bfd/elfnn-aarch64.c

   1 /* AArch64-specific support for NN-bit ELF.
   2    Copyright (C) 2009-2016 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   /* Short-cuts to get to dynamic linker sections.  */
2300   asection *sdynbss;
2301   asection *srelbss;
2302
2303   /* Small local sym cache.  */
2304   struct sym_cache sym_cache;
2305
2306   /* For convenience in allocate_dynrelocs.  */
2307   bfd *obfd;
2308
2309   /* The amount of space used by the reserved portion of the sgotplt
2310      section, plus whatever space is used by the jump slots.  */
2311   bfd_vma sgotplt_jump_table_size;
2312
2313   /* The stub hash table.  */
2314   struct bfd_hash_table stub_hash_table;
2315
2316   /* Linker stub bfd.  */
2317   bfd *stub_bfd;
2318
2319   /* Linker call-backs.  */
2320   asection *(*add_stub_section) (const char *, asection *);
2321   void (*layout_sections_again) (void);
2322
2323   /* Array to keep track of which stub sections have been created, and
2324      information on stub grouping.  */
2325   struct map_stub
2326   {
2327     /* This is the section to which stubs in the group will be
2328        attached.  */
2329     asection *link_sec;
2330     /* The stub section.  */
2331     asection *stub_sec;
2332   } *stub_group;
2333
2334   /* Assorted information used by elfNN_aarch64_size_stubs.  */
2335   unsigned int bfd_count;
2336   unsigned int top_index;
2337   asection **input_list;
2338
2339   /* The offset into splt of the PLT entry for the TLS descriptor
2340      resolver.  Special values are 0, if not necessary (or not found
2341      to be necessary yet), and -1 if needed but not determined
2342      yet.  */
2343   bfd_vma tlsdesc_plt;
2344
2345   /* The GOT offset for the lazy trampoline.  Communicated to the
2346      loader via DT_TLSDESC_GOT.  The magic value (bfd_vma) -1
2347      indicates an offset is not allocated.  */
2348   bfd_vma dt_tlsdesc_got;
2349
2350   /* Used by local STT_GNU_IFUNC symbols.  */
2351   htab_t loc_hash_table;
2352   void * loc_hash_memory;
2353 };
2354
2355 /* Create an entry in an AArch64 ELF linker hash table.  */
2356
2357 static struct bfd_hash_entry *
2358 elfNN_aarch64_link_hash_newfunc (struct bfd_hash_entry *entry,
2359                                  struct bfd_hash_table *table,
2360                                  const char *string)
2361 {
2362   struct elf_aarch64_link_hash_entry *ret =
2363     (struct elf_aarch64_link_hash_entry *) entry;
2364
2365   /* Allocate the structure if it has not already been allocated by a
2366      subclass.  */
2367   if (ret == NULL)
2368     ret = bfd_hash_allocate (table,
2369                              sizeof (struct elf_aarch64_link_hash_entry));
2370   if (ret == NULL)
2371     return (struct bfd_hash_entry *) ret;
2372
2373   /* Call the allocation method of the superclass.  */
2374   ret = ((struct elf_aarch64_link_hash_entry *)
2375          _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
2376                                      table, string));
2377   if (ret != NULL)
2378     {
2379       ret->dyn_relocs = NULL;
2380       ret->got_type = GOT_UNKNOWN;
2381       ret->plt_got_offset = (bfd_vma) - 1;
2382       ret->stub_cache = NULL;
2383       ret->tlsdesc_got_jump_table_offset = (bfd_vma) - 1;
2384     }
2385
2386   return (struct bfd_hash_entry *) ret;
2387 }
2388
2389 /* Initialize an entry in the stub hash table.  */
2390
2391 static struct bfd_hash_entry *
2392 stub_hash_newfunc (struct bfd_hash_entry *entry,
2393                    struct bfd_hash_table *table, const char *string)
2394 {
2395   /* Allocate the structure if it has not already been allocated by a
2396      subclass.  */
2397   if (entry == NULL)
2398     {
2399       entry = bfd_hash_allocate (table,
2400                                  sizeof (struct
2401                                          elf_aarch64_stub_hash_entry));
2402       if (entry == NULL)
2403         return entry;
2404     }
2405
2406   /* Call the allocation method of the superclass.  */
2407   entry = bfd_hash_newfunc (entry, table, string);
2408   if (entry != NULL)
2409     {
2410       struct elf_aarch64_stub_hash_entry *eh;
2411
2412       /* Initialize the local fields.  */
2413       eh = (struct elf_aarch64_stub_hash_entry *) entry;
2414       eh->adrp_offset = 0;
2415       eh->stub_sec = NULL;
2416       eh->stub_offset = 0;
2417       eh->target_value = 0;
2418       eh->target_section = NULL;
2419       eh->stub_type = aarch64_stub_none;
2420       eh->h = NULL;
2421       eh->id_sec = NULL;
2422     }
2423
2424   return entry;
2425 }
2426
2427 /* Compute a hash of a local hash entry.  We use elf_link_hash_entry
2428   for local symbol so that we can handle local STT_GNU_IFUNC symbols
2429   as global symbol.  We reuse indx and dynstr_index for local symbol
2430   hash since they aren't used by global symbols in this backend.  */
2431
2432 static hashval_t
2433 elfNN_aarch64_local_htab_hash (const void *ptr)
2434 {
2435   struct elf_link_hash_entry *h
2436     = (struct elf_link_hash_entry *) ptr;
2437   return ELF_LOCAL_SYMBOL_HASH (h->indx, h->dynstr_index);
2438 }
2439
2440 /* Compare local hash entries.  */
2441
2442 static int
2443 elfNN_aarch64_local_htab_eq (const void *ptr1, const void *ptr2)
2444 {
2445   struct elf_link_hash_entry *h1
2446      = (struct elf_link_hash_entry *) ptr1;
2447   struct elf_link_hash_entry *h2
2448     = (struct elf_link_hash_entry *) ptr2;
2449
2450   return h1->indx == h2->indx && h1->dynstr_index == h2->dynstr_index;
2451 }
2452
2453 /* Find and/or create a hash entry for local symbol.  */
2454
2455 static struct elf_link_hash_entry *
2456 elfNN_aarch64_get_local_sym_hash (struct elf_aarch64_link_hash_table *htab,
2457                                   bfd *abfd, const Elf_Internal_Rela *rel,
2458                                   bfd_boolean create)
2459 {
2460   struct elf_aarch64_link_hash_entry e, *ret;
2461   asection *sec = abfd->sections;
2462   hashval_t h = ELF_LOCAL_SYMBOL_HASH (sec->id,
2463                                        ELFNN_R_SYM (rel->r_info));
2464   void **slot;
2465
2466   e.root.indx = sec->id;
2467   e.root.dynstr_index = ELFNN_R_SYM (rel->r_info);
2468   slot = htab_find_slot_with_hash (htab->loc_hash_table, &e, h,
2469                                    create ? INSERT : NO_INSERT);
2470
2471   if (!slot)
2472     return NULL;
2473
2474   if (*slot)
2475     {
2476       ret = (struct elf_aarch64_link_hash_entry *) *slot;
2477       return &ret->root;
2478     }
2479
2480   ret = (struct elf_aarch64_link_hash_entry *)
2481         objalloc_alloc ((struct objalloc *) htab->loc_hash_memory,
2482                         sizeof (struct elf_aarch64_link_hash_entry));
2483   if (ret)
2484     {
2485       memset (ret, 0, sizeof (*ret));
2486       ret->root.indx = sec->id;
2487       ret->root.dynstr_index = ELFNN_R_SYM (rel->r_info);
2488       ret->root.dynindx = -1;
2489       *slot = ret;
2490     }
2491   return &ret->root;
2492 }
2493
2494 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
2495
2496 static void
2497 elfNN_aarch64_copy_indirect_symbol (struct bfd_link_info *info,
2498                                     struct elf_link_hash_entry *dir,
2499                                     struct elf_link_hash_entry *ind)
2500 {
2501   struct elf_aarch64_link_hash_entry *edir, *eind;
2502
2503   edir = (struct elf_aarch64_link_hash_entry *) dir;
2504   eind = (struct elf_aarch64_link_hash_entry *) ind;
2505
2506   if (eind->dyn_relocs != NULL)
2507     {
2508       if (edir->dyn_relocs != NULL)
2509         {
2510           struct elf_dyn_relocs **pp;
2511           struct elf_dyn_relocs *p;
2512
2513           /* Add reloc counts against the indirect sym to the direct sym
2514              list.  Merge any entries against the same section.  */
2515           for (pp = &eind->dyn_relocs; (p = *pp) != NULL;)
2516             {
2517               struct elf_dyn_relocs *q;
2518
2519               for (q = edir->dyn_relocs; q != NULL; q = q->next)
2520                 if (q->sec == p->sec)
2521                   {
2522                     q->pc_count += p->pc_count;
2523                     q->count += p->count;
2524                     *pp = p->next;
2525                     break;
2526                   }
2527               if (q == NULL)
2528                 pp = &p->next;
2529             }
2530           *pp = edir->dyn_relocs;
2531         }
2532
2533       edir->dyn_relocs = eind->dyn_relocs;
2534       eind->dyn_relocs = NULL;
2535     }
2536
2537   if (ind->root.type == bfd_link_hash_indirect)
2538     {
2539       /* Copy over PLT info.  */
2540       if (dir->got.refcount <= 0)
2541         {
2542           edir->got_type = eind->got_type;
2543           eind->got_type = GOT_UNKNOWN;
2544         }
2545     }
2546
2547   _bfd_elf_link_hash_copy_indirect (info, dir, ind);
2548 }
2549
2550 /* Destroy an AArch64 elf linker hash table.  */
2551
2552 static void
2553 elfNN_aarch64_link_hash_table_free (bfd *obfd)
2554 {
2555   struct elf_aarch64_link_hash_table *ret
2556     = (struct elf_aarch64_link_hash_table *) obfd->link.hash;
2557
2558   if (ret->loc_hash_table)
2559     htab_delete (ret->loc_hash_table);
2560   if (ret->loc_hash_memory)
2561     objalloc_free ((struct objalloc *) ret->loc_hash_memory);
2562
2563   bfd_hash_table_free (&ret->stub_hash_table);
2564   _bfd_elf_link_hash_table_free (obfd);
2565 }
2566
2567 /* Create an AArch64 elf linker hash table.  */
2568
2569 static struct bfd_link_hash_table *
2570 elfNN_aarch64_link_hash_table_create (bfd *abfd)
2571 {
2572   struct elf_aarch64_link_hash_table *ret;
2573   bfd_size_type amt = sizeof (struct elf_aarch64_link_hash_table);
2574
2575   ret = bfd_zmalloc (amt);
2576   if (ret == NULL)
2577     return NULL;
2578
2579   if (!_bfd_elf_link_hash_table_init
2580       (&ret->root, abfd, elfNN_aarch64_link_hash_newfunc,
2581        sizeof (struct elf_aarch64_link_hash_entry), AARCH64_ELF_DATA))
2582     {
2583       free (ret);
2584       return NULL;
2585     }
2586
2587   ret->plt_header_size = PLT_ENTRY_SIZE;
2588   ret->plt_entry_size = PLT_SMALL_ENTRY_SIZE;
2589   ret->obfd = abfd;
2590   ret->dt_tlsdesc_got = (bfd_vma) - 1;
2591
2592   if (!bfd_hash_table_init (&ret->stub_hash_table, stub_hash_newfunc,
2593                             sizeof (struct elf_aarch64_stub_hash_entry)))
2594     {
2595       _bfd_elf_link_hash_table_free (abfd);
2596       return NULL;
2597     }
2598
2599   ret->loc_hash_table = htab_try_create (1024,
2600                                          elfNN_aarch64_local_htab_hash,
2601                                          elfNN_aarch64_local_htab_eq,
2602                                          NULL);
2603   ret->loc_hash_memory = objalloc_create ();
2604   if (!ret->loc_hash_table || !ret->loc_hash_memory)
2605     {
2606       elfNN_aarch64_link_hash_table_free (abfd);
2607       return NULL;
2608     }
2609   ret->root.root.hash_table_free = elfNN_aarch64_link_hash_table_free;
2610
2611   return &ret->root.root;
2612 }
2613
2614 static bfd_boolean
2615 aarch64_relocate (unsigned int r_type, bfd *input_bfd, asection *input_section,
2616                   bfd_vma offset, bfd_vma value)
2617 {
2618   reloc_howto_type *howto;
2619   bfd_vma place;
2620
2621   howto = elfNN_aarch64_howto_from_type (r_type);
2622   place = (input_section->output_section->vma + input_section->output_offset
2623            + offset);
2624
2625   r_type = elfNN_aarch64_bfd_reloc_from_type (r_type);
2626   value = _bfd_aarch64_elf_resolve_relocation (r_type, place, value, 0, FALSE);
2627   return _bfd_aarch64_elf_put_addend (input_bfd,
2628                                       input_section->contents + offset, r_type,
2629                                       howto, value);
2630 }
2631
2632 static enum elf_aarch64_stub_type
2633 aarch64_select_branch_stub (bfd_vma value, bfd_vma place)
2634 {
2635   if (aarch64_valid_for_adrp_p (value, place))
2636     return aarch64_stub_adrp_branch;
2637   return aarch64_stub_long_branch;
2638 }
2639
2640 /* Determine the type of stub needed, if any, for a call.  */
2641
2642 static enum elf_aarch64_stub_type
2643 aarch64_type_of_stub (asection *input_sec,
2644                       const Elf_Internal_Rela *rel,
2645                       asection *sym_sec,
2646                       unsigned char st_type,
2647                       bfd_vma destination)
2648 {
2649   bfd_vma location;
2650   bfd_signed_vma branch_offset;
2651   unsigned int r_type;
2652   enum elf_aarch64_stub_type stub_type = aarch64_stub_none;
2653
2654   if (st_type != STT_FUNC
2655       && (sym_sec == input_sec))
2656     return stub_type;
2657
2658   /* Determine where the call point is.  */
2659   location = (input_sec->output_offset
2660               + input_sec->output_section->vma + rel->r_offset);
2661
2662   branch_offset = (bfd_signed_vma) (destination - location);
2663
2664   r_type = ELFNN_R_TYPE (rel->r_info);
2665
2666   /* We don't want to redirect any old unconditional jump in this way,
2667      only one which is being used for a sibcall, where it is
2668      acceptable for the IP0 and IP1 registers to be clobbered.  */
2669   if ((r_type == AARCH64_R (CALL26) || r_type == AARCH64_R (JUMP26))
2670       && (branch_offset > AARCH64_MAX_FWD_BRANCH_OFFSET
2671           || branch_offset < AARCH64_MAX_BWD_BRANCH_OFFSET))
2672     {
2673       stub_type = aarch64_stub_long_branch;
2674     }
2675
2676   return stub_type;
2677 }
2678
2679 /* Build a name for an entry in the stub hash table.  */
2680
2681 static char *
2682 elfNN_aarch64_stub_name (const asection *input_section,
2683                          const asection *sym_sec,
2684                          const struct elf_aarch64_link_hash_entry *hash,
2685                          const Elf_Internal_Rela *rel)
2686 {
2687   char *stub_name;
2688   bfd_size_type len;
2689
2690   if (hash)
2691     {
2692       len = 8 + 1 + strlen (hash->root.root.root.string) + 1 + 16 + 1;
2693       stub_name = bfd_malloc (len);
2694       if (stub_name != NULL)
2695         snprintf (stub_name, len, "%08x_%s+%" BFD_VMA_FMT "x",
2696                   (unsigned int) input_section->id,
2697                   hash->root.root.root.string,
2698                   rel->r_addend);
2699     }
2700   else
2701     {
2702       len = 8 + 1 + 8 + 1 + 8 + 1 + 16 + 1;
2703       stub_name = bfd_malloc (len);
2704       if (stub_name != NULL)
2705         snprintf (stub_name, len, "%08x_%x:%x+%" BFD_VMA_FMT "x",
2706                   (unsigned int) input_section->id,
2707                   (unsigned int) sym_sec->id,
2708                   (unsigned int) ELFNN_R_SYM (rel->r_info),
2709                   rel->r_addend);
2710     }
2711
2712   return stub_name;
2713 }
2714
2715 /* Look up an entry in the stub hash.  Stub entries are cached because
2716    creating the stub name takes a bit of time.  */
2717
2718 static struct elf_aarch64_stub_hash_entry *
2719 elfNN_aarch64_get_stub_entry (const asection *input_section,
2720                               const asection *sym_sec,
2721                               struct elf_link_hash_entry *hash,
2722                               const Elf_Internal_Rela *rel,
2723                               struct elf_aarch64_link_hash_table *htab)
2724 {
2725   struct elf_aarch64_stub_hash_entry *stub_entry;
2726   struct elf_aarch64_link_hash_entry *h =
2727     (struct elf_aarch64_link_hash_entry *) hash;
2728   const asection *id_sec;
2729
2730   if ((input_section->flags & SEC_CODE) == 0)
2731     return NULL;
2732
2733   /* If this input section is part of a group of sections sharing one
2734      stub section, then use the id of the first section in the group.
2735      Stub names need to include a section id, as there may well be
2736      more than one stub used to reach say, printf, and we need to
2737      distinguish between them.  */
2738   id_sec = htab->stub_group[input_section->id].link_sec;
2739
2740   if (h != NULL && h->stub_cache != NULL
2741       && h->stub_cache->h == h && h->stub_cache->id_sec == id_sec)
2742     {
2743       stub_entry = h->stub_cache;
2744     }
2745   else
2746     {
2747       char *stub_name;
2748
2749       stub_name = elfNN_aarch64_stub_name (id_sec, sym_sec, h, rel);
2750       if (stub_name == NULL)
2751         return NULL;
2752
2753       stub_entry = aarch64_stub_hash_lookup (&htab->stub_hash_table,
2754                                              stub_name, FALSE, FALSE);
2755       if (h != NULL)
2756         h->stub_cache = stub_entry;
2757
2758       free (stub_name);
2759     }
2760
2761   return stub_entry;
2762 }
2763
2764
2765 /* Create a stub section.  */
2766
2767 static asection *
2768 _bfd_aarch64_create_stub_section (asection *section,
2769                                   struct elf_aarch64_link_hash_table *htab)
2770 {
2771   size_t namelen;
2772   bfd_size_type len;
2773   char *s_name;
2774
2775   namelen = strlen (section->name);
2776   len = namelen + sizeof (STUB_SUFFIX);
2777   s_name = bfd_alloc (htab->stub_bfd, len);
2778   if (s_name == NULL)
2779     return NULL;
2780
2781   memcpy (s_name, section->name, namelen);
2782   memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
2783   return (*htab->add_stub_section) (s_name, section);
2784 }
2785
2786
2787 /* Find or create a stub section for a link section.
2788
2789    Fix or create the stub section used to collect stubs attached to
2790    the specified link section.  */
2791
2792 static asection *
2793 _bfd_aarch64_get_stub_for_link_section (asection *link_section,
2794                                         struct elf_aarch64_link_hash_table *htab)
2795 {
2796   if (htab->stub_group[link_section->id].stub_sec == NULL)
2797     htab->stub_group[link_section->id].stub_sec
2798       = _bfd_aarch64_create_stub_section (link_section, htab);
2799   return htab->stub_group[link_section->id].stub_sec;
2800 }
2801
2802
2803 /* Find or create a stub section in the stub group for an input
2804    section.  */
2805
2806 static asection *
2807 _bfd_aarch64_create_or_find_stub_sec (asection *section,
2808                                       struct elf_aarch64_link_hash_table *htab)
2809 {
2810   asection *link_sec = htab->stub_group[section->id].link_sec;
2811   return _bfd_aarch64_get_stub_for_link_section (link_sec, htab);
2812 }
2813
2814
2815 /* Add a new stub entry in the stub group associated with an input
2816    section to the stub hash.  Not all fields of the new stub entry are
2817    initialised.  */
2818
2819 static struct elf_aarch64_stub_hash_entry *
2820 _bfd_aarch64_add_stub_entry_in_group (const char *stub_name,
2821                                       asection *section,
2822                                       struct elf_aarch64_link_hash_table *htab)
2823 {
2824   asection *link_sec;
2825   asection *stub_sec;
2826   struct elf_aarch64_stub_hash_entry *stub_entry;
2827
2828   link_sec = htab->stub_group[section->id].link_sec;
2829   stub_sec = _bfd_aarch64_create_or_find_stub_sec (section, htab);
2830
2831   /* Enter this entry into the linker stub hash table.  */
2832   stub_entry = aarch64_stub_hash_lookup (&htab->stub_hash_table, stub_name,
2833                                          TRUE, FALSE);
2834   if (stub_entry == NULL)
2835     {
2836       (*_bfd_error_handler) (_("%s: cannot create stub entry %s"),
2837                              section->owner, stub_name);
2838       return NULL;
2839     }
2840
2841   stub_entry->stub_sec = stub_sec;
2842   stub_entry->stub_offset = 0;
2843   stub_entry->id_sec = link_sec;
2844
2845   return stub_entry;
2846 }
2847
2848 /* Add a new stub entry in the final stub section to the stub hash.
2849    Not all fields of the new stub entry are initialised.  */
2850
2851 static struct elf_aarch64_stub_hash_entry *
2852 _bfd_aarch64_add_stub_entry_after (const char *stub_name,
2853                                    asection *link_section,
2854                                    struct elf_aarch64_link_hash_table *htab)
2855 {
2856   asection *stub_sec;
2857   struct elf_aarch64_stub_hash_entry *stub_entry;
2858
2859   stub_sec = _bfd_aarch64_get_stub_for_link_section (link_section, htab);
2860   stub_entry = aarch64_stub_hash_lookup (&htab->stub_hash_table, stub_name,
2861                                          TRUE, FALSE);
2862   if (stub_entry == NULL)
2863     {
2864       (*_bfd_error_handler) (_("cannot create stub entry %s"), stub_name);
2865       return NULL;
2866     }
2867
2868   stub_entry->stub_sec = stub_sec;
2869   stub_entry->stub_offset = 0;
2870   stub_entry->id_sec = link_section;
2871
2872   return stub_entry;
2873 }
2874
2875
2876 static bfd_boolean
2877 aarch64_build_one_stub (struct bfd_hash_entry *gen_entry,
2878                         void *in_arg ATTRIBUTE_UNUSED)
2879 {
2880   struct elf_aarch64_stub_hash_entry *stub_entry;
2881   asection *stub_sec;
2882   bfd *stub_bfd;
2883   bfd_byte *loc;
2884   bfd_vma sym_value;
2885   bfd_vma veneered_insn_loc;
2886   bfd_vma veneer_entry_loc;
2887   bfd_signed_vma branch_offset = 0;
2888   unsigned int template_size;
2889   const uint32_t *template;
2890   unsigned int i;
2891
2892   /* Massage our args to the form they really have.  */
2893   stub_entry = (struct elf_aarch64_stub_hash_entry *) gen_entry;
2894
2895   stub_sec = stub_entry->stub_sec;
2896
2897   /* Make a note of the offset within the stubs for this entry.  */
2898   stub_entry->stub_offset = stub_sec->size;
2899   loc = stub_sec->contents + stub_entry->stub_offset;
2900
2901   stub_bfd = stub_sec->owner;
2902
2903   /* This is the address of the stub destination.  */
2904   sym_value = (stub_entry->target_value
2905                + stub_entry->target_section->output_offset
2906                + stub_entry->target_section->output_section->vma);
2907
2908   if (stub_entry->stub_type == aarch64_stub_long_branch)
2909     {
2910       bfd_vma place = (stub_entry->stub_offset + stub_sec->output_section->vma
2911                        + stub_sec->output_offset);
2912
2913       /* See if we can relax the stub.  */
2914       if (aarch64_valid_for_adrp_p (sym_value, place))
2915         stub_entry->stub_type = aarch64_select_branch_stub (sym_value, place);
2916     }
2917
2918   switch (stub_entry->stub_type)
2919     {
2920     case aarch64_stub_adrp_branch:
2921       template = aarch64_adrp_branch_stub;
2922       template_size = sizeof (aarch64_adrp_branch_stub);
2923       break;
2924     case aarch64_stub_long_branch:
2925       template = aarch64_long_branch_stub;
2926       template_size = sizeof (aarch64_long_branch_stub);
2927       break;
2928     case aarch64_stub_erratum_835769_veneer:
2929       template = aarch64_erratum_835769_stub;
2930       template_size = sizeof (aarch64_erratum_835769_stub);
2931       break;
2932     case aarch64_stub_erratum_843419_veneer:
2933       template = aarch64_erratum_843419_stub;
2934       template_size = sizeof (aarch64_erratum_843419_stub);
2935       break;
2936     default:
2937       abort ();
2938     }
2939
2940   for (i = 0; i < (template_size / sizeof template[0]); i++)
2941     {
2942       bfd_putl32 (template[i], loc);
2943       loc += 4;
2944     }
2945
2946   template_size = (template_size + 7) & ~7;
2947   stub_sec->size += template_size;
2948
2949   switch (stub_entry->stub_type)
2950     {
2951     case aarch64_stub_adrp_branch:
2952       if (aarch64_relocate (AARCH64_R (ADR_PREL_PG_HI21), stub_bfd, stub_sec,
2953                             stub_entry->stub_offset, sym_value))
2954         /* The stub would not have been relaxed if the offset was out
2955            of range.  */
2956         BFD_FAIL ();
2957
2958       if (aarch64_relocate (AARCH64_R (ADD_ABS_LO12_NC), stub_bfd, stub_sec,
2959                             stub_entry->stub_offset + 4, sym_value))
2960         BFD_FAIL ();
2961       break;
2962
2963     case aarch64_stub_long_branch:
2964       /* We want the value relative to the address 12 bytes back from the
2965          value itself.  */
2966       if (aarch64_relocate (AARCH64_R (PRELNN), stub_bfd, stub_sec,
2967                             stub_entry->stub_offset + 16, sym_value + 12))
2968         BFD_FAIL ();
2969       break;
2970
2971     case aarch64_stub_erratum_835769_veneer:
2972       veneered_insn_loc = stub_entry->target_section->output_section->vma
2973                           + stub_entry->target_section->output_offset
2974                           + stub_entry->target_value;
2975       veneer_entry_loc = stub_entry->stub_sec->output_section->vma
2976                           + stub_entry->stub_sec->output_offset
2977                           + stub_entry->stub_offset;
2978       branch_offset = veneered_insn_loc - veneer_entry_loc;
2979       branch_offset >>= 2;
2980       branch_offset &= 0x3ffffff;
2981       bfd_putl32 (stub_entry->veneered_insn,
2982                   stub_sec->contents + stub_entry->stub_offset);
2983       bfd_putl32 (template[1] | branch_offset,
2984                   stub_sec->contents + stub_entry->stub_offset + 4);
2985       break;
2986
2987     case aarch64_stub_erratum_843419_veneer:
2988       if (aarch64_relocate (AARCH64_R (JUMP26), stub_bfd, stub_sec,
2989                             stub_entry->stub_offset + 4, sym_value + 4))
2990         BFD_FAIL ();
2991       break;
2992
2993     default:
2994       abort ();
2995     }
2996
2997   return TRUE;
2998 }
2999
3000 /* As above, but don't actually build the stub.  Just bump offset so
3001    we know stub section sizes.  */
3002
3003 static bfd_boolean
3004 aarch64_size_one_stub (struct bfd_hash_entry *gen_entry,
3005                        void *in_arg ATTRIBUTE_UNUSED)
3006 {
3007   struct elf_aarch64_stub_hash_entry *stub_entry;
3008   int size;
3009
3010   /* Massage our args to the form they really have.  */
3011   stub_entry = (struct elf_aarch64_stub_hash_entry *) gen_entry;
3012
3013   switch (stub_entry->stub_type)
3014     {
3015     case aarch64_stub_adrp_branch:
3016       size = sizeof (aarch64_adrp_branch_stub);
3017       break;
3018     case aarch64_stub_long_branch:
3019       size = sizeof (aarch64_long_branch_stub);
3020       break;
3021     case aarch64_stub_erratum_835769_veneer:
3022       size = sizeof (aarch64_erratum_835769_stub);
3023       break;
3024     case aarch64_stub_erratum_843419_veneer:
3025       size = sizeof (aarch64_erratum_843419_stub);
3026       break;
3027     default:
3028       abort ();
3029     }
3030
3031   size = (size + 7) & ~7;
3032   stub_entry->stub_sec->size += size;
3033   return TRUE;
3034 }
3035
3036 /* External entry points for sizing and building linker stubs.  */
3037
3038 /* Set up various things so that we can make a list of input sections
3039    for each output section included in the link.  Returns -1 on error,
3040    0 when no stubs will be needed, and 1 on success.  */
3041
3042 int
3043 elfNN_aarch64_setup_section_lists (bfd *output_bfd,
3044                                    struct bfd_link_info *info)
3045 {
3046   bfd *input_bfd;
3047   unsigned int bfd_count;
3048   unsigned int top_id, top_index;
3049   asection *section;
3050   asection **input_list, **list;
3051   bfd_size_type amt;
3052   struct elf_aarch64_link_hash_table *htab =
3053     elf_aarch64_hash_table (info);
3054
3055   if (!is_elf_hash_table (htab))
3056     return 0;
3057
3058   /* Count the number of input BFDs and find the top input section id.  */
3059   for (input_bfd = info->input_bfds, bfd_count = 0, top_id = 0;
3060        input_bfd != NULL; input_bfd = input_bfd->link.next)
3061     {
3062       bfd_count += 1;
3063       for (section = input_bfd->sections;
3064            section != NULL; section = section->next)
3065         {
3066           if (top_id < section->id)
3067             top_id = section->id;
3068         }
3069     }
3070   htab->bfd_count = bfd_count;
3071
3072   amt = sizeof (struct map_stub) * (top_id + 1);
3073   htab->stub_group = bfd_zmalloc (amt);
3074   if (htab->stub_group == NULL)
3075     return -1;
3076
3077   /* We can't use output_bfd->section_count here to find the top output
3078      section index as some sections may have been removed, and
3079      _bfd_strip_section_from_output doesn't renumber the indices.  */
3080   for (section = output_bfd->sections, top_index = 0;
3081        section != NULL; section = section->next)
3082     {
3083       if (top_index < section->index)
3084         top_index = section->index;
3085     }
3086
3087   htab->top_index = top_index;
3088   amt = sizeof (asection *) * (top_index + 1);
3089   input_list = bfd_malloc (amt);
3090   htab->input_list = input_list;
3091   if (input_list == NULL)
3092     return -1;
3093
3094   /* For sections we aren't interested in, mark their entries with a
3095      value we can check later.  */
3096   list = input_list + top_index;
3097   do
3098     *list = bfd_abs_section_ptr;
3099   while (list-- != input_list);
3100
3101   for (section = output_bfd->sections;
3102        section != NULL; section = section->next)
3103     {
3104       if ((section->flags & SEC_CODE) != 0)
3105         input_list[section->index] = NULL;
3106     }
3107
3108   return 1;
3109 }
3110
3111 /* Used by elfNN_aarch64_next_input_section and group_sections.  */
3112 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
3113
3114 /* The linker repeatedly calls this function for each input section,
3115    in the order that input sections are linked into output sections.
3116    Build lists of input sections to determine groupings between which
3117    we may insert linker stubs.  */
3118
3119 void
3120 elfNN_aarch64_next_input_section (struct bfd_link_info *info, asection *isec)
3121 {
3122   struct elf_aarch64_link_hash_table *htab =
3123     elf_aarch64_hash_table (info);
3124
3125   if (isec->output_section->index <= htab->top_index)
3126     {
3127       asection **list = htab->input_list + isec->output_section->index;
3128
3129       if (*list != bfd_abs_section_ptr)
3130         {
3131           /* Steal the link_sec pointer for our list.  */
3132           /* This happens to make the list in reverse order,
3133              which is what we want.  */
3134           PREV_SEC (isec) = *list;
3135           *list = isec;
3136         }
3137     }
3138 }
3139
3140 /* See whether we can group stub sections together.  Grouping stub
3141    sections may result in fewer stubs.  More importantly, we need to
3142    put all .init* and .fini* stubs at the beginning of the .init or
3143    .fini output sections respectively, because glibc splits the
3144    _init and _fini functions into multiple parts.  Putting a stub in
3145    the middle of a function is not a good idea.  */
3146
3147 static void
3148 group_sections (struct elf_aarch64_link_hash_table *htab,
3149                 bfd_size_type stub_group_size,
3150                 bfd_boolean stubs_always_before_branch)
3151 {
3152   asection **list = htab->input_list + htab->top_index;
3153
3154   do
3155     {
3156       asection *tail = *list;
3157
3158       if (tail == bfd_abs_section_ptr)
3159         continue;
3160
3161       while (tail != NULL)
3162         {
3163           asection *curr;
3164           asection *prev;
3165           bfd_size_type total;
3166
3167           curr = tail;
3168           total = tail->size;
3169           while ((prev = PREV_SEC (curr)) != NULL
3170                  && ((total += curr->output_offset - prev->output_offset)
3171                      < stub_group_size))
3172             curr = prev;
3173
3174           /* OK, the size from the start of CURR to the end is less
3175              than stub_group_size and thus can be handled by one stub
3176              section.  (Or the tail section is itself larger than
3177              stub_group_size, in which case we may be toast.)
3178              We should really be keeping track of the total size of
3179              stubs added here, as stubs contribute to the final output
3180              section size.  */
3181           do
3182             {
3183               prev = PREV_SEC (tail);
3184               /* Set up this stub group.  */
3185               htab->stub_group[tail->id].link_sec = curr;
3186             }
3187           while (tail != curr && (tail = prev) != NULL);
3188
3189           /* But wait, there's more!  Input sections up to stub_group_size
3190              bytes before the stub section can be handled by it too.  */
3191           if (!stubs_always_before_branch)
3192             {
3193               total = 0;
3194               while (prev != NULL
3195                      && ((total += tail->output_offset - prev->output_offset)
3196                          < stub_group_size))
3197                 {
3198                   tail = prev;
3199                   prev = PREV_SEC (tail);
3200                   htab->stub_group[tail->id].link_sec = curr;
3201                 }
3202             }
3203           tail = prev;
3204         }
3205     }
3206   while (list-- != htab->input_list);
3207
3208   free (htab->input_list);
3209 }
3210
3211 #undef PREV_SEC
3212
3213 #define AARCH64_BITS(x, pos, n) (((x) >> (pos)) & ((1 << (n)) - 1))
3214
3215 #define AARCH64_RT(insn) AARCH64_BITS (insn, 0, 5)
3216 #define AARCH64_RT2(insn) AARCH64_BITS (insn, 10, 5)
3217 #define AARCH64_RA(insn) AARCH64_BITS (insn, 10, 5)
3218 #define AARCH64_RD(insn) AARCH64_BITS (insn, 0, 5)
3219 #define AARCH64_RN(insn) AARCH64_BITS (insn, 5, 5)
3220 #define AARCH64_RM(insn) AARCH64_BITS (insn, 16, 5)
3221
3222 #define AARCH64_MAC(insn) (((insn) & 0xff000000) == 0x9b000000)
3223 #define AARCH64_BIT(insn, n) AARCH64_BITS (insn, n, 1)
3224 #define AARCH64_OP31(insn) AARCH64_BITS (insn, 21, 3)
3225 #define AARCH64_ZR 0x1f
3226
3227 /* All ld/st ops.  See C4-182 of the ARM ARM.  The encoding space for
3228    LD_PCREL, LDST_RO, LDST_UI and LDST_UIMM cover prefetch ops.  */
3229
3230 #define AARCH64_LD(insn) (AARCH64_BIT (insn, 22) == 1)
3231 #define AARCH64_LDST(insn) (((insn) & 0x0a000000) == 0x08000000)
3232 #define AARCH64_LDST_EX(insn) (((insn) & 0x3f000000) == 0x08000000)
3233 #define AARCH64_LDST_PCREL(insn) (((insn) & 0x3b000000) == 0x18000000)
3234 #define AARCH64_LDST_NAP(insn) (((insn) & 0x3b800000) == 0x28000000)
3235 #define AARCH64_LDSTP_PI(insn) (((insn) & 0x3b800000) == 0x28800000)
3236 #define AARCH64_LDSTP_O(insn) (((insn) & 0x3b800000) == 0x29000000)
3237 #define AARCH64_LDSTP_PRE(insn) (((insn) & 0x3b800000) == 0x29800000)
3238 #define AARCH64_LDST_UI(insn) (((insn) & 0x3b200c00) == 0x38000000)
3239 #define AARCH64_LDST_PIIMM(insn) (((insn) & 0x3b200c00) == 0x38000400)
3240 #define AARCH64_LDST_U(insn) (((insn) & 0x3b200c00) == 0x38000800)
3241 #define AARCH64_LDST_PREIMM(insn) (((insn) & 0x3b200c00) == 0x38000c00)
3242 #define AARCH64_LDST_RO(insn) (((insn) & 0x3b200c00) == 0x38200800)
3243 #define AARCH64_LDST_UIMM(insn) (((insn) & 0x3b000000) == 0x39000000)
3244 #define AARCH64_LDST_SIMD_M(insn) (((insn) & 0xbfbf0000) == 0x0c000000)
3245 #define AARCH64_LDST_SIMD_M_PI(insn) (((insn) & 0xbfa00000) == 0x0c800000)
3246 #define AARCH64_LDST_SIMD_S(insn) (((insn) & 0xbf9f0000) == 0x0d000000)
3247 #define AARCH64_LDST_SIMD_S_PI(insn) (((insn) & 0xbf800000) == 0x0d800000)
3248
3249 /* Classify an INSN if it is indeed a load/store.
3250
3251    Return TRUE if INSN is a LD/ST instruction otherwise return FALSE.
3252
3253    For scalar LD/ST instructions PAIR is FALSE, RT is returned and RT2
3254    is set equal to RT.
3255
3256    For LD/ST pair instructions PAIR is TRUE, RT and RT2 are returned.
3257
3258  */
3259
3260 static bfd_boolean
3261 aarch64_mem_op_p (uint32_t insn, unsigned int *rt, unsigned int *rt2,
3262                   bfd_boolean *pair, bfd_boolean *load)
3263 {
3264   uint32_t opcode;
3265   unsigned int r;
3266   uint32_t opc = 0;
3267   uint32_t v = 0;
3268   uint32_t opc_v = 0;
3269
3270   /* Bail out quickly if INSN doesn't fall into the the load-store
3271      encoding space.  */
3272   if (!AARCH64_LDST (insn))
3273     return FALSE;
3274
3275   *pair = FALSE;
3276   *load = FALSE;
3277   if (AARCH64_LDST_EX (insn))
3278     {
3279       *rt = AARCH64_RT (insn);
3280       *rt2 = *rt;
3281       if (AARCH64_BIT (insn, 21) == 1)
3282         {
3283           *pair = TRUE;
3284           *rt2 = AARCH64_RT2 (insn);
3285         }
3286       *load = AARCH64_LD (insn);
3287       return TRUE;
3288     }
3289   else if (AARCH64_LDST_NAP (insn)
3290            || AARCH64_LDSTP_PI (insn)
3291            || AARCH64_LDSTP_O (insn)
3292            || AARCH64_LDSTP_PRE (insn))
3293     {
3294       *pair = TRUE;
3295       *rt = AARCH64_RT (insn);
3296       *rt2 = AARCH64_RT2 (insn);
3297       *load = AARCH64_LD (insn);
3298       return TRUE;
3299     }
3300   else if (AARCH64_LDST_PCREL (insn)
3301            || AARCH64_LDST_UI (insn)
3302            || AARCH64_LDST_PIIMM (insn)
3303            || AARCH64_LDST_U (insn)
3304            || AARCH64_LDST_PREIMM (insn)
3305            || AARCH64_LDST_RO (insn)
3306            || AARCH64_LDST_UIMM (insn))
3307    {
3308       *rt = AARCH64_RT (insn);
3309       *rt2 = *rt;
3310       if (AARCH64_LDST_PCREL (insn))
3311         *load = TRUE;
3312       opc = AARCH64_BITS (insn, 22, 2);
3313       v = AARCH64_BIT (insn, 26);
3314       opc_v = opc | (v << 2);
3315       *load =  (opc_v == 1 || opc_v == 2 || opc_v == 3
3316                 || opc_v == 5 || opc_v == 7);
3317       return TRUE;
3318    }
3319   else if (AARCH64_LDST_SIMD_M (insn)
3320            || AARCH64_LDST_SIMD_M_PI (insn))
3321     {
3322       *rt = AARCH64_RT (insn);
3323       *load = AARCH64_BIT (insn, 22);
3324       opcode = (insn >> 12) & 0xf;
3325       switch (opcode)
3326         {
3327         case 0:
3328         case 2:
3329           *rt2 = *rt + 3;
3330           break;
3331
3332         case 4:
3333         case 6:
3334           *rt2 = *rt + 2;
3335           break;
3336
3337         case 7:
3338           *rt2 = *rt;
3339           break;
3340
3341         case 8:
3342         case 10:
3343           *rt2 = *rt + 1;
3344           break;
3345
3346         default:
3347           return FALSE;
3348         }
3349       return TRUE;
3350     }
3351   else if (AARCH64_LDST_SIMD_S (insn)
3352            || AARCH64_LDST_SIMD_S_PI (insn))
3353     {
3354       *rt = AARCH64_RT (insn);
3355       r = (insn >> 21) & 1;
3356       *load = AARCH64_BIT (insn, 22);
3357       opcode = (insn >> 13) & 0x7;
3358       switch (opcode)
3359         {
3360         case 0:
3361         case 2:
3362         case 4:
3363           *rt2 = *rt + r;
3364           break;
3365
3366         case 1:
3367         case 3:
3368         case 5:
3369           *rt2 = *rt + (r == 0 ? 2 : 3);
3370           break;
3371
3372         case 6:
3373           *rt2 = *rt + r;
3374           break;
3375
3376         case 7:
3377           *rt2 = *rt + (r == 0 ? 2 : 3);
3378           break;
3379
3380         default:
3381           return FALSE;
3382         }
3383       return TRUE;
3384     }
3385
3386   return FALSE;
3387 }
3388
3389 /* Return TRUE if INSN is multiply-accumulate.  */
3390
3391 static bfd_boolean
3392 aarch64_mlxl_p (uint32_t insn)
3393 {
3394   uint32_t op31 = AARCH64_OP31 (insn);
3395
3396   if (AARCH64_MAC (insn)
3397       && (op31 == 0 || op31 == 1 || op31 == 5)
3398       /* Exclude MUL instructions which are encoded as a multiple accumulate
3399          with RA = XZR.  */
3400       && AARCH64_RA (insn) != AARCH64_ZR)
3401     return TRUE;
3402
3403   return FALSE;
3404 }
3405
3406 /* Some early revisions of the Cortex-A53 have an erratum (835769) whereby
3407    it is possible for a 64-bit multiply-accumulate instruction to generate an
3408    incorrect result.  The details are quite complex and hard to
3409    determine statically, since branches in the code may exist in some
3410    circumstances, but all cases end with a memory (load, store, or
3411    prefetch) instruction followed immediately by the multiply-accumulate
3412    operation.  We employ a linker patching technique, by moving the potentially
3413    affected multiply-accumulate instruction into a patch region and replacing
3414    the original instruction with a branch to the patch.  This function checks
3415    if INSN_1 is the memory operation followed by a multiply-accumulate
3416    operation (INSN_2).  Return TRUE if an erratum sequence is found, FALSE
3417    if INSN_1 and INSN_2 are safe.  */
3418
3419 static bfd_boolean
3420 aarch64_erratum_sequence (uint32_t insn_1, uint32_t insn_2)
3421 {
3422   uint32_t rt;
3423   uint32_t rt2;
3424   uint32_t rn;
3425   uint32_t rm;
3426   uint32_t ra;
3427   bfd_boolean pair;
3428   bfd_boolean load;
3429
3430   if (aarch64_mlxl_p (insn_2)
3431       && aarch64_mem_op_p (insn_1, &rt, &rt2, &pair, &load))
3432     {
3433       /* Any SIMD memory op is independent of the subsequent MLA
3434          by definition of the erratum.  */
3435       if (AARCH64_BIT (insn_1, 26))
3436         return TRUE;
3437
3438       /* If not SIMD, check for integer memory ops and MLA relationship.  */
3439       rn = AARCH64_RN (insn_2);
3440       ra = AARCH64_RA (insn_2);
3441       rm = AARCH64_RM (insn_2);
3442
3443       /* If this is a load and there's a true(RAW) dependency, we are safe
3444          and this is not an erratum sequence.  */
3445       if (load &&
3446           (rt == rn || rt == rm || rt == ra
3447            || (pair && (rt2 == rn || rt2 == rm || rt2 == ra))))
3448         return FALSE;
3449
3450       /* We conservatively put out stubs for all other cases (including
3451          writebacks).  */
3452       return TRUE;
3453     }
3454
3455   return FALSE;
3456 }
3457
3458 /* Used to order a list of mapping symbols by address.  */
3459
3460 static int
3461 elf_aarch64_compare_mapping (const void *a, const void *b)
3462 {
3463   const elf_aarch64_section_map *amap = (const elf_aarch64_section_map *) a;
3464   const elf_aarch64_section_map *bmap = (const elf_aarch64_section_map *) b;
3465
3466   if (amap->vma > bmap->vma)
3467     return 1;
3468   else if (amap->vma < bmap->vma)
3469     return -1;
3470   else if (amap->type > bmap->type)
3471     /* Ensure results do not depend on the host qsort for objects with
3472        multiple mapping symbols at the same address by sorting on type
3473        after vma.  */
3474     return 1;
3475   else if (amap->type < bmap->type)
3476     return -1;
3477   else
3478     return 0;
3479 }
3480
3481
3482 static char *
3483 _bfd_aarch64_erratum_835769_stub_name (unsigned num_fixes)
3484 {
3485   char *stub_name = (char *) bfd_malloc
3486     (strlen ("__erratum_835769_veneer_") + 16);
3487   sprintf (stub_name,"__erratum_835769_veneer_%d", num_fixes);
3488   return stub_name;
3489 }
3490
3491 /* Scan for Cortex-A53 erratum 835769 sequence.
3492
3493    Return TRUE else FALSE on abnormal termination.  */
3494
3495 static bfd_boolean
3496 _bfd_aarch64_erratum_835769_scan (bfd *input_bfd,
3497                                   struct bfd_link_info *info,
3498                                   unsigned int *num_fixes_p)
3499 {
3500   asection *section;
3501   struct elf_aarch64_link_hash_table *htab = elf_aarch64_hash_table (info);
3502   unsigned int num_fixes = *num_fixes_p;
3503
3504   if (htab == NULL)
3505     return TRUE;
3506
3507   for (section = input_bfd->sections;
3508        section != NULL;
3509        section = section->next)
3510     {
3511       bfd_byte *contents = NULL;
3512       struct _aarch64_elf_section_data *sec_data;
3513       unsigned int span;
3514
3515       if (elf_section_type (section) != SHT_PROGBITS
3516           || (elf_section_flags (section) & SHF_EXECINSTR) == 0
3517           || (section->flags & SEC_EXCLUDE) != 0
3518           || (section->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
3519           || (section->output_section == bfd_abs_section_ptr))
3520         continue;
3521
3522       if (elf_section_data (section)->this_hdr.contents != NULL)
3523         contents = elf_section_data (section)->this_hdr.contents;
3524       else if (! bfd_malloc_and_get_section (input_bfd, section, &contents))
3525         return FALSE;
3526
3527       sec_data = elf_aarch64_section_data (section);
3528
3529       qsort (sec_data->map, sec_data->mapcount,
3530              sizeof (elf_aarch64_section_map), elf_aarch64_compare_mapping);
3531
3532       for (span = 0; span < sec_data->mapcount; span++)
3533         {
3534           unsigned int span_start = sec_data->map[span].vma;
3535           unsigned int span_end = ((span == sec_data->mapcount - 1)
3536                                    ? sec_data->map[0].vma + section->size
3537                                    : sec_data->map[span + 1].vma);
3538           unsigned int i;
3539           char span_type = sec_data->map[span].type;
3540
3541           if (span_type == 'd')
3542             continue;
3543
3544           for (i = span_start; i + 4 < span_end; i += 4)
3545             {
3546               uint32_t insn_1 = bfd_getl32 (contents + i);
3547               uint32_t insn_2 = bfd_getl32 (contents + i + 4);
3548
3549               if (aarch64_erratum_sequence (insn_1, insn_2))
3550                 {
3551                   struct elf_aarch64_stub_hash_entry *stub_entry;
3552                   char *stub_name = _bfd_aarch64_erratum_835769_stub_name (num_fixes);
3553                   if (! stub_name)
3554                     return FALSE;
3555
3556                   stub_entry = _bfd_aarch64_add_stub_entry_in_group (stub_name,
3557                                                                      section,
3558                                                                      htab);
3559                   if (! stub_entry)
3560                     return FALSE;
3561
3562                   stub_entry->stub_type = aarch64_stub_erratum_835769_veneer;
3563                   stub_entry->target_section = section;
3564                   stub_entry->target_value = i + 4;
3565                   stub_entry->veneered_insn = insn_2;
3566                   stub_entry->output_name = stub_name;
3567                   num_fixes++;
3568                 }
3569             }
3570         }
3571       if (elf_section_data (section)->this_hdr.contents == NULL)
3572         free (contents);
3573     }
3574
3575   *num_fixes_p = num_fixes;
3576
3577   return TRUE;
3578 }
3579
3580
3581 /* Test if instruction INSN is ADRP.  */
3582
3583 static bfd_boolean
3584 _bfd_aarch64_adrp_p (uint32_t insn)
3585 {
3586   return ((insn & 0x9f000000) == 0x90000000);
3587 }
3588
3589
3590 /* Helper predicate to look for cortex-a53 erratum 843419 sequence 1.  */
3591
3592 static bfd_boolean
3593 _bfd_aarch64_erratum_843419_sequence_p (uint32_t insn_1, uint32_t insn_2,
3594                                         uint32_t insn_3)
3595 {
3596   uint32_t rt;
3597   uint32_t rt2;
3598   bfd_boolean pair;
3599   bfd_boolean load;
3600
3601   return (aarch64_mem_op_p (insn_2, &rt, &rt2, &pair, &load)
3602           && (!pair
3603               || (pair && !load))
3604           && AARCH64_LDST_UIMM (insn_3)
3605           && AARCH64_RN (insn_3) == AARCH64_RD (insn_1));
3606 }
3607
3608
3609 /* Test for the presence of Cortex-A53 erratum 843419 instruction sequence.
3610
3611    Return TRUE if section CONTENTS at offset I contains one of the
3612    erratum 843419 sequences, otherwise return FALSE.  If a sequence is
3613    seen set P_VENEER_I to the offset of the final LOAD/STORE
3614    instruction in the sequence.
3615  */
3616
3617 static bfd_boolean
3618 _bfd_aarch64_erratum_843419_p (bfd_byte *contents, bfd_vma vma,
3619                                bfd_vma i, bfd_vma span_end,
3620                                bfd_vma *p_veneer_i)
3621 {
3622   uint32_t insn_1 = bfd_getl32 (contents + i);
3623
3624   if (!_bfd_aarch64_adrp_p (insn_1))
3625     return FALSE;
3626
3627   if (span_end < i + 12)
3628     return FALSE;
3629
3630   uint32_t insn_2 = bfd_getl32 (contents + i + 4);
3631   uint32_t insn_3 = bfd_getl32 (contents + i + 8);
3632
3633   if ((vma & 0xfff) != 0xff8 && (vma & 0xfff) != 0xffc)
3634     return FALSE;
3635
3636   if (_bfd_aarch64_erratum_843419_sequence_p (insn_1, insn_2, insn_3))
3637     {
3638       *p_veneer_i = i + 8;
3639       return TRUE;
3640     }
3641
3642   if (span_end < i + 16)
3643     return FALSE;
3644
3645   uint32_t insn_4 = bfd_getl32 (contents + i + 12);
3646
3647   if (_bfd_aarch64_erratum_843419_sequence_p (insn_1, insn_2, insn_4))
3648     {
3649       *p_veneer_i = i + 12;
3650       return TRUE;
3651     }
3652
3653   return FALSE;
3654 }
3655
3656
3657 /* Resize all stub sections.  */
3658
3659 static void
3660 _bfd_aarch64_resize_stubs (struct elf_aarch64_link_hash_table *htab)
3661 {
3662   asection *section;
3663
3664   /* OK, we've added some stubs.  Find out the new size of the
3665      stub sections.  */
3666   for (section = htab->stub_bfd->sections;
3667        section != NULL; section = section->next)
3668     {
3669       /* Ignore non-stub sections.  */
3670       if (!strstr (section->name, STUB_SUFFIX))
3671         continue;
3672       section->size = 0;
3673     }
3674
3675   bfd_hash_traverse (&htab->stub_hash_table, aarch64_size_one_stub, htab);
3676
3677   for (section = htab->stub_bfd->sections;
3678        section != NULL; section = section->next)
3679     {
3680       if (!strstr (section->name, STUB_SUFFIX))
3681         continue;
3682
3683       if (section->size)
3684         section->size += 4;
3685
3686       /* Ensure all stub sections have a size which is a multiple of
3687          4096.  This is important in order to ensure that the insertion
3688          of stub sections does not in itself move existing code around
3689          in such a way that new errata sequences are created.  */
3690       if (htab->fix_erratum_843419)
3691         if (section->size)
3692           section->size = BFD_ALIGN (section->size, 0x1000);
3693     }
3694 }
3695
3696
3697 /* Construct an erratum 843419 workaround stub name.
3698  */
3699
3700 static char *
3701 _bfd_aarch64_erratum_843419_stub_name (asection *input_section,
3702                                        bfd_vma offset)
3703 {
3704   const bfd_size_type len = 8 + 4 + 1 + 8 + 1 + 16 + 1;
3705   char *stub_name = bfd_malloc (len);
3706
3707   if (stub_name != NULL)
3708     snprintf (stub_name, len, "e843419@%04x_%08x_%" BFD_VMA_FMT "x",
3709               input_section->owner->id,
3710               input_section->id,
3711               offset);
3712   return stub_name;
3713 }
3714
3715 /*  Build a stub_entry structure describing an 843419 fixup.
3716
3717     The stub_entry constructed is populated with the bit pattern INSN
3718     of the instruction located at OFFSET within input SECTION.
3719
3720     Returns TRUE on success.  */
3721
3722 static bfd_boolean
3723 _bfd_aarch64_erratum_843419_fixup (uint32_t insn,
3724                                    bfd_vma adrp_offset,
3725                                    bfd_vma ldst_offset,
3726                                    asection *section,
3727                                    struct bfd_link_info *info)
3728 {
3729   struct elf_aarch64_link_hash_table *htab = elf_aarch64_hash_table (info);
3730   char *stub_name;
3731   struct elf_aarch64_stub_hash_entry *stub_entry;
3732
3733   stub_name = _bfd_aarch64_erratum_843419_stub_name (section, ldst_offset);
3734   stub_entry = aarch64_stub_hash_lookup (&htab->stub_hash_table, stub_name,
3735                                          FALSE, FALSE);
3736   if (stub_entry)
3737     {
3738       free (stub_name);
3739       return TRUE;
3740     }
3741
3742   /* We always place an 843419 workaround veneer in the stub section
3743      attached to the input section in which an erratum sequence has
3744      been found.  This ensures that later in the link process (in
3745      elfNN_aarch64_write_section) when we copy the veneered
3746      instruction from the input section into the stub section the
3747      copied instruction will have had any relocations applied to it.
3748      If we placed workaround veneers in any other stub section then we
3749      could not assume that all relocations have been processed on the
3750      corresponding input section at the point we output the stub
3751      section.
3752    */
3753
3754   stub_entry = _bfd_aarch64_add_stub_entry_after (stub_name, section, htab);
3755   if (stub_entry == NULL)
3756     {
3757       free (stub_name);
3758       return FALSE;
3759     }
3760
3761   stub_entry->adrp_offset = adrp_offset;
3762   stub_entry->target_value = ldst_offset;
3763   stub_entry->target_section = section;
3764   stub_entry->stub_type = aarch64_stub_erratum_843419_veneer;
3765   stub_entry->veneered_insn = insn;
3766   stub_entry->output_name = stub_name;
3767
3768   return TRUE;
3769 }
3770
3771
3772 /* Scan an input section looking for the signature of erratum 843419.
3773
3774    Scans input SECTION in INPUT_BFD looking for erratum 843419
3775    signatures, for each signature found a stub_entry is created
3776    describing the location of the erratum for subsequent fixup.
3777
3778    Return TRUE on successful scan, FALSE on failure to scan.
3779  */
3780
3781 static bfd_boolean
3782 _bfd_aarch64_erratum_843419_scan (bfd *input_bfd, asection *section,
3783                                   struct bfd_link_info *info)
3784 {
3785   struct elf_aarch64_link_hash_table *htab = elf_aarch64_hash_table (info);
3786
3787   if (htab == NULL)
3788     return TRUE;
3789
3790   if (elf_section_type (section) != SHT_PROGBITS
3791       || (elf_section_flags (section) & SHF_EXECINSTR) == 0
3792       || (section->flags & SEC_EXCLUDE) != 0
3793       || (section->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
3794       || (section->output_section == bfd_abs_section_ptr))
3795     return TRUE;
3796
3797   do
3798     {
3799       bfd_byte *contents = NULL;
3800       struct _aarch64_elf_section_data *sec_data;
3801       unsigned int span;
3802
3803       if (elf_section_data (section)->this_hdr.contents != NULL)
3804         contents = elf_section_data (section)->this_hdr.contents;
3805       else if (! bfd_malloc_and_get_section (input_bfd, section, &contents))
3806         return FALSE;
3807
3808       sec_data = elf_aarch64_section_data (section);
3809
3810       qsort (sec_data->map, sec_data->mapcount,
3811              sizeof (elf_aarch64_section_map), elf_aarch64_compare_mapping);
3812
3813       for (span = 0; span < sec_data->mapcount; span++)
3814         {
3815           unsigned int span_start = sec_data->map[span].vma;
3816           unsigned int span_end = ((span == sec_data->mapcount - 1)
3817                                    ? sec_data->map[0].vma + section->size
3818                                    : sec_data->map[span + 1].vma);
3819           unsigned int i;
3820           char span_type = sec_data->map[span].type;
3821
3822           if (span_type == 'd')
3823             continue;
3824
3825           for (i = span_start; i + 8 < span_end; i += 4)
3826             {
3827               bfd_vma vma = (section->output_section->vma
3828                              + section->output_offset
3829                              + i);
3830               bfd_vma veneer_i;
3831
3832               if (_bfd_aarch64_erratum_843419_p
3833                   (contents, vma, i, span_end, &veneer_i))
3834                 {
3835                   uint32_t insn = bfd_getl32 (contents + veneer_i);
3836
3837                   if (!_bfd_aarch64_erratum_843419_fixup (insn, i, veneer_i,
3838                                                           section, info))
3839                     return FALSE;
3840                 }
3841             }
3842         }
3843
3844       if (elf_section_data (section)->this_hdr.contents == NULL)
3845         free (contents);
3846     }
3847   while (0);
3848
3849   return TRUE;
3850 }
3851
3852
3853 /* Determine and set the size of the stub section for a final link.
3854
3855    The basic idea here is to examine all the relocations looking for
3856    PC-relative calls to a target that is unreachable with a "bl"
3857    instruction.  */
3858
3859 bfd_boolean
3860 elfNN_aarch64_size_stubs (bfd *output_bfd,
3861                           bfd *stub_bfd,
3862                           struct bfd_link_info *info,
3863                           bfd_signed_vma group_size,
3864                           asection * (*add_stub_section) (const char *,
3865                                                           asection *),
3866                           void (*layout_sections_again) (void))
3867 {
3868   bfd_size_type stub_group_size;
3869   bfd_boolean stubs_always_before_branch;
3870   bfd_boolean stub_changed = FALSE;
3871   struct elf_aarch64_link_hash_table *htab = elf_aarch64_hash_table (info);
3872   unsigned int num_erratum_835769_fixes = 0;
3873
3874   /* Propagate mach to stub bfd, because it may not have been
3875      finalized when we created stub_bfd.  */
3876   bfd_set_arch_mach (stub_bfd, bfd_get_arch (output_bfd),
3877                      bfd_get_mach (output_bfd));
3878
3879   /* Stash our params away.  */
3880   htab->stub_bfd = stub_bfd;
3881   htab->add_stub_section = add_stub_section;
3882   htab->layout_sections_again = layout_sections_again;
3883   stubs_always_before_branch = group_size < 0;
3884   if (group_size < 0)
3885     stub_group_size = -group_size;
3886   else
3887     stub_group_size = group_size;
3888
3889   if (stub_group_size == 1)
3890     {
3891       /* Default values.  */
3892       /* AArch64 branch range is +-128MB. The value used is 1MB less.  */
3893       stub_group_size = 127 * 1024 * 1024;
3894     }
3895
3896   group_sections (htab, stub_group_size, stubs_always_before_branch);
3897
3898   (*htab->layout_sections_again) ();
3899
3900   if (htab->fix_erratum_835769)
3901     {
3902       bfd *input_bfd;
3903
3904       for (input_bfd = info->input_bfds;
3905            input_bfd != NULL; input_bfd = input_bfd->link.next)
3906         if (!_bfd_aarch64_erratum_835769_scan (input_bfd, info,
3907                                                &num_erratum_835769_fixes))
3908           return FALSE;
3909
3910       _bfd_aarch64_resize_stubs (htab);
3911       (*htab->layout_sections_again) ();
3912     }
3913
3914   if (htab->fix_erratum_843419)
3915     {
3916       bfd *input_bfd;
3917
3918       for (input_bfd = info->input_bfds;
3919            input_bfd != NULL;
3920            input_bfd = input_bfd->link.next)
3921         {
3922           asection *section;
3923
3924           for (section = input_bfd->sections;
3925                section != NULL;
3926                section = section->next)
3927             if (!_bfd_aarch64_erratum_843419_scan (input_bfd, section, info))
3928               return FALSE;
3929         }
3930
3931       _bfd_aarch64_resize_stubs (htab);
3932       (*htab->layout_sections_again) ();
3933     }
3934
3935   while (1)
3936     {
3937       bfd *input_bfd;
3938
3939       for (input_bfd = info->input_bfds;
3940            input_bfd != NULL; input_bfd = input_bfd->link.next)
3941         {
3942           Elf_Internal_Shdr *symtab_hdr;
3943           asection *section;
3944           Elf_Internal_Sym *local_syms = NULL;
3945
3946           /* We'll need the symbol table in a second.  */
3947           symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3948           if (symtab_hdr->sh_info == 0)
3949             continue;
3950
3951           /* Walk over each section attached to the input bfd.  */
3952           for (section = input_bfd->sections;
3953                section != NULL; section = section->next)
3954             {
3955               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
3956
3957               /* If there aren't any relocs, then there's nothing more
3958                  to do.  */
3959               if ((section->flags & SEC_RELOC) == 0
3960                   || section->reloc_count == 0
3961                   || (section->flags & SEC_CODE) == 0)
3962                 continue;
3963
3964               /* If this section is a link-once section that will be
3965                  discarded, then don't create any stubs.  */
3966               if (section->output_section == NULL
3967                   || section->output_section->owner != output_bfd)
3968                 continue;
3969
3970               /* Get the relocs.  */
3971               internal_relocs
3972                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL,
3973                                              NULL, info->keep_memory);
3974               if (internal_relocs == NULL)
3975                 goto error_ret_free_local;
3976
3977               /* Now examine each relocation.  */
3978               irela = internal_relocs;
3979               irelaend = irela + section->reloc_count;
3980               for (; irela < irelaend; irela++)
3981                 {
3982                   unsigned int r_type, r_indx;
3983                   enum elf_aarch64_stub_type stub_type;
3984                   struct elf_aarch64_stub_hash_entry *stub_entry;
3985                   asection *sym_sec;
3986                   bfd_vma sym_value;
3987                   bfd_vma destination;
3988                   struct elf_aarch64_link_hash_entry *hash;
3989                   const char *sym_name;
3990                   char *stub_name;
3991                   const asection *id_sec;
3992                   unsigned char st_type;
3993                   bfd_size_type len;
3994
3995                   r_type = ELFNN_R_TYPE (irela->r_info);
3996                   r_indx = ELFNN_R_SYM (irela->r_info);
3997
3998                   if (r_type >= (unsigned int) R_AARCH64_end)
3999                     {
4000                       bfd_set_error (bfd_error_bad_value);
4001                     error_ret_free_internal:
4002                       if (elf_section_data (section)->relocs == NULL)
4003                         free (internal_relocs);
4004                       goto error_ret_free_local;
4005                     }
4006
4007                   /* Only look for stubs on unconditional branch and
4008                      branch and link instructions.  */
4009                   if (r_type != (unsigned int) AARCH64_R (CALL26)
4010                       && r_type != (unsigned int) AARCH64_R (JUMP26))
4011                     continue;
4012
4013                   /* Now determine the call target, its name, value,
4014                      section.  */
4015                   sym_sec = NULL;
4016                   sym_value = 0;
4017                   destination = 0;
4018                   hash = NULL;
4019                   sym_name = NULL;
4020                   if (r_indx < symtab_hdr->sh_info)
4021                     {
4022                       /* It's a local symbol.  */
4023                       Elf_Internal_Sym *sym;
4024                       Elf_Internal_Shdr *hdr;
4025
4026                       if (local_syms == NULL)
4027                         {
4028                           local_syms
4029                             = (Elf_Internal_Sym *) symtab_hdr->contents;
4030                           if (local_syms == NULL)
4031                             local_syms
4032                               = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
4033                                                       symtab_hdr->sh_info, 0,
4034                                                       NULL, NULL, NULL);
4035                           if (local_syms == NULL)
4036                             goto error_ret_free_internal;
4037                         }
4038
4039                       sym = local_syms + r_indx;
4040                       hdr = elf_elfsections (input_bfd)[sym->st_shndx];
4041                       sym_sec = hdr->bfd_section;
4042                       if (!sym_sec)
4043                         /* This is an undefined symbol.  It can never
4044                            be resolved.  */
4045                         continue;
4046
4047                       if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
4048                         sym_value = sym->st_value;
4049                       destination = (sym_value + irela->r_addend
4050                                      + sym_sec->output_offset
4051                                      + sym_sec->output_section->vma);
4052                       st_type = ELF_ST_TYPE (sym->st_info);
4053                       sym_name
4054                         = bfd_elf_string_from_elf_section (input_bfd,
4055                                                            symtab_hdr->sh_link,
4056                                                            sym->st_name);
4057                     }
4058                   else
4059                     {
4060                       int e_indx;
4061
4062                       e_indx = r_indx - symtab_hdr->sh_info;
4063                       hash = ((struct elf_aarch64_link_hash_entry *)
4064                               elf_sym_hashes (input_bfd)[e_indx]);
4065
4066                       while (hash->root.root.type == bfd_link_hash_indirect
4067                              || hash->root.root.type == bfd_link_hash_warning)
4068                         hash = ((struct elf_aarch64_link_hash_entry *)
4069                                 hash->root.root.u.i.link);
4070
4071                       if (hash->root.root.type == bfd_link_hash_defined
4072                           || hash->root.root.type == bfd_link_hash_defweak)
4073                         {
4074                           struct elf_aarch64_link_hash_table *globals =
4075                             elf_aarch64_hash_table (info);
4076                           sym_sec = hash->root.root.u.def.section;
4077                           sym_value = hash->root.root.u.def.value;
4078                           /* For a destination in a shared library,
4079                              use the PLT stub as target address to
4080                              decide whether a branch stub is
4081                              needed.  */
4082                           if (globals->root.splt != NULL && hash != NULL
4083                               && hash->root.plt.offset != (bfd_vma) - 1)
4084                             {
4085                               sym_sec = globals->root.splt;
4086                               sym_value = hash->root.plt.offset;
4087                               if (sym_sec->output_section != NULL)
4088                                 destination = (sym_value
4089                                                + sym_sec->output_offset
4090                                                +
4091                                                sym_sec->output_section->vma);
4092                             }
4093                           else if (sym_sec->output_section != NULL)
4094                             destination = (sym_value + irela->r_addend
4095                                            + sym_sec->output_offset
4096                                            + sym_sec->output_section->vma);
4097                         }
4098                       else if (hash->root.root.type == bfd_link_hash_undefined
4099                                || (hash->root.root.type
4100                                    == bfd_link_hash_undefweak))
4101                         {
4102                           /* For a shared library, use the PLT stub as
4103                              target address to decide whether a long
4104                              branch stub is needed.
4105                              For absolute code, they cannot be handled.  */
4106                           struct elf_aarch64_link_hash_table *globals =
4107                             elf_aarch64_hash_table (info);
4108
4109                           if (globals->root.splt != NULL && hash != NULL
4110                               && hash->root.plt.offset != (bfd_vma) - 1)
4111                             {
4112                               sym_sec = globals->root.splt;
4113                               sym_value = hash->root.plt.offset;
4114                               if (sym_sec->output_section != NULL)
4115                                 destination = (sym_value
4116                                                + sym_sec->output_offset
4117                                                +
4118                                                sym_sec->output_section->vma);
4119                             }
4120                           else
4121                             continue;
4122                         }
4123                       else
4124                         {
4125                           bfd_set_error (bfd_error_bad_value);
4126                           goto error_ret_free_internal;
4127                         }
4128                       st_type = ELF_ST_TYPE (hash->root.type);
4129                       sym_name = hash->root.root.root.string;
4130                     }
4131
4132                   /* Determine what (if any) linker stub is needed.  */
4133                   stub_type = aarch64_type_of_stub (section, irela, sym_sec,
4134                                                     st_type, destination);
4135                   if (stub_type == aarch64_stub_none)
4136                     continue;
4137
4138                   /* Support for grouping stub sections.  */
4139                   id_sec = htab->stub_group[section->id].link_sec;
4140
4141                   /* Get the name of this stub.  */
4142                   stub_name = elfNN_aarch64_stub_name (id_sec, sym_sec, hash,
4143                                                        irela);
4144                   if (!stub_name)
4145                     goto error_ret_free_internal;
4146
4147                   stub_entry =
4148                     aarch64_stub_hash_lookup (&htab->stub_hash_table,
4149                                               stub_name, FALSE, FALSE);
4150                   if (stub_entry != NULL)
4151                     {
4152                       /* The proper stub has already been created.  */
4153                       free (stub_name);
4154                       continue;
4155                     }
4156
4157                   stub_entry = _bfd_aarch64_add_stub_entry_in_group
4158                     (stub_name, section, htab);
4159                   if (stub_entry == NULL)
4160                     {
4161                       free (stub_name);
4162                       goto error_ret_free_internal;
4163                     }
4164
4165                   stub_entry->target_value = sym_value + irela->r_addend;
4166                   stub_entry->target_section = sym_sec;
4167                   stub_entry->stub_type = stub_type;
4168                   stub_entry->h = hash;
4169                   stub_entry->st_type = st_type;
4170
4171                   if (sym_name == NULL)
4172                     sym_name = "unnamed";
4173                   len = sizeof (STUB_ENTRY_NAME) + strlen (sym_name);
4174                   stub_entry->output_name = bfd_alloc (htab->stub_bfd, len);
4175                   if (stub_entry->output_name == NULL)
4176                     {
4177                       free (stub_name);
4178                       goto error_ret_free_internal;
4179                     }
4180
4181                   snprintf (stub_entry->output_name, len, STUB_ENTRY_NAME,
4182                             sym_name);
4183
4184                   stub_changed = TRUE;
4185                 }
4186
4187               /* We're done with the internal relocs, free them.  */
4188               if (elf_section_data (section)->relocs == NULL)
4189                 free (internal_relocs);
4190             }
4191         }
4192
4193       if (!stub_changed)
4194         break;
4195
4196       _bfd_aarch64_resize_stubs (htab);
4197
4198       /* Ask the linker to do its stuff.  */
4199       (*htab->layout_sections_again) ();
4200       stub_changed = FALSE;
4201     }
4202
4203   return TRUE;
4204
4205 error_ret_free_local:
4206   return FALSE;
4207 }
4208
4209 /* Build all the stubs associated with the current output file.  The
4210    stubs are kept in a hash table attached to the main linker hash
4211    table.  We also set up the .plt entries for statically linked PIC
4212    functions here.  This function is called via aarch64_elf_finish in the
4213    linker.  */
4214
4215 bfd_boolean
4216 elfNN_aarch64_build_stubs (struct bfd_link_info *info)
4217 {
4218   asection *stub_sec;
4219   struct bfd_hash_table *table;
4220   struct elf_aarch64_link_hash_table *htab;
4221
4222   htab = elf_aarch64_hash_table (info);
4223
4224   for (stub_sec = htab->stub_bfd->sections;
4225        stub_sec != NULL; stub_sec = stub_sec->next)
4226     {
4227       bfd_size_type size;
4228
4229       /* Ignore non-stub sections.  */
4230       if (!strstr (stub_sec->name, STUB_SUFFIX))
4231         continue;
4232
4233       /* Allocate memory to hold the linker stubs.  */
4234       size = stub_sec->size;
4235       stub_sec->contents = bfd_zalloc (htab->stub_bfd, size);
4236       if (stub_sec->contents == NULL && size != 0)
4237         return FALSE;
4238       stub_sec->size = 0;
4239
4240       bfd_putl32 (0x14000000 | (size >> 2), stub_sec->contents);
4241       stub_sec->size += 4;
4242     }
4243
4244   /* Build the stubs as directed by the stub hash table.  */
4245   table = &htab->stub_hash_table;
4246   bfd_hash_traverse (table, aarch64_build_one_stub, info);
4247
4248   return TRUE;
4249 }
4250
4251
4252 /* Add an entry to the code/data map for section SEC.  */
4253
4254 static void
4255 elfNN_aarch64_section_map_add (asection *sec, char type, bfd_vma vma)
4256 {
4257   struct _aarch64_elf_section_data *sec_data =
4258     elf_aarch64_section_data (sec);
4259   unsigned int newidx;
4260
4261   if (sec_data->map == NULL)
4262     {
4263       sec_data->map = bfd_malloc (sizeof (elf_aarch64_section_map));
4264       sec_data->mapcount = 0;
4265       sec_data->mapsize = 1;
4266     }
4267
4268   newidx = sec_data->mapcount++;
4269
4270   if (sec_data->mapcount > sec_data->mapsize)
4271     {
4272       sec_data->mapsize *= 2;
4273       sec_data->map = bfd_realloc_or_free
4274         (sec_data->map, sec_data->mapsize * sizeof (elf_aarch64_section_map));
4275     }
4276
4277   if (sec_data->map)
4278     {
4279       sec_data->map[newidx].vma = vma;
4280       sec_data->map[newidx].type = type;
4281     }
4282 }
4283
4284
4285 /* Initialise maps of insn/data for input BFDs.  */
4286 void
4287 bfd_elfNN_aarch64_init_maps (bfd *abfd)
4288 {
4289   Elf_Internal_Sym *isymbuf;
4290   Elf_Internal_Shdr *hdr;
4291   unsigned int i, localsyms;
4292
4293   /* Make sure that we are dealing with an AArch64 elf binary.  */
4294   if (!is_aarch64_elf (abfd))
4295     return;
4296
4297   if ((abfd->flags & DYNAMIC) != 0)
4298    return;
4299
4300   hdr = &elf_symtab_hdr (abfd);
4301   localsyms = hdr->sh_info;
4302
4303   /* Obtain a buffer full of symbols for this BFD. The hdr->sh_info field
4304      should contain the number of local symbols, which should come before any
4305      global symbols.  Mapping symbols are always local.  */
4306   isymbuf = bfd_elf_get_elf_syms (abfd, hdr, localsyms, 0, NULL, NULL, NULL);
4307
4308   /* No internal symbols read?  Skip this BFD.  */
4309   if (isymbuf == NULL)
4310     return;
4311
4312   for (i = 0; i < localsyms; i++)
4313     {
4314       Elf_Internal_Sym *isym = &isymbuf[i];
4315       asection *sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
4316       const char *name;
4317
4318       if (sec != NULL && ELF_ST_BIND (isym->st_info) == STB_LOCAL)
4319         {
4320           name = bfd_elf_string_from_elf_section (abfd,
4321                                                   hdr->sh_link,
4322                                                   isym->st_name);
4323
4324           if (bfd_is_aarch64_special_symbol_name
4325               (name, BFD_AARCH64_SPECIAL_SYM_TYPE_MAP))
4326             elfNN_aarch64_section_map_add (sec, name[1], isym->st_value);
4327         }
4328     }
4329 }
4330
4331 /* Set option values needed during linking.  */
4332 void
4333 bfd_elfNN_aarch64_set_options (struct bfd *output_bfd,
4334                                struct bfd_link_info *link_info,
4335                                int no_enum_warn,
4336                                int no_wchar_warn, int pic_veneer,
4337                                int fix_erratum_835769,
4338                                int fix_erratum_843419,
4339                                int no_apply_dynamic_relocs)
4340 {
4341   struct elf_aarch64_link_hash_table *globals;
4342
4343   globals = elf_aarch64_hash_table (link_info);
4344   globals->pic_veneer = pic_veneer;
4345   globals->fix_erratum_835769 = fix_erratum_835769;
4346   globals->fix_erratum_843419 = fix_erratum_843419;
4347   globals->fix_erratum_843419_adr = TRUE;
4348   globals->no_apply_dynamic_relocs = no_apply_dynamic_relocs;
4349
4350   BFD_ASSERT (is_aarch64_elf (output_bfd));
4351   elf_aarch64_tdata (output_bfd)->no_enum_size_warning = no_enum_warn;
4352   elf_aarch64_tdata (output_bfd)->no_wchar_size_warning = no_wchar_warn;
4353 }
4354
4355 static bfd_vma
4356 aarch64_calculate_got_entry_vma (struct elf_link_hash_entry *h,
4357                                  struct elf_aarch64_link_hash_table
4358                                  *globals, struct bfd_link_info *info,
4359                                  bfd_vma value, bfd *output_bfd,
4360                                  bfd_boolean *unresolved_reloc_p)
4361 {
4362   bfd_vma off = (bfd_vma) - 1;
4363   asection *basegot = globals->root.sgot;
4364   bfd_boolean dyn = globals->root.dynamic_sections_created;
4365
4366   if (h != NULL)
4367     {
4368       BFD_ASSERT (basegot != NULL);
4369       off = h->got.offset;
4370       BFD_ASSERT (off != (bfd_vma) - 1);
4371       if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h)
4372           || (bfd_link_pic (info)
4373               && SYMBOL_REFERENCES_LOCAL (info, h))
4374           || (ELF_ST_VISIBILITY (h->other)
4375               && h->root.type == bfd_link_hash_undefweak))
4376         {
4377           /* This is actually a static link, or it is a -Bsymbolic link
4378              and the symbol is defined locally.  We must initialize this
4379              entry in the global offset table.  Since the offset must
4380              always be a multiple of 8 (4 in the case of ILP32), we use
4381              the least significant bit to record whether we have
4382              initialized it already.
4383              When doing a dynamic link, we create a .rel(a).got relocation
4384              entry to initialize the value.  This is done in the
4385              finish_dynamic_symbol routine.  */
4386           if ((off & 1) != 0)
4387             off &= ~1;
4388           else
4389             {
4390               bfd_put_NN (output_bfd, value, basegot->contents + off);
4391               h->got.offset |= 1;
4392             }
4393         }
4394       else
4395         *unresolved_reloc_p = FALSE;
4396
4397       off = off + basegot->output_section->vma + basegot->output_offset;
4398     }
4399
4400   return off;
4401 }
4402
4403 /* Change R_TYPE to a more efficient access model where possible,
4404    return the new reloc type.  */
4405
4406 static bfd_reloc_code_real_type
4407 aarch64_tls_transition_without_check (bfd_reloc_code_real_type r_type,
4408                                       struct elf_link_hash_entry *h)
4409 {
4410   bfd_boolean is_local = h == NULL;
4411
4412   switch (r_type)
4413     {
4414     case BFD_RELOC_AARCH64_TLSDESC_ADR_PAGE21:
4415     case BFD_RELOC_AARCH64_TLSGD_ADR_PAGE21:
4416       return (is_local
4417               ? BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G1
4418               : BFD_RELOC_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21);
4419
4420     case BFD_RELOC_AARCH64_TLSDESC_ADR_PREL21:
4421       return (is_local
4422               ? BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G0_NC
4423               : r_type);
4424
4425     case BFD_RELOC_AARCH64_TLSDESC_LD_PREL19:
4426       return (is_local
4427               ? BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G1
4428               : BFD_RELOC_AARCH64_TLSIE_LD_GOTTPREL_PREL19);
4429
4430     case BFD_RELOC_AARCH64_TLSDESC_LDR:
4431       return (is_local
4432               ? BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G0_NC
4433               : BFD_RELOC_AARCH64_NONE);
4434
4435     case BFD_RELOC_AARCH64_TLSDESC_OFF_G0_NC:
4436       return (is_local
4437               ? BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G1_NC
4438               : BFD_RELOC_AARCH64_TLSIE_MOVW_GOTTPREL_G0_NC);
4439
4440     case BFD_RELOC_AARCH64_TLSDESC_OFF_G1:
4441       return (is_local
4442               ? BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G2
4443               : BFD_RELOC_AARCH64_TLSIE_MOVW_GOTTPREL_G1);
4444
4445     case BFD_RELOC_AARCH64_TLSDESC_LDNN_LO12_NC:
4446     case BFD_RELOC_AARCH64_TLSGD_ADD_LO12_NC:
4447       return (is_local
4448               ? BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G0_NC
4449               : BFD_RELOC_AARCH64_TLSIE_LDNN_GOTTPREL_LO12_NC);
4450
4451     case BFD_RELOC_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21:
4452       return is_local ? BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G1 : r_type;
4453
4454     case BFD_RELOC_AARCH64_TLSIE_LDNN_GOTTPREL_LO12_NC:
4455       return is_local ? BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G0_NC : r_type;
4456
4457     case BFD_RELOC_AARCH64_TLSIE_LD_GOTTPREL_PREL19:
4458       return r_type;
4459
4460     case BFD_RELOC_AARCH64_TLSGD_ADR_PREL21:
4461       return (is_local
4462               ? BFD_RELOC_AARCH64_TLSLE_ADD_TPREL_HI12
4463               : BFD_RELOC_AARCH64_TLSIE_LD_GOTTPREL_PREL19);
4464
4465     case BFD_RELOC_AARCH64_TLSDESC_ADD:
4466     case BFD_RELOC_AARCH64_TLSDESC_ADD_LO12_NC:
4467     case BFD_RELOC_AARCH64_TLSDESC_CALL:
4468       /* Instructions with these relocations will become NOPs.  */
4469       return BFD_RELOC_AARCH64_NONE;
4470
4471     case BFD_RELOC_AARCH64_TLSLD_ADD_LO12_NC:
4472     case BFD_RELOC_AARCH64_TLSLD_ADR_PAGE21:
4473     case BFD_RELOC_AARCH64_TLSLD_ADR_PREL21:
4474       return is_local ? BFD_RELOC_AARCH64_NONE : r_type;
4475
4476 #if ARCH_SIZE == 64
4477     case BFD_RELOC_AARCH64_TLSGD_MOVW_G0_NC:
4478       return is_local
4479         ? BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G1_NC
4480         : BFD_RELOC_AARCH64_TLSIE_MOVW_GOTTPREL_G0_NC;
4481
4482     case BFD_RELOC_AARCH64_TLSGD_MOVW_G1:
4483       return is_local
4484         ? BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G2
4485         : BFD_RELOC_AARCH64_TLSIE_MOVW_GOTTPREL_G1;
4486 #endif
4487
4488     default:
4489       break;
4490     }
4491
4492   return r_type;
4493 }
4494
4495 static unsigned int
4496 aarch64_reloc_got_type (bfd_reloc_code_real_type r_type)
4497 {
4498   switch (r_type)
4499     {
4500     case BFD_RELOC_AARCH64_ADR_GOT_PAGE:
4501     case BFD_RELOC_AARCH64_GOT_LD_PREL19:
4502     case BFD_RELOC_AARCH64_LD32_GOTPAGE_LO14:
4503     case BFD_RELOC_AARCH64_LD32_GOT_LO12_NC:
4504     case BFD_RELOC_AARCH64_LD64_GOTOFF_LO15:
4505     case BFD_RELOC_AARCH64_LD64_GOTPAGE_LO15:
4506     case BFD_RELOC_AARCH64_LD64_GOT_LO12_NC:
4507     case BFD_RELOC_AARCH64_MOVW_GOTOFF_G0_NC:
4508     case BFD_RELOC_AARCH64_MOVW_GOTOFF_G1:
4509       return GOT_NORMAL;
4510
4511     case BFD_RELOC_AARCH64_TLSGD_ADD_LO12_NC:
4512     case BFD_RELOC_AARCH64_TLSGD_ADR_PAGE21:
4513     case BFD_RELOC_AARCH64_TLSGD_ADR_PREL21:
4514     case BFD_RELOC_AARCH64_TLSGD_MOVW_G0_NC:
4515     case BFD_RELOC_AARCH64_TLSGD_MOVW_G1:
4516     case BFD_RELOC_AARCH64_TLSLD_ADD_LO12_NC:
4517     case BFD_RELOC_AARCH64_TLSLD_ADR_PAGE21:
4518     case BFD_RELOC_AARCH64_TLSLD_ADR_PREL21:
4519       return GOT_TLS_GD;
4520
4521     case BFD_RELOC_AARCH64_TLSDESC_ADD:
4522     case BFD_RELOC_AARCH64_TLSDESC_ADD_LO12_NC:
4523     case BFD_RELOC_AARCH64_TLSDESC_ADR_PAGE21:
4524     case BFD_RELOC_AARCH64_TLSDESC_ADR_PREL21:
4525     case BFD_RELOC_AARCH64_TLSDESC_CALL:
4526     case BFD_RELOC_AARCH64_TLSDESC_LD32_LO12_NC:
4527     case BFD_RELOC_AARCH64_TLSDESC_LD64_LO12_NC:
4528     case BFD_RELOC_AARCH64_TLSDESC_LD_PREL19:
4529     case BFD_RELOC_AARCH64_TLSDESC_LDR:
4530     case BFD_RELOC_AARCH64_TLSDESC_OFF_G0_NC:
4531     case BFD_RELOC_AARCH64_TLSDESC_OFF_G1:
4532       return GOT_TLSDESC_GD;
4533
4534     case BFD_RELOC_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21:
4535     case BFD_RELOC_AARCH64_TLSIE_LD32_GOTTPREL_LO12_NC:
4536     case BFD_RELOC_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC:
4537     case BFD_RELOC_AARCH64_TLSIE_LD_GOTTPREL_PREL19:
4538     case BFD_RELOC_AARCH64_TLSIE_MOVW_GOTTPREL_G0_NC:
4539     case BFD_RELOC_AARCH64_TLSIE_MOVW_GOTTPREL_G1:
4540       return GOT_TLS_IE;
4541
4542     default:
4543       break;
4544     }
4545   return GOT_UNKNOWN;
4546 }
4547
4548 static bfd_boolean
4549 aarch64_can_relax_tls (bfd *input_bfd,
4550                        struct bfd_link_info *info,
4551                        bfd_reloc_code_real_type r_type,
4552                        struct elf_link_hash_entry *h,
4553                        unsigned long r_symndx)
4554 {
4555   unsigned int symbol_got_type;
4556   unsigned int reloc_got_type;
4557
4558   if (! IS_AARCH64_TLS_RELAX_RELOC (r_type))
4559     return FALSE;
4560
4561   symbol_got_type = elfNN_aarch64_symbol_got_type (h, input_bfd, r_symndx);
4562   reloc_got_type = aarch64_reloc_got_type (r_type);
4563
4564   if (symbol_got_type == GOT_TLS_IE && GOT_TLS_GD_ANY_P (reloc_got_type))
4565     return TRUE;
4566
4567   if (bfd_link_pic (info))
4568     return FALSE;
4569
4570   if  (h && h->root.type == bfd_link_hash_undefweak)
4571     return FALSE;
4572
4573   return TRUE;
4574 }
4575
4576 /* Given the relocation code R_TYPE, return the relaxed bfd reloc
4577    enumerator.  */
4578
4579 static bfd_reloc_code_real_type
4580 aarch64_tls_transition (bfd *input_bfd,
4581                         struct bfd_link_info *info,
4582                         unsigned int r_type,
4583                         struct elf_link_hash_entry *h,
4584                         unsigned long r_symndx)
4585 {
4586   bfd_reloc_code_real_type bfd_r_type
4587     = elfNN_aarch64_bfd_reloc_from_type (r_type);
4588
4589   if (! aarch64_can_relax_tls (input_bfd, info, bfd_r_type, h, r_symndx))
4590     return bfd_r_type;
4591
4592   return aarch64_tls_transition_without_check (bfd_r_type, h);
4593 }
4594
4595 /* Return the base VMA address which should be subtracted from real addresses
4596    when resolving R_AARCH64_TLS_DTPREL relocation.  */
4597
4598 static bfd_vma
4599 dtpoff_base (struct bfd_link_info *info)
4600 {
4601   /* If tls_sec is NULL, we should have signalled an error already.  */
4602   BFD_ASSERT (elf_hash_table (info)->tls_sec != NULL);
4603   return elf_hash_table (info)->tls_sec->vma;
4604 }
4605
4606 /* Return the base VMA address which should be subtracted from real addresses
4607    when resolving R_AARCH64_TLS_GOTTPREL64 relocations.  */
4608
4609 static bfd_vma
4610 tpoff_base (struct bfd_link_info *info)
4611 {
4612   struct elf_link_hash_table *htab = elf_hash_table (info);
4613
4614   /* If tls_sec is NULL, we should have signalled an error already.  */
4615   BFD_ASSERT (htab->tls_sec != NULL);
4616
4617   bfd_vma base = align_power ((bfd_vma) TCB_SIZE,
4618                               htab->tls_sec->alignment_power);
4619   return htab->tls_sec->vma - base;
4620 }
4621
4622 static bfd_vma *
4623 symbol_got_offset_ref (bfd *input_bfd, struct elf_link_hash_entry *h,
4624                        unsigned long r_symndx)
4625 {
4626   /* Calculate the address of the GOT entry for symbol
4627      referred to in h.  */
4628   if (h != NULL)
4629     return &h->got.offset;
4630   else
4631     {
4632       /* local symbol */
4633       struct elf_aarch64_local_symbol *l;
4634
4635       l = elf_aarch64_locals (input_bfd);
4636       return &l[r_symndx].got_offset;
4637     }
4638 }
4639
4640 static void
4641 symbol_got_offset_mark (bfd *input_bfd, struct elf_link_hash_entry *h,
4642                         unsigned long r_symndx)
4643 {
4644   bfd_vma *p;
4645   p = symbol_got_offset_ref (input_bfd, h, r_symndx);
4646   *p |= 1;
4647 }
4648
4649 static int
4650 symbol_got_offset_mark_p (bfd *input_bfd, struct elf_link_hash_entry *h,
4651                           unsigned long r_symndx)
4652 {
4653   bfd_vma value;
4654   value = * symbol_got_offset_ref (input_bfd, h, r_symndx);
4655   return value & 1;
4656 }
4657
4658 static bfd_vma
4659 symbol_got_offset (bfd *input_bfd, struct elf_link_hash_entry *h,
4660                    unsigned long r_symndx)
4661 {
4662   bfd_vma value;
4663   value = * symbol_got_offset_ref (input_bfd, h, r_symndx);
4664   value &= ~1;
4665   return value;
4666 }
4667
4668 static bfd_vma *
4669 symbol_tlsdesc_got_offset_ref (bfd *input_bfd, struct elf_link_hash_entry *h,
4670                                unsigned long r_symndx)
4671 {
4672   /* Calculate the address of the GOT entry for symbol
4673      referred to in h.  */
4674   if (h != NULL)
4675     {
4676       struct elf_aarch64_link_hash_entry *eh;
4677       eh = (struct elf_aarch64_link_hash_entry *) h;
4678       return &eh->tlsdesc_got_jump_table_offset;
4679     }
4680   else
4681     {
4682       /* local symbol */
4683       struct elf_aarch64_local_symbol *l;
4684
4685       l = elf_aarch64_locals (input_bfd);
4686       return &l[r_symndx].tlsdesc_got_jump_table_offset;
4687     }
4688 }
4689
4690 static void
4691 symbol_tlsdesc_got_offset_mark (bfd *input_bfd, struct elf_link_hash_entry *h,
4692                                 unsigned long r_symndx)
4693 {
4694   bfd_vma *p;
4695   p = symbol_tlsdesc_got_offset_ref (input_bfd, h, r_symndx);
4696   *p |= 1;
4697 }
4698
4699 static int
4700 symbol_tlsdesc_got_offset_mark_p (bfd *input_bfd,
4701                                   struct elf_link_hash_entry *h,
4702                                   unsigned long r_symndx)
4703 {
4704   bfd_vma value;
4705   value = * symbol_tlsdesc_got_offset_ref (input_bfd, h, r_symndx);
4706   return value & 1;
4707 }
4708
4709 static bfd_vma
4710 symbol_tlsdesc_got_offset (bfd *input_bfd, struct elf_link_hash_entry *h,
4711                           unsigned long r_symndx)
4712 {
4713   bfd_vma value;
4714   value = * symbol_tlsdesc_got_offset_ref (input_bfd, h, r_symndx);
4715   value &= ~1;
4716   return value;
4717 }
4718
4719 /* Data for make_branch_to_erratum_835769_stub().  */
4720
4721 struct erratum_835769_branch_to_stub_data
4722 {
4723   struct bfd_link_info *info;
4724   asection *output_section;
4725   bfd_byte *contents;
4726 };
4727
4728 /* Helper to insert branches to erratum 835769 stubs in the right
4729    places for a particular section.  */
4730
4731 static bfd_boolean
4732 make_branch_to_erratum_835769_stub (struct bfd_hash_entry *gen_entry,
4733                                     void *in_arg)
4734 {
4735   struct elf_aarch64_stub_hash_entry *stub_entry;
4736   struct erratum_835769_branch_to_stub_data *data;
4737   bfd_byte *contents;
4738   unsigned long branch_insn = 0;
4739   bfd_vma veneered_insn_loc, veneer_entry_loc;
4740   bfd_signed_vma branch_offset;
4741   unsigned int target;
4742   bfd *abfd;
4743
4744   stub_entry = (struct elf_aarch64_stub_hash_entry *) gen_entry;
4745   data = (struct erratum_835769_branch_to_stub_data *) in_arg;
4746
4747   if (stub_entry->target_section != data->output_section
4748       || stub_entry->stub_type != aarch64_stub_erratum_835769_veneer)
4749     return TRUE;
4750
4751   contents = data->contents;
4752   veneered_insn_loc = stub_entry->target_section->output_section->vma
4753                       + stub_entry->target_section->output_offset
4754                       + stub_entry->target_value;
4755   veneer_entry_loc = stub_entry->stub_sec->output_section->vma
4756                      + stub_entry->stub_sec->output_offset
4757                      + stub_entry->stub_offset;
4758   branch_offset = veneer_entry_loc - veneered_insn_loc;
4759
4760   abfd = stub_entry->target_section->owner;
4761   if (!aarch64_valid_branch_p (veneer_entry_loc, veneered_insn_loc))
4762             (*_bfd_error_handler)
4763                 (_("%B: error: Erratum 835769 stub out "
4764                    "of range (input file too large)"), abfd);
4765
4766   target = stub_entry->target_value;
4767   branch_insn = 0x14000000;
4768   branch_offset >>= 2;
4769   branch_offset &= 0x3ffffff;
4770   branch_insn |= branch_offset;
4771   bfd_putl32 (branch_insn, &contents[target]);
4772
4773   return TRUE;
4774 }
4775
4776
4777 static bfd_boolean
4778 _bfd_aarch64_erratum_843419_branch_to_stub (struct bfd_hash_entry *gen_entry,
4779                                             void *in_arg)
4780 {
4781   struct elf_aarch64_stub_hash_entry *stub_entry
4782     = (struct elf_aarch64_stub_hash_entry *) gen_entry;
4783   struct erratum_835769_branch_to_stub_data *data
4784     = (struct erratum_835769_branch_to_stub_data *) in_arg;
4785   struct bfd_link_info *info;
4786   struct elf_aarch64_link_hash_table *htab;
4787   bfd_byte *contents;
4788   asection *section;
4789   bfd *abfd;
4790   bfd_vma place;
4791   uint32_t insn;
4792
4793   info = data->info;
4794   contents = data->contents;
4795   section = data->output_section;
4796
4797   htab = elf_aarch64_hash_table (info);
4798
4799   if (stub_entry->target_section != section
4800       || stub_entry->stub_type != aarch64_stub_erratum_843419_veneer)
4801     return TRUE;
4802
4803   insn = bfd_getl32 (contents + stub_entry->target_value);
4804   bfd_putl32 (insn,
4805               stub_entry->stub_sec->contents + stub_entry->stub_offset);
4806
4807   place = (section->output_section->vma + section->output_offset
4808            + stub_entry->adrp_offset);
4809   insn = bfd_getl32 (contents + stub_entry->adrp_offset);
4810
4811   if ((insn & AARCH64_ADRP_OP_MASK) !=  AARCH64_ADRP_OP)
4812     abort ();
4813
4814   bfd_signed_vma imm =
4815     (_bfd_aarch64_sign_extend
4816      ((bfd_vma) _bfd_aarch64_decode_adrp_imm (insn) << 12, 33)
4817      - (place & 0xfff));
4818
4819   if (htab->fix_erratum_843419_adr
4820       && (imm >= AARCH64_MIN_ADRP_IMM  && imm <= AARCH64_MAX_ADRP_IMM))
4821     {
4822       insn = (_bfd_aarch64_reencode_adr_imm (AARCH64_ADR_OP, imm)
4823               | AARCH64_RT (insn));
4824       bfd_putl32 (insn, contents + stub_entry->adrp_offset);
4825     }
4826   else
4827     {
4828       bfd_vma veneered_insn_loc;
4829       bfd_vma veneer_entry_loc;
4830       bfd_signed_vma branch_offset;
4831       uint32_t branch_insn;
4832
4833       veneered_insn_loc = stub_entry->target_section->output_section->vma
4834         + stub_entry->target_section->output_offset
4835         + stub_entry->target_value;
4836       veneer_entry_loc = stub_entry->stub_sec->output_section->vma
4837         + stub_entry->stub_sec->output_offset
4838         + stub_entry->stub_offset;
4839       branch_offset = veneer_entry_loc - veneered_insn_loc;
4840
4841       abfd = stub_entry->target_section->owner;
4842       if (!aarch64_valid_branch_p (veneer_entry_loc, veneered_insn_loc))
4843         (*_bfd_error_handler)
4844           (_("%B: error: Erratum 843419 stub out "
4845              "of range (input file too large)"), abfd);
4846
4847       branch_insn = 0x14000000;
4848       branch_offset >>= 2;
4849       branch_offset &= 0x3ffffff;
4850       branch_insn |= branch_offset;
4851       bfd_putl32 (branch_insn, contents + stub_entry->target_value);
4852     }
4853   return TRUE;
4854 }
4855
4856
4857 static bfd_boolean
4858 elfNN_aarch64_write_section (bfd *output_bfd  ATTRIBUTE_UNUSED,
4859                              struct bfd_link_info *link_info,
4860                              asection *sec,
4861                              bfd_byte *contents)
4862
4863 {
4864   struct elf_aarch64_link_hash_table *globals =
4865     elf_aarch64_hash_table (link_info);
4866
4867   if (globals == NULL)
4868     return FALSE;
4869
4870   /* Fix code to point to erratum 835769 stubs.  */
4871   if (globals->fix_erratum_835769)
4872     {
4873       struct erratum_835769_branch_to_stub_data data;
4874
4875       data.info = link_info;
4876       data.output_section = sec;
4877       data.contents = contents;
4878       bfd_hash_traverse (&globals->stub_hash_table,
4879                          make_branch_to_erratum_835769_stub, &data);
4880     }
4881
4882   if (globals->fix_erratum_843419)
4883     {
4884       struct erratum_835769_branch_to_stub_data data;
4885
4886       data.info = link_info;
4887       data.output_section = sec;
4888       data.contents = contents;
4889       bfd_hash_traverse (&globals->stub_hash_table,
4890                          _bfd_aarch64_erratum_843419_branch_to_stub, &data);
4891     }
4892
4893   return FALSE;
4894 }
4895
4896 /* Perform a relocation as part of a final link.  The input relocation type
4897    should be TLS relaxed.  */
4898
4899 static bfd_reloc_status_type
4900 elfNN_aarch64_final_link_relocate (reloc_howto_type *howto,
4901                                    bfd *input_bfd,
4902                                    bfd *output_bfd,
4903                                    asection *input_section,
4904                                    bfd_byte *contents,
4905                                    Elf_Internal_Rela *rel,
4906                                    bfd_vma value,
4907                                    struct bfd_link_info *info,
4908                                    asection *sym_sec,
4909                                    struct elf_link_hash_entry *h,
4910                                    bfd_boolean *unresolved_reloc_p,
4911                                    bfd_boolean save_addend,
4912                                    bfd_vma *saved_addend,
4913                                    Elf_Internal_Sym *sym)
4914 {
4915   Elf_Internal_Shdr *symtab_hdr;
4916   unsigned int r_type = howto->type;
4917   bfd_reloc_code_real_type bfd_r_type
4918     = elfNN_aarch64_bfd_reloc_from_howto (howto);
4919   unsigned long r_symndx;
4920   bfd_byte *hit_data = contents + rel->r_offset;
4921   bfd_vma place, off;
4922   bfd_signed_vma signed_addend;
4923   struct elf_aarch64_link_hash_table *globals;
4924   bfd_boolean weak_undef_p;
4925   asection *base_got;
4926
4927   globals = elf_aarch64_hash_table (info);
4928
4929   symtab_hdr = &elf_symtab_hdr (input_bfd);
4930
4931   BFD_ASSERT (is_aarch64_elf (input_bfd));
4932
4933   r_symndx = ELFNN_R_SYM (rel->r_info);
4934
4935   place = input_section->output_section->vma
4936     + input_section->output_offset + rel->r_offset;
4937
4938   /* Get addend, accumulating the addend for consecutive relocs
4939      which refer to the same offset.  */
4940   signed_addend = saved_addend ? *saved_addend : 0;
4941   signed_addend += rel->r_addend;
4942
4943   weak_undef_p = (h ? h->root.type == bfd_link_hash_undefweak
4944                   : bfd_is_und_section (sym_sec));
4945
4946   /* Since STT_GNU_IFUNC symbol must go through PLT, we handle
4947      it here if it is defined in a non-shared object.  */
4948   if (h != NULL
4949       && h->type == STT_GNU_IFUNC
4950       && h->def_regular)
4951     {
4952       asection *plt;
4953       const char *name;
4954       bfd_vma addend = 0;
4955
4956       if ((input_section->flags & SEC_ALLOC) == 0
4957           || h->plt.offset == (bfd_vma) -1)
4958         abort ();
4959
4960       /* STT_GNU_IFUNC symbol must go through PLT.  */
4961       plt = globals->root.splt ? globals->root.splt : globals->root.iplt;
4962       value = (plt->output_section->vma + plt->output_offset + h->plt.offset);
4963
4964       switch (bfd_r_type)
4965         {
4966         default:
4967           if (h->root.root.string)
4968             name = h->root.root.string;
4969           else
4970             name = bfd_elf_sym_name (input_bfd, symtab_hdr, sym,
4971                                      NULL);
4972           (*_bfd_error_handler)
4973             (_("%B: relocation %s against STT_GNU_IFUNC "
4974                "symbol `%s' isn't handled by %s"), input_bfd,
4975              howto->name, name, __FUNCTION__);
4976           bfd_set_error (bfd_error_bad_value);
4977           return FALSE;
4978
4979         case BFD_RELOC_AARCH64_NN:
4980           if (rel->r_addend != 0)
4981             {
4982               if (h->root.root.string)
4983                 name = h->root.root.string;
4984               else
4985                 name = bfd_elf_sym_name (input_bfd, symtab_hdr,
4986                                          sym, NULL);
4987               (*_bfd_error_handler)
4988                 (_("%B: relocation %s against STT_GNU_IFUNC "
4989                    "symbol `%s' has non-zero addend: %d"),
4990                  input_bfd, howto->name, name, rel->r_addend);
4991               bfd_set_error (bfd_error_bad_value);
4992               return FALSE;
4993             }
4994
4995           /* Generate dynamic relocation only when there is a
4996              non-GOT reference in a shared object.  */
4997           if (bfd_link_pic (info) && h->non_got_ref)
4998             {
4999               Elf_Internal_Rela outrel;
5000               asection *sreloc;
5001
5002               /* Need a dynamic relocation to get the real function
5003                  address.  */
5004               outrel.r_offset = _bfd_elf_section_offset (output_bfd,
5005                                                          info,
5006                                                          input_section,
5007                                                          rel->r_offset);
5008               if (outrel.r_offset == (bfd_vma) -1
5009                   || outrel.r_offset == (bfd_vma) -2)
5010                 abort ();
5011
5012               outrel.r_offset += (input_section->output_section->vma
5013                                   + input_section->output_offset);
5014
5015               if (h->dynindx == -1
5016                   || h->forced_local
5017                   || bfd_link_executable (info))
5018                 {
5019                   /* This symbol is resolved locally.  */
5020                   outrel.r_info = ELFNN_R_INFO (0, AARCH64_R (IRELATIVE));
5021                   outrel.r_addend = (h->root.u.def.value
5022                                      + h->root.u.def.section->output_section->vma
5023                                      + h->root.u.def.section->output_offset);
5024                 }
5025               else
5026                 {
5027                   outrel.r_info = ELFNN_R_INFO (h->dynindx, r_type);
5028                   outrel.r_addend = 0;
5029                 }
5030
5031               sreloc = globals->root.irelifunc;
5032               elf_append_rela (output_bfd, sreloc, &outrel);
5033
5034               /* If this reloc is against an external symbol, we
5035                  do not want to fiddle with the addend.  Otherwise,
5036                  we need to include the symbol value so that it
5037                  becomes an addend for the dynamic reloc.  For an
5038                  internal symbol, we have updated addend.  */
5039               return bfd_reloc_ok;
5040             }
5041           /* FALLTHROUGH */
5042         case BFD_RELOC_AARCH64_CALL26:
5043         case BFD_RELOC_AARCH64_JUMP26:
5044           value = _bfd_aarch64_elf_resolve_relocation (bfd_r_type, place, value,
5045                                                        signed_addend,
5046                                                        weak_undef_p);
5047           return _bfd_aarch64_elf_put_addend (input_bfd, hit_data, bfd_r_type,
5048                                               howto, value);
5049         case BFD_RELOC_AARCH64_ADR_GOT_PAGE:
5050         case BFD_RELOC_AARCH64_GOT_LD_PREL19:
5051         case BFD_RELOC_AARCH64_LD32_GOTPAGE_LO14:
5052         case BFD_RELOC_AARCH64_LD32_GOT_LO12_NC:
5053         case BFD_RELOC_AARCH64_LD64_GOTPAGE_LO15:
5054         case BFD_RELOC_AARCH64_MOVW_GOTOFF_G0_NC:
5055         case BFD_RELOC_AARCH64_MOVW_GOTOFF_G1:
5056         case BFD_RELOC_AARCH64_LD64_GOTOFF_LO15:
5057         case BFD_RELOC_AARCH64_LD64_GOT_LO12_NC:
5058           base_got = globals->root.sgot;
5059           off = h->got.offset;
5060
5061           if (base_got == NULL)
5062             abort ();
5063
5064           if (off == (bfd_vma) -1)
5065             {
5066               bfd_vma plt_index;
5067
5068               /* We can't use h->got.offset here to save state, or
5069                  even just remember the offset, as finish_dynamic_symbol
5070                  would use that as offset into .got.  */
5071
5072               if (globals->root.splt != NULL)
5073                 {
5074                   plt_index = ((h->plt.offset - globals->plt_header_size) /
5075                                globals->plt_entry_size);
5076                   off = (plt_index + 3) * GOT_ENTRY_SIZE;
5077                   base_got = globals->root.sgotplt;
5078                 }
5079               else
5080                 {
5081                   plt_index = h->plt.offset / globals->plt_entry_size;
5082                   off = plt_index * GOT_ENTRY_SIZE;
5083                   base_got = globals->root.igotplt;
5084                 }
5085
5086               if (h->dynindx == -1
5087                   || h->forced_local
5088                   || info->symbolic)
5089                 {
5090                   /* This references the local definition.  We must
5091                      initialize this entry in the global offset table.
5092                      Since the offset must always be a multiple of 8,
5093                      we use the least significant bit to record
5094                      whether we have initialized it already.
5095
5096                      When doing a dynamic link, we create a .rela.got
5097                      relocation entry to initialize the value.  This
5098                      is done in the finish_dynamic_symbol routine.       */
5099                   if ((off & 1) != 0)
5100                     off &= ~1;
5101                   else
5102                     {
5103                       bfd_put_NN (output_bfd, value,
5104                                   base_got->contents + off);
5105                       /* Note that this is harmless as -1 | 1 still is -1.  */
5106                       h->got.offset |= 1;
5107                     }
5108                 }
5109               value = (base_got->output_section->vma
5110                        + base_got->output_offset + off);
5111             }
5112           else
5113             value = aarch64_calculate_got_entry_vma (h, globals, info,
5114                                                      value, output_bfd,
5115                                                      unresolved_reloc_p);
5116
5117           switch (bfd_r_type)
5118             {
5119             case BFD_RELOC_AARCH64_LD32_GOTPAGE_LO14:
5120             case BFD_RELOC_AARCH64_LD64_GOTPAGE_LO15:
5121               addend = (globals->root.sgot->output_section->vma
5122                         + globals->root.sgot->output_offset);
5123               break;
5124             case BFD_RELOC_AARCH64_MOVW_GOTOFF_G0_NC:
5125             case BFD_RELOC_AARCH64_MOVW_GOTOFF_G1:
5126             case BFD_RELOC_AARCH64_LD64_GOTOFF_LO15:
5127               value = (value - globals->root.sgot->output_section->vma
5128                        - globals->root.sgot->output_offset);
5129             default:
5130               break;
5131             }
5132
5133           value = _bfd_aarch64_elf_resolve_relocation (bfd_r_type, place, value,
5134                                                        addend, weak_undef_p);
5135           return _bfd_aarch64_elf_put_addend (input_bfd, hit_data, bfd_r_type, howto, value);
5136         case BFD_RELOC_AARCH64_ADD_LO12:
5137         case BFD_RELOC_AARCH64_ADR_HI21_PCREL:
5138           break;
5139         }
5140     }
5141
5142   switch (bfd_r_type)
5143     {
5144     case BFD_RELOC_AARCH64_NONE:
5145     case BFD_RELOC_AARCH64_TLSDESC_ADD:
5146     case BFD_RELOC_AARCH64_TLSDESC_CALL:
5147     case BFD_RELOC_AARCH64_TLSDESC_LDR:
5148       *unresolved_reloc_p = FALSE;
5149       return bfd_reloc_ok;
5150
5151     case BFD_RELOC_AARCH64_NN:
5152
5153       /* When generating a shared object or relocatable executable, these
5154          relocations are copied into the output file to be resolved at
5155          run time.  */
5156       if (((bfd_link_pic (info) == TRUE)
5157            || globals->root.is_relocatable_executable)
5158           && (input_section->flags & SEC_ALLOC)
5159           && (h == NULL
5160               || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
5161               || h->root.type != bfd_link_hash_undefweak))
5162         {
5163           Elf_Internal_Rela outrel;
5164           bfd_byte *loc;
5165           bfd_boolean skip, relocate;
5166           asection *sreloc;
5167
5168           *unresolved_reloc_p = FALSE;
5169
5170           skip = FALSE;
5171           relocate = FALSE;
5172
5173           outrel.r_addend = signed_addend;
5174           outrel.r_offset =
5175             _bfd_elf_section_offset (output_bfd, info, input_section,
5176                                      rel->r_offset);
5177           if (outrel.r_offset == (bfd_vma) - 1)
5178             skip = TRUE;
5179           else if (outrel.r_offset == (bfd_vma) - 2)
5180             {
5181               skip = TRUE;
5182               relocate = TRUE;
5183             }
5184
5185           outrel.r_offset += (input_section->output_section->vma
5186                               + input_section->output_offset);
5187
5188           if (skip)
5189             memset (&outrel, 0, sizeof outrel);
5190           else if (h != NULL
5191                    && h->dynindx != -1
5192                    && (!bfd_link_pic (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             (_("%B: relocation %s against external symbol `%s' can not be used"
5309                " when making a shared object; recompile with -fPIC"),
5310              input_bfd, elfNN_aarch64_howto_table[howto_index].name,
5311              h->root.root.string);
5312           bfd_set_error (bfd_error_bad_value);
5313           return FALSE;
5314         }
5315
5316     case BFD_RELOC_AARCH64_16:
5317 #if ARCH_SIZE == 64
5318     case BFD_RELOC_AARCH64_32:
5319 #endif
5320     case BFD_RELOC_AARCH64_ADD_LO12:
5321     case BFD_RELOC_AARCH64_BRANCH19:
5322     case BFD_RELOC_AARCH64_LDST128_LO12:
5323     case BFD_RELOC_AARCH64_LDST16_LO12:
5324     case BFD_RELOC_AARCH64_LDST32_LO12:
5325     case BFD_RELOC_AARCH64_LDST64_LO12:
5326     case BFD_RELOC_AARCH64_LDST8_LO12:
5327     case BFD_RELOC_AARCH64_MOVW_G0:
5328     case BFD_RELOC_AARCH64_MOVW_G0_NC:
5329     case BFD_RELOC_AARCH64_MOVW_G0_S:
5330     case BFD_RELOC_AARCH64_MOVW_G1:
5331     case BFD_RELOC_AARCH64_MOVW_G1_NC:
5332     case BFD_RELOC_AARCH64_MOVW_G1_S:
5333     case BFD_RELOC_AARCH64_MOVW_G2:
5334     case BFD_RELOC_AARCH64_MOVW_G2_NC:
5335     case BFD_RELOC_AARCH64_MOVW_G2_S:
5336     case BFD_RELOC_AARCH64_MOVW_G3:
5337     case BFD_RELOC_AARCH64_TSTBR14:
5338       value = _bfd_aarch64_elf_resolve_relocation (bfd_r_type, place, value,
5339                                                    signed_addend, weak_undef_p);
5340       break;
5341
5342     case BFD_RELOC_AARCH64_ADR_GOT_PAGE:
5343     case BFD_RELOC_AARCH64_GOT_LD_PREL19:
5344     case BFD_RELOC_AARCH64_LD32_GOTPAGE_LO14:
5345     case BFD_RELOC_AARCH64_LD32_GOT_LO12_NC:
5346     case BFD_RELOC_AARCH64_LD64_GOTPAGE_LO15:
5347     case BFD_RELOC_AARCH64_LD64_GOT_LO12_NC:
5348       if (globals->root.sgot == NULL)
5349         BFD_ASSERT (h != NULL);
5350
5351       if (h != NULL)
5352         {
5353           bfd_vma addend = 0;
5354           value = aarch64_calculate_got_entry_vma (h, globals, info, value,
5355                                                    output_bfd,
5356                                                    unresolved_reloc_p);
5357           if (bfd_r_type == BFD_RELOC_AARCH64_LD64_GOTPAGE_LO15
5358               || bfd_r_type == BFD_RELOC_AARCH64_LD32_GOTPAGE_LO14)
5359             addend = (globals->root.sgot->output_section->vma
5360                       + globals->root.sgot->output_offset);
5361           value = _bfd_aarch64_elf_resolve_relocation (bfd_r_type, place, value,
5362                                                        addend, weak_undef_p);
5363         }
5364       else
5365       {
5366         bfd_vma addend = 0;
5367         struct elf_aarch64_local_symbol *locals
5368           = elf_aarch64_locals (input_bfd);
5369
5370         if (locals == NULL)
5371           {
5372             int howto_index = bfd_r_type - BFD_RELOC_AARCH64_RELOC_START;
5373             (*_bfd_error_handler)
5374               (_("%B: Local symbol descriptor table be NULL when applying "
5375                  "relocation %s against local symbol"),
5376                input_bfd, elfNN_aarch64_howto_table[howto_index].name);
5377             abort ();
5378           }
5379
5380         off = symbol_got_offset (input_bfd, h, r_symndx);
5381         base_got = globals->root.sgot;
5382         bfd_vma got_entry_addr = (base_got->output_section->vma
5383                                   + base_got->output_offset + off);
5384
5385         if (!symbol_got_offset_mark_p (input_bfd, h, r_symndx))
5386           {
5387             bfd_put_64 (output_bfd, value, base_got->contents + off);
5388
5389             if (bfd_link_pic (info))
5390               {
5391                 asection *s;
5392                 Elf_Internal_Rela outrel;
5393
5394                 /* For local symbol, we have done absolute relocation in static
5395                    linking stageh. While for share library, we need to update
5396                    the content of GOT entry according to the share objects
5397                    loading base address. So we need to generate a
5398                    R_AARCH64_RELATIVE reloc for dynamic linker.  */
5399                 s = globals->root.srelgot;
5400                 if (s == NULL)
5401                   abort ();
5402
5403                 outrel.r_offset = got_entry_addr;
5404                 outrel.r_info = ELFNN_R_INFO (0, AARCH64_R (RELATIVE));
5405                 outrel.r_addend = value;
5406                 elf_append_rela (output_bfd, s, &outrel);
5407               }
5408
5409             symbol_got_offset_mark (input_bfd, h, r_symndx);
5410           }
5411
5412         /* Update the relocation value to GOT entry addr as we have transformed
5413            the direct data access into indirect data access through GOT.  */
5414         value = got_entry_addr;
5415
5416         if (bfd_r_type == BFD_RELOC_AARCH64_LD64_GOTPAGE_LO15
5417             || bfd_r_type == BFD_RELOC_AARCH64_LD32_GOTPAGE_LO14)
5418           addend = base_got->output_section->vma + base_got->output_offset;
5419
5420         value = _bfd_aarch64_elf_resolve_relocation (bfd_r_type, place, value,
5421                                                      addend, weak_undef_p);
5422       }
5423
5424       break;
5425
5426     case BFD_RELOC_AARCH64_LD64_GOTOFF_LO15:
5427     case BFD_RELOC_AARCH64_MOVW_GOTOFF_G0_NC:
5428     case BFD_RELOC_AARCH64_MOVW_GOTOFF_G1:
5429       if (h != NULL)
5430           value = aarch64_calculate_got_entry_vma (h, globals, info, value,
5431                                                    output_bfd,
5432                                                    unresolved_reloc_p);
5433       else
5434         {
5435           struct elf_aarch64_local_symbol *locals
5436             = elf_aarch64_locals (input_bfd);
5437
5438           if (locals == NULL)
5439             {
5440               int howto_index = bfd_r_type - BFD_RELOC_AARCH64_RELOC_START;
5441               (*_bfd_error_handler)
5442                 (_("%B: Local symbol descriptor table be NULL when applying "
5443                    "relocation %s against local symbol"),
5444                  input_bfd, elfNN_aarch64_howto_table[howto_index].name);
5445               abort ();
5446             }
5447
5448           off = symbol_got_offset (input_bfd, h, r_symndx);
5449           base_got = globals->root.sgot;
5450           if (base_got == NULL)
5451             abort ();
5452
5453           bfd_vma got_entry_addr = (base_got->output_section->vma
5454                                     + base_got->output_offset + off);
5455
5456           if (!symbol_got_offset_mark_p (input_bfd, h, r_symndx))
5457             {
5458               bfd_put_64 (output_bfd, value, base_got->contents + off);
5459
5460               if (bfd_link_pic (info))
5461                 {
5462                   asection *s;
5463                   Elf_Internal_Rela outrel;
5464
5465                   /* For local symbol, we have done absolute relocation in static
5466                      linking stage.  While for share library, we need to update
5467                      the content of GOT entry according to the share objects
5468                      loading base address.  So we need to generate a
5469                      R_AARCH64_RELATIVE reloc for dynamic linker.  */
5470                   s = globals->root.srelgot;
5471                   if (s == NULL)
5472                     abort ();
5473
5474                   outrel.r_offset = got_entry_addr;
5475                   outrel.r_info = ELFNN_R_INFO (0, AARCH64_R (RELATIVE));
5476                   outrel.r_addend = value;
5477                   elf_append_rela (output_bfd, s, &outrel);
5478                 }
5479
5480               symbol_got_offset_mark (input_bfd, h, r_symndx);
5481             }
5482         }
5483
5484       /* Update the relocation value to GOT entry addr as we have transformed
5485          the direct data access into indirect data access through GOT.  */
5486       value = symbol_got_offset (input_bfd, h, r_symndx);
5487       value = _bfd_aarch64_elf_resolve_relocation (bfd_r_type, place, value,
5488                                                    0, weak_undef_p);
5489       *unresolved_reloc_p = FALSE;
5490       break;
5491
5492     case BFD_RELOC_AARCH64_TLSGD_ADD_LO12_NC:
5493     case BFD_RELOC_AARCH64_TLSGD_ADR_PAGE21:
5494     case BFD_RELOC_AARCH64_TLSGD_ADR_PREL21:
5495     case BFD_RELOC_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21:
5496     case BFD_RELOC_AARCH64_TLSIE_LD32_GOTTPREL_LO12_NC:
5497     case BFD_RELOC_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC:
5498     case BFD_RELOC_AARCH64_TLSIE_LD_GOTTPREL_PREL19:
5499     case BFD_RELOC_AARCH64_TLSLD_ADD_LO12_NC:
5500     case BFD_RELOC_AARCH64_TLSLD_ADR_PAGE21:
5501     case BFD_RELOC_AARCH64_TLSLD_ADR_PREL21:
5502       if (globals->root.sgot == NULL)
5503         return bfd_reloc_notsupported;
5504
5505       value = (symbol_got_offset (input_bfd, h, r_symndx)
5506                + globals->root.sgot->output_section->vma
5507                + globals->root.sgot->output_offset);
5508
5509       value = _bfd_aarch64_elf_resolve_relocation (bfd_r_type, place, value,
5510                                                    0, weak_undef_p);
5511       *unresolved_reloc_p = FALSE;
5512       break;
5513
5514     case BFD_RELOC_AARCH64_TLSGD_MOVW_G0_NC:
5515     case BFD_RELOC_AARCH64_TLSGD_MOVW_G1:
5516     case BFD_RELOC_AARCH64_TLSIE_MOVW_GOTTPREL_G0_NC:
5517     case BFD_RELOC_AARCH64_TLSIE_MOVW_GOTTPREL_G1:
5518       if (globals->root.sgot == NULL)
5519         return bfd_reloc_notsupported;
5520
5521       value = symbol_got_offset (input_bfd, h, r_symndx);
5522       value = _bfd_aarch64_elf_resolve_relocation (bfd_r_type, place, value,
5523                                                    0, weak_undef_p);
5524       *unresolved_reloc_p = FALSE;
5525       break;
5526
5527     case BFD_RELOC_AARCH64_TLSLD_ADD_DTPREL_HI12:
5528     case BFD_RELOC_AARCH64_TLSLD_ADD_DTPREL_LO12:
5529     case BFD_RELOC_AARCH64_TLSLD_ADD_DTPREL_LO12_NC:
5530     case BFD_RELOC_AARCH64_TLSLD_LDST16_DTPREL_LO12:
5531     case BFD_RELOC_AARCH64_TLSLD_LDST16_DTPREL_LO12_NC:
5532     case BFD_RELOC_AARCH64_TLSLD_LDST32_DTPREL_LO12:
5533     case BFD_RELOC_AARCH64_TLSLD_LDST32_DTPREL_LO12_NC:
5534     case BFD_RELOC_AARCH64_TLSLD_LDST64_DTPREL_LO12:
5535     case BFD_RELOC_AARCH64_TLSLD_LDST64_DTPREL_LO12_NC:
5536     case BFD_RELOC_AARCH64_TLSLD_LDST8_DTPREL_LO12:
5537     case BFD_RELOC_AARCH64_TLSLD_LDST8_DTPREL_LO12_NC:
5538     case BFD_RELOC_AARCH64_TLSLD_MOVW_DTPREL_G0:
5539     case BFD_RELOC_AARCH64_TLSLD_MOVW_DTPREL_G0_NC:
5540     case BFD_RELOC_AARCH64_TLSLD_MOVW_DTPREL_G1:
5541     case BFD_RELOC_AARCH64_TLSLD_MOVW_DTPREL_G1_NC:
5542     case BFD_RELOC_AARCH64_TLSLD_MOVW_DTPREL_G2:
5543       value = _bfd_aarch64_elf_resolve_relocation (bfd_r_type, place, value,
5544                                                    signed_addend - dtpoff_base (info),
5545                                                    weak_undef_p);
5546       break;
5547
5548     case BFD_RELOC_AARCH64_TLSLE_ADD_TPREL_HI12:
5549     case BFD_RELOC_AARCH64_TLSLE_ADD_TPREL_LO12:
5550     case BFD_RELOC_AARCH64_TLSLE_ADD_TPREL_LO12_NC:
5551     case BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G0:
5552     case BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G0_NC:
5553     case BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G1:
5554     case BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G1_NC:
5555     case BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G2:
5556       value = _bfd_aarch64_elf_resolve_relocation (bfd_r_type, place, value,
5557                                                    signed_addend - tpoff_base (info),
5558                                                    weak_undef_p);
5559       *unresolved_reloc_p = FALSE;
5560       break;
5561
5562     case BFD_RELOC_AARCH64_TLSDESC_ADD_LO12_NC:
5563     case BFD_RELOC_AARCH64_TLSDESC_ADR_PAGE21:
5564     case BFD_RELOC_AARCH64_TLSDESC_ADR_PREL21:
5565     case BFD_RELOC_AARCH64_TLSDESC_LD32_LO12_NC:
5566     case BFD_RELOC_AARCH64_TLSDESC_LD64_LO12_NC:
5567     case BFD_RELOC_AARCH64_TLSDESC_LD_PREL19:
5568       if (globals->root.sgot == NULL)
5569         return bfd_reloc_notsupported;
5570       value = (symbol_tlsdesc_got_offset (input_bfd, h, r_symndx)
5571                + globals->root.sgotplt->output_section->vma
5572                + globals->root.sgotplt->output_offset
5573                + globals->sgotplt_jump_table_size);
5574
5575       value = _bfd_aarch64_elf_resolve_relocation (bfd_r_type, place, value,
5576                                                    0, weak_undef_p);
5577       *unresolved_reloc_p = FALSE;
5578       break;
5579
5580     case BFD_RELOC_AARCH64_TLSDESC_OFF_G0_NC:
5581     case BFD_RELOC_AARCH64_TLSDESC_OFF_G1:
5582       if (globals->root.sgot == NULL)
5583         return bfd_reloc_notsupported;
5584
5585       value = (symbol_tlsdesc_got_offset (input_bfd, h, r_symndx)
5586                + globals->root.sgotplt->output_section->vma
5587                + globals->root.sgotplt->output_offset
5588                + globals->sgotplt_jump_table_size);
5589
5590       value -= (globals->root.sgot->output_section->vma
5591                 + globals->root.sgot->output_offset);
5592
5593       value = _bfd_aarch64_elf_resolve_relocation (bfd_r_type, place, value,
5594                                                    0, weak_undef_p);
5595       *unresolved_reloc_p = FALSE;
5596       break;
5597
5598     default:
5599       return bfd_reloc_notsupported;
5600     }
5601
5602   if (saved_addend)
5603     *saved_addend = value;
5604
5605   /* Only apply the final relocation in a sequence.  */
5606   if (save_addend)
5607     return bfd_reloc_continue;
5608
5609   return _bfd_aarch64_elf_put_addend (input_bfd, hit_data, bfd_r_type,
5610                                       howto, value);
5611 }
5612
5613 /* Handle TLS relaxations.  Relaxing is possible for symbols that use
5614    R_AARCH64_TLSDESC_ADR_{PAGE, LD64_LO12_NC, ADD_LO12_NC} during a static
5615    link.
5616
5617    Return bfd_reloc_ok if we're done, bfd_reloc_continue if the caller
5618    is to then call final_link_relocate.  Return other values in the
5619    case of error.  */
5620
5621 static bfd_reloc_status_type
5622 elfNN_aarch64_tls_relax (struct elf_aarch64_link_hash_table *globals,
5623                          bfd *input_bfd, bfd_byte *contents,
5624                          Elf_Internal_Rela *rel, struct elf_link_hash_entry *h)
5625 {
5626   bfd_boolean is_local = h == NULL;
5627   unsigned int r_type = ELFNN_R_TYPE (rel->r_info);
5628   unsigned long insn;
5629
5630   BFD_ASSERT (globals && input_bfd && contents && rel);
5631
5632   switch (elfNN_aarch64_bfd_reloc_from_type (r_type))
5633     {
5634     case BFD_RELOC_AARCH64_TLSDESC_ADR_PAGE21:
5635     case BFD_RELOC_AARCH64_TLSGD_ADR_PAGE21:
5636       if (is_local)
5637         {
5638           /* GD->LE relaxation:
5639              adrp x0, :tlsgd:var     =>   movz x0, :tprel_g1:var
5640              or
5641              adrp x0, :tlsdesc:var   =>   movz x0, :tprel_g1:var
5642            */
5643           bfd_putl32 (0xd2a00000, contents + rel->r_offset);
5644           return bfd_reloc_continue;
5645         }
5646       else
5647         {
5648           /* GD->IE relaxation:
5649              adrp x0, :tlsgd:var     =>   adrp x0, :gottprel:var
5650              or
5651              adrp x0, :tlsdesc:var   =>   adrp x0, :gottprel:var
5652            */
5653           return bfd_reloc_continue;
5654         }
5655
5656     case BFD_RELOC_AARCH64_TLSDESC_ADR_PREL21:
5657       BFD_ASSERT (0);
5658       break;
5659
5660     case BFD_RELOC_AARCH64_TLSDESC_LD_PREL19:
5661       if (is_local)
5662         {
5663           /* Tiny TLSDESC->LE relaxation:
5664              ldr   x1, :tlsdesc:var      =>  movz  x0, #:tprel_g1:var
5665              adr   x0, :tlsdesc:var      =>  movk  x0, #:tprel_g0_nc:var
5666              .tlsdesccall var
5667              blr   x1                    =>  nop
5668            */
5669           BFD_ASSERT (ELFNN_R_TYPE (rel[1].r_info) == AARCH64_R (TLSDESC_ADR_PREL21));
5670           BFD_ASSERT (ELFNN_R_TYPE (rel[2].r_info) == AARCH64_R (TLSDESC_CALL));
5671
5672           rel[1].r_info = ELFNN_R_INFO (ELFNN_R_SYM (rel->r_info),
5673                                         AARCH64_R (TLSLE_MOVW_TPREL_G0_NC));
5674           rel[2].r_info = ELFNN_R_INFO (STN_UNDEF, R_AARCH64_NONE);
5675
5676           bfd_putl32 (0xd2a00000, contents + rel->r_offset);
5677           bfd_putl32 (0xf2800000, contents + rel->r_offset + 4);
5678           bfd_putl32 (INSN_NOP, contents + rel->r_offset + 8);
5679           return bfd_reloc_continue;
5680         }
5681       else
5682         {
5683           /* Tiny TLSDESC->IE relaxation:
5684              ldr   x1, :tlsdesc:var      =>  ldr   x0, :gottprel:var
5685              adr   x0, :tlsdesc:var      =>  nop
5686              .tlsdesccall var
5687              blr   x1                    =>  nop
5688            */
5689           BFD_ASSERT (ELFNN_R_TYPE (rel[1].r_info) == AARCH64_R (TLSDESC_ADR_PREL21));
5690           BFD_ASSERT (ELFNN_R_TYPE (rel[2].r_info) == AARCH64_R (TLSDESC_CALL));
5691
5692           rel[1].r_info = ELFNN_R_INFO (STN_UNDEF, R_AARCH64_NONE);
5693           rel[2].r_info = ELFNN_R_INFO (STN_UNDEF, R_AARCH64_NONE);
5694
5695           bfd_putl32 (0x58000000, contents + rel->r_offset);
5696           bfd_putl32 (INSN_NOP, contents + rel->r_offset + 4);
5697           bfd_putl32 (INSN_NOP, contents + rel->r_offset + 8);
5698           return bfd_reloc_continue;
5699         }
5700
5701     case BFD_RELOC_AARCH64_TLSGD_ADR_PREL21:
5702       if (is_local)
5703         {
5704           /* Tiny GD->LE relaxation:
5705              adr x0, :tlsgd:var      =>   mrs  x1, tpidr_el0
5706              bl   __tls_get_addr     =>   add  x0, x1, #:tprel_hi12:x, lsl #12
5707              nop                     =>   add  x0, x0, #:tprel_lo12_nc:x
5708            */
5709
5710           /* First kill the tls_get_addr reloc on the bl instruction.  */
5711           BFD_ASSERT (rel->r_offset + 4 == rel[1].r_offset);
5712
5713           bfd_putl32 (0xd53bd041, contents + rel->r_offset + 0);
5714           bfd_putl32 (0x91400020, contents + rel->r_offset + 4);
5715           bfd_putl32 (0x91000000, contents + rel->r_offset + 8);
5716
5717           rel[1].r_info = ELFNN_R_INFO (ELFNN_R_SYM (rel->r_info),
5718                                         AARCH64_R (TLSLE_ADD_TPREL_LO12_NC));
5719           rel[1].r_offset = rel->r_offset + 8;
5720
5721           /* Move the current relocation to the second instruction in
5722              the sequence.  */
5723           rel->r_offset += 4;
5724           rel->r_info = ELFNN_R_INFO (ELFNN_R_SYM (rel->r_info),
5725                                       AARCH64_R (TLSLE_ADD_TPREL_HI12));
5726           return bfd_reloc_continue;
5727         }
5728       else
5729         {
5730           /* Tiny GD->IE relaxation:
5731              adr x0, :tlsgd:var      =>   ldr  x0, :gottprel:var
5732              bl   __tls_get_addr     =>   mrs  x1, tpidr_el0
5733              nop                     =>   add  x0, x0, x1
5734            */
5735
5736           /* First kill the tls_get_addr reloc on the bl instruction.  */
5737           BFD_ASSERT (rel->r_offset + 4 == rel[1].r_offset);
5738           rel[1].r_info = ELFNN_R_INFO (STN_UNDEF, R_AARCH64_NONE);
5739
5740           bfd_putl32 (0x58000000, contents + rel->r_offset);
5741           bfd_putl32 (0xd53bd041, contents + rel->r_offset + 4);
5742           bfd_putl32 (0x8b000020, contents + rel->r_offset + 8);
5743           return bfd_reloc_continue;
5744         }
5745
5746 #if ARCH_SIZE == 64
5747     case BFD_RELOC_AARCH64_TLSGD_MOVW_G1:
5748       BFD_ASSERT (ELFNN_R_TYPE (rel[1].r_info) == AARCH64_R (TLSGD_MOVW_G0_NC));
5749       BFD_ASSERT (rel->r_offset + 12 == rel[2].r_offset);
5750       BFD_ASSERT (ELFNN_R_TYPE (rel[2].r_info) == AARCH64_R (CALL26));
5751
5752       if (is_local)
5753         {
5754           /* Large GD->LE relaxation:
5755              movz x0, #:tlsgd_g1:var    => movz x0, #:tprel_g2:var, lsl #32
5756              movk x0, #:tlsgd_g0_nc:var => movk x0, #:tprel_g1_nc:var, lsl #16
5757              add x0, gp, x0             => movk x0, #:tprel_g0_nc:var
5758              bl __tls_get_addr          => mrs x1, tpidr_el0
5759              nop                        => add x0, x0, x1
5760            */
5761           rel[2].r_info = ELFNN_R_INFO (ELFNN_R_SYM (rel->r_info),
5762                                         AARCH64_R (TLSLE_MOVW_TPREL_G0_NC));
5763           rel[2].r_offset = rel->r_offset + 8;
5764
5765           bfd_putl32 (0xd2c00000, contents + rel->r_offset + 0);
5766           bfd_putl32 (0xf2a00000, contents + rel->r_offset + 4);
5767           bfd_putl32 (0xf2800000, contents + rel->r_offset + 8);
5768           bfd_putl32 (0xd53bd041, contents + rel->r_offset + 12);
5769           bfd_putl32 (0x8b000020, contents + rel->r_offset + 16);
5770         }
5771       else
5772         {
5773           /* Large GD->IE relaxation:
5774              movz x0, #:tlsgd_g1:var    => movz x0, #:gottprel_g1:var, lsl #16
5775              movk x0, #:tlsgd_g0_nc:var => movk x0, #:gottprel_g0_nc:var
5776              add x0, gp, x0             => ldr x0, [gp, x0]
5777              bl __tls_get_addr          => mrs x1, tpidr_el0
5778              nop                        => add x0, x0, x1
5779            */
5780           rel[2].r_info = ELFNN_R_INFO (STN_UNDEF, R_AARCH64_NONE);
5781           bfd_putl32 (0xd2a80000, contents + rel->r_offset + 0);
5782           bfd_putl32 (0x58000000, contents + rel->r_offset + 8);
5783           bfd_putl32 (0xd53bd041, contents + rel->r_offset + 12);
5784           bfd_putl32 (0x8b000020, contents + rel->r_offset + 16);
5785         }
5786       return bfd_reloc_continue;
5787
5788     case BFD_RELOC_AARCH64_TLSGD_MOVW_G0_NC:
5789       return bfd_reloc_continue;
5790 #endif
5791
5792     case BFD_RELOC_AARCH64_TLSIE_LD_GOTTPREL_PREL19:
5793       return bfd_reloc_continue;
5794
5795     case BFD_RELOC_AARCH64_TLSDESC_LDNN_LO12_NC:
5796       if (is_local)
5797         {
5798           /* GD->LE relaxation:
5799              ldr xd, [x0, #:tlsdesc_lo12:var]   =>   movk x0, :tprel_g0_nc:var
5800            */
5801           bfd_putl32 (0xf2800000, contents + rel->r_offset);
5802           return bfd_reloc_continue;
5803         }
5804       else
5805         {
5806           /* GD->IE relaxation:
5807              ldr xd, [x0, #:tlsdesc_lo12:var] => ldr x0, [x0, #:gottprel_lo12:var]
5808            */
5809           insn = bfd_getl32 (contents + rel->r_offset);
5810           insn &= 0xffffffe0;
5811           bfd_putl32 (insn, contents + rel->r_offset);
5812           return bfd_reloc_continue;
5813         }
5814
5815     case BFD_RELOC_AARCH64_TLSGD_ADD_LO12_NC:
5816       if (is_local)
5817         {
5818           /* GD->LE relaxation
5819              add  x0, #:tlsgd_lo12:var  => movk x0, :tprel_g0_nc:var
5820              bl   __tls_get_addr        => mrs  x1, tpidr_el0
5821              nop                        => add  x0, x1, x0
5822            */
5823
5824           /* First kill the tls_get_addr reloc on the bl instruction.  */
5825           BFD_ASSERT (rel->r_offset + 4 == rel[1].r_offset);
5826           rel[1].r_info = ELFNN_R_INFO (STN_UNDEF, R_AARCH64_NONE);
5827
5828           bfd_putl32 (0xf2800000, contents + rel->r_offset);
5829           bfd_putl32 (0xd53bd041, contents + rel->r_offset + 4);
5830           bfd_putl32 (0x8b000020, contents + rel->r_offset + 8);
5831           return bfd_reloc_continue;
5832         }
5833       else
5834         {
5835           /* GD->IE relaxation
5836              ADD  x0, #:tlsgd_lo12:var  => ldr  x0, [x0, #:gottprel_lo12:var]
5837              BL   __tls_get_addr        => mrs  x1, tpidr_el0
5838                R_AARCH64_CALL26
5839              NOP                        => add  x0, x1, x0
5840            */
5841
5842           BFD_ASSERT (ELFNN_R_TYPE (rel[1].r_info) == AARCH64_R (CALL26));
5843
5844           /* Remove the relocation on the BL instruction.  */
5845           rel[1].r_info = ELFNN_R_INFO (STN_UNDEF, R_AARCH64_NONE);
5846
5847           bfd_putl32 (0xf9400000, contents + rel->r_offset);
5848
5849           /* We choose to fixup the BL and NOP instructions using the
5850              offset from the second relocation to allow flexibility in
5851              scheduling instructions between the ADD and BL.  */
5852           bfd_putl32 (0xd53bd041, contents + rel[1].r_offset);
5853           bfd_putl32 (0x8b000020, contents + rel[1].r_offset + 4);
5854           return bfd_reloc_continue;
5855         }
5856
5857     case BFD_RELOC_AARCH64_TLSDESC_ADD:
5858     case BFD_RELOC_AARCH64_TLSDESC_ADD_LO12_NC:
5859     case BFD_RELOC_AARCH64_TLSDESC_CALL:
5860       /* GD->IE/LE relaxation:
5861          add x0, x0, #:tlsdesc_lo12:var   =>   nop
5862          blr xd                           =>   nop
5863        */
5864       bfd_putl32 (INSN_NOP, contents + rel->r_offset);
5865       return bfd_reloc_ok;
5866
5867     case BFD_RELOC_AARCH64_TLSDESC_LDR:
5868       if (is_local)
5869         {
5870           /* GD->LE relaxation:
5871              ldr xd, [gp, xn]   =>   movk x0, #:tprel_g0_nc:var
5872            */
5873           bfd_putl32 (0xf2800000, contents + rel->r_offset);
5874           return bfd_reloc_continue;
5875         }
5876       else
5877         {
5878           /* GD->IE relaxation:
5879              ldr xd, [gp, xn]   =>   ldr x0, [gp, xn]
5880            */
5881           insn = bfd_getl32 (contents + rel->r_offset);
5882           insn &= 0xffffffe0;
5883           bfd_putl32 (insn, contents + rel->r_offset);
5884           return bfd_reloc_ok;
5885         }
5886
5887     case BFD_RELOC_AARCH64_TLSDESC_OFF_G0_NC:
5888       /* GD->LE relaxation:
5889          movk xd, #:tlsdesc_off_g0_nc:var => movk x0, #:tprel_g1_nc:var, lsl #16
5890          GD->IE relaxation:
5891          movk xd, #:tlsdesc_off_g0_nc:var => movk xd, #:gottprel_g0_nc:var
5892       */
5893       if (is_local)
5894         bfd_putl32 (0xf2a00000, contents + rel->r_offset);
5895       return bfd_reloc_continue;
5896
5897     case BFD_RELOC_AARCH64_TLSDESC_OFF_G1:
5898       if (is_local)
5899         {
5900           /* GD->LE relaxation:
5901              movz xd, #:tlsdesc_off_g1:var => movz x0, #:tprel_g2:var, lsl #32
5902           */
5903           bfd_putl32 (0xd2c00000, contents + rel->r_offset);
5904           return bfd_reloc_continue;
5905         }
5906       else
5907         {
5908           /*  GD->IE relaxation:
5909               movz xd, #:tlsdesc_off_g1:var => movz xd, #:gottprel_g1:var, lsl #16
5910           */
5911           insn = bfd_getl32 (contents + rel->r_offset);
5912           bfd_putl32 (0xd2a00000 | (insn & 0x1f), contents + rel->r_offset);
5913           return bfd_reloc_continue;
5914         }
5915
5916     case BFD_RELOC_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21:
5917       /* IE->LE relaxation:
5918          adrp xd, :gottprel:var   =>   movz xd, :tprel_g1:var
5919        */
5920       if (is_local)
5921         {
5922           insn = bfd_getl32 (contents + rel->r_offset);
5923           bfd_putl32 (0xd2a00000 | (insn & 0x1f), contents + rel->r_offset);
5924         }
5925       return bfd_reloc_continue;
5926
5927     case BFD_RELOC_AARCH64_TLSIE_LDNN_GOTTPREL_LO12_NC:
5928       /* IE->LE relaxation:
5929          ldr  xd, [xm, #:gottprel_lo12:var]   =>   movk xd, :tprel_g0_nc:var
5930        */
5931       if (is_local)
5932         {
5933           insn = bfd_getl32 (contents + rel->r_offset);
5934           bfd_putl32 (0xf2800000 | (insn & 0x1f), contents + rel->r_offset);
5935         }
5936       return bfd_reloc_continue;
5937
5938     case BFD_RELOC_AARCH64_TLSLD_ADR_PREL21:
5939       /* LD->LE relaxation (tiny):
5940          adr  x0, :tlsldm:x  => mrs x0, tpidr_el0
5941          bl   __tls_get_addr => add x0, x0, TCB_SIZE
5942        */
5943       if (is_local)
5944         {
5945           BFD_ASSERT (rel->r_offset + 4 == rel[1].r_offset);
5946           BFD_ASSERT (ELFNN_R_TYPE (rel[1].r_info) == AARCH64_R (CALL26));
5947           /* No need of CALL26 relocation for tls_get_addr.  */
5948           rel[1].r_info = ELFNN_R_INFO (STN_UNDEF, R_AARCH64_NONE);
5949           bfd_putl32 (0xd53bd040, contents + rel->r_offset + 0);
5950           bfd_putl32 (0x91004000, contents + rel->r_offset + 4);
5951           return bfd_reloc_ok;
5952         }
5953       return bfd_reloc_continue;
5954
5955     case BFD_RELOC_AARCH64_TLSLD_ADR_PAGE21:
5956       /* LD->LE relaxation (small):
5957          adrp  x0, :tlsldm:x       => mrs x0, tpidr_el0
5958        */
5959       if (is_local)
5960         {
5961           bfd_putl32 (0xd53bd040, contents + rel->r_offset);
5962           return bfd_reloc_ok;
5963         }
5964       return bfd_reloc_continue;
5965
5966     case BFD_RELOC_AARCH64_TLSLD_ADD_LO12_NC:
5967       /* LD->LE relaxation (small):
5968          add   x0, #:tlsldm_lo12:x => add x0, x0, TCB_SIZE
5969          bl   __tls_get_addr       => nop
5970        */
5971       if (is_local)
5972         {
5973           BFD_ASSERT (rel->r_offset + 4 == rel[1].r_offset);
5974           BFD_ASSERT (ELFNN_R_TYPE (rel[1].r_info) == AARCH64_R (CALL26));
5975           /* No need of CALL26 relocation for tls_get_addr.  */
5976           rel[1].r_info = ELFNN_R_INFO (STN_UNDEF, R_AARCH64_NONE);
5977           bfd_putl32 (0x91004000, contents + rel->r_offset + 0);
5978           bfd_putl32 (0xd503201f, contents + rel->r_offset + 4);
5979           return bfd_reloc_ok;
5980         }
5981       return bfd_reloc_continue;
5982
5983     default:
5984       return bfd_reloc_continue;
5985     }
5986
5987   return bfd_reloc_ok;
5988 }
5989
5990 /* Relocate an AArch64 ELF section.  */
5991
5992 static bfd_boolean
5993 elfNN_aarch64_relocate_section (bfd *output_bfd,
5994                                 struct bfd_link_info *info,
5995                                 bfd *input_bfd,
5996                                 asection *input_section,
5997                                 bfd_byte *contents,
5998                                 Elf_Internal_Rela *relocs,
5999                                 Elf_Internal_Sym *local_syms,
6000                                 asection **local_sections)
6001 {
6002   Elf_Internal_Shdr *symtab_hdr;
6003   struct elf_link_hash_entry **sym_hashes;
6004   Elf_Internal_Rela *rel;
6005   Elf_Internal_Rela *relend;
6006   const char *name;
6007   struct elf_aarch64_link_hash_table *globals;
6008   bfd_boolean save_addend = FALSE;
6009   bfd_vma addend = 0;
6010
6011   globals = elf_aarch64_hash_table (info);
6012
6013   symtab_hdr = &elf_symtab_hdr (input_bfd);
6014   sym_hashes = elf_sym_hashes (input_bfd);
6015
6016   rel = relocs;
6017   relend = relocs + input_section->reloc_count;
6018   for (; rel < relend; rel++)
6019     {
6020       unsigned int r_type;
6021       bfd_reloc_code_real_type bfd_r_type;
6022       bfd_reloc_code_real_type relaxed_bfd_r_type;
6023       reloc_howto_type *howto;
6024       unsigned long r_symndx;
6025       Elf_Internal_Sym *sym;
6026       asection *sec;
6027       struct elf_link_hash_entry *h;
6028       bfd_vma relocation;
6029       bfd_reloc_status_type r;
6030       arelent bfd_reloc;
6031       char sym_type;
6032       bfd_boolean unresolved_reloc = FALSE;
6033       char *error_message = NULL;
6034
6035       r_symndx = ELFNN_R_SYM (rel->r_info);
6036       r_type = ELFNN_R_TYPE (rel->r_info);
6037
6038       bfd_reloc.howto = elfNN_aarch64_howto_from_type (r_type);
6039       howto = bfd_reloc.howto;
6040
6041       if (howto == NULL)
6042         {
6043           (*_bfd_error_handler)
6044             (_("%B: unrecognized relocation (0x%x) in section `%A'"),
6045              input_bfd, input_section, r_type);
6046           return FALSE;
6047         }
6048       bfd_r_type = elfNN_aarch64_bfd_reloc_from_howto (howto);
6049
6050       h = NULL;
6051       sym = NULL;
6052       sec = NULL;
6053
6054       if (r_symndx < symtab_hdr->sh_info)
6055         {
6056           sym = local_syms + r_symndx;
6057           sym_type = ELFNN_ST_TYPE (sym->st_info);
6058           sec = local_sections[r_symndx];
6059
6060           /* An object file might have a reference to a local
6061              undefined symbol.  This is a daft object file, but we
6062              should at least do something about it.  */
6063           if (r_type != R_AARCH64_NONE && r_type != R_AARCH64_NULL
6064               && bfd_is_und_section (sec)
6065               && ELF_ST_BIND (sym->st_info) != STB_WEAK)
6066             {
6067               if (!info->callbacks->undefined_symbol
6068                   (info, bfd_elf_string_from_elf_section
6069                    (input_bfd, symtab_hdr->sh_link, sym->st_name),
6070                    input_bfd, input_section, rel->r_offset, TRUE))
6071                 return FALSE;
6072             }
6073
6074           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
6075
6076           /* Relocate against local STT_GNU_IFUNC symbol.  */
6077           if (!bfd_link_relocatable (info)
6078               && ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC)
6079             {
6080               h = elfNN_aarch64_get_local_sym_hash (globals, input_bfd,
6081                                                     rel, FALSE);
6082               if (h == NULL)
6083                 abort ();
6084
6085               /* Set STT_GNU_IFUNC symbol value.  */
6086               h->root.u.def.value = sym->st_value;
6087               h->root.u.def.section = sec;
6088             }
6089         }
6090       else
6091         {
6092           bfd_boolean warned, ignored;
6093
6094           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
6095                                    r_symndx, symtab_hdr, sym_hashes,
6096                                    h, sec, relocation,
6097                                    unresolved_reloc, warned, ignored);
6098
6099           sym_type = h->type;
6100         }
6101
6102       if (sec != NULL && discarded_section (sec))
6103         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
6104                                          rel, 1, relend, howto, 0, contents);
6105
6106       if (bfd_link_relocatable (info))
6107         continue;
6108
6109       if (h != NULL)
6110         name = h->root.root.string;
6111       else
6112         {
6113           name = (bfd_elf_string_from_elf_section
6114                   (input_bfd, symtab_hdr->sh_link, sym->st_name));
6115           if (name == NULL || *name == '\0')
6116             name = bfd_section_name (input_bfd, sec);
6117         }
6118
6119       if (r_symndx != 0
6120           && r_type != R_AARCH64_NONE
6121           && r_type != R_AARCH64_NULL
6122           && (h == NULL
6123               || h->root.type == bfd_link_hash_defined
6124               || h->root.type == bfd_link_hash_defweak)
6125           && IS_AARCH64_TLS_RELOC (bfd_r_type) != (sym_type == STT_TLS))
6126         {
6127           (*_bfd_error_handler)
6128             ((sym_type == STT_TLS
6129               ? _("%B(%A+0x%lx): %s used with TLS symbol %s")
6130               : _("%B(%A+0x%lx): %s used with non-TLS symbol %s")),
6131              input_bfd,
6132              input_section, (long) rel->r_offset, howto->name, name);
6133         }
6134
6135       /* We relax only if we can see that there can be a valid transition
6136          from a reloc type to another.
6137          We call elfNN_aarch64_final_link_relocate unless we're completely
6138          done, i.e., the relaxation produced the final output we want.  */
6139
6140       relaxed_bfd_r_type = aarch64_tls_transition (input_bfd, info, r_type,
6141                                                    h, r_symndx);
6142       if (relaxed_bfd_r_type != bfd_r_type)
6143         {
6144           bfd_r_type = relaxed_bfd_r_type;
6145           howto = elfNN_aarch64_howto_from_bfd_reloc (bfd_r_type);
6146           BFD_ASSERT (howto != NULL);
6147           r_type = howto->type;
6148           r = elfNN_aarch64_tls_relax (globals, input_bfd, contents, rel, h);
6149           unresolved_reloc = 0;
6150         }
6151       else
6152         r = bfd_reloc_continue;
6153
6154       /* There may be multiple consecutive relocations for the
6155          same offset.  In that case we are supposed to treat the
6156          output of each relocation as the addend for the next.  */
6157       if (rel + 1 < relend
6158           && rel->r_offset == rel[1].r_offset
6159           && ELFNN_R_TYPE (rel[1].r_info) != R_AARCH64_NONE
6160           && ELFNN_R_TYPE (rel[1].r_info) != R_AARCH64_NULL)
6161         save_addend = TRUE;
6162       else
6163         save_addend = FALSE;
6164
6165       if (r == bfd_reloc_continue)
6166         r = elfNN_aarch64_final_link_relocate (howto, input_bfd, output_bfd,
6167                                                input_section, contents, rel,
6168                                                relocation, info, sec,
6169                                                h, &unresolved_reloc,
6170                                                save_addend, &addend, sym);
6171
6172       switch (elfNN_aarch64_bfd_reloc_from_type (r_type))
6173         {
6174         case BFD_RELOC_AARCH64_TLSGD_ADD_LO12_NC:
6175         case BFD_RELOC_AARCH64_TLSGD_ADR_PAGE21:
6176         case BFD_RELOC_AARCH64_TLSGD_ADR_PREL21:
6177         case BFD_RELOC_AARCH64_TLSGD_MOVW_G0_NC:
6178         case BFD_RELOC_AARCH64_TLSGD_MOVW_G1:
6179         case BFD_RELOC_AARCH64_TLSLD_ADD_LO12_NC:
6180         case BFD_RELOC_AARCH64_TLSLD_ADR_PAGE21:
6181         case BFD_RELOC_AARCH64_TLSLD_ADR_PREL21:
6182           if (! symbol_got_offset_mark_p (input_bfd, h, r_symndx))
6183             {
6184               bfd_boolean need_relocs = FALSE;
6185               bfd_byte *loc;
6186               int indx;
6187               bfd_vma off;
6188
6189               off = symbol_got_offset (input_bfd, h, r_symndx);
6190               indx = h && h->dynindx != -1 ? h->dynindx : 0;
6191
6192               need_relocs =
6193                 (bfd_link_pic (info) || indx != 0) &&
6194                 (h == NULL
6195                  || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
6196                  || h->root.type != bfd_link_hash_undefweak);
6197
6198               BFD_ASSERT (globals->root.srelgot != NULL);
6199
6200               if (need_relocs)
6201                 {
6202                   Elf_Internal_Rela rela;
6203                   rela.r_info = ELFNN_R_INFO (indx, AARCH64_R (TLS_DTPMOD));
6204                   rela.r_addend = 0;
6205                   rela.r_offset = globals->root.sgot->output_section->vma +
6206                     globals->root.sgot->output_offset + off;
6207
6208
6209                   loc = globals->root.srelgot->contents;
6210                   loc += globals->root.srelgot->reloc_count++
6211                     * RELOC_SIZE (htab);
6212                   bfd_elfNN_swap_reloca_out (output_bfd, &rela, loc);
6213
6214                   bfd_reloc_code_real_type real_type =
6215                     elfNN_aarch64_bfd_reloc_from_type (r_type);
6216
6217                   if (real_type == BFD_RELOC_AARCH64_TLSLD_ADR_PREL21
6218                       || real_type == BFD_RELOC_AARCH64_TLSLD_ADR_PAGE21
6219                       || real_type == BFD_RELOC_AARCH64_TLSLD_ADD_LO12_NC)
6220                     {
6221                       /* For local dynamic, don't generate DTPREL in any case.
6222                          Initialize the DTPREL slot into zero, so we get module
6223                          base address when invoke runtime TLS resolver.  */
6224                       bfd_put_NN (output_bfd, 0,
6225                                   globals->root.sgot->contents + off
6226                                   + GOT_ENTRY_SIZE);
6227                     }
6228                   else if (indx == 0)
6229                     {
6230                       bfd_put_NN (output_bfd,
6231                                   relocation - dtpoff_base (info),
6232                                   globals->root.sgot->contents + off
6233                                   + GOT_ENTRY_SIZE);
6234                     }
6235                   else
6236                     {
6237                       /* This TLS symbol is global. We emit a
6238                          relocation to fixup the tls offset at load
6239                          time.  */
6240                       rela.r_info =
6241                         ELFNN_R_INFO (indx, AARCH64_R (TLS_DTPREL));
6242                       rela.r_addend = 0;
6243                       rela.r_offset =
6244                         (globals->root.sgot->output_section->vma
6245                          + globals->root.sgot->output_offset + off
6246                          + GOT_ENTRY_SIZE);
6247
6248                       loc = globals->root.srelgot->contents;
6249                       loc += globals->root.srelgot->reloc_count++
6250                         * RELOC_SIZE (globals);
6251                       bfd_elfNN_swap_reloca_out (output_bfd, &rela, loc);
6252                       bfd_put_NN (output_bfd, (bfd_vma) 0,
6253                                   globals->root.sgot->contents + off
6254                                   + GOT_ENTRY_SIZE);
6255                     }
6256                 }
6257               else
6258                 {
6259                   bfd_put_NN (output_bfd, (bfd_vma) 1,
6260                               globals->root.sgot->contents + off);
6261                   bfd_put_NN (output_bfd,
6262                               relocation - dtpoff_base (info),
6263                               globals->root.sgot->contents + off
6264                               + GOT_ENTRY_SIZE);
6265                 }
6266
6267               symbol_got_offset_mark (input_bfd, h, r_symndx);
6268             }
6269           break;
6270
6271         case BFD_RELOC_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21:
6272         case BFD_RELOC_AARCH64_TLSIE_LDNN_GOTTPREL_LO12_NC:
6273         case BFD_RELOC_AARCH64_TLSIE_LD_GOTTPREL_PREL19:
6274         case BFD_RELOC_AARCH64_TLSIE_MOVW_GOTTPREL_G0_NC:
6275         case BFD_RELOC_AARCH64_TLSIE_MOVW_GOTTPREL_G1:
6276           if (! symbol_got_offset_mark_p (input_bfd, h, r_symndx))
6277             {
6278               bfd_boolean need_relocs = FALSE;
6279               bfd_byte *loc;
6280               int indx;
6281               bfd_vma off;
6282
6283               off = symbol_got_offset (input_bfd, h, r_symndx);
6284
6285               indx = h && h->dynindx != -1 ? h->dynindx : 0;
6286
6287               need_relocs =
6288                 (bfd_link_pic (info) || indx != 0) &&
6289                 (h == NULL
6290                  || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
6291                  || h->root.type != bfd_link_hash_undefweak);
6292
6293               BFD_ASSERT (globals->root.srelgot != NULL);
6294
6295               if (need_relocs)
6296                 {
6297                   Elf_Internal_Rela rela;
6298
6299                   if (indx == 0)
6300                     rela.r_addend = relocation - dtpoff_base (info);
6301                   else
6302                     rela.r_addend = 0;
6303
6304                   rela.r_info = ELFNN_R_INFO (indx, AARCH64_R (TLS_TPREL));
6305                   rela.r_offset = globals->root.sgot->output_section->vma +
6306                     globals->root.sgot->output_offset + off;
6307
6308                   loc = globals->root.srelgot->contents;
6309                   loc += globals->root.srelgot->reloc_count++
6310                     * RELOC_SIZE (htab);
6311
6312                   bfd_elfNN_swap_reloca_out (output_bfd, &rela, loc);
6313
6314                   bfd_put_NN (output_bfd, rela.r_addend,
6315                               globals->root.sgot->contents + off);
6316                 }
6317               else
6318                 bfd_put_NN (output_bfd, relocation - tpoff_base (info),
6319                             globals->root.sgot->contents + off);
6320
6321               symbol_got_offset_mark (input_bfd, h, r_symndx);
6322             }
6323           break;
6324
6325         case BFD_RELOC_AARCH64_TLSDESC_ADD_LO12_NC:
6326         case BFD_RELOC_AARCH64_TLSDESC_ADR_PAGE21:
6327         case BFD_RELOC_AARCH64_TLSDESC_ADR_PREL21:
6328         case BFD_RELOC_AARCH64_TLSDESC_LDNN_LO12_NC:
6329         case BFD_RELOC_AARCH64_TLSDESC_LD_PREL19:
6330         case BFD_RELOC_AARCH64_TLSDESC_OFF_G0_NC:
6331         case BFD_RELOC_AARCH64_TLSDESC_OFF_G1:
6332           if (! symbol_tlsdesc_got_offset_mark_p (input_bfd, h, r_symndx))
6333             {
6334               bfd_boolean need_relocs = FALSE;
6335               int indx = h && h->dynindx != -1 ? h->dynindx : 0;
6336               bfd_vma off = symbol_tlsdesc_got_offset (input_bfd, h, r_symndx);
6337
6338               need_relocs = (h == NULL
6339                              || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
6340                              || h->root.type != bfd_link_hash_undefweak);
6341
6342               BFD_ASSERT (globals->root.srelgot != NULL);
6343               BFD_ASSERT (globals->root.sgot != NULL);
6344
6345               if (need_relocs)
6346                 {
6347                   bfd_byte *loc;
6348                   Elf_Internal_Rela rela;
6349                   rela.r_info = ELFNN_R_INFO (indx, AARCH64_R (TLSDESC));
6350
6351                   rela.r_addend = 0;
6352                   rela.r_offset = (globals->root.sgotplt->output_section->vma
6353                                    + globals->root.sgotplt->output_offset
6354                                    + off + globals->sgotplt_jump_table_size);
6355
6356                   if (indx == 0)
6357                     rela.r_addend = relocation - dtpoff_base (info);
6358
6359                   /* Allocate the next available slot in the PLT reloc
6360                      section to hold our R_AARCH64_TLSDESC, the next
6361                      available slot is determined from reloc_count,
6362                      which we step. But note, reloc_count was
6363                      artifically moved down while allocating slots for
6364                      real PLT relocs such that all of the PLT relocs
6365                      will fit above the initial reloc_count and the
6366                      extra stuff will fit below.  */
6367                   loc = globals->root.srelplt->contents;
6368                   loc += globals->root.srelplt->reloc_count++
6369                     * RELOC_SIZE (globals);
6370
6371                   bfd_elfNN_swap_reloca_out (output_bfd, &rela, loc);
6372
6373                   bfd_put_NN (output_bfd, (bfd_vma) 0,
6374                               globals->root.sgotplt->contents + off +
6375                               globals->sgotplt_jump_table_size);
6376                   bfd_put_NN (output_bfd, (bfd_vma) 0,
6377                               globals->root.sgotplt->contents + off +
6378                               globals->sgotplt_jump_table_size +
6379                               GOT_ENTRY_SIZE);
6380                 }
6381
6382               symbol_tlsdesc_got_offset_mark (input_bfd, h, r_symndx);
6383             }
6384           break;
6385         default:
6386           break;
6387         }
6388
6389       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
6390          because such sections are not SEC_ALLOC and thus ld.so will
6391          not process them.  */
6392       if (unresolved_reloc
6393           && !((input_section->flags & SEC_DEBUGGING) != 0
6394                && h->def_dynamic)
6395           && _bfd_elf_section_offset (output_bfd, info, input_section,
6396                                       +rel->r_offset) != (bfd_vma) - 1)
6397         {
6398           (*_bfd_error_handler)
6399             (_
6400              ("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
6401              input_bfd, input_section, (long) rel->r_offset, howto->name,
6402              h->root.root.string);
6403           return FALSE;
6404         }
6405
6406       if (r != bfd_reloc_ok && r != bfd_reloc_continue)
6407         {
6408           bfd_reloc_code_real_type real_r_type
6409             = elfNN_aarch64_bfd_reloc_from_type (r_type);
6410
6411           switch (r)
6412             {
6413             case bfd_reloc_overflow:
6414               if (!(*info->callbacks->reloc_overflow)
6415                   (info, (h ? &h->root : NULL), name, howto->name, (bfd_vma) 0,
6416                    input_bfd, input_section, rel->r_offset))
6417                 return FALSE;
6418               if (real_r_type == BFD_RELOC_AARCH64_LD64_GOTPAGE_LO15
6419                   || real_r_type == BFD_RELOC_AARCH64_LD32_GOTPAGE_LO14)
6420                 {
6421                   (*info->callbacks->warning)
6422                     (info,
6423                      _("Too many GOT entries for -fpic, "
6424                        "please recompile with -fPIC"),
6425                      name, input_bfd, input_section, rel->r_offset);
6426                   return FALSE;
6427                 }
6428               /* Overflow can occur when a variable is referenced with a type
6429                  that has a larger alignment than the type with which it was
6430                  declared. eg:
6431                    file1.c: extern int foo; int a (void) { return foo; }
6432                    file2.c: char bar, foo, baz;
6433                  If the variable is placed into a data section at an offset
6434                  that is incompatible with the larger alignment requirement
6435                  overflow will occur.  (Strictly speaking this is not overflow
6436                  but rather an alignment problem, but the bfd_reloc_ error
6437                  enum does not have a value to cover that situation).
6438
6439                  Try to catch this situation here and provide a more helpful
6440                  error message to the user.  */
6441               if (addend & ((1 << howto->rightshift) - 1)
6442                   /* FIXME: Are we testing all of the appropriate reloc
6443                      types here ?  */
6444                   && (real_r_type == BFD_RELOC_AARCH64_LD_LO19_PCREL
6445                       || real_r_type == BFD_RELOC_AARCH64_LDST16_LO12
6446                       || real_r_type == BFD_RELOC_AARCH64_LDST32_LO12
6447                       || real_r_type == BFD_RELOC_AARCH64_LDST64_LO12
6448                       || real_r_type == BFD_RELOC_AARCH64_LDST128_LO12))
6449                 {
6450                   info->callbacks->warning
6451                     (info, _("One possible cause of this error is that the \
6452 symbol is being referenced in the indicated code as if it had a larger \
6453 alignment than was declared where it was defined."),
6454                      name, input_bfd, input_section, rel->r_offset);
6455                 }
6456               break;
6457
6458             case bfd_reloc_undefined:
6459               if (!((*info->callbacks->undefined_symbol)
6460                     (info, name, input_bfd, input_section,
6461                      rel->r_offset, TRUE)))
6462                 return FALSE;
6463               break;
6464
6465             case bfd_reloc_outofrange:
6466               error_message = _("out of range");
6467               goto common_error;
6468
6469             case bfd_reloc_notsupported:
6470               error_message = _("unsupported relocation");
6471               goto common_error;
6472
6473             case bfd_reloc_dangerous:
6474               /* error_message should already be set.  */
6475               goto common_error;
6476
6477             default:
6478               error_message = _("unknown error");
6479               /* Fall through.  */
6480
6481             common_error:
6482               BFD_ASSERT (error_message != NULL);
6483               if (!((*info->callbacks->reloc_dangerous)
6484                     (info, error_message, input_bfd, input_section,
6485                      rel->r_offset)))
6486                 return FALSE;
6487               break;
6488             }
6489         }
6490
6491       if (!save_addend)
6492         addend = 0;
6493     }
6494
6495   return TRUE;
6496 }
6497
6498 /* Set the right machine number.  */
6499
6500 static bfd_boolean
6501 elfNN_aarch64_object_p (bfd *abfd)
6502 {
6503 #if ARCH_SIZE == 32
6504   bfd_default_set_arch_mach (abfd, bfd_arch_aarch64, bfd_mach_aarch64_ilp32);
6505 #else
6506   bfd_default_set_arch_mach (abfd, bfd_arch_aarch64, bfd_mach_aarch64);
6507 #endif
6508   return TRUE;
6509 }
6510
6511 /* Function to keep AArch64 specific flags in the ELF header.  */
6512
6513 static bfd_boolean
6514 elfNN_aarch64_set_private_flags (bfd *abfd, flagword flags)
6515 {
6516   if (elf_flags_init (abfd) && elf_elfheader (abfd)->e_flags != flags)
6517     {
6518     }
6519   else
6520     {
6521       elf_elfheader (abfd)->e_flags = flags;
6522       elf_flags_init (abfd) = TRUE;
6523     }
6524
6525   return TRUE;
6526 }
6527
6528 /* Merge backend specific data from an object file to the output
6529    object file when linking.  */
6530
6531 static bfd_boolean
6532 elfNN_aarch64_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
6533 {
6534   flagword out_flags;
6535   flagword in_flags;
6536   bfd_boolean flags_compatible = TRUE;
6537   asection *sec;
6538
6539   /* Check if we have the same endianess.  */
6540   if (!_bfd_generic_verify_endian_match (ibfd, obfd))
6541     return FALSE;
6542
6543   if (!is_aarch64_elf (ibfd) || !is_aarch64_elf (obfd))
6544     return TRUE;
6545
6546   /* The input BFD must have had its flags initialised.  */
6547   /* The following seems bogus to me -- The flags are initialized in
6548      the assembler but I don't think an elf_flags_init field is
6549      written into the object.  */
6550   /* BFD_ASSERT (elf_flags_init (ibfd)); */
6551
6552   in_flags = elf_elfheader (ibfd)->e_flags;
6553   out_flags = elf_elfheader (obfd)->e_flags;
6554
6555   if (!elf_flags_init (obfd))
6556     {
6557       /* If the input is the default architecture and had the default
6558          flags then do not bother setting the flags for the output
6559          architecture, instead allow future merges to do this.  If no
6560          future merges ever set these flags then they will retain their
6561          uninitialised values, which surprise surprise, correspond
6562          to the default values.  */
6563       if (bfd_get_arch_info (ibfd)->the_default
6564           && elf_elfheader (ibfd)->e_flags == 0)
6565         return TRUE;
6566
6567       elf_flags_init (obfd) = TRUE;
6568       elf_elfheader (obfd)->e_flags = in_flags;
6569
6570       if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
6571           && bfd_get_arch_info (obfd)->the_default)
6572         return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
6573                                   bfd_get_mach (ibfd));
6574
6575       return TRUE;
6576     }
6577
6578   /* Identical flags must be compatible.  */
6579   if (in_flags == out_flags)
6580     return TRUE;
6581
6582   /* Check to see if the input BFD actually contains any sections.  If
6583      not, its flags may not have been initialised either, but it
6584      cannot actually cause any incompatiblity.  Do not short-circuit
6585      dynamic objects; their section list may be emptied by
6586      elf_link_add_object_symbols.
6587
6588      Also check to see if there are no code sections in the input.
6589      In this case there is no need to check for code specific flags.
6590      XXX - do we need to worry about floating-point format compatability
6591      in data sections ?  */
6592   if (!(ibfd->flags & DYNAMIC))
6593     {
6594       bfd_boolean null_input_bfd = TRUE;
6595       bfd_boolean only_data_sections = TRUE;
6596
6597       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
6598         {
6599           if ((bfd_get_section_flags (ibfd, sec)
6600                & (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS))
6601               == (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS))
6602             only_data_sections = FALSE;
6603
6604           null_input_bfd = FALSE;
6605           break;
6606         }
6607
6608       if (null_input_bfd || only_data_sections)
6609         return TRUE;
6610     }
6611
6612   return flags_compatible;
6613 }
6614
6615 /* Display the flags field.  */
6616
6617 static bfd_boolean
6618 elfNN_aarch64_print_private_bfd_data (bfd *abfd, void *ptr)
6619 {
6620   FILE *file = (FILE *) ptr;
6621   unsigned long flags;
6622
6623   BFD_ASSERT (abfd != NULL && ptr != NULL);
6624
6625   /* Print normal ELF private data.  */
6626   _bfd_elf_print_private_bfd_data (abfd, ptr);
6627
6628   flags = elf_elfheader (abfd)->e_flags;
6629   /* Ignore init flag - it may not be set, despite the flags field
6630      containing valid data.  */
6631
6632   /* xgettext:c-format */
6633   fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
6634
6635   if (flags)
6636     fprintf (file, _("<Unrecognised flag bits set>"));
6637
6638   fputc ('\n', file);
6639
6640   return TRUE;
6641 }
6642
6643 /* Update the got entry reference counts for the section being removed.  */
6644
6645 static bfd_boolean
6646 elfNN_aarch64_gc_sweep_hook (bfd *abfd,
6647                              struct bfd_link_info *info,
6648                              asection *sec,
6649                              const Elf_Internal_Rela * relocs)
6650 {
6651   struct elf_aarch64_link_hash_table *htab;
6652   Elf_Internal_Shdr *symtab_hdr;
6653   struct elf_link_hash_entry **sym_hashes;
6654   struct elf_aarch64_local_symbol *locals;
6655   const Elf_Internal_Rela *rel, *relend;
6656
6657   if (bfd_link_relocatable (info))
6658     return TRUE;
6659
6660   htab = elf_aarch64_hash_table (info);
6661
6662   if (htab == NULL)
6663     return FALSE;
6664
6665   elf_section_data (sec)->local_dynrel = NULL;
6666
6667   symtab_hdr = &elf_symtab_hdr (abfd);
6668   sym_hashes = elf_sym_hashes (abfd);
6669
6670   locals = elf_aarch64_locals (abfd);
6671
6672   relend = relocs + sec->reloc_count;
6673   for (rel = relocs; rel < relend; rel++)
6674     {
6675       unsigned long r_symndx;
6676       unsigned int r_type;
6677       struct elf_link_hash_entry *h = NULL;
6678
6679       r_symndx = ELFNN_R_SYM (rel->r_info);
6680
6681       if (r_symndx >= symtab_hdr->sh_info)
6682         {
6683
6684           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6685           while (h->root.type == bfd_link_hash_indirect
6686                  || h->root.type == bfd_link_hash_warning)
6687             h = (struct elf_link_hash_entry *) h->root.u.i.link;
6688         }
6689       else
6690         {
6691           Elf_Internal_Sym *isym;
6692
6693           /* A local symbol.  */
6694           isym = bfd_sym_from_r_symndx (&htab->sym_cache,
6695                                         abfd, r_symndx);
6696
6697           /* Check relocation against local STT_GNU_IFUNC symbol.  */
6698           if (isym != NULL
6699               && ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
6700             {
6701               h = elfNN_aarch64_get_local_sym_hash (htab, abfd, rel, FALSE);
6702               if (h == NULL)
6703                 abort ();
6704             }
6705         }
6706
6707       if (h)
6708         {
6709           struct elf_aarch64_link_hash_entry *eh;
6710           struct elf_dyn_relocs **pp;
6711           struct elf_dyn_relocs *p;
6712
6713           eh = (struct elf_aarch64_link_hash_entry *) h;
6714
6715           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
6716             if (p->sec == sec)
6717               {
6718                 /* Everything must go for SEC.  */
6719                 *pp = p->next;
6720                 break;
6721               }
6722         }
6723
6724       r_type = ELFNN_R_TYPE (rel->r_info);
6725       switch (aarch64_tls_transition (abfd,info, r_type, h ,r_symndx))
6726         {
6727         case BFD_RELOC_AARCH64_ADR_GOT_PAGE:
6728         case BFD_RELOC_AARCH64_GOT_LD_PREL19:
6729         case BFD_RELOC_AARCH64_LD32_GOTPAGE_LO14:
6730         case BFD_RELOC_AARCH64_LD32_GOT_LO12_NC:
6731         case BFD_RELOC_AARCH64_LD64_GOTOFF_LO15:
6732         case BFD_RELOC_AARCH64_LD64_GOTPAGE_LO15:
6733         case BFD_RELOC_AARCH64_LD64_GOT_LO12_NC:
6734         case BFD_RELOC_AARCH64_MOVW_GOTOFF_G0_NC:
6735         case BFD_RELOC_AARCH64_MOVW_GOTOFF_G1:
6736         case BFD_RELOC_AARCH64_TLSDESC_ADD_LO12_NC:
6737         case BFD_RELOC_AARCH64_TLSDESC_ADR_PAGE21:
6738         case BFD_RELOC_AARCH64_TLSDESC_ADR_PREL21:
6739         case BFD_RELOC_AARCH64_TLSDESC_LD32_LO12_NC:
6740         case BFD_RELOC_AARCH64_TLSDESC_LD64_LO12_NC:
6741         case BFD_RELOC_AARCH64_TLSDESC_LD_PREL19:
6742         case BFD_RELOC_AARCH64_TLSDESC_OFF_G0_NC:
6743         case BFD_RELOC_AARCH64_TLSDESC_OFF_G1:
6744         case BFD_RELOC_AARCH64_TLSGD_ADD_LO12_NC:
6745         case BFD_RELOC_AARCH64_TLSGD_ADR_PAGE21:
6746         case BFD_RELOC_AARCH64_TLSGD_ADR_PREL21:
6747         case BFD_RELOC_AARCH64_TLSGD_MOVW_G0_NC:
6748         case BFD_RELOC_AARCH64_TLSGD_MOVW_G1:
6749         case BFD_RELOC_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21:
6750         case BFD_RELOC_AARCH64_TLSIE_LD32_GOTTPREL_LO12_NC:
6751         case BFD_RELOC_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC:
6752         case BFD_RELOC_AARCH64_TLSIE_LD_GOTTPREL_PREL19:
6753         case BFD_RELOC_AARCH64_TLSIE_MOVW_GOTTPREL_G0_NC:
6754         case BFD_RELOC_AARCH64_TLSIE_MOVW_GOTTPREL_G1:
6755         case BFD_RELOC_AARCH64_TLSLD_ADD_LO12_NC:
6756         case BFD_RELOC_AARCH64_TLSLD_ADR_PAGE21:
6757         case BFD_RELOC_AARCH64_TLSLD_ADR_PREL21:
6758           if (h != NULL)
6759             {
6760               if (h->got.refcount > 0)
6761                 h->got.refcount -= 1;
6762
6763               if (h->type == STT_GNU_IFUNC)
6764                 {
6765                   if (h->plt.refcount > 0)
6766                     h->plt.refcount -= 1;
6767                 }
6768             }
6769           else if (locals != NULL)
6770             {
6771               if (locals[r_symndx].got_refcount > 0)
6772                 locals[r_symndx].got_refcount -= 1;
6773             }
6774           break;
6775
6776         case BFD_RELOC_AARCH64_CALL26:
6777         case BFD_RELOC_AARCH64_JUMP26:
6778           /* If this is a local symbol then we resolve it
6779              directly without creating a PLT entry.  */
6780           if (h == NULL)
6781             continue;
6782
6783           if (h->plt.refcount > 0)
6784             h->plt.refcount -= 1;
6785           break;
6786
6787         case BFD_RELOC_AARCH64_ADR_HI21_NC_PCREL:
6788         case BFD_RELOC_AARCH64_ADR_HI21_PCREL:
6789         case BFD_RELOC_AARCH64_ADR_LO21_PCREL:
6790         case BFD_RELOC_AARCH64_MOVW_G0_NC:
6791         case BFD_RELOC_AARCH64_MOVW_G1_NC:
6792         case BFD_RELOC_AARCH64_MOVW_G2_NC:
6793         case BFD_RELOC_AARCH64_MOVW_G3:
6794         case BFD_RELOC_AARCH64_NN:
6795           if (h != NULL && bfd_link_executable (info))
6796             {
6797               if (h->plt.refcount > 0)
6798                 h->plt.refcount -= 1;
6799             }
6800           break;
6801
6802         default:
6803           break;
6804         }
6805     }
6806
6807   return TRUE;
6808 }
6809
6810 /* Adjust a symbol defined by a dynamic object and referenced by a
6811    regular object.  The current definition is in some section of the
6812    dynamic object, but we're not including those sections.  We have to
6813    change the definition to something the rest of the link can
6814    understand.  */
6815
6816 static bfd_boolean
6817 elfNN_aarch64_adjust_dynamic_symbol (struct bfd_link_info *info,
6818                                      struct elf_link_hash_entry *h)
6819 {
6820   struct elf_aarch64_link_hash_table *htab;
6821   asection *s;
6822
6823   /* If this is a function, put it in the procedure linkage table.  We
6824      will fill in the contents of the procedure linkage table later,
6825      when we know the address of the .got section.  */
6826   if (h->type == STT_FUNC || h->type == STT_GNU_IFUNC || h->needs_plt)
6827     {
6828       if (h->plt.refcount <= 0
6829           || (h->type != STT_GNU_IFUNC
6830               && (SYMBOL_CALLS_LOCAL (info, h)
6831                   || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
6832                       && h->root.type == bfd_link_hash_undefweak))))
6833         {
6834           /* This case can occur if we saw a CALL26 reloc in
6835              an input file, but the symbol wasn't referred to
6836              by a dynamic object or all references were
6837              garbage collected. In which case we can end up
6838              resolving.  */
6839           h->plt.offset = (bfd_vma) - 1;
6840           h->needs_plt = 0;
6841         }
6842
6843       return TRUE;
6844     }
6845   else
6846     /* Otherwise, reset to -1.  */
6847     h->plt.offset = (bfd_vma) - 1;
6848
6849
6850   /* If this is a weak symbol, and there is a real definition, the
6851      processor independent code will have arranged for us to see the
6852      real definition first, and we can just use the same value.  */
6853   if (h->u.weakdef != NULL)
6854     {
6855       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
6856                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
6857       h->root.u.def.section = h->u.weakdef->root.u.def.section;
6858       h->root.u.def.value = h->u.weakdef->root.u.def.value;
6859       if (ELIMINATE_COPY_RELOCS || info->nocopyreloc)
6860         h->non_got_ref = h->u.weakdef->non_got_ref;
6861       return TRUE;
6862     }
6863
6864   /* If we are creating a shared library, we must presume that the
6865      only references to the symbol are via the global offset table.
6866      For such cases we need not do anything here; the relocations will
6867      be handled correctly by relocate_section.  */
6868   if (bfd_link_pic (info))
6869     return TRUE;
6870
6871   /* If there are no references to this symbol that do not use the
6872      GOT, we don't need to generate a copy reloc.  */
6873   if (!h->non_got_ref)
6874     return TRUE;
6875
6876   /* If -z nocopyreloc was given, we won't generate them either.  */
6877   if (info->nocopyreloc)
6878     {
6879       h->non_got_ref = 0;
6880       return TRUE;
6881     }
6882
6883   /* We must allocate the symbol in our .dynbss section, which will
6884      become part of the .bss section of the executable.  There will be
6885      an entry for this symbol in the .dynsym section.  The dynamic
6886      object will contain position independent code, so all references
6887      from the dynamic object to this symbol will go through the global
6888      offset table.  The dynamic linker will use the .dynsym entry to
6889      determine the address it must put in the global offset table, so
6890      both the dynamic object and the regular object will refer to the
6891      same memory location for the variable.  */
6892
6893   htab = elf_aarch64_hash_table (info);
6894
6895   /* We must generate a R_AARCH64_COPY reloc to tell the dynamic linker
6896      to copy the initial value out of the dynamic object and into the
6897      runtime process image.  */
6898   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
6899     {
6900       htab->srelbss->size += RELOC_SIZE (htab);
6901       h->needs_copy = 1;
6902     }
6903
6904   s = htab->sdynbss;
6905
6906   return _bfd_elf_adjust_dynamic_copy (info, h, s);
6907
6908 }
6909
6910 static bfd_boolean
6911 elfNN_aarch64_allocate_local_symbols (bfd *abfd, unsigned number)
6912 {
6913   struct elf_aarch64_local_symbol *locals;
6914   locals = elf_aarch64_locals (abfd);
6915   if (locals == NULL)
6916     {
6917       locals = (struct elf_aarch64_local_symbol *)
6918         bfd_zalloc (abfd, number * sizeof (struct elf_aarch64_local_symbol));
6919       if (locals == NULL)
6920         return FALSE;
6921       elf_aarch64_locals (abfd) = locals;
6922     }
6923   return TRUE;
6924 }
6925
6926 /* Create the .got section to hold the global offset table.  */
6927
6928 static bfd_boolean
6929 aarch64_elf_create_got_section (bfd *abfd, struct bfd_link_info *info)
6930 {
6931   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
6932   flagword flags;
6933   asection *s;
6934   struct elf_link_hash_entry *h;
6935   struct elf_link_hash_table *htab = elf_hash_table (info);
6936
6937   /* This function may be called more than once.  */
6938   s = bfd_get_linker_section (abfd, ".got");
6939   if (s != NULL)
6940     return TRUE;
6941
6942   flags = bed->dynamic_sec_flags;
6943
6944   s = bfd_make_section_anyway_with_flags (abfd,
6945                                           (bed->rela_plts_and_copies_p
6946                                            ? ".rela.got" : ".rel.got"),
6947                                           (bed->dynamic_sec_flags
6948                                            | SEC_READONLY));
6949   if (s == NULL
6950       || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
6951     return FALSE;
6952   htab->srelgot = s;
6953
6954   s = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
6955   if (s == NULL
6956       || !bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
6957     return FALSE;
6958   htab->sgot = s;
6959   htab->sgot->size += GOT_ENTRY_SIZE;
6960
6961   if (bed->want_got_sym)
6962     {
6963       /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
6964          (or .got.plt) section.  We don't do this in the linker script
6965          because we don't want to define the symbol if we are not creating
6966          a global offset table.  */
6967       h = _bfd_elf_define_linkage_sym (abfd, info, s,
6968                                        "_GLOBAL_OFFSET_TABLE_");
6969       elf_hash_table (info)->hgot = h;
6970       if (h == NULL)
6971         return FALSE;
6972     }
6973
6974   if (bed->want_got_plt)
6975     {
6976       s = bfd_make_section_anyway_with_flags (abfd, ".got.plt", flags);
6977       if (s == NULL
6978           || !bfd_set_section_alignment (abfd, s,
6979                                          bed->s->log_file_align))
6980         return FALSE;
6981       htab->sgotplt = s;
6982     }
6983
6984   /* The first bit of the global offset table is the header.  */
6985   s->size += bed->got_header_size;
6986
6987   return TRUE;
6988 }
6989
6990 /* Look through the relocs for a section during the first phase.  */
6991
6992 static bfd_boolean
6993 elfNN_aarch64_check_relocs (bfd *abfd, struct bfd_link_info *info,
6994                             asection *sec, const Elf_Internal_Rela *relocs)
6995 {
6996   Elf_Internal_Shdr *symtab_hdr;
6997   struct elf_link_hash_entry **sym_hashes;
6998   const Elf_Internal_Rela *rel;
6999   const Elf_Internal_Rela *rel_end;
7000   asection *sreloc;
7001
7002   struct elf_aarch64_link_hash_table *htab;
7003
7004   if (bfd_link_relocatable (info))
7005     return TRUE;
7006
7007   BFD_ASSERT (is_aarch64_elf (abfd));
7008
7009   htab = elf_aarch64_hash_table (info);
7010   sreloc = NULL;
7011
7012   symtab_hdr = &elf_symtab_hdr (abfd);
7013   sym_hashes = elf_sym_hashes (abfd);
7014
7015   rel_end = relocs + sec->reloc_count;
7016   for (rel = relocs; rel < rel_end; rel++)
7017     {
7018       struct elf_link_hash_entry *h;
7019       unsigned long r_symndx;
7020       unsigned int r_type;
7021       bfd_reloc_code_real_type bfd_r_type;
7022       Elf_Internal_Sym *isym;
7023
7024       r_symndx = ELFNN_R_SYM (rel->r_info);
7025       r_type = ELFNN_R_TYPE (rel->r_info);
7026
7027       if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
7028         {
7029           (*_bfd_error_handler) (_("%B: bad symbol index: %d"), abfd,
7030                                  r_symndx);
7031           return FALSE;
7032         }
7033
7034       if (r_symndx < symtab_hdr->sh_info)
7035         {
7036           /* A local symbol.  */
7037           isym = bfd_sym_from_r_symndx (&htab->sym_cache,
7038                                         abfd, r_symndx);
7039           if (isym == NULL)
7040             return FALSE;
7041
7042           /* Check relocation against local STT_GNU_IFUNC symbol.  */
7043           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
7044             {
7045               h = elfNN_aarch64_get_local_sym_hash (htab, abfd, rel,
7046                                                     TRUE);
7047               if (h == NULL)
7048                 return FALSE;
7049
7050               /* Fake a STT_GNU_IFUNC symbol.  */
7051               h->type = STT_GNU_IFUNC;
7052               h->def_regular = 1;
7053               h->ref_regular = 1;
7054               h->forced_local = 1;
7055               h->root.type = bfd_link_hash_defined;
7056             }
7057           else
7058             h = NULL;
7059         }
7060       else
7061         {
7062           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7063           while (h->root.type == bfd_link_hash_indirect
7064                  || h->root.type == bfd_link_hash_warning)
7065             h = (struct elf_link_hash_entry *) h->root.u.i.link;
7066
7067           /* PR15323, ref flags aren't set for references in the same
7068              object.  */
7069           h->root.non_ir_ref = 1;
7070         }
7071
7072       /* Could be done earlier, if h were already available.  */
7073       bfd_r_type = aarch64_tls_transition (abfd, info, r_type, h, r_symndx);
7074
7075       if (h != NULL)
7076         {
7077           /* If a relocation refers to _GLOBAL_OFFSET_TABLE_, create the .got.
7078              This shows up in particular in an R_AARCH64_PREL64 in large model
7079              when calculating the pc-relative address to .got section which is
7080              used to initialize the gp register.  */
7081           if (h->root.root.string
7082               && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
7083             {
7084               if (htab->root.dynobj == NULL)
7085                 htab->root.dynobj = abfd;
7086
7087               if (! aarch64_elf_create_got_section (htab->root.dynobj, info))
7088                 return FALSE;
7089
7090               BFD_ASSERT (h == htab->root.hgot);
7091             }
7092
7093           /* Create the ifunc sections for static executables.  If we
7094              never see an indirect function symbol nor we are building
7095              a static executable, those sections will be empty and
7096              won't appear in output.  */
7097           switch (bfd_r_type)
7098             {
7099             default:
7100               break;
7101
7102             case BFD_RELOC_AARCH64_ADD_LO12:
7103             case BFD_RELOC_AARCH64_ADR_GOT_PAGE:
7104             case BFD_RELOC_AARCH64_ADR_HI21_PCREL:
7105             case BFD_RELOC_AARCH64_CALL26:
7106             case BFD_RELOC_AARCH64_GOT_LD_PREL19:
7107             case BFD_RELOC_AARCH64_JUMP26:
7108             case BFD_RELOC_AARCH64_LD32_GOTPAGE_LO14:
7109             case BFD_RELOC_AARCH64_LD32_GOT_LO12_NC:
7110             case BFD_RELOC_AARCH64_LD64_GOTOFF_LO15:
7111             case BFD_RELOC_AARCH64_LD64_GOTPAGE_LO15:
7112             case BFD_RELOC_AARCH64_LD64_GOT_LO12_NC:
7113             case BFD_RELOC_AARCH64_MOVW_GOTOFF_G0_NC:
7114             case BFD_RELOC_AARCH64_MOVW_GOTOFF_G1:
7115             case BFD_RELOC_AARCH64_NN:
7116               if (htab->root.dynobj == NULL)
7117                 htab->root.dynobj = abfd;
7118               if (!_bfd_elf_create_ifunc_sections (htab->root.dynobj, info))
7119                 return FALSE;
7120               break;
7121             }
7122
7123           /* It is referenced by a non-shared object. */
7124           h->ref_regular = 1;
7125           h->root.non_ir_ref = 1;
7126         }
7127
7128       switch (bfd_r_type)
7129         {
7130         case BFD_RELOC_AARCH64_NN:
7131
7132           /* We don't need to handle relocs into sections not going into
7133              the "real" output.  */
7134           if ((sec->flags & SEC_ALLOC) == 0)
7135             break;
7136
7137           if (h != NULL)
7138             {
7139               if (!bfd_link_pic (info))
7140                 h->non_got_ref = 1;
7141
7142               h->plt.refcount += 1;
7143               h->pointer_equality_needed = 1;
7144             }
7145
7146           /* No need to do anything if we're not creating a shared
7147              object.  */
7148           if (! bfd_link_pic (info))
7149             break;
7150
7151           {
7152             struct elf_dyn_relocs *p;
7153             struct elf_dyn_relocs **head;
7154
7155             /* We must copy these reloc types into the output file.
7156                Create a reloc section in dynobj and make room for
7157                this reloc.  */
7158             if (sreloc == NULL)
7159               {
7160                 if (htab->root.dynobj == NULL)
7161                   htab->root.dynobj = abfd;
7162
7163                 sreloc = _bfd_elf_make_dynamic_reloc_section
7164                   (sec, htab->root.dynobj, LOG_FILE_ALIGN, abfd, /*rela? */ TRUE);
7165
7166                 if (sreloc == NULL)
7167                   return FALSE;
7168               }
7169
7170             /* If this is a global symbol, we count the number of
7171                relocations we need for this symbol.  */
7172             if (h != NULL)
7173               {
7174                 struct elf_aarch64_link_hash_entry *eh;
7175                 eh = (struct elf_aarch64_link_hash_entry *) h;
7176                 head = &eh->dyn_relocs;
7177               }
7178             else
7179               {
7180                 /* Track dynamic relocs needed for local syms too.
7181                    We really need local syms available to do this
7182                    easily.  Oh well.  */
7183
7184                 asection *s;
7185                 void **vpp;
7186
7187                 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
7188                                               abfd, r_symndx);
7189                 if (isym == NULL)
7190                   return FALSE;
7191
7192                 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
7193                 if (s == NULL)
7194                   s = sec;
7195
7196                 /* Beware of type punned pointers vs strict aliasing
7197                    rules.  */
7198                 vpp = &(elf_section_data (s)->local_dynrel);
7199                 head = (struct elf_dyn_relocs **) vpp;
7200               }
7201
7202             p = *head;
7203             if (p == NULL || p->sec != sec)
7204               {
7205                 bfd_size_type amt = sizeof *p;
7206                 p = ((struct elf_dyn_relocs *)
7207                      bfd_zalloc (htab->root.dynobj, amt));
7208                 if (p == NULL)
7209                   return FALSE;
7210                 p->next = *head;
7211                 *head = p;
7212                 p->sec = sec;
7213               }
7214
7215             p->count += 1;
7216
7217           }
7218           break;
7219
7220           /* RR: We probably want to keep a consistency check that
7221              there are no dangling GOT_PAGE relocs.  */
7222         case BFD_RELOC_AARCH64_ADR_GOT_PAGE:
7223         case BFD_RELOC_AARCH64_GOT_LD_PREL19:
7224         case BFD_RELOC_AARCH64_LD32_GOTPAGE_LO14:
7225         case BFD_RELOC_AARCH64_LD32_GOT_LO12_NC:
7226         case BFD_RELOC_AARCH64_LD64_GOTOFF_LO15:
7227         case BFD_RELOC_AARCH64_LD64_GOTPAGE_LO15:
7228         case BFD_RELOC_AARCH64_LD64_GOT_LO12_NC:
7229         case BFD_RELOC_AARCH64_MOVW_GOTOFF_G0_NC:
7230         case BFD_RELOC_AARCH64_MOVW_GOTOFF_G1:
7231         case BFD_RELOC_AARCH64_TLSDESC_ADD_LO12_NC:
7232         case BFD_RELOC_AARCH64_TLSDESC_ADR_PAGE21:
7233         case BFD_RELOC_AARCH64_TLSDESC_ADR_PREL21:
7234         case BFD_RELOC_AARCH64_TLSDESC_LD32_LO12_NC:
7235         case BFD_RELOC_AARCH64_TLSDESC_LD64_LO12_NC:
7236         case BFD_RELOC_AARCH64_TLSDESC_LD_PREL19:
7237         case BFD_RELOC_AARCH64_TLSDESC_OFF_G0_NC:
7238         case BFD_RELOC_AARCH64_TLSDESC_OFF_G1:
7239         case BFD_RELOC_AARCH64_TLSGD_ADD_LO12_NC:
7240         case BFD_RELOC_AARCH64_TLSGD_ADR_PAGE21:
7241         case BFD_RELOC_AARCH64_TLSGD_ADR_PREL21:
7242         case BFD_RELOC_AARCH64_TLSGD_MOVW_G0_NC:
7243         case BFD_RELOC_AARCH64_TLSGD_MOVW_G1:
7244         case BFD_RELOC_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21:
7245         case BFD_RELOC_AARCH64_TLSIE_LD32_GOTTPREL_LO12_NC:
7246         case BFD_RELOC_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC:
7247         case BFD_RELOC_AARCH64_TLSIE_LD_GOTTPREL_PREL19:
7248         case BFD_RELOC_AARCH64_TLSIE_MOVW_GOTTPREL_G0_NC:
7249         case BFD_RELOC_AARCH64_TLSIE_MOVW_GOTTPREL_G1:
7250         case BFD_RELOC_AARCH64_TLSLD_ADD_LO12_NC:
7251         case BFD_RELOC_AARCH64_TLSLD_ADR_PAGE21:
7252         case BFD_RELOC_AARCH64_TLSLD_ADR_PREL21:
7253         case BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G1:
7254         case BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G1_NC:
7255         case BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G2:
7256           {
7257             unsigned got_type;
7258             unsigned old_got_type;
7259
7260             got_type = aarch64_reloc_got_type (bfd_r_type);
7261
7262             if (h)
7263               {
7264                 h->got.refcount += 1;
7265                 old_got_type = elf_aarch64_hash_entry (h)->got_type;
7266               }
7267             else
7268               {
7269                 struct elf_aarch64_local_symbol *locals;
7270
7271                 if (!elfNN_aarch64_allocate_local_symbols
7272                     (abfd, symtab_hdr->sh_info))
7273                   return FALSE;
7274
7275                 locals = elf_aarch64_locals (abfd);
7276                 BFD_ASSERT (r_symndx < symtab_hdr->sh_info);
7277                 locals[r_symndx].got_refcount += 1;
7278                 old_got_type = locals[r_symndx].got_type;
7279               }
7280
7281             /* If a variable is accessed with both general dynamic TLS
7282                methods, two slots may be created.  */
7283             if (GOT_TLS_GD_ANY_P (old_got_type) && GOT_TLS_GD_ANY_P (got_type))
7284               got_type |= old_got_type;
7285
7286             /* We will already have issued an error message if there
7287                is a TLS/non-TLS mismatch, based on the symbol type.
7288                So just combine any TLS types needed.  */
7289             if (old_got_type != GOT_UNKNOWN && old_got_type != GOT_NORMAL
7290                 && got_type != GOT_NORMAL)
7291               got_type |= old_got_type;
7292
7293             /* If the symbol is accessed by both IE and GD methods, we
7294                are able to relax.  Turn off the GD flag, without
7295                messing up with any other kind of TLS types that may be
7296                involved.  */
7297             if ((got_type & GOT_TLS_IE) && GOT_TLS_GD_ANY_P (got_type))
7298               got_type &= ~ (GOT_TLSDESC_GD | GOT_TLS_GD);
7299
7300             if (old_got_type != got_type)
7301               {
7302                 if (h != NULL)
7303                   elf_aarch64_hash_entry (h)->got_type = got_type;
7304                 else
7305                   {
7306                     struct elf_aarch64_local_symbol *locals;
7307                     locals = elf_aarch64_locals (abfd);
7308                     BFD_ASSERT (r_symndx < symtab_hdr->sh_info);
7309                     locals[r_symndx].got_type = got_type;
7310                   }
7311               }
7312
7313             if (htab->root.dynobj == NULL)
7314               htab->root.dynobj = abfd;
7315             if (! aarch64_elf_create_got_section (htab->root.dynobj, info))
7316               return FALSE;
7317             break;
7318           }
7319
7320         case BFD_RELOC_AARCH64_MOVW_G0_NC:
7321         case BFD_RELOC_AARCH64_MOVW_G1_NC:
7322         case BFD_RELOC_AARCH64_MOVW_G2_NC:
7323         case BFD_RELOC_AARCH64_MOVW_G3:
7324           if (bfd_link_pic (info))
7325             {
7326               int howto_index = bfd_r_type - BFD_RELOC_AARCH64_RELOC_START;
7327               (*_bfd_error_handler)
7328                 (_("%B: relocation %s against `%s' can not be used when making "
7329                    "a shared object; recompile with -fPIC"),
7330                  abfd, elfNN_aarch64_howto_table[howto_index].name,
7331                  (h) ? h->root.root.string : "a local symbol");
7332               bfd_set_error (bfd_error_bad_value);
7333               return FALSE;
7334             }
7335
7336         case BFD_RELOC_AARCH64_ADR_HI21_NC_PCREL:
7337         case BFD_RELOC_AARCH64_ADR_HI21_PCREL:
7338         case BFD_RELOC_AARCH64_ADR_LO21_PCREL:
7339           if (h != NULL && bfd_link_executable (info))
7340             {
7341               /* If this reloc is in a read-only section, we might
7342                  need a copy reloc.  We can't check reliably at this
7343                  stage whether the section is read-only, as input
7344                  sections have not yet been mapped to output sections.
7345                  Tentatively set the flag for now, and correct in
7346                  adjust_dynamic_symbol.  */
7347               h->non_got_ref = 1;
7348               h->plt.refcount += 1;
7349               h->pointer_equality_needed = 1;
7350             }
7351           /* FIXME:: RR need to handle these in shared libraries
7352              and essentially bomb out as these being non-PIC
7353              relocations in shared libraries.  */
7354           break;
7355
7356         case BFD_RELOC_AARCH64_CALL26:
7357         case BFD_RELOC_AARCH64_JUMP26:
7358           /* If this is a local symbol then we resolve it
7359              directly without creating a PLT entry.  */
7360           if (h == NULL)
7361             continue;
7362
7363           h->needs_plt = 1;
7364           if (h->plt.refcount <= 0)
7365             h->plt.refcount = 1;
7366           else
7367             h->plt.refcount += 1;
7368           break;
7369
7370         default:
7371           break;
7372         }
7373     }
7374
7375   return TRUE;
7376 }
7377
7378 /* Treat mapping symbols as special target symbols.  */
7379
7380 static bfd_boolean
7381 elfNN_aarch64_is_target_special_symbol (bfd *abfd ATTRIBUTE_UNUSED,
7382                                         asymbol *sym)
7383 {
7384   return bfd_is_aarch64_special_symbol_name (sym->name,
7385                                              BFD_AARCH64_SPECIAL_SYM_TYPE_ANY);
7386 }
7387
7388 /* This is a copy of elf_find_function () from elf.c except that
7389    AArch64 mapping symbols are ignored when looking for function names.  */
7390
7391 static bfd_boolean
7392 aarch64_elf_find_function (bfd *abfd ATTRIBUTE_UNUSED,
7393                            asymbol **symbols,
7394                            asection *section,
7395                            bfd_vma offset,
7396                            const char **filename_ptr,
7397                            const char **functionname_ptr)
7398 {
7399   const char *filename = NULL;
7400   asymbol *func = NULL;
7401   bfd_vma low_func = 0;
7402   asymbol **p;
7403
7404   for (p = symbols; *p != NULL; p++)
7405     {
7406       elf_symbol_type *q;
7407
7408       q = (elf_symbol_type *) * p;
7409
7410       switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
7411         {
7412         default:
7413           break;
7414         case STT_FILE:
7415           filename = bfd_asymbol_name (&q->symbol);
7416           break;
7417         case STT_FUNC:
7418         case STT_NOTYPE:
7419           /* Skip mapping symbols.  */
7420           if ((q->symbol.flags & BSF_LOCAL)
7421               && (bfd_is_aarch64_special_symbol_name
7422                   (q->symbol.name, BFD_AARCH64_SPECIAL_SYM_TYPE_ANY)))
7423             continue;
7424           /* Fall through.  */
7425           if (bfd_get_section (&q->symbol) == section
7426               && q->symbol.value >= low_func && q->symbol.value <= offset)
7427             {
7428               func = (asymbol *) q;
7429               low_func = q->symbol.value;
7430             }
7431           break;
7432         }
7433     }
7434
7435   if (func == NULL)
7436     return FALSE;
7437
7438   if (filename_ptr)
7439     *filename_ptr = filename;
7440   if (functionname_ptr)
7441     *functionname_ptr = bfd_asymbol_name (func);
7442
7443   return TRUE;
7444 }
7445
7446
7447 /* Find the nearest line to a particular section and offset, for error
7448    reporting.   This code is a duplicate of the code in elf.c, except
7449    that it uses aarch64_elf_find_function.  */
7450
7451 static bfd_boolean
7452 elfNN_aarch64_find_nearest_line (bfd *abfd,
7453                                  asymbol **symbols,
7454                                  asection *section,
7455                                  bfd_vma offset,
7456                                  const char **filename_ptr,
7457                                  const char **functionname_ptr,
7458                                  unsigned int *line_ptr,
7459                                  unsigned int *discriminator_ptr)
7460 {
7461   bfd_boolean found = FALSE;
7462
7463   if (_bfd_dwarf2_find_nearest_line (abfd, symbols, NULL, section, offset,
7464                                      filename_ptr, functionname_ptr,
7465                                      line_ptr, discriminator_ptr,
7466                                      dwarf_debug_sections, 0,
7467                                      &elf_tdata (abfd)->dwarf2_find_line_info))
7468     {
7469       if (!*functionname_ptr)
7470         aarch64_elf_find_function (abfd, symbols, section, offset,
7471                                    *filename_ptr ? NULL : filename_ptr,
7472                                    functionname_ptr);
7473
7474       return TRUE;
7475     }
7476
7477   /* Skip _bfd_dwarf1_find_nearest_line since no known AArch64
7478      toolchain uses DWARF1.  */
7479
7480   if (!_bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
7481                                             &found, filename_ptr,
7482                                             functionname_ptr, line_ptr,
7483                                             &elf_tdata (abfd)->line_info))
7484     return FALSE;
7485
7486   if (found && (*functionname_ptr || *line_ptr))
7487     return TRUE;
7488
7489   if (symbols == NULL)
7490     return FALSE;
7491
7492   if (!aarch64_elf_find_function (abfd, symbols, section, offset,
7493                                   filename_ptr, functionname_ptr))
7494     return FALSE;
7495
7496   *line_ptr = 0;
7497   return TRUE;
7498 }
7499
7500 static bfd_boolean
7501 elfNN_aarch64_find_inliner_info (bfd *abfd,
7502                                  const char **filename_ptr,
7503                                  const char **functionname_ptr,
7504                                  unsigned int *line_ptr)
7505 {
7506   bfd_boolean found;
7507   found = _bfd_dwarf2_find_inliner_info
7508     (abfd, filename_ptr,
7509      functionname_ptr, line_ptr, &elf_tdata (abfd)->dwarf2_find_line_info);
7510   return found;
7511 }
7512
7513
7514 static void
7515 elfNN_aarch64_post_process_headers (bfd *abfd,
7516                                     struct bfd_link_info *link_info)
7517 {
7518   Elf_Internal_Ehdr *i_ehdrp;   /* ELF file header, internal form.  */
7519
7520   i_ehdrp = elf_elfheader (abfd);
7521   i_ehdrp->e_ident[EI_ABIVERSION] = AARCH64_ELF_ABI_VERSION;
7522
7523   _bfd_elf_post_process_headers (abfd, link_info);
7524 }
7525
7526 static enum elf_reloc_type_class
7527 elfNN_aarch64_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
7528                                 const asection *rel_sec ATTRIBUTE_UNUSED,
7529                                 const Elf_Internal_Rela *rela)
7530 {
7531   switch ((int) ELFNN_R_TYPE (rela->r_info))
7532     {
7533     case AARCH64_R (RELATIVE):
7534       return reloc_class_relative;
7535     case AARCH64_R (JUMP_SLOT):
7536       return reloc_class_plt;
7537     case AARCH64_R (COPY):
7538       return reloc_class_copy;
7539     default:
7540       return reloc_class_normal;
7541     }
7542 }
7543
7544 /* Handle an AArch64 specific section when reading an object file.  This is
7545    called when bfd_section_from_shdr finds a section with an unknown
7546    type.  */
7547
7548 static bfd_boolean
7549 elfNN_aarch64_section_from_shdr (bfd *abfd,
7550                                  Elf_Internal_Shdr *hdr,
7551                                  const char *name, int shindex)
7552 {
7553   /* There ought to be a place to keep ELF backend specific flags, but
7554      at the moment there isn't one.  We just keep track of the
7555      sections by their name, instead.  Fortunately, the ABI gives
7556      names for all the AArch64 specific sections, so we will probably get
7557      away with this.  */
7558   switch (hdr->sh_type)
7559     {
7560     case SHT_AARCH64_ATTRIBUTES:
7561       break;
7562
7563     default:
7564       return FALSE;
7565     }
7566
7567   if (!_bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
7568     return FALSE;
7569
7570   return TRUE;
7571 }
7572
7573 /* A structure used to record a list of sections, independently
7574    of the next and prev fields in the asection structure.  */
7575 typedef struct section_list
7576 {
7577   asection *sec;
7578   struct section_list *next;
7579   struct section_list *prev;
7580 }
7581 section_list;
7582
7583 /* Unfortunately we need to keep a list of sections for which
7584    an _aarch64_elf_section_data structure has been allocated.  This
7585    is because it is possible for functions like elfNN_aarch64_write_section
7586    to be called on a section which has had an elf_data_structure
7587    allocated for it (and so the used_by_bfd field is valid) but
7588    for which the AArch64 extended version of this structure - the
7589    _aarch64_elf_section_data structure - has not been allocated.  */
7590 static section_list *sections_with_aarch64_elf_section_data = NULL;
7591
7592 static void
7593 record_section_with_aarch64_elf_section_data (asection *sec)
7594 {
7595   struct section_list *entry;
7596
7597   entry = bfd_malloc (sizeof (*entry));
7598   if (entry == NULL)
7599     return;
7600   entry->sec = sec;
7601   entry->next = sections_with_aarch64_elf_section_data;
7602   entry->prev = NULL;
7603   if (entry->next != NULL)
7604     entry->next->prev = entry;
7605   sections_with_aarch64_elf_section_data = entry;
7606 }
7607
7608 static struct section_list *
7609 find_aarch64_elf_section_entry (asection *sec)
7610 {
7611   struct section_list *entry;
7612   static struct section_list *last_entry = NULL;
7613
7614   /* This is a short cut for the typical case where the sections are added
7615      to the sections_with_aarch64_elf_section_data list in forward order and
7616      then looked up here in backwards order.  This makes a real difference
7617      to the ld-srec/sec64k.exp linker test.  */
7618   entry = sections_with_aarch64_elf_section_data;
7619   if (last_entry != NULL)
7620     {
7621       if (last_entry->sec == sec)
7622         entry = last_entry;
7623       else if (last_entry->next != NULL && last_entry->next->sec == sec)
7624         entry = last_entry->next;
7625     }
7626
7627   for (; entry; entry = entry->next)
7628     if (entry->sec == sec)
7629       break;
7630
7631   if (entry)
7632     /* Record the entry prior to this one - it is the entry we are
7633        most likely to want to locate next time.  Also this way if we
7634        have been called from
7635        unrecord_section_with_aarch64_elf_section_data () we will not
7636        be caching a pointer that is about to be freed.  */
7637     last_entry = entry->prev;
7638
7639   return entry;
7640 }
7641
7642 static void
7643 unrecord_section_with_aarch64_elf_section_data (asection *sec)
7644 {
7645   struct section_list *entry;
7646
7647   entry = find_aarch64_elf_section_entry (sec);
7648
7649   if (entry)
7650     {
7651       if (entry->prev != NULL)
7652         entry->prev->next = entry->next;
7653       if (entry->next != NULL)
7654         entry->next->prev = entry->prev;
7655       if (entry == sections_with_aarch64_elf_section_data)
7656         sections_with_aarch64_elf_section_data = entry->next;
7657       free (entry);
7658     }
7659 }
7660
7661
7662 typedef struct
7663 {
7664   void *finfo;
7665   struct bfd_link_info *info;
7666   asection *sec;
7667   int sec_shndx;
7668   int (*func) (void *, const char *, Elf_Internal_Sym *,
7669                asection *, struct elf_link_hash_entry *);
7670 } output_arch_syminfo;
7671
7672 enum map_symbol_type
7673 {
7674   AARCH64_MAP_INSN,
7675   AARCH64_MAP_DATA
7676 };
7677
7678
7679 /* Output a single mapping symbol.  */
7680
7681 static bfd_boolean
7682 elfNN_aarch64_output_map_sym (output_arch_syminfo *osi,
7683                               enum map_symbol_type type, bfd_vma offset)
7684 {
7685   static const char *names[2] = { "$x", "$d" };
7686   Elf_Internal_Sym sym;
7687
7688   sym.st_value = (osi->sec->output_section->vma
7689                   + osi->sec->output_offset + offset);
7690   sym.st_size = 0;
7691   sym.st_other = 0;
7692   sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_NOTYPE);
7693   sym.st_shndx = osi->sec_shndx;
7694   return osi->func (osi->finfo, names[type], &sym, osi->sec, NULL) == 1;
7695 }
7696
7697 /* Output a single local symbol for a generated stub.  */
7698
7699 static bfd_boolean
7700 elfNN_aarch64_output_stub_sym (output_arch_syminfo *osi, const char *name,
7701                                bfd_vma offset, bfd_vma size)
7702 {
7703   Elf_Internal_Sym sym;
7704
7705   sym.st_value = (osi->sec->output_section->vma
7706                   + osi->sec->output_offset + offset);
7707   sym.st_size = size;
7708   sym.st_other = 0;
7709   sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
7710   sym.st_shndx = osi->sec_shndx;
7711   return osi->func (osi->finfo, name, &sym, osi->sec, NULL) == 1;
7712 }
7713
7714 static bfd_boolean
7715 aarch64_map_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
7716 {
7717   struct elf_aarch64_stub_hash_entry *stub_entry;
7718   asection *stub_sec;
7719   bfd_vma addr;
7720   char *stub_name;
7721   output_arch_syminfo *osi;
7722
7723   /* Massage our args to the form they really have.  */
7724   stub_entry = (struct elf_aarch64_stub_hash_entry *) gen_entry;
7725   osi = (output_arch_syminfo *) in_arg;
7726
7727   stub_sec = stub_entry->stub_sec;
7728
7729   /* Ensure this stub is attached to the current section being
7730      processed.  */
7731   if (stub_sec != osi->sec)
7732     return TRUE;
7733
7734   addr = (bfd_vma) stub_entry->stub_offset;
7735
7736   stub_name = stub_entry->output_name;
7737
7738   switch (stub_entry->stub_type)
7739     {
7740     case aarch64_stub_adrp_branch:
7741       if (!elfNN_aarch64_output_stub_sym (osi, stub_name, addr,
7742                                           sizeof (aarch64_adrp_branch_stub)))
7743         return FALSE;
7744       if (!elfNN_aarch64_output_map_sym (osi, AARCH64_MAP_INSN, addr))
7745         return FALSE;
7746       break;
7747     case aarch64_stub_long_branch:
7748       if (!elfNN_aarch64_output_stub_sym
7749           (osi, stub_name, addr, sizeof (aarch64_long_branch_stub)))
7750         return FALSE;
7751       if (!elfNN_aarch64_output_map_sym (osi, AARCH64_MAP_INSN, addr))
7752         return FALSE;
7753       if (!elfNN_aarch64_output_map_sym (osi, AARCH64_MAP_DATA, addr + 16))
7754         return FALSE;
7755       break;
7756     case aarch64_stub_erratum_835769_veneer:
7757       if (!elfNN_aarch64_output_stub_sym (osi, stub_name, addr,
7758                                           sizeof (aarch64_erratum_835769_stub)))
7759         return FALSE;
7760       if (!elfNN_aarch64_output_map_sym (osi, AARCH64_MAP_INSN, addr))
7761         return FALSE;
7762       break;
7763     case aarch64_stub_erratum_843419_veneer:
7764       if (!elfNN_aarch64_output_stub_sym (osi, stub_name, addr,
7765                                           sizeof (aarch64_erratum_843419_stub)))
7766         return FALSE;
7767       if (!elfNN_aarch64_output_map_sym (osi, AARCH64_MAP_INSN, addr))
7768         return FALSE;
7769       break;
7770
7771     default:
7772       abort ();
7773     }
7774
7775   return TRUE;
7776 }
7777
7778 /* Output mapping symbols for linker generated sections.  */
7779
7780 static bfd_boolean
7781 elfNN_aarch64_output_arch_local_syms (bfd *output_bfd,
7782                                       struct bfd_link_info *info,
7783                                       void *finfo,
7784                                       int (*func) (void *, const char *,
7785                                                    Elf_Internal_Sym *,
7786                                                    asection *,
7787                                                    struct elf_link_hash_entry
7788                                                    *))
7789 {
7790   output_arch_syminfo osi;
7791   struct elf_aarch64_link_hash_table *htab;
7792
7793   htab = elf_aarch64_hash_table (info);
7794
7795   osi.finfo = finfo;
7796   osi.info = info;
7797   osi.func = func;
7798
7799   /* Long calls stubs.  */
7800   if (htab->stub_bfd && htab->stub_bfd->sections)
7801     {
7802       asection *stub_sec;
7803
7804       for (stub_sec = htab->stub_bfd->sections;
7805            stub_sec != NULL; stub_sec = stub_sec->next)
7806         {
7807           /* Ignore non-stub sections.  */
7808           if (!strstr (stub_sec->name, STUB_SUFFIX))
7809             continue;
7810
7811           osi.sec = stub_sec;
7812
7813           osi.sec_shndx = _bfd_elf_section_from_bfd_section
7814             (output_bfd, osi.sec->output_section);
7815
7816           /* The first instruction in a stub is always a branch.  */
7817           if (!elfNN_aarch64_output_map_sym (&osi, AARCH64_MAP_INSN, 0))
7818             return FALSE;
7819
7820           bfd_hash_traverse (&htab->stub_hash_table, aarch64_map_one_stub,
7821                              &osi);
7822         }
7823     }
7824
7825   /* Finally, output mapping symbols for the PLT.  */
7826   if (!htab->root.splt || htab->root.splt->size == 0)
7827     return TRUE;
7828
7829   osi.sec_shndx = _bfd_elf_section_from_bfd_section
7830     (output_bfd, htab->root.splt->output_section);
7831   osi.sec = htab->root.splt;
7832
7833   elfNN_aarch64_output_map_sym (&osi, AARCH64_MAP_INSN, 0);
7834
7835   return TRUE;
7836
7837 }
7838
7839 /* Allocate target specific section data.  */
7840
7841 static bfd_boolean
7842 elfNN_aarch64_new_section_hook (bfd *abfd, asection *sec)
7843 {
7844   if (!sec->used_by_bfd)
7845     {
7846       _aarch64_elf_section_data *sdata;
7847       bfd_size_type amt = sizeof (*sdata);
7848
7849       sdata = bfd_zalloc (abfd, amt);
7850       if (sdata == NULL)
7851         return FALSE;
7852       sec->used_by_bfd = sdata;
7853     }
7854
7855   record_section_with_aarch64_elf_section_data (sec);
7856
7857   return _bfd_elf_new_section_hook (abfd, sec);
7858 }
7859
7860
7861 static void
7862 unrecord_section_via_map_over_sections (bfd *abfd ATTRIBUTE_UNUSED,
7863                                         asection *sec,
7864                                         void *ignore ATTRIBUTE_UNUSED)
7865 {
7866   unrecord_section_with_aarch64_elf_section_data (sec);
7867 }
7868
7869 static bfd_boolean
7870 elfNN_aarch64_close_and_cleanup (bfd *abfd)
7871 {
7872   if (abfd->sections)
7873     bfd_map_over_sections (abfd,
7874                            unrecord_section_via_map_over_sections, NULL);
7875
7876   return _bfd_elf_close_and_cleanup (abfd);
7877 }
7878
7879 static bfd_boolean
7880 elfNN_aarch64_bfd_free_cached_info (bfd *abfd)
7881 {
7882   if (abfd->sections)
7883     bfd_map_over_sections (abfd,
7884                            unrecord_section_via_map_over_sections, NULL);
7885
7886   return _bfd_free_cached_info (abfd);
7887 }
7888
7889 /* Create dynamic sections. This is different from the ARM backend in that
7890    the got, plt, gotplt and their relocation sections are all created in the
7891    standard part of the bfd elf backend.  */
7892
7893 static bfd_boolean
7894 elfNN_aarch64_create_dynamic_sections (bfd *dynobj,
7895                                        struct bfd_link_info *info)
7896 {
7897   struct elf_aarch64_link_hash_table *htab;
7898
7899   /* We need to create .got section.  */
7900   if (!aarch64_elf_create_got_section (dynobj, info))
7901     return FALSE;
7902
7903   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
7904     return FALSE;
7905
7906   htab = elf_aarch64_hash_table (info);
7907   htab->sdynbss = bfd_get_linker_section (dynobj, ".dynbss");
7908   if (!bfd_link_pic (info))
7909     htab->srelbss = bfd_get_linker_section (dynobj, ".rela.bss");
7910
7911   if (!htab->sdynbss || (!bfd_link_pic (info) && !htab->srelbss))
7912     abort ();
7913
7914   return TRUE;
7915 }
7916
7917
7918 /* Allocate space in .plt, .got and associated reloc sections for
7919    dynamic relocs.  */
7920
7921 static bfd_boolean
7922 elfNN_aarch64_allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
7923 {
7924   struct bfd_link_info *info;
7925   struct elf_aarch64_link_hash_table *htab;
7926   struct elf_aarch64_link_hash_entry *eh;
7927   struct elf_dyn_relocs *p;
7928
7929   /* An example of a bfd_link_hash_indirect symbol is versioned
7930      symbol. For example: __gxx_personality_v0(bfd_link_hash_indirect)
7931      -> __gxx_personality_v0(bfd_link_hash_defined)
7932
7933      There is no need to process bfd_link_hash_indirect symbols here
7934      because we will also be presented with the concrete instance of
7935      the symbol and elfNN_aarch64_copy_indirect_symbol () will have been
7936      called to copy all relevant data from the generic to the concrete
7937      symbol instance.
7938    */
7939   if (h->root.type == bfd_link_hash_indirect)
7940     return TRUE;
7941
7942   if (h->root.type == bfd_link_hash_warning)
7943     h = (struct elf_link_hash_entry *) h->root.u.i.link;
7944
7945   info = (struct bfd_link_info *) inf;
7946   htab = elf_aarch64_hash_table (info);
7947
7948   /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
7949      here if it is defined and referenced in a non-shared object.  */
7950   if (h->type == STT_GNU_IFUNC
7951       && h->def_regular)
7952     return TRUE;
7953   else if (htab->root.dynamic_sections_created && h->plt.refcount > 0)
7954     {
7955       /* Make sure this symbol is output as a dynamic symbol.
7956          Undefined weak syms won't yet be marked as dynamic.  */
7957       if (h->dynindx == -1 && !h->forced_local)
7958         {
7959           if (!bfd_elf_link_record_dynamic_symbol (info, h))
7960             return FALSE;
7961         }
7962
7963       if (bfd_link_pic (info) || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
7964         {
7965           asection *s = htab->root.splt;
7966
7967           /* If this is the first .plt entry, make room for the special
7968              first entry.  */
7969           if (s->size == 0)
7970             s->size += htab->plt_header_size;
7971
7972           h->plt.offset = s->size;
7973
7974           /* If this symbol is not defined in a regular file, and we are
7975              not generating a shared library, then set the symbol to this
7976              location in the .plt.  This is required to make function
7977              pointers compare as equal between the normal executable and
7978              the shared library.  */
7979           if (!bfd_link_pic (info) && !h->def_regular)
7980             {
7981               h->root.u.def.section = s;
7982               h->root.u.def.value = h->plt.offset;
7983             }
7984
7985           /* Make room for this entry. For now we only create the
7986              small model PLT entries. We later need to find a way
7987              of relaxing into these from the large model PLT entries.  */
7988           s->size += PLT_SMALL_ENTRY_SIZE;
7989
7990           /* We also need to make an entry in the .got.plt section, which
7991              will be placed in the .got section by the linker script.  */
7992           htab->root.sgotplt->size += GOT_ENTRY_SIZE;
7993
7994           /* We also need to make an entry in the .rela.plt section.  */
7995           htab->root.srelplt->size += RELOC_SIZE (htab);
7996
7997           /* We need to ensure that all GOT entries that serve the PLT
7998              are consecutive with the special GOT slots [0] [1] and
7999              [2]. Any addtional relocations, such as
8000              R_AARCH64_TLSDESC, must be placed after the PLT related
8001              entries.  We abuse the reloc_count such that during
8002              sizing we adjust reloc_count to indicate the number of
8003              PLT related reserved entries.  In subsequent phases when
8004              filling in the contents of the reloc entries, PLT related
8005              entries are placed by computing their PLT index (0
8006              .. reloc_count). While other none PLT relocs are placed
8007              at the slot indicated by reloc_count and reloc_count is
8008              updated.  */
8009
8010           htab->root.srelplt->reloc_count++;
8011         }
8012       else
8013         {
8014           h->plt.offset = (bfd_vma) - 1;
8015           h->needs_plt = 0;
8016         }
8017     }
8018   else
8019     {
8020       h->plt.offset = (bfd_vma) - 1;
8021       h->needs_plt = 0;
8022     }
8023
8024   eh = (struct elf_aarch64_link_hash_entry *) h;
8025   eh->tlsdesc_got_jump_table_offset = (bfd_vma) - 1;
8026
8027   if (h->got.refcount > 0)
8028     {
8029       bfd_boolean dyn;
8030       unsigned got_type = elf_aarch64_hash_entry (h)->got_type;
8031
8032       h->got.offset = (bfd_vma) - 1;
8033
8034       dyn = htab->root.dynamic_sections_created;
8035
8036       /* Make sure this symbol is output as a dynamic symbol.
8037          Undefined weak syms won't yet be marked as dynamic.  */
8038       if (dyn && h->dynindx == -1 && !h->forced_local)
8039         {
8040           if (!bfd_elf_link_record_dynamic_symbol (info, h))
8041             return FALSE;
8042         }
8043
8044       if (got_type == GOT_UNKNOWN)
8045         {
8046         }
8047       else if (got_type == GOT_NORMAL)
8048         {
8049           h->got.offset = htab->root.sgot->size;
8050           htab->root.sgot->size += GOT_ENTRY_SIZE;
8051           if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
8052                || h->root.type != bfd_link_hash_undefweak)
8053               && (bfd_link_pic (info)
8054                   || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
8055             {
8056               htab->root.srelgot->size += RELOC_SIZE (htab);
8057             }
8058         }
8059       else
8060         {
8061           int indx;
8062           if (got_type & GOT_TLSDESC_GD)
8063             {
8064               eh->tlsdesc_got_jump_table_offset =
8065                 (htab->root.sgotplt->size
8066                  - aarch64_compute_jump_table_size (htab));
8067               htab->root.sgotplt->size += GOT_ENTRY_SIZE * 2;
8068               h->got.offset = (bfd_vma) - 2;
8069             }
8070
8071           if (got_type & GOT_TLS_GD)
8072             {
8073               h->got.offset = htab->root.sgot->size;
8074               htab->root.sgot->size += GOT_ENTRY_SIZE * 2;
8075             }
8076
8077           if (got_type & GOT_TLS_IE)
8078             {
8079               h->got.offset = htab->root.sgot->size;
8080               htab->root.sgot->size += GOT_ENTRY_SIZE;
8081             }
8082
8083           indx = h && h->dynindx != -1 ? h->dynindx : 0;
8084           if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
8085                || h->root.type != bfd_link_hash_undefweak)
8086               && (bfd_link_pic (info)
8087                   || indx != 0
8088                   || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
8089             {
8090               if (got_type & GOT_TLSDESC_GD)
8091                 {
8092                   htab->root.srelplt->size += RELOC_SIZE (htab);
8093                   /* Note reloc_count not incremented here!  We have
8094                      already adjusted reloc_count for this relocation
8095                      type.  */
8096
8097                   /* TLSDESC PLT is now needed, but not yet determined.  */
8098                   htab->tlsdesc_plt = (bfd_vma) - 1;
8099                 }
8100
8101               if (got_type & GOT_TLS_GD)
8102                 htab->root.srelgot->size += RELOC_SIZE (htab) * 2;
8103
8104               if (got_type & GOT_TLS_IE)
8105                 htab->root.srelgot->size += RELOC_SIZE (htab);
8106             }
8107         }
8108     }
8109   else
8110     {
8111       h->got.offset = (bfd_vma) - 1;
8112     }
8113
8114   if (eh->dyn_relocs == NULL)
8115     return TRUE;
8116
8117   /* In the shared -Bsymbolic case, discard space allocated for
8118      dynamic pc-relative relocs against symbols which turn out to be
8119      defined in regular objects.  For the normal shared case, discard
8120      space for pc-relative relocs that have become local due to symbol
8121      visibility changes.  */
8122
8123   if (bfd_link_pic (info))
8124     {
8125       /* Relocs that use pc_count are those that appear on a call
8126          insn, or certain REL relocs that can generated via assembly.
8127          We want calls to protected symbols to resolve directly to the
8128          function rather than going via the plt.  If people want
8129          function pointer comparisons to work as expected then they
8130          should avoid writing weird assembly.  */
8131       if (SYMBOL_CALLS_LOCAL (info, h))
8132         {
8133           struct elf_dyn_relocs **pp;
8134
8135           for (pp = &eh->dyn_relocs; (p = *pp) != NULL;)
8136             {
8137               p->count -= p->pc_count;
8138               p->pc_count = 0;
8139               if (p->count == 0)
8140                 *pp = p->next;
8141               else
8142                 pp = &p->next;
8143             }
8144         }
8145
8146       /* Also discard relocs on undefined weak syms with non-default
8147          visibility.  */
8148       if (eh->dyn_relocs != NULL && h->root.type == bfd_link_hash_undefweak)
8149         {
8150           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
8151             eh->dyn_relocs = NULL;
8152
8153           /* Make sure undefined weak symbols are output as a dynamic
8154              symbol in PIEs.  */
8155           else if (h->dynindx == -1
8156                    && !h->forced_local
8157                    && !bfd_elf_link_record_dynamic_symbol (info, h))
8158             return FALSE;
8159         }
8160
8161     }
8162   else if (ELIMINATE_COPY_RELOCS)
8163     {
8164       /* For the non-shared case, discard space for relocs against
8165          symbols which turn out to need copy relocs or are not
8166          dynamic.  */
8167
8168       if (!h->non_got_ref
8169           && ((h->def_dynamic
8170                && !h->def_regular)
8171               || (htab->root.dynamic_sections_created
8172                   && (h->root.type == bfd_link_hash_undefweak
8173                       || h->root.type == bfd_link_hash_undefined))))
8174         {
8175           /* Make sure this symbol is output as a dynamic symbol.
8176              Undefined weak syms won't yet be marked as dynamic.  */
8177           if (h->dynindx == -1
8178               && !h->forced_local
8179               && !bfd_elf_link_record_dynamic_symbol (info, h))
8180             return FALSE;
8181
8182           /* If that succeeded, we know we'll be keeping all the
8183              relocs.  */
8184           if (h->dynindx != -1)
8185             goto keep;
8186         }
8187
8188       eh->dyn_relocs = NULL;
8189
8190     keep:;
8191     }
8192
8193   /* Finally, allocate space.  */
8194   for (p = eh->dyn_relocs; p != NULL; p = p->next)
8195     {
8196       asection *sreloc;
8197
8198       sreloc = elf_section_data (p->sec)->sreloc;
8199
8200       BFD_ASSERT (sreloc != NULL);
8201
8202       sreloc->size += p->count * RELOC_SIZE (htab);
8203     }
8204
8205   return TRUE;
8206 }
8207
8208 /* Allocate space in .plt, .got and associated reloc sections for
8209    ifunc dynamic relocs.  */
8210
8211 static bfd_boolean
8212 elfNN_aarch64_allocate_ifunc_dynrelocs (struct elf_link_hash_entry *h,
8213                                         void *inf)
8214 {
8215   struct bfd_link_info *info;
8216   struct elf_aarch64_link_hash_table *htab;
8217   struct elf_aarch64_link_hash_entry *eh;
8218
8219   /* An example of a bfd_link_hash_indirect symbol is versioned
8220      symbol. For example: __gxx_personality_v0(bfd_link_hash_indirect)
8221      -> __gxx_personality_v0(bfd_link_hash_defined)
8222
8223      There is no need to process bfd_link_hash_indirect symbols here
8224      because we will also be presented with the concrete instance of
8225      the symbol and elfNN_aarch64_copy_indirect_symbol () will have been
8226      called to copy all relevant data from the generic to the concrete
8227      symbol instance.
8228    */
8229   if (h->root.type == bfd_link_hash_indirect)
8230     return TRUE;
8231
8232   if (h->root.type == bfd_link_hash_warning)
8233     h = (struct elf_link_hash_entry *) h->root.u.i.link;
8234
8235   info = (struct bfd_link_info *) inf;
8236   htab = elf_aarch64_hash_table (info);
8237
8238   eh = (struct elf_aarch64_link_hash_entry *) h;
8239
8240   /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
8241      here if it is defined and referenced in a non-shared object.  */
8242   if (h->type == STT_GNU_IFUNC
8243       && h->def_regular)
8244     return _bfd_elf_allocate_ifunc_dyn_relocs (info, h,
8245                                                &eh->dyn_relocs,
8246                                                NULL,
8247                                                htab->plt_entry_size,
8248                                                htab->plt_header_size,
8249                                                GOT_ENTRY_SIZE);
8250   return TRUE;
8251 }
8252
8253 /* Allocate space in .plt, .got and associated reloc sections for
8254    local dynamic relocs.  */
8255
8256 static bfd_boolean
8257 elfNN_aarch64_allocate_local_dynrelocs (void **slot, void *inf)
8258 {
8259   struct elf_link_hash_entry *h
8260     = (struct elf_link_hash_entry *) *slot;
8261
8262   if (h->type != STT_GNU_IFUNC
8263       || !h->def_regular
8264       || !h->ref_regular
8265       || !h->forced_local
8266       || h->root.type != bfd_link_hash_defined)
8267     abort ();
8268
8269   return elfNN_aarch64_allocate_dynrelocs (h, inf);
8270 }
8271
8272 /* Allocate space in .plt, .got and associated reloc sections for
8273    local ifunc dynamic relocs.  */
8274
8275 static bfd_boolean
8276 elfNN_aarch64_allocate_local_ifunc_dynrelocs (void **slot, void *inf)
8277 {
8278   struct elf_link_hash_entry *h
8279     = (struct elf_link_hash_entry *) *slot;
8280
8281   if (h->type != STT_GNU_IFUNC
8282       || !h->def_regular
8283       || !h->ref_regular
8284       || !h->forced_local
8285       || h->root.type != bfd_link_hash_defined)
8286     abort ();
8287
8288   return elfNN_aarch64_allocate_ifunc_dynrelocs (h, inf);
8289 }
8290
8291 /* Find any dynamic relocs that apply to read-only sections.  */
8292
8293 static bfd_boolean
8294 aarch64_readonly_dynrelocs (struct elf_link_hash_entry * h, void * inf)
8295 {
8296   struct elf_aarch64_link_hash_entry * eh;
8297   struct elf_dyn_relocs * p;
8298
8299   eh = (struct elf_aarch64_link_hash_entry *) h;
8300   for (p = eh->dyn_relocs; p != NULL; p = p->next)
8301     {
8302       asection *s = p->sec;
8303
8304       if (s != NULL && (s->flags & SEC_READONLY) != 0)
8305         {
8306           struct bfd_link_info *info = (struct bfd_link_info *) inf;
8307
8308           info->flags |= DF_TEXTREL;
8309
8310           /* Not an error, just cut short the traversal.  */
8311           return FALSE;
8312         }
8313     }
8314   return TRUE;
8315 }
8316
8317 /* This is the most important function of all . Innocuosly named
8318    though !  */
8319 static bfd_boolean
8320 elfNN_aarch64_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
8321                                      struct bfd_link_info *info)
8322 {
8323   struct elf_aarch64_link_hash_table *htab;
8324   bfd *dynobj;
8325   asection *s;
8326   bfd_boolean relocs;
8327   bfd *ibfd;
8328
8329   htab = elf_aarch64_hash_table ((info));
8330   dynobj = htab->root.dynobj;
8331
8332   BFD_ASSERT (dynobj != NULL);
8333
8334   if (htab->root.dynamic_sections_created)
8335     {
8336       if (bfd_link_executable (info) && !info->nointerp)
8337         {
8338           s = bfd_get_linker_section (dynobj, ".interp");
8339           if (s == NULL)
8340             abort ();
8341           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
8342           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
8343         }
8344     }
8345
8346   /* Set up .got offsets for local syms, and space for local dynamic
8347      relocs.  */
8348   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8349     {
8350       struct elf_aarch64_local_symbol *locals = NULL;
8351       Elf_Internal_Shdr *symtab_hdr;
8352       asection *srel;
8353       unsigned int i;
8354
8355       if (!is_aarch64_elf (ibfd))
8356         continue;
8357
8358       for (s = ibfd->sections; s != NULL; s = s->next)
8359         {
8360           struct elf_dyn_relocs *p;
8361
8362           for (p = (struct elf_dyn_relocs *)
8363                (elf_section_data (s)->local_dynrel); p != NULL; p = p->next)
8364             {
8365               if (!bfd_is_abs_section (p->sec)
8366                   && bfd_is_abs_section (p->sec->output_section))
8367                 {
8368                   /* Input section has been discarded, either because
8369                      it is a copy of a linkonce section or due to
8370                      linker script /DISCARD/, so we'll be discarding
8371                      the relocs too.  */
8372                 }
8373               else if (p->count != 0)
8374                 {
8375                   srel = elf_section_data (p->sec)->sreloc;
8376                   srel->size += p->count * RELOC_SIZE (htab);
8377                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
8378                     info->flags |= DF_TEXTREL;
8379                 }
8380             }
8381         }
8382
8383       locals = elf_aarch64_locals (ibfd);
8384       if (!locals)
8385         continue;
8386
8387       symtab_hdr = &elf_symtab_hdr (ibfd);
8388       srel = htab->root.srelgot;
8389       for (i = 0; i < symtab_hdr->sh_info; i++)
8390         {
8391           locals[i].got_offset = (bfd_vma) - 1;
8392           locals[i].tlsdesc_got_jump_table_offset = (bfd_vma) - 1;
8393           if (locals[i].got_refcount > 0)
8394             {
8395               unsigned got_type = locals[i].got_type;
8396               if (got_type & GOT_TLSDESC_GD)
8397                 {
8398                   locals[i].tlsdesc_got_jump_table_offset =
8399                     (htab->root.sgotplt->size
8400                      - aarch64_compute_jump_table_size (htab));
8401                   htab->root.sgotplt->size += GOT_ENTRY_SIZE * 2;
8402                   locals[i].got_offset = (bfd_vma) - 2;
8403                 }
8404
8405               if (got_type & GOT_TLS_GD)
8406                 {
8407                   locals[i].got_offset = htab->root.sgot->size;
8408                   htab->root.sgot->size += GOT_ENTRY_SIZE * 2;
8409                 }
8410
8411               if (got_type & GOT_TLS_IE
8412                   || got_type & GOT_NORMAL)
8413                 {
8414                   locals[i].got_offset = htab->root.sgot->size;
8415                   htab->root.sgot->size += GOT_ENTRY_SIZE;
8416                 }
8417
8418               if (got_type == GOT_UNKNOWN)
8419                 {
8420                 }
8421
8422               if (bfd_link_pic (info))
8423                 {
8424                   if (got_type & GOT_TLSDESC_GD)
8425                     {
8426                       htab->root.srelplt->size += RELOC_SIZE (htab);
8427                       /* Note RELOC_COUNT not incremented here! */
8428                       htab->tlsdesc_plt = (bfd_vma) - 1;
8429                     }
8430
8431                   if (got_type & GOT_TLS_GD)
8432                     htab->root.srelgot->size += RELOC_SIZE (htab) * 2;
8433
8434                   if (got_type & GOT_TLS_IE
8435                       || got_type & GOT_NORMAL)
8436                     htab->root.srelgot->size += RELOC_SIZE (htab);
8437                 }
8438             }
8439           else
8440             {
8441               locals[i].got_refcount = (bfd_vma) - 1;
8442             }
8443         }
8444     }
8445
8446
8447   /* Allocate global sym .plt and .got entries, and space for global
8448      sym dynamic relocs.  */
8449   elf_link_hash_traverse (&htab->root, elfNN_aarch64_allocate_dynrelocs,
8450                           info);
8451
8452   /* Allocate global ifunc sym .plt and .got entries, and space for global
8453      ifunc sym dynamic relocs.  */
8454   elf_link_hash_traverse (&htab->root, elfNN_aarch64_allocate_ifunc_dynrelocs,
8455                           info);
8456
8457   /* Allocate .plt and .got entries, and space for local symbols.  */
8458   htab_traverse (htab->loc_hash_table,
8459                  elfNN_aarch64_allocate_local_dynrelocs,
8460                  info);
8461
8462   /* Allocate .plt and .got entries, and space for local ifunc symbols.  */
8463   htab_traverse (htab->loc_hash_table,
8464                  elfNN_aarch64_allocate_local_ifunc_dynrelocs,
8465                  info);
8466
8467   /* For every jump slot reserved in the sgotplt, reloc_count is
8468      incremented.  However, when we reserve space for TLS descriptors,
8469      it's not incremented, so in order to compute the space reserved
8470      for them, it suffices to multiply the reloc count by the jump
8471      slot size.  */
8472
8473   if (htab->root.srelplt)
8474     htab->sgotplt_jump_table_size = aarch64_compute_jump_table_size (htab);
8475
8476   if (htab->tlsdesc_plt)
8477     {
8478       if (htab->root.splt->size == 0)
8479         htab->root.splt->size += PLT_ENTRY_SIZE;
8480
8481       htab->tlsdesc_plt = htab->root.splt->size;
8482       htab->root.splt->size += PLT_TLSDESC_ENTRY_SIZE;
8483
8484       /* If we're not using lazy TLS relocations, don't generate the
8485          GOT entry required.  */
8486       if (!(info->flags & DF_BIND_NOW))
8487         {
8488           htab->dt_tlsdesc_got = htab->root.sgot->size;
8489           htab->root.sgot->size += GOT_ENTRY_SIZE;
8490         }
8491     }
8492
8493   /* Init mapping symbols information to use later to distingush between
8494      code and data while scanning for errata.  */
8495   if (htab->fix_erratum_835769 || htab->fix_erratum_843419)
8496     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8497       {
8498         if (!is_aarch64_elf (ibfd))
8499           continue;
8500         bfd_elfNN_aarch64_init_maps (ibfd);
8501       }
8502
8503   /* We now have determined the sizes of the various dynamic sections.
8504      Allocate memory for them.  */
8505   relocs = FALSE;
8506   for (s = dynobj->sections; s != NULL; s = s->next)
8507     {
8508       if ((s->flags & SEC_LINKER_CREATED) == 0)
8509         continue;
8510
8511       if (s == htab->root.splt
8512           || s == htab->root.sgot
8513           || s == htab->root.sgotplt
8514           || s == htab->root.iplt
8515           || s == htab->root.igotplt || s == htab->sdynbss)
8516         {
8517           /* Strip this section if we don't need it; see the
8518              comment below.  */
8519         }
8520       else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
8521         {
8522           if (s->size != 0 && s != htab->root.srelplt)
8523             relocs = TRUE;
8524
8525           /* We use the reloc_count field as a counter if we need
8526              to copy relocs into the output file.  */
8527           if (s != htab->root.srelplt)
8528             s->reloc_count = 0;
8529         }
8530       else
8531         {
8532           /* It's not one of our sections, so don't allocate space.  */
8533           continue;
8534         }
8535
8536       if (s->size == 0)
8537         {
8538           /* If we don't need this section, strip it from the
8539              output file.  This is mostly to handle .rela.bss and
8540              .rela.plt.  We must create both sections in
8541              create_dynamic_sections, because they must be created
8542              before the linker maps input sections to output
8543              sections.  The linker does that before
8544              adjust_dynamic_symbol is called, and it is that
8545              function which decides whether anything needs to go
8546              into these sections.  */
8547
8548           s->flags |= SEC_EXCLUDE;
8549           continue;
8550         }
8551
8552       if ((s->flags & SEC_HAS_CONTENTS) == 0)
8553         continue;
8554
8555       /* Allocate memory for the section contents.  We use bfd_zalloc
8556          here in case unused entries are not reclaimed before the
8557          section's contents are written out.  This should not happen,
8558          but this way if it does, we get a R_AARCH64_NONE reloc instead
8559          of garbage.  */
8560       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
8561       if (s->contents == NULL)
8562         return FALSE;
8563     }
8564
8565   if (htab->root.dynamic_sections_created)
8566     {
8567       /* Add some entries to the .dynamic section.  We fill in the
8568          values later, in elfNN_aarch64_finish_dynamic_sections, but we
8569          must add the entries now so that we get the correct size for
8570          the .dynamic section.  The DT_DEBUG entry is filled in by the
8571          dynamic linker and used by the debugger.  */
8572 #define add_dynamic_entry(TAG, VAL)                     \
8573       _bfd_elf_add_dynamic_entry (info, TAG, VAL)
8574
8575       if (bfd_link_executable (info))
8576         {
8577           if (!add_dynamic_entry (DT_DEBUG, 0))
8578             return FALSE;
8579         }
8580
8581       if (htab->root.splt->size != 0)
8582         {
8583           if (!add_dynamic_entry (DT_PLTGOT, 0)
8584               || !add_dynamic_entry (DT_PLTRELSZ, 0)
8585               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
8586               || !add_dynamic_entry (DT_JMPREL, 0))
8587             return FALSE;
8588
8589           if (htab->tlsdesc_plt
8590               && (!add_dynamic_entry (DT_TLSDESC_PLT, 0)
8591                   || !add_dynamic_entry (DT_TLSDESC_GOT, 0)))
8592             return FALSE;
8593         }
8594
8595       if (relocs)
8596         {
8597           if (!add_dynamic_entry (DT_RELA, 0)
8598               || !add_dynamic_entry (DT_RELASZ, 0)
8599               || !add_dynamic_entry (DT_RELAENT, RELOC_SIZE (htab)))
8600             return FALSE;
8601
8602           /* If any dynamic relocs apply to a read-only section,
8603              then we need a DT_TEXTREL entry.  */
8604           if ((info->flags & DF_TEXTREL) == 0)
8605             elf_link_hash_traverse (& htab->root, aarch64_readonly_dynrelocs,
8606                                     info);
8607
8608           if ((info->flags & DF_TEXTREL) != 0)
8609             {
8610               if (!add_dynamic_entry (DT_TEXTREL, 0))
8611                 return FALSE;
8612             }
8613         }
8614     }
8615 #undef add_dynamic_entry
8616
8617   return TRUE;
8618 }
8619
8620 static inline void
8621 elf_aarch64_update_plt_entry (bfd *output_bfd,
8622                               bfd_reloc_code_real_type r_type,
8623                               bfd_byte *plt_entry, bfd_vma value)
8624 {
8625   reloc_howto_type *howto = elfNN_aarch64_howto_from_bfd_reloc (r_type);
8626
8627   _bfd_aarch64_elf_put_addend (output_bfd, plt_entry, r_type, howto, value);
8628 }
8629
8630 static void
8631 elfNN_aarch64_create_small_pltn_entry (struct elf_link_hash_entry *h,
8632                                        struct elf_aarch64_link_hash_table
8633                                        *htab, bfd *output_bfd,
8634                                        struct bfd_link_info *info)
8635 {
8636   bfd_byte *plt_entry;
8637   bfd_vma plt_index;
8638   bfd_vma got_offset;
8639   bfd_vma gotplt_entry_address;
8640   bfd_vma plt_entry_address;
8641   Elf_Internal_Rela rela;
8642   bfd_byte *loc;
8643   asection *plt, *gotplt, *relplt;
8644
8645   /* When building a static executable, use .iplt, .igot.plt and
8646      .rela.iplt sections for STT_GNU_IFUNC symbols.  */
8647   if (htab->root.splt != NULL)
8648     {
8649       plt = htab->root.splt;
8650       gotplt = htab->root.sgotplt;
8651       relplt = htab->root.srelplt;
8652     }
8653   else
8654     {
8655       plt = htab->root.iplt;
8656       gotplt = htab->root.igotplt;
8657       relplt = htab->root.irelplt;
8658     }
8659
8660   /* Get the index in the procedure linkage table which
8661      corresponds to this symbol.  This is the index of this symbol
8662      in all the symbols for which we are making plt entries.  The
8663      first entry in the procedure linkage table is reserved.
8664
8665      Get the offset into the .got table of the entry that
8666      corresponds to this function.      Each .got entry is GOT_ENTRY_SIZE
8667      bytes. The first three are reserved for the dynamic linker.
8668
8669      For static executables, we don't reserve anything.  */
8670
8671   if (plt == htab->root.splt)
8672     {
8673       plt_index = (h->plt.offset - htab->plt_header_size) / htab->plt_entry_size;
8674       got_offset = (plt_index + 3) * GOT_ENTRY_SIZE;
8675     }
8676   else
8677     {
8678       plt_index = h->plt.offset / htab->plt_entry_size;
8679       got_offset = plt_index * GOT_ENTRY_SIZE;
8680     }
8681
8682   plt_entry = plt->contents + h->plt.offset;
8683   plt_entry_address = plt->output_section->vma
8684     + plt->output_offset + h->plt.offset;
8685   gotplt_entry_address = gotplt->output_section->vma +
8686     gotplt->output_offset + got_offset;
8687
8688   /* Copy in the boiler-plate for the PLTn entry.  */
8689   memcpy (plt_entry, elfNN_aarch64_small_plt_entry, PLT_SMALL_ENTRY_SIZE);
8690
8691   /* Fill in the top 21 bits for this: ADRP x16, PLT_GOT + n * 8.
8692      ADRP:   ((PG(S+A)-PG(P)) >> 12) & 0x1fffff */
8693   elf_aarch64_update_plt_entry (output_bfd, BFD_RELOC_AARCH64_ADR_HI21_PCREL,
8694                                 plt_entry,
8695                                 PG (gotplt_entry_address) -
8696                                 PG (plt_entry_address));
8697
8698   /* Fill in the lo12 bits for the load from the pltgot.  */
8699   elf_aarch64_update_plt_entry (output_bfd, BFD_RELOC_AARCH64_LDSTNN_LO12,
8700                                 plt_entry + 4,
8701                                 PG_OFFSET (gotplt_entry_address));
8702
8703   /* Fill in the lo12 bits for the add from the pltgot entry.  */
8704   elf_aarch64_update_plt_entry (output_bfd, BFD_RELOC_AARCH64_ADD_LO12,
8705                                 plt_entry + 8,
8706                                 PG_OFFSET (gotplt_entry_address));
8707
8708   /* All the GOTPLT Entries are essentially initialized to PLT0.  */
8709   bfd_put_NN (output_bfd,
8710               plt->output_section->vma + plt->output_offset,
8711               gotplt->contents + got_offset);
8712
8713   rela.r_offset = gotplt_entry_address;
8714
8715   if (h->dynindx == -1
8716       || ((bfd_link_executable (info)
8717            || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
8718           && h->def_regular
8719           && h->type == STT_GNU_IFUNC))
8720     {
8721       /* If an STT_GNU_IFUNC symbol is locally defined, generate
8722          R_AARCH64_IRELATIVE instead of R_AARCH64_JUMP_SLOT.  */
8723       rela.r_info = ELFNN_R_INFO (0, AARCH64_R (IRELATIVE));
8724       rela.r_addend = (h->root.u.def.value
8725                        + h->root.u.def.section->output_section->vma
8726                        + h->root.u.def.section->output_offset);
8727     }
8728   else
8729     {
8730       /* Fill in the entry in the .rela.plt section.  */
8731       rela.r_info = ELFNN_R_INFO (h->dynindx, AARCH64_R (JUMP_SLOT));
8732       rela.r_addend = 0;
8733     }
8734
8735   /* Compute the relocation entry to used based on PLT index and do
8736      not adjust reloc_count. The reloc_count has already been adjusted
8737      to account for this entry.  */
8738   loc = relplt->contents + plt_index * RELOC_SIZE (htab);
8739   bfd_elfNN_swap_reloca_out (output_bfd, &rela, loc);
8740 }
8741
8742 /* Size sections even though they're not dynamic.  We use it to setup
8743    _TLS_MODULE_BASE_, if needed.  */
8744
8745 static bfd_boolean
8746 elfNN_aarch64_always_size_sections (bfd *output_bfd,
8747                                     struct bfd_link_info *info)
8748 {
8749   asection *tls_sec;
8750
8751   if (bfd_link_relocatable (info))
8752     return TRUE;
8753
8754   tls_sec = elf_hash_table (info)->tls_sec;
8755
8756   if (tls_sec)
8757     {
8758       struct elf_link_hash_entry *tlsbase;
8759
8760       tlsbase = elf_link_hash_lookup (elf_hash_table (info),
8761                                       "_TLS_MODULE_BASE_", TRUE, TRUE, FALSE);
8762
8763       if (tlsbase)
8764         {
8765           struct bfd_link_hash_entry *h = NULL;
8766           const struct elf_backend_data *bed =
8767             get_elf_backend_data (output_bfd);
8768
8769           if (!(_bfd_generic_link_add_one_symbol
8770                 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
8771                  tls_sec, 0, NULL, FALSE, bed->collect, &h)))
8772             return FALSE;
8773
8774           tlsbase->type = STT_TLS;
8775           tlsbase = (struct elf_link_hash_entry *) h;
8776           tlsbase->def_regular = 1;
8777           tlsbase->other = STV_HIDDEN;
8778           (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
8779         }
8780     }
8781
8782   return TRUE;
8783 }
8784
8785 /* Finish up dynamic symbol handling.  We set the contents of various
8786    dynamic sections here.  */
8787 static bfd_boolean
8788 elfNN_aarch64_finish_dynamic_symbol (bfd *output_bfd,
8789                                      struct bfd_link_info *info,
8790                                      struct elf_link_hash_entry *h,
8791                                      Elf_Internal_Sym *sym)
8792 {
8793   struct elf_aarch64_link_hash_table *htab;
8794   htab = elf_aarch64_hash_table (info);
8795
8796   if (h->plt.offset != (bfd_vma) - 1)
8797     {
8798       asection *plt, *gotplt, *relplt;
8799
8800       /* This symbol has an entry in the procedure linkage table.  Set
8801          it up.  */
8802
8803       /* When building a static executable, use .iplt, .igot.plt and
8804          .rela.iplt sections for STT_GNU_IFUNC symbols.  */
8805       if (htab->root.splt != NULL)
8806         {
8807           plt = htab->root.splt;
8808           gotplt = htab->root.sgotplt;
8809           relplt = htab->root.srelplt;
8810         }
8811       else
8812         {
8813           plt = htab->root.iplt;
8814           gotplt = htab->root.igotplt;
8815           relplt = htab->root.irelplt;
8816         }
8817
8818       /* This symbol has an entry in the procedure linkage table.  Set
8819          it up.  */
8820       if ((h->dynindx == -1
8821            && !((h->forced_local || bfd_link_executable (info))
8822                 && h->def_regular
8823                 && h->type == STT_GNU_IFUNC))
8824           || plt == NULL
8825           || gotplt == NULL
8826           || relplt == NULL)
8827         abort ();
8828
8829       elfNN_aarch64_create_small_pltn_entry (h, htab, output_bfd, info);
8830       if (!h->def_regular)
8831         {
8832           /* Mark the symbol as undefined, rather than as defined in
8833              the .plt section.  */
8834           sym->st_shndx = SHN_UNDEF;
8835           /* If the symbol is weak we need to clear the value.
8836              Otherwise, the PLT entry would provide a definition for
8837              the symbol even if the symbol wasn't defined anywhere,
8838              and so the symbol would never be NULL.  Leave the value if
8839              there were any relocations where pointer equality matters
8840              (this is a clue for the dynamic linker, to make function
8841              pointer comparisons work between an application and shared
8842              library).  */
8843           if (!h->ref_regular_nonweak || !h->pointer_equality_needed)
8844             sym->st_value = 0;
8845         }
8846     }
8847
8848   if (h->got.offset != (bfd_vma) - 1
8849       && elf_aarch64_hash_entry (h)->got_type == GOT_NORMAL)
8850     {
8851       Elf_Internal_Rela rela;
8852       bfd_byte *loc;
8853
8854       /* This symbol has an entry in the global offset table.  Set it
8855          up.  */
8856       if (htab->root.sgot == NULL || htab->root.srelgot == NULL)
8857         abort ();
8858
8859       rela.r_offset = (htab->root.sgot->output_section->vma
8860                        + htab->root.sgot->output_offset
8861                        + (h->got.offset & ~(bfd_vma) 1));
8862
8863       if (h->def_regular
8864           && h->type == STT_GNU_IFUNC)
8865         {
8866           if (bfd_link_pic (info))
8867             {
8868               /* Generate R_AARCH64_GLOB_DAT.  */
8869               goto do_glob_dat;
8870             }
8871           else
8872             {
8873               asection *plt;
8874
8875               if (!h->pointer_equality_needed)
8876                 abort ();
8877
8878               /* For non-shared object, we can't use .got.plt, which
8879                  contains the real function address if we need pointer
8880                  equality.  We load the GOT entry with the PLT entry.  */
8881               plt = htab->root.splt ? htab->root.splt : htab->root.iplt;
8882               bfd_put_NN (output_bfd, (plt->output_section->vma
8883                                        + plt->output_offset
8884                                        + h->plt.offset),
8885                           htab->root.sgot->contents
8886                           + (h->got.offset & ~(bfd_vma) 1));
8887               return TRUE;
8888             }
8889         }
8890       else if (bfd_link_pic (info) && SYMBOL_REFERENCES_LOCAL (info, h))
8891         {
8892           if (!h->def_regular)
8893             return FALSE;
8894
8895           BFD_ASSERT ((h->got.offset & 1) != 0);
8896           rela.r_info = ELFNN_R_INFO (0, AARCH64_R (RELATIVE));
8897           rela.r_addend = (h->root.u.def.value
8898                            + h->root.u.def.section->output_section->vma
8899                            + h->root.u.def.section->output_offset);
8900         }
8901       else
8902         {
8903 do_glob_dat:
8904           BFD_ASSERT ((h->got.offset & 1) == 0);
8905           bfd_put_NN (output_bfd, (bfd_vma) 0,
8906                       htab->root.sgot->contents + h->got.offset);
8907           rela.r_info = ELFNN_R_INFO (h->dynindx, AARCH64_R (GLOB_DAT));
8908           rela.r_addend = 0;
8909         }
8910
8911       loc = htab->root.srelgot->contents;
8912       loc += htab->root.srelgot->reloc_count++ * RELOC_SIZE (htab);
8913       bfd_elfNN_swap_reloca_out (output_bfd, &rela, loc);
8914     }
8915
8916   if (h->needs_copy)
8917     {
8918       Elf_Internal_Rela rela;
8919       bfd_byte *loc;
8920
8921       /* This symbol needs a copy reloc.  Set it up.  */
8922
8923       if (h->dynindx == -1
8924           || (h->root.type != bfd_link_hash_defined
8925               && h->root.type != bfd_link_hash_defweak)
8926           || htab->srelbss == NULL)
8927         abort ();
8928
8929       rela.r_offset = (h->root.u.def.value
8930                        + h->root.u.def.section->output_section->vma
8931                        + h->root.u.def.section->output_offset);
8932       rela.r_info = ELFNN_R_INFO (h->dynindx, AARCH64_R (COPY));
8933       rela.r_addend = 0;
8934       loc = htab->srelbss->contents;
8935       loc += htab->srelbss->reloc_count++ * RELOC_SIZE (htab);
8936       bfd_elfNN_swap_reloca_out (output_bfd, &rela, loc);
8937     }
8938
8939   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  SYM may
8940      be NULL for local symbols.  */
8941   if (sym != NULL
8942       && (h == elf_hash_table (info)->hdynamic
8943           || h == elf_hash_table (info)->hgot))
8944     sym->st_shndx = SHN_ABS;
8945
8946   return TRUE;
8947 }
8948
8949 /* Finish up local dynamic symbol handling.  We set the contents of
8950    various dynamic sections here.  */
8951
8952 static bfd_boolean
8953 elfNN_aarch64_finish_local_dynamic_symbol (void **slot, void *inf)
8954 {
8955   struct elf_link_hash_entry *h
8956     = (struct elf_link_hash_entry *) *slot;
8957   struct bfd_link_info *info
8958     = (struct bfd_link_info *) inf;
8959
8960   return elfNN_aarch64_finish_dynamic_symbol (info->output_bfd,
8961                                               info, h, NULL);
8962 }
8963
8964 static void
8965 elfNN_aarch64_init_small_plt0_entry (bfd *output_bfd ATTRIBUTE_UNUSED,
8966                                      struct elf_aarch64_link_hash_table
8967                                      *htab)
8968 {
8969   /* Fill in PLT0. Fixme:RR Note this doesn't distinguish between
8970      small and large plts and at the minute just generates
8971      the small PLT.  */
8972
8973   /* PLT0 of the small PLT looks like this in ELF64 -
8974      stp x16, x30, [sp, #-16]!          // Save the reloc and lr on stack.
8975      adrp x16, PLT_GOT + 16             // Get the page base of the GOTPLT
8976      ldr  x17, [x16, #:lo12:PLT_GOT+16] // Load the address of the
8977                                         // symbol resolver
8978      add  x16, x16, #:lo12:PLT_GOT+16   // Load the lo12 bits of the
8979                                         // GOTPLT entry for this.
8980      br   x17
8981      PLT0 will be slightly different in ELF32 due to different got entry
8982      size.
8983    */
8984   bfd_vma plt_got_2nd_ent;      /* Address of GOT[2].  */
8985   bfd_vma plt_base;
8986
8987
8988   memcpy (htab->root.splt->contents, elfNN_aarch64_small_plt0_entry,
8989           PLT_ENTRY_SIZE);
8990   elf_section_data (htab->root.splt->output_section)->this_hdr.sh_entsize =
8991     PLT_ENTRY_SIZE;
8992
8993   plt_got_2nd_ent = (htab->root.sgotplt->output_section->vma
8994                   + htab->root.sgotplt->output_offset
8995                   + GOT_ENTRY_SIZE * 2);
8996
8997   plt_base = htab->root.splt->output_section->vma +
8998     htab->root.splt->output_offset;
8999
9000   /* Fill in the top 21 bits for this: ADRP x16, PLT_GOT + n * 8.
9001      ADRP:   ((PG(S+A)-PG(P)) >> 12) & 0x1fffff */
9002   elf_aarch64_update_plt_entry (output_bfd, BFD_RELOC_AARCH64_ADR_HI21_PCREL,
9003                                 htab->root.splt->contents + 4,
9004                                 PG (plt_got_2nd_ent) - PG (plt_base + 4));
9005
9006   elf_aarch64_update_plt_entry (output_bfd, BFD_RELOC_AARCH64_LDSTNN_LO12,
9007                                 htab->root.splt->contents + 8,
9008                                 PG_OFFSET (plt_got_2nd_ent));
9009
9010   elf_aarch64_update_plt_entry (output_bfd, BFD_RELOC_AARCH64_ADD_LO12,
9011                                 htab->root.splt->contents + 12,
9012                                 PG_OFFSET (plt_got_2nd_ent));
9013 }
9014
9015 static bfd_boolean
9016 elfNN_aarch64_finish_dynamic_sections (bfd *output_bfd,
9017                                        struct bfd_link_info *info)
9018 {
9019   struct elf_aarch64_link_hash_table *htab;
9020   bfd *dynobj;
9021   asection *sdyn;
9022
9023   htab = elf_aarch64_hash_table (info);
9024   dynobj = htab->root.dynobj;
9025   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
9026
9027   if (htab->root.dynamic_sections_created)
9028     {
9029       ElfNN_External_Dyn *dyncon, *dynconend;
9030
9031       if (sdyn == NULL || htab->root.sgot == NULL)
9032         abort ();
9033
9034       dyncon = (ElfNN_External_Dyn *) sdyn->contents;
9035       dynconend = (ElfNN_External_Dyn *) (sdyn->contents + sdyn->size);
9036       for (; dyncon < dynconend; dyncon++)
9037         {
9038           Elf_Internal_Dyn dyn;
9039           asection *s;
9040
9041           bfd_elfNN_swap_dyn_in (dynobj, dyncon, &dyn);
9042
9043           switch (dyn.d_tag)
9044             {
9045             default:
9046               continue;
9047
9048             case DT_PLTGOT:
9049               s = htab->root.sgotplt;
9050               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
9051               break;
9052
9053             case DT_JMPREL:
9054               s = htab->root.srelplt;
9055               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
9056               break;
9057
9058             case DT_PLTRELSZ:
9059               s = htab->root.srelplt;
9060               dyn.d_un.d_val = s->size;
9061               break;
9062
9063             case DT_RELASZ:
9064               /* The procedure linkage table relocs (DT_JMPREL) should
9065                  not be included in the overall relocs (DT_RELA).
9066                  Therefore, we override the DT_RELASZ entry here to
9067                  make it not include the JMPREL relocs.  Since the
9068                  linker script arranges for .rela.plt to follow all
9069                  other relocation sections, we don't have to worry
9070                  about changing the DT_RELA entry.  */
9071               if (htab->root.srelplt != NULL)
9072                 {
9073                   s = htab->root.srelplt;
9074                   dyn.d_un.d_val -= s->size;
9075                 }
9076               break;
9077
9078             case DT_TLSDESC_PLT:
9079               s = htab->root.splt;
9080               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
9081                 + htab->tlsdesc_plt;
9082               break;
9083
9084             case DT_TLSDESC_GOT:
9085               s = htab->root.sgot;
9086               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
9087                 + htab->dt_tlsdesc_got;
9088               break;
9089             }
9090
9091           bfd_elfNN_swap_dyn_out (output_bfd, &dyn, dyncon);
9092         }
9093
9094     }
9095
9096   /* Fill in the special first entry in the procedure linkage table.  */
9097   if (htab->root.splt && htab->root.splt->size > 0)
9098     {
9099       elfNN_aarch64_init_small_plt0_entry (output_bfd, htab);
9100
9101       elf_section_data (htab->root.splt->output_section)->
9102         this_hdr.sh_entsize = htab->plt_entry_size;
9103
9104
9105       if (htab->tlsdesc_plt)
9106         {
9107           bfd_put_NN (output_bfd, (bfd_vma) 0,
9108                       htab->root.sgot->contents + htab->dt_tlsdesc_got);
9109
9110           memcpy (htab->root.splt->contents + htab->tlsdesc_plt,
9111                   elfNN_aarch64_tlsdesc_small_plt_entry,
9112                   sizeof (elfNN_aarch64_tlsdesc_small_plt_entry));
9113
9114           {
9115             bfd_vma adrp1_addr =
9116               htab->root.splt->output_section->vma
9117               + htab->root.splt->output_offset + htab->tlsdesc_plt + 4;
9118
9119             bfd_vma adrp2_addr = adrp1_addr + 4;
9120
9121             bfd_vma got_addr =
9122               htab->root.sgot->output_section->vma
9123               + htab->root.sgot->output_offset;
9124
9125             bfd_vma pltgot_addr =
9126               htab->root.sgotplt->output_section->vma
9127               + htab->root.sgotplt->output_offset;
9128
9129             bfd_vma dt_tlsdesc_got = got_addr + htab->dt_tlsdesc_got;
9130
9131             bfd_byte *plt_entry =
9132               htab->root.splt->contents + htab->tlsdesc_plt;
9133
9134             /* adrp x2, DT_TLSDESC_GOT */
9135             elf_aarch64_update_plt_entry (output_bfd,
9136                                           BFD_RELOC_AARCH64_ADR_HI21_PCREL,
9137                                           plt_entry + 4,
9138                                           (PG (dt_tlsdesc_got)
9139                                            - PG (adrp1_addr)));
9140
9141             /* adrp x3, 0 */
9142             elf_aarch64_update_plt_entry (output_bfd,
9143                                           BFD_RELOC_AARCH64_ADR_HI21_PCREL,
9144                                           plt_entry + 8,
9145                                           (PG (pltgot_addr)
9146                                            - PG (adrp2_addr)));
9147
9148             /* ldr x2, [x2, #0] */
9149             elf_aarch64_update_plt_entry (output_bfd,
9150                                           BFD_RELOC_AARCH64_LDSTNN_LO12,
9151                                           plt_entry + 12,
9152                                           PG_OFFSET (dt_tlsdesc_got));
9153
9154             /* add x3, x3, 0 */
9155             elf_aarch64_update_plt_entry (output_bfd,
9156                                           BFD_RELOC_AARCH64_ADD_LO12,
9157                                           plt_entry + 16,
9158                                           PG_OFFSET (pltgot_addr));
9159           }
9160         }
9161     }
9162
9163   if (htab->root.sgotplt)
9164     {
9165       if (bfd_is_abs_section (htab->root.sgotplt->output_section))
9166         {
9167           (*_bfd_error_handler)
9168             (_("discarded output section: `%A'"), htab->root.sgotplt);
9169           return FALSE;
9170         }
9171
9172       /* Fill in the first three entries in the global offset table.  */
9173       if (htab->root.sgotplt->size > 0)
9174         {
9175           bfd_put_NN (output_bfd, (bfd_vma) 0, htab->root.sgotplt->contents);
9176
9177           /* Write GOT[1] and GOT[2], needed for the dynamic linker.  */
9178           bfd_put_NN (output_bfd,
9179                       (bfd_vma) 0,
9180                       htab->root.sgotplt->contents + GOT_ENTRY_SIZE);
9181           bfd_put_NN (output_bfd,
9182                       (bfd_vma) 0,
9183                       htab->root.sgotplt->contents + GOT_ENTRY_SIZE * 2);
9184         }
9185
9186       if (htab->root.sgot)
9187         {
9188           if (htab->root.sgot->size > 0)
9189             {
9190               bfd_vma addr =
9191                 sdyn ? sdyn->output_section->vma + sdyn->output_offset : 0;
9192               bfd_put_NN (output_bfd, addr, htab->root.sgot->contents);
9193             }
9194         }
9195
9196       elf_section_data (htab->root.sgotplt->output_section)->
9197         this_hdr.sh_entsize = GOT_ENTRY_SIZE;
9198     }
9199
9200   if (htab->root.sgot && htab->root.sgot->size > 0)
9201     elf_section_data (htab->root.sgot->output_section)->this_hdr.sh_entsize
9202       = GOT_ENTRY_SIZE;
9203
9204   /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols.  */
9205   htab_traverse (htab->loc_hash_table,
9206                  elfNN_aarch64_finish_local_dynamic_symbol,
9207                  info);
9208
9209   return TRUE;
9210 }
9211
9212 /* Return address for Ith PLT stub in section PLT, for relocation REL
9213    or (bfd_vma) -1 if it should not be included.  */
9214
9215 static bfd_vma
9216 elfNN_aarch64_plt_sym_val (bfd_vma i, const asection *plt,
9217                            const arelent *rel ATTRIBUTE_UNUSED)
9218 {
9219   return plt->vma + PLT_ENTRY_SIZE + i * PLT_SMALL_ENTRY_SIZE;
9220 }
9221
9222
9223 /* We use this so we can override certain functions
9224    (though currently we don't).  */
9225
9226 const struct elf_size_info elfNN_aarch64_size_info =
9227 {
9228   sizeof (ElfNN_External_Ehdr),
9229   sizeof (ElfNN_External_Phdr),
9230   sizeof (ElfNN_External_Shdr),
9231   sizeof (ElfNN_External_Rel),
9232   sizeof (ElfNN_External_Rela),
9233   sizeof (ElfNN_External_Sym),
9234   sizeof (ElfNN_External_Dyn),
9235   sizeof (Elf_External_Note),
9236   4,                            /* Hash table entry size.  */
9237   1,                            /* Internal relocs per external relocs.  */
9238   ARCH_SIZE,                    /* Arch size.  */
9239   LOG_FILE_ALIGN,               /* Log_file_align.  */
9240   ELFCLASSNN, EV_CURRENT,
9241   bfd_elfNN_write_out_phdrs,
9242   bfd_elfNN_write_shdrs_and_ehdr,
9243   bfd_elfNN_checksum_contents,
9244   bfd_elfNN_write_relocs,
9245   bfd_elfNN_swap_symbol_in,
9246   bfd_elfNN_swap_symbol_out,
9247   bfd_elfNN_slurp_reloc_table,
9248   bfd_elfNN_slurp_symbol_table,
9249   bfd_elfNN_swap_dyn_in,
9250   bfd_elfNN_swap_dyn_out,
9251   bfd_elfNN_swap_reloc_in,
9252   bfd_elfNN_swap_reloc_out,
9253   bfd_elfNN_swap_reloca_in,
9254   bfd_elfNN_swap_reloca_out
9255 };
9256
9257 #define ELF_ARCH                        bfd_arch_aarch64
9258 #define ELF_MACHINE_CODE                EM_AARCH64
9259 #define ELF_MAXPAGESIZE                 0x10000
9260 #define ELF_MINPAGESIZE                 0x1000
9261 #define ELF_COMMONPAGESIZE              0x1000
9262
9263 #define bfd_elfNN_close_and_cleanup             \
9264   elfNN_aarch64_close_and_cleanup
9265
9266 #define bfd_elfNN_bfd_free_cached_info          \
9267   elfNN_aarch64_bfd_free_cached_info
9268
9269 #define bfd_elfNN_bfd_is_target_special_symbol  \
9270   elfNN_aarch64_is_target_special_symbol
9271
9272 #define bfd_elfNN_bfd_link_hash_table_create    \
9273   elfNN_aarch64_link_hash_table_create
9274
9275 #define bfd_elfNN_bfd_merge_private_bfd_data    \
9276   elfNN_aarch64_merge_private_bfd_data
9277
9278 #define bfd_elfNN_bfd_print_private_bfd_data    \
9279   elfNN_aarch64_print_private_bfd_data
9280
9281 #define bfd_elfNN_bfd_reloc_type_lookup         \
9282   elfNN_aarch64_reloc_type_lookup
9283
9284 #define bfd_elfNN_bfd_reloc_name_lookup         \
9285   elfNN_aarch64_reloc_name_lookup
9286
9287 #define bfd_elfNN_bfd_set_private_flags         \
9288   elfNN_aarch64_set_private_flags
9289
9290 #define bfd_elfNN_find_inliner_info             \
9291   elfNN_aarch64_find_inliner_info
9292
9293 #define bfd_elfNN_find_nearest_line             \
9294   elfNN_aarch64_find_nearest_line
9295
9296 #define bfd_elfNN_mkobject                      \
9297   elfNN_aarch64_mkobject
9298
9299 #define bfd_elfNN_new_section_hook              \
9300   elfNN_aarch64_new_section_hook
9301
9302 #define elf_backend_adjust_dynamic_symbol       \
9303   elfNN_aarch64_adjust_dynamic_symbol
9304
9305 #define elf_backend_always_size_sections        \
9306   elfNN_aarch64_always_size_sections
9307
9308 #define elf_backend_check_relocs                \
9309   elfNN_aarch64_check_relocs
9310
9311 #define elf_backend_copy_indirect_symbol        \
9312   elfNN_aarch64_copy_indirect_symbol
9313
9314 /* Create .dynbss, and .rela.bss sections in DYNOBJ, and set up shortcuts
9315    to them in our hash.  */
9316 #define elf_backend_create_dynamic_sections     \
9317   elfNN_aarch64_create_dynamic_sections
9318
9319 #define elf_backend_init_index_section          \
9320   _bfd_elf_init_2_index_sections
9321
9322 #define elf_backend_finish_dynamic_sections     \
9323   elfNN_aarch64_finish_dynamic_sections
9324
9325 #define elf_backend_finish_dynamic_symbol       \
9326   elfNN_aarch64_finish_dynamic_symbol
9327
9328 #define elf_backend_gc_sweep_hook               \
9329   elfNN_aarch64_gc_sweep_hook
9330
9331 #define elf_backend_object_p                    \
9332   elfNN_aarch64_object_p
9333
9334 #define elf_backend_output_arch_local_syms      \
9335   elfNN_aarch64_output_arch_local_syms
9336
9337 #define elf_backend_plt_sym_val                 \
9338   elfNN_aarch64_plt_sym_val
9339
9340 #define elf_backend_post_process_headers        \
9341   elfNN_aarch64_post_process_headers
9342
9343 #define elf_backend_relocate_section            \
9344   elfNN_aarch64_relocate_section
9345
9346 #define elf_backend_reloc_type_class            \
9347   elfNN_aarch64_reloc_type_class
9348
9349 #define elf_backend_section_from_shdr           \
9350   elfNN_aarch64_section_from_shdr
9351
9352 #define elf_backend_size_dynamic_sections       \
9353   elfNN_aarch64_size_dynamic_sections
9354
9355 #define elf_backend_size_info                   \
9356   elfNN_aarch64_size_info
9357
9358 #define elf_backend_write_section               \
9359   elfNN_aarch64_write_section
9360
9361 #define elf_backend_can_refcount       1
9362 #define elf_backend_can_gc_sections    1
9363 #define elf_backend_plt_readonly       1
9364 #define elf_backend_want_got_plt       1
9365 #define elf_backend_want_plt_sym       0
9366 #define elf_backend_may_use_rel_p      0
9367 #define elf_backend_may_use_rela_p     1
9368 #define elf_backend_default_use_rela_p 1
9369 #define elf_backend_rela_normal        1
9370 #define elf_backend_got_header_size (GOT_ENTRY_SIZE * 3)
9371 #define elf_backend_default_execstack  0
9372 #define elf_backend_extern_protected_data 1
9373
9374 #undef  elf_backend_obj_attrs_section
9375 #define elf_backend_obj_attrs_section           ".ARM.attributes"
9376
9377 #include "elfNN-target.h"
9378
9379 /* CloudABI support.  */
9380
9381 #undef  TARGET_LITTLE_SYM
9382 #define TARGET_LITTLE_SYM       aarch64_elfNN_le_cloudabi_vec
9383 #undef  TARGET_LITTLE_NAME
9384 #define TARGET_LITTLE_NAME      "elfNN-littleaarch64-cloudabi"
9385 #undef  TARGET_BIG_SYM
9386 #define TARGET_BIG_SYM          aarch64_elfNN_be_cloudabi_vec
9387 #undef  TARGET_BIG_NAME
9388 #define TARGET_BIG_NAME         "elfNN-bigaarch64-cloudabi"
9389
9390 #undef  ELF_OSABI
9391 #define ELF_OSABI               ELFOSABI_CLOUDABI
9392
9393 #undef  elfNN_bed
9394 #define elfNN_bed               elfNN_aarch64_cloudabi_bed
9395
9396 #include "elfNN-target.h"