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