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