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