bfd/elfnn-aarch64.c

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