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