bfd/elfnn-aarch64.c

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