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