bfd/elfnn-aarch64.c

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