1 /* TILE-Gx-specific support for ELF. 2 Copyright (C) 2011-2025 Free Software Foundation, Inc. 3 4 This file is part of BFD, the Binary File Descriptor library. 5 6 This program is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 3 of the License, or 9 (at your option) any later version. 10 11 This program is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program; if not, write to the Free Software 18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, 19 MA 02110-1301, USA. */ 20 21 #include "sysdep.h" 22 #include "bfd.h" 23 #include "libbfd.h" 24 #include "elf-bfd.h" 25 #include "elf/tilegx.h" 26 #include "opcode/tilegx.h" 27 #include "libiberty.h" 28 #include "elfxx-tilegx.h" 29 30 #define ABI_64_P(abfd) \ 31 (get_elf_backend_data (abfd)->s->elfclass == ELFCLASS64) 32 33 #define TILEGX_ELF_WORD_BYTES(htab) \ 34 ((htab)->bytes_per_word) 35 36 /* The size of an external RELA relocation. */ 37 #define TILEGX_ELF_RELA_BYTES(htab) \ 38 ((htab)->bytes_per_rela) 39 40 /* Both 32-bit and 64-bit tilegx encode this in an identical manner, 41 so just take advantage of that. */ 42 #define TILEGX_ELF_R_TYPE(r_info) \ 43 ((r_info) & 0xFF) 44 45 #define TILEGX_ELF_R_INFO(htab, in_rel, index, type) \ 46 ((htab)->r_info (in_rel, index, type)) 47 48 #define TILEGX_ELF_R_SYMNDX(htab, r_info) \ 49 ((htab)->r_symndx(r_info)) 50 51 #define TILEGX_ELF_DTPOFF_RELOC(htab) \ 52 ((htab)->dtpoff_reloc) 53 54 #define TILEGX_ELF_DTPMOD_RELOC(htab) \ 55 ((htab)->dtpmod_reloc) 56 57 #define TILEGX_ELF_TPOFF_RELOC(htab) \ 58 ((htab)->tpoff_reloc) 59 60 #define TILEGX_ELF_PUT_WORD(htab, bfd, val, ptr) \ 61 ((htab)->put_word (bfd, val, ptr)) 62 63 /* The name of the dynamic interpreter. This is put in the .interp 64 section. */ 65 66 #define ELF64_DYNAMIC_INTERPRETER "/lib/ld.so.1" 67 #define ELF32_DYNAMIC_INTERPRETER "/lib32/ld.so.1" 68 69 70 static reloc_howto_type tilegx_elf_howto_table [] = 71 { 72 /* This reloc does nothing. */ 73 HOWTO (R_TILEGX_NONE, /* type */ 74 0, /* rightshift */ 75 0, /* size */ 76 0, /* bitsize */ 77 false, /* pc_relative */ 78 0, /* bitpos */ 79 complain_overflow_dont, /* complain_on_overflow */ 80 bfd_elf_generic_reloc, /* special_function */ 81 "R_TILEGX_NONE", /* name */ 82 false, /* partial_inplace */ 83 0, /* src_mask */ 84 0, /* dst_mask */ 85 false), /* pcrel_offset */ 86 #ifdef BFD64 87 /* A 64 bit absolute relocation. */ 88 HOWTO (R_TILEGX_64, /* type */ 89 0, /* rightshift */ 90 8, /* size */ 91 64, /* bitsize */ 92 false, /* pc_relative */ 93 0, /* bitpos */ 94 complain_overflow_dont, /* complain_on_overflow */ 95 bfd_elf_generic_reloc, /* special_function */ 96 "R_TILEGX_64", /* name */ 97 false, /* partial_inplace */ 98 0, /* src_mask */ 99 0xffffffffffffffffULL, /* dst_mask */ 100 false), /* pcrel_offset */ 101 #endif 102 /* A 32 bit absolute relocation. */ 103 HOWTO (R_TILEGX_32, /* type */ 104 0, /* rightshift */ 105 4, /* size */ 106 32, /* bitsize */ 107 false, /* pc_relative */ 108 0, /* bitpos */ 109 complain_overflow_dont, /* complain_on_overflow */ 110 bfd_elf_generic_reloc, /* special_function */ 111 "R_TILEGX_32", /* name */ 112 false, /* partial_inplace */ 113 0, /* src_mask */ 114 0xffffffff, /* dst_mask */ 115 false), /* pcrel_offset */ 116 117 /* A 16 bit absolute relocation. */ 118 HOWTO (R_TILEGX_16, /* type */ 119 0, /* rightshift */ 120 2, /* size */ 121 16, /* bitsize */ 122 false, /* pc_relative */ 123 0, /* bitpos */ 124 complain_overflow_bitfield, /* complain_on_overflow */ 125 bfd_elf_generic_reloc, /* special_function */ 126 "R_TILEGX_16", /* name */ 127 false, /* partial_inplace */ 128 0, /* src_mask */ 129 0xffff, /* dst_mask */ 130 false), /* pcrel_offset */ 131 132 /* An 8 bit absolute relocation. */ 133 HOWTO (R_TILEGX_8, /* type */ 134 0, /* rightshift */ 135 1, /* size */ 136 8, /* bitsize */ 137 false, /* pc_relative */ 138 0, /* bitpos */ 139 complain_overflow_unsigned, /* complain_on_overflow */ 140 bfd_elf_generic_reloc, /* special_function */ 141 "R_TILEGX_8", /* name */ 142 false, /* partial_inplace */ 143 0, /* src_mask */ 144 0xff, /* dst_mask */ 145 false), /* pcrel_offset */ 146 #ifdef BFD64 147 /* A 64 bit pc-relative relocation. */ 148 HOWTO (R_TILEGX_64_PCREL,/* type */ 149 0, /* rightshift */ 150 8, /* size */ 151 64, /* bitsize */ 152 true, /* pc_relative */ 153 0, /* bitpos */ 154 complain_overflow_dont, /* complain_on_overflow */ 155 bfd_elf_generic_reloc, /* special_function */ 156 "R_TILEGX_32_PCREL", /* name */ 157 false, /* partial_inplace */ 158 0, /* src_mask */ 159 0xffffffffffffffffULL, /* dst_mask */ 160 true), /* pcrel_offset */ 161 #endif 162 /* A 32 bit pc-relative relocation. */ 163 HOWTO (R_TILEGX_32_PCREL,/* type */ 164 0, /* rightshift */ 165 4, /* size */ 166 32, /* bitsize */ 167 true, /* pc_relative */ 168 0, /* bitpos */ 169 complain_overflow_dont, /* complain_on_overflow */ 170 bfd_elf_generic_reloc, /* special_function */ 171 "R_TILEGX_32_PCREL", /* name */ 172 false, /* partial_inplace */ 173 0, /* src_mask */ 174 0xffffffff, /* dst_mask */ 175 true), /* pcrel_offset */ 176 177 /* A 16 bit pc-relative relocation. */ 178 HOWTO (R_TILEGX_16_PCREL,/* type */ 179 0, /* rightshift */ 180 2, /* size */ 181 16, /* bitsize */ 182 true, /* pc_relative */ 183 0, /* bitpos */ 184 complain_overflow_signed, /* complain_on_overflow */ 185 bfd_elf_generic_reloc, /* special_function */ 186 "R_TILEGX_16_PCREL", /* name */ 187 false, /* partial_inplace */ 188 0, /* src_mask */ 189 0xffff, /* dst_mask */ 190 true), /* pcrel_offset */ 191 192 /* An 8 bit pc-relative relocation. */ 193 HOWTO (R_TILEGX_8_PCREL, /* type */ 194 0, /* rightshift */ 195 1, /* size */ 196 8, /* bitsize */ 197 true, /* pc_relative */ 198 0, /* bitpos */ 199 complain_overflow_signed, /* complain_on_overflow */ 200 bfd_elf_generic_reloc, /* special_function */ 201 "R_TILEGX_8_PCREL",/* name */ 202 false, /* partial_inplace */ 203 0, /* src_mask */ 204 0xff, /* dst_mask */ 205 true), /* pcrel_offset */ 206 207 /* A 16 bit relocation without overflow. */ 208 HOWTO (R_TILEGX_HW0, /* type */ 209 0, /* rightshift */ 210 2, /* size */ 211 16, /* bitsize */ 212 false, /* pc_relative */ 213 0, /* bitpos */ 214 complain_overflow_dont,/* complain_on_overflow */ 215 bfd_elf_generic_reloc, /* special_function */ 216 "R_TILEGX_HW0", /* name */ 217 false, /* partial_inplace */ 218 0, /* src_mask */ 219 0xffff, /* dst_mask */ 220 false), /* pcrel_offset */ 221 222 /* A 16 bit relocation without overflow. */ 223 HOWTO (R_TILEGX_HW1, /* type */ 224 16, /* rightshift */ 225 2, /* size */ 226 16, /* bitsize */ 227 false, /* pc_relative */ 228 0, /* bitpos */ 229 complain_overflow_dont,/* complain_on_overflow */ 230 bfd_elf_generic_reloc, /* special_function */ 231 "R_TILEGX_HW1", /* name */ 232 false, /* partial_inplace */ 233 0, /* src_mask */ 234 0xffff, /* dst_mask */ 235 false), /* pcrel_offset */ 236 237 /* A 16 bit relocation without overflow. */ 238 HOWTO (R_TILEGX_HW2, /* type */ 239 32, /* rightshift */ 240 2, /* size */ 241 16, /* bitsize */ 242 false, /* pc_relative */ 243 0, /* bitpos */ 244 complain_overflow_dont,/* complain_on_overflow */ 245 bfd_elf_generic_reloc, /* special_function */ 246 "R_TILEGX_HW2", /* name */ 247 false, /* partial_inplace */ 248 0, /* src_mask */ 249 0xffff, /* dst_mask */ 250 false), /* pcrel_offset */ 251 252 /* A 16 bit relocation without overflow. */ 253 HOWTO (R_TILEGX_HW3, /* type */ 254 48, /* rightshift */ 255 2, /* size */ 256 16, /* bitsize */ 257 false, /* pc_relative */ 258 0, /* bitpos */ 259 complain_overflow_dont,/* complain_on_overflow */ 260 bfd_elf_generic_reloc, /* special_function */ 261 "R_TILEGX_HW3", /* name */ 262 false, /* partial_inplace */ 263 0, /* src_mask */ 264 0xffff, /* dst_mask */ 265 false), /* pcrel_offset */ 266 267 /* A 16 bit relocation with overflow. */ 268 HOWTO (R_TILEGX_HW0_LAST, /* type */ 269 0, /* rightshift */ 270 2, /* size */ 271 16, /* bitsize */ 272 false, /* pc_relative */ 273 0, /* bitpos */ 274 complain_overflow_signed,/* complain_on_overflow */ 275 bfd_elf_generic_reloc, /* special_function */ 276 "R_TILEGX_HW0_LAST", /* name */ 277 false, /* partial_inplace */ 278 0, /* src_mask */ 279 0xffff, /* dst_mask */ 280 false), /* pcrel_offset */ 281 282 /* A 16 bit relocation with overflow. */ 283 HOWTO (R_TILEGX_HW1_LAST, /* type */ 284 16, /* rightshift */ 285 2, /* size */ 286 16, /* bitsize */ 287 false, /* pc_relative */ 288 0, /* bitpos */ 289 complain_overflow_signed,/* complain_on_overflow */ 290 bfd_elf_generic_reloc, /* special_function */ 291 "R_TILEGX_HW1_LAST", /* name */ 292 false, /* partial_inplace */ 293 0, /* src_mask */ 294 0xffff, /* dst_mask */ 295 false), /* pcrel_offset */ 296 297 /* A 16 bit relocation with overflow. */ 298 HOWTO (R_TILEGX_HW2_LAST, /* type */ 299 32, /* rightshift */ 300 2, /* size */ 301 16, /* bitsize */ 302 false, /* pc_relative */ 303 0, /* bitpos */ 304 complain_overflow_signed,/* complain_on_overflow */ 305 bfd_elf_generic_reloc, /* special_function */ 306 "R_TILEGX_HW2_LAST", /* name */ 307 false, /* partial_inplace */ 308 0, /* src_mask */ 309 0xffff, /* dst_mask */ 310 false), /* pcrel_offset */ 311 312 HOWTO (R_TILEGX_COPY, /* type */ 313 0, /* rightshift */ 314 0, /* size */ 315 0, /* bitsize */ 316 false, /* pc_relative */ 317 0, /* bitpos */ 318 complain_overflow_dont, /* complain_on_overflow */ 319 bfd_elf_generic_reloc, /* special_function */ 320 "R_TILEGX_COPY", /* name */ 321 false, /* partial_inplace */ 322 0, /* src_mask */ 323 0, /* dst_mask */ 324 true), /* pcrel_offset */ 325 326 HOWTO (R_TILEGX_GLOB_DAT, /* type */ 327 0, /* rightshift */ 328 0, /* size */ 329 0, /* bitsize */ 330 false, /* pc_relative */ 331 0, /* bitpos */ 332 complain_overflow_dont, /* complain_on_overflow */ 333 bfd_elf_generic_reloc, /* special_function */ 334 "R_TILEGX_GLOB_DAT", /* name */ 335 false, /* partial_inplace */ 336 0, /* src_mask */ 337 0, /* dst_mask */ 338 true), /* pcrel_offset */ 339 340 HOWTO (R_TILEGX_JMP_SLOT, /* type */ 341 0, /* rightshift */ 342 0, /* size */ 343 0, /* bitsize */ 344 false, /* pc_relative */ 345 0, /* bitpos */ 346 complain_overflow_dont, /* complain_on_overflow */ 347 bfd_elf_generic_reloc, /* special_function */ 348 "R_TILEGX_JMP_SLOT", /* name */ 349 false, /* partial_inplace */ 350 0, /* src_mask */ 351 0, /* dst_mask */ 352 true), /* pcrel_offset */ 353 354 HOWTO (R_TILEGX_RELATIVE, /* type */ 355 0, /* rightshift */ 356 0, /* size */ 357 0, /* bitsize */ 358 false, /* pc_relative */ 359 0, /* bitpos */ 360 complain_overflow_dont, /* complain_on_overflow */ 361 bfd_elf_generic_reloc, /* special_function */ 362 "R_TILEGX_RELATIVE", /* name */ 363 false, /* partial_inplace */ 364 0, /* src_mask */ 365 0, /* dst_mask */ 366 true), /* pcrel_offset */ 367 368 HOWTO (R_TILEGX_BROFF_X1, /* type */ 369 TILEGX_LOG2_BUNDLE_ALIGNMENT_IN_BYTES, /* rightshift */ 370 4, /* size */ 371 17, /* bitsize */ 372 true, /* pc_relative */ 373 0, /* bitpos */ 374 complain_overflow_signed, /* complain_on_overflow */ 375 bfd_elf_generic_reloc, /* special_function */ 376 "R_TILEGX_BROFF_X1", /* name */ 377 false, /* partial_inplace */ 378 0, /* src_mask */ 379 -1, /* dst_mask */ 380 true), /* pcrel_offset */ 381 382 HOWTO (R_TILEGX_JUMPOFF_X1, /* type */ 383 TILEGX_LOG2_BUNDLE_ALIGNMENT_IN_BYTES, /* rightshift */ 384 4, /* size */ 385 27, /* bitsize */ 386 true, /* pc_relative */ 387 0, /* bitpos */ 388 complain_overflow_signed,/* complain_on_overflow */ 389 bfd_elf_generic_reloc, /* special_function */ 390 "R_TILEGX_JUMPOFF_X1", /* name */ 391 false, /* partial_inplace */ 392 0, /* src_mask */ 393 -1, /* dst_mask */ 394 true), /* pcrel_offset */ 395 396 HOWTO (R_TILEGX_JUMPOFF_X1_PLT, /* type */ 397 TILEGX_LOG2_BUNDLE_ALIGNMENT_IN_BYTES, /* rightshift */ 398 4, /* size */ 399 27, /* bitsize */ 400 true, /* pc_relative */ 401 0, /* bitpos */ 402 complain_overflow_signed,/* complain_on_overflow */ 403 bfd_elf_generic_reloc, /* special_function */ 404 "R_TILEGX_JUMPOFF_X1_PLT", /* name */ 405 false, /* partial_inplace */ 406 0, /* src_mask */ 407 -1, /* dst_mask */ 408 true), /* pcrel_offset */ 409 410 #define TILEGX_IMM_HOWTO(name, size, bitsize) \ 411 HOWTO (name, 0, size, bitsize, false, 0, \ 412 complain_overflow_signed, bfd_elf_generic_reloc, \ 413 #name, false, 0, -1, false) 414 415 #define TILEGX_UIMM_HOWTO(name, size, bitsize) \ 416 HOWTO (name, 0, size, bitsize, false, 0, \ 417 complain_overflow_unsigned, bfd_elf_generic_reloc, \ 418 #name, false, 0, -1, false) 419 420 TILEGX_IMM_HOWTO(R_TILEGX_IMM8_X0, 1, 8), 421 TILEGX_IMM_HOWTO(R_TILEGX_IMM8_Y0, 1, 8), 422 TILEGX_IMM_HOWTO(R_TILEGX_IMM8_X1, 1, 8), 423 TILEGX_IMM_HOWTO(R_TILEGX_IMM8_Y1, 1, 8), 424 TILEGX_IMM_HOWTO(R_TILEGX_DEST_IMM8_X1, 1, 8), 425 426 TILEGX_UIMM_HOWTO(R_TILEGX_MT_IMM14_X1, 2, 14), 427 TILEGX_UIMM_HOWTO(R_TILEGX_MF_IMM14_X1, 2, 14), 428 429 TILEGX_UIMM_HOWTO(R_TILEGX_MMSTART_X0, 1, 6), 430 TILEGX_UIMM_HOWTO(R_TILEGX_MMEND_X0, 1, 6), 431 432 TILEGX_UIMM_HOWTO(R_TILEGX_SHAMT_X0, 1, 6), 433 TILEGX_UIMM_HOWTO(R_TILEGX_SHAMT_X1, 1, 6), 434 TILEGX_UIMM_HOWTO(R_TILEGX_SHAMT_Y0, 1, 6), 435 TILEGX_UIMM_HOWTO(R_TILEGX_SHAMT_Y1, 1, 6), 436 437 #define TILEGX_IMM16_HOWTO(name, rshift) \ 438 HOWTO (name, rshift, 2, 16, false, 0, \ 439 complain_overflow_dont, bfd_elf_generic_reloc, \ 440 #name, false, 0, 0xffff, false) 441 442 TILEGX_IMM16_HOWTO (R_TILEGX_IMM16_X0_HW0, 0), 443 TILEGX_IMM16_HOWTO (R_TILEGX_IMM16_X1_HW0, 0), 444 TILEGX_IMM16_HOWTO (R_TILEGX_IMM16_X0_HW1, 16), 445 TILEGX_IMM16_HOWTO (R_TILEGX_IMM16_X1_HW1, 16), 446 TILEGX_IMM16_HOWTO (R_TILEGX_IMM16_X0_HW2, 32), 447 TILEGX_IMM16_HOWTO (R_TILEGX_IMM16_X1_HW2, 32), 448 TILEGX_IMM16_HOWTO (R_TILEGX_IMM16_X0_HW3, 48), 449 TILEGX_IMM16_HOWTO (R_TILEGX_IMM16_X1_HW3, 48), 450 451 #define TILEGX_IMM16_HOWTO_LAST(name, rshift) \ 452 HOWTO (name, rshift, 2, 16, false, 0, \ 453 complain_overflow_signed, bfd_elf_generic_reloc, \ 454 #name, false, 0, 0xffff, false) 455 456 TILEGX_IMM16_HOWTO_LAST (R_TILEGX_IMM16_X0_HW0_LAST, 0), 457 TILEGX_IMM16_HOWTO_LAST (R_TILEGX_IMM16_X1_HW0_LAST, 0), 458 TILEGX_IMM16_HOWTO_LAST (R_TILEGX_IMM16_X0_HW1_LAST, 16), 459 TILEGX_IMM16_HOWTO_LAST (R_TILEGX_IMM16_X1_HW1_LAST, 16), 460 TILEGX_IMM16_HOWTO_LAST (R_TILEGX_IMM16_X0_HW2_LAST, 32), 461 TILEGX_IMM16_HOWTO_LAST (R_TILEGX_IMM16_X1_HW2_LAST, 32), 462 463 /* PC-relative offsets. */ 464 465 #define TILEGX_IMM16_HOWTO_PCREL(name, rshift) \ 466 HOWTO (name, rshift, 2, 16, true, 0, \ 467 complain_overflow_dont, bfd_elf_generic_reloc, \ 468 #name, false, 0, 0xffff, true) 469 470 TILEGX_IMM16_HOWTO_PCREL (R_TILEGX_IMM16_X0_HW0_PCREL, 0), 471 TILEGX_IMM16_HOWTO_PCREL (R_TILEGX_IMM16_X1_HW0_PCREL, 0), 472 TILEGX_IMM16_HOWTO_PCREL (R_TILEGX_IMM16_X0_HW1_PCREL, 16), 473 TILEGX_IMM16_HOWTO_PCREL (R_TILEGX_IMM16_X1_HW1_PCREL, 16), 474 TILEGX_IMM16_HOWTO_PCREL (R_TILEGX_IMM16_X0_HW2_PCREL, 32), 475 TILEGX_IMM16_HOWTO_PCREL (R_TILEGX_IMM16_X1_HW2_PCREL, 32), 476 TILEGX_IMM16_HOWTO_PCREL (R_TILEGX_IMM16_X0_HW3_PCREL, 48), 477 TILEGX_IMM16_HOWTO_PCREL (R_TILEGX_IMM16_X1_HW3_PCREL, 48), 478 479 #define TILEGX_IMM16_HOWTO_LAST_PCREL(name, rshift) \ 480 HOWTO (name, rshift, 2, 16, true, 0, \ 481 complain_overflow_signed, bfd_elf_generic_reloc, \ 482 #name, false, 0, 0xffff, true) 483 484 TILEGX_IMM16_HOWTO_LAST_PCREL (R_TILEGX_IMM16_X0_HW0_LAST_PCREL, 0), 485 TILEGX_IMM16_HOWTO_LAST_PCREL (R_TILEGX_IMM16_X1_HW0_LAST_PCREL, 0), 486 TILEGX_IMM16_HOWTO_LAST_PCREL (R_TILEGX_IMM16_X0_HW1_LAST_PCREL, 16), 487 TILEGX_IMM16_HOWTO_LAST_PCREL (R_TILEGX_IMM16_X1_HW1_LAST_PCREL, 16), 488 TILEGX_IMM16_HOWTO_LAST_PCREL (R_TILEGX_IMM16_X0_HW2_LAST_PCREL, 32), 489 TILEGX_IMM16_HOWTO_LAST_PCREL (R_TILEGX_IMM16_X1_HW2_LAST_PCREL, 32), 490 491 TILEGX_IMM16_HOWTO (R_TILEGX_IMM16_X0_HW0_GOT, 0), 492 TILEGX_IMM16_HOWTO (R_TILEGX_IMM16_X1_HW0_GOT, 0), 493 494 TILEGX_IMM16_HOWTO_PCREL (R_TILEGX_IMM16_X0_HW0_PLT_PCREL, 0), 495 TILEGX_IMM16_HOWTO_PCREL (R_TILEGX_IMM16_X1_HW0_PLT_PCREL, 0), 496 TILEGX_IMM16_HOWTO_PCREL (R_TILEGX_IMM16_X0_HW1_PLT_PCREL, 16), 497 TILEGX_IMM16_HOWTO_PCREL (R_TILEGX_IMM16_X1_HW1_PLT_PCREL, 16), 498 TILEGX_IMM16_HOWTO_PCREL (R_TILEGX_IMM16_X0_HW2_PLT_PCREL, 32), 499 TILEGX_IMM16_HOWTO_PCREL (R_TILEGX_IMM16_X1_HW2_PLT_PCREL, 32), 500 501 TILEGX_IMM16_HOWTO_LAST (R_TILEGX_IMM16_X0_HW0_LAST_GOT, 0), 502 TILEGX_IMM16_HOWTO_LAST (R_TILEGX_IMM16_X1_HW0_LAST_GOT, 0), 503 TILEGX_IMM16_HOWTO_LAST (R_TILEGX_IMM16_X0_HW1_LAST_GOT, 16), 504 TILEGX_IMM16_HOWTO_LAST (R_TILEGX_IMM16_X1_HW1_LAST_GOT, 16), 505 506 TILEGX_IMM16_HOWTO_PCREL (R_TILEGX_IMM16_X0_HW3_PLT_PCREL, 48), 507 TILEGX_IMM16_HOWTO_PCREL (R_TILEGX_IMM16_X1_HW3_PLT_PCREL, 48), 508 509 TILEGX_IMM16_HOWTO (R_TILEGX_IMM16_X0_HW0_TLS_GD, 0), 510 TILEGX_IMM16_HOWTO (R_TILEGX_IMM16_X1_HW0_TLS_GD, 0), 511 512 TILEGX_IMM16_HOWTO (R_TILEGX_IMM16_X0_HW0_TLS_LE, 0), 513 TILEGX_IMM16_HOWTO (R_TILEGX_IMM16_X1_HW0_TLS_LE, 0), 514 TILEGX_IMM16_HOWTO_LAST (R_TILEGX_IMM16_X0_HW0_LAST_TLS_LE, 0), 515 TILEGX_IMM16_HOWTO_LAST (R_TILEGX_IMM16_X1_HW0_LAST_TLS_LE, 0), 516 TILEGX_IMM16_HOWTO_LAST (R_TILEGX_IMM16_X0_HW1_LAST_TLS_LE, 16), 517 TILEGX_IMM16_HOWTO_LAST (R_TILEGX_IMM16_X1_HW1_LAST_TLS_LE, 16), 518 519 TILEGX_IMM16_HOWTO_LAST (R_TILEGX_IMM16_X0_HW0_LAST_TLS_GD, 0), 520 TILEGX_IMM16_HOWTO_LAST (R_TILEGX_IMM16_X1_HW0_LAST_TLS_GD, 0), 521 TILEGX_IMM16_HOWTO_LAST (R_TILEGX_IMM16_X0_HW1_LAST_TLS_GD, 16), 522 TILEGX_IMM16_HOWTO_LAST (R_TILEGX_IMM16_X1_HW1_LAST_TLS_GD, 16), 523 EMPTY_HOWTO (90), 524 EMPTY_HOWTO (91), 525 526 #define TILEGX_IMM16_HOWTO_TLS_IE(name, rshift) \ 527 HOWTO (name, rshift, 2, 16, false, 0, \ 528 complain_overflow_dont, bfd_elf_generic_reloc, \ 529 #name, false, 0, 0xffff, true) 530 531 TILEGX_IMM16_HOWTO_TLS_IE (R_TILEGX_IMM16_X0_HW0_TLS_IE, 0), 532 TILEGX_IMM16_HOWTO_TLS_IE (R_TILEGX_IMM16_X1_HW0_TLS_IE, 0), 533 534 TILEGX_IMM16_HOWTO_LAST_PCREL (R_TILEGX_IMM16_X0_HW0_LAST_PLT_PCREL, 0), 535 TILEGX_IMM16_HOWTO_LAST_PCREL (R_TILEGX_IMM16_X1_HW0_LAST_PLT_PCREL, 0), 536 TILEGX_IMM16_HOWTO_LAST_PCREL (R_TILEGX_IMM16_X0_HW1_LAST_PLT_PCREL, 16), 537 TILEGX_IMM16_HOWTO_LAST_PCREL (R_TILEGX_IMM16_X1_HW1_LAST_PLT_PCREL, 16), 538 TILEGX_IMM16_HOWTO_LAST_PCREL (R_TILEGX_IMM16_X0_HW2_LAST_PLT_PCREL, 32), 539 TILEGX_IMM16_HOWTO_LAST_PCREL (R_TILEGX_IMM16_X1_HW2_LAST_PLT_PCREL, 32), 540 541 #define TILEGX_IMM16_HOWTO_LAST_TLS_IE(name, rshift) \ 542 HOWTO (name, rshift, 2, 16, false, 0, \ 543 complain_overflow_signed, bfd_elf_generic_reloc, \ 544 #name, false, 0, 0xffff, true) 545 546 TILEGX_IMM16_HOWTO_LAST_TLS_IE (R_TILEGX_IMM16_X0_HW0_LAST_TLS_IE, 0), 547 TILEGX_IMM16_HOWTO_LAST_TLS_IE (R_TILEGX_IMM16_X1_HW0_LAST_TLS_IE, 0), 548 TILEGX_IMM16_HOWTO_LAST_TLS_IE (R_TILEGX_IMM16_X0_HW1_LAST_TLS_IE, 16), 549 TILEGX_IMM16_HOWTO_LAST_TLS_IE (R_TILEGX_IMM16_X1_HW1_LAST_TLS_IE, 16), 550 EMPTY_HOWTO (104), 551 EMPTY_HOWTO (105), 552 553 HOWTO(R_TILEGX_TLS_DTPMOD64, 0, 0, 0, false, 0, complain_overflow_dont, 554 bfd_elf_generic_reloc, "R_TILEGX_TLS_DTPMOD64", 555 false, 0, 0, true), 556 HOWTO(R_TILEGX_TLS_DTPOFF64, 0, 8, 64, false, 0, complain_overflow_bitfield, 557 bfd_elf_generic_reloc, "R_TILEGX_TLS_DTPOFF64", 558 false, 0, -1, true), 559 HOWTO(R_TILEGX_TLS_TPOFF64, 0, 0, 0, false, 0, complain_overflow_dont, 560 bfd_elf_generic_reloc, "R_TILEGX_TLS_TPOFF64", 561 false, 0, 0, true), 562 563 HOWTO(R_TILEGX_TLS_DTPMOD32, 0, 0, 0, false, 0, complain_overflow_dont, 564 bfd_elf_generic_reloc, "R_TILEGX_TLS_DTPMOD32", 565 false, 0, 0, true), 566 HOWTO(R_TILEGX_TLS_DTPOFF32, 0, 8, 32, false, 0, complain_overflow_bitfield, 567 bfd_elf_generic_reloc, "R_TILEGX_TLS_DTPOFF32", 568 false, 0, -1, true), 569 HOWTO(R_TILEGX_TLS_TPOFF32, 0, 0, 0, false, 0, complain_overflow_dont, 570 bfd_elf_generic_reloc, "R_TILEGX_TLS_TPOFF32", 571 false, 0, 0, true), 572 573 HOWTO (R_TILEGX_TLS_GD_CALL, /* type */ 574 TILEGX_LOG2_BUNDLE_ALIGNMENT_IN_BYTES, /* rightshift */ 575 4, /* size */ 576 27, /* bitsize */ 577 true, /* pc_relative */ 578 0, /* bitpos */ 579 complain_overflow_signed,/* complain_on_overflow */ 580 bfd_elf_generic_reloc, /* special_function */ 581 "R_TILEGX_TLS_GD_CALL", /* name */ 582 false, /* partial_inplace */ 583 0, /* src_mask */ 584 -1, /* dst_mask */ 585 true), /* pcrel_offset */ 586 587 TILEGX_IMM_HOWTO(R_TILEGX_IMM8_X0_TLS_GD_ADD, 1, 8), 588 TILEGX_IMM_HOWTO(R_TILEGX_IMM8_X1_TLS_GD_ADD, 1, 8), 589 TILEGX_IMM_HOWTO(R_TILEGX_IMM8_Y0_TLS_GD_ADD, 1, 8), 590 TILEGX_IMM_HOWTO(R_TILEGX_IMM8_Y1_TLS_GD_ADD, 1, 8), 591 TILEGX_IMM_HOWTO(R_TILEGX_TLS_IE_LOAD, 1, 8), 592 TILEGX_IMM_HOWTO(R_TILEGX_IMM8_X0_TLS_ADD, 1, 8), 593 TILEGX_IMM_HOWTO(R_TILEGX_IMM8_X1_TLS_ADD, 1, 8), 594 TILEGX_IMM_HOWTO(R_TILEGX_IMM8_Y0_TLS_ADD, 1, 8), 595 TILEGX_IMM_HOWTO(R_TILEGX_IMM8_Y1_TLS_ADD, 1, 8), 596 }; 597 598 static reloc_howto_type tilegx_elf_howto_table2 [] = 599 { 600 /* GNU extension to record C++ vtable hierarchy */ 601 HOWTO (R_TILEGX_GNU_VTINHERIT, /* type */ 602 0, /* rightshift */ 603 8, /* size */ 604 0, /* bitsize */ 605 false, /* pc_relative */ 606 0, /* bitpos */ 607 complain_overflow_dont, /* complain_on_overflow */ 608 NULL, /* special_function */ 609 "R_TILEGX_GNU_VTINHERIT", /* name */ 610 false, /* partial_inplace */ 611 0, /* src_mask */ 612 0, /* dst_mask */ 613 false), /* pcrel_offset */ 614 615 /* GNU extension to record C++ vtable member usage */ 616 HOWTO (R_TILEGX_GNU_VTENTRY, /* type */ 617 0, /* rightshift */ 618 8, /* size */ 619 0, /* bitsize */ 620 false, /* pc_relative */ 621 0, /* bitpos */ 622 complain_overflow_dont, /* complain_on_overflow */ 623 _bfd_elf_rel_vtable_reloc_fn, /* special_function */ 624 "R_TILEGX_GNU_VTENTRY", /* name */ 625 false, /* partial_inplace */ 626 0, /* src_mask */ 627 0, /* dst_mask */ 628 false), /* pcrel_offset */ 629 630 }; 631 632 /* Map BFD reloc types to TILEGX ELF reloc types. */ 634 635 typedef struct tilegx_reloc_map 636 { 637 bfd_reloc_code_real_type bfd_reloc_val; 638 unsigned int tilegx_reloc_val; 639 reloc_howto_type * table; 640 } reloc_map; 641 642 static const reloc_map tilegx_reloc_map [] = 643 { 644 #define TH_REMAP(bfd, tilegx) \ 645 { bfd, tilegx, tilegx_elf_howto_table }, 646 647 /* Standard relocations. */ 648 TH_REMAP (BFD_RELOC_NONE, R_TILEGX_NONE) 649 TH_REMAP (BFD_RELOC_64, R_TILEGX_64) 650 TH_REMAP (BFD_RELOC_32, R_TILEGX_32) 651 TH_REMAP (BFD_RELOC_16, R_TILEGX_16) 652 TH_REMAP (BFD_RELOC_8, R_TILEGX_8) 653 TH_REMAP (BFD_RELOC_64_PCREL, R_TILEGX_64_PCREL) 654 TH_REMAP (BFD_RELOC_32_PCREL, R_TILEGX_32_PCREL) 655 TH_REMAP (BFD_RELOC_16_PCREL, R_TILEGX_16_PCREL) 656 TH_REMAP (BFD_RELOC_8_PCREL, R_TILEGX_8_PCREL) 657 658 #define SIMPLE_REMAP(t) TH_REMAP (BFD_RELOC_##t, R_##t) 659 660 /* Custom relocations. */ 661 SIMPLE_REMAP (TILEGX_HW0) 662 SIMPLE_REMAP (TILEGX_HW1) 663 SIMPLE_REMAP (TILEGX_HW2) 664 SIMPLE_REMAP (TILEGX_HW3) 665 SIMPLE_REMAP (TILEGX_HW0_LAST) 666 SIMPLE_REMAP (TILEGX_HW1_LAST) 667 SIMPLE_REMAP (TILEGX_HW2_LAST) 668 SIMPLE_REMAP (TILEGX_COPY) 669 SIMPLE_REMAP (TILEGX_GLOB_DAT) 670 SIMPLE_REMAP (TILEGX_JMP_SLOT) 671 SIMPLE_REMAP (TILEGX_RELATIVE) 672 SIMPLE_REMAP (TILEGX_BROFF_X1) 673 SIMPLE_REMAP (TILEGX_JUMPOFF_X1) 674 SIMPLE_REMAP (TILEGX_JUMPOFF_X1_PLT) 675 SIMPLE_REMAP (TILEGX_IMM8_X0) 676 SIMPLE_REMAP (TILEGX_IMM8_Y0) 677 SIMPLE_REMAP (TILEGX_IMM8_X1) 678 SIMPLE_REMAP (TILEGX_IMM8_Y1) 679 SIMPLE_REMAP (TILEGX_DEST_IMM8_X1) 680 SIMPLE_REMAP (TILEGX_MT_IMM14_X1) 681 SIMPLE_REMAP (TILEGX_MF_IMM14_X1) 682 SIMPLE_REMAP (TILEGX_MMSTART_X0) 683 SIMPLE_REMAP (TILEGX_MMEND_X0) 684 SIMPLE_REMAP (TILEGX_SHAMT_X0) 685 SIMPLE_REMAP (TILEGX_SHAMT_X1) 686 SIMPLE_REMAP (TILEGX_SHAMT_Y0) 687 SIMPLE_REMAP (TILEGX_SHAMT_Y1) 688 SIMPLE_REMAP (TILEGX_IMM16_X0_HW0) 689 SIMPLE_REMAP (TILEGX_IMM16_X1_HW0) 690 SIMPLE_REMAP (TILEGX_IMM16_X0_HW1) 691 SIMPLE_REMAP (TILEGX_IMM16_X1_HW1) 692 SIMPLE_REMAP (TILEGX_IMM16_X0_HW2) 693 SIMPLE_REMAP (TILEGX_IMM16_X1_HW2) 694 SIMPLE_REMAP (TILEGX_IMM16_X0_HW3) 695 SIMPLE_REMAP (TILEGX_IMM16_X1_HW3) 696 SIMPLE_REMAP (TILEGX_IMM16_X0_HW0_LAST) 697 SIMPLE_REMAP (TILEGX_IMM16_X1_HW0_LAST) 698 SIMPLE_REMAP (TILEGX_IMM16_X0_HW1_LAST) 699 SIMPLE_REMAP (TILEGX_IMM16_X1_HW1_LAST) 700 SIMPLE_REMAP (TILEGX_IMM16_X0_HW2_LAST) 701 SIMPLE_REMAP (TILEGX_IMM16_X1_HW2_LAST) 702 SIMPLE_REMAP (TILEGX_IMM16_X0_HW0_PCREL) 703 SIMPLE_REMAP (TILEGX_IMM16_X1_HW0_PCREL) 704 SIMPLE_REMAP (TILEGX_IMM16_X0_HW1_PCREL) 705 SIMPLE_REMAP (TILEGX_IMM16_X1_HW1_PCREL) 706 SIMPLE_REMAP (TILEGX_IMM16_X0_HW2_PCREL) 707 SIMPLE_REMAP (TILEGX_IMM16_X1_HW2_PCREL) 708 SIMPLE_REMAP (TILEGX_IMM16_X0_HW3_PCREL) 709 SIMPLE_REMAP (TILEGX_IMM16_X1_HW3_PCREL) 710 SIMPLE_REMAP (TILEGX_IMM16_X0_HW0_LAST_PCREL) 711 SIMPLE_REMAP (TILEGX_IMM16_X1_HW0_LAST_PCREL) 712 SIMPLE_REMAP (TILEGX_IMM16_X0_HW1_LAST_PCREL) 713 SIMPLE_REMAP (TILEGX_IMM16_X1_HW1_LAST_PCREL) 714 SIMPLE_REMAP (TILEGX_IMM16_X0_HW2_LAST_PCREL) 715 SIMPLE_REMAP (TILEGX_IMM16_X1_HW2_LAST_PCREL) 716 SIMPLE_REMAP (TILEGX_IMM16_X0_HW0_GOT) 717 SIMPLE_REMAP (TILEGX_IMM16_X1_HW0_GOT) 718 SIMPLE_REMAP (TILEGX_IMM16_X0_HW0_PLT_PCREL) 719 SIMPLE_REMAP (TILEGX_IMM16_X1_HW0_PLT_PCREL) 720 SIMPLE_REMAP (TILEGX_IMM16_X0_HW1_PLT_PCREL) 721 SIMPLE_REMAP (TILEGX_IMM16_X1_HW1_PLT_PCREL) 722 SIMPLE_REMAP (TILEGX_IMM16_X0_HW2_PLT_PCREL) 723 SIMPLE_REMAP (TILEGX_IMM16_X1_HW2_PLT_PCREL) 724 SIMPLE_REMAP (TILEGX_IMM16_X0_HW0_LAST_GOT) 725 SIMPLE_REMAP (TILEGX_IMM16_X1_HW0_LAST_GOT) 726 SIMPLE_REMAP (TILEGX_IMM16_X0_HW1_LAST_GOT) 727 SIMPLE_REMAP (TILEGX_IMM16_X1_HW1_LAST_GOT) 728 SIMPLE_REMAP (TILEGX_IMM16_X0_HW3_PLT_PCREL) 729 SIMPLE_REMAP (TILEGX_IMM16_X1_HW3_PLT_PCREL) 730 SIMPLE_REMAP (TILEGX_IMM16_X0_HW0_TLS_GD) 731 SIMPLE_REMAP (TILEGX_IMM16_X1_HW0_TLS_GD) 732 SIMPLE_REMAP (TILEGX_IMM16_X0_HW0_TLS_LE) 733 SIMPLE_REMAP (TILEGX_IMM16_X1_HW0_TLS_LE) 734 SIMPLE_REMAP (TILEGX_IMM16_X0_HW0_LAST_TLS_LE) 735 SIMPLE_REMAP (TILEGX_IMM16_X1_HW0_LAST_TLS_LE) 736 SIMPLE_REMAP (TILEGX_IMM16_X0_HW1_LAST_TLS_LE) 737 SIMPLE_REMAP (TILEGX_IMM16_X1_HW1_LAST_TLS_LE) 738 SIMPLE_REMAP (TILEGX_IMM16_X0_HW0_LAST_TLS_GD) 739 SIMPLE_REMAP (TILEGX_IMM16_X1_HW0_LAST_TLS_GD) 740 SIMPLE_REMAP (TILEGX_IMM16_X0_HW1_LAST_TLS_GD) 741 SIMPLE_REMAP (TILEGX_IMM16_X1_HW1_LAST_TLS_GD) 742 SIMPLE_REMAP (TILEGX_IMM16_X0_HW0_TLS_IE) 743 SIMPLE_REMAP (TILEGX_IMM16_X1_HW0_TLS_IE) 744 SIMPLE_REMAP (TILEGX_IMM16_X0_HW0_LAST_PLT_PCREL) 745 SIMPLE_REMAP (TILEGX_IMM16_X1_HW0_LAST_PLT_PCREL) 746 SIMPLE_REMAP (TILEGX_IMM16_X0_HW1_LAST_PLT_PCREL) 747 SIMPLE_REMAP (TILEGX_IMM16_X1_HW1_LAST_PLT_PCREL) 748 SIMPLE_REMAP (TILEGX_IMM16_X0_HW2_LAST_PLT_PCREL) 749 SIMPLE_REMAP (TILEGX_IMM16_X1_HW2_LAST_PLT_PCREL) 750 SIMPLE_REMAP (TILEGX_IMM16_X0_HW0_LAST_TLS_IE) 751 SIMPLE_REMAP (TILEGX_IMM16_X1_HW0_LAST_TLS_IE) 752 SIMPLE_REMAP (TILEGX_IMM16_X0_HW1_LAST_TLS_IE) 753 SIMPLE_REMAP (TILEGX_IMM16_X1_HW1_LAST_TLS_IE) 754 755 SIMPLE_REMAP (TILEGX_TLS_DTPMOD64) 756 SIMPLE_REMAP (TILEGX_TLS_DTPOFF64) 757 SIMPLE_REMAP (TILEGX_TLS_TPOFF64) 758 759 SIMPLE_REMAP (TILEGX_TLS_DTPMOD32) 760 SIMPLE_REMAP (TILEGX_TLS_DTPOFF32) 761 SIMPLE_REMAP (TILEGX_TLS_TPOFF32) 762 763 SIMPLE_REMAP (TILEGX_TLS_GD_CALL) 764 SIMPLE_REMAP (TILEGX_IMM8_X0_TLS_GD_ADD) 765 SIMPLE_REMAP (TILEGX_IMM8_X1_TLS_GD_ADD) 766 SIMPLE_REMAP (TILEGX_IMM8_Y0_TLS_GD_ADD) 767 SIMPLE_REMAP (TILEGX_IMM8_Y1_TLS_GD_ADD) 768 SIMPLE_REMAP (TILEGX_TLS_IE_LOAD) 769 SIMPLE_REMAP (TILEGX_IMM8_X0_TLS_ADD) 770 SIMPLE_REMAP (TILEGX_IMM8_X1_TLS_ADD) 771 SIMPLE_REMAP (TILEGX_IMM8_Y0_TLS_ADD) 772 SIMPLE_REMAP (TILEGX_IMM8_Y1_TLS_ADD) 773 774 #undef SIMPLE_REMAP 775 #undef TH_REMAP 776 777 { BFD_RELOC_VTABLE_INHERIT, R_TILEGX_GNU_VTINHERIT, tilegx_elf_howto_table2 }, 778 { BFD_RELOC_VTABLE_ENTRY, R_TILEGX_GNU_VTENTRY, tilegx_elf_howto_table2 }, 779 }; 780 781 782 783 /* TILEGX ELF linker hash entry. */ 784 785 struct tilegx_elf_link_hash_entry 786 { 787 struct elf_link_hash_entry elf; 788 789 #define GOT_UNKNOWN 0 790 #define GOT_NORMAL 1 791 #define GOT_TLS_GD 2 792 #define GOT_TLS_IE 4 793 unsigned char tls_type; 794 }; 795 796 #define tilegx_elf_hash_entry(ent) \ 797 ((struct tilegx_elf_link_hash_entry *)(ent)) 798 799 struct _bfd_tilegx_elf_obj_tdata 800 { 801 struct elf_obj_tdata root; 802 803 /* tls_type for each local got entry. */ 804 char *local_got_tls_type; 805 }; 806 807 #define _bfd_tilegx_elf_tdata(abfd) \ 808 ((struct _bfd_tilegx_elf_obj_tdata *) (abfd)->tdata.any) 809 810 #define _bfd_tilegx_elf_local_got_tls_type(abfd) \ 811 (_bfd_tilegx_elf_tdata (abfd)->local_got_tls_type) 812 813 #define is_tilegx_elf(bfd) \ 814 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \ 815 && elf_tdata (bfd) != NULL \ 816 && elf_object_id (bfd) == TILEGX_ELF_DATA) 817 818 #include "elf/common.h" 819 #include "elf/internal.h" 820 821 struct tilegx_elf_link_hash_table 822 { 823 struct elf_link_hash_table elf; 824 825 int bytes_per_word; 826 int word_align_power; 827 int bytes_per_rela; 828 int dtpmod_reloc; 829 int dtpoff_reloc; 830 int tpoff_reloc; 831 bfd_vma (*r_info) (Elf_Internal_Rela *, bfd_vma, bfd_vma); 832 bfd_vma (*r_symndx) (bfd_vma); 833 void (*put_word) (bfd *, bfd_vma, void *); 834 const char *dynamic_interpreter; 835 836 /* Whether LE transition has been disabled for some of the 837 sections. */ 838 bool disable_le_transition; 839 }; 840 841 842 /* Get the Tile ELF linker hash table from a link_info structure. */ 843 #define tilegx_elf_hash_table(p) \ 844 ((is_elf_hash_table ((p)->hash) \ 845 && elf_hash_table_id (elf_hash_table (p)) == TILEGX_ELF_DATA) \ 846 ? (struct tilegx_elf_link_hash_table *) (p)->hash : NULL) 847 848 #ifdef BFD64 849 static bfd_vma 850 tilegx_elf_r_info_64 (Elf_Internal_Rela *in_rel ATTRIBUTE_UNUSED, 851 bfd_vma rel_index, 852 bfd_vma type) 853 { 854 return ELF64_R_INFO (rel_index, type); 855 } 856 857 static bfd_vma 858 tilegx_elf_r_symndx_64 (bfd_vma r_info) 859 { 860 return ELF64_R_SYM (r_info); 861 } 862 863 static void 864 tilegx_put_word_64 (bfd *abfd, bfd_vma val, void *ptr) 865 { 866 bfd_put_64 (abfd, val, ptr); 867 } 868 #endif /* BFD64 */ 869 870 static bfd_vma 871 tilegx_elf_r_info_32 (Elf_Internal_Rela *in_rel ATTRIBUTE_UNUSED, 872 bfd_vma rel_index, 873 bfd_vma type) 874 { 875 return ELF32_R_INFO (rel_index, type); 876 } 877 878 static bfd_vma 879 tilegx_elf_r_symndx_32 (bfd_vma r_info) 880 { 881 return ELF32_R_SYM (r_info); 882 } 883 884 static void 885 tilegx_put_word_32 (bfd *abfd, bfd_vma val, void *ptr) 886 { 887 bfd_put_32 (abfd, val, ptr); 888 } 889 890 reloc_howto_type * 891 tilegx_reloc_type_lookup (bfd * abfd, 892 bfd_reloc_code_real_type code) 893 { 894 unsigned int i; 895 896 for (i = ARRAY_SIZE (tilegx_reloc_map); i--;) 897 { 898 const reloc_map * entry; 899 900 entry = tilegx_reloc_map + i; 901 902 if (entry->bfd_reloc_val == code) 903 return entry->table + (entry->tilegx_reloc_val 904 - entry->table[0].type); 905 } 906 907 /* xgettext:c-format */ 908 _bfd_error_handler (_("%pB: unsupported relocation type %#x"), 909 abfd, (int) code); 910 bfd_set_error (bfd_error_bad_value); 911 return NULL; 912 } 913 914 reloc_howto_type * 915 tilegx_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, 916 const char *r_name) 917 { 918 unsigned int i; 919 920 for (i = 0; 921 i < (sizeof (tilegx_elf_howto_table) 922 / sizeof (tilegx_elf_howto_table[0])); 923 i++) 924 if (tilegx_elf_howto_table[i].name != NULL 925 && strcasecmp (tilegx_elf_howto_table[i].name, r_name) == 0) 926 return &tilegx_elf_howto_table[i]; 927 928 return NULL; 929 } 930 931 bool 932 tilegx_info_to_howto_rela (bfd *abfd ATTRIBUTE_UNUSED, 933 arelent *cache_ptr, 934 Elf_Internal_Rela *dst) 935 { 936 unsigned int r_type = TILEGX_ELF_R_TYPE (dst->r_info); 937 938 if (r_type <= (unsigned int) R_TILEGX_IMM8_Y1_TLS_ADD) 939 cache_ptr->howto = &tilegx_elf_howto_table [r_type]; 940 else if (r_type - R_TILEGX_GNU_VTINHERIT 941 <= ((unsigned int) R_TILEGX_GNU_VTENTRY 942 - (unsigned int) R_TILEGX_GNU_VTINHERIT)) 943 cache_ptr->howto 944 = &tilegx_elf_howto_table2 [r_type - R_TILEGX_GNU_VTINHERIT]; 945 else 946 { 947 /* xgettext:c-format */ 948 _bfd_error_handler (_("%pB: unsupported relocation type %#x"), 949 abfd, r_type); 950 bfd_set_error (bfd_error_bad_value); 951 return false; 952 } 953 return true; 954 } 955 956 typedef tilegx_bundle_bits (*tilegx_create_func)(int); 957 958 static const tilegx_create_func reloc_to_create_func[] = 959 { 960 /* The first twenty relocation types don't correspond to operands */ 961 NULL, 962 NULL, 963 NULL, 964 NULL, 965 NULL, 966 NULL, 967 NULL, 968 NULL, 969 NULL, 970 NULL, 971 NULL, 972 NULL, 973 NULL, 974 NULL, 975 NULL, 976 NULL, 977 NULL, 978 NULL, 979 NULL, 980 NULL, 981 982 /* The remaining relocations are used for immediate operands */ 983 create_BrOff_X1, 984 create_JumpOff_X1, 985 create_JumpOff_X1, 986 create_Imm8_X0, 987 create_Imm8_Y0, 988 create_Imm8_X1, 989 create_Imm8_Y1, 990 create_Dest_Imm8_X1, 991 create_MT_Imm14_X1, 992 create_MF_Imm14_X1, 993 create_BFStart_X0, 994 create_BFEnd_X0, 995 create_ShAmt_X0, 996 create_ShAmt_X1, 997 create_ShAmt_Y0, 998 create_ShAmt_Y1, 999 create_Imm16_X0, 1000 create_Imm16_X1, 1001 create_Imm16_X0, 1002 create_Imm16_X1, 1003 create_Imm16_X0, 1004 create_Imm16_X1, 1005 create_Imm16_X0, 1006 create_Imm16_X1, 1007 create_Imm16_X0, 1008 create_Imm16_X1, 1009 create_Imm16_X0, 1010 create_Imm16_X1, 1011 create_Imm16_X0, 1012 create_Imm16_X1, 1013 create_Imm16_X0, 1014 create_Imm16_X1, 1015 create_Imm16_X0, 1016 create_Imm16_X1, 1017 create_Imm16_X0, 1018 create_Imm16_X1, 1019 create_Imm16_X0, 1020 create_Imm16_X1, 1021 create_Imm16_X0, 1022 create_Imm16_X1, 1023 create_Imm16_X0, 1024 create_Imm16_X1, 1025 create_Imm16_X0, 1026 create_Imm16_X1, 1027 create_Imm16_X0, 1028 create_Imm16_X1, 1029 create_Imm16_X0, 1030 create_Imm16_X1, 1031 create_Imm16_X0, 1032 create_Imm16_X1, 1033 create_Imm16_X0, 1034 create_Imm16_X1, 1035 create_Imm16_X0, 1036 create_Imm16_X1, 1037 create_Imm16_X0, 1038 create_Imm16_X1, 1039 create_Imm16_X0, 1040 create_Imm16_X1, 1041 create_Imm16_X0, 1042 create_Imm16_X1, 1043 create_Imm16_X0, 1044 create_Imm16_X1, 1045 create_Imm16_X0, 1046 create_Imm16_X1, 1047 create_Imm16_X0, 1048 create_Imm16_X1, 1049 create_Imm16_X0, 1050 create_Imm16_X1, 1051 create_Imm16_X0, 1052 create_Imm16_X1, 1053 NULL, 1054 NULL, 1055 create_Imm16_X0, 1056 create_Imm16_X1, 1057 create_Imm16_X0, 1058 create_Imm16_X1, 1059 create_Imm16_X0, 1060 create_Imm16_X1, 1061 create_Imm16_X0, 1062 create_Imm16_X1, 1063 create_Imm16_X0, 1064 create_Imm16_X1, 1065 create_Imm16_X0, 1066 create_Imm16_X1, 1067 }; 1068 1069 static void 1070 tilegx_elf_append_rela (bfd *abfd, asection *s, Elf_Internal_Rela *rel) 1071 { 1072 const struct elf_backend_data *bed; 1073 bfd_byte *loc; 1074 1075 bed = get_elf_backend_data (abfd); 1076 loc = s->contents + (s->reloc_count++ * bed->s->sizeof_rela); 1077 bed->s->swap_reloca_out (abfd, rel, loc); 1078 } 1079 1080 /* PLT/GOT stuff */ 1081 1082 /* The procedure linkage table starts with the following header: 1083 1084 ld_add r28, r27, 8 1085 ld r27, r27 1086 { 1087 jr r27 1088 info 10 ## SP not offset, return PC in LR 1089 } 1090 1091 Subsequent entries are the following, jumping to the header at the end: 1092 1093 { 1094 moveli r28, <_GLOBAL_OFFSET_TABLE_ - 1f + MY_GOT_OFFSET> 1095 lnk r26 1096 } 1097 1: 1098 { 1099 moveli r27, <_GLOBAL_OFFSET_TABLE_ - 1b> 1100 shl16insli r28, r28, <_GLOBAL_OFFSET_TABLE_ - 1b + MY_GOT_OFFSET> 1101 } 1102 { 1103 add r28, r26, r28 1104 shl16insli r27, r27, <_GLOBAL_OFFSET_TABLE_ - 1b> 1105 } 1106 { 1107 add r27, r26, r27 1108 ld r28, r28 1109 info 10 ## SP not offset, return PC in LR 1110 } 1111 { 1112 shl16insli r29, zero, MY_PLT_INDEX 1113 jr r28 1114 } 1115 1116 This code sequence lets the code at at the start of the PLT determine 1117 which PLT entry was executed by examining 'r29'. 1118 1119 Note that MY_PLT_INDEX skips over the header entries, so the first 1120 actual jump table entry has index zero. 1121 1122 If the offset fits in 16 bits, 1123 1124 lnk r26 1125 1: 1126 { 1127 addli r28, r26, <_GLOBAL_OFFSET_TABLE_ - 1b + MY_GOT_OFFSET> 1128 moveli r27, <_GLOBAL_OFFSET_TABLE_ - 1b> 1129 } 1130 { 1131 shl16insli r29, zero, MY_PLT_INDEX 1132 ld r28, r28 1133 } 1134 { 1135 add r27, r26, r27 1136 jr r28 1137 } 1138 info 10 ## SP not offset, return PC in LR 1139 1140 For the purpose of backtracing, the procedure linkage table ends with the 1141 following tail entry: 1142 1143 info 10 ## SP not offset, return PC in LR 1144 1145 The 32-bit versions are similar, with ld4s replacing ld, and offsets into 1146 the GOT being multiples of 4 instead of 8. 1147 1148 */ 1149 1150 #define PLT_HEADER_SIZE_IN_BUNDLES 3 1151 #define PLT_ENTRY_SIZE_IN_BUNDLES 5 1152 #define PLT_TAIL_SIZE_IN_BUNDLES 1 1153 1154 #define PLT_HEADER_SIZE \ 1155 (PLT_HEADER_SIZE_IN_BUNDLES * TILEGX_BUNDLE_SIZE_IN_BYTES) 1156 #define PLT_ENTRY_SIZE \ 1157 (PLT_ENTRY_SIZE_IN_BUNDLES * TILEGX_BUNDLE_SIZE_IN_BYTES) 1158 #define PLT_TAIL_SIZE \ 1159 (PLT_TAIL_SIZE_IN_BUNDLES * TILEGX_BUNDLE_SIZE_IN_BYTES) 1160 1161 #define GOT_ENTRY_SIZE(htab) TILEGX_ELF_WORD_BYTES (htab) 1162 1163 #define GOTPLT_HEADER_SIZE(htab) (2 * GOT_ENTRY_SIZE (htab)) 1164 1165 static const bfd_byte 1166 tilegx64_plt0_entry[PLT_HEADER_SIZE] = 1167 { 1168 0x00, 0x30, 0x48, 0x51, 1169 0x6e, 0x43, 0xa0, 0x18, /* { ld_add r28, r27, 8 } */ 1170 0x00, 0x30, 0xbc, 0x35, 1171 0x00, 0x40, 0xde, 0x9e, /* { ld r27, r27 } */ 1172 0xff, 0xaf, 0x30, 0x40, 1173 0x60, 0x73, 0x6a, 0x28, /* { info 10 ; jr r27 } */ 1174 }; 1175 1176 static const bfd_byte 1177 tilegx64_long_plt_entry[PLT_ENTRY_SIZE] = 1178 { 1179 0xdc, 0x0f, 0x00, 0x10, 1180 0x0d, 0xf0, 0x6a, 0x28, /* { moveli r28, 0 ; lnk r26 } */ 1181 0xdb, 0x0f, 0x00, 0x10, 1182 0x8e, 0x03, 0x00, 0x38, /* { moveli r27, 0 ; shl16insli r28, r28, 0 } */ 1183 0x9c, 0xc6, 0x0d, 0xd0, 1184 0x6d, 0x03, 0x00, 0x38, /* { add r28, r26, r28 ; shl16insli r27, r27, 0 } */ 1185 0x9b, 0xb6, 0xc5, 0xad, 1186 0xff, 0x57, 0xe0, 0x8e, /* { add r27, r26, r27 ; info 10 ; ld r28, r28 } */ 1187 0xdd, 0x0f, 0x00, 0x70, 1188 0x80, 0x73, 0x6a, 0x28, /* { shl16insli r29, zero, 0 ; jr r28 } */ 1189 }; 1190 1191 static const bfd_byte 1192 tilegx64_short_plt_entry[PLT_ENTRY_SIZE] = 1193 { 1194 0x00, 0x30, 0x48, 0x51, 1195 0x0d, 0xf0, 0x6a, 0x28, /* { lnk r26 } */ 1196 0x9c, 0x06, 0x00, 0x90, 1197 0xed, 0x07, 0x00, 0x00, /* { addli r28, r26, 0 ; moveli r27, 0 } */ 1198 0xdd, 0x0f, 0x00, 0x70, 1199 0x8e, 0xeb, 0x6a, 0x28, /* { shl16insli r29, zero, 0 ; ld r28, r28 } */ 1200 0x9b, 0xb6, 0x0d, 0x50, 1201 0x80, 0x73, 0x6a, 0x28, /* { add r27, r26, r27 ; jr r28 } */ 1202 0x00, 0x30, 0x48, 0xd1, 1203 0xff, 0x57, 0x18, 0x18, /* { info 10 } */ 1204 }; 1205 1206 /* Reuse an existing info 10 bundle. */ 1207 static const bfd_byte *const tilegx64_plt_tail_entry = 1208 &tilegx64_short_plt_entry[4 * TILEGX_BUNDLE_SIZE_IN_BYTES]; 1209 1210 static const bfd_byte 1211 tilegx32_plt0_entry[PLT_HEADER_SIZE] = 1212 { 1213 0x00, 0x30, 0x48, 0x51, 1214 0x6e, 0x23, 0x58, 0x18, /* { ld4s_add r28, r27, 4 } */ 1215 0x00, 0x30, 0xbc, 0x35, 1216 0x00, 0x40, 0xde, 0x9c, /* { ld4s r27, r27 } */ 1217 0xff, 0xaf, 0x30, 0x40, 1218 0x60, 0x73, 0x6a, 0x28, /* { info 10 ; jr r27 } */ 1219 }; 1220 1221 static const bfd_byte 1222 tilegx32_long_plt_entry[PLT_ENTRY_SIZE] = 1223 { 1224 0xdc, 0x0f, 0x00, 0x10, 1225 0x0d, 0xf0, 0x6a, 0x28, /* { moveli r28, 0 ; lnk r26 } */ 1226 0xdb, 0x0f, 0x00, 0x10, 1227 0x8e, 0x03, 0x00, 0x38, /* { moveli r27, 0 ; shl16insli r28, r28, 0 } */ 1228 0x9c, 0xc6, 0x0d, 0xd0, 1229 0x6d, 0x03, 0x00, 0x38, /* { add r28, r26, r28 ; shl16insli r27, r27, 0 } */ 1230 0x9b, 0xb6, 0xc5, 0xad, 1231 0xff, 0x57, 0xe0, 0x8c, /* { add r27, r26, r27 ; info 10 ; ld4s r28, r28 } */ 1232 0xdd, 0x0f, 0x00, 0x70, 1233 0x80, 0x73, 0x6a, 0x28, /* { shl16insli r29, zero, 0 ; jr r28 } */ 1234 }; 1235 1236 static const bfd_byte 1237 tilegx32_short_plt_entry[PLT_ENTRY_SIZE] = 1238 { 1239 0x00, 0x30, 0x48, 0x51, 1240 0x0d, 0xf0, 0x6a, 0x28, /* { lnk r26 } */ 1241 0x9c, 0x06, 0x00, 0x90, 1242 0xed, 0x07, 0x00, 0x00, /* { addli r28, r26, 0 ; moveli r27, 0 } */ 1243 0xdd, 0x0f, 0x00, 0x70, 1244 0x8e, 0x9b, 0x6a, 0x28, /* { shl16insli r29, zero, 0 ; ld4s r28, r28 } */ 1245 0x9b, 0xb6, 0x0d, 0x50, 1246 0x80, 0x73, 0x6a, 0x28, /* { add r27, r26, r27 ; jr r28 } */ 1247 0x00, 0x30, 0x48, 0xd1, 1248 0xff, 0x57, 0x18, 0x18, /* { info 10 } */ 1249 }; 1250 1251 /* Reuse an existing info 10 bundle. */ 1252 static const bfd_byte *const tilegx32_plt_tail_entry = 1253 &tilegx64_short_plt_entry[4 * TILEGX_BUNDLE_SIZE_IN_BYTES]; 1254 1255 static int 1256 tilegx_plt_entry_build (bfd *output_bfd, 1257 struct tilegx_elf_link_hash_table *htab, 1258 asection *splt, asection *sgotplt, 1259 bfd_vma offset, bfd_vma *r_offset) 1260 { 1261 int plt_index = (offset - PLT_HEADER_SIZE) / PLT_ENTRY_SIZE; 1262 int got_offset = (plt_index * GOT_ENTRY_SIZE (htab) 1263 + GOTPLT_HEADER_SIZE (htab)); 1264 tilegx_bundle_bits *pc; 1265 1266 /* Compute the distance from the got entry to the lnk. */ 1267 bfd_signed_vma dist_got_entry = sgotplt->output_section->vma 1268 + sgotplt->output_offset 1269 + got_offset 1270 - splt->output_section->vma 1271 - splt->output_offset 1272 - offset 1273 - TILEGX_BUNDLE_SIZE_IN_BYTES; 1274 1275 /* Compute the distance to GOTPLT[0]. */ 1276 bfd_signed_vma dist_got0 = dist_got_entry - got_offset; 1277 1278 /* Check whether we can use the short plt entry with 16-bit offset. */ 1279 bool short_plt_entry = 1280 (dist_got_entry <= 0x7fff && dist_got0 >= -0x8000); 1281 1282 const tilegx_bundle_bits *plt_entry = (tilegx_bundle_bits *) 1283 (ABI_64_P (output_bfd) ? 1284 (short_plt_entry ? tilegx64_short_plt_entry : tilegx64_long_plt_entry) : 1285 (short_plt_entry ? tilegx32_short_plt_entry : tilegx32_long_plt_entry)); 1286 1287 /* Copy the plt entry template. */ 1288 memcpy (splt->contents + offset, plt_entry, PLT_ENTRY_SIZE); 1289 1290 /* Write the immediate offsets. */ 1291 pc = (tilegx_bundle_bits *)(splt->contents + offset); 1292 1293 if (short_plt_entry) 1294 { 1295 /* { lnk r28 } */ 1296 pc++; 1297 1298 /* { addli r28, r28, &GOTPLT[MY_GOT_INDEX] ; moveli r27, &GOTPLT[0] } */ 1299 *pc++ |= create_Imm16_X0 (dist_got_entry) 1300 | create_Imm16_X1 (dist_got0); 1301 1302 /* { shl16insli r29, zero, MY_PLT_INDEX ; ld r28, r28 } */ 1303 *pc++ |= create_Imm16_X0 (plt_index); 1304 } 1305 else 1306 { 1307 /* { moveli r28, &GOTPLT[MY_GOT_INDEX] ; lnk r26 } */ 1308 *pc++ |= create_Imm16_X0 (dist_got_entry >> 16); 1309 1310 /* { moveli r27, &GOTPLT[0] ; 1311 shl16insli r28, r28, &GOTPLT[MY_GOT_INDEX] } */ 1312 *pc++ |= create_Imm16_X0 (dist_got0 >> 16) 1313 | create_Imm16_X1 (dist_got_entry); 1314 1315 /* { add r28, r26, r28 ; shl16insli r27, r27, &GOTPLT[0] } */ 1316 *pc++ |= create_Imm16_X1 (dist_got0); 1317 1318 /* { add r27, r26, r27 ; info 10 ; ld r28, r28 } */ 1319 pc++; 1320 1321 /* { shl16insli r29, zero, MY_GOT_INDEX ; jr r28 } */ 1322 *pc++ |= create_Imm16_X0 (plt_index); 1323 } 1324 1325 /* Set the relocation offset. */ 1326 *r_offset = got_offset; 1327 1328 return plt_index; 1329 } 1330 1331 /* Create an entry in an TILEGX ELF linker hash table. */ 1332 1333 static struct bfd_hash_entry * 1334 link_hash_newfunc (struct bfd_hash_entry *entry, 1335 struct bfd_hash_table *table, const char *string) 1336 { 1337 /* Allocate the structure if it has not already been allocated by a 1338 subclass. */ 1339 if (entry == NULL) 1340 { 1341 entry = 1342 bfd_hash_allocate (table, 1343 sizeof (struct tilegx_elf_link_hash_entry)); 1344 if (entry == NULL) 1345 return entry; 1346 } 1347 1348 /* Call the allocation method of the superclass. */ 1349 entry = _bfd_elf_link_hash_newfunc (entry, table, string); 1350 if (entry != NULL) 1351 { 1352 struct tilegx_elf_link_hash_entry *eh; 1353 1354 eh = (struct tilegx_elf_link_hash_entry *) entry; 1355 eh->tls_type = GOT_UNKNOWN; 1356 } 1357 1358 return entry; 1359 } 1360 1361 /* Create a TILEGX ELF linker hash table. */ 1362 1363 struct bfd_link_hash_table * 1364 tilegx_elf_link_hash_table_create (bfd *abfd) 1365 { 1366 struct tilegx_elf_link_hash_table *ret; 1367 size_t amt = sizeof (struct tilegx_elf_link_hash_table); 1368 1369 ret = (struct tilegx_elf_link_hash_table *) bfd_zmalloc (amt); 1370 if (ret == NULL) 1371 return NULL; 1372 1373 #ifdef BFD64 1374 if (ABI_64_P (abfd)) 1375 { 1376 ret->bytes_per_word = 8; 1377 ret->word_align_power = 3; 1378 ret->bytes_per_rela = sizeof (Elf64_External_Rela); 1379 ret->dtpoff_reloc = R_TILEGX_TLS_DTPOFF64; 1380 ret->dtpmod_reloc = R_TILEGX_TLS_DTPMOD64; 1381 ret->tpoff_reloc = R_TILEGX_TLS_TPOFF64; 1382 ret->r_info = tilegx_elf_r_info_64; 1383 ret->r_symndx = tilegx_elf_r_symndx_64; 1384 ret->dynamic_interpreter = ELF64_DYNAMIC_INTERPRETER; 1385 ret->put_word = tilegx_put_word_64; 1386 } 1387 else 1388 #endif 1389 { 1390 ret->bytes_per_word = 4; 1391 ret->word_align_power = 2; 1392 ret->bytes_per_rela = sizeof (Elf32_External_Rela); 1393 ret->dtpoff_reloc = R_TILEGX_TLS_DTPOFF32; 1394 ret->dtpmod_reloc = R_TILEGX_TLS_DTPMOD32; 1395 ret->tpoff_reloc = R_TILEGX_TLS_TPOFF32; 1396 ret->r_info = tilegx_elf_r_info_32; 1397 ret->r_symndx = tilegx_elf_r_symndx_32; 1398 ret->dynamic_interpreter = ELF32_DYNAMIC_INTERPRETER; 1399 ret->put_word = tilegx_put_word_32; 1400 } 1401 1402 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd, link_hash_newfunc, 1403 sizeof (struct tilegx_elf_link_hash_entry))) 1404 { 1405 free (ret); 1406 return NULL; 1407 } 1408 1409 return &ret->elf.root; 1410 } 1411 1412 /* Create the .got section. */ 1413 1414 static bool 1415 tilegx_elf_create_got_section (bfd *abfd, struct bfd_link_info *info) 1416 { 1417 flagword flags; 1418 asection *s, *s_got; 1419 struct elf_link_hash_entry *h; 1420 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 1421 struct elf_link_hash_table *htab = elf_hash_table (info); 1422 1423 /* This function may be called more than once. */ 1424 if (htab->sgot != NULL) 1425 return true; 1426 1427 flags = bed->dynamic_sec_flags; 1428 1429 s = bfd_make_section_anyway_with_flags (abfd, 1430 (bed->rela_plts_and_copies_p 1431 ? ".rela.got" : ".rel.got"), 1432 (bed->dynamic_sec_flags 1433 | SEC_READONLY)); 1434 if (s == NULL 1435 || !bfd_set_section_alignment (s, bed->s->log_file_align)) 1436 return false; 1437 htab->srelgot = s; 1438 1439 s = s_got = bfd_make_section_anyway_with_flags (abfd, ".got", flags); 1440 if (s == NULL 1441 || !bfd_set_section_alignment (s, bed->s->log_file_align)) 1442 return false; 1443 htab->sgot = s; 1444 1445 /* The first bit of the global offset table is the header. */ 1446 s->size += bed->got_header_size; 1447 1448 if (bed->want_got_plt) 1449 { 1450 s = bfd_make_section_anyway_with_flags (abfd, ".got.plt", flags); 1451 if (s == NULL 1452 || !bfd_set_section_alignment (s, bed->s->log_file_align)) 1453 return false; 1454 htab->sgotplt = s; 1455 1456 /* Reserve room for the header. */ 1457 s->size += GOTPLT_HEADER_SIZE (tilegx_elf_hash_table (info)); 1458 } 1459 1460 if (bed->want_got_sym) 1461 { 1462 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got 1463 section. We don't do this in the linker script because we don't want 1464 to define the symbol if we are not creating a global offset 1465 table. */ 1466 h = _bfd_elf_define_linkage_sym (abfd, info, s_got, 1467 "_GLOBAL_OFFSET_TABLE_"); 1468 elf_hash_table (info)->hgot = h; 1469 if (h == NULL) 1470 return false; 1471 } 1472 1473 return true; 1474 } 1475 1476 /* Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and 1477 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our 1478 hash table. */ 1479 1480 bool 1481 tilegx_elf_create_dynamic_sections (bfd *dynobj, 1482 struct bfd_link_info *info) 1483 { 1484 if (!tilegx_elf_create_got_section (dynobj, info)) 1485 return false; 1486 1487 return _bfd_elf_create_dynamic_sections (dynobj, info); 1488 } 1489 1490 /* Copy the extra info we tack onto an elf_link_hash_entry. */ 1491 1492 void 1493 tilegx_elf_copy_indirect_symbol (struct bfd_link_info *info, 1494 struct elf_link_hash_entry *dir, 1495 struct elf_link_hash_entry *ind) 1496 { 1497 struct tilegx_elf_link_hash_entry *edir, *eind; 1498 1499 edir = (struct tilegx_elf_link_hash_entry *) dir; 1500 eind = (struct tilegx_elf_link_hash_entry *) ind; 1501 1502 if (ind->root.type == bfd_link_hash_indirect 1503 && dir->got.refcount <= 0) 1504 { 1505 edir->tls_type = eind->tls_type; 1506 eind->tls_type = GOT_UNKNOWN; 1507 } 1508 _bfd_elf_link_hash_copy_indirect (info, dir, ind); 1509 } 1510 1511 static int 1512 tilegx_tls_translate_to_le (int r_type) 1513 { 1514 switch (r_type) 1515 { 1516 case R_TILEGX_IMM16_X0_HW0_TLS_GD: 1517 case R_TILEGX_IMM16_X0_HW0_TLS_IE: 1518 return R_TILEGX_IMM16_X0_HW0_TLS_LE; 1519 1520 case R_TILEGX_IMM16_X1_HW0_TLS_GD: 1521 case R_TILEGX_IMM16_X1_HW0_TLS_IE: 1522 return R_TILEGX_IMM16_X1_HW0_TLS_LE; 1523 1524 case R_TILEGX_IMM16_X0_HW0_LAST_TLS_GD: 1525 case R_TILEGX_IMM16_X0_HW0_LAST_TLS_IE: 1526 return R_TILEGX_IMM16_X0_HW0_LAST_TLS_LE; 1527 1528 case R_TILEGX_IMM16_X1_HW0_LAST_TLS_GD: 1529 case R_TILEGX_IMM16_X1_HW0_LAST_TLS_IE: 1530 return R_TILEGX_IMM16_X1_HW0_LAST_TLS_LE; 1531 1532 case R_TILEGX_IMM16_X0_HW1_LAST_TLS_GD: 1533 case R_TILEGX_IMM16_X0_HW1_LAST_TLS_IE: 1534 return R_TILEGX_IMM16_X0_HW1_LAST_TLS_LE; 1535 1536 case R_TILEGX_IMM16_X1_HW1_LAST_TLS_GD: 1537 case R_TILEGX_IMM16_X1_HW1_LAST_TLS_IE: 1538 return R_TILEGX_IMM16_X1_HW1_LAST_TLS_LE; 1539 } 1540 return r_type; 1541 } 1542 1543 static int 1544 tilegx_tls_translate_to_ie (int r_type) 1545 { 1546 switch (r_type) 1547 { 1548 case R_TILEGX_IMM16_X0_HW0_TLS_GD: 1549 case R_TILEGX_IMM16_X0_HW0_TLS_IE: 1550 return R_TILEGX_IMM16_X0_HW0_TLS_IE; 1551 1552 case R_TILEGX_IMM16_X1_HW0_TLS_GD: 1553 case R_TILEGX_IMM16_X1_HW0_TLS_IE: 1554 return R_TILEGX_IMM16_X1_HW0_TLS_IE; 1555 1556 case R_TILEGX_IMM16_X0_HW0_LAST_TLS_GD: 1557 case R_TILEGX_IMM16_X0_HW0_LAST_TLS_IE: 1558 return R_TILEGX_IMM16_X0_HW0_LAST_TLS_IE; 1559 1560 case R_TILEGX_IMM16_X1_HW0_LAST_TLS_GD: 1561 case R_TILEGX_IMM16_X1_HW0_LAST_TLS_IE: 1562 return R_TILEGX_IMM16_X1_HW0_LAST_TLS_IE; 1563 1564 case R_TILEGX_IMM16_X0_HW1_LAST_TLS_GD: 1565 case R_TILEGX_IMM16_X0_HW1_LAST_TLS_IE: 1566 return R_TILEGX_IMM16_X0_HW1_LAST_TLS_IE; 1567 1568 case R_TILEGX_IMM16_X1_HW1_LAST_TLS_GD: 1569 case R_TILEGX_IMM16_X1_HW1_LAST_TLS_IE: 1570 return R_TILEGX_IMM16_X1_HW1_LAST_TLS_IE; 1571 } 1572 return r_type; 1573 } 1574 1575 static int 1576 tilegx_elf_tls_transition (struct bfd_link_info *info, int r_type, 1577 int is_local, bool disable_le_transition) 1578 { 1579 if (!bfd_link_executable (info)) 1580 return r_type; 1581 1582 if (is_local && !disable_le_transition) 1583 return tilegx_tls_translate_to_le (r_type); 1584 else 1585 return tilegx_tls_translate_to_ie (r_type); 1586 } 1587 1588 /* Look through the relocs for a section during the first phase, and 1589 allocate space in the global offset table or procedure linkage 1590 table. */ 1591 1592 bool 1593 tilegx_elf_check_relocs (bfd *abfd, struct bfd_link_info *info, 1594 asection *sec, const Elf_Internal_Rela *relocs) 1595 { 1596 struct tilegx_elf_link_hash_table *htab; 1597 Elf_Internal_Shdr *symtab_hdr; 1598 struct elf_link_hash_entry **sym_hashes; 1599 const Elf_Internal_Rela *rel; 1600 const Elf_Internal_Rela *rel_end; 1601 asection *sreloc; 1602 int num_relocs; 1603 bool has_tls_gd_or_ie = false, has_tls_add = false; 1604 1605 if (bfd_link_relocatable (info)) 1606 return true; 1607 1608 htab = tilegx_elf_hash_table (info); 1609 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 1610 sym_hashes = elf_sym_hashes (abfd); 1611 1612 sreloc = NULL; 1613 1614 num_relocs = sec->reloc_count; 1615 1616 BFD_ASSERT (is_tilegx_elf (abfd) || num_relocs == 0); 1617 1618 if (htab->elf.dynobj == NULL) 1619 htab->elf.dynobj = abfd; 1620 1621 rel_end = relocs + num_relocs; 1622 1623 /* Check whether to do optimization to transform TLS GD/IE 1624 referehces to TLS LE. We disable it if we're linking with old 1625 TLS code sequences that do not support such optimization. Old 1626 TLS code sequences have tls_gd_call/tls_ie_load relocations but 1627 no tls_add relocations. */ 1628 for (rel = relocs; rel < rel_end && !has_tls_add; rel++) 1629 { 1630 int r_type = TILEGX_ELF_R_TYPE (rel->r_info); 1631 switch (r_type) 1632 { 1633 case R_TILEGX_TLS_GD_CALL: 1634 case R_TILEGX_TLS_IE_LOAD: 1635 has_tls_gd_or_ie = true; 1636 break; 1637 case R_TILEGX_IMM8_X0_TLS_ADD: 1638 case R_TILEGX_IMM8_Y0_TLS_ADD: 1639 case R_TILEGX_IMM8_X1_TLS_ADD: 1640 case R_TILEGX_IMM8_Y1_TLS_ADD: 1641 has_tls_add = true; 1642 break; 1643 } 1644 } 1645 1646 sec->sec_flg0 = (has_tls_gd_or_ie && !has_tls_add); 1647 htab->disable_le_transition |= sec->sec_flg0; 1648 1649 for (rel = relocs; rel < rel_end; rel++) 1650 { 1651 unsigned int r_type; 1652 unsigned int r_symndx; 1653 struct elf_link_hash_entry *h; 1654 int tls_type; 1655 1656 r_symndx = TILEGX_ELF_R_SYMNDX (htab, rel->r_info); 1657 r_type = TILEGX_ELF_R_TYPE (rel->r_info); 1658 1659 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr)) 1660 { 1661 /* xgettext:c-format */ 1662 _bfd_error_handler (_("%pB: bad symbol index: %d"), 1663 abfd, r_symndx); 1664 return false; 1665 } 1666 1667 if (r_symndx < symtab_hdr->sh_info) 1668 h = NULL; 1669 else 1670 { 1671 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 1672 while (h->root.type == bfd_link_hash_indirect 1673 || h->root.type == bfd_link_hash_warning) 1674 h = (struct elf_link_hash_entry *) h->root.u.i.link; 1675 } 1676 1677 r_type = tilegx_elf_tls_transition (info, r_type, h == NULL, 1678 sec->sec_flg0); 1679 switch (r_type) 1680 { 1681 case R_TILEGX_IMM16_X0_HW0_TLS_LE: 1682 case R_TILEGX_IMM16_X1_HW0_TLS_LE: 1683 case R_TILEGX_IMM16_X0_HW0_LAST_TLS_LE: 1684 case R_TILEGX_IMM16_X1_HW0_LAST_TLS_LE: 1685 case R_TILEGX_IMM16_X0_HW1_LAST_TLS_LE: 1686 case R_TILEGX_IMM16_X1_HW1_LAST_TLS_LE: 1687 if (!bfd_link_executable (info)) 1688 goto r_tilegx_plt32; 1689 break; 1690 1691 case R_TILEGX_IMM16_X0_HW0_TLS_GD: 1692 case R_TILEGX_IMM16_X1_HW0_TLS_GD: 1693 case R_TILEGX_IMM16_X0_HW0_LAST_TLS_GD: 1694 case R_TILEGX_IMM16_X1_HW0_LAST_TLS_GD: 1695 case R_TILEGX_IMM16_X0_HW1_LAST_TLS_GD: 1696 case R_TILEGX_IMM16_X1_HW1_LAST_TLS_GD: 1697 BFD_ASSERT (bfd_link_pic (info)); 1698 tls_type = GOT_TLS_GD; 1699 goto have_got_reference; 1700 1701 case R_TILEGX_IMM16_X0_HW0_TLS_IE: 1702 case R_TILEGX_IMM16_X1_HW0_TLS_IE: 1703 case R_TILEGX_IMM16_X0_HW0_LAST_TLS_IE: 1704 case R_TILEGX_IMM16_X1_HW0_LAST_TLS_IE: 1705 case R_TILEGX_IMM16_X0_HW1_LAST_TLS_IE: 1706 case R_TILEGX_IMM16_X1_HW1_LAST_TLS_IE: 1707 tls_type = GOT_TLS_IE; 1708 if (!bfd_link_executable (info)) 1709 info->flags |= DF_STATIC_TLS; 1710 goto have_got_reference; 1711 1712 case R_TILEGX_IMM16_X0_HW0_GOT: 1713 case R_TILEGX_IMM16_X1_HW0_GOT: 1714 case R_TILEGX_IMM16_X0_HW0_LAST_GOT: 1715 case R_TILEGX_IMM16_X1_HW0_LAST_GOT: 1716 case R_TILEGX_IMM16_X0_HW1_LAST_GOT: 1717 case R_TILEGX_IMM16_X1_HW1_LAST_GOT: 1718 tls_type = GOT_NORMAL; 1719 /* Fall Through */ 1720 1721 have_got_reference: 1722 /* This symbol requires a global offset table entry. */ 1723 { 1724 int old_tls_type; 1725 1726 if (h != NULL) 1727 { 1728 h->got.refcount += 1; 1729 old_tls_type = tilegx_elf_hash_entry(h)->tls_type; 1730 } 1731 else 1732 { 1733 bfd_signed_vma *local_got_refcounts; 1734 1735 /* This is a global offset table entry for a local symbol. */ 1736 local_got_refcounts = elf_local_got_refcounts (abfd); 1737 if (local_got_refcounts == NULL) 1738 { 1739 bfd_size_type size; 1740 1741 size = symtab_hdr->sh_info; 1742 size *= (sizeof (bfd_signed_vma) + sizeof(char)); 1743 local_got_refcounts = ((bfd_signed_vma *) 1744 bfd_zalloc (abfd, size)); 1745 if (local_got_refcounts == NULL) 1746 return false; 1747 elf_local_got_refcounts (abfd) = local_got_refcounts; 1748 _bfd_tilegx_elf_local_got_tls_type (abfd) 1749 = (char *) (local_got_refcounts + symtab_hdr->sh_info); 1750 } 1751 local_got_refcounts[r_symndx] += 1; 1752 old_tls_type = _bfd_tilegx_elf_local_got_tls_type (abfd) [r_symndx]; 1753 } 1754 1755 /* If a TLS symbol is accessed using IE at least once, 1756 there is no point to use dynamic model for it. */ 1757 if (old_tls_type != tls_type && old_tls_type != GOT_UNKNOWN 1758 && (old_tls_type != GOT_TLS_GD 1759 || tls_type != GOT_TLS_IE)) 1760 { 1761 if (old_tls_type == GOT_TLS_IE && tls_type == GOT_TLS_GD) 1762 tls_type = old_tls_type; 1763 else 1764 { 1765 _bfd_error_handler 1766 /* xgettext:c-format */ 1767 (_("%pB: `%s' accessed both as normal and thread local symbol"), 1768 abfd, h ? h->root.root.string : "<local>"); 1769 return false; 1770 } 1771 } 1772 1773 if (old_tls_type != tls_type) 1774 { 1775 if (h != NULL) 1776 tilegx_elf_hash_entry (h)->tls_type = tls_type; 1777 else 1778 _bfd_tilegx_elf_local_got_tls_type (abfd) [r_symndx] = tls_type; 1779 } 1780 } 1781 1782 if (htab->elf.sgot == NULL) 1783 { 1784 if (!tilegx_elf_create_got_section (htab->elf.dynobj, info)) 1785 return false; 1786 } 1787 break; 1788 1789 case R_TILEGX_TLS_GD_CALL: 1790 if (!bfd_link_executable (info)) 1791 { 1792 /* These are basically R_TILEGX_JUMPOFF_X1_PLT relocs 1793 against __tls_get_addr. */ 1794 struct bfd_link_hash_entry *bh = NULL; 1795 if (! _bfd_generic_link_add_one_symbol (info, abfd, 1796 "__tls_get_addr", 0, 1797 bfd_und_section_ptr, 0, 1798 NULL, false, false, 1799 &bh)) 1800 return false; 1801 h = (struct elf_link_hash_entry *) bh; 1802 } 1803 else 1804 break; 1805 /* Fall through */ 1806 1807 case R_TILEGX_JUMPOFF_X1_PLT: 1808 case R_TILEGX_IMM16_X0_HW0_PLT_PCREL: 1809 case R_TILEGX_IMM16_X1_HW0_PLT_PCREL: 1810 case R_TILEGX_IMM16_X0_HW1_PLT_PCREL: 1811 case R_TILEGX_IMM16_X1_HW1_PLT_PCREL: 1812 case R_TILEGX_IMM16_X0_HW2_PLT_PCREL: 1813 case R_TILEGX_IMM16_X1_HW2_PLT_PCREL: 1814 case R_TILEGX_IMM16_X0_HW3_PLT_PCREL: 1815 case R_TILEGX_IMM16_X1_HW3_PLT_PCREL: 1816 case R_TILEGX_IMM16_X0_HW0_LAST_PLT_PCREL: 1817 case R_TILEGX_IMM16_X1_HW0_LAST_PLT_PCREL: 1818 case R_TILEGX_IMM16_X0_HW1_LAST_PLT_PCREL: 1819 case R_TILEGX_IMM16_X1_HW1_LAST_PLT_PCREL: 1820 case R_TILEGX_IMM16_X0_HW2_LAST_PLT_PCREL: 1821 case R_TILEGX_IMM16_X1_HW2_LAST_PLT_PCREL: 1822 /* This symbol requires a procedure linkage table entry. We 1823 actually build the entry in adjust_dynamic_symbol, 1824 because this might be a case of linking PIC code without 1825 linking in any dynamic objects, in which case we don't 1826 need to generate a procedure linkage table after all. */ 1827 1828 if (h != NULL) 1829 { 1830 h->needs_plt = 1; 1831 h->plt.refcount += 1; 1832 } 1833 break; 1834 1835 case R_TILEGX_64_PCREL: 1836 case R_TILEGX_32_PCREL: 1837 case R_TILEGX_16_PCREL: 1838 case R_TILEGX_8_PCREL: 1839 case R_TILEGX_IMM16_X0_HW0_PCREL: 1840 case R_TILEGX_IMM16_X1_HW0_PCREL: 1841 case R_TILEGX_IMM16_X0_HW1_PCREL: 1842 case R_TILEGX_IMM16_X1_HW1_PCREL: 1843 case R_TILEGX_IMM16_X0_HW2_PCREL: 1844 case R_TILEGX_IMM16_X1_HW2_PCREL: 1845 case R_TILEGX_IMM16_X0_HW3_PCREL: 1846 case R_TILEGX_IMM16_X1_HW3_PCREL: 1847 case R_TILEGX_IMM16_X0_HW0_LAST_PCREL: 1848 case R_TILEGX_IMM16_X1_HW0_LAST_PCREL: 1849 case R_TILEGX_IMM16_X0_HW1_LAST_PCREL: 1850 case R_TILEGX_IMM16_X1_HW1_LAST_PCREL: 1851 case R_TILEGX_IMM16_X0_HW2_LAST_PCREL: 1852 case R_TILEGX_IMM16_X1_HW2_LAST_PCREL: 1853 if (h != NULL) 1854 h->non_got_ref = 1; 1855 1856 if (h != NULL 1857 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0) 1858 break; 1859 /* Fall through. */ 1860 1861 case R_TILEGX_64: 1862 case R_TILEGX_32: 1863 case R_TILEGX_16: 1864 case R_TILEGX_8: 1865 case R_TILEGX_HW0: 1866 case R_TILEGX_HW1: 1867 case R_TILEGX_HW2: 1868 case R_TILEGX_HW3: 1869 case R_TILEGX_HW0_LAST: 1870 case R_TILEGX_HW1_LAST: 1871 case R_TILEGX_HW2_LAST: 1872 case R_TILEGX_COPY: 1873 case R_TILEGX_GLOB_DAT: 1874 case R_TILEGX_JMP_SLOT: 1875 case R_TILEGX_RELATIVE: 1876 case R_TILEGX_BROFF_X1: 1877 case R_TILEGX_JUMPOFF_X1: 1878 case R_TILEGX_IMM8_X0: 1879 case R_TILEGX_IMM8_Y0: 1880 case R_TILEGX_IMM8_X1: 1881 case R_TILEGX_IMM8_Y1: 1882 case R_TILEGX_DEST_IMM8_X1: 1883 case R_TILEGX_MT_IMM14_X1: 1884 case R_TILEGX_MF_IMM14_X1: 1885 case R_TILEGX_MMSTART_X0: 1886 case R_TILEGX_MMEND_X0: 1887 case R_TILEGX_SHAMT_X0: 1888 case R_TILEGX_SHAMT_X1: 1889 case R_TILEGX_SHAMT_Y0: 1890 case R_TILEGX_SHAMT_Y1: 1891 case R_TILEGX_IMM16_X0_HW0: 1892 case R_TILEGX_IMM16_X1_HW0: 1893 case R_TILEGX_IMM16_X0_HW1: 1894 case R_TILEGX_IMM16_X1_HW1: 1895 case R_TILEGX_IMM16_X0_HW2: 1896 case R_TILEGX_IMM16_X1_HW2: 1897 case R_TILEGX_IMM16_X0_HW3: 1898 case R_TILEGX_IMM16_X1_HW3: 1899 case R_TILEGX_IMM16_X0_HW0_LAST: 1900 case R_TILEGX_IMM16_X1_HW0_LAST: 1901 case R_TILEGX_IMM16_X0_HW1_LAST: 1902 case R_TILEGX_IMM16_X1_HW1_LAST: 1903 case R_TILEGX_IMM16_X0_HW2_LAST: 1904 case R_TILEGX_IMM16_X1_HW2_LAST: 1905 if (h != NULL) 1906 h->non_got_ref = 1; 1907 1908 r_tilegx_plt32: 1909 if (h != NULL && !bfd_link_pic (info)) 1910 { 1911 /* We may need a .plt entry if the function this reloc 1912 refers to is in a shared lib. */ 1913 h->plt.refcount += 1; 1914 } 1915 1916 /* If we are creating a shared library, and this is a reloc 1917 against a global symbol, or a non PC relative reloc 1918 against a local symbol, then we need to copy the reloc 1919 into the shared library. However, if we are linking with 1920 -Bsymbolic, we do not need to copy a reloc against a 1921 global symbol which is defined in an object we are 1922 including in the link (i.e., DEF_REGULAR is set). At 1923 this point we have not seen all the input files, so it is 1924 possible that DEF_REGULAR is not set now but will be set 1925 later (it is never cleared). In case of a weak definition, 1926 DEF_REGULAR may be cleared later by a strong definition in 1927 a shared library. We account for that possibility below by 1928 storing information in the relocs_copied field of the hash 1929 table entry. A similar situation occurs when creating 1930 shared libraries and symbol visibility changes render the 1931 symbol local. 1932 1933 If on the other hand, we are creating an executable, we 1934 may need to keep relocations for symbols satisfied by a 1935 dynamic library if we manage to avoid copy relocs for the 1936 symbol. */ 1937 if ((bfd_link_pic (info) 1938 && (sec->flags & SEC_ALLOC) != 0 1939 && (! tilegx_elf_howto_table[r_type].pc_relative 1940 || (h != NULL 1941 && (! info->symbolic 1942 || h->root.type == bfd_link_hash_defweak 1943 || !h->def_regular)))) 1944 || (!bfd_link_pic (info) 1945 && (sec->flags & SEC_ALLOC) != 0 1946 && h != NULL 1947 && (h->root.type == bfd_link_hash_defweak 1948 || !h->def_regular))) 1949 { 1950 struct elf_dyn_relocs *p; 1951 struct elf_dyn_relocs **head; 1952 1953 /* When creating a shared object, we must copy these 1954 relocs into the output file. We create a reloc 1955 section in dynobj and make room for the reloc. */ 1956 if (sreloc == NULL) 1957 { 1958 sreloc = _bfd_elf_make_dynamic_reloc_section 1959 (sec, htab->elf.dynobj, htab->word_align_power, abfd, 1960 /*rela?*/ true); 1961 1962 if (sreloc == NULL) 1963 return false; 1964 } 1965 1966 /* If this is a global symbol, we count the number of 1967 relocations we need for this symbol. */ 1968 if (h != NULL) 1969 head = &h->dyn_relocs; 1970 else 1971 { 1972 /* Track dynamic relocs needed for local syms too. 1973 We really need local syms available to do this 1974 easily. Oh well. */ 1975 1976 asection *s; 1977 void *vpp; 1978 Elf_Internal_Sym *isym; 1979 1980 isym = bfd_sym_from_r_symndx (&htab->elf.sym_cache, 1981 abfd, r_symndx); 1982 if (isym == NULL) 1983 return false; 1984 1985 s = bfd_section_from_elf_index (abfd, isym->st_shndx); 1986 if (s == NULL) 1987 s = sec; 1988 1989 vpp = &elf_section_data (s)->local_dynrel; 1990 head = (struct elf_dyn_relocs **) vpp; 1991 } 1992 1993 p = *head; 1994 if (p == NULL || p->sec != sec) 1995 { 1996 size_t amt = sizeof *p; 1997 p = ((struct elf_dyn_relocs *) 1998 bfd_alloc (htab->elf.dynobj, amt)); 1999 if (p == NULL) 2000 return false; 2001 p->next = *head; 2002 *head = p; 2003 p->sec = sec; 2004 p->count = 0; 2005 p->pc_count = 0; 2006 } 2007 2008 p->count += 1; 2009 if (tilegx_elf_howto_table[r_type].pc_relative) 2010 p->pc_count += 1; 2011 } 2012 2013 break; 2014 2015 case R_TILEGX_GNU_VTINHERIT: 2016 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset)) 2017 return false; 2018 break; 2019 2020 case R_TILEGX_GNU_VTENTRY: 2021 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend)) 2022 return false; 2023 break; 2024 2025 default: 2026 break; 2027 } 2028 } 2029 2030 return true; 2031 } 2032 2033 2034 asection * 2036 tilegx_elf_gc_mark_hook (asection *sec, 2037 struct bfd_link_info *info, 2038 Elf_Internal_Rela *rel, 2039 struct elf_link_hash_entry *h, 2040 Elf_Internal_Sym *sym) 2041 { 2042 if (h != NULL) 2043 { 2044 switch (TILEGX_ELF_R_TYPE (rel->r_info)) 2045 { 2046 case R_TILEGX_GNU_VTINHERIT: 2047 case R_TILEGX_GNU_VTENTRY: 2048 return NULL; 2049 } 2050 } 2051 2052 /* FIXME: The test here, in check_relocs and in relocate_section 2053 dealing with TLS optimization, ought to be !bfd_link_executable (info). */ 2054 if (bfd_link_pic (info)) 2055 { 2056 struct bfd_link_hash_entry *bh; 2057 2058 switch (TILEGX_ELF_R_TYPE (rel->r_info)) 2059 { 2060 case R_TILEGX_TLS_GD_CALL: 2061 /* This reloc implicitly references __tls_get_addr. We know 2062 another reloc will reference the same symbol as the one 2063 on this reloc, so the real symbol and section will be 2064 gc marked when processing the other reloc. That lets 2065 us handle __tls_get_addr here. */ 2066 bh = NULL; 2067 if (! _bfd_generic_link_add_one_symbol (info, sec->owner, 2068 "__tls_get_addr", 0, 2069 bfd_und_section_ptr, 2070 0, NULL, false, 2071 false, &bh)) 2072 return NULL; 2073 h = (struct elf_link_hash_entry *) bh; 2074 BFD_ASSERT (h != NULL); 2075 h->mark = 1; 2076 if (h->is_weakalias) 2077 weakdef (h)->mark = 1; 2078 sym = NULL; 2079 } 2080 } 2081 2082 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym); 2083 } 2084 2085 /* Adjust a symbol defined by a dynamic object and referenced by a 2086 regular object. The current definition is in some section of the 2087 dynamic object, but we're not including those sections. We have to 2088 change the definition to something the rest of the link can 2089 understand. */ 2090 2091 bool 2092 tilegx_elf_adjust_dynamic_symbol (struct bfd_link_info *info, 2093 struct elf_link_hash_entry *h) 2094 { 2095 struct tilegx_elf_link_hash_table *htab; 2096 bfd *dynobj; 2097 asection *s, *srel; 2098 2099 htab = tilegx_elf_hash_table (info); 2100 BFD_ASSERT (htab != NULL); 2101 2102 dynobj = htab->elf.dynobj; 2103 2104 /* Make sure we know what is going on here. */ 2105 BFD_ASSERT (dynobj != NULL 2106 && (h->needs_plt 2107 || h->is_weakalias 2108 || (h->def_dynamic 2109 && h->ref_regular 2110 && !h->def_regular))); 2111 2112 /* If this is a function, put it in the procedure linkage table. We 2113 will fill in the contents of the procedure linkage table later 2114 (although we could actually do it here). */ 2115 if (h->type == STT_FUNC || h->needs_plt) 2116 { 2117 if (h->plt.refcount <= 0 2118 || SYMBOL_CALLS_LOCAL (info, h) 2119 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT 2120 && h->root.type == bfd_link_hash_undefweak)) 2121 { 2122 /* This case can occur if we saw a R_TILEGX_JUMPOFF_X1_PLT 2123 reloc in an input file, but the symbol was never referred 2124 to by a dynamic object, or if all references were garbage 2125 collected. In such a case, we don't actually need to build 2126 a procedure linkage table, and we can just do a 2127 R_TILEGX_JUMPOFF_X1 relocation instead. */ 2128 h->plt.offset = (bfd_vma) -1; 2129 h->needs_plt = 0; 2130 } 2131 2132 return true; 2133 } 2134 else 2135 h->plt.offset = (bfd_vma) -1; 2136 2137 /* If this is a weak symbol, and there is a real definition, the 2138 processor independent code will have arranged for us to see the 2139 real definition first, and we can just use the same value. */ 2140 if (h->is_weakalias) 2141 { 2142 struct elf_link_hash_entry *def = weakdef (h); 2143 BFD_ASSERT (def->root.type == bfd_link_hash_defined); 2144 h->root.u.def.section = def->root.u.def.section; 2145 h->root.u.def.value = def->root.u.def.value; 2146 return true; 2147 } 2148 2149 /* This is a reference to a symbol defined by a dynamic object which 2150 is not a function. */ 2151 2152 /* If we are creating a shared library, we must presume that the 2153 only references to the symbol are via the global offset table. 2154 For such cases we need not do anything here; the relocations will 2155 be handled correctly by relocate_section. */ 2156 if (bfd_link_pic (info)) 2157 return true; 2158 2159 /* If there are no references to this symbol that do not use the 2160 GOT, we don't need to generate a copy reloc. */ 2161 if (!h->non_got_ref) 2162 return true; 2163 2164 /* If -z nocopyreloc was given, we won't generate them either. */ 2165 if (info->nocopyreloc) 2166 { 2167 h->non_got_ref = 0; 2168 return true; 2169 } 2170 2171 /* If we don't find any dynamic relocs in read-only sections, then 2172 we'll be keeping the dynamic relocs and avoiding the copy reloc. */ 2173 if (!_bfd_elf_readonly_dynrelocs (h)) 2174 { 2175 h->non_got_ref = 0; 2176 return true; 2177 } 2178 2179 /* We must allocate the symbol in our .dynbss section, which will 2180 become part of the .bss section of the executable. There will be 2181 an entry for this symbol in the .dynsym section. The dynamic 2182 object will contain position independent code, so all references 2183 from the dynamic object to this symbol will go through the global 2184 offset table. The dynamic linker will use the .dynsym entry to 2185 determine the address it must put in the global offset table, so 2186 both the dynamic object and the regular object will refer to the 2187 same memory location for the variable. */ 2188 2189 /* We must generate a R_TILEGX_COPY reloc to tell the dynamic linker 2190 to copy the initial value out of the dynamic object and into the 2191 runtime process image. We need to remember the offset into the 2192 .rel.bss section we are going to use. */ 2193 if ((h->root.u.def.section->flags & SEC_READONLY) != 0) 2194 { 2195 s = htab->elf.sdynrelro; 2196 srel = htab->elf.sreldynrelro; 2197 } 2198 else 2199 { 2200 s = htab->elf.sdynbss; 2201 srel = htab->elf.srelbss; 2202 } 2203 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0) 2204 { 2205 srel->size += TILEGX_ELF_RELA_BYTES (htab); 2206 h->needs_copy = 1; 2207 } 2208 2209 return _bfd_elf_adjust_dynamic_copy (info, h, s); 2210 } 2211 2212 /* Allocate space in .plt, .got and associated reloc sections for 2213 dynamic relocs. */ 2214 2215 static bool 2216 allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf) 2217 { 2218 struct bfd_link_info *info; 2219 struct tilegx_elf_link_hash_table *htab; 2220 struct elf_dyn_relocs *p; 2221 2222 if (h->root.type == bfd_link_hash_indirect) 2223 return true; 2224 2225 info = (struct bfd_link_info *) inf; 2226 htab = tilegx_elf_hash_table (info); 2227 BFD_ASSERT (htab != NULL); 2228 2229 if (htab->elf.dynamic_sections_created 2230 && h->plt.refcount > 0) 2231 { 2232 /* Make sure this symbol is output as a dynamic symbol. 2233 Undefined weak syms won't yet be marked as dynamic. */ 2234 if (h->dynindx == -1 2235 && !h->forced_local) 2236 { 2237 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 2238 return false; 2239 } 2240 2241 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h)) 2242 { 2243 asection *s = htab->elf.splt; 2244 2245 /* Allocate room for the header and tail. */ 2246 if (s->size == 0) 2247 { 2248 s->size = PLT_ENTRY_SIZE; 2249 } 2250 2251 h->plt.offset = s->size - PLT_ENTRY_SIZE + PLT_HEADER_SIZE; 2252 2253 /* If this symbol is not defined in a regular file, and we are 2254 not generating a shared library, then set the symbol to this 2255 location in the .plt. This is required to make function 2256 pointers compare as equal between the normal executable and 2257 the shared library. */ 2258 if (! bfd_link_pic (info) 2259 && !h->def_regular) 2260 { 2261 h->root.u.def.section = s; 2262 h->root.u.def.value = h->plt.offset; 2263 } 2264 2265 /* Make room for this entry. */ 2266 s->size += PLT_ENTRY_SIZE; 2267 2268 /* We also need to make an entry in the .got.plt section. */ 2269 htab->elf.sgotplt->size += GOT_ENTRY_SIZE (htab); 2270 2271 /* We also need to make an entry in the .rela.plt section. */ 2272 htab->elf.srelplt->size += TILEGX_ELF_RELA_BYTES (htab); 2273 } 2274 else 2275 { 2276 h->plt.offset = (bfd_vma) -1; 2277 h->needs_plt = 0; 2278 } 2279 } 2280 else 2281 { 2282 h->plt.offset = (bfd_vma) -1; 2283 h->needs_plt = 0; 2284 } 2285 2286 /* If a TLS_IE symbol is now local to the binary, make it a TLS_LE 2287 requiring no TLS entry. */ 2288 if (h->got.refcount > 0 2289 && !htab->disable_le_transition 2290 && bfd_link_executable (info) 2291 && h->dynindx == -1 2292 && tilegx_elf_hash_entry(h)->tls_type == GOT_TLS_IE) 2293 h->got.offset = (bfd_vma) -1; 2294 else if (h->got.refcount > 0) 2295 { 2296 asection *s; 2297 bool dyn; 2298 int tls_type = tilegx_elf_hash_entry(h)->tls_type; 2299 2300 /* Make sure this symbol is output as a dynamic symbol. 2301 Undefined weak syms won't yet be marked as dynamic. */ 2302 if (h->dynindx == -1 2303 && !h->forced_local) 2304 { 2305 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 2306 return false; 2307 } 2308 2309 s = htab->elf.sgot; 2310 h->got.offset = s->size; 2311 s->size += TILEGX_ELF_WORD_BYTES (htab); 2312 /* TLS_GD entries need 2 consecutive GOT slots. */ 2313 if (tls_type == GOT_TLS_GD) 2314 s->size += TILEGX_ELF_WORD_BYTES (htab); 2315 dyn = htab->elf.dynamic_sections_created; 2316 /* TLS_IE needs one dynamic relocation, 2317 TLS_GD needs two if local symbol and two if global. */ 2318 if (tls_type == GOT_TLS_GD || tls_type == GOT_TLS_IE) 2319 htab->elf.srelgot->size += 2 * TILEGX_ELF_RELA_BYTES (htab); 2320 else if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 2321 bfd_link_pic (info), 2322 h)) 2323 htab->elf.srelgot->size += TILEGX_ELF_RELA_BYTES (htab); 2324 } 2325 else 2326 h->got.offset = (bfd_vma) -1; 2327 2328 if (h->dyn_relocs == NULL) 2329 return true; 2330 2331 /* In the shared -Bsymbolic case, discard space allocated for 2332 dynamic pc-relative relocs against symbols which turn out to be 2333 defined in regular objects. For the normal shared case, discard 2334 space for pc-relative relocs that have become local due to symbol 2335 visibility changes. */ 2336 2337 if (bfd_link_pic (info)) 2338 { 2339 if (SYMBOL_CALLS_LOCAL (info, h)) 2340 { 2341 struct elf_dyn_relocs **pp; 2342 2343 for (pp = &h->dyn_relocs; (p = *pp) != NULL; ) 2344 { 2345 p->count -= p->pc_count; 2346 p->pc_count = 0; 2347 if (p->count == 0) 2348 *pp = p->next; 2349 else 2350 pp = &p->next; 2351 } 2352 } 2353 2354 /* Also discard relocs on undefined weak syms with non-default 2355 visibility. */ 2356 if (h->dyn_relocs != NULL 2357 && h->root.type == bfd_link_hash_undefweak) 2358 { 2359 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT 2360 || UNDEFWEAK_NO_DYNAMIC_RELOC (info, h)) 2361 h->dyn_relocs = NULL; 2362 2363 /* Make sure undefined weak symbols are output as a dynamic 2364 symbol in PIEs. */ 2365 else if (h->dynindx == -1 2366 && !h->forced_local) 2367 { 2368 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 2369 return false; 2370 } 2371 } 2372 } 2373 else 2374 { 2375 /* For the non-shared case, discard space for relocs against 2376 symbols which turn out to need copy relocs or are not 2377 dynamic. */ 2378 2379 if (!h->non_got_ref 2380 && ((h->def_dynamic 2381 && !h->def_regular) 2382 || (htab->elf.dynamic_sections_created 2383 && (h->root.type == bfd_link_hash_undefweak 2384 || h->root.type == bfd_link_hash_undefined)))) 2385 { 2386 /* Make sure this symbol is output as a dynamic symbol. 2387 Undefined weak syms won't yet be marked as dynamic. */ 2388 if (h->dynindx == -1 2389 && !h->forced_local) 2390 { 2391 if (! bfd_elf_link_record_dynamic_symbol (info, h)) 2392 return false; 2393 } 2394 2395 /* If that succeeded, we know we'll be keeping all the 2396 relocs. */ 2397 if (h->dynindx != -1) 2398 goto keep; 2399 } 2400 2401 h->dyn_relocs = NULL; 2402 2403 keep: ; 2404 } 2405 2406 /* Finally, allocate space. */ 2407 for (p = h->dyn_relocs; p != NULL; p = p->next) 2408 { 2409 asection *sreloc = elf_section_data (p->sec)->sreloc; 2410 sreloc->size += p->count * TILEGX_ELF_RELA_BYTES (htab); 2411 } 2412 2413 return true; 2414 } 2415 2416 /* Return true if the dynamic symbol for a given section should be 2417 omitted when creating a shared library. */ 2418 2419 bool 2420 tilegx_elf_omit_section_dynsym (bfd *output_bfd, 2421 struct bfd_link_info *info, 2422 asection *p) 2423 { 2424 /* We keep the .got section symbol so that explicit relocations 2425 against the _GLOBAL_OFFSET_TABLE_ symbol emitted in PIC mode 2426 can be turned into relocations against the .got symbol. */ 2427 if (strcmp (p->name, ".got") == 0) 2428 return false; 2429 2430 return _bfd_elf_omit_section_dynsym_default (output_bfd, info, p); 2431 } 2432 2433 bool 2434 tilegx_elf_late_size_sections (bfd *output_bfd ATTRIBUTE_UNUSED, 2435 struct bfd_link_info *info) 2436 { 2437 struct tilegx_elf_link_hash_table *htab; 2438 bfd *dynobj; 2439 asection *s; 2440 bfd *ibfd; 2441 2442 htab = tilegx_elf_hash_table (info); 2443 BFD_ASSERT (htab != NULL); 2444 dynobj = htab->elf.dynobj; 2445 if (dynobj == NULL) 2446 return true; 2447 2448 if (elf_hash_table (info)->dynamic_sections_created) 2449 { 2450 /* Set the contents of the .interp section to the interpreter. */ 2451 if (bfd_link_executable (info) && !info->nointerp) 2452 { 2453 s = bfd_get_linker_section (dynobj, ".interp"); 2454 BFD_ASSERT (s != NULL); 2455 s->size = strlen (htab->dynamic_interpreter) + 1; 2456 s->contents = (unsigned char *) htab->dynamic_interpreter; 2457 s->alloced = 1; 2458 } 2459 } 2460 2461 /* Set up .got offsets for local syms, and space for local dynamic 2462 relocs. */ 2463 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next) 2464 { 2465 bfd_signed_vma *local_got; 2466 bfd_signed_vma *end_local_got; 2467 char *local_tls_type; 2468 bfd_size_type locsymcount; 2469 Elf_Internal_Shdr *symtab_hdr; 2470 asection *srel; 2471 2472 if (! is_tilegx_elf (ibfd)) 2473 continue; 2474 2475 for (s = ibfd->sections; s != NULL; s = s->next) 2476 { 2477 struct elf_dyn_relocs *p; 2478 2479 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next) 2480 { 2481 if (!bfd_is_abs_section (p->sec) 2482 && bfd_is_abs_section (p->sec->output_section)) 2483 { 2484 /* Input section has been discarded, either because 2485 it is a copy of a linkonce section or due to 2486 linker script /DISCARD/, so we'll be discarding 2487 the relocs too. */ 2488 } 2489 else if (p->count != 0) 2490 { 2491 srel = elf_section_data (p->sec)->sreloc; 2492 srel->size += p->count * TILEGX_ELF_RELA_BYTES (htab); 2493 if ((p->sec->output_section->flags & SEC_READONLY) != 0) 2494 { 2495 info->flags |= DF_TEXTREL; 2496 2497 info->callbacks->minfo (_("%pB: dynamic relocation in read-only section `%pA'\n"), 2498 p->sec->owner, p->sec); 2499 } 2500 } 2501 } 2502 } 2503 2504 local_got = elf_local_got_refcounts (ibfd); 2505 if (!local_got) 2506 continue; 2507 2508 symtab_hdr = &elf_symtab_hdr (ibfd); 2509 locsymcount = symtab_hdr->sh_info; 2510 end_local_got = local_got + locsymcount; 2511 local_tls_type = _bfd_tilegx_elf_local_got_tls_type (ibfd); 2512 s = htab->elf.sgot; 2513 srel = htab->elf.srelgot; 2514 for (; local_got < end_local_got; ++local_got, ++local_tls_type) 2515 { 2516 if (*local_got > 0) 2517 { 2518 *local_got = s->size; 2519 s->size += TILEGX_ELF_WORD_BYTES (htab); 2520 if (*local_tls_type == GOT_TLS_GD) 2521 s->size += TILEGX_ELF_WORD_BYTES (htab); 2522 if (bfd_link_pic (info) 2523 || *local_tls_type == GOT_TLS_GD 2524 || *local_tls_type == GOT_TLS_IE) 2525 srel->size += TILEGX_ELF_RELA_BYTES (htab); 2526 } 2527 else 2528 *local_got = (bfd_vma) -1; 2529 } 2530 } 2531 2532 /* Allocate global sym .plt and .got entries, and space for global 2533 sym dynamic relocs. */ 2534 elf_link_hash_traverse (&htab->elf, allocate_dynrelocs, info); 2535 2536 if (elf_hash_table (info)->dynamic_sections_created) 2537 { 2538 /* If the .got section is more than 0x8000 bytes, we add 2539 0x8000 to the value of _GLOBAL_OFFSET_TABLE_, so that 16 2540 bit relocations have a greater chance of working. */ 2541 if (htab->elf.sgot->size >= 0x8000 2542 && elf_hash_table (info)->hgot->root.u.def.value == 0) 2543 elf_hash_table (info)->hgot->root.u.def.value = 0x8000; 2544 } 2545 2546 if (htab->elf.sgotplt) 2547 { 2548 struct elf_link_hash_entry *got; 2549 got = elf_link_hash_lookup (elf_hash_table (info), 2550 "_GLOBAL_OFFSET_TABLE_", 2551 false, false, false); 2552 2553 /* Don't allocate .got.plt section if there are no GOT nor PLT 2554 entries and there is no refeence to _GLOBAL_OFFSET_TABLE_. */ 2555 if ((got == NULL 2556 || !got->ref_regular_nonweak) 2557 && (htab->elf.sgotplt->size 2558 == (unsigned)GOTPLT_HEADER_SIZE (htab)) 2559 && (htab->elf.splt == NULL 2560 || htab->elf.splt->size == 0) 2561 && (htab->elf.sgot == NULL 2562 || (htab->elf.sgot->size 2563 == get_elf_backend_data (output_bfd)->got_header_size))) 2564 htab->elf.sgotplt->size = 0; 2565 } 2566 2567 /* The check_relocs and adjust_dynamic_symbol entry points have 2568 determined the sizes of the various dynamic sections. Allocate 2569 memory for them. */ 2570 for (s = dynobj->sections; s != NULL; s = s->next) 2571 { 2572 if ((s->flags & SEC_LINKER_CREATED) == 0) 2573 continue; 2574 2575 if (s == htab->elf.splt 2576 || s == htab->elf.sgot 2577 || s == htab->elf.sgotplt 2578 || s == htab->elf.sdynbss 2579 || s == htab->elf.sdynrelro) 2580 { 2581 /* Strip this section if we don't need it; see the 2582 comment below. */ 2583 } 2584 else if (startswith (s->name, ".rela")) 2585 { 2586 if (s->size != 0) 2587 { 2588 /* We use the reloc_count field as a counter if we need 2589 to copy relocs into the output file. */ 2590 s->reloc_count = 0; 2591 } 2592 } 2593 else 2594 { 2595 /* It's not one of our sections. */ 2596 continue; 2597 } 2598 2599 if (s->size == 0) 2600 { 2601 /* If we don't need this section, strip it from the 2602 output file. This is mostly to handle .rela.bss and 2603 .rela.plt. We must create both sections in 2604 create_dynamic_sections, because they must be created 2605 before the linker maps input sections to output 2606 sections. The linker does that before 2607 adjust_dynamic_symbol is called, and it is that 2608 function which decides whether anything needs to go 2609 into these sections. */ 2610 s->flags |= SEC_EXCLUDE; 2611 continue; 2612 } 2613 2614 if ((s->flags & SEC_HAS_CONTENTS) == 0) 2615 continue; 2616 2617 /* Allocate memory for the section contents. Zero the memory 2618 for the benefit of .rela.plt, which has 4 unused entries 2619 at the beginning, and we don't want garbage. */ 2620 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size); 2621 if (s->contents == NULL) 2622 return false; 2623 s->alloced = 1; 2624 } 2625 2626 return _bfd_elf_add_dynamic_tags (output_bfd, info, true); 2627 } 2628 2629 /* Return the base VMA address which should be subtracted from real addresses 2631 when resolving @dtpoff relocation. 2632 This is PT_TLS segment p_vaddr. */ 2633 2634 static bfd_vma 2635 dtpoff_base (struct bfd_link_info *info) 2636 { 2637 /* If tls_sec is NULL, we should have signalled an error already. */ 2638 if (elf_hash_table (info)->tls_sec == NULL) 2639 return 0; 2640 return elf_hash_table (info)->tls_sec->vma; 2641 } 2642 2643 /* Return the relocation value for @tpoff relocation. */ 2644 2645 static bfd_vma 2646 tpoff (struct bfd_link_info *info, bfd_vma address) 2647 { 2648 struct elf_link_hash_table *htab = elf_hash_table (info); 2649 2650 /* If tls_sec is NULL, we should have signalled an error already. */ 2651 if (htab->tls_sec == NULL) 2652 return 0; 2653 2654 return (address - htab->tls_sec->vma); 2655 } 2656 2657 /* Copy SIZE bits from FROM to TO at address ADDR. */ 2658 2659 static void 2660 tilegx_copy_bits (bfd_byte *addr, int from, int to, int size) 2661 { 2662 int i; 2663 for (i = 0; i < size; i++) 2664 { 2665 int from_byte = (from + i) / 8; 2666 int from_bit = (from + i) % 8; 2667 int to_byte = (to + i) / 8; 2668 int to_bit = (to + i) % 8; 2669 bfd_byte to_mask = 1 << to_bit; 2670 addr[to_byte] = (addr[to_byte] & ~to_mask) 2671 | ((addr[from_byte] >> from_bit << to_bit) & to_mask); 2672 } 2673 } 2674 2675 /* Replace the MASK bits in ADDR with those in INSN, for the next 2676 TILEGX_BUNDLE_SIZE_IN_BYTES bytes. */ 2677 2678 static void 2679 tilegx_replace_insn (bfd_byte *addr, const bfd_byte *mask, 2680 const bfd_byte *insn) 2681 { 2682 int i; 2683 for (i = 0; i < TILEGX_BUNDLE_SIZE_IN_BYTES; i++) 2684 { 2685 addr[i] = (addr[i] & ~mask[i]) | (insn[i] & mask[i]); 2686 } 2687 } 2688 2689 /* Mask to extract the bits corresponding to an instruction in a 2690 specific pipe of a bundle. */ 2691 static const bfd_byte insn_mask_X1[] = { 2692 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff, 0x3f 2693 }; 2694 2695 /* Mask to extract the bits corresponding to an instruction in a 2696 specific pipe of a bundle, minus the destination operand and the 2697 first source operand. */ 2698 static const bfd_byte insn_mask_X0_no_dest_no_srca[] = { 2699 0x00, 0xf0, 0xff, 0x7f, 0x00, 0x00, 0x00, 0x00 2700 }; 2701 2702 static const bfd_byte insn_mask_X1_no_dest_no_srca[] = { 2703 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0xff, 0x3f 2704 }; 2705 2706 static const bfd_byte insn_mask_Y0_no_dest_no_srca[] = { 2707 0x00, 0xf0, 0x0f, 0x78, 0x00, 0x00, 0x00, 0x00 2708 }; 2709 static const bfd_byte insn_mask_Y1_no_dest_no_srca[] = { 2710 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x07, 0x3c 2711 }; 2712 2713 /* Mask to extract the bits corresponding to an instruction in a 2714 specific pipe of a bundle, minus the register operands. */ 2715 static const bfd_byte insn_mask_X0_no_operand[] = { 2716 0x00, 0x00, 0xfc, 0x7f, 0x00, 0x00, 0x00, 0x00 2717 }; 2718 2719 static const bfd_byte insn_mask_X1_no_operand[] = { 2720 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x3f 2721 }; 2722 2723 static const bfd_byte insn_mask_Y0_no_operand[] = { 2724 0x00, 0x00, 0x0c, 0x78, 0x00, 0x00, 0x00, 0x00 2725 }; 2726 2727 static const bfd_byte insn_mask_Y1_no_operand[] = { 2728 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x3c 2729 }; 2730 2731 /* Various instructions synthesized to support tls references. */ 2732 2733 /* ld r0, r0 in the X1 pipe, used for tls ie. */ 2734 static const bfd_byte insn_tls_ie_ld_X1[] = { 2735 0x00, 0x00, 0x00, 0x00, 0x00, 0xe8, 0x6a, 0x28 2736 }; 2737 2738 /* ld4s r0, r0 in the X1 pipe, used for tls ie. */ 2739 static const bfd_byte insn_tls_ie_ld4s_X1[] = { 2740 0x00, 0x00, 0x00, 0x00, 0x00, 0x98, 0x6a, 0x28 2741 }; 2742 2743 /* add r0, r0, tp in various pipes, used for tls ie. */ 2744 static const bfd_byte insn_tls_ie_add_X0X1[] = { 2745 0x00, 0x50, 0x0f, 0x50, 0x00, 0xa8, 0x07, 0x28 2746 }; 2747 static const bfd_byte insn_tls_ie_add_Y0Y1[] = { 2748 0x00, 0x50, 0x27, 0x2c, 0x00, 0xa8, 0x13, 0x9a 2749 }; 2750 2751 /* addx r0, r0, tp in various pipes, used for tls ie. */ 2752 static const bfd_byte insn_tls_ie_addx_X0X1[] = { 2753 0x00, 0x50, 0x0b, 0x50, 0x00, 0xa8, 0x05, 0x28 2754 }; 2755 static const bfd_byte insn_tls_ie_addx_Y0Y1[] = { 2756 0x00, 0x50, 0x03, 0x2c, 0x00, 0xa8, 0x01, 0x9a 2757 }; 2758 2759 /* move r0, r0 in various pipes, used for tls gd. */ 2760 static const bfd_byte insn_tls_gd_add_X0X1[] = { 2761 0x00, 0xf0, 0x07, 0x51, 0x00, 0xf8, 0x3b, 0x28 2762 }; 2763 static const bfd_byte insn_tls_gd_add_Y0Y1[] = { 2764 0x00, 0xf0, 0x0b, 0x54, 0x00, 0xf8, 0x05, 0xae 2765 }; 2766 2767 static const bfd_byte *insn_move_X0X1 = insn_tls_gd_add_X0X1; 2768 static const bfd_byte *insn_move_Y0Y1 = insn_tls_gd_add_Y0Y1; 2769 2770 static const bfd_byte *insn_add_X0X1 = insn_tls_ie_add_X0X1; 2771 static const bfd_byte *insn_add_Y0Y1 = insn_tls_ie_add_Y0Y1; 2772 2773 static const bfd_byte *insn_addx_X0X1 = insn_tls_ie_addx_X0X1; 2774 static const bfd_byte *insn_addx_Y0Y1 = insn_tls_ie_addx_Y0Y1; 2775 2776 /* Relocate an TILEGX ELF section. 2777 2778 The RELOCATE_SECTION function is called by the new ELF backend linker 2779 to handle the relocations for a section. 2780 2781 The relocs are always passed as Rela structures. 2782 2783 This function is responsible for adjusting the section contents as 2784 necessary, and (if generating a relocatable output file) adjusting 2785 the reloc addend as necessary. 2786 2787 This function does not have to worry about setting the reloc 2788 address or the reloc symbol index. 2789 2790 LOCAL_SYMS is a pointer to the swapped in local symbols. 2791 2792 LOCAL_SECTIONS is an array giving the section in the input file 2793 corresponding to the st_shndx field of each local symbol. 2794 2795 The global hash table entry for the global symbols can be found 2796 via elf_sym_hashes (input_bfd). 2797 2798 When generating relocatable output, this function must handle 2799 STB_LOCAL/STT_SECTION symbols specially. The output symbol is 2800 going to be the section symbol corresponding to the output 2801 section, which means that the addend must be adjusted 2802 accordingly. */ 2803 2804 int 2805 tilegx_elf_relocate_section (bfd *output_bfd, struct bfd_link_info *info, 2806 bfd *input_bfd, asection *input_section, 2807 bfd_byte *contents, Elf_Internal_Rela *relocs, 2808 Elf_Internal_Sym *local_syms, 2809 asection **local_sections) 2810 { 2811 struct tilegx_elf_link_hash_table *htab; 2812 Elf_Internal_Shdr *symtab_hdr; 2813 struct elf_link_hash_entry **sym_hashes; 2814 bfd_vma *local_got_offsets; 2815 bfd_vma got_base; 2816 asection *sreloc; 2817 Elf_Internal_Rela *rel; 2818 Elf_Internal_Rela *relend; 2819 int num_relocs; 2820 2821 htab = tilegx_elf_hash_table (info); 2822 BFD_ASSERT (htab != NULL); 2823 symtab_hdr = &elf_symtab_hdr (input_bfd); 2824 sym_hashes = elf_sym_hashes (input_bfd); 2825 local_got_offsets = elf_local_got_offsets (input_bfd); 2826 2827 if (elf_hash_table (info)->hgot == NULL) 2828 got_base = 0; 2829 else 2830 got_base = elf_hash_table (info)->hgot->root.u.def.value; 2831 2832 sreloc = elf_section_data (input_section)->sreloc; 2833 2834 rel = relocs; 2835 num_relocs = input_section->reloc_count; 2836 relend = relocs + num_relocs; 2837 for (; rel < relend; rel++) 2838 { 2839 int r_type, tls_type; 2840 bool is_tls_iele, is_tls_le; 2841 reloc_howto_type *howto; 2842 unsigned long r_symndx; 2843 struct elf_link_hash_entry *h; 2844 Elf_Internal_Sym *sym; 2845 tilegx_create_func create_func; 2846 asection *sec; 2847 bfd_vma relocation; 2848 bfd_reloc_status_type r; 2849 const char *name; 2850 bfd_vma off; 2851 bool is_plt = false; 2852 bool resolved_to_zero; 2853 bool unresolved_reloc; 2854 2855 r_type = TILEGX_ELF_R_TYPE (rel->r_info); 2856 if (r_type == R_TILEGX_GNU_VTINHERIT 2857 || r_type == R_TILEGX_GNU_VTENTRY) 2858 continue; 2859 2860 if ((unsigned int)r_type >= ARRAY_SIZE (tilegx_elf_howto_table)) 2861 return _bfd_unrecognized_reloc (input_bfd, input_section, r_type); 2862 2863 howto = tilegx_elf_howto_table + r_type; 2864 2865 /* This is a final link. */ 2866 r_symndx = TILEGX_ELF_R_SYMNDX (htab, rel->r_info); 2867 h = NULL; 2868 sym = NULL; 2869 sec = NULL; 2870 unresolved_reloc = false; 2871 if (r_symndx < symtab_hdr->sh_info) 2872 { 2873 sym = local_syms + r_symndx; 2874 sec = local_sections[r_symndx]; 2875 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel); 2876 } 2877 else 2878 { 2879 bool warned ATTRIBUTE_UNUSED; 2880 bool ignored ATTRIBUTE_UNUSED; 2881 2882 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel, 2883 r_symndx, symtab_hdr, sym_hashes, 2884 h, sec, relocation, 2885 unresolved_reloc, warned, ignored); 2886 if (warned) 2887 { 2888 /* To avoid generating warning messages about truncated 2889 relocations, set the relocation's address to be the same as 2890 the start of this section. */ 2891 if (input_section->output_section != NULL) 2892 relocation = input_section->output_section->vma; 2893 else 2894 relocation = 0; 2895 } 2896 } 2897 2898 if (sec != NULL && discarded_section (sec)) 2899 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section, 2900 rel, 1, relend, howto, 0, contents); 2901 2902 if (bfd_link_relocatable (info)) 2903 continue; 2904 2905 if (h != NULL) 2906 name = h->root.root.string; 2907 else 2908 { 2909 name = (bfd_elf_string_from_elf_section 2910 (input_bfd, symtab_hdr->sh_link, sym->st_name)); 2911 if (name == NULL || *name == '\0') 2912 name = bfd_section_name (sec); 2913 } 2914 2915 switch (r_type) 2916 { 2917 case R_TILEGX_TLS_GD_CALL: 2918 case R_TILEGX_IMM8_X0_TLS_GD_ADD: 2919 case R_TILEGX_IMM8_Y0_TLS_GD_ADD: 2920 case R_TILEGX_IMM8_X1_TLS_GD_ADD: 2921 case R_TILEGX_IMM8_Y1_TLS_GD_ADD: 2922 case R_TILEGX_IMM8_X0_TLS_ADD: 2923 case R_TILEGX_IMM8_Y0_TLS_ADD: 2924 case R_TILEGX_IMM8_X1_TLS_ADD: 2925 case R_TILEGX_IMM8_Y1_TLS_ADD: 2926 tls_type = GOT_UNKNOWN; 2927 if (h == NULL && local_got_offsets) 2928 tls_type = 2929 _bfd_tilegx_elf_local_got_tls_type (input_bfd) [r_symndx]; 2930 else if (h != NULL) 2931 tls_type = tilegx_elf_hash_entry(h)->tls_type; 2932 2933 is_tls_iele = (bfd_link_executable (info) || tls_type == GOT_TLS_IE); 2934 is_tls_le = is_tls_iele && (!input_section->sec_flg0 2935 && bfd_link_executable (info) 2936 && (h == NULL || h->dynindx == -1)); 2937 2938 if (r_type == R_TILEGX_TLS_GD_CALL) 2939 { 2940 if (is_tls_le) 2941 { 2942 /* GD -> LE */ 2943 tilegx_replace_insn (contents + rel->r_offset, 2944 insn_mask_X1, insn_move_X0X1); 2945 continue; 2946 } 2947 else if (is_tls_iele) 2948 { 2949 /* GD -> IE */ 2950 if (ABI_64_P (output_bfd)) 2951 tilegx_replace_insn (contents + rel->r_offset, 2952 insn_mask_X1, insn_tls_ie_ld_X1); 2953 else 2954 tilegx_replace_insn (contents + rel->r_offset, 2955 insn_mask_X1, insn_tls_ie_ld4s_X1); 2956 continue; 2957 } 2958 2959 /* GD -> GD */ 2960 h = (struct elf_link_hash_entry *) 2961 bfd_link_hash_lookup (info->hash, "__tls_get_addr", false, 2962 false, true); 2963 BFD_ASSERT (h != NULL); 2964 r_type = R_TILEGX_JUMPOFF_X1_PLT; 2965 howto = tilegx_elf_howto_table + r_type; 2966 } 2967 else if (r_type == R_TILEGX_IMM8_X0_TLS_ADD 2968 || r_type == R_TILEGX_IMM8_X1_TLS_ADD 2969 || r_type == R_TILEGX_IMM8_Y0_TLS_ADD 2970 || r_type == R_TILEGX_IMM8_Y1_TLS_ADD) 2971 { 2972 bool is_pipe0 = 2973 (r_type == R_TILEGX_IMM8_X0_TLS_ADD 2974 || r_type == R_TILEGX_IMM8_Y0_TLS_ADD); 2975 bool is_X0X1 = 2976 (r_type == R_TILEGX_IMM8_X0_TLS_ADD 2977 || r_type == R_TILEGX_IMM8_X1_TLS_ADD); 2978 int dest_begin = is_pipe0 ? 0 : 31; 2979 int src_begin; 2980 const bfd_byte *insn; 2981 const bfd_byte *mask = NULL; 2982 2983 if (is_tls_le) 2984 { 2985 /* 1. copy dest operand into the first source operand. 2986 2. change the opcode to "move". */ 2987 src_begin = is_pipe0 ? 6 : 37; 2988 insn = is_X0X1 ? insn_move_X0X1 : insn_move_Y0Y1; 2989 2990 switch (r_type) 2991 { 2992 case R_TILEGX_IMM8_X0_TLS_ADD: 2993 mask = insn_mask_X0_no_dest_no_srca; 2994 break; 2995 case R_TILEGX_IMM8_X1_TLS_ADD: 2996 mask = insn_mask_X1_no_dest_no_srca; 2997 break; 2998 case R_TILEGX_IMM8_Y0_TLS_ADD: 2999 mask = insn_mask_Y0_no_dest_no_srca; 3000 break; 3001 case R_TILEGX_IMM8_Y1_TLS_ADD: 3002 mask = insn_mask_Y1_no_dest_no_srca; 3003 break; 3004 } 3005 } 3006 else 3007 { 3008 /* 1. copy dest operand into the second source operand. 3009 2. change the opcode to "add". */ 3010 src_begin = is_pipe0 ? 12 : 43; 3011 if (ABI_64_P (output_bfd)) 3012 insn = is_X0X1 ? insn_add_X0X1 : insn_add_Y0Y1; 3013 else 3014 insn = is_X0X1 ? insn_addx_X0X1 : insn_addx_Y0Y1; 3015 3016 switch (r_type) 3017 { 3018 case R_TILEGX_IMM8_X0_TLS_ADD: 3019 mask = insn_mask_X0_no_operand; 3020 break; 3021 case R_TILEGX_IMM8_X1_TLS_ADD: 3022 mask = insn_mask_X1_no_operand; 3023 break; 3024 case R_TILEGX_IMM8_Y0_TLS_ADD: 3025 mask = insn_mask_Y0_no_operand; 3026 break; 3027 case R_TILEGX_IMM8_Y1_TLS_ADD: 3028 mask = insn_mask_Y1_no_operand; 3029 break; 3030 } 3031 } 3032 3033 tilegx_copy_bits (contents + rel->r_offset, dest_begin, 3034 src_begin, 6); 3035 tilegx_replace_insn (contents + rel->r_offset, mask, insn); 3036 3037 continue; 3038 } 3039 else 3040 { 3041 const bfd_byte *mask = NULL; 3042 const bfd_byte *add_insn = NULL; 3043 bool is_64bit = ABI_64_P (output_bfd); 3044 3045 switch (r_type) 3046 { 3047 case R_TILEGX_IMM8_X0_TLS_GD_ADD: 3048 add_insn = is_tls_iele 3049 ? (is_64bit ? insn_tls_ie_add_X0X1 : insn_tls_ie_addx_X0X1) 3050 : insn_tls_gd_add_X0X1; 3051 mask = insn_mask_X0_no_dest_no_srca; 3052 break; 3053 case R_TILEGX_IMM8_X1_TLS_GD_ADD: 3054 add_insn = is_tls_iele 3055 ? (is_64bit ? insn_tls_ie_add_X0X1 : insn_tls_ie_addx_X0X1) 3056 : insn_tls_gd_add_X0X1; 3057 mask = insn_mask_X1_no_dest_no_srca; 3058 break; 3059 case R_TILEGX_IMM8_Y0_TLS_GD_ADD: 3060 add_insn = is_tls_iele 3061 ? (is_64bit ? insn_tls_ie_add_Y0Y1 : insn_tls_ie_addx_Y0Y1) 3062 : insn_tls_gd_add_Y0Y1; 3063 mask = insn_mask_Y0_no_dest_no_srca; 3064 break; 3065 case R_TILEGX_IMM8_Y1_TLS_GD_ADD: 3066 add_insn = is_tls_iele 3067 ? (is_64bit ? insn_tls_ie_add_Y0Y1 : insn_tls_ie_addx_Y0Y1) 3068 : insn_tls_gd_add_Y0Y1; 3069 mask = insn_mask_Y1_no_dest_no_srca; 3070 break; 3071 } 3072 3073 tilegx_replace_insn (contents + rel->r_offset, mask, add_insn); 3074 3075 continue; 3076 } 3077 break; 3078 case R_TILEGX_TLS_IE_LOAD: 3079 if (!input_section->sec_flg0 3080 && bfd_link_executable (info) 3081 && (h == NULL || h->dynindx == -1)) 3082 { 3083 /* IE -> LE */ 3084 tilegx_replace_insn (contents + rel->r_offset, 3085 insn_mask_X1_no_dest_no_srca, 3086 insn_move_X0X1); 3087 } 3088 else 3089 { 3090 /* IE -> IE */ 3091 if (ABI_64_P (output_bfd)) 3092 tilegx_replace_insn (contents + rel->r_offset, 3093 insn_mask_X1_no_dest_no_srca, 3094 insn_tls_ie_ld_X1); 3095 else 3096 tilegx_replace_insn (contents + rel->r_offset, 3097 insn_mask_X1_no_dest_no_srca, 3098 insn_tls_ie_ld4s_X1); 3099 } 3100 continue; 3101 break; 3102 default: 3103 break; 3104 } 3105 3106 resolved_to_zero = (h != NULL 3107 && UNDEFWEAK_NO_DYNAMIC_RELOC (info, h)); 3108 3109 switch (r_type) 3110 { 3111 case R_TILEGX_IMM16_X0_HW0_GOT: 3112 case R_TILEGX_IMM16_X1_HW0_GOT: 3113 case R_TILEGX_IMM16_X0_HW0_LAST_GOT: 3114 case R_TILEGX_IMM16_X1_HW0_LAST_GOT: 3115 case R_TILEGX_IMM16_X0_HW1_LAST_GOT: 3116 case R_TILEGX_IMM16_X1_HW1_LAST_GOT: 3117 /* Relocation is to the entry for this symbol in the global 3118 offset table. */ 3119 if (htab->elf.sgot == NULL) 3120 abort (); 3121 3122 if (h != NULL) 3123 { 3124 bool dyn; 3125 3126 off = h->got.offset; 3127 BFD_ASSERT (off != (bfd_vma) -1); 3128 dyn = elf_hash_table (info)->dynamic_sections_created; 3129 3130 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 3131 bfd_link_pic (info), 3132 h) 3133 || (bfd_link_pic (info) 3134 && SYMBOL_REFERENCES_LOCAL (info, h))) 3135 { 3136 /* This is actually a static link, or it is a 3137 -Bsymbolic link and the symbol is defined 3138 locally, or the symbol was forced to be local 3139 because of a version file. We must initialize 3140 this entry in the global offset table. Since the 3141 offset must always be a multiple 3142 of 8 for 64-bit, we use the least significant bit 3143 to record whether we have initialized it already. 3144 3145 When doing a dynamic link, we create a .rela.got 3146 relocation entry to initialize the value. This 3147 is done in the finish_dynamic_symbol routine. */ 3148 if ((off & 1) != 0) 3149 off &= ~1; 3150 else 3151 { 3152 TILEGX_ELF_PUT_WORD (htab, output_bfd, relocation, 3153 htab->elf.sgot->contents + off); 3154 h->got.offset |= 1; 3155 } 3156 } 3157 else 3158 unresolved_reloc = false; 3159 } 3160 else 3161 { 3162 BFD_ASSERT (local_got_offsets != NULL 3163 && local_got_offsets[r_symndx] != (bfd_vma) -1); 3164 3165 off = local_got_offsets[r_symndx]; 3166 3167 /* The offset must always be a multiple of 8 on 64-bit. 3168 We use the least significant bit to record 3169 whether we have already processed this entry. */ 3170 if ((off & 1) != 0) 3171 off &= ~1; 3172 else 3173 { 3174 if (bfd_link_pic (info)) 3175 { 3176 asection *s; 3177 Elf_Internal_Rela outrel; 3178 3179 /* We need to generate a R_TILEGX_RELATIVE reloc 3180 for the dynamic linker. */ 3181 s = htab->elf.srelgot; 3182 BFD_ASSERT (s != NULL); 3183 3184 outrel.r_offset = (htab->elf.sgot->output_section->vma 3185 + htab->elf.sgot->output_offset 3186 + off); 3187 outrel.r_info = 3188 TILEGX_ELF_R_INFO (htab, NULL, 0, R_TILEGX_RELATIVE); 3189 outrel.r_addend = relocation; 3190 relocation = 0; 3191 tilegx_elf_append_rela (output_bfd, s, &outrel); 3192 } 3193 3194 TILEGX_ELF_PUT_WORD (htab, output_bfd, relocation, 3195 htab->elf.sgot->contents + off); 3196 local_got_offsets[r_symndx] |= 1; 3197 } 3198 } 3199 relocation = off - got_base; 3200 break; 3201 3202 case R_TILEGX_JUMPOFF_X1_PLT: 3203 case R_TILEGX_IMM16_X0_HW0_PLT_PCREL: 3204 case R_TILEGX_IMM16_X1_HW0_PLT_PCREL: 3205 case R_TILEGX_IMM16_X0_HW1_PLT_PCREL: 3206 case R_TILEGX_IMM16_X1_HW1_PLT_PCREL: 3207 case R_TILEGX_IMM16_X0_HW2_PLT_PCREL: 3208 case R_TILEGX_IMM16_X1_HW2_PLT_PCREL: 3209 case R_TILEGX_IMM16_X0_HW3_PLT_PCREL: 3210 case R_TILEGX_IMM16_X1_HW3_PLT_PCREL: 3211 case R_TILEGX_IMM16_X0_HW0_LAST_PLT_PCREL: 3212 case R_TILEGX_IMM16_X1_HW0_LAST_PLT_PCREL: 3213 case R_TILEGX_IMM16_X0_HW1_LAST_PLT_PCREL: 3214 case R_TILEGX_IMM16_X1_HW1_LAST_PLT_PCREL: 3215 case R_TILEGX_IMM16_X0_HW2_LAST_PLT_PCREL: 3216 case R_TILEGX_IMM16_X1_HW2_LAST_PLT_PCREL: 3217 /* Relocation is to the entry for this symbol in the 3218 procedure linkage table. */ 3219 BFD_ASSERT (h != NULL); 3220 3221 if (h->plt.offset == (bfd_vma) -1 || htab->elf.splt == NULL) 3222 { 3223 /* We didn't make a PLT entry for this symbol. This 3224 happens when statically linking PIC code, or when 3225 using -Bsymbolic. */ 3226 break; 3227 } 3228 3229 relocation = (htab->elf.splt->output_section->vma 3230 + htab->elf.splt->output_offset 3231 + h->plt.offset); 3232 unresolved_reloc = false; 3233 break; 3234 3235 case R_TILEGX_64_PCREL: 3236 case R_TILEGX_32_PCREL: 3237 case R_TILEGX_16_PCREL: 3238 case R_TILEGX_8_PCREL: 3239 case R_TILEGX_IMM16_X0_HW0_PCREL: 3240 case R_TILEGX_IMM16_X1_HW0_PCREL: 3241 case R_TILEGX_IMM16_X0_HW1_PCREL: 3242 case R_TILEGX_IMM16_X1_HW1_PCREL: 3243 case R_TILEGX_IMM16_X0_HW2_PCREL: 3244 case R_TILEGX_IMM16_X1_HW2_PCREL: 3245 case R_TILEGX_IMM16_X0_HW3_PCREL: 3246 case R_TILEGX_IMM16_X1_HW3_PCREL: 3247 case R_TILEGX_IMM16_X0_HW0_LAST_PCREL: 3248 case R_TILEGX_IMM16_X1_HW0_LAST_PCREL: 3249 case R_TILEGX_IMM16_X0_HW1_LAST_PCREL: 3250 case R_TILEGX_IMM16_X1_HW1_LAST_PCREL: 3251 case R_TILEGX_IMM16_X0_HW2_LAST_PCREL: 3252 case R_TILEGX_IMM16_X1_HW2_LAST_PCREL: 3253 if (h != NULL 3254 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0) 3255 break; 3256 /* Fall through. */ 3257 case R_TILEGX_64: 3258 case R_TILEGX_32: 3259 case R_TILEGX_16: 3260 case R_TILEGX_8: 3261 case R_TILEGX_HW0: 3262 case R_TILEGX_HW1: 3263 case R_TILEGX_HW2: 3264 case R_TILEGX_HW3: 3265 case R_TILEGX_HW0_LAST: 3266 case R_TILEGX_HW1_LAST: 3267 case R_TILEGX_HW2_LAST: 3268 case R_TILEGX_COPY: 3269 case R_TILEGX_GLOB_DAT: 3270 case R_TILEGX_JMP_SLOT: 3271 case R_TILEGX_RELATIVE: 3272 case R_TILEGX_BROFF_X1: 3273 case R_TILEGX_JUMPOFF_X1: 3274 case R_TILEGX_IMM8_X0: 3275 case R_TILEGX_IMM8_Y0: 3276 case R_TILEGX_IMM8_X1: 3277 case R_TILEGX_IMM8_Y1: 3278 case R_TILEGX_DEST_IMM8_X1: 3279 case R_TILEGX_MT_IMM14_X1: 3280 case R_TILEGX_MF_IMM14_X1: 3281 case R_TILEGX_MMSTART_X0: 3282 case R_TILEGX_MMEND_X0: 3283 case R_TILEGX_SHAMT_X0: 3284 case R_TILEGX_SHAMT_X1: 3285 case R_TILEGX_SHAMT_Y0: 3286 case R_TILEGX_SHAMT_Y1: 3287 case R_TILEGX_IMM16_X0_HW0: 3288 case R_TILEGX_IMM16_X1_HW0: 3289 case R_TILEGX_IMM16_X0_HW1: 3290 case R_TILEGX_IMM16_X1_HW1: 3291 case R_TILEGX_IMM16_X0_HW2: 3292 case R_TILEGX_IMM16_X1_HW2: 3293 case R_TILEGX_IMM16_X0_HW3: 3294 case R_TILEGX_IMM16_X1_HW3: 3295 case R_TILEGX_IMM16_X0_HW0_LAST: 3296 case R_TILEGX_IMM16_X1_HW0_LAST: 3297 case R_TILEGX_IMM16_X0_HW1_LAST: 3298 case R_TILEGX_IMM16_X1_HW1_LAST: 3299 case R_TILEGX_IMM16_X0_HW2_LAST: 3300 case R_TILEGX_IMM16_X1_HW2_LAST: 3301 if ((input_section->flags & SEC_ALLOC) == 0) 3302 break; 3303 3304 if ((bfd_link_pic (info) 3305 && (h == NULL 3306 || (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT 3307 && !resolved_to_zero) 3308 || h->root.type != bfd_link_hash_undefweak) 3309 && (! howto->pc_relative 3310 || !SYMBOL_CALLS_LOCAL (info, h))) 3311 || (!bfd_link_pic (info) 3312 && h != NULL 3313 && h->dynindx != -1 3314 && !h->non_got_ref 3315 && ((h->def_dynamic 3316 && !h->def_regular) 3317 || h->root.type == bfd_link_hash_undefweak 3318 || h->root.type == bfd_link_hash_undefined))) 3319 { 3320 Elf_Internal_Rela outrel; 3321 bool skip, relocate = false; 3322 3323 /* When generating a shared object, these relocations 3324 are copied into the output file to be resolved at run 3325 time. */ 3326 3327 BFD_ASSERT (sreloc != NULL); 3328 3329 skip = false; 3330 3331 outrel.r_offset = 3332 _bfd_elf_section_offset (output_bfd, info, input_section, 3333 rel->r_offset); 3334 if (outrel.r_offset == (bfd_vma) -1) 3335 skip = true; 3336 else if (outrel.r_offset == (bfd_vma) -2) 3337 skip = true, relocate = true; 3338 outrel.r_offset += (input_section->output_section->vma 3339 + input_section->output_offset); 3340 3341 switch (r_type) 3342 { 3343 case R_TILEGX_64_PCREL: 3344 case R_TILEGX_32_PCREL: 3345 case R_TILEGX_16_PCREL: 3346 case R_TILEGX_8_PCREL: 3347 /* If the symbol is not dynamic, we should not keep 3348 a dynamic relocation. But an .rela.* slot has been 3349 allocated for it, output R_TILEGX_NONE. 3350 FIXME: Add code tracking needed dynamic relocs as 3351 e.g. i386 has. */ 3352 if (h->dynindx == -1) 3353 skip = true, relocate = true; 3354 break; 3355 } 3356 3357 if (skip) 3358 memset (&outrel, 0, sizeof outrel); 3359 /* h->dynindx may be -1 if the symbol was marked to 3360 become local. */ 3361 else if (h != NULL && 3362 h->dynindx != -1 3363 && (! is_plt 3364 || !bfd_link_pic (info) 3365 || !SYMBOLIC_BIND (info, h) 3366 || !h->def_regular)) 3367 { 3368 BFD_ASSERT (h->dynindx != -1); 3369 outrel.r_info = TILEGX_ELF_R_INFO (htab, rel, h->dynindx, r_type); 3370 outrel.r_addend = rel->r_addend; 3371 } 3372 else 3373 { 3374 if (r_type == R_TILEGX_32 || r_type == R_TILEGX_64) 3375 { 3376 outrel.r_info = TILEGX_ELF_R_INFO (htab, NULL, 0, 3377 R_TILEGX_RELATIVE); 3378 outrel.r_addend = relocation + rel->r_addend; 3379 } 3380 else 3381 { 3382 long indx; 3383 3384 outrel.r_addend = relocation + rel->r_addend; 3385 3386 if (is_plt) 3387 sec = htab->elf.splt; 3388 3389 if (bfd_is_abs_section (sec)) 3390 indx = 0; 3391 else if (sec == NULL || sec->owner == NULL) 3392 { 3393 bfd_set_error (bfd_error_bad_value); 3394 return false; 3395 } 3396 else 3397 { 3398 asection *osec; 3399 3400 /* We are turning this relocation into one 3401 against a section symbol. It would be 3402 proper to subtract the symbol's value, 3403 osec->vma, from the emitted reloc addend, 3404 but ld.so expects buggy relocs. */ 3405 osec = sec->output_section; 3406 indx = elf_section_data (osec)->dynindx; 3407 3408 if (indx == 0) 3409 { 3410 osec = htab->elf.text_index_section; 3411 indx = elf_section_data (osec)->dynindx; 3412 } 3413 3414 /* FIXME: we really should be able to link non-pic 3415 shared libraries. */ 3416 if (indx == 0) 3417 { 3418 BFD_FAIL (); 3419 _bfd_error_handler 3420 (_("%pB: probably compiled without -fPIC?"), 3421 input_bfd); 3422 bfd_set_error (bfd_error_bad_value); 3423 return false; 3424 } 3425 } 3426 3427 outrel.r_info = TILEGX_ELF_R_INFO (htab, rel, indx, 3428 r_type); 3429 } 3430 } 3431 3432 tilegx_elf_append_rela (output_bfd, sreloc, &outrel); 3433 3434 /* This reloc will be computed at runtime, so there's no 3435 need to do anything now. */ 3436 if (! relocate) 3437 continue; 3438 } 3439 break; 3440 3441 case R_TILEGX_IMM16_X0_HW0_TLS_LE: 3442 case R_TILEGX_IMM16_X1_HW0_TLS_LE: 3443 case R_TILEGX_IMM16_X0_HW0_LAST_TLS_LE: 3444 case R_TILEGX_IMM16_X1_HW0_LAST_TLS_LE: 3445 case R_TILEGX_IMM16_X0_HW1_LAST_TLS_LE: 3446 case R_TILEGX_IMM16_X1_HW1_LAST_TLS_LE: 3447 if (!bfd_link_executable (info)) 3448 { 3449 Elf_Internal_Rela outrel; 3450 bool skip; 3451 3452 BFD_ASSERT (sreloc != NULL); 3453 skip = false; 3454 outrel.r_offset = 3455 _bfd_elf_section_offset (output_bfd, info, input_section, 3456 rel->r_offset); 3457 if (outrel.r_offset == (bfd_vma) -1) 3458 skip = true; 3459 else if (outrel.r_offset == (bfd_vma) -2) 3460 skip = true; 3461 outrel.r_offset += (input_section->output_section->vma 3462 + input_section->output_offset); 3463 if (skip) 3464 memset (&outrel, 0, sizeof outrel); 3465 else 3466 { 3467 outrel.r_info = TILEGX_ELF_R_INFO (htab, NULL, 0, r_type); 3468 outrel.r_addend = relocation - dtpoff_base (info) 3469 + rel->r_addend; 3470 } 3471 3472 tilegx_elf_append_rela (output_bfd, sreloc, &outrel); 3473 continue; 3474 } 3475 relocation = tpoff (info, relocation); 3476 break; 3477 3478 case R_TILEGX_IMM16_X0_HW0_TLS_GD: 3479 case R_TILEGX_IMM16_X1_HW0_TLS_GD: 3480 case R_TILEGX_IMM16_X0_HW0_LAST_TLS_GD: 3481 case R_TILEGX_IMM16_X1_HW0_LAST_TLS_GD: 3482 case R_TILEGX_IMM16_X0_HW1_LAST_TLS_GD: 3483 case R_TILEGX_IMM16_X1_HW1_LAST_TLS_GD: 3484 case R_TILEGX_IMM16_X0_HW0_TLS_IE: 3485 case R_TILEGX_IMM16_X1_HW0_TLS_IE: 3486 case R_TILEGX_IMM16_X0_HW0_LAST_TLS_IE: 3487 case R_TILEGX_IMM16_X1_HW0_LAST_TLS_IE: 3488 case R_TILEGX_IMM16_X0_HW1_LAST_TLS_IE: 3489 case R_TILEGX_IMM16_X1_HW1_LAST_TLS_IE: 3490 r_type = tilegx_elf_tls_transition (info, r_type, h == NULL, 3491 input_section->sec_flg0); 3492 tls_type = GOT_UNKNOWN; 3493 if (h == NULL && local_got_offsets) 3494 tls_type = 3495 _bfd_tilegx_elf_local_got_tls_type (input_bfd) [r_symndx]; 3496 else if (h != NULL) 3497 { 3498 tls_type = tilegx_elf_hash_entry(h)->tls_type; 3499 if (bfd_link_executable (info) 3500 && h->dynindx == -1 3501 && tls_type == GOT_TLS_IE) 3502 r_type = (!input_section->sec_flg0 3503 ? tilegx_tls_translate_to_le (r_type) 3504 : tilegx_tls_translate_to_ie (r_type)); 3505 } 3506 3507 if (tls_type == GOT_TLS_IE) 3508 r_type = tilegx_tls_translate_to_ie (r_type); 3509 3510 if (r_type == R_TILEGX_IMM16_X0_HW0_TLS_LE 3511 || r_type == R_TILEGX_IMM16_X1_HW0_TLS_LE 3512 || r_type == R_TILEGX_IMM16_X0_HW0_LAST_TLS_LE 3513 || r_type == R_TILEGX_IMM16_X1_HW0_LAST_TLS_LE 3514 || r_type == R_TILEGX_IMM16_X0_HW1_LAST_TLS_LE 3515 || r_type == R_TILEGX_IMM16_X1_HW1_LAST_TLS_LE) 3516 { 3517 relocation = tpoff (info, relocation); 3518 break; 3519 } 3520 3521 if (h != NULL) 3522 { 3523 off = h->got.offset; 3524 h->got.offset |= 1; 3525 } 3526 else 3527 { 3528 BFD_ASSERT (local_got_offsets != NULL); 3529 off = local_got_offsets[r_symndx]; 3530 local_got_offsets[r_symndx] |= 1; 3531 } 3532 3533 if (htab->elf.sgot == NULL) 3534 abort (); 3535 3536 if ((off & 1) != 0) 3537 off &= ~1; 3538 else 3539 { 3540 Elf_Internal_Rela outrel; 3541 int indx = 0; 3542 bool need_relocs = false; 3543 3544 if (htab->elf.srelgot == NULL) 3545 abort (); 3546 3547 if (h != NULL) 3548 { 3549 bool dyn; 3550 dyn = htab->elf.dynamic_sections_created; 3551 3552 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 3553 bfd_link_pic (info), 3554 h) 3555 && (!bfd_link_pic (info) 3556 || !SYMBOL_REFERENCES_LOCAL (info, h))) 3557 { 3558 indx = h->dynindx; 3559 } 3560 } 3561 3562 /* The GOT entries have not been initialized yet. Do it 3563 now, and emit any relocations. */ 3564 if ((bfd_link_pic (info) || indx != 0) 3565 && (h == NULL 3566 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT 3567 || h->root.type != bfd_link_hash_undefweak)) 3568 need_relocs = true; 3569 3570 switch (r_type) 3571 { 3572 case R_TILEGX_IMM16_X0_HW0_TLS_IE: 3573 case R_TILEGX_IMM16_X1_HW0_TLS_IE: 3574 case R_TILEGX_IMM16_X0_HW0_LAST_TLS_IE: 3575 case R_TILEGX_IMM16_X1_HW0_LAST_TLS_IE: 3576 case R_TILEGX_IMM16_X0_HW1_LAST_TLS_IE: 3577 case R_TILEGX_IMM16_X1_HW1_LAST_TLS_IE: 3578 if (need_relocs) { 3579 TILEGX_ELF_PUT_WORD (htab, output_bfd, 0, 3580 htab->elf.sgot->contents + off); 3581 outrel.r_offset = (htab->elf.sgot->output_section->vma 3582 + htab->elf.sgot->output_offset + off); 3583 outrel.r_addend = 0; 3584 if (indx == 0) 3585 outrel.r_addend = relocation - dtpoff_base (info); 3586 outrel.r_info = TILEGX_ELF_R_INFO (htab, NULL, indx, 3587 TILEGX_ELF_TPOFF_RELOC (htab)); 3588 tilegx_elf_append_rela (output_bfd, htab->elf.srelgot, &outrel); 3589 } else { 3590 TILEGX_ELF_PUT_WORD (htab, output_bfd, 3591 tpoff (info, relocation), 3592 htab->elf.sgot->contents + off); 3593 } 3594 break; 3595 3596 case R_TILEGX_IMM16_X0_HW0_TLS_GD: 3597 case R_TILEGX_IMM16_X1_HW0_TLS_GD: 3598 case R_TILEGX_IMM16_X0_HW0_LAST_TLS_GD: 3599 case R_TILEGX_IMM16_X1_HW0_LAST_TLS_GD: 3600 case R_TILEGX_IMM16_X0_HW1_LAST_TLS_GD: 3601 case R_TILEGX_IMM16_X1_HW1_LAST_TLS_GD: 3602 if (need_relocs) { 3603 outrel.r_offset = (htab->elf.sgot->output_section->vma 3604 + htab->elf.sgot->output_offset + off); 3605 outrel.r_addend = 0; 3606 outrel.r_info = TILEGX_ELF_R_INFO (htab, NULL, indx, 3607 TILEGX_ELF_DTPMOD_RELOC (htab)); 3608 TILEGX_ELF_PUT_WORD (htab, output_bfd, 0, 3609 htab->elf.sgot->contents + off); 3610 tilegx_elf_append_rela (output_bfd, htab->elf.srelgot, &outrel); 3611 if (indx == 0) 3612 { 3613 BFD_ASSERT (! unresolved_reloc); 3614 TILEGX_ELF_PUT_WORD (htab, output_bfd, 3615 relocation - dtpoff_base (info), 3616 (htab->elf.sgot->contents + off + 3617 TILEGX_ELF_WORD_BYTES (htab))); 3618 } 3619 else 3620 { 3621 TILEGX_ELF_PUT_WORD (htab, output_bfd, 0, 3622 (htab->elf.sgot->contents + off + 3623 TILEGX_ELF_WORD_BYTES (htab))); 3624 outrel.r_info = TILEGX_ELF_R_INFO (htab, NULL, indx, 3625 TILEGX_ELF_DTPOFF_RELOC (htab)); 3626 outrel.r_offset += TILEGX_ELF_WORD_BYTES (htab); 3627 tilegx_elf_append_rela (output_bfd, htab->elf.srelgot, &outrel); 3628 } 3629 } 3630 3631 else { 3632 /* If we are not emitting relocations for a 3633 general dynamic reference, then we must be in a 3634 static link or an executable link with the 3635 symbol binding locally. Mark it as belonging 3636 to module 1, the executable. */ 3637 TILEGX_ELF_PUT_WORD (htab, output_bfd, 1, 3638 htab->elf.sgot->contents + off ); 3639 TILEGX_ELF_PUT_WORD (htab, output_bfd, 3640 relocation - dtpoff_base (info), 3641 htab->elf.sgot->contents + off + 3642 TILEGX_ELF_WORD_BYTES (htab)); 3643 } 3644 break; 3645 } 3646 } 3647 3648 if (off >= (bfd_vma) -2) 3649 abort (); 3650 3651 relocation = off - got_base; 3652 unresolved_reloc = false; 3653 howto = tilegx_elf_howto_table + r_type; 3654 break; 3655 3656 default: 3657 break; 3658 } 3659 3660 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections 3661 because such sections are not SEC_ALLOC and thus ld.so will 3662 not process them. */ 3663 if (unresolved_reloc 3664 && !((input_section->flags & SEC_DEBUGGING) != 0 3665 && h->def_dynamic) 3666 && _bfd_elf_section_offset (output_bfd, info, input_section, 3667 rel->r_offset) != (bfd_vma) -1) 3668 _bfd_error_handler 3669 /* xgettext:c-format */ 3670 (_("%pB(%pA+%#" PRIx64 "): " 3671 "unresolvable %s relocation against symbol `%s'"), 3672 input_bfd, 3673 input_section, 3674 (uint64_t) rel->r_offset, 3675 howto->name, 3676 h->root.root.string); 3677 3678 r = bfd_reloc_continue; 3679 3680 /* Get the operand creation function, if any. */ 3681 create_func = reloc_to_create_func[r_type]; 3682 if (create_func == NULL) 3683 { 3684 r = _bfd_final_link_relocate (howto, input_bfd, input_section, 3685 contents, rel->r_offset, 3686 relocation, rel->r_addend); 3687 } 3688 else 3689 { 3690 if (howto->pc_relative) 3691 { 3692 relocation -= 3693 input_section->output_section->vma + input_section->output_offset; 3694 if (howto->pcrel_offset) 3695 relocation -= rel->r_offset; 3696 } 3697 3698 bfd_byte *data; 3699 3700 /* Add the relocation addend if any to the final target value */ 3701 relocation += rel->r_addend; 3702 3703 /* Do basic range checking */ 3704 r = bfd_check_overflow (howto->complain_on_overflow, 3705 howto->bitsize, 3706 howto->rightshift, 3707 TILEGX_ELF_WORD_BYTES (htab) * 8, 3708 relocation); 3709 3710 /* 3711 * Write the relocated value out into the raw section data. 3712 * Don't put a relocation out in the .rela section. 3713 */ 3714 tilegx_bundle_bits mask = create_func(-1); 3715 tilegx_bundle_bits value = create_func(relocation >> howto->rightshift); 3716 3717 /* Only touch bytes while the mask is not 0, so we 3718 don't write to out of bounds memory if this is actually 3719 a 16-bit switch instruction. */ 3720 for (data = contents + rel->r_offset; mask != 0; data++) 3721 { 3722 bfd_byte byte_mask = (bfd_byte)mask; 3723 *data = (*data & ~byte_mask) | ((bfd_byte)value & byte_mask); 3724 mask >>= 8; 3725 value >>= 8; 3726 } 3727 } 3728 3729 if (r != bfd_reloc_ok) 3730 { 3731 const char *msg = NULL; 3732 3733 switch (r) 3734 { 3735 case bfd_reloc_overflow: 3736 (*info->callbacks->reloc_overflow) 3737 (info, (h ? &h->root : NULL), name, howto->name, 3738 (bfd_vma) 0, input_bfd, input_section, rel->r_offset); 3739 break; 3740 3741 case bfd_reloc_undefined: 3742 (*info->callbacks->undefined_symbol) 3743 (info, name, input_bfd, input_section, rel->r_offset, true); 3744 break; 3745 3746 case bfd_reloc_outofrange: 3747 msg = _("internal error: out of range error"); 3748 break; 3749 3750 case bfd_reloc_notsupported: 3751 msg = _("internal error: unsupported relocation error"); 3752 break; 3753 3754 case bfd_reloc_dangerous: 3755 msg = _("internal error: dangerous relocation"); 3756 break; 3757 3758 default: 3759 msg = _("internal error: unknown error"); 3760 break; 3761 } 3762 3763 if (msg) 3764 (*info->callbacks->warning) (info, msg, name, input_bfd, 3765 input_section, rel->r_offset); 3766 } 3767 } 3768 3769 return true; 3770 } 3771 3772 /* Finish up dynamic symbol handling. We set the contents of various 3773 dynamic sections here. */ 3774 3775 bool 3776 tilegx_elf_finish_dynamic_symbol (bfd *output_bfd, 3777 struct bfd_link_info *info, 3778 struct elf_link_hash_entry *h, 3779 Elf_Internal_Sym *sym) 3780 { 3781 struct tilegx_elf_link_hash_table *htab; 3782 3783 htab = tilegx_elf_hash_table (info); 3784 BFD_ASSERT (htab != NULL); 3785 3786 if (h->plt.offset != (bfd_vma) -1) 3787 { 3788 asection *splt; 3789 asection *srela; 3790 asection *sgotplt; 3791 Elf_Internal_Rela rela; 3792 bfd_byte *loc; 3793 bfd_vma r_offset; 3794 const struct elf_backend_data *bed = get_elf_backend_data (output_bfd); 3795 3796 3797 int rela_index; 3798 3799 /* This symbol has an entry in the PLT. Set it up. */ 3800 3801 BFD_ASSERT (h->dynindx != -1); 3802 3803 splt = htab->elf.splt; 3804 srela = htab->elf.srelplt; 3805 sgotplt = htab->elf.sgotplt; 3806 3807 if (splt == NULL || srela == NULL) 3808 abort (); 3809 3810 /* Fill in the entry in the procedure linkage table. */ 3811 rela_index = tilegx_plt_entry_build (output_bfd, htab, splt, sgotplt, 3812 h->plt.offset, &r_offset); 3813 3814 /* Fill in the entry in the global offset table, which initially points 3815 to the beginning of the plt. */ 3816 TILEGX_ELF_PUT_WORD (htab, output_bfd, 3817 splt->output_section->vma + splt->output_offset, 3818 sgotplt->contents + r_offset); 3819 3820 /* Fill in the entry in the .rela.plt section. */ 3821 rela.r_offset = (sgotplt->output_section->vma 3822 + sgotplt->output_offset 3823 + r_offset); 3824 rela.r_addend = 0; 3825 rela.r_info = TILEGX_ELF_R_INFO (htab, NULL, h->dynindx, R_TILEGX_JMP_SLOT); 3826 3827 loc = srela->contents + rela_index * TILEGX_ELF_RELA_BYTES (htab); 3828 bed->s->swap_reloca_out (output_bfd, &rela, loc); 3829 3830 if (!h->def_regular) 3831 { 3832 /* Mark the symbol as undefined, rather than as defined in 3833 the .plt section. Leave the value alone. */ 3834 sym->st_shndx = SHN_UNDEF; 3835 /* If the symbol is weak, we do need to clear the value. 3836 Otherwise, the PLT entry would provide a definition for 3837 the symbol even if the symbol wasn't defined anywhere, 3838 and so the symbol would never be NULL. */ 3839 if (!h->ref_regular_nonweak) 3840 sym->st_value = 0; 3841 } 3842 } 3843 3844 if (h->got.offset != (bfd_vma) -1 3845 && tilegx_elf_hash_entry(h)->tls_type != GOT_TLS_GD 3846 && tilegx_elf_hash_entry(h)->tls_type != GOT_TLS_IE) 3847 { 3848 asection *sgot; 3849 asection *srela; 3850 Elf_Internal_Rela rela; 3851 3852 /* This symbol has an entry in the GOT. Set it up. */ 3853 3854 sgot = htab->elf.sgot; 3855 srela = htab->elf.srelgot; 3856 BFD_ASSERT (sgot != NULL && srela != NULL); 3857 3858 rela.r_offset = (sgot->output_section->vma 3859 + sgot->output_offset 3860 + (h->got.offset &~ (bfd_vma) 1)); 3861 3862 /* If this is a -Bsymbolic link, and the symbol is defined 3863 locally, we just want to emit a RELATIVE reloc. Likewise if 3864 the symbol was forced to be local because of a version file. 3865 The entry in the global offset table will already have been 3866 initialized in the relocate_section function. */ 3867 if (bfd_link_pic (info) 3868 && (info->symbolic || h->dynindx == -1) 3869 && h->def_regular) 3870 { 3871 asection *sec = h->root.u.def.section; 3872 rela.r_info = TILEGX_ELF_R_INFO (htab, NULL, 0, R_TILEGX_RELATIVE); 3873 rela.r_addend = (h->root.u.def.value 3874 + sec->output_section->vma 3875 + sec->output_offset); 3876 } 3877 else 3878 { 3879 rela.r_info = TILEGX_ELF_R_INFO (htab, NULL, h->dynindx, R_TILEGX_GLOB_DAT); 3880 rela.r_addend = 0; 3881 } 3882 3883 TILEGX_ELF_PUT_WORD (htab, output_bfd, 0, 3884 sgot->contents + (h->got.offset & ~(bfd_vma) 1)); 3885 tilegx_elf_append_rela (output_bfd, srela, &rela); 3886 } 3887 3888 if (h->needs_copy) 3889 { 3890 asection *s; 3891 Elf_Internal_Rela rela; 3892 3893 /* This symbols needs a copy reloc. Set it up. */ 3894 BFD_ASSERT (h->dynindx != -1); 3895 3896 if (h->root.u.def.section == htab->elf.sdynrelro) 3897 s = htab->elf.sreldynrelro; 3898 else 3899 s = htab->elf.srelbss; 3900 BFD_ASSERT (s != NULL); 3901 3902 rela.r_offset = (h->root.u.def.value 3903 + h->root.u.def.section->output_section->vma 3904 + h->root.u.def.section->output_offset); 3905 rela.r_info = TILEGX_ELF_R_INFO (htab, NULL, h->dynindx, R_TILEGX_COPY); 3906 rela.r_addend = 0; 3907 tilegx_elf_append_rela (output_bfd, s, &rela); 3908 } 3909 3910 /* Mark some specially defined symbols as absolute. */ 3911 if (h == htab->elf.hdynamic 3912 || (h == htab->elf.hgot || h == htab->elf.hplt)) 3913 sym->st_shndx = SHN_ABS; 3914 3915 return true; 3916 } 3917 3918 /* Finish up the dynamic sections. */ 3919 3920 static bool 3921 tilegx_finish_dyn (bfd *output_bfd, struct bfd_link_info *info, 3922 bfd *dynobj, asection *sdyn, 3923 asection *splt ATTRIBUTE_UNUSED) 3924 { 3925 struct tilegx_elf_link_hash_table *htab; 3926 const struct elf_backend_data *bed; 3927 bfd_byte *dyncon, *dynconend; 3928 size_t dynsize; 3929 3930 htab = tilegx_elf_hash_table (info); 3931 BFD_ASSERT (htab != NULL); 3932 bed = get_elf_backend_data (output_bfd); 3933 dynsize = bed->s->sizeof_dyn; 3934 dynconend = sdyn->contents + sdyn->size; 3935 3936 for (dyncon = sdyn->contents; dyncon < dynconend; dyncon += dynsize) 3937 { 3938 Elf_Internal_Dyn dyn; 3939 asection *s; 3940 3941 bed->s->swap_dyn_in (dynobj, dyncon, &dyn); 3942 3943 switch (dyn.d_tag) 3944 { 3945 case DT_PLTGOT: 3946 s = htab->elf.sgotplt; 3947 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset; 3948 break; 3949 case DT_JMPREL: 3950 s = htab->elf.srelplt; 3951 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset; 3952 break; 3953 case DT_PLTRELSZ: 3954 s = htab->elf.srelplt; 3955 dyn.d_un.d_val = s->size; 3956 break; 3957 default: 3958 continue; 3959 } 3960 3961 bed->s->swap_dyn_out (output_bfd, &dyn, dyncon); 3962 } 3963 return true; 3964 } 3965 3966 bool 3967 tilegx_elf_finish_dynamic_sections (bfd *output_bfd, 3968 struct bfd_link_info *info) 3969 { 3970 bfd *dynobj; 3971 asection *sdyn; 3972 struct tilegx_elf_link_hash_table *htab; 3973 size_t pad_size; 3974 3975 htab = tilegx_elf_hash_table (info); 3976 BFD_ASSERT (htab != NULL); 3977 dynobj = htab->elf.dynobj; 3978 3979 sdyn = bfd_get_linker_section (dynobj, ".dynamic"); 3980 3981 if (elf_hash_table (info)->dynamic_sections_created) 3982 { 3983 asection *splt; 3984 bool ret; 3985 3986 splt = htab->elf.splt; 3987 BFD_ASSERT (splt != NULL && sdyn != NULL); 3988 3989 ret = tilegx_finish_dyn (output_bfd, info, dynobj, sdyn, splt); 3990 3991 if (!ret) 3992 return ret; 3993 3994 /* Fill in the head and tail entries in the procedure linkage table. */ 3995 if (splt->size > 0) 3996 { 3997 memcpy (splt->contents, 3998 ABI_64_P (output_bfd) ? 3999 tilegx64_plt0_entry : tilegx32_plt0_entry, 4000 PLT_HEADER_SIZE); 4001 4002 memcpy (splt->contents + splt->size 4003 - PLT_ENTRY_SIZE + PLT_HEADER_SIZE, 4004 ABI_64_P (output_bfd) ? 4005 tilegx64_plt_tail_entry : tilegx32_plt_tail_entry, 4006 PLT_TAIL_SIZE); 4007 /* Add padding so that the plt section is a multiple of its 4008 entry size. */ 4009 pad_size = PLT_ENTRY_SIZE - PLT_HEADER_SIZE - PLT_TAIL_SIZE; 4010 memset (splt->contents + splt->size - pad_size, 0, pad_size); 4011 4012 elf_section_data (splt->output_section)->this_hdr.sh_entsize 4013 = PLT_ENTRY_SIZE; 4014 } 4015 } 4016 4017 if (htab->elf.sgotplt) 4018 { 4019 if (bfd_is_abs_section (htab->elf.sgotplt->output_section)) 4020 { 4021 _bfd_error_handler 4022 (_("discarded output section: `%pA'"), htab->elf.sgotplt); 4023 return false; 4024 } 4025 4026 if (htab->elf.sgotplt->size > 0) 4027 { 4028 /* Write the first two entries in .got.plt, needed for the dynamic 4029 linker. */ 4030 TILEGX_ELF_PUT_WORD (htab, output_bfd, (bfd_vma) -1, 4031 htab->elf.sgotplt->contents); 4032 TILEGX_ELF_PUT_WORD (htab, output_bfd, (bfd_vma) 0, 4033 htab->elf.sgotplt->contents 4034 + GOT_ENTRY_SIZE (htab)); 4035 4036 elf_section_data (htab->elf.sgotplt->output_section)->this_hdr.sh_entsize = 4037 GOT_ENTRY_SIZE (htab); 4038 } 4039 } 4040 4041 if (htab->elf.sgot) 4042 { 4043 if (htab->elf.sgot->size > 0) 4044 { 4045 /* Set the first entry in the global offset table to the address of 4046 the dynamic section. */ 4047 bfd_vma val = (sdyn ? 4048 sdyn->output_section->vma + sdyn->output_offset : 4049 0); 4050 TILEGX_ELF_PUT_WORD (htab, output_bfd, val, 4051 htab->elf.sgot->contents); 4052 4053 elf_section_data (htab->elf.sgot->output_section)->this_hdr.sh_entsize = 4054 GOT_ENTRY_SIZE (htab); 4055 } 4056 } 4057 4058 return true; 4059 } 4060 4061 4062 4064 /* Return address for Ith PLT stub in section PLT, for relocation REL 4065 or (bfd_vma) -1 if it should not be included. */ 4066 4067 bfd_vma 4068 tilegx_elf_plt_sym_val (bfd_vma i, const asection *plt, 4069 const arelent *rel ATTRIBUTE_UNUSED) 4070 { 4071 return plt->vma + PLT_HEADER_SIZE + i * PLT_ENTRY_SIZE; 4072 } 4073 4074 enum elf_reloc_type_class 4075 tilegx_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED, 4076 const asection *rel_sec ATTRIBUTE_UNUSED, 4077 const Elf_Internal_Rela *rela) 4078 { 4079 switch ((int) TILEGX_ELF_R_TYPE (rela->r_info)) 4080 { 4081 case R_TILEGX_RELATIVE: 4082 return reloc_class_relative; 4083 case R_TILEGX_JMP_SLOT: 4084 return reloc_class_plt; 4085 case R_TILEGX_COPY: 4086 return reloc_class_copy; 4087 default: 4088 return reloc_class_normal; 4089 } 4090 } 4091 4092 int 4093 tilegx_additional_program_headers (bfd *abfd, 4094 struct bfd_link_info *info ATTRIBUTE_UNUSED) 4095 { 4096 /* Each .intrpt section specified by the user adds another PT_LOAD 4097 header since the sections are discontiguous. */ 4098 static const char intrpt_sections[4][9] = 4099 { 4100 ".intrpt0", ".intrpt1", ".intrpt2", ".intrpt3" 4101 }; 4102 int count = 0; 4103 int i; 4104 4105 for (i = 0; i < 4; i++) 4106 { 4107 asection *sec = bfd_get_section_by_name (abfd, intrpt_sections[i]); 4108 if (sec != NULL && (sec->flags & SEC_LOAD) != 0) 4109 ++count; 4110 } 4111 4112 /* Add four "padding" headers in to leave room in case a custom linker 4113 script does something fancy. Otherwise ld complains that it ran 4114 out of program headers and refuses to link. */ 4115 count += 4; 4116 4117 return count; 4118 } 4119 4120 4121 bool 4122 _bfd_tilegx_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info) 4123 { 4124 bfd *obfd = info->output_bfd; 4125 const char *targ1 = bfd_get_target (ibfd); 4126 const char *targ2 = bfd_get_target (obfd); 4127 4128 if (strcmp (targ1, targ2) != 0) 4129 { 4130 _bfd_error_handler 4131 /* xgettext:c-format */ 4132 (_("%pB: cannot link together %s and %s objects"), 4133 ibfd, targ1, targ2); 4134 bfd_set_error (bfd_error_bad_value); 4135 return false; 4136 } 4137 4138 return true; 4139 } 4140
Indexes created Wed Mar 04 05:31:52 UTC 2026