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