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 /* PR15323, ref flags aren't set for references in the 2842 same object. */ 2843 h->root.non_ir_ref = 1; 2844 } 2845 } 2846 2847 /* Some relocs require a global offset table. */ 2848 if (dynobj == NULL || sgot == NULL) 2849 { 2850 switch (r_type) 2851 { 2852 case R_SCORE_GOT15: 2853 case R_SCORE_CALL15: 2854 if (dynobj == NULL) 2855 elf_hash_table (info)->dynobj = dynobj = abfd; 2856 if (!score_elf_create_got_section (dynobj, info, FALSE)) 2857 return FALSE; 2858 g = score_elf_got_info (dynobj, &sgot); 2859 break; 2860 case R_SCORE_ABS32: 2861 case R_SCORE_REL32: 2862 if (dynobj == NULL && (info->shared || h != NULL) && (sec->flags & SEC_ALLOC) != 0) 2863 elf_hash_table (info)->dynobj = dynobj = abfd; 2864 break; 2865 default: 2866 break; 2867 } 2868 } 2869 2870 if (!h && (r_type == R_SCORE_GOT_LO16)) 2871 { 2872 if (! score_elf_record_local_got_symbol (abfd, r_symndx, rel->r_addend, g)) 2873 return FALSE; 2874 } 2875 2876 switch (r_type) 2877 { 2878 case R_SCORE_CALL15: 2879 if (h == NULL) 2880 { 2881 (*_bfd_error_handler) 2882 (_("%B: CALL15 reloc at 0x%lx not against global symbol"), 2883 abfd, (unsigned long) rel->r_offset); 2884 bfd_set_error (bfd_error_bad_value); 2885 return FALSE; 2886 } 2887 else 2888 { 2889 /* This symbol requires a global offset table entry. */ 2890 if (! score_elf_record_global_got_symbol (h, abfd, info, g)) 2891 return FALSE; 2892 2893 /* We need a stub, not a plt entry for the undefined function. But we record 2894 it as if it needs plt. See _bfd_elf_adjust_dynamic_symbol. */ 2895 h->needs_plt = 1; 2896 h->type = STT_FUNC; 2897 } 2898 break; 2899 case R_SCORE_GOT15: 2900 if (h && ! score_elf_record_global_got_symbol (h, abfd, info, g)) 2901 return FALSE; 2902 break; 2903 case R_SCORE_ABS32: 2904 case R_SCORE_REL32: 2905 if ((info->shared || h != NULL) && (sec->flags & SEC_ALLOC) != 0) 2906 { 2907 if (sreloc == NULL) 2908 { 2909 sreloc = score_elf_rel_dyn_section (dynobj, TRUE); 2910 if (sreloc == NULL) 2911 return FALSE; 2912 } 2913 #define SCORE_READONLY_SECTION (SEC_ALLOC | SEC_LOAD | SEC_READONLY) 2914 if (info->shared) 2915 { 2916 /* When creating a shared object, we must copy these reloc types into 2917 the output file as R_SCORE_REL32 relocs. We make room for this reloc 2918 in the .rel.dyn reloc section. */ 2919 score_elf_allocate_dynamic_relocations (dynobj, 1); 2920 if ((sec->flags & SCORE_READONLY_SECTION) 2921 == SCORE_READONLY_SECTION) 2922 /* We tell the dynamic linker that there are 2923 relocations against the text segment. */ 2924 info->flags |= DF_TEXTREL; 2925 } 2926 else 2927 { 2928 struct score_elf_link_hash_entry *hscore; 2929 2930 /* We only need to copy this reloc if the symbol is 2931 defined in a dynamic object. */ 2932 hscore = (struct score_elf_link_hash_entry *)h; 2933 ++hscore->possibly_dynamic_relocs; 2934 if ((sec->flags & SCORE_READONLY_SECTION) 2935 == SCORE_READONLY_SECTION) 2936 /* We need it to tell the dynamic linker if there 2937 are relocations against the text segment. */ 2938 hscore->readonly_reloc = TRUE; 2939 } 2940 2941 /* Even though we don't directly need a GOT entry for this symbol, 2942 a symbol must have a dynamic symbol table index greater that 2943 DT_SCORE_GOTSYM if there are dynamic relocations against it. */ 2944 if (h != NULL) 2945 { 2946 if (dynobj == NULL) 2947 elf_hash_table (info)->dynobj = dynobj = abfd; 2948 if (! score_elf_create_got_section (dynobj, info, TRUE)) 2949 return FALSE; 2950 g = score_elf_got_info (dynobj, &sgot); 2951 if (! score_elf_record_global_got_symbol (h, abfd, info, g)) 2952 return FALSE; 2953 } 2954 } 2955 break; 2956 2957 /* This relocation describes the C++ object vtable hierarchy. 2958 Reconstruct it for later use during GC. */ 2959 case R_SCORE_GNU_VTINHERIT: 2960 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset)) 2961 return FALSE; 2962 break; 2963 2964 /* This relocation describes which C++ vtable entries are actually 2965 used. Record for later use during GC. */ 2966 case R_SCORE_GNU_VTENTRY: 2967 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset)) 2968 return FALSE; 2969 break; 2970 default: 2971 break; 2972 } 2973 2974 /* We must not create a stub for a symbol that has relocations 2975 related to taking the function's address. */ 2976 switch (r_type) 2977 { 2978 default: 2979 if (h != NULL) 2980 { 2981 struct score_elf_link_hash_entry *sh; 2982 2983 sh = (struct score_elf_link_hash_entry *) h; 2984 sh->no_fn_stub = TRUE; 2985 } 2986 break; 2987 case R_SCORE_CALL15: 2988 break; 2989 } 2990 } 2991 2992 return TRUE; 2993 } 2994 2995 static bfd_boolean 2996 s3_bfd_score_elf_add_symbol_hook (bfd *abfd, 2997 struct bfd_link_info *info ATTRIBUTE_UNUSED, 2998 Elf_Internal_Sym *sym, 2999 const char **namep ATTRIBUTE_UNUSED, 3000 flagword *flagsp ATTRIBUTE_UNUSED, 3001 asection **secp, 3002 bfd_vma *valp) 3003 { 3004 switch (sym->st_shndx) 3005 { 3006 case SHN_COMMON: 3007 if (sym->st_size > elf_gp_size (abfd)) 3008 break; 3009 /* Fall through. */ 3010 case SHN_SCORE_SCOMMON: 3011 *secp = bfd_make_section_old_way (abfd, ".scommon"); 3012 (*secp)->flags |= SEC_IS_COMMON; 3013 *valp = sym->st_size; 3014 break; 3015 } 3016 3017 return TRUE; 3018 } 3019 3020 static void 3021 s3_bfd_score_elf_symbol_processing (bfd *abfd, asymbol *asym) 3022 { 3023 elf_symbol_type *elfsym; 3024 3025 elfsym = (elf_symbol_type *) asym; 3026 switch (elfsym->internal_elf_sym.st_shndx) 3027 { 3028 case SHN_COMMON: 3029 if (asym->value > elf_gp_size (abfd)) 3030 break; 3031 /* Fall through. */ 3032 case SHN_SCORE_SCOMMON: 3033 if (score_elf_scom_section.name == NULL) 3034 { 3035 /* Initialize the small common section. */ 3036 score_elf_scom_section.name = ".scommon"; 3037 score_elf_scom_section.flags = SEC_IS_COMMON; 3038 score_elf_scom_section.output_section = &score_elf_scom_section; 3039 score_elf_scom_section.symbol = &score_elf_scom_symbol; 3040 score_elf_scom_section.symbol_ptr_ptr = &score_elf_scom_symbol_ptr; 3041 score_elf_scom_symbol.name = ".scommon"; 3042 score_elf_scom_symbol.flags = BSF_SECTION_SYM; 3043 score_elf_scom_symbol.section = &score_elf_scom_section; 3044 score_elf_scom_symbol_ptr = &score_elf_scom_symbol; 3045 } 3046 asym->section = &score_elf_scom_section; 3047 asym->value = elfsym->internal_elf_sym.st_size; 3048 break; 3049 } 3050 } 3051 3052 static int 3053 s3_bfd_score_elf_link_output_symbol_hook (struct bfd_link_info *info ATTRIBUTE_UNUSED, 3054 const char *name ATTRIBUTE_UNUSED, 3055 Elf_Internal_Sym *sym, 3056 asection *input_sec, 3057 struct elf_link_hash_entry *h ATTRIBUTE_UNUSED) 3058 { 3059 /* If we see a common symbol, which implies a relocatable link, then 3060 if a symbol was small common in an input file, mark it as small 3061 common in the output file. */ 3062 if (sym->st_shndx == SHN_COMMON && strcmp (input_sec->name, ".scommon") == 0) 3063 sym->st_shndx = SHN_SCORE_SCOMMON; 3064 3065 return 1; 3066 } 3067 3068 static bfd_boolean 3069 s3_bfd_score_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED, 3070 asection *sec, 3071 int *retval) 3072 { 3073 if (strcmp (bfd_get_section_name (abfd, sec), ".scommon") == 0) 3074 { 3075 *retval = SHN_SCORE_SCOMMON; 3076 return TRUE; 3077 } 3078 3079 return FALSE; 3080 } 3081 3082 /* Adjust a symbol defined by a dynamic object and referenced by a 3083 regular object. The current definition is in some section of the 3084 dynamic object, but we're not including those sections. We have to 3085 change the definition to something the rest of the link can understand. */ 3086 static bfd_boolean 3087 s3_bfd_score_elf_adjust_dynamic_symbol (struct bfd_link_info *info, 3088 struct elf_link_hash_entry *h) 3089 { 3090 bfd *dynobj; 3091 struct score_elf_link_hash_entry *hscore; 3092 asection *s; 3093 3094 dynobj = elf_hash_table (info)->dynobj; 3095 3096 /* Make sure we know what is going on here. */ 3097 BFD_ASSERT (dynobj != NULL 3098 && (h->needs_plt 3099 || h->u.weakdef != NULL 3100 || (h->def_dynamic && h->ref_regular && !h->def_regular))); 3101 3102 /* If this symbol is defined in a dynamic object, we need to copy 3103 any R_SCORE_ABS32 or R_SCORE_REL32 relocs against it into the output 3104 file. */ 3105 hscore = (struct score_elf_link_hash_entry *)h; 3106 if (!info->relocatable 3107 && hscore->possibly_dynamic_relocs != 0 3108 && (h->root.type == bfd_link_hash_defweak || !h->def_regular)) 3109 { 3110 score_elf_allocate_dynamic_relocations (dynobj, hscore->possibly_dynamic_relocs); 3111 if (hscore->readonly_reloc) 3112 /* We tell the dynamic linker that there are relocations 3113 against the text segment. */ 3114 info->flags |= DF_TEXTREL; 3115 } 3116 3117 /* For a function, create a stub, if allowed. */ 3118 if (!hscore->no_fn_stub && h->needs_plt) 3119 { 3120 if (!elf_hash_table (info)->dynamic_sections_created) 3121 return TRUE; 3122 3123 /* If this symbol is not defined in a regular file, then set 3124 the symbol to the stub location. This is required to make 3125 function pointers compare as equal between the normal 3126 executable and the shared library. */ 3127 if (!h->def_regular) 3128 { 3129 /* We need .stub section. */ 3130 s = bfd_get_linker_section (dynobj, SCORE_ELF_STUB_SECTION_NAME); 3131 BFD_ASSERT (s != NULL); 3132 3133 h->root.u.def.section = s; 3134 h->root.u.def.value = s->size; 3135 3136 /* XXX Write this stub address somewhere. */ 3137 h->plt.offset = s->size; 3138 3139 /* Make room for this stub code. */ 3140 s->size += SCORE_FUNCTION_STUB_SIZE; 3141 3142 /* The last half word of the stub will be filled with the index 3143 of this symbol in .dynsym section. */ 3144 return TRUE; 3145 } 3146 } 3147 else if ((h->type == STT_FUNC) && !h->needs_plt) 3148 { 3149 /* This will set the entry for this symbol in the GOT to 0, and 3150 the dynamic linker will take care of this. */ 3151 h->root.u.def.value = 0; 3152 return TRUE; 3153 } 3154 3155 /* If this is a weak symbol, and there is a real definition, the 3156 processor independent code will have arranged for us to see the 3157 real definition first, and we can just use the same value. */ 3158 if (h->u.weakdef != NULL) 3159 { 3160 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined 3161 || h->u.weakdef->root.type == bfd_link_hash_defweak); 3162 h->root.u.def.section = h->u.weakdef->root.u.def.section; 3163 h->root.u.def.value = h->u.weakdef->root.u.def.value; 3164 return TRUE; 3165 } 3166 3167 /* This is a reference to a symbol defined by a dynamic object which 3168 is not a function. */ 3169 return TRUE; 3170 } 3171 3172 /* This function is called after all the input files have been read, 3173 and the input sections have been assigned to output sections. */ 3174 static bfd_boolean 3175 s3_bfd_score_elf_always_size_sections (bfd *output_bfd, 3176 struct bfd_link_info *info) 3177 { 3178 bfd *dynobj; 3179 asection *s; 3180 struct score_got_info *g; 3181 int i; 3182 bfd_size_type loadable_size = 0; 3183 bfd_size_type local_gotno; 3184 bfd *sub; 3185 3186 dynobj = elf_hash_table (info)->dynobj; 3187 if (dynobj == NULL) 3188 /* Relocatable links don't have it. */ 3189 return TRUE; 3190 3191 g = score_elf_got_info (dynobj, &s); 3192 if (s == NULL) 3193 return TRUE; 3194 3195 /* Calculate the total loadable size of the output. That will give us the 3196 maximum number of GOT_PAGE entries required. */ 3197 for (sub = info->input_bfds; sub; sub = sub->link_next) 3198 { 3199 asection *subsection; 3200 3201 for (subsection = sub->sections; 3202 subsection; 3203 subsection = subsection->next) 3204 { 3205 if ((subsection->flags & SEC_ALLOC) == 0) 3206 continue; 3207 loadable_size += ((subsection->size + 0xf) 3208 &~ (bfd_size_type) 0xf); 3209 } 3210 } 3211 3212 /* There has to be a global GOT entry for every symbol with 3213 a dynamic symbol table index of DT_SCORE_GOTSYM or 3214 higher. Therefore, it make sense to put those symbols 3215 that need GOT entries at the end of the symbol table. We 3216 do that here. */ 3217 if (! score_elf_sort_hash_table (info, 1)) 3218 return FALSE; 3219 3220 if (g->global_gotsym != NULL) 3221 i = elf_hash_table (info)->dynsymcount - g->global_gotsym->dynindx; 3222 else 3223 /* If there are no global symbols, or none requiring 3224 relocations, then GLOBAL_GOTSYM will be NULL. */ 3225 i = 0; 3226 3227 /* In the worst case, we'll get one stub per dynamic symbol. */ 3228 loadable_size += SCORE_FUNCTION_STUB_SIZE * i; 3229 3230 /* Assume there are two loadable segments consisting of 3231 contiguous sections. Is 5 enough? */ 3232 local_gotno = (loadable_size >> 16) + 5; 3233 3234 g->local_gotno += local_gotno; 3235 s->size += g->local_gotno * SCORE_ELF_GOT_SIZE (output_bfd); 3236 3237 g->global_gotno = i; 3238 s->size += i * SCORE_ELF_GOT_SIZE (output_bfd); 3239 3240 score_elf_resolve_final_got_entries (g); 3241 3242 if (s->size > SCORE_ELF_GOT_MAX_SIZE (output_bfd)) 3243 { 3244 /* Fixme. Error message or Warning message should be issued here. */ 3245 } 3246 3247 return TRUE; 3248 } 3249 3250 /* Set the sizes of the dynamic sections. */ 3251 static bfd_boolean 3252 s3_bfd_score_elf_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info) 3253 { 3254 bfd *dynobj; 3255 asection *s; 3256 bfd_boolean reltext; 3257 3258 dynobj = elf_hash_table (info)->dynobj; 3259 BFD_ASSERT (dynobj != NULL); 3260 3261 if (elf_hash_table (info)->dynamic_sections_created) 3262 { 3263 /* Set the contents of the .interp section to the interpreter. */ 3264 if (!info->shared) 3265 { 3266 s = bfd_get_linker_section (dynobj, ".interp"); 3267 BFD_ASSERT (s != NULL); 3268 s->size = strlen (ELF_DYNAMIC_INTERPRETER) + 1; 3269 s->contents = (bfd_byte *) ELF_DYNAMIC_INTERPRETER; 3270 } 3271 } 3272 3273 /* The check_relocs and adjust_dynamic_symbol entry points have 3274 determined the sizes of the various dynamic sections. Allocate 3275 memory for them. */ 3276 reltext = FALSE; 3277 for (s = dynobj->sections; s != NULL; s = s->next) 3278 { 3279 const char *name; 3280 3281 if ((s->flags & SEC_LINKER_CREATED) == 0) 3282 continue; 3283 3284 /* It's OK to base decisions on the section name, because none 3285 of the dynobj section names depend upon the input files. */ 3286 name = bfd_get_section_name (dynobj, s); 3287 3288 if (CONST_STRNEQ (name, ".rel")) 3289 { 3290 if (s->size == 0) 3291 { 3292 /* We only strip the section if the output section name 3293 has the same name. Otherwise, there might be several 3294 input sections for this output section. FIXME: This 3295 code is probably not needed these days anyhow, since 3296 the linker now does not create empty output sections. */ 3297 if (s->output_section != NULL 3298 && strcmp (name, 3299 bfd_get_section_name (s->output_section->owner, 3300 s->output_section)) == 0) 3301 s->flags |= SEC_EXCLUDE; 3302 } 3303 else 3304 { 3305 const char *outname; 3306 asection *target; 3307 3308 /* If this relocation section applies to a read only 3309 section, then we probably need a DT_TEXTREL entry. 3310 If the relocation section is .rel.dyn, we always 3311 assert a DT_TEXTREL entry rather than testing whether 3312 there exists a relocation to a read only section or 3313 not. */ 3314 outname = bfd_get_section_name (output_bfd, s->output_section); 3315 target = bfd_get_section_by_name (output_bfd, outname + 4); 3316 if ((target != NULL 3317 && (target->flags & SEC_READONLY) != 0 3318 && (target->flags & SEC_ALLOC) != 0) || strcmp (outname, ".rel.dyn") == 0) 3319 reltext = TRUE; 3320 3321 /* We use the reloc_count field as a counter if we need 3322 to copy relocs into the output file. */ 3323 if (strcmp (name, ".rel.dyn") != 0) 3324 s->reloc_count = 0; 3325 } 3326 } 3327 else if (CONST_STRNEQ (name, ".got")) 3328 { 3329 /* s3_bfd_score_elf_always_size_sections() has already done 3330 most of the work, but some symbols may have been mapped 3331 to versions that we must now resolve in the got_entries 3332 hash tables. */ 3333 } 3334 else if (strcmp (name, SCORE_ELF_STUB_SECTION_NAME) == 0) 3335 { 3336 /* IRIX rld assumes that the function stub isn't at the end 3337 of .text section. So put a dummy. XXX */ 3338 s->size += SCORE_FUNCTION_STUB_SIZE; 3339 } 3340 else if (! CONST_STRNEQ (name, ".init")) 3341 { 3342 /* It's not one of our sections, so don't allocate space. */ 3343 continue; 3344 } 3345 3346 /* Allocate memory for the section contents. */ 3347 s->contents = bfd_zalloc (dynobj, s->size); 3348 if (s->contents == NULL && s->size != 0) 3349 { 3350 bfd_set_error (bfd_error_no_memory); 3351 return FALSE; 3352 } 3353 } 3354 3355 if (elf_hash_table (info)->dynamic_sections_created) 3356 { 3357 /* Add some entries to the .dynamic section. We fill in the 3358 values later, in s3_bfd_score_elf_finish_dynamic_sections, but we 3359 must add the entries now so that we get the correct size for 3360 the .dynamic section. The DT_DEBUG entry is filled in by the 3361 dynamic linker and used by the debugger. */ 3362 3363 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_DEBUG, 0)) 3364 return FALSE; 3365 3366 if (reltext) 3367 info->flags |= DF_TEXTREL; 3368 3369 if ((info->flags & DF_TEXTREL) != 0) 3370 { 3371 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_TEXTREL, 0)) 3372 return FALSE; 3373 } 3374 3375 if (! SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_PLTGOT, 0)) 3376 return FALSE; 3377 3378 if (score_elf_rel_dyn_section (dynobj, FALSE)) 3379 { 3380 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_REL, 0)) 3381 return FALSE; 3382 3383 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELSZ, 0)) 3384 return FALSE; 3385 3386 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_RELENT, 0)) 3387 return FALSE; 3388 } 3389 3390 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_SCORE_BASE_ADDRESS, 0)) 3391 return FALSE; 3392 3393 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_SCORE_LOCAL_GOTNO, 0)) 3394 return FALSE; 3395 3396 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_SCORE_SYMTABNO, 0)) 3397 return FALSE; 3398 3399 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_SCORE_UNREFEXTNO, 0)) 3400 return FALSE; 3401 3402 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_SCORE_GOTSYM, 0)) 3403 return FALSE; 3404 3405 if (!SCORE_ELF_ADD_DYNAMIC_ENTRY (info, DT_SCORE_HIPAGENO, 0)) 3406 return FALSE; 3407 } 3408 3409 return TRUE; 3410 } 3411 3412 static bfd_boolean 3413 s3_bfd_score_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info) 3414 { 3415 struct elf_link_hash_entry *h; 3416 struct bfd_link_hash_entry *bh; 3417 flagword flags; 3418 asection *s; 3419 3420 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY 3421 | SEC_LINKER_CREATED | SEC_READONLY); 3422 3423 /* ABI requests the .dynamic section to be read only. */ 3424 s = bfd_get_linker_section (abfd, ".dynamic"); 3425 if (s != NULL) 3426 { 3427 if (!bfd_set_section_flags (abfd, s, flags)) 3428 return FALSE; 3429 } 3430 3431 /* We need to create .got section. */ 3432 if (!score_elf_create_got_section (abfd, info, FALSE)) 3433 return FALSE; 3434 3435 if (!score_elf_rel_dyn_section (elf_hash_table (info)->dynobj, TRUE)) 3436 return FALSE; 3437 3438 /* Create .stub section. */ 3439 if (bfd_get_linker_section (abfd, SCORE_ELF_STUB_SECTION_NAME) == NULL) 3440 { 3441 s = bfd_make_section_anyway_with_flags (abfd, SCORE_ELF_STUB_SECTION_NAME, 3442 flags | SEC_CODE); 3443 if (s == NULL 3444 || !bfd_set_section_alignment (abfd, s, 2)) 3445 3446 return FALSE; 3447 } 3448 3449 if (!info->shared) 3450 { 3451 const char *name; 3452 3453 name = "_DYNAMIC_LINK"; 3454 bh = NULL; 3455 if (!(_bfd_generic_link_add_one_symbol 3456 (info, abfd, name, BSF_GLOBAL, bfd_abs_section_ptr, 3457 (bfd_vma) 0, NULL, FALSE, get_elf_backend_data (abfd)->collect, &bh))) 3458 return FALSE; 3459 3460 h = (struct elf_link_hash_entry *)bh; 3461 h->non_elf = 0; 3462 h->def_regular = 1; 3463 h->type = STT_SECTION; 3464 3465 if (!bfd_elf_link_record_dynamic_symbol (info, h)) 3466 return FALSE; 3467 } 3468 3469 return TRUE; 3470 } 3471 3472 3473 /* Finish up dynamic symbol handling. We set the contents of various 3474 dynamic sections here. */ 3475 static bfd_boolean 3476 s3_bfd_score_elf_finish_dynamic_symbol (bfd *output_bfd, 3477 struct bfd_link_info *info, 3478 struct elf_link_hash_entry *h, 3479 Elf_Internal_Sym *sym) 3480 { 3481 bfd *dynobj; 3482 asection *sgot; 3483 struct score_got_info *g; 3484 const char *name; 3485 3486 dynobj = elf_hash_table (info)->dynobj; 3487 3488 if (h->plt.offset != MINUS_ONE) 3489 { 3490 asection *s; 3491 bfd_byte stub[SCORE_FUNCTION_STUB_SIZE]; 3492 3493 /* This symbol has a stub. Set it up. */ 3494 BFD_ASSERT (h->dynindx != -1); 3495 3496 s = bfd_get_linker_section (dynobj, SCORE_ELF_STUB_SECTION_NAME); 3497 BFD_ASSERT (s != NULL); 3498 3499 /* FIXME: Can h->dynindex be more than 64K? */ 3500 if (h->dynindx & 0xffff0000) 3501 return FALSE; 3502 3503 /* Fill the stub. */ 3504 score_bfd_put_32 (output_bfd, STUB_LW, stub); 3505 score_bfd_put_32 (output_bfd, STUB_MOVE, stub + 4); 3506 score_bfd_put_32 (output_bfd, STUB_LI16 | (h->dynindx << 1), stub + 8); 3507 score_bfd_put_32 (output_bfd, STUB_BRL, stub + 12); 3508 3509 BFD_ASSERT (h->plt.offset <= s->size); 3510 memcpy (s->contents + h->plt.offset, stub, SCORE_FUNCTION_STUB_SIZE); 3511 3512 /* Mark the symbol as undefined. plt.offset != -1 occurs 3513 only for the referenced symbol. */ 3514 sym->st_shndx = SHN_UNDEF; 3515 3516 /* The run-time linker uses the st_value field of the symbol 3517 to reset the global offset table entry for this external 3518 to its stub address when unlinking a shared object. */ 3519 sym->st_value = (s->output_section->vma + s->output_offset + h->plt.offset); 3520 } 3521 3522 BFD_ASSERT (h->dynindx != -1 || h->forced_local); 3523 3524 sgot = score_elf_got_section (dynobj, FALSE); 3525 BFD_ASSERT (sgot != NULL); 3526 BFD_ASSERT (score_elf_section_data (sgot) != NULL); 3527 g = score_elf_section_data (sgot)->u.got_info; 3528 BFD_ASSERT (g != NULL); 3529 3530 /* Run through the global symbol table, creating GOT entries for all 3531 the symbols that need them. */ 3532 if (g->global_gotsym != NULL && h->dynindx >= g->global_gotsym->dynindx) 3533 { 3534 bfd_vma offset; 3535 bfd_vma value; 3536 3537 value = sym->st_value; 3538 offset = score_elf_global_got_index (dynobj, h); 3539 score_bfd_put_32 (output_bfd, value, sgot->contents + offset); 3540 } 3541 3542 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */ 3543 name = h->root.root.string; 3544 if (h == elf_hash_table (info)->hdynamic 3545 || h == elf_hash_table (info)->hgot) 3546 sym->st_shndx = SHN_ABS; 3547 else if (strcmp (name, "_DYNAMIC_LINK") == 0) 3548 { 3549 sym->st_shndx = SHN_ABS; 3550 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION); 3551 sym->st_value = 1; 3552 } 3553 else if (strcmp (name, GP_DISP_LABEL) == 0) 3554 { 3555 sym->st_shndx = SHN_ABS; 3556 sym->st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION); 3557 sym->st_value = elf_gp (output_bfd); 3558 } 3559 3560 return TRUE; 3561 } 3562 3563 /* Finish up the dynamic sections. */ 3564 static bfd_boolean 3565 s3_bfd_score_elf_finish_dynamic_sections (bfd *output_bfd, 3566 struct bfd_link_info *info) 3567 { 3568 bfd *dynobj; 3569 asection *sdyn; 3570 asection *sgot; 3571 asection *s; 3572 struct score_got_info *g; 3573 3574 dynobj = elf_hash_table (info)->dynobj; 3575 3576 sdyn = bfd_get_linker_section (dynobj, ".dynamic"); 3577 3578 sgot = score_elf_got_section (dynobj, FALSE); 3579 if (sgot == NULL) 3580 g = NULL; 3581 else 3582 { 3583 BFD_ASSERT (score_elf_section_data (sgot) != NULL); 3584 g = score_elf_section_data (sgot)->u.got_info; 3585 BFD_ASSERT (g != NULL); 3586 } 3587 3588 if (elf_hash_table (info)->dynamic_sections_created) 3589 { 3590 bfd_byte *b; 3591 3592 BFD_ASSERT (sdyn != NULL); 3593 BFD_ASSERT (g != NULL); 3594 3595 for (b = sdyn->contents; 3596 b < sdyn->contents + sdyn->size; 3597 b += SCORE_ELF_DYN_SIZE (dynobj)) 3598 { 3599 Elf_Internal_Dyn dyn; 3600 const char *name; 3601 size_t elemsize; 3602 bfd_boolean swap_out_p; 3603 3604 /* Read in the current dynamic entry. */ 3605 (*get_elf_backend_data (dynobj)->s->swap_dyn_in) (dynobj, b, &dyn); 3606 3607 /* Assume that we're going to modify it and write it out. */ 3608 swap_out_p = TRUE; 3609 3610 switch (dyn.d_tag) 3611 { 3612 case DT_RELENT: 3613 s = score_elf_rel_dyn_section (dynobj, FALSE); 3614 BFD_ASSERT (s != NULL); 3615 dyn.d_un.d_val = SCORE_ELF_REL_SIZE (dynobj); 3616 break; 3617 3618 case DT_STRSZ: 3619 /* Rewrite DT_STRSZ. */ 3620 dyn.d_un.d_val = _bfd_elf_strtab_size (elf_hash_table (info)->dynstr); 3621 break; 3622 3623 case DT_PLTGOT: 3624 name = ".got"; 3625 s = bfd_get_section_by_name (output_bfd, name); 3626 BFD_ASSERT (s != NULL); 3627 dyn.d_un.d_ptr = s->vma; 3628 break; 3629 3630 case DT_SCORE_BASE_ADDRESS: 3631 s = output_bfd->sections; 3632 BFD_ASSERT (s != NULL); 3633 dyn.d_un.d_ptr = s->vma & ~(bfd_vma) 0xffff; 3634 break; 3635 3636 case DT_SCORE_LOCAL_GOTNO: 3637 dyn.d_un.d_val = g->local_gotno; 3638 break; 3639 3640 case DT_SCORE_UNREFEXTNO: 3641 /* The index into the dynamic symbol table which is the 3642 entry of the first external symbol that is not 3643 referenced within the same object. */ 3644 dyn.d_un.d_val = bfd_count_sections (output_bfd) + 1; 3645 break; 3646 3647 case DT_SCORE_GOTSYM: 3648 if (g->global_gotsym) 3649 { 3650 dyn.d_un.d_val = g->global_gotsym->dynindx; 3651 break; 3652 } 3653 /* In case if we don't have global got symbols we default 3654 to setting DT_SCORE_GOTSYM to the same value as 3655 DT_SCORE_SYMTABNO, so we just fall through. */ 3656 3657 case DT_SCORE_SYMTABNO: 3658 name = ".dynsym"; 3659 elemsize = SCORE_ELF_SYM_SIZE (output_bfd); 3660 s = bfd_get_section_by_name (output_bfd, name); 3661 BFD_ASSERT (s != NULL); 3662 3663 dyn.d_un.d_val = s->size / elemsize; 3664 break; 3665 3666 case DT_SCORE_HIPAGENO: 3667 dyn.d_un.d_val = g->local_gotno - SCORE_RESERVED_GOTNO; 3668 break; 3669 3670 default: 3671 swap_out_p = FALSE; 3672 break; 3673 } 3674 3675 if (swap_out_p) 3676 (*get_elf_backend_data (dynobj)->s->swap_dyn_out) (dynobj, &dyn, b); 3677 } 3678 } 3679 3680 /* The first entry of the global offset table will be filled at 3681 runtime. The second entry will be used by some runtime loaders. 3682 This isn't the case of IRIX rld. */ 3683 if (sgot != NULL && sgot->size > 0) 3684 { 3685 score_bfd_put_32 (output_bfd, 0, sgot->contents); 3686 score_bfd_put_32 (output_bfd, 0x80000000, sgot->contents + SCORE_ELF_GOT_SIZE (output_bfd)); 3687 } 3688 3689 if (sgot != NULL) 3690 elf_section_data (sgot->output_section)->this_hdr.sh_entsize 3691 = SCORE_ELF_GOT_SIZE (output_bfd); 3692 3693 3694 /* We need to sort the entries of the dynamic relocation section. */ 3695 s = score_elf_rel_dyn_section (dynobj, FALSE); 3696 3697 if (s != NULL && s->size > (bfd_vma)2 * SCORE_ELF_REL_SIZE (output_bfd)) 3698 { 3699 reldyn_sorting_bfd = output_bfd; 3700 qsort ((Elf32_External_Rel *) s->contents + 1, s->reloc_count - 1, 3701 sizeof (Elf32_External_Rel), score_elf_sort_dynamic_relocs); 3702 } 3703 3704 return TRUE; 3705 } 3706 3707 /* This function set up the ELF section header for a BFD section in preparation for writing 3708 it out. This is where the flags and type fields are set for unusual sections. */ 3709 static bfd_boolean 3710 s3_bfd_score_elf_fake_sections (bfd *abfd ATTRIBUTE_UNUSED, 3711 Elf_Internal_Shdr *hdr, 3712 asection *sec) 3713 { 3714 const char *name; 3715 3716 name = bfd_get_section_name (abfd, sec); 3717 3718 if (strcmp (name, ".got") == 0 3719 || strcmp (name, ".srdata") == 0 3720 || strcmp (name, ".sdata") == 0 3721 || strcmp (name, ".sbss") == 0) 3722 hdr->sh_flags |= SHF_SCORE_GPREL; 3723 3724 return TRUE; 3725 } 3726 3727 /* This function do additional processing on the ELF section header before writing 3728 it out. This is used to set the flags and type fields for some sections. */ 3729 3730 /* assign_file_positions_except_relocs() check section flag and if it is allocatable, 3731 warning message will be issued. backend_fake_section is called before 3732 assign_file_positions_except_relocs(); backend_section_processing after it. so, we 3733 modify section flag there, but not backend_fake_section. */ 3734 static bfd_boolean 3735 s3_bfd_score_elf_section_processing (bfd *abfd ATTRIBUTE_UNUSED, Elf_Internal_Shdr *hdr) 3736 { 3737 if (hdr->bfd_section != NULL) 3738 { 3739 const char *name = bfd_get_section_name (abfd, hdr->bfd_section); 3740 3741 if (strcmp (name, ".sdata") == 0) 3742 { 3743 hdr->sh_flags |= SHF_ALLOC | SHF_WRITE | SHF_SCORE_GPREL; 3744 hdr->sh_type = SHT_PROGBITS; 3745 } 3746 else if (strcmp (name, ".sbss") == 0) 3747 { 3748 hdr->sh_flags |= SHF_ALLOC | SHF_WRITE | SHF_SCORE_GPREL; 3749 hdr->sh_type = SHT_NOBITS; 3750 } 3751 else if (strcmp (name, ".srdata") == 0) 3752 { 3753 hdr->sh_flags |= SHF_ALLOC | SHF_SCORE_GPREL; 3754 hdr->sh_type = SHT_PROGBITS; 3755 } 3756 } 3757 3758 return TRUE; 3759 } 3760 3761 static bfd_boolean 3762 s3_bfd_score_elf_write_section (bfd *output_bfd, asection *sec, bfd_byte *contents) 3763 { 3764 bfd_byte *to, *from, *end; 3765 int i; 3766 3767 if (strcmp (sec->name, ".pdr") != 0) 3768 return FALSE; 3769 3770 if (score_elf_section_data (sec)->u.tdata == NULL) 3771 return FALSE; 3772 3773 to = contents; 3774 end = contents + sec->size; 3775 for (from = contents, i = 0; from < end; from += PDR_SIZE, i++) 3776 { 3777 if ((score_elf_section_data (sec)->u.tdata)[i] == 1) 3778 continue; 3779 3780 if (to != from) 3781 memcpy (to, from, PDR_SIZE); 3782 3783 to += PDR_SIZE; 3784 } 3785 bfd_set_section_contents (output_bfd, sec->output_section, contents, 3786 (file_ptr) sec->output_offset, sec->size); 3787 3788 return TRUE; 3789 } 3790 3791 /* Copy data from a SCORE ELF indirect symbol to its direct symbol, hiding the old 3792 indirect symbol. Process additional relocation information. */ 3793 static void 3794 s3_bfd_score_elf_copy_indirect_symbol (struct bfd_link_info *info, 3795 struct elf_link_hash_entry *dir, 3796 struct elf_link_hash_entry *ind) 3797 { 3798 struct score_elf_link_hash_entry *dirscore, *indscore; 3799 3800 _bfd_elf_link_hash_copy_indirect (info, dir, ind); 3801 3802 if (ind->root.type != bfd_link_hash_indirect) 3803 return; 3804 3805 dirscore = (struct score_elf_link_hash_entry *) dir; 3806 indscore = (struct score_elf_link_hash_entry *) ind; 3807 dirscore->possibly_dynamic_relocs += indscore->possibly_dynamic_relocs; 3808 3809 if (indscore->readonly_reloc) 3810 dirscore->readonly_reloc = TRUE; 3811 3812 if (indscore->no_fn_stub) 3813 dirscore->no_fn_stub = TRUE; 3814 } 3815 3816 /* Remove information about discarded functions from other sections which mention them. */ 3817 static bfd_boolean 3818 s3_bfd_score_elf_discard_info (bfd *abfd, struct elf_reloc_cookie *cookie, 3819 struct bfd_link_info *info) 3820 { 3821 asection *o; 3822 bfd_boolean ret = FALSE; 3823 unsigned char *tdata; 3824 size_t i, skip; 3825 3826 o = bfd_get_section_by_name (abfd, ".pdr"); 3827 if ((!o) || (o->size == 0) || (o->size % PDR_SIZE != 0) 3828 || (o->output_section != NULL && bfd_is_abs_section (o->output_section))) 3829 return FALSE; 3830 3831 tdata = bfd_zmalloc (o->size / PDR_SIZE); 3832 if (!tdata) 3833 return FALSE; 3834 3835 cookie->rels = _bfd_elf_link_read_relocs (abfd, o, NULL, NULL, info->keep_memory); 3836 if (!cookie->rels) 3837 { 3838 free (tdata); 3839 return FALSE; 3840 } 3841 3842 cookie->rel = cookie->rels; 3843 cookie->relend = cookie->rels + o->reloc_count; 3844 3845 for (i = 0, skip = 0; i < o->size; i++) 3846 { 3847 if (bfd_elf_reloc_symbol_deleted_p (i * PDR_SIZE, cookie)) 3848 { 3849 tdata[i] = 1; 3850 skip++; 3851 } 3852 } 3853 3854 if (skip != 0) 3855 { 3856 score_elf_section_data (o)->u.tdata = tdata; 3857 o->size -= skip * PDR_SIZE; 3858 ret = TRUE; 3859 } 3860 else 3861 free (tdata); 3862 3863 if (!info->keep_memory) 3864 free (cookie->rels); 3865 3866 return ret; 3867 } 3868 3869 /* Signal that discard_info() has removed the discarded relocations for this section. */ 3870 static bfd_boolean 3871 s3_bfd_score_elf_ignore_discarded_relocs (asection *sec) 3872 { 3873 if (strcmp (sec->name, ".pdr") == 0) 3874 return TRUE; 3875 return FALSE; 3876 } 3877 3878 /* Return the section that should be marked against GC for a given 3879 relocation. */ 3880 static asection * 3881 s3_bfd_score_elf_gc_mark_hook (asection *sec, 3882 struct bfd_link_info *info, 3883 Elf_Internal_Rela *rel, 3884 struct elf_link_hash_entry *h, 3885 Elf_Internal_Sym *sym) 3886 { 3887 if (h != NULL) 3888 switch (ELF32_R_TYPE (rel->r_info)) 3889 { 3890 case R_SCORE_GNU_VTINHERIT: 3891 case R_SCORE_GNU_VTENTRY: 3892 return NULL; 3893 } 3894 3895 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym); 3896 } 3897 3898 /* Support for core dump NOTE sections. */ 3899 3900 static bfd_boolean 3901 s3_bfd_score_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note) 3902 { 3903 int offset; 3904 unsigned int raw_size; 3905 3906 switch (note->descsz) 3907 { 3908 default: 3909 return FALSE; 3910 3911 case 148: /* Linux/Score 32-bit. */ 3912 /* pr_cursig */ 3913 elf_tdata (abfd)->core->signal 3914 = score_bfd_get_16 (abfd, note->descdata + 12); 3915 3916 /* pr_pid */ 3917 elf_tdata (abfd)->core->lwpid 3918 = score_bfd_get_32 (abfd, note->descdata + 24); 3919 3920 /* pr_reg */ 3921 offset = 72; 3922 raw_size = 72; 3923 3924 break; 3925 } 3926 3927 /* Make a ".reg/999" section. */ 3928 return _bfd_elfcore_make_pseudosection (abfd, ".reg", raw_size, 3929 note->descpos + offset); 3930 } 3931 3932 static bfd_boolean 3933 s3_bfd_score_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note) 3934 { 3935 switch (note->descsz) 3936 { 3937 default: 3938 return FALSE; 3939 3940 case 124: /* Linux/Score elf_prpsinfo. */ 3941 elf_tdata (abfd)->core->program 3942 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16); 3943 elf_tdata (abfd)->core->command 3944 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80); 3945 } 3946 3947 /* Note that for some reason, a spurious space is tacked 3948 onto the end of the args in some (at least one anyway) 3949 implementations, so strip it off if it exists. */ 3950 3951 { 3952 char *command = elf_tdata (abfd)->core->command; 3953 int n = strlen (command); 3954 3955 if (0 < n && command[n - 1] == ' ') 3956 command[n - 1] = '\0'; 3957 } 3958 3959 return TRUE; 3960 } 3961 3962 3963 /* Score BFD functions. */ 3964 static reloc_howto_type * 3965 s3_elf32_score_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED, bfd_reloc_code_real_type code) 3966 { 3967 unsigned int i; 3968 3969 for (i = 0; i < ARRAY_SIZE (elf32_score_reloc_map); i++) 3970 if (elf32_score_reloc_map[i].bfd_reloc_val == code) 3971 return &elf32_score_howto_table[elf32_score_reloc_map[i].elf_reloc_val]; 3972 3973 return NULL; 3974 } 3975 3976 static reloc_howto_type * 3977 elf32_score_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, 3978 const char *r_name) 3979 { 3980 unsigned int i; 3981 3982 for (i = 0; 3983 i < (sizeof (elf32_score_howto_table) 3984 / sizeof (elf32_score_howto_table[0])); 3985 i++) 3986 if (elf32_score_howto_table[i].name != NULL 3987 && strcasecmp (elf32_score_howto_table[i].name, r_name) == 0) 3988 return &elf32_score_howto_table[i]; 3989 3990 return NULL; 3991 } 3992 3993 static bfd_boolean 3994 s3_elf32_score_print_private_bfd_data (bfd *abfd, void * ptr) 3995 { 3996 FILE *file = (FILE *) ptr; 3997 3998 BFD_ASSERT (abfd != NULL && ptr != NULL); 3999 4000 /* Print normal ELF private data. */ 4001 _bfd_elf_print_private_bfd_data (abfd, ptr); 4002 4003 /* xgettext:c-format */ 4004 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags); 4005 if (elf_elfheader (abfd)->e_flags & EF_SCORE_PIC) 4006 { 4007 fprintf (file, _(" [pic]")); 4008 } 4009 if (elf_elfheader (abfd)->e_flags & EF_SCORE_FIXDEP) 4010 { 4011 fprintf (file, _(" [fix dep]")); 4012 } 4013 fputc ('\n', file); 4014 4015 return TRUE; 4016 } 4017 4018 static bfd_boolean 4019 s3_elf32_score_merge_private_bfd_data (bfd *ibfd, bfd *obfd) 4020 { 4021 flagword in_flags; 4022 flagword out_flags; 4023 4024 if (!_bfd_generic_verify_endian_match (ibfd, obfd)) 4025 return FALSE; 4026 4027 in_flags = elf_elfheader (ibfd)->e_flags; 4028 out_flags = elf_elfheader (obfd)->e_flags; 4029 4030 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour 4031 || bfd_get_flavour (obfd) != bfd_target_elf_flavour) 4032 return TRUE; 4033 4034 in_flags = elf_elfheader (ibfd)->e_flags; 4035 out_flags = elf_elfheader (obfd)->e_flags; 4036 4037 if (! elf_flags_init (obfd)) 4038 { 4039 elf_flags_init (obfd) = TRUE; 4040 elf_elfheader (obfd)->e_flags = in_flags; 4041 4042 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd) 4043 && bfd_get_arch_info (obfd)->the_default) 4044 { 4045 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd)); 4046 } 4047 4048 return TRUE; 4049 } 4050 4051 if (((in_flags & EF_SCORE_PIC) != 0) != ((out_flags & EF_SCORE_PIC) != 0)) 4052 { 4053 (*_bfd_error_handler) (_("%B: warning: linking PIC files with non-PIC files"), ibfd); 4054 } 4055 4056 /* FIXME: Maybe dependency fix compatibility should be checked here. */ 4057 4058 return TRUE; 4059 } 4060 4061 static bfd_boolean 4062 s3_elf32_score_new_section_hook (bfd *abfd, asection *sec) 4063 { 4064 struct _score_elf_section_data *sdata; 4065 bfd_size_type amt = sizeof (*sdata); 4066 4067 sdata = bfd_zalloc (abfd, amt); 4068 if (sdata == NULL) 4069 return FALSE; 4070 sec->used_by_bfd = sdata; 4071 4072 return _bfd_elf_new_section_hook (abfd, sec); 4073 } 4074 4075 /*****************************************************************************/ 4076 4077 /* s3_s7: backend hooks. */ 4078 static void 4079 _bfd_score_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, 4080 arelent *bfd_reloc, 4081 Elf_Internal_Rela *elf_reloc) 4082 { 4083 if (bfd_get_mach (abfd) == bfd_mach_score3) 4084 return s3_bfd_score_info_to_howto (abfd, bfd_reloc, elf_reloc); 4085 else 4086 return s7_bfd_score_info_to_howto (abfd, bfd_reloc, elf_reloc); 4087 } 4088 4089 static bfd_boolean 4090 _bfd_score_elf_relocate_section (bfd *output_bfd, 4091 struct bfd_link_info *info, 4092 bfd *input_bfd, 4093 asection *input_section, 4094 bfd_byte *contents, 4095 Elf_Internal_Rela *relocs, 4096 Elf_Internal_Sym *local_syms, 4097 asection **local_sections) 4098 { 4099 if (bfd_get_mach (output_bfd) == bfd_mach_score3) 4100 return s3_bfd_score_elf_relocate_section (output_bfd, 4101 info, input_bfd, input_section, contents, relocs, 4102 local_syms, local_sections); 4103 else 4104 return s7_bfd_score_elf_relocate_section (output_bfd, 4105 info, input_bfd, input_section, contents, relocs, 4106 local_syms, local_sections); 4107 } 4108 4109 static bfd_boolean 4110 _bfd_score_elf_check_relocs (bfd *abfd, 4111 struct bfd_link_info *info, 4112 asection *sec, 4113 const Elf_Internal_Rela *relocs) 4114 { 4115 if (bfd_get_mach (abfd) == bfd_mach_score3) 4116 return s3_bfd_score_elf_check_relocs (abfd, info, sec, relocs); 4117 else 4118 return s7_bfd_score_elf_check_relocs (abfd, info, sec, relocs); 4119 } 4120 4121 static bfd_boolean 4122 _bfd_score_elf_add_symbol_hook (bfd *abfd, 4123 struct bfd_link_info *info ATTRIBUTE_UNUSED, 4124 Elf_Internal_Sym *sym, 4125 const char **namep ATTRIBUTE_UNUSED, 4126 flagword *flagsp ATTRIBUTE_UNUSED, 4127 asection **secp, 4128 bfd_vma *valp) 4129 { 4130 if (bfd_get_mach (abfd) == bfd_mach_score3) 4131 return s3_bfd_score_elf_add_symbol_hook (abfd, info, sym, namep, flagsp, 4132 secp, valp); 4133 else 4134 return s7_bfd_score_elf_add_symbol_hook (abfd, info, sym, namep, flagsp, 4135 secp, valp); 4136 } 4137 4138 static void 4139 _bfd_score_elf_symbol_processing (bfd *abfd, asymbol *asym) 4140 { 4141 if (bfd_get_mach (abfd) == bfd_mach_score3) 4142 return s3_bfd_score_elf_symbol_processing (abfd, asym); 4143 else 4144 return s7_bfd_score_elf_symbol_processing (abfd, asym); 4145 } 4146 4147 static int 4148 _bfd_score_elf_link_output_symbol_hook (struct bfd_link_info *info ATTRIBUTE_UNUSED, 4149 const char *name ATTRIBUTE_UNUSED, 4150 Elf_Internal_Sym *sym, 4151 asection *input_sec, 4152 struct elf_link_hash_entry *h ATTRIBUTE_UNUSED) 4153 { 4154 /* If link a empty .o, then this filed is NULL. */ 4155 if (info->input_bfds == NULL) 4156 { 4157 /* If we see a common symbol, which implies a relocatable link, then 4158 if a symbol was small common in an input file, mark it as small 4159 common in the output file. */ 4160 if (sym->st_shndx == SHN_COMMON && strcmp (input_sec->name, ".scommon") == 0) 4161 sym->st_shndx = SHN_SCORE_SCOMMON; 4162 return 1; 4163 } 4164 4165 if (bfd_get_mach (info->input_bfds) == bfd_mach_score3) 4166 return s3_bfd_score_elf_link_output_symbol_hook (info, name, sym, input_sec, h); 4167 else 4168 return s7_bfd_score_elf_link_output_symbol_hook (info, name, sym, input_sec, h); 4169 } 4170 4171 static bfd_boolean 4172 _bfd_score_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED, 4173 asection *sec, 4174 int *retval) 4175 { 4176 if (bfd_get_mach (abfd) == bfd_mach_score3) 4177 return s3_bfd_score_elf_section_from_bfd_section (abfd, sec, retval); 4178 else 4179 return s7_bfd_score_elf_section_from_bfd_section (abfd, sec, retval); 4180 } 4181 4182 static bfd_boolean 4183 _bfd_score_elf_adjust_dynamic_symbol (struct bfd_link_info *info, 4184 struct elf_link_hash_entry *h) 4185 { 4186 if (bfd_get_mach (info->input_bfds) == bfd_mach_score3) 4187 return s3_bfd_score_elf_adjust_dynamic_symbol (info, h); 4188 else 4189 return s7_bfd_score_elf_adjust_dynamic_symbol (info, h); 4190 } 4191 4192 static bfd_boolean 4193 _bfd_score_elf_always_size_sections (bfd *output_bfd, 4194 struct bfd_link_info *info) 4195 { 4196 if (bfd_get_mach (output_bfd) == bfd_mach_score3) 4197 return s3_bfd_score_elf_always_size_sections (output_bfd, info); 4198 else 4199 return s7_bfd_score_elf_always_size_sections (output_bfd, info); 4200 } 4201 4202 static bfd_boolean 4203 _bfd_score_elf_size_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info) 4204 { 4205 if (bfd_get_mach (output_bfd) == bfd_mach_score3) 4206 return s3_bfd_score_elf_size_dynamic_sections (output_bfd, info); 4207 else 4208 return s7_bfd_score_elf_size_dynamic_sections (output_bfd, info); 4209 } 4210 4211 static bfd_boolean 4212 _bfd_score_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info) 4213 { 4214 if (bfd_get_mach (abfd) == bfd_mach_score3) 4215 return s3_bfd_score_elf_create_dynamic_sections (abfd, info); 4216 else 4217 return s7_bfd_score_elf_create_dynamic_sections (abfd, info); 4218 } 4219 4220 static bfd_boolean 4221 _bfd_score_elf_finish_dynamic_symbol (bfd *output_bfd, 4222 struct bfd_link_info *info, 4223 struct elf_link_hash_entry *h, 4224 Elf_Internal_Sym *sym) 4225 { 4226 if (bfd_get_mach (output_bfd) == bfd_mach_score3) 4227 return s3_bfd_score_elf_finish_dynamic_symbol (output_bfd, info, h, sym); 4228 else 4229 return s7_bfd_score_elf_finish_dynamic_symbol (output_bfd, info, h, sym); 4230 } 4231 4232 static bfd_boolean 4233 _bfd_score_elf_finish_dynamic_sections (bfd *output_bfd, 4234 struct bfd_link_info *info) 4235 { 4236 if (bfd_get_mach (output_bfd) == bfd_mach_score3) 4237 return s3_bfd_score_elf_finish_dynamic_sections (output_bfd, info); 4238 else 4239 return s7_bfd_score_elf_finish_dynamic_sections (output_bfd, info); 4240 } 4241 4242 static bfd_boolean 4243 _bfd_score_elf_fake_sections (bfd *abfd ATTRIBUTE_UNUSED, 4244 Elf_Internal_Shdr *hdr, 4245 asection *sec) 4246 { 4247 if (bfd_get_mach (abfd) == bfd_mach_score3) 4248 return s3_bfd_score_elf_fake_sections (abfd, hdr, sec); 4249 else 4250 return s7_bfd_score_elf_fake_sections (abfd, hdr, sec); 4251 } 4252 4253 static bfd_boolean 4254 _bfd_score_elf_section_processing (bfd *abfd ATTRIBUTE_UNUSED, Elf_Internal_Shdr *hdr) 4255 { 4256 if (bfd_get_mach (abfd) == bfd_mach_score3) 4257 return s3_bfd_score_elf_section_processing (abfd, hdr); 4258 else 4259 return s7_bfd_score_elf_section_processing (abfd, hdr); 4260 } 4261 4262 static bfd_boolean 4263 _bfd_score_elf_write_section (bfd *output_bfd, 4264 struct bfd_link_info *link_info ATTRIBUTE_UNUSED, 4265 asection *sec, bfd_byte *contents) 4266 { 4267 if (bfd_get_mach (output_bfd) == bfd_mach_score3) 4268 return s3_bfd_score_elf_write_section (output_bfd, sec, contents); 4269 else 4270 return s7_bfd_score_elf_write_section (output_bfd, sec, contents); 4271 } 4272 4273 static void 4274 _bfd_score_elf_copy_indirect_symbol (struct bfd_link_info *info, 4275 struct elf_link_hash_entry *dir, 4276 struct elf_link_hash_entry *ind) 4277 { 4278 if (bfd_get_mach (info->input_bfds) == bfd_mach_score3) 4279 return s3_bfd_score_elf_copy_indirect_symbol (info, dir, ind); 4280 else 4281 return s7_bfd_score_elf_copy_indirect_symbol (info, dir, ind); 4282 } 4283 4284 static void 4285 _bfd_score_elf_hide_symbol (struct bfd_link_info *info, 4286 struct elf_link_hash_entry *entry, 4287 bfd_boolean force_local) 4288 { 4289 if (bfd_get_mach (info->input_bfds) == bfd_mach_score3) 4290 return s3_bfd_score_elf_hide_symbol (info, entry, force_local); 4291 else 4292 return s7_bfd_score_elf_hide_symbol (info, entry, force_local); 4293 } 4294 4295 static bfd_boolean 4296 _bfd_score_elf_discard_info (bfd *abfd, struct elf_reloc_cookie *cookie, 4297 struct bfd_link_info *info) 4298 { 4299 if (bfd_get_mach (abfd) == bfd_mach_score3) 4300 return s3_bfd_score_elf_discard_info (abfd, cookie, info); 4301 else 4302 return s7_bfd_score_elf_discard_info (abfd, cookie, info); 4303 } 4304 4305 static bfd_boolean 4306 _bfd_score_elf_ignore_discarded_relocs (asection *sec) 4307 { 4308 if (bfd_get_mach (sec->owner) == bfd_mach_score3) 4309 return s3_bfd_score_elf_ignore_discarded_relocs (sec); 4310 else 4311 return s7_bfd_score_elf_ignore_discarded_relocs (sec); 4312 } 4313 4314 static asection * 4315 _bfd_score_elf_gc_mark_hook (asection *sec, 4316 struct bfd_link_info *info, 4317 Elf_Internal_Rela *rel, 4318 struct elf_link_hash_entry *h, 4319 Elf_Internal_Sym *sym) 4320 { 4321 if (bfd_get_mach (info->input_bfds) == bfd_mach_score3) 4322 return s3_bfd_score_elf_gc_mark_hook (sec, info, rel, h, sym); 4323 else 4324 return s7_bfd_score_elf_gc_mark_hook (sec, info, rel, h, sym); 4325 } 4326 4327 static bfd_boolean 4328 _bfd_score_elf_grok_prstatus (bfd *abfd, Elf_Internal_Note *note) 4329 { 4330 if (bfd_get_mach (abfd) == bfd_mach_score3) 4331 return s3_bfd_score_elf_grok_prstatus (abfd, note); 4332 else 4333 return s7_bfd_score_elf_grok_prstatus (abfd, note); 4334 } 4335 4336 static bfd_boolean 4337 _bfd_score_elf_grok_psinfo (bfd *abfd, Elf_Internal_Note *note) 4338 { 4339 if (bfd_get_mach (abfd) == bfd_mach_score3) 4340 return s3_bfd_score_elf_grok_psinfo (abfd, note); 4341 else 4342 return s7_bfd_score_elf_grok_psinfo (abfd, note); 4343 } 4344 4345 static reloc_howto_type * 4346 elf32_score_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED, bfd_reloc_code_real_type code) 4347 { 4348 /* s3: NOTE!!! 4349 gas will call elf32_score_reloc_type_lookup, and don't write elf file. 4350 So just using score3, but we don't know ld will call this or not. 4351 If so, this way can't work. */ 4352 4353 if (score3) 4354 return s3_elf32_score_reloc_type_lookup (abfd, code); 4355 else 4356 return s7_elf32_score_reloc_type_lookup (abfd, code); 4357 } 4358 4359 /* Create a score elf linker hash table. 4360 This is a copy of _bfd_elf_link_hash_table_create() except with a 4361 different hash table entry creation function. */ 4362 4363 static struct bfd_link_hash_table * 4364 elf32_score_link_hash_table_create (bfd *abfd) 4365 { 4366 struct elf_link_hash_table *ret; 4367 bfd_size_type amt = sizeof (struct elf_link_hash_table); 4368 4369 ret = (struct elf_link_hash_table *) bfd_zmalloc (amt); 4370 if (ret == NULL) 4371 return NULL; 4372 4373 if (!_bfd_elf_link_hash_table_init (ret, abfd, score_elf_link_hash_newfunc, 4374 sizeof (struct score_elf_link_hash_entry), 4375 GENERIC_ELF_DATA)) 4376 { 4377 free (ret); 4378 return NULL; 4379 } 4380 4381 return &ret->root; 4382 } 4383 4384 static bfd_boolean 4385 elf32_score_print_private_bfd_data (bfd *abfd, void * ptr) 4386 { 4387 if (bfd_get_mach (abfd) == bfd_mach_score3) 4388 return s3_elf32_score_print_private_bfd_data (abfd, ptr); 4389 else 4390 return s7_elf32_score_print_private_bfd_data (abfd, ptr); 4391 } 4392 4393 static bfd_boolean 4394 elf32_score_merge_private_bfd_data (bfd *ibfd, bfd *obfd) 4395 { 4396 if (bfd_get_mach (obfd) == bfd_mach_score3) 4397 return s3_elf32_score_merge_private_bfd_data (ibfd, obfd); 4398 else 4399 return s7_elf32_score_merge_private_bfd_data (ibfd, obfd); 4400 } 4401 4402 static bfd_boolean 4403 elf32_score_new_section_hook (bfd *abfd, asection *sec) 4404 { 4405 if (bfd_get_mach (abfd) == bfd_mach_score3) 4406 return s3_elf32_score_new_section_hook (abfd, sec); 4407 else 4408 return s7_elf32_score_new_section_hook (abfd, sec); 4409 } 4410 4411 4412 /* s3_s7: don't need to split. */ 4413 4414 /* Set the right machine number. */ 4415 static bfd_boolean 4416 _bfd_score_elf_score_object_p (bfd * abfd) 4417 { 4418 int e_set = bfd_mach_score7; 4419 4420 if (elf_elfheader (abfd)->e_machine == EM_SCORE) 4421 { 4422 int e_mach = elf_elfheader (abfd)->e_flags & EF_SCORE_MACH & EF_OMIT_PIC_FIXDD; 4423 switch (e_mach) 4424 { 4425 /* Set default target is score7. */ 4426 default: 4427 case E_SCORE_MACH_SCORE7: 4428 e_set = bfd_mach_score7; 4429 break; 4430 4431 case E_SCORE_MACH_SCORE3: 4432 e_set = bfd_mach_score3; 4433 break; 4434 } 4435 } 4436 4437 return bfd_default_set_arch_mach (abfd, bfd_arch_score, e_set); 4438 } 4439 4440 bfd_boolean 4441 _bfd_score_elf_common_definition (Elf_Internal_Sym *sym) 4442 { 4443 return (sym->st_shndx == SHN_COMMON || sym->st_shndx == SHN_SCORE_SCOMMON); 4444 } 4445 4446 /*****************************************************************************/ 4447 4448 4449 #define USE_REL 1 4450 #define TARGET_LITTLE_SYM bfd_elf32_littlescore_vec 4451 #define TARGET_LITTLE_NAME "elf32-littlescore" 4452 #define TARGET_BIG_SYM bfd_elf32_bigscore_vec 4453 #define TARGET_BIG_NAME "elf32-bigscore" 4454 #define ELF_ARCH bfd_arch_score 4455 #define ELF_MACHINE_CODE EM_SCORE 4456 #define ELF_MACHINE_ALT1 EM_SCORE_OLD 4457 #define ELF_MAXPAGESIZE 0x8000 4458 4459 #define elf_info_to_howto 0 4460 #define elf_info_to_howto_rel _bfd_score_info_to_howto 4461 #define elf_backend_relocate_section _bfd_score_elf_relocate_section 4462 #define elf_backend_check_relocs _bfd_score_elf_check_relocs 4463 #define elf_backend_add_symbol_hook _bfd_score_elf_add_symbol_hook 4464 #define elf_backend_symbol_processing _bfd_score_elf_symbol_processing 4465 #define elf_backend_link_output_symbol_hook \ 4466 _bfd_score_elf_link_output_symbol_hook 4467 #define elf_backend_section_from_bfd_section \ 4468 _bfd_score_elf_section_from_bfd_section 4469 #define elf_backend_adjust_dynamic_symbol \ 4470 _bfd_score_elf_adjust_dynamic_symbol 4471 #define elf_backend_always_size_sections \ 4472 _bfd_score_elf_always_size_sections 4473 #define elf_backend_size_dynamic_sections \ 4474 _bfd_score_elf_size_dynamic_sections 4475 #define elf_backend_omit_section_dynsym \ 4476 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true) 4477 #define elf_backend_create_dynamic_sections \ 4478 _bfd_score_elf_create_dynamic_sections 4479 #define elf_backend_finish_dynamic_symbol \ 4480 _bfd_score_elf_finish_dynamic_symbol 4481 #define elf_backend_finish_dynamic_sections \ 4482 _bfd_score_elf_finish_dynamic_sections 4483 #define elf_backend_fake_sections _bfd_score_elf_fake_sections 4484 #define elf_backend_section_processing _bfd_score_elf_section_processing 4485 #define elf_backend_write_section _bfd_score_elf_write_section 4486 #define elf_backend_copy_indirect_symbol _bfd_score_elf_copy_indirect_symbol 4487 #define elf_backend_hide_symbol _bfd_score_elf_hide_symbol 4488 #define elf_backend_discard_info _bfd_score_elf_discard_info 4489 #define elf_backend_ignore_discarded_relocs \ 4490 _bfd_score_elf_ignore_discarded_relocs 4491 #define elf_backend_gc_mark_hook _bfd_score_elf_gc_mark_hook 4492 #define elf_backend_grok_prstatus _bfd_score_elf_grok_prstatus 4493 #define elf_backend_grok_psinfo _bfd_score_elf_grok_psinfo 4494 #define elf_backend_can_gc_sections 1 4495 #define elf_backend_want_plt_sym 0 4496 #define elf_backend_got_header_size (4 * SCORE_RESERVED_GOTNO) 4497 #define elf_backend_plt_header_size 0 4498 #define elf_backend_collect TRUE 4499 #define elf_backend_type_change_ok TRUE 4500 #define elf_backend_object_p _bfd_score_elf_score_object_p 4501 4502 #define bfd_elf32_bfd_reloc_type_lookup elf32_score_reloc_type_lookup 4503 #define bfd_elf32_bfd_reloc_name_lookup \ 4504 elf32_score_reloc_name_lookup 4505 #define bfd_elf32_bfd_link_hash_table_create elf32_score_link_hash_table_create 4506 #define bfd_elf32_bfd_print_private_bfd_data elf32_score_print_private_bfd_data 4507 #define bfd_elf32_bfd_merge_private_bfd_data elf32_score_merge_private_bfd_data 4508 #define bfd_elf32_new_section_hook elf32_score_new_section_hook 4509 4510 #include "elf32-target.h" 4511