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