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