bfd/elfnn-aarch64.c

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