bfd/elfnn-aarch64.c

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