1 /* FRV-specific support for 32-bit ELF. 2 Copyright 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 3 Free Software Foundation, Inc. 4 5 This file is part of BFD, the Binary File Descriptor library. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program; if not, write to the Free Software 19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 20 MA 02110-1301, USA. */ 21 22 #include "sysdep.h" 23 #include "bfd.h" 24 #include "libbfd.h" 25 #include "elf-bfd.h" 26 #include "elf/frv.h" 27 #include "dwarf2.h" 28 #include "hashtab.h" 29 30 /* Forward declarations. */ 31 static bfd_reloc_status_type elf32_frv_relocate_lo16 32 PARAMS ((bfd *, Elf_Internal_Rela *, bfd_byte *, bfd_vma)); 33 static bfd_reloc_status_type elf32_frv_relocate_hi16 34 PARAMS ((bfd *, Elf_Internal_Rela *, bfd_byte *, bfd_vma)); 35 static bfd_reloc_status_type elf32_frv_relocate_label24 36 PARAMS ((bfd *, asection *, Elf_Internal_Rela *, bfd_byte *, bfd_vma)); 37 static bfd_reloc_status_type elf32_frv_relocate_gprel12 38 PARAMS ((struct bfd_link_info *, bfd *, asection *, Elf_Internal_Rela *, 39 bfd_byte *, bfd_vma)); 40 static bfd_reloc_status_type elf32_frv_relocate_gprelu12 41 PARAMS ((struct bfd_link_info *, bfd *, asection *, Elf_Internal_Rela *, 42 bfd_byte *, bfd_vma)); 43 static bfd_reloc_status_type elf32_frv_relocate_gprello 44 PARAMS ((struct bfd_link_info *, bfd *, asection *, Elf_Internal_Rela *, 45 bfd_byte *, bfd_vma)); 46 static bfd_reloc_status_type elf32_frv_relocate_gprelhi 47 PARAMS ((struct bfd_link_info *, bfd *, asection *, Elf_Internal_Rela *, 48 bfd_byte *, bfd_vma)); 49 static reloc_howto_type *frv_reloc_type_lookup 50 PARAMS ((bfd *, bfd_reloc_code_real_type)); 51 static void frv_info_to_howto_rela 52 PARAMS ((bfd *, arelent *, Elf_Internal_Rela *)); 53 static bfd_boolean elf32_frv_relocate_section 54 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *, 55 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **)); 56 static bfd_boolean elf32_frv_add_symbol_hook 57 PARAMS (( bfd *, struct bfd_link_info *, Elf_Internal_Sym *, 58 const char **, flagword *, asection **, bfd_vma *)); 59 static bfd_reloc_status_type frv_final_link_relocate 60 PARAMS ((reloc_howto_type *, bfd *, asection *, bfd_byte *, 61 Elf_Internal_Rela *, bfd_vma)); 62 static bfd_boolean elf32_frv_check_relocs 63 PARAMS ((bfd *, struct bfd_link_info *, asection *, 64 const Elf_Internal_Rela *)); 65 static int elf32_frv_machine 66 PARAMS ((bfd *)); 67 static bfd_boolean elf32_frv_object_p 68 PARAMS ((bfd *)); 69 static bfd_boolean frv_elf_set_private_flags 70 PARAMS ((bfd *, flagword)); 71 static bfd_boolean frv_elf_copy_private_bfd_data 72 PARAMS ((bfd *, bfd *)); 73 static bfd_boolean frv_elf_merge_private_bfd_data 74 PARAMS ((bfd *, bfd *)); 75 static bfd_boolean frv_elf_print_private_bfd_data 76 PARAMS ((bfd *, PTR)); 77 static bfd_boolean elf32_frv_grok_prstatus (bfd * abfd, 78 Elf_Internal_Note * note); 79 static bfd_boolean elf32_frv_grok_psinfo (bfd * abfd, 80 Elf_Internal_Note * note); 81 82 static reloc_howto_type elf32_frv_howto_table [] = 83 { 84 /* This reloc does nothing. */ 85 HOWTO (R_FRV_NONE, /* type */ 86 0, /* rightshift */ 87 2, /* size (0 = byte, 1 = short, 2 = long) */ 88 32, /* bitsize */ 89 FALSE, /* pc_relative */ 90 0, /* bitpos */ 91 complain_overflow_bitfield, /* complain_on_overflow */ 92 bfd_elf_generic_reloc, /* special_function */ 93 "R_FRV_NONE", /* name */ 94 FALSE, /* partial_inplace */ 95 0, /* src_mask */ 96 0, /* dst_mask */ 97 FALSE), /* pcrel_offset */ 98 99 /* A 32 bit absolute relocation. */ 100 HOWTO (R_FRV_32, /* type */ 101 0, /* rightshift */ 102 2, /* size (0 = byte, 1 = short, 2 = long) */ 103 32, /* bitsize */ 104 FALSE, /* pc_relative */ 105 0, /* bitpos */ 106 complain_overflow_bitfield, /* complain_on_overflow */ 107 bfd_elf_generic_reloc, /* special_function */ 108 "R_FRV_32", /* name */ 109 FALSE, /* partial_inplace */ 110 0xffffffff, /* src_mask */ 111 0xffffffff, /* dst_mask */ 112 FALSE), /* pcrel_offset */ 113 114 /* A 16 bit pc-relative relocation. */ 115 HOWTO (R_FRV_LABEL16, /* type */ 116 2, /* rightshift */ 117 2, /* size (0 = byte, 1 = short, 2 = long) */ 118 16, /* bitsize */ 119 TRUE, /* pc_relative */ 120 0, /* bitpos */ 121 complain_overflow_signed, /* complain_on_overflow */ 122 bfd_elf_generic_reloc, /* special_function */ 123 "R_FRV_LABEL16", /* name */ 124 FALSE, /* partial_inplace */ 125 0xffff, /* src_mask */ 126 0xffff, /* dst_mask */ 127 TRUE), /* pcrel_offset */ 128 129 /* A 24-bit pc-relative relocation. */ 130 HOWTO (R_FRV_LABEL24, /* type */ 131 2, /* rightshift */ 132 2, /* size (0 = byte, 1 = short, 2 = long) */ 133 26, /* bitsize */ 134 TRUE, /* pc_relative */ 135 0, /* bitpos */ 136 complain_overflow_bitfield, /* complain_on_overflow */ 137 bfd_elf_generic_reloc, /* special_function */ 138 "R_FRV_LABEL24", /* name */ 139 FALSE, /* partial_inplace */ 140 0x7e03ffff, /* src_mask */ 141 0x7e03ffff, /* dst_mask */ 142 TRUE), /* pcrel_offset */ 143 144 HOWTO (R_FRV_LO16, /* type */ 145 0, /* rightshift */ 146 2, /* size (0 = byte, 1 = short, 2 = long) */ 147 16, /* bitsize */ 148 FALSE, /* pc_relative */ 149 0, /* bitpos */ 150 complain_overflow_dont, /* complain_on_overflow */ 151 bfd_elf_generic_reloc, /* special_function */ 152 "R_FRV_LO16", /* name */ 153 FALSE, /* partial_inplace */ 154 0xffff, /* src_mask */ 155 0xffff, /* dst_mask */ 156 FALSE), /* pcrel_offset */ 157 158 HOWTO (R_FRV_HI16, /* type */ 159 0, /* rightshift */ 160 2, /* size (0 = byte, 1 = short, 2 = long) */ 161 16, /* bitsize */ 162 FALSE, /* pc_relative */ 163 0, /* bitpos */ 164 complain_overflow_dont, /* complain_on_overflow */ 165 bfd_elf_generic_reloc, /* special_function */ 166 "R_FRV_HI16", /* name */ 167 FALSE, /* partial_inplace */ 168 0xffff, /* src_mask */ 169 0xffff, /* dst_mask */ 170 FALSE), /* pcrel_offset */ 171 172 HOWTO (R_FRV_GPREL12, /* type */ 173 0, /* rightshift */ 174 2, /* size (0 = byte, 1 = short, 2 = long) */ 175 12, /* bitsize */ 176 FALSE, /* pc_relative */ 177 0, /* bitpos */ 178 complain_overflow_dont, /* complain_on_overflow */ 179 bfd_elf_generic_reloc, /* special_function */ 180 "R_FRV_GPREL12", /* name */ 181 FALSE, /* partial_inplace */ 182 0xfff, /* src_mask */ 183 0xfff, /* dst_mask */ 184 FALSE), /* pcrel_offset */ 185 186 HOWTO (R_FRV_GPRELU12, /* type */ 187 0, /* rightshift */ 188 2, /* size (0 = byte, 1 = short, 2 = long) */ 189 12, /* bitsize */ 190 FALSE, /* pc_relative */ 191 0, /* bitpos */ 192 complain_overflow_dont, /* complain_on_overflow */ 193 bfd_elf_generic_reloc, /* special_function */ 194 "R_FRV_GPRELU12", /* name */ 195 FALSE, /* partial_inplace */ 196 0xfff, /* src_mask */ 197 0x3f03f, /* dst_mask */ 198 FALSE), /* pcrel_offset */ 199 200 HOWTO (R_FRV_GPREL32, /* type */ 201 0, /* rightshift */ 202 2, /* size (0 = byte, 1 = short, 2 = long) */ 203 32, /* bitsize */ 204 FALSE, /* pc_relative */ 205 0, /* bitpos */ 206 complain_overflow_dont, /* complain_on_overflow */ 207 bfd_elf_generic_reloc, /* special_function */ 208 "R_FRV_GPREL32", /* name */ 209 FALSE, /* partial_inplace */ 210 0xffffffff, /* src_mask */ 211 0xffffffff, /* dst_mask */ 212 FALSE), /* pcrel_offset */ 213 214 HOWTO (R_FRV_GPRELHI, /* type */ 215 0, /* rightshift */ 216 2, /* size (0 = byte, 1 = short, 2 = long) */ 217 16, /* bitsize */ 218 FALSE, /* pc_relative */ 219 0, /* bitpos */ 220 complain_overflow_dont, /* complain_on_overflow */ 221 bfd_elf_generic_reloc, /* special_function */ 222 "R_FRV_GPRELHI", /* name */ 223 FALSE, /* partial_inplace */ 224 0xffff, /* src_mask */ 225 0xffff, /* dst_mask */ 226 FALSE), /* pcrel_offset */ 227 228 HOWTO (R_FRV_GPRELLO, /* type */ 229 0, /* rightshift */ 230 2, /* size (0 = byte, 1 = short, 2 = long) */ 231 16, /* bitsize */ 232 FALSE, /* pc_relative */ 233 0, /* bitpos */ 234 complain_overflow_dont, /* complain_on_overflow */ 235 bfd_elf_generic_reloc, /* special_function */ 236 "R_FRV_GPRELLO", /* name */ 237 FALSE, /* partial_inplace */ 238 0xffff, /* src_mask */ 239 0xffff, /* dst_mask */ 240 FALSE), /* pcrel_offset */ 241 242 /* A 12-bit signed operand with the GOT offset for the address of 243 the symbol. */ 244 HOWTO (R_FRV_GOT12, /* type */ 245 0, /* rightshift */ 246 2, /* size (0 = byte, 1 = short, 2 = long) */ 247 12, /* bitsize */ 248 FALSE, /* pc_relative */ 249 0, /* bitpos */ 250 complain_overflow_signed, /* complain_on_overflow */ 251 bfd_elf_generic_reloc, /* special_function */ 252 "R_FRV_GOT12", /* name */ 253 FALSE, /* partial_inplace */ 254 0xfff, /* src_mask */ 255 0xfff, /* dst_mask */ 256 FALSE), /* pcrel_offset */ 257 258 /* The upper 16 bits of the GOT offset for the address of the 259 symbol. */ 260 HOWTO (R_FRV_GOTHI, /* type */ 261 0, /* rightshift */ 262 2, /* size (0 = byte, 1 = short, 2 = long) */ 263 16, /* bitsize */ 264 FALSE, /* pc_relative */ 265 0, /* bitpos */ 266 complain_overflow_dont, /* complain_on_overflow */ 267 bfd_elf_generic_reloc, /* special_function */ 268 "R_FRV_GOTHI", /* name */ 269 FALSE, /* partial_inplace */ 270 0xffff, /* src_mask */ 271 0xffff, /* dst_mask */ 272 FALSE), /* pcrel_offset */ 273 274 /* The lower 16 bits of the GOT offset for the address of the 275 symbol. */ 276 HOWTO (R_FRV_GOTLO, /* type */ 277 0, /* rightshift */ 278 2, /* size (0 = byte, 1 = short, 2 = long) */ 279 16, /* bitsize */ 280 FALSE, /* pc_relative */ 281 0, /* bitpos */ 282 complain_overflow_dont, /* complain_on_overflow */ 283 bfd_elf_generic_reloc, /* special_function */ 284 "R_FRV_GOTLO", /* name */ 285 FALSE, /* partial_inplace */ 286 0xffff, /* src_mask */ 287 0xffff, /* dst_mask */ 288 FALSE), /* pcrel_offset */ 289 290 /* The 32-bit address of the canonical descriptor of a function. */ 291 HOWTO (R_FRV_FUNCDESC, /* type */ 292 0, /* rightshift */ 293 2, /* size (0 = byte, 1 = short, 2 = long) */ 294 32, /* bitsize */ 295 FALSE, /* pc_relative */ 296 0, /* bitpos */ 297 complain_overflow_bitfield, /* complain_on_overflow */ 298 bfd_elf_generic_reloc, /* special_function */ 299 "R_FRV_FUNCDESC", /* name */ 300 FALSE, /* partial_inplace */ 301 0xffffffff, /* src_mask */ 302 0xffffffff, /* dst_mask */ 303 FALSE), /* pcrel_offset */ 304 305 /* A 12-bit signed operand with the GOT offset for the address of 306 canonical descriptor of a function. */ 307 HOWTO (R_FRV_FUNCDESC_GOT12, /* type */ 308 0, /* rightshift */ 309 2, /* size (0 = byte, 1 = short, 2 = long) */ 310 12, /* bitsize */ 311 FALSE, /* pc_relative */ 312 0, /* bitpos */ 313 complain_overflow_signed, /* complain_on_overflow */ 314 bfd_elf_generic_reloc, /* special_function */ 315 "R_FRV_FUNCDESC_GOT12", /* name */ 316 FALSE, /* partial_inplace */ 317 0xfff, /* src_mask */ 318 0xfff, /* dst_mask */ 319 FALSE), /* pcrel_offset */ 320 321 /* The upper 16 bits of the GOT offset for the address of the 322 canonical descriptor of a function. */ 323 HOWTO (R_FRV_FUNCDESC_GOTHI, /* type */ 324 0, /* rightshift */ 325 2, /* size (0 = byte, 1 = short, 2 = long) */ 326 16, /* bitsize */ 327 FALSE, /* pc_relative */ 328 0, /* bitpos */ 329 complain_overflow_dont, /* complain_on_overflow */ 330 bfd_elf_generic_reloc, /* special_function */ 331 "R_FRV_FUNCDESC_GOTHI", /* name */ 332 FALSE, /* partial_inplace */ 333 0xffff, /* src_mask */ 334 0xffff, /* dst_mask */ 335 FALSE), /* pcrel_offset */ 336 337 /* The lower 16 bits of the GOT offset for the address of the 338 canonical descriptor of a function. */ 339 HOWTO (R_FRV_FUNCDESC_GOTLO, /* type */ 340 0, /* rightshift */ 341 2, /* size (0 = byte, 1 = short, 2 = long) */ 342 16, /* bitsize */ 343 FALSE, /* pc_relative */ 344 0, /* bitpos */ 345 complain_overflow_dont, /* complain_on_overflow */ 346 bfd_elf_generic_reloc, /* special_function */ 347 "R_FRV_FUNCDESC_GOTLO", /* name */ 348 FALSE, /* partial_inplace */ 349 0xffff, /* src_mask */ 350 0xffff, /* dst_mask */ 351 FALSE), /* pcrel_offset */ 352 353 /* The 64-bit descriptor of a function. */ 354 HOWTO (R_FRV_FUNCDESC_VALUE, /* type */ 355 0, /* rightshift */ 356 2, /* size (0 = byte, 1 = short, 2 = long) */ 357 64, /* bitsize */ 358 FALSE, /* pc_relative */ 359 0, /* bitpos */ 360 complain_overflow_bitfield, /* complain_on_overflow */ 361 bfd_elf_generic_reloc, /* special_function */ 362 "R_FRV_FUNCDESC_VALUE", /* name */ 363 FALSE, /* partial_inplace */ 364 0xffffffff, /* src_mask */ 365 0xffffffff, /* dst_mask */ 366 FALSE), /* pcrel_offset */ 367 368 /* A 12-bit signed operand with the GOT offset for the address of 369 canonical descriptor of a function. */ 370 HOWTO (R_FRV_FUNCDESC_GOTOFF12, /* type */ 371 0, /* rightshift */ 372 2, /* size (0 = byte, 1 = short, 2 = long) */ 373 12, /* bitsize */ 374 FALSE, /* pc_relative */ 375 0, /* bitpos */ 376 complain_overflow_signed, /* complain_on_overflow */ 377 bfd_elf_generic_reloc, /* special_function */ 378 "R_FRV_FUNCDESC_GOTOFF12", /* name */ 379 FALSE, /* partial_inplace */ 380 0xfff, /* src_mask */ 381 0xfff, /* dst_mask */ 382 FALSE), /* pcrel_offset */ 383 384 /* The upper 16 bits of the GOT offset for the address of the 385 canonical descriptor of a function. */ 386 HOWTO (R_FRV_FUNCDESC_GOTOFFHI, /* type */ 387 0, /* rightshift */ 388 2, /* size (0 = byte, 1 = short, 2 = long) */ 389 16, /* bitsize */ 390 FALSE, /* pc_relative */ 391 0, /* bitpos */ 392 complain_overflow_dont, /* complain_on_overflow */ 393 bfd_elf_generic_reloc, /* special_function */ 394 "R_FRV_FUNCDESC_GOTOFFHI", /* name */ 395 FALSE, /* partial_inplace */ 396 0xffff, /* src_mask */ 397 0xffff, /* dst_mask */ 398 FALSE), /* pcrel_offset */ 399 400 /* The lower 16 bits of the GOT offset for the address of the 401 canonical descriptor of a function. */ 402 HOWTO (R_FRV_FUNCDESC_GOTOFFLO, /* type */ 403 0, /* rightshift */ 404 2, /* size (0 = byte, 1 = short, 2 = long) */ 405 16, /* bitsize */ 406 FALSE, /* pc_relative */ 407 0, /* bitpos */ 408 complain_overflow_dont, /* complain_on_overflow */ 409 bfd_elf_generic_reloc, /* special_function */ 410 "R_FRV_FUNCDESC_GOTOFFLO", /* name */ 411 FALSE, /* partial_inplace */ 412 0xffff, /* src_mask */ 413 0xffff, /* dst_mask */ 414 FALSE), /* pcrel_offset */ 415 416 /* A 12-bit signed operand with the GOT offset for the address of 417 the symbol. */ 418 HOWTO (R_FRV_GOTOFF12, /* type */ 419 0, /* rightshift */ 420 2, /* size (0 = byte, 1 = short, 2 = long) */ 421 12, /* bitsize */ 422 FALSE, /* pc_relative */ 423 0, /* bitpos */ 424 complain_overflow_signed, /* complain_on_overflow */ 425 bfd_elf_generic_reloc, /* special_function */ 426 "R_FRV_GOTOFF12", /* name */ 427 FALSE, /* partial_inplace */ 428 0xfff, /* src_mask */ 429 0xfff, /* dst_mask */ 430 FALSE), /* pcrel_offset */ 431 432 /* The upper 16 bits of the GOT offset for the address of the 433 symbol. */ 434 HOWTO (R_FRV_GOTOFFHI, /* type */ 435 0, /* rightshift */ 436 2, /* size (0 = byte, 1 = short, 2 = long) */ 437 16, /* bitsize */ 438 FALSE, /* pc_relative */ 439 0, /* bitpos */ 440 complain_overflow_dont, /* complain_on_overflow */ 441 bfd_elf_generic_reloc, /* special_function */ 442 "R_FRV_GOTOFFHI", /* name */ 443 FALSE, /* partial_inplace */ 444 0xffff, /* src_mask */ 445 0xffff, /* dst_mask */ 446 FALSE), /* pcrel_offset */ 447 448 /* The lower 16 bits of the GOT offset for the address of the 449 symbol. */ 450 HOWTO (R_FRV_GOTOFFLO, /* type */ 451 0, /* rightshift */ 452 2, /* size (0 = byte, 1 = short, 2 = long) */ 453 16, /* bitsize */ 454 FALSE, /* pc_relative */ 455 0, /* bitpos */ 456 complain_overflow_dont, /* complain_on_overflow */ 457 bfd_elf_generic_reloc, /* special_function */ 458 "R_FRV_GOTOFFLO", /* name */ 459 FALSE, /* partial_inplace */ 460 0xffff, /* src_mask */ 461 0xffff, /* dst_mask */ 462 FALSE), /* pcrel_offset */ 463 464 /* A 24-bit pc-relative relocation referencing the TLS PLT entry for 465 a thread-local symbol. If the symbol number is 0, it refers to 466 the module. */ 467 HOWTO (R_FRV_GETTLSOFF, /* type */ 468 2, /* rightshift */ 469 2, /* size (0 = byte, 1 = short, 2 = long) */ 470 26, /* bitsize */ 471 TRUE, /* pc_relative */ 472 0, /* bitpos */ 473 complain_overflow_bitfield, /* complain_on_overflow */ 474 bfd_elf_generic_reloc, /* special_function */ 475 "R_FRV_GETTLSOFF", /* name */ 476 FALSE, /* partial_inplace */ 477 0x7e03ffff, /* src_mask */ 478 0x7e03ffff, /* dst_mask */ 479 TRUE), /* pcrel_offset */ 480 481 /* A 64-bit TLS descriptor for a symbol. This relocation is only 482 valid as a REL, dynamic relocation. */ 483 HOWTO (R_FRV_TLSDESC_VALUE, /* type */ 484 0, /* rightshift */ 485 2, /* size (0 = byte, 1 = short, 2 = long) */ 486 64, /* bitsize */ 487 FALSE, /* pc_relative */ 488 0, /* bitpos */ 489 complain_overflow_bitfield, /* complain_on_overflow */ 490 bfd_elf_generic_reloc, /* special_function */ 491 "R_FRV_TLSDESC_VALUE", /* name */ 492 FALSE, /* partial_inplace */ 493 0xffffffff, /* src_mask */ 494 0xffffffff, /* dst_mask */ 495 FALSE), /* pcrel_offset */ 496 497 /* A 12-bit signed operand with the GOT offset for the TLS 498 descriptor of the symbol. */ 499 HOWTO (R_FRV_GOTTLSDESC12, /* type */ 500 0, /* rightshift */ 501 2, /* size (0 = byte, 1 = short, 2 = long) */ 502 12, /* bitsize */ 503 FALSE, /* pc_relative */ 504 0, /* bitpos */ 505 complain_overflow_signed, /* complain_on_overflow */ 506 bfd_elf_generic_reloc, /* special_function */ 507 "R_FRV_GOTTLSDESC12", /* name */ 508 FALSE, /* partial_inplace */ 509 0xfff, /* src_mask */ 510 0xfff, /* dst_mask */ 511 FALSE), /* pcrel_offset */ 512 513 /* The upper 16 bits of the GOT offset for the TLS descriptor of the 514 symbol. */ 515 HOWTO (R_FRV_GOTTLSDESCHI, /* type */ 516 0, /* rightshift */ 517 2, /* size (0 = byte, 1 = short, 2 = long) */ 518 16, /* bitsize */ 519 FALSE, /* pc_relative */ 520 0, /* bitpos */ 521 complain_overflow_dont, /* complain_on_overflow */ 522 bfd_elf_generic_reloc, /* special_function */ 523 "R_FRV_GOTTLSDESCHI", /* name */ 524 FALSE, /* partial_inplace */ 525 0xffff, /* src_mask */ 526 0xffff, /* dst_mask */ 527 FALSE), /* pcrel_offset */ 528 529 /* The lower 16 bits of the GOT offset for the TLS descriptor of the 530 symbol. */ 531 HOWTO (R_FRV_GOTTLSDESCLO, /* type */ 532 0, /* rightshift */ 533 2, /* size (0 = byte, 1 = short, 2 = long) */ 534 16, /* bitsize */ 535 FALSE, /* pc_relative */ 536 0, /* bitpos */ 537 complain_overflow_dont, /* complain_on_overflow */ 538 bfd_elf_generic_reloc, /* special_function */ 539 "R_FRV_GOTTLSDESCLO", /* name */ 540 FALSE, /* partial_inplace */ 541 0xffff, /* src_mask */ 542 0xffff, /* dst_mask */ 543 FALSE), /* pcrel_offset */ 544 545 /* A 12-bit signed operand with the offset from the module base 546 address to the thread-local symbol address. */ 547 HOWTO (R_FRV_TLSMOFF12, /* type */ 548 0, /* rightshift */ 549 2, /* size (0 = byte, 1 = short, 2 = long) */ 550 12, /* bitsize */ 551 FALSE, /* pc_relative */ 552 0, /* bitpos */ 553 complain_overflow_signed, /* complain_on_overflow */ 554 bfd_elf_generic_reloc, /* special_function */ 555 "R_FRV_TLSMOFF12", /* name */ 556 FALSE, /* partial_inplace */ 557 0xfff, /* src_mask */ 558 0xfff, /* dst_mask */ 559 FALSE), /* pcrel_offset */ 560 561 /* The upper 16 bits of the offset from the module base address to 562 the thread-local symbol address. */ 563 HOWTO (R_FRV_TLSMOFFHI, /* type */ 564 0, /* rightshift */ 565 2, /* size (0 = byte, 1 = short, 2 = long) */ 566 16, /* bitsize */ 567 FALSE, /* pc_relative */ 568 0, /* bitpos */ 569 complain_overflow_dont, /* complain_on_overflow */ 570 bfd_elf_generic_reloc, /* special_function */ 571 "R_FRV_TLSMOFFHI", /* name */ 572 FALSE, /* partial_inplace */ 573 0xffff, /* src_mask */ 574 0xffff, /* dst_mask */ 575 FALSE), /* pcrel_offset */ 576 577 /* The lower 16 bits of the offset from the module base address to 578 the thread-local symbol address. */ 579 HOWTO (R_FRV_TLSMOFFLO, /* type */ 580 0, /* rightshift */ 581 2, /* size (0 = byte, 1 = short, 2 = long) */ 582 16, /* bitsize */ 583 FALSE, /* pc_relative */ 584 0, /* bitpos */ 585 complain_overflow_dont, /* complain_on_overflow */ 586 bfd_elf_generic_reloc, /* special_function */ 587 "R_FRV_TLSMOFFLO", /* name */ 588 FALSE, /* partial_inplace */ 589 0xffff, /* src_mask */ 590 0xffff, /* dst_mask */ 591 FALSE), /* pcrel_offset */ 592 593 /* A 12-bit signed operand with the GOT offset for the TLSOFF entry 594 for a symbol. */ 595 HOWTO (R_FRV_GOTTLSOFF12, /* type */ 596 0, /* rightshift */ 597 2, /* size (0 = byte, 1 = short, 2 = long) */ 598 12, /* bitsize */ 599 FALSE, /* pc_relative */ 600 0, /* bitpos */ 601 complain_overflow_signed, /* complain_on_overflow */ 602 bfd_elf_generic_reloc, /* special_function */ 603 "R_FRV_GOTTLSOFF12", /* name */ 604 FALSE, /* partial_inplace */ 605 0xfff, /* src_mask */ 606 0xfff, /* dst_mask */ 607 FALSE), /* pcrel_offset */ 608 609 /* The upper 16 bits of the GOT offset for the TLSOFF entry for a 610 symbol. */ 611 HOWTO (R_FRV_GOTTLSOFFHI, /* type */ 612 0, /* rightshift */ 613 2, /* size (0 = byte, 1 = short, 2 = long) */ 614 16, /* bitsize */ 615 FALSE, /* pc_relative */ 616 0, /* bitpos */ 617 complain_overflow_dont, /* complain_on_overflow */ 618 bfd_elf_generic_reloc, /* special_function */ 619 "R_FRV_GOTTLSOFFHI", /* name */ 620 FALSE, /* partial_inplace */ 621 0xffff, /* src_mask */ 622 0xffff, /* dst_mask */ 623 FALSE), /* pcrel_offset */ 624 625 /* The lower 16 bits of the GOT offset for the TLSOFF entry for a 626 symbol. */ 627 HOWTO (R_FRV_GOTTLSOFFLO, /* type */ 628 0, /* rightshift */ 629 2, /* size (0 = byte, 1 = short, 2 = long) */ 630 16, /* bitsize */ 631 FALSE, /* pc_relative */ 632 0, /* bitpos */ 633 complain_overflow_dont, /* complain_on_overflow */ 634 bfd_elf_generic_reloc, /* special_function */ 635 "R_FRV_GOTTLSOFFLO", /* name */ 636 FALSE, /* partial_inplace */ 637 0xffff, /* src_mask */ 638 0xffff, /* dst_mask */ 639 FALSE), /* pcrel_offset */ 640 641 /* The 32-bit offset from the thread pointer (not the module base 642 address) to a thread-local symbol. */ 643 HOWTO (R_FRV_TLSOFF, /* type */ 644 0, /* rightshift */ 645 2, /* size (0 = byte, 1 = short, 2 = long) */ 646 32, /* bitsize */ 647 FALSE, /* pc_relative */ 648 0, /* bitpos */ 649 complain_overflow_dont, /* complain_on_overflow */ 650 bfd_elf_generic_reloc, /* special_function */ 651 "R_FRV_TLSOFF", /* name */ 652 FALSE, /* partial_inplace */ 653 0xffffffff, /* src_mask */ 654 0xffffffff, /* dst_mask */ 655 FALSE), /* pcrel_offset */ 656 657 /* An annotation for linker relaxation, that denotes the 658 symbol+addend whose TLS descriptor is referenced by the sum of 659 the two input registers of an ldd instruction. */ 660 HOWTO (R_FRV_TLSDESC_RELAX, /* type */ 661 0, /* rightshift */ 662 2, /* size (0 = byte, 1 = short, 2 = long) */ 663 0, /* bitsize */ 664 FALSE, /* pc_relative */ 665 0, /* bitpos */ 666 complain_overflow_dont, /* complain_on_overflow */ 667 bfd_elf_generic_reloc, /* special_function */ 668 "R_FRV_TLSDESC_RELAX", /* name */ 669 FALSE, /* partial_inplace */ 670 0, /* src_mask */ 671 0, /* dst_mask */ 672 FALSE), /* pcrel_offset */ 673 674 /* An annotation for linker relaxation, that denotes the 675 symbol+addend whose TLS resolver entry point is given by the sum 676 of the two register operands of an calll instruction. */ 677 HOWTO (R_FRV_GETTLSOFF_RELAX, /* type */ 678 0, /* rightshift */ 679 2, /* size (0 = byte, 1 = short, 2 = long) */ 680 0, /* bitsize */ 681 FALSE, /* pc_relative */ 682 0, /* bitpos */ 683 complain_overflow_dont, /* complain_on_overflow */ 684 bfd_elf_generic_reloc, /* special_function */ 685 "R_FRV_GETTLSOFF_RELAX", /* name */ 686 FALSE, /* partial_inplace */ 687 0, /* src_mask */ 688 0, /* dst_mask */ 689 FALSE), /* pcrel_offset */ 690 691 /* An annotation for linker relaxation, that denotes the 692 symbol+addend whose TLS offset GOT entry is given by the sum of 693 the two input registers of an ld instruction. */ 694 HOWTO (R_FRV_TLSOFF_RELAX, /* type */ 695 0, /* rightshift */ 696 2, /* size (0 = byte, 1 = short, 2 = long) */ 697 0, /* bitsize */ 698 FALSE, /* pc_relative */ 699 0, /* bitpos */ 700 complain_overflow_bitfield, /* complain_on_overflow */ 701 bfd_elf_generic_reloc, /* special_function */ 702 "R_FRV_TLSOFF_RELAX", /* name */ 703 FALSE, /* partial_inplace */ 704 0, /* src_mask */ 705 0, /* dst_mask */ 706 FALSE), /* pcrel_offset */ 707 708 /* A 32-bit offset from the module base address to 709 the thread-local symbol address. */ 710 HOWTO (R_FRV_TLSMOFF, /* type */ 711 0, /* rightshift */ 712 2, /* size (0 = byte, 1 = short, 2 = long) */ 713 32, /* bitsize */ 714 FALSE, /* pc_relative */ 715 0, /* bitpos */ 716 complain_overflow_dont, /* complain_on_overflow */ 717 bfd_elf_generic_reloc, /* special_function */ 718 "R_FRV_TLSMOFF", /* name */ 719 FALSE, /* partial_inplace */ 720 0xffffffff, /* src_mask */ 721 0xffffffff, /* dst_mask */ 722 FALSE), /* pcrel_offset */ 723 }; 724 725 /* GNU extension to record C++ vtable hierarchy. */ 726 static reloc_howto_type elf32_frv_vtinherit_howto = 727 HOWTO (R_FRV_GNU_VTINHERIT, /* type */ 728 0, /* rightshift */ 729 2, /* size (0 = byte, 1 = short, 2 = long) */ 730 0, /* bitsize */ 731 FALSE, /* pc_relative */ 732 0, /* bitpos */ 733 complain_overflow_dont, /* complain_on_overflow */ 734 NULL, /* special_function */ 735 "R_FRV_GNU_VTINHERIT", /* name */ 736 FALSE, /* partial_inplace */ 737 0, /* src_mask */ 738 0, /* dst_mask */ 739 FALSE); /* pcrel_offset */ 740 741 /* GNU extension to record C++ vtable member usage. */ 742 static reloc_howto_type elf32_frv_vtentry_howto = 743 HOWTO (R_FRV_GNU_VTENTRY, /* type */ 744 0, /* rightshift */ 745 2, /* size (0 = byte, 1 = short, 2 = long) */ 746 0, /* bitsize */ 747 FALSE, /* pc_relative */ 748 0, /* bitpos */ 749 complain_overflow_dont, /* complain_on_overflow */ 750 _bfd_elf_rel_vtable_reloc_fn, /* special_function */ 751 "R_FRV_GNU_VTENTRY", /* name */ 752 FALSE, /* partial_inplace */ 753 0, /* src_mask */ 754 0, /* dst_mask */ 755 FALSE); /* pcrel_offset */ 756 757 /* The following 3 relocations are REL. The only difference to the 758 entries in the table above are that partial_inplace is TRUE. */ 759 static reloc_howto_type elf32_frv_rel_32_howto = 760 HOWTO (R_FRV_32, /* type */ 761 0, /* rightshift */ 762 2, /* size (0 = byte, 1 = short, 2 = long) */ 763 32, /* bitsize */ 764 FALSE, /* pc_relative */ 765 0, /* bitpos */ 766 complain_overflow_bitfield, /* complain_on_overflow */ 767 bfd_elf_generic_reloc, /* special_function */ 768 "R_FRV_32", /* name */ 769 TRUE, /* partial_inplace */ 770 0xffffffff, /* src_mask */ 771 0xffffffff, /* dst_mask */ 772 FALSE); /* pcrel_offset */ 773 774 static reloc_howto_type elf32_frv_rel_funcdesc_howto = 775 HOWTO (R_FRV_FUNCDESC, /* type */ 776 0, /* rightshift */ 777 2, /* size (0 = byte, 1 = short, 2 = long) */ 778 32, /* bitsize */ 779 FALSE, /* pc_relative */ 780 0, /* bitpos */ 781 complain_overflow_bitfield, /* complain_on_overflow */ 782 bfd_elf_generic_reloc, /* special_function */ 783 "R_FRV_FUNCDESC", /* name */ 784 TRUE, /* partial_inplace */ 785 0xffffffff, /* src_mask */ 786 0xffffffff, /* dst_mask */ 787 FALSE); /* pcrel_offset */ 788 789 static reloc_howto_type elf32_frv_rel_funcdesc_value_howto = 790 HOWTO (R_FRV_FUNCDESC_VALUE, /* type */ 791 0, /* rightshift */ 792 2, /* size (0 = byte, 1 = short, 2 = long) */ 793 64, /* bitsize */ 794 FALSE, /* pc_relative */ 795 0, /* bitpos */ 796 complain_overflow_bitfield, /* complain_on_overflow */ 797 bfd_elf_generic_reloc, /* special_function */ 798 "R_FRV_FUNCDESC_VALUE", /* name */ 799 TRUE, /* partial_inplace */ 800 0xffffffff, /* src_mask */ 801 0xffffffff, /* dst_mask */ 802 FALSE); /* pcrel_offset */ 803 804 static reloc_howto_type elf32_frv_rel_tlsdesc_value_howto = 805 /* A 64-bit TLS descriptor for a symbol. The first word resolves to 806 an entry point, and the second resolves to a special argument. 807 If the symbol turns out to be in static TLS, the entry point is a 808 return instruction, and the special argument is the TLS offset 809 for the symbol. If it's in dynamic TLS, the entry point is a TLS 810 offset resolver, and the special argument is a pointer to a data 811 structure allocated by the dynamic loader, containing the GOT 812 address for the offset resolver, the module id, the offset within 813 the module, and anything else the TLS offset resolver might need 814 to determine the TLS offset for the symbol in the running 815 thread. */ 816 HOWTO (R_FRV_TLSDESC_VALUE, /* type */ 817 0, /* rightshift */ 818 2, /* size (0 = byte, 1 = short, 2 = long) */ 819 64, /* bitsize */ 820 FALSE, /* pc_relative */ 821 0, /* bitpos */ 822 complain_overflow_bitfield, /* complain_on_overflow */ 823 bfd_elf_generic_reloc, /* special_function */ 824 "R_FRV_TLSDESC_VALUE", /* name */ 825 TRUE, /* partial_inplace */ 826 0xffffffff, /* src_mask */ 827 0xffffffff, /* dst_mask */ 828 FALSE); /* pcrel_offset */ 829 830 static reloc_howto_type elf32_frv_rel_tlsoff_howto = 831 /* The 32-bit offset from the thread pointer (not the module base 832 address) to a thread-local symbol. */ 833 HOWTO (R_FRV_TLSOFF, /* type */ 834 0, /* rightshift */ 835 2, /* size (0 = byte, 1 = short, 2 = long) */ 836 32, /* bitsize */ 837 FALSE, /* pc_relative */ 838 0, /* bitpos */ 839 complain_overflow_bitfield, /* complain_on_overflow */ 840 bfd_elf_generic_reloc, /* special_function */ 841 "R_FRV_TLSOFF", /* name */ 842 TRUE, /* partial_inplace */ 843 0xffffffff, /* src_mask */ 844 0xffffffff, /* dst_mask */ 845 FALSE); /* pcrel_offset */ 846 847 848 849 extern const bfd_target bfd_elf32_frvfdpic_vec; 850 #define IS_FDPIC(bfd) ((bfd)->xvec == &bfd_elf32_frvfdpic_vec) 851 852 /* An extension of the elf hash table data structure, containing some 853 additional FRV-specific data. */ 854 struct frvfdpic_elf_link_hash_table 855 { 856 struct elf_link_hash_table elf; 857 858 /* A pointer to the .got section. */ 859 asection *sgot; 860 /* A pointer to the .rel.got section. */ 861 asection *sgotrel; 862 /* A pointer to the .rofixup section. */ 863 asection *sgotfixup; 864 /* A pointer to the .plt section. */ 865 asection *splt; 866 /* A pointer to the .rel.plt section. */ 867 asection *spltrel; 868 /* GOT base offset. */ 869 bfd_vma got0; 870 /* Location of the first non-lazy PLT entry, i.e., the number of 871 bytes taken by lazy PLT entries. If locally-bound TLS 872 descriptors require a ret instruction, it will be placed at this 873 offset. */ 874 bfd_vma plt0; 875 /* A hash table holding information about which symbols were 876 referenced with which PIC-related relocations. */ 877 struct htab *relocs_info; 878 /* Summary reloc information collected by 879 _frvfdpic_count_got_plt_entries. */ 880 struct _frvfdpic_dynamic_got_info *g; 881 }; 882 883 /* Get the FRV ELF linker hash table from a link_info structure. */ 884 885 #define frvfdpic_hash_table(p) \ 886 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \ 887 == FRV_ELF_DATA ? ((struct frvfdpic_elf_link_hash_table *) ((p)->hash)) : NULL) 888 889 #define frvfdpic_got_section(info) \ 890 (frvfdpic_hash_table (info)->sgot) 891 #define frvfdpic_gotrel_section(info) \ 892 (frvfdpic_hash_table (info)->sgotrel) 893 #define frvfdpic_gotfixup_section(info) \ 894 (frvfdpic_hash_table (info)->sgotfixup) 895 #define frvfdpic_plt_section(info) \ 896 (frvfdpic_hash_table (info)->splt) 897 #define frvfdpic_pltrel_section(info) \ 898 (frvfdpic_hash_table (info)->spltrel) 899 #define frvfdpic_relocs_info(info) \ 900 (frvfdpic_hash_table (info)->relocs_info) 901 #define frvfdpic_got_initial_offset(info) \ 902 (frvfdpic_hash_table (info)->got0) 903 #define frvfdpic_plt_initial_offset(info) \ 904 (frvfdpic_hash_table (info)->plt0) 905 #define frvfdpic_dynamic_got_plt_info(info) \ 906 (frvfdpic_hash_table (info)->g) 907 908 /* Currently it's the same, but if some day we have a reason to change 909 it, we'd better be using a different macro. 910 911 FIXME: if there's any TLS PLT entry that uses local-exec or 912 initial-exec models, we could use the ret at the end of any of them 913 instead of adding one more. */ 914 #define frvfdpic_plt_tls_ret_offset(info) \ 915 (frvfdpic_plt_initial_offset (info)) 916 917 /* The name of the dynamic interpreter. This is put in the .interp 918 section. */ 919 920 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1" 921 922 #define DEFAULT_STACK_SIZE 0x20000 923 924 /* This structure is used to collect the number of entries present in 925 each addressable range of the got. */ 926 struct _frvfdpic_dynamic_got_info 927 { 928 /* Several bits of information about the current link. */ 929 struct bfd_link_info *info; 930 /* Total GOT size needed for GOT entries within the 12-, 16- or 32-bit 931 ranges. */ 932 bfd_vma got12, gotlos, gothilo; 933 /* Total GOT size needed for function descriptor entries within the 12-, 934 16- or 32-bit ranges. */ 935 bfd_vma fd12, fdlos, fdhilo; 936 /* Total GOT size needed by function descriptor entries referenced 937 in PLT entries, that would be profitable to place in offsets 938 close to the PIC register. */ 939 bfd_vma fdplt; 940 /* Total PLT size needed by lazy PLT entries. */ 941 bfd_vma lzplt; 942 /* Total GOT size needed for TLS descriptor entries within the 12-, 943 16- or 32-bit ranges. */ 944 bfd_vma tlsd12, tlsdlos, tlsdhilo; 945 /* Total GOT size needed by TLS descriptors referenced in PLT 946 entries, that would be profitable to place in offers close to the 947 PIC register. */ 948 bfd_vma tlsdplt; 949 /* Total PLT size needed by TLS lazy PLT entries. */ 950 bfd_vma tlslzplt; 951 /* Number of relocations carried over from input object files. */ 952 unsigned long relocs; 953 /* Number of fixups introduced by relocations in input object files. */ 954 unsigned long fixups; 955 /* The number of fixups that reference the ret instruction added to 956 the PLT for locally-resolved TLS descriptors. */ 957 unsigned long tls_ret_refs; 958 }; 959 960 /* This structure is used to assign offsets to got entries, function 961 descriptors, plt entries and lazy plt entries. */ 962 963 struct _frvfdpic_dynamic_got_plt_info 964 { 965 /* Summary information collected with _frvfdpic_count_got_plt_entries. */ 966 struct _frvfdpic_dynamic_got_info g; 967 968 /* For each addressable range, we record a MAX (positive) and MIN 969 (negative) value. CUR is used to assign got entries, and it's 970 incremented from an initial positive value to MAX, then from MIN 971 to FDCUR (unless FDCUR wraps around first). FDCUR is used to 972 assign function descriptors, and it's decreased from an initial 973 non-positive value to MIN, then from MAX down to CUR (unless CUR 974 wraps around first). All of MIN, MAX, CUR and FDCUR always point 975 to even words. ODD, if non-zero, indicates an odd word to be 976 used for the next got entry, otherwise CUR is used and 977 incremented by a pair of words, wrapping around when it reaches 978 MAX. FDCUR is decremented (and wrapped) before the next function 979 descriptor is chosen. FDPLT indicates the number of remaining 980 slots that can be used for function descriptors used only by PLT 981 entries. 982 983 TMAX, TMIN and TCUR are used to assign TLS descriptors. TCUR 984 starts as MAX, and grows up to TMAX, then wraps around to TMIN 985 and grows up to MIN. TLSDPLT indicates the number of remaining 986 slots that can be used for TLS descriptors used only by TLS PLT 987 entries. */ 988 struct _frvfdpic_dynamic_got_alloc_data 989 { 990 bfd_signed_vma max, cur, odd, fdcur, min; 991 bfd_signed_vma tmax, tcur, tmin; 992 bfd_vma fdplt, tlsdplt; 993 } got12, gotlos, gothilo; 994 }; 995 996 /* Create an FRV ELF linker hash table. */ 997 998 static struct bfd_link_hash_table * 999 frvfdpic_elf_link_hash_table_create (bfd *abfd) 1000 { 1001 struct frvfdpic_elf_link_hash_table *ret; 1002 bfd_size_type amt = sizeof (struct frvfdpic_elf_link_hash_table); 1003 1004 ret = bfd_zalloc (abfd, amt); 1005 if (ret == NULL) 1006 return NULL; 1007 1008 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd, 1009 _bfd_elf_link_hash_newfunc, 1010 sizeof (struct elf_link_hash_entry), 1011 FRV_ELF_DATA)) 1012 { 1013 free (ret); 1014 return NULL; 1015 } 1016 1017 return &ret->elf.root; 1018 } 1019 1020 /* Decide whether a reference to a symbol can be resolved locally or 1021 not. If the symbol is protected, we want the local address, but 1022 its function descriptor must be assigned by the dynamic linker. */ 1023 #define FRVFDPIC_SYM_LOCAL(INFO, H) \ 1024 (_bfd_elf_symbol_refs_local_p ((H), (INFO), 1) \ 1025 || ! elf_hash_table (INFO)->dynamic_sections_created) 1026 #define FRVFDPIC_FUNCDESC_LOCAL(INFO, H) \ 1027 ((H)->dynindx == -1 || ! elf_hash_table (INFO)->dynamic_sections_created) 1028 1029 /* This structure collects information on what kind of GOT, PLT or 1030 function descriptors are required by relocations that reference a 1031 certain symbol. */ 1032 struct frvfdpic_relocs_info 1033 { 1034 /* The index of the symbol, as stored in the relocation r_info, if 1035 we have a local symbol; -1 otherwise. */ 1036 long symndx; 1037 union 1038 { 1039 /* The input bfd in which the symbol is defined, if it's a local 1040 symbol. */ 1041 bfd *abfd; 1042 /* If symndx == -1, the hash table entry corresponding to a global 1043 symbol (even if it turns out to bind locally, in which case it 1044 should ideally be replaced with section's symndx + addend). */ 1045 struct elf_link_hash_entry *h; 1046 } d; 1047 /* The addend of the relocation that references the symbol. */ 1048 bfd_vma addend; 1049 1050 /* The fields above are used to identify an entry. The fields below 1051 contain information on how an entry is used and, later on, which 1052 locations it was assigned. */ 1053 /* The following 3 fields record whether the symbol+addend above was 1054 ever referenced with a GOT relocation. The 12 suffix indicates a 1055 GOT12 relocation; los is used for GOTLO relocations that are not 1056 matched by a GOTHI relocation; hilo is used for GOTLO/GOTHI 1057 pairs. */ 1058 unsigned got12:1; 1059 unsigned gotlos:1; 1060 unsigned gothilo:1; 1061 /* Whether a FUNCDESC relocation references symbol+addend. */ 1062 unsigned fd:1; 1063 /* Whether a FUNCDESC_GOT relocation references symbol+addend. */ 1064 unsigned fdgot12:1; 1065 unsigned fdgotlos:1; 1066 unsigned fdgothilo:1; 1067 /* Whether a FUNCDESC_GOTOFF relocation references symbol+addend. */ 1068 unsigned fdgoff12:1; 1069 unsigned fdgofflos:1; 1070 unsigned fdgoffhilo:1; 1071 /* Whether a GETTLSOFF relocation references symbol+addend. */ 1072 unsigned tlsplt:1; 1073 /* FIXME: we should probably add tlspltdesc, tlspltoff and 1074 tlspltimm, to tell what kind of TLS PLT entry we're generating. 1075 We might instead just pre-compute flags telling whether the 1076 object is suitable for local exec, initial exec or general 1077 dynamic addressing, and use that all over the place. We could 1078 also try to do a better job of merging TLSOFF and TLSDESC entries 1079 in main executables, but perhaps we can get rid of TLSDESC 1080 entirely in them instead. */ 1081 /* Whether a GOTTLSDESC relocation references symbol+addend. */ 1082 unsigned tlsdesc12:1; 1083 unsigned tlsdesclos:1; 1084 unsigned tlsdeschilo:1; 1085 /* Whether a GOTTLSOFF relocation references symbol+addend. */ 1086 unsigned tlsoff12:1; 1087 unsigned tlsofflos:1; 1088 unsigned tlsoffhilo:1; 1089 /* Whether symbol+addend is referenced with GOTOFF12, GOTOFFLO or 1090 GOTOFFHI relocations. The addend doesn't really matter, since we 1091 envision that this will only be used to check whether the symbol 1092 is mapped to the same segment as the got. */ 1093 unsigned gotoff:1; 1094 /* Whether symbol+addend is referenced by a LABEL24 relocation. */ 1095 unsigned call:1; 1096 /* Whether symbol+addend is referenced by a 32 or FUNCDESC_VALUE 1097 relocation. */ 1098 unsigned sym:1; 1099 /* Whether we need a PLT entry for a symbol. Should be implied by 1100 something like: 1101 (call && symndx == -1 && ! FRVFDPIC_SYM_LOCAL (info, d.h)) */ 1102 unsigned plt:1; 1103 /* Whether a function descriptor should be created in this link unit 1104 for symbol+addend. Should be implied by something like: 1105 (plt || fdgotoff12 || fdgotofflos || fdgotofflohi 1106 || ((fd || fdgot12 || fdgotlos || fdgothilo) 1107 && (symndx != -1 || FRVFDPIC_FUNCDESC_LOCAL (info, d.h)))) */ 1108 unsigned privfd:1; 1109 /* Whether a lazy PLT entry is needed for this symbol+addend. 1110 Should be implied by something like: 1111 (privfd && symndx == -1 && ! FRVFDPIC_SYM_LOCAL (info, d.h) 1112 && ! (info->flags & DF_BIND_NOW)) */ 1113 unsigned lazyplt:1; 1114 /* Whether we've already emitted GOT relocations and PLT entries as 1115 needed for this symbol. */ 1116 unsigned done:1; 1117 1118 /* The number of R_FRV_32, R_FRV_FUNCDESC, R_FRV_FUNCDESC_VALUE and 1119 R_FRV_TLSDESC_VALUE, R_FRV_TLSOFF relocations referencing 1120 symbol+addend. */ 1121 unsigned relocs32, relocsfd, relocsfdv, relocstlsd, relocstlsoff; 1122 1123 /* The number of .rofixups entries and dynamic relocations allocated 1124 for this symbol, minus any that might have already been used. */ 1125 unsigned fixups, dynrelocs; 1126 1127 /* The offsets of the GOT entries assigned to symbol+addend, to the 1128 function descriptor's address, and to a function descriptor, 1129 respectively. Should be zero if unassigned. The offsets are 1130 counted from the value that will be assigned to the PIC register, 1131 not from the beginning of the .got section. */ 1132 bfd_signed_vma got_entry, fdgot_entry, fd_entry; 1133 /* The offsets of the PLT entries assigned to symbol+addend, 1134 non-lazy and lazy, respectively. If unassigned, should be 1135 (bfd_vma)-1. */ 1136 bfd_vma plt_entry, lzplt_entry; 1137 /* The offsets of the GOT entries for TLS offset and TLS descriptor. */ 1138 bfd_signed_vma tlsoff_entry, tlsdesc_entry; 1139 /* The offset of the TLS offset PLT entry. */ 1140 bfd_vma tlsplt_entry; 1141 }; 1142 1143 /* Compute a hash with the key fields of an frvfdpic_relocs_info entry. */ 1144 static hashval_t 1145 frvfdpic_relocs_info_hash (const void *entry_) 1146 { 1147 const struct frvfdpic_relocs_info *entry = entry_; 1148 1149 return (entry->symndx == -1 1150 ? (long) entry->d.h->root.root.hash 1151 : entry->symndx + (long) entry->d.abfd->id * 257) + entry->addend; 1152 } 1153 1154 /* Test whether the key fields of two frvfdpic_relocs_info entries are 1155 identical. */ 1156 static int 1157 frvfdpic_relocs_info_eq (const void *entry1, const void *entry2) 1158 { 1159 const struct frvfdpic_relocs_info *e1 = entry1; 1160 const struct frvfdpic_relocs_info *e2 = entry2; 1161 1162 return e1->symndx == e2->symndx && e1->addend == e2->addend 1163 && (e1->symndx == -1 ? e1->d.h == e2->d.h : e1->d.abfd == e2->d.abfd); 1164 } 1165 1166 /* Find or create an entry in a hash table HT that matches the key 1167 fields of the given ENTRY. If it's not found, memory for a new 1168 entry is allocated in ABFD's obstack. */ 1169 static struct frvfdpic_relocs_info * 1170 frvfdpic_relocs_info_find (struct htab *ht, 1171 bfd *abfd, 1172 const struct frvfdpic_relocs_info *entry, 1173 enum insert_option insert) 1174 { 1175 struct frvfdpic_relocs_info **loc = 1176 (struct frvfdpic_relocs_info **) htab_find_slot (ht, entry, insert); 1177 1178 if (! loc) 1179 return NULL; 1180 1181 if (*loc) 1182 return *loc; 1183 1184 *loc = bfd_zalloc (abfd, sizeof (**loc)); 1185 1186 if (! *loc) 1187 return *loc; 1188 1189 (*loc)->symndx = entry->symndx; 1190 (*loc)->d = entry->d; 1191 (*loc)->addend = entry->addend; 1192 (*loc)->plt_entry = (bfd_vma)-1; 1193 (*loc)->lzplt_entry = (bfd_vma)-1; 1194 (*loc)->tlsplt_entry = (bfd_vma)-1; 1195 1196 return *loc; 1197 } 1198 1199 /* Obtain the address of the entry in HT associated with H's symbol + 1200 addend, creating a new entry if none existed. ABFD is only used 1201 for memory allocation purposes. */ 1202 inline static struct frvfdpic_relocs_info * 1203 frvfdpic_relocs_info_for_global (struct htab *ht, 1204 bfd *abfd, 1205 struct elf_link_hash_entry *h, 1206 bfd_vma addend, 1207 enum insert_option insert) 1208 { 1209 struct frvfdpic_relocs_info entry; 1210 1211 entry.symndx = -1; 1212 entry.d.h = h; 1213 entry.addend = addend; 1214 1215 return frvfdpic_relocs_info_find (ht, abfd, &entry, insert); 1216 } 1217 1218 /* Obtain the address of the entry in HT associated with the SYMNDXth 1219 local symbol of the input bfd ABFD, plus the addend, creating a new 1220 entry if none existed. */ 1221 inline static struct frvfdpic_relocs_info * 1222 frvfdpic_relocs_info_for_local (struct htab *ht, 1223 bfd *abfd, 1224 long symndx, 1225 bfd_vma addend, 1226 enum insert_option insert) 1227 { 1228 struct frvfdpic_relocs_info entry; 1229 1230 entry.symndx = symndx; 1231 entry.d.abfd = abfd; 1232 entry.addend = addend; 1233 1234 return frvfdpic_relocs_info_find (ht, abfd, &entry, insert); 1235 } 1236 1237 /* Merge fields set by check_relocs() of two entries that end up being 1238 mapped to the same (presumably global) symbol. */ 1239 1240 inline static void 1241 frvfdpic_pic_merge_early_relocs_info (struct frvfdpic_relocs_info *e2, 1242 struct frvfdpic_relocs_info const *e1) 1243 { 1244 e2->got12 |= e1->got12; 1245 e2->gotlos |= e1->gotlos; 1246 e2->gothilo |= e1->gothilo; 1247 e2->fd |= e1->fd; 1248 e2->fdgot12 |= e1->fdgot12; 1249 e2->fdgotlos |= e1->fdgotlos; 1250 e2->fdgothilo |= e1->fdgothilo; 1251 e2->fdgoff12 |= e1->fdgoff12; 1252 e2->fdgofflos |= e1->fdgofflos; 1253 e2->fdgoffhilo |= e1->fdgoffhilo; 1254 e2->tlsplt |= e1->tlsplt; 1255 e2->tlsdesc12 |= e1->tlsdesc12; 1256 e2->tlsdesclos |= e1->tlsdesclos; 1257 e2->tlsdeschilo |= e1->tlsdeschilo; 1258 e2->tlsoff12 |= e1->tlsoff12; 1259 e2->tlsofflos |= e1->tlsofflos; 1260 e2->tlsoffhilo |= e1->tlsoffhilo; 1261 e2->gotoff |= e1->gotoff; 1262 e2->call |= e1->call; 1263 e2->sym |= e1->sym; 1264 } 1265 1266 /* Every block of 65535 lazy PLT entries shares a single call to the 1267 resolver, inserted in the 32768th lazy PLT entry (i.e., entry # 1268 32767, counting from 0). All other lazy PLT entries branch to it 1269 in a single instruction. */ 1270 1271 #define FRVFDPIC_LZPLT_BLOCK_SIZE ((bfd_vma) 8 * 65535 + 4) 1272 #define FRVFDPIC_LZPLT_RESOLV_LOC (8 * 32767) 1273 1274 /* Add a dynamic relocation to the SRELOC section. */ 1275 1276 inline static bfd_vma 1277 _frvfdpic_add_dyn_reloc (bfd *output_bfd, asection *sreloc, bfd_vma offset, 1278 int reloc_type, long dynindx, bfd_vma addend, 1279 struct frvfdpic_relocs_info *entry) 1280 { 1281 Elf_Internal_Rela outrel; 1282 bfd_vma reloc_offset; 1283 1284 outrel.r_offset = offset; 1285 outrel.r_info = ELF32_R_INFO (dynindx, reloc_type); 1286 outrel.r_addend = addend; 1287 1288 reloc_offset = sreloc->reloc_count * sizeof (Elf32_External_Rel); 1289 BFD_ASSERT (reloc_offset < sreloc->size); 1290 bfd_elf32_swap_reloc_out (output_bfd, &outrel, 1291 sreloc->contents + reloc_offset); 1292 sreloc->reloc_count++; 1293 1294 /* If the entry's index is zero, this relocation was probably to a 1295 linkonce section that got discarded. We reserved a dynamic 1296 relocation, but it was for another entry than the one we got at 1297 the time of emitting the relocation. Unfortunately there's no 1298 simple way for us to catch this situation, since the relocation 1299 is cleared right before calling relocate_section, at which point 1300 we no longer know what the relocation used to point to. */ 1301 if (entry->symndx) 1302 { 1303 BFD_ASSERT (entry->dynrelocs > 0); 1304 entry->dynrelocs--; 1305 } 1306 1307 return reloc_offset; 1308 } 1309 1310 /* Add a fixup to the ROFIXUP section. */ 1311 1312 static bfd_vma 1313 _frvfdpic_add_rofixup (bfd *output_bfd, asection *rofixup, bfd_vma offset, 1314 struct frvfdpic_relocs_info *entry) 1315 { 1316 bfd_vma fixup_offset; 1317 1318 if (rofixup->flags & SEC_EXCLUDE) 1319 return -1; 1320 1321 fixup_offset = rofixup->reloc_count * 4; 1322 if (rofixup->contents) 1323 { 1324 BFD_ASSERT (fixup_offset < rofixup->size); 1325 bfd_put_32 (output_bfd, offset, rofixup->contents + fixup_offset); 1326 } 1327 rofixup->reloc_count++; 1328 1329 if (entry && entry->symndx) 1330 { 1331 /* See discussion about symndx == 0 in _frvfdpic_add_dyn_reloc 1332 above. */ 1333 BFD_ASSERT (entry->fixups > 0); 1334 entry->fixups--; 1335 } 1336 1337 return fixup_offset; 1338 } 1339 1340 /* Find the segment number in which OSEC, and output section, is 1341 located. */ 1342 1343 static unsigned 1344 _frvfdpic_osec_to_segment (bfd *output_bfd, asection *osec) 1345 { 1346 Elf_Internal_Phdr *p = _bfd_elf_find_segment_containing_section (output_bfd, osec); 1347 1348 return (p != NULL) ? p - elf_tdata (output_bfd)->phdr : -1; 1349 } 1350 1351 inline static bfd_boolean 1352 _frvfdpic_osec_readonly_p (bfd *output_bfd, asection *osec) 1353 { 1354 unsigned seg = _frvfdpic_osec_to_segment (output_bfd, osec); 1355 1356 return ! (elf_tdata (output_bfd)->phdr[seg].p_flags & PF_W); 1357 } 1358 1359 #define FRVFDPIC_TLS_BIAS (2048 - 16) 1360 1361 /* Return the base VMA address which should be subtracted from real addresses 1362 when resolving TLSMOFF relocation. 1363 This is PT_TLS segment p_vaddr, plus the 2048-16 bias. */ 1364 1365 static bfd_vma 1366 tls_biased_base (struct bfd_link_info *info) 1367 { 1368 /* If tls_sec is NULL, we should have signalled an error already. */ 1369 if (elf_hash_table (info)->tls_sec == NULL) 1370 return FRVFDPIC_TLS_BIAS; 1371 return elf_hash_table (info)->tls_sec->vma + FRVFDPIC_TLS_BIAS; 1372 } 1373 1374 /* Generate relocations for GOT entries, function descriptors, and 1375 code for PLT and lazy PLT entries. */ 1376 1377 inline static bfd_boolean 1378 _frvfdpic_emit_got_relocs_plt_entries (struct frvfdpic_relocs_info *entry, 1379 bfd *output_bfd, 1380 struct bfd_link_info *info, 1381 asection *sec, 1382 Elf_Internal_Sym *sym, 1383 bfd_vma addend) 1384 1385 { 1386 bfd_vma fd_lazy_rel_offset = (bfd_vma)-1; 1387 int dynindx = -1; 1388 1389 if (entry->done) 1390 return TRUE; 1391 entry->done = 1; 1392 1393 if (entry->got_entry || entry->fdgot_entry || entry->fd_entry 1394 || entry->tlsoff_entry || entry->tlsdesc_entry) 1395 { 1396 /* If the symbol is dynamic, consider it for dynamic 1397 relocations, otherwise decay to section + offset. */ 1398 if (entry->symndx == -1 && entry->d.h->dynindx != -1) 1399 dynindx = entry->d.h->dynindx; 1400 else 1401 { 1402 if (sec 1403 && sec->output_section 1404 && ! bfd_is_abs_section (sec->output_section) 1405 && ! bfd_is_und_section (sec->output_section)) 1406 dynindx = elf_section_data (sec->output_section)->dynindx; 1407 else 1408 dynindx = 0; 1409 } 1410 } 1411 1412 /* Generate relocation for GOT entry pointing to the symbol. */ 1413 if (entry->got_entry) 1414 { 1415 int idx = dynindx; 1416 bfd_vma ad = addend; 1417 1418 /* If the symbol is dynamic but binds locally, use 1419 section+offset. */ 1420 if (sec && (entry->symndx != -1 1421 || FRVFDPIC_SYM_LOCAL (info, entry->d.h))) 1422 { 1423 if (entry->symndx == -1) 1424 ad += entry->d.h->root.u.def.value; 1425 else 1426 ad += sym->st_value; 1427 ad += sec->output_offset; 1428 if (sec->output_section && elf_section_data (sec->output_section)) 1429 idx = elf_section_data (sec->output_section)->dynindx; 1430 else 1431 idx = 0; 1432 } 1433 1434 /* If we're linking an executable at a fixed address, we can 1435 omit the dynamic relocation as long as the symbol is local to 1436 this module. */ 1437 if (info->executable && !info->pie 1438 && (entry->symndx != -1 1439 || FRVFDPIC_SYM_LOCAL (info, entry->d.h))) 1440 { 1441 if (sec) 1442 ad += sec->output_section->vma; 1443 if (entry->symndx != -1 1444 || entry->d.h->root.type != bfd_link_hash_undefweak) 1445 _frvfdpic_add_rofixup (output_bfd, 1446 frvfdpic_gotfixup_section (info), 1447 frvfdpic_got_section (info)->output_section 1448 ->vma 1449 + frvfdpic_got_section (info)->output_offset 1450 + frvfdpic_got_initial_offset (info) 1451 + entry->got_entry, entry); 1452 } 1453 else 1454 _frvfdpic_add_dyn_reloc (output_bfd, frvfdpic_gotrel_section (info), 1455 _bfd_elf_section_offset 1456 (output_bfd, info, 1457 frvfdpic_got_section (info), 1458 frvfdpic_got_initial_offset (info) 1459 + entry->got_entry) 1460 + frvfdpic_got_section (info) 1461 ->output_section->vma 1462 + frvfdpic_got_section (info)->output_offset, 1463 R_FRV_32, idx, ad, entry); 1464 1465 bfd_put_32 (output_bfd, ad, 1466 frvfdpic_got_section (info)->contents 1467 + frvfdpic_got_initial_offset (info) 1468 + entry->got_entry); 1469 } 1470 1471 /* Generate relocation for GOT entry pointing to a canonical 1472 function descriptor. */ 1473 if (entry->fdgot_entry) 1474 { 1475 int reloc, idx; 1476 bfd_vma ad = 0; 1477 1478 if (! (entry->symndx == -1 1479 && entry->d.h->root.type == bfd_link_hash_undefweak 1480 && FRVFDPIC_SYM_LOCAL (info, entry->d.h))) 1481 { 1482 /* If the symbol is dynamic and there may be dynamic symbol 1483 resolution because we are, or are linked with, a shared 1484 library, emit a FUNCDESC relocation such that the dynamic 1485 linker will allocate the function descriptor. If the 1486 symbol needs a non-local function descriptor but binds 1487 locally (e.g., its visibility is protected, emit a 1488 dynamic relocation decayed to section+offset. */ 1489 if (entry->symndx == -1 1490 && ! FRVFDPIC_FUNCDESC_LOCAL (info, entry->d.h) 1491 && FRVFDPIC_SYM_LOCAL (info, entry->d.h) 1492 && !(info->executable && !info->pie)) 1493 { 1494 reloc = R_FRV_FUNCDESC; 1495 idx = elf_section_data (entry->d.h->root.u.def.section 1496 ->output_section)->dynindx; 1497 ad = entry->d.h->root.u.def.section->output_offset 1498 + entry->d.h->root.u.def.value; 1499 } 1500 else if (entry->symndx == -1 1501 && ! FRVFDPIC_FUNCDESC_LOCAL (info, entry->d.h)) 1502 { 1503 reloc = R_FRV_FUNCDESC; 1504 idx = dynindx; 1505 ad = addend; 1506 if (ad) 1507 { 1508 (*info->callbacks->reloc_dangerous) 1509 (info, _("relocation requires zero addend"), 1510 elf_hash_table (info)->dynobj, 1511 frvfdpic_got_section (info), 1512 entry->fdgot_entry); 1513 return FALSE; 1514 } 1515 } 1516 else 1517 { 1518 /* Otherwise, we know we have a private function descriptor, 1519 so reference it directly. */ 1520 if (elf_hash_table (info)->dynamic_sections_created) 1521 BFD_ASSERT (entry->privfd); 1522 reloc = R_FRV_32; 1523 idx = elf_section_data (frvfdpic_got_section (info) 1524 ->output_section)->dynindx; 1525 ad = frvfdpic_got_section (info)->output_offset 1526 + frvfdpic_got_initial_offset (info) + entry->fd_entry; 1527 } 1528 1529 /* If there is room for dynamic symbol resolution, emit the 1530 dynamic relocation. However, if we're linking an 1531 executable at a fixed location, we won't have emitted a 1532 dynamic symbol entry for the got section, so idx will be 1533 zero, which means we can and should compute the address 1534 of the private descriptor ourselves. */ 1535 if (info->executable && !info->pie 1536 && (entry->symndx != -1 1537 || FRVFDPIC_FUNCDESC_LOCAL (info, entry->d.h))) 1538 { 1539 ad += frvfdpic_got_section (info)->output_section->vma; 1540 _frvfdpic_add_rofixup (output_bfd, 1541 frvfdpic_gotfixup_section (info), 1542 frvfdpic_got_section (info) 1543 ->output_section->vma 1544 + frvfdpic_got_section (info) 1545 ->output_offset 1546 + frvfdpic_got_initial_offset (info) 1547 + entry->fdgot_entry, entry); 1548 } 1549 else 1550 _frvfdpic_add_dyn_reloc (output_bfd, 1551 frvfdpic_gotrel_section (info), 1552 _bfd_elf_section_offset 1553 (output_bfd, info, 1554 frvfdpic_got_section (info), 1555 frvfdpic_got_initial_offset (info) 1556 + entry->fdgot_entry) 1557 + frvfdpic_got_section (info) 1558 ->output_section->vma 1559 + frvfdpic_got_section (info) 1560 ->output_offset, 1561 reloc, idx, ad, entry); 1562 } 1563 1564 bfd_put_32 (output_bfd, ad, 1565 frvfdpic_got_section (info)->contents 1566 + frvfdpic_got_initial_offset (info) 1567 + entry->fdgot_entry); 1568 } 1569 1570 /* Generate relocation to fill in a private function descriptor in 1571 the GOT. */ 1572 if (entry->fd_entry) 1573 { 1574 int idx = dynindx; 1575 bfd_vma ad = addend; 1576 bfd_vma ofst; 1577 long lowword, highword; 1578 1579 /* If the symbol is dynamic but binds locally, use 1580 section+offset. */ 1581 if (sec && (entry->symndx != -1 1582 || FRVFDPIC_SYM_LOCAL (info, entry->d.h))) 1583 { 1584 if (entry->symndx == -1) 1585 ad += entry->d.h->root.u.def.value; 1586 else 1587 ad += sym->st_value; 1588 ad += sec->output_offset; 1589 if (sec->output_section && elf_section_data (sec->output_section)) 1590 idx = elf_section_data (sec->output_section)->dynindx; 1591 else 1592 idx = 0; 1593 } 1594 1595 /* If we're linking an executable at a fixed address, we can 1596 omit the dynamic relocation as long as the symbol is local to 1597 this module. */ 1598 if (info->executable && !info->pie 1599 && (entry->symndx != -1 || FRVFDPIC_SYM_LOCAL (info, entry->d.h))) 1600 { 1601 if (sec) 1602 ad += sec->output_section->vma; 1603 ofst = 0; 1604 if (entry->symndx != -1 1605 || entry->d.h->root.type != bfd_link_hash_undefweak) 1606 { 1607 _frvfdpic_add_rofixup (output_bfd, 1608 frvfdpic_gotfixup_section (info), 1609 frvfdpic_got_section (info) 1610 ->output_section->vma 1611 + frvfdpic_got_section (info) 1612 ->output_offset 1613 + frvfdpic_got_initial_offset (info) 1614 + entry->fd_entry, entry); 1615 _frvfdpic_add_rofixup (output_bfd, 1616 frvfdpic_gotfixup_section (info), 1617 frvfdpic_got_section (info) 1618 ->output_section->vma 1619 + frvfdpic_got_section (info) 1620 ->output_offset 1621 + frvfdpic_got_initial_offset (info) 1622 + entry->fd_entry + 4, entry); 1623 } 1624 } 1625 else 1626 { 1627 ofst = 1628 _frvfdpic_add_dyn_reloc (output_bfd, 1629 entry->lazyplt 1630 ? frvfdpic_pltrel_section (info) 1631 : frvfdpic_gotrel_section (info), 1632 _bfd_elf_section_offset 1633 (output_bfd, info, 1634 frvfdpic_got_section (info), 1635 frvfdpic_got_initial_offset (info) 1636 + entry->fd_entry) 1637 + frvfdpic_got_section (info) 1638 ->output_section->vma 1639 + frvfdpic_got_section (info) 1640 ->output_offset, 1641 R_FRV_FUNCDESC_VALUE, idx, ad, entry); 1642 } 1643 1644 /* If we've omitted the dynamic relocation, just emit the fixed 1645 addresses of the symbol and of the local GOT base offset. */ 1646 if (info->executable && !info->pie && sec && sec->output_section) 1647 { 1648 lowword = ad; 1649 highword = frvfdpic_got_section (info)->output_section->vma 1650 + frvfdpic_got_section (info)->output_offset 1651 + frvfdpic_got_initial_offset (info); 1652 } 1653 else if (entry->lazyplt) 1654 { 1655 if (ad) 1656 { 1657 (*info->callbacks->reloc_dangerous) 1658 (info, _("relocation requires zero addend"), 1659 elf_hash_table (info)->dynobj, 1660 frvfdpic_got_section (info), 1661 entry->fd_entry); 1662 return FALSE; 1663 } 1664 1665 fd_lazy_rel_offset = ofst; 1666 1667 /* A function descriptor used for lazy or local resolving is 1668 initialized such that its high word contains the output 1669 section index in which the PLT entries are located, and 1670 the low word contains the address of the lazy PLT entry 1671 entry point, that must be within the memory region 1672 assigned to that section. */ 1673 lowword = entry->lzplt_entry + 4 1674 + frvfdpic_plt_section (info)->output_offset 1675 + frvfdpic_plt_section (info)->output_section->vma; 1676 highword = _frvfdpic_osec_to_segment 1677 (output_bfd, frvfdpic_plt_section (info)->output_section); 1678 } 1679 else 1680 { 1681 /* A function descriptor for a local function gets the index 1682 of the section. For a non-local function, it's 1683 disregarded. */ 1684 lowword = ad; 1685 if (sec == NULL 1686 || (entry->symndx == -1 && entry->d.h->dynindx != -1 1687 && entry->d.h->dynindx == idx)) 1688 highword = 0; 1689 else 1690 highword = _frvfdpic_osec_to_segment 1691 (output_bfd, sec->output_section); 1692 } 1693 1694 bfd_put_32 (output_bfd, lowword, 1695 frvfdpic_got_section (info)->contents 1696 + frvfdpic_got_initial_offset (info) 1697 + entry->fd_entry); 1698 bfd_put_32 (output_bfd, highword, 1699 frvfdpic_got_section (info)->contents 1700 + frvfdpic_got_initial_offset (info) 1701 + entry->fd_entry + 4); 1702 } 1703 1704 /* Generate code for the PLT entry. */ 1705 if (entry->plt_entry != (bfd_vma) -1) 1706 { 1707 bfd_byte *plt_code = frvfdpic_plt_section (info)->contents 1708 + entry->plt_entry; 1709 1710 BFD_ASSERT (entry->fd_entry); 1711 1712 /* Figure out what kind of PLT entry we need, depending on the 1713 location of the function descriptor within the GOT. */ 1714 if (entry->fd_entry >= -(1 << (12 - 1)) 1715 && entry->fd_entry < (1 << (12 - 1))) 1716 { 1717 /* lddi @(gr15, fd_entry), gr14 */ 1718 bfd_put_32 (output_bfd, 1719 0x9cccf000 | (entry->fd_entry & ((1 << 12) - 1)), 1720 plt_code); 1721 plt_code += 4; 1722 } 1723 else 1724 { 1725 if (entry->fd_entry >= -(1 << (16 - 1)) 1726 && entry->fd_entry < (1 << (16 - 1))) 1727 { 1728 /* setlos lo(fd_entry), gr14 */ 1729 bfd_put_32 (output_bfd, 1730 0x9cfc0000 1731 | (entry->fd_entry & (((bfd_vma)1 << 16) - 1)), 1732 plt_code); 1733 plt_code += 4; 1734 } 1735 else 1736 { 1737 /* sethi.p hi(fd_entry), gr14 1738 setlo lo(fd_entry), gr14 */ 1739 bfd_put_32 (output_bfd, 1740 0x1cf80000 1741 | ((entry->fd_entry >> 16) 1742 & (((bfd_vma)1 << 16) - 1)), 1743 plt_code); 1744 plt_code += 4; 1745 bfd_put_32 (output_bfd, 1746 0x9cf40000 1747 | (entry->fd_entry & (((bfd_vma)1 << 16) - 1)), 1748 plt_code); 1749 plt_code += 4; 1750 } 1751 /* ldd @(gr14,gr15),gr14 */ 1752 bfd_put_32 (output_bfd, 0x9c08e14f, plt_code); 1753 plt_code += 4; 1754 } 1755 /* jmpl @(gr14,gr0) */ 1756 bfd_put_32 (output_bfd, 0x8030e000, plt_code); 1757 } 1758 1759 /* Generate code for the lazy PLT entry. */ 1760 if (entry->lzplt_entry != (bfd_vma) -1) 1761 { 1762 bfd_byte *lzplt_code = frvfdpic_plt_section (info)->contents 1763 + entry->lzplt_entry; 1764 bfd_vma resolverStub_addr; 1765 1766 bfd_put_32 (output_bfd, fd_lazy_rel_offset, lzplt_code); 1767 lzplt_code += 4; 1768 1769 resolverStub_addr = entry->lzplt_entry / FRVFDPIC_LZPLT_BLOCK_SIZE 1770 * FRVFDPIC_LZPLT_BLOCK_SIZE + FRVFDPIC_LZPLT_RESOLV_LOC; 1771 if (resolverStub_addr >= frvfdpic_plt_initial_offset (info)) 1772 resolverStub_addr = frvfdpic_plt_initial_offset (info) - 12; 1773 1774 if (entry->lzplt_entry == resolverStub_addr) 1775 { 1776 /* This is a lazy PLT entry that includes a resolver call. */ 1777 /* ldd @(gr15,gr0), gr4 1778 jmpl @(gr4,gr0) */ 1779 bfd_put_32 (output_bfd, 0x8808f140, lzplt_code); 1780 bfd_put_32 (output_bfd, 0x80304000, lzplt_code + 4); 1781 } 1782 else 1783 { 1784 /* bra resolverStub */ 1785 bfd_put_32 (output_bfd, 1786 0xc01a0000 1787 | (((resolverStub_addr - entry->lzplt_entry) 1788 / 4) & (((bfd_vma)1 << 16) - 1)), 1789 lzplt_code); 1790 } 1791 } 1792 1793 /* Generate relocation for GOT entry holding the TLS offset. */ 1794 if (entry->tlsoff_entry) 1795 { 1796 int idx = dynindx; 1797 bfd_vma ad = addend; 1798 1799 if (entry->symndx != -1 1800 || FRVFDPIC_SYM_LOCAL (info, entry->d.h)) 1801 { 1802 /* If the symbol is dynamic but binds locally, use 1803 section+offset. */ 1804 if (sec) 1805 { 1806 if (entry->symndx == -1) 1807 ad += entry->d.h->root.u.def.value; 1808 else 1809 ad += sym->st_value; 1810 ad += sec->output_offset; 1811 if (sec->output_section 1812 && elf_section_data (sec->output_section)) 1813 idx = elf_section_data (sec->output_section)->dynindx; 1814 else 1815 idx = 0; 1816 } 1817 } 1818 1819 /* *ABS*+addend is special for TLS relocations, use only the 1820 addend. */ 1821 if (info->executable 1822 && idx == 0 1823 && (bfd_is_abs_section (sec) 1824 || bfd_is_und_section (sec))) 1825 ; 1826 /* If we're linking an executable, we can entirely omit the 1827 dynamic relocation if the symbol is local to this module. */ 1828 else if (info->executable 1829 && (entry->symndx != -1 1830 || FRVFDPIC_SYM_LOCAL (info, entry->d.h))) 1831 { 1832 if (sec) 1833 ad += sec->output_section->vma - tls_biased_base (info); 1834 } 1835 else 1836 { 1837 if (idx == 0 1838 && (bfd_is_abs_section (sec) 1839 || bfd_is_und_section (sec))) 1840 { 1841 if (! elf_hash_table (info)->tls_sec) 1842 { 1843 (*info->callbacks->undefined_symbol) 1844 (info, "TLS section", elf_hash_table (info)->dynobj, 1845 frvfdpic_got_section (info), entry->tlsoff_entry, TRUE); 1846 return FALSE; 1847 } 1848 idx = elf_section_data (elf_hash_table (info)->tls_sec)->dynindx; 1849 ad += FRVFDPIC_TLS_BIAS; 1850 } 1851 _frvfdpic_add_dyn_reloc (output_bfd, frvfdpic_gotrel_section (info), 1852 _bfd_elf_section_offset 1853 (output_bfd, info, 1854 frvfdpic_got_section (info), 1855 frvfdpic_got_initial_offset (info) 1856 + entry->tlsoff_entry) 1857 + frvfdpic_got_section (info) 1858 ->output_section->vma 1859 + frvfdpic_got_section (info) 1860 ->output_offset, 1861 R_FRV_TLSOFF, idx, ad, entry); 1862 } 1863 1864 bfd_put_32 (output_bfd, ad, 1865 frvfdpic_got_section (info)->contents 1866 + frvfdpic_got_initial_offset (info) 1867 + entry->tlsoff_entry); 1868 } 1869 1870 if (entry->tlsdesc_entry) 1871 { 1872 int idx = dynindx; 1873 bfd_vma ad = addend; 1874 1875 /* If the symbol is dynamic but binds locally, use 1876 section+offset. */ 1877 if (sec && (entry->symndx != -1 1878 || FRVFDPIC_SYM_LOCAL (info, entry->d.h))) 1879 { 1880 if (entry->symndx == -1) 1881 ad += entry->d.h->root.u.def.value; 1882 else 1883 ad += sym->st_value; 1884 ad += sec->output_offset; 1885 if (sec->output_section && elf_section_data (sec->output_section)) 1886 idx = elf_section_data (sec->output_section)->dynindx; 1887 else 1888 idx = 0; 1889 } 1890 1891 /* If we didn't set up a TLS offset entry, but we're linking an 1892 executable and the symbol binds locally, we can use the 1893 module offset in the TLS descriptor in relaxations. */ 1894 if (info->executable && ! entry->tlsoff_entry) 1895 entry->tlsoff_entry = entry->tlsdesc_entry + 4; 1896 1897 if (info->executable && !info->pie 1898 && ((idx == 0 1899 && (bfd_is_abs_section (sec) 1900 || bfd_is_und_section (sec))) 1901 || entry->symndx != -1 1902 || FRVFDPIC_SYM_LOCAL (info, entry->d.h))) 1903 { 1904 /* *ABS*+addend is special for TLS relocations, use only the 1905 addend for the TLS offset, and take the module id as 1906 0. */ 1907 if (idx == 0 1908 && (bfd_is_abs_section (sec) 1909 || bfd_is_und_section (sec))) 1910 ; 1911 /* For other TLS symbols that bind locally, add the section 1912 TLS offset to the addend. */ 1913 else if (sec) 1914 ad += sec->output_section->vma - tls_biased_base (info); 1915 1916 bfd_put_32 (output_bfd, 1917 frvfdpic_plt_section (info)->output_section->vma 1918 + frvfdpic_plt_section (info)->output_offset 1919 + frvfdpic_plt_tls_ret_offset (info), 1920 frvfdpic_got_section (info)->contents 1921 + frvfdpic_got_initial_offset (info) 1922 + entry->tlsdesc_entry); 1923 1924 _frvfdpic_add_rofixup (output_bfd, 1925 frvfdpic_gotfixup_section (info), 1926 frvfdpic_got_section (info) 1927 ->output_section->vma 1928 + frvfdpic_got_section (info) 1929 ->output_offset 1930 + frvfdpic_got_initial_offset (info) 1931 + entry->tlsdesc_entry, entry); 1932 1933 BFD_ASSERT (frvfdpic_dynamic_got_plt_info (info)->tls_ret_refs); 1934 1935 /* We've used one of the reserved fixups, so discount it so 1936 that we can check at the end that we've used them 1937 all. */ 1938 frvfdpic_dynamic_got_plt_info (info)->tls_ret_refs--; 1939 1940 /* While at that, make sure the ret instruction makes to the 1941 right location in the PLT. We could do it only when we 1942 got to 0, but since the check at the end will only print 1943 a warning, make sure we have the ret in place in case the 1944 warning is missed. */ 1945 bfd_put_32 (output_bfd, 0xc03a4000, 1946 frvfdpic_plt_section (info)->contents 1947 + frvfdpic_plt_tls_ret_offset (info)); 1948 } 1949 else 1950 { 1951 if (idx == 0 1952 && (bfd_is_abs_section (sec) 1953 || bfd_is_und_section (sec))) 1954 { 1955 if (! elf_hash_table (info)->tls_sec) 1956 { 1957 (*info->callbacks->undefined_symbol) 1958 (info, "TLS section", elf_hash_table (info)->dynobj, 1959 frvfdpic_got_section (info), entry->tlsdesc_entry, TRUE); 1960 return FALSE; 1961 } 1962 idx = elf_section_data (elf_hash_table (info)->tls_sec)->dynindx; 1963 ad += FRVFDPIC_TLS_BIAS; 1964 } 1965 1966 _frvfdpic_add_dyn_reloc (output_bfd, frvfdpic_gotrel_section (info), 1967 _bfd_elf_section_offset 1968 (output_bfd, info, 1969 frvfdpic_got_section (info), 1970 frvfdpic_got_initial_offset (info) 1971 + entry->tlsdesc_entry) 1972 + frvfdpic_got_section (info) 1973 ->output_section->vma 1974 + frvfdpic_got_section (info) 1975 ->output_offset, 1976 R_FRV_TLSDESC_VALUE, idx, ad, entry); 1977 1978 bfd_put_32 (output_bfd, 0, 1979 frvfdpic_got_section (info)->contents 1980 + frvfdpic_got_initial_offset (info) 1981 + entry->tlsdesc_entry); 1982 } 1983 1984 bfd_put_32 (output_bfd, ad, 1985 frvfdpic_got_section (info)->contents 1986 + frvfdpic_got_initial_offset (info) 1987 + entry->tlsdesc_entry + 4); 1988 } 1989 1990 /* Generate code for the get-TLS-offset PLT entry. */ 1991 if (entry->tlsplt_entry != (bfd_vma) -1) 1992 { 1993 bfd_byte *plt_code = frvfdpic_plt_section (info)->contents 1994 + entry->tlsplt_entry; 1995 1996 if (info->executable 1997 && (entry->symndx != -1 1998 || FRVFDPIC_SYM_LOCAL (info, entry->d.h))) 1999 { 2000 int idx = dynindx; 2001 bfd_vma ad = addend; 2002 2003 /* sec may be NULL when referencing an undefweak symbol 2004 while linking a static executable. */ 2005 if (!sec) 2006 { 2007 BFD_ASSERT (entry->symndx == -1 2008 && entry->d.h->root.type == bfd_link_hash_undefweak); 2009 } 2010 else 2011 { 2012 if (entry->symndx == -1) 2013 ad += entry->d.h->root.u.def.value; 2014 else 2015 ad += sym->st_value; 2016 ad += sec->output_offset; 2017 if (sec->output_section 2018 && elf_section_data (sec->output_section)) 2019 idx = elf_section_data (sec->output_section)->dynindx; 2020 else 2021 idx = 0; 2022 } 2023 2024 /* *ABS*+addend is special for TLS relocations, use only the 2025 addend for the TLS offset, and take the module id as 2026 0. */ 2027 if (idx == 0 2028 && (bfd_is_abs_section (sec) 2029 || bfd_is_und_section (sec))) 2030 ; 2031 /* For other TLS symbols that bind locally, add the section 2032 TLS offset to the addend. */ 2033 else if (sec) 2034 ad += sec->output_section->vma - tls_biased_base (info); 2035 2036 if ((bfd_signed_vma)ad >= -(1 << (16 - 1)) 2037 && (bfd_signed_vma)ad < (1 << (16 - 1))) 2038 { 2039 /* setlos lo(ad), gr9 */ 2040 bfd_put_32 (output_bfd, 2041 0x92fc0000 2042 | (ad 2043 & (((bfd_vma)1 << 16) - 1)), 2044 plt_code); 2045 plt_code += 4; 2046 } 2047 else 2048 { 2049 /* sethi.p hi(ad), gr9 2050 setlo lo(ad), gr9 */ 2051 bfd_put_32 (output_bfd, 2052 0x12f80000 2053 | ((ad >> 16) 2054 & (((bfd_vma)1 << 16) - 1)), 2055 plt_code); 2056 plt_code += 4; 2057 bfd_put_32 (output_bfd, 2058 0x92f40000 2059 | (ad 2060 & (((bfd_vma)1 << 16) - 1)), 2061 plt_code); 2062 plt_code += 4; 2063 } 2064 /* ret */ 2065 bfd_put_32 (output_bfd, 0xc03a4000, plt_code); 2066 } 2067 else if (entry->tlsoff_entry) 2068 { 2069 /* Figure out what kind of PLT entry we need, depending on the 2070 location of the TLS descriptor within the GOT. */ 2071 if (entry->tlsoff_entry >= -(1 << (12 - 1)) 2072 && entry->tlsoff_entry < (1 << (12 - 1))) 2073 { 2074 /* ldi @(gr15, tlsoff_entry), gr9 */ 2075 bfd_put_32 (output_bfd, 2076 0x92c8f000 | (entry->tlsoff_entry 2077 & ((1 << 12) - 1)), 2078 plt_code); 2079 plt_code += 4; 2080 } 2081 else 2082 { 2083 if (entry->tlsoff_entry >= -(1 << (16 - 1)) 2084 && entry->tlsoff_entry < (1 << (16 - 1))) 2085 { 2086 /* setlos lo(tlsoff_entry), gr8 */ 2087 bfd_put_32 (output_bfd, 2088 0x90fc0000 2089 | (entry->tlsoff_entry 2090 & (((bfd_vma)1 << 16) - 1)), 2091 plt_code); 2092 plt_code += 4; 2093 } 2094 else 2095 { 2096 /* sethi.p hi(tlsoff_entry), gr8 2097 setlo lo(tlsoff_entry), gr8 */ 2098 bfd_put_32 (output_bfd, 2099 0x10f80000 2100 | ((entry->tlsoff_entry >> 16) 2101 & (((bfd_vma)1 << 16) - 1)), 2102 plt_code); 2103 plt_code += 4; 2104 bfd_put_32 (output_bfd, 2105 0x90f40000 2106 | (entry->tlsoff_entry 2107 & (((bfd_vma)1 << 16) - 1)), 2108 plt_code); 2109 plt_code += 4; 2110 } 2111 /* ld @(gr15,gr8),gr9 */ 2112 bfd_put_32 (output_bfd, 0x9008f108, plt_code); 2113 plt_code += 4; 2114 } 2115 /* ret */ 2116 bfd_put_32 (output_bfd, 0xc03a4000, plt_code); 2117 } 2118 else 2119 { 2120 BFD_ASSERT (entry->tlsdesc_entry); 2121 2122 /* Figure out what kind of PLT entry we need, depending on the 2123 location of the TLS descriptor within the GOT. */ 2124 if (entry->tlsdesc_entry >= -(1 << (12 - 1)) 2125 && entry->tlsdesc_entry < (1 << (12 - 1))) 2126 { 2127 /* lddi @(gr15, tlsdesc_entry), gr8 */ 2128 bfd_put_32 (output_bfd, 2129 0x90ccf000 | (entry->tlsdesc_entry 2130 & ((1 << 12) - 1)), 2131 plt_code); 2132 plt_code += 4; 2133 } 2134 else 2135 { 2136 if (entry->tlsdesc_entry >= -(1 << (16 - 1)) 2137 && entry->tlsdesc_entry < (1 << (16 - 1))) 2138 { 2139 /* setlos lo(tlsdesc_entry), gr8 */ 2140 bfd_put_32 (output_bfd, 2141 0x90fc0000 2142 | (entry->tlsdesc_entry 2143 & (((bfd_vma)1 << 16) - 1)), 2144 plt_code); 2145 plt_code += 4; 2146 } 2147 else 2148 { 2149 /* sethi.p hi(tlsdesc_entry), gr8 2150 setlo lo(tlsdesc_entry), gr8 */ 2151 bfd_put_32 (output_bfd, 2152 0x10f80000 2153 | ((entry->tlsdesc_entry >> 16) 2154 & (((bfd_vma)1 << 16) - 1)), 2155 plt_code); 2156 plt_code += 4; 2157 bfd_put_32 (output_bfd, 2158 0x90f40000 2159 | (entry->tlsdesc_entry 2160 & (((bfd_vma)1 << 16) - 1)), 2161 plt_code); 2162 plt_code += 4; 2163 } 2164 /* ldd @(gr15,gr8),gr8 */ 2165 bfd_put_32 (output_bfd, 0x9008f148, plt_code); 2166 plt_code += 4; 2167 } 2168 /* jmpl @(gr8,gr0) */ 2169 bfd_put_32 (output_bfd, 0x80308000, plt_code); 2170 } 2171 } 2172 2173 return TRUE; 2174 } 2175 2176 /* Handle an FRV small data reloc. */ 2177 2178 static bfd_reloc_status_type 2179 elf32_frv_relocate_gprel12 (info, input_bfd, input_section, relocation, 2180 contents, value) 2181 struct bfd_link_info *info; 2182 bfd *input_bfd; 2183 asection *input_section; 2184 Elf_Internal_Rela *relocation; 2185 bfd_byte *contents; 2186 bfd_vma value; 2187 { 2188 bfd_vma insn; 2189 bfd_vma gp; 2190 struct bfd_link_hash_entry *h; 2191 2192 h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE); 2193 2194 gp = (h->u.def.value 2195 + h->u.def.section->output_section->vma 2196 + h->u.def.section->output_offset); 2197 2198 value -= input_section->output_section->vma; 2199 value -= (gp - input_section->output_section->vma); 2200 2201 insn = bfd_get_32 (input_bfd, contents + relocation->r_offset); 2202 2203 value += relocation->r_addend; 2204 2205 if ((long) value > 0x7ff || (long) value < -0x800) 2206 return bfd_reloc_overflow; 2207 2208 bfd_put_32 (input_bfd, 2209 (insn & 0xfffff000) | (value & 0xfff), 2210 contents + relocation->r_offset); 2211 2212 return bfd_reloc_ok; 2213 } 2214 2215 /* Handle an FRV small data reloc. for the u12 field. */ 2216 2217 static bfd_reloc_status_type 2218 elf32_frv_relocate_gprelu12 (info, input_bfd, input_section, relocation, 2219 contents, value) 2220 struct bfd_link_info *info; 2221 bfd *input_bfd; 2222 asection *input_section; 2223 Elf_Internal_Rela *relocation; 2224 bfd_byte *contents; 2225 bfd_vma value; 2226 { 2227 bfd_vma insn; 2228 bfd_vma gp; 2229 struct bfd_link_hash_entry *h; 2230 bfd_vma mask; 2231 2232 h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE); 2233 2234 gp = (h->u.def.value 2235 + h->u.def.section->output_section->vma 2236 + h->u.def.section->output_offset); 2237 2238 value -= input_section->output_section->vma; 2239 value -= (gp - input_section->output_section->vma); 2240 2241 insn = bfd_get_32 (input_bfd, contents + relocation->r_offset); 2242 2243 value += relocation->r_addend; 2244 2245 if ((long) value > 0x7ff || (long) value < -0x800) 2246 return bfd_reloc_overflow; 2247 2248 /* The high 6 bits go into bits 17-12. The low 6 bits go into bits 5-0. */ 2249 mask = 0x3f03f; 2250 insn = (insn & ~mask) | ((value & 0xfc0) << 12) | (value & 0x3f); 2251 2252 bfd_put_32 (input_bfd, insn, contents + relocation->r_offset); 2253 2254 return bfd_reloc_ok; 2255 } 2256 2257 /* Handle an FRV ELF HI16 reloc. */ 2258 2259 static bfd_reloc_status_type 2260 elf32_frv_relocate_hi16 (input_bfd, relhi, contents, value) 2261 bfd *input_bfd; 2262 Elf_Internal_Rela *relhi; 2263 bfd_byte *contents; 2264 bfd_vma value; 2265 { 2266 bfd_vma insn; 2267 2268 insn = bfd_get_32 (input_bfd, contents + relhi->r_offset); 2269 2270 value += relhi->r_addend; 2271 value = ((value >> 16) & 0xffff); 2272 2273 insn = (insn & 0xffff0000) | value; 2274 2275 if ((long) value > 0xffff || (long) value < -0x10000) 2276 return bfd_reloc_overflow; 2277 2278 bfd_put_32 (input_bfd, insn, contents + relhi->r_offset); 2279 return bfd_reloc_ok; 2280 2281 } 2282 static bfd_reloc_status_type 2283 elf32_frv_relocate_lo16 (input_bfd, rello, contents, value) 2284 bfd *input_bfd; 2285 Elf_Internal_Rela *rello; 2286 bfd_byte *contents; 2287 bfd_vma value; 2288 { 2289 bfd_vma insn; 2290 2291 insn = bfd_get_32 (input_bfd, contents + rello->r_offset); 2292 2293 value += rello->r_addend; 2294 value = value & 0xffff; 2295 2296 insn = (insn & 0xffff0000) | value; 2297 2298 if ((long) value > 0xffff || (long) value < -0x10000) 2299 return bfd_reloc_overflow; 2300 2301 bfd_put_32 (input_bfd, insn, contents + rello->r_offset); 2302 return bfd_reloc_ok; 2303 } 2304 2305 /* Perform the relocation for the CALL label24 instruction. */ 2306 2307 static bfd_reloc_status_type 2308 elf32_frv_relocate_label24 (input_bfd, input_section, rello, contents, value) 2309 bfd *input_bfd; 2310 asection *input_section; 2311 Elf_Internal_Rela *rello; 2312 bfd_byte *contents; 2313 bfd_vma value; 2314 { 2315 bfd_vma insn; 2316 bfd_vma label6; 2317 bfd_vma label18; 2318 2319 /* The format for the call instruction is: 2320 2321 0 000000 0001111 000000000000000000 2322 label6 opcode label18 2323 2324 The branch calculation is: pc + (4*label24) 2325 where label24 is the concatenation of label6 and label18. */ 2326 2327 /* Grab the instruction. */ 2328 insn = bfd_get_32 (input_bfd, contents + rello->r_offset); 2329 2330 value -= input_section->output_section->vma + input_section->output_offset; 2331 value -= rello->r_offset; 2332 value += rello->r_addend; 2333 2334 value = value >> 2; 2335 2336 label6 = value & 0xfc0000; 2337 label6 = label6 << 7; 2338 2339 label18 = value & 0x3ffff; 2340 2341 insn = insn & 0x803c0000; 2342 insn = insn | label6; 2343 insn = insn | label18; 2344 2345 bfd_put_32 (input_bfd, insn, contents + rello->r_offset); 2346 2347 return bfd_reloc_ok; 2348 } 2349 2350 static bfd_reloc_status_type 2351 elf32_frv_relocate_gprelhi (info, input_bfd, input_section, relocation, 2352 contents, value) 2353 struct bfd_link_info *info; 2354 bfd *input_bfd; 2355 asection *input_section; 2356 Elf_Internal_Rela *relocation; 2357 bfd_byte *contents; 2358 bfd_vma value; 2359 { 2360 bfd_vma insn; 2361 bfd_vma gp; 2362 struct bfd_link_hash_entry *h; 2363 2364 h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE); 2365 2366 gp = (h->u.def.value 2367 + h->u.def.section->output_section->vma 2368 + h->u.def.section->output_offset); 2369 2370 value -= input_section->output_section->vma; 2371 value -= (gp - input_section->output_section->vma); 2372 value += relocation->r_addend; 2373 value = ((value >> 16) & 0xffff); 2374 2375 if ((long) value > 0xffff || (long) value < -0x10000) 2376 return bfd_reloc_overflow; 2377 2378 insn = bfd_get_32 (input_bfd, contents + relocation->r_offset); 2379 insn = (insn & 0xffff0000) | value; 2380 2381 bfd_put_32 (input_bfd, insn, contents + relocation->r_offset); 2382 return bfd_reloc_ok; 2383 } 2384 2385 static bfd_reloc_status_type 2386 elf32_frv_relocate_gprello (info, input_bfd, input_section, relocation, 2387 contents, value) 2388 struct bfd_link_info *info; 2389 bfd *input_bfd; 2390 asection *input_section; 2391 Elf_Internal_Rela *relocation; 2392 bfd_byte *contents; 2393 bfd_vma value; 2394 { 2395 bfd_vma insn; 2396 bfd_vma gp; 2397 struct bfd_link_hash_entry *h; 2398 2399 h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE); 2400 2401 gp = (h->u.def.value 2402 + h->u.def.section->output_section->vma 2403 + h->u.def.section->output_offset); 2404 2405 value -= input_section->output_section->vma; 2406 value -= (gp - input_section->output_section->vma); 2407 value += relocation->r_addend; 2408 value = value & 0xffff; 2409 2410 if ((long) value > 0xffff || (long) value < -0x10000) 2411 return bfd_reloc_overflow; 2412 2413 insn = bfd_get_32 (input_bfd, contents + relocation->r_offset); 2414 insn = (insn & 0xffff0000) | value; 2415 2416 bfd_put_32 (input_bfd, insn, contents + relocation->r_offset); 2417 2418 return bfd_reloc_ok; 2419 } 2420 2421 static reloc_howto_type * 2422 frv_reloc_type_lookup (abfd, code) 2423 bfd *abfd ATTRIBUTE_UNUSED; 2424 bfd_reloc_code_real_type code; 2425 { 2426 switch (code) 2427 { 2428 default: 2429 break; 2430 2431 case BFD_RELOC_NONE: 2432 return &elf32_frv_howto_table[ (int) R_FRV_NONE]; 2433 2434 case BFD_RELOC_32: 2435 if (elf_elfheader (abfd)->e_type == ET_EXEC 2436 || elf_elfheader (abfd)->e_type == ET_DYN) 2437 return &elf32_frv_rel_32_howto; 2438 /* Fall through. */ 2439 case BFD_RELOC_CTOR: 2440 return &elf32_frv_howto_table[ (int) R_FRV_32]; 2441 2442 case BFD_RELOC_FRV_LABEL16: 2443 return &elf32_frv_howto_table[ (int) R_FRV_LABEL16]; 2444 2445 case BFD_RELOC_FRV_LABEL24: 2446 return &elf32_frv_howto_table[ (int) R_FRV_LABEL24]; 2447 2448 case BFD_RELOC_FRV_LO16: 2449 return &elf32_frv_howto_table[ (int) R_FRV_LO16]; 2450 2451 case BFD_RELOC_FRV_HI16: 2452 return &elf32_frv_howto_table[ (int) R_FRV_HI16]; 2453 2454 case BFD_RELOC_FRV_GPREL12: 2455 return &elf32_frv_howto_table[ (int) R_FRV_GPREL12]; 2456 2457 case BFD_RELOC_FRV_GPRELU12: 2458 return &elf32_frv_howto_table[ (int) R_FRV_GPRELU12]; 2459 2460 case BFD_RELOC_FRV_GPREL32: 2461 return &elf32_frv_howto_table[ (int) R_FRV_GPREL32]; 2462 2463 case BFD_RELOC_FRV_GPRELHI: 2464 return &elf32_frv_howto_table[ (int) R_FRV_GPRELHI]; 2465 2466 case BFD_RELOC_FRV_GPRELLO: 2467 return &elf32_frv_howto_table[ (int) R_FRV_GPRELLO]; 2468 2469 case BFD_RELOC_FRV_GOT12: 2470 return &elf32_frv_howto_table[ (int) R_FRV_GOT12]; 2471 2472 case BFD_RELOC_FRV_GOTHI: 2473 return &elf32_frv_howto_table[ (int) R_FRV_GOTHI]; 2474 2475 case BFD_RELOC_FRV_GOTLO: 2476 return &elf32_frv_howto_table[ (int) R_FRV_GOTLO]; 2477 2478 case BFD_RELOC_FRV_FUNCDESC: 2479 if (elf_elfheader (abfd)->e_type == ET_EXEC 2480 || elf_elfheader (abfd)->e_type == ET_DYN) 2481 return &elf32_frv_rel_funcdesc_howto; 2482 return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC]; 2483 2484 case BFD_RELOC_FRV_FUNCDESC_GOT12: 2485 return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC_GOT12]; 2486 2487 case BFD_RELOC_FRV_FUNCDESC_GOTHI: 2488 return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC_GOTHI]; 2489 2490 case BFD_RELOC_FRV_FUNCDESC_GOTLO: 2491 return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC_GOTLO]; 2492 2493 case BFD_RELOC_FRV_FUNCDESC_VALUE: 2494 if (elf_elfheader (abfd)->e_type == ET_EXEC 2495 || elf_elfheader (abfd)->e_type == ET_DYN) 2496 return &elf32_frv_rel_funcdesc_value_howto; 2497 return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC_VALUE]; 2498 2499 case BFD_RELOC_FRV_FUNCDESC_GOTOFF12: 2500 return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC_GOTOFF12]; 2501 2502 case BFD_RELOC_FRV_FUNCDESC_GOTOFFHI: 2503 return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC_GOTOFFHI]; 2504 2505 case BFD_RELOC_FRV_FUNCDESC_GOTOFFLO: 2506 return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC_GOTOFFLO]; 2507 2508 case BFD_RELOC_FRV_GOTOFF12: 2509 return &elf32_frv_howto_table[ (int) R_FRV_GOTOFF12]; 2510 2511 case BFD_RELOC_FRV_GOTOFFHI: 2512 return &elf32_frv_howto_table[ (int) R_FRV_GOTOFFHI]; 2513 2514 case BFD_RELOC_FRV_GOTOFFLO: 2515 return &elf32_frv_howto_table[ (int) R_FRV_GOTOFFLO]; 2516 2517 case BFD_RELOC_FRV_GETTLSOFF: 2518 return &elf32_frv_howto_table[ (int) R_FRV_GETTLSOFF]; 2519 2520 case BFD_RELOC_FRV_TLSDESC_VALUE: 2521 if (elf_elfheader (abfd)->e_type == ET_EXEC 2522 || elf_elfheader (abfd)->e_type == ET_DYN) 2523 return &elf32_frv_rel_tlsdesc_value_howto; 2524 return &elf32_frv_howto_table[ (int) R_FRV_TLSDESC_VALUE]; 2525 2526 case BFD_RELOC_FRV_GOTTLSDESC12: 2527 return &elf32_frv_howto_table[ (int) R_FRV_GOTTLSDESC12]; 2528 2529 case BFD_RELOC_FRV_GOTTLSDESCHI: 2530 return &elf32_frv_howto_table[ (int) R_FRV_GOTTLSDESCHI]; 2531 2532 case BFD_RELOC_FRV_GOTTLSDESCLO: 2533 return &elf32_frv_howto_table[ (int) R_FRV_GOTTLSDESCLO]; 2534 2535 case BFD_RELOC_FRV_TLSMOFF12: 2536 return &elf32_frv_howto_table[ (int) R_FRV_TLSMOFF12]; 2537 2538 case BFD_RELOC_FRV_TLSMOFFHI: 2539 return &elf32_frv_howto_table[ (int) R_FRV_TLSMOFFHI]; 2540 2541 case BFD_RELOC_FRV_TLSMOFFLO: 2542 return &elf32_frv_howto_table[ (int) R_FRV_TLSMOFFLO]; 2543 2544 case BFD_RELOC_FRV_GOTTLSOFF12: 2545 return &elf32_frv_howto_table[ (int) R_FRV_GOTTLSOFF12]; 2546 2547 case BFD_RELOC_FRV_GOTTLSOFFHI: 2548 return &elf32_frv_howto_table[ (int) R_FRV_GOTTLSOFFHI]; 2549 2550 case BFD_RELOC_FRV_GOTTLSOFFLO: 2551 return &elf32_frv_howto_table[ (int) R_FRV_GOTTLSOFFLO]; 2552 2553 case BFD_RELOC_FRV_TLSOFF: 2554 if (elf_elfheader (abfd)->e_type == ET_EXEC 2555 || elf_elfheader (abfd)->e_type == ET_DYN) 2556 return &elf32_frv_rel_tlsoff_howto; 2557 return &elf32_frv_howto_table[ (int) R_FRV_TLSOFF]; 2558 2559 case BFD_RELOC_FRV_TLSDESC_RELAX: 2560 return &elf32_frv_howto_table[ (int) R_FRV_TLSDESC_RELAX]; 2561 2562 case BFD_RELOC_FRV_GETTLSOFF_RELAX: 2563 return &elf32_frv_howto_table[ (int) R_FRV_GETTLSOFF_RELAX]; 2564 2565 case BFD_RELOC_FRV_TLSOFF_RELAX: 2566 return &elf32_frv_howto_table[ (int) R_FRV_TLSOFF_RELAX]; 2567 2568 case BFD_RELOC_FRV_TLSMOFF: 2569 return &elf32_frv_howto_table[ (int) R_FRV_TLSMOFF]; 2570 2571 case BFD_RELOC_VTABLE_INHERIT: 2572 return &elf32_frv_vtinherit_howto; 2573 2574 case BFD_RELOC_VTABLE_ENTRY: 2575 return &elf32_frv_vtentry_howto; 2576 } 2577 2578 return NULL; 2579 } 2580 2581 static reloc_howto_type * 2582 frv_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, const char *r_name) 2583 { 2584 unsigned int i; 2585 2586 for (i = 0; 2587 i < sizeof (elf32_frv_howto_table) / sizeof (elf32_frv_howto_table[0]); 2588 i++) 2589 if (elf32_frv_howto_table[i].name != NULL 2590 && strcasecmp (elf32_frv_howto_table[i].name, r_name) == 0) 2591 return &elf32_frv_howto_table[i]; 2592 2593 if (strcasecmp (elf32_frv_vtinherit_howto.name, r_name) == 0) 2594 return &elf32_frv_vtinherit_howto; 2595 if (strcasecmp (elf32_frv_vtentry_howto.name, r_name) == 0) 2596 return &elf32_frv_vtentry_howto; 2597 2598 return NULL; 2599 } 2600 2601 /* Set the howto pointer for an FRV ELF reloc. */ 2602 2603 static void 2604 frv_info_to_howto_rela (abfd, cache_ptr, dst) 2605 bfd *abfd ATTRIBUTE_UNUSED; 2606 arelent *cache_ptr; 2607 Elf_Internal_Rela *dst; 2608 { 2609 unsigned int r_type; 2610 2611 r_type = ELF32_R_TYPE (dst->r_info); 2612 switch (r_type) 2613 { 2614 case R_FRV_GNU_VTINHERIT: 2615 cache_ptr->howto = &elf32_frv_vtinherit_howto; 2616 break; 2617 2618 case R_FRV_GNU_VTENTRY: 2619 cache_ptr->howto = &elf32_frv_vtentry_howto; 2620 break; 2621 2622 default: 2623 cache_ptr->howto = & elf32_frv_howto_table [r_type]; 2624 break; 2625 } 2626 } 2627 2628 /* Set the howto pointer for an FRV ELF REL reloc. */ 2629 static void 2630 frvfdpic_info_to_howto_rel (bfd *abfd ATTRIBUTE_UNUSED, 2631 arelent *cache_ptr, Elf_Internal_Rela *dst) 2632 { 2633 unsigned int r_type; 2634 2635 r_type = ELF32_R_TYPE (dst->r_info); 2636 switch (r_type) 2637 { 2638 case R_FRV_32: 2639 cache_ptr->howto = &elf32_frv_rel_32_howto; 2640 break; 2641 2642 case R_FRV_FUNCDESC: 2643 cache_ptr->howto = &elf32_frv_rel_funcdesc_howto; 2644 break; 2645 2646 case R_FRV_FUNCDESC_VALUE: 2647 cache_ptr->howto = &elf32_frv_rel_funcdesc_value_howto; 2648 break; 2649 2650 case R_FRV_TLSDESC_VALUE: 2651 cache_ptr->howto = &elf32_frv_rel_tlsdesc_value_howto; 2652 break; 2653 2654 case R_FRV_TLSOFF: 2655 cache_ptr->howto = &elf32_frv_rel_tlsoff_howto; 2656 break; 2657 2658 default: 2659 cache_ptr->howto = NULL; 2660 break; 2661 } 2662 } 2663 2664 /* Perform a single relocation. By default we use the standard BFD 2665 routines, but a few relocs, we have to do them ourselves. */ 2666 2667 static bfd_reloc_status_type 2668 frv_final_link_relocate (howto, input_bfd, input_section, contents, rel, 2669 relocation) 2670 reloc_howto_type *howto; 2671 bfd *input_bfd; 2672 asection *input_section; 2673 bfd_byte *contents; 2674 Elf_Internal_Rela *rel; 2675 bfd_vma relocation; 2676 { 2677 return _bfd_final_link_relocate (howto, input_bfd, input_section, 2678 contents, rel->r_offset, relocation, 2679 rel->r_addend); 2680 } 2681 2682 2683 /* Relocate an FRV ELF section. 2684 2685 The RELOCATE_SECTION function is called by the new ELF backend linker 2686 to handle the relocations for a section. 2687 2688 The relocs are always passed as Rela structures; if the section 2689 actually uses Rel structures, the r_addend field will always be 2690 zero. 2691 2692 This function is responsible for adjusting the section contents as 2693 necessary, and (if using Rela relocs and generating a relocatable 2694 output file) adjusting the reloc addend as necessary. 2695 2696 This function does not have to worry about setting the reloc 2697 address or the reloc symbol index. 2698 2699 LOCAL_SYMS is a pointer to the swapped in local symbols. 2700 2701 LOCAL_SECTIONS is an array giving the section in the input file 2702 corresponding to the st_shndx field of each local symbol. 2703 2704 The global hash table entry for the global symbols can be found 2705 via elf_sym_hashes (input_bfd). 2706 2707 When generating relocatable output, this function must handle 2708 STB_LOCAL/STT_SECTION symbols specially. The output symbol is 2709 going to be the section symbol corresponding to the output 2710 section, which means that the addend must be adjusted 2711 accordingly. */ 2712 2713 static bfd_boolean 2714 elf32_frv_relocate_section (output_bfd, info, input_bfd, input_section, 2715 contents, relocs, local_syms, local_sections) 2716 bfd *output_bfd ATTRIBUTE_UNUSED; 2717 struct bfd_link_info *info; 2718 bfd *input_bfd; 2719 asection *input_section; 2720 bfd_byte *contents; 2721 Elf_Internal_Rela *relocs; 2722 Elf_Internal_Sym *local_syms; 2723 asection **local_sections; 2724 { 2725 Elf_Internal_Shdr *symtab_hdr; 2726 struct elf_link_hash_entry **sym_hashes; 2727 Elf_Internal_Rela *rel; 2728 Elf_Internal_Rela *relend; 2729 unsigned isec_segment, got_segment, plt_segment, gprel_segment, tls_segment, 2730 check_segment[2]; 2731 int silence_segment_error = !(info->shared || info->pie); 2732 unsigned long insn; 2733 2734 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr; 2735 sym_hashes = elf_sym_hashes (input_bfd); 2736 relend = relocs + input_section->reloc_count; 2737 2738 isec_segment = _frvfdpic_osec_to_segment (output_bfd, 2739 input_section->output_section); 2740 if (IS_FDPIC (output_bfd) && frvfdpic_got_section (info)) 2741 got_segment = _frvfdpic_osec_to_segment (output_bfd, 2742 frvfdpic_got_section (info) 2743 ->output_section); 2744 else 2745 got_segment = -1; 2746 if (IS_FDPIC (output_bfd) && frvfdpic_gotfixup_section (info)) 2747 gprel_segment = _frvfdpic_osec_to_segment (output_bfd, 2748 frvfdpic_gotfixup_section (info) 2749 ->output_section); 2750 else 2751 gprel_segment = -1; 2752 if (IS_FDPIC (output_bfd) && frvfdpic_plt_section (info)) 2753 plt_segment = _frvfdpic_osec_to_segment (output_bfd, 2754 frvfdpic_plt_section (info) 2755 ->output_section); 2756 else 2757 plt_segment = -1; 2758 if (elf_hash_table (info)->tls_sec) 2759 tls_segment = _frvfdpic_osec_to_segment (output_bfd, 2760 elf_hash_table (info)->tls_sec); 2761 else 2762 tls_segment = -1; 2763 2764 for (rel = relocs; rel < relend; rel ++) 2765 { 2766 reloc_howto_type *howto; 2767 unsigned long r_symndx; 2768 Elf_Internal_Sym *sym; 2769 asection *sec; 2770 struct elf_link_hash_entry *h; 2771 bfd_vma relocation; 2772 bfd_reloc_status_type r; 2773 const char *name; 2774 int r_type; 2775 asection *osec; 2776 struct frvfdpic_relocs_info *picrel; 2777 bfd_vma orig_addend = rel->r_addend; 2778 2779 r_type = ELF32_R_TYPE (rel->r_info); 2780 2781 if ( r_type == R_FRV_GNU_VTINHERIT 2782 || r_type == R_FRV_GNU_VTENTRY) 2783 continue; 2784 2785 r_symndx = ELF32_R_SYM (rel->r_info); 2786 howto = elf32_frv_howto_table + ELF32_R_TYPE (rel->r_info); 2787 h = NULL; 2788 sym = NULL; 2789 sec = NULL; 2790 2791 if (r_symndx < symtab_hdr->sh_info) 2792 { 2793 sym = local_syms + r_symndx; 2794 osec = sec = local_sections [r_symndx]; 2795 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel); 2796 2797 name = bfd_elf_string_from_elf_section 2798 (input_bfd, symtab_hdr->sh_link, sym->st_name); 2799 if (name == NULL || name[0] == 0) 2800 name = bfd_section_name (input_bfd, sec); 2801 } 2802 else 2803 { 2804 bfd_boolean warned; 2805 bfd_boolean unresolved_reloc; 2806 2807 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel, 2808 r_symndx, symtab_hdr, sym_hashes, 2809 h, sec, relocation, 2810 unresolved_reloc, warned); 2811 osec = sec; 2812 name = h->root.root.string; 2813 } 2814 2815 if (sec != NULL && elf_discarded_section (sec)) 2816 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section, 2817 rel, relend, howto, contents); 2818 2819 if (info->relocatable) 2820 continue; 2821 2822 if (r_type != R_FRV_TLSMOFF 2823 && h != NULL 2824 && (h->root.type == bfd_link_hash_defined 2825 || h->root.type == bfd_link_hash_defweak) 2826 && !FRVFDPIC_SYM_LOCAL (info, h)) 2827 { 2828 osec = sec = NULL; 2829 relocation = 0; 2830 } 2831 2832 switch (r_type) 2833 { 2834 case R_FRV_LABEL24: 2835 case R_FRV_32: 2836 if (! IS_FDPIC (output_bfd)) 2837 goto non_fdpic; 2838 2839 case R_FRV_GOT12: 2840 case R_FRV_GOTHI: 2841 case R_FRV_GOTLO: 2842 case R_FRV_FUNCDESC_GOT12: 2843 case R_FRV_FUNCDESC_GOTHI: 2844 case R_FRV_FUNCDESC_GOTLO: 2845 case R_FRV_GOTOFF12: 2846 case R_FRV_GOTOFFHI: 2847 case R_FRV_GOTOFFLO: 2848 case R_FRV_FUNCDESC_GOTOFF12: 2849 case R_FRV_FUNCDESC_GOTOFFHI: 2850 case R_FRV_FUNCDESC_GOTOFFLO: 2851 case R_FRV_FUNCDESC: 2852 case R_FRV_FUNCDESC_VALUE: 2853 case R_FRV_GETTLSOFF: 2854 case R_FRV_TLSDESC_VALUE: 2855 case R_FRV_GOTTLSDESC12: 2856 case R_FRV_GOTTLSDESCHI: 2857 case R_FRV_GOTTLSDESCLO: 2858 case R_FRV_TLSMOFF12: 2859 case R_FRV_TLSMOFFHI: 2860 case R_FRV_TLSMOFFLO: 2861 case R_FRV_GOTTLSOFF12: 2862 case R_FRV_GOTTLSOFFHI: 2863 case R_FRV_GOTTLSOFFLO: 2864 case R_FRV_TLSOFF: 2865 case R_FRV_TLSDESC_RELAX: 2866 case R_FRV_GETTLSOFF_RELAX: 2867 case R_FRV_TLSOFF_RELAX: 2868 case R_FRV_TLSMOFF: 2869 if (h != NULL) 2870 picrel = frvfdpic_relocs_info_for_global (frvfdpic_relocs_info 2871 (info), input_bfd, h, 2872 orig_addend, INSERT); 2873 else 2874 /* In order to find the entry we created before, we must 2875 use the original addend, not the one that may have been 2876 modified by _bfd_elf_rela_local_sym(). */ 2877 picrel = frvfdpic_relocs_info_for_local (frvfdpic_relocs_info 2878 (info), input_bfd, r_symndx, 2879 orig_addend, INSERT); 2880 if (! picrel) 2881 return FALSE; 2882 2883 if (!_frvfdpic_emit_got_relocs_plt_entries (picrel, output_bfd, info, 2884 osec, sym, 2885 rel->r_addend)) 2886 { 2887 (*_bfd_error_handler) 2888 (_("%B(%A+0x%x): relocation to `%s+%x' may have caused the error above"), 2889 input_bfd, input_section, rel->r_offset, name, rel->r_addend); 2890 return FALSE; 2891 } 2892 2893 break; 2894 2895 default: 2896 non_fdpic: 2897 picrel = NULL; 2898 if (h && ! FRVFDPIC_SYM_LOCAL (info, h)) 2899 { 2900 info->callbacks->warning 2901 (info, _("relocation references symbol not defined in the module"), 2902 name, input_bfd, input_section, rel->r_offset); 2903 return FALSE; 2904 } 2905 break; 2906 } 2907 2908 switch (r_type) 2909 { 2910 case R_FRV_GETTLSOFF: 2911 case R_FRV_TLSDESC_VALUE: 2912 case R_FRV_GOTTLSDESC12: 2913 case R_FRV_GOTTLSDESCHI: 2914 case R_FRV_GOTTLSDESCLO: 2915 case R_FRV_TLSMOFF12: 2916 case R_FRV_TLSMOFFHI: 2917 case R_FRV_TLSMOFFLO: 2918 case R_FRV_GOTTLSOFF12: 2919 case R_FRV_GOTTLSOFFHI: 2920 case R_FRV_GOTTLSOFFLO: 2921 case R_FRV_TLSOFF: 2922 case R_FRV_TLSDESC_RELAX: 2923 case R_FRV_GETTLSOFF_RELAX: 2924 case R_FRV_TLSOFF_RELAX: 2925 case R_FRV_TLSMOFF: 2926 if (sec && (bfd_is_abs_section (sec) || bfd_is_und_section (sec))) 2927 relocation += tls_biased_base (info); 2928 break; 2929 2930 default: 2931 break; 2932 } 2933 2934 /* Try to apply TLS relaxations. */ 2935 if (1) 2936 switch (r_type) 2937 { 2938 2939 #define LOCAL_EXEC_P(info, picrel) \ 2940 ((info)->executable \ 2941 && (picrel->symndx != -1 || FRVFDPIC_SYM_LOCAL ((info), (picrel)->d.h))) 2942 #define INITIAL_EXEC_P(info, picrel) \ 2943 (((info)->executable || (info)->flags & DF_STATIC_TLS) \ 2944 && (picrel)->tlsoff_entry) 2945 2946 #define IN_RANGE_FOR_OFST12_P(value) \ 2947 ((bfd_vma)((value) + 2048) < (bfd_vma)4096) 2948 #define IN_RANGE_FOR_SETLOS_P(value) \ 2949 ((bfd_vma)((value) + 32768) < (bfd_vma)65536) 2950 #define TLSMOFF_IN_RANGE_FOR_SETLOS_P(value, info) \ 2951 (IN_RANGE_FOR_SETLOS_P ((value) - tls_biased_base (info))) 2952 2953 #define RELAX_GETTLSOFF_LOCAL_EXEC_P(info, picrel, value) \ 2954 (LOCAL_EXEC_P ((info), (picrel)) \ 2955 && TLSMOFF_IN_RANGE_FOR_SETLOS_P((value), (info))) 2956 #define RELAX_GETTLSOFF_INITIAL_EXEC_P(info, picrel) \ 2957 (INITIAL_EXEC_P ((info), (picrel)) \ 2958 && IN_RANGE_FOR_OFST12_P ((picrel)->tlsoff_entry)) 2959 2960 #define RELAX_TLSDESC_LOCAL_EXEC_P(info, picrel, value) \ 2961 (LOCAL_EXEC_P ((info), (picrel))) 2962 #define RELAX_TLSDESC_INITIAL_EXEC_P(info, picrel) \ 2963 (INITIAL_EXEC_P ((info), (picrel))) 2964 2965 #define RELAX_GOTTLSOFF_LOCAL_EXEC_P(info, picrel, value) \ 2966 (LOCAL_EXEC_P ((info), (picrel)) \ 2967 && TLSMOFF_IN_RANGE_FOR_SETLOS_P((value), (info))) 2968 2969 case R_FRV_GETTLSOFF: 2970 insn = bfd_get_32 (input_bfd, contents + rel->r_offset); 2971 2972 /* Is this a call instruction? */ 2973 if ((insn & (unsigned long)0x01fc0000) != 0x003c0000) 2974 { 2975 r = info->callbacks->warning 2976 (info, 2977 _("R_FRV_GETTLSOFF not applied to a call instruction"), 2978 name, input_bfd, input_section, rel->r_offset); 2979 return FALSE; 2980 } 2981 2982 if (RELAX_GETTLSOFF_LOCAL_EXEC_P (info, picrel, 2983 relocation + rel->r_addend)) 2984 { 2985 /* Replace the call instruction (except the packing bit) 2986 with setlos #tlsmofflo(symbol+offset), gr9. */ 2987 insn &= (unsigned long)0x80000000; 2988 insn |= (unsigned long)0x12fc0000; 2989 bfd_put_32 (input_bfd, insn, contents + rel->r_offset); 2990 2991 r_type = R_FRV_TLSMOFFLO; 2992 howto = elf32_frv_howto_table + r_type; 2993 rel->r_info = ELF32_R_INFO (r_symndx, r_type); 2994 } 2995 2996 else if (RELAX_GETTLSOFF_INITIAL_EXEC_P (info, picrel)) 2997 { 2998 /* Replace the call instruction (except the packing bit) 2999 with ldi @(gr15, #gottlsoff12(symbol+addend)), gr9. */ 3000 insn &= (unsigned long)0x80000000; 3001 insn |= (unsigned long)0x12c8f000; 3002 bfd_put_32 (input_bfd, insn, contents + rel->r_offset); 3003 3004 r_type = R_FRV_GOTTLSOFF12; 3005 howto = elf32_frv_howto_table + r_type; 3006 rel->r_info = ELF32_R_INFO (r_symndx, r_type); 3007 } 3008 3009 break; 3010 3011 case R_FRV_GOTTLSDESC12: 3012 insn = bfd_get_32 (input_bfd, contents + rel->r_offset); 3013 3014 /* Is this an lddi instruction? */ 3015 if ((insn & (unsigned long)0x01fc0000) != 0x00cc0000) 3016 { 3017 r = info->callbacks->warning 3018 (info, 3019 _("R_FRV_GOTTLSDESC12 not applied to an lddi instruction"), 3020 name, input_bfd, input_section, rel->r_offset); 3021 return FALSE; 3022 } 3023 3024 if (RELAX_TLSDESC_LOCAL_EXEC_P (info, picrel, 3025 relocation + rel->r_addend) 3026 && TLSMOFF_IN_RANGE_FOR_SETLOS_P (relocation + rel->r_addend, 3027 info)) 3028 { 3029 /* Replace lddi @(grB, #gottlsdesc12(symbol+offset), grC 3030 with setlos #tlsmofflo(symbol+offset), gr<C+1>. 3031 Preserve the packing bit. */ 3032 insn = (insn & (unsigned long)0x80000000) 3033 | ((insn + (unsigned long)0x02000000) 3034 & (unsigned long)0x7e000000); 3035 insn |= (unsigned long)0x00fc0000; 3036 bfd_put_32 (input_bfd, insn, contents + rel->r_offset); 3037 3038 r_type = R_FRV_TLSMOFFLO; 3039 howto = elf32_frv_howto_table + r_type; 3040 rel->r_info = ELF32_R_INFO (r_symndx, r_type); 3041 } 3042 3043 else if (RELAX_TLSDESC_LOCAL_EXEC_P (info, picrel, 3044 relocation + rel->r_addend)) 3045 { 3046 /* Replace lddi @(grB, #gottlsdesc12(symbol+offset), grC 3047 with sethi #tlsmoffhi(symbol+offset), gr<C+1>. 3048 Preserve the packing bit. */ 3049 insn = (insn & (unsigned long)0x80000000) 3050 | ((insn + (unsigned long)0x02000000) 3051 & (unsigned long)0x7e000000); 3052 insn |= (unsigned long)0x00f80000; 3053 bfd_put_32 (input_bfd, insn, contents + rel->r_offset); 3054 3055 r_type = R_FRV_TLSMOFFHI; 3056 howto = elf32_frv_howto_table + r_type; 3057 rel->r_info = ELF32_R_INFO (r_symndx, r_type); 3058 } 3059 3060 else if (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel)) 3061 { 3062 /* Replace lddi @(grB, #gottlsdesc12(symbol+offset), grC 3063 with ldi @(grB, #gottlsoff12(symbol+offset), 3064 gr<C+1>. Preserve the packing bit. If gottlsoff12 3065 overflows, we'll error out, but that's sort-of ok, 3066 since we'd started with gottlsdesc12, that's actually 3067 more demanding. Compiling with -fPIE instead of 3068 -fpie would fix it; linking with --relax should fix 3069 it as well. */ 3070 insn = (insn & (unsigned long)0x80cbf000) 3071 | ((insn + (unsigned long)0x02000000) 3072 & (unsigned long)0x7e000000); 3073 bfd_put_32 (input_bfd, insn, contents + rel->r_offset); 3074 3075 r_type = R_FRV_GOTTLSOFF12; 3076 howto = elf32_frv_howto_table + r_type; 3077 rel->r_info = ELF32_R_INFO (r_symndx, r_type); 3078 } 3079 3080 break; 3081 3082 case R_FRV_GOTTLSDESCHI: 3083 insn = bfd_get_32 (input_bfd, contents + rel->r_offset); 3084 3085 /* Is this a sethi instruction? */ 3086 if ((insn & (unsigned long)0x01ff0000) != 0x00f80000) 3087 { 3088 r = info->callbacks->warning 3089 (info, 3090 _("R_FRV_GOTTLSDESCHI not applied to a sethi instruction"), 3091 name, input_bfd, input_section, rel->r_offset); 3092 return FALSE; 3093 } 3094 3095 if (RELAX_TLSDESC_LOCAL_EXEC_P (info, picrel, 3096 relocation + rel->r_addend) 3097 || (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel) 3098 && IN_RANGE_FOR_SETLOS_P (picrel->tlsoff_entry))) 3099 { 3100 /* Replace sethi with a nop. Preserve the packing bit. */ 3101 insn &= (unsigned long)0x80000000; 3102 insn |= (unsigned long)0x00880000; 3103 bfd_put_32 (input_bfd, insn, contents + rel->r_offset); 3104 3105 /* Nothing to relocate. */ 3106 continue; 3107 } 3108 3109 else if (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel)) 3110 { 3111 /* Simply decay GOTTLSDESC to GOTTLSOFF. */ 3112 r_type = R_FRV_GOTTLSOFFHI; 3113 howto = elf32_frv_howto_table + r_type; 3114 rel->r_info = ELF32_R_INFO (r_symndx, r_type); 3115 } 3116 3117 break; 3118 3119 case R_FRV_GOTTLSDESCLO: 3120 insn = bfd_get_32 (input_bfd, contents + rel->r_offset); 3121 3122 /* Is this a setlo or setlos instruction? */ 3123 if ((insn & (unsigned long)0x01f70000) != 0x00f40000) 3124 { 3125 r = info->callbacks->warning 3126 (info, 3127 _("R_FRV_GOTTLSDESCLO" 3128 " not applied to a setlo or setlos instruction"), 3129 name, input_bfd, input_section, rel->r_offset); 3130 return FALSE; 3131 } 3132 3133 if (RELAX_TLSDESC_LOCAL_EXEC_P (info, picrel, 3134 relocation + rel->r_addend) 3135 || (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel) 3136 && IN_RANGE_FOR_OFST12_P (picrel->tlsoff_entry))) 3137 { 3138 /* Replace setlo/setlos with a nop. Preserve the 3139 packing bit. */ 3140 insn &= (unsigned long)0x80000000; 3141 insn |= (unsigned long)0x00880000; 3142 bfd_put_32 (input_bfd, insn, contents + rel->r_offset); 3143 3144 /* Nothing to relocate. */ 3145 continue; 3146 } 3147 3148 else if (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel)) 3149 { 3150 /* If the corresponding sethi (if it exists) decayed 3151 to a nop, make sure this becomes (or already is) a 3152 setlos, not setlo. */ 3153 if (IN_RANGE_FOR_SETLOS_P (picrel->tlsoff_entry)) 3154 { 3155 insn |= (unsigned long)0x00080000; 3156 bfd_put_32 (input_bfd, insn, contents + rel->r_offset); 3157 } 3158 3159 /* Simply decay GOTTLSDESC to GOTTLSOFF. */ 3160 r_type = R_FRV_GOTTLSOFFLO; 3161 howto = elf32_frv_howto_table + r_type; 3162 rel->r_info = ELF32_R_INFO (r_symndx, r_type); 3163 } 3164 3165 break; 3166 3167 case R_FRV_TLSDESC_RELAX: 3168 insn = bfd_get_32 (input_bfd, contents + rel->r_offset); 3169 3170 /* Is this an ldd instruction? */ 3171 if ((insn & (unsigned long)0x01fc0fc0) != 0x00080140) 3172 { 3173 r = info->callbacks->warning 3174 (info, 3175 _("R_FRV_TLSDESC_RELAX not applied to an ldd instruction"), 3176 name, input_bfd, input_section, rel->r_offset); 3177 return FALSE; 3178 } 3179 3180 if (RELAX_TLSDESC_LOCAL_EXEC_P (info, picrel, 3181 relocation + rel->r_addend) 3182 && TLSMOFF_IN_RANGE_FOR_SETLOS_P (relocation + rel->r_addend, 3183 info)) 3184 { 3185 /* Replace ldd #tlsdesc(symbol+offset)@(grB, grA), grC 3186 with setlos #tlsmofflo(symbol+offset), gr<C+1>. 3187 Preserve the packing bit. */ 3188 insn = (insn & (unsigned long)0x80000000) 3189 | ((insn + (unsigned long)0x02000000) 3190 & (unsigned long)0x7e000000); 3191 insn |= (unsigned long)0x00fc0000; 3192 bfd_put_32 (input_bfd, insn, contents + rel->r_offset); 3193 3194 r_type = R_FRV_TLSMOFFLO; 3195 howto = elf32_frv_howto_table + r_type; 3196 rel->r_info = ELF32_R_INFO (r_symndx, r_type); 3197 } 3198 3199 else if (RELAX_TLSDESC_LOCAL_EXEC_P (info, picrel, 3200 relocation + rel->r_addend)) 3201 { 3202 /* Replace ldd #tlsdesc(symbol+offset)@(grB, grA), grC 3203 with sethi #tlsmoffhi(symbol+offset), gr<C+1>. 3204 Preserve the packing bit. */ 3205 insn = (insn & (unsigned long)0x80000000) 3206 | ((insn + (unsigned long)0x02000000) 3207 & (unsigned long)0x7e000000); 3208 insn |= (unsigned long)0x00f80000; 3209 bfd_put_32 (input_bfd, insn, contents + rel->r_offset); 3210 3211 r_type = R_FRV_TLSMOFFHI; 3212 howto = elf32_frv_howto_table + r_type; 3213 rel->r_info = ELF32_R_INFO (r_symndx, r_type); 3214 } 3215 3216 else if (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel) 3217 && IN_RANGE_FOR_OFST12_P (picrel->tlsoff_entry)) 3218 { 3219 /* Replace ldd #tlsdesc(symbol+offset)@(grB, grA), grC 3220 with ldi @(grB, #gottlsoff12(symbol+offset), gr<C+1>. 3221 Preserve the packing bit. */ 3222 insn = (insn & (unsigned long)0x8003f000) 3223 | (unsigned long)0x00c80000 3224 | ((insn + (unsigned long)0x02000000) 3225 & (unsigned long)0x7e000000); 3226 bfd_put_32 (input_bfd, insn, contents + rel->r_offset); 3227 3228 r_type = R_FRV_GOTTLSOFF12; 3229 howto = elf32_frv_howto_table + r_type; 3230 rel->r_info = ELF32_R_INFO (r_symndx, r_type); 3231 } 3232 3233 else if (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel)) 3234 { 3235 /* Replace ldd #tlsdesc(symbol+offset)@(grB, grA), grC 3236 with ld #tlsoff(symbol+offset)@(grB, grA), gr<C+1>. 3237 Preserve the packing bit. */ 3238 insn = (insn & (unsigned long)0x81ffffbf) 3239 | ((insn + (unsigned long)0x02000000) 3240 & (unsigned long)0x7e000000); 3241 bfd_put_32 (input_bfd, insn, contents + rel->r_offset); 3242 3243 /* #tlsoff(symbol+offset) is just a relaxation 3244 annotation, so there's nothing left to 3245 relocate. */ 3246 continue; 3247 } 3248 3249 break; 3250 3251 case R_FRV_GETTLSOFF_RELAX: 3252 insn = bfd_get_32 (input_bfd, contents + rel->r_offset); 3253 3254 /* Is this a calll or callil instruction? */ 3255 if ((insn & (unsigned long)0x7ff80fc0) != 0x02300000) 3256 { 3257 r = info->callbacks->warning 3258 (info, 3259 _("R_FRV_GETTLSOFF_RELAX" 3260 " not applied to a calll instruction"), 3261 name, input_bfd, input_section, rel->r_offset); 3262 return FALSE; 3263 } 3264 3265 if (RELAX_TLSDESC_LOCAL_EXEC_P (info, picrel, 3266 relocation + rel->r_addend) 3267 && TLSMOFF_IN_RANGE_FOR_SETLOS_P (relocation + rel->r_addend, 3268 info)) 3269 { 3270 /* Replace calll with a nop. Preserve the packing bit. */ 3271 insn &= (unsigned long)0x80000000; 3272 insn |= (unsigned long)0x00880000; 3273 bfd_put_32 (input_bfd, insn, contents + rel->r_offset); 3274 3275 /* Nothing to relocate. */ 3276 continue; 3277 } 3278 3279 else if (RELAX_TLSDESC_LOCAL_EXEC_P (info, picrel, 3280 relocation + rel->r_addend)) 3281 { 3282 /* Replace calll with setlo #tlsmofflo(symbol+offset), gr9. 3283 Preserve the packing bit. */ 3284 insn &= (unsigned long)0x80000000; 3285 insn |= (unsigned long)0x12f40000; 3286 bfd_put_32 (input_bfd, insn, contents + rel->r_offset); 3287 3288 r_type = R_FRV_TLSMOFFLO; 3289 howto = elf32_frv_howto_table + r_type; 3290 rel->r_info = ELF32_R_INFO (r_symndx, r_type); 3291 } 3292 3293 else if (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel)) 3294 { 3295 /* Replace calll with a nop. Preserve the packing bit. */ 3296 insn &= (unsigned long)0x80000000; 3297 insn |= (unsigned long)0x00880000; 3298 bfd_put_32 (input_bfd, insn, contents + rel->r_offset); 3299 3300 /* Nothing to relocate. */ 3301 continue; 3302 } 3303 3304 break; 3305 3306 case R_FRV_GOTTLSOFF12: 3307 insn = bfd_get_32 (input_bfd, contents + rel->r_offset); 3308 3309 /* Is this an ldi instruction? */ 3310 if ((insn & (unsigned long)0x01fc0000) != 0x00c80000) 3311 { 3312 r = info->callbacks->warning 3313 (info, 3314 _("R_FRV_GOTTLSOFF12 not applied to an ldi instruction"), 3315 name, input_bfd, input_section, rel->r_offset); 3316 return FALSE; 3317 } 3318 3319 if (RELAX_GOTTLSOFF_LOCAL_EXEC_P (info, picrel, 3320 relocation + rel->r_addend)) 3321 { 3322 /* Replace ldi @(grB, #gottlsoff12(symbol+offset), grC 3323 with setlos #tlsmofflo(symbol+offset), grC. 3324 Preserve the packing bit. */ 3325 insn &= (unsigned long)0xfe000000; 3326 insn |= (unsigned long)0x00fc0000; 3327 bfd_put_32 (input_bfd, insn, contents + rel->r_offset); 3328 3329 r_type = R_FRV_TLSMOFFLO; 3330 howto = elf32_frv_howto_table + r_type; 3331 rel->r_info = ELF32_R_INFO (r_symndx, r_type); 3332 } 3333 3334 break; 3335 3336 case R_FRV_GOTTLSOFFHI: 3337 insn = bfd_get_32 (input_bfd, contents + rel->r_offset); 3338 3339 /* Is this a sethi instruction? */ 3340 if ((insn & (unsigned long)0x01ff0000) != 0x00f80000) 3341 { 3342 r = info->callbacks->warning 3343 (info, 3344 _("R_FRV_GOTTLSOFFHI not applied to a sethi instruction"), 3345 name, input_bfd, input_section, rel->r_offset); 3346 return FALSE; 3347 } 3348 3349 if (RELAX_GOTTLSOFF_LOCAL_EXEC_P (info, picrel, 3350 relocation + rel->r_addend) 3351 || (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel) 3352 && IN_RANGE_FOR_OFST12_P (picrel->tlsoff_entry))) 3353 { 3354 /* Replace sethi with a nop. Preserve the packing bit. */ 3355 insn &= (unsigned long)0x80000000; 3356 insn |= (unsigned long)0x00880000; 3357 bfd_put_32 (input_bfd, insn, contents + rel->r_offset); 3358 3359 /* Nothing to relocate. */ 3360 continue; 3361 } 3362 3363 break; 3364 3365 case R_FRV_GOTTLSOFFLO: 3366 insn = bfd_get_32 (input_bfd, contents + rel->r_offset); 3367 3368 /* Is this a setlo or setlos instruction? */ 3369 if ((insn & (unsigned long)0x01f70000) != 0x00f40000) 3370 { 3371 r = info->callbacks->warning 3372 (info, 3373 _("R_FRV_GOTTLSOFFLO" 3374 " not applied to a setlo or setlos instruction"), 3375 name, input_bfd, input_section, rel->r_offset); 3376 return FALSE; 3377 } 3378 3379 if (RELAX_GOTTLSOFF_LOCAL_EXEC_P (info, picrel, 3380 relocation + rel->r_addend) 3381 || (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel) 3382 && IN_RANGE_FOR_OFST12_P (picrel->tlsoff_entry))) 3383 { 3384 /* Replace setlo/setlos with a nop. Preserve the 3385 packing bit. */ 3386 insn &= (unsigned long)0x80000000; 3387 insn |= (unsigned long)0x00880000; 3388 bfd_put_32 (input_bfd, insn, contents + rel->r_offset); 3389 3390 /* Nothing to relocate. */ 3391 continue; 3392 } 3393 3394 break; 3395 3396 case R_FRV_TLSOFF_RELAX: 3397 insn = bfd_get_32 (input_bfd, contents + rel->r_offset); 3398 3399 /* Is this an ld instruction? */ 3400 if ((insn & (unsigned long)0x01fc0fc0) != 0x00080100) 3401 { 3402 r = info->callbacks->warning 3403 (info, 3404 _("R_FRV_TLSOFF_RELAX not applied to an ld instruction"), 3405 name, input_bfd, input_section, rel->r_offset); 3406 return FALSE; 3407 } 3408 3409 if (RELAX_GOTTLSOFF_LOCAL_EXEC_P (info, picrel, 3410 relocation + rel->r_addend)) 3411 { 3412 /* Replace ld #gottlsoff(symbol+offset)@(grB, grA), grC 3413 with setlos #tlsmofflo(symbol+offset), grC. 3414 Preserve the packing bit. */ 3415 insn &= (unsigned long)0xfe000000; 3416 insn |= (unsigned long)0x00fc0000; 3417 bfd_put_32 (input_bfd, insn, contents + rel->r_offset); 3418 3419 r_type = R_FRV_TLSMOFFLO; 3420 howto = elf32_frv_howto_table + r_type; 3421 rel->r_info = ELF32_R_INFO (r_symndx, r_type); 3422 } 3423 3424 else if (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel) 3425 && IN_RANGE_FOR_OFST12_P (picrel->tlsoff_entry)) 3426 { 3427 /* Replace ld #tlsoff(symbol+offset)@(grB, grA), grC 3428 with ldi @(grB, #gottlsoff12(symbol+offset), grC. 3429 Preserve the packing bit. */ 3430 insn = (insn & (unsigned long)0xfe03f000) 3431 | (unsigned long)0x00c80000;; 3432 bfd_put_32 (input_bfd, insn, contents + rel->r_offset); 3433 3434 r_type = R_FRV_GOTTLSOFF12; 3435 howto = elf32_frv_howto_table + r_type; 3436 rel->r_info = ELF32_R_INFO (r_symndx, r_type); 3437 } 3438 3439 break; 3440 3441 case R_FRV_TLSMOFFHI: 3442 insn = bfd_get_32 (input_bfd, contents + rel->r_offset); 3443 3444 /* Is this a sethi instruction? */ 3445 if ((insn & (unsigned long)0x01ff0000) != 0x00f80000) 3446 { 3447 r = info->callbacks->warning 3448 (info, 3449 _("R_FRV_TLSMOFFHI not applied to a sethi instruction"), 3450 name, input_bfd, input_section, rel->r_offset); 3451 return FALSE; 3452 } 3453 3454 if (TLSMOFF_IN_RANGE_FOR_SETLOS_P (relocation + rel->r_addend, 3455 info)) 3456 { 3457 /* Replace sethi with a nop. Preserve the packing bit. */ 3458 insn &= (unsigned long)0x80000000; 3459 insn |= (unsigned long)0x00880000; 3460 bfd_put_32 (input_bfd, insn, contents + rel->r_offset); 3461 3462 /* Nothing to relocate. */ 3463 continue; 3464 } 3465 3466 break; 3467 3468 case R_FRV_TLSMOFFLO: 3469 insn = bfd_get_32 (input_bfd, contents + rel->r_offset); 3470 3471 /* Is this a setlo or setlos instruction? */ 3472 if ((insn & (unsigned long)0x01f70000) != 0x00f40000) 3473 { 3474 r = info->callbacks->warning 3475 (info, 3476 _("R_FRV_TLSMOFFLO" 3477 " not applied to a setlo or setlos instruction"), 3478 name, input_bfd, input_section, rel->r_offset); 3479 return FALSE; 3480 } 3481 3482 if (TLSMOFF_IN_RANGE_FOR_SETLOS_P (relocation + rel->r_addend, 3483 info)) 3484 /* If the corresponding sethi (if it exists) decayed 3485 to a nop, make sure this becomes (or already is) a 3486 setlos, not setlo. */ 3487 { 3488 insn |= (unsigned long)0x00080000; 3489 bfd_put_32 (input_bfd, insn, contents + rel->r_offset); 3490 } 3491 3492 break; 3493 3494 /* 3495 There's nothing to relax in these: 3496 R_FRV_TLSDESC_VALUE 3497 R_FRV_TLSOFF 3498 R_FRV_TLSMOFF12 3499 R_FRV_TLSMOFFHI 3500 R_FRV_TLSMOFFLO 3501 R_FRV_TLSMOFF 3502 */ 3503 3504 default: 3505 break; 3506 } 3507 3508 switch (r_type) 3509 { 3510 case R_FRV_LABEL24: 3511 check_segment[0] = isec_segment; 3512 if (! IS_FDPIC (output_bfd)) 3513 check_segment[1] = isec_segment; 3514 else if (picrel->plt) 3515 { 3516 relocation = frvfdpic_plt_section (info)->output_section->vma 3517 + frvfdpic_plt_section (info)->output_offset 3518 + picrel->plt_entry; 3519 check_segment[1] = plt_segment; 3520 } 3521 /* We don't want to warn on calls to undefined weak symbols, 3522 as calls to them must be protected by non-NULL tests 3523 anyway, and unprotected calls would invoke undefined 3524 behavior. */ 3525 else if (picrel->symndx == -1 3526 && picrel->d.h->root.type == bfd_link_hash_undefweak) 3527 check_segment[1] = check_segment[0]; 3528 else 3529 check_segment[1] = sec 3530 ? _frvfdpic_osec_to_segment (output_bfd, sec->output_section) 3531 : (unsigned)-1; 3532 break; 3533 3534 case R_FRV_GOT12: 3535 case R_FRV_GOTHI: 3536 case R_FRV_GOTLO: 3537 relocation = picrel->got_entry; 3538 check_segment[0] = check_segment[1] = got_segment; 3539 break; 3540 3541 case R_FRV_FUNCDESC_GOT12: 3542 case R_FRV_FUNCDESC_GOTHI: 3543 case R_FRV_FUNCDESC_GOTLO: 3544 relocation = picrel->fdgot_entry; 3545 check_segment[0] = check_segment[1] = got_segment; 3546 break; 3547 3548 case R_FRV_GOTOFFHI: 3549 case R_FRV_GOTOFF12: 3550 case R_FRV_GOTOFFLO: 3551 relocation -= frvfdpic_got_section (info)->output_section->vma 3552 + frvfdpic_got_section (info)->output_offset 3553 + frvfdpic_got_initial_offset (info); 3554 check_segment[0] = got_segment; 3555 check_segment[1] = sec 3556 ? _frvfdpic_osec_to_segment (output_bfd, sec->output_section) 3557 : (unsigned)-1; 3558 break; 3559 3560 case R_FRV_FUNCDESC_GOTOFF12: 3561 case R_FRV_FUNCDESC_GOTOFFHI: 3562 case R_FRV_FUNCDESC_GOTOFFLO: 3563 relocation = picrel->fd_entry; 3564 check_segment[0] = check_segment[1] = got_segment; 3565 break; 3566 3567 case R_FRV_FUNCDESC: 3568 { 3569 int dynindx; 3570 bfd_vma addend = rel->r_addend; 3571 3572 if (! (h && h->root.type == bfd_link_hash_undefweak 3573 && FRVFDPIC_SYM_LOCAL (info, h))) 3574 { 3575 /* If the symbol is dynamic and there may be dynamic 3576 symbol resolution because we are or are linked with a 3577 shared library, emit a FUNCDESC relocation such that 3578 the dynamic linker will allocate the function 3579 descriptor. If the symbol needs a non-local function 3580 descriptor but binds locally (e.g., its visibility is 3581 protected, emit a dynamic relocation decayed to 3582 section+offset. */ 3583 if (h && ! FRVFDPIC_FUNCDESC_LOCAL (info, h) 3584 && FRVFDPIC_SYM_LOCAL (info, h) 3585 && !(info->executable && !info->pie)) 3586 { 3587 dynindx = elf_section_data (h->root.u.def.section 3588 ->output_section)->dynindx; 3589 addend += h->root.u.def.section->output_offset 3590 + h->root.u.def.value; 3591 } 3592 else if (h && ! FRVFDPIC_FUNCDESC_LOCAL (info, h)) 3593 { 3594 if (addend) 3595 { 3596 info->callbacks->warning 3597 (info, _("R_FRV_FUNCDESC references dynamic symbol with nonzero addend"), 3598 name, input_bfd, input_section, rel->r_offset); 3599 return FALSE; 3600 } 3601 dynindx = h->dynindx; 3602 } 3603 else 3604 { 3605 /* Otherwise, we know we have a private function 3606 descriptor, so reference it directly. */ 3607 BFD_ASSERT (picrel->privfd); 3608 r_type = R_FRV_32; 3609 dynindx = elf_section_data (frvfdpic_got_section (info) 3610 ->output_section)->dynindx; 3611 addend = frvfdpic_got_section (info)->output_offset 3612 + frvfdpic_got_initial_offset (info) 3613 + picrel->fd_entry; 3614 } 3615 3616 /* If there is room for dynamic symbol resolution, emit 3617 the dynamic relocation. However, if we're linking an 3618 executable at a fixed location, we won't have emitted a 3619 dynamic symbol entry for the got section, so idx will 3620 be zero, which means we can and should compute the 3621 address of the private descriptor ourselves. */ 3622 if (info->executable && !info->pie 3623 && (!h || FRVFDPIC_FUNCDESC_LOCAL (info, h))) 3624 { 3625 addend += frvfdpic_got_section (info)->output_section->vma; 3626 if ((bfd_get_section_flags (output_bfd, 3627 input_section->output_section) 3628 & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD)) 3629 { 3630 bfd_vma offset; 3631 3632 if (_frvfdpic_osec_readonly_p (output_bfd, 3633 input_section 3634 ->output_section)) 3635 { 3636 info->callbacks->warning 3637 (info, 3638 _("cannot emit fixups in read-only section"), 3639 name, input_bfd, input_section, rel->r_offset); 3640 return FALSE; 3641 } 3642 3643 offset = _bfd_elf_section_offset 3644 (output_bfd, info, 3645 input_section, rel->r_offset); 3646 3647 if (offset != (bfd_vma)-1) 3648 _frvfdpic_add_rofixup (output_bfd, 3649 frvfdpic_gotfixup_section 3650 (info), 3651 offset + input_section 3652 ->output_section->vma 3653 + input_section->output_offset, 3654 picrel); 3655 } 3656 } 3657 else if ((bfd_get_section_flags (output_bfd, 3658 input_section->output_section) 3659 & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD)) 3660 { 3661 bfd_vma offset; 3662 3663 if (_frvfdpic_osec_readonly_p (output_bfd, 3664 input_section 3665 ->output_section)) 3666 { 3667 info->callbacks->warning 3668 (info, 3669 _("cannot emit dynamic relocations in read-only section"), 3670 name, input_bfd, input_section, rel->r_offset); 3671 return FALSE; 3672 } 3673 3674 offset = _bfd_elf_section_offset 3675 (output_bfd, info, 3676 input_section, rel->r_offset); 3677 3678 if (offset != (bfd_vma)-1) 3679 _frvfdpic_add_dyn_reloc (output_bfd, 3680 frvfdpic_gotrel_section (info), 3681 offset + input_section 3682 ->output_section->vma 3683 + input_section->output_offset, 3684 r_type, dynindx, addend, picrel); 3685 } 3686 else 3687 addend += frvfdpic_got_section (info)->output_section->vma; 3688 } 3689 3690 /* We want the addend in-place because dynamic 3691 relocations are REL. Setting relocation to it should 3692 arrange for it to be installed. */ 3693 relocation = addend - rel->r_addend; 3694 } 3695 check_segment[0] = check_segment[1] = got_segment; 3696 break; 3697 3698 case R_FRV_32: 3699 if (! IS_FDPIC (output_bfd)) 3700 { 3701 check_segment[0] = check_segment[1] = -1; 3702 break; 3703 } 3704 /* Fall through. */ 3705 case R_FRV_FUNCDESC_VALUE: 3706 { 3707 int dynindx; 3708 bfd_vma addend = rel->r_addend; 3709 3710 /* If the symbol is dynamic but binds locally, use 3711 section+offset. */ 3712 if (h && ! FRVFDPIC_SYM_LOCAL (info, h)) 3713 { 3714 if (addend && r_type == R_FRV_FUNCDESC_VALUE) 3715 { 3716 info->callbacks->warning 3717 (info, _("R_FRV_FUNCDESC_VALUE references dynamic symbol with nonzero addend"), 3718 name, input_bfd, input_section, rel->r_offset); 3719 return FALSE; 3720 } 3721 dynindx = h->dynindx; 3722 } 3723 else 3724 { 3725 if (h) 3726 addend += h->root.u.def.value; 3727 else 3728 addend += sym->st_value; 3729 if (osec) 3730 addend += osec->output_offset; 3731 if (osec && osec->output_section 3732 && ! bfd_is_abs_section (osec->output_section) 3733 && ! bfd_is_und_section (osec->output_section)) 3734 dynindx = elf_section_data (osec->output_section)->dynindx; 3735 else 3736 dynindx = 0; 3737 } 3738 3739 /* If we're linking an executable at a fixed address, we 3740 can omit the dynamic relocation as long as the symbol 3741 is defined in the current link unit (which is implied 3742 by its output section not being NULL). */ 3743 if (info->executable && !info->pie 3744 && (!h || FRVFDPIC_SYM_LOCAL (info, h))) 3745 { 3746 if (osec) 3747 addend += osec->output_section->vma; 3748 if (IS_FDPIC (input_bfd) 3749 && (bfd_get_section_flags (output_bfd, 3750 input_section->output_section) 3751 & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD)) 3752 { 3753 if (_frvfdpic_osec_readonly_p (output_bfd, 3754 input_section 3755 ->output_section)) 3756 { 3757 info->callbacks->warning 3758 (info, 3759 _("cannot emit fixups in read-only section"), 3760 name, input_bfd, input_section, rel->r_offset); 3761 return FALSE; 3762 } 3763 if (!h || h->root.type != bfd_link_hash_undefweak) 3764 { 3765 bfd_vma offset = _bfd_elf_section_offset 3766 (output_bfd, info, 3767 input_section, rel->r_offset); 3768 3769 if (offset != (bfd_vma)-1) 3770 { 3771 _frvfdpic_add_rofixup (output_bfd, 3772 frvfdpic_gotfixup_section 3773 (info), 3774 offset + input_section 3775 ->output_section->vma 3776 + input_section->output_offset, 3777 picrel); 3778 if (r_type == R_FRV_FUNCDESC_VALUE) 3779 _frvfdpic_add_rofixup 3780 (output_bfd, 3781 frvfdpic_gotfixup_section (info), 3782 offset 3783 + input_section->output_section->vma 3784 + input_section->output_offset + 4, picrel); 3785 } 3786 } 3787 } 3788 } 3789 else 3790 { 3791 if ((bfd_get_section_flags (output_bfd, 3792 input_section->output_section) 3793 & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD)) 3794 { 3795 bfd_vma offset; 3796 3797 if (_frvfdpic_osec_readonly_p (output_bfd, 3798 input_section 3799 ->output_section)) 3800 { 3801 info->callbacks->warning 3802 (info, 3803 _("cannot emit dynamic relocations in read-only section"), 3804 name, input_bfd, input_section, rel->r_offset); 3805 return FALSE; 3806 } 3807 3808 offset = _bfd_elf_section_offset 3809 (output_bfd, info, 3810 input_section, rel->r_offset); 3811 3812 if (offset != (bfd_vma)-1) 3813 _frvfdpic_add_dyn_reloc (output_bfd, 3814 frvfdpic_gotrel_section (info), 3815 offset + input_section 3816 ->output_section->vma 3817 + input_section->output_offset, 3818 r_type, dynindx, addend, picrel); 3819 } 3820 else if (osec) 3821 addend += osec->output_section->vma; 3822 /* We want the addend in-place because dynamic 3823 relocations are REL. Setting relocation to it 3824 should arrange for it to be installed. */ 3825 relocation = addend - rel->r_addend; 3826 } 3827 3828 if (r_type == R_FRV_FUNCDESC_VALUE) 3829 { 3830 /* If we've omitted the dynamic relocation, just emit 3831 the fixed addresses of the symbol and of the local 3832 GOT base offset. */ 3833 if (info->executable && !info->pie 3834 && (!h || FRVFDPIC_SYM_LOCAL (info, h))) 3835 bfd_put_32 (output_bfd, 3836 frvfdpic_got_section (info)->output_section->vma 3837 + frvfdpic_got_section (info)->output_offset 3838 + frvfdpic_got_initial_offset (info), 3839 contents + rel->r_offset + 4); 3840 else 3841 /* A function descriptor used for lazy or local 3842 resolving is initialized such that its high word 3843 contains the output section index in which the 3844 PLT entries are located, and the low word 3845 contains the offset of the lazy PLT entry entry 3846 point into that section. */ 3847 bfd_put_32 (output_bfd, 3848 h && ! FRVFDPIC_SYM_LOCAL (info, h) 3849 ? 0 3850 : _frvfdpic_osec_to_segment (output_bfd, 3851 sec 3852 ->output_section), 3853 contents + rel->r_offset + 4); 3854 } 3855 } 3856 check_segment[0] = check_segment[1] = got_segment; 3857 break; 3858 3859 case R_FRV_GPREL12: 3860 case R_FRV_GPRELU12: 3861 case R_FRV_GPREL32: 3862 case R_FRV_GPRELHI: 3863 case R_FRV_GPRELLO: 3864 check_segment[0] = gprel_segment; 3865 check_segment[1] = sec 3866 ? _frvfdpic_osec_to_segment (output_bfd, sec->output_section) 3867 : (unsigned)-1; 3868 break; 3869 3870 case R_FRV_GETTLSOFF: 3871 relocation = frvfdpic_plt_section (info)->output_section->vma 3872 + frvfdpic_plt_section (info)->output_offset 3873 + picrel->tlsplt_entry; 3874 BFD_ASSERT (picrel->tlsplt_entry != (bfd_vma)-1 3875 && picrel->tlsdesc_entry); 3876 check_segment[0] = isec_segment; 3877 check_segment[1] = plt_segment; 3878 break; 3879 3880 case R_FRV_GOTTLSDESC12: 3881 case R_FRV_GOTTLSDESCHI: 3882 case R_FRV_GOTTLSDESCLO: 3883 BFD_ASSERT (picrel->tlsdesc_entry); 3884 relocation = picrel->tlsdesc_entry; 3885 check_segment[0] = tls_segment; 3886 check_segment[1] = sec 3887 && ! bfd_is_abs_section (sec) 3888 && ! bfd_is_und_section (sec) 3889 ? _frvfdpic_osec_to_segment (output_bfd, sec->output_section) 3890 : tls_segment; 3891 break; 3892 3893 case R_FRV_TLSMOFF12: 3894 case R_FRV_TLSMOFFHI: 3895 case R_FRV_TLSMOFFLO: 3896 case R_FRV_TLSMOFF: 3897 check_segment[0] = tls_segment; 3898 if (! sec) 3899 check_segment[1] = -1; 3900 else if (bfd_is_abs_section (sec) 3901 || bfd_is_und_section (sec)) 3902 { 3903 relocation = 0; 3904 check_segment[1] = tls_segment; 3905 } 3906 else if (sec->output_section) 3907 { 3908 relocation -= tls_biased_base (info); 3909 check_segment[1] = 3910 _frvfdpic_osec_to_segment (output_bfd, sec->output_section); 3911 } 3912 else 3913 check_segment[1] = -1; 3914 break; 3915 3916 case R_FRV_GOTTLSOFF12: 3917 case R_FRV_GOTTLSOFFHI: 3918 case R_FRV_GOTTLSOFFLO: 3919 BFD_ASSERT (picrel->tlsoff_entry); 3920 relocation = picrel->tlsoff_entry; 3921 check_segment[0] = tls_segment; 3922 check_segment[1] = sec 3923 && ! bfd_is_abs_section (sec) 3924 && ! bfd_is_und_section (sec) 3925 ? _frvfdpic_osec_to_segment (output_bfd, sec->output_section) 3926 : tls_segment; 3927 break; 3928 3929 case R_FRV_TLSDESC_VALUE: 3930 case R_FRV_TLSOFF: 3931 /* These shouldn't be present in input object files. */ 3932 check_segment[0] = check_segment[1] = isec_segment; 3933 break; 3934 3935 case R_FRV_TLSDESC_RELAX: 3936 case R_FRV_GETTLSOFF_RELAX: 3937 case R_FRV_TLSOFF_RELAX: 3938 /* These are just annotations for relaxation, nothing to do 3939 here. */ 3940 continue; 3941 3942 default: 3943 check_segment[0] = isec_segment; 3944 check_segment[1] = sec 3945 ? _frvfdpic_osec_to_segment (output_bfd, sec->output_section) 3946 : (unsigned)-1; 3947 break; 3948 } 3949 3950 if (check_segment[0] != check_segment[1] && IS_FDPIC (output_bfd)) 3951 { 3952 /* If you take this out, remove the #error from fdpic-static-6.d 3953 in the ld testsuite. */ 3954 /* This helps catch problems in GCC while we can't do more 3955 than static linking. The idea is to test whether the 3956 input file basename is crt0.o only once. */ 3957 if (silence_segment_error == 1) 3958 silence_segment_error = 3959 (strlen (input_bfd->filename) == 6 3960 && strcmp (input_bfd->filename, "crt0.o") == 0) 3961 || (strlen (input_bfd->filename) > 6 3962 && strcmp (input_bfd->filename 3963 + strlen (input_bfd->filename) - 7, 3964 "/crt0.o") == 0) 3965 ? -1 : 0; 3966 if (!silence_segment_error 3967 /* We don't want duplicate errors for undefined 3968 symbols. */ 3969 && !(picrel && picrel->symndx == -1 3970 && picrel->d.h->root.type == bfd_link_hash_undefined)) 3971 { 3972 if (info->shared || info->pie) 3973 (*_bfd_error_handler) 3974 (_("%B(%A+0x%lx): reloc against `%s': %s"), 3975 input_bfd, input_section, (long)rel->r_offset, name, 3976 _("relocation references a different segment")); 3977 else 3978 info->callbacks->warning 3979 (info, 3980 _("relocation references a different segment"), 3981 name, input_bfd, input_section, rel->r_offset); 3982 } 3983 if (!silence_segment_error && (info->shared || info->pie)) 3984 return FALSE; 3985 elf_elfheader (output_bfd)->e_flags |= EF_FRV_PIC; 3986 } 3987 3988 switch (r_type) 3989 { 3990 case R_FRV_GOTOFFHI: 3991 case R_FRV_TLSMOFFHI: 3992 /* We need the addend to be applied before we shift the 3993 value right. */ 3994 relocation += rel->r_addend; 3995 /* Fall through. */ 3996 case R_FRV_GOTHI: 3997 case R_FRV_FUNCDESC_GOTHI: 3998 case R_FRV_FUNCDESC_GOTOFFHI: 3999 case R_FRV_GOTTLSOFFHI: 4000 case R_FRV_GOTTLSDESCHI: 4001 relocation >>= 16; 4002 /* Fall through. */ 4003 4004 case R_FRV_GOTLO: 4005 case R_FRV_FUNCDESC_GOTLO: 4006 case R_FRV_GOTOFFLO: 4007 case R_FRV_FUNCDESC_GOTOFFLO: 4008 case R_FRV_GOTTLSOFFLO: 4009 case R_FRV_GOTTLSDESCLO: 4010 case R_FRV_TLSMOFFLO: 4011 relocation &= 0xffff; 4012 break; 4013 4014 default: 4015 break; 4016 } 4017 4018 switch (r_type) 4019 { 4020 case R_FRV_LABEL24: 4021 if (! IS_FDPIC (output_bfd) || ! picrel->plt) 4022 break; 4023 /* Fall through. */ 4024 4025 /* When referencing a GOT entry, a function descriptor or a 4026 PLT, we don't want the addend to apply to the reference, 4027 but rather to the referenced symbol. The actual entry 4028 will have already been created taking the addend into 4029 account, so cancel it out here. */ 4030 case R_FRV_GOT12: 4031 case R_FRV_GOTHI: 4032 case R_FRV_GOTLO: 4033 case R_FRV_FUNCDESC_GOT12: 4034 case R_FRV_FUNCDESC_GOTHI: 4035 case R_FRV_FUNCDESC_GOTLO: 4036 case R_FRV_FUNCDESC_GOTOFF12: 4037 case R_FRV_FUNCDESC_GOTOFFHI: 4038 case R_FRV_FUNCDESC_GOTOFFLO: 4039 case R_FRV_GETTLSOFF: 4040 case R_FRV_GOTTLSDESC12: 4041 case R_FRV_GOTTLSDESCHI: 4042 case R_FRV_GOTTLSDESCLO: 4043 case R_FRV_GOTTLSOFF12: 4044 case R_FRV_GOTTLSOFFHI: 4045 case R_FRV_GOTTLSOFFLO: 4046 /* Note that we only want GOTOFFHI, not GOTOFFLO or GOTOFF12 4047 here, since we do want to apply the addend to the others. 4048 Note that we've applied the addend to GOTOFFHI before we 4049 shifted it right. */ 4050 case R_FRV_GOTOFFHI: 4051 case R_FRV_TLSMOFFHI: 4052 relocation -= rel->r_addend; 4053 break; 4054 4055 default: 4056 break; 4057 } 4058 4059 if (r_type == R_FRV_HI16) 4060 r = elf32_frv_relocate_hi16 (input_bfd, rel, contents, relocation); 4061 4062 else if (r_type == R_FRV_LO16) 4063 r = elf32_frv_relocate_lo16 (input_bfd, rel, contents, relocation); 4064 4065 else if (r_type == R_FRV_LABEL24 || r_type == R_FRV_GETTLSOFF) 4066 r = elf32_frv_relocate_label24 (input_bfd, input_section, rel, 4067 contents, relocation); 4068 4069 else if (r_type == R_FRV_GPREL12) 4070 r = elf32_frv_relocate_gprel12 (info, input_bfd, input_section, rel, 4071 contents, relocation); 4072 4073 else if (r_type == R_FRV_GPRELU12) 4074 r = elf32_frv_relocate_gprelu12 (info, input_bfd, input_section, rel, 4075 contents, relocation); 4076 4077 else if (r_type == R_FRV_GPRELLO) 4078 r = elf32_frv_relocate_gprello (info, input_bfd, input_section, rel, 4079 contents, relocation); 4080 4081 else if (r_type == R_FRV_GPRELHI) 4082 r = elf32_frv_relocate_gprelhi (info, input_bfd, input_section, rel, 4083 contents, relocation); 4084 4085 else if (r_type == R_FRV_TLSOFF 4086 || r_type == R_FRV_TLSDESC_VALUE) 4087 r = bfd_reloc_notsupported; 4088 4089 else 4090 r = frv_final_link_relocate (howto, input_bfd, input_section, contents, 4091 rel, relocation); 4092 4093 if (r != bfd_reloc_ok) 4094 { 4095 const char * msg = (const char *) NULL; 4096 4097 switch (r) 4098 { 4099 case bfd_reloc_overflow: 4100 r = info->callbacks->reloc_overflow 4101 (info, (h ? &h->root : NULL), name, howto->name, 4102 (bfd_vma) 0, input_bfd, input_section, rel->r_offset); 4103 break; 4104 4105 case bfd_reloc_undefined: 4106 r = info->callbacks->undefined_symbol 4107 (info, name, input_bfd, input_section, rel->r_offset, TRUE); 4108 break; 4109 4110 case bfd_reloc_outofrange: 4111 msg = _("internal error: out of range error"); 4112 break; 4113 4114 case bfd_reloc_notsupported: 4115 msg = _("internal error: unsupported relocation error"); 4116 break; 4117 4118 case bfd_reloc_dangerous: 4119 msg = _("internal error: dangerous relocation"); 4120 break; 4121 4122 default: 4123 msg = _("internal error: unknown error"); 4124 break; 4125 } 4126 4127 if (msg) 4128 { 4129 (*_bfd_error_handler) 4130 (_("%B(%A+0x%lx): reloc against `%s': %s"), 4131 input_bfd, input_section, (long)rel->r_offset, name, msg); 4132 return FALSE; 4133 } 4134 4135 if (! r) 4136 return FALSE; 4137 } 4138 } 4139 4140 return TRUE; 4141 } 4142 4143 /* Return the section that should be marked against GC for a given 4144 relocation. */ 4145 4146 static asection * 4147 elf32_frv_gc_mark_hook (asection *sec, 4148 struct bfd_link_info *info, 4149 Elf_Internal_Rela *rel, 4150 struct elf_link_hash_entry *h, 4151 Elf_Internal_Sym *sym) 4152 { 4153 if (h != NULL) 4154 switch (ELF32_R_TYPE (rel->r_info)) 4155 { 4156 case R_FRV_GNU_VTINHERIT: 4157 case R_FRV_GNU_VTENTRY: 4158 return NULL; 4159 } 4160 4161 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym); 4162 } 4163 4164 /* Hook called by the linker routine which adds symbols from an object 4165 file. We use it to put .comm items in .scomm, and not .comm. */ 4166 4167 static bfd_boolean 4168 elf32_frv_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp) 4169 bfd *abfd; 4170 struct bfd_link_info *info; 4171 Elf_Internal_Sym *sym; 4172 const char **namep ATTRIBUTE_UNUSED; 4173 flagword *flagsp ATTRIBUTE_UNUSED; 4174 asection **secp; 4175 bfd_vma *valp; 4176 { 4177 if (sym->st_shndx == SHN_COMMON 4178 && !info->relocatable 4179 && (int)sym->st_size <= (int)bfd_get_gp_size (abfd)) 4180 { 4181 /* Common symbols less than or equal to -G nn bytes are 4182 automatically put into .sbss. */ 4183 4184 asection *scomm = bfd_get_section_by_name (abfd, ".scommon"); 4185 4186 if (scomm == NULL) 4187 { 4188 scomm = bfd_make_section_with_flags (abfd, ".scommon", 4189 (SEC_ALLOC 4190 | SEC_IS_COMMON 4191 | SEC_LINKER_CREATED)); 4192 if (scomm == NULL) 4193 return FALSE; 4194 } 4195 4196 *secp = scomm; 4197 *valp = sym->st_size; 4198 } 4199 4200 return TRUE; 4201 } 4202 4203 /* We need dynamic symbols for every section, since segments can 4204 relocate independently. */ 4205 static bfd_boolean 4206 _frvfdpic_link_omit_section_dynsym (bfd *output_bfd ATTRIBUTE_UNUSED, 4207 struct bfd_link_info *info 4208 ATTRIBUTE_UNUSED, 4209 asection *p ATTRIBUTE_UNUSED) 4210 { 4211 switch (elf_section_data (p)->this_hdr.sh_type) 4212 { 4213 case SHT_PROGBITS: 4214 case SHT_NOBITS: 4215 /* If sh_type is yet undecided, assume it could be 4216 SHT_PROGBITS/SHT_NOBITS. */ 4217 case SHT_NULL: 4218 return FALSE; 4219 4220 /* There shouldn't be section relative relocations 4221 against any other section. */ 4222 default: 4223 return TRUE; 4224 } 4225 } 4226 4227 /* Create a .got section, as well as its additional info field. This 4228 is almost entirely copied from 4229 elflink.c:_bfd_elf_create_got_section(). */ 4230 4231 static bfd_boolean 4232 _frv_create_got_section (bfd *abfd, struct bfd_link_info *info) 4233 { 4234 flagword flags, pltflags; 4235 asection *s; 4236 struct elf_link_hash_entry *h; 4237 struct bfd_link_hash_entry *bh; 4238 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 4239 int ptralign; 4240 int offset; 4241 4242 /* This function may be called more than once. */ 4243 s = bfd_get_section_by_name (abfd, ".got"); 4244 if (s != NULL && (s->flags & SEC_LINKER_CREATED) != 0) 4245 return TRUE; 4246 4247 /* Machine specific: although pointers are 32-bits wide, we want the 4248 GOT to be aligned to a 64-bit boundary, such that function 4249 descriptors in it can be accessed with 64-bit loads and 4250 stores. */ 4251 ptralign = 3; 4252 4253 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY 4254 | SEC_LINKER_CREATED); 4255 pltflags = flags; 4256 4257 s = bfd_make_section_with_flags (abfd, ".got", flags); 4258 if (s == NULL 4259 || !bfd_set_section_alignment (abfd, s, ptralign)) 4260 return FALSE; 4261 4262 if (bed->want_got_plt) 4263 { 4264 s = bfd_make_section_with_flags (abfd, ".got.plt", flags); 4265 if (s == NULL 4266 || !bfd_set_section_alignment (abfd, s, ptralign)) 4267 return FALSE; 4268 } 4269 4270 if (bed->want_got_sym) 4271 { 4272 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got 4273 (or .got.plt) section. We don't do this in the linker script 4274 because we don't want to define the symbol if we are not creating 4275 a global offset table. */ 4276 h = _bfd_elf_define_linkage_sym (abfd, info, s, "_GLOBAL_OFFSET_TABLE_"); 4277 elf_hash_table (info)->hgot = h; 4278 if (h == NULL) 4279 return FALSE; 4280 4281 /* Machine-specific: we want the symbol for executables as 4282 well. */ 4283 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 4284 return FALSE; 4285 } 4286 4287 /* The first bit of the global offset table is the header. */ 4288 s->size += bed->got_header_size; 4289 4290 /* This is the machine-specific part. Create and initialize section 4291 data for the got. */ 4292 if (IS_FDPIC (abfd)) 4293 { 4294 frvfdpic_got_section (info) = s; 4295 frvfdpic_relocs_info (info) = htab_try_create (1, 4296 frvfdpic_relocs_info_hash, 4297 frvfdpic_relocs_info_eq, 4298 (htab_del) NULL); 4299 if (! frvfdpic_relocs_info (info)) 4300 return FALSE; 4301 4302 s = bfd_make_section_with_flags (abfd, ".rel.got", 4303 (flags | SEC_READONLY)); 4304 if (s == NULL 4305 || ! bfd_set_section_alignment (abfd, s, 2)) 4306 return FALSE; 4307 4308 frvfdpic_gotrel_section (info) = s; 4309 4310 /* Machine-specific. */ 4311 s = bfd_make_section_with_flags (abfd, ".rofixup", 4312 (flags | SEC_READONLY)); 4313 if (s == NULL 4314 || ! bfd_set_section_alignment (abfd, s, 2)) 4315 return FALSE; 4316 4317 frvfdpic_gotfixup_section (info) = s; 4318 offset = -2048; 4319 flags = BSF_GLOBAL; 4320 } 4321 else 4322 { 4323 offset = 2048; 4324 flags = BSF_GLOBAL | BSF_WEAK; 4325 } 4326 4327 /* Define _gp in .rofixup, for FDPIC, or .got otherwise. If it 4328 turns out that we're linking with a different linker script, the 4329 linker script will override it. */ 4330 bh = NULL; 4331 if (!(_bfd_generic_link_add_one_symbol 4332 (info, abfd, "_gp", flags, s, offset, (const char *) NULL, FALSE, 4333 bed->collect, &bh))) 4334 return FALSE; 4335 h = (struct elf_link_hash_entry *) bh; 4336 h->def_regular = 1; 4337 h->type = STT_OBJECT; 4338 /* h->other = STV_HIDDEN; */ /* Should we? */ 4339 4340 /* Machine-specific: we want the symbol for executables as well. */ 4341 if (IS_FDPIC (abfd) && ! bfd_elf_link_record_dynamic_symbol (info, h)) 4342 return FALSE; 4343 4344 if (!IS_FDPIC (abfd)) 4345 return TRUE; 4346 4347 /* FDPIC supports Thread Local Storage, and this may require a 4348 procedure linkage table for TLS PLT entries. */ 4349 4350 /* This is mostly copied from 4351 elflink.c:_bfd_elf_create_dynamic_sections(). */ 4352 4353 flags = pltflags; 4354 pltflags |= SEC_CODE; 4355 if (bed->plt_not_loaded) 4356 pltflags &= ~ (SEC_CODE | SEC_LOAD | SEC_HAS_CONTENTS); 4357 if (bed->plt_readonly) 4358 pltflags |= SEC_READONLY; 4359 4360 s = bfd_make_section_with_flags (abfd, ".plt", pltflags); 4361 if (s == NULL 4362 || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment)) 4363 return FALSE; 4364 /* FRV-specific: remember it. */ 4365 frvfdpic_plt_section (info) = s; 4366 4367 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the 4368 .plt section. */ 4369 if (bed->want_plt_sym) 4370 { 4371 h = _bfd_elf_define_linkage_sym (abfd, info, s, 4372 "_PROCEDURE_LINKAGE_TABLE_"); 4373 elf_hash_table (info)->hplt = h; 4374 if (h == NULL) 4375 return FALSE; 4376 } 4377 4378 /* FRV-specific: we want rel relocations for the plt. */ 4379 s = bfd_make_section_with_flags (abfd, ".rel.plt", 4380 flags | SEC_READONLY); 4381 if (s == NULL 4382 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align)) 4383 return FALSE; 4384 /* FRV-specific: remember it. */ 4385 frvfdpic_pltrel_section (info) = s; 4386 4387 return TRUE; 4388 } 4389 4390 /* Make sure the got and plt sections exist, and that our pointers in 4391 the link hash table point to them. */ 4392 4393 static bfd_boolean 4394 elf32_frvfdpic_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info) 4395 { 4396 /* This is mostly copied from 4397 elflink.c:_bfd_elf_create_dynamic_sections(). */ 4398 flagword flags; 4399 asection *s; 4400 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 4401 4402 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY 4403 | SEC_LINKER_CREATED); 4404 4405 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and 4406 .rel[a].bss sections. */ 4407 4408 /* FRV-specific: we want to create the GOT and the PLT in the FRV 4409 way. */ 4410 if (! _frv_create_got_section (abfd, info)) 4411 return FALSE; 4412 4413 /* FRV-specific: make sure we created everything we wanted. */ 4414 BFD_ASSERT (frvfdpic_got_section (info) && frvfdpic_gotrel_section (info) 4415 && frvfdpic_gotfixup_section (info) 4416 && frvfdpic_plt_section (info) 4417 && frvfdpic_pltrel_section (info)); 4418 4419 if (bed->want_dynbss) 4420 { 4421 /* The .dynbss section is a place to put symbols which are defined 4422 by dynamic objects, are referenced by regular objects, and are 4423 not functions. We must allocate space for them in the process 4424 image and use a R_*_COPY reloc to tell the dynamic linker to 4425 initialize them at run time. The linker script puts the .dynbss 4426 section into the .bss section of the final image. */ 4427 s = bfd_make_section_with_flags (abfd, ".dynbss", 4428 SEC_ALLOC | SEC_LINKER_CREATED); 4429 if (s == NULL) 4430 return FALSE; 4431 4432 /* The .rel[a].bss section holds copy relocs. This section is not 4433 normally needed. We need to create it here, though, so that the 4434 linker will map it to an output section. We can't just create it 4435 only if we need it, because we will not know whether we need it 4436 until we have seen all the input files, and the first time the 4437 main linker code calls BFD after examining all the input files 4438 (size_dynamic_sections) the input sections have already been 4439 mapped to the output sections. If the section turns out not to 4440 be needed, we can discard it later. We will never need this 4441 section when generating a shared object, since they do not use 4442 copy relocs. */ 4443 if (! info->shared) 4444 { 4445 s = bfd_make_section_with_flags (abfd, 4446 (bed->default_use_rela_p 4447 ? ".rela.bss" : ".rel.bss"), 4448 flags | SEC_READONLY); 4449 if (s == NULL 4450 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align)) 4451 return FALSE; 4452 } 4453 } 4454 4455 return TRUE; 4456 } 4457 4458 /* Compute the total GOT and PLT size required by each symbol in each 4459 range. Symbols may require up to 4 words in the GOT: an entry 4460 pointing to the symbol, an entry pointing to its function 4461 descriptor, and a private function descriptors taking two 4462 words. */ 4463 4464 static void 4465 _frvfdpic_count_nontls_entries (struct frvfdpic_relocs_info *entry, 4466 struct _frvfdpic_dynamic_got_info *dinfo) 4467 { 4468 /* Allocate space for a GOT entry pointing to the symbol. */ 4469 if (entry->got12) 4470 dinfo->got12 += 4; 4471 else if (entry->gotlos) 4472 dinfo->gotlos += 4; 4473 else if (entry->gothilo) 4474 dinfo->gothilo += 4; 4475 else 4476 entry->relocs32--; 4477 entry->relocs32++; 4478 4479 /* Allocate space for a GOT entry pointing to the function 4480 descriptor. */ 4481 if (entry->fdgot12) 4482 dinfo->got12 += 4; 4483 else if (entry->fdgotlos) 4484 dinfo->gotlos += 4; 4485 else if (entry->fdgothilo) 4486 dinfo->gothilo += 4; 4487 else 4488 entry->relocsfd--; 4489 entry->relocsfd++; 4490 4491 /* Decide whether we need a PLT entry, a function descriptor in the 4492 GOT, and a lazy PLT entry for this symbol. */ 4493 entry->plt = entry->call 4494 && entry->symndx == -1 && ! FRVFDPIC_SYM_LOCAL (dinfo->info, entry->d.h) 4495 && elf_hash_table (dinfo->info)->dynamic_sections_created; 4496 entry->privfd = entry->plt 4497 || entry->fdgoff12 || entry->fdgofflos || entry->fdgoffhilo 4498 || ((entry->fd || entry->fdgot12 || entry->fdgotlos || entry->fdgothilo) 4499 && (entry->symndx != -1 4500 || FRVFDPIC_FUNCDESC_LOCAL (dinfo->info, entry->d.h))); 4501 entry->lazyplt = entry->privfd 4502 && entry->symndx == -1 && ! FRVFDPIC_SYM_LOCAL (dinfo->info, entry->d.h) 4503 && ! (dinfo->info->flags & DF_BIND_NOW) 4504 && elf_hash_table (dinfo->info)->dynamic_sections_created; 4505 4506 /* Allocate space for a function descriptor. */ 4507 if (entry->fdgoff12) 4508 dinfo->fd12 += 8; 4509 else if (entry->fdgofflos) 4510 dinfo->fdlos += 8; 4511 else if (entry->privfd && entry->plt) 4512 dinfo->fdplt += 8; 4513 else if (entry->privfd) 4514 dinfo->fdhilo += 8; 4515 else 4516 entry->relocsfdv--; 4517 entry->relocsfdv++; 4518 4519 if (entry->lazyplt) 4520 dinfo->lzplt += 8; 4521 } 4522 4523 /* Compute the total GOT size required by each TLS symbol in each 4524 range. Symbols may require up to 5 words in the GOT: an entry 4525 holding the TLS offset for the symbol, and an entry with a full TLS 4526 descriptor taking 4 words. */ 4527 4528 static void 4529 _frvfdpic_count_tls_entries (struct frvfdpic_relocs_info *entry, 4530 struct _frvfdpic_dynamic_got_info *dinfo, 4531 bfd_boolean subtract) 4532 { 4533 const int l = subtract ? -1 : 1; 4534 4535 /* Allocate space for a GOT entry with the TLS offset of the 4536 symbol. */ 4537 if (entry->tlsoff12) 4538 dinfo->got12 += 4 * l; 4539 else if (entry->tlsofflos) 4540 dinfo->gotlos += 4 * l; 4541 else if (entry->tlsoffhilo) 4542 dinfo->gothilo += 4 * l; 4543 else 4544 entry->relocstlsoff -= l; 4545 entry->relocstlsoff += l; 4546 4547 /* If there's any TLSOFF relocation, mark the output file as not 4548 suitable for dlopening. This mark will remain even if we relax 4549 all such relocations, but this is not a problem, since we'll only 4550 do so for executables, and we definitely don't want anyone 4551 dlopening executables. */ 4552 if (entry->relocstlsoff) 4553 dinfo->info->flags |= DF_STATIC_TLS; 4554 4555 /* Allocate space for a TLS descriptor. */ 4556 if (entry->tlsdesc12) 4557 dinfo->tlsd12 += 8 * l; 4558 else if (entry->tlsdesclos) 4559 dinfo->tlsdlos += 8 * l; 4560 else if (entry->tlsplt) 4561 dinfo->tlsdplt += 8 * l; 4562 else if (entry->tlsdeschilo) 4563 dinfo->tlsdhilo += 8 * l; 4564 else 4565 entry->relocstlsd -= l; 4566 entry->relocstlsd += l; 4567 } 4568 4569 /* Compute the number of dynamic relocations and fixups that a symbol 4570 requires, and add (or subtract) from the grand and per-symbol 4571 totals. */ 4572 4573 static void 4574 _frvfdpic_count_relocs_fixups (struct frvfdpic_relocs_info *entry, 4575 struct _frvfdpic_dynamic_got_info *dinfo, 4576 bfd_boolean subtract) 4577 { 4578 bfd_vma relocs = 0, fixups = 0, tlsrets = 0; 4579 4580 if (!dinfo->info->executable || dinfo->info->pie) 4581 { 4582 relocs = entry->relocs32 + entry->relocsfd + entry->relocsfdv 4583 + entry->relocstlsd; 4584 4585 /* In the executable, TLS relocations to symbols that bind 4586 locally (including those that resolve to global TLS offsets) 4587 are resolved immediately, without any need for fixups or 4588 dynamic relocations. In shared libraries, however, we must 4589 emit dynamic relocations even for local symbols, because we 4590 don't know the module id the library is going to get at 4591 run-time, nor its TLS base offset. */ 4592 if (!dinfo->info->executable 4593 || (entry->symndx == -1 4594 && ! FRVFDPIC_SYM_LOCAL (dinfo->info, entry->d.h))) 4595 relocs += entry->relocstlsoff; 4596 } 4597 else 4598 { 4599 if (entry->symndx != -1 || FRVFDPIC_SYM_LOCAL (dinfo->info, entry->d.h)) 4600 { 4601 if (entry->symndx != -1 4602 || entry->d.h->root.type != bfd_link_hash_undefweak) 4603 fixups += entry->relocs32 + 2 * entry->relocsfdv; 4604 fixups += entry->relocstlsd; 4605 tlsrets += entry->relocstlsd; 4606 } 4607 else 4608 { 4609 relocs += entry->relocs32 + entry->relocsfdv 4610 + entry->relocstlsoff + entry->relocstlsd; 4611 } 4612 4613 if (entry->symndx != -1 4614 || FRVFDPIC_FUNCDESC_LOCAL (dinfo->info, entry->d.h)) 4615 { 4616 if (entry->symndx != -1 4617 || entry->d.h->root.type != bfd_link_hash_undefweak) 4618 fixups += entry->relocsfd; 4619 } 4620 else 4621 relocs += entry->relocsfd; 4622 } 4623 4624 if (subtract) 4625 { 4626 relocs = - relocs; 4627 fixups = - fixups; 4628 tlsrets = - tlsrets; 4629 } 4630 4631 entry->dynrelocs += relocs; 4632 entry->fixups += fixups; 4633 dinfo->relocs += relocs; 4634 dinfo->fixups += fixups; 4635 dinfo->tls_ret_refs += tlsrets; 4636 } 4637 4638 /* Look for opportunities to relax TLS relocations. We can assume 4639 we're linking the main executable or a static-tls library, since 4640 otherwise we wouldn't have got here. When relaxing, we have to 4641 first undo any previous accounting of TLS uses of fixups, dynamic 4642 relocations, GOT and PLT entries. */ 4643 4644 static void 4645 _frvfdpic_relax_tls_entries (struct frvfdpic_relocs_info *entry, 4646 struct _frvfdpic_dynamic_got_info *dinfo, 4647 bfd_boolean relaxing) 4648 { 4649 bfd_boolean changed = ! relaxing; 4650 4651 BFD_ASSERT (dinfo->info->executable 4652 || (dinfo->info->flags & DF_STATIC_TLS)); 4653 4654 if (entry->tlsdesc12 || entry->tlsdesclos || entry->tlsdeschilo) 4655 { 4656 if (! changed) 4657 { 4658 _frvfdpic_count_relocs_fixups (entry, dinfo, TRUE); 4659 _frvfdpic_count_tls_entries (entry, dinfo, TRUE); 4660 changed = TRUE; 4661 } 4662 4663 /* When linking an executable, we can always decay GOTTLSDESC to 4664 TLSMOFF, if the symbol is local, or GOTTLSOFF, otherwise. 4665 When linking a static-tls shared library, using TLSMOFF is 4666 not an option, but we can still use GOTTLSOFF. When decaying 4667 to GOTTLSOFF, we must keep the GOT entry in range. We know 4668 it has to fit because we'll be trading the 4 words of hte TLS 4669 descriptor for a single word in the same range. */ 4670 if (! dinfo->info->executable 4671 || (entry->symndx == -1 4672 && ! FRVFDPIC_SYM_LOCAL (dinfo->info, entry->d.h))) 4673 { 4674 entry->tlsoff12 |= entry->tlsdesc12; 4675 entry->tlsofflos |= entry->tlsdesclos; 4676 entry->tlsoffhilo |= entry->tlsdeschilo; 4677 } 4678 4679 entry->tlsdesc12 = entry->tlsdesclos = entry->tlsdeschilo = 0; 4680 } 4681 4682 /* We can only decay TLSOFFs or call #gettlsoff to TLSMOFF in the 4683 main executable. We have to check whether the symbol's TLSOFF is 4684 in range for a setlos. For symbols with a hash entry, we can 4685 determine exactly what to do; for others locals, we don't have 4686 addresses handy, so we use the size of the TLS section as an 4687 approximation. If we get it wrong, we'll retain a GOT entry 4688 holding the TLS offset (without dynamic relocations or fixups), 4689 but we'll still optimize away the loads from it. Since TLS sizes 4690 are generally very small, it's probably not worth attempting to 4691 do better than this. */ 4692 if ((entry->tlsplt 4693 || entry->tlsoff12 || entry->tlsofflos || entry->tlsoffhilo) 4694 && dinfo->info->executable && relaxing 4695 && ((entry->symndx == -1 4696 && FRVFDPIC_SYM_LOCAL (dinfo->info, entry->d.h) 4697 /* The above may hold for an undefweak TLS symbol, so make 4698 sure we don't have this case before accessing def.value 4699 and def.section. */ 4700 && (entry->d.h->root.type == bfd_link_hash_undefweak 4701 || (bfd_vma)(entry->d.h->root.u.def.value 4702 + (entry->d.h->root.u.def.section 4703 ->output_section->vma) 4704 + entry->d.h->root.u.def.section->output_offset 4705 + entry->addend 4706 - tls_biased_base (dinfo->info) 4707 + 32768) < (bfd_vma)65536)) 4708 || (entry->symndx != -1 4709 && (elf_hash_table (dinfo->info)->tls_sec->size 4710 + abs (entry->addend) < 32768 + FRVFDPIC_TLS_BIAS)))) 4711 { 4712 if (! changed) 4713 { 4714 _frvfdpic_count_relocs_fixups (entry, dinfo, TRUE); 4715 _frvfdpic_count_tls_entries (entry, dinfo, TRUE); 4716 changed = TRUE; 4717 } 4718 4719 entry->tlsplt = 4720 entry->tlsoff12 = entry->tlsofflos = entry->tlsoffhilo = 0; 4721 } 4722 4723 /* We can decay `call #gettlsoff' to a ldi #tlsoff if we already 4724 have a #gottlsoff12 relocation for this entry, or if we can fit 4725 one more in the 12-bit (and 16-bit) ranges. */ 4726 if (entry->tlsplt 4727 && (entry->tlsoff12 4728 || (relaxing 4729 && dinfo->got12 + dinfo->fd12 + dinfo->tlsd12 <= 4096 - 12 - 4 4730 && (dinfo->got12 + dinfo->fd12 + dinfo->tlsd12 4731 + dinfo->gotlos + dinfo->fdlos + dinfo->tlsdlos 4732 <= 65536 - 12 - 4)))) 4733 { 4734 if (! changed) 4735 { 4736 _frvfdpic_count_relocs_fixups (entry, dinfo, TRUE); 4737 _frvfdpic_count_tls_entries (entry, dinfo, TRUE); 4738 changed = TRUE; 4739 } 4740 4741 entry->tlsoff12 = 1; 4742 entry->tlsplt = 0; 4743 } 4744 4745 if (changed) 4746 { 4747 _frvfdpic_count_tls_entries (entry, dinfo, FALSE); 4748 _frvfdpic_count_relocs_fixups (entry, dinfo, FALSE); 4749 } 4750 4751 return; 4752 } 4753 4754 /* Compute the total GOT and PLT size required by each symbol in each range. * 4755 Symbols may require up to 4 words in the GOT: an entry pointing to 4756 the symbol, an entry pointing to its function descriptor, and a 4757 private function descriptors taking two words. */ 4758 4759 static int 4760 _frvfdpic_count_got_plt_entries (void **entryp, void *dinfo_) 4761 { 4762 struct frvfdpic_relocs_info *entry = *entryp; 4763 struct _frvfdpic_dynamic_got_info *dinfo = dinfo_; 4764 4765 _frvfdpic_count_nontls_entries (entry, dinfo); 4766 4767 if (dinfo->info->executable || (dinfo->info->flags & DF_STATIC_TLS)) 4768 _frvfdpic_relax_tls_entries (entry, dinfo, FALSE); 4769 else 4770 { 4771 _frvfdpic_count_tls_entries (entry, dinfo, FALSE); 4772 _frvfdpic_count_relocs_fixups (entry, dinfo, FALSE); 4773 } 4774 4775 return 1; 4776 } 4777 4778 /* Determine the positive and negative ranges to be used by each 4779 offset range in the GOT. FDCUR and CUR, that must be aligned to a 4780 double-word boundary, are the minimum (negative) and maximum 4781 (positive) GOT offsets already used by previous ranges, except for 4782 an ODD entry that may have been left behind. GOT and FD indicate 4783 the size of GOT entries and function descriptors that must be 4784 placed within the range from -WRAP to WRAP. If there's room left, 4785 up to FDPLT bytes should be reserved for additional function 4786 descriptors. */ 4787 4788 inline static bfd_signed_vma 4789 _frvfdpic_compute_got_alloc_data (struct _frvfdpic_dynamic_got_alloc_data *gad, 4790 bfd_signed_vma fdcur, 4791 bfd_signed_vma odd, 4792 bfd_signed_vma cur, 4793 bfd_vma got, 4794 bfd_vma fd, 4795 bfd_vma fdplt, 4796 bfd_vma tlsd, 4797 bfd_vma tlsdplt, 4798 bfd_vma wrap) 4799 { 4800 bfd_signed_vma wrapmin = -wrap; 4801 const bfd_vma tdescsz = 8; 4802 4803 /* Start at the given initial points. */ 4804 gad->fdcur = fdcur; 4805 gad->cur = cur; 4806 4807 /* If we had an incoming odd word and we have any got entries that 4808 are going to use it, consume it, otherwise leave gad->odd at 4809 zero. We might force gad->odd to zero and return the incoming 4810 odd such that it is used by the next range, but then GOT entries 4811 might appear to be out of order and we wouldn't be able to 4812 shorten the GOT by one word if it turns out to end with an 4813 unpaired GOT entry. */ 4814 if (odd && got) 4815 { 4816 gad->odd = odd; 4817 got -= 4; 4818 odd = 0; 4819 } 4820 else 4821 gad->odd = 0; 4822 4823 /* If we're left with an unpaired GOT entry, compute its location 4824 such that we can return it. Otherwise, if got doesn't require an 4825 odd number of words here, either odd was already zero in the 4826 block above, or it was set to zero because got was non-zero, or 4827 got was already zero. In the latter case, we want the value of 4828 odd to carry over to the return statement, so we don't want to 4829 reset odd unless the condition below is true. */ 4830 if (got & 4) 4831 { 4832 odd = cur + got; 4833 got += 4; 4834 } 4835 4836 /* Compute the tentative boundaries of this range. */ 4837 gad->max = cur + got; 4838 gad->min = fdcur - fd; 4839 gad->fdplt = 0; 4840 4841 /* If function descriptors took too much space, wrap some of them 4842 around. */ 4843 if (gad->min < wrapmin) 4844 { 4845 gad->max += wrapmin - gad->min; 4846 gad->tmin = gad->min = wrapmin; 4847 } 4848 4849 /* If GOT entries took too much space, wrap some of them around. 4850 This may well cause gad->min to become lower than wrapmin. This 4851 will cause a relocation overflow later on, so we don't have to 4852 report it here . */ 4853 if ((bfd_vma) gad->max > wrap) 4854 { 4855 gad->min -= gad->max - wrap; 4856 gad->max = wrap; 4857 } 4858 4859 /* Add TLS descriptors. */ 4860 gad->tmax = gad->max + tlsd; 4861 gad->tmin = gad->min; 4862 gad->tlsdplt = 0; 4863 4864 /* If TLS descriptors took too much space, wrap an integral number 4865 of them around. */ 4866 if ((bfd_vma) gad->tmax > wrap) 4867 { 4868 bfd_vma wrapsize = gad->tmax - wrap; 4869 4870 wrapsize += tdescsz / 2; 4871 wrapsize &= ~ tdescsz / 2; 4872 4873 gad->tmin -= wrapsize; 4874 gad->tmax -= wrapsize; 4875 } 4876 4877 /* If there is space left and we have function descriptors 4878 referenced in PLT entries that could take advantage of shorter 4879 offsets, place them now. */ 4880 if (fdplt && gad->tmin > wrapmin) 4881 { 4882 bfd_vma fds; 4883 4884 if ((bfd_vma) (gad->tmin - wrapmin) < fdplt) 4885 fds = gad->tmin - wrapmin; 4886 else 4887 fds = fdplt; 4888 4889 fdplt -= fds; 4890 gad->min -= fds; 4891 gad->tmin -= fds; 4892 gad->fdplt += fds; 4893 } 4894 4895 /* If there is more space left, try to place some more function 4896 descriptors for PLT entries. */ 4897 if (fdplt && (bfd_vma) gad->tmax < wrap) 4898 { 4899 bfd_vma fds; 4900 4901 if ((bfd_vma) (wrap - gad->tmax) < fdplt) 4902 fds = wrap - gad->tmax; 4903 else 4904 fds = fdplt; 4905 4906 fdplt -= fds; 4907 gad->max += fds; 4908 gad->tmax += fds; 4909 gad->fdplt += fds; 4910 } 4911 4912 /* If there is space left and we have TLS descriptors referenced in 4913 PLT entries that could take advantage of shorter offsets, place 4914 them now. */ 4915 if (tlsdplt && gad->tmin > wrapmin) 4916 { 4917 bfd_vma tlsds; 4918 4919 if ((bfd_vma) (gad->tmin - wrapmin) < tlsdplt) 4920 tlsds = (gad->tmin - wrapmin) & ~ (tdescsz / 2); 4921 else 4922 tlsds = tlsdplt; 4923 4924 tlsdplt -= tlsds; 4925 gad->tmin -= tlsds; 4926 gad->tlsdplt += tlsds; 4927 } 4928 4929 /* If there is more space left, try to place some more TLS 4930 descriptors for PLT entries. Although we could try to fit an 4931 additional TLS descriptor with half of it just before before the 4932 wrap point and another right past the wrap point, this might 4933 cause us to run out of space for the next region, so don't do 4934 it. */ 4935 if (tlsdplt && (bfd_vma) gad->tmax < wrap - tdescsz / 2) 4936 { 4937 bfd_vma tlsds; 4938 4939 if ((bfd_vma) (wrap - gad->tmax) < tlsdplt) 4940 tlsds = (wrap - gad->tmax) & ~ (tdescsz / 2); 4941 else 4942 tlsds = tlsdplt; 4943 4944 tlsdplt -= tlsds; 4945 gad->tmax += tlsds; 4946 gad->tlsdplt += tlsds; 4947 } 4948 4949 /* If odd was initially computed as an offset past the wrap point, 4950 wrap it around. */ 4951 if (odd > gad->max) 4952 odd = gad->min + odd - gad->max; 4953 4954 /* _frvfdpic_get_got_entry() below will always wrap gad->cur if needed 4955 before returning, so do it here too. This guarantees that, 4956 should cur and fdcur meet at the wrap point, they'll both be 4957 equal to min. */ 4958 if (gad->cur == gad->max) 4959 gad->cur = gad->min; 4960 4961 /* Ditto for _frvfdpic_get_tlsdesc_entry(). */ 4962 gad->tcur = gad->max; 4963 if (gad->tcur == gad->tmax) 4964 gad->tcur = gad->tmin; 4965 4966 return odd; 4967 } 4968 4969 /* Compute the location of the next GOT entry, given the allocation 4970 data for a range. */ 4971 4972 inline static bfd_signed_vma 4973 _frvfdpic_get_got_entry (struct _frvfdpic_dynamic_got_alloc_data *gad) 4974 { 4975 bfd_signed_vma ret; 4976 4977 if (gad->odd) 4978 { 4979 /* If there was an odd word left behind, use it. */ 4980 ret = gad->odd; 4981 gad->odd = 0; 4982 } 4983 else 4984 { 4985 /* Otherwise, use the word pointed to by cur, reserve the next 4986 as an odd word, and skip to the next pair of words, possibly 4987 wrapping around. */ 4988 ret = gad->cur; 4989 gad->odd = gad->cur + 4; 4990 gad->cur += 8; 4991 if (gad->cur == gad->max) 4992 gad->cur = gad->min; 4993 } 4994 4995 return ret; 4996 } 4997 4998 /* Compute the location of the next function descriptor entry in the 4999 GOT, given the allocation data for a range. */ 5000 5001 inline static bfd_signed_vma 5002 _frvfdpic_get_fd_entry (struct _frvfdpic_dynamic_got_alloc_data *gad) 5003 { 5004 /* If we're at the bottom, wrap around, and only then allocate the 5005 next pair of words. */ 5006 if (gad->fdcur == gad->min) 5007 gad->fdcur = gad->max; 5008 return gad->fdcur -= 8; 5009 } 5010 5011 /* Compute the location of the next TLS descriptor entry in the GOT, 5012 given the allocation data for a range. */ 5013 inline static bfd_signed_vma 5014 _frvfdpic_get_tlsdesc_entry (struct _frvfdpic_dynamic_got_alloc_data *gad) 5015 { 5016 bfd_signed_vma ret; 5017 5018 ret = gad->tcur; 5019 5020 gad->tcur += 8; 5021 5022 /* If we're at the top of the region, wrap around to the bottom. */ 5023 if (gad->tcur == gad->tmax) 5024 gad->tcur = gad->tmin; 5025 5026 return ret; 5027 } 5028 5029 /* Assign GOT offsets for every GOT entry and function descriptor. 5030 Doing everything in a single pass is tricky. */ 5031 5032 static int 5033 _frvfdpic_assign_got_entries (void **entryp, void *info_) 5034 { 5035 struct frvfdpic_relocs_info *entry = *entryp; 5036 struct _frvfdpic_dynamic_got_plt_info *dinfo = info_; 5037 5038 if (entry->got12) 5039 entry->got_entry = _frvfdpic_get_got_entry (&dinfo->got12); 5040 else if (entry->gotlos) 5041 entry->got_entry = _frvfdpic_get_got_entry (&dinfo->gotlos); 5042 else if (entry->gothilo) 5043 entry->got_entry = _frvfdpic_get_got_entry (&dinfo->gothilo); 5044 5045 if (entry->fdgot12) 5046 entry->fdgot_entry = _frvfdpic_get_got_entry (&dinfo->got12); 5047 else if (entry->fdgotlos) 5048 entry->fdgot_entry = _frvfdpic_get_got_entry (&dinfo->gotlos); 5049 else if (entry->fdgothilo) 5050 entry->fdgot_entry = _frvfdpic_get_got_entry (&dinfo->gothilo); 5051 5052 if (entry->fdgoff12) 5053 entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->got12); 5054 else if (entry->plt && dinfo->got12.fdplt) 5055 { 5056 dinfo->got12.fdplt -= 8; 5057 entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->got12); 5058 } 5059 else if (entry->fdgofflos) 5060 entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->gotlos); 5061 else if (entry->plt && dinfo->gotlos.fdplt) 5062 { 5063 dinfo->gotlos.fdplt -= 8; 5064 entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->gotlos); 5065 } 5066 else if (entry->plt) 5067 { 5068 dinfo->gothilo.fdplt -= 8; 5069 entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->gothilo); 5070 } 5071 else if (entry->privfd) 5072 entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->gothilo); 5073 5074 if (entry->tlsoff12) 5075 entry->tlsoff_entry = _frvfdpic_get_got_entry (&dinfo->got12); 5076 else if (entry->tlsofflos) 5077 entry->tlsoff_entry = _frvfdpic_get_got_entry (&dinfo->gotlos); 5078 else if (entry->tlsoffhilo) 5079 entry->tlsoff_entry = _frvfdpic_get_got_entry (&dinfo->gothilo); 5080 5081 if (entry->tlsdesc12) 5082 entry->tlsdesc_entry = _frvfdpic_get_tlsdesc_entry (&dinfo->got12); 5083 else if (entry->tlsplt && dinfo->got12.tlsdplt) 5084 { 5085 dinfo->got12.tlsdplt -= 8; 5086 entry->tlsdesc_entry = _frvfdpic_get_tlsdesc_entry (&dinfo->got12); 5087 } 5088 else if (entry->tlsdesclos) 5089 entry->tlsdesc_entry = _frvfdpic_get_tlsdesc_entry (&dinfo->gotlos); 5090 else if (entry->tlsplt && dinfo->gotlos.tlsdplt) 5091 { 5092 dinfo->gotlos.tlsdplt -= 8; 5093 entry->tlsdesc_entry = _frvfdpic_get_tlsdesc_entry (&dinfo->gotlos); 5094 } 5095 else if (entry->tlsplt) 5096 { 5097 dinfo->gothilo.tlsdplt -= 8; 5098 entry->tlsdesc_entry = _frvfdpic_get_tlsdesc_entry (&dinfo->gothilo); 5099 } 5100 else if (entry->tlsdeschilo) 5101 entry->tlsdesc_entry = _frvfdpic_get_tlsdesc_entry (&dinfo->gothilo); 5102 5103 return 1; 5104 } 5105 5106 /* Assign GOT offsets to private function descriptors used by PLT 5107 entries (or referenced by 32-bit offsets), as well as PLT entries 5108 and lazy PLT entries. */ 5109 5110 static int 5111 _frvfdpic_assign_plt_entries (void **entryp, void *info_) 5112 { 5113 struct frvfdpic_relocs_info *entry = *entryp; 5114 struct _frvfdpic_dynamic_got_plt_info *dinfo = info_; 5115 5116 if (entry->privfd) 5117 BFD_ASSERT (entry->fd_entry); 5118 5119 if (entry->plt) 5120 { 5121 int size; 5122 5123 /* We use the section's raw size to mark the location of the 5124 next PLT entry. */ 5125 entry->plt_entry = frvfdpic_plt_section (dinfo->g.info)->size; 5126 5127 /* Figure out the length of this PLT entry based on the 5128 addressing mode we need to reach the function descriptor. */ 5129 BFD_ASSERT (entry->fd_entry); 5130 if (entry->fd_entry >= -(1 << (12 - 1)) 5131 && entry->fd_entry < (1 << (12 - 1))) 5132 size = 8; 5133 else if (entry->fd_entry >= -(1 << (16 - 1)) 5134 && entry->fd_entry < (1 << (16 - 1))) 5135 size = 12; 5136 else 5137 size = 16; 5138 5139 frvfdpic_plt_section (dinfo->g.info)->size += size; 5140 } 5141 5142 if (entry->lazyplt) 5143 { 5144 entry->lzplt_entry = dinfo->g.lzplt; 5145 dinfo->g.lzplt += 8; 5146 /* If this entry is the one that gets the resolver stub, account 5147 for the additional instruction. */ 5148 if (entry->lzplt_entry % FRVFDPIC_LZPLT_BLOCK_SIZE 5149 == FRVFDPIC_LZPLT_RESOLV_LOC) 5150 dinfo->g.lzplt += 4; 5151 } 5152 5153 if (entry->tlsplt) 5154 { 5155 int size; 5156 5157 entry->tlsplt_entry 5158 = frvfdpic_plt_section (dinfo->g.info)->size; 5159 5160 if (dinfo->g.info->executable 5161 && (entry->symndx != -1 5162 || FRVFDPIC_SYM_LOCAL (dinfo->g.info, entry->d.h))) 5163 { 5164 if ((bfd_signed_vma)entry->addend >= -(1 << (16 - 1)) 5165 /* FIXME: here we use the size of the TLS section 5166 as an upper bound for the value of the TLS 5167 symbol, because we may not know the exact value 5168 yet. If we get it wrong, we'll just waste a 5169 word in the PLT, and we should never get even 5170 close to 32 KiB of TLS anyway. */ 5171 && elf_hash_table (dinfo->g.info)->tls_sec 5172 && (elf_hash_table (dinfo->g.info)->tls_sec->size 5173 + (bfd_signed_vma)(entry->addend) <= (1 << (16 - 1)))) 5174 size = 8; 5175 else 5176 size = 12; 5177 } 5178 else if (entry->tlsoff_entry) 5179 { 5180 if (entry->tlsoff_entry >= -(1 << (12 - 1)) 5181 && entry->tlsoff_entry < (1 << (12 - 1))) 5182 size = 8; 5183 else if (entry->tlsoff_entry >= -(1 << (16 - 1)) 5184 && entry->tlsoff_entry < (1 << (16 - 1))) 5185 size = 12; 5186 else 5187 size = 16; 5188 } 5189 else 5190 { 5191 BFD_ASSERT (entry->tlsdesc_entry); 5192 5193 if (entry->tlsdesc_entry >= -(1 << (12 - 1)) 5194 && entry->tlsdesc_entry < (1 << (12 - 1))) 5195 size = 8; 5196 else if (entry->tlsdesc_entry >= -(1 << (16 - 1)) 5197 && entry->tlsdesc_entry < (1 << (16 - 1))) 5198 size = 12; 5199 else 5200 size = 16; 5201 } 5202 5203 frvfdpic_plt_section (dinfo->g.info)->size += size; 5204 } 5205 5206 return 1; 5207 } 5208 5209 /* Cancel out any effects of calling _frvfdpic_assign_got_entries and 5210 _frvfdpic_assign_plt_entries. */ 5211 5212 static int 5213 _frvfdpic_reset_got_plt_entries (void **entryp, void *ignore ATTRIBUTE_UNUSED) 5214 { 5215 struct frvfdpic_relocs_info *entry = *entryp; 5216 5217 entry->got_entry = 0; 5218 entry->fdgot_entry = 0; 5219 entry->fd_entry = 0; 5220 entry->plt_entry = (bfd_vma)-1; 5221 entry->lzplt_entry = (bfd_vma)-1; 5222 entry->tlsoff_entry = 0; 5223 entry->tlsdesc_entry = 0; 5224 entry->tlsplt_entry = (bfd_vma)-1; 5225 5226 return 1; 5227 } 5228 5229 /* Follow indirect and warning hash entries so that each got entry 5230 points to the final symbol definition. P must point to a pointer 5231 to the hash table we're traversing. Since this traversal may 5232 modify the hash table, we set this pointer to NULL to indicate 5233 we've made a potentially-destructive change to the hash table, so 5234 the traversal must be restarted. */ 5235 static int 5236 _frvfdpic_resolve_final_relocs_info (void **entryp, void *p) 5237 { 5238 struct frvfdpic_relocs_info *entry = *entryp; 5239 htab_t *htab = p; 5240 5241 if (entry->symndx == -1) 5242 { 5243 struct elf_link_hash_entry *h = entry->d.h; 5244 struct frvfdpic_relocs_info *oentry; 5245 5246 while (h->root.type == bfd_link_hash_indirect 5247 || h->root.type == bfd_link_hash_warning) 5248 h = (struct elf_link_hash_entry *)h->root.u.i.link; 5249 5250 if (entry->d.h == h) 5251 return 1; 5252 5253 oentry = frvfdpic_relocs_info_for_global (*htab, 0, h, entry->addend, 5254 NO_INSERT); 5255 5256 if (oentry) 5257 { 5258 /* Merge the two entries. */ 5259 frvfdpic_pic_merge_early_relocs_info (oentry, entry); 5260 htab_clear_slot (*htab, entryp); 5261 return 1; 5262 } 5263 5264 entry->d.h = h; 5265 5266 /* If we can't find this entry with the new bfd hash, re-insert 5267 it, and get the traversal restarted. */ 5268 if (! htab_find (*htab, entry)) 5269 { 5270 htab_clear_slot (*htab, entryp); 5271 entryp = htab_find_slot (*htab, entry, INSERT); 5272 if (! *entryp) 5273 *entryp = entry; 5274 /* Abort the traversal, since the whole table may have 5275 moved, and leave it up to the parent to restart the 5276 process. */ 5277 *(htab_t *)p = NULL; 5278 return 0; 5279 } 5280 } 5281 5282 return 1; 5283 } 5284 5285 /* Compute the total size of the GOT, the PLT, the dynamic relocations 5286 section and the rofixup section. Assign locations for GOT and PLT 5287 entries. */ 5288 5289 static bfd_boolean 5290 _frvfdpic_size_got_plt (bfd *output_bfd, 5291 struct _frvfdpic_dynamic_got_plt_info *gpinfop) 5292 { 5293 bfd_signed_vma odd; 5294 bfd_vma limit, tlslimit; 5295 struct bfd_link_info *info = gpinfop->g.info; 5296 bfd *dynobj = elf_hash_table (info)->dynobj; 5297 5298 memcpy (frvfdpic_dynamic_got_plt_info (info), &gpinfop->g, 5299 sizeof (gpinfop->g)); 5300 5301 odd = 12; 5302 /* Compute the total size taken by entries in the 12-bit and 16-bit 5303 ranges, to tell how many PLT function descriptors we can bring 5304 into the 12-bit range without causing the 16-bit range to 5305 overflow. */ 5306 limit = odd + gpinfop->g.got12 + gpinfop->g.gotlos 5307 + gpinfop->g.fd12 + gpinfop->g.fdlos 5308 + gpinfop->g.tlsd12 + gpinfop->g.tlsdlos; 5309 if (limit < (bfd_vma)1 << 16) 5310 limit = ((bfd_vma)1 << 16) - limit; 5311 else 5312 limit = 0; 5313 if (gpinfop->g.fdplt < limit) 5314 { 5315 tlslimit = (limit - gpinfop->g.fdplt) & ~ (bfd_vma) 8; 5316 limit = gpinfop->g.fdplt; 5317 } 5318 else 5319 tlslimit = 0; 5320 if (gpinfop->g.tlsdplt < tlslimit) 5321 tlslimit = gpinfop->g.tlsdplt; 5322 5323 /* Determine the ranges of GOT offsets that we can use for each 5324 range of addressing modes. */ 5325 odd = _frvfdpic_compute_got_alloc_data (&gpinfop->got12, 5326 0, 5327 odd, 5328 16, 5329 gpinfop->g.got12, 5330 gpinfop->g.fd12, 5331 limit, 5332 gpinfop->g.tlsd12, 5333 tlslimit, 5334 (bfd_vma)1 << (12-1)); 5335 odd = _frvfdpic_compute_got_alloc_data (&gpinfop->gotlos, 5336 gpinfop->got12.tmin, 5337 odd, 5338 gpinfop->got12.tmax, 5339 gpinfop->g.gotlos, 5340 gpinfop->g.fdlos, 5341 gpinfop->g.fdplt 5342 - gpinfop->got12.fdplt, 5343 gpinfop->g.tlsdlos, 5344 gpinfop->g.tlsdplt 5345 - gpinfop->got12.tlsdplt, 5346 (bfd_vma)1 << (16-1)); 5347 odd = _frvfdpic_compute_got_alloc_data (&gpinfop->gothilo, 5348 gpinfop->gotlos.tmin, 5349 odd, 5350 gpinfop->gotlos.tmax, 5351 gpinfop->g.gothilo, 5352 gpinfop->g.fdhilo, 5353 gpinfop->g.fdplt 5354 - gpinfop->got12.fdplt 5355 - gpinfop->gotlos.fdplt, 5356 gpinfop->g.tlsdhilo, 5357 gpinfop->g.tlsdplt 5358 - gpinfop->got12.tlsdplt 5359 - gpinfop->gotlos.tlsdplt, 5360 (bfd_vma)1 << (32-1)); 5361 5362 /* Now assign (most) GOT offsets. */ 5363 htab_traverse (frvfdpic_relocs_info (info), _frvfdpic_assign_got_entries, 5364 gpinfop); 5365 5366 frvfdpic_got_section (info)->size = gpinfop->gothilo.tmax 5367 - gpinfop->gothilo.tmin 5368 /* If an odd word is the last word of the GOT, we don't need this 5369 word to be part of the GOT. */ 5370 - (odd + 4 == gpinfop->gothilo.tmax ? 4 : 0); 5371 if (frvfdpic_got_section (info)->size == 0) 5372 frvfdpic_got_section (info)->flags |= SEC_EXCLUDE; 5373 else if (frvfdpic_got_section (info)->size == 12 5374 && ! elf_hash_table (info)->dynamic_sections_created) 5375 { 5376 frvfdpic_got_section (info)->flags |= SEC_EXCLUDE; 5377 frvfdpic_got_section (info)->size = 0; 5378 } 5379 /* This will be non-NULL during relaxation. The assumption is that 5380 the size of one of these sections will never grow, only shrink, 5381 so we can use the larger buffer we allocated before. */ 5382 else if (frvfdpic_got_section (info)->contents == NULL) 5383 { 5384 frvfdpic_got_section (info)->contents = 5385 (bfd_byte *) bfd_zalloc (dynobj, 5386 frvfdpic_got_section (info)->size); 5387 if (frvfdpic_got_section (info)->contents == NULL) 5388 return FALSE; 5389 } 5390 5391 if (frvfdpic_gotrel_section (info)) 5392 /* Subtract the number of lzplt entries, since those will generate 5393 relocations in the pltrel section. */ 5394 frvfdpic_gotrel_section (info)->size = 5395 (gpinfop->g.relocs - gpinfop->g.lzplt / 8) 5396 * get_elf_backend_data (output_bfd)->s->sizeof_rel; 5397 else 5398 BFD_ASSERT (gpinfop->g.relocs == 0); 5399 if (frvfdpic_gotrel_section (info)->size == 0) 5400 frvfdpic_gotrel_section (info)->flags |= SEC_EXCLUDE; 5401 else if (frvfdpic_gotrel_section (info)->contents == NULL) 5402 { 5403 frvfdpic_gotrel_section (info)->contents = 5404 (bfd_byte *) bfd_zalloc (dynobj, 5405 frvfdpic_gotrel_section (info)->size); 5406 if (frvfdpic_gotrel_section (info)->contents == NULL) 5407 return FALSE; 5408 } 5409 5410 frvfdpic_gotfixup_section (info)->size = (gpinfop->g.fixups + 1) * 4; 5411 if (frvfdpic_gotfixup_section (info)->size == 0) 5412 frvfdpic_gotfixup_section (info)->flags |= SEC_EXCLUDE; 5413 else if (frvfdpic_gotfixup_section (info)->contents == NULL) 5414 { 5415 frvfdpic_gotfixup_section (info)->contents = 5416 (bfd_byte *) bfd_zalloc (dynobj, 5417 frvfdpic_gotfixup_section (info)->size); 5418 if (frvfdpic_gotfixup_section (info)->contents == NULL) 5419 return FALSE; 5420 } 5421 5422 if (frvfdpic_pltrel_section (info)) 5423 { 5424 frvfdpic_pltrel_section (info)->size = 5425 gpinfop->g.lzplt / 8 5426 * get_elf_backend_data (output_bfd)->s->sizeof_rel; 5427 if (frvfdpic_pltrel_section (info)->size == 0) 5428 frvfdpic_pltrel_section (info)->flags |= SEC_EXCLUDE; 5429 else if (frvfdpic_pltrel_section (info)->contents == NULL) 5430 { 5431 frvfdpic_pltrel_section (info)->contents = 5432 (bfd_byte *) bfd_zalloc (dynobj, 5433 frvfdpic_pltrel_section (info)->size); 5434 if (frvfdpic_pltrel_section (info)->contents == NULL) 5435 return FALSE; 5436 } 5437 } 5438 5439 /* Add 4 bytes for every block of at most 65535 lazy PLT entries, 5440 such that there's room for the additional instruction needed to 5441 call the resolver. Since _frvfdpic_assign_got_entries didn't 5442 account for them, our block size is 4 bytes smaller than the real 5443 block size. */ 5444 if (frvfdpic_plt_section (info)) 5445 { 5446 frvfdpic_plt_section (info)->size = gpinfop->g.lzplt 5447 + ((gpinfop->g.lzplt + (FRVFDPIC_LZPLT_BLOCK_SIZE - 4) - 8) 5448 / (FRVFDPIC_LZPLT_BLOCK_SIZE - 4) * 4); 5449 } 5450 5451 /* Reset it, such that _frvfdpic_assign_plt_entries() can use it to 5452 actually assign lazy PLT entries addresses. */ 5453 gpinfop->g.lzplt = 0; 5454 5455 /* Save information that we're going to need to generate GOT and PLT 5456 entries. */ 5457 frvfdpic_got_initial_offset (info) = -gpinfop->gothilo.tmin; 5458 5459 if (get_elf_backend_data (output_bfd)->want_got_sym) 5460 elf_hash_table (info)->hgot->root.u.def.value 5461 = frvfdpic_got_initial_offset (info); 5462 5463 if (frvfdpic_plt_section (info)) 5464 frvfdpic_plt_initial_offset (info) = 5465 frvfdpic_plt_section (info)->size; 5466 5467 /* Allocate a ret statement at plt_initial_offset, to be used by 5468 locally-resolved TLS descriptors. */ 5469 if (gpinfop->g.tls_ret_refs) 5470 frvfdpic_plt_section (info)->size += 4; 5471 5472 htab_traverse (frvfdpic_relocs_info (info), _frvfdpic_assign_plt_entries, 5473 gpinfop); 5474 5475 /* Allocate the PLT section contents only after 5476 _frvfdpic_assign_plt_entries has a chance to add the size of the 5477 non-lazy PLT entries. */ 5478 if (frvfdpic_plt_section (info)) 5479 { 5480 if (frvfdpic_plt_section (info)->size == 0) 5481 frvfdpic_plt_section (info)->flags |= SEC_EXCLUDE; 5482 else if (frvfdpic_plt_section (info)->contents == NULL) 5483 { 5484 frvfdpic_plt_section (info)->contents = 5485 (bfd_byte *) bfd_zalloc (dynobj, 5486 frvfdpic_plt_section (info)->size); 5487 if (frvfdpic_plt_section (info)->contents == NULL) 5488 return FALSE; 5489 } 5490 } 5491 5492 return TRUE; 5493 } 5494 5495 /* Set the sizes of the dynamic sections. */ 5496 5497 static bfd_boolean 5498 elf32_frvfdpic_size_dynamic_sections (bfd *output_bfd, 5499 struct bfd_link_info *info) 5500 { 5501 bfd *dynobj; 5502 asection *s; 5503 struct _frvfdpic_dynamic_got_plt_info gpinfo; 5504 5505 dynobj = elf_hash_table (info)->dynobj; 5506 BFD_ASSERT (dynobj != NULL); 5507 5508 if (elf_hash_table (info)->dynamic_sections_created) 5509 { 5510 /* Set the contents of the .interp section to the interpreter. */ 5511 if (info->executable) 5512 { 5513 s = bfd_get_section_by_name (dynobj, ".interp"); 5514 BFD_ASSERT (s != NULL); 5515 s->size = sizeof ELF_DYNAMIC_INTERPRETER; 5516 s->contents = (bfd_byte *) ELF_DYNAMIC_INTERPRETER; 5517 } 5518 } 5519 5520 memset (&gpinfo, 0, sizeof (gpinfo)); 5521 gpinfo.g.info = info; 5522 5523 for (;;) 5524 { 5525 htab_t relocs = frvfdpic_relocs_info (info); 5526 5527 htab_traverse (relocs, _frvfdpic_resolve_final_relocs_info, &relocs); 5528 5529 if (relocs == frvfdpic_relocs_info (info)) 5530 break; 5531 } 5532 5533 htab_traverse (frvfdpic_relocs_info (info), _frvfdpic_count_got_plt_entries, 5534 &gpinfo.g); 5535 5536 /* Allocate space to save the summary information, we're going to 5537 use it if we're doing relaxations. */ 5538 frvfdpic_dynamic_got_plt_info (info) = bfd_alloc (dynobj, sizeof (gpinfo.g)); 5539 5540 if (!_frvfdpic_size_got_plt (output_bfd, &gpinfo)) 5541 return FALSE; 5542 5543 if (elf_hash_table (info)->dynamic_sections_created) 5544 { 5545 if (frvfdpic_got_section (info)->size) 5546 if (!_bfd_elf_add_dynamic_entry (info, DT_PLTGOT, 0)) 5547 return FALSE; 5548 5549 if (frvfdpic_pltrel_section (info)->size) 5550 if (!_bfd_elf_add_dynamic_entry (info, DT_PLTRELSZ, 0) 5551 || !_bfd_elf_add_dynamic_entry (info, DT_PLTREL, DT_REL) 5552 || !_bfd_elf_add_dynamic_entry (info, DT_JMPREL, 0)) 5553 return FALSE; 5554 5555 if (frvfdpic_gotrel_section (info)->size) 5556 if (!_bfd_elf_add_dynamic_entry (info, DT_REL, 0) 5557 || !_bfd_elf_add_dynamic_entry (info, DT_RELSZ, 0) 5558 || !_bfd_elf_add_dynamic_entry (info, DT_RELENT, 5559 sizeof (Elf32_External_Rel))) 5560 return FALSE; 5561 } 5562 5563 return TRUE; 5564 } 5565 5566 static bfd_boolean 5567 elf32_frvfdpic_always_size_sections (bfd *output_bfd, 5568 struct bfd_link_info *info) 5569 { 5570 if (!info->relocatable) 5571 { 5572 struct elf_link_hash_entry *h; 5573 5574 /* Force a PT_GNU_STACK segment to be created. */ 5575 if (! elf_tdata (output_bfd)->stack_flags) 5576 elf_tdata (output_bfd)->stack_flags = PF_R | PF_W | PF_X; 5577 5578 /* Define __stacksize if it's not defined yet. */ 5579 h = elf_link_hash_lookup (elf_hash_table (info), "__stacksize", 5580 FALSE, FALSE, FALSE); 5581 if (! h || h->root.type != bfd_link_hash_defined 5582 || h->type != STT_OBJECT 5583 || !h->def_regular) 5584 { 5585 struct bfd_link_hash_entry *bh = NULL; 5586 5587 if (!(_bfd_generic_link_add_one_symbol 5588 (info, output_bfd, "__stacksize", 5589 BSF_GLOBAL, bfd_abs_section_ptr, DEFAULT_STACK_SIZE, 5590 (const char *) NULL, FALSE, 5591 get_elf_backend_data (output_bfd)->collect, &bh))) 5592 return FALSE; 5593 5594 h = (struct elf_link_hash_entry *) bh; 5595 h->def_regular = 1; 5596 h->type = STT_OBJECT; 5597 /* This one must NOT be hidden. */ 5598 } 5599 } 5600 5601 return TRUE; 5602 } 5603 5604 /* Check whether any of the relocations was optimized away, and 5605 subtract it from the relocation or fixup count. */ 5606 static bfd_boolean 5607 _frvfdpic_check_discarded_relocs (bfd *abfd, asection *sec, 5608 struct bfd_link_info *info, 5609 5610 bfd_boolean *changed) 5611 { 5612 Elf_Internal_Shdr *symtab_hdr; 5613 struct elf_link_hash_entry **sym_hashes; 5614 Elf_Internal_Rela *rel, *erel; 5615 5616 if ((sec->flags & SEC_RELOC) == 0 5617 || sec->reloc_count == 0) 5618 return TRUE; 5619 5620 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 5621 sym_hashes = elf_sym_hashes (abfd); 5622 5623 rel = elf_section_data (sec)->relocs; 5624 5625 /* Now examine each relocation. */ 5626 for (erel = rel + sec->reloc_count; rel < erel; rel++) 5627 { 5628 struct elf_link_hash_entry *h; 5629 unsigned long r_symndx; 5630 struct frvfdpic_relocs_info *picrel; 5631 struct _frvfdpic_dynamic_got_info *dinfo; 5632 5633 if (ELF32_R_TYPE (rel->r_info) != R_FRV_32 5634 && ELF32_R_TYPE (rel->r_info) != R_FRV_FUNCDESC) 5635 continue; 5636 5637 if (_bfd_elf_section_offset (sec->output_section->owner, 5638 info, sec, rel->r_offset) 5639 != (bfd_vma)-1) 5640 continue; 5641 5642 r_symndx = ELF32_R_SYM (rel->r_info); 5643 if (r_symndx < symtab_hdr->sh_info) 5644 h = NULL; 5645 else 5646 { 5647 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 5648 while (h->root.type == bfd_link_hash_indirect 5649 || h->root.type == bfd_link_hash_warning) 5650 h = (struct elf_link_hash_entry *)h->root.u.i.link; 5651 } 5652 5653 if (h != NULL) 5654 picrel = frvfdpic_relocs_info_for_global (frvfdpic_relocs_info (info), 5655 abfd, h, 5656 rel->r_addend, NO_INSERT); 5657 else 5658 picrel = frvfdpic_relocs_info_for_local (frvfdpic_relocs_info (info), 5659 abfd, r_symndx, 5660 rel->r_addend, NO_INSERT); 5661 5662 if (! picrel) 5663 return FALSE; 5664 5665 *changed = TRUE; 5666 dinfo = frvfdpic_dynamic_got_plt_info (info); 5667 5668 _frvfdpic_count_relocs_fixups (picrel, dinfo, TRUE); 5669 if (ELF32_R_TYPE (rel->r_info) == R_FRV_32) 5670 picrel->relocs32--; 5671 else /* we know (ELF32_R_TYPE (rel->r_info) == R_FRV_FUNCDESC) */ 5672 picrel->relocsfd--; 5673 _frvfdpic_count_relocs_fixups (picrel, dinfo, FALSE); 5674 } 5675 5676 return TRUE; 5677 } 5678 5679 static bfd_boolean 5680 frvfdpic_elf_discard_info (bfd *ibfd, 5681 struct elf_reloc_cookie *cookie ATTRIBUTE_UNUSED, 5682 struct bfd_link_info *info) 5683 { 5684 bfd_boolean changed = FALSE; 5685 asection *s; 5686 bfd *obfd = NULL; 5687 5688 /* Account for relaxation of .eh_frame section. */ 5689 for (s = ibfd->sections; s; s = s->next) 5690 if (s->sec_info_type == ELF_INFO_TYPE_EH_FRAME) 5691 { 5692 if (!_frvfdpic_check_discarded_relocs (ibfd, s, info, &changed)) 5693 return FALSE; 5694 obfd = s->output_section->owner; 5695 } 5696 5697 if (changed) 5698 { 5699 struct _frvfdpic_dynamic_got_plt_info gpinfo; 5700 5701 memset (&gpinfo, 0, sizeof (gpinfo)); 5702 memcpy (&gpinfo.g, frvfdpic_dynamic_got_plt_info (info), 5703 sizeof (gpinfo.g)); 5704 5705 /* Clear GOT and PLT assignments. */ 5706 htab_traverse (frvfdpic_relocs_info (info), 5707 _frvfdpic_reset_got_plt_entries, 5708 NULL); 5709 5710 if (!_frvfdpic_size_got_plt (obfd, &gpinfo)) 5711 return FALSE; 5712 } 5713 5714 return TRUE; 5715 } 5716 5717 /* Look for opportunities to relax TLS relocations. We can assume 5718 we're linking the main executable or a static-tls library, since 5719 otherwise we wouldn't have got here. */ 5720 5721 static int 5722 _frvfdpic_relax_got_plt_entries (void **entryp, void *dinfo_) 5723 { 5724 struct frvfdpic_relocs_info *entry = *entryp; 5725 struct _frvfdpic_dynamic_got_info *dinfo = dinfo_; 5726 5727 _frvfdpic_relax_tls_entries (entry, dinfo, TRUE); 5728 5729 return 1; 5730 } 5731 5732 static bfd_boolean 5733 elf32_frvfdpic_relax_section (bfd *abfd ATTRIBUTE_UNUSED, asection *sec, 5734 struct bfd_link_info *info, bfd_boolean *again) 5735 { 5736 struct _frvfdpic_dynamic_got_plt_info gpinfo; 5737 5738 if (info->relocatable) 5739 (*info->callbacks->einfo) 5740 (_("%P%F: --relax and -r may not be used together\n")); 5741 5742 /* If we return early, we didn't change anything. */ 5743 *again = FALSE; 5744 5745 /* We'll do our thing when requested to relax the GOT section. */ 5746 if (sec != frvfdpic_got_section (info)) 5747 return TRUE; 5748 5749 /* We can only relax when linking the main executable or a library 5750 that can't be dlopened. */ 5751 if (! info->executable && ! (info->flags & DF_STATIC_TLS)) 5752 return TRUE; 5753 5754 /* If there isn't a TLS section for this binary, we can't do 5755 anything about its TLS relocations (it probably doesn't have 5756 any. */ 5757 if (elf_hash_table (info)->tls_sec == NULL) 5758 return TRUE; 5759 5760 memset (&gpinfo, 0, sizeof (gpinfo)); 5761 memcpy (&gpinfo.g, frvfdpic_dynamic_got_plt_info (info), sizeof (gpinfo.g)); 5762 5763 /* Now look for opportunities to relax, adjusting the GOT usage 5764 as needed. */ 5765 htab_traverse (frvfdpic_relocs_info (info), 5766 _frvfdpic_relax_got_plt_entries, 5767 &gpinfo.g); 5768 5769 /* If we changed anything, reset and re-assign GOT and PLT entries. */ 5770 if (memcmp (frvfdpic_dynamic_got_plt_info (info), 5771 &gpinfo.g, sizeof (gpinfo.g)) != 0) 5772 { 5773 /* Clear GOT and PLT assignments. */ 5774 htab_traverse (frvfdpic_relocs_info (info), 5775 _frvfdpic_reset_got_plt_entries, 5776 NULL); 5777 5778 /* The owner of the TLS section is the output bfd. There should 5779 be a better way to get to it. */ 5780 if (!_frvfdpic_size_got_plt (elf_hash_table (info)->tls_sec->owner, 5781 &gpinfo)) 5782 return FALSE; 5783 5784 /* Repeat until we don't make any further changes. We could fail to 5785 introduce changes in a round if, for example, the 12-bit range is 5786 full, but we later release some space by getting rid of TLS 5787 descriptors in it. We have to repeat the whole process because 5788 we might have changed the size of a section processed before this 5789 one. */ 5790 *again = TRUE; 5791 } 5792 5793 return TRUE; 5794 } 5795 5796 static bfd_boolean 5797 elf32_frvfdpic_modify_program_headers (bfd *output_bfd, 5798 struct bfd_link_info *info) 5799 { 5800 struct elf_obj_tdata *tdata = elf_tdata (output_bfd); 5801 struct elf_segment_map *m; 5802 Elf_Internal_Phdr *p; 5803 5804 /* objcopy and strip preserve what's already there using 5805 elf32_frvfdpic_copy_private_bfd_data (). */ 5806 if (! info) 5807 return TRUE; 5808 5809 for (p = tdata->phdr, m = tdata->segment_map; m != NULL; m = m->next, p++) 5810 if (m->p_type == PT_GNU_STACK) 5811 break; 5812 5813 if (m) 5814 { 5815 struct elf_link_hash_entry *h; 5816 5817 /* Obtain the pointer to the __stacksize symbol. */ 5818 h = elf_link_hash_lookup (elf_hash_table (info), "__stacksize", 5819 FALSE, FALSE, FALSE); 5820 if (h) 5821 { 5822 while (h->root.type == bfd_link_hash_indirect 5823 || h->root.type == bfd_link_hash_warning) 5824 h = (struct elf_link_hash_entry *) h->root.u.i.link; 5825 BFD_ASSERT (h->root.type == bfd_link_hash_defined); 5826 } 5827 5828 /* Set the header p_memsz from the symbol value. We 5829 intentionally ignore the symbol section. */ 5830 if (h && h->root.type == bfd_link_hash_defined) 5831 p->p_memsz = h->root.u.def.value; 5832 else 5833 p->p_memsz = DEFAULT_STACK_SIZE; 5834 5835 p->p_align = 8; 5836 } 5837 5838 return TRUE; 5839 } 5840 5841 /* Fill in code and data in dynamic sections. */ 5842 5843 static bfd_boolean 5844 elf32_frv_finish_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED, 5845 struct bfd_link_info *info ATTRIBUTE_UNUSED) 5846 { 5847 /* Nothing to be done for non-FDPIC. */ 5848 return TRUE; 5849 } 5850 5851 static bfd_boolean 5852 elf32_frvfdpic_finish_dynamic_sections (bfd *output_bfd, 5853 struct bfd_link_info *info) 5854 { 5855 bfd *dynobj; 5856 asection *sdyn; 5857 5858 dynobj = elf_hash_table (info)->dynobj; 5859 5860 if (frvfdpic_dynamic_got_plt_info (info)) 5861 { 5862 BFD_ASSERT (frvfdpic_dynamic_got_plt_info (info)->tls_ret_refs == 0); 5863 } 5864 if (frvfdpic_got_section (info)) 5865 { 5866 BFD_ASSERT (frvfdpic_gotrel_section (info)->size 5867 == (frvfdpic_gotrel_section (info)->reloc_count 5868 * sizeof (Elf32_External_Rel))); 5869 5870 if (frvfdpic_gotfixup_section (info)) 5871 { 5872 struct elf_link_hash_entry *hgot = elf_hash_table (info)->hgot; 5873 bfd_vma got_value = hgot->root.u.def.value 5874 + hgot->root.u.def.section->output_section->vma 5875 + hgot->root.u.def.section->output_offset; 5876 struct bfd_link_hash_entry *hend; 5877 5878 _frvfdpic_add_rofixup (output_bfd, frvfdpic_gotfixup_section (info), 5879 got_value, 0); 5880 5881 if (frvfdpic_gotfixup_section (info)->size 5882 != (frvfdpic_gotfixup_section (info)->reloc_count * 4)) 5883 { 5884 error: 5885 (*_bfd_error_handler) 5886 ("LINKER BUG: .rofixup section size mismatch"); 5887 return FALSE; 5888 } 5889 5890 hend = bfd_link_hash_lookup (info->hash, "__ROFIXUP_END__", 5891 FALSE, FALSE, TRUE); 5892 if (hend 5893 && (hend->type == bfd_link_hash_defined 5894 || hend->type == bfd_link_hash_defweak) 5895 && hend->u.def.section->output_section != NULL) 5896 { 5897 bfd_vma value = 5898 frvfdpic_gotfixup_section (info)->output_section->vma 5899 + frvfdpic_gotfixup_section (info)->output_offset 5900 + frvfdpic_gotfixup_section (info)->size 5901 - hend->u.def.section->output_section->vma 5902 - hend->u.def.section->output_offset; 5903 BFD_ASSERT (hend->u.def.value == value); 5904 if (hend->u.def.value != value) 5905 goto error; 5906 } 5907 } 5908 } 5909 if (frvfdpic_pltrel_section (info)) 5910 { 5911 BFD_ASSERT (frvfdpic_pltrel_section (info)->size 5912 == (frvfdpic_pltrel_section (info)->reloc_count 5913 * sizeof (Elf32_External_Rel))); 5914 } 5915 5916 5917 if (elf_hash_table (info)->dynamic_sections_created) 5918 { 5919 Elf32_External_Dyn * dyncon; 5920 Elf32_External_Dyn * dynconend; 5921 5922 sdyn = bfd_get_section_by_name (dynobj, ".dynamic"); 5923 5924 BFD_ASSERT (sdyn != NULL); 5925 5926 dyncon = (Elf32_External_Dyn *) sdyn->contents; 5927 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size); 5928 5929 for (; dyncon < dynconend; dyncon++) 5930 { 5931 Elf_Internal_Dyn dyn; 5932 5933 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn); 5934 5935 switch (dyn.d_tag) 5936 { 5937 default: 5938 break; 5939 5940 case DT_PLTGOT: 5941 dyn.d_un.d_ptr = frvfdpic_got_section (info)->output_section->vma 5942 + frvfdpic_got_section (info)->output_offset 5943 + frvfdpic_got_initial_offset (info); 5944 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 5945 break; 5946 5947 case DT_JMPREL: 5948 dyn.d_un.d_ptr = frvfdpic_pltrel_section (info) 5949 ->output_section->vma 5950 + frvfdpic_pltrel_section (info)->output_offset; 5951 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 5952 break; 5953 5954 case DT_PLTRELSZ: 5955 dyn.d_un.d_val = frvfdpic_pltrel_section (info)->size; 5956 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon); 5957 break; 5958 } 5959 } 5960 } 5961 5962 return TRUE; 5963 } 5964 5965 /* Adjust a symbol defined by a dynamic object and referenced by a 5966 regular object. */ 5967 5968 static bfd_boolean 5969 elf32_frvfdpic_adjust_dynamic_symbol 5970 (struct bfd_link_info *info ATTRIBUTE_UNUSED, 5971 struct elf_link_hash_entry *h ATTRIBUTE_UNUSED) 5972 { 5973 bfd * dynobj; 5974 5975 dynobj = elf_hash_table (info)->dynobj; 5976 5977 /* Make sure we know what is going on here. */ 5978 BFD_ASSERT (dynobj != NULL 5979 && (h->u.weakdef != NULL 5980 || (h->def_dynamic 5981 && h->ref_regular 5982 && !h->def_regular))); 5983 5984 /* If this is a weak symbol, and there is a real definition, the 5985 processor independent code will have arranged for us to see the 5986 real definition first, and we can just use the same value. */ 5987 if (h->u.weakdef != NULL) 5988 { 5989 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined 5990 || h->u.weakdef->root.type == bfd_link_hash_defweak); 5991 h->root.u.def.section = h->u.weakdef->root.u.def.section; 5992 h->root.u.def.value = h->u.weakdef->root.u.def.value; 5993 } 5994 5995 return TRUE; 5996 } 5997 5998 /* Perform any actions needed for dynamic symbols. */ 5999 6000 static bfd_boolean 6001 elf32_frvfdpic_finish_dynamic_symbol 6002 (bfd *output_bfd ATTRIBUTE_UNUSED, 6003 struct bfd_link_info *info ATTRIBUTE_UNUSED, 6004 struct elf_link_hash_entry *h ATTRIBUTE_UNUSED, 6005 Elf_Internal_Sym *sym ATTRIBUTE_UNUSED) 6006 { 6007 return TRUE; 6008 } 6009 6010 /* Decide whether to attempt to turn absptr or lsda encodings in 6011 shared libraries into pcrel within the given input section. */ 6012 6013 static bfd_boolean 6014 frvfdpic_elf_use_relative_eh_frame 6015 (bfd *input_bfd ATTRIBUTE_UNUSED, 6016 struct bfd_link_info *info ATTRIBUTE_UNUSED, 6017 asection *eh_frame_section ATTRIBUTE_UNUSED) 6018 { 6019 /* We can't use PC-relative encodings in FDPIC binaries, in general. */ 6020 return FALSE; 6021 } 6022 6023 /* Adjust the contents of an eh_frame_hdr section before they're output. */ 6024 6025 static bfd_byte 6026 frvfdpic_elf_encode_eh_address (bfd *abfd, 6027 struct bfd_link_info *info, 6028 asection *osec, bfd_vma offset, 6029 asection *loc_sec, bfd_vma loc_offset, 6030 bfd_vma *encoded) 6031 { 6032 struct elf_link_hash_entry *h; 6033 6034 h = elf_hash_table (info)->hgot; 6035 BFD_ASSERT (h && h->root.type == bfd_link_hash_defined); 6036 6037 if (! h || (_frvfdpic_osec_to_segment (abfd, osec) 6038 == _frvfdpic_osec_to_segment (abfd, loc_sec->output_section))) 6039 return _bfd_elf_encode_eh_address (abfd, info, osec, offset, 6040 loc_sec, loc_offset, encoded); 6041 6042 BFD_ASSERT (_frvfdpic_osec_to_segment (abfd, osec) 6043 == (_frvfdpic_osec_to_segment 6044 (abfd, h->root.u.def.section->output_section))); 6045 6046 *encoded = osec->vma + offset 6047 - (h->root.u.def.value 6048 + h->root.u.def.section->output_section->vma 6049 + h->root.u.def.section->output_offset); 6050 6051 return DW_EH_PE_datarel | DW_EH_PE_sdata4; 6052 } 6053 6054 /* Look through the relocs for a section during the first phase. 6055 6056 Besides handling virtual table relocs for gc, we have to deal with 6057 all sorts of PIC-related relocations. We describe below the 6058 general plan on how to handle such relocations, even though we only 6059 collect information at this point, storing them in hash tables for 6060 perusal of later passes. 6061 6062 32 relocations are propagated to the linker output when creating 6063 position-independent output. LO16 and HI16 relocations are not 6064 supposed to be encountered in this case. 6065 6066 LABEL16 should always be resolvable by the linker, since it's only 6067 used by branches. 6068 6069 LABEL24, on the other hand, is used by calls. If it turns out that 6070 the target of a call is a dynamic symbol, a PLT entry must be 6071 created for it, which triggers the creation of a private function 6072 descriptor and, unless lazy binding is disabled, a lazy PLT entry. 6073 6074 GPREL relocations require the referenced symbol to be in the same 6075 segment as _gp, but this can only be checked later. 6076 6077 All GOT, GOTOFF and FUNCDESC relocations require a .got section to 6078 exist. LABEL24 might as well, since it may require a PLT entry, 6079 that will require a got. 6080 6081 Non-FUNCDESC GOT relocations require a GOT entry to be created 6082 regardless of whether the symbol is dynamic. However, since a 6083 global symbol that turns out to not be exported may have the same 6084 address of a non-dynamic symbol, we don't assign GOT entries at 6085 this point, such that we can share them in this case. A relocation 6086 for the GOT entry always has to be created, be it to offset a 6087 private symbol by the section load address, be it to get the symbol 6088 resolved dynamically. 6089 6090 FUNCDESC GOT relocations require a GOT entry to be created, and 6091 handled as if a FUNCDESC relocation was applied to the GOT entry in 6092 an object file. 6093 6094 FUNCDESC relocations referencing a symbol that turns out to NOT be 6095 dynamic cause a private function descriptor to be created. The 6096 FUNCDESC relocation then decays to a 32 relocation that points at 6097 the private descriptor. If the symbol is dynamic, the FUNCDESC 6098 relocation is propagated to the linker output, such that the 6099 dynamic linker creates the canonical descriptor, pointing to the 6100 dynamically-resolved definition of the function. 6101 6102 Non-FUNCDESC GOTOFF relocations must always refer to non-dynamic 6103 symbols that are assigned to the same segment as the GOT, but we 6104 can only check this later, after we know the complete set of 6105 symbols defined and/or exported. 6106 6107 FUNCDESC GOTOFF relocations require a function descriptor to be 6108 created and, unless lazy binding is disabled or the symbol is not 6109 dynamic, a lazy PLT entry. Since we can't tell at this point 6110 whether a symbol is going to be dynamic, we have to decide later 6111 whether to create a lazy PLT entry or bind the descriptor directly 6112 to the private function. 6113 6114 FUNCDESC_VALUE relocations are not supposed to be present in object 6115 files, but they may very well be simply propagated to the linker 6116 output, since they have no side effect. 6117 6118 6119 A function descriptor always requires a FUNCDESC_VALUE relocation. 6120 Whether it's in .plt.rel or not depends on whether lazy binding is 6121 enabled and on whether the referenced symbol is dynamic. 6122 6123 The existence of a lazy PLT requires the resolverStub lazy PLT 6124 entry to be present. 6125 6126 6127 As for assignment of GOT, PLT and lazy PLT entries, and private 6128 descriptors, we might do them all sequentially, but we can do 6129 better than that. For example, we can place GOT entries and 6130 private function descriptors referenced using 12-bit operands 6131 closer to the PIC register value, such that these relocations don't 6132 overflow. Those that are only referenced with LO16 relocations 6133 could come next, but we may as well place PLT-required function 6134 descriptors in the 12-bit range to make them shorter. Symbols 6135 referenced with LO16/HI16 may come next, but we may place 6136 additional function descriptors in the 16-bit range if we can 6137 reliably tell that we've already placed entries that are ever 6138 referenced with only LO16. PLT entries are therefore generated as 6139 small as possible, while not introducing relocation overflows in 6140 GOT or FUNCDESC_GOTOFF relocations. Lazy PLT entries could be 6141 generated before or after PLT entries, but not intermingled with 6142 them, such that we can have more lazy PLT entries in range for a 6143 branch to the resolverStub. The resolverStub should be emitted at 6144 the most distant location from the first lazy PLT entry such that 6145 it's still in range for a branch, or closer, if there isn't a need 6146 for so many lazy PLT entries. Additional lazy PLT entries may be 6147 emitted after the resolverStub, as long as branches are still in 6148 range. If the branch goes out of range, longer lazy PLT entries 6149 are emitted. 6150 6151 We could further optimize PLT and lazy PLT entries by giving them 6152 priority in assignment to closer-to-gr17 locations depending on the 6153 number of occurrences of references to them (assuming a function 6154 that's called more often is more important for performance, so its 6155 PLT entry should be faster), or taking hints from the compiler. 6156 Given infinite time and money... :-) */ 6157 6158 static bfd_boolean 6159 elf32_frv_check_relocs (abfd, info, sec, relocs) 6160 bfd *abfd; 6161 struct bfd_link_info *info; 6162 asection *sec; 6163 const Elf_Internal_Rela *relocs; 6164 { 6165 Elf_Internal_Shdr *symtab_hdr; 6166 struct elf_link_hash_entry **sym_hashes; 6167 const Elf_Internal_Rela *rel; 6168 const Elf_Internal_Rela *rel_end; 6169 bfd *dynobj; 6170 struct frvfdpic_relocs_info *picrel; 6171 6172 if (info->relocatable) 6173 return TRUE; 6174 6175 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 6176 sym_hashes = elf_sym_hashes (abfd); 6177 6178 dynobj = elf_hash_table (info)->dynobj; 6179 rel_end = relocs + sec->reloc_count; 6180 for (rel = relocs; rel < rel_end; rel++) 6181 { 6182 struct elf_link_hash_entry *h; 6183 unsigned long r_symndx; 6184 6185 r_symndx = ELF32_R_SYM (rel->r_info); 6186 if (r_symndx < symtab_hdr->sh_info) 6187 h = NULL; 6188 else 6189 { 6190 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 6191 while (h->root.type == bfd_link_hash_indirect 6192 || h->root.type == bfd_link_hash_warning) 6193 h = (struct elf_link_hash_entry *) h->root.u.i.link; 6194 } 6195 6196 switch (ELF32_R_TYPE (rel->r_info)) 6197 { 6198 case R_FRV_GETTLSOFF: 6199 case R_FRV_TLSDESC_VALUE: 6200 case R_FRV_GOTTLSDESC12: 6201 case R_FRV_GOTTLSDESCHI: 6202 case R_FRV_GOTTLSDESCLO: 6203 case R_FRV_GOTTLSOFF12: 6204 case R_FRV_GOTTLSOFFHI: 6205 case R_FRV_GOTTLSOFFLO: 6206 case R_FRV_TLSOFF: 6207 case R_FRV_GOT12: 6208 case R_FRV_GOTHI: 6209 case R_FRV_GOTLO: 6210 case R_FRV_FUNCDESC_GOT12: 6211 case R_FRV_FUNCDESC_GOTHI: 6212 case R_FRV_FUNCDESC_GOTLO: 6213 case R_FRV_GOTOFF12: 6214 case R_FRV_GOTOFFHI: 6215 case R_FRV_GOTOFFLO: 6216 case R_FRV_FUNCDESC_GOTOFF12: 6217 case R_FRV_FUNCDESC_GOTOFFHI: 6218 case R_FRV_FUNCDESC_GOTOFFLO: 6219 case R_FRV_FUNCDESC: 6220 case R_FRV_FUNCDESC_VALUE: 6221 case R_FRV_TLSMOFF12: 6222 case R_FRV_TLSMOFFHI: 6223 case R_FRV_TLSMOFFLO: 6224 case R_FRV_TLSMOFF: 6225 if (! IS_FDPIC (abfd)) 6226 goto bad_reloc; 6227 /* Fall through. */ 6228 case R_FRV_GPREL12: 6229 case R_FRV_GPRELU12: 6230 case R_FRV_GPRELHI: 6231 case R_FRV_GPRELLO: 6232 case R_FRV_LABEL24: 6233 case R_FRV_32: 6234 if (! dynobj) 6235 { 6236 elf_hash_table (info)->dynobj = dynobj = abfd; 6237 if (! _frv_create_got_section (abfd, info)) 6238 return FALSE; 6239 } 6240 if (! IS_FDPIC (abfd)) 6241 { 6242 picrel = NULL; 6243 break; 6244 } 6245 if (h != NULL) 6246 { 6247 if (h->dynindx == -1) 6248 switch (ELF_ST_VISIBILITY (h->other)) 6249 { 6250 case STV_INTERNAL: 6251 case STV_HIDDEN: 6252 break; 6253 default: 6254 bfd_elf_link_record_dynamic_symbol (info, h); 6255 break; 6256 } 6257 picrel 6258 = frvfdpic_relocs_info_for_global (frvfdpic_relocs_info (info), 6259 abfd, h, 6260 rel->r_addend, INSERT); 6261 } 6262 else 6263 picrel = frvfdpic_relocs_info_for_local (frvfdpic_relocs_info 6264 (info), abfd, r_symndx, 6265 rel->r_addend, INSERT); 6266 if (! picrel) 6267 return FALSE; 6268 break; 6269 6270 default: 6271 picrel = NULL; 6272 break; 6273 } 6274 6275 switch (ELF32_R_TYPE (rel->r_info)) 6276 { 6277 case R_FRV_LABEL24: 6278 if (IS_FDPIC (abfd)) 6279 picrel->call = 1; 6280 break; 6281 6282 case R_FRV_FUNCDESC_VALUE: 6283 picrel->relocsfdv++; 6284 if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC) 6285 picrel->relocs32--; 6286 /* Fall through. */ 6287 6288 case R_FRV_32: 6289 if (! IS_FDPIC (abfd)) 6290 break; 6291 6292 picrel->sym = 1; 6293 if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC) 6294 picrel->relocs32++; 6295 break; 6296 6297 case R_FRV_GOT12: 6298 picrel->got12 = 1; 6299 break; 6300 6301 case R_FRV_GOTHI: 6302 case R_FRV_GOTLO: 6303 picrel->gothilo = 1; 6304 break; 6305 6306 case R_FRV_FUNCDESC_GOT12: 6307 picrel->fdgot12 = 1; 6308 break; 6309 6310 case R_FRV_FUNCDESC_GOTHI: 6311 case R_FRV_FUNCDESC_GOTLO: 6312 picrel->fdgothilo = 1; 6313 break; 6314 6315 case R_FRV_GOTOFF12: 6316 case R_FRV_GOTOFFHI: 6317 case R_FRV_GOTOFFLO: 6318 picrel->gotoff = 1; 6319 break; 6320 6321 case R_FRV_FUNCDESC_GOTOFF12: 6322 picrel->fdgoff12 = 1; 6323 break; 6324 6325 case R_FRV_FUNCDESC_GOTOFFHI: 6326 case R_FRV_FUNCDESC_GOTOFFLO: 6327 picrel->fdgoffhilo = 1; 6328 break; 6329 6330 case R_FRV_FUNCDESC: 6331 picrel->fd = 1; 6332 picrel->relocsfd++; 6333 break; 6334 6335 case R_FRV_GETTLSOFF: 6336 picrel->tlsplt = 1; 6337 break; 6338 6339 case R_FRV_TLSDESC_VALUE: 6340 picrel->relocstlsd++; 6341 goto bad_reloc; 6342 6343 case R_FRV_GOTTLSDESC12: 6344 picrel->tlsdesc12 = 1; 6345 break; 6346 6347 case R_FRV_GOTTLSDESCHI: 6348 case R_FRV_GOTTLSDESCLO: 6349 picrel->tlsdeschilo = 1; 6350 break; 6351 6352 case R_FRV_TLSMOFF12: 6353 case R_FRV_TLSMOFFHI: 6354 case R_FRV_TLSMOFFLO: 6355 case R_FRV_TLSMOFF: 6356 break; 6357 6358 case R_FRV_GOTTLSOFF12: 6359 picrel->tlsoff12 = 1; 6360 info->flags |= DF_STATIC_TLS; 6361 break; 6362 6363 case R_FRV_GOTTLSOFFHI: 6364 case R_FRV_GOTTLSOFFLO: 6365 picrel->tlsoffhilo = 1; 6366 info->flags |= DF_STATIC_TLS; 6367 break; 6368 6369 case R_FRV_TLSOFF: 6370 picrel->relocstlsoff++; 6371 info->flags |= DF_STATIC_TLS; 6372 goto bad_reloc; 6373 6374 /* This relocation describes the C++ object vtable hierarchy. 6375 Reconstruct it for later use during GC. */ 6376 case R_FRV_GNU_VTINHERIT: 6377 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset)) 6378 return FALSE; 6379 break; 6380 6381 /* This relocation describes which C++ vtable entries are actually 6382 used. Record for later use during GC. */ 6383 case R_FRV_GNU_VTENTRY: 6384 BFD_ASSERT (h != NULL); 6385 if (h != NULL 6386 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend)) 6387 return FALSE; 6388 break; 6389 6390 case R_FRV_LABEL16: 6391 case R_FRV_LO16: 6392 case R_FRV_HI16: 6393 case R_FRV_GPREL12: 6394 case R_FRV_GPRELU12: 6395 case R_FRV_GPREL32: 6396 case R_FRV_GPRELHI: 6397 case R_FRV_GPRELLO: 6398 case R_FRV_TLSDESC_RELAX: 6399 case R_FRV_GETTLSOFF_RELAX: 6400 case R_FRV_TLSOFF_RELAX: 6401 break; 6402 6403 default: 6404 bad_reloc: 6405 (*_bfd_error_handler) 6406 (_("%B: unsupported relocation type %i"), 6407 abfd, ELF32_R_TYPE (rel->r_info)); 6408 return FALSE; 6409 } 6410 } 6411 6412 return TRUE; 6413 } 6414 6415 6416 /* Return the machine subcode from the ELF e_flags header. */ 6417 6418 static int 6419 elf32_frv_machine (abfd) 6420 bfd *abfd; 6421 { 6422 switch (elf_elfheader (abfd)->e_flags & EF_FRV_CPU_MASK) 6423 { 6424 default: break; 6425 case EF_FRV_CPU_FR550: return bfd_mach_fr550; 6426 case EF_FRV_CPU_FR500: return bfd_mach_fr500; 6427 case EF_FRV_CPU_FR450: return bfd_mach_fr450; 6428 case EF_FRV_CPU_FR405: return bfd_mach_fr400; 6429 case EF_FRV_CPU_FR400: return bfd_mach_fr400; 6430 case EF_FRV_CPU_FR300: return bfd_mach_fr300; 6431 case EF_FRV_CPU_SIMPLE: return bfd_mach_frvsimple; 6432 case EF_FRV_CPU_TOMCAT: return bfd_mach_frvtomcat; 6433 } 6434 6435 return bfd_mach_frv; 6436 } 6437 6438 /* Set the right machine number for a FRV ELF file. */ 6439 6440 static bfd_boolean 6441 elf32_frv_object_p (abfd) 6442 bfd *abfd; 6443 { 6444 bfd_default_set_arch_mach (abfd, bfd_arch_frv, elf32_frv_machine (abfd)); 6445 return (((elf_elfheader (abfd)->e_flags & EF_FRV_FDPIC) != 0) 6446 == (IS_FDPIC (abfd))); 6447 } 6448 6449 /* Function to set the ELF flag bits. */ 6450 6451 static bfd_boolean 6452 frv_elf_set_private_flags (abfd, flags) 6453 bfd *abfd; 6454 flagword flags; 6455 { 6456 elf_elfheader (abfd)->e_flags = flags; 6457 elf_flags_init (abfd) = TRUE; 6458 return TRUE; 6459 } 6460 6461 /* Copy backend specific data from one object module to another. */ 6462 6463 static bfd_boolean 6464 frv_elf_copy_private_bfd_data (ibfd, obfd) 6465 bfd *ibfd; 6466 bfd *obfd; 6467 { 6468 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour 6469 || bfd_get_flavour (obfd) != bfd_target_elf_flavour) 6470 return TRUE; 6471 6472 BFD_ASSERT (!elf_flags_init (obfd) 6473 || elf_elfheader (obfd)->e_flags == elf_elfheader (ibfd)->e_flags); 6474 6475 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags; 6476 elf_flags_init (obfd) = TRUE; 6477 6478 /* Copy object attributes. */ 6479 _bfd_elf_copy_obj_attributes (ibfd, obfd); 6480 6481 return TRUE; 6482 } 6483 6484 /* Return true if the architecture described by elf header flag 6485 EXTENSION is an extension of the architecture described by BASE. */ 6486 6487 static bfd_boolean 6488 frv_elf_arch_extension_p (flagword base, flagword extension) 6489 { 6490 if (base == extension) 6491 return TRUE; 6492 6493 /* CPU_GENERIC code can be merged with code for a specific 6494 architecture, in which case the result is marked as being 6495 for the specific architecture. Everything is therefore 6496 an extension of CPU_GENERIC. */ 6497 if (base == EF_FRV_CPU_GENERIC) 6498 return TRUE; 6499 6500 if (extension == EF_FRV_CPU_FR450) 6501 if (base == EF_FRV_CPU_FR400 || base == EF_FRV_CPU_FR405) 6502 return TRUE; 6503 6504 if (extension == EF_FRV_CPU_FR405) 6505 if (base == EF_FRV_CPU_FR400) 6506 return TRUE; 6507 6508 return FALSE; 6509 } 6510 6511 static bfd_boolean 6512 elf32_frvfdpic_copy_private_bfd_data (bfd *ibfd, bfd *obfd) 6513 { 6514 unsigned i; 6515 6516 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour 6517 || bfd_get_flavour (obfd) != bfd_target_elf_flavour) 6518 return TRUE; 6519 6520 if (! frv_elf_copy_private_bfd_data (ibfd, obfd)) 6521 return FALSE; 6522 6523 if (! elf_tdata (ibfd) || ! elf_tdata (ibfd)->phdr 6524 || ! elf_tdata (obfd) || ! elf_tdata (obfd)->phdr) 6525 return TRUE; 6526 6527 /* Copy the stack size. */ 6528 for (i = 0; i < elf_elfheader (ibfd)->e_phnum; i++) 6529 if (elf_tdata (ibfd)->phdr[i].p_type == PT_GNU_STACK) 6530 { 6531 Elf_Internal_Phdr *iphdr = &elf_tdata (ibfd)->phdr[i]; 6532 6533 for (i = 0; i < elf_elfheader (obfd)->e_phnum; i++) 6534 if (elf_tdata (obfd)->phdr[i].p_type == PT_GNU_STACK) 6535 { 6536 memcpy (&elf_tdata (obfd)->phdr[i], iphdr, sizeof (*iphdr)); 6537 6538 /* Rewrite the phdrs, since we're only called after they 6539 were first written. */ 6540 if (bfd_seek (obfd, (bfd_signed_vma) get_elf_backend_data (obfd) 6541 ->s->sizeof_ehdr, SEEK_SET) != 0 6542 || get_elf_backend_data (obfd)->s 6543 ->write_out_phdrs (obfd, elf_tdata (obfd)->phdr, 6544 elf_elfheader (obfd)->e_phnum) != 0) 6545 return FALSE; 6546 break; 6547 } 6548 6549 break; 6550 } 6551 6552 return TRUE; 6553 } 6554 6555 /* Merge backend specific data from an object file to the output 6556 object file when linking. */ 6557 6558 static bfd_boolean 6559 frv_elf_merge_private_bfd_data (ibfd, obfd) 6560 bfd *ibfd; 6561 bfd *obfd; 6562 { 6563 flagword old_flags, old_partial; 6564 flagword new_flags, new_partial; 6565 bfd_boolean error = FALSE; 6566 char new_opt[80]; 6567 char old_opt[80]; 6568 6569 new_opt[0] = old_opt[0] = '\0'; 6570 new_flags = elf_elfheader (ibfd)->e_flags; 6571 old_flags = elf_elfheader (obfd)->e_flags; 6572 6573 if (new_flags & EF_FRV_FDPIC) 6574 new_flags &= ~EF_FRV_PIC; 6575 6576 #ifdef DEBUG 6577 (*_bfd_error_handler) ("old_flags = 0x%.8lx, new_flags = 0x%.8lx, init = %s, filename = %s", 6578 old_flags, new_flags, elf_flags_init (obfd) ? "yes" : "no", 6579 bfd_get_filename (ibfd)); 6580 #endif 6581 6582 if (!elf_flags_init (obfd)) /* First call, no flags set. */ 6583 { 6584 elf_flags_init (obfd) = TRUE; 6585 old_flags = new_flags; 6586 } 6587 6588 else if (new_flags == old_flags) /* Compatible flags are ok. */ 6589 ; 6590 6591 else /* Possibly incompatible flags. */ 6592 { 6593 /* Warn if different # of gprs are used. Note, 0 means nothing is 6594 said about the size of gprs. */ 6595 new_partial = (new_flags & EF_FRV_GPR_MASK); 6596 old_partial = (old_flags & EF_FRV_GPR_MASK); 6597 if (new_partial == old_partial) 6598 ; 6599 6600 else if (new_partial == 0) 6601 ; 6602 6603 else if (old_partial == 0) 6604 old_flags |= new_partial; 6605 6606 else 6607 { 6608 switch (new_partial) 6609 { 6610 default: strcat (new_opt, " -mgpr-??"); break; 6611 case EF_FRV_GPR_32: strcat (new_opt, " -mgpr-32"); break; 6612 case EF_FRV_GPR_64: strcat (new_opt, " -mgpr-64"); break; 6613 } 6614 6615 switch (old_partial) 6616 { 6617 default: strcat (old_opt, " -mgpr-??"); break; 6618 case EF_FRV_GPR_32: strcat (old_opt, " -mgpr-32"); break; 6619 case EF_FRV_GPR_64: strcat (old_opt, " -mgpr-64"); break; 6620 } 6621 } 6622 6623 /* Warn if different # of fprs are used. Note, 0 means nothing is 6624 said about the size of fprs. */ 6625 new_partial = (new_flags & EF_FRV_FPR_MASK); 6626 old_partial = (old_flags & EF_FRV_FPR_MASK); 6627 if (new_partial == old_partial) 6628 ; 6629 6630 else if (new_partial == 0) 6631 ; 6632 6633 else if (old_partial == 0) 6634 old_flags |= new_partial; 6635 6636 else 6637 { 6638 switch (new_partial) 6639 { 6640 default: strcat (new_opt, " -mfpr-?"); break; 6641 case EF_FRV_FPR_32: strcat (new_opt, " -mfpr-32"); break; 6642 case EF_FRV_FPR_64: strcat (new_opt, " -mfpr-64"); break; 6643 case EF_FRV_FPR_NONE: strcat (new_opt, " -msoft-float"); break; 6644 } 6645 6646 switch (old_partial) 6647 { 6648 default: strcat (old_opt, " -mfpr-?"); break; 6649 case EF_FRV_FPR_32: strcat (old_opt, " -mfpr-32"); break; 6650 case EF_FRV_FPR_64: strcat (old_opt, " -mfpr-64"); break; 6651 case EF_FRV_FPR_NONE: strcat (old_opt, " -msoft-float"); break; 6652 } 6653 } 6654 6655 /* Warn if different dword support was used. Note, 0 means nothing is 6656 said about the dword support. */ 6657 new_partial = (new_flags & EF_FRV_DWORD_MASK); 6658 old_partial = (old_flags & EF_FRV_DWORD_MASK); 6659 if (new_partial == old_partial) 6660 ; 6661 6662 else if (new_partial == 0) 6663 ; 6664 6665 else if (old_partial == 0) 6666 old_flags |= new_partial; 6667 6668 else 6669 { 6670 switch (new_partial) 6671 { 6672 default: strcat (new_opt, " -mdword-?"); break; 6673 case EF_FRV_DWORD_YES: strcat (new_opt, " -mdword"); break; 6674 case EF_FRV_DWORD_NO: strcat (new_opt, " -mno-dword"); break; 6675 } 6676 6677 switch (old_partial) 6678 { 6679 default: strcat (old_opt, " -mdword-?"); break; 6680 case EF_FRV_DWORD_YES: strcat (old_opt, " -mdword"); break; 6681 case EF_FRV_DWORD_NO: strcat (old_opt, " -mno-dword"); break; 6682 } 6683 } 6684 6685 /* Or in flags that accumulate (ie, if one module uses it, mark that the 6686 feature is used. */ 6687 old_flags |= new_flags & (EF_FRV_DOUBLE 6688 | EF_FRV_MEDIA 6689 | EF_FRV_MULADD 6690 | EF_FRV_NON_PIC_RELOCS); 6691 6692 /* If any module was compiled without -G0, clear the G0 bit. */ 6693 old_flags = ((old_flags & ~ EF_FRV_G0) 6694 | (old_flags & new_flags & EF_FRV_G0)); 6695 6696 /* If any module was compiled without -mnopack, clear the mnopack bit. */ 6697 old_flags = ((old_flags & ~ EF_FRV_NOPACK) 6698 | (old_flags & new_flags & EF_FRV_NOPACK)); 6699 6700 /* We don't have to do anything if the pic flags are the same, or the new 6701 module(s) were compiled with -mlibrary-pic. */ 6702 new_partial = (new_flags & EF_FRV_PIC_FLAGS); 6703 old_partial = (old_flags & EF_FRV_PIC_FLAGS); 6704 if ((new_partial == old_partial) || ((new_partial & EF_FRV_LIBPIC) != 0)) 6705 ; 6706 6707 /* If the old module(s) were compiled with -mlibrary-pic, copy in the pic 6708 flags if any from the new module. */ 6709 else if ((old_partial & EF_FRV_LIBPIC) != 0) 6710 old_flags = (old_flags & ~ EF_FRV_PIC_FLAGS) | new_partial; 6711 6712 /* If we have mixtures of -fpic and -fPIC, or in both bits. */ 6713 else if (new_partial != 0 && old_partial != 0) 6714 old_flags |= new_partial; 6715 6716 /* One module was compiled for pic and the other was not, see if we have 6717 had any relocations that are not pic-safe. */ 6718 else 6719 { 6720 if ((old_flags & EF_FRV_NON_PIC_RELOCS) == 0) 6721 old_flags |= new_partial; 6722 else 6723 { 6724 old_flags &= ~ EF_FRV_PIC_FLAGS; 6725 #ifndef FRV_NO_PIC_ERROR 6726 error = TRUE; 6727 (*_bfd_error_handler) 6728 (_("%s: compiled with %s and linked with modules that use non-pic relocations"), 6729 bfd_get_filename (ibfd), 6730 (new_flags & EF_FRV_BIGPIC) ? "-fPIC" : "-fpic"); 6731 #endif 6732 } 6733 } 6734 6735 /* Warn if different cpu is used (allow a specific cpu to override 6736 the generic cpu). */ 6737 new_partial = (new_flags & EF_FRV_CPU_MASK); 6738 old_partial = (old_flags & EF_FRV_CPU_MASK); 6739 if (frv_elf_arch_extension_p (new_partial, old_partial)) 6740 ; 6741 6742 else if (frv_elf_arch_extension_p (old_partial, new_partial)) 6743 old_flags = (old_flags & ~EF_FRV_CPU_MASK) | new_partial; 6744 6745 else 6746 { 6747 switch (new_partial) 6748 { 6749 default: strcat (new_opt, " -mcpu=?"); break; 6750 case EF_FRV_CPU_GENERIC: strcat (new_opt, " -mcpu=frv"); break; 6751 case EF_FRV_CPU_SIMPLE: strcat (new_opt, " -mcpu=simple"); break; 6752 case EF_FRV_CPU_FR550: strcat (new_opt, " -mcpu=fr550"); break; 6753 case EF_FRV_CPU_FR500: strcat (new_opt, " -mcpu=fr500"); break; 6754 case EF_FRV_CPU_FR450: strcat (new_opt, " -mcpu=fr450"); break; 6755 case EF_FRV_CPU_FR405: strcat (new_opt, " -mcpu=fr405"); break; 6756 case EF_FRV_CPU_FR400: strcat (new_opt, " -mcpu=fr400"); break; 6757 case EF_FRV_CPU_FR300: strcat (new_opt, " -mcpu=fr300"); break; 6758 case EF_FRV_CPU_TOMCAT: strcat (new_opt, " -mcpu=tomcat"); break; 6759 } 6760 6761 switch (old_partial) 6762 { 6763 default: strcat (old_opt, " -mcpu=?"); break; 6764 case EF_FRV_CPU_GENERIC: strcat (old_opt, " -mcpu=frv"); break; 6765 case EF_FRV_CPU_SIMPLE: strcat (old_opt, " -mcpu=simple"); break; 6766 case EF_FRV_CPU_FR550: strcat (old_opt, " -mcpu=fr550"); break; 6767 case EF_FRV_CPU_FR500: strcat (old_opt, " -mcpu=fr500"); break; 6768 case EF_FRV_CPU_FR450: strcat (old_opt, " -mcpu=fr450"); break; 6769 case EF_FRV_CPU_FR405: strcat (old_opt, " -mcpu=fr405"); break; 6770 case EF_FRV_CPU_FR400: strcat (old_opt, " -mcpu=fr400"); break; 6771 case EF_FRV_CPU_FR300: strcat (old_opt, " -mcpu=fr300"); break; 6772 case EF_FRV_CPU_TOMCAT: strcat (old_opt, " -mcpu=tomcat"); break; 6773 } 6774 } 6775 6776 /* Print out any mismatches from above. */ 6777 if (new_opt[0]) 6778 { 6779 error = TRUE; 6780 (*_bfd_error_handler) 6781 (_("%s: compiled with %s and linked with modules compiled with %s"), 6782 bfd_get_filename (ibfd), new_opt, old_opt); 6783 } 6784 6785 /* Warn about any other mismatches */ 6786 new_partial = (new_flags & ~ EF_FRV_ALL_FLAGS); 6787 old_partial = (old_flags & ~ EF_FRV_ALL_FLAGS); 6788 if (new_partial != old_partial) 6789 { 6790 old_flags |= new_partial; 6791 error = TRUE; 6792 (*_bfd_error_handler) 6793 (_("%s: uses different unknown e_flags (0x%lx) fields than previous modules (0x%lx)"), 6794 bfd_get_filename (ibfd), (long)new_partial, (long)old_partial); 6795 } 6796 } 6797 6798 /* If the cpu is -mcpu=simple, then set the -mnopack bit. */ 6799 if ((old_flags & EF_FRV_CPU_MASK) == EF_FRV_CPU_SIMPLE) 6800 old_flags |= EF_FRV_NOPACK; 6801 6802 /* Update the old flags now with changes made above. */ 6803 old_partial = elf_elfheader (obfd)->e_flags & EF_FRV_CPU_MASK; 6804 elf_elfheader (obfd)->e_flags = old_flags; 6805 if (old_partial != (old_flags & EF_FRV_CPU_MASK)) 6806 bfd_default_set_arch_mach (obfd, bfd_arch_frv, elf32_frv_machine (obfd)); 6807 6808 if (((new_flags & EF_FRV_FDPIC) == 0) 6809 != (! IS_FDPIC (ibfd))) 6810 { 6811 error = TRUE; 6812 if (IS_FDPIC (obfd)) 6813 (*_bfd_error_handler) 6814 (_("%s: cannot link non-fdpic object file into fdpic executable"), 6815 bfd_get_filename (ibfd)); 6816 else 6817 (*_bfd_error_handler) 6818 (_("%s: cannot link fdpic object file into non-fdpic executable"), 6819 bfd_get_filename (ibfd)); 6820 } 6821 6822 if (error) 6823 bfd_set_error (bfd_error_bad_value); 6824 6825 return !error; 6826 } 6827 6828 6829 bfd_boolean 6830 frv_elf_print_private_bfd_data (abfd, ptr) 6831 bfd *abfd; 6832 PTR ptr; 6833 { 6834 FILE *file = (FILE *) ptr; 6835 flagword flags; 6836 6837 BFD_ASSERT (abfd != NULL && ptr != NULL); 6838 6839 /* Print normal ELF private data. */ 6840 _bfd_elf_print_private_bfd_data (abfd, ptr); 6841 6842 flags = elf_elfheader (abfd)->e_flags; 6843 fprintf (file, _("private flags = 0x%lx:"), (unsigned long) flags); 6844 6845 switch (flags & EF_FRV_CPU_MASK) 6846 { 6847 default: break; 6848 case EF_FRV_CPU_SIMPLE: fprintf (file, " -mcpu=simple"); break; 6849 case EF_FRV_CPU_FR550: fprintf (file, " -mcpu=fr550"); break; 6850 case EF_FRV_CPU_FR500: fprintf (file, " -mcpu=fr500"); break; 6851 case EF_FRV_CPU_FR450: fprintf (file, " -mcpu=fr450"); break; 6852 case EF_FRV_CPU_FR405: fprintf (file, " -mcpu=fr405"); break; 6853 case EF_FRV_CPU_FR400: fprintf (file, " -mcpu=fr400"); break; 6854 case EF_FRV_CPU_FR300: fprintf (file, " -mcpu=fr300"); break; 6855 case EF_FRV_CPU_TOMCAT: fprintf (file, " -mcpu=tomcat"); break; 6856 } 6857 6858 switch (flags & EF_FRV_GPR_MASK) 6859 { 6860 default: break; 6861 case EF_FRV_GPR_32: fprintf (file, " -mgpr-32"); break; 6862 case EF_FRV_GPR_64: fprintf (file, " -mgpr-64"); break; 6863 } 6864 6865 switch (flags & EF_FRV_FPR_MASK) 6866 { 6867 default: break; 6868 case EF_FRV_FPR_32: fprintf (file, " -mfpr-32"); break; 6869 case EF_FRV_FPR_64: fprintf (file, " -mfpr-64"); break; 6870 case EF_FRV_FPR_NONE: fprintf (file, " -msoft-float"); break; 6871 } 6872 6873 switch (flags & EF_FRV_DWORD_MASK) 6874 { 6875 default: break; 6876 case EF_FRV_DWORD_YES: fprintf (file, " -mdword"); break; 6877 case EF_FRV_DWORD_NO: fprintf (file, " -mno-dword"); break; 6878 } 6879 6880 if (flags & EF_FRV_DOUBLE) 6881 fprintf (file, " -mdouble"); 6882 6883 if (flags & EF_FRV_MEDIA) 6884 fprintf (file, " -mmedia"); 6885 6886 if (flags & EF_FRV_MULADD) 6887 fprintf (file, " -mmuladd"); 6888 6889 if (flags & EF_FRV_PIC) 6890 fprintf (file, " -fpic"); 6891 6892 if (flags & EF_FRV_BIGPIC) 6893 fprintf (file, " -fPIC"); 6894 6895 if (flags & EF_FRV_LIBPIC) 6896 fprintf (file, " -mlibrary-pic"); 6897 6898 if (flags & EF_FRV_FDPIC) 6899 fprintf (file, " -mfdpic"); 6900 6901 if (flags & EF_FRV_NON_PIC_RELOCS) 6902 fprintf (file, " non-pic relocations"); 6903 6904 if (flags & EF_FRV_G0) 6905 fprintf (file, " -G0"); 6906 6907 fputc ('\n', file); 6908 return TRUE; 6909 } 6910 6911 6912 /* Support for core dump NOTE sections. */ 6913 6914 static bfd_boolean 6915 elf32_frv_grok_prstatus (bfd *abfd, Elf_Internal_Note *note) 6916 { 6917 int offset; 6918 unsigned int raw_size; 6919 6920 switch (note->descsz) 6921 { 6922 default: 6923 return FALSE; 6924 6925 /* The Linux/FRV elf_prstatus struct is 268 bytes long. The other 6926 hardcoded offsets and sizes listed below (and contained within 6927 this lexical block) refer to fields in the target's elf_prstatus 6928 struct. */ 6929 case 268: 6930 /* `pr_cursig' is at offset 12. */ 6931 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12); 6932 6933 /* `pr_pid' is at offset 24. */ 6934 elf_tdata (abfd)->core_lwpid = bfd_get_32 (abfd, note->descdata + 24); 6935 6936 /* `pr_reg' is at offset 72. */ 6937 offset = 72; 6938 6939 /* Most grok_prstatus implementations set `raw_size' to the size 6940 of the pr_reg field. For Linux/FRV, we set `raw_size' to be 6941 the size of `pr_reg' plus the size of `pr_exec_fdpic_loadmap' 6942 and `pr_interp_fdpic_loadmap', both of which (by design) 6943 immediately follow `pr_reg'. This will allow these fields to 6944 be viewed by GDB as registers. 6945 6946 `pr_reg' is 184 bytes long. `pr_exec_fdpic_loadmap' and 6947 `pr_interp_fdpic_loadmap' are 4 bytes each. */ 6948 raw_size = 184 + 4 + 4; 6949 6950 break; 6951 } 6952 6953 /* Make a ".reg/999" section. */ 6954 return _bfd_elfcore_make_pseudosection (abfd, ".reg", raw_size, 6955 note->descpos + offset); 6956 } 6957 6958 static bfd_boolean 6959 elf32_frv_grok_psinfo (bfd *abfd, Elf_Internal_Note *note) 6960 { 6961 switch (note->descsz) 6962 { 6963 default: 6964 return FALSE; 6965 6966 /* The Linux/FRV elf_prpsinfo struct is 124 bytes long. */ 6967 case 124: 6968 6969 /* `pr_fname' is found at offset 28 and is 16 bytes long. */ 6970 elf_tdata (abfd)->core_program 6971 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16); 6972 6973 /* `pr_psargs' is found at offset 44 and is 80 bytes long. */ 6974 elf_tdata (abfd)->core_command 6975 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80); 6976 } 6977 6978 /* Note that for some reason, a spurious space is tacked 6979 onto the end of the args in some (at least one anyway) 6980 implementations, so strip it off if it exists. */ 6981 6982 { 6983 char *command = elf_tdata (abfd)->core_command; 6984 int n = strlen (command); 6985 6986 if (0 < n && command[n - 1] == ' ') 6987 command[n - 1] = '\0'; 6988 } 6989 6990 return TRUE; 6991 } 6992 #define ELF_ARCH bfd_arch_frv 6993 #define ELF_TARGET_ID FRV_ELF_DATA 6994 #define ELF_MACHINE_CODE EM_CYGNUS_FRV 6995 #define ELF_MAXPAGESIZE 0x1000 6996 6997 #define TARGET_BIG_SYM bfd_elf32_frv_vec 6998 #define TARGET_BIG_NAME "elf32-frv" 6999 7000 #define elf_info_to_howto frv_info_to_howto_rela 7001 #define elf_backend_relocate_section elf32_frv_relocate_section 7002 #define elf_backend_gc_mark_hook elf32_frv_gc_mark_hook 7003 #define elf_backend_check_relocs elf32_frv_check_relocs 7004 #define elf_backend_object_p elf32_frv_object_p 7005 #define elf_backend_add_symbol_hook elf32_frv_add_symbol_hook 7006 7007 #define elf_backend_can_gc_sections 1 7008 #define elf_backend_rela_normal 1 7009 7010 #define bfd_elf32_bfd_reloc_type_lookup frv_reloc_type_lookup 7011 #define bfd_elf32_bfd_reloc_name_lookup frv_reloc_name_lookup 7012 #define bfd_elf32_bfd_set_private_flags frv_elf_set_private_flags 7013 #define bfd_elf32_bfd_copy_private_bfd_data frv_elf_copy_private_bfd_data 7014 #define bfd_elf32_bfd_merge_private_bfd_data frv_elf_merge_private_bfd_data 7015 #define bfd_elf32_bfd_print_private_bfd_data frv_elf_print_private_bfd_data 7016 7017 #define elf_backend_want_got_sym 1 7018 #define elf_backend_got_header_size 0 7019 #define elf_backend_want_got_plt 0 7020 #define elf_backend_plt_readonly 1 7021 #define elf_backend_want_plt_sym 0 7022 #define elf_backend_plt_header_size 0 7023 7024 #define elf_backend_finish_dynamic_sections \ 7025 elf32_frv_finish_dynamic_sections 7026 7027 #define elf_backend_grok_prstatus elf32_frv_grok_prstatus 7028 #define elf_backend_grok_psinfo elf32_frv_grok_psinfo 7029 7030 #include "elf32-target.h" 7031 7032 #undef ELF_MAXPAGESIZE 7033 #define ELF_MAXPAGESIZE 0x4000 7034 7035 #undef TARGET_BIG_SYM 7036 #define TARGET_BIG_SYM bfd_elf32_frvfdpic_vec 7037 #undef TARGET_BIG_NAME 7038 #define TARGET_BIG_NAME "elf32-frvfdpic" 7039 #undef elf32_bed 7040 #define elf32_bed elf32_frvfdpic_bed 7041 7042 #undef elf_info_to_howto_rel 7043 #define elf_info_to_howto_rel frvfdpic_info_to_howto_rel 7044 7045 #undef bfd_elf32_bfd_link_hash_table_create 7046 #define bfd_elf32_bfd_link_hash_table_create \ 7047 frvfdpic_elf_link_hash_table_create 7048 #undef elf_backend_always_size_sections 7049 #define elf_backend_always_size_sections \ 7050 elf32_frvfdpic_always_size_sections 7051 #undef elf_backend_modify_program_headers 7052 #define elf_backend_modify_program_headers \ 7053 elf32_frvfdpic_modify_program_headers 7054 #undef bfd_elf32_bfd_copy_private_bfd_data 7055 #define bfd_elf32_bfd_copy_private_bfd_data \ 7056 elf32_frvfdpic_copy_private_bfd_data 7057 7058 #undef elf_backend_create_dynamic_sections 7059 #define elf_backend_create_dynamic_sections \ 7060 elf32_frvfdpic_create_dynamic_sections 7061 #undef elf_backend_adjust_dynamic_symbol 7062 #define elf_backend_adjust_dynamic_symbol \ 7063 elf32_frvfdpic_adjust_dynamic_symbol 7064 #undef elf_backend_size_dynamic_sections 7065 #define elf_backend_size_dynamic_sections \ 7066 elf32_frvfdpic_size_dynamic_sections 7067 #undef bfd_elf32_bfd_relax_section 7068 #define bfd_elf32_bfd_relax_section \ 7069 elf32_frvfdpic_relax_section 7070 #undef elf_backend_finish_dynamic_symbol 7071 #define elf_backend_finish_dynamic_symbol \ 7072 elf32_frvfdpic_finish_dynamic_symbol 7073 #undef elf_backend_finish_dynamic_sections 7074 #define elf_backend_finish_dynamic_sections \ 7075 elf32_frvfdpic_finish_dynamic_sections 7076 7077 #undef elf_backend_discard_info 7078 #define elf_backend_discard_info \ 7079 frvfdpic_elf_discard_info 7080 #undef elf_backend_can_make_relative_eh_frame 7081 #define elf_backend_can_make_relative_eh_frame \ 7082 frvfdpic_elf_use_relative_eh_frame 7083 #undef elf_backend_can_make_lsda_relative_eh_frame 7084 #define elf_backend_can_make_lsda_relative_eh_frame \ 7085 frvfdpic_elf_use_relative_eh_frame 7086 #undef elf_backend_encode_eh_address 7087 #define elf_backend_encode_eh_address \ 7088 frvfdpic_elf_encode_eh_address 7089 7090 #undef elf_backend_may_use_rel_p 7091 #define elf_backend_may_use_rel_p 1 7092 #undef elf_backend_may_use_rela_p 7093 #define elf_backend_may_use_rela_p 1 7094 /* We use REL for dynamic relocations only. */ 7095 #undef elf_backend_default_use_rela_p 7096 #define elf_backend_default_use_rela_p 1 7097 7098 #undef elf_backend_omit_section_dynsym 7099 #define elf_backend_omit_section_dynsym _frvfdpic_link_omit_section_dynsym 7100 7101 #include "elf32-target.h" 7102