1 /* ARC-specific support for 32-bit ELF 2 Copyright (C) 1994-2017 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 #include "opcode/arc.h" 30 #include "arc-plt.h" 31 32 /* #define ARC_ENABLE_DEBUG 1 */ 33 #ifdef ARC_ENABLE_DEBUG 34 static const char * 35 name_for_global_symbol (struct elf_link_hash_entry *h) 36 { 37 static char *local_str = "(local)"; 38 if (h == NULL) 39 return local_str; 40 return h->root.root.string; 41 } 42 #define ARC_DEBUG(fmt, args...) fprintf (stderr, fmt, ##args) 43 #else 44 #define ARC_DEBUG(...) 45 #endif 46 47 48 #define ADD_RELA(BFD, SECTION, OFFSET, SYM_IDX, TYPE, ADDEND) \ 49 { \ 50 struct elf_link_hash_table *_htab = elf_hash_table (info); \ 51 Elf_Internal_Rela _rel; \ 52 bfd_byte * _loc; \ 53 \ 54 BFD_ASSERT (_htab->srel##SECTION &&_htab->srel##SECTION->contents); \ 55 _loc = _htab->srel##SECTION->contents \ 56 + ((_htab->srel##SECTION->reloc_count) \ 57 * sizeof (Elf32_External_Rela)); \ 58 _htab->srel##SECTION->reloc_count++; \ 59 _rel.r_addend = ADDEND; \ 60 _rel.r_offset = (_htab->s##SECTION)->output_section->vma \ 61 + (_htab->s##SECTION)->output_offset + OFFSET; \ 62 BFD_ASSERT ((long) SYM_IDX != -1); \ 63 _rel.r_info = ELF32_R_INFO (SYM_IDX, TYPE); \ 64 bfd_elf32_swap_reloca_out (BFD, &_rel, _loc); \ 65 } 66 67 68 /* The default symbols representing the init and fini dyn values. 69 TODO: Check what is the relation of those strings with arclinux.em 70 and DT_INIT. */ 71 #define INIT_SYM_STRING "_init" 72 #define FINI_SYM_STRING "_fini" 73 74 char * init_str = INIT_SYM_STRING; 75 char * fini_str = FINI_SYM_STRING; 76 77 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \ 78 case VALUE: \ 79 return "R_" #TYPE; \ 80 break; 81 82 static ATTRIBUTE_UNUSED const char * 83 reloc_type_to_name (unsigned int type) 84 { 85 switch (type) 86 { 87 #include "elf/arc-reloc.def" 88 89 default: 90 return "UNKNOWN"; 91 break; 92 } 93 } 94 #undef ARC_RELOC_HOWTO 95 96 /* Try to minimize the amount of space occupied by relocation tables 97 on the ROM (not that the ROM won't be swamped by other ELF overhead). */ 98 99 #define USE_REL 1 100 101 static ATTRIBUTE_UNUSED bfd_boolean 102 is_reloc_PC_relative (reloc_howto_type *howto) 103 { 104 return (strstr (howto->name, "PC") != NULL) ? TRUE : FALSE; 105 } 106 107 static bfd_boolean 108 is_reloc_SDA_relative (reloc_howto_type *howto) 109 { 110 return (strstr (howto->name, "SDA") != NULL) ? TRUE : FALSE; 111 } 112 113 static bfd_boolean 114 is_reloc_for_GOT (reloc_howto_type * howto) 115 { 116 if (strstr (howto->name, "TLS") != NULL) 117 return FALSE; 118 return (strstr (howto->name, "GOT") != NULL) ? TRUE : FALSE; 119 } 120 121 static bfd_boolean 122 is_reloc_for_PLT (reloc_howto_type * howto) 123 { 124 return (strstr (howto->name, "PLT") != NULL) ? TRUE : FALSE; 125 } 126 127 static bfd_boolean 128 is_reloc_for_TLS (reloc_howto_type *howto) 129 { 130 return (strstr (howto->name, "TLS") != NULL) ? TRUE : FALSE; 131 } 132 133 struct arc_relocation_data 134 { 135 bfd_signed_vma reloc_offset; 136 bfd_signed_vma reloc_addend; 137 bfd_signed_vma got_offset_value; 138 139 bfd_signed_vma sym_value; 140 asection * sym_section; 141 142 reloc_howto_type *howto; 143 144 asection * input_section; 145 146 bfd_signed_vma sdata_begin_symbol_vma; 147 bfd_boolean sdata_begin_symbol_vma_set; 148 bfd_signed_vma got_symbol_vma; 149 150 bfd_boolean should_relocate; 151 152 const char * symbol_name; 153 }; 154 155 /* Should be included at this location due to static declarations 156 * defined before this point. */ 157 #include "arc-got.h" 158 159 #define arc_bfd_get_8(A,B,C) bfd_get_8(A,B) 160 #define arc_bfd_get_16(A,B,C) bfd_get_16(A,B) 161 #define arc_bfd_get_32(A,B,C) bfd_get_32(A,B) 162 #define arc_bfd_put_8(A,B,C,D) bfd_put_8(A,B,C) 163 #define arc_bfd_put_16(A,B,C,D) bfd_put_16(A,B,C) 164 #define arc_bfd_put_32(A,B,C,D) bfd_put_32(A,B,C) 165 166 167 static bfd_reloc_status_type 168 arc_elf_reloc (bfd *abfd ATTRIBUTE_UNUSED, 169 arelent *reloc_entry, 170 asymbol *symbol_in, 171 void *data ATTRIBUTE_UNUSED, 172 asection *input_section, 173 bfd *output_bfd, 174 char ** error_message ATTRIBUTE_UNUSED) 175 { 176 if (output_bfd != NULL) 177 { 178 reloc_entry->address += input_section->output_offset; 179 180 /* In case of relocateable link and if the reloc is against a 181 section symbol, the addend needs to be adjusted according to 182 where the section symbol winds up in the output section. */ 183 if ((symbol_in->flags & BSF_SECTION_SYM) && symbol_in->section) 184 reloc_entry->addend += symbol_in->section->output_offset; 185 186 return bfd_reloc_ok; 187 } 188 189 return bfd_reloc_continue; 190 } 191 192 193 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \ 194 TYPE = VALUE, 195 enum howto_list 196 { 197 #include "elf/arc-reloc.def" 198 HOWTO_LIST_LAST 199 }; 200 #undef ARC_RELOC_HOWTO 201 202 #define ARC_RELOC_HOWTO(TYPE, VALUE, RSIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \ 203 [TYPE] = HOWTO (R_##TYPE, 0, RSIZE, BITSIZE, FALSE, 0, \ 204 complain_overflow_##OVERFLOW, arc_elf_reloc, \ 205 "R_" #TYPE, FALSE, 0, 0, FALSE), 206 207 static struct reloc_howto_struct elf_arc_howto_table[] = 208 { 209 #include "elf/arc-reloc.def" 210 /* Example of what is generated by the preprocessor. Currently kept as an 211 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 elf_arc_howto_table[TYPE].dst_mask = RELOC_FUNCTION(0, ~0); \ 235 /* Only 32 bit data relocations should be marked as ME. */ \ 236 if (strstr (#FORMULA, " ME ") != NULL) \ 237 { \ 238 BFD_ASSERT (SIZE == 2); \ 239 } 240 241 #include "elf/arc-reloc.def" 242 243 } 244 #undef ARC_RELOC_HOWTO 245 246 247 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \ 248 [TYPE] = VALUE, 249 const int howto_table_lookup[] = 250 { 251 #include "elf/arc-reloc.def" 252 }; 253 #undef ARC_RELOC_HOWTO 254 255 static reloc_howto_type * 256 arc_elf_howto (unsigned int r_type) 257 { 258 if (elf_arc_howto_table[R_ARC_32].dst_mask == 0) 259 arc_elf_howto_init (); 260 return &elf_arc_howto_table[r_type]; 261 } 262 263 /* Map BFD reloc types to ARC ELF reloc types. */ 264 265 struct arc_reloc_map 266 { 267 bfd_reloc_code_real_type bfd_reloc_val; 268 unsigned char elf_reloc_val; 269 }; 270 271 /* ARC ELF linker hash entry. */ 272 struct elf_arc_link_hash_entry 273 { 274 struct elf_link_hash_entry root; 275 276 /* Track dynamic relocs copied for this symbol. */ 277 struct elf_dyn_relocs *dyn_relocs; 278 }; 279 280 /* ARC ELF linker hash table. */ 281 struct elf_arc_link_hash_table 282 { 283 struct elf_link_hash_table elf; 284 }; 285 286 static struct bfd_hash_entry * 287 elf_arc_link_hash_newfunc (struct bfd_hash_entry *entry, 288 struct bfd_hash_table *table, 289 const char *string) 290 { 291 /* Allocate the structure if it has not already been allocated by a 292 subclass. */ 293 if (entry == NULL) 294 { 295 entry = (struct bfd_hash_entry *) 296 bfd_hash_allocate (table, 297 sizeof (struct elf_arc_link_hash_entry)); 298 if (entry == NULL) 299 return entry; 300 } 301 302 /* Call the allocation method of the superclass. */ 303 entry = _bfd_elf_link_hash_newfunc (entry, table, string); 304 if (entry != NULL) 305 { 306 struct elf_arc_link_hash_entry *eh; 307 308 eh = (struct elf_arc_link_hash_entry *) entry; 309 eh->dyn_relocs = NULL; 310 } 311 312 return entry; 313 } 314 315 /* Destroy an ARC ELF linker hash table. */ 316 static void 317 elf_arc_link_hash_table_free (bfd *obfd) 318 { 319 _bfd_elf_link_hash_table_free (obfd); 320 } 321 322 /* Create an ARC ELF linker hash table. */ 323 324 static struct bfd_link_hash_table * 325 arc_elf_link_hash_table_create (bfd *abfd) 326 { 327 struct elf_arc_link_hash_table *ret; 328 329 ret = (struct elf_arc_link_hash_table *) bfd_zmalloc (sizeof (*ret)); 330 if (ret == NULL) 331 return NULL; 332 333 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd, 334 elf_arc_link_hash_newfunc, 335 sizeof (struct elf_arc_link_hash_entry), 336 ARC_ELF_DATA)) 337 { 338 free (ret); 339 return NULL; 340 } 341 342 ret->elf.init_got_refcount.refcount = 0; 343 ret->elf.init_got_refcount.glist = NULL; 344 ret->elf.init_got_offset.offset = 0; 345 ret->elf.init_got_offset.glist = NULL; 346 347 ret->elf.root.hash_table_free = elf_arc_link_hash_table_free; 348 349 return &ret->elf.root; 350 } 351 352 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \ 353 { BFD_RELOC_##TYPE, R_##TYPE }, 354 static const struct arc_reloc_map arc_reloc_map[] = 355 { 356 #include "elf/arc-reloc.def" 357 358 {BFD_RELOC_NONE, R_ARC_NONE}, 359 {BFD_RELOC_8, R_ARC_8}, 360 {BFD_RELOC_16, R_ARC_16}, 361 {BFD_RELOC_24, R_ARC_24}, 362 {BFD_RELOC_32, R_ARC_32}, 363 }; 364 #undef ARC_RELOC_HOWTO 365 366 typedef ATTRIBUTE_UNUSED bfd_vma (*replace_func) (unsigned, int ATTRIBUTE_UNUSED); 367 368 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \ 369 case TYPE: \ 370 func = (void *) RELOC_FUNCTION; \ 371 break; 372 static replace_func 373 get_replace_function (bfd *abfd, unsigned int r_type) 374 { 375 void *func = NULL; 376 377 switch (r_type) 378 { 379 #include "elf/arc-reloc.def" 380 } 381 382 if (func == replace_bits24 && bfd_big_endian (abfd)) 383 return (replace_func) replace_bits24_be; 384 385 return (replace_func) func; 386 } 387 #undef ARC_RELOC_HOWTO 388 389 static reloc_howto_type * 390 arc_elf32_bfd_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED, 391 bfd_reloc_code_real_type code) 392 { 393 unsigned int i; 394 395 for (i = ARRAY_SIZE (arc_reloc_map); i--;) 396 { 397 if (arc_reloc_map[i].bfd_reloc_val == code) 398 return arc_elf_howto (arc_reloc_map[i].elf_reloc_val); 399 } 400 401 return NULL; 402 } 403 404 /* Function to set the ELF flag bits. */ 405 static bfd_boolean 406 arc_elf_set_private_flags (bfd *abfd, flagword flags) 407 { 408 elf_elfheader (abfd)->e_flags = flags; 409 elf_flags_init (abfd) = TRUE; 410 return TRUE; 411 } 412 413 /* Print private flags. */ 414 static bfd_boolean 415 arc_elf_print_private_bfd_data (bfd *abfd, void * ptr) 416 { 417 FILE *file = (FILE *) ptr; 418 flagword flags; 419 420 BFD_ASSERT (abfd != NULL && ptr != NULL); 421 422 /* Print normal ELF private data. */ 423 _bfd_elf_print_private_bfd_data (abfd, ptr); 424 425 flags = elf_elfheader (abfd)->e_flags; 426 fprintf (file, _("private flags = 0x%lx:"), (unsigned long) flags); 427 428 switch (flags & EF_ARC_MACH_MSK) 429 { 430 case EF_ARC_CPU_ARCV2HS : fprintf (file, " -mcpu=ARCv2HS"); break; 431 case EF_ARC_CPU_ARCV2EM : fprintf (file, " -mcpu=ARCv2EM"); break; 432 case E_ARC_MACH_ARC600 : fprintf (file, " -mcpu=ARC600"); break; 433 case E_ARC_MACH_ARC601 : fprintf (file, " -mcpu=ARC601"); break; 434 case E_ARC_MACH_ARC700 : fprintf (file, " -mcpu=ARC700"); break; 435 default: 436 fprintf (file, "-mcpu=unknown"); 437 break; 438 } 439 440 switch (flags & EF_ARC_OSABI_MSK) 441 { 442 case E_ARC_OSABI_ORIG : fprintf (file, " (ABI:legacy)"); break; 443 case E_ARC_OSABI_V2 : fprintf (file, " (ABI:v2)"); break; 444 case E_ARC_OSABI_V3 : fprintf (file, " (ABI:v3)"); break; 445 default: 446 fprintf (file, "(ABI:unknown)"); 447 break; 448 } 449 450 fputc ('\n', file); 451 return TRUE; 452 } 453 454 /* Copy backend specific data from one object module to another. */ 455 456 static bfd_boolean 457 arc_elf_copy_private_bfd_data (bfd *ibfd, bfd *obfd) 458 { 459 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour 460 || bfd_get_flavour (obfd) != bfd_target_elf_flavour) 461 return TRUE; 462 463 BFD_ASSERT (!elf_flags_init (obfd) 464 || elf_elfheader (obfd)->e_flags == elf_elfheader (ibfd)->e_flags); 465 466 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags; 467 elf_flags_init (obfd) = TRUE; 468 469 /* Copy object attributes. */ 470 _bfd_elf_copy_obj_attributes (ibfd, obfd); 471 472 return _bfd_elf_copy_private_bfd_data (ibfd, obfd); 473 } 474 475 static reloc_howto_type * 476 bfd_elf32_bfd_reloc_name_lookup (bfd * abfd ATTRIBUTE_UNUSED, 477 const char *r_name) 478 { 479 unsigned int i; 480 481 for (i = 0; i < ARRAY_SIZE (elf_arc_howto_table); i++) 482 if (elf_arc_howto_table[i].name != NULL 483 && strcasecmp (elf_arc_howto_table[i].name, r_name) == 0) 484 return arc_elf_howto (i); 485 486 return NULL; 487 } 488 489 /* Set the howto pointer for an ARC ELF reloc. */ 490 491 static void 492 arc_info_to_howto_rel (bfd * abfd ATTRIBUTE_UNUSED, 493 arelent * cache_ptr, 494 Elf_Internal_Rela * dst) 495 { 496 unsigned int r_type; 497 498 r_type = ELF32_R_TYPE (dst->r_info); 499 BFD_ASSERT (r_type < (unsigned int) R_ARC_max); 500 cache_ptr->howto = arc_elf_howto (r_type); 501 } 502 503 /* Merge backend specific data from an object file to the output 504 object file when linking. */ 505 506 static bfd_boolean 507 arc_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info) 508 { 509 bfd *obfd = info->output_bfd; 510 unsigned short mach_ibfd; 511 static unsigned short mach_obfd = EM_NONE; 512 flagword out_flags; 513 flagword in_flags; 514 asection *sec; 515 516 /* Check if we have the same endianess. */ 517 if (! _bfd_generic_verify_endian_match (ibfd, info)) 518 return FALSE; 519 520 /* Collect ELF flags. */ 521 in_flags = elf_elfheader (ibfd)->e_flags & EF_ARC_MACH_MSK; 522 out_flags = elf_elfheader (obfd)->e_flags & EF_ARC_MACH_MSK; 523 524 if (!elf_flags_init (obfd)) /* First call, no flags set. */ 525 { 526 elf_flags_init (obfd) = TRUE; 527 out_flags = in_flags; 528 } 529 530 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour 531 || bfd_get_flavour (obfd) != bfd_target_elf_flavour) 532 return TRUE; 533 534 /* Check to see if the input BFD actually contains any sections. Do 535 not short-circuit dynamic objects; their section list may be 536 emptied by elf_link_add_object_symbols. */ 537 if (!(ibfd->flags & DYNAMIC)) 538 { 539 bfd_boolean null_input_bfd = TRUE; 540 bfd_boolean only_data_sections = TRUE; 541 542 for (sec = ibfd->sections; sec != NULL; sec = sec->next) 543 { 544 if ((bfd_get_section_flags (ibfd, sec) 545 & (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS)) 546 == (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS)) 547 only_data_sections = FALSE; 548 549 null_input_bfd = FALSE; 550 } 551 552 if (null_input_bfd || only_data_sections) 553 return TRUE; 554 } 555 556 /* Complain about various flag/architecture mismatches. */ 557 mach_ibfd = elf_elfheader (ibfd)->e_machine; 558 if (mach_obfd == EM_NONE) 559 { 560 mach_obfd = mach_ibfd; 561 } 562 else 563 { 564 if (mach_ibfd != mach_obfd) 565 { 566 /* xgettext:c-format */ 567 _bfd_error_handler (_("ERROR: Attempting to link %B " 568 "with a binary %B of different architecture"), 569 ibfd, obfd); 570 return FALSE; 571 } 572 else if (in_flags != out_flags) 573 { 574 /* Warn if different flags. */ 575 _bfd_error_handler 576 /* xgettext:c-format */ 577 (_("%B: uses different e_flags (0x%lx) fields than " 578 "previous modules (0x%lx)"), 579 ibfd, (long) in_flags, (long) out_flags); 580 if (in_flags && out_flags) 581 return FALSE; 582 /* MWDT doesnt set the eflags hence make sure we choose the 583 eflags set by gcc. */ 584 in_flags = in_flags > out_flags ? in_flags : out_flags; 585 } 586 } 587 588 /* Update the flags. */ 589 elf_elfheader (obfd)->e_flags = in_flags; 590 591 if (bfd_get_mach (obfd) < bfd_get_mach (ibfd)) 592 { 593 return bfd_set_arch_mach (obfd, bfd_arch_arc, bfd_get_mach (ibfd)); 594 } 595 596 return TRUE; 597 } 598 599 /* Set the right machine number for an ARC ELF file. */ 600 static bfd_boolean 601 arc_elf_object_p (bfd * abfd) 602 { 603 /* Make sure this is initialised, or you'll have the potential of passing 604 garbage---or misleading values---into the call to 605 bfd_default_set_arch_mach (). */ 606 int mach = bfd_mach_arc_arc700; 607 unsigned long arch = elf_elfheader (abfd)->e_flags & EF_ARC_MACH_MSK; 608 unsigned e_machine = elf_elfheader (abfd)->e_machine; 609 610 if (e_machine == EM_ARC_COMPACT || e_machine == EM_ARC_COMPACT2) 611 { 612 switch (arch) 613 { 614 case E_ARC_MACH_ARC600: 615 mach = bfd_mach_arc_arc600; 616 break; 617 case E_ARC_MACH_ARC601: 618 mach = bfd_mach_arc_arc601; 619 break; 620 case E_ARC_MACH_ARC700: 621 mach = bfd_mach_arc_arc700; 622 break; 623 case EF_ARC_CPU_ARCV2HS: 624 case EF_ARC_CPU_ARCV2EM: 625 mach = bfd_mach_arc_arcv2; 626 break; 627 default: 628 mach = (e_machine == EM_ARC_COMPACT) 629 ? bfd_mach_arc_arc700 : bfd_mach_arc_arcv2; 630 break; 631 } 632 } 633 else 634 { 635 if (e_machine == EM_ARC) 636 { 637 _bfd_error_handler 638 (_("Error: The ARC4 architecture is no longer supported.\n")); 639 return FALSE; 640 } 641 else 642 { 643 _bfd_error_handler 644 (_("Warning: unset or old architecture flags. \n" 645 " Use default machine.\n")); 646 } 647 } 648 649 return bfd_default_set_arch_mach (abfd, bfd_arch_arc, mach); 650 } 651 652 /* The final processing done just before writing out an ARC ELF object file. 653 This gets the ARC architecture right based on the machine number. */ 654 655 static void 656 arc_elf_final_write_processing (bfd * abfd, 657 bfd_boolean linker ATTRIBUTE_UNUSED) 658 { 659 unsigned long emf; 660 661 switch (bfd_get_mach (abfd)) 662 { 663 case bfd_mach_arc_arc600: 664 emf = EM_ARC_COMPACT; 665 break; 666 case bfd_mach_arc_arc601: 667 emf = EM_ARC_COMPACT; 668 break; 669 case bfd_mach_arc_arc700: 670 emf = EM_ARC_COMPACT; 671 break; 672 case bfd_mach_arc_arcv2: 673 emf = EM_ARC_COMPACT2; 674 break; 675 default: 676 goto DO_NOTHING; 677 } 678 679 elf_elfheader (abfd)->e_machine = emf; 680 681 /* Record whatever is the current syscall ABI version. */ 682 elf_elfheader (abfd)->e_flags |= E_ARC_OSABI_CURRENT; 683 684 DO_NOTHING: 685 return; 686 } 687 688 #ifdef ARC_ENABLE_DEBUG 689 #define DEBUG_ARC_RELOC(A) debug_arc_reloc (A) 690 691 static void 692 debug_arc_reloc (struct arc_relocation_data reloc_data) 693 { 694 ARC_DEBUG ("Reloc type=%s, should_relocate = %s\n", 695 reloc_data.howto->name, 696 reloc_data.should_relocate ? "true" : "false"); 697 ARC_DEBUG (" offset = 0x%x, addend = 0x%x\n", 698 (unsigned int) reloc_data.reloc_offset, 699 (unsigned int) reloc_data.reloc_addend); 700 ARC_DEBUG (" Symbol:\n"); 701 ARC_DEBUG (" value = 0x%08x\n", 702 (unsigned int) reloc_data.sym_value); 703 if (reloc_data.sym_section != NULL) 704 { 705 ARC_DEBUG (" Symbol Section:\n"); 706 ARC_DEBUG (" section name = %s, output_offset 0x%08x", 707 reloc_data.sym_section->name, 708 (unsigned int) reloc_data.sym_section->output_offset); 709 if (reloc_data.sym_section->output_section != NULL) 710 ARC_DEBUG (", output_section->vma = 0x%08x", 711 ((unsigned int) reloc_data.sym_section->output_section->vma)); 712 ARC_DEBUG ("\n"); 713 if (reloc_data.sym_section->owner && reloc_data.sym_section->owner->filename) 714 ARC_DEBUG (" file: %s\n", reloc_data.sym_section->owner->filename); 715 } 716 else 717 { 718 ARC_DEBUG (" symbol section is NULL\n"); 719 } 720 721 ARC_DEBUG (" Input_section:\n"); 722 if (reloc_data.input_section != NULL) 723 { 724 ARC_DEBUG (" section name = %s, output_offset 0x%08x, output_section->vma = 0x%08x\n", 725 reloc_data.input_section->name, 726 (unsigned int) reloc_data.input_section->output_offset, 727 (unsigned int) reloc_data.input_section->output_section->vma); 728 ARC_DEBUG (" changed_address = 0x%08x\n", 729 (unsigned int) (reloc_data.input_section->output_section->vma 730 + reloc_data.input_section->output_offset 731 + reloc_data.reloc_offset)); 732 ARC_DEBUG (" file: %s\n", reloc_data.input_section->owner->filename); 733 } 734 else 735 { 736 ARC_DEBUG (" input section is NULL\n"); 737 } 738 } 739 #else 740 #define DEBUG_ARC_RELOC(A) 741 #endif /* ARC_ENABLE_DEBUG */ 742 743 static bfd_vma 744 middle_endian_convert (bfd_vma insn, bfd_boolean do_it) 745 { 746 if (do_it) 747 { 748 insn 749 = ((insn & 0xffff0000) >> 16) 750 | ((insn & 0xffff) << 16); 751 } 752 return insn; 753 } 754 755 /* This function is called for relocations that are otherwise marked as NOT 756 requiring overflow checks. In here we perform non-standard checks of 757 the relocation value. */ 758 759 static inline bfd_reloc_status_type 760 arc_special_overflow_checks (const struct arc_relocation_data reloc_data, 761 bfd_signed_vma relocation, 762 struct bfd_link_info *info ATTRIBUTE_UNUSED) 763 { 764 switch (reloc_data.howto->type) 765 { 766 case R_ARC_NPS_CMEM16: 767 if (((relocation >> 16) & 0xffff) != NPS_CMEM_HIGH_VALUE) 768 { 769 if (reloc_data.reloc_addend == 0) 770 _bfd_error_handler 771 /* xgettext:c-format */ 772 (_("%B(%A+0x%lx): CMEM relocation to `%s' is invalid, " 773 "16 MSB should be 0x%04x (value is 0x%lx)"), 774 reloc_data.input_section->owner, 775 reloc_data.input_section, 776 reloc_data.reloc_offset, 777 reloc_data.symbol_name, 778 NPS_CMEM_HIGH_VALUE, 779 (relocation)); 780 else 781 _bfd_error_handler 782 /* xgettext:c-format */ 783 (_("%B(%A+0x%lx): CMEM relocation to `%s+0x%lx' is invalid, " 784 "16 MSB should be 0x%04x (value is 0x%lx)"), 785 reloc_data.input_section->owner, 786 reloc_data.input_section, 787 reloc_data.reloc_offset, 788 reloc_data.symbol_name, 789 reloc_data.reloc_addend, 790 NPS_CMEM_HIGH_VALUE, 791 (relocation)); 792 return bfd_reloc_overflow; 793 } 794 break; 795 796 default: 797 break; 798 } 799 800 return bfd_reloc_ok; 801 } 802 803 #define ME(reloc) (reloc) 804 805 #define IS_ME(FORMULA,BFD) ((strstr (FORMULA, "ME") != NULL) \ 806 && (!bfd_big_endian (BFD))) 807 808 #define S ((bfd_signed_vma) (reloc_data.sym_value \ 809 + (reloc_data.sym_section->output_section != NULL ? \ 810 (reloc_data.sym_section->output_offset \ 811 + reloc_data.sym_section->output_section->vma) : 0))) 812 #define L ((bfd_signed_vma) (reloc_data.sym_value \ 813 + (reloc_data.sym_section->output_section != NULL ? \ 814 (reloc_data.sym_section->output_offset \ 815 + reloc_data.sym_section->output_section->vma) : 0))) 816 #define A (reloc_data.reloc_addend) 817 #define B (0) 818 #define G (reloc_data.got_offset_value) 819 #define GOT (reloc_data.got_symbol_vma) 820 #define GOT_BEGIN (htab->sgot->output_section->vma) 821 822 #define MES (0) 823 /* P: relative offset to PCL The offset should be to the 824 current location aligned to 32 bits. */ 825 #define P ((bfd_signed_vma) ( \ 826 ( \ 827 (reloc_data.input_section->output_section != NULL ? \ 828 reloc_data.input_section->output_section->vma : 0) \ 829 + reloc_data.input_section->output_offset \ 830 + (reloc_data.reloc_offset - (bitsize >= 32 ? 4 : 0))) \ 831 & ~0x3)) 832 #define PDATA ((bfd_signed_vma) ( \ 833 (reloc_data.input_section->output_section->vma \ 834 + reloc_data.input_section->output_offset \ 835 + (reloc_data.reloc_offset)))) 836 #define SECTSTART (bfd_signed_vma) (reloc_data.sym_section->output_section->vma \ 837 + reloc_data.sym_section->output_offset) 838 839 #define _SDA_BASE_ (bfd_signed_vma) (reloc_data.sdata_begin_symbol_vma) 840 #define TLS_REL (bfd_signed_vma) \ 841 ((elf_hash_table (info))->tls_sec->output_section->vma) 842 #define TLS_TBSS (8) 843 #define TCB_SIZE (8) 844 845 #define none (0) 846 847 #ifdef ARC_ENABLE_DEBUG 848 #define PRINT_DEBUG_RELOC_INFO_BEFORE(FORMULA, TYPE) \ 849 do \ 850 { \ 851 asection *sym_section = reloc_data.sym_section; \ 852 asection *input_section = reloc_data.input_section; \ 853 ARC_DEBUG ("RELOC_TYPE = " TYPE "\n"); \ 854 ARC_DEBUG ("FORMULA = " FORMULA "\n"); \ 855 ARC_DEBUG ("S = %#lx\n", S); \ 856 ARC_DEBUG ("A = %#lx\n", A); \ 857 ARC_DEBUG ("L = %lx\n", L); \ 858 if (sym_section->output_section != NULL) \ 859 ARC_DEBUG ("symbol_section->vma = %#lx\n", \ 860 sym_section->output_section->vma \ 861 + sym_section->output_offset); \ 862 else \ 863 ARC_DEBUG ("symbol_section->vma = NULL\n"); \ 864 if (input_section->output_section != NULL) \ 865 ARC_DEBUG ("symbol_section->vma = %#lx\n", \ 866 input_section->output_section->vma \ 867 + input_section->output_offset); \ 868 else \ 869 ARC_DEBUG ("symbol_section->vma = NULL\n"); \ 870 ARC_DEBUG ("PCL = %#lx\n", P); \ 871 ARC_DEBUG ("P = %#lx\n", P); \ 872 ARC_DEBUG ("G = %#lx\n", G); \ 873 ARC_DEBUG ("SDA_OFFSET = %#lx\n", _SDA_BASE_); \ 874 ARC_DEBUG ("SDA_SET = %d\n", reloc_data.sdata_begin_symbol_vma_set); \ 875 ARC_DEBUG ("GOT_OFFSET = %#lx\n", GOT); \ 876 ARC_DEBUG ("relocation = %#08lx\n", relocation); \ 877 ARC_DEBUG ("before = %#08x\n", (unsigned) insn); \ 878 ARC_DEBUG ("data = %08x (%u) (%d)\n", (unsigned) relocation, \ 879 (unsigned) relocation, (int) relocation); \ 880 } \ 881 while (0) 882 883 #define PRINT_DEBUG_RELOC_INFO_AFTER \ 884 do \ 885 { \ 886 ARC_DEBUG ("after = 0x%08x\n", (unsigned int) insn); \ 887 } \ 888 while (0) 889 890 #else 891 892 #define PRINT_DEBUG_RELOC_INFO_BEFORE(...) 893 #define PRINT_DEBUG_RELOC_INFO_AFTER 894 895 #endif /* ARC_ENABLE_DEBUG */ 896 897 #define ARC_RELOC_HOWTO(TYPE, VALUE, SIZE, BITSIZE, RELOC_FUNCTION, OVERFLOW, FORMULA) \ 898 case R_##TYPE: \ 899 { \ 900 bfd_signed_vma bitsize ATTRIBUTE_UNUSED = BITSIZE; \ 901 relocation = FORMULA ; \ 902 PRINT_DEBUG_RELOC_INFO_BEFORE (#FORMULA, #TYPE); \ 903 insn = middle_endian_convert (insn, IS_ME (#FORMULA, abfd)); \ 904 insn = (* get_replace_function (abfd, TYPE)) (insn, relocation); \ 905 insn = middle_endian_convert (insn, IS_ME (#FORMULA, abfd)); \ 906 PRINT_DEBUG_RELOC_INFO_AFTER; \ 907 } \ 908 break; 909 910 static bfd_reloc_status_type 911 arc_do_relocation (bfd_byte * contents, 912 struct arc_relocation_data reloc_data, 913 struct bfd_link_info *info) 914 { 915 bfd_signed_vma relocation = 0; 916 bfd_vma insn; 917 bfd_vma orig_insn ATTRIBUTE_UNUSED; 918 bfd * abfd = reloc_data.input_section->owner; 919 struct elf_link_hash_table *htab ATTRIBUTE_UNUSED = elf_hash_table (info); 920 bfd_reloc_status_type flag; 921 922 if (reloc_data.should_relocate == FALSE) 923 return bfd_reloc_ok; 924 925 switch (reloc_data.howto->size) 926 { 927 case 2: 928 insn = arc_bfd_get_32 (abfd, 929 contents + reloc_data.reloc_offset, 930 reloc_data.input_section); 931 break; 932 case 1: 933 insn = arc_bfd_get_16 (abfd, 934 contents + reloc_data.reloc_offset, 935 reloc_data.input_section); 936 break; 937 case 0: 938 insn = arc_bfd_get_8 (abfd, 939 contents + reloc_data.reloc_offset, 940 reloc_data.input_section); 941 break; 942 default: 943 insn = 0; 944 BFD_ASSERT (0); 945 break; 946 } 947 948 orig_insn = insn; 949 950 switch (reloc_data.howto->type) 951 { 952 #include "elf/arc-reloc.def" 953 954 default: 955 BFD_ASSERT (0); 956 break; 957 } 958 959 /* Check for relocation overflow. */ 960 if (reloc_data.howto->complain_on_overflow != complain_overflow_dont) 961 flag = bfd_check_overflow (reloc_data.howto->complain_on_overflow, 962 reloc_data.howto->bitsize, 963 reloc_data.howto->rightshift, 964 bfd_arch_bits_per_address (abfd), 965 relocation); 966 else 967 flag = arc_special_overflow_checks (reloc_data, relocation, info); 968 969 if (flag != bfd_reloc_ok) 970 { 971 ARC_DEBUG ("Relocation overflows !\n"); 972 DEBUG_ARC_RELOC (reloc_data); 973 ARC_DEBUG ("Relocation value = signed -> %d, unsigned -> %u" 974 ", hex -> (0x%08x)\n", 975 (int) relocation, (unsigned) relocation, (int) relocation); 976 977 return flag; 978 } 979 980 /* Write updated instruction back to memory. */ 981 switch (reloc_data.howto->size) 982 { 983 case 2: 984 arc_bfd_put_32 (abfd, insn, 985 contents + reloc_data.reloc_offset, 986 reloc_data.input_section); 987 break; 988 case 1: 989 arc_bfd_put_16 (abfd, insn, 990 contents + reloc_data.reloc_offset, 991 reloc_data.input_section); 992 break; 993 case 0: 994 arc_bfd_put_8 (abfd, insn, 995 contents + reloc_data.reloc_offset, 996 reloc_data.input_section); 997 break; 998 default: 999 ARC_DEBUG ("size = %d\n", reloc_data.howto->size); 1000 BFD_ASSERT (0); 1001 break; 1002 } 1003 1004 return bfd_reloc_ok; 1005 } 1006 #undef S 1007 #undef A 1008 #undef B 1009 #undef G 1010 #undef GOT 1011 #undef L 1012 #undef MES 1013 #undef P 1014 #undef SECTSTAR 1015 #undef SECTSTART 1016 #undef _SDA_BASE_ 1017 #undef none 1018 1019 #undef ARC_RELOC_HOWTO 1020 1021 1022 /* Relocate an arc ELF section. 1023 Function : elf_arc_relocate_section 1024 Brief : Relocate an arc section, by handling all the relocations 1025 appearing in that section. 1026 Args : output_bfd : The bfd being written to. 1027 info : Link information. 1028 input_bfd : The input bfd. 1029 input_section : The section being relocated. 1030 contents : contents of the section being relocated. 1031 relocs : List of relocations in the section. 1032 local_syms : is a pointer to the swapped in local symbols. 1033 local_section : is an array giving the section in the input file 1034 corresponding to the st_shndx field of each 1035 local symbol. */ 1036 static bfd_boolean 1037 elf_arc_relocate_section (bfd * output_bfd, 1038 struct bfd_link_info * info, 1039 bfd * input_bfd, 1040 asection * input_section, 1041 bfd_byte * contents, 1042 Elf_Internal_Rela * relocs, 1043 Elf_Internal_Sym * local_syms, 1044 asection ** local_sections) 1045 { 1046 Elf_Internal_Shdr * symtab_hdr; 1047 struct elf_link_hash_entry ** sym_hashes; 1048 Elf_Internal_Rela * rel; 1049 Elf_Internal_Rela * wrel; 1050 Elf_Internal_Rela * relend; 1051 struct elf_link_hash_table * htab = elf_hash_table (info); 1052 1053 symtab_hdr = &((elf_tdata (input_bfd))->symtab_hdr); 1054 sym_hashes = elf_sym_hashes (input_bfd); 1055 1056 rel = wrel = relocs; 1057 relend = relocs + input_section->reloc_count; 1058 for (; rel < relend; wrel++, rel++) 1059 { 1060 enum elf_arc_reloc_type r_type; 1061 reloc_howto_type * howto; 1062 unsigned long r_symndx; 1063 struct elf_link_hash_entry * h; 1064 Elf_Internal_Sym * sym; 1065 asection * sec; 1066 struct elf_link_hash_entry * h2; 1067 const char * msg; 1068 1069 struct arc_relocation_data reloc_data = 1070 { 1071 .reloc_offset = 0, 1072 .reloc_addend = 0, 1073 .got_offset_value = 0, 1074 .sym_value = 0, 1075 .sym_section = NULL, 1076 .howto = NULL, 1077 .input_section = NULL, 1078 .sdata_begin_symbol_vma = 0, 1079 .sdata_begin_symbol_vma_set = FALSE, 1080 .got_symbol_vma = 0, 1081 .should_relocate = FALSE 1082 }; 1083 1084 r_type = ELF32_R_TYPE (rel->r_info); 1085 1086 if (r_type >= (int) R_ARC_max) 1087 { 1088 bfd_set_error (bfd_error_bad_value); 1089 return FALSE; 1090 } 1091 howto = arc_elf_howto (r_type); 1092 1093 r_symndx = ELF32_R_SYM (rel->r_info); 1094 1095 /* If we are generating another .o file and the symbol in not 1096 local, skip this relocation. */ 1097 if (bfd_link_relocatable (info)) 1098 { 1099 /* This is a relocateable link. We don't have to change 1100 anything, unless the reloc is against a section symbol, 1101 in which case we have to adjust according to where the 1102 section symbol winds up in the output section. */ 1103 1104 /* Checks if this is a local symbol and thus the reloc 1105 might (will??) be against a section symbol. */ 1106 if (r_symndx < symtab_hdr->sh_info) 1107 { 1108 sym = local_syms + r_symndx; 1109 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION) 1110 { 1111 sec = local_sections[r_symndx]; 1112 1113 /* For RELA relocs. Just adjust the addend 1114 value in the relocation entry. */ 1115 rel->r_addend += sec->output_offset + sym->st_value; 1116 1117 ARC_DEBUG ("local symbols reloc (section=%d %s) seen in %s\n", 1118 (int) r_symndx, local_sections[r_symndx]->name, 1119 __PRETTY_FUNCTION__); 1120 } 1121 } 1122 } 1123 1124 h2 = elf_link_hash_lookup (elf_hash_table (info), "__SDATA_BEGIN__", 1125 FALSE, FALSE, TRUE); 1126 1127 if (reloc_data.sdata_begin_symbol_vma_set == FALSE 1128 && h2 != NULL && h2->root.type != bfd_link_hash_undefined 1129 && h2->root.u.def.section->output_section != NULL) 1130 /* TODO: Verify this condition. */ 1131 { 1132 reloc_data.sdata_begin_symbol_vma = 1133 (h2->root.u.def.value 1134 + h2->root.u.def.section->output_section->vma); 1135 reloc_data.sdata_begin_symbol_vma_set = TRUE; 1136 } 1137 1138 reloc_data.input_section = input_section; 1139 reloc_data.howto = howto; 1140 reloc_data.reloc_offset = rel->r_offset; 1141 reloc_data.reloc_addend = rel->r_addend; 1142 1143 /* This is a final link. */ 1144 h = NULL; 1145 sym = NULL; 1146 sec = NULL; 1147 1148 if (r_symndx < symtab_hdr->sh_info) /* A local symbol. */ 1149 { 1150 sym = local_syms + r_symndx; 1151 sec = local_sections[r_symndx]; 1152 } 1153 else 1154 { 1155 /* TODO: This code is repeated from below. We should 1156 clean it and remove duplications. 1157 Sec is used check for discarded sections. 1158 Need to redesign code below. */ 1159 1160 /* Get the symbol's entry in the symtab. */ 1161 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 1162 1163 while (h->root.type == bfd_link_hash_indirect 1164 || h->root.type == bfd_link_hash_warning) 1165 h = (struct elf_link_hash_entry *) h->root.u.i.link; 1166 1167 /* If we have encountered a definition for this symbol. */ 1168 if (h->root.type == bfd_link_hash_defined 1169 || h->root.type == bfd_link_hash_defweak) 1170 { 1171 reloc_data.sym_value = h->root.u.def.value; 1172 sec = h->root.u.def.section; 1173 } 1174 } 1175 1176 /* Clean relocs for symbols in discarded sections. */ 1177 if (sec != NULL && discarded_section (sec)) 1178 { 1179 _bfd_clear_contents (howto, input_bfd, input_section, 1180 contents + rel->r_offset); 1181 rel->r_offset = rel->r_offset; 1182 rel->r_info = 0; 1183 rel->r_addend = 0; 1184 1185 /* For ld -r, remove relocations in debug sections against 1186 sections defined in discarded sections. Not done for 1187 eh_frame editing code expects to be present. */ 1188 if (bfd_link_relocatable (info) 1189 && (input_section->flags & SEC_DEBUGGING)) 1190 wrel--; 1191 1192 continue; 1193 } 1194 1195 if (bfd_link_relocatable (info)) 1196 { 1197 if (wrel != rel) 1198 *wrel = *rel; 1199 continue; 1200 } 1201 1202 if (r_symndx < symtab_hdr->sh_info) /* A local symbol. */ 1203 { 1204 reloc_data.sym_value = sym->st_value; 1205 reloc_data.sym_section = sec; 1206 reloc_data.symbol_name = 1207 bfd_elf_string_from_elf_section (input_bfd, 1208 symtab_hdr->sh_link, 1209 sym->st_name); 1210 1211 /* Mergeable section handling. */ 1212 if ((sec->flags & SEC_MERGE) 1213 && ELF_ST_TYPE (sym->st_info) == STT_SECTION) 1214 { 1215 asection *msec; 1216 msec = sec; 1217 rel->r_addend = _bfd_elf_rel_local_sym (output_bfd, sym, 1218 &msec, rel->r_addend); 1219 rel->r_addend -= (sec->output_section->vma 1220 + sec->output_offset 1221 + sym->st_value); 1222 rel->r_addend += msec->output_section->vma + msec->output_offset; 1223 1224 reloc_data.reloc_addend = rel->r_addend; 1225 } 1226 1227 BFD_ASSERT (htab->sgot != NULL || !is_reloc_for_GOT (howto)); 1228 if (htab->sgot != NULL) 1229 reloc_data.got_symbol_vma = htab->sgot->output_section->vma 1230 + htab->sgot->output_offset; 1231 1232 reloc_data.should_relocate = TRUE; 1233 } 1234 else /* Global symbol. */ 1235 { 1236 /* FIXME: We should use the RELOC_FOR_GLOBAL_SYMBOL macro 1237 (defined in elf-bfd.h) here. */ 1238 1239 /* Get the symbol's entry in the symtab. */ 1240 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 1241 1242 while (h->root.type == bfd_link_hash_indirect 1243 || h->root.type == bfd_link_hash_warning) 1244 h = (struct elf_link_hash_entry *) h->root.u.i.link; 1245 1246 /* TODO: Need to validate what was the intention. */ 1247 /* BFD_ASSERT ((h->dynindx == -1) || (h->forced_local != 0)); */ 1248 reloc_data.symbol_name = h->root.root.string; 1249 1250 /* If we have encountered a definition for this symbol. */ 1251 if (h->root.type == bfd_link_hash_defined 1252 || h->root.type == bfd_link_hash_defweak) 1253 { 1254 reloc_data.sym_value = h->root.u.def.value; 1255 reloc_data.sym_section = h->root.u.def.section; 1256 1257 reloc_data.should_relocate = TRUE; 1258 1259 if (is_reloc_for_GOT (howto) && !bfd_link_pic (info)) 1260 { 1261 /* TODO: Change it to use arc_do_relocation with 1262 ARC_32 reloc. Try to use ADD_RELA macro. */ 1263 bfd_vma relocation = 1264 reloc_data.sym_value + reloc_data.reloc_addend 1265 + (reloc_data.sym_section->output_section != NULL ? 1266 (reloc_data.sym_section->output_offset 1267 + reloc_data.sym_section->output_section->vma) 1268 : 0); 1269 1270 BFD_ASSERT (h->got.glist); 1271 bfd_vma got_offset = h->got.glist->offset; 1272 bfd_put_32 (output_bfd, relocation, 1273 htab->sgot->contents + got_offset); 1274 } 1275 if (is_reloc_for_PLT (howto) && h->plt.offset != (bfd_vma) -1) 1276 { 1277 /* TODO: This is repeated up here. */ 1278 reloc_data.sym_value = h->plt.offset; 1279 reloc_data.sym_section = htab->splt; 1280 } 1281 } 1282 else if (h->root.type == bfd_link_hash_undefweak) 1283 { 1284 /* Is weak symbol and has no definition. */ 1285 if (is_reloc_for_GOT (howto)) 1286 { 1287 reloc_data.sym_value = h->root.u.def.value; 1288 reloc_data.sym_section = htab->sgot; 1289 reloc_data.should_relocate = TRUE; 1290 } 1291 else if (is_reloc_for_PLT (howto) 1292 && h->plt.offset != (bfd_vma) -1) 1293 { 1294 /* TODO: This is repeated up here. */ 1295 reloc_data.sym_value = h->plt.offset; 1296 reloc_data.sym_section = htab->splt; 1297 reloc_data.should_relocate = TRUE; 1298 } 1299 else 1300 continue; 1301 } 1302 else 1303 { 1304 if (is_reloc_for_GOT (howto)) 1305 { 1306 reloc_data.sym_value = h->root.u.def.value; 1307 reloc_data.sym_section = htab->sgot; 1308 1309 reloc_data.should_relocate = TRUE; 1310 } 1311 else if (is_reloc_for_PLT (howto)) 1312 { 1313 /* Fail if it is linking for PIE and the symbol is 1314 undefined. */ 1315 if (bfd_link_executable (info)) 1316 (*info->callbacks->undefined_symbol) 1317 (info, h->root.root.string, input_bfd, input_section, 1318 rel->r_offset, TRUE); 1319 reloc_data.sym_value = h->plt.offset; 1320 reloc_data.sym_section = htab->splt; 1321 1322 reloc_data.should_relocate = TRUE; 1323 } 1324 else if (!bfd_link_pic (info) || bfd_link_executable (info)) 1325 (*info->callbacks->undefined_symbol) 1326 (info, h->root.root.string, input_bfd, input_section, 1327 rel->r_offset, TRUE); 1328 } 1329 1330 BFD_ASSERT (htab->sgot != NULL || !is_reloc_for_GOT (howto)); 1331 if (htab->sgot != NULL) 1332 reloc_data.got_symbol_vma = htab->sgot->output_section->vma 1333 + htab->sgot->output_offset; 1334 } 1335 1336 if ((is_reloc_for_GOT (howto) 1337 || is_reloc_for_TLS (howto))) 1338 { 1339 reloc_data.should_relocate = TRUE; 1340 1341 struct got_entry **list 1342 = get_got_entry_list_for_symbol (output_bfd, r_symndx, h); 1343 1344 reloc_data.got_offset_value 1345 = relocate_fix_got_relocs_for_got_info (list, 1346 tls_type_for_reloc (howto), 1347 info, 1348 output_bfd, 1349 r_symndx, 1350 local_syms, 1351 local_sections, 1352 h, 1353 &reloc_data); 1354 1355 if (h == NULL) 1356 { 1357 create_got_dynrelocs_for_single_entry ( 1358 got_entry_for_type (list, 1359 arc_got_entry_type_for_reloc (howto)), 1360 output_bfd, info, NULL); 1361 } 1362 } 1363 1364 switch (r_type) 1365 { 1366 case R_ARC_32: 1367 case R_ARC_32_ME: 1368 case R_ARC_PC32: 1369 case R_ARC_32_PCREL: 1370 if ((bfd_link_pic (info)) 1371 && ((r_type != R_ARC_PC32 && r_type != R_ARC_32_PCREL) 1372 || (h != NULL 1373 && h->dynindx != -1 1374 && (!info->symbolic || !h->def_regular)))) 1375 { 1376 Elf_Internal_Rela outrel; 1377 bfd_byte *loc; 1378 bfd_boolean skip = FALSE; 1379 bfd_boolean relocate = FALSE; 1380 asection *sreloc = _bfd_elf_get_dynamic_reloc_section 1381 (input_bfd, input_section, 1382 /*RELA*/ TRUE); 1383 1384 BFD_ASSERT (sreloc != NULL); 1385 1386 outrel.r_offset = _bfd_elf_section_offset (output_bfd, 1387 info, 1388 input_section, 1389 rel->r_offset); 1390 if (outrel.r_offset == (bfd_vma) -1) 1391 skip = TRUE; 1392 1393 outrel.r_addend = rel->r_addend; 1394 outrel.r_offset += (input_section->output_section->vma 1395 + input_section->output_offset); 1396 1397 #define IS_ARC_PCREL_TYPE(TYPE) \ 1398 ( (TYPE == R_ARC_PC32) \ 1399 || (TYPE == R_ARC_32_PCREL)) 1400 1401 if (skip) 1402 { 1403 memset (&outrel, 0, sizeof outrel); 1404 relocate = FALSE; 1405 } 1406 else if (h != NULL 1407 && h->dynindx != -1 1408 && ((IS_ARC_PCREL_TYPE (r_type)) 1409 || !(bfd_link_executable (info) 1410 || SYMBOLIC_BIND (info, h)) 1411 || ! h->def_regular)) 1412 { 1413 BFD_ASSERT (h != NULL); 1414 if ((input_section->flags & SEC_ALLOC) != 0) 1415 relocate = FALSE; 1416 else 1417 relocate = TRUE; 1418 1419 BFD_ASSERT (h->dynindx != -1); 1420 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type); 1421 } 1422 else 1423 { 1424 /* Handle local symbols, they either do not have a 1425 global hash table entry (h == NULL), or are 1426 forced local due to a version script 1427 (h->forced_local), or the third condition is 1428 legacy, it appears to say something like, for 1429 links where we are pre-binding the symbols, or 1430 there's not an entry for this symbol in the 1431 dynamic symbol table, and it's a regular symbol 1432 not defined in a shared object, then treat the 1433 symbol as local, resolve it now. */ 1434 relocate = TRUE; 1435 /* outrel.r_addend = 0; */ 1436 outrel.r_info = ELF32_R_INFO (0, R_ARC_RELATIVE); 1437 } 1438 1439 BFD_ASSERT (sreloc->contents != 0); 1440 1441 loc = sreloc->contents; 1442 loc += sreloc->reloc_count * sizeof (Elf32_External_Rela); 1443 sreloc->reloc_count += 1; 1444 1445 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc); 1446 1447 if (relocate == FALSE) 1448 continue; 1449 } 1450 break; 1451 default: 1452 break; 1453 } 1454 1455 if (is_reloc_SDA_relative (howto) 1456 && (reloc_data.sdata_begin_symbol_vma_set == FALSE)) 1457 { 1458 _bfd_error_handler 1459 ("Error: Linker symbol __SDATA_BEGIN__ not found"); 1460 bfd_set_error (bfd_error_bad_value); 1461 return FALSE; 1462 } 1463 1464 DEBUG_ARC_RELOC (reloc_data); 1465 1466 /* Make sure we have with a dynamic linker. In case of GOT and PLT 1467 the sym_section should point to .got or .plt respectively. */ 1468 if ((is_reloc_for_GOT (howto) || is_reloc_for_PLT (howto)) 1469 && reloc_data.sym_section == NULL) 1470 { 1471 _bfd_error_handler 1472 (_("GOT and PLT relocations cannot be fixed with a non dynamic linker.")); 1473 bfd_set_error (bfd_error_bad_value); 1474 return FALSE; 1475 } 1476 1477 msg = NULL; 1478 switch (arc_do_relocation (contents, reloc_data, info)) 1479 { 1480 case bfd_reloc_ok: 1481 continue; /* The reloc processing loop. */ 1482 1483 case bfd_reloc_overflow: 1484 (*info->callbacks->reloc_overflow) 1485 (info, (h ? &h->root : NULL), reloc_data.symbol_name, howto->name, (bfd_vma) 0, 1486 input_bfd, input_section, rel->r_offset); 1487 break; 1488 1489 case bfd_reloc_undefined: 1490 (*info->callbacks->undefined_symbol) 1491 (info, reloc_data.symbol_name, input_bfd, input_section, rel->r_offset, TRUE); 1492 break; 1493 1494 case bfd_reloc_other: 1495 /* xgettext:c-format */ 1496 msg = _("%B(%A): warning: unaligned access to symbol '%s' in the small data area"); 1497 break; 1498 1499 case bfd_reloc_outofrange: 1500 /* xgettext:c-format */ 1501 msg = _("%B(%A): internal error: out of range error"); 1502 break; 1503 1504 case bfd_reloc_notsupported: 1505 /* xgettext:c-format */ 1506 msg = _("%B(%A): internal error: unsupported relocation error"); 1507 break; 1508 1509 case bfd_reloc_dangerous: 1510 /* xgettext:c-format */ 1511 msg = _("%B(%A): internal error: dangerous relocation"); 1512 break; 1513 1514 default: 1515 /* xgettext:c-format */ 1516 msg = _("%B(%A): internal error: unknown error"); 1517 break; 1518 } 1519 1520 if (msg) 1521 _bfd_error_handler (msg, input_bfd, input_section, reloc_data.symbol_name); 1522 return FALSE; 1523 } 1524 1525 return TRUE; 1526 } 1527 1528 #define elf_arc_hash_table(p) \ 1529 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \ 1530 == ARC_ELF_DATA ? ((struct elf_arc_link_hash_table *) ((p)->hash)) : NULL) 1531 1532 static bfd_boolean 1533 elf_arc_check_relocs (bfd * abfd, 1534 struct bfd_link_info * info, 1535 asection * sec, 1536 const Elf_Internal_Rela * relocs) 1537 { 1538 Elf_Internal_Shdr * symtab_hdr; 1539 struct elf_link_hash_entry ** sym_hashes; 1540 const Elf_Internal_Rela * rel; 1541 const Elf_Internal_Rela * rel_end; 1542 bfd * dynobj; 1543 asection * sreloc = NULL; 1544 1545 if (bfd_link_relocatable (info)) 1546 return TRUE; 1547 1548 dynobj = (elf_hash_table (info))->dynobj; 1549 symtab_hdr = &((elf_tdata (abfd))->symtab_hdr); 1550 sym_hashes = elf_sym_hashes (abfd); 1551 1552 rel_end = relocs + sec->reloc_count; 1553 for (rel = relocs; rel < rel_end; rel++) 1554 { 1555 enum elf_arc_reloc_type r_type; 1556 reloc_howto_type *howto; 1557 unsigned long r_symndx; 1558 struct elf_link_hash_entry *h; 1559 1560 r_type = ELF32_R_TYPE (rel->r_info); 1561 1562 if (r_type >= (int) R_ARC_max) 1563 { 1564 bfd_set_error (bfd_error_bad_value); 1565 return FALSE; 1566 } 1567 howto = arc_elf_howto (r_type); 1568 1569 if (dynobj == NULL 1570 && (is_reloc_for_GOT (howto) == TRUE 1571 || is_reloc_for_TLS (howto) == TRUE)) 1572 { 1573 dynobj = elf_hash_table (info)->dynobj = abfd; 1574 if (! _bfd_elf_create_got_section (abfd, info)) 1575 return FALSE; 1576 } 1577 1578 /* Load symbol information. */ 1579 r_symndx = ELF32_R_SYM (rel->r_info); 1580 if (r_symndx < symtab_hdr->sh_info) /* Is a local symbol. */ 1581 h = NULL; 1582 else /* Global one. */ 1583 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 1584 1585 switch (r_type) 1586 { 1587 case R_ARC_32: 1588 case R_ARC_32_ME: 1589 /* During shared library creation, these relocs should not 1590 appear in a shared library (as memory will be read only 1591 and the dynamic linker can not resolve these. However 1592 the error should not occur for e.g. debugging or 1593 non-readonly sections. */ 1594 if ((bfd_link_dll (info) && !bfd_link_pie (info)) 1595 && (sec->flags & SEC_ALLOC) != 0 1596 && (sec->flags & SEC_READONLY) != 0 1597 && ((sec->flags & SEC_CODE) != 0 1598 || (sec->flags & SEC_DEBUGGING) != 0)) 1599 { 1600 const char *name; 1601 if (h) 1602 name = h->root.root.string; 1603 else 1604 /* bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL); */ 1605 name = "UNKNOWN"; 1606 _bfd_error_handler 1607 /* xgettext:c-format */ 1608 (_("\ 1609 %B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"), 1610 abfd, 1611 arc_elf_howto (r_type)->name, 1612 name); 1613 bfd_set_error (bfd_error_bad_value); 1614 return FALSE; 1615 } 1616 1617 /* In some cases we are not setting the 'non_got_ref' 1618 flag, even though the relocations don't require a GOT 1619 access. We should extend the testing in this area to 1620 ensure that no significant cases are being missed. */ 1621 if (h) 1622 h->non_got_ref = 1; 1623 /* FALLTHROUGH */ 1624 case R_ARC_PC32: 1625 case R_ARC_32_PCREL: 1626 if ((bfd_link_pic (info)) 1627 && ((r_type != R_ARC_PC32 && r_type != R_ARC_32_PCREL) 1628 || (h != NULL 1629 && (!info->symbolic || !h->def_regular)))) 1630 { 1631 if (sreloc == NULL) 1632 { 1633 sreloc = _bfd_elf_make_dynamic_reloc_section (sec, dynobj, 1634 2, abfd, 1635 /*rela*/ 1636 TRUE); 1637 1638 if (sreloc == NULL) 1639 return FALSE; 1640 } 1641 sreloc->size += sizeof (Elf32_External_Rela); 1642 1643 } 1644 default: 1645 break; 1646 } 1647 1648 if (is_reloc_for_PLT (howto) == TRUE) 1649 { 1650 if (h == NULL) 1651 continue; 1652 else 1653 h->needs_plt = 1; 1654 } 1655 1656 /* Add info to the symbol got_entry_list. */ 1657 if (is_reloc_for_GOT (howto) == TRUE 1658 || is_reloc_for_TLS (howto) == TRUE) 1659 { 1660 arc_fill_got_info_for_reloc ( 1661 arc_got_entry_type_for_reloc (howto), 1662 get_got_entry_list_for_symbol (abfd, r_symndx, h), 1663 info, 1664 h); 1665 } 1666 } 1667 1668 return TRUE; 1669 } 1670 1671 #define ELF_DYNAMIC_INTERPRETER "/sbin/ld-uClibc.so" 1672 1673 static struct plt_version_t * 1674 arc_get_plt_version (struct bfd_link_info *info) 1675 { 1676 int i; 1677 1678 for (i = 0; i < 1; i++) 1679 { 1680 ARC_DEBUG ("%d: size1 = %d, size2 = %d\n", i, 1681 (int) plt_versions[i].entry_size, 1682 (int) plt_versions[i].elem_size); 1683 } 1684 1685 if (bfd_get_mach (info->output_bfd) == bfd_mach_arc_arcv2) 1686 { 1687 if (bfd_link_pic (info)) 1688 return &(plt_versions[ELF_ARCV2_PIC]); 1689 else 1690 return &(plt_versions[ELF_ARCV2_ABS]); 1691 } 1692 else 1693 { 1694 if (bfd_link_pic (info)) 1695 return &(plt_versions[ELF_ARC_PIC]); 1696 else 1697 return &(plt_versions[ELF_ARC_ABS]); 1698 } 1699 } 1700 1701 static bfd_vma 1702 add_symbol_to_plt (struct bfd_link_info *info) 1703 { 1704 struct elf_link_hash_table *htab = elf_hash_table (info); 1705 bfd_vma ret; 1706 1707 struct plt_version_t *plt_data = arc_get_plt_version (info); 1708 1709 /* If this is the first .plt entry, make room for the special first 1710 entry. */ 1711 if (htab->splt->size == 0) 1712 htab->splt->size += plt_data->entry_size; 1713 1714 ret = htab->splt->size; 1715 1716 htab->splt->size += plt_data->elem_size; 1717 ARC_DEBUG ("PLT_SIZE = %d\n", (int) htab->splt->size); 1718 1719 htab->sgotplt->size += 4; 1720 htab->srelplt->size += sizeof (Elf32_External_Rela); 1721 1722 return ret; 1723 } 1724 1725 #define PLT_DO_RELOCS_FOR_ENTRY(ABFD, DS, RELOCS) \ 1726 plt_do_relocs_for_symbol (ABFD, DS, RELOCS, 0, 0) 1727 1728 static void 1729 plt_do_relocs_for_symbol (bfd *abfd, 1730 struct elf_link_hash_table *htab, 1731 const struct plt_reloc *reloc, 1732 bfd_vma plt_offset, 1733 bfd_vma symbol_got_offset) 1734 { 1735 while (SYM_ONLY (reloc->symbol) != LAST_RELOC) 1736 { 1737 bfd_vma relocation = 0; 1738 1739 switch (SYM_ONLY (reloc->symbol)) 1740 { 1741 case SGOT: 1742 relocation 1743 = htab->sgotplt->output_section->vma 1744 + htab->sgotplt->output_offset + symbol_got_offset; 1745 break; 1746 } 1747 relocation += reloc->addend; 1748 1749 if (IS_RELATIVE (reloc->symbol)) 1750 { 1751 bfd_vma reloc_offset = reloc->offset; 1752 reloc_offset -= (IS_INSN_32 (reloc->symbol)) ? 4 : 0; 1753 reloc_offset -= (IS_INSN_24 (reloc->symbol)) ? 2 : 0; 1754 1755 relocation -= htab->splt->output_section->vma 1756 + htab->splt->output_offset 1757 + plt_offset + reloc_offset; 1758 } 1759 1760 /* TODO: being ME is not a property of the relocation but of the 1761 section of which is applying the relocation. */ 1762 if (IS_MIDDLE_ENDIAN (reloc->symbol) && !bfd_big_endian (abfd)) 1763 { 1764 relocation 1765 = ((relocation & 0xffff0000) >> 16) 1766 | ((relocation & 0xffff) << 16); 1767 } 1768 1769 switch (reloc->size) 1770 { 1771 case 32: 1772 bfd_put_32 (htab->splt->output_section->owner, 1773 relocation, 1774 htab->splt->contents + plt_offset + reloc->offset); 1775 break; 1776 } 1777 1778 reloc = &(reloc[1]); /* Jump to next relocation. */ 1779 } 1780 } 1781 1782 static void 1783 relocate_plt_for_symbol (bfd *output_bfd, 1784 struct bfd_link_info *info, 1785 struct elf_link_hash_entry *h) 1786 { 1787 struct plt_version_t *plt_data = arc_get_plt_version (info); 1788 struct elf_link_hash_table *htab = elf_hash_table (info); 1789 1790 bfd_vma plt_index = (h->plt.offset - plt_data->entry_size) 1791 / plt_data->elem_size; 1792 bfd_vma got_offset = (plt_index + 3) * 4; 1793 1794 ARC_DEBUG ("arc_info: PLT_OFFSET = %#lx, PLT_ENTRY_VMA = %#lx, \ 1795 GOT_ENTRY_OFFSET = %#lx, GOT_ENTRY_VMA = %#lx, for symbol %s\n", 1796 (long) h->plt.offset, 1797 (long) (htab->splt->output_section->vma 1798 + htab->splt->output_offset 1799 + h->plt.offset), 1800 (long) got_offset, 1801 (long) (htab->sgotplt->output_section->vma 1802 + htab->sgotplt->output_offset 1803 + got_offset), 1804 h->root.root.string); 1805 1806 { 1807 bfd_vma i = 0; 1808 uint16_t *ptr = (uint16_t *) plt_data->elem; 1809 1810 for (i = 0; i < plt_data->elem_size/2; i++) 1811 { 1812 uint16_t data = ptr[i]; 1813 bfd_put_16 (output_bfd, 1814 (bfd_vma) data, 1815 htab->splt->contents + h->plt.offset + (i*2)); 1816 } 1817 } 1818 1819 plt_do_relocs_for_symbol (output_bfd, htab, 1820 plt_data->elem_relocs, 1821 h->plt.offset, 1822 got_offset); 1823 1824 /* Fill in the entry in the global offset table. */ 1825 bfd_put_32 (output_bfd, 1826 (bfd_vma) (htab->splt->output_section->vma 1827 + htab->splt->output_offset), 1828 htab->sgotplt->contents + got_offset); 1829 1830 /* TODO: Fill in the entry in the .rela.plt section. */ 1831 { 1832 Elf_Internal_Rela rel; 1833 bfd_byte *loc; 1834 1835 rel.r_offset = (htab->sgotplt->output_section->vma 1836 + htab->sgotplt->output_offset 1837 + got_offset); 1838 rel.r_addend = 0; 1839 1840 BFD_ASSERT (h->dynindx != -1); 1841 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARC_JMP_SLOT); 1842 1843 loc = htab->srelplt->contents; 1844 loc += plt_index * sizeof (Elf32_External_Rela); /* relA */ 1845 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc); 1846 } 1847 } 1848 1849 static void 1850 relocate_plt_for_entry (bfd *abfd, 1851 struct bfd_link_info *info) 1852 { 1853 struct plt_version_t *plt_data = arc_get_plt_version (info); 1854 struct elf_link_hash_table *htab = elf_hash_table (info); 1855 1856 { 1857 bfd_vma i = 0; 1858 uint16_t *ptr = (uint16_t *) plt_data->entry; 1859 for (i = 0; i < plt_data->entry_size/2; i++) 1860 { 1861 uint16_t data = ptr[i]; 1862 bfd_put_16 (abfd, 1863 (bfd_vma) data, 1864 htab->splt->contents + (i*2)); 1865 } 1866 } 1867 PLT_DO_RELOCS_FOR_ENTRY (abfd, htab, plt_data->entry_relocs); 1868 } 1869 1870 /* Desc : Adjust a symbol defined by a dynamic object and referenced 1871 by a regular object. The current definition is in some section of 1872 the dynamic object, but we're not including those sections. We 1873 have to change the definition to something the rest of the link can 1874 understand. */ 1875 1876 static bfd_boolean 1877 elf_arc_adjust_dynamic_symbol (struct bfd_link_info *info, 1878 struct elf_link_hash_entry *h) 1879 { 1880 asection *s; 1881 bfd *dynobj = (elf_hash_table (info))->dynobj; 1882 struct elf_link_hash_table *htab = elf_hash_table (info); 1883 1884 if (h->type == STT_FUNC 1885 || h->type == STT_GNU_IFUNC 1886 || h->needs_plt == 1) 1887 { 1888 if (!bfd_link_pic (info) && !h->def_dynamic && !h->ref_dynamic) 1889 { 1890 /* This case can occur if we saw a PLT32 reloc in an input 1891 file, but the symbol was never referred to by a dynamic 1892 object. In such a case, we don't actually need to build 1893 a procedure linkage table, and we can just do a PC32 1894 reloc instead. */ 1895 BFD_ASSERT (h->needs_plt); 1896 return TRUE; 1897 } 1898 1899 /* Make sure this symbol is output as a dynamic symbol. */ 1900 if (h->dynindx == -1 && !h->forced_local 1901 && !bfd_elf_link_record_dynamic_symbol (info, h)) 1902 return FALSE; 1903 1904 if (bfd_link_pic (info) 1905 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h)) 1906 { 1907 bfd_vma loc = add_symbol_to_plt (info); 1908 1909 if (bfd_link_executable (info) && !h->def_regular) 1910 { 1911 h->root.u.def.section = htab->splt; 1912 h->root.u.def.value = loc; 1913 } 1914 h->plt.offset = loc; 1915 } 1916 else 1917 { 1918 h->plt.offset = (bfd_vma) -1; 1919 h->needs_plt = 0; 1920 } 1921 return TRUE; 1922 } 1923 1924 /* If this is a weak symbol, and there is a real definition, the 1925 processor independent code will have arranged for us to see the 1926 real definition first, and we can just use the same value. */ 1927 if (h->u.weakdef != NULL) 1928 { 1929 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined 1930 || h->u.weakdef->root.type == bfd_link_hash_defweak); 1931 h->root.u.def.section = h->u.weakdef->root.u.def.section; 1932 h->root.u.def.value = h->u.weakdef->root.u.def.value; 1933 return TRUE; 1934 } 1935 1936 /* This is a reference to a symbol defined by a dynamic object which 1937 is not a function. */ 1938 1939 /* If we are creating a shared library, we must presume that the 1940 only references to the symbol are via the global offset table. 1941 For such cases we need not do anything here; the relocations will 1942 be handled correctly by relocate_section. */ 1943 if (!bfd_link_executable (info)) 1944 return TRUE; 1945 1946 /* If there are no non-GOT references, we do not need a copy 1947 relocation. */ 1948 if (!h->non_got_ref) 1949 return TRUE; 1950 1951 /* If -z nocopyreloc was given, we won't generate them either. */ 1952 if (info->nocopyreloc) 1953 { 1954 h->non_got_ref = 0; 1955 return TRUE; 1956 } 1957 1958 /* We must allocate the symbol in our .dynbss section, which will 1959 become part of the .bss section of the executable. There will be 1960 an entry for this symbol in the .dynsym section. The dynamic 1961 object will contain position independent code, so all references 1962 from the dynamic object to this symbol will go through the global 1963 offset table. The dynamic linker will use the .dynsym entry to 1964 determine the address it must put in the global offset table, so 1965 both the dynamic object and the regular object will refer to the 1966 same memory location for the variable. */ 1967 1968 if (htab == NULL) 1969 return FALSE; 1970 1971 /* We must generate a R_ARC_COPY reloc to tell the dynamic linker to 1972 copy the initial value out of the dynamic object and into the 1973 runtime process image. We need to remember the offset into the 1974 .rela.bss section we are going to use. */ 1975 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0) 1976 { 1977 struct elf_arc_link_hash_table *arc_htab = elf_arc_hash_table (info); 1978 1979 BFD_ASSERT (arc_htab->elf.srelbss != NULL); 1980 arc_htab->elf.srelbss->size += sizeof (Elf32_External_Rela); 1981 h->needs_copy = 1; 1982 } 1983 1984 /* TODO: Move this also to arc_hash_table. */ 1985 s = bfd_get_section_by_name (dynobj, ".dynbss"); 1986 BFD_ASSERT (s != NULL); 1987 1988 return _bfd_elf_adjust_dynamic_copy (info, h, s); 1989 } 1990 1991 /* Function : elf_arc_finish_dynamic_symbol 1992 Brief : Finish up dynamic symbol handling. We set the 1993 contents of various dynamic sections here. 1994 Args : output_bfd : 1995 info : 1996 h : 1997 sym : 1998 Returns : True/False as the return status. */ 1999 2000 static bfd_boolean 2001 elf_arc_finish_dynamic_symbol (bfd * output_bfd, 2002 struct bfd_link_info *info, 2003 struct elf_link_hash_entry *h, 2004 Elf_Internal_Sym * sym) 2005 { 2006 if (h->plt.offset != (bfd_vma) -1) 2007 { 2008 relocate_plt_for_symbol (output_bfd, info, h); 2009 2010 if (!h->def_regular) 2011 { 2012 /* Mark the symbol as undefined, rather than as defined in 2013 the .plt section. Leave the value alone. */ 2014 sym->st_shndx = SHN_UNDEF; 2015 } 2016 } 2017 2018 2019 /* This function traverses list of GOT entries and 2020 create respective dynamic relocs. */ 2021 /* TODO: Make function to get list and not access the list directly. */ 2022 /* TODO: Move function to relocate_section create this relocs eagerly. */ 2023 create_got_dynrelocs_for_got_info (&h->got.glist, 2024 output_bfd, 2025 info, 2026 h); 2027 2028 if (h->needs_copy) 2029 { 2030 struct elf_arc_link_hash_table *arc_htab = elf_arc_hash_table (info); 2031 2032 if (h->dynindx == -1 2033 || (h->root.type != bfd_link_hash_defined 2034 && h->root.type != bfd_link_hash_defweak) 2035 || arc_htab->elf.srelbss == NULL) 2036 abort (); 2037 2038 bfd_vma rel_offset = (h->root.u.def.value 2039 + h->root.u.def.section->output_section->vma 2040 + h->root.u.def.section->output_offset); 2041 2042 bfd_byte * loc = arc_htab->elf.srelbss->contents 2043 + (arc_htab->elf.srelbss->reloc_count * sizeof (Elf32_External_Rela)); 2044 arc_htab->elf.srelbss->reloc_count++; 2045 2046 Elf_Internal_Rela rel; 2047 rel.r_addend = 0; 2048 rel.r_offset = rel_offset; 2049 2050 BFD_ASSERT (h->dynindx != -1); 2051 rel.r_info = ELF32_R_INFO (h->dynindx, R_ARC_COPY); 2052 2053 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc); 2054 } 2055 2056 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */ 2057 if (strcmp (h->root.root.string, "_DYNAMIC") == 0 2058 || strcmp (h->root.root.string, "__DYNAMIC") == 0 2059 || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0) 2060 sym->st_shndx = SHN_ABS; 2061 2062 return TRUE; 2063 } 2064 2065 #define GET_SYMBOL_OR_SECTION(TAG, SYMBOL, SECTION) \ 2066 case TAG: \ 2067 if (SYMBOL != NULL) \ 2068 h = elf_link_hash_lookup (elf_hash_table (info), \ 2069 SYMBOL, FALSE, FALSE, TRUE); \ 2070 else if (SECTION != NULL) \ 2071 s = bfd_get_linker_section (dynobj, SECTION); \ 2072 break; 2073 2074 /* Function : elf_arc_finish_dynamic_sections 2075 Brief : Finish up the dynamic sections handling. 2076 Args : output_bfd : 2077 info : 2078 h : 2079 sym : 2080 Returns : True/False as the return status. */ 2081 2082 static bfd_boolean 2083 elf_arc_finish_dynamic_sections (bfd * output_bfd, 2084 struct bfd_link_info *info) 2085 { 2086 struct elf_link_hash_table *htab = elf_hash_table (info); 2087 bfd *dynobj = (elf_hash_table (info))->dynobj; 2088 asection *sdyn = bfd_get_linker_section (dynobj, ".dynamic"); 2089 2090 if (sdyn) 2091 { 2092 Elf32_External_Dyn *dyncon, *dynconend; 2093 2094 dyncon = (Elf32_External_Dyn *) sdyn->contents; 2095 dynconend 2096 = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size); 2097 for (; dyncon < dynconend; dyncon++) 2098 { 2099 Elf_Internal_Dyn internal_dyn; 2100 bfd_boolean do_it = FALSE; 2101 2102 struct elf_link_hash_entry *h = NULL; 2103 asection *s = NULL; 2104 2105 bfd_elf32_swap_dyn_in (dynobj, dyncon, &internal_dyn); 2106 2107 switch (internal_dyn.d_tag) 2108 { 2109 GET_SYMBOL_OR_SECTION (DT_INIT, info->init_function, NULL) 2110 GET_SYMBOL_OR_SECTION (DT_FINI, info->fini_function, NULL) 2111 GET_SYMBOL_OR_SECTION (DT_PLTGOT, NULL, ".plt") 2112 GET_SYMBOL_OR_SECTION (DT_JMPREL, NULL, ".rela.plt") 2113 GET_SYMBOL_OR_SECTION (DT_PLTRELSZ, NULL, ".rela.plt") 2114 GET_SYMBOL_OR_SECTION (DT_VERSYM, NULL, ".gnu.version") 2115 GET_SYMBOL_OR_SECTION (DT_VERDEF, NULL, ".gnu.version_d") 2116 GET_SYMBOL_OR_SECTION (DT_VERNEED, NULL, ".gnu.version_r") 2117 default: 2118 break; 2119 } 2120 2121 /* In case the dynamic symbols should be updated with a symbol. */ 2122 if (h != NULL 2123 && (h->root.type == bfd_link_hash_defined 2124 || h->root.type == bfd_link_hash_defweak)) 2125 { 2126 asection *asec_ptr; 2127 2128 internal_dyn.d_un.d_val = h->root.u.def.value; 2129 asec_ptr = h->root.u.def.section; 2130 if (asec_ptr->output_section != NULL) 2131 { 2132 internal_dyn.d_un.d_val += 2133 (asec_ptr->output_section->vma 2134 + asec_ptr->output_offset); 2135 } 2136 else 2137 { 2138 /* The symbol is imported from another shared 2139 library and does not apply to this one. */ 2140 internal_dyn.d_un.d_val = 0; 2141 } 2142 do_it = TRUE; 2143 } 2144 else if (s != NULL) /* With a section information. */ 2145 { 2146 switch (internal_dyn.d_tag) 2147 { 2148 case DT_PLTGOT: 2149 case DT_JMPREL: 2150 case DT_VERSYM: 2151 case DT_VERDEF: 2152 case DT_VERNEED: 2153 internal_dyn.d_un.d_ptr = (s->output_section->vma 2154 + s->output_offset); 2155 do_it = TRUE; 2156 break; 2157 2158 case DT_PLTRELSZ: 2159 internal_dyn.d_un.d_val = s->size; 2160 do_it = TRUE; 2161 break; 2162 2163 default: 2164 break; 2165 } 2166 } 2167 2168 if (do_it) 2169 bfd_elf32_swap_dyn_out (output_bfd, &internal_dyn, dyncon); 2170 } 2171 2172 if (htab->splt->size > 0) 2173 { 2174 relocate_plt_for_entry (output_bfd, info); 2175 } 2176 2177 /* TODO: Validate this. */ 2178 if (htab->srelplt->output_section != bfd_abs_section_ptr) 2179 elf_section_data (htab->srelplt->output_section) 2180 ->this_hdr.sh_entsize = 12; 2181 } 2182 2183 /* Fill in the first three entries in the global offset table. */ 2184 if (htab->sgot) 2185 { 2186 struct elf_link_hash_entry *h; 2187 h = elf_link_hash_lookup (elf_hash_table (info), "_GLOBAL_OFFSET_TABLE_", 2188 FALSE, FALSE, TRUE); 2189 2190 if (h != NULL && h->root.type != bfd_link_hash_undefined 2191 && h->root.u.def.section != NULL) 2192 { 2193 asection *sec = h->root.u.def.section; 2194 2195 if (sdyn == NULL) 2196 bfd_put_32 (output_bfd, (bfd_vma) 0, 2197 sec->contents); 2198 else 2199 bfd_put_32 (output_bfd, 2200 sdyn->output_section->vma + sdyn->output_offset, 2201 sec->contents); 2202 bfd_put_32 (output_bfd, (bfd_vma) 0, sec->contents + 4); 2203 bfd_put_32 (output_bfd, (bfd_vma) 0, sec->contents + 8); 2204 } 2205 } 2206 2207 return TRUE; 2208 } 2209 2210 #define ADD_DYNAMIC_SYMBOL(NAME, TAG) \ 2211 h = elf_link_hash_lookup (elf_hash_table (info), \ 2212 NAME, FALSE, FALSE, FALSE); \ 2213 if ((h != NULL && (h->ref_regular || h->def_regular))) \ 2214 if (! _bfd_elf_add_dynamic_entry (info, TAG, 0)) \ 2215 return FALSE; 2216 2217 /* Set the sizes of the dynamic sections. */ 2218 static bfd_boolean 2219 elf_arc_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED, 2220 struct bfd_link_info *info) 2221 { 2222 bfd *dynobj; 2223 asection *s; 2224 bfd_boolean relocs_exist = FALSE; 2225 bfd_boolean reltext_exist = FALSE; 2226 struct elf_link_hash_table *htab = elf_hash_table (info); 2227 2228 dynobj = htab->dynobj; 2229 BFD_ASSERT (dynobj != NULL); 2230 2231 if (htab->dynamic_sections_created) 2232 { 2233 struct elf_link_hash_entry *h; 2234 2235 /* Set the contents of the .interp section to the 2236 interpreter. */ 2237 if (bfd_link_executable (info) && !info->nointerp) 2238 { 2239 s = bfd_get_section_by_name (dynobj, ".interp"); 2240 BFD_ASSERT (s != NULL); 2241 s->size = sizeof (ELF_DYNAMIC_INTERPRETER); 2242 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER; 2243 } 2244 2245 /* Add some entries to the .dynamic section. We fill in some of 2246 the values later, in elf_bfd_final_link, but we must add the 2247 entries now so that we know the final size of the .dynamic 2248 section. Checking if the .init section is present. We also 2249 create DT_INIT and DT_FINI entries if the init_str has been 2250 changed by the user. */ 2251 ADD_DYNAMIC_SYMBOL (info->init_function, DT_INIT); 2252 ADD_DYNAMIC_SYMBOL (info->fini_function, DT_FINI); 2253 } 2254 else 2255 { 2256 /* We may have created entries in the .rela.got section. 2257 However, if we are not creating the dynamic sections, we will 2258 not actually use these entries. Reset the size of .rela.got, 2259 which will cause it to get stripped from the output file 2260 below. */ 2261 if (htab->srelgot != NULL) 2262 htab->srelgot->size = 0; 2263 } 2264 2265 for (s = dynobj->sections; s != NULL; s = s->next) 2266 { 2267 if ((s->flags & SEC_LINKER_CREATED) == 0) 2268 continue; 2269 2270 if (s == htab->splt 2271 || s == htab->sgot 2272 || s == htab->sgotplt 2273 || s == htab->sdynbss) 2274 { 2275 /* Strip this section if we don't need it. */ 2276 } 2277 else if (strncmp (s->name, ".rela", 5) == 0) 2278 { 2279 if (s->size != 0 && s != htab->srelplt) 2280 { 2281 if (!reltext_exist) 2282 { 2283 const char *name = s->name + 5; 2284 bfd *ibfd; 2285 for (ibfd = info->input_bfds; ibfd; ibfd = ibfd->link.next) 2286 if (bfd_get_flavour (ibfd) == bfd_target_elf_flavour) 2287 { 2288 asection *target = bfd_get_section_by_name (ibfd, name); 2289 if (target != NULL 2290 && elf_section_data (target)->sreloc == s 2291 && ((target->output_section->flags 2292 & (SEC_READONLY | SEC_ALLOC)) 2293 == (SEC_READONLY | SEC_ALLOC))) 2294 { 2295 reltext_exist = TRUE; 2296 break; 2297 } 2298 } 2299 } 2300 relocs_exist = TRUE; 2301 } 2302 2303 /* We use the reloc_count field as a counter if we need to 2304 copy relocs into the output file. */ 2305 s->reloc_count = 0; 2306 } 2307 else 2308 { 2309 /* It's not one of our sections, so don't allocate space. */ 2310 continue; 2311 } 2312 2313 if (s->size == 0) 2314 { 2315 s->flags |= SEC_EXCLUDE; 2316 continue; 2317 } 2318 2319 if ((s->flags & SEC_HAS_CONTENTS) == 0) 2320 continue; 2321 2322 /* Allocate memory for the section contents. */ 2323 s->contents = bfd_zalloc (dynobj, s->size); 2324 if (s->contents == NULL) 2325 return FALSE; 2326 } 2327 2328 if (htab->dynamic_sections_created) 2329 { 2330 /* TODO: Check if this is needed. */ 2331 if (!bfd_link_pic (info)) 2332 if (!_bfd_elf_add_dynamic_entry (info, DT_DEBUG, 0)) 2333 return FALSE; 2334 2335 if (htab->splt && (htab->splt->flags & SEC_EXCLUDE) == 0) 2336 if (!_bfd_elf_add_dynamic_entry (info, DT_PLTGOT, 0) 2337 || !_bfd_elf_add_dynamic_entry (info, DT_PLTRELSZ, 0) 2338 || !_bfd_elf_add_dynamic_entry (info, DT_PLTREL, DT_RELA) 2339 || !_bfd_elf_add_dynamic_entry (info, DT_JMPREL, 0)) 2340 return FALSE; 2341 2342 if (relocs_exist) 2343 if (!_bfd_elf_add_dynamic_entry (info, DT_RELA, 0) 2344 || !_bfd_elf_add_dynamic_entry (info, DT_RELASZ, 0) 2345 || !_bfd_elf_add_dynamic_entry (info, DT_RELAENT, 2346 sizeof (Elf32_External_Rela))) 2347 return FALSE; 2348 2349 if (reltext_exist) 2350 if (!_bfd_elf_add_dynamic_entry (info, DT_TEXTREL, 0)) 2351 return FALSE; 2352 } 2353 2354 return TRUE; 2355 } 2356 2357 2358 /* Classify dynamic relocs such that -z combreloc can reorder and combine 2359 them. */ 2360 static enum elf_reloc_type_class 2361 elf32_arc_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED, 2362 const asection *rel_sec ATTRIBUTE_UNUSED, 2363 const Elf_Internal_Rela *rela) 2364 { 2365 switch ((int) ELF32_R_TYPE (rela->r_info)) 2366 { 2367 case R_ARC_RELATIVE: 2368 return reloc_class_relative; 2369 case R_ARC_JMP_SLOT: 2370 return reloc_class_plt; 2371 case R_ARC_COPY: 2372 return reloc_class_copy; 2373 /* TODO: Needed in future to support ifunc. */ 2374 /* 2375 case R_ARC_IRELATIVE: 2376 return reloc_class_ifunc; 2377 */ 2378 default: 2379 return reloc_class_normal; 2380 } 2381 } 2382 2383 const struct elf_size_info arc_elf32_size_info = 2384 { 2385 sizeof (Elf32_External_Ehdr), 2386 sizeof (Elf32_External_Phdr), 2387 sizeof (Elf32_External_Shdr), 2388 sizeof (Elf32_External_Rel), 2389 sizeof (Elf32_External_Rela), 2390 sizeof (Elf32_External_Sym), 2391 sizeof (Elf32_External_Dyn), 2392 sizeof (Elf_External_Note), 2393 4, 2394 1, 2395 32, 2, 2396 ELFCLASS32, EV_CURRENT, 2397 bfd_elf32_write_out_phdrs, 2398 bfd_elf32_write_shdrs_and_ehdr, 2399 bfd_elf32_checksum_contents, 2400 bfd_elf32_write_relocs, 2401 bfd_elf32_swap_symbol_in, 2402 bfd_elf32_swap_symbol_out, 2403 bfd_elf32_slurp_reloc_table, 2404 bfd_elf32_slurp_symbol_table, 2405 bfd_elf32_swap_dyn_in, 2406 bfd_elf32_swap_dyn_out, 2407 bfd_elf32_swap_reloc_in, 2408 bfd_elf32_swap_reloc_out, 2409 bfd_elf32_swap_reloca_in, 2410 bfd_elf32_swap_reloca_out 2411 }; 2412 2413 #define elf_backend_size_info arc_elf32_size_info 2414 2415 /* Hook called by the linker routine which adds symbols from an object 2416 file. */ 2417 2418 static bfd_boolean 2419 elf_arc_add_symbol_hook (bfd * abfd, 2420 struct bfd_link_info * info, 2421 Elf_Internal_Sym * sym, 2422 const char ** namep ATTRIBUTE_UNUSED, 2423 flagword * flagsp ATTRIBUTE_UNUSED, 2424 asection ** secp ATTRIBUTE_UNUSED, 2425 bfd_vma * valp ATTRIBUTE_UNUSED) 2426 { 2427 if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC 2428 && (abfd->flags & DYNAMIC) == 0 2429 && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour) 2430 elf_tdata (info->output_bfd)->has_gnu_symbols |= elf_gnu_symbol_ifunc; 2431 2432 return TRUE; 2433 } 2434 2435 /* GDB expects general purpose registers to be in section .reg. However Linux 2436 kernel doesn't create this section and instead writes registers to NOTE 2437 section. It is up to the binutils to create a pseudo-section .reg from the 2438 contents of NOTE. Also BFD will read pid and signal number from NOTE. This 2439 function relies on offsets inside elf_prstatus structure in Linux to be 2440 stable. */ 2441 2442 static bfd_boolean 2443 elf32_arc_grok_prstatus (bfd *abfd, Elf_Internal_Note *note) 2444 { 2445 int offset; 2446 size_t size; 2447 2448 switch (note->descsz) 2449 { 2450 default: 2451 return FALSE; 2452 2453 case 236: /* sizeof (struct elf_prstatus) on Linux/arc. */ 2454 /* pr_cursig */ 2455 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12); 2456 /* pr_pid */ 2457 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24); 2458 /* pr_regs */ 2459 offset = 72; 2460 size = (40 * 4); /* There are 40 registers in user_regs_struct. */ 2461 break; 2462 } 2463 /* Make a ".reg/999" section. */ 2464 return _bfd_elfcore_make_pseudosection (abfd, ".reg", size, 2465 note->descpos + offset); 2466 } 2467 2468 #define TARGET_LITTLE_SYM arc_elf32_le_vec 2469 #define TARGET_LITTLE_NAME "elf32-littlearc" 2470 #define TARGET_BIG_SYM arc_elf32_be_vec 2471 #define TARGET_BIG_NAME "elf32-bigarc" 2472 #define ELF_ARCH bfd_arch_arc 2473 #define ELF_TARGET_ID ARC_ELF_DATA 2474 #define ELF_MACHINE_CODE EM_ARC_COMPACT 2475 #define ELF_MACHINE_ALT1 EM_ARC_COMPACT2 2476 #define ELF_MAXPAGESIZE 0x2000 2477 2478 #define bfd_elf32_bfd_link_hash_table_create arc_elf_link_hash_table_create 2479 2480 #define bfd_elf32_bfd_merge_private_bfd_data arc_elf_merge_private_bfd_data 2481 #define bfd_elf32_bfd_reloc_type_lookup arc_elf32_bfd_reloc_type_lookup 2482 #define bfd_elf32_bfd_set_private_flags arc_elf_set_private_flags 2483 #define bfd_elf32_bfd_print_private_bfd_data arc_elf_print_private_bfd_data 2484 #define bfd_elf32_bfd_copy_private_bfd_data arc_elf_copy_private_bfd_data 2485 2486 #define elf_info_to_howto_rel arc_info_to_howto_rel 2487 #define elf_backend_object_p arc_elf_object_p 2488 #define elf_backend_final_write_processing arc_elf_final_write_processing 2489 2490 #define elf_backend_relocate_section elf_arc_relocate_section 2491 #define elf_backend_check_relocs elf_arc_check_relocs 2492 #define elf_backend_create_dynamic_sections _bfd_elf_create_dynamic_sections 2493 2494 #define elf_backend_reloc_type_class elf32_arc_reloc_type_class 2495 2496 #define elf_backend_adjust_dynamic_symbol elf_arc_adjust_dynamic_symbol 2497 #define elf_backend_finish_dynamic_symbol elf_arc_finish_dynamic_symbol 2498 2499 #define elf_backend_finish_dynamic_sections elf_arc_finish_dynamic_sections 2500 #define elf_backend_size_dynamic_sections elf_arc_size_dynamic_sections 2501 #define elf_backend_add_symbol_hook elf_arc_add_symbol_hook 2502 2503 #define elf_backend_can_gc_sections 1 2504 #define elf_backend_want_got_plt 1 2505 #define elf_backend_plt_readonly 1 2506 #define elf_backend_rela_plts_and_copies_p 1 2507 #define elf_backend_want_plt_sym 0 2508 #define elf_backend_got_header_size 12 2509 #define elf_backend_dtrel_excludes_plt 1 2510 2511 #define elf_backend_may_use_rel_p 0 2512 #define elf_backend_may_use_rela_p 1 2513 #define elf_backend_default_use_rela_p 1 2514 2515 #define elf_backend_grok_prstatus elf32_arc_grok_prstatus 2516 2517 #define elf_backend_default_execstack 0 2518 2519 #include "elf32-target.h" 2520