1/* AArch64-specific support for NN-bit ELF. 2 Copyright (C) 2009-2017 Free Software Foundation, Inc. 3 Contributed by ARM Ltd. 4 5 This file is part of BFD, the Binary File Descriptor library. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program; see the file COPYING3. If not, 19 see <http://www.gnu.org/licenses/>. */ 20 21/* Notes on implementation: 22 23 Thread Local Store (TLS) 24 25 Overview: 26 27 The implementation currently supports both traditional TLS and TLS 28 descriptors, but only general dynamic (GD). 29 30 For traditional TLS the assembler will present us with code 31 fragments of the form: 32 33 adrp x0, :tlsgd:foo 34 R_AARCH64_TLSGD_ADR_PAGE21(foo) 35 add x0, :tlsgd_lo12:foo 36 R_AARCH64_TLSGD_ADD_LO12_NC(foo) 37 bl __tls_get_addr 38 nop 39 40 For TLS descriptors the assembler will present us with code 41 fragments of the form: 42 43 adrp x0, :tlsdesc:foo R_AARCH64_TLSDESC_ADR_PAGE21(foo) 44 ldr x1, [x0, #:tlsdesc_lo12:foo] R_AARCH64_TLSDESC_LD64_LO12(foo) 45 add x0, x0, #:tlsdesc_lo12:foo R_AARCH64_TLSDESC_ADD_LO12(foo) 46 .tlsdesccall foo 47 blr x1 R_AARCH64_TLSDESC_CALL(foo) 48 49 The relocations R_AARCH64_TLSGD_{ADR_PREL21,ADD_LO12_NC} against foo 50 indicate that foo is thread local and should be accessed via the 51 traditional TLS mechanims. 52 53 The relocations R_AARCH64_TLSDESC_{ADR_PAGE21,LD64_LO12_NC,ADD_LO12_NC} 54 against foo indicate that 'foo' is thread local and should be accessed 55 via a TLS descriptor mechanism. 56 57 The precise instruction sequence is only relevant from the 58 perspective of linker relaxation which is currently not implemented. 59 60 The static linker must detect that 'foo' is a TLS object and 61 allocate a double GOT entry. The GOT entry must be created for both 62 global and local TLS symbols. Note that this is different to none 63 TLS local objects which do not need a GOT entry. 64 65 In the traditional TLS mechanism, the double GOT entry is used to 66 provide the tls_index structure, containing module and offset 67 entries. The static linker places the relocation R_AARCH64_TLS_DTPMOD 68 on the module entry. The loader will subsequently fixup this 69 relocation with the module identity. 70 71 For global traditional TLS symbols the static linker places an 72 R_AARCH64_TLS_DTPREL relocation on the offset entry. The loader 73 will subsequently fixup the offset. For local TLS symbols the static 74 linker fixes up offset. 75 76 In the TLS descriptor mechanism the double GOT entry is used to 77 provide the descriptor. The static linker places the relocation 78 R_AARCH64_TLSDESC on the first GOT slot. The loader will 79 subsequently fix this up. 80 81 Implementation: 82 83 The handling of TLS symbols is implemented across a number of 84 different backend functions. The following is a top level view of 85 what processing is performed where. 86 87 The TLS implementation maintains state information for each TLS 88 symbol. The state information for local and global symbols is kept 89 in different places. Global symbols use generic BFD structures while 90 local symbols use backend specific structures that are allocated and 91 maintained entirely by the backend. 92 93 The flow: 94 95 elfNN_aarch64_check_relocs() 96 97 This function is invoked for each relocation. 98 99 The TLS relocations R_AARCH64_TLSGD_{ADR_PREL21,ADD_LO12_NC} and 100 R_AARCH64_TLSDESC_{ADR_PAGE21,LD64_LO12_NC,ADD_LO12_NC} are 101 spotted. One time creation of local symbol data structures are 102 created when the first local symbol is seen. 103 104 The reference count for a symbol is incremented. The GOT type for 105 each symbol is marked as general dynamic. 106 107 elfNN_aarch64_allocate_dynrelocs () 108 109 For each global with positive reference count we allocate a double 110 GOT slot. For a traditional TLS symbol we allocate space for two 111 relocation entries on the GOT, for a TLS descriptor symbol we 112 allocate space for one relocation on the slot. Record the GOT offset 113 for this symbol. 114 115 elfNN_aarch64_size_dynamic_sections () 116 117 Iterate all input BFDS, look for in the local symbol data structure 118 constructed earlier for local TLS symbols and allocate them double 119 GOT slots along with space for a single GOT relocation. Update the 120 local symbol structure to record the GOT offset allocated. 121 122 elfNN_aarch64_relocate_section () 123 124 Calls elfNN_aarch64_final_link_relocate () 125 126 Emit the relevant TLS relocations against the GOT for each TLS 127 symbol. For local TLS symbols emit the GOT offset directly. The GOT 128 relocations are emitted once the first time a TLS symbol is 129 encountered. The implementation uses the LSB of the GOT offset to 130 flag that the relevant GOT relocations for a symbol have been 131 emitted. All of the TLS code that uses the GOT offset needs to take 132 care to mask out this flag bit before using the offset. 133 134 elfNN_aarch64_final_link_relocate () 135 136 Fixup the R_AARCH64_TLSGD_{ADR_PREL21, ADD_LO12_NC} relocations. */ 137 138#include "sysdep.h" 139#include "bfd.h" 140#include "libiberty.h" 141#include "libbfd.h" 142#include "bfd_stdint.h" 143#include "elf-bfd.h" 144#include "bfdlink.h" 145#include "objalloc.h" 146#include "elf/aarch64.h" 147#include "elfxx-aarch64.h" 148 149#define ARCH_SIZE NN 150 151#if ARCH_SIZE == 64 152#define AARCH64_R(NAME) R_AARCH64_ ## NAME 153#define AARCH64_R_STR(NAME) "R_AARCH64_" #NAME 154#define HOWTO64(...) HOWTO (__VA_ARGS__) 155#define HOWTO32(...) EMPTY_HOWTO (0) 156#define LOG_FILE_ALIGN 3 157#endif 158 159#if ARCH_SIZE == 32 160#define AARCH64_R(NAME) R_AARCH64_P32_ ## NAME 161#define AARCH64_R_STR(NAME) "R_AARCH64_P32_" #NAME 162#define HOWTO64(...) EMPTY_HOWTO (0) 163#define HOWTO32(...) HOWTO (__VA_ARGS__) 164#define LOG_FILE_ALIGN 2 165#endif 166 167#define IS_AARCH64_TLS_RELOC(R_TYPE) \ 168 ((R_TYPE) == BFD_RELOC_AARCH64_TLSGD_ADD_LO12_NC \ 169 || (R_TYPE) == BFD_RELOC_AARCH64_TLSGD_ADR_PAGE21 \ 170 || (R_TYPE) == BFD_RELOC_AARCH64_TLSGD_ADR_PREL21 \ 171 || (R_TYPE) == BFD_RELOC_AARCH64_TLSGD_MOVW_G0_NC \ 172 || (R_TYPE) == BFD_RELOC_AARCH64_TLSGD_MOVW_G1 \ 173 || (R_TYPE) == BFD_RELOC_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21 \ 174 || (R_TYPE) == BFD_RELOC_AARCH64_TLSIE_LD32_GOTTPREL_LO12_NC \ 175 || (R_TYPE) == BFD_RELOC_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC \ 176 || (R_TYPE) == BFD_RELOC_AARCH64_TLSIE_LD_GOTTPREL_PREL19 \ 177 || (R_TYPE) == BFD_RELOC_AARCH64_TLSIE_MOVW_GOTTPREL_G0_NC \ 178 || (R_TYPE) == BFD_RELOC_AARCH64_TLSIE_MOVW_GOTTPREL_G1 \ 179 || (R_TYPE) == BFD_RELOC_AARCH64_TLSLD_ADD_DTPREL_HI12 \ 180 || (R_TYPE) == BFD_RELOC_AARCH64_TLSLD_ADD_DTPREL_LO12 \ 181 || (R_TYPE) == BFD_RELOC_AARCH64_TLSLD_ADD_DTPREL_LO12_NC \ 182 || (R_TYPE) == BFD_RELOC_AARCH64_TLSLD_ADD_LO12_NC \ 183 || (R_TYPE) == BFD_RELOC_AARCH64_TLSLD_ADR_PAGE21 \ 184 || (R_TYPE) == BFD_RELOC_AARCH64_TLSLD_ADR_PREL21 \ 185 || (R_TYPE) == BFD_RELOC_AARCH64_TLSLD_LDST16_DTPREL_LO12 \ 186 || (R_TYPE) == BFD_RELOC_AARCH64_TLSLD_LDST16_DTPREL_LO12_NC \ 187 || (R_TYPE) == BFD_RELOC_AARCH64_TLSLD_LDST32_DTPREL_LO12 \ 188 || (R_TYPE) == BFD_RELOC_AARCH64_TLSLD_LDST32_DTPREL_LO12_NC \ 189 || (R_TYPE) == BFD_RELOC_AARCH64_TLSLD_LDST64_DTPREL_LO12 \ 190 || (R_TYPE) == BFD_RELOC_AARCH64_TLSLD_LDST64_DTPREL_LO12_NC \ 191 || (R_TYPE) == BFD_RELOC_AARCH64_TLSLD_LDST8_DTPREL_LO12 \ 192 || (R_TYPE) == BFD_RELOC_AARCH64_TLSLD_LDST8_DTPREL_LO12_NC \ 193 || (R_TYPE) == BFD_RELOC_AARCH64_TLSLD_MOVW_DTPREL_G0 \ 194 || (R_TYPE) == BFD_RELOC_AARCH64_TLSLD_MOVW_DTPREL_G0_NC \ 195 || (R_TYPE) == BFD_RELOC_AARCH64_TLSLD_MOVW_DTPREL_G1 \ 196 || (R_TYPE) == BFD_RELOC_AARCH64_TLSLD_MOVW_DTPREL_G1_NC \ 197 || (R_TYPE) == BFD_RELOC_AARCH64_TLSLD_MOVW_DTPREL_G2 \ 198 || (R_TYPE) == BFD_RELOC_AARCH64_TLSLE_ADD_TPREL_HI12 \ 199 || (R_TYPE) == BFD_RELOC_AARCH64_TLSLE_ADD_TPREL_LO12 \ 200 || (R_TYPE) == BFD_RELOC_AARCH64_TLSLE_ADD_TPREL_LO12_NC \ 201 || (R_TYPE) == BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G0 \ 202 || (R_TYPE) == BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G0_NC \ 203 || (R_TYPE) == BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G1 \ 204 || (R_TYPE) == BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G1_NC \ 205 || (R_TYPE) == BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G2 \ 206 || (R_TYPE) == BFD_RELOC_AARCH64_TLS_DTPMOD \ 207 || (R_TYPE) == BFD_RELOC_AARCH64_TLS_DTPREL \ 208 || (R_TYPE) == BFD_RELOC_AARCH64_TLS_TPREL \ 209 || IS_AARCH64_TLSDESC_RELOC ((R_TYPE))) 210 211#define IS_AARCH64_TLS_RELAX_RELOC(R_TYPE) \ 212 ((R_TYPE) == BFD_RELOC_AARCH64_TLSDESC_ADD \ 213 || (R_TYPE) == BFD_RELOC_AARCH64_TLSDESC_ADD_LO12_NC \ 214 || (R_TYPE) == BFD_RELOC_AARCH64_TLSDESC_ADR_PAGE21 \ 215 || (R_TYPE) == BFD_RELOC_AARCH64_TLSDESC_ADR_PREL21 \ 216 || (R_TYPE) == BFD_RELOC_AARCH64_TLSDESC_CALL \ 217 || (R_TYPE) == BFD_RELOC_AARCH64_TLSDESC_LD_PREL19 \ 218 || (R_TYPE) == BFD_RELOC_AARCH64_TLSDESC_LDNN_LO12_NC \ 219 || (R_TYPE) == BFD_RELOC_AARCH64_TLSDESC_LDR \ 220 || (R_TYPE) == BFD_RELOC_AARCH64_TLSDESC_OFF_G0_NC \ 221 || (R_TYPE) == BFD_RELOC_AARCH64_TLSDESC_OFF_G1 \ 222 || (R_TYPE) == BFD_RELOC_AARCH64_TLSDESC_LDR \ 223 || (R_TYPE) == BFD_RELOC_AARCH64_TLSGD_ADR_PAGE21 \ 224 || (R_TYPE) == BFD_RELOC_AARCH64_TLSGD_ADR_PREL21 \ 225 || (R_TYPE) == BFD_RELOC_AARCH64_TLSGD_ADD_LO12_NC \ 226 || (R_TYPE) == BFD_RELOC_AARCH64_TLSGD_MOVW_G0_NC \ 227 || (R_TYPE) == BFD_RELOC_AARCH64_TLSGD_MOVW_G1 \ 228 || (R_TYPE) == BFD_RELOC_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21 \ 229 || (R_TYPE) == BFD_RELOC_AARCH64_TLSIE_LD_GOTTPREL_PREL19 \ 230 || (R_TYPE) == BFD_RELOC_AARCH64_TLSIE_LDNN_GOTTPREL_LO12_NC \ 231 || (R_TYPE) == BFD_RELOC_AARCH64_TLSLD_ADD_LO12_NC \ 232 || (R_TYPE) == BFD_RELOC_AARCH64_TLSLD_ADR_PAGE21 \ 233 || (R_TYPE) == BFD_RELOC_AARCH64_TLSLD_ADR_PREL21) 234 235#define IS_AARCH64_TLSDESC_RELOC(R_TYPE) \ 236 ((R_TYPE) == BFD_RELOC_AARCH64_TLSDESC \ 237 || (R_TYPE) == BFD_RELOC_AARCH64_TLSDESC_ADD \ 238 || (R_TYPE) == BFD_RELOC_AARCH64_TLSDESC_ADD_LO12_NC \ 239 || (R_TYPE) == BFD_RELOC_AARCH64_TLSDESC_ADR_PAGE21 \ 240 || (R_TYPE) == BFD_RELOC_AARCH64_TLSDESC_ADR_PREL21 \ 241 || (R_TYPE) == BFD_RELOC_AARCH64_TLSDESC_CALL \ 242 || (R_TYPE) == BFD_RELOC_AARCH64_TLSDESC_LD32_LO12_NC \ 243 || (R_TYPE) == BFD_RELOC_AARCH64_TLSDESC_LD64_LO12_NC \ 244 || (R_TYPE) == BFD_RELOC_AARCH64_TLSDESC_LDR \ 245 || (R_TYPE) == BFD_RELOC_AARCH64_TLSDESC_LD_PREL19 \ 246 || (R_TYPE) == BFD_RELOC_AARCH64_TLSDESC_OFF_G0_NC \ 247 || (R_TYPE) == BFD_RELOC_AARCH64_TLSDESC_OFF_G1) 248 249#define ELIMINATE_COPY_RELOCS 0 250 251/* Return size of a relocation entry. HTAB is the bfd's 252 elf_aarch64_link_hash_entry. */ 253#define RELOC_SIZE(HTAB) (sizeof (ElfNN_External_Rela)) 254 255/* GOT Entry size - 8 bytes in ELF64 and 4 bytes in ELF32. */ 256#define GOT_ENTRY_SIZE (ARCH_SIZE / 8) 257#define PLT_ENTRY_SIZE (32) 258#define PLT_SMALL_ENTRY_SIZE (16) 259#define PLT_TLSDESC_ENTRY_SIZE (32) 260 261/* Encoding of the nop instruction */ 262#define INSN_NOP 0xd503201f 263 264#define aarch64_compute_jump_table_size(htab) \ 265 (((htab)->root.srelplt == NULL) ? 0 \ 266 : (htab)->root.srelplt->reloc_count * GOT_ENTRY_SIZE) 267 268/* The first entry in a procedure linkage table looks like this 269 if the distance between the PLTGOT and the PLT is < 4GB use 270 these PLT entries. Note that the dynamic linker gets &PLTGOT[2] 271 in x16 and needs to work out PLTGOT[1] by using an address of 272 [x16,#-GOT_ENTRY_SIZE]. */ 273static const bfd_byte elfNN_aarch64_small_plt0_entry[PLT_ENTRY_SIZE] = 274{ 275 0xf0, 0x7b, 0xbf, 0xa9, /* stp x16, x30, [sp, #-16]! */ 276 0x10, 0x00, 0x00, 0x90, /* adrp x16, (GOT+16) */ 277#if ARCH_SIZE == 64 278 0x11, 0x0A, 0x40, 0xf9, /* ldr x17, [x16, #PLT_GOT+0x10] */ 279 0x10, 0x42, 0x00, 0x91, /* add x16, x16,#PLT_GOT+0x10 */ 280#else 281 0x11, 0x0A, 0x40, 0xb9, /* ldr w17, [x16, #PLT_GOT+0x8] */ 282 0x10, 0x22, 0x00, 0x11, /* add w16, w16,#PLT_GOT+0x8 */ 283#endif 284 0x20, 0x02, 0x1f, 0xd6, /* br x17 */ 285 0x1f, 0x20, 0x03, 0xd5, /* nop */ 286 0x1f, 0x20, 0x03, 0xd5, /* nop */ 287 0x1f, 0x20, 0x03, 0xd5, /* nop */ 288}; 289 290/* Per function entry in a procedure linkage table looks like this 291 if the distance between the PLTGOT and the PLT is < 4GB use 292 these PLT entries. */ 293static const bfd_byte elfNN_aarch64_small_plt_entry[PLT_SMALL_ENTRY_SIZE] = 294{ 295 0x10, 0x00, 0x00, 0x90, /* adrp x16, PLTGOT + n * 8 */ 296#if ARCH_SIZE == 64 297 0x11, 0x02, 0x40, 0xf9, /* ldr x17, [x16, PLTGOT + n * 8] */ 298 0x10, 0x02, 0x00, 0x91, /* add x16, x16, :lo12:PLTGOT + n * 8 */ 299#else 300 0x11, 0x02, 0x40, 0xb9, /* ldr w17, [x16, PLTGOT + n * 4] */ 301 0x10, 0x02, 0x00, 0x11, /* add w16, w16, :lo12:PLTGOT + n * 4 */ 302#endif 303 0x20, 0x02, 0x1f, 0xd6, /* br x17. */ 304}; 305 306static const bfd_byte 307elfNN_aarch64_tlsdesc_small_plt_entry[PLT_TLSDESC_ENTRY_SIZE] = 308{ 309 0xe2, 0x0f, 0xbf, 0xa9, /* stp x2, x3, [sp, #-16]! */ 310 0x02, 0x00, 0x00, 0x90, /* adrp x2, 0 */ 311 0x03, 0x00, 0x00, 0x90, /* adrp x3, 0 */ 312#if ARCH_SIZE == 64 313 0x42, 0x00, 0x40, 0xf9, /* ldr x2, [x2, #0] */ 314 0x63, 0x00, 0x00, 0x91, /* add x3, x3, 0 */ 315#else 316 0x42, 0x00, 0x40, 0xb9, /* ldr w2, [x2, #0] */ 317 0x63, 0x00, 0x00, 0x11, /* add w3, w3, 0 */ 318#endif 319 0x40, 0x00, 0x1f, 0xd6, /* br x2 */ 320 0x1f, 0x20, 0x03, 0xd5, /* nop */ 321 0x1f, 0x20, 0x03, 0xd5, /* nop */ 322}; 323 324#define elf_info_to_howto elfNN_aarch64_info_to_howto 325#define elf_info_to_howto_rel elfNN_aarch64_info_to_howto 326 327#define AARCH64_ELF_ABI_VERSION 0 328 329/* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */ 330#define ALL_ONES (~ (bfd_vma) 0) 331 332/* Indexed by the bfd interal reloc enumerators. 333 Therefore, the table needs to be synced with BFD_RELOC_AARCH64_* 334 in reloc.c. */ 335 336static reloc_howto_type elfNN_aarch64_howto_table[] = 337{ 338 EMPTY_HOWTO (0), 339 340 /* Basic data relocations. */ 341 342 /* Deprecated, but retained for backwards compatibility. */ 343 HOWTO64 (R_AARCH64_NULL, /* type */ 344 0, /* rightshift */ 345 3, /* size (0 = byte, 1 = short, 2 = long) */ 346 0, /* bitsize */ 347 FALSE, /* pc_relative */ 348 0, /* bitpos */ 349 complain_overflow_dont, /* complain_on_overflow */ 350 bfd_elf_generic_reloc, /* special_function */ 351 "R_AARCH64_NULL", /* name */ 352 FALSE, /* partial_inplace */ 353 0, /* src_mask */ 354 0, /* dst_mask */ 355 FALSE), /* pcrel_offset */ 356 HOWTO (R_AARCH64_NONE, /* type */ 357 0, /* rightshift */ 358 3, /* size (0 = byte, 1 = short, 2 = long) */ 359 0, /* bitsize */ 360 FALSE, /* pc_relative */ 361 0, /* bitpos */ 362 complain_overflow_dont, /* complain_on_overflow */ 363 bfd_elf_generic_reloc, /* special_function */ 364 "R_AARCH64_NONE", /* name */ 365 FALSE, /* partial_inplace */ 366 0, /* src_mask */ 367 0, /* dst_mask */ 368 FALSE), /* pcrel_offset */ 369 370 /* .xword: (S+A) */ 371 HOWTO64 (AARCH64_R (ABS64), /* type */ 372 0, /* rightshift */ 373 4, /* size (4 = long long) */ 374 64, /* bitsize */ 375 FALSE, /* pc_relative */ 376 0, /* bitpos */ 377 complain_overflow_unsigned, /* complain_on_overflow */ 378 bfd_elf_generic_reloc, /* special_function */ 379 AARCH64_R_STR (ABS64), /* name */ 380 FALSE, /* partial_inplace */ 381 ALL_ONES, /* src_mask */ 382 ALL_ONES, /* dst_mask */ 383 FALSE), /* pcrel_offset */ 384 385 /* .word: (S+A) */ 386 HOWTO (AARCH64_R (ABS32), /* type */ 387 0, /* rightshift */ 388 2, /* size (0 = byte, 1 = short, 2 = long) */ 389 32, /* bitsize */ 390 FALSE, /* pc_relative */ 391 0, /* bitpos */ 392 complain_overflow_unsigned, /* complain_on_overflow */ 393 bfd_elf_generic_reloc, /* special_function */ 394 AARCH64_R_STR (ABS32), /* name */ 395 FALSE, /* partial_inplace */ 396 0xffffffff, /* src_mask */ 397 0xffffffff, /* dst_mask */ 398 FALSE), /* pcrel_offset */ 399 400 /* .half: (S+A) */ 401 HOWTO (AARCH64_R (ABS16), /* type */ 402 0, /* rightshift */ 403 1, /* size (0 = byte, 1 = short, 2 = long) */ 404 16, /* bitsize */ 405 FALSE, /* pc_relative */ 406 0, /* bitpos */ 407 complain_overflow_unsigned, /* complain_on_overflow */ 408 bfd_elf_generic_reloc, /* special_function */ 409 AARCH64_R_STR (ABS16), /* name */ 410 FALSE, /* partial_inplace */ 411 0xffff, /* src_mask */ 412 0xffff, /* dst_mask */ 413 FALSE), /* pcrel_offset */ 414 415 /* .xword: (S+A-P) */ 416 HOWTO64 (AARCH64_R (PREL64), /* type */ 417 0, /* rightshift */ 418 4, /* size (4 = long long) */ 419 64, /* bitsize */ 420 TRUE, /* pc_relative */ 421 0, /* bitpos */ 422 complain_overflow_signed, /* complain_on_overflow */ 423 bfd_elf_generic_reloc, /* special_function */ 424 AARCH64_R_STR (PREL64), /* name */ 425 FALSE, /* partial_inplace */ 426 ALL_ONES, /* src_mask */ 427 ALL_ONES, /* dst_mask */ 428 TRUE), /* pcrel_offset */ 429 430 /* .word: (S+A-P) */ 431 HOWTO (AARCH64_R (PREL32), /* type */ 432 0, /* rightshift */ 433 2, /* size (0 = byte, 1 = short, 2 = long) */ 434 32, /* bitsize */ 435 TRUE, /* pc_relative */ 436 0, /* bitpos */ 437 complain_overflow_signed, /* complain_on_overflow */ 438 bfd_elf_generic_reloc, /* special_function */ 439 AARCH64_R_STR (PREL32), /* name */ 440 FALSE, /* partial_inplace */ 441 0xffffffff, /* src_mask */ 442 0xffffffff, /* dst_mask */ 443 TRUE), /* pcrel_offset */ 444 445 /* .half: (S+A-P) */ 446 HOWTO (AARCH64_R (PREL16), /* type */ 447 0, /* rightshift */ 448 1, /* size (0 = byte, 1 = short, 2 = long) */ 449 16, /* bitsize */ 450 TRUE, /* pc_relative */ 451 0, /* bitpos */ 452 complain_overflow_signed, /* complain_on_overflow */ 453 bfd_elf_generic_reloc, /* special_function */ 454 AARCH64_R_STR (PREL16), /* name */ 455 FALSE, /* partial_inplace */ 456 0xffff, /* src_mask */ 457 0xffff, /* dst_mask */ 458 TRUE), /* pcrel_offset */ 459 460 /* Group relocations to create a 16, 32, 48 or 64 bit 461 unsigned data or abs address inline. */ 462 463 /* MOVZ: ((S+A) >> 0) & 0xffff */ 464 HOWTO (AARCH64_R (MOVW_UABS_G0), /* type */ 465 0, /* rightshift */ 466 2, /* size (0 = byte, 1 = short, 2 = long) */ 467 16, /* bitsize */ 468 FALSE, /* pc_relative */ 469 0, /* bitpos */ 470 complain_overflow_unsigned, /* complain_on_overflow */ 471 bfd_elf_generic_reloc, /* special_function */ 472 AARCH64_R_STR (MOVW_UABS_G0), /* name */ 473 FALSE, /* partial_inplace */ 474 0xffff, /* src_mask */ 475 0xffff, /* dst_mask */ 476 FALSE), /* pcrel_offset */ 477 478 /* MOVK: ((S+A) >> 0) & 0xffff [no overflow check] */ 479 HOWTO (AARCH64_R (MOVW_UABS_G0_NC), /* type */ 480 0, /* rightshift */ 481 2, /* size (0 = byte, 1 = short, 2 = long) */ 482 16, /* bitsize */ 483 FALSE, /* pc_relative */ 484 0, /* bitpos */ 485 complain_overflow_dont, /* complain_on_overflow */ 486 bfd_elf_generic_reloc, /* special_function */ 487 AARCH64_R_STR (MOVW_UABS_G0_NC), /* name */ 488 FALSE, /* partial_inplace */ 489 0xffff, /* src_mask */ 490 0xffff, /* dst_mask */ 491 FALSE), /* pcrel_offset */ 492 493 /* MOVZ: ((S+A) >> 16) & 0xffff */ 494 HOWTO (AARCH64_R (MOVW_UABS_G1), /* type */ 495 16, /* rightshift */ 496 2, /* size (0 = byte, 1 = short, 2 = long) */ 497 16, /* bitsize */ 498 FALSE, /* pc_relative */ 499 0, /* bitpos */ 500 complain_overflow_unsigned, /* complain_on_overflow */ 501 bfd_elf_generic_reloc, /* special_function */ 502 AARCH64_R_STR (MOVW_UABS_G1), /* name */ 503 FALSE, /* partial_inplace */ 504 0xffff, /* src_mask */ 505 0xffff, /* dst_mask */ 506 FALSE), /* pcrel_offset */ 507 508 /* MOVK: ((S+A) >> 16) & 0xffff [no overflow check] */ 509 HOWTO64 (AARCH64_R (MOVW_UABS_G1_NC), /* type */ 510 16, /* rightshift */ 511 2, /* size (0 = byte, 1 = short, 2 = long) */ 512 16, /* bitsize */ 513 FALSE, /* pc_relative */ 514 0, /* bitpos */ 515 complain_overflow_dont, /* complain_on_overflow */ 516 bfd_elf_generic_reloc, /* special_function */ 517 AARCH64_R_STR (MOVW_UABS_G1_NC), /* name */ 518 FALSE, /* partial_inplace */ 519 0xffff, /* src_mask */ 520 0xffff, /* dst_mask */ 521 FALSE), /* pcrel_offset */ 522 523 /* MOVZ: ((S+A) >> 32) & 0xffff */ 524 HOWTO64 (AARCH64_R (MOVW_UABS_G2), /* type */ 525 32, /* rightshift */ 526 2, /* size (0 = byte, 1 = short, 2 = long) */ 527 16, /* bitsize */ 528 FALSE, /* pc_relative */ 529 0, /* bitpos */ 530 complain_overflow_unsigned, /* complain_on_overflow */ 531 bfd_elf_generic_reloc, /* special_function */ 532 AARCH64_R_STR (MOVW_UABS_G2), /* name */ 533 FALSE, /* partial_inplace */ 534 0xffff, /* src_mask */ 535 0xffff, /* dst_mask */ 536 FALSE), /* pcrel_offset */ 537 538 /* MOVK: ((S+A) >> 32) & 0xffff [no overflow check] */ 539 HOWTO64 (AARCH64_R (MOVW_UABS_G2_NC), /* type */ 540 32, /* rightshift */ 541 2, /* size (0 = byte, 1 = short, 2 = long) */ 542 16, /* bitsize */ 543 FALSE, /* pc_relative */ 544 0, /* bitpos */ 545 complain_overflow_dont, /* complain_on_overflow */ 546 bfd_elf_generic_reloc, /* special_function */ 547 AARCH64_R_STR (MOVW_UABS_G2_NC), /* name */ 548 FALSE, /* partial_inplace */ 549 0xffff, /* src_mask */ 550 0xffff, /* dst_mask */ 551 FALSE), /* pcrel_offset */ 552 553 /* MOVZ: ((S+A) >> 48) & 0xffff */ 554 HOWTO64 (AARCH64_R (MOVW_UABS_G3), /* type */ 555 48, /* rightshift */ 556 2, /* size (0 = byte, 1 = short, 2 = long) */ 557 16, /* bitsize */ 558 FALSE, /* pc_relative */ 559 0, /* bitpos */ 560 complain_overflow_unsigned, /* complain_on_overflow */ 561 bfd_elf_generic_reloc, /* special_function */ 562 AARCH64_R_STR (MOVW_UABS_G3), /* name */ 563 FALSE, /* partial_inplace */ 564 0xffff, /* src_mask */ 565 0xffff, /* dst_mask */ 566 FALSE), /* pcrel_offset */ 567 568 /* Group relocations to create high part of a 16, 32, 48 or 64 bit 569 signed data or abs address inline. Will change instruction 570 to MOVN or MOVZ depending on sign of calculated value. */ 571 572 /* MOV[ZN]: ((S+A) >> 0) & 0xffff */ 573 HOWTO (AARCH64_R (MOVW_SABS_G0), /* type */ 574 0, /* rightshift */ 575 2, /* size (0 = byte, 1 = short, 2 = long) */ 576 17, /* bitsize */ 577 FALSE, /* pc_relative */ 578 0, /* bitpos */ 579 complain_overflow_signed, /* complain_on_overflow */ 580 bfd_elf_generic_reloc, /* special_function */ 581 AARCH64_R_STR (MOVW_SABS_G0), /* name */ 582 FALSE, /* partial_inplace */ 583 0xffff, /* src_mask */ 584 0xffff, /* dst_mask */ 585 FALSE), /* pcrel_offset */ 586 587 /* MOV[ZN]: ((S+A) >> 16) & 0xffff */ 588 HOWTO64 (AARCH64_R (MOVW_SABS_G1), /* type */ 589 16, /* rightshift */ 590 2, /* size (0 = byte, 1 = short, 2 = long) */ 591 17, /* bitsize */ 592 FALSE, /* pc_relative */ 593 0, /* bitpos */ 594 complain_overflow_signed, /* complain_on_overflow */ 595 bfd_elf_generic_reloc, /* special_function */ 596 AARCH64_R_STR (MOVW_SABS_G1), /* name */ 597 FALSE, /* partial_inplace */ 598 0xffff, /* src_mask */ 599 0xffff, /* dst_mask */ 600 FALSE), /* pcrel_offset */ 601 602 /* MOV[ZN]: ((S+A) >> 32) & 0xffff */ 603 HOWTO64 (AARCH64_R (MOVW_SABS_G2), /* type */ 604 32, /* rightshift */ 605 2, /* size (0 = byte, 1 = short, 2 = long) */ 606 17, /* bitsize */ 607 FALSE, /* pc_relative */ 608 0, /* bitpos */ 609 complain_overflow_signed, /* complain_on_overflow */ 610 bfd_elf_generic_reloc, /* special_function */ 611 AARCH64_R_STR (MOVW_SABS_G2), /* name */ 612 FALSE, /* partial_inplace */ 613 0xffff, /* src_mask */ 614 0xffff, /* dst_mask */ 615 FALSE), /* pcrel_offset */ 616 617/* Relocations to generate 19, 21 and 33 bit PC-relative load/store 618 addresses: PG(x) is (x & ~0xfff). */ 619 620 /* LD-lit: ((S+A-P) >> 2) & 0x7ffff */ 621 HOWTO (AARCH64_R (LD_PREL_LO19), /* type */ 622 2, /* rightshift */ 623 2, /* size (0 = byte, 1 = short, 2 = long) */ 624 19, /* bitsize */ 625 TRUE, /* pc_relative */ 626 0, /* bitpos */ 627 complain_overflow_signed, /* complain_on_overflow */ 628 bfd_elf_generic_reloc, /* special_function */ 629 AARCH64_R_STR (LD_PREL_LO19), /* name */ 630 FALSE, /* partial_inplace */ 631 0x7ffff, /* src_mask */ 632 0x7ffff, /* dst_mask */ 633 TRUE), /* pcrel_offset */ 634 635 /* ADR: (S+A-P) & 0x1fffff */ 636 HOWTO (AARCH64_R (ADR_PREL_LO21), /* type */ 637 0, /* rightshift */ 638 2, /* size (0 = byte, 1 = short, 2 = long) */ 639 21, /* bitsize */ 640 TRUE, /* pc_relative */ 641 0, /* bitpos */ 642 complain_overflow_signed, /* complain_on_overflow */ 643 bfd_elf_generic_reloc, /* special_function */ 644 AARCH64_R_STR (ADR_PREL_LO21), /* name */ 645 FALSE, /* partial_inplace */ 646 0x1fffff, /* src_mask */ 647 0x1fffff, /* dst_mask */ 648 TRUE), /* pcrel_offset */ 649 650 /* ADRP: ((PG(S+A)-PG(P)) >> 12) & 0x1fffff */ 651 HOWTO (AARCH64_R (ADR_PREL_PG_HI21), /* type */ 652 12, /* rightshift */ 653 2, /* size (0 = byte, 1 = short, 2 = long) */ 654 21, /* bitsize */ 655 TRUE, /* pc_relative */ 656 0, /* bitpos */ 657 complain_overflow_signed, /* complain_on_overflow */ 658 bfd_elf_generic_reloc, /* special_function */ 659 AARCH64_R_STR (ADR_PREL_PG_HI21), /* name */ 660 FALSE, /* partial_inplace */ 661 0x1fffff, /* src_mask */ 662 0x1fffff, /* dst_mask */ 663 TRUE), /* pcrel_offset */ 664 665 /* ADRP: ((PG(S+A)-PG(P)) >> 12) & 0x1fffff [no overflow check] */ 666 HOWTO64 (AARCH64_R (ADR_PREL_PG_HI21_NC), /* type */ 667 12, /* rightshift */ 668 2, /* size (0 = byte, 1 = short, 2 = long) */ 669 21, /* bitsize */ 670 TRUE, /* pc_relative */ 671 0, /* bitpos */ 672 complain_overflow_dont, /* complain_on_overflow */ 673 bfd_elf_generic_reloc, /* special_function */ 674 AARCH64_R_STR (ADR_PREL_PG_HI21_NC), /* name */ 675 FALSE, /* partial_inplace */ 676 0x1fffff, /* src_mask */ 677 0x1fffff, /* dst_mask */ 678 TRUE), /* pcrel_offset */ 679 680 /* ADD: (S+A) & 0xfff [no overflow check] */ 681 HOWTO (AARCH64_R (ADD_ABS_LO12_NC), /* type */ 682 0, /* rightshift */ 683 2, /* size (0 = byte, 1 = short, 2 = long) */ 684 12, /* bitsize */ 685 FALSE, /* pc_relative */ 686 10, /* bitpos */ 687 complain_overflow_dont, /* complain_on_overflow */ 688 bfd_elf_generic_reloc, /* special_function */ 689 AARCH64_R_STR (ADD_ABS_LO12_NC), /* name */ 690 FALSE, /* partial_inplace */ 691 0x3ffc00, /* src_mask */ 692 0x3ffc00, /* dst_mask */ 693 FALSE), /* pcrel_offset */ 694 695 /* LD/ST8: (S+A) & 0xfff */ 696 HOWTO (AARCH64_R (LDST8_ABS_LO12_NC), /* type */ 697 0, /* rightshift */ 698 2, /* size (0 = byte, 1 = short, 2 = long) */ 699 12, /* bitsize */ 700 FALSE, /* pc_relative */ 701 0, /* bitpos */ 702 complain_overflow_dont, /* complain_on_overflow */ 703 bfd_elf_generic_reloc, /* special_function */ 704 AARCH64_R_STR (LDST8_ABS_LO12_NC), /* name */ 705 FALSE, /* partial_inplace */ 706 0xfff, /* src_mask */ 707 0xfff, /* dst_mask */ 708 FALSE), /* pcrel_offset */ 709 710 /* Relocations for control-flow instructions. */ 711 712 /* TBZ/NZ: ((S+A-P) >> 2) & 0x3fff */ 713 HOWTO (AARCH64_R (TSTBR14), /* type */ 714 2, /* rightshift */ 715 2, /* size (0 = byte, 1 = short, 2 = long) */ 716 14, /* bitsize */ 717 TRUE, /* pc_relative */ 718 0, /* bitpos */ 719 complain_overflow_signed, /* complain_on_overflow */ 720 bfd_elf_generic_reloc, /* special_function */ 721 AARCH64_R_STR (TSTBR14), /* name */ 722 FALSE, /* partial_inplace */ 723 0x3fff, /* src_mask */ 724 0x3fff, /* dst_mask */ 725 TRUE), /* pcrel_offset */ 726 727 /* B.cond: ((S+A-P) >> 2) & 0x7ffff */ 728 HOWTO (AARCH64_R (CONDBR19), /* type */ 729 2, /* rightshift */ 730 2, /* size (0 = byte, 1 = short, 2 = long) */ 731 19, /* bitsize */ 732 TRUE, /* pc_relative */ 733 0, /* bitpos */ 734 complain_overflow_signed, /* complain_on_overflow */ 735 bfd_elf_generic_reloc, /* special_function */ 736 AARCH64_R_STR (CONDBR19), /* name */ 737 FALSE, /* partial_inplace */ 738 0x7ffff, /* src_mask */ 739 0x7ffff, /* dst_mask */ 740 TRUE), /* pcrel_offset */ 741 742 /* B: ((S+A-P) >> 2) & 0x3ffffff */ 743 HOWTO (AARCH64_R (JUMP26), /* type */ 744 2, /* rightshift */ 745 2, /* size (0 = byte, 1 = short, 2 = long) */ 746 26, /* bitsize */ 747 TRUE, /* pc_relative */ 748 0, /* bitpos */ 749 complain_overflow_signed, /* complain_on_overflow */ 750 bfd_elf_generic_reloc, /* special_function */ 751 AARCH64_R_STR (JUMP26), /* name */ 752 FALSE, /* partial_inplace */ 753 0x3ffffff, /* src_mask */ 754 0x3ffffff, /* dst_mask */ 755 TRUE), /* pcrel_offset */ 756 757 /* BL: ((S+A-P) >> 2) & 0x3ffffff */ 758 HOWTO (AARCH64_R (CALL26), /* type */ 759 2, /* rightshift */ 760 2, /* size (0 = byte, 1 = short, 2 = long) */ 761 26, /* bitsize */ 762 TRUE, /* pc_relative */ 763 0, /* bitpos */ 764 complain_overflow_signed, /* complain_on_overflow */ 765 bfd_elf_generic_reloc, /* special_function */ 766 AARCH64_R_STR (CALL26), /* name */ 767 FALSE, /* partial_inplace */ 768 0x3ffffff, /* src_mask */ 769 0x3ffffff, /* dst_mask */ 770 TRUE), /* pcrel_offset */ 771 772 /* LD/ST16: (S+A) & 0xffe */ 773 HOWTO (AARCH64_R (LDST16_ABS_LO12_NC), /* type */ 774 1, /* rightshift */ 775 2, /* size (0 = byte, 1 = short, 2 = long) */ 776 12, /* bitsize */ 777 FALSE, /* pc_relative */ 778 0, /* bitpos */ 779 complain_overflow_dont, /* complain_on_overflow */ 780 bfd_elf_generic_reloc, /* special_function */ 781 AARCH64_R_STR (LDST16_ABS_LO12_NC), /* name */ 782 FALSE, /* partial_inplace */ 783 0xffe, /* src_mask */ 784 0xffe, /* dst_mask */ 785 FALSE), /* pcrel_offset */ 786 787 /* LD/ST32: (S+A) & 0xffc */ 788 HOWTO (AARCH64_R (LDST32_ABS_LO12_NC), /* type */ 789 2, /* rightshift */ 790 2, /* size (0 = byte, 1 = short, 2 = long) */ 791 12, /* bitsize */ 792 FALSE, /* pc_relative */ 793 0, /* bitpos */ 794 complain_overflow_dont, /* complain_on_overflow */ 795 bfd_elf_generic_reloc, /* special_function */ 796 AARCH64_R_STR (LDST32_ABS_LO12_NC), /* name */ 797 FALSE, /* partial_inplace */ 798 0xffc, /* src_mask */ 799 0xffc, /* dst_mask */ 800 FALSE), /* pcrel_offset */ 801 802 /* LD/ST64: (S+A) & 0xff8 */ 803 HOWTO (AARCH64_R (LDST64_ABS_LO12_NC), /* type */ 804 3, /* rightshift */ 805 2, /* size (0 = byte, 1 = short, 2 = long) */ 806 12, /* bitsize */ 807 FALSE, /* pc_relative */ 808 0, /* bitpos */ 809 complain_overflow_dont, /* complain_on_overflow */ 810 bfd_elf_generic_reloc, /* special_function */ 811 AARCH64_R_STR (LDST64_ABS_LO12_NC), /* name */ 812 FALSE, /* partial_inplace */ 813 0xff8, /* src_mask */ 814 0xff8, /* dst_mask */ 815 FALSE), /* pcrel_offset */ 816 817 /* LD/ST128: (S+A) & 0xff0 */ 818 HOWTO (AARCH64_R (LDST128_ABS_LO12_NC), /* type */ 819 4, /* rightshift */ 820 2, /* size (0 = byte, 1 = short, 2 = long) */ 821 12, /* bitsize */ 822 FALSE, /* pc_relative */ 823 0, /* bitpos */ 824 complain_overflow_dont, /* complain_on_overflow */ 825 bfd_elf_generic_reloc, /* special_function */ 826 AARCH64_R_STR (LDST128_ABS_LO12_NC), /* name */ 827 FALSE, /* partial_inplace */ 828 0xff0, /* src_mask */ 829 0xff0, /* dst_mask */ 830 FALSE), /* pcrel_offset */ 831 832 /* Set a load-literal immediate field to bits 833 0x1FFFFC of G(S)-P */ 834 HOWTO (AARCH64_R (GOT_LD_PREL19), /* type */ 835 2, /* rightshift */ 836 2, /* size (0 = byte,1 = short,2 = long) */ 837 19, /* bitsize */ 838 TRUE, /* pc_relative */ 839 0, /* bitpos */ 840 complain_overflow_signed, /* complain_on_overflow */ 841 bfd_elf_generic_reloc, /* special_function */ 842 AARCH64_R_STR (GOT_LD_PREL19), /* name */ 843 FALSE, /* partial_inplace */ 844 0xffffe0, /* src_mask */ 845 0xffffe0, /* dst_mask */ 846 TRUE), /* pcrel_offset */ 847 848 /* Get to the page for the GOT entry for the symbol 849 (G(S) - P) using an ADRP instruction. */ 850 HOWTO (AARCH64_R (ADR_GOT_PAGE), /* type */ 851 12, /* rightshift */ 852 2, /* size (0 = byte, 1 = short, 2 = long) */ 853 21, /* bitsize */ 854 TRUE, /* pc_relative */ 855 0, /* bitpos */ 856 complain_overflow_dont, /* complain_on_overflow */ 857 bfd_elf_generic_reloc, /* special_function */ 858 AARCH64_R_STR (ADR_GOT_PAGE), /* name */ 859 FALSE, /* partial_inplace */ 860 0x1fffff, /* src_mask */ 861 0x1fffff, /* dst_mask */ 862 TRUE), /* pcrel_offset */ 863 864 /* LD64: GOT offset G(S) & 0xff8 */ 865 HOWTO64 (AARCH64_R (LD64_GOT_LO12_NC), /* type */ 866 3, /* rightshift */ 867 2, /* size (0 = byte, 1 = short, 2 = long) */ 868 12, /* bitsize */ 869 FALSE, /* pc_relative */ 870 0, /* bitpos */ 871 complain_overflow_dont, /* complain_on_overflow */ 872 bfd_elf_generic_reloc, /* special_function */ 873 AARCH64_R_STR (LD64_GOT_LO12_NC), /* name */ 874 FALSE, /* partial_inplace */ 875 0xff8, /* src_mask */ 876 0xff8, /* dst_mask */ 877 FALSE), /* pcrel_offset */ 878 879 /* LD32: GOT offset G(S) & 0xffc */ 880 HOWTO32 (AARCH64_R (LD32_GOT_LO12_NC), /* type */ 881 2, /* rightshift */ 882 2, /* size (0 = byte, 1 = short, 2 = long) */ 883 12, /* bitsize */ 884 FALSE, /* pc_relative */ 885 0, /* bitpos */ 886 complain_overflow_dont, /* complain_on_overflow */ 887 bfd_elf_generic_reloc, /* special_function */ 888 AARCH64_R_STR (LD32_GOT_LO12_NC), /* name */ 889 FALSE, /* partial_inplace */ 890 0xffc, /* src_mask */ 891 0xffc, /* dst_mask */ 892 FALSE), /* pcrel_offset */ 893 894 /* Lower 16 bits of GOT offset for the symbol. */ 895 HOWTO64 (AARCH64_R (MOVW_GOTOFF_G0_NC), /* type */ 896 0, /* rightshift */ 897 2, /* size (0 = byte, 1 = short, 2 = long) */ 898 16, /* bitsize */ 899 FALSE, /* pc_relative */ 900 0, /* bitpos */ 901 complain_overflow_dont, /* complain_on_overflow */ 902 bfd_elf_generic_reloc, /* special_function */ 903 AARCH64_R_STR (MOVW_GOTOFF_G0_NC), /* name */ 904 FALSE, /* partial_inplace */ 905 0xffff, /* src_mask */ 906 0xffff, /* dst_mask */ 907 FALSE), /* pcrel_offset */ 908 909 /* Higher 16 bits of GOT offset for the symbol. */ 910 HOWTO64 (AARCH64_R (MOVW_GOTOFF_G1), /* type */ 911 16, /* rightshift */ 912 2, /* size (0 = byte, 1 = short, 2 = long) */ 913 16, /* bitsize */ 914 FALSE, /* pc_relative */ 915 0, /* bitpos */ 916 complain_overflow_unsigned, /* complain_on_overflow */ 917 bfd_elf_generic_reloc, /* special_function */ 918 AARCH64_R_STR (MOVW_GOTOFF_G1), /* name */ 919 FALSE, /* partial_inplace */ 920 0xffff, /* src_mask */ 921 0xffff, /* dst_mask */ 922 FALSE), /* pcrel_offset */ 923 924 /* LD64: GOT offset for the symbol. */ 925 HOWTO64 (AARCH64_R (LD64_GOTOFF_LO15), /* type */ 926 3, /* rightshift */ 927 2, /* size (0 = byte, 1 = short, 2 = long) */ 928 12, /* bitsize */ 929 FALSE, /* pc_relative */ 930 0, /* bitpos */ 931 complain_overflow_unsigned, /* complain_on_overflow */ 932 bfd_elf_generic_reloc, /* special_function */ 933 AARCH64_R_STR (LD64_GOTOFF_LO15), /* name */ 934 FALSE, /* partial_inplace */ 935 0x7ff8, /* src_mask */ 936 0x7ff8, /* dst_mask */ 937 FALSE), /* pcrel_offset */ 938 939 /* LD32: GOT offset to the page address of GOT table. 940 (G(S) - PAGE (_GLOBAL_OFFSET_TABLE_)) & 0x5ffc. */ 941 HOWTO32 (AARCH64_R (LD32_GOTPAGE_LO14), /* type */ 942 2, /* rightshift */ 943 2, /* size (0 = byte, 1 = short, 2 = long) */ 944 12, /* bitsize */ 945 FALSE, /* pc_relative */ 946 0, /* bitpos */ 947 complain_overflow_unsigned, /* complain_on_overflow */ 948 bfd_elf_generic_reloc, /* special_function */ 949 AARCH64_R_STR (LD32_GOTPAGE_LO14), /* name */ 950 FALSE, /* partial_inplace */ 951 0x5ffc, /* src_mask */ 952 0x5ffc, /* dst_mask */ 953 FALSE), /* pcrel_offset */ 954 955 /* LD64: GOT offset to the page address of GOT table. 956 (G(S) - PAGE (_GLOBAL_OFFSET_TABLE_)) & 0x7ff8. */ 957 HOWTO64 (AARCH64_R (LD64_GOTPAGE_LO15), /* type */ 958 3, /* rightshift */ 959 2, /* size (0 = byte, 1 = short, 2 = long) */ 960 12, /* bitsize */ 961 FALSE, /* pc_relative */ 962 0, /* bitpos */ 963 complain_overflow_unsigned, /* complain_on_overflow */ 964 bfd_elf_generic_reloc, /* special_function */ 965 AARCH64_R_STR (LD64_GOTPAGE_LO15), /* name */ 966 FALSE, /* partial_inplace */ 967 0x7ff8, /* src_mask */ 968 0x7ff8, /* dst_mask */ 969 FALSE), /* pcrel_offset */ 970 971 /* Get to the page for the GOT entry for the symbol 972 (G(S) - P) using an ADRP instruction. */ 973 HOWTO (AARCH64_R (TLSGD_ADR_PAGE21), /* type */ 974 12, /* rightshift */ 975 2, /* size (0 = byte, 1 = short, 2 = long) */ 976 21, /* bitsize */ 977 TRUE, /* pc_relative */ 978 0, /* bitpos */ 979 complain_overflow_dont, /* complain_on_overflow */ 980 bfd_elf_generic_reloc, /* special_function */ 981 AARCH64_R_STR (TLSGD_ADR_PAGE21), /* name */ 982 FALSE, /* partial_inplace */ 983 0x1fffff, /* src_mask */ 984 0x1fffff, /* dst_mask */ 985 TRUE), /* pcrel_offset */ 986 987 HOWTO (AARCH64_R (TLSGD_ADR_PREL21), /* type */ 988 0, /* rightshift */ 989 2, /* size (0 = byte, 1 = short, 2 = long) */ 990 21, /* bitsize */ 991 TRUE, /* pc_relative */ 992 0, /* bitpos */ 993 complain_overflow_dont, /* complain_on_overflow */ 994 bfd_elf_generic_reloc, /* special_function */ 995 AARCH64_R_STR (TLSGD_ADR_PREL21), /* name */ 996 FALSE, /* partial_inplace */ 997 0x1fffff, /* src_mask */ 998 0x1fffff, /* dst_mask */ 999 TRUE), /* pcrel_offset */ 1000 1001 /* ADD: GOT offset G(S) & 0xff8 [no overflow check] */ 1002 HOWTO (AARCH64_R (TLSGD_ADD_LO12_NC), /* type */ 1003 0, /* rightshift */ 1004 2, /* size (0 = byte, 1 = short, 2 = long) */ 1005 12, /* bitsize */ 1006 FALSE, /* pc_relative */ 1007 0, /* bitpos */ 1008 complain_overflow_dont, /* complain_on_overflow */ 1009 bfd_elf_generic_reloc, /* special_function */ 1010 AARCH64_R_STR (TLSGD_ADD_LO12_NC), /* name */ 1011 FALSE, /* partial_inplace */ 1012 0xfff, /* src_mask */ 1013 0xfff, /* dst_mask */ 1014 FALSE), /* pcrel_offset */ 1015 1016 /* Lower 16 bits of GOT offset to tls_index. */ 1017 HOWTO64 (AARCH64_R (TLSGD_MOVW_G0_NC), /* type */ 1018 0, /* rightshift */ 1019 2, /* size (0 = byte, 1 = short, 2 = long) */ 1020 16, /* bitsize */ 1021 FALSE, /* pc_relative */ 1022 0, /* bitpos */ 1023 complain_overflow_dont, /* complain_on_overflow */ 1024 bfd_elf_generic_reloc, /* special_function */ 1025 AARCH64_R_STR (TLSGD_MOVW_G0_NC), /* name */ 1026 FALSE, /* partial_inplace */ 1027 0xffff, /* src_mask */ 1028 0xffff, /* dst_mask */ 1029 FALSE), /* pcrel_offset */ 1030 1031 /* Higher 16 bits of GOT offset to tls_index. */ 1032 HOWTO64 (AARCH64_R (TLSGD_MOVW_G1), /* type */ 1033 16, /* rightshift */ 1034 2, /* size (0 = byte, 1 = short, 2 = long) */ 1035 16, /* bitsize */ 1036 FALSE, /* pc_relative */ 1037 0, /* bitpos */ 1038 complain_overflow_unsigned, /* complain_on_overflow */ 1039 bfd_elf_generic_reloc, /* special_function */ 1040 AARCH64_R_STR (TLSGD_MOVW_G1), /* name */ 1041 FALSE, /* partial_inplace */ 1042 0xffff, /* src_mask */ 1043 0xffff, /* dst_mask */ 1044 FALSE), /* pcrel_offset */ 1045 1046 HOWTO (AARCH64_R (TLSIE_ADR_GOTTPREL_PAGE21), /* type */ 1047 12, /* rightshift */ 1048 2, /* size (0 = byte, 1 = short, 2 = long) */ 1049 21, /* bitsize */ 1050 FALSE, /* pc_relative */ 1051 0, /* bitpos */ 1052 complain_overflow_dont, /* complain_on_overflow */ 1053 bfd_elf_generic_reloc, /* special_function */ 1054 AARCH64_R_STR (TLSIE_ADR_GOTTPREL_PAGE21), /* name */ 1055 FALSE, /* partial_inplace */ 1056 0x1fffff, /* src_mask */ 1057 0x1fffff, /* dst_mask */ 1058 FALSE), /* pcrel_offset */ 1059 1060 HOWTO64 (AARCH64_R (TLSIE_LD64_GOTTPREL_LO12_NC), /* type */ 1061 3, /* rightshift */ 1062 2, /* size (0 = byte, 1 = short, 2 = long) */ 1063 12, /* bitsize */ 1064 FALSE, /* pc_relative */ 1065 0, /* bitpos */ 1066 complain_overflow_dont, /* complain_on_overflow */ 1067 bfd_elf_generic_reloc, /* special_function */ 1068 AARCH64_R_STR (TLSIE_LD64_GOTTPREL_LO12_NC), /* name */ 1069 FALSE, /* partial_inplace */ 1070 0xff8, /* src_mask */ 1071 0xff8, /* dst_mask */ 1072 FALSE), /* pcrel_offset */ 1073 1074 HOWTO32 (AARCH64_R (TLSIE_LD32_GOTTPREL_LO12_NC), /* type */ 1075 2, /* rightshift */ 1076 2, /* size (0 = byte, 1 = short, 2 = long) */ 1077 12, /* bitsize */ 1078 FALSE, /* pc_relative */ 1079 0, /* bitpos */ 1080 complain_overflow_dont, /* complain_on_overflow */ 1081 bfd_elf_generic_reloc, /* special_function */ 1082 AARCH64_R_STR (TLSIE_LD32_GOTTPREL_LO12_NC), /* name */ 1083 FALSE, /* partial_inplace */ 1084 0xffc, /* src_mask */ 1085 0xffc, /* dst_mask */ 1086 FALSE), /* pcrel_offset */ 1087 1088 HOWTO (AARCH64_R (TLSIE_LD_GOTTPREL_PREL19), /* type */ 1089 2, /* rightshift */ 1090 2, /* size (0 = byte, 1 = short, 2 = long) */ 1091 19, /* bitsize */ 1092 FALSE, /* pc_relative */ 1093 0, /* bitpos */ 1094 complain_overflow_dont, /* complain_on_overflow */ 1095 bfd_elf_generic_reloc, /* special_function */ 1096 AARCH64_R_STR (TLSIE_LD_GOTTPREL_PREL19), /* name */ 1097 FALSE, /* partial_inplace */ 1098 0x1ffffc, /* src_mask */ 1099 0x1ffffc, /* dst_mask */ 1100 FALSE), /* pcrel_offset */ 1101 1102 HOWTO64 (AARCH64_R (TLSIE_MOVW_GOTTPREL_G0_NC), /* type */ 1103 0, /* rightshift */ 1104 2, /* size (0 = byte, 1 = short, 2 = long) */ 1105 16, /* bitsize */ 1106 FALSE, /* pc_relative */ 1107 0, /* bitpos */ 1108 complain_overflow_dont, /* complain_on_overflow */ 1109 bfd_elf_generic_reloc, /* special_function */ 1110 AARCH64_R_STR (TLSIE_MOVW_GOTTPREL_G0_NC), /* name */ 1111 FALSE, /* partial_inplace */ 1112 0xffff, /* src_mask */ 1113 0xffff, /* dst_mask */ 1114 FALSE), /* pcrel_offset */ 1115 1116 HOWTO64 (AARCH64_R (TLSIE_MOVW_GOTTPREL_G1), /* type */ 1117 16, /* rightshift */ 1118 2, /* size (0 = byte, 1 = short, 2 = long) */ 1119 16, /* bitsize */ 1120 FALSE, /* pc_relative */ 1121 0, /* bitpos */ 1122 complain_overflow_unsigned, /* complain_on_overflow */ 1123 bfd_elf_generic_reloc, /* special_function */ 1124 AARCH64_R_STR (TLSIE_MOVW_GOTTPREL_G1), /* name */ 1125 FALSE, /* partial_inplace */ 1126 0xffff, /* src_mask */ 1127 0xffff, /* dst_mask */ 1128 FALSE), /* pcrel_offset */ 1129 1130 /* ADD: bit[23:12] of byte offset to module TLS base address. */ 1131 HOWTO (AARCH64_R (TLSLD_ADD_DTPREL_HI12), /* type */ 1132 12, /* rightshift */ 1133 2, /* size (0 = byte, 1 = short, 2 = long) */ 1134 12, /* bitsize */ 1135 FALSE, /* pc_relative */ 1136 0, /* bitpos */ 1137 complain_overflow_unsigned, /* complain_on_overflow */ 1138 bfd_elf_generic_reloc, /* special_function */ 1139 AARCH64_R_STR (TLSLD_ADD_DTPREL_HI12), /* name */ 1140 FALSE, /* partial_inplace */ 1141 0xfff, /* src_mask */ 1142 0xfff, /* dst_mask */ 1143 FALSE), /* pcrel_offset */ 1144 1145 /* Unsigned 12 bit byte offset to module TLS base address. */ 1146 HOWTO (AARCH64_R (TLSLD_ADD_DTPREL_LO12), /* type */ 1147 0, /* rightshift */ 1148 2, /* size (0 = byte, 1 = short, 2 = long) */ 1149 12, /* bitsize */ 1150 FALSE, /* pc_relative */ 1151 0, /* bitpos */ 1152 complain_overflow_unsigned, /* complain_on_overflow */ 1153 bfd_elf_generic_reloc, /* special_function */ 1154 AARCH64_R_STR (TLSLD_ADD_DTPREL_LO12), /* name */ 1155 FALSE, /* partial_inplace */ 1156 0xfff, /* src_mask */ 1157 0xfff, /* dst_mask */ 1158 FALSE), /* pcrel_offset */ 1159 1160 /* No overflow check version of BFD_RELOC_AARCH64_TLSLD_ADD_DTPREL_LO12. */ 1161 HOWTO (AARCH64_R (TLSLD_ADD_DTPREL_LO12_NC), /* type */ 1162 0, /* rightshift */ 1163 2, /* size (0 = byte, 1 = short, 2 = long) */ 1164 12, /* bitsize */ 1165 FALSE, /* pc_relative */ 1166 0, /* bitpos */ 1167 complain_overflow_dont, /* complain_on_overflow */ 1168 bfd_elf_generic_reloc, /* special_function */ 1169 AARCH64_R_STR (TLSLD_ADD_DTPREL_LO12_NC), /* name */ 1170 FALSE, /* partial_inplace */ 1171 0xfff, /* src_mask */ 1172 0xfff, /* dst_mask */ 1173 FALSE), /* pcrel_offset */ 1174 1175 /* ADD: GOT offset G(S) & 0xff8 [no overflow check] */ 1176 HOWTO (AARCH64_R (TLSLD_ADD_LO12_NC), /* type */ 1177 0, /* rightshift */ 1178 2, /* size (0 = byte, 1 = short, 2 = long) */ 1179 12, /* bitsize */ 1180 FALSE, /* pc_relative */ 1181 0, /* bitpos */ 1182 complain_overflow_dont, /* complain_on_overflow */ 1183 bfd_elf_generic_reloc, /* special_function */ 1184 AARCH64_R_STR (TLSLD_ADD_LO12_NC), /* name */ 1185 FALSE, /* partial_inplace */ 1186 0xfff, /* src_mask */ 1187 0xfff, /* dst_mask */ 1188 FALSE), /* pcrel_offset */ 1189 1190 /* Get to the page for the GOT entry for the symbol 1191 (G(S) - P) using an ADRP instruction. */ 1192 HOWTO (AARCH64_R (TLSLD_ADR_PAGE21), /* type */ 1193 12, /* rightshift */ 1194 2, /* size (0 = byte, 1 = short, 2 = long) */ 1195 21, /* bitsize */ 1196 TRUE, /* pc_relative */ 1197 0, /* bitpos */ 1198 complain_overflow_signed, /* complain_on_overflow */ 1199 bfd_elf_generic_reloc, /* special_function */ 1200 AARCH64_R_STR (TLSLD_ADR_PAGE21), /* name */ 1201 FALSE, /* partial_inplace */ 1202 0x1fffff, /* src_mask */ 1203 0x1fffff, /* dst_mask */ 1204 TRUE), /* pcrel_offset */ 1205 1206 HOWTO (AARCH64_R (TLSLD_ADR_PREL21), /* type */ 1207 0, /* rightshift */ 1208 2, /* size (0 = byte, 1 = short, 2 = long) */ 1209 21, /* bitsize */ 1210 TRUE, /* pc_relative */ 1211 0, /* bitpos */ 1212 complain_overflow_signed, /* complain_on_overflow */ 1213 bfd_elf_generic_reloc, /* special_function */ 1214 AARCH64_R_STR (TLSLD_ADR_PREL21), /* name */ 1215 FALSE, /* partial_inplace */ 1216 0x1fffff, /* src_mask */ 1217 0x1fffff, /* dst_mask */ 1218 TRUE), /* pcrel_offset */ 1219 1220 /* LD/ST16: bit[11:1] of byte offset to module TLS base address. */ 1221 HOWTO64 (AARCH64_R (TLSLD_LDST16_DTPREL_LO12), /* type */ 1222 1, /* rightshift */ 1223 2, /* size (0 = byte, 1 = short, 2 = long) */ 1224 11, /* bitsize */ 1225 FALSE, /* pc_relative */ 1226 10, /* bitpos */ 1227 complain_overflow_unsigned, /* complain_on_overflow */ 1228 bfd_elf_generic_reloc, /* special_function */ 1229 AARCH64_R_STR (TLSLD_LDST16_DTPREL_LO12), /* name */ 1230 FALSE, /* partial_inplace */ 1231 0x1ffc00, /* src_mask */ 1232 0x1ffc00, /* dst_mask */ 1233 FALSE), /* pcrel_offset */ 1234 1235 /* Same as BFD_RELOC_AARCH64_TLSLD_LDST16_DTPREL_LO12, but no overflow check. */ 1236 HOWTO64 (AARCH64_R (TLSLD_LDST16_DTPREL_LO12_NC), /* type */ 1237 1, /* rightshift */ 1238 2, /* size (0 = byte, 1 = short, 2 = long) */ 1239 11, /* bitsize */ 1240 FALSE, /* pc_relative */ 1241 10, /* bitpos */ 1242 complain_overflow_dont, /* complain_on_overflow */ 1243 bfd_elf_generic_reloc, /* special_function */ 1244 AARCH64_R_STR (TLSLD_LDST16_DTPREL_LO12_NC), /* name */ 1245 FALSE, /* partial_inplace */ 1246 0x1ffc00, /* src_mask */ 1247 0x1ffc00, /* dst_mask */ 1248 FALSE), /* pcrel_offset */ 1249 1250 /* LD/ST32: bit[11:2] of byte offset to module TLS base address. */ 1251 HOWTO64 (AARCH64_R (TLSLD_LDST32_DTPREL_LO12), /* type */ 1252 2, /* rightshift */ 1253 2, /* size (0 = byte, 1 = short, 2 = long) */ 1254 10, /* bitsize */ 1255 FALSE, /* pc_relative */ 1256 10, /* bitpos */ 1257 complain_overflow_unsigned, /* complain_on_overflow */ 1258 bfd_elf_generic_reloc, /* special_function */ 1259 AARCH64_R_STR (TLSLD_LDST32_DTPREL_LO12), /* name */ 1260 FALSE, /* partial_inplace */ 1261 0x3ffc00, /* src_mask */ 1262 0x3ffc00, /* dst_mask */ 1263 FALSE), /* pcrel_offset */ 1264 1265 /* Same as BFD_RELOC_AARCH64_TLSLD_LDST32_DTPREL_LO12, but no overflow check. */ 1266 HOWTO64 (AARCH64_R (TLSLD_LDST32_DTPREL_LO12_NC), /* type */ 1267 2, /* rightshift */ 1268 2, /* size (0 = byte, 1 = short, 2 = long) */ 1269 10, /* bitsize */ 1270 FALSE, /* pc_relative */ 1271 10, /* bitpos */ 1272 complain_overflow_dont, /* complain_on_overflow */ 1273 bfd_elf_generic_reloc, /* special_function */ 1274 AARCH64_R_STR (TLSLD_LDST32_DTPREL_LO12_NC), /* name */ 1275 FALSE, /* partial_inplace */ 1276 0xffc00, /* src_mask */ 1277 0xffc00, /* dst_mask */ 1278 FALSE), /* pcrel_offset */ 1279 1280 /* LD/ST64: bit[11:3] of byte offset to module TLS base address. */ 1281 HOWTO64 (AARCH64_R (TLSLD_LDST64_DTPREL_LO12), /* type */ 1282 3, /* rightshift */ 1283 2, /* size (0 = byte, 1 = short, 2 = long) */ 1284 9, /* bitsize */ 1285 FALSE, /* pc_relative */ 1286 10, /* bitpos */ 1287 complain_overflow_unsigned, /* complain_on_overflow */ 1288 bfd_elf_generic_reloc, /* special_function */ 1289 AARCH64_R_STR (TLSLD_LDST64_DTPREL_LO12), /* name */ 1290 FALSE, /* partial_inplace */ 1291 0x3ffc00, /* src_mask */ 1292 0x3ffc00, /* dst_mask */ 1293 FALSE), /* pcrel_offset */ 1294 1295 /* Same as BFD_RELOC_AARCH64_TLSLD_LDST64_DTPREL_LO12, but no overflow check. */ 1296 HOWTO64 (AARCH64_R (TLSLD_LDST64_DTPREL_LO12_NC), /* type */ 1297 3, /* rightshift */ 1298 2, /* size (0 = byte, 1 = short, 2 = long) */ 1299 9, /* bitsize */ 1300 FALSE, /* pc_relative */ 1301 10, /* bitpos */ 1302 complain_overflow_dont, /* complain_on_overflow */ 1303 bfd_elf_generic_reloc, /* special_function */ 1304 AARCH64_R_STR (TLSLD_LDST64_DTPREL_LO12_NC), /* name */ 1305 FALSE, /* partial_inplace */ 1306 0x7fc00, /* src_mask */ 1307 0x7fc00, /* dst_mask */ 1308 FALSE), /* pcrel_offset */ 1309 1310 /* LD/ST8: bit[11:0] of byte offset to module TLS base address. */ 1311 HOWTO64 (AARCH64_R (TLSLD_LDST8_DTPREL_LO12), /* type */ 1312 0, /* rightshift */ 1313 2, /* size (0 = byte, 1 = short, 2 = long) */ 1314 12, /* bitsize */ 1315 FALSE, /* pc_relative */ 1316 10, /* bitpos */ 1317 complain_overflow_unsigned, /* complain_on_overflow */ 1318 bfd_elf_generic_reloc, /* special_function */ 1319 AARCH64_R_STR (TLSLD_LDST8_DTPREL_LO12), /* name */ 1320 FALSE, /* partial_inplace */ 1321 0x3ffc00, /* src_mask */ 1322 0x3ffc00, /* dst_mask */ 1323 FALSE), /* pcrel_offset */ 1324 1325 /* Same as BFD_RELOC_AARCH64_TLSLD_LDST8_DTPREL_LO12, but no overflow check. */ 1326 HOWTO64 (AARCH64_R (TLSLD_LDST8_DTPREL_LO12_NC), /* type */ 1327 0, /* rightshift */ 1328 2, /* size (0 = byte, 1 = short, 2 = long) */ 1329 12, /* bitsize */ 1330 FALSE, /* pc_relative */ 1331 10, /* bitpos */ 1332 complain_overflow_dont, /* complain_on_overflow */ 1333 bfd_elf_generic_reloc, /* special_function */ 1334 AARCH64_R_STR (TLSLD_LDST8_DTPREL_LO12_NC), /* name */ 1335 FALSE, /* partial_inplace */ 1336 0x3ffc00, /* src_mask */ 1337 0x3ffc00, /* dst_mask */ 1338 FALSE), /* pcrel_offset */ 1339 1340 /* MOVZ: bit[15:0] of byte offset to module TLS base address. */ 1341 HOWTO (AARCH64_R (TLSLD_MOVW_DTPREL_G0), /* type */ 1342 0, /* rightshift */ 1343 2, /* size (0 = byte, 1 = short, 2 = long) */ 1344 16, /* bitsize */ 1345 FALSE, /* pc_relative */ 1346 0, /* bitpos */ 1347 complain_overflow_unsigned, /* complain_on_overflow */ 1348 bfd_elf_generic_reloc, /* special_function */ 1349 AARCH64_R_STR (TLSLD_MOVW_DTPREL_G0), /* name */ 1350 FALSE, /* partial_inplace */ 1351 0xffff, /* src_mask */ 1352 0xffff, /* dst_mask */ 1353 FALSE), /* pcrel_offset */ 1354 1355 /* No overflow check version of BFD_RELOC_AARCH64_TLSLD_MOVW_DTPREL_G0. */ 1356 HOWTO (AARCH64_R (TLSLD_MOVW_DTPREL_G0_NC), /* type */ 1357 0, /* rightshift */ 1358 2, /* size (0 = byte, 1 = short, 2 = long) */ 1359 16, /* bitsize */ 1360 FALSE, /* pc_relative */ 1361 0, /* bitpos */ 1362 complain_overflow_dont, /* complain_on_overflow */ 1363 bfd_elf_generic_reloc, /* special_function */ 1364 AARCH64_R_STR (TLSLD_MOVW_DTPREL_G0_NC), /* name */ 1365 FALSE, /* partial_inplace */ 1366 0xffff, /* src_mask */ 1367 0xffff, /* dst_mask */ 1368 FALSE), /* pcrel_offset */ 1369 1370 /* MOVZ: bit[31:16] of byte offset to module TLS base address. */ 1371 HOWTO (AARCH64_R (TLSLD_MOVW_DTPREL_G1), /* type */ 1372 16, /* rightshift */ 1373 2, /* size (0 = byte, 1 = short, 2 = long) */ 1374 16, /* bitsize */ 1375 FALSE, /* pc_relative */ 1376 0, /* bitpos */ 1377 complain_overflow_unsigned, /* complain_on_overflow */ 1378 bfd_elf_generic_reloc, /* special_function */ 1379 AARCH64_R_STR (TLSLD_MOVW_DTPREL_G1), /* name */ 1380 FALSE, /* partial_inplace */ 1381 0xffff, /* src_mask */ 1382 0xffff, /* dst_mask */ 1383 FALSE), /* pcrel_offset */ 1384 1385 /* No overflow check version of BFD_RELOC_AARCH64_TLSLD_MOVW_DTPREL_G1. */ 1386 HOWTO64 (AARCH64_R (TLSLD_MOVW_DTPREL_G1_NC), /* type */ 1387 16, /* rightshift */ 1388 2, /* size (0 = byte, 1 = short, 2 = long) */ 1389 16, /* bitsize */ 1390 FALSE, /* pc_relative */ 1391 0, /* bitpos */ 1392 complain_overflow_dont, /* complain_on_overflow */ 1393 bfd_elf_generic_reloc, /* special_function */ 1394 AARCH64_R_STR (TLSLD_MOVW_DTPREL_G1_NC), /* name */ 1395 FALSE, /* partial_inplace */ 1396 0xffff, /* src_mask */ 1397 0xffff, /* dst_mask */ 1398 FALSE), /* pcrel_offset */ 1399 1400 /* MOVZ: bit[47:32] of byte offset to module TLS base address. */ 1401 HOWTO64 (AARCH64_R (TLSLD_MOVW_DTPREL_G2), /* type */ 1402 32, /* rightshift */ 1403 2, /* size (0 = byte, 1 = short, 2 = long) */ 1404 16, /* bitsize */ 1405 FALSE, /* pc_relative */ 1406 0, /* bitpos */ 1407 complain_overflow_unsigned, /* complain_on_overflow */ 1408 bfd_elf_generic_reloc, /* special_function */ 1409 AARCH64_R_STR (TLSLD_MOVW_DTPREL_G2), /* name */ 1410 FALSE, /* partial_inplace */ 1411 0xffff, /* src_mask */ 1412 0xffff, /* dst_mask */ 1413 FALSE), /* pcrel_offset */ 1414 1415 HOWTO64 (AARCH64_R (TLSLE_MOVW_TPREL_G2), /* type */ 1416 32, /* rightshift */ 1417 2, /* size (0 = byte, 1 = short, 2 = long) */ 1418 16, /* bitsize */ 1419 FALSE, /* pc_relative */ 1420 0, /* bitpos */ 1421 complain_overflow_unsigned, /* complain_on_overflow */ 1422 bfd_elf_generic_reloc, /* special_function */ 1423 AARCH64_R_STR (TLSLE_MOVW_TPREL_G2), /* name */ 1424 FALSE, /* partial_inplace */ 1425 0xffff, /* src_mask */ 1426 0xffff, /* dst_mask */ 1427 FALSE), /* pcrel_offset */ 1428 1429 HOWTO (AARCH64_R (TLSLE_MOVW_TPREL_G1), /* type */ 1430 16, /* rightshift */ 1431 2, /* size (0 = byte, 1 = short, 2 = long) */ 1432 16, /* bitsize */ 1433 FALSE, /* pc_relative */ 1434 0, /* bitpos */ 1435 complain_overflow_dont, /* complain_on_overflow */ 1436 bfd_elf_generic_reloc, /* special_function */ 1437 AARCH64_R_STR (TLSLE_MOVW_TPREL_G1), /* name */ 1438 FALSE, /* partial_inplace */ 1439 0xffff, /* src_mask */ 1440 0xffff, /* dst_mask */ 1441 FALSE), /* pcrel_offset */ 1442 1443 HOWTO64 (AARCH64_R (TLSLE_MOVW_TPREL_G1_NC), /* type */ 1444 16, /* rightshift */ 1445 2, /* size (0 = byte, 1 = short, 2 = long) */ 1446 16, /* bitsize */ 1447 FALSE, /* pc_relative */ 1448 0, /* bitpos */ 1449 complain_overflow_dont, /* complain_on_overflow */ 1450 bfd_elf_generic_reloc, /* special_function */ 1451 AARCH64_R_STR (TLSLE_MOVW_TPREL_G1_NC), /* name */ 1452 FALSE, /* partial_inplace */ 1453 0xffff, /* src_mask */ 1454 0xffff, /* dst_mask */ 1455 FALSE), /* pcrel_offset */ 1456 1457 HOWTO (AARCH64_R (TLSLE_MOVW_TPREL_G0), /* type */ 1458 0, /* rightshift */ 1459 2, /* size (0 = byte, 1 = short, 2 = long) */ 1460 16, /* bitsize */ 1461 FALSE, /* pc_relative */ 1462 0, /* bitpos */ 1463 complain_overflow_dont, /* complain_on_overflow */ 1464 bfd_elf_generic_reloc, /* special_function */ 1465 AARCH64_R_STR (TLSLE_MOVW_TPREL_G0), /* name */ 1466 FALSE, /* partial_inplace */ 1467 0xffff, /* src_mask */ 1468 0xffff, /* dst_mask */ 1469 FALSE), /* pcrel_offset */ 1470 1471 HOWTO (AARCH64_R (TLSLE_MOVW_TPREL_G0_NC), /* type */ 1472 0, /* rightshift */ 1473 2, /* size (0 = byte, 1 = short, 2 = long) */ 1474 16, /* bitsize */ 1475 FALSE, /* pc_relative */ 1476 0, /* bitpos */ 1477 complain_overflow_dont, /* complain_on_overflow */ 1478 bfd_elf_generic_reloc, /* special_function */ 1479 AARCH64_R_STR (TLSLE_MOVW_TPREL_G0_NC), /* name */ 1480 FALSE, /* partial_inplace */ 1481 0xffff, /* src_mask */ 1482 0xffff, /* dst_mask */ 1483 FALSE), /* pcrel_offset */ 1484 1485 HOWTO (AARCH64_R (TLSLE_ADD_TPREL_HI12), /* type */ 1486 12, /* rightshift */ 1487 2, /* size (0 = byte, 1 = short, 2 = long) */ 1488 12, /* bitsize */ 1489 FALSE, /* pc_relative */ 1490 0, /* bitpos */ 1491 complain_overflow_unsigned, /* complain_on_overflow */ 1492 bfd_elf_generic_reloc, /* special_function */ 1493 AARCH64_R_STR (TLSLE_ADD_TPREL_HI12), /* name */ 1494 FALSE, /* partial_inplace */ 1495 0xfff, /* src_mask */ 1496 0xfff, /* dst_mask */ 1497 FALSE), /* pcrel_offset */ 1498 1499 HOWTO (AARCH64_R (TLSLE_ADD_TPREL_LO12), /* type */ 1500 0, /* rightshift */ 1501 2, /* size (0 = byte, 1 = short, 2 = long) */ 1502 12, /* bitsize */ 1503 FALSE, /* pc_relative */ 1504 0, /* bitpos */ 1505 complain_overflow_unsigned, /* complain_on_overflow */ 1506 bfd_elf_generic_reloc, /* special_function */ 1507 AARCH64_R_STR (TLSLE_ADD_TPREL_LO12), /* name */ 1508 FALSE, /* partial_inplace */ 1509 0xfff, /* src_mask */ 1510 0xfff, /* dst_mask */ 1511 FALSE), /* pcrel_offset */ 1512 1513 HOWTO (AARCH64_R (TLSLE_ADD_TPREL_LO12_NC), /* type */ 1514 0, /* rightshift */ 1515 2, /* size (0 = byte, 1 = short, 2 = long) */ 1516 12, /* bitsize */ 1517 FALSE, /* pc_relative */ 1518 0, /* bitpos */ 1519 complain_overflow_dont, /* complain_on_overflow */ 1520 bfd_elf_generic_reloc, /* special_function */ 1521 AARCH64_R_STR (TLSLE_ADD_TPREL_LO12_NC), /* name */ 1522 FALSE, /* partial_inplace */ 1523 0xfff, /* src_mask */ 1524 0xfff, /* dst_mask */ 1525 FALSE), /* pcrel_offset */ 1526 1527 HOWTO (AARCH64_R (TLSDESC_LD_PREL19), /* type */ 1528 2, /* rightshift */ 1529 2, /* size (0 = byte, 1 = short, 2 = long) */ 1530 19, /* bitsize */ 1531 TRUE, /* pc_relative */ 1532 0, /* bitpos */ 1533 complain_overflow_dont, /* complain_on_overflow */ 1534 bfd_elf_generic_reloc, /* special_function */ 1535 AARCH64_R_STR (TLSDESC_LD_PREL19), /* name */ 1536 FALSE, /* partial_inplace */ 1537 0x0ffffe0, /* src_mask */ 1538 0x0ffffe0, /* dst_mask */ 1539 TRUE), /* pcrel_offset */ 1540 1541 HOWTO (AARCH64_R (TLSDESC_ADR_PREL21), /* type */ 1542 0, /* rightshift */ 1543 2, /* size (0 = byte, 1 = short, 2 = long) */ 1544 21, /* bitsize */ 1545 TRUE, /* pc_relative */ 1546 0, /* bitpos */ 1547 complain_overflow_dont, /* complain_on_overflow */ 1548 bfd_elf_generic_reloc, /* special_function */ 1549 AARCH64_R_STR (TLSDESC_ADR_PREL21), /* name */ 1550 FALSE, /* partial_inplace */ 1551 0x1fffff, /* src_mask */ 1552 0x1fffff, /* dst_mask */ 1553 TRUE), /* pcrel_offset */ 1554 1555 /* Get to the page for the GOT entry for the symbol 1556 (G(S) - P) using an ADRP instruction. */ 1557 HOWTO (AARCH64_R (TLSDESC_ADR_PAGE21), /* type */ 1558 12, /* rightshift */ 1559 2, /* size (0 = byte, 1 = short, 2 = long) */ 1560 21, /* bitsize */ 1561 TRUE, /* pc_relative */ 1562 0, /* bitpos */ 1563 complain_overflow_dont, /* complain_on_overflow */ 1564 bfd_elf_generic_reloc, /* special_function */ 1565 AARCH64_R_STR (TLSDESC_ADR_PAGE21), /* name */ 1566 FALSE, /* partial_inplace */ 1567 0x1fffff, /* src_mask */ 1568 0x1fffff, /* dst_mask */ 1569 TRUE), /* pcrel_offset */ 1570 1571 /* LD64: GOT offset G(S) & 0xff8. */ 1572 HOWTO64 (AARCH64_R (TLSDESC_LD64_LO12_NC), /* type */ 1573 3, /* rightshift */ 1574 2, /* size (0 = byte, 1 = short, 2 = long) */ 1575 12, /* bitsize */ 1576 FALSE, /* pc_relative */ 1577 0, /* bitpos */ 1578 complain_overflow_dont, /* complain_on_overflow */ 1579 bfd_elf_generic_reloc, /* special_function */ 1580 AARCH64_R_STR (TLSDESC_LD64_LO12_NC), /* name */ 1581 FALSE, /* partial_inplace */ 1582 0xff8, /* src_mask */ 1583 0xff8, /* dst_mask */ 1584 FALSE), /* pcrel_offset */ 1585 1586 /* LD32: GOT offset G(S) & 0xffc. */ 1587 HOWTO32 (AARCH64_R (TLSDESC_LD32_LO12_NC), /* type */ 1588 2, /* rightshift */ 1589 2, /* size (0 = byte, 1 = short, 2 = long) */ 1590 12, /* bitsize */ 1591 FALSE, /* pc_relative */ 1592 0, /* bitpos */ 1593 complain_overflow_dont, /* complain_on_overflow */ 1594 bfd_elf_generic_reloc, /* special_function */ 1595 AARCH64_R_STR (TLSDESC_LD32_LO12_NC), /* name */ 1596 FALSE, /* partial_inplace */ 1597 0xffc, /* src_mask */ 1598 0xffc, /* dst_mask */ 1599 FALSE), /* pcrel_offset */ 1600 1601 /* ADD: GOT offset G(S) & 0xfff. */ 1602 HOWTO (AARCH64_R (TLSDESC_ADD_LO12_NC), /* type */ 1603 0, /* rightshift */ 1604 2, /* size (0 = byte, 1 = short, 2 = long) */ 1605 12, /* bitsize */ 1606 FALSE, /* pc_relative */ 1607 0, /* bitpos */ 1608 complain_overflow_dont, /* complain_on_overflow */ 1609 bfd_elf_generic_reloc, /* special_function */ 1610 AARCH64_R_STR (TLSDESC_ADD_LO12_NC), /* name */ 1611 FALSE, /* partial_inplace */ 1612 0xfff, /* src_mask */ 1613 0xfff, /* dst_mask */ 1614 FALSE), /* pcrel_offset */ 1615 1616 HOWTO64 (AARCH64_R (TLSDESC_OFF_G1), /* type */ 1617 16, /* rightshift */ 1618 2, /* size (0 = byte, 1 = short, 2 = long) */ 1619 12, /* bitsize */ 1620 FALSE, /* pc_relative */ 1621 0, /* bitpos */ 1622 complain_overflow_unsigned, /* complain_on_overflow */ 1623 bfd_elf_generic_reloc, /* special_function */ 1624 AARCH64_R_STR (TLSDESC_OFF_G1), /* name */ 1625 FALSE, /* partial_inplace */ 1626 0xffff, /* src_mask */ 1627 0xffff, /* dst_mask */ 1628 FALSE), /* pcrel_offset */ 1629 1630 HOWTO64 (AARCH64_R (TLSDESC_OFF_G0_NC), /* type */ 1631 0, /* rightshift */ 1632 2, /* size (0 = byte, 1 = short, 2 = long) */ 1633 12, /* bitsize */ 1634 FALSE, /* pc_relative */ 1635 0, /* bitpos */ 1636 complain_overflow_dont, /* complain_on_overflow */ 1637 bfd_elf_generic_reloc, /* special_function */ 1638 AARCH64_R_STR (TLSDESC_OFF_G0_NC), /* name */ 1639 FALSE, /* partial_inplace */ 1640 0xffff, /* src_mask */ 1641 0xffff, /* dst_mask */ 1642 FALSE), /* pcrel_offset */ 1643 1644 HOWTO64 (AARCH64_R (TLSDESC_LDR), /* type */ 1645 0, /* rightshift */ 1646 2, /* size (0 = byte, 1 = short, 2 = long) */ 1647 12, /* bitsize */ 1648 FALSE, /* pc_relative */ 1649 0, /* bitpos */ 1650 complain_overflow_dont, /* complain_on_overflow */ 1651 bfd_elf_generic_reloc, /* special_function */ 1652 AARCH64_R_STR (TLSDESC_LDR), /* name */ 1653 FALSE, /* partial_inplace */ 1654 0x0, /* src_mask */ 1655 0x0, /* dst_mask */ 1656 FALSE), /* pcrel_offset */ 1657 1658 HOWTO64 (AARCH64_R (TLSDESC_ADD), /* type */ 1659 0, /* rightshift */ 1660 2, /* size (0 = byte, 1 = short, 2 = long) */ 1661 12, /* bitsize */ 1662 FALSE, /* pc_relative */ 1663 0, /* bitpos */ 1664 complain_overflow_dont, /* complain_on_overflow */ 1665 bfd_elf_generic_reloc, /* special_function */ 1666 AARCH64_R_STR (TLSDESC_ADD), /* name */ 1667 FALSE, /* partial_inplace */ 1668 0x0, /* src_mask */ 1669 0x0, /* dst_mask */ 1670 FALSE), /* pcrel_offset */ 1671 1672 HOWTO (AARCH64_R (TLSDESC_CALL), /* type */ 1673 0, /* rightshift */ 1674 2, /* size (0 = byte, 1 = short, 2 = long) */ 1675 0, /* bitsize */ 1676 FALSE, /* pc_relative */ 1677 0, /* bitpos */ 1678 complain_overflow_dont, /* complain_on_overflow */ 1679 bfd_elf_generic_reloc, /* special_function */ 1680 AARCH64_R_STR (TLSDESC_CALL), /* name */ 1681 FALSE, /* partial_inplace */ 1682 0x0, /* src_mask */ 1683 0x0, /* dst_mask */ 1684 FALSE), /* pcrel_offset */ 1685 1686 HOWTO (AARCH64_R (COPY), /* type */ 1687 0, /* rightshift */ 1688 2, /* size (0 = byte, 1 = short, 2 = long) */ 1689 64, /* bitsize */ 1690 FALSE, /* pc_relative */ 1691 0, /* bitpos */ 1692 complain_overflow_bitfield, /* complain_on_overflow */ 1693 bfd_elf_generic_reloc, /* special_function */ 1694 AARCH64_R_STR (COPY), /* name */ 1695 TRUE, /* partial_inplace */ 1696 0xffffffff, /* src_mask */ 1697 0xffffffff, /* dst_mask */ 1698 FALSE), /* pcrel_offset */ 1699 1700 HOWTO (AARCH64_R (GLOB_DAT), /* type */ 1701 0, /* rightshift */ 1702 2, /* size (0 = byte, 1 = short, 2 = long) */ 1703 64, /* bitsize */ 1704 FALSE, /* pc_relative */ 1705 0, /* bitpos */ 1706 complain_overflow_bitfield, /* complain_on_overflow */ 1707 bfd_elf_generic_reloc, /* special_function */ 1708 AARCH64_R_STR (GLOB_DAT), /* name */ 1709 TRUE, /* partial_inplace */ 1710 0xffffffff, /* src_mask */ 1711 0xffffffff, /* dst_mask */ 1712 FALSE), /* pcrel_offset */ 1713 1714 HOWTO (AARCH64_R (JUMP_SLOT), /* type */ 1715 0, /* rightshift */ 1716 2, /* size (0 = byte, 1 = short, 2 = long) */ 1717 64, /* bitsize */ 1718 FALSE, /* pc_relative */ 1719 0, /* bitpos */ 1720 complain_overflow_bitfield, /* complain_on_overflow */ 1721 bfd_elf_generic_reloc, /* special_function */ 1722 AARCH64_R_STR (JUMP_SLOT), /* name */ 1723 TRUE, /* partial_inplace */ 1724 0xffffffff, /* src_mask */ 1725 0xffffffff, /* dst_mask */ 1726 FALSE), /* pcrel_offset */ 1727 1728 HOWTO (AARCH64_R (RELATIVE), /* type */ 1729 0, /* rightshift */ 1730 2, /* size (0 = byte, 1 = short, 2 = long) */ 1731 64, /* bitsize */ 1732 FALSE, /* pc_relative */ 1733 0, /* bitpos */ 1734 complain_overflow_bitfield, /* complain_on_overflow */ 1735 bfd_elf_generic_reloc, /* special_function */ 1736 AARCH64_R_STR (RELATIVE), /* name */ 1737 TRUE, /* partial_inplace */ 1738 ALL_ONES, /* src_mask */ 1739 ALL_ONES, /* dst_mask */ 1740 FALSE), /* pcrel_offset */ 1741 1742 HOWTO (AARCH64_R (TLS_DTPMOD), /* type */ 1743 0, /* rightshift */ 1744 2, /* size (0 = byte, 1 = short, 2 = long) */ 1745 64, /* bitsize */ 1746 FALSE, /* pc_relative */ 1747 0, /* bitpos */ 1748 complain_overflow_dont, /* complain_on_overflow */ 1749 bfd_elf_generic_reloc, /* special_function */ 1750#if ARCH_SIZE == 64 1751 AARCH64_R_STR (TLS_DTPMOD64), /* name */ 1752#else 1753 AARCH64_R_STR (TLS_DTPMOD), /* name */ 1754#endif 1755 FALSE, /* partial_inplace */ 1756 0, /* src_mask */ 1757 ALL_ONES, /* dst_mask */ 1758 FALSE), /* pc_reloffset */ 1759 1760 HOWTO (AARCH64_R (TLS_DTPREL), /* type */ 1761 0, /* rightshift */ 1762 2, /* size (0 = byte, 1 = short, 2 = long) */ 1763 64, /* bitsize */ 1764 FALSE, /* pc_relative */ 1765 0, /* bitpos */ 1766 complain_overflow_dont, /* complain_on_overflow */ 1767 bfd_elf_generic_reloc, /* special_function */ 1768#if ARCH_SIZE == 64 1769 AARCH64_R_STR (TLS_DTPREL64), /* name */ 1770#else 1771 AARCH64_R_STR (TLS_DTPREL), /* name */ 1772#endif 1773 FALSE, /* partial_inplace */ 1774 0, /* src_mask */ 1775 ALL_ONES, /* dst_mask */ 1776 FALSE), /* pcrel_offset */ 1777 1778 HOWTO (AARCH64_R (TLS_TPREL), /* type */ 1779 0, /* rightshift */ 1780 2, /* size (0 = byte, 1 = short, 2 = long) */ 1781 64, /* bitsize */ 1782 FALSE, /* pc_relative */ 1783 0, /* bitpos */ 1784 complain_overflow_dont, /* complain_on_overflow */ 1785 bfd_elf_generic_reloc, /* special_function */ 1786#if ARCH_SIZE == 64 1787 AARCH64_R_STR (TLS_TPREL64), /* name */ 1788#else 1789 AARCH64_R_STR (TLS_TPREL), /* name */ 1790#endif 1791 FALSE, /* partial_inplace */ 1792 0, /* src_mask */ 1793 ALL_ONES, /* dst_mask */ 1794 FALSE), /* pcrel_offset */ 1795 1796 HOWTO (AARCH64_R (TLSDESC), /* type */ 1797 0, /* rightshift */ 1798 2, /* size (0 = byte, 1 = short, 2 = long) */ 1799 64, /* bitsize */ 1800 FALSE, /* pc_relative */ 1801 0, /* bitpos */ 1802 complain_overflow_dont, /* complain_on_overflow */ 1803 bfd_elf_generic_reloc, /* special_function */ 1804 AARCH64_R_STR (TLSDESC), /* name */ 1805 FALSE, /* partial_inplace */ 1806 0, /* src_mask */ 1807 ALL_ONES, /* dst_mask */ 1808 FALSE), /* pcrel_offset */ 1809 1810 HOWTO (AARCH64_R (IRELATIVE), /* type */ 1811 0, /* rightshift */ 1812 2, /* size (0 = byte, 1 = short, 2 = long) */ 1813 64, /* bitsize */ 1814 FALSE, /* pc_relative */ 1815 0, /* bitpos */ 1816 complain_overflow_bitfield, /* complain_on_overflow */ 1817 bfd_elf_generic_reloc, /* special_function */ 1818 AARCH64_R_STR (IRELATIVE), /* name */ 1819 FALSE, /* partial_inplace */ 1820 0, /* src_mask */ 1821 ALL_ONES, /* dst_mask */ 1822 FALSE), /* pcrel_offset */ 1823 1824 EMPTY_HOWTO (0), 1825}; 1826 1827static reloc_howto_type elfNN_aarch64_howto_none = 1828 HOWTO (R_AARCH64_NONE, /* type */ 1829 0, /* rightshift */ 1830 3, /* size (0 = byte, 1 = short, 2 = long) */ 1831 0, /* bitsize */ 1832 FALSE, /* pc_relative */ 1833 0, /* bitpos */ 1834 complain_overflow_dont,/* complain_on_overflow */ 1835 bfd_elf_generic_reloc, /* special_function */ 1836 "R_AARCH64_NONE", /* name */ 1837 FALSE, /* partial_inplace */ 1838 0, /* src_mask */ 1839 0, /* dst_mask */ 1840 FALSE); /* pcrel_offset */ 1841 1842/* Given HOWTO, return the bfd internal relocation enumerator. */ 1843 1844static bfd_reloc_code_real_type 1845elfNN_aarch64_bfd_reloc_from_howto (reloc_howto_type *howto) 1846{ 1847 const int size 1848 = (int) ARRAY_SIZE (elfNN_aarch64_howto_table); 1849 const ptrdiff_t offset 1850 = howto - elfNN_aarch64_howto_table; 1851 1852 if (offset > 0 && offset < size - 1) 1853 return BFD_RELOC_AARCH64_RELOC_START + offset; 1854 1855 if (howto == &elfNN_aarch64_howto_none) 1856 return BFD_RELOC_AARCH64_NONE; 1857 1858 return BFD_RELOC_AARCH64_RELOC_START; 1859} 1860 1861/* Given R_TYPE, return the bfd internal relocation enumerator. */ 1862 1863static bfd_reloc_code_real_type 1864elfNN_aarch64_bfd_reloc_from_type (unsigned int r_type) 1865{ 1866 static bfd_boolean initialized_p = FALSE; 1867 /* Indexed by R_TYPE, values are offsets in the howto_table. */ 1868 static unsigned int offsets[R_AARCH64_end]; 1869 1870 if (initialized_p == FALSE) 1871 { 1872 unsigned int i; 1873 1874 for (i = 1; i < ARRAY_SIZE (elfNN_aarch64_howto_table) - 1; ++i) 1875 if (elfNN_aarch64_howto_table[i].type != 0) 1876 offsets[elfNN_aarch64_howto_table[i].type] = i; 1877 1878 initialized_p = TRUE; 1879 } 1880 1881 if (r_type == R_AARCH64_NONE || r_type == R_AARCH64_NULL) 1882 return BFD_RELOC_AARCH64_NONE; 1883 1884 /* PR 17512: file: b371e70a. */ 1885 if (r_type >= R_AARCH64_end) 1886 { 1887 _bfd_error_handler (_("Invalid AArch64 reloc number: %d"), r_type); 1888 bfd_set_error (bfd_error_bad_value); 1889 return BFD_RELOC_AARCH64_NONE; 1890 } 1891 1892 return BFD_RELOC_AARCH64_RELOC_START + offsets[r_type]; 1893} 1894 1895struct elf_aarch64_reloc_map 1896{ 1897 bfd_reloc_code_real_type from; 1898 bfd_reloc_code_real_type to; 1899}; 1900 1901/* Map bfd generic reloc to AArch64-specific reloc. */ 1902static const struct elf_aarch64_reloc_map elf_aarch64_reloc_map[] = 1903{ 1904 {BFD_RELOC_NONE, BFD_RELOC_AARCH64_NONE}, 1905 1906 /* Basic data relocations. */ 1907 {BFD_RELOC_CTOR, BFD_RELOC_AARCH64_NN}, 1908 {BFD_RELOC_64, BFD_RELOC_AARCH64_64}, 1909 {BFD_RELOC_32, BFD_RELOC_AARCH64_32}, 1910 {BFD_RELOC_16, BFD_RELOC_AARCH64_16}, 1911 {BFD_RELOC_64_PCREL, BFD_RELOC_AARCH64_64_PCREL}, 1912 {BFD_RELOC_32_PCREL, BFD_RELOC_AARCH64_32_PCREL}, 1913 {BFD_RELOC_16_PCREL, BFD_RELOC_AARCH64_16_PCREL}, 1914}; 1915 1916/* Given the bfd internal relocation enumerator in CODE, return the 1917 corresponding howto entry. */ 1918 1919static reloc_howto_type * 1920elfNN_aarch64_howto_from_bfd_reloc (bfd_reloc_code_real_type code) 1921{ 1922 unsigned int i; 1923 1924 /* Convert bfd generic reloc to AArch64-specific reloc. */ 1925 if (code < BFD_RELOC_AARCH64_RELOC_START 1926 || code > BFD_RELOC_AARCH64_RELOC_END) 1927 for (i = 0; i < ARRAY_SIZE (elf_aarch64_reloc_map); i++) 1928 if (elf_aarch64_reloc_map[i].from == code) 1929 { 1930 code = elf_aarch64_reloc_map[i].to; 1931 break; 1932 } 1933 1934 if (code > BFD_RELOC_AARCH64_RELOC_START 1935 && code < BFD_RELOC_AARCH64_RELOC_END) 1936 if (elfNN_aarch64_howto_table[code - BFD_RELOC_AARCH64_RELOC_START].type) 1937 return &elfNN_aarch64_howto_table[code - BFD_RELOC_AARCH64_RELOC_START]; 1938 1939 if (code == BFD_RELOC_AARCH64_NONE) 1940 return &elfNN_aarch64_howto_none; 1941 1942 return NULL; 1943} 1944 1945static reloc_howto_type * 1946elfNN_aarch64_howto_from_type (unsigned int r_type) 1947{ 1948 bfd_reloc_code_real_type val; 1949 reloc_howto_type *howto; 1950 1951#if ARCH_SIZE == 32 1952 if (r_type > 256) 1953 { 1954 bfd_set_error (bfd_error_bad_value); 1955 return NULL; 1956 } 1957#endif 1958 1959 if (r_type == R_AARCH64_NONE) 1960 return &elfNN_aarch64_howto_none; 1961 1962 val = elfNN_aarch64_bfd_reloc_from_type (r_type); 1963 howto = elfNN_aarch64_howto_from_bfd_reloc (val); 1964 1965 if (howto != NULL) 1966 return howto; 1967 1968 bfd_set_error (bfd_error_bad_value); 1969 return NULL; 1970} 1971 1972static void 1973elfNN_aarch64_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *bfd_reloc, 1974 Elf_Internal_Rela *elf_reloc) 1975{ 1976 unsigned int r_type; 1977 1978 r_type = ELFNN_R_TYPE (elf_reloc->r_info); 1979 bfd_reloc->howto = elfNN_aarch64_howto_from_type (r_type); 1980} 1981 1982static reloc_howto_type * 1983elfNN_aarch64_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED, 1984 bfd_reloc_code_real_type code) 1985{ 1986 reloc_howto_type *howto = elfNN_aarch64_howto_from_bfd_reloc (code); 1987 1988 if (howto != NULL) 1989 return howto; 1990 1991 bfd_set_error (bfd_error_bad_value); 1992 return NULL; 1993} 1994 1995static reloc_howto_type * 1996elfNN_aarch64_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, 1997 const char *r_name) 1998{ 1999 unsigned int i; 2000 2001 for (i = 1; i < ARRAY_SIZE (elfNN_aarch64_howto_table) - 1; ++i) 2002 if (elfNN_aarch64_howto_table[i].name != NULL 2003 && strcasecmp (elfNN_aarch64_howto_table[i].name, r_name) == 0) 2004 return &elfNN_aarch64_howto_table[i]; 2005 2006 return NULL; 2007} 2008 2009#define TARGET_LITTLE_SYM aarch64_elfNN_le_vec 2010#define TARGET_LITTLE_NAME "elfNN-littleaarch64" 2011#define TARGET_BIG_SYM aarch64_elfNN_be_vec 2012#define TARGET_BIG_NAME "elfNN-bigaarch64" 2013 2014/* The linker script knows the section names for placement. 2015 The entry_names are used to do simple name mangling on the stubs. 2016 Given a function name, and its type, the stub can be found. The 2017 name can be changed. The only requirement is the %s be present. */ 2018#define STUB_ENTRY_NAME "__%s_veneer" 2019 2020/* The name of the dynamic interpreter. This is put in the .interp 2021 section. */ 2022#define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1" 2023 2024#define AARCH64_MAX_FWD_BRANCH_OFFSET \ 2025 (((1 << 25) - 1) << 2) 2026#define AARCH64_MAX_BWD_BRANCH_OFFSET \ 2027 (-((1 << 25) << 2)) 2028 2029#define AARCH64_MAX_ADRP_IMM ((1 << 20) - 1) 2030#define AARCH64_MIN_ADRP_IMM (-(1 << 20)) 2031 2032static int 2033aarch64_valid_for_adrp_p (bfd_vma value, bfd_vma place) 2034{ 2035 bfd_signed_vma offset = (bfd_signed_vma) (PG (value) - PG (place)) >> 12; 2036 return offset <= AARCH64_MAX_ADRP_IMM && offset >= AARCH64_MIN_ADRP_IMM; 2037} 2038 2039static int 2040aarch64_valid_branch_p (bfd_vma value, bfd_vma place) 2041{ 2042 bfd_signed_vma offset = (bfd_signed_vma) (value - place); 2043 return (offset <= AARCH64_MAX_FWD_BRANCH_OFFSET 2044 && offset >= AARCH64_MAX_BWD_BRANCH_OFFSET); 2045} 2046 2047static const uint32_t aarch64_adrp_branch_stub [] = 2048{ 2049 0x90000010, /* adrp ip0, X */ 2050 /* R_AARCH64_ADR_HI21_PCREL(X) */ 2051 0x91000210, /* add ip0, ip0, :lo12:X */ 2052 /* R_AARCH64_ADD_ABS_LO12_NC(X) */ 2053 0xd61f0200, /* br ip0 */ 2054}; 2055 2056static const uint32_t aarch64_long_branch_stub[] = 2057{ 2058#if ARCH_SIZE == 64 2059 0x58000090, /* ldr ip0, 1f */ 2060#else 2061 0x18000090, /* ldr wip0, 1f */ 2062#endif 2063 0x10000011, /* adr ip1, #0 */ 2064 0x8b110210, /* add ip0, ip0, ip1 */ 2065 0xd61f0200, /* br ip0 */ 2066 0x00000000, /* 1: .xword or .word 2067 R_AARCH64_PRELNN(X) + 12 2068 */ 2069 0x00000000, 2070}; 2071 2072static const uint32_t aarch64_erratum_835769_stub[] = 2073{ 2074 0x00000000, /* Placeholder for multiply accumulate. */ 2075 0x14000000, /* b <label> */ 2076}; 2077 2078static const uint32_t aarch64_erratum_843419_stub[] = 2079{ 2080 0x00000000, /* Placeholder for LDR instruction. */ 2081 0x14000000, /* b <label> */ 2082}; 2083 2084/* Section name for stubs is the associated section name plus this 2085 string. */ 2086#define STUB_SUFFIX ".stub" 2087 2088enum elf_aarch64_stub_type 2089{ 2090 aarch64_stub_none, 2091 aarch64_stub_adrp_branch, 2092 aarch64_stub_long_branch, 2093 aarch64_stub_erratum_835769_veneer, 2094 aarch64_stub_erratum_843419_veneer, 2095}; 2096 2097struct elf_aarch64_stub_hash_entry 2098{ 2099 /* Base hash table entry structure. */ 2100 struct bfd_hash_entry root; 2101 2102 /* The stub section. */ 2103 asection *stub_sec; 2104 2105 /* Offset within stub_sec of the beginning of this stub. */ 2106 bfd_vma stub_offset; 2107 2108 /* Given the symbol's value and its section we can determine its final 2109 value when building the stubs (so the stub knows where to jump). */ 2110 bfd_vma target_value; 2111 asection *target_section; 2112 2113 enum elf_aarch64_stub_type stub_type; 2114 2115 /* The symbol table entry, if any, that this was derived from. */ 2116 struct elf_aarch64_link_hash_entry *h; 2117 2118 /* Destination symbol type */ 2119 unsigned char st_type; 2120 2121 /* Where this stub is being called from, or, in the case of combined 2122 stub sections, the first input section in the group. */ 2123 asection *id_sec; 2124 2125 /* The name for the local symbol at the start of this stub. The 2126 stub name in the hash table has to be unique; this does not, so 2127 it can be friendlier. */ 2128 char *output_name; 2129 2130 /* The instruction which caused this stub to be generated (only valid for 2131 erratum 835769 workaround stubs at present). */ 2132 uint32_t veneered_insn; 2133 2134 /* In an erratum 843419 workaround stub, the ADRP instruction offset. */ 2135 bfd_vma adrp_offset; 2136}; 2137 2138/* Used to build a map of a section. This is required for mixed-endian 2139 code/data. */ 2140 2141typedef struct elf_elf_section_map 2142{ 2143 bfd_vma vma; 2144 char type; 2145} 2146elf_aarch64_section_map; 2147 2148 2149typedef struct _aarch64_elf_section_data 2150{ 2151 struct bfd_elf_section_data elf; 2152 unsigned int mapcount; 2153 unsigned int mapsize; 2154 elf_aarch64_section_map *map; 2155} 2156_aarch64_elf_section_data; 2157 2158#define elf_aarch64_section_data(sec) \ 2159 ((_aarch64_elf_section_data *) elf_section_data (sec)) 2160 2161/* The size of the thread control block which is defined to be two pointers. */ 2162#define TCB_SIZE (ARCH_SIZE/8)*2 2163 2164struct elf_aarch64_local_symbol 2165{ 2166 unsigned int got_type; 2167 bfd_signed_vma got_refcount; 2168 bfd_vma got_offset; 2169 2170 /* Offset of the GOTPLT entry reserved for the TLS descriptor. The 2171 offset is from the end of the jump table and reserved entries 2172 within the PLTGOT. 2173 2174 The magic value (bfd_vma) -1 indicates that an offset has not be 2175 allocated. */ 2176 bfd_vma tlsdesc_got_jump_table_offset; 2177}; 2178 2179struct elf_aarch64_obj_tdata 2180{ 2181 struct elf_obj_tdata root; 2182 2183 /* local symbol descriptors */ 2184 struct elf_aarch64_local_symbol *locals; 2185 2186 /* Zero to warn when linking objects with incompatible enum sizes. */ 2187 int no_enum_size_warning; 2188 2189 /* Zero to warn when linking objects with incompatible wchar_t sizes. */ 2190 int no_wchar_size_warning; 2191}; 2192 2193#define elf_aarch64_tdata(bfd) \ 2194 ((struct elf_aarch64_obj_tdata *) (bfd)->tdata.any) 2195 2196#define elf_aarch64_locals(bfd) (elf_aarch64_tdata (bfd)->locals) 2197 2198#define is_aarch64_elf(bfd) \ 2199 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \ 2200 && elf_tdata (bfd) != NULL \ 2201 && elf_object_id (bfd) == AARCH64_ELF_DATA) 2202 2203static bfd_boolean 2204elfNN_aarch64_mkobject (bfd *abfd) 2205{ 2206 return bfd_elf_allocate_object (abfd, sizeof (struct elf_aarch64_obj_tdata), 2207 AARCH64_ELF_DATA); 2208} 2209 2210#define elf_aarch64_hash_entry(ent) \ 2211 ((struct elf_aarch64_link_hash_entry *)(ent)) 2212 2213#define GOT_UNKNOWN 0 2214#define GOT_NORMAL 1 2215#define GOT_TLS_GD 2 2216#define GOT_TLS_IE 4 2217#define GOT_TLSDESC_GD 8 2218 2219#define GOT_TLS_GD_ANY_P(type) ((type & GOT_TLS_GD) || (type & GOT_TLSDESC_GD)) 2220 2221/* AArch64 ELF linker hash entry. */ 2222struct elf_aarch64_link_hash_entry 2223{ 2224 struct elf_link_hash_entry root; 2225 2226 /* Track dynamic relocs copied for this symbol. */ 2227 struct elf_dyn_relocs *dyn_relocs; 2228 2229 /* Since PLT entries have variable size, we need to record the 2230 index into .got.plt instead of recomputing it from the PLT 2231 offset. */ 2232 bfd_signed_vma plt_got_offset; 2233 2234 /* Bit mask representing the type of GOT entry(s) if any required by 2235 this symbol. */ 2236 unsigned int got_type; 2237 2238 /* A pointer to the most recently used stub hash entry against this 2239 symbol. */ 2240 struct elf_aarch64_stub_hash_entry *stub_cache; 2241 2242 /* Offset of the GOTPLT entry reserved for the TLS descriptor. The offset 2243 is from the end of the jump table and reserved entries within the PLTGOT. 2244 2245 The magic value (bfd_vma) -1 indicates that an offset has not 2246 be allocated. */ 2247 bfd_vma tlsdesc_got_jump_table_offset; 2248}; 2249 2250static unsigned int 2251elfNN_aarch64_symbol_got_type (struct elf_link_hash_entry *h, 2252 bfd *abfd, 2253 unsigned long r_symndx) 2254{ 2255 if (h) 2256 return elf_aarch64_hash_entry (h)->got_type; 2257 2258 if (! elf_aarch64_locals (abfd)) 2259 return GOT_UNKNOWN; 2260 2261 return elf_aarch64_locals (abfd)[r_symndx].got_type; 2262} 2263 2264/* Get the AArch64 elf linker hash table from a link_info structure. */ 2265#define elf_aarch64_hash_table(info) \ 2266 ((struct elf_aarch64_link_hash_table *) ((info)->hash)) 2267 2268#define aarch64_stub_hash_lookup(table, string, create, copy) \ 2269 ((struct elf_aarch64_stub_hash_entry *) \ 2270 bfd_hash_lookup ((table), (string), (create), (copy))) 2271 2272/* AArch64 ELF linker hash table. */ 2273struct elf_aarch64_link_hash_table 2274{ 2275 /* The main hash table. */ 2276 struct elf_link_hash_table root; 2277 2278 /* Nonzero to force PIC branch veneers. */ 2279 int pic_veneer; 2280 2281 /* Fix erratum 835769. */ 2282 int fix_erratum_835769; 2283 2284 /* Fix erratum 843419. */ 2285 int fix_erratum_843419; 2286 2287 /* Enable ADRP->ADR rewrite for erratum 843419 workaround. */ 2288 int fix_erratum_843419_adr; 2289 2290 /* Don't apply link-time values for dynamic relocations. */ 2291 int no_apply_dynamic_relocs; 2292 2293 /* The number of bytes in the initial entry in the PLT. */ 2294 bfd_size_type plt_header_size; 2295 2296 /* The number of bytes in the subsequent PLT etries. */ 2297 bfd_size_type plt_entry_size; 2298 2299 /* Small local sym cache. */ 2300 struct sym_cache sym_cache; 2301 2302 /* For convenience in allocate_dynrelocs. */ 2303 bfd *obfd; 2304 2305 /* The amount of space used by the reserved portion of the sgotplt 2306 section, plus whatever space is used by the jump slots. */ 2307 bfd_vma sgotplt_jump_table_size; 2308 2309 /* The stub hash table. */ 2310 struct bfd_hash_table stub_hash_table; 2311 2312 /* Linker stub bfd. */ 2313 bfd *stub_bfd; 2314 2315 /* Linker call-backs. */ 2316 asection *(*add_stub_section) (const char *, asection *); 2317 void (*layout_sections_again) (void); 2318 2319 /* Array to keep track of which stub sections have been created, and 2320 information on stub grouping. */ 2321 struct map_stub 2322 { 2323 /* This is the section to which stubs in the group will be 2324 attached. */ 2325 asection *link_sec; 2326 /* The stub section. */ 2327 asection *stub_sec; 2328 } *stub_group; 2329 2330 /* Assorted information used by elfNN_aarch64_size_stubs. */ 2331 unsigned int bfd_count; 2332 unsigned int top_index; 2333 asection **input_list; 2334 2335 /* The offset into splt of the PLT entry for the TLS descriptor 2336 resolver. Special values are 0, if not necessary (or not found 2337 to be necessary yet), and -1 if needed but not determined 2338 yet. */ 2339 bfd_vma tlsdesc_plt; 2340 2341 /* The GOT offset for the lazy trampoline. Communicated to the 2342 loader via DT_TLSDESC_GOT. The magic value (bfd_vma) -1 2343 indicates an offset is not allocated. */ 2344 bfd_vma dt_tlsdesc_got; 2345 2346 /* Used by local STT_GNU_IFUNC symbols. */ 2347 htab_t loc_hash_table; 2348 void * loc_hash_memory; 2349}; 2350 2351/* Create an entry in an AArch64 ELF linker hash table. */ 2352 2353static struct bfd_hash_entry * 2354elfNN_aarch64_link_hash_newfunc (struct bfd_hash_entry *entry, 2355 struct bfd_hash_table *table, 2356 const char *string) 2357{ 2358 struct elf_aarch64_link_hash_entry *ret = 2359 (struct elf_aarch64_link_hash_entry *) entry; 2360 2361 /* Allocate the structure if it has not already been allocated by a 2362 subclass. */ 2363 if (ret == NULL) 2364 ret = bfd_hash_allocate (table, 2365 sizeof (struct elf_aarch64_link_hash_entry)); 2366 if (ret == NULL) 2367 return (struct bfd_hash_entry *) ret; 2368 2369 /* Call the allocation method of the superclass. */ 2370 ret = ((struct elf_aarch64_link_hash_entry *) 2371 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret, 2372 table, string)); 2373 if (ret != NULL) 2374 { 2375 ret->dyn_relocs = NULL; 2376 ret->got_type = GOT_UNKNOWN; 2377 ret->plt_got_offset = (bfd_vma) - 1; 2378 ret->stub_cache = NULL; 2379 ret->tlsdesc_got_jump_table_offset = (bfd_vma) - 1; 2380 } 2381 2382 return (struct bfd_hash_entry *) ret; 2383} 2384 2385/* Initialize an entry in the stub hash table. */ 2386 2387static struct bfd_hash_entry * 2388stub_hash_newfunc (struct bfd_hash_entry *entry, 2389 struct bfd_hash_table *table, const char *string) 2390{ 2391 /* Allocate the structure if it has not already been allocated by a 2392 subclass. */ 2393 if (entry == NULL) 2394 { 2395 entry = bfd_hash_allocate (table, 2396 sizeof (struct 2397 elf_aarch64_stub_hash_entry)); 2398 if (entry == NULL) 2399 return entry; 2400 } 2401 2402 /* Call the allocation method of the superclass. */ 2403 entry = bfd_hash_newfunc (entry, table, string); 2404 if (entry != NULL) 2405 { 2406 struct elf_aarch64_stub_hash_entry *eh; 2407 2408 /* Initialize the local fields. */ 2409 eh = (struct elf_aarch64_stub_hash_entry *) entry; 2410 eh->adrp_offset = 0; 2411 eh->stub_sec = NULL; 2412 eh->stub_offset = 0; 2413 eh->target_value = 0; 2414 eh->target_section = NULL; 2415 eh->stub_type = aarch64_stub_none; 2416 eh->h = NULL; 2417 eh->id_sec = NULL; 2418 } 2419 2420 return entry; 2421} 2422 2423/* Compute a hash of a local hash entry. We use elf_link_hash_entry 2424 for local symbol so that we can handle local STT_GNU_IFUNC symbols 2425 as global symbol. We reuse indx and dynstr_index for local symbol 2426 hash since they aren't used by global symbols in this backend. */ 2427 2428static hashval_t 2429elfNN_aarch64_local_htab_hash (const void *ptr) 2430{ 2431 struct elf_link_hash_entry *h 2432 = (struct elf_link_hash_entry *) ptr; 2433 return ELF_LOCAL_SYMBOL_HASH (h->indx, h->dynstr_index); 2434} 2435 2436/* Compare local hash entries. */ 2437 2438static int 2439elfNN_aarch64_local_htab_eq (const void *ptr1, const void *ptr2) 2440{ 2441 struct elf_link_hash_entry *h1 2442 = (struct elf_link_hash_entry *) ptr1; 2443 struct elf_link_hash_entry *h2 2444 = (struct elf_link_hash_entry *) ptr2; 2445 2446 return h1->indx == h2->indx && h1->dynstr_index == h2->dynstr_index; 2447} 2448 2449/* Find and/or create a hash entry for local symbol. */ 2450 2451static struct elf_link_hash_entry * 2452elfNN_aarch64_get_local_sym_hash (struct elf_aarch64_link_hash_table *htab, 2453 bfd *abfd, const Elf_Internal_Rela *rel, 2454 bfd_boolean create) 2455{ 2456 struct elf_aarch64_link_hash_entry e, *ret; 2457 asection *sec = abfd->sections; 2458 hashval_t h = ELF_LOCAL_SYMBOL_HASH (sec->id, 2459 ELFNN_R_SYM (rel->r_info)); 2460 void **slot; 2461 2462 e.root.indx = sec->id; 2463 e.root.dynstr_index = ELFNN_R_SYM (rel->r_info); 2464 slot = htab_find_slot_with_hash (htab->loc_hash_table, &e, h, 2465 create ? INSERT : NO_INSERT); 2466 2467 if (!slot) 2468 return NULL; 2469 2470 if (*slot) 2471 { 2472 ret = (struct elf_aarch64_link_hash_entry *) *slot; 2473 return &ret->root; 2474 } 2475 2476 ret = (struct elf_aarch64_link_hash_entry *) 2477 objalloc_alloc ((struct objalloc *) htab->loc_hash_memory, 2478 sizeof (struct elf_aarch64_link_hash_entry)); 2479 if (ret) 2480 { 2481 memset (ret, 0, sizeof (*ret)); 2482 ret->root.indx = sec->id; 2483 ret->root.dynstr_index = ELFNN_R_SYM (rel->r_info); 2484 ret->root.dynindx = -1; 2485 *slot = ret; 2486 } 2487 return &ret->root; 2488} 2489 2490/* Copy the extra info we tack onto an elf_link_hash_entry. */ 2491 2492static void 2493elfNN_aarch64_copy_indirect_symbol (struct bfd_link_info *info, 2494 struct elf_link_hash_entry *dir, 2495 struct elf_link_hash_entry *ind) 2496{ 2497 struct elf_aarch64_link_hash_entry *edir, *eind; 2498 2499 edir = (struct elf_aarch64_link_hash_entry *) dir; 2500 eind = (struct elf_aarch64_link_hash_entry *) ind; 2501 2502 if (eind->dyn_relocs != NULL) 2503 { 2504 if (edir->dyn_relocs != NULL) 2505 { 2506 struct elf_dyn_relocs **pp; 2507 struct elf_dyn_relocs *p; 2508 2509 /* Add reloc counts against the indirect sym to the direct sym 2510 list. Merge any entries against the same section. */ 2511 for (pp = &eind->dyn_relocs; (p = *pp) != NULL;) 2512 { 2513 struct elf_dyn_relocs *q; 2514 2515 for (q = edir->dyn_relocs; q != NULL; q = q->next) 2516 if (q->sec == p->sec) 2517 { 2518 q->pc_count += p->pc_count; 2519 q->count += p->count; 2520 *pp = p->next; 2521 break; 2522 } 2523 if (q == NULL) 2524 pp = &p->next; 2525 } 2526 *pp = edir->dyn_relocs; 2527 } 2528 2529 edir->dyn_relocs = eind->dyn_relocs; 2530 eind->dyn_relocs = NULL; 2531 } 2532 2533 if (ind->root.type == bfd_link_hash_indirect) 2534 { 2535 /* Copy over PLT info. */ 2536 if (dir->got.refcount <= 0) 2537 { 2538 edir->got_type = eind->got_type; 2539 eind->got_type = GOT_UNKNOWN; 2540 } 2541 } 2542 2543 _bfd_elf_link_hash_copy_indirect (info, dir, ind); 2544} 2545 2546/* Destroy an AArch64 elf linker hash table. */ 2547 2548static void 2549elfNN_aarch64_link_hash_table_free (bfd *obfd) 2550{ 2551 struct elf_aarch64_link_hash_table *ret 2552 = (struct elf_aarch64_link_hash_table *) obfd->link.hash; 2553 2554 if (ret->loc_hash_table) 2555 htab_delete (ret->loc_hash_table); 2556 if (ret->loc_hash_memory) 2557 objalloc_free ((struct objalloc *) ret->loc_hash_memory); 2558 2559 bfd_hash_table_free (&ret->stub_hash_table); 2560 _bfd_elf_link_hash_table_free (obfd); 2561} 2562 2563/* Create an AArch64 elf linker hash table. */ 2564 2565static struct bfd_link_hash_table * 2566elfNN_aarch64_link_hash_table_create (bfd *abfd) 2567{ 2568 struct elf_aarch64_link_hash_table *ret; 2569 bfd_size_type amt = sizeof (struct elf_aarch64_link_hash_table); 2570 2571 ret = bfd_zmalloc (amt); 2572 if (ret == NULL) 2573 return NULL; 2574 2575 if (!_bfd_elf_link_hash_table_init 2576 (&ret->root, abfd, elfNN_aarch64_link_hash_newfunc, 2577 sizeof (struct elf_aarch64_link_hash_entry), AARCH64_ELF_DATA)) 2578 { 2579 free (ret); 2580 return NULL; 2581 } 2582 2583 ret->plt_header_size = PLT_ENTRY_SIZE; 2584 ret->plt_entry_size = PLT_SMALL_ENTRY_SIZE; 2585 ret->obfd = abfd; 2586 ret->dt_tlsdesc_got = (bfd_vma) - 1; 2587 2588 if (!bfd_hash_table_init (&ret->stub_hash_table, stub_hash_newfunc, 2589 sizeof (struct elf_aarch64_stub_hash_entry))) 2590 { 2591 _bfd_elf_link_hash_table_free (abfd); 2592 return NULL; 2593 } 2594 2595 ret->loc_hash_table = htab_try_create (1024, 2596 elfNN_aarch64_local_htab_hash, 2597 elfNN_aarch64_local_htab_eq, 2598 NULL); 2599 ret->loc_hash_memory = objalloc_create (); 2600 if (!ret->loc_hash_table || !ret->loc_hash_memory) 2601 { 2602 elfNN_aarch64_link_hash_table_free (abfd); 2603 return NULL; 2604 } 2605 ret->root.root.hash_table_free = elfNN_aarch64_link_hash_table_free; 2606 2607 return &ret->root.root; 2608} 2609 2610static bfd_boolean 2611aarch64_relocate (unsigned int r_type, bfd *input_bfd, asection *input_section, 2612 bfd_vma offset, bfd_vma value) 2613{ 2614 reloc_howto_type *howto; 2615 bfd_vma place; 2616 2617 howto = elfNN_aarch64_howto_from_type (r_type); 2618 place = (input_section->output_section->vma + input_section->output_offset 2619 + offset); 2620 2621 r_type = elfNN_aarch64_bfd_reloc_from_type (r_type); 2622 value = _bfd_aarch64_elf_resolve_relocation (r_type, place, value, 0, FALSE); 2623 return _bfd_aarch64_elf_put_addend (input_bfd, 2624 input_section->contents + offset, r_type, 2625 howto, value); 2626} 2627 2628static enum elf_aarch64_stub_type 2629aarch64_select_branch_stub (bfd_vma value, bfd_vma place) 2630{ 2631 if (aarch64_valid_for_adrp_p (value, place)) 2632 return aarch64_stub_adrp_branch; 2633 return aarch64_stub_long_branch; 2634} 2635 2636/* Determine the type of stub needed, if any, for a call. */ 2637 2638static enum elf_aarch64_stub_type 2639aarch64_type_of_stub (asection *input_sec, 2640 const Elf_Internal_Rela *rel, 2641 asection *sym_sec, 2642 unsigned char st_type, 2643 bfd_vma destination) 2644{ 2645 bfd_vma location; 2646 bfd_signed_vma branch_offset; 2647 unsigned int r_type; 2648 enum elf_aarch64_stub_type stub_type = aarch64_stub_none; 2649 2650 if (st_type != STT_FUNC 2651 && (sym_sec == input_sec)) 2652 return stub_type; 2653 2654 /* Determine where the call point is. */ 2655 location = (input_sec->output_offset 2656 + input_sec->output_section->vma + rel->r_offset); 2657 2658 branch_offset = (bfd_signed_vma) (destination - location); 2659 2660 r_type = ELFNN_R_TYPE (rel->r_info); 2661 2662 /* We don't want to redirect any old unconditional jump in this way, 2663 only one which is being used for a sibcall, where it is 2664 acceptable for the IP0 and IP1 registers to be clobbered. */ 2665 if ((r_type == AARCH64_R (CALL26) || r_type == AARCH64_R (JUMP26)) 2666 && (branch_offset > AARCH64_MAX_FWD_BRANCH_OFFSET 2667 || branch_offset < AARCH64_MAX_BWD_BRANCH_OFFSET)) 2668 { 2669 stub_type = aarch64_stub_long_branch; 2670 } 2671 2672 return stub_type; 2673} 2674 2675/* Build a name for an entry in the stub hash table. */ 2676 2677static char * 2678elfNN_aarch64_stub_name (const asection *input_section, 2679 const asection *sym_sec, 2680 const struct elf_aarch64_link_hash_entry *hash, 2681 const Elf_Internal_Rela *rel) 2682{ 2683 char *stub_name; 2684 bfd_size_type len; 2685 2686 if (hash) 2687 { 2688 len = 8 + 1 + strlen (hash->root.root.root.string) + 1 + 16 + 1; 2689 stub_name = bfd_malloc (len); 2690 if (stub_name != NULL) 2691 snprintf (stub_name, len, "%08x_%s+%" BFD_VMA_FMT "x", 2692 (unsigned int) input_section->id, 2693 hash->root.root.root.string, 2694 rel->r_addend); 2695 } 2696 else 2697 { 2698 len = 8 + 1 + 8 + 1 + 8 + 1 + 16 + 1; 2699 stub_name = bfd_malloc (len); 2700 if (stub_name != NULL) 2701 snprintf (stub_name, len, "%08x_%x:%x+%" BFD_VMA_FMT "x", 2702 (unsigned int) input_section->id, 2703 (unsigned int) sym_sec->id, 2704 (unsigned int) ELFNN_R_SYM (rel->r_info), 2705 rel->r_addend); 2706 } 2707 2708 return stub_name; 2709} 2710 2711/* Look up an entry in the stub hash. Stub entries are cached because 2712 creating the stub name takes a bit of time. */ 2713 2714static struct elf_aarch64_stub_hash_entry * 2715elfNN_aarch64_get_stub_entry (const asection *input_section, 2716 const asection *sym_sec, 2717 struct elf_link_hash_entry *hash, 2718 const Elf_Internal_Rela *rel, 2719 struct elf_aarch64_link_hash_table *htab) 2720{ 2721 struct elf_aarch64_stub_hash_entry *stub_entry; 2722 struct elf_aarch64_link_hash_entry *h = 2723 (struct elf_aarch64_link_hash_entry *) hash; 2724 const asection *id_sec; 2725 2726 if ((input_section->flags & SEC_CODE) == 0) 2727 return NULL; 2728 2729 /* If this input section is part of a group of sections sharing one 2730 stub section, then use the id of the first section in the group. 2731 Stub names need to include a section id, as there may well be 2732 more than one stub used to reach say, printf, and we need to 2733 distinguish between them. */ 2734 id_sec = htab->stub_group[input_section->id].link_sec; 2735 2736 if (h != NULL && h->stub_cache != NULL 2737 && h->stub_cache->h == h && h->stub_cache->id_sec == id_sec) 2738 { 2739 stub_entry = h->stub_cache; 2740 } 2741 else 2742 { 2743 char *stub_name; 2744 2745 stub_name = elfNN_aarch64_stub_name (id_sec, sym_sec, h, rel); 2746 if (stub_name == NULL) 2747 return NULL; 2748 2749 stub_entry = aarch64_stub_hash_lookup (&htab->stub_hash_table, 2750 stub_name, FALSE, FALSE); 2751 if (h != NULL) 2752 h->stub_cache = stub_entry; 2753 2754 free (stub_name); 2755 } 2756 2757 return stub_entry; 2758} 2759 2760 2761/* Create a stub section. */ 2762 2763static asection * 2764_bfd_aarch64_create_stub_section (asection *section, 2765 struct elf_aarch64_link_hash_table *htab) 2766{ 2767 size_t namelen; 2768 bfd_size_type len; 2769 char *s_name; 2770 2771 namelen = strlen (section->name); 2772 len = namelen + sizeof (STUB_SUFFIX); 2773 s_name = bfd_alloc (htab->stub_bfd, len); 2774 if (s_name == NULL) 2775 return NULL; 2776 2777 memcpy (s_name, section->name, namelen); 2778 memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX)); 2779 return (*htab->add_stub_section) (s_name, section); 2780} 2781 2782 2783/* Find or create a stub section for a link section. 2784 2785 Fix or create the stub section used to collect stubs attached to 2786 the specified link section. */ 2787 2788static asection * 2789_bfd_aarch64_get_stub_for_link_section (asection *link_section, 2790 struct elf_aarch64_link_hash_table *htab) 2791{ 2792 if (htab->stub_group[link_section->id].stub_sec == NULL) 2793 htab->stub_group[link_section->id].stub_sec 2794 = _bfd_aarch64_create_stub_section (link_section, htab); 2795 return htab->stub_group[link_section->id].stub_sec; 2796} 2797 2798 2799/* Find or create a stub section in the stub group for an input 2800 section. */ 2801 2802static asection * 2803_bfd_aarch64_create_or_find_stub_sec (asection *section, 2804 struct elf_aarch64_link_hash_table *htab) 2805{ 2806 asection *link_sec = htab->stub_group[section->id].link_sec; 2807 return _bfd_aarch64_get_stub_for_link_section (link_sec, htab); 2808} 2809 2810 2811/* Add a new stub entry in the stub group associated with an input 2812 section to the stub hash. Not all fields of the new stub entry are 2813 initialised. */ 2814 2815static struct elf_aarch64_stub_hash_entry * 2816_bfd_aarch64_add_stub_entry_in_group (const char *stub_name, 2817 asection *section, 2818 struct elf_aarch64_link_hash_table *htab) 2819{ 2820 asection *link_sec; 2821 asection *stub_sec; 2822 struct elf_aarch64_stub_hash_entry *stub_entry; 2823 2824 link_sec = htab->stub_group[section->id].link_sec; 2825 stub_sec = _bfd_aarch64_create_or_find_stub_sec (section, htab); 2826 2827 /* Enter this entry into the linker stub hash table. */ 2828 stub_entry = aarch64_stub_hash_lookup (&htab->stub_hash_table, stub_name, 2829 TRUE, FALSE); 2830 if (stub_entry == NULL) 2831 { 2832 /* xgettext:c-format */ 2833 _bfd_error_handler (_("%s: cannot create stub entry %s"), 2834 section->owner, stub_name); 2835 return NULL; 2836 } 2837 2838 stub_entry->stub_sec = stub_sec; 2839 stub_entry->stub_offset = 0; 2840 stub_entry->id_sec = link_sec; 2841 2842 return stub_entry; 2843} 2844 2845/* Add a new stub entry in the final stub section to the stub hash. 2846 Not all fields of the new stub entry are initialised. */ 2847 2848static struct elf_aarch64_stub_hash_entry * 2849_bfd_aarch64_add_stub_entry_after (const char *stub_name, 2850 asection *link_section, 2851 struct elf_aarch64_link_hash_table *htab) 2852{ 2853 asection *stub_sec; 2854 struct elf_aarch64_stub_hash_entry *stub_entry; 2855 2856 stub_sec = _bfd_aarch64_get_stub_for_link_section (link_section, htab); 2857 stub_entry = aarch64_stub_hash_lookup (&htab->stub_hash_table, stub_name, 2858 TRUE, FALSE); 2859 if (stub_entry == NULL) 2860 { 2861 _bfd_error_handler (_("cannot create stub entry %s"), stub_name); 2862 return NULL; 2863 } 2864 2865 stub_entry->stub_sec = stub_sec; 2866 stub_entry->stub_offset = 0; 2867 stub_entry->id_sec = link_section; 2868 2869 return stub_entry; 2870} 2871 2872 2873static bfd_boolean 2874aarch64_build_one_stub (struct bfd_hash_entry *gen_entry, 2875 void *in_arg ATTRIBUTE_UNUSED) 2876{ 2877 struct elf_aarch64_stub_hash_entry *stub_entry; 2878 asection *stub_sec; 2879 bfd *stub_bfd; 2880 bfd_byte *loc; 2881 bfd_vma sym_value; 2882 bfd_vma veneered_insn_loc; 2883 bfd_vma veneer_entry_loc; 2884 bfd_signed_vma branch_offset = 0; 2885 unsigned int template_size; 2886 const uint32_t *template; 2887 unsigned int i; 2888 2889 /* Massage our args to the form they really have. */ 2890 stub_entry = (struct elf_aarch64_stub_hash_entry *) gen_entry; 2891 2892 stub_sec = stub_entry->stub_sec; 2893 2894 /* Make a note of the offset within the stubs for this entry. */ 2895 stub_entry->stub_offset = stub_sec->size; 2896 loc = stub_sec->contents + stub_entry->stub_offset; 2897 2898 stub_bfd = stub_sec->owner; 2899 2900 /* This is the address of the stub destination. */ 2901 sym_value = (stub_entry->target_value 2902 + stub_entry->target_section->output_offset 2903 + stub_entry->target_section->output_section->vma); 2904 2905 if (stub_entry->stub_type == aarch64_stub_long_branch) 2906 { 2907 bfd_vma place = (stub_entry->stub_offset + stub_sec->output_section->vma 2908 + stub_sec->output_offset); 2909 2910 /* See if we can relax the stub. */ 2911 if (aarch64_valid_for_adrp_p (sym_value, place)) 2912 stub_entry->stub_type = aarch64_select_branch_stub (sym_value, place); 2913 } 2914 2915 switch (stub_entry->stub_type) 2916 { 2917 case aarch64_stub_adrp_branch: 2918 template = aarch64_adrp_branch_stub; 2919 template_size = sizeof (aarch64_adrp_branch_stub); 2920 break; 2921 case aarch64_stub_long_branch: 2922 template = aarch64_long_branch_stub; 2923 template_size = sizeof (aarch64_long_branch_stub); 2924 break; 2925 case aarch64_stub_erratum_835769_veneer: 2926 template = aarch64_erratum_835769_stub; 2927 template_size = sizeof (aarch64_erratum_835769_stub); 2928 break; 2929 case aarch64_stub_erratum_843419_veneer: 2930 template = aarch64_erratum_843419_stub; 2931 template_size = sizeof (aarch64_erratum_843419_stub); 2932 break; 2933 default: 2934 abort (); 2935 } 2936 2937 for (i = 0; i < (template_size / sizeof template[0]); i++) 2938 { 2939 bfd_putl32 (template[i], loc); 2940 loc += 4; 2941 } 2942 2943 template_size = (template_size + 7) & ~7; 2944 stub_sec->size += template_size; 2945 2946 switch (stub_entry->stub_type) 2947 { 2948 case aarch64_stub_adrp_branch: 2949 if (aarch64_relocate (AARCH64_R (ADR_PREL_PG_HI21), stub_bfd, stub_sec, 2950 stub_entry->stub_offset, sym_value)) 2951 /* The stub would not have been relaxed if the offset was out 2952 of range. */ 2953 BFD_FAIL (); 2954 2955 if (aarch64_relocate (AARCH64_R (ADD_ABS_LO12_NC), stub_bfd, stub_sec, 2956 stub_entry->stub_offset + 4, sym_value)) 2957 BFD_FAIL (); 2958 break; 2959 2960 case aarch64_stub_long_branch: 2961 /* We want the value relative to the address 12 bytes back from the 2962 value itself. */ 2963 if (aarch64_relocate (AARCH64_R (PRELNN), stub_bfd, stub_sec, 2964 stub_entry->stub_offset + 16, sym_value + 12)) 2965 BFD_FAIL (); 2966 break; 2967 2968 case aarch64_stub_erratum_835769_veneer: 2969 veneered_insn_loc = stub_entry->target_section->output_section->vma 2970 + stub_entry->target_section->output_offset 2971 + stub_entry->target_value; 2972 veneer_entry_loc = stub_entry->stub_sec->output_section->vma 2973 + stub_entry->stub_sec->output_offset 2974 + stub_entry->stub_offset; 2975 branch_offset = veneered_insn_loc - veneer_entry_loc; 2976 branch_offset >>= 2; 2977 branch_offset &= 0x3ffffff; 2978 bfd_putl32 (stub_entry->veneered_insn, 2979 stub_sec->contents + stub_entry->stub_offset); 2980 bfd_putl32 (template[1] | branch_offset, 2981 stub_sec->contents + stub_entry->stub_offset + 4); 2982 break; 2983 2984 case aarch64_stub_erratum_843419_veneer: 2985 if (aarch64_relocate (AARCH64_R (JUMP26), stub_bfd, stub_sec, 2986 stub_entry->stub_offset + 4, sym_value + 4)) 2987 BFD_FAIL (); 2988 break; 2989 2990 default: 2991 abort (); 2992 } 2993 2994 return TRUE; 2995} 2996 2997/* As above, but don't actually build the stub. Just bump offset so 2998 we know stub section sizes. */ 2999 3000static bfd_boolean 3001aarch64_size_one_stub (struct bfd_hash_entry *gen_entry, 3002 void *in_arg ATTRIBUTE_UNUSED) 3003{ 3004 struct elf_aarch64_stub_hash_entry *stub_entry; 3005 int size; 3006 3007 /* Massage our args to the form they really have. */ 3008 stub_entry = (struct elf_aarch64_stub_hash_entry *) gen_entry; 3009 3010 switch (stub_entry->stub_type) 3011 { 3012 case aarch64_stub_adrp_branch: 3013 size = sizeof (aarch64_adrp_branch_stub); 3014 break; 3015 case aarch64_stub_long_branch: 3016 size = sizeof (aarch64_long_branch_stub); 3017 break; 3018 case aarch64_stub_erratum_835769_veneer: 3019 size = sizeof (aarch64_erratum_835769_stub); 3020 break; 3021 case aarch64_stub_erratum_843419_veneer: 3022 size = sizeof (aarch64_erratum_843419_stub); 3023 break; 3024 default: 3025 abort (); 3026 } 3027 3028 size = (size + 7) & ~7; 3029 stub_entry->stub_sec->size += size; 3030 return TRUE; 3031} 3032 3033/* External entry points for sizing and building linker stubs. */ 3034 3035/* Set up various things so that we can make a list of input sections 3036 for each output section included in the link. Returns -1 on error, 3037 0 when no stubs will be needed, and 1 on success. */ 3038 3039int 3040elfNN_aarch64_setup_section_lists (bfd *output_bfd, 3041 struct bfd_link_info *info) 3042{ 3043 bfd *input_bfd; 3044 unsigned int bfd_count; 3045 unsigned int top_id, top_index; 3046 asection *section; 3047 asection **input_list, **list; 3048 bfd_size_type amt; 3049 struct elf_aarch64_link_hash_table *htab = 3050 elf_aarch64_hash_table (info); 3051 3052 if (!is_elf_hash_table (htab)) 3053 return 0; 3054 3055 /* Count the number of input BFDs and find the top input section id. */ 3056 for (input_bfd = info->input_bfds, bfd_count = 0, top_id = 0; 3057 input_bfd != NULL; input_bfd = input_bfd->link.next) 3058 { 3059 bfd_count += 1; 3060 for (section = input_bfd->sections; 3061 section != NULL; section = section->next) 3062 { 3063 if (top_id < section->id) 3064 top_id = section->id; 3065 } 3066 } 3067 htab->bfd_count = bfd_count; 3068 3069 amt = sizeof (struct map_stub) * (top_id + 1); 3070 htab->stub_group = bfd_zmalloc (amt); 3071 if (htab->stub_group == NULL) 3072 return -1; 3073 3074 /* We can't use output_bfd->section_count here to find the top output 3075 section index as some sections may have been removed, and 3076 _bfd_strip_section_from_output doesn't renumber the indices. */ 3077 for (section = output_bfd->sections, top_index = 0; 3078 section != NULL; section = section->next) 3079 { 3080 if (top_index < section->index) 3081 top_index = section->index; 3082 } 3083 3084 htab->top_index = top_index; 3085 amt = sizeof (asection *) * (top_index + 1); 3086 input_list = bfd_malloc (amt); 3087 htab->input_list = input_list; 3088 if (input_list == NULL) 3089 return -1; 3090 3091 /* For sections we aren't interested in, mark their entries with a 3092 value we can check later. */ 3093 list = input_list + top_index; 3094 do 3095 *list = bfd_abs_section_ptr; 3096 while (list-- != input_list); 3097 3098 for (section = output_bfd->sections; 3099 section != NULL; section = section->next) 3100 { 3101 if ((section->flags & SEC_CODE) != 0) 3102 input_list[section->index] = NULL; 3103 } 3104 3105 return 1; 3106} 3107 3108/* Used by elfNN_aarch64_next_input_section and group_sections. */ 3109#define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec) 3110 3111/* The linker repeatedly calls this function for each input section, 3112 in the order that input sections are linked into output sections. 3113 Build lists of input sections to determine groupings between which 3114 we may insert linker stubs. */ 3115 3116void 3117elfNN_aarch64_next_input_section (struct bfd_link_info *info, asection *isec) 3118{ 3119 struct elf_aarch64_link_hash_table *htab = 3120 elf_aarch64_hash_table (info); 3121 3122 if (isec->output_section->index <= htab->top_index) 3123 { 3124 asection **list = htab->input_list + isec->output_section->index; 3125 3126 if (*list != bfd_abs_section_ptr) 3127 { 3128 /* Steal the link_sec pointer for our list. */ 3129 /* This happens to make the list in reverse order, 3130 which is what we want. */ 3131 PREV_SEC (isec) = *list; 3132 *list = isec; 3133 } 3134 } 3135} 3136 3137/* See whether we can group stub sections together. Grouping stub 3138 sections may result in fewer stubs. More importantly, we need to 3139 put all .init* and .fini* stubs at the beginning of the .init or 3140 .fini output sections respectively, because glibc splits the 3141 _init and _fini functions into multiple parts. Putting a stub in 3142 the middle of a function is not a good idea. */ 3143 3144static void 3145group_sections (struct elf_aarch64_link_hash_table *htab, 3146 bfd_size_type stub_group_size, 3147 bfd_boolean stubs_always_before_branch) 3148{ 3149 asection **list = htab->input_list + htab->top_index; 3150 3151 do 3152 { 3153 asection *tail = *list; 3154 3155 if (tail == bfd_abs_section_ptr) 3156 continue; 3157 3158 while (tail != NULL) 3159 { 3160 asection *curr; 3161 asection *prev; 3162 bfd_size_type total; 3163 3164 curr = tail; 3165 total = tail->size; 3166 while ((prev = PREV_SEC (curr)) != NULL 3167 && ((total += curr->output_offset - prev->output_offset) 3168 < stub_group_size)) 3169 curr = prev; 3170 3171 /* OK, the size from the start of CURR to the end is less 3172 than stub_group_size and thus can be handled by one stub 3173 section. (Or the tail section is itself larger than 3174 stub_group_size, in which case we may be toast.) 3175 We should really be keeping track of the total size of 3176 stubs added here, as stubs contribute to the final output 3177 section size. */ 3178 do 3179 { 3180 prev = PREV_SEC (tail); 3181 /* Set up this stub group. */ 3182 htab->stub_group[tail->id].link_sec = curr; 3183 } 3184 while (tail != curr && (tail = prev) != NULL); 3185 3186 /* But wait, there's more! Input sections up to stub_group_size 3187 bytes before the stub section can be handled by it too. */ 3188 if (!stubs_always_before_branch) 3189 { 3190 total = 0; 3191 while (prev != NULL 3192 && ((total += tail->output_offset - prev->output_offset) 3193 < stub_group_size)) 3194 { 3195 tail = prev; 3196 prev = PREV_SEC (tail); 3197 htab->stub_group[tail->id].link_sec = curr; 3198 } 3199 } 3200 tail = prev; 3201 } 3202 } 3203 while (list-- != htab->input_list); 3204 3205 free (htab->input_list); 3206} 3207 3208#undef PREV_SEC 3209 3210#define AARCH64_BITS(x, pos, n) (((x) >> (pos)) & ((1 << (n)) - 1)) 3211 3212#define AARCH64_RT(insn) AARCH64_BITS (insn, 0, 5) 3213#define AARCH64_RT2(insn) AARCH64_BITS (insn, 10, 5) 3214#define AARCH64_RA(insn) AARCH64_BITS (insn, 10, 5) 3215#define AARCH64_RD(insn) AARCH64_BITS (insn, 0, 5) 3216#define AARCH64_RN(insn) AARCH64_BITS (insn, 5, 5) 3217#define AARCH64_RM(insn) AARCH64_BITS (insn, 16, 5) 3218 3219#define AARCH64_MAC(insn) (((insn) & 0xff000000) == 0x9b000000) 3220#define AARCH64_BIT(insn, n) AARCH64_BITS (insn, n, 1) 3221#define AARCH64_OP31(insn) AARCH64_BITS (insn, 21, 3) 3222#define AARCH64_ZR 0x1f 3223 3224/* All ld/st ops. See C4-182 of the ARM ARM. The encoding space for 3225 LD_PCREL, LDST_RO, LDST_UI and LDST_UIMM cover prefetch ops. */ 3226 3227#define AARCH64_LD(insn) (AARCH64_BIT (insn, 22) == 1) 3228#define AARCH64_LDST(insn) (((insn) & 0x0a000000) == 0x08000000) 3229#define AARCH64_LDST_EX(insn) (((insn) & 0x3f000000) == 0x08000000) 3230#define AARCH64_LDST_PCREL(insn) (((insn) & 0x3b000000) == 0x18000000) 3231#define AARCH64_LDST_NAP(insn) (((insn) & 0x3b800000) == 0x28000000) 3232#define AARCH64_LDSTP_PI(insn) (((insn) & 0x3b800000) == 0x28800000) 3233#define AARCH64_LDSTP_O(insn) (((insn) & 0x3b800000) == 0x29000000) 3234#define AARCH64_LDSTP_PRE(insn) (((insn) & 0x3b800000) == 0x29800000) 3235#define AARCH64_LDST_UI(insn) (((insn) & 0x3b200c00) == 0x38000000) 3236#define AARCH64_LDST_PIIMM(insn) (((insn) & 0x3b200c00) == 0x38000400) 3237#define AARCH64_LDST_U(insn) (((insn) & 0x3b200c00) == 0x38000800) 3238#define AARCH64_LDST_PREIMM(insn) (((insn) & 0x3b200c00) == 0x38000c00) 3239#define AARCH64_LDST_RO(insn) (((insn) & 0x3b200c00) == 0x38200800) 3240#define AARCH64_LDST_UIMM(insn) (((insn) & 0x3b000000) == 0x39000000) 3241#define AARCH64_LDST_SIMD_M(insn) (((insn) & 0xbfbf0000) == 0x0c000000) 3242#define AARCH64_LDST_SIMD_M_PI(insn) (((insn) & 0xbfa00000) == 0x0c800000) 3243#define AARCH64_LDST_SIMD_S(insn) (((insn) & 0xbf9f0000) == 0x0d000000) 3244#define AARCH64_LDST_SIMD_S_PI(insn) (((insn) & 0xbf800000) == 0x0d800000) 3245 3246/* Classify an INSN if it is indeed a load/store. 3247 3248 Return TRUE if INSN is a LD/ST instruction otherwise return FALSE. 3249 3250 For scalar LD/ST instructions PAIR is FALSE, RT is returned and RT2 3251 is set equal to RT. 3252 3253 For LD/ST pair instructions PAIR is TRUE, RT and RT2 are returned. 3254 3255 */ 3256 3257static bfd_boolean 3258aarch64_mem_op_p (uint32_t insn, unsigned int *rt, unsigned int *rt2, 3259 bfd_boolean *pair, bfd_boolean *load) 3260{ 3261 uint32_t opcode; 3262 unsigned int r; 3263 uint32_t opc = 0; 3264 uint32_t v = 0; 3265 uint32_t opc_v = 0; 3266 3267 /* Bail out quickly if INSN doesn't fall into the the load-store 3268 encoding space. */ 3269 if (!AARCH64_LDST (insn)) 3270 return FALSE; 3271 3272 *pair = FALSE; 3273 *load = FALSE; 3274 if (AARCH64_LDST_EX (insn)) 3275 { 3276 *rt = AARCH64_RT (insn); 3277 *rt2 = *rt; 3278 if (AARCH64_BIT (insn, 21) == 1) 3279 { 3280 *pair = TRUE; 3281 *rt2 = AARCH64_RT2 (insn); 3282 } 3283 *load = AARCH64_LD (insn); 3284 return TRUE; 3285 } 3286 else if (AARCH64_LDST_NAP (insn) 3287 || AARCH64_LDSTP_PI (insn) 3288 || AARCH64_LDSTP_O (insn) 3289 || AARCH64_LDSTP_PRE (insn)) 3290 { 3291 *pair = TRUE; 3292 *rt = AARCH64_RT (insn); 3293 *rt2 = AARCH64_RT2 (insn); 3294 *load = AARCH64_LD (insn); 3295 return TRUE; 3296 } 3297 else if (AARCH64_LDST_PCREL (insn) 3298 || AARCH64_LDST_UI (insn) 3299 || AARCH64_LDST_PIIMM (insn) 3300 || AARCH64_LDST_U (insn) 3301 || AARCH64_LDST_PREIMM (insn) 3302 || AARCH64_LDST_RO (insn) 3303 || AARCH64_LDST_UIMM (insn)) 3304 { 3305 *rt = AARCH64_RT (insn); 3306 *rt2 = *rt; 3307 if (AARCH64_LDST_PCREL (insn)) 3308 *load = TRUE; 3309 opc = AARCH64_BITS (insn, 22, 2); 3310 v = AARCH64_BIT (insn, 26); 3311 opc_v = opc | (v << 2); 3312 *load = (opc_v == 1 || opc_v == 2 || opc_v == 3 3313 || opc_v == 5 || opc_v == 7); 3314 return TRUE; 3315 } 3316 else if (AARCH64_LDST_SIMD_M (insn) 3317 || AARCH64_LDST_SIMD_M_PI (insn)) 3318 { 3319 *rt = AARCH64_RT (insn); 3320 *load = AARCH64_BIT (insn, 22); 3321 opcode = (insn >> 12) & 0xf; 3322 switch (opcode) 3323 { 3324 case 0: 3325 case 2: 3326 *rt2 = *rt + 3; 3327 break; 3328 3329 case 4: 3330 case 6: 3331 *rt2 = *rt + 2; 3332 break; 3333 3334 case 7: 3335 *rt2 = *rt; 3336 break; 3337 3338 case 8: 3339 case 10: 3340 *rt2 = *rt + 1; 3341 break; 3342 3343 default: 3344 return FALSE; 3345 } 3346 return TRUE; 3347 } 3348 else if (AARCH64_LDST_SIMD_S (insn) 3349 || AARCH64_LDST_SIMD_S_PI (insn)) 3350 { 3351 *rt = AARCH64_RT (insn); 3352 r = (insn >> 21) & 1; 3353 *load = AARCH64_BIT (insn, 22); 3354 opcode = (insn >> 13) & 0x7; 3355 switch (opcode) 3356 { 3357 case 0: 3358 case 2: 3359 case 4: 3360 *rt2 = *rt + r; 3361 break; 3362 3363 case 1: 3364 case 3: 3365 case 5: 3366 *rt2 = *rt + (r == 0 ? 2 : 3); 3367 break; 3368 3369 case 6: 3370 *rt2 = *rt + r; 3371 break; 3372 3373 case 7: 3374 *rt2 = *rt + (r == 0 ? 2 : 3); 3375 break; 3376 3377 default: 3378 return FALSE; 3379 } 3380 return TRUE; 3381 } 3382 3383 return FALSE; 3384} 3385 3386/* Return TRUE if INSN is multiply-accumulate. */ 3387 3388static bfd_boolean 3389aarch64_mlxl_p (uint32_t insn) 3390{ 3391 uint32_t op31 = AARCH64_OP31 (insn); 3392 3393 if (AARCH64_MAC (insn) 3394 && (op31 == 0 || op31 == 1 || op31 == 5) 3395 /* Exclude MUL instructions which are encoded as a multiple accumulate 3396 with RA = XZR. */ 3397 && AARCH64_RA (insn) != AARCH64_ZR) 3398 return TRUE; 3399 3400 return FALSE; 3401} 3402 3403/* Some early revisions of the Cortex-A53 have an erratum (835769) whereby 3404 it is possible for a 64-bit multiply-accumulate instruction to generate an 3405 incorrect result. The details are quite complex and hard to 3406 determine statically, since branches in the code may exist in some 3407 circumstances, but all cases end with a memory (load, store, or 3408 prefetch) instruction followed immediately by the multiply-accumulate 3409 operation. We employ a linker patching technique, by moving the potentially 3410 affected multiply-accumulate instruction into a patch region and replacing 3411 the original instruction with a branch to the patch. This function checks 3412 if INSN_1 is the memory operation followed by a multiply-accumulate 3413 operation (INSN_2). Return TRUE if an erratum sequence is found, FALSE 3414 if INSN_1 and INSN_2 are safe. */ 3415 3416static bfd_boolean 3417aarch64_erratum_sequence (uint32_t insn_1, uint32_t insn_2) 3418{ 3419 uint32_t rt; 3420 uint32_t rt2; 3421 uint32_t rn; 3422 uint32_t rm; 3423 uint32_t ra; 3424 bfd_boolean pair; 3425 bfd_boolean load; 3426 3427 if (aarch64_mlxl_p (insn_2) 3428 && aarch64_mem_op_p (insn_1, &rt, &rt2, &pair, &load)) 3429 { 3430 /* Any SIMD memory op is independent of the subsequent MLA 3431 by definition of the erratum. */ 3432 if (AARCH64_BIT (insn_1, 26)) 3433 return TRUE; 3434 3435 /* If not SIMD, check for integer memory ops and MLA relationship. */ 3436 rn = AARCH64_RN (insn_2); 3437 ra = AARCH64_RA (insn_2); 3438 rm = AARCH64_RM (insn_2); 3439 3440 /* If this is a load and there's a true(RAW) dependency, we are safe 3441 and this is not an erratum sequence. */ 3442 if (load && 3443 (rt == rn || rt == rm || rt == ra 3444 || (pair && (rt2 == rn || rt2 == rm || rt2 == ra)))) 3445 return FALSE; 3446 3447 /* We conservatively put out stubs for all other cases (including 3448 writebacks). */ 3449 return TRUE; 3450 } 3451 3452 return FALSE; 3453} 3454 3455/* Used to order a list of mapping symbols by address. */ 3456 3457static int 3458elf_aarch64_compare_mapping (const void *a, const void *b) 3459{ 3460 const elf_aarch64_section_map *amap = (const elf_aarch64_section_map *) a; 3461 const elf_aarch64_section_map *bmap = (const elf_aarch64_section_map *) b; 3462 3463 if (amap->vma > bmap->vma) 3464 return 1; 3465 else if (amap->vma < bmap->vma) 3466 return -1; 3467 else if (amap->type > bmap->type) 3468 /* Ensure results do not depend on the host qsort for objects with 3469 multiple mapping symbols at the same address by sorting on type 3470 after vma. */ 3471 return 1; 3472 else if (amap->type < bmap->type) 3473 return -1; 3474 else 3475 return 0; 3476} 3477 3478 3479static char * 3480_bfd_aarch64_erratum_835769_stub_name (unsigned num_fixes) 3481{ 3482 char *stub_name = (char *) bfd_malloc 3483 (strlen ("__erratum_835769_veneer_") + 16); 3484 sprintf (stub_name,"__erratum_835769_veneer_%d", num_fixes); 3485 return stub_name; 3486} 3487 3488/* Scan for Cortex-A53 erratum 835769 sequence. 3489 3490 Return TRUE else FALSE on abnormal termination. */ 3491 3492static bfd_boolean 3493_bfd_aarch64_erratum_835769_scan (bfd *input_bfd, 3494 struct bfd_link_info *info, 3495 unsigned int *num_fixes_p) 3496{ 3497 asection *section; 3498 struct elf_aarch64_link_hash_table *htab = elf_aarch64_hash_table (info); 3499 unsigned int num_fixes = *num_fixes_p; 3500 3501 if (htab == NULL) 3502 return TRUE; 3503 3504 for (section = input_bfd->sections; 3505 section != NULL; 3506 section = section->next) 3507 { 3508 bfd_byte *contents = NULL; 3509 struct _aarch64_elf_section_data *sec_data; 3510 unsigned int span; 3511 3512 if (elf_section_type (section) != SHT_PROGBITS 3513 || (elf_section_flags (section) & SHF_EXECINSTR) == 0 3514 || (section->flags & SEC_EXCLUDE) != 0 3515 || (section->sec_info_type == SEC_INFO_TYPE_JUST_SYMS) 3516 || (section->output_section == bfd_abs_section_ptr)) 3517 continue; 3518 3519 if (elf_section_data (section)->this_hdr.contents != NULL) 3520 contents = elf_section_data (section)->this_hdr.contents; 3521 else if (! bfd_malloc_and_get_section (input_bfd, section, &contents)) 3522 return FALSE; 3523 3524 sec_data = elf_aarch64_section_data (section); 3525 3526 qsort (sec_data->map, sec_data->mapcount, 3527 sizeof (elf_aarch64_section_map), elf_aarch64_compare_mapping); 3528 3529 for (span = 0; span < sec_data->mapcount; span++) 3530 { 3531 unsigned int span_start = sec_data->map[span].vma; 3532 unsigned int span_end = ((span == sec_data->mapcount - 1) 3533 ? sec_data->map[0].vma + section->size 3534 : sec_data->map[span + 1].vma); 3535 unsigned int i; 3536 char span_type = sec_data->map[span].type; 3537 3538 if (span_type == 'd') 3539 continue; 3540 3541 for (i = span_start; i + 4 < span_end; i += 4) 3542 { 3543 uint32_t insn_1 = bfd_getl32 (contents + i); 3544 uint32_t insn_2 = bfd_getl32 (contents + i + 4); 3545 3546 if (aarch64_erratum_sequence (insn_1, insn_2)) 3547 { 3548 struct elf_aarch64_stub_hash_entry *stub_entry; 3549 char *stub_name = _bfd_aarch64_erratum_835769_stub_name (num_fixes); 3550 if (! stub_name) 3551 return FALSE; 3552 3553 stub_entry = _bfd_aarch64_add_stub_entry_in_group (stub_name, 3554 section, 3555 htab); 3556 if (! stub_entry) 3557 return FALSE; 3558 3559 stub_entry->stub_type = aarch64_stub_erratum_835769_veneer; 3560 stub_entry->target_section = section; 3561 stub_entry->target_value = i + 4; 3562 stub_entry->veneered_insn = insn_2; 3563 stub_entry->output_name = stub_name; 3564 num_fixes++; 3565 } 3566 } 3567 } 3568 if (elf_section_data (section)->this_hdr.contents == NULL) 3569 free (contents); 3570 } 3571 3572 *num_fixes_p = num_fixes; 3573 3574 return TRUE; 3575} 3576 3577 3578/* Test if instruction INSN is ADRP. */ 3579 3580static bfd_boolean 3581_bfd_aarch64_adrp_p (uint32_t insn) 3582{ 3583 return ((insn & 0x9f000000) == 0x90000000); 3584} 3585 3586 3587/* Helper predicate to look for cortex-a53 erratum 843419 sequence 1. */ 3588 3589static bfd_boolean 3590_bfd_aarch64_erratum_843419_sequence_p (uint32_t insn_1, uint32_t insn_2, 3591 uint32_t insn_3) 3592{ 3593 uint32_t rt; 3594 uint32_t rt2; 3595 bfd_boolean pair; 3596 bfd_boolean load; 3597 3598 return (aarch64_mem_op_p (insn_2, &rt, &rt2, &pair, &load) 3599 && (!pair 3600 || (pair && !load)) 3601 && AARCH64_LDST_UIMM (insn_3) 3602 && AARCH64_RN (insn_3) == AARCH64_RD (insn_1)); 3603} 3604 3605 3606/* Test for the presence of Cortex-A53 erratum 843419 instruction sequence. 3607 3608 Return TRUE if section CONTENTS at offset I contains one of the 3609 erratum 843419 sequences, otherwise return FALSE. If a sequence is 3610 seen set P_VENEER_I to the offset of the final LOAD/STORE 3611 instruction in the sequence. 3612 */ 3613 3614static bfd_boolean 3615_bfd_aarch64_erratum_843419_p (bfd_byte *contents, bfd_vma vma, 3616 bfd_vma i, bfd_vma span_end, 3617 bfd_vma *p_veneer_i) 3618{ 3619 uint32_t insn_1 = bfd_getl32 (contents + i); 3620 3621 if (!_bfd_aarch64_adrp_p (insn_1)) 3622 return FALSE; 3623 3624 if (span_end < i + 12) 3625 return FALSE; 3626 3627 uint32_t insn_2 = bfd_getl32 (contents + i + 4); 3628 uint32_t insn_3 = bfd_getl32 (contents + i + 8); 3629 3630 if ((vma & 0xfff) != 0xff8 && (vma & 0xfff) != 0xffc) 3631 return FALSE; 3632 3633 if (_bfd_aarch64_erratum_843419_sequence_p (insn_1, insn_2, insn_3)) 3634 { 3635 *p_veneer_i = i + 8; 3636 return TRUE; 3637 } 3638 3639 if (span_end < i + 16) 3640 return FALSE; 3641 3642 uint32_t insn_4 = bfd_getl32 (contents + i + 12); 3643 3644 if (_bfd_aarch64_erratum_843419_sequence_p (insn_1, insn_2, insn_4)) 3645 { 3646 *p_veneer_i = i + 12; 3647 return TRUE; 3648 } 3649 3650 return FALSE; 3651} 3652 3653 3654/* Resize all stub sections. */ 3655 3656static void 3657_bfd_aarch64_resize_stubs (struct elf_aarch64_link_hash_table *htab) 3658{ 3659 asection *section; 3660 3661 /* OK, we've added some stubs. Find out the new size of the 3662 stub sections. */ 3663 for (section = htab->stub_bfd->sections; 3664 section != NULL; section = section->next) 3665 { 3666 /* Ignore non-stub sections. */ 3667 if (!strstr (section->name, STUB_SUFFIX)) 3668 continue; 3669 section->size = 0; 3670 } 3671 3672 bfd_hash_traverse (&htab->stub_hash_table, aarch64_size_one_stub, htab); 3673 3674 for (section = htab->stub_bfd->sections; 3675 section != NULL; section = section->next) 3676 { 3677 if (!strstr (section->name, STUB_SUFFIX)) 3678 continue; 3679 3680 if (section->size) 3681 section->size += 4; 3682 3683 /* Ensure all stub sections have a size which is a multiple of 3684 4096. This is important in order to ensure that the insertion 3685 of stub sections does not in itself move existing code around 3686 in such a way that new errata sequences are created. */ 3687 if (htab->fix_erratum_843419) 3688 if (section->size) 3689 section->size = BFD_ALIGN (section->size, 0x1000); 3690 } 3691} 3692 3693 3694/* Construct an erratum 843419 workaround stub name. 3695 */ 3696 3697static char * 3698_bfd_aarch64_erratum_843419_stub_name (asection *input_section, 3699 bfd_vma offset) 3700{ 3701 const bfd_size_type len = 8 + 4 + 1 + 8 + 1 + 16 + 1; 3702 char *stub_name = bfd_malloc (len); 3703 3704 if (stub_name != NULL) 3705 snprintf (stub_name, len, "e843419@%04x_%08x_%" BFD_VMA_FMT "x", 3706 input_section->owner->id, 3707 input_section->id, 3708 offset); 3709 return stub_name; 3710} 3711 3712/* Build a stub_entry structure describing an 843419 fixup. 3713 3714 The stub_entry constructed is populated with the bit pattern INSN 3715 of the instruction located at OFFSET within input SECTION. 3716 3717 Returns TRUE on success. */ 3718 3719static bfd_boolean 3720_bfd_aarch64_erratum_843419_fixup (uint32_t insn, 3721 bfd_vma adrp_offset, 3722 bfd_vma ldst_offset, 3723 asection *section, 3724 struct bfd_link_info *info) 3725{ 3726 struct elf_aarch64_link_hash_table *htab = elf_aarch64_hash_table (info); 3727 char *stub_name; 3728 struct elf_aarch64_stub_hash_entry *stub_entry; 3729 3730 stub_name = _bfd_aarch64_erratum_843419_stub_name (section, ldst_offset); 3731 stub_entry = aarch64_stub_hash_lookup (&htab->stub_hash_table, stub_name, 3732 FALSE, FALSE); 3733 if (stub_entry) 3734 { 3735 free (stub_name); 3736 return TRUE; 3737 } 3738 3739 /* We always place an 843419 workaround veneer in the stub section 3740 attached to the input section in which an erratum sequence has 3741 been found. This ensures that later in the link process (in 3742 elfNN_aarch64_write_section) when we copy the veneered 3743 instruction from the input section into the stub section the 3744 copied instruction will have had any relocations applied to it. 3745 If we placed workaround veneers in any other stub section then we 3746 could not assume that all relocations have been processed on the 3747 corresponding input section at the point we output the stub 3748 section. 3749 */ 3750 3751 stub_entry = _bfd_aarch64_add_stub_entry_after (stub_name, section, htab); 3752 if (stub_entry == NULL) 3753 { 3754 free (stub_name); 3755 return FALSE; 3756 } 3757 3758 stub_entry->adrp_offset = adrp_offset; 3759 stub_entry->target_value = ldst_offset; 3760 stub_entry->target_section = section; 3761 stub_entry->stub_type = aarch64_stub_erratum_843419_veneer; 3762 stub_entry->veneered_insn = insn; 3763 stub_entry->output_name = stub_name; 3764 3765 return TRUE; 3766} 3767 3768 3769/* Scan an input section looking for the signature of erratum 843419. 3770 3771 Scans input SECTION in INPUT_BFD looking for erratum 843419 3772 signatures, for each signature found a stub_entry is created 3773 describing the location of the erratum for subsequent fixup. 3774 3775 Return TRUE on successful scan, FALSE on failure to scan. 3776 */ 3777 3778static bfd_boolean 3779_bfd_aarch64_erratum_843419_scan (bfd *input_bfd, asection *section, 3780 struct bfd_link_info *info) 3781{ 3782 struct elf_aarch64_link_hash_table *htab = elf_aarch64_hash_table (info); 3783 3784 if (htab == NULL) 3785 return TRUE; 3786 3787 if (elf_section_type (section) != SHT_PROGBITS 3788 || (elf_section_flags (section) & SHF_EXECINSTR) == 0 3789 || (section->flags & SEC_EXCLUDE) != 0 3790 || (section->sec_info_type == SEC_INFO_TYPE_JUST_SYMS) 3791 || (section->output_section == bfd_abs_section_ptr)) 3792 return TRUE; 3793 3794 do 3795 { 3796 bfd_byte *contents = NULL; 3797 struct _aarch64_elf_section_data *sec_data; 3798 unsigned int span; 3799 3800 if (elf_section_data (section)->this_hdr.contents != NULL) 3801 contents = elf_section_data (section)->this_hdr.contents; 3802 else if (! bfd_malloc_and_get_section (input_bfd, section, &contents)) 3803 return FALSE; 3804 3805 sec_data = elf_aarch64_section_data (section); 3806 3807 qsort (sec_data->map, sec_data->mapcount, 3808 sizeof (elf_aarch64_section_map), elf_aarch64_compare_mapping); 3809 3810 for (span = 0; span < sec_data->mapcount; span++) 3811 { 3812 unsigned int span_start = sec_data->map[span].vma; 3813 unsigned int span_end = ((span == sec_data->mapcount - 1) 3814 ? sec_data->map[0].vma + section->size 3815 : sec_data->map[span + 1].vma); 3816 unsigned int i; 3817 char span_type = sec_data->map[span].type; 3818 3819 if (span_type == 'd') 3820 continue; 3821 3822 for (i = span_start; i + 8 < span_end; i += 4) 3823 { 3824 bfd_vma vma = (section->output_section->vma 3825 + section->output_offset 3826 + i); 3827 bfd_vma veneer_i; 3828 3829 if (_bfd_aarch64_erratum_843419_p 3830 (contents, vma, i, span_end, &veneer_i)) 3831 { 3832 uint32_t insn = bfd_getl32 (contents + veneer_i); 3833 3834 if (!_bfd_aarch64_erratum_843419_fixup (insn, i, veneer_i, 3835 section, info)) 3836 return FALSE; 3837 } 3838 } 3839 } 3840 3841 if (elf_section_data (section)->this_hdr.contents == NULL) 3842 free (contents); 3843 } 3844 while (0); 3845 3846 return TRUE; 3847} 3848 3849 3850/* Determine and set the size of the stub section for a final link. 3851 3852 The basic idea here is to examine all the relocations looking for 3853 PC-relative calls to a target that is unreachable with a "bl" 3854 instruction. */ 3855 3856bfd_boolean 3857elfNN_aarch64_size_stubs (bfd *output_bfd, 3858 bfd *stub_bfd, 3859 struct bfd_link_info *info, 3860 bfd_signed_vma group_size, 3861 asection * (*add_stub_section) (const char *, 3862 asection *), 3863 void (*layout_sections_again) (void)) 3864{ 3865 bfd_size_type stub_group_size; 3866 bfd_boolean stubs_always_before_branch; 3867 bfd_boolean stub_changed = FALSE; 3868 struct elf_aarch64_link_hash_table *htab = elf_aarch64_hash_table (info); 3869 unsigned int num_erratum_835769_fixes = 0; 3870 3871 /* Propagate mach to stub bfd, because it may not have been 3872 finalized when we created stub_bfd. */ 3873 bfd_set_arch_mach (stub_bfd, bfd_get_arch (output_bfd), 3874 bfd_get_mach (output_bfd)); 3875 3876 /* Stash our params away. */ 3877 htab->stub_bfd = stub_bfd; 3878 htab->add_stub_section = add_stub_section; 3879 htab->layout_sections_again = layout_sections_again; 3880 stubs_always_before_branch = group_size < 0; 3881 if (group_size < 0) 3882 stub_group_size = -group_size; 3883 else 3884 stub_group_size = group_size; 3885 3886 if (stub_group_size == 1) 3887 { 3888 /* Default values. */ 3889 /* AArch64 branch range is +-128MB. The value used is 1MB less. */ 3890 stub_group_size = 127 * 1024 * 1024; 3891 } 3892 3893 group_sections (htab, stub_group_size, stubs_always_before_branch); 3894 3895 (*htab->layout_sections_again) (); 3896 3897 if (htab->fix_erratum_835769) 3898 { 3899 bfd *input_bfd; 3900 3901 for (input_bfd = info->input_bfds; 3902 input_bfd != NULL; input_bfd = input_bfd->link.next) 3903 if (!_bfd_aarch64_erratum_835769_scan (input_bfd, info, 3904 &num_erratum_835769_fixes)) 3905 return FALSE; 3906 3907 _bfd_aarch64_resize_stubs (htab); 3908 (*htab->layout_sections_again) (); 3909 } 3910 3911 if (htab->fix_erratum_843419) 3912 { 3913 bfd *input_bfd; 3914 3915 for (input_bfd = info->input_bfds; 3916 input_bfd != NULL; 3917 input_bfd = input_bfd->link.next) 3918 { 3919 asection *section; 3920 3921 for (section = input_bfd->sections; 3922 section != NULL; 3923 section = section->next) 3924 if (!_bfd_aarch64_erratum_843419_scan (input_bfd, section, info)) 3925 return FALSE; 3926 } 3927 3928 _bfd_aarch64_resize_stubs (htab); 3929 (*htab->layout_sections_again) (); 3930 } 3931 3932 while (1) 3933 { 3934 bfd *input_bfd; 3935 3936 for (input_bfd = info->input_bfds; 3937 input_bfd != NULL; input_bfd = input_bfd->link.next) 3938 { 3939 Elf_Internal_Shdr *symtab_hdr; 3940 asection *section; 3941 Elf_Internal_Sym *local_syms = NULL; 3942 3943 /* We'll need the symbol table in a second. */ 3944 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 3945 if (symtab_hdr->sh_info == 0) 3946 continue; 3947 3948 /* Walk over each section attached to the input bfd. */ 3949 for (section = input_bfd->sections; 3950 section != NULL; section = section->next) 3951 { 3952 Elf_Internal_Rela *internal_relocs, *irelaend, *irela; 3953 3954 /* If there aren't any relocs, then there's nothing more 3955 to do. */ 3956 if ((section->flags & SEC_RELOC) == 0 3957 || section->reloc_count == 0 3958 || (section->flags & SEC_CODE) == 0) 3959 continue; 3960 3961 /* If this section is a link-once section that will be 3962 discarded, then don't create any stubs. */ 3963 if (section->output_section == NULL 3964 || section->output_section->owner != output_bfd) 3965 continue; 3966 3967 /* Get the relocs. */ 3968 internal_relocs 3969 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, 3970 NULL, info->keep_memory); 3971 if (internal_relocs == NULL) 3972 goto error_ret_free_local; 3973 3974 /* Now examine each relocation. */ 3975 irela = internal_relocs; 3976 irelaend = irela + section->reloc_count; 3977 for (; irela < irelaend; irela++) 3978 { 3979 unsigned int r_type, r_indx; 3980 enum elf_aarch64_stub_type stub_type; 3981 struct elf_aarch64_stub_hash_entry *stub_entry; 3982 asection *sym_sec; 3983 bfd_vma sym_value; 3984 bfd_vma destination; 3985 struct elf_aarch64_link_hash_entry *hash; 3986 const char *sym_name; 3987 char *stub_name; 3988 const asection *id_sec; 3989 unsigned char st_type; 3990 bfd_size_type len; 3991 3992 r_type = ELFNN_R_TYPE (irela->r_info); 3993 r_indx = ELFNN_R_SYM (irela->r_info); 3994 3995 if (r_type >= (unsigned int) R_AARCH64_end) 3996 { 3997 bfd_set_error (bfd_error_bad_value); 3998 error_ret_free_internal: 3999 if (elf_section_data (section)->relocs == NULL) 4000 free (internal_relocs); 4001 goto error_ret_free_local; 4002 } 4003 4004 /* Only look for stubs on unconditional branch and 4005 branch and link instructions. */ 4006 if (r_type != (unsigned int) AARCH64_R (CALL26) 4007 && r_type != (unsigned int) AARCH64_R (JUMP26)) 4008 continue; 4009 4010 /* Now determine the call target, its name, value, 4011 section. */ 4012 sym_sec = NULL; 4013 sym_value = 0; 4014 destination = 0; 4015 hash = NULL; 4016 sym_name = NULL; 4017 if (r_indx < symtab_hdr->sh_info) 4018 { 4019 /* It's a local symbol. */ 4020 Elf_Internal_Sym *sym; 4021 Elf_Internal_Shdr *hdr; 4022 4023 if (local_syms == NULL) 4024 { 4025 local_syms 4026 = (Elf_Internal_Sym *) symtab_hdr->contents; 4027 if (local_syms == NULL) 4028 local_syms 4029 = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, 4030 symtab_hdr->sh_info, 0, 4031 NULL, NULL, NULL); 4032 if (local_syms == NULL) 4033 goto error_ret_free_internal; 4034 } 4035 4036 sym = local_syms + r_indx; 4037 hdr = elf_elfsections (input_bfd)[sym->st_shndx]; 4038 sym_sec = hdr->bfd_section; 4039 if (!sym_sec) 4040 /* This is an undefined symbol. It can never 4041 be resolved. */ 4042 continue; 4043 4044 if (ELF_ST_TYPE (sym->st_info) != STT_SECTION) 4045 sym_value = sym->st_value; 4046 destination = (sym_value + irela->r_addend 4047 + sym_sec->output_offset 4048 + sym_sec->output_section->vma); 4049 st_type = ELF_ST_TYPE (sym->st_info); 4050 sym_name 4051 = bfd_elf_string_from_elf_section (input_bfd, 4052 symtab_hdr->sh_link, 4053 sym->st_name); 4054 } 4055 else 4056 { 4057 int e_indx; 4058 4059 e_indx = r_indx - symtab_hdr->sh_info; 4060 hash = ((struct elf_aarch64_link_hash_entry *) 4061 elf_sym_hashes (input_bfd)[e_indx]); 4062 4063 while (hash->root.root.type == bfd_link_hash_indirect 4064 || hash->root.root.type == bfd_link_hash_warning) 4065 hash = ((struct elf_aarch64_link_hash_entry *) 4066 hash->root.root.u.i.link); 4067 4068 if (hash->root.root.type == bfd_link_hash_defined 4069 || hash->root.root.type == bfd_link_hash_defweak) 4070 { 4071 struct elf_aarch64_link_hash_table *globals = 4072 elf_aarch64_hash_table (info); 4073 sym_sec = hash->root.root.u.def.section; 4074 sym_value = hash->root.root.u.def.value; 4075 /* For a destination in a shared library, 4076 use the PLT stub as target address to 4077 decide whether a branch stub is 4078 needed. */ 4079 if (globals->root.splt != NULL && hash != NULL 4080 && hash->root.plt.offset != (bfd_vma) - 1) 4081 { 4082 sym_sec = globals->root.splt; 4083 sym_value = hash->root.plt.offset; 4084 if (sym_sec->output_section != NULL) 4085 destination = (sym_value 4086 + sym_sec->output_offset 4087 + 4088 sym_sec->output_section->vma); 4089 } 4090 else if (sym_sec->output_section != NULL) 4091 destination = (sym_value + irela->r_addend 4092 + sym_sec->output_offset 4093 + sym_sec->output_section->vma); 4094 } 4095 else if (hash->root.root.type == bfd_link_hash_undefined 4096 || (hash->root.root.type 4097 == bfd_link_hash_undefweak)) 4098 { 4099 /* For a shared library, use the PLT stub as 4100 target address to decide whether a long 4101 branch stub is needed. 4102 For absolute code, they cannot be handled. */ 4103 struct elf_aarch64_link_hash_table *globals = 4104 elf_aarch64_hash_table (info); 4105 4106 if (globals->root.splt != NULL && hash != NULL 4107 && hash->root.plt.offset != (bfd_vma) - 1) 4108 { 4109 sym_sec = globals->root.splt; 4110 sym_value = hash->root.plt.offset; 4111 if (sym_sec->output_section != NULL) 4112 destination = (sym_value 4113 + sym_sec->output_offset 4114 + 4115 sym_sec->output_section->vma); 4116 } 4117 else 4118 continue; 4119 } 4120 else 4121 { 4122 bfd_set_error (bfd_error_bad_value); 4123 goto error_ret_free_internal; 4124 } 4125 st_type = ELF_ST_TYPE (hash->root.type); 4126 sym_name = hash->root.root.root.string; 4127 } 4128 4129 /* Determine what (if any) linker stub is needed. */ 4130 stub_type = aarch64_type_of_stub (section, irela, sym_sec, 4131 st_type, destination); 4132 if (stub_type == aarch64_stub_none) 4133 continue; 4134 4135 /* Support for grouping stub sections. */ 4136 id_sec = htab->stub_group[section->id].link_sec; 4137 4138 /* Get the name of this stub. */ 4139 stub_name = elfNN_aarch64_stub_name (id_sec, sym_sec, hash, 4140 irela); 4141 if (!stub_name) 4142 goto error_ret_free_internal; 4143 4144 stub_entry = 4145 aarch64_stub_hash_lookup (&htab->stub_hash_table, 4146 stub_name, FALSE, FALSE); 4147 if (stub_entry != NULL) 4148 { 4149 /* The proper stub has already been created. */ 4150 free (stub_name); 4151 continue; 4152 } 4153 4154 stub_entry = _bfd_aarch64_add_stub_entry_in_group 4155 (stub_name, section, htab); 4156 if (stub_entry == NULL) 4157 { 4158 free (stub_name); 4159 goto error_ret_free_internal; 4160 } 4161 4162 stub_entry->target_value = sym_value + irela->r_addend; 4163 stub_entry->target_section = sym_sec; 4164 stub_entry->stub_type = stub_type; 4165 stub_entry->h = hash; 4166 stub_entry->st_type = st_type; 4167 4168 if (sym_name == NULL) 4169 sym_name = "unnamed"; 4170 len = sizeof (STUB_ENTRY_NAME) + strlen (sym_name); 4171 stub_entry->output_name = bfd_alloc (htab->stub_bfd, len); 4172 if (stub_entry->output_name == NULL) 4173 { 4174 free (stub_name); 4175 goto error_ret_free_internal; 4176 } 4177 4178 snprintf (stub_entry->output_name, len, STUB_ENTRY_NAME, 4179 sym_name); 4180 4181 stub_changed = TRUE; 4182 } 4183 4184 /* We're done with the internal relocs, free them. */ 4185 if (elf_section_data (section)->relocs == NULL) 4186 free (internal_relocs); 4187 } 4188 } 4189 4190 if (!stub_changed) 4191 break; 4192 4193 _bfd_aarch64_resize_stubs (htab); 4194 4195 /* Ask the linker to do its stuff. */ 4196 (*htab->layout_sections_again) (); 4197 stub_changed = FALSE; 4198 } 4199 4200 return TRUE; 4201 4202error_ret_free_local: 4203 return FALSE; 4204} 4205 4206/* Build all the stubs associated with the current output file. The 4207 stubs are kept in a hash table attached to the main linker hash 4208 table. We also set up the .plt entries for statically linked PIC 4209 functions here. This function is called via aarch64_elf_finish in the 4210 linker. */ 4211 4212bfd_boolean 4213elfNN_aarch64_build_stubs (struct bfd_link_info *info) 4214{ 4215 asection *stub_sec; 4216 struct bfd_hash_table *table; 4217 struct elf_aarch64_link_hash_table *htab; 4218 4219 htab = elf_aarch64_hash_table (info); 4220 4221 for (stub_sec = htab->stub_bfd->sections; 4222 stub_sec != NULL; stub_sec = stub_sec->next) 4223 { 4224 bfd_size_type size; 4225 4226 /* Ignore non-stub sections. */ 4227 if (!strstr (stub_sec->name, STUB_SUFFIX)) 4228 continue; 4229 4230 /* Allocate memory to hold the linker stubs. */ 4231 size = stub_sec->size; 4232 stub_sec->contents = bfd_zalloc (htab->stub_bfd, size); 4233 if (stub_sec->contents == NULL && size != 0) 4234 return FALSE; 4235 stub_sec->size = 0; 4236 4237 bfd_putl32 (0x14000000 | (size >> 2), stub_sec->contents); 4238 stub_sec->size += 4; 4239 } 4240 4241 /* Build the stubs as directed by the stub hash table. */ 4242 table = &htab->stub_hash_table; 4243 bfd_hash_traverse (table, aarch64_build_one_stub, info); 4244 4245 return TRUE; 4246} 4247 4248 4249/* Add an entry to the code/data map for section SEC. */ 4250 4251static void 4252elfNN_aarch64_section_map_add (asection *sec, char type, bfd_vma vma) 4253{ 4254 struct _aarch64_elf_section_data *sec_data = 4255 elf_aarch64_section_data (sec); 4256 unsigned int newidx; 4257 4258 if (sec_data->map == NULL) 4259 { 4260 sec_data->map = bfd_malloc (sizeof (elf_aarch64_section_map)); 4261 sec_data->mapcount = 0; 4262 sec_data->mapsize = 1; 4263 } 4264 4265 newidx = sec_data->mapcount++; 4266 4267 if (sec_data->mapcount > sec_data->mapsize) 4268 { 4269 sec_data->mapsize *= 2; 4270 sec_data->map = bfd_realloc_or_free 4271 (sec_data->map, sec_data->mapsize * sizeof (elf_aarch64_section_map)); 4272 } 4273 4274 if (sec_data->map) 4275 { 4276 sec_data->map[newidx].vma = vma; 4277 sec_data->map[newidx].type = type; 4278 } 4279} 4280 4281 4282/* Initialise maps of insn/data for input BFDs. */ 4283void 4284bfd_elfNN_aarch64_init_maps (bfd *abfd) 4285{ 4286 Elf_Internal_Sym *isymbuf; 4287 Elf_Internal_Shdr *hdr; 4288 unsigned int i, localsyms; 4289 4290 /* Make sure that we are dealing with an AArch64 elf binary. */ 4291 if (!is_aarch64_elf (abfd)) 4292 return; 4293 4294 if ((abfd->flags & DYNAMIC) != 0) 4295 return; 4296 4297 hdr = &elf_symtab_hdr (abfd); 4298 localsyms = hdr->sh_info; 4299 4300 /* Obtain a buffer full of symbols for this BFD. The hdr->sh_info field 4301 should contain the number of local symbols, which should come before any 4302 global symbols. Mapping symbols are always local. */ 4303 isymbuf = bfd_elf_get_elf_syms (abfd, hdr, localsyms, 0, NULL, NULL, NULL); 4304 4305 /* No internal symbols read? Skip this BFD. */ 4306 if (isymbuf == NULL) 4307 return; 4308 4309 for (i = 0; i < localsyms; i++) 4310 { 4311 Elf_Internal_Sym *isym = &isymbuf[i]; 4312 asection *sec = bfd_section_from_elf_index (abfd, isym->st_shndx); 4313 const char *name; 4314 4315 if (sec != NULL && ELF_ST_BIND (isym->st_info) == STB_LOCAL) 4316 { 4317 name = bfd_elf_string_from_elf_section (abfd, 4318 hdr->sh_link, 4319 isym->st_name); 4320 4321 if (bfd_is_aarch64_special_symbol_name 4322 (name, BFD_AARCH64_SPECIAL_SYM_TYPE_MAP)) 4323 elfNN_aarch64_section_map_add (sec, name[1], isym->st_value); 4324 } 4325 } 4326} 4327 4328/* Set option values needed during linking. */ 4329void 4330bfd_elfNN_aarch64_set_options (struct bfd *output_bfd, 4331 struct bfd_link_info *link_info, 4332 int no_enum_warn, 4333 int no_wchar_warn, int pic_veneer, 4334 int fix_erratum_835769, 4335 int fix_erratum_843419, 4336 int no_apply_dynamic_relocs) 4337{ 4338 struct elf_aarch64_link_hash_table *globals; 4339 4340 globals = elf_aarch64_hash_table (link_info); 4341 globals->pic_veneer = pic_veneer; 4342 globals->fix_erratum_835769 = fix_erratum_835769; 4343 globals->fix_erratum_843419 = fix_erratum_843419; 4344 globals->fix_erratum_843419_adr = TRUE; 4345 globals->no_apply_dynamic_relocs = no_apply_dynamic_relocs; 4346 4347 BFD_ASSERT (is_aarch64_elf (output_bfd)); 4348 elf_aarch64_tdata (output_bfd)->no_enum_size_warning = no_enum_warn; 4349 elf_aarch64_tdata (output_bfd)->no_wchar_size_warning = no_wchar_warn; 4350} 4351 4352static bfd_vma 4353aarch64_calculate_got_entry_vma (struct elf_link_hash_entry *h, 4354 struct elf_aarch64_link_hash_table 4355 *globals, struct bfd_link_info *info, 4356 bfd_vma value, bfd *output_bfd, 4357 bfd_boolean *unresolved_reloc_p) 4358{ 4359 bfd_vma off = (bfd_vma) - 1; 4360 asection *basegot = globals->root.sgot; 4361 bfd_boolean dyn = globals->root.dynamic_sections_created; 4362 4363 if (h != NULL) 4364 { 4365 BFD_ASSERT (basegot != NULL); 4366 off = h->got.offset; 4367 BFD_ASSERT (off != (bfd_vma) - 1); 4368 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h) 4369 || (bfd_link_pic (info) 4370 && SYMBOL_REFERENCES_LOCAL (info, h)) 4371 || (ELF_ST_VISIBILITY (h->other) 4372 && h->root.type == bfd_link_hash_undefweak)) 4373 { 4374 /* This is actually a static link, or it is a -Bsymbolic link 4375 and the symbol is defined locally. We must initialize this 4376 entry in the global offset table. Since the offset must 4377 always be a multiple of 8 (4 in the case of ILP32), we use 4378 the least significant bit to record whether we have 4379 initialized it already. 4380 When doing a dynamic link, we create a .rel(a).got relocation 4381 entry to initialize the value. This is done in the 4382 finish_dynamic_symbol routine. */ 4383 if ((off & 1) != 0) 4384 off &= ~1; 4385 else 4386 { 4387 bfd_put_NN (output_bfd, value, basegot->contents + off); 4388 h->got.offset |= 1; 4389 } 4390 } 4391 else 4392 *unresolved_reloc_p = FALSE; 4393 4394 off = off + basegot->output_section->vma + basegot->output_offset; 4395 } 4396 4397 return off; 4398} 4399 4400/* Change R_TYPE to a more efficient access model where possible, 4401 return the new reloc type. */ 4402 4403static bfd_reloc_code_real_type 4404aarch64_tls_transition_without_check (bfd_reloc_code_real_type r_type, 4405 struct elf_link_hash_entry *h) 4406{ 4407 bfd_boolean is_local = h == NULL; 4408 4409 switch (r_type) 4410 { 4411 case BFD_RELOC_AARCH64_TLSDESC_ADR_PAGE21: 4412 case BFD_RELOC_AARCH64_TLSGD_ADR_PAGE21: 4413 return (is_local 4414 ? BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G1 4415 : BFD_RELOC_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21); 4416 4417 case BFD_RELOC_AARCH64_TLSDESC_ADR_PREL21: 4418 return (is_local 4419 ? BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G0_NC 4420 : r_type); 4421 4422 case BFD_RELOC_AARCH64_TLSDESC_LD_PREL19: 4423 return (is_local 4424 ? BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G1 4425 : BFD_RELOC_AARCH64_TLSIE_LD_GOTTPREL_PREL19); 4426 4427 case BFD_RELOC_AARCH64_TLSDESC_LDR: 4428 return (is_local 4429 ? BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G0_NC 4430 : BFD_RELOC_AARCH64_NONE); 4431 4432 case BFD_RELOC_AARCH64_TLSDESC_OFF_G0_NC: 4433 return (is_local 4434 ? BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G1_NC 4435 : BFD_RELOC_AARCH64_TLSIE_MOVW_GOTTPREL_G0_NC); 4436 4437 case BFD_RELOC_AARCH64_TLSDESC_OFF_G1: 4438 return (is_local 4439 ? BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G2 4440 : BFD_RELOC_AARCH64_TLSIE_MOVW_GOTTPREL_G1); 4441 4442 case BFD_RELOC_AARCH64_TLSDESC_LDNN_LO12_NC: 4443 case BFD_RELOC_AARCH64_TLSGD_ADD_LO12_NC: 4444 return (is_local 4445 ? BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G0_NC 4446 : BFD_RELOC_AARCH64_TLSIE_LDNN_GOTTPREL_LO12_NC); 4447 4448 case BFD_RELOC_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21: 4449 return is_local ? BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G1 : r_type; 4450 4451 case BFD_RELOC_AARCH64_TLSIE_LDNN_GOTTPREL_LO12_NC: 4452 return is_local ? BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G0_NC : r_type; 4453 4454 case BFD_RELOC_AARCH64_TLSIE_LD_GOTTPREL_PREL19: 4455 return r_type; 4456 4457 case BFD_RELOC_AARCH64_TLSGD_ADR_PREL21: 4458 return (is_local 4459 ? BFD_RELOC_AARCH64_TLSLE_ADD_TPREL_HI12 4460 : BFD_RELOC_AARCH64_TLSIE_LD_GOTTPREL_PREL19); 4461 4462 case BFD_RELOC_AARCH64_TLSDESC_ADD: 4463 case BFD_RELOC_AARCH64_TLSDESC_ADD_LO12_NC: 4464 case BFD_RELOC_AARCH64_TLSDESC_CALL: 4465 /* Instructions with these relocations will become NOPs. */ 4466 return BFD_RELOC_AARCH64_NONE; 4467 4468 case BFD_RELOC_AARCH64_TLSLD_ADD_LO12_NC: 4469 case BFD_RELOC_AARCH64_TLSLD_ADR_PAGE21: 4470 case BFD_RELOC_AARCH64_TLSLD_ADR_PREL21: 4471 return is_local ? BFD_RELOC_AARCH64_NONE : r_type; 4472 4473#if ARCH_SIZE == 64 4474 case BFD_RELOC_AARCH64_TLSGD_MOVW_G0_NC: 4475 return is_local 4476 ? BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G1_NC 4477 : BFD_RELOC_AARCH64_TLSIE_MOVW_GOTTPREL_G0_NC; 4478 4479 case BFD_RELOC_AARCH64_TLSGD_MOVW_G1: 4480 return is_local 4481 ? BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G2 4482 : BFD_RELOC_AARCH64_TLSIE_MOVW_GOTTPREL_G1; 4483#endif 4484 4485 default: 4486 break; 4487 } 4488 4489 return r_type; 4490} 4491 4492static unsigned int 4493aarch64_reloc_got_type (bfd_reloc_code_real_type r_type) 4494{ 4495 switch (r_type) 4496 { 4497 case BFD_RELOC_AARCH64_ADR_GOT_PAGE: 4498 case BFD_RELOC_AARCH64_GOT_LD_PREL19: 4499 case BFD_RELOC_AARCH64_LD32_GOTPAGE_LO14: 4500 case BFD_RELOC_AARCH64_LD32_GOT_LO12_NC: 4501 case BFD_RELOC_AARCH64_LD64_GOTOFF_LO15: 4502 case BFD_RELOC_AARCH64_LD64_GOTPAGE_LO15: 4503 case BFD_RELOC_AARCH64_LD64_GOT_LO12_NC: 4504 case BFD_RELOC_AARCH64_MOVW_GOTOFF_G0_NC: 4505 case BFD_RELOC_AARCH64_MOVW_GOTOFF_G1: 4506 return GOT_NORMAL; 4507 4508 case BFD_RELOC_AARCH64_TLSGD_ADD_LO12_NC: 4509 case BFD_RELOC_AARCH64_TLSGD_ADR_PAGE21: 4510 case BFD_RELOC_AARCH64_TLSGD_ADR_PREL21: 4511 case BFD_RELOC_AARCH64_TLSGD_MOVW_G0_NC: 4512 case BFD_RELOC_AARCH64_TLSGD_MOVW_G1: 4513 case BFD_RELOC_AARCH64_TLSLD_ADD_LO12_NC: 4514 case BFD_RELOC_AARCH64_TLSLD_ADR_PAGE21: 4515 case BFD_RELOC_AARCH64_TLSLD_ADR_PREL21: 4516 return GOT_TLS_GD; 4517 4518 case BFD_RELOC_AARCH64_TLSDESC_ADD: 4519 case BFD_RELOC_AARCH64_TLSDESC_ADD_LO12_NC: 4520 case BFD_RELOC_AARCH64_TLSDESC_ADR_PAGE21: 4521 case BFD_RELOC_AARCH64_TLSDESC_ADR_PREL21: 4522 case BFD_RELOC_AARCH64_TLSDESC_CALL: 4523 case BFD_RELOC_AARCH64_TLSDESC_LD32_LO12_NC: 4524 case BFD_RELOC_AARCH64_TLSDESC_LD64_LO12_NC: 4525 case BFD_RELOC_AARCH64_TLSDESC_LD_PREL19: 4526 case BFD_RELOC_AARCH64_TLSDESC_LDR: 4527 case BFD_RELOC_AARCH64_TLSDESC_OFF_G0_NC: 4528 case BFD_RELOC_AARCH64_TLSDESC_OFF_G1: 4529 return GOT_TLSDESC_GD; 4530 4531 case BFD_RELOC_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21: 4532 case BFD_RELOC_AARCH64_TLSIE_LD32_GOTTPREL_LO12_NC: 4533 case BFD_RELOC_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC: 4534 case BFD_RELOC_AARCH64_TLSIE_LD_GOTTPREL_PREL19: 4535 case BFD_RELOC_AARCH64_TLSIE_MOVW_GOTTPREL_G0_NC: 4536 case BFD_RELOC_AARCH64_TLSIE_MOVW_GOTTPREL_G1: 4537 return GOT_TLS_IE; 4538 4539 default: 4540 break; 4541 } 4542 return GOT_UNKNOWN; 4543} 4544 4545static bfd_boolean 4546aarch64_can_relax_tls (bfd *input_bfd, 4547 struct bfd_link_info *info, 4548 bfd_reloc_code_real_type r_type, 4549 struct elf_link_hash_entry *h, 4550 unsigned long r_symndx) 4551{ 4552 unsigned int symbol_got_type; 4553 unsigned int reloc_got_type; 4554 4555 if (! IS_AARCH64_TLS_RELAX_RELOC (r_type)) 4556 return FALSE; 4557 4558 symbol_got_type = elfNN_aarch64_symbol_got_type (h, input_bfd, r_symndx); 4559 reloc_got_type = aarch64_reloc_got_type (r_type); 4560 4561 if (symbol_got_type == GOT_TLS_IE && GOT_TLS_GD_ANY_P (reloc_got_type)) 4562 return TRUE; 4563 4564 if (bfd_link_pic (info)) 4565 return FALSE; 4566 4567 if (h && h->root.type == bfd_link_hash_undefweak) 4568 return FALSE; 4569 4570 return TRUE; 4571} 4572 4573/* Given the relocation code R_TYPE, return the relaxed bfd reloc 4574 enumerator. */ 4575 4576static bfd_reloc_code_real_type 4577aarch64_tls_transition (bfd *input_bfd, 4578 struct bfd_link_info *info, 4579 unsigned int r_type, 4580 struct elf_link_hash_entry *h, 4581 unsigned long r_symndx) 4582{ 4583 bfd_reloc_code_real_type bfd_r_type 4584 = elfNN_aarch64_bfd_reloc_from_type (r_type); 4585 4586 if (! aarch64_can_relax_tls (input_bfd, info, bfd_r_type, h, r_symndx)) 4587 return bfd_r_type; 4588 4589 return aarch64_tls_transition_without_check (bfd_r_type, h); 4590} 4591 4592/* Return the base VMA address which should be subtracted from real addresses 4593 when resolving R_AARCH64_TLS_DTPREL relocation. */ 4594 4595static bfd_vma 4596dtpoff_base (struct bfd_link_info *info) 4597{ 4598 /* If tls_sec is NULL, we should have signalled an error already. */ 4599 BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL); 4600 return elf_hash_table (info)->tls_sec->vma; 4601} 4602 4603/* Return the base VMA address which should be subtracted from real addresses 4604 when resolving R_AARCH64_TLS_GOTTPREL64 relocations. */ 4605 4606static bfd_vma 4607tpoff_base (struct bfd_link_info *info) 4608{ 4609 struct elf_link_hash_table *htab = elf_hash_table (info); 4610 4611 /* If tls_sec is NULL, we should have signalled an error already. */ 4612 BFD_ASSERT (htab->tls_sec != NULL); 4613 4614 bfd_vma base = align_power ((bfd_vma) TCB_SIZE, 4615 htab->tls_sec->alignment_power); 4616 return htab->tls_sec->vma - base; 4617} 4618 4619static bfd_vma * 4620symbol_got_offset_ref (bfd *input_bfd, struct elf_link_hash_entry *h, 4621 unsigned long r_symndx) 4622{ 4623 /* Calculate the address of the GOT entry for symbol 4624 referred to in h. */ 4625 if (h != NULL) 4626 return &h->got.offset; 4627 else 4628 { 4629 /* local symbol */ 4630 struct elf_aarch64_local_symbol *l; 4631 4632 l = elf_aarch64_locals (input_bfd); 4633 return &l[r_symndx].got_offset; 4634 } 4635} 4636 4637static void 4638symbol_got_offset_mark (bfd *input_bfd, struct elf_link_hash_entry *h, 4639 unsigned long r_symndx) 4640{ 4641 bfd_vma *p; 4642 p = symbol_got_offset_ref (input_bfd, h, r_symndx); 4643 *p |= 1; 4644} 4645 4646static int 4647symbol_got_offset_mark_p (bfd *input_bfd, struct elf_link_hash_entry *h, 4648 unsigned long r_symndx) 4649{ 4650 bfd_vma value; 4651 value = * symbol_got_offset_ref (input_bfd, h, r_symndx); 4652 return value & 1; 4653} 4654 4655static bfd_vma 4656symbol_got_offset (bfd *input_bfd, struct elf_link_hash_entry *h, 4657 unsigned long r_symndx) 4658{ 4659 bfd_vma value; 4660 value = * symbol_got_offset_ref (input_bfd, h, r_symndx); 4661 value &= ~1; 4662 return value; 4663} 4664 4665static bfd_vma * 4666symbol_tlsdesc_got_offset_ref (bfd *input_bfd, struct elf_link_hash_entry *h, 4667 unsigned long r_symndx) 4668{ 4669 /* Calculate the address of the GOT entry for symbol 4670 referred to in h. */ 4671 if (h != NULL) 4672 { 4673 struct elf_aarch64_link_hash_entry *eh; 4674 eh = (struct elf_aarch64_link_hash_entry *) h; 4675 return &eh->tlsdesc_got_jump_table_offset; 4676 } 4677 else 4678 { 4679 /* local symbol */ 4680 struct elf_aarch64_local_symbol *l; 4681 4682 l = elf_aarch64_locals (input_bfd); 4683 return &l[r_symndx].tlsdesc_got_jump_table_offset; 4684 } 4685} 4686 4687static void 4688symbol_tlsdesc_got_offset_mark (bfd *input_bfd, struct elf_link_hash_entry *h, 4689 unsigned long r_symndx) 4690{ 4691 bfd_vma *p; 4692 p = symbol_tlsdesc_got_offset_ref (input_bfd, h, r_symndx); 4693 *p |= 1; 4694} 4695 4696static int 4697symbol_tlsdesc_got_offset_mark_p (bfd *input_bfd, 4698 struct elf_link_hash_entry *h, 4699 unsigned long r_symndx) 4700{ 4701 bfd_vma value; 4702 value = * symbol_tlsdesc_got_offset_ref (input_bfd, h, r_symndx); 4703 return value & 1; 4704} 4705 4706static bfd_vma 4707symbol_tlsdesc_got_offset (bfd *input_bfd, struct elf_link_hash_entry *h, 4708 unsigned long r_symndx) 4709{ 4710 bfd_vma value; 4711 value = * symbol_tlsdesc_got_offset_ref (input_bfd, h, r_symndx); 4712 value &= ~1; 4713 return value; 4714} 4715 4716/* Data for make_branch_to_erratum_835769_stub(). */ 4717 4718struct erratum_835769_branch_to_stub_data 4719{ 4720 struct bfd_link_info *info; 4721 asection *output_section; 4722 bfd_byte *contents; 4723}; 4724 4725/* Helper to insert branches to erratum 835769 stubs in the right 4726 places for a particular section. */ 4727 4728static bfd_boolean 4729make_branch_to_erratum_835769_stub (struct bfd_hash_entry *gen_entry, 4730 void *in_arg) 4731{ 4732 struct elf_aarch64_stub_hash_entry *stub_entry; 4733 struct erratum_835769_branch_to_stub_data *data; 4734 bfd_byte *contents; 4735 unsigned long branch_insn = 0; 4736 bfd_vma veneered_insn_loc, veneer_entry_loc; 4737 bfd_signed_vma branch_offset; 4738 unsigned int target; 4739 bfd *abfd; 4740 4741 stub_entry = (struct elf_aarch64_stub_hash_entry *) gen_entry; 4742 data = (struct erratum_835769_branch_to_stub_data *) in_arg; 4743 4744 if (stub_entry->target_section != data->output_section 4745 || stub_entry->stub_type != aarch64_stub_erratum_835769_veneer) 4746 return TRUE; 4747 4748 contents = data->contents; 4749 veneered_insn_loc = stub_entry->target_section->output_section->vma 4750 + stub_entry->target_section->output_offset 4751 + stub_entry->target_value; 4752 veneer_entry_loc = stub_entry->stub_sec->output_section->vma 4753 + stub_entry->stub_sec->output_offset 4754 + stub_entry->stub_offset; 4755 branch_offset = veneer_entry_loc - veneered_insn_loc; 4756 4757 abfd = stub_entry->target_section->owner; 4758 if (!aarch64_valid_branch_p (veneer_entry_loc, veneered_insn_loc)) 4759 _bfd_error_handler 4760 (_("%B: error: Erratum 835769 stub out " 4761 "of range (input file too large)"), abfd); 4762 4763 target = stub_entry->target_value; 4764 branch_insn = 0x14000000; 4765 branch_offset >>= 2; 4766 branch_offset &= 0x3ffffff; 4767 branch_insn |= branch_offset; 4768 bfd_putl32 (branch_insn, &contents[target]); 4769 4770 return TRUE; 4771} 4772 4773 4774static bfd_boolean 4775_bfd_aarch64_erratum_843419_branch_to_stub (struct bfd_hash_entry *gen_entry, 4776 void *in_arg) 4777{ 4778 struct elf_aarch64_stub_hash_entry *stub_entry 4779 = (struct elf_aarch64_stub_hash_entry *) gen_entry; 4780 struct erratum_835769_branch_to_stub_data *data 4781 = (struct erratum_835769_branch_to_stub_data *) in_arg; 4782 struct bfd_link_info *info; 4783 struct elf_aarch64_link_hash_table *htab; 4784 bfd_byte *contents; 4785 asection *section; 4786 bfd *abfd; 4787 bfd_vma place; 4788 uint32_t insn; 4789 4790 info = data->info; 4791 contents = data->contents; 4792 section = data->output_section; 4793 4794 htab = elf_aarch64_hash_table (info); 4795 4796 if (stub_entry->target_section != section 4797 || stub_entry->stub_type != aarch64_stub_erratum_843419_veneer) 4798 return TRUE; 4799 4800 insn = bfd_getl32 (contents + stub_entry->target_value); 4801 bfd_putl32 (insn, 4802 stub_entry->stub_sec->contents + stub_entry->stub_offset); 4803 4804 place = (section->output_section->vma + section->output_offset 4805 + stub_entry->adrp_offset); 4806 insn = bfd_getl32 (contents + stub_entry->adrp_offset); 4807 4808 if ((insn & AARCH64_ADRP_OP_MASK) != AARCH64_ADRP_OP) 4809 abort (); 4810 4811 bfd_signed_vma imm = 4812 (_bfd_aarch64_sign_extend 4813 ((bfd_vma) _bfd_aarch64_decode_adrp_imm (insn) << 12, 33) 4814 - (place & 0xfff)); 4815 4816 if (htab->fix_erratum_843419_adr 4817 && (imm >= AARCH64_MIN_ADRP_IMM && imm <= AARCH64_MAX_ADRP_IMM)) 4818 { 4819 insn = (_bfd_aarch64_reencode_adr_imm (AARCH64_ADR_OP, imm) 4820 | AARCH64_RT (insn)); 4821 bfd_putl32 (insn, contents + stub_entry->adrp_offset); 4822 } 4823 else 4824 { 4825 bfd_vma veneered_insn_loc; 4826 bfd_vma veneer_entry_loc; 4827 bfd_signed_vma branch_offset; 4828 uint32_t branch_insn; 4829 4830 veneered_insn_loc = stub_entry->target_section->output_section->vma 4831 + stub_entry->target_section->output_offset 4832 + stub_entry->target_value; 4833 veneer_entry_loc = stub_entry->stub_sec->output_section->vma 4834 + stub_entry->stub_sec->output_offset 4835 + stub_entry->stub_offset; 4836 branch_offset = veneer_entry_loc - veneered_insn_loc; 4837 4838 abfd = stub_entry->target_section->owner; 4839 if (!aarch64_valid_branch_p (veneer_entry_loc, veneered_insn_loc)) 4840 _bfd_error_handler 4841 (_("%B: error: Erratum 843419 stub out " 4842 "of range (input file too large)"), abfd); 4843 4844 branch_insn = 0x14000000; 4845 branch_offset >>= 2; 4846 branch_offset &= 0x3ffffff; 4847 branch_insn |= branch_offset; 4848 bfd_putl32 (branch_insn, contents + stub_entry->target_value); 4849 } 4850 return TRUE; 4851} 4852 4853 4854static bfd_boolean 4855elfNN_aarch64_write_section (bfd *output_bfd ATTRIBUTE_UNUSED, 4856 struct bfd_link_info *link_info, 4857 asection *sec, 4858 bfd_byte *contents) 4859 4860{ 4861 struct elf_aarch64_link_hash_table *globals = 4862 elf_aarch64_hash_table (link_info); 4863 4864 if (globals == NULL) 4865 return FALSE; 4866 4867 /* Fix code to point to erratum 835769 stubs. */ 4868 if (globals->fix_erratum_835769) 4869 { 4870 struct erratum_835769_branch_to_stub_data data; 4871 4872 data.info = link_info; 4873 data.output_section = sec; 4874 data.contents = contents; 4875 bfd_hash_traverse (&globals->stub_hash_table, 4876 make_branch_to_erratum_835769_stub, &data); 4877 } 4878 4879 if (globals->fix_erratum_843419) 4880 { 4881 struct erratum_835769_branch_to_stub_data data; 4882 4883 data.info = link_info; 4884 data.output_section = sec; 4885 data.contents = contents; 4886 bfd_hash_traverse (&globals->stub_hash_table, 4887 _bfd_aarch64_erratum_843419_branch_to_stub, &data); 4888 } 4889 4890 return FALSE; 4891} 4892 4893/* Perform a relocation as part of a final link. The input relocation type 4894 should be TLS relaxed. */ 4895 4896static bfd_reloc_status_type 4897elfNN_aarch64_final_link_relocate (reloc_howto_type *howto, 4898 bfd *input_bfd, 4899 bfd *output_bfd, 4900 asection *input_section, 4901 bfd_byte *contents, 4902 Elf_Internal_Rela *rel, 4903 bfd_vma value, 4904 struct bfd_link_info *info, 4905 asection *sym_sec, 4906 struct elf_link_hash_entry *h, 4907 bfd_boolean *unresolved_reloc_p, 4908 bfd_boolean save_addend, 4909 bfd_vma *saved_addend, 4910 Elf_Internal_Sym *sym) 4911{ 4912 Elf_Internal_Shdr *symtab_hdr; 4913 unsigned int r_type = howto->type; 4914 bfd_reloc_code_real_type bfd_r_type 4915 = elfNN_aarch64_bfd_reloc_from_howto (howto); 4916 unsigned long r_symndx; 4917 bfd_byte *hit_data = contents + rel->r_offset; 4918 bfd_vma place, off; 4919 bfd_signed_vma signed_addend; 4920 struct elf_aarch64_link_hash_table *globals; 4921 bfd_boolean weak_undef_p; 4922 asection *base_got; 4923 4924 globals = elf_aarch64_hash_table (info); 4925 4926 symtab_hdr = &elf_symtab_hdr (input_bfd); 4927 4928 BFD_ASSERT (is_aarch64_elf (input_bfd)); 4929 4930 r_symndx = ELFNN_R_SYM (rel->r_info); 4931 4932 place = input_section->output_section->vma 4933 + input_section->output_offset + rel->r_offset; 4934 4935 /* Get addend, accumulating the addend for consecutive relocs 4936 which refer to the same offset. */ 4937 signed_addend = saved_addend ? *saved_addend : 0; 4938 signed_addend += rel->r_addend; 4939 4940 weak_undef_p = (h ? h->root.type == bfd_link_hash_undefweak 4941 : bfd_is_und_section (sym_sec)); 4942 4943 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle 4944 it here if it is defined in a non-shared object. */ 4945 if (h != NULL 4946 && h->type == STT_GNU_IFUNC 4947 && h->def_regular) 4948 { 4949 asection *plt; 4950 const char *name; 4951 bfd_vma addend = 0; 4952 4953 if ((input_section->flags & SEC_ALLOC) == 0 4954 || h->plt.offset == (bfd_vma) -1) 4955 abort (); 4956 4957 /* STT_GNU_IFUNC symbol must go through PLT. */ 4958 plt = globals->root.splt ? globals->root.splt : globals->root.iplt; 4959 value = (plt->output_section->vma + plt->output_offset + h->plt.offset); 4960 4961 switch (bfd_r_type) 4962 { 4963 default: 4964 if (h->root.root.string) 4965 name = h->root.root.string; 4966 else 4967 name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym, 4968 NULL); 4969 _bfd_error_handler 4970 /* xgettext:c-format */ 4971 (_("%B: relocation %s against STT_GNU_IFUNC " 4972 "symbol `%s' isn't handled by %s"), input_bfd, 4973 howto->name, name, __FUNCTION__); 4974 bfd_set_error (bfd_error_bad_value); 4975 return FALSE; 4976 4977 case BFD_RELOC_AARCH64_NN: 4978 if (rel->r_addend != 0) 4979 { 4980 if (h->root.root.string) 4981 name = h->root.root.string; 4982 else 4983 name = bfd_elf_sym_name (input_bfd, symtab_hdr, 4984 sym, NULL); 4985 _bfd_error_handler 4986 /* xgettext:c-format */ 4987 (_("%B: relocation %s against STT_GNU_IFUNC " 4988 "symbol `%s' has non-zero addend: %d"), 4989 input_bfd, howto->name, name, rel->r_addend); 4990 bfd_set_error (bfd_error_bad_value); 4991 return FALSE; 4992 } 4993 4994 /* Generate dynamic relocation only when there is a 4995 non-GOT reference in a shared object. */ 4996 if (bfd_link_pic (info) && h->non_got_ref) 4997 { 4998 Elf_Internal_Rela outrel; 4999 asection *sreloc; 5000 5001 /* Need a dynamic relocation to get the real function 5002 address. */ 5003 outrel.r_offset = _bfd_elf_section_offset (output_bfd, 5004 info, 5005 input_section, 5006 rel->r_offset); 5007 if (outrel.r_offset == (bfd_vma) -1 5008 || outrel.r_offset == (bfd_vma) -2) 5009 abort (); 5010 5011 outrel.r_offset += (input_section->output_section->vma 5012 + input_section->output_offset); 5013 5014 if (h->dynindx == -1 5015 || h->forced_local 5016 || bfd_link_executable (info)) 5017 { 5018 /* This symbol is resolved locally. */ 5019 outrel.r_info = ELFNN_R_INFO (0, AARCH64_R (IRELATIVE)); 5020 outrel.r_addend = (h->root.u.def.value 5021 + h->root.u.def.section->output_section->vma 5022 + h->root.u.def.section->output_offset); 5023 } 5024 else 5025 { 5026 outrel.r_info = ELFNN_R_INFO (h->dynindx, r_type); 5027 outrel.r_addend = 0; 5028 } 5029 5030 sreloc = globals->root.irelifunc; 5031 elf_append_rela (output_bfd, sreloc, &outrel); 5032 5033 /* If this reloc is against an external symbol, we 5034 do not want to fiddle with the addend. Otherwise, 5035 we need to include the symbol value so that it 5036 becomes an addend for the dynamic reloc. For an 5037 internal symbol, we have updated addend. */ 5038 return bfd_reloc_ok; 5039 } 5040 /* FALLTHROUGH */ 5041 case BFD_RELOC_AARCH64_CALL26: 5042 case BFD_RELOC_AARCH64_JUMP26: 5043 value = _bfd_aarch64_elf_resolve_relocation (bfd_r_type, place, value, 5044 signed_addend, 5045 weak_undef_p); 5046 return _bfd_aarch64_elf_put_addend (input_bfd, hit_data, bfd_r_type, 5047 howto, value); 5048 case BFD_RELOC_AARCH64_ADR_GOT_PAGE: 5049 case BFD_RELOC_AARCH64_GOT_LD_PREL19: 5050 case BFD_RELOC_AARCH64_LD32_GOTPAGE_LO14: 5051 case BFD_RELOC_AARCH64_LD32_GOT_LO12_NC: 5052 case BFD_RELOC_AARCH64_LD64_GOTPAGE_LO15: 5053 case BFD_RELOC_AARCH64_MOVW_GOTOFF_G0_NC: 5054 case BFD_RELOC_AARCH64_MOVW_GOTOFF_G1: 5055 case BFD_RELOC_AARCH64_LD64_GOTOFF_LO15: 5056 case BFD_RELOC_AARCH64_LD64_GOT_LO12_NC: 5057 base_got = globals->root.sgot; 5058 off = h->got.offset; 5059 5060 if (base_got == NULL) 5061 abort (); 5062 5063 if (off == (bfd_vma) -1) 5064 { 5065 bfd_vma plt_index; 5066 5067 /* We can't use h->got.offset here to save state, or 5068 even just remember the offset, as finish_dynamic_symbol 5069 would use that as offset into .got. */ 5070 5071 if (globals->root.splt != NULL) 5072 { 5073 plt_index = ((h->plt.offset - globals->plt_header_size) / 5074 globals->plt_entry_size); 5075 off = (plt_index + 3) * GOT_ENTRY_SIZE; 5076 base_got = globals->root.sgotplt; 5077 } 5078 else 5079 { 5080 plt_index = h->plt.offset / globals->plt_entry_size; 5081 off = plt_index * GOT_ENTRY_SIZE; 5082 base_got = globals->root.igotplt; 5083 } 5084 5085 if (h->dynindx == -1 5086 || h->forced_local 5087 || info->symbolic) 5088 { 5089 /* This references the local definition. We must 5090 initialize this entry in the global offset table. 5091 Since the offset must always be a multiple of 8, 5092 we use the least significant bit to record 5093 whether we have initialized it already. 5094 5095 When doing a dynamic link, we create a .rela.got 5096 relocation entry to initialize the value. This 5097 is done in the finish_dynamic_symbol routine. */ 5098 if ((off & 1) != 0) 5099 off &= ~1; 5100 else 5101 { 5102 bfd_put_NN (output_bfd, value, 5103 base_got->contents + off); 5104 /* Note that this is harmless as -1 | 1 still is -1. */ 5105 h->got.offset |= 1; 5106 } 5107 } 5108 value = (base_got->output_section->vma 5109 + base_got->output_offset + off); 5110 } 5111 else 5112 value = aarch64_calculate_got_entry_vma (h, globals, info, 5113 value, output_bfd, 5114 unresolved_reloc_p); 5115 5116 switch (bfd_r_type) 5117 { 5118 case BFD_RELOC_AARCH64_LD32_GOTPAGE_LO14: 5119 case BFD_RELOC_AARCH64_LD64_GOTPAGE_LO15: 5120 addend = (globals->root.sgot->output_section->vma 5121 + globals->root.sgot->output_offset); 5122 break; 5123 case BFD_RELOC_AARCH64_MOVW_GOTOFF_G0_NC: 5124 case BFD_RELOC_AARCH64_MOVW_GOTOFF_G1: 5125 case BFD_RELOC_AARCH64_LD64_GOTOFF_LO15: 5126 value = (value - globals->root.sgot->output_section->vma 5127 - globals->root.sgot->output_offset); 5128 default: 5129 break; 5130 } 5131 5132 value = _bfd_aarch64_elf_resolve_relocation (bfd_r_type, place, value, 5133 addend, weak_undef_p); 5134 return _bfd_aarch64_elf_put_addend (input_bfd, hit_data, bfd_r_type, howto, value); 5135 case BFD_RELOC_AARCH64_ADD_LO12: 5136 case BFD_RELOC_AARCH64_ADR_HI21_PCREL: 5137 break; 5138 } 5139 } 5140 5141 switch (bfd_r_type) 5142 { 5143 case BFD_RELOC_AARCH64_NONE: 5144 case BFD_RELOC_AARCH64_TLSDESC_ADD: 5145 case BFD_RELOC_AARCH64_TLSDESC_CALL: 5146 case BFD_RELOC_AARCH64_TLSDESC_LDR: 5147 *unresolved_reloc_p = FALSE; 5148 return bfd_reloc_ok; 5149 5150 case BFD_RELOC_AARCH64_NN: 5151 5152 /* When generating a shared object or relocatable executable, these 5153 relocations are copied into the output file to be resolved at 5154 run time. */ 5155 if (((bfd_link_pic (info) == TRUE) 5156 || globals->root.is_relocatable_executable) 5157 && (input_section->flags & SEC_ALLOC) 5158 && (h == NULL 5159 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT 5160 || h->root.type != bfd_link_hash_undefweak)) 5161 { 5162 Elf_Internal_Rela outrel; 5163 bfd_byte *loc; 5164 bfd_boolean skip, relocate; 5165 asection *sreloc; 5166 5167 *unresolved_reloc_p = FALSE; 5168 5169 skip = FALSE; 5170 relocate = FALSE; 5171 5172 outrel.r_addend = signed_addend; 5173 outrel.r_offset = 5174 _bfd_elf_section_offset (output_bfd, info, input_section, 5175 rel->r_offset); 5176 if (outrel.r_offset == (bfd_vma) - 1) 5177 skip = TRUE; 5178 else if (outrel.r_offset == (bfd_vma) - 2) 5179 { 5180 skip = TRUE; 5181 relocate = TRUE; 5182 } 5183 5184 outrel.r_offset += (input_section->output_section->vma 5185 + input_section->output_offset); 5186 5187 if (skip) 5188 memset (&outrel, 0, sizeof outrel); 5189 else if (h != NULL 5190 && h->dynindx != -1 5191 && (!bfd_link_pic (info) 5192 || !(bfd_link_pie (info) 5193 || SYMBOLIC_BIND (info, h)) 5194 || !h->def_regular)) 5195 outrel.r_info = ELFNN_R_INFO (h->dynindx, r_type); 5196 else 5197 { 5198 int symbol; 5199 5200 /* On SVR4-ish systems, the dynamic loader cannot 5201 relocate the text and data segments independently, 5202 so the symbol does not matter. */ 5203 symbol = 0; 5204 relocate = globals->no_apply_dynamic_relocs ? FALSE : TRUE; 5205 outrel.r_info = ELFNN_R_INFO (symbol, AARCH64_R (RELATIVE)); 5206 outrel.r_addend += value; 5207 } 5208 5209 sreloc = elf_section_data (input_section)->sreloc; 5210 if (sreloc == NULL || sreloc->contents == NULL) 5211 return bfd_reloc_notsupported; 5212 5213 loc = sreloc->contents + sreloc->reloc_count++ * RELOC_SIZE (globals); 5214 bfd_elfNN_swap_reloca_out (output_bfd, &outrel, loc); 5215 5216 if (sreloc->reloc_count * RELOC_SIZE (globals) > sreloc->size) 5217 { 5218 /* Sanity to check that we have previously allocated 5219 sufficient space in the relocation section for the 5220 number of relocations we actually want to emit. */ 5221 abort (); 5222 } 5223 5224 /* If this reloc is against an external symbol, we do not want to 5225 fiddle with the addend. Otherwise, we need to include the symbol 5226 value so that it becomes an addend for the dynamic reloc. */ 5227 if (!relocate) 5228 return bfd_reloc_ok; 5229 5230 return _bfd_final_link_relocate (howto, input_bfd, input_section, 5231 contents, rel->r_offset, value, 5232 signed_addend); 5233 } 5234 else 5235 value += signed_addend; 5236 break; 5237 5238 case BFD_RELOC_AARCH64_CALL26: 5239 case BFD_RELOC_AARCH64_JUMP26: 5240 { 5241 asection *splt = globals->root.splt; 5242 bfd_boolean via_plt_p = 5243 splt != NULL && h != NULL && h->plt.offset != (bfd_vma) - 1; 5244 5245 /* A call to an undefined weak symbol is converted to a jump to 5246 the next instruction unless a PLT entry will be created. 5247 The jump to the next instruction is optimized as a NOP. 5248 Do the same for local undefined symbols. */ 5249 if (weak_undef_p && ! via_plt_p) 5250 { 5251 bfd_putl32 (INSN_NOP, hit_data); 5252 return bfd_reloc_ok; 5253 } 5254 5255 /* If the call goes through a PLT entry, make sure to 5256 check distance to the right destination address. */ 5257 if (via_plt_p) 5258 value = (splt->output_section->vma 5259 + splt->output_offset + h->plt.offset); 5260 5261 /* Check if a stub has to be inserted because the destination 5262 is too far away. */ 5263 struct elf_aarch64_stub_hash_entry *stub_entry = NULL; 5264 5265 /* If the branch destination is directed to plt stub, "value" will be 5266 the final destination, otherwise we should plus signed_addend, it may 5267 contain non-zero value, for example call to local function symbol 5268 which are turned into "sec_sym + sec_off", and sec_off is kept in 5269 signed_addend. */ 5270 if (! aarch64_valid_branch_p (via_plt_p ? value : value + signed_addend, 5271 place)) 5272 /* The target is out of reach, so redirect the branch to 5273 the local stub for this function. */ 5274 stub_entry = elfNN_aarch64_get_stub_entry (input_section, sym_sec, h, 5275 rel, globals); 5276 if (stub_entry != NULL) 5277 { 5278 value = (stub_entry->stub_offset 5279 + stub_entry->stub_sec->output_offset 5280 + stub_entry->stub_sec->output_section->vma); 5281 5282 /* We have redirected the destination to stub entry address, 5283 so ignore any addend record in the original rela entry. */ 5284 signed_addend = 0; 5285 } 5286 } 5287 value = _bfd_aarch64_elf_resolve_relocation (bfd_r_type, place, value, 5288 signed_addend, weak_undef_p); 5289 *unresolved_reloc_p = FALSE; 5290 break; 5291 5292 case BFD_RELOC_AARCH64_16_PCREL: 5293 case BFD_RELOC_AARCH64_32_PCREL: 5294 case BFD_RELOC_AARCH64_64_PCREL: 5295 case BFD_RELOC_AARCH64_ADR_HI21_NC_PCREL: 5296 case BFD_RELOC_AARCH64_ADR_HI21_PCREL: 5297 case BFD_RELOC_AARCH64_ADR_LO21_PCREL: 5298 case BFD_RELOC_AARCH64_LD_LO19_PCREL: 5299 if (bfd_link_pic (info) 5300 && (input_section->flags & SEC_ALLOC) != 0 5301 && (input_section->flags & SEC_READONLY) != 0 5302 && h != NULL 5303 && !h->def_regular) 5304 { 5305 int howto_index = bfd_r_type - BFD_RELOC_AARCH64_RELOC_START; 5306 5307 _bfd_error_handler 5308 /* xgettext:c-format */ 5309 (_("%B: relocation %s against external symbol `%s' can not be used" 5310 " when making a shared object; recompile with -fPIC"), 5311 input_bfd, elfNN_aarch64_howto_table[howto_index].name, 5312 h->root.root.string); 5313 bfd_set_error (bfd_error_bad_value); 5314 return FALSE; 5315 } 5316 /* Fall through. */ 5317 5318 case BFD_RELOC_AARCH64_16: 5319#if ARCH_SIZE == 64 5320 case BFD_RELOC_AARCH64_32: 5321#endif 5322 case BFD_RELOC_AARCH64_ADD_LO12: 5323 case BFD_RELOC_AARCH64_BRANCH19: 5324 case BFD_RELOC_AARCH64_LDST128_LO12: 5325 case BFD_RELOC_AARCH64_LDST16_LO12: 5326 case BFD_RELOC_AARCH64_LDST32_LO12: 5327 case BFD_RELOC_AARCH64_LDST64_LO12: 5328 case BFD_RELOC_AARCH64_LDST8_LO12: 5329 case BFD_RELOC_AARCH64_MOVW_G0: 5330 case BFD_RELOC_AARCH64_MOVW_G0_NC: 5331 case BFD_RELOC_AARCH64_MOVW_G0_S: 5332 case BFD_RELOC_AARCH64_MOVW_G1: 5333 case BFD_RELOC_AARCH64_MOVW_G1_NC: 5334 case BFD_RELOC_AARCH64_MOVW_G1_S: 5335 case BFD_RELOC_AARCH64_MOVW_G2: 5336 case BFD_RELOC_AARCH64_MOVW_G2_NC: 5337 case BFD_RELOC_AARCH64_MOVW_G2_S: 5338 case BFD_RELOC_AARCH64_MOVW_G3: 5339 case BFD_RELOC_AARCH64_TSTBR14: 5340 value = _bfd_aarch64_elf_resolve_relocation (bfd_r_type, place, value, 5341 signed_addend, weak_undef_p); 5342 break; 5343 5344 case BFD_RELOC_AARCH64_ADR_GOT_PAGE: 5345 case BFD_RELOC_AARCH64_GOT_LD_PREL19: 5346 case BFD_RELOC_AARCH64_LD32_GOTPAGE_LO14: 5347 case BFD_RELOC_AARCH64_LD32_GOT_LO12_NC: 5348 case BFD_RELOC_AARCH64_LD64_GOTPAGE_LO15: 5349 case BFD_RELOC_AARCH64_LD64_GOT_LO12_NC: 5350 if (globals->root.sgot == NULL) 5351 BFD_ASSERT (h != NULL); 5352 5353 if (h != NULL) 5354 { 5355 bfd_vma addend = 0; 5356 value = aarch64_calculate_got_entry_vma (h, globals, info, value, 5357 output_bfd, 5358 unresolved_reloc_p); 5359 if (bfd_r_type == BFD_RELOC_AARCH64_LD64_GOTPAGE_LO15 5360 || bfd_r_type == BFD_RELOC_AARCH64_LD32_GOTPAGE_LO14) 5361 addend = (globals->root.sgot->output_section->vma 5362 + globals->root.sgot->output_offset); 5363 value = _bfd_aarch64_elf_resolve_relocation (bfd_r_type, place, value, 5364 addend, weak_undef_p); 5365 } 5366 else 5367 { 5368 bfd_vma addend = 0; 5369 struct elf_aarch64_local_symbol *locals 5370 = elf_aarch64_locals (input_bfd); 5371 5372 if (locals == NULL) 5373 { 5374 int howto_index = bfd_r_type - BFD_RELOC_AARCH64_RELOC_START; 5375 _bfd_error_handler 5376 /* xgettext:c-format */ 5377 (_("%B: Local symbol descriptor table be NULL when applying " 5378 "relocation %s against local symbol"), 5379 input_bfd, elfNN_aarch64_howto_table[howto_index].name); 5380 abort (); 5381 } 5382 5383 off = symbol_got_offset (input_bfd, h, r_symndx); 5384 base_got = globals->root.sgot; 5385 bfd_vma got_entry_addr = (base_got->output_section->vma 5386 + base_got->output_offset + off); 5387 5388 if (!symbol_got_offset_mark_p (input_bfd, h, r_symndx)) 5389 { 5390 bfd_put_64 (output_bfd, value, base_got->contents + off); 5391 5392 if (bfd_link_pic (info)) 5393 { 5394 asection *s; 5395 Elf_Internal_Rela outrel; 5396 5397 /* For local symbol, we have done absolute relocation in static 5398 linking stageh. While for share library, we need to update 5399 the content of GOT entry according to the share objects 5400 loading base address. So we need to generate a 5401 R_AARCH64_RELATIVE reloc for dynamic linker. */ 5402 s = globals->root.srelgot; 5403 if (s == NULL) 5404 abort (); 5405 5406 outrel.r_offset = got_entry_addr; 5407 outrel.r_info = ELFNN_R_INFO (0, AARCH64_R (RELATIVE)); 5408 outrel.r_addend = value; 5409 elf_append_rela (output_bfd, s, &outrel); 5410 } 5411 5412 symbol_got_offset_mark (input_bfd, h, r_symndx); 5413 } 5414 5415 /* Update the relocation value to GOT entry addr as we have transformed 5416 the direct data access into indirect data access through GOT. */ 5417 value = got_entry_addr; 5418 5419 if (bfd_r_type == BFD_RELOC_AARCH64_LD64_GOTPAGE_LO15 5420 || bfd_r_type == BFD_RELOC_AARCH64_LD32_GOTPAGE_LO14) 5421 addend = base_got->output_section->vma + base_got->output_offset; 5422 5423 value = _bfd_aarch64_elf_resolve_relocation (bfd_r_type, place, value, 5424 addend, weak_undef_p); 5425 } 5426 5427 break; 5428 5429 case BFD_RELOC_AARCH64_LD64_GOTOFF_LO15: 5430 case BFD_RELOC_AARCH64_MOVW_GOTOFF_G0_NC: 5431 case BFD_RELOC_AARCH64_MOVW_GOTOFF_G1: 5432 if (h != NULL) 5433 value = aarch64_calculate_got_entry_vma (h, globals, info, value, 5434 output_bfd, 5435 unresolved_reloc_p); 5436 else 5437 { 5438 struct elf_aarch64_local_symbol *locals 5439 = elf_aarch64_locals (input_bfd); 5440 5441 if (locals == NULL) 5442 { 5443 int howto_index = bfd_r_type - BFD_RELOC_AARCH64_RELOC_START; 5444 _bfd_error_handler 5445 /* xgettext:c-format */ 5446 (_("%B: Local symbol descriptor table be NULL when applying " 5447 "relocation %s against local symbol"), 5448 input_bfd, elfNN_aarch64_howto_table[howto_index].name); 5449 abort (); 5450 } 5451 5452 off = symbol_got_offset (input_bfd, h, r_symndx); 5453 base_got = globals->root.sgot; 5454 if (base_got == NULL) 5455 abort (); 5456 5457 bfd_vma got_entry_addr = (base_got->output_section->vma 5458 + base_got->output_offset + off); 5459 5460 if (!symbol_got_offset_mark_p (input_bfd, h, r_symndx)) 5461 { 5462 bfd_put_64 (output_bfd, value, base_got->contents + off); 5463 5464 if (bfd_link_pic (info)) 5465 { 5466 asection *s; 5467 Elf_Internal_Rela outrel; 5468 5469 /* For local symbol, we have done absolute relocation in static 5470 linking stage. While for share library, we need to update 5471 the content of GOT entry according to the share objects 5472 loading base address. So we need to generate a 5473 R_AARCH64_RELATIVE reloc for dynamic linker. */ 5474 s = globals->root.srelgot; 5475 if (s == NULL) 5476 abort (); 5477 5478 outrel.r_offset = got_entry_addr; 5479 outrel.r_info = ELFNN_R_INFO (0, AARCH64_R (RELATIVE)); 5480 outrel.r_addend = value; 5481 elf_append_rela (output_bfd, s, &outrel); 5482 } 5483 5484 symbol_got_offset_mark (input_bfd, h, r_symndx); 5485 } 5486 } 5487 5488 /* Update the relocation value to GOT entry addr as we have transformed 5489 the direct data access into indirect data access through GOT. */ 5490 value = symbol_got_offset (input_bfd, h, r_symndx); 5491 value = _bfd_aarch64_elf_resolve_relocation (bfd_r_type, place, value, 5492 0, weak_undef_p); 5493 *unresolved_reloc_p = FALSE; 5494 break; 5495 5496 case BFD_RELOC_AARCH64_TLSGD_ADD_LO12_NC: 5497 case BFD_RELOC_AARCH64_TLSGD_ADR_PAGE21: 5498 case BFD_RELOC_AARCH64_TLSGD_ADR_PREL21: 5499 case BFD_RELOC_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21: 5500 case BFD_RELOC_AARCH64_TLSIE_LD32_GOTTPREL_LO12_NC: 5501 case BFD_RELOC_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC: 5502 case BFD_RELOC_AARCH64_TLSIE_LD_GOTTPREL_PREL19: 5503 case BFD_RELOC_AARCH64_TLSLD_ADD_LO12_NC: 5504 case BFD_RELOC_AARCH64_TLSLD_ADR_PAGE21: 5505 case BFD_RELOC_AARCH64_TLSLD_ADR_PREL21: 5506 if (globals->root.sgot == NULL) 5507 return bfd_reloc_notsupported; 5508 5509 value = (symbol_got_offset (input_bfd, h, r_symndx) 5510 + globals->root.sgot->output_section->vma 5511 + globals->root.sgot->output_offset); 5512 5513 value = _bfd_aarch64_elf_resolve_relocation (bfd_r_type, place, value, 5514 0, weak_undef_p); 5515 *unresolved_reloc_p = FALSE; 5516 break; 5517 5518 case BFD_RELOC_AARCH64_TLSGD_MOVW_G0_NC: 5519 case BFD_RELOC_AARCH64_TLSGD_MOVW_G1: 5520 case BFD_RELOC_AARCH64_TLSIE_MOVW_GOTTPREL_G0_NC: 5521 case BFD_RELOC_AARCH64_TLSIE_MOVW_GOTTPREL_G1: 5522 if (globals->root.sgot == NULL) 5523 return bfd_reloc_notsupported; 5524 5525 value = symbol_got_offset (input_bfd, h, r_symndx); 5526 value = _bfd_aarch64_elf_resolve_relocation (bfd_r_type, place, value, 5527 0, weak_undef_p); 5528 *unresolved_reloc_p = FALSE; 5529 break; 5530 5531 case BFD_RELOC_AARCH64_TLSLD_ADD_DTPREL_HI12: 5532 case BFD_RELOC_AARCH64_TLSLD_ADD_DTPREL_LO12: 5533 case BFD_RELOC_AARCH64_TLSLD_ADD_DTPREL_LO12_NC: 5534 case BFD_RELOC_AARCH64_TLSLD_LDST16_DTPREL_LO12: 5535 case BFD_RELOC_AARCH64_TLSLD_LDST16_DTPREL_LO12_NC: 5536 case BFD_RELOC_AARCH64_TLSLD_LDST32_DTPREL_LO12: 5537 case BFD_RELOC_AARCH64_TLSLD_LDST32_DTPREL_LO12_NC: 5538 case BFD_RELOC_AARCH64_TLSLD_LDST64_DTPREL_LO12: 5539 case BFD_RELOC_AARCH64_TLSLD_LDST64_DTPREL_LO12_NC: 5540 case BFD_RELOC_AARCH64_TLSLD_LDST8_DTPREL_LO12: 5541 case BFD_RELOC_AARCH64_TLSLD_LDST8_DTPREL_LO12_NC: 5542 case BFD_RELOC_AARCH64_TLSLD_MOVW_DTPREL_G0: 5543 case BFD_RELOC_AARCH64_TLSLD_MOVW_DTPREL_G0_NC: 5544 case BFD_RELOC_AARCH64_TLSLD_MOVW_DTPREL_G1: 5545 case BFD_RELOC_AARCH64_TLSLD_MOVW_DTPREL_G1_NC: 5546 case BFD_RELOC_AARCH64_TLSLD_MOVW_DTPREL_G2: 5547 value = _bfd_aarch64_elf_resolve_relocation (bfd_r_type, place, value, 5548 signed_addend - dtpoff_base (info), 5549 weak_undef_p); 5550 break; 5551 5552 case BFD_RELOC_AARCH64_TLSLE_ADD_TPREL_HI12: 5553 case BFD_RELOC_AARCH64_TLSLE_ADD_TPREL_LO12: 5554 case BFD_RELOC_AARCH64_TLSLE_ADD_TPREL_LO12_NC: 5555 case BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G0: 5556 case BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G0_NC: 5557 case BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G1: 5558 case BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G1_NC: 5559 case BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G2: 5560 value = _bfd_aarch64_elf_resolve_relocation (bfd_r_type, place, value, 5561 signed_addend - tpoff_base (info), 5562 weak_undef_p); 5563 *unresolved_reloc_p = FALSE; 5564 break; 5565 5566 case BFD_RELOC_AARCH64_TLSDESC_ADD_LO12_NC: 5567 case BFD_RELOC_AARCH64_TLSDESC_ADR_PAGE21: 5568 case BFD_RELOC_AARCH64_TLSDESC_ADR_PREL21: 5569 case BFD_RELOC_AARCH64_TLSDESC_LD32_LO12_NC: 5570 case BFD_RELOC_AARCH64_TLSDESC_LD64_LO12_NC: 5571 case BFD_RELOC_AARCH64_TLSDESC_LD_PREL19: 5572 if (globals->root.sgot == NULL) 5573 return bfd_reloc_notsupported; 5574 value = (symbol_tlsdesc_got_offset (input_bfd, h, r_symndx) 5575 + globals->root.sgotplt->output_section->vma 5576 + globals->root.sgotplt->output_offset 5577 + globals->sgotplt_jump_table_size); 5578 5579 value = _bfd_aarch64_elf_resolve_relocation (bfd_r_type, place, value, 5580 0, weak_undef_p); 5581 *unresolved_reloc_p = FALSE; 5582 break; 5583 5584 case BFD_RELOC_AARCH64_TLSDESC_OFF_G0_NC: 5585 case BFD_RELOC_AARCH64_TLSDESC_OFF_G1: 5586 if (globals->root.sgot == NULL) 5587 return bfd_reloc_notsupported; 5588 5589 value = (symbol_tlsdesc_got_offset (input_bfd, h, r_symndx) 5590 + globals->root.sgotplt->output_section->vma 5591 + globals->root.sgotplt->output_offset 5592 + globals->sgotplt_jump_table_size); 5593 5594 value -= (globals->root.sgot->output_section->vma 5595 + globals->root.sgot->output_offset); 5596 5597 value = _bfd_aarch64_elf_resolve_relocation (bfd_r_type, place, value, 5598 0, weak_undef_p); 5599 *unresolved_reloc_p = FALSE; 5600 break; 5601 5602 default: 5603 return bfd_reloc_notsupported; 5604 } 5605 5606 if (saved_addend) 5607 *saved_addend = value; 5608 5609 /* Only apply the final relocation in a sequence. */ 5610 if (save_addend) 5611 return bfd_reloc_continue; 5612 5613 return _bfd_aarch64_elf_put_addend (input_bfd, hit_data, bfd_r_type, 5614 howto, value); 5615} 5616 5617/* Handle TLS relaxations. Relaxing is possible for symbols that use 5618 R_AARCH64_TLSDESC_ADR_{PAGE, LD64_LO12_NC, ADD_LO12_NC} during a static 5619 link. 5620 5621 Return bfd_reloc_ok if we're done, bfd_reloc_continue if the caller 5622 is to then call final_link_relocate. Return other values in the 5623 case of error. */ 5624 5625static bfd_reloc_status_type 5626elfNN_aarch64_tls_relax (struct elf_aarch64_link_hash_table *globals, 5627 bfd *input_bfd, bfd_byte *contents, 5628 Elf_Internal_Rela *rel, struct elf_link_hash_entry *h) 5629{ 5630 bfd_boolean is_local = h == NULL; 5631 unsigned int r_type = ELFNN_R_TYPE (rel->r_info); 5632 unsigned long insn; 5633 5634 BFD_ASSERT (globals && input_bfd && contents && rel); 5635 5636 switch (elfNN_aarch64_bfd_reloc_from_type (r_type)) 5637 { 5638 case BFD_RELOC_AARCH64_TLSDESC_ADR_PAGE21: 5639 case BFD_RELOC_AARCH64_TLSGD_ADR_PAGE21: 5640 if (is_local) 5641 { 5642 /* GD->LE relaxation: 5643 adrp x0, :tlsgd:var => movz x0, :tprel_g1:var 5644 or 5645 adrp x0, :tlsdesc:var => movz x0, :tprel_g1:var 5646 */ 5647 bfd_putl32 (0xd2a00000, contents + rel->r_offset); 5648 return bfd_reloc_continue; 5649 } 5650 else 5651 { 5652 /* GD->IE relaxation: 5653 adrp x0, :tlsgd:var => adrp x0, :gottprel:var 5654 or 5655 adrp x0, :tlsdesc:var => adrp x0, :gottprel:var 5656 */ 5657 return bfd_reloc_continue; 5658 } 5659 5660 case BFD_RELOC_AARCH64_TLSDESC_ADR_PREL21: 5661 BFD_ASSERT (0); 5662 break; 5663 5664 case BFD_RELOC_AARCH64_TLSDESC_LD_PREL19: 5665 if (is_local) 5666 { 5667 /* Tiny TLSDESC->LE relaxation: 5668 ldr x1, :tlsdesc:var => movz x0, #:tprel_g1:var 5669 adr x0, :tlsdesc:var => movk x0, #:tprel_g0_nc:var 5670 .tlsdesccall var 5671 blr x1 => nop 5672 */ 5673 BFD_ASSERT (ELFNN_R_TYPE (rel[1].r_info) == AARCH64_R (TLSDESC_ADR_PREL21)); 5674 BFD_ASSERT (ELFNN_R_TYPE (rel[2].r_info) == AARCH64_R (TLSDESC_CALL)); 5675 5676 rel[1].r_info = ELFNN_R_INFO (ELFNN_R_SYM (rel->r_info), 5677 AARCH64_R (TLSLE_MOVW_TPREL_G0_NC)); 5678 rel[2].r_info = ELFNN_R_INFO (STN_UNDEF, R_AARCH64_NONE); 5679 5680 bfd_putl32 (0xd2a00000, contents + rel->r_offset); 5681 bfd_putl32 (0xf2800000, contents + rel->r_offset + 4); 5682 bfd_putl32 (INSN_NOP, contents + rel->r_offset + 8); 5683 return bfd_reloc_continue; 5684 } 5685 else 5686 { 5687 /* Tiny TLSDESC->IE relaxation: 5688 ldr x1, :tlsdesc:var => ldr x0, :gottprel:var 5689 adr x0, :tlsdesc:var => nop 5690 .tlsdesccall var 5691 blr x1 => nop 5692 */ 5693 BFD_ASSERT (ELFNN_R_TYPE (rel[1].r_info) == AARCH64_R (TLSDESC_ADR_PREL21)); 5694 BFD_ASSERT (ELFNN_R_TYPE (rel[2].r_info) == AARCH64_R (TLSDESC_CALL)); 5695 5696 rel[1].r_info = ELFNN_R_INFO (STN_UNDEF, R_AARCH64_NONE); 5697 rel[2].r_info = ELFNN_R_INFO (STN_UNDEF, R_AARCH64_NONE); 5698 5699 bfd_putl32 (0x58000000, contents + rel->r_offset); 5700 bfd_putl32 (INSN_NOP, contents + rel->r_offset + 4); 5701 bfd_putl32 (INSN_NOP, contents + rel->r_offset + 8); 5702 return bfd_reloc_continue; 5703 } 5704 5705 case BFD_RELOC_AARCH64_TLSGD_ADR_PREL21: 5706 if (is_local) 5707 { 5708 /* Tiny GD->LE relaxation: 5709 adr x0, :tlsgd:var => mrs x1, tpidr_el0 5710 bl __tls_get_addr => add x0, x1, #:tprel_hi12:x, lsl #12 5711 nop => add x0, x0, #:tprel_lo12_nc:x 5712 */ 5713 5714 /* First kill the tls_get_addr reloc on the bl instruction. */ 5715 BFD_ASSERT (rel->r_offset + 4 == rel[1].r_offset); 5716 5717 bfd_putl32 (0xd53bd041, contents + rel->r_offset + 0); 5718 bfd_putl32 (0x91400020, contents + rel->r_offset + 4); 5719 bfd_putl32 (0x91000000, contents + rel->r_offset + 8); 5720 5721 rel[1].r_info = ELFNN_R_INFO (ELFNN_R_SYM (rel->r_info), 5722 AARCH64_R (TLSLE_ADD_TPREL_LO12_NC)); 5723 rel[1].r_offset = rel->r_offset + 8; 5724 5725 /* Move the current relocation to the second instruction in 5726 the sequence. */ 5727 rel->r_offset += 4; 5728 rel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (rel->r_info), 5729 AARCH64_R (TLSLE_ADD_TPREL_HI12)); 5730 return bfd_reloc_continue; 5731 } 5732 else 5733 { 5734 /* Tiny GD->IE relaxation: 5735 adr x0, :tlsgd:var => ldr x0, :gottprel:var 5736 bl __tls_get_addr => mrs x1, tpidr_el0 5737 nop => add x0, x0, x1 5738 */ 5739 5740 /* First kill the tls_get_addr reloc on the bl instruction. */ 5741 BFD_ASSERT (rel->r_offset + 4 == rel[1].r_offset); 5742 rel[1].r_info = ELFNN_R_INFO (STN_UNDEF, R_AARCH64_NONE); 5743 5744 bfd_putl32 (0x58000000, contents + rel->r_offset); 5745 bfd_putl32 (0xd53bd041, contents + rel->r_offset + 4); 5746 bfd_putl32 (0x8b000020, contents + rel->r_offset + 8); 5747 return bfd_reloc_continue; 5748 } 5749 5750#if ARCH_SIZE == 64 5751 case BFD_RELOC_AARCH64_TLSGD_MOVW_G1: 5752 BFD_ASSERT (ELFNN_R_TYPE (rel[1].r_info) == AARCH64_R (TLSGD_MOVW_G0_NC)); 5753 BFD_ASSERT (rel->r_offset + 12 == rel[2].r_offset); 5754 BFD_ASSERT (ELFNN_R_TYPE (rel[2].r_info) == AARCH64_R (CALL26)); 5755 5756 if (is_local) 5757 { 5758 /* Large GD->LE relaxation: 5759 movz x0, #:tlsgd_g1:var => movz x0, #:tprel_g2:var, lsl #32 5760 movk x0, #:tlsgd_g0_nc:var => movk x0, #:tprel_g1_nc:var, lsl #16 5761 add x0, gp, x0 => movk x0, #:tprel_g0_nc:var 5762 bl __tls_get_addr => mrs x1, tpidr_el0 5763 nop => add x0, x0, x1 5764 */ 5765 rel[2].r_info = ELFNN_R_INFO (ELFNN_R_SYM (rel->r_info), 5766 AARCH64_R (TLSLE_MOVW_TPREL_G0_NC)); 5767 rel[2].r_offset = rel->r_offset + 8; 5768 5769 bfd_putl32 (0xd2c00000, contents + rel->r_offset + 0); 5770 bfd_putl32 (0xf2a00000, contents + rel->r_offset + 4); 5771 bfd_putl32 (0xf2800000, contents + rel->r_offset + 8); 5772 bfd_putl32 (0xd53bd041, contents + rel->r_offset + 12); 5773 bfd_putl32 (0x8b000020, contents + rel->r_offset + 16); 5774 } 5775 else 5776 { 5777 /* Large GD->IE relaxation: 5778 movz x0, #:tlsgd_g1:var => movz x0, #:gottprel_g1:var, lsl #16 5779 movk x0, #:tlsgd_g0_nc:var => movk x0, #:gottprel_g0_nc:var 5780 add x0, gp, x0 => ldr x0, [gp, x0] 5781 bl __tls_get_addr => mrs x1, tpidr_el0 5782 nop => add x0, x0, x1 5783 */ 5784 rel[2].r_info = ELFNN_R_INFO (STN_UNDEF, R_AARCH64_NONE); 5785 bfd_putl32 (0xd2a80000, contents + rel->r_offset + 0); 5786 bfd_putl32 (0x58000000, contents + rel->r_offset + 8); 5787 bfd_putl32 (0xd53bd041, contents + rel->r_offset + 12); 5788 bfd_putl32 (0x8b000020, contents + rel->r_offset + 16); 5789 } 5790 return bfd_reloc_continue; 5791 5792 case BFD_RELOC_AARCH64_TLSGD_MOVW_G0_NC: 5793 return bfd_reloc_continue; 5794#endif 5795 5796 case BFD_RELOC_AARCH64_TLSIE_LD_GOTTPREL_PREL19: 5797 return bfd_reloc_continue; 5798 5799 case BFD_RELOC_AARCH64_TLSDESC_LDNN_LO12_NC: 5800 if (is_local) 5801 { 5802 /* GD->LE relaxation: 5803 ldr xd, [x0, #:tlsdesc_lo12:var] => movk x0, :tprel_g0_nc:var 5804 */ 5805 bfd_putl32 (0xf2800000, contents + rel->r_offset); 5806 return bfd_reloc_continue; 5807 } 5808 else 5809 { 5810 /* GD->IE relaxation: 5811 ldr xd, [x0, #:tlsdesc_lo12:var] => ldr x0, [x0, #:gottprel_lo12:var] 5812 */ 5813 insn = bfd_getl32 (contents + rel->r_offset); 5814 insn &= 0xffffffe0; 5815 bfd_putl32 (insn, contents + rel->r_offset); 5816 return bfd_reloc_continue; 5817 } 5818 5819 case BFD_RELOC_AARCH64_TLSGD_ADD_LO12_NC: 5820 if (is_local) 5821 { 5822 /* GD->LE relaxation 5823 add x0, #:tlsgd_lo12:var => movk x0, :tprel_g0_nc:var 5824 bl __tls_get_addr => mrs x1, tpidr_el0 5825 nop => add x0, x1, x0 5826 */ 5827 5828 /* First kill the tls_get_addr reloc on the bl instruction. */ 5829 BFD_ASSERT (rel->r_offset + 4 == rel[1].r_offset); 5830 rel[1].r_info = ELFNN_R_INFO (STN_UNDEF, R_AARCH64_NONE); 5831 5832 bfd_putl32 (0xf2800000, contents + rel->r_offset); 5833 bfd_putl32 (0xd53bd041, contents + rel->r_offset + 4); 5834 bfd_putl32 (0x8b000020, contents + rel->r_offset + 8); 5835 return bfd_reloc_continue; 5836 } 5837 else 5838 { 5839 /* GD->IE relaxation 5840 ADD x0, #:tlsgd_lo12:var => ldr R0, [x0, #:gottprel_lo12:var] 5841 BL __tls_get_addr => mrs x1, tpidr_el0 5842 R_AARCH64_CALL26 5843 NOP => add R0, R1, R0 5844 5845 Where R is x for lp64 mode, and w for ilp32 mode. */ 5846 5847 BFD_ASSERT (ELFNN_R_TYPE (rel[1].r_info) == AARCH64_R (CALL26)); 5848 5849 /* Remove the relocation on the BL instruction. */ 5850 rel[1].r_info = ELFNN_R_INFO (STN_UNDEF, R_AARCH64_NONE); 5851 5852 /* We choose to fixup the BL and NOP instructions using the 5853 offset from the second relocation to allow flexibility in 5854 scheduling instructions between the ADD and BL. */ 5855#if ARCH_SIZE == 32 5856 bfd_putl32 (0xb9400000, contents + rel->r_offset); 5857 bfd_putl32 (0x0b000020, contents + rel[1].r_offset + 4); 5858#else 5859 bfd_putl32 (0xf9400000, contents + rel->r_offset); 5860 bfd_putl32 (0x8b000020, contents + rel[1].r_offset + 4); 5861#endif 5862 bfd_putl32 (0xd53bd041, contents + rel[1].r_offset); 5863 return bfd_reloc_continue; 5864 } 5865 5866 case BFD_RELOC_AARCH64_TLSDESC_ADD: 5867 case BFD_RELOC_AARCH64_TLSDESC_ADD_LO12_NC: 5868 case BFD_RELOC_AARCH64_TLSDESC_CALL: 5869 /* GD->IE/LE relaxation: 5870 add x0, x0, #:tlsdesc_lo12:var => nop 5871 blr xd => nop 5872 */ 5873 bfd_putl32 (INSN_NOP, contents + rel->r_offset); 5874 return bfd_reloc_ok; 5875 5876 case BFD_RELOC_AARCH64_TLSDESC_LDR: 5877 if (is_local) 5878 { 5879 /* GD->LE relaxation: 5880 ldr xd, [gp, xn] => movk x0, #:tprel_g0_nc:var 5881 */ 5882 bfd_putl32 (0xf2800000, contents + rel->r_offset); 5883 return bfd_reloc_continue; 5884 } 5885 else 5886 { 5887 /* GD->IE relaxation: 5888 ldr xd, [gp, xn] => ldr x0, [gp, xn] 5889 */ 5890 insn = bfd_getl32 (contents + rel->r_offset); 5891 insn &= 0xffffffe0; 5892 bfd_putl32 (insn, contents + rel->r_offset); 5893 return bfd_reloc_ok; 5894 } 5895 5896 case BFD_RELOC_AARCH64_TLSDESC_OFF_G0_NC: 5897 /* GD->LE relaxation: 5898 movk xd, #:tlsdesc_off_g0_nc:var => movk x0, #:tprel_g1_nc:var, lsl #16 5899 GD->IE relaxation: 5900 movk xd, #:tlsdesc_off_g0_nc:var => movk xd, #:gottprel_g0_nc:var 5901 */ 5902 if (is_local) 5903 bfd_putl32 (0xf2a00000, contents + rel->r_offset); 5904 return bfd_reloc_continue; 5905 5906 case BFD_RELOC_AARCH64_TLSDESC_OFF_G1: 5907 if (is_local) 5908 { 5909 /* GD->LE relaxation: 5910 movz xd, #:tlsdesc_off_g1:var => movz x0, #:tprel_g2:var, lsl #32 5911 */ 5912 bfd_putl32 (0xd2c00000, contents + rel->r_offset); 5913 return bfd_reloc_continue; 5914 } 5915 else 5916 { 5917 /* GD->IE relaxation: 5918 movz xd, #:tlsdesc_off_g1:var => movz xd, #:gottprel_g1:var, lsl #16 5919 */ 5920 insn = bfd_getl32 (contents + rel->r_offset); 5921 bfd_putl32 (0xd2a00000 | (insn & 0x1f), contents + rel->r_offset); 5922 return bfd_reloc_continue; 5923 } 5924 5925 case BFD_RELOC_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21: 5926 /* IE->LE relaxation: 5927 adrp xd, :gottprel:var => movz xd, :tprel_g1:var 5928 */ 5929 if (is_local) 5930 { 5931 insn = bfd_getl32 (contents + rel->r_offset); 5932 bfd_putl32 (0xd2a00000 | (insn & 0x1f), contents + rel->r_offset); 5933 } 5934 return bfd_reloc_continue; 5935 5936 case BFD_RELOC_AARCH64_TLSIE_LDNN_GOTTPREL_LO12_NC: 5937 /* IE->LE relaxation: 5938 ldr xd, [xm, #:gottprel_lo12:var] => movk xd, :tprel_g0_nc:var 5939 */ 5940 if (is_local) 5941 { 5942 insn = bfd_getl32 (contents + rel->r_offset); 5943 bfd_putl32 (0xf2800000 | (insn & 0x1f), contents + rel->r_offset); 5944 } 5945 return bfd_reloc_continue; 5946 5947 case BFD_RELOC_AARCH64_TLSLD_ADR_PREL21: 5948 /* LD->LE relaxation (tiny): 5949 adr x0, :tlsldm:x => mrs x0, tpidr_el0 5950 bl __tls_get_addr => add R0, R0, TCB_SIZE 5951 5952 Where R is x for lp64 mode, and w for ilp32 mode. */ 5953 if (is_local) 5954 { 5955 BFD_ASSERT (rel->r_offset + 4 == rel[1].r_offset); 5956 BFD_ASSERT (ELFNN_R_TYPE (rel[1].r_info) == AARCH64_R (CALL26)); 5957 /* No need of CALL26 relocation for tls_get_addr. */ 5958 rel[1].r_info = ELFNN_R_INFO (STN_UNDEF, R_AARCH64_NONE); 5959 bfd_putl32 (0xd53bd040, contents + rel->r_offset + 0); 5960#if ARCH_SIZE == 64 5961 bfd_putl32 (0x91004000, contents + rel->r_offset + 4); 5962#else 5963 bfd_putl32 (0x11002000, contents + rel->r_offset + 4); 5964#endif 5965 return bfd_reloc_ok; 5966 } 5967 return bfd_reloc_continue; 5968 5969 case BFD_RELOC_AARCH64_TLSLD_ADR_PAGE21: 5970 /* LD->LE relaxation (small): 5971 adrp x0, :tlsldm:x => mrs x0, tpidr_el0 5972 */ 5973 if (is_local) 5974 { 5975 bfd_putl32 (0xd53bd040, contents + rel->r_offset); 5976 return bfd_reloc_ok; 5977 } 5978 return bfd_reloc_continue; 5979 5980 case BFD_RELOC_AARCH64_TLSLD_ADD_LO12_NC: 5981 /* LD->LE relaxation (small): 5982 add x0, #:tlsldm_lo12:x => add R0, R0, TCB_SIZE 5983 bl __tls_get_addr => nop 5984 5985 Where R is x for lp64 mode, and w for ilp32 mode. */ 5986 if (is_local) 5987 { 5988 BFD_ASSERT (rel->r_offset + 4 == rel[1].r_offset); 5989 BFD_ASSERT (ELFNN_R_TYPE (rel[1].r_info) == AARCH64_R (CALL26)); 5990 /* No need of CALL26 relocation for tls_get_addr. */ 5991 rel[1].r_info = ELFNN_R_INFO (STN_UNDEF, R_AARCH64_NONE); 5992#if ARCH_SIZE == 64 5993 bfd_putl32 (0x91004000, contents + rel->r_offset + 0); 5994#else 5995 bfd_putl32 (0x11002000, contents + rel->r_offset + 0); 5996#endif 5997 bfd_putl32 (INSN_NOP, contents + rel->r_offset + 4); 5998 return bfd_reloc_ok; 5999 } 6000 return bfd_reloc_continue; 6001 6002 default: 6003 return bfd_reloc_continue; 6004 } 6005 6006 return bfd_reloc_ok; 6007} 6008 6009/* Relocate an AArch64 ELF section. */ 6010 6011static bfd_boolean 6012elfNN_aarch64_relocate_section (bfd *output_bfd, 6013 struct bfd_link_info *info, 6014 bfd *input_bfd, 6015 asection *input_section, 6016 bfd_byte *contents, 6017 Elf_Internal_Rela *relocs, 6018 Elf_Internal_Sym *local_syms, 6019 asection **local_sections) 6020{ 6021 Elf_Internal_Shdr *symtab_hdr; 6022 struct elf_link_hash_entry **sym_hashes; 6023 Elf_Internal_Rela *rel; 6024 Elf_Internal_Rela *relend; 6025 const char *name; 6026 struct elf_aarch64_link_hash_table *globals; 6027 bfd_boolean save_addend = FALSE; 6028 bfd_vma addend = 0; 6029 6030 globals = elf_aarch64_hash_table (info); 6031 6032 symtab_hdr = &elf_symtab_hdr (input_bfd); 6033 sym_hashes = elf_sym_hashes (input_bfd); 6034 6035 rel = relocs; 6036 relend = relocs + input_section->reloc_count; 6037 for (; rel < relend; rel++) 6038 { 6039 unsigned int r_type; 6040 bfd_reloc_code_real_type bfd_r_type; 6041 bfd_reloc_code_real_type relaxed_bfd_r_type; 6042 reloc_howto_type *howto; 6043 unsigned long r_symndx; 6044 Elf_Internal_Sym *sym; 6045 asection *sec; 6046 struct elf_link_hash_entry *h; 6047 bfd_vma relocation; 6048 bfd_reloc_status_type r; 6049 arelent bfd_reloc; 6050 char sym_type; 6051 bfd_boolean unresolved_reloc = FALSE; 6052 char *error_message = NULL; 6053 6054 r_symndx = ELFNN_R_SYM (rel->r_info); 6055 r_type = ELFNN_R_TYPE (rel->r_info); 6056 6057 bfd_reloc.howto = elfNN_aarch64_howto_from_type (r_type); 6058 howto = bfd_reloc.howto; 6059 6060 if (howto == NULL) 6061 { 6062 /* xgettext:c-format */ 6063 _bfd_error_handler 6064 (_("%B: unrecognized relocation (0x%x) in section `%A'"), 6065 input_bfd, input_section, r_type); 6066 return FALSE; 6067 } 6068 bfd_r_type = elfNN_aarch64_bfd_reloc_from_howto (howto); 6069 6070 h = NULL; 6071 sym = NULL; 6072 sec = NULL; 6073 6074 if (r_symndx < symtab_hdr->sh_info) 6075 { 6076 sym = local_syms + r_symndx; 6077 sym_type = ELFNN_ST_TYPE (sym->st_info); 6078 sec = local_sections[r_symndx]; 6079 6080 /* An object file might have a reference to a local 6081 undefined symbol. This is a daft object file, but we 6082 should at least do something about it. */ 6083 if (r_type != R_AARCH64_NONE && r_type != R_AARCH64_NULL 6084 && bfd_is_und_section (sec) 6085 && ELF_ST_BIND (sym->st_info) != STB_WEAK) 6086 (*info->callbacks->undefined_symbol) 6087 (info, bfd_elf_string_from_elf_section 6088 (input_bfd, symtab_hdr->sh_link, sym->st_name), 6089 input_bfd, input_section, rel->r_offset, TRUE); 6090 6091 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel); 6092 6093 /* Relocate against local STT_GNU_IFUNC symbol. */ 6094 if (!bfd_link_relocatable (info) 6095 && ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC) 6096 { 6097 h = elfNN_aarch64_get_local_sym_hash (globals, input_bfd, 6098 rel, FALSE); 6099 if (h == NULL) 6100 abort (); 6101 6102 /* Set STT_GNU_IFUNC symbol value. */ 6103 h->root.u.def.value = sym->st_value; 6104 h->root.u.def.section = sec; 6105 } 6106 } 6107 else 6108 { 6109 bfd_boolean warned, ignored; 6110 6111 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel, 6112 r_symndx, symtab_hdr, sym_hashes, 6113 h, sec, relocation, 6114 unresolved_reloc, warned, ignored); 6115 6116 sym_type = h->type; 6117 } 6118 6119 if (sec != NULL && discarded_section (sec)) 6120 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section, 6121 rel, 1, relend, howto, 0, contents); 6122 6123 if (bfd_link_relocatable (info)) 6124 continue; 6125 6126 if (h != NULL) 6127 name = h->root.root.string; 6128 else 6129 { 6130 name = (bfd_elf_string_from_elf_section 6131 (input_bfd, symtab_hdr->sh_link, sym->st_name)); 6132 if (name == NULL || *name == '\0') 6133 name = bfd_section_name (input_bfd, sec); 6134 } 6135 6136 if (r_symndx != 0 6137 && r_type != R_AARCH64_NONE 6138 && r_type != R_AARCH64_NULL 6139 && (h == NULL 6140 || h->root.type == bfd_link_hash_defined 6141 || h->root.type == bfd_link_hash_defweak) 6142 && IS_AARCH64_TLS_RELOC (bfd_r_type) != (sym_type == STT_TLS)) 6143 { 6144 _bfd_error_handler 6145 ((sym_type == STT_TLS 6146 /* xgettext:c-format */ 6147 ? _("%B(%A+0x%lx): %s used with TLS symbol %s") 6148 /* xgettext:c-format */ 6149 : _("%B(%A+0x%lx): %s used with non-TLS symbol %s")), 6150 input_bfd, 6151 input_section, (long) rel->r_offset, howto->name, name); 6152 } 6153 6154 /* We relax only if we can see that there can be a valid transition 6155 from a reloc type to another. 6156 We call elfNN_aarch64_final_link_relocate unless we're completely 6157 done, i.e., the relaxation produced the final output we want. */ 6158 6159 relaxed_bfd_r_type = aarch64_tls_transition (input_bfd, info, r_type, 6160 h, r_symndx); 6161 if (relaxed_bfd_r_type != bfd_r_type) 6162 { 6163 bfd_r_type = relaxed_bfd_r_type; 6164 howto = elfNN_aarch64_howto_from_bfd_reloc (bfd_r_type); 6165 BFD_ASSERT (howto != NULL); 6166 r_type = howto->type; 6167 r = elfNN_aarch64_tls_relax (globals, input_bfd, contents, rel, h); 6168 unresolved_reloc = 0; 6169 } 6170 else 6171 r = bfd_reloc_continue; 6172 6173 /* There may be multiple consecutive relocations for the 6174 same offset. In that case we are supposed to treat the 6175 output of each relocation as the addend for the next. */ 6176 if (rel + 1 < relend 6177 && rel->r_offset == rel[1].r_offset 6178 && ELFNN_R_TYPE (rel[1].r_info) != R_AARCH64_NONE 6179 && ELFNN_R_TYPE (rel[1].r_info) != R_AARCH64_NULL) 6180 save_addend = TRUE; 6181 else 6182 save_addend = FALSE; 6183 6184 if (r == bfd_reloc_continue) 6185 r = elfNN_aarch64_final_link_relocate (howto, input_bfd, output_bfd, 6186 input_section, contents, rel, 6187 relocation, info, sec, 6188 h, &unresolved_reloc, 6189 save_addend, &addend, sym); 6190 6191 switch (elfNN_aarch64_bfd_reloc_from_type (r_type)) 6192 { 6193 case BFD_RELOC_AARCH64_TLSGD_ADD_LO12_NC: 6194 case BFD_RELOC_AARCH64_TLSGD_ADR_PAGE21: 6195 case BFD_RELOC_AARCH64_TLSGD_ADR_PREL21: 6196 case BFD_RELOC_AARCH64_TLSGD_MOVW_G0_NC: 6197 case BFD_RELOC_AARCH64_TLSGD_MOVW_G1: 6198 case BFD_RELOC_AARCH64_TLSLD_ADD_LO12_NC: 6199 case BFD_RELOC_AARCH64_TLSLD_ADR_PAGE21: 6200 case BFD_RELOC_AARCH64_TLSLD_ADR_PREL21: 6201 if (! symbol_got_offset_mark_p (input_bfd, h, r_symndx)) 6202 { 6203 bfd_boolean need_relocs = FALSE; 6204 bfd_byte *loc; 6205 int indx; 6206 bfd_vma off; 6207 6208 off = symbol_got_offset (input_bfd, h, r_symndx); 6209 indx = h && h->dynindx != -1 ? h->dynindx : 0; 6210 6211 need_relocs = 6212 (bfd_link_pic (info) || indx != 0) && 6213 (h == NULL 6214 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT 6215 || h->root.type != bfd_link_hash_undefweak); 6216 6217 BFD_ASSERT (globals->root.srelgot != NULL); 6218 6219 if (need_relocs) 6220 { 6221 Elf_Internal_Rela rela; 6222 rela.r_info = ELFNN_R_INFO (indx, AARCH64_R (TLS_DTPMOD)); 6223 rela.r_addend = 0; 6224 rela.r_offset = globals->root.sgot->output_section->vma + 6225 globals->root.sgot->output_offset + off; 6226 6227 6228 loc = globals->root.srelgot->contents; 6229 loc += globals->root.srelgot->reloc_count++ 6230 * RELOC_SIZE (htab); 6231 bfd_elfNN_swap_reloca_out (output_bfd, &rela, loc); 6232 6233 bfd_reloc_code_real_type real_type = 6234 elfNN_aarch64_bfd_reloc_from_type (r_type); 6235 6236 if (real_type == BFD_RELOC_AARCH64_TLSLD_ADR_PREL21 6237 || real_type == BFD_RELOC_AARCH64_TLSLD_ADR_PAGE21 6238 || real_type == BFD_RELOC_AARCH64_TLSLD_ADD_LO12_NC) 6239 { 6240 /* For local dynamic, don't generate DTPREL in any case. 6241 Initialize the DTPREL slot into zero, so we get module 6242 base address when invoke runtime TLS resolver. */ 6243 bfd_put_NN (output_bfd, 0, 6244 globals->root.sgot->contents + off 6245 + GOT_ENTRY_SIZE); 6246 } 6247 else if (indx == 0) 6248 { 6249 bfd_put_NN (output_bfd, 6250 relocation - dtpoff_base (info), 6251 globals->root.sgot->contents + off 6252 + GOT_ENTRY_SIZE); 6253 } 6254 else 6255 { 6256 /* This TLS symbol is global. We emit a 6257 relocation to fixup the tls offset at load 6258 time. */ 6259 rela.r_info = 6260 ELFNN_R_INFO (indx, AARCH64_R (TLS_DTPREL)); 6261 rela.r_addend = 0; 6262 rela.r_offset = 6263 (globals->root.sgot->output_section->vma 6264 + globals->root.sgot->output_offset + off 6265 + GOT_ENTRY_SIZE); 6266 6267 loc = globals->root.srelgot->contents; 6268 loc += globals->root.srelgot->reloc_count++ 6269 * RELOC_SIZE (globals); 6270 bfd_elfNN_swap_reloca_out (output_bfd, &rela, loc); 6271 bfd_put_NN (output_bfd, (bfd_vma) 0, 6272 globals->root.sgot->contents + off 6273 + GOT_ENTRY_SIZE); 6274 } 6275 } 6276 else 6277 { 6278 bfd_put_NN (output_bfd, (bfd_vma) 1, 6279 globals->root.sgot->contents + off); 6280 bfd_put_NN (output_bfd, 6281 relocation - dtpoff_base (info), 6282 globals->root.sgot->contents + off 6283 + GOT_ENTRY_SIZE); 6284 } 6285 6286 symbol_got_offset_mark (input_bfd, h, r_symndx); 6287 } 6288 break; 6289 6290 case BFD_RELOC_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21: 6291 case BFD_RELOC_AARCH64_TLSIE_LDNN_GOTTPREL_LO12_NC: 6292 case BFD_RELOC_AARCH64_TLSIE_LD_GOTTPREL_PREL19: 6293 case BFD_RELOC_AARCH64_TLSIE_MOVW_GOTTPREL_G0_NC: 6294 case BFD_RELOC_AARCH64_TLSIE_MOVW_GOTTPREL_G1: 6295 if (! symbol_got_offset_mark_p (input_bfd, h, r_symndx)) 6296 { 6297 bfd_boolean need_relocs = FALSE; 6298 bfd_byte *loc; 6299 int indx; 6300 bfd_vma off; 6301 6302 off = symbol_got_offset (input_bfd, h, r_symndx); 6303 6304 indx = h && h->dynindx != -1 ? h->dynindx : 0; 6305 6306 need_relocs = 6307 (bfd_link_pic (info) || indx != 0) && 6308 (h == NULL 6309 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT 6310 || h->root.type != bfd_link_hash_undefweak); 6311 6312 BFD_ASSERT (globals->root.srelgot != NULL); 6313 6314 if (need_relocs) 6315 { 6316 Elf_Internal_Rela rela; 6317 6318 if (indx == 0) 6319 rela.r_addend = relocation - dtpoff_base (info); 6320 else 6321 rela.r_addend = 0; 6322 6323 rela.r_info = ELFNN_R_INFO (indx, AARCH64_R (TLS_TPREL)); 6324 rela.r_offset = globals->root.sgot->output_section->vma + 6325 globals->root.sgot->output_offset + off; 6326 6327 loc = globals->root.srelgot->contents; 6328 loc += globals->root.srelgot->reloc_count++ 6329 * RELOC_SIZE (htab); 6330 6331 bfd_elfNN_swap_reloca_out (output_bfd, &rela, loc); 6332 6333 bfd_put_NN (output_bfd, rela.r_addend, 6334 globals->root.sgot->contents + off); 6335 } 6336 else 6337 bfd_put_NN (output_bfd, relocation - tpoff_base (info), 6338 globals->root.sgot->contents + off); 6339 6340 symbol_got_offset_mark (input_bfd, h, r_symndx); 6341 } 6342 break; 6343 6344 case BFD_RELOC_AARCH64_TLSDESC_ADD_LO12_NC: 6345 case BFD_RELOC_AARCH64_TLSDESC_ADR_PAGE21: 6346 case BFD_RELOC_AARCH64_TLSDESC_ADR_PREL21: 6347 case BFD_RELOC_AARCH64_TLSDESC_LDNN_LO12_NC: 6348 case BFD_RELOC_AARCH64_TLSDESC_LD_PREL19: 6349 case BFD_RELOC_AARCH64_TLSDESC_OFF_G0_NC: 6350 case BFD_RELOC_AARCH64_TLSDESC_OFF_G1: 6351 if (! symbol_tlsdesc_got_offset_mark_p (input_bfd, h, r_symndx)) 6352 { 6353 bfd_boolean need_relocs = FALSE; 6354 int indx = h && h->dynindx != -1 ? h->dynindx : 0; 6355 bfd_vma off = symbol_tlsdesc_got_offset (input_bfd, h, r_symndx); 6356 6357 need_relocs = (h == NULL 6358 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT 6359 || h->root.type != bfd_link_hash_undefweak); 6360 6361 BFD_ASSERT (globals->root.srelgot != NULL); 6362 BFD_ASSERT (globals->root.sgot != NULL); 6363 6364 if (need_relocs) 6365 { 6366 bfd_byte *loc; 6367 Elf_Internal_Rela rela; 6368 rela.r_info = ELFNN_R_INFO (indx, AARCH64_R (TLSDESC)); 6369 6370 rela.r_addend = 0; 6371 rela.r_offset = (globals->root.sgotplt->output_section->vma 6372 + globals->root.sgotplt->output_offset 6373 + off + globals->sgotplt_jump_table_size); 6374 6375 if (indx == 0) 6376 rela.r_addend = relocation - dtpoff_base (info); 6377 6378 /* Allocate the next available slot in the PLT reloc 6379 section to hold our R_AARCH64_TLSDESC, the next 6380 available slot is determined from reloc_count, 6381 which we step. But note, reloc_count was 6382 artifically moved down while allocating slots for 6383 real PLT relocs such that all of the PLT relocs 6384 will fit above the initial reloc_count and the 6385 extra stuff will fit below. */ 6386 loc = globals->root.srelplt->contents; 6387 loc += globals->root.srelplt->reloc_count++ 6388 * RELOC_SIZE (globals); 6389 6390 bfd_elfNN_swap_reloca_out (output_bfd, &rela, loc); 6391 6392 bfd_put_NN (output_bfd, (bfd_vma) 0, 6393 globals->root.sgotplt->contents + off + 6394 globals->sgotplt_jump_table_size); 6395 bfd_put_NN (output_bfd, (bfd_vma) 0, 6396 globals->root.sgotplt->contents + off + 6397 globals->sgotplt_jump_table_size + 6398 GOT_ENTRY_SIZE); 6399 } 6400 6401 symbol_tlsdesc_got_offset_mark (input_bfd, h, r_symndx); 6402 } 6403 break; 6404 default: 6405 break; 6406 } 6407 6408 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections 6409 because such sections are not SEC_ALLOC and thus ld.so will 6410 not process them. */ 6411 if (unresolved_reloc 6412 && !((input_section->flags & SEC_DEBUGGING) != 0 6413 && h->def_dynamic) 6414 && _bfd_elf_section_offset (output_bfd, info, input_section, 6415 +rel->r_offset) != (bfd_vma) - 1) 6416 { 6417 _bfd_error_handler 6418 /* xgettext:c-format */ 6419 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"), 6420 input_bfd, input_section, (long) rel->r_offset, howto->name, 6421 h->root.root.string); 6422 return FALSE; 6423 } 6424 6425 if (r != bfd_reloc_ok && r != bfd_reloc_continue) 6426 { 6427 bfd_reloc_code_real_type real_r_type 6428 = elfNN_aarch64_bfd_reloc_from_type (r_type); 6429 6430 switch (r) 6431 { 6432 case bfd_reloc_overflow: 6433 (*info->callbacks->reloc_overflow) 6434 (info, (h ? &h->root : NULL), name, howto->name, (bfd_vma) 0, 6435 input_bfd, input_section, rel->r_offset); 6436 if (real_r_type == BFD_RELOC_AARCH64_LD64_GOTPAGE_LO15 6437 || real_r_type == BFD_RELOC_AARCH64_LD32_GOTPAGE_LO14) 6438 { 6439 (*info->callbacks->warning) 6440 (info, 6441 _("Too many GOT entries for -fpic, " 6442 "please recompile with -fPIC"), 6443 name, input_bfd, input_section, rel->r_offset); 6444 return FALSE; 6445 } 6446 /* Overflow can occur when a variable is referenced with a type 6447 that has a larger alignment than the type with which it was 6448 declared. eg: 6449 file1.c: extern int foo; int a (void) { return foo; } 6450 file2.c: char bar, foo, baz; 6451 If the variable is placed into a data section at an offset 6452 that is incompatible with the larger alignment requirement 6453 overflow will occur. (Strictly speaking this is not overflow 6454 but rather an alignment problem, but the bfd_reloc_ error 6455 enum does not have a value to cover that situation). 6456 6457 Try to catch this situation here and provide a more helpful 6458 error message to the user. */ 6459 if (addend & ((1 << howto->rightshift) - 1) 6460 /* FIXME: Are we testing all of the appropriate reloc 6461 types here ? */ 6462 && (real_r_type == BFD_RELOC_AARCH64_LD_LO19_PCREL 6463 || real_r_type == BFD_RELOC_AARCH64_LDST16_LO12 6464 || real_r_type == BFD_RELOC_AARCH64_LDST32_LO12 6465 || real_r_type == BFD_RELOC_AARCH64_LDST64_LO12 6466 || real_r_type == BFD_RELOC_AARCH64_LDST128_LO12)) 6467 { 6468 info->callbacks->warning 6469 (info, _("One possible cause of this error is that the \ 6470symbol is being referenced in the indicated code as if it had a larger \ 6471alignment than was declared where it was defined."), 6472 name, input_bfd, input_section, rel->r_offset); 6473 } 6474 break; 6475 6476 case bfd_reloc_undefined: 6477 (*info->callbacks->undefined_symbol) 6478 (info, name, input_bfd, input_section, rel->r_offset, TRUE); 6479 break; 6480 6481 case bfd_reloc_outofrange: 6482 error_message = _("out of range"); 6483 goto common_error; 6484 6485 case bfd_reloc_notsupported: 6486 error_message = _("unsupported relocation"); 6487 goto common_error; 6488 6489 case bfd_reloc_dangerous: 6490 /* error_message should already be set. */ 6491 goto common_error; 6492 6493 default: 6494 error_message = _("unknown error"); 6495 /* Fall through. */ 6496 6497 common_error: 6498 BFD_ASSERT (error_message != NULL); 6499 (*info->callbacks->reloc_dangerous) 6500 (info, error_message, input_bfd, input_section, rel->r_offset); 6501 break; 6502 } 6503 } 6504 6505 if (!save_addend) 6506 addend = 0; 6507 } 6508 6509 return TRUE; 6510} 6511 6512/* Set the right machine number. */ 6513 6514static bfd_boolean 6515elfNN_aarch64_object_p (bfd *abfd) 6516{ 6517#if ARCH_SIZE == 32 6518 bfd_default_set_arch_mach (abfd, bfd_arch_aarch64, bfd_mach_aarch64_ilp32); 6519#else 6520 bfd_default_set_arch_mach (abfd, bfd_arch_aarch64, bfd_mach_aarch64); 6521#endif 6522 return TRUE; 6523} 6524 6525/* Function to keep AArch64 specific flags in the ELF header. */ 6526 6527static bfd_boolean 6528elfNN_aarch64_set_private_flags (bfd *abfd, flagword flags) 6529{ 6530 if (elf_flags_init (abfd) && elf_elfheader (abfd)->e_flags != flags) 6531 { 6532 } 6533 else 6534 { 6535 elf_elfheader (abfd)->e_flags = flags; 6536 elf_flags_init (abfd) = TRUE; 6537 } 6538 6539 return TRUE; 6540} 6541 6542/* Merge backend specific data from an object file to the output 6543 object file when linking. */ 6544 6545static bfd_boolean 6546elfNN_aarch64_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info) 6547{ 6548 bfd *obfd = info->output_bfd; 6549 flagword out_flags; 6550 flagword in_flags; 6551 bfd_boolean flags_compatible = TRUE; 6552 asection *sec; 6553 6554 /* Check if we have the same endianess. */ 6555 if (!_bfd_generic_verify_endian_match (ibfd, info)) 6556 return FALSE; 6557 6558 if (!is_aarch64_elf (ibfd) || !is_aarch64_elf (obfd)) 6559 return TRUE; 6560 6561 /* The input BFD must have had its flags initialised. */ 6562 /* The following seems bogus to me -- The flags are initialized in 6563 the assembler but I don't think an elf_flags_init field is 6564 written into the object. */ 6565 /* BFD_ASSERT (elf_flags_init (ibfd)); */ 6566 6567 in_flags = elf_elfheader (ibfd)->e_flags; 6568 out_flags = elf_elfheader (obfd)->e_flags; 6569 6570 if (!elf_flags_init (obfd)) 6571 { 6572 /* If the input is the default architecture and had the default 6573 flags then do not bother setting the flags for the output 6574 architecture, instead allow future merges to do this. If no 6575 future merges ever set these flags then they will retain their 6576 uninitialised values, which surprise surprise, correspond 6577 to the default values. */ 6578 if (bfd_get_arch_info (ibfd)->the_default 6579 && elf_elfheader (ibfd)->e_flags == 0) 6580 return TRUE; 6581 6582 elf_flags_init (obfd) = TRUE; 6583 elf_elfheader (obfd)->e_flags = in_flags; 6584 6585 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd) 6586 && bfd_get_arch_info (obfd)->the_default) 6587 return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), 6588 bfd_get_mach (ibfd)); 6589 6590 return TRUE; 6591 } 6592 6593 /* Identical flags must be compatible. */ 6594 if (in_flags == out_flags) 6595 return TRUE; 6596 6597 /* Check to see if the input BFD actually contains any sections. If 6598 not, its flags may not have been initialised either, but it 6599 cannot actually cause any incompatiblity. Do not short-circuit 6600 dynamic objects; their section list may be emptied by 6601 elf_link_add_object_symbols. 6602 6603 Also check to see if there are no code sections in the input. 6604 In this case there is no need to check for code specific flags. 6605 XXX - do we need to worry about floating-point format compatability 6606 in data sections ? */ 6607 if (!(ibfd->flags & DYNAMIC)) 6608 { 6609 bfd_boolean null_input_bfd = TRUE; 6610 bfd_boolean only_data_sections = TRUE; 6611 6612 for (sec = ibfd->sections; sec != NULL; sec = sec->next) 6613 { 6614 if ((bfd_get_section_flags (ibfd, sec) 6615 & (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS)) 6616 == (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS)) 6617 only_data_sections = FALSE; 6618 6619 null_input_bfd = FALSE; 6620 break; 6621 } 6622 6623 if (null_input_bfd || only_data_sections) 6624 return TRUE; 6625 } 6626 6627 return flags_compatible; 6628} 6629 6630/* Display the flags field. */ 6631 6632static bfd_boolean 6633elfNN_aarch64_print_private_bfd_data (bfd *abfd, void *ptr) 6634{ 6635 FILE *file = (FILE *) ptr; 6636 unsigned long flags; 6637 6638 BFD_ASSERT (abfd != NULL && ptr != NULL); 6639 6640 /* Print normal ELF private data. */ 6641 _bfd_elf_print_private_bfd_data (abfd, ptr); 6642 6643 flags = elf_elfheader (abfd)->e_flags; 6644 /* Ignore init flag - it may not be set, despite the flags field 6645 containing valid data. */ 6646 6647 /* xgettext:c-format */ 6648 fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags); 6649 6650 if (flags) 6651 fprintf (file, _("<Unrecognised flag bits set>")); 6652 6653 fputc ('\n', file); 6654 6655 return TRUE; 6656} 6657 6658/* Update the got entry reference counts for the section being removed. */ 6659 6660static bfd_boolean 6661elfNN_aarch64_gc_sweep_hook (bfd *abfd, 6662 struct bfd_link_info *info, 6663 asection *sec, 6664 const Elf_Internal_Rela * relocs) 6665{ 6666 struct elf_aarch64_link_hash_table *htab; 6667 Elf_Internal_Shdr *symtab_hdr; 6668 struct elf_link_hash_entry **sym_hashes; 6669 struct elf_aarch64_local_symbol *locals; 6670 const Elf_Internal_Rela *rel, *relend; 6671 6672 if (bfd_link_relocatable (info)) 6673 return TRUE; 6674 6675 htab = elf_aarch64_hash_table (info); 6676 6677 if (htab == NULL) 6678 return FALSE; 6679 6680 elf_section_data (sec)->local_dynrel = NULL; 6681 6682 symtab_hdr = &elf_symtab_hdr (abfd); 6683 sym_hashes = elf_sym_hashes (abfd); 6684 6685 locals = elf_aarch64_locals (abfd); 6686 6687 relend = relocs + sec->reloc_count; 6688 for (rel = relocs; rel < relend; rel++) 6689 { 6690 unsigned long r_symndx; 6691 unsigned int r_type; 6692 struct elf_link_hash_entry *h = NULL; 6693 6694 r_symndx = ELFNN_R_SYM (rel->r_info); 6695 6696 if (r_symndx >= symtab_hdr->sh_info) 6697 { 6698 6699 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 6700 while (h->root.type == bfd_link_hash_indirect 6701 || h->root.type == bfd_link_hash_warning) 6702 h = (struct elf_link_hash_entry *) h->root.u.i.link; 6703 } 6704 else 6705 { 6706 Elf_Internal_Sym *isym; 6707 6708 /* A local symbol. */ 6709 isym = bfd_sym_from_r_symndx (&htab->sym_cache, 6710 abfd, r_symndx); 6711 6712 /* Check relocation against local STT_GNU_IFUNC symbol. */ 6713 if (isym != NULL 6714 && ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC) 6715 { 6716 h = elfNN_aarch64_get_local_sym_hash (htab, abfd, rel, FALSE); 6717 if (h == NULL) 6718 abort (); 6719 } 6720 } 6721 6722 if (h) 6723 { 6724 struct elf_aarch64_link_hash_entry *eh; 6725 struct elf_dyn_relocs **pp; 6726 struct elf_dyn_relocs *p; 6727 6728 eh = (struct elf_aarch64_link_hash_entry *) h; 6729 6730 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next) 6731 if (p->sec == sec) 6732 { 6733 /* Everything must go for SEC. */ 6734 *pp = p->next; 6735 break; 6736 } 6737 } 6738 6739 r_type = ELFNN_R_TYPE (rel->r_info); 6740 switch (aarch64_tls_transition (abfd,info, r_type, h ,r_symndx)) 6741 { 6742 case BFD_RELOC_AARCH64_ADR_GOT_PAGE: 6743 case BFD_RELOC_AARCH64_GOT_LD_PREL19: 6744 case BFD_RELOC_AARCH64_LD32_GOTPAGE_LO14: 6745 case BFD_RELOC_AARCH64_LD32_GOT_LO12_NC: 6746 case BFD_RELOC_AARCH64_LD64_GOTOFF_LO15: 6747 case BFD_RELOC_AARCH64_LD64_GOTPAGE_LO15: 6748 case BFD_RELOC_AARCH64_LD64_GOT_LO12_NC: 6749 case BFD_RELOC_AARCH64_MOVW_GOTOFF_G0_NC: 6750 case BFD_RELOC_AARCH64_MOVW_GOTOFF_G1: 6751 case BFD_RELOC_AARCH64_TLSDESC_ADD_LO12_NC: 6752 case BFD_RELOC_AARCH64_TLSDESC_ADR_PAGE21: 6753 case BFD_RELOC_AARCH64_TLSDESC_ADR_PREL21: 6754 case BFD_RELOC_AARCH64_TLSDESC_LD32_LO12_NC: 6755 case BFD_RELOC_AARCH64_TLSDESC_LD64_LO12_NC: 6756 case BFD_RELOC_AARCH64_TLSDESC_LD_PREL19: 6757 case BFD_RELOC_AARCH64_TLSDESC_OFF_G0_NC: 6758 case BFD_RELOC_AARCH64_TLSDESC_OFF_G1: 6759 case BFD_RELOC_AARCH64_TLSGD_ADD_LO12_NC: 6760 case BFD_RELOC_AARCH64_TLSGD_ADR_PAGE21: 6761 case BFD_RELOC_AARCH64_TLSGD_ADR_PREL21: 6762 case BFD_RELOC_AARCH64_TLSGD_MOVW_G0_NC: 6763 case BFD_RELOC_AARCH64_TLSGD_MOVW_G1: 6764 case BFD_RELOC_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21: 6765 case BFD_RELOC_AARCH64_TLSIE_LD32_GOTTPREL_LO12_NC: 6766 case BFD_RELOC_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC: 6767 case BFD_RELOC_AARCH64_TLSIE_LD_GOTTPREL_PREL19: 6768 case BFD_RELOC_AARCH64_TLSIE_MOVW_GOTTPREL_G0_NC: 6769 case BFD_RELOC_AARCH64_TLSIE_MOVW_GOTTPREL_G1: 6770 case BFD_RELOC_AARCH64_TLSLD_ADD_LO12_NC: 6771 case BFD_RELOC_AARCH64_TLSLD_ADR_PAGE21: 6772 case BFD_RELOC_AARCH64_TLSLD_ADR_PREL21: 6773 if (h != NULL) 6774 { 6775 if (h->got.refcount > 0) 6776 h->got.refcount -= 1; 6777 6778 if (h->type == STT_GNU_IFUNC) 6779 { 6780 if (h->plt.refcount > 0) 6781 h->plt.refcount -= 1; 6782 } 6783 } 6784 else if (locals != NULL) 6785 { 6786 if (locals[r_symndx].got_refcount > 0) 6787 locals[r_symndx].got_refcount -= 1; 6788 } 6789 break; 6790 6791 case BFD_RELOC_AARCH64_CALL26: 6792 case BFD_RELOC_AARCH64_JUMP26: 6793 /* If this is a local symbol then we resolve it 6794 directly without creating a PLT entry. */ 6795 if (h == NULL) 6796 continue; 6797 6798 if (h->plt.refcount > 0) 6799 h->plt.refcount -= 1; 6800 break; 6801 6802 case BFD_RELOC_AARCH64_ADR_HI21_NC_PCREL: 6803 case BFD_RELOC_AARCH64_ADR_HI21_PCREL: 6804 case BFD_RELOC_AARCH64_ADR_LO21_PCREL: 6805 case BFD_RELOC_AARCH64_MOVW_G0_NC: 6806 case BFD_RELOC_AARCH64_MOVW_G1_NC: 6807 case BFD_RELOC_AARCH64_MOVW_G2_NC: 6808 case BFD_RELOC_AARCH64_MOVW_G3: 6809 case BFD_RELOC_AARCH64_NN: 6810 if (h != NULL && bfd_link_executable (info)) 6811 { 6812 if (h->plt.refcount > 0) 6813 h->plt.refcount -= 1; 6814 } 6815 break; 6816 6817 default: 6818 break; 6819 } 6820 } 6821 6822 return TRUE; 6823} 6824 6825/* Adjust a symbol defined by a dynamic object and referenced by a 6826 regular object. The current definition is in some section of the 6827 dynamic object, but we're not including those sections. We have to 6828 change the definition to something the rest of the link can 6829 understand. */ 6830 6831static bfd_boolean 6832elfNN_aarch64_adjust_dynamic_symbol (struct bfd_link_info *info, 6833 struct elf_link_hash_entry *h) 6834{ 6835 struct elf_aarch64_link_hash_table *htab; 6836 asection *s, *srel; 6837 6838 /* If this is a function, put it in the procedure linkage table. We 6839 will fill in the contents of the procedure linkage table later, 6840 when we know the address of the .got section. */ 6841 if (h->type == STT_FUNC || h->type == STT_GNU_IFUNC || h->needs_plt) 6842 { 6843 if (h->plt.refcount <= 0 6844 || (h->type != STT_GNU_IFUNC 6845 && (SYMBOL_CALLS_LOCAL (info, h) 6846 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT 6847 && h->root.type == bfd_link_hash_undefweak)))) 6848 { 6849 /* This case can occur if we saw a CALL26 reloc in 6850 an input file, but the symbol wasn't referred to 6851 by a dynamic object or all references were 6852 garbage collected. In which case we can end up 6853 resolving. */ 6854 h->plt.offset = (bfd_vma) - 1; 6855 h->needs_plt = 0; 6856 } 6857 6858 return TRUE; 6859 } 6860 else 6861 /* Otherwise, reset to -1. */ 6862 h->plt.offset = (bfd_vma) - 1; 6863 6864 6865 /* If this is a weak symbol, and there is a real definition, the 6866 processor independent code will have arranged for us to see the 6867 real definition first, and we can just use the same value. */ 6868 if (h->u.weakdef != NULL) 6869 { 6870 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined 6871 || h->u.weakdef->root.type == bfd_link_hash_defweak); 6872 h->root.u.def.section = h->u.weakdef->root.u.def.section; 6873 h->root.u.def.value = h->u.weakdef->root.u.def.value; 6874 if (ELIMINATE_COPY_RELOCS || info->nocopyreloc) 6875 h->non_got_ref = h->u.weakdef->non_got_ref; 6876 return TRUE; 6877 } 6878 6879 /* If we are creating a shared library, we must presume that the 6880 only references to the symbol are via the global offset table. 6881 For such cases we need not do anything here; the relocations will 6882 be handled correctly by relocate_section. */ 6883 if (bfd_link_pic (info)) 6884 return TRUE; 6885 6886 /* If there are no references to this symbol that do not use the 6887 GOT, we don't need to generate a copy reloc. */ 6888 if (!h->non_got_ref) 6889 return TRUE; 6890 6891 /* If -z nocopyreloc was given, we won't generate them either. */ 6892 if (info->nocopyreloc) 6893 { 6894 h->non_got_ref = 0; 6895 return TRUE; 6896 } 6897 6898 /* We must allocate the symbol in our .dynbss section, which will 6899 become part of the .bss section of the executable. There will be 6900 an entry for this symbol in the .dynsym section. The dynamic 6901 object will contain position independent code, so all references 6902 from the dynamic object to this symbol will go through the global 6903 offset table. The dynamic linker will use the .dynsym entry to 6904 determine the address it must put in the global offset table, so 6905 both the dynamic object and the regular object will refer to the 6906 same memory location for the variable. */ 6907 6908 htab = elf_aarch64_hash_table (info); 6909 6910 /* We must generate a R_AARCH64_COPY reloc to tell the dynamic linker 6911 to copy the initial value out of the dynamic object and into the 6912 runtime process image. */ 6913 if ((h->root.u.def.section->flags & SEC_READONLY) != 0) 6914 { 6915 s = htab->root.sdynrelro; 6916 srel = htab->root.sreldynrelro; 6917 } 6918 else 6919 { 6920 s = htab->root.sdynbss; 6921 srel = htab->root.srelbss; 6922 } 6923 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0) 6924 { 6925 srel->size += RELOC_SIZE (htab); 6926 h->needs_copy = 1; 6927 } 6928 6929 return _bfd_elf_adjust_dynamic_copy (info, h, s); 6930 6931} 6932 6933static bfd_boolean 6934elfNN_aarch64_allocate_local_symbols (bfd *abfd, unsigned number) 6935{ 6936 struct elf_aarch64_local_symbol *locals; 6937 locals = elf_aarch64_locals (abfd); 6938 if (locals == NULL) 6939 { 6940 locals = (struct elf_aarch64_local_symbol *) 6941 bfd_zalloc (abfd, number * sizeof (struct elf_aarch64_local_symbol)); 6942 if (locals == NULL) 6943 return FALSE; 6944 elf_aarch64_locals (abfd) = locals; 6945 } 6946 return TRUE; 6947} 6948 6949/* Create the .got section to hold the global offset table. */ 6950 6951static bfd_boolean 6952aarch64_elf_create_got_section (bfd *abfd, struct bfd_link_info *info) 6953{ 6954 const struct elf_backend_data *bed = get_elf_backend_data (abfd); 6955 flagword flags; 6956 asection *s; 6957 struct elf_link_hash_entry *h; 6958 struct elf_link_hash_table *htab = elf_hash_table (info); 6959 6960 /* This function may be called more than once. */ 6961 if (htab->sgot != NULL) 6962 return TRUE; 6963 6964 flags = bed->dynamic_sec_flags; 6965 6966 s = bfd_make_section_anyway_with_flags (abfd, 6967 (bed->rela_plts_and_copies_p 6968 ? ".rela.got" : ".rel.got"), 6969 (bed->dynamic_sec_flags 6970 | SEC_READONLY)); 6971 if (s == NULL 6972 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align)) 6973 return FALSE; 6974 htab->srelgot = s; 6975 6976 s = bfd_make_section_anyway_with_flags (abfd, ".got", flags); 6977 if (s == NULL 6978 || !bfd_set_section_alignment (abfd, s, bed->s->log_file_align)) 6979 return FALSE; 6980 htab->sgot = s; 6981 htab->sgot->size += GOT_ENTRY_SIZE; 6982 6983 if (bed->want_got_sym) 6984 { 6985 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got 6986 (or .got.plt) section. We don't do this in the linker script 6987 because we don't want to define the symbol if we are not creating 6988 a global offset table. */ 6989 h = _bfd_elf_define_linkage_sym (abfd, info, s, 6990 "_GLOBAL_OFFSET_TABLE_"); 6991 elf_hash_table (info)->hgot = h; 6992 if (h == NULL) 6993 return FALSE; 6994 } 6995 6996 if (bed->want_got_plt) 6997 { 6998 s = bfd_make_section_anyway_with_flags (abfd, ".got.plt", flags); 6999 if (s == NULL 7000 || !bfd_set_section_alignment (abfd, s, 7001 bed->s->log_file_align)) 7002 return FALSE; 7003 htab->sgotplt = s; 7004 } 7005 7006 /* The first bit of the global offset table is the header. */ 7007 s->size += bed->got_header_size; 7008 7009 return TRUE; 7010} 7011 7012/* Look through the relocs for a section during the first phase. */ 7013 7014static bfd_boolean 7015elfNN_aarch64_check_relocs (bfd *abfd, struct bfd_link_info *info, 7016 asection *sec, const Elf_Internal_Rela *relocs) 7017{ 7018 Elf_Internal_Shdr *symtab_hdr; 7019 struct elf_link_hash_entry **sym_hashes; 7020 const Elf_Internal_Rela *rel; 7021 const Elf_Internal_Rela *rel_end; 7022 asection *sreloc; 7023 7024 struct elf_aarch64_link_hash_table *htab; 7025 7026 if (bfd_link_relocatable (info)) 7027 return TRUE; 7028 7029 BFD_ASSERT (is_aarch64_elf (abfd)); 7030 7031 htab = elf_aarch64_hash_table (info); 7032 sreloc = NULL; 7033 7034 symtab_hdr = &elf_symtab_hdr (abfd); 7035 sym_hashes = elf_sym_hashes (abfd); 7036 7037 rel_end = relocs + sec->reloc_count; 7038 for (rel = relocs; rel < rel_end; rel++) 7039 { 7040 struct elf_link_hash_entry *h; 7041 unsigned long r_symndx; 7042 unsigned int r_type; 7043 bfd_reloc_code_real_type bfd_r_type; 7044 Elf_Internal_Sym *isym; 7045 7046 r_symndx = ELFNN_R_SYM (rel->r_info); 7047 r_type = ELFNN_R_TYPE (rel->r_info); 7048 7049 if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr)) 7050 { 7051 /* xgettext:c-format */ 7052 _bfd_error_handler (_("%B: bad symbol index: %d"), abfd, r_symndx); 7053 return FALSE; 7054 } 7055 7056 if (r_symndx < symtab_hdr->sh_info) 7057 { 7058 /* A local symbol. */ 7059 isym = bfd_sym_from_r_symndx (&htab->sym_cache, 7060 abfd, r_symndx); 7061 if (isym == NULL) 7062 return FALSE; 7063 7064 /* Check relocation against local STT_GNU_IFUNC symbol. */ 7065 if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC) 7066 { 7067 h = elfNN_aarch64_get_local_sym_hash (htab, abfd, rel, 7068 TRUE); 7069 if (h == NULL) 7070 return FALSE; 7071 7072 /* Fake a STT_GNU_IFUNC symbol. */ 7073 h->type = STT_GNU_IFUNC; 7074 h->def_regular = 1; 7075 h->ref_regular = 1; 7076 h->forced_local = 1; 7077 h->root.type = bfd_link_hash_defined; 7078 } 7079 else 7080 h = NULL; 7081 } 7082 else 7083 { 7084 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 7085 while (h->root.type == bfd_link_hash_indirect 7086 || h->root.type == bfd_link_hash_warning) 7087 h = (struct elf_link_hash_entry *) h->root.u.i.link; 7088 7089 /* PR15323, ref flags aren't set for references in the same 7090 object. */ 7091 h->root.non_ir_ref = 1; 7092 } 7093 7094 /* Could be done earlier, if h were already available. */ 7095 bfd_r_type = aarch64_tls_transition (abfd, info, r_type, h, r_symndx); 7096 7097 if (h != NULL) 7098 { 7099 /* If a relocation refers to _GLOBAL_OFFSET_TABLE_, create the .got. 7100 This shows up in particular in an R_AARCH64_PREL64 in large model 7101 when calculating the pc-relative address to .got section which is 7102 used to initialize the gp register. */ 7103 if (h->root.root.string 7104 && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0) 7105 { 7106 if (htab->root.dynobj == NULL) 7107 htab->root.dynobj = abfd; 7108 7109 if (! aarch64_elf_create_got_section (htab->root.dynobj, info)) 7110 return FALSE; 7111 7112 BFD_ASSERT (h == htab->root.hgot); 7113 } 7114 7115 /* Create the ifunc sections for static executables. If we 7116 never see an indirect function symbol nor we are building 7117 a static executable, those sections will be empty and 7118 won't appear in output. */ 7119 switch (bfd_r_type) 7120 { 7121 default: 7122 break; 7123 7124 case BFD_RELOC_AARCH64_ADD_LO12: 7125 case BFD_RELOC_AARCH64_ADR_GOT_PAGE: 7126 case BFD_RELOC_AARCH64_ADR_HI21_PCREL: 7127 case BFD_RELOC_AARCH64_CALL26: 7128 case BFD_RELOC_AARCH64_GOT_LD_PREL19: 7129 case BFD_RELOC_AARCH64_JUMP26: 7130 case BFD_RELOC_AARCH64_LD32_GOTPAGE_LO14: 7131 case BFD_RELOC_AARCH64_LD32_GOT_LO12_NC: 7132 case BFD_RELOC_AARCH64_LD64_GOTOFF_LO15: 7133 case BFD_RELOC_AARCH64_LD64_GOTPAGE_LO15: 7134 case BFD_RELOC_AARCH64_LD64_GOT_LO12_NC: 7135 case BFD_RELOC_AARCH64_MOVW_GOTOFF_G0_NC: 7136 case BFD_RELOC_AARCH64_MOVW_GOTOFF_G1: 7137 case BFD_RELOC_AARCH64_NN: 7138 if (htab->root.dynobj == NULL) 7139 htab->root.dynobj = abfd; 7140 if (!_bfd_elf_create_ifunc_sections (htab->root.dynobj, info)) 7141 return FALSE; 7142 break; 7143 } 7144 7145 /* It is referenced by a non-shared object. */ 7146 h->ref_regular = 1; 7147 h->root.non_ir_ref = 1; 7148 } 7149 7150 switch (bfd_r_type) 7151 { 7152 case BFD_RELOC_AARCH64_NN: 7153 7154 /* We don't need to handle relocs into sections not going into 7155 the "real" output. */ 7156 if ((sec->flags & SEC_ALLOC) == 0) 7157 break; 7158 7159 if (h != NULL) 7160 { 7161 if (!bfd_link_pic (info)) 7162 h->non_got_ref = 1; 7163 7164 h->plt.refcount += 1; 7165 h->pointer_equality_needed = 1; 7166 } 7167 7168 /* No need to do anything if we're not creating a shared 7169 object. */ 7170 if (! bfd_link_pic (info)) 7171 break; 7172 7173 { 7174 struct elf_dyn_relocs *p; 7175 struct elf_dyn_relocs **head; 7176 7177 /* We must copy these reloc types into the output file. 7178 Create a reloc section in dynobj and make room for 7179 this reloc. */ 7180 if (sreloc == NULL) 7181 { 7182 if (htab->root.dynobj == NULL) 7183 htab->root.dynobj = abfd; 7184 7185 sreloc = _bfd_elf_make_dynamic_reloc_section 7186 (sec, htab->root.dynobj, LOG_FILE_ALIGN, abfd, /*rela? */ TRUE); 7187 7188 if (sreloc == NULL) 7189 return FALSE; 7190 } 7191 7192 /* If this is a global symbol, we count the number of 7193 relocations we need for this symbol. */ 7194 if (h != NULL) 7195 { 7196 struct elf_aarch64_link_hash_entry *eh; 7197 eh = (struct elf_aarch64_link_hash_entry *) h; 7198 head = &eh->dyn_relocs; 7199 } 7200 else 7201 { 7202 /* Track dynamic relocs needed for local syms too. 7203 We really need local syms available to do this 7204 easily. Oh well. */ 7205 7206 asection *s; 7207 void **vpp; 7208 7209 isym = bfd_sym_from_r_symndx (&htab->sym_cache, 7210 abfd, r_symndx); 7211 if (isym == NULL) 7212 return FALSE; 7213 7214 s = bfd_section_from_elf_index (abfd, isym->st_shndx); 7215 if (s == NULL) 7216 s = sec; 7217 7218 /* Beware of type punned pointers vs strict aliasing 7219 rules. */ 7220 vpp = &(elf_section_data (s)->local_dynrel); 7221 head = (struct elf_dyn_relocs **) vpp; 7222 } 7223 7224 p = *head; 7225 if (p == NULL || p->sec != sec) 7226 { 7227 bfd_size_type amt = sizeof *p; 7228 p = ((struct elf_dyn_relocs *) 7229 bfd_zalloc (htab->root.dynobj, amt)); 7230 if (p == NULL) 7231 return FALSE; 7232 p->next = *head; 7233 *head = p; 7234 p->sec = sec; 7235 } 7236 7237 p->count += 1; 7238 7239 } 7240 break; 7241 7242 /* RR: We probably want to keep a consistency check that 7243 there are no dangling GOT_PAGE relocs. */ 7244 case BFD_RELOC_AARCH64_ADR_GOT_PAGE: 7245 case BFD_RELOC_AARCH64_GOT_LD_PREL19: 7246 case BFD_RELOC_AARCH64_LD32_GOTPAGE_LO14: 7247 case BFD_RELOC_AARCH64_LD32_GOT_LO12_NC: 7248 case BFD_RELOC_AARCH64_LD64_GOTOFF_LO15: 7249 case BFD_RELOC_AARCH64_LD64_GOTPAGE_LO15: 7250 case BFD_RELOC_AARCH64_LD64_GOT_LO12_NC: 7251 case BFD_RELOC_AARCH64_MOVW_GOTOFF_G0_NC: 7252 case BFD_RELOC_AARCH64_MOVW_GOTOFF_G1: 7253 case BFD_RELOC_AARCH64_TLSDESC_ADD_LO12_NC: 7254 case BFD_RELOC_AARCH64_TLSDESC_ADR_PAGE21: 7255 case BFD_RELOC_AARCH64_TLSDESC_ADR_PREL21: 7256 case BFD_RELOC_AARCH64_TLSDESC_LD32_LO12_NC: 7257 case BFD_RELOC_AARCH64_TLSDESC_LD64_LO12_NC: 7258 case BFD_RELOC_AARCH64_TLSDESC_LD_PREL19: 7259 case BFD_RELOC_AARCH64_TLSDESC_OFF_G0_NC: 7260 case BFD_RELOC_AARCH64_TLSDESC_OFF_G1: 7261 case BFD_RELOC_AARCH64_TLSGD_ADD_LO12_NC: 7262 case BFD_RELOC_AARCH64_TLSGD_ADR_PAGE21: 7263 case BFD_RELOC_AARCH64_TLSGD_ADR_PREL21: 7264 case BFD_RELOC_AARCH64_TLSGD_MOVW_G0_NC: 7265 case BFD_RELOC_AARCH64_TLSGD_MOVW_G1: 7266 case BFD_RELOC_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21: 7267 case BFD_RELOC_AARCH64_TLSIE_LD32_GOTTPREL_LO12_NC: 7268 case BFD_RELOC_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC: 7269 case BFD_RELOC_AARCH64_TLSIE_LD_GOTTPREL_PREL19: 7270 case BFD_RELOC_AARCH64_TLSIE_MOVW_GOTTPREL_G0_NC: 7271 case BFD_RELOC_AARCH64_TLSIE_MOVW_GOTTPREL_G1: 7272 case BFD_RELOC_AARCH64_TLSLD_ADD_LO12_NC: 7273 case BFD_RELOC_AARCH64_TLSLD_ADR_PAGE21: 7274 case BFD_RELOC_AARCH64_TLSLD_ADR_PREL21: 7275 case BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G1: 7276 case BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G1_NC: 7277 case BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G2: 7278 { 7279 unsigned got_type; 7280 unsigned old_got_type; 7281 7282 got_type = aarch64_reloc_got_type (bfd_r_type); 7283 7284 if (h) 7285 { 7286 h->got.refcount += 1; 7287 old_got_type = elf_aarch64_hash_entry (h)->got_type; 7288 } 7289 else 7290 { 7291 struct elf_aarch64_local_symbol *locals; 7292 7293 if (!elfNN_aarch64_allocate_local_symbols 7294 (abfd, symtab_hdr->sh_info)) 7295 return FALSE; 7296 7297 locals = elf_aarch64_locals (abfd); 7298 BFD_ASSERT (r_symndx < symtab_hdr->sh_info); 7299 locals[r_symndx].got_refcount += 1; 7300 old_got_type = locals[r_symndx].got_type; 7301 } 7302 7303 /* If a variable is accessed with both general dynamic TLS 7304 methods, two slots may be created. */ 7305 if (GOT_TLS_GD_ANY_P (old_got_type) && GOT_TLS_GD_ANY_P (got_type)) 7306 got_type |= old_got_type; 7307 7308 /* We will already have issued an error message if there 7309 is a TLS/non-TLS mismatch, based on the symbol type. 7310 So just combine any TLS types needed. */ 7311 if (old_got_type != GOT_UNKNOWN && old_got_type != GOT_NORMAL 7312 && got_type != GOT_NORMAL) 7313 got_type |= old_got_type; 7314 7315 /* If the symbol is accessed by both IE and GD methods, we 7316 are able to relax. Turn off the GD flag, without 7317 messing up with any other kind of TLS types that may be 7318 involved. */ 7319 if ((got_type & GOT_TLS_IE) && GOT_TLS_GD_ANY_P (got_type)) 7320 got_type &= ~ (GOT_TLSDESC_GD | GOT_TLS_GD); 7321 7322 if (old_got_type != got_type) 7323 { 7324 if (h != NULL) 7325 elf_aarch64_hash_entry (h)->got_type = got_type; 7326 else 7327 { 7328 struct elf_aarch64_local_symbol *locals; 7329 locals = elf_aarch64_locals (abfd); 7330 BFD_ASSERT (r_symndx < symtab_hdr->sh_info); 7331 locals[r_symndx].got_type = got_type; 7332 } 7333 } 7334 7335 if (htab->root.dynobj == NULL) 7336 htab->root.dynobj = abfd; 7337 if (! aarch64_elf_create_got_section (htab->root.dynobj, info)) 7338 return FALSE; 7339 break; 7340 } 7341 7342 case BFD_RELOC_AARCH64_MOVW_G0_NC: 7343 case BFD_RELOC_AARCH64_MOVW_G1_NC: 7344 case BFD_RELOC_AARCH64_MOVW_G2_NC: 7345 case BFD_RELOC_AARCH64_MOVW_G3: 7346 if (bfd_link_pic (info)) 7347 { 7348 int howto_index = bfd_r_type - BFD_RELOC_AARCH64_RELOC_START; 7349 _bfd_error_handler 7350 /* xgettext:c-format */ 7351 (_("%B: relocation %s against `%s' can not be used when making " 7352 "a shared object; recompile with -fPIC"), 7353 abfd, elfNN_aarch64_howto_table[howto_index].name, 7354 (h) ? h->root.root.string : "a local symbol"); 7355 bfd_set_error (bfd_error_bad_value); 7356 return FALSE; 7357 } 7358 /* Fall through. */ 7359 7360 case BFD_RELOC_AARCH64_ADR_HI21_NC_PCREL: 7361 case BFD_RELOC_AARCH64_ADR_HI21_PCREL: 7362 case BFD_RELOC_AARCH64_ADR_LO21_PCREL: 7363 if (h != NULL && bfd_link_executable (info)) 7364 { 7365 /* If this reloc is in a read-only section, we might 7366 need a copy reloc. We can't check reliably at this 7367 stage whether the section is read-only, as input 7368 sections have not yet been mapped to output sections. 7369 Tentatively set the flag for now, and correct in 7370 adjust_dynamic_symbol. */ 7371 h->non_got_ref = 1; 7372 h->plt.refcount += 1; 7373 h->pointer_equality_needed = 1; 7374 } 7375 /* FIXME:: RR need to handle these in shared libraries 7376 and essentially bomb out as these being non-PIC 7377 relocations in shared libraries. */ 7378 break; 7379 7380 case BFD_RELOC_AARCH64_CALL26: 7381 case BFD_RELOC_AARCH64_JUMP26: 7382 /* If this is a local symbol then we resolve it 7383 directly without creating a PLT entry. */ 7384 if (h == NULL) 7385 continue; 7386 7387 h->needs_plt = 1; 7388 if (h->plt.refcount <= 0) 7389 h->plt.refcount = 1; 7390 else 7391 h->plt.refcount += 1; 7392 break; 7393 7394 default: 7395 break; 7396 } 7397 } 7398 7399 return TRUE; 7400} 7401 7402/* Treat mapping symbols as special target symbols. */ 7403 7404static bfd_boolean 7405elfNN_aarch64_is_target_special_symbol (bfd *abfd ATTRIBUTE_UNUSED, 7406 asymbol *sym) 7407{ 7408 return bfd_is_aarch64_special_symbol_name (sym->name, 7409 BFD_AARCH64_SPECIAL_SYM_TYPE_ANY); 7410} 7411 7412/* This is a copy of elf_find_function () from elf.c except that 7413 AArch64 mapping symbols are ignored when looking for function names. */ 7414 7415static bfd_boolean 7416aarch64_elf_find_function (bfd *abfd ATTRIBUTE_UNUSED, 7417 asymbol **symbols, 7418 asection *section, 7419 bfd_vma offset, 7420 const char **filename_ptr, 7421 const char **functionname_ptr) 7422{ 7423 const char *filename = NULL; 7424 asymbol *func = NULL; 7425 bfd_vma low_func = 0; 7426 asymbol **p; 7427 7428 for (p = symbols; *p != NULL; p++) 7429 { 7430 elf_symbol_type *q; 7431 7432 q = (elf_symbol_type *) * p; 7433 7434 switch (ELF_ST_TYPE (q->internal_elf_sym.st_info)) 7435 { 7436 default: 7437 break; 7438 case STT_FILE: 7439 filename = bfd_asymbol_name (&q->symbol); 7440 break; 7441 case STT_FUNC: 7442 case STT_NOTYPE: 7443 /* Skip mapping symbols. */ 7444 if ((q->symbol.flags & BSF_LOCAL) 7445 && (bfd_is_aarch64_special_symbol_name 7446 (q->symbol.name, BFD_AARCH64_SPECIAL_SYM_TYPE_ANY))) 7447 continue; 7448 /* Fall through. */ 7449 if (bfd_get_section (&q->symbol) == section 7450 && q->symbol.value >= low_func && q->symbol.value <= offset) 7451 { 7452 func = (asymbol *) q; 7453 low_func = q->symbol.value; 7454 } 7455 break; 7456 } 7457 } 7458 7459 if (func == NULL) 7460 return FALSE; 7461 7462 if (filename_ptr) 7463 *filename_ptr = filename; 7464 if (functionname_ptr) 7465 *functionname_ptr = bfd_asymbol_name (func); 7466 7467 return TRUE; 7468} 7469 7470 7471/* Find the nearest line to a particular section and offset, for error 7472 reporting. This code is a duplicate of the code in elf.c, except 7473 that it uses aarch64_elf_find_function. */ 7474 7475static bfd_boolean 7476elfNN_aarch64_find_nearest_line (bfd *abfd, 7477 asymbol **symbols, 7478 asection *section, 7479 bfd_vma offset, 7480 const char **filename_ptr, 7481 const char **functionname_ptr, 7482 unsigned int *line_ptr, 7483 unsigned int *discriminator_ptr) 7484{ 7485 bfd_boolean found = FALSE; 7486 7487 if (_bfd_dwarf2_find_nearest_line (abfd, symbols, NULL, section, offset, 7488 filename_ptr, functionname_ptr, 7489 line_ptr, discriminator_ptr, 7490 dwarf_debug_sections, 0, 7491 &elf_tdata (abfd)->dwarf2_find_line_info)) 7492 { 7493 if (!*functionname_ptr) 7494 aarch64_elf_find_function (abfd, symbols, section, offset, 7495 *filename_ptr ? NULL : filename_ptr, 7496 functionname_ptr); 7497 7498 return TRUE; 7499 } 7500 7501 /* Skip _bfd_dwarf1_find_nearest_line since no known AArch64 7502 toolchain uses DWARF1. */ 7503 7504 if (!_bfd_stab_section_find_nearest_line (abfd, symbols, section, offset, 7505 &found, filename_ptr, 7506 functionname_ptr, line_ptr, 7507 &elf_tdata (abfd)->line_info)) 7508 return FALSE; 7509 7510 if (found && (*functionname_ptr || *line_ptr)) 7511 return TRUE; 7512 7513 if (symbols == NULL) 7514 return FALSE; 7515 7516 if (!aarch64_elf_find_function (abfd, symbols, section, offset, 7517 filename_ptr, functionname_ptr)) 7518 return FALSE; 7519 7520 *line_ptr = 0; 7521 return TRUE; 7522} 7523 7524static bfd_boolean 7525elfNN_aarch64_find_inliner_info (bfd *abfd, 7526 const char **filename_ptr, 7527 const char **functionname_ptr, 7528 unsigned int *line_ptr) 7529{ 7530 bfd_boolean found; 7531 found = _bfd_dwarf2_find_inliner_info 7532 (abfd, filename_ptr, 7533 functionname_ptr, line_ptr, &elf_tdata (abfd)->dwarf2_find_line_info); 7534 return found; 7535} 7536 7537 7538static void 7539elfNN_aarch64_post_process_headers (bfd *abfd, 7540 struct bfd_link_info *link_info) 7541{ 7542 Elf_Internal_Ehdr *i_ehdrp; /* ELF file header, internal form. */ 7543 7544 i_ehdrp = elf_elfheader (abfd); 7545 i_ehdrp->e_ident[EI_ABIVERSION] = AARCH64_ELF_ABI_VERSION; 7546 7547 _bfd_elf_post_process_headers (abfd, link_info); 7548} 7549 7550static enum elf_reloc_type_class 7551elfNN_aarch64_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED, 7552 const asection *rel_sec ATTRIBUTE_UNUSED, 7553 const Elf_Internal_Rela *rela) 7554{ 7555 switch ((int) ELFNN_R_TYPE (rela->r_info)) 7556 { 7557 case AARCH64_R (RELATIVE): 7558 return reloc_class_relative; 7559 case AARCH64_R (JUMP_SLOT): 7560 return reloc_class_plt; 7561 case AARCH64_R (COPY): 7562 return reloc_class_copy; 7563 default: 7564 return reloc_class_normal; 7565 } 7566} 7567 7568/* Handle an AArch64 specific section when reading an object file. This is 7569 called when bfd_section_from_shdr finds a section with an unknown 7570 type. */ 7571 7572static bfd_boolean 7573elfNN_aarch64_section_from_shdr (bfd *abfd, 7574 Elf_Internal_Shdr *hdr, 7575 const char *name, int shindex) 7576{ 7577 /* There ought to be a place to keep ELF backend specific flags, but 7578 at the moment there isn't one. We just keep track of the 7579 sections by their name, instead. Fortunately, the ABI gives 7580 names for all the AArch64 specific sections, so we will probably get 7581 away with this. */ 7582 switch (hdr->sh_type) 7583 { 7584 case SHT_AARCH64_ATTRIBUTES: 7585 break; 7586 7587 default: 7588 return FALSE; 7589 } 7590 7591 if (!_bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex)) 7592 return FALSE; 7593 7594 return TRUE; 7595} 7596 7597/* A structure used to record a list of sections, independently 7598 of the next and prev fields in the asection structure. */ 7599typedef struct section_list 7600{ 7601 asection *sec; 7602 struct section_list *next; 7603 struct section_list *prev; 7604} 7605section_list; 7606 7607/* Unfortunately we need to keep a list of sections for which 7608 an _aarch64_elf_section_data structure has been allocated. This 7609 is because it is possible for functions like elfNN_aarch64_write_section 7610 to be called on a section which has had an elf_data_structure 7611 allocated for it (and so the used_by_bfd field is valid) but 7612 for which the AArch64 extended version of this structure - the 7613 _aarch64_elf_section_data structure - has not been allocated. */ 7614static section_list *sections_with_aarch64_elf_section_data = NULL; 7615 7616static void 7617record_section_with_aarch64_elf_section_data (asection *sec) 7618{ 7619 struct section_list *entry; 7620 7621 entry = bfd_malloc (sizeof (*entry)); 7622 if (entry == NULL) 7623 return; 7624 entry->sec = sec; 7625 entry->next = sections_with_aarch64_elf_section_data; 7626 entry->prev = NULL; 7627 if (entry->next != NULL) 7628 entry->next->prev = entry; 7629 sections_with_aarch64_elf_section_data = entry; 7630} 7631 7632static struct section_list * 7633find_aarch64_elf_section_entry (asection *sec) 7634{ 7635 struct section_list *entry; 7636 static struct section_list *last_entry = NULL; 7637 7638 /* This is a short cut for the typical case where the sections are added 7639 to the sections_with_aarch64_elf_section_data list in forward order and 7640 then looked up here in backwards order. This makes a real difference 7641 to the ld-srec/sec64k.exp linker test. */ 7642 entry = sections_with_aarch64_elf_section_data; 7643 if (last_entry != NULL) 7644 { 7645 if (last_entry->sec == sec) 7646 entry = last_entry; 7647 else if (last_entry->next != NULL && last_entry->next->sec == sec) 7648 entry = last_entry->next; 7649 } 7650 7651 for (; entry; entry = entry->next) 7652 if (entry->sec == sec) 7653 break; 7654 7655 if (entry) 7656 /* Record the entry prior to this one - it is the entry we are 7657 most likely to want to locate next time. Also this way if we 7658 have been called from 7659 unrecord_section_with_aarch64_elf_section_data () we will not 7660 be caching a pointer that is about to be freed. */ 7661 last_entry = entry->prev; 7662 7663 return entry; 7664} 7665 7666static void 7667unrecord_section_with_aarch64_elf_section_data (asection *sec) 7668{ 7669 struct section_list *entry; 7670 7671 entry = find_aarch64_elf_section_entry (sec); 7672 7673 if (entry) 7674 { 7675 if (entry->prev != NULL) 7676 entry->prev->next = entry->next; 7677 if (entry->next != NULL) 7678 entry->next->prev = entry->prev; 7679 if (entry == sections_with_aarch64_elf_section_data) 7680 sections_with_aarch64_elf_section_data = entry->next; 7681 free (entry); 7682 } 7683} 7684 7685 7686typedef struct 7687{ 7688 void *finfo; 7689 struct bfd_link_info *info; 7690 asection *sec; 7691 int sec_shndx; 7692 int (*func) (void *, const char *, Elf_Internal_Sym *, 7693 asection *, struct elf_link_hash_entry *); 7694} output_arch_syminfo; 7695 7696enum map_symbol_type 7697{ 7698 AARCH64_MAP_INSN, 7699 AARCH64_MAP_DATA 7700}; 7701 7702 7703/* Output a single mapping symbol. */ 7704 7705static bfd_boolean 7706elfNN_aarch64_output_map_sym (output_arch_syminfo *osi, 7707 enum map_symbol_type type, bfd_vma offset) 7708{ 7709 static const char *names[2] = { "$x", "$d" }; 7710 Elf_Internal_Sym sym; 7711 7712 sym.st_value = (osi->sec->output_section->vma 7713 + osi->sec->output_offset + offset); 7714 sym.st_size = 0; 7715 sym.st_other = 0; 7716 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_NOTYPE); 7717 sym.st_shndx = osi->sec_shndx; 7718 return osi->func (osi->finfo, names[type], &sym, osi->sec, NULL) == 1; 7719} 7720 7721/* Output a single local symbol for a generated stub. */ 7722 7723static bfd_boolean 7724elfNN_aarch64_output_stub_sym (output_arch_syminfo *osi, const char *name, 7725 bfd_vma offset, bfd_vma size) 7726{ 7727 Elf_Internal_Sym sym; 7728 7729 sym.st_value = (osi->sec->output_section->vma 7730 + osi->sec->output_offset + offset); 7731 sym.st_size = size; 7732 sym.st_other = 0; 7733 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FUNC); 7734 sym.st_shndx = osi->sec_shndx; 7735 return osi->func (osi->finfo, name, &sym, osi->sec, NULL) == 1; 7736} 7737 7738static bfd_boolean 7739aarch64_map_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg) 7740{ 7741 struct elf_aarch64_stub_hash_entry *stub_entry; 7742 asection *stub_sec; 7743 bfd_vma addr; 7744 char *stub_name; 7745 output_arch_syminfo *osi; 7746 7747 /* Massage our args to the form they really have. */ 7748 stub_entry = (struct elf_aarch64_stub_hash_entry *) gen_entry; 7749 osi = (output_arch_syminfo *) in_arg; 7750 7751 stub_sec = stub_entry->stub_sec; 7752 7753 /* Ensure this stub is attached to the current section being 7754 processed. */ 7755 if (stub_sec != osi->sec) 7756 return TRUE; 7757 7758 addr = (bfd_vma) stub_entry->stub_offset; 7759 7760 stub_name = stub_entry->output_name; 7761 7762 switch (stub_entry->stub_type) 7763 { 7764 case aarch64_stub_adrp_branch: 7765 if (!elfNN_aarch64_output_stub_sym (osi, stub_name, addr, 7766 sizeof (aarch64_adrp_branch_stub))) 7767 return FALSE; 7768 if (!elfNN_aarch64_output_map_sym (osi, AARCH64_MAP_INSN, addr)) 7769 return FALSE; 7770 break; 7771 case aarch64_stub_long_branch: 7772 if (!elfNN_aarch64_output_stub_sym 7773 (osi, stub_name, addr, sizeof (aarch64_long_branch_stub))) 7774 return FALSE; 7775 if (!elfNN_aarch64_output_map_sym (osi, AARCH64_MAP_INSN, addr)) 7776 return FALSE; 7777 if (!elfNN_aarch64_output_map_sym (osi, AARCH64_MAP_DATA, addr + 16)) 7778 return FALSE; 7779 break; 7780 case aarch64_stub_erratum_835769_veneer: 7781 if (!elfNN_aarch64_output_stub_sym (osi, stub_name, addr, 7782 sizeof (aarch64_erratum_835769_stub))) 7783 return FALSE; 7784 if (!elfNN_aarch64_output_map_sym (osi, AARCH64_MAP_INSN, addr)) 7785 return FALSE; 7786 break; 7787 case aarch64_stub_erratum_843419_veneer: 7788 if (!elfNN_aarch64_output_stub_sym (osi, stub_name, addr, 7789 sizeof (aarch64_erratum_843419_stub))) 7790 return FALSE; 7791 if (!elfNN_aarch64_output_map_sym (osi, AARCH64_MAP_INSN, addr)) 7792 return FALSE; 7793 break; 7794 7795 default: 7796 abort (); 7797 } 7798 7799 return TRUE; 7800} 7801 7802/* Output mapping symbols for linker generated sections. */ 7803 7804static bfd_boolean 7805elfNN_aarch64_output_arch_local_syms (bfd *output_bfd, 7806 struct bfd_link_info *info, 7807 void *finfo, 7808 int (*func) (void *, const char *, 7809 Elf_Internal_Sym *, 7810 asection *, 7811 struct elf_link_hash_entry 7812 *)) 7813{ 7814 output_arch_syminfo osi; 7815 struct elf_aarch64_link_hash_table *htab; 7816 7817 htab = elf_aarch64_hash_table (info); 7818 7819 osi.finfo = finfo; 7820 osi.info = info; 7821 osi.func = func; 7822 7823 /* Long calls stubs. */ 7824 if (htab->stub_bfd && htab->stub_bfd->sections) 7825 { 7826 asection *stub_sec; 7827 7828 for (stub_sec = htab->stub_bfd->sections; 7829 stub_sec != NULL; stub_sec = stub_sec->next) 7830 { 7831 /* Ignore non-stub sections. */ 7832 if (!strstr (stub_sec->name, STUB_SUFFIX)) 7833 continue; 7834 7835 osi.sec = stub_sec; 7836 7837 osi.sec_shndx = _bfd_elf_section_from_bfd_section 7838 (output_bfd, osi.sec->output_section); 7839 7840 /* The first instruction in a stub is always a branch. */ 7841 if (!elfNN_aarch64_output_map_sym (&osi, AARCH64_MAP_INSN, 0)) 7842 return FALSE; 7843 7844 bfd_hash_traverse (&htab->stub_hash_table, aarch64_map_one_stub, 7845 &osi); 7846 } 7847 } 7848 7849 /* Finally, output mapping symbols for the PLT. */ 7850 if (!htab->root.splt || htab->root.splt->size == 0) 7851 return TRUE; 7852 7853 osi.sec_shndx = _bfd_elf_section_from_bfd_section 7854 (output_bfd, htab->root.splt->output_section); 7855 osi.sec = htab->root.splt; 7856 7857 elfNN_aarch64_output_map_sym (&osi, AARCH64_MAP_INSN, 0); 7858 7859 return TRUE; 7860 7861} 7862 7863/* Allocate target specific section data. */ 7864 7865static bfd_boolean 7866elfNN_aarch64_new_section_hook (bfd *abfd, asection *sec) 7867{ 7868 if (!sec->used_by_bfd) 7869 { 7870 _aarch64_elf_section_data *sdata; 7871 bfd_size_type amt = sizeof (*sdata); 7872 7873 sdata = bfd_zalloc (abfd, amt); 7874 if (sdata == NULL) 7875 return FALSE; 7876 sec->used_by_bfd = sdata; 7877 } 7878 7879 record_section_with_aarch64_elf_section_data (sec); 7880 7881 return _bfd_elf_new_section_hook (abfd, sec); 7882} 7883 7884 7885static void 7886unrecord_section_via_map_over_sections (bfd *abfd ATTRIBUTE_UNUSED, 7887 asection *sec, 7888 void *ignore ATTRIBUTE_UNUSED) 7889{ 7890 unrecord_section_with_aarch64_elf_section_data (sec); 7891} 7892 7893static bfd_boolean 7894elfNN_aarch64_close_and_cleanup (bfd *abfd) 7895{ 7896 if (abfd->sections) 7897 bfd_map_over_sections (abfd, 7898 unrecord_section_via_map_over_sections, NULL); 7899 7900 return _bfd_elf_close_and_cleanup (abfd); 7901} 7902 7903static bfd_boolean 7904elfNN_aarch64_bfd_free_cached_info (bfd *abfd) 7905{ 7906 if (abfd->sections) 7907 bfd_map_over_sections (abfd, 7908 unrecord_section_via_map_over_sections, NULL); 7909 7910 return _bfd_free_cached_info (abfd); 7911} 7912 7913/* Create dynamic sections. This is different from the ARM backend in that 7914 the got, plt, gotplt and their relocation sections are all created in the 7915 standard part of the bfd elf backend. */ 7916 7917static bfd_boolean 7918elfNN_aarch64_create_dynamic_sections (bfd *dynobj, 7919 struct bfd_link_info *info) 7920{ 7921 /* We need to create .got section. */ 7922 if (!aarch64_elf_create_got_section (dynobj, info)) 7923 return FALSE; 7924 7925 return _bfd_elf_create_dynamic_sections (dynobj, info); 7926} 7927 7928 7929/* Allocate space in .plt, .got and associated reloc sections for 7930 dynamic relocs. */ 7931 7932static bfd_boolean 7933elfNN_aarch64_allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf) 7934{ 7935 struct bfd_link_info *info; 7936 struct elf_aarch64_link_hash_table *htab; 7937 struct elf_aarch64_link_hash_entry *eh; 7938 struct elf_dyn_relocs *p; 7939 7940 /* An example of a bfd_link_hash_indirect symbol is versioned 7941 symbol. For example: __gxx_personality_v0(bfd_link_hash_indirect) 7942 -> __gxx_personality_v0(bfd_link_hash_defined) 7943 7944 There is no need to process bfd_link_hash_indirect symbols here 7945 because we will also be presented with the concrete instance of 7946 the symbol and elfNN_aarch64_copy_indirect_symbol () will have been 7947 called to copy all relevant data from the generic to the concrete 7948 symbol instance. 7949 */ 7950 if (h->root.type == bfd_link_hash_indirect) 7951 return TRUE; 7952 7953 if (h->root.type == bfd_link_hash_warning) 7954 h = (struct elf_link_hash_entry *) h->root.u.i.link; 7955 7956 info = (struct bfd_link_info *) inf; 7957 htab = elf_aarch64_hash_table (info); 7958 7959 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it 7960 here if it is defined and referenced in a non-shared object. */ 7961 if (h->type == STT_GNU_IFUNC 7962 && h->def_regular) 7963 return TRUE; 7964 else if (htab->root.dynamic_sections_created && h->plt.refcount > 0) 7965 { 7966 /* Make sure this symbol is output as a dynamic symbol. 7967 Undefined weak syms won't yet be marked as dynamic. */ 7968 if (h->dynindx == -1 && !h->forced_local) 7969 { 7970 if (!bfd_elf_link_record_dynamic_symbol (info, h)) 7971 return FALSE; 7972 } 7973 7974 if (bfd_link_pic (info) || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h)) 7975 { 7976 asection *s = htab->root.splt; 7977 7978 /* If this is the first .plt entry, make room for the special 7979 first entry. */ 7980 if (s->size == 0) 7981 s->size += htab->plt_header_size; 7982 7983 h->plt.offset = s->size; 7984 7985 /* If this symbol is not defined in a regular file, and we are 7986 not generating a shared library, then set the symbol to this 7987 location in the .plt. This is required to make function 7988 pointers compare as equal between the normal executable and 7989 the shared library. */ 7990 if (!bfd_link_pic (info) && !h->def_regular) 7991 { 7992 h->root.u.def.section = s; 7993 h->root.u.def.value = h->plt.offset; 7994 } 7995 7996 /* Make room for this entry. For now we only create the 7997 small model PLT entries. We later need to find a way 7998 of relaxing into these from the large model PLT entries. */ 7999 s->size += PLT_SMALL_ENTRY_SIZE; 8000 8001 /* We also need to make an entry in the .got.plt section, which 8002 will be placed in the .got section by the linker script. */ 8003 htab->root.sgotplt->size += GOT_ENTRY_SIZE; 8004 8005 /* We also need to make an entry in the .rela.plt section. */ 8006 htab->root.srelplt->size += RELOC_SIZE (htab); 8007 8008 /* We need to ensure that all GOT entries that serve the PLT 8009 are consecutive with the special GOT slots [0] [1] and 8010 [2]. Any addtional relocations, such as 8011 R_AARCH64_TLSDESC, must be placed after the PLT related 8012 entries. We abuse the reloc_count such that during 8013 sizing we adjust reloc_count to indicate the number of 8014 PLT related reserved entries. In subsequent phases when 8015 filling in the contents of the reloc entries, PLT related 8016 entries are placed by computing their PLT index (0 8017 .. reloc_count). While other none PLT relocs are placed 8018 at the slot indicated by reloc_count and reloc_count is 8019 updated. */ 8020 8021 htab->root.srelplt->reloc_count++; 8022 } 8023 else 8024 { 8025 h->plt.offset = (bfd_vma) - 1; 8026 h->needs_plt = 0; 8027 } 8028 } 8029 else 8030 { 8031 h->plt.offset = (bfd_vma) - 1; 8032 h->needs_plt = 0; 8033 } 8034 8035 eh = (struct elf_aarch64_link_hash_entry *) h; 8036 eh->tlsdesc_got_jump_table_offset = (bfd_vma) - 1; 8037 8038 if (h->got.refcount > 0) 8039 { 8040 bfd_boolean dyn; 8041 unsigned got_type = elf_aarch64_hash_entry (h)->got_type; 8042 8043 h->got.offset = (bfd_vma) - 1; 8044 8045 dyn = htab->root.dynamic_sections_created; 8046 8047 /* Make sure this symbol is output as a dynamic symbol. 8048 Undefined weak syms won't yet be marked as dynamic. */ 8049 if (dyn && h->dynindx == -1 && !h->forced_local) 8050 { 8051 if (!bfd_elf_link_record_dynamic_symbol (info, h)) 8052 return FALSE; 8053 } 8054 8055 if (got_type == GOT_UNKNOWN) 8056 { 8057 } 8058 else if (got_type == GOT_NORMAL) 8059 { 8060 h->got.offset = htab->root.sgot->size; 8061 htab->root.sgot->size += GOT_ENTRY_SIZE; 8062 if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT 8063 || h->root.type != bfd_link_hash_undefweak) 8064 && (bfd_link_pic (info) 8065 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))) 8066 { 8067 htab->root.srelgot->size += RELOC_SIZE (htab); 8068 } 8069 } 8070 else 8071 { 8072 int indx; 8073 if (got_type & GOT_TLSDESC_GD) 8074 { 8075 eh->tlsdesc_got_jump_table_offset = 8076 (htab->root.sgotplt->size 8077 - aarch64_compute_jump_table_size (htab)); 8078 htab->root.sgotplt->size += GOT_ENTRY_SIZE * 2; 8079 h->got.offset = (bfd_vma) - 2; 8080 } 8081 8082 if (got_type & GOT_TLS_GD) 8083 { 8084 h->got.offset = htab->root.sgot->size; 8085 htab->root.sgot->size += GOT_ENTRY_SIZE * 2; 8086 } 8087 8088 if (got_type & GOT_TLS_IE) 8089 { 8090 h->got.offset = htab->root.sgot->size; 8091 htab->root.sgot->size += GOT_ENTRY_SIZE; 8092 } 8093 8094 indx = h && h->dynindx != -1 ? h->dynindx : 0; 8095 if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT 8096 || h->root.type != bfd_link_hash_undefweak) 8097 && (bfd_link_pic (info) 8098 || indx != 0 8099 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h))) 8100 { 8101 if (got_type & GOT_TLSDESC_GD) 8102 { 8103 htab->root.srelplt->size += RELOC_SIZE (htab); 8104 /* Note reloc_count not incremented here! We have 8105 already adjusted reloc_count for this relocation 8106 type. */ 8107 8108 /* TLSDESC PLT is now needed, but not yet determined. */ 8109 htab->tlsdesc_plt = (bfd_vma) - 1; 8110 } 8111 8112 if (got_type & GOT_TLS_GD) 8113 htab->root.srelgot->size += RELOC_SIZE (htab) * 2; 8114 8115 if (got_type & GOT_TLS_IE) 8116 htab->root.srelgot->size += RELOC_SIZE (htab); 8117 } 8118 } 8119 } 8120 else 8121 { 8122 h->got.offset = (bfd_vma) - 1; 8123 } 8124 8125 if (eh->dyn_relocs == NULL) 8126 return TRUE; 8127 8128 /* In the shared -Bsymbolic case, discard space allocated for 8129 dynamic pc-relative relocs against symbols which turn out to be 8130 defined in regular objects. For the normal shared case, discard 8131 space for pc-relative relocs that have become local due to symbol 8132 visibility changes. */ 8133 8134 if (bfd_link_pic (info)) 8135 { 8136 /* Relocs that use pc_count are those that appear on a call 8137 insn, or certain REL relocs that can generated via assembly. 8138 We want calls to protected symbols to resolve directly to the 8139 function rather than going via the plt. If people want 8140 function pointer comparisons to work as expected then they 8141 should avoid writing weird assembly. */ 8142 if (SYMBOL_CALLS_LOCAL (info, h)) 8143 { 8144 struct elf_dyn_relocs **pp; 8145 8146 for (pp = &eh->dyn_relocs; (p = *pp) != NULL;) 8147 { 8148 p->count -= p->pc_count; 8149 p->pc_count = 0; 8150 if (p->count == 0) 8151 *pp = p->next; 8152 else 8153 pp = &p->next; 8154 } 8155 } 8156 8157 /* Also discard relocs on undefined weak syms with non-default 8158 visibility. */ 8159 if (eh->dyn_relocs != NULL && h->root.type == bfd_link_hash_undefweak) 8160 { 8161 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT) 8162 eh->dyn_relocs = NULL; 8163 8164 /* Make sure undefined weak symbols are output as a dynamic 8165 symbol in PIEs. */ 8166 else if (h->dynindx == -1 8167 && !h->forced_local 8168 && !bfd_elf_link_record_dynamic_symbol (info, h)) 8169 return FALSE; 8170 } 8171 8172 } 8173 else if (ELIMINATE_COPY_RELOCS) 8174 { 8175 /* For the non-shared case, discard space for relocs against 8176 symbols which turn out to need copy relocs or are not 8177 dynamic. */ 8178 8179 if (!h->non_got_ref 8180 && ((h->def_dynamic 8181 && !h->def_regular) 8182 || (htab->root.dynamic_sections_created 8183 && (h->root.type == bfd_link_hash_undefweak 8184 || h->root.type == bfd_link_hash_undefined)))) 8185 { 8186 /* Make sure this symbol is output as a dynamic symbol. 8187 Undefined weak syms won't yet be marked as dynamic. */ 8188 if (h->dynindx == -1 8189 && !h->forced_local 8190 && !bfd_elf_link_record_dynamic_symbol (info, h)) 8191 return FALSE; 8192 8193 /* If that succeeded, we know we'll be keeping all the 8194 relocs. */ 8195 if (h->dynindx != -1) 8196 goto keep; 8197 } 8198 8199 eh->dyn_relocs = NULL; 8200 8201 keep:; 8202 } 8203 8204 /* Finally, allocate space. */ 8205 for (p = eh->dyn_relocs; p != NULL; p = p->next) 8206 { 8207 asection *sreloc; 8208 8209 sreloc = elf_section_data (p->sec)->sreloc; 8210 8211 BFD_ASSERT (sreloc != NULL); 8212 8213 sreloc->size += p->count * RELOC_SIZE (htab); 8214 } 8215 8216 return TRUE; 8217} 8218 8219/* Allocate space in .plt, .got and associated reloc sections for 8220 ifunc dynamic relocs. */ 8221 8222static bfd_boolean 8223elfNN_aarch64_allocate_ifunc_dynrelocs (struct elf_link_hash_entry *h, 8224 void *inf) 8225{ 8226 struct bfd_link_info *info; 8227 struct elf_aarch64_link_hash_table *htab; 8228 struct elf_aarch64_link_hash_entry *eh; 8229 8230 /* An example of a bfd_link_hash_indirect symbol is versioned 8231 symbol. For example: __gxx_personality_v0(bfd_link_hash_indirect) 8232 -> __gxx_personality_v0(bfd_link_hash_defined) 8233 8234 There is no need to process bfd_link_hash_indirect symbols here 8235 because we will also be presented with the concrete instance of 8236 the symbol and elfNN_aarch64_copy_indirect_symbol () will have been 8237 called to copy all relevant data from the generic to the concrete 8238 symbol instance. 8239 */ 8240 if (h->root.type == bfd_link_hash_indirect) 8241 return TRUE; 8242 8243 if (h->root.type == bfd_link_hash_warning) 8244 h = (struct elf_link_hash_entry *) h->root.u.i.link; 8245 8246 info = (struct bfd_link_info *) inf; 8247 htab = elf_aarch64_hash_table (info); 8248 8249 eh = (struct elf_aarch64_link_hash_entry *) h; 8250 8251 /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it 8252 here if it is defined and referenced in a non-shared object. */ 8253 if (h->type == STT_GNU_IFUNC 8254 && h->def_regular) 8255 return _bfd_elf_allocate_ifunc_dyn_relocs (info, h, 8256 &eh->dyn_relocs, 8257 NULL, 8258 htab->plt_entry_size, 8259 htab->plt_header_size, 8260 GOT_ENTRY_SIZE, 8261 FALSE); 8262 return TRUE; 8263} 8264 8265/* Allocate space in .plt, .got and associated reloc sections for 8266 local dynamic relocs. */ 8267 8268static bfd_boolean 8269elfNN_aarch64_allocate_local_dynrelocs (void **slot, void *inf) 8270{ 8271 struct elf_link_hash_entry *h 8272 = (struct elf_link_hash_entry *) *slot; 8273 8274 if (h->type != STT_GNU_IFUNC 8275 || !h->def_regular 8276 || !h->ref_regular 8277 || !h->forced_local 8278 || h->root.type != bfd_link_hash_defined) 8279 abort (); 8280 8281 return elfNN_aarch64_allocate_dynrelocs (h, inf); 8282} 8283 8284/* Allocate space in .plt, .got and associated reloc sections for 8285 local ifunc dynamic relocs. */ 8286 8287static bfd_boolean 8288elfNN_aarch64_allocate_local_ifunc_dynrelocs (void **slot, void *inf) 8289{ 8290 struct elf_link_hash_entry *h 8291 = (struct elf_link_hash_entry *) *slot; 8292 8293 if (h->type != STT_GNU_IFUNC 8294 || !h->def_regular 8295 || !h->ref_regular 8296 || !h->forced_local 8297 || h->root.type != bfd_link_hash_defined) 8298 abort (); 8299 8300 return elfNN_aarch64_allocate_ifunc_dynrelocs (h, inf); 8301} 8302 8303/* Find any dynamic relocs that apply to read-only sections. */ 8304 8305static bfd_boolean 8306aarch64_readonly_dynrelocs (struct elf_link_hash_entry * h, void * inf) 8307{ 8308 struct elf_aarch64_link_hash_entry * eh; 8309 struct elf_dyn_relocs * p; 8310 8311 eh = (struct elf_aarch64_link_hash_entry *) h; 8312 for (p = eh->dyn_relocs; p != NULL; p = p->next) 8313 { 8314 asection *s = p->sec; 8315 8316 if (s != NULL && (s->flags & SEC_READONLY) != 0) 8317 { 8318 struct bfd_link_info *info = (struct bfd_link_info *) inf; 8319 8320 info->flags |= DF_TEXTREL; 8321 8322 /* Not an error, just cut short the traversal. */ 8323 return FALSE; 8324 } 8325 } 8326 return TRUE; 8327} 8328 8329/* This is the most important function of all . Innocuosly named 8330 though ! */ 8331static bfd_boolean 8332elfNN_aarch64_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED, 8333 struct bfd_link_info *info) 8334{ 8335 struct elf_aarch64_link_hash_table *htab; 8336 bfd *dynobj; 8337 asection *s; 8338 bfd_boolean relocs; 8339 bfd *ibfd; 8340 8341 htab = elf_aarch64_hash_table ((info)); 8342 dynobj = htab->root.dynobj; 8343 8344 BFD_ASSERT (dynobj != NULL); 8345 8346 if (htab->root.dynamic_sections_created) 8347 { 8348 if (bfd_link_executable (info) && !info->nointerp) 8349 { 8350 s = bfd_get_linker_section (dynobj, ".interp"); 8351 if (s == NULL) 8352 abort (); 8353 s->size = sizeof ELF_DYNAMIC_INTERPRETER; 8354 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER; 8355 } 8356 } 8357 8358 /* Set up .got offsets for local syms, and space for local dynamic 8359 relocs. */ 8360 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next) 8361 { 8362 struct elf_aarch64_local_symbol *locals = NULL; 8363 Elf_Internal_Shdr *symtab_hdr; 8364 asection *srel; 8365 unsigned int i; 8366 8367 if (!is_aarch64_elf (ibfd)) 8368 continue; 8369 8370 for (s = ibfd->sections; s != NULL; s = s->next) 8371 { 8372 struct elf_dyn_relocs *p; 8373 8374 for (p = (struct elf_dyn_relocs *) 8375 (elf_section_data (s)->local_dynrel); p != NULL; p = p->next) 8376 { 8377 if (!bfd_is_abs_section (p->sec) 8378 && bfd_is_abs_section (p->sec->output_section)) 8379 { 8380 /* Input section has been discarded, either because 8381 it is a copy of a linkonce section or due to 8382 linker script /DISCARD/, so we'll be discarding 8383 the relocs too. */ 8384 } 8385 else if (p->count != 0) 8386 { 8387 srel = elf_section_data (p->sec)->sreloc; 8388 srel->size += p->count * RELOC_SIZE (htab); 8389 if ((p->sec->output_section->flags & SEC_READONLY) != 0) 8390 info->flags |= DF_TEXTREL; 8391 } 8392 } 8393 } 8394 8395 locals = elf_aarch64_locals (ibfd); 8396 if (!locals) 8397 continue; 8398 8399 symtab_hdr = &elf_symtab_hdr (ibfd); 8400 srel = htab->root.srelgot; 8401 for (i = 0; i < symtab_hdr->sh_info; i++) 8402 { 8403 locals[i].got_offset = (bfd_vma) - 1; 8404 locals[i].tlsdesc_got_jump_table_offset = (bfd_vma) - 1; 8405 if (locals[i].got_refcount > 0) 8406 { 8407 unsigned got_type = locals[i].got_type; 8408 if (got_type & GOT_TLSDESC_GD) 8409 { 8410 locals[i].tlsdesc_got_jump_table_offset = 8411 (htab->root.sgotplt->size 8412 - aarch64_compute_jump_table_size (htab)); 8413 htab->root.sgotplt->size += GOT_ENTRY_SIZE * 2; 8414 locals[i].got_offset = (bfd_vma) - 2; 8415 } 8416 8417 if (got_type & GOT_TLS_GD) 8418 { 8419 locals[i].got_offset = htab->root.sgot->size; 8420 htab->root.sgot->size += GOT_ENTRY_SIZE * 2; 8421 } 8422 8423 if (got_type & GOT_TLS_IE 8424 || got_type & GOT_NORMAL) 8425 { 8426 locals[i].got_offset = htab->root.sgot->size; 8427 htab->root.sgot->size += GOT_ENTRY_SIZE; 8428 } 8429 8430 if (got_type == GOT_UNKNOWN) 8431 { 8432 } 8433 8434 if (bfd_link_pic (info)) 8435 { 8436 if (got_type & GOT_TLSDESC_GD) 8437 { 8438 htab->root.srelplt->size += RELOC_SIZE (htab); 8439 /* Note RELOC_COUNT not incremented here! */ 8440 htab->tlsdesc_plt = (bfd_vma) - 1; 8441 } 8442 8443 if (got_type & GOT_TLS_GD) 8444 htab->root.srelgot->size += RELOC_SIZE (htab) * 2; 8445 8446 if (got_type & GOT_TLS_IE 8447 || got_type & GOT_NORMAL) 8448 htab->root.srelgot->size += RELOC_SIZE (htab); 8449 } 8450 } 8451 else 8452 { 8453 locals[i].got_refcount = (bfd_vma) - 1; 8454 } 8455 } 8456 } 8457 8458 8459 /* Allocate global sym .plt and .got entries, and space for global 8460 sym dynamic relocs. */ 8461 elf_link_hash_traverse (&htab->root, elfNN_aarch64_allocate_dynrelocs, 8462 info); 8463 8464 /* Allocate global ifunc sym .plt and .got entries, and space for global 8465 ifunc sym dynamic relocs. */ 8466 elf_link_hash_traverse (&htab->root, elfNN_aarch64_allocate_ifunc_dynrelocs, 8467 info); 8468 8469 /* Allocate .plt and .got entries, and space for local symbols. */ 8470 htab_traverse (htab->loc_hash_table, 8471 elfNN_aarch64_allocate_local_dynrelocs, 8472 info); 8473 8474 /* Allocate .plt and .got entries, and space for local ifunc symbols. */ 8475 htab_traverse (htab->loc_hash_table, 8476 elfNN_aarch64_allocate_local_ifunc_dynrelocs, 8477 info); 8478 8479 /* For every jump slot reserved in the sgotplt, reloc_count is 8480 incremented. However, when we reserve space for TLS descriptors, 8481 it's not incremented, so in order to compute the space reserved 8482 for them, it suffices to multiply the reloc count by the jump 8483 slot size. */ 8484 8485 if (htab->root.srelplt) 8486 htab->sgotplt_jump_table_size = aarch64_compute_jump_table_size (htab); 8487 8488 if (htab->tlsdesc_plt) 8489 { 8490 if (htab->root.splt->size == 0) 8491 htab->root.splt->size += PLT_ENTRY_SIZE; 8492 8493 htab->tlsdesc_plt = htab->root.splt->size; 8494 htab->root.splt->size += PLT_TLSDESC_ENTRY_SIZE; 8495 8496 /* If we're not using lazy TLS relocations, don't generate the 8497 GOT entry required. */ 8498 if (!(info->flags & DF_BIND_NOW)) 8499 { 8500 htab->dt_tlsdesc_got = htab->root.sgot->size; 8501 htab->root.sgot->size += GOT_ENTRY_SIZE; 8502 } 8503 } 8504 8505 /* Init mapping symbols information to use later to distingush between 8506 code and data while scanning for errata. */ 8507 if (htab->fix_erratum_835769 || htab->fix_erratum_843419) 8508 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next) 8509 { 8510 if (!is_aarch64_elf (ibfd)) 8511 continue; 8512 bfd_elfNN_aarch64_init_maps (ibfd); 8513 } 8514 8515 /* We now have determined the sizes of the various dynamic sections. 8516 Allocate memory for them. */ 8517 relocs = FALSE; 8518 for (s = dynobj->sections; s != NULL; s = s->next) 8519 { 8520 if ((s->flags & SEC_LINKER_CREATED) == 0) 8521 continue; 8522 8523 if (s == htab->root.splt 8524 || s == htab->root.sgot 8525 || s == htab->root.sgotplt 8526 || s == htab->root.iplt 8527 || s == htab->root.igotplt 8528 || s == htab->root.sdynbss 8529 || s == htab->root.sdynrelro) 8530 { 8531 /* Strip this section if we don't need it; see the 8532 comment below. */ 8533 } 8534 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela")) 8535 { 8536 if (s->size != 0 && s != htab->root.srelplt) 8537 relocs = TRUE; 8538 8539 /* We use the reloc_count field as a counter if we need 8540 to copy relocs into the output file. */ 8541 if (s != htab->root.srelplt) 8542 s->reloc_count = 0; 8543 } 8544 else 8545 { 8546 /* It's not one of our sections, so don't allocate space. */ 8547 continue; 8548 } 8549 8550 if (s->size == 0) 8551 { 8552 /* If we don't need this section, strip it from the 8553 output file. This is mostly to handle .rela.bss and 8554 .rela.plt. We must create both sections in 8555 create_dynamic_sections, because they must be created 8556 before the linker maps input sections to output 8557 sections. The linker does that before 8558 adjust_dynamic_symbol is called, and it is that 8559 function which decides whether anything needs to go 8560 into these sections. */ 8561 8562 s->flags |= SEC_EXCLUDE; 8563 continue; 8564 } 8565 8566 if ((s->flags & SEC_HAS_CONTENTS) == 0) 8567 continue; 8568 8569 /* Allocate memory for the section contents. We use bfd_zalloc 8570 here in case unused entries are not reclaimed before the 8571 section's contents are written out. This should not happen, 8572 but this way if it does, we get a R_AARCH64_NONE reloc instead 8573 of garbage. */ 8574 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size); 8575 if (s->contents == NULL) 8576 return FALSE; 8577 } 8578 8579 if (htab->root.dynamic_sections_created) 8580 { 8581 /* Add some entries to the .dynamic section. We fill in the 8582 values later, in elfNN_aarch64_finish_dynamic_sections, but we 8583 must add the entries now so that we get the correct size for 8584 the .dynamic section. The DT_DEBUG entry is filled in by the 8585 dynamic linker and used by the debugger. */ 8586#define add_dynamic_entry(TAG, VAL) \ 8587 _bfd_elf_add_dynamic_entry (info, TAG, VAL) 8588 8589 if (bfd_link_executable (info)) 8590 { 8591 if (!add_dynamic_entry (DT_DEBUG, 0)) 8592 return FALSE; 8593 } 8594 8595 if (htab->root.splt->size != 0) 8596 { 8597 if (!add_dynamic_entry (DT_PLTGOT, 0) 8598 || !add_dynamic_entry (DT_PLTRELSZ, 0) 8599 || !add_dynamic_entry (DT_PLTREL, DT_RELA) 8600 || !add_dynamic_entry (DT_JMPREL, 0)) 8601 return FALSE; 8602 8603 if (htab->tlsdesc_plt 8604 && (!add_dynamic_entry (DT_TLSDESC_PLT, 0) 8605 || !add_dynamic_entry (DT_TLSDESC_GOT, 0))) 8606 return FALSE; 8607 } 8608 8609 if (relocs) 8610 { 8611 if (!add_dynamic_entry (DT_RELA, 0) 8612 || !add_dynamic_entry (DT_RELASZ, 0) 8613 || !add_dynamic_entry (DT_RELAENT, RELOC_SIZE (htab))) 8614 return FALSE; 8615 8616 /* If any dynamic relocs apply to a read-only section, 8617 then we need a DT_TEXTREL entry. */ 8618 if ((info->flags & DF_TEXTREL) == 0) 8619 elf_link_hash_traverse (& htab->root, aarch64_readonly_dynrelocs, 8620 info); 8621 8622 if ((info->flags & DF_TEXTREL) != 0) 8623 { 8624 if (!add_dynamic_entry (DT_TEXTREL, 0)) 8625 return FALSE; 8626 } 8627 } 8628 } 8629#undef add_dynamic_entry 8630 8631 return TRUE; 8632} 8633 8634static inline void 8635elf_aarch64_update_plt_entry (bfd *output_bfd, 8636 bfd_reloc_code_real_type r_type, 8637 bfd_byte *plt_entry, bfd_vma value) 8638{ 8639 reloc_howto_type *howto = elfNN_aarch64_howto_from_bfd_reloc (r_type); 8640 8641 _bfd_aarch64_elf_put_addend (output_bfd, plt_entry, r_type, howto, value); 8642} 8643 8644static void 8645elfNN_aarch64_create_small_pltn_entry (struct elf_link_hash_entry *h, 8646 struct elf_aarch64_link_hash_table 8647 *htab, bfd *output_bfd, 8648 struct bfd_link_info *info) 8649{ 8650 bfd_byte *plt_entry; 8651 bfd_vma plt_index; 8652 bfd_vma got_offset; 8653 bfd_vma gotplt_entry_address; 8654 bfd_vma plt_entry_address; 8655 Elf_Internal_Rela rela; 8656 bfd_byte *loc; 8657 asection *plt, *gotplt, *relplt; 8658 8659 /* When building a static executable, use .iplt, .igot.plt and 8660 .rela.iplt sections for STT_GNU_IFUNC symbols. */ 8661 if (htab->root.splt != NULL) 8662 { 8663 plt = htab->root.splt; 8664 gotplt = htab->root.sgotplt; 8665 relplt = htab->root.srelplt; 8666 } 8667 else 8668 { 8669 plt = htab->root.iplt; 8670 gotplt = htab->root.igotplt; 8671 relplt = htab->root.irelplt; 8672 } 8673 8674 /* Get the index in the procedure linkage table which 8675 corresponds to this symbol. This is the index of this symbol 8676 in all the symbols for which we are making plt entries. The 8677 first entry in the procedure linkage table is reserved. 8678 8679 Get the offset into the .got table of the entry that 8680 corresponds to this function. Each .got entry is GOT_ENTRY_SIZE 8681 bytes. The first three are reserved for the dynamic linker. 8682 8683 For static executables, we don't reserve anything. */ 8684 8685 if (plt == htab->root.splt) 8686 { 8687 plt_index = (h->plt.offset - htab->plt_header_size) / htab->plt_entry_size; 8688 got_offset = (plt_index + 3) * GOT_ENTRY_SIZE; 8689 } 8690 else 8691 { 8692 plt_index = h->plt.offset / htab->plt_entry_size; 8693 got_offset = plt_index * GOT_ENTRY_SIZE; 8694 } 8695 8696 plt_entry = plt->contents + h->plt.offset; 8697 plt_entry_address = plt->output_section->vma 8698 + plt->output_offset + h->plt.offset; 8699 gotplt_entry_address = gotplt->output_section->vma + 8700 gotplt->output_offset + got_offset; 8701 8702 /* Copy in the boiler-plate for the PLTn entry. */ 8703 memcpy (plt_entry, elfNN_aarch64_small_plt_entry, PLT_SMALL_ENTRY_SIZE); 8704 8705 /* Fill in the top 21 bits for this: ADRP x16, PLT_GOT + n * 8. 8706 ADRP: ((PG(S+A)-PG(P)) >> 12) & 0x1fffff */ 8707 elf_aarch64_update_plt_entry (output_bfd, BFD_RELOC_AARCH64_ADR_HI21_PCREL, 8708 plt_entry, 8709 PG (gotplt_entry_address) - 8710 PG (plt_entry_address)); 8711 8712 /* Fill in the lo12 bits for the load from the pltgot. */ 8713 elf_aarch64_update_plt_entry (output_bfd, BFD_RELOC_AARCH64_LDSTNN_LO12, 8714 plt_entry + 4, 8715 PG_OFFSET (gotplt_entry_address)); 8716 8717 /* Fill in the lo12 bits for the add from the pltgot entry. */ 8718 elf_aarch64_update_plt_entry (output_bfd, BFD_RELOC_AARCH64_ADD_LO12, 8719 plt_entry + 8, 8720 PG_OFFSET (gotplt_entry_address)); 8721 8722 /* All the GOTPLT Entries are essentially initialized to PLT0. */ 8723 bfd_put_NN (output_bfd, 8724 plt->output_section->vma + plt->output_offset, 8725 gotplt->contents + got_offset); 8726 8727 rela.r_offset = gotplt_entry_address; 8728 8729 if (h->dynindx == -1 8730 || ((bfd_link_executable (info) 8731 || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT) 8732 && h->def_regular 8733 && h->type == STT_GNU_IFUNC)) 8734 { 8735 /* If an STT_GNU_IFUNC symbol is locally defined, generate 8736 R_AARCH64_IRELATIVE instead of R_AARCH64_JUMP_SLOT. */ 8737 rela.r_info = ELFNN_R_INFO (0, AARCH64_R (IRELATIVE)); 8738 rela.r_addend = (h->root.u.def.value 8739 + h->root.u.def.section->output_section->vma 8740 + h->root.u.def.section->output_offset); 8741 } 8742 else 8743 { 8744 /* Fill in the entry in the .rela.plt section. */ 8745 rela.r_info = ELFNN_R_INFO (h->dynindx, AARCH64_R (JUMP_SLOT)); 8746 rela.r_addend = 0; 8747 } 8748 8749 /* Compute the relocation entry to used based on PLT index and do 8750 not adjust reloc_count. The reloc_count has already been adjusted 8751 to account for this entry. */ 8752 loc = relplt->contents + plt_index * RELOC_SIZE (htab); 8753 bfd_elfNN_swap_reloca_out (output_bfd, &rela, loc); 8754} 8755 8756/* Size sections even though they're not dynamic. We use it to setup 8757 _TLS_MODULE_BASE_, if needed. */ 8758 8759static bfd_boolean 8760elfNN_aarch64_always_size_sections (bfd *output_bfd, 8761 struct bfd_link_info *info) 8762{ 8763 asection *tls_sec; 8764 8765 if (bfd_link_relocatable (info)) 8766 return TRUE; 8767 8768 tls_sec = elf_hash_table (info)->tls_sec; 8769 8770 if (tls_sec) 8771 { 8772 struct elf_link_hash_entry *tlsbase; 8773 8774 tlsbase = elf_link_hash_lookup (elf_hash_table (info), 8775 "_TLS_MODULE_BASE_", TRUE, TRUE, FALSE); 8776 8777 if (tlsbase) 8778 { 8779 struct bfd_link_hash_entry *h = NULL; 8780 const struct elf_backend_data *bed = 8781 get_elf_backend_data (output_bfd); 8782 8783 if (!(_bfd_generic_link_add_one_symbol 8784 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL, 8785 tls_sec, 0, NULL, FALSE, bed->collect, &h))) 8786 return FALSE; 8787 8788 tlsbase->type = STT_TLS; 8789 tlsbase = (struct elf_link_hash_entry *) h; 8790 tlsbase->def_regular = 1; 8791 tlsbase->other = STV_HIDDEN; 8792 (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE); 8793 } 8794 } 8795 8796 return TRUE; 8797} 8798 8799/* Finish up dynamic symbol handling. We set the contents of various 8800 dynamic sections here. */ 8801static bfd_boolean 8802elfNN_aarch64_finish_dynamic_symbol (bfd *output_bfd, 8803 struct bfd_link_info *info, 8804 struct elf_link_hash_entry *h, 8805 Elf_Internal_Sym *sym) 8806{ 8807 struct elf_aarch64_link_hash_table *htab; 8808 htab = elf_aarch64_hash_table (info); 8809 8810 if (h->plt.offset != (bfd_vma) - 1) 8811 { 8812 asection *plt, *gotplt, *relplt; 8813 8814 /* This symbol has an entry in the procedure linkage table. Set 8815 it up. */ 8816 8817 /* When building a static executable, use .iplt, .igot.plt and 8818 .rela.iplt sections for STT_GNU_IFUNC symbols. */ 8819 if (htab->root.splt != NULL) 8820 { 8821 plt = htab->root.splt; 8822 gotplt = htab->root.sgotplt; 8823 relplt = htab->root.srelplt; 8824 } 8825 else 8826 { 8827 plt = htab->root.iplt; 8828 gotplt = htab->root.igotplt; 8829 relplt = htab->root.irelplt; 8830 } 8831 8832 /* This symbol has an entry in the procedure linkage table. Set 8833 it up. */ 8834 if ((h->dynindx == -1 8835 && !((h->forced_local || bfd_link_executable (info)) 8836 && h->def_regular 8837 && h->type == STT_GNU_IFUNC)) 8838 || plt == NULL 8839 || gotplt == NULL 8840 || relplt == NULL) 8841 abort (); 8842 8843 elfNN_aarch64_create_small_pltn_entry (h, htab, output_bfd, info); 8844 if (!h->def_regular) 8845 { 8846 /* Mark the symbol as undefined, rather than as defined in 8847 the .plt section. */ 8848 sym->st_shndx = SHN_UNDEF; 8849 /* If the symbol is weak we need to clear the value. 8850 Otherwise, the PLT entry would provide a definition for 8851 the symbol even if the symbol wasn't defined anywhere, 8852 and so the symbol would never be NULL. Leave the value if 8853 there were any relocations where pointer equality matters 8854 (this is a clue for the dynamic linker, to make function 8855 pointer comparisons work between an application and shared 8856 library). */ 8857 if (!h->ref_regular_nonweak || !h->pointer_equality_needed) 8858 sym->st_value = 0; 8859 } 8860 } 8861 8862 if (h->got.offset != (bfd_vma) - 1 8863 && elf_aarch64_hash_entry (h)->got_type == GOT_NORMAL) 8864 { 8865 Elf_Internal_Rela rela; 8866 bfd_byte *loc; 8867 8868 /* This symbol has an entry in the global offset table. Set it 8869 up. */ 8870 if (htab->root.sgot == NULL || htab->root.srelgot == NULL) 8871 abort (); 8872 8873 rela.r_offset = (htab->root.sgot->output_section->vma 8874 + htab->root.sgot->output_offset 8875 + (h->got.offset & ~(bfd_vma) 1)); 8876 8877 if (h->def_regular 8878 && h->type == STT_GNU_IFUNC) 8879 { 8880 if (bfd_link_pic (info)) 8881 { 8882 /* Generate R_AARCH64_GLOB_DAT. */ 8883 goto do_glob_dat; 8884 } 8885 else 8886 { 8887 asection *plt; 8888 8889 if (!h->pointer_equality_needed) 8890 abort (); 8891 8892 /* For non-shared object, we can't use .got.plt, which 8893 contains the real function address if we need pointer 8894 equality. We load the GOT entry with the PLT entry. */ 8895 plt = htab->root.splt ? htab->root.splt : htab->root.iplt; 8896 bfd_put_NN (output_bfd, (plt->output_section->vma 8897 + plt->output_offset 8898 + h->plt.offset), 8899 htab->root.sgot->contents 8900 + (h->got.offset & ~(bfd_vma) 1)); 8901 return TRUE; 8902 } 8903 } 8904 else if (bfd_link_pic (info) && SYMBOL_REFERENCES_LOCAL (info, h)) 8905 { 8906 if (!(h->def_regular || ELF_COMMON_DEF_P (h))) 8907 return FALSE; 8908 8909 BFD_ASSERT ((h->got.offset & 1) != 0); 8910 rela.r_info = ELFNN_R_INFO (0, AARCH64_R (RELATIVE)); 8911 rela.r_addend = (h->root.u.def.value 8912 + h->root.u.def.section->output_section->vma 8913 + h->root.u.def.section->output_offset); 8914 } 8915 else 8916 { 8917do_glob_dat: 8918 BFD_ASSERT ((h->got.offset & 1) == 0); 8919 bfd_put_NN (output_bfd, (bfd_vma) 0, 8920 htab->root.sgot->contents + h->got.offset); 8921 rela.r_info = ELFNN_R_INFO (h->dynindx, AARCH64_R (GLOB_DAT)); 8922 rela.r_addend = 0; 8923 } 8924 8925 loc = htab->root.srelgot->contents; 8926 loc += htab->root.srelgot->reloc_count++ * RELOC_SIZE (htab); 8927 bfd_elfNN_swap_reloca_out (output_bfd, &rela, loc); 8928 } 8929 8930 if (h->needs_copy) 8931 { 8932 Elf_Internal_Rela rela; 8933 asection *s; 8934 bfd_byte *loc; 8935 8936 /* This symbol needs a copy reloc. Set it up. */ 8937 8938 if (h->dynindx == -1 8939 || (h->root.type != bfd_link_hash_defined 8940 && h->root.type != bfd_link_hash_defweak) 8941 || htab->root.srelbss == NULL) 8942 abort (); 8943 8944 rela.r_offset = (h->root.u.def.value 8945 + h->root.u.def.section->output_section->vma 8946 + h->root.u.def.section->output_offset); 8947 rela.r_info = ELFNN_R_INFO (h->dynindx, AARCH64_R (COPY)); 8948 rela.r_addend = 0; 8949 if (h->root.u.def.section == htab->root.sdynrelro) 8950 s = htab->root.sreldynrelro; 8951 else 8952 s = htab->root.srelbss; 8953 loc = s->contents + s->reloc_count++ * RELOC_SIZE (htab); 8954 bfd_elfNN_swap_reloca_out (output_bfd, &rela, loc); 8955 } 8956 8957 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. SYM may 8958 be NULL for local symbols. */ 8959 if (sym != NULL 8960 && (h == elf_hash_table (info)->hdynamic 8961 || h == elf_hash_table (info)->hgot)) 8962 sym->st_shndx = SHN_ABS; 8963 8964 return TRUE; 8965} 8966 8967/* Finish up local dynamic symbol handling. We set the contents of 8968 various dynamic sections here. */ 8969 8970static bfd_boolean 8971elfNN_aarch64_finish_local_dynamic_symbol (void **slot, void *inf) 8972{ 8973 struct elf_link_hash_entry *h 8974 = (struct elf_link_hash_entry *) *slot; 8975 struct bfd_link_info *info 8976 = (struct bfd_link_info *) inf; 8977 8978 return elfNN_aarch64_finish_dynamic_symbol (info->output_bfd, 8979 info, h, NULL); 8980} 8981 8982static void 8983elfNN_aarch64_init_small_plt0_entry (bfd *output_bfd ATTRIBUTE_UNUSED, 8984 struct elf_aarch64_link_hash_table 8985 *htab) 8986{ 8987 /* Fill in PLT0. Fixme:RR Note this doesn't distinguish between 8988 small and large plts and at the minute just generates 8989 the small PLT. */ 8990 8991 /* PLT0 of the small PLT looks like this in ELF64 - 8992 stp x16, x30, [sp, #-16]! // Save the reloc and lr on stack. 8993 adrp x16, PLT_GOT + 16 // Get the page base of the GOTPLT 8994 ldr x17, [x16, #:lo12:PLT_GOT+16] // Load the address of the 8995 // symbol resolver 8996 add x16, x16, #:lo12:PLT_GOT+16 // Load the lo12 bits of the 8997 // GOTPLT entry for this. 8998 br x17 8999 PLT0 will be slightly different in ELF32 due to different got entry 9000 size. 9001 */ 9002 bfd_vma plt_got_2nd_ent; /* Address of GOT[2]. */ 9003 bfd_vma plt_base; 9004 9005 9006 memcpy (htab->root.splt->contents, elfNN_aarch64_small_plt0_entry, 9007 PLT_ENTRY_SIZE); 9008 elf_section_data (htab->root.splt->output_section)->this_hdr.sh_entsize = 9009 PLT_ENTRY_SIZE; 9010 9011 plt_got_2nd_ent = (htab->root.sgotplt->output_section->vma 9012 + htab->root.sgotplt->output_offset 9013 + GOT_ENTRY_SIZE * 2); 9014 9015 plt_base = htab->root.splt->output_section->vma + 9016 htab->root.splt->output_offset; 9017 9018 /* Fill in the top 21 bits for this: ADRP x16, PLT_GOT + n * 8. 9019 ADRP: ((PG(S+A)-PG(P)) >> 12) & 0x1fffff */ 9020 elf_aarch64_update_plt_entry (output_bfd, BFD_RELOC_AARCH64_ADR_HI21_PCREL, 9021 htab->root.splt->contents + 4, 9022 PG (plt_got_2nd_ent) - PG (plt_base + 4)); 9023 9024 elf_aarch64_update_plt_entry (output_bfd, BFD_RELOC_AARCH64_LDSTNN_LO12, 9025 htab->root.splt->contents + 8, 9026 PG_OFFSET (plt_got_2nd_ent)); 9027 9028 elf_aarch64_update_plt_entry (output_bfd, BFD_RELOC_AARCH64_ADD_LO12, 9029 htab->root.splt->contents + 12, 9030 PG_OFFSET (plt_got_2nd_ent)); 9031} 9032 9033static bfd_boolean 9034elfNN_aarch64_finish_dynamic_sections (bfd *output_bfd, 9035 struct bfd_link_info *info) 9036{ 9037 struct elf_aarch64_link_hash_table *htab; 9038 bfd *dynobj; 9039 asection *sdyn; 9040 9041 htab = elf_aarch64_hash_table (info); 9042 dynobj = htab->root.dynobj; 9043 sdyn = bfd_get_linker_section (dynobj, ".dynamic"); 9044 9045 if (htab->root.dynamic_sections_created) 9046 { 9047 ElfNN_External_Dyn *dyncon, *dynconend; 9048 9049 if (sdyn == NULL || htab->root.sgot == NULL) 9050 abort (); 9051 9052 dyncon = (ElfNN_External_Dyn *) sdyn->contents; 9053 dynconend = (ElfNN_External_Dyn *) (sdyn->contents + sdyn->size); 9054 for (; dyncon < dynconend; dyncon++) 9055 { 9056 Elf_Internal_Dyn dyn; 9057 asection *s; 9058 9059 bfd_elfNN_swap_dyn_in (dynobj, dyncon, &dyn); 9060 9061 switch (dyn.d_tag) 9062 { 9063 default: 9064 continue; 9065 9066 case DT_PLTGOT: 9067 s = htab->root.sgotplt; 9068 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset; 9069 break; 9070 9071 case DT_JMPREL: 9072 s = htab->root.srelplt; 9073 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset; 9074 break; 9075 9076 case DT_PLTRELSZ: 9077 s = htab->root.srelplt; 9078 dyn.d_un.d_val = s->size; 9079 break; 9080 9081 case DT_TLSDESC_PLT: 9082 s = htab->root.splt; 9083 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset 9084 + htab->tlsdesc_plt; 9085 break; 9086 9087 case DT_TLSDESC_GOT: 9088 s = htab->root.sgot; 9089 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset 9090 + htab->dt_tlsdesc_got; 9091 break; 9092 } 9093 9094 bfd_elfNN_swap_dyn_out (output_bfd, &dyn, dyncon); 9095 } 9096 9097 } 9098 9099 /* Fill in the special first entry in the procedure linkage table. */ 9100 if (htab->root.splt && htab->root.splt->size > 0) 9101 { 9102 elfNN_aarch64_init_small_plt0_entry (output_bfd, htab); 9103 9104 elf_section_data (htab->root.splt->output_section)-> 9105 this_hdr.sh_entsize = htab->plt_entry_size; 9106 9107 9108 if (htab->tlsdesc_plt) 9109 { 9110 bfd_put_NN (output_bfd, (bfd_vma) 0, 9111 htab->root.sgot->contents + htab->dt_tlsdesc_got); 9112 9113 memcpy (htab->root.splt->contents + htab->tlsdesc_plt, 9114 elfNN_aarch64_tlsdesc_small_plt_entry, 9115 sizeof (elfNN_aarch64_tlsdesc_small_plt_entry)); 9116 9117 { 9118 bfd_vma adrp1_addr = 9119 htab->root.splt->output_section->vma 9120 + htab->root.splt->output_offset + htab->tlsdesc_plt + 4; 9121 9122 bfd_vma adrp2_addr = adrp1_addr + 4; 9123 9124 bfd_vma got_addr = 9125 htab->root.sgot->output_section->vma 9126 + htab->root.sgot->output_offset; 9127 9128 bfd_vma pltgot_addr = 9129 htab->root.sgotplt->output_section->vma 9130 + htab->root.sgotplt->output_offset; 9131 9132 bfd_vma dt_tlsdesc_got = got_addr + htab->dt_tlsdesc_got; 9133 9134 bfd_byte *plt_entry = 9135 htab->root.splt->contents + htab->tlsdesc_plt; 9136 9137 /* adrp x2, DT_TLSDESC_GOT */ 9138 elf_aarch64_update_plt_entry (output_bfd, 9139 BFD_RELOC_AARCH64_ADR_HI21_PCREL, 9140 plt_entry + 4, 9141 (PG (dt_tlsdesc_got) 9142 - PG (adrp1_addr))); 9143 9144 /* adrp x3, 0 */ 9145 elf_aarch64_update_plt_entry (output_bfd, 9146 BFD_RELOC_AARCH64_ADR_HI21_PCREL, 9147 plt_entry + 8, 9148 (PG (pltgot_addr) 9149 - PG (adrp2_addr))); 9150 9151 /* ldr x2, [x2, #0] */ 9152 elf_aarch64_update_plt_entry (output_bfd, 9153 BFD_RELOC_AARCH64_LDSTNN_LO12, 9154 plt_entry + 12, 9155 PG_OFFSET (dt_tlsdesc_got)); 9156 9157 /* add x3, x3, 0 */ 9158 elf_aarch64_update_plt_entry (output_bfd, 9159 BFD_RELOC_AARCH64_ADD_LO12, 9160 plt_entry + 16, 9161 PG_OFFSET (pltgot_addr)); 9162 } 9163 } 9164 } 9165 9166 if (htab->root.sgotplt) 9167 { 9168 if (bfd_is_abs_section (htab->root.sgotplt->output_section)) 9169 { 9170 _bfd_error_handler 9171 (_("discarded output section: `%A'"), htab->root.sgotplt); 9172 return FALSE; 9173 } 9174 9175 /* Fill in the first three entries in the global offset table. */ 9176 if (htab->root.sgotplt->size > 0) 9177 { 9178 bfd_put_NN (output_bfd, (bfd_vma) 0, htab->root.sgotplt->contents); 9179 9180 /* Write GOT[1] and GOT[2], needed for the dynamic linker. */ 9181 bfd_put_NN (output_bfd, 9182 (bfd_vma) 0, 9183 htab->root.sgotplt->contents + GOT_ENTRY_SIZE); 9184 bfd_put_NN (output_bfd, 9185 (bfd_vma) 0, 9186 htab->root.sgotplt->contents + GOT_ENTRY_SIZE * 2); 9187 } 9188 9189 if (htab->root.sgot) 9190 { 9191 if (htab->root.sgot->size > 0) 9192 { 9193 bfd_vma addr = 9194 sdyn ? sdyn->output_section->vma + sdyn->output_offset : 0; 9195 bfd_put_NN (output_bfd, addr, htab->root.sgot->contents); 9196 } 9197 } 9198 9199 elf_section_data (htab->root.sgotplt->output_section)-> 9200 this_hdr.sh_entsize = GOT_ENTRY_SIZE; 9201 } 9202 9203 if (htab->root.sgot && htab->root.sgot->size > 0) 9204 elf_section_data (htab->root.sgot->output_section)->this_hdr.sh_entsize 9205 = GOT_ENTRY_SIZE; 9206 9207 /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols. */ 9208 htab_traverse (htab->loc_hash_table, 9209 elfNN_aarch64_finish_local_dynamic_symbol, 9210 info); 9211 9212 return TRUE; 9213} 9214 9215/* Return address for Ith PLT stub in section PLT, for relocation REL 9216 or (bfd_vma) -1 if it should not be included. */ 9217 9218static bfd_vma 9219elfNN_aarch64_plt_sym_val (bfd_vma i, const asection *plt, 9220 const arelent *rel ATTRIBUTE_UNUSED) 9221{ 9222 return plt->vma + PLT_ENTRY_SIZE + i * PLT_SMALL_ENTRY_SIZE; 9223} 9224 9225/* Returns TRUE if NAME is an AArch64 mapping symbol. 9226 The ARM ELF standard defines $x (for A64 code) and $d (for data). 9227 It also allows a period initiated suffix to be added to the symbol, ie: 9228 "$[adtx]\.[:sym_char]+". */ 9229 9230static bfd_boolean 9231is_aarch64_mapping_symbol (const char * name) 9232{ 9233 return name != NULL /* Paranoia. */ 9234 && name[0] == '$' /* Note: if objcopy --prefix-symbols has been used then 9235 the mapping symbols could have acquired a prefix. 9236 We do not support this here, since such symbols no 9237 longer conform to the ARM ELF ABI. */ 9238 && (name[1] == 'd' || name[1] == 'x') 9239 && (name[2] == 0 || name[2] == '.'); 9240 /* FIXME: Strictly speaking the symbol is only a valid mapping symbol if 9241 any characters that follow the period are legal characters for the body 9242 of a symbol's name. For now we just assume that this is the case. */ 9243} 9244 9245/* Make sure that mapping symbols in object files are not removed via the 9246 "strip --strip-unneeded" tool. These symbols might needed in order to 9247 correctly generate linked files. Once an object file has been linked, 9248 it should be safe to remove them. */ 9249 9250static void 9251elfNN_aarch64_backend_symbol_processing (bfd *abfd, asymbol *sym) 9252{ 9253 if (((abfd->flags & (EXEC_P | DYNAMIC)) == 0) 9254 && sym->section != bfd_abs_section_ptr 9255 && is_aarch64_mapping_symbol (sym->name)) 9256 sym->flags |= BSF_KEEP; 9257} 9258 9259 9260/* We use this so we can override certain functions 9261 (though currently we don't). */ 9262 9263const struct elf_size_info elfNN_aarch64_size_info = 9264{ 9265 sizeof (ElfNN_External_Ehdr), 9266 sizeof (ElfNN_External_Phdr), 9267 sizeof (ElfNN_External_Shdr), 9268 sizeof (ElfNN_External_Rel), 9269 sizeof (ElfNN_External_Rela), 9270 sizeof (ElfNN_External_Sym), 9271 sizeof (ElfNN_External_Dyn), 9272 sizeof (Elf_External_Note), 9273 4, /* Hash table entry size. */ 9274 1, /* Internal relocs per external relocs. */ 9275 ARCH_SIZE, /* Arch size. */ 9276 LOG_FILE_ALIGN, /* Log_file_align. */ 9277 ELFCLASSNN, EV_CURRENT, 9278 bfd_elfNN_write_out_phdrs, 9279 bfd_elfNN_write_shdrs_and_ehdr, 9280 bfd_elfNN_checksum_contents, 9281 bfd_elfNN_write_relocs, 9282 bfd_elfNN_swap_symbol_in, 9283 bfd_elfNN_swap_symbol_out, 9284 bfd_elfNN_slurp_reloc_table, 9285 bfd_elfNN_slurp_symbol_table, 9286 bfd_elfNN_swap_dyn_in, 9287 bfd_elfNN_swap_dyn_out, 9288 bfd_elfNN_swap_reloc_in, 9289 bfd_elfNN_swap_reloc_out, 9290 bfd_elfNN_swap_reloca_in, 9291 bfd_elfNN_swap_reloca_out 9292}; 9293 9294#define ELF_ARCH bfd_arch_aarch64 9295#define ELF_MACHINE_CODE EM_AARCH64 9296#define ELF_MAXPAGESIZE 0x10000 9297#define ELF_MINPAGESIZE 0x1000 9298#define ELF_COMMONPAGESIZE 0x1000 9299 9300#define bfd_elfNN_close_and_cleanup \ 9301 elfNN_aarch64_close_and_cleanup 9302 9303#define bfd_elfNN_bfd_free_cached_info \ 9304 elfNN_aarch64_bfd_free_cached_info 9305 9306#define bfd_elfNN_bfd_is_target_special_symbol \ 9307 elfNN_aarch64_is_target_special_symbol 9308 9309#define bfd_elfNN_bfd_link_hash_table_create \ 9310 elfNN_aarch64_link_hash_table_create 9311 9312#define bfd_elfNN_bfd_merge_private_bfd_data \ 9313 elfNN_aarch64_merge_private_bfd_data 9314 9315#define bfd_elfNN_bfd_print_private_bfd_data \ 9316 elfNN_aarch64_print_private_bfd_data 9317 9318#define bfd_elfNN_bfd_reloc_type_lookup \ 9319 elfNN_aarch64_reloc_type_lookup 9320 9321#define bfd_elfNN_bfd_reloc_name_lookup \ 9322 elfNN_aarch64_reloc_name_lookup 9323 9324#define bfd_elfNN_bfd_set_private_flags \ 9325 elfNN_aarch64_set_private_flags 9326 9327#define bfd_elfNN_find_inliner_info \ 9328 elfNN_aarch64_find_inliner_info 9329 9330#define bfd_elfNN_find_nearest_line \ 9331 elfNN_aarch64_find_nearest_line 9332 9333#define bfd_elfNN_mkobject \ 9334 elfNN_aarch64_mkobject 9335 9336#define bfd_elfNN_new_section_hook \ 9337 elfNN_aarch64_new_section_hook 9338 9339#define elf_backend_adjust_dynamic_symbol \ 9340 elfNN_aarch64_adjust_dynamic_symbol 9341 9342#define elf_backend_always_size_sections \ 9343 elfNN_aarch64_always_size_sections 9344 9345#define elf_backend_check_relocs \ 9346 elfNN_aarch64_check_relocs 9347 9348#define elf_backend_copy_indirect_symbol \ 9349 elfNN_aarch64_copy_indirect_symbol 9350 9351/* Create .dynbss, and .rela.bss sections in DYNOBJ, and set up shortcuts 9352 to them in our hash. */ 9353#define elf_backend_create_dynamic_sections \ 9354 elfNN_aarch64_create_dynamic_sections 9355 9356#define elf_backend_init_index_section \ 9357 _bfd_elf_init_2_index_sections 9358 9359#define elf_backend_finish_dynamic_sections \ 9360 elfNN_aarch64_finish_dynamic_sections 9361 9362#define elf_backend_finish_dynamic_symbol \ 9363 elfNN_aarch64_finish_dynamic_symbol 9364 9365#define elf_backend_gc_sweep_hook \ 9366 elfNN_aarch64_gc_sweep_hook 9367 9368#define elf_backend_object_p \ 9369 elfNN_aarch64_object_p 9370 9371#define elf_backend_output_arch_local_syms \ 9372 elfNN_aarch64_output_arch_local_syms 9373 9374#define elf_backend_plt_sym_val \ 9375 elfNN_aarch64_plt_sym_val 9376 9377#define elf_backend_post_process_headers \ 9378 elfNN_aarch64_post_process_headers 9379 9380#define elf_backend_relocate_section \ 9381 elfNN_aarch64_relocate_section 9382 9383#define elf_backend_reloc_type_class \ 9384 elfNN_aarch64_reloc_type_class 9385 9386#define elf_backend_section_from_shdr \ 9387 elfNN_aarch64_section_from_shdr 9388 9389#define elf_backend_size_dynamic_sections \ 9390 elfNN_aarch64_size_dynamic_sections 9391 9392#define elf_backend_size_info \ 9393 elfNN_aarch64_size_info 9394 9395#define elf_backend_write_section \ 9396 elfNN_aarch64_write_section 9397 9398#define elf_backend_symbol_processing \ 9399 elfNN_aarch64_backend_symbol_processing 9400 9401#define elf_backend_can_refcount 1 9402#define elf_backend_can_gc_sections 1 9403#define elf_backend_plt_readonly 1 9404#define elf_backend_want_got_plt 1 9405#define elf_backend_want_plt_sym 0 9406#define elf_backend_want_dynrelro 1 9407#define elf_backend_may_use_rel_p 0 9408#define elf_backend_may_use_rela_p 1 9409#define elf_backend_default_use_rela_p 1 9410#define elf_backend_rela_normal 1 9411#define elf_backend_dtrel_excludes_plt 1 9412#define elf_backend_got_header_size (GOT_ENTRY_SIZE * 3) 9413#define elf_backend_default_execstack 0 9414#define elf_backend_extern_protected_data 1 9415 9416#undef elf_backend_obj_attrs_section 9417#define elf_backend_obj_attrs_section ".ARM.attributes" 9418 9419#include "elfNN-target.h" 9420 9421/* CloudABI support. */ 9422 9423#undef TARGET_LITTLE_SYM 9424#define TARGET_LITTLE_SYM aarch64_elfNN_le_cloudabi_vec 9425#undef TARGET_LITTLE_NAME 9426#define TARGET_LITTLE_NAME "elfNN-littleaarch64-cloudabi" 9427#undef TARGET_BIG_SYM 9428#define TARGET_BIG_SYM aarch64_elfNN_be_cloudabi_vec 9429#undef TARGET_BIG_NAME 9430#define TARGET_BIG_NAME "elfNN-bigaarch64-cloudabi" 9431 9432#undef ELF_OSABI 9433#define ELF_OSABI ELFOSABI_CLOUDABI 9434 9435#undef elfNN_bed 9436#define elfNN_bed elfNN_aarch64_cloudabi_bed 9437 9438#include "elfNN-target.h" 9439