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