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