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