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