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