1 /* Renesas / SuperH SH specific support for 32-bit ELF 2 Copyright (C) 1996-2022 Free Software Foundation, Inc. 3 Contributed by Ian Lance Taylor, Cygnus Support. 4 5 This file is part of BFD, the Binary File Descriptor library. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program; if not, write to the Free Software 19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 20 MA 02110-1301, USA. */ 21 22 #include "sysdep.h" 23 #include "bfd.h" 24 #include "bfdlink.h" 25 #include "libbfd.h" 26 #include "elf-bfd.h" 27 #include "elf-vxworks.h" 28 #include "elf/sh.h" 29 #include "dwarf2.h" 30 #include "libiberty.h" 31 #include "../opcodes/sh-opc.h" 32 33 /* All users of this file have bfd_octets_per_byte (abfd, sec) == 1. */ 34 #define OCTETS_PER_BYTE(ABFD, SEC) 1 35 36 static bfd_reloc_status_type sh_elf_reloc 37 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **); 38 static bfd_reloc_status_type sh_elf_ignore_reloc 39 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **); 40 static bool sh_elf_relax_delete_bytes 41 (bfd *, asection *, bfd_vma, int); 42 static bool sh_elf_align_loads 43 (bfd *, asection *, Elf_Internal_Rela *, bfd_byte *, bool *); 44 static bool sh_elf_swap_insns 45 (bfd *, asection *, void *, bfd_byte *, bfd_vma); 46 static int sh_elf_optimized_tls_reloc 47 (struct bfd_link_info *, int, int); 48 static bfd_vma dtpoff_base 49 (struct bfd_link_info *); 50 static bfd_vma tpoff 51 (struct bfd_link_info *, bfd_vma); 52 53 /* The name of the dynamic interpreter. This is put in the .interp 54 section. */ 55 56 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1" 57 58 /* FDPIC binaries have a default 128K stack. */ 59 #define DEFAULT_STACK_SIZE 0x20000 60 61 #define MINUS_ONE ((bfd_vma) 0 - 1) 62 63 /* Decide whether a reference to a symbol can be resolved locally or 64 not. If the symbol is protected, we want the local address, but 65 its function descriptor must be assigned by the dynamic linker. */ 66 #define SYMBOL_FUNCDESC_LOCAL(INFO, H) \ 67 (SYMBOL_REFERENCES_LOCAL (INFO, H) \ 68 || ! elf_hash_table (INFO)->dynamic_sections_created) 69 70 #define SH_PARTIAL32 true 71 #define SH_SRC_MASK32 0xffffffff 72 #define SH_ELF_RELOC sh_elf_reloc 73 static reloc_howto_type sh_elf_howto_table[] = 74 { 75 #include "elf32-sh-relocs.h" 76 }; 77 78 #define SH_PARTIAL32 false 79 #define SH_SRC_MASK32 0 80 #define SH_ELF_RELOC bfd_elf_generic_reloc 81 static reloc_howto_type sh_vxworks_howto_table[] = 82 { 83 #include "elf32-sh-relocs.h" 84 }; 85 86 /* Return true if OUTPUT_BFD is a VxWorks object. */ 87 88 static bool 89 vxworks_object_p (bfd *abfd ATTRIBUTE_UNUSED) 90 { 91 #if !defined SH_TARGET_ALREADY_DEFINED 92 extern const bfd_target sh_elf32_vxworks_le_vec; 93 extern const bfd_target sh_elf32_vxworks_vec; 94 95 return (abfd->xvec == &sh_elf32_vxworks_le_vec 96 || abfd->xvec == &sh_elf32_vxworks_vec); 97 #else 98 return false; 99 #endif 100 } 101 102 /* Return true if OUTPUT_BFD is an FDPIC object. */ 103 104 static bool 105 fdpic_object_p (bfd *abfd ATTRIBUTE_UNUSED) 106 { 107 #if !defined SH_TARGET_ALREADY_DEFINED 108 extern const bfd_target sh_elf32_fdpic_le_vec; 109 extern const bfd_target sh_elf32_fdpic_be_vec; 110 111 return (abfd->xvec == &sh_elf32_fdpic_le_vec 112 || abfd->xvec == &sh_elf32_fdpic_be_vec); 113 #else 114 return false; 115 #endif 116 } 117 118 /* Return the howto table for ABFD. */ 119 120 static reloc_howto_type * 121 get_howto_table (bfd *abfd) 122 { 123 if (vxworks_object_p (abfd)) 124 return sh_vxworks_howto_table; 125 return sh_elf_howto_table; 126 } 127 128 static bfd_reloc_status_type 129 sh_elf_reloc_loop (int r_type ATTRIBUTE_UNUSED, bfd *input_bfd, 130 asection *input_section, bfd_byte *contents, 131 bfd_vma addr, asection *symbol_section, 132 bfd_vma start, bfd_vma end) 133 { 134 static bfd_vma last_addr; 135 static asection *last_symbol_section; 136 bfd_byte *start_ptr, *ptr, *last_ptr; 137 int diff, cum_diff; 138 bfd_signed_vma x; 139 int insn; 140 141 /* Sanity check the address. */ 142 if (addr > bfd_get_section_limit (input_bfd, input_section)) 143 return bfd_reloc_outofrange; 144 145 /* We require the start and end relocations to be processed consecutively - 146 although we allow then to be processed forwards or backwards. */ 147 if (! last_addr) 148 { 149 last_addr = addr; 150 last_symbol_section = symbol_section; 151 return bfd_reloc_ok; 152 } 153 if (last_addr != addr) 154 abort (); 155 last_addr = 0; 156 157 if (! symbol_section || last_symbol_section != symbol_section || end < start) 158 return bfd_reloc_outofrange; 159 160 /* Get the symbol_section contents. */ 161 if (symbol_section != input_section) 162 { 163 if (elf_section_data (symbol_section)->this_hdr.contents != NULL) 164 contents = elf_section_data (symbol_section)->this_hdr.contents; 165 else 166 { 167 if (!bfd_malloc_and_get_section (input_bfd, symbol_section, 168 &contents)) 169 { 170 free (contents); 171 return bfd_reloc_outofrange; 172 } 173 } 174 } 175 #define IS_PPI(PTR) ((bfd_get_16 (input_bfd, (PTR)) & 0xfc00) == 0xf800) 176 start_ptr = contents + start; 177 for (cum_diff = -6, ptr = contents + end; cum_diff < 0 && ptr > start_ptr;) 178 { 179 for (last_ptr = ptr, ptr -= 4; ptr >= start_ptr && IS_PPI (ptr);) 180 ptr -= 2; 181 ptr += 2; 182 diff = (last_ptr - ptr) >> 1; 183 cum_diff += diff & 1; 184 cum_diff += diff; 185 } 186 /* Calculate the start / end values to load into rs / re minus four - 187 so that will cancel out the four we would otherwise have to add to 188 addr to get the value to subtract in order to get relative addressing. */ 189 if (cum_diff >= 0) 190 { 191 start -= 4; 192 end = (ptr + cum_diff * 2) - contents; 193 } 194 else 195 { 196 bfd_vma start0 = start - 4; 197 198 while (start0 && IS_PPI (contents + start0)) 199 start0 -= 2; 200 start0 = start - 2 - ((start - start0) & 2); 201 start = start0 - cum_diff - 2; 202 end = start0; 203 } 204 205 if (elf_section_data (symbol_section)->this_hdr.contents != contents) 206 free (contents); 207 208 insn = bfd_get_16 (input_bfd, contents + addr); 209 210 x = (insn & 0x200 ? end : start) - addr; 211 if (input_section != symbol_section) 212 x += ((symbol_section->output_section->vma + symbol_section->output_offset) 213 - (input_section->output_section->vma 214 + input_section->output_offset)); 215 x >>= 1; 216 if (x < -128 || x > 127) 217 return bfd_reloc_overflow; 218 219 x = (insn & ~0xff) | (x & 0xff); 220 bfd_put_16 (input_bfd, (bfd_vma) x, contents + addr); 221 222 return bfd_reloc_ok; 223 } 224 225 /* This function is used for normal relocs. This used to be like the COFF 226 function, and is almost certainly incorrect for other ELF targets. */ 227 228 static bfd_reloc_status_type 229 sh_elf_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol_in, 230 void *data, asection *input_section, bfd *output_bfd, 231 char **error_message ATTRIBUTE_UNUSED) 232 { 233 bfd_vma insn; 234 bfd_vma sym_value; 235 enum elf_sh_reloc_type r_type; 236 bfd_vma addr = reloc_entry->address; 237 bfd_size_type octets = addr * OCTETS_PER_BYTE (abfd, input_section); 238 bfd_byte *hit_data = (bfd_byte *) data + octets; 239 240 r_type = (enum elf_sh_reloc_type) reloc_entry->howto->type; 241 242 if (output_bfd != NULL) 243 { 244 /* Partial linking--do nothing. */ 245 reloc_entry->address += input_section->output_offset; 246 return bfd_reloc_ok; 247 } 248 249 /* Almost all relocs have to do with relaxing. If any work must be 250 done for them, it has been done in sh_relax_section. */ 251 if (r_type == R_SH_IND12W && (symbol_in->flags & BSF_LOCAL) != 0) 252 return bfd_reloc_ok; 253 254 if (symbol_in != NULL 255 && bfd_is_und_section (symbol_in->section)) 256 return bfd_reloc_undefined; 257 258 /* PR 17512: file: 9891ca98. */ 259 if (octets + bfd_get_reloc_size (reloc_entry->howto) 260 > bfd_get_section_limit_octets (abfd, input_section)) 261 return bfd_reloc_outofrange; 262 263 if (bfd_is_com_section (symbol_in->section)) 264 sym_value = 0; 265 else 266 sym_value = (symbol_in->value + 267 symbol_in->section->output_section->vma + 268 symbol_in->section->output_offset); 269 270 switch (r_type) 271 { 272 case R_SH_DIR32: 273 insn = bfd_get_32 (abfd, hit_data); 274 insn += sym_value + reloc_entry->addend; 275 bfd_put_32 (abfd, insn, hit_data); 276 break; 277 case R_SH_IND12W: 278 insn = bfd_get_16 (abfd, hit_data); 279 sym_value += reloc_entry->addend; 280 sym_value -= (input_section->output_section->vma 281 + input_section->output_offset 282 + addr 283 + 4); 284 sym_value += (((insn & 0xfff) ^ 0x800) - 0x800) << 1; 285 insn = (insn & 0xf000) | ((sym_value >> 1) & 0xfff); 286 bfd_put_16 (abfd, insn, hit_data); 287 if (sym_value + 0x1000 >= 0x2000 || (sym_value & 1) != 0) 288 return bfd_reloc_overflow; 289 break; 290 default: 291 abort (); 292 break; 293 } 294 295 return bfd_reloc_ok; 296 } 297 298 /* This function is used for relocs which are only used for relaxing, 299 which the linker should otherwise ignore. */ 300 301 static bfd_reloc_status_type 302 sh_elf_ignore_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry, 303 asymbol *symbol ATTRIBUTE_UNUSED, 304 void *data ATTRIBUTE_UNUSED, asection *input_section, 305 bfd *output_bfd, 306 char **error_message ATTRIBUTE_UNUSED) 307 { 308 if (output_bfd != NULL) 309 reloc_entry->address += input_section->output_offset; 310 return bfd_reloc_ok; 311 } 312 313 /* This structure is used to map BFD reloc codes to SH ELF relocs. */ 314 315 struct elf_reloc_map 316 { 317 bfd_reloc_code_real_type bfd_reloc_val; 318 unsigned char elf_reloc_val; 319 }; 320 321 /* An array mapping BFD reloc codes to SH ELF relocs. */ 322 323 static const struct elf_reloc_map sh_reloc_map[] = 324 { 325 { BFD_RELOC_NONE, R_SH_NONE }, 326 { BFD_RELOC_32, R_SH_DIR32 }, 327 { BFD_RELOC_16, R_SH_DIR16 }, 328 { BFD_RELOC_8, R_SH_DIR8 }, 329 { BFD_RELOC_CTOR, R_SH_DIR32 }, 330 { BFD_RELOC_32_PCREL, R_SH_REL32 }, 331 { BFD_RELOC_SH_PCDISP8BY2, R_SH_DIR8WPN }, 332 { BFD_RELOC_SH_PCDISP12BY2, R_SH_IND12W }, 333 { BFD_RELOC_SH_PCRELIMM8BY2, R_SH_DIR8WPZ }, 334 { BFD_RELOC_SH_PCRELIMM8BY4, R_SH_DIR8WPL }, 335 { BFD_RELOC_8_PCREL, R_SH_SWITCH8 }, 336 { BFD_RELOC_SH_SWITCH16, R_SH_SWITCH16 }, 337 { BFD_RELOC_SH_SWITCH32, R_SH_SWITCH32 }, 338 { BFD_RELOC_SH_USES, R_SH_USES }, 339 { BFD_RELOC_SH_COUNT, R_SH_COUNT }, 340 { BFD_RELOC_SH_ALIGN, R_SH_ALIGN }, 341 { BFD_RELOC_SH_CODE, R_SH_CODE }, 342 { BFD_RELOC_SH_DATA, R_SH_DATA }, 343 { BFD_RELOC_SH_LABEL, R_SH_LABEL }, 344 { BFD_RELOC_VTABLE_INHERIT, R_SH_GNU_VTINHERIT }, 345 { BFD_RELOC_VTABLE_ENTRY, R_SH_GNU_VTENTRY }, 346 { BFD_RELOC_SH_LOOP_START, R_SH_LOOP_START }, 347 { BFD_RELOC_SH_LOOP_END, R_SH_LOOP_END }, 348 { BFD_RELOC_SH_TLS_GD_32, R_SH_TLS_GD_32 }, 349 { BFD_RELOC_SH_TLS_LD_32, R_SH_TLS_LD_32 }, 350 { BFD_RELOC_SH_TLS_LDO_32, R_SH_TLS_LDO_32 }, 351 { BFD_RELOC_SH_TLS_IE_32, R_SH_TLS_IE_32 }, 352 { BFD_RELOC_SH_TLS_LE_32, R_SH_TLS_LE_32 }, 353 { BFD_RELOC_SH_TLS_DTPMOD32, R_SH_TLS_DTPMOD32 }, 354 { BFD_RELOC_SH_TLS_DTPOFF32, R_SH_TLS_DTPOFF32 }, 355 { BFD_RELOC_SH_TLS_TPOFF32, R_SH_TLS_TPOFF32 }, 356 { BFD_RELOC_32_GOT_PCREL, R_SH_GOT32 }, 357 { BFD_RELOC_32_PLT_PCREL, R_SH_PLT32 }, 358 { BFD_RELOC_SH_COPY, R_SH_COPY }, 359 { BFD_RELOC_SH_GLOB_DAT, R_SH_GLOB_DAT }, 360 { BFD_RELOC_SH_JMP_SLOT, R_SH_JMP_SLOT }, 361 { BFD_RELOC_SH_RELATIVE, R_SH_RELATIVE }, 362 { BFD_RELOC_32_GOTOFF, R_SH_GOTOFF }, 363 { BFD_RELOC_SH_GOTPC, R_SH_GOTPC }, 364 { BFD_RELOC_SH_GOTPLT32, R_SH_GOTPLT32 }, 365 { BFD_RELOC_SH_GOT20, R_SH_GOT20 }, 366 { BFD_RELOC_SH_GOTOFF20, R_SH_GOTOFF20 }, 367 { BFD_RELOC_SH_GOTFUNCDESC, R_SH_GOTFUNCDESC }, 368 { BFD_RELOC_SH_GOTFUNCDESC20, R_SH_GOTFUNCDESC20 }, 369 { BFD_RELOC_SH_GOTOFFFUNCDESC, R_SH_GOTOFFFUNCDESC }, 370 { BFD_RELOC_SH_GOTOFFFUNCDESC20, R_SH_GOTOFFFUNCDESC20 }, 371 { BFD_RELOC_SH_FUNCDESC, R_SH_FUNCDESC }, 372 }; 373 374 /* Given a BFD reloc code, return the howto structure for the 375 corresponding SH ELF reloc. */ 376 377 static reloc_howto_type * 378 sh_elf_reloc_type_lookup (bfd *abfd, bfd_reloc_code_real_type code) 379 { 380 unsigned int i; 381 382 for (i = 0; i < sizeof (sh_reloc_map) / sizeof (struct elf_reloc_map); i++) 383 { 384 if (sh_reloc_map[i].bfd_reloc_val == code) 385 return get_howto_table (abfd) + (int) sh_reloc_map[i].elf_reloc_val; 386 } 387 388 return NULL; 389 } 390 391 static reloc_howto_type * 392 sh_elf_reloc_name_lookup (bfd *abfd, const char *r_name) 393 { 394 unsigned int i; 395 396 if (vxworks_object_p (abfd)) 397 { 398 for (i = 0; 399 i < (sizeof (sh_vxworks_howto_table) 400 / sizeof (sh_vxworks_howto_table[0])); 401 i++) 402 if (sh_vxworks_howto_table[i].name != NULL 403 && strcasecmp (sh_vxworks_howto_table[i].name, r_name) == 0) 404 return &sh_vxworks_howto_table[i]; 405 } 406 else 407 { 408 for (i = 0; 409 i < (sizeof (sh_elf_howto_table) 410 / sizeof (sh_elf_howto_table[0])); 411 i++) 412 if (sh_elf_howto_table[i].name != NULL 413 && strcasecmp (sh_elf_howto_table[i].name, r_name) == 0) 414 return &sh_elf_howto_table[i]; 415 } 416 417 return NULL; 418 } 419 420 /* Given an ELF reloc, fill in the howto field of a relent. */ 421 422 static bool 423 sh_elf_info_to_howto (bfd *abfd, arelent *cache_ptr, Elf_Internal_Rela *dst) 424 { 425 unsigned int r; 426 427 r = ELF32_R_TYPE (dst->r_info); 428 429 if (r >= R_SH_FIRST_INVALID_RELOC_6 430 || (r >= R_SH_FIRST_INVALID_RELOC && r <= R_SH_LAST_INVALID_RELOC) 431 || (r >= R_SH_FIRST_INVALID_RELOC_2 && r <= R_SH_LAST_INVALID_RELOC_2) 432 || (r >= R_SH_FIRST_INVALID_RELOC_3 && r <= R_SH_LAST_INVALID_RELOC_3) 433 || (r >= R_SH_FIRST_INVALID_RELOC_4 && r <= R_SH_LAST_INVALID_RELOC_4) 434 || (r >= R_SH_FIRST_INVALID_RELOC_5 && r <= R_SH_LAST_INVALID_RELOC_5)) 435 { 436 /* xgettext:c-format */ 437 _bfd_error_handler (_("%pB: unsupported relocation type %#x"), 438 abfd, r); 439 bfd_set_error (bfd_error_bad_value); 440 return false; 441 } 442 443 cache_ptr->howto = get_howto_table (abfd) + r; 444 return true; 445 } 446 447 /* This function handles relaxing for SH ELF. See the corresponding 448 function in coff-sh.c for a description of what this does. FIXME: 449 There is a lot of duplication here between this code and the COFF 450 specific code. The format of relocs and symbols is wound deeply 451 into this code, but it would still be better if the duplication 452 could be eliminated somehow. Note in particular that although both 453 functions use symbols like R_SH_CODE, those symbols have different 454 values; in coff-sh.c they come from include/coff/sh.h, whereas here 455 they come from enum elf_sh_reloc_type in include/elf/sh.h. */ 456 457 static bool 458 sh_elf_relax_section (bfd *abfd, asection *sec, 459 struct bfd_link_info *link_info, bool *again) 460 { 461 Elf_Internal_Shdr *symtab_hdr; 462 Elf_Internal_Rela *internal_relocs; 463 bool have_code; 464 Elf_Internal_Rela *irel, *irelend; 465 bfd_byte *contents = NULL; 466 Elf_Internal_Sym *isymbuf = NULL; 467 468 *again = false; 469 470 if (bfd_link_relocatable (link_info) 471 || (sec->flags & SEC_RELOC) == 0 472 || sec->reloc_count == 0) 473 return true; 474 475 symtab_hdr = &elf_symtab_hdr (abfd); 476 477 internal_relocs = (_bfd_elf_link_read_relocs 478 (abfd, sec, NULL, (Elf_Internal_Rela *) NULL, 479 link_info->keep_memory)); 480 if (internal_relocs == NULL) 481 goto error_return; 482 483 have_code = false; 484 485 irelend = internal_relocs + sec->reloc_count; 486 for (irel = internal_relocs; irel < irelend; irel++) 487 { 488 bfd_vma laddr, paddr, symval; 489 unsigned short insn; 490 Elf_Internal_Rela *irelfn, *irelscan, *irelcount; 491 bfd_signed_vma foff; 492 493 if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_CODE) 494 have_code = true; 495 496 if (ELF32_R_TYPE (irel->r_info) != (int) R_SH_USES) 497 continue; 498 499 /* Get the section contents. */ 500 if (contents == NULL) 501 { 502 if (elf_section_data (sec)->this_hdr.contents != NULL) 503 contents = elf_section_data (sec)->this_hdr.contents; 504 else 505 { 506 if (!bfd_malloc_and_get_section (abfd, sec, &contents)) 507 goto error_return; 508 } 509 } 510 511 /* The r_addend field of the R_SH_USES reloc will point us to 512 the register load. The 4 is because the r_addend field is 513 computed as though it were a jump offset, which are based 514 from 4 bytes after the jump instruction. */ 515 laddr = irel->r_offset + 4 + irel->r_addend; 516 if (laddr >= sec->size) 517 { 518 /* xgettext:c-format */ 519 _bfd_error_handler 520 (_("%pB: %#" PRIx64 ": warning: bad R_SH_USES offset"), 521 abfd, (uint64_t) irel->r_offset); 522 continue; 523 } 524 insn = bfd_get_16 (abfd, contents + laddr); 525 526 /* If the instruction is not mov.l NN,rN, we don't know what to 527 do. */ 528 if ((insn & 0xf000) != 0xd000) 529 { 530 _bfd_error_handler 531 /* xgettext:c-format */ 532 (_("%pB: %#" PRIx64 ": warning: " 533 "R_SH_USES points to unrecognized insn 0x%x"), 534 abfd, (uint64_t) irel->r_offset, insn); 535 continue; 536 } 537 538 /* Get the address from which the register is being loaded. The 539 displacement in the mov.l instruction is quadrupled. It is a 540 displacement from four bytes after the movl instruction, but, 541 before adding in the PC address, two least significant bits 542 of the PC are cleared. We assume that the section is aligned 543 on a four byte boundary. */ 544 paddr = insn & 0xff; 545 paddr *= 4; 546 paddr += (laddr + 4) &~ (bfd_vma) 3; 547 if (paddr >= sec->size) 548 { 549 _bfd_error_handler 550 /* xgettext:c-format */ 551 (_("%pB: %#" PRIx64 ": warning: bad R_SH_USES load offset"), 552 abfd, (uint64_t) irel->r_offset); 553 continue; 554 } 555 556 /* Get the reloc for the address from which the register is 557 being loaded. This reloc will tell us which function is 558 actually being called. */ 559 for (irelfn = internal_relocs; irelfn < irelend; irelfn++) 560 if (irelfn->r_offset == paddr 561 && ELF32_R_TYPE (irelfn->r_info) == (int) R_SH_DIR32) 562 break; 563 if (irelfn >= irelend) 564 { 565 _bfd_error_handler 566 /* xgettext:c-format */ 567 (_("%pB: %#" PRIx64 ": warning: could not find expected reloc"), 568 abfd, (uint64_t) paddr); 569 continue; 570 } 571 572 /* Read this BFD's symbols if we haven't done so already. */ 573 if (isymbuf == NULL && symtab_hdr->sh_info != 0) 574 { 575 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents; 576 if (isymbuf == NULL) 577 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr, 578 symtab_hdr->sh_info, 0, 579 NULL, NULL, NULL); 580 if (isymbuf == NULL) 581 goto error_return; 582 } 583 584 /* Get the value of the symbol referred to by the reloc. */ 585 if (ELF32_R_SYM (irelfn->r_info) < symtab_hdr->sh_info) 586 { 587 /* A local symbol. */ 588 Elf_Internal_Sym *isym; 589 590 isym = isymbuf + ELF32_R_SYM (irelfn->r_info); 591 if (isym->st_shndx 592 != (unsigned int) _bfd_elf_section_from_bfd_section (abfd, sec)) 593 { 594 _bfd_error_handler 595 /* xgettext:c-format */ 596 (_("%pB: %#" PRIx64 ": warning: symbol in unexpected section"), 597 abfd, (uint64_t) paddr); 598 continue; 599 } 600 601 symval = (isym->st_value 602 + sec->output_section->vma 603 + sec->output_offset); 604 } 605 else 606 { 607 unsigned long indx; 608 struct elf_link_hash_entry *h; 609 610 indx = ELF32_R_SYM (irelfn->r_info) - symtab_hdr->sh_info; 611 h = elf_sym_hashes (abfd)[indx]; 612 BFD_ASSERT (h != NULL); 613 if (h->root.type != bfd_link_hash_defined 614 && h->root.type != bfd_link_hash_defweak) 615 { 616 /* This appears to be a reference to an undefined 617 symbol. Just ignore it--it will be caught by the 618 regular reloc processing. */ 619 continue; 620 } 621 622 symval = (h->root.u.def.value 623 + h->root.u.def.section->output_section->vma 624 + h->root.u.def.section->output_offset); 625 } 626 627 if (get_howto_table (abfd)[R_SH_DIR32].partial_inplace) 628 symval += bfd_get_32 (abfd, contents + paddr); 629 else 630 symval += irelfn->r_addend; 631 632 /* See if this function call can be shortened. */ 633 foff = (symval 634 - (irel->r_offset 635 + sec->output_section->vma 636 + sec->output_offset 637 + 4)); 638 /* A branch to an address beyond ours might be increased by an 639 .align that doesn't move when bytes behind us are deleted. 640 So, we add some slop in this calculation to allow for 641 that. */ 642 if (foff < -0x1000 || foff >= 0x1000 - 8) 643 { 644 /* After all that work, we can't shorten this function call. */ 645 continue; 646 } 647 648 /* Shorten the function call. */ 649 650 /* For simplicity of coding, we are going to modify the section 651 contents, the section relocs, and the BFD symbol table. We 652 must tell the rest of the code not to free up this 653 information. It would be possible to instead create a table 654 of changes which have to be made, as is done in coff-mips.c; 655 that would be more work, but would require less memory when 656 the linker is run. */ 657 658 elf_section_data (sec)->relocs = internal_relocs; 659 elf_section_data (sec)->this_hdr.contents = contents; 660 symtab_hdr->contents = (unsigned char *) isymbuf; 661 662 /* Replace the jmp/jsr with a bra/bsr. */ 663 664 /* Change the R_SH_USES reloc into an R_SH_IND12W reloc, and 665 replace the jmp/jsr with a bra/bsr. */ 666 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irelfn->r_info), R_SH_IND12W); 667 /* We used to test (ELF32_R_SYM (irelfn->r_info) < symtab_hdr->sh_info) 668 here, but that only checks if the symbol is an external symbol, 669 not if the symbol is in a different section. Besides, we need 670 a consistent meaning for the relocation, so we just assume here that 671 the value of the symbol is not available. */ 672 673 /* We can't fully resolve this yet, because the external 674 symbol value may be changed by future relaxing. We let 675 the final link phase handle it. */ 676 if (bfd_get_16 (abfd, contents + irel->r_offset) & 0x0020) 677 bfd_put_16 (abfd, (bfd_vma) 0xa000, contents + irel->r_offset); 678 else 679 bfd_put_16 (abfd, (bfd_vma) 0xb000, contents + irel->r_offset); 680 681 irel->r_addend = -4; 682 683 /* When we calculated the symbol "value" we had an offset in the 684 DIR32's word in memory (we read and add it above). However, 685 the jsr we create does NOT have this offset encoded, so we 686 have to add it to the addend to preserve it. */ 687 irel->r_addend += bfd_get_32 (abfd, contents + paddr); 688 689 /* See if there is another R_SH_USES reloc referring to the same 690 register load. */ 691 for (irelscan = internal_relocs; irelscan < irelend; irelscan++) 692 if (ELF32_R_TYPE (irelscan->r_info) == (int) R_SH_USES 693 && laddr == irelscan->r_offset + 4 + irelscan->r_addend) 694 break; 695 if (irelscan < irelend) 696 { 697 /* Some other function call depends upon this register load, 698 and we have not yet converted that function call. 699 Indeed, we may never be able to convert it. There is 700 nothing else we can do at this point. */ 701 continue; 702 } 703 704 /* Look for a R_SH_COUNT reloc on the location where the 705 function address is stored. Do this before deleting any 706 bytes, to avoid confusion about the address. */ 707 for (irelcount = internal_relocs; irelcount < irelend; irelcount++) 708 if (irelcount->r_offset == paddr 709 && ELF32_R_TYPE (irelcount->r_info) == (int) R_SH_COUNT) 710 break; 711 712 /* Delete the register load. */ 713 if (! sh_elf_relax_delete_bytes (abfd, sec, laddr, 2)) 714 goto error_return; 715 716 /* That will change things, so, just in case it permits some 717 other function call to come within range, we should relax 718 again. Note that this is not required, and it may be slow. */ 719 *again = true; 720 721 /* Now check whether we got a COUNT reloc. */ 722 if (irelcount >= irelend) 723 { 724 _bfd_error_handler 725 /* xgettext:c-format */ 726 (_("%pB: %#" PRIx64 ": warning: " 727 "could not find expected COUNT reloc"), 728 abfd, (uint64_t) paddr); 729 continue; 730 } 731 732 /* The number of uses is stored in the r_addend field. We've 733 just deleted one. */ 734 if (irelcount->r_addend == 0) 735 { 736 /* xgettext:c-format */ 737 _bfd_error_handler (_("%pB: %#" PRIx64 ": warning: bad count"), 738 abfd, (uint64_t) paddr); 739 continue; 740 } 741 742 --irelcount->r_addend; 743 744 /* If there are no more uses, we can delete the address. Reload 745 the address from irelfn, in case it was changed by the 746 previous call to sh_elf_relax_delete_bytes. */ 747 if (irelcount->r_addend == 0) 748 { 749 if (! sh_elf_relax_delete_bytes (abfd, sec, irelfn->r_offset, 4)) 750 goto error_return; 751 } 752 753 /* We've done all we can with that function call. */ 754 } 755 756 /* Look for load and store instructions that we can align on four 757 byte boundaries. */ 758 if ((elf_elfheader (abfd)->e_flags & EF_SH_MACH_MASK) != EF_SH4 759 && have_code) 760 { 761 bool swapped; 762 763 /* Get the section contents. */ 764 if (contents == NULL) 765 { 766 if (elf_section_data (sec)->this_hdr.contents != NULL) 767 contents = elf_section_data (sec)->this_hdr.contents; 768 else 769 { 770 if (!bfd_malloc_and_get_section (abfd, sec, &contents)) 771 goto error_return; 772 } 773 } 774 775 if (! sh_elf_align_loads (abfd, sec, internal_relocs, contents, 776 &swapped)) 777 goto error_return; 778 779 if (swapped) 780 { 781 elf_section_data (sec)->relocs = internal_relocs; 782 elf_section_data (sec)->this_hdr.contents = contents; 783 symtab_hdr->contents = (unsigned char *) isymbuf; 784 } 785 } 786 787 if (isymbuf != NULL 788 && symtab_hdr->contents != (unsigned char *) isymbuf) 789 { 790 if (! link_info->keep_memory) 791 free (isymbuf); 792 else 793 { 794 /* Cache the symbols for elf_link_input_bfd. */ 795 symtab_hdr->contents = (unsigned char *) isymbuf; 796 } 797 } 798 799 if (contents != NULL 800 && elf_section_data (sec)->this_hdr.contents != contents) 801 { 802 if (! link_info->keep_memory) 803 free (contents); 804 else 805 { 806 /* Cache the section contents for elf_link_input_bfd. */ 807 elf_section_data (sec)->this_hdr.contents = contents; 808 } 809 } 810 811 if (elf_section_data (sec)->relocs != internal_relocs) 812 free (internal_relocs); 813 814 return true; 815 816 error_return: 817 if (symtab_hdr->contents != (unsigned char *) isymbuf) 818 free (isymbuf); 819 if (elf_section_data (sec)->this_hdr.contents != contents) 820 free (contents); 821 if (elf_section_data (sec)->relocs != internal_relocs) 822 free (internal_relocs); 823 824 return false; 825 } 826 827 /* Delete some bytes from a section while relaxing. FIXME: There is a 828 lot of duplication between this function and sh_relax_delete_bytes 829 in coff-sh.c. */ 830 831 static bool 832 sh_elf_relax_delete_bytes (bfd *abfd, asection *sec, bfd_vma addr, 833 int count) 834 { 835 Elf_Internal_Shdr *symtab_hdr; 836 unsigned int sec_shndx; 837 bfd_byte *contents; 838 Elf_Internal_Rela *irel, *irelend; 839 Elf_Internal_Rela *irelalign; 840 bfd_vma toaddr; 841 Elf_Internal_Sym *isymbuf, *isym, *isymend; 842 struct elf_link_hash_entry **sym_hashes; 843 struct elf_link_hash_entry **end_hashes; 844 unsigned int symcount; 845 asection *o; 846 847 symtab_hdr = &elf_symtab_hdr (abfd); 848 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents; 849 850 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec); 851 852 contents = elf_section_data (sec)->this_hdr.contents; 853 854 /* The deletion must stop at the next ALIGN reloc for an alignment 855 power larger than the number of bytes we are deleting. */ 856 857 irelalign = NULL; 858 toaddr = sec->size; 859 860 irel = elf_section_data (sec)->relocs; 861 irelend = irel + sec->reloc_count; 862 for (; irel < irelend; irel++) 863 { 864 if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_ALIGN 865 && irel->r_offset > addr 866 && count < (1 << irel->r_addend)) 867 { 868 irelalign = irel; 869 toaddr = irel->r_offset; 870 break; 871 } 872 } 873 874 /* Actually delete the bytes. */ 875 memmove (contents + addr, contents + addr + count, 876 (size_t) (toaddr - addr - count)); 877 if (irelalign == NULL) 878 sec->size -= count; 879 else 880 { 881 int i; 882 883 #define NOP_OPCODE (0x0009) 884 885 BFD_ASSERT ((count & 1) == 0); 886 for (i = 0; i < count; i += 2) 887 bfd_put_16 (abfd, (bfd_vma) NOP_OPCODE, contents + toaddr - count + i); 888 } 889 890 /* Adjust all the relocs. */ 891 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++) 892 { 893 bfd_vma nraddr, stop; 894 bfd_vma start = 0; 895 int insn = 0; 896 int off, adjust, oinsn; 897 bfd_signed_vma voff = 0; 898 bool overflow; 899 900 /* Get the new reloc address. */ 901 nraddr = irel->r_offset; 902 if ((irel->r_offset > addr 903 && irel->r_offset < toaddr) 904 || (ELF32_R_TYPE (irel->r_info) == (int) R_SH_ALIGN 905 && irel->r_offset == toaddr)) 906 nraddr -= count; 907 908 /* See if this reloc was for the bytes we have deleted, in which 909 case we no longer care about it. Don't delete relocs which 910 represent addresses, though. */ 911 if (irel->r_offset >= addr 912 && irel->r_offset < addr + count 913 && ELF32_R_TYPE (irel->r_info) != (int) R_SH_ALIGN 914 && ELF32_R_TYPE (irel->r_info) != (int) R_SH_CODE 915 && ELF32_R_TYPE (irel->r_info) != (int) R_SH_DATA 916 && ELF32_R_TYPE (irel->r_info) != (int) R_SH_LABEL) 917 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), 918 (int) R_SH_NONE); 919 920 /* If this is a PC relative reloc, see if the range it covers 921 includes the bytes we have deleted. */ 922 switch ((enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info)) 923 { 924 default: 925 break; 926 927 case R_SH_DIR8WPN: 928 case R_SH_IND12W: 929 case R_SH_DIR8WPZ: 930 case R_SH_DIR8WPL: 931 start = irel->r_offset; 932 insn = bfd_get_16 (abfd, contents + nraddr); 933 break; 934 } 935 936 switch ((enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info)) 937 { 938 default: 939 start = stop = addr; 940 break; 941 942 case R_SH_DIR32: 943 /* If this reloc is against a symbol defined in this 944 section, and the symbol will not be adjusted below, we 945 must check the addend to see it will put the value in 946 range to be adjusted, and hence must be changed. */ 947 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info) 948 { 949 isym = isymbuf + ELF32_R_SYM (irel->r_info); 950 if (isym->st_shndx == sec_shndx 951 && (isym->st_value <= addr 952 || isym->st_value >= toaddr)) 953 { 954 bfd_vma val; 955 956 if (get_howto_table (abfd)[R_SH_DIR32].partial_inplace) 957 { 958 val = bfd_get_32 (abfd, contents + nraddr); 959 val += isym->st_value; 960 if (val > addr && val < toaddr) 961 bfd_put_32 (abfd, val - count, contents + nraddr); 962 } 963 else 964 { 965 val = isym->st_value + irel->r_addend; 966 if (val > addr && val < toaddr) 967 irel->r_addend -= count; 968 } 969 } 970 } 971 start = stop = addr; 972 break; 973 974 case R_SH_DIR8WPN: 975 off = insn & 0xff; 976 if (off & 0x80) 977 off -= 0x100; 978 stop = (bfd_vma) ((bfd_signed_vma) start + 4 + off * 2); 979 break; 980 981 case R_SH_IND12W: 982 off = insn & 0xfff; 983 if (! off) 984 { 985 /* This has been made by previous relaxation. Since the 986 relocation will be against an external symbol, the 987 final relocation will just do the right thing. */ 988 start = stop = addr; 989 } 990 else 991 { 992 if (off & 0x800) 993 off -= 0x1000; 994 stop = (bfd_vma) ((bfd_signed_vma) start + 4 + off * 2); 995 996 /* The addend will be against the section symbol, thus 997 for adjusting the addend, the relevant start is the 998 start of the section. 999 N.B. If we want to abandon in-place changes here and 1000 test directly using symbol + addend, we have to take into 1001 account that the addend has already been adjusted by -4. */ 1002 if (stop > addr && stop < toaddr) 1003 irel->r_addend -= count; 1004 } 1005 break; 1006 1007 case R_SH_DIR8WPZ: 1008 off = insn & 0xff; 1009 stop = start + 4 + off * 2; 1010 break; 1011 1012 case R_SH_DIR8WPL: 1013 off = insn & 0xff; 1014 stop = (start & ~(bfd_vma) 3) + 4 + off * 4; 1015 break; 1016 1017 case R_SH_SWITCH8: 1018 case R_SH_SWITCH16: 1019 case R_SH_SWITCH32: 1020 /* These relocs types represent 1021 .word L2-L1 1022 The r_addend field holds the difference between the reloc 1023 address and L1. That is the start of the reloc, and 1024 adding in the contents gives us the top. We must adjust 1025 both the r_offset field and the section contents. 1026 N.B. in gas / coff bfd, the elf bfd r_addend is called r_offset, 1027 and the elf bfd r_offset is called r_vaddr. */ 1028 1029 stop = irel->r_offset; 1030 start = (bfd_vma) ((bfd_signed_vma) stop - (long) irel->r_addend); 1031 1032 if (start > addr 1033 && start < toaddr 1034 && (stop <= addr || stop >= toaddr)) 1035 irel->r_addend += count; 1036 else if (stop > addr 1037 && stop < toaddr 1038 && (start <= addr || start >= toaddr)) 1039 irel->r_addend -= count; 1040 1041 if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_SWITCH16) 1042 voff = bfd_get_signed_16 (abfd, contents + nraddr); 1043 else if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_SWITCH8) 1044 voff = bfd_get_8 (abfd, contents + nraddr); 1045 else 1046 voff = bfd_get_signed_32 (abfd, contents + nraddr); 1047 stop = (bfd_vma) ((bfd_signed_vma) start + voff); 1048 1049 break; 1050 1051 case R_SH_USES: 1052 start = irel->r_offset; 1053 stop = (bfd_vma) ((bfd_signed_vma) start 1054 + (long) irel->r_addend 1055 + 4); 1056 break; 1057 } 1058 1059 if (start > addr 1060 && start < toaddr 1061 && (stop <= addr || stop >= toaddr)) 1062 adjust = count; 1063 else if (stop > addr 1064 && stop < toaddr 1065 && (start <= addr || start >= toaddr)) 1066 adjust = - count; 1067 else 1068 adjust = 0; 1069 1070 if (adjust != 0) 1071 { 1072 oinsn = insn; 1073 overflow = false; 1074 switch ((enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info)) 1075 { 1076 default: 1077 abort (); 1078 break; 1079 1080 case R_SH_DIR8WPN: 1081 case R_SH_DIR8WPZ: 1082 insn += adjust / 2; 1083 if ((oinsn & 0xff00) != (insn & 0xff00)) 1084 overflow = true; 1085 bfd_put_16 (abfd, (bfd_vma) insn, contents + nraddr); 1086 break; 1087 1088 case R_SH_IND12W: 1089 insn += adjust / 2; 1090 if ((oinsn & 0xf000) != (insn & 0xf000)) 1091 overflow = true; 1092 bfd_put_16 (abfd, (bfd_vma) insn, contents + nraddr); 1093 break; 1094 1095 case R_SH_DIR8WPL: 1096 BFD_ASSERT (adjust == count || count >= 4); 1097 if (count >= 4) 1098 insn += adjust / 4; 1099 else 1100 { 1101 if ((irel->r_offset & 3) == 0) 1102 ++insn; 1103 } 1104 if ((oinsn & 0xff00) != (insn & 0xff00)) 1105 overflow = true; 1106 bfd_put_16 (abfd, (bfd_vma) insn, contents + nraddr); 1107 break; 1108 1109 case R_SH_SWITCH8: 1110 voff += adjust; 1111 if (voff < 0 || voff >= 0xff) 1112 overflow = true; 1113 bfd_put_8 (abfd, voff, contents + nraddr); 1114 break; 1115 1116 case R_SH_SWITCH16: 1117 voff += adjust; 1118 if (voff < - 0x8000 || voff >= 0x8000) 1119 overflow = true; 1120 bfd_put_signed_16 (abfd, (bfd_vma) voff, contents + nraddr); 1121 break; 1122 1123 case R_SH_SWITCH32: 1124 voff += adjust; 1125 bfd_put_signed_32 (abfd, (bfd_vma) voff, contents + nraddr); 1126 break; 1127 1128 case R_SH_USES: 1129 irel->r_addend += adjust; 1130 break; 1131 } 1132 1133 if (overflow) 1134 { 1135 _bfd_error_handler 1136 /* xgettext:c-format */ 1137 (_("%pB: %#" PRIx64 ": fatal: reloc overflow while relaxing"), 1138 abfd, (uint64_t) irel->r_offset); 1139 bfd_set_error (bfd_error_bad_value); 1140 return false; 1141 } 1142 } 1143 1144 irel->r_offset = nraddr; 1145 } 1146 1147 /* Look through all the other sections. If there contain any IMM32 1148 relocs against internal symbols which we are not going to adjust 1149 below, we may need to adjust the addends. */ 1150 for (o = abfd->sections; o != NULL; o = o->next) 1151 { 1152 Elf_Internal_Rela *internal_relocs; 1153 Elf_Internal_Rela *irelscan, *irelscanend; 1154 bfd_byte *ocontents; 1155 1156 if (o == sec 1157 || (o->flags & SEC_RELOC) == 0 1158 || o->reloc_count == 0) 1159 continue; 1160 1161 /* We always cache the relocs. Perhaps, if info->keep_memory is 1162 FALSE, we should free them, if we are permitted to, when we 1163 leave sh_coff_relax_section. */ 1164 internal_relocs = (_bfd_elf_link_read_relocs 1165 (abfd, o, NULL, (Elf_Internal_Rela *) NULL, true)); 1166 if (internal_relocs == NULL) 1167 return false; 1168 1169 ocontents = NULL; 1170 irelscanend = internal_relocs + o->reloc_count; 1171 for (irelscan = internal_relocs; irelscan < irelscanend; irelscan++) 1172 { 1173 /* Dwarf line numbers use R_SH_SWITCH32 relocs. */ 1174 if (ELF32_R_TYPE (irelscan->r_info) == (int) R_SH_SWITCH32) 1175 { 1176 bfd_vma start, stop; 1177 bfd_signed_vma voff; 1178 1179 if (ocontents == NULL) 1180 { 1181 if (elf_section_data (o)->this_hdr.contents != NULL) 1182 ocontents = elf_section_data (o)->this_hdr.contents; 1183 else 1184 { 1185 /* We always cache the section contents. 1186 Perhaps, if info->keep_memory is FALSE, we 1187 should free them, if we are permitted to, 1188 when we leave sh_coff_relax_section. */ 1189 if (!bfd_malloc_and_get_section (abfd, o, &ocontents)) 1190 { 1191 free (ocontents); 1192 return false; 1193 } 1194 1195 elf_section_data (o)->this_hdr.contents = ocontents; 1196 } 1197 } 1198 1199 stop = irelscan->r_offset; 1200 start 1201 = (bfd_vma) ((bfd_signed_vma) stop - (long) irelscan->r_addend); 1202 1203 /* STOP is in a different section, so it won't change. */ 1204 if (start > addr && start < toaddr) 1205 irelscan->r_addend += count; 1206 1207 voff = bfd_get_signed_32 (abfd, ocontents + irelscan->r_offset); 1208 stop = (bfd_vma) ((bfd_signed_vma) start + voff); 1209 1210 if (start > addr 1211 && start < toaddr 1212 && (stop <= addr || stop >= toaddr)) 1213 bfd_put_signed_32 (abfd, (bfd_vma) voff + count, 1214 ocontents + irelscan->r_offset); 1215 else if (stop > addr 1216 && stop < toaddr 1217 && (start <= addr || start >= toaddr)) 1218 bfd_put_signed_32 (abfd, (bfd_vma) voff - count, 1219 ocontents + irelscan->r_offset); 1220 } 1221 1222 if (ELF32_R_TYPE (irelscan->r_info) != (int) R_SH_DIR32) 1223 continue; 1224 1225 if (ELF32_R_SYM (irelscan->r_info) >= symtab_hdr->sh_info) 1226 continue; 1227 1228 1229 isym = isymbuf + ELF32_R_SYM (irelscan->r_info); 1230 if (isym->st_shndx == sec_shndx 1231 && (isym->st_value <= addr 1232 || isym->st_value >= toaddr)) 1233 { 1234 bfd_vma val; 1235 1236 if (ocontents == NULL) 1237 { 1238 if (elf_section_data (o)->this_hdr.contents != NULL) 1239 ocontents = elf_section_data (o)->this_hdr.contents; 1240 else 1241 { 1242 /* We always cache the section contents. 1243 Perhaps, if info->keep_memory is FALSE, we 1244 should free them, if we are permitted to, 1245 when we leave sh_coff_relax_section. */ 1246 if (!bfd_malloc_and_get_section (abfd, o, &ocontents)) 1247 { 1248 free (ocontents); 1249 return false; 1250 } 1251 1252 elf_section_data (o)->this_hdr.contents = ocontents; 1253 } 1254 } 1255 1256 val = bfd_get_32 (abfd, ocontents + irelscan->r_offset); 1257 val += isym->st_value; 1258 if (val > addr && val < toaddr) 1259 bfd_put_32 (abfd, val - count, 1260 ocontents + irelscan->r_offset); 1261 } 1262 } 1263 } 1264 1265 /* Adjust the local symbols defined in this section. */ 1266 isymend = isymbuf + symtab_hdr->sh_info; 1267 for (isym = isymbuf; isym < isymend; isym++) 1268 { 1269 if (isym->st_shndx == sec_shndx 1270 && isym->st_value > addr 1271 && isym->st_value < toaddr) 1272 isym->st_value -= count; 1273 } 1274 1275 /* Now adjust the global symbols defined in this section. */ 1276 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym) 1277 - symtab_hdr->sh_info); 1278 sym_hashes = elf_sym_hashes (abfd); 1279 end_hashes = sym_hashes + symcount; 1280 for (; sym_hashes < end_hashes; sym_hashes++) 1281 { 1282 struct elf_link_hash_entry *sym_hash = *sym_hashes; 1283 if ((sym_hash->root.type == bfd_link_hash_defined 1284 || sym_hash->root.type == bfd_link_hash_defweak) 1285 && sym_hash->root.u.def.section == sec 1286 && sym_hash->root.u.def.value > addr 1287 && sym_hash->root.u.def.value < toaddr) 1288 { 1289 sym_hash->root.u.def.value -= count; 1290 } 1291 } 1292 1293 /* See if we can move the ALIGN reloc forward. We have adjusted 1294 r_offset for it already. */ 1295 if (irelalign != NULL) 1296 { 1297 bfd_vma alignto, alignaddr; 1298 1299 alignto = BFD_ALIGN (toaddr, 1 << irelalign->r_addend); 1300 alignaddr = BFD_ALIGN (irelalign->r_offset, 1301 1 << irelalign->r_addend); 1302 if (alignto != alignaddr) 1303 { 1304 /* Tail recursion. */ 1305 return sh_elf_relax_delete_bytes (abfd, sec, alignaddr, 1306 (int) (alignto - alignaddr)); 1307 } 1308 } 1309 1310 return true; 1311 } 1312 1313 /* Look for loads and stores which we can align to four byte 1314 boundaries. This is like sh_align_loads in coff-sh.c. */ 1315 1316 static bool 1317 sh_elf_align_loads (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, 1318 Elf_Internal_Rela *internal_relocs, 1319 bfd_byte *contents ATTRIBUTE_UNUSED, 1320 bool *pswapped) 1321 { 1322 Elf_Internal_Rela *irel, *irelend; 1323 bfd_vma *labels = NULL; 1324 bfd_vma *label, *label_end; 1325 bfd_size_type amt; 1326 1327 *pswapped = false; 1328 1329 irelend = internal_relocs + sec->reloc_count; 1330 1331 /* Get all the addresses with labels on them. */ 1332 amt = sec->reloc_count; 1333 amt *= sizeof (bfd_vma); 1334 labels = (bfd_vma *) bfd_malloc (amt); 1335 if (labels == NULL) 1336 goto error_return; 1337 label_end = labels; 1338 for (irel = internal_relocs; irel < irelend; irel++) 1339 { 1340 if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_LABEL) 1341 { 1342 *label_end = irel->r_offset; 1343 ++label_end; 1344 } 1345 } 1346 1347 /* Note that the assembler currently always outputs relocs in 1348 address order. If that ever changes, this code will need to sort 1349 the label values and the relocs. */ 1350 1351 label = labels; 1352 1353 for (irel = internal_relocs; irel < irelend; irel++) 1354 { 1355 bfd_vma start, stop; 1356 1357 if (ELF32_R_TYPE (irel->r_info) != (int) R_SH_CODE) 1358 continue; 1359 1360 start = irel->r_offset; 1361 1362 for (irel++; irel < irelend; irel++) 1363 if (ELF32_R_TYPE (irel->r_info) == (int) R_SH_DATA) 1364 break; 1365 if (irel < irelend) 1366 stop = irel->r_offset; 1367 else 1368 stop = sec->size; 1369 1370 if (! _bfd_sh_align_load_span (abfd, sec, contents, sh_elf_swap_insns, 1371 internal_relocs, &label, 1372 label_end, start, stop, pswapped)) 1373 goto error_return; 1374 } 1375 1376 free (labels); 1377 1378 return true; 1379 1380 error_return: 1381 free (labels); 1382 return false; 1383 } 1384 1385 /* Swap two SH instructions. This is like sh_swap_insns in coff-sh.c. */ 1386 1387 static bool 1388 sh_elf_swap_insns (bfd *abfd, asection *sec, void *relocs, 1389 bfd_byte *contents, bfd_vma addr) 1390 { 1391 Elf_Internal_Rela *internal_relocs = (Elf_Internal_Rela *) relocs; 1392 unsigned short i1, i2; 1393 Elf_Internal_Rela *irel, *irelend; 1394 1395 /* Swap the instructions themselves. */ 1396 i1 = bfd_get_16 (abfd, contents + addr); 1397 i2 = bfd_get_16 (abfd, contents + addr + 2); 1398 bfd_put_16 (abfd, (bfd_vma) i2, contents + addr); 1399 bfd_put_16 (abfd, (bfd_vma) i1, contents + addr + 2); 1400 1401 /* Adjust all reloc addresses. */ 1402 irelend = internal_relocs + sec->reloc_count; 1403 for (irel = internal_relocs; irel < irelend; irel++) 1404 { 1405 enum elf_sh_reloc_type type; 1406 int add; 1407 1408 /* There are a few special types of relocs that we don't want to 1409 adjust. These relocs do not apply to the instruction itself, 1410 but are only associated with the address. */ 1411 type = (enum elf_sh_reloc_type) ELF32_R_TYPE (irel->r_info); 1412 if (type == R_SH_ALIGN 1413 || type == R_SH_CODE 1414 || type == R_SH_DATA 1415 || type == R_SH_LABEL) 1416 continue; 1417 1418 /* If an R_SH_USES reloc points to one of the addresses being 1419 swapped, we must adjust it. It would be incorrect to do this 1420 for a jump, though, since we want to execute both 1421 instructions after the jump. (We have avoided swapping 1422 around a label, so the jump will not wind up executing an 1423 instruction it shouldn't). */ 1424 if (type == R_SH_USES) 1425 { 1426 bfd_vma off; 1427 1428 off = irel->r_offset + 4 + irel->r_addend; 1429 if (off == addr) 1430 irel->r_offset += 2; 1431 else if (off == addr + 2) 1432 irel->r_offset -= 2; 1433 } 1434 1435 if (irel->r_offset == addr) 1436 { 1437 irel->r_offset += 2; 1438 add = -2; 1439 } 1440 else if (irel->r_offset == addr + 2) 1441 { 1442 irel->r_offset -= 2; 1443 add = 2; 1444 } 1445 else 1446 add = 0; 1447 1448 if (add != 0) 1449 { 1450 bfd_byte *loc; 1451 unsigned short insn, oinsn; 1452 bool overflow; 1453 1454 loc = contents + irel->r_offset; 1455 overflow = false; 1456 switch (type) 1457 { 1458 default: 1459 break; 1460 1461 case R_SH_DIR8WPN: 1462 case R_SH_DIR8WPZ: 1463 insn = bfd_get_16 (abfd, loc); 1464 oinsn = insn; 1465 insn += add / 2; 1466 if ((oinsn & 0xff00) != (insn & 0xff00)) 1467 overflow = true; 1468 bfd_put_16 (abfd, (bfd_vma) insn, loc); 1469 break; 1470 1471 case R_SH_IND12W: 1472 insn = bfd_get_16 (abfd, loc); 1473 oinsn = insn; 1474 insn += add / 2; 1475 if ((oinsn & 0xf000) != (insn & 0xf000)) 1476 overflow = true; 1477 bfd_put_16 (abfd, (bfd_vma) insn, loc); 1478 break; 1479 1480 case R_SH_DIR8WPL: 1481 /* This reloc ignores the least significant 3 bits of 1482 the program counter before adding in the offset. 1483 This means that if ADDR is at an even address, the 1484 swap will not affect the offset. If ADDR is an at an 1485 odd address, then the instruction will be crossing a 1486 four byte boundary, and must be adjusted. */ 1487 if ((addr & 3) != 0) 1488 { 1489 insn = bfd_get_16 (abfd, loc); 1490 oinsn = insn; 1491 insn += add / 2; 1492 if ((oinsn & 0xff00) != (insn & 0xff00)) 1493 overflow = true; 1494 bfd_put_16 (abfd, (bfd_vma) insn, loc); 1495 } 1496 1497 break; 1498 } 1499 1500 if (overflow) 1501 { 1502 _bfd_error_handler 1503 /* xgettext:c-format */ 1504 (_("%pB: %#" PRIx64 ": fatal: reloc overflow while relaxing"), 1505 abfd, (uint64_t) irel->r_offset); 1506 bfd_set_error (bfd_error_bad_value); 1507 return false; 1508 } 1509 } 1510 } 1511 1512 return true; 1513 } 1514 1515 /* Describes one of the various PLT styles. */ 1516 1517 struct elf_sh_plt_info 1518 { 1519 /* The template for the first PLT entry, or NULL if there is no special 1520 first entry. */ 1521 const bfd_byte *plt0_entry; 1522 1523 /* The size of PLT0_ENTRY in bytes, or 0 if PLT0_ENTRY is NULL. */ 1524 bfd_vma plt0_entry_size; 1525 1526 /* Index I is the offset into PLT0_ENTRY of a pointer to 1527 _GLOBAL_OFFSET_TABLE_ + I * 4. The value is MINUS_ONE 1528 if there is no such pointer. */ 1529 bfd_vma plt0_got_fields[3]; 1530 1531 /* The template for a symbol's PLT entry. */ 1532 const bfd_byte *symbol_entry; 1533 1534 /* The size of SYMBOL_ENTRY in bytes. */ 1535 bfd_vma symbol_entry_size; 1536 1537 /* Byte offsets of fields in SYMBOL_ENTRY. Not all fields are used 1538 on all targets. The comments by each member indicate the value 1539 that the field must hold. */ 1540 struct { 1541 bfd_vma got_entry; /* the address of the symbol's .got.plt entry */ 1542 bfd_vma plt; /* .plt (or a branch to .plt on VxWorks) */ 1543 bfd_vma reloc_offset; /* the offset of the symbol's JMP_SLOT reloc */ 1544 bool got20; /* TRUE if got_entry points to a movi20 instruction 1545 (instead of a constant pool entry). */ 1546 } symbol_fields; 1547 1548 /* The offset of the resolver stub from the start of SYMBOL_ENTRY. */ 1549 bfd_vma symbol_resolve_offset; 1550 1551 /* A different PLT layout which can be used for the first 1552 MAX_SHORT_PLT entries. It must share the same plt0. NULL in 1553 other cases. */ 1554 const struct elf_sh_plt_info *short_plt; 1555 }; 1556 1557 /* The size in bytes of an entry in the procedure linkage table. */ 1558 1559 #define ELF_PLT_ENTRY_SIZE 28 1560 1561 /* First entry in an absolute procedure linkage table look like this. */ 1562 1563 /* Note - this code has been "optimised" not to use r2. r2 is used by 1564 GCC to return the address of large structures, so it should not be 1565 corrupted here. This does mean however, that this PLT does not conform 1566 to the SH PIC ABI. That spec says that r0 contains the type of the PLT 1567 and r2 contains the GOT id. This version stores the GOT id in r0 and 1568 ignores the type. Loaders can easily detect this difference however, 1569 since the type will always be 0 or 8, and the GOT ids will always be 1570 greater than or equal to 12. */ 1571 static const bfd_byte elf_sh_plt0_entry_be[ELF_PLT_ENTRY_SIZE] = 1572 { 1573 0xd0, 0x05, /* mov.l 2f,r0 */ 1574 0x60, 0x02, /* mov.l @r0,r0 */ 1575 0x2f, 0x06, /* mov.l r0,@-r15 */ 1576 0xd0, 0x03, /* mov.l 1f,r0 */ 1577 0x60, 0x02, /* mov.l @r0,r0 */ 1578 0x40, 0x2b, /* jmp @r0 */ 1579 0x60, 0xf6, /* mov.l @r15+,r0 */ 1580 0x00, 0x09, /* nop */ 1581 0x00, 0x09, /* nop */ 1582 0x00, 0x09, /* nop */ 1583 0, 0, 0, 0, /* 1: replaced with address of .got.plt + 8. */ 1584 0, 0, 0, 0, /* 2: replaced with address of .got.plt + 4. */ 1585 }; 1586 1587 static const bfd_byte elf_sh_plt0_entry_le[ELF_PLT_ENTRY_SIZE] = 1588 { 1589 0x05, 0xd0, /* mov.l 2f,r0 */ 1590 0x02, 0x60, /* mov.l @r0,r0 */ 1591 0x06, 0x2f, /* mov.l r0,@-r15 */ 1592 0x03, 0xd0, /* mov.l 1f,r0 */ 1593 0x02, 0x60, /* mov.l @r0,r0 */ 1594 0x2b, 0x40, /* jmp @r0 */ 1595 0xf6, 0x60, /* mov.l @r15+,r0 */ 1596 0x09, 0x00, /* nop */ 1597 0x09, 0x00, /* nop */ 1598 0x09, 0x00, /* nop */ 1599 0, 0, 0, 0, /* 1: replaced with address of .got.plt + 8. */ 1600 0, 0, 0, 0, /* 2: replaced with address of .got.plt + 4. */ 1601 }; 1602 1603 /* Sebsequent entries in an absolute procedure linkage table look like 1604 this. */ 1605 1606 static const bfd_byte elf_sh_plt_entry_be[ELF_PLT_ENTRY_SIZE] = 1607 { 1608 0xd0, 0x04, /* mov.l 1f,r0 */ 1609 0x60, 0x02, /* mov.l @(r0,r12),r0 */ 1610 0xd1, 0x02, /* mov.l 0f,r1 */ 1611 0x40, 0x2b, /* jmp @r0 */ 1612 0x60, 0x13, /* mov r1,r0 */ 1613 0xd1, 0x03, /* mov.l 2f,r1 */ 1614 0x40, 0x2b, /* jmp @r0 */ 1615 0x00, 0x09, /* nop */ 1616 0, 0, 0, 0, /* 0: replaced with address of .PLT0. */ 1617 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */ 1618 0, 0, 0, 0, /* 2: replaced with offset into relocation table. */ 1619 }; 1620 1621 static const bfd_byte elf_sh_plt_entry_le[ELF_PLT_ENTRY_SIZE] = 1622 { 1623 0x04, 0xd0, /* mov.l 1f,r0 */ 1624 0x02, 0x60, /* mov.l @r0,r0 */ 1625 0x02, 0xd1, /* mov.l 0f,r1 */ 1626 0x2b, 0x40, /* jmp @r0 */ 1627 0x13, 0x60, /* mov r1,r0 */ 1628 0x03, 0xd1, /* mov.l 2f,r1 */ 1629 0x2b, 0x40, /* jmp @r0 */ 1630 0x09, 0x00, /* nop */ 1631 0, 0, 0, 0, /* 0: replaced with address of .PLT0. */ 1632 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */ 1633 0, 0, 0, 0, /* 2: replaced with offset into relocation table. */ 1634 }; 1635 1636 /* Entries in a PIC procedure linkage table look like this. */ 1637 1638 static const bfd_byte elf_sh_pic_plt_entry_be[ELF_PLT_ENTRY_SIZE] = 1639 { 1640 0xd0, 0x04, /* mov.l 1f,r0 */ 1641 0x00, 0xce, /* mov.l @(r0,r12),r0 */ 1642 0x40, 0x2b, /* jmp @r0 */ 1643 0x00, 0x09, /* nop */ 1644 0x50, 0xc2, /* mov.l @(8,r12),r0 */ 1645 0xd1, 0x03, /* mov.l 2f,r1 */ 1646 0x40, 0x2b, /* jmp @r0 */ 1647 0x50, 0xc1, /* mov.l @(4,r12),r0 */ 1648 0x00, 0x09, /* nop */ 1649 0x00, 0x09, /* nop */ 1650 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */ 1651 0, 0, 0, 0 /* 2: replaced with offset into relocation table. */ 1652 }; 1653 1654 static const bfd_byte elf_sh_pic_plt_entry_le[ELF_PLT_ENTRY_SIZE] = 1655 { 1656 0x04, 0xd0, /* mov.l 1f,r0 */ 1657 0xce, 0x00, /* mov.l @(r0,r12),r0 */ 1658 0x2b, 0x40, /* jmp @r0 */ 1659 0x09, 0x00, /* nop */ 1660 0xc2, 0x50, /* mov.l @(8,r12),r0 */ 1661 0x03, 0xd1, /* mov.l 2f,r1 */ 1662 0x2b, 0x40, /* jmp @r0 */ 1663 0xc1, 0x50, /* mov.l @(4,r12),r0 */ 1664 0x09, 0x00, /* nop */ 1665 0x09, 0x00, /* nop */ 1666 0, 0, 0, 0, /* 1: replaced with address of this symbol in .got. */ 1667 0, 0, 0, 0 /* 2: replaced with offset into relocation table. */ 1668 }; 1669 1670 static const struct elf_sh_plt_info elf_sh_plts[2][2] = { 1671 { 1672 { 1673 /* Big-endian non-PIC. */ 1674 elf_sh_plt0_entry_be, 1675 ELF_PLT_ENTRY_SIZE, 1676 { MINUS_ONE, 24, 20 }, 1677 elf_sh_plt_entry_be, 1678 ELF_PLT_ENTRY_SIZE, 1679 { 20, 16, 24, false }, 1680 8, 1681 NULL 1682 }, 1683 { 1684 /* Little-endian non-PIC. */ 1685 elf_sh_plt0_entry_le, 1686 ELF_PLT_ENTRY_SIZE, 1687 { MINUS_ONE, 24, 20 }, 1688 elf_sh_plt_entry_le, 1689 ELF_PLT_ENTRY_SIZE, 1690 { 20, 16, 24, false }, 1691 8, 1692 NULL 1693 }, 1694 }, 1695 { 1696 { 1697 /* Big-endian PIC. */ 1698 elf_sh_plt0_entry_be, 1699 ELF_PLT_ENTRY_SIZE, 1700 { MINUS_ONE, MINUS_ONE, MINUS_ONE }, 1701 elf_sh_pic_plt_entry_be, 1702 ELF_PLT_ENTRY_SIZE, 1703 { 20, MINUS_ONE, 24, false }, 1704 8, 1705 NULL 1706 }, 1707 { 1708 /* Little-endian PIC. */ 1709 elf_sh_plt0_entry_le, 1710 ELF_PLT_ENTRY_SIZE, 1711 { MINUS_ONE, MINUS_ONE, MINUS_ONE }, 1712 elf_sh_pic_plt_entry_le, 1713 ELF_PLT_ENTRY_SIZE, 1714 { 20, MINUS_ONE, 24, false }, 1715 8, 1716 NULL 1717 }, 1718 } 1719 }; 1720 1721 #define VXWORKS_PLT_HEADER_SIZE 12 1722 #define VXWORKS_PLT_ENTRY_SIZE 24 1723 1724 static const bfd_byte vxworks_sh_plt0_entry_be[VXWORKS_PLT_HEADER_SIZE] = 1725 { 1726 0xd1, 0x01, /* mov.l @(8,pc),r1 */ 1727 0x61, 0x12, /* mov.l @r1,r1 */ 1728 0x41, 0x2b, /* jmp @r1 */ 1729 0x00, 0x09, /* nop */ 1730 0, 0, 0, 0 /* 0: replaced with _GLOBAL_OFFSET_TABLE+8. */ 1731 }; 1732 1733 static const bfd_byte vxworks_sh_plt0_entry_le[VXWORKS_PLT_HEADER_SIZE] = 1734 { 1735 0x01, 0xd1, /* mov.l @(8,pc),r1 */ 1736 0x12, 0x61, /* mov.l @r1,r1 */ 1737 0x2b, 0x41, /* jmp @r1 */ 1738 0x09, 0x00, /* nop */ 1739 0, 0, 0, 0 /* 0: replaced with _GLOBAL_OFFSET_TABLE+8. */ 1740 }; 1741 1742 static const bfd_byte vxworks_sh_plt_entry_be[VXWORKS_PLT_ENTRY_SIZE] = 1743 { 1744 0xd0, 0x01, /* mov.l @(8,pc),r0 */ 1745 0x60, 0x02, /* mov.l @r0,r0 */ 1746 0x40, 0x2b, /* jmp @r0 */ 1747 0x00, 0x09, /* nop */ 1748 0, 0, 0, 0, /* 0: replaced with address of this symbol in .got. */ 1749 0xd0, 0x01, /* mov.l @(8,pc),r0 */ 1750 0xa0, 0x00, /* bra PLT (We need to fix the offset.) */ 1751 0x00, 0x09, /* nop */ 1752 0x00, 0x09, /* nop */ 1753 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */ 1754 }; 1755 1756 static const bfd_byte vxworks_sh_plt_entry_le[VXWORKS_PLT_ENTRY_SIZE] = 1757 { 1758 0x01, 0xd0, /* mov.l @(8,pc),r0 */ 1759 0x02, 0x60, /* mov.l @r0,r0 */ 1760 0x2b, 0x40, /* jmp @r0 */ 1761 0x09, 0x00, /* nop */ 1762 0, 0, 0, 0, /* 0: replaced with address of this symbol in .got. */ 1763 0x01, 0xd0, /* mov.l @(8,pc),r0 */ 1764 0x00, 0xa0, /* bra PLT (We need to fix the offset.) */ 1765 0x09, 0x00, /* nop */ 1766 0x09, 0x00, /* nop */ 1767 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */ 1768 }; 1769 1770 static const bfd_byte vxworks_sh_pic_plt_entry_be[VXWORKS_PLT_ENTRY_SIZE] = 1771 { 1772 0xd0, 0x01, /* mov.l @(8,pc),r0 */ 1773 0x00, 0xce, /* mov.l @(r0,r12),r0 */ 1774 0x40, 0x2b, /* jmp @r0 */ 1775 0x00, 0x09, /* nop */ 1776 0, 0, 0, 0, /* 0: replaced with offset of this symbol in .got. */ 1777 0xd0, 0x01, /* mov.l @(8,pc),r0 */ 1778 0x51, 0xc2, /* mov.l @(8,r12),r1 */ 1779 0x41, 0x2b, /* jmp @r1 */ 1780 0x00, 0x09, /* nop */ 1781 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */ 1782 }; 1783 1784 static const bfd_byte vxworks_sh_pic_plt_entry_le[VXWORKS_PLT_ENTRY_SIZE] = 1785 { 1786 0x01, 0xd0, /* mov.l @(8,pc),r0 */ 1787 0xce, 0x00, /* mov.l @(r0,r12),r0 */ 1788 0x2b, 0x40, /* jmp @r0 */ 1789 0x09, 0x00, /* nop */ 1790 0, 0, 0, 0, /* 0: replaced with offset of this symbol in .got. */ 1791 0x01, 0xd0, /* mov.l @(8,pc),r0 */ 1792 0xc2, 0x51, /* mov.l @(8,r12),r1 */ 1793 0x2b, 0x41, /* jmp @r1 */ 1794 0x09, 0x00, /* nop */ 1795 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */ 1796 }; 1797 1798 static const struct elf_sh_plt_info vxworks_sh_plts[2][2] = { 1799 { 1800 { 1801 /* Big-endian non-PIC. */ 1802 vxworks_sh_plt0_entry_be, 1803 VXWORKS_PLT_HEADER_SIZE, 1804 { MINUS_ONE, MINUS_ONE, 8 }, 1805 vxworks_sh_plt_entry_be, 1806 VXWORKS_PLT_ENTRY_SIZE, 1807 { 8, 14, 20, false }, 1808 12, 1809 NULL 1810 }, 1811 { 1812 /* Little-endian non-PIC. */ 1813 vxworks_sh_plt0_entry_le, 1814 VXWORKS_PLT_HEADER_SIZE, 1815 { MINUS_ONE, MINUS_ONE, 8 }, 1816 vxworks_sh_plt_entry_le, 1817 VXWORKS_PLT_ENTRY_SIZE, 1818 { 8, 14, 20, false }, 1819 12, 1820 NULL 1821 }, 1822 }, 1823 { 1824 { 1825 /* Big-endian PIC. */ 1826 NULL, 1827 0, 1828 { MINUS_ONE, MINUS_ONE, MINUS_ONE }, 1829 vxworks_sh_pic_plt_entry_be, 1830 VXWORKS_PLT_ENTRY_SIZE, 1831 { 8, MINUS_ONE, 20, false }, 1832 12, 1833 NULL 1834 }, 1835 { 1836 /* Little-endian PIC. */ 1837 NULL, 1838 0, 1839 { MINUS_ONE, MINUS_ONE, MINUS_ONE }, 1840 vxworks_sh_pic_plt_entry_le, 1841 VXWORKS_PLT_ENTRY_SIZE, 1842 { 8, MINUS_ONE, 20, false }, 1843 12, 1844 NULL 1845 }, 1846 } 1847 }; 1848 1849 /* FDPIC PLT entries. Two unimplemented optimizations for lazy 1850 binding are to omit the lazy binding stub when linking with -z now 1851 and to move lazy binding stubs into a separate region for better 1852 cache behavior. */ 1853 1854 #define FDPIC_PLT_ENTRY_SIZE 28 1855 #define FDPIC_PLT_LAZY_OFFSET 20 1856 1857 /* FIXME: The lazy binding stub requires a plt0 - which may need to be 1858 duplicated if it is out of range, or which can be inlined. So 1859 right now it is always inlined, which wastes a word per stub. It 1860 might be easier to handle the duplication if we put the lazy 1861 stubs separately. */ 1862 1863 static const bfd_byte fdpic_sh_plt_entry_be[FDPIC_PLT_ENTRY_SIZE] = 1864 { 1865 0xd0, 0x02, /* mov.l @(12,pc),r0 */ 1866 0x01, 0xce, /* mov.l @(r0,r12),r1 */ 1867 0x70, 0x04, /* add #4, r0 */ 1868 0x41, 0x2b, /* jmp @r1 */ 1869 0x0c, 0xce, /* mov.l @(r0,r12),r12 */ 1870 0x00, 0x09, /* nop */ 1871 0, 0, 0, 0, /* 0: replaced with offset of this symbol's funcdesc */ 1872 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */ 1873 0x60, 0xc2, /* mov.l @r12,r0 */ 1874 0x40, 0x2b, /* jmp @r0 */ 1875 0x53, 0xc1, /* mov.l @(4,r12),r3 */ 1876 0x00, 0x09, /* nop */ 1877 }; 1878 1879 static const bfd_byte fdpic_sh_plt_entry_le[FDPIC_PLT_ENTRY_SIZE] = 1880 { 1881 0x02, 0xd0, /* mov.l @(12,pc),r0 */ 1882 0xce, 0x01, /* mov.l @(r0,r12),r1 */ 1883 0x04, 0x70, /* add #4, r0 */ 1884 0x2b, 0x41, /* jmp @r1 */ 1885 0xce, 0x0c, /* mov.l @(r0,r12),r12 */ 1886 0x09, 0x00, /* nop */ 1887 0, 0, 0, 0, /* 0: replaced with offset of this symbol's funcdesc */ 1888 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */ 1889 0xc2, 0x60, /* mov.l @r12,r0 */ 1890 0x2b, 0x40, /* jmp @r0 */ 1891 0xc1, 0x53, /* mov.l @(4,r12),r3 */ 1892 0x09, 0x00, /* nop */ 1893 }; 1894 1895 static const struct elf_sh_plt_info fdpic_sh_plts[2] = { 1896 { 1897 /* Big-endian PIC. */ 1898 NULL, 1899 0, 1900 { MINUS_ONE, MINUS_ONE, MINUS_ONE }, 1901 fdpic_sh_plt_entry_be, 1902 FDPIC_PLT_ENTRY_SIZE, 1903 { 12, MINUS_ONE, 16, false }, 1904 FDPIC_PLT_LAZY_OFFSET, 1905 NULL 1906 }, 1907 { 1908 /* Little-endian PIC. */ 1909 NULL, 1910 0, 1911 { MINUS_ONE, MINUS_ONE, MINUS_ONE }, 1912 fdpic_sh_plt_entry_le, 1913 FDPIC_PLT_ENTRY_SIZE, 1914 { 12, MINUS_ONE, 16, false }, 1915 FDPIC_PLT_LAZY_OFFSET, 1916 NULL 1917 }, 1918 }; 1919 1920 /* On SH2A, we can use the movi20 instruction to generate shorter PLT 1921 entries for the first 64K slots. We use the normal FDPIC PLT entry 1922 past that point; we could also use movi20s, which might be faster, 1923 but would not be any smaller. */ 1924 1925 #define FDPIC_SH2A_PLT_ENTRY_SIZE 24 1926 #define FDPIC_SH2A_PLT_LAZY_OFFSET 16 1927 1928 static const bfd_byte fdpic_sh2a_plt_entry_be[FDPIC_SH2A_PLT_ENTRY_SIZE] = 1929 { 1930 0, 0, 0, 0, /* movi20 #gotofffuncdesc,r0 */ 1931 0x01, 0xce, /* mov.l @(r0,r12),r1 */ 1932 0x70, 0x04, /* add #4, r0 */ 1933 0x41, 0x2b, /* jmp @r1 */ 1934 0x0c, 0xce, /* mov.l @(r0,r12),r12 */ 1935 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */ 1936 0x60, 0xc2, /* mov.l @r12,r0 */ 1937 0x40, 0x2b, /* jmp @r0 */ 1938 0x53, 0xc1, /* mov.l @(4,r12),r3 */ 1939 0x00, 0x09, /* nop */ 1940 }; 1941 1942 static const bfd_byte fdpic_sh2a_plt_entry_le[FDPIC_SH2A_PLT_ENTRY_SIZE] = 1943 { 1944 0, 0, 0, 0, /* movi20 #gotofffuncdesc,r0 */ 1945 0xce, 0x01, /* mov.l @(r0,r12),r1 */ 1946 0x04, 0x70, /* add #4, r0 */ 1947 0x2b, 0x41, /* jmp @r1 */ 1948 0xce, 0x0c, /* mov.l @(r0,r12),r12 */ 1949 0, 0, 0, 0, /* 1: replaced with offset into relocation table. */ 1950 0xc2, 0x60, /* mov.l @r12,r0 */ 1951 0x2b, 0x40, /* jmp @r0 */ 1952 0xc1, 0x53, /* mov.l @(4,r12),r3 */ 1953 0x09, 0x00, /* nop */ 1954 }; 1955 1956 static const struct elf_sh_plt_info fdpic_sh2a_short_plt_be = { 1957 /* Big-endian FDPIC, max index 64K. */ 1958 NULL, 1959 0, 1960 { MINUS_ONE, MINUS_ONE, MINUS_ONE }, 1961 fdpic_sh2a_plt_entry_be, 1962 FDPIC_SH2A_PLT_ENTRY_SIZE, 1963 { 0, MINUS_ONE, 12, true }, 1964 FDPIC_SH2A_PLT_LAZY_OFFSET, 1965 NULL 1966 }; 1967 1968 static const struct elf_sh_plt_info fdpic_sh2a_short_plt_le = { 1969 /* Little-endian FDPIC, max index 64K. */ 1970 NULL, 1971 0, 1972 { MINUS_ONE, MINUS_ONE, MINUS_ONE }, 1973 fdpic_sh2a_plt_entry_le, 1974 FDPIC_SH2A_PLT_ENTRY_SIZE, 1975 { 0, MINUS_ONE, 12, true }, 1976 FDPIC_SH2A_PLT_LAZY_OFFSET, 1977 NULL 1978 }; 1979 1980 static const struct elf_sh_plt_info fdpic_sh2a_plts[2] = { 1981 { 1982 /* Big-endian PIC. */ 1983 NULL, 1984 0, 1985 { MINUS_ONE, MINUS_ONE, MINUS_ONE }, 1986 fdpic_sh_plt_entry_be, 1987 FDPIC_PLT_ENTRY_SIZE, 1988 { 12, MINUS_ONE, 16, false }, 1989 FDPIC_PLT_LAZY_OFFSET, 1990 &fdpic_sh2a_short_plt_be 1991 }, 1992 { 1993 /* Little-endian PIC. */ 1994 NULL, 1995 0, 1996 { MINUS_ONE, MINUS_ONE, MINUS_ONE }, 1997 fdpic_sh_plt_entry_le, 1998 FDPIC_PLT_ENTRY_SIZE, 1999 { 12, MINUS_ONE, 16, false }, 2000 FDPIC_PLT_LAZY_OFFSET, 2001 &fdpic_sh2a_short_plt_le 2002 }, 2003 }; 2004 2005 /* Return the type of PLT associated with ABFD. PIC_P is true if 2006 the object is position-independent. */ 2007 2008 static const struct elf_sh_plt_info * 2009 get_plt_info (bfd *abfd, bool pic_p) 2010 { 2011 if (fdpic_object_p (abfd)) 2012 { 2013 /* If any input file requires SH2A we can use a shorter PLT 2014 sequence. */ 2015 if (sh_get_arch_from_bfd_mach (bfd_get_mach (abfd)) & arch_sh2a_base) 2016 return &fdpic_sh2a_plts[!bfd_big_endian (abfd)]; 2017 else 2018 return &fdpic_sh_plts[!bfd_big_endian (abfd)]; 2019 } 2020 if (vxworks_object_p (abfd)) 2021 return &vxworks_sh_plts[pic_p][!bfd_big_endian (abfd)]; 2022 return &elf_sh_plts[pic_p][!bfd_big_endian (abfd)]; 2023 } 2024 2025 /* Install a 32-bit PLT field starting at ADDR, which occurs in OUTPUT_BFD. 2026 VALUE is the field's value and CODE_P is true if VALUE refers to code, 2027 not data. */ 2028 2029 inline static void 2030 install_plt_field (bfd *output_bfd, bool code_p ATTRIBUTE_UNUSED, 2031 unsigned long value, bfd_byte *addr) 2032 { 2033 bfd_put_32 (output_bfd, value, addr); 2034 } 2035 2036 /* The number of PLT entries which can use a shorter PLT, if any. 2037 Currently always 64K, since only SH-2A FDPIC uses this; a 2038 20-bit movi20 can address that many function descriptors below 2039 _GLOBAL_OFFSET_TABLE_. */ 2040 #define MAX_SHORT_PLT 65536 2041 2042 /* Return the index of the PLT entry at byte offset OFFSET. */ 2043 2044 static bfd_vma 2045 get_plt_index (const struct elf_sh_plt_info *info, bfd_vma offset) 2046 { 2047 bfd_vma plt_index = 0; 2048 2049 offset -= info->plt0_entry_size; 2050 if (info->short_plt != NULL) 2051 { 2052 if (offset > MAX_SHORT_PLT * info->short_plt->symbol_entry_size) 2053 { 2054 plt_index = MAX_SHORT_PLT; 2055 offset -= MAX_SHORT_PLT * info->short_plt->symbol_entry_size; 2056 } 2057 else 2058 info = info->short_plt; 2059 } 2060 return plt_index + offset / info->symbol_entry_size; 2061 } 2062 2063 /* Do the inverse operation. */ 2064 2065 static bfd_vma 2066 get_plt_offset (const struct elf_sh_plt_info *info, bfd_vma plt_index) 2067 { 2068 bfd_vma offset = 0; 2069 2070 if (info->short_plt != NULL) 2071 { 2072 if (plt_index > MAX_SHORT_PLT) 2073 { 2074 offset = MAX_SHORT_PLT * info->short_plt->symbol_entry_size; 2075 plt_index -= MAX_SHORT_PLT; 2076 } 2077 else 2078 info = info->short_plt; 2079 } 2080 return (offset + info->plt0_entry_size 2081 + (plt_index * info->symbol_entry_size)); 2082 } 2083 2084 union gotref 2085 { 2086 bfd_signed_vma refcount; 2087 bfd_vma offset; 2088 }; 2089 2090 /* sh ELF linker hash entry. */ 2091 2092 struct elf_sh_link_hash_entry 2093 { 2094 struct elf_link_hash_entry root; 2095 2096 bfd_signed_vma gotplt_refcount; 2097 2098 /* A local function descriptor, for FDPIC. The refcount counts 2099 R_SH_FUNCDESC, R_SH_GOTOFFFUNCDESC, and R_SH_GOTOFFFUNCDESC20 2100 relocations; the PLT and GOT entry are accounted 2101 for separately. After adjust_dynamic_symbol, the offset is 2102 MINUS_ONE if there is no local descriptor (dynamic linker 2103 managed and no PLT entry, or undefined weak non-dynamic). 2104 During check_relocs we do not yet know whether the local 2105 descriptor will be canonical. */ 2106 union gotref funcdesc; 2107 2108 /* How many of the above refcounted relocations were R_SH_FUNCDESC, 2109 and thus require fixups or relocations. */ 2110 bfd_signed_vma abs_funcdesc_refcount; 2111 2112 enum got_type { 2113 GOT_UNKNOWN = 0, GOT_NORMAL, GOT_TLS_GD, GOT_TLS_IE, GOT_FUNCDESC 2114 } got_type; 2115 }; 2116 2117 #define sh_elf_hash_entry(ent) ((struct elf_sh_link_hash_entry *)(ent)) 2118 2119 struct sh_elf_obj_tdata 2120 { 2121 struct elf_obj_tdata root; 2122 2123 /* got_type for each local got entry. */ 2124 char *local_got_type; 2125 2126 /* Function descriptor refcount and offset for each local symbol. */ 2127 union gotref *local_funcdesc; 2128 }; 2129 2130 #define sh_elf_tdata(abfd) \ 2131 ((struct sh_elf_obj_tdata *) (abfd)->tdata.any) 2132 2133 #define sh_elf_local_got_type(abfd) \ 2134 (sh_elf_tdata (abfd)->local_got_type) 2135 2136 #define sh_elf_local_funcdesc(abfd) \ 2137 (sh_elf_tdata (abfd)->local_funcdesc) 2138 2139 #define is_sh_elf(bfd) \ 2140 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \ 2141 && elf_tdata (bfd) != NULL \ 2142 && elf_object_id (bfd) == SH_ELF_DATA) 2143 2144 /* Override the generic function because we need to store sh_elf_obj_tdata 2145 as the specific tdata. */ 2146 2147 static bool 2148 sh_elf_mkobject (bfd *abfd) 2149 { 2150 return bfd_elf_allocate_object (abfd, sizeof (struct sh_elf_obj_tdata), 2151 SH_ELF_DATA); 2152 } 2153 2154 /* sh ELF linker hash table. */ 2155 2156 struct elf_sh_link_hash_table 2157 { 2158 struct elf_link_hash_table root; 2159 2160 /* Short-cuts to get to dynamic linker sections. */ 2161 asection *sfuncdesc; 2162 asection *srelfuncdesc; 2163 asection *srofixup; 2164 2165 /* The (unloaded but important) VxWorks .rela.plt.unloaded section. */ 2166 asection *srelplt2; 2167 2168 /* A counter or offset to track a TLS got entry. */ 2169 union 2170 { 2171 bfd_signed_vma refcount; 2172 bfd_vma offset; 2173 } tls_ldm_got; 2174 2175 /* The type of PLT to use. */ 2176 const struct elf_sh_plt_info *plt_info; 2177 2178 /* True if the target system uses FDPIC. */ 2179 bool fdpic_p; 2180 }; 2181 2182 /* Traverse an sh ELF linker hash table. */ 2183 2184 #define sh_elf_link_hash_traverse(table, func, info) \ 2185 (elf_link_hash_traverse \ 2186 (&(table)->root, \ 2187 (bool (*) (struct elf_link_hash_entry *, void *)) (func), \ 2188 (info))) 2189 2190 /* Get the sh ELF linker hash table from a link_info structure. */ 2191 2192 #define sh_elf_hash_table(p) \ 2193 ((is_elf_hash_table ((p)->hash) \ 2194 && elf_hash_table_id (elf_hash_table (p)) == SH_ELF_DATA) \ 2195 ? (struct elf_sh_link_hash_table *) (p)->hash : NULL) 2196 2197 /* Create an entry in an sh ELF linker hash table. */ 2198 2199 static struct bfd_hash_entry * 2200 sh_elf_link_hash_newfunc (struct bfd_hash_entry *entry, 2201 struct bfd_hash_table *table, 2202 const char *string) 2203 { 2204 struct elf_sh_link_hash_entry *ret = 2205 (struct elf_sh_link_hash_entry *) entry; 2206 2207 /* Allocate the structure if it has not already been allocated by a 2208 subclass. */ 2209 if (ret == (struct elf_sh_link_hash_entry *) NULL) 2210 ret = ((struct elf_sh_link_hash_entry *) 2211 bfd_hash_allocate (table, 2212 sizeof (struct elf_sh_link_hash_entry))); 2213 if (ret == (struct elf_sh_link_hash_entry *) NULL) 2214 return (struct bfd_hash_entry *) ret; 2215 2216 /* Call the allocation method of the superclass. */ 2217 ret = ((struct elf_sh_link_hash_entry *) 2218 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret, 2219 table, string)); 2220 if (ret != (struct elf_sh_link_hash_entry *) NULL) 2221 { 2222 ret->gotplt_refcount = 0; 2223 ret->funcdesc.refcount = 0; 2224 ret->abs_funcdesc_refcount = 0; 2225 ret->got_type = GOT_UNKNOWN; 2226 } 2227 2228 return (struct bfd_hash_entry *) ret; 2229 } 2230 2231 /* Create an sh ELF linker hash table. */ 2232 2233 static struct bfd_link_hash_table * 2234 sh_elf_link_hash_table_create (bfd *abfd) 2235 { 2236 struct elf_sh_link_hash_table *ret; 2237 size_t amt = sizeof (struct elf_sh_link_hash_table); 2238 2239 ret = (struct elf_sh_link_hash_table *) bfd_zmalloc (amt); 2240 if (ret == (struct elf_sh_link_hash_table *) NULL) 2241 return NULL; 2242 2243 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd, 2244 sh_elf_link_hash_newfunc, 2245 sizeof (struct elf_sh_link_hash_entry), 2246 SH_ELF_DATA)) 2247 { 2248 free (ret); 2249 return NULL; 2250 } 2251 2252 if (fdpic_object_p (abfd)) 2253 { 2254 ret->root.dt_pltgot_required = true; 2255 ret->fdpic_p = true; 2256 } 2257 2258 return &ret->root.root; 2259 } 2260 2261 static bool 2262 sh_elf_omit_section_dynsym (bfd *output_bfd ATTRIBUTE_UNUSED, 2263 struct bfd_link_info *info, asection *p) 2264 { 2265 struct elf_sh_link_hash_table *htab = sh_elf_hash_table (info); 2266 2267 /* Non-FDPIC binaries do not need dynamic symbols for sections. */ 2268 if (!htab->fdpic_p) 2269 return true; 2270 2271 /* We need dynamic symbols for every section, since segments can 2272 relocate independently. */ 2273 switch (elf_section_data (p)->this_hdr.sh_type) 2274 { 2275 case SHT_PROGBITS: 2276 case SHT_NOBITS: 2277 /* If sh_type is yet undecided, assume it could be 2278 SHT_PROGBITS/SHT_NOBITS. */ 2279 case SHT_NULL: 2280 return false; 2281 2282 /* There shouldn't be section relative relocations 2283 against any other section. */ 2284 default: 2285 return true; 2286 } 2287 } 2288 2289 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up 2290 shortcuts to them in our hash table. */ 2291 2292 static bool 2293 create_got_section (bfd *dynobj, struct bfd_link_info *info) 2294 { 2295 struct elf_sh_link_hash_table *htab; 2296 2297 if (! _bfd_elf_create_got_section (dynobj, info)) 2298 return false; 2299 2300 htab = sh_elf_hash_table (info); 2301 if (htab == NULL) 2302 return false; 2303 2304 htab->sfuncdesc = bfd_make_section_anyway_with_flags (dynobj, ".got.funcdesc", 2305 (SEC_ALLOC | SEC_LOAD 2306 | SEC_HAS_CONTENTS 2307 | SEC_IN_MEMORY 2308 | SEC_LINKER_CREATED)); 2309 if (htab->sfuncdesc == NULL 2310 || !bfd_set_section_alignment (htab->sfuncdesc, 2)) 2311 return false; 2312 2313 htab->srelfuncdesc = bfd_make_section_anyway_with_flags (dynobj, 2314 ".rela.got.funcdesc", 2315 (SEC_ALLOC | SEC_LOAD 2316 | SEC_HAS_CONTENTS 2317 | SEC_IN_MEMORY 2318 | SEC_LINKER_CREATED 2319 | SEC_READONLY)); 2320 if (htab->srelfuncdesc == NULL 2321 || !bfd_set_section_alignment (htab->srelfuncdesc, 2)) 2322 return false; 2323 2324 /* Also create .rofixup. */ 2325 htab->srofixup = bfd_make_section_anyway_with_flags (dynobj, ".rofixup", 2326 (SEC_ALLOC | SEC_LOAD 2327 | SEC_HAS_CONTENTS 2328 | SEC_IN_MEMORY 2329 | SEC_LINKER_CREATED 2330 | SEC_READONLY)); 2331 if (htab->srofixup == NULL 2332 || !bfd_set_section_alignment (htab->srofixup, 2)) 2333 return false; 2334 2335 return true; 2336 } 2337 2338 /* Create dynamic sections when linking against a dynamic object. */ 2339 2340 static bool 2341 sh_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info) 2342 { 2343 struct elf_sh_link_hash_table *htab; 2344 flagword flags, pltflags; 2345 asection *s; 2346 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 2347 int ptralign = 0; 2348 2349 switch (bed->s->arch_size) 2350 { 2351 case 32: 2352 ptralign = 2; 2353 break; 2354 2355 case 64: 2356 ptralign = 3; 2357 break; 2358 2359 default: 2360 bfd_set_error (bfd_error_bad_value); 2361 return false; 2362 } 2363 2364 htab = sh_elf_hash_table (info); 2365 if (htab == NULL) 2366 return false; 2367 2368 if (htab->root.dynamic_sections_created) 2369 return true; 2370 2371 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and 2372 .rel[a].bss sections. */ 2373 2374 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY 2375 | SEC_LINKER_CREATED); 2376 2377 pltflags = flags; 2378 pltflags |= SEC_CODE; 2379 if (bed->plt_not_loaded) 2380 pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS); 2381 if (bed->plt_readonly) 2382 pltflags |= SEC_READONLY; 2383 2384 s = bfd_make_section_anyway_with_flags (abfd, ".plt", pltflags); 2385 htab->root.splt = s; 2386 if (s == NULL 2387 || !bfd_set_section_alignment (s, bed->plt_alignment)) 2388 return false; 2389 2390 if (bed->want_plt_sym) 2391 { 2392 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the 2393 .plt section. */ 2394 struct elf_link_hash_entry *h; 2395 struct bfd_link_hash_entry *bh = NULL; 2396 2397 if (! (_bfd_generic_link_add_one_symbol 2398 (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s, 2399 (bfd_vma) 0, (const char *) NULL, false, 2400 get_elf_backend_data (abfd)->collect, &bh))) 2401 return false; 2402 2403 h = (struct elf_link_hash_entry *) bh; 2404 h->def_regular = 1; 2405 h->type = STT_OBJECT; 2406 htab->root.hplt = h; 2407 2408 if (bfd_link_pic (info) 2409 && ! bfd_elf_link_record_dynamic_symbol (info, h)) 2410 return false; 2411 } 2412 2413 s = bfd_make_section_anyway_with_flags (abfd, 2414 bed->default_use_rela_p 2415 ? ".rela.plt" : ".rel.plt", 2416 flags | SEC_READONLY); 2417 htab->root.srelplt = s; 2418 if (s == NULL 2419 || !bfd_set_section_alignment (s, ptralign)) 2420 return false; 2421 2422 if (htab->root.sgot == NULL 2423 && !create_got_section (abfd, info)) 2424 return false; 2425 2426 if (bed->want_dynbss) 2427 { 2428 /* The .dynbss section is a place to put symbols which are defined 2429 by dynamic objects, are referenced by regular objects, and are 2430 not functions. We must allocate space for them in the process 2431 image and use a R_*_COPY reloc to tell the dynamic linker to 2432 initialize them at run time. The linker script puts the .dynbss 2433 section into the .bss section of the final image. */ 2434 s = bfd_make_section_anyway_with_flags (abfd, ".dynbss", 2435 SEC_ALLOC | SEC_LINKER_CREATED); 2436 htab->root.sdynbss = s; 2437 if (s == NULL) 2438 return false; 2439 2440 /* The .rel[a].bss section holds copy relocs. This section is not 2441 normally needed. We need to create it here, though, so that the 2442 linker will map it to an output section. We can't just create it 2443 only if we need it, because we will not know whether we need it 2444 until we have seen all the input files, and the first time the 2445 main linker code calls BFD after examining all the input files 2446 (size_dynamic_sections) the input sections have already been 2447 mapped to the output sections. If the section turns out not to 2448 be needed, we can discard it later. We will never need this 2449 section when generating a shared object, since they do not use 2450 copy relocs. */ 2451 if (! bfd_link_pic (info)) 2452 { 2453 s = bfd_make_section_anyway_with_flags (abfd, 2454 (bed->default_use_rela_p 2455 ? ".rela.bss" : ".rel.bss"), 2456 flags | SEC_READONLY); 2457 htab->root.srelbss = s; 2458 if (s == NULL 2459 || !bfd_set_section_alignment (s, ptralign)) 2460 return false; 2461 } 2462 } 2463 2464 if (htab->root.target_os == is_vxworks) 2465 { 2466 if (!elf_vxworks_create_dynamic_sections (abfd, info, &htab->srelplt2)) 2467 return false; 2468 } 2469 2470 return true; 2471 } 2472 2473 /* Adjust a symbol defined by a dynamic object and referenced by a 2474 regular object. The current definition is in some section of the 2475 dynamic object, but we're not including those sections. We have to 2476 change the definition to something the rest of the link can 2477 understand. */ 2478 2479 static bool 2480 sh_elf_adjust_dynamic_symbol (struct bfd_link_info *info, 2481 struct elf_link_hash_entry *h) 2482 { 2483 struct elf_sh_link_hash_table *htab; 2484 asection *s; 2485 2486 htab = sh_elf_hash_table (info); 2487 if (htab == NULL) 2488 return false; 2489 2490 /* Make sure we know what is going on here. */ 2491 BFD_ASSERT (htab->root.dynobj != NULL 2492 && (h->needs_plt 2493 || h->is_weakalias 2494 || (h->def_dynamic 2495 && h->ref_regular 2496 && !h->def_regular))); 2497 2498 /* If this is a function, put it in the procedure linkage table. We 2499 will fill in the contents of the procedure linkage table later, 2500 when we know the address of the .got section. */ 2501 if (h->type == STT_FUNC 2502 || h->needs_plt) 2503 { 2504 if (h->plt.refcount <= 0 2505 || SYMBOL_CALLS_LOCAL (info, h) 2506 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT 2507 && h->root.type == bfd_link_hash_undefweak)) 2508 { 2509 /* This case can occur if we saw a PLT reloc in an input 2510 file, but the symbol was never referred to by a dynamic 2511 object. In such a case, we don't actually need to build 2512 a procedure linkage table, and we can just do a REL32 2513 reloc instead. */ 2514 h->plt.offset = (bfd_vma) -1; 2515 h->needs_plt = 0; 2516 } 2517 2518 return true; 2519 } 2520 else 2521 h->plt.offset = (bfd_vma) -1; 2522 2523 /* If this is a weak symbol, and there is a real definition, the 2524 processor independent code will have arranged for us to see the 2525 real definition first, and we can just use the same value. */ 2526 if (h->is_weakalias) 2527 { 2528 struct elf_link_hash_entry *def = weakdef (h); 2529 BFD_ASSERT (def->root.type == bfd_link_hash_defined); 2530 h->root.u.def.section = def->root.u.def.section; 2531 h->root.u.def.value = def->root.u.def.value; 2532 if (info->nocopyreloc) 2533 h->non_got_ref = def->non_got_ref; 2534 return true; 2535 } 2536 2537 /* This is a reference to a symbol defined by a dynamic object which 2538 is not a function. */ 2539 2540 /* If we are creating a shared library, we must presume that the 2541 only references to the symbol are via the global offset table. 2542 For such cases we need not do anything here; the relocations will 2543 be handled correctly by relocate_section. */ 2544 if (bfd_link_pic (info)) 2545 return true; 2546 2547 /* If there are no references to this symbol that do not use the 2548 GOT, we don't need to generate a copy reloc. */ 2549 if (!h->non_got_ref) 2550 return true; 2551 2552 /* If -z nocopyreloc was given, we won't generate them either. */ 2553 if (0 && info->nocopyreloc) 2554 { 2555 h->non_got_ref = 0; 2556 return true; 2557 } 2558 2559 /* If we don't find any dynamic relocs in read-only sections, then 2560 we'll be keeping the dynamic relocs and avoiding the copy reloc. */ 2561 if (0 && !_bfd_elf_readonly_dynrelocs (h)) 2562 { 2563 h->non_got_ref = 0; 2564 return true; 2565 } 2566 2567 /* We must allocate the symbol in our .dynbss section, which will 2568 become part of the .bss section of the executable. There will be 2569 an entry for this symbol in the .dynsym section. The dynamic 2570 object will contain position independent code, so all references 2571 from the dynamic object to this symbol will go through the global 2572 offset table. The dynamic linker will use the .dynsym entry to 2573 determine the address it must put in the global offset table, so 2574 both the dynamic object and the regular object will refer to the 2575 same memory location for the variable. */ 2576 2577 s = htab->root.sdynbss; 2578 BFD_ASSERT (s != NULL); 2579 2580 /* We must generate a R_SH_COPY reloc to tell the dynamic linker to 2581 copy the initial value out of the dynamic object and into the 2582 runtime process image. We need to remember the offset into the 2583 .rela.bss section we are going to use. */ 2584 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0) 2585 { 2586 asection *srel; 2587 2588 srel = htab->root.srelbss; 2589 BFD_ASSERT (srel != NULL); 2590 srel->size += sizeof (Elf32_External_Rela); 2591 h->needs_copy = 1; 2592 } 2593 2594 return _bfd_elf_adjust_dynamic_copy (info, h, s); 2595 } 2596 2597 /* Allocate space in .plt, .got and associated reloc sections for 2598 dynamic relocs. */ 2599 2600 static bool 2601 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf) 2602 { 2603 struct bfd_link_info *info; 2604 struct elf_sh_link_hash_table *htab; 2605 struct elf_sh_link_hash_entry *eh; 2606 struct elf_dyn_relocs *p; 2607 2608 if (h->root.type == bfd_link_hash_indirect) 2609 return true; 2610 2611 info = (struct bfd_link_info *) inf; 2612 htab = sh_elf_hash_table (info); 2613 if (htab == NULL) 2614 return false; 2615 2616 eh = (struct elf_sh_link_hash_entry *) h; 2617 if ((h->got.refcount > 0 2618 || h->forced_local) 2619 && eh->gotplt_refcount > 0) 2620 { 2621 /* The symbol has been forced local, or we have some direct got refs, 2622 so treat all the gotplt refs as got refs. */ 2623 h->got.refcount += eh->gotplt_refcount; 2624 if (h->plt.refcount >= eh->gotplt_refcount) 2625 h->plt.refcount -= eh->gotplt_refcount; 2626 } 2627 2628 if (htab->root.dynamic_sections_created 2629 && h->plt.refcount > 0 2630 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT 2631 || h->root.type != bfd_link_hash_undefweak)) 2632 { 2633 /* Make sure this symbol is output as a dynamic symbol. 2634 Undefined weak syms won't yet be marked as dynamic. */ 2635 if (h->dynindx == -1 2636 && !h->forced_local) 2637 { 2638 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 2639 return false; 2640 } 2641 2642 if (bfd_link_pic (info) 2643 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h)) 2644 { 2645 asection *s = htab->root.splt; 2646 const struct elf_sh_plt_info *plt_info; 2647 2648 /* If this is the first .plt entry, make room for the special 2649 first entry. */ 2650 if (s->size == 0) 2651 s->size += htab->plt_info->plt0_entry_size; 2652 2653 h->plt.offset = s->size; 2654 2655 /* If this symbol is not defined in a regular file, and we are 2656 not generating a shared library, then set the symbol to this 2657 location in the .plt. This is required to make function 2658 pointers compare as equal between the normal executable and 2659 the shared library. Skip this for FDPIC, since the 2660 function's address will be the address of the canonical 2661 function descriptor. */ 2662 if (!htab->fdpic_p && !bfd_link_pic (info) && !h->def_regular) 2663 { 2664 h->root.u.def.section = s; 2665 h->root.u.def.value = h->plt.offset; 2666 } 2667 2668 /* Make room for this entry. */ 2669 plt_info = htab->plt_info; 2670 if (plt_info->short_plt != NULL 2671 && (get_plt_index (plt_info->short_plt, s->size) < MAX_SHORT_PLT)) 2672 plt_info = plt_info->short_plt; 2673 s->size += plt_info->symbol_entry_size; 2674 2675 /* We also need to make an entry in the .got.plt section, which 2676 will be placed in the .got section by the linker script. */ 2677 if (!htab->fdpic_p) 2678 htab->root.sgotplt->size += 4; 2679 else 2680 htab->root.sgotplt->size += 8; 2681 2682 /* We also need to make an entry in the .rel.plt section. */ 2683 htab->root.srelplt->size += sizeof (Elf32_External_Rela); 2684 2685 if (htab->root.target_os == is_vxworks && !bfd_link_pic (info)) 2686 { 2687 /* VxWorks executables have a second set of relocations 2688 for each PLT entry. They go in a separate relocation 2689 section, which is processed by the kernel loader. */ 2690 2691 /* There is a relocation for the initial PLT entry: 2692 an R_SH_DIR32 relocation for _GLOBAL_OFFSET_TABLE_. */ 2693 if (h->plt.offset == htab->plt_info->plt0_entry_size) 2694 htab->srelplt2->size += sizeof (Elf32_External_Rela); 2695 2696 /* There are two extra relocations for each subsequent 2697 PLT entry: an R_SH_DIR32 relocation for the GOT entry, 2698 and an R_SH_DIR32 relocation for the PLT entry. */ 2699 htab->srelplt2->size += sizeof (Elf32_External_Rela) * 2; 2700 } 2701 } 2702 else 2703 { 2704 h->plt.offset = (bfd_vma) -1; 2705 h->needs_plt = 0; 2706 } 2707 } 2708 else 2709 { 2710 h->plt.offset = (bfd_vma) -1; 2711 h->needs_plt = 0; 2712 } 2713 2714 if (h->got.refcount > 0) 2715 { 2716 asection *s; 2717 bool dyn; 2718 enum got_type got_type = sh_elf_hash_entry (h)->got_type; 2719 2720 /* Make sure this symbol is output as a dynamic symbol. 2721 Undefined weak syms won't yet be marked as dynamic. */ 2722 if (h->dynindx == -1 2723 && !h->forced_local) 2724 { 2725 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 2726 return false; 2727 } 2728 2729 s = htab->root.sgot; 2730 h->got.offset = s->size; 2731 s->size += 4; 2732 /* R_SH_TLS_GD needs 2 consecutive GOT slots. */ 2733 if (got_type == GOT_TLS_GD) 2734 s->size += 4; 2735 dyn = htab->root.dynamic_sections_created; 2736 if (!dyn) 2737 { 2738 /* No dynamic relocations required. */ 2739 if (htab->fdpic_p && !bfd_link_pic (info) 2740 && h->root.type != bfd_link_hash_undefweak 2741 && (got_type == GOT_NORMAL || got_type == GOT_FUNCDESC)) 2742 htab->srofixup->size += 4; 2743 } 2744 /* No dynamic relocations required when IE->LE conversion happens. */ 2745 else if (got_type == GOT_TLS_IE 2746 && !h->def_dynamic 2747 && !bfd_link_pic (info)) 2748 ; 2749 /* R_SH_TLS_IE_32 needs one dynamic relocation if dynamic, 2750 R_SH_TLS_GD needs one if local symbol and two if global. */ 2751 else if ((got_type == GOT_TLS_GD && h->dynindx == -1) 2752 || got_type == GOT_TLS_IE) 2753 htab->root.srelgot->size += sizeof (Elf32_External_Rela); 2754 else if (got_type == GOT_TLS_GD) 2755 htab->root.srelgot->size += 2 * sizeof (Elf32_External_Rela); 2756 else if (got_type == GOT_FUNCDESC) 2757 { 2758 if (!bfd_link_pic (info) && SYMBOL_FUNCDESC_LOCAL (info, h)) 2759 htab->srofixup->size += 4; 2760 else 2761 htab->root.srelgot->size += sizeof (Elf32_External_Rela); 2762 } 2763 else if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT 2764 || h->root.type != bfd_link_hash_undefweak) 2765 && (bfd_link_pic (info) 2766 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))) 2767 htab->root.srelgot->size += sizeof (Elf32_External_Rela); 2768 else if (htab->fdpic_p 2769 && !bfd_link_pic (info) 2770 && got_type == GOT_NORMAL 2771 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT 2772 || h->root.type != bfd_link_hash_undefweak)) 2773 htab->srofixup->size += 4; 2774 } 2775 else 2776 h->got.offset = (bfd_vma) -1; 2777 2778 /* Allocate space for any dynamic relocations to function 2779 descriptors, canonical or otherwise. We need to relocate the 2780 reference unless it resolves to zero, which only happens for 2781 undefined weak symbols (either non-default visibility, or when 2782 static linking). Any GOT slot is accounted for elsewhere. */ 2783 if (eh->abs_funcdesc_refcount > 0 2784 && (h->root.type != bfd_link_hash_undefweak 2785 || (htab->root.dynamic_sections_created 2786 && ! SYMBOL_CALLS_LOCAL (info, h)))) 2787 { 2788 if (!bfd_link_pic (info) && SYMBOL_FUNCDESC_LOCAL (info, h)) 2789 htab->srofixup->size += eh->abs_funcdesc_refcount * 4; 2790 else 2791 htab->root.srelgot->size 2792 += eh->abs_funcdesc_refcount * sizeof (Elf32_External_Rela); 2793 } 2794 2795 /* We must allocate a function descriptor if there are references to 2796 a canonical descriptor (R_SH_GOTFUNCDESC or R_SH_FUNCDESC) and 2797 the dynamic linker isn't going to allocate it. None of this 2798 applies if we already created one in .got.plt, but if the 2799 canonical function descriptor can be in this object, there 2800 won't be a PLT entry at all. */ 2801 if ((eh->funcdesc.refcount > 0 2802 || (h->got.offset != MINUS_ONE && eh->got_type == GOT_FUNCDESC)) 2803 && h->root.type != bfd_link_hash_undefweak 2804 && SYMBOL_FUNCDESC_LOCAL (info, h)) 2805 { 2806 /* Make room for this function descriptor. */ 2807 eh->funcdesc.offset = htab->sfuncdesc->size; 2808 htab->sfuncdesc->size += 8; 2809 2810 /* We will need a relocation or two fixups to initialize the 2811 function descriptor, so allocate those too. */ 2812 if (!bfd_link_pic (info) && SYMBOL_CALLS_LOCAL (info, h)) 2813 htab->srofixup->size += 8; 2814 else 2815 htab->srelfuncdesc->size += sizeof (Elf32_External_Rela); 2816 } 2817 2818 if (h->dyn_relocs == NULL) 2819 return true; 2820 2821 /* In the shared -Bsymbolic case, discard space allocated for 2822 dynamic pc-relative relocs against symbols which turn out to be 2823 defined in regular objects. For the normal shared case, discard 2824 space for pc-relative relocs that have become local due to symbol 2825 visibility changes. */ 2826 2827 if (bfd_link_pic (info)) 2828 { 2829 if (SYMBOL_CALLS_LOCAL (info, h)) 2830 { 2831 struct elf_dyn_relocs **pp; 2832 2833 for (pp = &h->dyn_relocs; (p = *pp) != NULL; ) 2834 { 2835 p->count -= p->pc_count; 2836 p->pc_count = 0; 2837 if (p->count == 0) 2838 *pp = p->next; 2839 else 2840 pp = &p->next; 2841 } 2842 } 2843 2844 if (htab->root.target_os == is_vxworks) 2845 { 2846 struct elf_dyn_relocs **pp; 2847 2848 for (pp = &h->dyn_relocs; (p = *pp) != NULL; ) 2849 { 2850 if (strcmp (p->sec->output_section->name, ".tls_vars") == 0) 2851 *pp = p->next; 2852 else 2853 pp = &p->next; 2854 } 2855 } 2856 2857 /* Also discard relocs on undefined weak syms with non-default 2858 visibility. */ 2859 if (h->dyn_relocs != NULL 2860 && h->root.type == bfd_link_hash_undefweak) 2861 { 2862 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT 2863 || UNDEFWEAK_NO_DYNAMIC_RELOC (info, h)) 2864 h->dyn_relocs = NULL; 2865 2866 /* Make sure undefined weak symbols are output as a dynamic 2867 symbol in PIEs. */ 2868 else if (h->dynindx == -1 2869 && !h->forced_local) 2870 { 2871 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 2872 return false; 2873 } 2874 } 2875 } 2876 else 2877 { 2878 /* For the non-shared case, discard space for relocs against 2879 symbols which turn out to need copy relocs or are not 2880 dynamic. */ 2881 2882 if (!h->non_got_ref 2883 && ((h->def_dynamic 2884 && !h->def_regular) 2885 || (htab->root.dynamic_sections_created 2886 && (h->root.type == bfd_link_hash_undefweak 2887 || h->root.type == bfd_link_hash_undefined)))) 2888 { 2889 /* Make sure this symbol is output as a dynamic symbol. 2890 Undefined weak syms won't yet be marked as dynamic. */ 2891 if (h->dynindx == -1 2892 && !h->forced_local) 2893 { 2894 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 2895 return false; 2896 } 2897 2898 /* If that succeeded, we know we'll be keeping all the 2899 relocs. */ 2900 if (h->dynindx != -1) 2901 goto keep; 2902 } 2903 2904 h->dyn_relocs = NULL; 2905 2906 keep: ; 2907 } 2908 2909 /* Finally, allocate space. */ 2910 for (p = h->dyn_relocs; p != NULL; p = p->next) 2911 { 2912 asection *sreloc = elf_section_data (p->sec)->sreloc; 2913 sreloc->size += p->count * sizeof (Elf32_External_Rela); 2914 2915 /* If we need relocations, we do not need fixups. */ 2916 if (htab->fdpic_p && !bfd_link_pic (info)) 2917 htab->srofixup->size -= 4 * (p->count - p->pc_count); 2918 } 2919 2920 return true; 2921 } 2922 2923 /* This function is called after all the input files have been read, 2924 and the input sections have been assigned to output sections. 2925 It's a convenient place to determine the PLT style. */ 2926 2927 static bool 2928 sh_elf_always_size_sections (bfd *output_bfd, struct bfd_link_info *info) 2929 { 2930 sh_elf_hash_table (info)->plt_info = get_plt_info (output_bfd, 2931 bfd_link_pic (info)); 2932 2933 if (sh_elf_hash_table (info)->fdpic_p && !bfd_link_relocatable (info) 2934 && !bfd_elf_stack_segment_size (output_bfd, info, 2935 "__stacksize", DEFAULT_STACK_SIZE)) 2936 return false; 2937 return true; 2938 } 2939 2940 /* Set the sizes of the dynamic sections. */ 2941 2942 static bool 2943 sh_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED, 2944 struct bfd_link_info *info) 2945 { 2946 struct elf_sh_link_hash_table *htab; 2947 bfd *dynobj; 2948 asection *s; 2949 bool relocs; 2950 bfd *ibfd; 2951 2952 htab = sh_elf_hash_table (info); 2953 if (htab == NULL) 2954 return false; 2955 2956 dynobj = htab->root.dynobj; 2957 BFD_ASSERT (dynobj != NULL); 2958 2959 if (htab->root.dynamic_sections_created) 2960 { 2961 /* Set the contents of the .interp section to the interpreter. */ 2962 if (bfd_link_executable (info) && !info->nointerp) 2963 { 2964 s = bfd_get_linker_section (dynobj, ".interp"); 2965 BFD_ASSERT (s != NULL); 2966 s->size = sizeof ELF_DYNAMIC_INTERPRETER; 2967 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER; 2968 } 2969 } 2970 2971 /* Set up .got offsets for local syms, and space for local dynamic 2972 relocs. */ 2973 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next) 2974 { 2975 bfd_signed_vma *local_got; 2976 bfd_signed_vma *end_local_got; 2977 union gotref *local_funcdesc, *end_local_funcdesc; 2978 char *local_got_type; 2979 bfd_size_type locsymcount; 2980 Elf_Internal_Shdr *symtab_hdr; 2981 asection *srel; 2982 2983 if (! is_sh_elf (ibfd)) 2984 continue; 2985 2986 for (s = ibfd->sections; s != NULL; s = s->next) 2987 { 2988 struct elf_dyn_relocs *p; 2989 2990 for (p = ((struct elf_dyn_relocs *) 2991 elf_section_data (s)->local_dynrel); 2992 p != NULL; 2993 p = p->next) 2994 { 2995 if (! bfd_is_abs_section (p->sec) 2996 && bfd_is_abs_section (p->sec->output_section)) 2997 { 2998 /* Input section has been discarded, either because 2999 it is a copy of a linkonce section or due to 3000 linker script /DISCARD/, so we'll be discarding 3001 the relocs too. */ 3002 } 3003 else if (htab->root.target_os == is_vxworks 3004 && strcmp (p->sec->output_section->name, 3005 ".tls_vars") == 0) 3006 { 3007 /* Relocations in vxworks .tls_vars sections are 3008 handled specially by the loader. */ 3009 } 3010 else if (p->count != 0) 3011 { 3012 srel = elf_section_data (p->sec)->sreloc; 3013 srel->size += p->count * sizeof (Elf32_External_Rela); 3014 if ((p->sec->output_section->flags & SEC_READONLY) != 0) 3015 { 3016 info->flags |= DF_TEXTREL; 3017 info->callbacks->minfo (_("%pB: dynamic relocation in read-only section `%pA'\n"), 3018 p->sec->owner, p->sec); 3019 } 3020 3021 /* If we need relocations, we do not need fixups. */ 3022 if (htab->fdpic_p && !bfd_link_pic (info)) 3023 htab->srofixup->size -= 4 * (p->count - p->pc_count); 3024 } 3025 } 3026 } 3027 3028 symtab_hdr = &elf_symtab_hdr (ibfd); 3029 locsymcount = symtab_hdr->sh_info; 3030 s = htab->root.sgot; 3031 srel = htab->root.srelgot; 3032 3033 local_got = elf_local_got_refcounts (ibfd); 3034 if (local_got) 3035 { 3036 end_local_got = local_got + locsymcount; 3037 local_got_type = sh_elf_local_got_type (ibfd); 3038 local_funcdesc = sh_elf_local_funcdesc (ibfd); 3039 for (; local_got < end_local_got; ++local_got) 3040 { 3041 if (*local_got > 0) 3042 { 3043 *local_got = s->size; 3044 s->size += 4; 3045 if (*local_got_type == GOT_TLS_GD) 3046 s->size += 4; 3047 if (bfd_link_pic (info)) 3048 srel->size += sizeof (Elf32_External_Rela); 3049 else 3050 htab->srofixup->size += 4; 3051 3052 if (*local_got_type == GOT_FUNCDESC) 3053 { 3054 if (local_funcdesc == NULL) 3055 { 3056 bfd_size_type size; 3057 3058 size = locsymcount * sizeof (union gotref); 3059 local_funcdesc = (union gotref *) bfd_zalloc (ibfd, 3060 size); 3061 if (local_funcdesc == NULL) 3062 return false; 3063 sh_elf_local_funcdesc (ibfd) = local_funcdesc; 3064 local_funcdesc += (local_got 3065 - elf_local_got_refcounts (ibfd)); 3066 } 3067 local_funcdesc->refcount++; 3068 ++local_funcdesc; 3069 } 3070 } 3071 else 3072 *local_got = (bfd_vma) -1; 3073 ++local_got_type; 3074 } 3075 } 3076 3077 local_funcdesc = sh_elf_local_funcdesc (ibfd); 3078 if (local_funcdesc) 3079 { 3080 end_local_funcdesc = local_funcdesc + locsymcount; 3081 3082 for (; local_funcdesc < end_local_funcdesc; ++local_funcdesc) 3083 { 3084 if (local_funcdesc->refcount > 0) 3085 { 3086 local_funcdesc->offset = htab->sfuncdesc->size; 3087 htab->sfuncdesc->size += 8; 3088 if (!bfd_link_pic (info)) 3089 htab->srofixup->size += 8; 3090 else 3091 htab->srelfuncdesc->size += sizeof (Elf32_External_Rela); 3092 } 3093 else 3094 local_funcdesc->offset = MINUS_ONE; 3095 } 3096 } 3097 3098 } 3099 3100 if (htab->tls_ldm_got.refcount > 0) 3101 { 3102 /* Allocate 2 got entries and 1 dynamic reloc for R_SH_TLS_LD_32 3103 relocs. */ 3104 htab->tls_ldm_got.offset = htab->root.sgot->size; 3105 htab->root.sgot->size += 8; 3106 htab->root.srelgot->size += sizeof (Elf32_External_Rela); 3107 } 3108 else 3109 htab->tls_ldm_got.offset = -1; 3110 3111 /* Only the reserved entries should be present. For FDPIC, they go at 3112 the end of .got.plt. */ 3113 if (htab->fdpic_p) 3114 { 3115 BFD_ASSERT (htab->root.sgotplt && htab->root.sgotplt->size == 12); 3116 htab->root.sgotplt->size = 0; 3117 } 3118 3119 /* Allocate global sym .plt and .got entries, and space for global 3120 sym dynamic relocs. */ 3121 elf_link_hash_traverse (&htab->root, allocate_dynrelocs, info); 3122 3123 /* Move the reserved entries and the _GLOBAL_OFFSET_TABLE_ symbol to the 3124 end of the FDPIC .got.plt. */ 3125 if (htab->fdpic_p) 3126 { 3127 htab->root.hgot->root.u.def.value = htab->root.sgotplt->size; 3128 htab->root.sgotplt->size += 12; 3129 } 3130 3131 /* At the very end of the .rofixup section is a pointer to the GOT. */ 3132 if (htab->fdpic_p && htab->srofixup != NULL) 3133 htab->srofixup->size += 4; 3134 3135 /* We now have determined the sizes of the various dynamic sections. 3136 Allocate memory for them. */ 3137 relocs = false; 3138 for (s = dynobj->sections; s != NULL; s = s->next) 3139 { 3140 if ((s->flags & SEC_LINKER_CREATED) == 0) 3141 continue; 3142 3143 if (s == htab->root.splt 3144 || s == htab->root.sgot 3145 || s == htab->root.sgotplt 3146 || s == htab->sfuncdesc 3147 || s == htab->srofixup 3148 || s == htab->root.sdynbss) 3149 { 3150 /* Strip this section if we don't need it; see the 3151 comment below. */ 3152 } 3153 else if (startswith (bfd_section_name (s), ".rela")) 3154 { 3155 if (s->size != 0 && s != htab->root.srelplt && s != htab->srelplt2) 3156 relocs = true; 3157 3158 /* We use the reloc_count field as a counter if we need 3159 to copy relocs into the output file. */ 3160 s->reloc_count = 0; 3161 } 3162 else 3163 { 3164 /* It's not one of our sections, so don't allocate space. */ 3165 continue; 3166 } 3167 3168 if (s->size == 0) 3169 { 3170 /* If we don't need this section, strip it from the 3171 output file. This is mostly to handle .rela.bss and 3172 .rela.plt. We must create both sections in 3173 create_dynamic_sections, because they must be created 3174 before the linker maps input sections to output 3175 sections. The linker does that before 3176 adjust_dynamic_symbol is called, and it is that 3177 function which decides whether anything needs to go 3178 into these sections. */ 3179 3180 s->flags |= SEC_EXCLUDE; 3181 continue; 3182 } 3183 3184 if ((s->flags & SEC_HAS_CONTENTS) == 0) 3185 continue; 3186 3187 /* Allocate memory for the section contents. We use bfd_zalloc 3188 here in case unused entries are not reclaimed before the 3189 section's contents are written out. This should not happen, 3190 but this way if it does, we get a R_SH_NONE reloc instead 3191 of garbage. */ 3192 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size); 3193 if (s->contents == NULL) 3194 return false; 3195 } 3196 3197 return _bfd_elf_maybe_vxworks_add_dynamic_tags (output_bfd, info, 3198 relocs); 3199 } 3200 3201 /* Add a dynamic relocation to the SRELOC section. */ 3202 3203 inline static bfd_vma 3204 sh_elf_add_dyn_reloc (bfd *output_bfd, asection *sreloc, bfd_vma offset, 3205 int reloc_type, long dynindx, bfd_vma addend) 3206 { 3207 Elf_Internal_Rela outrel; 3208 bfd_vma reloc_offset; 3209 3210 outrel.r_offset = offset; 3211 outrel.r_info = ELF32_R_INFO (dynindx, reloc_type); 3212 outrel.r_addend = addend; 3213 3214 reloc_offset = sreloc->reloc_count * sizeof (Elf32_External_Rela); 3215 BFD_ASSERT (reloc_offset < sreloc->size); 3216 bfd_elf32_swap_reloca_out (output_bfd, &outrel, 3217 sreloc->contents + reloc_offset); 3218 sreloc->reloc_count++; 3219 3220 return reloc_offset; 3221 } 3222 3223 /* Add an FDPIC read-only fixup. */ 3224 3225 inline static void 3226 sh_elf_add_rofixup (bfd *output_bfd, asection *srofixup, bfd_vma offset) 3227 { 3228 bfd_vma fixup_offset; 3229 3230 fixup_offset = srofixup->reloc_count++ * 4; 3231 BFD_ASSERT (fixup_offset < srofixup->size); 3232 bfd_put_32 (output_bfd, offset, srofixup->contents + fixup_offset); 3233 } 3234 3235 /* Return the offset of the generated .got section from the 3236 _GLOBAL_OFFSET_TABLE_ symbol. */ 3237 3238 static bfd_signed_vma 3239 sh_elf_got_offset (struct elf_sh_link_hash_table *htab) 3240 { 3241 return (htab->root.sgot->output_offset - htab->root.sgotplt->output_offset 3242 - htab->root.hgot->root.u.def.value); 3243 } 3244 3245 /* Find the segment number in which OSEC, and output section, is 3246 located. */ 3247 3248 static unsigned 3249 sh_elf_osec_to_segment (bfd *output_bfd, asection *osec) 3250 { 3251 Elf_Internal_Phdr *p = NULL; 3252 3253 if (output_bfd->xvec->flavour == bfd_target_elf_flavour 3254 /* PR ld/17110: Do not look for output segments in an input bfd. */ 3255 && output_bfd->direction != read_direction) 3256 p = _bfd_elf_find_segment_containing_section (output_bfd, osec); 3257 3258 /* FIXME: Nothing ever says what this index is relative to. The kernel 3259 supplies data in terms of the number of load segments but this is 3260 a phdr index and the first phdr may not be a load segment. */ 3261 return (p != NULL) ? p - elf_tdata (output_bfd)->phdr : -1; 3262 } 3263 3264 static bool 3265 sh_elf_osec_readonly_p (bfd *output_bfd, asection *osec) 3266 { 3267 unsigned seg = sh_elf_osec_to_segment (output_bfd, osec); 3268 3269 return (seg != (unsigned) -1 3270 && ! (elf_tdata (output_bfd)->phdr[seg].p_flags & PF_W)); 3271 } 3272 3273 /* Generate the initial contents of a local function descriptor, along 3274 with any relocations or fixups required. */ 3275 static bool 3276 sh_elf_initialize_funcdesc (bfd *output_bfd, 3277 struct bfd_link_info *info, 3278 struct elf_link_hash_entry *h, 3279 bfd_vma offset, 3280 asection *section, 3281 bfd_vma value) 3282 { 3283 struct elf_sh_link_hash_table *htab; 3284 int dynindx; 3285 bfd_vma addr, seg; 3286 3287 htab = sh_elf_hash_table (info); 3288 3289 /* FIXME: The ABI says that the offset to the function goes in the 3290 descriptor, along with the segment index. We're RELA, so it could 3291 go in the reloc instead... */ 3292 3293 if (h != NULL && SYMBOL_CALLS_LOCAL (info, h)) 3294 { 3295 section = h->root.u.def.section; 3296 value = h->root.u.def.value; 3297 } 3298 3299 if (h == NULL || SYMBOL_CALLS_LOCAL (info, h)) 3300 { 3301 dynindx = elf_section_data (section->output_section)->dynindx; 3302 addr = value + section->output_offset; 3303 seg = sh_elf_osec_to_segment (output_bfd, section->output_section); 3304 } 3305 else 3306 { 3307 BFD_ASSERT (h->dynindx != -1); 3308 dynindx = h->dynindx; 3309 addr = seg = 0; 3310 } 3311 3312 if (!bfd_link_pic (info) && SYMBOL_CALLS_LOCAL (info, h)) 3313 { 3314 if (h == NULL || h->root.type != bfd_link_hash_undefweak) 3315 { 3316 sh_elf_add_rofixup (output_bfd, htab->srofixup, 3317 offset 3318 + htab->sfuncdesc->output_section->vma 3319 + htab->sfuncdesc->output_offset); 3320 sh_elf_add_rofixup (output_bfd, htab->srofixup, 3321 offset + 4 3322 + htab->sfuncdesc->output_section->vma 3323 + htab->sfuncdesc->output_offset); 3324 } 3325 3326 /* There are no dynamic relocations so fill in the final 3327 address and gp value (barring fixups). */ 3328 addr += section->output_section->vma; 3329 seg = htab->root.hgot->root.u.def.value 3330 + htab->root.hgot->root.u.def.section->output_section->vma 3331 + htab->root.hgot->root.u.def.section->output_offset; 3332 } 3333 else 3334 sh_elf_add_dyn_reloc (output_bfd, htab->srelfuncdesc, 3335 offset 3336 + htab->sfuncdesc->output_section->vma 3337 + htab->sfuncdesc->output_offset, 3338 R_SH_FUNCDESC_VALUE, dynindx, 0); 3339 3340 bfd_put_32 (output_bfd, addr, htab->sfuncdesc->contents + offset); 3341 bfd_put_32 (output_bfd, seg, htab->sfuncdesc->contents + offset + 4); 3342 3343 return true; 3344 } 3345 3346 /* Install a 20-bit movi20 field starting at ADDR, which occurs in OUTPUT_BFD. 3347 VALUE is the field's value. Return bfd_reloc_ok if successful or an error 3348 otherwise. */ 3349 3350 static bfd_reloc_status_type 3351 install_movi20_field (bfd *output_bfd, unsigned long relocation, 3352 bfd *input_bfd, asection *input_section, 3353 bfd_byte *contents, bfd_vma offset) 3354 { 3355 unsigned long cur_val; 3356 bfd_byte *addr; 3357 bfd_reloc_status_type r; 3358 3359 if (offset > bfd_get_section_limit (input_bfd, input_section)) 3360 return bfd_reloc_outofrange; 3361 3362 r = bfd_check_overflow (complain_overflow_signed, 20, 0, 3363 bfd_arch_bits_per_address (input_bfd), relocation); 3364 if (r != bfd_reloc_ok) 3365 return r; 3366 3367 addr = contents + offset; 3368 cur_val = bfd_get_16 (output_bfd, addr); 3369 bfd_put_16 (output_bfd, cur_val | ((relocation & 0xf0000) >> 12), addr); 3370 bfd_put_16 (output_bfd, relocation & 0xffff, addr + 2); 3371 3372 return bfd_reloc_ok; 3373 } 3374 3375 /* Relocate an SH ELF section. */ 3376 3377 static int 3378 sh_elf_relocate_section (bfd *output_bfd, struct bfd_link_info *info, 3379 bfd *input_bfd, asection *input_section, 3380 bfd_byte *contents, Elf_Internal_Rela *relocs, 3381 Elf_Internal_Sym *local_syms, 3382 asection **local_sections) 3383 { 3384 struct elf_sh_link_hash_table *htab; 3385 Elf_Internal_Shdr *symtab_hdr; 3386 struct elf_link_hash_entry **sym_hashes; 3387 Elf_Internal_Rela *rel, *relend; 3388 bfd_vma *local_got_offsets; 3389 asection *sgot = NULL; 3390 asection *sgotplt = NULL; 3391 asection *splt = NULL; 3392 asection *sreloc = NULL; 3393 asection *srelgot = NULL; 3394 bool is_vxworks_tls; 3395 unsigned isec_segment, got_segment, plt_segment, check_segment[2]; 3396 bool fdpic_p = false; 3397 3398 if (!is_sh_elf (input_bfd)) 3399 { 3400 bfd_set_error (bfd_error_wrong_format); 3401 return false; 3402 } 3403 3404 htab = sh_elf_hash_table (info); 3405 if (htab != NULL) 3406 { 3407 sgot = htab->root.sgot; 3408 sgotplt = htab->root.sgotplt; 3409 srelgot = htab->root.srelgot; 3410 splt = htab->root.splt; 3411 fdpic_p = htab->fdpic_p; 3412 } 3413 symtab_hdr = &elf_symtab_hdr (input_bfd); 3414 sym_hashes = elf_sym_hashes (input_bfd); 3415 local_got_offsets = elf_local_got_offsets (input_bfd); 3416 3417 isec_segment = sh_elf_osec_to_segment (output_bfd, 3418 input_section->output_section); 3419 if (fdpic_p && sgot) 3420 got_segment = sh_elf_osec_to_segment (output_bfd, 3421 sgot->output_section); 3422 else 3423 got_segment = -1; 3424 if (fdpic_p && splt) 3425 plt_segment = sh_elf_osec_to_segment (output_bfd, 3426 splt->output_section); 3427 else 3428 plt_segment = -1; 3429 3430 /* We have to handle relocations in vxworks .tls_vars sections 3431 specially, because the dynamic loader is 'weird'. */ 3432 is_vxworks_tls = (htab && htab->root.target_os == is_vxworks && bfd_link_pic (info) 3433 && !strcmp (input_section->output_section->name, 3434 ".tls_vars")); 3435 3436 rel = relocs; 3437 relend = relocs + input_section->reloc_count; 3438 for (; rel < relend; rel++) 3439 { 3440 int r_type; 3441 reloc_howto_type *howto; 3442 unsigned long r_symndx; 3443 Elf_Internal_Sym *sym; 3444 asection *sec; 3445 struct elf_link_hash_entry *h; 3446 bfd_vma relocation; 3447 bfd_vma addend = (bfd_vma) 0; 3448 bfd_reloc_status_type r; 3449 bfd_vma off; 3450 enum got_type got_type; 3451 const char *symname = NULL; 3452 bool resolved_to_zero; 3453 3454 r_symndx = ELF32_R_SYM (rel->r_info); 3455 3456 r_type = ELF32_R_TYPE (rel->r_info); 3457 3458 /* Many of the relocs are only used for relaxing, and are 3459 handled entirely by the relaxation code. */ 3460 if (r_type >= (int) R_SH_GNU_VTINHERIT 3461 && r_type <= (int) R_SH_LABEL) 3462 continue; 3463 if (r_type == (int) R_SH_NONE) 3464 continue; 3465 3466 if (r_type < 0 3467 || r_type >= R_SH_max 3468 || (r_type >= (int) R_SH_FIRST_INVALID_RELOC 3469 && r_type <= (int) R_SH_LAST_INVALID_RELOC) 3470 || (r_type >= (int) R_SH_FIRST_INVALID_RELOC_2 3471 && r_type <= (int) R_SH_LAST_INVALID_RELOC_2) 3472 || ( r_type >= (int) R_SH_FIRST_INVALID_RELOC_3 3473 && r_type <= (int) R_SH_LAST_INVALID_RELOC_3) 3474 || ( r_type >= (int) R_SH_FIRST_INVALID_RELOC_4 3475 && r_type <= (int) R_SH_LAST_INVALID_RELOC_4) 3476 || ( r_type >= (int) R_SH_FIRST_INVALID_RELOC_5 3477 && r_type <= (int) R_SH_LAST_INVALID_RELOC_5) 3478 || ( r_type >= (int) R_SH_FIRST_INVALID_RELOC_6 3479 && r_type <= (int) R_SH_LAST_INVALID_RELOC_6)) 3480 { 3481 bfd_set_error (bfd_error_bad_value); 3482 return false; 3483 } 3484 3485 howto = get_howto_table (output_bfd) + r_type; 3486 3487 /* For relocs that aren't partial_inplace, we get the addend from 3488 the relocation. */ 3489 if (! howto->partial_inplace) 3490 addend = rel->r_addend; 3491 3492 resolved_to_zero = false; 3493 h = NULL; 3494 sym = NULL; 3495 sec = NULL; 3496 check_segment[0] = -1; 3497 check_segment[1] = -1; 3498 if (r_symndx < symtab_hdr->sh_info) 3499 { 3500 sym = local_syms + r_symndx; 3501 sec = local_sections[r_symndx]; 3502 3503 symname = bfd_elf_string_from_elf_section 3504 (input_bfd, symtab_hdr->sh_link, sym->st_name); 3505 if (symname == NULL || *symname == '\0') 3506 symname = bfd_section_name (sec); 3507 3508 relocation = (sec->output_section->vma 3509 + sec->output_offset 3510 + sym->st_value); 3511 3512 if (sec != NULL && discarded_section (sec)) 3513 /* Handled below. */ 3514 ; 3515 else if (bfd_link_relocatable (info)) 3516 { 3517 /* This is a relocatable link. We don't have to change 3518 anything, unless the reloc is against a section symbol, 3519 in which case we have to adjust according to where the 3520 section symbol winds up in the output section. */ 3521 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION) 3522 { 3523 if (! howto->partial_inplace) 3524 { 3525 /* For relocations with the addend in the 3526 relocation, we need just to update the addend. 3527 All real relocs are of type partial_inplace; this 3528 code is mostly for completeness. */ 3529 rel->r_addend += sec->output_offset; 3530 3531 continue; 3532 } 3533 3534 /* Relocs of type partial_inplace need to pick up the 3535 contents in the contents and add the offset resulting 3536 from the changed location of the section symbol. 3537 Using _bfd_final_link_relocate (e.g. goto 3538 final_link_relocate) here would be wrong, because 3539 relocations marked pc_relative would get the current 3540 location subtracted, and we must only do that at the 3541 final link. */ 3542 r = _bfd_relocate_contents (howto, input_bfd, 3543 sec->output_offset 3544 + sym->st_value, 3545 contents + rel->r_offset); 3546 goto relocation_done; 3547 } 3548 3549 continue; 3550 } 3551 else if (! howto->partial_inplace) 3552 { 3553 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel); 3554 addend = rel->r_addend; 3555 } 3556 else if ((sec->flags & SEC_MERGE) 3557 && ELF_ST_TYPE (sym->st_info) == STT_SECTION) 3558 { 3559 asection *msec; 3560 3561 if (howto->rightshift || howto->src_mask != 0xffffffff) 3562 { 3563 _bfd_error_handler 3564 /* xgettext:c-format */ 3565 (_("%pB(%pA+%#" PRIx64 "): " 3566 "%s relocation against SEC_MERGE section"), 3567 input_bfd, input_section, 3568 (uint64_t) rel->r_offset, howto->name); 3569 return false; 3570 } 3571 3572 addend = bfd_get_32 (input_bfd, contents + rel->r_offset); 3573 msec = sec; 3574 addend = 3575 _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend) 3576 - relocation; 3577 addend += msec->output_section->vma + msec->output_offset; 3578 bfd_put_32 (input_bfd, addend, contents + rel->r_offset); 3579 addend = 0; 3580 } 3581 } 3582 else 3583 { 3584 /* FIXME: Ought to make use of the RELOC_FOR_GLOBAL_SYMBOL macro. */ 3585 3586 relocation = 0; 3587 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 3588 symname = h->root.root.string; 3589 while (h->root.type == bfd_link_hash_indirect 3590 || h->root.type == bfd_link_hash_warning) 3591 h = (struct elf_link_hash_entry *) h->root.u.i.link; 3592 if (h->root.type == bfd_link_hash_defined 3593 || h->root.type == bfd_link_hash_defweak) 3594 { 3595 bool dyn; 3596 3597 dyn = htab ? htab->root.dynamic_sections_created : false; 3598 sec = h->root.u.def.section; 3599 /* In these cases, we don't need the relocation value. 3600 We check specially because in some obscure cases 3601 sec->output_section will be NULL. */ 3602 if (r_type == R_SH_GOTPC 3603 || r_type == R_SH_GOTPC_LOW16 3604 || r_type == R_SH_GOTPC_MEDLOW16 3605 || r_type == R_SH_GOTPC_MEDHI16 3606 || r_type == R_SH_GOTPC_HI16 3607 || ((r_type == R_SH_PLT32 3608 || r_type == R_SH_PLT_LOW16 3609 || r_type == R_SH_PLT_MEDLOW16 3610 || r_type == R_SH_PLT_MEDHI16 3611 || r_type == R_SH_PLT_HI16) 3612 && h->plt.offset != (bfd_vma) -1) 3613 || ((r_type == R_SH_GOT32 3614 || r_type == R_SH_GOT20 3615 || r_type == R_SH_GOTFUNCDESC 3616 || r_type == R_SH_GOTFUNCDESC20 3617 || r_type == R_SH_GOTOFFFUNCDESC 3618 || r_type == R_SH_GOTOFFFUNCDESC20 3619 || r_type == R_SH_FUNCDESC 3620 || r_type == R_SH_GOT_LOW16 3621 || r_type == R_SH_GOT_MEDLOW16 3622 || r_type == R_SH_GOT_MEDHI16 3623 || r_type == R_SH_GOT_HI16) 3624 && WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 3625 bfd_link_pic (info), 3626 h) 3627 && (! bfd_link_pic (info) 3628 || (! info->symbolic && h->dynindx != -1) 3629 || !h->def_regular)) 3630 /* The cases above are those in which relocation is 3631 overwritten in the switch block below. The cases 3632 below are those in which we must defer relocation 3633 to run-time, because we can't resolve absolute 3634 addresses when creating a shared library. */ 3635 || (bfd_link_pic (info) 3636 && ((! info->symbolic && h->dynindx != -1) 3637 || !h->def_regular) 3638 && ((r_type == R_SH_DIR32 3639 && !h->forced_local) 3640 || (r_type == R_SH_REL32 3641 && !SYMBOL_CALLS_LOCAL (info, h))) 3642 && ((input_section->flags & SEC_ALLOC) != 0 3643 /* DWARF will emit R_SH_DIR32 relocations in its 3644 sections against symbols defined externally 3645 in shared libraries. We can't do anything 3646 with them here. */ 3647 || ((input_section->flags & SEC_DEBUGGING) != 0 3648 && h->def_dynamic))) 3649 /* Dynamic relocs are not propagated for SEC_DEBUGGING 3650 sections because such sections are not SEC_ALLOC and 3651 thus ld.so will not process them. */ 3652 || (sec->output_section == NULL 3653 && ((input_section->flags & SEC_DEBUGGING) != 0 3654 && h->def_dynamic)) 3655 || (sec->output_section == NULL 3656 && (sh_elf_hash_entry (h)->got_type == GOT_TLS_IE 3657 || sh_elf_hash_entry (h)->got_type == GOT_TLS_GD))) 3658 ; 3659 else if (sec->output_section != NULL) 3660 relocation = (h->root.u.def.value 3661 + sec->output_section->vma 3662 + sec->output_offset); 3663 else if (!bfd_link_relocatable (info) 3664 && (_bfd_elf_section_offset (output_bfd, info, 3665 input_section, 3666 rel->r_offset) 3667 != (bfd_vma) -1)) 3668 { 3669 _bfd_error_handler 3670 /* xgettext:c-format */ 3671 (_("%pB(%pA+%#" PRIx64 "): " 3672 "unresolvable %s relocation against symbol `%s'"), 3673 input_bfd, 3674 input_section, 3675 (uint64_t) rel->r_offset, 3676 howto->name, 3677 h->root.root.string); 3678 return false; 3679 } 3680 } 3681 else if (h->root.type == bfd_link_hash_undefweak) 3682 resolved_to_zero = UNDEFWEAK_NO_DYNAMIC_RELOC (info, h); 3683 else if (info->unresolved_syms_in_objects == RM_IGNORE 3684 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT) 3685 ; 3686 else if (!bfd_link_relocatable (info)) 3687 info->callbacks->undefined_symbol 3688 (info, h->root.root.string, input_bfd, input_section, 3689 rel->r_offset, 3690 (info->unresolved_syms_in_objects == RM_DIAGNOSE 3691 && !info->warn_unresolved_syms) 3692 || ELF_ST_VISIBILITY (h->other)); 3693 } 3694 3695 if (sec != NULL && discarded_section (sec)) 3696 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section, 3697 rel, 1, relend, howto, 0, contents); 3698 3699 if (bfd_link_relocatable (info)) 3700 continue; 3701 3702 /* Check for inter-segment relocations in FDPIC files. Most 3703 relocations connect the relocation site to the location of 3704 the target symbol, but there are some exceptions below. */ 3705 check_segment[0] = isec_segment; 3706 if (sec != NULL) 3707 check_segment[1] = sh_elf_osec_to_segment (output_bfd, 3708 sec->output_section); 3709 else 3710 check_segment[1] = -1; 3711 3712 switch ((int) r_type) 3713 { 3714 final_link_relocate: 3715 /* COFF relocs don't use the addend. The addend is used for 3716 R_SH_DIR32 to be compatible with other compilers. */ 3717 r = _bfd_final_link_relocate (howto, input_bfd, input_section, 3718 contents, rel->r_offset, 3719 relocation, addend); 3720 break; 3721 3722 case R_SH_IND12W: 3723 goto final_link_relocate; 3724 3725 case R_SH_DIR8WPN: 3726 case R_SH_DIR8WPZ: 3727 case R_SH_DIR8WPL: 3728 /* If the reloc is against the start of this section, then 3729 the assembler has already taken care of it and the reloc 3730 is here only to assist in relaxing. If the reloc is not 3731 against the start of this section, then it's against an 3732 external symbol and we must deal with it ourselves. */ 3733 if (input_section->output_section->vma + input_section->output_offset 3734 != relocation) 3735 { 3736 int disp = (relocation 3737 - input_section->output_section->vma 3738 - input_section->output_offset 3739 - rel->r_offset); 3740 int mask = 0; 3741 switch (r_type) 3742 { 3743 case R_SH_DIR8WPN: 3744 case R_SH_DIR8WPZ: mask = 1; break; 3745 case R_SH_DIR8WPL: mask = 3; break; 3746 default: mask = 0; break; 3747 } 3748 if (disp & mask) 3749 { 3750 _bfd_error_handler 3751 /* xgettext:c-format */ 3752 (_("%pB: %#" PRIx64 ": fatal: " 3753 "unaligned branch target for relax-support relocation"), 3754 input_section->owner, 3755 (uint64_t) rel->r_offset); 3756 bfd_set_error (bfd_error_bad_value); 3757 return false; 3758 } 3759 relocation -= 4; 3760 goto final_link_relocate; 3761 } 3762 r = bfd_reloc_ok; 3763 break; 3764 3765 default: 3766 bfd_set_error (bfd_error_bad_value); 3767 return false; 3768 3769 case R_SH_DIR16: 3770 case R_SH_DIR8: 3771 case R_SH_DIR8U: 3772 case R_SH_DIR8S: 3773 case R_SH_DIR4U: 3774 goto final_link_relocate; 3775 3776 case R_SH_DIR8UL: 3777 case R_SH_DIR4UL: 3778 if (relocation & 3) 3779 { 3780 _bfd_error_handler 3781 /* xgettext:c-format */ 3782 (_("%pB: %#" PRIx64 ": fatal: " 3783 "unaligned %s relocation %#" PRIx64), 3784 input_section->owner, (uint64_t) rel->r_offset, 3785 howto->name, (uint64_t) relocation); 3786 bfd_set_error (bfd_error_bad_value); 3787 return false; 3788 } 3789 goto final_link_relocate; 3790 3791 case R_SH_DIR8UW: 3792 case R_SH_DIR8SW: 3793 case R_SH_DIR4UW: 3794 if (relocation & 1) 3795 { 3796 _bfd_error_handler 3797 /* xgettext:c-format */ 3798 (_("%pB: %#" PRIx64 ": fatal: " 3799 "unaligned %s relocation %#" PRIx64 ""), 3800 input_section->owner, 3801 (uint64_t) rel->r_offset, howto->name, 3802 (uint64_t) relocation); 3803 bfd_set_error (bfd_error_bad_value); 3804 return false; 3805 } 3806 goto final_link_relocate; 3807 3808 case R_SH_PSHA: 3809 if ((signed int)relocation < -32 3810 || (signed int)relocation > 32) 3811 { 3812 _bfd_error_handler 3813 /* xgettext:c-format */ 3814 (_("%pB: %#" PRIx64 ": fatal: R_SH_PSHA relocation %" PRId64 3815 " not in range -32..32"), 3816 input_section->owner, 3817 (uint64_t) rel->r_offset, 3818 (int64_t) relocation); 3819 bfd_set_error (bfd_error_bad_value); 3820 return false; 3821 } 3822 goto final_link_relocate; 3823 3824 case R_SH_PSHL: 3825 if ((signed int)relocation < -16 3826 || (signed int)relocation > 16) 3827 { 3828 _bfd_error_handler 3829 /* xgettext:c-format */ 3830 (_("%pB: %#" PRIx64 ": fatal: R_SH_PSHL relocation %" PRId64 3831 " not in range -32..32"), 3832 input_section->owner, 3833 (uint64_t) rel->r_offset, 3834 (int64_t) relocation); 3835 bfd_set_error (bfd_error_bad_value); 3836 return false; 3837 } 3838 goto final_link_relocate; 3839 3840 case R_SH_DIR32: 3841 case R_SH_REL32: 3842 if (bfd_link_pic (info) 3843 && (h == NULL 3844 || (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT 3845 && !resolved_to_zero) 3846 || h->root.type != bfd_link_hash_undefweak) 3847 && r_symndx != STN_UNDEF 3848 && (input_section->flags & SEC_ALLOC) != 0 3849 && !is_vxworks_tls 3850 && (r_type == R_SH_DIR32 3851 || !SYMBOL_CALLS_LOCAL (info, h))) 3852 { 3853 Elf_Internal_Rela outrel; 3854 bfd_byte *loc; 3855 bool skip, relocate; 3856 3857 /* When generating a shared object, these relocations 3858 are copied into the output file to be resolved at run 3859 time. */ 3860 3861 if (sreloc == NULL) 3862 { 3863 sreloc = _bfd_elf_get_dynamic_reloc_section 3864 (input_bfd, input_section, /*rela?*/ true); 3865 if (sreloc == NULL) 3866 return false; 3867 } 3868 3869 skip = false; 3870 relocate = false; 3871 3872 outrel.r_offset = 3873 _bfd_elf_section_offset (output_bfd, info, input_section, 3874 rel->r_offset); 3875 if (outrel.r_offset == (bfd_vma) -1) 3876 skip = true; 3877 else if (outrel.r_offset == (bfd_vma) -2) 3878 skip = true, relocate = true; 3879 outrel.r_offset += (input_section->output_section->vma 3880 + input_section->output_offset); 3881 3882 if (skip) 3883 memset (&outrel, 0, sizeof outrel); 3884 else if (r_type == R_SH_REL32) 3885 { 3886 BFD_ASSERT (h != NULL && h->dynindx != -1); 3887 outrel.r_info = ELF32_R_INFO (h->dynindx, R_SH_REL32); 3888 outrel.r_addend 3889 = (howto->partial_inplace 3890 ? bfd_get_32 (input_bfd, contents + rel->r_offset) 3891 : addend); 3892 } 3893 else if (fdpic_p 3894 && (h == NULL 3895 || ((info->symbolic || h->dynindx == -1) 3896 && h->def_regular))) 3897 { 3898 int dynindx; 3899 3900 BFD_ASSERT (sec != NULL); 3901 BFD_ASSERT (sec->output_section != NULL); 3902 dynindx = elf_section_data (sec->output_section)->dynindx; 3903 outrel.r_info = ELF32_R_INFO (dynindx, R_SH_DIR32); 3904 outrel.r_addend = relocation; 3905 outrel.r_addend 3906 += (howto->partial_inplace 3907 ? bfd_get_32 (input_bfd, contents + rel->r_offset) 3908 : addend); 3909 outrel.r_addend -= sec->output_section->vma; 3910 } 3911 else 3912 { 3913 /* h->dynindx may be -1 if this symbol was marked to 3914 become local. */ 3915 if (h == NULL 3916 || ((info->symbolic || h->dynindx == -1) 3917 && h->def_regular)) 3918 { 3919 relocate = howto->partial_inplace; 3920 outrel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE); 3921 } 3922 else 3923 { 3924 BFD_ASSERT (h->dynindx != -1); 3925 outrel.r_info = ELF32_R_INFO (h->dynindx, R_SH_DIR32); 3926 } 3927 outrel.r_addend = relocation; 3928 outrel.r_addend 3929 += (howto->partial_inplace 3930 ? bfd_get_32 (input_bfd, contents + rel->r_offset) 3931 : addend); 3932 } 3933 3934 loc = sreloc->contents; 3935 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela); 3936 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc); 3937 3938 check_segment[0] = check_segment[1] = -1; 3939 3940 /* If this reloc is against an external symbol, we do 3941 not want to fiddle with the addend. Otherwise, we 3942 need to include the symbol value so that it becomes 3943 an addend for the dynamic reloc. */ 3944 if (! relocate) 3945 continue; 3946 } 3947 else if (fdpic_p && !bfd_link_pic (info) 3948 && r_type == R_SH_DIR32 3949 && (input_section->flags & SEC_ALLOC) != 0) 3950 { 3951 bfd_vma offset; 3952 3953 BFD_ASSERT (htab); 3954 3955 if (sh_elf_osec_readonly_p (output_bfd, 3956 input_section->output_section)) 3957 { 3958 _bfd_error_handler 3959 /* xgettext:c-format */ 3960 (_("%pB(%pA+%#" PRIx64 "): " 3961 "cannot emit fixup to `%s' in read-only section"), 3962 input_bfd, 3963 input_section, 3964 (uint64_t) rel->r_offset, 3965 symname); 3966 return false; 3967 } 3968 3969 offset = _bfd_elf_section_offset (output_bfd, info, 3970 input_section, rel->r_offset); 3971 if (offset != (bfd_vma)-1) 3972 sh_elf_add_rofixup (output_bfd, htab->srofixup, 3973 input_section->output_section->vma 3974 + input_section->output_offset 3975 + rel->r_offset); 3976 3977 check_segment[0] = check_segment[1] = -1; 3978 } 3979 /* We don't want warnings for non-NULL tests on undefined weak 3980 symbols. */ 3981 else if (r_type == R_SH_REL32 3982 && h 3983 && h->root.type == bfd_link_hash_undefweak) 3984 check_segment[0] = check_segment[1] = -1; 3985 goto final_link_relocate; 3986 3987 case R_SH_GOTPLT32: 3988 /* Relocation is to the entry for this symbol in the 3989 procedure linkage table. */ 3990 3991 if (h == NULL 3992 || h->forced_local 3993 || ! bfd_link_pic (info) 3994 || info->symbolic 3995 || h->dynindx == -1 3996 || h->plt.offset == (bfd_vma) -1 3997 || h->got.offset != (bfd_vma) -1) 3998 goto force_got; 3999 4000 /* Relocation is to the entry for this symbol in the global 4001 offset table extension for the procedure linkage table. */ 4002 4003 BFD_ASSERT (htab); 4004 BFD_ASSERT (sgotplt != NULL); 4005 relocation = (sgotplt->output_offset 4006 + (get_plt_index (htab->plt_info, h->plt.offset) 4007 + 3) * 4); 4008 4009 #ifdef GOT_BIAS 4010 relocation -= GOT_BIAS; 4011 #endif 4012 4013 goto final_link_relocate; 4014 4015 force_got: 4016 case R_SH_GOT32: 4017 case R_SH_GOT20: 4018 /* Relocation is to the entry for this symbol in the global 4019 offset table. */ 4020 4021 BFD_ASSERT (htab); 4022 BFD_ASSERT (sgot != NULL); 4023 check_segment[0] = check_segment[1] = -1; 4024 4025 if (h != NULL) 4026 { 4027 bool dyn; 4028 4029 off = h->got.offset; 4030 BFD_ASSERT (off != (bfd_vma) -1); 4031 4032 dyn = htab->root.dynamic_sections_created; 4033 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 4034 bfd_link_pic (info), 4035 h) 4036 || (bfd_link_pic (info) 4037 && SYMBOL_REFERENCES_LOCAL (info, h)) 4038 || ((ELF_ST_VISIBILITY (h->other) 4039 || resolved_to_zero) 4040 && h->root.type == bfd_link_hash_undefweak)) 4041 { 4042 /* This is actually a static link, or it is a 4043 -Bsymbolic link and the symbol is defined 4044 locally, or the symbol was forced to be local 4045 because of a version file. We must initialize 4046 this entry in the global offset table. Since the 4047 offset must always be a multiple of 4, we use the 4048 least significant bit to record whether we have 4049 initialized it already. 4050 4051 When doing a dynamic link, we create a .rela.got 4052 relocation entry to initialize the value. This 4053 is done in the finish_dynamic_symbol routine. */ 4054 if ((off & 1) != 0) 4055 off &= ~1; 4056 else 4057 { 4058 bfd_put_32 (output_bfd, relocation, 4059 sgot->contents + off); 4060 h->got.offset |= 1; 4061 4062 /* If we initialize the GOT entry here with a valid 4063 symbol address, also add a fixup. */ 4064 if (fdpic_p && !bfd_link_pic (info) 4065 && sh_elf_hash_entry (h)->got_type == GOT_NORMAL 4066 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT 4067 || h->root.type != bfd_link_hash_undefweak)) 4068 sh_elf_add_rofixup (output_bfd, htab->srofixup, 4069 sgot->output_section->vma 4070 + sgot->output_offset 4071 + off); 4072 } 4073 } 4074 4075 relocation = sh_elf_got_offset (htab) + off; 4076 } 4077 else 4078 { 4079 BFD_ASSERT (local_got_offsets != NULL 4080 && local_got_offsets[r_symndx] != (bfd_vma) -1); 4081 4082 off = local_got_offsets[r_symndx]; 4083 4084 /* The offset must always be a multiple of 4. We use 4085 the least significant bit to record whether we have 4086 already generated the necessary reloc. */ 4087 if ((off & 1) != 0) 4088 off &= ~1; 4089 else 4090 { 4091 bfd_put_32 (output_bfd, relocation, sgot->contents + off); 4092 4093 if (bfd_link_pic (info)) 4094 { 4095 Elf_Internal_Rela outrel; 4096 bfd_byte *loc; 4097 4098 outrel.r_offset = (sgot->output_section->vma 4099 + sgot->output_offset 4100 + off); 4101 if (fdpic_p) 4102 { 4103 int dynindx 4104 = elf_section_data (sec->output_section)->dynindx; 4105 outrel.r_info = ELF32_R_INFO (dynindx, R_SH_DIR32); 4106 outrel.r_addend = relocation; 4107 outrel.r_addend -= sec->output_section->vma; 4108 } 4109 else 4110 { 4111 outrel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE); 4112 outrel.r_addend = relocation; 4113 } 4114 loc = srelgot->contents; 4115 loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela); 4116 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc); 4117 } 4118 else if (fdpic_p 4119 && (sh_elf_local_got_type (input_bfd) [r_symndx] 4120 == GOT_NORMAL)) 4121 sh_elf_add_rofixup (output_bfd, htab->srofixup, 4122 sgot->output_section->vma 4123 + sgot->output_offset 4124 + off); 4125 4126 local_got_offsets[r_symndx] |= 1; 4127 } 4128 4129 relocation = sh_elf_got_offset (htab) + off; 4130 } 4131 4132 #ifdef GOT_BIAS 4133 relocation -= GOT_BIAS; 4134 #endif 4135 4136 if (r_type == R_SH_GOT20) 4137 { 4138 r = install_movi20_field (output_bfd, relocation + addend, 4139 input_bfd, input_section, contents, 4140 rel->r_offset); 4141 break; 4142 } 4143 else 4144 goto final_link_relocate; 4145 4146 case R_SH_GOTOFF: 4147 case R_SH_GOTOFF20: 4148 /* GOTOFF relocations are relative to _GLOBAL_OFFSET_TABLE_, which 4149 we place at the start of the .got.plt section. This is the same 4150 as the start of the output .got section, unless there are function 4151 descriptors in front of it. */ 4152 BFD_ASSERT (htab); 4153 BFD_ASSERT (sgotplt != NULL); 4154 check_segment[0] = got_segment; 4155 relocation -= sgotplt->output_section->vma + sgotplt->output_offset 4156 + htab->root.hgot->root.u.def.value; 4157 4158 #ifdef GOT_BIAS 4159 relocation -= GOT_BIAS; 4160 #endif 4161 4162 addend = rel->r_addend; 4163 4164 if (r_type == R_SH_GOTOFF20) 4165 { 4166 r = install_movi20_field (output_bfd, relocation + addend, 4167 input_bfd, input_section, contents, 4168 rel->r_offset); 4169 break; 4170 } 4171 else 4172 goto final_link_relocate; 4173 4174 case R_SH_GOTPC: 4175 /* Use global offset table as symbol value. */ 4176 4177 BFD_ASSERT (sgotplt != NULL); 4178 relocation = sgotplt->output_section->vma + sgotplt->output_offset; 4179 4180 #ifdef GOT_BIAS 4181 relocation += GOT_BIAS; 4182 #endif 4183 4184 addend = rel->r_addend; 4185 4186 goto final_link_relocate; 4187 4188 case R_SH_PLT32: 4189 /* Relocation is to the entry for this symbol in the 4190 procedure linkage table. */ 4191 4192 /* Resolve a PLT reloc against a local symbol directly, 4193 without using the procedure linkage table. */ 4194 if (h == NULL) 4195 goto final_link_relocate; 4196 4197 /* We don't want to warn on calls to undefined weak symbols, 4198 as calls to them must be protected by non-NULL tests 4199 anyway, and unprotected calls would invoke undefined 4200 behavior. */ 4201 if (h->root.type == bfd_link_hash_undefweak) 4202 check_segment[0] = check_segment[1] = -1; 4203 4204 if (h->forced_local) 4205 goto final_link_relocate; 4206 4207 if (h->plt.offset == (bfd_vma) -1) 4208 { 4209 /* We didn't make a PLT entry for this symbol. This 4210 happens when statically linking PIC code, or when 4211 using -Bsymbolic. */ 4212 goto final_link_relocate; 4213 } 4214 4215 BFD_ASSERT (splt != NULL); 4216 check_segment[1] = plt_segment; 4217 relocation = (splt->output_section->vma 4218 + splt->output_offset 4219 + h->plt.offset); 4220 4221 addend = rel->r_addend; 4222 4223 goto final_link_relocate; 4224 4225 /* Relocation is to the canonical function descriptor for this 4226 symbol, possibly via the GOT. Initialize the GOT 4227 entry and function descriptor if necessary. */ 4228 case R_SH_GOTFUNCDESC: 4229 case R_SH_GOTFUNCDESC20: 4230 case R_SH_FUNCDESC: 4231 { 4232 int dynindx = -1; 4233 asection *reloc_section; 4234 bfd_vma reloc_offset; 4235 int reloc_type = R_SH_FUNCDESC; 4236 4237 BFD_ASSERT (htab); 4238 4239 check_segment[0] = check_segment[1] = -1; 4240 4241 /* FIXME: See what FRV does for global symbols in the 4242 executable, with --export-dynamic. Do they need ld.so 4243 to allocate official descriptors? See what this code 4244 does. */ 4245 4246 relocation = 0; 4247 addend = 0; 4248 4249 if (r_type == R_SH_FUNCDESC) 4250 { 4251 reloc_section = input_section; 4252 reloc_offset = rel->r_offset; 4253 } 4254 else 4255 { 4256 reloc_section = sgot; 4257 4258 if (h != NULL) 4259 reloc_offset = h->got.offset; 4260 else 4261 { 4262 BFD_ASSERT (local_got_offsets != NULL); 4263 reloc_offset = local_got_offsets[r_symndx]; 4264 } 4265 BFD_ASSERT (reloc_offset != MINUS_ONE); 4266 4267 if (reloc_offset & 1) 4268 { 4269 reloc_offset &= ~1; 4270 goto funcdesc_done_got; 4271 } 4272 } 4273 4274 if (h && h->root.type == bfd_link_hash_undefweak 4275 && (SYMBOL_CALLS_LOCAL (info, h) 4276 || !htab->root.dynamic_sections_created)) 4277 /* Undefined weak symbol which will not be dynamically 4278 resolved later; leave it at zero. */ 4279 goto funcdesc_leave_zero; 4280 else if (SYMBOL_CALLS_LOCAL (info, h) 4281 && ! SYMBOL_FUNCDESC_LOCAL (info, h)) 4282 { 4283 /* If the symbol needs a non-local function descriptor 4284 but binds locally (i.e., its visibility is 4285 protected), emit a dynamic relocation decayed to 4286 section+offset. This is an optimization; the dynamic 4287 linker would resolve our function descriptor request 4288 to our copy of the function anyway. */ 4289 dynindx = elf_section_data (h->root.u.def.section 4290 ->output_section)->dynindx; 4291 relocation += h->root.u.def.section->output_offset 4292 + h->root.u.def.value; 4293 } 4294 else if (! SYMBOL_FUNCDESC_LOCAL (info, h)) 4295 { 4296 /* If the symbol is dynamic and there will be dynamic 4297 symbol resolution because we are or are linked with a 4298 shared library, emit a FUNCDESC relocation such that 4299 the dynamic linker will allocate the function 4300 descriptor. */ 4301 BFD_ASSERT (h->dynindx != -1); 4302 dynindx = h->dynindx; 4303 } 4304 else 4305 { 4306 bfd_vma offset; 4307 4308 /* Otherwise, we know we have a private function 4309 descriptor, so reference it directly. */ 4310 reloc_type = R_SH_DIR32; 4311 dynindx = elf_section_data (htab->sfuncdesc 4312 ->output_section)->dynindx; 4313 4314 if (h) 4315 { 4316 offset = sh_elf_hash_entry (h)->funcdesc.offset; 4317 BFD_ASSERT (offset != MINUS_ONE); 4318 if ((offset & 1) == 0) 4319 { 4320 if (!sh_elf_initialize_funcdesc (output_bfd, info, h, 4321 offset, NULL, 0)) 4322 return false; 4323 sh_elf_hash_entry (h)->funcdesc.offset |= 1; 4324 } 4325 } 4326 else 4327 { 4328 union gotref *local_funcdesc; 4329 4330 local_funcdesc = sh_elf_local_funcdesc (input_bfd); 4331 offset = local_funcdesc[r_symndx].offset; 4332 BFD_ASSERT (offset != MINUS_ONE); 4333 if ((offset & 1) == 0) 4334 { 4335 if (!sh_elf_initialize_funcdesc (output_bfd, info, NULL, 4336 offset, sec, 4337 sym->st_value)) 4338 return false; 4339 local_funcdesc[r_symndx].offset |= 1; 4340 } 4341 } 4342 4343 relocation = htab->sfuncdesc->output_offset + (offset & ~1); 4344 } 4345 4346 if (!bfd_link_pic (info) && SYMBOL_FUNCDESC_LOCAL (info, h)) 4347 { 4348 bfd_vma offset; 4349 4350 if (sh_elf_osec_readonly_p (output_bfd, 4351 reloc_section->output_section)) 4352 { 4353 _bfd_error_handler 4354 /* xgettext:c-format */ 4355 (_("%pB(%pA+%#" PRIx64 "): " 4356 "cannot emit fixup to `%s' in read-only section"), 4357 input_bfd, 4358 input_section, 4359 (uint64_t) rel->r_offset, 4360 symname); 4361 return false; 4362 } 4363 4364 offset = _bfd_elf_section_offset (output_bfd, info, 4365 reloc_section, reloc_offset); 4366 4367 if (offset != (bfd_vma)-1) 4368 sh_elf_add_rofixup (output_bfd, htab->srofixup, 4369 offset 4370 + reloc_section->output_section->vma 4371 + reloc_section->output_offset); 4372 } 4373 else if ((reloc_section->output_section->flags 4374 & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD)) 4375 { 4376 bfd_vma offset; 4377 4378 if (sh_elf_osec_readonly_p (output_bfd, 4379 reloc_section->output_section)) 4380 { 4381 info->callbacks->warning 4382 (info, 4383 _("cannot emit dynamic relocations in read-only section"), 4384 symname, input_bfd, reloc_section, reloc_offset); 4385 return false; 4386 } 4387 4388 offset = _bfd_elf_section_offset (output_bfd, info, 4389 reloc_section, reloc_offset); 4390 4391 if (offset != (bfd_vma)-1) 4392 sh_elf_add_dyn_reloc (output_bfd, srelgot, 4393 offset 4394 + reloc_section->output_section->vma 4395 + reloc_section->output_offset, 4396 reloc_type, dynindx, relocation); 4397 4398 if (r_type == R_SH_FUNCDESC) 4399 { 4400 r = bfd_reloc_ok; 4401 break; 4402 } 4403 else 4404 { 4405 relocation = 0; 4406 goto funcdesc_leave_zero; 4407 } 4408 } 4409 4410 if (SYMBOL_FUNCDESC_LOCAL (info, h)) 4411 relocation += htab->sfuncdesc->output_section->vma; 4412 funcdesc_leave_zero: 4413 if (r_type != R_SH_FUNCDESC) 4414 { 4415 bfd_put_32 (output_bfd, relocation, 4416 reloc_section->contents + reloc_offset); 4417 if (h != NULL) 4418 h->got.offset |= 1; 4419 else 4420 local_got_offsets[r_symndx] |= 1; 4421 4422 funcdesc_done_got: 4423 4424 relocation = sh_elf_got_offset (htab) + reloc_offset; 4425 #ifdef GOT_BIAS 4426 relocation -= GOT_BIAS; 4427 #endif 4428 } 4429 if (r_type == R_SH_GOTFUNCDESC20) 4430 { 4431 r = install_movi20_field (output_bfd, relocation + addend, 4432 input_bfd, input_section, contents, 4433 rel->r_offset); 4434 break; 4435 } 4436 else 4437 goto final_link_relocate; 4438 } 4439 break; 4440 4441 case R_SH_GOTOFFFUNCDESC: 4442 case R_SH_GOTOFFFUNCDESC20: 4443 /* FIXME: See R_SH_FUNCDESC comment about global symbols in the 4444 executable and --export-dynamic. If such symbols get 4445 ld.so-allocated descriptors we can not use R_SH_GOTOFFFUNCDESC 4446 for them. */ 4447 BFD_ASSERT (htab); 4448 4449 check_segment[0] = check_segment[1] = -1; 4450 relocation = 0; 4451 addend = rel->r_addend; 4452 4453 if (h && (h->root.type == bfd_link_hash_undefweak 4454 || !SYMBOL_FUNCDESC_LOCAL (info, h))) 4455 { 4456 _bfd_error_handler 4457 /* xgettext:c-format */ 4458 (_("%pB(%pA+%#" PRIx64 "): " 4459 "%s relocation against external symbol \"%s\""), 4460 input_bfd, input_section, (uint64_t) rel->r_offset, 4461 howto->name, h->root.root.string); 4462 return false; 4463 } 4464 else 4465 { 4466 bfd_vma offset; 4467 4468 /* Otherwise, we know we have a private function 4469 descriptor, so reference it directly. */ 4470 if (h) 4471 { 4472 offset = sh_elf_hash_entry (h)->funcdesc.offset; 4473 BFD_ASSERT (offset != MINUS_ONE); 4474 if ((offset & 1) == 0) 4475 { 4476 if (!sh_elf_initialize_funcdesc (output_bfd, info, h, 4477 offset, NULL, 0)) 4478 return false; 4479 sh_elf_hash_entry (h)->funcdesc.offset |= 1; 4480 } 4481 } 4482 else 4483 { 4484 union gotref *local_funcdesc; 4485 4486 local_funcdesc = sh_elf_local_funcdesc (input_bfd); 4487 offset = local_funcdesc[r_symndx].offset; 4488 BFD_ASSERT (offset != MINUS_ONE); 4489 if ((offset & 1) == 0) 4490 { 4491 if (!sh_elf_initialize_funcdesc (output_bfd, info, NULL, 4492 offset, sec, 4493 sym->st_value)) 4494 return false; 4495 local_funcdesc[r_symndx].offset |= 1; 4496 } 4497 } 4498 4499 relocation = htab->sfuncdesc->output_offset + (offset & ~1); 4500 } 4501 4502 relocation -= (htab->root.hgot->root.u.def.value 4503 + sgotplt->output_offset); 4504 #ifdef GOT_BIAS 4505 relocation -= GOT_BIAS; 4506 #endif 4507 4508 if (r_type == R_SH_GOTOFFFUNCDESC20) 4509 { 4510 r = install_movi20_field (output_bfd, relocation + addend, 4511 input_bfd, input_section, contents, 4512 rel->r_offset); 4513 break; 4514 } 4515 else 4516 goto final_link_relocate; 4517 4518 case R_SH_LOOP_START: 4519 { 4520 static bfd_vma start, end; 4521 4522 start = (relocation + rel->r_addend 4523 - (sec->output_section->vma + sec->output_offset)); 4524 r = sh_elf_reloc_loop (r_type, input_bfd, input_section, contents, 4525 rel->r_offset, sec, start, end); 4526 break; 4527 4528 case R_SH_LOOP_END: 4529 end = (relocation + rel->r_addend 4530 - (sec->output_section->vma + sec->output_offset)); 4531 r = sh_elf_reloc_loop (r_type, input_bfd, input_section, contents, 4532 rel->r_offset, sec, start, end); 4533 break; 4534 } 4535 4536 case R_SH_TLS_GD_32: 4537 case R_SH_TLS_IE_32: 4538 BFD_ASSERT (htab); 4539 check_segment[0] = check_segment[1] = -1; 4540 r_type = sh_elf_optimized_tls_reloc (info, r_type, h == NULL); 4541 got_type = GOT_UNKNOWN; 4542 if (h == NULL && local_got_offsets) 4543 got_type = sh_elf_local_got_type (input_bfd) [r_symndx]; 4544 else if (h != NULL) 4545 { 4546 got_type = sh_elf_hash_entry (h)->got_type; 4547 if (! bfd_link_pic (info) 4548 && (h->dynindx == -1 4549 || h->def_regular)) 4550 r_type = R_SH_TLS_LE_32; 4551 } 4552 4553 if (r_type == R_SH_TLS_GD_32 && got_type == GOT_TLS_IE) 4554 r_type = R_SH_TLS_IE_32; 4555 4556 if (r_type == R_SH_TLS_LE_32) 4557 { 4558 bfd_vma offset; 4559 unsigned short insn; 4560 4561 if (ELF32_R_TYPE (rel->r_info) == R_SH_TLS_GD_32) 4562 { 4563 /* GD->LE transition: 4564 mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1; 4565 jsr @r1; add r12,r4; bra 3f; nop; .align 2; 4566 1: .long x$TLSGD; 2: .long __tls_get_addr@PLT; 3: 4567 We change it into: 4568 mov.l 1f,r4; stc gbr,r0; add r4,r0; nop; 4569 nop; nop; ... 4570 1: .long x@TPOFF; 2: .long __tls_get_addr@PLT; 3:. */ 4571 4572 offset = rel->r_offset; 4573 if (offset < 16) 4574 { 4575 _bfd_error_handler 4576 /* xgettext:c-format */ 4577 (_("%pB(%pA): offset in relocation for GD->LE translation is too small: %#" PRIx64), 4578 input_bfd, input_section, (uint64_t) offset); 4579 return false; 4580 } 4581 4582 /* Size of GD instructions is 16 or 18. */ 4583 offset -= 16; 4584 insn = bfd_get_16 (input_bfd, contents + offset + 0); 4585 if ((insn & 0xff00) == 0xc700) 4586 { 4587 BFD_ASSERT (offset >= 2); 4588 offset -= 2; 4589 insn = bfd_get_16 (input_bfd, contents + offset + 0); 4590 } 4591 4592 if ((insn & 0xff00) != 0xd400) 4593 _bfd_error_handler 4594 /* xgettext:c-format */ /* The backslash is to prevent bogus trigraph detection. */ 4595 (_("%pB(%pA+%#" PRIx64 "): unexpected instruction %#04X (expected 0xd4?\?)"), 4596 input_bfd, input_section, (uint64_t) offset, (int) insn); 4597 4598 insn = bfd_get_16 (input_bfd, contents + offset + 2); 4599 4600 if ((insn & 0xff00) != 0xc700) 4601 _bfd_error_handler 4602 /* xgettext:c-format */ 4603 (_("%pB(%pA+%#" PRIx64 "): unexpected instruction %#04X (expected 0xc7?\?)"), 4604 input_bfd, input_section, (uint64_t) offset, (int) insn); 4605 4606 insn = bfd_get_16 (input_bfd, contents + offset + 4); 4607 if ((insn & 0xff00) != 0xd100) 4608 _bfd_error_handler 4609 /* xgettext:c-format */ 4610 (_("%pB(%pA+%#" PRIx64 "): unexpected instruction %#04X (expected 0xd1?\?)"), 4611 input_bfd, input_section, (uint64_t) offset, (int) insn); 4612 4613 insn = bfd_get_16 (input_bfd, contents + offset + 6); 4614 if (insn != 0x310c) 4615 _bfd_error_handler 4616 /* xgettext:c-format */ 4617 (_("%pB(%pA+%#" PRIx64 "): unexpected instruction %#04X (expected 0x310c)"), 4618 input_bfd, input_section, (uint64_t) offset, (int) insn); 4619 4620 insn = bfd_get_16 (input_bfd, contents + offset + 8); 4621 if (insn != 0x410b) 4622 _bfd_error_handler 4623 /* xgettext:c-format */ 4624 (_("%pB(%pA+%#" PRIx64 "): unexpected instruction %#04X (expected 0x410b)"), 4625 input_bfd, input_section, (uint64_t) offset, (int) insn); 4626 4627 insn = bfd_get_16 (input_bfd, contents + offset + 10); 4628 if (insn != 0x34cc) 4629 _bfd_error_handler 4630 /* xgettext:c-format */ 4631 (_("%pB(%pA+%#" PRIx64 "): unexpected instruction %#04X (expected 0x34cc)"), 4632 input_bfd, input_section, (uint64_t) offset, (int) insn); 4633 4634 bfd_put_16 (output_bfd, 0x0012, contents + offset + 2); 4635 bfd_put_16 (output_bfd, 0x304c, contents + offset + 4); 4636 bfd_put_16 (output_bfd, 0x0009, contents + offset + 6); 4637 bfd_put_16 (output_bfd, 0x0009, contents + offset + 8); 4638 bfd_put_16 (output_bfd, 0x0009, contents + offset + 10); 4639 } 4640 else 4641 { 4642 int target; 4643 4644 /* IE->LE transition: 4645 mov.l 1f,r0; 4646 stc gbr,rN; 4647 mov.l @(r0,r12),rM; 4648 bra 2f; 4649 add ...; 4650 .align 2; 4651 1: x@GOTTPOFF; 4652 2: 4653 We change it into: 4654 mov.l .Ln,rM; 4655 stc gbr,rN; 4656 nop; 4657 ...; 4658 1: x@TPOFF; 4659 2:. */ 4660 4661 offset = rel->r_offset; 4662 if (offset < 16) 4663 { 4664 _bfd_error_handler 4665 /* xgettext:c-format */ 4666 (_("%pB(%pA): offset in relocation for IE->LE translation is too small: %#" PRIx64), 4667 input_bfd, input_section, (uint64_t) offset); 4668 return false; 4669 } 4670 4671 /* Size of IE instructions is 10 or 12. */ 4672 offset -= 10; 4673 insn = bfd_get_16 (input_bfd, contents + offset + 0); 4674 if ((insn & 0xf0ff) == 0x0012) 4675 { 4676 BFD_ASSERT (offset >= 2); 4677 offset -= 2; 4678 insn = bfd_get_16 (input_bfd, contents + offset + 0); 4679 } 4680 4681 if ((insn & 0xff00) != 0xd000) 4682 _bfd_error_handler 4683 /* xgettext:c-format */ 4684 (_("%pB(%pA+%#" PRIx64 "): unexpected instruction %#04X (expected 0xd0??: mov.l)"), 4685 input_bfd, input_section, (uint64_t) offset, (int) insn); 4686 4687 target = insn & 0x00ff; 4688 4689 insn = bfd_get_16 (input_bfd, contents + offset + 2); 4690 if ((insn & 0xf0ff) != 0x0012) 4691 _bfd_error_handler 4692 /* xgettext:c-format */ 4693 (_("%pB(%pA+%#" PRIx64 "): unexpected instruction %#04X (expected 0x0?12: stc)"), 4694 input_bfd, input_section, (uint64_t) (offset + 2), (int) insn); 4695 4696 insn = bfd_get_16 (input_bfd, contents + offset + 4); 4697 if ((insn & 0xf0ff) != 0x00ce) 4698 _bfd_error_handler 4699 /* xgettext:c-format */ 4700 (_("%pB(%pA+%#" PRIx64 "): unexpected instruction %#04X (expected 0x0?ce: mov.l)"), 4701 input_bfd, input_section, (uint64_t) (offset + 4), (int) insn); 4702 4703 insn = 0xd000 | (insn & 0x0f00) | target; 4704 bfd_put_16 (output_bfd, insn, contents + offset + 0); 4705 bfd_put_16 (output_bfd, 0x0009, contents + offset + 4); 4706 } 4707 4708 bfd_put_32 (output_bfd, tpoff (info, relocation), 4709 contents + rel->r_offset); 4710 continue; 4711 } 4712 4713 if (sgot == NULL || sgotplt == NULL) 4714 abort (); 4715 4716 if (h != NULL) 4717 off = h->got.offset; 4718 else 4719 { 4720 if (local_got_offsets == NULL) 4721 abort (); 4722 4723 off = local_got_offsets[r_symndx]; 4724 } 4725 4726 /* Relocate R_SH_TLS_IE_32 directly when statically linking. */ 4727 if (r_type == R_SH_TLS_IE_32 4728 && ! htab->root.dynamic_sections_created) 4729 { 4730 off &= ~1; 4731 bfd_put_32 (output_bfd, tpoff (info, relocation), 4732 sgot->contents + off); 4733 bfd_put_32 (output_bfd, sh_elf_got_offset (htab) + off, 4734 contents + rel->r_offset); 4735 continue; 4736 } 4737 4738 if ((off & 1) != 0) 4739 off &= ~1; 4740 else 4741 { 4742 Elf_Internal_Rela outrel; 4743 bfd_byte *loc; 4744 int dr_type, indx; 4745 4746 outrel.r_offset = (sgot->output_section->vma 4747 + sgot->output_offset + off); 4748 4749 if (h == NULL || h->dynindx == -1) 4750 indx = 0; 4751 else 4752 indx = h->dynindx; 4753 4754 dr_type = (r_type == R_SH_TLS_GD_32 ? R_SH_TLS_DTPMOD32 : 4755 R_SH_TLS_TPOFF32); 4756 if (dr_type == R_SH_TLS_TPOFF32 && indx == 0) 4757 outrel.r_addend = relocation - dtpoff_base (info); 4758 else 4759 outrel.r_addend = 0; 4760 outrel.r_info = ELF32_R_INFO (indx, dr_type); 4761 loc = srelgot->contents; 4762 loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela); 4763 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc); 4764 4765 if (r_type == R_SH_TLS_GD_32) 4766 { 4767 if (indx == 0) 4768 { 4769 bfd_put_32 (output_bfd, 4770 relocation - dtpoff_base (info), 4771 sgot->contents + off + 4); 4772 } 4773 else 4774 { 4775 outrel.r_info = ELF32_R_INFO (indx, 4776 R_SH_TLS_DTPOFF32); 4777 outrel.r_offset += 4; 4778 outrel.r_addend = 0; 4779 srelgot->reloc_count++; 4780 loc += sizeof (Elf32_External_Rela); 4781 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc); 4782 } 4783 } 4784 4785 if (h != NULL) 4786 h->got.offset |= 1; 4787 else 4788 local_got_offsets[r_symndx] |= 1; 4789 } 4790 4791 if (off >= (bfd_vma) -2) 4792 abort (); 4793 4794 if (r_type == (int) ELF32_R_TYPE (rel->r_info)) 4795 relocation = sh_elf_got_offset (htab) + off; 4796 else 4797 { 4798 bfd_vma offset; 4799 unsigned short insn; 4800 4801 /* GD->IE transition: 4802 mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1; 4803 jsr @r1; add r12,r4; bra 3f; nop; .align 2; 4804 1: .long x$TLSGD; 2: .long __tls_get_addr@PLT; 3: 4805 We change it into: 4806 mov.l 1f,r0; stc gbr,r4; mov.l @(r0,r12),r0; add r4,r0; 4807 nop; nop; bra 3f; nop; .align 2; 4808 1: .long x@TPOFF; 2:...; 3:. */ 4809 4810 offset = rel->r_offset; 4811 if (offset < 16) 4812 { 4813 _bfd_error_handler 4814 /* xgettext:c-format */ 4815 (_("%pB(%pA): offset in relocation for GD->IE translation is too small: %#" PRIx64), 4816 input_bfd, input_section, (uint64_t) offset); 4817 return false; 4818 } 4819 4820 /* Size of GD instructions is 16 or 18. */ 4821 offset -= 16; 4822 insn = bfd_get_16 (input_bfd, contents + offset + 0); 4823 if ((insn & 0xff00) == 0xc700) 4824 { 4825 BFD_ASSERT (offset >= 2); 4826 offset -= 2; 4827 insn = bfd_get_16 (input_bfd, contents + offset + 0); 4828 } 4829 4830 BFD_ASSERT ((insn & 0xff00) == 0xd400); 4831 4832 /* Replace mov.l 1f,R4 with mov.l 1f,r0. */ 4833 bfd_put_16 (output_bfd, insn & 0xf0ff, contents + offset); 4834 4835 insn = bfd_get_16 (input_bfd, contents + offset + 2); 4836 BFD_ASSERT ((insn & 0xff00) == 0xc700); 4837 insn = bfd_get_16 (input_bfd, contents + offset + 4); 4838 BFD_ASSERT ((insn & 0xff00) == 0xd100); 4839 insn = bfd_get_16 (input_bfd, contents + offset + 6); 4840 BFD_ASSERT (insn == 0x310c); 4841 insn = bfd_get_16 (input_bfd, contents + offset + 8); 4842 BFD_ASSERT (insn == 0x410b); 4843 insn = bfd_get_16 (input_bfd, contents + offset + 10); 4844 BFD_ASSERT (insn == 0x34cc); 4845 4846 bfd_put_16 (output_bfd, 0x0412, contents + offset + 2); 4847 bfd_put_16 (output_bfd, 0x00ce, contents + offset + 4); 4848 bfd_put_16 (output_bfd, 0x304c, contents + offset + 6); 4849 bfd_put_16 (output_bfd, 0x0009, contents + offset + 8); 4850 bfd_put_16 (output_bfd, 0x0009, contents + offset + 10); 4851 4852 bfd_put_32 (output_bfd, sh_elf_got_offset (htab) + off, 4853 contents + rel->r_offset); 4854 4855 continue; 4856 } 4857 4858 addend = rel->r_addend; 4859 4860 goto final_link_relocate; 4861 4862 case R_SH_TLS_LD_32: 4863 BFD_ASSERT (htab); 4864 check_segment[0] = check_segment[1] = -1; 4865 if (! bfd_link_pic (info)) 4866 { 4867 bfd_vma offset; 4868 unsigned short insn; 4869 4870 /* LD->LE transition: 4871 mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1; 4872 jsr @r1; add r12,r4; bra 3f; nop; .align 2; 4873 1: .long x$TLSLD; 2: .long __tls_get_addr@PLT; 3: 4874 We change it into: 4875 stc gbr,r0; nop; nop; nop; 4876 nop; nop; bra 3f; ...; 3:. */ 4877 4878 offset = rel->r_offset; 4879 if (offset < 16) 4880 { 4881 _bfd_error_handler 4882 /* xgettext:c-format */ 4883 (_("%pB(%pA): offset in relocation for LD->LE translation is too small: %#" PRIx64), 4884 input_bfd, input_section, (uint64_t) offset); 4885 return false; 4886 } 4887 4888 /* Size of LD instructions is 16 or 18. */ 4889 offset -= 16; 4890 insn = bfd_get_16 (input_bfd, contents + offset + 0); 4891 if ((insn & 0xff00) == 0xc700) 4892 { 4893 BFD_ASSERT (offset >= 2); 4894 offset -= 2; 4895 insn = bfd_get_16 (input_bfd, contents + offset + 0); 4896 } 4897 4898 BFD_ASSERT ((insn & 0xff00) == 0xd400); 4899 insn = bfd_get_16 (input_bfd, contents + offset + 2); 4900 BFD_ASSERT ((insn & 0xff00) == 0xc700); 4901 insn = bfd_get_16 (input_bfd, contents + offset + 4); 4902 BFD_ASSERT ((insn & 0xff00) == 0xd100); 4903 insn = bfd_get_16 (input_bfd, contents + offset + 6); 4904 BFD_ASSERT (insn == 0x310c); 4905 insn = bfd_get_16 (input_bfd, contents + offset + 8); 4906 BFD_ASSERT (insn == 0x410b); 4907 insn = bfd_get_16 (input_bfd, contents + offset + 10); 4908 BFD_ASSERT (insn == 0x34cc); 4909 4910 bfd_put_16 (output_bfd, 0x0012, contents + offset + 0); 4911 bfd_put_16 (output_bfd, 0x0009, contents + offset + 2); 4912 bfd_put_16 (output_bfd, 0x0009, contents + offset + 4); 4913 bfd_put_16 (output_bfd, 0x0009, contents + offset + 6); 4914 bfd_put_16 (output_bfd, 0x0009, contents + offset + 8); 4915 bfd_put_16 (output_bfd, 0x0009, contents + offset + 10); 4916 4917 continue; 4918 } 4919 4920 if (sgot == NULL || sgotplt == NULL) 4921 abort (); 4922 4923 off = htab->tls_ldm_got.offset; 4924 if (off & 1) 4925 off &= ~1; 4926 else 4927 { 4928 Elf_Internal_Rela outrel; 4929 bfd_byte *loc; 4930 4931 outrel.r_offset = (sgot->output_section->vma 4932 + sgot->output_offset + off); 4933 outrel.r_addend = 0; 4934 outrel.r_info = ELF32_R_INFO (0, R_SH_TLS_DTPMOD32); 4935 loc = srelgot->contents; 4936 loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela); 4937 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc); 4938 htab->tls_ldm_got.offset |= 1; 4939 } 4940 4941 relocation = sh_elf_got_offset (htab) + off; 4942 addend = rel->r_addend; 4943 4944 goto final_link_relocate; 4945 4946 case R_SH_TLS_LDO_32: 4947 check_segment[0] = check_segment[1] = -1; 4948 if (! bfd_link_pic (info)) 4949 relocation = tpoff (info, relocation); 4950 else 4951 relocation -= dtpoff_base (info); 4952 4953 addend = rel->r_addend; 4954 goto final_link_relocate; 4955 4956 case R_SH_TLS_LE_32: 4957 { 4958 int indx; 4959 Elf_Internal_Rela outrel; 4960 bfd_byte *loc; 4961 4962 check_segment[0] = check_segment[1] = -1; 4963 4964 if (!bfd_link_dll (info)) 4965 { 4966 relocation = tpoff (info, relocation); 4967 addend = rel->r_addend; 4968 goto final_link_relocate; 4969 } 4970 4971 if (sreloc == NULL) 4972 { 4973 sreloc = _bfd_elf_get_dynamic_reloc_section 4974 (input_bfd, input_section, /*rela?*/ true); 4975 if (sreloc == NULL) 4976 return false; 4977 } 4978 4979 if (h == NULL || h->dynindx == -1) 4980 indx = 0; 4981 else 4982 indx = h->dynindx; 4983 4984 outrel.r_offset = (input_section->output_section->vma 4985 + input_section->output_offset 4986 + rel->r_offset); 4987 outrel.r_info = ELF32_R_INFO (indx, R_SH_TLS_TPOFF32); 4988 if (indx == 0) 4989 outrel.r_addend = relocation - dtpoff_base (info); 4990 else 4991 outrel.r_addend = 0; 4992 4993 loc = sreloc->contents; 4994 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela); 4995 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc); 4996 continue; 4997 } 4998 } 4999 5000 relocation_done: 5001 if (fdpic_p && check_segment[0] != (unsigned) -1 5002 && check_segment[0] != check_segment[1]) 5003 { 5004 /* We don't want duplicate errors for undefined symbols. */ 5005 if (!h || h->root.type != bfd_link_hash_undefined) 5006 { 5007 if (bfd_link_pic (info)) 5008 { 5009 info->callbacks->einfo 5010 /* xgettext:c-format */ 5011 (_("%X%C: relocation to \"%s\" references a different segment\n"), 5012 input_bfd, input_section, rel->r_offset, symname); 5013 return false; 5014 } 5015 else 5016 info->callbacks->einfo 5017 /* xgettext:c-format */ 5018 (_("%C: warning: relocation to \"%s\" references a different segment\n"), 5019 input_bfd, input_section, rel->r_offset, symname); 5020 } 5021 5022 elf_elfheader (output_bfd)->e_flags |= EF_SH_PIC; 5023 } 5024 5025 if (r != bfd_reloc_ok) 5026 { 5027 switch (r) 5028 { 5029 default: 5030 case bfd_reloc_outofrange: 5031 abort (); 5032 case bfd_reloc_overflow: 5033 { 5034 const char *name; 5035 5036 if (h != NULL) 5037 name = NULL; 5038 else 5039 { 5040 name = (bfd_elf_string_from_elf_section 5041 (input_bfd, symtab_hdr->sh_link, sym->st_name)); 5042 if (name == NULL) 5043 return false; 5044 if (*name == '\0') 5045 name = bfd_section_name (sec); 5046 } 5047 (*info->callbacks->reloc_overflow) 5048 (info, (h ? &h->root : NULL), name, howto->name, 5049 (bfd_vma) 0, input_bfd, input_section, rel->r_offset); 5050 } 5051 break; 5052 } 5053 } 5054 } 5055 5056 return true; 5057 } 5058 5059 /* This is a version of bfd_generic_get_relocated_section_contents 5060 which uses sh_elf_relocate_section. */ 5061 5062 static bfd_byte * 5063 sh_elf_get_relocated_section_contents (bfd *output_bfd, 5064 struct bfd_link_info *link_info, 5065 struct bfd_link_order *link_order, 5066 bfd_byte *data, 5067 bool relocatable, 5068 asymbol **symbols) 5069 { 5070 Elf_Internal_Shdr *symtab_hdr; 5071 asection *input_section = link_order->u.indirect.section; 5072 bfd *input_bfd = input_section->owner; 5073 asection **sections = NULL; 5074 Elf_Internal_Rela *internal_relocs = NULL; 5075 Elf_Internal_Sym *isymbuf = NULL; 5076 5077 /* We only need to handle the case of relaxing, or of having a 5078 particular set of section contents, specially. */ 5079 if (relocatable 5080 || elf_section_data (input_section)->this_hdr.contents == NULL) 5081 return bfd_generic_get_relocated_section_contents (output_bfd, link_info, 5082 link_order, data, 5083 relocatable, 5084 symbols); 5085 5086 symtab_hdr = &elf_symtab_hdr (input_bfd); 5087 5088 bfd_byte *orig_data = data; 5089 if (data == NULL) 5090 { 5091 data = bfd_malloc (input_section->size); 5092 if (data == NULL) 5093 return NULL; 5094 } 5095 memcpy (data, elf_section_data (input_section)->this_hdr.contents, 5096 (size_t) input_section->size); 5097 5098 if ((input_section->flags & SEC_RELOC) != 0 5099 && input_section->reloc_count > 0) 5100 { 5101 asection **secpp; 5102 Elf_Internal_Sym *isym, *isymend; 5103 bfd_size_type amt; 5104 5105 internal_relocs = (_bfd_elf_link_read_relocs 5106 (input_bfd, input_section, NULL, 5107 (Elf_Internal_Rela *) NULL, false)); 5108 if (internal_relocs == NULL) 5109 goto error_return; 5110 5111 if (symtab_hdr->sh_info != 0) 5112 { 5113 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents; 5114 if (isymbuf == NULL) 5115 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, 5116 symtab_hdr->sh_info, 0, 5117 NULL, NULL, NULL); 5118 if (isymbuf == NULL) 5119 goto error_return; 5120 } 5121 5122 amt = symtab_hdr->sh_info; 5123 amt *= sizeof (asection *); 5124 sections = (asection **) bfd_malloc (amt); 5125 if (sections == NULL && amt != 0) 5126 goto error_return; 5127 5128 isymend = isymbuf + symtab_hdr->sh_info; 5129 for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp) 5130 { 5131 asection *isec; 5132 5133 if (isym->st_shndx == SHN_UNDEF) 5134 isec = bfd_und_section_ptr; 5135 else if (isym->st_shndx == SHN_ABS) 5136 isec = bfd_abs_section_ptr; 5137 else if (isym->st_shndx == SHN_COMMON) 5138 isec = bfd_com_section_ptr; 5139 else 5140 isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx); 5141 5142 *secpp = isec; 5143 } 5144 5145 if (! sh_elf_relocate_section (output_bfd, link_info, input_bfd, 5146 input_section, data, internal_relocs, 5147 isymbuf, sections)) 5148 goto error_return; 5149 5150 free (sections); 5151 if (symtab_hdr->contents != (unsigned char *) isymbuf) 5152 free (isymbuf); 5153 if (elf_section_data (input_section)->relocs != internal_relocs) 5154 free (internal_relocs); 5155 } 5156 5157 return data; 5158 5159 error_return: 5160 free (sections); 5161 if (symtab_hdr->contents != (unsigned char *) isymbuf) 5162 free (isymbuf); 5163 if (elf_section_data (input_section)->relocs != internal_relocs) 5164 free (internal_relocs); 5165 if (orig_data == NULL) 5166 free (data); 5167 return NULL; 5168 } 5169 5170 /* Return the base VMA address which should be subtracted from real addresses 5171 when resolving @dtpoff relocation. 5172 This is PT_TLS segment p_vaddr. */ 5173 5174 static bfd_vma 5175 dtpoff_base (struct bfd_link_info *info) 5176 { 5177 /* If tls_sec is NULL, we should have signalled an error already. */ 5178 if (elf_hash_table (info)->tls_sec == NULL) 5179 return 0; 5180 return elf_hash_table (info)->tls_sec->vma; 5181 } 5182 5183 /* Return the relocation value for R_SH_TLS_TPOFF32.. */ 5184 5185 static bfd_vma 5186 tpoff (struct bfd_link_info *info, bfd_vma address) 5187 { 5188 /* If tls_sec is NULL, we should have signalled an error already. */ 5189 if (elf_hash_table (info)->tls_sec == NULL) 5190 return 0; 5191 /* SH TLS ABI is variant I and static TLS block start just after tcbhead 5192 structure which has 2 pointer fields. */ 5193 return (address - elf_hash_table (info)->tls_sec->vma 5194 + align_power ((bfd_vma) 8, 5195 elf_hash_table (info)->tls_sec->alignment_power)); 5196 } 5197 5198 static asection * 5199 sh_elf_gc_mark_hook (asection *sec, 5200 struct bfd_link_info *info, 5201 Elf_Internal_Rela *rel, 5202 struct elf_link_hash_entry *h, 5203 Elf_Internal_Sym *sym) 5204 { 5205 if (h != NULL) 5206 switch (ELF32_R_TYPE (rel->r_info)) 5207 { 5208 case R_SH_GNU_VTINHERIT: 5209 case R_SH_GNU_VTENTRY: 5210 return NULL; 5211 } 5212 5213 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym); 5214 } 5215 5216 /* Copy the extra info we tack onto an elf_link_hash_entry. */ 5217 5218 static void 5219 sh_elf_copy_indirect_symbol (struct bfd_link_info *info, 5220 struct elf_link_hash_entry *dir, 5221 struct elf_link_hash_entry *ind) 5222 { 5223 struct elf_sh_link_hash_entry *edir, *eind; 5224 5225 edir = (struct elf_sh_link_hash_entry *) dir; 5226 eind = (struct elf_sh_link_hash_entry *) ind; 5227 5228 edir->gotplt_refcount = eind->gotplt_refcount; 5229 eind->gotplt_refcount = 0; 5230 edir->funcdesc.refcount += eind->funcdesc.refcount; 5231 eind->funcdesc.refcount = 0; 5232 edir->abs_funcdesc_refcount += eind->abs_funcdesc_refcount; 5233 eind->abs_funcdesc_refcount = 0; 5234 5235 if (ind->root.type == bfd_link_hash_indirect 5236 && dir->got.refcount <= 0) 5237 { 5238 edir->got_type = eind->got_type; 5239 eind->got_type = GOT_UNKNOWN; 5240 } 5241 5242 if (ind->root.type != bfd_link_hash_indirect 5243 && dir->dynamic_adjusted) 5244 { 5245 /* If called to transfer flags for a weakdef during processing 5246 of elf_adjust_dynamic_symbol, don't copy non_got_ref. 5247 We clear it ourselves for ELIMINATE_COPY_RELOCS. */ 5248 if (dir->versioned != versioned_hidden) 5249 dir->ref_dynamic |= ind->ref_dynamic; 5250 dir->ref_regular |= ind->ref_regular; 5251 dir->ref_regular_nonweak |= ind->ref_regular_nonweak; 5252 dir->needs_plt |= ind->needs_plt; 5253 } 5254 else 5255 _bfd_elf_link_hash_copy_indirect (info, dir, ind); 5256 } 5257 5258 static int 5259 sh_elf_optimized_tls_reloc (struct bfd_link_info *info, int r_type, 5260 int is_local) 5261 { 5262 if (bfd_link_pic (info)) 5263 return r_type; 5264 5265 switch (r_type) 5266 { 5267 case R_SH_TLS_GD_32: 5268 case R_SH_TLS_IE_32: 5269 if (is_local) 5270 return R_SH_TLS_LE_32; 5271 return R_SH_TLS_IE_32; 5272 case R_SH_TLS_LD_32: 5273 return R_SH_TLS_LE_32; 5274 } 5275 5276 return r_type; 5277 } 5278 5279 /* Look through the relocs for a section during the first phase. 5280 Since we don't do .gots or .plts, we just need to consider the 5281 virtual table relocs for gc. */ 5282 5283 static bool 5284 sh_elf_check_relocs (bfd *abfd, struct bfd_link_info *info, asection *sec, 5285 const Elf_Internal_Rela *relocs) 5286 { 5287 Elf_Internal_Shdr *symtab_hdr; 5288 struct elf_link_hash_entry **sym_hashes; 5289 struct elf_sh_link_hash_table *htab; 5290 const Elf_Internal_Rela *rel; 5291 const Elf_Internal_Rela *rel_end; 5292 asection *sreloc; 5293 unsigned int r_type; 5294 enum got_type got_type, old_got_type; 5295 5296 sreloc = NULL; 5297 5298 if (bfd_link_relocatable (info)) 5299 return true; 5300 5301 BFD_ASSERT (is_sh_elf (abfd)); 5302 5303 symtab_hdr = &elf_symtab_hdr (abfd); 5304 sym_hashes = elf_sym_hashes (abfd); 5305 5306 htab = sh_elf_hash_table (info); 5307 if (htab == NULL) 5308 return false; 5309 5310 rel_end = relocs + sec->reloc_count; 5311 for (rel = relocs; rel < rel_end; rel++) 5312 { 5313 struct elf_link_hash_entry *h; 5314 unsigned long r_symndx; 5315 5316 r_symndx = ELF32_R_SYM (rel->r_info); 5317 r_type = ELF32_R_TYPE (rel->r_info); 5318 5319 if (r_symndx < symtab_hdr->sh_info) 5320 h = NULL; 5321 else 5322 { 5323 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 5324 while (h->root.type == bfd_link_hash_indirect 5325 || h->root.type == bfd_link_hash_warning) 5326 h = (struct elf_link_hash_entry *) h->root.u.i.link; 5327 } 5328 5329 r_type = sh_elf_optimized_tls_reloc (info, r_type, h == NULL); 5330 if (! bfd_link_pic (info) 5331 && r_type == R_SH_TLS_IE_32 5332 && h != NULL 5333 && h->root.type != bfd_link_hash_undefined 5334 && h->root.type != bfd_link_hash_undefweak 5335 && (h->dynindx == -1 5336 || h->def_regular)) 5337 r_type = R_SH_TLS_LE_32; 5338 5339 if (htab->fdpic_p) 5340 switch (r_type) 5341 { 5342 case R_SH_GOTOFFFUNCDESC: 5343 case R_SH_GOTOFFFUNCDESC20: 5344 case R_SH_FUNCDESC: 5345 case R_SH_GOTFUNCDESC: 5346 case R_SH_GOTFUNCDESC20: 5347 if (h != NULL) 5348 { 5349 if (h->dynindx == -1) 5350 switch (ELF_ST_VISIBILITY (h->other)) 5351 { 5352 case STV_INTERNAL: 5353 case STV_HIDDEN: 5354 break; 5355 default: 5356 bfd_elf_link_record_dynamic_symbol (info, h); 5357 break; 5358 } 5359 } 5360 break; 5361 } 5362 5363 /* Some relocs require a global offset table. */ 5364 if (htab->root.sgot == NULL) 5365 { 5366 switch (r_type) 5367 { 5368 case R_SH_DIR32: 5369 /* This may require an rofixup. */ 5370 if (!htab->fdpic_p) 5371 break; 5372 /* Fall through. */ 5373 case R_SH_GOTPLT32: 5374 case R_SH_GOT32: 5375 case R_SH_GOT20: 5376 case R_SH_GOTOFF: 5377 case R_SH_GOTOFF20: 5378 case R_SH_FUNCDESC: 5379 case R_SH_GOTFUNCDESC: 5380 case R_SH_GOTFUNCDESC20: 5381 case R_SH_GOTOFFFUNCDESC: 5382 case R_SH_GOTOFFFUNCDESC20: 5383 case R_SH_GOTPC: 5384 case R_SH_TLS_GD_32: 5385 case R_SH_TLS_LD_32: 5386 case R_SH_TLS_IE_32: 5387 if (htab->root.dynobj == NULL) 5388 htab->root.dynobj = abfd; 5389 if (!create_got_section (htab->root.dynobj, info)) 5390 return false; 5391 break; 5392 5393 default: 5394 break; 5395 } 5396 } 5397 5398 switch (r_type) 5399 { 5400 /* This relocation describes the C++ object vtable hierarchy. 5401 Reconstruct it for later use during GC. */ 5402 case R_SH_GNU_VTINHERIT: 5403 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset)) 5404 return false; 5405 break; 5406 5407 /* This relocation describes which C++ vtable entries are actually 5408 used. Record for later use during GC. */ 5409 case R_SH_GNU_VTENTRY: 5410 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend)) 5411 return false; 5412 break; 5413 5414 case R_SH_TLS_IE_32: 5415 if (bfd_link_pic (info)) 5416 info->flags |= DF_STATIC_TLS; 5417 5418 /* FALLTHROUGH */ 5419 force_got: 5420 case R_SH_TLS_GD_32: 5421 case R_SH_GOT32: 5422 case R_SH_GOT20: 5423 case R_SH_GOTFUNCDESC: 5424 case R_SH_GOTFUNCDESC20: 5425 switch (r_type) 5426 { 5427 default: 5428 got_type = GOT_NORMAL; 5429 break; 5430 case R_SH_TLS_GD_32: 5431 got_type = GOT_TLS_GD; 5432 break; 5433 case R_SH_TLS_IE_32: 5434 got_type = GOT_TLS_IE; 5435 break; 5436 case R_SH_GOTFUNCDESC: 5437 case R_SH_GOTFUNCDESC20: 5438 got_type = GOT_FUNCDESC; 5439 break; 5440 } 5441 5442 if (h != NULL) 5443 { 5444 h->got.refcount += 1; 5445 old_got_type = sh_elf_hash_entry (h)->got_type; 5446 } 5447 else 5448 { 5449 bfd_signed_vma *local_got_refcounts; 5450 5451 /* This is a global offset table entry for a local 5452 symbol. */ 5453 local_got_refcounts = elf_local_got_refcounts (abfd); 5454 if (local_got_refcounts == NULL) 5455 { 5456 bfd_size_type size; 5457 5458 size = symtab_hdr->sh_info; 5459 size *= sizeof (bfd_signed_vma); 5460 size += symtab_hdr->sh_info; 5461 local_got_refcounts = ((bfd_signed_vma *) 5462 bfd_zalloc (abfd, size)); 5463 if (local_got_refcounts == NULL) 5464 return false; 5465 elf_local_got_refcounts (abfd) = local_got_refcounts; 5466 sh_elf_local_got_type (abfd) 5467 = (char *) (local_got_refcounts + symtab_hdr->sh_info); 5468 } 5469 local_got_refcounts[r_symndx] += 1; 5470 old_got_type = sh_elf_local_got_type (abfd) [r_symndx]; 5471 } 5472 5473 /* If a TLS symbol is accessed using IE at least once, 5474 there is no point to use dynamic model for it. */ 5475 if (old_got_type != got_type && old_got_type != GOT_UNKNOWN 5476 && (old_got_type != GOT_TLS_GD || got_type != GOT_TLS_IE)) 5477 { 5478 if (old_got_type == GOT_TLS_IE && got_type == GOT_TLS_GD) 5479 got_type = GOT_TLS_IE; 5480 else 5481 { 5482 if ((old_got_type == GOT_FUNCDESC || got_type == GOT_FUNCDESC) 5483 && (old_got_type == GOT_NORMAL || got_type == GOT_NORMAL)) 5484 _bfd_error_handler 5485 /* xgettext:c-format */ 5486 (_("%pB: `%s' accessed both as normal and FDPIC symbol"), 5487 abfd, h->root.root.string); 5488 else if (old_got_type == GOT_FUNCDESC 5489 || got_type == GOT_FUNCDESC) 5490 _bfd_error_handler 5491 /* xgettext:c-format */ 5492 (_("%pB: `%s' accessed both as FDPIC and thread local symbol"), 5493 abfd, h->root.root.string); 5494 else 5495 _bfd_error_handler 5496 /* xgettext:c-format */ 5497 (_("%pB: `%s' accessed both as normal and thread local symbol"), 5498 abfd, h->root.root.string); 5499 return false; 5500 } 5501 } 5502 5503 if (old_got_type != got_type) 5504 { 5505 if (h != NULL) 5506 sh_elf_hash_entry (h)->got_type = got_type; 5507 else 5508 sh_elf_local_got_type (abfd) [r_symndx] = got_type; 5509 } 5510 5511 break; 5512 5513 case R_SH_TLS_LD_32: 5514 sh_elf_hash_table(info)->tls_ldm_got.refcount += 1; 5515 break; 5516 5517 case R_SH_FUNCDESC: 5518 case R_SH_GOTOFFFUNCDESC: 5519 case R_SH_GOTOFFFUNCDESC20: 5520 if (rel->r_addend) 5521 { 5522 _bfd_error_handler 5523 (_("%pB: Function descriptor relocation with non-zero addend"), 5524 abfd); 5525 return false; 5526 } 5527 5528 if (h == NULL) 5529 { 5530 union gotref *local_funcdesc; 5531 5532 /* We need a function descriptor for a local symbol. */ 5533 local_funcdesc = sh_elf_local_funcdesc (abfd); 5534 if (local_funcdesc == NULL) 5535 { 5536 bfd_size_type size; 5537 5538 size = symtab_hdr->sh_info * sizeof (union gotref); 5539 local_funcdesc = (union gotref *) bfd_zalloc (abfd, size); 5540 if (local_funcdesc == NULL) 5541 return false; 5542 sh_elf_local_funcdesc (abfd) = local_funcdesc; 5543 } 5544 local_funcdesc[r_symndx].refcount += 1; 5545 5546 if (r_type == R_SH_FUNCDESC) 5547 { 5548 if (!bfd_link_pic (info)) 5549 htab->srofixup->size += 4; 5550 else 5551 htab->root.srelgot->size += sizeof (Elf32_External_Rela); 5552 } 5553 } 5554 else 5555 { 5556 sh_elf_hash_entry (h)->funcdesc.refcount++; 5557 if (r_type == R_SH_FUNCDESC) 5558 sh_elf_hash_entry (h)->abs_funcdesc_refcount++; 5559 5560 /* If there is a function descriptor reference, then 5561 there should not be any non-FDPIC references. */ 5562 old_got_type = sh_elf_hash_entry (h)->got_type; 5563 if (old_got_type != GOT_FUNCDESC && old_got_type != GOT_UNKNOWN) 5564 { 5565 if (old_got_type == GOT_NORMAL) 5566 _bfd_error_handler 5567 /* xgettext:c-format */ 5568 (_("%pB: `%s' accessed both as normal and FDPIC symbol"), 5569 abfd, h->root.root.string); 5570 else 5571 _bfd_error_handler 5572 /* xgettext:c-format */ 5573 (_("%pB: `%s' accessed both as FDPIC and thread local symbol"), 5574 abfd, h->root.root.string); 5575 } 5576 } 5577 break; 5578 5579 case R_SH_GOTPLT32: 5580 /* If this is a local symbol, we resolve it directly without 5581 creating a procedure linkage table entry. */ 5582 5583 if (h == NULL 5584 || h->forced_local 5585 || ! bfd_link_pic (info) 5586 || info->symbolic 5587 || h->dynindx == -1) 5588 goto force_got; 5589 5590 h->needs_plt = 1; 5591 h->plt.refcount += 1; 5592 ((struct elf_sh_link_hash_entry *) h)->gotplt_refcount += 1; 5593 5594 break; 5595 5596 case R_SH_PLT32: 5597 /* This symbol requires a procedure linkage table entry. We 5598 actually build the entry in adjust_dynamic_symbol, 5599 because this might be a case of linking PIC code which is 5600 never referenced by a dynamic object, in which case we 5601 don't need to generate a procedure linkage table entry 5602 after all. */ 5603 5604 /* If this is a local symbol, we resolve it directly without 5605 creating a procedure linkage table entry. */ 5606 if (h == NULL) 5607 continue; 5608 5609 if (h->forced_local) 5610 break; 5611 5612 h->needs_plt = 1; 5613 h->plt.refcount += 1; 5614 break; 5615 5616 case R_SH_DIR32: 5617 case R_SH_REL32: 5618 if (h != NULL && ! bfd_link_pic (info)) 5619 { 5620 h->non_got_ref = 1; 5621 h->plt.refcount += 1; 5622 } 5623 5624 /* If we are creating a shared library, and this is a reloc 5625 against a global symbol, or a non PC relative reloc 5626 against a local symbol, then we need to copy the reloc 5627 into the shared library. However, if we are linking with 5628 -Bsymbolic, we do not need to copy a reloc against a 5629 global symbol which is defined in an object we are 5630 including in the link (i.e., DEF_REGULAR is set). At 5631 this point we have not seen all the input files, so it is 5632 possible that DEF_REGULAR is not set now but will be set 5633 later (it is never cleared). We account for that 5634 possibility below by storing information in the 5635 dyn_relocs field of the hash table entry. A similar 5636 situation occurs when creating shared libraries and symbol 5637 visibility changes render the symbol local. 5638 5639 If on the other hand, we are creating an executable, we 5640 may need to keep relocations for symbols satisfied by a 5641 dynamic library if we manage to avoid copy relocs for the 5642 symbol. */ 5643 if ((bfd_link_pic (info) 5644 && (sec->flags & SEC_ALLOC) != 0 5645 && (r_type != R_SH_REL32 5646 || (h != NULL 5647 && (! info->symbolic 5648 || h->root.type == bfd_link_hash_defweak 5649 || !h->def_regular)))) 5650 || (! bfd_link_pic (info) 5651 && (sec->flags & SEC_ALLOC) != 0 5652 && h != NULL 5653 && (h->root.type == bfd_link_hash_defweak 5654 || !h->def_regular))) 5655 { 5656 struct elf_dyn_relocs *p; 5657 struct elf_dyn_relocs **head; 5658 5659 if (htab->root.dynobj == NULL) 5660 htab->root.dynobj = abfd; 5661 5662 /* When creating a shared object, we must copy these 5663 reloc types into the output file. We create a reloc 5664 section in dynobj and make room for this reloc. */ 5665 if (sreloc == NULL) 5666 { 5667 sreloc = _bfd_elf_make_dynamic_reloc_section 5668 (sec, htab->root.dynobj, 2, abfd, /*rela?*/ true); 5669 5670 if (sreloc == NULL) 5671 return false; 5672 } 5673 5674 /* If this is a global symbol, we count the number of 5675 relocations we need for this symbol. */ 5676 if (h != NULL) 5677 head = &h->dyn_relocs; 5678 else 5679 { 5680 /* Track dynamic relocs needed for local syms too. */ 5681 asection *s; 5682 void *vpp; 5683 Elf_Internal_Sym *isym; 5684 5685 isym = bfd_sym_from_r_symndx (&htab->root.sym_cache, 5686 abfd, r_symndx); 5687 if (isym == NULL) 5688 return false; 5689 5690 s = bfd_section_from_elf_index (abfd, isym->st_shndx); 5691 if (s == NULL) 5692 s = sec; 5693 5694 vpp = &elf_section_data (s)->local_dynrel; 5695 head = (struct elf_dyn_relocs **) vpp; 5696 } 5697 5698 p = *head; 5699 if (p == NULL || p->sec != sec) 5700 { 5701 size_t amt = sizeof (*p); 5702 p = bfd_alloc (htab->root.dynobj, amt); 5703 if (p == NULL) 5704 return false; 5705 p->next = *head; 5706 *head = p; 5707 p->sec = sec; 5708 p->count = 0; 5709 p->pc_count = 0; 5710 } 5711 5712 p->count += 1; 5713 if (r_type == R_SH_REL32) 5714 p->pc_count += 1; 5715 } 5716 5717 /* Allocate the fixup regardless of whether we need a relocation. 5718 If we end up generating the relocation, we'll unallocate the 5719 fixup. */ 5720 if (htab->fdpic_p && !bfd_link_pic (info) 5721 && r_type == R_SH_DIR32 5722 && (sec->flags & SEC_ALLOC) != 0) 5723 htab->srofixup->size += 4; 5724 break; 5725 5726 case R_SH_TLS_LE_32: 5727 if (bfd_link_dll (info)) 5728 { 5729 _bfd_error_handler 5730 (_("%pB: TLS local exec code cannot be linked into shared objects"), 5731 abfd); 5732 return false; 5733 } 5734 5735 break; 5736 5737 case R_SH_TLS_LDO_32: 5738 /* Nothing to do. */ 5739 break; 5740 5741 default: 5742 break; 5743 } 5744 } 5745 5746 return true; 5747 } 5748 5749 #ifndef sh_elf_set_mach_from_flags 5750 static unsigned int sh_ef_bfd_table[] = { EF_SH_BFD_TABLE }; 5751 5752 static bool 5753 sh_elf_set_mach_from_flags (bfd *abfd) 5754 { 5755 flagword flags = elf_elfheader (abfd)->e_flags & EF_SH_MACH_MASK; 5756 5757 if (flags >= ARRAY_SIZE (sh_ef_bfd_table)) 5758 return false; 5759 5760 if (sh_ef_bfd_table[flags] == 0) 5761 return false; 5762 5763 bfd_default_set_arch_mach (abfd, bfd_arch_sh, sh_ef_bfd_table[flags]); 5764 5765 return true; 5766 } 5767 5768 5769 /* Reverse table lookup for sh_ef_bfd_table[]. 5770 Given a bfd MACH value from archures.c 5771 return the equivalent ELF flags from the table. 5772 Return -1 if no match is found. */ 5773 5774 int 5775 sh_elf_get_flags_from_mach (unsigned long mach) 5776 { 5777 int i = ARRAY_SIZE (sh_ef_bfd_table) - 1; 5778 5779 for (; i>0; i--) 5780 if (sh_ef_bfd_table[i] == mach) 5781 return i; 5782 5783 /* shouldn't get here */ 5784 BFD_FAIL(); 5785 5786 return -1; 5787 } 5788 #endif /* not sh_elf_set_mach_from_flags */ 5789 5790 #ifndef sh_elf_copy_private_data 5791 /* Copy backend specific data from one object module to another */ 5792 5793 static bool 5794 sh_elf_copy_private_data (bfd * ibfd, bfd * obfd) 5795 { 5796 if (! is_sh_elf (ibfd) || ! is_sh_elf (obfd)) 5797 return true; 5798 5799 if (! _bfd_elf_copy_private_bfd_data (ibfd, obfd)) 5800 return false; 5801 5802 return sh_elf_set_mach_from_flags (obfd); 5803 } 5804 #endif /* not sh_elf_copy_private_data */ 5805 5806 #ifndef sh_elf_merge_private_data 5807 5808 /* This function returns the ELF architecture number that 5809 corresponds to the given arch_sh* flags. */ 5810 5811 int 5812 sh_find_elf_flags (unsigned int arch_set) 5813 { 5814 extern unsigned long sh_get_bfd_mach_from_arch_set (unsigned int); 5815 unsigned long bfd_mach = sh_get_bfd_mach_from_arch_set (arch_set); 5816 5817 return sh_elf_get_flags_from_mach (bfd_mach); 5818 } 5819 5820 /* Merge the architecture type of two BFD files, such that the 5821 resultant architecture supports all the features required 5822 by the two input BFDs. 5823 If the input BFDs are multually incompatible - i.e. one uses 5824 DSP while the other uses FPU - or there is no known architecture 5825 that fits the requirements then an error is emitted. */ 5826 5827 static bool 5828 sh_merge_bfd_arch (bfd *ibfd, struct bfd_link_info *info) 5829 { 5830 bfd *obfd = info->output_bfd; 5831 unsigned int old_arch, new_arch, merged_arch; 5832 5833 if (! _bfd_generic_verify_endian_match (ibfd, info)) 5834 return false; 5835 5836 old_arch = sh_get_arch_up_from_bfd_mach (bfd_get_mach (obfd)); 5837 new_arch = sh_get_arch_up_from_bfd_mach (bfd_get_mach (ibfd)); 5838 5839 merged_arch = SH_MERGE_ARCH_SET (old_arch, new_arch); 5840 5841 if (!SH_VALID_CO_ARCH_SET (merged_arch)) 5842 { 5843 _bfd_error_handler 5844 /* xgettext:c-format */ 5845 (_("%pB: uses %s instructions while previous modules " 5846 "use %s instructions"), 5847 ibfd, 5848 SH_ARCH_SET_HAS_DSP (new_arch) ? "dsp" : "floating point", 5849 SH_ARCH_SET_HAS_DSP (new_arch) ? "floating point" : "dsp"); 5850 bfd_set_error (bfd_error_bad_value); 5851 return false; 5852 } 5853 else if (!SH_VALID_ARCH_SET (merged_arch)) 5854 { 5855 _bfd_error_handler 5856 /* xgettext:c-format */ 5857 (_("internal error: merge of architecture '%s' with " 5858 "architecture '%s' produced unknown architecture"), 5859 bfd_printable_name (obfd), 5860 bfd_printable_name (ibfd)); 5861 bfd_set_error (bfd_error_bad_value); 5862 return false; 5863 } 5864 5865 bfd_default_set_arch_mach (obfd, bfd_arch_sh, 5866 sh_get_bfd_mach_from_arch_set (merged_arch)); 5867 5868 return true; 5869 } 5870 5871 /* This routine initialises the elf flags when required and 5872 calls sh_merge_bfd_arch() to check dsp/fpu compatibility. */ 5873 5874 static bool 5875 sh_elf_merge_private_data (bfd *ibfd, struct bfd_link_info *info) 5876 { 5877 bfd *obfd = info->output_bfd; 5878 5879 /* FIXME: What should be checked when linking shared libraries? */ 5880 if ((ibfd->flags & DYNAMIC) != 0) 5881 return true; 5882 5883 if (! is_sh_elf (ibfd) || ! is_sh_elf (obfd)) 5884 return true; 5885 5886 if (! elf_flags_init (obfd)) 5887 { 5888 /* This happens when ld starts out with a 'blank' output file. */ 5889 elf_flags_init (obfd) = true; 5890 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags; 5891 sh_elf_set_mach_from_flags (obfd); 5892 if (elf_elfheader (obfd)->e_flags & EF_SH_FDPIC) 5893 elf_elfheader (obfd)->e_flags &= ~EF_SH_PIC; 5894 } 5895 5896 if (! sh_merge_bfd_arch (ibfd, info)) 5897 { 5898 _bfd_error_handler (_("%pB: uses instructions which are incompatible " 5899 "with instructions used in previous modules"), 5900 ibfd); 5901 bfd_set_error (bfd_error_bad_value); 5902 return false; 5903 } 5904 5905 elf_elfheader (obfd)->e_flags &= ~EF_SH_MACH_MASK; 5906 elf_elfheader (obfd)->e_flags |= 5907 sh_elf_get_flags_from_mach (bfd_get_mach (obfd)); 5908 5909 if (fdpic_object_p (ibfd) != fdpic_object_p (obfd)) 5910 { 5911 _bfd_error_handler (_("%pB: attempt to mix FDPIC and non-FDPIC objects"), 5912 ibfd); 5913 bfd_set_error (bfd_error_bad_value); 5914 return false; 5915 } 5916 5917 return true; 5918 } 5919 #endif /* not sh_elf_merge_private_data */ 5920 5921 /* Override the generic function because we need to store sh_elf_obj_tdata 5922 as the specific tdata. We set also the machine architecture from flags 5923 here. */ 5924 5925 static bool 5926 sh_elf_object_p (bfd *abfd) 5927 { 5928 if (! sh_elf_set_mach_from_flags (abfd)) 5929 return false; 5930 5931 return (((elf_elfheader (abfd)->e_flags & EF_SH_FDPIC) != 0) 5932 == fdpic_object_p (abfd)); 5933 } 5934 5935 /* Finish up dynamic symbol handling. We set the contents of various 5936 dynamic sections here. */ 5937 5938 static bool 5939 sh_elf_finish_dynamic_symbol (bfd *output_bfd, struct bfd_link_info *info, 5940 struct elf_link_hash_entry *h, 5941 Elf_Internal_Sym *sym) 5942 { 5943 struct elf_sh_link_hash_table *htab; 5944 5945 htab = sh_elf_hash_table (info); 5946 if (htab == NULL) 5947 return false; 5948 5949 if (h->plt.offset != (bfd_vma) -1) 5950 { 5951 asection *splt; 5952 asection *sgotplt; 5953 asection *srelplt; 5954 5955 bfd_vma plt_index; 5956 bfd_vma got_offset; 5957 Elf_Internal_Rela rel; 5958 bfd_byte *loc; 5959 const struct elf_sh_plt_info *plt_info; 5960 5961 /* This symbol has an entry in the procedure linkage table. Set 5962 it up. */ 5963 5964 BFD_ASSERT (h->dynindx != -1); 5965 5966 splt = htab->root.splt; 5967 sgotplt = htab->root.sgotplt; 5968 srelplt = htab->root.srelplt; 5969 BFD_ASSERT (splt != NULL && sgotplt != NULL && srelplt != NULL); 5970 5971 /* Get the index in the procedure linkage table which 5972 corresponds to this symbol. This is the index of this symbol 5973 in all the symbols for which we are making plt entries. The 5974 first entry in the procedure linkage table is reserved. */ 5975 plt_index = get_plt_index (htab->plt_info, h->plt.offset); 5976 5977 plt_info = htab->plt_info; 5978 if (plt_info->short_plt != NULL && plt_index <= MAX_SHORT_PLT) 5979 plt_info = plt_info->short_plt; 5980 5981 /* Get the offset into the .got table of the entry that 5982 corresponds to this function. */ 5983 if (htab->fdpic_p) 5984 /* The offset must be relative to the GOT symbol, twelve bytes 5985 before the end of .got.plt. Each descriptor is eight 5986 bytes. */ 5987 got_offset = plt_index * 8 + 12 - sgotplt->size; 5988 else 5989 /* Each .got entry is 4 bytes. The first three are 5990 reserved. */ 5991 got_offset = (plt_index + 3) * 4; 5992 5993 #ifdef GOT_BIAS 5994 if (bfd_link_pic (info)) 5995 got_offset -= GOT_BIAS; 5996 #endif 5997 5998 /* Fill in the entry in the procedure linkage table. */ 5999 memcpy (splt->contents + h->plt.offset, 6000 plt_info->symbol_entry, 6001 plt_info->symbol_entry_size); 6002 6003 if (bfd_link_pic (info) || htab->fdpic_p) 6004 { 6005 if (plt_info->symbol_fields.got20) 6006 { 6007 bfd_reloc_status_type r; 6008 r = install_movi20_field (output_bfd, got_offset, 6009 splt->owner, splt, splt->contents, 6010 h->plt.offset 6011 + plt_info->symbol_fields.got_entry); 6012 BFD_ASSERT (r == bfd_reloc_ok); 6013 } 6014 else 6015 install_plt_field (output_bfd, false, got_offset, 6016 (splt->contents 6017 + h->plt.offset 6018 + plt_info->symbol_fields.got_entry)); 6019 } 6020 else 6021 { 6022 BFD_ASSERT (!plt_info->symbol_fields.got20); 6023 6024 install_plt_field (output_bfd, false, 6025 (sgotplt->output_section->vma 6026 + sgotplt->output_offset 6027 + got_offset), 6028 (splt->contents 6029 + h->plt.offset 6030 + plt_info->symbol_fields.got_entry)); 6031 if (htab->root.target_os == is_vxworks) 6032 { 6033 unsigned int reachable_plts, plts_per_4k; 6034 int distance; 6035 6036 /* Divide the PLT into groups. The first group contains 6037 REACHABLE_PLTS entries and the other groups contain 6038 PLTS_PER_4K entries. Entries in the first group can 6039 branch directly to .plt; those in later groups branch 6040 to the last element of the previous group. */ 6041 /* ??? It would be better to create multiple copies of 6042 the common resolver stub. */ 6043 reachable_plts = ((4096 6044 - plt_info->plt0_entry_size 6045 - (plt_info->symbol_fields.plt + 4)) 6046 / plt_info->symbol_entry_size) + 1; 6047 plts_per_4k = (4096 / plt_info->symbol_entry_size); 6048 if (plt_index < reachable_plts) 6049 distance = -(h->plt.offset 6050 + plt_info->symbol_fields.plt); 6051 else 6052 distance = -(((plt_index - reachable_plts) % plts_per_4k + 1) 6053 * plt_info->symbol_entry_size); 6054 6055 /* Install the 'bra' with this offset. */ 6056 bfd_put_16 (output_bfd, 6057 0xa000 | (0x0fff & ((distance - 4) / 2)), 6058 (splt->contents 6059 + h->plt.offset 6060 + plt_info->symbol_fields.plt)); 6061 } 6062 else 6063 install_plt_field (output_bfd, true, 6064 splt->output_section->vma + splt->output_offset, 6065 (splt->contents 6066 + h->plt.offset 6067 + plt_info->symbol_fields.plt)); 6068 } 6069 6070 /* Make got_offset relative to the start of .got.plt. */ 6071 #ifdef GOT_BIAS 6072 if (bfd_link_pic (info)) 6073 got_offset += GOT_BIAS; 6074 #endif 6075 if (htab->fdpic_p) 6076 got_offset = plt_index * 8; 6077 6078 if (plt_info->symbol_fields.reloc_offset != MINUS_ONE) 6079 install_plt_field (output_bfd, false, 6080 plt_index * sizeof (Elf32_External_Rela), 6081 (splt->contents 6082 + h->plt.offset 6083 + plt_info->symbol_fields.reloc_offset)); 6084 6085 /* Fill in the entry in the global offset table. */ 6086 bfd_put_32 (output_bfd, 6087 (splt->output_section->vma 6088 + splt->output_offset 6089 + h->plt.offset 6090 + plt_info->symbol_resolve_offset), 6091 sgotplt->contents + got_offset); 6092 if (htab->fdpic_p) 6093 bfd_put_32 (output_bfd, 6094 sh_elf_osec_to_segment (output_bfd, splt->output_section), 6095 sgotplt->contents + got_offset + 4); 6096 6097 /* Fill in the entry in the .rela.plt section. */ 6098 rel.r_offset = (sgotplt->output_section->vma 6099 + sgotplt->output_offset 6100 + got_offset); 6101 if (htab->fdpic_p) 6102 rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_FUNCDESC_VALUE); 6103 else 6104 rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_JMP_SLOT); 6105 rel.r_addend = 0; 6106 #ifdef GOT_BIAS 6107 rel.r_addend = GOT_BIAS; 6108 #endif 6109 loc = srelplt->contents + plt_index * sizeof (Elf32_External_Rela); 6110 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc); 6111 6112 if (htab->root.target_os == is_vxworks && !bfd_link_pic (info)) 6113 { 6114 /* Create the .rela.plt.unloaded relocations for this PLT entry. 6115 Begin by pointing LOC to the first such relocation. */ 6116 loc = (htab->srelplt2->contents 6117 + (plt_index * 2 + 1) * sizeof (Elf32_External_Rela)); 6118 6119 /* Create a .rela.plt.unloaded R_SH_DIR32 relocation 6120 for the PLT entry's pointer to the .got.plt entry. */ 6121 rel.r_offset = (splt->output_section->vma 6122 + splt->output_offset 6123 + h->plt.offset 6124 + plt_info->symbol_fields.got_entry); 6125 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_SH_DIR32); 6126 rel.r_addend = got_offset; 6127 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc); 6128 loc += sizeof (Elf32_External_Rela); 6129 6130 /* Create a .rela.plt.unloaded R_SH_DIR32 relocation for 6131 the .got.plt entry, which initially points to .plt. */ 6132 rel.r_offset = (sgotplt->output_section->vma 6133 + sgotplt->output_offset 6134 + got_offset); 6135 rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_SH_DIR32); 6136 rel.r_addend = 0; 6137 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc); 6138 } 6139 6140 if (!h->def_regular) 6141 { 6142 /* Mark the symbol as undefined, rather than as defined in 6143 the .plt section. Leave the value alone. */ 6144 sym->st_shndx = SHN_UNDEF; 6145 } 6146 } 6147 6148 if (h->got.offset != (bfd_vma) -1 6149 && sh_elf_hash_entry (h)->got_type != GOT_TLS_GD 6150 && sh_elf_hash_entry (h)->got_type != GOT_TLS_IE 6151 && sh_elf_hash_entry (h)->got_type != GOT_FUNCDESC) 6152 { 6153 asection *sgot; 6154 asection *srelgot; 6155 Elf_Internal_Rela rel; 6156 bfd_byte *loc; 6157 6158 /* This symbol has an entry in the global offset table. Set it 6159 up. */ 6160 6161 sgot = htab->root.sgot; 6162 srelgot = htab->root.srelgot; 6163 BFD_ASSERT (sgot != NULL && srelgot != NULL); 6164 6165 rel.r_offset = (sgot->output_section->vma 6166 + sgot->output_offset 6167 + (h->got.offset &~ (bfd_vma) 1)); 6168 6169 /* If this is a static link, or it is a -Bsymbolic link and the 6170 symbol is defined locally or was forced to be local because 6171 of a version file, we just want to emit a RELATIVE reloc. 6172 The entry in the global offset table will already have been 6173 initialized in the relocate_section function. */ 6174 if (bfd_link_pic (info) 6175 && SYMBOL_REFERENCES_LOCAL (info, h)) 6176 { 6177 if (htab->fdpic_p) 6178 { 6179 asection *sec = h->root.u.def.section; 6180 int dynindx 6181 = elf_section_data (sec->output_section)->dynindx; 6182 6183 rel.r_info = ELF32_R_INFO (dynindx, R_SH_DIR32); 6184 rel.r_addend = (h->root.u.def.value 6185 + h->root.u.def.section->output_offset); 6186 } 6187 else 6188 { 6189 rel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE); 6190 rel.r_addend = (h->root.u.def.value 6191 + h->root.u.def.section->output_section->vma 6192 + h->root.u.def.section->output_offset); 6193 } 6194 } 6195 else 6196 { 6197 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset); 6198 rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_GLOB_DAT); 6199 rel.r_addend = 0; 6200 } 6201 6202 loc = srelgot->contents; 6203 loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela); 6204 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc); 6205 } 6206 6207 if (h->needs_copy) 6208 { 6209 asection *s; 6210 Elf_Internal_Rela rel; 6211 bfd_byte *loc; 6212 6213 /* This symbol needs a copy reloc. Set it up. */ 6214 6215 BFD_ASSERT (h->dynindx != -1 6216 && (h->root.type == bfd_link_hash_defined 6217 || h->root.type == bfd_link_hash_defweak)); 6218 6219 s = bfd_get_linker_section (htab->root.dynobj, ".rela.bss"); 6220 BFD_ASSERT (s != NULL); 6221 6222 rel.r_offset = (h->root.u.def.value 6223 + h->root.u.def.section->output_section->vma 6224 + h->root.u.def.section->output_offset); 6225 rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_COPY); 6226 rel.r_addend = 0; 6227 loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela); 6228 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc); 6229 } 6230 6231 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. On VxWorks, 6232 _GLOBAL_OFFSET_TABLE_ is not absolute: it is relative to the 6233 ".got" section. */ 6234 if (h == htab->root.hdynamic 6235 || (htab->root.target_os != is_vxworks && h == htab->root.hgot)) 6236 sym->st_shndx = SHN_ABS; 6237 6238 return true; 6239 } 6240 6241 /* Finish up the dynamic sections. */ 6242 6243 static bool 6244 sh_elf_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info) 6245 { 6246 struct elf_sh_link_hash_table *htab; 6247 asection *sgotplt; 6248 asection *sdyn; 6249 6250 htab = sh_elf_hash_table (info); 6251 if (htab == NULL) 6252 return false; 6253 6254 sgotplt = htab->root.sgotplt; 6255 sdyn = bfd_get_linker_section (htab->root.dynobj, ".dynamic"); 6256 6257 if (htab->root.dynamic_sections_created) 6258 { 6259 asection *splt; 6260 Elf32_External_Dyn *dyncon, *dynconend; 6261 6262 BFD_ASSERT (sgotplt != NULL && sdyn != NULL); 6263 6264 dyncon = (Elf32_External_Dyn *) sdyn->contents; 6265 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size); 6266 for (; dyncon < dynconend; dyncon++) 6267 { 6268 Elf_Internal_Dyn dyn; 6269 asection *s; 6270 6271 bfd_elf32_swap_dyn_in (htab->root.dynobj, dyncon, &dyn); 6272 6273 switch (dyn.d_tag) 6274 { 6275 default: 6276 if (htab->root.target_os == is_vxworks 6277 && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn)) 6278 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 6279 break; 6280 6281 case DT_PLTGOT: 6282 BFD_ASSERT (htab->root.hgot != NULL); 6283 s = htab->root.hgot->root.u.def.section; 6284 dyn.d_un.d_ptr = htab->root.hgot->root.u.def.value 6285 + s->output_section->vma + s->output_offset; 6286 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 6287 break; 6288 6289 case DT_JMPREL: 6290 s = htab->root.srelplt->output_section; 6291 BFD_ASSERT (s != NULL); 6292 dyn.d_un.d_ptr = s->vma; 6293 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 6294 break; 6295 6296 case DT_PLTRELSZ: 6297 s = htab->root.srelplt->output_section; 6298 BFD_ASSERT (s != NULL); 6299 dyn.d_un.d_val = s->size; 6300 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 6301 break; 6302 } 6303 } 6304 6305 /* Fill in the first entry in the procedure linkage table. */ 6306 splt = htab->root.splt; 6307 if (splt && splt->size > 0 && htab->plt_info->plt0_entry) 6308 { 6309 unsigned int i; 6310 6311 memcpy (splt->contents, 6312 htab->plt_info->plt0_entry, 6313 htab->plt_info->plt0_entry_size); 6314 for (i = 0; i < ARRAY_SIZE (htab->plt_info->plt0_got_fields); i++) 6315 if (htab->plt_info->plt0_got_fields[i] != MINUS_ONE) 6316 install_plt_field (output_bfd, false, 6317 (sgotplt->output_section->vma 6318 + sgotplt->output_offset 6319 + (i * 4)), 6320 (splt->contents 6321 + htab->plt_info->plt0_got_fields[i])); 6322 6323 if (htab->root.target_os == is_vxworks) 6324 { 6325 /* Finalize the .rela.plt.unloaded contents. */ 6326 Elf_Internal_Rela rel; 6327 bfd_byte *loc; 6328 6329 /* Create a .rela.plt.unloaded R_SH_DIR32 relocation for the 6330 first PLT entry's pointer to _GLOBAL_OFFSET_TABLE_ + 8. */ 6331 loc = htab->srelplt2->contents; 6332 rel.r_offset = (splt->output_section->vma 6333 + splt->output_offset 6334 + htab->plt_info->plt0_got_fields[2]); 6335 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_SH_DIR32); 6336 rel.r_addend = 8; 6337 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc); 6338 loc += sizeof (Elf32_External_Rela); 6339 6340 /* Fix up the remaining .rela.plt.unloaded relocations. 6341 They may have the wrong symbol index for _G_O_T_ or 6342 _P_L_T_ depending on the order in which symbols were 6343 output. */ 6344 while (loc < htab->srelplt2->contents + htab->srelplt2->size) 6345 { 6346 /* The PLT entry's pointer to the .got.plt slot. */ 6347 bfd_elf32_swap_reloc_in (output_bfd, loc, &rel); 6348 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, 6349 R_SH_DIR32); 6350 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc); 6351 loc += sizeof (Elf32_External_Rela); 6352 6353 /* The .got.plt slot's pointer to .plt. */ 6354 bfd_elf32_swap_reloc_in (output_bfd, loc, &rel); 6355 rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, 6356 R_SH_DIR32); 6357 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc); 6358 loc += sizeof (Elf32_External_Rela); 6359 } 6360 } 6361 6362 /* UnixWare sets the entsize of .plt to 4, although that doesn't 6363 really seem like the right value. */ 6364 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4; 6365 } 6366 } 6367 6368 /* Fill in the first three entries in the global offset table. */ 6369 if (sgotplt && sgotplt->size > 0 && !htab->fdpic_p) 6370 { 6371 if (sdyn == NULL) 6372 bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents); 6373 else 6374 bfd_put_32 (output_bfd, 6375 sdyn->output_section->vma + sdyn->output_offset, 6376 sgotplt->contents); 6377 bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents + 4); 6378 bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents + 8); 6379 } 6380 6381 if (sgotplt && sgotplt->size > 0) 6382 elf_section_data (sgotplt->output_section)->this_hdr.sh_entsize = 4; 6383 6384 /* At the very end of the .rofixup section is a pointer to the GOT. */ 6385 if (htab->fdpic_p && htab->srofixup != NULL) 6386 { 6387 struct elf_link_hash_entry *hgot = htab->root.hgot; 6388 bfd_vma got_value = hgot->root.u.def.value 6389 + hgot->root.u.def.section->output_section->vma 6390 + hgot->root.u.def.section->output_offset; 6391 6392 sh_elf_add_rofixup (output_bfd, htab->srofixup, got_value); 6393 6394 /* Make sure we allocated and generated the same number of fixups. */ 6395 BFD_ASSERT (htab->srofixup->reloc_count * 4 == htab->srofixup->size); 6396 } 6397 6398 if (htab->srelfuncdesc) 6399 BFD_ASSERT (htab->srelfuncdesc->reloc_count * sizeof (Elf32_External_Rela) 6400 == htab->srelfuncdesc->size); 6401 6402 if (htab->root.srelgot) 6403 BFD_ASSERT (htab->root.srelgot->reloc_count * sizeof (Elf32_External_Rela) 6404 == htab->root.srelgot->size); 6405 6406 return true; 6407 } 6408 6409 static enum elf_reloc_type_class 6410 sh_elf_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED, 6411 const asection *rel_sec ATTRIBUTE_UNUSED, 6412 const Elf_Internal_Rela *rela) 6413 { 6414 switch ((int) ELF32_R_TYPE (rela->r_info)) 6415 { 6416 case R_SH_RELATIVE: 6417 return reloc_class_relative; 6418 case R_SH_JMP_SLOT: 6419 return reloc_class_plt; 6420 case R_SH_COPY: 6421 return reloc_class_copy; 6422 default: 6423 return reloc_class_normal; 6424 } 6425 } 6426 6427 #if !defined SH_TARGET_ALREADY_DEFINED 6428 /* Support for Linux core dump NOTE sections. */ 6429 6430 static bool 6431 elf32_shlin_grok_prstatus (bfd *abfd, Elf_Internal_Note *note) 6432 { 6433 int offset; 6434 unsigned int size; 6435 6436 switch (note->descsz) 6437 { 6438 default: 6439 return false; 6440 6441 case 168: /* Linux/SH */ 6442 /* pr_cursig */ 6443 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12); 6444 6445 /* pr_pid */ 6446 elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24); 6447 6448 /* pr_reg */ 6449 offset = 72; 6450 size = 92; 6451 6452 break; 6453 } 6454 6455 /* Make a ".reg/999" section. */ 6456 return _bfd_elfcore_make_pseudosection (abfd, ".reg", 6457 size, note->descpos + offset); 6458 } 6459 6460 static bool 6461 elf32_shlin_grok_psinfo (bfd *abfd, Elf_Internal_Note *note) 6462 { 6463 switch (note->descsz) 6464 { 6465 default: 6466 return false; 6467 6468 case 124: /* Linux/SH elf_prpsinfo */ 6469 elf_tdata (abfd)->core->program 6470 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16); 6471 elf_tdata (abfd)->core->command 6472 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80); 6473 } 6474 6475 /* Note that for some reason, a spurious space is tacked 6476 onto the end of the args in some (at least one anyway) 6477 implementations, so strip it off if it exists. */ 6478 6479 { 6480 char *command = elf_tdata (abfd)->core->command; 6481 int n = strlen (command); 6482 6483 if (0 < n && command[n - 1] == ' ') 6484 command[n - 1] = '\0'; 6485 } 6486 6487 return true; 6488 } 6489 #endif /* not SH_TARGET_ALREADY_DEFINED */ 6490 6491 6492 /* Return address for Ith PLT stub in section PLT, for relocation REL 6493 or (bfd_vma) -1 if it should not be included. */ 6494 6495 static bfd_vma 6496 sh_elf_plt_sym_val (bfd_vma i, const asection *plt, 6497 const arelent *rel ATTRIBUTE_UNUSED) 6498 { 6499 const struct elf_sh_plt_info *plt_info; 6500 6501 plt_info = get_plt_info (plt->owner, (plt->owner->flags & DYNAMIC) != 0); 6502 return plt->vma + get_plt_offset (plt_info, i); 6503 } 6504 6505 /* Decide whether to attempt to turn absptr or lsda encodings in 6506 shared libraries into pcrel within the given input section. */ 6507 6508 static bool 6509 sh_elf_use_relative_eh_frame (bfd *input_bfd ATTRIBUTE_UNUSED, 6510 struct bfd_link_info *info, 6511 asection *eh_frame_section ATTRIBUTE_UNUSED) 6512 { 6513 struct elf_sh_link_hash_table *htab = sh_elf_hash_table (info); 6514 6515 /* We can't use PC-relative encodings in FDPIC binaries, in general. */ 6516 if (htab->fdpic_p) 6517 return false; 6518 6519 return true; 6520 } 6521 6522 /* Adjust the contents of an eh_frame_hdr section before they're output. */ 6523 6524 static bfd_byte 6525 sh_elf_encode_eh_address (bfd *abfd, 6526 struct bfd_link_info *info, 6527 asection *osec, bfd_vma offset, 6528 asection *loc_sec, bfd_vma loc_offset, 6529 bfd_vma *encoded) 6530 { 6531 struct elf_sh_link_hash_table *htab = sh_elf_hash_table (info); 6532 struct elf_link_hash_entry *h; 6533 6534 if (!htab->fdpic_p) 6535 return _bfd_elf_encode_eh_address (abfd, info, osec, offset, loc_sec, 6536 loc_offset, encoded); 6537 6538 h = htab->root.hgot; 6539 BFD_ASSERT (h && h->root.type == bfd_link_hash_defined); 6540 6541 if (! h || (sh_elf_osec_to_segment (abfd, osec) 6542 == sh_elf_osec_to_segment (abfd, loc_sec->output_section))) 6543 return _bfd_elf_encode_eh_address (abfd, info, osec, offset, 6544 loc_sec, loc_offset, encoded); 6545 6546 BFD_ASSERT (sh_elf_osec_to_segment (abfd, osec) 6547 == (sh_elf_osec_to_segment 6548 (abfd, h->root.u.def.section->output_section))); 6549 6550 *encoded = osec->vma + offset 6551 - (h->root.u.def.value 6552 + h->root.u.def.section->output_section->vma 6553 + h->root.u.def.section->output_offset); 6554 6555 return DW_EH_PE_datarel | DW_EH_PE_sdata4; 6556 } 6557 6558 #if !defined SH_TARGET_ALREADY_DEFINED 6559 #define TARGET_BIG_SYM sh_elf32_vec 6560 #define TARGET_BIG_NAME "elf32-sh" 6561 #define TARGET_LITTLE_SYM sh_elf32_le_vec 6562 #define TARGET_LITTLE_NAME "elf32-shl" 6563 #endif 6564 6565 #define ELF_ARCH bfd_arch_sh 6566 #define ELF_TARGET_ID SH_ELF_DATA 6567 #define ELF_MACHINE_CODE EM_SH 6568 #ifdef __QNXTARGET__ 6569 #define ELF_MAXPAGESIZE 0x1000 6570 #else 6571 #define ELF_MAXPAGESIZE 0x80 6572 #endif 6573 6574 #define elf_symbol_leading_char '_' 6575 6576 #define bfd_elf32_bfd_reloc_type_lookup sh_elf_reloc_type_lookup 6577 #define bfd_elf32_bfd_reloc_name_lookup \ 6578 sh_elf_reloc_name_lookup 6579 #define elf_info_to_howto sh_elf_info_to_howto 6580 #define bfd_elf32_bfd_relax_section sh_elf_relax_section 6581 #define elf_backend_relocate_section sh_elf_relocate_section 6582 #define bfd_elf32_bfd_get_relocated_section_contents \ 6583 sh_elf_get_relocated_section_contents 6584 #define bfd_elf32_mkobject sh_elf_mkobject 6585 #define elf_backend_object_p sh_elf_object_p 6586 #define bfd_elf32_bfd_copy_private_bfd_data \ 6587 sh_elf_copy_private_data 6588 #define bfd_elf32_bfd_merge_private_bfd_data \ 6589 sh_elf_merge_private_data 6590 6591 #define elf_backend_gc_mark_hook sh_elf_gc_mark_hook 6592 #define elf_backend_check_relocs sh_elf_check_relocs 6593 #define elf_backend_copy_indirect_symbol \ 6594 sh_elf_copy_indirect_symbol 6595 #define elf_backend_create_dynamic_sections \ 6596 sh_elf_create_dynamic_sections 6597 #define bfd_elf32_bfd_link_hash_table_create \ 6598 sh_elf_link_hash_table_create 6599 #define elf_backend_adjust_dynamic_symbol \ 6600 sh_elf_adjust_dynamic_symbol 6601 #define elf_backend_always_size_sections \ 6602 sh_elf_always_size_sections 6603 #define elf_backend_size_dynamic_sections \ 6604 sh_elf_size_dynamic_sections 6605 #define elf_backend_omit_section_dynsym sh_elf_omit_section_dynsym 6606 #define elf_backend_finish_dynamic_symbol \ 6607 sh_elf_finish_dynamic_symbol 6608 #define elf_backend_finish_dynamic_sections \ 6609 sh_elf_finish_dynamic_sections 6610 #define elf_backend_reloc_type_class sh_elf_reloc_type_class 6611 #define elf_backend_plt_sym_val sh_elf_plt_sym_val 6612 #define elf_backend_can_make_relative_eh_frame \ 6613 sh_elf_use_relative_eh_frame 6614 #define elf_backend_can_make_lsda_relative_eh_frame \ 6615 sh_elf_use_relative_eh_frame 6616 #define elf_backend_encode_eh_address \ 6617 sh_elf_encode_eh_address 6618 6619 #define elf_backend_stack_align 8 6620 #define elf_backend_can_gc_sections 1 6621 #define elf_backend_can_refcount 1 6622 #define elf_backend_want_got_plt 1 6623 #define elf_backend_plt_readonly 1 6624 #define elf_backend_want_plt_sym 0 6625 #define elf_backend_got_header_size 12 6626 #define elf_backend_dtrel_excludes_plt 1 6627 6628 #define elf_backend_linux_prpsinfo32_ugid16 true 6629 6630 #if !defined SH_TARGET_ALREADY_DEFINED 6631 6632 #include "elf32-target.h" 6633 6634 /* NetBSD support. */ 6635 #undef TARGET_BIG_SYM 6636 #define TARGET_BIG_SYM sh_elf32_nbsd_vec 6637 #undef TARGET_BIG_NAME 6638 #define TARGET_BIG_NAME "elf32-sh-nbsd" 6639 #undef TARGET_LITTLE_SYM 6640 #define TARGET_LITTLE_SYM sh_elf32_nbsd_le_vec 6641 #undef TARGET_LITTLE_NAME 6642 #define TARGET_LITTLE_NAME "elf32-shl-nbsd" 6643 #undef ELF_MAXPAGESIZE 6644 #define ELF_MAXPAGESIZE 0x10000 6645 #undef ELF_COMMONPAGESIZE 6646 #undef elf_symbol_leading_char 6647 #define elf_symbol_leading_char 0 6648 #undef elf32_bed 6649 #define elf32_bed elf32_sh_nbsd_bed 6650 6651 #include "elf32-target.h" 6652 6653 6654 /* Linux support. */ 6655 #undef TARGET_BIG_SYM 6656 #define TARGET_BIG_SYM sh_elf32_linux_be_vec 6657 #undef TARGET_BIG_NAME 6658 #define TARGET_BIG_NAME "elf32-shbig-linux" 6659 #undef TARGET_LITTLE_SYM 6660 #define TARGET_LITTLE_SYM sh_elf32_linux_vec 6661 #undef TARGET_LITTLE_NAME 6662 #define TARGET_LITTLE_NAME "elf32-sh-linux" 6663 #undef ELF_COMMONPAGESIZE 6664 #define ELF_COMMONPAGESIZE 0x1000 6665 6666 #undef elf_backend_grok_prstatus 6667 #define elf_backend_grok_prstatus elf32_shlin_grok_prstatus 6668 #undef elf_backend_grok_psinfo 6669 #define elf_backend_grok_psinfo elf32_shlin_grok_psinfo 6670 #undef elf32_bed 6671 #define elf32_bed elf32_sh_lin_bed 6672 6673 #include "elf32-target.h" 6674 6675 6676 /* FDPIC support. */ 6677 #undef TARGET_BIG_SYM 6678 #define TARGET_BIG_SYM sh_elf32_fdpic_be_vec 6679 #undef TARGET_BIG_NAME 6680 #define TARGET_BIG_NAME "elf32-shbig-fdpic" 6681 #undef TARGET_LITTLE_SYM 6682 #define TARGET_LITTLE_SYM sh_elf32_fdpic_le_vec 6683 #undef TARGET_LITTLE_NAME 6684 #define TARGET_LITTLE_NAME "elf32-sh-fdpic" 6685 6686 #undef elf32_bed 6687 #define elf32_bed elf32_sh_fd_bed 6688 6689 #include "elf32-target.h" 6690 6691 /* VxWorks support. */ 6692 #undef TARGET_BIG_SYM 6693 #define TARGET_BIG_SYM sh_elf32_vxworks_vec 6694 #undef TARGET_BIG_NAME 6695 #define TARGET_BIG_NAME "elf32-sh-vxworks" 6696 #undef TARGET_LITTLE_SYM 6697 #define TARGET_LITTLE_SYM sh_elf32_vxworks_le_vec 6698 #undef TARGET_LITTLE_NAME 6699 #define TARGET_LITTLE_NAME "elf32-shl-vxworks" 6700 #undef elf32_bed 6701 #define elf32_bed elf32_sh_vxworks_bed 6702 6703 #undef elf_backend_want_plt_sym 6704 #define elf_backend_want_plt_sym 1 6705 #undef elf_symbol_leading_char 6706 #define elf_symbol_leading_char '_' 6707 #define elf_backend_want_got_underscore 1 6708 #undef elf_backend_grok_prstatus 6709 #undef elf_backend_grok_psinfo 6710 #undef elf_backend_add_symbol_hook 6711 #define elf_backend_add_symbol_hook elf_vxworks_add_symbol_hook 6712 #undef elf_backend_link_output_symbol_hook 6713 #define elf_backend_link_output_symbol_hook \ 6714 elf_vxworks_link_output_symbol_hook 6715 #undef elf_backend_emit_relocs 6716 #define elf_backend_emit_relocs elf_vxworks_emit_relocs 6717 #undef elf_backend_final_write_processing 6718 #define elf_backend_final_write_processing \ 6719 elf_vxworks_final_write_processing 6720 #undef ELF_MAXPAGESIZE 6721 #define ELF_MAXPAGESIZE 0x1000 6722 #undef ELF_COMMONPAGESIZE 6723 6724 #undef ELF_TARGET_OS 6725 #define ELF_TARGET_OS is_vxworks 6726 6727 #include "elf32-target.h" 6728 6729 #endif /* not SH_TARGET_ALREADY_DEFINED */ 6730