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, r_symndx);
7022           return FALSE;
7023         }
7024
7025       if (r_symndx < symtab_hdr->sh_info)
7026         {
7027           /* A local symbol.  */
7028           isym = bfd_sym_from_r_symndx (&htab->sym_cache,
7029                                         abfd, r_symndx);
7030           if (isym == NULL)
7031             return FALSE;
7032
7033           /* Check relocation against local STT_GNU_IFUNC symbol.  */
7034           if (ELF_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
7035             {
7036               h = elfNN_aarch64_get_local_sym_hash (htab, abfd, rel,
7037                                                     TRUE);
7038               if (h == NULL)
7039                 return FALSE;
7040
7041               /* Fake a STT_GNU_IFUNC symbol.  */
7042               h->type = STT_GNU_IFUNC;
7043               h->def_regular = 1;
7044               h->ref_regular = 1;
7045               h->forced_local = 1;
7046               h->root.type = bfd_link_hash_defined;
7047             }
7048           else
7049             h = NULL;
7050         }
7051       else
7052         {
7053           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
7054           while (h->root.type == bfd_link_hash_indirect
7055                  || h->root.type == bfd_link_hash_warning)
7056             h = (struct elf_link_hash_entry *) h->root.u.i.link;
7057
7058           /* PR15323, ref flags aren't set for references in the same
7059              object.  */
7060           h->root.non_ir_ref = 1;
7061         }
7062
7063       /* Could be done earlier, if h were already available.  */
7064       bfd_r_type = aarch64_tls_transition (abfd, info, r_type, h, r_symndx);
7065
7066       if (h != NULL)
7067         {
7068           /* If a relocation refers to _GLOBAL_OFFSET_TABLE_, create the .got.
7069              This shows up in particular in an R_AARCH64_PREL64 in large model
7070              when calculating the pc-relative address to .got section which is
7071              used to initialize the gp register.  */
7072           if (h->root.root.string
7073               && strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
7074             {
7075               if (htab->root.dynobj == NULL)
7076                 htab->root.dynobj = abfd;
7077
7078               if (! aarch64_elf_create_got_section (htab->root.dynobj, info))
7079                 return FALSE;
7080
7081               BFD_ASSERT (h == htab->root.hgot);
7082             }
7083
7084           /* Create the ifunc sections for static executables.  If we
7085              never see an indirect function symbol nor we are building
7086              a static executable, those sections will be empty and
7087              won't appear in output.  */
7088           switch (bfd_r_type)
7089             {
7090             default:
7091               break;
7092
7093             case BFD_RELOC_AARCH64_ADD_LO12:
7094             case BFD_RELOC_AARCH64_ADR_GOT_PAGE:
7095             case BFD_RELOC_AARCH64_ADR_HI21_PCREL:
7096             case BFD_RELOC_AARCH64_CALL26:
7097             case BFD_RELOC_AARCH64_GOT_LD_PREL19:
7098             case BFD_RELOC_AARCH64_JUMP26:
7099             case BFD_RELOC_AARCH64_LD32_GOTPAGE_LO14:
7100             case BFD_RELOC_AARCH64_LD32_GOT_LO12_NC:
7101             case BFD_RELOC_AARCH64_LD64_GOTOFF_LO15:
7102             case BFD_RELOC_AARCH64_LD64_GOTPAGE_LO15:
7103             case BFD_RELOC_AARCH64_LD64_GOT_LO12_NC:
7104             case BFD_RELOC_AARCH64_MOVW_GOTOFF_G0_NC:
7105             case BFD_RELOC_AARCH64_MOVW_GOTOFF_G1:
7106             case BFD_RELOC_AARCH64_NN:
7107               if (htab->root.dynobj == NULL)
7108                 htab->root.dynobj = abfd;
7109               if (!_bfd_elf_create_ifunc_sections (htab->root.dynobj, info))
7110                 return FALSE;
7111               break;
7112             }
7113
7114           /* It is referenced by a non-shared object. */
7115           h->ref_regular = 1;
7116           h->root.non_ir_ref = 1;
7117         }
7118
7119       switch (bfd_r_type)
7120         {
7121         case BFD_RELOC_AARCH64_NN:
7122
7123           /* We don't need to handle relocs into sections not going into
7124              the "real" output.  */
7125           if ((sec->flags & SEC_ALLOC) == 0)
7126             break;
7127
7128           if (h != NULL)
7129             {
7130               if (!bfd_link_pic (info))
7131                 h->non_got_ref = 1;
7132
7133               h->plt.refcount += 1;
7134               h->pointer_equality_needed = 1;
7135             }
7136
7137           /* No need to do anything if we're not creating a shared
7138              object.  */
7139           if (! bfd_link_pic (info))
7140             break;
7141
7142           {
7143             struct elf_dyn_relocs *p;
7144             struct elf_dyn_relocs **head;
7145
7146             /* We must copy these reloc types into the output file.
7147                Create a reloc section in dynobj and make room for
7148                this reloc.  */
7149             if (sreloc == NULL)
7150               {
7151                 if (htab->root.dynobj == NULL)
7152                   htab->root.dynobj = abfd;
7153
7154                 sreloc = _bfd_elf_make_dynamic_reloc_section
7155                   (sec, htab->root.dynobj, LOG_FILE_ALIGN, abfd, /*rela? */ TRUE);
7156
7157                 if (sreloc == NULL)
7158                   return FALSE;
7159               }
7160
7161             /* If this is a global symbol, we count the number of
7162                relocations we need for this symbol.  */
7163             if (h != NULL)
7164               {
7165                 struct elf_aarch64_link_hash_entry *eh;
7166                 eh = (struct elf_aarch64_link_hash_entry *) h;
7167                 head = &eh->dyn_relocs;
7168               }
7169             else
7170               {
7171                 /* Track dynamic relocs needed for local syms too.
7172                    We really need local syms available to do this
7173                    easily.  Oh well.  */
7174
7175                 asection *s;
7176                 void **vpp;
7177
7178                 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
7179                                               abfd, r_symndx);
7180                 if (isym == NULL)
7181                   return FALSE;
7182
7183                 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
7184                 if (s == NULL)
7185                   s = sec;
7186
7187                 /* Beware of type punned pointers vs strict aliasing
7188                    rules.  */
7189                 vpp = &(elf_section_data (s)->local_dynrel);
7190                 head = (struct elf_dyn_relocs **) vpp;
7191               }
7192
7193             p = *head;
7194             if (p == NULL || p->sec != sec)
7195               {
7196                 bfd_size_type amt = sizeof *p;
7197                 p = ((struct elf_dyn_relocs *)
7198                      bfd_zalloc (htab->root.dynobj, amt));
7199                 if (p == NULL)
7200                   return FALSE;
7201                 p->next = *head;
7202                 *head = p;
7203                 p->sec = sec;
7204               }
7205
7206             p->count += 1;
7207
7208           }
7209           break;
7210
7211           /* RR: We probably want to keep a consistency check that
7212              there are no dangling GOT_PAGE relocs.  */
7213         case BFD_RELOC_AARCH64_ADR_GOT_PAGE:
7214         case BFD_RELOC_AARCH64_GOT_LD_PREL19:
7215         case BFD_RELOC_AARCH64_LD32_GOTPAGE_LO14:
7216         case BFD_RELOC_AARCH64_LD32_GOT_LO12_NC:
7217         case BFD_RELOC_AARCH64_LD64_GOTOFF_LO15:
7218         case BFD_RELOC_AARCH64_LD64_GOTPAGE_LO15:
7219         case BFD_RELOC_AARCH64_LD64_GOT_LO12_NC:
7220         case BFD_RELOC_AARCH64_MOVW_GOTOFF_G0_NC:
7221         case BFD_RELOC_AARCH64_MOVW_GOTOFF_G1:
7222         case BFD_RELOC_AARCH64_TLSDESC_ADD_LO12_NC:
7223         case BFD_RELOC_AARCH64_TLSDESC_ADR_PAGE21:
7224         case BFD_RELOC_AARCH64_TLSDESC_ADR_PREL21:
7225         case BFD_RELOC_AARCH64_TLSDESC_LD32_LO12_NC:
7226         case BFD_RELOC_AARCH64_TLSDESC_LD64_LO12_NC:
7227         case BFD_RELOC_AARCH64_TLSDESC_LD_PREL19:
7228         case BFD_RELOC_AARCH64_TLSDESC_OFF_G0_NC:
7229         case BFD_RELOC_AARCH64_TLSDESC_OFF_G1:
7230         case BFD_RELOC_AARCH64_TLSGD_ADD_LO12_NC:
7231         case BFD_RELOC_AARCH64_TLSGD_ADR_PAGE21:
7232         case BFD_RELOC_AARCH64_TLSGD_ADR_PREL21:
7233         case BFD_RELOC_AARCH64_TLSGD_MOVW_G0_NC:
7234         case BFD_RELOC_AARCH64_TLSGD_MOVW_G1:
7235         case BFD_RELOC_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21:
7236         case BFD_RELOC_AARCH64_TLSIE_LD32_GOTTPREL_LO12_NC:
7237         case BFD_RELOC_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC:
7238         case BFD_RELOC_AARCH64_TLSIE_LD_GOTTPREL_PREL19:
7239         case BFD_RELOC_AARCH64_TLSIE_MOVW_GOTTPREL_G0_NC:
7240         case BFD_RELOC_AARCH64_TLSIE_MOVW_GOTTPREL_G1:
7241         case BFD_RELOC_AARCH64_TLSLD_ADD_LO12_NC:
7242         case BFD_RELOC_AARCH64_TLSLD_ADR_PAGE21:
7243         case BFD_RELOC_AARCH64_TLSLD_ADR_PREL21:
7244         case BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G1:
7245         case BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G1_NC:
7246         case BFD_RELOC_AARCH64_TLSLE_MOVW_TPREL_G2:
7247           {
7248             unsigned got_type;
7249             unsigned old_got_type;
7250
7251             got_type = aarch64_reloc_got_type (bfd_r_type);
7252
7253             if (h)
7254               {
7255                 h->got.refcount += 1;
7256                 old_got_type = elf_aarch64_hash_entry (h)->got_type;
7257               }
7258             else
7259               {
7260                 struct elf_aarch64_local_symbol *locals;
7261
7262                 if (!elfNN_aarch64_allocate_local_symbols
7263                     (abfd, symtab_hdr->sh_info))
7264                   return FALSE;
7265
7266                 locals = elf_aarch64_locals (abfd);
7267                 BFD_ASSERT (r_symndx < symtab_hdr->sh_info);
7268                 locals[r_symndx].got_refcount += 1;
7269                 old_got_type = locals[r_symndx].got_type;
7270               }
7271
7272             /* If a variable is accessed with both general dynamic TLS
7273                methods, two slots may be created.  */
7274             if (GOT_TLS_GD_ANY_P (old_got_type) && GOT_TLS_GD_ANY_P (got_type))
7275               got_type |= old_got_type;
7276
7277             /* We will already have issued an error message if there
7278                is a TLS/non-TLS mismatch, based on the symbol type.
7279                So just combine any TLS types needed.  */
7280             if (old_got_type != GOT_UNKNOWN && old_got_type != GOT_NORMAL
7281                 && got_type != GOT_NORMAL)
7282               got_type |= old_got_type;
7283
7284             /* If the symbol is accessed by both IE and GD methods, we
7285                are able to relax.  Turn off the GD flag, without
7286                messing up with any other kind of TLS types that may be
7287                involved.  */
7288             if ((got_type & GOT_TLS_IE) && GOT_TLS_GD_ANY_P (got_type))
7289               got_type &= ~ (GOT_TLSDESC_GD | GOT_TLS_GD);
7290
7291             if (old_got_type != got_type)
7292               {
7293                 if (h != NULL)
7294                   elf_aarch64_hash_entry (h)->got_type = got_type;
7295                 else
7296                   {
7297                     struct elf_aarch64_local_symbol *locals;
7298                     locals = elf_aarch64_locals (abfd);
7299                     BFD_ASSERT (r_symndx < symtab_hdr->sh_info);
7300                     locals[r_symndx].got_type = got_type;
7301                   }
7302               }
7303
7304             if (htab->root.dynobj == NULL)
7305               htab->root.dynobj = abfd;
7306             if (! aarch64_elf_create_got_section (htab->root.dynobj, info))
7307               return FALSE;
7308             break;
7309           }
7310
7311         case BFD_RELOC_AARCH64_MOVW_G0_NC:
7312         case BFD_RELOC_AARCH64_MOVW_G1_NC:
7313         case BFD_RELOC_AARCH64_MOVW_G2_NC:
7314         case BFD_RELOC_AARCH64_MOVW_G3:
7315           if (bfd_link_pic (info))
7316             {
7317               int howto_index = bfd_r_type - BFD_RELOC_AARCH64_RELOC_START;
7318               _bfd_error_handler
7319                 (_("%B: relocation %s against `%s' can not be used when making "
7320                    "a shared object; recompile with -fPIC"),
7321                  abfd, elfNN_aarch64_howto_table[howto_index].name,
7322                  (h) ? h->root.root.string : "a local symbol");
7323               bfd_set_error (bfd_error_bad_value);
7324               return FALSE;
7325             }
7326
7327         case BFD_RELOC_AARCH64_ADR_HI21_NC_PCREL:
7328         case BFD_RELOC_AARCH64_ADR_HI21_PCREL:
7329         case BFD_RELOC_AARCH64_ADR_LO21_PCREL:
7330           if (h != NULL && bfd_link_executable (info))
7331             {
7332               /* If this reloc is in a read-only section, we might
7333                  need a copy reloc.  We can't check reliably at this
7334                  stage whether the section is read-only, as input
7335                  sections have not yet been mapped to output sections.
7336                  Tentatively set the flag for now, and correct in
7337                  adjust_dynamic_symbol.  */
7338               h->non_got_ref = 1;
7339               h->plt.refcount += 1;
7340               h->pointer_equality_needed = 1;
7341             }
7342           /* FIXME:: RR need to handle these in shared libraries
7343              and essentially bomb out as these being non-PIC
7344              relocations in shared libraries.  */
7345           break;
7346
7347         case BFD_RELOC_AARCH64_CALL26:
7348         case BFD_RELOC_AARCH64_JUMP26:
7349           /* If this is a local symbol then we resolve it
7350              directly without creating a PLT entry.  */
7351           if (h == NULL)
7352             continue;
7353
7354           h->needs_plt = 1;
7355           if (h->plt.refcount <= 0)
7356             h->plt.refcount = 1;
7357           else
7358             h->plt.refcount += 1;
7359           break;
7360
7361         default:
7362           break;
7363         }
7364     }
7365
7366   return TRUE;
7367 }
7368
7369 /* Treat mapping symbols as special target symbols.  */
7370
7371 static bfd_boolean
7372 elfNN_aarch64_is_target_special_symbol (bfd *abfd ATTRIBUTE_UNUSED,
7373                                         asymbol *sym)
7374 {
7375   return bfd_is_aarch64_special_symbol_name (sym->name,
7376                                              BFD_AARCH64_SPECIAL_SYM_TYPE_ANY);
7377 }
7378
7379 /* This is a copy of elf_find_function () from elf.c except that
7380    AArch64 mapping symbols are ignored when looking for function names.  */
7381
7382 static bfd_boolean
7383 aarch64_elf_find_function (bfd *abfd ATTRIBUTE_UNUSED,
7384                            asymbol **symbols,
7385                            asection *section,
7386                            bfd_vma offset,
7387                            const char **filename_ptr,
7388                            const char **functionname_ptr)
7389 {
7390   const char *filename = NULL;
7391   asymbol *func = NULL;
7392   bfd_vma low_func = 0;
7393   asymbol **p;
7394
7395   for (p = symbols; *p != NULL; p++)
7396     {
7397       elf_symbol_type *q;
7398
7399       q = (elf_symbol_type *) * p;
7400
7401       switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
7402         {
7403         default:
7404           break;
7405         case STT_FILE:
7406           filename = bfd_asymbol_name (&q->symbol);
7407           break;
7408         case STT_FUNC:
7409         case STT_NOTYPE:
7410           /* Skip mapping symbols.  */
7411           if ((q->symbol.flags & BSF_LOCAL)
7412               && (bfd_is_aarch64_special_symbol_name
7413                   (q->symbol.name, BFD_AARCH64_SPECIAL_SYM_TYPE_ANY)))
7414             continue;
7415           /* Fall through.  */
7416           if (bfd_get_section (&q->symbol) == section
7417               && q->symbol.value >= low_func && q->symbol.value <= offset)
7418             {
7419               func = (asymbol *) q;
7420               low_func = q->symbol.value;
7421             }
7422           break;
7423         }
7424     }
7425
7426   if (func == NULL)
7427     return FALSE;
7428
7429   if (filename_ptr)
7430     *filename_ptr = filename;
7431   if (functionname_ptr)
7432     *functionname_ptr = bfd_asymbol_name (func);
7433
7434   return TRUE;
7435 }
7436
7437
7438 /* Find the nearest line to a particular section and offset, for error
7439    reporting.   This code is a duplicate of the code in elf.c, except
7440    that it uses aarch64_elf_find_function.  */
7441
7442 static bfd_boolean
7443 elfNN_aarch64_find_nearest_line (bfd *abfd,
7444                                  asymbol **symbols,
7445                                  asection *section,
7446                                  bfd_vma offset,
7447                                  const char **filename_ptr,
7448                                  const char **functionname_ptr,
7449                                  unsigned int *line_ptr,
7450                                  unsigned int *discriminator_ptr)
7451 {
7452   bfd_boolean found = FALSE;
7453
7454   if (_bfd_dwarf2_find_nearest_line (abfd, symbols, NULL, section, offset,
7455                                      filename_ptr, functionname_ptr,
7456                                      line_ptr, discriminator_ptr,
7457                                      dwarf_debug_sections, 0,
7458                                      &elf_tdata (abfd)->dwarf2_find_line_info))
7459     {
7460       if (!*functionname_ptr)
7461         aarch64_elf_find_function (abfd, symbols, section, offset,
7462                                    *filename_ptr ? NULL : filename_ptr,
7463                                    functionname_ptr);
7464
7465       return TRUE;
7466     }
7467
7468   /* Skip _bfd_dwarf1_find_nearest_line since no known AArch64
7469      toolchain uses DWARF1.  */
7470
7471   if (!_bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
7472                                             &found, filename_ptr,
7473                                             functionname_ptr, line_ptr,
7474                                             &elf_tdata (abfd)->line_info))
7475     return FALSE;
7476
7477   if (found && (*functionname_ptr || *line_ptr))
7478     return TRUE;
7479
7480   if (symbols == NULL)
7481     return FALSE;
7482
7483   if (!aarch64_elf_find_function (abfd, symbols, section, offset,
7484                                   filename_ptr, functionname_ptr))
7485     return FALSE;
7486
7487   *line_ptr = 0;
7488   return TRUE;
7489 }
7490
7491 static bfd_boolean
7492 elfNN_aarch64_find_inliner_info (bfd *abfd,
7493                                  const char **filename_ptr,
7494                                  const char **functionname_ptr,
7495                                  unsigned int *line_ptr)
7496 {
7497   bfd_boolean found;
7498   found = _bfd_dwarf2_find_inliner_info
7499     (abfd, filename_ptr,
7500      functionname_ptr, line_ptr, &elf_tdata (abfd)->dwarf2_find_line_info);
7501   return found;
7502 }
7503
7504
7505 static void
7506 elfNN_aarch64_post_process_headers (bfd *abfd,
7507                                     struct bfd_link_info *link_info)
7508 {
7509   Elf_Internal_Ehdr *i_ehdrp;   /* ELF file header, internal form.  */
7510
7511   i_ehdrp = elf_elfheader (abfd);
7512   i_ehdrp->e_ident[EI_ABIVERSION] = AARCH64_ELF_ABI_VERSION;
7513
7514   _bfd_elf_post_process_headers (abfd, link_info);
7515 }
7516
7517 static enum elf_reloc_type_class
7518 elfNN_aarch64_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
7519                                 const asection *rel_sec ATTRIBUTE_UNUSED,
7520                                 const Elf_Internal_Rela *rela)
7521 {
7522   switch ((int) ELFNN_R_TYPE (rela->r_info))
7523     {
7524     case AARCH64_R (RELATIVE):
7525       return reloc_class_relative;
7526     case AARCH64_R (JUMP_SLOT):
7527       return reloc_class_plt;
7528     case AARCH64_R (COPY):
7529       return reloc_class_copy;
7530     default:
7531       return reloc_class_normal;
7532     }
7533 }
7534
7535 /* Handle an AArch64 specific section when reading an object file.  This is
7536    called when bfd_section_from_shdr finds a section with an unknown
7537    type.  */
7538
7539 static bfd_boolean
7540 elfNN_aarch64_section_from_shdr (bfd *abfd,
7541                                  Elf_Internal_Shdr *hdr,
7542                                  const char *name, int shindex)
7543 {
7544   /* There ought to be a place to keep ELF backend specific flags, but
7545      at the moment there isn't one.  We just keep track of the
7546      sections by their name, instead.  Fortunately, the ABI gives
7547      names for all the AArch64 specific sections, so we will probably get
7548      away with this.  */
7549   switch (hdr->sh_type)
7550     {
7551     case SHT_AARCH64_ATTRIBUTES:
7552       break;
7553
7554     default:
7555       return FALSE;
7556     }
7557
7558   if (!_bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
7559     return FALSE;
7560
7561   return TRUE;
7562 }
7563
7564 /* A structure used to record a list of sections, independently
7565    of the next and prev fields in the asection structure.  */
7566 typedef struct section_list
7567 {
7568   asection *sec;
7569   struct section_list *next;
7570   struct section_list *prev;
7571 }
7572 section_list;
7573
7574 /* Unfortunately we need to keep a list of sections for which
7575    an _aarch64_elf_section_data structure has been allocated.  This
7576    is because it is possible for functions like elfNN_aarch64_write_section
7577    to be called on a section which has had an elf_data_structure
7578    allocated for it (and so the used_by_bfd field is valid) but
7579    for which the AArch64 extended version of this structure - the
7580    _aarch64_elf_section_data structure - has not been allocated.  */
7581 static section_list *sections_with_aarch64_elf_section_data = NULL;
7582
7583 static void
7584 record_section_with_aarch64_elf_section_data (asection *sec)
7585 {
7586   struct section_list *entry;
7587
7588   entry = bfd_malloc (sizeof (*entry));
7589   if (entry == NULL)
7590     return;
7591   entry->sec = sec;
7592   entry->next = sections_with_aarch64_elf_section_data;
7593   entry->prev = NULL;
7594   if (entry->next != NULL)
7595     entry->next->prev = entry;
7596   sections_with_aarch64_elf_section_data = entry;
7597 }
7598
7599 static struct section_list *
7600 find_aarch64_elf_section_entry (asection *sec)
7601 {
7602   struct section_list *entry;
7603   static struct section_list *last_entry = NULL;
7604
7605   /* This is a short cut for the typical case where the sections are added
7606      to the sections_with_aarch64_elf_section_data list in forward order and
7607      then looked up here in backwards order.  This makes a real difference
7608      to the ld-srec/sec64k.exp linker test.  */
7609   entry = sections_with_aarch64_elf_section_data;
7610   if (last_entry != NULL)
7611     {
7612       if (last_entry->sec == sec)
7613         entry = last_entry;
7614       else if (last_entry->next != NULL && last_entry->next->sec == sec)
7615         entry = last_entry->next;
7616     }
7617
7618   for (; entry; entry = entry->next)
7619     if (entry->sec == sec)
7620       break;
7621
7622   if (entry)
7623     /* Record the entry prior to this one - it is the entry we are
7624        most likely to want to locate next time.  Also this way if we
7625        have been called from
7626        unrecord_section_with_aarch64_elf_section_data () we will not
7627        be caching a pointer that is about to be freed.  */
7628     last_entry = entry->prev;
7629
7630   return entry;
7631 }
7632
7633 static void
7634 unrecord_section_with_aarch64_elf_section_data (asection *sec)
7635 {
7636   struct section_list *entry;
7637
7638   entry = find_aarch64_elf_section_entry (sec);
7639
7640   if (entry)
7641     {
7642       if (entry->prev != NULL)
7643         entry->prev->next = entry->next;
7644       if (entry->next != NULL)
7645         entry->next->prev = entry->prev;
7646       if (entry == sections_with_aarch64_elf_section_data)
7647         sections_with_aarch64_elf_section_data = entry->next;
7648       free (entry);
7649     }
7650 }
7651
7652
7653 typedef struct
7654 {
7655   void *finfo;
7656   struct bfd_link_info *info;
7657   asection *sec;
7658   int sec_shndx;
7659   int (*func) (void *, const char *, Elf_Internal_Sym *,
7660                asection *, struct elf_link_hash_entry *);
7661 } output_arch_syminfo;
7662
7663 enum map_symbol_type
7664 {
7665   AARCH64_MAP_INSN,
7666   AARCH64_MAP_DATA
7667 };
7668
7669
7670 /* Output a single mapping symbol.  */
7671
7672 static bfd_boolean
7673 elfNN_aarch64_output_map_sym (output_arch_syminfo *osi,
7674                               enum map_symbol_type type, bfd_vma offset)
7675 {
7676   static const char *names[2] = { "$x", "$d" };
7677   Elf_Internal_Sym sym;
7678
7679   sym.st_value = (osi->sec->output_section->vma
7680                   + osi->sec->output_offset + offset);
7681   sym.st_size = 0;
7682   sym.st_other = 0;
7683   sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_NOTYPE);
7684   sym.st_shndx = osi->sec_shndx;
7685   return osi->func (osi->finfo, names[type], &sym, osi->sec, NULL) == 1;
7686 }
7687
7688 /* Output a single local symbol for a generated stub.  */
7689
7690 static bfd_boolean
7691 elfNN_aarch64_output_stub_sym (output_arch_syminfo *osi, const char *name,
7692                                bfd_vma offset, bfd_vma size)
7693 {
7694   Elf_Internal_Sym sym;
7695
7696   sym.st_value = (osi->sec->output_section->vma
7697                   + osi->sec->output_offset + offset);
7698   sym.st_size = size;
7699   sym.st_other = 0;
7700   sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
7701   sym.st_shndx = osi->sec_shndx;
7702   return osi->func (osi->finfo, name, &sym, osi->sec, NULL) == 1;
7703 }
7704
7705 static bfd_boolean
7706 aarch64_map_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg)
7707 {
7708   struct elf_aarch64_stub_hash_entry *stub_entry;
7709   asection *stub_sec;
7710   bfd_vma addr;
7711   char *stub_name;
7712   output_arch_syminfo *osi;
7713
7714   /* Massage our args to the form they really have.  */
7715   stub_entry = (struct elf_aarch64_stub_hash_entry *) gen_entry;
7716   osi = (output_arch_syminfo *) in_arg;
7717
7718   stub_sec = stub_entry->stub_sec;
7719
7720   /* Ensure this stub is attached to the current section being
7721      processed.  */
7722   if (stub_sec != osi->sec)
7723     return TRUE;
7724
7725   addr = (bfd_vma) stub_entry->stub_offset;
7726
7727   stub_name = stub_entry->output_name;
7728
7729   switch (stub_entry->stub_type)
7730     {
7731     case aarch64_stub_adrp_branch:
7732       if (!elfNN_aarch64_output_stub_sym (osi, stub_name, addr,
7733                                           sizeof (aarch64_adrp_branch_stub)))
7734         return FALSE;
7735       if (!elfNN_aarch64_output_map_sym (osi, AARCH64_MAP_INSN, addr))
7736         return FALSE;
7737       break;
7738     case aarch64_stub_long_branch:
7739       if (!elfNN_aarch64_output_stub_sym
7740           (osi, stub_name, addr, sizeof (aarch64_long_branch_stub)))
7741         return FALSE;
7742       if (!elfNN_aarch64_output_map_sym (osi, AARCH64_MAP_INSN, addr))
7743         return FALSE;
7744       if (!elfNN_aarch64_output_map_sym (osi, AARCH64_MAP_DATA, addr + 16))
7745         return FALSE;
7746       break;
7747     case aarch64_stub_erratum_835769_veneer:
7748       if (!elfNN_aarch64_output_stub_sym (osi, stub_name, addr,
7749                                           sizeof (aarch64_erratum_835769_stub)))
7750         return FALSE;
7751       if (!elfNN_aarch64_output_map_sym (osi, AARCH64_MAP_INSN, addr))
7752         return FALSE;
7753       break;
7754     case aarch64_stub_erratum_843419_veneer:
7755       if (!elfNN_aarch64_output_stub_sym (osi, stub_name, addr,
7756                                           sizeof (aarch64_erratum_843419_stub)))
7757         return FALSE;
7758       if (!elfNN_aarch64_output_map_sym (osi, AARCH64_MAP_INSN, addr))
7759         return FALSE;
7760       break;
7761
7762     default:
7763       abort ();
7764     }
7765
7766   return TRUE;
7767 }
7768
7769 /* Output mapping symbols for linker generated sections.  */
7770
7771 static bfd_boolean
7772 elfNN_aarch64_output_arch_local_syms (bfd *output_bfd,
7773                                       struct bfd_link_info *info,
7774                                       void *finfo,
7775                                       int (*func) (void *, const char *,
7776                                                    Elf_Internal_Sym *,
7777                                                    asection *,
7778                                                    struct elf_link_hash_entry
7779                                                    *))
7780 {
7781   output_arch_syminfo osi;
7782   struct elf_aarch64_link_hash_table *htab;
7783
7784   htab = elf_aarch64_hash_table (info);
7785
7786   osi.finfo = finfo;
7787   osi.info = info;
7788   osi.func = func;
7789
7790   /* Long calls stubs.  */
7791   if (htab->stub_bfd && htab->stub_bfd->sections)
7792     {
7793       asection *stub_sec;
7794
7795       for (stub_sec = htab->stub_bfd->sections;
7796            stub_sec != NULL; stub_sec = stub_sec->next)
7797         {
7798           /* Ignore non-stub sections.  */
7799           if (!strstr (stub_sec->name, STUB_SUFFIX))
7800             continue;
7801
7802           osi.sec = stub_sec;
7803
7804           osi.sec_shndx = _bfd_elf_section_from_bfd_section
7805             (output_bfd, osi.sec->output_section);
7806
7807           /* The first instruction in a stub is always a branch.  */
7808           if (!elfNN_aarch64_output_map_sym (&osi, AARCH64_MAP_INSN, 0))
7809             return FALSE;
7810
7811           bfd_hash_traverse (&htab->stub_hash_table, aarch64_map_one_stub,
7812                              &osi);
7813         }
7814     }
7815
7816   /* Finally, output mapping symbols for the PLT.  */
7817   if (!htab->root.splt || htab->root.splt->size == 0)
7818     return TRUE;
7819
7820   osi.sec_shndx = _bfd_elf_section_from_bfd_section
7821     (output_bfd, htab->root.splt->output_section);
7822   osi.sec = htab->root.splt;
7823
7824   elfNN_aarch64_output_map_sym (&osi, AARCH64_MAP_INSN, 0);
7825
7826   return TRUE;
7827
7828 }
7829
7830 /* Allocate target specific section data.  */
7831
7832 static bfd_boolean
7833 elfNN_aarch64_new_section_hook (bfd *abfd, asection *sec)
7834 {
7835   if (!sec->used_by_bfd)
7836     {
7837       _aarch64_elf_section_data *sdata;
7838       bfd_size_type amt = sizeof (*sdata);
7839
7840       sdata = bfd_zalloc (abfd, amt);
7841       if (sdata == NULL)
7842         return FALSE;
7843       sec->used_by_bfd = sdata;
7844     }
7845
7846   record_section_with_aarch64_elf_section_data (sec);
7847
7848   return _bfd_elf_new_section_hook (abfd, sec);
7849 }
7850
7851
7852 static void
7853 unrecord_section_via_map_over_sections (bfd *abfd ATTRIBUTE_UNUSED,
7854                                         asection *sec,
7855                                         void *ignore ATTRIBUTE_UNUSED)
7856 {
7857   unrecord_section_with_aarch64_elf_section_data (sec);
7858 }
7859
7860 static bfd_boolean
7861 elfNN_aarch64_close_and_cleanup (bfd *abfd)
7862 {
7863   if (abfd->sections)
7864     bfd_map_over_sections (abfd,
7865                            unrecord_section_via_map_over_sections, NULL);
7866
7867   return _bfd_elf_close_and_cleanup (abfd);
7868 }
7869
7870 static bfd_boolean
7871 elfNN_aarch64_bfd_free_cached_info (bfd *abfd)
7872 {
7873   if (abfd->sections)
7874     bfd_map_over_sections (abfd,
7875                            unrecord_section_via_map_over_sections, NULL);
7876
7877   return _bfd_free_cached_info (abfd);
7878 }
7879
7880 /* Create dynamic sections. This is different from the ARM backend in that
7881    the got, plt, gotplt and their relocation sections are all created in the
7882    standard part of the bfd elf backend.  */
7883
7884 static bfd_boolean
7885 elfNN_aarch64_create_dynamic_sections (bfd *dynobj,
7886                                        struct bfd_link_info *info)
7887 {
7888   struct elf_aarch64_link_hash_table *htab;
7889
7890   /* We need to create .got section.  */
7891   if (!aarch64_elf_create_got_section (dynobj, info))
7892     return FALSE;
7893
7894   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
7895     return FALSE;
7896
7897   htab = elf_aarch64_hash_table (info);
7898   htab->sdynbss = bfd_get_linker_section (dynobj, ".dynbss");
7899   if (!bfd_link_pic (info))
7900     htab->srelbss = bfd_get_linker_section (dynobj, ".rela.bss");
7901
7902   if (!htab->sdynbss || (!bfd_link_pic (info) && !htab->srelbss))
7903     abort ();
7904
7905   return TRUE;
7906 }
7907
7908
7909 /* Allocate space in .plt, .got and associated reloc sections for
7910    dynamic relocs.  */
7911
7912 static bfd_boolean
7913 elfNN_aarch64_allocate_dynrelocs (struct elf_link_hash_entry *h, void *inf)
7914 {
7915   struct bfd_link_info *info;
7916   struct elf_aarch64_link_hash_table *htab;
7917   struct elf_aarch64_link_hash_entry *eh;
7918   struct elf_dyn_relocs *p;
7919
7920   /* An example of a bfd_link_hash_indirect symbol is versioned
7921      symbol. For example: __gxx_personality_v0(bfd_link_hash_indirect)
7922      -> __gxx_personality_v0(bfd_link_hash_defined)
7923
7924      There is no need to process bfd_link_hash_indirect symbols here
7925      because we will also be presented with the concrete instance of
7926      the symbol and elfNN_aarch64_copy_indirect_symbol () will have been
7927      called to copy all relevant data from the generic to the concrete
7928      symbol instance.
7929    */
7930   if (h->root.type == bfd_link_hash_indirect)
7931     return TRUE;
7932
7933   if (h->root.type == bfd_link_hash_warning)
7934     h = (struct elf_link_hash_entry *) h->root.u.i.link;
7935
7936   info = (struct bfd_link_info *) inf;
7937   htab = elf_aarch64_hash_table (info);
7938
7939   /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
7940      here if it is defined and referenced in a non-shared object.  */
7941   if (h->type == STT_GNU_IFUNC
7942       && h->def_regular)
7943     return TRUE;
7944   else if (htab->root.dynamic_sections_created && h->plt.refcount > 0)
7945     {
7946       /* Make sure this symbol is output as a dynamic symbol.
7947          Undefined weak syms won't yet be marked as dynamic.  */
7948       if (h->dynindx == -1 && !h->forced_local)
7949         {
7950           if (!bfd_elf_link_record_dynamic_symbol (info, h))
7951             return FALSE;
7952         }
7953
7954       if (bfd_link_pic (info) || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
7955         {
7956           asection *s = htab->root.splt;
7957
7958           /* If this is the first .plt entry, make room for the special
7959              first entry.  */
7960           if (s->size == 0)
7961             s->size += htab->plt_header_size;
7962
7963           h->plt.offset = s->size;
7964
7965           /* If this symbol is not defined in a regular file, and we are
7966              not generating a shared library, then set the symbol to this
7967              location in the .plt.  This is required to make function
7968              pointers compare as equal between the normal executable and
7969              the shared library.  */
7970           if (!bfd_link_pic (info) && !h->def_regular)
7971             {
7972               h->root.u.def.section = s;
7973               h->root.u.def.value = h->plt.offset;
7974             }
7975
7976           /* Make room for this entry. For now we only create the
7977              small model PLT entries. We later need to find a way
7978              of relaxing into these from the large model PLT entries.  */
7979           s->size += PLT_SMALL_ENTRY_SIZE;
7980
7981           /* We also need to make an entry in the .got.plt section, which
7982              will be placed in the .got section by the linker script.  */
7983           htab->root.sgotplt->size += GOT_ENTRY_SIZE;
7984
7985           /* We also need to make an entry in the .rela.plt section.  */
7986           htab->root.srelplt->size += RELOC_SIZE (htab);
7987
7988           /* We need to ensure that all GOT entries that serve the PLT
7989              are consecutive with the special GOT slots [0] [1] and
7990              [2]. Any addtional relocations, such as
7991              R_AARCH64_TLSDESC, must be placed after the PLT related
7992              entries.  We abuse the reloc_count such that during
7993              sizing we adjust reloc_count to indicate the number of
7994              PLT related reserved entries.  In subsequent phases when
7995              filling in the contents of the reloc entries, PLT related
7996              entries are placed by computing their PLT index (0
7997              .. reloc_count). While other none PLT relocs are placed
7998              at the slot indicated by reloc_count and reloc_count is
7999              updated.  */
8000
8001           htab->root.srelplt->reloc_count++;
8002         }
8003       else
8004         {
8005           h->plt.offset = (bfd_vma) - 1;
8006           h->needs_plt = 0;
8007         }
8008     }
8009   else
8010     {
8011       h->plt.offset = (bfd_vma) - 1;
8012       h->needs_plt = 0;
8013     }
8014
8015   eh = (struct elf_aarch64_link_hash_entry *) h;
8016   eh->tlsdesc_got_jump_table_offset = (bfd_vma) - 1;
8017
8018   if (h->got.refcount > 0)
8019     {
8020       bfd_boolean dyn;
8021       unsigned got_type = elf_aarch64_hash_entry (h)->got_type;
8022
8023       h->got.offset = (bfd_vma) - 1;
8024
8025       dyn = htab->root.dynamic_sections_created;
8026
8027       /* Make sure this symbol is output as a dynamic symbol.
8028          Undefined weak syms won't yet be marked as dynamic.  */
8029       if (dyn && h->dynindx == -1 && !h->forced_local)
8030         {
8031           if (!bfd_elf_link_record_dynamic_symbol (info, h))
8032             return FALSE;
8033         }
8034
8035       if (got_type == GOT_UNKNOWN)
8036         {
8037         }
8038       else if (got_type == GOT_NORMAL)
8039         {
8040           h->got.offset = htab->root.sgot->size;
8041           htab->root.sgot->size += GOT_ENTRY_SIZE;
8042           if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
8043                || h->root.type != bfd_link_hash_undefweak)
8044               && (bfd_link_pic (info)
8045                   || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
8046             {
8047               htab->root.srelgot->size += RELOC_SIZE (htab);
8048             }
8049         }
8050       else
8051         {
8052           int indx;
8053           if (got_type & GOT_TLSDESC_GD)
8054             {
8055               eh->tlsdesc_got_jump_table_offset =
8056                 (htab->root.sgotplt->size
8057                  - aarch64_compute_jump_table_size (htab));
8058               htab->root.sgotplt->size += GOT_ENTRY_SIZE * 2;
8059               h->got.offset = (bfd_vma) - 2;
8060             }
8061
8062           if (got_type & GOT_TLS_GD)
8063             {
8064               h->got.offset = htab->root.sgot->size;
8065               htab->root.sgot->size += GOT_ENTRY_SIZE * 2;
8066             }
8067
8068           if (got_type & GOT_TLS_IE)
8069             {
8070               h->got.offset = htab->root.sgot->size;
8071               htab->root.sgot->size += GOT_ENTRY_SIZE;
8072             }
8073
8074           indx = h && h->dynindx != -1 ? h->dynindx : 0;
8075           if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
8076                || h->root.type != bfd_link_hash_undefweak)
8077               && (bfd_link_pic (info)
8078                   || indx != 0
8079                   || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
8080             {
8081               if (got_type & GOT_TLSDESC_GD)
8082                 {
8083                   htab->root.srelplt->size += RELOC_SIZE (htab);
8084                   /* Note reloc_count not incremented here!  We have
8085                      already adjusted reloc_count for this relocation
8086                      type.  */
8087
8088                   /* TLSDESC PLT is now needed, but not yet determined.  */
8089                   htab->tlsdesc_plt = (bfd_vma) - 1;
8090                 }
8091
8092               if (got_type & GOT_TLS_GD)
8093                 htab->root.srelgot->size += RELOC_SIZE (htab) * 2;
8094
8095               if (got_type & GOT_TLS_IE)
8096                 htab->root.srelgot->size += RELOC_SIZE (htab);
8097             }
8098         }
8099     }
8100   else
8101     {
8102       h->got.offset = (bfd_vma) - 1;
8103     }
8104
8105   if (eh->dyn_relocs == NULL)
8106     return TRUE;
8107
8108   /* In the shared -Bsymbolic case, discard space allocated for
8109      dynamic pc-relative relocs against symbols which turn out to be
8110      defined in regular objects.  For the normal shared case, discard
8111      space for pc-relative relocs that have become local due to symbol
8112      visibility changes.  */
8113
8114   if (bfd_link_pic (info))
8115     {
8116       /* Relocs that use pc_count are those that appear on a call
8117          insn, or certain REL relocs that can generated via assembly.
8118          We want calls to protected symbols to resolve directly to the
8119          function rather than going via the plt.  If people want
8120          function pointer comparisons to work as expected then they
8121          should avoid writing weird assembly.  */
8122       if (SYMBOL_CALLS_LOCAL (info, h))
8123         {
8124           struct elf_dyn_relocs **pp;
8125
8126           for (pp = &eh->dyn_relocs; (p = *pp) != NULL;)
8127             {
8128               p->count -= p->pc_count;
8129               p->pc_count = 0;
8130               if (p->count == 0)
8131                 *pp = p->next;
8132               else
8133                 pp = &p->next;
8134             }
8135         }
8136
8137       /* Also discard relocs on undefined weak syms with non-default
8138          visibility.  */
8139       if (eh->dyn_relocs != NULL && h->root.type == bfd_link_hash_undefweak)
8140         {
8141           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
8142             eh->dyn_relocs = NULL;
8143
8144           /* Make sure undefined weak symbols are output as a dynamic
8145              symbol in PIEs.  */
8146           else if (h->dynindx == -1
8147                    && !h->forced_local
8148                    && !bfd_elf_link_record_dynamic_symbol (info, h))
8149             return FALSE;
8150         }
8151
8152     }
8153   else if (ELIMINATE_COPY_RELOCS)
8154     {
8155       /* For the non-shared case, discard space for relocs against
8156          symbols which turn out to need copy relocs or are not
8157          dynamic.  */
8158
8159       if (!h->non_got_ref
8160           && ((h->def_dynamic
8161                && !h->def_regular)
8162               || (htab->root.dynamic_sections_created
8163                   && (h->root.type == bfd_link_hash_undefweak
8164                       || h->root.type == bfd_link_hash_undefined))))
8165         {
8166           /* Make sure this symbol is output as a dynamic symbol.
8167              Undefined weak syms won't yet be marked as dynamic.  */
8168           if (h->dynindx == -1
8169               && !h->forced_local
8170               && !bfd_elf_link_record_dynamic_symbol (info, h))
8171             return FALSE;
8172
8173           /* If that succeeded, we know we'll be keeping all the
8174              relocs.  */
8175           if (h->dynindx != -1)
8176             goto keep;
8177         }
8178
8179       eh->dyn_relocs = NULL;
8180
8181     keep:;
8182     }
8183
8184   /* Finally, allocate space.  */
8185   for (p = eh->dyn_relocs; p != NULL; p = p->next)
8186     {
8187       asection *sreloc;
8188
8189       sreloc = elf_section_data (p->sec)->sreloc;
8190
8191       BFD_ASSERT (sreloc != NULL);
8192
8193       sreloc->size += p->count * RELOC_SIZE (htab);
8194     }
8195
8196   return TRUE;
8197 }
8198
8199 /* Allocate space in .plt, .got and associated reloc sections for
8200    ifunc dynamic relocs.  */
8201
8202 static bfd_boolean
8203 elfNN_aarch64_allocate_ifunc_dynrelocs (struct elf_link_hash_entry *h,
8204                                         void *inf)
8205 {
8206   struct bfd_link_info *info;
8207   struct elf_aarch64_link_hash_table *htab;
8208   struct elf_aarch64_link_hash_entry *eh;
8209
8210   /* An example of a bfd_link_hash_indirect symbol is versioned
8211      symbol. For example: __gxx_personality_v0(bfd_link_hash_indirect)
8212      -> __gxx_personality_v0(bfd_link_hash_defined)
8213
8214      There is no need to process bfd_link_hash_indirect symbols here
8215      because we will also be presented with the concrete instance of
8216      the symbol and elfNN_aarch64_copy_indirect_symbol () will have been
8217      called to copy all relevant data from the generic to the concrete
8218      symbol instance.
8219    */
8220   if (h->root.type == bfd_link_hash_indirect)
8221     return TRUE;
8222
8223   if (h->root.type == bfd_link_hash_warning)
8224     h = (struct elf_link_hash_entry *) h->root.u.i.link;
8225
8226   info = (struct bfd_link_info *) inf;
8227   htab = elf_aarch64_hash_table (info);
8228
8229   eh = (struct elf_aarch64_link_hash_entry *) h;
8230
8231   /* Since STT_GNU_IFUNC symbol must go through PLT, we handle it
8232      here if it is defined and referenced in a non-shared object.  */
8233   if (h->type == STT_GNU_IFUNC
8234       && h->def_regular)
8235     return _bfd_elf_allocate_ifunc_dyn_relocs (info, h,
8236                                                &eh->dyn_relocs,
8237                                                NULL,
8238                                                htab->plt_entry_size,
8239                                                htab->plt_header_size,
8240                                                GOT_ENTRY_SIZE,
8241                                                FALSE);
8242   return TRUE;
8243 }
8244
8245 /* Allocate space in .plt, .got and associated reloc sections for
8246    local dynamic relocs.  */
8247
8248 static bfd_boolean
8249 elfNN_aarch64_allocate_local_dynrelocs (void **slot, void *inf)
8250 {
8251   struct elf_link_hash_entry *h
8252     = (struct elf_link_hash_entry *) *slot;
8253
8254   if (h->type != STT_GNU_IFUNC
8255       || !h->def_regular
8256       || !h->ref_regular
8257       || !h->forced_local
8258       || h->root.type != bfd_link_hash_defined)
8259     abort ();
8260
8261   return elfNN_aarch64_allocate_dynrelocs (h, inf);
8262 }
8263
8264 /* Allocate space in .plt, .got and associated reloc sections for
8265    local ifunc dynamic relocs.  */
8266
8267 static bfd_boolean
8268 elfNN_aarch64_allocate_local_ifunc_dynrelocs (void **slot, void *inf)
8269 {
8270   struct elf_link_hash_entry *h
8271     = (struct elf_link_hash_entry *) *slot;
8272
8273   if (h->type != STT_GNU_IFUNC
8274       || !h->def_regular
8275       || !h->ref_regular
8276       || !h->forced_local
8277       || h->root.type != bfd_link_hash_defined)
8278     abort ();
8279
8280   return elfNN_aarch64_allocate_ifunc_dynrelocs (h, inf);
8281 }
8282
8283 /* Find any dynamic relocs that apply to read-only sections.  */
8284
8285 static bfd_boolean
8286 aarch64_readonly_dynrelocs (struct elf_link_hash_entry * h, void * inf)
8287 {
8288   struct elf_aarch64_link_hash_entry * eh;
8289   struct elf_dyn_relocs * p;
8290
8291   eh = (struct elf_aarch64_link_hash_entry *) h;
8292   for (p = eh->dyn_relocs; p != NULL; p = p->next)
8293     {
8294       asection *s = p->sec;
8295
8296       if (s != NULL && (s->flags & SEC_READONLY) != 0)
8297         {
8298           struct bfd_link_info *info = (struct bfd_link_info *) inf;
8299
8300           info->flags |= DF_TEXTREL;
8301
8302           /* Not an error, just cut short the traversal.  */
8303           return FALSE;
8304         }
8305     }
8306   return TRUE;
8307 }
8308
8309 /* This is the most important function of all . Innocuosly named
8310    though !  */
8311 static bfd_boolean
8312 elfNN_aarch64_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
8313                                      struct bfd_link_info *info)
8314 {
8315   struct elf_aarch64_link_hash_table *htab;
8316   bfd *dynobj;
8317   asection *s;
8318   bfd_boolean relocs;
8319   bfd *ibfd;
8320
8321   htab = elf_aarch64_hash_table ((info));
8322   dynobj = htab->root.dynobj;
8323
8324   BFD_ASSERT (dynobj != NULL);
8325
8326   if (htab->root.dynamic_sections_created)
8327     {
8328       if (bfd_link_executable (info) && !info->nointerp)
8329         {
8330           s = bfd_get_linker_section (dynobj, ".interp");
8331           if (s == NULL)
8332             abort ();
8333           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
8334           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
8335         }
8336     }
8337
8338   /* Set up .got offsets for local syms, and space for local dynamic
8339      relocs.  */
8340   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8341     {
8342       struct elf_aarch64_local_symbol *locals = NULL;
8343       Elf_Internal_Shdr *symtab_hdr;
8344       asection *srel;
8345       unsigned int i;
8346
8347       if (!is_aarch64_elf (ibfd))
8348         continue;
8349
8350       for (s = ibfd->sections; s != NULL; s = s->next)
8351         {
8352           struct elf_dyn_relocs *p;
8353
8354           for (p = (struct elf_dyn_relocs *)
8355                (elf_section_data (s)->local_dynrel); p != NULL; p = p->next)
8356             {
8357               if (!bfd_is_abs_section (p->sec)
8358                   && bfd_is_abs_section (p->sec->output_section))
8359                 {
8360                   /* Input section has been discarded, either because
8361                      it is a copy of a linkonce section or due to
8362                      linker script /DISCARD/, so we'll be discarding
8363                      the relocs too.  */
8364                 }
8365               else if (p->count != 0)
8366                 {
8367                   srel = elf_section_data (p->sec)->sreloc;
8368                   srel->size += p->count * RELOC_SIZE (htab);
8369                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
8370                     info->flags |= DF_TEXTREL;
8371                 }
8372             }
8373         }
8374
8375       locals = elf_aarch64_locals (ibfd);
8376       if (!locals)
8377         continue;
8378
8379       symtab_hdr = &elf_symtab_hdr (ibfd);
8380       srel = htab->root.srelgot;
8381       for (i = 0; i < symtab_hdr->sh_info; i++)
8382         {
8383           locals[i].got_offset = (bfd_vma) - 1;
8384           locals[i].tlsdesc_got_jump_table_offset = (bfd_vma) - 1;
8385           if (locals[i].got_refcount > 0)
8386             {
8387               unsigned got_type = locals[i].got_type;
8388               if (got_type & GOT_TLSDESC_GD)
8389                 {
8390                   locals[i].tlsdesc_got_jump_table_offset =
8391                     (htab->root.sgotplt->size
8392                      - aarch64_compute_jump_table_size (htab));
8393                   htab->root.sgotplt->size += GOT_ENTRY_SIZE * 2;
8394                   locals[i].got_offset = (bfd_vma) - 2;
8395                 }
8396
8397               if (got_type & GOT_TLS_GD)
8398                 {
8399                   locals[i].got_offset = htab->root.sgot->size;
8400                   htab->root.sgot->size += GOT_ENTRY_SIZE * 2;
8401                 }
8402
8403               if (got_type & GOT_TLS_IE
8404                   || got_type & GOT_NORMAL)
8405                 {
8406                   locals[i].got_offset = htab->root.sgot->size;
8407                   htab->root.sgot->size += GOT_ENTRY_SIZE;
8408                 }
8409
8410               if (got_type == GOT_UNKNOWN)
8411                 {
8412                 }
8413
8414               if (bfd_link_pic (info))
8415                 {
8416                   if (got_type & GOT_TLSDESC_GD)
8417                     {
8418                       htab->root.srelplt->size += RELOC_SIZE (htab);
8419                       /* Note RELOC_COUNT not incremented here! */
8420                       htab->tlsdesc_plt = (bfd_vma) - 1;
8421                     }
8422
8423                   if (got_type & GOT_TLS_GD)
8424                     htab->root.srelgot->size += RELOC_SIZE (htab) * 2;
8425
8426                   if (got_type & GOT_TLS_IE
8427                       || got_type & GOT_NORMAL)
8428                     htab->root.srelgot->size += RELOC_SIZE (htab);
8429                 }
8430             }
8431           else
8432             {
8433               locals[i].got_refcount = (bfd_vma) - 1;
8434             }
8435         }
8436     }
8437
8438
8439   /* Allocate global sym .plt and .got entries, and space for global
8440      sym dynamic relocs.  */
8441   elf_link_hash_traverse (&htab->root, elfNN_aarch64_allocate_dynrelocs,
8442                           info);
8443
8444   /* Allocate global ifunc sym .plt and .got entries, and space for global
8445      ifunc sym dynamic relocs.  */
8446   elf_link_hash_traverse (&htab->root, elfNN_aarch64_allocate_ifunc_dynrelocs,
8447                           info);
8448
8449   /* Allocate .plt and .got entries, and space for local symbols.  */
8450   htab_traverse (htab->loc_hash_table,
8451                  elfNN_aarch64_allocate_local_dynrelocs,
8452                  info);
8453
8454   /* Allocate .plt and .got entries, and space for local ifunc symbols.  */
8455   htab_traverse (htab->loc_hash_table,
8456                  elfNN_aarch64_allocate_local_ifunc_dynrelocs,
8457                  info);
8458
8459   /* For every jump slot reserved in the sgotplt, reloc_count is
8460      incremented.  However, when we reserve space for TLS descriptors,
8461      it's not incremented, so in order to compute the space reserved
8462      for them, it suffices to multiply the reloc count by the jump
8463      slot size.  */
8464
8465   if (htab->root.srelplt)
8466     htab->sgotplt_jump_table_size = aarch64_compute_jump_table_size (htab);
8467
8468   if (htab->tlsdesc_plt)
8469     {
8470       if (htab->root.splt->size == 0)
8471         htab->root.splt->size += PLT_ENTRY_SIZE;
8472
8473       htab->tlsdesc_plt = htab->root.splt->size;
8474       htab->root.splt->size += PLT_TLSDESC_ENTRY_SIZE;
8475
8476       /* If we're not using lazy TLS relocations, don't generate the
8477          GOT entry required.  */
8478       if (!(info->flags & DF_BIND_NOW))
8479         {
8480           htab->dt_tlsdesc_got = htab->root.sgot->size;
8481           htab->root.sgot->size += GOT_ENTRY_SIZE;
8482         }
8483     }
8484
8485   /* Init mapping symbols information to use later to distingush between
8486      code and data while scanning for errata.  */
8487   if (htab->fix_erratum_835769 || htab->fix_erratum_843419)
8488     for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
8489       {
8490         if (!is_aarch64_elf (ibfd))
8491           continue;
8492         bfd_elfNN_aarch64_init_maps (ibfd);
8493       }
8494
8495   /* We now have determined the sizes of the various dynamic sections.
8496      Allocate memory for them.  */
8497   relocs = FALSE;
8498   for (s = dynobj->sections; s != NULL; s = s->next)
8499     {
8500       if ((s->flags & SEC_LINKER_CREATED) == 0)
8501         continue;
8502
8503       if (s == htab->root.splt
8504           || s == htab->root.sgot
8505           || s == htab->root.sgotplt
8506           || s == htab->root.iplt
8507           || s == htab->root.igotplt || s == htab->sdynbss)
8508         {
8509           /* Strip this section if we don't need it; see the
8510              comment below.  */
8511         }
8512       else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
8513         {
8514           if (s->size != 0 && s != htab->root.srelplt)
8515             relocs = TRUE;
8516
8517           /* We use the reloc_count field as a counter if we need
8518              to copy relocs into the output file.  */
8519           if (s != htab->root.srelplt)
8520             s->reloc_count = 0;
8521         }
8522       else
8523         {
8524           /* It's not one of our sections, so don't allocate space.  */
8525           continue;
8526         }
8527
8528       if (s->size == 0)
8529         {
8530           /* If we don't need this section, strip it from the
8531              output file.  This is mostly to handle .rela.bss and
8532              .rela.plt.  We must create both sections in
8533              create_dynamic_sections, because they must be created
8534              before the linker maps input sections to output
8535              sections.  The linker does that before
8536              adjust_dynamic_symbol is called, and it is that
8537              function which decides whether anything needs to go
8538              into these sections.  */
8539
8540           s->flags |= SEC_EXCLUDE;
8541           continue;
8542         }
8543
8544       if ((s->flags & SEC_HAS_CONTENTS) == 0)
8545         continue;
8546
8547       /* Allocate memory for the section contents.  We use bfd_zalloc
8548          here in case unused entries are not reclaimed before the
8549          section's contents are written out.  This should not happen,
8550          but this way if it does, we get a R_AARCH64_NONE reloc instead
8551          of garbage.  */
8552       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
8553       if (s->contents == NULL)
8554         return FALSE;
8555     }
8556
8557   if (htab->root.dynamic_sections_created)
8558     {
8559       /* Add some entries to the .dynamic section.  We fill in the
8560          values later, in elfNN_aarch64_finish_dynamic_sections, but we
8561          must add the entries now so that we get the correct size for
8562          the .dynamic section.  The DT_DEBUG entry is filled in by the
8563          dynamic linker and used by the debugger.  */
8564 #define add_dynamic_entry(TAG, VAL)                     \
8565       _bfd_elf_add_dynamic_entry (info, TAG, VAL)
8566
8567       if (bfd_link_executable (info))
8568         {
8569           if (!add_dynamic_entry (DT_DEBUG, 0))
8570             return FALSE;
8571         }
8572
8573       if (htab->root.splt->size != 0)
8574         {
8575           if (!add_dynamic_entry (DT_PLTGOT, 0)
8576               || !add_dynamic_entry (DT_PLTRELSZ, 0)
8577               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
8578               || !add_dynamic_entry (DT_JMPREL, 0))
8579             return FALSE;
8580
8581           if (htab->tlsdesc_plt
8582               && (!add_dynamic_entry (DT_TLSDESC_PLT, 0)
8583                   || !add_dynamic_entry (DT_TLSDESC_GOT, 0)))
8584             return FALSE;
8585         }
8586
8587       if (relocs)
8588         {
8589           if (!add_dynamic_entry (DT_RELA, 0)
8590               || !add_dynamic_entry (DT_RELASZ, 0)
8591               || !add_dynamic_entry (DT_RELAENT, RELOC_SIZE (htab)))
8592             return FALSE;
8593
8594           /* If any dynamic relocs apply to a read-only section,
8595              then we need a DT_TEXTREL entry.  */
8596           if ((info->flags & DF_TEXTREL) == 0)
8597             elf_link_hash_traverse (& htab->root, aarch64_readonly_dynrelocs,
8598                                     info);
8599
8600           if ((info->flags & DF_TEXTREL) != 0)
8601             {
8602               if (!add_dynamic_entry (DT_TEXTREL, 0))
8603                 return FALSE;
8604             }
8605         }
8606     }
8607 #undef add_dynamic_entry
8608
8609   return TRUE;
8610 }
8611
8612 static inline void
8613 elf_aarch64_update_plt_entry (bfd *output_bfd,
8614                               bfd_reloc_code_real_type r_type,
8615                               bfd_byte *plt_entry, bfd_vma value)
8616 {
8617   reloc_howto_type *howto = elfNN_aarch64_howto_from_bfd_reloc (r_type);
8618
8619   _bfd_aarch64_elf_put_addend (output_bfd, plt_entry, r_type, howto, value);
8620 }
8621
8622 static void
8623 elfNN_aarch64_create_small_pltn_entry (struct elf_link_hash_entry *h,
8624                                        struct elf_aarch64_link_hash_table
8625                                        *htab, bfd *output_bfd,
8626                                        struct bfd_link_info *info)
8627 {
8628   bfd_byte *plt_entry;
8629   bfd_vma plt_index;
8630   bfd_vma got_offset;
8631   bfd_vma gotplt_entry_address;
8632   bfd_vma plt_entry_address;
8633   Elf_Internal_Rela rela;
8634   bfd_byte *loc;
8635   asection *plt, *gotplt, *relplt;
8636
8637   /* When building a static executable, use .iplt, .igot.plt and
8638      .rela.iplt sections for STT_GNU_IFUNC symbols.  */
8639   if (htab->root.splt != NULL)
8640     {
8641       plt = htab->root.splt;
8642       gotplt = htab->root.sgotplt;
8643       relplt = htab->root.srelplt;
8644     }
8645   else
8646     {
8647       plt = htab->root.iplt;
8648       gotplt = htab->root.igotplt;
8649       relplt = htab->root.irelplt;
8650     }
8651
8652   /* Get the index in the procedure linkage table which
8653      corresponds to this symbol.  This is the index of this symbol
8654      in all the symbols for which we are making plt entries.  The
8655      first entry in the procedure linkage table is reserved.
8656
8657      Get the offset into the .got table of the entry that
8658      corresponds to this function.      Each .got entry is GOT_ENTRY_SIZE
8659      bytes. The first three are reserved for the dynamic linker.
8660
8661      For static executables, we don't reserve anything.  */
8662
8663   if (plt == htab->root.splt)
8664     {
8665       plt_index = (h->plt.offset - htab->plt_header_size) / htab->plt_entry_size;
8666       got_offset = (plt_index + 3) * GOT_ENTRY_SIZE;
8667     }
8668   else
8669     {
8670       plt_index = h->plt.offset / htab->plt_entry_size;
8671       got_offset = plt_index * GOT_ENTRY_SIZE;
8672     }
8673
8674   plt_entry = plt->contents + h->plt.offset;
8675   plt_entry_address = plt->output_section->vma
8676     + plt->output_offset + h->plt.offset;
8677   gotplt_entry_address = gotplt->output_section->vma +
8678     gotplt->output_offset + got_offset;
8679
8680   /* Copy in the boiler-plate for the PLTn entry.  */
8681   memcpy (plt_entry, elfNN_aarch64_small_plt_entry, PLT_SMALL_ENTRY_SIZE);
8682
8683   /* Fill in the top 21 bits for this: ADRP x16, PLT_GOT + n * 8.
8684      ADRP:   ((PG(S+A)-PG(P)) >> 12) & 0x1fffff */
8685   elf_aarch64_update_plt_entry (output_bfd, BFD_RELOC_AARCH64_ADR_HI21_PCREL,
8686                                 plt_entry,
8687                                 PG (gotplt_entry_address) -
8688                                 PG (plt_entry_address));
8689
8690   /* Fill in the lo12 bits for the load from the pltgot.  */
8691   elf_aarch64_update_plt_entry (output_bfd, BFD_RELOC_AARCH64_LDSTNN_LO12,
8692                                 plt_entry + 4,
8693                                 PG_OFFSET (gotplt_entry_address));
8694
8695   /* Fill in the lo12 bits for the add from the pltgot entry.  */
8696   elf_aarch64_update_plt_entry (output_bfd, BFD_RELOC_AARCH64_ADD_LO12,
8697                                 plt_entry + 8,
8698                                 PG_OFFSET (gotplt_entry_address));
8699
8700   /* All the GOTPLT Entries are essentially initialized to PLT0.  */
8701   bfd_put_NN (output_bfd,
8702               plt->output_section->vma + plt->output_offset,
8703               gotplt->contents + got_offset);
8704
8705   rela.r_offset = gotplt_entry_address;
8706
8707   if (h->dynindx == -1
8708       || ((bfd_link_executable (info)
8709            || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
8710           && h->def_regular
8711           && h->type == STT_GNU_IFUNC))
8712     {
8713       /* If an STT_GNU_IFUNC symbol is locally defined, generate
8714          R_AARCH64_IRELATIVE instead of R_AARCH64_JUMP_SLOT.  */
8715       rela.r_info = ELFNN_R_INFO (0, AARCH64_R (IRELATIVE));
8716       rela.r_addend = (h->root.u.def.value
8717                        + h->root.u.def.section->output_section->vma
8718                        + h->root.u.def.section->output_offset);
8719     }
8720   else
8721     {
8722       /* Fill in the entry in the .rela.plt section.  */
8723       rela.r_info = ELFNN_R_INFO (h->dynindx, AARCH64_R (JUMP_SLOT));
8724       rela.r_addend = 0;
8725     }
8726
8727   /* Compute the relocation entry to used based on PLT index and do
8728      not adjust reloc_count. The reloc_count has already been adjusted
8729      to account for this entry.  */
8730   loc = relplt->contents + plt_index * RELOC_SIZE (htab);
8731   bfd_elfNN_swap_reloca_out (output_bfd, &rela, loc);
8732 }
8733
8734 /* Size sections even though they're not dynamic.  We use it to setup
8735    _TLS_MODULE_BASE_, if needed.  */
8736
8737 static bfd_boolean
8738 elfNN_aarch64_always_size_sections (bfd *output_bfd,
8739                                     struct bfd_link_info *info)
8740 {
8741   asection *tls_sec;
8742
8743   if (bfd_link_relocatable (info))
8744     return TRUE;
8745
8746   tls_sec = elf_hash_table (info)->tls_sec;
8747
8748   if (tls_sec)
8749     {
8750       struct elf_link_hash_entry *tlsbase;
8751
8752       tlsbase = elf_link_hash_lookup (elf_hash_table (info),
8753                                       "_TLS_MODULE_BASE_", TRUE, TRUE, FALSE);
8754
8755       if (tlsbase)
8756         {
8757           struct bfd_link_hash_entry *h = NULL;
8758           const struct elf_backend_data *bed =
8759             get_elf_backend_data (output_bfd);
8760
8761           if (!(_bfd_generic_link_add_one_symbol
8762                 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
8763                  tls_sec, 0, NULL, FALSE, bed->collect, &h)))
8764             return FALSE;
8765
8766           tlsbase->type = STT_TLS;
8767           tlsbase = (struct elf_link_hash_entry *) h;
8768           tlsbase->def_regular = 1;
8769           tlsbase->other = STV_HIDDEN;
8770           (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
8771         }
8772     }
8773
8774   return TRUE;
8775 }
8776
8777 /* Finish up dynamic symbol handling.  We set the contents of various
8778    dynamic sections here.  */
8779 static bfd_boolean
8780 elfNN_aarch64_finish_dynamic_symbol (bfd *output_bfd,
8781                                      struct bfd_link_info *info,
8782                                      struct elf_link_hash_entry *h,
8783                                      Elf_Internal_Sym *sym)
8784 {
8785   struct elf_aarch64_link_hash_table *htab;
8786   htab = elf_aarch64_hash_table (info);
8787
8788   if (h->plt.offset != (bfd_vma) - 1)
8789     {
8790       asection *plt, *gotplt, *relplt;
8791
8792       /* This symbol has an entry in the procedure linkage table.  Set
8793          it up.  */
8794
8795       /* When building a static executable, use .iplt, .igot.plt and
8796          .rela.iplt sections for STT_GNU_IFUNC symbols.  */
8797       if (htab->root.splt != NULL)
8798         {
8799           plt = htab->root.splt;
8800           gotplt = htab->root.sgotplt;
8801           relplt = htab->root.srelplt;
8802         }
8803       else
8804         {
8805           plt = htab->root.iplt;
8806           gotplt = htab->root.igotplt;
8807           relplt = htab->root.irelplt;
8808         }
8809
8810       /* This symbol has an entry in the procedure linkage table.  Set
8811          it up.  */
8812       if ((h->dynindx == -1
8813            && !((h->forced_local || bfd_link_executable (info))
8814                 && h->def_regular
8815                 && h->type == STT_GNU_IFUNC))
8816           || plt == NULL
8817           || gotplt == NULL
8818           || relplt == NULL)
8819         abort ();
8820
8821       elfNN_aarch64_create_small_pltn_entry (h, htab, output_bfd, info);
8822       if (!h->def_regular)
8823         {
8824           /* Mark the symbol as undefined, rather than as defined in
8825              the .plt section.  */
8826           sym->st_shndx = SHN_UNDEF;
8827           /* If the symbol is weak we need to clear the value.
8828              Otherwise, the PLT entry would provide a definition for
8829              the symbol even if the symbol wasn't defined anywhere,
8830              and so the symbol would never be NULL.  Leave the value if
8831              there were any relocations where pointer equality matters
8832              (this is a clue for the dynamic linker, to make function
8833              pointer comparisons work between an application and shared
8834              library).  */
8835           if (!h->ref_regular_nonweak || !h->pointer_equality_needed)
8836             sym->st_value = 0;
8837         }
8838     }
8839
8840   if (h->got.offset != (bfd_vma) - 1
8841       && elf_aarch64_hash_entry (h)->got_type == GOT_NORMAL)
8842     {
8843       Elf_Internal_Rela rela;
8844       bfd_byte *loc;
8845
8846       /* This symbol has an entry in the global offset table.  Set it
8847          up.  */
8848       if (htab->root.sgot == NULL || htab->root.srelgot == NULL)
8849         abort ();
8850
8851       rela.r_offset = (htab->root.sgot->output_section->vma
8852                        + htab->root.sgot->output_offset
8853                        + (h->got.offset & ~(bfd_vma) 1));
8854
8855       if (h->def_regular
8856           && h->type == STT_GNU_IFUNC)
8857         {
8858           if (bfd_link_pic (info))
8859             {
8860               /* Generate R_AARCH64_GLOB_DAT.  */
8861               goto do_glob_dat;
8862             }
8863           else
8864             {
8865               asection *plt;
8866
8867               if (!h->pointer_equality_needed)
8868                 abort ();
8869
8870               /* For non-shared object, we can't use .got.plt, which
8871                  contains the real function address if we need pointer
8872                  equality.  We load the GOT entry with the PLT entry.  */
8873               plt = htab->root.splt ? htab->root.splt : htab->root.iplt;
8874               bfd_put_NN (output_bfd, (plt->output_section->vma
8875                                        + plt->output_offset
8876                                        + h->plt.offset),
8877                           htab->root.sgot->contents
8878                           + (h->got.offset & ~(bfd_vma) 1));
8879               return TRUE;
8880             }
8881         }
8882       else if (bfd_link_pic (info) && SYMBOL_REFERENCES_LOCAL (info, h))
8883         {
8884           if (!h->def_regular)
8885             return FALSE;
8886
8887           BFD_ASSERT ((h->got.offset & 1) != 0);
8888           rela.r_info = ELFNN_R_INFO (0, AARCH64_R (RELATIVE));
8889           rela.r_addend = (h->root.u.def.value
8890                            + h->root.u.def.section->output_section->vma
8891                            + h->root.u.def.section->output_offset);
8892         }
8893       else
8894         {
8895 do_glob_dat:
8896           BFD_ASSERT ((h->got.offset & 1) == 0);
8897           bfd_put_NN (output_bfd, (bfd_vma) 0,
8898                       htab->root.sgot->contents + h->got.offset);
8899           rela.r_info = ELFNN_R_INFO (h->dynindx, AARCH64_R (GLOB_DAT));
8900           rela.r_addend = 0;
8901         }
8902
8903       loc = htab->root.srelgot->contents;
8904       loc += htab->root.srelgot->reloc_count++ * RELOC_SIZE (htab);
8905       bfd_elfNN_swap_reloca_out (output_bfd, &rela, loc);
8906     }
8907
8908   if (h->needs_copy)
8909     {
8910       Elf_Internal_Rela rela;
8911       bfd_byte *loc;
8912
8913       /* This symbol needs a copy reloc.  Set it up.  */
8914
8915       if (h->dynindx == -1
8916           || (h->root.type != bfd_link_hash_defined
8917               && h->root.type != bfd_link_hash_defweak)
8918           || htab->srelbss == NULL)
8919         abort ();
8920
8921       rela.r_offset = (h->root.u.def.value
8922                        + h->root.u.def.section->output_section->vma
8923                        + h->root.u.def.section->output_offset);
8924       rela.r_info = ELFNN_R_INFO (h->dynindx, AARCH64_R (COPY));
8925       rela.r_addend = 0;
8926       loc = htab->srelbss->contents;
8927       loc += htab->srelbss->reloc_count++ * RELOC_SIZE (htab);
8928       bfd_elfNN_swap_reloca_out (output_bfd, &rela, loc);
8929     }
8930
8931   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  SYM may
8932      be NULL for local symbols.  */
8933   if (sym != NULL
8934       && (h == elf_hash_table (info)->hdynamic
8935           || h == elf_hash_table (info)->hgot))
8936     sym->st_shndx = SHN_ABS;
8937
8938   return TRUE;
8939 }
8940
8941 /* Finish up local dynamic symbol handling.  We set the contents of
8942    various dynamic sections here.  */
8943
8944 static bfd_boolean
8945 elfNN_aarch64_finish_local_dynamic_symbol (void **slot, void *inf)
8946 {
8947   struct elf_link_hash_entry *h
8948     = (struct elf_link_hash_entry *) *slot;
8949   struct bfd_link_info *info
8950     = (struct bfd_link_info *) inf;
8951
8952   return elfNN_aarch64_finish_dynamic_symbol (info->output_bfd,
8953                                               info, h, NULL);
8954 }
8955
8956 static void
8957 elfNN_aarch64_init_small_plt0_entry (bfd *output_bfd ATTRIBUTE_UNUSED,
8958                                      struct elf_aarch64_link_hash_table
8959                                      *htab)
8960 {
8961   /* Fill in PLT0. Fixme:RR Note this doesn't distinguish between
8962      small and large plts and at the minute just generates
8963      the small PLT.  */
8964
8965   /* PLT0 of the small PLT looks like this in ELF64 -
8966      stp x16, x30, [sp, #-16]!          // Save the reloc and lr on stack.
8967      adrp x16, PLT_GOT + 16             // Get the page base of the GOTPLT
8968      ldr  x17, [x16, #:lo12:PLT_GOT+16] // Load the address of the
8969                                         // symbol resolver
8970      add  x16, x16, #:lo12:PLT_GOT+16   // Load the lo12 bits of the
8971                                         // GOTPLT entry for this.
8972      br   x17
8973      PLT0 will be slightly different in ELF32 due to different got entry
8974      size.
8975    */
8976   bfd_vma plt_got_2nd_ent;      /* Address of GOT[2].  */
8977   bfd_vma plt_base;
8978
8979
8980   memcpy (htab->root.splt->contents, elfNN_aarch64_small_plt0_entry,
8981           PLT_ENTRY_SIZE);
8982   elf_section_data (htab->root.splt->output_section)->this_hdr.sh_entsize =
8983     PLT_ENTRY_SIZE;
8984
8985   plt_got_2nd_ent = (htab->root.sgotplt->output_section->vma
8986                   + htab->root.sgotplt->output_offset
8987                   + GOT_ENTRY_SIZE * 2);
8988
8989   plt_base = htab->root.splt->output_section->vma +
8990     htab->root.splt->output_offset;
8991
8992   /* Fill in the top 21 bits for this: ADRP x16, PLT_GOT + n * 8.
8993      ADRP:   ((PG(S+A)-PG(P)) >> 12) & 0x1fffff */
8994   elf_aarch64_update_plt_entry (output_bfd, BFD_RELOC_AARCH64_ADR_HI21_PCREL,
8995                                 htab->root.splt->contents + 4,
8996                                 PG (plt_got_2nd_ent) - PG (plt_base + 4));
8997
8998   elf_aarch64_update_plt_entry (output_bfd, BFD_RELOC_AARCH64_LDSTNN_LO12,
8999                                 htab->root.splt->contents + 8,
9000                                 PG_OFFSET (plt_got_2nd_ent));
9001
9002   elf_aarch64_update_plt_entry (output_bfd, BFD_RELOC_AARCH64_ADD_LO12,
9003                                 htab->root.splt->contents + 12,
9004                                 PG_OFFSET (plt_got_2nd_ent));
9005 }
9006
9007 static bfd_boolean
9008 elfNN_aarch64_finish_dynamic_sections (bfd *output_bfd,
9009                                        struct bfd_link_info *info)
9010 {
9011   struct elf_aarch64_link_hash_table *htab;
9012   bfd *dynobj;
9013   asection *sdyn;
9014
9015   htab = elf_aarch64_hash_table (info);
9016   dynobj = htab->root.dynobj;
9017   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
9018
9019   if (htab->root.dynamic_sections_created)
9020     {
9021       ElfNN_External_Dyn *dyncon, *dynconend;
9022
9023       if (sdyn == NULL || htab->root.sgot == NULL)
9024         abort ();
9025
9026       dyncon = (ElfNN_External_Dyn *) sdyn->contents;
9027       dynconend = (ElfNN_External_Dyn *) (sdyn->contents + sdyn->size);
9028       for (; dyncon < dynconend; dyncon++)
9029         {
9030           Elf_Internal_Dyn dyn;
9031           asection *s;
9032
9033           bfd_elfNN_swap_dyn_in (dynobj, dyncon, &dyn);
9034
9035           switch (dyn.d_tag)
9036             {
9037             default:
9038               continue;
9039
9040             case DT_PLTGOT:
9041               s = htab->root.sgotplt;
9042               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
9043               break;
9044
9045             case DT_JMPREL:
9046               s = htab->root.srelplt;
9047               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
9048               break;
9049
9050             case DT_PLTRELSZ:
9051               s = htab->root.srelplt;
9052               dyn.d_un.d_val = s->size;
9053               break;
9054
9055             case DT_RELASZ:
9056               /* The procedure linkage table relocs (DT_JMPREL) should
9057                  not be included in the overall relocs (DT_RELA).
9058                  Therefore, we override the DT_RELASZ entry here to
9059                  make it not include the JMPREL relocs.  Since the
9060                  linker script arranges for .rela.plt to follow all
9061                  other relocation sections, we don't have to worry
9062                  about changing the DT_RELA entry.  */
9063               if (htab->root.srelplt != NULL)
9064                 {
9065                   s = htab->root.srelplt;
9066                   dyn.d_un.d_val -= s->size;
9067                 }
9068               break;
9069
9070             case DT_TLSDESC_PLT:
9071               s = htab->root.splt;
9072               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
9073                 + htab->tlsdesc_plt;
9074               break;
9075
9076             case DT_TLSDESC_GOT:
9077               s = htab->root.sgot;
9078               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset
9079                 + htab->dt_tlsdesc_got;
9080               break;
9081             }
9082
9083           bfd_elfNN_swap_dyn_out (output_bfd, &dyn, dyncon);
9084         }
9085
9086     }
9087
9088   /* Fill in the special first entry in the procedure linkage table.  */
9089   if (htab->root.splt && htab->root.splt->size > 0)
9090     {
9091       elfNN_aarch64_init_small_plt0_entry (output_bfd, htab);
9092
9093       elf_section_data (htab->root.splt->output_section)->
9094         this_hdr.sh_entsize = htab->plt_entry_size;
9095
9096
9097       if (htab->tlsdesc_plt)
9098         {
9099           bfd_put_NN (output_bfd, (bfd_vma) 0,
9100                       htab->root.sgot->contents + htab->dt_tlsdesc_got);
9101
9102           memcpy (htab->root.splt->contents + htab->tlsdesc_plt,
9103                   elfNN_aarch64_tlsdesc_small_plt_entry,
9104                   sizeof (elfNN_aarch64_tlsdesc_small_plt_entry));
9105
9106           {
9107             bfd_vma adrp1_addr =
9108               htab->root.splt->output_section->vma
9109               + htab->root.splt->output_offset + htab->tlsdesc_plt + 4;
9110
9111             bfd_vma adrp2_addr = adrp1_addr + 4;
9112
9113             bfd_vma got_addr =
9114               htab->root.sgot->output_section->vma
9115               + htab->root.sgot->output_offset;
9116
9117             bfd_vma pltgot_addr =
9118               htab->root.sgotplt->output_section->vma
9119               + htab->root.sgotplt->output_offset;
9120
9121             bfd_vma dt_tlsdesc_got = got_addr + htab->dt_tlsdesc_got;
9122
9123             bfd_byte *plt_entry =
9124               htab->root.splt->contents + htab->tlsdesc_plt;
9125
9126             /* adrp x2, DT_TLSDESC_GOT */
9127             elf_aarch64_update_plt_entry (output_bfd,
9128                                           BFD_RELOC_AARCH64_ADR_HI21_PCREL,
9129                                           plt_entry + 4,
9130                                           (PG (dt_tlsdesc_got)
9131                                            - PG (adrp1_addr)));
9132
9133             /* adrp x3, 0 */
9134             elf_aarch64_update_plt_entry (output_bfd,
9135                                           BFD_RELOC_AARCH64_ADR_HI21_PCREL,
9136                                           plt_entry + 8,
9137                                           (PG (pltgot_addr)
9138                                            - PG (adrp2_addr)));
9139
9140             /* ldr x2, [x2, #0] */
9141             elf_aarch64_update_plt_entry (output_bfd,
9142                                           BFD_RELOC_AARCH64_LDSTNN_LO12,
9143                                           plt_entry + 12,
9144                                           PG_OFFSET (dt_tlsdesc_got));
9145
9146             /* add x3, x3, 0 */
9147             elf_aarch64_update_plt_entry (output_bfd,
9148                                           BFD_RELOC_AARCH64_ADD_LO12,
9149                                           plt_entry + 16,
9150                                           PG_OFFSET (pltgot_addr));
9151           }
9152         }
9153     }
9154
9155   if (htab->root.sgotplt)
9156     {
9157       if (bfd_is_abs_section (htab->root.sgotplt->output_section))
9158         {
9159           _bfd_error_handler
9160             (_("discarded output section: `%A'"), htab->root.sgotplt);
9161           return FALSE;
9162         }
9163
9164       /* Fill in the first three entries in the global offset table.  */
9165       if (htab->root.sgotplt->size > 0)
9166         {
9167           bfd_put_NN (output_bfd, (bfd_vma) 0, htab->root.sgotplt->contents);
9168
9169           /* Write GOT[1] and GOT[2], needed for the dynamic linker.  */
9170           bfd_put_NN (output_bfd,
9171                       (bfd_vma) 0,
9172                       htab->root.sgotplt->contents + GOT_ENTRY_SIZE);
9173           bfd_put_NN (output_bfd,
9174                       (bfd_vma) 0,
9175                       htab->root.sgotplt->contents + GOT_ENTRY_SIZE * 2);
9176         }
9177
9178       if (htab->root.sgot)
9179         {
9180           if (htab->root.sgot->size > 0)
9181             {
9182               bfd_vma addr =
9183                 sdyn ? sdyn->output_section->vma + sdyn->output_offset : 0;
9184               bfd_put_NN (output_bfd, addr, htab->root.sgot->contents);
9185             }
9186         }
9187
9188       elf_section_data (htab->root.sgotplt->output_section)->
9189         this_hdr.sh_entsize = GOT_ENTRY_SIZE;
9190     }
9191
9192   if (htab->root.sgot && htab->root.sgot->size > 0)
9193     elf_section_data (htab->root.sgot->output_section)->this_hdr.sh_entsize
9194       = GOT_ENTRY_SIZE;
9195
9196   /* Fill PLT and GOT entries for local STT_GNU_IFUNC symbols.  */
9197   htab_traverse (htab->loc_hash_table,
9198                  elfNN_aarch64_finish_local_dynamic_symbol,
9199                  info);
9200
9201   return TRUE;
9202 }
9203
9204 /* Return address for Ith PLT stub in section PLT, for relocation REL
9205    or (bfd_vma) -1 if it should not be included.  */
9206
9207 static bfd_vma
9208 elfNN_aarch64_plt_sym_val (bfd_vma i, const asection *plt,
9209                            const arelent *rel ATTRIBUTE_UNUSED)
9210 {
9211   return plt->vma + PLT_ENTRY_SIZE + i * PLT_SMALL_ENTRY_SIZE;
9212 }
9213
9214 /* Returns TRUE if NAME is an AArch64 mapping symbol.
9215    The ARM ELF standard defines $x (for A64 code) and $d (for data).
9216    It also allows a period initiated suffix to be added to the symbol, ie:
9217    "$[adtx]\.[:sym_char]+".  */
9218
9219 static bfd_boolean
9220 is_aarch64_mapping_symbol (const char * name)
9221 {
9222   return name != NULL /* Paranoia.  */
9223     && name[0] == '$' /* Note: if objcopy --prefix-symbols has been used then
9224                          the mapping symbols could have acquired a prefix.
9225                          We do not support this here, since such symbols no
9226                          longer conform to the ARM ELF ABI.  */
9227     && (name[1] == 'd' || name[1] == 'x')
9228     && (name[2] == 0 || name[2] == '.');
9229   /* FIXME: Strictly speaking the symbol is only a valid mapping symbol if
9230      any characters that follow the period are legal characters for the body
9231      of a symbol's name.  For now we just assume that this is the case.  */
9232 }
9233
9234 /* Make sure that mapping symbols in object files are not removed via the
9235    "strip --strip-unneeded" tool.  These symbols might needed in order to
9236    correctly generate linked files.  Once an object file has been linked,
9237    it should be safe to remove them.  */
9238
9239 static void
9240 elfNN_aarch64_backend_symbol_processing (bfd *abfd, asymbol *sym)
9241 {
9242   if (((abfd->flags & (EXEC_P | DYNAMIC)) == 0)
9243       && sym->section != bfd_abs_section_ptr
9244       && is_aarch64_mapping_symbol (sym->name))
9245     sym->flags |= BSF_KEEP;
9246 }
9247
9248
9249 /* We use this so we can override certain functions
9250    (though currently we don't).  */
9251
9252 const struct elf_size_info elfNN_aarch64_size_info =
9253 {
9254   sizeof (ElfNN_External_Ehdr),
9255   sizeof (ElfNN_External_Phdr),
9256   sizeof (ElfNN_External_Shdr),
9257   sizeof (ElfNN_External_Rel),
9258   sizeof (ElfNN_External_Rela),
9259   sizeof (ElfNN_External_Sym),
9260   sizeof (ElfNN_External_Dyn),
9261   sizeof (Elf_External_Note),
9262   4,                            /* Hash table entry size.  */
9263   1,                            /* Internal relocs per external relocs.  */
9264   ARCH_SIZE,                    /* Arch size.  */
9265   LOG_FILE_ALIGN,               /* Log_file_align.  */
9266   ELFCLASSNN, EV_CURRENT,
9267   bfd_elfNN_write_out_phdrs,
9268   bfd_elfNN_write_shdrs_and_ehdr,
9269   bfd_elfNN_checksum_contents,
9270   bfd_elfNN_write_relocs,
9271   bfd_elfNN_swap_symbol_in,
9272   bfd_elfNN_swap_symbol_out,
9273   bfd_elfNN_slurp_reloc_table,
9274   bfd_elfNN_slurp_symbol_table,
9275   bfd_elfNN_swap_dyn_in,
9276   bfd_elfNN_swap_dyn_out,
9277   bfd_elfNN_swap_reloc_in,
9278   bfd_elfNN_swap_reloc_out,
9279   bfd_elfNN_swap_reloca_in,
9280   bfd_elfNN_swap_reloca_out
9281 };
9282
9283 #define ELF_ARCH                        bfd_arch_aarch64
9284 #define ELF_MACHINE_CODE                EM_AARCH64
9285 #define ELF_MAXPAGESIZE                 0x10000
9286 #define ELF_MINPAGESIZE                 0x1000
9287 #define ELF_COMMONPAGESIZE              0x1000
9288
9289 #define bfd_elfNN_close_and_cleanup             \
9290   elfNN_aarch64_close_and_cleanup
9291
9292 #define bfd_elfNN_bfd_free_cached_info          \
9293   elfNN_aarch64_bfd_free_cached_info
9294
9295 #define bfd_elfNN_bfd_is_target_special_symbol  \
9296   elfNN_aarch64_is_target_special_symbol
9297
9298 #define bfd_elfNN_bfd_link_hash_table_create    \
9299   elfNN_aarch64_link_hash_table_create
9300
9301 #define bfd_elfNN_bfd_merge_private_bfd_data    \
9302   elfNN_aarch64_merge_private_bfd_data
9303
9304 #define bfd_elfNN_bfd_print_private_bfd_data    \
9305   elfNN_aarch64_print_private_bfd_data
9306
9307 #define bfd_elfNN_bfd_reloc_type_lookup         \
9308   elfNN_aarch64_reloc_type_lookup
9309
9310 #define bfd_elfNN_bfd_reloc_name_lookup         \
9311   elfNN_aarch64_reloc_name_lookup
9312
9313 #define bfd_elfNN_bfd_set_private_flags         \
9314   elfNN_aarch64_set_private_flags
9315
9316 #define bfd_elfNN_find_inliner_info             \
9317   elfNN_aarch64_find_inliner_info
9318
9319 #define bfd_elfNN_find_nearest_line             \
9320   elfNN_aarch64_find_nearest_line
9321
9322 #define bfd_elfNN_mkobject                      \
9323   elfNN_aarch64_mkobject
9324
9325 #define bfd_elfNN_new_section_hook              \
9326   elfNN_aarch64_new_section_hook
9327
9328 #define elf_backend_adjust_dynamic_symbol       \
9329   elfNN_aarch64_adjust_dynamic_symbol
9330
9331 #define elf_backend_always_size_sections        \
9332   elfNN_aarch64_always_size_sections
9333
9334 #define elf_backend_check_relocs                \
9335   elfNN_aarch64_check_relocs
9336
9337 #define elf_backend_copy_indirect_symbol        \
9338   elfNN_aarch64_copy_indirect_symbol
9339
9340 /* Create .dynbss, and .rela.bss sections in DYNOBJ, and set up shortcuts
9341    to them in our hash.  */
9342 #define elf_backend_create_dynamic_sections     \
9343   elfNN_aarch64_create_dynamic_sections
9344
9345 #define elf_backend_init_index_section          \
9346   _bfd_elf_init_2_index_sections
9347
9348 #define elf_backend_finish_dynamic_sections     \
9349   elfNN_aarch64_finish_dynamic_sections
9350
9351 #define elf_backend_finish_dynamic_symbol       \
9352   elfNN_aarch64_finish_dynamic_symbol
9353
9354 #define elf_backend_gc_sweep_hook               \
9355   elfNN_aarch64_gc_sweep_hook
9356
9357 #define elf_backend_object_p                    \
9358   elfNN_aarch64_object_p
9359
9360 #define elf_backend_output_arch_local_syms      \
9361   elfNN_aarch64_output_arch_local_syms
9362
9363 #define elf_backend_plt_sym_val                 \
9364   elfNN_aarch64_plt_sym_val
9365
9366 #define elf_backend_post_process_headers        \
9367   elfNN_aarch64_post_process_headers
9368
9369 #define elf_backend_relocate_section            \
9370   elfNN_aarch64_relocate_section
9371
9372 #define elf_backend_reloc_type_class            \
9373   elfNN_aarch64_reloc_type_class
9374
9375 #define elf_backend_section_from_shdr           \
9376   elfNN_aarch64_section_from_shdr
9377
9378 #define elf_backend_size_dynamic_sections       \
9379   elfNN_aarch64_size_dynamic_sections
9380
9381 #define elf_backend_size_info                   \
9382   elfNN_aarch64_size_info
9383
9384 #define elf_backend_write_section               \
9385   elfNN_aarch64_write_section
9386
9387 #define elf_backend_symbol_processing           \
9388   elfNN_aarch64_backend_symbol_processing
9389
9390 #define elf_backend_can_refcount       1
9391 #define elf_backend_can_gc_sections    1
9392 #define elf_backend_plt_readonly       1
9393 #define elf_backend_want_got_plt       1
9394 #define elf_backend_want_plt_sym       0
9395 #define elf_backend_may_use_rel_p      0
9396 #define elf_backend_may_use_rela_p     1
9397 #define elf_backend_default_use_rela_p 1
9398 #define elf_backend_rela_normal        1
9399 #define elf_backend_got_header_size (GOT_ENTRY_SIZE * 3)
9400 #define elf_backend_default_execstack  0
9401 #define elf_backend_extern_protected_data 1
9402
9403 #undef  elf_backend_obj_attrs_section
9404 #define elf_backend_obj_attrs_section           ".ARM.attributes"
9405
9406 #include "elfNN-target.h"
9407
9408 /* CloudABI support.  */
9409
9410 #undef  TARGET_LITTLE_SYM
9411 #define TARGET_LITTLE_SYM       aarch64_elfNN_le_cloudabi_vec
9412 #undef  TARGET_LITTLE_NAME
9413 #define TARGET_LITTLE_NAME      "elfNN-littleaarch64-cloudabi"
9414 #undef  TARGET_BIG_SYM
9415 #define TARGET_BIG_SYM          aarch64_elfNN_be_cloudabi_vec
9416 #undef  TARGET_BIG_NAME
9417 #define TARGET_BIG_NAME         "elfNN-bigaarch64-cloudabi"
9418
9419 #undef  ELF_OSABI
9420 #define ELF_OSABI               ELFOSABI_CLOUDABI
9421
9422 #undef  elfNN_bed
9423 #define elfNN_bed               elfNN_aarch64_cloudabi_bed
9424
9425 #include "elfNN-target.h"