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