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 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->type == STT_GNU_IFUNC 2812 || h->u.weakdef != NULL 2813 || (h->def_dynamic 2814 && h->ref_regular 2815 && !h->def_regular))); 2816 2817 /* If this is a function, put it in the procedure linkage table. We 2818 will fill in the contents of the procedure linkage table later, 2819 when we know the address of the .got section. */ 2820 if ((h->type == STT_FUNC || h->type == STT_GNU_IFUNC) 2821 || h->needs_plt) 2822 { 2823 if (h->plt.refcount <= 0 2824 || SYMBOL_CALLS_LOCAL (info, h) 2825 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT 2826 && h->root.type == bfd_link_hash_undefweak)) 2827 { 2828 /* This case can occur if we saw a PLT reloc in an input 2829 file, but the symbol was never referred to by a dynamic 2830 object. In such a case, we don't actually need to build 2831 a procedure linkage table, and we can just do a REL32 2832 reloc instead. */ 2833 h->plt.offset = (bfd_vma) -1; 2834 h->needs_plt = 0; 2835 } 2836 2837 return TRUE; 2838 } 2839 else 2840 h->plt.offset = (bfd_vma) -1; 2841 2842 /* If this is a weak symbol, and there is a real definition, the 2843 processor independent code will have arranged for us to see the 2844 real definition first, and we can just use the same value. */ 2845 if (h->u.weakdef != NULL) 2846 { 2847 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined 2848 || h->u.weakdef->root.type == bfd_link_hash_defweak); 2849 h->root.u.def.section = h->u.weakdef->root.u.def.section; 2850 h->root.u.def.value = h->u.weakdef->root.u.def.value; 2851 if (info->nocopyreloc) 2852 h->non_got_ref = h->u.weakdef->non_got_ref; 2853 return TRUE; 2854 } 2855 2856 /* This is a reference to a symbol defined by a dynamic object which 2857 is not a function. */ 2858 2859 /* If we are creating a shared library, we must presume that the 2860 only references to the symbol are via the global offset table. 2861 For such cases we need not do anything here; the relocations will 2862 be handled correctly by relocate_section. */ 2863 if (info->shared) 2864 return TRUE; 2865 2866 /* If there are no references to this symbol that do not use the 2867 GOT, we don't need to generate a copy reloc. */ 2868 if (!h->non_got_ref) 2869 return TRUE; 2870 2871 /* If -z nocopyreloc was given, we won't generate them either. */ 2872 if (info->nocopyreloc) 2873 { 2874 h->non_got_ref = 0; 2875 return TRUE; 2876 } 2877 2878 eh = (struct elf_sh_link_hash_entry *) h; 2879 for (p = eh->dyn_relocs; p != NULL; p = p->next) 2880 { 2881 s = p->sec->output_section; 2882 if (s != NULL && (s->flags & (SEC_READONLY | SEC_HAS_CONTENTS)) != 0) 2883 break; 2884 } 2885 2886 /* If we didn't find any dynamic relocs in sections which needs the 2887 copy reloc, then we'll be keeping the dynamic relocs and avoiding 2888 the copy reloc. */ 2889 if (p == NULL) 2890 { 2891 h->non_got_ref = 0; 2892 return TRUE; 2893 } 2894 2895 /* We must allocate the symbol in our .dynbss section, which will 2896 become part of the .bss section of the executable. There will be 2897 an entry for this symbol in the .dynsym section. The dynamic 2898 object will contain position independent code, so all references 2899 from the dynamic object to this symbol will go through the global 2900 offset table. The dynamic linker will use the .dynsym entry to 2901 determine the address it must put in the global offset table, so 2902 both the dynamic object and the regular object will refer to the 2903 same memory location for the variable. */ 2904 2905 s = htab->sdynbss; 2906 BFD_ASSERT (s != NULL); 2907 2908 /* We must generate a R_SH_COPY reloc to tell the dynamic linker to 2909 copy the initial value out of the dynamic object and into the 2910 runtime process image. We need to remember the offset into the 2911 .rela.bss section we are going to use. */ 2912 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0) 2913 { 2914 asection *srel; 2915 2916 srel = htab->srelbss; 2917 BFD_ASSERT (srel != NULL); 2918 srel->size += sizeof (Elf32_External_Rela); 2919 h->needs_copy = 1; 2920 } 2921 2922 return _bfd_elf_adjust_dynamic_copy (h, s); 2923 } 2924 2925 /* Allocate space in .plt, .got and associated reloc sections for 2926 dynamic relocs. */ 2927 2928 static bfd_boolean 2929 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf) 2930 { 2931 struct bfd_link_info *info; 2932 struct elf_sh_link_hash_table *htab; 2933 struct elf_sh_link_hash_entry *eh; 2934 struct elf_sh_dyn_relocs *p; 2935 2936 if (h->root.type == bfd_link_hash_indirect) 2937 return TRUE; 2938 2939 info = (struct bfd_link_info *) inf; 2940 htab = sh_elf_hash_table (info); 2941 if (htab == NULL) 2942 return FALSE; 2943 2944 eh = (struct elf_sh_link_hash_entry *) h; 2945 if ((h->got.refcount > 0 2946 || h->forced_local) 2947 && eh->gotplt_refcount > 0) 2948 { 2949 /* The symbol has been forced local, or we have some direct got refs, 2950 so treat all the gotplt refs as got refs. */ 2951 h->got.refcount += eh->gotplt_refcount; 2952 if (h->plt.refcount >= eh->gotplt_refcount) 2953 h->plt.refcount -= eh->gotplt_refcount; 2954 } 2955 2956 if (htab->root.dynamic_sections_created 2957 && h->plt.refcount > 0 2958 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT 2959 || h->root.type != bfd_link_hash_undefweak)) 2960 { 2961 /* Make sure this symbol is output as a dynamic symbol. 2962 Undefined weak syms won't yet be marked as dynamic. */ 2963 if (h->dynindx == -1 2964 && !h->forced_local) 2965 { 2966 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 2967 return FALSE; 2968 } 2969 2970 if (info->shared 2971 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h)) 2972 { 2973 asection *s = htab->splt; 2974 const struct elf_sh_plt_info *plt_info; 2975 2976 /* If this is the first .plt entry, make room for the special 2977 first entry. */ 2978 if (s->size == 0) 2979 s->size += htab->plt_info->plt0_entry_size; 2980 2981 h->plt.offset = s->size; 2982 2983 /* If this symbol is not defined in a regular file, and we are 2984 not generating a shared library, then set the symbol to this 2985 location in the .plt. This is required to make function 2986 pointers compare as equal between the normal executable and 2987 the shared library. Skip this for FDPIC, since the 2988 function's address will be the address of the canonical 2989 function descriptor. */ 2990 if (!htab->fdpic_p && !info->shared && !h->def_regular) 2991 { 2992 h->root.u.def.section = s; 2993 h->root.u.def.value = h->plt.offset; 2994 } 2995 2996 /* Make room for this entry. */ 2997 plt_info = htab->plt_info; 2998 if (plt_info->short_plt != NULL 2999 && (get_plt_index (plt_info->short_plt, s->size) < MAX_SHORT_PLT)) 3000 plt_info = plt_info->short_plt; 3001 s->size += plt_info->symbol_entry_size; 3002 3003 /* We also need to make an entry in the .got.plt section, which 3004 will be placed in the .got section by the linker script. */ 3005 if (!htab->fdpic_p) 3006 htab->sgotplt->size += 4; 3007 else 3008 htab->sgotplt->size += 8; 3009 3010 /* We also need to make an entry in the .rel.plt section. */ 3011 htab->srelplt->size += sizeof (Elf32_External_Rela); 3012 3013 if (htab->vxworks_p && !info->shared) 3014 { 3015 /* VxWorks executables have a second set of relocations 3016 for each PLT entry. They go in a separate relocation 3017 section, which is processed by the kernel loader. */ 3018 3019 /* There is a relocation for the initial PLT entry: 3020 an R_SH_DIR32 relocation for _GLOBAL_OFFSET_TABLE_. */ 3021 if (h->plt.offset == htab->plt_info->plt0_entry_size) 3022 htab->srelplt2->size += sizeof (Elf32_External_Rela); 3023 3024 /* There are two extra relocations for each subsequent 3025 PLT entry: an R_SH_DIR32 relocation for the GOT entry, 3026 and an R_SH_DIR32 relocation for the PLT entry. */ 3027 htab->srelplt2->size += sizeof (Elf32_External_Rela) * 2; 3028 } 3029 } 3030 else 3031 { 3032 h->plt.offset = (bfd_vma) -1; 3033 h->needs_plt = 0; 3034 } 3035 } 3036 else 3037 { 3038 h->plt.offset = (bfd_vma) -1; 3039 h->needs_plt = 0; 3040 } 3041 3042 if (h->got.refcount > 0) 3043 { 3044 asection *s; 3045 bfd_boolean dyn; 3046 enum got_type got_type = sh_elf_hash_entry (h)->got_type; 3047 3048 /* Make sure this symbol is output as a dynamic symbol. 3049 Undefined weak syms won't yet be marked as dynamic. */ 3050 if (h->dynindx == -1 3051 && !h->forced_local) 3052 { 3053 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 3054 return FALSE; 3055 } 3056 3057 s = htab->sgot; 3058 h->got.offset = s->size; 3059 s->size += 4; 3060 /* R_SH_TLS_GD needs 2 consecutive GOT slots. */ 3061 if (got_type == GOT_TLS_GD) 3062 s->size += 4; 3063 dyn = htab->root.dynamic_sections_created; 3064 if (!dyn) 3065 { 3066 /* No dynamic relocations required. */ 3067 if (htab->fdpic_p && !info->shared 3068 && h->root.type != bfd_link_hash_undefweak 3069 && (got_type == GOT_NORMAL || got_type == GOT_FUNCDESC)) 3070 htab->srofixup->size += 4; 3071 } 3072 /* No dynamic relocations required when IE->LE conversion happens. */ 3073 else if (got_type == GOT_TLS_IE && !h->def_dynamic && !info->shared) 3074 ; 3075 /* R_SH_TLS_IE_32 needs one dynamic relocation if dynamic, 3076 R_SH_TLS_GD needs one if local symbol and two if global. */ 3077 else if ((got_type == GOT_TLS_GD && h->dynindx == -1) 3078 || got_type == GOT_TLS_IE) 3079 htab->srelgot->size += sizeof (Elf32_External_Rela); 3080 else if (got_type == GOT_TLS_GD) 3081 htab->srelgot->size += 2 * sizeof (Elf32_External_Rela); 3082 else if (got_type == GOT_FUNCDESC) 3083 { 3084 if (!info->shared && SYMBOL_FUNCDESC_LOCAL (info, h)) 3085 htab->srofixup->size += 4; 3086 else 3087 htab->srelgot->size += sizeof (Elf32_External_Rela); 3088 } 3089 else if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT 3090 || h->root.type != bfd_link_hash_undefweak) 3091 && (info->shared 3092 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))) 3093 htab->srelgot->size += sizeof (Elf32_External_Rela); 3094 else if (htab->fdpic_p && !info->shared && got_type == GOT_NORMAL 3095 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT 3096 || h->root.type != bfd_link_hash_undefweak)) 3097 htab->srofixup->size += 4; 3098 } 3099 else 3100 h->got.offset = (bfd_vma) -1; 3101 3102 #ifdef INCLUDE_SHMEDIA 3103 if (eh->datalabel_got.refcount > 0) 3104 { 3105 asection *s; 3106 bfd_boolean dyn; 3107 3108 /* Make sure this symbol is output as a dynamic symbol. 3109 Undefined weak syms won't yet be marked as dynamic. */ 3110 if (h->dynindx == -1 3111 && !h->forced_local) 3112 { 3113 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 3114 return FALSE; 3115 } 3116 3117 s = htab->sgot; 3118 eh->datalabel_got.offset = s->size; 3119 s->size += 4; 3120 dyn = htab->root.dynamic_sections_created; 3121 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)) 3122 htab->srelgot->size += sizeof (Elf32_External_Rela); 3123 } 3124 else 3125 eh->datalabel_got.offset = (bfd_vma) -1; 3126 #endif 3127 3128 /* Allocate space for any dynamic relocations to function 3129 descriptors, canonical or otherwise. We need to relocate the 3130 reference unless it resolves to zero, which only happens for 3131 undefined weak symbols (either non-default visibility, or when 3132 static linking). Any GOT slot is accounted for elsewhere. */ 3133 if (eh->abs_funcdesc_refcount > 0 3134 && (h->root.type != bfd_link_hash_undefweak 3135 || (htab->root.dynamic_sections_created 3136 && ! SYMBOL_CALLS_LOCAL (info, h)))) 3137 { 3138 if (!info->shared && SYMBOL_FUNCDESC_LOCAL (info, h)) 3139 htab->srofixup->size += eh->abs_funcdesc_refcount * 4; 3140 else 3141 htab->srelgot->size 3142 += eh->abs_funcdesc_refcount * sizeof (Elf32_External_Rela); 3143 } 3144 3145 /* We must allocate a function descriptor if there are references to 3146 a canonical descriptor (R_SH_GOTFUNCDESC or R_SH_FUNCDESC) and 3147 the dynamic linker isn't going to allocate it. None of this 3148 applies if we already created one in .got.plt, but if the 3149 canonical function descriptor can be in this object, there 3150 won't be a PLT entry at all. */ 3151 if ((eh->funcdesc.refcount > 0 3152 || (h->got.offset != MINUS_ONE && eh->got_type == GOT_FUNCDESC)) 3153 && h->root.type != bfd_link_hash_undefweak 3154 && SYMBOL_FUNCDESC_LOCAL (info, h)) 3155 { 3156 /* Make room for this function descriptor. */ 3157 eh->funcdesc.offset = htab->sfuncdesc->size; 3158 htab->sfuncdesc->size += 8; 3159 3160 /* We will need a relocation or two fixups to initialize the 3161 function descriptor, so allocate those too. */ 3162 if (!info->shared && SYMBOL_CALLS_LOCAL (info, h)) 3163 htab->srofixup->size += 8; 3164 else 3165 htab->srelfuncdesc->size += sizeof (Elf32_External_Rela); 3166 } 3167 3168 if (eh->dyn_relocs == NULL) 3169 return TRUE; 3170 3171 /* In the shared -Bsymbolic case, discard space allocated for 3172 dynamic pc-relative relocs against symbols which turn out to be 3173 defined in regular objects. For the normal shared case, discard 3174 space for pc-relative relocs that have become local due to symbol 3175 visibility changes. */ 3176 3177 if (info->shared) 3178 { 3179 if (SYMBOL_CALLS_LOCAL (info, h)) 3180 { 3181 struct elf_sh_dyn_relocs **pp; 3182 3183 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; ) 3184 { 3185 p->count -= p->pc_count; 3186 p->pc_count = 0; 3187 if (p->count == 0) 3188 *pp = p->next; 3189 else 3190 pp = &p->next; 3191 } 3192 } 3193 3194 if (htab->vxworks_p) 3195 { 3196 struct elf_sh_dyn_relocs **pp; 3197 3198 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; ) 3199 { 3200 if (strcmp (p->sec->output_section->name, ".tls_vars") == 0) 3201 *pp = p->next; 3202 else 3203 pp = &p->next; 3204 } 3205 } 3206 3207 /* Also discard relocs on undefined weak syms with non-default 3208 visibility. */ 3209 if (eh->dyn_relocs != NULL 3210 && h->root.type == bfd_link_hash_undefweak) 3211 { 3212 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT) 3213 eh->dyn_relocs = NULL; 3214 3215 /* Make sure undefined weak symbols are output as a dynamic 3216 symbol in PIEs. */ 3217 else if (h->dynindx == -1 3218 && !h->forced_local) 3219 { 3220 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 3221 return FALSE; 3222 } 3223 } 3224 } 3225 else 3226 { 3227 /* For the non-shared case, discard space for relocs against 3228 symbols which turn out to need copy relocs or are not 3229 dynamic. */ 3230 3231 if (!h->non_got_ref 3232 && ((h->def_dynamic 3233 && !h->def_regular) 3234 || (htab->root.dynamic_sections_created 3235 && (h->root.type == bfd_link_hash_undefweak 3236 || h->root.type == bfd_link_hash_undefined)))) 3237 { 3238 /* Make sure this symbol is output as a dynamic symbol. 3239 Undefined weak syms won't yet be marked as dynamic. */ 3240 if (h->dynindx == -1 3241 && !h->forced_local) 3242 { 3243 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 3244 return FALSE; 3245 } 3246 3247 /* If that succeeded, we know we'll be keeping all the 3248 relocs. */ 3249 if (h->dynindx != -1) 3250 goto keep; 3251 } 3252 3253 eh->dyn_relocs = NULL; 3254 3255 keep: ; 3256 } 3257 3258 /* Finally, allocate space. */ 3259 for (p = eh->dyn_relocs; p != NULL; p = p->next) 3260 { 3261 asection *sreloc = elf_section_data (p->sec)->sreloc; 3262 sreloc->size += p->count * sizeof (Elf32_External_Rela); 3263 3264 /* If we need relocations, we do not need fixups. */ 3265 if (htab->fdpic_p && !info->shared) 3266 htab->srofixup->size -= 4 * (p->count - p->pc_count); 3267 } 3268 3269 return TRUE; 3270 } 3271 3272 /* Find any dynamic relocs that apply to read-only sections. */ 3273 3274 static bfd_boolean 3275 readonly_dynrelocs (struct elf_link_hash_entry *h, void *inf) 3276 { 3277 struct elf_sh_link_hash_entry *eh; 3278 struct elf_sh_dyn_relocs *p; 3279 3280 eh = (struct elf_sh_link_hash_entry *) h; 3281 for (p = eh->dyn_relocs; p != NULL; p = p->next) 3282 { 3283 asection *s = p->sec->output_section; 3284 3285 if (s != NULL && (s->flags & SEC_READONLY) != 0) 3286 { 3287 struct bfd_link_info *info = (struct bfd_link_info *) inf; 3288 3289 if (info->warn_shared_textrel) 3290 (*_bfd_error_handler) 3291 (_("warning: dynamic relocation in readonly section `%s'"), 3292 h->root.root.string); 3293 info->flags |= DF_TEXTREL; 3294 3295 /* Not an error, just cut short the traversal. */ 3296 return FALSE; 3297 } 3298 } 3299 return TRUE; 3300 } 3301 3302 /* This function is called after all the input files have been read, 3303 and the input sections have been assigned to output sections. 3304 It's a convenient place to determine the PLT style. */ 3305 3306 static bfd_boolean 3307 sh_elf_always_size_sections (bfd *output_bfd, struct bfd_link_info *info) 3308 { 3309 sh_elf_hash_table (info)->plt_info = get_plt_info (output_bfd, info->shared); 3310 3311 if (sh_elf_hash_table (info)->fdpic_p && !info->relocatable) 3312 { 3313 struct elf_link_hash_entry *h; 3314 3315 /* Force a PT_GNU_STACK segment to be created. */ 3316 if (! elf_tdata (output_bfd)->stack_flags) 3317 elf_tdata (output_bfd)->stack_flags = PF_R | PF_W | PF_X; 3318 3319 /* Define __stacksize if it's not defined yet. */ 3320 h = elf_link_hash_lookup (elf_hash_table (info), "__stacksize", 3321 FALSE, FALSE, FALSE); 3322 if (! h || h->root.type != bfd_link_hash_defined 3323 || h->type != STT_OBJECT 3324 || !h->def_regular) 3325 { 3326 struct bfd_link_hash_entry *bh = NULL; 3327 3328 if (!(_bfd_generic_link_add_one_symbol 3329 (info, output_bfd, "__stacksize", 3330 BSF_GLOBAL, bfd_abs_section_ptr, DEFAULT_STACK_SIZE, 3331 (const char *) NULL, FALSE, 3332 get_elf_backend_data (output_bfd)->collect, &bh))) 3333 return FALSE; 3334 3335 h = (struct elf_link_hash_entry *) bh; 3336 h->def_regular = 1; 3337 h->type = STT_OBJECT; 3338 } 3339 } 3340 return TRUE; 3341 } 3342 3343 #if !defined INCLUDE_SHMEDIA && !defined SH_TARGET_ALREADY_DEFINED 3344 3345 static bfd_boolean 3346 sh_elf_modify_program_headers (bfd *output_bfd, struct bfd_link_info *info) 3347 { 3348 struct elf_obj_tdata *tdata = elf_tdata (output_bfd); 3349 struct elf_segment_map *m; 3350 Elf_Internal_Phdr *p; 3351 3352 /* objcopy and strip preserve what's already there using 3353 sh_elf_copy_private_bfd_data (). */ 3354 if (! info) 3355 return TRUE; 3356 3357 for (p = tdata->phdr, m = tdata->segment_map; m != NULL; m = m->next, p++) 3358 if (m->p_type == PT_GNU_STACK) 3359 break; 3360 3361 if (m) 3362 { 3363 struct elf_link_hash_entry *h; 3364 3365 /* Obtain the pointer to the __stacksize symbol. */ 3366 h = elf_link_hash_lookup (elf_hash_table (info), "__stacksize", 3367 FALSE, FALSE, FALSE); 3368 if (h) 3369 { 3370 while (h->root.type == bfd_link_hash_indirect 3371 || h->root.type == bfd_link_hash_warning) 3372 h = (struct elf_link_hash_entry *) h->root.u.i.link; 3373 BFD_ASSERT (h->root.type == bfd_link_hash_defined); 3374 } 3375 3376 /* Set the header p_memsz from the symbol value. We 3377 intentionally ignore the symbol section. */ 3378 if (h && h->root.type == bfd_link_hash_defined) 3379 p->p_memsz = h->root.u.def.value; 3380 else 3381 p->p_memsz = DEFAULT_STACK_SIZE; 3382 3383 p->p_align = 8; 3384 } 3385 3386 return TRUE; 3387 } 3388 3389 #endif 3390 3391 /* Set the sizes of the dynamic sections. */ 3392 3393 static bfd_boolean 3394 sh_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED, 3395 struct bfd_link_info *info) 3396 { 3397 struct elf_sh_link_hash_table *htab; 3398 bfd *dynobj; 3399 asection *s; 3400 bfd_boolean relocs; 3401 bfd *ibfd; 3402 3403 htab = sh_elf_hash_table (info); 3404 if (htab == NULL) 3405 return FALSE; 3406 3407 dynobj = htab->root.dynobj; 3408 BFD_ASSERT (dynobj != NULL); 3409 3410 if (htab->root.dynamic_sections_created) 3411 { 3412 /* Set the contents of the .interp section to the interpreter. */ 3413 if (info->executable) 3414 { 3415 s = bfd_get_linker_section (dynobj, ".interp"); 3416 BFD_ASSERT (s != NULL); 3417 s->size = sizeof ELF_DYNAMIC_INTERPRETER; 3418 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER; 3419 } 3420 } 3421 3422 /* Set up .got offsets for local syms, and space for local dynamic 3423 relocs. */ 3424 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next) 3425 { 3426 bfd_signed_vma *local_got; 3427 bfd_signed_vma *end_local_got; 3428 union gotref *local_funcdesc, *end_local_funcdesc; 3429 char *local_got_type; 3430 bfd_size_type locsymcount; 3431 Elf_Internal_Shdr *symtab_hdr; 3432 asection *srel; 3433 3434 if (! is_sh_elf (ibfd)) 3435 continue; 3436 3437 for (s = ibfd->sections; s != NULL; s = s->next) 3438 { 3439 struct elf_sh_dyn_relocs *p; 3440 3441 for (p = ((struct elf_sh_dyn_relocs *) 3442 elf_section_data (s)->local_dynrel); 3443 p != NULL; 3444 p = p->next) 3445 { 3446 if (! bfd_is_abs_section (p->sec) 3447 && bfd_is_abs_section (p->sec->output_section)) 3448 { 3449 /* Input section has been discarded, either because 3450 it is a copy of a linkonce section or due to 3451 linker script /DISCARD/, so we'll be discarding 3452 the relocs too. */ 3453 } 3454 else if (htab->vxworks_p 3455 && strcmp (p->sec->output_section->name, 3456 ".tls_vars") == 0) 3457 { 3458 /* Relocations in vxworks .tls_vars sections are 3459 handled specially by the loader. */ 3460 } 3461 else if (p->count != 0) 3462 { 3463 srel = elf_section_data (p->sec)->sreloc; 3464 srel->size += p->count * sizeof (Elf32_External_Rela); 3465 if ((p->sec->output_section->flags & SEC_READONLY) != 0) 3466 info->flags |= DF_TEXTREL; 3467 3468 /* If we need relocations, we do not need fixups. */ 3469 if (htab->fdpic_p && !info->shared) 3470 htab->srofixup->size -= 4 * (p->count - p->pc_count); 3471 } 3472 } 3473 } 3474 3475 symtab_hdr = &elf_symtab_hdr (ibfd); 3476 locsymcount = symtab_hdr->sh_info; 3477 #ifdef INCLUDE_SHMEDIA 3478 /* Count datalabel local GOT. */ 3479 locsymcount *= 2; 3480 #endif 3481 s = htab->sgot; 3482 srel = htab->srelgot; 3483 3484 local_got = elf_local_got_refcounts (ibfd); 3485 if (local_got) 3486 { 3487 end_local_got = local_got + locsymcount; 3488 local_got_type = sh_elf_local_got_type (ibfd); 3489 local_funcdesc = sh_elf_local_funcdesc (ibfd); 3490 for (; local_got < end_local_got; ++local_got) 3491 { 3492 if (*local_got > 0) 3493 { 3494 *local_got = s->size; 3495 s->size += 4; 3496 if (*local_got_type == GOT_TLS_GD) 3497 s->size += 4; 3498 if (info->shared) 3499 srel->size += sizeof (Elf32_External_Rela); 3500 else 3501 htab->srofixup->size += 4; 3502 3503 if (*local_got_type == GOT_FUNCDESC) 3504 { 3505 if (local_funcdesc == NULL) 3506 { 3507 bfd_size_type size; 3508 3509 size = locsymcount * sizeof (union gotref); 3510 local_funcdesc = (union gotref *) bfd_zalloc (ibfd, 3511 size); 3512 if (local_funcdesc == NULL) 3513 return FALSE; 3514 sh_elf_local_funcdesc (ibfd) = local_funcdesc; 3515 local_funcdesc += (local_got 3516 - elf_local_got_refcounts (ibfd)); 3517 } 3518 local_funcdesc->refcount++; 3519 ++local_funcdesc; 3520 } 3521 } 3522 else 3523 *local_got = (bfd_vma) -1; 3524 ++local_got_type; 3525 } 3526 } 3527 3528 local_funcdesc = sh_elf_local_funcdesc (ibfd); 3529 if (local_funcdesc) 3530 { 3531 end_local_funcdesc = local_funcdesc + locsymcount; 3532 3533 for (; local_funcdesc < end_local_funcdesc; ++local_funcdesc) 3534 { 3535 if (local_funcdesc->refcount > 0) 3536 { 3537 local_funcdesc->offset = htab->sfuncdesc->size; 3538 htab->sfuncdesc->size += 8; 3539 if (!info->shared) 3540 htab->srofixup->size += 8; 3541 else 3542 htab->srelfuncdesc->size += sizeof (Elf32_External_Rela); 3543 } 3544 else 3545 local_funcdesc->offset = MINUS_ONE; 3546 } 3547 } 3548 3549 } 3550 3551 if (htab->tls_ldm_got.refcount > 0) 3552 { 3553 /* Allocate 2 got entries and 1 dynamic reloc for R_SH_TLS_LD_32 3554 relocs. */ 3555 htab->tls_ldm_got.offset = htab->sgot->size; 3556 htab->sgot->size += 8; 3557 htab->srelgot->size += sizeof (Elf32_External_Rela); 3558 } 3559 else 3560 htab->tls_ldm_got.offset = -1; 3561 3562 /* Only the reserved entries should be present. For FDPIC, they go at 3563 the end of .got.plt. */ 3564 if (htab->fdpic_p) 3565 { 3566 BFD_ASSERT (htab->sgotplt && htab->sgotplt->size == 12); 3567 htab->sgotplt->size = 0; 3568 } 3569 3570 /* Allocate global sym .plt and .got entries, and space for global 3571 sym dynamic relocs. */ 3572 elf_link_hash_traverse (&htab->root, allocate_dynrelocs, info); 3573 3574 /* Move the reserved entries and the _GLOBAL_OFFSET_TABLE_ symbol to the 3575 end of the FDPIC .got.plt. */ 3576 if (htab->fdpic_p) 3577 { 3578 htab->root.hgot->root.u.def.value = htab->sgotplt->size; 3579 htab->sgotplt->size += 12; 3580 } 3581 3582 /* At the very end of the .rofixup section is a pointer to the GOT. */ 3583 if (htab->fdpic_p && htab->srofixup != NULL) 3584 htab->srofixup->size += 4; 3585 3586 /* We now have determined the sizes of the various dynamic sections. 3587 Allocate memory for them. */ 3588 relocs = FALSE; 3589 for (s = dynobj->sections; s != NULL; s = s->next) 3590 { 3591 if ((s->flags & SEC_LINKER_CREATED) == 0) 3592 continue; 3593 3594 if (s == htab->splt 3595 || s == htab->sgot 3596 || s == htab->sgotplt 3597 || s == htab->sfuncdesc 3598 || s == htab->srofixup 3599 || s == htab->sdynbss) 3600 { 3601 /* Strip this section if we don't need it; see the 3602 comment below. */ 3603 } 3604 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela")) 3605 { 3606 if (s->size != 0 && s != htab->srelplt && s != htab->srelplt2) 3607 relocs = TRUE; 3608 3609 /* We use the reloc_count field as a counter if we need 3610 to copy relocs into the output file. */ 3611 s->reloc_count = 0; 3612 } 3613 else 3614 { 3615 /* It's not one of our sections, so don't allocate space. */ 3616 continue; 3617 } 3618 3619 if (s->size == 0) 3620 { 3621 /* If we don't need this section, strip it from the 3622 output file. This is mostly to handle .rela.bss and 3623 .rela.plt. We must create both sections in 3624 create_dynamic_sections, because they must be created 3625 before the linker maps input sections to output 3626 sections. The linker does that before 3627 adjust_dynamic_symbol is called, and it is that 3628 function which decides whether anything needs to go 3629 into these sections. */ 3630 3631 s->flags |= SEC_EXCLUDE; 3632 continue; 3633 } 3634 3635 if ((s->flags & SEC_HAS_CONTENTS) == 0) 3636 continue; 3637 3638 /* Allocate memory for the section contents. We use bfd_zalloc 3639 here in case unused entries are not reclaimed before the 3640 section's contents are written out. This should not happen, 3641 but this way if it does, we get a R_SH_NONE reloc instead 3642 of garbage. */ 3643 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size); 3644 if (s->contents == NULL) 3645 return FALSE; 3646 } 3647 3648 if (htab->root.dynamic_sections_created) 3649 { 3650 /* Add some entries to the .dynamic section. We fill in the 3651 values later, in sh_elf_finish_dynamic_sections, but we 3652 must add the entries now so that we get the correct size for 3653 the .dynamic section. The DT_DEBUG entry is filled in by the 3654 dynamic linker and used by the debugger. */ 3655 #define add_dynamic_entry(TAG, VAL) \ 3656 _bfd_elf_add_dynamic_entry (info, TAG, VAL) 3657 3658 if (info->executable) 3659 { 3660 if (! add_dynamic_entry (DT_DEBUG, 0)) 3661 return FALSE; 3662 } 3663 3664 if (htab->splt->size != 0) 3665 { 3666 if (! add_dynamic_entry (DT_PLTGOT, 0) 3667 || ! add_dynamic_entry (DT_PLTRELSZ, 0) 3668 || ! add_dynamic_entry (DT_PLTREL, DT_RELA) 3669 || ! add_dynamic_entry (DT_JMPREL, 0)) 3670 return FALSE; 3671 } 3672 else if ((elf_elfheader (output_bfd)->e_flags & EF_SH_FDPIC) 3673 && htab->sgot->size != 0) 3674 { 3675 if (! add_dynamic_entry (DT_PLTGOT, 0)) 3676 return FALSE; 3677 } 3678 3679 if (relocs) 3680 { 3681 if (! add_dynamic_entry (DT_RELA, 0) 3682 || ! add_dynamic_entry (DT_RELASZ, 0) 3683 || ! add_dynamic_entry (DT_RELAENT, 3684 sizeof (Elf32_External_Rela))) 3685 return FALSE; 3686 3687 /* If any dynamic relocs apply to a read-only section, 3688 then we need a DT_TEXTREL entry. */ 3689 if ((info->flags & DF_TEXTREL) == 0) 3690 elf_link_hash_traverse (&htab->root, readonly_dynrelocs, info); 3691 3692 if ((info->flags & DF_TEXTREL) != 0) 3693 { 3694 if (! add_dynamic_entry (DT_TEXTREL, 0)) 3695 return FALSE; 3696 } 3697 } 3698 if (htab->vxworks_p 3699 && !elf_vxworks_add_dynamic_entries (output_bfd, info)) 3700 return FALSE; 3701 } 3702 #undef add_dynamic_entry 3703 3704 return TRUE; 3705 } 3706 3707 /* Add a dynamic relocation to the SRELOC section. */ 3708 3709 inline static bfd_vma 3710 sh_elf_add_dyn_reloc (bfd *output_bfd, asection *sreloc, bfd_vma offset, 3711 int reloc_type, long dynindx, bfd_vma addend) 3712 { 3713 Elf_Internal_Rela outrel; 3714 bfd_vma reloc_offset; 3715 3716 outrel.r_offset = offset; 3717 outrel.r_info = ELF32_R_INFO (dynindx, reloc_type); 3718 outrel.r_addend = addend; 3719 3720 reloc_offset = sreloc->reloc_count * sizeof (Elf32_External_Rela); 3721 BFD_ASSERT (reloc_offset < sreloc->size); 3722 bfd_elf32_swap_reloca_out (output_bfd, &outrel, 3723 sreloc->contents + reloc_offset); 3724 sreloc->reloc_count++; 3725 3726 return reloc_offset; 3727 } 3728 3729 /* Add an FDPIC read-only fixup. */ 3730 3731 inline static void 3732 sh_elf_add_rofixup (bfd *output_bfd, asection *srofixup, bfd_vma offset) 3733 { 3734 bfd_vma fixup_offset; 3735 3736 fixup_offset = srofixup->reloc_count++ * 4; 3737 BFD_ASSERT (fixup_offset < srofixup->size); 3738 bfd_put_32 (output_bfd, offset, srofixup->contents + fixup_offset); 3739 } 3740 3741 /* Return the offset of the generated .got section from the 3742 _GLOBAL_OFFSET_TABLE_ symbol. */ 3743 3744 static bfd_signed_vma 3745 sh_elf_got_offset (struct elf_sh_link_hash_table *htab) 3746 { 3747 return (htab->sgot->output_offset - htab->sgotplt->output_offset 3748 - htab->root.hgot->root.u.def.value); 3749 } 3750 3751 /* Find the segment number in which OSEC, and output section, is 3752 located. */ 3753 3754 static unsigned 3755 sh_elf_osec_to_segment (bfd *output_bfd, asection *osec) 3756 { 3757 Elf_Internal_Phdr *p = NULL; 3758 3759 if (output_bfd->xvec->flavour == bfd_target_elf_flavour) 3760 p = _bfd_elf_find_segment_containing_section (output_bfd, osec); 3761 3762 /* FIXME: Nothing ever says what this index is relative to. The kernel 3763 supplies data in terms of the number of load segments but this is 3764 a phdr index and the first phdr may not be a load segment. */ 3765 return (p != NULL) ? p - elf_tdata (output_bfd)->phdr : -1; 3766 } 3767 3768 static bfd_boolean 3769 sh_elf_osec_readonly_p (bfd *output_bfd, asection *osec) 3770 { 3771 unsigned seg = sh_elf_osec_to_segment (output_bfd, osec); 3772 3773 return (seg != (unsigned) -1 3774 && ! (elf_tdata (output_bfd)->phdr[seg].p_flags & PF_W)); 3775 } 3776 3777 /* Generate the initial contents of a local function descriptor, along 3778 with any relocations or fixups required. */ 3779 static bfd_boolean 3780 sh_elf_initialize_funcdesc (bfd *output_bfd, 3781 struct bfd_link_info *info, 3782 struct elf_link_hash_entry *h, 3783 bfd_vma offset, 3784 asection *section, 3785 bfd_vma value) 3786 { 3787 struct elf_sh_link_hash_table *htab; 3788 int dynindx; 3789 bfd_vma addr, seg; 3790 3791 htab = sh_elf_hash_table (info); 3792 3793 /* FIXME: The ABI says that the offset to the function goes in the 3794 descriptor, along with the segment index. We're RELA, so it could 3795 go in the reloc instead... */ 3796 3797 if (h != NULL && SYMBOL_CALLS_LOCAL (info, h)) 3798 { 3799 section = h->root.u.def.section; 3800 value = h->root.u.def.value; 3801 } 3802 3803 if (h == NULL || SYMBOL_CALLS_LOCAL (info, h)) 3804 { 3805 dynindx = elf_section_data (section->output_section)->dynindx; 3806 addr = value + section->output_offset; 3807 seg = sh_elf_osec_to_segment (output_bfd, section->output_section); 3808 } 3809 else 3810 { 3811 BFD_ASSERT (h->dynindx != -1); 3812 dynindx = h->dynindx; 3813 addr = seg = 0; 3814 } 3815 3816 if (!info->shared && SYMBOL_CALLS_LOCAL (info, h)) 3817 { 3818 if (h == NULL || h->root.type != bfd_link_hash_undefweak) 3819 { 3820 sh_elf_add_rofixup (output_bfd, htab->srofixup, 3821 offset 3822 + htab->sfuncdesc->output_section->vma 3823 + htab->sfuncdesc->output_offset); 3824 sh_elf_add_rofixup (output_bfd, htab->srofixup, 3825 offset + 4 3826 + htab->sfuncdesc->output_section->vma 3827 + htab->sfuncdesc->output_offset); 3828 } 3829 3830 /* There are no dynamic relocations so fill in the final 3831 address and gp value (barring fixups). */ 3832 addr += section->output_section->vma; 3833 seg = htab->root.hgot->root.u.def.value 3834 + htab->root.hgot->root.u.def.section->output_section->vma 3835 + htab->root.hgot->root.u.def.section->output_offset; 3836 } 3837 else 3838 sh_elf_add_dyn_reloc (output_bfd, htab->srelfuncdesc, 3839 offset 3840 + htab->sfuncdesc->output_section->vma 3841 + htab->sfuncdesc->output_offset, 3842 R_SH_FUNCDESC_VALUE, dynindx, 0); 3843 3844 bfd_put_32 (output_bfd, addr, htab->sfuncdesc->contents + offset); 3845 bfd_put_32 (output_bfd, seg, htab->sfuncdesc->contents + offset + 4); 3846 3847 return TRUE; 3848 } 3849 3850 /* Install a 20-bit movi20 field starting at ADDR, which occurs in OUTPUT_BFD. 3851 VALUE is the field's value. Return bfd_reloc_ok if successful or an error 3852 otherwise. */ 3853 3854 static bfd_reloc_status_type 3855 install_movi20_field (bfd *output_bfd, unsigned long relocation, 3856 bfd *input_bfd, asection *input_section, 3857 bfd_byte *contents, bfd_vma offset) 3858 { 3859 unsigned long cur_val; 3860 bfd_byte *addr; 3861 bfd_reloc_status_type r; 3862 3863 if (offset > bfd_get_section_limit (input_bfd, input_section)) 3864 return bfd_reloc_outofrange; 3865 3866 r = bfd_check_overflow (complain_overflow_signed, 20, 0, 3867 bfd_arch_bits_per_address (input_bfd), relocation); 3868 if (r != bfd_reloc_ok) 3869 return r; 3870 3871 addr = contents + offset; 3872 cur_val = bfd_get_16 (output_bfd, addr); 3873 bfd_put_16 (output_bfd, cur_val | ((relocation & 0xf0000) >> 12), addr); 3874 bfd_put_16 (output_bfd, relocation & 0xffff, addr + 2); 3875 3876 return bfd_reloc_ok; 3877 } 3878 3879 /* Relocate an SH ELF section. */ 3880 3881 static bfd_boolean 3882 sh_elf_relocate_section (bfd *output_bfd, struct bfd_link_info *info, 3883 bfd *input_bfd, asection *input_section, 3884 bfd_byte *contents, Elf_Internal_Rela *relocs, 3885 Elf_Internal_Sym *local_syms, 3886 asection **local_sections) 3887 { 3888 struct elf_sh_link_hash_table *htab; 3889 Elf_Internal_Shdr *symtab_hdr; 3890 struct elf_link_hash_entry **sym_hashes; 3891 Elf_Internal_Rela *rel, *relend; 3892 bfd *dynobj = NULL; 3893 bfd_vma *local_got_offsets; 3894 asection *sgot = NULL; 3895 asection *sgotplt = NULL; 3896 asection *splt = NULL; 3897 asection *sreloc = NULL; 3898 asection *srelgot = NULL; 3899 bfd_boolean is_vxworks_tls; 3900 unsigned isec_segment, got_segment, plt_segment, check_segment[2]; 3901 bfd_boolean fdpic_p = FALSE; 3902 3903 BFD_ASSERT (is_sh_elf (input_bfd)); 3904 3905 htab = sh_elf_hash_table (info); 3906 if (htab != NULL) 3907 { 3908 dynobj = htab->root.dynobj; 3909 sgot = htab->sgot; 3910 sgotplt = htab->sgotplt; 3911 splt = htab->splt; 3912 fdpic_p = htab->fdpic_p; 3913 } 3914 symtab_hdr = &elf_symtab_hdr (input_bfd); 3915 sym_hashes = elf_sym_hashes (input_bfd); 3916 local_got_offsets = elf_local_got_offsets (input_bfd); 3917 3918 isec_segment = sh_elf_osec_to_segment (output_bfd, 3919 input_section->output_section); 3920 if (fdpic_p && sgot) 3921 got_segment = sh_elf_osec_to_segment (output_bfd, 3922 sgot->output_section); 3923 else 3924 got_segment = -1; 3925 if (fdpic_p && splt) 3926 plt_segment = sh_elf_osec_to_segment (output_bfd, 3927 splt->output_section); 3928 else 3929 plt_segment = -1; 3930 3931 /* We have to handle relocations in vxworks .tls_vars sections 3932 specially, because the dynamic loader is 'weird'. */ 3933 is_vxworks_tls = (htab && htab->vxworks_p && info->shared 3934 && !strcmp (input_section->output_section->name, 3935 ".tls_vars")); 3936 3937 rel = relocs; 3938 relend = relocs + input_section->reloc_count; 3939 for (; rel < relend; rel++) 3940 { 3941 int r_type; 3942 reloc_howto_type *howto; 3943 unsigned long r_symndx; 3944 Elf_Internal_Sym *sym; 3945 asection *sec; 3946 struct elf_link_hash_entry *h; 3947 bfd_vma relocation; 3948 bfd_vma addend = (bfd_vma) 0; 3949 bfd_reloc_status_type r; 3950 int seen_stt_datalabel = 0; 3951 bfd_vma off; 3952 enum got_type got_type; 3953 const char *symname = NULL; 3954 3955 r_symndx = ELF32_R_SYM (rel->r_info); 3956 3957 r_type = ELF32_R_TYPE (rel->r_info); 3958 3959 /* Many of the relocs are only used for relaxing, and are 3960 handled entirely by the relaxation code. */ 3961 if (r_type >= (int) R_SH_GNU_VTINHERIT 3962 && r_type <= (int) R_SH_LABEL) 3963 continue; 3964 if (r_type == (int) R_SH_NONE) 3965 continue; 3966 3967 if (r_type < 0 3968 || r_type >= R_SH_max 3969 || (r_type >= (int) R_SH_FIRST_INVALID_RELOC 3970 && r_type <= (int) R_SH_LAST_INVALID_RELOC) 3971 || (r_type >= (int) R_SH_FIRST_INVALID_RELOC_2 3972 && r_type <= (int) R_SH_LAST_INVALID_RELOC_2) 3973 || ( r_type >= (int) R_SH_FIRST_INVALID_RELOC_3 3974 && r_type <= (int) R_SH_LAST_INVALID_RELOC_3) 3975 || ( r_type >= (int) R_SH_FIRST_INVALID_RELOC_4 3976 && r_type <= (int) R_SH_LAST_INVALID_RELOC_4) 3977 || ( r_type >= (int) R_SH_FIRST_INVALID_RELOC_5 3978 && r_type <= (int) R_SH_LAST_INVALID_RELOC_5) 3979 || ( r_type >= (int) R_SH_FIRST_INVALID_RELOC_6 3980 && r_type <= (int) R_SH_LAST_INVALID_RELOC_6)) 3981 { 3982 bfd_set_error (bfd_error_bad_value); 3983 return FALSE; 3984 } 3985 3986 howto = get_howto_table (output_bfd) + r_type; 3987 3988 /* For relocs that aren't partial_inplace, we get the addend from 3989 the relocation. */ 3990 if (! howto->partial_inplace) 3991 addend = rel->r_addend; 3992 3993 h = NULL; 3994 sym = NULL; 3995 sec = NULL; 3996 check_segment[0] = -1; 3997 check_segment[1] = -1; 3998 if (r_symndx < symtab_hdr->sh_info) 3999 { 4000 sym = local_syms + r_symndx; 4001 sec = local_sections[r_symndx]; 4002 4003 symname = bfd_elf_string_from_elf_section 4004 (input_bfd, symtab_hdr->sh_link, sym->st_name); 4005 if (symname == NULL || *symname == '\0') 4006 symname = bfd_section_name (input_bfd, sec); 4007 4008 relocation = (sec->output_section->vma 4009 + sec->output_offset 4010 + sym->st_value); 4011 /* A local symbol never has STO_SH5_ISA32, so we don't need 4012 datalabel processing here. Make sure this does not change 4013 without notice. */ 4014 if ((sym->st_other & STO_SH5_ISA32) != 0) 4015 ((*info->callbacks->reloc_dangerous) 4016 (info, 4017 _("Unexpected STO_SH5_ISA32 on local symbol is not handled"), 4018 input_bfd, input_section, rel->r_offset)); 4019 4020 if (sec != NULL && discarded_section (sec)) 4021 /* Handled below. */ 4022 ; 4023 else if (info->relocatable) 4024 { 4025 /* This is a relocatable link. We don't have to change 4026 anything, unless the reloc is against a section symbol, 4027 in which case we have to adjust according to where the 4028 section symbol winds up in the output section. */ 4029 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION) 4030 { 4031 if (! howto->partial_inplace) 4032 { 4033 /* For relocations with the addend in the 4034 relocation, we need just to update the addend. 4035 All real relocs are of type partial_inplace; this 4036 code is mostly for completeness. */ 4037 rel->r_addend += sec->output_offset; 4038 4039 continue; 4040 } 4041 4042 /* Relocs of type partial_inplace need to pick up the 4043 contents in the contents and add the offset resulting 4044 from the changed location of the section symbol. 4045 Using _bfd_final_link_relocate (e.g. goto 4046 final_link_relocate) here would be wrong, because 4047 relocations marked pc_relative would get the current 4048 location subtracted, and we must only do that at the 4049 final link. */ 4050 r = _bfd_relocate_contents (howto, input_bfd, 4051 sec->output_offset 4052 + sym->st_value, 4053 contents + rel->r_offset); 4054 goto relocation_done; 4055 } 4056 4057 continue; 4058 } 4059 else if (! howto->partial_inplace) 4060 { 4061 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel); 4062 addend = rel->r_addend; 4063 } 4064 else if ((sec->flags & SEC_MERGE) 4065 && ELF_ST_TYPE (sym->st_info) == STT_SECTION) 4066 { 4067 asection *msec; 4068 4069 if (howto->rightshift || howto->src_mask != 0xffffffff) 4070 { 4071 (*_bfd_error_handler) 4072 (_("%B(%A+0x%lx): %s relocation against SEC_MERGE section"), 4073 input_bfd, input_section, 4074 (long) rel->r_offset, howto->name); 4075 return FALSE; 4076 } 4077 4078 addend = bfd_get_32 (input_bfd, contents + rel->r_offset); 4079 msec = sec; 4080 addend = 4081 _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend) 4082 - relocation; 4083 addend += msec->output_section->vma + msec->output_offset; 4084 bfd_put_32 (input_bfd, addend, contents + rel->r_offset); 4085 addend = 0; 4086 } 4087 } 4088 else 4089 { 4090 /* FIXME: Ought to make use of the RELOC_FOR_GLOBAL_SYMBOL macro. */ 4091 4092 relocation = 0; 4093 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 4094 symname = h->root.root.string; 4095 while (h->root.type == bfd_link_hash_indirect 4096 || h->root.type == bfd_link_hash_warning) 4097 { 4098 #ifdef INCLUDE_SHMEDIA 4099 /* If the reference passes a symbol marked with 4100 STT_DATALABEL, then any STO_SH5_ISA32 on the final value 4101 doesn't count. */ 4102 seen_stt_datalabel |= h->type == STT_DATALABEL; 4103 #endif 4104 h = (struct elf_link_hash_entry *) h->root.u.i.link; 4105 } 4106 if (h->root.type == bfd_link_hash_defined 4107 || h->root.type == bfd_link_hash_defweak) 4108 { 4109 bfd_boolean dyn; 4110 4111 dyn = htab ? htab->root.dynamic_sections_created : FALSE; 4112 sec = h->root.u.def.section; 4113 /* In these cases, we don't need the relocation value. 4114 We check specially because in some obscure cases 4115 sec->output_section will be NULL. */ 4116 if (r_type == R_SH_GOTPC 4117 || r_type == R_SH_GOTPC_LOW16 4118 || r_type == R_SH_GOTPC_MEDLOW16 4119 || r_type == R_SH_GOTPC_MEDHI16 4120 || r_type == R_SH_GOTPC_HI16 4121 || ((r_type == R_SH_PLT32 4122 || r_type == R_SH_PLT_LOW16 4123 || r_type == R_SH_PLT_MEDLOW16 4124 || r_type == R_SH_PLT_MEDHI16 4125 || r_type == R_SH_PLT_HI16) 4126 && h->plt.offset != (bfd_vma) -1) 4127 || ((r_type == R_SH_GOT32 4128 || r_type == R_SH_GOT20 4129 || r_type == R_SH_GOTFUNCDESC 4130 || r_type == R_SH_GOTFUNCDESC20 4131 || r_type == R_SH_GOTOFFFUNCDESC 4132 || r_type == R_SH_GOTOFFFUNCDESC20 4133 || r_type == R_SH_FUNCDESC 4134 || r_type == R_SH_GOT_LOW16 4135 || r_type == R_SH_GOT_MEDLOW16 4136 || r_type == R_SH_GOT_MEDHI16 4137 || r_type == R_SH_GOT_HI16) 4138 && WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h) 4139 && (! info->shared 4140 || (! info->symbolic && h->dynindx != -1) 4141 || !h->def_regular)) 4142 /* The cases above are those in which relocation is 4143 overwritten in the switch block below. The cases 4144 below are those in which we must defer relocation 4145 to run-time, because we can't resolve absolute 4146 addresses when creating a shared library. */ 4147 || (info->shared 4148 && ((! info->symbolic && h->dynindx != -1) 4149 || !h->def_regular) 4150 && ((r_type == R_SH_DIR32 4151 && !h->forced_local) 4152 || (r_type == R_SH_REL32 4153 && !SYMBOL_CALLS_LOCAL (info, h))) 4154 && ((input_section->flags & SEC_ALLOC) != 0 4155 /* DWARF will emit R_SH_DIR32 relocations in its 4156 sections against symbols defined externally 4157 in shared libraries. We can't do anything 4158 with them here. */ 4159 || ((input_section->flags & SEC_DEBUGGING) != 0 4160 && h->def_dynamic))) 4161 /* Dynamic relocs are not propagated for SEC_DEBUGGING 4162 sections because such sections are not SEC_ALLOC and 4163 thus ld.so will not process them. */ 4164 || (sec->output_section == NULL 4165 && ((input_section->flags & SEC_DEBUGGING) != 0 4166 && h->def_dynamic)) 4167 || (sec->output_section == NULL 4168 && (sh_elf_hash_entry (h)->got_type == GOT_TLS_IE 4169 || sh_elf_hash_entry (h)->got_type == GOT_TLS_GD))) 4170 ; 4171 else if (sec->output_section != NULL) 4172 relocation = ((h->root.u.def.value 4173 + sec->output_section->vma 4174 + sec->output_offset) 4175 /* A STO_SH5_ISA32 causes a "bitor 1" to the 4176 symbol value, unless we've seen 4177 STT_DATALABEL on the way to it. */ 4178 | ((h->other & STO_SH5_ISA32) != 0 4179 && ! seen_stt_datalabel)); 4180 else if (!info->relocatable 4181 && (_bfd_elf_section_offset (output_bfd, info, 4182 input_section, 4183 rel->r_offset) 4184 != (bfd_vma) -1)) 4185 { 4186 (*_bfd_error_handler) 4187 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"), 4188 input_bfd, 4189 input_section, 4190 (long) rel->r_offset, 4191 howto->name, 4192 h->root.root.string); 4193 return FALSE; 4194 } 4195 } 4196 else if (h->root.type == bfd_link_hash_undefweak) 4197 ; 4198 else if (info->unresolved_syms_in_objects == RM_IGNORE 4199 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT) 4200 ; 4201 else if (!info->relocatable) 4202 { 4203 if (! info->callbacks->undefined_symbol 4204 (info, h->root.root.string, input_bfd, 4205 input_section, rel->r_offset, 4206 (info->unresolved_syms_in_objects == RM_GENERATE_ERROR 4207 || ELF_ST_VISIBILITY (h->other)))) 4208 return FALSE; 4209 } 4210 } 4211 4212 if (sec != NULL && discarded_section (sec)) 4213 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section, 4214 rel, 1, relend, howto, 0, contents); 4215 4216 if (info->relocatable) 4217 continue; 4218 4219 /* Check for inter-segment relocations in FDPIC files. Most 4220 relocations connect the relocation site to the location of 4221 the target symbol, but there are some exceptions below. */ 4222 check_segment[0] = isec_segment; 4223 if (sec != NULL) 4224 check_segment[1] = sh_elf_osec_to_segment (output_bfd, 4225 sec->output_section); 4226 else 4227 check_segment[1] = -1; 4228 4229 switch ((int) r_type) 4230 { 4231 final_link_relocate: 4232 /* COFF relocs don't use the addend. The addend is used for 4233 R_SH_DIR32 to be compatible with other compilers. */ 4234 r = _bfd_final_link_relocate (howto, input_bfd, input_section, 4235 contents, rel->r_offset, 4236 relocation, addend); 4237 break; 4238 4239 case R_SH_IND12W: 4240 goto final_link_relocate; 4241 4242 case R_SH_DIR8WPN: 4243 case R_SH_DIR8WPZ: 4244 case R_SH_DIR8WPL: 4245 /* If the reloc is against the start of this section, then 4246 the assembler has already taken care of it and the reloc 4247 is here only to assist in relaxing. If the reloc is not 4248 against the start of this section, then it's against an 4249 external symbol and we must deal with it ourselves. */ 4250 if (input_section->output_section->vma + input_section->output_offset 4251 != relocation) 4252 { 4253 int disp = (relocation 4254 - input_section->output_section->vma 4255 - input_section->output_offset 4256 - rel->r_offset); 4257 int mask = 0; 4258 switch (r_type) 4259 { 4260 case R_SH_DIR8WPN: 4261 case R_SH_DIR8WPZ: mask = 1; break; 4262 case R_SH_DIR8WPL: mask = 3; break; 4263 default: mask = 0; break; 4264 } 4265 if (disp & mask) 4266 { 4267 ((*_bfd_error_handler) 4268 (_("%B: 0x%lx: fatal: unaligned branch target for relax-support relocation"), 4269 input_section->owner, 4270 (unsigned long) rel->r_offset)); 4271 bfd_set_error (bfd_error_bad_value); 4272 return FALSE; 4273 } 4274 relocation -= 4; 4275 goto final_link_relocate; 4276 } 4277 r = bfd_reloc_ok; 4278 break; 4279 4280 default: 4281 #ifdef INCLUDE_SHMEDIA 4282 if (shmedia_prepare_reloc (info, input_bfd, input_section, 4283 contents, rel, &relocation)) 4284 goto final_link_relocate; 4285 #endif 4286 bfd_set_error (bfd_error_bad_value); 4287 return FALSE; 4288 4289 case R_SH_DIR16: 4290 case R_SH_DIR8: 4291 case R_SH_DIR8U: 4292 case R_SH_DIR8S: 4293 case R_SH_DIR4U: 4294 goto final_link_relocate; 4295 4296 case R_SH_DIR8UL: 4297 case R_SH_DIR4UL: 4298 if (relocation & 3) 4299 { 4300 ((*_bfd_error_handler) 4301 (_("%B: 0x%lx: fatal: unaligned %s relocation 0x%lx"), 4302 input_section->owner, 4303 (unsigned long) rel->r_offset, howto->name, 4304 (unsigned long) relocation)); 4305 bfd_set_error (bfd_error_bad_value); 4306 return FALSE; 4307 } 4308 goto final_link_relocate; 4309 4310 case R_SH_DIR8UW: 4311 case R_SH_DIR8SW: 4312 case R_SH_DIR4UW: 4313 if (relocation & 1) 4314 { 4315 ((*_bfd_error_handler) 4316 (_("%B: 0x%lx: fatal: unaligned %s relocation 0x%lx"), 4317 input_section->owner, 4318 (unsigned long) rel->r_offset, howto->name, 4319 (unsigned long) relocation)); 4320 bfd_set_error (bfd_error_bad_value); 4321 return FALSE; 4322 } 4323 goto final_link_relocate; 4324 4325 case R_SH_PSHA: 4326 if ((signed int)relocation < -32 4327 || (signed int)relocation > 32) 4328 { 4329 ((*_bfd_error_handler) 4330 (_("%B: 0x%lx: fatal: R_SH_PSHA relocation %d not in range -32..32"), 4331 input_section->owner, 4332 (unsigned long) rel->r_offset, 4333 (unsigned long) relocation)); 4334 bfd_set_error (bfd_error_bad_value); 4335 return FALSE; 4336 } 4337 goto final_link_relocate; 4338 4339 case R_SH_PSHL: 4340 if ((signed int)relocation < -16 4341 || (signed int)relocation > 16) 4342 { 4343 ((*_bfd_error_handler) 4344 (_("%B: 0x%lx: fatal: R_SH_PSHL relocation %d not in range -32..32"), 4345 input_section->owner, 4346 (unsigned long) rel->r_offset, 4347 (unsigned long) relocation)); 4348 bfd_set_error (bfd_error_bad_value); 4349 return FALSE; 4350 } 4351 goto final_link_relocate; 4352 4353 case R_SH_DIR32: 4354 case R_SH_REL32: 4355 #ifdef INCLUDE_SHMEDIA 4356 case R_SH_IMM_LOW16_PCREL: 4357 case R_SH_IMM_MEDLOW16_PCREL: 4358 case R_SH_IMM_MEDHI16_PCREL: 4359 case R_SH_IMM_HI16_PCREL: 4360 #endif 4361 if (info->shared 4362 && (h == NULL 4363 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT 4364 || h->root.type != bfd_link_hash_undefweak) 4365 && r_symndx != STN_UNDEF 4366 && (input_section->flags & SEC_ALLOC) != 0 4367 && !is_vxworks_tls 4368 && (r_type == R_SH_DIR32 4369 || !SYMBOL_CALLS_LOCAL (info, h))) 4370 { 4371 Elf_Internal_Rela outrel; 4372 bfd_byte *loc; 4373 bfd_boolean skip, relocate; 4374 4375 /* When generating a shared object, these relocations 4376 are copied into the output file to be resolved at run 4377 time. */ 4378 4379 if (sreloc == NULL) 4380 { 4381 sreloc = _bfd_elf_get_dynamic_reloc_section 4382 (input_bfd, input_section, /*rela?*/ TRUE); 4383 if (sreloc == NULL) 4384 return FALSE; 4385 } 4386 4387 skip = FALSE; 4388 relocate = FALSE; 4389 4390 outrel.r_offset = 4391 _bfd_elf_section_offset (output_bfd, info, input_section, 4392 rel->r_offset); 4393 if (outrel.r_offset == (bfd_vma) -1) 4394 skip = TRUE; 4395 else if (outrel.r_offset == (bfd_vma) -2) 4396 skip = TRUE, relocate = TRUE; 4397 outrel.r_offset += (input_section->output_section->vma 4398 + input_section->output_offset); 4399 4400 if (skip) 4401 memset (&outrel, 0, sizeof outrel); 4402 else if (r_type == R_SH_REL32) 4403 { 4404 BFD_ASSERT (h != NULL && h->dynindx != -1); 4405 outrel.r_info = ELF32_R_INFO (h->dynindx, R_SH_REL32); 4406 outrel.r_addend 4407 = (howto->partial_inplace 4408 ? bfd_get_32 (input_bfd, contents + rel->r_offset) 4409 : addend); 4410 } 4411 #ifdef INCLUDE_SHMEDIA 4412 else if (r_type == R_SH_IMM_LOW16_PCREL 4413 || r_type == R_SH_IMM_MEDLOW16_PCREL 4414 || r_type == R_SH_IMM_MEDHI16_PCREL 4415 || r_type == R_SH_IMM_HI16_PCREL) 4416 { 4417 BFD_ASSERT (h != NULL && h->dynindx != -1); 4418 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type); 4419 outrel.r_addend = addend; 4420 } 4421 #endif 4422 else if (fdpic_p 4423 && (h == NULL 4424 || ((info->symbolic || h->dynindx == -1) 4425 && h->def_regular))) 4426 { 4427 int dynindx; 4428 4429 BFD_ASSERT (sec != NULL); 4430 BFD_ASSERT (sec->output_section != NULL); 4431 dynindx = elf_section_data (sec->output_section)->dynindx; 4432 outrel.r_info = ELF32_R_INFO (dynindx, R_SH_DIR32); 4433 outrel.r_addend = relocation; 4434 outrel.r_addend 4435 += (howto->partial_inplace 4436 ? bfd_get_32 (input_bfd, contents + rel->r_offset) 4437 : addend); 4438 outrel.r_addend -= sec->output_section->vma; 4439 } 4440 else 4441 { 4442 /* h->dynindx may be -1 if this symbol was marked to 4443 become local. */ 4444 if (h == NULL 4445 || ((info->symbolic || h->dynindx == -1) 4446 && h->def_regular)) 4447 { 4448 relocate = howto->partial_inplace; 4449 outrel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE); 4450 } 4451 else 4452 { 4453 BFD_ASSERT (h->dynindx != -1); 4454 outrel.r_info = ELF32_R_INFO (h->dynindx, R_SH_DIR32); 4455 } 4456 outrel.r_addend = relocation; 4457 outrel.r_addend 4458 += (howto->partial_inplace 4459 ? bfd_get_32 (input_bfd, contents + rel->r_offset) 4460 : addend); 4461 } 4462 4463 loc = sreloc->contents; 4464 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela); 4465 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc); 4466 4467 check_segment[0] = check_segment[1] = -1; 4468 4469 /* If this reloc is against an external symbol, we do 4470 not want to fiddle with the addend. Otherwise, we 4471 need to include the symbol value so that it becomes 4472 an addend for the dynamic reloc. */ 4473 if (! relocate) 4474 continue; 4475 } 4476 else if (fdpic_p && !info->shared 4477 && r_type == R_SH_DIR32 4478 && (input_section->flags & SEC_ALLOC) != 0) 4479 { 4480 bfd_vma offset; 4481 4482 BFD_ASSERT (htab); 4483 4484 if (sh_elf_osec_readonly_p (output_bfd, 4485 input_section->output_section)) 4486 { 4487 (*_bfd_error_handler) 4488 (_("%B(%A+0x%lx): cannot emit fixup to `%s' in read-only section"), 4489 input_bfd, 4490 input_section, 4491 (long) rel->r_offset, 4492 symname); 4493 return FALSE; 4494 } 4495 4496 offset = _bfd_elf_section_offset (output_bfd, info, 4497 input_section, rel->r_offset); 4498 if (offset != (bfd_vma)-1) 4499 sh_elf_add_rofixup (output_bfd, htab->srofixup, 4500 input_section->output_section->vma 4501 + input_section->output_offset 4502 + rel->r_offset); 4503 4504 check_segment[0] = check_segment[1] = -1; 4505 } 4506 goto final_link_relocate; 4507 4508 case R_SH_GOTPLT32: 4509 #ifdef INCLUDE_SHMEDIA 4510 case R_SH_GOTPLT_LOW16: 4511 case R_SH_GOTPLT_MEDLOW16: 4512 case R_SH_GOTPLT_MEDHI16: 4513 case R_SH_GOTPLT_HI16: 4514 case R_SH_GOTPLT10BY4: 4515 case R_SH_GOTPLT10BY8: 4516 #endif 4517 /* Relocation is to the entry for this symbol in the 4518 procedure linkage table. */ 4519 4520 if (h == NULL 4521 || h->forced_local 4522 || ! info->shared 4523 || info->symbolic 4524 || h->dynindx == -1 4525 || h->plt.offset == (bfd_vma) -1 4526 || h->got.offset != (bfd_vma) -1) 4527 goto force_got; 4528 4529 /* Relocation is to the entry for this symbol in the global 4530 offset table extension for the procedure linkage table. */ 4531 4532 BFD_ASSERT (htab); 4533 BFD_ASSERT (sgotplt != NULL); 4534 relocation = (sgotplt->output_offset 4535 + (get_plt_index (htab->plt_info, h->plt.offset) 4536 + 3) * 4); 4537 4538 #ifdef GOT_BIAS 4539 relocation -= GOT_BIAS; 4540 #endif 4541 4542 goto final_link_relocate; 4543 4544 force_got: 4545 case R_SH_GOT32: 4546 case R_SH_GOT20: 4547 #ifdef INCLUDE_SHMEDIA 4548 case R_SH_GOT_LOW16: 4549 case R_SH_GOT_MEDLOW16: 4550 case R_SH_GOT_MEDHI16: 4551 case R_SH_GOT_HI16: 4552 case R_SH_GOT10BY4: 4553 case R_SH_GOT10BY8: 4554 #endif 4555 /* Relocation is to the entry for this symbol in the global 4556 offset table. */ 4557 4558 BFD_ASSERT (htab); 4559 BFD_ASSERT (sgot != NULL); 4560 check_segment[0] = check_segment[1] = -1; 4561 4562 if (h != NULL) 4563 { 4564 bfd_boolean dyn; 4565 4566 off = h->got.offset; 4567 #ifdef INCLUDE_SHMEDIA 4568 if (seen_stt_datalabel) 4569 { 4570 struct elf_sh_link_hash_entry *hsh; 4571 4572 hsh = (struct elf_sh_link_hash_entry *)h; 4573 off = hsh->datalabel_got.offset; 4574 } 4575 #endif 4576 BFD_ASSERT (off != (bfd_vma) -1); 4577 4578 dyn = htab->root.dynamic_sections_created; 4579 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h) 4580 || (info->shared 4581 && SYMBOL_REFERENCES_LOCAL (info, h)) 4582 || (ELF_ST_VISIBILITY (h->other) 4583 && h->root.type == bfd_link_hash_undefweak)) 4584 { 4585 /* This is actually a static link, or it is a 4586 -Bsymbolic link and the symbol is defined 4587 locally, or the symbol was forced to be local 4588 because of a version file. We must initialize 4589 this entry in the global offset table. Since the 4590 offset must always be a multiple of 4, we use the 4591 least significant bit to record whether we have 4592 initialized it already. 4593 4594 When doing a dynamic link, we create a .rela.got 4595 relocation entry to initialize the value. This 4596 is done in the finish_dynamic_symbol routine. */ 4597 if ((off & 1) != 0) 4598 off &= ~1; 4599 else 4600 { 4601 bfd_put_32 (output_bfd, relocation, 4602 sgot->contents + off); 4603 #ifdef INCLUDE_SHMEDIA 4604 if (seen_stt_datalabel) 4605 { 4606 struct elf_sh_link_hash_entry *hsh; 4607 4608 hsh = (struct elf_sh_link_hash_entry *)h; 4609 hsh->datalabel_got.offset |= 1; 4610 } 4611 else 4612 #endif 4613 h->got.offset |= 1; 4614 4615 /* If we initialize the GOT entry here with a valid 4616 symbol address, also add a fixup. */ 4617 if (fdpic_p && !info->shared 4618 && sh_elf_hash_entry (h)->got_type == GOT_NORMAL 4619 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT 4620 || h->root.type != bfd_link_hash_undefweak)) 4621 sh_elf_add_rofixup (output_bfd, htab->srofixup, 4622 sgot->output_section->vma 4623 + sgot->output_offset 4624 + off); 4625 } 4626 } 4627 4628 relocation = sh_elf_got_offset (htab) + off; 4629 } 4630 else 4631 { 4632 #ifdef INCLUDE_SHMEDIA 4633 if (rel->r_addend) 4634 { 4635 BFD_ASSERT (local_got_offsets != NULL 4636 && (local_got_offsets[symtab_hdr->sh_info 4637 + r_symndx] 4638 != (bfd_vma) -1)); 4639 4640 off = local_got_offsets[symtab_hdr->sh_info 4641 + r_symndx]; 4642 } 4643 else 4644 { 4645 #endif 4646 BFD_ASSERT (local_got_offsets != NULL 4647 && local_got_offsets[r_symndx] != (bfd_vma) -1); 4648 4649 off = local_got_offsets[r_symndx]; 4650 #ifdef INCLUDE_SHMEDIA 4651 } 4652 #endif 4653 4654 /* The offset must always be a multiple of 4. We use 4655 the least significant bit to record whether we have 4656 already generated the necessary reloc. */ 4657 if ((off & 1) != 0) 4658 off &= ~1; 4659 else 4660 { 4661 bfd_put_32 (output_bfd, relocation, sgot->contents + off); 4662 4663 if (info->shared) 4664 { 4665 Elf_Internal_Rela outrel; 4666 bfd_byte *loc; 4667 4668 if (srelgot == NULL) 4669 { 4670 srelgot = bfd_get_linker_section (dynobj, 4671 ".rela.got"); 4672 BFD_ASSERT (srelgot != NULL); 4673 } 4674 4675 outrel.r_offset = (sgot->output_section->vma 4676 + sgot->output_offset 4677 + off); 4678 if (fdpic_p) 4679 { 4680 int dynindx 4681 = elf_section_data (sec->output_section)->dynindx; 4682 outrel.r_info = ELF32_R_INFO (dynindx, R_SH_DIR32); 4683 outrel.r_addend = relocation; 4684 outrel.r_addend -= sec->output_section->vma; 4685 } 4686 else 4687 { 4688 outrel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE); 4689 outrel.r_addend = relocation; 4690 } 4691 loc = srelgot->contents; 4692 loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela); 4693 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc); 4694 } 4695 else if (fdpic_p 4696 && (sh_elf_local_got_type (input_bfd) [r_symndx] 4697 == GOT_NORMAL)) 4698 sh_elf_add_rofixup (output_bfd, htab->srofixup, 4699 sgot->output_section->vma 4700 + sgot->output_offset 4701 + off); 4702 4703 #ifdef INCLUDE_SHMEDIA 4704 if (rel->r_addend) 4705 local_got_offsets[symtab_hdr->sh_info + r_symndx] |= 1; 4706 else 4707 #endif 4708 local_got_offsets[r_symndx] |= 1; 4709 } 4710 4711 relocation = sh_elf_got_offset (htab) + off; 4712 } 4713 4714 #ifdef GOT_BIAS 4715 relocation -= GOT_BIAS; 4716 #endif 4717 4718 if (r_type == R_SH_GOT20) 4719 { 4720 r = install_movi20_field (output_bfd, relocation + addend, 4721 input_bfd, input_section, contents, 4722 rel->r_offset); 4723 break; 4724 } 4725 else 4726 goto final_link_relocate; 4727 4728 case R_SH_GOTOFF: 4729 case R_SH_GOTOFF20: 4730 #ifdef INCLUDE_SHMEDIA 4731 case R_SH_GOTOFF_LOW16: 4732 case R_SH_GOTOFF_MEDLOW16: 4733 case R_SH_GOTOFF_MEDHI16: 4734 case R_SH_GOTOFF_HI16: 4735 #endif 4736 /* GOTOFF relocations are relative to _GLOBAL_OFFSET_TABLE_, which 4737 we place at the start of the .got.plt section. This is the same 4738 as the start of the output .got section, unless there are function 4739 descriptors in front of it. */ 4740 BFD_ASSERT (htab); 4741 BFD_ASSERT (sgotplt != NULL); 4742 check_segment[0] = got_segment; 4743 relocation -= sgotplt->output_section->vma + sgotplt->output_offset 4744 + htab->root.hgot->root.u.def.value; 4745 4746 #ifdef GOT_BIAS 4747 relocation -= GOT_BIAS; 4748 #endif 4749 4750 addend = rel->r_addend; 4751 4752 if (r_type == R_SH_GOTOFF20) 4753 { 4754 r = install_movi20_field (output_bfd, relocation + addend, 4755 input_bfd, input_section, contents, 4756 rel->r_offset); 4757 break; 4758 } 4759 else 4760 goto final_link_relocate; 4761 4762 case R_SH_GOTPC: 4763 #ifdef INCLUDE_SHMEDIA 4764 case R_SH_GOTPC_LOW16: 4765 case R_SH_GOTPC_MEDLOW16: 4766 case R_SH_GOTPC_MEDHI16: 4767 case R_SH_GOTPC_HI16: 4768 #endif 4769 /* Use global offset table as symbol value. */ 4770 4771 BFD_ASSERT (sgotplt != NULL); 4772 relocation = sgotplt->output_section->vma + sgotplt->output_offset; 4773 4774 #ifdef GOT_BIAS 4775 relocation += GOT_BIAS; 4776 #endif 4777 4778 addend = rel->r_addend; 4779 4780 goto final_link_relocate; 4781 4782 case R_SH_PLT32: 4783 #ifdef INCLUDE_SHMEDIA 4784 case R_SH_PLT_LOW16: 4785 case R_SH_PLT_MEDLOW16: 4786 case R_SH_PLT_MEDHI16: 4787 case R_SH_PLT_HI16: 4788 #endif 4789 /* Relocation is to the entry for this symbol in the 4790 procedure linkage table. */ 4791 4792 /* Resolve a PLT reloc against a local symbol directly, 4793 without using the procedure linkage table. */ 4794 if (h == NULL) 4795 goto final_link_relocate; 4796 4797 /* We don't want to warn on calls to undefined weak symbols, 4798 as calls to them must be protected by non-NULL tests 4799 anyway, and unprotected calls would invoke undefined 4800 behavior. */ 4801 if (h->root.type == bfd_link_hash_undefweak) 4802 check_segment[0] = check_segment[1] = -1; 4803 4804 if (h->forced_local) 4805 goto final_link_relocate; 4806 4807 if (h->plt.offset == (bfd_vma) -1) 4808 { 4809 /* We didn't make a PLT entry for this symbol. This 4810 happens when statically linking PIC code, or when 4811 using -Bsymbolic. */ 4812 goto final_link_relocate; 4813 } 4814 4815 BFD_ASSERT (splt != NULL); 4816 check_segment[1] = plt_segment; 4817 relocation = (splt->output_section->vma 4818 + splt->output_offset 4819 + h->plt.offset); 4820 4821 #ifdef INCLUDE_SHMEDIA 4822 relocation++; 4823 #endif 4824 4825 addend = rel->r_addend; 4826 4827 goto final_link_relocate; 4828 4829 /* Relocation is to the canonical function descriptor for this 4830 symbol, possibly via the GOT. Initialize the GOT 4831 entry and function descriptor if necessary. */ 4832 case R_SH_GOTFUNCDESC: 4833 case R_SH_GOTFUNCDESC20: 4834 case R_SH_FUNCDESC: 4835 { 4836 int dynindx = -1; 4837 asection *reloc_section; 4838 bfd_vma reloc_offset; 4839 int reloc_type = R_SH_FUNCDESC; 4840 4841 BFD_ASSERT (htab); 4842 4843 check_segment[0] = check_segment[1] = -1; 4844 4845 /* FIXME: See what FRV does for global symbols in the 4846 executable, with --export-dynamic. Do they need ld.so 4847 to allocate official descriptors? See what this code 4848 does. */ 4849 4850 relocation = 0; 4851 addend = 0; 4852 4853 if (r_type == R_SH_FUNCDESC) 4854 { 4855 reloc_section = input_section; 4856 reloc_offset = rel->r_offset; 4857 } 4858 else 4859 { 4860 reloc_section = sgot; 4861 4862 if (h != NULL) 4863 reloc_offset = h->got.offset; 4864 else 4865 { 4866 BFD_ASSERT (local_got_offsets != NULL); 4867 reloc_offset = local_got_offsets[r_symndx]; 4868 } 4869 BFD_ASSERT (reloc_offset != MINUS_ONE); 4870 4871 if (reloc_offset & 1) 4872 { 4873 reloc_offset &= ~1; 4874 goto funcdesc_done_got; 4875 } 4876 } 4877 4878 if (h && h->root.type == bfd_link_hash_undefweak 4879 && (SYMBOL_CALLS_LOCAL (info, h) 4880 || !htab->root.dynamic_sections_created)) 4881 /* Undefined weak symbol which will not be dynamically 4882 resolved later; leave it at zero. */ 4883 goto funcdesc_leave_zero; 4884 else if (SYMBOL_CALLS_LOCAL (info, h) 4885 && ! SYMBOL_FUNCDESC_LOCAL (info, h)) 4886 { 4887 /* If the symbol needs a non-local function descriptor 4888 but binds locally (i.e., its visibility is 4889 protected), emit a dynamic relocation decayed to 4890 section+offset. This is an optimization; the dynamic 4891 linker would resolve our function descriptor request 4892 to our copy of the function anyway. */ 4893 dynindx = elf_section_data (h->root.u.def.section 4894 ->output_section)->dynindx; 4895 relocation += h->root.u.def.section->output_offset 4896 + h->root.u.def.value; 4897 } 4898 else if (! SYMBOL_FUNCDESC_LOCAL (info, h)) 4899 { 4900 /* If the symbol is dynamic and there will be dynamic 4901 symbol resolution because we are or are linked with a 4902 shared library, emit a FUNCDESC relocation such that 4903 the dynamic linker will allocate the function 4904 descriptor. */ 4905 BFD_ASSERT (h->dynindx != -1); 4906 dynindx = h->dynindx; 4907 } 4908 else 4909 { 4910 bfd_vma offset; 4911 4912 /* Otherwise, we know we have a private function 4913 descriptor, so reference it directly. */ 4914 reloc_type = R_SH_DIR32; 4915 dynindx = elf_section_data (htab->sfuncdesc 4916 ->output_section)->dynindx; 4917 4918 if (h) 4919 { 4920 offset = sh_elf_hash_entry (h)->funcdesc.offset; 4921 BFD_ASSERT (offset != MINUS_ONE); 4922 if ((offset & 1) == 0) 4923 { 4924 if (!sh_elf_initialize_funcdesc (output_bfd, info, h, 4925 offset, NULL, 0)) 4926 return FALSE; 4927 sh_elf_hash_entry (h)->funcdesc.offset |= 1; 4928 } 4929 } 4930 else 4931 { 4932 union gotref *local_funcdesc; 4933 4934 local_funcdesc = sh_elf_local_funcdesc (input_bfd); 4935 offset = local_funcdesc[r_symndx].offset; 4936 BFD_ASSERT (offset != MINUS_ONE); 4937 if ((offset & 1) == 0) 4938 { 4939 if (!sh_elf_initialize_funcdesc (output_bfd, info, NULL, 4940 offset, sec, 4941 sym->st_value)) 4942 return FALSE; 4943 local_funcdesc[r_symndx].offset |= 1; 4944 } 4945 } 4946 4947 relocation = htab->sfuncdesc->output_offset + (offset & ~1); 4948 } 4949 4950 if (!info->shared && SYMBOL_FUNCDESC_LOCAL (info, h)) 4951 { 4952 bfd_vma offset; 4953 4954 if (sh_elf_osec_readonly_p (output_bfd, 4955 reloc_section->output_section)) 4956 { 4957 (*_bfd_error_handler) 4958 (_("%B(%A+0x%lx): cannot emit fixup to `%s' in read-only section"), 4959 input_bfd, 4960 input_section, 4961 (long) rel->r_offset, 4962 symname); 4963 return FALSE; 4964 } 4965 4966 offset = _bfd_elf_section_offset (output_bfd, info, 4967 reloc_section, reloc_offset); 4968 4969 if (offset != (bfd_vma)-1) 4970 sh_elf_add_rofixup (output_bfd, htab->srofixup, 4971 offset 4972 + reloc_section->output_section->vma 4973 + reloc_section->output_offset); 4974 } 4975 else if ((reloc_section->output_section->flags 4976 & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD)) 4977 { 4978 bfd_vma offset; 4979 4980 if (sh_elf_osec_readonly_p (output_bfd, 4981 reloc_section->output_section)) 4982 { 4983 info->callbacks->warning 4984 (info, 4985 _("cannot emit dynamic relocations in read-only section"), 4986 symname, input_bfd, reloc_section, reloc_offset); 4987 return FALSE; 4988 } 4989 4990 if (srelgot == NULL) 4991 { 4992 srelgot = bfd_get_linker_section (dynobj, ".rela.got"); 4993 BFD_ASSERT (srelgot != NULL); 4994 } 4995 4996 offset = _bfd_elf_section_offset (output_bfd, info, 4997 reloc_section, reloc_offset); 4998 4999 if (offset != (bfd_vma)-1) 5000 sh_elf_add_dyn_reloc (output_bfd, srelgot, 5001 offset 5002 + reloc_section->output_section->vma 5003 + reloc_section->output_offset, 5004 reloc_type, dynindx, relocation); 5005 5006 if (r_type == R_SH_FUNCDESC) 5007 { 5008 r = bfd_reloc_ok; 5009 break; 5010 } 5011 else 5012 { 5013 relocation = 0; 5014 goto funcdesc_leave_zero; 5015 } 5016 } 5017 5018 if (SYMBOL_FUNCDESC_LOCAL (info, h)) 5019 relocation += htab->sfuncdesc->output_section->vma; 5020 funcdesc_leave_zero: 5021 if (r_type != R_SH_FUNCDESC) 5022 { 5023 bfd_put_32 (output_bfd, relocation, 5024 reloc_section->contents + reloc_offset); 5025 if (h != NULL) 5026 h->got.offset |= 1; 5027 else 5028 local_got_offsets[r_symndx] |= 1; 5029 5030 funcdesc_done_got: 5031 5032 relocation = sh_elf_got_offset (htab) + reloc_offset; 5033 #ifdef GOT_BIAS 5034 relocation -= GOT_BIAS; 5035 #endif 5036 } 5037 if (r_type == R_SH_GOTFUNCDESC20) 5038 { 5039 r = install_movi20_field (output_bfd, relocation + addend, 5040 input_bfd, input_section, contents, 5041 rel->r_offset); 5042 break; 5043 } 5044 else 5045 goto final_link_relocate; 5046 } 5047 break; 5048 5049 case R_SH_GOTOFFFUNCDESC: 5050 case R_SH_GOTOFFFUNCDESC20: 5051 /* FIXME: See R_SH_FUNCDESC comment about global symbols in the 5052 executable and --export-dynamic. If such symbols get 5053 ld.so-allocated descriptors we can not use R_SH_GOTOFFFUNCDESC 5054 for them. */ 5055 BFD_ASSERT (htab); 5056 5057 check_segment[0] = check_segment[1] = -1; 5058 relocation = 0; 5059 addend = rel->r_addend; 5060 5061 if (h && (h->root.type == bfd_link_hash_undefweak 5062 || !SYMBOL_FUNCDESC_LOCAL (info, h))) 5063 { 5064 _bfd_error_handler 5065 (_("%B(%A+0x%lx): %s relocation against external symbol \"%s\""), 5066 input_bfd, input_section, (long) rel->r_offset, howto->name, 5067 h->root.root.string); 5068 return FALSE; 5069 } 5070 else 5071 { 5072 bfd_vma offset; 5073 5074 /* Otherwise, we know we have a private function 5075 descriptor, so reference it directly. */ 5076 if (h) 5077 { 5078 offset = sh_elf_hash_entry (h)->funcdesc.offset; 5079 BFD_ASSERT (offset != MINUS_ONE); 5080 if ((offset & 1) == 0) 5081 { 5082 if (!sh_elf_initialize_funcdesc (output_bfd, info, h, 5083 offset, NULL, 0)) 5084 return FALSE; 5085 sh_elf_hash_entry (h)->funcdesc.offset |= 1; 5086 } 5087 } 5088 else 5089 { 5090 union gotref *local_funcdesc; 5091 5092 local_funcdesc = sh_elf_local_funcdesc (input_bfd); 5093 offset = local_funcdesc[r_symndx].offset; 5094 BFD_ASSERT (offset != MINUS_ONE); 5095 if ((offset & 1) == 0) 5096 { 5097 if (!sh_elf_initialize_funcdesc (output_bfd, info, NULL, 5098 offset, sec, 5099 sym->st_value)) 5100 return FALSE; 5101 local_funcdesc[r_symndx].offset |= 1; 5102 } 5103 } 5104 5105 relocation = htab->sfuncdesc->output_offset + (offset & ~1); 5106 } 5107 5108 relocation -= (htab->root.hgot->root.u.def.value 5109 + sgotplt->output_offset); 5110 #ifdef GOT_BIAS 5111 relocation -= GOT_BIAS; 5112 #endif 5113 5114 if (r_type == R_SH_GOTOFFFUNCDESC20) 5115 { 5116 r = install_movi20_field (output_bfd, relocation + addend, 5117 input_bfd, input_section, contents, 5118 rel->r_offset); 5119 break; 5120 } 5121 else 5122 goto final_link_relocate; 5123 5124 case R_SH_LOOP_START: 5125 { 5126 static bfd_vma start, end; 5127 5128 start = (relocation + rel->r_addend 5129 - (sec->output_section->vma + sec->output_offset)); 5130 r = sh_elf_reloc_loop (r_type, input_bfd, input_section, contents, 5131 rel->r_offset, sec, start, end); 5132 break; 5133 5134 case R_SH_LOOP_END: 5135 end = (relocation + rel->r_addend 5136 - (sec->output_section->vma + sec->output_offset)); 5137 r = sh_elf_reloc_loop (r_type, input_bfd, input_section, contents, 5138 rel->r_offset, sec, start, end); 5139 break; 5140 } 5141 5142 case R_SH_TLS_GD_32: 5143 case R_SH_TLS_IE_32: 5144 BFD_ASSERT (htab); 5145 check_segment[0] = check_segment[1] = -1; 5146 r_type = sh_elf_optimized_tls_reloc (info, r_type, h == NULL); 5147 got_type = GOT_UNKNOWN; 5148 if (h == NULL && local_got_offsets) 5149 got_type = sh_elf_local_got_type (input_bfd) [r_symndx]; 5150 else if (h != NULL) 5151 { 5152 got_type = sh_elf_hash_entry (h)->got_type; 5153 if (! info->shared 5154 && (h->dynindx == -1 5155 || h->def_regular)) 5156 r_type = R_SH_TLS_LE_32; 5157 } 5158 5159 if (r_type == R_SH_TLS_GD_32 && got_type == GOT_TLS_IE) 5160 r_type = R_SH_TLS_IE_32; 5161 5162 if (r_type == R_SH_TLS_LE_32) 5163 { 5164 bfd_vma offset; 5165 unsigned short insn; 5166 5167 if (ELF32_R_TYPE (rel->r_info) == R_SH_TLS_GD_32) 5168 { 5169 /* GD->LE transition: 5170 mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1; 5171 jsr @r1; add r12,r4; bra 3f; nop; .align 2; 5172 1: .long x$TLSGD; 2: .long __tls_get_addr@PLT; 3: 5173 We change it into: 5174 mov.l 1f,r4; stc gbr,r0; add r4,r0; nop; 5175 nop; nop; ... 5176 1: .long x@TPOFF; 2: .long __tls_get_addr@PLT; 3:. */ 5177 5178 offset = rel->r_offset; 5179 BFD_ASSERT (offset >= 16); 5180 /* Size of GD instructions is 16 or 18. */ 5181 offset -= 16; 5182 insn = bfd_get_16 (input_bfd, contents + offset + 0); 5183 if ((insn & 0xff00) == 0xc700) 5184 { 5185 BFD_ASSERT (offset >= 2); 5186 offset -= 2; 5187 insn = bfd_get_16 (input_bfd, contents + offset + 0); 5188 } 5189 5190 BFD_ASSERT ((insn & 0xff00) == 0xd400); 5191 insn = bfd_get_16 (input_bfd, contents + offset + 2); 5192 BFD_ASSERT ((insn & 0xff00) == 0xc700); 5193 insn = bfd_get_16 (input_bfd, contents + offset + 4); 5194 BFD_ASSERT ((insn & 0xff00) == 0xd100); 5195 insn = bfd_get_16 (input_bfd, contents + offset + 6); 5196 BFD_ASSERT (insn == 0x310c); 5197 insn = bfd_get_16 (input_bfd, contents + offset + 8); 5198 BFD_ASSERT (insn == 0x410b); 5199 insn = bfd_get_16 (input_bfd, contents + offset + 10); 5200 BFD_ASSERT (insn == 0x34cc); 5201 5202 bfd_put_16 (output_bfd, 0x0012, contents + offset + 2); 5203 bfd_put_16 (output_bfd, 0x304c, contents + offset + 4); 5204 bfd_put_16 (output_bfd, 0x0009, contents + offset + 6); 5205 bfd_put_16 (output_bfd, 0x0009, contents + offset + 8); 5206 bfd_put_16 (output_bfd, 0x0009, contents + offset + 10); 5207 } 5208 else 5209 { 5210 int target; 5211 5212 /* IE->LE transition: 5213 mov.l 1f,r0; stc gbr,rN; mov.l @(r0,r12),rM; 5214 bra 2f; add ...; .align 2; 1: x@GOTTPOFF; 2: 5215 We change it into: 5216 mov.l .Ln,rM; stc gbr,rN; nop; ...; 5217 1: x@TPOFF; 2:. */ 5218 5219 offset = rel->r_offset; 5220 BFD_ASSERT (offset >= 16); 5221 /* Size of IE instructions is 10 or 12. */ 5222 offset -= 10; 5223 insn = bfd_get_16 (input_bfd, contents + offset + 0); 5224 if ((insn & 0xf0ff) == 0x0012) 5225 { 5226 BFD_ASSERT (offset >= 2); 5227 offset -= 2; 5228 insn = bfd_get_16 (input_bfd, contents + offset + 0); 5229 } 5230 5231 BFD_ASSERT ((insn & 0xff00) == 0xd000); 5232 target = insn & 0x00ff; 5233 insn = bfd_get_16 (input_bfd, contents + offset + 2); 5234 BFD_ASSERT ((insn & 0xf0ff) == 0x0012); 5235 insn = bfd_get_16 (input_bfd, contents + offset + 4); 5236 BFD_ASSERT ((insn & 0xf0ff) == 0x00ce); 5237 insn = 0xd000 | (insn & 0x0f00) | target; 5238 bfd_put_16 (output_bfd, insn, contents + offset + 0); 5239 bfd_put_16 (output_bfd, 0x0009, contents + offset + 4); 5240 } 5241 5242 bfd_put_32 (output_bfd, tpoff (info, relocation), 5243 contents + rel->r_offset); 5244 continue; 5245 } 5246 5247 if (sgot == NULL || sgotplt == NULL) 5248 abort (); 5249 5250 if (h != NULL) 5251 off = h->got.offset; 5252 else 5253 { 5254 if (local_got_offsets == NULL) 5255 abort (); 5256 5257 off = local_got_offsets[r_symndx]; 5258 } 5259 5260 /* Relocate R_SH_TLS_IE_32 directly when statically linking. */ 5261 if (r_type == R_SH_TLS_IE_32 5262 && ! htab->root.dynamic_sections_created) 5263 { 5264 off &= ~1; 5265 bfd_put_32 (output_bfd, tpoff (info, relocation), 5266 sgot->contents + off); 5267 bfd_put_32 (output_bfd, sh_elf_got_offset (htab) + off, 5268 contents + rel->r_offset); 5269 continue; 5270 } 5271 5272 if ((off & 1) != 0) 5273 off &= ~1; 5274 else 5275 { 5276 Elf_Internal_Rela outrel; 5277 bfd_byte *loc; 5278 int dr_type, indx; 5279 5280 if (srelgot == NULL) 5281 { 5282 srelgot = bfd_get_linker_section (dynobj, ".rela.got"); 5283 BFD_ASSERT (srelgot != NULL); 5284 } 5285 5286 outrel.r_offset = (sgot->output_section->vma 5287 + sgot->output_offset + off); 5288 5289 if (h == NULL || h->dynindx == -1) 5290 indx = 0; 5291 else 5292 indx = h->dynindx; 5293 5294 dr_type = (r_type == R_SH_TLS_GD_32 ? R_SH_TLS_DTPMOD32 : 5295 R_SH_TLS_TPOFF32); 5296 if (dr_type == R_SH_TLS_TPOFF32 && indx == 0) 5297 outrel.r_addend = relocation - dtpoff_base (info); 5298 else 5299 outrel.r_addend = 0; 5300 outrel.r_info = ELF32_R_INFO (indx, dr_type); 5301 loc = srelgot->contents; 5302 loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela); 5303 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc); 5304 5305 if (r_type == R_SH_TLS_GD_32) 5306 { 5307 if (indx == 0) 5308 { 5309 bfd_put_32 (output_bfd, 5310 relocation - dtpoff_base (info), 5311 sgot->contents + off + 4); 5312 } 5313 else 5314 { 5315 outrel.r_info = ELF32_R_INFO (indx, 5316 R_SH_TLS_DTPOFF32); 5317 outrel.r_offset += 4; 5318 outrel.r_addend = 0; 5319 srelgot->reloc_count++; 5320 loc += sizeof (Elf32_External_Rela); 5321 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc); 5322 } 5323 } 5324 5325 if (h != NULL) 5326 h->got.offset |= 1; 5327 else 5328 local_got_offsets[r_symndx] |= 1; 5329 } 5330 5331 if (off >= (bfd_vma) -2) 5332 abort (); 5333 5334 if (r_type == (int) ELF32_R_TYPE (rel->r_info)) 5335 relocation = sh_elf_got_offset (htab) + off; 5336 else 5337 { 5338 bfd_vma offset; 5339 unsigned short insn; 5340 5341 /* GD->IE transition: 5342 mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1; 5343 jsr @r1; add r12,r4; bra 3f; nop; .align 2; 5344 1: .long x$TLSGD; 2: .long __tls_get_addr@PLT; 3: 5345 We change it into: 5346 mov.l 1f,r0; stc gbr,r4; mov.l @(r0,r12),r0; add r4,r0; 5347 nop; nop; bra 3f; nop; .align 2; 5348 1: .long x@TPOFF; 2:...; 3:. */ 5349 5350 offset = rel->r_offset; 5351 BFD_ASSERT (offset >= 16); 5352 /* Size of GD instructions is 16 or 18. */ 5353 offset -= 16; 5354 insn = bfd_get_16 (input_bfd, contents + offset + 0); 5355 if ((insn & 0xff00) == 0xc700) 5356 { 5357 BFD_ASSERT (offset >= 2); 5358 offset -= 2; 5359 insn = bfd_get_16 (input_bfd, contents + offset + 0); 5360 } 5361 5362 BFD_ASSERT ((insn & 0xff00) == 0xd400); 5363 5364 /* Replace mov.l 1f,R4 with mov.l 1f,r0. */ 5365 bfd_put_16 (output_bfd, insn & 0xf0ff, contents + offset); 5366 5367 insn = bfd_get_16 (input_bfd, contents + offset + 2); 5368 BFD_ASSERT ((insn & 0xff00) == 0xc700); 5369 insn = bfd_get_16 (input_bfd, contents + offset + 4); 5370 BFD_ASSERT ((insn & 0xff00) == 0xd100); 5371 insn = bfd_get_16 (input_bfd, contents + offset + 6); 5372 BFD_ASSERT (insn == 0x310c); 5373 insn = bfd_get_16 (input_bfd, contents + offset + 8); 5374 BFD_ASSERT (insn == 0x410b); 5375 insn = bfd_get_16 (input_bfd, contents + offset + 10); 5376 BFD_ASSERT (insn == 0x34cc); 5377 5378 bfd_put_16 (output_bfd, 0x0412, contents + offset + 2); 5379 bfd_put_16 (output_bfd, 0x00ce, contents + offset + 4); 5380 bfd_put_16 (output_bfd, 0x304c, contents + offset + 6); 5381 bfd_put_16 (output_bfd, 0x0009, contents + offset + 8); 5382 bfd_put_16 (output_bfd, 0x0009, contents + offset + 10); 5383 5384 bfd_put_32 (output_bfd, sh_elf_got_offset (htab) + off, 5385 contents + rel->r_offset); 5386 5387 continue; 5388 } 5389 5390 addend = rel->r_addend; 5391 5392 goto final_link_relocate; 5393 5394 case R_SH_TLS_LD_32: 5395 BFD_ASSERT (htab); 5396 check_segment[0] = check_segment[1] = -1; 5397 if (! info->shared) 5398 { 5399 bfd_vma offset; 5400 unsigned short insn; 5401 5402 /* LD->LE transition: 5403 mov.l 1f,r4; mova 2f,r0; mov.l 2f,r1; add r0,r1; 5404 jsr @r1; add r12,r4; bra 3f; nop; .align 2; 5405 1: .long x$TLSLD; 2: .long __tls_get_addr@PLT; 3: 5406 We change it into: 5407 stc gbr,r0; nop; nop; nop; 5408 nop; nop; bra 3f; ...; 3:. */ 5409 5410 offset = rel->r_offset; 5411 BFD_ASSERT (offset >= 16); 5412 /* Size of LD instructions is 16 or 18. */ 5413 offset -= 16; 5414 insn = bfd_get_16 (input_bfd, contents + offset + 0); 5415 if ((insn & 0xff00) == 0xc700) 5416 { 5417 BFD_ASSERT (offset >= 2); 5418 offset -= 2; 5419 insn = bfd_get_16 (input_bfd, contents + offset + 0); 5420 } 5421 5422 BFD_ASSERT ((insn & 0xff00) == 0xd400); 5423 insn = bfd_get_16 (input_bfd, contents + offset + 2); 5424 BFD_ASSERT ((insn & 0xff00) == 0xc700); 5425 insn = bfd_get_16 (input_bfd, contents + offset + 4); 5426 BFD_ASSERT ((insn & 0xff00) == 0xd100); 5427 insn = bfd_get_16 (input_bfd, contents + offset + 6); 5428 BFD_ASSERT (insn == 0x310c); 5429 insn = bfd_get_16 (input_bfd, contents + offset + 8); 5430 BFD_ASSERT (insn == 0x410b); 5431 insn = bfd_get_16 (input_bfd, contents + offset + 10); 5432 BFD_ASSERT (insn == 0x34cc); 5433 5434 bfd_put_16 (output_bfd, 0x0012, contents + offset + 0); 5435 bfd_put_16 (output_bfd, 0x0009, contents + offset + 2); 5436 bfd_put_16 (output_bfd, 0x0009, contents + offset + 4); 5437 bfd_put_16 (output_bfd, 0x0009, contents + offset + 6); 5438 bfd_put_16 (output_bfd, 0x0009, contents + offset + 8); 5439 bfd_put_16 (output_bfd, 0x0009, contents + offset + 10); 5440 5441 continue; 5442 } 5443 5444 if (sgot == NULL || sgotplt == NULL) 5445 abort (); 5446 5447 off = htab->tls_ldm_got.offset; 5448 if (off & 1) 5449 off &= ~1; 5450 else 5451 { 5452 Elf_Internal_Rela outrel; 5453 bfd_byte *loc; 5454 5455 srelgot = htab->srelgot; 5456 if (srelgot == NULL) 5457 abort (); 5458 5459 outrel.r_offset = (sgot->output_section->vma 5460 + sgot->output_offset + off); 5461 outrel.r_addend = 0; 5462 outrel.r_info = ELF32_R_INFO (0, R_SH_TLS_DTPMOD32); 5463 loc = srelgot->contents; 5464 loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela); 5465 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc); 5466 htab->tls_ldm_got.offset |= 1; 5467 } 5468 5469 relocation = sh_elf_got_offset (htab) + off; 5470 addend = rel->r_addend; 5471 5472 goto final_link_relocate; 5473 5474 case R_SH_TLS_LDO_32: 5475 check_segment[0] = check_segment[1] = -1; 5476 if (! info->shared) 5477 relocation = tpoff (info, relocation); 5478 else 5479 relocation -= dtpoff_base (info); 5480 5481 addend = rel->r_addend; 5482 goto final_link_relocate; 5483 5484 case R_SH_TLS_LE_32: 5485 { 5486 int indx; 5487 Elf_Internal_Rela outrel; 5488 bfd_byte *loc; 5489 5490 check_segment[0] = check_segment[1] = -1; 5491 5492 if (! info->shared || info->pie) 5493 { 5494 relocation = tpoff (info, relocation); 5495 addend = rel->r_addend; 5496 goto final_link_relocate; 5497 } 5498 5499 if (sreloc == NULL) 5500 { 5501 sreloc = _bfd_elf_get_dynamic_reloc_section 5502 (input_bfd, input_section, /*rela?*/ TRUE); 5503 if (sreloc == NULL) 5504 return FALSE; 5505 } 5506 5507 if (h == NULL || h->dynindx == -1) 5508 indx = 0; 5509 else 5510 indx = h->dynindx; 5511 5512 outrel.r_offset = (input_section->output_section->vma 5513 + input_section->output_offset 5514 + rel->r_offset); 5515 outrel.r_info = ELF32_R_INFO (indx, R_SH_TLS_TPOFF32); 5516 if (indx == 0) 5517 outrel.r_addend = relocation - dtpoff_base (info); 5518 else 5519 outrel.r_addend = 0; 5520 5521 loc = sreloc->contents; 5522 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela); 5523 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc); 5524 continue; 5525 } 5526 } 5527 5528 relocation_done: 5529 if (fdpic_p && check_segment[0] != (unsigned) -1 5530 && check_segment[0] != check_segment[1]) 5531 { 5532 /* We don't want duplicate errors for undefined symbols. */ 5533 if (!h || h->root.type != bfd_link_hash_undefined) 5534 { 5535 if (info->shared) 5536 { 5537 info->callbacks->einfo 5538 (_("%X%C: relocation to \"%s\" references a different segment\n"), 5539 input_bfd, input_section, rel->r_offset, symname); 5540 return FALSE; 5541 } 5542 else 5543 info->callbacks->einfo 5544 (_("%C: warning: relocation to \"%s\" references a different segment\n"), 5545 input_bfd, input_section, rel->r_offset, symname); 5546 } 5547 5548 elf_elfheader (output_bfd)->e_flags &= ~EF_SH_PIC; 5549 } 5550 5551 if (r != bfd_reloc_ok) 5552 { 5553 switch (r) 5554 { 5555 default: 5556 case bfd_reloc_outofrange: 5557 abort (); 5558 case bfd_reloc_overflow: 5559 { 5560 const char *name; 5561 5562 if (h != NULL) 5563 name = NULL; 5564 else 5565 { 5566 name = (bfd_elf_string_from_elf_section 5567 (input_bfd, symtab_hdr->sh_link, sym->st_name)); 5568 if (name == NULL) 5569 return FALSE; 5570 if (*name == '\0') 5571 name = bfd_section_name (input_bfd, sec); 5572 } 5573 if (! ((*info->callbacks->reloc_overflow) 5574 (info, (h ? &h->root : NULL), name, howto->name, 5575 (bfd_vma) 0, input_bfd, input_section, 5576 rel->r_offset))) 5577 return FALSE; 5578 } 5579 break; 5580 } 5581 } 5582 } 5583 5584 return TRUE; 5585 } 5586 5587 /* This is a version of bfd_generic_get_relocated_section_contents 5588 which uses sh_elf_relocate_section. */ 5589 5590 static bfd_byte * 5591 sh_elf_get_relocated_section_contents (bfd *output_bfd, 5592 struct bfd_link_info *link_info, 5593 struct bfd_link_order *link_order, 5594 bfd_byte *data, 5595 bfd_boolean relocatable, 5596 asymbol **symbols) 5597 { 5598 Elf_Internal_Shdr *symtab_hdr; 5599 asection *input_section = link_order->u.indirect.section; 5600 bfd *input_bfd = input_section->owner; 5601 asection **sections = NULL; 5602 Elf_Internal_Rela *internal_relocs = NULL; 5603 Elf_Internal_Sym *isymbuf = NULL; 5604 5605 /* We only need to handle the case of relaxing, or of having a 5606 particular set of section contents, specially. */ 5607 if (relocatable 5608 || elf_section_data (input_section)->this_hdr.contents == NULL) 5609 return bfd_generic_get_relocated_section_contents (output_bfd, link_info, 5610 link_order, data, 5611 relocatable, 5612 symbols); 5613 5614 symtab_hdr = &elf_symtab_hdr (input_bfd); 5615 5616 memcpy (data, elf_section_data (input_section)->this_hdr.contents, 5617 (size_t) input_section->size); 5618 5619 if ((input_section->flags & SEC_RELOC) != 0 5620 && input_section->reloc_count > 0) 5621 { 5622 asection **secpp; 5623 Elf_Internal_Sym *isym, *isymend; 5624 bfd_size_type amt; 5625 5626 internal_relocs = (_bfd_elf_link_read_relocs 5627 (input_bfd, input_section, NULL, 5628 (Elf_Internal_Rela *) NULL, FALSE)); 5629 if (internal_relocs == NULL) 5630 goto error_return; 5631 5632 if (symtab_hdr->sh_info != 0) 5633 { 5634 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents; 5635 if (isymbuf == NULL) 5636 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, 5637 symtab_hdr->sh_info, 0, 5638 NULL, NULL, NULL); 5639 if (isymbuf == NULL) 5640 goto error_return; 5641 } 5642 5643 amt = symtab_hdr->sh_info; 5644 amt *= sizeof (asection *); 5645 sections = (asection **) bfd_malloc (amt); 5646 if (sections == NULL && amt != 0) 5647 goto error_return; 5648 5649 isymend = isymbuf + symtab_hdr->sh_info; 5650 for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp) 5651 { 5652 asection *isec; 5653 5654 if (isym->st_shndx == SHN_UNDEF) 5655 isec = bfd_und_section_ptr; 5656 else if (isym->st_shndx == SHN_ABS) 5657 isec = bfd_abs_section_ptr; 5658 else if (isym->st_shndx == SHN_COMMON) 5659 isec = bfd_com_section_ptr; 5660 else 5661 isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx); 5662 5663 *secpp = isec; 5664 } 5665 5666 if (! sh_elf_relocate_section (output_bfd, link_info, input_bfd, 5667 input_section, data, internal_relocs, 5668 isymbuf, sections)) 5669 goto error_return; 5670 5671 if (sections != NULL) 5672 free (sections); 5673 if (isymbuf != NULL 5674 && symtab_hdr->contents != (unsigned char *) isymbuf) 5675 free (isymbuf); 5676 if (elf_section_data (input_section)->relocs != internal_relocs) 5677 free (internal_relocs); 5678 } 5679 5680 return data; 5681 5682 error_return: 5683 if (sections != NULL) 5684 free (sections); 5685 if (isymbuf != NULL 5686 && symtab_hdr->contents != (unsigned char *) isymbuf) 5687 free (isymbuf); 5688 if (internal_relocs != NULL 5689 && elf_section_data (input_section)->relocs != internal_relocs) 5690 free (internal_relocs); 5691 return NULL; 5692 } 5693 5694 /* Return the base VMA address which should be subtracted from real addresses 5695 when resolving @dtpoff relocation. 5696 This is PT_TLS segment p_vaddr. */ 5697 5698 static bfd_vma 5699 dtpoff_base (struct bfd_link_info *info) 5700 { 5701 /* If tls_sec is NULL, we should have signalled an error already. */ 5702 if (elf_hash_table (info)->tls_sec == NULL) 5703 return 0; 5704 return elf_hash_table (info)->tls_sec->vma; 5705 } 5706 5707 /* Return the relocation value for R_SH_TLS_TPOFF32.. */ 5708 5709 static bfd_vma 5710 tpoff (struct bfd_link_info *info, bfd_vma address) 5711 { 5712 /* If tls_sec is NULL, we should have signalled an error already. */ 5713 if (elf_hash_table (info)->tls_sec == NULL) 5714 return 0; 5715 /* SH TLS ABI is variant I and static TLS block start just after tcbhead 5716 structure which has 2 pointer fields. */ 5717 return (address - elf_hash_table (info)->tls_sec->vma 5718 + align_power ((bfd_vma) 8, 5719 elf_hash_table (info)->tls_sec->alignment_power)); 5720 } 5721 5722 static asection * 5723 sh_elf_gc_mark_hook (asection *sec, 5724 struct bfd_link_info *info, 5725 Elf_Internal_Rela *rel, 5726 struct elf_link_hash_entry *h, 5727 Elf_Internal_Sym *sym) 5728 { 5729 if (h != NULL) 5730 switch (ELF32_R_TYPE (rel->r_info)) 5731 { 5732 case R_SH_GNU_VTINHERIT: 5733 case R_SH_GNU_VTENTRY: 5734 return NULL; 5735 } 5736 5737 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym); 5738 } 5739 5740 /* Update the got entry reference counts for the section being removed. */ 5741 5742 static bfd_boolean 5743 sh_elf_gc_sweep_hook (bfd *abfd, struct bfd_link_info *info, 5744 asection *sec, const Elf_Internal_Rela *relocs) 5745 { 5746 Elf_Internal_Shdr *symtab_hdr; 5747 struct elf_link_hash_entry **sym_hashes; 5748 bfd_signed_vma *local_got_refcounts; 5749 union gotref *local_funcdesc; 5750 const Elf_Internal_Rela *rel, *relend; 5751 5752 if (info->relocatable) 5753 return TRUE; 5754 5755 elf_section_data (sec)->local_dynrel = NULL; 5756 5757 symtab_hdr = &elf_symtab_hdr (abfd); 5758 sym_hashes = elf_sym_hashes (abfd); 5759 local_got_refcounts = elf_local_got_refcounts (abfd); 5760 local_funcdesc = sh_elf_local_funcdesc (abfd); 5761 5762 relend = relocs + sec->reloc_count; 5763 for (rel = relocs; rel < relend; rel++) 5764 { 5765 unsigned long r_symndx; 5766 unsigned int r_type; 5767 struct elf_link_hash_entry *h = NULL; 5768 #ifdef INCLUDE_SHMEDIA 5769 int seen_stt_datalabel = 0; 5770 #endif 5771 5772 r_symndx = ELF32_R_SYM (rel->r_info); 5773 if (r_symndx >= symtab_hdr->sh_info) 5774 { 5775 struct elf_sh_link_hash_entry *eh; 5776 struct elf_sh_dyn_relocs **pp; 5777 struct elf_sh_dyn_relocs *p; 5778 5779 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 5780 while (h->root.type == bfd_link_hash_indirect 5781 || h->root.type == bfd_link_hash_warning) 5782 { 5783 #ifdef INCLUDE_SHMEDIA 5784 seen_stt_datalabel |= h->type == STT_DATALABEL; 5785 #endif 5786 h = (struct elf_link_hash_entry *) h->root.u.i.link; 5787 } 5788 eh = (struct elf_sh_link_hash_entry *) h; 5789 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next) 5790 if (p->sec == sec) 5791 { 5792 /* Everything must go for SEC. */ 5793 *pp = p->next; 5794 break; 5795 } 5796 } 5797 5798 r_type = ELF32_R_TYPE (rel->r_info); 5799 switch (sh_elf_optimized_tls_reloc (info, r_type, h != NULL)) 5800 { 5801 case R_SH_TLS_LD_32: 5802 if (sh_elf_hash_table (info)->tls_ldm_got.refcount > 0) 5803 sh_elf_hash_table (info)->tls_ldm_got.refcount -= 1; 5804 break; 5805 5806 case R_SH_GOT32: 5807 case R_SH_GOT20: 5808 case R_SH_GOTOFF: 5809 case R_SH_GOTOFF20: 5810 case R_SH_GOTPC: 5811 #ifdef INCLUDE_SHMEDIA 5812 case R_SH_GOT_LOW16: 5813 case R_SH_GOT_MEDLOW16: 5814 case R_SH_GOT_MEDHI16: 5815 case R_SH_GOT_HI16: 5816 case R_SH_GOT10BY4: 5817 case R_SH_GOT10BY8: 5818 case R_SH_GOTOFF_LOW16: 5819 case R_SH_GOTOFF_MEDLOW16: 5820 case R_SH_GOTOFF_MEDHI16: 5821 case R_SH_GOTOFF_HI16: 5822 case R_SH_GOTPC_LOW16: 5823 case R_SH_GOTPC_MEDLOW16: 5824 case R_SH_GOTPC_MEDHI16: 5825 case R_SH_GOTPC_HI16: 5826 #endif 5827 case R_SH_TLS_GD_32: 5828 case R_SH_TLS_IE_32: 5829 case R_SH_GOTFUNCDESC: 5830 case R_SH_GOTFUNCDESC20: 5831 if (h != NULL) 5832 { 5833 #ifdef INCLUDE_SHMEDIA 5834 if (seen_stt_datalabel) 5835 { 5836 struct elf_sh_link_hash_entry *eh; 5837 eh = (struct elf_sh_link_hash_entry *) h; 5838 if (eh->datalabel_got.refcount > 0) 5839 eh->datalabel_got.refcount -= 1; 5840 } 5841 else 5842 #endif 5843 if (h->got.refcount > 0) 5844 h->got.refcount -= 1; 5845 } 5846 else if (local_got_refcounts != NULL) 5847 { 5848 #ifdef INCLUDE_SHMEDIA 5849 if (rel->r_addend & 1) 5850 { 5851 if (local_got_refcounts[symtab_hdr->sh_info + r_symndx] > 0) 5852 local_got_refcounts[symtab_hdr->sh_info + r_symndx] -= 1; 5853 } 5854 else 5855 #endif 5856 if (local_got_refcounts[r_symndx] > 0) 5857 local_got_refcounts[r_symndx] -= 1; 5858 } 5859 break; 5860 5861 case R_SH_FUNCDESC: 5862 if (h != NULL) 5863 sh_elf_hash_entry (h)->abs_funcdesc_refcount -= 1; 5864 else if (sh_elf_hash_table (info)->fdpic_p && !info->shared) 5865 sh_elf_hash_table (info)->srofixup->size -= 4; 5866 5867 /* Fall through. */ 5868 5869 case R_SH_GOTOFFFUNCDESC: 5870 case R_SH_GOTOFFFUNCDESC20: 5871 if (h != NULL) 5872 sh_elf_hash_entry (h)->funcdesc.refcount -= 1; 5873 else 5874 local_funcdesc[r_symndx].refcount -= 1; 5875 break; 5876 5877 case R_SH_DIR32: 5878 if (sh_elf_hash_table (info)->fdpic_p && !info->shared 5879 && (sec->flags & SEC_ALLOC) != 0) 5880 sh_elf_hash_table (info)->srofixup->size -= 4; 5881 /* Fall thru */ 5882 5883 case R_SH_REL32: 5884 if (info->shared) 5885 break; 5886 /* Fall thru */ 5887 5888 case R_SH_PLT32: 5889 #ifdef INCLUDE_SHMEDIA 5890 case R_SH_PLT_LOW16: 5891 case R_SH_PLT_MEDLOW16: 5892 case R_SH_PLT_MEDHI16: 5893 case R_SH_PLT_HI16: 5894 #endif 5895 if (h != NULL) 5896 { 5897 if (h->plt.refcount > 0) 5898 h->plt.refcount -= 1; 5899 } 5900 break; 5901 5902 case R_SH_GOTPLT32: 5903 #ifdef INCLUDE_SHMEDIA 5904 case R_SH_GOTPLT_LOW16: 5905 case R_SH_GOTPLT_MEDLOW16: 5906 case R_SH_GOTPLT_MEDHI16: 5907 case R_SH_GOTPLT_HI16: 5908 case R_SH_GOTPLT10BY4: 5909 case R_SH_GOTPLT10BY8: 5910 #endif 5911 if (h != NULL) 5912 { 5913 struct elf_sh_link_hash_entry *eh; 5914 eh = (struct elf_sh_link_hash_entry *) h; 5915 if (eh->gotplt_refcount > 0) 5916 { 5917 eh->gotplt_refcount -= 1; 5918 if (h->plt.refcount > 0) 5919 h->plt.refcount -= 1; 5920 } 5921 #ifdef INCLUDE_SHMEDIA 5922 else if (seen_stt_datalabel) 5923 { 5924 if (eh->datalabel_got.refcount > 0) 5925 eh->datalabel_got.refcount -= 1; 5926 } 5927 #endif 5928 else if (h->got.refcount > 0) 5929 h->got.refcount -= 1; 5930 } 5931 else if (local_got_refcounts != NULL) 5932 { 5933 #ifdef INCLUDE_SHMEDIA 5934 if (rel->r_addend & 1) 5935 { 5936 if (local_got_refcounts[symtab_hdr->sh_info + r_symndx] > 0) 5937 local_got_refcounts[symtab_hdr->sh_info + r_symndx] -= 1; 5938 } 5939 else 5940 #endif 5941 if (local_got_refcounts[r_symndx] > 0) 5942 local_got_refcounts[r_symndx] -= 1; 5943 } 5944 break; 5945 5946 default: 5947 break; 5948 } 5949 } 5950 5951 return TRUE; 5952 } 5953 5954 /* Copy the extra info we tack onto an elf_link_hash_entry. */ 5955 5956 static void 5957 sh_elf_copy_indirect_symbol (struct bfd_link_info *info, 5958 struct elf_link_hash_entry *dir, 5959 struct elf_link_hash_entry *ind) 5960 { 5961 struct elf_sh_link_hash_entry *edir, *eind; 5962 5963 edir = (struct elf_sh_link_hash_entry *) dir; 5964 eind = (struct elf_sh_link_hash_entry *) ind; 5965 5966 if (eind->dyn_relocs != NULL) 5967 { 5968 if (edir->dyn_relocs != NULL) 5969 { 5970 struct elf_sh_dyn_relocs **pp; 5971 struct elf_sh_dyn_relocs *p; 5972 5973 /* Add reloc counts against the indirect sym to the direct sym 5974 list. Merge any entries against the same section. */ 5975 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; ) 5976 { 5977 struct elf_sh_dyn_relocs *q; 5978 5979 for (q = edir->dyn_relocs; q != NULL; q = q->next) 5980 if (q->sec == p->sec) 5981 { 5982 q->pc_count += p->pc_count; 5983 q->count += p->count; 5984 *pp = p->next; 5985 break; 5986 } 5987 if (q == NULL) 5988 pp = &p->next; 5989 } 5990 *pp = edir->dyn_relocs; 5991 } 5992 5993 edir->dyn_relocs = eind->dyn_relocs; 5994 eind->dyn_relocs = NULL; 5995 } 5996 edir->gotplt_refcount = eind->gotplt_refcount; 5997 eind->gotplt_refcount = 0; 5998 #ifdef INCLUDE_SHMEDIA 5999 edir->datalabel_got.refcount += eind->datalabel_got.refcount; 6000 eind->datalabel_got.refcount = 0; 6001 #endif 6002 edir->funcdesc.refcount += eind->funcdesc.refcount; 6003 eind->funcdesc.refcount = 0; 6004 edir->abs_funcdesc_refcount += eind->abs_funcdesc_refcount; 6005 eind->abs_funcdesc_refcount = 0; 6006 6007 if (ind->root.type == bfd_link_hash_indirect 6008 && dir->got.refcount <= 0) 6009 { 6010 edir->got_type = eind->got_type; 6011 eind->got_type = GOT_UNKNOWN; 6012 } 6013 6014 if (ind->root.type != bfd_link_hash_indirect 6015 && dir->dynamic_adjusted) 6016 { 6017 /* If called to transfer flags for a weakdef during processing 6018 of elf_adjust_dynamic_symbol, don't copy non_got_ref. 6019 We clear it ourselves for ELIMINATE_COPY_RELOCS. */ 6020 dir->ref_dynamic |= ind->ref_dynamic; 6021 dir->ref_regular |= ind->ref_regular; 6022 dir->ref_regular_nonweak |= ind->ref_regular_nonweak; 6023 dir->needs_plt |= ind->needs_plt; 6024 } 6025 else 6026 _bfd_elf_link_hash_copy_indirect (info, dir, ind); 6027 } 6028 6029 static int 6030 sh_elf_optimized_tls_reloc (struct bfd_link_info *info, int r_type, 6031 int is_local) 6032 { 6033 if (info->shared) 6034 return r_type; 6035 6036 switch (r_type) 6037 { 6038 case R_SH_TLS_GD_32: 6039 case R_SH_TLS_IE_32: 6040 if (is_local) 6041 return R_SH_TLS_LE_32; 6042 return R_SH_TLS_IE_32; 6043 case R_SH_TLS_LD_32: 6044 return R_SH_TLS_LE_32; 6045 } 6046 6047 return r_type; 6048 } 6049 6050 /* Look through the relocs for a section during the first phase. 6051 Since we don't do .gots or .plts, we just need to consider the 6052 virtual table relocs for gc. */ 6053 6054 static bfd_boolean 6055 sh_elf_check_relocs (bfd *abfd, struct bfd_link_info *info, asection *sec, 6056 const Elf_Internal_Rela *relocs) 6057 { 6058 Elf_Internal_Shdr *symtab_hdr; 6059 struct elf_link_hash_entry **sym_hashes; 6060 struct elf_sh_link_hash_table *htab; 6061 const Elf_Internal_Rela *rel; 6062 const Elf_Internal_Rela *rel_end; 6063 asection *sreloc; 6064 unsigned int r_type; 6065 enum got_type got_type, old_got_type; 6066 6067 sreloc = NULL; 6068 6069 if (info->relocatable) 6070 return TRUE; 6071 6072 BFD_ASSERT (is_sh_elf (abfd)); 6073 6074 symtab_hdr = &elf_symtab_hdr (abfd); 6075 sym_hashes = elf_sym_hashes (abfd); 6076 6077 htab = sh_elf_hash_table (info); 6078 if (htab == NULL) 6079 return FALSE; 6080 6081 rel_end = relocs + sec->reloc_count; 6082 for (rel = relocs; rel < rel_end; rel++) 6083 { 6084 struct elf_link_hash_entry *h; 6085 unsigned long r_symndx; 6086 #ifdef INCLUDE_SHMEDIA 6087 int seen_stt_datalabel = 0; 6088 #endif 6089 6090 r_symndx = ELF32_R_SYM (rel->r_info); 6091 r_type = ELF32_R_TYPE (rel->r_info); 6092 6093 if (r_symndx < symtab_hdr->sh_info) 6094 h = NULL; 6095 else 6096 { 6097 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 6098 while (h->root.type == bfd_link_hash_indirect 6099 || h->root.type == bfd_link_hash_warning) 6100 { 6101 #ifdef INCLUDE_SHMEDIA 6102 seen_stt_datalabel |= h->type == STT_DATALABEL; 6103 #endif 6104 h = (struct elf_link_hash_entry *) h->root.u.i.link; 6105 } 6106 } 6107 6108 r_type = sh_elf_optimized_tls_reloc (info, r_type, h == NULL); 6109 if (! info->shared 6110 && r_type == R_SH_TLS_IE_32 6111 && h != NULL 6112 && h->root.type != bfd_link_hash_undefined 6113 && h->root.type != bfd_link_hash_undefweak 6114 && (h->dynindx == -1 6115 || h->def_regular)) 6116 r_type = R_SH_TLS_LE_32; 6117 6118 if (htab->fdpic_p) 6119 switch (r_type) 6120 { 6121 case R_SH_GOTOFFFUNCDESC: 6122 case R_SH_GOTOFFFUNCDESC20: 6123 case R_SH_FUNCDESC: 6124 case R_SH_GOTFUNCDESC: 6125 case R_SH_GOTFUNCDESC20: 6126 if (h != NULL) 6127 { 6128 if (h->dynindx == -1) 6129 switch (ELF_ST_VISIBILITY (h->other)) 6130 { 6131 case STV_INTERNAL: 6132 case STV_HIDDEN: 6133 break; 6134 default: 6135 bfd_elf_link_record_dynamic_symbol (info, h); 6136 break; 6137 } 6138 } 6139 break; 6140 } 6141 6142 /* Some relocs require a global offset table. */ 6143 if (htab->sgot == NULL) 6144 { 6145 switch (r_type) 6146 { 6147 case R_SH_DIR32: 6148 /* This may require an rofixup. */ 6149 if (!htab->fdpic_p) 6150 break; 6151 case R_SH_GOTPLT32: 6152 case R_SH_GOT32: 6153 case R_SH_GOT20: 6154 case R_SH_GOTOFF: 6155 case R_SH_GOTOFF20: 6156 case R_SH_FUNCDESC: 6157 case R_SH_GOTFUNCDESC: 6158 case R_SH_GOTFUNCDESC20: 6159 case R_SH_GOTOFFFUNCDESC: 6160 case R_SH_GOTOFFFUNCDESC20: 6161 case R_SH_GOTPC: 6162 #ifdef INCLUDE_SHMEDIA 6163 case R_SH_GOTPLT_LOW16: 6164 case R_SH_GOTPLT_MEDLOW16: 6165 case R_SH_GOTPLT_MEDHI16: 6166 case R_SH_GOTPLT_HI16: 6167 case R_SH_GOTPLT10BY4: 6168 case R_SH_GOTPLT10BY8: 6169 case R_SH_GOT_LOW16: 6170 case R_SH_GOT_MEDLOW16: 6171 case R_SH_GOT_MEDHI16: 6172 case R_SH_GOT_HI16: 6173 case R_SH_GOT10BY4: 6174 case R_SH_GOT10BY8: 6175 case R_SH_GOTOFF_LOW16: 6176 case R_SH_GOTOFF_MEDLOW16: 6177 case R_SH_GOTOFF_MEDHI16: 6178 case R_SH_GOTOFF_HI16: 6179 case R_SH_GOTPC_LOW16: 6180 case R_SH_GOTPC_MEDLOW16: 6181 case R_SH_GOTPC_MEDHI16: 6182 case R_SH_GOTPC_HI16: 6183 #endif 6184 case R_SH_TLS_GD_32: 6185 case R_SH_TLS_LD_32: 6186 case R_SH_TLS_IE_32: 6187 if (htab->root.dynobj == NULL) 6188 htab->root.dynobj = abfd; 6189 if (!create_got_section (htab->root.dynobj, info)) 6190 return FALSE; 6191 break; 6192 6193 default: 6194 break; 6195 } 6196 } 6197 6198 switch (r_type) 6199 { 6200 /* This relocation describes the C++ object vtable hierarchy. 6201 Reconstruct it for later use during GC. */ 6202 case R_SH_GNU_VTINHERIT: 6203 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset)) 6204 return FALSE; 6205 break; 6206 6207 /* This relocation describes which C++ vtable entries are actually 6208 used. Record for later use during GC. */ 6209 case R_SH_GNU_VTENTRY: 6210 BFD_ASSERT (h != NULL); 6211 if (h != NULL 6212 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend)) 6213 return FALSE; 6214 break; 6215 6216 case R_SH_TLS_IE_32: 6217 if (info->shared) 6218 info->flags |= DF_STATIC_TLS; 6219 6220 /* FALLTHROUGH */ 6221 force_got: 6222 case R_SH_TLS_GD_32: 6223 case R_SH_GOT32: 6224 case R_SH_GOT20: 6225 #ifdef INCLUDE_SHMEDIA 6226 case R_SH_GOT_LOW16: 6227 case R_SH_GOT_MEDLOW16: 6228 case R_SH_GOT_MEDHI16: 6229 case R_SH_GOT_HI16: 6230 case R_SH_GOT10BY4: 6231 case R_SH_GOT10BY8: 6232 #endif 6233 case R_SH_GOTFUNCDESC: 6234 case R_SH_GOTFUNCDESC20: 6235 switch (r_type) 6236 { 6237 default: 6238 got_type = GOT_NORMAL; 6239 break; 6240 case R_SH_TLS_GD_32: 6241 got_type = GOT_TLS_GD; 6242 break; 6243 case R_SH_TLS_IE_32: 6244 got_type = GOT_TLS_IE; 6245 break; 6246 case R_SH_GOTFUNCDESC: 6247 case R_SH_GOTFUNCDESC20: 6248 got_type = GOT_FUNCDESC; 6249 break; 6250 } 6251 6252 if (h != NULL) 6253 { 6254 #ifdef INCLUDE_SHMEDIA 6255 if (seen_stt_datalabel) 6256 { 6257 struct elf_sh_link_hash_entry *eh 6258 = (struct elf_sh_link_hash_entry *) h; 6259 6260 eh->datalabel_got.refcount += 1; 6261 } 6262 else 6263 #endif 6264 h->got.refcount += 1; 6265 old_got_type = sh_elf_hash_entry (h)->got_type; 6266 } 6267 else 6268 { 6269 bfd_signed_vma *local_got_refcounts; 6270 6271 /* This is a global offset table entry for a local 6272 symbol. */ 6273 local_got_refcounts = elf_local_got_refcounts (abfd); 6274 if (local_got_refcounts == NULL) 6275 { 6276 bfd_size_type size; 6277 6278 size = symtab_hdr->sh_info; 6279 size *= sizeof (bfd_signed_vma); 6280 #ifdef INCLUDE_SHMEDIA 6281 /* Reserve space for both the datalabel and 6282 codelabel local GOT offsets. */ 6283 size *= 2; 6284 #endif 6285 size += symtab_hdr->sh_info; 6286 local_got_refcounts = ((bfd_signed_vma *) 6287 bfd_zalloc (abfd, size)); 6288 if (local_got_refcounts == NULL) 6289 return FALSE; 6290 elf_local_got_refcounts (abfd) = local_got_refcounts; 6291 #ifdef INCLUDE_SHMEDIA 6292 /* Take care of both the datalabel and codelabel local 6293 GOT offsets. */ 6294 sh_elf_local_got_type (abfd) 6295 = (char *) (local_got_refcounts + 2 * symtab_hdr->sh_info); 6296 #else 6297 sh_elf_local_got_type (abfd) 6298 = (char *) (local_got_refcounts + symtab_hdr->sh_info); 6299 #endif 6300 } 6301 #ifdef INCLUDE_SHMEDIA 6302 if (rel->r_addend & 1) 6303 local_got_refcounts[symtab_hdr->sh_info + r_symndx] += 1; 6304 else 6305 #endif 6306 local_got_refcounts[r_symndx] += 1; 6307 old_got_type = sh_elf_local_got_type (abfd) [r_symndx]; 6308 } 6309 6310 /* If a TLS symbol is accessed using IE at least once, 6311 there is no point to use dynamic model for it. */ 6312 if (old_got_type != got_type && old_got_type != GOT_UNKNOWN 6313 && (old_got_type != GOT_TLS_GD || got_type != GOT_TLS_IE)) 6314 { 6315 if (old_got_type == GOT_TLS_IE && got_type == GOT_TLS_GD) 6316 got_type = GOT_TLS_IE; 6317 else 6318 { 6319 if ((old_got_type == GOT_FUNCDESC || got_type == GOT_FUNCDESC) 6320 && (old_got_type == GOT_NORMAL || got_type == GOT_NORMAL)) 6321 (*_bfd_error_handler) 6322 (_("%B: `%s' accessed both as normal and FDPIC symbol"), 6323 abfd, h->root.root.string); 6324 else if (old_got_type == GOT_FUNCDESC 6325 || got_type == GOT_FUNCDESC) 6326 (*_bfd_error_handler) 6327 (_("%B: `%s' accessed both as FDPIC and thread local symbol"), 6328 abfd, h->root.root.string); 6329 else 6330 (*_bfd_error_handler) 6331 (_("%B: `%s' accessed both as normal and thread local symbol"), 6332 abfd, h->root.root.string); 6333 return FALSE; 6334 } 6335 } 6336 6337 if (old_got_type != got_type) 6338 { 6339 if (h != NULL) 6340 sh_elf_hash_entry (h)->got_type = got_type; 6341 else 6342 sh_elf_local_got_type (abfd) [r_symndx] = got_type; 6343 } 6344 6345 break; 6346 6347 case R_SH_TLS_LD_32: 6348 sh_elf_hash_table(info)->tls_ldm_got.refcount += 1; 6349 break; 6350 6351 case R_SH_FUNCDESC: 6352 case R_SH_GOTOFFFUNCDESC: 6353 case R_SH_GOTOFFFUNCDESC20: 6354 if (rel->r_addend) 6355 { 6356 (*_bfd_error_handler) 6357 (_("%B: Function descriptor relocation with non-zero addend"), 6358 abfd); 6359 return FALSE; 6360 } 6361 6362 if (h == NULL) 6363 { 6364 union gotref *local_funcdesc; 6365 6366 /* We need a function descriptor for a local symbol. */ 6367 local_funcdesc = sh_elf_local_funcdesc (abfd); 6368 if (local_funcdesc == NULL) 6369 { 6370 bfd_size_type size; 6371 6372 size = symtab_hdr->sh_info * sizeof (union gotref); 6373 #ifdef INCLUDE_SHMEDIA 6374 /* Count datalabel local GOT. */ 6375 size *= 2; 6376 #endif 6377 local_funcdesc = (union gotref *) bfd_zalloc (abfd, size); 6378 if (local_funcdesc == NULL) 6379 return FALSE; 6380 sh_elf_local_funcdesc (abfd) = local_funcdesc; 6381 } 6382 local_funcdesc[r_symndx].refcount += 1; 6383 6384 if (r_type == R_SH_FUNCDESC) 6385 { 6386 if (!info->shared) 6387 htab->srofixup->size += 4; 6388 else 6389 htab->srelgot->size += sizeof (Elf32_External_Rela); 6390 } 6391 } 6392 else 6393 { 6394 sh_elf_hash_entry (h)->funcdesc.refcount++; 6395 if (r_type == R_SH_FUNCDESC) 6396 sh_elf_hash_entry (h)->abs_funcdesc_refcount++; 6397 6398 /* If there is a function descriptor reference, then 6399 there should not be any non-FDPIC references. */ 6400 old_got_type = sh_elf_hash_entry (h)->got_type; 6401 if (old_got_type != GOT_FUNCDESC && old_got_type != GOT_UNKNOWN) 6402 { 6403 if (old_got_type == GOT_NORMAL) 6404 (*_bfd_error_handler) 6405 (_("%B: `%s' accessed both as normal and FDPIC symbol"), 6406 abfd, h->root.root.string); 6407 else 6408 (*_bfd_error_handler) 6409 (_("%B: `%s' accessed both as FDPIC and thread local symbol"), 6410 abfd, h->root.root.string); 6411 } 6412 } 6413 break; 6414 6415 case R_SH_GOTPLT32: 6416 #ifdef INCLUDE_SHMEDIA 6417 case R_SH_GOTPLT_LOW16: 6418 case R_SH_GOTPLT_MEDLOW16: 6419 case R_SH_GOTPLT_MEDHI16: 6420 case R_SH_GOTPLT_HI16: 6421 case R_SH_GOTPLT10BY4: 6422 case R_SH_GOTPLT10BY8: 6423 #endif 6424 /* If this is a local symbol, we resolve it directly without 6425 creating a procedure linkage table entry. */ 6426 6427 if (h == NULL 6428 || h->forced_local 6429 || ! info->shared 6430 || info->symbolic 6431 || h->dynindx == -1) 6432 goto force_got; 6433 6434 h->needs_plt = 1; 6435 h->plt.refcount += 1; 6436 ((struct elf_sh_link_hash_entry *) h)->gotplt_refcount += 1; 6437 6438 break; 6439 6440 case R_SH_PLT32: 6441 #ifdef INCLUDE_SHMEDIA 6442 case R_SH_PLT_LOW16: 6443 case R_SH_PLT_MEDLOW16: 6444 case R_SH_PLT_MEDHI16: 6445 case R_SH_PLT_HI16: 6446 #endif 6447 /* This symbol requires a procedure linkage table entry. We 6448 actually build the entry in adjust_dynamic_symbol, 6449 because this might be a case of linking PIC code which is 6450 never referenced by a dynamic object, in which case we 6451 don't need to generate a procedure linkage table entry 6452 after all. */ 6453 6454 /* If this is a local symbol, we resolve it directly without 6455 creating a procedure linkage table entry. */ 6456 if (h == NULL) 6457 continue; 6458 6459 if (h->forced_local) 6460 break; 6461 6462 h->needs_plt = 1; 6463 h->plt.refcount += 1; 6464 break; 6465 6466 case R_SH_DIR32: 6467 case R_SH_REL32: 6468 #ifdef INCLUDE_SHMEDIA 6469 case R_SH_IMM_LOW16_PCREL: 6470 case R_SH_IMM_MEDLOW16_PCREL: 6471 case R_SH_IMM_MEDHI16_PCREL: 6472 case R_SH_IMM_HI16_PCREL: 6473 #endif 6474 if (h != NULL && ! info->shared) 6475 { 6476 h->non_got_ref = 1; 6477 h->plt.refcount += 1; 6478 } 6479 6480 /* If we are creating a shared library, and this is a reloc 6481 against a global symbol, or a non PC relative reloc 6482 against a local symbol, then we need to copy the reloc 6483 into the shared library. However, if we are linking with 6484 -Bsymbolic, we do not need to copy a reloc against a 6485 global symbol which is defined in an object we are 6486 including in the link (i.e., DEF_REGULAR is set). At 6487 this point we have not seen all the input files, so it is 6488 possible that DEF_REGULAR is not set now but will be set 6489 later (it is never cleared). We account for that 6490 possibility below by storing information in the 6491 dyn_relocs field of the hash table entry. A similar 6492 situation occurs when creating shared libraries and symbol 6493 visibility changes render the symbol local. 6494 6495 If on the other hand, we are creating an executable, we 6496 may need to keep relocations for symbols satisfied by a 6497 dynamic library if we manage to avoid copy relocs for the 6498 symbol. */ 6499 if ((info->shared 6500 && (sec->flags & SEC_ALLOC) != 0 6501 && (r_type != R_SH_REL32 6502 || (h != NULL 6503 && (! info->symbolic 6504 || h->root.type == bfd_link_hash_defweak 6505 || !h->def_regular)))) 6506 || (! info->shared 6507 && (sec->flags & SEC_ALLOC) != 0 6508 && h != NULL 6509 && (h->root.type == bfd_link_hash_defweak 6510 || !h->def_regular))) 6511 { 6512 struct elf_sh_dyn_relocs *p; 6513 struct elf_sh_dyn_relocs **head; 6514 6515 if (htab->root.dynobj == NULL) 6516 htab->root.dynobj = abfd; 6517 6518 /* When creating a shared object, we must copy these 6519 reloc types into the output file. We create a reloc 6520 section in dynobj and make room for this reloc. */ 6521 if (sreloc == NULL) 6522 { 6523 sreloc = _bfd_elf_make_dynamic_reloc_section 6524 (sec, htab->root.dynobj, 2, abfd, /*rela?*/ TRUE); 6525 6526 if (sreloc == NULL) 6527 return FALSE; 6528 } 6529 6530 /* If this is a global symbol, we count the number of 6531 relocations we need for this symbol. */ 6532 if (h != NULL) 6533 head = &((struct elf_sh_link_hash_entry *) h)->dyn_relocs; 6534 else 6535 { 6536 /* Track dynamic relocs needed for local syms too. */ 6537 asection *s; 6538 void *vpp; 6539 Elf_Internal_Sym *isym; 6540 6541 isym = bfd_sym_from_r_symndx (&htab->sym_cache, 6542 abfd, r_symndx); 6543 if (isym == NULL) 6544 return FALSE; 6545 6546 s = bfd_section_from_elf_index (abfd, isym->st_shndx); 6547 if (s == NULL) 6548 s = sec; 6549 6550 vpp = &elf_section_data (s)->local_dynrel; 6551 head = (struct elf_sh_dyn_relocs **) vpp; 6552 } 6553 6554 p = *head; 6555 if (p == NULL || p->sec != sec) 6556 { 6557 bfd_size_type amt = sizeof (*p); 6558 p = bfd_alloc (htab->root.dynobj, amt); 6559 if (p == NULL) 6560 return FALSE; 6561 p->next = *head; 6562 *head = p; 6563 p->sec = sec; 6564 p->count = 0; 6565 p->pc_count = 0; 6566 } 6567 6568 p->count += 1; 6569 if (r_type == R_SH_REL32 6570 #ifdef INCLUDE_SHMEDIA 6571 || r_type == R_SH_IMM_LOW16_PCREL 6572 || r_type == R_SH_IMM_MEDLOW16_PCREL 6573 || r_type == R_SH_IMM_MEDHI16_PCREL 6574 || r_type == R_SH_IMM_HI16_PCREL 6575 #endif 6576 ) 6577 p->pc_count += 1; 6578 } 6579 6580 /* Allocate the fixup regardless of whether we need a relocation. 6581 If we end up generating the relocation, we'll unallocate the 6582 fixup. */ 6583 if (htab->fdpic_p && !info->shared 6584 && r_type == R_SH_DIR32 6585 && (sec->flags & SEC_ALLOC) != 0) 6586 htab->srofixup->size += 4; 6587 break; 6588 6589 case R_SH_TLS_LE_32: 6590 if (info->shared && !info->pie) 6591 { 6592 (*_bfd_error_handler) 6593 (_("%B: TLS local exec code cannot be linked into shared objects"), 6594 abfd); 6595 return FALSE; 6596 } 6597 6598 break; 6599 6600 case R_SH_TLS_LDO_32: 6601 /* Nothing to do. */ 6602 break; 6603 6604 default: 6605 break; 6606 } 6607 } 6608 6609 return TRUE; 6610 } 6611 6612 #ifndef sh_elf_set_mach_from_flags 6613 static unsigned int sh_ef_bfd_table[] = { EF_SH_BFD_TABLE }; 6614 6615 static bfd_boolean 6616 sh_elf_set_mach_from_flags (bfd *abfd) 6617 { 6618 flagword flags = elf_elfheader (abfd)->e_flags & EF_SH_MACH_MASK; 6619 6620 if (flags >= sizeof(sh_ef_bfd_table)) 6621 return FALSE; 6622 6623 if (sh_ef_bfd_table[flags] == 0) 6624 return FALSE; 6625 6626 bfd_default_set_arch_mach (abfd, bfd_arch_sh, sh_ef_bfd_table[flags]); 6627 6628 return TRUE; 6629 } 6630 6631 6632 /* Reverse table lookup for sh_ef_bfd_table[]. 6633 Given a bfd MACH value from archures.c 6634 return the equivalent ELF flags from the table. 6635 Return -1 if no match is found. */ 6636 6637 int 6638 sh_elf_get_flags_from_mach (unsigned long mach) 6639 { 6640 int i = ARRAY_SIZE (sh_ef_bfd_table) - 1; 6641 6642 for (; i>0; i--) 6643 if (sh_ef_bfd_table[i] == mach) 6644 return i; 6645 6646 /* shouldn't get here */ 6647 BFD_FAIL(); 6648 6649 return -1; 6650 } 6651 #endif /* not sh_elf_set_mach_from_flags */ 6652 6653 #ifndef sh_elf_set_private_flags 6654 /* Function to keep SH specific file flags. */ 6655 6656 static bfd_boolean 6657 sh_elf_set_private_flags (bfd *abfd, flagword flags) 6658 { 6659 BFD_ASSERT (! elf_flags_init (abfd) 6660 || elf_elfheader (abfd)->e_flags == flags); 6661 6662 elf_elfheader (abfd)->e_flags = flags; 6663 elf_flags_init (abfd) = TRUE; 6664 return sh_elf_set_mach_from_flags (abfd); 6665 } 6666 #endif /* not sh_elf_set_private_flags */ 6667 6668 #ifndef sh_elf_copy_private_data 6669 /* Copy backend specific data from one object module to another */ 6670 6671 static bfd_boolean 6672 sh_elf_copy_private_data (bfd * ibfd, bfd * obfd) 6673 { 6674 /* Copy object attributes. */ 6675 _bfd_elf_copy_obj_attributes (ibfd, obfd); 6676 6677 if (! is_sh_elf (ibfd) || ! is_sh_elf (obfd)) 6678 return TRUE; 6679 6680 /* Copy the stack size. */ 6681 if (elf_tdata (ibfd)->phdr && elf_tdata (obfd)->phdr 6682 && fdpic_object_p (ibfd) && fdpic_object_p (obfd)) 6683 { 6684 unsigned i; 6685 6686 for (i = 0; i < elf_elfheader (ibfd)->e_phnum; i++) 6687 if (elf_tdata (ibfd)->phdr[i].p_type == PT_GNU_STACK) 6688 { 6689 Elf_Internal_Phdr *iphdr = &elf_tdata (ibfd)->phdr[i]; 6690 6691 for (i = 0; i < elf_elfheader (obfd)->e_phnum; i++) 6692 if (elf_tdata (obfd)->phdr[i].p_type == PT_GNU_STACK) 6693 { 6694 memcpy (&elf_tdata (obfd)->phdr[i], iphdr, sizeof (*iphdr)); 6695 6696 /* Rewrite the phdrs, since we're only called after they 6697 were first written. */ 6698 if (bfd_seek (obfd, 6699 (bfd_signed_vma) get_elf_backend_data (obfd) 6700 ->s->sizeof_ehdr, SEEK_SET) != 0 6701 || get_elf_backend_data (obfd)->s 6702 ->write_out_phdrs (obfd, elf_tdata (obfd)->phdr, 6703 elf_elfheader (obfd)->e_phnum) != 0) 6704 return FALSE; 6705 break; 6706 } 6707 6708 break; 6709 } 6710 } 6711 6712 return sh_elf_set_private_flags (obfd, elf_elfheader (ibfd)->e_flags); 6713 } 6714 #endif /* not sh_elf_copy_private_data */ 6715 6716 #ifndef sh_elf_merge_private_data 6717 6718 /* This function returns the ELF architecture number that 6719 corresponds to the given arch_sh* flags. */ 6720 6721 int 6722 sh_find_elf_flags (unsigned int arch_set) 6723 { 6724 extern unsigned long sh_get_bfd_mach_from_arch_set (unsigned int); 6725 unsigned long bfd_mach = sh_get_bfd_mach_from_arch_set (arch_set); 6726 6727 return sh_elf_get_flags_from_mach (bfd_mach); 6728 } 6729 6730 /* This routine initialises the elf flags when required and 6731 calls sh_merge_bfd_arch() to check dsp/fpu compatibility. */ 6732 6733 static bfd_boolean 6734 sh_elf_merge_private_data (bfd *ibfd, bfd *obfd) 6735 { 6736 extern bfd_boolean sh_merge_bfd_arch (bfd *, bfd *); 6737 6738 if (! is_sh_elf (ibfd) || ! is_sh_elf (obfd)) 6739 return TRUE; 6740 6741 if (! elf_flags_init (obfd)) 6742 { 6743 /* This happens when ld starts out with a 'blank' output file. */ 6744 elf_flags_init (obfd) = TRUE; 6745 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags; 6746 sh_elf_set_mach_from_flags (obfd); 6747 if (elf_elfheader (obfd)->e_flags & EF_SH_FDPIC) 6748 elf_elfheader (obfd)->e_flags |= EF_SH_PIC; 6749 } 6750 6751 if (! sh_merge_bfd_arch (ibfd, obfd)) 6752 { 6753 _bfd_error_handler ("%B: uses instructions which are incompatible " 6754 "with instructions used in previous modules", 6755 ibfd); 6756 bfd_set_error (bfd_error_bad_value); 6757 return FALSE; 6758 } 6759 6760 elf_elfheader (obfd)->e_flags &= ~EF_SH_MACH_MASK; 6761 elf_elfheader (obfd)->e_flags |= 6762 sh_elf_get_flags_from_mach (bfd_get_mach (obfd)); 6763 6764 if (fdpic_object_p (ibfd) != fdpic_object_p (obfd)) 6765 { 6766 _bfd_error_handler ("%B: attempt to mix FDPIC and non-FDPIC objects", 6767 ibfd); 6768 bfd_set_error (bfd_error_bad_value); 6769 return FALSE; 6770 } 6771 6772 return TRUE; 6773 } 6774 #endif /* not sh_elf_merge_private_data */ 6775 6776 /* Override the generic function because we need to store sh_elf_obj_tdata 6777 as the specific tdata. We set also the machine architecture from flags 6778 here. */ 6779 6780 static bfd_boolean 6781 sh_elf_object_p (bfd *abfd) 6782 { 6783 if (! sh_elf_set_mach_from_flags (abfd)) 6784 return FALSE; 6785 6786 return (((elf_elfheader (abfd)->e_flags & EF_SH_FDPIC) != 0) 6787 == fdpic_object_p (abfd)); 6788 } 6789 6790 /* Finish up dynamic symbol handling. We set the contents of various 6791 dynamic sections here. */ 6792 6793 static bfd_boolean 6794 sh_elf_finish_dynamic_symbol (bfd *output_bfd, struct bfd_link_info *info, 6795 struct elf_link_hash_entry *h, 6796 Elf_Internal_Sym *sym) 6797 { 6798 struct elf_sh_link_hash_table *htab; 6799 6800 htab = sh_elf_hash_table (info); 6801 if (htab == NULL) 6802 return FALSE; 6803 6804 if (h->plt.offset != (bfd_vma) -1) 6805 { 6806 asection *splt; 6807 asection *sgotplt; 6808 asection *srelplt; 6809 6810 bfd_vma plt_index; 6811 bfd_vma got_offset; 6812 Elf_Internal_Rela rel; 6813 bfd_byte *loc; 6814 const struct elf_sh_plt_info *plt_info; 6815 6816 /* This symbol has an entry in the procedure linkage table. Set 6817 it up. */ 6818 6819 BFD_ASSERT (h->dynindx != -1); 6820 6821 splt = htab->splt; 6822 sgotplt = htab->sgotplt; 6823 srelplt = htab->srelplt; 6824 BFD_ASSERT (splt != NULL && sgotplt != NULL && srelplt != NULL); 6825 6826 /* Get the index in the procedure linkage table which 6827 corresponds to this symbol. This is the index of this symbol 6828 in all the symbols for which we are making plt entries. The 6829 first entry in the procedure linkage table is reserved. */ 6830 plt_index = get_plt_index (htab->plt_info, h->plt.offset); 6831 6832 plt_info = htab->plt_info; 6833 if (plt_info->short_plt != NULL && plt_index <= MAX_SHORT_PLT) 6834 plt_info = plt_info->short_plt; 6835 6836 /* Get the offset into the .got table of the entry that 6837 corresponds to this function. */ 6838 if (htab->fdpic_p) 6839 /* The offset must be relative to the GOT symbol, twelve bytes 6840 before the end of .got.plt. Each descriptor is eight 6841 bytes. */ 6842 got_offset = plt_index * 8 + 12 - sgotplt->size; 6843 else 6844 /* Each .got entry is 4 bytes. The first three are 6845 reserved. */ 6846 got_offset = (plt_index + 3) * 4; 6847 6848 #ifdef GOT_BIAS 6849 if (info->shared) 6850 got_offset -= GOT_BIAS; 6851 #endif 6852 6853 /* Fill in the entry in the procedure linkage table. */ 6854 memcpy (splt->contents + h->plt.offset, 6855 plt_info->symbol_entry, 6856 plt_info->symbol_entry_size); 6857 6858 if (info->shared || htab->fdpic_p) 6859 { 6860 if (plt_info->symbol_fields.got20) 6861 { 6862 bfd_reloc_status_type r; 6863 r = install_movi20_field (output_bfd, got_offset, 6864 splt->owner, splt, splt->contents, 6865 h->plt.offset 6866 + plt_info->symbol_fields.got_entry); 6867 BFD_ASSERT (r == bfd_reloc_ok); 6868 } 6869 else 6870 install_plt_field (output_bfd, FALSE, got_offset, 6871 (splt->contents 6872 + h->plt.offset 6873 + plt_info->symbol_fields.got_entry)); 6874 } 6875 else 6876 { 6877 BFD_ASSERT (!plt_info->symbol_fields.got20); 6878 6879 install_plt_field (output_bfd, FALSE, 6880 (sgotplt->output_section->vma 6881 + sgotplt->output_offset 6882 + got_offset), 6883 (splt->contents 6884 + h->plt.offset 6885 + plt_info->symbol_fields.got_entry)); 6886 if (htab->vxworks_p) 6887 { 6888 unsigned int reachable_plts, plts_per_4k; 6889 int distance; 6890 6891 /* Divide the PLT into groups. The first group contains 6892 REACHABLE_PLTS entries and the other groups contain 6893 PLTS_PER_4K entries. Entries in the first group can 6894 branch directly to .plt; those in later groups branch 6895 to the last element of the previous group. */ 6896 /* ??? It would be better to create multiple copies of 6897 the common resolver stub. */ 6898 reachable_plts = ((4096 6899 - plt_info->plt0_entry_size 6900 - (plt_info->symbol_fields.plt + 4)) 6901 / plt_info->symbol_entry_size) + 1; 6902 plts_per_4k = (4096 / plt_info->symbol_entry_size); 6903 if (plt_index < reachable_plts) 6904 distance = -(h->plt.offset 6905 + plt_info->symbol_fields.plt); 6906 else 6907 distance = -(((plt_index - reachable_plts) % plts_per_4k + 1) 6908 * plt_info->symbol_entry_size); 6909 6910 /* Install the 'bra' with this offset. */ 6911 bfd_put_16 (output_bfd, 6912 0xa000 | (0x0fff & ((distance - 4) / 2)), 6913 (splt->contents 6914 + h->plt.offset 6915 + plt_info->symbol_fields.plt)); 6916 } 6917 else 6918 install_plt_field (output_bfd, TRUE, 6919 splt->output_section->vma + splt->output_offset, 6920 (splt->contents 6921 + h->plt.offset 6922 + plt_info->symbol_fields.plt)); 6923 } 6924 6925 /* Make got_offset relative to the start of .got.plt. */ 6926 #ifdef GOT_BIAS 6927 if (info->shared) 6928 got_offset += GOT_BIAS; 6929 #endif 6930 if (htab->fdpic_p) 6931 got_offset = plt_index * 8; 6932 6933 if (plt_info->symbol_fields.reloc_offset != MINUS_ONE) 6934 install_plt_field (output_bfd, FALSE, 6935 plt_index * sizeof (Elf32_External_Rela), 6936 (splt->contents 6937 + h->plt.offset 6938 + plt_info->symbol_fields.reloc_offset)); 6939 6940 /* Fill in the entry in the global offset table. */ 6941 bfd_put_32 (output_bfd, 6942 (splt->output_section->vma 6943 + splt->output_offset 6944 + h->plt.offset 6945 + plt_info->symbol_resolve_offset), 6946 sgotplt->contents + got_offset); 6947 if (htab->fdpic_p) 6948 bfd_put_32 (output_bfd, 6949 sh_elf_osec_to_segment (output_bfd, 6950 htab->splt->output_section), 6951 sgotplt->contents + got_offset + 4); 6952 6953 /* Fill in the entry in the .rela.plt section. */ 6954 rel.r_offset = (sgotplt->output_section->vma 6955 + sgotplt->output_offset 6956 + got_offset); 6957 if (htab->fdpic_p) 6958 rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_FUNCDESC_VALUE); 6959 else 6960 rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_JMP_SLOT); 6961 rel.r_addend = 0; 6962 #ifdef GOT_BIAS 6963 rel.r_addend = GOT_BIAS; 6964 #endif 6965 loc = srelplt->contents + plt_index * sizeof (Elf32_External_Rela); 6966 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc); 6967 6968 if (htab->vxworks_p && !info->shared) 6969 { 6970 /* Create the .rela.plt.unloaded relocations for this PLT entry. 6971 Begin by pointing LOC to the first such relocation. */ 6972 loc = (htab->srelplt2->contents 6973 + (plt_index * 2 + 1) * sizeof (Elf32_External_Rela)); 6974 6975 /* Create a .rela.plt.unloaded R_SH_DIR32 relocation 6976 for the PLT entry's pointer to the .got.plt entry. */ 6977 rel.r_offset = (htab->splt->output_section->vma 6978 + htab->splt->output_offset 6979 + h->plt.offset 6980 + plt_info->symbol_fields.got_entry); 6981 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_SH_DIR32); 6982 rel.r_addend = got_offset; 6983 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc); 6984 loc += sizeof (Elf32_External_Rela); 6985 6986 /* Create a .rela.plt.unloaded R_SH_DIR32 relocation for 6987 the .got.plt entry, which initially points to .plt. */ 6988 rel.r_offset = (sgotplt->output_section->vma 6989 + sgotplt->output_offset 6990 + got_offset); 6991 rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_SH_DIR32); 6992 rel.r_addend = 0; 6993 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc); 6994 } 6995 6996 if (!h->def_regular) 6997 { 6998 /* Mark the symbol as undefined, rather than as defined in 6999 the .plt section. Leave the value alone. */ 7000 sym->st_shndx = SHN_UNDEF; 7001 } 7002 } 7003 7004 if (h->got.offset != (bfd_vma) -1 7005 && sh_elf_hash_entry (h)->got_type != GOT_TLS_GD 7006 && sh_elf_hash_entry (h)->got_type != GOT_TLS_IE 7007 && sh_elf_hash_entry (h)->got_type != GOT_FUNCDESC) 7008 { 7009 asection *sgot; 7010 asection *srelgot; 7011 Elf_Internal_Rela rel; 7012 bfd_byte *loc; 7013 7014 /* This symbol has an entry in the global offset table. Set it 7015 up. */ 7016 7017 sgot = htab->sgot; 7018 srelgot = htab->srelgot; 7019 BFD_ASSERT (sgot != NULL && srelgot != NULL); 7020 7021 rel.r_offset = (sgot->output_section->vma 7022 + sgot->output_offset 7023 + (h->got.offset &~ (bfd_vma) 1)); 7024 7025 /* If this is a static link, or it is a -Bsymbolic link and the 7026 symbol is defined locally or was forced to be local because 7027 of a version file, we just want to emit a RELATIVE reloc. 7028 The entry in the global offset table will already have been 7029 initialized in the relocate_section function. */ 7030 if (info->shared 7031 && SYMBOL_REFERENCES_LOCAL (info, h)) 7032 { 7033 if (htab->fdpic_p) 7034 { 7035 asection *sec = h->root.u.def.section; 7036 int dynindx 7037 = elf_section_data (sec->output_section)->dynindx; 7038 7039 rel.r_info = ELF32_R_INFO (dynindx, R_SH_DIR32); 7040 rel.r_addend = (h->root.u.def.value 7041 + h->root.u.def.section->output_offset); 7042 } 7043 else 7044 { 7045 rel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE); 7046 rel.r_addend = (h->root.u.def.value 7047 + h->root.u.def.section->output_section->vma 7048 + h->root.u.def.section->output_offset); 7049 } 7050 } 7051 else 7052 { 7053 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset); 7054 rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_GLOB_DAT); 7055 rel.r_addend = 0; 7056 } 7057 7058 loc = srelgot->contents; 7059 loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela); 7060 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc); 7061 } 7062 7063 #ifdef INCLUDE_SHMEDIA 7064 { 7065 struct elf_sh_link_hash_entry *eh; 7066 7067 eh = (struct elf_sh_link_hash_entry *) h; 7068 if (eh->datalabel_got.offset != (bfd_vma) -1) 7069 { 7070 asection *sgot; 7071 asection *srelgot; 7072 Elf_Internal_Rela rel; 7073 bfd_byte *loc; 7074 7075 /* This symbol has a datalabel entry in the global offset table. 7076 Set it up. */ 7077 7078 sgot = htab->sgot; 7079 srelgot = htab->srelgot; 7080 BFD_ASSERT (sgot != NULL && srelgot != NULL); 7081 7082 rel.r_offset = (sgot->output_section->vma 7083 + sgot->output_offset 7084 + (eh->datalabel_got.offset &~ (bfd_vma) 1)); 7085 7086 /* If this is a static link, or it is a -Bsymbolic link and the 7087 symbol is defined locally or was forced to be local because 7088 of a version file, we just want to emit a RELATIVE reloc. 7089 The entry in the global offset table will already have been 7090 initialized in the relocate_section function. */ 7091 if (info->shared 7092 && SYMBOL_REFERENCES_LOCAL (info, h)) 7093 { 7094 if (htab->fdpic_p) 7095 { 7096 asection *sec = h->root.u.def.section; 7097 int dynindx 7098 = elf_section_data (sec->output_section)->dynindx; 7099 7100 rel.r_info = ELF32_R_INFO (dynindx, R_SH_DIR32); 7101 rel.r_addend = (h->root.u.def.value 7102 + h->root.u.def.section->output_offset); 7103 } 7104 else 7105 { 7106 rel.r_info = ELF32_R_INFO (0, R_SH_RELATIVE); 7107 rel.r_addend = (h->root.u.def.value 7108 + h->root.u.def.section->output_section->vma 7109 + h->root.u.def.section->output_offset); 7110 } 7111 } 7112 else 7113 { 7114 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents 7115 + eh->datalabel_got.offset); 7116 rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_GLOB_DAT); 7117 rel.r_addend = 0; 7118 } 7119 7120 loc = srelgot->contents; 7121 loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela); 7122 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc); 7123 } 7124 } 7125 #endif 7126 7127 if (h->needs_copy) 7128 { 7129 asection *s; 7130 Elf_Internal_Rela rel; 7131 bfd_byte *loc; 7132 7133 /* This symbol needs a copy reloc. Set it up. */ 7134 7135 BFD_ASSERT (h->dynindx != -1 7136 && (h->root.type == bfd_link_hash_defined 7137 || h->root.type == bfd_link_hash_defweak)); 7138 7139 s = bfd_get_linker_section (htab->root.dynobj, ".rela.bss"); 7140 BFD_ASSERT (s != NULL); 7141 7142 rel.r_offset = (h->root.u.def.value 7143 + h->root.u.def.section->output_section->vma 7144 + h->root.u.def.section->output_offset); 7145 rel.r_info = ELF32_R_INFO (h->dynindx, R_SH_COPY); 7146 rel.r_addend = 0; 7147 loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela); 7148 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc); 7149 } 7150 7151 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. On VxWorks, 7152 _GLOBAL_OFFSET_TABLE_ is not absolute: it is relative to the 7153 ".got" section. */ 7154 if (strcmp (h->root.root.string, "_DYNAMIC") == 0 7155 || (!htab->vxworks_p && h == htab->root.hgot)) 7156 sym->st_shndx = SHN_ABS; 7157 7158 return TRUE; 7159 } 7160 7161 /* Finish up the dynamic sections. */ 7162 7163 static bfd_boolean 7164 sh_elf_finish_dynamic_sections (bfd *output_bfd, struct bfd_link_info *info) 7165 { 7166 struct elf_sh_link_hash_table *htab; 7167 asection *sgotplt; 7168 asection *sdyn; 7169 7170 htab = sh_elf_hash_table (info); 7171 if (htab == NULL) 7172 return FALSE; 7173 7174 sgotplt = htab->sgotplt; 7175 sdyn = bfd_get_linker_section (htab->root.dynobj, ".dynamic"); 7176 7177 if (htab->root.dynamic_sections_created) 7178 { 7179 asection *splt; 7180 Elf32_External_Dyn *dyncon, *dynconend; 7181 7182 BFD_ASSERT (sgotplt != NULL && sdyn != NULL); 7183 7184 dyncon = (Elf32_External_Dyn *) sdyn->contents; 7185 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size); 7186 for (; dyncon < dynconend; dyncon++) 7187 { 7188 Elf_Internal_Dyn dyn; 7189 asection *s; 7190 #ifdef INCLUDE_SHMEDIA 7191 const char *name; 7192 #endif 7193 7194 bfd_elf32_swap_dyn_in (htab->root.dynobj, dyncon, &dyn); 7195 7196 switch (dyn.d_tag) 7197 { 7198 default: 7199 if (htab->vxworks_p 7200 && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn)) 7201 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 7202 break; 7203 7204 #ifdef INCLUDE_SHMEDIA 7205 case DT_INIT: 7206 name = info->init_function; 7207 goto get_sym; 7208 7209 case DT_FINI: 7210 name = info->fini_function; 7211 get_sym: 7212 if (dyn.d_un.d_val != 0) 7213 { 7214 struct elf_link_hash_entry *h; 7215 7216 h = elf_link_hash_lookup (&htab->root, name, 7217 FALSE, FALSE, TRUE); 7218 if (h != NULL && (h->other & STO_SH5_ISA32)) 7219 { 7220 dyn.d_un.d_val |= 1; 7221 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 7222 } 7223 } 7224 break; 7225 #endif 7226 7227 case DT_PLTGOT: 7228 BFD_ASSERT (htab->root.hgot != NULL); 7229 s = htab->root.hgot->root.u.def.section; 7230 dyn.d_un.d_ptr = htab->root.hgot->root.u.def.value 7231 + s->output_section->vma + s->output_offset; 7232 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 7233 break; 7234 7235 case DT_JMPREL: 7236 s = htab->srelplt->output_section; 7237 BFD_ASSERT (s != NULL); 7238 dyn.d_un.d_ptr = s->vma; 7239 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 7240 break; 7241 7242 case DT_PLTRELSZ: 7243 s = htab->srelplt->output_section; 7244 BFD_ASSERT (s != NULL); 7245 dyn.d_un.d_val = s->size; 7246 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 7247 break; 7248 7249 case DT_RELASZ: 7250 /* My reading of the SVR4 ABI indicates that the 7251 procedure linkage table relocs (DT_JMPREL) should be 7252 included in the overall relocs (DT_RELA). This is 7253 what Solaris does. However, UnixWare can not handle 7254 that case. Therefore, we override the DT_RELASZ entry 7255 here to make it not include the JMPREL relocs. Since 7256 the linker script arranges for .rela.plt to follow all 7257 other relocation sections, we don't have to worry 7258 about changing the DT_RELA entry. */ 7259 if (htab->srelplt != NULL) 7260 { 7261 s = htab->srelplt->output_section; 7262 dyn.d_un.d_val -= s->size; 7263 } 7264 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 7265 break; 7266 } 7267 } 7268 7269 /* Fill in the first entry in the procedure linkage table. */ 7270 splt = htab->splt; 7271 if (splt && splt->size > 0 && htab->plt_info->plt0_entry) 7272 { 7273 unsigned int i; 7274 7275 memcpy (splt->contents, 7276 htab->plt_info->plt0_entry, 7277 htab->plt_info->plt0_entry_size); 7278 for (i = 0; i < ARRAY_SIZE (htab->plt_info->plt0_got_fields); i++) 7279 if (htab->plt_info->plt0_got_fields[i] != MINUS_ONE) 7280 install_plt_field (output_bfd, FALSE, 7281 (sgotplt->output_section->vma 7282 + sgotplt->output_offset 7283 + (i * 4)), 7284 (splt->contents 7285 + htab->plt_info->plt0_got_fields[i])); 7286 7287 if (htab->vxworks_p) 7288 { 7289 /* Finalize the .rela.plt.unloaded contents. */ 7290 Elf_Internal_Rela rel; 7291 bfd_byte *loc; 7292 7293 /* Create a .rela.plt.unloaded R_SH_DIR32 relocation for the 7294 first PLT entry's pointer to _GLOBAL_OFFSET_TABLE_ + 8. */ 7295 loc = htab->srelplt2->contents; 7296 rel.r_offset = (splt->output_section->vma 7297 + splt->output_offset 7298 + htab->plt_info->plt0_got_fields[2]); 7299 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_SH_DIR32); 7300 rel.r_addend = 8; 7301 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc); 7302 loc += sizeof (Elf32_External_Rela); 7303 7304 /* Fix up the remaining .rela.plt.unloaded relocations. 7305 They may have the wrong symbol index for _G_O_T_ or 7306 _P_L_T_ depending on the order in which symbols were 7307 output. */ 7308 while (loc < htab->srelplt2->contents + htab->srelplt2->size) 7309 { 7310 /* The PLT entry's pointer to the .got.plt slot. */ 7311 bfd_elf32_swap_reloc_in (output_bfd, loc, &rel); 7312 rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, 7313 R_SH_DIR32); 7314 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc); 7315 loc += sizeof (Elf32_External_Rela); 7316 7317 /* The .got.plt slot's pointer to .plt. */ 7318 bfd_elf32_swap_reloc_in (output_bfd, loc, &rel); 7319 rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, 7320 R_SH_DIR32); 7321 bfd_elf32_swap_reloc_out (output_bfd, &rel, loc); 7322 loc += sizeof (Elf32_External_Rela); 7323 } 7324 } 7325 7326 /* UnixWare sets the entsize of .plt to 4, although that doesn't 7327 really seem like the right value. */ 7328 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4; 7329 } 7330 } 7331 7332 /* Fill in the first three entries in the global offset table. */ 7333 if (sgotplt && sgotplt->size > 0 && !htab->fdpic_p) 7334 { 7335 if (sdyn == NULL) 7336 bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents); 7337 else 7338 bfd_put_32 (output_bfd, 7339 sdyn->output_section->vma + sdyn->output_offset, 7340 sgotplt->contents); 7341 bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents + 4); 7342 bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents + 8); 7343 } 7344 7345 if (sgotplt && sgotplt->size > 0) 7346 elf_section_data (sgotplt->output_section)->this_hdr.sh_entsize = 4; 7347 7348 /* At the very end of the .rofixup section is a pointer to the GOT. */ 7349 if (htab->fdpic_p && htab->srofixup != NULL) 7350 { 7351 struct elf_link_hash_entry *hgot = htab->root.hgot; 7352 bfd_vma got_value = hgot->root.u.def.value 7353 + hgot->root.u.def.section->output_section->vma 7354 + hgot->root.u.def.section->output_offset; 7355 7356 sh_elf_add_rofixup (output_bfd, htab->srofixup, got_value); 7357 7358 /* Make sure we allocated and generated the same number of fixups. */ 7359 BFD_ASSERT (htab->srofixup->reloc_count * 4 == htab->srofixup->size); 7360 } 7361 7362 if (htab->srelfuncdesc) 7363 BFD_ASSERT (htab->srelfuncdesc->reloc_count * sizeof (Elf32_External_Rela) 7364 == htab->srelfuncdesc->size); 7365 7366 if (htab->srelgot) 7367 BFD_ASSERT (htab->srelgot->reloc_count * sizeof (Elf32_External_Rela) 7368 == htab->srelgot->size); 7369 7370 return TRUE; 7371 } 7372 7373 static enum elf_reloc_type_class 7374 sh_elf_reloc_type_class (const Elf_Internal_Rela *rela) 7375 { 7376 switch ((int) ELF32_R_TYPE (rela->r_info)) 7377 { 7378 case R_SH_RELATIVE: 7379 return reloc_class_relative; 7380 case R_SH_JMP_SLOT: 7381 return reloc_class_plt; 7382 case R_SH_COPY: 7383 return reloc_class_copy; 7384 default: 7385 return reloc_class_normal; 7386 } 7387 } 7388 7389 #if !defined SH_TARGET_ALREADY_DEFINED 7390 /* Support for Linux core dump NOTE sections. */ 7391 7392 static bfd_boolean 7393 elf32_shlin_grok_prstatus (bfd *abfd, Elf_Internal_Note *note) 7394 { 7395 int offset; 7396 unsigned int size; 7397 7398 switch (note->descsz) 7399 { 7400 default: 7401 return FALSE; 7402 7403 case 168: /* Linux/SH */ 7404 /* pr_cursig */ 7405 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12); 7406 7407 /* pr_pid */ 7408 elf_tdata (abfd)->core_lwpid = bfd_get_32 (abfd, note->descdata + 24); 7409 7410 /* pr_reg */ 7411 offset = 72; 7412 size = 92; 7413 7414 break; 7415 } 7416 7417 /* Make a ".reg/999" section. */ 7418 return _bfd_elfcore_make_pseudosection (abfd, ".reg", 7419 size, note->descpos + offset); 7420 } 7421 7422 static bfd_boolean 7423 elf32_shlin_grok_psinfo (bfd *abfd, Elf_Internal_Note *note) 7424 { 7425 switch (note->descsz) 7426 { 7427 default: 7428 return FALSE; 7429 7430 case 124: /* Linux/SH elf_prpsinfo */ 7431 elf_tdata (abfd)->core_program 7432 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16); 7433 elf_tdata (abfd)->core_command 7434 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80); 7435 } 7436 7437 /* Note that for some reason, a spurious space is tacked 7438 onto the end of the args in some (at least one anyway) 7439 implementations, so strip it off if it exists. */ 7440 7441 { 7442 char *command = elf_tdata (abfd)->core_command; 7443 int n = strlen (command); 7444 7445 if (0 < n && command[n - 1] == ' ') 7446 command[n - 1] = '\0'; 7447 } 7448 7449 return TRUE; 7450 } 7451 #endif /* not SH_TARGET_ALREADY_DEFINED */ 7452 7453 7454 /* Return address for Ith PLT stub in section PLT, for relocation REL 7455 or (bfd_vma) -1 if it should not be included. */ 7456 7457 static bfd_vma 7458 sh_elf_plt_sym_val (bfd_vma i, const asection *plt, 7459 const arelent *rel ATTRIBUTE_UNUSED) 7460 { 7461 const struct elf_sh_plt_info *plt_info; 7462 7463 plt_info = get_plt_info (plt->owner, (plt->owner->flags & DYNAMIC) != 0); 7464 return plt->vma + get_plt_offset (plt_info, i); 7465 } 7466 7467 /* Decide whether to attempt to turn absptr or lsda encodings in 7468 shared libraries into pcrel within the given input section. */ 7469 7470 static bfd_boolean 7471 sh_elf_use_relative_eh_frame (bfd *input_bfd ATTRIBUTE_UNUSED, 7472 struct bfd_link_info *info, 7473 asection *eh_frame_section ATTRIBUTE_UNUSED) 7474 { 7475 struct elf_sh_link_hash_table *htab = sh_elf_hash_table (info); 7476 7477 /* We can't use PC-relative encodings in FDPIC binaries, in general. */ 7478 if (htab->fdpic_p) 7479 return FALSE; 7480 7481 return TRUE; 7482 } 7483 7484 /* Adjust the contents of an eh_frame_hdr section before they're output. */ 7485 7486 static bfd_byte 7487 sh_elf_encode_eh_address (bfd *abfd, 7488 struct bfd_link_info *info, 7489 asection *osec, bfd_vma offset, 7490 asection *loc_sec, bfd_vma loc_offset, 7491 bfd_vma *encoded) 7492 { 7493 struct elf_sh_link_hash_table *htab = sh_elf_hash_table (info); 7494 struct elf_link_hash_entry *h; 7495 7496 if (!htab->fdpic_p) 7497 return _bfd_elf_encode_eh_address (abfd, info, osec, offset, loc_sec, 7498 loc_offset, encoded); 7499 7500 h = htab->root.hgot; 7501 BFD_ASSERT (h && h->root.type == bfd_link_hash_defined); 7502 7503 if (! h || (sh_elf_osec_to_segment (abfd, osec) 7504 == sh_elf_osec_to_segment (abfd, loc_sec->output_section))) 7505 return _bfd_elf_encode_eh_address (abfd, info, osec, offset, 7506 loc_sec, loc_offset, encoded); 7507 7508 BFD_ASSERT (sh_elf_osec_to_segment (abfd, osec) 7509 == (sh_elf_osec_to_segment 7510 (abfd, h->root.u.def.section->output_section))); 7511 7512 *encoded = osec->vma + offset 7513 - (h->root.u.def.value 7514 + h->root.u.def.section->output_section->vma 7515 + h->root.u.def.section->output_offset); 7516 7517 return DW_EH_PE_datarel | DW_EH_PE_sdata4; 7518 } 7519 7520 #if !defined SH_TARGET_ALREADY_DEFINED 7521 #define TARGET_BIG_SYM bfd_elf32_sh_vec 7522 #define TARGET_BIG_NAME "elf32-sh" 7523 #define TARGET_LITTLE_SYM bfd_elf32_shl_vec 7524 #define TARGET_LITTLE_NAME "elf32-shl" 7525 #endif 7526 7527 #define ELF_ARCH bfd_arch_sh 7528 #define ELF_TARGET_ID SH_ELF_DATA 7529 #define ELF_MACHINE_CODE EM_SH 7530 #ifdef __QNXTARGET__ 7531 #define ELF_MAXPAGESIZE 0x1000 7532 #else 7533 #define ELF_MAXPAGESIZE 0x80 7534 #endif 7535 7536 #define elf_symbol_leading_char '_' 7537 7538 #define bfd_elf32_bfd_reloc_type_lookup sh_elf_reloc_type_lookup 7539 #define bfd_elf32_bfd_reloc_name_lookup \ 7540 sh_elf_reloc_name_lookup 7541 #define elf_info_to_howto sh_elf_info_to_howto 7542 #define bfd_elf32_bfd_relax_section sh_elf_relax_section 7543 #define elf_backend_relocate_section sh_elf_relocate_section 7544 #define bfd_elf32_bfd_get_relocated_section_contents \ 7545 sh_elf_get_relocated_section_contents 7546 #define bfd_elf32_mkobject sh_elf_mkobject 7547 #define elf_backend_object_p sh_elf_object_p 7548 #define bfd_elf32_bfd_set_private_bfd_flags \ 7549 sh_elf_set_private_flags 7550 #define bfd_elf32_bfd_copy_private_bfd_data \ 7551 sh_elf_copy_private_data 7552 #define bfd_elf32_bfd_merge_private_bfd_data \ 7553 sh_elf_merge_private_data 7554 7555 #define elf_backend_gc_mark_hook sh_elf_gc_mark_hook 7556 #define elf_backend_gc_sweep_hook sh_elf_gc_sweep_hook 7557 #define elf_backend_check_relocs sh_elf_check_relocs 7558 #define elf_backend_copy_indirect_symbol \ 7559 sh_elf_copy_indirect_symbol 7560 #define elf_backend_create_dynamic_sections \ 7561 sh_elf_create_dynamic_sections 7562 #define bfd_elf32_bfd_link_hash_table_create \ 7563 sh_elf_link_hash_table_create 7564 #define elf_backend_adjust_dynamic_symbol \ 7565 sh_elf_adjust_dynamic_symbol 7566 #define elf_backend_always_size_sections \ 7567 sh_elf_always_size_sections 7568 #define elf_backend_size_dynamic_sections \ 7569 sh_elf_size_dynamic_sections 7570 #define elf_backend_omit_section_dynsym sh_elf_omit_section_dynsym 7571 #define elf_backend_finish_dynamic_symbol \ 7572 sh_elf_finish_dynamic_symbol 7573 #define elf_backend_finish_dynamic_sections \ 7574 sh_elf_finish_dynamic_sections 7575 #define elf_backend_reloc_type_class sh_elf_reloc_type_class 7576 #define elf_backend_plt_sym_val sh_elf_plt_sym_val 7577 #define elf_backend_can_make_relative_eh_frame \ 7578 sh_elf_use_relative_eh_frame 7579 #define elf_backend_can_make_lsda_relative_eh_frame \ 7580 sh_elf_use_relative_eh_frame 7581 #define elf_backend_encode_eh_address \ 7582 sh_elf_encode_eh_address 7583 7584 #define elf_backend_can_gc_sections 1 7585 #define elf_backend_can_refcount 1 7586 #define elf_backend_want_got_plt 1 7587 #define elf_backend_plt_readonly 1 7588 #define elf_backend_want_plt_sym 0 7589 #define elf_backend_got_header_size 12 7590 7591 #if !defined INCLUDE_SHMEDIA && !defined SH_TARGET_ALREADY_DEFINED 7592 7593 #include "elf32-target.h" 7594 7595 /* NetBSD support. */ 7596 #undef TARGET_BIG_SYM 7597 #define TARGET_BIG_SYM bfd_elf32_shnbsd_vec 7598 #undef TARGET_BIG_NAME 7599 #define TARGET_BIG_NAME "elf32-sh-nbsd" 7600 #undef TARGET_LITTLE_SYM 7601 #define TARGET_LITTLE_SYM bfd_elf32_shlnbsd_vec 7602 #undef TARGET_LITTLE_NAME 7603 #define TARGET_LITTLE_NAME "elf32-shl-nbsd" 7604 #undef ELF_MAXPAGESIZE 7605 #define ELF_MAXPAGESIZE 0x10000 7606 #undef ELF_COMMONPAGESIZE 7607 #undef elf_symbol_leading_char 7608 #define elf_symbol_leading_char 0 7609 #undef elf32_bed 7610 #define elf32_bed elf32_sh_nbsd_bed 7611 7612 #include "elf32-target.h" 7613 7614 7615 /* Linux support. */ 7616 #undef TARGET_BIG_SYM 7617 #define TARGET_BIG_SYM bfd_elf32_shblin_vec 7618 #undef TARGET_BIG_NAME 7619 #define TARGET_BIG_NAME "elf32-shbig-linux" 7620 #undef TARGET_LITTLE_SYM 7621 #define TARGET_LITTLE_SYM bfd_elf32_shlin_vec 7622 #undef TARGET_LITTLE_NAME 7623 #define TARGET_LITTLE_NAME "elf32-sh-linux" 7624 #undef ELF_COMMONPAGESIZE 7625 #define ELF_COMMONPAGESIZE 0x1000 7626 7627 #undef elf_backend_grok_prstatus 7628 #define elf_backend_grok_prstatus elf32_shlin_grok_prstatus 7629 #undef elf_backend_grok_psinfo 7630 #define elf_backend_grok_psinfo elf32_shlin_grok_psinfo 7631 #undef elf32_bed 7632 #define elf32_bed elf32_sh_lin_bed 7633 7634 #include "elf32-target.h" 7635 7636 7637 /* FDPIC support. */ 7638 #undef TARGET_BIG_SYM 7639 #define TARGET_BIG_SYM bfd_elf32_shbfd_vec 7640 #undef TARGET_BIG_NAME 7641 #define TARGET_BIG_NAME "elf32-shbig-fdpic" 7642 #undef TARGET_LITTLE_SYM 7643 #define TARGET_LITTLE_SYM bfd_elf32_shfd_vec 7644 #undef TARGET_LITTLE_NAME 7645 #define TARGET_LITTLE_NAME "elf32-sh-fdpic" 7646 #undef elf_backend_modify_program_headers 7647 #define elf_backend_modify_program_headers \ 7648 sh_elf_modify_program_headers 7649 7650 #undef elf32_bed 7651 #define elf32_bed elf32_sh_fd_bed 7652 7653 #include "elf32-target.h" 7654 7655 #undef elf_backend_modify_program_headers 7656 7657 /* VxWorks support. */ 7658 #undef TARGET_BIG_SYM 7659 #define TARGET_BIG_SYM bfd_elf32_shvxworks_vec 7660 #undef TARGET_BIG_NAME 7661 #define TARGET_BIG_NAME "elf32-sh-vxworks" 7662 #undef TARGET_LITTLE_SYM 7663 #define TARGET_LITTLE_SYM bfd_elf32_shlvxworks_vec 7664 #undef TARGET_LITTLE_NAME 7665 #define TARGET_LITTLE_NAME "elf32-shl-vxworks" 7666 #undef elf32_bed 7667 #define elf32_bed elf32_sh_vxworks_bed 7668 7669 #undef elf_backend_want_plt_sym 7670 #define elf_backend_want_plt_sym 1 7671 #undef elf_symbol_leading_char 7672 #define elf_symbol_leading_char '_' 7673 #define elf_backend_want_got_underscore 1 7674 #undef elf_backend_grok_prstatus 7675 #undef elf_backend_grok_psinfo 7676 #undef elf_backend_add_symbol_hook 7677 #define elf_backend_add_symbol_hook elf_vxworks_add_symbol_hook 7678 #undef elf_backend_link_output_symbol_hook 7679 #define elf_backend_link_output_symbol_hook \ 7680 elf_vxworks_link_output_symbol_hook 7681 #undef elf_backend_emit_relocs 7682 #define elf_backend_emit_relocs elf_vxworks_emit_relocs 7683 #undef elf_backend_final_write_processing 7684 #define elf_backend_final_write_processing \ 7685 elf_vxworks_final_write_processing 7686 #undef ELF_MAXPAGESIZE 7687 #define ELF_MAXPAGESIZE 0x1000 7688 #undef ELF_COMMONPAGESIZE 7689 7690 #include "elf32-target.h" 7691 7692 #endif /* neither INCLUDE_SHMEDIA nor SH_TARGET_ALREADY_DEFINED */ 7693