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