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