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