1 /* 32-bit ELF support for S+core. 2 Copyright 2006, 2007, 2008, 2009, 2010, 2011, 2012 3 Free Software Foundation, Inc. 4 Contributed by 5 Brain.lin (brain.lin@sunplusct.com) 6 Mei Ligang (ligang@sunnorth.com.cn) 7 Pei-Lin Tsai (pltsai@sunplus.com) 8 9 This file is part of BFD, the Binary File Descriptor library. 10 11 This program is free software; you can redistribute it and/or modify 12 it under the terms of the GNU General Public License as published by 13 the Free Software Foundation; either version 3 of the License, or 14 (at your option) any later version. 15 16 This program is distributed in the hope that it will be useful, 17 but WITHOUT ANY WARRANTY; without even the implied warranty of 18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 19 GNU General Public License for more details. 20 21 You should have received a copy of the GNU General Public License 22 along with this program; if not, write to the Free Software 23 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 24 MA 02110-1301, USA. */ 25 26 #include "sysdep.h" 27 #include "bfd.h" 28 #include "libbfd.h" 29 #include "libiberty.h" 30 #include "elf-bfd.h" 31 #include "elf/score.h" 32 #include "elf/common.h" 33 #include "elf/internal.h" 34 #include "hashtab.h" 35 #include "elf32-score.h" 36 37 38 int score3 = 0; 39 int score7 = 1; 40 41 /* The SCORE ELF linker needs additional information for each symbol in 42 the global hash table. */ 43 struct score_elf_link_hash_entry 44 { 45 struct elf_link_hash_entry root; 46 47 /* Number of R_SCORE_ABS32, R_SCORE_REL32 relocs against this symbol. */ 48 unsigned int possibly_dynamic_relocs; 49 50 /* If the R_SCORE_ABS32, R_SCORE_REL32 reloc is against a readonly section. */ 51 bfd_boolean readonly_reloc; 52 53 /* We must not create a stub for a symbol that has relocations related to 54 taking the function's address, i.e. any but R_SCORE_CALL15 ones. */ 55 bfd_boolean no_fn_stub; 56 57 /* Are we forced local? This will only be set if we have converted 58 the initial global GOT entry to a local GOT entry. */ 59 bfd_boolean forced_local; 60 }; 61 62 /* Traverse a score ELF linker hash table. */ 63 #define score_elf_link_hash_traverse(table, func, info) \ 64 (elf_link_hash_traverse \ 65 ((table), \ 66 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \ 67 (info))) 68 69 /* This structure is used to hold .got entries while estimating got sizes. */ 70 struct score_got_entry 71 { 72 /* The input bfd in which the symbol is defined. */ 73 bfd *abfd; 74 /* The index of the symbol, as stored in the relocation r_info, if 75 we have a local symbol; -1 otherwise. */ 76 long symndx; 77 union 78 { 79 /* If abfd == NULL, an address that must be stored in the got. */ 80 bfd_vma address; 81 /* If abfd != NULL && symndx != -1, the addend of the relocation 82 that should be added to the symbol value. */ 83 bfd_vma addend; 84 /* If abfd != NULL && symndx == -1, the hash table entry 85 corresponding to a global symbol in the got (or, local, if 86 h->forced_local). */ 87 struct score_elf_link_hash_entry *h; 88 } d; 89 90 /* The offset from the beginning of the .got section to the entry 91 corresponding to this symbol+addend. If it's a global symbol 92 whose offset is yet to be decided, it's going to be -1. */ 93 long gotidx; 94 }; 95 96 /* This structure is passed to score_elf_sort_hash_table_f when sorting 97 the dynamic symbols. */ 98 99 struct score_elf_hash_sort_data 100 { 101 /* The symbol in the global GOT with the lowest dynamic symbol table index. */ 102 struct elf_link_hash_entry *low; 103 /* The least dynamic symbol table index corresponding to a symbol with a GOT entry. */ 104 long min_got_dynindx; 105 /* The greatest dynamic symbol table index corresponding to a symbol 106 with a GOT entry that is not referenced (e.g., a dynamic symbol 107 with dynamic relocations pointing to it from non-primary GOTs). */ 108 long max_unref_got_dynindx; 109 /* The greatest dynamic symbol table index not corresponding to a 110 symbol without a GOT entry. */ 111 long max_non_got_dynindx; 112 }; 113 114 struct score_got_info 115 { 116 /* The global symbol in the GOT with the lowest index in the dynamic 117 symbol table. */ 118 struct elf_link_hash_entry *global_gotsym; 119 /* The number of global .got entries. */ 120 unsigned int global_gotno; 121 /* The number of local .got entries. */ 122 unsigned int local_gotno; 123 /* The number of local .got entries we have used. */ 124 unsigned int assigned_gotno; 125 /* A hash table holding members of the got. */ 126 struct htab *got_entries; 127 /* In multi-got links, a pointer to the next got (err, rather, most 128 of the time, it points to the previous got). */ 129 struct score_got_info *next; 130 }; 131 132 /* A structure used to count GOT entries, for GOT entry or ELF symbol table traversal. */ 133 struct _score_elf_section_data 134 { 135 struct bfd_elf_section_data elf; 136 union 137 { 138 struct score_got_info *got_info; 139 bfd_byte *tdata; 140 } 141 u; 142 }; 143 144 #define score_elf_section_data(sec) \ 145 ((struct _score_elf_section_data *) elf_section_data (sec)) 146 147 /* The size of a symbol-table entry. */ 148 #define SCORE_ELF_SYM_SIZE(abfd) \ 149 (get_elf_backend_data (abfd)->s->sizeof_sym) 150 151 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value 152 from smaller values. Start with zero, widen, *then* decrement. */ 153 #define MINUS_ONE (((bfd_vma)0) - 1) 154 #define MINUS_TWO (((bfd_vma)0) - 2) 155 156 #define PDR_SIZE 32 157 158 159 /* The number of local .got entries we reserve. */ 160 #define SCORE_RESERVED_GOTNO (2) 161 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/ld.so.1" 162 163 /* The offset of $gp from the beginning of the .got section. */ 164 #define ELF_SCORE_GP_OFFSET(abfd) (0x3ff0) 165 /* The maximum size of the GOT for it to be addressable using 15-bit offsets from $gp. */ 166 #define SCORE_ELF_GOT_MAX_SIZE(abfd) (ELF_SCORE_GP_OFFSET(abfd) + 0x3fff) 167 168 #define SCORE_ELF_STUB_SECTION_NAME (".SCORE.stub") 169 #define SCORE_FUNCTION_STUB_SIZE (16) 170 171 #define STUB_LW 0xc3bcc010 /* lw r29, [r28, -0x3ff0] */ 172 #define STUB_MOVE 0x8363bc56 /* mv r27, r3 */ 173 #define STUB_LI16 0x87548000 /* ori r26, .dynsym_index */ 174 #define STUB_BRL 0x801dbc09 /* brl r29 */ 175 176 #define SCORE_ELF_GOT_SIZE(abfd) \ 177 (get_elf_backend_data (abfd)->s->arch_size / 8) 178 179 #define SCORE_ELF_ADD_DYNAMIC_ENTRY(info, tag, val) \ 180 (_bfd_elf_add_dynamic_entry (info, (bfd_vma) tag, (bfd_vma) val)) 181 182 /* The size of an external dynamic table entry. */ 183 #define SCORE_ELF_DYN_SIZE(abfd) \ 184 (get_elf_backend_data (abfd)->s->sizeof_dyn) 185 186 /* The size of an external REL relocation. */ 187 #define SCORE_ELF_REL_SIZE(abfd) \ 188 (get_elf_backend_data (abfd)->s->sizeof_rel) 189 190 /* The default alignment for sections, as a power of two. */ 191 #define SCORE_ELF_LOG_FILE_ALIGN(abfd)\ 192 (get_elf_backend_data (abfd)->s->log_file_align) 193 194 static bfd_byte *hi16_rel_addr; 195 196 /* This will be used when we sort the dynamic relocation records. */ 197 static bfd *reldyn_sorting_bfd; 198 199 /* SCORE ELF uses two common sections. One is the usual one, and the 200 other is for small objects. All the small objects are kept 201 together, and then referenced via the gp pointer, which yields 202 faster assembler code. This is what we use for the small common 203 section. This approach is copied from ecoff.c. */ 204 static asection score_elf_scom_section; 205 static asymbol score_elf_scom_symbol; 206 static asymbol *score_elf_scom_symbol_ptr; 207 208 static bfd_vma 209 score_bfd_get_16 (bfd *abfd, const void *data) 210 { 211 return bfd_get_16 (abfd, data); 212 } 213 214 static bfd_vma 215 score3_bfd_getl32 (const void *p) 216 { 217 const bfd_byte *addr = p; 218 unsigned long v; 219 220 v = (unsigned long) addr[2]; 221 v |= (unsigned long) addr[3] << 8; 222 v |= (unsigned long) addr[0] << 16; 223 v |= (unsigned long) addr[1] << 24; 224 return v; 225 } 226 227 static bfd_vma 228 score3_bfd_getl48 (const void *p) 229 { 230 const bfd_byte *addr = p; 231 unsigned long long v; 232 233 v = (unsigned long long) addr[4]; 234 v |= (unsigned long long) addr[5] << 8; 235 v |= (unsigned long long) addr[2] << 16; 236 v |= (unsigned long long) addr[3] << 24; 237 v |= (unsigned long long) addr[0] << 32; 238 v |= (unsigned long long) addr[1] << 40; 239 return v; 240 } 241 242 static bfd_vma 243 score_bfd_get_32 (bfd *abfd, const void *data) 244 { 245 if (/* score3 && */ abfd->xvec->byteorder == BFD_ENDIAN_LITTLE) 246 return score3_bfd_getl32 (data); 247 else 248 return bfd_get_32 (abfd, data); 249 } 250 251 static bfd_vma 252 score_bfd_get_48 (bfd *abfd, const void *p) 253 { 254 if (/* score3 && */ abfd->xvec->byteorder == BFD_ENDIAN_LITTLE) 255 return score3_bfd_getl48 (p); 256 else 257 return bfd_get_bits (p, 48, 1); 258 } 259 260 static void 261 score_bfd_put_16 (bfd *abfd, bfd_vma addr, void *data) 262 { 263 return bfd_put_16 (abfd, addr, data); 264 } 265 266 static void 267 score3_bfd_putl32 (bfd_vma data, void *p) 268 { 269 bfd_byte *addr = p; 270 addr[0] = (data >> 16) & 0xff; 271 addr[1] = (data >> 24) & 0xff; 272 addr[2] = data & 0xff; 273 addr[3] = (data >> 8) & 0xff; 274 } 275 276 static void 277 score3_bfd_putl48 (bfd_vma data, void *p) 278 { 279 bfd_byte *addr = p; 280 addr[0] = (data >> 32) & 0xff; 281 addr[1] = (data >> 40) & 0xff; 282 addr[2] = (data >> 16) & 0xff; 283 addr[3] = (data >> 24) & 0xff; 284 addr[4] = data & 0xff; 285 addr[5] = (data >> 8) & 0xff; 286 } 287 288 static void 289 score_bfd_put_32 (bfd *abfd, bfd_vma addr, void *data) 290 { 291 if (/* score3 && */ abfd->xvec->byteorder == BFD_ENDIAN_LITTLE) 292 return score3_bfd_putl32 (addr, data); 293 else 294 return bfd_put_32 (abfd, addr, data); 295 } 296 297 static void 298 score_bfd_put_48 (bfd *abfd, bfd_vma val, void *p) 299 { 300 if (/* score3 && */ abfd->xvec->byteorder == BFD_ENDIAN_LITTLE) 301 return score3_bfd_putl48 (val, p); 302 else 303 return bfd_put_bits (val, p, 48, 1); 304 } 305 306 static bfd_reloc_status_type 307 score_elf_hi16_reloc (bfd *abfd ATTRIBUTE_UNUSED, 308 arelent *reloc_entry, 309 asymbol *symbol ATTRIBUTE_UNUSED, 310 void * data, 311 asection *input_section ATTRIBUTE_UNUSED, 312 bfd *output_bfd ATTRIBUTE_UNUSED, 313 char **error_message ATTRIBUTE_UNUSED) 314 { 315 hi16_rel_addr = (bfd_byte *) data + reloc_entry->address; 316 return bfd_reloc_ok; 317 } 318 319 static bfd_reloc_status_type 320 score_elf_lo16_reloc (bfd *abfd, 321 arelent *reloc_entry, 322 asymbol *symbol ATTRIBUTE_UNUSED, 323 void * data, 324 asection *input_section, 325 bfd *output_bfd ATTRIBUTE_UNUSED, 326 char **error_message ATTRIBUTE_UNUSED) 327 { 328 bfd_vma addend = 0, offset = 0; 329 unsigned long val; 330 unsigned long hi16_offset, hi16_value, uvalue; 331 332 hi16_value = score_bfd_get_32 (abfd, hi16_rel_addr); 333 hi16_offset = ((((hi16_value >> 16) & 0x3) << 15) | (hi16_value & 0x7fff)) >> 1; 334 addend = score_bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address); 335 offset = ((((addend >> 16) & 0x3) << 15) | (addend & 0x7fff)) >> 1; 336 val = reloc_entry->addend; 337 if (reloc_entry->address > input_section->size) 338 return bfd_reloc_outofrange; 339 uvalue = ((hi16_offset << 16) | (offset & 0xffff)) + val; 340 hi16_offset = (uvalue >> 16) << 1; 341 hi16_value = (hi16_value & ~0x37fff) | (hi16_offset & 0x7fff) | ((hi16_offset << 1) & 0x30000); 342 score_bfd_put_32 (abfd, hi16_value, hi16_rel_addr); 343 offset = (uvalue & 0xffff) << 1; 344 addend = (addend & ~0x37fff) | (offset & 0x7fff) | ((offset << 1) & 0x30000); 345 score_bfd_put_32 (abfd, addend, (bfd_byte *) data + reloc_entry->address); 346 return bfd_reloc_ok; 347 } 348 349 /* Set the GP value for OUTPUT_BFD. Returns FALSE if this is a 350 dangerous relocation. */ 351 352 static bfd_boolean 353 score_elf_assign_gp (bfd *output_bfd, bfd_vma *pgp) 354 { 355 unsigned int count; 356 asymbol **sym; 357 unsigned int i; 358 359 /* If we've already figured out what GP will be, just return it. */ 360 *pgp = _bfd_get_gp_value (output_bfd); 361 if (*pgp) 362 return TRUE; 363 364 count = bfd_get_symcount (output_bfd); 365 sym = bfd_get_outsymbols (output_bfd); 366 367 /* The linker script will have created a symbol named `_gp' with the 368 appropriate value. */ 369 if (sym == NULL) 370 i = count; 371 else 372 { 373 for (i = 0; i < count; i++, sym++) 374 { 375 const char *name; 376 377 name = bfd_asymbol_name (*sym); 378 if (*name == '_' && strcmp (name, "_gp") == 0) 379 { 380 *pgp = bfd_asymbol_value (*sym); 381 _bfd_set_gp_value (output_bfd, *pgp); 382 break; 383 } 384 } 385 } 386 387 if (i >= count) 388 { 389 /* Only get the error once. */ 390 *pgp = 4; 391 _bfd_set_gp_value (output_bfd, *pgp); 392 return FALSE; 393 } 394 395 return TRUE; 396 } 397 398 /* We have to figure out the gp value, so that we can adjust the 399 symbol value correctly. We look up the symbol _gp in the output 400 BFD. If we can't find it, we're stuck. We cache it in the ELF 401 target data. We don't need to adjust the symbol value for an 402 external symbol if we are producing relocatable output. */ 403 static bfd_reloc_status_type 404 score_elf_final_gp (bfd *output_bfd, 405 asymbol *symbol, 406 bfd_boolean relocatable, 407 char **error_message, 408 bfd_vma *pgp) 409 { 410 if (bfd_is_und_section (symbol->section) 411 && ! relocatable) 412 { 413 *pgp = 0; 414 return bfd_reloc_undefined; 415 } 416 417 *pgp = _bfd_get_gp_value (output_bfd); 418 if (*pgp == 0 419 && (! relocatable 420 || (symbol->flags & BSF_SECTION_SYM) != 0)) 421 { 422 if (relocatable) 423 { 424 /* Make up a value. */ 425 *pgp = symbol->section->output_section->vma + 0x4000; 426 _bfd_set_gp_value (output_bfd, *pgp); 427 } 428 else if (!score_elf_assign_gp (output_bfd, pgp)) 429 { 430 *error_message = 431 (char *) _("GP relative relocation when _gp not defined"); 432 return bfd_reloc_dangerous; 433 } 434 } 435 436 return bfd_reloc_ok; 437 } 438 439 static bfd_reloc_status_type 440 score_elf_gprel15_with_gp (bfd *abfd, 441 asymbol *symbol, 442 arelent *reloc_entry, 443 asection *input_section, 444 bfd_boolean relocateable, 445 void * data, 446 bfd_vma gp ATTRIBUTE_UNUSED) 447 { 448 bfd_vma relocation; 449 unsigned long insn; 450 451 if (bfd_is_com_section (symbol->section)) 452 relocation = 0; 453 else 454 relocation = symbol->value; 455 456 relocation += symbol->section->output_section->vma; 457 relocation += symbol->section->output_offset; 458 if (reloc_entry->address > input_section->size) 459 return bfd_reloc_outofrange; 460 461 insn = score_bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address); 462 if (((reloc_entry->addend & 0xffffc000) != 0) 463 && ((reloc_entry->addend & 0xffffc000) != 0xffffc000)) 464 return bfd_reloc_overflow; 465 466 insn = (insn & ~0x7fff) | (reloc_entry->addend & 0x7fff); 467 score_bfd_put_32 (abfd, insn, (bfd_byte *) data + reloc_entry->address); 468 if (relocateable) 469 reloc_entry->address += input_section->output_offset; 470 471 return bfd_reloc_ok; 472 } 473 474 static bfd_reloc_status_type 475 gprel32_with_gp (bfd *abfd, asymbol *symbol, arelent *reloc_entry, 476 asection *input_section, bfd_boolean relocatable, 477 void *data, bfd_vma gp) 478 { 479 bfd_vma relocation; 480 bfd_vma val; 481 482 if (bfd_is_com_section (symbol->section)) 483 relocation = 0; 484 else 485 relocation = symbol->value; 486 487 relocation += symbol->section->output_section->vma; 488 relocation += symbol->section->output_offset; 489 490 if (reloc_entry->address > bfd_get_section_limit (abfd, input_section)) 491 return bfd_reloc_outofrange; 492 493 /* Set val to the offset into the section or symbol. */ 494 val = reloc_entry->addend; 495 496 if (reloc_entry->howto->partial_inplace) 497 val += score_bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address); 498 499 /* Adjust val for the final section location and GP value. If we 500 are producing relocatable output, we don't want to do this for 501 an external symbol. */ 502 if (! relocatable 503 || (symbol->flags & BSF_SECTION_SYM) != 0) 504 val += relocation - gp; 505 506 if (reloc_entry->howto->partial_inplace) 507 score_bfd_put_32 (abfd, val, (bfd_byte *) data + reloc_entry->address); 508 else 509 reloc_entry->addend = val; 510 511 if (relocatable) 512 reloc_entry->address += input_section->output_offset; 513 514 return bfd_reloc_ok; 515 } 516 517 static bfd_reloc_status_type 518 score_elf_gprel15_reloc (bfd *abfd, 519 arelent *reloc_entry, 520 asymbol *symbol, 521 void * data, 522 asection *input_section, 523 bfd *output_bfd, 524 char **error_message) 525 { 526 bfd_boolean relocateable; 527 bfd_reloc_status_type ret; 528 bfd_vma gp; 529 530 if (output_bfd != NULL 531 && (symbol->flags & BSF_SECTION_SYM) == 0 && reloc_entry->addend == 0) 532 { 533 reloc_entry->address += input_section->output_offset; 534 return bfd_reloc_ok; 535 } 536 if (output_bfd != NULL) 537 relocateable = TRUE; 538 else 539 { 540 relocateable = FALSE; 541 output_bfd = symbol->section->output_section->owner; 542 } 543 544 ret = score_elf_final_gp (output_bfd, symbol, relocateable, error_message, &gp); 545 if (ret != bfd_reloc_ok) 546 return ret; 547 548 return score_elf_gprel15_with_gp (abfd, symbol, reloc_entry, 549 input_section, relocateable, data, gp); 550 } 551 552 /* Do a R_SCORE_GPREL32 relocation. This is a 32 bit value which must 553 become the offset from the gp register. */ 554 555 static bfd_reloc_status_type 556 score_elf_gprel32_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol, 557 void *data, asection *input_section, bfd *output_bfd, 558 char **error_message) 559 { 560 bfd_boolean relocatable; 561 bfd_reloc_status_type ret; 562 bfd_vma gp; 563 564 /* R_SCORE_GPREL32 relocations are defined for local symbols only. */ 565 if (output_bfd != NULL 566 && (symbol->flags & BSF_SECTION_SYM) == 0 567 && (symbol->flags & BSF_LOCAL) != 0) 568 { 569 *error_message = (char *) 570 _("32bits gp relative relocation occurs for an external symbol"); 571 return bfd_reloc_outofrange; 572 } 573 574 if (output_bfd != NULL) 575 relocatable = TRUE; 576 else 577 { 578 relocatable = FALSE; 579 output_bfd = symbol->section->output_section->owner; 580 } 581 582 ret = score_elf_final_gp (output_bfd, symbol, relocatable, error_message, &gp); 583 if (ret != bfd_reloc_ok) 584 return ret; 585 586 gp = 0; 587 return gprel32_with_gp (abfd, symbol, reloc_entry, input_section, 588 relocatable, data, gp); 589 } 590 591 /* A howto special_function for R_SCORE_GOT15 relocations. This is just 592 like any other 16-bit relocation when applied to global symbols, but is 593 treated in the same as R_SCORE_HI16 when applied to local symbols. */ 594 static bfd_reloc_status_type 595 score_elf_got15_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol, 596 void *data, asection *input_section, 597 bfd *output_bfd, char **error_message) 598 { 599 if ((symbol->flags & (BSF_GLOBAL | BSF_WEAK)) != 0 600 || bfd_is_und_section (bfd_get_section (symbol)) 601 || bfd_is_com_section (bfd_get_section (symbol))) 602 /* The relocation is against a global symbol. */ 603 return bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data, 604 input_section, output_bfd, 605 error_message); 606 607 return score_elf_hi16_reloc (abfd, reloc_entry, symbol, data, 608 input_section, output_bfd, error_message); 609 } 610 611 static bfd_reloc_status_type 612 score_elf_got_lo16_reloc (bfd *abfd, 613 arelent *reloc_entry, 614 asymbol *symbol ATTRIBUTE_UNUSED, 615 void * data, 616 asection *input_section, 617 bfd *output_bfd ATTRIBUTE_UNUSED, 618 char **error_message ATTRIBUTE_UNUSED) 619 { 620 bfd_vma addend = 0, offset = 0; 621 signed long val; 622 signed long hi16_offset, hi16_value, uvalue; 623 624 hi16_value = score_bfd_get_32 (abfd, hi16_rel_addr); 625 hi16_offset = ((((hi16_value >> 16) & 0x3) << 15) | (hi16_value & 0x7fff)) >> 1; 626 addend = score_bfd_get_32 (abfd, (bfd_byte *) data + reloc_entry->address); 627 offset = ((((addend >> 16) & 0x3) << 15) | (addend & 0x7fff)) >> 1; 628 val = reloc_entry->addend; 629 if (reloc_entry->address > input_section->size) 630 return bfd_reloc_outofrange; 631 uvalue = ((hi16_offset << 16) | (offset & 0xffff)) + val; 632 if ((uvalue > -0x8000) && (uvalue < 0x7fff)) 633 hi16_offset = 0; 634 else 635 hi16_offset = (uvalue >> 16) & 0x7fff; 636 hi16_value = (hi16_value & ~0x37fff) | (hi16_offset & 0x7fff) | ((hi16_offset << 1) & 0x30000); 637 score_bfd_put_32 (abfd, hi16_value, hi16_rel_addr); 638 offset = (uvalue & 0xffff) << 1; 639 addend = (addend & ~0x37fff) | (offset & 0x7fff) | ((offset << 1) & 0x30000); 640 score_bfd_put_32 (abfd, addend, (bfd_byte *) data + reloc_entry->address); 641 return bfd_reloc_ok; 642 } 643 644 static reloc_howto_type elf32_score_howto_table[] = 645 { 646 /* No relocation. */ 647 HOWTO (R_SCORE_NONE, /* type */ 648 0, /* rightshift */ 649 0, /* size (0 = byte, 1 = short, 2 = long) */ 650 0, /* bitsize */ 651 FALSE, /* pc_relative */ 652 0, /* bitpos */ 653 complain_overflow_dont,/* complain_on_overflow */ 654 bfd_elf_generic_reloc, /* special_function */ 655 "R_SCORE_NONE", /* name */ 656 FALSE, /* partial_inplace */ 657 0, /* src_mask */ 658 0, /* dst_mask */ 659 FALSE), /* pcrel_offset */ 660 661 /* R_SCORE_HI16 */ 662 HOWTO (R_SCORE_HI16, /* type */ 663 0, /* rightshift */ 664 2, /* size (0 = byte, 1 = short, 2 = long) */ 665 16, /* bitsize */ 666 FALSE, /* pc_relative */ 667 1, /* bitpos */ 668 complain_overflow_dont,/* complain_on_overflow */ 669 score_elf_hi16_reloc, /* special_function */ 670 "R_SCORE_HI16", /* name */ 671 TRUE, /* partial_inplace */ 672 0x37fff, /* src_mask */ 673 0x37fff, /* dst_mask */ 674 FALSE), /* pcrel_offset */ 675 676 /* R_SCORE_LO16 */ 677 HOWTO (R_SCORE_LO16, /* type */ 678 0, /* rightshift */ 679 2, /* size (0 = byte, 1 = short, 2 = long) */ 680 16, /* bitsize */ 681 FALSE, /* pc_relative */ 682 1, /* bitpos */ 683 complain_overflow_dont,/* complain_on_overflow */ 684 score_elf_lo16_reloc, /* special_function */ 685 "R_SCORE_LO16", /* name */ 686 TRUE, /* partial_inplace */ 687 0x37fff, /* src_mask */ 688 0x37fff, /* dst_mask */ 689 FALSE), /* pcrel_offset */ 690 691 /* R_SCORE_BCMP */ 692 HOWTO (R_SCORE_BCMP, /* type */ 693 1, /* rightshift */ 694 2, /* size (0 = byte, 1 = short, 2 = long) */ 695 16, /* bitsize */ 696 TRUE, /* pc_relative */ 697 1, /* bitpos */ 698 complain_overflow_dont,/* complain_on_overflow */ 699 bfd_elf_generic_reloc, /* special_function */ 700 "R_SCORE_BCMP", /* name */ 701 FALSE, /* partial_inplace */ 702 0x03e00381, /* src_mask */ 703 0x03e00381, /* dst_mask */ 704 FALSE), /* pcrel_offset */ 705 706 /*R_SCORE_24 */ 707 HOWTO (R_SCORE_24, /* type */ 708 1, /* rightshift */ 709 2, /* size (0 = byte, 1 = short, 2 = long) */ 710 24, /* bitsize */ 711 FALSE, /* pc_relative */ 712 1, /* bitpos */ 713 complain_overflow_dont,/* complain_on_overflow */ 714 bfd_elf_generic_reloc, /* special_function */ 715 "R_SCORE_24", /* name */ 716 FALSE, /* partial_inplace */ 717 0x3ff7fff, /* src_mask */ 718 0x3ff7fff, /* dst_mask */ 719 FALSE), /* pcrel_offset */ 720 721 /*R_SCORE_PC19 */ 722 HOWTO (R_SCORE_PC19, /* type */ 723 1, /* rightshift */ 724 2, /* size (0 = byte, 1 = short, 2 = long) */ 725 19, /* bitsize */ 726 TRUE, /* pc_relative */ 727 1, /* bitpos */ 728 complain_overflow_dont,/* complain_on_overflow */ 729 bfd_elf_generic_reloc, /* special_function */ 730 "R_SCORE_PC19", /* name */ 731 FALSE, /* partial_inplace */ 732 0x3ff03fe, /* src_mask */ 733 0x3ff03fe, /* dst_mask */ 734 FALSE), /* pcrel_offset */ 735 736 /*R_SCORE16_11 */ 737 HOWTO (R_SCORE16_11, /* type */ 738 1, /* rightshift */ 739 1, /* size (0 = byte, 1 = short, 2 = long) */ 740 11, /* bitsize */ 741 FALSE, /* pc_relative */ 742 1, /* bitpos */ 743 complain_overflow_dont,/* complain_on_overflow */ 744 bfd_elf_generic_reloc, /* special_function */ 745 "R_SCORE16_11", /* name */ 746 FALSE, /* partial_inplace */ 747 0x000000ffe, /* src_mask */ 748 0x000000ffe, /* dst_mask */ 749 FALSE), /* pcrel_offset */ 750 751 /* R_SCORE16_PC8 */ 752 HOWTO (R_SCORE16_PC8, /* type */ 753 1, /* rightshift */ 754 1, /* size (0 = byte, 1 = short, 2 = long) */ 755 9, /* bitsize */ 756 TRUE, /* pc_relative */ 757 0, /* bitpos */ 758 complain_overflow_dont,/* complain_on_overflow */ 759 bfd_elf_generic_reloc, /* special_function */ 760 "R_SCORE16_PC8", /* name */ 761 FALSE, /* partial_inplace */ 762 0x000001ff, /* src_mask */ 763 0x000001ff, /* dst_mask */ 764 FALSE), /* pcrel_offset */ 765 766 /* 32 bit absolute */ 767 HOWTO (R_SCORE_ABS32, /* type 8 */ 768 0, /* rightshift */ 769 2, /* size (0 = byte, 1 = short, 2 = long) */ 770 32, /* bitsize */ 771 FALSE, /* pc_relative */ 772 0, /* bitpos */ 773 complain_overflow_bitfield, /* complain_on_overflow */ 774 bfd_elf_generic_reloc, /* special_function */ 775 "R_SCORE_ABS32", /* name */ 776 FALSE, /* partial_inplace */ 777 0xffffffff, /* src_mask */ 778 0xffffffff, /* dst_mask */ 779 FALSE), /* pcrel_offset */ 780 781 /* 16 bit absolute */ 782 HOWTO (R_SCORE_ABS16, /* type 11 */ 783 0, /* rightshift */ 784 1, /* size (0 = byte, 1 = short, 2 = long) */ 785 16, /* bitsize */ 786 FALSE, /* pc_relative */ 787 0, /* bitpos */ 788 complain_overflow_bitfield, /* complain_on_overflow */ 789 bfd_elf_generic_reloc, /* special_function */ 790 "R_SCORE_ABS16", /* name */ 791 FALSE, /* partial_inplace */ 792 0x0000ffff, /* src_mask */ 793 0x0000ffff, /* dst_mask */ 794 FALSE), /* pcrel_offset */ 795 796 /* R_SCORE_DUMMY2 */ 797 HOWTO (R_SCORE_DUMMY2, /* type */ 798 0, /* rightshift */ 799 2, /* size (0 = byte, 1 = short, 2 = long) */ 800 16, /* bitsize */ 801 FALSE, /* pc_relative */ 802 0, /* bitpos */ 803 complain_overflow_dont,/* complain_on_overflow */ 804 bfd_elf_generic_reloc, /* special_function */ 805 "R_SCORE_DUMMY2", /* name */ 806 TRUE, /* partial_inplace */ 807 0x00007fff, /* src_mask */ 808 0x00007fff, /* dst_mask */ 809 FALSE), /* pcrel_offset */ 810 811 /* R_SCORE_GP15 */ 812 HOWTO (R_SCORE_GP15, /* type */ 813 0, /* rightshift */ 814 2, /* size (0 = byte, 1 = short, 2 = long) */ 815 16, /* bitsize */ 816 FALSE, /* pc_relative */ 817 0, /* bitpos */ 818 complain_overflow_dont,/* complain_on_overflow */ 819 score_elf_gprel15_reloc,/* special_function */ 820 "R_SCORE_GP15", /* name */ 821 TRUE, /* partial_inplace */ 822 0x00007fff, /* src_mask */ 823 0x00007fff, /* dst_mask */ 824 FALSE), /* pcrel_offset */ 825 826 /* GNU extension to record C++ vtable hierarchy. */ 827 HOWTO (R_SCORE_GNU_VTINHERIT, /* type */ 828 0, /* rightshift */ 829 2, /* size (0 = byte, 1 = short, 2 = long) */ 830 0, /* bitsize */ 831 FALSE, /* pc_relative */ 832 0, /* bitpos */ 833 complain_overflow_dont,/* complain_on_overflow */ 834 NULL, /* special_function */ 835 "R_SCORE_GNU_VTINHERIT", /* name */ 836 FALSE, /* partial_inplace */ 837 0, /* src_mask */ 838 0, /* dst_mask */ 839 FALSE), /* pcrel_offset */ 840 841 /* GNU extension to record C++ vtable member usage */ 842 HOWTO (R_SCORE_GNU_VTENTRY, /* type */ 843 0, /* rightshift */ 844 2, /* size (0 = byte, 1 = short, 2 = long) */ 845 0, /* bitsize */ 846 FALSE, /* pc_relative */ 847 0, /* bitpos */ 848 complain_overflow_dont,/* complain_on_overflow */ 849 _bfd_elf_rel_vtable_reloc_fn, /* special_function */ 850 "R_SCORE_GNU_VTENTRY", /* name */ 851 FALSE, /* partial_inplace */ 852 0, /* src_mask */ 853 0, /* dst_mask */ 854 FALSE), /* pcrel_offset */ 855 856 /* Reference to global offset table. */ 857 HOWTO (R_SCORE_GOT15, /* type */ 858 0, /* rightshift */ 859 2, /* size (0 = byte, 1 = short, 2 = long) */ 860 16, /* bitsize */ 861 FALSE, /* pc_relative */ 862 0, /* bitpos */ 863 complain_overflow_signed, /* complain_on_overflow */ 864 score_elf_got15_reloc, /* special_function */ 865 "R_SCORE_GOT15", /* name */ 866 TRUE, /* partial_inplace */ 867 0x00007fff, /* src_mask */ 868 0x00007fff, /* dst_mask */ 869 FALSE), /* pcrel_offset */ 870 871 /* Low 16 bits of displacement in global offset table. */ 872 HOWTO (R_SCORE_GOT_LO16, /* type */ 873 0, /* rightshift */ 874 2, /* size (0 = byte, 1 = short, 2 = long) */ 875 16, /* bitsize */ 876 FALSE, /* pc_relative */ 877 1, /* bitpos */ 878 complain_overflow_dont,/* complain_on_overflow */ 879 score_elf_got_lo16_reloc, /* special_function */ 880 "R_SCORE_GOT_LO16", /* name */ 881 TRUE, /* partial_inplace */ 882 0x37ffe, /* src_mask */ 883 0x37ffe, /* dst_mask */ 884 FALSE), /* pcrel_offset */ 885 886 /* 15 bit call through global offset table. */ 887 HOWTO (R_SCORE_CALL15, /* type */ 888 0, /* rightshift */ 889 2, /* size (0 = byte, 1 = short, 2 = long) */ 890 16, /* bitsize */ 891 FALSE, /* pc_relative */ 892 0, /* bitpos */ 893 complain_overflow_signed, /* complain_on_overflow */ 894 bfd_elf_generic_reloc, /* special_function */ 895 "R_SCORE_CALL15", /* name */ 896 TRUE, /* partial_inplace */ 897 0x0000ffff, /* src_mask */ 898 0x0000ffff, /* dst_mask */ 899 FALSE), /* pcrel_offset */ 900 901 /* 32 bit GP relative reference. */ 902 HOWTO (R_SCORE_GPREL32, /* type */ 903 0, /* rightshift */ 904 2, /* size (0 = byte, 1 = short, 2 = long) */ 905 32, /* bitsize */ 906 FALSE, /* pc_relative */ 907 0, /* bitpos */ 908 complain_overflow_dont,/* complain_on_overflow */ 909 score_elf_gprel32_reloc, /* special_function */ 910 "R_SCORE_GPREL32", /* name */ 911 TRUE, /* partial_inplace */ 912 0xffffffff, /* src_mask */ 913 0xffffffff, /* dst_mask */ 914 FALSE), /* pcrel_offset */ 915 916 /* 32 bit symbol relative relocation. */ 917 HOWTO (R_SCORE_REL32, /* type */ 918 0, /* rightshift */ 919 2, /* size (0 = byte, 1 = short, 2 = long) */ 920 32, /* bitsize */ 921 FALSE, /* pc_relative */ 922 0, /* bitpos */ 923 complain_overflow_dont,/* complain_on_overflow */ 924 bfd_elf_generic_reloc, /* special_function */ 925 "R_SCORE_REL32", /* name */ 926 TRUE, /* partial_inplace */ 927 0xffffffff, /* src_mask */ 928 0xffffffff, /* dst_mask */ 929 FALSE), /* pcrel_offset */ 930 931 /* R_SCORE_DUMMY_HI16 */ 932 HOWTO (R_SCORE_DUMMY_HI16, /* type */ 933 0, /* rightshift */ 934 2, /* size (0 = byte, 1 = short, 2 = long) */ 935 16, /* bitsize */ 936 FALSE, /* pc_relative */ 937 1, /* bitpos */ 938 complain_overflow_dont,/* complain_on_overflow */ 939 score_elf_hi16_reloc, /* special_function */ 940 "R_SCORE_DUMMY_HI16", /* name */ 941 TRUE, /* partial_inplace */ 942 0x37fff, /* src_mask */ 943 0x37fff, /* dst_mask */ 944 FALSE), /* pcrel_offset */ 945 946 /* R_SCORE_IMM30 */ 947 HOWTO (R_SCORE_IMM30, /* type */ 948 2, /* rightshift */ 949 2, /* size (0 = byte, 1 = short, 2 = long) */ 950 30, /* bitsize */ 951 FALSE, /* pc_relative */ 952 7, /* bitpos */ 953 complain_overflow_dont,/* complain_on_overflow */ 954 bfd_elf_generic_reloc, /* special_function */ 955 "R_SCORE_IMM30", /* name */ 956 FALSE, /* partial_inplace */ 957 0x7f7fff7f80LL, /* src_mask */ 958 0x7f7fff7f80LL, /* dst_mask */ 959 FALSE), /* pcrel_offset */ 960 961 /* R_SCORE_IMM32 */ 962 HOWTO (R_SCORE_IMM32, /* type */ 963 0, /* rightshift */ 964 2, /* size (0 = byte, 1 = short, 2 = long) */ 965 32, /* bitsize */ 966 FALSE, /* pc_relative */ 967 5, /* bitpos */ 968 complain_overflow_dont,/* complain_on_overflow */ 969 bfd_elf_generic_reloc, /* special_function */ 970 "R_SCORE_IMM32", /* name */ 971 FALSE, /* partial_inplace */ 972 0x7f7fff7fe0LL, /* src_mask */ 973 0x7f7fff7fe0LL, /* dst_mask */ 974 FALSE), /* pcrel_offset */ 975 }; 976 977 struct score_reloc_map 978 { 979 bfd_reloc_code_real_type bfd_reloc_val; 980 unsigned char elf_reloc_val; 981 }; 982 983 static const struct score_reloc_map elf32_score_reloc_map[] = 984 { 985 {BFD_RELOC_NONE, R_SCORE_NONE}, 986 {BFD_RELOC_HI16_S, R_SCORE_HI16}, 987 {BFD_RELOC_LO16, R_SCORE_LO16}, 988 {BFD_RELOC_SCORE_BCMP, R_SCORE_BCMP}, 989 {BFD_RELOC_SCORE_JMP, R_SCORE_24}, 990 {BFD_RELOC_SCORE_BRANCH, R_SCORE_PC19}, 991 {BFD_RELOC_SCORE16_JMP, R_SCORE16_11}, 992 {BFD_RELOC_SCORE16_BRANCH, R_SCORE16_PC8}, 993 {BFD_RELOC_32, R_SCORE_ABS32}, 994 {BFD_RELOC_16, R_SCORE_ABS16}, 995 {BFD_RELOC_SCORE_DUMMY2, R_SCORE_DUMMY2}, 996 {BFD_RELOC_SCORE_GPREL15, R_SCORE_GP15}, 997 {BFD_RELOC_VTABLE_INHERIT, R_SCORE_GNU_VTINHERIT}, 998 {BFD_RELOC_VTABLE_ENTRY, R_SCORE_GNU_VTENTRY}, 999 {BFD_RELOC_SCORE_GOT15, R_SCORE_GOT15}, 1000 {BFD_RELOC_SCORE_GOT_LO16, R_SCORE_GOT_LO16}, 1001 {BFD_RELOC_SCORE_CALL15, R_SCORE_CALL15}, 1002 {BFD_RELOC_GPREL32, R_SCORE_GPREL32}, 1003 {BFD_RELOC_32_PCREL, R_SCORE_REL32}, 1004 {BFD_RELOC_SCORE_DUMMY_HI16, R_SCORE_DUMMY_HI16}, 1005 {BFD_RELOC_SCORE_IMM30, R_SCORE_IMM30}, 1006 {BFD_RELOC_SCORE_IMM32, R_SCORE_IMM32}, 1007 }; 1008 1009 /* got_entries only match if they're identical, except for gotidx, so 1010 use all fields to compute the hash, and compare the appropriate 1011 union members. */ 1012 static hashval_t 1013 score_elf_got_entry_hash (const void *entry_) 1014 { 1015 const struct score_got_entry *entry = (struct score_got_entry *)entry_; 1016 1017 return entry->symndx 1018 + (!entry->abfd ? entry->d.address : entry->abfd->id); 1019 } 1020 1021 static int 1022 score_elf_got_entry_eq (const void *entry1, const void *entry2) 1023 { 1024 const struct score_got_entry *e1 = (struct score_got_entry *)entry1; 1025 const struct score_got_entry *e2 = (struct score_got_entry *)entry2; 1026 1027 return e1->abfd == e2->abfd && e1->symndx == e2->symndx 1028 && (! e1->abfd ? e1->d.address == e2->d.address 1029 : e1->symndx >= 0 ? e1->d.addend == e2->d.addend 1030 : e1->d.h == e2->d.h); 1031 } 1032 1033 /* If H needs a GOT entry, assign it the highest available dynamic 1034 index. Otherwise, assign it the lowest available dynamic 1035 index. */ 1036 static bfd_boolean 1037 score_elf_sort_hash_table_f (struct score_elf_link_hash_entry *h, void *data) 1038 { 1039 struct score_elf_hash_sort_data *hsd = data; 1040 1041 /* Symbols without dynamic symbol table entries aren't interesting at all. */ 1042 if (h->root.dynindx == -1) 1043 return TRUE; 1044 1045 /* Global symbols that need GOT entries that are not explicitly 1046 referenced are marked with got offset 2. Those that are 1047 referenced get a 1, and those that don't need GOT entries get 1048 -1. */ 1049 if (h->root.got.offset == 2) 1050 { 1051 if (hsd->max_unref_got_dynindx == hsd->min_got_dynindx) 1052 hsd->low = (struct elf_link_hash_entry *) h; 1053 h->root.dynindx = hsd->max_unref_got_dynindx++; 1054 } 1055 else if (h->root.got.offset != 1) 1056 h->root.dynindx = hsd->max_non_got_dynindx++; 1057 else 1058 { 1059 h->root.dynindx = --hsd->min_got_dynindx; 1060 hsd->low = (struct elf_link_hash_entry *) h; 1061 } 1062 1063 return TRUE; 1064 } 1065 1066 static asection * 1067 score_elf_got_section (bfd *abfd, bfd_boolean maybe_excluded) 1068 { 1069 asection *sgot = bfd_get_linker_section (abfd, ".got"); 1070 1071 if (sgot == NULL || (! maybe_excluded && (sgot->flags & SEC_EXCLUDE) != 0)) 1072 return NULL; 1073 return sgot; 1074 } 1075 1076 /* Returns the GOT information associated with the link indicated by 1077 INFO. If SGOTP is non-NULL, it is filled in with the GOT section. */ 1078 static struct score_got_info * 1079 score_elf_got_info (bfd *abfd, asection **sgotp) 1080 { 1081 asection *sgot; 1082 struct score_got_info *g; 1083 1084 sgot = score_elf_got_section (abfd, TRUE); 1085 BFD_ASSERT (sgot != NULL); 1086 BFD_ASSERT (elf_section_data (sgot) != NULL); 1087 g = score_elf_section_data (sgot)->u.got_info; 1088 BFD_ASSERT (g != NULL); 1089 1090 if (sgotp) 1091 *sgotp = sgot; 1092 return g; 1093 } 1094 1095 /* Sort the dynamic symbol table so that symbols that need GOT entries 1096 appear towards the end. This reduces the amount of GOT space 1097 required. MAX_LOCAL is used to set the number of local symbols 1098 known to be in the dynamic symbol table. During 1099 s3_bfd_score_elf_size_dynamic_sections, this value is 1. Afterward, the 1100 section symbols are added and the count is higher. */ 1101 static bfd_boolean 1102 score_elf_sort_hash_table (struct bfd_link_info *info, 1103 unsigned long max_local) 1104 { 1105 struct score_elf_hash_sort_data hsd; 1106 struct score_got_info *g; 1107 bfd *dynobj; 1108 1109 dynobj = elf_hash_table (info)->dynobj; 1110 1111 g = score_elf_got_info (dynobj, NULL); 1112 1113 hsd.low = NULL; 1114 hsd.max_unref_got_dynindx = 1115 hsd.min_got_dynindx = elf_hash_table (info)->dynsymcount 1116 /* In the multi-got case, assigned_gotno of the master got_info 1117 indicate the number of entries that aren't referenced in the 1118 primary GOT, but that must have entries because there are 1119 dynamic relocations that reference it. Since they aren't 1120 referenced, we move them to the end of the GOT, so that they 1121 don't prevent other entries that are referenced from getting 1122 too large offsets. */ 1123 - (g->next ? g->assigned_gotno : 0); 1124 hsd.max_non_got_dynindx = max_local; 1125 score_elf_link_hash_traverse (elf_hash_table (info), 1126 score_elf_sort_hash_table_f, 1127 &hsd); 1128 1129 /* There should have been enough room in the symbol table to 1130 accommodate both the GOT and non-GOT symbols. */ 1131 BFD_ASSERT (hsd.max_non_got_dynindx <= hsd.min_got_dynindx); 1132 BFD_ASSERT ((unsigned long)hsd.max_unref_got_dynindx 1133 <= elf_hash_table (info)->dynsymcount); 1134 1135 /* Now we know which dynamic symbol has the lowest dynamic symbol 1136 table index in the GOT. */ 1137 g->global_gotsym = hsd.low; 1138 1139 return TRUE; 1140 } 1141 1142 /* Create an entry in an score ELF linker hash table. */ 1143 1144 static struct bfd_hash_entry * 1145 score_elf_link_hash_newfunc (struct bfd_hash_entry *entry, 1146 struct bfd_hash_table *table, 1147 const char *string) 1148 { 1149 struct score_elf_link_hash_entry *ret = (struct score_elf_link_hash_entry *) entry; 1150 1151 /* Allocate the structure if it has not already been allocated by a subclass. */ 1152 if (ret == NULL) 1153 ret = bfd_hash_allocate (table, sizeof (struct score_elf_link_hash_entry)); 1154 if (ret == NULL) 1155 return (struct bfd_hash_entry *) ret; 1156 1157 /* Call the allocation method of the superclass. */ 1158 ret = ((struct score_elf_link_hash_entry *) 1159 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret, table, string)); 1160 1161 if (ret != NULL) 1162 { 1163 ret->possibly_dynamic_relocs = 0; 1164 ret->readonly_reloc = FALSE; 1165 ret->no_fn_stub = FALSE; 1166 ret->forced_local = FALSE; 1167 } 1168 1169 return (struct bfd_hash_entry *) ret; 1170 } 1171 1172 /* Returns the first relocation of type r_type found, beginning with 1173 RELOCATION. RELEND is one-past-the-end of the relocation table. */ 1174 static const Elf_Internal_Rela * 1175 score_elf_next_relocation (bfd *abfd ATTRIBUTE_UNUSED, unsigned int r_type, 1176 const Elf_Internal_Rela *relocation, 1177 const Elf_Internal_Rela *relend) 1178 { 1179 while (relocation < relend) 1180 { 1181 if (ELF32_R_TYPE (relocation->r_info) == r_type) 1182 return relocation; 1183 1184 ++relocation; 1185 } 1186 1187 /* We didn't find it. */ 1188 bfd_set_error (bfd_error_bad_value); 1189 return NULL; 1190 } 1191 1192 /* This function is called via qsort() to sort the dynamic relocation 1193 entries by increasing r_symndx value. */ 1194 static int 1195 score_elf_sort_dynamic_relocs (const void *arg1, const void *arg2) 1196 { 1197 Elf_Internal_Rela int_reloc1; 1198 Elf_Internal_Rela int_reloc2; 1199 1200 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd, arg1, &int_reloc1); 1201 bfd_elf32_swap_reloc_in (reldyn_sorting_bfd, arg2, &int_reloc2); 1202 1203 return (ELF32_R_SYM (int_reloc1.r_info) - ELF32_R_SYM (int_reloc2.r_info)); 1204 } 1205 1206 /* Return whether a relocation is against a local symbol. */ 1207 static bfd_boolean 1208 score_elf_local_relocation_p (bfd *input_bfd, 1209 const Elf_Internal_Rela *relocation, 1210 asection **local_sections, 1211 bfd_boolean check_forced) 1212 { 1213 unsigned long r_symndx; 1214 Elf_Internal_Shdr *symtab_hdr; 1215 struct score_elf_link_hash_entry *h; 1216 size_t extsymoff; 1217 1218 r_symndx = ELF32_R_SYM (relocation->r_info); 1219 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 1220 extsymoff = (elf_bad_symtab (input_bfd)) ? 0 : symtab_hdr->sh_info; 1221 1222 if (r_symndx < extsymoff) 1223 return TRUE; 1224 if (elf_bad_symtab (input_bfd) && local_sections[r_symndx] != NULL) 1225 return TRUE; 1226 1227 if (check_forced) 1228 { 1229 /* Look up the hash table to check whether the symbol was forced local. */ 1230 h = (struct score_elf_link_hash_entry *) 1231 elf_sym_hashes (input_bfd) [r_symndx - extsymoff]; 1232 /* Find the real hash-table entry for this symbol. */ 1233 while (h->root.root.type == bfd_link_hash_indirect 1234 || h->root.root.type == bfd_link_hash_warning) 1235 h = (struct score_elf_link_hash_entry *) h->root.root.u.i.link; 1236 if (h->root.forced_local) 1237 return TRUE; 1238 } 1239 1240 return FALSE; 1241 } 1242 1243 /* Returns the dynamic relocation section for DYNOBJ. */ 1244 static asection * 1245 score_elf_rel_dyn_section (bfd *dynobj, bfd_boolean create_p) 1246 { 1247 static const char dname[] = ".rel.dyn"; 1248 asection *sreloc; 1249 1250 sreloc = bfd_get_linker_section (dynobj, dname); 1251 if (sreloc == NULL && create_p) 1252 { 1253 sreloc = bfd_make_section_anyway_with_flags (dynobj, dname, 1254 (SEC_ALLOC 1255 | SEC_LOAD 1256 | SEC_HAS_CONTENTS 1257 | SEC_IN_MEMORY 1258 | SEC_LINKER_CREATED 1259 | SEC_READONLY)); 1260 if (sreloc == NULL 1261 || ! bfd_set_section_alignment (dynobj, sreloc, 1262 SCORE_ELF_LOG_FILE_ALIGN (dynobj))) 1263 return NULL; 1264 } 1265 return sreloc; 1266 } 1267 1268 static void 1269 score_elf_allocate_dynamic_relocations (bfd *abfd, unsigned int n) 1270 { 1271 asection *s; 1272 1273 s = score_elf_rel_dyn_section (abfd, FALSE); 1274 BFD_ASSERT (s != NULL); 1275 1276 if (s->size == 0) 1277 { 1278 /* Make room for a null element. */ 1279 s->size += SCORE_ELF_REL_SIZE (abfd); 1280 ++s->reloc_count; 1281 } 1282 s->size += n * SCORE_ELF_REL_SIZE (abfd); 1283 } 1284 1285 /* Create a rel.dyn relocation for the dynamic linker to resolve. REL 1286 is the original relocation, which is now being transformed into a 1287 dynamic relocation. The ADDENDP is adjusted if necessary; the 1288 caller should store the result in place of the original addend. */ 1289 static bfd_boolean 1290 score_elf_create_dynamic_relocation (bfd *output_bfd, 1291 struct bfd_link_info *info, 1292 const Elf_Internal_Rela *rel, 1293 struct score_elf_link_hash_entry *h, 1294 bfd_vma symbol, 1295 bfd_vma *addendp, asection *input_section) 1296 { 1297 Elf_Internal_Rela outrel[3]; 1298 asection *sreloc; 1299 bfd *dynobj; 1300 int r_type; 1301 long indx; 1302 bfd_boolean defined_p; 1303 1304 r_type = ELF32_R_TYPE (rel->r_info); 1305 dynobj = elf_hash_table (info)->dynobj; 1306 sreloc = score_elf_rel_dyn_section (dynobj, FALSE); 1307 BFD_ASSERT (sreloc != NULL); 1308 BFD_ASSERT (sreloc->contents != NULL); 1309 BFD_ASSERT (sreloc->reloc_count * SCORE_ELF_REL_SIZE (output_bfd) < sreloc->size); 1310 1311 outrel[0].r_offset = 1312 _bfd_elf_section_offset (output_bfd, info, input_section, rel[0].r_offset); 1313 outrel[1].r_offset = 1314 _bfd_elf_section_offset (output_bfd, info, input_section, rel[1].r_offset); 1315 outrel[2].r_offset = 1316 _bfd_elf_section_offset (output_bfd, info, input_section, rel[2].r_offset); 1317 1318 if (outrel[0].r_offset == MINUS_ONE) 1319 /* The relocation field has been deleted. */ 1320 return TRUE; 1321 1322 if (outrel[0].r_offset == MINUS_TWO) 1323 { 1324 /* The relocation field has been converted into a relative value of 1325 some sort. Functions like _bfd_elf_write_section_eh_frame expect 1326 the field to be fully relocated, so add in the symbol's value. */ 1327 *addendp += symbol; 1328 return TRUE; 1329 } 1330 1331 /* We must now calculate the dynamic symbol table index to use 1332 in the relocation. */ 1333 if (h != NULL 1334 && (! info->symbolic || !h->root.def_regular) 1335 /* h->root.dynindx may be -1 if this symbol was marked to 1336 become local. */ 1337 && h->root.dynindx != -1) 1338 { 1339 indx = h->root.dynindx; 1340 /* ??? glibc's ld.so just adds the final GOT entry to the 1341 relocation field. It therefore treats relocs against 1342 defined symbols in the same way as relocs against 1343 undefined symbols. */ 1344 defined_p = FALSE; 1345 } 1346 else 1347 { 1348 indx = 0; 1349 defined_p = TRUE; 1350 } 1351 1352 /* If the relocation was previously an absolute relocation and 1353 this symbol will not be referred to by the relocation, we must 1354 adjust it by the value we give it in the dynamic symbol table. 1355 Otherwise leave the job up to the dynamic linker. */ 1356 if (defined_p && r_type != R_SCORE_REL32) 1357 *addendp += symbol; 1358 1359 /* The relocation is always an REL32 relocation because we don't 1360 know where the shared library will wind up at load-time. */ 1361 outrel[0].r_info = ELF32_R_INFO ((unsigned long) indx, R_SCORE_REL32); 1362 1363 /* For strict adherence to the ABI specification, we should 1364 generate a R_SCORE_64 relocation record by itself before the 1365 _REL32/_64 record as well, such that the addend is read in as 1366 a 64-bit value (REL32 is a 32-bit relocation, after all). 1367 However, since none of the existing ELF64 SCORE dynamic 1368 loaders seems to care, we don't waste space with these 1369 artificial relocations. If this turns out to not be true, 1370 score_elf_allocate_dynamic_relocations() should be tweaked so 1371 as to make room for a pair of dynamic relocations per 1372 invocation if ABI_64_P, and here we should generate an 1373 additional relocation record with R_SCORE_64 by itself for a 1374 NULL symbol before this relocation record. */ 1375 outrel[1].r_info = ELF32_R_INFO (0, R_SCORE_NONE); 1376 outrel[2].r_info = ELF32_R_INFO (0, R_SCORE_NONE); 1377 1378 /* Adjust the output offset of the relocation to reference the 1379 correct location in the output file. */ 1380 outrel[0].r_offset += (input_section->output_section->vma 1381 + input_section->output_offset); 1382 outrel[1].r_offset += (input_section->output_section->vma 1383 + input_section->output_offset); 1384 outrel[2].r_offset += (input_section->output_section->vma 1385 + input_section->output_offset); 1386 1387 /* Put the relocation back out. We have to use the special 1388 relocation outputter in the 64-bit case since the 64-bit 1389 relocation format is non-standard. */ 1390 bfd_elf32_swap_reloc_out 1391 (output_bfd, &outrel[0], 1392 (sreloc->contents + sreloc->reloc_count * sizeof (Elf32_External_Rel))); 1393 1394 /* We've now added another relocation. */ 1395 ++sreloc->reloc_count; 1396 1397 /* Make sure the output section is writable. The dynamic linker 1398 will be writing to it. */ 1399 elf_section_data (input_section->output_section)->this_hdr.sh_flags |= SHF_WRITE; 1400 1401 return TRUE; 1402 } 1403 1404 static bfd_boolean 1405 score_elf_create_got_section (bfd *abfd, 1406 struct bfd_link_info *info, 1407 bfd_boolean maybe_exclude) 1408 { 1409 flagword flags; 1410 asection *s; 1411 struct elf_link_hash_entry *h; 1412 struct bfd_link_hash_entry *bh; 1413 struct score_got_info *g; 1414 bfd_size_type amt; 1415 1416 /* This function may be called more than once. */ 1417 s = score_elf_got_section (abfd, TRUE); 1418 if (s) 1419 { 1420 if (! maybe_exclude) 1421 s->flags &= ~SEC_EXCLUDE; 1422 return TRUE; 1423 } 1424 1425 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED); 1426 1427 if (maybe_exclude) 1428 flags |= SEC_EXCLUDE; 1429 1430 /* We have to use an alignment of 2**4 here because this is hardcoded 1431 in the function stub generation and in the linker script. */ 1432 s = bfd_make_section_anyway_with_flags (abfd, ".got", flags); 1433 if (s == NULL 1434 || ! bfd_set_section_alignment (abfd, s, 4)) 1435 return FALSE; 1436 1437 /* Define the symbol _GLOBAL_OFFSET_TABLE_. We don't do this in the 1438 linker script because we don't want to define the symbol if we 1439 are not creating a global offset table. */ 1440 bh = NULL; 1441 if (! (_bfd_generic_link_add_one_symbol 1442 (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL, s, 1443 0, NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh))) 1444 return FALSE; 1445 1446 h = (struct elf_link_hash_entry *) bh; 1447 h->non_elf = 0; 1448 h->def_regular = 1; 1449 h->type = STT_OBJECT; 1450 1451 if (info->shared && ! bfd_elf_link_record_dynamic_symbol (info, h)) 1452 return FALSE; 1453 1454 amt = sizeof (struct score_got_info); 1455 g = bfd_alloc (abfd, amt); 1456 if (g == NULL) 1457 return FALSE; 1458 1459 g->global_gotsym = NULL; 1460 g->global_gotno = 0; 1461 1462 g->local_gotno = SCORE_RESERVED_GOTNO; 1463 g->assigned_gotno = SCORE_RESERVED_GOTNO; 1464 g->next = NULL; 1465 1466 g->got_entries = htab_try_create (1, score_elf_got_entry_hash, 1467 score_elf_got_entry_eq, NULL); 1468 if (g->got_entries == NULL) 1469 return FALSE; 1470 score_elf_section_data (s)->u.got_info = g; 1471 score_elf_section_data (s)->elf.this_hdr.sh_flags |= SHF_ALLOC | SHF_WRITE | SHF_SCORE_GPREL; 1472 1473 return TRUE; 1474 } 1475 1476 /* Calculate the %high function. */ 1477 static bfd_vma 1478 score_elf_high (bfd_vma value) 1479 { 1480 return ((value + (bfd_vma) 0x8000) >> 16) & 0xffff; 1481 } 1482 1483 /* Create a local GOT entry for VALUE. Return the index of the entry, 1484 or -1 if it could not be created. */ 1485 static struct score_got_entry * 1486 score_elf_create_local_got_entry (bfd *abfd, 1487 bfd *ibfd ATTRIBUTE_UNUSED, 1488 struct score_got_info *gg, 1489 asection *sgot, bfd_vma value, 1490 unsigned long r_symndx ATTRIBUTE_UNUSED, 1491 struct score_elf_link_hash_entry *h ATTRIBUTE_UNUSED, 1492 int r_type ATTRIBUTE_UNUSED) 1493 { 1494 struct score_got_entry entry, **loc; 1495 struct score_got_info *g; 1496 1497 entry.abfd = NULL; 1498 entry.symndx = -1; 1499 entry.d.address = value; 1500 1501 g = gg; 1502 loc = (struct score_got_entry **) htab_find_slot (g->got_entries, &entry, INSERT); 1503 if (*loc) 1504 return *loc; 1505 1506 entry.gotidx = SCORE_ELF_GOT_SIZE (abfd) * g->assigned_gotno++; 1507 1508 *loc = bfd_alloc (abfd, sizeof entry); 1509 1510 if (! *loc) 1511 return NULL; 1512 1513 memcpy (*loc, &entry, sizeof entry); 1514 1515 if (g->assigned_gotno >= g->local_gotno) 1516 { 1517 (*loc)->gotidx = -1; 1518 /* We didn't allocate enough space in the GOT. */ 1519 (*_bfd_error_handler) 1520 (_("not enough GOT space for local GOT entries")); 1521 bfd_set_error (bfd_error_bad_value); 1522 return NULL; 1523 } 1524 1525 score_bfd_put_32 (abfd, value, (sgot->contents + entry.gotidx)); 1526 1527 return *loc; 1528 } 1529 1530 /* Find a GOT entry whose higher-order 16 bits are the same as those 1531 for value. Return the index into the GOT for this entry. */ 1532 static bfd_vma 1533 score_elf_got16_entry (bfd *abfd, bfd *ibfd, struct bfd_link_info *info, 1534 bfd_vma value, bfd_boolean external) 1535 { 1536 asection *sgot; 1537 struct score_got_info *g; 1538 struct score_got_entry *entry; 1539 1540 if (!external) 1541 { 1542 /* Although the ABI says that it is "the high-order 16 bits" that we 1543 want, it is really the %high value. The complete value is 1544 calculated with a `addiu' of a LO16 relocation, just as with a 1545 HI16/LO16 pair. */ 1546 value = score_elf_high (value) << 16; 1547 } 1548 1549 g = score_elf_got_info (elf_hash_table (info)->dynobj, &sgot); 1550 1551 entry = score_elf_create_local_got_entry (abfd, ibfd, g, sgot, value, 0, NULL, 1552 R_SCORE_GOT15); 1553 if (entry) 1554 return entry->gotidx; 1555 else 1556 return MINUS_ONE; 1557 } 1558 1559 static void 1560 s3_bfd_score_elf_hide_symbol (struct bfd_link_info *info, 1561 struct elf_link_hash_entry *entry, 1562 bfd_boolean force_local) 1563 { 1564 bfd *dynobj; 1565 asection *got; 1566 struct score_got_info *g; 1567 struct score_elf_link_hash_entry *h; 1568 1569 h = (struct score_elf_link_hash_entry *) entry; 1570 if (h->forced_local) 1571 return; 1572 h->forced_local = TRUE; 1573 1574 dynobj = elf_hash_table (info)->dynobj; 1575 if (dynobj != NULL && force_local) 1576 { 1577 got = score_elf_got_section (dynobj, FALSE); 1578 if (got == NULL) 1579 return; 1580 g = score_elf_section_data (got)->u.got_info; 1581 1582 if (g->next) 1583 { 1584 struct score_got_entry e; 1585 struct score_got_info *gg = g; 1586 1587 /* Since we're turning what used to be a global symbol into a 1588 local one, bump up the number of local entries of each GOT 1589 that had an entry for it. This will automatically decrease 1590 the number of global entries, since global_gotno is actually 1591 the upper limit of global entries. */ 1592 e.abfd = dynobj; 1593 e.symndx = -1; 1594 e.d.h = h; 1595 1596 for (g = g->next; g != gg; g = g->next) 1597 if (htab_find (g->got_entries, &e)) 1598 { 1599 BFD_ASSERT (g->global_gotno > 0); 1600 g->local_gotno++; 1601 g->global_gotno--; 1602 } 1603 1604 /* If this was a global symbol forced into the primary GOT, we 1605 no longer need an entry for it. We can't release the entry 1606 at this point, but we must at least stop counting it as one 1607 of the symbols that required a forced got entry. */ 1608 if (h->root.got.offset == 2) 1609 { 1610 BFD_ASSERT (gg->assigned_gotno > 0); 1611 gg->assigned_gotno--; 1612 } 1613 } 1614 else if (g->global_gotno == 0 && g->global_gotsym == NULL) 1615 /* If we haven't got through GOT allocation yet, just bump up the 1616 number of local entries, as this symbol won't be counted as 1617 global. */ 1618 g->local_gotno++; 1619 else if (h->root.got.offset == 1) 1620 { 1621 /* If we're past non-multi-GOT allocation and this symbol had 1622 been marked for a global got entry, give it a local entry 1623 instead. */ 1624 BFD_ASSERT (g->global_gotno > 0); 1625 g->local_gotno++; 1626 g->global_gotno--; 1627 } 1628 } 1629 1630 _bfd_elf_link_hash_hide_symbol (info, &h->root, force_local); 1631 } 1632 1633 /* If H is a symbol that needs a global GOT entry, but has a dynamic 1634 symbol table index lower than any we've seen to date, record it for 1635 posterity. */ 1636 static bfd_boolean 1637 score_elf_record_global_got_symbol (struct elf_link_hash_entry *h, 1638 bfd *abfd, 1639 struct bfd_link_info *info, 1640 struct score_got_info *g) 1641 { 1642 struct score_got_entry entry, **loc; 1643 1644 /* A global symbol in the GOT must also be in the dynamic symbol table. */ 1645 if (h->dynindx == -1) 1646 { 1647 switch (ELF_ST_VISIBILITY (h->other)) 1648 { 1649 case STV_INTERNAL: 1650 case STV_HIDDEN: 1651 s3_bfd_score_elf_hide_symbol (info, h, TRUE); 1652 break; 1653 } 1654 if (!bfd_elf_link_record_dynamic_symbol (info, h)) 1655 return FALSE; 1656 } 1657 1658 entry.abfd = abfd; 1659 entry.symndx = -1; 1660 entry.d.h = (struct score_elf_link_hash_entry *)h; 1661 1662 loc = (struct score_got_entry **)htab_find_slot (g->got_entries, &entry, INSERT); 1663 1664 /* If we've already marked this entry as needing GOT space, we don't 1665 need to do it again. */ 1666 if (*loc) 1667 return TRUE; 1668 1669 *loc = bfd_alloc (abfd, sizeof entry); 1670 if (! *loc) 1671 return FALSE; 1672 1673 entry.gotidx = -1; 1674 1675 memcpy (*loc, &entry, sizeof (entry)); 1676 1677 if (h->got.offset != MINUS_ONE) 1678 return TRUE; 1679 1680 /* By setting this to a value other than -1, we are indicating that 1681 there needs to be a GOT entry for H. Avoid using zero, as the 1682 generic ELF copy_indirect_symbol tests for <= 0. */ 1683 h->got.offset = 1; 1684 1685 return TRUE; 1686 } 1687 1688 /* Reserve space in G for a GOT entry containing the value of symbol 1689 SYMNDX in input bfd ABDF, plus ADDEND. */ 1690 static bfd_boolean 1691 score_elf_record_local_got_symbol (bfd *abfd, 1692 long symndx, 1693 bfd_vma addend, 1694 struct score_got_info *g) 1695 { 1696 struct score_got_entry entry, **loc; 1697 1698 entry.abfd = abfd; 1699 entry.symndx = symndx; 1700 entry.d.addend = addend; 1701 loc = (struct score_got_entry **)htab_find_slot (g->got_entries, &entry, INSERT); 1702 1703 if (*loc) 1704 return TRUE; 1705 1706 entry.gotidx = g->local_gotno++; 1707 1708 *loc = bfd_alloc (abfd, sizeof(entry)); 1709 if (! *loc) 1710 return FALSE; 1711 1712 memcpy (*loc, &entry, sizeof (entry)); 1713 1714 return TRUE; 1715 } 1716 1717 /* Returns the GOT offset at which the indicated address can be found. 1718 If there is not yet a GOT entry for this value, create one. 1719 Returns -1 if no satisfactory GOT offset can be found. */ 1720 static bfd_vma 1721 score_elf_local_got_index (bfd *abfd, bfd *ibfd, struct bfd_link_info *info, 1722 bfd_vma value, unsigned long r_symndx, 1723 struct score_elf_link_hash_entry *h, int r_type) 1724 { 1725 asection *sgot; 1726 struct score_got_info *g; 1727 struct score_got_entry *entry; 1728 1729 g = score_elf_got_info (elf_hash_table (info)->dynobj, &sgot); 1730 1731 entry = score_elf_create_local_got_entry (abfd, ibfd, g, sgot, value, 1732 r_symndx, h, r_type); 1733 if (!entry) 1734 return MINUS_ONE; 1735 1736 else 1737 return entry->gotidx; 1738 } 1739 1740 /* Returns the GOT index for the global symbol indicated by H. */ 1741 1742 static bfd_vma 1743 score_elf_global_got_index (bfd *abfd, struct elf_link_hash_entry *h) 1744 { 1745 bfd_vma got_index; 1746 asection *sgot; 1747 struct score_got_info *g; 1748 long global_got_dynindx = 0; 1749 1750 g = score_elf_got_info (abfd, &sgot); 1751 if (g->global_gotsym != NULL) 1752 global_got_dynindx = g->global_gotsym->dynindx; 1753 1754 /* Once we determine the global GOT entry with the lowest dynamic 1755 symbol table index, we must put all dynamic symbols with greater 1756 indices into the GOT. That makes it easy to calculate the GOT 1757 offset. */ 1758 BFD_ASSERT (h->dynindx >= global_got_dynindx); 1759 got_index = ((h->dynindx - global_got_dynindx + g->local_gotno) * SCORE_ELF_GOT_SIZE (abfd)); 1760 BFD_ASSERT (got_index < sgot->size); 1761 1762 return got_index; 1763 } 1764 1765 /* Returns the offset for the entry at the INDEXth position in the GOT. */ 1766 1767 static bfd_vma 1768 score_elf_got_offset_from_index (bfd *dynobj, 1769 bfd *output_bfd, 1770 bfd *input_bfd ATTRIBUTE_UNUSED, 1771 bfd_vma got_index) 1772 { 1773 asection *sgot; 1774 bfd_vma gp; 1775 1776 score_elf_got_info (dynobj, &sgot); 1777 gp = _bfd_get_gp_value (output_bfd); 1778 1779 return sgot->output_section->vma + sgot->output_offset + got_index - gp; 1780 } 1781 1782 /* Follow indirect and warning hash entries so that each got entry 1783 points to the final symbol definition. P must point to a pointer 1784 to the hash table we're traversing. Since this traversal may 1785 modify the hash table, we set this pointer to NULL to indicate 1786 we've made a potentially-destructive change to the hash table, so 1787 the traversal must be restarted. */ 1788 static int 1789 score_elf_resolve_final_got_entry (void **entryp, void *p) 1790 { 1791 struct score_got_entry *entry = (struct score_got_entry *)*entryp; 1792 htab_t got_entries = *(htab_t *)p; 1793 1794 if (entry->abfd != NULL && entry->symndx == -1) 1795 { 1796 struct score_elf_link_hash_entry *h = entry->d.h; 1797 1798 while (h->root.root.type == bfd_link_hash_indirect 1799 || h->root.root.type == bfd_link_hash_warning) 1800 h = (struct score_elf_link_hash_entry *) h->root.root.u.i.link; 1801 1802 if (entry->d.h == h) 1803 return 1; 1804 1805 entry->d.h = h; 1806 1807 /* If we can't find this entry with the new bfd hash, re-insert 1808 it, and get the traversal restarted. */ 1809 if (! htab_find (got_entries, entry)) 1810 { 1811 htab_clear_slot (got_entries, entryp); 1812 entryp = htab_find_slot (got_entries, entry, INSERT); 1813 if (! *entryp) 1814 *entryp = entry; 1815 /* Abort the traversal, since the whole table may have 1816 moved, and leave it up to the parent to restart the 1817 process. */ 1818 *(htab_t *)p = NULL; 1819 return 0; 1820 } 1821 /* We might want to decrement the global_gotno count, but it's 1822 either too early or too late for that at this point. */ 1823 } 1824 1825 return 1; 1826 } 1827 1828 /* Turn indirect got entries in a got_entries table into their final locations. */ 1829 static void 1830 score_elf_resolve_final_got_entries (struct score_got_info *g) 1831 { 1832 htab_t got_entries; 1833 1834 do 1835 { 1836 got_entries = g->got_entries; 1837 1838 htab_traverse (got_entries, 1839 score_elf_resolve_final_got_entry, 1840 &got_entries); 1841 } 1842 while (got_entries == NULL); 1843 } 1844 1845 /* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS. for -r */ 1846 static void 1847 score_elf_add_to_rel (bfd *abfd, 1848 bfd_byte *address, 1849 reloc_howto_type *howto, 1850 bfd_signed_vma increment) 1851 { 1852 bfd_signed_vma addend; 1853 bfd_vma contents; 1854 unsigned long offset; 1855 unsigned long r_type = howto->type; 1856 unsigned long hi16_addend, hi16_offset, hi16_value, uvalue; 1857 1858 contents = score_bfd_get_32 (abfd, address); 1859 /* Get the (signed) value from the instruction. */ 1860 addend = contents & howto->src_mask; 1861 if (addend & ((howto->src_mask + 1) >> 1)) 1862 { 1863 bfd_signed_vma mask; 1864 1865 mask = -1; 1866 mask &= ~howto->src_mask; 1867 addend |= mask; 1868 } 1869 /* Add in the increment, (which is a byte value). */ 1870 switch (r_type) 1871 { 1872 case R_SCORE_PC19: 1873 offset = 1874 (((contents & howto->src_mask) & 0x3ff0000) >> 6) | ((contents & howto->src_mask) & 0x3ff); 1875 offset += increment; 1876 contents = 1877 (contents & ~howto-> 1878 src_mask) | (((offset << 6) & howto->src_mask) & 0x3ff0000) | (offset & 0x3ff); 1879 score_bfd_put_32 (abfd, contents, address); 1880 break; 1881 case R_SCORE_HI16: 1882 break; 1883 case R_SCORE_LO16: 1884 hi16_addend = score_bfd_get_32 (abfd, address - 4); 1885 hi16_offset = ((((hi16_addend >> 16) & 0x3) << 15) | (hi16_addend & 0x7fff)) >> 1; 1886 offset = ((((contents >> 16) & 0x3) << 15) | (contents & 0x7fff)) >> 1; 1887 offset = (hi16_offset << 16) | (offset & 0xffff); 1888 uvalue = increment + offset; 1889 hi16_offset = (uvalue >> 16) << 1; 1890 hi16_value = (hi16_addend & (~(howto->dst_mask))) 1891 | (hi16_offset & 0x7fff) | ((hi16_offset << 1) & 0x30000); 1892 score_bfd_put_32 (abfd, hi16_value, address - 4); 1893 offset = (uvalue & 0xffff) << 1; 1894 contents = (contents & (~(howto->dst_mask))) | (offset & 0x7fff) | ((offset << 1) & 0x30000); 1895 score_bfd_put_32 (abfd, contents, address); 1896 break; 1897 case R_SCORE_24: 1898 offset = 1899 (((contents & howto->src_mask) >> 1) & 0x1ff8000) | ((contents & howto->src_mask) & 0x7fff); 1900 offset += increment; 1901 contents = 1902 (contents & ~howto-> 1903 src_mask) | (((offset << 1) & howto->src_mask) & 0x3ff0000) | (offset & 0x7fff); 1904 score_bfd_put_32 (abfd, contents, address); 1905 break; 1906 1907 case R_SCORE16_11: 1908 1909 contents = score_bfd_get_16 (abfd, address); 1910 offset = contents & howto->src_mask; 1911 offset += increment; 1912 contents = (contents & ~howto->src_mask) | (offset & howto->src_mask); 1913 score_bfd_put_16 (abfd, contents, address); 1914 1915 break; 1916 case R_SCORE16_PC8: 1917 1918 contents = score_bfd_get_16 (abfd, address); 1919 offset = (contents & howto->src_mask) + ((increment >> 1) & 0x1ff); 1920 contents = (contents & (~howto->src_mask)) | (offset & howto->src_mask); 1921 score_bfd_put_16 (abfd, contents, address); 1922 1923 break; 1924 1925 case R_SCORE_BCMP: 1926 contents = score_bfd_get_32 (abfd, address); 1927 offset = (contents & howto->src_mask); 1928 offset <<= howto->rightshift; 1929 offset += increment; 1930 offset >>= howto->rightshift; 1931 contents = (contents & (~howto->src_mask)) | (offset & howto->src_mask); 1932 score_bfd_put_32 (abfd, contents, address); 1933 break; 1934 1935 case R_SCORE_IMM30: 1936 contents = score_bfd_get_48 (abfd, address); 1937 offset = (contents & howto->src_mask); 1938 offset <<= howto->rightshift; 1939 offset += increment; 1940 offset >>= howto->rightshift; 1941 contents = (contents & (~howto->src_mask)) | (offset & howto->src_mask); 1942 score_bfd_put_48 (abfd, contents, address); 1943 break; 1944 1945 case R_SCORE_IMM32: 1946 contents = score_bfd_get_48 (abfd, address); 1947 offset = (contents & howto->src_mask); 1948 offset += increment; 1949 contents = (contents & (~howto->src_mask)) | (offset & howto->src_mask); 1950 score_bfd_put_48 (abfd, contents, address); 1951 break; 1952 1953 default: 1954 addend += increment; 1955 contents = (contents & ~howto->dst_mask) | (addend & howto->dst_mask); 1956 score_bfd_put_32 (abfd, contents, address); 1957 break; 1958 } 1959 } 1960 1961 /* Perform a relocation as part of a final link. */ 1962 static bfd_reloc_status_type 1963 score_elf_final_link_relocate (reloc_howto_type *howto, 1964 bfd *input_bfd, 1965 bfd *output_bfd, 1966 asection *input_section, 1967 bfd_byte *contents, 1968 Elf_Internal_Rela *rel, 1969 Elf_Internal_Rela *relocs, 1970 bfd_vma symbol, 1971 struct bfd_link_info *info, 1972 const char *sym_name ATTRIBUTE_UNUSED, 1973 int sym_flags ATTRIBUTE_UNUSED, 1974 struct score_elf_link_hash_entry *h, 1975 asection **local_sections, 1976 bfd_boolean gp_disp_p) 1977 { 1978 unsigned long r_type; 1979 unsigned long r_symndx; 1980 bfd_byte *hit_data = contents + rel->r_offset; 1981 bfd_vma addend; 1982 /* The final GP value to be used for the relocatable, executable, or 1983 shared object file being produced. */ 1984 bfd_vma gp = MINUS_ONE; 1985 /* The place (section offset or address) of the storage unit being relocated. */ 1986 bfd_vma rel_addr; 1987 /* The offset into the global offset table at which the address of the relocation entry 1988 symbol, adjusted by the addend, resides during execution. */ 1989 bfd_vma g = MINUS_ONE; 1990 /* TRUE if the symbol referred to by this relocation is a local symbol. */ 1991 bfd_boolean local_p; 1992 /* The eventual value we will relocate. */ 1993 bfd_vma value = symbol; 1994 unsigned long hi16_addend, hi16_offset, hi16_value, uvalue, offset, abs_value = 0; 1995 1996 1997 if (elf_gp (output_bfd) == 0) 1998 { 1999 struct bfd_link_hash_entry *bh; 2000 asection *o; 2001 2002 bh = bfd_link_hash_lookup (info->hash, "_gp", 0, 0, 1); 2003 if (bh != NULL && bh->type == bfd_link_hash_defined) 2004 elf_gp (output_bfd) = (bh->u.def.value 2005 + bh->u.def.section->output_section->vma 2006 + bh->u.def.section->output_offset); 2007 else if (info->relocatable) 2008 { 2009 bfd_vma lo = -1; 2010 2011 /* Find the GP-relative section with the lowest offset. */ 2012 for (o = output_bfd->sections; o != NULL; o = o->next) 2013 if (o->vma < lo) 2014 lo = o->vma; 2015 /* And calculate GP relative to that. */ 2016 elf_gp (output_bfd) = lo + ELF_SCORE_GP_OFFSET (input_bfd); 2017 } 2018 else 2019 { 2020 /* If the relocate_section function needs to do a reloc 2021 involving the GP value, it should make a reloc_dangerous 2022 callback to warn that GP is not defined. */ 2023 } 2024 } 2025 2026 /* Parse the relocation. */ 2027 r_symndx = ELF32_R_SYM (rel->r_info); 2028 r_type = ELF32_R_TYPE (rel->r_info); 2029 rel_addr = (input_section->output_section->vma + input_section->output_offset + rel->r_offset); 2030 local_p = score_elf_local_relocation_p (input_bfd, rel, local_sections, TRUE); 2031 2032 if (r_type == R_SCORE_GOT15) 2033 { 2034 const Elf_Internal_Rela *relend; 2035 const Elf_Internal_Rela *lo16_rel; 2036 const struct elf_backend_data *bed; 2037 bfd_vma lo_value = 0; 2038 2039 bed = get_elf_backend_data (output_bfd); 2040 relend = relocs + input_section->reloc_count * bed->s->int_rels_per_ext_rel; 2041 lo16_rel = score_elf_next_relocation (input_bfd, R_SCORE_GOT_LO16, rel, relend); 2042 if ((local_p) && (lo16_rel != NULL)) 2043 { 2044 bfd_vma tmp = 0; 2045 tmp = score_bfd_get_32 (input_bfd, contents + lo16_rel->r_offset); 2046 lo_value = (((tmp >> 16) & 0x3) << 14) | ((tmp & 0x7fff) >> 1); 2047 } 2048 addend = lo_value; 2049 } 2050 /* For score3 R_SCORE_ABS32. */ 2051 else if (r_type == R_SCORE_ABS32 || r_type == R_SCORE_REL32) 2052 { 2053 addend = (bfd_get_32 (input_bfd, hit_data) >> howto->bitpos) & howto->src_mask; 2054 } 2055 else 2056 { 2057 addend = (score_bfd_get_32 (input_bfd, hit_data) >> howto->bitpos) & howto->src_mask; 2058 } 2059 2060 /* If we haven't already determined the GOT offset, or the GP value, 2061 and we're going to need it, get it now. */ 2062 switch (r_type) 2063 { 2064 case R_SCORE_CALL15: 2065 case R_SCORE_GOT15: 2066 if (!local_p) 2067 { 2068 g = score_elf_global_got_index (elf_hash_table (info)->dynobj, 2069 (struct elf_link_hash_entry *) h); 2070 if ((! elf_hash_table (info)->dynamic_sections_created 2071 || (info->shared 2072 && (info->symbolic || h->root.dynindx == -1) 2073 && h->root.def_regular))) 2074 { 2075 /* This is a static link or a -Bsymbolic link. The 2076 symbol is defined locally, or was forced to be local. 2077 We must initialize this entry in the GOT. */ 2078 bfd *tmpbfd = elf_hash_table (info)->dynobj; 2079 asection *sgot = score_elf_got_section (tmpbfd, FALSE); 2080 score_bfd_put_32 (tmpbfd, value, sgot->contents + g); 2081 } 2082 } 2083 else if (r_type == R_SCORE_GOT15 || r_type == R_SCORE_CALL15) 2084 { 2085 /* There's no need to create a local GOT entry here; the 2086 calculation for a local GOT15 entry does not involve G. */ 2087 ; 2088 } 2089 else 2090 { 2091 g = score_elf_local_got_index (output_bfd, input_bfd, info, 2092 symbol + addend, r_symndx, h, r_type); 2093 if (g == MINUS_ONE) 2094 return bfd_reloc_outofrange; 2095 } 2096 2097 /* Convert GOT indices to actual offsets. */ 2098 g = score_elf_got_offset_from_index (elf_hash_table (info)->dynobj, 2099 output_bfd, input_bfd, g); 2100 break; 2101 2102 case R_SCORE_HI16: 2103 case R_SCORE_LO16: 2104 case R_SCORE_GPREL32: 2105 gp = _bfd_get_gp_value (output_bfd); 2106 break; 2107 2108 case R_SCORE_GP15: 2109 gp = _bfd_get_gp_value (output_bfd); 2110 2111 default: 2112 break; 2113 } 2114 2115 switch (r_type) 2116 { 2117 case R_SCORE_NONE: 2118 return bfd_reloc_ok; 2119 2120 case R_SCORE_ABS32: 2121 case R_SCORE_REL32: 2122 if ((info->shared 2123 || (elf_hash_table (info)->dynamic_sections_created 2124 && h != NULL 2125 && h->root.def_dynamic 2126 && !h->root.def_regular)) 2127 && r_symndx != STN_UNDEF 2128 && (input_section->flags & SEC_ALLOC) != 0) 2129 { 2130 /* If we're creating a shared library, or this relocation is against a symbol 2131 in a shared library, then we can't know where the symbol will end up. 2132 So, we create a relocation record in the output, and leave the job up 2133 to the dynamic linker. */ 2134 value = addend; 2135 if (!score_elf_create_dynamic_relocation (output_bfd, info, rel, h, 2136 symbol, &value, 2137 input_section)) 2138 return bfd_reloc_undefined; 2139 } 2140 else if (r_symndx == STN_UNDEF) 2141 /* r_symndx will be STN_UNDEF (zero) only for relocs against symbols 2142 from removed linkonce sections, or sections discarded by 2143 a linker script. */ 2144 value = 0; 2145 else 2146 { 2147 if (r_type != R_SCORE_REL32) 2148 value = symbol + addend; 2149 else 2150 value = addend; 2151 } 2152 value &= howto->dst_mask; 2153 bfd_put_32 (input_bfd, value, hit_data); 2154 return bfd_reloc_ok; 2155 2156 case R_SCORE_ABS16: 2157 value += addend; 2158 if ((long)value > 0x7fff || (long)value < -0x8000) 2159 return bfd_reloc_overflow; 2160 score_bfd_put_16 (input_bfd, value, hit_data); 2161 return bfd_reloc_ok; 2162 2163 case R_SCORE_24: 2164 addend = score_bfd_get_32 (input_bfd, hit_data); 2165 offset = (((addend & howto->src_mask) >> 1) & 0x1ff8000) | ((addend & howto->src_mask) & 0x7fff); 2166 if ((offset & 0x1000000) != 0) 2167 offset |= 0xfe000000; 2168 value += offset; 2169 abs_value = abs (value - rel_addr); 2170 if ((abs_value & 0xfe000000) != 0) 2171 return bfd_reloc_overflow; 2172 addend = (addend & ~howto->src_mask) 2173 | (((value << 1) & howto->src_mask) & 0x3ff0000) | (value & 0x7fff); 2174 score_bfd_put_32 (input_bfd, addend, hit_data); 2175 return bfd_reloc_ok; 2176 2177 /* signed imm32. */ 2178 case R_SCORE_IMM30: 2179 { 2180 int not_word_align_p = 0; 2181 bfd_vma imm_offset = 0; 2182 addend = score_bfd_get_48 (input_bfd, hit_data); 2183 imm_offset = ((addend >> 7) & 0xff) 2184 | (((addend >> 16) & 0x7fff) << 8) 2185 | (((addend >> 32) & 0x7f) << 23); 2186 imm_offset <<= howto->rightshift; 2187 value += imm_offset; 2188 value &= 0xffffffff; 2189 2190 /* Check lw48/sw48 rd, value/label word align. */ 2191 if ((value & 0x3) != 0) 2192 not_word_align_p = 1; 2193 2194 value >>= howto->rightshift; 2195 addend = (addend & ~howto->src_mask) 2196 | (((value & 0xff) >> 0) << 7) 2197 | (((value & 0x7fff00) >> 8) << 16) 2198 | (((value & 0x3f800000) >> 23) << 32); 2199 score_bfd_put_48 (input_bfd, addend, hit_data); 2200 if (not_word_align_p) 2201 return bfd_reloc_other; 2202 else 2203 return bfd_reloc_ok; 2204 } 2205 2206 case R_SCORE_IMM32: 2207 { 2208 bfd_vma imm_offset = 0; 2209 addend = score_bfd_get_48 (input_bfd, hit_data); 2210 imm_offset = ((addend >> 5) & 0x3ff) 2211 | (((addend >> 16) & 0x7fff) << 10) 2212 | (((addend >> 32) & 0x7f) << 25); 2213 value += imm_offset; 2214 value &= 0xffffffff; 2215 addend = (addend & ~howto->src_mask) 2216 | ((value & 0x3ff) << 5) 2217 | (((value >> 10) & 0x7fff) << 16) 2218 | (((value >> 25) & 0x7f) << 32); 2219 score_bfd_put_48 (input_bfd, addend, hit_data); 2220 return bfd_reloc_ok; 2221 } 2222 2223 case R_SCORE_PC19: 2224 addend = score_bfd_get_32 (input_bfd, hit_data); 2225 offset = (((addend & howto->src_mask) & 0x3ff0000) >> 6) | ((addend & howto->src_mask) & 0x3ff); 2226 if ((offset & 0x80000) != 0) 2227 offset |= 0xfff00000; 2228 abs_value = value = value - rel_addr + offset; 2229 /* exceed 20 bit : overflow. */ 2230 if ((abs_value & 0x80000000) == 0x80000000) 2231 abs_value = 0xffffffff - value + 1; 2232 if ((abs_value & 0xfff80000) != 0) 2233 return bfd_reloc_overflow; 2234 addend = (addend & ~howto->src_mask) 2235 | (((value << 6) & howto->src_mask) & 0x3ff0000) | (value & 0x3ff); 2236 score_bfd_put_32 (input_bfd, addend, hit_data); 2237 return bfd_reloc_ok; 2238 2239 case R_SCORE16_11: 2240 addend = score_bfd_get_16 (input_bfd, hit_data); 2241 offset = addend & howto->src_mask; 2242 if ((offset & 0x800) != 0) /* Offset is negative. */ 2243 offset |= 0xfffff000; 2244 value += offset; 2245 abs_value = abs (value - rel_addr); 2246 if ((abs_value & 0xfffff000) != 0) 2247 return bfd_reloc_overflow; 2248 addend = (addend & ~howto->src_mask) | (value & howto->src_mask); 2249 score_bfd_put_16 (input_bfd, addend, hit_data); 2250 return bfd_reloc_ok; 2251 2252 case R_SCORE16_PC8: 2253 addend = score_bfd_get_16 (input_bfd, hit_data); 2254 offset = (addend & howto->src_mask) << 1; 2255 if ((offset & 0x200) != 0) /* Offset is negative. */ 2256 offset |= 0xfffffe00; 2257 abs_value = value = value - rel_addr + offset; 2258 /* Sign bit + exceed 9 bit. */ 2259 if (((value & 0xfffffe00) != 0) && ((value & 0xfffffe00) != 0xfffffe00)) 2260 return bfd_reloc_overflow; 2261 value >>= 1; 2262 addend = (addend & ~howto->src_mask) | (value & howto->src_mask); 2263 score_bfd_put_16 (input_bfd, addend, hit_data); 2264 return bfd_reloc_ok; 2265 2266 case R_SCORE_BCMP: 2267 addend = score_bfd_get_32 (input_bfd, hit_data); 2268 offset = (addend & howto->src_mask) << howto->rightshift; 2269 if ((offset & 0x200) != 0) /* Offset is negative. */ 2270 offset |= 0xfffffe00; 2271 value = value - rel_addr + offset; 2272 /* Sign bit + exceed 9 bit. */ 2273 if (((value & 0xfffffe00) != 0) && ((value & 0xfffffe00) != 0xfffffe00)) 2274 return bfd_reloc_overflow; 2275 value >>= howto->rightshift; 2276 addend = (addend & ~howto->src_mask) 2277 | (value & 0x1) 2278 | (((value >> 1) & 0x7) << 7) 2279 | (((value >> 4) & 0x1f) << 21); 2280 score_bfd_put_32 (input_bfd, addend, hit_data); 2281 return bfd_reloc_ok; 2282 2283 case R_SCORE_HI16: 2284 return bfd_reloc_ok; 2285 2286 case R_SCORE_LO16: 2287 hi16_addend = score_bfd_get_32 (input_bfd, hit_data - 4); 2288 hi16_offset = ((((hi16_addend >> 16) & 0x3) << 15) | (hi16_addend & 0x7fff)) >> 1; 2289 addend = score_bfd_get_32 (input_bfd, hit_data); 2290 offset = ((((addend >> 16) & 0x3) << 15) | (addend & 0x7fff)) >> 1; 2291 offset = (hi16_offset << 16) | (offset & 0xffff); 2292 2293 if (!gp_disp_p) 2294 uvalue = value + offset; 2295 else 2296 uvalue = offset + gp - rel_addr + 4; 2297 2298 hi16_offset = (uvalue >> 16) << 1; 2299 hi16_value = (hi16_addend & (~(howto->dst_mask))) 2300 | (hi16_offset & 0x7fff) | ((hi16_offset << 1) & 0x30000); 2301 score_bfd_put_32 (input_bfd, hi16_value, hit_data - 4); 2302 offset = (uvalue & 0xffff) << 1; 2303 value = (addend & (~(howto->dst_mask))) | (offset & 0x7fff) | ((offset << 1) & 0x30000); 2304 score_bfd_put_32 (input_bfd, value, hit_data); 2305 return bfd_reloc_ok; 2306 2307 case R_SCORE_GP15: 2308 addend = score_bfd_get_32 (input_bfd, hit_data); 2309 offset = addend & 0x7fff; 2310 if ((offset & 0x4000) == 0x4000) 2311 offset |= 0xffffc000; 2312 value = value + offset - gp; 2313 if (((value & 0xffffc000) != 0) && ((value & 0xffffc000) != 0xffffc000)) 2314 return bfd_reloc_overflow; 2315 value = (addend & ~howto->src_mask) | (value & howto->src_mask); 2316 score_bfd_put_32 (input_bfd, value, hit_data); 2317 return bfd_reloc_ok; 2318 2319 case R_SCORE_GOT15: 2320 case R_SCORE_CALL15: 2321 if (local_p) 2322 { 2323 bfd_boolean forced; 2324 2325 /* The special case is when the symbol is forced to be local. We need the 2326 full address in the GOT since no R_SCORE_GOT_LO16 relocation follows. */ 2327 forced = ! score_elf_local_relocation_p (input_bfd, rel, 2328 local_sections, FALSE); 2329 value = score_elf_got16_entry (output_bfd, input_bfd, info, 2330 symbol + addend, forced); 2331 if (value == MINUS_ONE) 2332 return bfd_reloc_outofrange; 2333 value = score_elf_got_offset_from_index (elf_hash_table (info)->dynobj, 2334 output_bfd, input_bfd, value); 2335 } 2336 else 2337 { 2338 value = g; 2339 } 2340 2341 if ((long) value > 0x3fff || (long) value < -0x4000) 2342 return bfd_reloc_overflow; 2343 2344 addend = score_bfd_get_32 (input_bfd, hit_data); 2345 value = (addend & ~howto->dst_mask) | (value & howto->dst_mask); 2346 score_bfd_put_32 (input_bfd, value, hit_data); 2347 return bfd_reloc_ok; 2348 2349 case R_SCORE_GPREL32: 2350 value = (addend + symbol - gp); 2351 value &= howto->dst_mask; 2352 score_bfd_put_32 (input_bfd, value, hit_data); 2353 return bfd_reloc_ok; 2354 2355 case R_SCORE_GOT_LO16: 2356 addend = score_bfd_get_32 (input_bfd, hit_data); 2357 value = (((addend >> 16) & 0x3) << 14) | ((addend & 0x7fff) >> 1); 2358 value += symbol; 2359 value = (addend & (~(howto->dst_mask))) | ((value & 0x3fff) << 1) 2360 | (((value >> 14) & 0x3) << 16); 2361 2362 score_bfd_put_32 (input_bfd, value, hit_data); 2363 return bfd_reloc_ok; 2364 2365 case R_SCORE_DUMMY_HI16: 2366 return bfd_reloc_ok; 2367 2368 case R_SCORE_GNU_VTINHERIT: 2369 case R_SCORE_GNU_VTENTRY: 2370 /* We don't do anything with these at present. */ 2371 return bfd_reloc_continue; 2372 2373 default: 2374 return bfd_reloc_notsupported; 2375 } 2376 } 2377 2378 /* Score backend functions. */ 2379 static void 2380 s3_bfd_score_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, 2381 arelent *bfd_reloc, 2382 Elf_Internal_Rela *elf_reloc) 2383 { 2384 unsigned int r_type; 2385 2386 r_type = ELF32_R_TYPE (elf_reloc->r_info); 2387 if (r_type >= ARRAY_SIZE (elf32_score_howto_table)) 2388 bfd_reloc->howto = NULL; 2389 else 2390 bfd_reloc->howto = &elf32_score_howto_table[r_type]; 2391 } 2392 2393 /* Relocate an score ELF section. */ 2394 static bfd_boolean 2395 s3_bfd_score_elf_relocate_section (bfd *output_bfd, 2396 struct bfd_link_info *info, 2397 bfd *input_bfd, 2398 asection *input_section, 2399 bfd_byte *contents, 2400 Elf_Internal_Rela *relocs, 2401 Elf_Internal_Sym *local_syms, 2402 asection **local_sections) 2403 { 2404 Elf_Internal_Shdr *symtab_hdr; 2405 Elf_Internal_Rela *rel; 2406 Elf_Internal_Rela *relend; 2407 const char *name; 2408 unsigned long offset; 2409 unsigned long hi16_addend, hi16_offset, hi16_value, uvalue; 2410 size_t extsymoff; 2411 bfd_boolean gp_disp_p = FALSE; 2412 2413 /* Sort dynsym. */ 2414 if (elf_hash_table (info)->dynamic_sections_created) 2415 { 2416 bfd_size_type dynsecsymcount = 0; 2417 if (info->shared) 2418 { 2419 asection * p; 2420 const struct elf_backend_data *bed = get_elf_backend_data (output_bfd); 2421 2422 for (p = output_bfd->sections; p ; p = p->next) 2423 if ((p->flags & SEC_EXCLUDE) == 0 2424 && (p->flags & SEC_ALLOC) != 0 2425 && !(*bed->elf_backend_omit_section_dynsym) (output_bfd, info, p)) 2426 ++ dynsecsymcount; 2427 } 2428 2429 if (!score_elf_sort_hash_table (info, dynsecsymcount + 1)) 2430 return FALSE; 2431 } 2432 2433 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 2434 extsymoff = (elf_bad_symtab (input_bfd)) ? 0 : symtab_hdr->sh_info; 2435 rel = relocs; 2436 relend = relocs + input_section->reloc_count; 2437 for (; rel < relend; rel++) 2438 { 2439 int r_type; 2440 reloc_howto_type *howto; 2441 unsigned long r_symndx; 2442 Elf_Internal_Sym *sym; 2443 asection *sec; 2444 struct score_elf_link_hash_entry *h; 2445 bfd_vma relocation = 0; 2446 bfd_reloc_status_type r; 2447 arelent bfd_reloc; 2448 2449 r_symndx = ELF32_R_SYM (rel->r_info); 2450 r_type = ELF32_R_TYPE (rel->r_info); 2451 2452 s3_bfd_score_info_to_howto (input_bfd, &bfd_reloc, (Elf_Internal_Rela *) rel); 2453 howto = bfd_reloc.howto; 2454 2455 h = NULL; 2456 sym = NULL; 2457 sec = NULL; 2458 2459 if (r_symndx < extsymoff) 2460 { 2461 sym = local_syms + r_symndx; 2462 sec = local_sections[r_symndx]; 2463 relocation = (sec->output_section->vma 2464 + sec->output_offset 2465 + sym->st_value); 2466 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, sec); 2467 2468 if (!info->relocatable 2469 && (sec->flags & SEC_MERGE) 2470 && ELF_ST_TYPE (sym->st_info) == STT_SECTION) 2471 { 2472 asection *msec; 2473 bfd_vma addend, value; 2474 2475 switch (r_type) 2476 { 2477 case R_SCORE_HI16: 2478 break; 2479 case R_SCORE_LO16: 2480 hi16_addend = score_bfd_get_32 (input_bfd, contents + rel->r_offset - 4); 2481 hi16_offset = ((((hi16_addend >> 16) & 0x3) << 15) | (hi16_addend & 0x7fff)) >> 1; 2482 value = score_bfd_get_32 (input_bfd, contents + rel->r_offset); 2483 offset = ((((value >> 16) & 0x3) << 15) | (value & 0x7fff)) >> 1; 2484 addend = (hi16_offset << 16) | (offset & 0xffff); 2485 msec = sec; 2486 addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend); 2487 addend -= relocation; 2488 addend += msec->output_section->vma + msec->output_offset; 2489 uvalue = addend; 2490 hi16_offset = (uvalue >> 16) << 1; 2491 hi16_value = (hi16_addend & (~(howto->dst_mask))) 2492 | (hi16_offset & 0x7fff) | ((hi16_offset << 1) & 0x30000); 2493 score_bfd_put_32 (input_bfd, hi16_value, contents + rel->r_offset - 4); 2494 offset = (uvalue & 0xffff) << 1; 2495 value = (value & (~(howto->dst_mask))) 2496 | (offset & 0x7fff) | ((offset << 1) & 0x30000); 2497 score_bfd_put_32 (input_bfd, value, contents + rel->r_offset); 2498 break; 2499 2500 case R_SCORE_IMM32: 2501 { 2502 value = score_bfd_get_48 (input_bfd, contents + rel->r_offset); 2503 addend = ((value >> 5) & 0x3ff) 2504 | (((value >> 16) & 0x7fff) << 10) 2505 | (((value >> 32) & 0x7f) << 25); 2506 msec = sec; 2507 addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend); 2508 addend -= relocation; 2509 addend += msec->output_section->vma + msec->output_offset; 2510 addend &= 0xffffffff; 2511 value = (value & ~howto->src_mask) 2512 | ((addend & 0x3ff) << 5) 2513 | (((addend >> 10) & 0x7fff) << 16) 2514 | (((addend >> 25) & 0x7f) << 32); 2515 score_bfd_put_48 (input_bfd, value, contents + rel->r_offset); 2516 break; 2517 } 2518 2519 case R_SCORE_IMM30: 2520 { 2521 int not_word_align_p = 0; 2522 value = score_bfd_get_48 (input_bfd, contents + rel->r_offset); 2523 addend = ((value >> 7) & 0xff) 2524 | (((value >> 16) & 0x7fff) << 8) 2525 | (((value >> 32) & 0x7f) << 23); 2526 addend <<= howto->rightshift; 2527 msec = sec; 2528 addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend); 2529 addend -= relocation; 2530 addend += msec->output_section->vma + msec->output_offset; 2531 addend &= 0xffffffff; 2532 2533 /* Check lw48/sw48 rd, value/label word align. */ 2534 if ((addend & 0x3) != 0) 2535 not_word_align_p = 1; 2536 2537 addend >>= howto->rightshift; 2538 value = (value & ~howto->src_mask) 2539 | (((addend & 0xff) >> 0) << 7) 2540 | (((addend & 0x7fff00) >> 8) << 16) 2541 | (((addend & 0x3f800000) >> 23) << 32); 2542 score_bfd_put_48 (input_bfd, value, contents + rel->r_offset); 2543 2544 if (not_word_align_p) 2545 return bfd_reloc_other; 2546 else 2547 break; 2548 } 2549 2550 case R_SCORE_GOT_LO16: 2551 value = score_bfd_get_32 (input_bfd, contents + rel->r_offset); 2552 addend = (((value >> 16) & 0x3) << 14) | ((value & 0x7fff) >> 1); 2553 msec = sec; 2554 addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend) - relocation; 2555 addend += msec->output_section->vma + msec->output_offset; 2556 value = (value & (~(howto->dst_mask))) | ((addend & 0x3fff) << 1) 2557 | (((addend >> 14) & 0x3) << 16); 2558 2559 score_bfd_put_32 (input_bfd, value, contents + rel->r_offset); 2560 break; 2561 2562 case R_SCORE_ABS32: 2563 case R_SCORE_REL32: 2564 value = bfd_get_32 (input_bfd, contents + rel->r_offset); 2565 /* Get the (signed) value from the instruction. */ 2566 addend = value & howto->src_mask; 2567 if (addend & ((howto->src_mask + 1) >> 1)) 2568 { 2569 bfd_signed_vma mask; 2570 2571 mask = -1; 2572 mask &= ~howto->src_mask; 2573 addend |= mask; 2574 } 2575 msec = sec; 2576 addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend) - relocation; 2577 addend += msec->output_section->vma + msec->output_offset; 2578 value = (value & ~howto->dst_mask) | (addend & howto->dst_mask); 2579 bfd_put_32 (input_bfd, value, contents + rel->r_offset); 2580 break; 2581 2582 default: 2583 value = score_bfd_get_32 (input_bfd, contents + rel->r_offset); 2584 /* Get the (signed) value from the instruction. */ 2585 addend = value & howto->src_mask; 2586 if (addend & ((howto->src_mask + 1) >> 1)) 2587 { 2588 bfd_signed_vma mask; 2589 2590 mask = -1; 2591 mask &= ~howto->src_mask; 2592 addend |= mask; 2593 } 2594 msec = sec; 2595 addend = _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend) - relocation; 2596 addend += msec->output_section->vma + msec->output_offset; 2597 value = (value & ~howto->dst_mask) | (addend & howto->dst_mask); 2598 score_bfd_put_32 (input_bfd, value, contents + rel->r_offset); 2599 break; 2600 } 2601 } 2602 } 2603 else 2604 { 2605 /* For global symbols we look up the symbol in the hash-table. */ 2606 h = ((struct score_elf_link_hash_entry *) 2607 elf_sym_hashes (input_bfd) [r_symndx - extsymoff]); 2608 /* Find the real hash-table entry for this symbol. */ 2609 while (h->root.root.type == bfd_link_hash_indirect 2610 || h->root.root.type == bfd_link_hash_warning) 2611 h = (struct score_elf_link_hash_entry *) h->root.root.u.i.link; 2612 2613 /* Record the name of this symbol, for our caller. */ 2614 name = h->root.root.root.string; 2615 2616 /* See if this is the special GP_DISP_LABEL symbol. Note that such a 2617 symbol must always be a global symbol. */ 2618 if (strcmp (name, GP_DISP_LABEL) == 0) 2619 { 2620 /* Relocations against GP_DISP_LABEL are permitted only with 2621 R_SCORE_HI16 and R_SCORE_LO16 relocations. */ 2622 if (r_type != R_SCORE_HI16 && r_type != R_SCORE_LO16) 2623 return bfd_reloc_notsupported; 2624 2625 gp_disp_p = TRUE; 2626 } 2627 2628 /* If this symbol is defined, calculate its address. Note that 2629 GP_DISP_LABEL is a magic symbol, always implicitly defined by the 2630 linker, so it's inappropriate to check to see whether or not 2631 its defined. */ 2632 else if ((h->root.root.type == bfd_link_hash_defined 2633 || h->root.root.type == bfd_link_hash_defweak) 2634 && h->root.root.u.def.section) 2635 { 2636 sec = h->root.root.u.def.section; 2637 if (sec->output_section) 2638 relocation = (h->root.root.u.def.value 2639 + sec->output_section->vma 2640 + sec->output_offset); 2641 else 2642 { 2643 relocation = h->root.root.u.def.value; 2644 } 2645 } 2646 else if (h->root.root.type == bfd_link_hash_undefweak) 2647 /* We allow relocations against undefined weak symbols, giving 2648 it the value zero, so that you can undefined weak functions 2649 and check to see if they exist by looking at their addresses. */ 2650 relocation = 0; 2651 else if (info->unresolved_syms_in_objects == RM_IGNORE 2652 && ELF_ST_VISIBILITY (h->root.other) == STV_DEFAULT) 2653 relocation = 0; 2654 else if (strcmp (name, "_DYNAMIC_LINK") == 0) 2655 { 2656 /* If this is a dynamic link, we should have created a _DYNAMIC_LINK symbol 2657 in s3_bfd_score_elf_create_dynamic_sections. Otherwise, we should define 2658 the symbol with a value of 0. */ 2659 BFD_ASSERT (! info->shared); 2660 BFD_ASSERT (bfd_get_section_by_name (output_bfd, ".dynamic") == NULL); 2661 relocation = 0; 2662 } 2663 else if (!info->relocatable) 2664 { 2665 if (! ((*info->callbacks->undefined_symbol) 2666 (info, h->root.root.root.string, input_bfd, 2667 input_section, rel->r_offset, 2668 (info->unresolved_syms_in_objects == RM_GENERATE_ERROR) 2669 || ELF_ST_VISIBILITY (h->root.other)))) 2670 return bfd_reloc_undefined; 2671 relocation = 0; 2672 } 2673 } 2674 2675 if (sec != NULL && discarded_section (sec)) 2676 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section, 2677 rel, 1, relend, howto, 0, contents); 2678 2679 if (info->relocatable) 2680 { 2681 /* This is a relocatable link. We don't have to change 2682 anything, unless the reloc is against a section symbol, 2683 in which case we have to adjust according to where the 2684 section symbol winds up in the output section. */ 2685 if (r_symndx < symtab_hdr->sh_info) 2686 { 2687 sym = local_syms + r_symndx; 2688 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION) 2689 { 2690 sec = local_sections[r_symndx]; 2691 score_elf_add_to_rel (input_bfd, contents + rel->r_offset, 2692 howto, (bfd_signed_vma) (sec->output_offset + sym->st_value)); 2693 } 2694 } 2695 continue; 2696 } 2697 2698 /* This is a final link. */ 2699 r = score_elf_final_link_relocate (howto, input_bfd, output_bfd, 2700 input_section, contents, rel, relocs, 2701 relocation, info, name, 2702 (h ? ELF_ST_TYPE ((unsigned int)h->root.root.type) : 2703 ELF_ST_TYPE ((unsigned int)sym->st_info)), h, local_sections, 2704 gp_disp_p); 2705 2706 if (r != bfd_reloc_ok) 2707 { 2708 const char *msg = (const char *)0; 2709 2710 switch (r) 2711 { 2712 case bfd_reloc_overflow: 2713 /* If the overflowing reloc was to an undefined symbol, 2714 we have already printed one error message and there 2715 is no point complaining again. */ 2716 if (((!h) || (h->root.root.type != bfd_link_hash_undefined)) 2717 && (!((*info->callbacks->reloc_overflow) 2718 (info, NULL, name, howto->name, (bfd_vma) 0, 2719 input_bfd, input_section, rel->r_offset)))) 2720 return FALSE; 2721 break; 2722 case bfd_reloc_undefined: 2723 if (!((*info->callbacks->undefined_symbol) 2724 (info, name, input_bfd, input_section, rel->r_offset, TRUE))) 2725 return FALSE; 2726 break; 2727 2728 case bfd_reloc_outofrange: 2729 msg = _("internal error: out of range error"); 2730 goto common_error; 2731 2732 case bfd_reloc_notsupported: 2733 msg = _("internal error: unsupported relocation error"); 2734 goto common_error; 2735 2736 case bfd_reloc_dangerous: 2737 msg = _("internal error: dangerous error"); 2738 goto common_error; 2739 2740 /* Use bfd_reloc_other to check lw48, sw48 word align. */ 2741 case bfd_reloc_other: 2742 msg = _("address not word align"); 2743 goto common_error; 2744 2745 default: 2746 msg = _("internal error: unknown error"); 2747 /* fall through */ 2748 2749 common_error: 2750 if (!((*info->callbacks->warning) 2751 (info, msg, name, input_bfd, input_section, rel->r_offset))) 2752 return FALSE; 2753 break; 2754 } 2755 } 2756 } 2757 2758 return TRUE; 2759 } 2760 2761 /* Look through the relocs for a section during the first phase, and 2762 allocate space in the global offset table. */ 2763 static bfd_boolean 2764 s3_bfd_score_elf_check_relocs (bfd *abfd, 2765 struct bfd_link_info *info, 2766 asection *sec, 2767 const Elf_Internal_Rela *relocs) 2768 { 2769 const char *name; 2770 bfd *dynobj; 2771 Elf_Internal_Shdr *symtab_hdr; 2772 struct elf_link_hash_entry **sym_hashes; 2773 struct score_got_info *g; 2774 size_t extsymoff; 2775 const Elf_Internal_Rela *rel; 2776 const Elf_Internal_Rela *rel_end; 2777 asection *sgot; 2778 asection *sreloc; 2779 const struct elf_backend_data *bed; 2780 2781 if (info->relocatable) 2782 return TRUE; 2783 2784 dynobj = elf_hash_table (info)->dynobj; 2785 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 2786 sym_hashes = elf_sym_hashes (abfd); 2787 extsymoff = (elf_bad_symtab (abfd)) ? 0 : symtab_hdr->sh_info; 2788 2789 name = bfd_get_section_name (abfd, sec); 2790 2791 if (dynobj == NULL) 2792 { 2793 sgot = NULL; 2794 g = NULL; 2795 } 2796 else 2797 { 2798 sgot = score_elf_got_section (dynobj, FALSE); 2799 if (sgot == NULL) 2800 g = NULL; 2801 else 2802 { 2803 BFD_ASSERT (score_elf_section_data (sgot) != NULL); 2804 g = score_elf_section_data (sgot)->u.got_info; 2805 BFD_ASSERT (g != NULL); 2806 } 2807 } 2808 2809 sreloc = NULL; 2810 bed = get_elf_backend_data (abfd); 2811 rel_end = relocs + sec->reloc_count * bed->s->int_rels_per_ext_rel; 2812 for (rel = relocs; rel < rel_end; ++rel) 2813 { 2814 unsigned long r_symndx; 2815 unsigned int r_type; 2816 struct elf_link_hash_entry *h; 2817 2818 r_symndx = ELF32_R_SYM (rel->r_info); 2819 r_type = ELF32_R_TYPE (rel->r_info); 2820 2821 if (r_symndx < extsymoff) 2822 { 2823 h = NULL; 2824 } 2825 else if (r_symndx >= extsymoff + NUM_SHDR_ENTRIES (symtab_hdr)) 2826 { 2827 (*_bfd_error_handler) (_("%s: Malformed reloc detected for section %s"), abfd, name); 2828 bfd_set_error (bfd_error_bad_value); 2829 return FALSE; 2830 } 2831 else 2832 { 2833 h = sym_hashes[r_symndx - extsymoff]; 2834 2835 /* This may be an indirect symbol created because of a version. */ 2836 if (h != NULL) 2837 { 2838 while (h->root.type == bfd_link_hash_indirect) 2839 h = (struct elf_link_hash_entry *)h->root.u.i.link; 2840 } 2841 } 2842 2843 /* Some relocs require a global offset table. */ 2844 if (dynobj == NULL || sgot == NULL) 2845 { 2846 switch (r_type) 2847 { 2848 case R_SCORE_GOT15: 2849 case R_SCORE_CALL15: 2850 if (dynobj == NULL) 2851 elf_hash_table (info)->dynobj = dynobj = abfd; 2852 if (!score_elf_create_got_section (dynobj, info, FALSE)) 2853 return FALSE; 2854 g = score_elf_got_info (dynobj, &sgot); 2855 break; 2856 case R_SCORE_ABS32: 2857 case R_SCORE_REL32: 2858 if (dynobj == NULL && (info->shared || h != NULL) && (sec->flags & SEC_ALLOC) != 0) 2859 elf_hash_table (info)->dynobj = dynobj = abfd; 2860 break; 2861 default: 2862 break; 2863 } 2864 } 2865 2866 if (!h && (r_type == R_SCORE_GOT_LO16)) 2867 { 2868 if (! score_elf_record_local_got_symbol (abfd, r_symndx, rel->r_addend, g)) 2869 return FALSE; 2870 } 2871 2872 switch (r_type) 2873 { 2874 case R_SCORE_CALL15: 2875 if (h == NULL) 2876 { 2877 (*_bfd_error_handler) 2878 (_("%B: CALL15 reloc at 0x%lx not against global symbol"), 2879 abfd, (unsigned long) rel->r_offset); 2880 bfd_set_error (bfd_error_bad_value); 2881 return FALSE; 2882 } 2883 else 2884 { 2885 /* This symbol requires a global offset table entry. */ 2886 if (! score_elf_record_global_got_symbol (h, abfd, info, g)) 2887 return FALSE; 2888 2889 /* We need a stub, not a plt entry for the undefined function. But we record 2890 it as if it needs plt. See _bfd_elf_adjust_dynamic_symbol. */ 2891 h->needs_plt = 1; 2892 h->type = STT_FUNC; 2893 } 2894 break; 2895 case R_SCORE_GOT15: 2896 if (h && ! score_elf_record_global_got_symbol (h, abfd, info, g)) 2897 return FALSE; 2898 break; 2899 case R_SCORE_ABS32: 2900 case R_SCORE_REL32: 2901 if ((info->shared || h != NULL) && (sec->flags & SEC_ALLOC) != 0) 2902 { 2903 if (sreloc == NULL) 2904 { 2905 sreloc = score_elf_rel_dyn_section (dynobj, TRUE); 2906 if (sreloc == NULL) 2907 return FALSE; 2908 } 2909 #define SCORE_READONLY_SECTION (SEC_ALLOC | SEC_LOAD | SEC_READONLY) 2910 if (info->shared) 2911 { 2912 /* When creating a shared object, we must copy these reloc types into 2913 the output file as R_SCORE_REL32 relocs. We make room for this reloc 2914 in the .rel.dyn reloc section. */ 2915 score_elf_allocate_dynamic_relocations (dynobj, 1); 2916 if ((sec->flags & SCORE_READONLY_SECTION) 2917 == SCORE_READONLY_SECTION) 2918 /* We tell the dynamic linker that there are 2919 relocations against the text segment. */ 2920 info->flags |= DF_TEXTREL; 2921 } 2922 else 2923 { 2924 struct score_elf_link_hash_entry *hscore; 2925 2926 /* We only need to copy this reloc if the symbol is 2927 defined in a dynamic object. */ 2928 hscore = (struct score_elf_link_hash_entry *)h; 2929 ++hscore->possibly_dynamic_relocs; 2930 if ((sec->flags & SCORE_READONLY_SECTION) 2931 == SCORE_READONLY_SECTION) 2932 /* We need it to tell the dynamic linker if there 2933 are relocations against the text segment. */ 2934 hscore->readonly_reloc = TRUE; 2935 } 2936 2937 /* Even though we don't directly need a GOT entry for this symbol, 2938 a symbol must have a dynamic symbol table index greater that 2939 DT_SCORE_GOTSYM if there are dynamic relocations against it. */ 2940 if (h != NULL) 2941 { 2942 if (dynobj == NULL) 2943 elf_hash_table (info)->dynobj = dynobj = abfd; 2944 if (! score_elf_create_got_section (dynobj, info, TRUE)) 2945 return FALSE; 2946 g = score_elf_got_info (dynobj, &sgot); 2947 if (! score_elf_record_global_got_symbol (h, abfd, info, g)) 2948 return FALSE; 2949 } 2950 } 2951 break; 2952 2953 /* This relocation describes the C++ object vtable hierarchy. 2954 Reconstruct it for later use during GC. */ 2955 case R_SCORE_GNU_VTINHERIT: 2956 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset)) 2957 return FALSE; 2958 break; 2959 2960 /* This relocation describes which C++ vtable entries are actually 2961 used. Record for later use during GC. */ 2962 case R_SCORE_GNU_VTENTRY: 2963 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset)) 2964 return FALSE; 2965 break; 2966 default: 2967 break; 2968 } 2969 2970 /* We must not create a stub for a symbol that has relocations 2971 related to taking the function's address. */ 2972 switch (r_type) 2973 { 2974 default: 2975 if (h != NULL) 2976 { 2977 struct score_elf_link_hash_entry *sh; 2978 2979 sh = (struct score_elf_link_hash_entry *) h; 2980 sh->no_fn_stub = TRUE; 2981 } 2982 break; 2983 case R_SCORE_CALL15: 2984 break; 2985 } 2986 } 2987 2988 return TRUE; 2989 } 2990 2991 static bfd_boolean 2992 s3_bfd_score_elf_add_symbol_hook (bfd *abfd, 2993 struct bfd_link_info *info ATTRIBUTE_UNUSED, 2994 Elf_Internal_Sym *sym, 2995 const char **namep ATTRIBUTE_UNUSED, 2996 flagword *flagsp ATTRIBUTE_UNUSED, 2997 asection **secp, 2998 bfd_vma *valp) 2999 { 3000 switch (sym->st_shndx) 3001 { 3002 case SHN_COMMON: 3003 if (sym->st_size > elf_gp_size (abfd)) 3004 break; 3005 /* Fall through. */ 3006 case SHN_SCORE_SCOMMON: 3007 *secp = bfd_make_section_old_way (abfd, ".scommon"); 3008 (*secp)->flags |= SEC_IS_COMMON; 3009 *valp = sym->st_size; 3010 break; 3011 } 3012 3013 return TRUE; 3014 } 3015 3016 static void 3017 s3_bfd_score_elf_symbol_processing (bfd *abfd, asymbol *asym) 3018 { 3019 elf_symbol_type *elfsym; 3020 3021 elfsym = (elf_symbol_type *) asym; 3022 switch (elfsym->internal_elf_sym.st_shndx) 3023 { 3024 case SHN_COMMON: 3025 if (asym->value > elf_gp_size (abfd)) 3026 break; 3027 /* Fall through. */ 3028 case SHN_SCORE_SCOMMON: 3029 if (score_elf_scom_section.name == NULL) 3030 { 3031 /* Initialize the small common section. */ 3032 score_elf_scom_section.name = ".scommon"; 3033 score_elf_scom_section.flags = SEC_IS_COMMON; 3034 score_elf_scom_section.output_section = &score_elf_scom_section; 3035 score_elf_scom_section.symbol = &score_elf_scom_symbol; 3036 score_elf_scom_section.symbol_ptr_ptr = &score_elf_scom_symbol_ptr; 3037 score_elf_scom_symbol.name = ".scommon"; 3038 score_elf_scom_symbol.flags = BSF_SECTION_SYM; 3039 score_elf_scom_symbol.section = &score_elf_scom_section; 3040 score_elf_scom_symbol_ptr = &score_elf_scom_symbol; 3041 } 3042 asym->section = &score_elf_scom_section; 3043 asym->value = elfsym->internal_elf_sym.st_size; 3044 break; 3045 } 3046 } 3047 3048 static int 3049 s3_bfd_score_elf_link_output_symbol_hook (struct bfd_link_info *info ATTRIBUTE_UNUSED, 3050 const char *name ATTRIBUTE_UNUSED, 3051 Elf_Internal_Sym *sym, 3052 asection *input_sec, 3053 struct elf_link_hash_entry *h ATTRIBUTE_UNUSED) 3054 { 3055 /* If we see a common symbol, which implies a relocatable link, then 3056 if a symbol was small common in an input file, mark it as small 3057 common in the output file. */ 3058 if (sym->st_shndx == SHN_COMMON && strcmp (input_sec->name, ".scommon") == 0) 3059 sym->st_shndx = SHN_SCORE_SCOMMON; 3060 3061 return 1; 3062 } 3063 3064 static bfd_boolean 3065 s3_bfd_score_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED, 3066 asection *sec, 3067 int *retval) 3068 { 3069 if (strcmp (bfd_get_section_name (abfd, sec), ".scommon") == 0) 3070 { 3071 *retval = SHN_SCORE_SCOMMON; 3072 return TRUE; 3073 } 3074 3075 return FALSE; 3076 } 3077 3078 /* Adjust a symbol defined by a dynamic object and referenced by a 3079 regular object. The current definition is in some section of the 3080 dynamic object, but we're not including those sections. We have to 3081 change the definition to something the rest of the link can understand. */ 3082 static bfd_boolean 3083 s3_bfd_score_elf_adjust_dynamic_symbol (struct bfd_link_info *info, 3084 struct elf_link_hash_entry *h) 3085 { 3086 bfd *dynobj; 3087 struct score_elf_link_hash_entry *hscore; 3088 asection *s; 3089 3090 dynobj = elf_hash_table (info)->dynobj; 3091 3092 /* Make sure we know what is going on here. */ 3093 BFD_ASSERT (dynobj != NULL 3094 && (h->needs_plt 3095 || h->u.weakdef != NULL 3096 || (h->def_dynamic && h->ref_regular && !h->def_regular))); 3097 3098 /* If this symbol is defined in a dynamic object, we need to copy 3099 any R_SCORE_ABS32 or R_SCORE_REL32 relocs against it into the output 3100 file. */ 3101 hscore = (struct score_elf_link_hash_entry *)h; 3102 if (!info->relocatable 3103 && hscore->possibly_dynamic_relocs != 0 3104 && (h->root.type == bfd_link_hash_defweak || !h->def_regular)) 3105 { 3106 score_elf_allocate_dynamic_relocations (dynobj, hscore->possibly_dynamic_relocs); 3107 if (hscore->readonly_reloc) 3108 /* We tell the dynamic linker that there are relocations 3109 against the text segment. */ 3110 info->flags |= DF_TEXTREL; 3111 } 3112 3113 /* For a function, create a stub, if allowed. */ 3114 if (!hscore->no_fn_stub && h->needs_plt) 3115 { 3116 if (!elf_hash_table (info)->dynamic_sections_created) 3117 return TRUE; 3118 3119 /* If this symbol is not defined in a regular file, then set 3120 the symbol to the stub location. This is required to make 3121 function pointers compare as equal between the normal 3122 executable and the shared library. */ 3123 if (!h->def_regular) 3124 { 3125 /* We need .stub section. */ 3126 s = bfd_get_linker_section (dynobj, SCORE_ELF_STUB_SECTION_NAME); 3127 BFD_ASSERT (s != NULL); 3128 3129 h->root.u.def.section = s; 3130 h->root.u.def.value = s->size; 3131 3132 /* XXX Write this stub address somewhere. */ 3133 h->plt.offset = s->size; 3134 3135 /* Make room for this stub code. */ 3136 s->size += SCORE_FUNCTION_STUB_SIZE; 3137 3138 /* The last half word of the stub will be filled with the index 3139 of this symbol in .dynsym section. */ 3140 return TRUE; 3141 } 3142 } 3143 else if ((h->type == STT_FUNC) && !h->needs_plt) 3144 { 3145 /* This will set the entry for this symbol in the GOT to 0, and 3146 the dynamic linker will take care of this. */ 3147 h->root.u.def.value = 0; 3148 return TRUE; 3149 } 3150 3151 /* If this is a weak symbol, and there is a real definition, the 3152 processor independent code will have arranged for us to see the 3153 real definition first, and we can just use the same value. */ 3154 if (h->u.weakdef != NULL) 3155 { 3156 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined 3157 || h->u.weakdef->root.type == bfd_link_hash_defweak); 3158 h->root.u.def.section = h->u.weakdef->root.u.def.section; 3159 h->root.u.def.value = h->u.weakdef->root.u.def.value; 3160 return TRUE; 3161 } 3162 3163 /* This is a reference to a symbol defined by a dynamic object which 3164 is not a function. */ 3165 return TRUE; 3166 } 3167 3168 /* This function is called after all the input files have been read, 3169 and the input sections have been assigned to output sections. */ 3170 static bfd_boolean 3171 s3_bfd_score_elf_always_size_sections (bfd *output_bfd, 3172 struct bfd_link_info *info) 3173 { 3174 bfd *dynobj; 3175 asection *s; 3176 struct score_got_info *g; 3177 int i; 3178 bfd_size_type loadable_size = 0; 3179 bfd_size_type local_gotno; 3180 bfd *sub; 3181 3182 dynobj = elf_hash_table (info)->dynobj; 3183 if (dynobj == NULL) 3184 /* Relocatable links don't have it. */ 3185 return TRUE; 3186 3187 g = score_elf_got_info (dynobj, &s); 3188 if (s == NULL) 3189 return TRUE; 3190 3191 /* Calculate the total loadable size of the output. That will give us the 3192 maximum number of GOT_PAGE entries required. */ 3193 for (sub = info->input_bfds; sub; sub = sub->link_next) 3194 { 3195 asection *subsection; 3196 3197 for (subsection = sub->sections; 3198 subsection; 3199 subsection = subsection->next) 3200 { 3201 if ((subsection->flags & SEC_ALLOC) == 0) 3202 continue; 3203 loadable_size += ((subsection->size + 0xf) 3204 &~ (bfd_size_type) 0xf); 3205 } 3206 } 3207 3208 /* There has to be a global GOT entry for every symbol with 3209 a dynamic symbol table index of DT_SCORE_GOTSYM or 3210 higher. Therefore, it make sense to put those symbols 3211 that need GOT entries at the end of the symbol table. We 3212 do that here. */ 3213 if (! score_elf_sort_hash_table (info, 1)) 3214 return FALSE; 3215 3216 if (g->global_gotsym != NULL) 3217 i = elf_hash_table (info)->dynsymcount - g->global_gotsym->dynindx; 3218 else 3219 /* If there are no global symbols, or none requiring 3220 relocations, then GLOBAL_GOTSYM will be NULL. */ 3221 i = 0; 3222 3223 /* In the worst case, we'll get one stub per dynamic symbol. */ 3224 loadable_size += SCORE_FUNCTION_STUB_SIZE * i; 3225 3226 /* Assume there are two loadable segments consisting of 3227 contiguous sections. Is 5 enough? */ 3228 local_gotno = (loadable_size >> 16) + 5; 3229 3230 g->local_gotno += local_gotno; 3231 s->size += g->local_gotno * SCORE_ELF_GOT_SIZE (output_bfd); 3232 3233 g->global_gotno = i; 3234 s->size += i * SCORE_ELF_GOT_SIZE (output_bfd); 3235 3236 score_elf_resolve_final_got_entries (g); 3237 3238 if (s->size > SCORE_ELF_GOT_MAX_SIZE (output_bfd)) 3239 { 3240 /* Fixme. Error message or Warning message should be issued here. */ 3241 } 3242 3243 return TRUE; 3244 } 3245 3246 /* Set the sizes of the dynamic sections. */ 3247 static bfd_boolean 3248 s3_bfd_score_elf_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info) 3249 { 3250 bfd *dynobj; 3251 asection *s; 3252 bfd_boolean reltext; 3253 3254 dynobj = elf_hash_table (info)->dynobj; 3255 BFD_ASSERT (dynobj != NULL); 3256 3257 if (elf_hash_table (info)->dynamic_sections_created) 3258 { 3259 /* Set the contents of the .interp section to the interpreter. */ 3260 if (!info->shared) 3261 { 3262 s = bfd_get_linker_section (dynobj, ".interp"); 3263 BFD_ASSERT (s != NULL); 3264 s->size = strlen (ELF_DYNAMIC_INTERPRETER) + 1; 3265 s->contents = (bfd_byte *) ELF_DYNAMIC_INTERPRETER; 3266 } 3267 } 3268 3269 /* The check_relocs and adjust_dynamic_symbol entry points have 3270 determined the sizes of the various dynamic sections. Allocate 3271 memory for them. */ 3272 reltext = FALSE; 3273 for (s = dynobj->sections; s != NULL; s = s->next) 3274 { 3275 const char *name; 3276 3277 if ((s->flags & SEC_LINKER_CREATED) == 0) 3278 continue; 3279 3280 /* It's OK to base decisions on the section name, because none 3281 of the dynobj section names depend upon the input files. */ 3282 name = bfd_get_section_name (dynobj, s); 3283 3284 if (CONST_STRNEQ (name, ".rel")) 3285 { 3286 if (s->size == 0) 3287 { 3288 /* We only strip the section if the output section name 3289 has the same name. Otherwise, there might be several 3290 input sections for this output section. FIXME: This 3291 code is probably not needed these days anyhow, since 3292 the linker now does not create empty output sections. */ 3293 if (s->output_section != NULL 3294 && strcmp (name, 3295 bfd_get_section_name (s->output_section->owner, 3296 s->output_section)) == 0) 3297 s->flags |= SEC_EXCLUDE; 3298 } 3299 else 3300 { 3301 const char *outname; 3302 asection *target; 3303 3304 /* If this relocation section applies to a read only 3305 section, then we probably need a DT_TEXTREL entry. 3306 If the relocation section is .rel.dyn, we always 3307 assert a DT_TEXTREL entry rather than testing whether 3308 there exists a relocation to a read only section or 3309 not. */ 3310 outname = bfd_get_section_name (output_bfd, s->output_section); 3311 target = bfd_get_section_by_name (output_bfd, outname + 4); 3312 if ((target != NULL 3313 && (target->flags & SEC_READONLY) != 0 3314 && (target->flags & SEC_ALLOC) != 0) || strcmp (outname, ".rel.dyn") == 0) 3315 reltext = TRUE; 3316 3317 /* We use the reloc_count field as a counter if we need 3318 to copy relocs into the output file. */ 3319 if (strcmp (name, ".rel.dyn") != 0) 3320 s->reloc_count = 0; 3321 } 3322 } 3323 else if (CONST_STRNEQ (name, ".got")) 3324 { 3325 /* s3_bfd_score_elf_always_size_sections() has already done 3326 most of the work, but some symbols may have been mapped 3327 to versions that we must now resolve in the got_entries 3328 hash tables. */ 3329 } 3330 else if (strcmp (name, SCORE_ELF_STUB_SECTION_NAME) == 0) 3331 { 3332 /* IRIX rld assumes that the function stub isn't at the end 3333 of .text section. So put a dummy. XXX */ 3334 s->size += SCORE_FUNCTION_STUB_SIZE; 3335 } 3336 else if (! CONST_STRNEQ (name, ".init")) 3337 { 3338 /* It's not one of our sections, so don't allocate space. */ 3339 continue; 3340 } 3341 3342 /* Allocate memory for the section contents. */ 3343 s->contents = bfd_zalloc (dynobj, s->size); 3344 if (s->contents == NULL && s->size != 0) 3345 { 3346 bfd_set_error (bfd_error_no_memory); 3347 return FALSE; 3348 } 3349 } 3350 3351 if (elf_hash_table (info)->dynamic_sections_created) 3352 { 3353 /* Add some entries to the .dynamic section. We fill in the 3354 values later, in s3_bfd_score_elf_finish_dynamic_sections, but we 3355 must add the entries now so that we get the correct size for 3356 the .dynamic section. The DT_DEBUG entry is filled in by the 3357 dynamic linker and used by the debugger. */ 3358 3359 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_DEBUG, 0)) 3360 return FALSE; 3361 3362 if (reltext) 3363 info->flags |= DF_TEXTREL; 3364 3365 if ((info->flags & DF_TEXTREL) != 0) 3366 { 3367 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_TEXTREL, 0)) 3368 return FALSE; 3369 } 3370 3371 if (! SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTGOT, 0)) 3372 return FALSE; 3373 3374 if (score_elf_rel_dyn_section (dynobj, FALSE)) 3375 { 3376 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_REL, 0)) 3377 return FALSE; 3378 3379 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELSZ, 0)) 3380 return FALSE; 3381 3382 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELENT, 0)) 3383 return FALSE; 3384 } 3385 3386 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_SCORE_BASE_ADDRESS, 0)) 3387 return FALSE; 3388 3389 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_SCORE_LOCAL_GOTNO, 0)) 3390 return FALSE; 3391 3392 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_SCORE_SYMTABNO, 0)) 3393 return FALSE; 3394 3395 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_SCORE_UNREFEXTNO, 0)) 3396 return FALSE; 3397 3398 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_SCORE_GOTSYM, 0)) 3399 return FALSE; 3400 3401 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_SCORE_HIPAGENO, 0)) 3402 return FALSE; 3403 } 3404 3405 return TRUE; 3406 } 3407 3408 static bfd_boolean 3409 s3_bfd_score_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info) 3410 { 3411 struct elf_link_hash_entry *h; 3412 struct bfd_link_hash_entry *bh; 3413 flagword flags; 3414 asection *s; 3415 3416 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY 3417 | SEC_LINKER_CREATED | SEC_READONLY); 3418 3419 /* ABI requests the .dynamic section to be read only. */ 3420 s = bfd_get_linker_section (abfd, ".dynamic"); 3421 if (s != NULL) 3422 { 3423 if (!bfd_set_section_flags (abfd, s, flags)) 3424 return FALSE; 3425 } 3426 3427 /* We need to create .got section. */ 3428 if (!score_elf_create_got_section (abfd, info, FALSE)) 3429 return FALSE; 3430 3431 if (!score_elf_rel_dyn_section (elf_hash_table (info)->dynobj, TRUE)) 3432 return FALSE; 3433 3434 /* Create .stub section. */ 3435 if (bfd_get_linker_section (abfd, SCORE_ELF_STUB_SECTION_NAME) == NULL) 3436 { 3437 s = bfd_make_section_anyway_with_flags (abfd, SCORE_ELF_STUB_SECTION_NAME, 3438 flags | SEC_CODE); 3439 if (s == NULL 3440 || !bfd_set_section_alignment (abfd, s, 2)) 3441 3442 return FALSE; 3443 } 3444 3445 if (!info->shared) 3446 { 3447 const char *name; 3448 3449 name = "_DYNAMIC_LINK"; 3450 bh = NULL; 3451 if (!(_bfd_generic_link_add_one_symbol 3452 (info, abfd, name, BSF_GLOBAL, bfd_abs_section_ptr, 3453 (bfd_vma) 0, NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh))) 3454 return FALSE; 3455 3456 h = (struct elf_link_hash_entry *)bh; 3457 h->non_elf = 0; 3458 h->def_regular = 1; 3459 h->type = STT_SECTION; 3460 3461 if (!bfd_elf_link_record_dynamic_symbol (info, h)) 3462 return FALSE; 3463 } 3464 3465 return TRUE; 3466 } 3467 3468 3469 /* Finish up dynamic symbol handling. We set the contents of various 3470 dynamic sections here. */ 3471 static bfd_boolean 3472 s3_bfd_score_elf_finish_dynamic_symbol (bfd *output_bfd, 3473 struct bfd_link_info *info, 3474 struct elf_link_hash_entry *h, 3475 Elf_Internal_Sym *sym) 3476 { 3477 bfd *dynobj; 3478 asection *sgot; 3479 struct score_got_info *g; 3480 const char *name; 3481 3482 dynobj = elf_hash_table (info)->dynobj; 3483 3484 if (h->plt.offset != MINUS_ONE) 3485 { 3486 asection *s; 3487 bfd_byte stub[SCORE_FUNCTION_STUB_SIZE]; 3488 3489 /* This symbol has a stub. Set it up. */ 3490 BFD_ASSERT (h->dynindx != -1); 3491 3492 s = bfd_get_linker_section (dynobj, SCORE_ELF_STUB_SECTION_NAME); 3493 BFD_ASSERT (s != NULL); 3494 3495 /* FIXME: Can h->dynindex be more than 64K? */ 3496 if (h->dynindx & 0xffff0000) 3497 return FALSE; 3498 3499 /* Fill the stub. */ 3500 score_bfd_put_32 (output_bfd, STUB_LW, stub); 3501 score_bfd_put_32 (output_bfd, STUB_MOVE, stub + 4); 3502 score_bfd_put_32 (output_bfd, STUB_LI16 | (h->dynindx << 1), stub + 8); 3503 score_bfd_put_32 (output_bfd, STUB_BRL, stub + 12); 3504 3505 BFD_ASSERT (h->plt.offset <= s->size); 3506 memcpy (s->contents + h->plt.offset, stub, SCORE_FUNCTION_STUB_SIZE); 3507 3508 /* Mark the symbol as undefined. plt.offset != -1 occurs 3509 only for the referenced symbol. */ 3510 sym->st_shndx = SHN_UNDEF; 3511 3512 /* The run-time linker uses the st_value field of the symbol 3513 to reset the global offset table entry for this external 3514 to its stub address when unlinking a shared object. */ 3515 sym->st_value = (s->output_section->vma + s->output_offset + h->plt.offset); 3516 } 3517 3518 BFD_ASSERT (h->dynindx != -1 || h->forced_local); 3519 3520 sgot = score_elf_got_section (dynobj, FALSE); 3521 BFD_ASSERT (sgot != NULL); 3522 BFD_ASSERT (score_elf_section_data (sgot) != NULL); 3523 g = score_elf_section_data (sgot)->u.got_info; 3524 BFD_ASSERT (g != NULL); 3525 3526 /* Run through the global symbol table, creating GOT entries for all 3527 the symbols that need them. */ 3528 if (g->global_gotsym != NULL && h->dynindx >= g->global_gotsym->dynindx) 3529 { 3530 bfd_vma offset; 3531 bfd_vma value; 3532 3533 value = sym->st_value; 3534 offset = score_elf_global_got_index (dynobj, h); 3535 score_bfd_put_32 (output_bfd, value, sgot->contents + offset); 3536 } 3537 3538 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */ 3539 name = h->root.root.string; 3540 if (strcmp (name, "_DYNAMIC") == 0 || strcmp (name, "_GLOBAL_OFFSET_TABLE_") == 0) 3541 sym->st_shndx = SHN_ABS; 3542 else if (strcmp (name, "_DYNAMIC_LINK") == 0) 3543 { 3544 sym->st_shndx = SHN_ABS; 3545 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION); 3546 sym->st_value = 1; 3547 } 3548 else if (strcmp (name, GP_DISP_LABEL) == 0) 3549 { 3550 sym->st_shndx = SHN_ABS; 3551 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION); 3552 sym->st_value = elf_gp (output_bfd); 3553 } 3554 3555 return TRUE; 3556 } 3557 3558 /* Finish up the dynamic sections. */ 3559 static bfd_boolean 3560 s3_bfd_score_elf_finish_dynamic_sections (bfd *output_bfd, 3561 struct bfd_link_info *info) 3562 { 3563 bfd *dynobj; 3564 asection *sdyn; 3565 asection *sgot; 3566 asection *s; 3567 struct score_got_info *g; 3568 3569 dynobj = elf_hash_table (info)->dynobj; 3570 3571 sdyn = bfd_get_linker_section (dynobj, ".dynamic"); 3572 3573 sgot = score_elf_got_section (dynobj, FALSE); 3574 if (sgot == NULL) 3575 g = NULL; 3576 else 3577 { 3578 BFD_ASSERT (score_elf_section_data (sgot) != NULL); 3579 g = score_elf_section_data (sgot)->u.got_info; 3580 BFD_ASSERT (g != NULL); 3581 } 3582 3583 if (elf_hash_table (info)->dynamic_sections_created) 3584 { 3585 bfd_byte *b; 3586 3587 BFD_ASSERT (sdyn != NULL); 3588 BFD_ASSERT (g != NULL); 3589 3590 for (b = sdyn->contents; 3591 b < sdyn->contents + sdyn->size; 3592 b += SCORE_ELF_DYN_SIZE (dynobj)) 3593 { 3594 Elf_Internal_Dyn dyn; 3595 const char *name; 3596 size_t elemsize; 3597 bfd_boolean swap_out_p; 3598 3599 /* Read in the current dynamic entry. */ 3600 (*get_elf_backend_data (dynobj)->s->swap_dyn_in) (dynobj, b, &dyn); 3601 3602 /* Assume that we're going to modify it and write it out. */ 3603 swap_out_p = TRUE; 3604 3605 switch (dyn.d_tag) 3606 { 3607 case DT_RELENT: 3608 s = score_elf_rel_dyn_section (dynobj, FALSE); 3609 BFD_ASSERT (s != NULL); 3610 dyn.d_un.d_val = SCORE_ELF_REL_SIZE (dynobj); 3611 break; 3612 3613 case DT_STRSZ: 3614 /* Rewrite DT_STRSZ. */ 3615 dyn.d_un.d_val = _bfd_elf_strtab_size (elf_hash_table (info)->dynstr); 3616 break; 3617 3618 case DT_PLTGOT: 3619 name = ".got"; 3620 s = bfd_get_section_by_name (output_bfd, name); 3621 BFD_ASSERT (s != NULL); 3622 dyn.d_un.d_ptr = s->vma; 3623 break; 3624 3625 case DT_SCORE_BASE_ADDRESS: 3626 s = output_bfd->sections; 3627 BFD_ASSERT (s != NULL); 3628 dyn.d_un.d_ptr = s->vma & ~(bfd_vma) 0xffff; 3629 break; 3630 3631 case DT_SCORE_LOCAL_GOTNO: 3632 dyn.d_un.d_val = g->local_gotno; 3633 break; 3634 3635 case DT_SCORE_UNREFEXTNO: 3636 /* The index into the dynamic symbol table which is the 3637 entry of the first external symbol that is not 3638 referenced within the same object. */ 3639 dyn.d_un.d_val = bfd_count_sections (output_bfd) + 1; 3640 break; 3641 3642 case DT_SCORE_GOTSYM: 3643 if (g->global_gotsym) 3644 { 3645 dyn.d_un.d_val = g->global_gotsym->dynindx; 3646 break; 3647 } 3648 /* In case if we don't have global got symbols we default 3649 to setting DT_SCORE_GOTSYM to the same value as 3650 DT_SCORE_SYMTABNO, so we just fall through. */ 3651 3652 case DT_SCORE_SYMTABNO: 3653 name = ".dynsym"; 3654 elemsize = SCORE_ELF_SYM_SIZE (output_bfd); 3655 s = bfd_get_section_by_name (output_bfd, name); 3656 BFD_ASSERT (s != NULL); 3657 3658 dyn.d_un.d_val = s->size / elemsize; 3659 break; 3660 3661 case DT_SCORE_HIPAGENO: 3662 dyn.d_un.d_val = g->local_gotno - SCORE_RESERVED_GOTNO; 3663 break; 3664 3665 default: 3666 swap_out_p = FALSE; 3667 break; 3668 } 3669 3670 if (swap_out_p) 3671 (*get_elf_backend_data (dynobj)->s->swap_dyn_out) (dynobj, &dyn, b); 3672 } 3673 } 3674 3675 /* The first entry of the global offset table will be filled at 3676 runtime. The second entry will be used by some runtime loaders. 3677 This isn't the case of IRIX rld. */ 3678 if (sgot != NULL && sgot->size > 0) 3679 { 3680 score_bfd_put_32 (output_bfd, 0, sgot->contents); 3681 score_bfd_put_32 (output_bfd, 0x80000000, sgot->contents + SCORE_ELF_GOT_SIZE (output_bfd)); 3682 } 3683 3684 if (sgot != NULL) 3685 elf_section_data (sgot->output_section)->this_hdr.sh_entsize 3686 = SCORE_ELF_GOT_SIZE (output_bfd); 3687 3688 3689 /* We need to sort the entries of the dynamic relocation section. */ 3690 s = score_elf_rel_dyn_section (dynobj, FALSE); 3691 3692 if (s != NULL && s->size > (bfd_vma)2 * SCORE_ELF_REL_SIZE (output_bfd)) 3693 { 3694 reldyn_sorting_bfd = output_bfd; 3695 qsort ((Elf32_External_Rel *) s->contents + 1, s->reloc_count - 1, 3696 sizeof (Elf32_External_Rel), score_elf_sort_dynamic_relocs); 3697 } 3698 3699 return TRUE; 3700 } 3701 3702 /* This function set up the ELF section header for a BFD section in preparation for writing 3703 it out. This is where the flags and type fields are set for unusual sections. */ 3704 static bfd_boolean 3705 s3_bfd_score_elf_fake_sections (bfd *abfd ATTRIBUTE_UNUSED, 3706 Elf_Internal_Shdr *hdr, 3707 asection *sec) 3708 { 3709 const char *name; 3710 3711 name = bfd_get_section_name (abfd, sec); 3712 3713 if (strcmp (name, ".got") == 0 3714 || strcmp (name, ".srdata") == 0 3715 || strcmp (name, ".sdata") == 0 3716 || strcmp (name, ".sbss") == 0) 3717 hdr->sh_flags |= SHF_SCORE_GPREL; 3718 3719 return TRUE; 3720 } 3721 3722 /* This function do additional processing on the ELF section header before writing 3723 it out. This is used to set the flags and type fields for some sections. */ 3724 3725 /* assign_file_positions_except_relocs() check section flag and if it is allocatable, 3726 warning message will be issued. backend_fake_section is called before 3727 assign_file_positions_except_relocs(); backend_section_processing after it. so, we 3728 modify section flag there, but not backend_fake_section. */ 3729 static bfd_boolean 3730 s3_bfd_score_elf_section_processing (bfd *abfd ATTRIBUTE_UNUSED, Elf_Internal_Shdr *hdr) 3731 { 3732 if (hdr->bfd_section != NULL) 3733 { 3734 const char *name = bfd_get_section_name (abfd, hdr->bfd_section); 3735 3736 if (strcmp (name, ".sdata") == 0) 3737 { 3738 hdr->sh_flags |= SHF_ALLOC | SHF_WRITE | SHF_SCORE_GPREL; 3739 hdr->sh_type = SHT_PROGBITS; 3740 } 3741 else if (strcmp (name, ".sbss") == 0) 3742 { 3743 hdr->sh_flags |= SHF_ALLOC | SHF_WRITE | SHF_SCORE_GPREL; 3744 hdr->sh_type = SHT_NOBITS; 3745 } 3746 else if (strcmp (name, ".srdata") == 0) 3747 { 3748 hdr->sh_flags |= SHF_ALLOC | SHF_SCORE_GPREL; 3749 hdr->sh_type = SHT_PROGBITS; 3750 } 3751 } 3752 3753 return TRUE; 3754 } 3755 3756 static bfd_boolean 3757 s3_bfd_score_elf_write_section (bfd *output_bfd, asection *sec, bfd_byte *contents) 3758 { 3759 bfd_byte *to, *from, *end; 3760 int i; 3761 3762 if (strcmp (sec->name, ".pdr") != 0) 3763 return FALSE; 3764 3765 if (score_elf_section_data (sec)->u.tdata == NULL) 3766 return FALSE; 3767 3768 to = contents; 3769 end = contents + sec->size; 3770 for (from = contents, i = 0; from < end; from += PDR_SIZE, i++) 3771 { 3772 if ((score_elf_section_data (sec)->u.tdata)[i] == 1) 3773 continue; 3774 3775 if (to != from) 3776 memcpy (to, from, PDR_SIZE); 3777 3778 to += PDR_SIZE; 3779 } 3780 bfd_set_section_contents (output_bfd, sec->output_section, contents, 3781 (file_ptr) sec->output_offset, sec->size); 3782 3783 return TRUE; 3784 } 3785 3786 /* Copy data from a SCORE ELF indirect symbol to its direct symbol, hiding the old 3787 indirect symbol. Process additional relocation information. */ 3788 static void 3789 s3_bfd_score_elf_copy_indirect_symbol (struct bfd_link_info *info, 3790 struct elf_link_hash_entry *dir, 3791 struct elf_link_hash_entry *ind) 3792 { 3793 struct score_elf_link_hash_entry *dirscore, *indscore; 3794 3795 _bfd_elf_link_hash_copy_indirect (info, dir, ind); 3796 3797 if (ind->root.type != bfd_link_hash_indirect) 3798 return; 3799 3800 dirscore = (struct score_elf_link_hash_entry *) dir; 3801 indscore = (struct score_elf_link_hash_entry *) ind; 3802 dirscore->possibly_dynamic_relocs += indscore->possibly_dynamic_relocs; 3803 3804 if (indscore->readonly_reloc) 3805 dirscore->readonly_reloc = TRUE; 3806 3807 if (indscore->no_fn_stub) 3808 dirscore->no_fn_stub = TRUE; 3809 } 3810 3811 /* Remove information about discarded functions from other sections which mention them. */ 3812 static bfd_boolean 3813 s3_bfd_score_elf_discard_info (bfd *abfd, struct elf_reloc_cookie *cookie, 3814 struct bfd_link_info *info) 3815 { 3816 asection *o; 3817 bfd_boolean ret = FALSE; 3818 unsigned char *tdata; 3819 size_t i, skip; 3820 3821 o = bfd_get_section_by_name (abfd, ".pdr"); 3822 if ((!o) || (o->size == 0) || (o->size % PDR_SIZE != 0) 3823 || (o->output_section != NULL && bfd_is_abs_section (o->output_section))) 3824 return FALSE; 3825 3826 tdata = bfd_zmalloc (o->size / PDR_SIZE); 3827 if (!tdata) 3828 return FALSE; 3829 3830 cookie->rels = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL, info->keep_memory); 3831 if (!cookie->rels) 3832 { 3833 free (tdata); 3834 return FALSE; 3835 } 3836 3837 cookie->rel = cookie->rels; 3838 cookie->relend = cookie->rels + o->reloc_count; 3839 3840 for (i = 0, skip = 0; i < o->size; i++) 3841 { 3842 if (bfd_elf_reloc_symbol_deleted_p (i * PDR_SIZE, cookie)) 3843 { 3844 tdata[i] = 1; 3845 skip++; 3846 } 3847 } 3848 3849 if (skip != 0) 3850 { 3851 score_elf_section_data (o)->u.tdata = tdata; 3852 o->size -= skip * PDR_SIZE; 3853 ret = TRUE; 3854 } 3855 else 3856 free (tdata); 3857 3858 if (!info->keep_memory) 3859 free (cookie->rels); 3860 3861 return ret; 3862 } 3863 3864 /* Signal that discard_info() has removed the discarded relocations for this section. */ 3865 static bfd_boolean 3866 s3_bfd_score_elf_ignore_discarded_relocs (asection *sec) 3867 { 3868 if (strcmp (sec->name, ".pdr") == 0) 3869 return TRUE; 3870 return FALSE; 3871 } 3872 3873 /* Return the section that should be marked against GC for a given 3874 relocation. */ 3875 static asection * 3876 s3_bfd_score_elf_gc_mark_hook (asection *sec, 3877 struct bfd_link_info *info, 3878 Elf_Internal_Rela *rel, 3879 struct elf_link_hash_entry *h, 3880 Elf_Internal_Sym *sym) 3881 { 3882 if (h != NULL) 3883 switch (ELF32_R_TYPE (rel->r_info)) 3884 { 3885 case R_SCORE_GNU_VTINHERIT: 3886 case R_SCORE_GNU_VTENTRY: 3887 return NULL; 3888 } 3889 3890 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym); 3891 } 3892 3893 /* Support for core dump NOTE sections. */ 3894 3895 static bfd_boolean 3896 s3_bfd_score_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note) 3897 { 3898 int offset; 3899 unsigned int raw_size; 3900 3901 switch (note->descsz) 3902 { 3903 default: 3904 return FALSE; 3905 3906 case 148: /* Linux/Score 32-bit. */ 3907 /* pr_cursig */ 3908 elf_tdata (abfd)->core_signal = score_bfd_get_16 (abfd, note->descdata + 12); 3909 3910 /* pr_pid */ 3911 elf_tdata (abfd)->core_lwpid = score_bfd_get_32 (abfd, note->descdata + 24); 3912 3913 /* pr_reg */ 3914 offset = 72; 3915 raw_size = 72; 3916 3917 break; 3918 } 3919 3920 /* Make a ".reg/999" section. */ 3921 return _bfd_elfcore_make_pseudosection (abfd, ".reg", raw_size, note->descpos + offset); 3922 } 3923 3924 static bfd_boolean 3925 s3_bfd_score_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note) 3926 { 3927 switch (note->descsz) 3928 { 3929 default: 3930 return FALSE; 3931 3932 case 124: /* Linux/Score elf_prpsinfo. */ 3933 elf_tdata (abfd)->core_program = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16); 3934 elf_tdata (abfd)->core_command = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80); 3935 } 3936 3937 /* Note that for some reason, a spurious space is tacked 3938 onto the end of the args in some (at least one anyway) 3939 implementations, so strip it off if it exists. */ 3940 3941 { 3942 char *command = elf_tdata (abfd)->core_command; 3943 int n = strlen (command); 3944 3945 if (0 < n && command[n - 1] == ' ') 3946 command[n - 1] = '\0'; 3947 } 3948 3949 return TRUE; 3950 } 3951 3952 3953 /* Score BFD functions. */ 3954 static reloc_howto_type * 3955 s3_elf32_score_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED, bfd_reloc_code_real_type code) 3956 { 3957 unsigned int i; 3958 3959 for (i = 0; i < ARRAY_SIZE (elf32_score_reloc_map); i++) 3960 if (elf32_score_reloc_map[i].bfd_reloc_val == code) 3961 return &elf32_score_howto_table[elf32_score_reloc_map[i].elf_reloc_val]; 3962 3963 return NULL; 3964 } 3965 3966 static reloc_howto_type * 3967 elf32_score_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, 3968 const char *r_name) 3969 { 3970 unsigned int i; 3971 3972 for (i = 0; 3973 i < (sizeof (elf32_score_howto_table) 3974 / sizeof (elf32_score_howto_table[0])); 3975 i++) 3976 if (elf32_score_howto_table[i].name != NULL 3977 && strcasecmp (elf32_score_howto_table[i].name, r_name) == 0) 3978 return &elf32_score_howto_table[i]; 3979 3980 return NULL; 3981 } 3982 3983 static bfd_boolean 3984 s3_elf32_score_print_private_bfd_data (bfd *abfd, void * ptr) 3985 { 3986 FILE *file = (FILE *) ptr; 3987 3988 BFD_ASSERT (abfd != NULL && ptr != NULL); 3989 3990 /* Print normal ELF private data. */ 3991 _bfd_elf_print_private_bfd_data (abfd, ptr); 3992 3993 /* xgettext:c-format */ 3994 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags); 3995 if (elf_elfheader (abfd)->e_flags & EF_SCORE_PIC) 3996 { 3997 fprintf (file, _(" [pic]")); 3998 } 3999 if (elf_elfheader (abfd)->e_flags & EF_SCORE_FIXDEP) 4000 { 4001 fprintf (file, _(" [fix dep]")); 4002 } 4003 fputc ('\n', file); 4004 4005 return TRUE; 4006 } 4007 4008 static bfd_boolean 4009 s3_elf32_score_merge_private_bfd_data (bfd *ibfd, bfd *obfd) 4010 { 4011 flagword in_flags; 4012 flagword out_flags; 4013 4014 if (!_bfd_generic_verify_endian_match (ibfd, obfd)) 4015 return FALSE; 4016 4017 in_flags = elf_elfheader (ibfd)->e_flags; 4018 out_flags = elf_elfheader (obfd)->e_flags; 4019 4020 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour 4021 || bfd_get_flavour (obfd) != bfd_target_elf_flavour) 4022 return TRUE; 4023 4024 in_flags = elf_elfheader (ibfd)->e_flags; 4025 out_flags = elf_elfheader (obfd)->e_flags; 4026 4027 if (! elf_flags_init (obfd)) 4028 { 4029 elf_flags_init (obfd) = TRUE; 4030 elf_elfheader (obfd)->e_flags = in_flags; 4031 4032 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd) 4033 && bfd_get_arch_info (obfd)->the_default) 4034 { 4035 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd)); 4036 } 4037 4038 return TRUE; 4039 } 4040 4041 if (((in_flags & EF_SCORE_PIC) != 0) != ((out_flags & EF_SCORE_PIC) != 0)) 4042 { 4043 (*_bfd_error_handler) (_("%B: warning: linking PIC files with non-PIC files"), ibfd); 4044 } 4045 4046 /* FIXME: Maybe dependency fix compatibility should be checked here. */ 4047 4048 return TRUE; 4049 } 4050 4051 static bfd_boolean 4052 s3_elf32_score_new_section_hook (bfd *abfd, asection *sec) 4053 { 4054 struct _score_elf_section_data *sdata; 4055 bfd_size_type amt = sizeof (*sdata); 4056 4057 sdata = bfd_zalloc (abfd, amt); 4058 if (sdata == NULL) 4059 return FALSE; 4060 sec->used_by_bfd = sdata; 4061 4062 return _bfd_elf_new_section_hook (abfd, sec); 4063 } 4064 4065 /*****************************************************************************/ 4066 4067 /* s3_s7: backend hooks. */ 4068 static void 4069 _bfd_score_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, 4070 arelent *bfd_reloc, 4071 Elf_Internal_Rela *elf_reloc) 4072 { 4073 if (bfd_get_mach (abfd) == bfd_mach_score3) 4074 return s3_bfd_score_info_to_howto (abfd, bfd_reloc, elf_reloc); 4075 else 4076 return s7_bfd_score_info_to_howto (abfd, bfd_reloc, elf_reloc); 4077 } 4078 4079 static bfd_boolean 4080 _bfd_score_elf_relocate_section (bfd *output_bfd, 4081 struct bfd_link_info *info, 4082 bfd *input_bfd, 4083 asection *input_section, 4084 bfd_byte *contents, 4085 Elf_Internal_Rela *relocs, 4086 Elf_Internal_Sym *local_syms, 4087 asection **local_sections) 4088 { 4089 if (bfd_get_mach (output_bfd) == bfd_mach_score3) 4090 return s3_bfd_score_elf_relocate_section (output_bfd, 4091 info, input_bfd, input_section, contents, relocs, 4092 local_syms, local_sections); 4093 else 4094 return s7_bfd_score_elf_relocate_section (output_bfd, 4095 info, input_bfd, input_section, contents, relocs, 4096 local_syms, local_sections); 4097 } 4098 4099 static bfd_boolean 4100 _bfd_score_elf_check_relocs (bfd *abfd, 4101 struct bfd_link_info *info, 4102 asection *sec, 4103 const Elf_Internal_Rela *relocs) 4104 { 4105 if (bfd_get_mach (abfd) == bfd_mach_score3) 4106 return s3_bfd_score_elf_check_relocs (abfd, info, sec, relocs); 4107 else 4108 return s7_bfd_score_elf_check_relocs (abfd, info, sec, relocs); 4109 } 4110 4111 static bfd_boolean 4112 _bfd_score_elf_add_symbol_hook (bfd *abfd, 4113 struct bfd_link_info *info ATTRIBUTE_UNUSED, 4114 Elf_Internal_Sym *sym, 4115 const char **namep ATTRIBUTE_UNUSED, 4116 flagword *flagsp ATTRIBUTE_UNUSED, 4117 asection **secp, 4118 bfd_vma *valp) 4119 { 4120 if (bfd_get_mach (abfd) == bfd_mach_score3) 4121 return s3_bfd_score_elf_add_symbol_hook (abfd, info, sym, namep, flagsp, 4122 secp, valp); 4123 else 4124 return s7_bfd_score_elf_add_symbol_hook (abfd, info, sym, namep, flagsp, 4125 secp, valp); 4126 } 4127 4128 static void 4129 _bfd_score_elf_symbol_processing (bfd *abfd, asymbol *asym) 4130 { 4131 if (bfd_get_mach (abfd) == bfd_mach_score3) 4132 return s3_bfd_score_elf_symbol_processing (abfd, asym); 4133 else 4134 return s7_bfd_score_elf_symbol_processing (abfd, asym); 4135 } 4136 4137 static int 4138 _bfd_score_elf_link_output_symbol_hook (struct bfd_link_info *info ATTRIBUTE_UNUSED, 4139 const char *name ATTRIBUTE_UNUSED, 4140 Elf_Internal_Sym *sym, 4141 asection *input_sec, 4142 struct elf_link_hash_entry *h ATTRIBUTE_UNUSED) 4143 { 4144 /* If link a empty .o, then this filed is NULL. */ 4145 if (info->input_bfds == NULL) 4146 { 4147 /* If we see a common symbol, which implies a relocatable link, then 4148 if a symbol was small common in an input file, mark it as small 4149 common in the output file. */ 4150 if (sym->st_shndx == SHN_COMMON && strcmp (input_sec->name, ".scommon") == 0) 4151 sym->st_shndx = SHN_SCORE_SCOMMON; 4152 return 1; 4153 } 4154 4155 if (bfd_get_mach (info->input_bfds) == bfd_mach_score3) 4156 return s3_bfd_score_elf_link_output_symbol_hook (info, name, sym, input_sec, h); 4157 else 4158 return s7_bfd_score_elf_link_output_symbol_hook (info, name, sym, input_sec, h); 4159 } 4160 4161 static bfd_boolean 4162 _bfd_score_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED, 4163 asection *sec, 4164 int *retval) 4165 { 4166 if (bfd_get_mach (abfd) == bfd_mach_score3) 4167 return s3_bfd_score_elf_section_from_bfd_section (abfd, sec, retval); 4168 else 4169 return s7_bfd_score_elf_section_from_bfd_section (abfd, sec, retval); 4170 } 4171 4172 static bfd_boolean 4173 _bfd_score_elf_adjust_dynamic_symbol (struct bfd_link_info *info, 4174 struct elf_link_hash_entry *h) 4175 { 4176 if (bfd_get_mach (info->input_bfds) == bfd_mach_score3) 4177 return s3_bfd_score_elf_adjust_dynamic_symbol (info, h); 4178 else 4179 return s7_bfd_score_elf_adjust_dynamic_symbol (info, h); 4180 } 4181 4182 static bfd_boolean 4183 _bfd_score_elf_always_size_sections (bfd *output_bfd, 4184 struct bfd_link_info *info) 4185 { 4186 if (bfd_get_mach (output_bfd) == bfd_mach_score3) 4187 return s3_bfd_score_elf_always_size_sections (output_bfd, info); 4188 else 4189 return s7_bfd_score_elf_always_size_sections (output_bfd, info); 4190 } 4191 4192 static bfd_boolean 4193 _bfd_score_elf_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info) 4194 { 4195 if (bfd_get_mach (output_bfd) == bfd_mach_score3) 4196 return s3_bfd_score_elf_size_dynamic_sections (output_bfd, info); 4197 else 4198 return s7_bfd_score_elf_size_dynamic_sections (output_bfd, info); 4199 } 4200 4201 static bfd_boolean 4202 _bfd_score_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info) 4203 { 4204 if (bfd_get_mach (abfd) == bfd_mach_score3) 4205 return s3_bfd_score_elf_create_dynamic_sections (abfd, info); 4206 else 4207 return s7_bfd_score_elf_create_dynamic_sections (abfd, info); 4208 } 4209 4210 static bfd_boolean 4211 _bfd_score_elf_finish_dynamic_symbol (bfd *output_bfd, 4212 struct bfd_link_info *info, 4213 struct elf_link_hash_entry *h, 4214 Elf_Internal_Sym *sym) 4215 { 4216 if (bfd_get_mach (output_bfd) == bfd_mach_score3) 4217 return s3_bfd_score_elf_finish_dynamic_symbol (output_bfd, info, h, sym); 4218 else 4219 return s7_bfd_score_elf_finish_dynamic_symbol (output_bfd, info, h, sym); 4220 } 4221 4222 static bfd_boolean 4223 _bfd_score_elf_finish_dynamic_sections (bfd *output_bfd, 4224 struct bfd_link_info *info) 4225 { 4226 if (bfd_get_mach (output_bfd) == bfd_mach_score3) 4227 return s3_bfd_score_elf_finish_dynamic_sections (output_bfd, info); 4228 else 4229 return s7_bfd_score_elf_finish_dynamic_sections (output_bfd, info); 4230 } 4231 4232 static bfd_boolean 4233 _bfd_score_elf_fake_sections (bfd *abfd ATTRIBUTE_UNUSED, 4234 Elf_Internal_Shdr *hdr, 4235 asection *sec) 4236 { 4237 if (bfd_get_mach (abfd) == bfd_mach_score3) 4238 return s3_bfd_score_elf_fake_sections (abfd, hdr, sec); 4239 else 4240 return s7_bfd_score_elf_fake_sections (abfd, hdr, sec); 4241 } 4242 4243 static bfd_boolean 4244 _bfd_score_elf_section_processing (bfd *abfd ATTRIBUTE_UNUSED, Elf_Internal_Shdr *hdr) 4245 { 4246 if (bfd_get_mach (abfd) == bfd_mach_score3) 4247 return s3_bfd_score_elf_section_processing (abfd, hdr); 4248 else 4249 return s7_bfd_score_elf_section_processing (abfd, hdr); 4250 } 4251 4252 static bfd_boolean 4253 _bfd_score_elf_write_section (bfd *output_bfd, 4254 struct bfd_link_info *link_info ATTRIBUTE_UNUSED, 4255 asection *sec, bfd_byte *contents) 4256 { 4257 if (bfd_get_mach (output_bfd) == bfd_mach_score3) 4258 return s3_bfd_score_elf_write_section (output_bfd, sec, contents); 4259 else 4260 return s7_bfd_score_elf_write_section (output_bfd, sec, contents); 4261 } 4262 4263 static void 4264 _bfd_score_elf_copy_indirect_symbol (struct bfd_link_info *info, 4265 struct elf_link_hash_entry *dir, 4266 struct elf_link_hash_entry *ind) 4267 { 4268 if (bfd_get_mach (info->input_bfds) == bfd_mach_score3) 4269 return s3_bfd_score_elf_copy_indirect_symbol (info, dir, ind); 4270 else 4271 return s7_bfd_score_elf_copy_indirect_symbol (info, dir, ind); 4272 } 4273 4274 static void 4275 _bfd_score_elf_hide_symbol (struct bfd_link_info *info, 4276 struct elf_link_hash_entry *entry, 4277 bfd_boolean force_local) 4278 { 4279 if (bfd_get_mach (info->input_bfds) == bfd_mach_score3) 4280 return s3_bfd_score_elf_hide_symbol (info, entry, force_local); 4281 else 4282 return s7_bfd_score_elf_hide_symbol (info, entry, force_local); 4283 } 4284 4285 static bfd_boolean 4286 _bfd_score_elf_discard_info (bfd *abfd, struct elf_reloc_cookie *cookie, 4287 struct bfd_link_info *info) 4288 { 4289 if (bfd_get_mach (abfd) == bfd_mach_score3) 4290 return s3_bfd_score_elf_discard_info (abfd, cookie, info); 4291 else 4292 return s7_bfd_score_elf_discard_info (abfd, cookie, info); 4293 } 4294 4295 static bfd_boolean 4296 _bfd_score_elf_ignore_discarded_relocs (asection *sec) 4297 { 4298 if (bfd_get_mach (sec->owner) == bfd_mach_score3) 4299 return s3_bfd_score_elf_ignore_discarded_relocs (sec); 4300 else 4301 return s7_bfd_score_elf_ignore_discarded_relocs (sec); 4302 } 4303 4304 static asection * 4305 _bfd_score_elf_gc_mark_hook (asection *sec, 4306 struct bfd_link_info *info, 4307 Elf_Internal_Rela *rel, 4308 struct elf_link_hash_entry *h, 4309 Elf_Internal_Sym *sym) 4310 { 4311 if (bfd_get_mach (info->input_bfds) == bfd_mach_score3) 4312 return s3_bfd_score_elf_gc_mark_hook (sec, info, rel, h, sym); 4313 else 4314 return s7_bfd_score_elf_gc_mark_hook (sec, info, rel, h, sym); 4315 } 4316 4317 static bfd_boolean 4318 _bfd_score_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note) 4319 { 4320 if (bfd_get_mach (abfd) == bfd_mach_score3) 4321 return s3_bfd_score_elf_grok_prstatus (abfd, note); 4322 else 4323 return s7_bfd_score_elf_grok_prstatus (abfd, note); 4324 } 4325 4326 static bfd_boolean 4327 _bfd_score_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note) 4328 { 4329 if (bfd_get_mach (abfd) == bfd_mach_score3) 4330 return s3_bfd_score_elf_grok_psinfo (abfd, note); 4331 else 4332 return s7_bfd_score_elf_grok_psinfo (abfd, note); 4333 } 4334 4335 static reloc_howto_type * 4336 elf32_score_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED, bfd_reloc_code_real_type code) 4337 { 4338 /* s3: NOTE!!! 4339 gas will call elf32_score_reloc_type_lookup, and don't write elf file. 4340 So just using score3, but we don't know ld will call this or not. 4341 If so, this way can't work. */ 4342 4343 if (score3) 4344 return s3_elf32_score_reloc_type_lookup (abfd, code); 4345 else 4346 return s7_elf32_score_reloc_type_lookup (abfd, code); 4347 } 4348 4349 /* Create a score elf linker hash table. 4350 This is a copy of _bfd_elf_link_hash_table_create() except with a 4351 different hash table entry creation function. */ 4352 4353 static struct bfd_link_hash_table * 4354 elf32_score_link_hash_table_create (bfd *abfd) 4355 { 4356 struct elf_link_hash_table *ret; 4357 bfd_size_type amt = sizeof (struct elf_link_hash_table); 4358 4359 ret = (struct elf_link_hash_table *) bfd_malloc (amt); 4360 if (ret == NULL) 4361 return NULL; 4362 4363 if (!_bfd_elf_link_hash_table_init (ret, abfd, score_elf_link_hash_newfunc, 4364 sizeof (struct score_elf_link_hash_entry), 4365 GENERIC_ELF_DATA)) 4366 { 4367 free (ret); 4368 return NULL; 4369 } 4370 4371 return &ret->root; 4372 } 4373 4374 static bfd_boolean 4375 elf32_score_print_private_bfd_data (bfd *abfd, void * ptr) 4376 { 4377 if (bfd_get_mach (abfd) == bfd_mach_score3) 4378 return s3_elf32_score_print_private_bfd_data (abfd, ptr); 4379 else 4380 return s7_elf32_score_print_private_bfd_data (abfd, ptr); 4381 } 4382 4383 static bfd_boolean 4384 elf32_score_merge_private_bfd_data (bfd *ibfd, bfd *obfd) 4385 { 4386 if (bfd_get_mach (obfd) == bfd_mach_score3) 4387 return s3_elf32_score_merge_private_bfd_data (ibfd, obfd); 4388 else 4389 return s7_elf32_score_merge_private_bfd_data (ibfd, obfd); 4390 } 4391 4392 static bfd_boolean 4393 elf32_score_new_section_hook (bfd *abfd, asection *sec) 4394 { 4395 if (bfd_get_mach (abfd) == bfd_mach_score3) 4396 return s3_elf32_score_new_section_hook (abfd, sec); 4397 else 4398 return s7_elf32_score_new_section_hook (abfd, sec); 4399 } 4400 4401 4402 /* s3_s7: don't need to split. */ 4403 4404 /* Set the right machine number. */ 4405 static bfd_boolean 4406 _bfd_score_elf_score_object_p (bfd * abfd) 4407 { 4408 int e_set = bfd_mach_score7; 4409 4410 if (elf_elfheader (abfd)->e_machine == EM_SCORE) 4411 { 4412 int e_mach = elf_elfheader (abfd)->e_flags & EF_SCORE_MACH & EF_OMIT_PIC_FIXDD; 4413 switch (e_mach) 4414 { 4415 /* Set default target is score7. */ 4416 default: 4417 case E_SCORE_MACH_SCORE7: 4418 e_set = bfd_mach_score7; 4419 break; 4420 4421 case E_SCORE_MACH_SCORE3: 4422 e_set = bfd_mach_score3; 4423 break; 4424 } 4425 } 4426 4427 return bfd_default_set_arch_mach (abfd, bfd_arch_score, e_set); 4428 } 4429 4430 bfd_boolean 4431 _bfd_score_elf_common_definition (Elf_Internal_Sym *sym) 4432 { 4433 return (sym->st_shndx == SHN_COMMON || sym->st_shndx == SHN_SCORE_SCOMMON); 4434 } 4435 4436 /*****************************************************************************/ 4437 4438 4439 #define USE_REL 1 4440 #define TARGET_LITTLE_SYM bfd_elf32_littlescore_vec 4441 #define TARGET_LITTLE_NAME "elf32-littlescore" 4442 #define TARGET_BIG_SYM bfd_elf32_bigscore_vec 4443 #define TARGET_BIG_NAME "elf32-bigscore" 4444 #define ELF_ARCH bfd_arch_score 4445 #define ELF_MACHINE_CODE EM_SCORE 4446 #define ELF_MACHINE_ALT1 EM_SCORE_OLD 4447 #define ELF_MAXPAGESIZE 0x8000 4448 4449 #define elf_info_to_howto 0 4450 #define elf_info_to_howto_rel _bfd_score_info_to_howto 4451 #define elf_backend_relocate_section _bfd_score_elf_relocate_section 4452 #define elf_backend_check_relocs _bfd_score_elf_check_relocs 4453 #define elf_backend_add_symbol_hook _bfd_score_elf_add_symbol_hook 4454 #define elf_backend_symbol_processing _bfd_score_elf_symbol_processing 4455 #define elf_backend_link_output_symbol_hook \ 4456 _bfd_score_elf_link_output_symbol_hook 4457 #define elf_backend_section_from_bfd_section \ 4458 _bfd_score_elf_section_from_bfd_section 4459 #define elf_backend_adjust_dynamic_symbol \ 4460 _bfd_score_elf_adjust_dynamic_symbol 4461 #define elf_backend_always_size_sections \ 4462 _bfd_score_elf_always_size_sections 4463 #define elf_backend_size_dynamic_sections \ 4464 _bfd_score_elf_size_dynamic_sections 4465 #define elf_backend_omit_section_dynsym \ 4466 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true) 4467 #define elf_backend_create_dynamic_sections \ 4468 _bfd_score_elf_create_dynamic_sections 4469 #define elf_backend_finish_dynamic_symbol \ 4470 _bfd_score_elf_finish_dynamic_symbol 4471 #define elf_backend_finish_dynamic_sections \ 4472 _bfd_score_elf_finish_dynamic_sections 4473 #define elf_backend_fake_sections _bfd_score_elf_fake_sections 4474 #define elf_backend_section_processing _bfd_score_elf_section_processing 4475 #define elf_backend_write_section _bfd_score_elf_write_section 4476 #define elf_backend_copy_indirect_symbol _bfd_score_elf_copy_indirect_symbol 4477 #define elf_backend_hide_symbol _bfd_score_elf_hide_symbol 4478 #define elf_backend_discard_info _bfd_score_elf_discard_info 4479 #define elf_backend_ignore_discarded_relocs \ 4480 _bfd_score_elf_ignore_discarded_relocs 4481 #define elf_backend_gc_mark_hook _bfd_score_elf_gc_mark_hook 4482 #define elf_backend_grok_prstatus _bfd_score_elf_grok_prstatus 4483 #define elf_backend_grok_psinfo _bfd_score_elf_grok_psinfo 4484 #define elf_backend_can_gc_sections 1 4485 #define elf_backend_want_plt_sym 0 4486 #define elf_backend_got_header_size (4 * SCORE_RESERVED_GOTNO) 4487 #define elf_backend_plt_header_size 0 4488 #define elf_backend_collect TRUE 4489 #define elf_backend_type_change_ok TRUE 4490 #define elf_backend_object_p _bfd_score_elf_score_object_p 4491 4492 #define bfd_elf32_bfd_reloc_type_lookup elf32_score_reloc_type_lookup 4493 #define bfd_elf32_bfd_reloc_name_lookup \ 4494 elf32_score_reloc_name_lookup 4495 #define bfd_elf32_bfd_link_hash_table_create elf32_score_link_hash_table_create 4496 #define bfd_elf32_bfd_print_private_bfd_data elf32_score_print_private_bfd_data 4497 #define bfd_elf32_bfd_merge_private_bfd_data elf32_score_merge_private_bfd_data 4498 #define bfd_elf32_new_section_hook elf32_score_new_section_hook 4499 4500 #include "elf32-target.h" 4501