bfd/elf32-arm.c

   1 /* 32-bit ELF support for ARM
   2    Copyright (C) 1998-2016 Free Software Foundation, Inc.
   3
   4    This file is part of BFD, the Binary File Descriptor library.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  19    MA 02110-1301, USA.  */
  20
  21 #include "sysdep.h"
  22 #include <limits.h>
  23
  24 #include "bfd.h"
  25 #include "bfd_stdint.h"
  26 #include "libiberty.h"
  27 #include "libbfd.h"
  28 #include "elf-bfd.h"
  29 #include "elf-nacl.h"
  30 #include "elf-vxworks.h"
  31 #include "elf/arm.h"
  32
  33 /* Return the relocation section associated with NAME.  HTAB is the
  34    bfd's elf32_arm_link_hash_entry.  */
  35 #define RELOC_SECTION(HTAB, NAME) \
  36   ((HTAB)->use_rel ? ".rel" NAME : ".rela" NAME)
  37
  38 /* Return size of a relocation entry.  HTAB is the bfd's
  39    elf32_arm_link_hash_entry.  */
  40 #define RELOC_SIZE(HTAB) \
  41   ((HTAB)->use_rel \
  42    ? sizeof (Elf32_External_Rel) \
  43    : sizeof (Elf32_External_Rela))
  44
  45 /* Return function to swap relocations in.  HTAB is the bfd's
  46    elf32_arm_link_hash_entry.  */
  47 #define SWAP_RELOC_IN(HTAB) \
  48   ((HTAB)->use_rel \
  49    ? bfd_elf32_swap_reloc_in \
  50    : bfd_elf32_swap_reloca_in)
  51
  52 /* Return function to swap relocations out.  HTAB is the bfd's
  53    elf32_arm_link_hash_entry.  */
  54 #define SWAP_RELOC_OUT(HTAB) \
  55   ((HTAB)->use_rel \
  56    ? bfd_elf32_swap_reloc_out \
  57    : bfd_elf32_swap_reloca_out)
  58
  59 #define elf_info_to_howto               0
  60 #define elf_info_to_howto_rel           elf32_arm_info_to_howto
  61
  62 #define ARM_ELF_ABI_VERSION             0
  63 #define ARM_ELF_OS_ABI_VERSION          ELFOSABI_ARM
  64
  65 /* The Adjusted Place, as defined by AAELF.  */
  66 #define Pa(X) ((X) & 0xfffffffc)
  67
  68 static bfd_boolean elf32_arm_write_section (bfd *output_bfd,
  69                                             struct bfd_link_info *link_info,
  70                                             asection *sec,
  71                                             bfd_byte *contents);
  72
  73 /* Note: code such as elf32_arm_reloc_type_lookup expect to use e.g.
  74    R_ARM_PC24 as an index into this, and find the R_ARM_PC24 HOWTO
  75    in that slot.  */
  76
  77 static reloc_howto_type elf32_arm_howto_table_1[] =
  78 {
  79   /* No relocation.  */
  80   HOWTO (R_ARM_NONE,            /* type */
  81          0,                     /* rightshift */
  82          3,                     /* size (0 = byte, 1 = short, 2 = long) */
  83          0,                     /* bitsize */
  84          FALSE,                 /* pc_relative */
  85          0,                     /* bitpos */
  86          complain_overflow_dont,/* complain_on_overflow */
  87          bfd_elf_generic_reloc, /* special_function */
  88          "R_ARM_NONE",          /* name */
  89          FALSE,                 /* partial_inplace */
  90          0,                     /* src_mask */
  91          0,                     /* dst_mask */
  92          FALSE),                /* pcrel_offset */
  93
  94   HOWTO (R_ARM_PC24,            /* type */
  95          2,                     /* rightshift */
  96          2,                     /* size (0 = byte, 1 = short, 2 = long) */
  97          24,                    /* bitsize */
  98          TRUE,                  /* pc_relative */
  99          0,                     /* bitpos */
 100          complain_overflow_signed,/* complain_on_overflow */
 101          bfd_elf_generic_reloc, /* special_function */
 102          "R_ARM_PC24",          /* name */
 103          FALSE,                 /* partial_inplace */
 104          0x00ffffff,            /* src_mask */
 105          0x00ffffff,            /* dst_mask */
 106          TRUE),                 /* pcrel_offset */
 107
 108   /* 32 bit absolute */
 109   HOWTO (R_ARM_ABS32,           /* type */
 110          0,                     /* rightshift */
 111          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 112          32,                    /* bitsize */
 113          FALSE,                 /* pc_relative */
 114          0,                     /* bitpos */
 115          complain_overflow_bitfield,/* complain_on_overflow */
 116          bfd_elf_generic_reloc, /* special_function */
 117          "R_ARM_ABS32",         /* name */
 118          FALSE,                 /* partial_inplace */
 119          0xffffffff,            /* src_mask */
 120          0xffffffff,            /* dst_mask */
 121          FALSE),                /* pcrel_offset */
 122
 123   /* standard 32bit pc-relative reloc */
 124   HOWTO (R_ARM_REL32,           /* type */
 125          0,                     /* rightshift */
 126          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 127          32,                    /* bitsize */
 128          TRUE,                  /* pc_relative */
 129          0,                     /* bitpos */
 130          complain_overflow_bitfield,/* complain_on_overflow */
 131          bfd_elf_generic_reloc, /* special_function */
 132          "R_ARM_REL32",         /* name */
 133          FALSE,                 /* partial_inplace */
 134          0xffffffff,            /* src_mask */
 135          0xffffffff,            /* dst_mask */
 136          TRUE),                 /* pcrel_offset */
 137
 138   /* 8 bit absolute - R_ARM_LDR_PC_G0 in AAELF */
 139   HOWTO (R_ARM_LDR_PC_G0,       /* type */
 140          0,                     /* rightshift */
 141          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 142          32,                    /* bitsize */
 143          TRUE,                  /* pc_relative */
 144          0,                     /* bitpos */
 145          complain_overflow_dont,/* complain_on_overflow */
 146          bfd_elf_generic_reloc, /* special_function */
 147          "R_ARM_LDR_PC_G0",     /* name */
 148          FALSE,                 /* partial_inplace */
 149          0xffffffff,            /* src_mask */
 150          0xffffffff,            /* dst_mask */
 151          TRUE),                 /* pcrel_offset */
 152
 153    /* 16 bit absolute */
 154   HOWTO (R_ARM_ABS16,           /* type */
 155          0,                     /* rightshift */
 156          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 157          16,                    /* bitsize */
 158          FALSE,                 /* pc_relative */
 159          0,                     /* bitpos */
 160          complain_overflow_bitfield,/* complain_on_overflow */
 161          bfd_elf_generic_reloc, /* special_function */
 162          "R_ARM_ABS16",         /* name */
 163          FALSE,                 /* partial_inplace */
 164          0x0000ffff,            /* src_mask */
 165          0x0000ffff,            /* dst_mask */
 166          FALSE),                /* pcrel_offset */
 167
 168   /* 12 bit absolute */
 169   HOWTO (R_ARM_ABS12,           /* type */
 170          0,                     /* rightshift */
 171          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 172          12,                    /* bitsize */
 173          FALSE,                 /* pc_relative */
 174          0,                     /* bitpos */
 175          complain_overflow_bitfield,/* complain_on_overflow */
 176          bfd_elf_generic_reloc, /* special_function */
 177          "R_ARM_ABS12",         /* name */
 178          FALSE,                 /* partial_inplace */
 179          0x00000fff,            /* src_mask */
 180          0x00000fff,            /* dst_mask */
 181          FALSE),                /* pcrel_offset */
 182
 183   HOWTO (R_ARM_THM_ABS5,        /* type */
 184          6,                     /* rightshift */
 185          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 186          5,                     /* bitsize */
 187          FALSE,                 /* pc_relative */
 188          0,                     /* bitpos */
 189          complain_overflow_bitfield,/* complain_on_overflow */
 190          bfd_elf_generic_reloc, /* special_function */
 191          "R_ARM_THM_ABS5",      /* name */
 192          FALSE,                 /* partial_inplace */
 193          0x000007e0,            /* src_mask */
 194          0x000007e0,            /* dst_mask */
 195          FALSE),                /* pcrel_offset */
 196
 197   /* 8 bit absolute */
 198   HOWTO (R_ARM_ABS8,            /* type */
 199          0,                     /* rightshift */
 200          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 201          8,                     /* bitsize */
 202          FALSE,                 /* pc_relative */
 203          0,                     /* bitpos */
 204          complain_overflow_bitfield,/* complain_on_overflow */
 205          bfd_elf_generic_reloc, /* special_function */
 206          "R_ARM_ABS8",          /* name */
 207          FALSE,                 /* partial_inplace */
 208          0x000000ff,            /* src_mask */
 209          0x000000ff,            /* dst_mask */
 210          FALSE),                /* pcrel_offset */
 211
 212   HOWTO (R_ARM_SBREL32,         /* type */
 213          0,                     /* rightshift */
 214          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 215          32,                    /* bitsize */
 216          FALSE,                 /* pc_relative */
 217          0,                     /* bitpos */
 218          complain_overflow_dont,/* complain_on_overflow */
 219          bfd_elf_generic_reloc, /* special_function */
 220          "R_ARM_SBREL32",       /* name */
 221          FALSE,                 /* partial_inplace */
 222          0xffffffff,            /* src_mask */
 223          0xffffffff,            /* dst_mask */
 224          FALSE),                /* pcrel_offset */
 225
 226   HOWTO (R_ARM_THM_CALL,        /* type */
 227          1,                     /* rightshift */
 228          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 229          24,                    /* bitsize */
 230          TRUE,                  /* pc_relative */
 231          0,                     /* bitpos */
 232          complain_overflow_signed,/* complain_on_overflow */
 233          bfd_elf_generic_reloc, /* special_function */
 234          "R_ARM_THM_CALL",      /* name */
 235          FALSE,                 /* partial_inplace */
 236          0x07ff2fff,            /* src_mask */
 237          0x07ff2fff,            /* dst_mask */
 238          TRUE),                 /* pcrel_offset */
 239
 240   HOWTO (R_ARM_THM_PC8,         /* type */
 241          1,                     /* rightshift */
 242          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 243          8,                     /* bitsize */
 244          TRUE,                  /* pc_relative */
 245          0,                     /* bitpos */
 246          complain_overflow_signed,/* complain_on_overflow */
 247          bfd_elf_generic_reloc, /* special_function */
 248          "R_ARM_THM_PC8",       /* name */
 249          FALSE,                 /* partial_inplace */
 250          0x000000ff,            /* src_mask */
 251          0x000000ff,            /* dst_mask */
 252          TRUE),                 /* pcrel_offset */
 253
 254   HOWTO (R_ARM_BREL_ADJ,        /* type */
 255          1,                     /* rightshift */
 256          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 257          32,                    /* bitsize */
 258          FALSE,                 /* pc_relative */
 259          0,                     /* bitpos */
 260          complain_overflow_signed,/* complain_on_overflow */
 261          bfd_elf_generic_reloc, /* special_function */
 262          "R_ARM_BREL_ADJ",      /* name */
 263          FALSE,                 /* partial_inplace */
 264          0xffffffff,            /* src_mask */
 265          0xffffffff,            /* dst_mask */
 266          FALSE),                /* pcrel_offset */
 267
 268   HOWTO (R_ARM_TLS_DESC,        /* type */
 269          0,                     /* rightshift */
 270          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 271          32,                    /* bitsize */
 272          FALSE,                 /* pc_relative */
 273          0,                     /* bitpos */
 274          complain_overflow_bitfield,/* complain_on_overflow */
 275          bfd_elf_generic_reloc, /* special_function */
 276          "R_ARM_TLS_DESC",      /* name */
 277          FALSE,                 /* partial_inplace */
 278          0xffffffff,            /* src_mask */
 279          0xffffffff,            /* dst_mask */
 280          FALSE),                /* pcrel_offset */
 281
 282   HOWTO (R_ARM_THM_SWI8,        /* type */
 283          0,                     /* rightshift */
 284          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 285          0,                     /* bitsize */
 286          FALSE,                 /* pc_relative */
 287          0,                     /* bitpos */
 288          complain_overflow_signed,/* complain_on_overflow */
 289          bfd_elf_generic_reloc, /* special_function */
 290          "R_ARM_SWI8",          /* name */
 291          FALSE,                 /* partial_inplace */
 292          0x00000000,            /* src_mask */
 293          0x00000000,            /* dst_mask */
 294          FALSE),                /* pcrel_offset */
 295
 296   /* BLX instruction for the ARM.  */
 297   HOWTO (R_ARM_XPC25,           /* type */
 298          2,                     /* rightshift */
 299          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 300          24,                    /* bitsize */
 301          TRUE,                  /* pc_relative */
 302          0,                     /* bitpos */
 303          complain_overflow_signed,/* complain_on_overflow */
 304          bfd_elf_generic_reloc, /* special_function */
 305          "R_ARM_XPC25",         /* name */
 306          FALSE,                 /* partial_inplace */
 307          0x00ffffff,            /* src_mask */
 308          0x00ffffff,            /* dst_mask */
 309          TRUE),                 /* pcrel_offset */
 310
 311   /* BLX instruction for the Thumb.  */
 312   HOWTO (R_ARM_THM_XPC22,       /* type */
 313          2,                     /* rightshift */
 314          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 315          24,                    /* bitsize */
 316          TRUE,                  /* pc_relative */
 317          0,                     /* bitpos */
 318          complain_overflow_signed,/* complain_on_overflow */
 319          bfd_elf_generic_reloc, /* special_function */
 320          "R_ARM_THM_XPC22",     /* name */
 321          FALSE,                 /* partial_inplace */
 322          0x07ff2fff,            /* src_mask */
 323          0x07ff2fff,            /* dst_mask */
 324          TRUE),                 /* pcrel_offset */
 325
 326   /* Dynamic TLS relocations.  */
 327
 328   HOWTO (R_ARM_TLS_DTPMOD32,    /* type */
 329          0,                     /* rightshift */
 330          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 331          32,                    /* bitsize */
 332          FALSE,                 /* pc_relative */
 333          0,                     /* bitpos */
 334          complain_overflow_bitfield,/* complain_on_overflow */
 335          bfd_elf_generic_reloc, /* special_function */
 336          "R_ARM_TLS_DTPMOD32",  /* name */
 337          TRUE,                  /* partial_inplace */
 338          0xffffffff,            /* src_mask */
 339          0xffffffff,            /* dst_mask */
 340          FALSE),                /* pcrel_offset */
 341
 342   HOWTO (R_ARM_TLS_DTPOFF32,    /* type */
 343          0,                     /* rightshift */
 344          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 345          32,                    /* bitsize */
 346          FALSE,                 /* pc_relative */
 347          0,                     /* bitpos */
 348          complain_overflow_bitfield,/* complain_on_overflow */
 349          bfd_elf_generic_reloc, /* special_function */
 350          "R_ARM_TLS_DTPOFF32",  /* name */
 351          TRUE,                  /* partial_inplace */
 352          0xffffffff,            /* src_mask */
 353          0xffffffff,            /* dst_mask */
 354          FALSE),                /* pcrel_offset */
 355
 356   HOWTO (R_ARM_TLS_TPOFF32,     /* type */
 357          0,                     /* rightshift */
 358          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 359          32,                    /* bitsize */
 360          FALSE,                 /* pc_relative */
 361          0,                     /* bitpos */
 362          complain_overflow_bitfield,/* complain_on_overflow */
 363          bfd_elf_generic_reloc, /* special_function */
 364          "R_ARM_TLS_TPOFF32",   /* name */
 365          TRUE,                  /* partial_inplace */
 366          0xffffffff,            /* src_mask */
 367          0xffffffff,            /* dst_mask */
 368          FALSE),                /* pcrel_offset */
 369
 370   /* Relocs used in ARM Linux */
 371
 372   HOWTO (R_ARM_COPY,            /* type */
 373          0,                     /* rightshift */
 374          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 375          32,                    /* bitsize */
 376          FALSE,                 /* pc_relative */
 377          0,                     /* bitpos */
 378          complain_overflow_bitfield,/* complain_on_overflow */
 379          bfd_elf_generic_reloc, /* special_function */
 380          "R_ARM_COPY",          /* name */
 381          TRUE,                  /* partial_inplace */
 382          0xffffffff,            /* src_mask */
 383          0xffffffff,            /* dst_mask */
 384          FALSE),                /* pcrel_offset */
 385
 386   HOWTO (R_ARM_GLOB_DAT,        /* type */
 387          0,                     /* rightshift */
 388          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 389          32,                    /* bitsize */
 390          FALSE,                 /* pc_relative */
 391          0,                     /* bitpos */
 392          complain_overflow_bitfield,/* complain_on_overflow */
 393          bfd_elf_generic_reloc, /* special_function */
 394          "R_ARM_GLOB_DAT",      /* name */
 395          TRUE,                  /* partial_inplace */
 396          0xffffffff,            /* src_mask */
 397          0xffffffff,            /* dst_mask */
 398          FALSE),                /* pcrel_offset */
 399
 400   HOWTO (R_ARM_JUMP_SLOT,       /* type */
 401          0,                     /* rightshift */
 402          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 403          32,                    /* bitsize */
 404          FALSE,                 /* pc_relative */
 405          0,                     /* bitpos */
 406          complain_overflow_bitfield,/* complain_on_overflow */
 407          bfd_elf_generic_reloc, /* special_function */
 408          "R_ARM_JUMP_SLOT",     /* name */
 409          TRUE,                  /* partial_inplace */
 410          0xffffffff,            /* src_mask */
 411          0xffffffff,            /* dst_mask */
 412          FALSE),                /* pcrel_offset */
 413
 414   HOWTO (R_ARM_RELATIVE,        /* type */
 415          0,                     /* rightshift */
 416          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 417          32,                    /* bitsize */
 418          FALSE,                 /* pc_relative */
 419          0,                     /* bitpos */
 420          complain_overflow_bitfield,/* complain_on_overflow */
 421          bfd_elf_generic_reloc, /* special_function */
 422          "R_ARM_RELATIVE",      /* name */
 423          TRUE,                  /* partial_inplace */
 424          0xffffffff,            /* src_mask */
 425          0xffffffff,            /* dst_mask */
 426          FALSE),                /* pcrel_offset */
 427
 428   HOWTO (R_ARM_GOTOFF32,        /* type */
 429          0,                     /* rightshift */
 430          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 431          32,                    /* bitsize */
 432          FALSE,                 /* pc_relative */
 433          0,                     /* bitpos */
 434          complain_overflow_bitfield,/* complain_on_overflow */
 435          bfd_elf_generic_reloc, /* special_function */
 436          "R_ARM_GOTOFF32",      /* name */
 437          TRUE,                  /* partial_inplace */
 438          0xffffffff,            /* src_mask */
 439          0xffffffff,            /* dst_mask */
 440          FALSE),                /* pcrel_offset */
 441
 442   HOWTO (R_ARM_GOTPC,           /* type */
 443          0,                     /* rightshift */
 444          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 445          32,                    /* bitsize */
 446          TRUE,                  /* pc_relative */
 447          0,                     /* bitpos */
 448          complain_overflow_bitfield,/* complain_on_overflow */
 449          bfd_elf_generic_reloc, /* special_function */
 450          "R_ARM_GOTPC",         /* name */
 451          TRUE,                  /* partial_inplace */
 452          0xffffffff,            /* src_mask */
 453          0xffffffff,            /* dst_mask */
 454          TRUE),                 /* pcrel_offset */
 455
 456   HOWTO (R_ARM_GOT32,           /* type */
 457          0,                     /* rightshift */
 458          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 459          32,                    /* bitsize */
 460          FALSE,                 /* pc_relative */
 461          0,                     /* bitpos */
 462          complain_overflow_bitfield,/* complain_on_overflow */
 463          bfd_elf_generic_reloc, /* special_function */
 464          "R_ARM_GOT32",         /* name */
 465          TRUE,                  /* partial_inplace */
 466          0xffffffff,            /* src_mask */
 467          0xffffffff,            /* dst_mask */
 468          FALSE),                /* pcrel_offset */
 469
 470   HOWTO (R_ARM_PLT32,           /* type */
 471          2,                     /* rightshift */
 472          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 473          24,                    /* bitsize */
 474          TRUE,                  /* pc_relative */
 475          0,                     /* bitpos */
 476          complain_overflow_bitfield,/* complain_on_overflow */
 477          bfd_elf_generic_reloc, /* special_function */
 478          "R_ARM_PLT32",         /* name */
 479          FALSE,                 /* partial_inplace */
 480          0x00ffffff,            /* src_mask */
 481          0x00ffffff,            /* dst_mask */
 482          TRUE),                 /* pcrel_offset */
 483
 484   HOWTO (R_ARM_CALL,            /* type */
 485          2,                     /* rightshift */
 486          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 487          24,                    /* bitsize */
 488          TRUE,                  /* pc_relative */
 489          0,                     /* bitpos */
 490          complain_overflow_signed,/* complain_on_overflow */
 491          bfd_elf_generic_reloc, /* special_function */
 492          "R_ARM_CALL",          /* name */
 493          FALSE,                 /* partial_inplace */
 494          0x00ffffff,            /* src_mask */
 495          0x00ffffff,            /* dst_mask */
 496          TRUE),                 /* pcrel_offset */
 497
 498   HOWTO (R_ARM_JUMP24,          /* type */
 499          2,                     /* rightshift */
 500          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 501          24,                    /* bitsize */
 502          TRUE,                  /* pc_relative */
 503          0,                     /* bitpos */
 504          complain_overflow_signed,/* complain_on_overflow */
 505          bfd_elf_generic_reloc, /* special_function */
 506          "R_ARM_JUMP24",        /* name */
 507          FALSE,                 /* partial_inplace */
 508          0x00ffffff,            /* src_mask */
 509          0x00ffffff,            /* dst_mask */
 510          TRUE),                 /* pcrel_offset */
 511
 512   HOWTO (R_ARM_THM_JUMP24,      /* type */
 513          1,                     /* rightshift */
 514          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 515          24,                    /* bitsize */
 516          TRUE,                  /* pc_relative */
 517          0,                     /* bitpos */
 518          complain_overflow_signed,/* complain_on_overflow */
 519          bfd_elf_generic_reloc, /* special_function */
 520          "R_ARM_THM_JUMP24",    /* name */
 521          FALSE,                 /* partial_inplace */
 522          0x07ff2fff,            /* src_mask */
 523          0x07ff2fff,            /* dst_mask */
 524          TRUE),                 /* pcrel_offset */
 525
 526   HOWTO (R_ARM_BASE_ABS,        /* type */
 527          0,                     /* rightshift */
 528          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 529          32,                    /* bitsize */
 530          FALSE,                 /* pc_relative */
 531          0,                     /* bitpos */
 532          complain_overflow_dont,/* complain_on_overflow */
 533          bfd_elf_generic_reloc, /* special_function */
 534          "R_ARM_BASE_ABS",      /* name */
 535          FALSE,                 /* partial_inplace */
 536          0xffffffff,            /* src_mask */
 537          0xffffffff,            /* dst_mask */
 538          FALSE),                /* pcrel_offset */
 539
 540   HOWTO (R_ARM_ALU_PCREL7_0,    /* type */
 541          0,                     /* rightshift */
 542          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 543          12,                    /* bitsize */
 544          TRUE,                  /* pc_relative */
 545          0,                     /* bitpos */
 546          complain_overflow_dont,/* complain_on_overflow */
 547          bfd_elf_generic_reloc, /* special_function */
 548          "R_ARM_ALU_PCREL_7_0", /* name */
 549          FALSE,                 /* partial_inplace */
 550          0x00000fff,            /* src_mask */
 551          0x00000fff,            /* dst_mask */
 552          TRUE),                 /* pcrel_offset */
 553
 554   HOWTO (R_ARM_ALU_PCREL15_8,   /* type */
 555          0,                     /* rightshift */
 556          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 557          12,                    /* bitsize */
 558          TRUE,                  /* pc_relative */
 559          8,                     /* bitpos */
 560          complain_overflow_dont,/* complain_on_overflow */
 561          bfd_elf_generic_reloc, /* special_function */
 562          "R_ARM_ALU_PCREL_15_8",/* name */
 563          FALSE,                 /* partial_inplace */
 564          0x00000fff,            /* src_mask */
 565          0x00000fff,            /* dst_mask */
 566          TRUE),                 /* pcrel_offset */
 567
 568   HOWTO (R_ARM_ALU_PCREL23_15,  /* type */
 569          0,                     /* rightshift */
 570          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 571          12,                    /* bitsize */
 572          TRUE,                  /* pc_relative */
 573          16,                    /* bitpos */
 574          complain_overflow_dont,/* complain_on_overflow */
 575          bfd_elf_generic_reloc, /* special_function */
 576          "R_ARM_ALU_PCREL_23_15",/* name */
 577          FALSE,                 /* partial_inplace */
 578          0x00000fff,            /* src_mask */
 579          0x00000fff,            /* dst_mask */
 580          TRUE),                 /* pcrel_offset */
 581
 582   HOWTO (R_ARM_LDR_SBREL_11_0,  /* type */
 583          0,                     /* rightshift */
 584          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 585          12,                    /* bitsize */
 586          FALSE,                 /* pc_relative */
 587          0,                     /* bitpos */
 588          complain_overflow_dont,/* complain_on_overflow */
 589          bfd_elf_generic_reloc, /* special_function */
 590          "R_ARM_LDR_SBREL_11_0",/* name */
 591          FALSE,                 /* partial_inplace */
 592          0x00000fff,            /* src_mask */
 593          0x00000fff,            /* dst_mask */
 594          FALSE),                /* pcrel_offset */
 595
 596   HOWTO (R_ARM_ALU_SBREL_19_12, /* type */
 597          0,                     /* rightshift */
 598          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 599          8,                     /* bitsize */
 600          FALSE,                 /* pc_relative */
 601          12,                    /* bitpos */
 602          complain_overflow_dont,/* complain_on_overflow */
 603          bfd_elf_generic_reloc, /* special_function */
 604          "R_ARM_ALU_SBREL_19_12",/* name */
 605          FALSE,                 /* partial_inplace */
 606          0x000ff000,            /* src_mask */
 607          0x000ff000,            /* dst_mask */
 608          FALSE),                /* pcrel_offset */
 609
 610   HOWTO (R_ARM_ALU_SBREL_27_20, /* type */
 611          0,                     /* rightshift */
 612          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 613          8,                     /* bitsize */
 614          FALSE,                 /* pc_relative */
 615          20,                    /* bitpos */
 616          complain_overflow_dont,/* complain_on_overflow */
 617          bfd_elf_generic_reloc, /* special_function */
 618          "R_ARM_ALU_SBREL_27_20",/* name */
 619          FALSE,                 /* partial_inplace */
 620          0x0ff00000,            /* src_mask */
 621          0x0ff00000,            /* dst_mask */
 622          FALSE),                /* pcrel_offset */
 623
 624   HOWTO (R_ARM_TARGET1,         /* type */
 625          0,                     /* rightshift */
 626          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 627          32,                    /* bitsize */
 628          FALSE,                 /* pc_relative */
 629          0,                     /* bitpos */
 630          complain_overflow_dont,/* complain_on_overflow */
 631          bfd_elf_generic_reloc, /* special_function */
 632          "R_ARM_TARGET1",       /* name */
 633          FALSE,                 /* partial_inplace */
 634          0xffffffff,            /* src_mask */
 635          0xffffffff,            /* dst_mask */
 636          FALSE),                /* pcrel_offset */
 637
 638   HOWTO (R_ARM_ROSEGREL32,      /* type */
 639          0,                     /* rightshift */
 640          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 641          32,                    /* bitsize */
 642          FALSE,                 /* pc_relative */
 643          0,                     /* bitpos */
 644          complain_overflow_dont,/* complain_on_overflow */
 645          bfd_elf_generic_reloc, /* special_function */
 646          "R_ARM_ROSEGREL32",    /* name */
 647          FALSE,                 /* partial_inplace */
 648          0xffffffff,            /* src_mask */
 649          0xffffffff,            /* dst_mask */
 650          FALSE),                /* pcrel_offset */
 651
 652   HOWTO (R_ARM_V4BX,            /* type */
 653          0,                     /* rightshift */
 654          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 655          32,                    /* bitsize */
 656          FALSE,                 /* pc_relative */
 657          0,                     /* bitpos */
 658          complain_overflow_dont,/* complain_on_overflow */
 659          bfd_elf_generic_reloc, /* special_function */
 660          "R_ARM_V4BX",          /* name */
 661          FALSE,                 /* partial_inplace */
 662          0xffffffff,            /* src_mask */
 663          0xffffffff,            /* dst_mask */
 664          FALSE),                /* pcrel_offset */
 665
 666   HOWTO (R_ARM_TARGET2,         /* type */
 667          0,                     /* rightshift */
 668          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 669          32,                    /* bitsize */
 670          FALSE,                 /* pc_relative */
 671          0,                     /* bitpos */
 672          complain_overflow_signed,/* complain_on_overflow */
 673          bfd_elf_generic_reloc, /* special_function */
 674          "R_ARM_TARGET2",       /* name */
 675          FALSE,                 /* partial_inplace */
 676          0xffffffff,            /* src_mask */
 677          0xffffffff,            /* dst_mask */
 678          TRUE),                 /* pcrel_offset */
 679
 680   HOWTO (R_ARM_PREL31,          /* type */
 681          0,                     /* rightshift */
 682          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 683          31,                    /* bitsize */
 684          TRUE,                  /* pc_relative */
 685          0,                     /* bitpos */
 686          complain_overflow_signed,/* complain_on_overflow */
 687          bfd_elf_generic_reloc, /* special_function */
 688          "R_ARM_PREL31",        /* name */
 689          FALSE,                 /* partial_inplace */
 690          0x7fffffff,            /* src_mask */
 691          0x7fffffff,            /* dst_mask */
 692          TRUE),                 /* pcrel_offset */
 693
 694   HOWTO (R_ARM_MOVW_ABS_NC,     /* type */
 695          0,                     /* rightshift */
 696          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 697          16,                    /* bitsize */
 698          FALSE,                 /* pc_relative */
 699          0,                     /* bitpos */
 700          complain_overflow_dont,/* complain_on_overflow */
 701          bfd_elf_generic_reloc, /* special_function */
 702          "R_ARM_MOVW_ABS_NC",   /* name */
 703          FALSE,                 /* partial_inplace */
 704          0x000f0fff,            /* src_mask */
 705          0x000f0fff,            /* dst_mask */
 706          FALSE),                /* pcrel_offset */
 707
 708   HOWTO (R_ARM_MOVT_ABS,        /* type */
 709          0,                     /* rightshift */
 710          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 711          16,                    /* bitsize */
 712          FALSE,                 /* pc_relative */
 713          0,                     /* bitpos */
 714          complain_overflow_bitfield,/* complain_on_overflow */
 715          bfd_elf_generic_reloc, /* special_function */
 716          "R_ARM_MOVT_ABS",      /* name */
 717          FALSE,                 /* partial_inplace */
 718          0x000f0fff,            /* src_mask */
 719          0x000f0fff,            /* dst_mask */
 720          FALSE),                /* pcrel_offset */
 721
 722   HOWTO (R_ARM_MOVW_PREL_NC,    /* type */
 723          0,                     /* rightshift */
 724          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 725          16,                    /* bitsize */
 726          TRUE,                  /* pc_relative */
 727          0,                     /* bitpos */
 728          complain_overflow_dont,/* complain_on_overflow */
 729          bfd_elf_generic_reloc, /* special_function */
 730          "R_ARM_MOVW_PREL_NC",  /* name */
 731          FALSE,                 /* partial_inplace */
 732          0x000f0fff,            /* src_mask */
 733          0x000f0fff,            /* dst_mask */
 734          TRUE),                 /* pcrel_offset */
 735
 736   HOWTO (R_ARM_MOVT_PREL,       /* type */
 737          0,                     /* rightshift */
 738          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 739          16,                    /* bitsize */
 740          TRUE,                  /* pc_relative */
 741          0,                     /* bitpos */
 742          complain_overflow_bitfield,/* complain_on_overflow */
 743          bfd_elf_generic_reloc, /* special_function */
 744          "R_ARM_MOVT_PREL",     /* name */
 745          FALSE,                 /* partial_inplace */
 746          0x000f0fff,            /* src_mask */
 747          0x000f0fff,            /* dst_mask */
 748          TRUE),                 /* pcrel_offset */
 749
 750   HOWTO (R_ARM_THM_MOVW_ABS_NC, /* type */
 751          0,                     /* rightshift */
 752          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 753          16,                    /* bitsize */
 754          FALSE,                 /* pc_relative */
 755          0,                     /* bitpos */
 756          complain_overflow_dont,/* complain_on_overflow */
 757          bfd_elf_generic_reloc, /* special_function */
 758          "R_ARM_THM_MOVW_ABS_NC",/* name */
 759          FALSE,                 /* partial_inplace */
 760          0x040f70ff,            /* src_mask */
 761          0x040f70ff,            /* dst_mask */
 762          FALSE),                /* pcrel_offset */
 763
 764   HOWTO (R_ARM_THM_MOVT_ABS,    /* type */
 765          0,                     /* rightshift */
 766          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 767          16,                    /* bitsize */
 768          FALSE,                 /* pc_relative */
 769          0,                     /* bitpos */
 770          complain_overflow_bitfield,/* complain_on_overflow */
 771          bfd_elf_generic_reloc, /* special_function */
 772          "R_ARM_THM_MOVT_ABS",  /* name */
 773          FALSE,                 /* partial_inplace */
 774          0x040f70ff,            /* src_mask */
 775          0x040f70ff,            /* dst_mask */
 776          FALSE),                /* pcrel_offset */
 777
 778   HOWTO (R_ARM_THM_MOVW_PREL_NC,/* type */
 779          0,                     /* rightshift */
 780          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 781          16,                    /* bitsize */
 782          TRUE,                  /* pc_relative */
 783          0,                     /* bitpos */
 784          complain_overflow_dont,/* complain_on_overflow */
 785          bfd_elf_generic_reloc, /* special_function */
 786          "R_ARM_THM_MOVW_PREL_NC",/* name */
 787          FALSE,                 /* partial_inplace */
 788          0x040f70ff,            /* src_mask */
 789          0x040f70ff,            /* dst_mask */
 790          TRUE),                 /* pcrel_offset */
 791
 792   HOWTO (R_ARM_THM_MOVT_PREL,   /* type */
 793          0,                     /* rightshift */
 794          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 795          16,                    /* bitsize */
 796          TRUE,                  /* pc_relative */
 797          0,                     /* bitpos */
 798          complain_overflow_bitfield,/* complain_on_overflow */
 799          bfd_elf_generic_reloc, /* special_function */
 800          "R_ARM_THM_MOVT_PREL", /* name */
 801          FALSE,                 /* partial_inplace */
 802          0x040f70ff,            /* src_mask */
 803          0x040f70ff,            /* dst_mask */
 804          TRUE),                 /* pcrel_offset */
 805
 806   HOWTO (R_ARM_THM_JUMP19,      /* type */
 807          1,                     /* rightshift */
 808          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 809          19,                    /* bitsize */
 810          TRUE,                  /* pc_relative */
 811          0,                     /* bitpos */
 812          complain_overflow_signed,/* complain_on_overflow */
 813          bfd_elf_generic_reloc, /* special_function */
 814          "R_ARM_THM_JUMP19",    /* name */
 815          FALSE,                 /* partial_inplace */
 816          0x043f2fff,            /* src_mask */
 817          0x043f2fff,            /* dst_mask */
 818          TRUE),                 /* pcrel_offset */
 819
 820   HOWTO (R_ARM_THM_JUMP6,       /* type */
 821          1,                     /* rightshift */
 822          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 823          6,                     /* bitsize */
 824          TRUE,                  /* pc_relative */
 825          0,                     /* bitpos */
 826          complain_overflow_unsigned,/* complain_on_overflow */
 827          bfd_elf_generic_reloc, /* special_function */
 828          "R_ARM_THM_JUMP6",     /* name */
 829          FALSE,                 /* partial_inplace */
 830          0x02f8,                /* src_mask */
 831          0x02f8,                /* dst_mask */
 832          TRUE),                 /* pcrel_offset */
 833
 834   /* These are declared as 13-bit signed relocations because we can
 835      address -4095 .. 4095(base) by altering ADDW to SUBW or vice
 836      versa.  */
 837   HOWTO (R_ARM_THM_ALU_PREL_11_0,/* type */
 838          0,                     /* rightshift */
 839          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 840          13,                    /* bitsize */
 841          TRUE,                  /* pc_relative */
 842          0,                     /* bitpos */
 843          complain_overflow_dont,/* complain_on_overflow */
 844          bfd_elf_generic_reloc, /* special_function */
 845          "R_ARM_THM_ALU_PREL_11_0",/* name */
 846          FALSE,                 /* partial_inplace */
 847          0xffffffff,            /* src_mask */
 848          0xffffffff,            /* dst_mask */
 849          TRUE),                 /* pcrel_offset */
 850
 851   HOWTO (R_ARM_THM_PC12,        /* type */
 852          0,                     /* rightshift */
 853          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 854          13,                    /* bitsize */
 855          TRUE,                  /* pc_relative */
 856          0,                     /* bitpos */
 857          complain_overflow_dont,/* complain_on_overflow */
 858          bfd_elf_generic_reloc, /* special_function */
 859          "R_ARM_THM_PC12",      /* name */
 860          FALSE,                 /* partial_inplace */
 861          0xffffffff,            /* src_mask */
 862          0xffffffff,            /* dst_mask */
 863          TRUE),                 /* pcrel_offset */
 864
 865   HOWTO (R_ARM_ABS32_NOI,       /* type */
 866          0,                     /* rightshift */
 867          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 868          32,                    /* bitsize */
 869          FALSE,                 /* pc_relative */
 870          0,                     /* bitpos */
 871          complain_overflow_dont,/* complain_on_overflow */
 872          bfd_elf_generic_reloc, /* special_function */
 873          "R_ARM_ABS32_NOI",     /* name */
 874          FALSE,                 /* partial_inplace */
 875          0xffffffff,            /* src_mask */
 876          0xffffffff,            /* dst_mask */
 877          FALSE),                /* pcrel_offset */
 878
 879   HOWTO (R_ARM_REL32_NOI,       /* type */
 880          0,                     /* rightshift */
 881          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 882          32,                    /* bitsize */
 883          TRUE,                  /* pc_relative */
 884          0,                     /* bitpos */
 885          complain_overflow_dont,/* complain_on_overflow */
 886          bfd_elf_generic_reloc, /* special_function */
 887          "R_ARM_REL32_NOI",     /* name */
 888          FALSE,                 /* partial_inplace */
 889          0xffffffff,            /* src_mask */
 890          0xffffffff,            /* dst_mask */
 891          FALSE),                /* pcrel_offset */
 892
 893   /* Group relocations.  */
 894
 895   HOWTO (R_ARM_ALU_PC_G0_NC,    /* type */
 896          0,                     /* rightshift */
 897          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 898          32,                    /* bitsize */
 899          TRUE,                  /* pc_relative */
 900          0,                     /* bitpos */
 901          complain_overflow_dont,/* complain_on_overflow */
 902          bfd_elf_generic_reloc, /* special_function */
 903          "R_ARM_ALU_PC_G0_NC",  /* name */
 904          FALSE,                 /* partial_inplace */
 905          0xffffffff,            /* src_mask */
 906          0xffffffff,            /* dst_mask */
 907          TRUE),                 /* pcrel_offset */
 908
 909   HOWTO (R_ARM_ALU_PC_G0,       /* type */
 910          0,                     /* rightshift */
 911          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 912          32,                    /* bitsize */
 913          TRUE,                  /* pc_relative */
 914          0,                     /* bitpos */
 915          complain_overflow_dont,/* complain_on_overflow */
 916          bfd_elf_generic_reloc, /* special_function */
 917          "R_ARM_ALU_PC_G0",     /* name */
 918          FALSE,                 /* partial_inplace */
 919          0xffffffff,            /* src_mask */
 920          0xffffffff,            /* dst_mask */
 921          TRUE),                 /* pcrel_offset */
 922
 923   HOWTO (R_ARM_ALU_PC_G1_NC,    /* type */
 924          0,                     /* rightshift */
 925          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 926          32,                    /* bitsize */
 927          TRUE,                  /* pc_relative */
 928          0,                     /* bitpos */
 929          complain_overflow_dont,/* complain_on_overflow */
 930          bfd_elf_generic_reloc, /* special_function */
 931          "R_ARM_ALU_PC_G1_NC",  /* name */
 932          FALSE,                 /* partial_inplace */
 933          0xffffffff,            /* src_mask */
 934          0xffffffff,            /* dst_mask */
 935          TRUE),                 /* pcrel_offset */
 936
 937   HOWTO (R_ARM_ALU_PC_G1,       /* type */
 938          0,                     /* rightshift */
 939          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 940          32,                    /* bitsize */
 941          TRUE,                  /* pc_relative */
 942          0,                     /* bitpos */
 943          complain_overflow_dont,/* complain_on_overflow */
 944          bfd_elf_generic_reloc, /* special_function */
 945          "R_ARM_ALU_PC_G1",     /* name */
 946          FALSE,                 /* partial_inplace */
 947          0xffffffff,            /* src_mask */
 948          0xffffffff,            /* dst_mask */
 949          TRUE),                 /* pcrel_offset */
 950
 951   HOWTO (R_ARM_ALU_PC_G2,       /* type */
 952          0,                     /* rightshift */
 953          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 954          32,                    /* bitsize */
 955          TRUE,                  /* pc_relative */
 956          0,                     /* bitpos */
 957          complain_overflow_dont,/* complain_on_overflow */
 958          bfd_elf_generic_reloc, /* special_function */
 959          "R_ARM_ALU_PC_G2",     /* name */
 960          FALSE,                 /* partial_inplace */
 961          0xffffffff,            /* src_mask */
 962          0xffffffff,            /* dst_mask */
 963          TRUE),                 /* pcrel_offset */
 964
 965   HOWTO (R_ARM_LDR_PC_G1,       /* type */
 966          0,                     /* rightshift */
 967          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 968          32,                    /* bitsize */
 969          TRUE,                  /* pc_relative */
 970          0,                     /* bitpos */
 971          complain_overflow_dont,/* complain_on_overflow */
 972          bfd_elf_generic_reloc, /* special_function */
 973          "R_ARM_LDR_PC_G1",     /* name */
 974          FALSE,                 /* partial_inplace */
 975          0xffffffff,            /* src_mask */
 976          0xffffffff,            /* dst_mask */
 977          TRUE),                 /* pcrel_offset */
 978
 979   HOWTO (R_ARM_LDR_PC_G2,       /* type */
 980          0,                     /* rightshift */
 981          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 982          32,                    /* bitsize */
 983          TRUE,                  /* pc_relative */
 984          0,                     /* bitpos */
 985          complain_overflow_dont,/* complain_on_overflow */
 986          bfd_elf_generic_reloc, /* special_function */
 987          "R_ARM_LDR_PC_G2",     /* name */
 988          FALSE,                 /* partial_inplace */
 989          0xffffffff,            /* src_mask */
 990          0xffffffff,            /* dst_mask */
 991          TRUE),                 /* pcrel_offset */
 992
 993   HOWTO (R_ARM_LDRS_PC_G0,      /* type */
 994          0,                     /* rightshift */
 995          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 996          32,                    /* bitsize */
 997          TRUE,                  /* pc_relative */
 998          0,                     /* bitpos */
 999          complain_overflow_dont,/* complain_on_overflow */
1000          bfd_elf_generic_reloc, /* special_function */
1001          "R_ARM_LDRS_PC_G0",    /* name */
1002          FALSE,                 /* partial_inplace */
1003          0xffffffff,            /* src_mask */
1004          0xffffffff,            /* dst_mask */
1005          TRUE),                 /* pcrel_offset */
1006
1007   HOWTO (R_ARM_LDRS_PC_G1,      /* type */
1008          0,                     /* rightshift */
1009          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1010          32,                    /* bitsize */
1011          TRUE,                  /* pc_relative */
1012          0,                     /* bitpos */
1013          complain_overflow_dont,/* complain_on_overflow */
1014          bfd_elf_generic_reloc, /* special_function */
1015          "R_ARM_LDRS_PC_G1",    /* name */
1016          FALSE,                 /* partial_inplace */
1017          0xffffffff,            /* src_mask */
1018          0xffffffff,            /* dst_mask */
1019          TRUE),                 /* pcrel_offset */
1020
1021   HOWTO (R_ARM_LDRS_PC_G2,      /* type */
1022          0,                     /* rightshift */
1023          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1024          32,                    /* bitsize */
1025          TRUE,                  /* pc_relative */
1026          0,                     /* bitpos */
1027          complain_overflow_dont,/* complain_on_overflow */
1028          bfd_elf_generic_reloc, /* special_function */
1029          "R_ARM_LDRS_PC_G2",    /* name */
1030          FALSE,                 /* partial_inplace */
1031          0xffffffff,            /* src_mask */
1032          0xffffffff,            /* dst_mask */
1033          TRUE),                 /* pcrel_offset */
1034
1035   HOWTO (R_ARM_LDC_PC_G0,       /* type */
1036          0,                     /* rightshift */
1037          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1038          32,                    /* bitsize */
1039          TRUE,                  /* pc_relative */
1040          0,                     /* bitpos */
1041          complain_overflow_dont,/* complain_on_overflow */
1042          bfd_elf_generic_reloc, /* special_function */
1043          "R_ARM_LDC_PC_G0",     /* name */
1044          FALSE,                 /* partial_inplace */
1045          0xffffffff,            /* src_mask */
1046          0xffffffff,            /* dst_mask */
1047          TRUE),                 /* pcrel_offset */
1048
1049   HOWTO (R_ARM_LDC_PC_G1,       /* type */
1050          0,                     /* rightshift */
1051          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1052          32,                    /* bitsize */
1053          TRUE,                  /* pc_relative */
1054          0,                     /* bitpos */
1055          complain_overflow_dont,/* complain_on_overflow */
1056          bfd_elf_generic_reloc, /* special_function */
1057          "R_ARM_LDC_PC_G1",     /* name */
1058          FALSE,                 /* partial_inplace */
1059          0xffffffff,            /* src_mask */
1060          0xffffffff,            /* dst_mask */
1061          TRUE),                 /* pcrel_offset */
1062
1063   HOWTO (R_ARM_LDC_PC_G2,       /* type */
1064          0,                     /* rightshift */
1065          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1066          32,                    /* bitsize */
1067          TRUE,                  /* pc_relative */
1068          0,                     /* bitpos */
1069          complain_overflow_dont,/* complain_on_overflow */
1070          bfd_elf_generic_reloc, /* special_function */
1071          "R_ARM_LDC_PC_G2",     /* name */
1072          FALSE,                 /* partial_inplace */
1073          0xffffffff,            /* src_mask */
1074          0xffffffff,            /* dst_mask */
1075          TRUE),                 /* pcrel_offset */
1076
1077   HOWTO (R_ARM_ALU_SB_G0_NC,    /* type */
1078          0,                     /* rightshift */
1079          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1080          32,                    /* bitsize */
1081          TRUE,                  /* pc_relative */
1082          0,                     /* bitpos */
1083          complain_overflow_dont,/* complain_on_overflow */
1084          bfd_elf_generic_reloc, /* special_function */
1085          "R_ARM_ALU_SB_G0_NC",  /* name */
1086          FALSE,                 /* partial_inplace */
1087          0xffffffff,            /* src_mask */
1088          0xffffffff,            /* dst_mask */
1089          TRUE),                 /* pcrel_offset */
1090
1091   HOWTO (R_ARM_ALU_SB_G0,       /* type */
1092          0,                     /* rightshift */
1093          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1094          32,                    /* bitsize */
1095          TRUE,                  /* pc_relative */
1096          0,                     /* bitpos */
1097          complain_overflow_dont,/* complain_on_overflow */
1098          bfd_elf_generic_reloc, /* special_function */
1099          "R_ARM_ALU_SB_G0",     /* name */
1100          FALSE,                 /* partial_inplace */
1101          0xffffffff,            /* src_mask */
1102          0xffffffff,            /* dst_mask */
1103          TRUE),                 /* pcrel_offset */
1104
1105   HOWTO (R_ARM_ALU_SB_G1_NC,    /* type */
1106          0,                     /* rightshift */
1107          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1108          32,                    /* bitsize */
1109          TRUE,                  /* pc_relative */
1110          0,                     /* bitpos */
1111          complain_overflow_dont,/* complain_on_overflow */
1112          bfd_elf_generic_reloc, /* special_function */
1113          "R_ARM_ALU_SB_G1_NC",  /* name */
1114          FALSE,                 /* partial_inplace */
1115          0xffffffff,            /* src_mask */
1116          0xffffffff,            /* dst_mask */
1117          TRUE),                 /* pcrel_offset */
1118
1119   HOWTO (R_ARM_ALU_SB_G1,       /* type */
1120          0,                     /* rightshift */
1121          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1122          32,                    /* bitsize */
1123          TRUE,                  /* pc_relative */
1124          0,                     /* bitpos */
1125          complain_overflow_dont,/* complain_on_overflow */
1126          bfd_elf_generic_reloc, /* special_function */
1127          "R_ARM_ALU_SB_G1",     /* name */
1128          FALSE,                 /* partial_inplace */
1129          0xffffffff,            /* src_mask */
1130          0xffffffff,            /* dst_mask */
1131          TRUE),                 /* pcrel_offset */
1132
1133   HOWTO (R_ARM_ALU_SB_G2,       /* type */
1134          0,                     /* rightshift */
1135          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1136          32,                    /* bitsize */
1137          TRUE,                  /* pc_relative */
1138          0,                     /* bitpos */
1139          complain_overflow_dont,/* complain_on_overflow */
1140          bfd_elf_generic_reloc, /* special_function */
1141          "R_ARM_ALU_SB_G2",     /* name */
1142          FALSE,                 /* partial_inplace */
1143          0xffffffff,            /* src_mask */
1144          0xffffffff,            /* dst_mask */
1145          TRUE),                 /* pcrel_offset */
1146
1147   HOWTO (R_ARM_LDR_SB_G0,       /* type */
1148          0,                     /* rightshift */
1149          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1150          32,                    /* bitsize */
1151          TRUE,                  /* pc_relative */
1152          0,                     /* bitpos */
1153          complain_overflow_dont,/* complain_on_overflow */
1154          bfd_elf_generic_reloc, /* special_function */
1155          "R_ARM_LDR_SB_G0",     /* name */
1156          FALSE,                 /* partial_inplace */
1157          0xffffffff,            /* src_mask */
1158          0xffffffff,            /* dst_mask */
1159          TRUE),                 /* pcrel_offset */
1160
1161   HOWTO (R_ARM_LDR_SB_G1,       /* type */
1162          0,                     /* rightshift */
1163          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1164          32,                    /* bitsize */
1165          TRUE,                  /* pc_relative */
1166          0,                     /* bitpos */
1167          complain_overflow_dont,/* complain_on_overflow */
1168          bfd_elf_generic_reloc, /* special_function */
1169          "R_ARM_LDR_SB_G1",     /* name */
1170          FALSE,                 /* partial_inplace */
1171          0xffffffff,            /* src_mask */
1172          0xffffffff,            /* dst_mask */
1173          TRUE),                 /* pcrel_offset */
1174
1175   HOWTO (R_ARM_LDR_SB_G2,       /* type */
1176          0,                     /* rightshift */
1177          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1178          32,                    /* bitsize */
1179          TRUE,                  /* pc_relative */
1180          0,                     /* bitpos */
1181          complain_overflow_dont,/* complain_on_overflow */
1182          bfd_elf_generic_reloc, /* special_function */
1183          "R_ARM_LDR_SB_G2",     /* name */
1184          FALSE,                 /* partial_inplace */
1185          0xffffffff,            /* src_mask */
1186          0xffffffff,            /* dst_mask */
1187          TRUE),                 /* pcrel_offset */
1188
1189   HOWTO (R_ARM_LDRS_SB_G0,      /* type */
1190          0,                     /* rightshift */
1191          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1192          32,                    /* bitsize */
1193          TRUE,                  /* pc_relative */
1194          0,                     /* bitpos */
1195          complain_overflow_dont,/* complain_on_overflow */
1196          bfd_elf_generic_reloc, /* special_function */
1197          "R_ARM_LDRS_SB_G0",    /* name */
1198          FALSE,                 /* partial_inplace */
1199          0xffffffff,            /* src_mask */
1200          0xffffffff,            /* dst_mask */
1201          TRUE),                 /* pcrel_offset */
1202
1203   HOWTO (R_ARM_LDRS_SB_G1,      /* type */
1204          0,                     /* rightshift */
1205          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1206          32,                    /* bitsize */
1207          TRUE,                  /* pc_relative */
1208          0,                     /* bitpos */
1209          complain_overflow_dont,/* complain_on_overflow */
1210          bfd_elf_generic_reloc, /* special_function */
1211          "R_ARM_LDRS_SB_G1",    /* name */
1212          FALSE,                 /* partial_inplace */
1213          0xffffffff,            /* src_mask */
1214          0xffffffff,            /* dst_mask */
1215          TRUE),                 /* pcrel_offset */
1216
1217   HOWTO (R_ARM_LDRS_SB_G2,      /* type */
1218          0,                     /* rightshift */
1219          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1220          32,                    /* bitsize */
1221          TRUE,                  /* pc_relative */
1222          0,                     /* bitpos */
1223          complain_overflow_dont,/* complain_on_overflow */
1224          bfd_elf_generic_reloc, /* special_function */
1225          "R_ARM_LDRS_SB_G2",    /* name */
1226          FALSE,                 /* partial_inplace */
1227          0xffffffff,            /* src_mask */
1228          0xffffffff,            /* dst_mask */
1229          TRUE),                 /* pcrel_offset */
1230
1231   HOWTO (R_ARM_LDC_SB_G0,       /* type */
1232          0,                     /* rightshift */
1233          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1234          32,                    /* bitsize */
1235          TRUE,                  /* pc_relative */
1236          0,                     /* bitpos */
1237          complain_overflow_dont,/* complain_on_overflow */
1238          bfd_elf_generic_reloc, /* special_function */
1239          "R_ARM_LDC_SB_G0",     /* name */
1240          FALSE,                 /* partial_inplace */
1241          0xffffffff,            /* src_mask */
1242          0xffffffff,            /* dst_mask */
1243          TRUE),                 /* pcrel_offset */
1244
1245   HOWTO (R_ARM_LDC_SB_G1,       /* type */
1246          0,                     /* rightshift */
1247          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1248          32,                    /* bitsize */
1249          TRUE,                  /* pc_relative */
1250          0,                     /* bitpos */
1251          complain_overflow_dont,/* complain_on_overflow */
1252          bfd_elf_generic_reloc, /* special_function */
1253          "R_ARM_LDC_SB_G1",     /* name */
1254          FALSE,                 /* partial_inplace */
1255          0xffffffff,            /* src_mask */
1256          0xffffffff,            /* dst_mask */
1257          TRUE),                 /* pcrel_offset */
1258
1259   HOWTO (R_ARM_LDC_SB_G2,       /* type */
1260          0,                     /* rightshift */
1261          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1262          32,                    /* bitsize */
1263          TRUE,                  /* pc_relative */
1264          0,                     /* bitpos */
1265          complain_overflow_dont,/* complain_on_overflow */
1266          bfd_elf_generic_reloc, /* special_function */
1267          "R_ARM_LDC_SB_G2",     /* name */
1268          FALSE,                 /* partial_inplace */
1269          0xffffffff,            /* src_mask */
1270          0xffffffff,            /* dst_mask */
1271          TRUE),                 /* pcrel_offset */
1272
1273   /* End of group relocations.  */
1274
1275   HOWTO (R_ARM_MOVW_BREL_NC,    /* type */
1276          0,                     /* rightshift */
1277          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1278          16,                    /* bitsize */
1279          FALSE,                 /* pc_relative */
1280          0,                     /* bitpos */
1281          complain_overflow_dont,/* complain_on_overflow */
1282          bfd_elf_generic_reloc, /* special_function */
1283          "R_ARM_MOVW_BREL_NC",  /* name */
1284          FALSE,                 /* partial_inplace */
1285          0x0000ffff,            /* src_mask */
1286          0x0000ffff,            /* dst_mask */
1287          FALSE),                /* pcrel_offset */
1288
1289   HOWTO (R_ARM_MOVT_BREL,       /* type */
1290          0,                     /* rightshift */
1291          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1292          16,                    /* bitsize */
1293          FALSE,                 /* pc_relative */
1294          0,                     /* bitpos */
1295          complain_overflow_bitfield,/* complain_on_overflow */
1296          bfd_elf_generic_reloc, /* special_function */
1297          "R_ARM_MOVT_BREL",     /* name */
1298          FALSE,                 /* partial_inplace */
1299          0x0000ffff,            /* src_mask */
1300          0x0000ffff,            /* dst_mask */
1301          FALSE),                /* pcrel_offset */
1302
1303   HOWTO (R_ARM_MOVW_BREL,       /* type */
1304          0,                     /* rightshift */
1305          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1306          16,                    /* bitsize */
1307          FALSE,                 /* pc_relative */
1308          0,                     /* bitpos */
1309          complain_overflow_dont,/* complain_on_overflow */
1310          bfd_elf_generic_reloc, /* special_function */
1311          "R_ARM_MOVW_BREL",     /* name */
1312          FALSE,                 /* partial_inplace */
1313          0x0000ffff,            /* src_mask */
1314          0x0000ffff,            /* dst_mask */
1315          FALSE),                /* pcrel_offset */
1316
1317   HOWTO (R_ARM_THM_MOVW_BREL_NC,/* type */
1318          0,                     /* rightshift */
1319          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1320          16,                    /* bitsize */
1321          FALSE,                 /* pc_relative */
1322          0,                     /* bitpos */
1323          complain_overflow_dont,/* complain_on_overflow */
1324          bfd_elf_generic_reloc, /* special_function */
1325          "R_ARM_THM_MOVW_BREL_NC",/* name */
1326          FALSE,                 /* partial_inplace */
1327          0x040f70ff,            /* src_mask */
1328          0x040f70ff,            /* dst_mask */
1329          FALSE),                /* pcrel_offset */
1330
1331   HOWTO (R_ARM_THM_MOVT_BREL,   /* type */
1332          0,                     /* rightshift */
1333          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1334          16,                    /* bitsize */
1335          FALSE,                 /* pc_relative */
1336          0,                     /* bitpos */
1337          complain_overflow_bitfield,/* complain_on_overflow */
1338          bfd_elf_generic_reloc, /* special_function */
1339          "R_ARM_THM_MOVT_BREL", /* name */
1340          FALSE,                 /* partial_inplace */
1341          0x040f70ff,            /* src_mask */
1342          0x040f70ff,            /* dst_mask */
1343          FALSE),                /* pcrel_offset */
1344
1345   HOWTO (R_ARM_THM_MOVW_BREL,   /* type */
1346          0,                     /* rightshift */
1347          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1348          16,                    /* bitsize */
1349          FALSE,                 /* pc_relative */
1350          0,                     /* bitpos */
1351          complain_overflow_dont,/* complain_on_overflow */
1352          bfd_elf_generic_reloc, /* special_function */
1353          "R_ARM_THM_MOVW_BREL", /* name */
1354          FALSE,                 /* partial_inplace */
1355          0x040f70ff,            /* src_mask */
1356          0x040f70ff,            /* dst_mask */
1357          FALSE),                /* pcrel_offset */
1358
1359   HOWTO (R_ARM_TLS_GOTDESC,     /* type */
1360          0,                     /* rightshift */
1361          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1362          32,                    /* bitsize */
1363          FALSE,                 /* pc_relative */
1364          0,                     /* bitpos */
1365          complain_overflow_bitfield,/* complain_on_overflow */
1366          NULL,                  /* special_function */
1367          "R_ARM_TLS_GOTDESC",   /* name */
1368          TRUE,                  /* partial_inplace */
1369          0xffffffff,            /* src_mask */
1370          0xffffffff,            /* dst_mask */
1371          FALSE),                /* pcrel_offset */
1372
1373   HOWTO (R_ARM_TLS_CALL,        /* type */
1374          0,                     /* rightshift */
1375          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1376          24,                    /* bitsize */
1377          FALSE,                 /* pc_relative */
1378          0,                     /* bitpos */
1379          complain_overflow_dont,/* complain_on_overflow */
1380          bfd_elf_generic_reloc, /* special_function */
1381          "R_ARM_TLS_CALL",      /* name */
1382          FALSE,                 /* partial_inplace */
1383          0x00ffffff,            /* src_mask */
1384          0x00ffffff,            /* dst_mask */
1385          FALSE),                /* pcrel_offset */
1386
1387   HOWTO (R_ARM_TLS_DESCSEQ,     /* type */
1388          0,                     /* rightshift */
1389          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1390          0,                     /* bitsize */
1391          FALSE,                 /* pc_relative */
1392          0,                     /* bitpos */
1393          complain_overflow_bitfield,/* complain_on_overflow */
1394          bfd_elf_generic_reloc, /* special_function */
1395          "R_ARM_TLS_DESCSEQ",   /* name */
1396          FALSE,                 /* partial_inplace */
1397          0x00000000,            /* src_mask */
1398          0x00000000,            /* dst_mask */
1399          FALSE),                /* pcrel_offset */
1400
1401   HOWTO (R_ARM_THM_TLS_CALL,    /* type */
1402          0,                     /* rightshift */
1403          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1404          24,                    /* bitsize */
1405          FALSE,                 /* pc_relative */
1406          0,                     /* bitpos */
1407          complain_overflow_dont,/* complain_on_overflow */
1408          bfd_elf_generic_reloc, /* special_function */
1409          "R_ARM_THM_TLS_CALL",  /* name */
1410          FALSE,                 /* partial_inplace */
1411          0x07ff07ff,            /* src_mask */
1412          0x07ff07ff,            /* dst_mask */
1413          FALSE),                /* pcrel_offset */
1414
1415   HOWTO (R_ARM_PLT32_ABS,       /* type */
1416          0,                     /* rightshift */
1417          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1418          32,                    /* bitsize */
1419          FALSE,                 /* pc_relative */
1420          0,                     /* bitpos */
1421          complain_overflow_dont,/* complain_on_overflow */
1422          bfd_elf_generic_reloc, /* special_function */
1423          "R_ARM_PLT32_ABS",     /* name */
1424          FALSE,                 /* partial_inplace */
1425          0xffffffff,            /* src_mask */
1426          0xffffffff,            /* dst_mask */
1427          FALSE),                /* pcrel_offset */
1428
1429   HOWTO (R_ARM_GOT_ABS,         /* type */
1430          0,                     /* rightshift */
1431          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1432          32,                    /* bitsize */
1433          FALSE,                 /* pc_relative */
1434          0,                     /* bitpos */
1435          complain_overflow_dont,/* complain_on_overflow */
1436          bfd_elf_generic_reloc, /* special_function */
1437          "R_ARM_GOT_ABS",       /* name */
1438          FALSE,                 /* partial_inplace */
1439          0xffffffff,            /* src_mask */
1440          0xffffffff,            /* dst_mask */
1441          FALSE),                        /* pcrel_offset */
1442
1443   HOWTO (R_ARM_GOT_PREL,        /* type */
1444          0,                     /* rightshift */
1445          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1446          32,                    /* bitsize */
1447          TRUE,                  /* pc_relative */
1448          0,                     /* bitpos */
1449          complain_overflow_dont,        /* complain_on_overflow */
1450          bfd_elf_generic_reloc, /* special_function */
1451          "R_ARM_GOT_PREL",      /* name */
1452          FALSE,                 /* partial_inplace */
1453          0xffffffff,            /* src_mask */
1454          0xffffffff,            /* dst_mask */
1455          TRUE),                 /* pcrel_offset */
1456
1457   HOWTO (R_ARM_GOT_BREL12,      /* type */
1458          0,                     /* rightshift */
1459          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1460          12,                    /* bitsize */
1461          FALSE,                 /* pc_relative */
1462          0,                     /* bitpos */
1463          complain_overflow_bitfield,/* complain_on_overflow */
1464          bfd_elf_generic_reloc, /* special_function */
1465          "R_ARM_GOT_BREL12",    /* name */
1466          FALSE,                 /* partial_inplace */
1467          0x00000fff,            /* src_mask */
1468          0x00000fff,            /* dst_mask */
1469          FALSE),                /* pcrel_offset */
1470
1471   HOWTO (R_ARM_GOTOFF12,        /* type */
1472          0,                     /* rightshift */
1473          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1474          12,                    /* bitsize */
1475          FALSE,                 /* pc_relative */
1476          0,                     /* bitpos */
1477          complain_overflow_bitfield,/* complain_on_overflow */
1478          bfd_elf_generic_reloc, /* special_function */
1479          "R_ARM_GOTOFF12",      /* name */
1480          FALSE,                 /* partial_inplace */
1481          0x00000fff,            /* src_mask */
1482          0x00000fff,            /* dst_mask */
1483          FALSE),                /* pcrel_offset */
1484
1485   EMPTY_HOWTO (R_ARM_GOTRELAX),  /* reserved for future GOT-load optimizations */
1486
1487   /* GNU extension to record C++ vtable member usage */
1488   HOWTO (R_ARM_GNU_VTENTRY,     /* type */
1489          0,                     /* rightshift */
1490          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1491          0,                     /* bitsize */
1492          FALSE,                 /* pc_relative */
1493          0,                     /* bitpos */
1494          complain_overflow_dont, /* complain_on_overflow */
1495          _bfd_elf_rel_vtable_reloc_fn,  /* special_function */
1496          "R_ARM_GNU_VTENTRY",   /* name */
1497          FALSE,                 /* partial_inplace */
1498          0,                     /* src_mask */
1499          0,                     /* dst_mask */
1500          FALSE),                /* pcrel_offset */
1501
1502   /* GNU extension to record C++ vtable hierarchy */
1503   HOWTO (R_ARM_GNU_VTINHERIT, /* type */
1504          0,                     /* rightshift */
1505          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1506          0,                     /* bitsize */
1507          FALSE,                 /* pc_relative */
1508          0,                     /* bitpos */
1509          complain_overflow_dont, /* complain_on_overflow */
1510          NULL,                  /* special_function */
1511          "R_ARM_GNU_VTINHERIT", /* name */
1512          FALSE,                 /* partial_inplace */
1513          0,                     /* src_mask */
1514          0,                     /* dst_mask */
1515          FALSE),                /* pcrel_offset */
1516
1517   HOWTO (R_ARM_THM_JUMP11,      /* type */
1518          1,                     /* rightshift */
1519          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1520          11,                    /* bitsize */
1521          TRUE,                  /* pc_relative */
1522          0,                     /* bitpos */
1523          complain_overflow_signed,      /* complain_on_overflow */
1524          bfd_elf_generic_reloc, /* special_function */
1525          "R_ARM_THM_JUMP11",    /* name */
1526          FALSE,                 /* partial_inplace */
1527          0x000007ff,            /* src_mask */
1528          0x000007ff,            /* dst_mask */
1529          TRUE),                 /* pcrel_offset */
1530
1531   HOWTO (R_ARM_THM_JUMP8,       /* type */
1532          1,                     /* rightshift */
1533          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1534          8,                     /* bitsize */
1535          TRUE,                  /* pc_relative */
1536          0,                     /* bitpos */
1537          complain_overflow_signed,      /* complain_on_overflow */
1538          bfd_elf_generic_reloc, /* special_function */
1539          "R_ARM_THM_JUMP8",     /* name */
1540          FALSE,                 /* partial_inplace */
1541          0x000000ff,            /* src_mask */
1542          0x000000ff,            /* dst_mask */
1543          TRUE),                 /* pcrel_offset */
1544
1545   /* TLS relocations */
1546   HOWTO (R_ARM_TLS_GD32,        /* type */
1547          0,                     /* rightshift */
1548          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1549          32,                    /* bitsize */
1550          FALSE,                 /* pc_relative */
1551          0,                     /* bitpos */
1552          complain_overflow_bitfield,/* complain_on_overflow */
1553          NULL,                  /* special_function */
1554          "R_ARM_TLS_GD32",      /* name */
1555          TRUE,                  /* partial_inplace */
1556          0xffffffff,            /* src_mask */
1557          0xffffffff,            /* dst_mask */
1558          FALSE),                /* pcrel_offset */
1559
1560   HOWTO (R_ARM_TLS_LDM32,       /* type */
1561          0,                     /* rightshift */
1562          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1563          32,                    /* bitsize */
1564          FALSE,                 /* pc_relative */
1565          0,                     /* bitpos */
1566          complain_overflow_bitfield,/* complain_on_overflow */
1567          bfd_elf_generic_reloc, /* special_function */
1568          "R_ARM_TLS_LDM32",     /* name */
1569          TRUE,                  /* partial_inplace */
1570          0xffffffff,            /* src_mask */
1571          0xffffffff,            /* dst_mask */
1572          FALSE),                /* pcrel_offset */
1573
1574   HOWTO (R_ARM_TLS_LDO32,       /* type */
1575          0,                     /* rightshift */
1576          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1577          32,                    /* bitsize */
1578          FALSE,                 /* pc_relative */
1579          0,                     /* bitpos */
1580          complain_overflow_bitfield,/* complain_on_overflow */
1581          bfd_elf_generic_reloc, /* special_function */
1582          "R_ARM_TLS_LDO32",     /* name */
1583          TRUE,                  /* partial_inplace */
1584          0xffffffff,            /* src_mask */
1585          0xffffffff,            /* dst_mask */
1586          FALSE),                /* pcrel_offset */
1587
1588   HOWTO (R_ARM_TLS_IE32,        /* type */
1589          0,                     /* rightshift */
1590          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1591          32,                    /* bitsize */
1592          FALSE,                  /* pc_relative */
1593          0,                     /* bitpos */
1594          complain_overflow_bitfield,/* complain_on_overflow */
1595          NULL,                  /* special_function */
1596          "R_ARM_TLS_IE32",      /* name */
1597          TRUE,                  /* partial_inplace */
1598          0xffffffff,            /* src_mask */
1599          0xffffffff,            /* dst_mask */
1600          FALSE),                /* pcrel_offset */
1601
1602   HOWTO (R_ARM_TLS_LE32,        /* type */
1603          0,                     /* rightshift */
1604          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1605          32,                    /* bitsize */
1606          FALSE,                 /* pc_relative */
1607          0,                     /* bitpos */
1608          complain_overflow_bitfield,/* complain_on_overflow */
1609          NULL,                  /* special_function */
1610          "R_ARM_TLS_LE32",      /* name */
1611          TRUE,                  /* partial_inplace */
1612          0xffffffff,            /* src_mask */
1613          0xffffffff,            /* dst_mask */
1614          FALSE),                /* pcrel_offset */
1615
1616   HOWTO (R_ARM_TLS_LDO12,       /* type */
1617          0,                     /* rightshift */
1618          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1619          12,                    /* bitsize */
1620          FALSE,                 /* pc_relative */
1621          0,                     /* bitpos */
1622          complain_overflow_bitfield,/* complain_on_overflow */
1623          bfd_elf_generic_reloc, /* special_function */
1624          "R_ARM_TLS_LDO12",     /* name */
1625          FALSE,                 /* partial_inplace */
1626          0x00000fff,            /* src_mask */
1627          0x00000fff,            /* dst_mask */
1628          FALSE),                /* pcrel_offset */
1629
1630   HOWTO (R_ARM_TLS_LE12,        /* type */
1631          0,                     /* rightshift */
1632          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1633          12,                    /* bitsize */
1634          FALSE,                 /* pc_relative */
1635          0,                     /* bitpos */
1636          complain_overflow_bitfield,/* complain_on_overflow */
1637          bfd_elf_generic_reloc, /* special_function */
1638          "R_ARM_TLS_LE12",      /* name */
1639          FALSE,                 /* partial_inplace */
1640          0x00000fff,            /* src_mask */
1641          0x00000fff,            /* dst_mask */
1642          FALSE),                /* pcrel_offset */
1643
1644   HOWTO (R_ARM_TLS_IE12GP,      /* type */
1645          0,                     /* rightshift */
1646          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1647          12,                    /* bitsize */
1648          FALSE,                 /* pc_relative */
1649          0,                     /* bitpos */
1650          complain_overflow_bitfield,/* complain_on_overflow */
1651          bfd_elf_generic_reloc, /* special_function */
1652          "R_ARM_TLS_IE12GP",    /* name */
1653          FALSE,                 /* partial_inplace */
1654          0x00000fff,            /* src_mask */
1655          0x00000fff,            /* dst_mask */
1656          FALSE),                /* pcrel_offset */
1657
1658   /* 112-127 private relocations.  */
1659   EMPTY_HOWTO (112),
1660   EMPTY_HOWTO (113),
1661   EMPTY_HOWTO (114),
1662   EMPTY_HOWTO (115),
1663   EMPTY_HOWTO (116),
1664   EMPTY_HOWTO (117),
1665   EMPTY_HOWTO (118),
1666   EMPTY_HOWTO (119),
1667   EMPTY_HOWTO (120),
1668   EMPTY_HOWTO (121),
1669   EMPTY_HOWTO (122),
1670   EMPTY_HOWTO (123),
1671   EMPTY_HOWTO (124),
1672   EMPTY_HOWTO (125),
1673   EMPTY_HOWTO (126),
1674   EMPTY_HOWTO (127),
1675
1676   /* R_ARM_ME_TOO, obsolete.  */
1677   EMPTY_HOWTO (128),
1678
1679   HOWTO (R_ARM_THM_TLS_DESCSEQ, /* type */
1680          0,                     /* rightshift */
1681          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1682          0,                     /* bitsize */
1683          FALSE,                 /* pc_relative */
1684          0,                     /* bitpos */
1685          complain_overflow_bitfield,/* complain_on_overflow */
1686          bfd_elf_generic_reloc, /* special_function */
1687          "R_ARM_THM_TLS_DESCSEQ",/* name */
1688          FALSE,                 /* partial_inplace */
1689          0x00000000,            /* src_mask */
1690          0x00000000,            /* dst_mask */
1691          FALSE),                /* pcrel_offset */
1692   EMPTY_HOWTO (130),
1693   EMPTY_HOWTO (131),
1694   HOWTO (R_ARM_THM_ALU_ABS_G0_NC,/* type.  */
1695          0,                     /* rightshift.  */
1696          1,                     /* size (0 = byte, 1 = short, 2 = long).  */
1697          16,                    /* bitsize.  */
1698          FALSE,                 /* pc_relative.  */
1699          0,                     /* bitpos.  */
1700          complain_overflow_bitfield,/* complain_on_overflow.  */
1701          bfd_elf_generic_reloc, /* special_function.  */
1702          "R_ARM_THM_ALU_ABS_G0_NC",/* name.  */
1703          FALSE,                 /* partial_inplace.  */
1704          0x00000000,            /* src_mask.  */
1705          0x00000000,            /* dst_mask.  */
1706          FALSE),                /* pcrel_offset.  */
1707   HOWTO (R_ARM_THM_ALU_ABS_G1_NC,/* type.  */
1708          0,                     /* rightshift.  */
1709          1,                     /* size (0 = byte, 1 = short, 2 = long).  */
1710          16,                    /* bitsize.  */
1711          FALSE,                 /* pc_relative.  */
1712          0,                     /* bitpos.  */
1713          complain_overflow_bitfield,/* complain_on_overflow.  */
1714          bfd_elf_generic_reloc, /* special_function.  */
1715          "R_ARM_THM_ALU_ABS_G1_NC",/* name.  */
1716          FALSE,                 /* partial_inplace.  */
1717          0x00000000,            /* src_mask.  */
1718          0x00000000,            /* dst_mask.  */
1719          FALSE),                /* pcrel_offset.  */
1720   HOWTO (R_ARM_THM_ALU_ABS_G2_NC,/* type.  */
1721          0,                     /* rightshift.  */
1722          1,                     /* size (0 = byte, 1 = short, 2 = long).  */
1723          16,                    /* bitsize.  */
1724          FALSE,                 /* pc_relative.  */
1725          0,                     /* bitpos.  */
1726          complain_overflow_bitfield,/* complain_on_overflow.  */
1727          bfd_elf_generic_reloc, /* special_function.  */
1728          "R_ARM_THM_ALU_ABS_G2_NC",/* name.  */
1729          FALSE,                 /* partial_inplace.  */
1730          0x00000000,            /* src_mask.  */
1731          0x00000000,            /* dst_mask.  */
1732          FALSE),                /* pcrel_offset.  */
1733   HOWTO (R_ARM_THM_ALU_ABS_G3_NC,/* type.  */
1734          0,                     /* rightshift.  */
1735          1,                     /* size (0 = byte, 1 = short, 2 = long).  */
1736          16,                    /* bitsize.  */
1737          FALSE,                 /* pc_relative.  */
1738          0,                     /* bitpos.  */
1739          complain_overflow_bitfield,/* complain_on_overflow.  */
1740          bfd_elf_generic_reloc, /* special_function.  */
1741          "R_ARM_THM_ALU_ABS_G3_NC",/* name.  */
1742          FALSE,                 /* partial_inplace.  */
1743          0x00000000,            /* src_mask.  */
1744          0x00000000,            /* dst_mask.  */
1745          FALSE),                /* pcrel_offset.  */
1746 };
1747
1748 /* 160 onwards: */
1749 static reloc_howto_type elf32_arm_howto_table_2[1] =
1750 {
1751   HOWTO (R_ARM_IRELATIVE,       /* type */
1752          0,                     /* rightshift */
1753          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1754          32,                    /* bitsize */
1755          FALSE,                 /* pc_relative */
1756          0,                     /* bitpos */
1757          complain_overflow_bitfield,/* complain_on_overflow */
1758          bfd_elf_generic_reloc, /* special_function */
1759          "R_ARM_IRELATIVE",     /* name */
1760          TRUE,                  /* partial_inplace */
1761          0xffffffff,            /* src_mask */
1762          0xffffffff,            /* dst_mask */
1763          FALSE)                 /* pcrel_offset */
1764 };
1765
1766 /* 249-255 extended, currently unused, relocations:  */
1767 static reloc_howto_type elf32_arm_howto_table_3[4] =
1768 {
1769   HOWTO (R_ARM_RREL32,          /* type */
1770          0,                     /* rightshift */
1771          0,                     /* size (0 = byte, 1 = short, 2 = long) */
1772          0,                     /* bitsize */
1773          FALSE,                 /* pc_relative */
1774          0,                     /* bitpos */
1775          complain_overflow_dont,/* complain_on_overflow */
1776          bfd_elf_generic_reloc, /* special_function */
1777          "R_ARM_RREL32",        /* name */
1778          FALSE,                 /* partial_inplace */
1779          0,                     /* src_mask */
1780          0,                     /* dst_mask */
1781          FALSE),                /* pcrel_offset */
1782
1783   HOWTO (R_ARM_RABS32,          /* type */
1784          0,                     /* rightshift */
1785          0,                     /* size (0 = byte, 1 = short, 2 = long) */
1786          0,                     /* bitsize */
1787          FALSE,                 /* pc_relative */
1788          0,                     /* bitpos */
1789          complain_overflow_dont,/* complain_on_overflow */
1790          bfd_elf_generic_reloc, /* special_function */
1791          "R_ARM_RABS32",        /* name */
1792          FALSE,                 /* partial_inplace */
1793          0,                     /* src_mask */
1794          0,                     /* dst_mask */
1795          FALSE),                /* pcrel_offset */
1796
1797   HOWTO (R_ARM_RPC24,           /* type */
1798          0,                     /* rightshift */
1799          0,                     /* size (0 = byte, 1 = short, 2 = long) */
1800          0,                     /* bitsize */
1801          FALSE,                 /* pc_relative */
1802          0,                     /* bitpos */
1803          complain_overflow_dont,/* complain_on_overflow */
1804          bfd_elf_generic_reloc, /* special_function */
1805          "R_ARM_RPC24",         /* name */
1806          FALSE,                 /* partial_inplace */
1807          0,                     /* src_mask */
1808          0,                     /* dst_mask */
1809          FALSE),                /* pcrel_offset */
1810
1811   HOWTO (R_ARM_RBASE,           /* type */
1812          0,                     /* rightshift */
1813          0,                     /* size (0 = byte, 1 = short, 2 = long) */
1814          0,                     /* bitsize */
1815          FALSE,                 /* pc_relative */
1816          0,                     /* bitpos */
1817          complain_overflow_dont,/* complain_on_overflow */
1818          bfd_elf_generic_reloc, /* special_function */
1819          "R_ARM_RBASE",         /* name */
1820          FALSE,                 /* partial_inplace */
1821          0,                     /* src_mask */
1822          0,                     /* dst_mask */
1823          FALSE)                 /* pcrel_offset */
1824 };
1825
1826 static reloc_howto_type *
1827 elf32_arm_howto_from_type (unsigned int r_type)
1828 {
1829   if (r_type < ARRAY_SIZE (elf32_arm_howto_table_1))
1830     return &elf32_arm_howto_table_1[r_type];
1831
1832   if (r_type == R_ARM_IRELATIVE)
1833     return &elf32_arm_howto_table_2[r_type - R_ARM_IRELATIVE];
1834
1835   if (r_type >= R_ARM_RREL32
1836       && r_type < R_ARM_RREL32 + ARRAY_SIZE (elf32_arm_howto_table_3))
1837     return &elf32_arm_howto_table_3[r_type - R_ARM_RREL32];
1838
1839   return NULL;
1840 }
1841
1842 static void
1843 elf32_arm_info_to_howto (bfd * abfd ATTRIBUTE_UNUSED, arelent * bfd_reloc,
1844                          Elf_Internal_Rela * elf_reloc)
1845 {
1846   unsigned int r_type;
1847
1848   r_type = ELF32_R_TYPE (elf_reloc->r_info);
1849   bfd_reloc->howto = elf32_arm_howto_from_type (r_type);
1850 }
1851
1852 struct elf32_arm_reloc_map
1853   {
1854     bfd_reloc_code_real_type  bfd_reloc_val;
1855     unsigned char             elf_reloc_val;
1856   };
1857
1858 /* All entries in this list must also be present in elf32_arm_howto_table.  */
1859 static const struct elf32_arm_reloc_map elf32_arm_reloc_map[] =
1860   {
1861     {BFD_RELOC_NONE,                 R_ARM_NONE},
1862     {BFD_RELOC_ARM_PCREL_BRANCH,     R_ARM_PC24},
1863     {BFD_RELOC_ARM_PCREL_CALL,       R_ARM_CALL},
1864     {BFD_RELOC_ARM_PCREL_JUMP,       R_ARM_JUMP24},
1865     {BFD_RELOC_ARM_PCREL_BLX,        R_ARM_XPC25},
1866     {BFD_RELOC_THUMB_PCREL_BLX,      R_ARM_THM_XPC22},
1867     {BFD_RELOC_32,                   R_ARM_ABS32},
1868     {BFD_RELOC_32_PCREL,             R_ARM_REL32},
1869     {BFD_RELOC_8,                    R_ARM_ABS8},
1870     {BFD_RELOC_16,                   R_ARM_ABS16},
1871     {BFD_RELOC_ARM_OFFSET_IMM,       R_ARM_ABS12},
1872     {BFD_RELOC_ARM_THUMB_OFFSET,     R_ARM_THM_ABS5},
1873     {BFD_RELOC_THUMB_PCREL_BRANCH25, R_ARM_THM_JUMP24},
1874     {BFD_RELOC_THUMB_PCREL_BRANCH23, R_ARM_THM_CALL},
1875     {BFD_RELOC_THUMB_PCREL_BRANCH12, R_ARM_THM_JUMP11},
1876     {BFD_RELOC_THUMB_PCREL_BRANCH20, R_ARM_THM_JUMP19},
1877     {BFD_RELOC_THUMB_PCREL_BRANCH9,  R_ARM_THM_JUMP8},
1878     {BFD_RELOC_THUMB_PCREL_BRANCH7,  R_ARM_THM_JUMP6},
1879     {BFD_RELOC_ARM_GLOB_DAT,         R_ARM_GLOB_DAT},
1880     {BFD_RELOC_ARM_JUMP_SLOT,        R_ARM_JUMP_SLOT},
1881     {BFD_RELOC_ARM_RELATIVE,         R_ARM_RELATIVE},
1882     {BFD_RELOC_ARM_GOTOFF,           R_ARM_GOTOFF32},
1883     {BFD_RELOC_ARM_GOTPC,            R_ARM_GOTPC},
1884     {BFD_RELOC_ARM_GOT_PREL,         R_ARM_GOT_PREL},
1885     {BFD_RELOC_ARM_GOT32,            R_ARM_GOT32},
1886     {BFD_RELOC_ARM_PLT32,            R_ARM_PLT32},
1887     {BFD_RELOC_ARM_TARGET1,          R_ARM_TARGET1},
1888     {BFD_RELOC_ARM_ROSEGREL32,       R_ARM_ROSEGREL32},
1889     {BFD_RELOC_ARM_SBREL32,          R_ARM_SBREL32},
1890     {BFD_RELOC_ARM_PREL31,           R_ARM_PREL31},
1891     {BFD_RELOC_ARM_TARGET2,          R_ARM_TARGET2},
1892     {BFD_RELOC_ARM_PLT32,            R_ARM_PLT32},
1893     {BFD_RELOC_ARM_TLS_GOTDESC,      R_ARM_TLS_GOTDESC},
1894     {BFD_RELOC_ARM_TLS_CALL,         R_ARM_TLS_CALL},
1895     {BFD_RELOC_ARM_THM_TLS_CALL,     R_ARM_THM_TLS_CALL},
1896     {BFD_RELOC_ARM_TLS_DESCSEQ,      R_ARM_TLS_DESCSEQ},
1897     {BFD_RELOC_ARM_THM_TLS_DESCSEQ,  R_ARM_THM_TLS_DESCSEQ},
1898     {BFD_RELOC_ARM_TLS_DESC,         R_ARM_TLS_DESC},
1899     {BFD_RELOC_ARM_TLS_GD32,         R_ARM_TLS_GD32},
1900     {BFD_RELOC_ARM_TLS_LDO32,        R_ARM_TLS_LDO32},
1901     {BFD_RELOC_ARM_TLS_LDM32,        R_ARM_TLS_LDM32},
1902     {BFD_RELOC_ARM_TLS_DTPMOD32,     R_ARM_TLS_DTPMOD32},
1903     {BFD_RELOC_ARM_TLS_DTPOFF32,     R_ARM_TLS_DTPOFF32},
1904     {BFD_RELOC_ARM_TLS_TPOFF32,      R_ARM_TLS_TPOFF32},
1905     {BFD_RELOC_ARM_TLS_IE32,         R_ARM_TLS_IE32},
1906     {BFD_RELOC_ARM_TLS_LE32,         R_ARM_TLS_LE32},
1907     {BFD_RELOC_ARM_IRELATIVE,        R_ARM_IRELATIVE},
1908     {BFD_RELOC_VTABLE_INHERIT,       R_ARM_GNU_VTINHERIT},
1909     {BFD_RELOC_VTABLE_ENTRY,         R_ARM_GNU_VTENTRY},
1910     {BFD_RELOC_ARM_MOVW,             R_ARM_MOVW_ABS_NC},
1911     {BFD_RELOC_ARM_MOVT,             R_ARM_MOVT_ABS},
1912     {BFD_RELOC_ARM_MOVW_PCREL,       R_ARM_MOVW_PREL_NC},
1913     {BFD_RELOC_ARM_MOVT_PCREL,       R_ARM_MOVT_PREL},
1914     {BFD_RELOC_ARM_THUMB_MOVW,       R_ARM_THM_MOVW_ABS_NC},
1915     {BFD_RELOC_ARM_THUMB_MOVT,       R_ARM_THM_MOVT_ABS},
1916     {BFD_RELOC_ARM_THUMB_MOVW_PCREL, R_ARM_THM_MOVW_PREL_NC},
1917     {BFD_RELOC_ARM_THUMB_MOVT_PCREL, R_ARM_THM_MOVT_PREL},
1918     {BFD_RELOC_ARM_ALU_PC_G0_NC, R_ARM_ALU_PC_G0_NC},
1919     {BFD_RELOC_ARM_ALU_PC_G0, R_ARM_ALU_PC_G0},
1920     {BFD_RELOC_ARM_ALU_PC_G1_NC, R_ARM_ALU_PC_G1_NC},
1921     {BFD_RELOC_ARM_ALU_PC_G1, R_ARM_ALU_PC_G1},
1922     {BFD_RELOC_ARM_ALU_PC_G2, R_ARM_ALU_PC_G2},
1923     {BFD_RELOC_ARM_LDR_PC_G0, R_ARM_LDR_PC_G0},
1924     {BFD_RELOC_ARM_LDR_PC_G1, R_ARM_LDR_PC_G1},
1925     {BFD_RELOC_ARM_LDR_PC_G2, R_ARM_LDR_PC_G2},
1926     {BFD_RELOC_ARM_LDRS_PC_G0, R_ARM_LDRS_PC_G0},
1927     {BFD_RELOC_ARM_LDRS_PC_G1, R_ARM_LDRS_PC_G1},
1928     {BFD_RELOC_ARM_LDRS_PC_G2, R_ARM_LDRS_PC_G2},
1929     {BFD_RELOC_ARM_LDC_PC_G0, R_ARM_LDC_PC_G0},
1930     {BFD_RELOC_ARM_LDC_PC_G1, R_ARM_LDC_PC_G1},
1931     {BFD_RELOC_ARM_LDC_PC_G2, R_ARM_LDC_PC_G2},
1932     {BFD_RELOC_ARM_ALU_SB_G0_NC, R_ARM_ALU_SB_G0_NC},
1933     {BFD_RELOC_ARM_ALU_SB_G0, R_ARM_ALU_SB_G0},
1934     {BFD_RELOC_ARM_ALU_SB_G1_NC, R_ARM_ALU_SB_G1_NC},
1935     {BFD_RELOC_ARM_ALU_SB_G1, R_ARM_ALU_SB_G1},
1936     {BFD_RELOC_ARM_ALU_SB_G2, R_ARM_ALU_SB_G2},
1937     {BFD_RELOC_ARM_LDR_SB_G0, R_ARM_LDR_SB_G0},
1938     {BFD_RELOC_ARM_LDR_SB_G1, R_ARM_LDR_SB_G1},
1939     {BFD_RELOC_ARM_LDR_SB_G2, R_ARM_LDR_SB_G2},
1940     {BFD_RELOC_ARM_LDRS_SB_G0, R_ARM_LDRS_SB_G0},
1941     {BFD_RELOC_ARM_LDRS_SB_G1, R_ARM_LDRS_SB_G1},
1942     {BFD_RELOC_ARM_LDRS_SB_G2, R_ARM_LDRS_SB_G2},
1943     {BFD_RELOC_ARM_LDC_SB_G0, R_ARM_LDC_SB_G0},
1944     {BFD_RELOC_ARM_LDC_SB_G1, R_ARM_LDC_SB_G1},
1945     {BFD_RELOC_ARM_LDC_SB_G2, R_ARM_LDC_SB_G2},
1946     {BFD_RELOC_ARM_V4BX,             R_ARM_V4BX},
1947     {BFD_RELOC_ARM_THUMB_ALU_ABS_G3_NC, R_ARM_THM_ALU_ABS_G3_NC},
1948     {BFD_RELOC_ARM_THUMB_ALU_ABS_G2_NC, R_ARM_THM_ALU_ABS_G2_NC},
1949     {BFD_RELOC_ARM_THUMB_ALU_ABS_G1_NC, R_ARM_THM_ALU_ABS_G1_NC},
1950     {BFD_RELOC_ARM_THUMB_ALU_ABS_G0_NC, R_ARM_THM_ALU_ABS_G0_NC}
1951   };
1952
1953 static reloc_howto_type *
1954 elf32_arm_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1955                              bfd_reloc_code_real_type code)
1956 {
1957   unsigned int i;
1958
1959   for (i = 0; i < ARRAY_SIZE (elf32_arm_reloc_map); i ++)
1960     if (elf32_arm_reloc_map[i].bfd_reloc_val == code)
1961       return elf32_arm_howto_from_type (elf32_arm_reloc_map[i].elf_reloc_val);
1962
1963   return NULL;
1964 }
1965
1966 static reloc_howto_type *
1967 elf32_arm_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1968                              const char *r_name)
1969 {
1970   unsigned int i;
1971
1972   for (i = 0; i < ARRAY_SIZE (elf32_arm_howto_table_1); i++)
1973     if (elf32_arm_howto_table_1[i].name != NULL
1974         && strcasecmp (elf32_arm_howto_table_1[i].name, r_name) == 0)
1975       return &elf32_arm_howto_table_1[i];
1976
1977   for (i = 0; i < ARRAY_SIZE (elf32_arm_howto_table_2); i++)
1978     if (elf32_arm_howto_table_2[i].name != NULL
1979         && strcasecmp (elf32_arm_howto_table_2[i].name, r_name) == 0)
1980       return &elf32_arm_howto_table_2[i];
1981
1982   for (i = 0; i < ARRAY_SIZE (elf32_arm_howto_table_3); i++)
1983     if (elf32_arm_howto_table_3[i].name != NULL
1984         && strcasecmp (elf32_arm_howto_table_3[i].name, r_name) == 0)
1985       return &elf32_arm_howto_table_3[i];
1986
1987   return NULL;
1988 }
1989
1990 /* Support for core dump NOTE sections.  */
1991
1992 static bfd_boolean
1993 elf32_arm_nabi_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
1994 {
1995   int offset;
1996   size_t size;
1997
1998   switch (note->descsz)
1999     {
2000       default:
2001         return FALSE;
2002
2003       case 148:         /* Linux/ARM 32-bit.  */
2004         /* pr_cursig */
2005         elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
2006
2007         /* pr_pid */
2008         elf_tdata (abfd)->core->lwpid = bfd_get_32 (abfd, note->descdata + 24);
2009
2010         /* pr_reg */
2011         offset = 72;
2012         size = 72;
2013
2014         break;
2015     }
2016
2017   /* Make a ".reg/999" section.  */
2018   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
2019                                           size, note->descpos + offset);
2020 }
2021
2022 static bfd_boolean
2023 elf32_arm_nabi_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
2024 {
2025   switch (note->descsz)
2026     {
2027       default:
2028         return FALSE;
2029
2030       case 124:         /* Linux/ARM elf_prpsinfo.  */
2031         elf_tdata (abfd)->core->pid
2032          = bfd_get_32 (abfd, note->descdata + 12);
2033         elf_tdata (abfd)->core->program
2034          = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
2035         elf_tdata (abfd)->core->command
2036          = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
2037     }
2038
2039   /* Note that for some reason, a spurious space is tacked
2040      onto the end of the args in some (at least one anyway)
2041      implementations, so strip it off if it exists.  */
2042   {
2043     char *command = elf_tdata (abfd)->core->command;
2044     int n = strlen (command);
2045
2046     if (0 < n && command[n - 1] == ' ')
2047       command[n - 1] = '\0';
2048   }
2049
2050   return TRUE;
2051 }
2052
2053 static char *
2054 elf32_arm_nabi_write_core_note (bfd *abfd, char *buf, int *bufsiz,
2055                                 int note_type, ...)
2056 {
2057   switch (note_type)
2058     {
2059     default:
2060       return NULL;
2061
2062     case NT_PRPSINFO:
2063       {
2064         char data[124];
2065         va_list ap;
2066
2067         va_start (ap, note_type);
2068         memset (data, 0, sizeof (data));
2069         strncpy (data + 28, va_arg (ap, const char *), 16);
2070         strncpy (data + 44, va_arg (ap, const char *), 80);
2071         va_end (ap);
2072
2073         return elfcore_write_note (abfd, buf, bufsiz,
2074                                    "CORE", note_type, data, sizeof (data));
2075       }
2076
2077     case NT_PRSTATUS:
2078       {
2079         char data[148];
2080         va_list ap;
2081         long pid;
2082         int cursig;
2083         const void *greg;
2084
2085         va_start (ap, note_type);
2086         memset (data, 0, sizeof (data));
2087         pid = va_arg (ap, long);
2088         bfd_put_32 (abfd, pid, data + 24);
2089         cursig = va_arg (ap, int);
2090         bfd_put_16 (abfd, cursig, data + 12);
2091         greg = va_arg (ap, const void *);
2092         memcpy (data + 72, greg, 72);
2093         va_end (ap);
2094
2095         return elfcore_write_note (abfd, buf, bufsiz,
2096                                    "CORE", note_type, data, sizeof (data));
2097       }
2098     }
2099 }
2100
2101 #define TARGET_LITTLE_SYM               arm_elf32_le_vec
2102 #define TARGET_LITTLE_NAME              "elf32-littlearm"
2103 #define TARGET_BIG_SYM                  arm_elf32_be_vec
2104 #define TARGET_BIG_NAME                 "elf32-bigarm"
2105
2106 #define elf_backend_grok_prstatus       elf32_arm_nabi_grok_prstatus
2107 #define elf_backend_grok_psinfo         elf32_arm_nabi_grok_psinfo
2108 #define elf_backend_write_core_note     elf32_arm_nabi_write_core_note
2109
2110 typedef unsigned long int insn32;
2111 typedef unsigned short int insn16;
2112
2113 /* In lieu of proper flags, assume all EABIv4 or later objects are
2114    interworkable.  */
2115 #define INTERWORK_FLAG(abfd)  \
2116   (EF_ARM_EABI_VERSION (elf_elfheader (abfd)->e_flags) >= EF_ARM_EABI_VER4 \
2117   || (elf_elfheader (abfd)->e_flags & EF_ARM_INTERWORK) \
2118   || ((abfd)->flags & BFD_LINKER_CREATED))
2119
2120 /* The linker script knows the section names for placement.
2121    The entry_names are used to do simple name mangling on the stubs.
2122    Given a function name, and its type, the stub can be found. The
2123    name can be changed. The only requirement is the %s be present.  */
2124 #define THUMB2ARM_GLUE_SECTION_NAME ".glue_7t"
2125 #define THUMB2ARM_GLUE_ENTRY_NAME   "__%s_from_thumb"
2126
2127 #define ARM2THUMB_GLUE_SECTION_NAME ".glue_7"
2128 #define ARM2THUMB_GLUE_ENTRY_NAME   "__%s_from_arm"
2129
2130 #define VFP11_ERRATUM_VENEER_SECTION_NAME ".vfp11_veneer"
2131 #define VFP11_ERRATUM_VENEER_ENTRY_NAME   "__vfp11_veneer_%x"
2132
2133 #define STM32L4XX_ERRATUM_VENEER_SECTION_NAME ".text.stm32l4xx_veneer"
2134 #define STM32L4XX_ERRATUM_VENEER_ENTRY_NAME   "__stm32l4xx_veneer_%x"
2135
2136 #define ARM_BX_GLUE_SECTION_NAME ".v4_bx"
2137 #define ARM_BX_GLUE_ENTRY_NAME   "__bx_r%d"
2138
2139 #define STUB_ENTRY_NAME   "__%s_veneer"
2140
2141 /* The name of the dynamic interpreter.  This is put in the .interp
2142    section.  */
2143 #define ELF_DYNAMIC_INTERPRETER     "/usr/lib/ld.so.1"
2144
2145 static const unsigned long tls_trampoline [] =
2146 {
2147   0xe08e0000,           /* add r0, lr, r0 */
2148   0xe5901004,           /* ldr r1, [r0,#4] */
2149   0xe12fff11,           /* bx  r1 */
2150 };
2151
2152 static const unsigned long dl_tlsdesc_lazy_trampoline [] =
2153 {
2154   0xe52d2004, /*        push    {r2}                    */
2155   0xe59f200c, /*      ldr     r2, [pc, #3f - . - 8]     */
2156   0xe59f100c, /*      ldr     r1, [pc, #4f - . - 8]     */
2157   0xe79f2002, /* 1:   ldr     r2, [pc, r2]              */
2158   0xe081100f, /* 2:   add     r1, pc                    */
2159   0xe12fff12, /*      bx      r2                        */
2160   0x00000014, /* 3:   .word  _GLOBAL_OFFSET_TABLE_ - 1b - 8
2161                                 + dl_tlsdesc_lazy_resolver(GOT)   */
2162   0x00000018, /* 4:   .word  _GLOBAL_OFFSET_TABLE_ - 2b - 8 */
2163 };
2164
2165 #ifdef FOUR_WORD_PLT
2166
2167 /* The first entry in a procedure linkage table looks like
2168    this.  It is set up so that any shared library function that is
2169    called before the relocation has been set up calls the dynamic
2170    linker first.  */
2171 static const bfd_vma elf32_arm_plt0_entry [] =
2172 {
2173   0xe52de004,           /* str   lr, [sp, #-4]! */
2174   0xe59fe010,           /* ldr   lr, [pc, #16]  */
2175   0xe08fe00e,           /* add   lr, pc, lr     */
2176   0xe5bef008,           /* ldr   pc, [lr, #8]!  */
2177 };
2178
2179 /* Subsequent entries in a procedure linkage table look like
2180    this.  */
2181 static const bfd_vma elf32_arm_plt_entry [] =
2182 {
2183   0xe28fc600,           /* add   ip, pc, #NN    */
2184   0xe28cca00,           /* add   ip, ip, #NN    */
2185   0xe5bcf000,           /* ldr   pc, [ip, #NN]! */
2186   0x00000000,           /* unused               */
2187 };
2188
2189 #else /* not FOUR_WORD_PLT */
2190
2191 /* The first entry in a procedure linkage table looks like
2192    this.  It is set up so that any shared library function that is
2193    called before the relocation has been set up calls the dynamic
2194    linker first.  */
2195 static const bfd_vma elf32_arm_plt0_entry [] =
2196 {
2197   0xe52de004,           /* str   lr, [sp, #-4]! */
2198   0xe59fe004,           /* ldr   lr, [pc, #4]   */
2199   0xe08fe00e,           /* add   lr, pc, lr     */
2200   0xe5bef008,           /* ldr   pc, [lr, #8]!  */
2201   0x00000000,           /* &GOT[0] - .          */
2202 };
2203
2204 /* By default subsequent entries in a procedure linkage table look like
2205    this. Offsets that don't fit into 28 bits will cause link error.  */
2206 static const bfd_vma elf32_arm_plt_entry_short [] =
2207 {
2208   0xe28fc600,           /* add   ip, pc, #0xNN00000 */
2209   0xe28cca00,           /* add   ip, ip, #0xNN000   */
2210   0xe5bcf000,           /* ldr   pc, [ip, #0xNNN]!  */
2211 };
2212
2213 /* When explicitly asked, we'll use this "long" entry format
2214    which can cope with arbitrary displacements.  */
2215 static const bfd_vma elf32_arm_plt_entry_long [] =
2216 {
2217   0xe28fc200,           /* add   ip, pc, #0xN0000000 */
2218   0xe28cc600,           /* add   ip, ip, #0xNN00000  */
2219   0xe28cca00,           /* add   ip, ip, #0xNN000    */
2220   0xe5bcf000,           /* ldr   pc, [ip, #0xNNN]!   */
2221 };
2222
2223 static bfd_boolean elf32_arm_use_long_plt_entry = FALSE;
2224
2225 #endif /* not FOUR_WORD_PLT */
2226
2227 /* The first entry in a procedure linkage table looks like this.
2228    It is set up so that any shared library function that is called before the
2229    relocation has been set up calls the dynamic linker first.  */
2230 static const bfd_vma elf32_thumb2_plt0_entry [] =
2231 {
2232   /* NOTE: As this is a mixture of 16-bit and 32-bit instructions,
2233      an instruction maybe encoded to one or two array elements.  */
2234   0xf8dfb500,           /* push    {lr}          */
2235   0x44fee008,           /* ldr.w   lr, [pc, #8]  */
2236                         /* add     lr, pc        */
2237   0xff08f85e,           /* ldr.w   pc, [lr, #8]! */
2238   0x00000000,           /* &GOT[0] - .           */
2239 };
2240
2241 /* Subsequent entries in a procedure linkage table for thumb only target
2242    look like this.  */
2243 static const bfd_vma elf32_thumb2_plt_entry [] =
2244 {
2245   /* NOTE: As this is a mixture of 16-bit and 32-bit instructions,
2246      an instruction maybe encoded to one or two array elements.  */
2247   0x0c00f240,           /* movw    ip, #0xNNNN    */
2248   0x0c00f2c0,           /* movt    ip, #0xNNNN    */
2249   0xf8dc44fc,           /* add     ip, pc         */
2250   0xbf00f000            /* ldr.w   pc, [ip]       */
2251                         /* nop                    */
2252 };
2253
2254 /* The format of the first entry in the procedure linkage table
2255    for a VxWorks executable.  */
2256 static const bfd_vma elf32_arm_vxworks_exec_plt0_entry[] =
2257 {
2258   0xe52dc008,           /* str    ip,[sp,#-8]!                  */
2259   0xe59fc000,           /* ldr    ip,[pc]                       */
2260   0xe59cf008,           /* ldr    pc,[ip,#8]                    */
2261   0x00000000,           /* .long  _GLOBAL_OFFSET_TABLE_         */
2262 };
2263
2264 /* The format of subsequent entries in a VxWorks executable.  */
2265 static const bfd_vma elf32_arm_vxworks_exec_plt_entry[] =
2266 {
2267   0xe59fc000,         /* ldr    ip,[pc]                 */
2268   0xe59cf000,         /* ldr    pc,[ip]                 */
2269   0x00000000,         /* .long  @got                            */
2270   0xe59fc000,         /* ldr    ip,[pc]                 */
2271   0xea000000,         /* b      _PLT                            */
2272   0x00000000,         /* .long  @pltindex*sizeof(Elf32_Rela)    */
2273 };
2274
2275 /* The format of entries in a VxWorks shared library.  */
2276 static const bfd_vma elf32_arm_vxworks_shared_plt_entry[] =
2277 {
2278   0xe59fc000,         /* ldr    ip,[pc]                 */
2279   0xe79cf009,         /* ldr    pc,[ip,r9]                      */
2280   0x00000000,         /* .long  @got                            */
2281   0xe59fc000,         /* ldr    ip,[pc]                 */
2282   0xe599f008,         /* ldr    pc,[r9,#8]                      */
2283   0x00000000,         /* .long  @pltindex*sizeof(Elf32_Rela)    */
2284 };
2285
2286 /* An initial stub used if the PLT entry is referenced from Thumb code.  */
2287 #define PLT_THUMB_STUB_SIZE 4
2288 static const bfd_vma elf32_arm_plt_thumb_stub [] =
2289 {
2290   0x4778,               /* bx pc */
2291   0x46c0                /* nop   */
2292 };
2293
2294 /* The entries in a PLT when using a DLL-based target with multiple
2295    address spaces.  */
2296 static const bfd_vma elf32_arm_symbian_plt_entry [] =
2297 {
2298   0xe51ff004,         /* ldr   pc, [pc, #-4] */
2299   0x00000000,         /* dcd   R_ARM_GLOB_DAT(X) */
2300 };
2301
2302 /* The first entry in a procedure linkage table looks like
2303    this.  It is set up so that any shared library function that is
2304    called before the relocation has been set up calls the dynamic
2305    linker first.  */
2306 static const bfd_vma elf32_arm_nacl_plt0_entry [] =
2307 {
2308   /* First bundle: */
2309   0xe300c000,           /* movw ip, #:lower16:&GOT[2]-.+8       */
2310   0xe340c000,           /* movt ip, #:upper16:&GOT[2]-.+8       */
2311   0xe08cc00f,           /* add  ip, ip, pc                      */
2312   0xe52dc008,           /* str  ip, [sp, #-8]!                  */
2313   /* Second bundle: */
2314   0xe3ccc103,           /* bic  ip, ip, #0xc0000000             */
2315   0xe59cc000,           /* ldr  ip, [ip]                        */
2316   0xe3ccc13f,           /* bic  ip, ip, #0xc000000f             */
2317   0xe12fff1c,           /* bx   ip                              */
2318   /* Third bundle: */
2319   0xe320f000,           /* nop                                  */
2320   0xe320f000,           /* nop                                  */
2321   0xe320f000,           /* nop                                  */
2322   /* .Lplt_tail: */
2323   0xe50dc004,           /* str  ip, [sp, #-4]                   */
2324   /* Fourth bundle: */
2325   0xe3ccc103,           /* bic  ip, ip, #0xc0000000             */
2326   0xe59cc000,           /* ldr  ip, [ip]                        */
2327   0xe3ccc13f,           /* bic  ip, ip, #0xc000000f             */
2328   0xe12fff1c,           /* bx   ip                              */
2329 };
2330 #define ARM_NACL_PLT_TAIL_OFFSET        (11 * 4)
2331
2332 /* Subsequent entries in a procedure linkage table look like this.  */
2333 static const bfd_vma elf32_arm_nacl_plt_entry [] =
2334 {
2335   0xe300c000,           /* movw ip, #:lower16:&GOT[n]-.+8       */
2336   0xe340c000,           /* movt ip, #:upper16:&GOT[n]-.+8       */
2337   0xe08cc00f,           /* add  ip, ip, pc                      */
2338   0xea000000,           /* b    .Lplt_tail                      */
2339 };
2340
2341 #define ARM_MAX_FWD_BRANCH_OFFSET  ((((1 << 23) - 1) << 2) + 8)
2342 #define ARM_MAX_BWD_BRANCH_OFFSET  ((-((1 << 23) << 2)) + 8)
2343 #define THM_MAX_FWD_BRANCH_OFFSET  ((1 << 22) -2 + 4)
2344 #define THM_MAX_BWD_BRANCH_OFFSET  (-(1 << 22) + 4)
2345 #define THM2_MAX_FWD_BRANCH_OFFSET (((1 << 24) - 2) + 4)
2346 #define THM2_MAX_BWD_BRANCH_OFFSET (-(1 << 24) + 4)
2347 #define THM2_MAX_FWD_COND_BRANCH_OFFSET (((1 << 20) -2) + 4)
2348 #define THM2_MAX_BWD_COND_BRANCH_OFFSET (-(1 << 20) + 4)
2349
2350 enum stub_insn_type
2351 {
2352   THUMB16_TYPE = 1,
2353   THUMB32_TYPE,
2354   ARM_TYPE,
2355   DATA_TYPE
2356 };
2357
2358 #define THUMB16_INSN(X)         {(X), THUMB16_TYPE, R_ARM_NONE, 0}
2359 /* A bit of a hack.  A Thumb conditional branch, in which the proper condition
2360    is inserted in arm_build_one_stub().  */
2361 #define THUMB16_BCOND_INSN(X)   {(X), THUMB16_TYPE, R_ARM_NONE, 1}
2362 #define THUMB32_INSN(X)         {(X), THUMB32_TYPE, R_ARM_NONE, 0}
2363 #define THUMB32_B_INSN(X, Z)    {(X), THUMB32_TYPE, R_ARM_THM_JUMP24, (Z)}
2364 #define ARM_INSN(X)             {(X), ARM_TYPE, R_ARM_NONE, 0}
2365 #define ARM_REL_INSN(X, Z)      {(X), ARM_TYPE, R_ARM_JUMP24, (Z)}
2366 #define DATA_WORD(X,Y,Z)        {(X), DATA_TYPE, (Y), (Z)}
2367
2368 typedef struct
2369 {
2370   bfd_vma              data;
2371   enum stub_insn_type  type;
2372   unsigned int         r_type;
2373   int                  reloc_addend;
2374 }  insn_sequence;
2375
2376 /* Arm/Thumb -> Arm/Thumb long branch stub. On V5T and above, use blx
2377    to reach the stub if necessary.  */
2378 static const insn_sequence elf32_arm_stub_long_branch_any_any[] =
2379 {
2380   ARM_INSN (0xe51ff004),            /* ldr   pc, [pc, #-4] */
2381   DATA_WORD (0, R_ARM_ABS32, 0),    /* dcd   R_ARM_ABS32(X) */
2382 };
2383
2384 /* V4T Arm -> Thumb long branch stub. Used on V4T where blx is not
2385    available.  */
2386 static const insn_sequence elf32_arm_stub_long_branch_v4t_arm_thumb[] =
2387 {
2388   ARM_INSN (0xe59fc000),            /* ldr   ip, [pc, #0] */
2389   ARM_INSN (0xe12fff1c),            /* bx    ip */
2390   DATA_WORD (0, R_ARM_ABS32, 0),    /* dcd   R_ARM_ABS32(X) */
2391 };
2392
2393 /* Thumb -> Thumb long branch stub. Used on M-profile architectures.  */
2394 static const insn_sequence elf32_arm_stub_long_branch_thumb_only[] =
2395 {
2396   THUMB16_INSN (0xb401),             /* push {r0} */
2397   THUMB16_INSN (0x4802),             /* ldr  r0, [pc, #8] */
2398   THUMB16_INSN (0x4684),             /* mov  ip, r0 */
2399   THUMB16_INSN (0xbc01),             /* pop  {r0} */
2400   THUMB16_INSN (0x4760),             /* bx   ip */
2401   THUMB16_INSN (0xbf00),             /* nop */
2402   DATA_WORD (0, R_ARM_ABS32, 0),     /* dcd  R_ARM_ABS32(X) */
2403 };
2404
2405 /* V4T Thumb -> Thumb long branch stub. Using the stack is not
2406    allowed.  */
2407 static const insn_sequence elf32_arm_stub_long_branch_v4t_thumb_thumb[] =
2408 {
2409   THUMB16_INSN (0x4778),             /* bx   pc */
2410   THUMB16_INSN (0x46c0),             /* nop */
2411   ARM_INSN (0xe59fc000),             /* ldr  ip, [pc, #0] */
2412   ARM_INSN (0xe12fff1c),             /* bx   ip */
2413   DATA_WORD (0, R_ARM_ABS32, 0),     /* dcd  R_ARM_ABS32(X) */
2414 };
2415
2416 /* V4T Thumb -> ARM long branch stub. Used on V4T where blx is not
2417    available.  */
2418 static const insn_sequence elf32_arm_stub_long_branch_v4t_thumb_arm[] =
2419 {
2420   THUMB16_INSN (0x4778),             /* bx   pc */
2421   THUMB16_INSN (0x46c0),             /* nop   */
2422   ARM_INSN (0xe51ff004),             /* ldr   pc, [pc, #-4] */
2423   DATA_WORD (0, R_ARM_ABS32, 0),     /* dcd   R_ARM_ABS32(X) */
2424 };
2425
2426 /* V4T Thumb -> ARM short branch stub. Shorter variant of the above
2427    one, when the destination is close enough.  */
2428 static const insn_sequence elf32_arm_stub_short_branch_v4t_thumb_arm[] =
2429 {
2430   THUMB16_INSN (0x4778),             /* bx   pc */
2431   THUMB16_INSN (0x46c0),             /* nop   */
2432   ARM_REL_INSN (0xea000000, -8),     /* b    (X-8) */
2433 };
2434
2435 /* ARM/Thumb -> ARM long branch stub, PIC.  On V5T and above, use
2436    blx to reach the stub if necessary.  */
2437 static const insn_sequence elf32_arm_stub_long_branch_any_arm_pic[] =
2438 {
2439   ARM_INSN (0xe59fc000),             /* ldr   ip, [pc] */
2440   ARM_INSN (0xe08ff00c),             /* add   pc, pc, ip */
2441   DATA_WORD (0, R_ARM_REL32, -4),    /* dcd   R_ARM_REL32(X-4) */
2442 };
2443
2444 /* ARM/Thumb -> Thumb long branch stub, PIC.  On V5T and above, use
2445    blx to reach the stub if necessary.  We can not add into pc;
2446    it is not guaranteed to mode switch (different in ARMv6 and
2447    ARMv7).  */
2448 static const insn_sequence elf32_arm_stub_long_branch_any_thumb_pic[] =
2449 {
2450   ARM_INSN (0xe59fc004),             /* ldr   ip, [pc, #4] */
2451   ARM_INSN (0xe08fc00c),             /* add   ip, pc, ip */
2452   ARM_INSN (0xe12fff1c),             /* bx    ip */
2453   DATA_WORD (0, R_ARM_REL32, 0),     /* dcd   R_ARM_REL32(X) */
2454 };
2455
2456 /* V4T ARM -> ARM long branch stub, PIC.  */
2457 static const insn_sequence elf32_arm_stub_long_branch_v4t_arm_thumb_pic[] =
2458 {
2459   ARM_INSN (0xe59fc004),             /* ldr   ip, [pc, #4] */
2460   ARM_INSN (0xe08fc00c),             /* add   ip, pc, ip */
2461   ARM_INSN (0xe12fff1c),             /* bx    ip */
2462   DATA_WORD (0, R_ARM_REL32, 0),     /* dcd   R_ARM_REL32(X) */
2463 };
2464
2465 /* V4T Thumb -> ARM long branch stub, PIC.  */
2466 static const insn_sequence elf32_arm_stub_long_branch_v4t_thumb_arm_pic[] =
2467 {
2468   THUMB16_INSN (0x4778),             /* bx   pc */
2469   THUMB16_INSN (0x46c0),             /* nop  */
2470   ARM_INSN (0xe59fc000),             /* ldr  ip, [pc, #0] */
2471   ARM_INSN (0xe08cf00f),             /* add  pc, ip, pc */
2472   DATA_WORD (0, R_ARM_REL32, -4),     /* dcd  R_ARM_REL32(X) */
2473 };
2474
2475 /* Thumb -> Thumb long branch stub, PIC. Used on M-profile
2476    architectures.  */
2477 static const insn_sequence elf32_arm_stub_long_branch_thumb_only_pic[] =
2478 {
2479   THUMB16_INSN (0xb401),             /* push {r0} */
2480   THUMB16_INSN (0x4802),             /* ldr  r0, [pc, #8] */
2481   THUMB16_INSN (0x46fc),             /* mov  ip, pc */
2482   THUMB16_INSN (0x4484),             /* add  ip, r0 */
2483   THUMB16_INSN (0xbc01),             /* pop  {r0} */
2484   THUMB16_INSN (0x4760),             /* bx   ip */
2485   DATA_WORD (0, R_ARM_REL32, 4),     /* dcd  R_ARM_REL32(X) */
2486 };
2487
2488 /* V4T Thumb -> Thumb long branch stub, PIC. Using the stack is not
2489    allowed.  */
2490 static const insn_sequence elf32_arm_stub_long_branch_v4t_thumb_thumb_pic[] =
2491 {
2492   THUMB16_INSN (0x4778),             /* bx   pc */
2493   THUMB16_INSN (0x46c0),             /* nop */
2494   ARM_INSN (0xe59fc004),             /* ldr  ip, [pc, #4] */
2495   ARM_INSN (0xe08fc00c),             /* add   ip, pc, ip */
2496   ARM_INSN (0xe12fff1c),             /* bx   ip */
2497   DATA_WORD (0, R_ARM_REL32, 0),     /* dcd  R_ARM_REL32(X) */
2498 };
2499
2500 /* Thumb2/ARM -> TLS trampoline.  Lowest common denominator, which is a
2501    long PIC stub.  We can use r1 as a scratch -- and cannot use ip.  */
2502 static const insn_sequence elf32_arm_stub_long_branch_any_tls_pic[] =
2503 {
2504   ARM_INSN (0xe59f1000),             /* ldr   r1, [pc] */
2505   ARM_INSN (0xe08ff001),             /* add   pc, pc, r1 */
2506   DATA_WORD (0, R_ARM_REL32, -4),    /* dcd   R_ARM_REL32(X-4) */
2507 };
2508
2509 /* V4T Thumb -> TLS trampoline.  lowest common denominator, which is a
2510    long PIC stub.  We can use r1 as a scratch -- and cannot use ip.  */
2511 static const insn_sequence elf32_arm_stub_long_branch_v4t_thumb_tls_pic[] =
2512 {
2513   THUMB16_INSN (0x4778),             /* bx   pc */
2514   THUMB16_INSN (0x46c0),             /* nop */
2515   ARM_INSN (0xe59f1000),             /* ldr  r1, [pc, #0] */
2516   ARM_INSN (0xe081f00f),             /* add  pc, r1, pc */
2517   DATA_WORD (0, R_ARM_REL32, -4),    /* dcd  R_ARM_REL32(X) */
2518 };
2519
2520 /* NaCl ARM -> ARM long branch stub.  */
2521 static const insn_sequence elf32_arm_stub_long_branch_arm_nacl[] =
2522 {
2523   ARM_INSN (0xe59fc00c),                /* ldr  ip, [pc, #12] */
2524   ARM_INSN (0xe3ccc13f),                /* bic  ip, ip, #0xc000000f */
2525   ARM_INSN (0xe12fff1c),                /* bx   ip */
2526   ARM_INSN (0xe320f000),                /* nop */
2527   ARM_INSN (0xe125be70),                /* bkpt 0x5be0 */
2528   DATA_WORD (0, R_ARM_ABS32, 0),        /* dcd  R_ARM_ABS32(X) */
2529   DATA_WORD (0, R_ARM_NONE, 0),         /* .word 0 */
2530   DATA_WORD (0, R_ARM_NONE, 0),         /* .word 0 */
2531 };
2532
2533 /* NaCl ARM -> ARM long branch stub, PIC.  */
2534 static const insn_sequence elf32_arm_stub_long_branch_arm_nacl_pic[] =
2535 {
2536   ARM_INSN (0xe59fc00c),                /* ldr  ip, [pc, #12] */
2537   ARM_INSN (0xe08cc00f),                /* add  ip, ip, pc */
2538   ARM_INSN (0xe3ccc13f),                /* bic  ip, ip, #0xc000000f */
2539   ARM_INSN (0xe12fff1c),                /* bx   ip */
2540   ARM_INSN (0xe125be70),                /* bkpt 0x5be0 */
2541   DATA_WORD (0, R_ARM_REL32, 8),        /* dcd  R_ARM_REL32(X+8) */
2542   DATA_WORD (0, R_ARM_NONE, 0),         /* .word 0 */
2543   DATA_WORD (0, R_ARM_NONE, 0),         /* .word 0 */
2544 };
2545
2546
2547 /* Cortex-A8 erratum-workaround stubs.  */
2548
2549 /* Stub used for conditional branches (which may be beyond +/-1MB away, so we
2550    can't use a conditional branch to reach this stub).  */
2551
2552 static const insn_sequence elf32_arm_stub_a8_veneer_b_cond[] =
2553 {
2554   THUMB16_BCOND_INSN (0xd001),         /* b<cond>.n true.  */
2555   THUMB32_B_INSN (0xf000b800, -4),     /* b.w insn_after_original_branch.  */
2556   THUMB32_B_INSN (0xf000b800, -4)      /* true: b.w original_branch_dest.  */
2557 };
2558
2559 /* Stub used for b.w and bl.w instructions.  */
2560
2561 static const insn_sequence elf32_arm_stub_a8_veneer_b[] =
2562 {
2563   THUMB32_B_INSN (0xf000b800, -4)       /* b.w original_branch_dest.  */
2564 };
2565
2566 static const insn_sequence elf32_arm_stub_a8_veneer_bl[] =
2567 {
2568   THUMB32_B_INSN (0xf000b800, -4)       /* b.w original_branch_dest.  */
2569 };
2570
2571 /* Stub used for Thumb-2 blx.w instructions.  We modified the original blx.w
2572    instruction (which switches to ARM mode) to point to this stub.  Jump to the
2573    real destination using an ARM-mode branch.  */
2574
2575 static const insn_sequence elf32_arm_stub_a8_veneer_blx[] =
2576 {
2577   ARM_REL_INSN (0xea000000, -8) /* b original_branch_dest.  */
2578 };
2579
2580 /* For each section group there can be a specially created linker section
2581    to hold the stubs for that group.  The name of the stub section is based
2582    upon the name of another section within that group with the suffix below
2583    applied.
2584
2585    PR 13049: STUB_SUFFIX used to be ".stub", but this allowed the user to
2586    create what appeared to be a linker stub section when it actually
2587    contained user code/data.  For example, consider this fragment:
2588
2589      const char * stubborn_problems[] = { "np" };
2590
2591    If this is compiled with "-fPIC -fdata-sections" then gcc produces a
2592    section called:
2593
2594      .data.rel.local.stubborn_problems
2595
2596    This then causes problems in arm32_arm_build_stubs() as it triggers:
2597
2598       // Ignore non-stub sections.
2599       if (!strstr (stub_sec->name, STUB_SUFFIX))
2600         continue;
2601
2602    And so the section would be ignored instead of being processed.  Hence
2603    the change in definition of STUB_SUFFIX to a name that cannot be a valid
2604    C identifier.  */
2605 #define STUB_SUFFIX ".__stub"
2606
2607 /* One entry per long/short branch stub defined above.  */
2608 #define DEF_STUBS \
2609   DEF_STUB(long_branch_any_any) \
2610   DEF_STUB(long_branch_v4t_arm_thumb) \
2611   DEF_STUB(long_branch_thumb_only) \
2612   DEF_STUB(long_branch_v4t_thumb_thumb) \
2613   DEF_STUB(long_branch_v4t_thumb_arm) \
2614   DEF_STUB(short_branch_v4t_thumb_arm) \
2615   DEF_STUB(long_branch_any_arm_pic) \
2616   DEF_STUB(long_branch_any_thumb_pic) \
2617   DEF_STUB(long_branch_v4t_thumb_thumb_pic) \
2618   DEF_STUB(long_branch_v4t_arm_thumb_pic) \
2619   DEF_STUB(long_branch_v4t_thumb_arm_pic) \
2620   DEF_STUB(long_branch_thumb_only_pic) \
2621   DEF_STUB(long_branch_any_tls_pic) \
2622   DEF_STUB(long_branch_v4t_thumb_tls_pic) \
2623   DEF_STUB(long_branch_arm_nacl) \
2624   DEF_STUB(long_branch_arm_nacl_pic) \
2625   DEF_STUB(a8_veneer_b_cond) \
2626   DEF_STUB(a8_veneer_b) \
2627   DEF_STUB(a8_veneer_bl) \
2628   DEF_STUB(a8_veneer_blx)
2629
2630 #define DEF_STUB(x) arm_stub_##x,
2631 enum elf32_arm_stub_type
2632 {
2633   arm_stub_none,
2634   DEF_STUBS
2635   max_stub_type
2636 };
2637 #undef DEF_STUB
2638
2639 /* Note the first a8_veneer type.  */
2640 const unsigned arm_stub_a8_veneer_lwm = arm_stub_a8_veneer_b_cond;
2641
2642 typedef struct
2643 {
2644   const insn_sequence* template_sequence;
2645   int template_size;
2646 } stub_def;
2647
2648 #define DEF_STUB(x) {elf32_arm_stub_##x, ARRAY_SIZE(elf32_arm_stub_##x)},
2649 static const stub_def stub_definitions[] =
2650 {
2651   {NULL, 0},
2652   DEF_STUBS
2653 };
2654
2655 struct elf32_arm_stub_hash_entry
2656 {
2657   /* Base hash table entry structure.  */
2658   struct bfd_hash_entry root;
2659
2660   /* The stub section.  */
2661   asection *stub_sec;
2662
2663   /* Offset within stub_sec of the beginning of this stub.  */
2664   bfd_vma stub_offset;
2665
2666   /* Given the symbol's value and its section we can determine its final
2667      value when building the stubs (so the stub knows where to jump).  */
2668   bfd_vma target_value;
2669   asection *target_section;
2670
2671   /* Same as above but for the source of the branch to the stub.  Used for
2672      Cortex-A8 erratum workaround to patch it to branch to the stub.  As
2673      such, source section does not need to be recorded since Cortex-A8 erratum
2674      workaround stubs are only generated when both source and target are in the
2675      same section.  */
2676   bfd_vma source_value;
2677
2678   /* The instruction which caused this stub to be generated (only valid for
2679      Cortex-A8 erratum workaround stubs at present).  */
2680   unsigned long orig_insn;
2681
2682   /* The stub type.  */
2683   enum elf32_arm_stub_type stub_type;
2684   /* Its encoding size in bytes.  */
2685   int stub_size;
2686   /* Its template.  */
2687   const insn_sequence *stub_template;
2688   /* The size of the template (number of entries).  */
2689   int stub_template_size;
2690
2691   /* The symbol table entry, if any, that this was derived from.  */
2692   struct elf32_arm_link_hash_entry *h;
2693
2694   /* Type of branch.  */
2695   enum arm_st_branch_type branch_type;
2696
2697   /* Where this stub is being called from, or, in the case of combined
2698      stub sections, the first input section in the group.  */
2699   asection *id_sec;
2700
2701   /* The name for the local symbol at the start of this stub.  The
2702      stub name in the hash table has to be unique; this does not, so
2703      it can be friendlier.  */
2704   char *output_name;
2705 };
2706
2707 /* Used to build a map of a section.  This is required for mixed-endian
2708    code/data.  */
2709
2710 typedef struct elf32_elf_section_map
2711 {
2712   bfd_vma vma;
2713   char type;
2714 }
2715 elf32_arm_section_map;
2716
2717 /* Information about a VFP11 erratum veneer, or a branch to such a veneer.  */
2718
2719 typedef enum
2720 {
2721   VFP11_ERRATUM_BRANCH_TO_ARM_VENEER,
2722   VFP11_ERRATUM_BRANCH_TO_THUMB_VENEER,
2723   VFP11_ERRATUM_ARM_VENEER,
2724   VFP11_ERRATUM_THUMB_VENEER
2725 }
2726 elf32_vfp11_erratum_type;
2727
2728 typedef struct elf32_vfp11_erratum_list
2729 {
2730   struct elf32_vfp11_erratum_list *next;
2731   bfd_vma vma;
2732   union
2733   {
2734     struct
2735     {
2736       struct elf32_vfp11_erratum_list *veneer;
2737       unsigned int vfp_insn;
2738     } b;
2739     struct
2740     {
2741       struct elf32_vfp11_erratum_list *branch;
2742       unsigned int id;
2743     } v;
2744   } u;
2745   elf32_vfp11_erratum_type type;
2746 }
2747 elf32_vfp11_erratum_list;
2748
2749 /* Information about a STM32L4XX erratum veneer, or a branch to such a
2750    veneer.  */
2751 typedef enum
2752 {
2753   STM32L4XX_ERRATUM_BRANCH_TO_VENEER,
2754   STM32L4XX_ERRATUM_VENEER
2755 }
2756 elf32_stm32l4xx_erratum_type;
2757
2758 typedef struct elf32_stm32l4xx_erratum_list
2759 {
2760   struct elf32_stm32l4xx_erratum_list *next;
2761   bfd_vma vma;
2762   union
2763   {
2764     struct
2765     {
2766       struct elf32_stm32l4xx_erratum_list *veneer;
2767       unsigned int insn;
2768     } b;
2769     struct
2770     {
2771       struct elf32_stm32l4xx_erratum_list *branch;
2772       unsigned int id;
2773     } v;
2774   } u;
2775   elf32_stm32l4xx_erratum_type type;
2776 }
2777 elf32_stm32l4xx_erratum_list;
2778
2779 typedef enum
2780 {
2781   DELETE_EXIDX_ENTRY,
2782   INSERT_EXIDX_CANTUNWIND_AT_END
2783 }
2784 arm_unwind_edit_type;
2785
2786 /* A (sorted) list of edits to apply to an unwind table.  */
2787 typedef struct arm_unwind_table_edit
2788 {
2789   arm_unwind_edit_type type;
2790   /* Note: we sometimes want to insert an unwind entry corresponding to a
2791      section different from the one we're currently writing out, so record the
2792      (text) section this edit relates to here.  */
2793   asection *linked_section;
2794   unsigned int index;
2795   struct arm_unwind_table_edit *next;
2796 }
2797 arm_unwind_table_edit;
2798
2799 typedef struct _arm_elf_section_data
2800 {
2801   /* Information about mapping symbols.  */
2802   struct bfd_elf_section_data elf;
2803   unsigned int mapcount;
2804   unsigned int mapsize;
2805   elf32_arm_section_map *map;
2806   /* Information about CPU errata.  */
2807   unsigned int erratumcount;
2808   elf32_vfp11_erratum_list *erratumlist;
2809   unsigned int stm32l4xx_erratumcount;
2810   elf32_stm32l4xx_erratum_list *stm32l4xx_erratumlist;
2811   unsigned int additional_reloc_count;
2812   /* Information about unwind tables.  */
2813   union
2814   {
2815     /* Unwind info attached to a text section.  */
2816     struct
2817     {
2818       asection *arm_exidx_sec;
2819     } text;
2820
2821     /* Unwind info attached to an .ARM.exidx section.  */
2822     struct
2823     {
2824       arm_unwind_table_edit *unwind_edit_list;
2825       arm_unwind_table_edit *unwind_edit_tail;
2826     } exidx;
2827   } u;
2828 }
2829 _arm_elf_section_data;
2830
2831 #define elf32_arm_section_data(sec) \
2832   ((_arm_elf_section_data *) elf_section_data (sec))
2833
2834 /* A fix which might be required for Cortex-A8 Thumb-2 branch/TLB erratum.
2835    These fixes are subject to a relaxation procedure (in elf32_arm_size_stubs),
2836    so may be created multiple times: we use an array of these entries whilst
2837    relaxing which we can refresh easily, then create stubs for each potentially
2838    erratum-triggering instruction once we've settled on a solution.  */
2839
2840 struct a8_erratum_fix
2841 {
2842   bfd *input_bfd;
2843   asection *section;
2844   bfd_vma offset;
2845   bfd_vma target_offset;
2846   unsigned long orig_insn;
2847   char *stub_name;
2848   enum elf32_arm_stub_type stub_type;
2849   enum arm_st_branch_type branch_type;
2850 };
2851
2852 /* A table of relocs applied to branches which might trigger Cortex-A8
2853    erratum.  */
2854
2855 struct a8_erratum_reloc
2856 {
2857   bfd_vma from;
2858   bfd_vma destination;
2859   struct elf32_arm_link_hash_entry *hash;
2860   const char *sym_name;
2861   unsigned int r_type;
2862   enum arm_st_branch_type branch_type;
2863   bfd_boolean non_a8_stub;
2864 };
2865
2866 /* The size of the thread control block.  */
2867 #define TCB_SIZE        8
2868
2869 /* ARM-specific information about a PLT entry, over and above the usual
2870    gotplt_union.  */
2871 struct arm_plt_info
2872 {
2873   /* We reference count Thumb references to a PLT entry separately,
2874      so that we can emit the Thumb trampoline only if needed.  */
2875   bfd_signed_vma thumb_refcount;
2876
2877   /* Some references from Thumb code may be eliminated by BL->BLX
2878      conversion, so record them separately.  */
2879   bfd_signed_vma maybe_thumb_refcount;
2880
2881   /* How many of the recorded PLT accesses were from non-call relocations.
2882      This information is useful when deciding whether anything takes the
2883      address of an STT_GNU_IFUNC PLT.  A value of 0 means that all
2884      non-call references to the function should resolve directly to the
2885      real runtime target.  */
2886   unsigned int noncall_refcount;
2887
2888   /* Since PLT entries have variable size if the Thumb prologue is
2889      used, we need to record the index into .got.plt instead of
2890      recomputing it from the PLT offset.  */
2891   bfd_signed_vma got_offset;
2892 };
2893
2894 /* Information about an .iplt entry for a local STT_GNU_IFUNC symbol.  */
2895 struct arm_local_iplt_info
2896 {
2897   /* The information that is usually found in the generic ELF part of
2898      the hash table entry.  */
2899   union gotplt_union root;
2900
2901   /* The information that is usually found in the ARM-specific part of
2902      the hash table entry.  */
2903   struct arm_plt_info arm;
2904
2905   /* A list of all potential dynamic relocations against this symbol.  */
2906   struct elf_dyn_relocs *dyn_relocs;
2907 };
2908
2909 struct elf_arm_obj_tdata
2910 {
2911   struct elf_obj_tdata root;
2912
2913   /* tls_type for each local got entry.  */
2914   char *local_got_tls_type;
2915
2916   /* GOTPLT entries for TLS descriptors.  */
2917   bfd_vma *local_tlsdesc_gotent;
2918
2919   /* Information for local symbols that need entries in .iplt.  */
2920   struct arm_local_iplt_info **local_iplt;
2921
2922   /* Zero to warn when linking objects with incompatible enum sizes.  */
2923   int no_enum_size_warning;
2924
2925   /* Zero to warn when linking objects with incompatible wchar_t sizes.  */
2926   int no_wchar_size_warning;
2927 };
2928
2929 #define elf_arm_tdata(bfd) \
2930   ((struct elf_arm_obj_tdata *) (bfd)->tdata.any)
2931
2932 #define elf32_arm_local_got_tls_type(bfd) \
2933   (elf_arm_tdata (bfd)->local_got_tls_type)
2934
2935 #define elf32_arm_local_tlsdesc_gotent(bfd) \
2936   (elf_arm_tdata (bfd)->local_tlsdesc_gotent)
2937
2938 #define elf32_arm_local_iplt(bfd) \
2939   (elf_arm_tdata (bfd)->local_iplt)
2940
2941 #define is_arm_elf(bfd) \
2942   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2943    && elf_tdata (bfd) != NULL \
2944    && elf_object_id (bfd) == ARM_ELF_DATA)
2945
2946 static bfd_boolean
2947 elf32_arm_mkobject (bfd *abfd)
2948 {
2949   return bfd_elf_allocate_object (abfd, sizeof (struct elf_arm_obj_tdata),
2950                                   ARM_ELF_DATA);
2951 }
2952
2953 #define elf32_arm_hash_entry(ent) ((struct elf32_arm_link_hash_entry *)(ent))
2954
2955 /* Arm ELF linker hash entry.  */
2956 struct elf32_arm_link_hash_entry
2957 {
2958   struct elf_link_hash_entry root;
2959
2960   /* Track dynamic relocs copied for this symbol.  */
2961   struct elf_dyn_relocs *dyn_relocs;
2962
2963   /* ARM-specific PLT information.  */
2964   struct arm_plt_info plt;
2965
2966 #define GOT_UNKNOWN     0
2967 #define GOT_NORMAL      1
2968 #define GOT_TLS_GD      2
2969 #define GOT_TLS_IE      4
2970 #define GOT_TLS_GDESC   8
2971 #define GOT_TLS_GD_ANY_P(type)  ((type & GOT_TLS_GD) || (type & GOT_TLS_GDESC))
2972   unsigned int tls_type : 8;
2973
2974   /* True if the symbol's PLT entry is in .iplt rather than .plt.  */
2975   unsigned int is_iplt : 1;
2976
2977   unsigned int unused : 23;
2978
2979   /* Offset of the GOTPLT entry reserved for the TLS descriptor,
2980      starting at the end of the jump table.  */
2981   bfd_vma tlsdesc_got;
2982
2983   /* The symbol marking the real symbol location for exported thumb
2984      symbols with Arm stubs.  */
2985   struct elf_link_hash_entry *export_glue;
2986
2987   /* A pointer to the most recently used stub hash entry against this
2988      symbol.  */
2989   struct elf32_arm_stub_hash_entry *stub_cache;
2990 };
2991
2992 /* Traverse an arm ELF linker hash table.  */
2993 #define elf32_arm_link_hash_traverse(table, func, info)                 \
2994   (elf_link_hash_traverse                                               \
2995    (&(table)->root,                                                     \
2996     (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func),    \
2997     (info)))
2998
2999 /* Get the ARM elf linker hash table from a link_info structure.  */
3000 #define elf32_arm_hash_table(info) \
3001   (elf_hash_table_id ((struct elf_link_hash_table *) ((info)->hash)) \
3002   == ARM_ELF_DATA ? ((struct elf32_arm_link_hash_table *) ((info)->hash)) : NULL)
3003
3004 #define arm_stub_hash_lookup(table, string, create, copy) \
3005   ((struct elf32_arm_stub_hash_entry *) \
3006    bfd_hash_lookup ((table), (string), (create), (copy)))
3007
3008 /* Array to keep track of which stub sections have been created, and
3009    information on stub grouping.  */
3010 struct map_stub
3011 {
3012   /* This is the section to which stubs in the group will be
3013      attached.  */
3014   asection *link_sec;
3015   /* The stub section.  */
3016   asection *stub_sec;
3017 };
3018
3019 #define elf32_arm_compute_jump_table_size(htab) \
3020   ((htab)->next_tls_desc_index * 4)
3021
3022 /* ARM ELF linker hash table.  */
3023 struct elf32_arm_link_hash_table
3024 {
3025   /* The main hash table.  */
3026   struct elf_link_hash_table root;
3027
3028   /* The size in bytes of the section containing the Thumb-to-ARM glue.  */
3029   bfd_size_type thumb_glue_size;
3030
3031   /* The size in bytes of the section containing the ARM-to-Thumb glue.  */
3032   bfd_size_type arm_glue_size;
3033
3034   /* The size in bytes of section containing the ARMv4 BX veneers.  */
3035   bfd_size_type bx_glue_size;
3036
3037   /* Offsets of ARMv4 BX veneers.  Bit1 set if present, and Bit0 set when
3038      veneer has been populated.  */
3039   bfd_vma bx_glue_offset[15];
3040
3041   /* The size in bytes of the section containing glue for VFP11 erratum
3042      veneers.  */
3043   bfd_size_type vfp11_erratum_glue_size;
3044
3045  /* The size in bytes of the section containing glue for STM32L4XX erratum
3046      veneers.  */
3047   bfd_size_type stm32l4xx_erratum_glue_size;
3048
3049   /* A table of fix locations for Cortex-A8 Thumb-2 branch/TLB erratum.  This
3050      holds Cortex-A8 erratum fix locations between elf32_arm_size_stubs() and
3051      elf32_arm_write_section().  */
3052   struct a8_erratum_fix *a8_erratum_fixes;
3053   unsigned int num_a8_erratum_fixes;
3054
3055   /* An arbitrary input BFD chosen to hold the glue sections.  */
3056   bfd * bfd_of_glue_owner;
3057
3058   /* Nonzero to output a BE8 image.  */
3059   int byteswap_code;
3060
3061   /* Zero if R_ARM_TARGET1 means R_ARM_ABS32.
3062      Nonzero if R_ARM_TARGET1 means R_ARM_REL32.  */
3063   int target1_is_rel;
3064
3065   /* The relocation to use for R_ARM_TARGET2 relocations.  */
3066   int target2_reloc;
3067
3068   /* 0 = Ignore R_ARM_V4BX.
3069      1 = Convert BX to MOV PC.
3070      2 = Generate v4 interworing stubs.  */
3071   int fix_v4bx;
3072
3073   /* Whether we should fix the Cortex-A8 Thumb-2 branch/TLB erratum.  */
3074   int fix_cortex_a8;
3075
3076   /* Whether we should fix the ARM1176 BLX immediate issue.  */
3077   int fix_arm1176;
3078
3079   /* Nonzero if the ARM/Thumb BLX instructions are available for use.  */
3080   int use_blx;
3081
3082   /* What sort of code sequences we should look for which may trigger the
3083      VFP11 denorm erratum.  */
3084   bfd_arm_vfp11_fix vfp11_fix;
3085
3086   /* Global counter for the number of fixes we have emitted.  */
3087   int num_vfp11_fixes;
3088
3089   /* What sort of code sequences we should look for which may trigger the
3090      STM32L4XX erratum.  */
3091   bfd_arm_stm32l4xx_fix stm32l4xx_fix;
3092
3093   /* Global counter for the number of fixes we have emitted.  */
3094   int num_stm32l4xx_fixes;
3095
3096   /* Nonzero to force PIC branch veneers.  */
3097   int pic_veneer;
3098
3099   /* The number of bytes in the initial entry in the PLT.  */
3100   bfd_size_type plt_header_size;
3101
3102   /* The number of bytes in the subsequent PLT etries.  */
3103   bfd_size_type plt_entry_size;
3104
3105   /* True if the target system is VxWorks.  */
3106   int vxworks_p;
3107
3108   /* True if the target system is Symbian OS.  */
3109   int symbian_p;
3110
3111   /* True if the target system is Native Client.  */
3112   int nacl_p;
3113
3114   /* True if the target uses REL relocations.  */
3115   int use_rel;
3116
3117   /* The index of the next unused R_ARM_TLS_DESC slot in .rel.plt.  */
3118   bfd_vma next_tls_desc_index;
3119
3120   /* How many R_ARM_TLS_DESC relocations were generated so far.  */
3121   bfd_vma num_tls_desc;
3122
3123   /* Short-cuts to get to dynamic linker sections.  */
3124   asection *sdynbss;
3125   asection *srelbss;
3126
3127   /* The (unloaded but important) VxWorks .rela.plt.unloaded section.  */
3128   asection *srelplt2;
3129
3130   /* The offset into splt of the PLT entry for the TLS descriptor
3131      resolver.  Special values are 0, if not necessary (or not found
3132      to be necessary yet), and -1 if needed but not determined
3133      yet.  */
3134   bfd_vma dt_tlsdesc_plt;
3135
3136   /* The offset into sgot of the GOT entry used by the PLT entry
3137      above.  */
3138   bfd_vma dt_tlsdesc_got;
3139
3140   /* Offset in .plt section of tls_arm_trampoline.  */
3141   bfd_vma tls_trampoline;
3142
3143   /* Data for R_ARM_TLS_LDM32 relocations.  */
3144   union
3145   {
3146     bfd_signed_vma refcount;
3147     bfd_vma offset;
3148   } tls_ldm_got;
3149
3150   /* Small local sym cache.  */
3151   struct sym_cache sym_cache;
3152
3153   /* For convenience in allocate_dynrelocs.  */
3154   bfd * obfd;
3155
3156   /* The amount of space used by the reserved portion of the sgotplt
3157      section, plus whatever space is used by the jump slots.  */
3158   bfd_vma sgotplt_jump_table_size;
3159
3160   /* The stub hash table.  */
3161   struct bfd_hash_table stub_hash_table;
3162
3163   /* Linker stub bfd.  */
3164   bfd *stub_bfd;
3165
3166   /* Linker call-backs.  */
3167   asection * (*add_stub_section) (const char *, asection *, asection *,
3168                                   unsigned int);
3169   void (*layout_sections_again) (void);
3170
3171   /* Array to keep track of which stub sections have been created, and
3172      information on stub grouping.  */
3173   struct map_stub *stub_group;
3174
3175   /* Number of elements in stub_group.  */
3176   unsigned int top_id;
3177
3178   /* Assorted information used by elf32_arm_size_stubs.  */
3179   unsigned int bfd_count;
3180   unsigned int top_index;
3181   asection **input_list;
3182 };
3183
3184 static inline int
3185 ctz (unsigned int mask)
3186 {
3187 #if GCC_VERSION >= 3004
3188   return __builtin_ctz (mask);
3189 #else
3190   unsigned int i;
3191
3192   for (i = 0; i < 8 * sizeof (mask); i++)
3193     {
3194       if (mask & 0x1)
3195         break;
3196       mask = (mask >> 1);
3197     }
3198   return i;
3199 #endif
3200 }
3201
3202 static inline int
3203 popcount (unsigned int mask)
3204 {
3205 #if GCC_VERSION >= 3004
3206   return __builtin_popcount (mask);
3207 #else
3208   unsigned int i, sum = 0;
3209
3210   for (i = 0; i < 8 * sizeof (mask); i++)
3211     {
3212       if (mask & 0x1)
3213         sum++;
3214       mask = (mask >> 1);
3215     }
3216   return sum;
3217 #endif
3218 }
3219
3220 /* Create an entry in an ARM ELF linker hash table.  */
3221
3222 static struct bfd_hash_entry *
3223 elf32_arm_link_hash_newfunc (struct bfd_hash_entry * entry,
3224                              struct bfd_hash_table * table,
3225                              const char * string)
3226 {
3227   struct elf32_arm_link_hash_entry * ret =
3228     (struct elf32_arm_link_hash_entry *) entry;
3229
3230   /* Allocate the structure if it has not already been allocated by a
3231      subclass.  */
3232   if (ret == NULL)
3233     ret = (struct elf32_arm_link_hash_entry *)
3234         bfd_hash_allocate (table, sizeof (struct elf32_arm_link_hash_entry));
3235   if (ret == NULL)
3236     return (struct bfd_hash_entry *) ret;
3237
3238   /* Call the allocation method of the superclass.  */
3239   ret = ((struct elf32_arm_link_hash_entry *)
3240          _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
3241                                      table, string));
3242   if (ret != NULL)
3243     {
3244       ret->dyn_relocs = NULL;
3245       ret->tls_type = GOT_UNKNOWN;
3246       ret->tlsdesc_got = (bfd_vma) -1;
3247       ret->plt.thumb_refcount = 0;
3248       ret->plt.maybe_thumb_refcount = 0;
3249       ret->plt.noncall_refcount = 0;
3250       ret->plt.got_offset = -1;
3251       ret->is_iplt = FALSE;
3252       ret->export_glue = NULL;
3253
3254       ret->stub_cache = NULL;
3255     }
3256
3257   return (struct bfd_hash_entry *) ret;
3258 }
3259
3260 /* Ensure that we have allocated bookkeeping structures for ABFD's local
3261    symbols.  */
3262
3263 static bfd_boolean
3264 elf32_arm_allocate_local_sym_info (bfd *abfd)
3265 {
3266   if (elf_local_got_refcounts (abfd) == NULL)
3267     {
3268       bfd_size_type num_syms;
3269       bfd_size_type size;
3270       char *data;
3271
3272       num_syms = elf_tdata (abfd)->symtab_hdr.sh_info;
3273       size = num_syms * (sizeof (bfd_signed_vma)
3274                          + sizeof (struct arm_local_iplt_info *)
3275                          + sizeof (bfd_vma)
3276                          + sizeof (char));
3277       data = bfd_zalloc (abfd, size);
3278       if (data == NULL)
3279         return FALSE;
3280
3281       elf_local_got_refcounts (abfd) = (bfd_signed_vma *) data;
3282       data += num_syms * sizeof (bfd_signed_vma);
3283
3284       elf32_arm_local_iplt (abfd) = (struct arm_local_iplt_info **) data;
3285       data += num_syms * sizeof (struct arm_local_iplt_info *);
3286
3287       elf32_arm_local_tlsdesc_gotent (abfd) = (bfd_vma *) data;
3288       data += num_syms * sizeof (bfd_vma);
3289
3290       elf32_arm_local_got_tls_type (abfd) = data;
3291     }
3292   return TRUE;
3293 }
3294
3295 /* Return the .iplt information for local symbol R_SYMNDX, which belongs
3296    to input bfd ABFD.  Create the information if it doesn't already exist.
3297    Return null if an allocation fails.  */
3298
3299 static struct arm_local_iplt_info *
3300 elf32_arm_create_local_iplt (bfd *abfd, unsigned long r_symndx)
3301 {
3302   struct arm_local_iplt_info **ptr;
3303
3304   if (!elf32_arm_allocate_local_sym_info (abfd))
3305     return NULL;
3306
3307   BFD_ASSERT (r_symndx < elf_tdata (abfd)->symtab_hdr.sh_info);
3308   ptr = &elf32_arm_local_iplt (abfd)[r_symndx];
3309   if (*ptr == NULL)
3310     *ptr = bfd_zalloc (abfd, sizeof (**ptr));
3311   return *ptr;
3312 }
3313
3314 /* Try to obtain PLT information for the symbol with index R_SYMNDX
3315    in ABFD's symbol table.  If the symbol is global, H points to its
3316    hash table entry, otherwise H is null.
3317
3318    Return true if the symbol does have PLT information.  When returning
3319    true, point *ROOT_PLT at the target-independent reference count/offset
3320    union and *ARM_PLT at the ARM-specific information.  */
3321
3322 static bfd_boolean
3323 elf32_arm_get_plt_info (bfd *abfd, struct elf32_arm_link_hash_entry *h,
3324                         unsigned long r_symndx, union gotplt_union **root_plt,
3325                         struct arm_plt_info **arm_plt)
3326 {
3327   struct arm_local_iplt_info *local_iplt;
3328
3329   if (h != NULL)
3330     {
3331       *root_plt = &h->root.plt;
3332       *arm_plt = &h->plt;
3333       return TRUE;
3334     }
3335
3336   if (elf32_arm_local_iplt (abfd) == NULL)
3337     return FALSE;
3338
3339   local_iplt = elf32_arm_local_iplt (abfd)[r_symndx];
3340   if (local_iplt == NULL)
3341     return FALSE;
3342
3343   *root_plt = &local_iplt->root;
3344   *arm_plt = &local_iplt->arm;
3345   return TRUE;
3346 }
3347
3348 /* Return true if the PLT described by ARM_PLT requires a Thumb stub
3349    before it.  */
3350
3351 static bfd_boolean
3352 elf32_arm_plt_needs_thumb_stub_p (struct bfd_link_info *info,
3353                                   struct arm_plt_info *arm_plt)
3354 {
3355   struct elf32_arm_link_hash_table *htab;
3356
3357   htab = elf32_arm_hash_table (info);
3358   return (arm_plt->thumb_refcount != 0
3359           || (!htab->use_blx && arm_plt->maybe_thumb_refcount != 0));
3360 }
3361
3362 /* Return a pointer to the head of the dynamic reloc list that should
3363    be used for local symbol ISYM, which is symbol number R_SYMNDX in
3364    ABFD's symbol table.  Return null if an error occurs.  */
3365
3366 static struct elf_dyn_relocs **
3367 elf32_arm_get_local_dynreloc_list (bfd *abfd, unsigned long r_symndx,
3368                                    Elf_Internal_Sym *isym)
3369 {
3370   if (ELF32_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
3371     {
3372       struct arm_local_iplt_info *local_iplt;
3373
3374       local_iplt = elf32_arm_create_local_iplt (abfd, r_symndx);
3375       if (local_iplt == NULL)
3376         return NULL;
3377       return &local_iplt->dyn_relocs;
3378     }
3379   else
3380     {
3381       /* Track dynamic relocs needed for local syms too.
3382          We really need local syms available to do this
3383          easily.  Oh well.  */
3384       asection *s;
3385       void *vpp;
3386
3387       s = bfd_section_from_elf_index (abfd, isym->st_shndx);
3388       if (s == NULL)
3389         abort ();
3390
3391       vpp = &elf_section_data (s)->local_dynrel;
3392       return (struct elf_dyn_relocs **) vpp;
3393     }
3394 }
3395
3396 /* Initialize an entry in the stub hash table.  */
3397
3398 static struct bfd_hash_entry *
3399 stub_hash_newfunc (struct bfd_hash_entry *entry,
3400                    struct bfd_hash_table *table,
3401                    const char *string)
3402 {
3403   /* Allocate the structure if it has not already been allocated by a
3404      subclass.  */
3405   if (entry == NULL)
3406     {
3407       entry = (struct bfd_hash_entry *)
3408           bfd_hash_allocate (table, sizeof (struct elf32_arm_stub_hash_entry));
3409       if (entry == NULL)
3410         return entry;
3411     }
3412
3413   /* Call the allocation method of the superclass.  */
3414   entry = bfd_hash_newfunc (entry, table, string);
3415   if (entry != NULL)
3416     {
3417       struct elf32_arm_stub_hash_entry *eh;
3418
3419       /* Initialize the local fields.  */
3420       eh = (struct elf32_arm_stub_hash_entry *) entry;
3421       eh->stub_sec = NULL;
3422       eh->stub_offset = 0;
3423       eh->source_value = 0;
3424       eh->target_value = 0;
3425       eh->target_section = NULL;
3426       eh->orig_insn = 0;
3427       eh->stub_type = arm_stub_none;
3428       eh->stub_size = 0;
3429       eh->stub_template = NULL;
3430       eh->stub_template_size = 0;
3431       eh->h = NULL;
3432       eh->id_sec = NULL;
3433       eh->output_name = NULL;
3434     }
3435
3436   return entry;
3437 }
3438
3439 /* Create .got, .gotplt, and .rel(a).got sections in DYNOBJ, and set up
3440    shortcuts to them in our hash table.  */
3441
3442 static bfd_boolean
3443 create_got_section (bfd *dynobj, struct bfd_link_info *info)
3444 {
3445   struct elf32_arm_link_hash_table *htab;
3446
3447   htab = elf32_arm_hash_table (info);
3448   if (htab == NULL)
3449     return FALSE;
3450
3451   /* BPABI objects never have a GOT, or associated sections.  */
3452   if (htab->symbian_p)
3453     return TRUE;
3454
3455   if (! _bfd_elf_create_got_section (dynobj, info))
3456     return FALSE;
3457
3458   return TRUE;
3459 }
3460
3461 /* Create the .iplt, .rel(a).iplt and .igot.plt sections.  */
3462
3463 static bfd_boolean
3464 create_ifunc_sections (struct bfd_link_info *info)
3465 {
3466   struct elf32_arm_link_hash_table *htab;
3467   const struct elf_backend_data *bed;
3468   bfd *dynobj;
3469   asection *s;
3470   flagword flags;
3471
3472   htab = elf32_arm_hash_table (info);
3473   dynobj = htab->root.dynobj;
3474   bed = get_elf_backend_data (dynobj);
3475   flags = bed->dynamic_sec_flags;
3476
3477   if (htab->root.iplt == NULL)
3478     {
3479       s = bfd_make_section_anyway_with_flags (dynobj, ".iplt",
3480                                               flags | SEC_READONLY | SEC_CODE);
3481       if (s == NULL
3482           || !bfd_set_section_alignment (dynobj, s, bed->plt_alignment))
3483         return FALSE;
3484       htab->root.iplt = s;
3485     }
3486
3487   if (htab->root.irelplt == NULL)
3488     {
3489       s = bfd_make_section_anyway_with_flags (dynobj,
3490                                               RELOC_SECTION (htab, ".iplt"),
3491                                               flags | SEC_READONLY);
3492       if (s == NULL
3493           || !bfd_set_section_alignment (dynobj, s, bed->s->log_file_align))
3494         return FALSE;
3495       htab->root.irelplt = s;
3496     }
3497
3498   if (htab->root.igotplt == NULL)
3499     {
3500       s = bfd_make_section_anyway_with_flags (dynobj, ".igot.plt", flags);
3501       if (s == NULL
3502           || !bfd_set_section_alignment (dynobj, s, bed->s->log_file_align))
3503         return FALSE;
3504       htab->root.igotplt = s;
3505     }
3506   return TRUE;
3507 }
3508
3509 /* Determine if we're dealing with a Thumb only architecture.  */
3510
3511 static bfd_boolean
3512 using_thumb_only (struct elf32_arm_link_hash_table *globals)
3513 {
3514   int arch;
3515   int profile = bfd_elf_get_obj_attr_int (globals->obfd, OBJ_ATTR_PROC,
3516                                           Tag_CPU_arch_profile);
3517
3518   if (profile)
3519     return profile == 'M';
3520
3521   arch = bfd_elf_get_obj_attr_int (globals->obfd, OBJ_ATTR_PROC, Tag_CPU_arch);
3522
3523   /* Force return logic to be reviewed for each new architecture.  */
3524   BFD_ASSERT (arch <= TAG_CPU_ARCH_V8
3525               || arch == TAG_CPU_ARCH_V8M_BASE
3526               || arch == TAG_CPU_ARCH_V8M_MAIN);
3527
3528   if (arch == TAG_CPU_ARCH_V6_M
3529       || arch == TAG_CPU_ARCH_V6S_M
3530       || arch == TAG_CPU_ARCH_V7E_M
3531       || arch == TAG_CPU_ARCH_V8M_BASE
3532       || arch == TAG_CPU_ARCH_V8M_MAIN)
3533     return TRUE;
3534
3535   return FALSE;
3536 }
3537
3538 /* Determine if we're dealing with a Thumb-2 object.  */
3539
3540 static bfd_boolean
3541 using_thumb2 (struct elf32_arm_link_hash_table *globals)
3542 {
3543   int arch;
3544   int thumb_isa = bfd_elf_get_obj_attr_int (globals->obfd, OBJ_ATTR_PROC,
3545                                             Tag_THUMB_ISA_use);
3546
3547   if (thumb_isa)
3548     return thumb_isa == 2;
3549
3550   arch = bfd_elf_get_obj_attr_int (globals->obfd, OBJ_ATTR_PROC, Tag_CPU_arch);
3551
3552   /* Force return logic to be reviewed for each new architecture.  */
3553   BFD_ASSERT (arch <= TAG_CPU_ARCH_V8
3554               || arch == TAG_CPU_ARCH_V8M_BASE
3555               || arch == TAG_CPU_ARCH_V8M_MAIN);
3556
3557   return (arch == TAG_CPU_ARCH_V6T2
3558           || arch == TAG_CPU_ARCH_V7
3559           || arch == TAG_CPU_ARCH_V7E_M
3560           || arch == TAG_CPU_ARCH_V8
3561           || arch == TAG_CPU_ARCH_V8M_MAIN);
3562 }
3563
3564 /* Create .plt, .rel(a).plt, .got, .got.plt, .rel(a).got, .dynbss, and
3565    .rel(a).bss sections in DYNOBJ, and set up shortcuts to them in our
3566    hash table.  */
3567
3568 static bfd_boolean
3569 elf32_arm_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
3570 {
3571   struct elf32_arm_link_hash_table *htab;
3572
3573   htab = elf32_arm_hash_table (info);
3574   if (htab == NULL)
3575     return FALSE;
3576
3577   if (!htab->root.sgot && !create_got_section (dynobj, info))
3578     return FALSE;
3579
3580   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
3581     return FALSE;
3582
3583   htab->sdynbss = bfd_get_linker_section (dynobj, ".dynbss");
3584   if (!bfd_link_pic (info))
3585     htab->srelbss = bfd_get_linker_section (dynobj,
3586                                             RELOC_SECTION (htab, ".bss"));
3587
3588   if (htab->vxworks_p)
3589     {
3590       if (!elf_vxworks_create_dynamic_sections (dynobj, info, &htab->srelplt2))
3591         return FALSE;
3592
3593       if (bfd_link_pic (info))
3594         {
3595           htab->plt_header_size = 0;
3596           htab->plt_entry_size
3597             = 4 * ARRAY_SIZE (elf32_arm_vxworks_shared_plt_entry);
3598         }
3599       else
3600         {
3601           htab->plt_header_size
3602             = 4 * ARRAY_SIZE (elf32_arm_vxworks_exec_plt0_entry);
3603           htab->plt_entry_size
3604             = 4 * ARRAY_SIZE (elf32_arm_vxworks_exec_plt_entry);
3605         }
3606
3607       if (elf_elfheader (dynobj))
3608         elf_elfheader (dynobj)->e_ident[EI_CLASS] = ELFCLASS32;
3609     }
3610   else
3611     {
3612       /* PR ld/16017
3613          Test for thumb only architectures.  Note - we cannot just call
3614          using_thumb_only() as the attributes in the output bfd have not been
3615          initialised at this point, so instead we use the input bfd.  */
3616       bfd * saved_obfd = htab->obfd;
3617
3618       htab->obfd = dynobj;
3619       if (using_thumb_only (htab))
3620         {
3621           htab->plt_header_size = 4 * ARRAY_SIZE (elf32_thumb2_plt0_entry);
3622           htab->plt_entry_size  = 4 * ARRAY_SIZE (elf32_thumb2_plt_entry);
3623         }
3624       htab->obfd = saved_obfd;
3625     }
3626
3627   if (!htab->root.splt
3628       || !htab->root.srelplt
3629       || !htab->sdynbss
3630       || (!bfd_link_pic (info) && !htab->srelbss))
3631     abort ();
3632
3633   return TRUE;
3634 }
3635
3636 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
3637
3638 static void
3639 elf32_arm_copy_indirect_symbol (struct bfd_link_info *info,
3640                                 struct elf_link_hash_entry *dir,
3641                                 struct elf_link_hash_entry *ind)
3642 {
3643   struct elf32_arm_link_hash_entry *edir, *eind;
3644
3645   edir = (struct elf32_arm_link_hash_entry *) dir;
3646   eind = (struct elf32_arm_link_hash_entry *) ind;
3647
3648   if (eind->dyn_relocs != NULL)
3649     {
3650       if (edir->dyn_relocs != NULL)
3651         {
3652           struct elf_dyn_relocs **pp;
3653           struct elf_dyn_relocs *p;
3654
3655           /* Add reloc counts against the indirect sym to the direct sym
3656              list.  Merge any entries against the same section.  */
3657           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
3658             {
3659               struct elf_dyn_relocs *q;
3660
3661               for (q = edir->dyn_relocs; q != NULL; q = q->next)
3662                 if (q->sec == p->sec)
3663                   {
3664                     q->pc_count += p->pc_count;
3665                     q->count += p->count;
3666                     *pp = p->next;
3667                     break;
3668                   }
3669               if (q == NULL)
3670                 pp = &p->next;
3671             }
3672           *pp = edir->dyn_relocs;
3673         }
3674
3675       edir->dyn_relocs = eind->dyn_relocs;
3676       eind->dyn_relocs = NULL;
3677     }
3678
3679   if (ind->root.type == bfd_link_hash_indirect)
3680     {
3681       /* Copy over PLT info.  */
3682       edir->plt.thumb_refcount += eind->plt.thumb_refcount;
3683       eind->plt.thumb_refcount = 0;
3684       edir->plt.maybe_thumb_refcount += eind->plt.maybe_thumb_refcount;
3685       eind->plt.maybe_thumb_refcount = 0;
3686       edir->plt.noncall_refcount += eind->plt.noncall_refcount;
3687       eind->plt.noncall_refcount = 0;
3688
3689       /* We should only allocate a function to .iplt once the final
3690          symbol information is known.  */
3691       BFD_ASSERT (!eind->is_iplt);
3692
3693       if (dir->got.refcount <= 0)
3694         {
3695           edir->tls_type = eind->tls_type;
3696           eind->tls_type = GOT_UNKNOWN;
3697         }
3698     }
3699
3700   _bfd_elf_link_hash_copy_indirect (info, dir, ind);
3701 }
3702
3703 /* Destroy an ARM elf linker hash table.  */
3704
3705 static void
3706 elf32_arm_link_hash_table_free (bfd *obfd)
3707 {
3708   struct elf32_arm_link_hash_table *ret
3709     = (struct elf32_arm_link_hash_table *) obfd->link.hash;
3710
3711   bfd_hash_table_free (&ret->stub_hash_table);
3712   _bfd_elf_link_hash_table_free (obfd);
3713 }
3714
3715 /* Create an ARM elf linker hash table.  */
3716
3717 static struct bfd_link_hash_table *
3718 elf32_arm_link_hash_table_create (bfd *abfd)
3719 {
3720   struct elf32_arm_link_hash_table *ret;
3721   bfd_size_type amt = sizeof (struct elf32_arm_link_hash_table);
3722
3723   ret = (struct elf32_arm_link_hash_table *) bfd_zmalloc (amt);
3724   if (ret == NULL)
3725     return NULL;
3726
3727   if (!_bfd_elf_link_hash_table_init (& ret->root, abfd,
3728                                       elf32_arm_link_hash_newfunc,
3729                                       sizeof (struct elf32_arm_link_hash_entry),
3730                                       ARM_ELF_DATA))
3731     {
3732       free (ret);
3733       return NULL;
3734     }
3735
3736   ret->vfp11_fix = BFD_ARM_VFP11_FIX_NONE;
3737   ret->stm32l4xx_fix = BFD_ARM_STM32L4XX_FIX_NONE;
3738 #ifdef FOUR_WORD_PLT
3739   ret->plt_header_size = 16;
3740   ret->plt_entry_size = 16;
3741 #else
3742   ret->plt_header_size = 20;
3743   ret->plt_entry_size = elf32_arm_use_long_plt_entry ? 16 : 12;
3744 #endif
3745   ret->use_rel = 1;
3746   ret->obfd = abfd;
3747
3748   if (!bfd_hash_table_init (&ret->stub_hash_table, stub_hash_newfunc,
3749                             sizeof (struct elf32_arm_stub_hash_entry)))
3750     {
3751       _bfd_elf_link_hash_table_free (abfd);
3752       return NULL;
3753     }
3754   ret->root.root.hash_table_free = elf32_arm_link_hash_table_free;
3755
3756   return &ret->root.root;
3757 }
3758
3759 /* Determine what kind of NOPs are available.  */
3760
3761 static bfd_boolean
3762 arch_has_arm_nop (struct elf32_arm_link_hash_table *globals)
3763 {
3764   const int arch = bfd_elf_get_obj_attr_int (globals->obfd, OBJ_ATTR_PROC,
3765                                              Tag_CPU_arch);
3766
3767   /* Force return logic to be reviewed for each new architecture.  */
3768   BFD_ASSERT (arch <= TAG_CPU_ARCH_V8
3769               || arch == TAG_CPU_ARCH_V8M_BASE
3770               || arch == TAG_CPU_ARCH_V8M_MAIN);
3771
3772   return (arch == TAG_CPU_ARCH_V6T2
3773           || arch == TAG_CPU_ARCH_V6K
3774           || arch == TAG_CPU_ARCH_V7
3775           || arch == TAG_CPU_ARCH_V8);
3776 }
3777
3778 static bfd_boolean
3779 arm_stub_is_thumb (enum elf32_arm_stub_type stub_type)
3780 {
3781   switch (stub_type)
3782     {
3783     case arm_stub_long_branch_thumb_only:
3784     case arm_stub_long_branch_v4t_thumb_arm:
3785     case arm_stub_short_branch_v4t_thumb_arm:
3786     case arm_stub_long_branch_v4t_thumb_arm_pic:
3787     case arm_stub_long_branch_v4t_thumb_tls_pic:
3788     case arm_stub_long_branch_thumb_only_pic:
3789       return TRUE;
3790     case arm_stub_none:
3791       BFD_FAIL ();
3792       return FALSE;
3793       break;
3794     default:
3795       return FALSE;
3796     }
3797 }
3798
3799 /* Determine the type of stub needed, if any, for a call.  */
3800
3801 static enum elf32_arm_stub_type
3802 arm_type_of_stub (struct bfd_link_info *info,
3803                   asection *input_sec,
3804                   const Elf_Internal_Rela *rel,
3805                   unsigned char st_type,
3806                   enum arm_st_branch_type *actual_branch_type,
3807                   struct elf32_arm_link_hash_entry *hash,
3808                   bfd_vma destination,
3809                   asection *sym_sec,
3810                   bfd *input_bfd,
3811                   const char *name)
3812 {
3813   bfd_vma location;
3814   bfd_signed_vma branch_offset;
3815   unsigned int r_type;
3816   struct elf32_arm_link_hash_table * globals;
3817   int thumb2;
3818   int thumb_only;
3819   enum elf32_arm_stub_type stub_type = arm_stub_none;
3820   int use_plt = 0;
3821   enum arm_st_branch_type branch_type = *actual_branch_type;
3822   union gotplt_union *root_plt;
3823   struct arm_plt_info *arm_plt;
3824
3825   if (branch_type == ST_BRANCH_LONG)
3826     return stub_type;
3827
3828   globals = elf32_arm_hash_table (info);
3829   if (globals == NULL)
3830     return stub_type;
3831
3832   thumb_only = using_thumb_only (globals);
3833
3834   thumb2 = using_thumb2 (globals);
3835
3836   /* Determine where the call point is.  */
3837   location = (input_sec->output_offset
3838               + input_sec->output_section->vma
3839               + rel->r_offset);
3840
3841   r_type = ELF32_R_TYPE (rel->r_info);
3842
3843   /* ST_BRANCH_TO_ARM is nonsense to thumb-only targets when we
3844      are considering a function call relocation.  */
3845   if (thumb_only && (r_type == R_ARM_THM_CALL || r_type == R_ARM_THM_JUMP24
3846                      || r_type == R_ARM_THM_JUMP19)
3847       && branch_type == ST_BRANCH_TO_ARM)
3848     branch_type = ST_BRANCH_TO_THUMB;
3849
3850   /* For TLS call relocs, it is the caller's responsibility to provide
3851      the address of the appropriate trampoline.  */
3852   if (r_type != R_ARM_TLS_CALL
3853       && r_type != R_ARM_THM_TLS_CALL
3854       && elf32_arm_get_plt_info (input_bfd, hash, ELF32_R_SYM (rel->r_info),
3855                                  &root_plt, &arm_plt)
3856       && root_plt->offset != (bfd_vma) -1)
3857     {
3858       asection *splt;
3859
3860       if (hash == NULL || hash->is_iplt)
3861         splt = globals->root.iplt;
3862       else
3863         splt = globals->root.splt;
3864       if (splt != NULL)
3865         {
3866           use_plt = 1;
3867
3868           /* Note when dealing with PLT entries: the main PLT stub is in
3869              ARM mode, so if the branch is in Thumb mode, another
3870              Thumb->ARM stub will be inserted later just before the ARM
3871              PLT stub. We don't take this extra distance into account
3872              here, because if a long branch stub is needed, we'll add a
3873              Thumb->Arm one and branch directly to the ARM PLT entry
3874              because it avoids spreading offset corrections in several
3875              places.  */
3876
3877           destination = (splt->output_section->vma
3878                          + splt->output_offset
3879                          + root_plt->offset);
3880           st_type = STT_FUNC;
3881           branch_type = ST_BRANCH_TO_ARM;
3882         }
3883     }
3884   /* Calls to STT_GNU_IFUNC symbols should go through a PLT.  */
3885   BFD_ASSERT (st_type != STT_GNU_IFUNC);
3886
3887   branch_offset = (bfd_signed_vma)(destination - location);
3888
3889   if (r_type == R_ARM_THM_CALL || r_type == R_ARM_THM_JUMP24
3890       || r_type == R_ARM_THM_TLS_CALL || r_type == R_ARM_THM_JUMP19)
3891     {
3892       /* Handle cases where:
3893          - this call goes too far (different Thumb/Thumb2 max
3894            distance)
3895          - it's a Thumb->Arm call and blx is not available, or it's a
3896            Thumb->Arm branch (not bl). A stub is needed in this case,
3897            but only if this call is not through a PLT entry. Indeed,
3898            PLT stubs handle mode switching already.
3899       */
3900       if ((!thumb2
3901             && (branch_offset > THM_MAX_FWD_BRANCH_OFFSET
3902                 || (branch_offset < THM_MAX_BWD_BRANCH_OFFSET)))
3903           || (thumb2
3904               && (branch_offset > THM2_MAX_FWD_BRANCH_OFFSET
3905                   || (branch_offset < THM2_MAX_BWD_BRANCH_OFFSET)))
3906           || (thumb2
3907               && (branch_offset > THM2_MAX_FWD_COND_BRANCH_OFFSET
3908                   || (branch_offset < THM2_MAX_BWD_COND_BRANCH_OFFSET))
3909               && (r_type == R_ARM_THM_JUMP19))
3910           || (branch_type == ST_BRANCH_TO_ARM
3911               && (((r_type == R_ARM_THM_CALL
3912                     || r_type == R_ARM_THM_TLS_CALL) && !globals->use_blx)
3913                   || (r_type == R_ARM_THM_JUMP24)
3914                   || (r_type == R_ARM_THM_JUMP19))
3915               && !use_plt))
3916         {
3917           if (branch_type == ST_BRANCH_TO_THUMB)
3918             {
3919               /* Thumb to thumb.  */
3920               if (!thumb_only)
3921                 {
3922                   stub_type = (bfd_link_pic (info) | globals->pic_veneer)
3923                     /* PIC stubs.  */
3924                     ? ((globals->use_blx
3925                         && (r_type == R_ARM_THM_CALL))
3926                        /* V5T and above. Stub starts with ARM code, so
3927                           we must be able to switch mode before
3928                           reaching it, which is only possible for 'bl'
3929                           (ie R_ARM_THM_CALL relocation).  */
3930                        ? arm_stub_long_branch_any_thumb_pic
3931                        /* On V4T, use Thumb code only.  */
3932                        : arm_stub_long_branch_v4t_thumb_thumb_pic)
3933
3934                     /* non-PIC stubs.  */
3935                     : ((globals->use_blx
3936                         && (r_type == R_ARM_THM_CALL))
3937                        /* V5T and above.  */
3938                        ? arm_stub_long_branch_any_any
3939                        /* V4T.  */
3940                        : arm_stub_long_branch_v4t_thumb_thumb);
3941                 }
3942               else
3943                 {
3944                   stub_type = (bfd_link_pic (info) | globals->pic_veneer)
3945                     /* PIC stub.  */
3946                     ? arm_stub_long_branch_thumb_only_pic
3947                     /* non-PIC stub.  */
3948                     : arm_stub_long_branch_thumb_only;
3949                 }
3950             }
3951           else
3952             {
3953               /* Thumb to arm.  */
3954               if (sym_sec != NULL
3955                   && sym_sec->owner != NULL
3956                   && !INTERWORK_FLAG (sym_sec->owner))
3957                 {
3958                   (*_bfd_error_handler)
3959                     (_("%B(%s): warning: interworking not enabled.\n"
3960                        "  first occurrence: %B: Thumb call to ARM"),
3961                      sym_sec->owner, input_bfd, name);
3962                 }
3963
3964               stub_type =
3965                 (bfd_link_pic (info) | globals->pic_veneer)
3966                 /* PIC stubs.  */
3967                 ? (r_type == R_ARM_THM_TLS_CALL
3968                    /* TLS PIC stubs.  */
3969                    ? (globals->use_blx ? arm_stub_long_branch_any_tls_pic
3970                       : arm_stub_long_branch_v4t_thumb_tls_pic)
3971                    : ((globals->use_blx && r_type == R_ARM_THM_CALL)
3972                       /* V5T PIC and above.  */
3973                       ? arm_stub_long_branch_any_arm_pic
3974                       /* V4T PIC stub.  */
3975                       : arm_stub_long_branch_v4t_thumb_arm_pic))
3976
3977                 /* non-PIC stubs.  */
3978                 : ((globals->use_blx && r_type == R_ARM_THM_CALL)
3979                    /* V5T and above.  */
3980                    ? arm_stub_long_branch_any_any
3981                    /* V4T.  */
3982                    : arm_stub_long_branch_v4t_thumb_arm);
3983
3984               /* Handle v4t short branches.  */
3985               if ((stub_type == arm_stub_long_branch_v4t_thumb_arm)
3986                   && (branch_offset <= THM_MAX_FWD_BRANCH_OFFSET)
3987                   && (branch_offset >= THM_MAX_BWD_BRANCH_OFFSET))
3988                 stub_type = arm_stub_short_branch_v4t_thumb_arm;
3989             }
3990         }
3991     }
3992   else if (r_type == R_ARM_CALL
3993            || r_type == R_ARM_JUMP24
3994            || r_type == R_ARM_PLT32
3995            || r_type == R_ARM_TLS_CALL)
3996     {
3997       if (branch_type == ST_BRANCH_TO_THUMB)
3998         {
3999           /* Arm to thumb.  */
4000
4001           if (sym_sec != NULL
4002               && sym_sec->owner != NULL
4003               && !INTERWORK_FLAG (sym_sec->owner))
4004             {
4005               (*_bfd_error_handler)
4006                 (_("%B(%s): warning: interworking not enabled.\n"
4007                    "  first occurrence: %B: ARM call to Thumb"),
4008                  sym_sec->owner, input_bfd, name);
4009             }
4010
4011           /* We have an extra 2-bytes reach because of
4012              the mode change (bit 24 (H) of BLX encoding).  */
4013           if (branch_offset > (ARM_MAX_FWD_BRANCH_OFFSET + 2)
4014               || (branch_offset < ARM_MAX_BWD_BRANCH_OFFSET)
4015               || (r_type == R_ARM_CALL && !globals->use_blx)
4016               || (r_type == R_ARM_JUMP24)
4017               || (r_type == R_ARM_PLT32))
4018             {
4019               stub_type = (bfd_link_pic (info) | globals->pic_veneer)
4020                 /* PIC stubs.  */
4021                 ? ((globals->use_blx)
4022                    /* V5T and above.  */
4023                    ? arm_stub_long_branch_any_thumb_pic
4024                    /* V4T stub.  */
4025                    : arm_stub_long_branch_v4t_arm_thumb_pic)
4026
4027                 /* non-PIC stubs.  */
4028                 : ((globals->use_blx)
4029                    /* V5T and above.  */
4030                    ? arm_stub_long_branch_any_any
4031                    /* V4T.  */
4032                    : arm_stub_long_branch_v4t_arm_thumb);
4033             }
4034         }
4035       else
4036         {
4037           /* Arm to arm.  */
4038           if (branch_offset > ARM_MAX_FWD_BRANCH_OFFSET
4039               || (branch_offset < ARM_MAX_BWD_BRANCH_OFFSET))
4040             {
4041               stub_type =
4042                 (bfd_link_pic (info) | globals->pic_veneer)
4043                 /* PIC stubs.  */
4044                 ? (r_type == R_ARM_TLS_CALL
4045                    /* TLS PIC Stub.  */
4046                    ? arm_stub_long_branch_any_tls_pic
4047                    : (globals->nacl_p
4048                       ? arm_stub_long_branch_arm_nacl_pic
4049                       : arm_stub_long_branch_any_arm_pic))
4050                 /* non-PIC stubs.  */
4051                 : (globals->nacl_p
4052                    ? arm_stub_long_branch_arm_nacl
4053                    : arm_stub_long_branch_any_any);
4054             }
4055         }
4056     }
4057
4058   /* If a stub is needed, record the actual destination type.  */
4059   if (stub_type != arm_stub_none)
4060     *actual_branch_type = branch_type;
4061
4062   return stub_type;
4063 }
4064
4065 /* Build a name for an entry in the stub hash table.  */
4066
4067 static char *
4068 elf32_arm_stub_name (const asection *input_section,
4069                      const asection *sym_sec,
4070                      const struct elf32_arm_link_hash_entry *hash,
4071                      const Elf_Internal_Rela *rel,
4072                      enum elf32_arm_stub_type stub_type)
4073 {
4074   char *stub_name;
4075   bfd_size_type len;
4076
4077   if (hash)
4078     {
4079       len = 8 + 1 + strlen (hash->root.root.root.string) + 1 + 8 + 1 + 2 + 1;
4080       stub_name = (char *) bfd_malloc (len);
4081       if (stub_name != NULL)
4082         sprintf (stub_name, "%08x_%s+%x_%d",
4083                  input_section->id & 0xffffffff,
4084                  hash->root.root.root.string,
4085                  (int) rel->r_addend & 0xffffffff,
4086                  (int) stub_type);
4087     }
4088   else
4089     {
4090       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1 + 2 + 1;
4091       stub_name = (char *) bfd_malloc (len);
4092       if (stub_name != NULL)
4093         sprintf (stub_name, "%08x_%x:%x+%x_%d",
4094                  input_section->id & 0xffffffff,
4095                  sym_sec->id & 0xffffffff,
4096                  ELF32_R_TYPE (rel->r_info) == R_ARM_TLS_CALL
4097                  || ELF32_R_TYPE (rel->r_info) == R_ARM_THM_TLS_CALL
4098                  ? 0 : (int) ELF32_R_SYM (rel->r_info) & 0xffffffff,
4099                  (int) rel->r_addend & 0xffffffff,
4100                  (int) stub_type);
4101     }
4102
4103   return stub_name;
4104 }
4105
4106 /* Look up an entry in the stub hash.  Stub entries are cached because
4107    creating the stub name takes a bit of time.  */
4108
4109 static struct elf32_arm_stub_hash_entry *
4110 elf32_arm_get_stub_entry (const asection *input_section,
4111                           const asection *sym_sec,
4112                           struct elf_link_hash_entry *hash,
4113                           const Elf_Internal_Rela *rel,
4114                           struct elf32_arm_link_hash_table *htab,
4115                           enum elf32_arm_stub_type stub_type)
4116 {
4117   struct elf32_arm_stub_hash_entry *stub_entry;
4118   struct elf32_arm_link_hash_entry *h = (struct elf32_arm_link_hash_entry *) hash;
4119   const asection *id_sec;
4120
4121   if ((input_section->flags & SEC_CODE) == 0)
4122     return NULL;
4123
4124   /* If this input section is part of a group of sections sharing one
4125      stub section, then use the id of the first section in the group.
4126      Stub names need to include a section id, as there may well be
4127      more than one stub used to reach say, printf, and we need to
4128      distinguish between them.  */
4129   id_sec = htab->stub_group[input_section->id].link_sec;
4130
4131   if (h != NULL && h->stub_cache != NULL
4132       && h->stub_cache->h == h
4133       && h->stub_cache->id_sec == id_sec
4134       && h->stub_cache->stub_type == stub_type)
4135     {
4136       stub_entry = h->stub_cache;
4137     }
4138   else
4139     {
4140       char *stub_name;
4141
4142       stub_name = elf32_arm_stub_name (id_sec, sym_sec, h, rel, stub_type);
4143       if (stub_name == NULL)
4144         return NULL;
4145
4146       stub_entry = arm_stub_hash_lookup (&htab->stub_hash_table,
4147                                         stub_name, FALSE, FALSE);
4148       if (h != NULL)
4149         h->stub_cache = stub_entry;
4150
4151       free (stub_name);
4152     }
4153
4154   return stub_entry;
4155 }
4156
4157 /* Whether veneers of type STUB_TYPE require to be in a dedicated output
4158    section.  */
4159
4160 static bfd_boolean
4161 arm_dedicated_stub_output_section_required (enum elf32_arm_stub_type stub_type)
4162 {
4163   if (stub_type >= max_stub_type)
4164     abort ();  /* Should be unreachable.  */
4165
4166   return FALSE;
4167 }
4168
4169 /* Required alignment (as a power of 2) for the dedicated section holding
4170    veneers of type STUB_TYPE, or 0 if veneers of this type are interspersed
4171    with input sections.  */
4172
4173 static int
4174 arm_dedicated_stub_output_section_required_alignment
4175   (enum elf32_arm_stub_type stub_type)
4176 {
4177   if (stub_type >= max_stub_type)
4178     abort ();  /* Should be unreachable.  */
4179
4180   BFD_ASSERT (!arm_dedicated_stub_output_section_required (stub_type));
4181   return 0;
4182 }
4183
4184 /* Name of the dedicated output section to put veneers of type STUB_TYPE, or
4185    NULL if veneers of this type are interspersed with input sections.  */
4186
4187 static const char *
4188 arm_dedicated_stub_output_section_name (enum elf32_arm_stub_type stub_type)
4189 {
4190   if (stub_type >= max_stub_type)
4191     abort ();  /* Should be unreachable.  */
4192
4193   BFD_ASSERT (!arm_dedicated_stub_output_section_required (stub_type));
4194   return NULL;
4195 }
4196
4197 /* If veneers of type STUB_TYPE should go in a dedicated output section,
4198    returns the address of the hash table field in HTAB holding a pointer to the
4199    corresponding input section.  Otherwise, returns NULL.  */
4200
4201 static asection **
4202 arm_dedicated_stub_input_section_ptr
4203   (struct elf32_arm_link_hash_table *htab ATTRIBUTE_UNUSED,
4204    enum elf32_arm_stub_type stub_type)
4205 {
4206   if (stub_type >= max_stub_type)
4207     abort ();  /* Should be unreachable.  */
4208
4209   BFD_ASSERT (!arm_dedicated_stub_output_section_required (stub_type));
4210   return NULL;
4211 }
4212
4213 /* Find or create a stub section to contain a stub of type STUB_TYPE.  SECTION
4214    is the section that branch into veneer and can be NULL if stub should go in
4215    a dedicated output section.  Returns a pointer to the stub section, and the
4216    section to which the stub section will be attached (in *LINK_SEC_P).
4217    LINK_SEC_P may be NULL.  */
4218
4219 static asection *
4220 elf32_arm_create_or_find_stub_sec (asection **link_sec_p, asection *section,
4221                                    struct elf32_arm_link_hash_table *htab,
4222                                    enum elf32_arm_stub_type stub_type)
4223 {
4224   asection *link_sec, *out_sec, **stub_sec_p;
4225   const char *stub_sec_prefix;
4226   bfd_boolean dedicated_output_section =
4227     arm_dedicated_stub_output_section_required (stub_type);
4228   int align;
4229
4230   if (dedicated_output_section)
4231     {
4232       bfd *output_bfd = htab->obfd;
4233       const char *out_sec_name =
4234         arm_dedicated_stub_output_section_name (stub_type);
4235       link_sec = NULL;
4236       stub_sec_p = arm_dedicated_stub_input_section_ptr (htab, stub_type);
4237       stub_sec_prefix = out_sec_name;
4238       align = arm_dedicated_stub_output_section_required_alignment (stub_type);
4239       out_sec = bfd_get_section_by_name (output_bfd, out_sec_name);
4240       if (out_sec == NULL)
4241         {
4242           (*_bfd_error_handler) (_("No address assigned to the veneers output "
4243                                    "section %s"), out_sec_name);
4244           return NULL;
4245         }
4246     }
4247   else
4248     {
4249       link_sec = htab->stub_group[section->id].link_sec;
4250       BFD_ASSERT (link_sec != NULL);
4251       stub_sec_p = &htab->stub_group[section->id].stub_sec;
4252       if (*stub_sec_p == NULL)
4253         stub_sec_p = &htab->stub_group[link_sec->id].stub_sec;
4254       stub_sec_prefix = link_sec->name;
4255       out_sec = link_sec->output_section;
4256       align = htab->nacl_p ? 4 : 3;
4257     }
4258
4259   if (*stub_sec_p == NULL)
4260     {
4261       size_t namelen;
4262       bfd_size_type len;
4263       char *s_name;
4264
4265       namelen = strlen (stub_sec_prefix);
4266       len = namelen + sizeof (STUB_SUFFIX);
4267       s_name = (char *) bfd_alloc (htab->stub_bfd, len);
4268       if (s_name == NULL)
4269         return NULL;
4270
4271       memcpy (s_name, stub_sec_prefix, namelen);
4272       memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
4273       *stub_sec_p = (*htab->add_stub_section) (s_name, out_sec, link_sec,
4274                                                align);
4275       if (*stub_sec_p == NULL)
4276         return NULL;
4277
4278       out_sec->flags |= SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE
4279                         | SEC_HAS_CONTENTS | SEC_RELOC | SEC_IN_MEMORY
4280                         | SEC_KEEP;
4281     }
4282
4283   if (!dedicated_output_section)
4284     htab->stub_group[section->id].stub_sec = *stub_sec_p;
4285
4286   if (link_sec_p)
4287     *link_sec_p = link_sec;
4288
4289   return *stub_sec_p;
4290 }
4291
4292 /* Add a new stub entry to the stub hash.  Not all fields of the new
4293    stub entry are initialised.  */
4294
4295 static struct elf32_arm_stub_hash_entry *
4296 elf32_arm_add_stub (const char *stub_name, asection *section,
4297                     struct elf32_arm_link_hash_table *htab,
4298                     enum elf32_arm_stub_type stub_type)
4299 {
4300   asection *link_sec;
4301   asection *stub_sec;
4302   struct elf32_arm_stub_hash_entry *stub_entry;
4303
4304   stub_sec = elf32_arm_create_or_find_stub_sec (&link_sec, section, htab,
4305                                                 stub_type);
4306   if (stub_sec == NULL)
4307     return NULL;
4308
4309   /* Enter this entry into the linker stub hash table.  */
4310   stub_entry = arm_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4311                                      TRUE, FALSE);
4312   if (stub_entry == NULL)
4313     {
4314       if (section == NULL)
4315         section = stub_sec;
4316       (*_bfd_error_handler) (_("%s: cannot create stub entry %s"),
4317                              section->owner,
4318                              stub_name);
4319       return NULL;
4320     }
4321
4322   stub_entry->stub_sec = stub_sec;
4323   stub_entry->stub_offset = 0;
4324   stub_entry->id_sec = link_sec;
4325
4326   return stub_entry;
4327 }
4328
4329 /* Store an Arm insn into an output section not processed by
4330    elf32_arm_write_section.  */
4331
4332 static void
4333 put_arm_insn (struct elf32_arm_link_hash_table * htab,
4334               bfd * output_bfd, bfd_vma val, void * ptr)
4335 {
4336   if (htab->byteswap_code != bfd_little_endian (output_bfd))
4337     bfd_putl32 (val, ptr);
4338   else
4339     bfd_putb32 (val, ptr);
4340 }
4341
4342 /* Store a 16-bit Thumb insn into an output section not processed by
4343    elf32_arm_write_section.  */
4344
4345 static void
4346 put_thumb_insn (struct elf32_arm_link_hash_table * htab,
4347                 bfd * output_bfd, bfd_vma val, void * ptr)
4348 {
4349   if (htab->byteswap_code != bfd_little_endian (output_bfd))
4350     bfd_putl16 (val, ptr);
4351   else
4352     bfd_putb16 (val, ptr);
4353 }
4354
4355 /* Store a Thumb2 insn into an output section not processed by
4356    elf32_arm_write_section.  */
4357
4358 static void
4359 put_thumb2_insn (struct elf32_arm_link_hash_table * htab,
4360                  bfd * output_bfd, bfd_vma val, bfd_byte * ptr)
4361 {
4362   /* T2 instructions are 16-bit streamed.  */
4363   if (htab->byteswap_code != bfd_little_endian (output_bfd))
4364     {
4365       bfd_putl16 ((val >> 16) & 0xffff, ptr);
4366       bfd_putl16 ((val & 0xffff), ptr + 2);
4367     }
4368   else
4369     {
4370       bfd_putb16 ((val >> 16) & 0xffff, ptr);
4371       bfd_putb16 ((val & 0xffff), ptr + 2);
4372     }
4373 }
4374
4375 /* If it's possible to change R_TYPE to a more efficient access
4376    model, return the new reloc type.  */
4377
4378 static unsigned
4379 elf32_arm_tls_transition (struct bfd_link_info *info, int r_type,
4380                           struct elf_link_hash_entry *h)
4381 {
4382   int is_local = (h == NULL);
4383
4384   if (bfd_link_pic (info)
4385       || (h && h->root.type == bfd_link_hash_undefweak))
4386     return r_type;
4387
4388   /* We do not support relaxations for Old TLS models.  */
4389   switch (r_type)
4390     {
4391     case R_ARM_TLS_GOTDESC:
4392     case R_ARM_TLS_CALL:
4393     case R_ARM_THM_TLS_CALL:
4394     case R_ARM_TLS_DESCSEQ:
4395     case R_ARM_THM_TLS_DESCSEQ:
4396       return is_local ? R_ARM_TLS_LE32 : R_ARM_TLS_IE32;
4397     }
4398
4399   return r_type;
4400 }
4401
4402 static bfd_reloc_status_type elf32_arm_final_link_relocate
4403   (reloc_howto_type *, bfd *, bfd *, asection *, bfd_byte *,
4404    Elf_Internal_Rela *, bfd_vma, struct bfd_link_info *, asection *,
4405    const char *, unsigned char, enum arm_st_branch_type,
4406    struct elf_link_hash_entry *, bfd_boolean *, char **);
4407
4408 static unsigned int
4409 arm_stub_required_alignment (enum elf32_arm_stub_type stub_type)
4410 {
4411   switch (stub_type)
4412     {
4413     case arm_stub_a8_veneer_b_cond:
4414     case arm_stub_a8_veneer_b:
4415     case arm_stub_a8_veneer_bl:
4416       return 2;
4417
4418     case arm_stub_long_branch_any_any:
4419     case arm_stub_long_branch_v4t_arm_thumb:
4420     case arm_stub_long_branch_thumb_only:
4421     case arm_stub_long_branch_v4t_thumb_thumb:
4422     case arm_stub_long_branch_v4t_thumb_arm:
4423     case arm_stub_short_branch_v4t_thumb_arm:
4424     case arm_stub_long_branch_any_arm_pic:
4425     case arm_stub_long_branch_any_thumb_pic:
4426     case arm_stub_long_branch_v4t_thumb_thumb_pic:
4427     case arm_stub_long_branch_v4t_arm_thumb_pic:
4428     case arm_stub_long_branch_v4t_thumb_arm_pic:
4429     case arm_stub_long_branch_thumb_only_pic:
4430     case arm_stub_long_branch_any_tls_pic:
4431     case arm_stub_long_branch_v4t_thumb_tls_pic:
4432     case arm_stub_a8_veneer_blx:
4433       return 4;
4434
4435     case arm_stub_long_branch_arm_nacl:
4436     case arm_stub_long_branch_arm_nacl_pic:
4437       return 16;
4438
4439     default:
4440       abort ();  /* Should be unreachable.  */
4441     }
4442 }
4443
4444 /* Returns whether stubs of type STUB_TYPE take over the symbol they are
4445    veneering (TRUE) or have their own symbol (FALSE).  */
4446
4447 static bfd_boolean
4448 arm_stub_sym_claimed (enum elf32_arm_stub_type stub_type)
4449 {
4450   if (stub_type >= max_stub_type)
4451     abort ();  /* Should be unreachable.  */
4452
4453   return FALSE;
4454 }
4455
4456 /* Returns the padding needed for the dedicated section used stubs of type
4457    STUB_TYPE.  */
4458
4459 static int
4460 arm_dedicated_stub_section_padding (enum elf32_arm_stub_type stub_type)
4461 {
4462   if (stub_type >= max_stub_type)
4463     abort ();  /* Should be unreachable.  */
4464
4465   return 0;
4466 }
4467
4468 static bfd_boolean
4469 arm_build_one_stub (struct bfd_hash_entry *gen_entry,
4470                     void * in_arg)
4471 {
4472 #define MAXRELOCS 3
4473   struct elf32_arm_stub_hash_entry *stub_entry;
4474   struct elf32_arm_link_hash_table *globals;
4475   struct bfd_link_info *info;
4476   asection *stub_sec;
4477   bfd *stub_bfd;
4478   bfd_byte *loc;
4479   bfd_vma sym_value;
4480   int template_size;
4481   int size;
4482   const insn_sequence *template_sequence;
4483   int i;
4484   int stub_reloc_idx[MAXRELOCS] = {-1, -1};
4485   int stub_reloc_offset[MAXRELOCS] = {0, 0};
4486   int nrelocs = 0;
4487
4488   /* Massage our args to the form they really have.  */
4489   stub_entry = (struct elf32_arm_stub_hash_entry *) gen_entry;
4490   info = (struct bfd_link_info *) in_arg;
4491
4492   globals = elf32_arm_hash_table (info);
4493   if (globals == NULL)
4494     return FALSE;
4495
4496   stub_sec = stub_entry->stub_sec;
4497
4498   if ((globals->fix_cortex_a8 < 0)
4499       != (arm_stub_required_alignment (stub_entry->stub_type) == 2))
4500     /* We have to do less-strictly-aligned fixes last.  */
4501     return TRUE;
4502
4503   /* Make a note of the offset within the stubs for this entry.  */
4504   stub_entry->stub_offset = stub_sec->size;
4505   loc = stub_sec->contents + stub_entry->stub_offset;
4506
4507   stub_bfd = stub_sec->owner;
4508
4509   /* This is the address of the stub destination.  */
4510   sym_value = (stub_entry->target_value
4511                + stub_entry->target_section->output_offset
4512                + stub_entry->target_section->output_section->vma);
4513
4514   template_sequence = stub_entry->stub_template;
4515   template_size = stub_entry->stub_template_size;
4516
4517   size = 0;
4518   for (i = 0; i < template_size; i++)
4519     {
4520       switch (template_sequence[i].type)
4521         {
4522         case THUMB16_TYPE:
4523           {
4524             bfd_vma data = (bfd_vma) template_sequence[i].data;
4525             if (template_sequence[i].reloc_addend != 0)
4526               {
4527                 /* We've borrowed the reloc_addend field to mean we should
4528                    insert a condition code into this (Thumb-1 branch)
4529                    instruction.  See THUMB16_BCOND_INSN.  */
4530                 BFD_ASSERT ((data & 0xff00) == 0xd000);
4531                 data |= ((stub_entry->orig_insn >> 22) & 0xf) << 8;
4532               }
4533             bfd_put_16 (stub_bfd, data, loc + size);
4534             size += 2;
4535           }
4536           break;
4537
4538         case THUMB32_TYPE:
4539           bfd_put_16 (stub_bfd,
4540                       (template_sequence[i].data >> 16) & 0xffff,
4541                       loc + size);
4542           bfd_put_16 (stub_bfd, template_sequence[i].data & 0xffff,
4543                       loc + size + 2);
4544           if (template_sequence[i].r_type != R_ARM_NONE)
4545             {
4546               stub_reloc_idx[nrelocs] = i;
4547               stub_reloc_offset[nrelocs++] = size;
4548             }
4549           size += 4;
4550           break;
4551
4552         case ARM_TYPE:
4553           bfd_put_32 (stub_bfd, template_sequence[i].data,
4554                       loc + size);
4555           /* Handle cases where the target is encoded within the
4556              instruction.  */
4557           if (template_sequence[i].r_type == R_ARM_JUMP24)
4558             {
4559               stub_reloc_idx[nrelocs] = i;
4560               stub_reloc_offset[nrelocs++] = size;
4561             }
4562           size += 4;
4563           break;
4564
4565         case DATA_TYPE:
4566           bfd_put_32 (stub_bfd, template_sequence[i].data, loc + size);
4567           stub_reloc_idx[nrelocs] = i;
4568           stub_reloc_offset[nrelocs++] = size;
4569           size += 4;
4570           break;
4571
4572         default:
4573           BFD_FAIL ();
4574           return FALSE;
4575         }
4576     }
4577
4578   stub_sec->size += size;
4579
4580   /* Stub size has already been computed in arm_size_one_stub. Check
4581      consistency.  */
4582   BFD_ASSERT (size == stub_entry->stub_size);
4583
4584   /* Destination is Thumb. Force bit 0 to 1 to reflect this.  */
4585   if (stub_entry->branch_type == ST_BRANCH_TO_THUMB)
4586     sym_value |= 1;
4587
4588   /* Assume there is at least one and at most MAXRELOCS entries to relocate
4589      in each stub.  */
4590   BFD_ASSERT (nrelocs != 0 && nrelocs <= MAXRELOCS);
4591
4592   for (i = 0; i < nrelocs; i++)
4593     {
4594       Elf_Internal_Rela rel;
4595       bfd_boolean unresolved_reloc;
4596       char *error_message;
4597       bfd_vma points_to =
4598         sym_value + template_sequence[stub_reloc_idx[i]].reloc_addend;
4599
4600       rel.r_offset = stub_entry->stub_offset + stub_reloc_offset[i];
4601       rel.r_info = ELF32_R_INFO (0,
4602                                  template_sequence[stub_reloc_idx[i]].r_type);
4603       rel.r_addend = 0;
4604
4605       if (stub_entry->stub_type == arm_stub_a8_veneer_b_cond && i == 0)
4606         /* The first relocation in the elf32_arm_stub_a8_veneer_b_cond[]
4607            template should refer back to the instruction after the original
4608            branch.  We use target_section as Cortex-A8 erratum workaround stubs
4609            are only generated when both source and target are in the same
4610            section.  */
4611         points_to = stub_entry->target_section->output_section->vma
4612                     + stub_entry->target_section->output_offset
4613                     + stub_entry->source_value;
4614
4615       elf32_arm_final_link_relocate (elf32_arm_howto_from_type
4616           (template_sequence[stub_reloc_idx[i]].r_type),
4617            stub_bfd, info->output_bfd, stub_sec, stub_sec->contents, &rel,
4618            points_to, info, stub_entry->target_section, "", STT_FUNC,
4619            stub_entry->branch_type,
4620            (struct elf_link_hash_entry *) stub_entry->h, &unresolved_reloc,
4621            &error_message);
4622     }
4623
4624   return TRUE;
4625 #undef MAXRELOCS
4626 }
4627
4628 /* Calculate the template, template size and instruction size for a stub.
4629    Return value is the instruction size.  */
4630
4631 static unsigned int
4632 find_stub_size_and_template (enum elf32_arm_stub_type stub_type,
4633                              const insn_sequence **stub_template,
4634                              int *stub_template_size)
4635 {
4636   const insn_sequence *template_sequence = NULL;
4637   int template_size = 0, i;
4638   unsigned int size;
4639
4640   template_sequence = stub_definitions[stub_type].template_sequence;
4641   if (stub_template)
4642     *stub_template = template_sequence;
4643
4644   template_size = stub_definitions[stub_type].template_size;
4645   if (stub_template_size)
4646     *stub_template_size = template_size;
4647
4648   size = 0;
4649   for (i = 0; i < template_size; i++)
4650     {
4651       switch (template_sequence[i].type)
4652         {
4653         case THUMB16_TYPE:
4654           size += 2;
4655           break;
4656
4657         case ARM_TYPE:
4658         case THUMB32_TYPE:
4659         case DATA_TYPE:
4660           size += 4;
4661           break;
4662
4663         default:
4664           BFD_FAIL ();
4665           return 0;
4666         }
4667     }
4668
4669   return size;
4670 }
4671
4672 /* As above, but don't actually build the stub.  Just bump offset so
4673    we know stub section sizes.  */
4674
4675 static bfd_boolean
4676 arm_size_one_stub (struct bfd_hash_entry *gen_entry,
4677                    void *in_arg ATTRIBUTE_UNUSED)
4678 {
4679   struct elf32_arm_stub_hash_entry *stub_entry;
4680   const insn_sequence *template_sequence;
4681   int template_size, size;
4682
4683   /* Massage our args to the form they really have.  */
4684   stub_entry = (struct elf32_arm_stub_hash_entry *) gen_entry;
4685
4686   BFD_ASSERT((stub_entry->stub_type > arm_stub_none)
4687              && stub_entry->stub_type < ARRAY_SIZE(stub_definitions));
4688
4689   size = find_stub_size_and_template (stub_entry->stub_type, &template_sequence,
4690                                       &template_size);
4691
4692   stub_entry->stub_size = size;
4693   stub_entry->stub_template = template_sequence;
4694   stub_entry->stub_template_size = template_size;
4695
4696   size = (size + 7) & ~7;
4697   stub_entry->stub_sec->size += size;
4698
4699   return TRUE;
4700 }
4701
4702 /* External entry points for sizing and building linker stubs.  */
4703
4704 /* Set up various things so that we can make a list of input sections
4705    for each output section included in the link.  Returns -1 on error,
4706    0 when no stubs will be needed, and 1 on success.  */
4707
4708 int
4709 elf32_arm_setup_section_lists (bfd *output_bfd,
4710                                struct bfd_link_info *info)
4711 {
4712   bfd *input_bfd;
4713   unsigned int bfd_count;
4714   unsigned int top_id, top_index;
4715   asection *section;
4716   asection **input_list, **list;
4717   bfd_size_type amt;
4718   struct elf32_arm_link_hash_table *htab = elf32_arm_hash_table (info);
4719
4720   if (htab == NULL)
4721     return 0;
4722   if (! is_elf_hash_table (htab))
4723     return 0;
4724
4725   /* Count the number of input BFDs and find the top input section id.  */
4726   for (input_bfd = info->input_bfds, bfd_count = 0, top_id = 0;
4727        input_bfd != NULL;
4728        input_bfd = input_bfd->link.next)
4729     {
4730       bfd_count += 1;
4731       for (section = input_bfd->sections;
4732            section != NULL;
4733            section = section->next)
4734         {
4735           if (top_id < section->id)
4736             top_id = section->id;
4737         }
4738     }
4739   htab->bfd_count = bfd_count;
4740
4741   amt = sizeof (struct map_stub) * (top_id + 1);
4742   htab->stub_group = (struct map_stub *) bfd_zmalloc (amt);
4743   if (htab->stub_group == NULL)
4744     return -1;
4745   htab->top_id = top_id;
4746
4747   /* We can't use output_bfd->section_count here to find the top output
4748      section index as some sections may have been removed, and
4749      _bfd_strip_section_from_output doesn't renumber the indices.  */
4750   for (section = output_bfd->sections, top_index = 0;
4751        section != NULL;
4752        section = section->next)
4753     {
4754       if (top_index < section->index)
4755         top_index = section->index;
4756     }
4757
4758   htab->top_index = top_index;
4759   amt = sizeof (asection *) * (top_index + 1);
4760   input_list = (asection **) bfd_malloc (amt);
4761   htab->input_list = input_list;
4762   if (input_list == NULL)
4763     return -1;
4764
4765   /* For sections we aren't interested in, mark their entries with a
4766      value we can check later.  */
4767   list = input_list + top_index;
4768   do
4769     *list = bfd_abs_section_ptr;
4770   while (list-- != input_list);
4771
4772   for (section = output_bfd->sections;
4773        section != NULL;
4774        section = section->next)
4775     {
4776       if ((section->flags & SEC_CODE) != 0)
4777         input_list[section->index] = NULL;
4778     }
4779
4780   return 1;
4781 }
4782
4783 /* The linker repeatedly calls this function for each input section,
4784    in the order that input sections are linked into output sections.
4785    Build lists of input sections to determine groupings between which
4786    we may insert linker stubs.  */
4787
4788 void
4789 elf32_arm_next_input_section (struct bfd_link_info *info,
4790                               asection *isec)
4791 {
4792   struct elf32_arm_link_hash_table *htab = elf32_arm_hash_table (info);
4793
4794   if (htab == NULL)
4795     return;
4796
4797   if (isec->output_section->index <= htab->top_index)
4798     {
4799       asection **list = htab->input_list + isec->output_section->index;
4800
4801       if (*list != bfd_abs_section_ptr && (isec->flags & SEC_CODE) != 0)
4802         {
4803           /* Steal the link_sec pointer for our list.  */
4804 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
4805           /* This happens to make the list in reverse order,
4806              which we reverse later.  */
4807           PREV_SEC (isec) = *list;
4808           *list = isec;
4809         }
4810     }
4811 }
4812
4813 /* See whether we can group stub sections together.  Grouping stub
4814    sections may result in fewer stubs.  More importantly, we need to
4815    put all .init* and .fini* stubs at the end of the .init or
4816    .fini output sections respectively, because glibc splits the
4817    _init and _fini functions into multiple parts.  Putting a stub in
4818    the middle of a function is not a good idea.  */
4819
4820 static void
4821 group_sections (struct elf32_arm_link_hash_table *htab,
4822                 bfd_size_type stub_group_size,
4823                 bfd_boolean stubs_always_after_branch)
4824 {
4825   asection **list = htab->input_list;
4826
4827   do
4828     {
4829       asection *tail = *list;
4830       asection *head;
4831
4832       if (tail == bfd_abs_section_ptr)
4833         continue;
4834
4835       /* Reverse the list: we must avoid placing stubs at the
4836          beginning of the section because the beginning of the text
4837          section may be required for an interrupt vector in bare metal
4838          code.  */
4839 #define NEXT_SEC PREV_SEC
4840       head = NULL;
4841       while (tail != NULL)
4842         {
4843           /* Pop from tail.  */
4844           asection *item = tail;
4845           tail = PREV_SEC (item);
4846
4847           /* Push on head.  */
4848           NEXT_SEC (item) = head;
4849           head = item;
4850         }
4851
4852       while (head != NULL)
4853         {
4854           asection *curr;
4855           asection *next;
4856           bfd_vma stub_group_start = head->output_offset;
4857           bfd_vma end_of_next;
4858
4859           curr = head;
4860           while (NEXT_SEC (curr) != NULL)
4861             {
4862               next = NEXT_SEC (curr);
4863               end_of_next = next->output_offset + next->size;
4864               if (end_of_next - stub_group_start >= stub_group_size)
4865                 /* End of NEXT is too far from start, so stop.  */
4866                 break;
4867               /* Add NEXT to the group.  */
4868               curr = next;
4869             }
4870
4871           /* OK, the size from the start to the start of CURR is less
4872              than stub_group_size and thus can be handled by one stub
4873              section.  (Or the head section is itself larger than
4874              stub_group_size, in which case we may be toast.)
4875              We should really be keeping track of the total size of
4876              stubs added here, as stubs contribute to the final output
4877              section size.  */
4878           do
4879             {
4880               next = NEXT_SEC (head);
4881               /* Set up this stub group.  */
4882               htab->stub_group[head->id].link_sec = curr;
4883             }
4884           while (head != curr && (head = next) != NULL);
4885
4886           /* But wait, there's more!  Input sections up to stub_group_size
4887              bytes after the stub section can be handled by it too.  */
4888           if (!stubs_always_after_branch)
4889             {
4890               stub_group_start = curr->output_offset + curr->size;
4891
4892               while (next != NULL)
4893                 {
4894                   end_of_next = next->output_offset + next->size;
4895                   if (end_of_next - stub_group_start >= stub_group_size)
4896                     /* End of NEXT is too far from stubs, so stop.  */
4897                     break;
4898                   /* Add NEXT to the stub group.  */
4899                   head = next;
4900                   next = NEXT_SEC (head);
4901                   htab->stub_group[head->id].link_sec = curr;
4902                 }
4903             }
4904           head = next;
4905         }
4906     }
4907   while (list++ != htab->input_list + htab->top_index);
4908
4909   free (htab->input_list);
4910 #undef PREV_SEC
4911 #undef NEXT_SEC
4912 }
4913
4914 /* Comparison function for sorting/searching relocations relating to Cortex-A8
4915    erratum fix.  */
4916
4917 static int
4918 a8_reloc_compare (const void *a, const void *b)
4919 {
4920   const struct a8_erratum_reloc *ra = (const struct a8_erratum_reloc *) a;
4921   const struct a8_erratum_reloc *rb = (const struct a8_erratum_reloc *) b;
4922
4923   if (ra->from < rb->from)
4924     return -1;
4925   else if (ra->from > rb->from)
4926     return 1;
4927   else
4928     return 0;
4929 }
4930
4931 static struct elf_link_hash_entry *find_thumb_glue (struct bfd_link_info *,
4932                                                     const char *, char **);
4933
4934 /* Helper function to scan code for sequences which might trigger the Cortex-A8
4935    branch/TLB erratum.  Fill in the table described by A8_FIXES_P,
4936    NUM_A8_FIXES_P, A8_FIX_TABLE_SIZE_P.  Returns true if an error occurs, false
4937    otherwise.  */
4938
4939 static bfd_boolean
4940 cortex_a8_erratum_scan (bfd *input_bfd,
4941                         struct bfd_link_info *info,
4942                         struct a8_erratum_fix **a8_fixes_p,
4943                         unsigned int *num_a8_fixes_p,
4944                         unsigned int *a8_fix_table_size_p,
4945                         struct a8_erratum_reloc *a8_relocs,
4946                         unsigned int num_a8_relocs,
4947                         unsigned prev_num_a8_fixes,
4948                         bfd_boolean *stub_changed_p)
4949 {
4950   asection *section;
4951   struct elf32_arm_link_hash_table *htab = elf32_arm_hash_table (info);
4952   struct a8_erratum_fix *a8_fixes = *a8_fixes_p;
4953   unsigned int num_a8_fixes = *num_a8_fixes_p;
4954   unsigned int a8_fix_table_size = *a8_fix_table_size_p;
4955
4956   if (htab == NULL)
4957     return FALSE;
4958
4959   for (section = input_bfd->sections;
4960        section != NULL;
4961        section = section->next)
4962     {
4963       bfd_byte *contents = NULL;
4964       struct _arm_elf_section_data *sec_data;
4965       unsigned int span;
4966       bfd_vma base_vma;
4967
4968       if (elf_section_type (section) != SHT_PROGBITS
4969           || (elf_section_flags (section) & SHF_EXECINSTR) == 0
4970           || (section->flags & SEC_EXCLUDE) != 0
4971           || (section->sec_info_type == SEC_INFO_TYPE_JUST_SYMS)
4972           || (section->output_section == bfd_abs_section_ptr))
4973         continue;
4974
4975       base_vma = section->output_section->vma + section->output_offset;
4976
4977       if (elf_section_data (section)->this_hdr.contents != NULL)
4978         contents = elf_section_data (section)->this_hdr.contents;
4979       else if (! bfd_malloc_and_get_section (input_bfd, section, &contents))
4980         return TRUE;
4981
4982       sec_data = elf32_arm_section_data (section);
4983
4984       for (span = 0; span < sec_data->mapcount; span++)
4985         {
4986           unsigned int span_start = sec_data->map[span].vma;
4987           unsigned int span_end = (span == sec_data->mapcount - 1)
4988             ? section->size : sec_data->map[span + 1].vma;
4989           unsigned int i;
4990           char span_type = sec_data->map[span].type;
4991           bfd_boolean last_was_32bit = FALSE, last_was_branch = FALSE;
4992
4993           if (span_type != 't')
4994             continue;
4995
4996           /* Span is entirely within a single 4KB region: skip scanning.  */
4997           if (((base_vma + span_start) & ~0xfff)
4998               == ((base_vma + span_end) & ~0xfff))
4999             continue;
5000
5001           /* Scan for 32-bit Thumb-2 branches which span two 4K regions, where:
5002
5003                * The opcode is BLX.W, BL.W, B.W, Bcc.W
5004                * The branch target is in the same 4KB region as the
5005                  first half of the branch.
5006                * The instruction before the branch is a 32-bit
5007                  length non-branch instruction.  */
5008           for (i = span_start; i < span_end;)
5009             {
5010               unsigned int insn = bfd_getl16 (&contents[i]);
5011               bfd_boolean insn_32bit = FALSE, is_blx = FALSE, is_b = FALSE;
5012               bfd_boolean is_bl = FALSE, is_bcc = FALSE, is_32bit_branch;
5013
5014               if ((insn & 0xe000) == 0xe000 && (insn & 0x1800) != 0x0000)
5015                 insn_32bit = TRUE;
5016
5017               if (insn_32bit)
5018                 {
5019                   /* Load the rest of the insn (in manual-friendly order).  */
5020                   insn = (insn << 16) | bfd_getl16 (&contents[i + 2]);
5021
5022                   /* Encoding T4: B<c>.W.  */
5023                   is_b = (insn & 0xf800d000) == 0xf0009000;
5024                   /* Encoding T1: BL<c>.W.  */
5025                   is_bl = (insn & 0xf800d000) == 0xf000d000;
5026                   /* Encoding T2: BLX<c>.W.  */
5027                   is_blx = (insn & 0xf800d000) == 0xf000c000;
5028                   /* Encoding T3: B<c>.W (not permitted in IT block).  */
5029                   is_bcc = (insn & 0xf800d000) == 0xf0008000
5030                            && (insn & 0x07f00000) != 0x03800000;
5031                 }
5032
5033               is_32bit_branch = is_b || is_bl || is_blx || is_bcc;
5034
5035               if (((base_vma + i) & 0xfff) == 0xffe
5036                   && insn_32bit
5037                   && is_32bit_branch
5038                   && last_was_32bit
5039                   && ! last_was_branch)
5040                 {
5041                   bfd_signed_vma offset = 0;
5042                   bfd_boolean force_target_arm = FALSE;
5043                   bfd_boolean force_target_thumb = FALSE;
5044                   bfd_vma target;
5045                   enum elf32_arm_stub_type stub_type = arm_stub_none;
5046                   struct a8_erratum_reloc key, *found;
5047                   bfd_boolean use_plt = FALSE;
5048
5049                   key.from = base_vma + i;
5050                   found = (struct a8_erratum_reloc *)
5051                       bsearch (&key, a8_relocs, num_a8_relocs,
5052                                sizeof (struct a8_erratum_reloc),
5053                                &a8_reloc_compare);
5054
5055                   if (found)
5056                     {
5057                       char *error_message = NULL;
5058                       struct elf_link_hash_entry *entry;
5059
5060                       /* We don't care about the error returned from this
5061                          function, only if there is glue or not.  */
5062                       entry = find_thumb_glue (info, found->sym_name,
5063                                                &error_message);
5064
5065                       if (entry)
5066                         found->non_a8_stub = TRUE;
5067
5068                       /* Keep a simpler condition, for the sake of clarity.  */
5069                       if (htab->root.splt != NULL && found->hash != NULL
5070                           && found->hash->root.plt.offset != (bfd_vma) -1)
5071                         use_plt = TRUE;
5072
5073                       if (found->r_type == R_ARM_THM_CALL)
5074                         {
5075                           if (found->branch_type == ST_BRANCH_TO_ARM
5076                               || use_plt)
5077                             force_target_arm = TRUE;
5078                           else
5079                             force_target_thumb = TRUE;
5080                         }
5081                     }
5082
5083                   /* Check if we have an offending branch instruction.  */
5084
5085                   if (found && found->non_a8_stub)
5086                     /* We've already made a stub for this instruction, e.g.
5087                        it's a long branch or a Thumb->ARM stub.  Assume that
5088                        stub will suffice to work around the A8 erratum (see
5089                        setting of always_after_branch above).  */
5090                     ;
5091                   else if (is_bcc)
5092                     {
5093                       offset = (insn & 0x7ff) << 1;
5094                       offset |= (insn & 0x3f0000) >> 4;
5095                       offset |= (insn & 0x2000) ? 0x40000 : 0;
5096                       offset |= (insn & 0x800) ? 0x80000 : 0;
5097                       offset |= (insn & 0x4000000) ? 0x100000 : 0;
5098                       if (offset & 0x100000)
5099                         offset |= ~ ((bfd_signed_vma) 0xfffff);
5100                       stub_type = arm_stub_a8_veneer_b_cond;
5101                     }
5102                   else if (is_b || is_bl || is_blx)
5103                     {
5104                       int s = (insn & 0x4000000) != 0;
5105                       int j1 = (insn & 0x2000) != 0;
5106                       int j2 = (insn & 0x800) != 0;
5107                       int i1 = !(j1 ^ s);
5108                       int i2 = !(j2 ^ s);
5109
5110                       offset = (insn & 0x7ff) << 1;
5111                       offset |= (insn & 0x3ff0000) >> 4;
5112                       offset |= i2 << 22;
5113                       offset |= i1 << 23;
5114                       offset |= s << 24;
5115                       if (offset & 0x1000000)
5116                         offset |= ~ ((bfd_signed_vma) 0xffffff);
5117
5118                       if (is_blx)
5119                         offset &= ~ ((bfd_signed_vma) 3);
5120
5121                       stub_type = is_blx ? arm_stub_a8_veneer_blx :
5122                         is_bl ? arm_stub_a8_veneer_bl : arm_stub_a8_veneer_b;
5123                     }
5124
5125                   if (stub_type != arm_stub_none)
5126                     {
5127                       bfd_vma pc_for_insn = base_vma + i + 4;
5128
5129                       /* The original instruction is a BL, but the target is
5130                          an ARM instruction.  If we were not making a stub,
5131                          the BL would have been converted to a BLX.  Use the
5132                          BLX stub instead in that case.  */
5133                       if (htab->use_blx && force_target_arm
5134                           && stub_type == arm_stub_a8_veneer_bl)
5135                         {
5136                           stub_type = arm_stub_a8_veneer_blx;
5137                           is_blx = TRUE;
5138                           is_bl = FALSE;
5139                         }
5140                       /* Conversely, if the original instruction was
5141                          BLX but the target is Thumb mode, use the BL
5142                          stub.  */
5143                       else if (force_target_thumb
5144                                && stub_type == arm_stub_a8_veneer_blx)
5145                         {
5146                           stub_type = arm_stub_a8_veneer_bl;
5147                           is_blx = FALSE;
5148                           is_bl = TRUE;
5149                         }
5150
5151                       if (is_blx)
5152                         pc_for_insn &= ~ ((bfd_vma) 3);
5153
5154                       /* If we found a relocation, use the proper destination,
5155                          not the offset in the (unrelocated) instruction.
5156                          Note this is always done if we switched the stub type
5157                          above.  */
5158                       if (found)
5159                         offset =
5160                           (bfd_signed_vma) (found->destination - pc_for_insn);
5161
5162                       /* If the stub will use a Thumb-mode branch to a
5163                          PLT target, redirect it to the preceding Thumb
5164                          entry point.  */
5165                       if (stub_type != arm_stub_a8_veneer_blx && use_plt)
5166                         offset -= PLT_THUMB_STUB_SIZE;
5167
5168                       target = pc_for_insn + offset;
5169
5170                       /* The BLX stub is ARM-mode code.  Adjust the offset to
5171                          take the different PC value (+8 instead of +4) into
5172                          account.  */
5173                       if (stub_type == arm_stub_a8_veneer_blx)
5174                         offset += 4;
5175
5176                       if (((base_vma + i) & ~0xfff) == (target & ~0xfff))
5177                         {
5178                           char *stub_name = NULL;
5179
5180                           if (num_a8_fixes == a8_fix_table_size)
5181                             {
5182                               a8_fix_table_size *= 2;
5183                               a8_fixes = (struct a8_erratum_fix *)
5184                                   bfd_realloc (a8_fixes,
5185                                                sizeof (struct a8_erratum_fix)
5186                                                * a8_fix_table_size);
5187                             }
5188
5189                           if (num_a8_fixes < prev_num_a8_fixes)
5190                             {
5191                               /* If we're doing a subsequent scan,
5192                                  check if we've found the same fix as
5193                                  before, and try and reuse the stub
5194                                  name.  */
5195                               stub_name = a8_fixes[num_a8_fixes].stub_name;
5196                               if ((a8_fixes[num_a8_fixes].section != section)
5197                                   || (a8_fixes[num_a8_fixes].offset != i))
5198                                 {
5199                                   free (stub_name);
5200                                   stub_name = NULL;
5201                                   *stub_changed_p = TRUE;
5202                                 }
5203                             }
5204
5205                           if (!stub_name)
5206                             {
5207                               stub_name = (char *) bfd_malloc (8 + 1 + 8 + 1);
5208                               if (stub_name != NULL)
5209                                 sprintf (stub_name, "%x:%x", section->id, i);
5210                             }
5211
5212                           a8_fixes[num_a8_fixes].input_bfd = input_bfd;
5213                           a8_fixes[num_a8_fixes].section = section;
5214                           a8_fixes[num_a8_fixes].offset = i;
5215                           a8_fixes[num_a8_fixes].target_offset =
5216                             target - base_vma;
5217                           a8_fixes[num_a8_fixes].orig_insn = insn;
5218                           a8_fixes[num_a8_fixes].stub_name = stub_name;
5219                           a8_fixes[num_a8_fixes].stub_type = stub_type;
5220                           a8_fixes[num_a8_fixes].branch_type =
5221                             is_blx ? ST_BRANCH_TO_ARM : ST_BRANCH_TO_THUMB;
5222
5223                           num_a8_fixes++;
5224                         }
5225                     }
5226                 }
5227
5228               i += insn_32bit ? 4 : 2;
5229               last_was_32bit = insn_32bit;
5230               last_was_branch = is_32bit_branch;
5231             }
5232         }
5233
5234       if (elf_section_data (section)->this_hdr.contents == NULL)
5235         free (contents);
5236     }
5237
5238   *a8_fixes_p = a8_fixes;
5239   *num_a8_fixes_p = num_a8_fixes;
5240   *a8_fix_table_size_p = a8_fix_table_size;
5241
5242   return FALSE;
5243 }
5244
5245 /* Create or update a stub entry depending on whether the stub can already be
5246    found in HTAB.  The stub is identified by:
5247    - its type STUB_TYPE
5248    - its source branch (note that several can share the same stub) whose
5249      section and relocation (if any) are given by SECTION and IRELA
5250      respectively
5251    - its target symbol whose input section, hash, name, value and branch type
5252      are given in SYM_SEC, HASH, SYM_NAME, SYM_VALUE and BRANCH_TYPE
5253      respectively
5254
5255    If found, the value of the stub's target symbol is updated from SYM_VALUE
5256    and *NEW_STUB is set to FALSE.  Otherwise, *NEW_STUB is set to
5257    TRUE and the stub entry is initialized.
5258
5259    Returns whether the stub could be successfully created or updated, or FALSE
5260    if an error occured.  */
5261
5262 static bfd_boolean
5263 elf32_arm_create_stub (struct elf32_arm_link_hash_table *htab,
5264                        enum elf32_arm_stub_type stub_type, asection *section,
5265                        Elf_Internal_Rela *irela, asection *sym_sec,
5266                        struct elf32_arm_link_hash_entry *hash, char *sym_name,
5267                        bfd_vma sym_value, enum arm_st_branch_type branch_type,
5268                        bfd_boolean *new_stub)
5269 {
5270   const asection *id_sec;
5271   char *stub_name;
5272   struct elf32_arm_stub_hash_entry *stub_entry;
5273   unsigned int r_type;
5274   bfd_boolean sym_claimed = arm_stub_sym_claimed (stub_type);
5275
5276   BFD_ASSERT (stub_type != arm_stub_none);
5277   *new_stub = FALSE;
5278
5279   if (sym_claimed)
5280     stub_name = sym_name;
5281   else
5282     {
5283       BFD_ASSERT (irela);
5284       BFD_ASSERT (section);
5285
5286       /* Support for grouping stub sections.  */
5287       id_sec = htab->stub_group[section->id].link_sec;
5288
5289       /* Get the name of this stub.  */
5290       stub_name = elf32_arm_stub_name (id_sec, sym_sec, hash, irela,
5291                                        stub_type);
5292       if (!stub_name)
5293         return FALSE;
5294     }
5295
5296   stub_entry = arm_stub_hash_lookup (&htab->stub_hash_table, stub_name, FALSE,
5297                                      FALSE);
5298   /* The proper stub has already been created, just update its value.  */
5299   if (stub_entry != NULL)
5300     {
5301       if (!sym_claimed)
5302         free (stub_name);
5303       stub_entry->target_value = sym_value;
5304       return TRUE;
5305     }
5306
5307   stub_entry = elf32_arm_add_stub (stub_name, section, htab, stub_type);
5308   if (stub_entry == NULL)
5309     {
5310       if (!sym_claimed)
5311         free (stub_name);
5312       return FALSE;
5313     }
5314
5315   stub_entry->target_value = sym_value;
5316   stub_entry->target_section = sym_sec;
5317   stub_entry->stub_type = stub_type;
5318   stub_entry->h = hash;
5319   stub_entry->branch_type = branch_type;
5320
5321   if (sym_claimed)
5322     stub_entry->output_name = sym_name;
5323   else
5324     {
5325       if (sym_name == NULL)
5326         sym_name = "unnamed";
5327       stub_entry->output_name = (char *)
5328         bfd_alloc (htab->stub_bfd, sizeof (THUMB2ARM_GLUE_ENTRY_NAME)
5329                                    + strlen (sym_name));
5330       if (stub_entry->output_name == NULL)
5331         {
5332           free (stub_name);
5333           return FALSE;
5334         }
5335
5336       /* For historical reasons, use the existing names for ARM-to-Thumb and
5337          Thumb-to-ARM stubs.  */
5338       r_type = ELF32_R_TYPE (irela->r_info);
5339       if ((r_type == (unsigned int) R_ARM_THM_CALL
5340            || r_type == (unsigned int) R_ARM_THM_JUMP24
5341            || r_type == (unsigned int) R_ARM_THM_JUMP19)
5342           && branch_type == ST_BRANCH_TO_ARM)
5343         sprintf (stub_entry->output_name, THUMB2ARM_GLUE_ENTRY_NAME, sym_name);
5344       else if ((r_type == (unsigned int) R_ARM_CALL
5345                 || r_type == (unsigned int) R_ARM_JUMP24)
5346                && branch_type == ST_BRANCH_TO_THUMB)
5347         sprintf (stub_entry->output_name, ARM2THUMB_GLUE_ENTRY_NAME, sym_name);
5348       else
5349         sprintf (stub_entry->output_name, STUB_ENTRY_NAME, sym_name);
5350     }
5351
5352   *new_stub = TRUE;
5353   return TRUE;
5354 }
5355
5356 /* Determine and set the size of the stub section for a final link.
5357
5358    The basic idea here is to examine all the relocations looking for
5359    PC-relative calls to a target that is unreachable with a "bl"
5360    instruction.  */
5361
5362 bfd_boolean
5363 elf32_arm_size_stubs (bfd *output_bfd,
5364                       bfd *stub_bfd,
5365                       struct bfd_link_info *info,
5366                       bfd_signed_vma group_size,
5367                       asection * (*add_stub_section) (const char *, asection *,
5368                                                       asection *,
5369                                                       unsigned int),
5370                       void (*layout_sections_again) (void))
5371 {
5372   bfd_size_type stub_group_size;
5373   bfd_boolean stubs_always_after_branch;
5374   struct elf32_arm_link_hash_table *htab = elf32_arm_hash_table (info);
5375   struct a8_erratum_fix *a8_fixes = NULL;
5376   unsigned int num_a8_fixes = 0, a8_fix_table_size = 10;
5377   struct a8_erratum_reloc *a8_relocs = NULL;
5378   unsigned int num_a8_relocs = 0, a8_reloc_table_size = 10, i;
5379
5380   if (htab == NULL)
5381     return FALSE;
5382
5383   if (htab->fix_cortex_a8)
5384     {
5385       a8_fixes = (struct a8_erratum_fix *)
5386           bfd_zmalloc (sizeof (struct a8_erratum_fix) * a8_fix_table_size);
5387       a8_relocs = (struct a8_erratum_reloc *)
5388           bfd_zmalloc (sizeof (struct a8_erratum_reloc) * a8_reloc_table_size);
5389     }
5390
5391   /* Propagate mach to stub bfd, because it may not have been
5392      finalized when we created stub_bfd.  */
5393   bfd_set_arch_mach (stub_bfd, bfd_get_arch (output_bfd),
5394                      bfd_get_mach (output_bfd));
5395
5396   /* Stash our params away.  */
5397   htab->stub_bfd = stub_bfd;
5398   htab->add_stub_section = add_stub_section;
5399   htab->layout_sections_again = layout_sections_again;
5400   stubs_always_after_branch = group_size < 0;
5401
5402   /* The Cortex-A8 erratum fix depends on stubs not being in the same 4K page
5403      as the first half of a 32-bit branch straddling two 4K pages.  This is a
5404      crude way of enforcing that.  */
5405   if (htab->fix_cortex_a8)
5406     stubs_always_after_branch = 1;
5407
5408   if (group_size < 0)
5409     stub_group_size = -group_size;
5410   else
5411     stub_group_size = group_size;
5412
5413   if (stub_group_size == 1)
5414     {
5415       /* Default values.  */
5416       /* Thumb branch range is +-4MB has to be used as the default
5417          maximum size (a given section can contain both ARM and Thumb
5418          code, so the worst case has to be taken into account).
5419
5420          This value is 24K less than that, which allows for 2025
5421          12-byte stubs.  If we exceed that, then we will fail to link.
5422          The user will have to relink with an explicit group size
5423          option.  */
5424       stub_group_size = 4170000;
5425     }
5426
5427   group_sections (htab, stub_group_size, stubs_always_after_branch);
5428
5429   /* If we're applying the cortex A8 fix, we need to determine the
5430      program header size now, because we cannot change it later --
5431      that could alter section placements.  Notice the A8 erratum fix
5432      ends up requiring the section addresses to remain unchanged
5433      modulo the page size.  That's something we cannot represent
5434      inside BFD, and we don't want to force the section alignment to
5435      be the page size.  */
5436   if (htab->fix_cortex_a8)
5437     (*htab->layout_sections_again) ();
5438
5439   while (1)
5440     {
5441       bfd *input_bfd;
5442       unsigned int bfd_indx;
5443       asection *stub_sec;
5444       enum elf32_arm_stub_type stub_type;
5445       bfd_boolean stub_changed = FALSE;
5446       unsigned prev_num_a8_fixes = num_a8_fixes;
5447
5448       num_a8_fixes = 0;
5449       for (input_bfd = info->input_bfds, bfd_indx = 0;
5450            input_bfd != NULL;
5451            input_bfd = input_bfd->link.next, bfd_indx++)
5452         {
5453           Elf_Internal_Shdr *symtab_hdr;
5454           asection *section;
5455           Elf_Internal_Sym *local_syms = NULL;
5456
5457           if (!is_arm_elf (input_bfd))
5458             continue;
5459
5460           num_a8_relocs = 0;
5461
5462           /* We'll need the symbol table in a second.  */
5463           symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
5464           if (symtab_hdr->sh_info == 0)
5465             continue;
5466
5467           /* Walk over each section attached to the input bfd.  */
5468           for (section = input_bfd->sections;
5469                section != NULL;
5470                section = section->next)
5471             {
5472               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
5473
5474               /* If there aren't any relocs, then there's nothing more
5475                  to do.  */
5476               if ((section->flags & SEC_RELOC) == 0
5477                   || section->reloc_count == 0
5478                   || (section->flags & SEC_CODE) == 0)
5479                 continue;
5480
5481               /* If this section is a link-once section that will be
5482                  discarded, then don't create any stubs.  */
5483               if (section->output_section == NULL
5484                   || section->output_section->owner != output_bfd)
5485                 continue;
5486
5487               /* Get the relocs.  */
5488               internal_relocs
5489                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL,
5490                                              NULL, info->keep_memory);
5491               if (internal_relocs == NULL)
5492                 goto error_ret_free_local;
5493
5494               /* Now examine each relocation.  */
5495               irela = internal_relocs;
5496               irelaend = irela + section->reloc_count;
5497               for (; irela < irelaend; irela++)
5498                 {
5499                   unsigned int r_type, r_indx;
5500                   asection *sym_sec;
5501                   bfd_vma sym_value;
5502                   bfd_vma destination;
5503                   struct elf32_arm_link_hash_entry *hash;
5504                   const char *sym_name;
5505                   unsigned char st_type;
5506                   enum arm_st_branch_type branch_type;
5507                   bfd_boolean created_stub = FALSE;
5508
5509                   r_type = ELF32_R_TYPE (irela->r_info);
5510                   r_indx = ELF32_R_SYM (irela->r_info);
5511
5512                   if (r_type >= (unsigned int) R_ARM_max)
5513                     {
5514                       bfd_set_error (bfd_error_bad_value);
5515                     error_ret_free_internal:
5516                       if (elf_section_data (section)->relocs == NULL)
5517                         free (internal_relocs);
5518                     /* Fall through.  */
5519                     error_ret_free_local:
5520                       if (local_syms != NULL
5521                           && (symtab_hdr->contents
5522                               != (unsigned char *) local_syms))
5523                         free (local_syms);
5524                       return FALSE;
5525                     }
5526
5527                   hash = NULL;
5528                   if (r_indx >= symtab_hdr->sh_info)
5529                     hash = elf32_arm_hash_entry
5530                       (elf_sym_hashes (input_bfd)
5531                        [r_indx - symtab_hdr->sh_info]);
5532
5533                   /* Only look for stubs on branch instructions, or
5534                      non-relaxed TLSCALL  */
5535                   if ((r_type != (unsigned int) R_ARM_CALL)
5536                       && (r_type != (unsigned int) R_ARM_THM_CALL)
5537                       && (r_type != (unsigned int) R_ARM_JUMP24)
5538                       && (r_type != (unsigned int) R_ARM_THM_JUMP19)
5539                       && (r_type != (unsigned int) R_ARM_THM_XPC22)
5540                       && (r_type != (unsigned int) R_ARM_THM_JUMP24)
5541                       && (r_type != (unsigned int) R_ARM_PLT32)
5542                       && !((r_type == (unsigned int) R_ARM_TLS_CALL
5543                             || r_type == (unsigned int) R_ARM_THM_TLS_CALL)
5544                            && r_type == elf32_arm_tls_transition
5545                                (info, r_type, &hash->root)
5546                            && ((hash ? hash->tls_type
5547                                 : (elf32_arm_local_got_tls_type
5548                                    (input_bfd)[r_indx]))
5549                                & GOT_TLS_GDESC) != 0))
5550                     continue;
5551
5552                   /* Now determine the call target, its name, value,
5553                      section.  */
5554                   sym_sec = NULL;
5555                   sym_value = 0;
5556                   destination = 0;
5557                   sym_name = NULL;
5558
5559                   if (r_type == (unsigned int) R_ARM_TLS_CALL
5560                       || r_type == (unsigned int) R_ARM_THM_TLS_CALL)
5561                     {
5562                       /* A non-relaxed TLS call.  The target is the
5563                          plt-resident trampoline and nothing to do
5564                          with the symbol.  */
5565                       BFD_ASSERT (htab->tls_trampoline > 0);
5566                       sym_sec = htab->root.splt;
5567                       sym_value = htab->tls_trampoline;
5568                       hash = 0;
5569                       st_type = STT_FUNC;
5570                       branch_type = ST_BRANCH_TO_ARM;
5571                     }
5572                   else if (!hash)
5573                     {
5574                       /* It's a local symbol.  */
5575                       Elf_Internal_Sym *sym;
5576
5577                       if (local_syms == NULL)
5578                         {
5579                           local_syms
5580                             = (Elf_Internal_Sym *) symtab_hdr->contents;
5581                           if (local_syms == NULL)
5582                             local_syms
5583                               = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
5584                                                       symtab_hdr->sh_info, 0,
5585                                                       NULL, NULL, NULL);
5586                           if (local_syms == NULL)
5587                             goto error_ret_free_internal;
5588                         }
5589
5590                       sym = local_syms + r_indx;
5591                       if (sym->st_shndx == SHN_UNDEF)
5592                         sym_sec = bfd_und_section_ptr;
5593                       else if (sym->st_shndx == SHN_ABS)
5594                         sym_sec = bfd_abs_section_ptr;
5595                       else if (sym->st_shndx == SHN_COMMON)
5596                         sym_sec = bfd_com_section_ptr;
5597                       else
5598                         sym_sec =
5599                           bfd_section_from_elf_index (input_bfd, sym->st_shndx);
5600
5601                       if (!sym_sec)
5602                         /* This is an undefined symbol.  It can never
5603                            be resolved.  */
5604                         continue;
5605
5606                       if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
5607                         sym_value = sym->st_value;
5608                       destination = (sym_value + irela->r_addend
5609                                      + sym_sec->output_offset
5610                                      + sym_sec->output_section->vma);
5611                       st_type = ELF_ST_TYPE (sym->st_info);
5612                       branch_type =
5613                         ARM_GET_SYM_BRANCH_TYPE (sym->st_target_internal);
5614                       sym_name
5615                         = bfd_elf_string_from_elf_section (input_bfd,
5616                                                            symtab_hdr->sh_link,
5617                                                            sym->st_name);
5618                     }
5619                   else
5620                     {
5621                       /* It's an external symbol.  */
5622                       while (hash->root.root.type == bfd_link_hash_indirect
5623                              || hash->root.root.type == bfd_link_hash_warning)
5624                         hash = ((struct elf32_arm_link_hash_entry *)
5625                                 hash->root.root.u.i.link);
5626
5627                       if (hash->root.root.type == bfd_link_hash_defined
5628                           || hash->root.root.type == bfd_link_hash_defweak)
5629                         {
5630                           sym_sec = hash->root.root.u.def.section;
5631                           sym_value = hash->root.root.u.def.value;
5632
5633                           struct elf32_arm_link_hash_table *globals =
5634                                                   elf32_arm_hash_table (info);
5635
5636                           /* For a destination in a shared library,
5637                              use the PLT stub as target address to
5638                              decide whether a branch stub is
5639                              needed.  */
5640                           if (globals != NULL
5641                               && globals->root.splt != NULL
5642                               && hash != NULL
5643                               && hash->root.plt.offset != (bfd_vma) -1)
5644                             {
5645                               sym_sec = globals->root.splt;
5646                               sym_value = hash->root.plt.offset;
5647                               if (sym_sec->output_section != NULL)
5648                                 destination = (sym_value
5649                                                + sym_sec->output_offset
5650                                                + sym_sec->output_section->vma);
5651                             }
5652                           else if (sym_sec->output_section != NULL)
5653                             destination = (sym_value + irela->r_addend
5654                                            + sym_sec->output_offset
5655                                            + sym_sec->output_section->vma);
5656                         }
5657                       else if ((hash->root.root.type == bfd_link_hash_undefined)
5658                                || (hash->root.root.type == bfd_link_hash_undefweak))
5659                         {
5660                           /* For a shared library, use the PLT stub as
5661                              target address to decide whether a long
5662                              branch stub is needed.
5663                              For absolute code, they cannot be handled.  */
5664                           struct elf32_arm_link_hash_table *globals =
5665                             elf32_arm_hash_table (info);
5666
5667                           if (globals != NULL
5668                               && globals->root.splt != NULL
5669                               && hash != NULL
5670                               && hash->root.plt.offset != (bfd_vma) -1)
5671                             {
5672                               sym_sec = globals->root.splt;
5673                               sym_value = hash->root.plt.offset;
5674                               if (sym_sec->output_section != NULL)
5675                                 destination = (sym_value
5676                                                + sym_sec->output_offset
5677                                                + sym_sec->output_section->vma);
5678                             }
5679                           else
5680                             continue;
5681                         }
5682                       else
5683                         {
5684                           bfd_set_error (bfd_error_bad_value);
5685                           goto error_ret_free_internal;
5686                         }
5687                       st_type = hash->root.type;
5688                       branch_type =
5689                         ARM_GET_SYM_BRANCH_TYPE (hash->root.target_internal);
5690                       sym_name = hash->root.root.root.string;
5691                     }
5692
5693                   do
5694                     {
5695                       bfd_boolean new_stub;
5696
5697                       /* Determine what (if any) linker stub is needed.  */
5698                       stub_type = arm_type_of_stub (info, section, irela,
5699                                                     st_type, &branch_type,
5700                                                     hash, destination, sym_sec,
5701                                                     input_bfd, sym_name);
5702                       if (stub_type == arm_stub_none)
5703                         break;
5704
5705                       /* We've either created a stub for this reloc already,
5706                          or we are about to.  */
5707                       created_stub =
5708                         elf32_arm_create_stub (htab, stub_type, section, irela,
5709                                                sym_sec, hash,
5710                                                (char *) sym_name, sym_value,
5711                                                branch_type, &new_stub);
5712
5713                       if (!created_stub)
5714                         goto error_ret_free_internal;
5715                       else if (!new_stub)
5716                         break;
5717                       else
5718                         stub_changed = TRUE;
5719                     }
5720                   while (0);
5721
5722                   /* Look for relocations which might trigger Cortex-A8
5723                      erratum.  */
5724                   if (htab->fix_cortex_a8
5725                       && (r_type == (unsigned int) R_ARM_THM_JUMP24
5726                           || r_type == (unsigned int) R_ARM_THM_JUMP19
5727                           || r_type == (unsigned int) R_ARM_THM_CALL
5728                           || r_type == (unsigned int) R_ARM_THM_XPC22))
5729                     {
5730                       bfd_vma from = section->output_section->vma
5731                                      + section->output_offset
5732                                      + irela->r_offset;
5733
5734                       if ((from & 0xfff) == 0xffe)
5735                         {
5736                           /* Found a candidate.  Note we haven't checked the
5737                              destination is within 4K here: if we do so (and
5738                              don't create an entry in a8_relocs) we can't tell
5739                              that a branch should have been relocated when
5740                              scanning later.  */
5741                           if (num_a8_relocs == a8_reloc_table_size)
5742                             {
5743                               a8_reloc_table_size *= 2;
5744                               a8_relocs = (struct a8_erratum_reloc *)
5745                                   bfd_realloc (a8_relocs,
5746                                                sizeof (struct a8_erratum_reloc)
5747                                                * a8_reloc_table_size);
5748                             }
5749
5750                           a8_relocs[num_a8_relocs].from = from;
5751                           a8_relocs[num_a8_relocs].destination = destination;
5752                           a8_relocs[num_a8_relocs].r_type = r_type;
5753                           a8_relocs[num_a8_relocs].branch_type = branch_type;
5754                           a8_relocs[num_a8_relocs].sym_name = sym_name;
5755                           a8_relocs[num_a8_relocs].non_a8_stub = created_stub;
5756                           a8_relocs[num_a8_relocs].hash = hash;
5757
5758                           num_a8_relocs++;
5759                         }
5760                     }
5761                 }
5762
5763               /* We're done with the internal relocs, free them.  */
5764               if (elf_section_data (section)->relocs == NULL)
5765                 free (internal_relocs);
5766             }
5767
5768           if (htab->fix_cortex_a8)
5769             {
5770               /* Sort relocs which might apply to Cortex-A8 erratum.  */
5771               qsort (a8_relocs, num_a8_relocs,
5772                      sizeof (struct a8_erratum_reloc),
5773                      &a8_reloc_compare);
5774
5775               /* Scan for branches which might trigger Cortex-A8 erratum.  */
5776               if (cortex_a8_erratum_scan (input_bfd, info, &a8_fixes,
5777                                           &num_a8_fixes, &a8_fix_table_size,
5778                                           a8_relocs, num_a8_relocs,
5779                                           prev_num_a8_fixes, &stub_changed)
5780                   != 0)
5781                 goto error_ret_free_local;
5782             }
5783
5784           if (local_syms != NULL
5785               && symtab_hdr->contents != (unsigned char *) local_syms)
5786             {
5787               if (!info->keep_memory)
5788                 free (local_syms);
5789               else
5790                 symtab_hdr->contents = (unsigned char *) local_syms;
5791             }
5792         }
5793
5794       if (prev_num_a8_fixes != num_a8_fixes)
5795         stub_changed = TRUE;
5796
5797       if (!stub_changed)
5798         break;
5799
5800       /* OK, we've added some stubs.  Find out the new size of the
5801          stub sections.  */
5802       for (stub_sec = htab->stub_bfd->sections;
5803            stub_sec != NULL;
5804            stub_sec = stub_sec->next)
5805         {
5806           /* Ignore non-stub sections.  */
5807           if (!strstr (stub_sec->name, STUB_SUFFIX))
5808             continue;
5809
5810           stub_sec->size = 0;
5811         }
5812
5813       /* Compute stub section size, considering padding.  */
5814       bfd_hash_traverse (&htab->stub_hash_table, arm_size_one_stub, htab);
5815       for (stub_type = arm_stub_none + 1; stub_type < max_stub_type;
5816            stub_type++)
5817         {
5818           int size, padding;
5819           asection **stub_sec_p;
5820
5821           padding = arm_dedicated_stub_section_padding (stub_type);
5822           stub_sec_p = arm_dedicated_stub_input_section_ptr (htab, stub_type);
5823           /* Skip if no stub input section or no stub section padding
5824              required.  */
5825           if ((stub_sec_p != NULL && *stub_sec_p == NULL) || padding == 0)
5826             continue;
5827           /* Stub section padding required but no dedicated section.  */
5828           BFD_ASSERT (stub_sec_p);
5829
5830           size = (*stub_sec_p)->size;
5831           size = (size + padding - 1) & ~(padding - 1);
5832           (*stub_sec_p)->size = size;
5833         }
5834
5835       /* Add Cortex-A8 erratum veneers to stub section sizes too.  */
5836       if (htab->fix_cortex_a8)
5837         for (i = 0; i < num_a8_fixes; i++)
5838           {
5839             stub_sec = elf32_arm_create_or_find_stub_sec (NULL,
5840                          a8_fixes[i].section, htab, a8_fixes[i].stub_type);
5841
5842             if (stub_sec == NULL)
5843               return FALSE;
5844
5845             stub_sec->size
5846               += find_stub_size_and_template (a8_fixes[i].stub_type, NULL,
5847                                               NULL);
5848           }
5849
5850
5851       /* Ask the linker to do its stuff.  */
5852       (*htab->layout_sections_again) ();
5853     }
5854
5855   /* Add stubs for Cortex-A8 erratum fixes now.  */
5856   if (htab->fix_cortex_a8)
5857     {
5858       for (i = 0; i < num_a8_fixes; i++)
5859         {
5860           struct elf32_arm_stub_hash_entry *stub_entry;
5861           char *stub_name = a8_fixes[i].stub_name;
5862           asection *section = a8_fixes[i].section;
5863           unsigned int section_id = a8_fixes[i].section->id;
5864           asection *link_sec = htab->stub_group[section_id].link_sec;
5865           asection *stub_sec = htab->stub_group[section_id].stub_sec;
5866           const insn_sequence *template_sequence;
5867           int template_size, size = 0;
5868
5869           stub_entry = arm_stub_hash_lookup (&htab->stub_hash_table, stub_name,
5870                                              TRUE, FALSE);
5871           if (stub_entry == NULL)
5872             {
5873               (*_bfd_error_handler) (_("%s: cannot create stub entry %s"),
5874                                      section->owner,
5875                                      stub_name);
5876               return FALSE;
5877             }
5878
5879           stub_entry->stub_sec = stub_sec;
5880           stub_entry->stub_offset = 0;
5881           stub_entry->id_sec = link_sec;
5882           stub_entry->stub_type = a8_fixes[i].stub_type;
5883           stub_entry->source_value = a8_fixes[i].offset;
5884           stub_entry->target_section = a8_fixes[i].section;
5885           stub_entry->target_value = a8_fixes[i].target_offset;
5886           stub_entry->orig_insn = a8_fixes[i].orig_insn;
5887           stub_entry->branch_type = a8_fixes[i].branch_type;
5888
5889           size = find_stub_size_and_template (a8_fixes[i].stub_type,
5890                                               &template_sequence,
5891                                               &template_size);
5892
5893           stub_entry->stub_size = size;
5894           stub_entry->stub_template = template_sequence;
5895           stub_entry->stub_template_size = template_size;
5896         }
5897
5898       /* Stash the Cortex-A8 erratum fix array for use later in
5899          elf32_arm_write_section().  */
5900       htab->a8_erratum_fixes = a8_fixes;
5901       htab->num_a8_erratum_fixes = num_a8_fixes;
5902     }
5903   else
5904     {
5905       htab->a8_erratum_fixes = NULL;
5906       htab->num_a8_erratum_fixes = 0;
5907     }
5908   return TRUE;
5909 }
5910
5911 /* Build all the stubs associated with the current output file.  The
5912    stubs are kept in a hash table attached to the main linker hash
5913    table.  We also set up the .plt entries for statically linked PIC
5914    functions here.  This function is called via arm_elf_finish in the
5915    linker.  */
5916
5917 bfd_boolean
5918 elf32_arm_build_stubs (struct bfd_link_info *info)
5919 {
5920   asection *stub_sec;
5921   struct bfd_hash_table *table;
5922   struct elf32_arm_link_hash_table *htab;
5923
5924   htab = elf32_arm_hash_table (info);
5925   if (htab == NULL)
5926     return FALSE;
5927
5928   for (stub_sec = htab->stub_bfd->sections;
5929        stub_sec != NULL;
5930        stub_sec = stub_sec->next)
5931     {
5932       bfd_size_type size;
5933
5934       /* Ignore non-stub sections.  */
5935       if (!strstr (stub_sec->name, STUB_SUFFIX))
5936         continue;
5937
5938       /* Allocate memory to hold the linker stubs.  Zeroing the stub sections
5939          must at least be done for stub section requiring padding.  */
5940       size = stub_sec->size;
5941       stub_sec->contents = (unsigned char *) bfd_zalloc (htab->stub_bfd, size);
5942       if (stub_sec->contents == NULL && size != 0)
5943         return FALSE;
5944       stub_sec->size = 0;
5945     }
5946
5947   /* Build the stubs as directed by the stub hash table.  */
5948   table = &htab->stub_hash_table;
5949   bfd_hash_traverse (table, arm_build_one_stub, info);
5950   if (htab->fix_cortex_a8)
5951     {
5952       /* Place the cortex a8 stubs last.  */
5953       htab->fix_cortex_a8 = -1;
5954       bfd_hash_traverse (table, arm_build_one_stub, info);
5955     }
5956
5957   return TRUE;
5958 }
5959
5960 /* Locate the Thumb encoded calling stub for NAME.  */
5961
5962 static struct elf_link_hash_entry *
5963 find_thumb_glue (struct bfd_link_info *link_info,
5964                  const char *name,
5965                  char **error_message)
5966 {
5967   char *tmp_name;
5968   struct elf_link_hash_entry *hash;
5969   struct elf32_arm_link_hash_table *hash_table;
5970
5971   /* We need a pointer to the armelf specific hash table.  */
5972   hash_table = elf32_arm_hash_table (link_info);
5973   if (hash_table == NULL)
5974     return NULL;
5975
5976   tmp_name = (char *) bfd_malloc ((bfd_size_type) strlen (name)
5977                                   + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1);
5978
5979   BFD_ASSERT (tmp_name);
5980
5981   sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name);
5982
5983   hash = elf_link_hash_lookup
5984     (&(hash_table)->root, tmp_name, FALSE, FALSE, TRUE);
5985
5986   if (hash == NULL
5987       && asprintf (error_message, _("unable to find THUMB glue '%s' for '%s'"),
5988                    tmp_name, name) == -1)
5989     *error_message = (char *) bfd_errmsg (bfd_error_system_call);
5990
5991   free (tmp_name);
5992
5993   return hash;
5994 }
5995
5996 /* Locate the ARM encoded calling stub for NAME.  */
5997
5998 static struct elf_link_hash_entry *
5999 find_arm_glue (struct bfd_link_info *link_info,
6000                const char *name,
6001                char **error_message)
6002 {
6003   char *tmp_name;
6004   struct elf_link_hash_entry *myh;
6005   struct elf32_arm_link_hash_table *hash_table;
6006
6007   /* We need a pointer to the elfarm specific hash table.  */
6008   hash_table = elf32_arm_hash_table (link_info);
6009   if (hash_table == NULL)
6010     return NULL;
6011
6012   tmp_name = (char *) bfd_malloc ((bfd_size_type) strlen (name)
6013                                   + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1);
6014
6015   BFD_ASSERT (tmp_name);
6016
6017   sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
6018
6019   myh = elf_link_hash_lookup
6020     (&(hash_table)->root, tmp_name, FALSE, FALSE, TRUE);
6021
6022   if (myh == NULL
6023       && asprintf (error_message, _("unable to find ARM glue '%s' for '%s'"),
6024                    tmp_name, name) == -1)
6025     *error_message = (char *) bfd_errmsg (bfd_error_system_call);
6026
6027   free (tmp_name);
6028
6029   return myh;
6030 }
6031
6032 /* ARM->Thumb glue (static images):
6033
6034    .arm
6035    __func_from_arm:
6036    ldr r12, __func_addr
6037    bx  r12
6038    __func_addr:
6039    .word func    @ behave as if you saw a ARM_32 reloc.
6040
6041    (v5t static images)
6042    .arm
6043    __func_from_arm:
6044    ldr pc, __func_addr
6045    __func_addr:
6046    .word func    @ behave as if you saw a ARM_32 reloc.
6047
6048    (relocatable images)
6049    .arm
6050    __func_from_arm:
6051    ldr r12, __func_offset
6052    add r12, r12, pc
6053    bx  r12
6054    __func_offset:
6055    .word func - .   */
6056
6057 #define ARM2THUMB_STATIC_GLUE_SIZE 12
6058 static const insn32 a2t1_ldr_insn = 0xe59fc000;
6059 static const insn32 a2t2_bx_r12_insn = 0xe12fff1c;
6060 static const insn32 a2t3_func_addr_insn = 0x00000001;
6061
6062 #define ARM2THUMB_V5_STATIC_GLUE_SIZE 8
6063 static const insn32 a2t1v5_ldr_insn = 0xe51ff004;
6064 static const insn32 a2t2v5_func_addr_insn = 0x00000001;
6065
6066 #define ARM2THUMB_PIC_GLUE_SIZE 16
6067 static const insn32 a2t1p_ldr_insn = 0xe59fc004;
6068 static const insn32 a2t2p_add_pc_insn = 0xe08cc00f;
6069 static const insn32 a2t3p_bx_r12_insn = 0xe12fff1c;
6070
6071 /* Thumb->ARM:                          Thumb->(non-interworking aware) ARM
6072
6073      .thumb                             .thumb
6074      .align 2                           .align 2
6075  __func_from_thumb:                 __func_from_thumb:
6076      bx pc                              push {r6, lr}
6077      nop                                ldr  r6, __func_addr
6078      .arm                               mov  lr, pc
6079      b func                             bx   r6
6080                                         .arm
6081                                     ;; back_to_thumb
6082                                         ldmia r13! {r6, lr}
6083                                         bx    lr
6084                                     __func_addr:
6085                                         .word        func  */
6086
6087 #define THUMB2ARM_GLUE_SIZE 8
6088 static const insn16 t2a1_bx_pc_insn = 0x4778;
6089 static const insn16 t2a2_noop_insn = 0x46c0;
6090 static const insn32 t2a3_b_insn = 0xea000000;
6091
6092 #define VFP11_ERRATUM_VENEER_SIZE 8
6093 #define STM32L4XX_ERRATUM_LDM_VENEER_SIZE 16
6094 #define STM32L4XX_ERRATUM_VLDM_VENEER_SIZE 24
6095
6096 #define ARM_BX_VENEER_SIZE 12
6097 static const insn32 armbx1_tst_insn = 0xe3100001;
6098 static const insn32 armbx2_moveq_insn = 0x01a0f000;
6099 static const insn32 armbx3_bx_insn = 0xe12fff10;
6100
6101 #ifndef ELFARM_NABI_C_INCLUDED
6102 static void
6103 arm_allocate_glue_section_space (bfd * abfd, bfd_size_type size, const char * name)
6104 {
6105   asection * s;
6106   bfd_byte * contents;
6107
6108   if (size == 0)
6109     {
6110       /* Do not include empty glue sections in the output.  */
6111       if (abfd != NULL)
6112         {
6113           s = bfd_get_linker_section (abfd, name);
6114           if (s != NULL)
6115             s->flags |= SEC_EXCLUDE;
6116         }
6117       return;
6118     }
6119
6120   BFD_ASSERT (abfd != NULL);
6121
6122   s = bfd_get_linker_section (abfd, name);
6123   BFD_ASSERT (s != NULL);
6124
6125   contents = (bfd_byte *) bfd_alloc (abfd, size);
6126
6127   BFD_ASSERT (s->size == size);
6128   s->contents = contents;
6129 }
6130
6131 bfd_boolean
6132 bfd_elf32_arm_allocate_interworking_sections (struct bfd_link_info * info)
6133 {
6134   struct elf32_arm_link_hash_table * globals;
6135
6136   globals = elf32_arm_hash_table (info);
6137   BFD_ASSERT (globals != NULL);
6138
6139   arm_allocate_glue_section_space (globals->bfd_of_glue_owner,
6140                                    globals->arm_glue_size,
6141                                    ARM2THUMB_GLUE_SECTION_NAME);
6142
6143   arm_allocate_glue_section_space (globals->bfd_of_glue_owner,
6144                                    globals->thumb_glue_size,
6145                                    THUMB2ARM_GLUE_SECTION_NAME);
6146
6147   arm_allocate_glue_section_space (globals->bfd_of_glue_owner,
6148                                    globals->vfp11_erratum_glue_size,
6149                                    VFP11_ERRATUM_VENEER_SECTION_NAME);
6150
6151   arm_allocate_glue_section_space (globals->bfd_of_glue_owner,
6152                                    globals->stm32l4xx_erratum_glue_size,
6153                                    STM32L4XX_ERRATUM_VENEER_SECTION_NAME);
6154
6155   arm_allocate_glue_section_space (globals->bfd_of_glue_owner,
6156                                    globals->bx_glue_size,
6157                                    ARM_BX_GLUE_SECTION_NAME);
6158
6159   return TRUE;
6160 }
6161
6162 /* Allocate space and symbols for calling a Thumb function from Arm mode.
6163    returns the symbol identifying the stub.  */
6164
6165 static struct elf_link_hash_entry *
6166 record_arm_to_thumb_glue (struct bfd_link_info * link_info,
6167                           struct elf_link_hash_entry * h)
6168 {
6169   const char * name = h->root.root.string;
6170   asection * s;
6171   char * tmp_name;
6172   struct elf_link_hash_entry * myh;
6173   struct bfd_link_hash_entry * bh;
6174   struct elf32_arm_link_hash_table * globals;
6175   bfd_vma val;
6176   bfd_size_type size;
6177
6178   globals = elf32_arm_hash_table (link_info);
6179   BFD_ASSERT (globals != NULL);
6180   BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
6181
6182   s = bfd_get_linker_section
6183     (globals->bfd_of_glue_owner, ARM2THUMB_GLUE_SECTION_NAME);
6184
6185   BFD_ASSERT (s != NULL);
6186
6187   tmp_name = (char *) bfd_malloc ((bfd_size_type) strlen (name)
6188                                   + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1);
6189
6190   BFD_ASSERT (tmp_name);
6191
6192   sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
6193
6194   myh = elf_link_hash_lookup
6195     (&(globals)->root, tmp_name, FALSE, FALSE, TRUE);
6196
6197   if (myh != NULL)
6198     {
6199       /* We've already seen this guy.  */
6200       free (tmp_name);
6201       return myh;
6202     }
6203
6204   /* The only trick here is using hash_table->arm_glue_size as the value.
6205      Even though the section isn't allocated yet, this is where we will be
6206      putting it.  The +1 on the value marks that the stub has not been
6207      output yet - not that it is a Thumb function.  */
6208   bh = NULL;
6209   val = globals->arm_glue_size + 1;
6210   _bfd_generic_link_add_one_symbol (link_info, globals->bfd_of_glue_owner,
6211                                     tmp_name, BSF_GLOBAL, s, val,
6212                                     NULL, TRUE, FALSE, &bh);
6213
6214   myh = (struct elf_link_hash_entry *) bh;
6215   myh->type = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
6216   myh->forced_local = 1;
6217
6218   free (tmp_name);
6219
6220   if (bfd_link_pic (link_info)
6221       || globals->root.is_relocatable_executable
6222       || globals->pic_veneer)
6223     size = ARM2THUMB_PIC_GLUE_SIZE;
6224   else if (globals->use_blx)
6225     size = ARM2THUMB_V5_STATIC_GLUE_SIZE;
6226   else
6227     size = ARM2THUMB_STATIC_GLUE_SIZE;
6228
6229   s->size += size;
6230   globals->arm_glue_size += size;
6231
6232   return myh;
6233 }
6234
6235 /* Allocate space for ARMv4 BX veneers.  */
6236
6237 static void
6238 record_arm_bx_glue (struct bfd_link_info * link_info, int reg)
6239 {
6240   asection * s;
6241   struct elf32_arm_link_hash_table *globals;
6242   char *tmp_name;
6243   struct elf_link_hash_entry *myh;
6244   struct bfd_link_hash_entry *bh;
6245   bfd_vma val;
6246
6247   /* BX PC does not need a veneer.  */
6248   if (reg == 15)
6249     return;
6250
6251   globals = elf32_arm_hash_table (link_info);
6252   BFD_ASSERT (globals != NULL);
6253   BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
6254
6255   /* Check if this veneer has already been allocated.  */
6256   if (globals->bx_glue_offset[reg])
6257     return;
6258
6259   s = bfd_get_linker_section
6260     (globals->bfd_of_glue_owner, ARM_BX_GLUE_SECTION_NAME);
6261
6262   BFD_ASSERT (s != NULL);
6263
6264   /* Add symbol for veneer.  */
6265   tmp_name = (char *)
6266       bfd_malloc ((bfd_size_type) strlen (ARM_BX_GLUE_ENTRY_NAME) + 1);
6267
6268   BFD_ASSERT (tmp_name);
6269
6270   sprintf (tmp_name, ARM_BX_GLUE_ENTRY_NAME, reg);
6271
6272   myh = elf_link_hash_lookup
6273     (&(globals)->root, tmp_name, FALSE, FALSE, FALSE);
6274
6275   BFD_ASSERT (myh == NULL);
6276
6277   bh = NULL;
6278   val = globals->bx_glue_size;
6279   _bfd_generic_link_add_one_symbol (link_info, globals->bfd_of_glue_owner,
6280                                     tmp_name, BSF_FUNCTION | BSF_LOCAL, s, val,
6281                                     NULL, TRUE, FALSE, &bh);
6282
6283   myh = (struct elf_link_hash_entry *) bh;
6284   myh->type = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
6285   myh->forced_local = 1;
6286
6287   s->size += ARM_BX_VENEER_SIZE;
6288   globals->bx_glue_offset[reg] = globals->bx_glue_size | 2;
6289   globals->bx_glue_size += ARM_BX_VENEER_SIZE;
6290 }
6291
6292
6293 /* Add an entry to the code/data map for section SEC.  */
6294
6295 static void
6296 elf32_arm_section_map_add (asection *sec, char type, bfd_vma vma)
6297 {
6298   struct _arm_elf_section_data *sec_data = elf32_arm_section_data (sec);
6299   unsigned int newidx;
6300
6301   if (sec_data->map == NULL)
6302     {
6303       sec_data->map = (elf32_arm_section_map *)
6304           bfd_malloc (sizeof (elf32_arm_section_map));
6305       sec_data->mapcount = 0;
6306       sec_data->mapsize = 1;
6307     }
6308
6309   newidx = sec_data->mapcount++;
6310
6311   if (sec_data->mapcount > sec_data->mapsize)
6312     {
6313       sec_data->mapsize *= 2;
6314       sec_data->map = (elf32_arm_section_map *)
6315           bfd_realloc_or_free (sec_data->map, sec_data->mapsize
6316                                * sizeof (elf32_arm_section_map));
6317     }
6318
6319   if (sec_data->map)
6320     {
6321       sec_data->map[newidx].vma = vma;
6322       sec_data->map[newidx].type = type;
6323     }
6324 }
6325
6326
6327 /* Record information about a VFP11 denorm-erratum veneer.  Only ARM-mode
6328    veneers are handled for now.  */
6329
6330 static bfd_vma
6331 record_vfp11_erratum_veneer (struct bfd_link_info *link_info,
6332                              elf32_vfp11_erratum_list *branch,
6333                              bfd *branch_bfd,
6334                              asection *branch_sec,
6335                              unsigned int offset)
6336 {
6337   asection *s;
6338   struct elf32_arm_link_hash_table *hash_table;
6339   char *tmp_name;
6340   struct elf_link_hash_entry *myh;
6341   struct bfd_link_hash_entry *bh;
6342   bfd_vma val;
6343   struct _arm_elf_section_data *sec_data;
6344   elf32_vfp11_erratum_list *newerr;
6345
6346   hash_table = elf32_arm_hash_table (link_info);
6347   BFD_ASSERT (hash_table != NULL);
6348   BFD_ASSERT (hash_table->bfd_of_glue_owner != NULL);
6349
6350   s = bfd_get_linker_section
6351     (hash_table->bfd_of_glue_owner, VFP11_ERRATUM_VENEER_SECTION_NAME);
6352
6353   sec_data = elf32_arm_section_data (s);
6354
6355   BFD_ASSERT (s != NULL);
6356
6357   tmp_name = (char *) bfd_malloc ((bfd_size_type) strlen
6358                                   (VFP11_ERRATUM_VENEER_ENTRY_NAME) + 10);
6359
6360   BFD_ASSERT (tmp_name);
6361
6362   sprintf (tmp_name, VFP11_ERRATUM_VENEER_ENTRY_NAME,
6363            hash_table->num_vfp11_fixes);
6364
6365   myh = elf_link_hash_lookup
6366     (&(hash_table)->root, tmp_name, FALSE, FALSE, FALSE);
6367
6368   BFD_ASSERT (myh == NULL);
6369
6370   bh = NULL;
6371   val = hash_table->vfp11_erratum_glue_size;
6372   _bfd_generic_link_add_one_symbol (link_info, hash_table->bfd_of_glue_owner,
6373                                     tmp_name, BSF_FUNCTION | BSF_LOCAL, s, val,
6374                                     NULL, TRUE, FALSE, &bh);
6375
6376   myh = (struct elf_link_hash_entry *) bh;
6377   myh->type = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
6378   myh->forced_local = 1;
6379
6380   /* Link veneer back to calling location.  */
6381   sec_data->erratumcount += 1;
6382   newerr = (elf32_vfp11_erratum_list *)
6383       bfd_zmalloc (sizeof (elf32_vfp11_erratum_list));
6384
6385   newerr->type = VFP11_ERRATUM_ARM_VENEER;
6386   newerr->vma = -1;
6387   newerr->u.v.branch = branch;
6388   newerr->u.v.id = hash_table->num_vfp11_fixes;
6389   branch->u.b.veneer = newerr;
6390
6391   newerr->next = sec_data->erratumlist;
6392   sec_data->erratumlist = newerr;
6393
6394   /* A symbol for the return from the veneer.  */
6395   sprintf (tmp_name, VFP11_ERRATUM_VENEER_ENTRY_NAME "_r",
6396            hash_table->num_vfp11_fixes);
6397
6398   myh = elf_link_hash_lookup
6399     (&(hash_table)->root, tmp_name, FALSE, FALSE, FALSE);
6400
6401   if (myh != NULL)
6402     abort ();
6403
6404   bh = NULL;
6405   val = offset + 4;
6406   _bfd_generic_link_add_one_symbol (link_info, branch_bfd, tmp_name, BSF_LOCAL,
6407                                     branch_sec, val, NULL, TRUE, FALSE, &bh);
6408
6409   myh = (struct elf_link_hash_entry *) bh;
6410   myh->type = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
6411   myh->forced_local = 1;
6412
6413   free (tmp_name);
6414
6415   /* Generate a mapping symbol for the veneer section, and explicitly add an
6416      entry for that symbol to the code/data map for the section.  */
6417   if (hash_table->vfp11_erratum_glue_size == 0)
6418     {
6419       bh = NULL;
6420       /* FIXME: Creates an ARM symbol.  Thumb mode will need attention if it
6421          ever requires this erratum fix.  */
6422       _bfd_generic_link_add_one_symbol (link_info,
6423                                         hash_table->bfd_of_glue_owner, "$a",
6424                                         BSF_LOCAL, s, 0, NULL,
6425                                         TRUE, FALSE, &bh);
6426
6427       myh = (struct elf_link_hash_entry *) bh;
6428       myh->type = ELF_ST_INFO (STB_LOCAL, STT_NOTYPE);
6429       myh->forced_local = 1;
6430
6431       /* The elf32_arm_init_maps function only cares about symbols from input
6432          BFDs.  We must make a note of this generated mapping symbol
6433          ourselves so that code byteswapping works properly in
6434          elf32_arm_write_section.  */
6435       elf32_arm_section_map_add (s, 'a', 0);
6436     }
6437
6438   s->size += VFP11_ERRATUM_VENEER_SIZE;
6439   hash_table->vfp11_erratum_glue_size += VFP11_ERRATUM_VENEER_SIZE;
6440   hash_table->num_vfp11_fixes++;
6441
6442   /* The offset of the veneer.  */
6443   return val;
6444 }
6445
6446 /* Record information about a STM32L4XX STM erratum veneer.  Only THUMB-mode
6447    veneers need to be handled because used only in Cortex-M.  */
6448
6449 static bfd_vma
6450 record_stm32l4xx_erratum_veneer (struct bfd_link_info *link_info,
6451                                  elf32_stm32l4xx_erratum_list *branch,
6452                                  bfd *branch_bfd,
6453                                  asection *branch_sec,
6454                                  unsigned int offset,
6455                                  bfd_size_type veneer_size)
6456 {
6457   asection *s;
6458   struct elf32_arm_link_hash_table *hash_table;
6459   char *tmp_name;
6460   struct elf_link_hash_entry *myh;
6461   struct bfd_link_hash_entry *bh;
6462   bfd_vma val;
6463   struct _arm_elf_section_data *sec_data;
6464   elf32_stm32l4xx_erratum_list *newerr;
6465
6466   hash_table = elf32_arm_hash_table (link_info);
6467   BFD_ASSERT (hash_table != NULL);
6468   BFD_ASSERT (hash_table->bfd_of_glue_owner != NULL);
6469
6470   s = bfd_get_linker_section
6471     (hash_table->bfd_of_glue_owner, STM32L4XX_ERRATUM_VENEER_SECTION_NAME);
6472
6473   BFD_ASSERT (s != NULL);
6474
6475   sec_data = elf32_arm_section_data (s);
6476
6477   tmp_name = (char *) bfd_malloc ((bfd_size_type) strlen
6478                                   (STM32L4XX_ERRATUM_VENEER_ENTRY_NAME) + 10);
6479
6480   BFD_ASSERT (tmp_name);
6481
6482   sprintf (tmp_name, STM32L4XX_ERRATUM_VENEER_ENTRY_NAME,
6483            hash_table->num_stm32l4xx_fixes);
6484
6485   myh = elf_link_hash_lookup
6486     (&(hash_table)->root, tmp_name, FALSE, FALSE, FALSE);
6487
6488   BFD_ASSERT (myh == NULL);
6489
6490   bh = NULL;
6491   val = hash_table->stm32l4xx_erratum_glue_size;
6492   _bfd_generic_link_add_one_symbol (link_info, hash_table->bfd_of_glue_owner,
6493                                     tmp_name, BSF_FUNCTION | BSF_LOCAL, s, val,
6494                                     NULL, TRUE, FALSE, &bh);
6495
6496   myh = (struct elf_link_hash_entry *) bh;
6497   myh->type = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
6498   myh->forced_local = 1;
6499
6500   /* Link veneer back to calling location.  */
6501   sec_data->stm32l4xx_erratumcount += 1;
6502   newerr = (elf32_stm32l4xx_erratum_list *)
6503       bfd_zmalloc (sizeof (elf32_stm32l4xx_erratum_list));
6504
6505   newerr->type = STM32L4XX_ERRATUM_VENEER;
6506   newerr->vma = -1;
6507   newerr->u.v.branch = branch;
6508   newerr->u.v.id = hash_table->num_stm32l4xx_fixes;
6509   branch->u.b.veneer = newerr;
6510
6511   newerr->next = sec_data->stm32l4xx_erratumlist;
6512   sec_data->stm32l4xx_erratumlist = newerr;
6513
6514   /* A symbol for the return from the veneer.  */
6515   sprintf (tmp_name, STM32L4XX_ERRATUM_VENEER_ENTRY_NAME "_r",
6516            hash_table->num_stm32l4xx_fixes);
6517
6518   myh = elf_link_hash_lookup
6519     (&(hash_table)->root, tmp_name, FALSE, FALSE, FALSE);
6520
6521   if (myh != NULL)
6522     abort ();
6523
6524   bh = NULL;
6525   val = offset + 4;
6526   _bfd_generic_link_add_one_symbol (link_info, branch_bfd, tmp_name, BSF_LOCAL,
6527                                     branch_sec, val, NULL, TRUE, FALSE, &bh);
6528
6529   myh = (struct elf_link_hash_entry *) bh;
6530   myh->type = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
6531   myh->forced_local = 1;
6532
6533   free (tmp_name);
6534
6535   /* Generate a mapping symbol for the veneer section, and explicitly add an
6536      entry for that symbol to the code/data map for the section.  */
6537   if (hash_table->stm32l4xx_erratum_glue_size == 0)
6538     {
6539       bh = NULL;
6540       /* Creates a THUMB symbol since there is no other choice.  */
6541       _bfd_generic_link_add_one_symbol (link_info,
6542                                         hash_table->bfd_of_glue_owner, "$t",
6543                                         BSF_LOCAL, s, 0, NULL,
6544                                         TRUE, FALSE, &bh);
6545
6546       myh = (struct elf_link_hash_entry *) bh;
6547       myh->type = ELF_ST_INFO (STB_LOCAL, STT_NOTYPE);
6548       myh->forced_local = 1;
6549
6550       /* The elf32_arm_init_maps function only cares about symbols from input
6551          BFDs.  We must make a note of this generated mapping symbol
6552          ourselves so that code byteswapping works properly in
6553          elf32_arm_write_section.  */
6554       elf32_arm_section_map_add (s, 't', 0);
6555     }
6556
6557   s->size += veneer_size;
6558   hash_table->stm32l4xx_erratum_glue_size += veneer_size;
6559   hash_table->num_stm32l4xx_fixes++;
6560
6561   /* The offset of the veneer.  */
6562   return val;
6563 }
6564
6565 #define ARM_GLUE_SECTION_FLAGS \
6566   (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_CODE \
6567    | SEC_READONLY | SEC_LINKER_CREATED)
6568
6569 /* Create a fake section for use by the ARM backend of the linker.  */
6570
6571 static bfd_boolean
6572 arm_make_glue_section (bfd * abfd, const char * name)
6573 {
6574   asection * sec;
6575
6576   sec = bfd_get_linker_section (abfd, name);
6577   if (sec != NULL)
6578     /* Already made.  */
6579     return TRUE;
6580
6581   sec = bfd_make_section_anyway_with_flags (abfd, name, ARM_GLUE_SECTION_FLAGS);
6582
6583   if (sec == NULL
6584       || !bfd_set_section_alignment (abfd, sec, 2))
6585     return FALSE;
6586
6587   /* Set the gc mark to prevent the section from being removed by garbage
6588      collection, despite the fact that no relocs refer to this section.  */
6589   sec->gc_mark = 1;
6590
6591   return TRUE;
6592 }
6593
6594 /* Set size of .plt entries.  This function is called from the
6595    linker scripts in ld/emultempl/{armelf}.em.  */
6596
6597 void
6598 bfd_elf32_arm_use_long_plt (void)
6599 {
6600   elf32_arm_use_long_plt_entry = TRUE;
6601 }
6602
6603 /* Add the glue sections to ABFD.  This function is called from the
6604    linker scripts in ld/emultempl/{armelf}.em.  */
6605
6606 bfd_boolean
6607 bfd_elf32_arm_add_glue_sections_to_bfd (bfd *abfd,
6608                                         struct bfd_link_info *info)
6609 {
6610   struct elf32_arm_link_hash_table *globals = elf32_arm_hash_table (info);
6611   bfd_boolean dostm32l4xx = globals
6612     && globals->stm32l4xx_fix != BFD_ARM_STM32L4XX_FIX_NONE;
6613   bfd_boolean addglue;
6614
6615   /* If we are only performing a partial
6616      link do not bother adding the glue.  */
6617   if (bfd_link_relocatable (info))
6618     return TRUE;
6619
6620   addglue = arm_make_glue_section (abfd, ARM2THUMB_GLUE_SECTION_NAME)
6621     && arm_make_glue_section (abfd, THUMB2ARM_GLUE_SECTION_NAME)
6622     && arm_make_glue_section (abfd, VFP11_ERRATUM_VENEER_SECTION_NAME)
6623     && arm_make_glue_section (abfd, ARM_BX_GLUE_SECTION_NAME);
6624
6625   if (!dostm32l4xx)
6626     return addglue;
6627
6628   return addglue
6629     && arm_make_glue_section (abfd, STM32L4XX_ERRATUM_VENEER_SECTION_NAME);
6630 }
6631
6632 /* Mark output sections of veneers needing a dedicated one with SEC_KEEP.  This
6633    ensures they are not marked for deletion by
6634    strip_excluded_output_sections () when veneers are going to be created
6635    later.  Not doing so would trigger assert on empty section size in
6636    lang_size_sections_1 ().  */
6637
6638 void
6639 bfd_elf32_arm_keep_private_stub_output_sections (struct bfd_link_info *info)
6640 {
6641   enum elf32_arm_stub_type stub_type;
6642
6643   /* If we are only performing a partial
6644      link do not bother adding the glue.  */
6645   if (bfd_link_relocatable (info))
6646     return;
6647
6648   for (stub_type = arm_stub_none + 1; stub_type < max_stub_type; stub_type++)
6649     {
6650       asection *out_sec;
6651       const char *out_sec_name;
6652
6653       if (!arm_dedicated_stub_output_section_required (stub_type))
6654         continue;
6655
6656      out_sec_name = arm_dedicated_stub_output_section_name (stub_type);
6657      out_sec = bfd_get_section_by_name (info->output_bfd, out_sec_name);
6658      if (out_sec != NULL)
6659         out_sec->flags |= SEC_KEEP;
6660     }
6661 }
6662
6663 /* Select a BFD to be used to hold the sections used by the glue code.
6664    This function is called from the linker scripts in ld/emultempl/
6665    {armelf/pe}.em.  */
6666
6667 bfd_boolean
6668 bfd_elf32_arm_get_bfd_for_interworking (bfd *abfd, struct bfd_link_info *info)
6669 {
6670   struct elf32_arm_link_hash_table *globals;
6671
6672   /* If we are only performing a partial link
6673      do not bother getting a bfd to hold the glue.  */
6674   if (bfd_link_relocatable (info))
6675     return TRUE;
6676
6677   /* Make sure we don't attach the glue sections to a dynamic object.  */
6678   BFD_ASSERT (!(abfd->flags & DYNAMIC));
6679
6680   globals = elf32_arm_hash_table (info);
6681   BFD_ASSERT (globals != NULL);
6682
6683   if (globals->bfd_of_glue_owner != NULL)
6684     return TRUE;
6685
6686   /* Save the bfd for later use.  */
6687   globals->bfd_of_glue_owner = abfd;
6688
6689   return TRUE;
6690 }
6691
6692 static void
6693 check_use_blx (struct elf32_arm_link_hash_table *globals)
6694 {
6695   int cpu_arch;
6696
6697   cpu_arch = bfd_elf_get_obj_attr_int (globals->obfd, OBJ_ATTR_PROC,
6698                                        Tag_CPU_arch);
6699
6700   if (globals->fix_arm1176)
6701     {
6702       if (cpu_arch == TAG_CPU_ARCH_V6T2 || cpu_arch > TAG_CPU_ARCH_V6K)
6703         globals->use_blx = 1;
6704     }
6705   else
6706     {
6707       if (cpu_arch > TAG_CPU_ARCH_V4T)
6708         globals->use_blx = 1;
6709     }
6710 }
6711
6712 bfd_boolean
6713 bfd_elf32_arm_process_before_allocation (bfd *abfd,
6714                                          struct bfd_link_info *link_info)
6715 {
6716   Elf_Internal_Shdr *symtab_hdr;
6717   Elf_Internal_Rela *internal_relocs = NULL;
6718   Elf_Internal_Rela *irel, *irelend;
6719   bfd_byte *contents = NULL;
6720
6721   asection *sec;
6722   struct elf32_arm_link_hash_table *globals;
6723
6724   /* If we are only performing a partial link do not bother
6725      to construct any glue.  */
6726   if (bfd_link_relocatable (link_info))
6727     return TRUE;
6728
6729   /* Here we have a bfd that is to be included on the link.  We have a
6730      hook to do reloc rummaging, before section sizes are nailed down.  */
6731   globals = elf32_arm_hash_table (link_info);
6732   BFD_ASSERT (globals != NULL);
6733
6734   check_use_blx (globals);
6735
6736   if (globals->byteswap_code && !bfd_big_endian (abfd))
6737     {
6738       _bfd_error_handler (_("%B: BE8 images only valid in big-endian mode."),
6739                           abfd);
6740       return FALSE;
6741     }
6742
6743   /* PR 5398: If we have not decided to include any loadable sections in
6744      the output then we will not have a glue owner bfd.  This is OK, it
6745      just means that there is nothing else for us to do here.  */
6746   if (globals->bfd_of_glue_owner == NULL)
6747     return TRUE;
6748
6749   /* Rummage around all the relocs and map the glue vectors.  */
6750   sec = abfd->sections;
6751
6752   if (sec == NULL)
6753     return TRUE;
6754
6755   for (; sec != NULL; sec = sec->next)
6756     {
6757       if (sec->reloc_count == 0)
6758         continue;
6759
6760       if ((sec->flags & SEC_EXCLUDE) != 0)
6761         continue;
6762
6763       symtab_hdr = & elf_symtab_hdr (abfd);
6764
6765       /* Load the relocs.  */
6766       internal_relocs
6767         = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL, FALSE);
6768
6769       if (internal_relocs == NULL)
6770         goto error_return;
6771
6772       irelend = internal_relocs + sec->reloc_count;
6773       for (irel = internal_relocs; irel < irelend; irel++)
6774         {
6775           long r_type;
6776           unsigned long r_index;
6777
6778           struct elf_link_hash_entry *h;
6779
6780           r_type = ELF32_R_TYPE (irel->r_info);
6781           r_index = ELF32_R_SYM (irel->r_info);
6782
6783           /* These are the only relocation types we care about.  */
6784           if (   r_type != R_ARM_PC24
6785               && (r_type != R_ARM_V4BX || globals->fix_v4bx < 2))
6786             continue;
6787
6788           /* Get the section contents if we haven't done so already.  */
6789           if (contents == NULL)
6790             {
6791               /* Get cached copy if it exists.  */
6792               if (elf_section_data (sec)->this_hdr.contents != NULL)
6793                 contents = elf_section_data (sec)->this_hdr.contents;
6794               else
6795                 {
6796                   /* Go get them off disk.  */
6797                   if (! bfd_malloc_and_get_section (abfd, sec, &contents))
6798                     goto error_return;
6799                 }
6800             }
6801
6802           if (r_type == R_ARM_V4BX)
6803             {
6804               int reg;
6805
6806               reg = bfd_get_32 (abfd, contents + irel->r_offset) & 0xf;
6807               record_arm_bx_glue (link_info, reg);
6808               continue;
6809             }
6810
6811           /* If the relocation is not against a symbol it cannot concern us.  */
6812           h = NULL;
6813
6814           /* We don't care about local symbols.  */
6815           if (r_index < symtab_hdr->sh_info)
6816             continue;
6817
6818           /* This is an external symbol.  */
6819           r_index -= symtab_hdr->sh_info;
6820           h = (struct elf_link_hash_entry *)
6821             elf_sym_hashes (abfd)[r_index];
6822
6823           /* If the relocation is against a static symbol it must be within
6824              the current section and so cannot be a cross ARM/Thumb relocation.  */
6825           if (h == NULL)
6826             continue;
6827
6828           /* If the call will go through a PLT entry then we do not need
6829              glue.  */
6830           if (globals->root.splt != NULL && h->plt.offset != (bfd_vma) -1)
6831             continue;
6832
6833           switch (r_type)
6834             {
6835             case R_ARM_PC24:
6836               /* This one is a call from arm code.  We need to look up
6837                  the target of the call.  If it is a thumb target, we
6838                  insert glue.  */
6839               if (ARM_GET_SYM_BRANCH_TYPE (h->target_internal)
6840                   == ST_BRANCH_TO_THUMB)
6841                 record_arm_to_thumb_glue (link_info, h);
6842               break;
6843
6844             default:
6845               abort ();
6846             }
6847         }
6848
6849       if (contents != NULL
6850           && elf_section_data (sec)->this_hdr.contents != contents)
6851         free (contents);
6852       contents = NULL;
6853
6854       if (internal_relocs != NULL
6855           && elf_section_data (sec)->relocs != internal_relocs)
6856         free (internal_relocs);
6857       internal_relocs = NULL;
6858     }
6859
6860   return TRUE;
6861
6862 error_return:
6863   if (contents != NULL
6864       && elf_section_data (sec)->this_hdr.contents != contents)
6865     free (contents);
6866   if (internal_relocs != NULL
6867       && elf_section_data (sec)->relocs != internal_relocs)
6868     free (internal_relocs);
6869
6870   return FALSE;
6871 }
6872 #endif
6873
6874
6875 /* Initialise maps of ARM/Thumb/data for input BFDs.  */
6876
6877 void
6878 bfd_elf32_arm_init_maps (bfd *abfd)
6879 {
6880   Elf_Internal_Sym *isymbuf;
6881   Elf_Internal_Shdr *hdr;
6882   unsigned int i, localsyms;
6883
6884   /* PR 7093: Make sure that we are dealing with an arm elf binary.  */
6885   if (! is_arm_elf (abfd))
6886     return;
6887
6888   if ((abfd->flags & DYNAMIC) != 0)
6889     return;
6890
6891   hdr = & elf_symtab_hdr (abfd);
6892   localsyms = hdr->sh_info;
6893
6894   /* Obtain a buffer full of symbols for this BFD. The hdr->sh_info field
6895      should contain the number of local symbols, which should come before any
6896      global symbols.  Mapping symbols are always local.  */
6897   isymbuf = bfd_elf_get_elf_syms (abfd, hdr, localsyms, 0, NULL, NULL,
6898                                   NULL);
6899
6900   /* No internal symbols read?  Skip this BFD.  */
6901   if (isymbuf == NULL)
6902     return;
6903
6904   for (i = 0; i < localsyms; i++)
6905     {
6906       Elf_Internal_Sym *isym = &isymbuf[i];
6907       asection *sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
6908       const char *name;
6909
6910       if (sec != NULL
6911           && ELF_ST_BIND (isym->st_info) == STB_LOCAL)
6912         {
6913           name = bfd_elf_string_from_elf_section (abfd,
6914             hdr->sh_link, isym->st_name);
6915
6916           if (bfd_is_arm_special_symbol_name (name,
6917                                               BFD_ARM_SPECIAL_SYM_TYPE_MAP))
6918             elf32_arm_section_map_add (sec, name[1], isym->st_value);
6919         }
6920     }
6921 }
6922
6923
6924 /* Auto-select enabling of Cortex-A8 erratum fix if the user didn't explicitly
6925    say what they wanted.  */
6926
6927 void
6928 bfd_elf32_arm_set_cortex_a8_fix (bfd *obfd, struct bfd_link_info *link_info)
6929 {
6930   struct elf32_arm_link_hash_table *globals = elf32_arm_hash_table (link_info);
6931   obj_attribute *out_attr = elf_known_obj_attributes_proc (obfd);
6932
6933   if (globals == NULL)
6934     return;
6935
6936   if (globals->fix_cortex_a8 == -1)
6937     {
6938       /* Turn on Cortex-A8 erratum workaround for ARMv7-A.  */
6939       if (out_attr[Tag_CPU_arch].i == TAG_CPU_ARCH_V7
6940           && (out_attr[Tag_CPU_arch_profile].i == 'A'
6941               || out_attr[Tag_CPU_arch_profile].i == 0))
6942         globals->fix_cortex_a8 = 1;
6943       else
6944         globals->fix_cortex_a8 = 0;
6945     }
6946 }
6947
6948
6949 void
6950 bfd_elf32_arm_set_vfp11_fix (bfd *obfd, struct bfd_link_info *link_info)
6951 {
6952   struct elf32_arm_link_hash_table *globals = elf32_arm_hash_table (link_info);
6953   obj_attribute *out_attr = elf_known_obj_attributes_proc (obfd);
6954
6955   if (globals == NULL)
6956     return;
6957   /* We assume that ARMv7+ does not need the VFP11 denorm erratum fix.  */
6958   if (out_attr[Tag_CPU_arch].i >= TAG_CPU_ARCH_V7)
6959     {
6960       switch (globals->vfp11_fix)
6961         {
6962         case BFD_ARM_VFP11_FIX_DEFAULT:
6963         case BFD_ARM_VFP11_FIX_NONE:
6964           globals->vfp11_fix = BFD_ARM_VFP11_FIX_NONE;
6965           break;
6966
6967         default:
6968           /* Give a warning, but do as the user requests anyway.  */
6969           (*_bfd_error_handler) (_("%B: warning: selected VFP11 erratum "
6970             "workaround is not necessary for target architecture"), obfd);
6971         }
6972     }
6973   else if (globals->vfp11_fix == BFD_ARM_VFP11_FIX_DEFAULT)
6974     /* For earlier architectures, we might need the workaround, but do not
6975        enable it by default.  If users is running with broken hardware, they
6976        must enable the erratum fix explicitly.  */
6977     globals->vfp11_fix = BFD_ARM_VFP11_FIX_NONE;
6978 }
6979
6980 void
6981 bfd_elf32_arm_set_stm32l4xx_fix (bfd *obfd, struct bfd_link_info *link_info)
6982 {
6983   struct elf32_arm_link_hash_table *globals = elf32_arm_hash_table (link_info);
6984   obj_attribute *out_attr = elf_known_obj_attributes_proc (obfd);
6985
6986   if (globals == NULL)
6987     return;
6988
6989   /* We assume only Cortex-M4 may require the fix.  */
6990   if (out_attr[Tag_CPU_arch].i != TAG_CPU_ARCH_V7E_M
6991       || out_attr[Tag_CPU_arch_profile].i != 'M')
6992     {
6993       if (globals->stm32l4xx_fix != BFD_ARM_STM32L4XX_FIX_NONE)
6994         /* Give a warning, but do as the user requests anyway.  */
6995         (*_bfd_error_handler)
6996           (_("%B: warning: selected STM32L4XX erratum "
6997              "workaround is not necessary for target architecture"), obfd);
6998     }
6999 }
7000
7001 enum bfd_arm_vfp11_pipe
7002 {
7003   VFP11_FMAC,
7004   VFP11_LS,
7005   VFP11_DS,
7006   VFP11_BAD
7007 };
7008
7009 /* Return a VFP register number.  This is encoded as RX:X for single-precision
7010    registers, or X:RX for double-precision registers, where RX is the group of
7011    four bits in the instruction encoding and X is the single extension bit.
7012    RX and X fields are specified using their lowest (starting) bit.  The return
7013    value is:
7014
7015      0...31: single-precision registers s0...s31
7016      32...63: double-precision registers d0...d31.
7017
7018    Although X should be zero for VFP11 (encoding d0...d15 only), we might
7019    encounter VFP3 instructions, so we allow the full range for DP registers.  */
7020
7021 static unsigned int
7022 bfd_arm_vfp11_regno (unsigned int insn, bfd_boolean is_double, unsigned int rx,
7023                      unsigned int x)
7024 {
7025   if (is_double)
7026     return (((insn >> rx) & 0xf) | (((insn >> x) & 1) << 4)) + 32;
7027   else
7028     return (((insn >> rx) & 0xf) << 1) | ((insn >> x) & 1);
7029 }
7030
7031 /* Set bits in *WMASK according to a register number REG as encoded by
7032    bfd_arm_vfp11_regno().  Ignore d16-d31.  */
7033
7034 static void
7035 bfd_arm_vfp11_write_mask (unsigned int *wmask, unsigned int reg)
7036 {
7037   if (reg < 32)
7038     *wmask |= 1 << reg;
7039   else if (reg < 48)
7040     *wmask |= 3 << ((reg - 32) * 2);
7041 }
7042
7043 /* Return TRUE if WMASK overwrites anything in REGS.  */
7044
7045 static bfd_boolean
7046 bfd_arm_vfp11_antidependency (unsigned int wmask, int *regs, int numregs)
7047 {
7048   int i;
7049
7050   for (i = 0; i < numregs; i++)
7051     {
7052       unsigned int reg = regs[i];
7053
7054       if (reg < 32 && (wmask & (1 << reg)) != 0)
7055         return TRUE;
7056
7057       reg -= 32;
7058
7059       if (reg >= 16)
7060         continue;
7061
7062       if ((wmask & (3 << (reg * 2))) != 0)
7063         return TRUE;
7064     }
7065
7066   return FALSE;
7067 }
7068
7069 /* In this function, we're interested in two things: finding input registers
7070    for VFP data-processing instructions, and finding the set of registers which
7071    arbitrary VFP instructions may write to.  We use a 32-bit unsigned int to
7072    hold the written set, so FLDM etc. are easy to deal with (we're only
7073    interested in 32 SP registers or 16 dp registers, due to the VFP version
7074    implemented by the chip in question).  DP registers are marked by setting
7075    both SP registers in the write mask).  */
7076
7077 static enum bfd_arm_vfp11_pipe
7078 bfd_arm_vfp11_insn_decode (unsigned int insn, unsigned int *destmask, int *regs,
7079                            int *numregs)
7080 {
7081   enum bfd_arm_vfp11_pipe vpipe = VFP11_BAD;
7082   bfd_boolean is_double = ((insn & 0xf00) == 0xb00) ? 1 : 0;
7083
7084   if ((insn & 0x0f000e10) == 0x0e000a00)  /* A data-processing insn.  */
7085     {
7086       unsigned int pqrs;
7087       unsigned int fd = bfd_arm_vfp11_regno (insn, is_double, 12, 22);
7088       unsigned int fm = bfd_arm_vfp11_regno (insn, is_double, 0, 5);
7089
7090       pqrs = ((insn & 0x00800000) >> 20)
7091            | ((insn & 0x00300000) >> 19)
7092            | ((insn & 0x00000040) >> 6);
7093
7094       switch (pqrs)
7095         {
7096         case 0: /* fmac[sd].  */
7097         case 1: /* fnmac[sd].  */
7098         case 2: /* fmsc[sd].  */
7099         case 3: /* fnmsc[sd].  */
7100           vpipe = VFP11_FMAC;
7101           bfd_arm_vfp11_write_mask (destmask, fd);
7102           regs[0] = fd;
7103           regs[1] = bfd_arm_vfp11_regno (insn, is_double, 16, 7);  /* Fn.  */
7104           regs[2] = fm;
7105           *numregs = 3;
7106           break;
7107
7108         case 4: /* fmul[sd].  */
7109         case 5: /* fnmul[sd].  */
7110         case 6: /* fadd[sd].  */
7111         case 7: /* fsub[sd].  */
7112           vpipe = VFP11_FMAC;
7113           goto vfp_binop;
7114
7115         case 8: /* fdiv[sd].  */
7116           vpipe = VFP11_DS;
7117           vfp_binop:
7118           bfd_arm_vfp11_write_mask (destmask, fd);
7119           regs[0] = bfd_arm_vfp11_regno (insn, is_double, 16, 7);   /* Fn.  */
7120           regs[1] = fm;
7121           *numregs = 2;
7122           break;
7123
7124         case 15: /* extended opcode.  */
7125           {
7126             unsigned int extn = ((insn >> 15) & 0x1e)
7127                               | ((insn >> 7) & 1);
7128
7129             switch (extn)
7130               {
7131               case 0: /* fcpy[sd].  */
7132               case 1: /* fabs[sd].  */
7133               case 2: /* fneg[sd].  */
7134               case 8: /* fcmp[sd].  */
7135               case 9: /* fcmpe[sd].  */
7136               case 10: /* fcmpz[sd].  */
7137               case 11: /* fcmpez[sd].  */
7138               case 16: /* fuito[sd].  */
7139               case 17: /* fsito[sd].  */
7140               case 24: /* ftoui[sd].  */
7141               case 25: /* ftouiz[sd].  */
7142               case 26: /* ftosi[sd].  */
7143               case 27: /* ftosiz[sd].  */
7144                 /* These instructions will not bounce due to underflow.  */
7145                 *numregs = 0;
7146                 vpipe = VFP11_FMAC;
7147                 break;
7148
7149               case 3: /* fsqrt[sd].  */
7150                 /* fsqrt cannot underflow, but it can (perhaps) overwrite
7151                    registers to cause the erratum in previous instructions.  */
7152                 bfd_arm_vfp11_write_mask (destmask, fd);
7153                 vpipe = VFP11_DS;
7154                 break;
7155
7156               case 15: /* fcvt{ds,sd}.  */
7157                 {
7158                   int rnum = 0;
7159
7160                   bfd_arm_vfp11_write_mask (destmask, fd);
7161
7162                   /* Only FCVTSD can underflow.  */
7163                   if ((insn & 0x100) != 0)
7164                     regs[rnum++] = fm;
7165
7166                   *numregs = rnum;
7167
7168                   vpipe = VFP11_FMAC;
7169                 }
7170                 break;
7171
7172               default:
7173                 return VFP11_BAD;
7174               }
7175           }
7176           break;
7177
7178         default:
7179           return VFP11_BAD;
7180         }
7181     }
7182   /* Two-register transfer.  */
7183   else if ((insn & 0x0fe00ed0) == 0x0c400a10)
7184     {
7185       unsigned int fm = bfd_arm_vfp11_regno (insn, is_double, 0, 5);
7186
7187       if ((insn & 0x100000) == 0)
7188         {
7189           if (is_double)
7190             bfd_arm_vfp11_write_mask (destmask, fm);
7191           else
7192             {
7193               bfd_arm_vfp11_write_mask (destmask, fm);
7194               bfd_arm_vfp11_write_mask (destmask, fm + 1);
7195             }
7196         }
7197
7198       vpipe = VFP11_LS;
7199     }
7200   else if ((insn & 0x0e100e00) == 0x0c100a00)  /* A load insn.  */
7201     {
7202       int fd = bfd_arm_vfp11_regno (insn, is_double, 12, 22);
7203       unsigned int puw = ((insn >> 21) & 0x1) | (((insn >> 23) & 3) << 1);
7204
7205       switch (puw)
7206         {
7207         case 0: /* Two-reg transfer.  We should catch these above.  */
7208           abort ();
7209
7210         case 2: /* fldm[sdx].  */
7211         case 3:
7212         case 5:
7213           {
7214             unsigned int i, offset = insn & 0xff;
7215
7216             if (is_double)
7217               offset >>= 1;
7218
7219             for (i = fd; i < fd + offset; i++)
7220               bfd_arm_vfp11_write_mask (destmask, i);
7221           }
7222           break;
7223
7224         case 4: /* fld[sd].  */
7225         case 6:
7226           bfd_arm_vfp11_write_mask (destmask, fd);
7227           break;
7228
7229         default:
7230           return VFP11_BAD;
7231         }
7232
7233       vpipe = VFP11_LS;
7234     }
7235   /* Single-register transfer. Note L==0.  */
7236   else if ((insn & 0x0f100e10) == 0x0e000a10)
7237     {
7238       unsigned int opcode = (insn >> 21) & 7;
7239       unsigned int fn = bfd_arm_vfp11_regno (insn, is_double, 16, 7);
7240
7241       switch (opcode)
7242         {
7243         case 0: /* fmsr/fmdlr.  */
7244         case 1: /* fmdhr.  */
7245           /* Mark fmdhr and fmdlr as writing to the whole of the DP
7246              destination register.  I don't know if this is exactly right,
7247              but it is the conservative choice.  */
7248           bfd_arm_vfp11_write_mask (destmask, fn);
7249           break;
7250
7251         case 7: /* fmxr.  */
7252           break;
7253         }
7254
7255       vpipe = VFP11_LS;
7256     }
7257
7258   return vpipe;
7259 }
7260
7261
7262 static int elf32_arm_compare_mapping (const void * a, const void * b);
7263
7264
7265 /* Look for potentially-troublesome code sequences which might trigger the
7266    VFP11 denormal/antidependency erratum.  See, e.g., the ARM1136 errata sheet
7267    (available from ARM) for details of the erratum.  A short version is
7268    described in ld.texinfo.  */
7269
7270 bfd_boolean
7271 bfd_elf32_arm_vfp11_erratum_scan (bfd *abfd, struct bfd_link_info *link_info)
7272 {
7273   asection *sec;
7274   bfd_byte *contents = NULL;
7275   int state = 0;
7276   int regs[3], numregs = 0;
7277   struct elf32_arm_link_hash_table *globals = elf32_arm_hash_table (link_info);
7278   int use_vector = (globals->vfp11_fix == BFD_ARM_VFP11_FIX_VECTOR);
7279
7280   if (globals == NULL)
7281     return FALSE;
7282
7283   /* We use a simple FSM to match troublesome VFP11 instruction sequences.
7284      The states transition as follows:
7285
7286        0 -> 1 (vector) or 0 -> 2 (scalar)
7287            A VFP FMAC-pipeline instruction has been seen. Fill
7288            regs[0]..regs[numregs-1] with its input operands. Remember this
7289            instruction in 'first_fmac'.
7290
7291        1 -> 2
7292            Any instruction, except for a VFP instruction which overwrites
7293            regs[*].
7294
7295        1 -> 3 [ -> 0 ]  or
7296        2 -> 3 [ -> 0 ]
7297            A VFP instruction has been seen which overwrites any of regs[*].
7298            We must make a veneer!  Reset state to 0 before examining next
7299            instruction.
7300
7301        2 -> 0
7302            If we fail to match anything in state 2, reset to state 0 and reset
7303            the instruction pointer to the instruction after 'first_fmac'.
7304
7305      If the VFP11 vector mode is in use, there must be at least two unrelated
7306      instructions between anti-dependent VFP11 instructions to properly avoid
7307      triggering the erratum, hence the use of the extra state 1.  */
7308
7309   /* If we are only performing a partial link do not bother
7310      to construct any glue.  */
7311   if (bfd_link_relocatable (link_info))
7312     return TRUE;
7313
7314   /* Skip if this bfd does not correspond to an ELF image.  */
7315   if (! is_arm_elf (abfd))
7316     return TRUE;
7317
7318   /* We should have chosen a fix type by the time we get here.  */
7319   BFD_ASSERT (globals->vfp11_fix != BFD_ARM_VFP11_FIX_DEFAULT);
7320
7321   if (globals->vfp11_fix == BFD_ARM_VFP11_FIX_NONE)
7322     return TRUE;
7323
7324   /* Skip this BFD if it corresponds to an executable or dynamic object.  */
7325   if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
7326     return TRUE;
7327
7328   for (sec = abfd->sections; sec != NULL; sec = sec->next)
7329     {
7330       unsigned int i, span, first_fmac = 0, veneer_of_insn = 0;
7331       struct _arm_elf_section_data *sec_data;
7332
7333       /* If we don't have executable progbits, we're not interested in this
7334          section.  Also skip if section is to be excluded.  */
7335       if (elf_section_type (sec) != SHT_PROGBITS
7336           || (elf_section_flags (sec) & SHF_EXECINSTR) == 0
7337           || (sec->flags & SEC_EXCLUDE) != 0
7338           || sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
7339           || sec->output_section == bfd_abs_section_ptr
7340           || strcmp (sec->name, VFP11_ERRATUM_VENEER_SECTION_NAME) == 0)
7341         continue;
7342
7343       sec_data = elf32_arm_section_data (sec);
7344
7345       if (sec_data->mapcount == 0)
7346         continue;
7347
7348       if (elf_section_data (sec)->this_hdr.contents != NULL)
7349         contents = elf_section_data (sec)->this_hdr.contents;
7350       else if (! bfd_malloc_and_get_section (abfd, sec, &contents))
7351         goto error_return;
7352
7353       qsort (sec_data->map, sec_data->mapcount, sizeof (elf32_arm_section_map),
7354              elf32_arm_compare_mapping);
7355
7356       for (span = 0; span < sec_data->mapcount; span++)
7357         {
7358           unsigned int span_start = sec_data->map[span].vma;
7359           unsigned int span_end = (span == sec_data->mapcount - 1)
7360                                   ? sec->size : sec_data->map[span + 1].vma;
7361           char span_type = sec_data->map[span].type;
7362
7363           /* FIXME: Only ARM mode is supported at present.  We may need to
7364              support Thumb-2 mode also at some point.  */
7365           if (span_type != 'a')
7366             continue;
7367
7368           for (i = span_start; i < span_end;)
7369             {
7370               unsigned int next_i = i + 4;
7371               unsigned int insn = bfd_big_endian (abfd)
7372                 ? (contents[i] << 24)
7373                   | (contents[i + 1] << 16)
7374                   | (contents[i + 2] << 8)
7375                   | contents[i + 3]
7376                 : (contents[i + 3] << 24)
7377                   | (contents[i + 2] << 16)
7378                   | (contents[i + 1] << 8)
7379                   | contents[i];
7380               unsigned int writemask = 0;
7381               enum bfd_arm_vfp11_pipe vpipe;
7382
7383               switch (state)
7384                 {
7385                 case 0:
7386                   vpipe = bfd_arm_vfp11_insn_decode (insn, &writemask, regs,
7387                                                     &numregs);
7388                   /* I'm assuming the VFP11 erratum can trigger with denorm
7389                      operands on either the FMAC or the DS pipeline. This might
7390                      lead to slightly overenthusiastic veneer insertion.  */
7391                   if (vpipe == VFP11_FMAC || vpipe == VFP11_DS)
7392                     {
7393                       state = use_vector ? 1 : 2;
7394                       first_fmac = i;
7395                       veneer_of_insn = insn;
7396                     }
7397                   break;
7398
7399                 case 1:
7400                   {
7401                     int other_regs[3], other_numregs;
7402                     vpipe = bfd_arm_vfp11_insn_decode (insn, &writemask,
7403                                                       other_regs,
7404                                                       &other_numregs);
7405                     if (vpipe != VFP11_BAD
7406                         && bfd_arm_vfp11_antidependency (writemask, regs,
7407                                                          numregs))
7408                       state = 3;
7409                     else
7410                       state = 2;
7411                   }
7412                   break;
7413
7414                 case 2:
7415                   {
7416                     int other_regs[3], other_numregs;
7417                     vpipe = bfd_arm_vfp11_insn_decode (insn, &writemask,
7418                                                       other_regs,
7419                                                       &other_numregs);
7420                     if (vpipe != VFP11_BAD
7421                         && bfd_arm_vfp11_antidependency (writemask, regs,
7422                                                          numregs))
7423                       state = 3;
7424                     else
7425                       {
7426                         state = 0;
7427                         next_i = first_fmac + 4;
7428                       }
7429                   }
7430                   break;
7431
7432                 case 3:
7433                   abort ();  /* Should be unreachable.  */
7434                 }
7435
7436               if (state == 3)
7437                 {
7438                   elf32_vfp11_erratum_list *newerr =(elf32_vfp11_erratum_list *)
7439                       bfd_zmalloc (sizeof (elf32_vfp11_erratum_list));
7440
7441                   elf32_arm_section_data (sec)->erratumcount += 1;
7442
7443                   newerr->u.b.vfp_insn = veneer_of_insn;
7444
7445                   switch (span_type)
7446                     {
7447                     case 'a':
7448                       newerr->type = VFP11_ERRATUM_BRANCH_TO_ARM_VENEER;
7449                       break;
7450
7451                     default:
7452                       abort ();
7453                     }
7454
7455                   record_vfp11_erratum_veneer (link_info, newerr, abfd, sec,
7456                                                first_fmac);
7457
7458                   newerr->vma = -1;
7459
7460                   newerr->next = sec_data->erratumlist;
7461                   sec_data->erratumlist = newerr;
7462
7463                   state = 0;
7464                 }
7465
7466               i = next_i;
7467             }
7468         }
7469
7470       if (contents != NULL
7471           && elf_section_data (sec)->this_hdr.contents != contents)
7472         free (contents);
7473       contents = NULL;
7474     }
7475
7476   return TRUE;
7477
7478 error_return:
7479   if (contents != NULL
7480       && elf_section_data (sec)->this_hdr.contents != contents)
7481     free (contents);
7482
7483   return FALSE;
7484 }
7485
7486 /* Find virtual-memory addresses for VFP11 erratum veneers and return locations
7487    after sections have been laid out, using specially-named symbols.  */
7488
7489 void
7490 bfd_elf32_arm_vfp11_fix_veneer_locations (bfd *abfd,
7491                                           struct bfd_link_info *link_info)
7492 {
7493   asection *sec;
7494   struct elf32_arm_link_hash_table *globals;
7495   char *tmp_name;
7496
7497   if (bfd_link_relocatable (link_info))
7498     return;
7499
7500   /* Skip if this bfd does not correspond to an ELF image.  */
7501   if (! is_arm_elf (abfd))
7502     return;
7503
7504   globals = elf32_arm_hash_table (link_info);
7505   if (globals == NULL)
7506     return;
7507
7508   tmp_name = (char *) bfd_malloc ((bfd_size_type) strlen
7509                                   (VFP11_ERRATUM_VENEER_ENTRY_NAME) + 10);
7510
7511   for (sec = abfd->sections; sec != NULL; sec = sec->next)
7512     {
7513       struct _arm_elf_section_data *sec_data = elf32_arm_section_data (sec);
7514       elf32_vfp11_erratum_list *errnode = sec_data->erratumlist;
7515
7516       for (; errnode != NULL; errnode = errnode->next)
7517         {
7518           struct elf_link_hash_entry *myh;
7519           bfd_vma vma;
7520
7521           switch (errnode->type)
7522             {
7523             case VFP11_ERRATUM_BRANCH_TO_ARM_VENEER:
7524             case VFP11_ERRATUM_BRANCH_TO_THUMB_VENEER:
7525               /* Find veneer symbol.  */
7526               sprintf (tmp_name, VFP11_ERRATUM_VENEER_ENTRY_NAME,
7527                        errnode->u.b.veneer->u.v.id);
7528
7529               myh = elf_link_hash_lookup
7530                 (&(globals)->root, tmp_name, FALSE, FALSE, TRUE);
7531
7532               if (myh == NULL)
7533                 (*_bfd_error_handler) (_("%B: unable to find VFP11 veneer "
7534                                          "`%s'"), abfd, tmp_name);
7535
7536               vma = myh->root.u.def.section->output_section->vma
7537                     + myh->root.u.def.section->output_offset
7538                     + myh->root.u.def.value;
7539
7540               errnode->u.b.veneer->vma = vma;
7541               break;
7542
7543             case VFP11_ERRATUM_ARM_VENEER:
7544             case VFP11_ERRATUM_THUMB_VENEER:
7545               /* Find return location.  */
7546               sprintf (tmp_name, VFP11_ERRATUM_VENEER_ENTRY_NAME "_r",
7547                        errnode->u.v.id);
7548
7549               myh = elf_link_hash_lookup
7550                 (&(globals)->root, tmp_name, FALSE, FALSE, TRUE);
7551
7552               if (myh == NULL)
7553                 (*_bfd_error_handler) (_("%B: unable to find VFP11 veneer "
7554                                          "`%s'"), abfd, tmp_name);
7555
7556               vma = myh->root.u.def.section->output_section->vma
7557                     + myh->root.u.def.section->output_offset
7558                     + myh->root.u.def.value;
7559
7560               errnode->u.v.branch->vma = vma;
7561               break;
7562
7563             default:
7564               abort ();
7565             }
7566         }
7567     }
7568
7569   free (tmp_name);
7570 }
7571
7572 /* Find virtual-memory addresses for STM32L4XX erratum veneers and
7573    return locations after sections have been laid out, using
7574    specially-named symbols.  */
7575
7576 void
7577 bfd_elf32_arm_stm32l4xx_fix_veneer_locations (bfd *abfd,
7578                                               struct bfd_link_info *link_info)
7579 {
7580   asection *sec;
7581   struct elf32_arm_link_hash_table *globals;
7582   char *tmp_name;
7583
7584   if (bfd_link_relocatable (link_info))
7585     return;
7586
7587   /* Skip if this bfd does not correspond to an ELF image.  */
7588   if (! is_arm_elf (abfd))
7589     return;
7590
7591   globals = elf32_arm_hash_table (link_info);
7592   if (globals == NULL)
7593     return;
7594
7595   tmp_name = (char *) bfd_malloc ((bfd_size_type) strlen
7596                                   (STM32L4XX_ERRATUM_VENEER_ENTRY_NAME) + 10);
7597
7598   for (sec = abfd->sections; sec != NULL; sec = sec->next)
7599     {
7600       struct _arm_elf_section_data *sec_data = elf32_arm_section_data (sec);
7601       elf32_stm32l4xx_erratum_list *errnode = sec_data->stm32l4xx_erratumlist;
7602
7603       for (; errnode != NULL; errnode = errnode->next)
7604         {
7605           struct elf_link_hash_entry *myh;
7606           bfd_vma vma;
7607
7608           switch (errnode->type)
7609             {
7610             case STM32L4XX_ERRATUM_BRANCH_TO_VENEER:
7611               /* Find veneer symbol.  */
7612               sprintf (tmp_name, STM32L4XX_ERRATUM_VENEER_ENTRY_NAME,
7613                        errnode->u.b.veneer->u.v.id);
7614
7615               myh = elf_link_hash_lookup
7616                 (&(globals)->root, tmp_name, FALSE, FALSE, TRUE);
7617
7618               if (myh == NULL)
7619                 (*_bfd_error_handler) (_("%B: unable to find STM32L4XX veneer "
7620                                          "`%s'"), abfd, tmp_name);
7621
7622               vma = myh->root.u.def.section->output_section->vma
7623                 + myh->root.u.def.section->output_offset
7624                 + myh->root.u.def.value;
7625
7626               errnode->u.b.veneer->vma = vma;
7627               break;
7628
7629             case STM32L4XX_ERRATUM_VENEER:
7630               /* Find return location.  */
7631               sprintf (tmp_name, STM32L4XX_ERRATUM_VENEER_ENTRY_NAME "_r",
7632                        errnode->u.v.id);
7633
7634               myh = elf_link_hash_lookup
7635                 (&(globals)->root, tmp_name, FALSE, FALSE, TRUE);
7636
7637               if (myh == NULL)
7638                 (*_bfd_error_handler) (_("%B: unable to find STM32L4XX veneer "
7639                                          "`%s'"), abfd, tmp_name);
7640
7641               vma = myh->root.u.def.section->output_section->vma
7642                 + myh->root.u.def.section->output_offset
7643                 + myh->root.u.def.value;
7644
7645               errnode->u.v.branch->vma = vma;
7646               break;
7647
7648             default:
7649               abort ();
7650             }
7651         }
7652     }
7653
7654   free (tmp_name);
7655 }
7656
7657 static inline bfd_boolean
7658 is_thumb2_ldmia (const insn32 insn)
7659 {
7660   /* Encoding T2: LDM<c>.W <Rn>{!},<registers>
7661      1110 - 1000 - 10W1 - rrrr - PM (0) l - llll - llll - llll.  */
7662   return (insn & 0xffd02000) == 0xe8900000;
7663 }
7664
7665 static inline bfd_boolean
7666 is_thumb2_ldmdb (const insn32 insn)
7667 {
7668   /* Encoding T1: LDMDB<c> <Rn>{!},<registers>
7669      1110 - 1001 - 00W1 - rrrr - PM (0) l - llll - llll - llll.  */
7670   return (insn & 0xffd02000) == 0xe9100000;
7671 }
7672
7673 static inline bfd_boolean
7674 is_thumb2_vldm (const insn32 insn)
7675 {
7676   /* A6.5 Extension register load or store instruction
7677      A7.7.229
7678      We look for SP 32-bit and DP 64-bit registers.
7679      Encoding T1 VLDM{mode}<c> <Rn>{!}, <list>
7680      <list> is consecutive 64-bit registers
7681      1110 - 110P - UDW1 - rrrr - vvvv - 1011 - iiii - iiii
7682      Encoding T2 VLDM{mode}<c> <Rn>{!}, <list>
7683      <list> is consecutive 32-bit registers
7684      1110 - 110P - UDW1 - rrrr - vvvv - 1010 - iiii - iiii
7685      if P==0 && U==1 && W==1 && Rn=1101 VPOP
7686      if PUW=010 || PUW=011 || PUW=101 VLDM.  */
7687   return
7688     (((insn & 0xfe100f00) == 0xec100b00) ||
7689      ((insn & 0xfe100f00) == 0xec100a00))
7690     && /* (IA without !).  */
7691     (((((insn << 7) >> 28) & 0xd) == 0x4)
7692      /* (IA with !), includes VPOP (when reg number is SP).  */
7693      || ((((insn << 7) >> 28) & 0xd) == 0x5)
7694      /* (DB with !).  */
7695      || ((((insn << 7) >> 28) & 0xd) == 0x9));
7696 }
7697
7698 /* STM STM32L4XX erratum : This function assumes that it receives an LDM or
7699    VLDM opcode and:
7700  - computes the number and the mode of memory accesses
7701  - decides if the replacement should be done:
7702    . replaces only if > 8-word accesses
7703    . or (testing purposes only) replaces all accesses.  */
7704
7705 static bfd_boolean
7706 stm32l4xx_need_create_replacing_stub (const insn32 insn,
7707                                       bfd_arm_stm32l4xx_fix stm32l4xx_fix)
7708 {
7709   int nb_words = 0;
7710
7711   /* The field encoding the register list is the same for both LDMIA
7712      and LDMDB encodings.  */
7713   if (is_thumb2_ldmia (insn) || is_thumb2_ldmdb (insn))
7714     nb_words = popcount (insn & 0x0000ffff);
7715   else if (is_thumb2_vldm (insn))
7716    nb_words = (insn & 0xff);
7717
7718   /* DEFAULT mode accounts for the real bug condition situation,
7719      ALL mode inserts stubs for each LDM/VLDM instruction (testing).  */
7720   return
7721     (stm32l4xx_fix == BFD_ARM_STM32L4XX_FIX_DEFAULT) ? nb_words > 8 :
7722     (stm32l4xx_fix == BFD_ARM_STM32L4XX_FIX_ALL) ? TRUE : FALSE;
7723 }
7724
7725 /* Look for potentially-troublesome code sequences which might trigger
7726    the STM STM32L4XX erratum.  */
7727
7728 bfd_boolean
7729 bfd_elf32_arm_stm32l4xx_erratum_scan (bfd *abfd,
7730                                       struct bfd_link_info *link_info)
7731 {
7732   asection *sec;
7733   bfd_byte *contents = NULL;
7734   struct elf32_arm_link_hash_table *globals = elf32_arm_hash_table (link_info);
7735
7736   if (globals == NULL)
7737     return FALSE;
7738
7739   /* If we are only performing a partial link do not bother
7740      to construct any glue.  */
7741   if (bfd_link_relocatable (link_info))
7742     return TRUE;
7743
7744   /* Skip if this bfd does not correspond to an ELF image.  */
7745   if (! is_arm_elf (abfd))
7746     return TRUE;
7747
7748   if (globals->stm32l4xx_fix == BFD_ARM_STM32L4XX_FIX_NONE)
7749     return TRUE;
7750
7751   /* Skip this BFD if it corresponds to an executable or dynamic object.  */
7752   if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
7753     return TRUE;
7754
7755   for (sec = abfd->sections; sec != NULL; sec = sec->next)
7756     {
7757       unsigned int i, span;
7758       struct _arm_elf_section_data *sec_data;
7759
7760       /* If we don't have executable progbits, we're not interested in this
7761          section.  Also skip if section is to be excluded.  */
7762       if (elf_section_type (sec) != SHT_PROGBITS
7763           || (elf_section_flags (sec) & SHF_EXECINSTR) == 0
7764           || (sec->flags & SEC_EXCLUDE) != 0
7765           || sec->sec_info_type == SEC_INFO_TYPE_JUST_SYMS
7766           || sec->output_section == bfd_abs_section_ptr
7767           || strcmp (sec->name, STM32L4XX_ERRATUM_VENEER_SECTION_NAME) == 0)
7768         continue;
7769
7770       sec_data = elf32_arm_section_data (sec);
7771
7772       if (sec_data->mapcount == 0)
7773         continue;
7774
7775       if (elf_section_data (sec)->this_hdr.contents != NULL)
7776         contents = elf_section_data (sec)->this_hdr.contents;
7777       else if (! bfd_malloc_and_get_section (abfd, sec, &contents))
7778         goto error_return;
7779
7780       qsort (sec_data->map, sec_data->mapcount, sizeof (elf32_arm_section_map),
7781              elf32_arm_compare_mapping);
7782
7783       for (span = 0; span < sec_data->mapcount; span++)
7784         {
7785           unsigned int span_start = sec_data->map[span].vma;
7786           unsigned int span_end = (span == sec_data->mapcount - 1)
7787             ? sec->size : sec_data->map[span + 1].vma;
7788           char span_type = sec_data->map[span].type;
7789           int itblock_current_pos = 0;
7790
7791           /* Only Thumb2 mode need be supported with this CM4 specific
7792              code, we should not encounter any arm mode eg span_type
7793              != 'a'.  */
7794           if (span_type != 't')
7795             continue;
7796
7797           for (i = span_start; i < span_end;)
7798             {
7799               unsigned int insn = bfd_get_16 (abfd, &contents[i]);
7800               bfd_boolean insn_32bit = FALSE;
7801               bfd_boolean is_ldm = FALSE;
7802               bfd_boolean is_vldm = FALSE;
7803               bfd_boolean is_not_last_in_it_block = FALSE;
7804
7805               /* The first 16-bits of all 32-bit thumb2 instructions start
7806                  with opcode[15..13]=0b111 and the encoded op1 can be anything
7807                  except opcode[12..11]!=0b00.
7808                  See 32-bit Thumb instruction encoding.  */
7809               if ((insn & 0xe000) == 0xe000 && (insn & 0x1800) != 0x0000)
7810                 insn_32bit = TRUE;
7811
7812               /* Compute the predicate that tells if the instruction
7813                  is concerned by the IT block
7814                  - Creates an error if there is a ldm that is not
7815                    last in the IT block thus cannot be replaced
7816                  - Otherwise we can create a branch at the end of the
7817                    IT block, it will be controlled naturally by IT
7818                    with the proper pseudo-predicate
7819                  - So the only interesting predicate is the one that
7820                    tells that we are not on the last item of an IT
7821                    block.  */
7822               if (itblock_current_pos != 0)
7823                   is_not_last_in_it_block = !!--itblock_current_pos;
7824
7825               if (insn_32bit)
7826                 {
7827                   /* Load the rest of the insn (in manual-friendly order).  */
7828                   insn = (insn << 16) | bfd_get_16 (abfd, &contents[i + 2]);
7829                   is_ldm = is_thumb2_ldmia (insn) || is_thumb2_ldmdb (insn);
7830                   is_vldm = is_thumb2_vldm (insn);
7831
7832                   /* Veneers are created for (v)ldm depending on
7833                      option flags and memory accesses conditions; but
7834                      if the instruction is not the last instruction of
7835                      an IT block, we cannot create a jump there, so we
7836                      bail out.  */
7837                     if ((is_ldm || is_vldm) &&
7838                         stm32l4xx_need_create_replacing_stub
7839                         (insn, globals->stm32l4xx_fix))
7840                       {
7841                         if (is_not_last_in_it_block)
7842                           {
7843                             (*_bfd_error_handler)
7844                               /* Note - overlong line used here to allow for translation.  */
7845                               (_("\
7846 %B(%A+0x%lx): error: multiple load detected in non-last IT block instruction : STM32L4XX veneer cannot be generated.\n"
7847                                  "Use gcc option -mrestrict-it to generate only one instruction per IT block.\n"),
7848                                abfd, sec, (long)i);
7849                           }
7850                         else
7851                           {
7852                             elf32_stm32l4xx_erratum_list *newerr =
7853                               (elf32_stm32l4xx_erratum_list *)
7854                               bfd_zmalloc
7855                               (sizeof (elf32_stm32l4xx_erratum_list));
7856
7857                             elf32_arm_section_data (sec)
7858                               ->stm32l4xx_erratumcount += 1;
7859                             newerr->u.b.insn = insn;
7860                             /* We create only thumb branches.  */
7861                             newerr->type =
7862                               STM32L4XX_ERRATUM_BRANCH_TO_VENEER;
7863                             record_stm32l4xx_erratum_veneer
7864                               (link_info, newerr, abfd, sec,
7865                                i,
7866                                is_ldm ?
7867                                STM32L4XX_ERRATUM_LDM_VENEER_SIZE:
7868                                STM32L4XX_ERRATUM_VLDM_VENEER_SIZE);
7869                             newerr->vma = -1;
7870                             newerr->next = sec_data->stm32l4xx_erratumlist;
7871                             sec_data->stm32l4xx_erratumlist = newerr;
7872                           }
7873                       }
7874                 }
7875               else
7876                 {
7877                   /* A7.7.37 IT p208
7878                      IT blocks are only encoded in T1
7879                      Encoding T1: IT{x{y{z}}} <firstcond>
7880                      1 0 1 1 - 1 1 1 1 - firstcond - mask
7881                      if mask = '0000' then see 'related encodings'
7882                      We don't deal with UNPREDICTABLE, just ignore these.
7883                      There can be no nested IT blocks so an IT block
7884                      is naturally a new one for which it is worth
7885                      computing its size.  */
7886                   bfd_boolean is_newitblock = ((insn & 0xff00) == 0xbf00) &&
7887                     ((insn & 0x000f) != 0x0000);
7888                   /* If we have a new IT block we compute its size.  */
7889                   if (is_newitblock)
7890                     {
7891                       /* Compute the number of instructions controlled
7892                          by the IT block, it will be used to decide
7893                          whether we are inside an IT block or not.  */
7894                       unsigned int mask = insn & 0x000f;
7895                       itblock_current_pos = 4 - ctz (mask);
7896                     }
7897                 }
7898
7899               i += insn_32bit ? 4 : 2;
7900             }
7901         }
7902
7903       if (contents != NULL
7904           && elf_section_data (sec)->this_hdr.contents != contents)
7905         free (contents);
7906       contents = NULL;
7907     }
7908
7909   return TRUE;
7910
7911 error_return:
7912   if (contents != NULL
7913       && elf_section_data (sec)->this_hdr.contents != contents)
7914     free (contents);
7915
7916   return FALSE;
7917 }
7918
7919 /* Set target relocation values needed during linking.  */
7920
7921 void
7922 bfd_elf32_arm_set_target_relocs (struct bfd *output_bfd,
7923                                  struct bfd_link_info *link_info,
7924                                  int target1_is_rel,
7925                                  char * target2_type,
7926                                  int fix_v4bx,
7927                                  int use_blx,
7928                                  bfd_arm_vfp11_fix vfp11_fix,
7929                                  bfd_arm_stm32l4xx_fix stm32l4xx_fix,
7930                                  int no_enum_warn, int no_wchar_warn,
7931                                  int pic_veneer, int fix_cortex_a8,
7932                                  int fix_arm1176)
7933 {
7934   struct elf32_arm_link_hash_table *globals;
7935
7936   globals = elf32_arm_hash_table (link_info);
7937   if (globals == NULL)
7938     return;
7939
7940   globals->target1_is_rel = target1_is_rel;
7941   if (strcmp (target2_type, "rel") == 0)
7942     globals->target2_reloc = R_ARM_REL32;
7943   else if (strcmp (target2_type, "abs") == 0)
7944     globals->target2_reloc = R_ARM_ABS32;
7945   else if (strcmp (target2_type, "got-rel") == 0)
7946     globals->target2_reloc = R_ARM_GOT_PREL;
7947   else
7948     {
7949       _bfd_error_handler (_("Invalid TARGET2 relocation type '%s'."),
7950                           target2_type);
7951     }
7952   globals->fix_v4bx = fix_v4bx;
7953   globals->use_blx |= use_blx;
7954   globals->vfp11_fix = vfp11_fix;
7955   globals->stm32l4xx_fix = stm32l4xx_fix;
7956   globals->pic_veneer = pic_veneer;
7957   globals->fix_cortex_a8 = fix_cortex_a8;
7958   globals->fix_arm1176 = fix_arm1176;
7959
7960   BFD_ASSERT (is_arm_elf (output_bfd));
7961   elf_arm_tdata (output_bfd)->no_enum_size_warning = no_enum_warn;
7962   elf_arm_tdata (output_bfd)->no_wchar_size_warning = no_wchar_warn;
7963 }
7964
7965 /* Replace the target offset of a Thumb bl or b.w instruction.  */
7966
7967 static void
7968 insert_thumb_branch (bfd *abfd, long int offset, bfd_byte *insn)
7969 {
7970   bfd_vma upper;
7971   bfd_vma lower;
7972   int reloc_sign;
7973
7974   BFD_ASSERT ((offset & 1) == 0);
7975
7976   upper = bfd_get_16 (abfd, insn);
7977   lower = bfd_get_16 (abfd, insn + 2);
7978   reloc_sign = (offset < 0) ? 1 : 0;
7979   upper = (upper & ~(bfd_vma) 0x7ff)
7980           | ((offset >> 12) & 0x3ff)
7981           | (reloc_sign << 10);
7982   lower = (lower & ~(bfd_vma) 0x2fff)
7983           | (((!((offset >> 23) & 1)) ^ reloc_sign) << 13)
7984           | (((!((offset >> 22) & 1)) ^ reloc_sign) << 11)
7985           | ((offset >> 1) & 0x7ff);
7986   bfd_put_16 (abfd, upper, insn);
7987   bfd_put_16 (abfd, lower, insn + 2);
7988 }
7989
7990 /* Thumb code calling an ARM function.  */
7991
7992 static int
7993 elf32_thumb_to_arm_stub (struct bfd_link_info * info,
7994                          const char *           name,
7995                          bfd *                  input_bfd,
7996                          bfd *                  output_bfd,
7997                          asection *             input_section,
7998                          bfd_byte *             hit_data,
7999                          asection *             sym_sec,
8000                          bfd_vma                offset,
8001                          bfd_signed_vma         addend,
8002                          bfd_vma                val,
8003                          char **error_message)
8004 {
8005   asection * s = 0;
8006   bfd_vma my_offset;
8007   long int ret_offset;
8008   struct elf_link_hash_entry * myh;
8009   struct elf32_arm_link_hash_table * globals;
8010
8011   myh = find_thumb_glue (info, name, error_message);
8012   if (myh == NULL)
8013     return FALSE;
8014
8015   globals = elf32_arm_hash_table (info);
8016   BFD_ASSERT (globals != NULL);
8017   BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
8018
8019   my_offset = myh->root.u.def.value;
8020
8021   s = bfd_get_linker_section (globals->bfd_of_glue_owner,
8022                               THUMB2ARM_GLUE_SECTION_NAME);
8023
8024   BFD_ASSERT (s != NULL);
8025   BFD_ASSERT (s->contents != NULL);
8026   BFD_ASSERT (s->output_section != NULL);
8027
8028   if ((my_offset & 0x01) == 0x01)
8029     {
8030       if (sym_sec != NULL
8031           && sym_sec->owner != NULL
8032           && !INTERWORK_FLAG (sym_sec->owner))
8033         {
8034           (*_bfd_error_handler)
8035             (_("%B(%s): warning: interworking not enabled.\n"
8036                "  first occurrence: %B: Thumb call to ARM"),
8037              sym_sec->owner, input_bfd, name);
8038
8039           return FALSE;
8040         }
8041
8042       --my_offset;
8043       myh->root.u.def.value = my_offset;
8044
8045       put_thumb_insn (globals, output_bfd, (bfd_vma) t2a1_bx_pc_insn,
8046                       s->contents + my_offset);
8047
8048       put_thumb_insn (globals, output_bfd, (bfd_vma) t2a2_noop_insn,
8049                       s->contents + my_offset + 2);
8050
8051       ret_offset =
8052         /* Address of destination of the stub.  */
8053         ((bfd_signed_vma) val)
8054         - ((bfd_signed_vma)
8055            /* Offset from the start of the current section
8056               to the start of the stubs.  */
8057            (s->output_offset
8058             /* Offset of the start of this stub from the start of the stubs.  */
8059             + my_offset
8060             /* Address of the start of the current section.  */
8061             + s->output_section->vma)
8062            /* The branch instruction is 4 bytes into the stub.  */
8063            + 4
8064            /* ARM branches work from the pc of the instruction + 8.  */
8065            + 8);
8066
8067       put_arm_insn (globals, output_bfd,
8068                     (bfd_vma) t2a3_b_insn | ((ret_offset >> 2) & 0x00FFFFFF),
8069                     s->contents + my_offset + 4);
8070     }
8071
8072   BFD_ASSERT (my_offset <= globals->thumb_glue_size);
8073
8074   /* Now go back and fix up the original BL insn to point to here.  */
8075   ret_offset =
8076     /* Address of where the stub is located.  */
8077     (s->output_section->vma + s->output_offset + my_offset)
8078      /* Address of where the BL is located.  */
8079     - (input_section->output_section->vma + input_section->output_offset
8080        + offset)
8081     /* Addend in the relocation.  */
8082     - addend
8083     /* Biassing for PC-relative addressing.  */
8084     - 8;
8085
8086   insert_thumb_branch (input_bfd, ret_offset, hit_data - input_section->vma);
8087
8088   return TRUE;
8089 }
8090
8091 /* Populate an Arm to Thumb stub.  Returns the stub symbol.  */
8092
8093 static struct elf_link_hash_entry *
8094 elf32_arm_create_thumb_stub (struct bfd_link_info * info,
8095                              const char *           name,
8096                              bfd *                  input_bfd,
8097                              bfd *                  output_bfd,
8098                              asection *             sym_sec,
8099                              bfd_vma                val,
8100                              asection *             s,
8101                              char **                error_message)
8102 {
8103   bfd_vma my_offset;
8104   long int ret_offset;
8105   struct elf_link_hash_entry * myh;
8106   struct elf32_arm_link_hash_table * globals;
8107
8108   myh = find_arm_glue (info, name, error_message);
8109   if (myh == NULL)
8110     return NULL;
8111
8112   globals = elf32_arm_hash_table (info);
8113   BFD_ASSERT (globals != NULL);
8114   BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
8115
8116   my_offset = myh->root.u.def.value;
8117
8118   if ((my_offset & 0x01) == 0x01)
8119     {
8120       if (sym_sec != NULL
8121           && sym_sec->owner != NULL
8122           && !INTERWORK_FLAG (sym_sec->owner))
8123         {
8124           (*_bfd_error_handler)
8125             (_("%B(%s): warning: interworking not enabled.\n"
8126                "  first occurrence: %B: arm call to thumb"),
8127              sym_sec->owner, input_bfd, name);
8128         }
8129
8130       --my_offset;
8131       myh->root.u.def.value = my_offset;
8132
8133       if (bfd_link_pic (info)
8134           || globals->root.is_relocatable_executable
8135           || globals->pic_veneer)
8136         {
8137           /* For relocatable objects we can't use absolute addresses,
8138              so construct the address from a relative offset.  */
8139           /* TODO: If the offset is small it's probably worth
8140              constructing the address with adds.  */
8141           put_arm_insn (globals, output_bfd, (bfd_vma) a2t1p_ldr_insn,
8142                         s->contents + my_offset);
8143           put_arm_insn (globals, output_bfd, (bfd_vma) a2t2p_add_pc_insn,
8144                         s->contents + my_offset + 4);
8145           put_arm_insn (globals, output_bfd, (bfd_vma) a2t3p_bx_r12_insn,
8146                         s->contents + my_offset + 8);
8147           /* Adjust the offset by 4 for the position of the add,
8148              and 8 for the pipeline offset.  */
8149           ret_offset = (val - (s->output_offset
8150                                + s->output_section->vma
8151                                + my_offset + 12))
8152                        | 1;
8153           bfd_put_32 (output_bfd, ret_offset,
8154                       s->contents + my_offset + 12);
8155         }
8156       else if (globals->use_blx)
8157         {
8158           put_arm_insn (globals, output_bfd, (bfd_vma) a2t1v5_ldr_insn,
8159                         s->contents + my_offset);
8160
8161           /* It's a thumb address.  Add the low order bit.  */
8162           bfd_put_32 (output_bfd, val | a2t2v5_func_addr_insn,
8163                       s->contents + my_offset + 4);
8164         }
8165       else
8166         {
8167           put_arm_insn (globals, output_bfd, (bfd_vma) a2t1_ldr_insn,
8168                         s->contents + my_offset);
8169
8170           put_arm_insn (globals, output_bfd, (bfd_vma) a2t2_bx_r12_insn,
8171                         s->contents + my_offset + 4);
8172
8173           /* It's a thumb address.  Add the low order bit.  */
8174           bfd_put_32 (output_bfd, val | a2t3_func_addr_insn,
8175                       s->contents + my_offset + 8);
8176
8177           my_offset += 12;
8178         }
8179     }
8180
8181   BFD_ASSERT (my_offset <= globals->arm_glue_size);
8182
8183   return myh;
8184 }
8185
8186 /* Arm code calling a Thumb function.  */
8187
8188 static int
8189 elf32_arm_to_thumb_stub (struct bfd_link_info * info,
8190                          const char *           name,
8191                          bfd *                  input_bfd,
8192                          bfd *                  output_bfd,
8193                          asection *             input_section,
8194                          bfd_byte *             hit_data,
8195                          asection *             sym_sec,
8196                          bfd_vma                offset,
8197                          bfd_signed_vma         addend,
8198                          bfd_vma                val,
8199                          char **error_message)
8200 {
8201   unsigned long int tmp;
8202   bfd_vma my_offset;
8203   asection * s;
8204   long int ret_offset;
8205   struct elf_link_hash_entry * myh;
8206   struct elf32_arm_link_hash_table * globals;
8207
8208   globals = elf32_arm_hash_table (info);
8209   BFD_ASSERT (globals != NULL);
8210   BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
8211
8212   s = bfd_get_linker_section (globals->bfd_of_glue_owner,
8213                               ARM2THUMB_GLUE_SECTION_NAME);
8214   BFD_ASSERT (s != NULL);
8215   BFD_ASSERT (s->contents != NULL);
8216   BFD_ASSERT (s->output_section != NULL);
8217
8218   myh = elf32_arm_create_thumb_stub (info, name, input_bfd, output_bfd,
8219                                      sym_sec, val, s, error_message);
8220   if (!myh)
8221     return FALSE;
8222
8223   my_offset = myh->root.u.def.value;
8224   tmp = bfd_get_32 (input_bfd, hit_data);
8225   tmp = tmp & 0xFF000000;
8226
8227   /* Somehow these are both 4 too far, so subtract 8.  */
8228   ret_offset = (s->output_offset
8229                 + my_offset
8230                 + s->output_section->vma
8231                 - (input_section->output_offset
8232                    + input_section->output_section->vma
8233                    + offset + addend)
8234                 - 8);
8235
8236   tmp = tmp | ((ret_offset >> 2) & 0x00FFFFFF);
8237
8238   bfd_put_32 (output_bfd, (bfd_vma) tmp, hit_data - input_section->vma);
8239
8240   return TRUE;
8241 }
8242
8243 /* Populate Arm stub for an exported Thumb function.  */
8244
8245 static bfd_boolean
8246 elf32_arm_to_thumb_export_stub (struct elf_link_hash_entry *h, void * inf)
8247 {
8248   struct bfd_link_info * info = (struct bfd_link_info *) inf;
8249   asection * s;
8250   struct elf_link_hash_entry * myh;
8251   struct elf32_arm_link_hash_entry *eh;
8252   struct elf32_arm_link_hash_table * globals;
8253   asection *sec;
8254   bfd_vma val;
8255   char *error_message;
8256
8257   eh = elf32_arm_hash_entry (h);
8258   /* Allocate stubs for exported Thumb functions on v4t.  */
8259   if (eh->export_glue == NULL)
8260     return TRUE;
8261
8262   globals = elf32_arm_hash_table (info);
8263   BFD_ASSERT (globals != NULL);
8264   BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
8265
8266   s = bfd_get_linker_section (globals->bfd_of_glue_owner,
8267                               ARM2THUMB_GLUE_SECTION_NAME);
8268   BFD_ASSERT (s != NULL);
8269   BFD_ASSERT (s->contents != NULL);
8270   BFD_ASSERT (s->output_section != NULL);
8271
8272   sec = eh->export_glue->root.u.def.section;
8273
8274   BFD_ASSERT (sec->output_section != NULL);
8275
8276   val = eh->export_glue->root.u.def.value + sec->output_offset
8277         + sec->output_section->vma;
8278
8279   myh = elf32_arm_create_thumb_stub (info, h->root.root.string,
8280                                      h->root.u.def.section->owner,
8281                                      globals->obfd, sec, val, s,
8282                                      &error_message);
8283   BFD_ASSERT (myh);
8284   return TRUE;
8285 }
8286
8287 /* Populate ARMv4 BX veneers.  Returns the absolute adress of the veneer.  */
8288
8289 static bfd_vma
8290 elf32_arm_bx_glue (struct bfd_link_info * info, int reg)
8291 {
8292   bfd_byte *p;
8293   bfd_vma glue_addr;
8294   asection *s;
8295   struct elf32_arm_link_hash_table *globals;
8296
8297   globals = elf32_arm_hash_table (info);
8298   BFD_ASSERT (globals != NULL);
8299   BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
8300
8301   s = bfd_get_linker_section (globals->bfd_of_glue_owner,
8302                               ARM_BX_GLUE_SECTION_NAME);
8303   BFD_ASSERT (s != NULL);
8304   BFD_ASSERT (s->contents != NULL);
8305   BFD_ASSERT (s->output_section != NULL);
8306
8307   BFD_ASSERT (globals->bx_glue_offset[reg] & 2);
8308
8309   glue_addr = globals->bx_glue_offset[reg] & ~(bfd_vma)3;
8310
8311   if ((globals->bx_glue_offset[reg] & 1) == 0)
8312     {
8313       p = s->contents + glue_addr;
8314       bfd_put_32 (globals->obfd, armbx1_tst_insn + (reg << 16), p);
8315       bfd_put_32 (globals->obfd, armbx2_moveq_insn + reg, p + 4);
8316       bfd_put_32 (globals->obfd, armbx3_bx_insn + reg, p + 8);
8317       globals->bx_glue_offset[reg] |= 1;
8318     }
8319
8320   return glue_addr + s->output_section->vma + s->output_offset;
8321 }
8322
8323 /* Generate Arm stubs for exported Thumb symbols.  */
8324 static void
8325 elf32_arm_begin_write_processing (bfd *abfd ATTRIBUTE_UNUSED,
8326                                   struct bfd_link_info *link_info)
8327 {
8328   struct elf32_arm_link_hash_table * globals;
8329
8330   if (link_info == NULL)
8331     /* Ignore this if we are not called by the ELF backend linker.  */
8332     return;
8333
8334   globals = elf32_arm_hash_table (link_info);
8335   if (globals == NULL)
8336     return;
8337
8338   /* If blx is available then exported Thumb symbols are OK and there is
8339      nothing to do.  */
8340   if (globals->use_blx)
8341     return;
8342
8343   elf_link_hash_traverse (&globals->root, elf32_arm_to_thumb_export_stub,
8344                           link_info);
8345 }
8346
8347 /* Reserve space for COUNT dynamic relocations in relocation selection
8348    SRELOC.  */
8349
8350 static void
8351 elf32_arm_allocate_dynrelocs (struct bfd_link_info *info, asection *sreloc,
8352                               bfd_size_type count)
8353 {
8354   struct elf32_arm_link_hash_table *htab;
8355
8356   htab = elf32_arm_hash_table (info);
8357   BFD_ASSERT (htab->root.dynamic_sections_created);
8358   if (sreloc == NULL)
8359     abort ();
8360   sreloc->size += RELOC_SIZE (htab) * count;
8361 }
8362
8363 /* Reserve space for COUNT R_ARM_IRELATIVE relocations.  If the link is
8364    dynamic, the relocations should go in SRELOC, otherwise they should
8365    go in the special .rel.iplt section.  */
8366
8367 static void
8368 elf32_arm_allocate_irelocs (struct bfd_link_info *info, asection *sreloc,
8369                             bfd_size_type count)
8370 {
8371   struct elf32_arm_link_hash_table *htab;
8372
8373   htab = elf32_arm_hash_table (info);
8374   if (!htab->root.dynamic_sections_created)
8375     htab->root.irelplt->size += RELOC_SIZE (htab) * count;
8376   else
8377     {
8378       BFD_ASSERT (sreloc != NULL);
8379       sreloc->size += RELOC_SIZE (htab) * count;
8380     }
8381 }
8382
8383 /* Add relocation REL to the end of relocation section SRELOC.  */
8384
8385 static void
8386 elf32_arm_add_dynreloc (bfd *output_bfd, struct bfd_link_info *info,
8387                         asection *sreloc, Elf_Internal_Rela *rel)
8388 {
8389   bfd_byte *loc;
8390   struct elf32_arm_link_hash_table *htab;
8391
8392   htab = elf32_arm_hash_table (info);
8393   if (!htab->root.dynamic_sections_created
8394       && ELF32_R_TYPE (rel->r_info) == R_ARM_IRELATIVE)
8395     sreloc = htab->root.irelplt;
8396   if (sreloc == NULL)
8397     abort ();
8398   loc = sreloc->contents;
8399   loc += sreloc->reloc_count++ * RELOC_SIZE (htab);
8400   if (sreloc->reloc_count * RELOC_SIZE (htab) > sreloc->size)
8401     abort ();
8402   SWAP_RELOC_OUT (htab) (output_bfd, rel, loc);
8403 }
8404
8405 /* Allocate room for a PLT entry described by ROOT_PLT and ARM_PLT.
8406    IS_IPLT_ENTRY says whether the entry belongs to .iplt rather than
8407    to .plt.  */
8408
8409 static void
8410 elf32_arm_allocate_plt_entry (struct bfd_link_info *info,
8411                               bfd_boolean is_iplt_entry,
8412                               union gotplt_union *root_plt,
8413                               struct arm_plt_info *arm_plt)
8414 {
8415   struct elf32_arm_link_hash_table *htab;
8416   asection *splt;
8417   asection *sgotplt;
8418
8419   htab = elf32_arm_hash_table (info);
8420
8421   if (is_iplt_entry)
8422     {
8423       splt = htab->root.iplt;
8424       sgotplt = htab->root.igotplt;
8425
8426       /* NaCl uses a special first entry in .iplt too.  */
8427       if (htab->nacl_p && splt->size == 0)
8428         splt->size += htab->plt_header_size;
8429
8430       /* Allocate room for an R_ARM_IRELATIVE relocation in .rel.iplt.  */
8431       elf32_arm_allocate_irelocs (info, htab->root.irelplt, 1);
8432     }
8433   else
8434     {
8435       splt = htab->root.splt;
8436       sgotplt = htab->root.sgotplt;
8437
8438       /* Allocate room for an R_JUMP_SLOT relocation in .rel.plt.  */
8439       elf32_arm_allocate_dynrelocs (info, htab->root.srelplt, 1);
8440
8441       /* If this is the first .plt entry, make room for the special
8442          first entry.  */
8443       if (splt->size == 0)
8444         splt->size += htab->plt_header_size;
8445
8446       htab->next_tls_desc_index++;
8447     }
8448
8449   /* Allocate the PLT entry itself, including any leading Thumb stub.  */
8450   if (elf32_arm_plt_needs_thumb_stub_p (info, arm_plt))
8451     splt->size += PLT_THUMB_STUB_SIZE;
8452   root_plt->offset = splt->size;
8453   splt->size += htab->plt_entry_size;
8454
8455   if (!htab->symbian_p)
8456     {
8457       /* We also need to make an entry in the .got.plt section, which
8458          will be placed in the .got section by the linker script.  */
8459       if (is_iplt_entry)
8460         arm_plt->got_offset = sgotplt->size;
8461       else
8462         arm_plt->got_offset = sgotplt->size - 8 * htab->num_tls_desc;
8463       sgotplt->size += 4;
8464     }
8465 }
8466
8467 static bfd_vma
8468 arm_movw_immediate (bfd_vma value)
8469 {
8470   return (value & 0x00000fff) | ((value & 0x0000f000) << 4);
8471 }
8472
8473 static bfd_vma
8474 arm_movt_immediate (bfd_vma value)
8475 {
8476   return ((value & 0x0fff0000) >> 16) | ((value & 0xf0000000) >> 12);
8477 }
8478
8479 /* Fill in a PLT entry and its associated GOT slot.  If DYNINDX == -1,
8480    the entry lives in .iplt and resolves to (*SYM_VALUE)().
8481    Otherwise, DYNINDX is the index of the symbol in the dynamic
8482    symbol table and SYM_VALUE is undefined.
8483
8484    ROOT_PLT points to the offset of the PLT entry from the start of its
8485    section (.iplt or .plt).  ARM_PLT points to the symbol's ARM-specific
8486    bookkeeping information.
8487
8488    Returns FALSE if there was a problem.  */
8489
8490 static bfd_boolean
8491 elf32_arm_populate_plt_entry (bfd *output_bfd, struct bfd_link_info *info,
8492                               union gotplt_union *root_plt,
8493                               struct arm_plt_info *arm_plt,
8494                               int dynindx, bfd_vma sym_value)
8495 {
8496   struct elf32_arm_link_hash_table *htab;
8497   asection *sgot;
8498   asection *splt;
8499   asection *srel;
8500   bfd_byte *loc;
8501   bfd_vma plt_index;
8502   Elf_Internal_Rela rel;
8503   bfd_vma plt_header_size;
8504   bfd_vma got_header_size;
8505
8506   htab = elf32_arm_hash_table (info);
8507
8508   /* Pick the appropriate sections and sizes.  */
8509   if (dynindx == -1)
8510     {
8511       splt = htab->root.iplt;
8512       sgot = htab->root.igotplt;
8513       srel = htab->root.irelplt;
8514
8515       /* There are no reserved entries in .igot.plt, and no special
8516          first entry in .iplt.  */
8517       got_header_size = 0;
8518       plt_header_size = 0;
8519     }
8520   else
8521     {
8522       splt = htab->root.splt;
8523       sgot = htab->root.sgotplt;
8524       srel = htab->root.srelplt;
8525
8526       got_header_size = get_elf_backend_data (output_bfd)->got_header_size;
8527       plt_header_size = htab->plt_header_size;
8528     }
8529   BFD_ASSERT (splt != NULL && srel != NULL);
8530
8531   /* Fill in the entry in the procedure linkage table.  */
8532   if (htab->symbian_p)
8533     {
8534       BFD_ASSERT (dynindx >= 0);
8535       put_arm_insn (htab, output_bfd,
8536                     elf32_arm_symbian_plt_entry[0],
8537                     splt->contents + root_plt->offset);
8538       bfd_put_32 (output_bfd,
8539                   elf32_arm_symbian_plt_entry[1],
8540                   splt->contents + root_plt->offset + 4);
8541
8542       /* Fill in the entry in the .rel.plt section.  */
8543       rel.r_offset = (splt->output_section->vma
8544                       + splt->output_offset
8545                       + root_plt->offset + 4);
8546       rel.r_info = ELF32_R_INFO (dynindx, R_ARM_GLOB_DAT);
8547
8548       /* Get the index in the procedure linkage table which
8549          corresponds to this symbol.  This is the index of this symbol
8550          in all the symbols for which we are making plt entries.  The
8551          first entry in the procedure linkage table is reserved.  */
8552       plt_index = ((root_plt->offset - plt_header_size)
8553                    / htab->plt_entry_size);
8554     }
8555   else
8556     {
8557       bfd_vma got_offset, got_address, plt_address;
8558       bfd_vma got_displacement, initial_got_entry;
8559       bfd_byte * ptr;
8560
8561       BFD_ASSERT (sgot != NULL);
8562
8563       /* Get the offset into the .(i)got.plt table of the entry that
8564          corresponds to this function.  */
8565       got_offset = (arm_plt->got_offset & -2);
8566
8567       /* Get the index in the procedure linkage table which
8568          corresponds to this symbol.  This is the index of this symbol
8569          in all the symbols for which we are making plt entries.
8570          After the reserved .got.plt entries, all symbols appear in
8571          the same order as in .plt.  */
8572       plt_index = (got_offset - got_header_size) / 4;
8573
8574       /* Calculate the address of the GOT entry.  */
8575       got_address = (sgot->output_section->vma
8576                      + sgot->output_offset
8577                      + got_offset);
8578
8579       /* ...and the address of the PLT entry.  */
8580       plt_address = (splt->output_section->vma
8581                      + splt->output_offset
8582                      + root_plt->offset);
8583
8584       ptr = splt->contents + root_plt->offset;
8585       if (htab->vxworks_p && bfd_link_pic (info))
8586         {
8587           unsigned int i;
8588           bfd_vma val;
8589
8590           for (i = 0; i != htab->plt_entry_size / 4; i++, ptr += 4)
8591             {
8592               val = elf32_arm_vxworks_shared_plt_entry[i];
8593               if (i == 2)
8594                 val |= got_address - sgot->output_section->vma;
8595               if (i == 5)
8596                 val |= plt_index * RELOC_SIZE (htab);
8597               if (i == 2 || i == 5)
8598                 bfd_put_32 (output_bfd, val, ptr);
8599               else
8600                 put_arm_insn (htab, output_bfd, val, ptr);
8601             }
8602         }
8603       else if (htab->vxworks_p)
8604         {
8605           unsigned int i;
8606           bfd_vma val;
8607
8608           for (i = 0; i != htab->plt_entry_size / 4; i++, ptr += 4)
8609             {
8610               val = elf32_arm_vxworks_exec_plt_entry[i];
8611               if (i == 2)
8612                 val |= got_address;
8613               if (i == 4)
8614                 val |= 0xffffff & -((root_plt->offset + i * 4 + 8) >> 2);
8615               if (i == 5)
8616                 val |= plt_index * RELOC_SIZE (htab);
8617               if (i == 2 || i == 5)
8618                 bfd_put_32 (output_bfd, val, ptr);
8619               else
8620                 put_arm_insn (htab, output_bfd, val, ptr);
8621             }
8622
8623           loc = (htab->srelplt2->contents
8624                  + (plt_index * 2 + 1) * RELOC_SIZE (htab));
8625
8626           /* Create the .rela.plt.unloaded R_ARM_ABS32 relocation
8627              referencing the GOT for this PLT entry.  */
8628           rel.r_offset = plt_address + 8;
8629           rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_ARM_ABS32);
8630           rel.r_addend = got_offset;
8631           SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc);
8632           loc += RELOC_SIZE (htab);
8633
8634           /* Create the R_ARM_ABS32 relocation referencing the
8635              beginning of the PLT for this GOT entry.  */
8636           rel.r_offset = got_address;
8637           rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_ARM_ABS32);
8638           rel.r_addend = 0;
8639           SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc);
8640         }
8641       else if (htab->nacl_p)
8642         {
8643           /* Calculate the displacement between the PLT slot and the
8644              common tail that's part of the special initial PLT slot.  */
8645           int32_t tail_displacement
8646             = ((splt->output_section->vma + splt->output_offset
8647                 + ARM_NACL_PLT_TAIL_OFFSET)
8648                - (plt_address + htab->plt_entry_size + 4));
8649           BFD_ASSERT ((tail_displacement & 3) == 0);
8650           tail_displacement >>= 2;
8651
8652           BFD_ASSERT ((tail_displacement & 0xff000000) == 0
8653                       || (-tail_displacement & 0xff000000) == 0);
8654
8655           /* Calculate the displacement between the PLT slot and the entry
8656              in the GOT.  The offset accounts for the value produced by
8657              adding to pc in the penultimate instruction of the PLT stub.  */
8658           got_displacement = (got_address
8659                               - (plt_address + htab->plt_entry_size));
8660
8661           /* NaCl does not support interworking at all.  */
8662           BFD_ASSERT (!elf32_arm_plt_needs_thumb_stub_p (info, arm_plt));
8663
8664           put_arm_insn (htab, output_bfd,
8665                         elf32_arm_nacl_plt_entry[0]
8666                         | arm_movw_immediate (got_displacement),
8667                         ptr + 0);
8668           put_arm_insn (htab, output_bfd,
8669                         elf32_arm_nacl_plt_entry[1]
8670                         | arm_movt_immediate (got_displacement),
8671                         ptr + 4);
8672           put_arm_insn (htab, output_bfd,
8673                         elf32_arm_nacl_plt_entry[2],
8674                         ptr + 8);
8675           put_arm_insn (htab, output_bfd,
8676                         elf32_arm_nacl_plt_entry[3]
8677                         | (tail_displacement & 0x00ffffff),
8678                         ptr + 12);
8679         }
8680       else if (using_thumb_only (htab))
8681         {
8682           /* PR ld/16017: Generate thumb only PLT entries.  */
8683           if (!using_thumb2 (htab))
8684             {
8685               /* FIXME: We ought to be able to generate thumb-1 PLT
8686                  instructions...  */
8687               _bfd_error_handler (_("%B: Warning: thumb-1 mode PLT generation not currently supported"),
8688                                   output_bfd);
8689               return FALSE;
8690             }
8691
8692           /* Calculate the displacement between the PLT slot and the entry in
8693              the GOT.  The 12-byte offset accounts for the value produced by
8694              adding to pc in the 3rd instruction of the PLT stub.  */
8695           got_displacement = got_address - (plt_address + 12);
8696
8697           /* As we are using 32 bit instructions we have to use 'put_arm_insn'
8698              instead of 'put_thumb_insn'.  */
8699           put_arm_insn (htab, output_bfd,
8700                         elf32_thumb2_plt_entry[0]
8701                         | ((got_displacement & 0x000000ff) << 16)
8702                         | ((got_displacement & 0x00000700) << 20)
8703                         | ((got_displacement & 0x00000800) >>  1)
8704                         | ((got_displacement & 0x0000f000) >> 12),
8705                         ptr + 0);
8706           put_arm_insn (htab, output_bfd,
8707                         elf32_thumb2_plt_entry[1]
8708                         | ((got_displacement & 0x00ff0000)      )
8709                         | ((got_displacement & 0x07000000) <<  4)
8710                         | ((got_displacement & 0x08000000) >> 17)
8711                         | ((got_displacement & 0xf0000000) >> 28),
8712                         ptr + 4);
8713           put_arm_insn (htab, output_bfd,
8714                         elf32_thumb2_plt_entry[2],
8715                         ptr + 8);
8716           put_arm_insn (htab, output_bfd,
8717                         elf32_thumb2_plt_entry[3],
8718                         ptr + 12);
8719         }
8720       else
8721         {
8722           /* Calculate the displacement between the PLT slot and the
8723              entry in the GOT.  The eight-byte offset accounts for the
8724              value produced by adding to pc in the first instruction
8725              of the PLT stub.  */
8726           got_displacement = got_address - (plt_address + 8);
8727
8728           if (elf32_arm_plt_needs_thumb_stub_p (info, arm_plt))
8729             {
8730               put_thumb_insn (htab, output_bfd,
8731                               elf32_arm_plt_thumb_stub[0], ptr - 4);
8732               put_thumb_insn (htab, output_bfd,
8733                               elf32_arm_plt_thumb_stub[1], ptr - 2);
8734             }
8735
8736           if (!elf32_arm_use_long_plt_entry)
8737             {
8738               BFD_ASSERT ((got_displacement & 0xf0000000) == 0);
8739
8740               put_arm_insn (htab, output_bfd,
8741                             elf32_arm_plt_entry_short[0]
8742                             | ((got_displacement & 0x0ff00000) >> 20),
8743                             ptr + 0);
8744               put_arm_insn (htab, output_bfd,
8745                             elf32_arm_plt_entry_short[1]
8746                             | ((got_displacement & 0x000ff000) >> 12),
8747                             ptr+ 4);
8748               put_arm_insn (htab, output_bfd,
8749                             elf32_arm_plt_entry_short[2]
8750                             | (got_displacement & 0x00000fff),
8751                             ptr + 8);
8752 #ifdef FOUR_WORD_PLT
8753               bfd_put_32 (output_bfd, elf32_arm_plt_entry_short[3], ptr + 12);
8754 #endif
8755             }
8756           else
8757             {
8758               put_arm_insn (htab, output_bfd,
8759                             elf32_arm_plt_entry_long[0]
8760                             | ((got_displacement & 0xf0000000) >> 28),
8761                             ptr + 0);
8762               put_arm_insn (htab, output_bfd,
8763                             elf32_arm_plt_entry_long[1]
8764                             | ((got_displacement & 0x0ff00000) >> 20),
8765                             ptr + 4);
8766               put_arm_insn (htab, output_bfd,
8767                             elf32_arm_plt_entry_long[2]
8768                             | ((got_displacement & 0x000ff000) >> 12),
8769                             ptr+ 8);
8770               put_arm_insn (htab, output_bfd,
8771                             elf32_arm_plt_entry_long[3]
8772                             | (got_displacement & 0x00000fff),
8773                             ptr + 12);
8774             }
8775         }
8776
8777       /* Fill in the entry in the .rel(a).(i)plt section.  */
8778       rel.r_offset = got_address;
8779       rel.r_addend = 0;
8780       if (dynindx == -1)
8781         {
8782           /* .igot.plt entries use IRELATIVE relocations against SYM_VALUE.
8783              The dynamic linker or static executable then calls SYM_VALUE
8784              to determine the correct run-time value of the .igot.plt entry.  */
8785           rel.r_info = ELF32_R_INFO (0, R_ARM_IRELATIVE);
8786           initial_got_entry = sym_value;
8787         }
8788       else
8789         {
8790           rel.r_info = ELF32_R_INFO (dynindx, R_ARM_JUMP_SLOT);
8791           initial_got_entry = (splt->output_section->vma
8792                                + splt->output_offset);
8793         }
8794
8795       /* Fill in the entry in the global offset table.  */
8796       bfd_put_32 (output_bfd, initial_got_entry,
8797                   sgot->contents + got_offset);
8798     }
8799
8800   if (dynindx == -1)
8801     elf32_arm_add_dynreloc (output_bfd, info, srel, &rel);
8802   else
8803     {
8804       loc = srel->contents + plt_index * RELOC_SIZE (htab);
8805       SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc);
8806     }
8807
8808   return TRUE;
8809 }
8810
8811 /* Some relocations map to different relocations depending on the
8812    target.  Return the real relocation.  */
8813
8814 static int
8815 arm_real_reloc_type (struct elf32_arm_link_hash_table * globals,
8816                      int r_type)
8817 {
8818   switch (r_type)
8819     {
8820     case R_ARM_TARGET1:
8821       if (globals->target1_is_rel)
8822         return R_ARM_REL32;
8823       else
8824         return R_ARM_ABS32;
8825
8826     case R_ARM_TARGET2:
8827       return globals->target2_reloc;
8828
8829     default:
8830       return r_type;
8831     }
8832 }
8833
8834 /* Return the base VMA address which should be subtracted from real addresses
8835    when resolving @dtpoff relocation.
8836    This is PT_TLS segment p_vaddr.  */
8837
8838 static bfd_vma
8839 dtpoff_base (struct bfd_link_info *info)
8840 {
8841   /* If tls_sec is NULL, we should have signalled an error already.  */
8842   if (elf_hash_table (info)->tls_sec == NULL)
8843     return 0;
8844   return elf_hash_table (info)->tls_sec->vma;
8845 }
8846
8847 /* Return the relocation value for @tpoff relocation
8848    if STT_TLS virtual address is ADDRESS.  */
8849
8850 static bfd_vma
8851 tpoff (struct bfd_link_info *info, bfd_vma address)
8852 {
8853   struct elf_link_hash_table *htab = elf_hash_table (info);
8854   bfd_vma base;
8855
8856   /* If tls_sec is NULL, we should have signalled an error already.  */
8857   if (htab->tls_sec == NULL)
8858     return 0;
8859   base = align_power ((bfd_vma) TCB_SIZE, htab->tls_sec->alignment_power);
8860   return address - htab->tls_sec->vma + base;
8861 }
8862
8863 /* Perform an R_ARM_ABS12 relocation on the field pointed to by DATA.
8864    VALUE is the relocation value.  */
8865
8866 static bfd_reloc_status_type
8867 elf32_arm_abs12_reloc (bfd *abfd, void *data, bfd_vma value)
8868 {
8869   if (value > 0xfff)
8870     return bfd_reloc_overflow;
8871
8872   value |= bfd_get_32 (abfd, data) & 0xfffff000;
8873   bfd_put_32 (abfd, value, data);
8874   return bfd_reloc_ok;
8875 }
8876
8877 /* Handle TLS relaxations.  Relaxing is possible for symbols that use
8878    R_ARM_GOTDESC, R_ARM_{,THM_}TLS_CALL or
8879    R_ARM_{,THM_}TLS_DESCSEQ relocations, during a static link.
8880
8881    Return bfd_reloc_ok if we're done, bfd_reloc_continue if the caller
8882    is to then call final_link_relocate.  Return other values in the
8883    case of error.
8884
8885    FIXME:When --emit-relocs is in effect, we'll emit relocs describing
8886    the pre-relaxed code.  It would be nice if the relocs were updated
8887    to match the optimization.   */
8888
8889 static bfd_reloc_status_type
8890 elf32_arm_tls_relax (struct elf32_arm_link_hash_table *globals,
8891                      bfd *input_bfd, asection *input_sec, bfd_byte *contents,
8892                      Elf_Internal_Rela *rel, unsigned long is_local)
8893 {
8894   unsigned long insn;
8895
8896   switch (ELF32_R_TYPE (rel->r_info))
8897     {
8898     default:
8899       return bfd_reloc_notsupported;
8900
8901     case R_ARM_TLS_GOTDESC:
8902       if (is_local)
8903         insn = 0;
8904       else
8905         {
8906           insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
8907           if (insn & 1)
8908             insn -= 5; /* THUMB */
8909           else
8910             insn -= 8; /* ARM */
8911         }
8912       bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
8913       return bfd_reloc_continue;
8914
8915     case R_ARM_THM_TLS_DESCSEQ:
8916       /* Thumb insn.  */
8917       insn = bfd_get_16 (input_bfd, contents + rel->r_offset);
8918       if ((insn & 0xff78) == 0x4478)      /* add rx, pc */
8919         {
8920           if (is_local)
8921             /* nop */
8922             bfd_put_16 (input_bfd, 0x46c0, contents + rel->r_offset);
8923         }
8924       else if ((insn & 0xffc0) == 0x6840)  /* ldr rx,[ry,#4] */
8925         {
8926           if (is_local)
8927             /* nop */
8928             bfd_put_16 (input_bfd, 0x46c0, contents + rel->r_offset);
8929           else
8930             /* ldr rx,[ry] */
8931             bfd_put_16 (input_bfd, insn & 0xf83f, contents + rel->r_offset);
8932         }
8933       else if ((insn & 0xff87) == 0x4780)  /* blx rx */
8934         {
8935           if (is_local)
8936             /* nop */
8937             bfd_put_16 (input_bfd, 0x46c0, contents + rel->r_offset);
8938           else
8939             /* mov r0, rx */
8940             bfd_put_16 (input_bfd, 0x4600 | (insn & 0x78),
8941                         contents + rel->r_offset);
8942         }
8943       else
8944         {
8945           if ((insn & 0xf000) == 0xf000 || (insn & 0xf800) == 0xe800)
8946             /* It's a 32 bit instruction, fetch the rest of it for
8947                error generation.  */
8948             insn = (insn << 16)
8949               | bfd_get_16 (input_bfd, contents + rel->r_offset + 2);
8950           (*_bfd_error_handler)
8951             (_("%B(%A+0x%lx):unexpected Thumb instruction '0x%x' in TLS trampoline"),
8952              input_bfd, input_sec, (unsigned long)rel->r_offset, insn);
8953           return bfd_reloc_notsupported;
8954         }
8955       break;
8956
8957     case R_ARM_TLS_DESCSEQ:
8958       /* arm insn.  */
8959       insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
8960       if ((insn & 0xffff0ff0) == 0xe08f0000) /* add rx,pc,ry */
8961         {
8962           if (is_local)
8963             /* mov rx, ry */
8964             bfd_put_32 (input_bfd, 0xe1a00000 | (insn & 0xffff),
8965                         contents + rel->r_offset);
8966         }
8967       else if ((insn & 0xfff00fff) == 0xe5900004) /* ldr rx,[ry,#4]*/
8968         {
8969           if (is_local)
8970             /* nop */
8971             bfd_put_32 (input_bfd, 0xe1a00000, contents + rel->r_offset);
8972           else
8973             /* ldr rx,[ry] */
8974             bfd_put_32 (input_bfd, insn & 0xfffff000,
8975                         contents + rel->r_offset);
8976         }
8977       else if ((insn & 0xfffffff0) == 0xe12fff30) /* blx rx */
8978         {
8979           if (is_local)
8980             /* nop */
8981             bfd_put_32 (input_bfd, 0xe1a00000, contents + rel->r_offset);
8982           else
8983             /* mov r0, rx */
8984             bfd_put_32 (input_bfd, 0xe1a00000 | (insn & 0xf),
8985                         contents + rel->r_offset);
8986         }
8987       else
8988         {
8989           (*_bfd_error_handler)
8990             (_("%B(%A+0x%lx):unexpected ARM instruction '0x%x' in TLS trampoline"),
8991              input_bfd, input_sec, (unsigned long)rel->r_offset, insn);
8992           return bfd_reloc_notsupported;
8993         }
8994       break;
8995
8996     case R_ARM_TLS_CALL:
8997       /* GD->IE relaxation, turn the instruction into 'nop' or
8998          'ldr r0, [pc,r0]'  */
8999       insn = is_local ? 0xe1a00000 : 0xe79f0000;
9000       bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
9001       break;
9002
9003     case R_ARM_THM_TLS_CALL:
9004       /* GD->IE relaxation.  */
9005       if (!is_local)
9006         /* add r0,pc; ldr r0, [r0]  */
9007         insn = 0x44786800;
9008       else if (using_thumb2 (globals))
9009         /* nop.w */
9010         insn = 0xf3af8000;
9011       else
9012         /* nop; nop */
9013         insn = 0xbf00bf00;
9014
9015       bfd_put_16 (input_bfd, insn >> 16, contents + rel->r_offset);
9016       bfd_put_16 (input_bfd, insn & 0xffff, contents + rel->r_offset + 2);
9017       break;
9018     }
9019   return bfd_reloc_ok;
9020 }
9021
9022 /* For a given value of n, calculate the value of G_n as required to
9023    deal with group relocations.  We return it in the form of an
9024    encoded constant-and-rotation, together with the final residual.  If n is
9025    specified as less than zero, then final_residual is filled with the
9026    input value and no further action is performed.  */
9027
9028 static bfd_vma
9029 calculate_group_reloc_mask (bfd_vma value, int n, bfd_vma *final_residual)
9030 {
9031   int current_n;
9032   bfd_vma g_n;
9033   bfd_vma encoded_g_n = 0;
9034   bfd_vma residual = value; /* Also known as Y_n.  */
9035
9036   for (current_n = 0; current_n <= n; current_n++)
9037     {
9038       int shift;
9039
9040       /* Calculate which part of the value to mask.  */
9041       if (residual == 0)
9042         shift = 0;
9043       else
9044         {
9045           int msb;
9046
9047           /* Determine the most significant bit in the residual and
9048              align the resulting value to a 2-bit boundary.  */
9049           for (msb = 30; msb >= 0; msb -= 2)
9050             if (residual & (3 << msb))
9051               break;
9052
9053           /* The desired shift is now (msb - 6), or zero, whichever
9054              is the greater.  */
9055           shift = msb - 6;
9056           if (shift < 0)
9057             shift = 0;
9058         }
9059
9060       /* Calculate g_n in 32-bit as well as encoded constant+rotation form.  */
9061       g_n = residual & (0xff << shift);
9062       encoded_g_n = (g_n >> shift)
9063                     | ((g_n <= 0xff ? 0 : (32 - shift) / 2) << 8);
9064
9065       /* Calculate the residual for the next time around.  */
9066       residual &= ~g_n;
9067     }
9068
9069   *final_residual = residual;
9070
9071   return encoded_g_n;
9072 }
9073
9074 /* Given an ARM instruction, determine whether it is an ADD or a SUB.
9075    Returns 1 if it is an ADD, -1 if it is a SUB, and 0 otherwise.  */
9076
9077 static int
9078 identify_add_or_sub (bfd_vma insn)
9079 {
9080   int opcode = insn & 0x1e00000;
9081
9082   if (opcode == 1 << 23) /* ADD */
9083     return 1;
9084
9085   if (opcode == 1 << 22) /* SUB */
9086     return -1;
9087
9088   return 0;
9089 }
9090
9091 /* Perform a relocation as part of a final link.  */
9092
9093 static bfd_reloc_status_type
9094 elf32_arm_final_link_relocate (reloc_howto_type *           howto,
9095                                bfd *                        input_bfd,
9096                                bfd *                        output_bfd,
9097                                asection *                   input_section,
9098                                bfd_byte *                   contents,
9099                                Elf_Internal_Rela *          rel,
9100                                bfd_vma                      value,
9101                                struct bfd_link_info *       info,
9102                                asection *                   sym_sec,
9103                                const char *                 sym_name,
9104                                unsigned char                st_type,
9105                                enum arm_st_branch_type      branch_type,
9106                                struct elf_link_hash_entry * h,
9107                                bfd_boolean *                unresolved_reloc_p,
9108                                char **                      error_message)
9109 {
9110   unsigned long                 r_type = howto->type;
9111   unsigned long                 r_symndx;
9112   bfd_byte *                    hit_data = contents + rel->r_offset;
9113   bfd_vma *                     local_got_offsets;
9114   bfd_vma *                     local_tlsdesc_gotents;
9115   asection *                    sgot;
9116   asection *                    splt;
9117   asection *                    sreloc = NULL;
9118   asection *                    srelgot;
9119   bfd_vma                       addend;
9120   bfd_signed_vma                signed_addend;
9121   unsigned char                 dynreloc_st_type;
9122   bfd_vma                       dynreloc_value;
9123   struct elf32_arm_link_hash_table * globals;
9124   struct elf32_arm_link_hash_entry *eh;
9125   union gotplt_union           *root_plt;
9126   struct arm_plt_info          *arm_plt;
9127   bfd_vma                       plt_offset;
9128   bfd_vma                       gotplt_offset;
9129   bfd_boolean                   has_iplt_entry;
9130
9131   globals = elf32_arm_hash_table (info);
9132   if (globals == NULL)
9133     return bfd_reloc_notsupported;
9134
9135   BFD_ASSERT (is_arm_elf (input_bfd));
9136
9137   /* Some relocation types map to different relocations depending on the
9138      target.  We pick the right one here.  */
9139   r_type = arm_real_reloc_type (globals, r_type);
9140
9141   /* It is possible to have linker relaxations on some TLS access
9142      models.  Update our information here.  */
9143   r_type = elf32_arm_tls_transition (info, r_type, h);
9144
9145   if (r_type != howto->type)
9146     howto = elf32_arm_howto_from_type (r_type);
9147
9148   eh = (struct elf32_arm_link_hash_entry *) h;
9149   sgot = globals->root.sgot;
9150   local_got_offsets = elf_local_got_offsets (input_bfd);
9151   local_tlsdesc_gotents = elf32_arm_local_tlsdesc_gotent (input_bfd);
9152
9153   if (globals->root.dynamic_sections_created)
9154     srelgot = globals->root.srelgot;
9155   else
9156     srelgot = NULL;
9157
9158   r_symndx = ELF32_R_SYM (rel->r_info);
9159
9160   if (globals->use_rel)
9161     {
9162       addend = bfd_get_32 (input_bfd, hit_data) & howto->src_mask;
9163
9164       if (addend & ((howto->src_mask + 1) >> 1))
9165         {
9166           signed_addend = -1;
9167           signed_addend &= ~ howto->src_mask;
9168           signed_addend |= addend;
9169         }
9170       else
9171         signed_addend = addend;
9172     }
9173   else
9174     addend = signed_addend = rel->r_addend;
9175
9176   /* ST_BRANCH_TO_ARM is nonsense to thumb-only targets when we
9177      are resolving a function call relocation.  */
9178   if (using_thumb_only (globals)
9179       && (r_type == R_ARM_THM_CALL
9180           || r_type == R_ARM_THM_JUMP24)
9181       && branch_type == ST_BRANCH_TO_ARM)
9182     branch_type = ST_BRANCH_TO_THUMB;
9183
9184   /* Record the symbol information that should be used in dynamic
9185      relocations.  */
9186   dynreloc_st_type = st_type;
9187   dynreloc_value = value;
9188   if (branch_type == ST_BRANCH_TO_THUMB)
9189     dynreloc_value |= 1;
9190
9191   /* Find out whether the symbol has a PLT.  Set ST_VALUE, BRANCH_TYPE and
9192      VALUE appropriately for relocations that we resolve at link time.  */
9193   has_iplt_entry = FALSE;
9194   if (elf32_arm_get_plt_info (input_bfd, eh, r_symndx, &root_plt, &arm_plt)
9195       && root_plt->offset != (bfd_vma) -1)
9196     {
9197       plt_offset = root_plt->offset;
9198       gotplt_offset = arm_plt->got_offset;
9199
9200       if (h == NULL || eh->is_iplt)
9201         {
9202           has_iplt_entry = TRUE;
9203           splt = globals->root.iplt;
9204
9205           /* Populate .iplt entries here, because not all of them will
9206              be seen by finish_dynamic_symbol.  The lower bit is set if
9207              we have already populated the entry.  */
9208           if (plt_offset & 1)
9209             plt_offset--;
9210           else
9211             {
9212               if (elf32_arm_populate_plt_entry (output_bfd, info, root_plt, arm_plt,
9213                                                 -1, dynreloc_value))
9214                 root_plt->offset |= 1;
9215               else
9216                 return bfd_reloc_notsupported;
9217             }
9218
9219           /* Static relocations always resolve to the .iplt entry.  */
9220           st_type = STT_FUNC;
9221           value = (splt->output_section->vma
9222                    + splt->output_offset
9223                    + plt_offset);
9224           branch_type = ST_BRANCH_TO_ARM;
9225
9226           /* If there are non-call relocations that resolve to the .iplt
9227              entry, then all dynamic ones must too.  */
9228           if (arm_plt->noncall_refcount != 0)
9229             {
9230               dynreloc_st_type = st_type;
9231               dynreloc_value = value;
9232             }
9233         }
9234       else
9235         /* We populate the .plt entry in finish_dynamic_symbol.  */
9236         splt = globals->root.splt;
9237     }
9238   else
9239     {
9240       splt = NULL;
9241       plt_offset = (bfd_vma) -1;
9242       gotplt_offset = (bfd_vma) -1;
9243     }
9244
9245   switch (r_type)
9246     {
9247     case R_ARM_NONE:
9248       /* We don't need to find a value for this symbol.  It's just a
9249          marker.  */
9250       *unresolved_reloc_p = FALSE;
9251       return bfd_reloc_ok;
9252
9253     case R_ARM_ABS12:
9254       if (!globals->vxworks_p)
9255         return elf32_arm_abs12_reloc (input_bfd, hit_data, value + addend);
9256
9257     case R_ARM_PC24:
9258     case R_ARM_ABS32:
9259     case R_ARM_ABS32_NOI:
9260     case R_ARM_REL32:
9261     case R_ARM_REL32_NOI:
9262     case R_ARM_CALL:
9263     case R_ARM_JUMP24:
9264     case R_ARM_XPC25:
9265     case R_ARM_PREL31:
9266     case R_ARM_PLT32:
9267       /* Handle relocations which should use the PLT entry.  ABS32/REL32
9268          will use the symbol's value, which may point to a PLT entry, but we
9269          don't need to handle that here.  If we created a PLT entry, all
9270          branches in this object should go to it, except if the PLT is too
9271          far away, in which case a long branch stub should be inserted.  */
9272       if ((r_type != R_ARM_ABS32 && r_type != R_ARM_REL32
9273            && r_type != R_ARM_ABS32_NOI && r_type != R_ARM_REL32_NOI
9274            && r_type != R_ARM_CALL
9275            && r_type != R_ARM_JUMP24
9276            && r_type != R_ARM_PLT32)
9277           && plt_offset != (bfd_vma) -1)
9278         {
9279           /* If we've created a .plt section, and assigned a PLT entry
9280              to this function, it must either be a STT_GNU_IFUNC reference
9281              or not be known to bind locally.  In other cases, we should
9282              have cleared the PLT entry by now.  */
9283           BFD_ASSERT (has_iplt_entry || !SYMBOL_CALLS_LOCAL (info, h));
9284
9285           value = (splt->output_section->vma
9286                    + splt->output_offset
9287                    + plt_offset);
9288           *unresolved_reloc_p = FALSE;
9289           return _bfd_final_link_relocate (howto, input_bfd, input_section,
9290                                            contents, rel->r_offset, value,
9291                                            rel->r_addend);
9292         }
9293
9294       /* When generating a shared object or relocatable executable, these
9295          relocations are copied into the output file to be resolved at
9296          run time.  */
9297       if ((bfd_link_pic (info)
9298            || globals->root.is_relocatable_executable)
9299           && (input_section->flags & SEC_ALLOC)
9300           && !(globals->vxworks_p
9301                && strcmp (input_section->output_section->name,
9302                           ".tls_vars") == 0)
9303           && ((r_type != R_ARM_REL32 && r_type != R_ARM_REL32_NOI)
9304               || !SYMBOL_CALLS_LOCAL (info, h))
9305           && !(input_bfd == globals->stub_bfd
9306                && strstr (input_section->name, STUB_SUFFIX))
9307           && (h == NULL
9308               || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9309               || h->root.type != bfd_link_hash_undefweak)
9310           && r_type != R_ARM_PC24
9311           && r_type != R_ARM_CALL
9312           && r_type != R_ARM_JUMP24
9313           && r_type != R_ARM_PREL31
9314           && r_type != R_ARM_PLT32)
9315         {
9316           Elf_Internal_Rela outrel;
9317           bfd_boolean skip, relocate;
9318
9319           if ((r_type == R_ARM_REL32 || r_type == R_ARM_REL32_NOI)
9320               && !h->def_regular)
9321             {
9322               char *v = _("shared object");
9323
9324               if (bfd_link_executable (info))
9325                 v = _("PIE executable");
9326
9327               (*_bfd_error_handler)
9328                 (_("%B: relocation %s against external or undefined symbol `%s'"
9329                    " can not be used when making a %s; recompile with -fPIC"), input_bfd,
9330                  elf32_arm_howto_table_1[r_type].name, h->root.root.string, v);
9331               return bfd_reloc_notsupported;
9332             }
9333
9334           *unresolved_reloc_p = FALSE;
9335
9336           if (sreloc == NULL && globals->root.dynamic_sections_created)
9337             {
9338               sreloc = _bfd_elf_get_dynamic_reloc_section (input_bfd, input_section,
9339                                                            ! globals->use_rel);
9340
9341               if (sreloc == NULL)
9342                 return bfd_reloc_notsupported;
9343             }
9344
9345           skip = FALSE;
9346           relocate = FALSE;
9347
9348           outrel.r_addend = addend;
9349           outrel.r_offset =
9350             _bfd_elf_section_offset (output_bfd, info, input_section,
9351                                      rel->r_offset);
9352           if (outrel.r_offset == (bfd_vma) -1)
9353             skip = TRUE;
9354           else if (outrel.r_offset == (bfd_vma) -2)
9355             skip = TRUE, relocate = TRUE;
9356           outrel.r_offset += (input_section->output_section->vma
9357                               + input_section->output_offset);
9358
9359           if (skip)
9360             memset (&outrel, 0, sizeof outrel);
9361           else if (h != NULL
9362                    && h->dynindx != -1
9363                    && (!bfd_link_pic (info)
9364                        || !SYMBOLIC_BIND (info, h)
9365                        || !h->def_regular))
9366             outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
9367           else
9368             {
9369               int symbol;
9370
9371               /* This symbol is local, or marked to become local.  */
9372               BFD_ASSERT (r_type == R_ARM_ABS32 || r_type == R_ARM_ABS32_NOI);
9373               if (globals->symbian_p)
9374                 {
9375                   asection *osec;
9376
9377                   /* On Symbian OS, the data segment and text segement
9378                      can be relocated independently.  Therefore, we
9379                      must indicate the segment to which this
9380                      relocation is relative.  The BPABI allows us to
9381                      use any symbol in the right segment; we just use
9382                      the section symbol as it is convenient.  (We
9383                      cannot use the symbol given by "h" directly as it
9384                      will not appear in the dynamic symbol table.)
9385
9386                      Note that the dynamic linker ignores the section
9387                      symbol value, so we don't subtract osec->vma
9388                      from the emitted reloc addend.  */
9389                   if (sym_sec)
9390                     osec = sym_sec->output_section;
9391                   else
9392                     osec = input_section->output_section;
9393                   symbol = elf_section_data (osec)->dynindx;
9394                   if (symbol == 0)
9395                     {
9396                       struct elf_link_hash_table *htab = elf_hash_table (info);
9397
9398                       if ((osec->flags & SEC_READONLY) == 0
9399                           && htab->data_index_section != NULL)
9400                         osec = htab->data_index_section;
9401                       else
9402                         osec = htab->text_index_section;
9403                       symbol = elf_section_data (osec)->dynindx;
9404                     }
9405                   BFD_ASSERT (symbol != 0);
9406                 }
9407               else
9408                 /* On SVR4-ish systems, the dynamic loader cannot
9409                    relocate the text and data segments independently,
9410                    so the symbol does not matter.  */
9411                 symbol = 0;
9412               if (dynreloc_st_type == STT_GNU_IFUNC)
9413                 /* We have an STT_GNU_IFUNC symbol that doesn't resolve
9414                    to the .iplt entry.  Instead, every non-call reference
9415                    must use an R_ARM_IRELATIVE relocation to obtain the
9416                    correct run-time address.  */
9417                 outrel.r_info = ELF32_R_INFO (symbol, R_ARM_IRELATIVE);
9418               else
9419                 outrel.r_info = ELF32_R_INFO (symbol, R_ARM_RELATIVE);
9420               if (globals->use_rel)
9421                 relocate = TRUE;
9422               else
9423                 outrel.r_addend += dynreloc_value;
9424             }
9425
9426           elf32_arm_add_dynreloc (output_bfd, info, sreloc, &outrel);
9427
9428           /* If this reloc is against an external symbol, we do not want to
9429              fiddle with the addend.  Otherwise, we need to include the symbol
9430              value so that it becomes an addend for the dynamic reloc.  */
9431           if (! relocate)
9432             return bfd_reloc_ok;
9433
9434           return _bfd_final_link_relocate (howto, input_bfd, input_section,
9435                                            contents, rel->r_offset,
9436                                            dynreloc_value, (bfd_vma) 0);
9437         }
9438       else switch (r_type)
9439         {
9440         case R_ARM_ABS12:
9441           return elf32_arm_abs12_reloc (input_bfd, hit_data, value + addend);
9442
9443         case R_ARM_XPC25:         /* Arm BLX instruction.  */
9444         case R_ARM_CALL:
9445         case R_ARM_JUMP24:
9446         case R_ARM_PC24:          /* Arm B/BL instruction.  */
9447         case R_ARM_PLT32:
9448           {
9449           struct elf32_arm_stub_hash_entry *stub_entry = NULL;
9450
9451           if (r_type == R_ARM_XPC25)
9452             {
9453               /* Check for Arm calling Arm function.  */
9454               /* FIXME: Should we translate the instruction into a BL
9455                  instruction instead ?  */
9456               if (branch_type != ST_BRANCH_TO_THUMB)
9457                 (*_bfd_error_handler)
9458                   (_("\%B: Warning: Arm BLX instruction targets Arm function '%s'."),
9459                    input_bfd,
9460                    h ? h->root.root.string : "(local)");
9461             }
9462           else if (r_type == R_ARM_PC24)
9463             {
9464               /* Check for Arm calling Thumb function.  */
9465               if (branch_type == ST_BRANCH_TO_THUMB)
9466                 {
9467                   if (elf32_arm_to_thumb_stub (info, sym_name, input_bfd,
9468                                                output_bfd, input_section,
9469                                                hit_data, sym_sec, rel->r_offset,
9470                                                signed_addend, value,
9471                                                error_message))
9472                     return bfd_reloc_ok;
9473                   else
9474                     return bfd_reloc_dangerous;
9475                 }
9476             }
9477
9478           /* Check if a stub has to be inserted because the
9479              destination is too far or we are changing mode.  */
9480           if (   r_type == R_ARM_CALL
9481               || r_type == R_ARM_JUMP24
9482               || r_type == R_ARM_PLT32)
9483             {
9484               enum elf32_arm_stub_type stub_type = arm_stub_none;
9485               struct elf32_arm_link_hash_entry *hash;
9486
9487               hash = (struct elf32_arm_link_hash_entry *) h;
9488               stub_type = arm_type_of_stub (info, input_section, rel,
9489                                             st_type, &branch_type,
9490                                             hash, value, sym_sec,
9491                                             input_bfd, sym_name);
9492
9493               if (stub_type != arm_stub_none)
9494                 {
9495                   /* The target is out of reach, so redirect the
9496                      branch to the local stub for this function.  */
9497                   stub_entry = elf32_arm_get_stub_entry (input_section,
9498                                                          sym_sec, h,
9499                                                          rel, globals,
9500                                                          stub_type);
9501                   {
9502                     if (stub_entry != NULL)
9503                       value = (stub_entry->stub_offset
9504                                + stub_entry->stub_sec->output_offset
9505                                + stub_entry->stub_sec->output_section->vma);
9506
9507                     if (plt_offset != (bfd_vma) -1)
9508                       *unresolved_reloc_p = FALSE;
9509                   }
9510                 }
9511               else
9512                 {
9513                   /* If the call goes through a PLT entry, make sure to
9514                      check distance to the right destination address.  */
9515                   if (plt_offset != (bfd_vma) -1)
9516                     {
9517                       value = (splt->output_section->vma
9518                                + splt->output_offset
9519                                + plt_offset);
9520                       *unresolved_reloc_p = FALSE;
9521                       /* The PLT entry is in ARM mode, regardless of the
9522                          target function.  */
9523                       branch_type = ST_BRANCH_TO_ARM;
9524                     }
9525                 }
9526             }
9527
9528           /* The ARM ELF ABI says that this reloc is computed as: S - P + A
9529              where:
9530               S is the address of the symbol in the relocation.
9531               P is address of the instruction being relocated.
9532               A is the addend (extracted from the instruction) in bytes.
9533
9534              S is held in 'value'.
9535              P is the base address of the section containing the
9536                instruction plus the offset of the reloc into that
9537                section, ie:
9538                  (input_section->output_section->vma +
9539                   input_section->output_offset +
9540                   rel->r_offset).
9541              A is the addend, converted into bytes, ie:
9542                  (signed_addend * 4)
9543
9544              Note: None of these operations have knowledge of the pipeline
9545              size of the processor, thus it is up to the assembler to
9546              encode this information into the addend.  */
9547           value -= (input_section->output_section->vma
9548                     + input_section->output_offset);
9549           value -= rel->r_offset;
9550           if (globals->use_rel)
9551             value += (signed_addend << howto->size);
9552           else
9553             /* RELA addends do not have to be adjusted by howto->size.  */
9554             value += signed_addend;
9555
9556           signed_addend = value;
9557           signed_addend >>= howto->rightshift;
9558
9559           /* A branch to an undefined weak symbol is turned into a jump to
9560              the next instruction unless a PLT entry will be created.
9561              Do the same for local undefined symbols (but not for STN_UNDEF).
9562              The jump to the next instruction is optimized as a NOP depending
9563              on the architecture.  */
9564           if (h ? (h->root.type == bfd_link_hash_undefweak
9565                    && plt_offset == (bfd_vma) -1)
9566               : r_symndx != STN_UNDEF && bfd_is_und_section (sym_sec))
9567             {
9568               value = (bfd_get_32 (input_bfd, hit_data) & 0xf0000000);
9569
9570               if (arch_has_arm_nop (globals))
9571                 value |= 0x0320f000;
9572               else
9573                 value |= 0x01a00000; /* Using pre-UAL nop: mov r0, r0.  */
9574             }
9575           else
9576             {
9577               /* Perform a signed range check.  */
9578               if (   signed_addend >   ((bfd_signed_vma)  (howto->dst_mask >> 1))
9579                   || signed_addend < - ((bfd_signed_vma) ((howto->dst_mask + 1) >> 1)))
9580                 return bfd_reloc_overflow;
9581
9582               addend = (value & 2);
9583
9584               value = (signed_addend & howto->dst_mask)
9585                 | (bfd_get_32 (input_bfd, hit_data) & (~ howto->dst_mask));
9586
9587               if (r_type == R_ARM_CALL)
9588                 {
9589                   /* Set the H bit in the BLX instruction.  */
9590                   if (branch_type == ST_BRANCH_TO_THUMB)
9591                     {
9592                       if (addend)
9593                         value |= (1 << 24);
9594                       else
9595                         value &= ~(bfd_vma)(1 << 24);
9596                     }
9597
9598                   /* Select the correct instruction (BL or BLX).  */
9599                   /* Only if we are not handling a BL to a stub. In this
9600                      case, mode switching is performed by the stub.  */
9601                   if (branch_type == ST_BRANCH_TO_THUMB && !stub_entry)
9602                     value |= (1 << 28);
9603                   else if (stub_entry || branch_type != ST_BRANCH_UNKNOWN)
9604                     {
9605                       value &= ~(bfd_vma)(1 << 28);
9606                       value |= (1 << 24);
9607                     }
9608                 }
9609             }
9610           }
9611           break;
9612
9613         case R_ARM_ABS32:
9614           value += addend;
9615           if (branch_type == ST_BRANCH_TO_THUMB)
9616             value |= 1;
9617           break;
9618
9619         case R_ARM_ABS32_NOI:
9620           value += addend;
9621           break;
9622
9623         case R_ARM_REL32:
9624           value += addend;
9625           if (branch_type == ST_BRANCH_TO_THUMB)
9626             value |= 1;
9627           value -= (input_section->output_section->vma
9628                     + input_section->output_offset + rel->r_offset);
9629           break;
9630
9631         case R_ARM_REL32_NOI:
9632           value += addend;
9633           value -= (input_section->output_section->vma
9634                     + input_section->output_offset + rel->r_offset);
9635           break;
9636
9637         case R_ARM_PREL31:
9638           value -= (input_section->output_section->vma
9639                     + input_section->output_offset + rel->r_offset);
9640           value += signed_addend;
9641           if (! h || h->root.type != bfd_link_hash_undefweak)
9642             {
9643               /* Check for overflow.  */
9644               if ((value ^ (value >> 1)) & (1 << 30))
9645                 return bfd_reloc_overflow;
9646             }
9647           value &= 0x7fffffff;
9648           value |= (bfd_get_32 (input_bfd, hit_data) & 0x80000000);
9649           if (branch_type == ST_BRANCH_TO_THUMB)
9650             value |= 1;
9651           break;
9652         }
9653
9654       bfd_put_32 (input_bfd, value, hit_data);
9655       return bfd_reloc_ok;
9656
9657     case R_ARM_ABS8:
9658       /* PR 16202: Refectch the addend using the correct size.  */
9659       if (globals->use_rel)
9660         addend = bfd_get_8 (input_bfd, hit_data);
9661       value += addend;
9662
9663       /* There is no way to tell whether the user intended to use a signed or
9664          unsigned addend.  When checking for overflow we accept either,
9665          as specified by the AAELF.  */
9666       if ((long) value > 0xff || (long) value < -0x80)
9667         return bfd_reloc_overflow;
9668
9669       bfd_put_8 (input_bfd, value, hit_data);
9670       return bfd_reloc_ok;
9671
9672     case R_ARM_ABS16:
9673       /* PR 16202: Refectch the addend using the correct size.  */
9674       if (globals->use_rel)
9675         addend = bfd_get_16 (input_bfd, hit_data);
9676       value += addend;
9677
9678       /* See comment for R_ARM_ABS8.  */
9679       if ((long) value > 0xffff || (long) value < -0x8000)
9680         return bfd_reloc_overflow;
9681
9682       bfd_put_16 (input_bfd, value, hit_data);
9683       return bfd_reloc_ok;
9684
9685     case R_ARM_THM_ABS5:
9686       /* Support ldr and str instructions for the thumb.  */
9687       if (globals->use_rel)
9688         {
9689           /* Need to refetch addend.  */
9690           addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
9691           /* ??? Need to determine shift amount from operand size.  */
9692           addend >>= howto->rightshift;
9693         }
9694       value += addend;
9695
9696       /* ??? Isn't value unsigned?  */
9697       if ((long) value > 0x1f || (long) value < -0x10)
9698         return bfd_reloc_overflow;
9699
9700       /* ??? Value needs to be properly shifted into place first.  */
9701       value |= bfd_get_16 (input_bfd, hit_data) & 0xf83f;
9702       bfd_put_16 (input_bfd, value, hit_data);
9703       return bfd_reloc_ok;
9704
9705     case R_ARM_THM_ALU_PREL_11_0:
9706       /* Corresponds to: addw.w reg, pc, #offset (and similarly for subw).  */
9707       {
9708         bfd_vma insn;
9709         bfd_signed_vma relocation;
9710
9711         insn = (bfd_get_16 (input_bfd, hit_data) << 16)
9712              | bfd_get_16 (input_bfd, hit_data + 2);
9713
9714         if (globals->use_rel)
9715           {
9716             signed_addend = (insn & 0xff) | ((insn & 0x7000) >> 4)
9717                           | ((insn & (1 << 26)) >> 15);
9718             if (insn & 0xf00000)
9719               signed_addend = -signed_addend;
9720           }
9721
9722         relocation = value + signed_addend;
9723         relocation -= Pa (input_section->output_section->vma
9724                           + input_section->output_offset
9725                           + rel->r_offset);
9726
9727         value = relocation;
9728
9729         if (value >= 0x1000)
9730           return bfd_reloc_overflow;
9731
9732         insn = (insn & 0xfb0f8f00) | (value & 0xff)
9733              | ((value & 0x700) << 4)
9734              | ((value & 0x800) << 15);
9735         if (relocation < 0)
9736           insn |= 0xa00000;
9737
9738         bfd_put_16 (input_bfd, insn >> 16, hit_data);
9739         bfd_put_16 (input_bfd, insn & 0xffff, hit_data + 2);
9740
9741         return bfd_reloc_ok;
9742       }
9743
9744     case R_ARM_THM_PC8:
9745       /* PR 10073:  This reloc is not generated by the GNU toolchain,
9746          but it is supported for compatibility with third party libraries
9747          generated by other compilers, specifically the ARM/IAR.  */
9748       {
9749         bfd_vma insn;
9750         bfd_signed_vma relocation;
9751
9752         insn = bfd_get_16 (input_bfd, hit_data);
9753
9754         if (globals->use_rel)
9755           addend = ((((insn & 0x00ff) << 2) + 4) & 0x3ff) -4;
9756
9757         relocation = value + addend;
9758         relocation -= Pa (input_section->output_section->vma
9759                           + input_section->output_offset
9760                           + rel->r_offset);
9761
9762         value = relocation;
9763
9764         /* We do not check for overflow of this reloc.  Although strictly
9765            speaking this is incorrect, it appears to be necessary in order
9766            to work with IAR generated relocs.  Since GCC and GAS do not
9767            generate R_ARM_THM_PC8 relocs, the lack of a check should not be
9768            a problem for them.  */
9769         value &= 0x3fc;
9770
9771         insn = (insn & 0xff00) | (value >> 2);
9772
9773         bfd_put_16 (input_bfd, insn, hit_data);
9774
9775         return bfd_reloc_ok;
9776       }
9777
9778     case R_ARM_THM_PC12:
9779       /* Corresponds to: ldr.w reg, [pc, #offset].  */
9780       {
9781         bfd_vma insn;
9782         bfd_signed_vma relocation;
9783
9784         insn = (bfd_get_16 (input_bfd, hit_data) << 16)
9785              | bfd_get_16 (input_bfd, hit_data + 2);
9786
9787         if (globals->use_rel)
9788           {
9789             signed_addend = insn & 0xfff;
9790             if (!(insn & (1 << 23)))
9791               signed_addend = -signed_addend;
9792           }
9793
9794         relocation = value + signed_addend;
9795         relocation -= Pa (input_section->output_section->vma
9796                           + input_section->output_offset
9797                           + rel->r_offset);
9798
9799         value = relocation;
9800
9801         if (value >= 0x1000)
9802           return bfd_reloc_overflow;
9803
9804         insn = (insn & 0xff7ff000) | value;
9805         if (relocation >= 0)
9806           insn |= (1 << 23);
9807
9808         bfd_put_16 (input_bfd, insn >> 16, hit_data);
9809         bfd_put_16 (input_bfd, insn & 0xffff, hit_data + 2);
9810
9811         return bfd_reloc_ok;
9812       }
9813
9814     case R_ARM_THM_XPC22:
9815     case R_ARM_THM_CALL:
9816     case R_ARM_THM_JUMP24:
9817       /* Thumb BL (branch long instruction).  */
9818       {
9819         bfd_vma relocation;
9820         bfd_vma reloc_sign;
9821         bfd_boolean overflow = FALSE;
9822         bfd_vma upper_insn = bfd_get_16 (input_bfd, hit_data);
9823         bfd_vma lower_insn = bfd_get_16 (input_bfd, hit_data + 2);
9824         bfd_signed_vma reloc_signed_max;
9825         bfd_signed_vma reloc_signed_min;
9826         bfd_vma check;
9827         bfd_signed_vma signed_check;
9828         int bitsize;
9829         const int thumb2 = using_thumb2 (globals);
9830
9831         /* A branch to an undefined weak symbol is turned into a jump to
9832            the next instruction unless a PLT entry will be created.
9833            The jump to the next instruction is optimized as a NOP.W for
9834            Thumb-2 enabled architectures.  */
9835         if (h && h->root.type == bfd_link_hash_undefweak
9836             && plt_offset == (bfd_vma) -1)
9837           {
9838             if (thumb2)
9839               {
9840                 bfd_put_16 (input_bfd, 0xf3af, hit_data);
9841                 bfd_put_16 (input_bfd, 0x8000, hit_data + 2);
9842               }
9843             else
9844               {
9845                 bfd_put_16 (input_bfd, 0xe000, hit_data);
9846                 bfd_put_16 (input_bfd, 0xbf00, hit_data + 2);
9847               }
9848             return bfd_reloc_ok;
9849           }
9850
9851         /* Fetch the addend.  We use the Thumb-2 encoding (backwards compatible
9852            with Thumb-1) involving the J1 and J2 bits.  */
9853         if (globals->use_rel)
9854           {
9855             bfd_vma s = (upper_insn & (1 << 10)) >> 10;
9856             bfd_vma upper = upper_insn & 0x3ff;
9857             bfd_vma lower = lower_insn & 0x7ff;
9858             bfd_vma j1 = (lower_insn & (1 << 13)) >> 13;
9859             bfd_vma j2 = (lower_insn & (1 << 11)) >> 11;
9860             bfd_vma i1 = j1 ^ s ? 0 : 1;
9861             bfd_vma i2 = j2 ^ s ? 0 : 1;
9862
9863             addend = (i1 << 23) | (i2 << 22) | (upper << 12) | (lower << 1);
9864             /* Sign extend.  */
9865             addend = (addend | ((s ? 0 : 1) << 24)) - (1 << 24);
9866
9867             signed_addend = addend;
9868           }
9869
9870         if (r_type == R_ARM_THM_XPC22)
9871           {
9872             /* Check for Thumb to Thumb call.  */
9873             /* FIXME: Should we translate the instruction into a BL
9874                instruction instead ?  */
9875             if (branch_type == ST_BRANCH_TO_THUMB)
9876               (*_bfd_error_handler)
9877                 (_("%B: Warning: Thumb BLX instruction targets thumb function '%s'."),
9878                  input_bfd,
9879                  h ? h->root.root.string : "(local)");
9880           }
9881         else
9882           {
9883             /* If it is not a call to Thumb, assume call to Arm.
9884                If it is a call relative to a section name, then it is not a
9885                function call at all, but rather a long jump.  Calls through
9886                the PLT do not require stubs.  */
9887             if (branch_type == ST_BRANCH_TO_ARM && plt_offset == (bfd_vma) -1)
9888               {
9889                 if (globals->use_blx && r_type == R_ARM_THM_CALL)
9890                   {
9891                     /* Convert BL to BLX.  */
9892                     lower_insn = (lower_insn & ~0x1000) | 0x0800;
9893                   }
9894                 else if ((   r_type != R_ARM_THM_CALL)
9895                          && (r_type != R_ARM_THM_JUMP24))
9896                   {
9897                     if (elf32_thumb_to_arm_stub
9898                         (info, sym_name, input_bfd, output_bfd, input_section,
9899                          hit_data, sym_sec, rel->r_offset, signed_addend, value,
9900                          error_message))
9901                       return bfd_reloc_ok;
9902                     else
9903                       return bfd_reloc_dangerous;
9904                   }
9905               }
9906             else if (branch_type == ST_BRANCH_TO_THUMB
9907                      && globals->use_blx
9908                      && r_type == R_ARM_THM_CALL)
9909               {
9910                 /* Make sure this is a BL.  */
9911                 lower_insn |= 0x1800;
9912               }
9913           }
9914
9915         enum elf32_arm_stub_type stub_type = arm_stub_none;
9916         if (r_type == R_ARM_THM_CALL || r_type == R_ARM_THM_JUMP24)
9917           {
9918             /* Check if a stub has to be inserted because the destination
9919                is too far.  */
9920             struct elf32_arm_stub_hash_entry *stub_entry;
9921             struct elf32_arm_link_hash_entry *hash;
9922
9923             hash = (struct elf32_arm_link_hash_entry *) h;
9924
9925             stub_type = arm_type_of_stub (info, input_section, rel,
9926                                           st_type, &branch_type,
9927                                           hash, value, sym_sec,
9928                                           input_bfd, sym_name);
9929
9930             if (stub_type != arm_stub_none)
9931               {
9932                 /* The target is out of reach or we are changing modes, so
9933                    redirect the branch to the local stub for this
9934                    function.  */
9935                 stub_entry = elf32_arm_get_stub_entry (input_section,
9936                                                        sym_sec, h,
9937                                                        rel, globals,
9938                                                        stub_type);
9939                 if (stub_entry != NULL)
9940                   {
9941                     value = (stub_entry->stub_offset
9942                              + stub_entry->stub_sec->output_offset
9943                              + stub_entry->stub_sec->output_section->vma);
9944
9945                     if (plt_offset != (bfd_vma) -1)
9946                       *unresolved_reloc_p = FALSE;
9947                   }
9948
9949                 /* If this call becomes a call to Arm, force BLX.  */
9950                 if (globals->use_blx && (r_type == R_ARM_THM_CALL))
9951                   {
9952                     if ((stub_entry
9953                          && !arm_stub_is_thumb (stub_entry->stub_type))
9954                         || branch_type != ST_BRANCH_TO_THUMB)
9955                       lower_insn = (lower_insn & ~0x1000) | 0x0800;
9956                   }
9957               }
9958           }
9959
9960         /* Handle calls via the PLT.  */
9961         if (stub_type == arm_stub_none && plt_offset != (bfd_vma) -1)
9962           {
9963             value = (splt->output_section->vma
9964                      + splt->output_offset
9965                      + plt_offset);
9966
9967             if (globals->use_blx
9968                 && r_type == R_ARM_THM_CALL
9969                 && ! using_thumb_only (globals))
9970               {
9971                 /* If the Thumb BLX instruction is available, convert
9972                    the BL to a BLX instruction to call the ARM-mode
9973                    PLT entry.  */
9974                 lower_insn = (lower_insn & ~0x1000) | 0x0800;
9975                 branch_type = ST_BRANCH_TO_ARM;
9976               }
9977             else
9978               {
9979                 if (! using_thumb_only (globals))
9980                   /* Target the Thumb stub before the ARM PLT entry.  */
9981                   value -= PLT_THUMB_STUB_SIZE;
9982                 branch_type = ST_BRANCH_TO_THUMB;
9983               }
9984             *unresolved_reloc_p = FALSE;
9985           }
9986
9987         relocation = value + signed_addend;
9988
9989         relocation -= (input_section->output_section->vma
9990                        + input_section->output_offset
9991                        + rel->r_offset);
9992
9993         check = relocation >> howto->rightshift;
9994
9995         /* If this is a signed value, the rightshift just dropped
9996            leading 1 bits (assuming twos complement).  */
9997         if ((bfd_signed_vma) relocation >= 0)
9998           signed_check = check;
9999         else
10000           signed_check = check | ~((bfd_vma) -1 >> howto->rightshift);
10001
10002         /* Calculate the permissable maximum and minimum values for
10003            this relocation according to whether we're relocating for
10004            Thumb-2 or not.  */
10005         bitsize = howto->bitsize;
10006         if (!thumb2)
10007           bitsize -= 2;
10008         reloc_signed_max = (1 << (bitsize - 1)) - 1;
10009         reloc_signed_min = ~reloc_signed_max;
10010
10011         /* Assumes two's complement.  */
10012         if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
10013           overflow = TRUE;
10014
10015         if ((lower_insn & 0x5000) == 0x4000)
10016           /* For a BLX instruction, make sure that the relocation is rounded up
10017              to a word boundary.  This follows the semantics of the instruction
10018              which specifies that bit 1 of the target address will come from bit
10019              1 of the base address.  */
10020           relocation = (relocation + 2) & ~ 3;
10021
10022         /* Put RELOCATION back into the insn.  Assumes two's complement.
10023            We use the Thumb-2 encoding, which is safe even if dealing with
10024            a Thumb-1 instruction by virtue of our overflow check above.  */
10025         reloc_sign = (signed_check < 0) ? 1 : 0;
10026         upper_insn = (upper_insn & ~(bfd_vma) 0x7ff)
10027                      | ((relocation >> 12) & 0x3ff)
10028                      | (reloc_sign << 10);
10029         lower_insn = (lower_insn & ~(bfd_vma) 0x2fff)
10030                      | (((!((relocation >> 23) & 1)) ^ reloc_sign) << 13)
10031                      | (((!((relocation >> 22) & 1)) ^ reloc_sign) << 11)
10032                      | ((relocation >> 1) & 0x7ff);
10033
10034         /* Put the relocated value back in the object file:  */
10035         bfd_put_16 (input_bfd, upper_insn, hit_data);
10036         bfd_put_16 (input_bfd, lower_insn, hit_data + 2);
10037
10038         return (overflow ? bfd_reloc_overflow : bfd_reloc_ok);
10039       }
10040       break;
10041
10042     case R_ARM_THM_JUMP19:
10043       /* Thumb32 conditional branch instruction.  */
10044       {
10045         bfd_vma relocation;
10046         bfd_boolean overflow = FALSE;
10047         bfd_vma upper_insn = bfd_get_16 (input_bfd, hit_data);
10048         bfd_vma lower_insn = bfd_get_16 (input_bfd, hit_data + 2);
10049         bfd_signed_vma reloc_signed_max = 0xffffe;
10050         bfd_signed_vma reloc_signed_min = -0x100000;
10051         bfd_signed_vma signed_check;
10052         enum elf32_arm_stub_type stub_type = arm_stub_none;
10053         struct elf32_arm_stub_hash_entry *stub_entry;
10054         struct elf32_arm_link_hash_entry *hash;
10055
10056         /* Need to refetch the addend, reconstruct the top three bits,
10057            and squish the two 11 bit pieces together.  */
10058         if (globals->use_rel)
10059           {
10060             bfd_vma S     = (upper_insn & 0x0400) >> 10;
10061             bfd_vma upper = (upper_insn & 0x003f);
10062             bfd_vma J1    = (lower_insn & 0x2000) >> 13;
10063             bfd_vma J2    = (lower_insn & 0x0800) >> 11;
10064             bfd_vma lower = (lower_insn & 0x07ff);
10065
10066             upper |= J1 << 6;
10067             upper |= J2 << 7;
10068             upper |= (!S) << 8;
10069             upper -= 0x0100; /* Sign extend.  */
10070
10071             addend = (upper << 12) | (lower << 1);
10072             signed_addend = addend;
10073           }
10074
10075         /* Handle calls via the PLT.  */
10076         if (plt_offset != (bfd_vma) -1)
10077           {
10078             value = (splt->output_section->vma
10079                      + splt->output_offset
10080                      + plt_offset);
10081             /* Target the Thumb stub before the ARM PLT entry.  */
10082             value -= PLT_THUMB_STUB_SIZE;
10083             *unresolved_reloc_p = FALSE;
10084           }
10085
10086         hash = (struct elf32_arm_link_hash_entry *)h;
10087
10088         stub_type = arm_type_of_stub (info, input_section, rel,
10089                                       st_type, &branch_type,
10090                                       hash, value, sym_sec,
10091                                       input_bfd, sym_name);
10092         if (stub_type != arm_stub_none)
10093           {
10094             stub_entry = elf32_arm_get_stub_entry (input_section,
10095                                                    sym_sec, h,
10096                                                    rel, globals,
10097                                                    stub_type);
10098             if (stub_entry != NULL)
10099               {
10100                 value = (stub_entry->stub_offset
10101                         + stub_entry->stub_sec->output_offset
10102                         + stub_entry->stub_sec->output_section->vma);
10103               }
10104           }
10105
10106         relocation = value + signed_addend;
10107         relocation -= (input_section->output_section->vma
10108                        + input_section->output_offset
10109                        + rel->r_offset);
10110         signed_check = (bfd_signed_vma) relocation;
10111
10112         if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
10113           overflow = TRUE;
10114
10115         /* Put RELOCATION back into the insn.  */
10116         {
10117           bfd_vma S  = (relocation & 0x00100000) >> 20;
10118           bfd_vma J2 = (relocation & 0x00080000) >> 19;
10119           bfd_vma J1 = (relocation & 0x00040000) >> 18;
10120           bfd_vma hi = (relocation & 0x0003f000) >> 12;
10121           bfd_vma lo = (relocation & 0x00000ffe) >>  1;
10122
10123           upper_insn = (upper_insn & 0xfbc0) | (S << 10) | hi;
10124           lower_insn = (lower_insn & 0xd000) | (J1 << 13) | (J2 << 11) | lo;
10125         }
10126
10127         /* Put the relocated value back in the object file:  */
10128         bfd_put_16 (input_bfd, upper_insn, hit_data);
10129         bfd_put_16 (input_bfd, lower_insn, hit_data + 2);
10130
10131         return (overflow ? bfd_reloc_overflow : bfd_reloc_ok);
10132       }
10133
10134     case R_ARM_THM_JUMP11:
10135     case R_ARM_THM_JUMP8:
10136     case R_ARM_THM_JUMP6:
10137       /* Thumb B (branch) instruction).  */
10138       {
10139         bfd_signed_vma relocation;
10140         bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
10141         bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
10142         bfd_signed_vma signed_check;
10143
10144         /* CZB cannot jump backward.  */
10145         if (r_type == R_ARM_THM_JUMP6)
10146           reloc_signed_min = 0;
10147
10148         if (globals->use_rel)
10149           {
10150             /* Need to refetch addend.  */
10151             addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
10152             if (addend & ((howto->src_mask + 1) >> 1))
10153               {
10154                 signed_addend = -1;
10155                 signed_addend &= ~ howto->src_mask;
10156                 signed_addend |= addend;
10157               }
10158             else
10159               signed_addend = addend;
10160             /* The value in the insn has been right shifted.  We need to
10161                undo this, so that we can perform the address calculation
10162                in terms of bytes.  */
10163             signed_addend <<= howto->rightshift;
10164           }
10165         relocation = value + signed_addend;
10166
10167         relocation -= (input_section->output_section->vma
10168                        + input_section->output_offset
10169                        + rel->r_offset);
10170
10171         relocation >>= howto->rightshift;
10172         signed_check = relocation;
10173
10174         if (r_type == R_ARM_THM_JUMP6)
10175           relocation = ((relocation & 0x0020) << 4) | ((relocation & 0x001f) << 3);
10176         else
10177           relocation &= howto->dst_mask;
10178         relocation |= (bfd_get_16 (input_bfd, hit_data) & (~ howto->dst_mask));
10179
10180         bfd_put_16 (input_bfd, relocation, hit_data);
10181
10182         /* Assumes two's complement.  */
10183         if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
10184           return bfd_reloc_overflow;
10185
10186         return bfd_reloc_ok;
10187       }
10188
10189     case R_ARM_ALU_PCREL7_0:
10190     case R_ARM_ALU_PCREL15_8:
10191     case R_ARM_ALU_PCREL23_15:
10192       {
10193         bfd_vma insn;
10194         bfd_vma relocation;
10195
10196         insn = bfd_get_32 (input_bfd, hit_data);
10197         if (globals->use_rel)
10198           {
10199             /* Extract the addend.  */
10200             addend = (insn & 0xff) << ((insn & 0xf00) >> 7);
10201             signed_addend = addend;
10202           }
10203         relocation = value + signed_addend;
10204
10205         relocation -= (input_section->output_section->vma
10206                        + input_section->output_offset
10207                        + rel->r_offset);
10208         insn = (insn & ~0xfff)
10209                | ((howto->bitpos << 7) & 0xf00)
10210                | ((relocation >> howto->bitpos) & 0xff);
10211         bfd_put_32 (input_bfd, value, hit_data);
10212       }
10213       return bfd_reloc_ok;
10214
10215     case R_ARM_GNU_VTINHERIT:
10216     case R_ARM_GNU_VTENTRY:
10217       return bfd_reloc_ok;
10218
10219     case R_ARM_GOTOFF32:
10220       /* Relocation is relative to the start of the
10221          global offset table.  */
10222
10223       BFD_ASSERT (sgot != NULL);
10224       if (sgot == NULL)
10225         return bfd_reloc_notsupported;
10226
10227       /* If we are addressing a Thumb function, we need to adjust the
10228          address by one, so that attempts to call the function pointer will
10229          correctly interpret it as Thumb code.  */
10230       if (branch_type == ST_BRANCH_TO_THUMB)
10231         value += 1;
10232
10233       /* Note that sgot->output_offset is not involved in this
10234          calculation.  We always want the start of .got.  If we
10235          define _GLOBAL_OFFSET_TABLE in a different way, as is
10236          permitted by the ABI, we might have to change this
10237          calculation.  */
10238       value -= sgot->output_section->vma;
10239       return _bfd_final_link_relocate (howto, input_bfd, input_section,
10240                                        contents, rel->r_offset, value,
10241                                        rel->r_addend);
10242
10243     case R_ARM_GOTPC:
10244       /* Use global offset table as symbol value.  */
10245       BFD_ASSERT (sgot != NULL);
10246
10247       if (sgot == NULL)
10248         return bfd_reloc_notsupported;
10249
10250       *unresolved_reloc_p = FALSE;
10251       value = sgot->output_section->vma;
10252       return _bfd_final_link_relocate (howto, input_bfd, input_section,
10253                                        contents, rel->r_offset, value,
10254                                        rel->r_addend);
10255
10256     case R_ARM_GOT32:
10257     case R_ARM_GOT_PREL:
10258       /* Relocation is to the entry for this symbol in the
10259          global offset table.  */
10260       if (sgot == NULL)
10261         return bfd_reloc_notsupported;
10262
10263       if (dynreloc_st_type == STT_GNU_IFUNC
10264           && plt_offset != (bfd_vma) -1
10265           && (h == NULL || SYMBOL_REFERENCES_LOCAL (info, h)))
10266         {
10267           /* We have a relocation against a locally-binding STT_GNU_IFUNC
10268              symbol, and the relocation resolves directly to the runtime
10269              target rather than to the .iplt entry.  This means that any
10270              .got entry would be the same value as the .igot.plt entry,
10271              so there's no point creating both.  */
10272           sgot = globals->root.igotplt;
10273           value = sgot->output_offset + gotplt_offset;
10274         }
10275       else if (h != NULL)
10276         {
10277           bfd_vma off;
10278
10279           off = h->got.offset;
10280           BFD_ASSERT (off != (bfd_vma) -1);
10281           if ((off & 1) != 0)
10282             {
10283               /* We have already processsed one GOT relocation against
10284                  this symbol.  */
10285               off &= ~1;
10286               if (globals->root.dynamic_sections_created
10287                   && !SYMBOL_REFERENCES_LOCAL (info, h))
10288                 *unresolved_reloc_p = FALSE;
10289             }
10290           else
10291             {
10292               Elf_Internal_Rela outrel;
10293
10294               if (h->dynindx != -1 && !SYMBOL_REFERENCES_LOCAL (info, h))
10295                 {
10296                   /* If the symbol doesn't resolve locally in a static
10297                      object, we have an undefined reference.  If the
10298                      symbol doesn't resolve locally in a dynamic object,
10299                      it should be resolved by the dynamic linker.  */
10300                   if (globals->root.dynamic_sections_created)
10301                     {
10302                       outrel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT);
10303                       *unresolved_reloc_p = FALSE;
10304                     }
10305                   else
10306                     outrel.r_info = 0;
10307                   outrel.r_addend = 0;
10308                 }
10309               else
10310                 {
10311                   if (dynreloc_st_type == STT_GNU_IFUNC)
10312                     outrel.r_info = ELF32_R_INFO (0, R_ARM_IRELATIVE);
10313                   else if (bfd_link_pic (info) &&
10314                            (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
10315                             || h->root.type != bfd_link_hash_undefweak))
10316                     outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
10317                   else
10318                     outrel.r_info = 0;
10319                   outrel.r_addend = dynreloc_value;
10320                 }
10321
10322               /* The GOT entry is initialized to zero by default.
10323                  See if we should install a different value.  */
10324               if (outrel.r_addend != 0
10325                   && (outrel.r_info == 0 || globals->use_rel))
10326                 {
10327                   bfd_put_32 (output_bfd, outrel.r_addend,
10328                               sgot->contents + off);
10329                   outrel.r_addend = 0;
10330                 }
10331
10332               if (outrel.r_info != 0)
10333                 {
10334                   outrel.r_offset = (sgot->output_section->vma
10335                                      + sgot->output_offset
10336                                      + off);
10337                   elf32_arm_add_dynreloc (output_bfd, info, srelgot, &outrel);
10338                 }
10339               h->got.offset |= 1;
10340             }
10341           value = sgot->output_offset + off;
10342         }
10343       else
10344         {
10345           bfd_vma off;
10346
10347           BFD_ASSERT (local_got_offsets != NULL &&
10348                       local_got_offsets[r_symndx] != (bfd_vma) -1);
10349
10350           off = local_got_offsets[r_symndx];
10351
10352           /* The offset must always be a multiple of 4.  We use the
10353              least significant bit to record whether we have already
10354              generated the necessary reloc.  */
10355           if ((off & 1) != 0)
10356             off &= ~1;
10357           else
10358             {
10359               if (globals->use_rel)
10360                 bfd_put_32 (output_bfd, dynreloc_value, sgot->contents + off);
10361
10362               if (bfd_link_pic (info) || dynreloc_st_type == STT_GNU_IFUNC)
10363                 {
10364                   Elf_Internal_Rela outrel;
10365
10366                   outrel.r_addend = addend + dynreloc_value;
10367                   outrel.r_offset = (sgot->output_section->vma
10368                                      + sgot->output_offset
10369                                      + off);
10370                   if (dynreloc_st_type == STT_GNU_IFUNC)
10371                     outrel.r_info = ELF32_R_INFO (0, R_ARM_IRELATIVE);
10372                   else
10373                     outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
10374                   elf32_arm_add_dynreloc (output_bfd, info, srelgot, &outrel);
10375                 }
10376
10377               local_got_offsets[r_symndx] |= 1;
10378             }
10379
10380           value = sgot->output_offset + off;
10381         }
10382       if (r_type != R_ARM_GOT32)
10383         value += sgot->output_section->vma;
10384
10385       return _bfd_final_link_relocate (howto, input_bfd, input_section,
10386                                        contents, rel->r_offset, value,
10387                                        rel->r_addend);
10388
10389     case R_ARM_TLS_LDO32:
10390       value = value - dtpoff_base (info);
10391
10392       return _bfd_final_link_relocate (howto, input_bfd, input_section,
10393                                        contents, rel->r_offset, value,
10394                                        rel->r_addend);
10395
10396     case R_ARM_TLS_LDM32:
10397       {
10398         bfd_vma off;
10399
10400         if (sgot == NULL)
10401           abort ();
10402
10403         off = globals->tls_ldm_got.offset;
10404
10405         if ((off & 1) != 0)
10406           off &= ~1;
10407         else
10408           {
10409             /* If we don't know the module number, create a relocation
10410                for it.  */
10411             if (bfd_link_pic (info))
10412               {
10413                 Elf_Internal_Rela outrel;
10414
10415                 if (srelgot == NULL)
10416                   abort ();
10417
10418                 outrel.r_addend = 0;
10419                 outrel.r_offset = (sgot->output_section->vma
10420                                    + sgot->output_offset + off);
10421                 outrel.r_info = ELF32_R_INFO (0, R_ARM_TLS_DTPMOD32);
10422
10423                 if (globals->use_rel)
10424                   bfd_put_32 (output_bfd, outrel.r_addend,
10425                               sgot->contents + off);
10426
10427                 elf32_arm_add_dynreloc (output_bfd, info, srelgot, &outrel);
10428               }
10429             else
10430               bfd_put_32 (output_bfd, 1, sgot->contents + off);
10431
10432             globals->tls_ldm_got.offset |= 1;
10433           }
10434
10435         value = sgot->output_section->vma + sgot->output_offset + off
10436           - (input_section->output_section->vma + input_section->output_offset + rel->r_offset);
10437
10438         return _bfd_final_link_relocate (howto, input_bfd, input_section,
10439                                          contents, rel->r_offset, value,
10440                                          rel->r_addend);
10441       }
10442
10443     case R_ARM_TLS_CALL:
10444     case R_ARM_THM_TLS_CALL:
10445     case R_ARM_TLS_GD32:
10446     case R_ARM_TLS_IE32:
10447     case R_ARM_TLS_GOTDESC:
10448     case R_ARM_TLS_DESCSEQ:
10449     case R_ARM_THM_TLS_DESCSEQ:
10450       {
10451         bfd_vma off, offplt;
10452         int indx = 0;
10453         char tls_type;
10454
10455         BFD_ASSERT (sgot != NULL);
10456
10457         if (h != NULL)
10458           {
10459             bfd_boolean dyn;
10460             dyn = globals->root.dynamic_sections_created;
10461             if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
10462                                                  bfd_link_pic (info),
10463                                                  h)
10464                 && (!bfd_link_pic (info)
10465                     || !SYMBOL_REFERENCES_LOCAL (info, h)))
10466               {
10467                 *unresolved_reloc_p = FALSE;
10468                 indx = h->dynindx;
10469               }
10470             off = h->got.offset;
10471             offplt = elf32_arm_hash_entry (h)->tlsdesc_got;
10472             tls_type = ((struct elf32_arm_link_hash_entry *) h)->tls_type;
10473           }
10474         else
10475           {
10476             BFD_ASSERT (local_got_offsets != NULL);
10477             off = local_got_offsets[r_symndx];
10478             offplt = local_tlsdesc_gotents[r_symndx];
10479             tls_type = elf32_arm_local_got_tls_type (input_bfd)[r_symndx];
10480           }
10481
10482         /* Linker relaxations happens from one of the
10483            R_ARM_{GOTDESC,CALL,DESCSEQ} relocations to IE or LE.  */
10484         if (ELF32_R_TYPE(rel->r_info) != r_type)
10485           tls_type = GOT_TLS_IE;
10486
10487         BFD_ASSERT (tls_type != GOT_UNKNOWN);
10488
10489         if ((off & 1) != 0)
10490           off &= ~1;
10491         else
10492           {
10493             bfd_boolean need_relocs = FALSE;
10494             Elf_Internal_Rela outrel;
10495             int cur_off = off;
10496
10497             /* The GOT entries have not been initialized yet.  Do it
10498                now, and emit any relocations.  If both an IE GOT and a
10499                GD GOT are necessary, we emit the GD first.  */
10500
10501             if ((bfd_link_pic (info) || indx != 0)
10502                 && (h == NULL
10503                     || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
10504                     || h->root.type != bfd_link_hash_undefweak))
10505               {
10506                 need_relocs = TRUE;
10507                 BFD_ASSERT (srelgot != NULL);
10508               }
10509
10510             if (tls_type & GOT_TLS_GDESC)
10511               {
10512                 bfd_byte *loc;
10513
10514                 /* We should have relaxed, unless this is an undefined
10515                    weak symbol.  */
10516                 BFD_ASSERT ((h && (h->root.type == bfd_link_hash_undefweak))
10517                             || bfd_link_pic (info));
10518                 BFD_ASSERT (globals->sgotplt_jump_table_size + offplt + 8
10519                             <= globals->root.sgotplt->size);
10520
10521                 outrel.r_addend = 0;
10522                 outrel.r_offset = (globals->root.sgotplt->output_section->vma
10523                                    + globals->root.sgotplt->output_offset
10524                                    + offplt
10525                                    + globals->sgotplt_jump_table_size);
10526
10527                 outrel.r_info = ELF32_R_INFO (indx, R_ARM_TLS_DESC);
10528                 sreloc = globals->root.srelplt;
10529                 loc = sreloc->contents;
10530                 loc += globals->next_tls_desc_index++ * RELOC_SIZE (globals);
10531                 BFD_ASSERT (loc + RELOC_SIZE (globals)
10532                            <= sreloc->contents + sreloc->size);
10533
10534                 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
10535
10536                 /* For globals, the first word in the relocation gets
10537                    the relocation index and the top bit set, or zero,
10538                    if we're binding now.  For locals, it gets the
10539                    symbol's offset in the tls section.  */
10540                 bfd_put_32 (output_bfd,
10541                             !h ? value - elf_hash_table (info)->tls_sec->vma
10542                             : info->flags & DF_BIND_NOW ? 0
10543                             : 0x80000000 | ELF32_R_SYM (outrel.r_info),
10544                             globals->root.sgotplt->contents + offplt
10545                             + globals->sgotplt_jump_table_size);
10546
10547                 /* Second word in the relocation is always zero.  */
10548                 bfd_put_32 (output_bfd, 0,
10549                             globals->root.sgotplt->contents + offplt
10550                             + globals->sgotplt_jump_table_size + 4);
10551               }
10552             if (tls_type & GOT_TLS_GD)
10553               {
10554                 if (need_relocs)
10555                   {
10556                     outrel.r_addend = 0;
10557                     outrel.r_offset = (sgot->output_section->vma
10558                                        + sgot->output_offset
10559                                        + cur_off);
10560                     outrel.r_info = ELF32_R_INFO (indx, R_ARM_TLS_DTPMOD32);
10561
10562                     if (globals->use_rel)
10563                       bfd_put_32 (output_bfd, outrel.r_addend,
10564                                   sgot->contents + cur_off);
10565
10566                     elf32_arm_add_dynreloc (output_bfd, info, srelgot, &outrel);
10567
10568                     if (indx == 0)
10569                       bfd_put_32 (output_bfd, value - dtpoff_base (info),
10570                                   sgot->contents + cur_off + 4);
10571                     else
10572                       {
10573                         outrel.r_addend = 0;
10574                         outrel.r_info = ELF32_R_INFO (indx,
10575                                                       R_ARM_TLS_DTPOFF32);
10576                         outrel.r_offset += 4;
10577
10578                         if (globals->use_rel)
10579                           bfd_put_32 (output_bfd, outrel.r_addend,
10580                                       sgot->contents + cur_off + 4);
10581
10582                         elf32_arm_add_dynreloc (output_bfd, info,
10583                                                 srelgot, &outrel);
10584                       }
10585                   }
10586                 else
10587                   {
10588                     /* If we are not emitting relocations for a
10589                        general dynamic reference, then we must be in a
10590                        static link or an executable link with the
10591                        symbol binding locally.  Mark it as belonging
10592                        to module 1, the executable.  */
10593                     bfd_put_32 (output_bfd, 1,
10594                                 sgot->contents + cur_off);
10595                     bfd_put_32 (output_bfd, value - dtpoff_base (info),
10596                                 sgot->contents + cur_off + 4);
10597                   }
10598
10599                 cur_off += 8;
10600               }
10601
10602             if (tls_type & GOT_TLS_IE)
10603               {
10604                 if (need_relocs)
10605                   {
10606                     if (indx == 0)
10607                       outrel.r_addend = value - dtpoff_base (info);
10608                     else
10609                       outrel.r_addend = 0;
10610                     outrel.r_offset = (sgot->output_section->vma
10611                                        + sgot->output_offset
10612                                        + cur_off);
10613                     outrel.r_info = ELF32_R_INFO (indx, R_ARM_TLS_TPOFF32);
10614
10615                     if (globals->use_rel)
10616                       bfd_put_32 (output_bfd, outrel.r_addend,
10617                                   sgot->contents + cur_off);
10618
10619                     elf32_arm_add_dynreloc (output_bfd, info, srelgot, &outrel);
10620                   }
10621                 else
10622                   bfd_put_32 (output_bfd, tpoff (info, value),
10623                               sgot->contents + cur_off);
10624                 cur_off += 4;
10625               }
10626
10627             if (h != NULL)
10628               h->got.offset |= 1;
10629             else
10630               local_got_offsets[r_symndx] |= 1;
10631           }
10632
10633         if ((tls_type & GOT_TLS_GD) && r_type != R_ARM_TLS_GD32)
10634           off += 8;
10635         else if (tls_type & GOT_TLS_GDESC)
10636           off = offplt;
10637
10638         if (ELF32_R_TYPE(rel->r_info) == R_ARM_TLS_CALL
10639             || ELF32_R_TYPE(rel->r_info) == R_ARM_THM_TLS_CALL)
10640           {
10641             bfd_signed_vma offset;
10642             /* TLS stubs are arm mode.  The original symbol is a
10643                data object, so branch_type is bogus.  */
10644             branch_type = ST_BRANCH_TO_ARM;
10645             enum elf32_arm_stub_type stub_type
10646               = arm_type_of_stub (info, input_section, rel,
10647                                   st_type, &branch_type,
10648                                   (struct elf32_arm_link_hash_entry *)h,
10649                                   globals->tls_trampoline, globals->root.splt,
10650                                   input_bfd, sym_name);
10651
10652             if (stub_type != arm_stub_none)
10653               {
10654                 struct elf32_arm_stub_hash_entry *stub_entry
10655                   = elf32_arm_get_stub_entry
10656                   (input_section, globals->root.splt, 0, rel,
10657                    globals, stub_type);
10658                 offset = (stub_entry->stub_offset
10659                           + stub_entry->stub_sec->output_offset
10660                           + stub_entry->stub_sec->output_section->vma);
10661               }
10662             else
10663               offset = (globals->root.splt->output_section->vma
10664                         + globals->root.splt->output_offset
10665                         + globals->tls_trampoline);
10666
10667             if (ELF32_R_TYPE(rel->r_info) == R_ARM_TLS_CALL)
10668               {
10669                 unsigned long inst;
10670
10671                 offset -= (input_section->output_section->vma
10672                            + input_section->output_offset
10673                            + rel->r_offset + 8);
10674
10675                 inst = offset >> 2;
10676                 inst &= 0x00ffffff;
10677                 value = inst | (globals->use_blx ? 0xfa000000 : 0xeb000000);
10678               }
10679             else
10680               {
10681                 /* Thumb blx encodes the offset in a complicated
10682                    fashion.  */
10683                 unsigned upper_insn, lower_insn;
10684                 unsigned neg;
10685
10686                 offset -= (input_section->output_section->vma
10687                            + input_section->output_offset
10688                            + rel->r_offset + 4);
10689
10690                 if (stub_type != arm_stub_none
10691                     && arm_stub_is_thumb (stub_type))
10692                   {
10693                     lower_insn = 0xd000;
10694                   }
10695                 else
10696                   {
10697                     lower_insn = 0xc000;
10698                     /* Round up the offset to a word boundary.  */
10699                     offset = (offset + 2) & ~2;
10700                   }
10701
10702                 neg = offset < 0;
10703                 upper_insn = (0xf000
10704                               | ((offset >> 12) & 0x3ff)
10705                               | (neg << 10));
10706                 lower_insn |= (((!((offset >> 23) & 1)) ^ neg) << 13)
10707                               | (((!((offset >> 22) & 1)) ^ neg) << 11)
10708                               | ((offset >> 1) & 0x7ff);
10709                 bfd_put_16 (input_bfd, upper_insn, hit_data);
10710                 bfd_put_16 (input_bfd, lower_insn, hit_data + 2);
10711                 return bfd_reloc_ok;
10712               }
10713           }
10714         /* These relocations needs special care, as besides the fact
10715            they point somewhere in .gotplt, the addend must be
10716            adjusted accordingly depending on the type of instruction
10717            we refer to.  */
10718         else if ((r_type == R_ARM_TLS_GOTDESC) && (tls_type & GOT_TLS_GDESC))
10719           {
10720             unsigned long data, insn;
10721             unsigned thumb;
10722
10723             data = bfd_get_32 (input_bfd, hit_data);
10724             thumb = data & 1;
10725             data &= ~1u;
10726
10727             if (thumb)
10728               {
10729                 insn = bfd_get_16 (input_bfd, contents + rel->r_offset - data);
10730                 if ((insn & 0xf000) == 0xf000 || (insn & 0xf800) == 0xe800)
10731                   insn = (insn << 16)
10732                     | bfd_get_16 (input_bfd,
10733                                   contents + rel->r_offset - data + 2);
10734                 if ((insn & 0xf800c000) == 0xf000c000)
10735                   /* bl/blx */
10736                   value = -6;
10737                 else if ((insn & 0xffffff00) == 0x4400)
10738                   /* add */
10739                   value = -5;
10740                 else
10741                   {
10742                     (*_bfd_error_handler)
10743                       (_("%B(%A+0x%lx):unexpected Thumb instruction '0x%x' referenced by TLS_GOTDESC"),
10744                        input_bfd, input_section,
10745                        (unsigned long)rel->r_offset, insn);
10746                     return bfd_reloc_notsupported;
10747                   }
10748               }
10749             else
10750               {
10751                 insn = bfd_get_32 (input_bfd, contents + rel->r_offset - data);
10752
10753                 switch (insn >> 24)
10754                   {
10755                   case 0xeb:  /* bl */
10756                   case 0xfa:  /* blx */
10757                     value = -4;
10758                     break;
10759
10760                   case 0xe0:    /* add */
10761                     value = -8;
10762                     break;
10763
10764                   default:
10765                     (*_bfd_error_handler)
10766                       (_("%B(%A+0x%lx):unexpected ARM instruction '0x%x' referenced by TLS_GOTDESC"),
10767                        input_bfd, input_section,
10768                        (unsigned long)rel->r_offset, insn);
10769                     return bfd_reloc_notsupported;
10770                   }
10771               }
10772
10773             value += ((globals->root.sgotplt->output_section->vma
10774                        + globals->root.sgotplt->output_offset + off)
10775                       - (input_section->output_section->vma
10776                          + input_section->output_offset
10777                          + rel->r_offset)
10778                       + globals->sgotplt_jump_table_size);
10779           }
10780         else
10781           value = ((globals->root.sgot->output_section->vma
10782                     + globals->root.sgot->output_offset + off)
10783                    - (input_section->output_section->vma
10784                       + input_section->output_offset + rel->r_offset));
10785
10786         return _bfd_final_link_relocate (howto, input_bfd, input_section,
10787                                          contents, rel->r_offset, value,
10788                                          rel->r_addend);
10789       }
10790
10791     case R_ARM_TLS_LE32:
10792       if (bfd_link_dll (info))
10793         {
10794           (*_bfd_error_handler)
10795             (_("%B(%A+0x%lx): R_ARM_TLS_LE32 relocation not permitted in shared object"),
10796              input_bfd, input_section,
10797              (long) rel->r_offset, howto->name);
10798           return bfd_reloc_notsupported;
10799         }
10800       else
10801         value = tpoff (info, value);
10802
10803       return _bfd_final_link_relocate (howto, input_bfd, input_section,
10804                                        contents, rel->r_offset, value,
10805                                        rel->r_addend);
10806
10807     case R_ARM_V4BX:
10808       if (globals->fix_v4bx)
10809         {
10810           bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
10811
10812           /* Ensure that we have a BX instruction.  */
10813           BFD_ASSERT ((insn & 0x0ffffff0) == 0x012fff10);
10814
10815           if (globals->fix_v4bx == 2 && (insn & 0xf) != 0xf)
10816             {
10817               /* Branch to veneer.  */
10818               bfd_vma glue_addr;
10819               glue_addr = elf32_arm_bx_glue (info, insn & 0xf);
10820               glue_addr -= input_section->output_section->vma
10821                            + input_section->output_offset
10822                            + rel->r_offset + 8;
10823               insn = (insn & 0xf0000000) | 0x0a000000
10824                      | ((glue_addr >> 2) & 0x00ffffff);
10825             }
10826           else
10827             {
10828               /* Preserve Rm (lowest four bits) and the condition code
10829                  (highest four bits). Other bits encode MOV PC,Rm.  */
10830               insn = (insn & 0xf000000f) | 0x01a0f000;
10831             }
10832
10833           bfd_put_32 (input_bfd, insn, hit_data);
10834         }
10835       return bfd_reloc_ok;
10836
10837     case R_ARM_MOVW_ABS_NC:
10838     case R_ARM_MOVT_ABS:
10839     case R_ARM_MOVW_PREL_NC:
10840     case R_ARM_MOVT_PREL:
10841     /* Until we properly support segment-base-relative addressing then
10842        we assume the segment base to be zero, as for the group relocations.
10843        Thus R_ARM_MOVW_BREL_NC has the same semantics as R_ARM_MOVW_ABS_NC
10844        and R_ARM_MOVT_BREL has the same semantics as R_ARM_MOVT_ABS.  */
10845     case R_ARM_MOVW_BREL_NC:
10846     case R_ARM_MOVW_BREL:
10847     case R_ARM_MOVT_BREL:
10848       {
10849         bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
10850
10851         if (globals->use_rel)
10852           {
10853             addend = ((insn >> 4) & 0xf000) | (insn & 0xfff);
10854             signed_addend = (addend ^ 0x8000) - 0x8000;
10855           }
10856
10857         value += signed_addend;
10858
10859         if (r_type == R_ARM_MOVW_PREL_NC || r_type == R_ARM_MOVT_PREL)
10860           value -= (input_section->output_section->vma
10861                     + input_section->output_offset + rel->r_offset);
10862
10863         if (r_type == R_ARM_MOVW_BREL && value >= 0x10000)
10864           return bfd_reloc_overflow;
10865
10866         if (branch_type == ST_BRANCH_TO_THUMB)
10867           value |= 1;
10868
10869         if (r_type == R_ARM_MOVT_ABS || r_type == R_ARM_MOVT_PREL
10870             || r_type == R_ARM_MOVT_BREL)
10871           value >>= 16;
10872
10873         insn &= 0xfff0f000;
10874         insn |= value & 0xfff;
10875         insn |= (value & 0xf000) << 4;
10876         bfd_put_32 (input_bfd, insn, hit_data);
10877       }
10878       return bfd_reloc_ok;
10879
10880     case R_ARM_THM_MOVW_ABS_NC:
10881     case R_ARM_THM_MOVT_ABS:
10882     case R_ARM_THM_MOVW_PREL_NC:
10883     case R_ARM_THM_MOVT_PREL:
10884     /* Until we properly support segment-base-relative addressing then
10885        we assume the segment base to be zero, as for the above relocations.
10886        Thus R_ARM_THM_MOVW_BREL_NC has the same semantics as
10887        R_ARM_THM_MOVW_ABS_NC and R_ARM_THM_MOVT_BREL has the same semantics
10888        as R_ARM_THM_MOVT_ABS.  */
10889     case R_ARM_THM_MOVW_BREL_NC:
10890     case R_ARM_THM_MOVW_BREL:
10891     case R_ARM_THM_MOVT_BREL:
10892       {
10893         bfd_vma insn;
10894
10895         insn = bfd_get_16 (input_bfd, hit_data) << 16;
10896         insn |= bfd_get_16 (input_bfd, hit_data + 2);
10897
10898         if (globals->use_rel)
10899           {
10900             addend = ((insn >> 4)  & 0xf000)
10901                    | ((insn >> 15) & 0x0800)
10902                    | ((insn >> 4)  & 0x0700)
10903                    | (insn         & 0x00ff);
10904             signed_addend = (addend ^ 0x8000) - 0x8000;
10905           }
10906
10907         value += signed_addend;
10908
10909         if (r_type == R_ARM_THM_MOVW_PREL_NC || r_type == R_ARM_THM_MOVT_PREL)
10910           value -= (input_section->output_section->vma
10911                     + input_section->output_offset + rel->r_offset);
10912
10913         if (r_type == R_ARM_THM_MOVW_BREL && value >= 0x10000)
10914           return bfd_reloc_overflow;
10915
10916         if (branch_type == ST_BRANCH_TO_THUMB)
10917           value |= 1;
10918
10919         if (r_type == R_ARM_THM_MOVT_ABS || r_type == R_ARM_THM_MOVT_PREL
10920             || r_type == R_ARM_THM_MOVT_BREL)
10921           value >>= 16;
10922
10923         insn &= 0xfbf08f00;
10924         insn |= (value & 0xf000) << 4;
10925         insn |= (value & 0x0800) << 15;
10926         insn |= (value & 0x0700) << 4;
10927         insn |= (value & 0x00ff);
10928
10929         bfd_put_16 (input_bfd, insn >> 16, hit_data);
10930         bfd_put_16 (input_bfd, insn & 0xffff, hit_data + 2);
10931       }
10932       return bfd_reloc_ok;
10933
10934     case R_ARM_ALU_PC_G0_NC:
10935     case R_ARM_ALU_PC_G1_NC:
10936     case R_ARM_ALU_PC_G0:
10937     case R_ARM_ALU_PC_G1:
10938     case R_ARM_ALU_PC_G2:
10939     case R_ARM_ALU_SB_G0_NC:
10940     case R_ARM_ALU_SB_G1_NC:
10941     case R_ARM_ALU_SB_G0:
10942     case R_ARM_ALU_SB_G1:
10943     case R_ARM_ALU_SB_G2:
10944       {
10945         bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
10946         bfd_vma pc = input_section->output_section->vma
10947                      + input_section->output_offset + rel->r_offset;
10948         /* sb is the origin of the *segment* containing the symbol.  */
10949         bfd_vma sb = sym_sec ? sym_sec->output_section->vma : 0;
10950         bfd_vma residual;
10951         bfd_vma g_n;
10952         bfd_signed_vma signed_value;
10953         int group = 0;
10954
10955         /* Determine which group of bits to select.  */
10956         switch (r_type)
10957           {
10958           case R_ARM_ALU_PC_G0_NC:
10959           case R_ARM_ALU_PC_G0:
10960           case R_ARM_ALU_SB_G0_NC:
10961           case R_ARM_ALU_SB_G0:
10962             group = 0;
10963             break;
10964
10965           case R_ARM_ALU_PC_G1_NC:
10966           case R_ARM_ALU_PC_G1:
10967           case R_ARM_ALU_SB_G1_NC:
10968           case R_ARM_ALU_SB_G1:
10969             group = 1;
10970             break;
10971
10972           case R_ARM_ALU_PC_G2:
10973           case R_ARM_ALU_SB_G2:
10974             group = 2;
10975             break;
10976
10977           default:
10978             abort ();
10979           }
10980
10981         /* If REL, extract the addend from the insn.  If RELA, it will
10982            have already been fetched for us.  */
10983         if (globals->use_rel)
10984           {
10985             int negative;
10986             bfd_vma constant = insn & 0xff;
10987             bfd_vma rotation = (insn & 0xf00) >> 8;
10988
10989             if (rotation == 0)
10990               signed_addend = constant;
10991             else
10992               {
10993                 /* Compensate for the fact that in the instruction, the
10994                    rotation is stored in multiples of 2 bits.  */
10995                 rotation *= 2;
10996
10997                 /* Rotate "constant" right by "rotation" bits.  */
10998                 signed_addend = (constant >> rotation) |
10999                                 (constant << (8 * sizeof (bfd_vma) - rotation));
11000               }
11001
11002             /* Determine if the instruction is an ADD or a SUB.
11003                (For REL, this determines the sign of the addend.)  */
11004             negative = identify_add_or_sub (insn);
11005             if (negative == 0)
11006               {
11007                 (*_bfd_error_handler)
11008                   (_("%B(%A+0x%lx): Only ADD or SUB instructions are allowed for ALU group relocations"),
11009                   input_bfd, input_section,
11010                   (long) rel->r_offset, howto->name);
11011                 return bfd_reloc_overflow;
11012               }
11013
11014             signed_addend *= negative;
11015           }
11016
11017         /* Compute the value (X) to go in the place.  */
11018         if (r_type == R_ARM_ALU_PC_G0_NC
11019             || r_type == R_ARM_ALU_PC_G1_NC
11020             || r_type == R_ARM_ALU_PC_G0
11021             || r_type == R_ARM_ALU_PC_G1
11022             || r_type == R_ARM_ALU_PC_G2)
11023           /* PC relative.  */
11024           signed_value = value - pc + signed_addend;
11025         else
11026           /* Section base relative.  */
11027           signed_value = value - sb + signed_addend;
11028
11029         /* If the target symbol is a Thumb function, then set the
11030            Thumb bit in the address.  */
11031         if (branch_type == ST_BRANCH_TO_THUMB)
11032           signed_value |= 1;
11033
11034         /* Calculate the value of the relevant G_n, in encoded
11035            constant-with-rotation format.  */
11036         g_n = calculate_group_reloc_mask (signed_value < 0 ? - signed_value : signed_value,
11037                                           group, &residual);
11038
11039         /* Check for overflow if required.  */
11040         if ((r_type == R_ARM_ALU_PC_G0
11041              || r_type == R_ARM_ALU_PC_G1
11042              || r_type == R_ARM_ALU_PC_G2
11043              || r_type == R_ARM_ALU_SB_G0
11044              || r_type == R_ARM_ALU_SB_G1
11045              || r_type == R_ARM_ALU_SB_G2) && residual != 0)
11046           {
11047             (*_bfd_error_handler)
11048               (_("%B(%A+0x%lx): Overflow whilst splitting 0x%lx for group relocation %s"),
11049               input_bfd, input_section,
11050                (long) rel->r_offset, signed_value < 0 ? - signed_value : signed_value,
11051                howto->name);
11052             return bfd_reloc_overflow;
11053           }
11054
11055         /* Mask out the value and the ADD/SUB part of the opcode; take care
11056            not to destroy the S bit.  */
11057         insn &= 0xff1ff000;
11058
11059         /* Set the opcode according to whether the value to go in the
11060            place is negative.  */
11061         if (signed_value < 0)
11062           insn |= 1 << 22;
11063         else
11064           insn |= 1 << 23;
11065
11066         /* Encode the offset.  */
11067         insn |= g_n;
11068
11069         bfd_put_32 (input_bfd, insn, hit_data);
11070       }
11071       return bfd_reloc_ok;
11072
11073     case R_ARM_LDR_PC_G0:
11074     case R_ARM_LDR_PC_G1:
11075     case R_ARM_LDR_PC_G2:
11076     case R_ARM_LDR_SB_G0:
11077     case R_ARM_LDR_SB_G1:
11078     case R_ARM_LDR_SB_G2:
11079       {
11080         bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
11081         bfd_vma pc = input_section->output_section->vma
11082                      + input_section->output_offset + rel->r_offset;
11083         /* sb is the origin of the *segment* containing the symbol.  */
11084         bfd_vma sb = sym_sec ? sym_sec->output_section->vma : 0;
11085         bfd_vma residual;
11086         bfd_signed_vma signed_value;
11087         int group = 0;
11088
11089         /* Determine which groups of bits to calculate.  */
11090         switch (r_type)
11091           {
11092           case R_ARM_LDR_PC_G0:
11093           case R_ARM_LDR_SB_G0:
11094             group = 0;
11095             break;
11096
11097           case R_ARM_LDR_PC_G1:
11098           case R_ARM_LDR_SB_G1:
11099             group = 1;
11100             break;
11101
11102           case R_ARM_LDR_PC_G2:
11103           case R_ARM_LDR_SB_G2:
11104             group = 2;
11105             break;
11106
11107           default:
11108             abort ();
11109           }
11110
11111         /* If REL, extract the addend from the insn.  If RELA, it will
11112            have already been fetched for us.  */
11113         if (globals->use_rel)
11114           {
11115             int negative = (insn & (1 << 23)) ? 1 : -1;
11116             signed_addend = negative * (insn & 0xfff);
11117           }
11118
11119         /* Compute the value (X) to go in the place.  */
11120         if (r_type == R_ARM_LDR_PC_G0
11121             || r_type == R_ARM_LDR_PC_G1
11122             || r_type == R_ARM_LDR_PC_G2)
11123           /* PC relative.  */
11124           signed_value = value - pc + signed_addend;
11125         else
11126           /* Section base relative.  */
11127           signed_value = value - sb + signed_addend;
11128
11129         /* Calculate the value of the relevant G_{n-1} to obtain
11130            the residual at that stage.  */
11131         calculate_group_reloc_mask (signed_value < 0 ? - signed_value : signed_value,
11132                                     group - 1, &residual);
11133
11134         /* Check for overflow.  */
11135         if (residual >= 0x1000)
11136           {
11137             (*_bfd_error_handler)
11138               (_("%B(%A+0x%lx): Overflow whilst splitting 0x%lx for group relocation %s"),
11139                input_bfd, input_section,
11140                (long) rel->r_offset, labs (signed_value), howto->name);
11141             return bfd_reloc_overflow;
11142           }
11143
11144         /* Mask out the value and U bit.  */
11145         insn &= 0xff7ff000;
11146
11147         /* Set the U bit if the value to go in the place is non-negative.  */
11148         if (signed_value >= 0)
11149           insn |= 1 << 23;
11150
11151         /* Encode the offset.  */
11152         insn |= residual;
11153
11154         bfd_put_32 (input_bfd, insn, hit_data);
11155       }
11156       return bfd_reloc_ok;
11157
11158     case R_ARM_LDRS_PC_G0:
11159     case R_ARM_LDRS_PC_G1:
11160     case R_ARM_LDRS_PC_G2:
11161     case R_ARM_LDRS_SB_G0:
11162     case R_ARM_LDRS_SB_G1:
11163     case R_ARM_LDRS_SB_G2:
11164       {
11165         bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
11166         bfd_vma pc = input_section->output_section->vma
11167                      + input_section->output_offset + rel->r_offset;
11168         /* sb is the origin of the *segment* containing the symbol.  */
11169         bfd_vma sb = sym_sec ? sym_sec->output_section->vma : 0;
11170         bfd_vma residual;
11171         bfd_signed_vma signed_value;
11172         int group = 0;
11173
11174         /* Determine which groups of bits to calculate.  */
11175         switch (r_type)
11176           {
11177           case R_ARM_LDRS_PC_G0:
11178           case R_ARM_LDRS_SB_G0:
11179             group = 0;
11180             break;
11181
11182           case R_ARM_LDRS_PC_G1:
11183           case R_ARM_LDRS_SB_G1:
11184             group = 1;
11185             break;
11186
11187           case R_ARM_LDRS_PC_G2:
11188           case R_ARM_LDRS_SB_G2:
11189             group = 2;
11190             break;
11191
11192           default:
11193             abort ();
11194           }
11195
11196         /* If REL, extract the addend from the insn.  If RELA, it will
11197            have already been fetched for us.  */
11198         if (globals->use_rel)
11199           {
11200             int negative = (insn & (1 << 23)) ? 1 : -1;
11201             signed_addend = negative * (((insn & 0xf00) >> 4) + (insn & 0xf));
11202           }
11203
11204         /* Compute the value (X) to go in the place.  */
11205         if (r_type == R_ARM_LDRS_PC_G0
11206             || r_type == R_ARM_LDRS_PC_G1
11207             || r_type == R_ARM_LDRS_PC_G2)
11208           /* PC relative.  */
11209           signed_value = value - pc + signed_addend;
11210         else
11211           /* Section base relative.  */
11212           signed_value = value - sb + signed_addend;
11213
11214         /* Calculate the value of the relevant G_{n-1} to obtain
11215            the residual at that stage.  */
11216         calculate_group_reloc_mask (signed_value < 0 ? - signed_value : signed_value,
11217                                     group - 1, &residual);
11218
11219         /* Check for overflow.  */
11220         if (residual >= 0x100)
11221           {
11222             (*_bfd_error_handler)
11223               (_("%B(%A+0x%lx): Overflow whilst splitting 0x%lx for group relocation %s"),
11224                input_bfd, input_section,
11225                (long) rel->r_offset, labs (signed_value), howto->name);
11226             return bfd_reloc_overflow;
11227           }
11228
11229         /* Mask out the value and U bit.  */
11230         insn &= 0xff7ff0f0;
11231
11232         /* Set the U bit if the value to go in the place is non-negative.  */
11233         if (signed_value >= 0)
11234           insn |= 1 << 23;
11235
11236         /* Encode the offset.  */
11237         insn |= ((residual & 0xf0) << 4) | (residual & 0xf);
11238
11239         bfd_put_32 (input_bfd, insn, hit_data);
11240       }
11241       return bfd_reloc_ok;
11242
11243     case R_ARM_LDC_PC_G0:
11244     case R_ARM_LDC_PC_G1:
11245     case R_ARM_LDC_PC_G2:
11246     case R_ARM_LDC_SB_G0:
11247     case R_ARM_LDC_SB_G1:
11248     case R_ARM_LDC_SB_G2:
11249       {
11250         bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
11251         bfd_vma pc = input_section->output_section->vma
11252                      + input_section->output_offset + rel->r_offset;
11253         /* sb is the origin of the *segment* containing the symbol.  */
11254         bfd_vma sb = sym_sec ? sym_sec->output_section->vma : 0;
11255         bfd_vma residual;
11256         bfd_signed_vma signed_value;
11257         int group = 0;
11258
11259         /* Determine which groups of bits to calculate.  */
11260         switch (r_type)
11261           {
11262           case R_ARM_LDC_PC_G0:
11263           case R_ARM_LDC_SB_G0:
11264             group = 0;
11265             break;
11266
11267           case R_ARM_LDC_PC_G1:
11268           case R_ARM_LDC_SB_G1:
11269             group = 1;
11270             break;
11271
11272           case R_ARM_LDC_PC_G2:
11273           case R_ARM_LDC_SB_G2:
11274             group = 2;
11275             break;
11276
11277           default:
11278             abort ();
11279           }
11280
11281         /* If REL, extract the addend from the insn.  If RELA, it will
11282            have already been fetched for us.  */
11283         if (globals->use_rel)
11284           {
11285             int negative = (insn & (1 << 23)) ? 1 : -1;
11286             signed_addend = negative * ((insn & 0xff) << 2);
11287           }
11288
11289         /* Compute the value (X) to go in the place.  */
11290         if (r_type == R_ARM_LDC_PC_G0
11291             || r_type == R_ARM_LDC_PC_G1
11292             || r_type == R_ARM_LDC_PC_G2)
11293           /* PC relative.  */
11294           signed_value = value - pc + signed_addend;
11295         else
11296           /* Section base relative.  */
11297           signed_value = value - sb + signed_addend;
11298
11299         /* Calculate the value of the relevant G_{n-1} to obtain
11300            the residual at that stage.  */
11301         calculate_group_reloc_mask (signed_value < 0 ? - signed_value : signed_value,
11302                                     group - 1, &residual);
11303
11304         /* Check for overflow.  (The absolute value to go in the place must be
11305            divisible by four and, after having been divided by four, must
11306            fit in eight bits.)  */
11307         if ((residual & 0x3) != 0 || residual >= 0x400)
11308           {
11309             (*_bfd_error_handler)
11310               (_("%B(%A+0x%lx): Overflow whilst splitting 0x%lx for group relocation %s"),
11311               input_bfd, input_section,
11312               (long) rel->r_offset, labs (signed_value), howto->name);
11313             return bfd_reloc_overflow;
11314           }
11315
11316         /* Mask out the value and U bit.  */
11317         insn &= 0xff7fff00;
11318
11319         /* Set the U bit if the value to go in the place is non-negative.  */
11320         if (signed_value >= 0)
11321           insn |= 1 << 23;
11322
11323         /* Encode the offset.  */
11324         insn |= residual >> 2;
11325
11326         bfd_put_32 (input_bfd, insn, hit_data);
11327       }
11328       return bfd_reloc_ok;
11329
11330     case R_ARM_THM_ALU_ABS_G0_NC:
11331     case R_ARM_THM_ALU_ABS_G1_NC:
11332     case R_ARM_THM_ALU_ABS_G2_NC:
11333     case R_ARM_THM_ALU_ABS_G3_NC:
11334         {
11335             const int shift_array[4] = {0, 8, 16, 24};
11336             bfd_vma insn = bfd_get_16 (input_bfd, hit_data);
11337             bfd_vma addr = value;
11338             int shift = shift_array[r_type - R_ARM_THM_ALU_ABS_G0_NC];
11339
11340             /* Compute address.  */
11341             if (globals->use_rel)
11342                 signed_addend = insn & 0xff;
11343             addr += signed_addend;
11344             if (branch_type == ST_BRANCH_TO_THUMB)
11345                 addr |= 1;
11346             /* Clean imm8 insn.  */
11347             insn &= 0xff00;
11348             /* And update with correct part of address.  */
11349             insn |= (addr >> shift) & 0xff;
11350             /* Update insn.  */
11351             bfd_put_16 (input_bfd, insn, hit_data);
11352         }
11353
11354         *unresolved_reloc_p = FALSE;
11355         return bfd_reloc_ok;
11356
11357     default:
11358       return bfd_reloc_notsupported;
11359     }
11360 }
11361
11362 /* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS.  */
11363 static void
11364 arm_add_to_rel (bfd *              abfd,
11365                 bfd_byte *         address,
11366                 reloc_howto_type * howto,
11367                 bfd_signed_vma     increment)
11368 {
11369   bfd_signed_vma addend;
11370
11371   if (howto->type == R_ARM_THM_CALL
11372       || howto->type == R_ARM_THM_JUMP24)
11373     {
11374       int upper_insn, lower_insn;
11375       int upper, lower;
11376
11377       upper_insn = bfd_get_16 (abfd, address);
11378       lower_insn = bfd_get_16 (abfd, address + 2);
11379       upper = upper_insn & 0x7ff;
11380       lower = lower_insn & 0x7ff;
11381
11382       addend = (upper << 12) | (lower << 1);
11383       addend += increment;
11384       addend >>= 1;
11385
11386       upper_insn = (upper_insn & 0xf800) | ((addend >> 11) & 0x7ff);
11387       lower_insn = (lower_insn & 0xf800) | (addend & 0x7ff);
11388
11389       bfd_put_16 (abfd, (bfd_vma) upper_insn, address);
11390       bfd_put_16 (abfd, (bfd_vma) lower_insn, address + 2);
11391     }
11392   else
11393     {
11394       bfd_vma        contents;
11395
11396       contents = bfd_get_32 (abfd, address);
11397
11398       /* Get the (signed) value from the instruction.  */
11399       addend = contents & howto->src_mask;
11400       if (addend & ((howto->src_mask + 1) >> 1))
11401         {
11402           bfd_signed_vma mask;
11403
11404           mask = -1;
11405           mask &= ~ howto->src_mask;
11406           addend |= mask;
11407         }
11408
11409       /* Add in the increment, (which is a byte value).  */
11410       switch (howto->type)
11411         {
11412         default:
11413           addend += increment;
11414           break;
11415
11416         case R_ARM_PC24:
11417         case R_ARM_PLT32:
11418         case R_ARM_CALL:
11419         case R_ARM_JUMP24:
11420           addend <<= howto->size;
11421           addend += increment;
11422
11423           /* Should we check for overflow here ?  */
11424
11425           /* Drop any undesired bits.  */
11426           addend >>= howto->rightshift;
11427           break;
11428         }
11429
11430       contents = (contents & ~ howto->dst_mask) | (addend & howto->dst_mask);
11431
11432       bfd_put_32 (abfd, contents, address);
11433     }
11434 }
11435
11436 #define IS_ARM_TLS_RELOC(R_TYPE)        \
11437   ((R_TYPE) == R_ARM_TLS_GD32           \
11438    || (R_TYPE) == R_ARM_TLS_LDO32       \
11439    || (R_TYPE) == R_ARM_TLS_LDM32       \
11440    || (R_TYPE) == R_ARM_TLS_DTPOFF32    \
11441    || (R_TYPE) == R_ARM_TLS_DTPMOD32    \
11442    || (R_TYPE) == R_ARM_TLS_TPOFF32     \
11443    || (R_TYPE) == R_ARM_TLS_LE32        \
11444    || (R_TYPE) == R_ARM_TLS_IE32        \
11445    || IS_ARM_TLS_GNU_RELOC (R_TYPE))
11446
11447 /* Specific set of relocations for the gnu tls dialect.  */
11448 #define IS_ARM_TLS_GNU_RELOC(R_TYPE)    \
11449   ((R_TYPE) == R_ARM_TLS_GOTDESC        \
11450    || (R_TYPE) == R_ARM_TLS_CALL        \
11451    || (R_TYPE) == R_ARM_THM_TLS_CALL    \
11452    || (R_TYPE) == R_ARM_TLS_DESCSEQ     \
11453    || (R_TYPE) == R_ARM_THM_TLS_DESCSEQ)
11454
11455 /* Relocate an ARM ELF section.  */
11456
11457 static bfd_boolean
11458 elf32_arm_relocate_section (bfd *                  output_bfd,
11459                             struct bfd_link_info * info,
11460                             bfd *                  input_bfd,
11461                             asection *             input_section,
11462                             bfd_byte *             contents,
11463                             Elf_Internal_Rela *    relocs,
11464                             Elf_Internal_Sym *     local_syms,
11465                             asection **            local_sections)
11466 {
11467   Elf_Internal_Shdr *symtab_hdr;
11468   struct elf_link_hash_entry **sym_hashes;
11469   Elf_Internal_Rela *rel;
11470   Elf_Internal_Rela *relend;
11471   const char *name;
11472   struct elf32_arm_link_hash_table * globals;
11473
11474   globals = elf32_arm_hash_table (info);
11475   if (globals == NULL)
11476     return FALSE;
11477
11478   symtab_hdr = & elf_symtab_hdr (input_bfd);
11479   sym_hashes = elf_sym_hashes (input_bfd);
11480
11481   rel = relocs;
11482   relend = relocs + input_section->reloc_count;
11483   for (; rel < relend; rel++)
11484     {
11485       int                          r_type;
11486       reloc_howto_type *           howto;
11487       unsigned long                r_symndx;
11488       Elf_Internal_Sym *           sym;
11489       asection *                   sec;
11490       struct elf_link_hash_entry * h;
11491       bfd_vma                      relocation;
11492       bfd_reloc_status_type        r;
11493       arelent                      bfd_reloc;
11494       char                         sym_type;
11495       bfd_boolean                  unresolved_reloc = FALSE;
11496       char *error_message = NULL;
11497
11498       r_symndx = ELF32_R_SYM (rel->r_info);
11499       r_type   = ELF32_R_TYPE (rel->r_info);
11500       r_type   = arm_real_reloc_type (globals, r_type);
11501
11502       if (   r_type == R_ARM_GNU_VTENTRY
11503           || r_type == R_ARM_GNU_VTINHERIT)
11504         continue;
11505
11506       bfd_reloc.howto = elf32_arm_howto_from_type (r_type);
11507       howto = bfd_reloc.howto;
11508
11509       h = NULL;
11510       sym = NULL;
11511       sec = NULL;
11512
11513       if (r_symndx < symtab_hdr->sh_info)
11514         {
11515           sym = local_syms + r_symndx;
11516           sym_type = ELF32_ST_TYPE (sym->st_info);
11517           sec = local_sections[r_symndx];
11518
11519           /* An object file might have a reference to a local
11520              undefined symbol.  This is a daft object file, but we
11521              should at least do something about it.  V4BX & NONE
11522              relocations do not use the symbol and are explicitly
11523              allowed to use the undefined symbol, so allow those.
11524              Likewise for relocations against STN_UNDEF.  */
11525           if (r_type != R_ARM_V4BX
11526               && r_type != R_ARM_NONE
11527               && r_symndx != STN_UNDEF
11528               && bfd_is_und_section (sec)
11529               && ELF_ST_BIND (sym->st_info) != STB_WEAK)
11530             (*info->callbacks->undefined_symbol)
11531               (info, bfd_elf_string_from_elf_section
11532                (input_bfd, symtab_hdr->sh_link, sym->st_name),
11533                input_bfd, input_section,
11534                rel->r_offset, TRUE);
11535
11536           if (globals->use_rel)
11537             {
11538               relocation = (sec->output_section->vma
11539                             + sec->output_offset
11540                             + sym->st_value);
11541               if (!bfd_link_relocatable (info)
11542                   && (sec->flags & SEC_MERGE)
11543                   && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
11544                 {
11545                   asection *msec;
11546                   bfd_vma addend, value;
11547
11548                   switch (r_type)
11549                     {
11550                     case R_ARM_MOVW_ABS_NC:
11551                     case R_ARM_MOVT_ABS:
11552                       value = bfd_get_32 (input_bfd, contents + rel->r_offset);
11553                       addend = ((value & 0xf0000) >> 4) | (value & 0xfff);
11554                       addend = (addend ^ 0x8000) - 0x8000;
11555                       break;
11556
11557                     case R_ARM_THM_MOVW_ABS_NC:
11558                     case R_ARM_THM_MOVT_ABS:
11559                       value = bfd_get_16 (input_bfd, contents + rel->r_offset)
11560                               << 16;
11561                       value |= bfd_get_16 (input_bfd,
11562                                            contents + rel->r_offset + 2);
11563                       addend = ((value & 0xf7000) >> 4) | (value & 0xff)
11564                                | ((value & 0x04000000) >> 15);
11565                       addend = (addend ^ 0x8000) - 0x8000;
11566                       break;
11567
11568                     default:
11569                       if (howto->rightshift
11570                           || (howto->src_mask & (howto->src_mask + 1)))
11571                         {
11572                           (*_bfd_error_handler)
11573                             (_("%B(%A+0x%lx): %s relocation against SEC_MERGE section"),
11574                              input_bfd, input_section,
11575                              (long) rel->r_offset, howto->name);
11576                           return FALSE;
11577                         }
11578
11579                       value = bfd_get_32 (input_bfd, contents + rel->r_offset);
11580
11581                       /* Get the (signed) value from the instruction.  */
11582                       addend = value & howto->src_mask;
11583                       if (addend & ((howto->src_mask + 1) >> 1))
11584                         {
11585                           bfd_signed_vma mask;
11586
11587                           mask = -1;
11588                           mask &= ~ howto->src_mask;
11589                           addend |= mask;
11590                         }
11591                       break;
11592                     }
11593
11594                   msec = sec;
11595                   addend =
11596                     _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend)
11597                     - relocation;
11598                   addend += msec->output_section->vma + msec->output_offset;
11599
11600                   /* Cases here must match those in the preceding
11601                      switch statement.  */
11602                   switch (r_type)
11603                     {
11604                     case R_ARM_MOVW_ABS_NC:
11605                     case R_ARM_MOVT_ABS:
11606                       value = (value & 0xfff0f000) | ((addend & 0xf000) << 4)
11607                               | (addend & 0xfff);
11608                       bfd_put_32 (input_bfd, value, contents + rel->r_offset);
11609                       break;
11610
11611                     case R_ARM_THM_MOVW_ABS_NC:
11612                     case R_ARM_THM_MOVT_ABS:
11613                       value = (value & 0xfbf08f00) | ((addend & 0xf700) << 4)
11614                               | (addend & 0xff) | ((addend & 0x0800) << 15);
11615                       bfd_put_16 (input_bfd, value >> 16,
11616                                   contents + rel->r_offset);
11617                       bfd_put_16 (input_bfd, value,
11618                                   contents + rel->r_offset + 2);
11619                       break;
11620
11621                     default:
11622                       value = (value & ~ howto->dst_mask)
11623                               | (addend & howto->dst_mask);
11624                       bfd_put_32 (input_bfd, value, contents + rel->r_offset);
11625                       break;
11626                     }
11627                 }
11628             }
11629           else
11630             relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
11631         }
11632       else
11633         {
11634           bfd_boolean warned, ignored;
11635
11636           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
11637                                    r_symndx, symtab_hdr, sym_hashes,
11638                                    h, sec, relocation,
11639                                    unresolved_reloc, warned, ignored);
11640
11641           sym_type = h->type;
11642         }
11643
11644       if (sec != NULL && discarded_section (sec))
11645         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
11646                                          rel, 1, relend, howto, 0, contents);
11647
11648       if (bfd_link_relocatable (info))
11649         {
11650           /* This is a relocatable link.  We don't have to change
11651              anything, unless the reloc is against a section symbol,
11652              in which case we have to adjust according to where the
11653              section symbol winds up in the output section.  */
11654           if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
11655             {
11656               if (globals->use_rel)
11657                 arm_add_to_rel (input_bfd, contents + rel->r_offset,
11658                                 howto, (bfd_signed_vma) sec->output_offset);
11659               else
11660                 rel->r_addend += sec->output_offset;
11661             }
11662           continue;
11663         }
11664
11665       if (h != NULL)
11666         name = h->root.root.string;
11667       else
11668         {
11669           name = (bfd_elf_string_from_elf_section
11670                   (input_bfd, symtab_hdr->sh_link, sym->st_name));
11671           if (name == NULL || *name == '\0')
11672             name = bfd_section_name (input_bfd, sec);
11673         }
11674
11675       if (r_symndx != STN_UNDEF
11676           && r_type != R_ARM_NONE
11677           && (h == NULL
11678               || h->root.type == bfd_link_hash_defined
11679               || h->root.type == bfd_link_hash_defweak)
11680           && IS_ARM_TLS_RELOC (r_type) != (sym_type == STT_TLS))
11681         {
11682           (*_bfd_error_handler)
11683             ((sym_type == STT_TLS
11684               ? _("%B(%A+0x%lx): %s used with TLS symbol %s")
11685               : _("%B(%A+0x%lx): %s used with non-TLS symbol %s")),
11686              input_bfd,
11687              input_section,
11688              (long) rel->r_offset,
11689              howto->name,
11690              name);
11691         }
11692
11693       /* We call elf32_arm_final_link_relocate unless we're completely
11694          done, i.e., the relaxation produced the final output we want,
11695          and we won't let anybody mess with it. Also, we have to do
11696          addend adjustments in case of a R_ARM_TLS_GOTDESC relocation
11697          both in relaxed and non-relaxed cases.  */
11698       if ((elf32_arm_tls_transition (info, r_type, h) != (unsigned)r_type)
11699           || (IS_ARM_TLS_GNU_RELOC (r_type)
11700               && !((h ? elf32_arm_hash_entry (h)->tls_type :
11701                     elf32_arm_local_got_tls_type (input_bfd)[r_symndx])
11702                    & GOT_TLS_GDESC)))
11703         {
11704           r = elf32_arm_tls_relax (globals, input_bfd, input_section,
11705                                    contents, rel, h == NULL);
11706           /* This may have been marked unresolved because it came from
11707              a shared library.  But we've just dealt with that.  */
11708           unresolved_reloc = 0;
11709         }
11710       else
11711         r = bfd_reloc_continue;
11712
11713       if (r == bfd_reloc_continue)
11714         {
11715           unsigned char branch_type =
11716             h ? ARM_GET_SYM_BRANCH_TYPE (h->target_internal)
11717               : ARM_GET_SYM_BRANCH_TYPE (sym->st_target_internal);
11718
11719           r = elf32_arm_final_link_relocate (howto, input_bfd, output_bfd,
11720                                              input_section, contents, rel,
11721                                              relocation, info, sec, name,
11722                                              sym_type, branch_type, h,
11723                                              &unresolved_reloc,
11724                                              &error_message);
11725         }
11726
11727       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
11728          because such sections are not SEC_ALLOC and thus ld.so will
11729          not process them.  */
11730       if (unresolved_reloc
11731           && !((input_section->flags & SEC_DEBUGGING) != 0
11732                && h->def_dynamic)
11733           && _bfd_elf_section_offset (output_bfd, info, input_section,
11734                                       rel->r_offset) != (bfd_vma) -1)
11735         {
11736           (*_bfd_error_handler)
11737             (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
11738              input_bfd,
11739              input_section,
11740              (long) rel->r_offset,
11741              howto->name,
11742              h->root.root.string);
11743           return FALSE;
11744         }
11745
11746       if (r != bfd_reloc_ok)
11747         {
11748           switch (r)
11749             {
11750             case bfd_reloc_overflow:
11751               /* If the overflowing reloc was to an undefined symbol,
11752                  we have already printed one error message and there
11753                  is no point complaining again.  */
11754               if (!h || h->root.type != bfd_link_hash_undefined)
11755                 (*info->callbacks->reloc_overflow)
11756                   (info, (h ? &h->root : NULL), name, howto->name,
11757                    (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
11758               break;
11759
11760             case bfd_reloc_undefined:
11761               (*info->callbacks->undefined_symbol)
11762                 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
11763               break;
11764
11765             case bfd_reloc_outofrange:
11766               error_message = _("out of range");
11767               goto common_error;
11768
11769             case bfd_reloc_notsupported:
11770               error_message = _("unsupported relocation");
11771               goto common_error;
11772
11773             case bfd_reloc_dangerous:
11774               /* error_message should already be set.  */
11775               goto common_error;
11776
11777             default:
11778               error_message = _("unknown error");
11779               /* Fall through.  */
11780
11781             common_error:
11782               BFD_ASSERT (error_message != NULL);
11783               (*info->callbacks->reloc_dangerous)
11784                 (info, error_message, input_bfd, input_section, rel->r_offset);
11785               break;
11786             }
11787         }
11788     }
11789
11790   return TRUE;
11791 }
11792
11793 /* Add a new unwind edit to the list described by HEAD, TAIL.  If TINDEX is zero,
11794    adds the edit to the start of the list.  (The list must be built in order of
11795    ascending TINDEX: the function's callers are primarily responsible for
11796    maintaining that condition).  */
11797
11798 static void
11799 add_unwind_table_edit (arm_unwind_table_edit **head,
11800                        arm_unwind_table_edit **tail,
11801                        arm_unwind_edit_type type,
11802                        asection *linked_section,
11803                        unsigned int tindex)
11804 {
11805   arm_unwind_table_edit *new_edit = (arm_unwind_table_edit *)
11806       xmalloc (sizeof (arm_unwind_table_edit));
11807
11808   new_edit->type = type;
11809   new_edit->linked_section = linked_section;
11810   new_edit->index = tindex;
11811
11812   if (tindex > 0)
11813     {
11814       new_edit->next = NULL;
11815
11816       if (*tail)
11817         (*tail)->next = new_edit;
11818
11819       (*tail) = new_edit;
11820
11821       if (!*head)
11822         (*head) = new_edit;
11823     }
11824   else
11825     {
11826       new_edit->next = *head;
11827
11828       if (!*tail)
11829         *tail = new_edit;
11830
11831       *head = new_edit;
11832     }
11833 }
11834
11835 static _arm_elf_section_data *get_arm_elf_section_data (asection *);
11836
11837 /* Increase the size of EXIDX_SEC by ADJUST bytes.  ADJUST mau be negative.  */
11838 static void
11839 adjust_exidx_size(asection *exidx_sec, int adjust)
11840 {
11841   asection *out_sec;
11842
11843   if (!exidx_sec->rawsize)
11844     exidx_sec->rawsize = exidx_sec->size;
11845
11846   bfd_set_section_size (exidx_sec->owner, exidx_sec, exidx_sec->size + adjust);
11847   out_sec = exidx_sec->output_section;
11848   /* Adjust size of output section.  */
11849   bfd_set_section_size (out_sec->owner, out_sec, out_sec->size +adjust);
11850 }
11851
11852 /* Insert an EXIDX_CANTUNWIND marker at the end of a section.  */
11853 static void
11854 insert_cantunwind_after(asection *text_sec, asection *exidx_sec)
11855 {
11856   struct _arm_elf_section_data *exidx_arm_data;
11857
11858   exidx_arm_data = get_arm_elf_section_data (exidx_sec);
11859   add_unwind_table_edit (
11860     &exidx_arm_data->u.exidx.unwind_edit_list,
11861     &exidx_arm_data->u.exidx.unwind_edit_tail,
11862     INSERT_EXIDX_CANTUNWIND_AT_END, text_sec, UINT_MAX);
11863
11864   exidx_arm_data->additional_reloc_count++;
11865
11866   adjust_exidx_size(exidx_sec, 8);
11867 }
11868
11869 /* Scan .ARM.exidx tables, and create a list describing edits which should be
11870    made to those tables, such that:
11871
11872      1. Regions without unwind data are marked with EXIDX_CANTUNWIND entries.
11873      2. Duplicate entries are merged together (EXIDX_CANTUNWIND, or unwind
11874         codes which have been inlined into the index).
11875
11876    If MERGE_EXIDX_ENTRIES is false, duplicate entries are not merged.
11877
11878    The edits are applied when the tables are written
11879    (in elf32_arm_write_section).  */
11880
11881 bfd_boolean
11882 elf32_arm_fix_exidx_coverage (asection **text_section_order,
11883                               unsigned int num_text_sections,
11884                               struct bfd_link_info *info,
11885                               bfd_boolean merge_exidx_entries)
11886 {
11887   bfd *inp;
11888   unsigned int last_second_word = 0, i;
11889   asection *last_exidx_sec = NULL;
11890   asection *last_text_sec = NULL;
11891   int last_unwind_type = -1;
11892
11893   /* Walk over all EXIDX sections, and create backlinks from the corrsponding
11894      text sections.  */
11895   for (inp = info->input_bfds; inp != NULL; inp = inp->link.next)
11896     {
11897       asection *sec;
11898
11899       for (sec = inp->sections; sec != NULL; sec = sec->next)
11900         {
11901           struct bfd_elf_section_data *elf_sec = elf_section_data (sec);
11902           Elf_Internal_Shdr *hdr = &elf_sec->this_hdr;
11903
11904           if (!hdr || hdr->sh_type != SHT_ARM_EXIDX)
11905             continue;
11906
11907           if (elf_sec->linked_to)
11908             {
11909               Elf_Internal_Shdr *linked_hdr
11910                 = &elf_section_data (elf_sec->linked_to)->this_hdr;
11911               struct _arm_elf_section_data *linked_sec_arm_data
11912                 = get_arm_elf_section_data (linked_hdr->bfd_section);
11913
11914               if (linked_sec_arm_data == NULL)
11915                 continue;
11916
11917               /* Link this .ARM.exidx section back from the text section it
11918                  describes.  */
11919               linked_sec_arm_data->u.text.arm_exidx_sec = sec;
11920             }
11921         }
11922     }
11923
11924   /* Walk all text sections in order of increasing VMA.  Eilminate duplicate
11925      index table entries (EXIDX_CANTUNWIND and inlined unwind opcodes),
11926      and add EXIDX_CANTUNWIND entries for sections with no unwind table data.  */
11927
11928   for (i = 0; i < num_text_sections; i++)
11929     {
11930       asection *sec = text_section_order[i];
11931       asection *exidx_sec;
11932       struct _arm_elf_section_data *arm_data = get_arm_elf_section_data (sec);
11933       struct _arm_elf_section_data *exidx_arm_data;
11934       bfd_byte *contents = NULL;
11935       int deleted_exidx_bytes = 0;
11936       bfd_vma j;
11937       arm_unwind_table_edit *unwind_edit_head = NULL;
11938       arm_unwind_table_edit *unwind_edit_tail = NULL;
11939       Elf_Internal_Shdr *hdr;
11940       bfd *ibfd;
11941
11942       if (arm_data == NULL)
11943         continue;
11944
11945       exidx_sec = arm_data->u.text.arm_exidx_sec;
11946       if (exidx_sec == NULL)
11947         {
11948           /* Section has no unwind data.  */
11949           if (last_unwind_type == 0 || !last_exidx_sec)
11950             continue;
11951
11952           /* Ignore zero sized sections.  */
11953           if (sec->size == 0)
11954             continue;
11955
11956           insert_cantunwind_after(last_text_sec, last_exidx_sec);
11957           last_unwind_type = 0;
11958           continue;
11959         }
11960
11961       /* Skip /DISCARD/ sections.  */
11962       if (bfd_is_abs_section (exidx_sec->output_section))
11963         continue;
11964
11965       hdr = &elf_section_data (exidx_sec)->this_hdr;
11966       if (hdr->sh_type != SHT_ARM_EXIDX)
11967         continue;
11968
11969       exidx_arm_data = get_arm_elf_section_data (exidx_sec);
11970       if (exidx_arm_data == NULL)
11971         continue;
11972
11973       ibfd = exidx_sec->owner;
11974
11975       if (hdr->contents != NULL)
11976         contents = hdr->contents;
11977       else if (! bfd_malloc_and_get_section (ibfd, exidx_sec, &contents))
11978         /* An error?  */
11979         continue;
11980
11981       if (last_unwind_type > 0)
11982         {
11983           unsigned int first_word = bfd_get_32 (ibfd, contents);
11984           /* Add cantunwind if first unwind item does not match section
11985              start.  */
11986           if (first_word != sec->vma)
11987             {
11988               insert_cantunwind_after (last_text_sec, last_exidx_sec);
11989               last_unwind_type = 0;
11990             }
11991         }
11992
11993       for (j = 0; j < hdr->sh_size; j += 8)
11994         {
11995           unsigned int second_word = bfd_get_32 (ibfd, contents + j + 4);
11996           int unwind_type;
11997           int elide = 0;
11998
11999           /* An EXIDX_CANTUNWIND entry.  */
12000           if (second_word == 1)
12001             {
12002               if (last_unwind_type == 0)
12003                 elide = 1;
12004               unwind_type = 0;
12005             }
12006           /* Inlined unwinding data.  Merge if equal to previous.  */
12007           else if ((second_word & 0x80000000) != 0)
12008             {
12009               if (merge_exidx_entries
12010                    && last_second_word == second_word && last_unwind_type == 1)
12011                 elide = 1;
12012               unwind_type = 1;
12013               last_second_word = second_word;
12014             }
12015           /* Normal table entry.  In theory we could merge these too,
12016              but duplicate entries are likely to be much less common.  */
12017           else
12018             unwind_type = 2;
12019
12020           if (elide && !bfd_link_relocatable (info))
12021             {
12022               add_unwind_table_edit (&unwind_edit_head, &unwind_edit_tail,
12023                                      DELETE_EXIDX_ENTRY, NULL, j / 8);
12024
12025               deleted_exidx_bytes += 8;
12026             }
12027
12028           last_unwind_type = unwind_type;
12029         }
12030
12031       /* Free contents if we allocated it ourselves.  */
12032       if (contents != hdr->contents)
12033         free (contents);
12034
12035       /* Record edits to be applied later (in elf32_arm_write_section).  */
12036       exidx_arm_data->u.exidx.unwind_edit_list = unwind_edit_head;
12037       exidx_arm_data->u.exidx.unwind_edit_tail = unwind_edit_tail;
12038
12039       if (deleted_exidx_bytes > 0)
12040         adjust_exidx_size(exidx_sec, -deleted_exidx_bytes);
12041
12042       last_exidx_sec = exidx_sec;
12043       last_text_sec = sec;
12044     }
12045
12046   /* Add terminating CANTUNWIND entry.  */
12047   if (!bfd_link_relocatable (info) && last_exidx_sec
12048       && last_unwind_type != 0)
12049     insert_cantunwind_after(last_text_sec, last_exidx_sec);
12050
12051   return TRUE;
12052 }
12053
12054 static bfd_boolean
12055 elf32_arm_output_glue_section (struct bfd_link_info *info, bfd *obfd,
12056                                bfd *ibfd, const char *name)
12057 {
12058   asection *sec, *osec;
12059
12060   sec = bfd_get_linker_section (ibfd, name);
12061   if (sec == NULL || (sec->flags & SEC_EXCLUDE) != 0)
12062     return TRUE;
12063
12064   osec = sec->output_section;
12065   if (elf32_arm_write_section (obfd, info, sec, sec->contents))
12066     return TRUE;
12067
12068   if (! bfd_set_section_contents (obfd, osec, sec->contents,
12069                                   sec->output_offset, sec->size))
12070     return FALSE;
12071
12072   return TRUE;
12073 }
12074
12075 static bfd_boolean
12076 elf32_arm_final_link (bfd *abfd, struct bfd_link_info *info)
12077 {
12078   struct elf32_arm_link_hash_table *globals = elf32_arm_hash_table (info);
12079   asection *sec, *osec;
12080
12081   if (globals == NULL)
12082     return FALSE;
12083
12084   /* Invoke the regular ELF backend linker to do all the work.  */
12085   if (!bfd_elf_final_link (abfd, info))
12086     return FALSE;
12087
12088   /* Process stub sections (eg BE8 encoding, ...).  */
12089   struct elf32_arm_link_hash_table *htab = elf32_arm_hash_table (info);
12090   unsigned int i;
12091   for (i=0; i<htab->top_id; i++)
12092     {
12093       sec = htab->stub_group[i].stub_sec;
12094       /* Only process it once, in its link_sec slot.  */
12095       if (sec && i == htab->stub_group[i].link_sec->id)
12096         {
12097           osec = sec->output_section;
12098           elf32_arm_write_section (abfd, info, sec, sec->contents);
12099           if (! bfd_set_section_contents (abfd, osec, sec->contents,
12100                                           sec->output_offset, sec->size))
12101             return FALSE;
12102         }
12103     }
12104
12105   /* Write out any glue sections now that we have created all the
12106      stubs.  */
12107   if (globals->bfd_of_glue_owner != NULL)
12108     {
12109       if (! elf32_arm_output_glue_section (info, abfd,
12110                                            globals->bfd_of_glue_owner,
12111                                            ARM2THUMB_GLUE_SECTION_NAME))
12112         return FALSE;
12113
12114       if (! elf32_arm_output_glue_section (info, abfd,
12115                                            globals->bfd_of_glue_owner,
12116                                            THUMB2ARM_GLUE_SECTION_NAME))
12117         return FALSE;
12118
12119       if (! elf32_arm_output_glue_section (info, abfd,
12120                                            globals->bfd_of_glue_owner,
12121                                            VFP11_ERRATUM_VENEER_SECTION_NAME))
12122         return FALSE;
12123
12124       if (! elf32_arm_output_glue_section (info, abfd,
12125                                            globals->bfd_of_glue_owner,
12126                                            STM32L4XX_ERRATUM_VENEER_SECTION_NAME))
12127         return FALSE;
12128
12129       if (! elf32_arm_output_glue_section (info, abfd,
12130                                            globals->bfd_of_glue_owner,
12131                                            ARM_BX_GLUE_SECTION_NAME))
12132         return FALSE;
12133     }
12134
12135   return TRUE;
12136 }
12137
12138 /* Return a best guess for the machine number based on the attributes.  */
12139
12140 static unsigned int
12141 bfd_arm_get_mach_from_attributes (bfd * abfd)
12142 {
12143   int arch = bfd_elf_get_obj_attr_int (abfd, OBJ_ATTR_PROC, Tag_CPU_arch);
12144
12145   switch (arch)
12146     {
12147     case TAG_CPU_ARCH_V4: return bfd_mach_arm_4;
12148     case TAG_CPU_ARCH_V4T: return bfd_mach_arm_4T;
12149     case TAG_CPU_ARCH_V5T: return bfd_mach_arm_5T;
12150
12151     case TAG_CPU_ARCH_V5TE:
12152       {
12153         char * name;
12154
12155         BFD_ASSERT (Tag_CPU_name < NUM_KNOWN_OBJ_ATTRIBUTES);
12156         name = elf_known_obj_attributes (abfd) [OBJ_ATTR_PROC][Tag_CPU_name].s;
12157
12158         if (name)
12159           {
12160             if (strcmp (name, "IWMMXT2") == 0)
12161               return bfd_mach_arm_iWMMXt2;
12162
12163             if (strcmp (name, "IWMMXT") == 0)
12164               return bfd_mach_arm_iWMMXt;
12165
12166             if (strcmp (name, "XSCALE") == 0)
12167               {
12168                 int wmmx;
12169
12170                 BFD_ASSERT (Tag_WMMX_arch < NUM_KNOWN_OBJ_ATTRIBUTES);
12171                 wmmx = elf_known_obj_attributes (abfd) [OBJ_ATTR_PROC][Tag_WMMX_arch].i;
12172                 switch (wmmx)
12173                   {
12174                   case 1: return bfd_mach_arm_iWMMXt;
12175                   case 2: return bfd_mach_arm_iWMMXt2;
12176                   default: return bfd_mach_arm_XScale;
12177                   }
12178               }
12179           }
12180
12181         return bfd_mach_arm_5TE;
12182       }
12183
12184     default:
12185       return bfd_mach_arm_unknown;
12186     }
12187 }
12188
12189 /* Set the right machine number.  */
12190
12191 static bfd_boolean
12192 elf32_arm_object_p (bfd *abfd)
12193 {
12194   unsigned int mach;
12195
12196   mach = bfd_arm_get_mach_from_notes (abfd, ARM_NOTE_SECTION);
12197
12198   if (mach == bfd_mach_arm_unknown)
12199     {
12200       if (elf_elfheader (abfd)->e_flags & EF_ARM_MAVERICK_FLOAT)
12201         mach = bfd_mach_arm_ep9312;
12202       else
12203         mach = bfd_arm_get_mach_from_attributes (abfd);
12204     }
12205
12206   bfd_default_set_arch_mach (abfd, bfd_arch_arm, mach);
12207   return TRUE;
12208 }
12209
12210 /* Function to keep ARM specific flags in the ELF header.  */
12211
12212 static bfd_boolean
12213 elf32_arm_set_private_flags (bfd *abfd, flagword flags)
12214 {
12215   if (elf_flags_init (abfd)
12216       && elf_elfheader (abfd)->e_flags != flags)
12217     {
12218       if (EF_ARM_EABI_VERSION (flags) == EF_ARM_EABI_UNKNOWN)
12219         {
12220           if (flags & EF_ARM_INTERWORK)
12221             (*_bfd_error_handler)
12222               (_("Warning: Not setting interworking flag of %B since it has already been specified as non-interworking"),
12223                abfd);
12224           else
12225             _bfd_error_handler
12226               (_("Warning: Clearing the interworking flag of %B due to outside request"),
12227                abfd);
12228         }
12229     }
12230   else
12231     {
12232       elf_elfheader (abfd)->e_flags = flags;
12233       elf_flags_init (abfd) = TRUE;
12234     }
12235
12236   return TRUE;
12237 }
12238
12239 /* Copy backend specific data from one object module to another.  */
12240
12241 static bfd_boolean
12242 elf32_arm_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
12243 {
12244   flagword in_flags;
12245   flagword out_flags;
12246
12247   if (! is_arm_elf (ibfd) || ! is_arm_elf (obfd))
12248     return TRUE;
12249
12250   in_flags  = elf_elfheader (ibfd)->e_flags;
12251   out_flags = elf_elfheader (obfd)->e_flags;
12252
12253   if (elf_flags_init (obfd)
12254       && EF_ARM_EABI_VERSION (out_flags) == EF_ARM_EABI_UNKNOWN
12255       && in_flags != out_flags)
12256     {
12257       /* Cannot mix APCS26 and APCS32 code.  */
12258       if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
12259         return FALSE;
12260
12261       /* Cannot mix float APCS and non-float APCS code.  */
12262       if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
12263         return FALSE;
12264
12265       /* If the src and dest have different interworking flags
12266          then turn off the interworking bit.  */
12267       if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
12268         {
12269           if (out_flags & EF_ARM_INTERWORK)
12270             _bfd_error_handler
12271               (_("Warning: Clearing the interworking flag of %B because non-interworking code in %B has been linked with it"),
12272                obfd, ibfd);
12273
12274           in_flags &= ~EF_ARM_INTERWORK;
12275         }
12276
12277       /* Likewise for PIC, though don't warn for this case.  */
12278       if ((in_flags & EF_ARM_PIC) != (out_flags & EF_ARM_PIC))
12279         in_flags &= ~EF_ARM_PIC;
12280     }
12281
12282   elf_elfheader (obfd)->e_flags = in_flags;
12283   elf_flags_init (obfd) = TRUE;
12284
12285   return _bfd_elf_copy_private_bfd_data (ibfd, obfd);
12286 }
12287
12288 /* Values for Tag_ABI_PCS_R9_use.  */
12289 enum
12290 {
12291   AEABI_R9_V6,
12292   AEABI_R9_SB,
12293   AEABI_R9_TLS,
12294   AEABI_R9_unused
12295 };
12296
12297 /* Values for Tag_ABI_PCS_RW_data.  */
12298 enum
12299 {
12300   AEABI_PCS_RW_data_absolute,
12301   AEABI_PCS_RW_data_PCrel,
12302   AEABI_PCS_RW_data_SBrel,
12303   AEABI_PCS_RW_data_unused
12304 };
12305
12306 /* Values for Tag_ABI_enum_size.  */
12307 enum
12308 {
12309   AEABI_enum_unused,
12310   AEABI_enum_short,
12311   AEABI_enum_wide,
12312   AEABI_enum_forced_wide
12313 };
12314
12315 /* Determine whether an object attribute tag takes an integer, a
12316    string or both.  */
12317
12318 static int
12319 elf32_arm_obj_attrs_arg_type (int tag)
12320 {
12321   if (tag == Tag_compatibility)
12322     return ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_STR_VAL;
12323   else if (tag == Tag_nodefaults)
12324     return ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_NO_DEFAULT;
12325   else if (tag == Tag_CPU_raw_name || tag == Tag_CPU_name)
12326     return ATTR_TYPE_FLAG_STR_VAL;
12327   else if (tag < 32)
12328     return ATTR_TYPE_FLAG_INT_VAL;
12329   else
12330     return (tag & 1) != 0 ? ATTR_TYPE_FLAG_STR_VAL : ATTR_TYPE_FLAG_INT_VAL;
12331 }
12332
12333 /* The ABI defines that Tag_conformance should be emitted first, and that
12334    Tag_nodefaults should be second (if either is defined).  This sets those
12335    two positions, and bumps up the position of all the remaining tags to
12336    compensate.  */
12337 static int
12338 elf32_arm_obj_attrs_order (int num)
12339 {
12340   if (num == LEAST_KNOWN_OBJ_ATTRIBUTE)
12341     return Tag_conformance;
12342   if (num == LEAST_KNOWN_OBJ_ATTRIBUTE + 1)
12343     return Tag_nodefaults;
12344   if ((num - 2) < Tag_nodefaults)
12345     return num - 2;
12346   if ((num - 1) < Tag_conformance)
12347     return num - 1;
12348   return num;
12349 }
12350
12351 /* Attribute numbers >=64 (mod 128) can be safely ignored.  */
12352 static bfd_boolean
12353 elf32_arm_obj_attrs_handle_unknown (bfd *abfd, int tag)
12354 {
12355   if ((tag & 127) < 64)
12356     {
12357       _bfd_error_handler
12358         (_("%B: Unknown mandatory EABI object attribute %d"),
12359          abfd, tag);
12360       bfd_set_error (bfd_error_bad_value);
12361       return FALSE;
12362     }
12363   else
12364     {
12365       _bfd_error_handler
12366         (_("Warning: %B: Unknown EABI object attribute %d"),
12367          abfd, tag);
12368       return TRUE;
12369     }
12370 }
12371
12372 /* Read the architecture from the Tag_also_compatible_with attribute, if any.
12373    Returns -1 if no architecture could be read.  */
12374
12375 static int
12376 get_secondary_compatible_arch (bfd *abfd)
12377 {
12378   obj_attribute *attr =
12379     &elf_known_obj_attributes_proc (abfd)[Tag_also_compatible_with];
12380
12381   /* Note: the tag and its argument below are uleb128 values, though
12382      currently-defined values fit in one byte for each.  */
12383   if (attr->s
12384       && attr->s[0] == Tag_CPU_arch
12385       && (attr->s[1] & 128) != 128
12386       && attr->s[2] == 0)
12387    return attr->s[1];
12388
12389   /* This tag is "safely ignorable", so don't complain if it looks funny.  */
12390   return -1;
12391 }
12392
12393 /* Set, or unset, the architecture of the Tag_also_compatible_with attribute.
12394    The tag is removed if ARCH is -1.  */
12395
12396 static void
12397 set_secondary_compatible_arch (bfd *abfd, int arch)
12398 {
12399   obj_attribute *attr =
12400     &elf_known_obj_attributes_proc (abfd)[Tag_also_compatible_with];
12401
12402   if (arch == -1)
12403     {
12404       attr->s = NULL;
12405       return;
12406     }
12407
12408   /* Note: the tag and its argument below are uleb128 values, though
12409      currently-defined values fit in one byte for each.  */
12410   if (!attr->s)
12411     attr->s = (char *) bfd_alloc (abfd, 3);
12412   attr->s[0] = Tag_CPU_arch;
12413   attr->s[1] = arch;
12414   attr->s[2] = '\0';
12415 }
12416
12417 /* Combine two values for Tag_CPU_arch, taking secondary compatibility tags
12418    into account.  */
12419
12420 static int
12421 tag_cpu_arch_combine (bfd *ibfd, int oldtag, int *secondary_compat_out,
12422                       int newtag, int secondary_compat)
12423 {
12424 #define T(X) TAG_CPU_ARCH_##X
12425   int tagl, tagh, result;
12426   const int v6t2[] =
12427     {
12428       T(V6T2),   /* PRE_V4.  */
12429       T(V6T2),   /* V4.  */
12430       T(V6T2),   /* V4T.  */
12431       T(V6T2),   /* V5T.  */
12432       T(V6T2),   /* V5TE.  */
12433       T(V6T2),   /* V5TEJ.  */
12434       T(V6T2),   /* V6.  */
12435       T(V7),     /* V6KZ.  */
12436       T(V6T2)    /* V6T2.  */
12437     };
12438   const int v6k[] =
12439     {
12440       T(V6K),    /* PRE_V4.  */
12441       T(V6K),    /* V4.  */
12442       T(V6K),    /* V4T.  */
12443       T(V6K),    /* V5T.  */
12444       T(V6K),    /* V5TE.  */
12445       T(V6K),    /* V5TEJ.  */
12446       T(V6K),    /* V6.  */
12447       T(V6KZ),   /* V6KZ.  */
12448       T(V7),     /* V6T2.  */
12449       T(V6K)     /* V6K.  */
12450     };
12451   const int v7[] =
12452     {
12453       T(V7),     /* PRE_V4.  */
12454       T(V7),     /* V4.  */
12455       T(V7),     /* V4T.  */
12456       T(V7),     /* V5T.  */
12457       T(V7),     /* V5TE.  */
12458       T(V7),     /* V5TEJ.  */
12459       T(V7),     /* V6.  */
12460       T(V7),     /* V6KZ.  */
12461       T(V7),     /* V6T2.  */
12462       T(V7),     /* V6K.  */
12463       T(V7)      /* V7.  */
12464     };
12465   const int v6_m[] =
12466     {
12467       -1,        /* PRE_V4.  */
12468       -1,        /* V4.  */
12469       T(V6K),    /* V4T.  */
12470       T(V6K),    /* V5T.  */
12471       T(V6K),    /* V5TE.  */
12472       T(V6K),    /* V5TEJ.  */
12473       T(V6K),    /* V6.  */
12474       T(V6KZ),   /* V6KZ.  */
12475       T(V7),     /* V6T2.  */
12476       T(V6K),    /* V6K.  */
12477       T(V7),     /* V7.  */
12478       T(V6_M)    /* V6_M.  */
12479     };
12480   const int v6s_m[] =
12481     {
12482       -1,        /* PRE_V4.  */
12483       -1,        /* V4.  */
12484       T(V6K),    /* V4T.  */
12485       T(V6K),    /* V5T.  */
12486       T(V6K),    /* V5TE.  */
12487       T(V6K),    /* V5TEJ.  */
12488       T(V6K),    /* V6.  */
12489       T(V6KZ),   /* V6KZ.  */
12490       T(V7),     /* V6T2.  */
12491       T(V6K),    /* V6K.  */
12492       T(V7),     /* V7.  */
12493       T(V6S_M),  /* V6_M.  */
12494       T(V6S_M)   /* V6S_M.  */
12495     };
12496   const int v7e_m[] =
12497     {
12498       -1,        /* PRE_V4.  */
12499       -1,        /* V4.  */
12500       T(V7E_M),  /* V4T.  */
12501       T(V7E_M),  /* V5T.  */
12502       T(V7E_M),  /* V5TE.  */
12503       T(V7E_M),  /* V5TEJ.  */
12504       T(V7E_M),  /* V6.  */
12505       T(V7E_M),  /* V6KZ.  */
12506       T(V7E_M),  /* V6T2.  */
12507       T(V7E_M),  /* V6K.  */
12508       T(V7E_M),  /* V7.  */
12509       T(V7E_M),  /* V6_M.  */
12510       T(V7E_M),  /* V6S_M.  */
12511       T(V7E_M)   /* V7E_M.  */
12512     };
12513   const int v8[] =
12514     {
12515       T(V8),            /* PRE_V4.  */
12516       T(V8),            /* V4.  */
12517       T(V8),            /* V4T.  */
12518       T(V8),            /* V5T.  */
12519       T(V8),            /* V5TE.  */
12520       T(V8),            /* V5TEJ.  */
12521       T(V8),            /* V6.  */
12522       T(V8),            /* V6KZ.  */
12523       T(V8),            /* V6T2.  */
12524       T(V8),            /* V6K.  */
12525       T(V8),            /* V7.  */
12526       T(V8),            /* V6_M.  */
12527       T(V8),            /* V6S_M.  */
12528       T(V8),            /* V7E_M.  */
12529       T(V8)             /* V8.  */
12530     };
12531   const int v8m_baseline[] =
12532     {
12533       -1,               /* PRE_V4.  */
12534       -1,               /* V4.  */
12535       -1,               /* V4T.  */
12536       -1,               /* V5T.  */
12537       -1,               /* V5TE.  */
12538       -1,               /* V5TEJ.  */
12539       -1,               /* V6.  */
12540       -1,               /* V6KZ.  */
12541       -1,               /* V6T2.  */
12542       -1,               /* V6K.  */
12543       -1,               /* V7.  */
12544       T(V8M_BASE),      /* V6_M.  */
12545       T(V8M_BASE),      /* V6S_M.  */
12546       -1,               /* V7E_M.  */
12547       -1,               /* V8.  */
12548       -1,
12549       T(V8M_BASE)       /* V8-M BASELINE.  */
12550     };
12551   const int v8m_mainline[] =
12552     {
12553       -1,               /* PRE_V4.  */
12554       -1,               /* V4.  */
12555       -1,               /* V4T.  */
12556       -1,               /* V5T.  */
12557       -1,               /* V5TE.  */
12558       -1,               /* V5TEJ.  */
12559       -1,               /* V6.  */
12560       -1,               /* V6KZ.  */
12561       -1,               /* V6T2.  */
12562       -1,               /* V6K.  */
12563       T(V8M_MAIN),      /* V7.  */
12564       T(V8M_MAIN),      /* V6_M.  */
12565       T(V8M_MAIN),      /* V6S_M.  */
12566       T(V8M_MAIN),      /* V7E_M.  */
12567       -1,               /* V8.  */
12568       -1,
12569       T(V8M_MAIN),      /* V8-M BASELINE.  */
12570       T(V8M_MAIN)       /* V8-M MAINLINE.  */
12571     };
12572   const int v4t_plus_v6_m[] =
12573     {
12574       -1,               /* PRE_V4.  */
12575       -1,               /* V4.  */
12576       T(V4T),           /* V4T.  */
12577       T(V5T),           /* V5T.  */
12578       T(V5TE),          /* V5TE.  */
12579       T(V5TEJ),         /* V5TEJ.  */
12580       T(V6),            /* V6.  */
12581       T(V6KZ),          /* V6KZ.  */
12582       T(V6T2),          /* V6T2.  */
12583       T(V6K),           /* V6K.  */
12584       T(V7),            /* V7.  */
12585       T(V6_M),          /* V6_M.  */
12586       T(V6S_M),         /* V6S_M.  */
12587       T(V7E_M),         /* V7E_M.  */
12588       T(V8),            /* V8.  */
12589       -1,               /* Unused.  */
12590       T(V8M_BASE),      /* V8-M BASELINE.  */
12591       T(V8M_MAIN),      /* V8-M MAINLINE.  */
12592       T(V4T_PLUS_V6_M)  /* V4T plus V6_M.  */
12593     };
12594   const int *comb[] =
12595     {
12596       v6t2,
12597       v6k,
12598       v7,
12599       v6_m,
12600       v6s_m,
12601       v7e_m,
12602       v8,
12603       NULL,
12604       v8m_baseline,
12605       v8m_mainline,
12606       /* Pseudo-architecture.  */
12607       v4t_plus_v6_m
12608     };
12609
12610   /* Check we've not got a higher architecture than we know about.  */
12611
12612   if (oldtag > MAX_TAG_CPU_ARCH || newtag > MAX_TAG_CPU_ARCH)
12613     {
12614       _bfd_error_handler (_("error: %B: Unknown CPU architecture"), ibfd);
12615       return -1;
12616     }
12617
12618   /* Override old tag if we have a Tag_also_compatible_with on the output.  */
12619
12620   if ((oldtag == T(V6_M) && *secondary_compat_out == T(V4T))
12621       || (oldtag == T(V4T) && *secondary_compat_out == T(V6_M)))
12622     oldtag = T(V4T_PLUS_V6_M);
12623
12624   /* And override the new tag if we have a Tag_also_compatible_with on the
12625      input.  */
12626
12627   if ((newtag == T(V6_M) && secondary_compat == T(V4T))
12628       || (newtag == T(V4T) && secondary_compat == T(V6_M)))
12629     newtag = T(V4T_PLUS_V6_M);
12630
12631   tagl = (oldtag < newtag) ? oldtag : newtag;
12632   result = tagh = (oldtag > newtag) ? oldtag : newtag;
12633
12634   /* Architectures before V6KZ add features monotonically.  */
12635   if (tagh <= TAG_CPU_ARCH_V6KZ)
12636     return result;
12637
12638   result = comb[tagh - T(V6T2)] ? comb[tagh - T(V6T2)][tagl] : -1;
12639
12640   /* Use Tag_CPU_arch == V4T and Tag_also_compatible_with (Tag_CPU_arch V6_M)
12641      as the canonical version.  */
12642   if (result == T(V4T_PLUS_V6_M))
12643     {
12644       result = T(V4T);
12645       *secondary_compat_out = T(V6_M);
12646     }
12647   else
12648     *secondary_compat_out = -1;
12649
12650   if (result == -1)
12651     {
12652       _bfd_error_handler (_("error: %B: Conflicting CPU architectures %d/%d"),
12653                           ibfd, oldtag, newtag);
12654       return -1;
12655     }
12656
12657   return result;
12658 #undef T
12659 }
12660
12661 /* Query attributes object to see if integer divide instructions may be
12662    present in an object.  */
12663 static bfd_boolean
12664 elf32_arm_attributes_accept_div (const obj_attribute *attr)
12665 {
12666   int arch = attr[Tag_CPU_arch].i;
12667   int profile = attr[Tag_CPU_arch_profile].i;
12668
12669   switch (attr[Tag_DIV_use].i)
12670     {
12671     case 0:
12672       /* Integer divide allowed if instruction contained in archetecture.  */
12673       if (arch == TAG_CPU_ARCH_V7 && (profile == 'R' || profile == 'M'))
12674         return TRUE;
12675       else if (arch >= TAG_CPU_ARCH_V7E_M)
12676         return TRUE;
12677       else
12678         return FALSE;
12679
12680     case 1:
12681       /* Integer divide explicitly prohibited.  */
12682       return FALSE;
12683
12684     default:
12685       /* Unrecognised case - treat as allowing divide everywhere.  */
12686     case 2:
12687       /* Integer divide allowed in ARM state.  */
12688       return TRUE;
12689     }
12690 }
12691
12692 /* Query attributes object to see if integer divide instructions are
12693    forbidden to be in the object.  This is not the inverse of
12694    elf32_arm_attributes_accept_div.  */
12695 static bfd_boolean
12696 elf32_arm_attributes_forbid_div (const obj_attribute *attr)
12697 {
12698   return attr[Tag_DIV_use].i == 1;
12699 }
12700
12701 /* Merge EABI object attributes from IBFD into OBFD.  Raise an error if there
12702    are conflicting attributes.  */
12703
12704 static bfd_boolean
12705 elf32_arm_merge_eabi_attributes (bfd *ibfd, bfd *obfd)
12706 {
12707   obj_attribute *in_attr;
12708   obj_attribute *out_attr;
12709   /* Some tags have 0 = don't care, 1 = strong requirement,
12710      2 = weak requirement.  */
12711   static const int order_021[3] = {0, 2, 1};
12712   int i;
12713   bfd_boolean result = TRUE;
12714   const char *sec_name = get_elf_backend_data (ibfd)->obj_attrs_section;
12715
12716   /* Skip the linker stubs file.  This preserves previous behavior
12717      of accepting unknown attributes in the first input file - but
12718      is that a bug?  */
12719   if (ibfd->flags & BFD_LINKER_CREATED)
12720     return TRUE;
12721
12722   /* Skip any input that hasn't attribute section.
12723      This enables to link object files without attribute section with
12724      any others.  */
12725   if (bfd_get_section_by_name (ibfd, sec_name) == NULL)
12726     return TRUE;
12727
12728   if (!elf_known_obj_attributes_proc (obfd)[0].i)
12729     {
12730       /* This is the first object.  Copy the attributes.  */
12731       _bfd_elf_copy_obj_attributes (ibfd, obfd);
12732
12733       out_attr = elf_known_obj_attributes_proc (obfd);
12734
12735       /* Use the Tag_null value to indicate the attributes have been
12736          initialized.  */
12737       out_attr[0].i = 1;
12738
12739       /* We do not output objects with Tag_MPextension_use_legacy - we move
12740          the attribute's value to Tag_MPextension_use.  */
12741       if (out_attr[Tag_MPextension_use_legacy].i != 0)
12742         {
12743           if (out_attr[Tag_MPextension_use].i != 0
12744               && out_attr[Tag_MPextension_use_legacy].i
12745                 != out_attr[Tag_MPextension_use].i)
12746             {
12747               _bfd_error_handler
12748                 (_("Error: %B has both the current and legacy "
12749                    "Tag_MPextension_use attributes"), ibfd);
12750               result = FALSE;
12751             }
12752
12753           out_attr[Tag_MPextension_use] =
12754             out_attr[Tag_MPextension_use_legacy];
12755           out_attr[Tag_MPextension_use_legacy].type = 0;
12756           out_attr[Tag_MPextension_use_legacy].i = 0;
12757         }
12758
12759       return result;
12760     }
12761
12762   in_attr = elf_known_obj_attributes_proc (ibfd);
12763   out_attr = elf_known_obj_attributes_proc (obfd);
12764   /* This needs to happen before Tag_ABI_FP_number_model is merged.  */
12765   if (in_attr[Tag_ABI_VFP_args].i != out_attr[Tag_ABI_VFP_args].i)
12766     {
12767       /* Ignore mismatches if the object doesn't use floating point or is
12768          floating point ABI independent.  */
12769       if (out_attr[Tag_ABI_FP_number_model].i == AEABI_FP_number_model_none
12770           || (in_attr[Tag_ABI_FP_number_model].i != AEABI_FP_number_model_none
12771               && out_attr[Tag_ABI_VFP_args].i == AEABI_VFP_args_compatible))
12772         out_attr[Tag_ABI_VFP_args].i = in_attr[Tag_ABI_VFP_args].i;
12773       else if (in_attr[Tag_ABI_FP_number_model].i != AEABI_FP_number_model_none
12774                && in_attr[Tag_ABI_VFP_args].i != AEABI_VFP_args_compatible)
12775         {
12776           _bfd_error_handler
12777             (_("error: %B uses VFP register arguments, %B does not"),
12778              in_attr[Tag_ABI_VFP_args].i ? ibfd : obfd,
12779              in_attr[Tag_ABI_VFP_args].i ? obfd : ibfd);
12780           result = FALSE;
12781         }
12782     }
12783
12784   for (i = LEAST_KNOWN_OBJ_ATTRIBUTE; i < NUM_KNOWN_OBJ_ATTRIBUTES; i++)
12785     {
12786       /* Merge this attribute with existing attributes.  */
12787       switch (i)
12788         {
12789         case Tag_CPU_raw_name:
12790         case Tag_CPU_name:
12791           /* These are merged after Tag_CPU_arch.  */
12792           break;
12793
12794         case Tag_ABI_optimization_goals:
12795         case Tag_ABI_FP_optimization_goals:
12796           /* Use the first value seen.  */
12797           break;
12798
12799         case Tag_CPU_arch:
12800           {
12801             int secondary_compat = -1, secondary_compat_out = -1;
12802             unsigned int saved_out_attr = out_attr[i].i;
12803             int arch_attr;
12804             static const char *name_table[] =
12805               {
12806                 /* These aren't real CPU names, but we can't guess
12807                    that from the architecture version alone.  */
12808                 "Pre v4",
12809                 "ARM v4",
12810                 "ARM v4T",
12811                 "ARM v5T",
12812                 "ARM v5TE",
12813                 "ARM v5TEJ",
12814                 "ARM v6",
12815                 "ARM v6KZ",
12816                 "ARM v6T2",
12817                 "ARM v6K",
12818                 "ARM v7",
12819                 "ARM v6-M",
12820                 "ARM v6S-M",
12821                 "ARM v8",
12822                 "",
12823                 "ARM v8-M.baseline",
12824                 "ARM v8-M.mainline",
12825             };
12826
12827             /* Merge Tag_CPU_arch and Tag_also_compatible_with.  */
12828             secondary_compat = get_secondary_compatible_arch (ibfd);
12829             secondary_compat_out = get_secondary_compatible_arch (obfd);
12830             arch_attr = tag_cpu_arch_combine (ibfd, out_attr[i].i,
12831                                               &secondary_compat_out,
12832                                               in_attr[i].i,
12833                                               secondary_compat);
12834
12835             /* Return with error if failed to merge.  */
12836             if (arch_attr == -1)
12837               return FALSE;
12838
12839             out_attr[i].i = arch_attr;
12840
12841             set_secondary_compatible_arch (obfd, secondary_compat_out);
12842
12843             /* Merge Tag_CPU_name and Tag_CPU_raw_name.  */
12844             if (out_attr[i].i == saved_out_attr)
12845               ; /* Leave the names alone.  */
12846             else if (out_attr[i].i == in_attr[i].i)
12847               {
12848                 /* The output architecture has been changed to match the
12849                    input architecture.  Use the input names.  */
12850                 out_attr[Tag_CPU_name].s = in_attr[Tag_CPU_name].s
12851                   ? _bfd_elf_attr_strdup (obfd, in_attr[Tag_CPU_name].s)
12852                   : NULL;
12853                 out_attr[Tag_CPU_raw_name].s = in_attr[Tag_CPU_raw_name].s
12854                   ? _bfd_elf_attr_strdup (obfd, in_attr[Tag_CPU_raw_name].s)
12855                   : NULL;
12856               }
12857             else
12858               {
12859                 out_attr[Tag_CPU_name].s = NULL;
12860                 out_attr[Tag_CPU_raw_name].s = NULL;
12861               }
12862
12863             /* If we still don't have a value for Tag_CPU_name,
12864                make one up now.  Tag_CPU_raw_name remains blank.  */
12865             if (out_attr[Tag_CPU_name].s == NULL
12866                 && out_attr[i].i < ARRAY_SIZE (name_table))
12867               out_attr[Tag_CPU_name].s =
12868                 _bfd_elf_attr_strdup (obfd, name_table[out_attr[i].i]);
12869           }
12870           break;
12871
12872         case Tag_ARM_ISA_use:
12873         case Tag_THUMB_ISA_use:
12874         case Tag_WMMX_arch:
12875         case Tag_Advanced_SIMD_arch:
12876           /* ??? Do Advanced_SIMD (NEON) and WMMX conflict?  */
12877         case Tag_ABI_FP_rounding:
12878         case Tag_ABI_FP_exceptions:
12879         case Tag_ABI_FP_user_exceptions:
12880         case Tag_ABI_FP_number_model:
12881         case Tag_FP_HP_extension:
12882         case Tag_CPU_unaligned_access:
12883         case Tag_T2EE_use:
12884         case Tag_MPextension_use:
12885           /* Use the largest value specified.  */
12886           if (in_attr[i].i > out_attr[i].i)
12887             out_attr[i].i = in_attr[i].i;
12888           break;
12889
12890         case Tag_ABI_align_preserved:
12891         case Tag_ABI_PCS_RO_data:
12892           /* Use the smallest value specified.  */
12893           if (in_attr[i].i < out_attr[i].i)
12894             out_attr[i].i = in_attr[i].i;
12895           break;
12896
12897         case Tag_ABI_align_needed:
12898           if ((in_attr[i].i > 0 || out_attr[i].i > 0)
12899               && (in_attr[Tag_ABI_align_preserved].i == 0
12900                   || out_attr[Tag_ABI_align_preserved].i == 0))
12901             {
12902               /* This error message should be enabled once all non-conformant
12903                  binaries in the toolchain have had the attributes set
12904                  properly.
12905               _bfd_error_handler
12906                 (_("error: %B: 8-byte data alignment conflicts with %B"),
12907                  obfd, ibfd);
12908               result = FALSE; */
12909             }
12910           /* Fall through.  */
12911         case Tag_ABI_FP_denormal:
12912         case Tag_ABI_PCS_GOT_use:
12913           /* Use the "greatest" from the sequence 0, 2, 1, or the largest
12914              value if greater than 2 (for future-proofing).  */
12915           if ((in_attr[i].i > 2 && in_attr[i].i > out_attr[i].i)
12916               || (in_attr[i].i <= 2 && out_attr[i].i <= 2
12917                   && order_021[in_attr[i].i] > order_021[out_attr[i].i]))
12918             out_attr[i].i = in_attr[i].i;
12919           break;
12920
12921         case Tag_Virtualization_use:
12922           /* The virtualization tag effectively stores two bits of
12923              information: the intended use of TrustZone (in bit 0), and the
12924              intended use of Virtualization (in bit 1).  */
12925           if (out_attr[i].i == 0)
12926             out_attr[i].i = in_attr[i].i;
12927           else if (in_attr[i].i != 0
12928                    && in_attr[i].i != out_attr[i].i)
12929             {
12930               if (in_attr[i].i <= 3 && out_attr[i].i <= 3)
12931                 out_attr[i].i = 3;
12932               else
12933                 {
12934                   _bfd_error_handler
12935                     (_("error: %B: unable to merge virtualization attributes "
12936                        "with %B"),
12937                      obfd, ibfd);
12938                   result = FALSE;
12939                 }
12940             }
12941           break;
12942
12943         case Tag_CPU_arch_profile:
12944           if (out_attr[i].i != in_attr[i].i)
12945             {
12946               /* 0 will merge with anything.
12947                  'A' and 'S' merge to 'A'.
12948                  'R' and 'S' merge to 'R'.
12949                  'M' and 'A|R|S' is an error.  */
12950               if (out_attr[i].i == 0
12951                   || (out_attr[i].i == 'S'
12952                       && (in_attr[i].i == 'A' || in_attr[i].i == 'R')))
12953                 out_attr[i].i = in_attr[i].i;
12954               else if (in_attr[i].i == 0
12955                        || (in_attr[i].i == 'S'
12956                            && (out_attr[i].i == 'A' || out_attr[i].i == 'R')))
12957                 ; /* Do nothing.  */
12958               else
12959                 {
12960                   _bfd_error_handler
12961                     (_("error: %B: Conflicting architecture profiles %c/%c"),
12962                      ibfd,
12963                      in_attr[i].i ? in_attr[i].i : '0',
12964                      out_attr[i].i ? out_attr[i].i : '0');
12965                   result = FALSE;
12966                 }
12967             }
12968           break;
12969
12970         case Tag_DSP_extension:
12971           /* No need to change output value if any of:
12972              - pre (<=) ARMv5T input architecture (do not have DSP)
12973              - M input profile not ARMv7E-M and do not have DSP.  */
12974           if (in_attr[Tag_CPU_arch].i <= 3
12975               || (in_attr[Tag_CPU_arch_profile].i == 'M'
12976                   && in_attr[Tag_CPU_arch].i != 13
12977                   && in_attr[i].i == 0))
12978             ; /* Do nothing.  */
12979           /* Output value should be 0 if DSP part of architecture, ie.
12980              - post (>=) ARMv5te architecture output
12981              - A, R or S profile output or ARMv7E-M output architecture.  */
12982           else if (out_attr[Tag_CPU_arch].i >= 4
12983                    && (out_attr[Tag_CPU_arch_profile].i == 'A'
12984                        || out_attr[Tag_CPU_arch_profile].i == 'R'
12985                        || out_attr[Tag_CPU_arch_profile].i == 'S'
12986                        || out_attr[Tag_CPU_arch].i == 13))
12987             out_attr[i].i = 0;
12988           /* Otherwise, DSP instructions are added and not part of output
12989              architecture.  */
12990           else
12991             out_attr[i].i = 1;
12992           break;
12993
12994         case Tag_FP_arch:
12995             {
12996               /* Tag_ABI_HardFP_use is handled along with Tag_FP_arch since
12997                  the meaning of Tag_ABI_HardFP_use depends on Tag_FP_arch
12998                  when it's 0.  It might mean absence of FP hardware if
12999                  Tag_FP_arch is zero.  */
13000
13001 #define VFP_VERSION_COUNT 9
13002               static const struct
13003               {
13004                   int ver;
13005                   int regs;
13006               } vfp_versions[VFP_VERSION_COUNT] =
13007                 {
13008                   {0, 0},
13009                   {1, 16},
13010                   {2, 16},
13011                   {3, 32},
13012                   {3, 16},
13013                   {4, 32},
13014                   {4, 16},
13015                   {8, 32},
13016                   {8, 16}
13017                 };
13018               int ver;
13019               int regs;
13020               int newval;
13021
13022               /* If the output has no requirement about FP hardware,
13023                  follow the requirement of the input.  */
13024               if (out_attr[i].i == 0)
13025                 {
13026                   BFD_ASSERT (out_attr[Tag_ABI_HardFP_use].i == 0);
13027                   out_attr[i].i = in_attr[i].i;
13028                   out_attr[Tag_ABI_HardFP_use].i
13029                     = in_attr[Tag_ABI_HardFP_use].i;
13030                   break;
13031                 }
13032               /* If the input has no requirement about FP hardware, do
13033                  nothing.  */
13034               else if (in_attr[i].i == 0)
13035                 {
13036                   BFD_ASSERT (in_attr[Tag_ABI_HardFP_use].i == 0);
13037                   break;
13038                 }
13039
13040               /* Both the input and the output have nonzero Tag_FP_arch.
13041                  So Tag_ABI_HardFP_use is implied by Tag_FP_arch when it's zero.  */
13042
13043               /* If both the input and the output have zero Tag_ABI_HardFP_use,
13044                  do nothing.  */
13045               if (in_attr[Tag_ABI_HardFP_use].i == 0
13046                   && out_attr[Tag_ABI_HardFP_use].i == 0)
13047                 ;
13048               /* If the input and the output have different Tag_ABI_HardFP_use,
13049                  the combination of them is 0 (implied by Tag_FP_arch).  */
13050               else if (in_attr[Tag_ABI_HardFP_use].i
13051                        != out_attr[Tag_ABI_HardFP_use].i)
13052                 out_attr[Tag_ABI_HardFP_use].i = 0;
13053
13054               /* Now we can handle Tag_FP_arch.  */
13055
13056               /* Values of VFP_VERSION_COUNT or more aren't defined, so just
13057                  pick the biggest.  */
13058               if (in_attr[i].i >= VFP_VERSION_COUNT
13059                   && in_attr[i].i > out_attr[i].i)
13060                 {
13061                   out_attr[i] = in_attr[i];
13062                   break;
13063                 }
13064               /* The output uses the superset of input features
13065                  (ISA version) and registers.  */
13066               ver = vfp_versions[in_attr[i].i].ver;
13067               if (ver < vfp_versions[out_attr[i].i].ver)
13068                 ver = vfp_versions[out_attr[i].i].ver;
13069               regs = vfp_versions[in_attr[i].i].regs;
13070               if (regs < vfp_versions[out_attr[i].i].regs)
13071                 regs = vfp_versions[out_attr[i].i].regs;
13072               /* This assumes all possible supersets are also a valid
13073                  options.  */
13074               for (newval = VFP_VERSION_COUNT - 1; newval > 0; newval--)
13075                 {
13076                   if (regs == vfp_versions[newval].regs
13077                       && ver == vfp_versions[newval].ver)
13078                     break;
13079                 }
13080               out_attr[i].i = newval;
13081             }
13082           break;
13083         case Tag_PCS_config:
13084           if (out_attr[i].i == 0)
13085             out_attr[i].i = in_attr[i].i;
13086           else if (in_attr[i].i != 0 && out_attr[i].i != in_attr[i].i)
13087             {
13088               /* It's sometimes ok to mix different configs, so this is only
13089                  a warning.  */
13090               _bfd_error_handler
13091                 (_("Warning: %B: Conflicting platform configuration"), ibfd);
13092             }
13093           break;
13094         case Tag_ABI_PCS_R9_use:
13095           if (in_attr[i].i != out_attr[i].i
13096               && out_attr[i].i != AEABI_R9_unused
13097               && in_attr[i].i != AEABI_R9_unused)
13098             {
13099               _bfd_error_handler
13100                 (_("error: %B: Conflicting use of R9"), ibfd);
13101               result = FALSE;
13102             }
13103           if (out_attr[i].i == AEABI_R9_unused)
13104             out_attr[i].i = in_attr[i].i;
13105           break;
13106         case Tag_ABI_PCS_RW_data:
13107           if (in_attr[i].i == AEABI_PCS_RW_data_SBrel
13108               && out_attr[Tag_ABI_PCS_R9_use].i != AEABI_R9_SB
13109               && out_attr[Tag_ABI_PCS_R9_use].i != AEABI_R9_unused)
13110             {
13111               _bfd_error_handler
13112                 (_("error: %B: SB relative addressing conflicts with use of R9"),
13113                  ibfd);
13114               result = FALSE;
13115             }
13116           /* Use the smallest value specified.  */
13117           if (in_attr[i].i < out_attr[i].i)
13118             out_attr[i].i = in_attr[i].i;
13119           break;
13120         case Tag_ABI_PCS_wchar_t:
13121           if (out_attr[i].i && in_attr[i].i && out_attr[i].i != in_attr[i].i
13122               && !elf_arm_tdata (obfd)->no_wchar_size_warning)
13123             {
13124               _bfd_error_handler
13125                 (_("warning: %B uses %u-byte wchar_t yet the output is to use %u-byte wchar_t; use of wchar_t values across objects may fail"),
13126                  ibfd, in_attr[i].i, out_attr[i].i);
13127             }
13128           else if (in_attr[i].i && !out_attr[i].i)
13129             out_attr[i].i = in_attr[i].i;
13130           break;
13131         case Tag_ABI_enum_size:
13132           if (in_attr[i].i != AEABI_enum_unused)
13133             {
13134               if (out_attr[i].i == AEABI_enum_unused
13135                   || out_attr[i].i == AEABI_enum_forced_wide)
13136                 {
13137                   /* The existing object is compatible with anything.
13138                      Use whatever requirements the new object has.  */
13139                   out_attr[i].i = in_attr[i].i;
13140                 }
13141               else if (in_attr[i].i != AEABI_enum_forced_wide
13142                        && out_attr[i].i != in_attr[i].i
13143                        && !elf_arm_tdata (obfd)->no_enum_size_warning)
13144                 {
13145                   static const char *aeabi_enum_names[] =
13146                     { "", "variable-size", "32-bit", "" };
13147                   const char *in_name =
13148                     in_attr[i].i < ARRAY_SIZE(aeabi_enum_names)
13149                     ? aeabi_enum_names[in_attr[i].i]
13150                     : "<unknown>";
13151                   const char *out_name =
13152                     out_attr[i].i < ARRAY_SIZE(aeabi_enum_names)
13153                     ? aeabi_enum_names[out_attr[i].i]
13154                     : "<unknown>";
13155                   _bfd_error_handler
13156                     (_("warning: %B uses %s enums yet the output is to use %s enums; use of enum values across objects may fail"),
13157                      ibfd, in_name, out_name);
13158                 }
13159             }
13160           break;
13161         case Tag_ABI_VFP_args:
13162           /* Aready done.  */
13163           break;
13164         case Tag_ABI_WMMX_args:
13165           if (in_attr[i].i != out_attr[i].i)
13166             {
13167               _bfd_error_handler
13168                 (_("error: %B uses iWMMXt register arguments, %B does not"),
13169                  ibfd, obfd);
13170               result = FALSE;
13171             }
13172           break;
13173         case Tag_compatibility:
13174           /* Merged in target-independent code.  */
13175           break;
13176         case Tag_ABI_HardFP_use:
13177           /* This is handled along with Tag_FP_arch.  */
13178           break;
13179         case Tag_ABI_FP_16bit_format:
13180           if (in_attr[i].i != 0 && out_attr[i].i != 0)
13181             {
13182               if (in_attr[i].i != out_attr[i].i)
13183                 {
13184                   _bfd_error_handler
13185                     (_("error: fp16 format mismatch between %B and %B"),
13186                      ibfd, obfd);
13187                   result = FALSE;
13188                 }
13189             }
13190           if (in_attr[i].i != 0)
13191             out_attr[i].i = in_attr[i].i;
13192           break;
13193
13194         case Tag_DIV_use:
13195           /* A value of zero on input means that the divide instruction may
13196              be used if available in the base architecture as specified via
13197              Tag_CPU_arch and Tag_CPU_arch_profile.  A value of 1 means that
13198              the user did not want divide instructions.  A value of 2
13199              explicitly means that divide instructions were allowed in ARM
13200              and Thumb state.  */
13201           if (in_attr[i].i == out_attr[i].i)
13202             /* Do nothing.  */ ;
13203           else if (elf32_arm_attributes_forbid_div (in_attr)
13204                    && !elf32_arm_attributes_accept_div (out_attr))
13205             out_attr[i].i = 1;
13206           else if (elf32_arm_attributes_forbid_div (out_attr)
13207                    && elf32_arm_attributes_accept_div (in_attr))
13208             out_attr[i].i = in_attr[i].i;
13209           else if (in_attr[i].i == 2)
13210             out_attr[i].i = in_attr[i].i;
13211           break;
13212
13213         case Tag_MPextension_use_legacy:
13214           /* We don't output objects with Tag_MPextension_use_legacy - we
13215              move the value to Tag_MPextension_use.  */
13216           if (in_attr[i].i != 0 && in_attr[Tag_MPextension_use].i != 0)
13217             {
13218               if (in_attr[Tag_MPextension_use].i != in_attr[i].i)
13219                 {
13220                   _bfd_error_handler
13221                     (_("%B has has both the current and legacy "
13222                        "Tag_MPextension_use attributes"),
13223                      ibfd);
13224                   result = FALSE;
13225                 }
13226             }
13227
13228           if (in_attr[i].i > out_attr[Tag_MPextension_use].i)
13229             out_attr[Tag_MPextension_use] = in_attr[i];
13230
13231           break;
13232
13233         case Tag_nodefaults:
13234           /* This tag is set if it exists, but the value is unused (and is
13235              typically zero).  We don't actually need to do anything here -
13236              the merge happens automatically when the type flags are merged
13237              below.  */
13238           break;
13239         case Tag_also_compatible_with:
13240           /* Already done in Tag_CPU_arch.  */
13241           break;
13242         case Tag_conformance:
13243           /* Keep the attribute if it matches.  Throw it away otherwise.
13244              No attribute means no claim to conform.  */
13245           if (!in_attr[i].s || !out_attr[i].s
13246               || strcmp (in_attr[i].s, out_attr[i].s) != 0)
13247             out_attr[i].s = NULL;
13248           break;
13249
13250         default:
13251           result
13252             = result && _bfd_elf_merge_unknown_attribute_low (ibfd, obfd, i);
13253         }
13254
13255       /* If out_attr was copied from in_attr then it won't have a type yet.  */
13256       if (in_attr[i].type && !out_attr[i].type)
13257         out_attr[i].type = in_attr[i].type;
13258     }
13259
13260   /* Merge Tag_compatibility attributes and any common GNU ones.  */
13261   if (!_bfd_elf_merge_object_attributes (ibfd, obfd))
13262     return FALSE;
13263
13264   /* Check for any attributes not known on ARM.  */
13265   result &= _bfd_elf_merge_unknown_attribute_list (ibfd, obfd);
13266
13267   return result;
13268 }
13269
13270
13271 /* Return TRUE if the two EABI versions are incompatible.  */
13272
13273 static bfd_boolean
13274 elf32_arm_versions_compatible (unsigned iver, unsigned over)
13275 {
13276   /* v4 and v5 are the same spec before and after it was released,
13277      so allow mixing them.  */
13278   if ((iver == EF_ARM_EABI_VER4 && over == EF_ARM_EABI_VER5)
13279       || (iver == EF_ARM_EABI_VER5 && over == EF_ARM_EABI_VER4))
13280     return TRUE;
13281
13282   return (iver == over);
13283 }
13284
13285 /* Merge backend specific data from an object file to the output
13286    object file when linking.  */
13287
13288 static bfd_boolean
13289 elf32_arm_merge_private_bfd_data (bfd * ibfd, bfd * obfd);
13290
13291 /* Display the flags field.  */
13292
13293 static bfd_boolean
13294 elf32_arm_print_private_bfd_data (bfd *abfd, void * ptr)
13295 {
13296   FILE * file = (FILE *) ptr;
13297   unsigned long flags;
13298
13299   BFD_ASSERT (abfd != NULL && ptr != NULL);
13300
13301   /* Print normal ELF private data.  */
13302   _bfd_elf_print_private_bfd_data (abfd, ptr);
13303
13304   flags = elf_elfheader (abfd)->e_flags;
13305   /* Ignore init flag - it may not be set, despite the flags field
13306      containing valid data.  */
13307
13308   /* xgettext:c-format */
13309   fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
13310
13311   switch (EF_ARM_EABI_VERSION (flags))
13312     {
13313     case EF_ARM_EABI_UNKNOWN:
13314       /* The following flag bits are GNU extensions and not part of the
13315          official ARM ELF extended ABI.  Hence they are only decoded if
13316          the EABI version is not set.  */
13317       if (flags & EF_ARM_INTERWORK)
13318         fprintf (file, _(" [interworking enabled]"));
13319
13320       if (flags & EF_ARM_APCS_26)
13321         fprintf (file, " [APCS-26]");
13322       else
13323         fprintf (file, " [APCS-32]");
13324
13325       if (flags & EF_ARM_VFP_FLOAT)
13326         fprintf (file, _(" [VFP float format]"));
13327       else if (flags & EF_ARM_MAVERICK_FLOAT)
13328         fprintf (file, _(" [Maverick float format]"));
13329       else
13330         fprintf (file, _(" [FPA float format]"));
13331
13332       if (flags & EF_ARM_APCS_FLOAT)
13333         fprintf (file, _(" [floats passed in float registers]"));
13334
13335       if (flags & EF_ARM_PIC)
13336         fprintf (file, _(" [position independent]"));
13337
13338       if (flags & EF_ARM_NEW_ABI)
13339         fprintf (file, _(" [new ABI]"));
13340
13341       if (flags & EF_ARM_OLD_ABI)
13342         fprintf (file, _(" [old ABI]"));
13343
13344       if (flags & EF_ARM_SOFT_FLOAT)
13345         fprintf (file, _(" [software FP]"));
13346
13347       flags &= ~(EF_ARM_INTERWORK | EF_ARM_APCS_26 | EF_ARM_APCS_FLOAT
13348                  | EF_ARM_PIC | EF_ARM_NEW_ABI | EF_ARM_OLD_ABI
13349                  | EF_ARM_SOFT_FLOAT | EF_ARM_VFP_FLOAT
13350                  | EF_ARM_MAVERICK_FLOAT);
13351       break;
13352
13353     case EF_ARM_EABI_VER1:
13354       fprintf (file, _(" [Version1 EABI]"));
13355
13356       if (flags & EF_ARM_SYMSARESORTED)
13357         fprintf (file, _(" [sorted symbol table]"));
13358       else
13359         fprintf (file, _(" [unsorted symbol table]"));
13360
13361       flags &= ~ EF_ARM_SYMSARESORTED;
13362       break;
13363
13364     case EF_ARM_EABI_VER2:
13365       fprintf (file, _(" [Version2 EABI]"));
13366
13367       if (flags & EF_ARM_SYMSARESORTED)
13368         fprintf (file, _(" [sorted symbol table]"));
13369       else
13370         fprintf (file, _(" [unsorted symbol table]"));
13371
13372       if (flags & EF_ARM_DYNSYMSUSESEGIDX)
13373         fprintf (file, _(" [dynamic symbols use segment index]"));
13374
13375       if (flags & EF_ARM_MAPSYMSFIRST)
13376         fprintf (file, _(" [mapping symbols precede others]"));
13377
13378       flags &= ~(EF_ARM_SYMSARESORTED | EF_ARM_DYNSYMSUSESEGIDX
13379                  | EF_ARM_MAPSYMSFIRST);
13380       break;
13381
13382     case EF_ARM_EABI_VER3:
13383       fprintf (file, _(" [Version3 EABI]"));
13384       break;
13385
13386     case EF_ARM_EABI_VER4:
13387       fprintf (file, _(" [Version4 EABI]"));
13388       goto eabi;
13389
13390     case EF_ARM_EABI_VER5:
13391       fprintf (file, _(" [Version5 EABI]"));
13392
13393       if (flags & EF_ARM_ABI_FLOAT_SOFT)
13394         fprintf (file, _(" [soft-float ABI]"));
13395
13396       if (flags & EF_ARM_ABI_FLOAT_HARD)
13397         fprintf (file, _(" [hard-float ABI]"));
13398
13399       flags &= ~(EF_ARM_ABI_FLOAT_SOFT | EF_ARM_ABI_FLOAT_HARD);
13400
13401     eabi:
13402       if (flags & EF_ARM_BE8)
13403         fprintf (file, _(" [BE8]"));
13404
13405       if (flags & EF_ARM_LE8)
13406         fprintf (file, _(" [LE8]"));
13407
13408       flags &= ~(EF_ARM_LE8 | EF_ARM_BE8);
13409       break;
13410
13411     default:
13412       fprintf (file, _(" <EABI version unrecognised>"));
13413       break;
13414     }
13415
13416   flags &= ~ EF_ARM_EABIMASK;
13417
13418   if (flags & EF_ARM_RELEXEC)
13419     fprintf (file, _(" [relocatable executable]"));
13420
13421   flags &= ~EF_ARM_RELEXEC;
13422
13423   if (flags)
13424     fprintf (file, _("<Unrecognised flag bits set>"));
13425
13426   fputc ('\n', file);
13427
13428   return TRUE;
13429 }
13430
13431 static int
13432 elf32_arm_get_symbol_type (Elf_Internal_Sym * elf_sym, int type)
13433 {
13434   switch (ELF_ST_TYPE (elf_sym->st_info))
13435     {
13436     case STT_ARM_TFUNC:
13437       return ELF_ST_TYPE (elf_sym->st_info);
13438
13439     case STT_ARM_16BIT:
13440       /* If the symbol is not an object, return the STT_ARM_16BIT flag.
13441          This allows us to distinguish between data used by Thumb instructions
13442          and non-data (which is probably code) inside Thumb regions of an
13443          executable.  */
13444       if (type != STT_OBJECT && type != STT_TLS)
13445         return ELF_ST_TYPE (elf_sym->st_info);
13446       break;
13447
13448     default:
13449       break;
13450     }
13451
13452   return type;
13453 }
13454
13455 static asection *
13456 elf32_arm_gc_mark_hook (asection *sec,
13457                         struct bfd_link_info *info,
13458                         Elf_Internal_Rela *rel,
13459                         struct elf_link_hash_entry *h,
13460                         Elf_Internal_Sym *sym)
13461 {
13462   if (h != NULL)
13463     switch (ELF32_R_TYPE (rel->r_info))
13464       {
13465       case R_ARM_GNU_VTINHERIT:
13466       case R_ARM_GNU_VTENTRY:
13467         return NULL;
13468       }
13469
13470   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
13471 }
13472
13473 /* Update the got entry reference counts for the section being removed.  */
13474
13475 static bfd_boolean
13476 elf32_arm_gc_sweep_hook (bfd *                     abfd,
13477                          struct bfd_link_info *    info,
13478                          asection *                sec,
13479                          const Elf_Internal_Rela * relocs)
13480 {
13481   Elf_Internal_Shdr *symtab_hdr;
13482   struct elf_link_hash_entry **sym_hashes;
13483   bfd_signed_vma *local_got_refcounts;
13484   const Elf_Internal_Rela *rel, *relend;
13485   struct elf32_arm_link_hash_table * globals;
13486
13487   if (bfd_link_relocatable (info))
13488     return TRUE;
13489
13490   globals = elf32_arm_hash_table (info);
13491   if (globals == NULL)
13492     return FALSE;
13493
13494   elf_section_data (sec)->local_dynrel = NULL;
13495
13496   symtab_hdr = & elf_symtab_hdr (abfd);
13497   sym_hashes = elf_sym_hashes (abfd);
13498   local_got_refcounts = elf_local_got_refcounts (abfd);
13499
13500   check_use_blx (globals);
13501
13502   relend = relocs + sec->reloc_count;
13503   for (rel = relocs; rel < relend; rel++)
13504     {
13505       unsigned long r_symndx;
13506       struct elf_link_hash_entry *h = NULL;
13507       struct elf32_arm_link_hash_entry *eh;
13508       int r_type;
13509       bfd_boolean call_reloc_p;
13510       bfd_boolean may_become_dynamic_p;
13511       bfd_boolean may_need_local_target_p;
13512       union gotplt_union *root_plt;
13513       struct arm_plt_info *arm_plt;
13514
13515       r_symndx = ELF32_R_SYM (rel->r_info);
13516       if (r_symndx >= symtab_hdr->sh_info)
13517         {
13518           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
13519           while (h->root.type == bfd_link_hash_indirect
13520                  || h->root.type == bfd_link_hash_warning)
13521             h = (struct elf_link_hash_entry *) h->root.u.i.link;
13522         }
13523       eh = (struct elf32_arm_link_hash_entry *) h;
13524
13525       call_reloc_p = FALSE;
13526       may_become_dynamic_p = FALSE;
13527       may_need_local_target_p = FALSE;
13528
13529       r_type = ELF32_R_TYPE (rel->r_info);
13530       r_type = arm_real_reloc_type (globals, r_type);
13531       switch (r_type)
13532         {
13533         case R_ARM_GOT32:
13534         case R_ARM_GOT_PREL:
13535         case R_ARM_TLS_GD32:
13536         case R_ARM_TLS_IE32:
13537           if (h != NULL)
13538             {
13539               if (h->got.refcount > 0)
13540                 h->got.refcount -= 1;
13541             }
13542           else if (local_got_refcounts != NULL)
13543             {
13544               if (local_got_refcounts[r_symndx] > 0)
13545                 local_got_refcounts[r_symndx] -= 1;
13546             }
13547           break;
13548
13549         case R_ARM_TLS_LDM32:
13550           globals->tls_ldm_got.refcount -= 1;
13551           break;
13552
13553         case R_ARM_PC24:
13554         case R_ARM_PLT32:
13555         case R_ARM_CALL:
13556         case R_ARM_JUMP24:
13557         case R_ARM_PREL31:
13558         case R_ARM_THM_CALL:
13559         case R_ARM_THM_JUMP24:
13560         case R_ARM_THM_JUMP19:
13561           call_reloc_p = TRUE;
13562           may_need_local_target_p = TRUE;
13563           break;
13564
13565         case R_ARM_ABS12:
13566           if (!globals->vxworks_p)
13567             {
13568               may_need_local_target_p = TRUE;
13569               break;
13570             }
13571           /* Fall through.  */
13572         case R_ARM_ABS32:
13573         case R_ARM_ABS32_NOI:
13574         case R_ARM_REL32:
13575         case R_ARM_REL32_NOI:
13576         case R_ARM_MOVW_ABS_NC:
13577         case R_ARM_MOVT_ABS:
13578         case R_ARM_MOVW_PREL_NC:
13579         case R_ARM_MOVT_PREL:
13580         case R_ARM_THM_MOVW_ABS_NC:
13581         case R_ARM_THM_MOVT_ABS:
13582         case R_ARM_THM_MOVW_PREL_NC:
13583         case R_ARM_THM_MOVT_PREL:
13584           /* Should the interworking branches be here also?  */
13585           if ((bfd_link_pic (info) || globals->root.is_relocatable_executable)
13586               && (sec->flags & SEC_ALLOC) != 0)
13587             {
13588               if (h == NULL
13589                   && elf32_arm_howto_from_type (r_type)->pc_relative)
13590                 {
13591                   call_reloc_p = TRUE;
13592                   may_need_local_target_p = TRUE;
13593                 }
13594               else
13595                 may_become_dynamic_p = TRUE;
13596             }
13597           else
13598             may_need_local_target_p = TRUE;
13599           break;
13600
13601         default:
13602           break;
13603         }
13604
13605       if (may_need_local_target_p
13606           && elf32_arm_get_plt_info (abfd, eh, r_symndx, &root_plt, &arm_plt))
13607         {
13608           /* If PLT refcount book-keeping is wrong and too low, we'll
13609              see a zero value (going to -1) for the root PLT reference
13610              count.  */
13611           if (root_plt->refcount >= 0)
13612             {
13613               BFD_ASSERT (root_plt->refcount != 0);
13614               root_plt->refcount -= 1;
13615             }
13616           else
13617             /* A value of -1 means the symbol has become local, forced
13618                or seeing a hidden definition.  Any other negative value
13619                is an error.  */
13620             BFD_ASSERT (root_plt->refcount == -1);
13621
13622           if (!call_reloc_p)
13623             arm_plt->noncall_refcount--;
13624
13625           if (r_type == R_ARM_THM_CALL)
13626             arm_plt->maybe_thumb_refcount--;
13627
13628           if (r_type == R_ARM_THM_JUMP24
13629               || r_type == R_ARM_THM_JUMP19)
13630             arm_plt->thumb_refcount--;
13631         }
13632
13633       if (may_become_dynamic_p)
13634         {
13635           struct elf_dyn_relocs **pp;
13636           struct elf_dyn_relocs *p;
13637
13638           if (h != NULL)
13639             pp = &(eh->dyn_relocs);
13640           else
13641             {
13642               Elf_Internal_Sym *isym;
13643
13644               isym = bfd_sym_from_r_symndx (&globals->sym_cache,
13645                                             abfd, r_symndx);
13646               if (isym == NULL)
13647                 return FALSE;
13648               pp = elf32_arm_get_local_dynreloc_list (abfd, r_symndx, isym);
13649               if (pp == NULL)
13650                 return FALSE;
13651             }
13652           for (; (p = *pp) != NULL; pp = &p->next)
13653             if (p->sec == sec)
13654               {
13655                 /* Everything must go for SEC.  */
13656                 *pp = p->next;
13657                 break;
13658               }
13659         }
13660     }
13661
13662   return TRUE;
13663 }
13664
13665 /* Look through the relocs for a section during the first phase.  */
13666
13667 static bfd_boolean
13668 elf32_arm_check_relocs (bfd *abfd, struct bfd_link_info *info,
13669                         asection *sec, const Elf_Internal_Rela *relocs)
13670 {
13671   Elf_Internal_Shdr *symtab_hdr;
13672   struct elf_link_hash_entry **sym_hashes;
13673   const Elf_Internal_Rela *rel;
13674   const Elf_Internal_Rela *rel_end;
13675   bfd *dynobj;
13676   asection *sreloc;
13677   struct elf32_arm_link_hash_table *htab;
13678   bfd_boolean call_reloc_p;
13679   bfd_boolean may_become_dynamic_p;
13680   bfd_boolean may_need_local_target_p;
13681   unsigned long nsyms;
13682
13683   if (bfd_link_relocatable (info))
13684     return TRUE;
13685
13686   BFD_ASSERT (is_arm_elf (abfd));
13687
13688   htab = elf32_arm_hash_table (info);
13689   if (htab == NULL)
13690     return FALSE;
13691
13692   sreloc = NULL;
13693
13694   /* Create dynamic sections for relocatable executables so that we can
13695      copy relocations.  */
13696   if (htab->root.is_relocatable_executable
13697       && ! htab->root.dynamic_sections_created)
13698     {
13699       if (! _bfd_elf_link_create_dynamic_sections (abfd, info))
13700         return FALSE;
13701     }
13702
13703   if (htab->root.dynobj == NULL)
13704     htab->root.dynobj = abfd;
13705   if (!create_ifunc_sections (info))
13706     return FALSE;
13707
13708   dynobj = htab->root.dynobj;
13709
13710   symtab_hdr = & elf_symtab_hdr (abfd);
13711   sym_hashes = elf_sym_hashes (abfd);
13712   nsyms = NUM_SHDR_ENTRIES (symtab_hdr);
13713
13714   rel_end = relocs + sec->reloc_count;
13715   for (rel = relocs; rel < rel_end; rel++)
13716     {
13717       Elf_Internal_Sym *isym;
13718       struct elf_link_hash_entry *h;
13719       struct elf32_arm_link_hash_entry *eh;
13720       unsigned long r_symndx;
13721       int r_type;
13722
13723       r_symndx = ELF32_R_SYM (rel->r_info);
13724       r_type = ELF32_R_TYPE (rel->r_info);
13725       r_type = arm_real_reloc_type (htab, r_type);
13726
13727       if (r_symndx >= nsyms
13728           /* PR 9934: It is possible to have relocations that do not
13729              refer to symbols, thus it is also possible to have an
13730              object file containing relocations but no symbol table.  */
13731           && (r_symndx > STN_UNDEF || nsyms > 0))
13732         {
13733           (*_bfd_error_handler) (_("%B: bad symbol index: %d"), abfd,
13734                                    r_symndx);
13735           return FALSE;
13736         }
13737
13738       h = NULL;
13739       isym = NULL;
13740       if (nsyms > 0)
13741         {
13742           if (r_symndx < symtab_hdr->sh_info)
13743             {
13744               /* A local symbol.  */
13745               isym = bfd_sym_from_r_symndx (&htab->sym_cache,
13746                                             abfd, r_symndx);
13747               if (isym == NULL)
13748                 return FALSE;
13749             }
13750           else
13751             {
13752               h = sym_hashes[r_symndx - symtab_hdr->sh_info];
13753               while (h->root.type == bfd_link_hash_indirect
13754                      || h->root.type == bfd_link_hash_warning)
13755                 h = (struct elf_link_hash_entry *) h->root.u.i.link;
13756
13757               /* PR15323, ref flags aren't set for references in the
13758                  same object.  */
13759               h->root.non_ir_ref = 1;
13760             }
13761         }
13762
13763       eh = (struct elf32_arm_link_hash_entry *) h;
13764
13765       call_reloc_p = FALSE;
13766       may_become_dynamic_p = FALSE;
13767       may_need_local_target_p = FALSE;
13768
13769       /* Could be done earlier, if h were already available.  */
13770       r_type = elf32_arm_tls_transition (info, r_type, h);
13771       switch (r_type)
13772         {
13773           case R_ARM_GOT32:
13774           case R_ARM_GOT_PREL:
13775           case R_ARM_TLS_GD32:
13776           case R_ARM_TLS_IE32:
13777           case R_ARM_TLS_GOTDESC:
13778           case R_ARM_TLS_DESCSEQ:
13779           case R_ARM_THM_TLS_DESCSEQ:
13780           case R_ARM_TLS_CALL:
13781           case R_ARM_THM_TLS_CALL:
13782             /* This symbol requires a global offset table entry.  */
13783             {
13784               int tls_type, old_tls_type;
13785
13786               switch (r_type)
13787                 {
13788                 case R_ARM_TLS_GD32: tls_type = GOT_TLS_GD; break;
13789
13790                 case R_ARM_TLS_IE32: tls_type = GOT_TLS_IE; break;
13791
13792                 case R_ARM_TLS_GOTDESC:
13793                 case R_ARM_TLS_CALL: case R_ARM_THM_TLS_CALL:
13794                 case R_ARM_TLS_DESCSEQ: case R_ARM_THM_TLS_DESCSEQ:
13795                   tls_type = GOT_TLS_GDESC; break;
13796
13797                 default: tls_type = GOT_NORMAL; break;
13798                 }
13799
13800               if (!bfd_link_executable (info) && (tls_type & GOT_TLS_IE))
13801                 info->flags |= DF_STATIC_TLS;
13802
13803               if (h != NULL)
13804                 {
13805                   h->got.refcount++;
13806                   old_tls_type = elf32_arm_hash_entry (h)->tls_type;
13807                 }
13808               else
13809                 {
13810                   /* This is a global offset table entry for a local symbol.  */
13811                   if (!elf32_arm_allocate_local_sym_info (abfd))
13812                     return FALSE;
13813                   elf_local_got_refcounts (abfd)[r_symndx] += 1;
13814                   old_tls_type = elf32_arm_local_got_tls_type (abfd) [r_symndx];
13815                 }
13816
13817               /* If a variable is accessed with both tls methods, two
13818                  slots may be created.  */
13819               if (GOT_TLS_GD_ANY_P (old_tls_type)
13820                   && GOT_TLS_GD_ANY_P (tls_type))
13821                 tls_type |= old_tls_type;
13822
13823               /* We will already have issued an error message if there
13824                  is a TLS/non-TLS mismatch, based on the symbol
13825                  type.  So just combine any TLS types needed.  */
13826               if (old_tls_type != GOT_UNKNOWN && old_tls_type != GOT_NORMAL
13827                   && tls_type != GOT_NORMAL)
13828                 tls_type |= old_tls_type;
13829
13830               /* If the symbol is accessed in both IE and GDESC
13831                  method, we're able to relax. Turn off the GDESC flag,
13832                  without messing up with any other kind of tls types
13833                  that may be involved.  */
13834               if ((tls_type & GOT_TLS_IE) && (tls_type & GOT_TLS_GDESC))
13835                 tls_type &= ~GOT_TLS_GDESC;
13836
13837               if (old_tls_type != tls_type)
13838                 {
13839                   if (h != NULL)
13840                     elf32_arm_hash_entry (h)->tls_type = tls_type;
13841                   else
13842                     elf32_arm_local_got_tls_type (abfd) [r_symndx] = tls_type;
13843                 }
13844             }
13845             /* Fall through.  */
13846
13847           case R_ARM_TLS_LDM32:
13848             if (r_type == R_ARM_TLS_LDM32)
13849                 htab->tls_ldm_got.refcount++;
13850             /* Fall through.  */
13851
13852           case R_ARM_GOTOFF32:
13853           case R_ARM_GOTPC:
13854             if (htab->root.sgot == NULL
13855                 && !create_got_section (htab->root.dynobj, info))
13856               return FALSE;
13857             break;
13858
13859           case R_ARM_PC24:
13860           case R_ARM_PLT32:
13861           case R_ARM_CALL:
13862           case R_ARM_JUMP24:
13863           case R_ARM_PREL31:
13864           case R_ARM_THM_CALL:
13865           case R_ARM_THM_JUMP24:
13866           case R_ARM_THM_JUMP19:
13867             call_reloc_p = TRUE;
13868             may_need_local_target_p = TRUE;
13869             break;
13870
13871           case R_ARM_ABS12:
13872             /* VxWorks uses dynamic R_ARM_ABS12 relocations for
13873                ldr __GOTT_INDEX__ offsets.  */
13874             if (!htab->vxworks_p)
13875               {
13876                 may_need_local_target_p = TRUE;
13877                 break;
13878               }
13879             else goto jump_over;
13880
13881             /* Fall through.  */
13882
13883           case R_ARM_MOVW_ABS_NC:
13884           case R_ARM_MOVT_ABS:
13885           case R_ARM_THM_MOVW_ABS_NC:
13886           case R_ARM_THM_MOVT_ABS:
13887             if (bfd_link_pic (info))
13888               {
13889                 (*_bfd_error_handler)
13890                   (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
13891                    abfd, elf32_arm_howto_table_1[r_type].name,
13892                    (h) ? h->root.root.string : "a local symbol");
13893                 bfd_set_error (bfd_error_bad_value);
13894                 return FALSE;
13895               }
13896
13897             /* Fall through.  */
13898           case R_ARM_ABS32:
13899           case R_ARM_ABS32_NOI:
13900         jump_over:
13901             if (h != NULL && bfd_link_executable (info))
13902               {
13903                 h->pointer_equality_needed = 1;
13904               }
13905             /* Fall through.  */
13906           case R_ARM_REL32:
13907           case R_ARM_REL32_NOI:
13908           case R_ARM_MOVW_PREL_NC:
13909           case R_ARM_MOVT_PREL:
13910           case R_ARM_THM_MOVW_PREL_NC:
13911           case R_ARM_THM_MOVT_PREL:
13912
13913             /* Should the interworking branches be listed here?  */
13914             if ((bfd_link_pic (info) || htab->root.is_relocatable_executable)
13915                 && (sec->flags & SEC_ALLOC) != 0)
13916               {
13917                 if (h == NULL
13918                     && elf32_arm_howto_from_type (r_type)->pc_relative)
13919                   {
13920                     /* In shared libraries and relocatable executables,
13921                        we treat local relative references as calls;
13922                        see the related SYMBOL_CALLS_LOCAL code in
13923                        allocate_dynrelocs.  */
13924                     call_reloc_p = TRUE;
13925                     may_need_local_target_p = TRUE;
13926                   }
13927                 else
13928                   /* We are creating a shared library or relocatable
13929                      executable, and this is a reloc against a global symbol,
13930                      or a non-PC-relative reloc against a local symbol.
13931                      We may need to copy the reloc into the output.  */
13932                   may_become_dynamic_p = TRUE;
13933               }
13934             else
13935               may_need_local_target_p = TRUE;
13936             break;
13937
13938         /* This relocation describes the C++ object vtable hierarchy.
13939            Reconstruct it for later use during GC.  */
13940         case R_ARM_GNU_VTINHERIT:
13941           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
13942             return FALSE;
13943           break;
13944
13945         /* This relocation describes which C++ vtable entries are actually
13946            used.  Record for later use during GC.  */
13947         case R_ARM_GNU_VTENTRY:
13948           BFD_ASSERT (h != NULL);
13949           if (h != NULL
13950               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
13951             return FALSE;
13952           break;
13953         }
13954
13955       if (h != NULL)
13956         {
13957           if (call_reloc_p)
13958             /* We may need a .plt entry if the function this reloc
13959                refers to is in a different object, regardless of the
13960                symbol's type.  We can't tell for sure yet, because
13961                something later might force the symbol local.  */
13962             h->needs_plt = 1;
13963           else if (may_need_local_target_p)
13964             /* If this reloc is in a read-only section, we might
13965                need a copy reloc.  We can't check reliably at this
13966                stage whether the section is read-only, as input
13967                sections have not yet been mapped to output sections.
13968                Tentatively set the flag for now, and correct in
13969                adjust_dynamic_symbol.  */
13970             h->non_got_ref = 1;
13971         }
13972
13973       if (may_need_local_target_p
13974           && (h != NULL || ELF32_ST_TYPE (isym->st_info) == STT_GNU_IFUNC))
13975         {
13976           union gotplt_union *root_plt;
13977           struct arm_plt_info *arm_plt;
13978           struct arm_local_iplt_info *local_iplt;
13979
13980           if (h != NULL)
13981             {
13982               root_plt = &h->plt;
13983               arm_plt = &eh->plt;
13984             }
13985           else
13986             {
13987               local_iplt = elf32_arm_create_local_iplt (abfd, r_symndx);
13988               if (local_iplt == NULL)
13989                 return FALSE;
13990               root_plt = &local_iplt->root;
13991               arm_plt = &local_iplt->arm;
13992             }
13993
13994           /* If the symbol is a function that doesn't bind locally,
13995              this relocation will need a PLT entry.  */
13996           if (root_plt->refcount != -1)
13997             root_plt->refcount += 1;
13998
13999           if (!call_reloc_p)
14000             arm_plt->noncall_refcount++;
14001
14002           /* It's too early to use htab->use_blx here, so we have to
14003              record possible blx references separately from
14004              relocs that definitely need a thumb stub.  */
14005
14006           if (r_type == R_ARM_THM_CALL)
14007             arm_plt->maybe_thumb_refcount += 1;
14008
14009           if (r_type == R_ARM_THM_JUMP24
14010               || r_type == R_ARM_THM_JUMP19)
14011             arm_plt->thumb_refcount += 1;
14012         }
14013
14014       if (may_become_dynamic_p)
14015         {
14016           struct elf_dyn_relocs *p, **head;
14017
14018           /* Create a reloc section in dynobj.  */
14019           if (sreloc == NULL)
14020             {
14021               sreloc = _bfd_elf_make_dynamic_reloc_section
14022                 (sec, dynobj, 2, abfd, ! htab->use_rel);
14023
14024               if (sreloc == NULL)
14025                 return FALSE;
14026
14027               /* BPABI objects never have dynamic relocations mapped.  */
14028               if (htab->symbian_p)
14029                 {
14030                   flagword flags;
14031
14032                   flags = bfd_get_section_flags (dynobj, sreloc);
14033                   flags &= ~(SEC_LOAD | SEC_ALLOC);
14034                   bfd_set_section_flags (dynobj, sreloc, flags);
14035                 }
14036             }
14037
14038           /* If this is a global symbol, count the number of
14039              relocations we need for this symbol.  */
14040           if (h != NULL)
14041             head = &((struct elf32_arm_link_hash_entry *) h)->dyn_relocs;
14042           else
14043             {
14044               head = elf32_arm_get_local_dynreloc_list (abfd, r_symndx, isym);
14045               if (head == NULL)
14046                 return FALSE;
14047             }
14048
14049           p = *head;
14050           if (p == NULL || p->sec != sec)
14051             {
14052               bfd_size_type amt = sizeof *p;
14053
14054               p = (struct elf_dyn_relocs *) bfd_alloc (htab->root.dynobj, amt);
14055               if (p == NULL)
14056                 return FALSE;
14057               p->next = *head;
14058               *head = p;
14059               p->sec = sec;
14060               p->count = 0;
14061               p->pc_count = 0;
14062             }
14063
14064           if (elf32_arm_howto_from_type (r_type)->pc_relative)
14065             p->pc_count += 1;
14066           p->count += 1;
14067         }
14068     }
14069
14070   return TRUE;
14071 }
14072
14073 /* Unwinding tables are not referenced directly.  This pass marks them as
14074    required if the corresponding code section is marked.  */
14075
14076 static bfd_boolean
14077 elf32_arm_gc_mark_extra_sections (struct bfd_link_info *info,
14078                                   elf_gc_mark_hook_fn gc_mark_hook)
14079 {
14080   bfd *sub;
14081   Elf_Internal_Shdr **elf_shdrp;
14082   bfd_boolean again;
14083
14084   _bfd_elf_gc_mark_extra_sections (info, gc_mark_hook);
14085
14086   /* Marking EH data may cause additional code sections to be marked,
14087      requiring multiple passes.  */
14088   again = TRUE;
14089   while (again)
14090     {
14091       again = FALSE;
14092       for (sub = info->input_bfds; sub != NULL; sub = sub->link.next)
14093         {
14094           asection *o;
14095
14096           if (! is_arm_elf (sub))
14097             continue;
14098
14099           elf_shdrp = elf_elfsections (sub);
14100           for (o = sub->sections; o != NULL; o = o->next)
14101             {
14102               Elf_Internal_Shdr *hdr;
14103
14104               hdr = &elf_section_data (o)->this_hdr;
14105               if (hdr->sh_type == SHT_ARM_EXIDX
14106                   && hdr->sh_link
14107                   && hdr->sh_link < elf_numsections (sub)
14108                   && !o->gc_mark
14109                   && elf_shdrp[hdr->sh_link]->bfd_section->gc_mark)
14110                 {
14111                   again = TRUE;
14112                   if (!_bfd_elf_gc_mark (info, o, gc_mark_hook))
14113                     return FALSE;
14114                 }
14115             }
14116         }
14117     }
14118
14119   return TRUE;
14120 }
14121
14122 /* Treat mapping symbols as special target symbols.  */
14123
14124 static bfd_boolean
14125 elf32_arm_is_target_special_symbol (bfd * abfd ATTRIBUTE_UNUSED, asymbol * sym)
14126 {
14127   return bfd_is_arm_special_symbol_name (sym->name,
14128                                          BFD_ARM_SPECIAL_SYM_TYPE_ANY);
14129 }
14130
14131 /* This is a copy of elf_find_function() from elf.c except that
14132    ARM mapping symbols are ignored when looking for function names
14133    and STT_ARM_TFUNC is considered to a function type.  */
14134
14135 static bfd_boolean
14136 arm_elf_find_function (bfd *         abfd ATTRIBUTE_UNUSED,
14137                        asymbol **    symbols,
14138                        asection *    section,
14139                        bfd_vma       offset,
14140                        const char ** filename_ptr,
14141                        const char ** functionname_ptr)
14142 {
14143   const char * filename = NULL;
14144   asymbol * func = NULL;
14145   bfd_vma low_func = 0;
14146   asymbol ** p;
14147
14148   for (p = symbols; *p != NULL; p++)
14149     {
14150       elf_symbol_type *q;
14151
14152       q = (elf_symbol_type *) *p;
14153
14154       switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
14155         {
14156         default:
14157           break;
14158         case STT_FILE:
14159           filename = bfd_asymbol_name (&q->symbol);
14160           break;
14161         case STT_FUNC:
14162         case STT_ARM_TFUNC:
14163         case STT_NOTYPE:
14164           /* Skip mapping symbols.  */
14165           if ((q->symbol.flags & BSF_LOCAL)
14166               && bfd_is_arm_special_symbol_name (q->symbol.name,
14167                     BFD_ARM_SPECIAL_SYM_TYPE_ANY))
14168             continue;
14169           /* Fall through.  */
14170           if (bfd_get_section (&q->symbol) == section
14171               && q->symbol.value >= low_func
14172               && q->symbol.value <= offset)
14173             {
14174               func = (asymbol *) q;
14175               low_func = q->symbol.value;
14176             }
14177           break;
14178         }
14179     }
14180
14181   if (func == NULL)
14182     return FALSE;
14183
14184   if (filename_ptr)
14185     *filename_ptr = filename;
14186   if (functionname_ptr)
14187     *functionname_ptr = bfd_asymbol_name (func);
14188
14189   return TRUE;
14190 }
14191
14192
14193 /* Find the nearest line to a particular section and offset, for error
14194    reporting.   This code is a duplicate of the code in elf.c, except
14195    that it uses arm_elf_find_function.  */
14196
14197 static bfd_boolean
14198 elf32_arm_find_nearest_line (bfd *          abfd,
14199                              asymbol **     symbols,
14200                              asection *     section,
14201                              bfd_vma        offset,
14202                              const char **  filename_ptr,
14203                              const char **  functionname_ptr,
14204                              unsigned int * line_ptr,
14205                              unsigned int * discriminator_ptr)
14206 {
14207   bfd_boolean found = FALSE;
14208
14209   if (_bfd_dwarf2_find_nearest_line (abfd, symbols, NULL, section, offset,
14210                                      filename_ptr, functionname_ptr,
14211                                      line_ptr, discriminator_ptr,
14212                                      dwarf_debug_sections, 0,
14213                                      & elf_tdata (abfd)->dwarf2_find_line_info))
14214     {
14215       if (!*functionname_ptr)
14216         arm_elf_find_function (abfd, symbols, section, offset,
14217                                *filename_ptr ? NULL : filename_ptr,
14218                                functionname_ptr);
14219
14220       return TRUE;
14221     }
14222
14223   /* Skip _bfd_dwarf1_find_nearest_line since no known ARM toolchain
14224      uses DWARF1.  */
14225
14226   if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
14227                                              & found, filename_ptr,
14228                                              functionname_ptr, line_ptr,
14229                                              & elf_tdata (abfd)->line_info))
14230     return FALSE;
14231
14232   if (found && (*functionname_ptr || *line_ptr))
14233     return TRUE;
14234
14235   if (symbols == NULL)
14236     return FALSE;
14237
14238   if (! arm_elf_find_function (abfd, symbols, section, offset,
14239                                filename_ptr, functionname_ptr))
14240     return FALSE;
14241
14242   *line_ptr = 0;
14243   return TRUE;
14244 }
14245
14246 static bfd_boolean
14247 elf32_arm_find_inliner_info (bfd *          abfd,
14248                              const char **  filename_ptr,
14249                              const char **  functionname_ptr,
14250                              unsigned int * line_ptr)
14251 {
14252   bfd_boolean found;
14253   found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
14254                                          functionname_ptr, line_ptr,
14255                                          & elf_tdata (abfd)->dwarf2_find_line_info);
14256   return found;
14257 }
14258
14259 /* Adjust a symbol defined by a dynamic object and referenced by a
14260    regular object.  The current definition is in some section of the
14261    dynamic object, but we're not including those sections.  We have to
14262    change the definition to something the rest of the link can
14263    understand.  */
14264
14265 static bfd_boolean
14266 elf32_arm_adjust_dynamic_symbol (struct bfd_link_info * info,
14267                                  struct elf_link_hash_entry * h)
14268 {
14269   bfd * dynobj;
14270   asection * s;
14271   struct elf32_arm_link_hash_entry * eh;
14272   struct elf32_arm_link_hash_table *globals;
14273
14274   globals = elf32_arm_hash_table (info);
14275   if (globals == NULL)
14276     return FALSE;
14277
14278   dynobj = elf_hash_table (info)->dynobj;
14279
14280   /* Make sure we know what is going on here.  */
14281   BFD_ASSERT (dynobj != NULL
14282               && (h->needs_plt
14283                   || h->type == STT_GNU_IFUNC
14284                   || h->u.weakdef != NULL
14285                   || (h->def_dynamic
14286                       && h->ref_regular
14287                       && !h->def_regular)));
14288
14289   eh = (struct elf32_arm_link_hash_entry *) h;
14290
14291   /* If this is a function, put it in the procedure linkage table.  We
14292      will fill in the contents of the procedure linkage table later,
14293      when we know the address of the .got section.  */
14294   if (h->type == STT_FUNC || h->type == STT_GNU_IFUNC || h->needs_plt)
14295     {
14296       /* Calls to STT_GNU_IFUNC symbols always use a PLT, even if the
14297          symbol binds locally.  */
14298       if (h->plt.refcount <= 0
14299           || (h->type != STT_GNU_IFUNC
14300               && (SYMBOL_CALLS_LOCAL (info, h)
14301                   || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
14302                       && h->root.type == bfd_link_hash_undefweak))))
14303         {
14304           /* This case can occur if we saw a PLT32 reloc in an input
14305              file, but the symbol was never referred to by a dynamic
14306              object, or if all references were garbage collected.  In
14307              such a case, we don't actually need to build a procedure
14308              linkage table, and we can just do a PC24 reloc instead.  */
14309           h->plt.offset = (bfd_vma) -1;
14310           eh->plt.thumb_refcount = 0;
14311           eh->plt.maybe_thumb_refcount = 0;
14312           eh->plt.noncall_refcount = 0;
14313           h->needs_plt = 0;
14314         }
14315
14316       return TRUE;
14317     }
14318   else
14319     {
14320       /* It's possible that we incorrectly decided a .plt reloc was
14321          needed for an R_ARM_PC24 or similar reloc to a non-function sym
14322          in check_relocs.  We can't decide accurately between function
14323          and non-function syms in check-relocs; Objects loaded later in
14324          the link may change h->type.  So fix it now.  */
14325       h->plt.offset = (bfd_vma) -1;
14326       eh->plt.thumb_refcount = 0;
14327       eh->plt.maybe_thumb_refcount = 0;
14328       eh->plt.noncall_refcount = 0;
14329     }
14330
14331   /* If this is a weak symbol, and there is a real definition, the
14332      processor independent code will have arranged for us to see the
14333      real definition first, and we can just use the same value.  */
14334   if (h->u.weakdef != NULL)
14335     {
14336       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
14337                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
14338       h->root.u.def.section = h->u.weakdef->root.u.def.section;
14339       h->root.u.def.value = h->u.weakdef->root.u.def.value;
14340       return TRUE;
14341     }
14342
14343   /* If there are no non-GOT references, we do not need a copy
14344      relocation.  */
14345   if (!h->non_got_ref)
14346     return TRUE;
14347
14348   /* This is a reference to a symbol defined by a dynamic object which
14349      is not a function.  */
14350
14351   /* If we are creating a shared library, we must presume that the
14352      only references to the symbol are via the global offset table.
14353      For such cases we need not do anything here; the relocations will
14354      be handled correctly by relocate_section.  Relocatable executables
14355      can reference data in shared objects directly, so we don't need to
14356      do anything here.  */
14357   if (bfd_link_pic (info) || globals->root.is_relocatable_executable)
14358     return TRUE;
14359
14360   /* We must allocate the symbol in our .dynbss section, which will
14361      become part of the .bss section of the executable.  There will be
14362      an entry for this symbol in the .dynsym section.  The dynamic
14363      object will contain position independent code, so all references
14364      from the dynamic object to this symbol will go through the global
14365      offset table.  The dynamic linker will use the .dynsym entry to
14366      determine the address it must put in the global offset table, so
14367      both the dynamic object and the regular object will refer to the
14368      same memory location for the variable.  */
14369   s = bfd_get_linker_section (dynobj, ".dynbss");
14370   BFD_ASSERT (s != NULL);
14371
14372   /* If allowed, we must generate a R_ARM_COPY reloc to tell the dynamic
14373      linker to copy the initial value out of the dynamic object and into
14374      the runtime process image.  We need to remember the offset into the
14375      .rel(a).bss section we are going to use.  */
14376   if (info->nocopyreloc == 0
14377       && (h->root.u.def.section->flags & SEC_ALLOC) != 0
14378       && h->size != 0)
14379     {
14380       asection *srel;
14381
14382       srel = bfd_get_linker_section (dynobj, RELOC_SECTION (globals, ".bss"));
14383       elf32_arm_allocate_dynrelocs (info, srel, 1);
14384       h->needs_copy = 1;
14385     }
14386
14387   return _bfd_elf_adjust_dynamic_copy (info, h, s);
14388 }
14389
14390 /* Allocate space in .plt, .got and associated reloc sections for
14391    dynamic relocs.  */
14392
14393 static bfd_boolean
14394 allocate_dynrelocs_for_symbol (struct elf_link_hash_entry *h, void * inf)
14395 {
14396   struct bfd_link_info *info;
14397   struct elf32_arm_link_hash_table *htab;
14398   struct elf32_arm_link_hash_entry *eh;
14399   struct elf_dyn_relocs *p;
14400
14401   if (h->root.type == bfd_link_hash_indirect)
14402     return TRUE;
14403
14404   eh = (struct elf32_arm_link_hash_entry *) h;
14405
14406   info = (struct bfd_link_info *) inf;
14407   htab = elf32_arm_hash_table (info);
14408   if (htab == NULL)
14409     return FALSE;
14410
14411   if ((htab->root.dynamic_sections_created || h->type == STT_GNU_IFUNC)
14412       && h->plt.refcount > 0)
14413     {
14414       /* Make sure this symbol is output as a dynamic symbol.
14415          Undefined weak syms won't yet be marked as dynamic.  */
14416       if (h->dynindx == -1
14417           && !h->forced_local)
14418         {
14419           if (! bfd_elf_link_record_dynamic_symbol (info, h))
14420             return FALSE;
14421         }
14422
14423       /* If the call in the PLT entry binds locally, the associated
14424          GOT entry should use an R_ARM_IRELATIVE relocation instead of
14425          the usual R_ARM_JUMP_SLOT.  Put it in the .iplt section rather
14426          than the .plt section.  */
14427       if (h->type == STT_GNU_IFUNC && SYMBOL_CALLS_LOCAL (info, h))
14428         {
14429           eh->is_iplt = 1;
14430           if (eh->plt.noncall_refcount == 0
14431               && SYMBOL_REFERENCES_LOCAL (info, h))
14432             /* All non-call references can be resolved directly.
14433                This means that they can (and in some cases, must)
14434                resolve directly to the run-time target, rather than
14435                to the PLT.  That in turns means that any .got entry
14436                would be equal to the .igot.plt entry, so there's
14437                no point having both.  */
14438             h->got.refcount = 0;
14439         }
14440
14441       if (bfd_link_pic (info)
14442           || eh->is_iplt
14443           || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
14444         {
14445           elf32_arm_allocate_plt_entry (info, eh->is_iplt, &h->plt, &eh->plt);
14446
14447           /* If this symbol is not defined in a regular file, and we are
14448              not generating a shared library, then set the symbol to this
14449              location in the .plt.  This is required to make function
14450              pointers compare as equal between the normal executable and
14451              the shared library.  */
14452           if (! bfd_link_pic (info)
14453               && !h->def_regular)
14454             {
14455               h->root.u.def.section = htab->root.splt;
14456               h->root.u.def.value = h->plt.offset;
14457
14458               /* Make sure the function is not marked as Thumb, in case
14459                  it is the target of an ABS32 relocation, which will
14460                  point to the PLT entry.  */
14461               ARM_SET_SYM_BRANCH_TYPE (h->target_internal, ST_BRANCH_TO_ARM);
14462             }
14463
14464           /* VxWorks executables have a second set of relocations for
14465              each PLT entry.  They go in a separate relocation section,
14466              which is processed by the kernel loader.  */
14467           if (htab->vxworks_p && !bfd_link_pic (info))
14468             {
14469               /* There is a relocation for the initial PLT entry:
14470                  an R_ARM_32 relocation for _GLOBAL_OFFSET_TABLE_.  */
14471               if (h->plt.offset == htab->plt_header_size)
14472                 elf32_arm_allocate_dynrelocs (info, htab->srelplt2, 1);
14473
14474               /* There are two extra relocations for each subsequent
14475                  PLT entry: an R_ARM_32 relocation for the GOT entry,
14476                  and an R_ARM_32 relocation for the PLT entry.  */
14477               elf32_arm_allocate_dynrelocs (info, htab->srelplt2, 2);
14478             }
14479         }
14480       else
14481         {
14482           h->plt.offset = (bfd_vma) -1;
14483           h->needs_plt = 0;
14484         }
14485     }
14486   else
14487     {
14488       h->plt.offset = (bfd_vma) -1;
14489       h->needs_plt = 0;
14490     }
14491
14492   eh = (struct elf32_arm_link_hash_entry *) h;
14493   eh->tlsdesc_got = (bfd_vma) -1;
14494
14495   if (h->got.refcount > 0)
14496     {
14497       asection *s;
14498       bfd_boolean dyn;
14499       int tls_type = elf32_arm_hash_entry (h)->tls_type;
14500       int indx;
14501
14502       /* Make sure this symbol is output as a dynamic symbol.
14503          Undefined weak syms won't yet be marked as dynamic.  */
14504       if (h->dynindx == -1
14505           && !h->forced_local)
14506         {
14507           if (! bfd_elf_link_record_dynamic_symbol (info, h))
14508             return FALSE;
14509         }
14510
14511       if (!htab->symbian_p)
14512         {
14513           s = htab->root.sgot;
14514           h->got.offset = s->size;
14515
14516           if (tls_type == GOT_UNKNOWN)
14517             abort ();
14518
14519           if (tls_type == GOT_NORMAL)
14520             /* Non-TLS symbols need one GOT slot.  */
14521             s->size += 4;
14522           else
14523             {
14524               if (tls_type & GOT_TLS_GDESC)
14525                 {
14526                   /* R_ARM_TLS_DESC needs 2 GOT slots.  */
14527                   eh->tlsdesc_got
14528                     = (htab->root.sgotplt->size
14529                        - elf32_arm_compute_jump_table_size (htab));
14530                   htab->root.sgotplt->size += 8;
14531                   h->got.offset = (bfd_vma) -2;
14532                   /* plt.got_offset needs to know there's a TLS_DESC
14533                      reloc in the middle of .got.plt.  */
14534                   htab->num_tls_desc++;
14535                 }
14536
14537               if (tls_type & GOT_TLS_GD)
14538                 {
14539                   /* R_ARM_TLS_GD32 needs 2 consecutive GOT slots.  If
14540                      the symbol is both GD and GDESC, got.offset may
14541                      have been overwritten.  */
14542                   h->got.offset = s->size;
14543                   s->size += 8;
14544                 }
14545
14546               if (tls_type & GOT_TLS_IE)
14547                 /* R_ARM_TLS_IE32 needs one GOT slot.  */
14548                 s->size += 4;
14549             }
14550
14551           dyn = htab->root.dynamic_sections_created;
14552
14553           indx = 0;
14554           if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
14555                                                bfd_link_pic (info),
14556                                                h)
14557               && (!bfd_link_pic (info)
14558                   || !SYMBOL_REFERENCES_LOCAL (info, h)))
14559             indx = h->dynindx;
14560
14561           if (tls_type != GOT_NORMAL
14562               && (bfd_link_pic (info) || indx != 0)
14563               && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
14564                   || h->root.type != bfd_link_hash_undefweak))
14565             {
14566               if (tls_type & GOT_TLS_IE)
14567                 elf32_arm_allocate_dynrelocs (info, htab->root.srelgot, 1);
14568
14569               if (tls_type & GOT_TLS_GD)
14570                 elf32_arm_allocate_dynrelocs (info, htab->root.srelgot, 1);
14571
14572               if (tls_type & GOT_TLS_GDESC)
14573                 {
14574                   elf32_arm_allocate_dynrelocs (info, htab->root.srelplt, 1);
14575                   /* GDESC needs a trampoline to jump to.  */
14576                   htab->tls_trampoline = -1;
14577                 }
14578
14579               /* Only GD needs it.  GDESC just emits one relocation per
14580                  2 entries.  */
14581               if ((tls_type & GOT_TLS_GD) && indx != 0)
14582                 elf32_arm_allocate_dynrelocs (info, htab->root.srelgot, 1);
14583             }
14584           else if (indx != -1 && !SYMBOL_REFERENCES_LOCAL (info, h))
14585             {
14586               if (htab->root.dynamic_sections_created)
14587                 /* Reserve room for the GOT entry's R_ARM_GLOB_DAT relocation.  */
14588                 elf32_arm_allocate_dynrelocs (info, htab->root.srelgot, 1);
14589             }
14590           else if (h->type == STT_GNU_IFUNC
14591                    && eh->plt.noncall_refcount == 0)
14592             /* No non-call references resolve the STT_GNU_IFUNC's PLT entry;
14593                they all resolve dynamically instead.  Reserve room for the
14594                GOT entry's R_ARM_IRELATIVE relocation.  */
14595             elf32_arm_allocate_irelocs (info, htab->root.srelgot, 1);
14596           else if (bfd_link_pic (info)
14597                    && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
14598                        || h->root.type != bfd_link_hash_undefweak))
14599             /* Reserve room for the GOT entry's R_ARM_RELATIVE relocation.  */
14600             elf32_arm_allocate_dynrelocs (info, htab->root.srelgot, 1);
14601         }
14602     }
14603   else
14604     h->got.offset = (bfd_vma) -1;
14605
14606   /* Allocate stubs for exported Thumb functions on v4t.  */
14607   if (!htab->use_blx && h->dynindx != -1
14608       && h->def_regular
14609       && ARM_GET_SYM_BRANCH_TYPE (h->target_internal) == ST_BRANCH_TO_THUMB
14610       && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
14611     {
14612       struct elf_link_hash_entry * th;
14613       struct bfd_link_hash_entry * bh;
14614       struct elf_link_hash_entry * myh;
14615       char name[1024];
14616       asection *s;
14617       bh = NULL;
14618       /* Create a new symbol to regist the real location of the function.  */
14619       s = h->root.u.def.section;
14620       sprintf (name, "__real_%s", h->root.root.string);
14621       _bfd_generic_link_add_one_symbol (info, s->owner,
14622                                         name, BSF_GLOBAL, s,
14623                                         h->root.u.def.value,
14624                                         NULL, TRUE, FALSE, &bh);
14625
14626       myh = (struct elf_link_hash_entry *) bh;
14627       myh->type = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
14628       myh->forced_local = 1;
14629       ARM_SET_SYM_BRANCH_TYPE (myh->target_internal, ST_BRANCH_TO_THUMB);
14630       eh->export_glue = myh;
14631       th = record_arm_to_thumb_glue (info, h);
14632       /* Point the symbol at the stub.  */
14633       h->type = ELF_ST_INFO (ELF_ST_BIND (h->type), STT_FUNC);
14634       ARM_SET_SYM_BRANCH_TYPE (h->target_internal, ST_BRANCH_TO_ARM);
14635       h->root.u.def.section = th->root.u.def.section;
14636       h->root.u.def.value = th->root.u.def.value & ~1;
14637     }
14638
14639   if (eh->dyn_relocs == NULL)
14640     return TRUE;
14641
14642   /* In the shared -Bsymbolic case, discard space allocated for
14643      dynamic pc-relative relocs against symbols which turn out to be
14644      defined in regular objects.  For the normal shared case, discard
14645      space for pc-relative relocs that have become local due to symbol
14646      visibility changes.  */
14647
14648   if (bfd_link_pic (info) || htab->root.is_relocatable_executable)
14649     {
14650       /* Relocs that use pc_count are PC-relative forms, which will appear
14651          on something like ".long foo - ." or "movw REG, foo - .".  We want
14652          calls to protected symbols to resolve directly to the function
14653          rather than going via the plt.  If people want function pointer
14654          comparisons to work as expected then they should avoid writing
14655          assembly like ".long foo - .".  */
14656       if (SYMBOL_CALLS_LOCAL (info, h))
14657         {
14658           struct elf_dyn_relocs **pp;
14659
14660           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
14661             {
14662               p->count -= p->pc_count;
14663               p->pc_count = 0;
14664               if (p->count == 0)
14665                 *pp = p->next;
14666               else
14667                 pp = &p->next;
14668             }
14669         }
14670
14671       if (htab->vxworks_p)
14672         {
14673           struct elf_dyn_relocs **pp;
14674
14675           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
14676             {
14677               if (strcmp (p->sec->output_section->name, ".tls_vars") == 0)
14678                 *pp = p->next;
14679               else
14680                 pp = &p->next;
14681             }
14682         }
14683
14684       /* Also discard relocs on undefined weak syms with non-default
14685          visibility.  */
14686       if (eh->dyn_relocs != NULL
14687           && h->root.type == bfd_link_hash_undefweak)
14688         {
14689           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
14690             eh->dyn_relocs = NULL;
14691
14692           /* Make sure undefined weak symbols are output as a dynamic
14693              symbol in PIEs.  */
14694           else if (h->dynindx == -1
14695                    && !h->forced_local)
14696             {
14697               if (! bfd_elf_link_record_dynamic_symbol (info, h))
14698                 return FALSE;
14699             }
14700         }
14701
14702       else if (htab->root.is_relocatable_executable && h->dynindx == -1
14703                && h->root.type == bfd_link_hash_new)
14704         {
14705           /* Output absolute symbols so that we can create relocations
14706              against them.  For normal symbols we output a relocation
14707              against the section that contains them.  */
14708           if (! bfd_elf_link_record_dynamic_symbol (info, h))
14709             return FALSE;
14710         }
14711
14712     }
14713   else
14714     {
14715       /* For the non-shared case, discard space for relocs against
14716          symbols which turn out to need copy relocs or are not
14717          dynamic.  */
14718
14719       if (!h->non_got_ref
14720           && ((h->def_dynamic
14721                && !h->def_regular)
14722               || (htab->root.dynamic_sections_created
14723                   && (h->root.type == bfd_link_hash_undefweak
14724                       || h->root.type == bfd_link_hash_undefined))))
14725         {
14726           /* Make sure this symbol is output as a dynamic symbol.
14727              Undefined weak syms won't yet be marked as dynamic.  */
14728           if (h->dynindx == -1
14729               && !h->forced_local)
14730             {
14731               if (! bfd_elf_link_record_dynamic_symbol (info, h))
14732                 return FALSE;
14733             }
14734
14735           /* If that succeeded, we know we'll be keeping all the
14736              relocs.  */
14737           if (h->dynindx != -1)
14738             goto keep;
14739         }
14740
14741       eh->dyn_relocs = NULL;
14742
14743     keep: ;
14744     }
14745
14746   /* Finally, allocate space.  */
14747   for (p = eh->dyn_relocs; p != NULL; p = p->next)
14748     {
14749       asection *sreloc = elf_section_data (p->sec)->sreloc;
14750       if (h->type == STT_GNU_IFUNC
14751           && eh->plt.noncall_refcount == 0
14752           && SYMBOL_REFERENCES_LOCAL (info, h))
14753         elf32_arm_allocate_irelocs (info, sreloc, p->count);
14754       else
14755         elf32_arm_allocate_dynrelocs (info, sreloc, p->count);
14756     }
14757
14758   return TRUE;
14759 }
14760
14761 /* Find any dynamic relocs that apply to read-only sections.  */
14762
14763 static bfd_boolean
14764 elf32_arm_readonly_dynrelocs (struct elf_link_hash_entry * h, void * inf)
14765 {
14766   struct elf32_arm_link_hash_entry * eh;
14767   struct elf_dyn_relocs * p;
14768
14769   eh = (struct elf32_arm_link_hash_entry *) h;
14770   for (p = eh->dyn_relocs; p != NULL; p = p->next)
14771     {
14772       asection *s = p->sec;
14773
14774       if (s != NULL && (s->flags & SEC_READONLY) != 0)
14775         {
14776           struct bfd_link_info *info = (struct bfd_link_info *) inf;
14777
14778           info->flags |= DF_TEXTREL;
14779
14780           /* Not an error, just cut short the traversal.  */
14781           return FALSE;
14782         }
14783     }
14784   return TRUE;
14785 }
14786
14787 void
14788 bfd_elf32_arm_set_byteswap_code (struct bfd_link_info *info,
14789                                  int byteswap_code)
14790 {
14791   struct elf32_arm_link_hash_table *globals;
14792
14793   globals = elf32_arm_hash_table (info);
14794   if (globals == NULL)
14795     return;
14796
14797   globals->byteswap_code = byteswap_code;
14798 }
14799
14800 /* Set the sizes of the dynamic sections.  */
14801
14802 static bfd_boolean
14803 elf32_arm_size_dynamic_sections (bfd * output_bfd ATTRIBUTE_UNUSED,
14804                                  struct bfd_link_info * info)
14805 {
14806   bfd * dynobj;
14807   asection * s;
14808   bfd_boolean plt;
14809   bfd_boolean relocs;
14810   bfd *ibfd;
14811   struct elf32_arm_link_hash_table *htab;
14812
14813   htab = elf32_arm_hash_table (info);
14814   if (htab == NULL)
14815     return FALSE;
14816
14817   dynobj = elf_hash_table (info)->dynobj;
14818   BFD_ASSERT (dynobj != NULL);
14819   check_use_blx (htab);
14820
14821   if (elf_hash_table (info)->dynamic_sections_created)
14822     {
14823       /* Set the contents of the .interp section to the interpreter.  */
14824       if (bfd_link_executable (info) && !info->nointerp)
14825         {
14826           s = bfd_get_linker_section (dynobj, ".interp");
14827           BFD_ASSERT (s != NULL);
14828           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
14829           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
14830         }
14831     }
14832
14833   /* Set up .got offsets for local syms, and space for local dynamic
14834      relocs.  */
14835   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
14836     {
14837       bfd_signed_vma *local_got;
14838       bfd_signed_vma *end_local_got;
14839       struct arm_local_iplt_info **local_iplt_ptr, *local_iplt;
14840       char *local_tls_type;
14841       bfd_vma *local_tlsdesc_gotent;
14842       bfd_size_type locsymcount;
14843       Elf_Internal_Shdr *symtab_hdr;
14844       asection *srel;
14845       bfd_boolean is_vxworks = htab->vxworks_p;
14846       unsigned int symndx;
14847
14848       if (! is_arm_elf (ibfd))
14849         continue;
14850
14851       for (s = ibfd->sections; s != NULL; s = s->next)
14852         {
14853           struct elf_dyn_relocs *p;
14854
14855           for (p = (struct elf_dyn_relocs *)
14856                    elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
14857             {
14858               if (!bfd_is_abs_section (p->sec)
14859                   && bfd_is_abs_section (p->sec->output_section))
14860                 {
14861                   /* Input section has been discarded, either because
14862                      it is a copy of a linkonce section or due to
14863                      linker script /DISCARD/, so we'll be discarding
14864                      the relocs too.  */
14865                 }
14866               else if (is_vxworks
14867                        && strcmp (p->sec->output_section->name,
14868                                   ".tls_vars") == 0)
14869                 {
14870                   /* Relocations in vxworks .tls_vars sections are
14871                      handled specially by the loader.  */
14872                 }
14873               else if (p->count != 0)
14874                 {
14875                   srel = elf_section_data (p->sec)->sreloc;
14876                   elf32_arm_allocate_dynrelocs (info, srel, p->count);
14877                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
14878                     info->flags |= DF_TEXTREL;
14879                 }
14880             }
14881         }
14882
14883       local_got = elf_local_got_refcounts (ibfd);
14884       if (!local_got)
14885         continue;
14886
14887       symtab_hdr = & elf_symtab_hdr (ibfd);
14888       locsymcount = symtab_hdr->sh_info;
14889       end_local_got = local_got + locsymcount;
14890       local_iplt_ptr = elf32_arm_local_iplt (ibfd);
14891       local_tls_type = elf32_arm_local_got_tls_type (ibfd);
14892       local_tlsdesc_gotent = elf32_arm_local_tlsdesc_gotent (ibfd);
14893       symndx = 0;
14894       s = htab->root.sgot;
14895       srel = htab->root.srelgot;
14896       for (; local_got < end_local_got;
14897            ++local_got, ++local_iplt_ptr, ++local_tls_type,
14898            ++local_tlsdesc_gotent, ++symndx)
14899         {
14900           *local_tlsdesc_gotent = (bfd_vma) -1;
14901           local_iplt = *local_iplt_ptr;
14902           if (local_iplt != NULL)
14903             {
14904               struct elf_dyn_relocs *p;
14905
14906               if (local_iplt->root.refcount > 0)
14907                 {
14908                   elf32_arm_allocate_plt_entry (info, TRUE,
14909                                                 &local_iplt->root,
14910                                                 &local_iplt->arm);
14911                   if (local_iplt->arm.noncall_refcount == 0)
14912                     /* All references to the PLT are calls, so all
14913                        non-call references can resolve directly to the
14914                        run-time target.  This means that the .got entry
14915                        would be the same as the .igot.plt entry, so there's
14916                        no point creating both.  */
14917                     *local_got = 0;
14918                 }
14919               else
14920                 {
14921                   BFD_ASSERT (local_iplt->arm.noncall_refcount == 0);
14922                   local_iplt->root.offset = (bfd_vma) -1;
14923                 }
14924
14925               for (p = local_iplt->dyn_relocs; p != NULL; p = p->next)
14926                 {
14927                   asection *psrel;
14928
14929                   psrel = elf_section_data (p->sec)->sreloc;
14930                   if (local_iplt->arm.noncall_refcount == 0)
14931                     elf32_arm_allocate_irelocs (info, psrel, p->count);
14932                   else
14933                     elf32_arm_allocate_dynrelocs (info, psrel, p->count);
14934                 }
14935             }
14936           if (*local_got > 0)
14937             {
14938               Elf_Internal_Sym *isym;
14939
14940               *local_got = s->size;
14941               if (*local_tls_type & GOT_TLS_GD)
14942                 /* TLS_GD relocs need an 8-byte structure in the GOT.  */
14943                 s->size += 8;
14944               if (*local_tls_type & GOT_TLS_GDESC)
14945                 {
14946                   *local_tlsdesc_gotent = htab->root.sgotplt->size
14947                     - elf32_arm_compute_jump_table_size (htab);
14948                   htab->root.sgotplt->size += 8;
14949                   *local_got = (bfd_vma) -2;
14950                   /* plt.got_offset needs to know there's a TLS_DESC
14951                      reloc in the middle of .got.plt.  */
14952                   htab->num_tls_desc++;
14953                 }
14954               if (*local_tls_type & GOT_TLS_IE)
14955                 s->size += 4;
14956
14957               if (*local_tls_type & GOT_NORMAL)
14958                 {
14959                   /* If the symbol is both GD and GDESC, *local_got
14960                      may have been overwritten.  */
14961                   *local_got = s->size;
14962                   s->size += 4;
14963                 }
14964
14965               isym = bfd_sym_from_r_symndx (&htab->sym_cache, ibfd, symndx);
14966               if (isym == NULL)
14967                 return FALSE;
14968
14969               /* If all references to an STT_GNU_IFUNC PLT are calls,
14970                  then all non-call references, including this GOT entry,
14971                  resolve directly to the run-time target.  */
14972               if (ELF32_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
14973                   && (local_iplt == NULL
14974                       || local_iplt->arm.noncall_refcount == 0))
14975                 elf32_arm_allocate_irelocs (info, srel, 1);
14976               else if (bfd_link_pic (info) || output_bfd->flags & DYNAMIC)
14977                 {
14978                   if ((bfd_link_pic (info) && !(*local_tls_type & GOT_TLS_GDESC))
14979                       || *local_tls_type & GOT_TLS_GD)
14980                     elf32_arm_allocate_dynrelocs (info, srel, 1);
14981
14982                   if (bfd_link_pic (info) && *local_tls_type & GOT_TLS_GDESC)
14983                     {
14984                       elf32_arm_allocate_dynrelocs (info,
14985                                                     htab->root.srelplt, 1);
14986                       htab->tls_trampoline = -1;
14987                     }
14988                 }
14989             }
14990           else
14991             *local_got = (bfd_vma) -1;
14992         }
14993     }
14994
14995   if (htab->tls_ldm_got.refcount > 0)
14996     {
14997       /* Allocate two GOT entries and one dynamic relocation (if necessary)
14998          for R_ARM_TLS_LDM32 relocations.  */
14999       htab->tls_ldm_got.offset = htab->root.sgot->size;
15000       htab->root.sgot->size += 8;
15001       if (bfd_link_pic (info))
15002         elf32_arm_allocate_dynrelocs (info, htab->root.srelgot, 1);
15003     }
15004   else
15005     htab->tls_ldm_got.offset = -1;
15006
15007   /* Allocate global sym .plt and .got entries, and space for global
15008      sym dynamic relocs.  */
15009   elf_link_hash_traverse (& htab->root, allocate_dynrelocs_for_symbol, info);
15010
15011   /* Here we rummage through the found bfds to collect glue information.  */
15012   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
15013     {
15014       if (! is_arm_elf (ibfd))
15015         continue;
15016
15017       /* Initialise mapping tables for code/data.  */
15018       bfd_elf32_arm_init_maps (ibfd);
15019
15020       if (!bfd_elf32_arm_process_before_allocation (ibfd, info)
15021           || !bfd_elf32_arm_vfp11_erratum_scan (ibfd, info)
15022           || !bfd_elf32_arm_stm32l4xx_erratum_scan (ibfd, info))
15023         /* xgettext:c-format */
15024         _bfd_error_handler (_("Errors encountered processing file %s"),
15025                             ibfd->filename);
15026     }
15027
15028   /* Allocate space for the glue sections now that we've sized them.  */
15029   bfd_elf32_arm_allocate_interworking_sections (info);
15030
15031   /* For every jump slot reserved in the sgotplt, reloc_count is
15032      incremented.  However, when we reserve space for TLS descriptors,
15033      it's not incremented, so in order to compute the space reserved
15034      for them, it suffices to multiply the reloc count by the jump
15035      slot size.  */
15036   if (htab->root.srelplt)
15037     htab->sgotplt_jump_table_size = elf32_arm_compute_jump_table_size(htab);
15038
15039   if (htab->tls_trampoline)
15040     {
15041       if (htab->root.splt->size == 0)
15042         htab->root.splt->size += htab->plt_header_size;
15043
15044       htab->tls_trampoline = htab->root.splt->size;
15045       htab->root.splt->size += htab->plt_entry_size;
15046
15047       /* If we're not using lazy TLS relocations, don't generate the
15048          PLT and GOT entries they require.  */
15049       if (!(info->flags & DF_BIND_NOW))
15050         {
15051           htab->dt_tlsdesc_got = htab->root.sgot->size;
15052           htab->root.sgot->size += 4;
15053
15054           htab->dt_tlsdesc_plt = htab->root.splt->size;
15055           htab->root.splt->size += 4 * ARRAY_SIZE (dl_tlsdesc_lazy_trampoline);
15056         }
15057     }
15058
15059   /* The check_relocs and adjust_dynamic_symbol entry points have
15060      determined the sizes of the various dynamic sections.  Allocate
15061      memory for them.  */
15062   plt = FALSE;
15063   relocs = FALSE;
15064   for (s = dynobj->sections; s != NULL; s = s->next)
15065     {
15066       const char * name;
15067
15068       if ((s->flags & SEC_LINKER_CREATED) == 0)
15069         continue;
15070
15071       /* It's OK to base decisions on the section name, because none
15072          of the dynobj section names depend upon the input files.  */
15073       name = bfd_get_section_name (dynobj, s);
15074
15075       if (s == htab->root.splt)
15076         {
15077           /* Remember whether there is a PLT.  */
15078           plt = s->size != 0;
15079         }
15080       else if (CONST_STRNEQ (name, ".rel"))
15081         {
15082           if (s->size != 0)
15083             {
15084               /* Remember whether there are any reloc sections other
15085                  than .rel(a).plt and .rela.plt.unloaded.  */
15086               if (s != htab->root.srelplt && s != htab->srelplt2)
15087                 relocs = TRUE;
15088
15089               /* We use the reloc_count field as a counter if we need
15090                  to copy relocs into the output file.  */
15091               s->reloc_count = 0;
15092             }
15093         }
15094       else if (s != htab->root.sgot
15095                && s != htab->root.sgotplt
15096                && s != htab->root.iplt
15097                && s != htab->root.igotplt
15098                && s != htab->sdynbss)
15099         {
15100           /* It's not one of our sections, so don't allocate space.  */
15101           continue;
15102         }
15103
15104       if (s->size == 0)
15105         {
15106           /* If we don't need this section, strip it from the
15107              output file.  This is mostly to handle .rel(a).bss and
15108              .rel(a).plt.  We must create both sections in
15109              create_dynamic_sections, because they must be created
15110              before the linker maps input sections to output
15111              sections.  The linker does that before
15112              adjust_dynamic_symbol is called, and it is that
15113              function which decides whether anything needs to go
15114              into these sections.  */
15115           s->flags |= SEC_EXCLUDE;
15116           continue;
15117         }
15118
15119       if ((s->flags & SEC_HAS_CONTENTS) == 0)
15120         continue;
15121
15122       /* Allocate memory for the section contents.  */
15123       s->contents = (unsigned char *) bfd_zalloc (dynobj, s->size);
15124       if (s->contents == NULL)
15125         return FALSE;
15126     }
15127
15128   if (elf_hash_table (info)->dynamic_sections_created)
15129     {
15130       /* Add some entries to the .dynamic section.  We fill in the
15131          values later, in elf32_arm_finish_dynamic_sections, but we
15132          must add the entries now so that we get the correct size for
15133          the .dynamic section.  The DT_DEBUG entry is filled in by the
15134          dynamic linker and used by the debugger.  */
15135 #define add_dynamic_entry(TAG, VAL) \
15136   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
15137
15138      if (bfd_link_executable (info))
15139         {
15140           if (!add_dynamic_entry (DT_DEBUG, 0))
15141             return FALSE;
15142         }
15143
15144       if (plt)
15145         {
15146           if (   !add_dynamic_entry (DT_PLTGOT, 0)
15147               || !add_dynamic_entry (DT_PLTRELSZ, 0)
15148               || !add_dynamic_entry (DT_PLTREL,
15149                                      htab->use_rel ? DT_REL : DT_RELA)
15150               || !add_dynamic_entry (DT_JMPREL, 0))
15151             return FALSE;
15152
15153           if (htab->dt_tlsdesc_plt &&
15154                 (!add_dynamic_entry (DT_TLSDESC_PLT,0)
15155                  || !add_dynamic_entry (DT_TLSDESC_GOT,0)))
15156             return FALSE;
15157         }
15158
15159       if (relocs)
15160         {
15161           if (htab->use_rel)
15162             {
15163               if (!add_dynamic_entry (DT_REL, 0)
15164                   || !add_dynamic_entry (DT_RELSZ, 0)
15165                   || !add_dynamic_entry (DT_RELENT, RELOC_SIZE (htab)))
15166                 return FALSE;
15167             }
15168           else
15169             {
15170               if (!add_dynamic_entry (DT_RELA, 0)
15171                   || !add_dynamic_entry (DT_RELASZ, 0)
15172                   || !add_dynamic_entry (DT_RELAENT, RELOC_SIZE (htab)))
15173                 return FALSE;
15174             }
15175         }
15176
15177       /* If any dynamic relocs apply to a read-only section,
15178          then we need a DT_TEXTREL entry.  */
15179       if ((info->flags & DF_TEXTREL) == 0)
15180         elf_link_hash_traverse (& htab->root, elf32_arm_readonly_dynrelocs,
15181                                 info);
15182
15183       if ((info->flags & DF_TEXTREL) != 0)
15184         {
15185           if (!add_dynamic_entry (DT_TEXTREL, 0))
15186             return FALSE;
15187         }
15188       if (htab->vxworks_p
15189           && !elf_vxworks_add_dynamic_entries (output_bfd, info))
15190         return FALSE;
15191     }
15192 #undef add_dynamic_entry
15193
15194   return TRUE;
15195 }
15196
15197 /* Size sections even though they're not dynamic.  We use it to setup
15198    _TLS_MODULE_BASE_, if needed.  */
15199
15200 static bfd_boolean
15201 elf32_arm_always_size_sections (bfd *output_bfd,
15202                                 struct bfd_link_info *info)
15203 {
15204   asection *tls_sec;
15205
15206   if (bfd_link_relocatable (info))
15207     return TRUE;
15208
15209   tls_sec = elf_hash_table (info)->tls_sec;
15210
15211   if (tls_sec)
15212     {
15213       struct elf_link_hash_entry *tlsbase;
15214
15215       tlsbase = elf_link_hash_lookup
15216         (elf_hash_table (info), "_TLS_MODULE_BASE_", TRUE, TRUE, FALSE);
15217
15218       if (tlsbase)
15219         {
15220           struct bfd_link_hash_entry *bh = NULL;
15221           const struct elf_backend_data *bed
15222             = get_elf_backend_data (output_bfd);
15223
15224           if (!(_bfd_generic_link_add_one_symbol
15225                 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
15226                  tls_sec, 0, NULL, FALSE,
15227                  bed->collect, &bh)))
15228             return FALSE;
15229
15230           tlsbase->type = STT_TLS;
15231           tlsbase = (struct elf_link_hash_entry *)bh;
15232           tlsbase->def_regular = 1;
15233           tlsbase->other = STV_HIDDEN;
15234           (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
15235         }
15236     }
15237   return TRUE;
15238 }
15239
15240 /* Finish up dynamic symbol handling.  We set the contents of various
15241    dynamic sections here.  */
15242
15243 static bfd_boolean
15244 elf32_arm_finish_dynamic_symbol (bfd * output_bfd,
15245                                  struct bfd_link_info * info,
15246                                  struct elf_link_hash_entry * h,
15247                                  Elf_Internal_Sym * sym)
15248 {
15249   struct elf32_arm_link_hash_table *htab;
15250   struct elf32_arm_link_hash_entry *eh;
15251
15252   htab = elf32_arm_hash_table (info);
15253   if (htab == NULL)
15254     return FALSE;
15255
15256   eh = (struct elf32_arm_link_hash_entry *) h;
15257
15258   if (h->plt.offset != (bfd_vma) -1)
15259     {
15260       if (!eh->is_iplt)
15261         {
15262           BFD_ASSERT (h->dynindx != -1);
15263           if (! elf32_arm_populate_plt_entry (output_bfd, info, &h->plt, &eh->plt,
15264                                               h->dynindx, 0))
15265             return FALSE;
15266         }
15267
15268       if (!h->def_regular)
15269         {
15270           /* Mark the symbol as undefined, rather than as defined in
15271              the .plt section.  */
15272           sym->st_shndx = SHN_UNDEF;
15273           /* If the symbol is weak we need to clear the value.
15274              Otherwise, the PLT entry would provide a definition for
15275              the symbol even if the symbol wasn't defined anywhere,
15276              and so the symbol would never be NULL.  Leave the value if
15277              there were any relocations where pointer equality matters
15278              (this is a clue for the dynamic linker, to make function
15279              pointer comparisons work between an application and shared
15280              library).  */
15281           if (!h->ref_regular_nonweak || !h->pointer_equality_needed)
15282             sym->st_value = 0;
15283         }
15284       else if (eh->is_iplt && eh->plt.noncall_refcount != 0)
15285         {
15286           /* At least one non-call relocation references this .iplt entry,
15287              so the .iplt entry is the function's canonical address.  */
15288           sym->st_info = ELF_ST_INFO (ELF_ST_BIND (sym->st_info), STT_FUNC);
15289           ARM_SET_SYM_BRANCH_TYPE (sym->st_target_internal, ST_BRANCH_TO_ARM);
15290           sym->st_shndx = (_bfd_elf_section_from_bfd_section
15291                            (output_bfd, htab->root.iplt->output_section));
15292           sym->st_value = (h->plt.offset
15293                            + htab->root.iplt->output_section->vma
15294                            + htab->root.iplt->output_offset);
15295         }
15296     }
15297
15298   if (h->needs_copy)
15299     {
15300       asection * s;
15301       Elf_Internal_Rela rel;
15302
15303       /* This symbol needs a copy reloc.  Set it up.  */
15304       BFD_ASSERT (h->dynindx != -1
15305                   && (h->root.type == bfd_link_hash_defined
15306                       || h->root.type == bfd_link_hash_defweak));
15307
15308       s = htab->srelbss;
15309       BFD_ASSERT (s != NULL);
15310
15311       rel.r_addend = 0;
15312       rel.r_offset = (h->root.u.def.value
15313                       + h->root.u.def.section->output_section->vma
15314                       + h->root.u.def.section->output_offset);
15315       rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_COPY);
15316       elf32_arm_add_dynreloc (output_bfd, info, s, &rel);
15317     }
15318
15319   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  On VxWorks,
15320      the _GLOBAL_OFFSET_TABLE_ symbol is not absolute: it is relative
15321      to the ".got" section.  */
15322   if (h == htab->root.hdynamic
15323       || (!htab->vxworks_p && h == htab->root.hgot))
15324     sym->st_shndx = SHN_ABS;
15325
15326   return TRUE;
15327 }
15328
15329 static void
15330 arm_put_trampoline (struct elf32_arm_link_hash_table *htab, bfd *output_bfd,
15331                     void *contents,
15332                     const unsigned long *template, unsigned count)
15333 {
15334   unsigned ix;
15335
15336   for (ix = 0; ix != count; ix++)
15337     {
15338       unsigned long insn = template[ix];
15339
15340       /* Emit mov pc,rx if bx is not permitted.  */
15341       if (htab->fix_v4bx == 1 && (insn & 0x0ffffff0) == 0x012fff10)
15342         insn = (insn & 0xf000000f) | 0x01a0f000;
15343       put_arm_insn (htab, output_bfd, insn, (char *)contents + ix*4);
15344     }
15345 }
15346
15347 /* Install the special first PLT entry for elf32-arm-nacl.  Unlike
15348    other variants, NaCl needs this entry in a static executable's
15349    .iplt too.  When we're handling that case, GOT_DISPLACEMENT is
15350    zero.  For .iplt really only the last bundle is useful, and .iplt
15351    could have a shorter first entry, with each individual PLT entry's
15352    relative branch calculated differently so it targets the last
15353    bundle instead of the instruction before it (labelled .Lplt_tail
15354    above).  But it's simpler to keep the size and layout of PLT0
15355    consistent with the dynamic case, at the cost of some dead code at
15356    the start of .iplt and the one dead store to the stack at the start
15357    of .Lplt_tail.  */
15358 static void
15359 arm_nacl_put_plt0 (struct elf32_arm_link_hash_table *htab, bfd *output_bfd,
15360                    asection *plt, bfd_vma got_displacement)
15361 {
15362   unsigned int i;
15363
15364   put_arm_insn (htab, output_bfd,
15365                 elf32_arm_nacl_plt0_entry[0]
15366                 | arm_movw_immediate (got_displacement),
15367                 plt->contents + 0);
15368   put_arm_insn (htab, output_bfd,
15369                 elf32_arm_nacl_plt0_entry[1]
15370                 | arm_movt_immediate (got_displacement),
15371                 plt->contents + 4);
15372
15373   for (i = 2; i < ARRAY_SIZE (elf32_arm_nacl_plt0_entry); ++i)
15374     put_arm_insn (htab, output_bfd,
15375                   elf32_arm_nacl_plt0_entry[i],
15376                   plt->contents + (i * 4));
15377 }
15378
15379 /* Finish up the dynamic sections.  */
15380
15381 static bfd_boolean
15382 elf32_arm_finish_dynamic_sections (bfd * output_bfd, struct bfd_link_info * info)
15383 {
15384   bfd * dynobj;
15385   asection * sgot;
15386   asection * sdyn;
15387   struct elf32_arm_link_hash_table *htab;
15388
15389   htab = elf32_arm_hash_table (info);
15390   if (htab == NULL)
15391     return FALSE;
15392
15393   dynobj = elf_hash_table (info)->dynobj;
15394
15395   sgot = htab->root.sgotplt;
15396   /* A broken linker script might have discarded the dynamic sections.
15397      Catch this here so that we do not seg-fault later on.  */
15398   if (sgot != NULL && bfd_is_abs_section (sgot->output_section))
15399     return FALSE;
15400   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
15401
15402   if (elf_hash_table (info)->dynamic_sections_created)
15403     {
15404       asection *splt;
15405       Elf32_External_Dyn *dyncon, *dynconend;
15406
15407       splt = htab->root.splt;
15408       BFD_ASSERT (splt != NULL && sdyn != NULL);
15409       BFD_ASSERT (htab->symbian_p || sgot != NULL);
15410
15411       dyncon = (Elf32_External_Dyn *) sdyn->contents;
15412       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
15413
15414       for (; dyncon < dynconend; dyncon++)
15415         {
15416           Elf_Internal_Dyn dyn;
15417           const char * name;
15418           asection * s;
15419
15420           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
15421
15422           switch (dyn.d_tag)
15423             {
15424               unsigned int type;
15425
15426             default:
15427               if (htab->vxworks_p
15428                   && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
15429                 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
15430               break;
15431
15432             case DT_HASH:
15433               name = ".hash";
15434               goto get_vma_if_bpabi;
15435             case DT_STRTAB:
15436               name = ".dynstr";
15437               goto get_vma_if_bpabi;
15438             case DT_SYMTAB:
15439               name = ".dynsym";
15440               goto get_vma_if_bpabi;
15441             case DT_VERSYM:
15442               name = ".gnu.version";
15443               goto get_vma_if_bpabi;
15444             case DT_VERDEF:
15445               name = ".gnu.version_d";
15446               goto get_vma_if_bpabi;
15447             case DT_VERNEED:
15448               name = ".gnu.version_r";
15449               goto get_vma_if_bpabi;
15450
15451             case DT_PLTGOT:
15452               name = htab->symbian_p ? ".got" : ".got.plt";
15453               goto get_vma;
15454             case DT_JMPREL:
15455               name = RELOC_SECTION (htab, ".plt");
15456             get_vma:
15457               s = bfd_get_linker_section (dynobj, name);
15458               if (s == NULL)
15459                 {
15460                   (*_bfd_error_handler)
15461                     (_("could not find section %s"), name);
15462                   bfd_set_error (bfd_error_invalid_operation);
15463                   return FALSE;
15464                 }
15465               if (!htab->symbian_p)
15466                 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
15467               else
15468                 /* In the BPABI, tags in the PT_DYNAMIC section point
15469                    at the file offset, not the memory address, for the
15470                    convenience of the post linker.  */
15471                 dyn.d_un.d_ptr = s->output_section->filepos + s->output_offset;
15472               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
15473               break;
15474
15475             get_vma_if_bpabi:
15476               if (htab->symbian_p)
15477                 goto get_vma;
15478               break;
15479
15480             case DT_PLTRELSZ:
15481               s = htab->root.srelplt;
15482               BFD_ASSERT (s != NULL);
15483               dyn.d_un.d_val = s->size;
15484               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
15485               break;
15486
15487             case DT_RELSZ:
15488             case DT_RELASZ:
15489               if (!htab->symbian_p)
15490                 {
15491                   /* My reading of the SVR4 ABI indicates that the
15492                      procedure linkage table relocs (DT_JMPREL) should be
15493                      included in the overall relocs (DT_REL).  This is
15494                      what Solaris does.  However, UnixWare can not handle
15495                      that case.  Therefore, we override the DT_RELSZ entry
15496                      here to make it not include the JMPREL relocs.  Since
15497                      the linker script arranges for .rel(a).plt to follow all
15498                      other relocation sections, we don't have to worry
15499                      about changing the DT_REL entry.  */
15500                   s = htab->root.srelplt;
15501                   if (s != NULL)
15502                     dyn.d_un.d_val -= s->size;
15503                   bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
15504                   break;
15505                 }
15506               /* Fall through.  */
15507
15508             case DT_REL:
15509             case DT_RELA:
15510               /* In the BPABI, the DT_REL tag must point at the file
15511                  offset, not the VMA, of the first relocation
15512                  section.  So, we use code similar to that in
15513                  elflink.c, but do not check for SHF_ALLOC on the
15514                  relcoation section, since relocations sections are
15515                  never allocated under the BPABI.  The comments above
15516                  about Unixware notwithstanding, we include all of the
15517                  relocations here.  */
15518               if (htab->symbian_p)
15519                 {
15520                   unsigned int i;
15521                   type = ((dyn.d_tag == DT_REL || dyn.d_tag == DT_RELSZ)
15522                           ? SHT_REL : SHT_RELA);
15523                   dyn.d_un.d_val = 0;
15524                   for (i = 1; i < elf_numsections (output_bfd); i++)
15525                     {
15526                       Elf_Internal_Shdr *hdr
15527                         = elf_elfsections (output_bfd)[i];
15528                       if (hdr->sh_type == type)
15529                         {
15530                           if (dyn.d_tag == DT_RELSZ
15531                               || dyn.d_tag == DT_RELASZ)
15532                             dyn.d_un.d_val += hdr->sh_size;
15533                           else if ((ufile_ptr) hdr->sh_offset
15534                                    <= dyn.d_un.d_val - 1)
15535                             dyn.d_un.d_val = hdr->sh_offset;
15536                         }
15537                     }
15538                   bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
15539                 }
15540               break;
15541
15542             case DT_TLSDESC_PLT:
15543               s = htab->root.splt;
15544               dyn.d_un.d_ptr = (s->output_section->vma + s->output_offset
15545                                 + htab->dt_tlsdesc_plt);
15546               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
15547               break;
15548
15549             case DT_TLSDESC_GOT:
15550               s = htab->root.sgot;
15551               dyn.d_un.d_ptr = (s->output_section->vma + s->output_offset
15552                                 + htab->dt_tlsdesc_got);
15553               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
15554               break;
15555
15556               /* Set the bottom bit of DT_INIT/FINI if the
15557                  corresponding function is Thumb.  */
15558             case DT_INIT:
15559               name = info->init_function;
15560               goto get_sym;
15561             case DT_FINI:
15562               name = info->fini_function;
15563             get_sym:
15564               /* If it wasn't set by elf_bfd_final_link
15565                  then there is nothing to adjust.  */
15566               if (dyn.d_un.d_val != 0)
15567                 {
15568                   struct elf_link_hash_entry * eh;
15569
15570                   eh = elf_link_hash_lookup (elf_hash_table (info), name,
15571                                              FALSE, FALSE, TRUE);
15572                   if (eh != NULL
15573                       && ARM_GET_SYM_BRANCH_TYPE (eh->target_internal)
15574                          == ST_BRANCH_TO_THUMB)
15575                     {
15576                       dyn.d_un.d_val |= 1;
15577                       bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
15578                     }
15579                 }
15580               break;
15581             }
15582         }
15583
15584       /* Fill in the first entry in the procedure linkage table.  */
15585       if (splt->size > 0 && htab->plt_header_size)
15586         {
15587           const bfd_vma *plt0_entry;
15588           bfd_vma got_address, plt_address, got_displacement;
15589
15590           /* Calculate the addresses of the GOT and PLT.  */
15591           got_address = sgot->output_section->vma + sgot->output_offset;
15592           plt_address = splt->output_section->vma + splt->output_offset;
15593
15594           if (htab->vxworks_p)
15595             {
15596               /* The VxWorks GOT is relocated by the dynamic linker.
15597                  Therefore, we must emit relocations rather than simply
15598                  computing the values now.  */
15599               Elf_Internal_Rela rel;
15600
15601               plt0_entry = elf32_arm_vxworks_exec_plt0_entry;
15602               put_arm_insn (htab, output_bfd, plt0_entry[0],
15603                             splt->contents + 0);
15604               put_arm_insn (htab, output_bfd, plt0_entry[1],
15605                             splt->contents + 4);
15606               put_arm_insn (htab, output_bfd, plt0_entry[2],
15607                             splt->contents + 8);
15608               bfd_put_32 (output_bfd, got_address, splt->contents + 12);
15609
15610               /* Generate a relocation for _GLOBAL_OFFSET_TABLE_.  */
15611               rel.r_offset = plt_address + 12;
15612               rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_ARM_ABS32);
15613               rel.r_addend = 0;
15614               SWAP_RELOC_OUT (htab) (output_bfd, &rel,
15615                                      htab->srelplt2->contents);
15616             }
15617           else if (htab->nacl_p)
15618             arm_nacl_put_plt0 (htab, output_bfd, splt,
15619                                got_address + 8 - (plt_address + 16));
15620           else if (using_thumb_only (htab))
15621             {
15622               got_displacement = got_address - (plt_address + 12);
15623
15624               plt0_entry = elf32_thumb2_plt0_entry;
15625               put_arm_insn (htab, output_bfd, plt0_entry[0],
15626                             splt->contents + 0);
15627               put_arm_insn (htab, output_bfd, plt0_entry[1],
15628                             splt->contents + 4);
15629               put_arm_insn (htab, output_bfd, plt0_entry[2],
15630                             splt->contents + 8);
15631
15632               bfd_put_32 (output_bfd, got_displacement, splt->contents + 12);
15633             }
15634           else
15635             {
15636               got_displacement = got_address - (plt_address + 16);
15637
15638               plt0_entry = elf32_arm_plt0_entry;
15639               put_arm_insn (htab, output_bfd, plt0_entry[0],
15640                             splt->contents + 0);
15641               put_arm_insn (htab, output_bfd, plt0_entry[1],
15642                             splt->contents + 4);
15643               put_arm_insn (htab, output_bfd, plt0_entry[2],
15644                             splt->contents + 8);
15645               put_arm_insn (htab, output_bfd, plt0_entry[3],
15646                             splt->contents + 12);
15647
15648 #ifdef FOUR_WORD_PLT
15649               /* The displacement value goes in the otherwise-unused
15650                  last word of the second entry.  */
15651               bfd_put_32 (output_bfd, got_displacement, splt->contents + 28);
15652 #else
15653               bfd_put_32 (output_bfd, got_displacement, splt->contents + 16);
15654 #endif
15655             }
15656         }
15657
15658       /* UnixWare sets the entsize of .plt to 4, although that doesn't
15659          really seem like the right value.  */
15660       if (splt->output_section->owner == output_bfd)
15661         elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
15662
15663       if (htab->dt_tlsdesc_plt)
15664         {
15665           bfd_vma got_address
15666             = sgot->output_section->vma + sgot->output_offset;
15667           bfd_vma gotplt_address = (htab->root.sgot->output_section->vma
15668                                     + htab->root.sgot->output_offset);
15669           bfd_vma plt_address
15670             = splt->output_section->vma + splt->output_offset;
15671
15672           arm_put_trampoline (htab, output_bfd,
15673                               splt->contents + htab->dt_tlsdesc_plt,
15674                               dl_tlsdesc_lazy_trampoline, 6);
15675
15676           bfd_put_32 (output_bfd,
15677                       gotplt_address + htab->dt_tlsdesc_got
15678                       - (plt_address + htab->dt_tlsdesc_plt)
15679                       - dl_tlsdesc_lazy_trampoline[6],
15680                       splt->contents + htab->dt_tlsdesc_plt + 24);
15681           bfd_put_32 (output_bfd,
15682                       got_address - (plt_address + htab->dt_tlsdesc_plt)
15683                       - dl_tlsdesc_lazy_trampoline[7],
15684                       splt->contents + htab->dt_tlsdesc_plt + 24 + 4);
15685         }
15686
15687       if (htab->tls_trampoline)
15688         {
15689           arm_put_trampoline (htab, output_bfd,
15690                               splt->contents + htab->tls_trampoline,
15691                               tls_trampoline, 3);
15692 #ifdef FOUR_WORD_PLT
15693           bfd_put_32 (output_bfd, 0x00000000,
15694                       splt->contents + htab->tls_trampoline + 12);
15695 #endif
15696         }
15697
15698       if (htab->vxworks_p
15699           && !bfd_link_pic (info)
15700           && htab->root.splt->size > 0)
15701         {
15702           /* Correct the .rel(a).plt.unloaded relocations.  They will have
15703              incorrect symbol indexes.  */
15704           int num_plts;
15705           unsigned char *p;
15706
15707           num_plts = ((htab->root.splt->size - htab->plt_header_size)
15708                       / htab->plt_entry_size);
15709           p = htab->srelplt2->contents + RELOC_SIZE (htab);
15710
15711           for (; num_plts; num_plts--)
15712             {
15713               Elf_Internal_Rela rel;
15714
15715               SWAP_RELOC_IN (htab) (output_bfd, p, &rel);
15716               rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_ARM_ABS32);
15717               SWAP_RELOC_OUT (htab) (output_bfd, &rel, p);
15718               p += RELOC_SIZE (htab);
15719
15720               SWAP_RELOC_IN (htab) (output_bfd, p, &rel);
15721               rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_ARM_ABS32);
15722               SWAP_RELOC_OUT (htab) (output_bfd, &rel, p);
15723               p += RELOC_SIZE (htab);
15724             }
15725         }
15726     }
15727
15728   if (htab->nacl_p && htab->root.iplt != NULL && htab->root.iplt->size > 0)
15729     /* NaCl uses a special first entry in .iplt too.  */
15730     arm_nacl_put_plt0 (htab, output_bfd, htab->root.iplt, 0);
15731
15732   /* Fill in the first three entries in the global offset table.  */
15733   if (sgot)
15734     {
15735       if (sgot->size > 0)
15736         {
15737           if (sdyn == NULL)
15738             bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
15739           else
15740             bfd_put_32 (output_bfd,
15741                         sdyn->output_section->vma + sdyn->output_offset,
15742                         sgot->contents);
15743           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
15744           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
15745         }
15746
15747       elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
15748     }
15749
15750   return TRUE;
15751 }
15752
15753 static void
15754 elf32_arm_post_process_headers (bfd * abfd, struct bfd_link_info * link_info ATTRIBUTE_UNUSED)
15755 {
15756   Elf_Internal_Ehdr * i_ehdrp;  /* ELF file header, internal form.  */
15757   struct elf32_arm_link_hash_table *globals;
15758   struct elf_segment_map *m;
15759
15760   i_ehdrp = elf_elfheader (abfd);
15761
15762   if (EF_ARM_EABI_VERSION (i_ehdrp->e_flags) == EF_ARM_EABI_UNKNOWN)
15763     i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_ARM;
15764   else
15765     _bfd_elf_post_process_headers (abfd, link_info);
15766   i_ehdrp->e_ident[EI_ABIVERSION] = ARM_ELF_ABI_VERSION;
15767
15768   if (link_info)
15769     {
15770       globals = elf32_arm_hash_table (link_info);
15771       if (globals != NULL && globals->byteswap_code)
15772         i_ehdrp->e_flags |= EF_ARM_BE8;
15773     }
15774
15775   if (EF_ARM_EABI_VERSION (i_ehdrp->e_flags) == EF_ARM_EABI_VER5
15776       && ((i_ehdrp->e_type == ET_DYN) || (i_ehdrp->e_type == ET_EXEC)))
15777     {
15778       int abi = bfd_elf_get_obj_attr_int (abfd, OBJ_ATTR_PROC, Tag_ABI_VFP_args);
15779       if (abi == AEABI_VFP_args_vfp)
15780         i_ehdrp->e_flags |= EF_ARM_ABI_FLOAT_HARD;
15781       else
15782         i_ehdrp->e_flags |= EF_ARM_ABI_FLOAT_SOFT;
15783     }
15784
15785   /* Scan segment to set p_flags attribute if it contains only sections with
15786      SHF_ARM_NOREAD flag.  */
15787   for (m = elf_seg_map (abfd); m != NULL; m = m->next)
15788     {
15789       unsigned int j;
15790
15791       if (m->count == 0)
15792         continue;
15793       for (j = 0; j < m->count; j++)
15794         {
15795           if (!(elf_section_flags (m->sections[j]) & SHF_ARM_NOREAD))
15796             break;
15797         }
15798       if (j == m->count)
15799         {
15800           m->p_flags = PF_X;
15801           m->p_flags_valid = 1;
15802         }
15803     }
15804 }
15805
15806 static enum elf_reloc_type_class
15807 elf32_arm_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
15808                             const asection *rel_sec ATTRIBUTE_UNUSED,
15809                             const Elf_Internal_Rela *rela)
15810 {
15811   switch ((int) ELF32_R_TYPE (rela->r_info))
15812     {
15813     case R_ARM_RELATIVE:
15814       return reloc_class_relative;
15815     case R_ARM_JUMP_SLOT:
15816       return reloc_class_plt;
15817     case R_ARM_COPY:
15818       return reloc_class_copy;
15819     case R_ARM_IRELATIVE:
15820       return reloc_class_ifunc;
15821     default:
15822       return reloc_class_normal;
15823     }
15824 }
15825
15826 static void
15827 elf32_arm_final_write_processing (bfd *abfd, bfd_boolean linker ATTRIBUTE_UNUSED)
15828 {
15829   bfd_arm_update_notes (abfd, ARM_NOTE_SECTION);
15830 }
15831
15832 /* Return TRUE if this is an unwinding table entry.  */
15833
15834 static bfd_boolean
15835 is_arm_elf_unwind_section_name (bfd * abfd ATTRIBUTE_UNUSED, const char * name)
15836 {
15837   return (CONST_STRNEQ (name, ELF_STRING_ARM_unwind)
15838           || CONST_STRNEQ (name, ELF_STRING_ARM_unwind_once));
15839 }
15840
15841
15842 /* Set the type and flags for an ARM section.  We do this by
15843    the section name, which is a hack, but ought to work.  */
15844
15845 static bfd_boolean
15846 elf32_arm_fake_sections (bfd * abfd, Elf_Internal_Shdr * hdr, asection * sec)
15847 {
15848   const char * name;
15849
15850   name = bfd_get_section_name (abfd, sec);
15851
15852   if (is_arm_elf_unwind_section_name (abfd, name))
15853     {
15854       hdr->sh_type = SHT_ARM_EXIDX;
15855       hdr->sh_flags |= SHF_LINK_ORDER;
15856     }
15857
15858   if (sec->flags & SEC_ELF_NOREAD)
15859     hdr->sh_flags |= SHF_ARM_NOREAD;
15860
15861   return TRUE;
15862 }
15863
15864 /* Handle an ARM specific section when reading an object file.  This is
15865    called when bfd_section_from_shdr finds a section with an unknown
15866    type.  */
15867
15868 static bfd_boolean
15869 elf32_arm_section_from_shdr (bfd *abfd,
15870                              Elf_Internal_Shdr * hdr,
15871                              const char *name,
15872                              int shindex)
15873 {
15874   /* There ought to be a place to keep ELF backend specific flags, but
15875      at the moment there isn't one.  We just keep track of the
15876      sections by their name, instead.  Fortunately, the ABI gives
15877      names for all the ARM specific sections, so we will probably get
15878      away with this.  */
15879   switch (hdr->sh_type)
15880     {
15881     case SHT_ARM_EXIDX:
15882     case SHT_ARM_PREEMPTMAP:
15883     case SHT_ARM_ATTRIBUTES:
15884       break;
15885
15886     default:
15887       return FALSE;
15888     }
15889
15890   if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
15891     return FALSE;
15892
15893   return TRUE;
15894 }
15895
15896 static _arm_elf_section_data *
15897 get_arm_elf_section_data (asection * sec)
15898 {
15899   if (sec && sec->owner && is_arm_elf (sec->owner))
15900     return elf32_arm_section_data (sec);
15901   else
15902     return NULL;
15903 }
15904
15905 typedef struct
15906 {
15907   void *flaginfo;
15908   struct bfd_link_info *info;
15909   asection *sec;
15910   int sec_shndx;
15911   int (*func) (void *, const char *, Elf_Internal_Sym *,
15912                asection *, struct elf_link_hash_entry *);
15913 } output_arch_syminfo;
15914
15915 enum map_symbol_type
15916 {
15917   ARM_MAP_ARM,
15918   ARM_MAP_THUMB,
15919   ARM_MAP_DATA
15920 };
15921
15922
15923 /* Output a single mapping symbol.  */
15924
15925 static bfd_boolean
15926 elf32_arm_output_map_sym (output_arch_syminfo *osi,
15927                           enum map_symbol_type type,
15928                           bfd_vma offset)
15929 {
15930   static const char *names[3] = {"$a", "$t", "$d"};
15931   Elf_Internal_Sym sym;
15932
15933   sym.st_value = osi->sec->output_section->vma
15934                  + osi->sec->output_offset
15935                  + offset;
15936   sym.st_size = 0;
15937   sym.st_other = 0;
15938   sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_NOTYPE);
15939   sym.st_shndx = osi->sec_shndx;
15940   sym.st_target_internal = 0;
15941   elf32_arm_section_map_add (osi->sec, names[type][1], offset);
15942   return osi->func (osi->flaginfo, names[type], &sym, osi->sec, NULL) == 1;
15943 }
15944
15945 /* Output mapping symbols for the PLT entry described by ROOT_PLT and ARM_PLT.
15946    IS_IPLT_ENTRY_P says whether the PLT is in .iplt rather than .plt.  */
15947
15948 static bfd_boolean
15949 elf32_arm_output_plt_map_1 (output_arch_syminfo *osi,
15950                             bfd_boolean is_iplt_entry_p,
15951                             union gotplt_union *root_plt,
15952                             struct arm_plt_info *arm_plt)
15953 {
15954   struct elf32_arm_link_hash_table *htab;
15955   bfd_vma addr, plt_header_size;
15956
15957   if (root_plt->offset == (bfd_vma) -1)
15958     return TRUE;
15959
15960   htab = elf32_arm_hash_table (osi->info);
15961   if (htab == NULL)
15962     return FALSE;
15963
15964   if (is_iplt_entry_p)
15965     {
15966       osi->sec = htab->root.iplt;
15967       plt_header_size = 0;
15968     }
15969   else
15970     {
15971       osi->sec = htab->root.splt;
15972       plt_header_size = htab->plt_header_size;
15973     }
15974   osi->sec_shndx = (_bfd_elf_section_from_bfd_section
15975                     (osi->info->output_bfd, osi->sec->output_section));
15976
15977   addr = root_plt->offset & -2;
15978   if (htab->symbian_p)
15979     {
15980       if (!elf32_arm_output_map_sym (osi, ARM_MAP_ARM, addr))
15981         return FALSE;
15982       if (!elf32_arm_output_map_sym (osi, ARM_MAP_DATA, addr + 4))
15983         return FALSE;
15984     }
15985   else if (htab->vxworks_p)
15986     {
15987       if (!elf32_arm_output_map_sym (osi, ARM_MAP_ARM, addr))
15988         return FALSE;
15989       if (!elf32_arm_output_map_sym (osi, ARM_MAP_DATA, addr + 8))
15990         return FALSE;
15991       if (!elf32_arm_output_map_sym (osi, ARM_MAP_ARM, addr + 12))
15992         return FALSE;
15993       if (!elf32_arm_output_map_sym (osi, ARM_MAP_DATA, addr + 20))
15994         return FALSE;
15995     }
15996   else if (htab->nacl_p)
15997     {
15998       if (!elf32_arm_output_map_sym (osi, ARM_MAP_ARM, addr))
15999         return FALSE;
16000     }
16001   else if (using_thumb_only (htab))
16002     {
16003       if (!elf32_arm_output_map_sym (osi, ARM_MAP_THUMB, addr))
16004         return FALSE;
16005     }
16006   else
16007     {
16008       bfd_boolean thumb_stub_p;
16009
16010       thumb_stub_p = elf32_arm_plt_needs_thumb_stub_p (osi->info, arm_plt);
16011       if (thumb_stub_p)
16012         {
16013           if (!elf32_arm_output_map_sym (osi, ARM_MAP_THUMB, addr - 4))
16014             return FALSE;
16015         }
16016 #ifdef FOUR_WORD_PLT
16017       if (!elf32_arm_output_map_sym (osi, ARM_MAP_ARM, addr))
16018         return FALSE;
16019       if (!elf32_arm_output_map_sym (osi, ARM_MAP_DATA, addr + 12))
16020         return FALSE;
16021 #else
16022       /* A three-word PLT with no Thumb thunk contains only Arm code,
16023          so only need to output a mapping symbol for the first PLT entry and
16024          entries with thumb thunks.  */
16025       if (thumb_stub_p || addr == plt_header_size)
16026         {
16027           if (!elf32_arm_output_map_sym (osi, ARM_MAP_ARM, addr))
16028             return FALSE;
16029         }
16030 #endif
16031     }
16032
16033   return TRUE;
16034 }
16035
16036 /* Output mapping symbols for PLT entries associated with H.  */
16037
16038 static bfd_boolean
16039 elf32_arm_output_plt_map (struct elf_link_hash_entry *h, void *inf)
16040 {
16041   output_arch_syminfo *osi = (output_arch_syminfo *) inf;
16042   struct elf32_arm_link_hash_entry *eh;
16043
16044   if (h->root.type == bfd_link_hash_indirect)
16045     return TRUE;
16046
16047   if (h->root.type == bfd_link_hash_warning)
16048     /* When warning symbols are created, they **replace** the "real"
16049        entry in the hash table, thus we never get to see the real
16050        symbol in a hash traversal.  So look at it now.  */
16051     h = (struct elf_link_hash_entry *) h->root.u.i.link;
16052
16053   eh = (struct elf32_arm_link_hash_entry *) h;
16054   return elf32_arm_output_plt_map_1 (osi, SYMBOL_CALLS_LOCAL (osi->info, h),
16055                                      &h->plt, &eh->plt);
16056 }
16057
16058 /* Bind a veneered symbol to its veneer identified by its hash entry
16059    STUB_ENTRY.  The veneered location thus loose its symbol.  */
16060
16061 static void
16062 arm_stub_claim_sym (struct elf32_arm_stub_hash_entry *stub_entry)
16063 {
16064   struct elf32_arm_link_hash_entry *hash = stub_entry->h;
16065
16066   BFD_ASSERT (hash);
16067   hash->root.root.u.def.section = stub_entry->stub_sec;
16068   hash->root.root.u.def.value = stub_entry->stub_offset;
16069   hash->root.size = stub_entry->stub_size;
16070 }
16071
16072 /* Output a single local symbol for a generated stub.  */
16073
16074 static bfd_boolean
16075 elf32_arm_output_stub_sym (output_arch_syminfo *osi, const char *name,
16076                            bfd_vma offset, bfd_vma size)
16077 {
16078   Elf_Internal_Sym sym;
16079
16080   sym.st_value = osi->sec->output_section->vma
16081                  + osi->sec->output_offset
16082                  + offset;
16083   sym.st_size = size;
16084   sym.st_other = 0;
16085   sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
16086   sym.st_shndx = osi->sec_shndx;
16087   sym.st_target_internal = 0;
16088   return osi->func (osi->flaginfo, name, &sym, osi->sec, NULL) == 1;
16089 }
16090
16091 static bfd_boolean
16092 arm_map_one_stub (struct bfd_hash_entry * gen_entry,
16093                   void * in_arg)
16094 {
16095   struct elf32_arm_stub_hash_entry *stub_entry;
16096   asection *stub_sec;
16097   bfd_vma addr;
16098   char *stub_name;
16099   output_arch_syminfo *osi;
16100   const insn_sequence *template_sequence;
16101   enum stub_insn_type prev_type;
16102   int size;
16103   int i;
16104   enum map_symbol_type sym_type;
16105
16106   /* Massage our args to the form they really have.  */
16107   stub_entry = (struct elf32_arm_stub_hash_entry *) gen_entry;
16108   osi = (output_arch_syminfo *) in_arg;
16109
16110   stub_sec = stub_entry->stub_sec;
16111
16112   /* Ensure this stub is attached to the current section being
16113      processed.  */
16114   if (stub_sec != osi->sec)
16115     return TRUE;
16116
16117   addr = (bfd_vma) stub_entry->stub_offset;
16118   template_sequence = stub_entry->stub_template;
16119
16120   if (arm_stub_sym_claimed (stub_entry->stub_type))
16121     arm_stub_claim_sym (stub_entry);
16122   else
16123     {
16124       stub_name = stub_entry->output_name;
16125       switch (template_sequence[0].type)
16126         {
16127         case ARM_TYPE:
16128           if (!elf32_arm_output_stub_sym (osi, stub_name, addr,
16129                                           stub_entry->stub_size))
16130             return FALSE;
16131           break;
16132         case THUMB16_TYPE:
16133         case THUMB32_TYPE:
16134           if (!elf32_arm_output_stub_sym (osi, stub_name, addr | 1,
16135                                           stub_entry->stub_size))
16136             return FALSE;
16137           break;
16138         default:
16139           BFD_FAIL ();
16140           return 0;
16141         }
16142     }
16143
16144   prev_type = DATA_TYPE;
16145   size = 0;
16146   for (i = 0; i < stub_entry->stub_template_size; i++)
16147     {
16148       switch (template_sequence[i].type)
16149         {
16150         case ARM_TYPE:
16151           sym_type = ARM_MAP_ARM;
16152           break;
16153
16154         case THUMB16_TYPE:
16155         case THUMB32_TYPE:
16156           sym_type = ARM_MAP_THUMB;
16157           break;
16158
16159         case DATA_TYPE:
16160           sym_type = ARM_MAP_DATA;
16161           break;
16162
16163         default:
16164           BFD_FAIL ();
16165           return FALSE;
16166         }
16167
16168       if (template_sequence[i].type != prev_type)
16169         {
16170           prev_type = template_sequence[i].type;
16171           if (!elf32_arm_output_map_sym (osi, sym_type, addr + size))
16172             return FALSE;
16173         }
16174
16175       switch (template_sequence[i].type)
16176         {
16177         case ARM_TYPE:
16178         case THUMB32_TYPE:
16179           size += 4;
16180           break;
16181
16182         case THUMB16_TYPE:
16183           size += 2;
16184           break;
16185
16186         case DATA_TYPE:
16187           size += 4;
16188           break;
16189
16190         default:
16191           BFD_FAIL ();
16192           return FALSE;
16193         }
16194     }
16195
16196   return TRUE;
16197 }
16198
16199 /* Output mapping symbols for linker generated sections,
16200    and for those data-only sections that do not have a
16201    $d.  */
16202
16203 static bfd_boolean
16204 elf32_arm_output_arch_local_syms (bfd *output_bfd,
16205                                   struct bfd_link_info *info,
16206                                   void *flaginfo,
16207                                   int (*func) (void *, const char *,
16208                                                Elf_Internal_Sym *,
16209                                                asection *,
16210                                                struct elf_link_hash_entry *))
16211 {
16212   output_arch_syminfo osi;
16213   struct elf32_arm_link_hash_table *htab;
16214   bfd_vma offset;
16215   bfd_size_type size;
16216   bfd *input_bfd;
16217
16218   htab = elf32_arm_hash_table (info);
16219   if (htab == NULL)
16220     return FALSE;
16221
16222   check_use_blx (htab);
16223
16224   osi.flaginfo = flaginfo;
16225   osi.info = info;
16226   osi.func = func;
16227
16228   /* Add a $d mapping symbol to data-only sections that
16229      don't have any mapping symbol.  This may result in (harmless) redundant
16230      mapping symbols.  */
16231   for (input_bfd = info->input_bfds;
16232        input_bfd != NULL;
16233        input_bfd = input_bfd->link.next)
16234     {
16235       if ((input_bfd->flags & (BFD_LINKER_CREATED | HAS_SYMS)) == HAS_SYMS)
16236         for (osi.sec = input_bfd->sections;
16237              osi.sec != NULL;
16238              osi.sec = osi.sec->next)
16239           {
16240             if (osi.sec->output_section != NULL
16241                 && ((osi.sec->output_section->flags & (SEC_ALLOC | SEC_CODE))
16242                     != 0)
16243                 && (osi.sec->flags & (SEC_HAS_CONTENTS | SEC_LINKER_CREATED))
16244                    == SEC_HAS_CONTENTS
16245                 && get_arm_elf_section_data (osi.sec) != NULL
16246                 && get_arm_elf_section_data (osi.sec)->mapcount == 0
16247                 && osi.sec->size > 0
16248                 && (osi.sec->flags & SEC_EXCLUDE) == 0)
16249               {
16250                 osi.sec_shndx = _bfd_elf_section_from_bfd_section
16251                   (output_bfd, osi.sec->output_section);
16252                 if (osi.sec_shndx != (int)SHN_BAD)
16253                   elf32_arm_output_map_sym (&osi, ARM_MAP_DATA, 0);
16254               }
16255           }
16256     }
16257
16258   /* ARM->Thumb glue.  */
16259   if (htab->arm_glue_size > 0)
16260     {
16261       osi.sec = bfd_get_linker_section (htab->bfd_of_glue_owner,
16262                                         ARM2THUMB_GLUE_SECTION_NAME);
16263
16264       osi.sec_shndx = _bfd_elf_section_from_bfd_section
16265           (output_bfd, osi.sec->output_section);
16266       if (bfd_link_pic (info) || htab->root.is_relocatable_executable
16267           || htab->pic_veneer)
16268         size = ARM2THUMB_PIC_GLUE_SIZE;
16269       else if (htab->use_blx)
16270         size = ARM2THUMB_V5_STATIC_GLUE_SIZE;
16271       else
16272         size = ARM2THUMB_STATIC_GLUE_SIZE;
16273
16274       for (offset = 0; offset < htab->arm_glue_size; offset += size)
16275         {
16276           elf32_arm_output_map_sym (&osi, ARM_MAP_ARM, offset);
16277           elf32_arm_output_map_sym (&osi, ARM_MAP_DATA, offset + size - 4);
16278         }
16279     }
16280
16281   /* Thumb->ARM glue.  */
16282   if (htab->thumb_glue_size > 0)
16283     {
16284       osi.sec = bfd_get_linker_section (htab->bfd_of_glue_owner,
16285                                         THUMB2ARM_GLUE_SECTION_NAME);
16286
16287       osi.sec_shndx = _bfd_elf_section_from_bfd_section
16288           (output_bfd, osi.sec->output_section);
16289       size = THUMB2ARM_GLUE_SIZE;
16290
16291       for (offset = 0; offset < htab->thumb_glue_size; offset += size)
16292         {
16293           elf32_arm_output_map_sym (&osi, ARM_MAP_THUMB, offset);
16294           elf32_arm_output_map_sym (&osi, ARM_MAP_ARM, offset + 4);
16295         }
16296     }
16297
16298   /* ARMv4 BX veneers.  */
16299   if (htab->bx_glue_size > 0)
16300     {
16301       osi.sec = bfd_get_linker_section (htab->bfd_of_glue_owner,
16302                                         ARM_BX_GLUE_SECTION_NAME);
16303
16304       osi.sec_shndx = _bfd_elf_section_from_bfd_section
16305           (output_bfd, osi.sec->output_section);
16306
16307       elf32_arm_output_map_sym (&osi, ARM_MAP_ARM, 0);
16308     }
16309
16310   /* Long calls stubs.  */
16311   if (htab->stub_bfd && htab->stub_bfd->sections)
16312     {
16313       asection* stub_sec;
16314
16315       for (stub_sec = htab->stub_bfd->sections;
16316            stub_sec != NULL;
16317            stub_sec = stub_sec->next)
16318         {
16319           /* Ignore non-stub sections.  */
16320           if (!strstr (stub_sec->name, STUB_SUFFIX))
16321             continue;
16322
16323           osi.sec = stub_sec;
16324
16325           osi.sec_shndx = _bfd_elf_section_from_bfd_section
16326             (output_bfd, osi.sec->output_section);
16327
16328           bfd_hash_traverse (&htab->stub_hash_table, arm_map_one_stub, &osi);
16329         }
16330     }
16331
16332   /* Finally, output mapping symbols for the PLT.  */
16333   if (htab->root.splt && htab->root.splt->size > 0)
16334     {
16335       osi.sec = htab->root.splt;
16336       osi.sec_shndx = (_bfd_elf_section_from_bfd_section
16337                        (output_bfd, osi.sec->output_section));
16338
16339       /* Output mapping symbols for the plt header.  SymbianOS does not have a
16340          plt header.  */
16341       if (htab->vxworks_p)
16342         {
16343           /* VxWorks shared libraries have no PLT header.  */
16344           if (!bfd_link_pic (info))
16345             {
16346               if (!elf32_arm_output_map_sym (&osi, ARM_MAP_ARM, 0))
16347                 return FALSE;
16348               if (!elf32_arm_output_map_sym (&osi, ARM_MAP_DATA, 12))
16349                 return FALSE;
16350             }
16351         }
16352       else if (htab->nacl_p)
16353         {
16354           if (!elf32_arm_output_map_sym (&osi, ARM_MAP_ARM, 0))
16355             return FALSE;
16356         }
16357       else if (using_thumb_only (htab))
16358         {
16359           if (!elf32_arm_output_map_sym (&osi, ARM_MAP_THUMB, 0))
16360             return FALSE;
16361           if (!elf32_arm_output_map_sym (&osi, ARM_MAP_DATA, 12))
16362             return FALSE;
16363           if (!elf32_arm_output_map_sym (&osi, ARM_MAP_THUMB, 16))
16364             return FALSE;
16365         }
16366       else if (!htab->symbian_p)
16367         {
16368           if (!elf32_arm_output_map_sym (&osi, ARM_MAP_ARM, 0))
16369             return FALSE;
16370 #ifndef FOUR_WORD_PLT
16371           if (!elf32_arm_output_map_sym (&osi, ARM_MAP_DATA, 16))
16372             return FALSE;
16373 #endif
16374         }
16375     }
16376   if (htab->nacl_p && htab->root.iplt && htab->root.iplt->size > 0)
16377     {
16378       /* NaCl uses a special first entry in .iplt too.  */
16379       osi.sec = htab->root.iplt;
16380       osi.sec_shndx = (_bfd_elf_section_from_bfd_section
16381                        (output_bfd, osi.sec->output_section));
16382       if (!elf32_arm_output_map_sym (&osi, ARM_MAP_ARM, 0))
16383         return FALSE;
16384     }
16385   if ((htab->root.splt && htab->root.splt->size > 0)
16386       || (htab->root.iplt && htab->root.iplt->size > 0))
16387     {
16388       elf_link_hash_traverse (&htab->root, elf32_arm_output_plt_map, &osi);
16389       for (input_bfd = info->input_bfds;
16390            input_bfd != NULL;
16391            input_bfd = input_bfd->link.next)
16392         {
16393           struct arm_local_iplt_info **local_iplt;
16394           unsigned int i, num_syms;
16395
16396           local_iplt = elf32_arm_local_iplt (input_bfd);
16397           if (local_iplt != NULL)
16398             {
16399               num_syms = elf_symtab_hdr (input_bfd).sh_info;
16400               for (i = 0; i < num_syms; i++)
16401                 if (local_iplt[i] != NULL
16402                     && !elf32_arm_output_plt_map_1 (&osi, TRUE,
16403                                                     &local_iplt[i]->root,
16404                                                     &local_iplt[i]->arm))
16405                   return FALSE;
16406             }
16407         }
16408     }
16409   if (htab->dt_tlsdesc_plt != 0)
16410     {
16411       /* Mapping symbols for the lazy tls trampoline.  */
16412       if (!elf32_arm_output_map_sym (&osi, ARM_MAP_ARM, htab->dt_tlsdesc_plt))
16413         return FALSE;
16414
16415       if (!elf32_arm_output_map_sym (&osi, ARM_MAP_DATA,
16416                                      htab->dt_tlsdesc_plt + 24))
16417         return FALSE;
16418     }
16419   if (htab->tls_trampoline != 0)
16420     {
16421       /* Mapping symbols for the tls trampoline.  */
16422       if (!elf32_arm_output_map_sym (&osi, ARM_MAP_ARM, htab->tls_trampoline))
16423         return FALSE;
16424 #ifdef FOUR_WORD_PLT
16425       if (!elf32_arm_output_map_sym (&osi, ARM_MAP_DATA,
16426                                      htab->tls_trampoline + 12))
16427         return FALSE;
16428 #endif
16429     }
16430
16431   return TRUE;
16432 }
16433
16434 /* Allocate target specific section data.  */
16435
16436 static bfd_boolean
16437 elf32_arm_new_section_hook (bfd *abfd, asection *sec)
16438 {
16439   if (!sec->used_by_bfd)
16440     {
16441       _arm_elf_section_data *sdata;
16442       bfd_size_type amt = sizeof (*sdata);
16443
16444       sdata = (_arm_elf_section_data *) bfd_zalloc (abfd, amt);
16445       if (sdata == NULL)
16446         return FALSE;
16447       sec->used_by_bfd = sdata;
16448     }
16449
16450   return _bfd_elf_new_section_hook (abfd, sec);
16451 }
16452
16453
16454 /* Used to order a list of mapping symbols by address.  */
16455
16456 static int
16457 elf32_arm_compare_mapping (const void * a, const void * b)
16458 {
16459   const elf32_arm_section_map *amap = (const elf32_arm_section_map *) a;
16460   const elf32_arm_section_map *bmap = (const elf32_arm_section_map *) b;
16461
16462   if (amap->vma > bmap->vma)
16463     return 1;
16464   else if (amap->vma < bmap->vma)
16465     return -1;
16466   else if (amap->type > bmap->type)
16467     /* Ensure results do not depend on the host qsort for objects with
16468        multiple mapping symbols at the same address by sorting on type
16469        after vma.  */
16470     return 1;
16471   else if (amap->type < bmap->type)
16472     return -1;
16473   else
16474     return 0;
16475 }
16476
16477 /* Add OFFSET to lower 31 bits of ADDR, leaving other bits unmodified.  */
16478
16479 static unsigned long
16480 offset_prel31 (unsigned long addr, bfd_vma offset)
16481 {
16482   return (addr & ~0x7ffffffful) | ((addr + offset) & 0x7ffffffful);
16483 }
16484
16485 /* Copy an .ARM.exidx table entry, adding OFFSET to (applied) PREL31
16486    relocations.  */
16487
16488 static void
16489 copy_exidx_entry (bfd *output_bfd, bfd_byte *to, bfd_byte *from, bfd_vma offset)
16490 {
16491   unsigned long first_word = bfd_get_32 (output_bfd, from);
16492   unsigned long second_word = bfd_get_32 (output_bfd, from + 4);
16493
16494   /* High bit of first word is supposed to be zero.  */
16495   if ((first_word & 0x80000000ul) == 0)
16496     first_word = offset_prel31 (first_word, offset);
16497
16498   /* If the high bit of the first word is clear, and the bit pattern is not 0x1
16499      (EXIDX_CANTUNWIND), this is an offset to an .ARM.extab entry.  */
16500   if ((second_word != 0x1) && ((second_word & 0x80000000ul) == 0))
16501     second_word = offset_prel31 (second_word, offset);
16502
16503   bfd_put_32 (output_bfd, first_word, to);
16504   bfd_put_32 (output_bfd, second_word, to + 4);
16505 }
16506
16507 /* Data for make_branch_to_a8_stub().  */
16508
16509 struct a8_branch_to_stub_data
16510 {
16511   asection *writing_section;
16512   bfd_byte *contents;
16513 };
16514
16515
16516 /* Helper to insert branches to Cortex-A8 erratum stubs in the right
16517    places for a particular section.  */
16518
16519 static bfd_boolean
16520 make_branch_to_a8_stub (struct bfd_hash_entry *gen_entry,
16521                        void *in_arg)
16522 {
16523   struct elf32_arm_stub_hash_entry *stub_entry;
16524   struct a8_branch_to_stub_data *data;
16525   bfd_byte *contents;
16526   unsigned long branch_insn;
16527   bfd_vma veneered_insn_loc, veneer_entry_loc;
16528   bfd_signed_vma branch_offset;
16529   bfd *abfd;
16530   unsigned int loc;
16531
16532   stub_entry = (struct elf32_arm_stub_hash_entry *) gen_entry;
16533   data = (struct a8_branch_to_stub_data *) in_arg;
16534
16535   if (stub_entry->target_section != data->writing_section
16536       || stub_entry->stub_type < arm_stub_a8_veneer_lwm)
16537     return TRUE;
16538
16539   contents = data->contents;
16540
16541   /* We use target_section as Cortex-A8 erratum workaround stubs are only
16542      generated when both source and target are in the same section.  */
16543   veneered_insn_loc = stub_entry->target_section->output_section->vma
16544                       + stub_entry->target_section->output_offset
16545                       + stub_entry->source_value;
16546
16547   veneer_entry_loc = stub_entry->stub_sec->output_section->vma
16548                      + stub_entry->stub_sec->output_offset
16549                      + stub_entry->stub_offset;
16550
16551   if (stub_entry->stub_type == arm_stub_a8_veneer_blx)
16552     veneered_insn_loc &= ~3u;
16553
16554   branch_offset = veneer_entry_loc - veneered_insn_loc - 4;
16555
16556   abfd = stub_entry->target_section->owner;
16557   loc = stub_entry->source_value;
16558
16559   /* We attempt to avoid this condition by setting stubs_always_after_branch
16560      in elf32_arm_size_stubs if we've enabled the Cortex-A8 erratum workaround.
16561      This check is just to be on the safe side...  */
16562   if ((veneered_insn_loc & ~0xfff) == (veneer_entry_loc & ~0xfff))
16563     {
16564       (*_bfd_error_handler) (_("%B: error: Cortex-A8 erratum stub is "
16565                                "allocated in unsafe location"), abfd);
16566       return FALSE;
16567     }
16568
16569   switch (stub_entry->stub_type)
16570     {
16571     case arm_stub_a8_veneer_b:
16572     case arm_stub_a8_veneer_b_cond:
16573       branch_insn = 0xf0009000;
16574       goto jump24;
16575
16576     case arm_stub_a8_veneer_blx:
16577       branch_insn = 0xf000e800;
16578       goto jump24;
16579
16580     case arm_stub_a8_veneer_bl:
16581       {
16582         unsigned int i1, j1, i2, j2, s;
16583
16584         branch_insn = 0xf000d000;
16585
16586       jump24:
16587         if (branch_offset < -16777216 || branch_offset > 16777214)
16588           {
16589             /* There's not much we can do apart from complain if this
16590                happens.  */
16591             (*_bfd_error_handler) (_("%B: error: Cortex-A8 erratum stub out "
16592                                      "of range (input file too large)"), abfd);
16593             return FALSE;
16594           }
16595
16596         /* i1 = not(j1 eor s), so:
16597            not i1 = j1 eor s
16598            j1 = (not i1) eor s.  */
16599
16600         branch_insn |= (branch_offset >> 1) & 0x7ff;
16601         branch_insn |= ((branch_offset >> 12) & 0x3ff) << 16;
16602         i2 = (branch_offset >> 22) & 1;
16603         i1 = (branch_offset >> 23) & 1;
16604         s = (branch_offset >> 24) & 1;
16605         j1 = (!i1) ^ s;
16606         j2 = (!i2) ^ s;
16607         branch_insn |= j2 << 11;
16608         branch_insn |= j1 << 13;
16609         branch_insn |= s << 26;
16610       }
16611       break;
16612
16613     default:
16614       BFD_FAIL ();
16615       return FALSE;
16616     }
16617
16618   bfd_put_16 (abfd, (branch_insn >> 16) & 0xffff, &contents[loc]);
16619   bfd_put_16 (abfd, branch_insn & 0xffff, &contents[loc + 2]);
16620
16621   return TRUE;
16622 }
16623
16624 /* Beginning of stm32l4xx work-around.  */
16625
16626 /* Functions encoding instructions necessary for the emission of the
16627    fix-stm32l4xx-629360.
16628    Encoding is extracted from the
16629    ARM (C) Architecture Reference Manual
16630    ARMv7-A and ARMv7-R edition
16631    ARM DDI 0406C.b (ID072512).  */
16632
16633 static inline bfd_vma
16634 create_instruction_branch_absolute (int branch_offset)
16635 {
16636   /* A8.8.18 B (A8-334)
16637      B target_address (Encoding T4).  */
16638   /* 1111 - 0Sii - iiii - iiii - 10J1 - Jiii - iiii - iiii.  */
16639   /* jump offset is:  S:I1:I2:imm10:imm11:0.  */
16640   /* with : I1 = NOT (J1 EOR S) I2 = NOT (J2 EOR S).  */
16641
16642   int s = ((branch_offset & 0x1000000) >> 24);
16643   int j1 = s ^ !((branch_offset & 0x800000) >> 23);
16644   int j2 = s ^ !((branch_offset & 0x400000) >> 22);
16645
16646   if (branch_offset < -(1 << 24) || branch_offset >= (1 << 24))
16647     BFD_ASSERT (0 && "Error: branch out of range.  Cannot create branch.");
16648
16649   bfd_vma patched_inst = 0xf0009000
16650     | s << 26 /* S.  */
16651     | (((unsigned long) (branch_offset) >> 12) & 0x3ff) << 16 /* imm10.  */
16652     | j1 << 13 /* J1.  */
16653     | j2 << 11 /* J2.  */
16654     | (((unsigned long) (branch_offset) >> 1) & 0x7ff); /* imm11.  */
16655
16656   return patched_inst;
16657 }
16658
16659 static inline bfd_vma
16660 create_instruction_ldmia (int base_reg, int wback, int reg_mask)
16661 {
16662   /* A8.8.57 LDM/LDMIA/LDMFD (A8-396)
16663      LDMIA Rn!, {Ra, Rb, Rc, ...} (Encoding T2).  */
16664   bfd_vma patched_inst = 0xe8900000
16665     | (/*W=*/wback << 21)
16666     | (base_reg << 16)
16667     | (reg_mask & 0x0000ffff);
16668
16669   return patched_inst;
16670 }
16671
16672 static inline bfd_vma
16673 create_instruction_ldmdb (int base_reg, int wback, int reg_mask)
16674 {
16675   /* A8.8.60 LDMDB/LDMEA (A8-402)
16676      LDMDB Rn!, {Ra, Rb, Rc, ...} (Encoding T1).  */
16677   bfd_vma patched_inst = 0xe9100000
16678     | (/*W=*/wback << 21)
16679     | (base_reg << 16)
16680     | (reg_mask & 0x0000ffff);
16681
16682   return patched_inst;
16683 }
16684
16685 static inline bfd_vma
16686 create_instruction_mov (int target_reg, int source_reg)
16687 {
16688   /* A8.8.103 MOV (register) (A8-486)
16689      MOV Rd, Rm (Encoding T1).  */
16690   bfd_vma patched_inst = 0x4600
16691     | (target_reg & 0x7)
16692     | ((target_reg & 0x8) >> 3) << 7
16693     | (source_reg << 3);
16694
16695   return patched_inst;
16696 }
16697
16698 static inline bfd_vma
16699 create_instruction_sub (int target_reg, int source_reg, int value)
16700 {
16701   /* A8.8.221 SUB (immediate) (A8-708)
16702      SUB Rd, Rn, #value (Encoding T3).  */
16703   bfd_vma patched_inst = 0xf1a00000
16704     | (target_reg << 8)
16705     | (source_reg << 16)
16706     | (/*S=*/0 << 20)
16707     | ((value & 0x800) >> 11) << 26
16708     | ((value & 0x700) >>  8) << 12
16709     | (value & 0x0ff);
16710
16711   return patched_inst;
16712 }
16713
16714 static inline bfd_vma
16715 create_instruction_vldmia (int base_reg, int is_dp, int wback, int num_words,
16716                            int first_reg)
16717 {
16718   /* A8.8.332 VLDM (A8-922)
16719      VLMD{MODE} Rn{!}, {list} (Encoding T1 or T2).  */
16720   bfd_vma patched_inst = (is_dp ? 0xec900b00 : 0xec900a00)
16721     | (/*W=*/wback << 21)
16722     | (base_reg << 16)
16723     | (num_words & 0x000000ff)
16724     | (((unsigned)first_reg >> 1) & 0x0000000f) << 12
16725     | (first_reg & 0x00000001) << 22;
16726
16727   return patched_inst;
16728 }
16729
16730 static inline bfd_vma
16731 create_instruction_vldmdb (int base_reg, int is_dp, int num_words,
16732                            int first_reg)
16733 {
16734   /* A8.8.332 VLDM (A8-922)
16735      VLMD{MODE} Rn!, {} (Encoding T1 or T2).  */
16736   bfd_vma patched_inst = (is_dp ? 0xed300b00 : 0xed300a00)
16737     | (base_reg << 16)
16738     | (num_words & 0x000000ff)
16739     | (((unsigned)first_reg >>1 ) & 0x0000000f) << 12
16740     | (first_reg & 0x00000001) << 22;
16741
16742   return patched_inst;
16743 }
16744
16745 static inline bfd_vma
16746 create_instruction_udf_w (int value)
16747 {
16748   /* A8.8.247 UDF (A8-758)
16749      Undefined (Encoding T2).  */
16750   bfd_vma patched_inst = 0xf7f0a000
16751     | (value & 0x00000fff)
16752     | (value & 0x000f0000) << 16;
16753
16754   return patched_inst;
16755 }
16756
16757 static inline bfd_vma
16758 create_instruction_udf (int value)
16759 {
16760   /* A8.8.247 UDF (A8-758)
16761      Undefined (Encoding T1).  */
16762   bfd_vma patched_inst = 0xde00
16763     | (value & 0xff);
16764
16765   return patched_inst;
16766 }
16767
16768 /* Functions writing an instruction in memory, returning the next
16769    memory position to write to.  */
16770
16771 static inline bfd_byte *
16772 push_thumb2_insn32 (struct elf32_arm_link_hash_table * htab,
16773                     bfd * output_bfd, bfd_byte *pt, insn32 insn)
16774 {
16775   put_thumb2_insn (htab, output_bfd, insn, pt);
16776   return pt + 4;
16777 }
16778
16779 static inline bfd_byte *
16780 push_thumb2_insn16 (struct elf32_arm_link_hash_table * htab,
16781                     bfd * output_bfd, bfd_byte *pt, insn32 insn)
16782 {
16783   put_thumb_insn (htab, output_bfd, insn, pt);
16784   return pt + 2;
16785 }
16786
16787 /* Function filling up a region in memory with T1 and T2 UDFs taking
16788    care of alignment.  */
16789
16790 static bfd_byte *
16791 stm32l4xx_fill_stub_udf (struct elf32_arm_link_hash_table * htab,
16792                          bfd *                   output_bfd,
16793                          const bfd_byte * const  base_stub_contents,
16794                          bfd_byte * const        from_stub_contents,
16795                          const bfd_byte * const  end_stub_contents)
16796 {
16797   bfd_byte *current_stub_contents = from_stub_contents;
16798
16799   /* Fill the remaining of the stub with deterministic contents : UDF
16800      instructions.
16801      Check if realignment is needed on modulo 4 frontier using T1, to
16802      further use T2.  */
16803   if ((current_stub_contents < end_stub_contents)
16804       && !((current_stub_contents - base_stub_contents) % 2)
16805       && ((current_stub_contents - base_stub_contents) % 4))
16806     current_stub_contents =
16807       push_thumb2_insn16 (htab, output_bfd, current_stub_contents,
16808                           create_instruction_udf (0));
16809
16810   for (; current_stub_contents < end_stub_contents;)
16811     current_stub_contents =
16812       push_thumb2_insn32 (htab, output_bfd, current_stub_contents,
16813                           create_instruction_udf_w (0));
16814
16815   return current_stub_contents;
16816 }
16817
16818 /* Functions writing the stream of instructions equivalent to the
16819    derived sequence for ldmia, ldmdb, vldm respectively.  */
16820
16821 static void
16822 stm32l4xx_create_replacing_stub_ldmia (struct elf32_arm_link_hash_table * htab,
16823                                        bfd * output_bfd,
16824                                        const insn32 initial_insn,
16825                                        const bfd_byte *const initial_insn_addr,
16826                                        bfd_byte *const base_stub_contents)
16827 {
16828   int wback = (initial_insn & 0x00200000) >> 21;
16829   int ri, rn = (initial_insn & 0x000F0000) >> 16;
16830   int insn_all_registers = initial_insn & 0x0000ffff;
16831   int insn_low_registers, insn_high_registers;
16832   int usable_register_mask;
16833   int nb_registers = popcount (insn_all_registers);
16834   int restore_pc = (insn_all_registers & (1 << 15)) ? 1 : 0;
16835   int restore_rn = (insn_all_registers & (1 << rn)) ? 1 : 0;
16836   bfd_byte *current_stub_contents = base_stub_contents;
16837
16838   BFD_ASSERT (is_thumb2_ldmia (initial_insn));
16839
16840   /* In BFD_ARM_STM32L4XX_FIX_ALL mode we may have to deal with
16841      smaller than 8 registers load sequences that do not cause the
16842      hardware issue.  */
16843   if (nb_registers <= 8)
16844     {
16845       /* UNTOUCHED : LDMIA Rn{!}, {R-all-register-list}.  */
16846       current_stub_contents =
16847         push_thumb2_insn32 (htab, output_bfd, current_stub_contents,
16848                             initial_insn);
16849
16850       /* B initial_insn_addr+4.  */
16851       if (!restore_pc)
16852         current_stub_contents =
16853           push_thumb2_insn32 (htab, output_bfd, current_stub_contents,
16854                               create_instruction_branch_absolute
16855                               (initial_insn_addr - current_stub_contents));
16856
16857
16858       /* Fill the remaining of the stub with deterministic contents.  */
16859       current_stub_contents =
16860         stm32l4xx_fill_stub_udf (htab, output_bfd,
16861                                  base_stub_contents, current_stub_contents,
16862                                  base_stub_contents +
16863                                  STM32L4XX_ERRATUM_LDM_VENEER_SIZE);
16864
16865       return;
16866     }
16867
16868   /* - reg_list[13] == 0.  */
16869   BFD_ASSERT ((insn_all_registers & (1 << 13))==0);
16870
16871   /* - reg_list[14] & reg_list[15] != 1.  */
16872   BFD_ASSERT ((insn_all_registers & 0xC000) != 0xC000);
16873
16874   /* - if (wback==1) reg_list[rn] == 0.  */
16875   BFD_ASSERT (!wback || !restore_rn);
16876
16877   /* - nb_registers > 8.  */
16878   BFD_ASSERT (popcount (insn_all_registers) > 8);
16879
16880   /* At this point, LDMxx initial insn loads between 9 and 14 registers.  */
16881
16882   /* In the following algorithm, we split this wide LDM using 2 LDM insns:
16883     - One with the 7 lowest registers (register mask 0x007F)
16884       This LDM will finally contain between 2 and 7 registers
16885     - One with the 7 highest registers (register mask 0xDF80)
16886       This ldm will finally contain between 2 and 7 registers.  */
16887   insn_low_registers = insn_all_registers & 0x007F;
16888   insn_high_registers = insn_all_registers & 0xDF80;
16889
16890   /* A spare register may be needed during this veneer to temporarily
16891      handle the base register.  This register will be restored with the
16892      last LDM operation.
16893      The usable register may be any general purpose register (that
16894      excludes PC, SP, LR : register mask is 0x1FFF).  */
16895   usable_register_mask = 0x1FFF;
16896
16897   /* Generate the stub function.  */
16898   if (wback)
16899     {
16900       /* LDMIA Rn!, {R-low-register-list} : (Encoding T2).  */
16901       current_stub_contents =
16902         push_thumb2_insn32 (htab, output_bfd, current_stub_contents,
16903                             create_instruction_ldmia
16904                             (rn, /*wback=*/1, insn_low_registers));
16905
16906       /* LDMIA Rn!, {R-high-register-list} : (Encoding T2).  */
16907       current_stub_contents =
16908         push_thumb2_insn32 (htab, output_bfd, current_stub_contents,
16909                             create_instruction_ldmia
16910                             (rn, /*wback=*/1, insn_high_registers));
16911       if (!restore_pc)
16912         {
16913           /* B initial_insn_addr+4.  */
16914           current_stub_contents =
16915             push_thumb2_insn32 (htab, output_bfd, current_stub_contents,
16916                                 create_instruction_branch_absolute
16917                                 (initial_insn_addr - current_stub_contents));
16918        }
16919     }
16920   else /* if (!wback).  */
16921     {
16922       ri = rn;
16923
16924       /* If Rn is not part of the high-register-list, move it there.  */
16925       if (!(insn_high_registers & (1 << rn)))
16926         {
16927           /* Choose a Ri in the high-register-list that will be restored.  */
16928           ri = ctz (insn_high_registers & usable_register_mask & ~(1 << rn));
16929
16930           /* MOV Ri, Rn.  */
16931           current_stub_contents =
16932             push_thumb2_insn16 (htab, output_bfd, current_stub_contents,
16933                                 create_instruction_mov (ri, rn));
16934         }
16935
16936       /* LDMIA Ri!, {R-low-register-list} : (Encoding T2).  */
16937       current_stub_contents =
16938         push_thumb2_insn32 (htab, output_bfd, current_stub_contents,
16939                             create_instruction_ldmia
16940                             (ri, /*wback=*/1, insn_low_registers));
16941
16942       /* LDMIA Ri, {R-high-register-list} : (Encoding T2).  */
16943       current_stub_contents =
16944         push_thumb2_insn32 (htab, output_bfd, current_stub_contents,
16945                             create_instruction_ldmia
16946                             (ri, /*wback=*/0, insn_high_registers));
16947
16948       if (!restore_pc)
16949         {
16950           /* B initial_insn_addr+4.  */
16951           current_stub_contents =
16952             push_thumb2_insn32 (htab, output_bfd, current_stub_contents,
16953                                 create_instruction_branch_absolute
16954                                 (initial_insn_addr - current_stub_contents));
16955         }
16956     }
16957
16958   /* Fill the remaining of the stub with deterministic contents.  */
16959   current_stub_contents =
16960     stm32l4xx_fill_stub_udf (htab, output_bfd,
16961                              base_stub_contents, current_stub_contents,
16962                              base_stub_contents +
16963                              STM32L4XX_ERRATUM_LDM_VENEER_SIZE);
16964 }
16965
16966 static void
16967 stm32l4xx_create_replacing_stub_ldmdb (struct elf32_arm_link_hash_table * htab,
16968                                        bfd * output_bfd,
16969                                        const insn32 initial_insn,
16970                                        const bfd_byte *const initial_insn_addr,
16971                                        bfd_byte *const base_stub_contents)
16972 {
16973   int wback = (initial_insn & 0x00200000) >> 21;
16974   int ri, rn = (initial_insn & 0x000f0000) >> 16;
16975   int insn_all_registers = initial_insn & 0x0000ffff;
16976   int insn_low_registers, insn_high_registers;
16977   int usable_register_mask;
16978   int restore_pc = (insn_all_registers & (1 << 15)) ? 1 : 0;
16979   int restore_rn = (insn_all_registers & (1 << rn)) ? 1 : 0;
16980   int nb_registers = popcount (insn_all_registers);
16981   bfd_byte *current_stub_contents = base_stub_contents;
16982
16983   BFD_ASSERT (is_thumb2_ldmdb (initial_insn));
16984
16985   /* In BFD_ARM_STM32L4XX_FIX_ALL mode we may have to deal with
16986      smaller than 8 registers load sequences that do not cause the
16987      hardware issue.  */
16988   if (nb_registers <= 8)
16989     {
16990       /* UNTOUCHED : LDMIA Rn{!}, {R-all-register-list}.  */
16991       current_stub_contents =
16992         push_thumb2_insn32 (htab, output_bfd, current_stub_contents,
16993                             initial_insn);
16994
16995       /* B initial_insn_addr+4.  */
16996       current_stub_contents =
16997         push_thumb2_insn32 (htab, output_bfd, current_stub_contents,
16998                             create_instruction_branch_absolute
16999                             (initial_insn_addr - current_stub_contents));
17000
17001       /* Fill the remaining of the stub with deterministic contents.  */
17002       current_stub_contents =
17003         stm32l4xx_fill_stub_udf (htab, output_bfd,
17004                                  base_stub_contents, current_stub_contents,
17005                                  base_stub_contents +
17006                                  STM32L4XX_ERRATUM_LDM_VENEER_SIZE);
17007
17008       return;
17009     }
17010
17011   /* - reg_list[13] == 0.  */
17012   BFD_ASSERT ((insn_all_registers & (1 << 13)) == 0);
17013
17014   /* - reg_list[14] & reg_list[15] != 1.  */
17015   BFD_ASSERT ((insn_all_registers & 0xC000) != 0xC000);
17016
17017   /* - if (wback==1) reg_list[rn] == 0.  */
17018   BFD_ASSERT (!wback || !restore_rn);
17019
17020   /* - nb_registers > 8.  */
17021   BFD_ASSERT (popcount (insn_all_registers) > 8);
17022
17023   /* At this point, LDMxx initial insn loads between 9 and 14 registers.  */
17024
17025   /* In the following algorithm, we split this wide LDM using 2 LDM insn:
17026     - One with the 7 lowest registers (register mask 0x007F)
17027       This LDM will finally contain between 2 and 7 registers
17028     - One with the 7 highest registers (register mask 0xDF80)
17029       This ldm will finally contain between 2 and 7 registers.  */
17030   insn_low_registers = insn_all_registers & 0x007F;
17031   insn_high_registers = insn_all_registers & 0xDF80;
17032
17033   /* A spare register may be needed during this veneer to temporarily
17034      handle the base register.  This register will be restored with
17035      the last LDM operation.
17036      The usable register may be any general purpose register (that excludes
17037      PC, SP, LR : register mask is 0x1FFF).  */
17038   usable_register_mask = 0x1FFF;
17039
17040   /* Generate the stub function.  */
17041   if (!wback && !restore_pc && !restore_rn)
17042     {
17043       /* Choose a Ri in the low-register-list that will be restored.  */
17044       ri = ctz (insn_low_registers & usable_register_mask & ~(1 << rn));
17045
17046       /* MOV Ri, Rn.  */
17047       current_stub_contents =
17048         push_thumb2_insn16 (htab, output_bfd, current_stub_contents,
17049                             create_instruction_mov (ri, rn));
17050
17051       /* LDMDB Ri!, {R-high-register-list}.  */
17052       current_stub_contents =
17053         push_thumb2_insn32 (htab, output_bfd, current_stub_contents,
17054                             create_instruction_ldmdb
17055                             (ri, /*wback=*/1, insn_high_registers));
17056
17057       /* LDMDB Ri, {R-low-register-list}.  */
17058       current_stub_contents =
17059         push_thumb2_insn32 (htab, output_bfd, current_stub_contents,
17060                             create_instruction_ldmdb
17061                             (ri, /*wback=*/0, insn_low_registers));
17062
17063       /* B initial_insn_addr+4.  */
17064       current_stub_contents =
17065         push_thumb2_insn32 (htab, output_bfd, current_stub_contents,
17066                             create_instruction_branch_absolute
17067                             (initial_insn_addr - current_stub_contents));
17068     }
17069   else if (wback && !restore_pc && !restore_rn)
17070     {
17071       /* LDMDB Rn!, {R-high-register-list}.  */
17072       current_stub_contents =
17073         push_thumb2_insn32 (htab, output_bfd, current_stub_contents,
17074                             create_instruction_ldmdb
17075                             (rn, /*wback=*/1, insn_high_registers));
17076
17077       /* LDMDB Rn!, {R-low-register-list}.  */
17078       current_stub_contents =
17079         push_thumb2_insn32 (htab, output_bfd, current_stub_contents,
17080                             create_instruction_ldmdb
17081                             (rn, /*wback=*/1, insn_low_registers));
17082
17083       /* B initial_insn_addr+4.  */
17084       current_stub_contents =
17085         push_thumb2_insn32 (htab, output_bfd, current_stub_contents,
17086                             create_instruction_branch_absolute
17087                             (initial_insn_addr - current_stub_contents));
17088     }
17089   else if (!wback && restore_pc && !restore_rn)
17090     {
17091       /* Choose a Ri in the high-register-list that will be restored.  */
17092       ri = ctz (insn_high_registers & usable_register_mask & ~(1 << rn));
17093
17094       /* SUB Ri, Rn, #(4*nb_registers).  */
17095       current_stub_contents =
17096         push_thumb2_insn32 (htab, output_bfd, current_stub_contents,
17097                             create_instruction_sub (ri, rn, (4 * nb_registers)));
17098
17099       /* LDMIA Ri!, {R-low-register-list}.  */
17100       current_stub_contents =
17101         push_thumb2_insn32 (htab, output_bfd, current_stub_contents,
17102                             create_instruction_ldmia
17103                             (ri, /*wback=*/1, insn_low_registers));
17104
17105       /* LDMIA Ri, {R-high-register-list}.  */
17106       current_stub_contents =
17107         push_thumb2_insn32 (htab, output_bfd, current_stub_contents,
17108                             create_instruction_ldmia
17109                             (ri, /*wback=*/0, insn_high_registers));
17110     }
17111   else if (wback && restore_pc && !restore_rn)
17112     {
17113       /* Choose a Ri in the high-register-list that will be restored.  */
17114       ri = ctz (insn_high_registers & usable_register_mask & ~(1 << rn));
17115
17116       /* SUB Rn, Rn, #(4*nb_registers)  */
17117       current_stub_contents =
17118         push_thumb2_insn32 (htab, output_bfd, current_stub_contents,
17119                             create_instruction_sub (rn, rn, (4 * nb_registers)));
17120
17121       /* MOV Ri, Rn.  */
17122       current_stub_contents =
17123         push_thumb2_insn16 (htab, output_bfd, current_stub_contents,
17124                             create_instruction_mov (ri, rn));
17125
17126       /* LDMIA Ri!, {R-low-register-list}.  */
17127       current_stub_contents =
17128         push_thumb2_insn32 (htab, output_bfd, current_stub_contents,
17129                             create_instruction_ldmia
17130                             (ri, /*wback=*/1, insn_low_registers));
17131
17132       /* LDMIA Ri, {R-high-register-list}.  */
17133       current_stub_contents =
17134         push_thumb2_insn32 (htab, output_bfd, current_stub_contents,
17135                             create_instruction_ldmia
17136                             (ri, /*wback=*/0, insn_high_registers));
17137     }
17138   else if (!wback && !restore_pc && restore_rn)
17139     {
17140       ri = rn;
17141       if (!(insn_low_registers & (1 << rn)))
17142         {
17143           /* Choose a Ri in the low-register-list that will be restored.  */
17144           ri = ctz (insn_low_registers & usable_register_mask & ~(1 << rn));
17145
17146           /* MOV Ri, Rn.  */
17147           current_stub_contents =
17148             push_thumb2_insn16 (htab, output_bfd, current_stub_contents,
17149                                 create_instruction_mov (ri, rn));
17150         }
17151
17152       /* LDMDB Ri!, {R-high-register-list}.  */
17153       current_stub_contents =
17154         push_thumb2_insn32 (htab, output_bfd, current_stub_contents,
17155                             create_instruction_ldmdb
17156                             (ri, /*wback=*/1, insn_high_registers));
17157
17158       /* LDMDB Ri, {R-low-register-list}.  */
17159       current_stub_contents =
17160         push_thumb2_insn32 (htab, output_bfd, current_stub_contents,
17161                             create_instruction_ldmdb
17162                             (ri, /*wback=*/0, insn_low_registers));
17163
17164       /* B initial_insn_addr+4.  */
17165       current_stub_contents =
17166         push_thumb2_insn32 (htab, output_bfd, current_stub_contents,
17167                             create_instruction_branch_absolute
17168                             (initial_insn_addr - current_stub_contents));
17169     }
17170   else if (!wback && restore_pc && restore_rn)
17171     {
17172       ri = rn;
17173       if (!(insn_high_registers & (1 << rn)))
17174         {
17175           /* Choose a Ri in the high-register-list that will be restored.  */
17176           ri = ctz (insn_high_registers & usable_register_mask & ~(1 << rn));
17177         }
17178
17179       /* SUB Ri, Rn, #(4*nb_registers).  */
17180       current_stub_contents =
17181         push_thumb2_insn32 (htab, output_bfd, current_stub_contents,
17182                             create_instruction_sub (ri, rn, (4 * nb_registers)));
17183
17184       /* LDMIA Ri!, {R-low-register-list}.  */
17185       current_stub_contents =
17186         push_thumb2_insn32 (htab, output_bfd, current_stub_contents,
17187                             create_instruction_ldmia
17188                             (ri, /*wback=*/1, insn_low_registers));
17189
17190       /* LDMIA Ri, {R-high-register-list}.  */
17191       current_stub_contents =
17192         push_thumb2_insn32 (htab, output_bfd, current_stub_contents,
17193                             create_instruction_ldmia
17194                             (ri, /*wback=*/0, insn_high_registers));
17195     }
17196   else if (wback && restore_rn)
17197     {
17198       /* The assembler should not have accepted to encode this.  */
17199       BFD_ASSERT (0 && "Cannot patch an instruction that has an "
17200         "undefined behavior.\n");
17201     }
17202
17203   /* Fill the remaining of the stub with deterministic contents.  */
17204   current_stub_contents =
17205     stm32l4xx_fill_stub_udf (htab, output_bfd,
17206                              base_stub_contents, current_stub_contents,
17207                              base_stub_contents +
17208                              STM32L4XX_ERRATUM_LDM_VENEER_SIZE);
17209
17210 }
17211
17212 static void
17213 stm32l4xx_create_replacing_stub_vldm (struct elf32_arm_link_hash_table * htab,
17214                                       bfd * output_bfd,
17215                                       const insn32 initial_insn,
17216                                       const bfd_byte *const initial_insn_addr,
17217                                       bfd_byte *const base_stub_contents)
17218 {
17219   int num_words = ((unsigned int) initial_insn << 24) >> 24;
17220   bfd_byte *current_stub_contents = base_stub_contents;
17221
17222   BFD_ASSERT (is_thumb2_vldm (initial_insn));
17223
17224   /* In BFD_ARM_STM32L4XX_FIX_ALL mode we may have to deal with
17225      smaller than 8 words load sequences that do not cause the
17226      hardware issue.  */
17227   if (num_words <= 8)
17228     {
17229       /* Untouched instruction.  */
17230       current_stub_contents =
17231         push_thumb2_insn32 (htab, output_bfd, current_stub_contents,
17232                             initial_insn);
17233
17234       /* B initial_insn_addr+4.  */
17235       current_stub_contents =
17236         push_thumb2_insn32 (htab, output_bfd, current_stub_contents,
17237                             create_instruction_branch_absolute
17238                             (initial_insn_addr - current_stub_contents));
17239     }
17240   else
17241     {
17242       bfd_boolean is_dp = /* DP encoding. */
17243         (initial_insn & 0xfe100f00) == 0xec100b00;
17244       bfd_boolean is_ia_nobang = /* (IA without !).  */
17245         (((initial_insn << 7) >> 28) & 0xd) == 0x4;
17246       bfd_boolean is_ia_bang = /* (IA with !) - includes VPOP.  */
17247         (((initial_insn << 7) >> 28) & 0xd) == 0x5;
17248       bfd_boolean is_db_bang = /* (DB with !).  */
17249         (((initial_insn << 7) >> 28) & 0xd) == 0x9;
17250       int base_reg = ((unsigned int) initial_insn << 12) >> 28;
17251       /* d = UInt (Vd:D);.  */
17252       int first_reg = ((((unsigned int) initial_insn << 16) >> 28) << 1)
17253         | (((unsigned int)initial_insn << 9) >> 31);
17254
17255       /* Compute the number of 8-words chunks needed to split.  */
17256       int chunks = (num_words % 8) ? (num_words / 8 + 1) : (num_words / 8);
17257       int chunk;
17258
17259       /* The test coverage has been done assuming the following
17260          hypothesis that exactly one of the previous is_ predicates is
17261          true.  */
17262       BFD_ASSERT (    (is_ia_nobang ^ is_ia_bang ^ is_db_bang)
17263                   && !(is_ia_nobang & is_ia_bang & is_db_bang));
17264
17265       /* We treat the cutting of the words in one pass for all
17266          cases, then we emit the adjustments:
17267
17268          vldm rx, {...}
17269          -> vldm rx!, {8_words_or_less} for each needed 8_word
17270          -> sub rx, rx, #size (list)
17271
17272          vldm rx!, {...}
17273          -> vldm rx!, {8_words_or_less} for each needed 8_word
17274          This also handles vpop instruction (when rx is sp)
17275
17276          vldmd rx!, {...}
17277          -> vldmb rx!, {8_words_or_less} for each needed 8_word.  */
17278       for (chunk = 0; chunk < chunks; ++chunk)
17279         {
17280           bfd_vma new_insn = 0;
17281
17282           if (is_ia_nobang || is_ia_bang)
17283             {
17284               new_insn = create_instruction_vldmia
17285                 (base_reg,
17286                  is_dp,
17287                  /*wback= .  */1,
17288                  chunks - (chunk + 1) ?
17289                  8 : num_words - chunk * 8,
17290                  first_reg + chunk * 8);
17291             }
17292           else if (is_db_bang)
17293             {
17294               new_insn = create_instruction_vldmdb
17295                 (base_reg,
17296                  is_dp,
17297                  chunks - (chunk + 1) ?
17298                  8 : num_words - chunk * 8,
17299                  first_reg + chunk * 8);
17300             }
17301
17302           if (new_insn)
17303             current_stub_contents =
17304               push_thumb2_insn32 (htab, output_bfd, current_stub_contents,
17305                                   new_insn);
17306         }
17307
17308       /* Only this case requires the base register compensation
17309          subtract.  */
17310       if (is_ia_nobang)
17311         {
17312           current_stub_contents =
17313             push_thumb2_insn32 (htab, output_bfd, current_stub_contents,
17314                                 create_instruction_sub
17315                                 (base_reg, base_reg, 4*num_words));
17316         }
17317
17318       /* B initial_insn_addr+4.  */
17319       current_stub_contents =
17320         push_thumb2_insn32 (htab, output_bfd, current_stub_contents,
17321                             create_instruction_branch_absolute
17322                             (initial_insn_addr - current_stub_contents));
17323     }
17324
17325   /* Fill the remaining of the stub with deterministic contents.  */
17326   current_stub_contents =
17327     stm32l4xx_fill_stub_udf (htab, output_bfd,
17328                              base_stub_contents, current_stub_contents,
17329                              base_stub_contents +
17330                              STM32L4XX_ERRATUM_VLDM_VENEER_SIZE);
17331 }
17332
17333 static void
17334 stm32l4xx_create_replacing_stub (struct elf32_arm_link_hash_table * htab,
17335                                  bfd * output_bfd,
17336                                  const insn32 wrong_insn,
17337                                  const bfd_byte *const wrong_insn_addr,
17338                                  bfd_byte *const stub_contents)
17339 {
17340   if (is_thumb2_ldmia (wrong_insn))
17341     stm32l4xx_create_replacing_stub_ldmia (htab, output_bfd,
17342                                            wrong_insn, wrong_insn_addr,
17343                                            stub_contents);
17344   else if (is_thumb2_ldmdb (wrong_insn))
17345     stm32l4xx_create_replacing_stub_ldmdb (htab, output_bfd,
17346                                            wrong_insn, wrong_insn_addr,
17347                                            stub_contents);
17348   else if (is_thumb2_vldm (wrong_insn))
17349     stm32l4xx_create_replacing_stub_vldm (htab, output_bfd,
17350                                           wrong_insn, wrong_insn_addr,
17351                                           stub_contents);
17352 }
17353
17354 /* End of stm32l4xx work-around.  */
17355
17356
17357 static void
17358 elf32_arm_add_relocation (bfd *output_bfd, struct bfd_link_info *info,
17359                           asection *output_sec, Elf_Internal_Rela *rel)
17360 {
17361   BFD_ASSERT (output_sec && rel);
17362   struct bfd_elf_section_reloc_data *output_reldata;
17363   struct elf32_arm_link_hash_table *htab;
17364   struct bfd_elf_section_data *oesd = elf_section_data (output_sec);
17365   Elf_Internal_Shdr *rel_hdr;
17366
17367
17368   if (oesd->rel.hdr)
17369     {
17370       rel_hdr = oesd->rel.hdr;
17371       output_reldata = &(oesd->rel);
17372     }
17373   else if (oesd->rela.hdr)
17374     {
17375       rel_hdr = oesd->rela.hdr;
17376       output_reldata = &(oesd->rela);
17377     }
17378   else
17379     {
17380       abort ();
17381     }
17382
17383   bfd_byte *erel = rel_hdr->contents;
17384   erel += output_reldata->count * rel_hdr->sh_entsize;
17385   htab = elf32_arm_hash_table (info);
17386   SWAP_RELOC_OUT (htab) (output_bfd, rel, erel);
17387   output_reldata->count++;
17388 }
17389
17390 /* Do code byteswapping.  Return FALSE afterwards so that the section is
17391    written out as normal.  */
17392
17393 static bfd_boolean
17394 elf32_arm_write_section (bfd *output_bfd,
17395                          struct bfd_link_info *link_info,
17396                          asection *sec,
17397                          bfd_byte *contents)
17398 {
17399   unsigned int mapcount, errcount;
17400   _arm_elf_section_data *arm_data;
17401   struct elf32_arm_link_hash_table *globals = elf32_arm_hash_table (link_info);
17402   elf32_arm_section_map *map;
17403   elf32_vfp11_erratum_list *errnode;
17404   elf32_stm32l4xx_erratum_list *stm32l4xx_errnode;
17405   bfd_vma ptr;
17406   bfd_vma end;
17407   bfd_vma offset = sec->output_section->vma + sec->output_offset;
17408   bfd_byte tmp;
17409   unsigned int i;
17410
17411   if (globals == NULL)
17412     return FALSE;
17413
17414   /* If this section has not been allocated an _arm_elf_section_data
17415      structure then we cannot record anything.  */
17416   arm_data = get_arm_elf_section_data (sec);
17417   if (arm_data == NULL)
17418     return FALSE;
17419
17420   mapcount = arm_data->mapcount;
17421   map = arm_data->map;
17422   errcount = arm_data->erratumcount;
17423
17424   if (errcount != 0)
17425     {
17426       unsigned int endianflip = bfd_big_endian (output_bfd) ? 3 : 0;
17427
17428       for (errnode = arm_data->erratumlist; errnode != 0;
17429            errnode = errnode->next)
17430         {
17431           bfd_vma target = errnode->vma - offset;
17432
17433           switch (errnode->type)
17434             {
17435             case VFP11_ERRATUM_BRANCH_TO_ARM_VENEER:
17436               {
17437                 bfd_vma branch_to_veneer;
17438                 /* Original condition code of instruction, plus bit mask for
17439                    ARM B instruction.  */
17440                 unsigned int insn = (errnode->u.b.vfp_insn & 0xf0000000)
17441                                   | 0x0a000000;
17442
17443                 /* The instruction is before the label.  */
17444                 target -= 4;
17445
17446                 /* Above offset included in -4 below.  */
17447                 branch_to_veneer = errnode->u.b.veneer->vma
17448                                    - errnode->vma - 4;
17449
17450                 if ((signed) branch_to_veneer < -(1 << 25)
17451                     || (signed) branch_to_veneer >= (1 << 25))
17452                   (*_bfd_error_handler) (_("%B: error: VFP11 veneer out of "
17453                                            "range"), output_bfd);
17454
17455                 insn |= (branch_to_veneer >> 2) & 0xffffff;
17456                 contents[endianflip ^ target] = insn & 0xff;
17457                 contents[endianflip ^ (target + 1)] = (insn >> 8) & 0xff;
17458                 contents[endianflip ^ (target + 2)] = (insn >> 16) & 0xff;
17459                 contents[endianflip ^ (target + 3)] = (insn >> 24) & 0xff;
17460               }
17461               break;
17462
17463             case VFP11_ERRATUM_ARM_VENEER:
17464               {
17465                 bfd_vma branch_from_veneer;
17466                 unsigned int insn;
17467
17468                 /* Take size of veneer into account.  */
17469                 branch_from_veneer = errnode->u.v.branch->vma
17470                                      - errnode->vma - 12;
17471
17472                 if ((signed) branch_from_veneer < -(1 << 25)
17473                     || (signed) branch_from_veneer >= (1 << 25))
17474                   (*_bfd_error_handler) (_("%B: error: VFP11 veneer out of "
17475                                            "range"), output_bfd);
17476
17477                 /* Original instruction.  */
17478                 insn = errnode->u.v.branch->u.b.vfp_insn;
17479                 contents[endianflip ^ target] = insn & 0xff;
17480                 contents[endianflip ^ (target + 1)] = (insn >> 8) & 0xff;
17481                 contents[endianflip ^ (target + 2)] = (insn >> 16) & 0xff;
17482                 contents[endianflip ^ (target + 3)] = (insn >> 24) & 0xff;
17483
17484                 /* Branch back to insn after original insn.  */
17485                 insn = 0xea000000 | ((branch_from_veneer >> 2) & 0xffffff);
17486                 contents[endianflip ^ (target + 4)] = insn & 0xff;
17487                 contents[endianflip ^ (target + 5)] = (insn >> 8) & 0xff;
17488                 contents[endianflip ^ (target + 6)] = (insn >> 16) & 0xff;
17489                 contents[endianflip ^ (target + 7)] = (insn >> 24) & 0xff;
17490               }
17491               break;
17492
17493             default:
17494               abort ();
17495             }
17496         }
17497     }
17498
17499   if (arm_data->stm32l4xx_erratumcount != 0)
17500     {
17501       for (stm32l4xx_errnode = arm_data->stm32l4xx_erratumlist;
17502            stm32l4xx_errnode != 0;
17503            stm32l4xx_errnode = stm32l4xx_errnode->next)
17504         {
17505           bfd_vma target = stm32l4xx_errnode->vma - offset;
17506
17507           switch (stm32l4xx_errnode->type)
17508             {
17509             case STM32L4XX_ERRATUM_BRANCH_TO_VENEER:
17510               {
17511                 unsigned int insn;
17512                 bfd_vma branch_to_veneer =
17513                   stm32l4xx_errnode->u.b.veneer->vma - stm32l4xx_errnode->vma;
17514
17515                 if ((signed) branch_to_veneer < -(1 << 24)
17516                     || (signed) branch_to_veneer >= (1 << 24))
17517                   {
17518                     bfd_vma out_of_range =
17519                       ((signed) branch_to_veneer < -(1 << 24)) ?
17520                       - branch_to_veneer - (1 << 24) :
17521                       ((signed) branch_to_veneer >= (1 << 24)) ?
17522                       branch_to_veneer - (1 << 24) : 0;
17523
17524                     (*_bfd_error_handler)
17525                       (_("%B(%#x): error: Cannot create STM32L4XX veneer. "
17526                          "Jump out of range by %ld bytes. "
17527                          "Cannot encode branch instruction. "),
17528                        output_bfd,
17529                        (long) (stm32l4xx_errnode->vma - 4),
17530                        out_of_range);
17531                     continue;
17532                   }
17533
17534                 insn = create_instruction_branch_absolute
17535                   (stm32l4xx_errnode->u.b.veneer->vma - stm32l4xx_errnode->vma);
17536
17537                 /* The instruction is before the label.  */
17538                 target -= 4;
17539
17540                 put_thumb2_insn (globals, output_bfd,
17541                                  (bfd_vma) insn, contents + target);
17542               }
17543               break;
17544
17545             case STM32L4XX_ERRATUM_VENEER:
17546               {
17547                 bfd_byte * veneer;
17548                 bfd_byte * veneer_r;
17549                 unsigned int insn;
17550
17551                 veneer = contents + target;
17552                 veneer_r = veneer
17553                   + stm32l4xx_errnode->u.b.veneer->vma
17554                   - stm32l4xx_errnode->vma - 4;
17555
17556                 if ((signed) (veneer_r - veneer -
17557                               STM32L4XX_ERRATUM_VLDM_VENEER_SIZE >
17558                               STM32L4XX_ERRATUM_LDM_VENEER_SIZE ?
17559                               STM32L4XX_ERRATUM_VLDM_VENEER_SIZE :
17560                               STM32L4XX_ERRATUM_LDM_VENEER_SIZE) < -(1 << 24)
17561                     || (signed) (veneer_r - veneer) >= (1 << 24))
17562                   {
17563                     (*_bfd_error_handler) (_("%B: error: Cannot create STM32L4XX "
17564                                              "veneer."), output_bfd);
17565                      continue;
17566                   }
17567
17568                 /* Original instruction.  */
17569                 insn = stm32l4xx_errnode->u.v.branch->u.b.insn;
17570
17571                 stm32l4xx_create_replacing_stub
17572                   (globals, output_bfd, insn, (void*)veneer_r, (void*)veneer);
17573               }
17574               break;
17575
17576             default:
17577               abort ();
17578             }
17579         }
17580     }
17581
17582   if (arm_data->elf.this_hdr.sh_type == SHT_ARM_EXIDX)
17583     {
17584       arm_unwind_table_edit *edit_node
17585         = arm_data->u.exidx.unwind_edit_list;
17586       /* Now, sec->size is the size of the section we will write.  The original
17587          size (before we merged duplicate entries and inserted EXIDX_CANTUNWIND
17588          markers) was sec->rawsize.  (This isn't the case if we perform no
17589          edits, then rawsize will be zero and we should use size).  */
17590       bfd_byte *edited_contents = (bfd_byte *) bfd_malloc (sec->size);
17591       unsigned int input_size = sec->rawsize ? sec->rawsize : sec->size;
17592       unsigned int in_index, out_index;
17593       bfd_vma add_to_offsets = 0;
17594
17595       for (in_index = 0, out_index = 0; in_index * 8 < input_size || edit_node;)
17596         {
17597           if (edit_node)
17598             {
17599               unsigned int edit_index = edit_node->index;
17600
17601               if (in_index < edit_index && in_index * 8 < input_size)
17602                 {
17603                   copy_exidx_entry (output_bfd, edited_contents + out_index * 8,
17604                                     contents + in_index * 8, add_to_offsets);
17605                   out_index++;
17606                   in_index++;
17607                 }
17608               else if (in_index == edit_index
17609                        || (in_index * 8 >= input_size
17610                            && edit_index == UINT_MAX))
17611                 {
17612                   switch (edit_node->type)
17613                     {
17614                     case DELETE_EXIDX_ENTRY:
17615                       in_index++;
17616                       add_to_offsets += 8;
17617                       break;
17618
17619                     case INSERT_EXIDX_CANTUNWIND_AT_END:
17620                       {
17621                         asection *text_sec = edit_node->linked_section;
17622                         bfd_vma text_offset = text_sec->output_section->vma
17623                                               + text_sec->output_offset
17624                                               + text_sec->size;
17625                         bfd_vma exidx_offset = offset + out_index * 8;
17626                         unsigned long prel31_offset;
17627
17628                         /* Note: this is meant to be equivalent to an
17629                            R_ARM_PREL31 relocation.  These synthetic
17630                            EXIDX_CANTUNWIND markers are not relocated by the
17631                            usual BFD method.  */
17632                         prel31_offset = (text_offset - exidx_offset)
17633                                         & 0x7ffffffful;
17634                         if (bfd_link_relocatable (link_info))
17635                           {
17636                             /* Here relocation for new EXIDX_CANTUNWIND is
17637                                created, so there is no need to
17638                                adjust offset by hand.  */
17639                             prel31_offset = text_sec->output_offset
17640                                             + text_sec->size;
17641
17642                             /* New relocation entity.  */
17643                             asection *text_out = text_sec->output_section;
17644                             Elf_Internal_Rela rel;
17645                             rel.r_addend = 0;
17646                             rel.r_offset = exidx_offset;
17647                             rel.r_info = ELF32_R_INFO (text_out->target_index,
17648                                                        R_ARM_PREL31);
17649
17650                             elf32_arm_add_relocation (output_bfd, link_info,
17651                                                       sec->output_section,
17652                                                       &rel);
17653                           }
17654
17655                         /* First address we can't unwind.  */
17656                         bfd_put_32 (output_bfd, prel31_offset,
17657                                     &edited_contents[out_index * 8]);
17658
17659                         /* Code for EXIDX_CANTUNWIND.  */
17660                         bfd_put_32 (output_bfd, 0x1,
17661                                     &edited_contents[out_index * 8 + 4]);
17662
17663                         out_index++;
17664                         add_to_offsets -= 8;
17665                       }
17666                       break;
17667                     }
17668
17669                   edit_node = edit_node->next;
17670                 }
17671             }
17672           else
17673             {
17674               /* No more edits, copy remaining entries verbatim.  */
17675               copy_exidx_entry (output_bfd, edited_contents + out_index * 8,
17676                                 contents + in_index * 8, add_to_offsets);
17677               out_index++;
17678               in_index++;
17679             }
17680         }
17681
17682       if (!(sec->flags & SEC_EXCLUDE) && !(sec->flags & SEC_NEVER_LOAD))
17683         bfd_set_section_contents (output_bfd, sec->output_section,
17684                                   edited_contents,
17685                                   (file_ptr) sec->output_offset, sec->size);
17686
17687       return TRUE;
17688     }
17689
17690   /* Fix code to point to Cortex-A8 erratum stubs.  */
17691   if (globals->fix_cortex_a8)
17692     {
17693       struct a8_branch_to_stub_data data;
17694
17695       data.writing_section = sec;
17696       data.contents = contents;
17697
17698       bfd_hash_traverse (& globals->stub_hash_table, make_branch_to_a8_stub,
17699                          & data);
17700     }
17701
17702   if (mapcount == 0)
17703     return FALSE;
17704
17705   if (globals->byteswap_code)
17706     {
17707       qsort (map, mapcount, sizeof (* map), elf32_arm_compare_mapping);
17708
17709       ptr = map[0].vma;
17710       for (i = 0; i < mapcount; i++)
17711         {
17712           if (i == mapcount - 1)
17713             end = sec->size;
17714           else
17715             end = map[i + 1].vma;
17716
17717           switch (map[i].type)
17718             {
17719             case 'a':
17720               /* Byte swap code words.  */
17721               while (ptr + 3 < end)
17722                 {
17723                   tmp = contents[ptr];
17724                   contents[ptr] = contents[ptr + 3];
17725                   contents[ptr + 3] = tmp;
17726                   tmp = contents[ptr + 1];
17727                   contents[ptr + 1] = contents[ptr + 2];
17728                   contents[ptr + 2] = tmp;
17729                   ptr += 4;
17730                 }
17731               break;
17732
17733             case 't':
17734               /* Byte swap code halfwords.  */
17735               while (ptr + 1 < end)
17736                 {
17737                   tmp = contents[ptr];
17738                   contents[ptr] = contents[ptr + 1];
17739                   contents[ptr + 1] = tmp;
17740                   ptr += 2;
17741                 }
17742               break;
17743
17744             case 'd':
17745               /* Leave data alone.  */
17746               break;
17747             }
17748           ptr = end;
17749         }
17750     }
17751
17752   free (map);
17753   arm_data->mapcount = -1;
17754   arm_data->mapsize = 0;
17755   arm_data->map = NULL;
17756
17757   return FALSE;
17758 }
17759
17760 /* Mangle thumb function symbols as we read them in.  */
17761
17762 static bfd_boolean
17763 elf32_arm_swap_symbol_in (bfd * abfd,
17764                           const void *psrc,
17765                           const void *pshn,
17766                           Elf_Internal_Sym *dst)
17767 {
17768   if (!bfd_elf32_swap_symbol_in (abfd, psrc, pshn, dst))
17769     return FALSE;
17770   dst->st_target_internal = 0;
17771
17772   /* New EABI objects mark thumb function symbols by setting the low bit of
17773      the address.  */
17774   if (ELF_ST_TYPE (dst->st_info) == STT_FUNC
17775       || ELF_ST_TYPE (dst->st_info) == STT_GNU_IFUNC)
17776     {
17777       if (dst->st_value & 1)
17778         {
17779           dst->st_value &= ~(bfd_vma) 1;
17780           ARM_SET_SYM_BRANCH_TYPE (dst->st_target_internal,
17781                                    ST_BRANCH_TO_THUMB);
17782         }
17783       else
17784         ARM_SET_SYM_BRANCH_TYPE (dst->st_target_internal, ST_BRANCH_TO_ARM);
17785     }
17786   else if (ELF_ST_TYPE (dst->st_info) == STT_ARM_TFUNC)
17787     {
17788       dst->st_info = ELF_ST_INFO (ELF_ST_BIND (dst->st_info), STT_FUNC);
17789       ARM_SET_SYM_BRANCH_TYPE (dst->st_target_internal, ST_BRANCH_TO_THUMB);
17790     }
17791   else if (ELF_ST_TYPE (dst->st_info) == STT_SECTION)
17792     ARM_SET_SYM_BRANCH_TYPE (dst->st_target_internal, ST_BRANCH_LONG);
17793   else
17794     ARM_SET_SYM_BRANCH_TYPE (dst->st_target_internal, ST_BRANCH_UNKNOWN);
17795
17796   return TRUE;
17797 }
17798
17799
17800 /* Mangle thumb function symbols as we write them out.  */
17801
17802 static void
17803 elf32_arm_swap_symbol_out (bfd *abfd,
17804                            const Elf_Internal_Sym *src,
17805                            void *cdst,
17806                            void *shndx)
17807 {
17808   Elf_Internal_Sym newsym;
17809
17810   /* We convert STT_ARM_TFUNC symbols into STT_FUNC with the low bit
17811      of the address set, as per the new EABI.  We do this unconditionally
17812      because objcopy does not set the elf header flags until after
17813      it writes out the symbol table.  */
17814   if (ARM_GET_SYM_BRANCH_TYPE (src->st_target_internal) == ST_BRANCH_TO_THUMB)
17815     {
17816       newsym = *src;
17817       if (ELF_ST_TYPE (src->st_info) != STT_GNU_IFUNC)
17818         newsym.st_info = ELF_ST_INFO (ELF_ST_BIND (src->st_info), STT_FUNC);
17819       if (newsym.st_shndx != SHN_UNDEF)
17820         {
17821           /* Do this only for defined symbols. At link type, the static
17822              linker will simulate the work of dynamic linker of resolving
17823              symbols and will carry over the thumbness of found symbols to
17824              the output symbol table. It's not clear how it happens, but
17825              the thumbness of undefined symbols can well be different at
17826              runtime, and writing '1' for them will be confusing for users
17827              and possibly for dynamic linker itself.
17828           */
17829           newsym.st_value |= 1;
17830         }
17831
17832       src = &newsym;
17833     }
17834   bfd_elf32_swap_symbol_out (abfd, src, cdst, shndx);
17835 }
17836
17837 /* Add the PT_ARM_EXIDX program header.  */
17838
17839 static bfd_boolean
17840 elf32_arm_modify_segment_map (bfd *abfd,
17841                               struct bfd_link_info *info ATTRIBUTE_UNUSED)
17842 {
17843   struct elf_segment_map *m;
17844   asection *sec;
17845
17846   sec = bfd_get_section_by_name (abfd, ".ARM.exidx");
17847   if (sec != NULL && (sec->flags & SEC_LOAD) != 0)
17848     {
17849       /* If there is already a PT_ARM_EXIDX header, then we do not
17850          want to add another one.  This situation arises when running
17851          "strip"; the input binary already has the header.  */
17852       m = elf_seg_map (abfd);
17853       while (m && m->p_type != PT_ARM_EXIDX)
17854         m = m->next;
17855       if (!m)
17856         {
17857           m = (struct elf_segment_map *)
17858               bfd_zalloc (abfd, sizeof (struct elf_segment_map));
17859           if (m == NULL)
17860             return FALSE;
17861           m->p_type = PT_ARM_EXIDX;
17862           m->count = 1;
17863           m->sections[0] = sec;
17864
17865           m->next = elf_seg_map (abfd);
17866           elf_seg_map (abfd) = m;
17867         }
17868     }
17869
17870   return TRUE;
17871 }
17872
17873 /* We may add a PT_ARM_EXIDX program header.  */
17874
17875 static int
17876 elf32_arm_additional_program_headers (bfd *abfd,
17877                                       struct bfd_link_info *info ATTRIBUTE_UNUSED)
17878 {
17879   asection *sec;
17880
17881   sec = bfd_get_section_by_name (abfd, ".ARM.exidx");
17882   if (sec != NULL && (sec->flags & SEC_LOAD) != 0)
17883     return 1;
17884   else
17885     return 0;
17886 }
17887
17888 /* Hook called by the linker routine which adds symbols from an object
17889    file.  */
17890
17891 static bfd_boolean
17892 elf32_arm_add_symbol_hook (bfd *abfd, struct bfd_link_info *info,
17893                            Elf_Internal_Sym *sym, const char **namep,
17894                            flagword *flagsp, asection **secp, bfd_vma *valp)
17895 {
17896   if (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC
17897       && (abfd->flags & DYNAMIC) == 0
17898       && bfd_get_flavour (info->output_bfd) == bfd_target_elf_flavour)
17899     elf_tdata (info->output_bfd)->has_gnu_symbols |= elf_gnu_symbol_ifunc;
17900
17901   if (elf32_arm_hash_table (info) == NULL)
17902     return FALSE;
17903
17904   if (elf32_arm_hash_table (info)->vxworks_p
17905       && !elf_vxworks_add_symbol_hook (abfd, info, sym, namep,
17906                                        flagsp, secp, valp))
17907     return FALSE;
17908
17909   return TRUE;
17910 }
17911
17912 /* We use this to override swap_symbol_in and swap_symbol_out.  */
17913 const struct elf_size_info elf32_arm_size_info =
17914 {
17915   sizeof (Elf32_External_Ehdr),
17916   sizeof (Elf32_External_Phdr),
17917   sizeof (Elf32_External_Shdr),
17918   sizeof (Elf32_External_Rel),
17919   sizeof (Elf32_External_Rela),
17920   sizeof (Elf32_External_Sym),
17921   sizeof (Elf32_External_Dyn),
17922   sizeof (Elf_External_Note),
17923   4,
17924   1,
17925   32, 2,
17926   ELFCLASS32, EV_CURRENT,
17927   bfd_elf32_write_out_phdrs,
17928   bfd_elf32_write_shdrs_and_ehdr,
17929   bfd_elf32_checksum_contents,
17930   bfd_elf32_write_relocs,
17931   elf32_arm_swap_symbol_in,
17932   elf32_arm_swap_symbol_out,
17933   bfd_elf32_slurp_reloc_table,
17934   bfd_elf32_slurp_symbol_table,
17935   bfd_elf32_swap_dyn_in,
17936   bfd_elf32_swap_dyn_out,
17937   bfd_elf32_swap_reloc_in,
17938   bfd_elf32_swap_reloc_out,
17939   bfd_elf32_swap_reloca_in,
17940   bfd_elf32_swap_reloca_out
17941 };
17942
17943 static bfd_vma
17944 read_code32 (const bfd *abfd, const bfd_byte *addr)
17945 {
17946   /* V7 BE8 code is always little endian.  */
17947   if ((elf_elfheader (abfd)->e_flags & EF_ARM_BE8) != 0)
17948     return bfd_getl32 (addr);
17949
17950   return bfd_get_32 (abfd, addr);
17951 }
17952
17953 static bfd_vma
17954 read_code16 (const bfd *abfd, const bfd_byte *addr)
17955 {
17956   /* V7 BE8 code is always little endian.  */
17957   if ((elf_elfheader (abfd)->e_flags & EF_ARM_BE8) != 0)
17958     return bfd_getl16 (addr);
17959
17960   return bfd_get_16 (abfd, addr);
17961 }
17962
17963 /* Return size of plt0 entry starting at ADDR
17964    or (bfd_vma) -1 if size can not be determined.  */
17965
17966 static bfd_vma
17967 elf32_arm_plt0_size (const bfd *abfd, const bfd_byte *addr)
17968 {
17969   bfd_vma first_word;
17970   bfd_vma plt0_size;
17971
17972   first_word = read_code32 (abfd, addr);
17973
17974   if (first_word == elf32_arm_plt0_entry[0])
17975     plt0_size = 4 * ARRAY_SIZE (elf32_arm_plt0_entry);
17976   else if (first_word == elf32_thumb2_plt0_entry[0])
17977     plt0_size = 4 * ARRAY_SIZE (elf32_thumb2_plt0_entry);
17978   else
17979     /* We don't yet handle this PLT format.  */
17980     return (bfd_vma) -1;
17981
17982   return plt0_size;
17983 }
17984
17985 /* Return size of plt entry starting at offset OFFSET
17986    of plt section located at address START
17987    or (bfd_vma) -1 if size can not be determined.  */
17988
17989 static bfd_vma
17990 elf32_arm_plt_size (const bfd *abfd, const bfd_byte *start, bfd_vma offset)
17991 {
17992   bfd_vma first_insn;
17993   bfd_vma plt_size = 0;
17994   const bfd_byte *addr = start + offset;
17995
17996   /* PLT entry size if fixed on Thumb-only platforms.  */
17997   if (read_code32 (abfd, start) == elf32_thumb2_plt0_entry[0])
17998       return 4 * ARRAY_SIZE (elf32_thumb2_plt_entry);
17999
18000   /* Respect Thumb stub if necessary.  */
18001   if (read_code16 (abfd, addr) == elf32_arm_plt_thumb_stub[0])
18002     {
18003       plt_size += 2 * ARRAY_SIZE(elf32_arm_plt_thumb_stub);
18004     }
18005
18006   /* Strip immediate from first add.  */
18007   first_insn = read_code32 (abfd, addr + plt_size) & 0xffffff00;
18008
18009 #ifdef FOUR_WORD_PLT
18010   if (first_insn == elf32_arm_plt_entry[0])
18011     plt_size += 4 * ARRAY_SIZE (elf32_arm_plt_entry);
18012 #else
18013   if (first_insn == elf32_arm_plt_entry_long[0])
18014     plt_size += 4 * ARRAY_SIZE (elf32_arm_plt_entry_long);
18015   else if (first_insn == elf32_arm_plt_entry_short[0])
18016     plt_size += 4 * ARRAY_SIZE (elf32_arm_plt_entry_short);
18017 #endif
18018   else
18019     /* We don't yet handle this PLT format.  */
18020     return (bfd_vma) -1;
18021
18022   return plt_size;
18023 }
18024
18025 /* Implementation is shamelessly borrowed from _bfd_elf_get_synthetic_symtab.  */
18026
18027 static long
18028 elf32_arm_get_synthetic_symtab (bfd *abfd,
18029                                long symcount ATTRIBUTE_UNUSED,
18030                                asymbol **syms ATTRIBUTE_UNUSED,
18031                                long dynsymcount,
18032                                asymbol **dynsyms,
18033                                asymbol **ret)
18034 {
18035   asection *relplt;
18036   asymbol *s;
18037   arelent *p;
18038   long count, i, n;
18039   size_t size;
18040   Elf_Internal_Shdr *hdr;
18041   char *names;
18042   asection *plt;
18043   bfd_vma offset;
18044   bfd_byte *data;
18045
18046   *ret = NULL;
18047
18048   if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0)
18049     return 0;
18050
18051   if (dynsymcount <= 0)
18052     return 0;
18053
18054   relplt = bfd_get_section_by_name (abfd, ".rel.plt");
18055   if (relplt == NULL)
18056     return 0;
18057
18058   hdr = &elf_section_data (relplt)->this_hdr;
18059   if (hdr->sh_link != elf_dynsymtab (abfd)
18060       || (hdr->sh_type != SHT_REL && hdr->sh_type != SHT_RELA))
18061     return 0;
18062
18063   plt = bfd_get_section_by_name (abfd, ".plt");
18064   if (plt == NULL)
18065     return 0;
18066
18067   if (!elf32_arm_size_info.slurp_reloc_table (abfd, relplt, dynsyms, TRUE))
18068     return -1;
18069
18070   data = plt->contents;
18071   if (data == NULL)
18072     {
18073       if (!bfd_get_full_section_contents(abfd, (asection *) plt, &data) || data == NULL)
18074         return -1;
18075       bfd_cache_section_contents((asection *) plt, data);
18076     }
18077
18078   count = relplt->size / hdr->sh_entsize;
18079   size = count * sizeof (asymbol);
18080   p = relplt->relocation;
18081   for (i = 0; i < count; i++, p += elf32_arm_size_info.int_rels_per_ext_rel)
18082     {
18083       size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
18084       if (p->addend != 0)
18085         size += sizeof ("+0x") - 1 + 8;
18086     }
18087
18088   s = *ret = (asymbol *) bfd_malloc (size);
18089   if (s == NULL)
18090     return -1;
18091
18092   offset = elf32_arm_plt0_size (abfd, data);
18093   if (offset == (bfd_vma) -1)
18094     return -1;
18095
18096   names = (char *) (s + count);
18097   p = relplt->relocation;
18098   n = 0;
18099   for (i = 0; i < count; i++, p += elf32_arm_size_info.int_rels_per_ext_rel)
18100     {
18101       size_t len;
18102
18103       bfd_vma plt_size = elf32_arm_plt_size (abfd, data, offset);
18104       if (plt_size == (bfd_vma) -1)
18105         break;
18106
18107       *s = **p->sym_ptr_ptr;
18108       /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set.  Since
18109          we are defining a symbol, ensure one of them is set.  */
18110       if ((s->flags & BSF_LOCAL) == 0)
18111         s->flags |= BSF_GLOBAL;
18112       s->flags |= BSF_SYNTHETIC;
18113       s->section = plt;
18114       s->value = offset;
18115       s->name = names;
18116       s->udata.p = NULL;
18117       len = strlen ((*p->sym_ptr_ptr)->name);
18118       memcpy (names, (*p->sym_ptr_ptr)->name, len);
18119       names += len;
18120       if (p->addend != 0)
18121         {
18122           char buf[30], *a;
18123
18124           memcpy (names, "+0x", sizeof ("+0x") - 1);
18125           names += sizeof ("+0x") - 1;
18126           bfd_sprintf_vma (abfd, buf, p->addend);
18127           for (a = buf; *a == '0'; ++a)
18128             ;
18129           len = strlen (a);
18130           memcpy (names, a, len);
18131           names += len;
18132         }
18133       memcpy (names, "@plt", sizeof ("@plt"));
18134       names += sizeof ("@plt");
18135       ++s, ++n;
18136       offset += plt_size;
18137     }
18138
18139   return n;
18140 }
18141
18142 static bfd_boolean
18143 elf32_arm_section_flags (flagword *flags, const Elf_Internal_Shdr * hdr)
18144 {
18145   if (hdr->sh_flags & SHF_ARM_NOREAD)
18146     *flags |= SEC_ELF_NOREAD;
18147   return TRUE;
18148 }
18149
18150 static flagword
18151 elf32_arm_lookup_section_flags (char *flag_name)
18152 {
18153   if (!strcmp (flag_name, "SHF_ARM_NOREAD"))
18154     return SHF_ARM_NOREAD;
18155
18156   return SEC_NO_FLAGS;
18157 }
18158
18159 static unsigned int
18160 elf32_arm_count_additional_relocs (asection *sec)
18161 {
18162   struct _arm_elf_section_data *arm_data;
18163   arm_data = get_arm_elf_section_data (sec);
18164   return arm_data->additional_reloc_count;
18165 }
18166
18167 /* Called to set the sh_flags, sh_link and sh_info fields of OSECTION which
18168    has a type >= SHT_LOOS.  Returns TRUE if these fields were initialised
18169    FALSE otherwise.  ISECTION is the best guess matching section from the
18170    input bfd IBFD, but it might be NULL.  */
18171
18172 static bfd_boolean
18173 elf32_arm_copy_special_section_fields (const bfd *ibfd ATTRIBUTE_UNUSED,
18174                                        bfd *obfd ATTRIBUTE_UNUSED,
18175                                        const Elf_Internal_Shdr *isection ATTRIBUTE_UNUSED,
18176                                        Elf_Internal_Shdr *osection)
18177 {
18178   switch (osection->sh_type)
18179     {
18180     case SHT_ARM_EXIDX:
18181       {
18182         Elf_Internal_Shdr **oheaders = elf_elfsections (obfd);
18183         Elf_Internal_Shdr **iheaders = elf_elfsections (ibfd);
18184         unsigned i = 0;
18185
18186         osection->sh_flags = SHF_ALLOC | SHF_LINK_ORDER;
18187         osection->sh_info = 0;
18188
18189         /* The sh_link field must be set to the text section associated with
18190            this index section.  Unfortunately the ARM EHABI does not specify
18191            exactly how to determine this association.  Our caller does try
18192            to match up OSECTION with its corresponding input section however
18193            so that is a good first guess.  */
18194         if (isection != NULL
18195             && osection->bfd_section != NULL
18196             && isection->bfd_section != NULL
18197             && isection->bfd_section->output_section != NULL
18198             && isection->bfd_section->output_section == osection->bfd_section
18199             && iheaders != NULL
18200             && isection->sh_link > 0
18201             && isection->sh_link < elf_numsections (ibfd)
18202             && iheaders[isection->sh_link]->bfd_section != NULL
18203             && iheaders[isection->sh_link]->bfd_section->output_section != NULL
18204             )
18205           {
18206             for (i = elf_numsections (obfd); i-- > 0;)
18207               if (oheaders[i]->bfd_section
18208                   == iheaders[isection->sh_link]->bfd_section->output_section)
18209                 break;
18210           }
18211
18212         if (i == 0)
18213           {
18214             /* Failing that we have to find a matching section ourselves.  If
18215                we had the output section name available we could compare that
18216                with input section names.  Unfortunately we don't.  So instead
18217                we use a simple heuristic and look for the nearest executable
18218                section before this one.  */
18219             for (i = elf_numsections (obfd); i-- > 0;)
18220               if (oheaders[i] == osection)
18221                 break;
18222             if (i == 0)
18223               break;
18224
18225             while (i-- > 0)
18226               if (oheaders[i]->sh_type == SHT_PROGBITS
18227                   && (oheaders[i]->sh_flags & (SHF_ALLOC | SHF_EXECINSTR))
18228                   == (SHF_ALLOC | SHF_EXECINSTR))
18229                 break;
18230           }
18231
18232         if (i)
18233           {
18234             osection->sh_link = i;
18235             /* If the text section was part of a group
18236                then the index section should be too.  */
18237             if (oheaders[i]->sh_flags & SHF_GROUP)
18238               osection->sh_flags |= SHF_GROUP;
18239             return TRUE;
18240           }
18241       }
18242       break;
18243
18244     case SHT_ARM_PREEMPTMAP:
18245       osection->sh_flags = SHF_ALLOC;
18246       break;
18247
18248     case SHT_ARM_ATTRIBUTES:
18249     case SHT_ARM_DEBUGOVERLAY:
18250     case SHT_ARM_OVERLAYSECTION:
18251     default:
18252       break;
18253     }
18254
18255   return FALSE;
18256 }
18257
18258 #undef  elf_backend_copy_special_section_fields
18259 #define elf_backend_copy_special_section_fields elf32_arm_copy_special_section_fields
18260
18261 #define ELF_ARCH                        bfd_arch_arm
18262 #define ELF_TARGET_ID                   ARM_ELF_DATA
18263 #define ELF_MACHINE_CODE                EM_ARM
18264 #ifdef __QNXTARGET__
18265 #define ELF_MAXPAGESIZE                 0x1000
18266 #else
18267 #define ELF_MAXPAGESIZE                 0x10000
18268 #endif
18269 #define ELF_MINPAGESIZE                 0x1000
18270 #define ELF_COMMONPAGESIZE              0x1000
18271
18272 #define bfd_elf32_mkobject                      elf32_arm_mkobject
18273
18274 #define bfd_elf32_bfd_copy_private_bfd_data     elf32_arm_copy_private_bfd_data
18275 #define bfd_elf32_bfd_merge_private_bfd_data    elf32_arm_merge_private_bfd_data
18276 #define bfd_elf32_bfd_set_private_flags         elf32_arm_set_private_flags
18277 #define bfd_elf32_bfd_print_private_bfd_data    elf32_arm_print_private_bfd_data
18278 #define bfd_elf32_bfd_link_hash_table_create    elf32_arm_link_hash_table_create
18279 #define bfd_elf32_bfd_reloc_type_lookup         elf32_arm_reloc_type_lookup
18280 #define bfd_elf32_bfd_reloc_name_lookup         elf32_arm_reloc_name_lookup
18281 #define bfd_elf32_find_nearest_line             elf32_arm_find_nearest_line
18282 #define bfd_elf32_find_inliner_info             elf32_arm_find_inliner_info
18283 #define bfd_elf32_new_section_hook              elf32_arm_new_section_hook
18284 #define bfd_elf32_bfd_is_target_special_symbol  elf32_arm_is_target_special_symbol
18285 #define bfd_elf32_bfd_final_link                elf32_arm_final_link
18286 #define bfd_elf32_get_synthetic_symtab  elf32_arm_get_synthetic_symtab
18287
18288 #define elf_backend_get_symbol_type             elf32_arm_get_symbol_type
18289 #define elf_backend_gc_mark_hook                elf32_arm_gc_mark_hook
18290 #define elf_backend_gc_mark_extra_sections      elf32_arm_gc_mark_extra_sections
18291 #define elf_backend_gc_sweep_hook               elf32_arm_gc_sweep_hook
18292 #define elf_backend_check_relocs                elf32_arm_check_relocs
18293 #define elf_backend_relocate_section            elf32_arm_relocate_section
18294 #define elf_backend_write_section               elf32_arm_write_section
18295 #define elf_backend_adjust_dynamic_symbol       elf32_arm_adjust_dynamic_symbol
18296 #define elf_backend_create_dynamic_sections     elf32_arm_create_dynamic_sections
18297 #define elf_backend_finish_dynamic_symbol       elf32_arm_finish_dynamic_symbol
18298 #define elf_backend_finish_dynamic_sections     elf32_arm_finish_dynamic_sections
18299 #define elf_backend_size_dynamic_sections       elf32_arm_size_dynamic_sections
18300 #define elf_backend_always_size_sections        elf32_arm_always_size_sections
18301 #define elf_backend_init_index_section          _bfd_elf_init_2_index_sections
18302 #define elf_backend_post_process_headers        elf32_arm_post_process_headers
18303 #define elf_backend_reloc_type_class            elf32_arm_reloc_type_class
18304 #define elf_backend_object_p                    elf32_arm_object_p
18305 #define elf_backend_fake_sections               elf32_arm_fake_sections
18306 #define elf_backend_section_from_shdr           elf32_arm_section_from_shdr
18307 #define elf_backend_final_write_processing      elf32_arm_final_write_processing
18308 #define elf_backend_copy_indirect_symbol        elf32_arm_copy_indirect_symbol
18309 #define elf_backend_size_info                   elf32_arm_size_info
18310 #define elf_backend_modify_segment_map          elf32_arm_modify_segment_map
18311 #define elf_backend_additional_program_headers  elf32_arm_additional_program_headers
18312 #define elf_backend_output_arch_local_syms      elf32_arm_output_arch_local_syms
18313 #define elf_backend_begin_write_processing      elf32_arm_begin_write_processing
18314 #define elf_backend_add_symbol_hook             elf32_arm_add_symbol_hook
18315 #define elf_backend_count_additional_relocs     elf32_arm_count_additional_relocs
18316
18317 #define elf_backend_can_refcount       1
18318 #define elf_backend_can_gc_sections    1
18319 #define elf_backend_plt_readonly       1
18320 #define elf_backend_want_got_plt       1
18321 #define elf_backend_want_plt_sym       0
18322 #define elf_backend_may_use_rel_p      1
18323 #define elf_backend_may_use_rela_p     0
18324 #define elf_backend_default_use_rela_p 0
18325
18326 #define elf_backend_got_header_size     12
18327 #define elf_backend_extern_protected_data 1
18328
18329 #undef  elf_backend_obj_attrs_vendor
18330 #define elf_backend_obj_attrs_vendor            "aeabi"
18331 #undef  elf_backend_obj_attrs_section
18332 #define elf_backend_obj_attrs_section           ".ARM.attributes"
18333 #undef  elf_backend_obj_attrs_arg_type
18334 #define elf_backend_obj_attrs_arg_type          elf32_arm_obj_attrs_arg_type
18335 #undef  elf_backend_obj_attrs_section_type
18336 #define elf_backend_obj_attrs_section_type      SHT_ARM_ATTRIBUTES
18337 #define elf_backend_obj_attrs_order             elf32_arm_obj_attrs_order
18338 #define elf_backend_obj_attrs_handle_unknown    elf32_arm_obj_attrs_handle_unknown
18339
18340 #undef elf_backend_section_flags
18341 #define elf_backend_section_flags               elf32_arm_section_flags
18342 #undef elf_backend_lookup_section_flags_hook
18343 #define elf_backend_lookup_section_flags_hook   elf32_arm_lookup_section_flags
18344
18345 #include "elf32-target.h"
18346
18347 /* Native Client targets.  */
18348
18349 #undef  TARGET_LITTLE_SYM
18350 #define TARGET_LITTLE_SYM               arm_elf32_nacl_le_vec
18351 #undef  TARGET_LITTLE_NAME
18352 #define TARGET_LITTLE_NAME              "elf32-littlearm-nacl"
18353 #undef  TARGET_BIG_SYM
18354 #define TARGET_BIG_SYM                  arm_elf32_nacl_be_vec
18355 #undef  TARGET_BIG_NAME
18356 #define TARGET_BIG_NAME                 "elf32-bigarm-nacl"
18357
18358 /* Like elf32_arm_link_hash_table_create -- but overrides
18359    appropriately for NaCl.  */
18360
18361 static struct bfd_link_hash_table *
18362 elf32_arm_nacl_link_hash_table_create (bfd *abfd)
18363 {
18364   struct bfd_link_hash_table *ret;
18365
18366   ret = elf32_arm_link_hash_table_create (abfd);
18367   if (ret)
18368     {
18369       struct elf32_arm_link_hash_table *htab
18370         = (struct elf32_arm_link_hash_table *) ret;
18371
18372       htab->nacl_p = 1;
18373
18374       htab->plt_header_size = 4 * ARRAY_SIZE (elf32_arm_nacl_plt0_entry);
18375       htab->plt_entry_size = 4 * ARRAY_SIZE (elf32_arm_nacl_plt_entry);
18376     }
18377   return ret;
18378 }
18379
18380 /* Since NaCl doesn't use the ARM-specific unwind format, we don't
18381    really need to use elf32_arm_modify_segment_map.  But we do it
18382    anyway just to reduce gratuitous differences with the stock ARM backend.  */
18383
18384 static bfd_boolean
18385 elf32_arm_nacl_modify_segment_map (bfd *abfd, struct bfd_link_info *info)
18386 {
18387   return (elf32_arm_modify_segment_map (abfd, info)
18388           && nacl_modify_segment_map (abfd, info));
18389 }
18390
18391 static void
18392 elf32_arm_nacl_final_write_processing (bfd *abfd, bfd_boolean linker)
18393 {
18394   elf32_arm_final_write_processing (abfd, linker);
18395   nacl_final_write_processing (abfd, linker);
18396 }
18397
18398 static bfd_vma
18399 elf32_arm_nacl_plt_sym_val (bfd_vma i, const asection *plt,
18400                             const arelent *rel ATTRIBUTE_UNUSED)
18401 {
18402   return plt->vma
18403     + 4 * (ARRAY_SIZE (elf32_arm_nacl_plt0_entry) +
18404            i * ARRAY_SIZE (elf32_arm_nacl_plt_entry));
18405 }
18406
18407 #undef  elf32_bed
18408 #define elf32_bed                               elf32_arm_nacl_bed
18409 #undef  bfd_elf32_bfd_link_hash_table_create
18410 #define bfd_elf32_bfd_link_hash_table_create    \
18411   elf32_arm_nacl_link_hash_table_create
18412 #undef  elf_backend_plt_alignment
18413 #define elf_backend_plt_alignment               4
18414 #undef  elf_backend_modify_segment_map
18415 #define elf_backend_modify_segment_map          elf32_arm_nacl_modify_segment_map
18416 #undef  elf_backend_modify_program_headers
18417 #define elf_backend_modify_program_headers      nacl_modify_program_headers
18418 #undef  elf_backend_final_write_processing
18419 #define elf_backend_final_write_processing      elf32_arm_nacl_final_write_processing
18420 #undef bfd_elf32_get_synthetic_symtab
18421 #undef  elf_backend_plt_sym_val
18422 #define elf_backend_plt_sym_val                 elf32_arm_nacl_plt_sym_val
18423 #undef  elf_backend_copy_special_section_fields
18424
18425 #undef  ELF_MINPAGESIZE
18426 #undef  ELF_COMMONPAGESIZE
18427
18428
18429 #include "elf32-target.h"
18430
18431 /* Reset to defaults.  */
18432 #undef  elf_backend_plt_alignment
18433 #undef  elf_backend_modify_segment_map
18434 #define elf_backend_modify_segment_map          elf32_arm_modify_segment_map
18435 #undef  elf_backend_modify_program_headers
18436 #undef  elf_backend_final_write_processing
18437 #define elf_backend_final_write_processing      elf32_arm_final_write_processing
18438 #undef  ELF_MINPAGESIZE
18439 #define ELF_MINPAGESIZE                 0x1000
18440 #undef  ELF_COMMONPAGESIZE
18441 #define ELF_COMMONPAGESIZE              0x1000
18442
18443
18444 /* VxWorks Targets.  */
18445
18446 #undef  TARGET_LITTLE_SYM
18447 #define TARGET_LITTLE_SYM               arm_elf32_vxworks_le_vec
18448 #undef  TARGET_LITTLE_NAME
18449 #define TARGET_LITTLE_NAME              "elf32-littlearm-vxworks"
18450 #undef  TARGET_BIG_SYM
18451 #define TARGET_BIG_SYM                  arm_elf32_vxworks_be_vec
18452 #undef  TARGET_BIG_NAME
18453 #define TARGET_BIG_NAME                 "elf32-bigarm-vxworks"
18454
18455 /* Like elf32_arm_link_hash_table_create -- but overrides
18456    appropriately for VxWorks.  */
18457
18458 static struct bfd_link_hash_table *
18459 elf32_arm_vxworks_link_hash_table_create (bfd *abfd)
18460 {
18461   struct bfd_link_hash_table *ret;
18462
18463   ret = elf32_arm_link_hash_table_create (abfd);
18464   if (ret)
18465     {
18466       struct elf32_arm_link_hash_table *htab
18467         = (struct elf32_arm_link_hash_table *) ret;
18468       htab->use_rel = 0;
18469       htab->vxworks_p = 1;
18470     }
18471   return ret;
18472 }
18473
18474 static void
18475 elf32_arm_vxworks_final_write_processing (bfd *abfd, bfd_boolean linker)
18476 {
18477   elf32_arm_final_write_processing (abfd, linker);
18478   elf_vxworks_final_write_processing (abfd, linker);
18479 }
18480
18481 #undef  elf32_bed
18482 #define elf32_bed elf32_arm_vxworks_bed
18483
18484 #undef  bfd_elf32_bfd_link_hash_table_create
18485 #define bfd_elf32_bfd_link_hash_table_create    elf32_arm_vxworks_link_hash_table_create
18486 #undef  elf_backend_final_write_processing
18487 #define elf_backend_final_write_processing      elf32_arm_vxworks_final_write_processing
18488 #undef  elf_backend_emit_relocs
18489 #define elf_backend_emit_relocs                 elf_vxworks_emit_relocs
18490
18491 #undef  elf_backend_may_use_rel_p
18492 #define elf_backend_may_use_rel_p       0
18493 #undef  elf_backend_may_use_rela_p
18494 #define elf_backend_may_use_rela_p      1
18495 #undef  elf_backend_default_use_rela_p
18496 #define elf_backend_default_use_rela_p  1
18497 #undef  elf_backend_want_plt_sym
18498 #define elf_backend_want_plt_sym        1
18499 #undef  ELF_MAXPAGESIZE
18500 #define ELF_MAXPAGESIZE                 0x1000
18501
18502 #include "elf32-target.h"
18503
18504
18505 /* Merge backend specific data from an object file to the output
18506    object file when linking.  */
18507
18508 static bfd_boolean
18509 elf32_arm_merge_private_bfd_data (bfd * ibfd, bfd * obfd)
18510 {
18511   flagword out_flags;
18512   flagword in_flags;
18513   bfd_boolean flags_compatible = TRUE;
18514   asection *sec;
18515
18516   /* Check if we have the same endianness.  */
18517   if (! _bfd_generic_verify_endian_match (ibfd, obfd))
18518     return FALSE;
18519
18520   if (! is_arm_elf (ibfd) || ! is_arm_elf (obfd))
18521     return TRUE;
18522
18523   if (!elf32_arm_merge_eabi_attributes (ibfd, obfd))
18524     return FALSE;
18525
18526   /* The input BFD must have had its flags initialised.  */
18527   /* The following seems bogus to me -- The flags are initialized in
18528      the assembler but I don't think an elf_flags_init field is
18529      written into the object.  */
18530   /* BFD_ASSERT (elf_flags_init (ibfd)); */
18531
18532   in_flags  = elf_elfheader (ibfd)->e_flags;
18533   out_flags = elf_elfheader (obfd)->e_flags;
18534
18535   /* In theory there is no reason why we couldn't handle this.  However
18536      in practice it isn't even close to working and there is no real
18537      reason to want it.  */
18538   if (EF_ARM_EABI_VERSION (in_flags) >= EF_ARM_EABI_VER4
18539       && !(ibfd->flags & DYNAMIC)
18540       && (in_flags & EF_ARM_BE8))
18541     {
18542       _bfd_error_handler (_("error: %B is already in final BE8 format"),
18543                           ibfd);
18544       return FALSE;
18545     }
18546
18547   if (!elf_flags_init (obfd))
18548     {
18549       /* If the input is the default architecture and had the default
18550          flags then do not bother setting the flags for the output
18551          architecture, instead allow future merges to do this.  If no
18552          future merges ever set these flags then they will retain their
18553          uninitialised values, which surprise surprise, correspond
18554          to the default values.  */
18555       if (bfd_get_arch_info (ibfd)->the_default
18556           && elf_elfheader (ibfd)->e_flags == 0)
18557         return TRUE;
18558
18559       elf_flags_init (obfd) = TRUE;
18560       elf_elfheader (obfd)->e_flags = in_flags;
18561
18562       if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
18563           && bfd_get_arch_info (obfd)->the_default)
18564         return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
18565
18566       return TRUE;
18567     }
18568
18569   /* Determine what should happen if the input ARM architecture
18570      does not match the output ARM architecture.  */
18571   if (! bfd_arm_merge_machines (ibfd, obfd))
18572     return FALSE;
18573
18574   /* Identical flags must be compatible.  */
18575   if (in_flags == out_flags)
18576     return TRUE;
18577
18578   /* Check to see if the input BFD actually contains any sections.  If
18579      not, its flags may not have been initialised either, but it
18580      cannot actually cause any incompatiblity.  Do not short-circuit
18581      dynamic objects; their section list may be emptied by
18582     elf_link_add_object_symbols.
18583
18584     Also check to see if there are no code sections in the input.
18585     In this case there is no need to check for code specific flags.
18586     XXX - do we need to worry about floating-point format compatability
18587     in data sections ?  */
18588   if (!(ibfd->flags & DYNAMIC))
18589     {
18590       bfd_boolean null_input_bfd = TRUE;
18591       bfd_boolean only_data_sections = TRUE;
18592
18593       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
18594         {
18595           /* Ignore synthetic glue sections.  */
18596           if (strcmp (sec->name, ".glue_7")
18597               && strcmp (sec->name, ".glue_7t"))
18598             {
18599               if ((bfd_get_section_flags (ibfd, sec)
18600                    & (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS))
18601                   == (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS))
18602                 only_data_sections = FALSE;
18603
18604               null_input_bfd = FALSE;
18605               break;
18606             }
18607         }
18608
18609       if (null_input_bfd || only_data_sections)
18610         return TRUE;
18611     }
18612
18613   /* Complain about various flag mismatches.  */
18614   if (!elf32_arm_versions_compatible (EF_ARM_EABI_VERSION (in_flags),
18615                                       EF_ARM_EABI_VERSION (out_flags)))
18616     {
18617       _bfd_error_handler
18618         (_("error: Source object %B has EABI version %d, but target %B has EABI version %d"),
18619          ibfd, obfd,
18620          (in_flags & EF_ARM_EABIMASK) >> 24,
18621          (out_flags & EF_ARM_EABIMASK) >> 24);
18622       return FALSE;
18623     }
18624
18625   /* Not sure what needs to be checked for EABI versions >= 1.  */
18626   /* VxWorks libraries do not use these flags.  */
18627   if (get_elf_backend_data (obfd) != &elf32_arm_vxworks_bed
18628       && get_elf_backend_data (ibfd) != &elf32_arm_vxworks_bed
18629       && EF_ARM_EABI_VERSION (in_flags) == EF_ARM_EABI_UNKNOWN)
18630     {
18631       if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
18632         {
18633           _bfd_error_handler
18634             (_("error: %B is compiled for APCS-%d, whereas target %B uses APCS-%d"),
18635              ibfd, obfd,
18636              in_flags & EF_ARM_APCS_26 ? 26 : 32,
18637              out_flags & EF_ARM_APCS_26 ? 26 : 32);
18638           flags_compatible = FALSE;
18639         }
18640
18641       if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
18642         {
18643           if (in_flags & EF_ARM_APCS_FLOAT)
18644             _bfd_error_handler
18645               (_("error: %B passes floats in float registers, whereas %B passes them in integer registers"),
18646                ibfd, obfd);
18647           else
18648             _bfd_error_handler
18649               (_("error: %B passes floats in integer registers, whereas %B passes them in float registers"),
18650                ibfd, obfd);
18651
18652           flags_compatible = FALSE;
18653         }
18654
18655       if ((in_flags & EF_ARM_VFP_FLOAT) != (out_flags & EF_ARM_VFP_FLOAT))
18656         {
18657           if (in_flags & EF_ARM_VFP_FLOAT)
18658             _bfd_error_handler
18659               (_("error: %B uses VFP instructions, whereas %B does not"),
18660                ibfd, obfd);
18661           else
18662             _bfd_error_handler
18663               (_("error: %B uses FPA instructions, whereas %B does not"),
18664                ibfd, obfd);
18665
18666           flags_compatible = FALSE;
18667         }
18668
18669       if ((in_flags & EF_ARM_MAVERICK_FLOAT) != (out_flags & EF_ARM_MAVERICK_FLOAT))
18670         {
18671           if (in_flags & EF_ARM_MAVERICK_FLOAT)
18672             _bfd_error_handler
18673               (_("error: %B uses Maverick instructions, whereas %B does not"),
18674                ibfd, obfd);
18675           else
18676             _bfd_error_handler
18677               (_("error: %B does not use Maverick instructions, whereas %B does"),
18678                ibfd, obfd);
18679
18680           flags_compatible = FALSE;
18681         }
18682
18683 #ifdef EF_ARM_SOFT_FLOAT
18684       if ((in_flags & EF_ARM_SOFT_FLOAT) != (out_flags & EF_ARM_SOFT_FLOAT))
18685         {
18686           /* We can allow interworking between code that is VFP format
18687              layout, and uses either soft float or integer regs for
18688              passing floating point arguments and results.  We already
18689              know that the APCS_FLOAT flags match; similarly for VFP
18690              flags.  */
18691           if ((in_flags & EF_ARM_APCS_FLOAT) != 0
18692               || (in_flags & EF_ARM_VFP_FLOAT) == 0)
18693             {
18694               if (in_flags & EF_ARM_SOFT_FLOAT)
18695                 _bfd_error_handler
18696                   (_("error: %B uses software FP, whereas %B uses hardware FP"),
18697                    ibfd, obfd);
18698               else
18699                 _bfd_error_handler
18700                   (_("error: %B uses hardware FP, whereas %B uses software FP"),
18701                    ibfd, obfd);
18702
18703               flags_compatible = FALSE;
18704             }
18705         }
18706 #endif
18707
18708       /* Interworking mismatch is only a warning.  */
18709       if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
18710         {
18711           if (in_flags & EF_ARM_INTERWORK)
18712             {
18713               _bfd_error_handler
18714                 (_("Warning: %B supports interworking, whereas %B does not"),
18715                  ibfd, obfd);
18716             }
18717           else
18718             {
18719               _bfd_error_handler
18720                 (_("Warning: %B does not support interworking, whereas %B does"),
18721                  ibfd, obfd);
18722             }
18723         }
18724     }
18725
18726   return flags_compatible;
18727 }
18728
18729
18730 /* Symbian OS Targets.  */
18731
18732 #undef  TARGET_LITTLE_SYM
18733 #define TARGET_LITTLE_SYM               arm_elf32_symbian_le_vec
18734 #undef  TARGET_LITTLE_NAME
18735 #define TARGET_LITTLE_NAME              "elf32-littlearm-symbian"
18736 #undef  TARGET_BIG_SYM
18737 #define TARGET_BIG_SYM                  arm_elf32_symbian_be_vec
18738 #undef  TARGET_BIG_NAME
18739 #define TARGET_BIG_NAME                 "elf32-bigarm-symbian"
18740
18741 /* Like elf32_arm_link_hash_table_create -- but overrides
18742    appropriately for Symbian OS.  */
18743
18744 static struct bfd_link_hash_table *
18745 elf32_arm_symbian_link_hash_table_create (bfd *abfd)
18746 {
18747   struct bfd_link_hash_table *ret;
18748
18749   ret = elf32_arm_link_hash_table_create (abfd);
18750   if (ret)
18751     {
18752       struct elf32_arm_link_hash_table *htab
18753         = (struct elf32_arm_link_hash_table *)ret;
18754       /* There is no PLT header for Symbian OS.  */
18755       htab->plt_header_size = 0;
18756       /* The PLT entries are each one instruction and one word.  */
18757       htab->plt_entry_size = 4 * ARRAY_SIZE (elf32_arm_symbian_plt_entry);
18758       htab->symbian_p = 1;
18759       /* Symbian uses armv5t or above, so use_blx is always true.  */
18760       htab->use_blx = 1;
18761       htab->root.is_relocatable_executable = 1;
18762     }
18763   return ret;
18764 }
18765
18766 static const struct bfd_elf_special_section
18767 elf32_arm_symbian_special_sections[] =
18768 {
18769   /* In a BPABI executable, the dynamic linking sections do not go in
18770      the loadable read-only segment.  The post-linker may wish to
18771      refer to these sections, but they are not part of the final
18772      program image.  */
18773   { STRING_COMMA_LEN (".dynamic"),       0, SHT_DYNAMIC,  0 },
18774   { STRING_COMMA_LEN (".dynstr"),        0, SHT_STRTAB,   0 },
18775   { STRING_COMMA_LEN (".dynsym"),        0, SHT_DYNSYM,   0 },
18776   { STRING_COMMA_LEN (".got"),           0, SHT_PROGBITS, 0 },
18777   { STRING_COMMA_LEN (".hash"),          0, SHT_HASH,     0 },
18778   /* These sections do not need to be writable as the SymbianOS
18779      postlinker will arrange things so that no dynamic relocation is
18780      required.  */
18781   { STRING_COMMA_LEN (".init_array"),    0, SHT_INIT_ARRAY,    SHF_ALLOC },
18782   { STRING_COMMA_LEN (".fini_array"),    0, SHT_FINI_ARRAY,    SHF_ALLOC },
18783   { STRING_COMMA_LEN (".preinit_array"), 0, SHT_PREINIT_ARRAY, SHF_ALLOC },
18784   { NULL,                             0, 0, 0,                 0 }
18785 };
18786
18787 static void
18788 elf32_arm_symbian_begin_write_processing (bfd *abfd,
18789                                           struct bfd_link_info *link_info)
18790 {
18791   /* BPABI objects are never loaded directly by an OS kernel; they are
18792      processed by a postlinker first, into an OS-specific format.  If
18793      the D_PAGED bit is set on the file, BFD will align segments on
18794      page boundaries, so that an OS can directly map the file.  With
18795      BPABI objects, that just results in wasted space.  In addition,
18796      because we clear the D_PAGED bit, map_sections_to_segments will
18797      recognize that the program headers should not be mapped into any
18798      loadable segment.  */
18799   abfd->flags &= ~D_PAGED;
18800   elf32_arm_begin_write_processing (abfd, link_info);
18801 }
18802
18803 static bfd_boolean
18804 elf32_arm_symbian_modify_segment_map (bfd *abfd,
18805                                       struct bfd_link_info *info)
18806 {
18807   struct elf_segment_map *m;
18808   asection *dynsec;
18809
18810   /* BPABI shared libraries and executables should have a PT_DYNAMIC
18811      segment.  However, because the .dynamic section is not marked
18812      with SEC_LOAD, the generic ELF code will not create such a
18813      segment.  */
18814   dynsec = bfd_get_section_by_name (abfd, ".dynamic");
18815   if (dynsec)
18816     {
18817       for (m = elf_seg_map (abfd); m != NULL; m = m->next)
18818         if (m->p_type == PT_DYNAMIC)
18819           break;
18820
18821       if (m == NULL)
18822         {
18823           m = _bfd_elf_make_dynamic_segment (abfd, dynsec);
18824           m->next = elf_seg_map (abfd);
18825           elf_seg_map (abfd) = m;
18826         }
18827     }
18828
18829   /* Also call the generic arm routine.  */
18830   return elf32_arm_modify_segment_map (abfd, info);
18831 }
18832
18833 /* Return address for Ith PLT stub in section PLT, for relocation REL
18834    or (bfd_vma) -1 if it should not be included.  */
18835
18836 static bfd_vma
18837 elf32_arm_symbian_plt_sym_val (bfd_vma i, const asection *plt,
18838                                const arelent *rel ATTRIBUTE_UNUSED)
18839 {
18840   return plt->vma + 4 * ARRAY_SIZE (elf32_arm_symbian_plt_entry) * i;
18841 }
18842
18843 #undef  elf32_bed
18844 #define elf32_bed elf32_arm_symbian_bed
18845
18846 /* The dynamic sections are not allocated on SymbianOS; the postlinker
18847    will process them and then discard them.  */
18848 #undef  ELF_DYNAMIC_SEC_FLAGS
18849 #define ELF_DYNAMIC_SEC_FLAGS \
18850   (SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED)
18851
18852 #undef elf_backend_emit_relocs
18853
18854 #undef  bfd_elf32_bfd_link_hash_table_create
18855 #define bfd_elf32_bfd_link_hash_table_create    elf32_arm_symbian_link_hash_table_create
18856 #undef  elf_backend_special_sections
18857 #define elf_backend_special_sections            elf32_arm_symbian_special_sections
18858 #undef  elf_backend_begin_write_processing
18859 #define elf_backend_begin_write_processing      elf32_arm_symbian_begin_write_processing
18860 #undef  elf_backend_final_write_processing
18861 #define elf_backend_final_write_processing      elf32_arm_final_write_processing
18862
18863 #undef  elf_backend_modify_segment_map
18864 #define elf_backend_modify_segment_map elf32_arm_symbian_modify_segment_map
18865
18866 /* There is no .got section for BPABI objects, and hence no header.  */
18867 #undef  elf_backend_got_header_size
18868 #define elf_backend_got_header_size 0
18869
18870 /* Similarly, there is no .got.plt section.  */
18871 #undef  elf_backend_want_got_plt
18872 #define elf_backend_want_got_plt 0
18873
18874 #undef  elf_backend_plt_sym_val
18875 #define elf_backend_plt_sym_val         elf32_arm_symbian_plt_sym_val
18876
18877 #undef  elf_backend_may_use_rel_p
18878 #define elf_backend_may_use_rel_p       1
18879 #undef  elf_backend_may_use_rela_p
18880 #define elf_backend_may_use_rela_p      0
18881 #undef  elf_backend_default_use_rela_p
18882 #define elf_backend_default_use_rela_p  0
18883 #undef  elf_backend_want_plt_sym
18884 #define elf_backend_want_plt_sym        0
18885 #undef  ELF_MAXPAGESIZE
18886 #define ELF_MAXPAGESIZE                 0x8000
18887
18888 #include "elf32-target.h"