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