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