bfd/elf32-arm.c

   1 /* 32-bit ELF support for ARM
   2    Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
   3    2008 Free Software Foundation, Inc.
   4
   5    This file is part of BFD, the Binary File Descriptor library.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  20    MA 02110-1301, USA.  */
  21
  22 #include "sysdep.h"
  23 #include <limits.h>
  24
  25 #include "bfd.h"
  26 #include "libiberty.h"
  27 #include "libbfd.h"
  28 #include "elf-bfd.h"
  29 #include "elf-vxworks.h"
  30 #include "elf/arm.h"
  31
  32 /* Return the relocation section associated with NAME.  HTAB is the
  33    bfd's elf32_arm_link_hash_entry.  */
  34 #define RELOC_SECTION(HTAB, NAME) \
  35   ((HTAB)->use_rel ? ".rel" NAME : ".rela" NAME)
  36
  37 /* Return size of a relocation entry.  HTAB is the bfd's
  38    elf32_arm_link_hash_entry.  */
  39 #define RELOC_SIZE(HTAB) \
  40   ((HTAB)->use_rel \
  41    ? sizeof (Elf32_External_Rel) \
  42    : sizeof (Elf32_External_Rela))
  43
  44 /* Return function to swap relocations in.  HTAB is the bfd's
  45    elf32_arm_link_hash_entry.  */
  46 #define SWAP_RELOC_IN(HTAB) \
  47   ((HTAB)->use_rel \
  48    ? bfd_elf32_swap_reloc_in \
  49    : bfd_elf32_swap_reloca_in)
  50
  51 /* Return function to swap relocations out.  HTAB is the bfd's
  52    elf32_arm_link_hash_entry.  */
  53 #define SWAP_RELOC_OUT(HTAB) \
  54   ((HTAB)->use_rel \
  55    ? bfd_elf32_swap_reloc_out \
  56    : bfd_elf32_swap_reloca_out)
  57
  58 #define elf_info_to_howto               0
  59 #define elf_info_to_howto_rel           elf32_arm_info_to_howto
  60
  61 #define ARM_ELF_ABI_VERSION             0
  62 #define ARM_ELF_OS_ABI_VERSION          ELFOSABI_ARM
  63
  64 static struct elf_backend_data elf32_arm_vxworks_bed;
  65
  66 static bfd_boolean elf32_arm_write_section (bfd *output_bfd,
  67                                             struct bfd_link_info *link_info,
  68                                             asection *sec,
  69                                             bfd_byte *contents);
  70
  71 /* Note: code such as elf32_arm_reloc_type_lookup expect to use e.g.
  72    R_ARM_PC24 as an index into this, and find the R_ARM_PC24 HOWTO
  73    in that slot.  */
  74
  75 static reloc_howto_type elf32_arm_howto_table_1[] =
  76 {
  77   /* No relocation.  */
  78   HOWTO (R_ARM_NONE,            /* type */
  79          0,                     /* rightshift */
  80          0,                     /* size (0 = byte, 1 = short, 2 = long) */
  81          0,                     /* bitsize */
  82          FALSE,                 /* pc_relative */
  83          0,                     /* bitpos */
  84          complain_overflow_dont,/* complain_on_overflow */
  85          bfd_elf_generic_reloc, /* special_function */
  86          "R_ARM_NONE",          /* name */
  87          FALSE,                 /* partial_inplace */
  88          0,                     /* src_mask */
  89          0,                     /* dst_mask */
  90          FALSE),                /* pcrel_offset */
  91
  92   HOWTO (R_ARM_PC24,            /* type */
  93          2,                     /* rightshift */
  94          2,                     /* size (0 = byte, 1 = short, 2 = long) */
  95          24,                    /* bitsize */
  96          TRUE,                  /* pc_relative */
  97          0,                     /* bitpos */
  98          complain_overflow_signed,/* complain_on_overflow */
  99          bfd_elf_generic_reloc, /* special_function */
 100          "R_ARM_PC24",          /* name */
 101          FALSE,                 /* partial_inplace */
 102          0x00ffffff,            /* src_mask */
 103          0x00ffffff,            /* dst_mask */
 104          TRUE),                 /* pcrel_offset */
 105
 106   /* 32 bit absolute */
 107   HOWTO (R_ARM_ABS32,           /* type */
 108          0,                     /* rightshift */
 109          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 110          32,                    /* bitsize */
 111          FALSE,                 /* pc_relative */
 112          0,                     /* bitpos */
 113          complain_overflow_bitfield,/* complain_on_overflow */
 114          bfd_elf_generic_reloc, /* special_function */
 115          "R_ARM_ABS32",         /* name */
 116          FALSE,                 /* partial_inplace */
 117          0xffffffff,            /* src_mask */
 118          0xffffffff,            /* dst_mask */
 119          FALSE),                /* pcrel_offset */
 120
 121   /* standard 32bit pc-relative reloc */
 122   HOWTO (R_ARM_REL32,           /* type */
 123          0,                     /* rightshift */
 124          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 125          32,                    /* bitsize */
 126          TRUE,                  /* pc_relative */
 127          0,                     /* bitpos */
 128          complain_overflow_bitfield,/* complain_on_overflow */
 129          bfd_elf_generic_reloc, /* special_function */
 130          "R_ARM_REL32",         /* name */
 131          FALSE,                 /* partial_inplace */
 132          0xffffffff,            /* src_mask */
 133          0xffffffff,            /* dst_mask */
 134          TRUE),                 /* pcrel_offset */
 135
 136   /* 8 bit absolute - R_ARM_LDR_PC_G0 in AAELF */
 137   HOWTO (R_ARM_LDR_PC_G0,       /* type */
 138          0,                     /* rightshift */
 139          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 140          32,                    /* bitsize */
 141          TRUE,                  /* pc_relative */
 142          0,                     /* bitpos */
 143          complain_overflow_dont,/* complain_on_overflow */
 144          bfd_elf_generic_reloc, /* special_function */
 145          "R_ARM_LDR_PC_G0",     /* name */
 146          FALSE,                 /* partial_inplace */
 147          0xffffffff,            /* src_mask */
 148          0xffffffff,            /* dst_mask */
 149          TRUE),                 /* pcrel_offset */
 150
 151    /* 16 bit absolute */
 152   HOWTO (R_ARM_ABS16,           /* type */
 153          0,                     /* rightshift */
 154          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 155          16,                    /* bitsize */
 156          FALSE,                 /* pc_relative */
 157          0,                     /* bitpos */
 158          complain_overflow_bitfield,/* complain_on_overflow */
 159          bfd_elf_generic_reloc, /* special_function */
 160          "R_ARM_ABS16",         /* name */
 161          FALSE,                 /* partial_inplace */
 162          0x0000ffff,            /* src_mask */
 163          0x0000ffff,            /* dst_mask */
 164          FALSE),                /* pcrel_offset */
 165
 166   /* 12 bit absolute */
 167   HOWTO (R_ARM_ABS12,           /* type */
 168          0,                     /* rightshift */
 169          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 170          12,                    /* bitsize */
 171          FALSE,                 /* pc_relative */
 172          0,                     /* bitpos */
 173          complain_overflow_bitfield,/* complain_on_overflow */
 174          bfd_elf_generic_reloc, /* special_function */
 175          "R_ARM_ABS12",         /* name */
 176          FALSE,                 /* partial_inplace */
 177          0x00000fff,            /* src_mask */
 178          0x00000fff,            /* dst_mask */
 179          FALSE),                /* pcrel_offset */
 180
 181   HOWTO (R_ARM_THM_ABS5,        /* type */
 182          6,                     /* rightshift */
 183          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 184          5,                     /* bitsize */
 185          FALSE,                 /* pc_relative */
 186          0,                     /* bitpos */
 187          complain_overflow_bitfield,/* complain_on_overflow */
 188          bfd_elf_generic_reloc, /* special_function */
 189          "R_ARM_THM_ABS5",      /* name */
 190          FALSE,                 /* partial_inplace */
 191          0x000007e0,            /* src_mask */
 192          0x000007e0,            /* dst_mask */
 193          FALSE),                /* pcrel_offset */
 194
 195   /* 8 bit absolute */
 196   HOWTO (R_ARM_ABS8,            /* type */
 197          0,                     /* rightshift */
 198          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 199          8,                     /* bitsize */
 200          FALSE,                 /* pc_relative */
 201          0,                     /* bitpos */
 202          complain_overflow_bitfield,/* complain_on_overflow */
 203          bfd_elf_generic_reloc, /* special_function */
 204          "R_ARM_ABS8",          /* name */
 205          FALSE,                 /* partial_inplace */
 206          0x000000ff,            /* src_mask */
 207          0x000000ff,            /* dst_mask */
 208          FALSE),                /* pcrel_offset */
 209
 210   HOWTO (R_ARM_SBREL32,         /* type */
 211          0,                     /* rightshift */
 212          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 213          32,                    /* bitsize */
 214          FALSE,                 /* pc_relative */
 215          0,                     /* bitpos */
 216          complain_overflow_dont,/* complain_on_overflow */
 217          bfd_elf_generic_reloc, /* special_function */
 218          "R_ARM_SBREL32",       /* name */
 219          FALSE,                 /* partial_inplace */
 220          0xffffffff,            /* src_mask */
 221          0xffffffff,            /* dst_mask */
 222          FALSE),                /* pcrel_offset */
 223
 224   HOWTO (R_ARM_THM_CALL,        /* type */
 225          1,                     /* rightshift */
 226          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 227          25,                    /* bitsize */
 228          TRUE,                  /* pc_relative */
 229          0,                     /* bitpos */
 230          complain_overflow_signed,/* complain_on_overflow */
 231          bfd_elf_generic_reloc, /* special_function */
 232          "R_ARM_THM_CALL",      /* name */
 233          FALSE,                 /* partial_inplace */
 234          0x07ff07ff,            /* src_mask */
 235          0x07ff07ff,            /* dst_mask */
 236          TRUE),                 /* pcrel_offset */
 237
 238   HOWTO (R_ARM_THM_PC8,         /* type */
 239          1,                     /* rightshift */
 240          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 241          8,                     /* bitsize */
 242          TRUE,                  /* pc_relative */
 243          0,                     /* bitpos */
 244          complain_overflow_signed,/* complain_on_overflow */
 245          bfd_elf_generic_reloc, /* special_function */
 246          "R_ARM_THM_PC8",       /* name */
 247          FALSE,                 /* partial_inplace */
 248          0x000000ff,            /* src_mask */
 249          0x000000ff,            /* dst_mask */
 250          TRUE),                 /* pcrel_offset */
 251
 252   HOWTO (R_ARM_BREL_ADJ,        /* type */
 253          1,                     /* rightshift */
 254          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 255          32,                    /* bitsize */
 256          FALSE,                 /* pc_relative */
 257          0,                     /* bitpos */
 258          complain_overflow_signed,/* complain_on_overflow */
 259          bfd_elf_generic_reloc, /* special_function */
 260          "R_ARM_BREL_ADJ",      /* name */
 261          FALSE,                 /* partial_inplace */
 262          0xffffffff,            /* src_mask */
 263          0xffffffff,            /* dst_mask */
 264          FALSE),                /* pcrel_offset */
 265
 266   HOWTO (R_ARM_SWI24,           /* type */
 267          0,                     /* rightshift */
 268          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 269          0,                     /* bitsize */
 270          FALSE,                 /* pc_relative */
 271          0,                     /* bitpos */
 272          complain_overflow_signed,/* complain_on_overflow */
 273          bfd_elf_generic_reloc, /* special_function */
 274          "R_ARM_SWI24",         /* name */
 275          FALSE,                 /* partial_inplace */
 276          0x00000000,            /* src_mask */
 277          0x00000000,            /* dst_mask */
 278          FALSE),                /* pcrel_offset */
 279
 280   HOWTO (R_ARM_THM_SWI8,        /* type */
 281          0,                     /* rightshift */
 282          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 283          0,                     /* bitsize */
 284          FALSE,                 /* pc_relative */
 285          0,                     /* bitpos */
 286          complain_overflow_signed,/* complain_on_overflow */
 287          bfd_elf_generic_reloc, /* special_function */
 288          "R_ARM_SWI8",          /* name */
 289          FALSE,                 /* partial_inplace */
 290          0x00000000,            /* src_mask */
 291          0x00000000,            /* dst_mask */
 292          FALSE),                /* pcrel_offset */
 293
 294   /* BLX instruction for the ARM.  */
 295   HOWTO (R_ARM_XPC25,           /* type */
 296          2,                     /* rightshift */
 297          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 298          25,                    /* bitsize */
 299          TRUE,                  /* pc_relative */
 300          0,                     /* bitpos */
 301          complain_overflow_signed,/* complain_on_overflow */
 302          bfd_elf_generic_reloc, /* special_function */
 303          "R_ARM_XPC25",         /* name */
 304          FALSE,                 /* partial_inplace */
 305          0x00ffffff,            /* src_mask */
 306          0x00ffffff,            /* dst_mask */
 307          TRUE),                 /* pcrel_offset */
 308
 309   /* BLX instruction for the Thumb.  */
 310   HOWTO (R_ARM_THM_XPC22,       /* type */
 311          2,                     /* rightshift */
 312          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 313          22,                    /* bitsize */
 314          TRUE,                  /* pc_relative */
 315          0,                     /* bitpos */
 316          complain_overflow_signed,/* complain_on_overflow */
 317          bfd_elf_generic_reloc, /* special_function */
 318          "R_ARM_THM_XPC22",     /* name */
 319          FALSE,                 /* partial_inplace */
 320          0x07ff07ff,            /* src_mask */
 321          0x07ff07ff,            /* dst_mask */
 322          TRUE),                 /* pcrel_offset */
 323
 324   /* Dynamic TLS relocations.  */
 325
 326   HOWTO (R_ARM_TLS_DTPMOD32,    /* type */
 327          0,                     /* rightshift */
 328          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 329          32,                    /* bitsize */
 330          FALSE,                 /* pc_relative */
 331          0,                     /* bitpos */
 332          complain_overflow_bitfield,/* complain_on_overflow */
 333          bfd_elf_generic_reloc, /* special_function */
 334          "R_ARM_TLS_DTPMOD32",  /* name */
 335          TRUE,                  /* partial_inplace */
 336          0xffffffff,            /* src_mask */
 337          0xffffffff,            /* dst_mask */
 338          FALSE),                /* pcrel_offset */
 339
 340   HOWTO (R_ARM_TLS_DTPOFF32,    /* type */
 341          0,                     /* rightshift */
 342          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 343          32,                    /* bitsize */
 344          FALSE,                 /* pc_relative */
 345          0,                     /* bitpos */
 346          complain_overflow_bitfield,/* complain_on_overflow */
 347          bfd_elf_generic_reloc, /* special_function */
 348          "R_ARM_TLS_DTPOFF32",  /* name */
 349          TRUE,                  /* partial_inplace */
 350          0xffffffff,            /* src_mask */
 351          0xffffffff,            /* dst_mask */
 352          FALSE),                /* pcrel_offset */
 353
 354   HOWTO (R_ARM_TLS_TPOFF32,     /* type */
 355          0,                     /* rightshift */
 356          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 357          32,                    /* bitsize */
 358          FALSE,                 /* pc_relative */
 359          0,                     /* bitpos */
 360          complain_overflow_bitfield,/* complain_on_overflow */
 361          bfd_elf_generic_reloc, /* special_function */
 362          "R_ARM_TLS_TPOFF32",   /* name */
 363          TRUE,                  /* partial_inplace */
 364          0xffffffff,            /* src_mask */
 365          0xffffffff,            /* dst_mask */
 366          FALSE),                /* pcrel_offset */
 367
 368   /* Relocs used in ARM Linux */
 369
 370   HOWTO (R_ARM_COPY,            /* type */
 371          0,                     /* rightshift */
 372          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 373          32,                    /* bitsize */
 374          FALSE,                 /* pc_relative */
 375          0,                     /* bitpos */
 376          complain_overflow_bitfield,/* complain_on_overflow */
 377          bfd_elf_generic_reloc, /* special_function */
 378          "R_ARM_COPY",          /* name */
 379          TRUE,                  /* partial_inplace */
 380          0xffffffff,            /* src_mask */
 381          0xffffffff,            /* dst_mask */
 382          FALSE),                /* pcrel_offset */
 383
 384   HOWTO (R_ARM_GLOB_DAT,        /* type */
 385          0,                     /* rightshift */
 386          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 387          32,                    /* bitsize */
 388          FALSE,                 /* pc_relative */
 389          0,                     /* bitpos */
 390          complain_overflow_bitfield,/* complain_on_overflow */
 391          bfd_elf_generic_reloc, /* special_function */
 392          "R_ARM_GLOB_DAT",      /* name */
 393          TRUE,                  /* partial_inplace */
 394          0xffffffff,            /* src_mask */
 395          0xffffffff,            /* dst_mask */
 396          FALSE),                /* pcrel_offset */
 397
 398   HOWTO (R_ARM_JUMP_SLOT,       /* type */
 399          0,                     /* rightshift */
 400          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 401          32,                    /* bitsize */
 402          FALSE,                 /* pc_relative */
 403          0,                     /* bitpos */
 404          complain_overflow_bitfield,/* complain_on_overflow */
 405          bfd_elf_generic_reloc, /* special_function */
 406          "R_ARM_JUMP_SLOT",     /* name */
 407          TRUE,                  /* partial_inplace */
 408          0xffffffff,            /* src_mask */
 409          0xffffffff,            /* dst_mask */
 410          FALSE),                /* pcrel_offset */
 411
 412   HOWTO (R_ARM_RELATIVE,        /* type */
 413          0,                     /* rightshift */
 414          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 415          32,                    /* bitsize */
 416          FALSE,                 /* pc_relative */
 417          0,                     /* bitpos */
 418          complain_overflow_bitfield,/* complain_on_overflow */
 419          bfd_elf_generic_reloc, /* special_function */
 420          "R_ARM_RELATIVE",      /* name */
 421          TRUE,                  /* partial_inplace */
 422          0xffffffff,            /* src_mask */
 423          0xffffffff,            /* dst_mask */
 424          FALSE),                /* pcrel_offset */
 425
 426   HOWTO (R_ARM_GOTOFF32,        /* type */
 427          0,                     /* rightshift */
 428          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 429          32,                    /* bitsize */
 430          FALSE,                 /* pc_relative */
 431          0,                     /* bitpos */
 432          complain_overflow_bitfield,/* complain_on_overflow */
 433          bfd_elf_generic_reloc, /* special_function */
 434          "R_ARM_GOTOFF32",      /* name */
 435          TRUE,                  /* partial_inplace */
 436          0xffffffff,            /* src_mask */
 437          0xffffffff,            /* dst_mask */
 438          FALSE),                /* pcrel_offset */
 439
 440   HOWTO (R_ARM_GOTPC,           /* type */
 441          0,                     /* rightshift */
 442          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 443          32,                    /* bitsize */
 444          TRUE,                  /* pc_relative */
 445          0,                     /* bitpos */
 446          complain_overflow_bitfield,/* complain_on_overflow */
 447          bfd_elf_generic_reloc, /* special_function */
 448          "R_ARM_GOTPC",         /* name */
 449          TRUE,                  /* partial_inplace */
 450          0xffffffff,            /* src_mask */
 451          0xffffffff,            /* dst_mask */
 452          TRUE),                 /* pcrel_offset */
 453
 454   HOWTO (R_ARM_GOT32,           /* type */
 455          0,                     /* rightshift */
 456          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 457          32,                    /* bitsize */
 458          FALSE,                 /* pc_relative */
 459          0,                     /* bitpos */
 460          complain_overflow_bitfield,/* complain_on_overflow */
 461          bfd_elf_generic_reloc, /* special_function */
 462          "R_ARM_GOT32",         /* name */
 463          TRUE,                  /* partial_inplace */
 464          0xffffffff,            /* src_mask */
 465          0xffffffff,            /* dst_mask */
 466          FALSE),                /* pcrel_offset */
 467
 468   HOWTO (R_ARM_PLT32,           /* type */
 469          2,                     /* rightshift */
 470          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 471          24,                    /* bitsize */
 472          TRUE,                  /* pc_relative */
 473          0,                     /* bitpos */
 474          complain_overflow_bitfield,/* complain_on_overflow */
 475          bfd_elf_generic_reloc, /* special_function */
 476          "R_ARM_PLT32",         /* name */
 477          FALSE,                 /* partial_inplace */
 478          0x00ffffff,            /* src_mask */
 479          0x00ffffff,            /* dst_mask */
 480          TRUE),                 /* pcrel_offset */
 481
 482   HOWTO (R_ARM_CALL,            /* type */
 483          2,                     /* rightshift */
 484          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 485          24,                    /* bitsize */
 486          TRUE,                  /* pc_relative */
 487          0,                     /* bitpos */
 488          complain_overflow_signed,/* complain_on_overflow */
 489          bfd_elf_generic_reloc, /* special_function */
 490          "R_ARM_CALL",          /* name */
 491          FALSE,                 /* partial_inplace */
 492          0x00ffffff,            /* src_mask */
 493          0x00ffffff,            /* dst_mask */
 494          TRUE),                 /* pcrel_offset */
 495
 496   HOWTO (R_ARM_JUMP24,          /* type */
 497          2,                     /* rightshift */
 498          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 499          24,                    /* bitsize */
 500          TRUE,                  /* pc_relative */
 501          0,                     /* bitpos */
 502          complain_overflow_signed,/* complain_on_overflow */
 503          bfd_elf_generic_reloc, /* special_function */
 504          "R_ARM_JUMP24",        /* name */
 505          FALSE,                 /* partial_inplace */
 506          0x00ffffff,            /* src_mask */
 507          0x00ffffff,            /* dst_mask */
 508          TRUE),                 /* pcrel_offset */
 509
 510   HOWTO (R_ARM_THM_JUMP24,      /* type */
 511          1,                     /* rightshift */
 512          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 513          24,                    /* bitsize */
 514          TRUE,                  /* pc_relative */
 515          0,                     /* bitpos */
 516          complain_overflow_signed,/* complain_on_overflow */
 517          bfd_elf_generic_reloc, /* special_function */
 518          "R_ARM_THM_JUMP24",    /* name */
 519          FALSE,                 /* partial_inplace */
 520          0x07ff2fff,            /* src_mask */
 521          0x07ff2fff,            /* dst_mask */
 522          TRUE),                 /* pcrel_offset */
 523
 524   HOWTO (R_ARM_BASE_ABS,        /* type */
 525          0,                     /* rightshift */
 526          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 527          32,                    /* bitsize */
 528          FALSE,                 /* pc_relative */
 529          0,                     /* bitpos */
 530          complain_overflow_dont,/* complain_on_overflow */
 531          bfd_elf_generic_reloc, /* special_function */
 532          "R_ARM_BASE_ABS",      /* name */
 533          FALSE,                 /* partial_inplace */
 534          0xffffffff,            /* src_mask */
 535          0xffffffff,            /* dst_mask */
 536          FALSE),                /* pcrel_offset */
 537
 538   HOWTO (R_ARM_ALU_PCREL7_0,    /* type */
 539          0,                     /* rightshift */
 540          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 541          12,                    /* bitsize */
 542          TRUE,                  /* pc_relative */
 543          0,                     /* bitpos */
 544          complain_overflow_dont,/* complain_on_overflow */
 545          bfd_elf_generic_reloc, /* special_function */
 546          "R_ARM_ALU_PCREL_7_0", /* name */
 547          FALSE,                 /* partial_inplace */
 548          0x00000fff,            /* src_mask */
 549          0x00000fff,            /* dst_mask */
 550          TRUE),                 /* pcrel_offset */
 551
 552   HOWTO (R_ARM_ALU_PCREL15_8,   /* type */
 553          0,                     /* rightshift */
 554          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 555          12,                    /* bitsize */
 556          TRUE,                  /* pc_relative */
 557          8,                     /* bitpos */
 558          complain_overflow_dont,/* complain_on_overflow */
 559          bfd_elf_generic_reloc, /* special_function */
 560          "R_ARM_ALU_PCREL_15_8",/* name */
 561          FALSE,                 /* partial_inplace */
 562          0x00000fff,            /* src_mask */
 563          0x00000fff,            /* dst_mask */
 564          TRUE),                 /* pcrel_offset */
 565
 566   HOWTO (R_ARM_ALU_PCREL23_15,  /* type */
 567          0,                     /* rightshift */
 568          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 569          12,                    /* bitsize */
 570          TRUE,                  /* pc_relative */
 571          16,                    /* bitpos */
 572          complain_overflow_dont,/* complain_on_overflow */
 573          bfd_elf_generic_reloc, /* special_function */
 574          "R_ARM_ALU_PCREL_23_15",/* name */
 575          FALSE,                 /* partial_inplace */
 576          0x00000fff,            /* src_mask */
 577          0x00000fff,            /* dst_mask */
 578          TRUE),                 /* pcrel_offset */
 579
 580   HOWTO (R_ARM_LDR_SBREL_11_0,  /* type */
 581          0,                     /* rightshift */
 582          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 583          12,                    /* bitsize */
 584          FALSE,                 /* pc_relative */
 585          0,                     /* bitpos */
 586          complain_overflow_dont,/* complain_on_overflow */
 587          bfd_elf_generic_reloc, /* special_function */
 588          "R_ARM_LDR_SBREL_11_0",/* name */
 589          FALSE,                 /* partial_inplace */
 590          0x00000fff,            /* src_mask */
 591          0x00000fff,            /* dst_mask */
 592          FALSE),                /* pcrel_offset */
 593
 594   HOWTO (R_ARM_ALU_SBREL_19_12, /* type */
 595          0,                     /* rightshift */
 596          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 597          8,                     /* bitsize */
 598          FALSE,                 /* pc_relative */
 599          12,                    /* bitpos */
 600          complain_overflow_dont,/* complain_on_overflow */
 601          bfd_elf_generic_reloc, /* special_function */
 602          "R_ARM_ALU_SBREL_19_12",/* name */
 603          FALSE,                 /* partial_inplace */
 604          0x000ff000,            /* src_mask */
 605          0x000ff000,            /* dst_mask */
 606          FALSE),                /* pcrel_offset */
 607
 608   HOWTO (R_ARM_ALU_SBREL_27_20, /* type */
 609          0,                     /* rightshift */
 610          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 611          8,                     /* bitsize */
 612          FALSE,                 /* pc_relative */
 613          20,                    /* bitpos */
 614          complain_overflow_dont,/* complain_on_overflow */
 615          bfd_elf_generic_reloc, /* special_function */
 616          "R_ARM_ALU_SBREL_27_20",/* name */
 617          FALSE,                 /* partial_inplace */
 618          0x0ff00000,            /* src_mask */
 619          0x0ff00000,            /* dst_mask */
 620          FALSE),                /* pcrel_offset */
 621
 622   HOWTO (R_ARM_TARGET1,         /* type */
 623          0,                     /* rightshift */
 624          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 625          32,                    /* bitsize */
 626          FALSE,                 /* pc_relative */
 627          0,                     /* bitpos */
 628          complain_overflow_dont,/* complain_on_overflow */
 629          bfd_elf_generic_reloc, /* special_function */
 630          "R_ARM_TARGET1",       /* name */
 631          FALSE,                 /* partial_inplace */
 632          0xffffffff,            /* src_mask */
 633          0xffffffff,            /* dst_mask */
 634          FALSE),                /* pcrel_offset */
 635
 636   HOWTO (R_ARM_ROSEGREL32,      /* type */
 637          0,                     /* rightshift */
 638          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 639          32,                    /* bitsize */
 640          FALSE,                 /* pc_relative */
 641          0,                     /* bitpos */
 642          complain_overflow_dont,/* complain_on_overflow */
 643          bfd_elf_generic_reloc, /* special_function */
 644          "R_ARM_ROSEGREL32",    /* name */
 645          FALSE,                 /* partial_inplace */
 646          0xffffffff,            /* src_mask */
 647          0xffffffff,            /* dst_mask */
 648          FALSE),                /* pcrel_offset */
 649
 650   HOWTO (R_ARM_V4BX,            /* type */
 651          0,                     /* rightshift */
 652          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 653          32,                    /* bitsize */
 654          FALSE,                 /* pc_relative */
 655          0,                     /* bitpos */
 656          complain_overflow_dont,/* complain_on_overflow */
 657          bfd_elf_generic_reloc, /* special_function */
 658          "R_ARM_V4BX",          /* name */
 659          FALSE,                 /* partial_inplace */
 660          0xffffffff,            /* src_mask */
 661          0xffffffff,            /* dst_mask */
 662          FALSE),                /* pcrel_offset */
 663
 664   HOWTO (R_ARM_TARGET2,         /* type */
 665          0,                     /* rightshift */
 666          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 667          32,                    /* bitsize */
 668          FALSE,                 /* pc_relative */
 669          0,                     /* bitpos */
 670          complain_overflow_signed,/* complain_on_overflow */
 671          bfd_elf_generic_reloc, /* special_function */
 672          "R_ARM_TARGET2",       /* name */
 673          FALSE,                 /* partial_inplace */
 674          0xffffffff,            /* src_mask */
 675          0xffffffff,            /* dst_mask */
 676          TRUE),                 /* pcrel_offset */
 677
 678   HOWTO (R_ARM_PREL31,          /* type */
 679          0,                     /* rightshift */
 680          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 681          31,                    /* bitsize */
 682          TRUE,                  /* pc_relative */
 683          0,                     /* bitpos */
 684          complain_overflow_signed,/* complain_on_overflow */
 685          bfd_elf_generic_reloc, /* special_function */
 686          "R_ARM_PREL31",        /* name */
 687          FALSE,                 /* partial_inplace */
 688          0x7fffffff,            /* src_mask */
 689          0x7fffffff,            /* dst_mask */
 690          TRUE),                 /* pcrel_offset */
 691
 692   HOWTO (R_ARM_MOVW_ABS_NC,     /* type */
 693          0,                     /* rightshift */
 694          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 695          16,                    /* bitsize */
 696          FALSE,                 /* pc_relative */
 697          0,                     /* bitpos */
 698          complain_overflow_dont,/* complain_on_overflow */
 699          bfd_elf_generic_reloc, /* special_function */
 700          "R_ARM_MOVW_ABS_NC",   /* name */
 701          FALSE,                 /* partial_inplace */
 702          0x000f0fff,            /* src_mask */
 703          0x000f0fff,            /* dst_mask */
 704          FALSE),                /* pcrel_offset */
 705
 706   HOWTO (R_ARM_MOVT_ABS,        /* type */
 707          0,                     /* rightshift */
 708          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 709          16,                    /* bitsize */
 710          FALSE,                 /* pc_relative */
 711          0,                     /* bitpos */
 712          complain_overflow_bitfield,/* complain_on_overflow */
 713          bfd_elf_generic_reloc, /* special_function */
 714          "R_ARM_MOVT_ABS",      /* name */
 715          FALSE,                 /* partial_inplace */
 716          0x000f0fff,            /* src_mask */
 717          0x000f0fff,            /* dst_mask */
 718          FALSE),                /* pcrel_offset */
 719
 720   HOWTO (R_ARM_MOVW_PREL_NC,    /* type */
 721          0,                     /* rightshift */
 722          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 723          16,                    /* bitsize */
 724          TRUE,                  /* pc_relative */
 725          0,                     /* bitpos */
 726          complain_overflow_dont,/* complain_on_overflow */
 727          bfd_elf_generic_reloc, /* special_function */
 728          "R_ARM_MOVW_PREL_NC",  /* name */
 729          FALSE,                 /* partial_inplace */
 730          0x000f0fff,            /* src_mask */
 731          0x000f0fff,            /* dst_mask */
 732          TRUE),                 /* pcrel_offset */
 733
 734   HOWTO (R_ARM_MOVT_PREL,       /* type */
 735          0,                     /* rightshift */
 736          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 737          16,                    /* bitsize */
 738          TRUE,                  /* pc_relative */
 739          0,                     /* bitpos */
 740          complain_overflow_bitfield,/* complain_on_overflow */
 741          bfd_elf_generic_reloc, /* special_function */
 742          "R_ARM_MOVT_PREL",     /* name */
 743          FALSE,                 /* partial_inplace */
 744          0x000f0fff,            /* src_mask */
 745          0x000f0fff,            /* dst_mask */
 746          TRUE),                 /* pcrel_offset */
 747
 748   HOWTO (R_ARM_THM_MOVW_ABS_NC, /* type */
 749          0,                     /* rightshift */
 750          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 751          16,                    /* bitsize */
 752          FALSE,                 /* pc_relative */
 753          0,                     /* bitpos */
 754          complain_overflow_dont,/* complain_on_overflow */
 755          bfd_elf_generic_reloc, /* special_function */
 756          "R_ARM_THM_MOVW_ABS_NC",/* name */
 757          FALSE,                 /* partial_inplace */
 758          0x040f70ff,            /* src_mask */
 759          0x040f70ff,            /* dst_mask */
 760          FALSE),                /* pcrel_offset */
 761
 762   HOWTO (R_ARM_THM_MOVT_ABS,    /* type */
 763          0,                     /* rightshift */
 764          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 765          16,                    /* bitsize */
 766          FALSE,                 /* pc_relative */
 767          0,                     /* bitpos */
 768          complain_overflow_bitfield,/* complain_on_overflow */
 769          bfd_elf_generic_reloc, /* special_function */
 770          "R_ARM_THM_MOVT_ABS",  /* name */
 771          FALSE,                 /* partial_inplace */
 772          0x040f70ff,            /* src_mask */
 773          0x040f70ff,            /* dst_mask */
 774          FALSE),                /* pcrel_offset */
 775
 776   HOWTO (R_ARM_THM_MOVW_PREL_NC,/* type */
 777          0,                     /* rightshift */
 778          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 779          16,                    /* bitsize */
 780          TRUE,                  /* pc_relative */
 781          0,                     /* bitpos */
 782          complain_overflow_dont,/* complain_on_overflow */
 783          bfd_elf_generic_reloc, /* special_function */
 784          "R_ARM_THM_MOVW_PREL_NC",/* name */
 785          FALSE,                 /* partial_inplace */
 786          0x040f70ff,            /* src_mask */
 787          0x040f70ff,            /* dst_mask */
 788          TRUE),                 /* pcrel_offset */
 789
 790   HOWTO (R_ARM_THM_MOVT_PREL,   /* type */
 791          0,                     /* rightshift */
 792          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 793          16,                    /* bitsize */
 794          TRUE,                  /* pc_relative */
 795          0,                     /* bitpos */
 796          complain_overflow_bitfield,/* complain_on_overflow */
 797          bfd_elf_generic_reloc, /* special_function */
 798          "R_ARM_THM_MOVT_PREL", /* name */
 799          FALSE,                 /* partial_inplace */
 800          0x040f70ff,            /* src_mask */
 801          0x040f70ff,            /* dst_mask */
 802          TRUE),                 /* pcrel_offset */
 803
 804   HOWTO (R_ARM_THM_JUMP19,      /* type */
 805          1,                     /* rightshift */
 806          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 807          19,                    /* bitsize */
 808          TRUE,                  /* pc_relative */
 809          0,                     /* bitpos */
 810          complain_overflow_signed,/* complain_on_overflow */
 811          bfd_elf_generic_reloc, /* special_function */
 812          "R_ARM_THM_JUMP19",    /* name */
 813          FALSE,                 /* partial_inplace */
 814          0x043f2fff,            /* src_mask */
 815          0x043f2fff,            /* dst_mask */
 816          TRUE),                 /* pcrel_offset */
 817
 818   HOWTO (R_ARM_THM_JUMP6,       /* type */
 819          1,                     /* rightshift */
 820          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 821          6,                     /* bitsize */
 822          TRUE,                  /* pc_relative */
 823          0,                     /* bitpos */
 824          complain_overflow_unsigned,/* complain_on_overflow */
 825          bfd_elf_generic_reloc, /* special_function */
 826          "R_ARM_THM_JUMP6",     /* name */
 827          FALSE,                 /* partial_inplace */
 828          0x02f8,                /* src_mask */
 829          0x02f8,                /* dst_mask */
 830          TRUE),                 /* pcrel_offset */
 831
 832   /* These are declared as 13-bit signed relocations because we can
 833      address -4095 .. 4095(base) by altering ADDW to SUBW or vice
 834      versa.  */
 835   HOWTO (R_ARM_THM_ALU_PREL_11_0,/* type */
 836          0,                     /* rightshift */
 837          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 838          13,                    /* bitsize */
 839          TRUE,                  /* pc_relative */
 840          0,                     /* bitpos */
 841          complain_overflow_dont,/* complain_on_overflow */
 842          bfd_elf_generic_reloc, /* special_function */
 843          "R_ARM_THM_ALU_PREL_11_0",/* name */
 844          FALSE,                 /* partial_inplace */
 845          0xffffffff,            /* src_mask */
 846          0xffffffff,            /* dst_mask */
 847          TRUE),                 /* pcrel_offset */
 848
 849   HOWTO (R_ARM_THM_PC12,        /* type */
 850          0,                     /* rightshift */
 851          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 852          13,                    /* bitsize */
 853          TRUE,                  /* pc_relative */
 854          0,                     /* bitpos */
 855          complain_overflow_dont,/* complain_on_overflow */
 856          bfd_elf_generic_reloc, /* special_function */
 857          "R_ARM_THM_PC12",      /* name */
 858          FALSE,                 /* partial_inplace */
 859          0xffffffff,            /* src_mask */
 860          0xffffffff,            /* dst_mask */
 861          TRUE),                 /* pcrel_offset */
 862
 863   HOWTO (R_ARM_ABS32_NOI,       /* type */
 864          0,                     /* rightshift */
 865          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 866          32,                    /* bitsize */
 867          FALSE,                 /* pc_relative */
 868          0,                     /* bitpos */
 869          complain_overflow_dont,/* complain_on_overflow */
 870          bfd_elf_generic_reloc, /* special_function */
 871          "R_ARM_ABS32_NOI",     /* name */
 872          FALSE,                 /* partial_inplace */
 873          0xffffffff,            /* src_mask */
 874          0xffffffff,            /* dst_mask */
 875          FALSE),                /* pcrel_offset */
 876
 877   HOWTO (R_ARM_REL32_NOI,       /* type */
 878          0,                     /* rightshift */
 879          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 880          32,                    /* bitsize */
 881          TRUE,                  /* pc_relative */
 882          0,                     /* bitpos */
 883          complain_overflow_dont,/* complain_on_overflow */
 884          bfd_elf_generic_reloc, /* special_function */
 885          "R_ARM_REL32_NOI",     /* name */
 886          FALSE,                 /* partial_inplace */
 887          0xffffffff,            /* src_mask */
 888          0xffffffff,            /* dst_mask */
 889          FALSE),                /* pcrel_offset */
 890
 891   /* Group relocations.  */
 892
 893   HOWTO (R_ARM_ALU_PC_G0_NC,    /* type */
 894          0,                     /* rightshift */
 895          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 896          32,                    /* bitsize */
 897          TRUE,                  /* pc_relative */
 898          0,                     /* bitpos */
 899          complain_overflow_dont,/* complain_on_overflow */
 900          bfd_elf_generic_reloc, /* special_function */
 901          "R_ARM_ALU_PC_G0_NC",  /* name */
 902          FALSE,                 /* partial_inplace */
 903          0xffffffff,            /* src_mask */
 904          0xffffffff,            /* dst_mask */
 905          TRUE),                 /* pcrel_offset */
 906
 907   HOWTO (R_ARM_ALU_PC_G0,       /* type */
 908          0,                     /* rightshift */
 909          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 910          32,                    /* bitsize */
 911          TRUE,                  /* pc_relative */
 912          0,                     /* bitpos */
 913          complain_overflow_dont,/* complain_on_overflow */
 914          bfd_elf_generic_reloc, /* special_function */
 915          "R_ARM_ALU_PC_G0",     /* name */
 916          FALSE,                 /* partial_inplace */
 917          0xffffffff,            /* src_mask */
 918          0xffffffff,            /* dst_mask */
 919          TRUE),                 /* pcrel_offset */
 920
 921   HOWTO (R_ARM_ALU_PC_G1_NC,    /* type */
 922          0,                     /* rightshift */
 923          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 924          32,                    /* bitsize */
 925          TRUE,                  /* pc_relative */
 926          0,                     /* bitpos */
 927          complain_overflow_dont,/* complain_on_overflow */
 928          bfd_elf_generic_reloc, /* special_function */
 929          "R_ARM_ALU_PC_G1_NC",  /* name */
 930          FALSE,                 /* partial_inplace */
 931          0xffffffff,            /* src_mask */
 932          0xffffffff,            /* dst_mask */
 933          TRUE),                 /* pcrel_offset */
 934
 935   HOWTO (R_ARM_ALU_PC_G1,       /* type */
 936          0,                     /* rightshift */
 937          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 938          32,                    /* bitsize */
 939          TRUE,                  /* pc_relative */
 940          0,                     /* bitpos */
 941          complain_overflow_dont,/* complain_on_overflow */
 942          bfd_elf_generic_reloc, /* special_function */
 943          "R_ARM_ALU_PC_G1",     /* name */
 944          FALSE,                 /* partial_inplace */
 945          0xffffffff,            /* src_mask */
 946          0xffffffff,            /* dst_mask */
 947          TRUE),                 /* pcrel_offset */
 948
 949   HOWTO (R_ARM_ALU_PC_G2,       /* type */
 950          0,                     /* rightshift */
 951          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 952          32,                    /* bitsize */
 953          TRUE,                  /* pc_relative */
 954          0,                     /* bitpos */
 955          complain_overflow_dont,/* complain_on_overflow */
 956          bfd_elf_generic_reloc, /* special_function */
 957          "R_ARM_ALU_PC_G2",     /* name */
 958          FALSE,                 /* partial_inplace */
 959          0xffffffff,            /* src_mask */
 960          0xffffffff,            /* dst_mask */
 961          TRUE),                 /* pcrel_offset */
 962
 963   HOWTO (R_ARM_LDR_PC_G1,       /* type */
 964          0,                     /* rightshift */
 965          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 966          32,                    /* bitsize */
 967          TRUE,                  /* pc_relative */
 968          0,                     /* bitpos */
 969          complain_overflow_dont,/* complain_on_overflow */
 970          bfd_elf_generic_reloc, /* special_function */
 971          "R_ARM_LDR_PC_G1",     /* name */
 972          FALSE,                 /* partial_inplace */
 973          0xffffffff,            /* src_mask */
 974          0xffffffff,            /* dst_mask */
 975          TRUE),                 /* pcrel_offset */
 976
 977   HOWTO (R_ARM_LDR_PC_G2,       /* type */
 978          0,                     /* rightshift */
 979          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 980          32,                    /* bitsize */
 981          TRUE,                  /* pc_relative */
 982          0,                     /* bitpos */
 983          complain_overflow_dont,/* complain_on_overflow */
 984          bfd_elf_generic_reloc, /* special_function */
 985          "R_ARM_LDR_PC_G2",     /* name */
 986          FALSE,                 /* partial_inplace */
 987          0xffffffff,            /* src_mask */
 988          0xffffffff,            /* dst_mask */
 989          TRUE),                 /* pcrel_offset */
 990
 991   HOWTO (R_ARM_LDRS_PC_G0,      /* type */
 992          0,                     /* rightshift */
 993          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 994          32,                    /* bitsize */
 995          TRUE,                  /* pc_relative */
 996          0,                     /* bitpos */
 997          complain_overflow_dont,/* complain_on_overflow */
 998          bfd_elf_generic_reloc, /* special_function */
 999          "R_ARM_LDRS_PC_G0",    /* name */
1000          FALSE,                 /* partial_inplace */
1001          0xffffffff,            /* src_mask */
1002          0xffffffff,            /* dst_mask */
1003          TRUE),                 /* pcrel_offset */
1004
1005   HOWTO (R_ARM_LDRS_PC_G1,      /* type */
1006          0,                     /* rightshift */
1007          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1008          32,                    /* bitsize */
1009          TRUE,                  /* pc_relative */
1010          0,                     /* bitpos */
1011          complain_overflow_dont,/* complain_on_overflow */
1012          bfd_elf_generic_reloc, /* special_function */
1013          "R_ARM_LDRS_PC_G1",    /* name */
1014          FALSE,                 /* partial_inplace */
1015          0xffffffff,            /* src_mask */
1016          0xffffffff,            /* dst_mask */
1017          TRUE),                 /* pcrel_offset */
1018
1019   HOWTO (R_ARM_LDRS_PC_G2,      /* type */
1020          0,                     /* rightshift */
1021          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1022          32,                    /* bitsize */
1023          TRUE,                  /* pc_relative */
1024          0,                     /* bitpos */
1025          complain_overflow_dont,/* complain_on_overflow */
1026          bfd_elf_generic_reloc, /* special_function */
1027          "R_ARM_LDRS_PC_G2",    /* name */
1028          FALSE,                 /* partial_inplace */
1029          0xffffffff,            /* src_mask */
1030          0xffffffff,            /* dst_mask */
1031          TRUE),                 /* pcrel_offset */
1032
1033   HOWTO (R_ARM_LDC_PC_G0,       /* type */
1034          0,                     /* rightshift */
1035          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1036          32,                    /* bitsize */
1037          TRUE,                  /* pc_relative */
1038          0,                     /* bitpos */
1039          complain_overflow_dont,/* complain_on_overflow */
1040          bfd_elf_generic_reloc, /* special_function */
1041          "R_ARM_LDC_PC_G0",     /* name */
1042          FALSE,                 /* partial_inplace */
1043          0xffffffff,            /* src_mask */
1044          0xffffffff,            /* dst_mask */
1045          TRUE),                 /* pcrel_offset */
1046
1047   HOWTO (R_ARM_LDC_PC_G1,       /* type */
1048          0,                     /* rightshift */
1049          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1050          32,                    /* bitsize */
1051          TRUE,                  /* pc_relative */
1052          0,                     /* bitpos */
1053          complain_overflow_dont,/* complain_on_overflow */
1054          bfd_elf_generic_reloc, /* special_function */
1055          "R_ARM_LDC_PC_G1",     /* name */
1056          FALSE,                 /* partial_inplace */
1057          0xffffffff,            /* src_mask */
1058          0xffffffff,            /* dst_mask */
1059          TRUE),                 /* pcrel_offset */
1060
1061   HOWTO (R_ARM_LDC_PC_G2,       /* type */
1062          0,                     /* rightshift */
1063          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1064          32,                    /* bitsize */
1065          TRUE,                  /* pc_relative */
1066          0,                     /* bitpos */
1067          complain_overflow_dont,/* complain_on_overflow */
1068          bfd_elf_generic_reloc, /* special_function */
1069          "R_ARM_LDC_PC_G2",     /* name */
1070          FALSE,                 /* partial_inplace */
1071          0xffffffff,            /* src_mask */
1072          0xffffffff,            /* dst_mask */
1073          TRUE),                 /* pcrel_offset */
1074
1075   HOWTO (R_ARM_ALU_SB_G0_NC,    /* type */
1076          0,                     /* rightshift */
1077          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1078          32,                    /* bitsize */
1079          TRUE,                  /* pc_relative */
1080          0,                     /* bitpos */
1081          complain_overflow_dont,/* complain_on_overflow */
1082          bfd_elf_generic_reloc, /* special_function */
1083          "R_ARM_ALU_SB_G0_NC",  /* name */
1084          FALSE,                 /* partial_inplace */
1085          0xffffffff,            /* src_mask */
1086          0xffffffff,            /* dst_mask */
1087          TRUE),                 /* pcrel_offset */
1088
1089   HOWTO (R_ARM_ALU_SB_G0,       /* type */
1090          0,                     /* rightshift */
1091          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1092          32,                    /* bitsize */
1093          TRUE,                  /* pc_relative */
1094          0,                     /* bitpos */
1095          complain_overflow_dont,/* complain_on_overflow */
1096          bfd_elf_generic_reloc, /* special_function */
1097          "R_ARM_ALU_SB_G0",     /* name */
1098          FALSE,                 /* partial_inplace */
1099          0xffffffff,            /* src_mask */
1100          0xffffffff,            /* dst_mask */
1101          TRUE),                 /* pcrel_offset */
1102
1103   HOWTO (R_ARM_ALU_SB_G1_NC,    /* type */
1104          0,                     /* rightshift */
1105          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1106          32,                    /* bitsize */
1107          TRUE,                  /* pc_relative */
1108          0,                     /* bitpos */
1109          complain_overflow_dont,/* complain_on_overflow */
1110          bfd_elf_generic_reloc, /* special_function */
1111          "R_ARM_ALU_SB_G1_NC",  /* name */
1112          FALSE,                 /* partial_inplace */
1113          0xffffffff,            /* src_mask */
1114          0xffffffff,            /* dst_mask */
1115          TRUE),                 /* pcrel_offset */
1116
1117   HOWTO (R_ARM_ALU_SB_G1,       /* type */
1118          0,                     /* rightshift */
1119          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1120          32,                    /* bitsize */
1121          TRUE,                  /* pc_relative */
1122          0,                     /* bitpos */
1123          complain_overflow_dont,/* complain_on_overflow */
1124          bfd_elf_generic_reloc, /* special_function */
1125          "R_ARM_ALU_SB_G1",     /* name */
1126          FALSE,                 /* partial_inplace */
1127          0xffffffff,            /* src_mask */
1128          0xffffffff,            /* dst_mask */
1129          TRUE),                 /* pcrel_offset */
1130
1131   HOWTO (R_ARM_ALU_SB_G2,       /* type */
1132          0,                     /* rightshift */
1133          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1134          32,                    /* bitsize */
1135          TRUE,                  /* pc_relative */
1136          0,                     /* bitpos */
1137          complain_overflow_dont,/* complain_on_overflow */
1138          bfd_elf_generic_reloc, /* special_function */
1139          "R_ARM_ALU_SB_G2",     /* name */
1140          FALSE,                 /* partial_inplace */
1141          0xffffffff,            /* src_mask */
1142          0xffffffff,            /* dst_mask */
1143          TRUE),                 /* pcrel_offset */
1144
1145   HOWTO (R_ARM_LDR_SB_G0,       /* type */
1146          0,                     /* rightshift */
1147          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1148          32,                    /* bitsize */
1149          TRUE,                  /* pc_relative */
1150          0,                     /* bitpos */
1151          complain_overflow_dont,/* complain_on_overflow */
1152          bfd_elf_generic_reloc, /* special_function */
1153          "R_ARM_LDR_SB_G0",     /* name */
1154          FALSE,                 /* partial_inplace */
1155          0xffffffff,            /* src_mask */
1156          0xffffffff,            /* dst_mask */
1157          TRUE),                 /* pcrel_offset */
1158
1159   HOWTO (R_ARM_LDR_SB_G1,       /* type */
1160          0,                     /* rightshift */
1161          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1162          32,                    /* bitsize */
1163          TRUE,                  /* pc_relative */
1164          0,                     /* bitpos */
1165          complain_overflow_dont,/* complain_on_overflow */
1166          bfd_elf_generic_reloc, /* special_function */
1167          "R_ARM_LDR_SB_G1",     /* name */
1168          FALSE,                 /* partial_inplace */
1169          0xffffffff,            /* src_mask */
1170          0xffffffff,            /* dst_mask */
1171          TRUE),                 /* pcrel_offset */
1172
1173   HOWTO (R_ARM_LDR_SB_G2,       /* type */
1174          0,                     /* rightshift */
1175          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1176          32,                    /* bitsize */
1177          TRUE,                  /* pc_relative */
1178          0,                     /* bitpos */
1179          complain_overflow_dont,/* complain_on_overflow */
1180          bfd_elf_generic_reloc, /* special_function */
1181          "R_ARM_LDR_SB_G2",     /* name */
1182          FALSE,                 /* partial_inplace */
1183          0xffffffff,            /* src_mask */
1184          0xffffffff,            /* dst_mask */
1185          TRUE),                 /* pcrel_offset */
1186
1187   HOWTO (R_ARM_LDRS_SB_G0,      /* type */
1188          0,                     /* rightshift */
1189          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1190          32,                    /* bitsize */
1191          TRUE,                  /* pc_relative */
1192          0,                     /* bitpos */
1193          complain_overflow_dont,/* complain_on_overflow */
1194          bfd_elf_generic_reloc, /* special_function */
1195          "R_ARM_LDRS_SB_G0",    /* name */
1196          FALSE,                 /* partial_inplace */
1197          0xffffffff,            /* src_mask */
1198          0xffffffff,            /* dst_mask */
1199          TRUE),                 /* pcrel_offset */
1200
1201   HOWTO (R_ARM_LDRS_SB_G1,      /* type */
1202          0,                     /* rightshift */
1203          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1204          32,                    /* bitsize */
1205          TRUE,                  /* pc_relative */
1206          0,                     /* bitpos */
1207          complain_overflow_dont,/* complain_on_overflow */
1208          bfd_elf_generic_reloc, /* special_function */
1209          "R_ARM_LDRS_SB_G1",    /* name */
1210          FALSE,                 /* partial_inplace */
1211          0xffffffff,            /* src_mask */
1212          0xffffffff,            /* dst_mask */
1213          TRUE),                 /* pcrel_offset */
1214
1215   HOWTO (R_ARM_LDRS_SB_G2,      /* type */
1216          0,                     /* rightshift */
1217          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1218          32,                    /* bitsize */
1219          TRUE,                  /* pc_relative */
1220          0,                     /* bitpos */
1221          complain_overflow_dont,/* complain_on_overflow */
1222          bfd_elf_generic_reloc, /* special_function */
1223          "R_ARM_LDRS_SB_G2",    /* name */
1224          FALSE,                 /* partial_inplace */
1225          0xffffffff,            /* src_mask */
1226          0xffffffff,            /* dst_mask */
1227          TRUE),                 /* pcrel_offset */
1228
1229   HOWTO (R_ARM_LDC_SB_G0,       /* type */
1230          0,                     /* rightshift */
1231          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1232          32,                    /* bitsize */
1233          TRUE,                  /* pc_relative */
1234          0,                     /* bitpos */
1235          complain_overflow_dont,/* complain_on_overflow */
1236          bfd_elf_generic_reloc, /* special_function */
1237          "R_ARM_LDC_SB_G0",     /* name */
1238          FALSE,                 /* partial_inplace */
1239          0xffffffff,            /* src_mask */
1240          0xffffffff,            /* dst_mask */
1241          TRUE),                 /* pcrel_offset */
1242
1243   HOWTO (R_ARM_LDC_SB_G1,       /* type */
1244          0,                     /* rightshift */
1245          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1246          32,                    /* bitsize */
1247          TRUE,                  /* pc_relative */
1248          0,                     /* bitpos */
1249          complain_overflow_dont,/* complain_on_overflow */
1250          bfd_elf_generic_reloc, /* special_function */
1251          "R_ARM_LDC_SB_G1",     /* name */
1252          FALSE,                 /* partial_inplace */
1253          0xffffffff,            /* src_mask */
1254          0xffffffff,            /* dst_mask */
1255          TRUE),                 /* pcrel_offset */
1256
1257   HOWTO (R_ARM_LDC_SB_G2,       /* type */
1258          0,                     /* rightshift */
1259          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1260          32,                    /* bitsize */
1261          TRUE,                  /* pc_relative */
1262          0,                     /* bitpos */
1263          complain_overflow_dont,/* complain_on_overflow */
1264          bfd_elf_generic_reloc, /* special_function */
1265          "R_ARM_LDC_SB_G2",     /* name */
1266          FALSE,                 /* partial_inplace */
1267          0xffffffff,            /* src_mask */
1268          0xffffffff,            /* dst_mask */
1269          TRUE),                 /* pcrel_offset */
1270
1271   /* End of group relocations.  */
1272
1273   HOWTO (R_ARM_MOVW_BREL_NC,    /* type */
1274          0,                     /* rightshift */
1275          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1276          16,                    /* bitsize */
1277          FALSE,                 /* pc_relative */
1278          0,                     /* bitpos */
1279          complain_overflow_dont,/* complain_on_overflow */
1280          bfd_elf_generic_reloc, /* special_function */
1281          "R_ARM_MOVW_BREL_NC",  /* name */
1282          FALSE,                 /* partial_inplace */
1283          0x0000ffff,            /* src_mask */
1284          0x0000ffff,            /* dst_mask */
1285          FALSE),                /* pcrel_offset */
1286
1287   HOWTO (R_ARM_MOVT_BREL,       /* type */
1288          0,                     /* rightshift */
1289          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1290          16,                    /* bitsize */
1291          FALSE,                 /* pc_relative */
1292          0,                     /* bitpos */
1293          complain_overflow_bitfield,/* complain_on_overflow */
1294          bfd_elf_generic_reloc, /* special_function */
1295          "R_ARM_MOVT_BREL",     /* name */
1296          FALSE,                 /* partial_inplace */
1297          0x0000ffff,            /* src_mask */
1298          0x0000ffff,            /* dst_mask */
1299          FALSE),                /* pcrel_offset */
1300
1301   HOWTO (R_ARM_MOVW_BREL,       /* type */
1302          0,                     /* rightshift */
1303          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1304          16,                    /* bitsize */
1305          FALSE,                 /* pc_relative */
1306          0,                     /* bitpos */
1307          complain_overflow_dont,/* complain_on_overflow */
1308          bfd_elf_generic_reloc, /* special_function */
1309          "R_ARM_MOVW_BREL",     /* name */
1310          FALSE,                 /* partial_inplace */
1311          0x0000ffff,            /* src_mask */
1312          0x0000ffff,            /* dst_mask */
1313          FALSE),                /* pcrel_offset */
1314
1315   HOWTO (R_ARM_THM_MOVW_BREL_NC,/* type */
1316          0,                     /* rightshift */
1317          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1318          16,                    /* bitsize */
1319          FALSE,                 /* pc_relative */
1320          0,                     /* bitpos */
1321          complain_overflow_dont,/* complain_on_overflow */
1322          bfd_elf_generic_reloc, /* special_function */
1323          "R_ARM_THM_MOVW_BREL_NC",/* name */
1324          FALSE,                 /* partial_inplace */
1325          0x040f70ff,            /* src_mask */
1326          0x040f70ff,            /* dst_mask */
1327          FALSE),                /* pcrel_offset */
1328
1329   HOWTO (R_ARM_THM_MOVT_BREL,   /* type */
1330          0,                     /* rightshift */
1331          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1332          16,                    /* bitsize */
1333          FALSE,                 /* pc_relative */
1334          0,                     /* bitpos */
1335          complain_overflow_bitfield,/* complain_on_overflow */
1336          bfd_elf_generic_reloc, /* special_function */
1337          "R_ARM_THM_MOVT_BREL", /* name */
1338          FALSE,                 /* partial_inplace */
1339          0x040f70ff,            /* src_mask */
1340          0x040f70ff,            /* dst_mask */
1341          FALSE),                /* pcrel_offset */
1342
1343   HOWTO (R_ARM_THM_MOVW_BREL,   /* type */
1344          0,                     /* rightshift */
1345          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1346          16,                    /* bitsize */
1347          FALSE,                 /* pc_relative */
1348          0,                     /* bitpos */
1349          complain_overflow_dont,/* complain_on_overflow */
1350          bfd_elf_generic_reloc, /* special_function */
1351          "R_ARM_THM_MOVW_BREL", /* name */
1352          FALSE,                 /* partial_inplace */
1353          0x040f70ff,            /* src_mask */
1354          0x040f70ff,            /* dst_mask */
1355          FALSE),                /* pcrel_offset */
1356
1357   EMPTY_HOWTO (90),   /* Unallocated.  */
1358   EMPTY_HOWTO (91),
1359   EMPTY_HOWTO (92),
1360   EMPTY_HOWTO (93),
1361
1362   HOWTO (R_ARM_PLT32_ABS,       /* type */
1363          0,                     /* rightshift */
1364          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1365          32,                    /* bitsize */
1366          FALSE,                 /* pc_relative */
1367          0,                     /* bitpos */
1368          complain_overflow_dont,/* complain_on_overflow */
1369          bfd_elf_generic_reloc, /* special_function */
1370          "R_ARM_PLT32_ABS",     /* name */
1371          FALSE,                 /* partial_inplace */
1372          0xffffffff,            /* src_mask */
1373          0xffffffff,            /* dst_mask */
1374          FALSE),                /* pcrel_offset */
1375
1376   HOWTO (R_ARM_GOT_ABS,         /* type */
1377          0,                     /* rightshift */
1378          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1379          32,                    /* bitsize */
1380          FALSE,                 /* pc_relative */
1381          0,                     /* bitpos */
1382          complain_overflow_dont,/* complain_on_overflow */
1383          bfd_elf_generic_reloc, /* special_function */
1384          "R_ARM_GOT_ABS",       /* name */
1385          FALSE,                 /* partial_inplace */
1386          0xffffffff,            /* src_mask */
1387          0xffffffff,            /* dst_mask */
1388          FALSE),                        /* pcrel_offset */
1389
1390   HOWTO (R_ARM_GOT_PREL,        /* type */
1391          0,                     /* rightshift */
1392          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1393          32,                    /* bitsize */
1394          TRUE,                  /* pc_relative */
1395          0,                     /* bitpos */
1396          complain_overflow_dont,        /* complain_on_overflow */
1397          bfd_elf_generic_reloc, /* special_function */
1398          "R_ARM_GOT_PREL",      /* name */
1399          FALSE,                 /* partial_inplace */
1400          0xffffffff,            /* src_mask */
1401          0xffffffff,            /* dst_mask */
1402          TRUE),                 /* pcrel_offset */
1403
1404   HOWTO (R_ARM_GOT_BREL12,      /* type */
1405          0,                     /* rightshift */
1406          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1407          12,                    /* bitsize */
1408          FALSE,                 /* pc_relative */
1409          0,                     /* bitpos */
1410          complain_overflow_bitfield,/* complain_on_overflow */
1411          bfd_elf_generic_reloc, /* special_function */
1412          "R_ARM_GOT_BREL12",    /* name */
1413          FALSE,                 /* partial_inplace */
1414          0x00000fff,            /* src_mask */
1415          0x00000fff,            /* dst_mask */
1416          FALSE),                /* pcrel_offset */
1417
1418   HOWTO (R_ARM_GOTOFF12,        /* type */
1419          0,                     /* rightshift */
1420          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1421          12,                    /* bitsize */
1422          FALSE,                 /* pc_relative */
1423          0,                     /* bitpos */
1424          complain_overflow_bitfield,/* complain_on_overflow */
1425          bfd_elf_generic_reloc, /* special_function */
1426          "R_ARM_GOTOFF12",      /* name */
1427          FALSE,                 /* partial_inplace */
1428          0x00000fff,            /* src_mask */
1429          0x00000fff,            /* dst_mask */
1430          FALSE),                /* pcrel_offset */
1431
1432   EMPTY_HOWTO (R_ARM_GOTRELAX),  /* reserved for future GOT-load optimizations */
1433
1434   /* GNU extension to record C++ vtable member usage */
1435   HOWTO (R_ARM_GNU_VTENTRY,     /* type */
1436          0,                     /* rightshift */
1437          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1438          0,                     /* bitsize */
1439          FALSE,                 /* pc_relative */
1440          0,                     /* bitpos */
1441          complain_overflow_dont, /* complain_on_overflow */
1442          _bfd_elf_rel_vtable_reloc_fn,  /* special_function */
1443          "R_ARM_GNU_VTENTRY",   /* name */
1444          FALSE,                 /* partial_inplace */
1445          0,                     /* src_mask */
1446          0,                     /* dst_mask */
1447          FALSE),                /* pcrel_offset */
1448
1449   /* GNU extension to record C++ vtable hierarchy */
1450   HOWTO (R_ARM_GNU_VTINHERIT, /* type */
1451          0,                     /* rightshift */
1452          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1453          0,                     /* bitsize */
1454          FALSE,                 /* pc_relative */
1455          0,                     /* bitpos */
1456          complain_overflow_dont, /* complain_on_overflow */
1457          NULL,                  /* special_function */
1458          "R_ARM_GNU_VTINHERIT", /* name */
1459          FALSE,                 /* partial_inplace */
1460          0,                     /* src_mask */
1461          0,                     /* dst_mask */
1462          FALSE),                /* pcrel_offset */
1463
1464   HOWTO (R_ARM_THM_JUMP11,      /* type */
1465          1,                     /* rightshift */
1466          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1467          11,                    /* bitsize */
1468          TRUE,                  /* pc_relative */
1469          0,                     /* bitpos */
1470          complain_overflow_signed,      /* complain_on_overflow */
1471          bfd_elf_generic_reloc, /* special_function */
1472          "R_ARM_THM_JUMP11",    /* name */
1473          FALSE,                 /* partial_inplace */
1474          0x000007ff,            /* src_mask */
1475          0x000007ff,            /* dst_mask */
1476          TRUE),                 /* pcrel_offset */
1477
1478   HOWTO (R_ARM_THM_JUMP8,       /* type */
1479          1,                     /* rightshift */
1480          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1481          8,                     /* bitsize */
1482          TRUE,                  /* pc_relative */
1483          0,                     /* bitpos */
1484          complain_overflow_signed,      /* complain_on_overflow */
1485          bfd_elf_generic_reloc, /* special_function */
1486          "R_ARM_THM_JUMP8",     /* name */
1487          FALSE,                 /* partial_inplace */
1488          0x000000ff,            /* src_mask */
1489          0x000000ff,            /* dst_mask */
1490          TRUE),                 /* pcrel_offset */
1491
1492   /* TLS relocations */
1493   HOWTO (R_ARM_TLS_GD32,        /* type */
1494          0,                     /* rightshift */
1495          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1496          32,                    /* bitsize */
1497          FALSE,                 /* pc_relative */
1498          0,                     /* bitpos */
1499          complain_overflow_bitfield,/* complain_on_overflow */
1500          NULL,                  /* special_function */
1501          "R_ARM_TLS_GD32",      /* name */
1502          TRUE,                  /* partial_inplace */
1503          0xffffffff,            /* src_mask */
1504          0xffffffff,            /* dst_mask */
1505          FALSE),                /* pcrel_offset */
1506
1507   HOWTO (R_ARM_TLS_LDM32,       /* type */
1508          0,                     /* rightshift */
1509          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1510          32,                    /* bitsize */
1511          FALSE,                 /* pc_relative */
1512          0,                     /* bitpos */
1513          complain_overflow_bitfield,/* complain_on_overflow */
1514          bfd_elf_generic_reloc, /* special_function */
1515          "R_ARM_TLS_LDM32",     /* name */
1516          TRUE,                  /* partial_inplace */
1517          0xffffffff,            /* src_mask */
1518          0xffffffff,            /* dst_mask */
1519          FALSE),                /* pcrel_offset */
1520
1521   HOWTO (R_ARM_TLS_LDO32,       /* type */
1522          0,                     /* rightshift */
1523          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1524          32,                    /* bitsize */
1525          FALSE,                 /* pc_relative */
1526          0,                     /* bitpos */
1527          complain_overflow_bitfield,/* complain_on_overflow */
1528          bfd_elf_generic_reloc, /* special_function */
1529          "R_ARM_TLS_LDO32",     /* name */
1530          TRUE,                  /* partial_inplace */
1531          0xffffffff,            /* src_mask */
1532          0xffffffff,            /* dst_mask */
1533          FALSE),                /* pcrel_offset */
1534
1535   HOWTO (R_ARM_TLS_IE32,        /* type */
1536          0,                     /* rightshift */
1537          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1538          32,                    /* bitsize */
1539          FALSE,                  /* pc_relative */
1540          0,                     /* bitpos */
1541          complain_overflow_bitfield,/* complain_on_overflow */
1542          NULL,                  /* special_function */
1543          "R_ARM_TLS_IE32",      /* name */
1544          TRUE,                  /* partial_inplace */
1545          0xffffffff,            /* src_mask */
1546          0xffffffff,            /* dst_mask */
1547          FALSE),                /* pcrel_offset */
1548
1549   HOWTO (R_ARM_TLS_LE32,        /* type */
1550          0,                     /* rightshift */
1551          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1552          32,                    /* bitsize */
1553          FALSE,                 /* pc_relative */
1554          0,                     /* bitpos */
1555          complain_overflow_bitfield,/* complain_on_overflow */
1556          bfd_elf_generic_reloc, /* special_function */
1557          "R_ARM_TLS_LE32",      /* name */
1558          TRUE,                  /* partial_inplace */
1559          0xffffffff,            /* src_mask */
1560          0xffffffff,            /* dst_mask */
1561          FALSE),                /* pcrel_offset */
1562
1563   HOWTO (R_ARM_TLS_LDO12,       /* type */
1564          0,                     /* rightshift */
1565          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1566          12,                    /* bitsize */
1567          FALSE,                 /* pc_relative */
1568          0,                     /* bitpos */
1569          complain_overflow_bitfield,/* complain_on_overflow */
1570          bfd_elf_generic_reloc, /* special_function */
1571          "R_ARM_TLS_LDO12",     /* name */
1572          FALSE,                 /* partial_inplace */
1573          0x00000fff,            /* src_mask */
1574          0x00000fff,            /* dst_mask */
1575          FALSE),                /* pcrel_offset */
1576
1577   HOWTO (R_ARM_TLS_LE12,        /* type */
1578          0,                     /* rightshift */
1579          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1580          12,                    /* bitsize */
1581          FALSE,                 /* pc_relative */
1582          0,                     /* bitpos */
1583          complain_overflow_bitfield,/* complain_on_overflow */
1584          bfd_elf_generic_reloc, /* special_function */
1585          "R_ARM_TLS_LE12",      /* name */
1586          FALSE,                 /* partial_inplace */
1587          0x00000fff,            /* src_mask */
1588          0x00000fff,            /* dst_mask */
1589          FALSE),                /* pcrel_offset */
1590
1591   HOWTO (R_ARM_TLS_IE12GP,      /* type */
1592          0,                     /* rightshift */
1593          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1594          12,                    /* bitsize */
1595          FALSE,                 /* pc_relative */
1596          0,                     /* bitpos */
1597          complain_overflow_bitfield,/* complain_on_overflow */
1598          bfd_elf_generic_reloc, /* special_function */
1599          "R_ARM_TLS_IE12GP",    /* name */
1600          FALSE,                 /* partial_inplace */
1601          0x00000fff,            /* src_mask */
1602          0x00000fff,            /* dst_mask */
1603          FALSE),                /* pcrel_offset */
1604 };
1605
1606 /* 112-127 private relocations
1607    128 R_ARM_ME_TOO, obsolete
1608    129-255 unallocated in AAELF.
1609
1610    249-255 extended, currently unused, relocations:  */
1611
1612 static reloc_howto_type elf32_arm_howto_table_2[4] =
1613 {
1614   HOWTO (R_ARM_RREL32,          /* type */
1615          0,                     /* rightshift */
1616          0,                     /* size (0 = byte, 1 = short, 2 = long) */
1617          0,                     /* bitsize */
1618          FALSE,                 /* pc_relative */
1619          0,                     /* bitpos */
1620          complain_overflow_dont,/* complain_on_overflow */
1621          bfd_elf_generic_reloc, /* special_function */
1622          "R_ARM_RREL32",        /* name */
1623          FALSE,                 /* partial_inplace */
1624          0,                     /* src_mask */
1625          0,                     /* dst_mask */
1626          FALSE),                /* pcrel_offset */
1627
1628   HOWTO (R_ARM_RABS32,          /* type */
1629          0,                     /* rightshift */
1630          0,                     /* size (0 = byte, 1 = short, 2 = long) */
1631          0,                     /* bitsize */
1632          FALSE,                 /* pc_relative */
1633          0,                     /* bitpos */
1634          complain_overflow_dont,/* complain_on_overflow */
1635          bfd_elf_generic_reloc, /* special_function */
1636          "R_ARM_RABS32",        /* name */
1637          FALSE,                 /* partial_inplace */
1638          0,                     /* src_mask */
1639          0,                     /* dst_mask */
1640          FALSE),                /* pcrel_offset */
1641
1642   HOWTO (R_ARM_RPC24,           /* type */
1643          0,                     /* rightshift */
1644          0,                     /* size (0 = byte, 1 = short, 2 = long) */
1645          0,                     /* bitsize */
1646          FALSE,                 /* pc_relative */
1647          0,                     /* bitpos */
1648          complain_overflow_dont,/* complain_on_overflow */
1649          bfd_elf_generic_reloc, /* special_function */
1650          "R_ARM_RPC24",         /* name */
1651          FALSE,                 /* partial_inplace */
1652          0,                     /* src_mask */
1653          0,                     /* dst_mask */
1654          FALSE),                /* pcrel_offset */
1655
1656   HOWTO (R_ARM_RBASE,           /* type */
1657          0,                     /* rightshift */
1658          0,                     /* size (0 = byte, 1 = short, 2 = long) */
1659          0,                     /* bitsize */
1660          FALSE,                 /* pc_relative */
1661          0,                     /* bitpos */
1662          complain_overflow_dont,/* complain_on_overflow */
1663          bfd_elf_generic_reloc, /* special_function */
1664          "R_ARM_RBASE",         /* name */
1665          FALSE,                 /* partial_inplace */
1666          0,                     /* src_mask */
1667          0,                     /* dst_mask */
1668          FALSE)                 /* pcrel_offset */
1669 };
1670
1671 static reloc_howto_type *
1672 elf32_arm_howto_from_type (unsigned int r_type)
1673 {
1674   if (r_type < ARRAY_SIZE (elf32_arm_howto_table_1))
1675     return &elf32_arm_howto_table_1[r_type];
1676
1677   if (r_type >= R_ARM_RREL32
1678       && r_type < R_ARM_RREL32 + ARRAY_SIZE (elf32_arm_howto_table_2))
1679     return &elf32_arm_howto_table_2[r_type - R_ARM_RREL32];
1680
1681   return NULL;
1682 }
1683
1684 static void
1685 elf32_arm_info_to_howto (bfd * abfd ATTRIBUTE_UNUSED, arelent * bfd_reloc,
1686                          Elf_Internal_Rela * elf_reloc)
1687 {
1688   unsigned int r_type;
1689
1690   r_type = ELF32_R_TYPE (elf_reloc->r_info);
1691   bfd_reloc->howto = elf32_arm_howto_from_type (r_type);
1692 }
1693
1694 struct elf32_arm_reloc_map
1695   {
1696     bfd_reloc_code_real_type  bfd_reloc_val;
1697     unsigned char             elf_reloc_val;
1698   };
1699
1700 /* All entries in this list must also be present in elf32_arm_howto_table.  */
1701 static const struct elf32_arm_reloc_map elf32_arm_reloc_map[] =
1702   {
1703     {BFD_RELOC_NONE,                 R_ARM_NONE},
1704     {BFD_RELOC_ARM_PCREL_BRANCH,     R_ARM_PC24},
1705     {BFD_RELOC_ARM_PCREL_CALL,       R_ARM_CALL},
1706     {BFD_RELOC_ARM_PCREL_JUMP,       R_ARM_JUMP24},
1707     {BFD_RELOC_ARM_PCREL_BLX,        R_ARM_XPC25},
1708     {BFD_RELOC_THUMB_PCREL_BLX,      R_ARM_THM_XPC22},
1709     {BFD_RELOC_32,                   R_ARM_ABS32},
1710     {BFD_RELOC_32_PCREL,             R_ARM_REL32},
1711     {BFD_RELOC_8,                    R_ARM_ABS8},
1712     {BFD_RELOC_16,                   R_ARM_ABS16},
1713     {BFD_RELOC_ARM_OFFSET_IMM,       R_ARM_ABS12},
1714     {BFD_RELOC_ARM_THUMB_OFFSET,     R_ARM_THM_ABS5},
1715     {BFD_RELOC_THUMB_PCREL_BRANCH25, R_ARM_THM_JUMP24},
1716     {BFD_RELOC_THUMB_PCREL_BRANCH23, R_ARM_THM_CALL},
1717     {BFD_RELOC_THUMB_PCREL_BRANCH12, R_ARM_THM_JUMP11},
1718     {BFD_RELOC_THUMB_PCREL_BRANCH20, R_ARM_THM_JUMP19},
1719     {BFD_RELOC_THUMB_PCREL_BRANCH9,  R_ARM_THM_JUMP8},
1720     {BFD_RELOC_THUMB_PCREL_BRANCH7,  R_ARM_THM_JUMP6},
1721     {BFD_RELOC_ARM_GLOB_DAT,         R_ARM_GLOB_DAT},
1722     {BFD_RELOC_ARM_JUMP_SLOT,        R_ARM_JUMP_SLOT},
1723     {BFD_RELOC_ARM_RELATIVE,         R_ARM_RELATIVE},
1724     {BFD_RELOC_ARM_GOTOFF,           R_ARM_GOTOFF32},
1725     {BFD_RELOC_ARM_GOTPC,            R_ARM_GOTPC},
1726     {BFD_RELOC_ARM_GOT32,            R_ARM_GOT32},
1727     {BFD_RELOC_ARM_PLT32,            R_ARM_PLT32},
1728     {BFD_RELOC_ARM_TARGET1,          R_ARM_TARGET1},
1729     {BFD_RELOC_ARM_ROSEGREL32,       R_ARM_ROSEGREL32},
1730     {BFD_RELOC_ARM_SBREL32,          R_ARM_SBREL32},
1731     {BFD_RELOC_ARM_PREL31,           R_ARM_PREL31},
1732     {BFD_RELOC_ARM_TARGET2,          R_ARM_TARGET2},
1733     {BFD_RELOC_ARM_PLT32,            R_ARM_PLT32},
1734     {BFD_RELOC_ARM_TLS_GD32,         R_ARM_TLS_GD32},
1735     {BFD_RELOC_ARM_TLS_LDO32,        R_ARM_TLS_LDO32},
1736     {BFD_RELOC_ARM_TLS_LDM32,        R_ARM_TLS_LDM32},
1737     {BFD_RELOC_ARM_TLS_DTPMOD32,     R_ARM_TLS_DTPMOD32},
1738     {BFD_RELOC_ARM_TLS_DTPOFF32,     R_ARM_TLS_DTPOFF32},
1739     {BFD_RELOC_ARM_TLS_TPOFF32,      R_ARM_TLS_TPOFF32},
1740     {BFD_RELOC_ARM_TLS_IE32,         R_ARM_TLS_IE32},
1741     {BFD_RELOC_ARM_TLS_LE32,         R_ARM_TLS_LE32},
1742     {BFD_RELOC_VTABLE_INHERIT,       R_ARM_GNU_VTINHERIT},
1743     {BFD_RELOC_VTABLE_ENTRY,         R_ARM_GNU_VTENTRY},
1744     {BFD_RELOC_ARM_MOVW,             R_ARM_MOVW_ABS_NC},
1745     {BFD_RELOC_ARM_MOVT,             R_ARM_MOVT_ABS},
1746     {BFD_RELOC_ARM_MOVW_PCREL,       R_ARM_MOVW_PREL_NC},
1747     {BFD_RELOC_ARM_MOVT_PCREL,       R_ARM_MOVT_PREL},
1748     {BFD_RELOC_ARM_THUMB_MOVW,       R_ARM_THM_MOVW_ABS_NC},
1749     {BFD_RELOC_ARM_THUMB_MOVT,       R_ARM_THM_MOVT_ABS},
1750     {BFD_RELOC_ARM_THUMB_MOVW_PCREL, R_ARM_THM_MOVW_PREL_NC},
1751     {BFD_RELOC_ARM_THUMB_MOVT_PCREL, R_ARM_THM_MOVT_PREL},
1752     {BFD_RELOC_ARM_ALU_PC_G0_NC, R_ARM_ALU_PC_G0_NC},
1753     {BFD_RELOC_ARM_ALU_PC_G0, R_ARM_ALU_PC_G0},
1754     {BFD_RELOC_ARM_ALU_PC_G1_NC, R_ARM_ALU_PC_G1_NC},
1755     {BFD_RELOC_ARM_ALU_PC_G1, R_ARM_ALU_PC_G1},
1756     {BFD_RELOC_ARM_ALU_PC_G2, R_ARM_ALU_PC_G2},
1757     {BFD_RELOC_ARM_LDR_PC_G0, R_ARM_LDR_PC_G0},
1758     {BFD_RELOC_ARM_LDR_PC_G1, R_ARM_LDR_PC_G1},
1759     {BFD_RELOC_ARM_LDR_PC_G2, R_ARM_LDR_PC_G2},
1760     {BFD_RELOC_ARM_LDRS_PC_G0, R_ARM_LDRS_PC_G0},
1761     {BFD_RELOC_ARM_LDRS_PC_G1, R_ARM_LDRS_PC_G1},
1762     {BFD_RELOC_ARM_LDRS_PC_G2, R_ARM_LDRS_PC_G2},
1763     {BFD_RELOC_ARM_LDC_PC_G0, R_ARM_LDC_PC_G0},
1764     {BFD_RELOC_ARM_LDC_PC_G1, R_ARM_LDC_PC_G1},
1765     {BFD_RELOC_ARM_LDC_PC_G2, R_ARM_LDC_PC_G2},
1766     {BFD_RELOC_ARM_ALU_SB_G0_NC, R_ARM_ALU_SB_G0_NC},
1767     {BFD_RELOC_ARM_ALU_SB_G0, R_ARM_ALU_SB_G0},
1768     {BFD_RELOC_ARM_ALU_SB_G1_NC, R_ARM_ALU_SB_G1_NC},
1769     {BFD_RELOC_ARM_ALU_SB_G1, R_ARM_ALU_SB_G1},
1770     {BFD_RELOC_ARM_ALU_SB_G2, R_ARM_ALU_SB_G2},
1771     {BFD_RELOC_ARM_LDR_SB_G0, R_ARM_LDR_SB_G0},
1772     {BFD_RELOC_ARM_LDR_SB_G1, R_ARM_LDR_SB_G1},
1773     {BFD_RELOC_ARM_LDR_SB_G2, R_ARM_LDR_SB_G2},
1774     {BFD_RELOC_ARM_LDRS_SB_G0, R_ARM_LDRS_SB_G0},
1775     {BFD_RELOC_ARM_LDRS_SB_G1, R_ARM_LDRS_SB_G1},
1776     {BFD_RELOC_ARM_LDRS_SB_G2, R_ARM_LDRS_SB_G2},
1777     {BFD_RELOC_ARM_LDC_SB_G0, R_ARM_LDC_SB_G0},
1778     {BFD_RELOC_ARM_LDC_SB_G1, R_ARM_LDC_SB_G1},
1779     {BFD_RELOC_ARM_LDC_SB_G2, R_ARM_LDC_SB_G2},
1780     {BFD_RELOC_ARM_V4BX,             R_ARM_V4BX}
1781   };
1782
1783 static reloc_howto_type *
1784 elf32_arm_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1785                              bfd_reloc_code_real_type code)
1786 {
1787   unsigned int i;
1788
1789   for (i = 0; i < ARRAY_SIZE (elf32_arm_reloc_map); i ++)
1790     if (elf32_arm_reloc_map[i].bfd_reloc_val == code)
1791       return elf32_arm_howto_from_type (elf32_arm_reloc_map[i].elf_reloc_val);
1792
1793   return NULL;
1794 }
1795
1796 static reloc_howto_type *
1797 elf32_arm_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1798                              const char *r_name)
1799 {
1800   unsigned int i;
1801
1802   for (i = 0; i < ARRAY_SIZE (elf32_arm_howto_table_1); i++)
1803     if (elf32_arm_howto_table_1[i].name != NULL
1804         && strcasecmp (elf32_arm_howto_table_1[i].name, r_name) == 0)
1805       return &elf32_arm_howto_table_1[i];
1806
1807   for (i = 0; i < ARRAY_SIZE (elf32_arm_howto_table_2); i++)
1808     if (elf32_arm_howto_table_2[i].name != NULL
1809         && strcasecmp (elf32_arm_howto_table_2[i].name, r_name) == 0)
1810       return &elf32_arm_howto_table_2[i];
1811
1812   return NULL;
1813 }
1814
1815 /* Support for core dump NOTE sections.  */
1816
1817 static bfd_boolean
1818 elf32_arm_nabi_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
1819 {
1820   int offset;
1821   size_t size;
1822
1823   switch (note->descsz)
1824     {
1825       default:
1826         return FALSE;
1827
1828       case 148:         /* Linux/ARM 32-bit.  */
1829         /* pr_cursig */
1830         elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
1831
1832         /* pr_pid */
1833         elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
1834
1835         /* pr_reg */
1836         offset = 72;
1837         size = 72;
1838
1839         break;
1840     }
1841
1842   /* Make a ".reg/999" section.  */
1843   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
1844                                           size, note->descpos + offset);
1845 }
1846
1847 static bfd_boolean
1848 elf32_arm_nabi_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
1849 {
1850   switch (note->descsz)
1851     {
1852       default:
1853         return FALSE;
1854
1855       case 124:         /* Linux/ARM elf_prpsinfo.  */
1856         elf_tdata (abfd)->core_program
1857          = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
1858         elf_tdata (abfd)->core_command
1859          = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
1860     }
1861
1862   /* Note that for some reason, a spurious space is tacked
1863      onto the end of the args in some (at least one anyway)
1864      implementations, so strip it off if it exists.  */
1865   {
1866     char *command = elf_tdata (abfd)->core_command;
1867     int n = strlen (command);
1868
1869     if (0 < n && command[n - 1] == ' ')
1870       command[n - 1] = '\0';
1871   }
1872
1873   return TRUE;
1874 }
1875
1876 #define TARGET_LITTLE_SYM               bfd_elf32_littlearm_vec
1877 #define TARGET_LITTLE_NAME              "elf32-littlearm"
1878 #define TARGET_BIG_SYM                  bfd_elf32_bigarm_vec
1879 #define TARGET_BIG_NAME                 "elf32-bigarm"
1880
1881 #define elf_backend_grok_prstatus       elf32_arm_nabi_grok_prstatus
1882 #define elf_backend_grok_psinfo         elf32_arm_nabi_grok_psinfo
1883
1884 typedef unsigned long int insn32;
1885 typedef unsigned short int insn16;
1886
1887 /* In lieu of proper flags, assume all EABIv4 or later objects are
1888    interworkable.  */
1889 #define INTERWORK_FLAG(abfd)  \
1890   (EF_ARM_EABI_VERSION (elf_elfheader (abfd)->e_flags) >= EF_ARM_EABI_VER4 \
1891   || (elf_elfheader (abfd)->e_flags & EF_ARM_INTERWORK) \
1892   || ((abfd)->flags & BFD_LINKER_CREATED))
1893
1894 /* The linker script knows the section names for placement.
1895    The entry_names are used to do simple name mangling on the stubs.
1896    Given a function name, and its type, the stub can be found. The
1897    name can be changed. The only requirement is the %s be present.  */
1898 #define THUMB2ARM_GLUE_SECTION_NAME ".glue_7t"
1899 #define THUMB2ARM_GLUE_ENTRY_NAME   "__%s_from_thumb"
1900
1901 #define ARM2THUMB_GLUE_SECTION_NAME ".glue_7"
1902 #define ARM2THUMB_GLUE_ENTRY_NAME   "__%s_from_arm"
1903
1904 #define VFP11_ERRATUM_VENEER_SECTION_NAME ".vfp11_veneer"
1905 #define VFP11_ERRATUM_VENEER_ENTRY_NAME   "__vfp11_veneer_%x"
1906
1907 #define ARM_BX_GLUE_SECTION_NAME ".v4_bx"
1908 #define ARM_BX_GLUE_ENTRY_NAME   "__bx_r%d"
1909
1910 #define STUB_ENTRY_NAME   "__%s_veneer"
1911
1912 /* The name of the dynamic interpreter.  This is put in the .interp
1913    section.  */
1914 #define ELF_DYNAMIC_INTERPRETER     "/usr/lib/ld.so.1"
1915
1916 #ifdef FOUR_WORD_PLT
1917
1918 /* The first entry in a procedure linkage table looks like
1919    this.  It is set up so that any shared library function that is
1920    called before the relocation has been set up calls the dynamic
1921    linker first.  */
1922 static const bfd_vma elf32_arm_plt0_entry [] =
1923   {
1924     0xe52de004,         /* str   lr, [sp, #-4]! */
1925     0xe59fe010,         /* ldr   lr, [pc, #16]  */
1926     0xe08fe00e,         /* add   lr, pc, lr     */
1927     0xe5bef008,         /* ldr   pc, [lr, #8]!  */
1928   };
1929
1930 /* Subsequent entries in a procedure linkage table look like
1931    this.  */
1932 static const bfd_vma elf32_arm_plt_entry [] =
1933   {
1934     0xe28fc600,         /* add   ip, pc, #NN    */
1935     0xe28cca00,         /* add   ip, ip, #NN    */
1936     0xe5bcf000,         /* ldr   pc, [ip, #NN]! */
1937     0x00000000,         /* unused               */
1938   };
1939
1940 #else
1941
1942 /* The first entry in a procedure linkage table looks like
1943    this.  It is set up so that any shared library function that is
1944    called before the relocation has been set up calls the dynamic
1945    linker first.  */
1946 static const bfd_vma elf32_arm_plt0_entry [] =
1947   {
1948     0xe52de004,         /* str   lr, [sp, #-4]! */
1949     0xe59fe004,         /* ldr   lr, [pc, #4]   */
1950     0xe08fe00e,         /* add   lr, pc, lr     */
1951     0xe5bef008,         /* ldr   pc, [lr, #8]!  */
1952     0x00000000,         /* &GOT[0] - .          */
1953   };
1954
1955 /* Subsequent entries in a procedure linkage table look like
1956    this.  */
1957 static const bfd_vma elf32_arm_plt_entry [] =
1958   {
1959     0xe28fc600,         /* add   ip, pc, #0xNN00000 */
1960     0xe28cca00,         /* add   ip, ip, #0xNN000   */
1961     0xe5bcf000,         /* ldr   pc, [ip, #0xNNN]!  */
1962   };
1963
1964 #endif
1965
1966 /* The format of the first entry in the procedure linkage table
1967    for a VxWorks executable.  */
1968 static const bfd_vma elf32_arm_vxworks_exec_plt0_entry[] =
1969   {
1970     0xe52dc008,         /* str    ip,[sp,#-8]!                  */
1971     0xe59fc000,         /* ldr    ip,[pc]                       */
1972     0xe59cf008,         /* ldr    pc,[ip,#8]                    */
1973     0x00000000,         /* .long  _GLOBAL_OFFSET_TABLE_         */
1974   };
1975
1976 /* The format of subsequent entries in a VxWorks executable.  */
1977 static const bfd_vma elf32_arm_vxworks_exec_plt_entry[] =
1978   {
1979     0xe59fc000,         /* ldr    ip,[pc]                       */
1980     0xe59cf000,         /* ldr    pc,[ip]                       */
1981     0x00000000,         /* .long  @got                          */
1982     0xe59fc000,         /* ldr    ip,[pc]                       */
1983     0xea000000,         /* b      _PLT                          */
1984     0x00000000,         /* .long  @pltindex*sizeof(Elf32_Rela)  */
1985   };
1986
1987 /* The format of entries in a VxWorks shared library.  */
1988 static const bfd_vma elf32_arm_vxworks_shared_plt_entry[] =
1989   {
1990     0xe59fc000,         /* ldr    ip,[pc]                       */
1991     0xe79cf009,         /* ldr    pc,[ip,r9]                    */
1992     0x00000000,         /* .long  @got                          */
1993     0xe59fc000,         /* ldr    ip,[pc]                       */
1994     0xe599f008,         /* ldr    pc,[r9,#8]                    */
1995     0x00000000,         /* .long  @pltindex*sizeof(Elf32_Rela)  */
1996   };
1997
1998 /* An initial stub used if the PLT entry is referenced from Thumb code.  */
1999 #define PLT_THUMB_STUB_SIZE 4
2000 static const bfd_vma elf32_arm_plt_thumb_stub [] =
2001   {
2002     0x4778,             /* bx pc */
2003     0x46c0              /* nop   */
2004   };
2005
2006 /* The entries in a PLT when using a DLL-based target with multiple
2007    address spaces.  */
2008 static const bfd_vma elf32_arm_symbian_plt_entry [] =
2009   {
2010     0xe51ff004,         /* ldr   pc, [pc, #-4] */
2011     0x00000000,         /* dcd   R_ARM_GLOB_DAT(X) */
2012   };
2013
2014 #define ARM_MAX_FWD_BRANCH_OFFSET  ((((1 << 23) - 1) << 2) + 8)
2015 #define ARM_MAX_BWD_BRANCH_OFFSET  ((-((1 << 23) << 2)) + 8)
2016 #define THM_MAX_FWD_BRANCH_OFFSET  ((1 << 22) -2 + 4)
2017 #define THM_MAX_BWD_BRANCH_OFFSET  (-(1 << 22) + 4)
2018 #define THM2_MAX_FWD_BRANCH_OFFSET (((1 << 24) - 2) + 4)
2019 #define THM2_MAX_BWD_BRANCH_OFFSET (-(1 << 24) + 4)
2020
2021 enum stub_insn_type
2022   {
2023     THUMB16_TYPE = 1,
2024     THUMB32_TYPE,
2025     ARM_TYPE,
2026     DATA_TYPE
2027   };
2028
2029 #define THUMB16_INSN(X)         {(X), THUMB16_TYPE, R_ARM_NONE, 0}
2030 /* A bit of a hack.  A Thumb conditional branch, in which the proper condition
2031    is inserted in arm_build_one_stub().  */
2032 #define THUMB16_BCOND_INSN(X)   {(X), THUMB16_TYPE, R_ARM_NONE, 1}
2033 #define THUMB32_INSN(X)         {(X), THUMB32_TYPE, R_ARM_NONE, 0}
2034 #define THUMB32_B_INSN(X, Z)    {(X), THUMB32_TYPE, R_ARM_THM_JUMP24, (Z)}
2035 #define ARM_INSN(X)             {(X), ARM_TYPE, R_ARM_NONE, 0}
2036 #define ARM_REL_INSN(X, Z)      {(X), ARM_TYPE, R_ARM_JUMP24, (Z)}
2037 #define DATA_WORD(X,Y,Z)        {(X), DATA_TYPE, (Y), (Z)}
2038
2039 typedef struct
2040 {
2041   bfd_vma data;
2042   enum stub_insn_type type;
2043   unsigned int r_type;
2044   int reloc_addend;
2045 }  insn_sequence;
2046
2047 /* Arm/Thumb -> Arm/Thumb long branch stub. On V5T and above, use blx
2048    to reach the stub if necessary.  */
2049 static const insn_sequence elf32_arm_stub_long_branch_any_any[] =
2050   {
2051     ARM_INSN(0xe51ff004),            /* ldr   pc, [pc, #-4] */
2052     DATA_WORD(0, R_ARM_ABS32, 0),    /* dcd   R_ARM_ABS32(X) */
2053   };
2054
2055 /* V4T Arm -> Thumb long branch stub. Used on V4T where blx is not
2056    available.  */
2057 static const insn_sequence elf32_arm_stub_long_branch_v4t_arm_thumb[] =
2058   {
2059     ARM_INSN(0xe59fc000),            /* ldr   ip, [pc, #0] */
2060     ARM_INSN(0xe12fff1c),            /* bx    ip */
2061     DATA_WORD(0, R_ARM_ABS32, 0),    /* dcd   R_ARM_ABS32(X) */
2062   };
2063
2064 /* Thumb -> Thumb long branch stub. Used on M-profile architectures.  */
2065 static const insn_sequence elf32_arm_stub_long_branch_thumb_only[] =
2066   {
2067     THUMB16_INSN(0xb401),             /* push {r0} */
2068     THUMB16_INSN(0x4802),             /* ldr  r0, [pc, #8] */
2069     THUMB16_INSN(0x4684),             /* mov  ip, r0 */
2070     THUMB16_INSN(0xbc01),             /* pop  {r0} */
2071     THUMB16_INSN(0x4760),             /* bx   ip */
2072     THUMB16_INSN(0xbf00),             /* nop */
2073     DATA_WORD(0, R_ARM_ABS32, 0),     /* dcd  R_ARM_ABS32(X) */
2074   };
2075
2076 /* V4T Thumb -> Thumb long branch stub. Using the stack is not
2077    allowed.  */
2078 static const insn_sequence elf32_arm_stub_long_branch_v4t_thumb_thumb[] =
2079   {
2080     THUMB16_INSN(0x4778),             /* bx   pc */
2081     THUMB16_INSN(0x46c0),             /* nop */
2082     ARM_INSN(0xe59fc000),             /* ldr  ip, [pc, #0] */
2083     ARM_INSN(0xe12fff1c),             /* bx   ip */
2084     DATA_WORD(0, R_ARM_ABS32, 0),     /* dcd  R_ARM_ABS32(X) */
2085   };
2086
2087 /* V4T Thumb -> ARM long branch stub. Used on V4T where blx is not
2088    available.  */
2089 static const insn_sequence elf32_arm_stub_long_branch_v4t_thumb_arm[] =
2090   {
2091     THUMB16_INSN(0x4778),             /* bx   pc */
2092     THUMB16_INSN(0x46c0),             /* nop   */
2093     ARM_INSN(0xe51ff004),             /* ldr   pc, [pc, #-4] */
2094     DATA_WORD(0, R_ARM_ABS32, 0),     /* dcd   R_ARM_ABS32(X) */
2095   };
2096
2097 /* V4T Thumb -> ARM short branch stub. Shorter variant of the above
2098    one, when the destination is close enough.  */
2099 static const insn_sequence elf32_arm_stub_short_branch_v4t_thumb_arm[] =
2100   {
2101     THUMB16_INSN(0x4778),             /* bx   pc */
2102     THUMB16_INSN(0x46c0),             /* nop   */
2103     ARM_REL_INSN(0xea000000, -8),     /* b    (X-8) */
2104   };
2105
2106 /* ARM/Thumb -> ARM long branch stub, PIC.  On V5T and above, use
2107    blx to reach the stub if necessary.  */
2108 static const insn_sequence elf32_arm_stub_long_branch_any_arm_pic[] =
2109   {
2110     ARM_INSN(0xe59fc000),             /* ldr   r12, [pc] */
2111     ARM_INSN(0xe08ff00c),             /* add   pc, pc, ip */
2112     DATA_WORD(0, R_ARM_REL32, -4),    /* dcd   R_ARM_REL32(X-4) */
2113   };
2114
2115 /* ARM/Thumb -> Thumb long branch stub, PIC.  On V5T and above, use
2116    blx to reach the stub if necessary.  We can not add into pc;
2117    it is not guaranteed to mode switch (different in ARMv6 and
2118    ARMv7).  */
2119 static const insn_sequence elf32_arm_stub_long_branch_any_thumb_pic[] =
2120   {
2121     ARM_INSN(0xe59fc004),             /* ldr   r12, [pc, #4] */
2122     ARM_INSN(0xe08fc00c),             /* add   ip, pc, ip */
2123     ARM_INSN(0xe12fff1c),             /* bx    ip */
2124     DATA_WORD(0, R_ARM_REL32, 0),     /* dcd   R_ARM_REL32(X) */
2125   };
2126
2127 /* V4T ARM -> ARM long branch stub, PIC.  */
2128 static const insn_sequence elf32_arm_stub_long_branch_v4t_arm_thumb_pic[] =
2129   {
2130     ARM_INSN(0xe59fc004),             /* ldr   ip, [pc, #4] */
2131     ARM_INSN(0xe08fc00c),             /* add   ip, pc, ip */
2132     ARM_INSN(0xe12fff1c),             /* bx    ip */
2133     DATA_WORD(0, R_ARM_REL32, 0),     /* dcd   R_ARM_REL32(X) */
2134   };
2135
2136 /* V4T Thumb -> ARM long branch stub, PIC.  */
2137 static const insn_sequence elf32_arm_stub_long_branch_v4t_thumb_arm_pic[] =
2138   {
2139     THUMB16_INSN(0x4778),             /* bx   pc */
2140     THUMB16_INSN(0x46c0),             /* nop  */
2141     ARM_INSN(0xe59fc000),             /* ldr  ip, [pc, #0] */
2142     ARM_INSN(0xe08cf00f),             /* add  pc, ip, pc */
2143     DATA_WORD(0, R_ARM_REL32, -4),     /* dcd  R_ARM_REL32(X) */
2144   };
2145
2146 /* Thumb -> Thumb long branch stub, PIC. Used on M-profile
2147    architectures.  */
2148 static const insn_sequence elf32_arm_stub_long_branch_thumb_only_pic[] =
2149   {
2150     THUMB16_INSN(0xb401),             /* push {r0} */
2151     THUMB16_INSN(0x4802),             /* ldr  r0, [pc, #8] */
2152     THUMB16_INSN(0x46fc),             /* mov  ip, pc */
2153     THUMB16_INSN(0x4484),             /* add  ip, r0 */
2154     THUMB16_INSN(0xbc01),             /* pop  {r0} */
2155     THUMB16_INSN(0x4760),             /* bx   ip */
2156     DATA_WORD(0, R_ARM_REL32, 4),     /* dcd  R_ARM_REL32(X) */
2157   };
2158
2159 /* V4T Thumb -> Thumb long branch stub, PIC. Using the stack is not
2160    allowed.  */
2161 static const insn_sequence elf32_arm_stub_long_branch_v4t_thumb_thumb_pic[] =
2162   {
2163     THUMB16_INSN(0x4778),             /* bx   pc */
2164     THUMB16_INSN(0x46c0),             /* nop */
2165     ARM_INSN(0xe59fc004),             /* ldr  ip, [pc, #4] */
2166     ARM_INSN(0xe08fc00c),             /* add   ip, pc, ip */
2167     ARM_INSN(0xe12fff1c),             /* bx   ip */
2168     DATA_WORD(0, R_ARM_REL32, 0),     /* dcd  R_ARM_REL32(X) */
2169   };
2170
2171 /* Cortex-A8 erratum-workaround stubs.  */
2172
2173 /* Stub used for conditional branches (which may be beyond +/-1MB away, so we
2174    can't use a conditional branch to reach this stub).  */
2175
2176 static const insn_sequence elf32_arm_stub_a8_veneer_b_cond[] =
2177   {
2178     THUMB16_BCOND_INSN(0xd001),         /* b<cond>.n true.  */
2179     THUMB32_B_INSN(0xf000b800, -4),     /* b.w insn_after_original_branch.  */
2180     THUMB32_B_INSN(0xf000b800, -4)      /* true: b.w original_branch_dest.  */
2181   };
2182
2183 /* Stub used for b.w and bl.w instructions.  */
2184
2185 static const insn_sequence elf32_arm_stub_a8_veneer_b[] =
2186   {
2187     THUMB32_B_INSN(0xf000b800, -4)      /* b.w original_branch_dest.  */
2188   };
2189
2190 static const insn_sequence elf32_arm_stub_a8_veneer_bl[] =
2191   {
2192     THUMB32_B_INSN(0xf000b800, -4)      /* b.w original_branch_dest.  */
2193   };
2194
2195 /* Stub used for Thumb-2 blx.w instructions.  We modified the original blx.w
2196    instruction (which switches to ARM mode) to point to this stub.  Jump to the
2197    real destination using an ARM-mode branch.  */
2198
2199 static const insn_sequence elf32_arm_stub_a8_veneer_blx[] =
2200   {
2201     ARM_REL_INSN(0xea000000, -8)        /* b original_branch_dest.  */
2202   };
2203
2204 /* Section name for stubs is the associated section name plus this
2205    string.  */
2206 #define STUB_SUFFIX ".stub"
2207
2208 /* One entry per long/short branch stub defined above.  */
2209 #define DEF_STUBS \
2210   DEF_STUB(long_branch_any_any) \
2211   DEF_STUB(long_branch_v4t_arm_thumb) \
2212   DEF_STUB(long_branch_thumb_only) \
2213   DEF_STUB(long_branch_v4t_thumb_thumb) \
2214   DEF_STUB(long_branch_v4t_thumb_arm) \
2215   DEF_STUB(short_branch_v4t_thumb_arm) \
2216   DEF_STUB(long_branch_any_arm_pic) \
2217   DEF_STUB(long_branch_any_thumb_pic) \
2218   DEF_STUB(long_branch_v4t_thumb_thumb_pic) \
2219   DEF_STUB(long_branch_v4t_arm_thumb_pic) \
2220   DEF_STUB(long_branch_v4t_thumb_arm_pic) \
2221   DEF_STUB(long_branch_thumb_only_pic) \
2222   DEF_STUB(a8_veneer_b_cond) \
2223   DEF_STUB(a8_veneer_b) \
2224   DEF_STUB(a8_veneer_bl) \
2225   DEF_STUB(a8_veneer_blx)
2226
2227 #define DEF_STUB(x) arm_stub_##x,
2228 enum elf32_arm_stub_type {
2229   arm_stub_none,
2230   DEF_STUBS
2231 };
2232 #undef DEF_STUB
2233
2234 typedef struct
2235 {
2236   const insn_sequence* template;
2237   int template_size;
2238 } stub_def;
2239
2240 #define DEF_STUB(x) {elf32_arm_stub_##x, ARRAY_SIZE(elf32_arm_stub_##x)},
2241 static const stub_def stub_definitions[] = {
2242   {NULL, 0},
2243   DEF_STUBS
2244 };
2245
2246 struct elf32_arm_stub_hash_entry
2247 {
2248   /* Base hash table entry structure.  */
2249   struct bfd_hash_entry root;
2250
2251   /* The stub section.  */
2252   asection *stub_sec;
2253
2254   /* Offset within stub_sec of the beginning of this stub.  */
2255   bfd_vma stub_offset;
2256
2257   /* Given the symbol's value and its section we can determine its final
2258      value when building the stubs (so the stub knows where to jump).  */
2259   bfd_vma target_value;
2260   asection *target_section;
2261
2262   /* Offset to apply to relocation referencing target_value.  */
2263   bfd_vma target_addend;
2264
2265   /* The instruction which caused this stub to be generated (only valid for
2266      Cortex-A8 erratum workaround stubs at present).  */
2267   unsigned long orig_insn;
2268
2269   /* The stub type.  */
2270   enum elf32_arm_stub_type stub_type;
2271   /* Its encoding size in bytes.  */
2272   int stub_size;
2273   /* Its template.  */
2274   const insn_sequence *stub_template;
2275   /* The size of the template (number of entries).  */
2276   int stub_template_size;
2277
2278   /* The symbol table entry, if any, that this was derived from.  */
2279   struct elf32_arm_link_hash_entry *h;
2280
2281   /* Destination symbol type (STT_ARM_TFUNC, ...) */
2282   unsigned char st_type;
2283
2284   /* Where this stub is being called from, or, in the case of combined
2285      stub sections, the first input section in the group.  */
2286   asection *id_sec;
2287
2288   /* The name for the local symbol at the start of this stub.  The
2289      stub name in the hash table has to be unique; this does not, so
2290      it can be friendlier.  */
2291   char *output_name;
2292 };
2293
2294 /* Used to build a map of a section.  This is required for mixed-endian
2295    code/data.  */
2296
2297 typedef struct elf32_elf_section_map
2298 {
2299   bfd_vma vma;
2300   char type;
2301 }
2302 elf32_arm_section_map;
2303
2304 /* Information about a VFP11 erratum veneer, or a branch to such a veneer.  */
2305
2306 typedef enum
2307 {
2308   VFP11_ERRATUM_BRANCH_TO_ARM_VENEER,
2309   VFP11_ERRATUM_BRANCH_TO_THUMB_VENEER,
2310   VFP11_ERRATUM_ARM_VENEER,
2311   VFP11_ERRATUM_THUMB_VENEER
2312 }
2313 elf32_vfp11_erratum_type;
2314
2315 typedef struct elf32_vfp11_erratum_list
2316 {
2317   struct elf32_vfp11_erratum_list *next;
2318   bfd_vma vma;
2319   union
2320   {
2321     struct
2322     {
2323       struct elf32_vfp11_erratum_list *veneer;
2324       unsigned int vfp_insn;
2325     } b;
2326     struct
2327     {
2328       struct elf32_vfp11_erratum_list *branch;
2329       unsigned int id;
2330     } v;
2331   } u;
2332   elf32_vfp11_erratum_type type;
2333 }
2334 elf32_vfp11_erratum_list;
2335
2336 typedef enum
2337 {
2338   DELETE_EXIDX_ENTRY,
2339   INSERT_EXIDX_CANTUNWIND_AT_END
2340 }
2341 arm_unwind_edit_type;
2342
2343 /* A (sorted) list of edits to apply to an unwind table.  */
2344 typedef struct arm_unwind_table_edit
2345 {
2346   arm_unwind_edit_type type;
2347   /* Note: we sometimes want to insert an unwind entry corresponding to a
2348      section different from the one we're currently writing out, so record the
2349      (text) section this edit relates to here.  */
2350   asection *linked_section;
2351   unsigned int index;
2352   struct arm_unwind_table_edit *next;
2353 }
2354 arm_unwind_table_edit;
2355
2356 typedef struct _arm_elf_section_data
2357 {
2358   /* Information about mapping symbols.  */
2359   struct bfd_elf_section_data elf;
2360   unsigned int mapcount;
2361   unsigned int mapsize;
2362   elf32_arm_section_map *map;
2363   /* Information about CPU errata.  */
2364   unsigned int erratumcount;
2365   elf32_vfp11_erratum_list *erratumlist;
2366   /* Information about unwind tables.  */
2367   union
2368   {
2369     /* Unwind info attached to a text section.  */
2370     struct
2371     {
2372       asection *arm_exidx_sec;
2373     } text;
2374
2375     /* Unwind info attached to an .ARM.exidx section.  */
2376     struct
2377     {
2378       arm_unwind_table_edit *unwind_edit_list;
2379       arm_unwind_table_edit *unwind_edit_tail;
2380     } exidx;
2381   } u;
2382 }
2383 _arm_elf_section_data;
2384
2385 #define elf32_arm_section_data(sec) \
2386   ((_arm_elf_section_data *) elf_section_data (sec))
2387
2388 /* A fix which might be required for Cortex-A8 Thumb-2 branch/TLB erratum.
2389    These fixes are subject to a relaxation procedure (in elf32_arm_size_stubs),
2390    so may be created multiple times: we use an array of these entries whilst
2391    relaxing which we can refresh easily, then create stubs for each potentially
2392    erratum-triggering instruction once we've settled on a solution.  */
2393
2394 struct a8_erratum_fix {
2395   bfd *input_bfd;
2396   asection *section;
2397   bfd_vma offset;
2398   bfd_vma addend;
2399   unsigned long orig_insn;
2400   char *stub_name;
2401   enum elf32_arm_stub_type stub_type;
2402 };
2403
2404 /* A table of relocs applied to branches which might trigger Cortex-A8
2405    erratum.  */
2406
2407 struct a8_erratum_reloc {
2408   bfd_vma from;
2409   bfd_vma destination;
2410   unsigned int r_type;
2411   unsigned char st_type;
2412   const char *sym_name;
2413   bfd_boolean non_a8_stub;
2414 };
2415
2416 /* The size of the thread control block.  */
2417 #define TCB_SIZE        8
2418
2419 struct elf_arm_obj_tdata
2420 {
2421   struct elf_obj_tdata root;
2422
2423   /* tls_type for each local got entry.  */
2424   char *local_got_tls_type;
2425
2426   /* Zero to warn when linking objects with incompatible enum sizes.  */
2427   int no_enum_size_warning;
2428
2429   /* Zero to warn when linking objects with incompatible wchar_t sizes.  */
2430   int no_wchar_size_warning;
2431 };
2432
2433 #define elf_arm_tdata(bfd) \
2434   ((struct elf_arm_obj_tdata *) (bfd)->tdata.any)
2435
2436 #define elf32_arm_local_got_tls_type(bfd) \
2437   (elf_arm_tdata (bfd)->local_got_tls_type)
2438
2439 #define is_arm_elf(bfd) \
2440   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2441    && elf_tdata (bfd) != NULL \
2442    && elf_object_id (bfd) == ARM_ELF_TDATA)
2443
2444 static bfd_boolean
2445 elf32_arm_mkobject (bfd *abfd)
2446 {
2447   return bfd_elf_allocate_object (abfd, sizeof (struct elf_arm_obj_tdata),
2448                                   ARM_ELF_TDATA);
2449 }
2450
2451 /* The ARM linker needs to keep track of the number of relocs that it
2452    decides to copy in check_relocs for each symbol.  This is so that
2453    it can discard PC relative relocs if it doesn't need them when
2454    linking with -Bsymbolic.  We store the information in a field
2455    extending the regular ELF linker hash table.  */
2456
2457 /* This structure keeps track of the number of relocs we have copied
2458    for a given symbol.  */
2459 struct elf32_arm_relocs_copied
2460   {
2461     /* Next section.  */
2462     struct elf32_arm_relocs_copied * next;
2463     /* A section in dynobj.  */
2464     asection * section;
2465     /* Number of relocs copied in this section.  */
2466     bfd_size_type count;
2467     /* Number of PC-relative relocs copied in this section.  */
2468     bfd_size_type pc_count;
2469   };
2470
2471 #define elf32_arm_hash_entry(ent) ((struct elf32_arm_link_hash_entry *)(ent))
2472
2473 /* Arm ELF linker hash entry.  */
2474 struct elf32_arm_link_hash_entry
2475   {
2476     struct elf_link_hash_entry root;
2477
2478     /* Number of PC relative relocs copied for this symbol.  */
2479     struct elf32_arm_relocs_copied * relocs_copied;
2480
2481     /* We reference count Thumb references to a PLT entry separately,
2482        so that we can emit the Thumb trampoline only if needed.  */
2483     bfd_signed_vma plt_thumb_refcount;
2484
2485     /* Some references from Thumb code may be eliminated by BL->BLX
2486        conversion, so record them separately.  */
2487     bfd_signed_vma plt_maybe_thumb_refcount;
2488
2489     /* Since PLT entries have variable size if the Thumb prologue is
2490        used, we need to record the index into .got.plt instead of
2491        recomputing it from the PLT offset.  */
2492     bfd_signed_vma plt_got_offset;
2493
2494 #define GOT_UNKNOWN     0
2495 #define GOT_NORMAL      1
2496 #define GOT_TLS_GD      2
2497 #define GOT_TLS_IE      4
2498     unsigned char tls_type;
2499
2500     /* The symbol marking the real symbol location for exported thumb
2501        symbols with Arm stubs.  */
2502     struct elf_link_hash_entry *export_glue;
2503
2504    /* A pointer to the most recently used stub hash entry against this
2505      symbol.  */
2506     struct elf32_arm_stub_hash_entry *stub_cache;
2507   };
2508
2509 /* Traverse an arm ELF linker hash table.  */
2510 #define elf32_arm_link_hash_traverse(table, func, info)                 \
2511   (elf_link_hash_traverse                                               \
2512    (&(table)->root,                                                     \
2513     (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func),    \
2514     (info)))
2515
2516 /* Get the ARM elf linker hash table from a link_info structure.  */
2517 #define elf32_arm_hash_table(info) \
2518   ((struct elf32_arm_link_hash_table *) ((info)->hash))
2519
2520 #define arm_stub_hash_lookup(table, string, create, copy) \
2521   ((struct elf32_arm_stub_hash_entry *) \
2522    bfd_hash_lookup ((table), (string), (create), (copy)))
2523
2524 /* ARM ELF linker hash table.  */
2525 struct elf32_arm_link_hash_table
2526 {
2527   /* The main hash table.  */
2528   struct elf_link_hash_table root;
2529
2530   /* The size in bytes of the section containing the Thumb-to-ARM glue.  */
2531   bfd_size_type thumb_glue_size;
2532
2533   /* The size in bytes of the section containing the ARM-to-Thumb glue.  */
2534   bfd_size_type arm_glue_size;
2535
2536   /* The size in bytes of section containing the ARMv4 BX veneers.  */
2537   bfd_size_type bx_glue_size;
2538
2539   /* Offsets of ARMv4 BX veneers.  Bit1 set if present, and Bit0 set when
2540      veneer has been populated.  */
2541   bfd_vma bx_glue_offset[15];
2542
2543   /* The size in bytes of the section containing glue for VFP11 erratum
2544      veneers.  */
2545   bfd_size_type vfp11_erratum_glue_size;
2546
2547   /* A table of fix locations for Cortex-A8 Thumb-2 branch/TLB erratum.  This
2548      holds Cortex-A8 erratum fix locations between elf32_arm_size_stubs() and
2549      elf32_arm_write_section().  */
2550   struct a8_erratum_fix *a8_erratum_fixes;
2551   unsigned int num_a8_erratum_fixes;
2552
2553   /* An arbitrary input BFD chosen to hold the glue sections.  */
2554   bfd * bfd_of_glue_owner;
2555
2556   /* Nonzero to output a BE8 image.  */
2557   int byteswap_code;
2558
2559   /* Zero if R_ARM_TARGET1 means R_ARM_ABS32.
2560      Nonzero if R_ARM_TARGET1 means R_ARM_REL32.  */
2561   int target1_is_rel;
2562
2563   /* The relocation to use for R_ARM_TARGET2 relocations.  */
2564   int target2_reloc;
2565
2566   /* 0 = Ignore R_ARM_V4BX.
2567      1 = Convert BX to MOV PC.
2568      2 = Generate v4 interworing stubs.  */
2569   int fix_v4bx;
2570
2571   /* Whether we should fix the Cortex-A8 Thumb-2 branch/TLB erratum.  */
2572   int fix_cortex_a8;
2573
2574   /* Nonzero if the ARM/Thumb BLX instructions are available for use.  */
2575   int use_blx;
2576
2577   /* What sort of code sequences we should look for which may trigger the
2578      VFP11 denorm erratum.  */
2579   bfd_arm_vfp11_fix vfp11_fix;
2580
2581   /* Global counter for the number of fixes we have emitted.  */
2582   int num_vfp11_fixes;
2583
2584   /* Nonzero to force PIC branch veneers.  */
2585   int pic_veneer;
2586
2587   /* The number of bytes in the initial entry in the PLT.  */
2588   bfd_size_type plt_header_size;
2589
2590   /* The number of bytes in the subsequent PLT etries.  */
2591   bfd_size_type plt_entry_size;
2592
2593   /* True if the target system is VxWorks.  */
2594   int vxworks_p;
2595
2596   /* True if the target system is Symbian OS.  */
2597   int symbian_p;
2598
2599   /* True if the target uses REL relocations.  */
2600   int use_rel;
2601
2602   /* Short-cuts to get to dynamic linker sections.  */
2603   asection *sgot;
2604   asection *sgotplt;
2605   asection *srelgot;
2606   asection *splt;
2607   asection *srelplt;
2608   asection *sdynbss;
2609   asection *srelbss;
2610
2611   /* The (unloaded but important) VxWorks .rela.plt.unloaded section.  */
2612   asection *srelplt2;
2613
2614   /* Data for R_ARM_TLS_LDM32 relocations.  */
2615   union
2616   {
2617     bfd_signed_vma refcount;
2618     bfd_vma offset;
2619   } tls_ldm_got;
2620
2621   /* Small local sym to section mapping cache.  */
2622   struct sym_sec_cache sym_sec;
2623
2624   /* For convenience in allocate_dynrelocs.  */
2625   bfd * obfd;
2626
2627   /* The stub hash table.  */
2628   struct bfd_hash_table stub_hash_table;
2629
2630   /* Linker stub bfd.  */
2631   bfd *stub_bfd;
2632
2633   /* Linker call-backs.  */
2634   asection * (*add_stub_section) (const char *, asection *);
2635   void (*layout_sections_again) (void);
2636
2637   /* Array to keep track of which stub sections have been created, and
2638      information on stub grouping.  */
2639   struct map_stub
2640   {
2641     /* This is the section to which stubs in the group will be
2642        attached.  */
2643     asection *link_sec;
2644     /* The stub section.  */
2645     asection *stub_sec;
2646   } *stub_group;
2647
2648   /* Assorted information used by elf32_arm_size_stubs.  */
2649   unsigned int bfd_count;
2650   int top_index;
2651   asection **input_list;
2652 };
2653
2654 /* Create an entry in an ARM ELF linker hash table.  */
2655
2656 static struct bfd_hash_entry *
2657 elf32_arm_link_hash_newfunc (struct bfd_hash_entry * entry,
2658                              struct bfd_hash_table * table,
2659                              const char * string)
2660 {
2661   struct elf32_arm_link_hash_entry * ret =
2662     (struct elf32_arm_link_hash_entry *) entry;
2663
2664   /* Allocate the structure if it has not already been allocated by a
2665      subclass.  */
2666   if (ret == NULL)
2667     ret = bfd_hash_allocate (table, sizeof (struct elf32_arm_link_hash_entry));
2668   if (ret == NULL)
2669     return (struct bfd_hash_entry *) ret;
2670
2671   /* Call the allocation method of the superclass.  */
2672   ret = ((struct elf32_arm_link_hash_entry *)
2673          _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
2674                                      table, string));
2675   if (ret != NULL)
2676     {
2677       ret->relocs_copied = NULL;
2678       ret->tls_type = GOT_UNKNOWN;
2679       ret->plt_thumb_refcount = 0;
2680       ret->plt_maybe_thumb_refcount = 0;
2681       ret->plt_got_offset = -1;
2682       ret->export_glue = NULL;
2683
2684       ret->stub_cache = NULL;
2685     }
2686
2687   return (struct bfd_hash_entry *) ret;
2688 }
2689
2690 /* Initialize an entry in the stub hash table.  */
2691
2692 static struct bfd_hash_entry *
2693 stub_hash_newfunc (struct bfd_hash_entry *entry,
2694                    struct bfd_hash_table *table,
2695                    const char *string)
2696 {
2697   /* Allocate the structure if it has not already been allocated by a
2698      subclass.  */
2699   if (entry == NULL)
2700     {
2701       entry = bfd_hash_allocate (table,
2702                                  sizeof (struct elf32_arm_stub_hash_entry));
2703       if (entry == NULL)
2704         return entry;
2705     }
2706
2707   /* Call the allocation method of the superclass.  */
2708   entry = bfd_hash_newfunc (entry, table, string);
2709   if (entry != NULL)
2710     {
2711       struct elf32_arm_stub_hash_entry *eh;
2712
2713       /* Initialize the local fields.  */
2714       eh = (struct elf32_arm_stub_hash_entry *) entry;
2715       eh->stub_sec = NULL;
2716       eh->stub_offset = 0;
2717       eh->target_value = 0;
2718       eh->target_section = NULL;
2719       eh->stub_type = arm_stub_none;
2720       eh->stub_size = 0;
2721       eh->stub_template = NULL;
2722       eh->stub_template_size = 0;
2723       eh->h = NULL;
2724       eh->id_sec = NULL;
2725     }
2726
2727   return entry;
2728 }
2729
2730 /* Create .got, .gotplt, and .rel(a).got sections in DYNOBJ, and set up
2731    shortcuts to them in our hash table.  */
2732
2733 static bfd_boolean
2734 create_got_section (bfd *dynobj, struct bfd_link_info *info)
2735 {
2736   struct elf32_arm_link_hash_table *htab;
2737
2738   htab = elf32_arm_hash_table (info);
2739   /* BPABI objects never have a GOT, or associated sections.  */
2740   if (htab->symbian_p)
2741     return TRUE;
2742
2743   if (! _bfd_elf_create_got_section (dynobj, info))
2744     return FALSE;
2745
2746   htab->sgot = bfd_get_section_by_name (dynobj, ".got");
2747   htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
2748   if (!htab->sgot || !htab->sgotplt)
2749     abort ();
2750
2751   htab->srelgot = bfd_make_section_with_flags (dynobj,
2752                                                RELOC_SECTION (htab, ".got"),
2753                                                (SEC_ALLOC | SEC_LOAD
2754                                                 | SEC_HAS_CONTENTS
2755                                                 | SEC_IN_MEMORY
2756                                                 | SEC_LINKER_CREATED
2757                                                 | SEC_READONLY));
2758   if (htab->srelgot == NULL
2759       || ! bfd_set_section_alignment (dynobj, htab->srelgot, 2))
2760     return FALSE;
2761   return TRUE;
2762 }
2763
2764 /* Create .plt, .rel(a).plt, .got, .got.plt, .rel(a).got, .dynbss, and
2765    .rel(a).bss sections in DYNOBJ, and set up shortcuts to them in our
2766    hash table.  */
2767
2768 static bfd_boolean
2769 elf32_arm_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
2770 {
2771   struct elf32_arm_link_hash_table *htab;
2772
2773   htab = elf32_arm_hash_table (info);
2774   if (!htab->sgot && !create_got_section (dynobj, info))
2775     return FALSE;
2776
2777   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
2778     return FALSE;
2779
2780   htab->splt = bfd_get_section_by_name (dynobj, ".plt");
2781   htab->srelplt = bfd_get_section_by_name (dynobj,
2782                                            RELOC_SECTION (htab, ".plt"));
2783   htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
2784   if (!info->shared)
2785     htab->srelbss = bfd_get_section_by_name (dynobj,
2786                                              RELOC_SECTION (htab, ".bss"));
2787
2788   if (htab->vxworks_p)
2789     {
2790       if (!elf_vxworks_create_dynamic_sections (dynobj, info, &htab->srelplt2))
2791         return FALSE;
2792
2793       if (info->shared)
2794         {
2795           htab->plt_header_size = 0;
2796           htab->plt_entry_size
2797             = 4 * ARRAY_SIZE (elf32_arm_vxworks_shared_plt_entry);
2798         }
2799       else
2800         {
2801           htab->plt_header_size
2802             = 4 * ARRAY_SIZE (elf32_arm_vxworks_exec_plt0_entry);
2803           htab->plt_entry_size
2804             = 4 * ARRAY_SIZE (elf32_arm_vxworks_exec_plt_entry);
2805         }
2806     }
2807
2808   if (!htab->splt
2809       || !htab->srelplt
2810       || !htab->sdynbss
2811       || (!info->shared && !htab->srelbss))
2812     abort ();
2813
2814   return TRUE;
2815 }
2816
2817 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
2818
2819 static void
2820 elf32_arm_copy_indirect_symbol (struct bfd_link_info *info,
2821                                 struct elf_link_hash_entry *dir,
2822                                 struct elf_link_hash_entry *ind)
2823 {
2824   struct elf32_arm_link_hash_entry *edir, *eind;
2825
2826   edir = (struct elf32_arm_link_hash_entry *) dir;
2827   eind = (struct elf32_arm_link_hash_entry *) ind;
2828
2829   if (eind->relocs_copied != NULL)
2830     {
2831       if (edir->relocs_copied != NULL)
2832         {
2833           struct elf32_arm_relocs_copied **pp;
2834           struct elf32_arm_relocs_copied *p;
2835
2836           /* Add reloc counts against the indirect sym to the direct sym
2837              list.  Merge any entries against the same section.  */
2838           for (pp = &eind->relocs_copied; (p = *pp) != NULL; )
2839             {
2840               struct elf32_arm_relocs_copied *q;
2841
2842               for (q = edir->relocs_copied; q != NULL; q = q->next)
2843                 if (q->section == p->section)
2844                   {
2845                     q->pc_count += p->pc_count;
2846                     q->count += p->count;
2847                     *pp = p->next;
2848                     break;
2849                   }
2850               if (q == NULL)
2851                 pp = &p->next;
2852             }
2853           *pp = edir->relocs_copied;
2854         }
2855
2856       edir->relocs_copied = eind->relocs_copied;
2857       eind->relocs_copied = NULL;
2858     }
2859
2860   if (ind->root.type == bfd_link_hash_indirect)
2861     {
2862       /* Copy over PLT info.  */
2863       edir->plt_thumb_refcount += eind->plt_thumb_refcount;
2864       eind->plt_thumb_refcount = 0;
2865       edir->plt_maybe_thumb_refcount += eind->plt_maybe_thumb_refcount;
2866       eind->plt_maybe_thumb_refcount = 0;
2867
2868       if (dir->got.refcount <= 0)
2869         {
2870           edir->tls_type = eind->tls_type;
2871           eind->tls_type = GOT_UNKNOWN;
2872         }
2873     }
2874
2875   _bfd_elf_link_hash_copy_indirect (info, dir, ind);
2876 }
2877
2878 /* Create an ARM elf linker hash table.  */
2879
2880 static struct bfd_link_hash_table *
2881 elf32_arm_link_hash_table_create (bfd *abfd)
2882 {
2883   struct elf32_arm_link_hash_table *ret;
2884   bfd_size_type amt = sizeof (struct elf32_arm_link_hash_table);
2885
2886   ret = bfd_malloc (amt);
2887   if (ret == NULL)
2888     return NULL;
2889
2890   if (!_bfd_elf_link_hash_table_init (& ret->root, abfd,
2891                                       elf32_arm_link_hash_newfunc,
2892                                       sizeof (struct elf32_arm_link_hash_entry)))
2893     {
2894       free (ret);
2895       return NULL;
2896     }
2897
2898   ret->sgot = NULL;
2899   ret->sgotplt = NULL;
2900   ret->srelgot = NULL;
2901   ret->splt = NULL;
2902   ret->srelplt = NULL;
2903   ret->sdynbss = NULL;
2904   ret->srelbss = NULL;
2905   ret->srelplt2 = NULL;
2906   ret->thumb_glue_size = 0;
2907   ret->arm_glue_size = 0;
2908   ret->bx_glue_size = 0;
2909   memset (ret->bx_glue_offset, 0, sizeof (ret->bx_glue_offset));
2910   ret->vfp11_fix = BFD_ARM_VFP11_FIX_NONE;
2911   ret->vfp11_erratum_glue_size = 0;
2912   ret->num_vfp11_fixes = 0;
2913   ret->fix_cortex_a8 = 0;
2914   ret->bfd_of_glue_owner = NULL;
2915   ret->byteswap_code = 0;
2916   ret->target1_is_rel = 0;
2917   ret->target2_reloc = R_ARM_NONE;
2918 #ifdef FOUR_WORD_PLT
2919   ret->plt_header_size = 16;
2920   ret->plt_entry_size = 16;
2921 #else
2922   ret->plt_header_size = 20;
2923   ret->plt_entry_size = 12;
2924 #endif
2925   ret->fix_v4bx = 0;
2926   ret->use_blx = 0;
2927   ret->vxworks_p = 0;
2928   ret->symbian_p = 0;
2929   ret->use_rel = 1;
2930   ret->sym_sec.abfd = NULL;
2931   ret->obfd = abfd;
2932   ret->tls_ldm_got.refcount = 0;
2933   ret->stub_bfd = NULL;
2934   ret->add_stub_section = NULL;
2935   ret->layout_sections_again = NULL;
2936   ret->stub_group = NULL;
2937   ret->bfd_count = 0;
2938   ret->top_index = 0;
2939   ret->input_list = NULL;
2940
2941   if (!bfd_hash_table_init (&ret->stub_hash_table, stub_hash_newfunc,
2942                             sizeof (struct elf32_arm_stub_hash_entry)))
2943     {
2944       free (ret);
2945       return NULL;
2946     }
2947
2948   return &ret->root.root;
2949 }
2950
2951 /* Free the derived linker hash table.  */
2952
2953 static void
2954 elf32_arm_hash_table_free (struct bfd_link_hash_table *hash)
2955 {
2956   struct elf32_arm_link_hash_table *ret
2957     = (struct elf32_arm_link_hash_table *) hash;
2958
2959   bfd_hash_table_free (&ret->stub_hash_table);
2960   _bfd_generic_link_hash_table_free (hash);
2961 }
2962
2963 /* Determine if we're dealing with a Thumb only architecture.  */
2964
2965 static bfd_boolean
2966 using_thumb_only (struct elf32_arm_link_hash_table *globals)
2967 {
2968   int arch = bfd_elf_get_obj_attr_int (globals->obfd, OBJ_ATTR_PROC,
2969                                        Tag_CPU_arch);
2970   int profile;
2971
2972   if (arch != TAG_CPU_ARCH_V7)
2973     return FALSE;
2974
2975   profile = bfd_elf_get_obj_attr_int (globals->obfd, OBJ_ATTR_PROC,
2976                                       Tag_CPU_arch_profile);
2977
2978   return profile == 'M';
2979 }
2980
2981 /* Determine if we're dealing with a Thumb-2 object.  */
2982
2983 static bfd_boolean
2984 using_thumb2 (struct elf32_arm_link_hash_table *globals)
2985 {
2986   int arch = bfd_elf_get_obj_attr_int (globals->obfd, OBJ_ATTR_PROC,
2987                                        Tag_CPU_arch);
2988   return arch == TAG_CPU_ARCH_V6T2 || arch >= TAG_CPU_ARCH_V7;
2989 }
2990
2991 static bfd_boolean
2992 arm_stub_is_thumb (enum elf32_arm_stub_type stub_type)
2993 {
2994   switch (stub_type)
2995     {
2996     case arm_stub_long_branch_thumb_only:
2997     case arm_stub_long_branch_v4t_thumb_arm:
2998     case arm_stub_short_branch_v4t_thumb_arm:
2999     case arm_stub_long_branch_v4t_thumb_arm_pic:
3000     case arm_stub_long_branch_thumb_only_pic:
3001       return TRUE;
3002     case arm_stub_none:
3003       BFD_FAIL ();
3004       return FALSE;
3005       break;
3006     default:
3007       return FALSE;
3008     }
3009 }
3010
3011 /* Determine the type of stub needed, if any, for a call.  */
3012
3013 static enum elf32_arm_stub_type
3014 arm_type_of_stub (struct bfd_link_info *info,
3015                   asection *input_sec,
3016                   const Elf_Internal_Rela *rel,
3017                   unsigned char st_type,
3018                   struct elf32_arm_link_hash_entry *hash,
3019                   bfd_vma destination,
3020                   asection *sym_sec,
3021                   bfd *input_bfd,
3022                   const char *name)
3023 {
3024   bfd_vma location;
3025   bfd_signed_vma branch_offset;
3026   unsigned int r_type;
3027   struct elf32_arm_link_hash_table * globals;
3028   int thumb2;
3029   int thumb_only;
3030   enum elf32_arm_stub_type stub_type = arm_stub_none;
3031   int use_plt = 0;
3032
3033   /* We don't know the actual type of destination in case it is of
3034      type STT_SECTION: give up.  */
3035   if (st_type == STT_SECTION)
3036     return stub_type;
3037
3038   globals = elf32_arm_hash_table (info);
3039
3040   thumb_only = using_thumb_only (globals);
3041
3042   thumb2 = using_thumb2 (globals);
3043
3044   /* Determine where the call point is.  */
3045   location = (input_sec->output_offset
3046               + input_sec->output_section->vma
3047               + rel->r_offset);
3048
3049   branch_offset = (bfd_signed_vma)(destination - location);
3050
3051   r_type = ELF32_R_TYPE (rel->r_info);
3052
3053   /* Keep a simpler condition, for the sake of clarity.  */
3054   if (globals->splt != NULL && hash != NULL && hash->root.plt.offset != (bfd_vma) -1)
3055     {
3056       use_plt = 1;
3057       /* Note when dealing with PLT entries: the main PLT stub is in
3058          ARM mode, so if the branch is in Thumb mode, another
3059          Thumb->ARM stub will be inserted later just before the ARM
3060          PLT stub. We don't take this extra distance into account
3061          here, because if a long branch stub is needed, we'll add a
3062          Thumb->Arm one and branch directly to the ARM PLT entry
3063          because it avoids spreading offset corrections in several
3064          places.  */
3065     }
3066
3067   if (r_type == R_ARM_THM_CALL || r_type == R_ARM_THM_JUMP24)
3068     {
3069       /* Handle cases where:
3070          - this call goes too far (different Thumb/Thumb2 max
3071            distance)
3072          - it's a Thumb->Arm call and blx is not available, or it's a
3073            Thumb->Arm branch (not bl). A stub is needed in this case,
3074            but only if this call is not through a PLT entry. Indeed,
3075            PLT stubs handle mode switching already.
3076       */
3077       if ((!thumb2
3078             && (branch_offset > THM_MAX_FWD_BRANCH_OFFSET
3079                 || (branch_offset < THM_MAX_BWD_BRANCH_OFFSET)))
3080           || (thumb2
3081               && (branch_offset > THM2_MAX_FWD_BRANCH_OFFSET
3082                   || (branch_offset < THM2_MAX_BWD_BRANCH_OFFSET)))
3083           || ((st_type != STT_ARM_TFUNC)
3084               && (((r_type == R_ARM_THM_CALL) && !globals->use_blx)
3085                   || (r_type == R_ARM_THM_JUMP24))
3086               && !use_plt))
3087         {
3088           if (st_type == STT_ARM_TFUNC)
3089             {
3090               /* Thumb to thumb.  */
3091               if (!thumb_only)
3092                 {
3093                   stub_type = (info->shared | globals->pic_veneer)
3094                     /* PIC stubs.  */
3095                     ? ((globals->use_blx
3096                         && (r_type ==R_ARM_THM_CALL))
3097                        /* V5T and above. Stub starts with ARM code, so
3098                           we must be able to switch mode before
3099                           reaching it, which is only possible for 'bl'
3100                           (ie R_ARM_THM_CALL relocation).  */
3101                        ? arm_stub_long_branch_any_thumb_pic
3102                        /* On V4T, use Thumb code only.  */
3103                        : arm_stub_long_branch_v4t_thumb_thumb_pic)
3104
3105                     /* non-PIC stubs.  */
3106                     : ((globals->use_blx
3107                         && (r_type ==R_ARM_THM_CALL))
3108                        /* V5T and above.  */
3109                        ? arm_stub_long_branch_any_any
3110                        /* V4T.  */
3111                        : arm_stub_long_branch_v4t_thumb_thumb);
3112                 }
3113               else
3114                 {
3115                   stub_type = (info->shared | globals->pic_veneer)
3116                     /* PIC stub.  */
3117                     ? arm_stub_long_branch_thumb_only_pic
3118                     /* non-PIC stub.  */
3119                     : arm_stub_long_branch_thumb_only;
3120                 }
3121             }
3122           else
3123             {
3124               /* Thumb to arm.  */
3125               if (sym_sec != NULL
3126                   && sym_sec->owner != NULL
3127                   && !INTERWORK_FLAG (sym_sec->owner))
3128                 {
3129                   (*_bfd_error_handler)
3130                     (_("%B(%s): warning: interworking not enabled.\n"
3131                        "  first occurrence: %B: Thumb call to ARM"),
3132                      sym_sec->owner, input_bfd, name);
3133                 }
3134
3135               stub_type = (info->shared | globals->pic_veneer)
3136                 /* PIC stubs.  */
3137                 ? ((globals->use_blx
3138                     && (r_type ==R_ARM_THM_CALL))
3139                    /* V5T and above.  */
3140                    ? arm_stub_long_branch_any_arm_pic
3141                    /* V4T PIC stub.  */
3142                    : arm_stub_long_branch_v4t_thumb_arm_pic)
3143
3144                 /* non-PIC stubs.  */
3145                 : ((globals->use_blx
3146                     && (r_type ==R_ARM_THM_CALL))
3147                    /* V5T and above.  */
3148                    ? arm_stub_long_branch_any_any
3149                    /* V4T.  */
3150                    : arm_stub_long_branch_v4t_thumb_arm);
3151
3152               /* Handle v4t short branches.  */
3153               if ((stub_type == arm_stub_long_branch_v4t_thumb_arm)
3154                   && (branch_offset <= THM_MAX_FWD_BRANCH_OFFSET)
3155                   && (branch_offset >= THM_MAX_BWD_BRANCH_OFFSET))
3156                 stub_type = arm_stub_short_branch_v4t_thumb_arm;
3157             }
3158         }
3159     }
3160   else if (r_type == R_ARM_CALL || r_type == R_ARM_JUMP24 || r_type == R_ARM_PLT32)
3161     {
3162       if (st_type == STT_ARM_TFUNC)
3163         {
3164           /* Arm to thumb.  */
3165
3166           if (sym_sec != NULL
3167               && sym_sec->owner != NULL
3168               && !INTERWORK_FLAG (sym_sec->owner))
3169             {
3170               (*_bfd_error_handler)
3171                 (_("%B(%s): warning: interworking not enabled.\n"
3172                    "  first occurrence: %B: ARM call to Thumb"),
3173                  sym_sec->owner, input_bfd, name);
3174             }
3175
3176           /* We have an extra 2-bytes reach because of
3177              the mode change (bit 24 (H) of BLX encoding).  */
3178           if (branch_offset > (ARM_MAX_FWD_BRANCH_OFFSET + 2)
3179               || (branch_offset < ARM_MAX_BWD_BRANCH_OFFSET)
3180               || ((r_type == R_ARM_CALL) && !globals->use_blx)
3181               || (r_type == R_ARM_JUMP24)
3182               || (r_type == R_ARM_PLT32))
3183             {
3184               stub_type = (info->shared | globals->pic_veneer)
3185                 /* PIC stubs.  */
3186                 ? ((globals->use_blx)
3187                    /* V5T and above.  */
3188                    ? arm_stub_long_branch_any_thumb_pic
3189                    /* V4T stub.  */
3190                    : arm_stub_long_branch_v4t_arm_thumb_pic)
3191
3192                 /* non-PIC stubs.  */
3193                 : ((globals->use_blx)
3194                    /* V5T and above.  */
3195                    ? arm_stub_long_branch_any_any
3196                    /* V4T.  */
3197                    : arm_stub_long_branch_v4t_arm_thumb);
3198             }
3199         }
3200       else
3201         {
3202           /* Arm to arm.  */
3203           if (branch_offset > ARM_MAX_FWD_BRANCH_OFFSET
3204               || (branch_offset < ARM_MAX_BWD_BRANCH_OFFSET))
3205             {
3206               stub_type = (info->shared | globals->pic_veneer)
3207                 /* PIC stubs.  */
3208                 ? arm_stub_long_branch_any_arm_pic
3209                 /* non-PIC stubs.  */
3210                 : arm_stub_long_branch_any_any;
3211             }
3212         }
3213     }
3214
3215   return stub_type;
3216 }
3217
3218 /* Build a name for an entry in the stub hash table.  */
3219
3220 static char *
3221 elf32_arm_stub_name (const asection *input_section,
3222                      const asection *sym_sec,
3223                      const struct elf32_arm_link_hash_entry *hash,
3224                      const Elf_Internal_Rela *rel)
3225 {
3226   char *stub_name;
3227   bfd_size_type len;
3228
3229   if (hash)
3230     {
3231       len = 8 + 1 + strlen (hash->root.root.root.string) + 1 + 8 + 1;
3232       stub_name = bfd_malloc (len);
3233       if (stub_name != NULL)
3234         sprintf (stub_name, "%08x_%s+%x",
3235                  input_section->id & 0xffffffff,
3236                  hash->root.root.root.string,
3237                  (int) rel->r_addend & 0xffffffff);
3238     }
3239   else
3240     {
3241       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
3242       stub_name = bfd_malloc (len);
3243       if (stub_name != NULL)
3244         sprintf (stub_name, "%08x_%x:%x+%x",
3245                  input_section->id & 0xffffffff,
3246                  sym_sec->id & 0xffffffff,
3247                  (int) ELF32_R_SYM (rel->r_info) & 0xffffffff,
3248                  (int) rel->r_addend & 0xffffffff);
3249     }
3250
3251   return stub_name;
3252 }
3253
3254 /* Look up an entry in the stub hash.  Stub entries are cached because
3255    creating the stub name takes a bit of time.  */
3256
3257 static struct elf32_arm_stub_hash_entry *
3258 elf32_arm_get_stub_entry (const asection *input_section,
3259                           const asection *sym_sec,
3260                           struct elf_link_hash_entry *hash,
3261                           const Elf_Internal_Rela *rel,
3262                           struct elf32_arm_link_hash_table *htab)
3263 {
3264   struct elf32_arm_stub_hash_entry *stub_entry;
3265   struct elf32_arm_link_hash_entry *h = (struct elf32_arm_link_hash_entry *) hash;
3266   const asection *id_sec;
3267
3268   if ((input_section->flags & SEC_CODE) == 0)
3269     return NULL;
3270
3271   /* If this input section is part of a group of sections sharing one
3272      stub section, then use the id of the first section in the group.
3273      Stub names need to include a section id, as there may well be
3274      more than one stub used to reach say, printf, and we need to
3275      distinguish between them.  */
3276   id_sec = htab->stub_group[input_section->id].link_sec;
3277
3278   if (h != NULL && h->stub_cache != NULL
3279       && h->stub_cache->h == h
3280       && h->stub_cache->id_sec == id_sec)
3281     {
3282       stub_entry = h->stub_cache;
3283     }
3284   else
3285     {
3286       char *stub_name;
3287
3288       stub_name = elf32_arm_stub_name (id_sec, sym_sec, h, rel);
3289       if (stub_name == NULL)
3290         return NULL;
3291
3292       stub_entry = arm_stub_hash_lookup (&htab->stub_hash_table,
3293                                         stub_name, FALSE, FALSE);
3294       if (h != NULL)
3295         h->stub_cache = stub_entry;
3296
3297       free (stub_name);
3298     }
3299
3300   return stub_entry;
3301 }
3302
3303 /* Find or create a stub section.  Returns a pointer to the stub section, and
3304    the section to which the stub section will be attached (in *LINK_SEC_P).
3305    LINK_SEC_P may be NULL.  */
3306
3307 static asection *
3308 elf32_arm_create_or_find_stub_sec (asection **link_sec_p, asection *section,
3309                                    struct elf32_arm_link_hash_table *htab)
3310 {
3311   asection *link_sec;
3312   asection *stub_sec;
3313
3314   link_sec = htab->stub_group[section->id].link_sec;
3315   stub_sec = htab->stub_group[section->id].stub_sec;
3316   if (stub_sec == NULL)
3317     {
3318       stub_sec = htab->stub_group[link_sec->id].stub_sec;
3319       if (stub_sec == NULL)
3320         {
3321           size_t namelen;
3322           bfd_size_type len;
3323           char *s_name;
3324
3325           namelen = strlen (link_sec->name);
3326           len = namelen + sizeof (STUB_SUFFIX);
3327           s_name = bfd_alloc (htab->stub_bfd, len);
3328           if (s_name == NULL)
3329             return NULL;
3330
3331           memcpy (s_name, link_sec->name, namelen);
3332           memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
3333           stub_sec = (*htab->add_stub_section) (s_name, link_sec);
3334           if (stub_sec == NULL)
3335             return NULL;
3336           htab->stub_group[link_sec->id].stub_sec = stub_sec;
3337         }
3338       htab->stub_group[section->id].stub_sec = stub_sec;
3339     }
3340
3341   if (link_sec_p)
3342     *link_sec_p = link_sec;
3343
3344   return stub_sec;
3345 }
3346
3347 /* Add a new stub entry to the stub hash.  Not all fields of the new
3348    stub entry are initialised.  */
3349
3350 static struct elf32_arm_stub_hash_entry *
3351 elf32_arm_add_stub (const char *stub_name,
3352                     asection *section,
3353                     struct elf32_arm_link_hash_table *htab)
3354 {
3355   asection *link_sec;
3356   asection *stub_sec;
3357   struct elf32_arm_stub_hash_entry *stub_entry;
3358
3359   stub_sec = elf32_arm_create_or_find_stub_sec (&link_sec, section, htab);
3360   if (stub_sec == NULL)
3361     return NULL;
3362
3363   /* Enter this entry into the linker stub hash table.  */
3364   stub_entry = arm_stub_hash_lookup (&htab->stub_hash_table, stub_name,
3365                                      TRUE, FALSE);
3366   if (stub_entry == NULL)
3367     {
3368       (*_bfd_error_handler) (_("%s: cannot create stub entry %s"),
3369                              section->owner,
3370                              stub_name);
3371       return NULL;
3372     }
3373
3374   stub_entry->stub_sec = stub_sec;
3375   stub_entry->stub_offset = 0;
3376   stub_entry->id_sec = link_sec;
3377
3378   return stub_entry;
3379 }
3380
3381 /* Store an Arm insn into an output section not processed by
3382    elf32_arm_write_section.  */
3383
3384 static void
3385 put_arm_insn (struct elf32_arm_link_hash_table * htab,
3386               bfd * output_bfd, bfd_vma val, void * ptr)
3387 {
3388   if (htab->byteswap_code != bfd_little_endian (output_bfd))
3389     bfd_putl32 (val, ptr);
3390   else
3391     bfd_putb32 (val, ptr);
3392 }
3393
3394 /* Store a 16-bit Thumb insn into an output section not processed by
3395    elf32_arm_write_section.  */
3396
3397 static void
3398 put_thumb_insn (struct elf32_arm_link_hash_table * htab,
3399                 bfd * output_bfd, bfd_vma val, void * ptr)
3400 {
3401   if (htab->byteswap_code != bfd_little_endian (output_bfd))
3402     bfd_putl16 (val, ptr);
3403   else
3404     bfd_putb16 (val, ptr);
3405 }
3406
3407 static bfd_reloc_status_type elf32_arm_final_link_relocate
3408   (reloc_howto_type *, bfd *, bfd *, asection *, bfd_byte *,
3409    Elf_Internal_Rela *, bfd_vma, struct bfd_link_info *, asection *,
3410    const char *, int, struct elf_link_hash_entry *, bfd_boolean *, char **);
3411
3412 static bfd_boolean
3413 arm_build_one_stub (struct bfd_hash_entry *gen_entry,
3414                     void * in_arg)
3415 {
3416 #define MAXRELOCS 2
3417   struct elf32_arm_stub_hash_entry *stub_entry;
3418   struct bfd_link_info *info;
3419   struct elf32_arm_link_hash_table *htab;
3420   asection *stub_sec;
3421   bfd *stub_bfd;
3422   bfd_vma stub_addr;
3423   bfd_byte *loc;
3424   bfd_vma sym_value;
3425   int template_size;
3426   int size;
3427   const insn_sequence *template;
3428   int i;
3429   struct elf32_arm_link_hash_table * globals;
3430   int stub_reloc_idx[MAXRELOCS] = {-1, -1};
3431   int stub_reloc_offset[MAXRELOCS] = {0, 0};
3432   int nrelocs = 0;
3433
3434   /* Massage our args to the form they really have.  */
3435   stub_entry = (struct elf32_arm_stub_hash_entry *) gen_entry;
3436   info = (struct bfd_link_info *) in_arg;
3437
3438   globals = elf32_arm_hash_table (info);
3439
3440   htab = elf32_arm_hash_table (info);
3441   stub_sec = stub_entry->stub_sec;
3442
3443   /* Make a note of the offset within the stubs for this entry.  */
3444   stub_entry->stub_offset = stub_sec->size;
3445   loc = stub_sec->contents + stub_entry->stub_offset;
3446
3447   stub_bfd = stub_sec->owner;
3448
3449   /* This is the address of the start of the stub.  */
3450   stub_addr = stub_sec->output_section->vma + stub_sec->output_offset
3451     + stub_entry->stub_offset;
3452
3453   /* This is the address of the stub destination.  */
3454   sym_value = (stub_entry->target_value
3455                + stub_entry->target_section->output_offset
3456                + stub_entry->target_section->output_section->vma);
3457
3458   template = stub_entry->stub_template;
3459   template_size = stub_entry->stub_template_size;
3460
3461   size = 0;
3462   for (i = 0; i < template_size; i++)
3463     {
3464       switch (template[i].type)
3465         {
3466         case THUMB16_TYPE:
3467           {
3468             bfd_vma data = template[i].data;
3469             if (template[i].reloc_addend != 0)
3470               {
3471                 /* We've borrowed the reloc_addend field to mean we should
3472                    insert a condition code into this (Thumb-1 branch)
3473                    instruction.  See THUMB16_BCOND_INSN.  */
3474                 BFD_ASSERT ((data & 0xff00) == 0xd000);
3475                 data |= ((stub_entry->orig_insn >> 22) & 0xf) << 8;
3476               }
3477             put_thumb_insn (globals, stub_bfd, data, loc + size);
3478             size += 2;
3479           }
3480           break;
3481
3482         case THUMB32_TYPE:
3483           put_thumb_insn (globals, stub_bfd, (template[i].data >> 16) & 0xffff,
3484                           loc + size);
3485           put_thumb_insn (globals, stub_bfd, template[i].data & 0xffff,
3486                           loc + size + 2);
3487           if (template[i].r_type != R_ARM_NONE)
3488             {
3489               stub_reloc_idx[nrelocs] = i;
3490               stub_reloc_offset[nrelocs++] = size;
3491             }
3492           size += 4;
3493           break;
3494
3495         case ARM_TYPE:
3496           put_arm_insn (globals, stub_bfd, template[i].data, loc + size);
3497           /* Handle cases where the target is encoded within the
3498              instruction.  */
3499           if (template[i].r_type == R_ARM_JUMP24)
3500             {
3501               stub_reloc_idx[nrelocs] = i;
3502               stub_reloc_offset[nrelocs++] = size;
3503             }
3504           size += 4;
3505           break;
3506
3507         case DATA_TYPE:
3508           bfd_put_32 (stub_bfd, template[i].data, loc + size);
3509           stub_reloc_idx[nrelocs] = i;
3510           stub_reloc_offset[nrelocs++] = size;
3511           size += 4;
3512           break;
3513
3514         default:
3515           BFD_FAIL ();
3516           return FALSE;
3517         }
3518     }
3519
3520   stub_sec->size += size;
3521
3522   /* Stub size has already been computed in arm_size_one_stub. Check
3523      consistency.  */
3524   BFD_ASSERT (size == stub_entry->stub_size);
3525
3526   /* Destination is Thumb. Force bit 0 to 1 to reflect this.  */
3527   if (stub_entry->st_type == STT_ARM_TFUNC)
3528     sym_value |= 1;
3529
3530   /* Assume there is at least one and at most MAXRELOCS entries to relocate
3531      in each stub.  */
3532   BFD_ASSERT (nrelocs != 0 && nrelocs <= MAXRELOCS);
3533
3534   for (i = 0; i < nrelocs; i++)
3535     if (template[stub_reloc_idx[i]].r_type == R_ARM_THM_JUMP24
3536         || template[stub_reloc_idx[i]].r_type == R_ARM_THM_JUMP19
3537         || template[stub_reloc_idx[i]].r_type == R_ARM_THM_CALL
3538         || template[stub_reloc_idx[i]].r_type == R_ARM_THM_XPC22)
3539       {
3540         Elf_Internal_Rela rel;
3541         bfd_boolean unresolved_reloc;
3542         char *error_message;
3543         int sym_flags
3544           = (template[stub_reloc_idx[i]].r_type != R_ARM_THM_XPC22)
3545             ? STT_ARM_TFUNC : 0;
3546         bfd_vma points_to = sym_value + stub_entry->target_addend;
3547
3548         rel.r_offset = stub_entry->stub_offset + stub_reloc_offset[i];
3549         rel.r_info = ELF32_R_INFO (0, template[stub_reloc_idx[i]].r_type);
3550         rel.r_addend = template[stub_reloc_idx[i]].reloc_addend;
3551
3552         if (stub_entry->stub_type == arm_stub_a8_veneer_b_cond && i == 0)
3553           /* The first relocation in the elf32_arm_stub_a8_veneer_b_cond[]
3554              template should refer back to the instruction after the original
3555              branch.  */
3556           points_to = sym_value;
3557
3558         /* Note: _bfd_final_link_relocate doesn't handle these relocations
3559            properly.  We should probably use this function unconditionally,
3560            rather than only for certain relocations listed in the enclosing
3561            conditional, for the sake of consistency.  */
3562         elf32_arm_final_link_relocate (elf32_arm_howto_from_type
3563             (template[stub_reloc_idx[i]].r_type),
3564           stub_bfd, info->output_bfd, stub_sec, stub_sec->contents, &rel,
3565           points_to, info, stub_entry->target_section, "", sym_flags,
3566           (struct elf_link_hash_entry *) stub_entry, &unresolved_reloc,
3567           &error_message);
3568       }
3569     else
3570       {
3571         _bfd_final_link_relocate (elf32_arm_howto_from_type
3572             (template[stub_reloc_idx[i]].r_type), stub_bfd, stub_sec,
3573           stub_sec->contents, stub_entry->stub_offset + stub_reloc_offset[i],
3574           sym_value + stub_entry->target_addend,
3575           template[stub_reloc_idx[i]].reloc_addend);
3576       }
3577
3578   return TRUE;
3579 #undef MAXRELOCS
3580 }
3581
3582 /* Calculate the template, template size and instruction size for a stub.
3583    Return value is the instruction size.  */
3584
3585 static unsigned int
3586 find_stub_size_and_template (enum elf32_arm_stub_type stub_type,
3587                              const insn_sequence **stub_template,
3588                              int *stub_template_size)
3589 {
3590   const insn_sequence *template = NULL;
3591   int template_size = 0, i;
3592   unsigned int size;
3593
3594   template = stub_definitions[stub_type].template;
3595   template_size = stub_definitions[stub_type].template_size;
3596
3597   size = 0;
3598   for (i = 0; i < template_size; i++)
3599     {
3600       switch (template[i].type)
3601         {
3602         case THUMB16_TYPE:
3603           size += 2;
3604           break;
3605
3606         case ARM_TYPE:
3607         case THUMB32_TYPE:
3608         case DATA_TYPE:
3609           size += 4;
3610           break;
3611
3612         default:
3613           BFD_FAIL ();
3614           return FALSE;
3615         }
3616     }
3617
3618   if (stub_template)
3619     *stub_template = template;
3620
3621   if (stub_template_size)
3622     *stub_template_size = template_size;
3623
3624   return size;
3625 }
3626
3627 /* As above, but don't actually build the stub.  Just bump offset so
3628    we know stub section sizes.  */
3629
3630 static bfd_boolean
3631 arm_size_one_stub (struct bfd_hash_entry *gen_entry,
3632                    void * in_arg)
3633 {
3634   struct elf32_arm_stub_hash_entry *stub_entry;
3635   struct elf32_arm_link_hash_table *htab;
3636   const insn_sequence *template;
3637   int template_size, size;
3638
3639   /* Massage our args to the form they really have.  */
3640   stub_entry = (struct elf32_arm_stub_hash_entry *) gen_entry;
3641   htab = (struct elf32_arm_link_hash_table *) in_arg;
3642
3643   BFD_ASSERT((stub_entry->stub_type > arm_stub_none)
3644              && stub_entry->stub_type < ARRAY_SIZE(stub_definitions));
3645
3646   size = find_stub_size_and_template (stub_entry->stub_type, &template,
3647                                       &template_size);
3648
3649   stub_entry->stub_size = size;
3650   stub_entry->stub_template = template;
3651   stub_entry->stub_template_size = template_size;
3652
3653   size = (size + 7) & ~7;
3654   stub_entry->stub_sec->size += size;
3655
3656   return TRUE;
3657 }
3658
3659 /* External entry points for sizing and building linker stubs.  */
3660
3661 /* Set up various things so that we can make a list of input sections
3662    for each output section included in the link.  Returns -1 on error,
3663    0 when no stubs will be needed, and 1 on success.  */
3664
3665 int
3666 elf32_arm_setup_section_lists (bfd *output_bfd,
3667                                struct bfd_link_info *info)
3668 {
3669   bfd *input_bfd;
3670   unsigned int bfd_count;
3671   int top_id, top_index;
3672   asection *section;
3673   asection **input_list, **list;
3674   bfd_size_type amt;
3675   struct elf32_arm_link_hash_table *htab = elf32_arm_hash_table (info);
3676
3677   if (! is_elf_hash_table (htab))
3678     return 0;
3679
3680   /* Count the number of input BFDs and find the top input section id.  */
3681   for (input_bfd = info->input_bfds, bfd_count = 0, top_id = 0;
3682        input_bfd != NULL;
3683        input_bfd = input_bfd->link_next)
3684     {
3685       bfd_count += 1;
3686       for (section = input_bfd->sections;
3687            section != NULL;
3688            section = section->next)
3689         {
3690           if (top_id < section->id)
3691             top_id = section->id;
3692         }
3693     }
3694   htab->bfd_count = bfd_count;
3695
3696   amt = sizeof (struct map_stub) * (top_id + 1);
3697   htab->stub_group = bfd_zmalloc (amt);
3698   if (htab->stub_group == NULL)
3699     return -1;
3700
3701   /* We can't use output_bfd->section_count here to find the top output
3702      section index as some sections may have been removed, and
3703      _bfd_strip_section_from_output doesn't renumber the indices.  */
3704   for (section = output_bfd->sections, top_index = 0;
3705        section != NULL;
3706        section = section->next)
3707     {
3708       if (top_index < section->index)
3709         top_index = section->index;
3710     }
3711
3712   htab->top_index = top_index;
3713   amt = sizeof (asection *) * (top_index + 1);
3714   input_list = bfd_malloc (amt);
3715   htab->input_list = input_list;
3716   if (input_list == NULL)
3717     return -1;
3718
3719   /* For sections we aren't interested in, mark their entries with a
3720      value we can check later.  */
3721   list = input_list + top_index;
3722   do
3723     *list = bfd_abs_section_ptr;
3724   while (list-- != input_list);
3725
3726   for (section = output_bfd->sections;
3727        section != NULL;
3728        section = section->next)
3729     {
3730       if ((section->flags & SEC_CODE) != 0)
3731         input_list[section->index] = NULL;
3732     }
3733
3734   return 1;
3735 }
3736
3737 /* The linker repeatedly calls this function for each input section,
3738    in the order that input sections are linked into output sections.
3739    Build lists of input sections to determine groupings between which
3740    we may insert linker stubs.  */
3741
3742 void
3743 elf32_arm_next_input_section (struct bfd_link_info *info,
3744                               asection *isec)
3745 {
3746   struct elf32_arm_link_hash_table *htab = elf32_arm_hash_table (info);
3747
3748   if (isec->output_section->index <= htab->top_index)
3749     {
3750       asection **list = htab->input_list + isec->output_section->index;
3751
3752       if (*list != bfd_abs_section_ptr)
3753         {
3754           /* Steal the link_sec pointer for our list.  */
3755 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
3756           /* This happens to make the list in reverse order,
3757              which we reverse later.  */
3758           PREV_SEC (isec) = *list;
3759           *list = isec;
3760         }
3761     }
3762 }
3763
3764 /* See whether we can group stub sections together.  Grouping stub
3765    sections may result in fewer stubs.  More importantly, we need to
3766    put all .init* and .fini* stubs at the end of the .init or
3767    .fini output sections respectively, because glibc splits the
3768    _init and _fini functions into multiple parts.  Putting a stub in
3769    the middle of a function is not a good idea.  */
3770
3771 static void
3772 group_sections (struct elf32_arm_link_hash_table *htab,
3773                 bfd_size_type stub_group_size,
3774                 bfd_boolean stubs_always_after_branch)
3775 {
3776   asection **list = htab->input_list;
3777
3778   do
3779     {
3780       asection *tail = *list;
3781       asection *head;
3782
3783       if (tail == bfd_abs_section_ptr)
3784         continue;
3785
3786       /* Reverse the list: we must avoid placing stubs at the
3787          beginning of the section because the beginning of the text
3788          section may be required for an interrupt vector in bare metal
3789          code.  */
3790 #define NEXT_SEC PREV_SEC
3791       head = NULL;
3792       while (tail != NULL)
3793         {
3794           /* Pop from tail.  */
3795           asection *item = tail;
3796           tail = PREV_SEC (item);
3797
3798           /* Push on head.  */
3799           NEXT_SEC (item) = head;
3800           head = item;
3801         }
3802
3803       while (head != NULL)
3804         {
3805           asection *curr;
3806           asection *next;
3807           bfd_vma stub_group_start = head->output_offset;
3808           bfd_vma end_of_next;
3809
3810           curr = head;
3811           while (NEXT_SEC (curr) != NULL)
3812             {
3813               next = NEXT_SEC (curr);
3814               end_of_next = next->output_offset + next->size;
3815               if (end_of_next - stub_group_start >= stub_group_size)
3816                 /* End of NEXT is too far from start, so stop.  */
3817                 break;
3818               /* Add NEXT to the group.  */
3819               curr = next;
3820             }
3821
3822           /* OK, the size from the start to the start of CURR is less
3823              than stub_group_size and thus can be handled by one stub
3824              section.  (Or the head section is itself larger than
3825              stub_group_size, in which case we may be toast.)
3826              We should really be keeping track of the total size of
3827              stubs added here, as stubs contribute to the final output
3828              section size.  */
3829           do
3830             {
3831               next = NEXT_SEC (head);
3832               /* Set up this stub group.  */
3833               htab->stub_group[head->id].link_sec = curr;
3834             }
3835           while (head != curr && (head = next) != NULL);
3836
3837           /* But wait, there's more!  Input sections up to stub_group_size
3838              bytes after the stub section can be handled by it too.  */
3839           if (!stubs_always_after_branch)
3840             {
3841               stub_group_start = curr->output_offset + curr->size;
3842
3843               while (next != NULL)
3844                 {
3845                   end_of_next = next->output_offset + next->size;
3846                   if (end_of_next - stub_group_start >= stub_group_size)
3847                     /* End of NEXT is too far from stubs, so stop.  */
3848                     break;
3849                   /* Add NEXT to the stub group.  */
3850                   head = next;
3851                   next = NEXT_SEC (head);
3852                   htab->stub_group[head->id].link_sec = curr;
3853                 }
3854             }
3855           head = next;
3856         }
3857     }
3858   while (list++ != htab->input_list + htab->top_index);
3859
3860   free (htab->input_list);
3861 #undef PREV_SEC
3862 #undef NEXT_SEC
3863 }
3864
3865 /* Comparison function for sorting/searching relocations relating to Cortex-A8
3866    erratum fix.  */
3867
3868 static int
3869 a8_reloc_compare (const void *a, const void *b)
3870 {
3871   const struct a8_erratum_reloc *ra = a, *rb = b;
3872
3873   if (ra->from < rb->from)
3874     return -1;
3875   else if (ra->from > rb->from)
3876     return 1;
3877   else
3878     return 0;
3879 }
3880
3881 static struct elf_link_hash_entry *find_thumb_glue (struct bfd_link_info *,
3882                                                     const char *, char **);
3883
3884 /* Helper function to scan code for sequences which might trigger the Cortex-A8
3885    branch/TLB erratum.  Fill in the table described by A8_FIXES_P,
3886    NUM_A8_FIXES_P, A8_FIX_TABLE_SIZE_P.  Return 1 if an error occurs, 0
3887    otherwise.  */
3888
3889 static int
3890 cortex_a8_erratum_scan (bfd *input_bfd, struct bfd_link_info *info,
3891                         struct a8_erratum_fix **a8_fixes_p,
3892                         unsigned int *num_a8_fixes_p,
3893                         unsigned int *a8_fix_table_size_p,
3894                         struct a8_erratum_reloc *a8_relocs,
3895                         unsigned int num_a8_relocs)
3896 {
3897   asection *section;
3898   struct elf32_arm_link_hash_table *htab = elf32_arm_hash_table (info);
3899   struct a8_erratum_fix *a8_fixes = *a8_fixes_p;
3900   unsigned int num_a8_fixes = *num_a8_fixes_p;
3901   unsigned int a8_fix_table_size = *a8_fix_table_size_p;
3902
3903   for (section = input_bfd->sections;
3904        section != NULL;
3905        section = section->next)
3906     {
3907       bfd_byte *contents = NULL;
3908       struct _arm_elf_section_data *sec_data;
3909       unsigned int span;
3910       bfd_vma base_vma;
3911
3912       if (elf_section_type (section) != SHT_PROGBITS
3913           || (elf_section_flags (section) & SHF_EXECINSTR) == 0
3914           || (section->flags & SEC_EXCLUDE) != 0
3915           || (section->sec_info_type == ELF_INFO_TYPE_JUST_SYMS)
3916           || (section->output_section == bfd_abs_section_ptr))
3917         continue;
3918
3919       base_vma = section->output_section->vma + section->output_offset;
3920
3921       if (elf_section_data (section)->this_hdr.contents != NULL)
3922         contents = elf_section_data (section)->this_hdr.contents;
3923       else if (! bfd_malloc_and_get_section (input_bfd, section, &contents))
3924         return 1;
3925
3926       sec_data = elf32_arm_section_data (section);
3927
3928       for (span = 0; span < sec_data->mapcount; span++)
3929         {
3930           unsigned int span_start = sec_data->map[span].vma;
3931           unsigned int span_end = (span == sec_data->mapcount - 1)
3932             ? section->size : sec_data->map[span + 1].vma;
3933           unsigned int i;
3934           char span_type = sec_data->map[span].type;
3935           bfd_boolean last_was_32bit = FALSE, last_was_branch = FALSE;
3936
3937           if (span_type != 't')
3938             continue;
3939
3940           /* Span is entirely within a single 4KB region: skip scanning.  */
3941           if (((base_vma + span_start) & ~0xfff)
3942               == ((base_vma + span_end) & ~0xfff))
3943             continue;
3944
3945           /* Scan for 32-bit Thumb-2 branches which span two 4K regions, where:
3946
3947                * The opcode is BLX.W, BL.W, B.W, Bcc.W
3948                * The branch target is in the same 4KB region as the
3949                  first half of the branch.
3950                * The instruction before the branch is a 32-bit
3951                  length non-branch instruction.
3952           */
3953
3954           for (i = span_start; i < span_end;)
3955             {
3956               unsigned int insn = bfd_getl16 (&contents[i]);
3957               bfd_boolean insn_32bit = FALSE, is_blx = FALSE, is_b = FALSE;
3958               bfd_boolean is_bl = FALSE, is_bcc = FALSE, is_32bit_branch;
3959
3960               if ((insn & 0xe000) == 0xe000 && (insn & 0x1800) != 0x0000)
3961                 insn_32bit = TRUE;
3962
3963               if (insn_32bit)
3964                 {
3965                   /* Load the rest of the insn (in manual-friendly order).  */
3966                   insn = (insn << 16) | bfd_getl16 (&contents[i + 2]);
3967
3968                   /* Encoding T4: B<c>.W.  */
3969                   is_b = (insn & 0xf800d000) == 0xf0009000;
3970                   /* Encoding T1: BL<c>.W.  */
3971                   is_bl = (insn & 0xf800d000) == 0xf000d000;
3972                   /* Encoding T2: BLX<c>.W.  */
3973                   is_blx = (insn & 0xf800d000) == 0xf000c000;
3974                   /* Encoding T3: B<c>.W (not permitted in IT block).  */
3975                   is_bcc = (insn & 0xf800d000) == 0xf0008000
3976                            && (insn & 0x07f00000) != 0x03800000;
3977                 }
3978
3979               is_32bit_branch = is_b || is_bl || is_blx || is_bcc;
3980
3981               if (((base_vma + i) & 0xfff) == 0xffe && insn_32bit
3982                   && is_32bit_branch && last_was_32bit && !last_was_branch)
3983                 {
3984                   bfd_vma offset;
3985                   bfd_boolean force_target_arm = FALSE;
3986                   bfd_boolean force_target_thumb = FALSE;
3987                   bfd_vma target;
3988                   enum elf32_arm_stub_type stub_type = arm_stub_none;
3989                   struct a8_erratum_reloc key, *found;
3990
3991                   key.from = base_vma + i;
3992                   found = bsearch (&key, a8_relocs, num_a8_relocs,
3993                                    sizeof (struct a8_erratum_reloc),
3994                                    &a8_reloc_compare);
3995
3996                   if (found)
3997                     {
3998                       char *error_message = NULL;
3999                       struct elf_link_hash_entry *entry;
4000
4001                       /* We don't care about the error returned from this
4002                          function, only if there is glue or not.  */
4003                       entry = find_thumb_glue (info, found->sym_name,
4004                                                &error_message);
4005
4006                       if (entry)
4007                         found->non_a8_stub = TRUE;
4008
4009                       if (found->r_type == R_ARM_THM_CALL
4010                           && found->st_type != STT_ARM_TFUNC)
4011                         force_target_arm = TRUE;
4012                       else if (found->r_type == R_ARM_THM_CALL
4013                                && found->st_type == STT_ARM_TFUNC)
4014                         force_target_thumb = TRUE;
4015                     }
4016
4017                   /* Check if we have an offending branch instruction.  */
4018
4019                   if (found && found->non_a8_stub)
4020                     /* We've already made a stub for this instruction, e.g.
4021                        it's a long branch or a Thumb->ARM stub.  Assume that
4022                        stub will suffice to work around the A8 erratum (see
4023                        setting of always_after_branch above).  */
4024                     ;
4025                   else if (is_bcc)
4026                     {
4027                       offset = (insn & 0x7ff) << 1;
4028                       offset |= (insn & 0x3f0000) >> 4;
4029                       offset |= (insn & 0x2000) ? 0x40000 : 0;
4030                       offset |= (insn & 0x800) ? 0x80000 : 0;
4031                       offset |= (insn & 0x4000000) ? 0x100000 : 0;
4032                       if (offset & 0x100000)
4033                         offset |= ~0xfffff;
4034                       stub_type = arm_stub_a8_veneer_b_cond;
4035                     }
4036                   else if (is_b || is_bl || is_blx)
4037                     {
4038                       int s = (insn & 0x4000000) != 0;
4039                       int j1 = (insn & 0x2000) != 0;
4040                       int j2 = (insn & 0x800) != 0;
4041                       int i1 = !(j1 ^ s);
4042                       int i2 = !(j2 ^ s);
4043
4044                       offset = (insn & 0x7ff) << 1;
4045                       offset |= (insn & 0x3ff0000) >> 4;
4046                       offset |= i2 << 22;
4047                       offset |= i1 << 23;
4048                       offset |= s << 24;
4049                       if (offset & 0x1000000)
4050                         offset |= ~0xffffff;
4051
4052                       if (is_blx)
4053                         offset &= ~3u;
4054
4055                       stub_type = is_blx ? arm_stub_a8_veneer_blx :
4056                         is_bl ? arm_stub_a8_veneer_bl : arm_stub_a8_veneer_b;
4057                     }
4058
4059                   if (stub_type != arm_stub_none)
4060                     {
4061                       bfd_vma pc_for_insn = base_vma + i + 4;
4062
4063                       /* The original instruction is a BL, but the target is
4064                          an ARM instruction.  If we were not making a stub,
4065                          the BL would have been converted to a BLX.  Use the
4066                          BLX stub instead in that case.  */
4067                       if (htab->use_blx && force_target_arm
4068                           && stub_type == arm_stub_a8_veneer_bl)
4069                         {
4070                           stub_type = arm_stub_a8_veneer_blx;
4071                           is_blx = TRUE;
4072                           is_bl = FALSE;
4073                         }
4074                       /* Conversely, if the original instruction was
4075                          BLX but the target is Thumb mode, use the BL
4076                          stub.  */
4077                       else if (force_target_thumb
4078                                && stub_type == arm_stub_a8_veneer_blx)
4079                         {
4080                           stub_type = arm_stub_a8_veneer_bl;
4081                           is_blx = FALSE;
4082                           is_bl = TRUE;
4083                         }
4084
4085                       if (is_blx)
4086                         pc_for_insn &= ~3u;
4087
4088                       /* If we found a relocation, use the proper destination,
4089                          not the offset in the (unrelocated) instruction.
4090                          Note this is always done if we switched the stub type
4091                          above.  */
4092                       if (found)
4093                         offset = found->destination - pc_for_insn;
4094
4095                       target = pc_for_insn + offset;
4096
4097                       /* The BLX stub is ARM-mode code.  Adjust the offset to
4098                          take the different PC value (+8 instead of +4) into
4099                          account.  */
4100                       if (stub_type == arm_stub_a8_veneer_blx)
4101                         offset += 4;
4102
4103                       if (((base_vma + i) & ~0xfff) == (target & ~0xfff))
4104                         {
4105                           char *stub_name;
4106
4107                           if (num_a8_fixes == a8_fix_table_size)
4108                             {
4109                               a8_fix_table_size *= 2;
4110                               a8_fixes = bfd_realloc (a8_fixes,
4111                                 sizeof (struct a8_erratum_fix)
4112                                 * a8_fix_table_size);
4113                             }
4114
4115                           stub_name = bfd_malloc (8 + 1 + 8 + 1);
4116                           if (stub_name != NULL)
4117                             sprintf (stub_name, "%x:%x", section->id, i);
4118
4119                           a8_fixes[num_a8_fixes].input_bfd = input_bfd;
4120                           a8_fixes[num_a8_fixes].section = section;
4121                           a8_fixes[num_a8_fixes].offset = i;
4122                           a8_fixes[num_a8_fixes].addend = offset;
4123                           a8_fixes[num_a8_fixes].orig_insn = insn;
4124                           a8_fixes[num_a8_fixes].stub_name = stub_name;
4125                           a8_fixes[num_a8_fixes].stub_type = stub_type;
4126
4127                           num_a8_fixes++;
4128                         }
4129                     }
4130                 }
4131
4132               i += insn_32bit ? 4 : 2;
4133               last_was_32bit = insn_32bit;
4134               last_was_branch = is_32bit_branch;
4135             }
4136         }
4137
4138       if (elf_section_data (section)->this_hdr.contents == NULL)
4139         free (contents);
4140     }
4141
4142   *a8_fixes_p = a8_fixes;
4143   *num_a8_fixes_p = num_a8_fixes;
4144   *a8_fix_table_size_p = a8_fix_table_size;
4145
4146   return 0;
4147 }
4148
4149 /* Determine and set the size of the stub section for a final link.
4150
4151    The basic idea here is to examine all the relocations looking for
4152    PC-relative calls to a target that is unreachable with a "bl"
4153    instruction.  */
4154
4155 bfd_boolean
4156 elf32_arm_size_stubs (bfd *output_bfd,
4157                       bfd *stub_bfd,
4158                       struct bfd_link_info *info,
4159                       bfd_signed_vma group_size,
4160                       asection * (*add_stub_section) (const char *, asection *),
4161                       void (*layout_sections_again) (void))
4162 {
4163   bfd_size_type stub_group_size;
4164   bfd_boolean stubs_always_after_branch;
4165   bfd_boolean stub_changed = 0;
4166   struct elf32_arm_link_hash_table *htab = elf32_arm_hash_table (info);
4167   struct a8_erratum_fix *a8_fixes = NULL;
4168   unsigned int num_a8_fixes = 0, prev_num_a8_fixes = 0, a8_fix_table_size = 10;
4169   struct a8_erratum_reloc *a8_relocs = NULL;
4170   unsigned int num_a8_relocs = 0, a8_reloc_table_size = 10, i;
4171
4172   if (htab->fix_cortex_a8)
4173     {
4174       a8_fixes = bfd_zmalloc (sizeof (struct a8_erratum_fix)
4175                               * a8_fix_table_size);
4176       a8_relocs = bfd_zmalloc (sizeof (struct a8_erratum_reloc)
4177                                * a8_reloc_table_size);
4178     }
4179
4180   /* Propagate mach to stub bfd, because it may not have been
4181      finalized when we created stub_bfd.  */
4182   bfd_set_arch_mach (stub_bfd, bfd_get_arch (output_bfd),
4183                      bfd_get_mach (output_bfd));
4184
4185   /* Stash our params away.  */
4186   htab->stub_bfd = stub_bfd;
4187   htab->add_stub_section = add_stub_section;
4188   htab->layout_sections_again = layout_sections_again;
4189   stubs_always_after_branch = group_size < 0;
4190
4191   /* The Cortex-A8 erratum fix depends on stubs not being in the same 4K page
4192      as the first half of a 32-bit branch straddling two 4K pages.  This is a
4193      crude way of enforcing that.  */
4194   if (htab->fix_cortex_a8)
4195     stubs_always_after_branch = 1;
4196
4197   if (group_size < 0)
4198     stub_group_size = -group_size;
4199   else
4200     stub_group_size = group_size;
4201
4202   if (stub_group_size == 1)
4203     {
4204       /* Default values.  */
4205       /* Thumb branch range is +-4MB has to be used as the default
4206          maximum size (a given section can contain both ARM and Thumb
4207          code, so the worst case has to be taken into account).
4208
4209          This value is 24K less than that, which allows for 2025
4210          12-byte stubs.  If we exceed that, then we will fail to link.
4211          The user will have to relink with an explicit group size
4212          option.  */
4213       stub_group_size = 4170000;
4214     }
4215
4216   group_sections (htab, stub_group_size, stubs_always_after_branch);
4217
4218   while (1)
4219     {
4220       bfd *input_bfd;
4221       unsigned int bfd_indx;
4222       asection *stub_sec;
4223
4224       num_a8_fixes = 0;
4225
4226       for (input_bfd = info->input_bfds, bfd_indx = 0;
4227            input_bfd != NULL;
4228            input_bfd = input_bfd->link_next, bfd_indx++)
4229         {
4230           Elf_Internal_Shdr *symtab_hdr;
4231           asection *section;
4232           Elf_Internal_Sym *local_syms = NULL;
4233
4234           num_a8_relocs = 0;
4235
4236           /* We'll need the symbol table in a second.  */
4237           symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
4238           if (symtab_hdr->sh_info == 0)
4239             continue;
4240
4241           /* Walk over each section attached to the input bfd.  */
4242           for (section = input_bfd->sections;
4243                section != NULL;
4244                section = section->next)
4245             {
4246               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
4247
4248               /* If there aren't any relocs, then there's nothing more
4249                  to do.  */
4250               if ((section->flags & SEC_RELOC) == 0
4251                   || section->reloc_count == 0
4252                   || (section->flags & SEC_CODE) == 0)
4253                 continue;
4254
4255               /* If this section is a link-once section that will be
4256                  discarded, then don't create any stubs.  */
4257               if (section->output_section == NULL
4258                   || section->output_section->owner != output_bfd)
4259                 continue;
4260
4261               /* Get the relocs.  */
4262               internal_relocs
4263                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL,
4264                                              NULL, info->keep_memory);
4265               if (internal_relocs == NULL)
4266                 goto error_ret_free_local;
4267
4268               /* Now examine each relocation.  */
4269               irela = internal_relocs;
4270               irelaend = irela + section->reloc_count;
4271               for (; irela < irelaend; irela++)
4272                 {
4273                   unsigned int r_type, r_indx;
4274                   enum elf32_arm_stub_type stub_type;
4275                   struct elf32_arm_stub_hash_entry *stub_entry;
4276                   asection *sym_sec;
4277                   bfd_vma sym_value;
4278                   bfd_vma destination;
4279                   struct elf32_arm_link_hash_entry *hash;
4280                   const char *sym_name;
4281                   char *stub_name;
4282                   const asection *id_sec;
4283                   unsigned char st_type;
4284                   bfd_boolean created_stub = FALSE;
4285
4286                   r_type = ELF32_R_TYPE (irela->r_info);
4287                   r_indx = ELF32_R_SYM (irela->r_info);
4288
4289                   if (r_type >= (unsigned int) R_ARM_max)
4290                     {
4291                       bfd_set_error (bfd_error_bad_value);
4292                     error_ret_free_internal:
4293                       if (elf_section_data (section)->relocs == NULL)
4294                         free (internal_relocs);
4295                       goto error_ret_free_local;
4296                     }
4297
4298                   /* Only look for stubs on branch instructions.  */
4299                   if ((r_type != (unsigned int) R_ARM_CALL)
4300                       && (r_type != (unsigned int) R_ARM_THM_CALL)
4301                       && (r_type != (unsigned int) R_ARM_JUMP24)
4302                       && (r_type != (unsigned int) R_ARM_THM_JUMP19)
4303                       && (r_type != (unsigned int) R_ARM_THM_XPC22)
4304                       && (r_type != (unsigned int) R_ARM_THM_JUMP24)
4305                       && (r_type != (unsigned int) R_ARM_PLT32))
4306                     continue;
4307
4308                   /* Now determine the call target, its name, value,
4309                      section.  */
4310                   sym_sec = NULL;
4311                   sym_value = 0;
4312                   destination = 0;
4313                   hash = NULL;
4314                   sym_name = NULL;
4315                   if (r_indx < symtab_hdr->sh_info)
4316                     {
4317                       /* It's a local symbol.  */
4318                       Elf_Internal_Sym *sym;
4319                       Elf_Internal_Shdr *hdr;
4320
4321                       if (local_syms == NULL)
4322                         {
4323                           local_syms
4324                             = (Elf_Internal_Sym *) symtab_hdr->contents;
4325                           if (local_syms == NULL)
4326                             local_syms
4327                               = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
4328                                                       symtab_hdr->sh_info, 0,
4329                                                       NULL, NULL, NULL);
4330                           if (local_syms == NULL)
4331                             goto error_ret_free_internal;
4332                         }
4333
4334                       sym = local_syms + r_indx;
4335                       hdr = elf_elfsections (input_bfd)[sym->st_shndx];
4336                       sym_sec = hdr->bfd_section;
4337                       if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
4338                         sym_value = sym->st_value;
4339                       destination = (sym_value + irela->r_addend
4340                                      + sym_sec->output_offset
4341                                      + sym_sec->output_section->vma);
4342                       st_type = ELF_ST_TYPE (sym->st_info);
4343                       sym_name
4344                         = bfd_elf_string_from_elf_section (input_bfd,
4345                                                            symtab_hdr->sh_link,
4346                                                            sym->st_name);
4347                     }
4348                   else
4349                     {
4350                       /* It's an external symbol.  */
4351                       int e_indx;
4352
4353                       e_indx = r_indx - symtab_hdr->sh_info;
4354                       hash = ((struct elf32_arm_link_hash_entry *)
4355                               elf_sym_hashes (input_bfd)[e_indx]);
4356
4357                       while (hash->root.root.type == bfd_link_hash_indirect
4358                              || hash->root.root.type == bfd_link_hash_warning)
4359                         hash = ((struct elf32_arm_link_hash_entry *)
4360                                 hash->root.root.u.i.link);
4361
4362                       if (hash->root.root.type == bfd_link_hash_defined
4363                           || hash->root.root.type == bfd_link_hash_defweak)
4364                         {
4365                           sym_sec = hash->root.root.u.def.section;
4366                           sym_value = hash->root.root.u.def.value;
4367                           if (sym_sec->output_section != NULL)
4368                             destination = (sym_value + irela->r_addend
4369                                            + sym_sec->output_offset
4370                                            + sym_sec->output_section->vma);
4371                         }
4372                       else if ((hash->root.root.type == bfd_link_hash_undefined)
4373                                || (hash->root.root.type == bfd_link_hash_undefweak))
4374                         {
4375                           /* For a shared library, use the PLT stub as
4376                              target address to decide whether a long
4377                              branch stub is needed.
4378                              For absolute code, they cannot be handled.  */
4379                           struct elf32_arm_link_hash_table *globals =
4380                             elf32_arm_hash_table (info);
4381
4382                           if (globals->splt != NULL && hash != NULL
4383                               && hash->root.plt.offset != (bfd_vma) -1)
4384                             {
4385                               sym_sec = globals->splt;
4386                               sym_value = hash->root.plt.offset;
4387                               if (sym_sec->output_section != NULL)
4388                                 destination = (sym_value
4389                                                + sym_sec->output_offset
4390                                                + sym_sec->output_section->vma);
4391                             }
4392                           else
4393                             continue;
4394                         }
4395                       else
4396                         {
4397                           bfd_set_error (bfd_error_bad_value);
4398                           goto error_ret_free_internal;
4399                         }
4400                       st_type = ELF_ST_TYPE (hash->root.type);
4401                       sym_name = hash->root.root.root.string;
4402                     }
4403
4404                   do
4405                     {
4406                       /* Determine what (if any) linker stub is needed.  */
4407                       stub_type = arm_type_of_stub (info, section, irela,
4408                                                     st_type, hash,
4409                                                     destination, sym_sec,
4410                                                     input_bfd, sym_name);
4411                       if (stub_type == arm_stub_none)
4412                         break;
4413
4414                       /* Support for grouping stub sections.  */
4415                       id_sec = htab->stub_group[section->id].link_sec;
4416
4417                       /* Get the name of this stub.  */
4418                       stub_name = elf32_arm_stub_name (id_sec, sym_sec, hash,
4419                                                        irela);
4420                       if (!stub_name)
4421                         goto error_ret_free_internal;
4422
4423                       /* We've either created a stub for this reloc already,
4424                          or we are about to.  */
4425                       created_stub = TRUE;
4426
4427                       stub_entry = arm_stub_hash_lookup
4428                                      (&htab->stub_hash_table, stub_name,
4429                                       FALSE, FALSE);
4430                       if (stub_entry != NULL)
4431                         {
4432                           /* The proper stub has already been created.  */
4433                           free (stub_name);
4434                           break;
4435                         }
4436
4437                       stub_entry = elf32_arm_add_stub (stub_name, section,
4438                                                        htab);
4439                       if (stub_entry == NULL)
4440                         {
4441                           free (stub_name);
4442                           goto error_ret_free_internal;
4443                         }
4444
4445                       stub_entry->target_value = sym_value;
4446                       stub_entry->target_section = sym_sec;
4447                       stub_entry->stub_type = stub_type;
4448                       stub_entry->h = hash;
4449                       stub_entry->st_type = st_type;
4450
4451                       if (sym_name == NULL)
4452                         sym_name = "unnamed";
4453                       stub_entry->output_name
4454                         = bfd_alloc (htab->stub_bfd,
4455                                      sizeof (THUMB2ARM_GLUE_ENTRY_NAME)
4456                                      + strlen (sym_name));
4457                       if (stub_entry->output_name == NULL)
4458                         {
4459                           free (stub_name);
4460                           goto error_ret_free_internal;
4461                         }
4462
4463                       /* For historical reasons, use the existing names for
4464                          ARM-to-Thumb and Thumb-to-ARM stubs.  */
4465                       if ( ((r_type == (unsigned int) R_ARM_THM_CALL)
4466                             || (r_type == (unsigned int) R_ARM_THM_JUMP24))
4467                            && st_type != STT_ARM_TFUNC)
4468                         sprintf (stub_entry->output_name,
4469                                  THUMB2ARM_GLUE_ENTRY_NAME, sym_name);
4470                       else if ( ((r_type == (unsigned int) R_ARM_CALL)
4471                                  || (r_type == (unsigned int) R_ARM_JUMP24))
4472                                && st_type == STT_ARM_TFUNC)
4473                         sprintf (stub_entry->output_name,
4474                                  ARM2THUMB_GLUE_ENTRY_NAME, sym_name);
4475                       else
4476                         sprintf (stub_entry->output_name, STUB_ENTRY_NAME,
4477                                  sym_name);
4478
4479                       stub_changed = TRUE;
4480                     }
4481                   while (0);
4482
4483                   /* Look for relocations which might trigger Cortex-A8
4484                      erratum.  */
4485                   if (htab->fix_cortex_a8
4486                       && (r_type == (unsigned int) R_ARM_THM_JUMP24
4487                           || r_type == (unsigned int) R_ARM_THM_JUMP19
4488                           || r_type == (unsigned int) R_ARM_THM_CALL
4489                           || r_type == (unsigned int) R_ARM_THM_XPC22))
4490                     {
4491                       bfd_vma from = section->output_section->vma
4492                                      + section->output_offset
4493                                      + irela->r_offset;
4494
4495                       if ((from & 0xfff) == 0xffe)
4496                         {
4497                           /* Found a candidate.  Note we haven't checked the
4498                              destination is within 4K here: if we do so (and
4499                              don't create an entry in a8_relocs) we can't tell
4500                              that a branch should have been relocated when
4501                              scanning later.  */
4502                           if (num_a8_relocs == a8_reloc_table_size)
4503                             {
4504                               a8_reloc_table_size *= 2;
4505                               a8_relocs = bfd_realloc (a8_relocs,
4506                                 sizeof (struct a8_erratum_reloc)
4507                                 * a8_reloc_table_size);
4508                             }
4509
4510                           a8_relocs[num_a8_relocs].from = from;
4511                           a8_relocs[num_a8_relocs].destination = destination;
4512                           a8_relocs[num_a8_relocs].r_type = r_type;
4513                           a8_relocs[num_a8_relocs].st_type = st_type;
4514                           a8_relocs[num_a8_relocs].sym_name = sym_name;
4515                           a8_relocs[num_a8_relocs].non_a8_stub = created_stub;
4516
4517                           num_a8_relocs++;
4518                         }
4519                     }
4520                 }
4521
4522               /* We're done with the internal relocs, free them.  */
4523               if (elf_section_data (section)->relocs == NULL)
4524                 free (internal_relocs);
4525             }
4526
4527           if (htab->fix_cortex_a8)
4528             {
4529               /* Sort relocs which might apply to Cortex-A8 erratum.  */
4530               qsort (a8_relocs, num_a8_relocs, sizeof (struct a8_erratum_reloc),
4531                      &a8_reloc_compare);
4532
4533               /* Scan for branches which might trigger Cortex-A8 erratum.  */
4534               if (cortex_a8_erratum_scan (input_bfd, info, &a8_fixes,
4535                                           &num_a8_fixes, &a8_fix_table_size,
4536                                           a8_relocs, num_a8_relocs) != 0)
4537                 goto error_ret_free_local;
4538             }
4539         }
4540
4541       if (htab->fix_cortex_a8 && num_a8_fixes != prev_num_a8_fixes)
4542         stub_changed = TRUE;
4543
4544       if (!stub_changed)
4545         break;
4546
4547       /* OK, we've added some stubs.  Find out the new size of the
4548          stub sections.  */
4549       for (stub_sec = htab->stub_bfd->sections;
4550            stub_sec != NULL;
4551            stub_sec = stub_sec->next)
4552         {
4553           /* Ignore non-stub sections.  */
4554           if (!strstr (stub_sec->name, STUB_SUFFIX))
4555             continue;
4556
4557           stub_sec->size = 0;
4558         }
4559
4560       bfd_hash_traverse (&htab->stub_hash_table, arm_size_one_stub, htab);
4561
4562       /* Add Cortex-A8 erratum veneers to stub section sizes too.  */
4563       if (htab->fix_cortex_a8)
4564         for (i = 0; i < num_a8_fixes; i++)
4565           {
4566             stub_sec = elf32_arm_create_or_find_stub_sec (NULL,
4567                          a8_fixes[i].section, htab);
4568
4569             if (stub_sec == NULL)
4570               goto error_ret_free_local;
4571
4572             stub_sec->size
4573               += find_stub_size_and_template (a8_fixes[i].stub_type, NULL,
4574                                               NULL);
4575           }
4576
4577
4578       /* Ask the linker to do its stuff.  */
4579       (*htab->layout_sections_again) ();
4580       stub_changed = FALSE;
4581       prev_num_a8_fixes = num_a8_fixes;
4582     }
4583
4584   /* Add stubs for Cortex-A8 erratum fixes now.  */
4585   if (htab->fix_cortex_a8)
4586     {
4587       for (i = 0; i < num_a8_fixes; i++)
4588         {
4589           struct elf32_arm_stub_hash_entry *stub_entry;
4590           char *stub_name = a8_fixes[i].stub_name;
4591           asection *section = a8_fixes[i].section;
4592           unsigned int section_id = a8_fixes[i].section->id;
4593           asection *link_sec = htab->stub_group[section_id].link_sec;
4594           asection *stub_sec = htab->stub_group[section_id].stub_sec;
4595           const insn_sequence *template;
4596           int template_size, size = 0;
4597
4598           stub_entry = arm_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4599                                              TRUE, FALSE);
4600           if (stub_entry == NULL)
4601             {
4602               (*_bfd_error_handler) (_("%s: cannot create stub entry %s"),
4603                                      section->owner,
4604                                      stub_name);
4605               return FALSE;
4606             }
4607
4608           stub_entry->stub_sec = stub_sec;
4609           stub_entry->stub_offset = 0;
4610           stub_entry->id_sec = link_sec;
4611           stub_entry->stub_type = a8_fixes[i].stub_type;
4612           stub_entry->target_section = a8_fixes[i].section;
4613           stub_entry->target_value = a8_fixes[i].offset;
4614           stub_entry->target_addend = a8_fixes[i].addend;
4615           stub_entry->orig_insn = a8_fixes[i].orig_insn;
4616           stub_entry->st_type = STT_ARM_TFUNC;
4617
4618           size = find_stub_size_and_template (a8_fixes[i].stub_type, &template,
4619                                               &template_size);
4620
4621           stub_entry->stub_size = size;
4622           stub_entry->stub_template = template;
4623           stub_entry->stub_template_size = template_size;
4624         }
4625
4626       /* Stash the Cortex-A8 erratum fix array for use later in
4627          elf32_arm_write_section().  */
4628       htab->a8_erratum_fixes = a8_fixes;
4629       htab->num_a8_erratum_fixes = num_a8_fixes;
4630     }
4631   else
4632     {
4633       htab->a8_erratum_fixes = NULL;
4634       htab->num_a8_erratum_fixes = 0;
4635     }
4636   return TRUE;
4637
4638  error_ret_free_local:
4639   return FALSE;
4640 }
4641
4642 /* Build all the stubs associated with the current output file.  The
4643    stubs are kept in a hash table attached to the main linker hash
4644    table.  We also set up the .plt entries for statically linked PIC
4645    functions here.  This function is called via arm_elf_finish in the
4646    linker.  */
4647
4648 bfd_boolean
4649 elf32_arm_build_stubs (struct bfd_link_info *info)
4650 {
4651   asection *stub_sec;
4652   struct bfd_hash_table *table;
4653   struct elf32_arm_link_hash_table *htab;
4654
4655   htab = elf32_arm_hash_table (info);
4656
4657   for (stub_sec = htab->stub_bfd->sections;
4658        stub_sec != NULL;
4659        stub_sec = stub_sec->next)
4660     {
4661       bfd_size_type size;
4662
4663       /* Ignore non-stub sections.  */
4664       if (!strstr (stub_sec->name, STUB_SUFFIX))
4665         continue;
4666
4667       /* Allocate memory to hold the linker stubs.  */
4668       size = stub_sec->size;
4669       stub_sec->contents = bfd_zalloc (htab->stub_bfd, size);
4670       if (stub_sec->contents == NULL && size != 0)
4671         return FALSE;
4672       stub_sec->size = 0;
4673     }
4674
4675   /* Build the stubs as directed by the stub hash table.  */
4676   table = &htab->stub_hash_table;
4677   bfd_hash_traverse (table, arm_build_one_stub, info);
4678
4679   return TRUE;
4680 }
4681
4682 /* Locate the Thumb encoded calling stub for NAME.  */
4683
4684 static struct elf_link_hash_entry *
4685 find_thumb_glue (struct bfd_link_info *link_info,
4686                  const char *name,
4687                  char **error_message)
4688 {
4689   char *tmp_name;
4690   struct elf_link_hash_entry *hash;
4691   struct elf32_arm_link_hash_table *hash_table;
4692
4693   /* We need a pointer to the armelf specific hash table.  */
4694   hash_table = elf32_arm_hash_table (link_info);
4695
4696   tmp_name = bfd_malloc ((bfd_size_type) strlen (name)
4697                          + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1);
4698
4699   BFD_ASSERT (tmp_name);
4700
4701   sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name);
4702
4703   hash = elf_link_hash_lookup
4704     (&(hash_table)->root, tmp_name, FALSE, FALSE, TRUE);
4705
4706   if (hash == NULL
4707       && asprintf (error_message, _("unable to find THUMB glue '%s' for '%s'"),
4708                    tmp_name, name) == -1)
4709     *error_message = (char *) bfd_errmsg (bfd_error_system_call);
4710
4711   free (tmp_name);
4712
4713   return hash;
4714 }
4715
4716 /* Locate the ARM encoded calling stub for NAME.  */
4717
4718 static struct elf_link_hash_entry *
4719 find_arm_glue (struct bfd_link_info *link_info,
4720                const char *name,
4721                char **error_message)
4722 {
4723   char *tmp_name;
4724   struct elf_link_hash_entry *myh;
4725   struct elf32_arm_link_hash_table *hash_table;
4726
4727   /* We need a pointer to the elfarm specific hash table.  */
4728   hash_table = elf32_arm_hash_table (link_info);
4729
4730   tmp_name = bfd_malloc ((bfd_size_type) strlen (name)
4731                          + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1);
4732
4733   BFD_ASSERT (tmp_name);
4734
4735   sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
4736
4737   myh = elf_link_hash_lookup
4738     (&(hash_table)->root, tmp_name, FALSE, FALSE, TRUE);
4739
4740   if (myh == NULL
4741       && asprintf (error_message, _("unable to find ARM glue '%s' for '%s'"),
4742                    tmp_name, name) == -1)
4743     *error_message = (char *) bfd_errmsg (bfd_error_system_call);
4744
4745   free (tmp_name);
4746
4747   return myh;
4748 }
4749
4750 /* ARM->Thumb glue (static images):
4751
4752    .arm
4753    __func_from_arm:
4754    ldr r12, __func_addr
4755    bx  r12
4756    __func_addr:
4757    .word func    @ behave as if you saw a ARM_32 reloc.
4758
4759    (v5t static images)
4760    .arm
4761    __func_from_arm:
4762    ldr pc, __func_addr
4763    __func_addr:
4764    .word func    @ behave as if you saw a ARM_32 reloc.
4765
4766    (relocatable images)
4767    .arm
4768    __func_from_arm:
4769    ldr r12, __func_offset
4770    add r12, r12, pc
4771    bx  r12
4772    __func_offset:
4773    .word func - .   */
4774
4775 #define ARM2THUMB_STATIC_GLUE_SIZE 12
4776 static const insn32 a2t1_ldr_insn = 0xe59fc000;
4777 static const insn32 a2t2_bx_r12_insn = 0xe12fff1c;
4778 static const insn32 a2t3_func_addr_insn = 0x00000001;
4779
4780 #define ARM2THUMB_V5_STATIC_GLUE_SIZE 8
4781 static const insn32 a2t1v5_ldr_insn = 0xe51ff004;
4782 static const insn32 a2t2v5_func_addr_insn = 0x00000001;
4783
4784 #define ARM2THUMB_PIC_GLUE_SIZE 16
4785 static const insn32 a2t1p_ldr_insn = 0xe59fc004;
4786 static const insn32 a2t2p_add_pc_insn = 0xe08cc00f;
4787 static const insn32 a2t3p_bx_r12_insn = 0xe12fff1c;
4788
4789 /* Thumb->ARM:                          Thumb->(non-interworking aware) ARM
4790
4791      .thumb                             .thumb
4792      .align 2                           .align 2
4793  __func_from_thumb:                 __func_from_thumb:
4794      bx pc                              push {r6, lr}
4795      nop                                ldr  r6, __func_addr
4796      .arm                               mov  lr, pc
4797      b func                             bx   r6
4798                                         .arm
4799                                     ;; back_to_thumb
4800                                         ldmia r13! {r6, lr}
4801                                         bx    lr
4802                                     __func_addr:
4803                                         .word        func  */
4804
4805 #define THUMB2ARM_GLUE_SIZE 8
4806 static const insn16 t2a1_bx_pc_insn = 0x4778;
4807 static const insn16 t2a2_noop_insn = 0x46c0;
4808 static const insn32 t2a3_b_insn = 0xea000000;
4809
4810 #define VFP11_ERRATUM_VENEER_SIZE 8
4811
4812 #define ARM_BX_VENEER_SIZE 12
4813 static const insn32 armbx1_tst_insn = 0xe3100001;
4814 static const insn32 armbx2_moveq_insn = 0x01a0f000;
4815 static const insn32 armbx3_bx_insn = 0xe12fff10;
4816
4817 #ifndef ELFARM_NABI_C_INCLUDED
4818 static void
4819 arm_allocate_glue_section_space (bfd * abfd, bfd_size_type size, const char * name)
4820 {
4821   asection * s;
4822   bfd_byte * contents;
4823
4824   if (size == 0)
4825     {
4826       /* Do not include empty glue sections in the output.  */
4827       if (abfd != NULL)
4828         {
4829           s = bfd_get_section_by_name (abfd, name);
4830           if (s != NULL)
4831             s->flags |= SEC_EXCLUDE;
4832         }
4833       return;
4834     }
4835
4836   BFD_ASSERT (abfd != NULL);
4837
4838   s = bfd_get_section_by_name (abfd, name);
4839   BFD_ASSERT (s != NULL);
4840
4841   contents = bfd_alloc (abfd, size);
4842
4843   BFD_ASSERT (s->size == size);
4844   s->contents = contents;
4845 }
4846
4847 bfd_boolean
4848 bfd_elf32_arm_allocate_interworking_sections (struct bfd_link_info * info)
4849 {
4850   struct elf32_arm_link_hash_table * globals;
4851
4852   globals = elf32_arm_hash_table (info);
4853   BFD_ASSERT (globals != NULL);
4854
4855   arm_allocate_glue_section_space (globals->bfd_of_glue_owner,
4856                                    globals->arm_glue_size,
4857                                    ARM2THUMB_GLUE_SECTION_NAME);
4858
4859   arm_allocate_glue_section_space (globals->bfd_of_glue_owner,
4860                                    globals->thumb_glue_size,
4861                                    THUMB2ARM_GLUE_SECTION_NAME);
4862
4863   arm_allocate_glue_section_space (globals->bfd_of_glue_owner,
4864                                    globals->vfp11_erratum_glue_size,
4865                                    VFP11_ERRATUM_VENEER_SECTION_NAME);
4866
4867   arm_allocate_glue_section_space (globals->bfd_of_glue_owner,
4868                                    globals->bx_glue_size,
4869                                    ARM_BX_GLUE_SECTION_NAME);
4870
4871   return TRUE;
4872 }
4873
4874 /* Allocate space and symbols for calling a Thumb function from Arm mode.
4875    returns the symbol identifying the stub.  */
4876
4877 static struct elf_link_hash_entry *
4878 record_arm_to_thumb_glue (struct bfd_link_info * link_info,
4879                           struct elf_link_hash_entry * h)
4880 {
4881   const char * name = h->root.root.string;
4882   asection * s;
4883   char * tmp_name;
4884   struct elf_link_hash_entry * myh;
4885   struct bfd_link_hash_entry * bh;
4886   struct elf32_arm_link_hash_table * globals;
4887   bfd_vma val;
4888   bfd_size_type size;
4889
4890   globals = elf32_arm_hash_table (link_info);
4891
4892   BFD_ASSERT (globals != NULL);
4893   BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
4894
4895   s = bfd_get_section_by_name
4896     (globals->bfd_of_glue_owner, ARM2THUMB_GLUE_SECTION_NAME);
4897
4898   BFD_ASSERT (s != NULL);
4899
4900   tmp_name = bfd_malloc ((bfd_size_type) strlen (name) + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1);
4901
4902   BFD_ASSERT (tmp_name);
4903
4904   sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
4905
4906   myh = elf_link_hash_lookup
4907     (&(globals)->root, tmp_name, FALSE, FALSE, TRUE);
4908
4909   if (myh != NULL)
4910     {
4911       /* We've already seen this guy.  */
4912       free (tmp_name);
4913       return myh;
4914     }
4915
4916   /* The only trick here is using hash_table->arm_glue_size as the value.
4917      Even though the section isn't allocated yet, this is where we will be
4918      putting it.  The +1 on the value marks that the stub has not been
4919      output yet - not that it is a Thumb function.  */
4920   bh = NULL;
4921   val = globals->arm_glue_size + 1;
4922   _bfd_generic_link_add_one_symbol (link_info, globals->bfd_of_glue_owner,
4923                                     tmp_name, BSF_GLOBAL, s, val,
4924                                     NULL, TRUE, FALSE, &bh);
4925
4926   myh = (struct elf_link_hash_entry *) bh;
4927   myh->type = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
4928   myh->forced_local = 1;
4929
4930   free (tmp_name);
4931
4932   if (link_info->shared || globals->root.is_relocatable_executable
4933       || globals->pic_veneer)
4934     size = ARM2THUMB_PIC_GLUE_SIZE;
4935   else if (globals->use_blx)
4936     size = ARM2THUMB_V5_STATIC_GLUE_SIZE;
4937   else
4938     size = ARM2THUMB_STATIC_GLUE_SIZE;
4939
4940   s->size += size;
4941   globals->arm_glue_size += size;
4942
4943   return myh;
4944 }
4945
4946 /* Allocate space for ARMv4 BX veneers.  */
4947
4948 static void
4949 record_arm_bx_glue (struct bfd_link_info * link_info, int reg)
4950 {
4951   asection * s;
4952   struct elf32_arm_link_hash_table *globals;
4953   char *tmp_name;
4954   struct elf_link_hash_entry *myh;
4955   struct bfd_link_hash_entry *bh;
4956   bfd_vma val;
4957
4958   /* BX PC does not need a veneer.  */
4959   if (reg == 15)
4960     return;
4961
4962   globals = elf32_arm_hash_table (link_info);
4963
4964   BFD_ASSERT (globals != NULL);
4965   BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
4966
4967   /* Check if this veneer has already been allocated.  */
4968   if (globals->bx_glue_offset[reg])
4969     return;
4970
4971   s = bfd_get_section_by_name
4972     (globals->bfd_of_glue_owner, ARM_BX_GLUE_SECTION_NAME);
4973
4974   BFD_ASSERT (s != NULL);
4975
4976   /* Add symbol for veneer.  */
4977   tmp_name = bfd_malloc ((bfd_size_type) strlen (ARM_BX_GLUE_ENTRY_NAME) + 1);
4978
4979   BFD_ASSERT (tmp_name);
4980
4981   sprintf (tmp_name, ARM_BX_GLUE_ENTRY_NAME, reg);
4982
4983   myh = elf_link_hash_lookup
4984     (&(globals)->root, tmp_name, FALSE, FALSE, FALSE);
4985
4986   BFD_ASSERT (myh == NULL);
4987
4988   bh = NULL;
4989   val = globals->bx_glue_size;
4990   _bfd_generic_link_add_one_symbol (link_info, globals->bfd_of_glue_owner,
4991                                     tmp_name, BSF_FUNCTION | BSF_LOCAL, s, val,
4992                                     NULL, TRUE, FALSE, &bh);
4993
4994   myh = (struct elf_link_hash_entry *) bh;
4995   myh->type = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
4996   myh->forced_local = 1;
4997
4998   s->size += ARM_BX_VENEER_SIZE;
4999   globals->bx_glue_offset[reg] = globals->bx_glue_size | 2;
5000   globals->bx_glue_size += ARM_BX_VENEER_SIZE;
5001 }
5002
5003
5004 /* Add an entry to the code/data map for section SEC.  */
5005
5006 static void
5007 elf32_arm_section_map_add (asection *sec, char type, bfd_vma vma)
5008 {
5009   struct _arm_elf_section_data *sec_data = elf32_arm_section_data (sec);
5010   unsigned int newidx;
5011
5012   if (sec_data->map == NULL)
5013     {
5014       sec_data->map = bfd_malloc (sizeof (elf32_arm_section_map));
5015       sec_data->mapcount = 0;
5016       sec_data->mapsize = 1;
5017     }
5018
5019   newidx = sec_data->mapcount++;
5020
5021   if (sec_data->mapcount > sec_data->mapsize)
5022     {
5023       sec_data->mapsize *= 2;
5024       sec_data->map = bfd_realloc_or_free (sec_data->map, sec_data->mapsize
5025                                            * sizeof (elf32_arm_section_map));
5026     }
5027
5028   if (sec_data->map)
5029     {
5030       sec_data->map[newidx].vma = vma;
5031       sec_data->map[newidx].type = type;
5032     }
5033 }
5034
5035
5036 /* Record information about a VFP11 denorm-erratum veneer.  Only ARM-mode
5037    veneers are handled for now.  */
5038
5039 static bfd_vma
5040 record_vfp11_erratum_veneer (struct bfd_link_info *link_info,
5041                              elf32_vfp11_erratum_list *branch,
5042                              bfd *branch_bfd,
5043                              asection *branch_sec,
5044                              unsigned int offset)
5045 {
5046   asection *s;
5047   struct elf32_arm_link_hash_table *hash_table;
5048   char *tmp_name;
5049   struct elf_link_hash_entry *myh;
5050   struct bfd_link_hash_entry *bh;
5051   bfd_vma val;
5052   struct _arm_elf_section_data *sec_data;
5053   int errcount;
5054   elf32_vfp11_erratum_list *newerr;
5055
5056   hash_table = elf32_arm_hash_table (link_info);
5057
5058   BFD_ASSERT (hash_table != NULL);
5059   BFD_ASSERT (hash_table->bfd_of_glue_owner != NULL);
5060
5061   s = bfd_get_section_by_name
5062     (hash_table->bfd_of_glue_owner, VFP11_ERRATUM_VENEER_SECTION_NAME);
5063
5064   sec_data = elf32_arm_section_data (s);
5065
5066   BFD_ASSERT (s != NULL);
5067
5068   tmp_name = bfd_malloc ((bfd_size_type) strlen
5069                          (VFP11_ERRATUM_VENEER_ENTRY_NAME) + 10);
5070
5071   BFD_ASSERT (tmp_name);
5072
5073   sprintf (tmp_name, VFP11_ERRATUM_VENEER_ENTRY_NAME,
5074            hash_table->num_vfp11_fixes);
5075
5076   myh = elf_link_hash_lookup
5077     (&(hash_table)->root, tmp_name, FALSE, FALSE, FALSE);
5078
5079   BFD_ASSERT (myh == NULL);
5080
5081   bh = NULL;
5082   val = hash_table->vfp11_erratum_glue_size;
5083   _bfd_generic_link_add_one_symbol (link_info, hash_table->bfd_of_glue_owner,
5084                                     tmp_name, BSF_FUNCTION | BSF_LOCAL, s, val,
5085                                     NULL, TRUE, FALSE, &bh);
5086
5087   myh = (struct elf_link_hash_entry *) bh;
5088   myh->type = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
5089   myh->forced_local = 1;
5090
5091   /* Link veneer back to calling location.  */
5092   errcount = ++(sec_data->erratumcount);
5093   newerr = bfd_zmalloc (sizeof (elf32_vfp11_erratum_list));
5094
5095   newerr->type = VFP11_ERRATUM_ARM_VENEER;
5096   newerr->vma = -1;
5097   newerr->u.v.branch = branch;
5098   newerr->u.v.id = hash_table->num_vfp11_fixes;
5099   branch->u.b.veneer = newerr;
5100
5101   newerr->next = sec_data->erratumlist;
5102   sec_data->erratumlist = newerr;
5103
5104   /* A symbol for the return from the veneer.  */
5105   sprintf (tmp_name, VFP11_ERRATUM_VENEER_ENTRY_NAME "_r",
5106            hash_table->num_vfp11_fixes);
5107
5108   myh = elf_link_hash_lookup
5109     (&(hash_table)->root, tmp_name, FALSE, FALSE, FALSE);
5110
5111   if (myh != NULL)
5112     abort ();
5113
5114   bh = NULL;
5115   val = offset + 4;
5116   _bfd_generic_link_add_one_symbol (link_info, branch_bfd, tmp_name, BSF_LOCAL,
5117                                     branch_sec, val, NULL, TRUE, FALSE, &bh);
5118
5119   myh = (struct elf_link_hash_entry *) bh;
5120   myh->type = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
5121   myh->forced_local = 1;
5122
5123   free (tmp_name);
5124
5125   /* Generate a mapping symbol for the veneer section, and explicitly add an
5126      entry for that symbol to the code/data map for the section.  */
5127   if (hash_table->vfp11_erratum_glue_size == 0)
5128     {
5129       bh = NULL;
5130       /* FIXME: Creates an ARM symbol.  Thumb mode will need attention if it
5131          ever requires this erratum fix.  */
5132       _bfd_generic_link_add_one_symbol (link_info,
5133                                         hash_table->bfd_of_glue_owner, "$a",
5134                                         BSF_LOCAL, s, 0, NULL,
5135                                         TRUE, FALSE, &bh);
5136
5137       myh = (struct elf_link_hash_entry *) bh;
5138       myh->type = ELF_ST_INFO (STB_LOCAL, STT_NOTYPE);
5139       myh->forced_local = 1;
5140
5141       /* The elf32_arm_init_maps function only cares about symbols from input
5142          BFDs.  We must make a note of this generated mapping symbol
5143          ourselves so that code byteswapping works properly in
5144          elf32_arm_write_section.  */
5145       elf32_arm_section_map_add (s, 'a', 0);
5146     }
5147
5148   s->size += VFP11_ERRATUM_VENEER_SIZE;
5149   hash_table->vfp11_erratum_glue_size += VFP11_ERRATUM_VENEER_SIZE;
5150   hash_table->num_vfp11_fixes++;
5151
5152   /* The offset of the veneer.  */
5153   return val;
5154 }
5155
5156 #define ARM_GLUE_SECTION_FLAGS \
5157   (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_CODE \
5158    | SEC_READONLY | SEC_LINKER_CREATED)
5159
5160 /* Create a fake section for use by the ARM backend of the linker.  */
5161
5162 static bfd_boolean
5163 arm_make_glue_section (bfd * abfd, const char * name)
5164 {
5165   asection * sec;
5166
5167   sec = bfd_get_section_by_name (abfd, name);
5168   if (sec != NULL)
5169     /* Already made.  */
5170     return TRUE;
5171
5172   sec = bfd_make_section_with_flags (abfd, name, ARM_GLUE_SECTION_FLAGS);
5173
5174   if (sec == NULL
5175       || !bfd_set_section_alignment (abfd, sec, 2))
5176     return FALSE;
5177
5178   /* Set the gc mark to prevent the section from being removed by garbage
5179      collection, despite the fact that no relocs refer to this section.  */
5180   sec->gc_mark = 1;
5181
5182   return TRUE;
5183 }
5184
5185 /* Add the glue sections to ABFD.  This function is called from the
5186    linker scripts in ld/emultempl/{armelf}.em.  */
5187
5188 bfd_boolean
5189 bfd_elf32_arm_add_glue_sections_to_bfd (bfd *abfd,
5190                                         struct bfd_link_info *info)
5191 {
5192   /* If we are only performing a partial
5193      link do not bother adding the glue.  */
5194   if (info->relocatable)
5195     return TRUE;
5196
5197   return arm_make_glue_section (abfd, ARM2THUMB_GLUE_SECTION_NAME)
5198     && arm_make_glue_section (abfd, THUMB2ARM_GLUE_SECTION_NAME)
5199     && arm_make_glue_section (abfd, VFP11_ERRATUM_VENEER_SECTION_NAME)
5200     && arm_make_glue_section (abfd, ARM_BX_GLUE_SECTION_NAME);
5201 }
5202
5203 /* Select a BFD to be used to hold the sections used by the glue code.
5204    This function is called from the linker scripts in ld/emultempl/
5205    {armelf/pe}.em.  */
5206
5207 bfd_boolean
5208 bfd_elf32_arm_get_bfd_for_interworking (bfd *abfd, struct bfd_link_info *info)
5209 {
5210   struct elf32_arm_link_hash_table *globals;
5211
5212   /* If we are only performing a partial link
5213      do not bother getting a bfd to hold the glue.  */
5214   if (info->relocatable)
5215     return TRUE;
5216
5217   /* Make sure we don't attach the glue sections to a dynamic object.  */
5218   BFD_ASSERT (!(abfd->flags & DYNAMIC));
5219
5220   globals = elf32_arm_hash_table (info);
5221
5222   BFD_ASSERT (globals != NULL);
5223
5224   if (globals->bfd_of_glue_owner != NULL)
5225     return TRUE;
5226
5227   /* Save the bfd for later use.  */
5228   globals->bfd_of_glue_owner = abfd;
5229
5230   return TRUE;
5231 }
5232
5233 static void
5234 check_use_blx (struct elf32_arm_link_hash_table *globals)
5235 {
5236   if (bfd_elf_get_obj_attr_int (globals->obfd, OBJ_ATTR_PROC,
5237                                 Tag_CPU_arch) > 2)
5238     globals->use_blx = 1;
5239 }
5240
5241 bfd_boolean
5242 bfd_elf32_arm_process_before_allocation (bfd *abfd,
5243                                          struct bfd_link_info *link_info)
5244 {
5245   Elf_Internal_Shdr *symtab_hdr;
5246   Elf_Internal_Rela *internal_relocs = NULL;
5247   Elf_Internal_Rela *irel, *irelend;
5248   bfd_byte *contents = NULL;
5249
5250   asection *sec;
5251   struct elf32_arm_link_hash_table *globals;
5252
5253   /* If we are only performing a partial link do not bother
5254      to construct any glue.  */
5255   if (link_info->relocatable)
5256     return TRUE;
5257
5258   /* Here we have a bfd that is to be included on the link.  We have a
5259      hook to do reloc rummaging, before section sizes are nailed down.  */
5260   globals = elf32_arm_hash_table (link_info);
5261
5262   BFD_ASSERT (globals != NULL);
5263
5264   check_use_blx (globals);
5265
5266   if (globals->byteswap_code && !bfd_big_endian (abfd))
5267     {
5268       _bfd_error_handler (_("%B: BE8 images only valid in big-endian mode."),
5269                           abfd);
5270       return FALSE;
5271     }
5272
5273   /* PR 5398: If we have not decided to include any loadable sections in
5274      the output then we will not have a glue owner bfd.  This is OK, it
5275      just means that there is nothing else for us to do here.  */
5276   if (globals->bfd_of_glue_owner == NULL)
5277     return TRUE;
5278
5279   /* Rummage around all the relocs and map the glue vectors.  */
5280   sec = abfd->sections;
5281
5282   if (sec == NULL)
5283     return TRUE;
5284
5285   for (; sec != NULL; sec = sec->next)
5286     {
5287       if (sec->reloc_count == 0)
5288         continue;
5289
5290       if ((sec->flags & SEC_EXCLUDE) != 0)
5291         continue;
5292
5293       symtab_hdr = & elf_symtab_hdr (abfd);
5294
5295       /* Load the relocs.  */
5296       internal_relocs
5297         = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL, FALSE);
5298
5299       if (internal_relocs == NULL)
5300         goto error_return;
5301
5302       irelend = internal_relocs + sec->reloc_count;
5303       for (irel = internal_relocs; irel < irelend; irel++)
5304         {
5305           long r_type;
5306           unsigned long r_index;
5307
5308           struct elf_link_hash_entry *h;
5309
5310           r_type = ELF32_R_TYPE (irel->r_info);
5311           r_index = ELF32_R_SYM (irel->r_info);
5312
5313           /* These are the only relocation types we care about.  */
5314           if (   r_type != R_ARM_PC24
5315               && (r_type != R_ARM_V4BX || globals->fix_v4bx < 2))
5316             continue;
5317
5318           /* Get the section contents if we haven't done so already.  */
5319           if (contents == NULL)
5320             {
5321               /* Get cached copy if it exists.  */
5322               if (elf_section_data (sec)->this_hdr.contents != NULL)
5323                 contents = elf_section_data (sec)->this_hdr.contents;
5324               else
5325                 {
5326                   /* Go get them off disk.  */
5327                   if (! bfd_malloc_and_get_section (abfd, sec, &contents))
5328                     goto error_return;
5329                 }
5330             }
5331
5332           if (r_type == R_ARM_V4BX)
5333             {
5334               int reg;
5335
5336               reg = bfd_get_32 (abfd, contents + irel->r_offset) & 0xf;
5337               record_arm_bx_glue (link_info, reg);
5338               continue;
5339             }
5340
5341           /* If the relocation is not against a symbol it cannot concern us.  */
5342           h = NULL;
5343
5344           /* We don't care about local symbols.  */
5345           if (r_index < symtab_hdr->sh_info)
5346             continue;
5347
5348           /* This is an external symbol.  */
5349           r_index -= symtab_hdr->sh_info;
5350           h = (struct elf_link_hash_entry *)
5351             elf_sym_hashes (abfd)[r_index];
5352
5353           /* If the relocation is against a static symbol it must be within
5354              the current section and so cannot be a cross ARM/Thumb relocation.  */
5355           if (h == NULL)
5356             continue;
5357
5358           /* If the call will go through a PLT entry then we do not need
5359              glue.  */
5360           if (globals->splt != NULL && h->plt.offset != (bfd_vma) -1)
5361             continue;
5362
5363           switch (r_type)
5364             {
5365             case R_ARM_PC24:
5366               /* This one is a call from arm code.  We need to look up
5367                  the target of the call.  If it is a thumb target, we
5368                  insert glue.  */
5369               if (ELF_ST_TYPE (h->type) == STT_ARM_TFUNC)
5370                 record_arm_to_thumb_glue (link_info, h);
5371               break;
5372
5373             default:
5374               abort ();
5375             }
5376         }
5377
5378       if (contents != NULL
5379           && elf_section_data (sec)->this_hdr.contents != contents)
5380         free (contents);
5381       contents = NULL;
5382
5383       if (internal_relocs != NULL
5384           && elf_section_data (sec)->relocs != internal_relocs)
5385         free (internal_relocs);
5386       internal_relocs = NULL;
5387     }
5388
5389   return TRUE;
5390
5391 error_return:
5392   if (contents != NULL
5393       && elf_section_data (sec)->this_hdr.contents != contents)
5394     free (contents);
5395   if (internal_relocs != NULL
5396       && elf_section_data (sec)->relocs != internal_relocs)
5397     free (internal_relocs);
5398
5399   return FALSE;
5400 }
5401 #endif
5402
5403
5404 /* Initialise maps of ARM/Thumb/data for input BFDs.  */
5405
5406 void
5407 bfd_elf32_arm_init_maps (bfd *abfd)
5408 {
5409   Elf_Internal_Sym *isymbuf;
5410   Elf_Internal_Shdr *hdr;
5411   unsigned int i, localsyms;
5412
5413   /* PR 7093: Make sure that we are dealing with an arm elf binary.  */
5414   if (! is_arm_elf (abfd))
5415     return;
5416
5417   if ((abfd->flags & DYNAMIC) != 0)
5418     return;
5419
5420   hdr = & elf_symtab_hdr (abfd);
5421   localsyms = hdr->sh_info;
5422
5423   /* Obtain a buffer full of symbols for this BFD. The hdr->sh_info field
5424      should contain the number of local symbols, which should come before any
5425      global symbols.  Mapping symbols are always local.  */
5426   isymbuf = bfd_elf_get_elf_syms (abfd, hdr, localsyms, 0, NULL, NULL,
5427                                   NULL);
5428
5429   /* No internal symbols read?  Skip this BFD.  */
5430   if (isymbuf == NULL)
5431     return;
5432
5433   for (i = 0; i < localsyms; i++)
5434     {
5435       Elf_Internal_Sym *isym = &isymbuf[i];
5436       asection *sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
5437       const char *name;
5438
5439       if (sec != NULL
5440           && ELF_ST_BIND (isym->st_info) == STB_LOCAL)
5441         {
5442           name = bfd_elf_string_from_elf_section (abfd,
5443             hdr->sh_link, isym->st_name);
5444
5445           if (bfd_is_arm_special_symbol_name (name,
5446                                               BFD_ARM_SPECIAL_SYM_TYPE_MAP))
5447             elf32_arm_section_map_add (sec, name[1], isym->st_value);
5448         }
5449     }
5450 }
5451
5452
5453 /* Auto-select enabling of Cortex-A8 erratum fix if the user didn't explicitly
5454    say what they wanted.  */
5455
5456 void
5457 bfd_elf32_arm_set_cortex_a8_fix (bfd *obfd, struct bfd_link_info *link_info)
5458 {
5459   struct elf32_arm_link_hash_table *globals = elf32_arm_hash_table (link_info);
5460   obj_attribute *out_attr = elf_known_obj_attributes_proc (obfd);
5461
5462   if (globals->fix_cortex_a8 == -1)
5463     {
5464       /* Turn on Cortex-A8 erratum workaround for ARMv7-A.  */
5465       if (out_attr[Tag_CPU_arch].i == TAG_CPU_ARCH_V7
5466           && (out_attr[Tag_CPU_arch_profile].i == 'A'
5467               || out_attr[Tag_CPU_arch_profile].i == 0))
5468         globals->fix_cortex_a8 = 1;
5469       else
5470         globals->fix_cortex_a8 = 0;
5471     }
5472 }
5473
5474
5475 void
5476 bfd_elf32_arm_set_vfp11_fix (bfd *obfd, struct bfd_link_info *link_info)
5477 {
5478   struct elf32_arm_link_hash_table *globals = elf32_arm_hash_table (link_info);
5479   obj_attribute *out_attr = elf_known_obj_attributes_proc (obfd);
5480
5481   /* We assume that ARMv7+ does not need the VFP11 denorm erratum fix.  */
5482   if (out_attr[Tag_CPU_arch].i >= TAG_CPU_ARCH_V7)
5483     {
5484       switch (globals->vfp11_fix)
5485         {
5486         case BFD_ARM_VFP11_FIX_DEFAULT:
5487         case BFD_ARM_VFP11_FIX_NONE:
5488           globals->vfp11_fix = BFD_ARM_VFP11_FIX_NONE;
5489           break;
5490
5491         default:
5492           /* Give a warning, but do as the user requests anyway.  */
5493           (*_bfd_error_handler) (_("%B: warning: selected VFP11 erratum "
5494             "workaround is not necessary for target architecture"), obfd);
5495         }
5496     }
5497   else if (globals->vfp11_fix == BFD_ARM_VFP11_FIX_DEFAULT)
5498     /* For earlier architectures, we might need the workaround, but do not
5499        enable it by default.  If users is running with broken hardware, they
5500        must enable the erratum fix explicitly.  */
5501     globals->vfp11_fix = BFD_ARM_VFP11_FIX_NONE;
5502 }
5503
5504
5505 enum bfd_arm_vfp11_pipe
5506 {
5507   VFP11_FMAC,
5508   VFP11_LS,
5509   VFP11_DS,
5510   VFP11_BAD
5511 };
5512
5513 /* Return a VFP register number.  This is encoded as RX:X for single-precision
5514    registers, or X:RX for double-precision registers, where RX is the group of
5515    four bits in the instruction encoding and X is the single extension bit.
5516    RX and X fields are specified using their lowest (starting) bit.  The return
5517    value is:
5518
5519      0...31: single-precision registers s0...s31
5520      32...63: double-precision registers d0...d31.
5521
5522    Although X should be zero for VFP11 (encoding d0...d15 only), we might
5523    encounter VFP3 instructions, so we allow the full range for DP registers.  */
5524
5525 static unsigned int
5526 bfd_arm_vfp11_regno (unsigned int insn, bfd_boolean is_double, unsigned int rx,
5527                      unsigned int x)
5528 {
5529   if (is_double)
5530     return (((insn >> rx) & 0xf) | (((insn >> x) & 1) << 4)) + 32;
5531   else
5532     return (((insn >> rx) & 0xf) << 1) | ((insn >> x) & 1);
5533 }
5534
5535 /* Set bits in *WMASK according to a register number REG as encoded by
5536    bfd_arm_vfp11_regno().  Ignore d16-d31.  */
5537
5538 static void
5539 bfd_arm_vfp11_write_mask (unsigned int *wmask, unsigned int reg)
5540 {
5541   if (reg < 32)
5542     *wmask |= 1 << reg;
5543   else if (reg < 48)
5544     *wmask |= 3 << ((reg - 32) * 2);
5545 }
5546
5547 /* Return TRUE if WMASK overwrites anything in REGS.  */
5548
5549 static bfd_boolean
5550 bfd_arm_vfp11_antidependency (unsigned int wmask, int *regs, int numregs)
5551 {
5552   int i;
5553
5554   for (i = 0; i < numregs; i++)
5555     {
5556       unsigned int reg = regs[i];
5557
5558       if (reg < 32 && (wmask & (1 << reg)) != 0)
5559         return TRUE;
5560
5561       reg -= 32;
5562
5563       if (reg >= 16)
5564         continue;
5565
5566       if ((wmask & (3 << (reg * 2))) != 0)
5567         return TRUE;
5568     }
5569
5570   return FALSE;
5571 }
5572
5573 /* In this function, we're interested in two things: finding input registers
5574    for VFP data-processing instructions, and finding the set of registers which
5575    arbitrary VFP instructions may write to.  We use a 32-bit unsigned int to
5576    hold the written set, so FLDM etc. are easy to deal with (we're only
5577    interested in 32 SP registers or 16 dp registers, due to the VFP version
5578    implemented by the chip in question).  DP registers are marked by setting
5579    both SP registers in the write mask).  */
5580
5581 static enum bfd_arm_vfp11_pipe
5582 bfd_arm_vfp11_insn_decode (unsigned int insn, unsigned int *destmask, int *regs,
5583                            int *numregs)
5584 {
5585   enum bfd_arm_vfp11_pipe pipe = VFP11_BAD;
5586   bfd_boolean is_double = ((insn & 0xf00) == 0xb00) ? 1 : 0;
5587
5588   if ((insn & 0x0f000e10) == 0x0e000a00)  /* A data-processing insn.  */
5589     {
5590       unsigned int pqrs;
5591       unsigned int fd = bfd_arm_vfp11_regno (insn, is_double, 12, 22);
5592       unsigned int fm = bfd_arm_vfp11_regno (insn, is_double, 0, 5);
5593
5594       pqrs = ((insn & 0x00800000) >> 20)
5595            | ((insn & 0x00300000) >> 19)
5596            | ((insn & 0x00000040) >> 6);
5597
5598       switch (pqrs)
5599         {
5600         case 0: /* fmac[sd].  */
5601         case 1: /* fnmac[sd].  */
5602         case 2: /* fmsc[sd].  */
5603         case 3: /* fnmsc[sd].  */
5604           pipe = VFP11_FMAC;
5605           bfd_arm_vfp11_write_mask (destmask, fd);
5606           regs[0] = fd;
5607           regs[1] = bfd_arm_vfp11_regno (insn, is_double, 16, 7);  /* Fn.  */
5608           regs[2] = fm;
5609           *numregs = 3;
5610           break;
5611
5612         case 4: /* fmul[sd].  */
5613         case 5: /* fnmul[sd].  */
5614         case 6: /* fadd[sd].  */
5615         case 7: /* fsub[sd].  */
5616           pipe = VFP11_FMAC;
5617           goto vfp_binop;
5618
5619         case 8: /* fdiv[sd].  */
5620           pipe = VFP11_DS;
5621           vfp_binop:
5622           bfd_arm_vfp11_write_mask (destmask, fd);
5623           regs[0] = bfd_arm_vfp11_regno (insn, is_double, 16, 7);   /* Fn.  */
5624           regs[1] = fm;
5625           *numregs = 2;
5626           break;
5627
5628         case 15: /* extended opcode.  */
5629           {
5630             unsigned int extn = ((insn >> 15) & 0x1e)
5631                               | ((insn >> 7) & 1);
5632
5633             switch (extn)
5634               {
5635               case 0: /* fcpy[sd].  */
5636               case 1: /* fabs[sd].  */
5637               case 2: /* fneg[sd].  */
5638               case 8: /* fcmp[sd].  */
5639               case 9: /* fcmpe[sd].  */
5640               case 10: /* fcmpz[sd].  */
5641               case 11: /* fcmpez[sd].  */
5642               case 16: /* fuito[sd].  */
5643               case 17: /* fsito[sd].  */
5644               case 24: /* ftoui[sd].  */
5645               case 25: /* ftouiz[sd].  */
5646               case 26: /* ftosi[sd].  */
5647               case 27: /* ftosiz[sd].  */
5648                 /* These instructions will not bounce due to underflow.  */
5649                 *numregs = 0;
5650                 pipe = VFP11_FMAC;
5651                 break;
5652
5653               case 3: /* fsqrt[sd].  */
5654                 /* fsqrt cannot underflow, but it can (perhaps) overwrite
5655                    registers to cause the erratum in previous instructions.  */
5656                 bfd_arm_vfp11_write_mask (destmask, fd);
5657                 pipe = VFP11_DS;
5658                 break;
5659
5660               case 15: /* fcvt{ds,sd}.  */
5661                 {
5662                   int rnum = 0;
5663
5664                   bfd_arm_vfp11_write_mask (destmask, fd);
5665
5666                   /* Only FCVTSD can underflow.  */
5667                   if ((insn & 0x100) != 0)
5668                     regs[rnum++] = fm;
5669
5670                   *numregs = rnum;
5671
5672                   pipe = VFP11_FMAC;
5673                 }
5674                 break;
5675
5676               default:
5677                 return VFP11_BAD;
5678               }
5679           }
5680           break;
5681
5682         default:
5683           return VFP11_BAD;
5684         }
5685     }
5686   /* Two-register transfer.  */
5687   else if ((insn & 0x0fe00ed0) == 0x0c400a10)
5688     {
5689       unsigned int fm = bfd_arm_vfp11_regno (insn, is_double, 0, 5);
5690
5691       if ((insn & 0x100000) == 0)
5692         {
5693           if (is_double)
5694             bfd_arm_vfp11_write_mask (destmask, fm);
5695           else
5696             {
5697               bfd_arm_vfp11_write_mask (destmask, fm);
5698               bfd_arm_vfp11_write_mask (destmask, fm + 1);
5699             }
5700         }
5701
5702       pipe = VFP11_LS;
5703     }
5704   else if ((insn & 0x0e100e00) == 0x0c100a00)  /* A load insn.  */
5705     {
5706       int fd = bfd_arm_vfp11_regno (insn, is_double, 12, 22);
5707       unsigned int puw = ((insn >> 21) & 0x1) | (((insn >> 23) & 3) << 1);
5708
5709       switch (puw)
5710         {
5711         case 0: /* Two-reg transfer.  We should catch these above.  */
5712           abort ();
5713
5714         case 2: /* fldm[sdx].  */
5715         case 3:
5716         case 5:
5717           {
5718             unsigned int i, offset = insn & 0xff;
5719
5720             if (is_double)
5721               offset >>= 1;
5722
5723             for (i = fd; i < fd + offset; i++)
5724               bfd_arm_vfp11_write_mask (destmask, i);
5725           }
5726           break;
5727
5728         case 4: /* fld[sd].  */
5729         case 6:
5730           bfd_arm_vfp11_write_mask (destmask, fd);
5731           break;
5732
5733         default:
5734           return VFP11_BAD;
5735         }
5736
5737       pipe = VFP11_LS;
5738     }
5739   /* Single-register transfer. Note L==0.  */
5740   else if ((insn & 0x0f100e10) == 0x0e000a10)
5741     {
5742       unsigned int opcode = (insn >> 21) & 7;
5743       unsigned int fn = bfd_arm_vfp11_regno (insn, is_double, 16, 7);
5744
5745       switch (opcode)
5746         {
5747         case 0: /* fmsr/fmdlr.  */
5748         case 1: /* fmdhr.  */
5749           /* Mark fmdhr and fmdlr as writing to the whole of the DP
5750              destination register.  I don't know if this is exactly right,
5751              but it is the conservative choice.  */
5752           bfd_arm_vfp11_write_mask (destmask, fn);
5753           break;
5754
5755         case 7: /* fmxr.  */
5756           break;
5757         }
5758
5759       pipe = VFP11_LS;
5760     }
5761
5762   return pipe;
5763 }
5764
5765
5766 static int elf32_arm_compare_mapping (const void * a, const void * b);
5767
5768
5769 /* Look for potentially-troublesome code sequences which might trigger the
5770    VFP11 denormal/antidependency erratum.  See, e.g., the ARM1136 errata sheet
5771    (available from ARM) for details of the erratum.  A short version is
5772    described in ld.texinfo.  */
5773
5774 bfd_boolean
5775 bfd_elf32_arm_vfp11_erratum_scan (bfd *abfd, struct bfd_link_info *link_info)
5776 {
5777   asection *sec;
5778   bfd_byte *contents = NULL;
5779   int state = 0;
5780   int regs[3], numregs = 0;
5781   struct elf32_arm_link_hash_table *globals = elf32_arm_hash_table (link_info);
5782   int use_vector = (globals->vfp11_fix == BFD_ARM_VFP11_FIX_VECTOR);
5783
5784   /* We use a simple FSM to match troublesome VFP11 instruction sequences.
5785      The states transition as follows:
5786
5787        0 -> 1 (vector) or 0 -> 2 (scalar)
5788            A VFP FMAC-pipeline instruction has been seen. Fill
5789            regs[0]..regs[numregs-1] with its input operands. Remember this
5790            instruction in 'first_fmac'.
5791
5792        1 -> 2
5793            Any instruction, except for a VFP instruction which overwrites
5794            regs[*].
5795
5796        1 -> 3 [ -> 0 ]  or
5797        2 -> 3 [ -> 0 ]
5798            A VFP instruction has been seen which overwrites any of regs[*].
5799            We must make a veneer!  Reset state to 0 before examining next
5800            instruction.
5801
5802        2 -> 0
5803            If we fail to match anything in state 2, reset to state 0 and reset
5804            the instruction pointer to the instruction after 'first_fmac'.
5805
5806      If the VFP11 vector mode is in use, there must be at least two unrelated
5807      instructions between anti-dependent VFP11 instructions to properly avoid
5808      triggering the erratum, hence the use of the extra state 1.  */
5809
5810   /* If we are only performing a partial link do not bother
5811      to construct any glue.  */
5812   if (link_info->relocatable)
5813     return TRUE;
5814
5815   /* Skip if this bfd does not correspond to an ELF image.  */
5816   if (! is_arm_elf (abfd))
5817     return TRUE;
5818
5819   /* We should have chosen a fix type by the time we get here.  */
5820   BFD_ASSERT (globals->vfp11_fix != BFD_ARM_VFP11_FIX_DEFAULT);
5821
5822   if (globals->vfp11_fix == BFD_ARM_VFP11_FIX_NONE)
5823     return TRUE;
5824
5825   /* Skip this BFD if it corresponds to an executable or dynamic object.  */
5826   if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
5827     return TRUE;
5828
5829   for (sec = abfd->sections; sec != NULL; sec = sec->next)
5830     {
5831       unsigned int i, span, first_fmac = 0, veneer_of_insn = 0;
5832       struct _arm_elf_section_data *sec_data;
5833
5834       /* If we don't have executable progbits, we're not interested in this
5835          section.  Also skip if section is to be excluded.  */
5836       if (elf_section_type (sec) != SHT_PROGBITS
5837           || (elf_section_flags (sec) & SHF_EXECINSTR) == 0
5838           || (sec->flags & SEC_EXCLUDE) != 0
5839           || sec->sec_info_type == ELF_INFO_TYPE_JUST_SYMS
5840           || sec->output_section == bfd_abs_section_ptr
5841           || strcmp (sec->name, VFP11_ERRATUM_VENEER_SECTION_NAME) == 0)
5842         continue;
5843
5844       sec_data = elf32_arm_section_data (sec);
5845
5846       if (sec_data->mapcount == 0)
5847         continue;
5848
5849       if (elf_section_data (sec)->this_hdr.contents != NULL)
5850         contents = elf_section_data (sec)->this_hdr.contents;
5851       else if (! bfd_malloc_and_get_section (abfd, sec, &contents))
5852         goto error_return;
5853
5854       qsort (sec_data->map, sec_data->mapcount, sizeof (elf32_arm_section_map),
5855              elf32_arm_compare_mapping);
5856
5857       for (span = 0; span < sec_data->mapcount; span++)
5858         {
5859           unsigned int span_start = sec_data->map[span].vma;
5860           unsigned int span_end = (span == sec_data->mapcount - 1)
5861                                   ? sec->size : sec_data->map[span + 1].vma;
5862           char span_type = sec_data->map[span].type;
5863
5864           /* FIXME: Only ARM mode is supported at present.  We may need to
5865              support Thumb-2 mode also at some point.  */
5866           if (span_type != 'a')
5867             continue;
5868
5869           for (i = span_start; i < span_end;)
5870             {
5871               unsigned int next_i = i + 4;
5872               unsigned int insn = bfd_big_endian (abfd)
5873                 ? (contents[i] << 24)
5874                   | (contents[i + 1] << 16)
5875                   | (contents[i + 2] << 8)
5876                   | contents[i + 3]
5877                 : (contents[i + 3] << 24)
5878                   | (contents[i + 2] << 16)
5879                   | (contents[i + 1] << 8)
5880                   | contents[i];
5881               unsigned int writemask = 0;
5882               enum bfd_arm_vfp11_pipe pipe;
5883
5884               switch (state)
5885                 {
5886                 case 0:
5887                   pipe = bfd_arm_vfp11_insn_decode (insn, &writemask, regs,
5888                                                     &numregs);
5889                   /* I'm assuming the VFP11 erratum can trigger with denorm
5890                      operands on either the FMAC or the DS pipeline. This might
5891                      lead to slightly overenthusiastic veneer insertion.  */
5892                   if (pipe == VFP11_FMAC || pipe == VFP11_DS)
5893                     {
5894                       state = use_vector ? 1 : 2;
5895                       first_fmac = i;
5896                       veneer_of_insn = insn;
5897                     }
5898                   break;
5899
5900                 case 1:
5901                   {
5902                     int other_regs[3], other_numregs;
5903                     pipe = bfd_arm_vfp11_insn_decode (insn, &writemask,
5904                                                       other_regs,
5905                                                       &other_numregs);
5906                     if (pipe != VFP11_BAD
5907                         && bfd_arm_vfp11_antidependency (writemask, regs,
5908                                                          numregs))
5909                       state = 3;
5910                     else
5911                       state = 2;
5912                   }
5913                   break;
5914
5915                 case 2:
5916                   {
5917                     int other_regs[3], other_numregs;
5918                     pipe = bfd_arm_vfp11_insn_decode (insn, &writemask,
5919                                                       other_regs,
5920                                                       &other_numregs);
5921                     if (pipe != VFP11_BAD
5922                         && bfd_arm_vfp11_antidependency (writemask, regs,
5923                                                          numregs))
5924                       state = 3;
5925                     else
5926                       {
5927                         state = 0;
5928                         next_i = first_fmac + 4;
5929                       }
5930                   }
5931                   break;
5932
5933                 case 3:
5934                   abort ();  /* Should be unreachable.  */
5935                 }
5936
5937               if (state == 3)
5938                 {
5939                   elf32_vfp11_erratum_list *newerr
5940                     = bfd_zmalloc (sizeof (elf32_vfp11_erratum_list));
5941                   int errcount;
5942
5943                   errcount = ++(elf32_arm_section_data (sec)->erratumcount);
5944
5945                   newerr->u.b.vfp_insn = veneer_of_insn;
5946
5947                   switch (span_type)
5948                     {
5949                     case 'a':
5950                       newerr->type = VFP11_ERRATUM_BRANCH_TO_ARM_VENEER;
5951                       break;
5952
5953                     default:
5954                       abort ();
5955                     }
5956
5957                   record_vfp11_erratum_veneer (link_info, newerr, abfd, sec,
5958                                                first_fmac);
5959
5960                   newerr->vma = -1;
5961
5962                   newerr->next = sec_data->erratumlist;
5963                   sec_data->erratumlist = newerr;
5964
5965                   state = 0;
5966                 }
5967
5968               i = next_i;
5969             }
5970         }
5971
5972       if (contents != NULL
5973           && elf_section_data (sec)->this_hdr.contents != contents)
5974         free (contents);
5975       contents = NULL;
5976     }
5977
5978   return TRUE;
5979
5980 error_return:
5981   if (contents != NULL
5982       && elf_section_data (sec)->this_hdr.contents != contents)
5983     free (contents);
5984
5985   return FALSE;
5986 }
5987
5988 /* Find virtual-memory addresses for VFP11 erratum veneers and return locations
5989    after sections have been laid out, using specially-named symbols.  */
5990
5991 void
5992 bfd_elf32_arm_vfp11_fix_veneer_locations (bfd *abfd,
5993                                           struct bfd_link_info *link_info)
5994 {
5995   asection *sec;
5996   struct elf32_arm_link_hash_table *globals;
5997   char *tmp_name;
5998
5999   if (link_info->relocatable)
6000     return;
6001
6002   /* Skip if this bfd does not correspond to an ELF image.  */
6003   if (! is_arm_elf (abfd))
6004     return;
6005
6006   globals = elf32_arm_hash_table (link_info);
6007
6008   tmp_name = bfd_malloc ((bfd_size_type) strlen
6009                            (VFP11_ERRATUM_VENEER_ENTRY_NAME) + 10);
6010
6011   for (sec = abfd->sections; sec != NULL; sec = sec->next)
6012     {
6013       struct _arm_elf_section_data *sec_data = elf32_arm_section_data (sec);
6014       elf32_vfp11_erratum_list *errnode = sec_data->erratumlist;
6015
6016       for (; errnode != NULL; errnode = errnode->next)
6017         {
6018           struct elf_link_hash_entry *myh;
6019           bfd_vma vma;
6020
6021           switch (errnode->type)
6022             {
6023             case VFP11_ERRATUM_BRANCH_TO_ARM_VENEER:
6024             case VFP11_ERRATUM_BRANCH_TO_THUMB_VENEER:
6025               /* Find veneer symbol.  */
6026               sprintf (tmp_name, VFP11_ERRATUM_VENEER_ENTRY_NAME,
6027                        errnode->u.b.veneer->u.v.id);
6028
6029               myh = elf_link_hash_lookup
6030                 (&(globals)->root, tmp_name, FALSE, FALSE, TRUE);
6031
6032               if (myh == NULL)
6033                 (*_bfd_error_handler) (_("%B: unable to find VFP11 veneer "
6034                                          "`%s'"), abfd, tmp_name);
6035
6036               vma = myh->root.u.def.section->output_section->vma
6037                     + myh->root.u.def.section->output_offset
6038                     + myh->root.u.def.value;
6039
6040               errnode->u.b.veneer->vma = vma;
6041               break;
6042
6043             case VFP11_ERRATUM_ARM_VENEER:
6044             case VFP11_ERRATUM_THUMB_VENEER:
6045               /* Find return location.  */
6046               sprintf (tmp_name, VFP11_ERRATUM_VENEER_ENTRY_NAME "_r",
6047                        errnode->u.v.id);
6048
6049               myh = elf_link_hash_lookup
6050                 (&(globals)->root, tmp_name, FALSE, FALSE, TRUE);
6051
6052               if (myh == NULL)
6053                 (*_bfd_error_handler) (_("%B: unable to find VFP11 veneer "
6054                                          "`%s'"), abfd, tmp_name);
6055
6056               vma = myh->root.u.def.section->output_section->vma
6057                     + myh->root.u.def.section->output_offset
6058                     + myh->root.u.def.value;
6059
6060               errnode->u.v.branch->vma = vma;
6061               break;
6062
6063             default:
6064               abort ();
6065             }
6066         }
6067     }
6068
6069   free (tmp_name);
6070 }
6071
6072
6073 /* Set target relocation values needed during linking.  */
6074
6075 void
6076 bfd_elf32_arm_set_target_relocs (struct bfd *output_bfd,
6077                                  struct bfd_link_info *link_info,
6078                                  int target1_is_rel,
6079                                  char * target2_type,
6080                                  int fix_v4bx,
6081                                  int use_blx,
6082                                  bfd_arm_vfp11_fix vfp11_fix,
6083                                  int no_enum_warn, int no_wchar_warn,
6084                                  int pic_veneer, int fix_cortex_a8)
6085 {
6086   struct elf32_arm_link_hash_table *globals;
6087
6088   globals = elf32_arm_hash_table (link_info);
6089
6090   globals->target1_is_rel = target1_is_rel;
6091   if (strcmp (target2_type, "rel") == 0)
6092     globals->target2_reloc = R_ARM_REL32;
6093   else if (strcmp (target2_type, "abs") == 0)
6094     globals->target2_reloc = R_ARM_ABS32;
6095   else if (strcmp (target2_type, "got-rel") == 0)
6096     globals->target2_reloc = R_ARM_GOT_PREL;
6097   else
6098     {
6099       _bfd_error_handler (_("Invalid TARGET2 relocation type '%s'."),
6100                           target2_type);
6101     }
6102   globals->fix_v4bx = fix_v4bx;
6103   globals->use_blx |= use_blx;
6104   globals->vfp11_fix = vfp11_fix;
6105   globals->pic_veneer = pic_veneer;
6106   globals->fix_cortex_a8 = fix_cortex_a8;
6107
6108   BFD_ASSERT (is_arm_elf (output_bfd));
6109   elf_arm_tdata (output_bfd)->no_enum_size_warning = no_enum_warn;
6110   elf_arm_tdata (output_bfd)->no_wchar_size_warning = no_wchar_warn;
6111 }
6112
6113 /* Replace the target offset of a Thumb bl or b.w instruction.  */
6114
6115 static void
6116 insert_thumb_branch (bfd *abfd, long int offset, bfd_byte *insn)
6117 {
6118   bfd_vma upper;
6119   bfd_vma lower;
6120   int reloc_sign;
6121
6122   BFD_ASSERT ((offset & 1) == 0);
6123
6124   upper = bfd_get_16 (abfd, insn);
6125   lower = bfd_get_16 (abfd, insn + 2);
6126   reloc_sign = (offset < 0) ? 1 : 0;
6127   upper = (upper & ~(bfd_vma) 0x7ff)
6128           | ((offset >> 12) & 0x3ff)
6129           | (reloc_sign << 10);
6130   lower = (lower & ~(bfd_vma) 0x2fff)
6131           | (((!((offset >> 23) & 1)) ^ reloc_sign) << 13)
6132           | (((!((offset >> 22) & 1)) ^ reloc_sign) << 11)
6133           | ((offset >> 1) & 0x7ff);
6134   bfd_put_16 (abfd, upper, insn);
6135   bfd_put_16 (abfd, lower, insn + 2);
6136 }
6137
6138 /* Thumb code calling an ARM function.  */
6139
6140 static int
6141 elf32_thumb_to_arm_stub (struct bfd_link_info * info,
6142                          const char *           name,
6143                          bfd *                  input_bfd,
6144                          bfd *                  output_bfd,
6145                          asection *             input_section,
6146                          bfd_byte *             hit_data,
6147                          asection *             sym_sec,
6148                          bfd_vma                offset,
6149                          bfd_signed_vma         addend,
6150                          bfd_vma                val,
6151                          char **error_message)
6152 {
6153   asection * s = 0;
6154   bfd_vma my_offset;
6155   long int ret_offset;
6156   struct elf_link_hash_entry * myh;
6157   struct elf32_arm_link_hash_table * globals;
6158
6159   myh = find_thumb_glue (info, name, error_message);
6160   if (myh == NULL)
6161     return FALSE;
6162
6163   globals = elf32_arm_hash_table (info);
6164
6165   BFD_ASSERT (globals != NULL);
6166   BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
6167
6168   my_offset = myh->root.u.def.value;
6169
6170   s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
6171                                THUMB2ARM_GLUE_SECTION_NAME);
6172
6173   BFD_ASSERT (s != NULL);
6174   BFD_ASSERT (s->contents != NULL);
6175   BFD_ASSERT (s->output_section != NULL);
6176
6177   if ((my_offset & 0x01) == 0x01)
6178     {
6179       if (sym_sec != NULL
6180           && sym_sec->owner != NULL
6181           && !INTERWORK_FLAG (sym_sec->owner))
6182         {
6183           (*_bfd_error_handler)
6184             (_("%B(%s): warning: interworking not enabled.\n"
6185                "  first occurrence: %B: thumb call to arm"),
6186              sym_sec->owner, input_bfd, name);
6187
6188           return FALSE;
6189         }
6190
6191       --my_offset;
6192       myh->root.u.def.value = my_offset;
6193
6194       put_thumb_insn (globals, output_bfd, (bfd_vma) t2a1_bx_pc_insn,
6195                       s->contents + my_offset);
6196
6197       put_thumb_insn (globals, output_bfd, (bfd_vma) t2a2_noop_insn,
6198                       s->contents + my_offset + 2);
6199
6200       ret_offset =
6201         /* Address of destination of the stub.  */
6202         ((bfd_signed_vma) val)
6203         - ((bfd_signed_vma)
6204            /* Offset from the start of the current section
6205               to the start of the stubs.  */
6206            (s->output_offset
6207             /* Offset of the start of this stub from the start of the stubs.  */
6208             + my_offset
6209             /* Address of the start of the current section.  */
6210             + s->output_section->vma)
6211            /* The branch instruction is 4 bytes into the stub.  */
6212            + 4
6213            /* ARM branches work from the pc of the instruction + 8.  */
6214            + 8);
6215
6216       put_arm_insn (globals, output_bfd,
6217                     (bfd_vma) t2a3_b_insn | ((ret_offset >> 2) & 0x00FFFFFF),
6218                     s->contents + my_offset + 4);
6219     }
6220
6221   BFD_ASSERT (my_offset <= globals->thumb_glue_size);
6222
6223   /* Now go back and fix up the original BL insn to point to here.  */
6224   ret_offset =
6225     /* Address of where the stub is located.  */
6226     (s->output_section->vma + s->output_offset + my_offset)
6227      /* Address of where the BL is located.  */
6228     - (input_section->output_section->vma + input_section->output_offset
6229        + offset)
6230     /* Addend in the relocation.  */
6231     - addend
6232     /* Biassing for PC-relative addressing.  */
6233     - 8;
6234
6235   insert_thumb_branch (input_bfd, ret_offset, hit_data - input_section->vma);
6236
6237   return TRUE;
6238 }
6239
6240 /* Populate an Arm to Thumb stub.  Returns the stub symbol.  */
6241
6242 static struct elf_link_hash_entry *
6243 elf32_arm_create_thumb_stub (struct bfd_link_info * info,
6244                              const char *           name,
6245                              bfd *                  input_bfd,
6246                              bfd *                  output_bfd,
6247                              asection *             sym_sec,
6248                              bfd_vma                val,
6249                              asection *             s,
6250                              char **                error_message)
6251 {
6252   bfd_vma my_offset;
6253   long int ret_offset;
6254   struct elf_link_hash_entry * myh;
6255   struct elf32_arm_link_hash_table * globals;
6256
6257   myh = find_arm_glue (info, name, error_message);
6258   if (myh == NULL)
6259     return NULL;
6260
6261   globals = elf32_arm_hash_table (info);
6262
6263   BFD_ASSERT (globals != NULL);
6264   BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
6265
6266   my_offset = myh->root.u.def.value;
6267
6268   if ((my_offset & 0x01) == 0x01)
6269     {
6270       if (sym_sec != NULL
6271           && sym_sec->owner != NULL
6272           && !INTERWORK_FLAG (sym_sec->owner))
6273         {
6274           (*_bfd_error_handler)
6275             (_("%B(%s): warning: interworking not enabled.\n"
6276                "  first occurrence: %B: arm call to thumb"),
6277              sym_sec->owner, input_bfd, name);
6278         }
6279
6280       --my_offset;
6281       myh->root.u.def.value = my_offset;
6282
6283       if (info->shared || globals->root.is_relocatable_executable
6284           || globals->pic_veneer)
6285         {
6286           /* For relocatable objects we can't use absolute addresses,
6287              so construct the address from a relative offset.  */
6288           /* TODO: If the offset is small it's probably worth
6289              constructing the address with adds.  */
6290           put_arm_insn (globals, output_bfd, (bfd_vma) a2t1p_ldr_insn,
6291                         s->contents + my_offset);
6292           put_arm_insn (globals, output_bfd, (bfd_vma) a2t2p_add_pc_insn,
6293                         s->contents + my_offset + 4);
6294           put_arm_insn (globals, output_bfd, (bfd_vma) a2t3p_bx_r12_insn,
6295                         s->contents + my_offset + 8);
6296           /* Adjust the offset by 4 for the position of the add,
6297              and 8 for the pipeline offset.  */
6298           ret_offset = (val - (s->output_offset
6299                                + s->output_section->vma
6300                                + my_offset + 12))
6301                        | 1;
6302           bfd_put_32 (output_bfd, ret_offset,
6303                       s->contents + my_offset + 12);
6304         }
6305       else if (globals->use_blx)
6306         {
6307           put_arm_insn (globals, output_bfd, (bfd_vma) a2t1v5_ldr_insn,
6308                         s->contents + my_offset);
6309
6310           /* It's a thumb address.  Add the low order bit.  */
6311           bfd_put_32 (output_bfd, val | a2t2v5_func_addr_insn,
6312                       s->contents + my_offset + 4);
6313         }
6314       else
6315         {
6316           put_arm_insn (globals, output_bfd, (bfd_vma) a2t1_ldr_insn,
6317                         s->contents + my_offset);
6318
6319           put_arm_insn (globals, output_bfd, (bfd_vma) a2t2_bx_r12_insn,
6320                         s->contents + my_offset + 4);
6321
6322           /* It's a thumb address.  Add the low order bit.  */
6323           bfd_put_32 (output_bfd, val | a2t3_func_addr_insn,
6324                       s->contents + my_offset + 8);
6325
6326           my_offset += 12;
6327         }
6328     }
6329
6330   BFD_ASSERT (my_offset <= globals->arm_glue_size);
6331
6332   return myh;
6333 }
6334
6335 /* Arm code calling a Thumb function.  */
6336
6337 static int
6338 elf32_arm_to_thumb_stub (struct bfd_link_info * info,
6339                          const char *           name,
6340                          bfd *                  input_bfd,
6341                          bfd *                  output_bfd,
6342                          asection *             input_section,
6343                          bfd_byte *             hit_data,
6344                          asection *             sym_sec,
6345                          bfd_vma                offset,
6346                          bfd_signed_vma         addend,
6347                          bfd_vma                val,
6348                          char **error_message)
6349 {
6350   unsigned long int tmp;
6351   bfd_vma my_offset;
6352   asection * s;
6353   long int ret_offset;
6354   struct elf_link_hash_entry * myh;
6355   struct elf32_arm_link_hash_table * globals;
6356
6357   globals = elf32_arm_hash_table (info);
6358
6359   BFD_ASSERT (globals != NULL);
6360   BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
6361
6362   s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
6363                                ARM2THUMB_GLUE_SECTION_NAME);
6364   BFD_ASSERT (s != NULL);
6365   BFD_ASSERT (s->contents != NULL);
6366   BFD_ASSERT (s->output_section != NULL);
6367
6368   myh = elf32_arm_create_thumb_stub (info, name, input_bfd, output_bfd,
6369                                      sym_sec, val, s, error_message);
6370   if (!myh)
6371     return FALSE;
6372
6373   my_offset = myh->root.u.def.value;
6374   tmp = bfd_get_32 (input_bfd, hit_data);
6375   tmp = tmp & 0xFF000000;
6376
6377   /* Somehow these are both 4 too far, so subtract 8.  */
6378   ret_offset = (s->output_offset
6379                 + my_offset
6380                 + s->output_section->vma
6381                 - (input_section->output_offset
6382                    + input_section->output_section->vma
6383                    + offset + addend)
6384                 - 8);
6385
6386   tmp = tmp | ((ret_offset >> 2) & 0x00FFFFFF);
6387
6388   bfd_put_32 (output_bfd, (bfd_vma) tmp, hit_data - input_section->vma);
6389
6390   return TRUE;
6391 }
6392
6393 /* Populate Arm stub for an exported Thumb function.  */
6394
6395 static bfd_boolean
6396 elf32_arm_to_thumb_export_stub (struct elf_link_hash_entry *h, void * inf)
6397 {
6398   struct bfd_link_info * info = (struct bfd_link_info *) inf;
6399   asection * s;
6400   struct elf_link_hash_entry * myh;
6401   struct elf32_arm_link_hash_entry *eh;
6402   struct elf32_arm_link_hash_table * globals;
6403   asection *sec;
6404   bfd_vma val;
6405   char *error_message;
6406
6407   eh = elf32_arm_hash_entry (h);
6408   /* Allocate stubs for exported Thumb functions on v4t.  */
6409   if (eh->export_glue == NULL)
6410     return TRUE;
6411
6412   globals = elf32_arm_hash_table (info);
6413
6414   BFD_ASSERT (globals != NULL);
6415   BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
6416
6417   s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
6418                                ARM2THUMB_GLUE_SECTION_NAME);
6419   BFD_ASSERT (s != NULL);
6420   BFD_ASSERT (s->contents != NULL);
6421   BFD_ASSERT (s->output_section != NULL);
6422
6423   sec = eh->export_glue->root.u.def.section;
6424
6425   BFD_ASSERT (sec->output_section != NULL);
6426
6427   val = eh->export_glue->root.u.def.value + sec->output_offset
6428         + sec->output_section->vma;
6429
6430   myh = elf32_arm_create_thumb_stub (info, h->root.root.string,
6431                                      h->root.u.def.section->owner,
6432                                      globals->obfd, sec, val, s,
6433                                      &error_message);
6434   BFD_ASSERT (myh);
6435   return TRUE;
6436 }
6437
6438 /* Populate ARMv4 BX veneers.  Returns the absolute adress of the veneer.  */
6439
6440 static bfd_vma
6441 elf32_arm_bx_glue (struct bfd_link_info * info, int reg)
6442 {
6443   bfd_byte *p;
6444   bfd_vma glue_addr;
6445   asection *s;
6446   struct elf32_arm_link_hash_table *globals;
6447
6448   globals = elf32_arm_hash_table (info);
6449
6450   BFD_ASSERT (globals != NULL);
6451   BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
6452
6453   s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
6454                                ARM_BX_GLUE_SECTION_NAME);
6455   BFD_ASSERT (s != NULL);
6456   BFD_ASSERT (s->contents != NULL);
6457   BFD_ASSERT (s->output_section != NULL);
6458
6459   BFD_ASSERT (globals->bx_glue_offset[reg] & 2);
6460
6461   glue_addr = globals->bx_glue_offset[reg] & ~(bfd_vma)3;
6462
6463   if ((globals->bx_glue_offset[reg] & 1) == 0)
6464     {
6465       p = s->contents + glue_addr;
6466       bfd_put_32 (globals->obfd, armbx1_tst_insn + (reg << 16), p);
6467       bfd_put_32 (globals->obfd, armbx2_moveq_insn + reg, p + 4);
6468       bfd_put_32 (globals->obfd, armbx3_bx_insn + reg, p + 8);
6469       globals->bx_glue_offset[reg] |= 1;
6470     }
6471
6472   return glue_addr + s->output_section->vma + s->output_offset;
6473 }
6474
6475 /* Generate Arm stubs for exported Thumb symbols.  */
6476 static void
6477 elf32_arm_begin_write_processing (bfd *abfd ATTRIBUTE_UNUSED,
6478                                   struct bfd_link_info *link_info)
6479 {
6480   struct elf32_arm_link_hash_table * globals;
6481
6482   if (link_info == NULL)
6483     /* Ignore this if we are not called by the ELF backend linker.  */
6484     return;
6485
6486   globals = elf32_arm_hash_table (link_info);
6487   /* If blx is available then exported Thumb symbols are OK and there is
6488      nothing to do.  */
6489   if (globals->use_blx)
6490     return;
6491
6492   elf_link_hash_traverse (&globals->root, elf32_arm_to_thumb_export_stub,
6493                           link_info);
6494 }
6495
6496 /* Some relocations map to different relocations depending on the
6497    target.  Return the real relocation.  */
6498
6499 static int
6500 arm_real_reloc_type (struct elf32_arm_link_hash_table * globals,
6501                      int r_type)
6502 {
6503   switch (r_type)
6504     {
6505     case R_ARM_TARGET1:
6506       if (globals->target1_is_rel)
6507         return R_ARM_REL32;
6508       else
6509         return R_ARM_ABS32;
6510
6511     case R_ARM_TARGET2:
6512       return globals->target2_reloc;
6513
6514     default:
6515       return r_type;
6516     }
6517 }
6518
6519 /* Return the base VMA address which should be subtracted from real addresses
6520    when resolving @dtpoff relocation.
6521    This is PT_TLS segment p_vaddr.  */
6522
6523 static bfd_vma
6524 dtpoff_base (struct bfd_link_info *info)
6525 {
6526   /* If tls_sec is NULL, we should have signalled an error already.  */
6527   if (elf_hash_table (info)->tls_sec == NULL)
6528     return 0;
6529   return elf_hash_table (info)->tls_sec->vma;
6530 }
6531
6532 /* Return the relocation value for @tpoff relocation
6533    if STT_TLS virtual address is ADDRESS.  */
6534
6535 static bfd_vma
6536 tpoff (struct bfd_link_info *info, bfd_vma address)
6537 {
6538   struct elf_link_hash_table *htab = elf_hash_table (info);
6539   bfd_vma base;
6540
6541   /* If tls_sec is NULL, we should have signalled an error already.  */
6542   if (htab->tls_sec == NULL)
6543     return 0;
6544   base = align_power ((bfd_vma) TCB_SIZE, htab->tls_sec->alignment_power);
6545   return address - htab->tls_sec->vma + base;
6546 }
6547
6548 /* Perform an R_ARM_ABS12 relocation on the field pointed to by DATA.
6549    VALUE is the relocation value.  */
6550
6551 static bfd_reloc_status_type
6552 elf32_arm_abs12_reloc (bfd *abfd, void *data, bfd_vma value)
6553 {
6554   if (value > 0xfff)
6555     return bfd_reloc_overflow;
6556
6557   value |= bfd_get_32 (abfd, data) & 0xfffff000;
6558   bfd_put_32 (abfd, value, data);
6559   return bfd_reloc_ok;
6560 }
6561
6562 /* For a given value of n, calculate the value of G_n as required to
6563    deal with group relocations.  We return it in the form of an
6564    encoded constant-and-rotation, together with the final residual.  If n is
6565    specified as less than zero, then final_residual is filled with the
6566    input value and no further action is performed.  */
6567
6568 static bfd_vma
6569 calculate_group_reloc_mask (bfd_vma value, int n, bfd_vma *final_residual)
6570 {
6571   int current_n;
6572   bfd_vma g_n;
6573   bfd_vma encoded_g_n = 0;
6574   bfd_vma residual = value; /* Also known as Y_n.  */
6575
6576   for (current_n = 0; current_n <= n; current_n++)
6577     {
6578       int shift;
6579
6580       /* Calculate which part of the value to mask.  */
6581       if (residual == 0)
6582         shift = 0;
6583       else
6584         {
6585           int msb;
6586
6587           /* Determine the most significant bit in the residual and
6588              align the resulting value to a 2-bit boundary.  */
6589           for (msb = 30; msb >= 0; msb -= 2)
6590             if (residual & (3 << msb))
6591               break;
6592
6593           /* The desired shift is now (msb - 6), or zero, whichever
6594              is the greater.  */
6595           shift = msb - 6;
6596           if (shift < 0)
6597             shift = 0;
6598         }
6599
6600       /* Calculate g_n in 32-bit as well as encoded constant+rotation form.  */
6601       g_n = residual & (0xff << shift);
6602       encoded_g_n = (g_n >> shift)
6603                     | ((g_n <= 0xff ? 0 : (32 - shift) / 2) << 8);
6604
6605       /* Calculate the residual for the next time around.  */
6606       residual &= ~g_n;
6607     }
6608
6609   *final_residual = residual;
6610
6611   return encoded_g_n;
6612 }
6613
6614 /* Given an ARM instruction, determine whether it is an ADD or a SUB.
6615    Returns 1 if it is an ADD, -1 if it is a SUB, and 0 otherwise.  */
6616
6617 static int
6618 identify_add_or_sub (bfd_vma insn)
6619 {
6620   int opcode = insn & 0x1e00000;
6621
6622   if (opcode == 1 << 23) /* ADD */
6623     return 1;
6624
6625   if (opcode == 1 << 22) /* SUB */
6626     return -1;
6627
6628   return 0;
6629 }
6630
6631 /* Perform a relocation as part of a final link.  */
6632
6633 static bfd_reloc_status_type
6634 elf32_arm_final_link_relocate (reloc_howto_type *           howto,
6635                                bfd *                        input_bfd,
6636                                bfd *                        output_bfd,
6637                                asection *                   input_section,
6638                                bfd_byte *                   contents,
6639                                Elf_Internal_Rela *          rel,
6640                                bfd_vma                      value,
6641                                struct bfd_link_info *       info,
6642                                asection *                   sym_sec,
6643                                const char *                 sym_name,
6644                                int                          sym_flags,
6645                                struct elf_link_hash_entry * h,
6646                                bfd_boolean *                unresolved_reloc_p,
6647                                char **                      error_message)
6648 {
6649   unsigned long                 r_type = howto->type;
6650   unsigned long                 r_symndx;
6651   bfd_byte *                    hit_data = contents + rel->r_offset;
6652   bfd *                         dynobj = NULL;
6653   Elf_Internal_Shdr *           symtab_hdr;
6654   struct elf_link_hash_entry ** sym_hashes;
6655   bfd_vma *                     local_got_offsets;
6656   asection *                    sgot = NULL;
6657   asection *                    splt = NULL;
6658   asection *                    sreloc = NULL;
6659   bfd_vma                       addend;
6660   bfd_signed_vma                signed_addend;
6661   struct elf32_arm_link_hash_table * globals;
6662
6663   globals = elf32_arm_hash_table (info);
6664
6665   BFD_ASSERT (is_arm_elf (input_bfd));
6666
6667   /* Some relocation types map to different relocations depending on the
6668      target.  We pick the right one here.  */
6669   r_type = arm_real_reloc_type (globals, r_type);
6670   if (r_type != howto->type)
6671     howto = elf32_arm_howto_from_type (r_type);
6672
6673   /* If the start address has been set, then set the EF_ARM_HASENTRY
6674      flag.  Setting this more than once is redundant, but the cost is
6675      not too high, and it keeps the code simple.
6676
6677      The test is done  here, rather than somewhere else, because the
6678      start address is only set just before the final link commences.
6679
6680      Note - if the user deliberately sets a start address of 0, the
6681      flag will not be set.  */
6682   if (bfd_get_start_address (output_bfd) != 0)
6683     elf_elfheader (output_bfd)->e_flags |= EF_ARM_HASENTRY;
6684
6685   dynobj = elf_hash_table (info)->dynobj;
6686   if (dynobj)
6687     {
6688       sgot = bfd_get_section_by_name (dynobj, ".got");
6689       splt = bfd_get_section_by_name (dynobj, ".plt");
6690     }
6691   symtab_hdr = & elf_symtab_hdr (input_bfd);
6692   sym_hashes = elf_sym_hashes (input_bfd);
6693   local_got_offsets = elf_local_got_offsets (input_bfd);
6694   r_symndx = ELF32_R_SYM (rel->r_info);
6695
6696   if (globals->use_rel)
6697     {
6698       addend = bfd_get_32 (input_bfd, hit_data) & howto->src_mask;
6699
6700       if (addend & ((howto->src_mask + 1) >> 1))
6701         {
6702           signed_addend = -1;
6703           signed_addend &= ~ howto->src_mask;
6704           signed_addend |= addend;
6705         }
6706       else
6707         signed_addend = addend;
6708     }
6709   else
6710     addend = signed_addend = rel->r_addend;
6711
6712   switch (r_type)
6713     {
6714     case R_ARM_NONE:
6715       /* We don't need to find a value for this symbol.  It's just a
6716          marker.  */
6717       *unresolved_reloc_p = FALSE;
6718       return bfd_reloc_ok;
6719
6720     case R_ARM_ABS12:
6721       if (!globals->vxworks_p)
6722         return elf32_arm_abs12_reloc (input_bfd, hit_data, value + addend);
6723
6724     case R_ARM_PC24:
6725     case R_ARM_ABS32:
6726     case R_ARM_ABS32_NOI:
6727     case R_ARM_REL32:
6728     case R_ARM_REL32_NOI:
6729     case R_ARM_CALL:
6730     case R_ARM_JUMP24:
6731     case R_ARM_XPC25:
6732     case R_ARM_PREL31:
6733     case R_ARM_PLT32:
6734       /* Handle relocations which should use the PLT entry.  ABS32/REL32
6735          will use the symbol's value, which may point to a PLT entry, but we
6736          don't need to handle that here.  If we created a PLT entry, all
6737          branches in this object should go to it, except if the PLT is too
6738          far away, in which case a long branch stub should be inserted.  */
6739       if ((r_type != R_ARM_ABS32 && r_type != R_ARM_REL32
6740            && r_type != R_ARM_ABS32_NOI && r_type != R_ARM_REL32_NOI
6741            && r_type != R_ARM_CALL
6742            && r_type != R_ARM_JUMP24
6743            && r_type != R_ARM_PLT32)
6744           && h != NULL
6745           && splt != NULL
6746           && h->plt.offset != (bfd_vma) -1)
6747         {
6748           /* If we've created a .plt section, and assigned a PLT entry to
6749              this function, it should not be known to bind locally.  If
6750              it were, we would have cleared the PLT entry.  */
6751           BFD_ASSERT (!SYMBOL_CALLS_LOCAL (info, h));
6752
6753           value = (splt->output_section->vma
6754                    + splt->output_offset
6755                    + h->plt.offset);
6756           *unresolved_reloc_p = FALSE;
6757           return _bfd_final_link_relocate (howto, input_bfd, input_section,
6758                                            contents, rel->r_offset, value,
6759                                            rel->r_addend);
6760         }
6761
6762       /* When generating a shared object or relocatable executable, these
6763          relocations are copied into the output file to be resolved at
6764          run time.  */
6765       if ((info->shared || globals->root.is_relocatable_executable)
6766           && (input_section->flags & SEC_ALLOC)
6767           && !(elf32_arm_hash_table (info)->vxworks_p
6768                && strcmp (input_section->output_section->name,
6769                           ".tls_vars") == 0)
6770           && ((r_type != R_ARM_REL32 && r_type != R_ARM_REL32_NOI)
6771               || !SYMBOL_CALLS_LOCAL (info, h))
6772           && (h == NULL
6773               || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
6774               || h->root.type != bfd_link_hash_undefweak)
6775           && r_type != R_ARM_PC24
6776           && r_type != R_ARM_CALL
6777           && r_type != R_ARM_JUMP24
6778           && r_type != R_ARM_PREL31
6779           && r_type != R_ARM_PLT32)
6780         {
6781           Elf_Internal_Rela outrel;
6782           bfd_byte *loc;
6783           bfd_boolean skip, relocate;
6784
6785           *unresolved_reloc_p = FALSE;
6786
6787           if (sreloc == NULL)
6788             {
6789               sreloc = _bfd_elf_get_dynamic_reloc_section (input_bfd, input_section,
6790                                                            ! globals->use_rel);
6791
6792               if (sreloc == NULL)
6793                 return bfd_reloc_notsupported;
6794             }
6795
6796           skip = FALSE;
6797           relocate = FALSE;
6798
6799           outrel.r_addend = addend;
6800           outrel.r_offset =
6801             _bfd_elf_section_offset (output_bfd, info, input_section,
6802                                      rel->r_offset);
6803           if (outrel.r_offset == (bfd_vma) -1)
6804             skip = TRUE;
6805           else if (outrel.r_offset == (bfd_vma) -2)
6806             skip = TRUE, relocate = TRUE;
6807           outrel.r_offset += (input_section->output_section->vma
6808                               + input_section->output_offset);
6809
6810           if (skip)
6811             memset (&outrel, 0, sizeof outrel);
6812           else if (h != NULL
6813                    && h->dynindx != -1
6814                    && (!info->shared
6815                        || !info->symbolic
6816                        || !h->def_regular))
6817             outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
6818           else
6819             {
6820               int symbol;
6821
6822               /* This symbol is local, or marked to become local.  */
6823               if (sym_flags == STT_ARM_TFUNC)
6824                 value |= 1;
6825               if (globals->symbian_p)
6826                 {
6827                   asection *osec;
6828
6829                   /* On Symbian OS, the data segment and text segement
6830                      can be relocated independently.  Therefore, we
6831                      must indicate the segment to which this
6832                      relocation is relative.  The BPABI allows us to
6833                      use any symbol in the right segment; we just use
6834                      the section symbol as it is convenient.  (We
6835                      cannot use the symbol given by "h" directly as it
6836                      will not appear in the dynamic symbol table.)
6837
6838                      Note that the dynamic linker ignores the section
6839                      symbol value, so we don't subtract osec->vma
6840                      from the emitted reloc addend.  */
6841                   if (sym_sec)
6842                     osec = sym_sec->output_section;
6843                   else
6844                     osec = input_section->output_section;
6845                   symbol = elf_section_data (osec)->dynindx;
6846                   if (symbol == 0)
6847                     {
6848                       struct elf_link_hash_table *htab = elf_hash_table (info);
6849
6850                       if ((osec->flags & SEC_READONLY) == 0
6851                           && htab->data_index_section != NULL)
6852                         osec = htab->data_index_section;
6853                       else
6854                         osec = htab->text_index_section;
6855                       symbol = elf_section_data (osec)->dynindx;
6856                     }
6857                   BFD_ASSERT (symbol != 0);
6858                 }
6859               else
6860                 /* On SVR4-ish systems, the dynamic loader cannot
6861                    relocate the text and data segments independently,
6862                    so the symbol does not matter.  */
6863                 symbol = 0;
6864               outrel.r_info = ELF32_R_INFO (symbol, R_ARM_RELATIVE);
6865               if (globals->use_rel)
6866                 relocate = TRUE;
6867               else
6868                 outrel.r_addend += value;
6869             }
6870
6871           loc = sreloc->contents;
6872           loc += sreloc->reloc_count++ * RELOC_SIZE (globals);
6873           SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
6874
6875           /* If this reloc is against an external symbol, we do not want to
6876              fiddle with the addend.  Otherwise, we need to include the symbol
6877              value so that it becomes an addend for the dynamic reloc.  */
6878           if (! relocate)
6879             return bfd_reloc_ok;
6880
6881           return _bfd_final_link_relocate (howto, input_bfd, input_section,
6882                                            contents, rel->r_offset, value,
6883                                            (bfd_vma) 0);
6884         }
6885       else switch (r_type)
6886         {
6887         case R_ARM_ABS12:
6888           return elf32_arm_abs12_reloc (input_bfd, hit_data, value + addend);
6889
6890         case R_ARM_XPC25:         /* Arm BLX instruction.  */
6891         case R_ARM_CALL:
6892         case R_ARM_JUMP24:
6893         case R_ARM_PC24:          /* Arm B/BL instruction.  */
6894         case R_ARM_PLT32:
6895           {
6896           bfd_vma from;
6897           bfd_signed_vma branch_offset;
6898           struct elf32_arm_stub_hash_entry *stub_entry = NULL;
6899
6900           if (r_type == R_ARM_XPC25)
6901             {
6902               /* Check for Arm calling Arm function.  */
6903               /* FIXME: Should we translate the instruction into a BL
6904                  instruction instead ?  */
6905               if (sym_flags != STT_ARM_TFUNC)
6906                 (*_bfd_error_handler)
6907                   (_("\%B: Warning: Arm BLX instruction targets Arm function '%s'."),
6908                    input_bfd,
6909                    h ? h->root.root.string : "(local)");
6910             }
6911           else if (r_type == R_ARM_PC24)
6912             {
6913               /* Check for Arm calling Thumb function.  */
6914               if (sym_flags == STT_ARM_TFUNC)
6915                 {
6916                   if (elf32_arm_to_thumb_stub (info, sym_name, input_bfd,
6917                                                output_bfd, input_section,
6918                                                hit_data, sym_sec, rel->r_offset,
6919                                                signed_addend, value,
6920                                                error_message))
6921                     return bfd_reloc_ok;
6922                   else
6923                     return bfd_reloc_dangerous;
6924                 }
6925             }
6926
6927           /* Check if a stub has to be inserted because the
6928              destination is too far or we are changing mode.  */
6929           if (   r_type == R_ARM_CALL
6930               || r_type == R_ARM_JUMP24
6931               || r_type == R_ARM_PLT32)
6932             {
6933               /* If the call goes through a PLT entry, make sure to
6934                  check distance to the right destination address.  */
6935               if (h != NULL && splt != NULL && h->plt.offset != (bfd_vma) -1)
6936                 {
6937                   value = (splt->output_section->vma
6938                            + splt->output_offset
6939                            + h->plt.offset);
6940                   *unresolved_reloc_p = FALSE;
6941                 }
6942
6943               from = (input_section->output_section->vma
6944                       + input_section->output_offset
6945                       + rel->r_offset);
6946               branch_offset = (bfd_signed_vma)(value - from);
6947
6948               if (branch_offset > ARM_MAX_FWD_BRANCH_OFFSET
6949                   || branch_offset < ARM_MAX_BWD_BRANCH_OFFSET
6950                   || ((sym_flags == STT_ARM_TFUNC)
6951                       && (((r_type == R_ARM_CALL) && !globals->use_blx)
6952                           || (r_type == R_ARM_JUMP24)
6953                           || (r_type == R_ARM_PLT32) ))
6954                   )
6955                 {
6956                   /* The target is out of reach, so redirect the
6957                      branch to the local stub for this function.  */
6958
6959                   stub_entry = elf32_arm_get_stub_entry (input_section,
6960                                                          sym_sec, h,
6961                                                          rel, globals);
6962                   if (stub_entry != NULL)
6963                     value = (stub_entry->stub_offset
6964                              + stub_entry->stub_sec->output_offset
6965                              + stub_entry->stub_sec->output_section->vma);
6966                 }
6967             }
6968
6969           /* The ARM ELF ABI says that this reloc is computed as: S - P + A
6970              where:
6971               S is the address of the symbol in the relocation.
6972               P is address of the instruction being relocated.
6973               A is the addend (extracted from the instruction) in bytes.
6974
6975              S is held in 'value'.
6976              P is the base address of the section containing the
6977                instruction plus the offset of the reloc into that
6978                section, ie:
6979                  (input_section->output_section->vma +
6980                   input_section->output_offset +
6981                   rel->r_offset).
6982              A is the addend, converted into bytes, ie:
6983                  (signed_addend * 4)
6984
6985              Note: None of these operations have knowledge of the pipeline
6986              size of the processor, thus it is up to the assembler to
6987              encode this information into the addend.  */
6988           value -= (input_section->output_section->vma
6989                     + input_section->output_offset);
6990           value -= rel->r_offset;
6991           if (globals->use_rel)
6992             value += (signed_addend << howto->size);
6993           else
6994             /* RELA addends do not have to be adjusted by howto->size.  */
6995             value += signed_addend;
6996
6997           signed_addend = value;
6998           signed_addend >>= howto->rightshift;
6999
7000           /* A branch to an undefined weak symbol is turned into a jump to
7001              the next instruction unless a PLT entry will be created.  */
7002           if (h && h->root.type == bfd_link_hash_undefweak
7003               && !(splt != NULL && h->plt.offset != (bfd_vma) -1))
7004             {
7005               value = (bfd_get_32 (input_bfd, hit_data) & 0xf0000000)
7006                       | 0x0affffff;
7007             }
7008           else
7009             {
7010               /* Perform a signed range check.  */
7011               if (   signed_addend >   ((bfd_signed_vma)  (howto->dst_mask >> 1))
7012                   || signed_addend < - ((bfd_signed_vma) ((howto->dst_mask + 1) >> 1)))
7013                 return bfd_reloc_overflow;
7014
7015               addend = (value & 2);
7016
7017               value = (signed_addend & howto->dst_mask)
7018                 | (bfd_get_32 (input_bfd, hit_data) & (~ howto->dst_mask));
7019
7020               if (r_type == R_ARM_CALL)
7021                 {
7022                   /* Set the H bit in the BLX instruction.  */
7023                   if (sym_flags == STT_ARM_TFUNC)
7024                     {
7025                       if (addend)
7026                         value |= (1 << 24);
7027                       else
7028                         value &= ~(bfd_vma)(1 << 24);
7029                     }
7030
7031                   /* Select the correct instruction (BL or BLX).  */
7032                   /* Only if we are not handling a BL to a stub. In this
7033                      case, mode switching is performed by the stub.  */
7034                   if (sym_flags == STT_ARM_TFUNC && !stub_entry)
7035                     value |= (1 << 28);
7036                   else
7037                     {
7038                       value &= ~(bfd_vma)(1 << 28);
7039                       value |= (1 << 24);
7040                     }
7041                 }
7042             }
7043           }
7044           break;
7045
7046         case R_ARM_ABS32:
7047           value += addend;
7048           if (sym_flags == STT_ARM_TFUNC)
7049             value |= 1;
7050           break;
7051
7052         case R_ARM_ABS32_NOI:
7053           value += addend;
7054           break;
7055
7056         case R_ARM_REL32:
7057           value += addend;
7058           if (sym_flags == STT_ARM_TFUNC)
7059             value |= 1;
7060           value -= (input_section->output_section->vma
7061                     + input_section->output_offset + rel->r_offset);
7062           break;
7063
7064         case R_ARM_REL32_NOI:
7065           value += addend;
7066           value -= (input_section->output_section->vma
7067                     + input_section->output_offset + rel->r_offset);
7068           break;
7069
7070         case R_ARM_PREL31:
7071           value -= (input_section->output_section->vma
7072                     + input_section->output_offset + rel->r_offset);
7073           value += signed_addend;
7074           if (! h || h->root.type != bfd_link_hash_undefweak)
7075             {
7076               /* Check for overflow.  */
7077               if ((value ^ (value >> 1)) & (1 << 30))
7078                 return bfd_reloc_overflow;
7079             }
7080           value &= 0x7fffffff;
7081           value |= (bfd_get_32 (input_bfd, hit_data) & 0x80000000);
7082           if (sym_flags == STT_ARM_TFUNC)
7083             value |= 1;
7084           break;
7085         }
7086
7087       bfd_put_32 (input_bfd, value, hit_data);
7088       return bfd_reloc_ok;
7089
7090     case R_ARM_ABS8:
7091       value += addend;
7092       if ((long) value > 0x7f || (long) value < -0x80)
7093         return bfd_reloc_overflow;
7094
7095       bfd_put_8 (input_bfd, value, hit_data);
7096       return bfd_reloc_ok;
7097
7098     case R_ARM_ABS16:
7099       value += addend;
7100
7101       if ((long) value > 0x7fff || (long) value < -0x8000)
7102         return bfd_reloc_overflow;
7103
7104       bfd_put_16 (input_bfd, value, hit_data);
7105       return bfd_reloc_ok;
7106
7107     case R_ARM_THM_ABS5:
7108       /* Support ldr and str instructions for the thumb.  */
7109       if (globals->use_rel)
7110         {
7111           /* Need to refetch addend.  */
7112           addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
7113           /* ??? Need to determine shift amount from operand size.  */
7114           addend >>= howto->rightshift;
7115         }
7116       value += addend;
7117
7118       /* ??? Isn't value unsigned?  */
7119       if ((long) value > 0x1f || (long) value < -0x10)
7120         return bfd_reloc_overflow;
7121
7122       /* ??? Value needs to be properly shifted into place first.  */
7123       value |= bfd_get_16 (input_bfd, hit_data) & 0xf83f;
7124       bfd_put_16 (input_bfd, value, hit_data);
7125       return bfd_reloc_ok;
7126
7127     case R_ARM_THM_ALU_PREL_11_0:
7128       /* Corresponds to: addw.w reg, pc, #offset (and similarly for subw).  */
7129       {
7130         bfd_vma insn;
7131         bfd_signed_vma relocation;
7132
7133         insn = (bfd_get_16 (input_bfd, hit_data) << 16)
7134              | bfd_get_16 (input_bfd, hit_data + 2);
7135
7136         if (globals->use_rel)
7137           {
7138             signed_addend = (insn & 0xff) | ((insn & 0x7000) >> 4)
7139                           | ((insn & (1 << 26)) >> 15);
7140             if (insn & 0xf00000)
7141               signed_addend = -signed_addend;
7142           }
7143
7144         relocation = value + signed_addend;
7145         relocation -= (input_section->output_section->vma
7146                        + input_section->output_offset
7147                        + rel->r_offset);
7148
7149         value = abs (relocation);
7150
7151         if (value >= 0x1000)
7152           return bfd_reloc_overflow;
7153
7154         insn = (insn & 0xfb0f8f00) | (value & 0xff)
7155              | ((value & 0x700) << 4)
7156              | ((value & 0x800) << 15);
7157         if (relocation < 0)
7158           insn |= 0xa00000;
7159
7160         bfd_put_16 (input_bfd, insn >> 16, hit_data);
7161         bfd_put_16 (input_bfd, insn & 0xffff, hit_data + 2);
7162
7163         return bfd_reloc_ok;
7164       }
7165
7166     case R_ARM_THM_PC12:
7167       /* Corresponds to: ldr.w reg, [pc, #offset].  */
7168       {
7169         bfd_vma insn;
7170         bfd_signed_vma relocation;
7171
7172         insn = (bfd_get_16 (input_bfd, hit_data) << 16)
7173              | bfd_get_16 (input_bfd, hit_data + 2);
7174
7175         if (globals->use_rel)
7176           {
7177             signed_addend = insn & 0xfff;
7178             if (!(insn & (1 << 23)))
7179               signed_addend = -signed_addend;
7180           }
7181
7182         relocation = value + signed_addend;
7183         relocation -= (input_section->output_section->vma
7184                        + input_section->output_offset
7185                        + rel->r_offset);
7186
7187         value = abs (relocation);
7188
7189         if (value >= 0x1000)
7190           return bfd_reloc_overflow;
7191
7192         insn = (insn & 0xff7ff000) | value;
7193         if (relocation >= 0)
7194           insn |= (1 << 23);
7195
7196         bfd_put_16 (input_bfd, insn >> 16, hit_data);
7197         bfd_put_16 (input_bfd, insn & 0xffff, hit_data + 2);
7198
7199         return bfd_reloc_ok;
7200       }
7201
7202     case R_ARM_THM_XPC22:
7203     case R_ARM_THM_CALL:
7204     case R_ARM_THM_JUMP24:
7205       /* Thumb BL (branch long instruction).  */
7206       {
7207         bfd_vma relocation;
7208         bfd_vma reloc_sign;
7209         bfd_boolean overflow = FALSE;
7210         bfd_vma upper_insn = bfd_get_16 (input_bfd, hit_data);
7211         bfd_vma lower_insn = bfd_get_16 (input_bfd, hit_data + 2);
7212         bfd_signed_vma reloc_signed_max;
7213         bfd_signed_vma reloc_signed_min;
7214         bfd_vma check;
7215         bfd_signed_vma signed_check;
7216         int bitsize;
7217         int thumb2 = using_thumb2 (globals);
7218
7219         /* A branch to an undefined weak symbol is turned into a jump to
7220            the next instruction unless a PLT entry will be created.  */
7221         if (h && h->root.type == bfd_link_hash_undefweak
7222             && !(splt != NULL && h->plt.offset != (bfd_vma) -1))
7223           {
7224             bfd_put_16 (input_bfd, 0xe000, hit_data);
7225             bfd_put_16 (input_bfd, 0xbf00, hit_data + 2);
7226             return bfd_reloc_ok;
7227           }
7228
7229         /* Fetch the addend.  We use the Thumb-2 encoding (backwards compatible
7230            with Thumb-1) involving the J1 and J2 bits.  */
7231         if (globals->use_rel)
7232           {
7233             bfd_vma s = (upper_insn & (1 << 10)) >> 10;
7234             bfd_vma upper = upper_insn & 0x3ff;
7235             bfd_vma lower = lower_insn & 0x7ff;
7236             bfd_vma j1 = (lower_insn & (1 << 13)) >> 13;
7237             bfd_vma j2 = (lower_insn & (1 << 11)) >> 11;
7238             bfd_vma i1 = j1 ^ s ? 0 : 1;
7239             bfd_vma i2 = j2 ^ s ? 0 : 1;
7240
7241             addend = (i1 << 23) | (i2 << 22) | (upper << 12) | (lower << 1);
7242             /* Sign extend.  */
7243             addend = (addend | ((s ? 0 : 1) << 24)) - (1 << 24);
7244
7245             signed_addend = addend;
7246           }
7247
7248         if (r_type == R_ARM_THM_XPC22)
7249           {
7250             /* Check for Thumb to Thumb call.  */
7251             /* FIXME: Should we translate the instruction into a BL
7252                instruction instead ?  */
7253             if (sym_flags == STT_ARM_TFUNC)
7254               (*_bfd_error_handler)
7255                 (_("%B: Warning: Thumb BLX instruction targets thumb function '%s'."),
7256                  input_bfd,
7257                  h ? h->root.root.string : "(local)");
7258           }
7259         else
7260           {
7261             /* If it is not a call to Thumb, assume call to Arm.
7262                If it is a call relative to a section name, then it is not a
7263                function call at all, but rather a long jump.  Calls through
7264                the PLT do not require stubs.  */
7265             if (sym_flags != STT_ARM_TFUNC && sym_flags != STT_SECTION
7266                 && (h == NULL || splt == NULL
7267                     || h->plt.offset == (bfd_vma) -1))
7268               {
7269                 if (globals->use_blx && r_type == R_ARM_THM_CALL)
7270                   {
7271                     /* Convert BL to BLX.  */
7272                     lower_insn = (lower_insn & ~0x1000) | 0x0800;
7273                   }
7274                 else if ((   r_type != R_ARM_THM_CALL)
7275                          && (r_type != R_ARM_THM_JUMP24))
7276                   {
7277                     if (elf32_thumb_to_arm_stub
7278                         (info, sym_name, input_bfd, output_bfd, input_section,
7279                          hit_data, sym_sec, rel->r_offset, signed_addend, value,
7280                          error_message))
7281                       return bfd_reloc_ok;
7282                     else
7283                       return bfd_reloc_dangerous;
7284                   }
7285               }
7286             else if (sym_flags == STT_ARM_TFUNC && globals->use_blx
7287                      && r_type == R_ARM_THM_CALL)
7288               {
7289                 /* Make sure this is a BL.  */
7290                 lower_insn |= 0x1800;
7291               }
7292           }
7293
7294         /* Handle calls via the PLT.  */
7295         if (h != NULL && splt != NULL && h->plt.offset != (bfd_vma) -1)
7296           {
7297             value = (splt->output_section->vma
7298                      + splt->output_offset
7299                      + h->plt.offset);
7300             if (globals->use_blx && r_type == R_ARM_THM_CALL)
7301               {
7302                 /* If the Thumb BLX instruction is available, convert the
7303                    BL to a BLX instruction to call the ARM-mode PLT entry.  */
7304                 lower_insn = (lower_insn & ~0x1000) | 0x0800;
7305               }
7306             else
7307               /* Target the Thumb stub before the ARM PLT entry.  */
7308               value -= PLT_THUMB_STUB_SIZE;
7309             *unresolved_reloc_p = FALSE;
7310           }
7311
7312         if (r_type == R_ARM_THM_CALL || r_type == R_ARM_THM_JUMP24)
7313           {
7314             /* Check if a stub has to be inserted because the destination
7315                is too far.  */
7316             bfd_vma from;
7317             bfd_signed_vma branch_offset;
7318             struct elf32_arm_stub_hash_entry *stub_entry = NULL;
7319
7320             from = (input_section->output_section->vma
7321                     + input_section->output_offset
7322                     + rel->r_offset);
7323             branch_offset = (bfd_signed_vma)(value - from);
7324
7325             if ((!thumb2
7326                  && (branch_offset > THM_MAX_FWD_BRANCH_OFFSET
7327                      || (branch_offset < THM_MAX_BWD_BRANCH_OFFSET)))
7328                 ||
7329                 (thumb2
7330                  && (branch_offset > THM2_MAX_FWD_BRANCH_OFFSET
7331                      || (branch_offset < THM2_MAX_BWD_BRANCH_OFFSET)))
7332                 || ((sym_flags != STT_ARM_TFUNC)
7333                     && (((r_type == R_ARM_THM_CALL) && !globals->use_blx)
7334                         || r_type == R_ARM_THM_JUMP24)))
7335               {
7336                 /* The target is out of reach or we are changing modes, so
7337                    redirect the branch to the local stub for this
7338                    function.  */
7339                 stub_entry = elf32_arm_get_stub_entry (input_section,
7340                                                        sym_sec, h,
7341                                                        rel, globals);
7342                 if (stub_entry != NULL)
7343                   value = (stub_entry->stub_offset
7344                            + stub_entry->stub_sec->output_offset
7345                            + stub_entry->stub_sec->output_section->vma);
7346
7347                 /* If this call becomes a call to Arm, force BLX.  */
7348                 if (globals->use_blx && (r_type == R_ARM_THM_CALL))
7349                   {
7350                     if ((stub_entry
7351                          && !arm_stub_is_thumb (stub_entry->stub_type))
7352                         || (sym_flags != STT_ARM_TFUNC))
7353                       lower_insn = (lower_insn & ~0x1000) | 0x0800;
7354                   }
7355               }
7356           }
7357
7358         relocation = value + signed_addend;
7359
7360         relocation -= (input_section->output_section->vma
7361                        + input_section->output_offset
7362                        + rel->r_offset);
7363
7364         check = relocation >> howto->rightshift;
7365
7366         /* If this is a signed value, the rightshift just dropped
7367            leading 1 bits (assuming twos complement).  */
7368         if ((bfd_signed_vma) relocation >= 0)
7369           signed_check = check;
7370         else
7371           signed_check = check | ~((bfd_vma) -1 >> howto->rightshift);
7372
7373         /* Calculate the permissable maximum and minimum values for
7374            this relocation according to whether we're relocating for
7375            Thumb-2 or not.  */
7376         bitsize = howto->bitsize;
7377         if (!thumb2)
7378           bitsize -= 2;
7379         reloc_signed_max = ((1 << (bitsize - 1)) - 1) >> howto->rightshift;
7380         reloc_signed_min = ~reloc_signed_max;
7381
7382         /* Assumes two's complement.  */
7383         if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
7384           overflow = TRUE;
7385
7386         if ((lower_insn & 0x5000) == 0x4000)
7387           /* For a BLX instruction, make sure that the relocation is rounded up
7388              to a word boundary.  This follows the semantics of the instruction
7389              which specifies that bit 1 of the target address will come from bit
7390              1 of the base address.  */
7391           relocation = (relocation + 2) & ~ 3;
7392
7393         /* Put RELOCATION back into the insn.  Assumes two's complement.
7394            We use the Thumb-2 encoding, which is safe even if dealing with
7395            a Thumb-1 instruction by virtue of our overflow check above.  */
7396         reloc_sign = (signed_check < 0) ? 1 : 0;
7397         upper_insn = (upper_insn & ~(bfd_vma) 0x7ff)
7398                      | ((relocation >> 12) & 0x3ff)
7399                      | (reloc_sign << 10);
7400         lower_insn = (lower_insn & ~(bfd_vma) 0x2fff)
7401                      | (((!((relocation >> 23) & 1)) ^ reloc_sign) << 13)
7402                      | (((!((relocation >> 22) & 1)) ^ reloc_sign) << 11)
7403                      | ((relocation >> 1) & 0x7ff);
7404
7405         /* Put the relocated value back in the object file:  */
7406         bfd_put_16 (input_bfd, upper_insn, hit_data);
7407         bfd_put_16 (input_bfd, lower_insn, hit_data + 2);
7408
7409         return (overflow ? bfd_reloc_overflow : bfd_reloc_ok);
7410       }
7411       break;
7412
7413     case R_ARM_THM_JUMP19:
7414       /* Thumb32 conditional branch instruction.  */
7415       {
7416         bfd_vma relocation;
7417         bfd_boolean overflow = FALSE;
7418         bfd_vma upper_insn = bfd_get_16 (input_bfd, hit_data);
7419         bfd_vma lower_insn = bfd_get_16 (input_bfd, hit_data + 2);
7420         bfd_signed_vma reloc_signed_max = 0xffffe;
7421         bfd_signed_vma reloc_signed_min = -0x100000;
7422         bfd_signed_vma signed_check;
7423
7424         /* Need to refetch the addend, reconstruct the top three bits,
7425            and squish the two 11 bit pieces together.  */
7426         if (globals->use_rel)
7427           {
7428             bfd_vma S     = (upper_insn & 0x0400) >> 10;
7429             bfd_vma upper = (upper_insn & 0x003f);
7430             bfd_vma J1    = (lower_insn & 0x2000) >> 13;
7431             bfd_vma J2    = (lower_insn & 0x0800) >> 11;
7432             bfd_vma lower = (lower_insn & 0x07ff);
7433
7434             upper |= J1 << 6;
7435             upper |= J2 << 7;
7436             upper |= (!S) << 8;
7437             upper -= 0x0100; /* Sign extend.  */
7438
7439             addend = (upper << 12) | (lower << 1);
7440             signed_addend = addend;
7441           }
7442
7443         /* Handle calls via the PLT.  */
7444         if (h != NULL && splt != NULL && h->plt.offset != (bfd_vma) -1)
7445           {
7446             value = (splt->output_section->vma
7447                      + splt->output_offset
7448                      + h->plt.offset);
7449             /* Target the Thumb stub before the ARM PLT entry.  */
7450             value -= PLT_THUMB_STUB_SIZE;
7451             *unresolved_reloc_p = FALSE;
7452           }
7453
7454         /* ??? Should handle interworking?  GCC might someday try to
7455            use this for tail calls.  */
7456
7457         relocation = value + signed_addend;
7458         relocation -= (input_section->output_section->vma
7459                        + input_section->output_offset
7460                        + rel->r_offset);
7461         signed_check = (bfd_signed_vma) relocation;
7462
7463         if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
7464           overflow = TRUE;
7465
7466         /* Put RELOCATION back into the insn.  */
7467         {
7468           bfd_vma S  = (relocation & 0x00100000) >> 20;
7469           bfd_vma J2 = (relocation & 0x00080000) >> 19;
7470           bfd_vma J1 = (relocation & 0x00040000) >> 18;
7471           bfd_vma hi = (relocation & 0x0003f000) >> 12;
7472           bfd_vma lo = (relocation & 0x00000ffe) >>  1;
7473
7474           upper_insn = (upper_insn & 0xfbc0) | (S << 10) | hi;
7475           lower_insn = (lower_insn & 0xd000) | (J1 << 13) | (J2 << 11) | lo;
7476         }
7477
7478         /* Put the relocated value back in the object file:  */
7479         bfd_put_16 (input_bfd, upper_insn, hit_data);
7480         bfd_put_16 (input_bfd, lower_insn, hit_data + 2);
7481
7482         return (overflow ? bfd_reloc_overflow : bfd_reloc_ok);
7483       }
7484
7485     case R_ARM_THM_JUMP11:
7486     case R_ARM_THM_JUMP8:
7487     case R_ARM_THM_JUMP6:
7488       /* Thumb B (branch) instruction).  */
7489       {
7490         bfd_signed_vma relocation;
7491         bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
7492         bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
7493         bfd_signed_vma signed_check;
7494
7495         /* CZB cannot jump backward.  */
7496         if (r_type == R_ARM_THM_JUMP6)
7497           reloc_signed_min = 0;
7498
7499         if (globals->use_rel)
7500           {
7501             /* Need to refetch addend.  */
7502             addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
7503             if (addend & ((howto->src_mask + 1) >> 1))
7504               {
7505                 signed_addend = -1;
7506                 signed_addend &= ~ howto->src_mask;
7507                 signed_addend |= addend;
7508               }
7509             else
7510               signed_addend = addend;
7511             /* The value in the insn has been right shifted.  We need to
7512                undo this, so that we can perform the address calculation
7513                in terms of bytes.  */
7514             signed_addend <<= howto->rightshift;
7515           }
7516         relocation = value + signed_addend;
7517
7518         relocation -= (input_section->output_section->vma
7519                        + input_section->output_offset
7520                        + rel->r_offset);
7521
7522         relocation >>= howto->rightshift;
7523         signed_check = relocation;
7524
7525         if (r_type == R_ARM_THM_JUMP6)
7526           relocation = ((relocation & 0x0020) << 4) | ((relocation & 0x001f) << 3);
7527         else
7528           relocation &= howto->dst_mask;
7529         relocation |= (bfd_get_16 (input_bfd, hit_data) & (~ howto->dst_mask));
7530
7531         bfd_put_16 (input_bfd, relocation, hit_data);
7532
7533         /* Assumes two's complement.  */
7534         if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
7535           return bfd_reloc_overflow;
7536
7537         return bfd_reloc_ok;
7538       }
7539
7540     case R_ARM_ALU_PCREL7_0:
7541     case R_ARM_ALU_PCREL15_8:
7542     case R_ARM_ALU_PCREL23_15:
7543       {
7544         bfd_vma insn;
7545         bfd_vma relocation;
7546
7547         insn = bfd_get_32 (input_bfd, hit_data);
7548         if (globals->use_rel)
7549           {
7550             /* Extract the addend.  */
7551             addend = (insn & 0xff) << ((insn & 0xf00) >> 7);
7552             signed_addend = addend;
7553           }
7554         relocation = value + signed_addend;
7555
7556         relocation -= (input_section->output_section->vma
7557                        + input_section->output_offset
7558                        + rel->r_offset);
7559         insn = (insn & ~0xfff)
7560                | ((howto->bitpos << 7) & 0xf00)
7561                | ((relocation >> howto->bitpos) & 0xff);
7562         bfd_put_32 (input_bfd, value, hit_data);
7563       }
7564       return bfd_reloc_ok;
7565
7566     case R_ARM_GNU_VTINHERIT:
7567     case R_ARM_GNU_VTENTRY:
7568       return bfd_reloc_ok;
7569
7570     case R_ARM_GOTOFF32:
7571       /* Relocation is relative to the start of the
7572          global offset table.  */
7573
7574       BFD_ASSERT (sgot != NULL);
7575       if (sgot == NULL)
7576         return bfd_reloc_notsupported;
7577
7578       /* If we are addressing a Thumb function, we need to adjust the
7579          address by one, so that attempts to call the function pointer will
7580          correctly interpret it as Thumb code.  */
7581       if (sym_flags == STT_ARM_TFUNC)
7582         value += 1;
7583
7584       /* Note that sgot->output_offset is not involved in this
7585          calculation.  We always want the start of .got.  If we
7586          define _GLOBAL_OFFSET_TABLE in a different way, as is
7587          permitted by the ABI, we might have to change this
7588          calculation.  */
7589       value -= sgot->output_section->vma;
7590       return _bfd_final_link_relocate (howto, input_bfd, input_section,
7591                                        contents, rel->r_offset, value,
7592                                        rel->r_addend);
7593
7594     case R_ARM_GOTPC:
7595       /* Use global offset table as symbol value.  */
7596       BFD_ASSERT (sgot != NULL);
7597
7598       if (sgot == NULL)
7599         return bfd_reloc_notsupported;
7600
7601       *unresolved_reloc_p = FALSE;
7602       value = sgot->output_section->vma;
7603       return _bfd_final_link_relocate (howto, input_bfd, input_section,
7604                                        contents, rel->r_offset, value,
7605                                        rel->r_addend);
7606
7607     case R_ARM_GOT32:
7608     case R_ARM_GOT_PREL:
7609       /* Relocation is to the entry for this symbol in the
7610          global offset table.  */
7611       if (sgot == NULL)
7612         return bfd_reloc_notsupported;
7613
7614       if (h != NULL)
7615         {
7616           bfd_vma off;
7617           bfd_boolean dyn;
7618
7619           off = h->got.offset;
7620           BFD_ASSERT (off != (bfd_vma) -1);
7621           dyn = globals->root.dynamic_sections_created;
7622
7623           if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
7624               || (info->shared
7625                   && SYMBOL_REFERENCES_LOCAL (info, h))
7626               || (ELF_ST_VISIBILITY (h->other)
7627                   && h->root.type == bfd_link_hash_undefweak))
7628             {
7629               /* This is actually a static link, or it is a -Bsymbolic link
7630                  and the symbol is defined locally.  We must initialize this
7631                  entry in the global offset table.  Since the offset must
7632                  always be a multiple of 4, we use the least significant bit
7633                  to record whether we have initialized it already.
7634
7635                  When doing a dynamic link, we create a .rel(a).got relocation
7636                  entry to initialize the value.  This is done in the
7637                  finish_dynamic_symbol routine.  */
7638               if ((off & 1) != 0)
7639                 off &= ~1;
7640               else
7641                 {
7642                   /* If we are addressing a Thumb function, we need to
7643                      adjust the address by one, so that attempts to
7644                      call the function pointer will correctly
7645                      interpret it as Thumb code.  */
7646                   if (sym_flags == STT_ARM_TFUNC)
7647                     value |= 1;
7648
7649                   bfd_put_32 (output_bfd, value, sgot->contents + off);
7650                   h->got.offset |= 1;
7651                 }
7652             }
7653           else
7654             *unresolved_reloc_p = FALSE;
7655
7656           value = sgot->output_offset + off;
7657         }
7658       else
7659         {
7660           bfd_vma off;
7661
7662           BFD_ASSERT (local_got_offsets != NULL &&
7663                       local_got_offsets[r_symndx] != (bfd_vma) -1);
7664
7665           off = local_got_offsets[r_symndx];
7666
7667           /* The offset must always be a multiple of 4.  We use the
7668              least significant bit to record whether we have already
7669              generated the necessary reloc.  */
7670           if ((off & 1) != 0)
7671             off &= ~1;
7672           else
7673             {
7674               /* If we are addressing a Thumb function, we need to
7675                  adjust the address by one, so that attempts to
7676                  call the function pointer will correctly
7677                  interpret it as Thumb code.  */
7678               if (sym_flags == STT_ARM_TFUNC)
7679                 value |= 1;
7680
7681               if (globals->use_rel)
7682                 bfd_put_32 (output_bfd, value, sgot->contents + off);
7683
7684               if (info->shared)
7685                 {
7686                   asection * srelgot;
7687                   Elf_Internal_Rela outrel;
7688                   bfd_byte *loc;
7689
7690                   srelgot = (bfd_get_section_by_name
7691                              (dynobj, RELOC_SECTION (globals, ".got")));
7692                   BFD_ASSERT (srelgot != NULL);
7693
7694                   outrel.r_addend = addend + value;
7695                   outrel.r_offset = (sgot->output_section->vma
7696                                      + sgot->output_offset
7697                                      + off);
7698                   outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
7699                   loc = srelgot->contents;
7700                   loc += srelgot->reloc_count++ * RELOC_SIZE (globals);
7701                   SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
7702                 }
7703
7704               local_got_offsets[r_symndx] |= 1;
7705             }
7706
7707           value = sgot->output_offset + off;
7708         }
7709       if (r_type != R_ARM_GOT32)
7710         value += sgot->output_section->vma;
7711
7712       return _bfd_final_link_relocate (howto, input_bfd, input_section,
7713                                        contents, rel->r_offset, value,
7714                                        rel->r_addend);
7715
7716     case R_ARM_TLS_LDO32:
7717       value = value - dtpoff_base (info);
7718
7719       return _bfd_final_link_relocate (howto, input_bfd, input_section,
7720                                        contents, rel->r_offset, value,
7721                                        rel->r_addend);
7722
7723     case R_ARM_TLS_LDM32:
7724       {
7725         bfd_vma off;
7726
7727         if (globals->sgot == NULL)
7728           abort ();
7729
7730         off = globals->tls_ldm_got.offset;
7731
7732         if ((off & 1) != 0)
7733           off &= ~1;
7734         else
7735           {
7736             /* If we don't know the module number, create a relocation
7737                for it.  */
7738             if (info->shared)
7739               {
7740                 Elf_Internal_Rela outrel;
7741                 bfd_byte *loc;
7742
7743                 if (globals->srelgot == NULL)
7744                   abort ();
7745
7746                 outrel.r_addend = 0;
7747                 outrel.r_offset = (globals->sgot->output_section->vma
7748                                    + globals->sgot->output_offset + off);
7749                 outrel.r_info = ELF32_R_INFO (0, R_ARM_TLS_DTPMOD32);
7750
7751                 if (globals->use_rel)
7752                   bfd_put_32 (output_bfd, outrel.r_addend,
7753                               globals->sgot->contents + off);
7754
7755                 loc = globals->srelgot->contents;
7756                 loc += globals->srelgot->reloc_count++ * RELOC_SIZE (globals);
7757                 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
7758               }
7759             else
7760               bfd_put_32 (output_bfd, 1, globals->sgot->contents + off);
7761
7762             globals->tls_ldm_got.offset |= 1;
7763           }
7764
7765         value = globals->sgot->output_section->vma + globals->sgot->output_offset + off
7766           - (input_section->output_section->vma + input_section->output_offset + rel->r_offset);
7767
7768         return _bfd_final_link_relocate (howto, input_bfd, input_section,
7769                                          contents, rel->r_offset, value,
7770                                          rel->r_addend);
7771       }
7772
7773     case R_ARM_TLS_GD32:
7774     case R_ARM_TLS_IE32:
7775       {
7776         bfd_vma off;
7777         int indx;
7778         char tls_type;
7779
7780         if (globals->sgot == NULL)
7781           abort ();
7782
7783         indx = 0;
7784         if (h != NULL)
7785           {
7786             bfd_boolean dyn;
7787             dyn = globals->root.dynamic_sections_created;
7788             if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
7789                 && (!info->shared
7790                     || !SYMBOL_REFERENCES_LOCAL (info, h)))
7791               {
7792                 *unresolved_reloc_p = FALSE;
7793                 indx = h->dynindx;
7794               }
7795             off = h->got.offset;
7796             tls_type = ((struct elf32_arm_link_hash_entry *) h)->tls_type;
7797           }
7798         else
7799           {
7800             if (local_got_offsets == NULL)
7801               abort ();
7802             off = local_got_offsets[r_symndx];
7803             tls_type = elf32_arm_local_got_tls_type (input_bfd)[r_symndx];
7804           }
7805
7806         if (tls_type == GOT_UNKNOWN)
7807           abort ();
7808
7809         if ((off & 1) != 0)
7810           off &= ~1;
7811         else
7812           {
7813             bfd_boolean need_relocs = FALSE;
7814             Elf_Internal_Rela outrel;
7815             bfd_byte *loc = NULL;
7816             int cur_off = off;
7817
7818             /* The GOT entries have not been initialized yet.  Do it
7819                now, and emit any relocations.  If both an IE GOT and a
7820                GD GOT are necessary, we emit the GD first.  */
7821
7822             if ((info->shared || indx != 0)
7823                 && (h == NULL
7824                     || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
7825                     || h->root.type != bfd_link_hash_undefweak))
7826               {
7827                 need_relocs = TRUE;
7828                 if (globals->srelgot == NULL)
7829                   abort ();
7830                 loc = globals->srelgot->contents;
7831                 loc += globals->srelgot->reloc_count * RELOC_SIZE (globals);
7832               }
7833
7834             if (tls_type & GOT_TLS_GD)
7835               {
7836                 if (need_relocs)
7837                   {
7838                     outrel.r_addend = 0;
7839                     outrel.r_offset = (globals->sgot->output_section->vma
7840                                        + globals->sgot->output_offset
7841                                        + cur_off);
7842                     outrel.r_info = ELF32_R_INFO (indx, R_ARM_TLS_DTPMOD32);
7843
7844                     if (globals->use_rel)
7845                       bfd_put_32 (output_bfd, outrel.r_addend,
7846                                   globals->sgot->contents + cur_off);
7847
7848                     SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
7849                     globals->srelgot->reloc_count++;
7850                     loc += RELOC_SIZE (globals);
7851
7852                     if (indx == 0)
7853                       bfd_put_32 (output_bfd, value - dtpoff_base (info),
7854                                   globals->sgot->contents + cur_off + 4);
7855                     else
7856                       {
7857                         outrel.r_addend = 0;
7858                         outrel.r_info = ELF32_R_INFO (indx,
7859                                                       R_ARM_TLS_DTPOFF32);
7860                         outrel.r_offset += 4;
7861
7862                         if (globals->use_rel)
7863                           bfd_put_32 (output_bfd, outrel.r_addend,
7864                                       globals->sgot->contents + cur_off + 4);
7865
7866
7867                         SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
7868                         globals->srelgot->reloc_count++;
7869                         loc += RELOC_SIZE (globals);
7870                       }
7871                   }
7872                 else
7873                   {
7874                     /* If we are not emitting relocations for a
7875                        general dynamic reference, then we must be in a
7876                        static link or an executable link with the
7877                        symbol binding locally.  Mark it as belonging
7878                        to module 1, the executable.  */
7879                     bfd_put_32 (output_bfd, 1,
7880                                 globals->sgot->contents + cur_off);
7881                     bfd_put_32 (output_bfd, value - dtpoff_base (info),
7882                                 globals->sgot->contents + cur_off + 4);
7883                   }
7884
7885                 cur_off += 8;
7886               }
7887
7888             if (tls_type & GOT_TLS_IE)
7889               {
7890                 if (need_relocs)
7891                   {
7892                     if (indx == 0)
7893                       outrel.r_addend = value - dtpoff_base (info);
7894                     else
7895                       outrel.r_addend = 0;
7896                     outrel.r_offset = (globals->sgot->output_section->vma
7897                                        + globals->sgot->output_offset
7898                                        + cur_off);
7899                     outrel.r_info = ELF32_R_INFO (indx, R_ARM_TLS_TPOFF32);
7900
7901                     if (globals->use_rel)
7902                       bfd_put_32 (output_bfd, outrel.r_addend,
7903                                   globals->sgot->contents + cur_off);
7904
7905                     SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
7906                     globals->srelgot->reloc_count++;
7907                     loc += RELOC_SIZE (globals);
7908                   }
7909                 else
7910                   bfd_put_32 (output_bfd, tpoff (info, value),
7911                               globals->sgot->contents + cur_off);
7912                 cur_off += 4;
7913               }
7914
7915             if (h != NULL)
7916               h->got.offset |= 1;
7917             else
7918               local_got_offsets[r_symndx] |= 1;
7919           }
7920
7921         if ((tls_type & GOT_TLS_GD) && r_type != R_ARM_TLS_GD32)
7922           off += 8;
7923         value = globals->sgot->output_section->vma + globals->sgot->output_offset + off
7924           - (input_section->output_section->vma + input_section->output_offset + rel->r_offset);
7925
7926         return _bfd_final_link_relocate (howto, input_bfd, input_section,
7927                                          contents, rel->r_offset, value,
7928                                          rel->r_addend);
7929       }
7930
7931     case R_ARM_TLS_LE32:
7932       if (info->shared)
7933         {
7934           (*_bfd_error_handler)
7935             (_("%B(%A+0x%lx): R_ARM_TLS_LE32 relocation not permitted in shared object"),
7936              input_bfd, input_section,
7937              (long) rel->r_offset, howto->name);
7938           return FALSE;
7939         }
7940       else
7941         value = tpoff (info, value);
7942
7943       return _bfd_final_link_relocate (howto, input_bfd, input_section,
7944                                        contents, rel->r_offset, value,
7945                                        rel->r_addend);
7946
7947     case R_ARM_V4BX:
7948       if (globals->fix_v4bx)
7949         {
7950           bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
7951
7952           /* Ensure that we have a BX instruction.  */
7953           BFD_ASSERT ((insn & 0x0ffffff0) == 0x012fff10);
7954
7955           if (globals->fix_v4bx == 2 && (insn & 0xf) != 0xf)
7956             {
7957               /* Branch to veneer.  */
7958               bfd_vma glue_addr;
7959               glue_addr = elf32_arm_bx_glue (info, insn & 0xf);
7960               glue_addr -= input_section->output_section->vma
7961                            + input_section->output_offset
7962                            + rel->r_offset + 8;
7963               insn = (insn & 0xf0000000) | 0x0a000000
7964                      | ((glue_addr >> 2) & 0x00ffffff);
7965             }
7966           else
7967             {
7968               /* Preserve Rm (lowest four bits) and the condition code
7969                  (highest four bits). Other bits encode MOV PC,Rm.  */
7970               insn = (insn & 0xf000000f) | 0x01a0f000;
7971             }
7972
7973           bfd_put_32 (input_bfd, insn, hit_data);
7974         }
7975       return bfd_reloc_ok;
7976
7977     case R_ARM_MOVW_ABS_NC:
7978     case R_ARM_MOVT_ABS:
7979     case R_ARM_MOVW_PREL_NC:
7980     case R_ARM_MOVT_PREL:
7981     /* Until we properly support segment-base-relative addressing then
7982        we assume the segment base to be zero, as for the group relocations.
7983        Thus R_ARM_MOVW_BREL_NC has the same semantics as R_ARM_MOVW_ABS_NC
7984        and R_ARM_MOVT_BREL has the same semantics as R_ARM_MOVT_ABS.  */
7985     case R_ARM_MOVW_BREL_NC:
7986     case R_ARM_MOVW_BREL:
7987     case R_ARM_MOVT_BREL:
7988       {
7989         bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
7990
7991         if (globals->use_rel)
7992           {
7993             addend = ((insn >> 4) & 0xf000) | (insn & 0xfff);
7994             signed_addend = (addend ^ 0x8000) - 0x8000;
7995           }
7996
7997         value += signed_addend;
7998
7999         if (r_type == R_ARM_MOVW_PREL_NC || r_type == R_ARM_MOVT_PREL)
8000           value -= (input_section->output_section->vma
8001                     + input_section->output_offset + rel->r_offset);
8002
8003         if (r_type == R_ARM_MOVW_BREL && value >= 0x10000)
8004           return bfd_reloc_overflow;
8005
8006         if (sym_flags == STT_ARM_TFUNC)
8007           value |= 1;
8008
8009         if (r_type == R_ARM_MOVT_ABS || r_type == R_ARM_MOVT_PREL
8010             || r_type == R_ARM_MOVT_BREL)
8011           value >>= 16;
8012
8013         insn &= 0xfff0f000;
8014         insn |= value & 0xfff;
8015         insn |= (value & 0xf000) << 4;
8016         bfd_put_32 (input_bfd, insn, hit_data);
8017       }
8018       return bfd_reloc_ok;
8019
8020     case R_ARM_THM_MOVW_ABS_NC:
8021     case R_ARM_THM_MOVT_ABS:
8022     case R_ARM_THM_MOVW_PREL_NC:
8023     case R_ARM_THM_MOVT_PREL:
8024     /* Until we properly support segment-base-relative addressing then
8025        we assume the segment base to be zero, as for the above relocations.
8026        Thus R_ARM_THM_MOVW_BREL_NC has the same semantics as
8027        R_ARM_THM_MOVW_ABS_NC and R_ARM_THM_MOVT_BREL has the same semantics
8028        as R_ARM_THM_MOVT_ABS.  */
8029     case R_ARM_THM_MOVW_BREL_NC:
8030     case R_ARM_THM_MOVW_BREL:
8031     case R_ARM_THM_MOVT_BREL:
8032       {
8033         bfd_vma insn;
8034
8035         insn = bfd_get_16 (input_bfd, hit_data) << 16;
8036         insn |= bfd_get_16 (input_bfd, hit_data + 2);
8037
8038         if (globals->use_rel)
8039           {
8040             addend = ((insn >> 4)  & 0xf000)
8041                    | ((insn >> 15) & 0x0800)
8042                    | ((insn >> 4)  & 0x0700)
8043                    | (insn         & 0x00ff);
8044             signed_addend = (addend ^ 0x8000) - 0x8000;
8045           }
8046
8047         value += signed_addend;
8048
8049         if (r_type == R_ARM_THM_MOVW_PREL_NC || r_type == R_ARM_THM_MOVT_PREL)
8050           value -= (input_section->output_section->vma
8051                     + input_section->output_offset + rel->r_offset);
8052
8053         if (r_type == R_ARM_THM_MOVW_BREL && value >= 0x10000)
8054           return bfd_reloc_overflow;
8055
8056         if (sym_flags == STT_ARM_TFUNC)
8057           value |= 1;
8058
8059         if (r_type == R_ARM_THM_MOVT_ABS || r_type == R_ARM_THM_MOVT_PREL
8060             || r_type == R_ARM_THM_MOVT_BREL)
8061           value >>= 16;
8062
8063         insn &= 0xfbf08f00;
8064         insn |= (value & 0xf000) << 4;
8065         insn |= (value & 0x0800) << 15;
8066         insn |= (value & 0x0700) << 4;
8067         insn |= (value & 0x00ff);
8068
8069         bfd_put_16 (input_bfd, insn >> 16, hit_data);
8070         bfd_put_16 (input_bfd, insn & 0xffff, hit_data + 2);
8071       }
8072       return bfd_reloc_ok;
8073
8074     case R_ARM_ALU_PC_G0_NC:
8075     case R_ARM_ALU_PC_G1_NC:
8076     case R_ARM_ALU_PC_G0:
8077     case R_ARM_ALU_PC_G1:
8078     case R_ARM_ALU_PC_G2:
8079     case R_ARM_ALU_SB_G0_NC:
8080     case R_ARM_ALU_SB_G1_NC:
8081     case R_ARM_ALU_SB_G0:
8082     case R_ARM_ALU_SB_G1:
8083     case R_ARM_ALU_SB_G2:
8084       {
8085         bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
8086         bfd_vma pc = input_section->output_section->vma
8087                      + input_section->output_offset + rel->r_offset;
8088         /* sb should be the origin of the *segment* containing the symbol.
8089            It is not clear how to obtain this OS-dependent value, so we
8090            make an arbitrary choice of zero.  */
8091         bfd_vma sb = 0;
8092         bfd_vma residual;
8093         bfd_vma g_n;
8094         bfd_signed_vma signed_value;
8095         int group = 0;
8096
8097         /* Determine which group of bits to select.  */
8098         switch (r_type)
8099           {
8100           case R_ARM_ALU_PC_G0_NC:
8101           case R_ARM_ALU_PC_G0:
8102           case R_ARM_ALU_SB_G0_NC:
8103           case R_ARM_ALU_SB_G0:
8104             group = 0;
8105             break;
8106
8107           case R_ARM_ALU_PC_G1_NC:
8108           case R_ARM_ALU_PC_G1:
8109           case R_ARM_ALU_SB_G1_NC:
8110           case R_ARM_ALU_SB_G1:
8111             group = 1;
8112             break;
8113
8114           case R_ARM_ALU_PC_G2:
8115           case R_ARM_ALU_SB_G2:
8116             group = 2;
8117             break;
8118
8119           default:
8120             abort ();
8121           }
8122
8123         /* If REL, extract the addend from the insn.  If RELA, it will
8124            have already been fetched for us.  */
8125         if (globals->use_rel)
8126           {
8127             int negative;
8128             bfd_vma constant = insn & 0xff;
8129             bfd_vma rotation = (insn & 0xf00) >> 8;
8130
8131             if (rotation == 0)
8132               signed_addend = constant;
8133             else
8134               {
8135                 /* Compensate for the fact that in the instruction, the
8136                    rotation is stored in multiples of 2 bits.  */
8137                 rotation *= 2;
8138
8139                 /* Rotate "constant" right by "rotation" bits.  */
8140                 signed_addend = (constant >> rotation) |
8141                                 (constant << (8 * sizeof (bfd_vma) - rotation));
8142               }
8143
8144             /* Determine if the instruction is an ADD or a SUB.
8145                (For REL, this determines the sign of the addend.)  */
8146             negative = identify_add_or_sub (insn);
8147             if (negative == 0)
8148               {
8149                 (*_bfd_error_handler)
8150                   (_("%B(%A+0x%lx): Only ADD or SUB instructions are allowed for ALU group relocations"),
8151                   input_bfd, input_section,
8152                   (long) rel->r_offset, howto->name);
8153                 return bfd_reloc_overflow;
8154               }
8155
8156             signed_addend *= negative;
8157           }
8158
8159         /* Compute the value (X) to go in the place.  */
8160         if (r_type == R_ARM_ALU_PC_G0_NC
8161             || r_type == R_ARM_ALU_PC_G1_NC
8162             || r_type == R_ARM_ALU_PC_G0
8163             || r_type == R_ARM_ALU_PC_G1
8164             || r_type == R_ARM_ALU_PC_G2)
8165           /* PC relative.  */
8166           signed_value = value - pc + signed_addend;
8167         else
8168           /* Section base relative.  */
8169           signed_value = value - sb + signed_addend;
8170
8171         /* If the target symbol is a Thumb function, then set the
8172            Thumb bit in the address.  */
8173         if (sym_flags == STT_ARM_TFUNC)
8174           signed_value |= 1;
8175
8176         /* Calculate the value of the relevant G_n, in encoded
8177            constant-with-rotation format.  */
8178         g_n = calculate_group_reloc_mask (abs (signed_value), group,
8179                                           &residual);
8180
8181         /* Check for overflow if required.  */
8182         if ((r_type == R_ARM_ALU_PC_G0
8183              || r_type == R_ARM_ALU_PC_G1
8184              || r_type == R_ARM_ALU_PC_G2
8185              || r_type == R_ARM_ALU_SB_G0
8186              || r_type == R_ARM_ALU_SB_G1
8187              || r_type == R_ARM_ALU_SB_G2) && residual != 0)
8188           {
8189             (*_bfd_error_handler)
8190               (_("%B(%A+0x%lx): Overflow whilst splitting 0x%lx for group relocation %s"),
8191               input_bfd, input_section,
8192               (long) rel->r_offset, abs (signed_value), howto->name);
8193             return bfd_reloc_overflow;
8194           }
8195
8196         /* Mask out the value and the ADD/SUB part of the opcode; take care
8197            not to destroy the S bit.  */
8198         insn &= 0xff1ff000;
8199
8200         /* Set the opcode according to whether the value to go in the
8201            place is negative.  */
8202         if (signed_value < 0)
8203           insn |= 1 << 22;
8204         else
8205           insn |= 1 << 23;
8206
8207         /* Encode the offset.  */
8208         insn |= g_n;
8209
8210         bfd_put_32 (input_bfd, insn, hit_data);
8211       }
8212       return bfd_reloc_ok;
8213
8214     case R_ARM_LDR_PC_G0:
8215     case R_ARM_LDR_PC_G1:
8216     case R_ARM_LDR_PC_G2:
8217     case R_ARM_LDR_SB_G0:
8218     case R_ARM_LDR_SB_G1:
8219     case R_ARM_LDR_SB_G2:
8220       {
8221         bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
8222         bfd_vma pc = input_section->output_section->vma
8223                      + input_section->output_offset + rel->r_offset;
8224         bfd_vma sb = 0; /* See note above.  */
8225         bfd_vma residual;
8226         bfd_signed_vma signed_value;
8227         int group = 0;
8228
8229         /* Determine which groups of bits to calculate.  */
8230         switch (r_type)
8231           {
8232           case R_ARM_LDR_PC_G0:
8233           case R_ARM_LDR_SB_G0:
8234             group = 0;
8235             break;
8236
8237           case R_ARM_LDR_PC_G1:
8238           case R_ARM_LDR_SB_G1:
8239             group = 1;
8240             break;
8241
8242           case R_ARM_LDR_PC_G2:
8243           case R_ARM_LDR_SB_G2:
8244             group = 2;
8245             break;
8246
8247           default:
8248             abort ();
8249           }
8250
8251         /* If REL, extract the addend from the insn.  If RELA, it will
8252            have already been fetched for us.  */
8253         if (globals->use_rel)
8254           {
8255             int negative = (insn & (1 << 23)) ? 1 : -1;
8256             signed_addend = negative * (insn & 0xfff);
8257           }
8258
8259         /* Compute the value (X) to go in the place.  */
8260         if (r_type == R_ARM_LDR_PC_G0
8261             || r_type == R_ARM_LDR_PC_G1
8262             || r_type == R_ARM_LDR_PC_G2)
8263           /* PC relative.  */
8264           signed_value = value - pc + signed_addend;
8265         else
8266           /* Section base relative.  */
8267           signed_value = value - sb + signed_addend;
8268
8269         /* Calculate the value of the relevant G_{n-1} to obtain
8270            the residual at that stage.  */
8271         calculate_group_reloc_mask (abs (signed_value), group - 1, &residual);
8272
8273         /* Check for overflow.  */
8274         if (residual >= 0x1000)
8275           {
8276             (*_bfd_error_handler)
8277               (_("%B(%A+0x%lx): Overflow whilst splitting 0x%lx for group relocation %s"),
8278               input_bfd, input_section,
8279               (long) rel->r_offset, abs (signed_value), howto->name);
8280             return bfd_reloc_overflow;
8281           }
8282
8283         /* Mask out the value and U bit.  */
8284         insn &= 0xff7ff000;
8285
8286         /* Set the U bit if the value to go in the place is non-negative.  */
8287         if (signed_value >= 0)
8288           insn |= 1 << 23;
8289
8290         /* Encode the offset.  */
8291         insn |= residual;
8292
8293         bfd_put_32 (input_bfd, insn, hit_data);
8294       }
8295       return bfd_reloc_ok;
8296
8297     case R_ARM_LDRS_PC_G0:
8298     case R_ARM_LDRS_PC_G1:
8299     case R_ARM_LDRS_PC_G2:
8300     case R_ARM_LDRS_SB_G0:
8301     case R_ARM_LDRS_SB_G1:
8302     case R_ARM_LDRS_SB_G2:
8303       {
8304         bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
8305         bfd_vma pc = input_section->output_section->vma
8306                      + input_section->output_offset + rel->r_offset;
8307         bfd_vma sb = 0; /* See note above.  */
8308         bfd_vma residual;
8309         bfd_signed_vma signed_value;
8310         int group = 0;
8311
8312         /* Determine which groups of bits to calculate.  */
8313         switch (r_type)
8314           {
8315           case R_ARM_LDRS_PC_G0:
8316           case R_ARM_LDRS_SB_G0:
8317             group = 0;
8318             break;
8319
8320           case R_ARM_LDRS_PC_G1:
8321           case R_ARM_LDRS_SB_G1:
8322             group = 1;
8323             break;
8324
8325           case R_ARM_LDRS_PC_G2:
8326           case R_ARM_LDRS_SB_G2:
8327             group = 2;
8328             break;
8329
8330           default:
8331             abort ();
8332           }
8333
8334         /* If REL, extract the addend from the insn.  If RELA, it will
8335            have already been fetched for us.  */
8336         if (globals->use_rel)
8337           {
8338             int negative = (insn & (1 << 23)) ? 1 : -1;
8339             signed_addend = negative * (((insn & 0xf00) >> 4) + (insn & 0xf));
8340           }
8341
8342         /* Compute the value (X) to go in the place.  */
8343         if (r_type == R_ARM_LDRS_PC_G0
8344             || r_type == R_ARM_LDRS_PC_G1
8345             || r_type == R_ARM_LDRS_PC_G2)
8346           /* PC relative.  */
8347           signed_value = value - pc + signed_addend;
8348         else
8349           /* Section base relative.  */
8350           signed_value = value - sb + signed_addend;
8351
8352         /* Calculate the value of the relevant G_{n-1} to obtain
8353            the residual at that stage.  */
8354         calculate_group_reloc_mask (abs (signed_value), group - 1, &residual);
8355
8356         /* Check for overflow.  */
8357         if (residual >= 0x100)
8358           {
8359             (*_bfd_error_handler)
8360               (_("%B(%A+0x%lx): Overflow whilst splitting 0x%lx for group relocation %s"),
8361               input_bfd, input_section,
8362               (long) rel->r_offset, abs (signed_value), howto->name);
8363             return bfd_reloc_overflow;
8364           }
8365
8366         /* Mask out the value and U bit.  */
8367         insn &= 0xff7ff0f0;
8368
8369         /* Set the U bit if the value to go in the place is non-negative.  */
8370         if (signed_value >= 0)
8371           insn |= 1 << 23;
8372
8373         /* Encode the offset.  */
8374         insn |= ((residual & 0xf0) << 4) | (residual & 0xf);
8375
8376         bfd_put_32 (input_bfd, insn, hit_data);
8377       }
8378       return bfd_reloc_ok;
8379
8380     case R_ARM_LDC_PC_G0:
8381     case R_ARM_LDC_PC_G1:
8382     case R_ARM_LDC_PC_G2:
8383     case R_ARM_LDC_SB_G0:
8384     case R_ARM_LDC_SB_G1:
8385     case R_ARM_LDC_SB_G2:
8386       {
8387         bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
8388         bfd_vma pc = input_section->output_section->vma
8389                      + input_section->output_offset + rel->r_offset;
8390         bfd_vma sb = 0; /* See note above.  */
8391         bfd_vma residual;
8392         bfd_signed_vma signed_value;
8393         int group = 0;
8394
8395         /* Determine which groups of bits to calculate.  */
8396         switch (r_type)
8397           {
8398           case R_ARM_LDC_PC_G0:
8399           case R_ARM_LDC_SB_G0:
8400             group = 0;
8401             break;
8402
8403           case R_ARM_LDC_PC_G1:
8404           case R_ARM_LDC_SB_G1:
8405             group = 1;
8406             break;
8407
8408           case R_ARM_LDC_PC_G2:
8409           case R_ARM_LDC_SB_G2:
8410             group = 2;
8411             break;
8412
8413           default:
8414             abort ();
8415           }
8416
8417         /* If REL, extract the addend from the insn.  If RELA, it will
8418            have already been fetched for us.  */
8419         if (globals->use_rel)
8420           {
8421             int negative = (insn & (1 << 23)) ? 1 : -1;
8422             signed_addend = negative * ((insn & 0xff) << 2);
8423           }
8424
8425         /* Compute the value (X) to go in the place.  */
8426         if (r_type == R_ARM_LDC_PC_G0
8427             || r_type == R_ARM_LDC_PC_G1
8428             || r_type == R_ARM_LDC_PC_G2)
8429           /* PC relative.  */
8430           signed_value = value - pc + signed_addend;
8431         else
8432           /* Section base relative.  */
8433           signed_value = value - sb + signed_addend;
8434
8435         /* Calculate the value of the relevant G_{n-1} to obtain
8436            the residual at that stage.  */
8437         calculate_group_reloc_mask (abs (signed_value), group - 1, &residual);
8438
8439         /* Check for overflow.  (The absolute value to go in the place must be
8440            divisible by four and, after having been divided by four, must
8441            fit in eight bits.)  */
8442         if ((residual & 0x3) != 0 || residual >= 0x400)
8443           {
8444             (*_bfd_error_handler)
8445               (_("%B(%A+0x%lx): Overflow whilst splitting 0x%lx for group relocation %s"),
8446               input_bfd, input_section,
8447               (long) rel->r_offset, abs (signed_value), howto->name);
8448             return bfd_reloc_overflow;
8449           }
8450
8451         /* Mask out the value and U bit.  */
8452         insn &= 0xff7fff00;
8453
8454         /* Set the U bit if the value to go in the place is non-negative.  */
8455         if (signed_value >= 0)
8456           insn |= 1 << 23;
8457
8458         /* Encode the offset.  */
8459         insn |= residual >> 2;
8460
8461         bfd_put_32 (input_bfd, insn, hit_data);
8462       }
8463       return bfd_reloc_ok;
8464
8465     default:
8466       return bfd_reloc_notsupported;
8467     }
8468 }
8469
8470 /* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS.  */
8471 static void
8472 arm_add_to_rel (bfd *              abfd,
8473                 bfd_byte *         address,
8474                 reloc_howto_type * howto,
8475                 bfd_signed_vma     increment)
8476 {
8477   bfd_signed_vma addend;
8478
8479   if (howto->type == R_ARM_THM_CALL
8480       || howto->type == R_ARM_THM_JUMP24)
8481     {
8482       int upper_insn, lower_insn;
8483       int upper, lower;
8484
8485       upper_insn = bfd_get_16 (abfd, address);
8486       lower_insn = bfd_get_16 (abfd, address + 2);
8487       upper = upper_insn & 0x7ff;
8488       lower = lower_insn & 0x7ff;
8489
8490       addend = (upper << 12) | (lower << 1);
8491       addend += increment;
8492       addend >>= 1;
8493
8494       upper_insn = (upper_insn & 0xf800) | ((addend >> 11) & 0x7ff);
8495       lower_insn = (lower_insn & 0xf800) | (addend & 0x7ff);
8496
8497       bfd_put_16 (abfd, (bfd_vma) upper_insn, address);
8498       bfd_put_16 (abfd, (bfd_vma) lower_insn, address + 2);
8499     }
8500   else
8501     {
8502       bfd_vma        contents;
8503
8504       contents = bfd_get_32 (abfd, address);
8505
8506       /* Get the (signed) value from the instruction.  */
8507       addend = contents & howto->src_mask;
8508       if (addend & ((howto->src_mask + 1) >> 1))
8509         {
8510           bfd_signed_vma mask;
8511
8512           mask = -1;
8513           mask &= ~ howto->src_mask;
8514           addend |= mask;
8515         }
8516
8517       /* Add in the increment, (which is a byte value).  */
8518       switch (howto->type)
8519         {
8520         default:
8521           addend += increment;
8522           break;
8523
8524         case R_ARM_PC24:
8525         case R_ARM_PLT32:
8526         case R_ARM_CALL:
8527         case R_ARM_JUMP24:
8528           addend <<= howto->size;
8529           addend += increment;
8530
8531           /* Should we check for overflow here ?  */
8532
8533           /* Drop any undesired bits.  */
8534           addend >>= howto->rightshift;
8535           break;
8536         }
8537
8538       contents = (contents & ~ howto->dst_mask) | (addend & howto->dst_mask);
8539
8540       bfd_put_32 (abfd, contents, address);
8541     }
8542 }
8543
8544 #define IS_ARM_TLS_RELOC(R_TYPE)        \
8545   ((R_TYPE) == R_ARM_TLS_GD32           \
8546    || (R_TYPE) == R_ARM_TLS_LDO32       \
8547    || (R_TYPE) == R_ARM_TLS_LDM32       \
8548    || (R_TYPE) == R_ARM_TLS_DTPOFF32    \
8549    || (R_TYPE) == R_ARM_TLS_DTPMOD32    \
8550    || (R_TYPE) == R_ARM_TLS_TPOFF32     \
8551    || (R_TYPE) == R_ARM_TLS_LE32        \
8552    || (R_TYPE) == R_ARM_TLS_IE32)
8553
8554 /* Relocate an ARM ELF section.  */
8555
8556 static bfd_boolean
8557 elf32_arm_relocate_section (bfd *                  output_bfd,
8558                             struct bfd_link_info * info,
8559                             bfd *                  input_bfd,
8560                             asection *             input_section,
8561                             bfd_byte *             contents,
8562                             Elf_Internal_Rela *    relocs,
8563                             Elf_Internal_Sym *     local_syms,
8564                             asection **            local_sections)
8565 {
8566   Elf_Internal_Shdr *symtab_hdr;
8567   struct elf_link_hash_entry **sym_hashes;
8568   Elf_Internal_Rela *rel;
8569   Elf_Internal_Rela *relend;
8570   const char *name;
8571   struct elf32_arm_link_hash_table * globals;
8572
8573   globals = elf32_arm_hash_table (info);
8574
8575   symtab_hdr = & elf_symtab_hdr (input_bfd);
8576   sym_hashes = elf_sym_hashes (input_bfd);
8577
8578   rel = relocs;
8579   relend = relocs + input_section->reloc_count;
8580   for (; rel < relend; rel++)
8581     {
8582       int                          r_type;
8583       reloc_howto_type *           howto;
8584       unsigned long                r_symndx;
8585       Elf_Internal_Sym *           sym;
8586       asection *                   sec;
8587       struct elf_link_hash_entry * h;
8588       bfd_vma                      relocation;
8589       bfd_reloc_status_type        r;
8590       arelent                      bfd_reloc;
8591       char                         sym_type;
8592       bfd_boolean                  unresolved_reloc = FALSE;
8593       char *error_message = NULL;
8594
8595       r_symndx = ELF32_R_SYM (rel->r_info);
8596       r_type   = ELF32_R_TYPE (rel->r_info);
8597       r_type   = arm_real_reloc_type (globals, r_type);
8598
8599       if (   r_type == R_ARM_GNU_VTENTRY
8600           || r_type == R_ARM_GNU_VTINHERIT)
8601         continue;
8602
8603       bfd_reloc.howto = elf32_arm_howto_from_type (r_type);
8604       howto = bfd_reloc.howto;
8605
8606       h = NULL;
8607       sym = NULL;
8608       sec = NULL;
8609
8610       if (r_symndx < symtab_hdr->sh_info)
8611         {
8612           sym = local_syms + r_symndx;
8613           sym_type = ELF32_ST_TYPE (sym->st_info);
8614           sec = local_sections[r_symndx];
8615           if (globals->use_rel)
8616             {
8617               relocation = (sec->output_section->vma
8618                             + sec->output_offset
8619                             + sym->st_value);
8620               if (!info->relocatable
8621                   && (sec->flags & SEC_MERGE)
8622                   && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
8623                 {
8624                   asection *msec;
8625                   bfd_vma addend, value;
8626
8627                   switch (r_type)
8628                     {
8629                     case R_ARM_MOVW_ABS_NC:
8630                     case R_ARM_MOVT_ABS:
8631                       value = bfd_get_32 (input_bfd, contents + rel->r_offset);
8632                       addend = ((value & 0xf0000) >> 4) | (value & 0xfff);
8633                       addend = (addend ^ 0x8000) - 0x8000;
8634                       break;
8635
8636                     case R_ARM_THM_MOVW_ABS_NC:
8637                     case R_ARM_THM_MOVT_ABS:
8638                       value = bfd_get_16 (input_bfd, contents + rel->r_offset)
8639                               << 16;
8640                       value |= bfd_get_16 (input_bfd,
8641                                            contents + rel->r_offset + 2);
8642                       addend = ((value & 0xf7000) >> 4) | (value & 0xff)
8643                                | ((value & 0x04000000) >> 15);
8644                       addend = (addend ^ 0x8000) - 0x8000;
8645                       break;
8646
8647                     default:
8648                       if (howto->rightshift
8649                           || (howto->src_mask & (howto->src_mask + 1)))
8650                         {
8651                           (*_bfd_error_handler)
8652                             (_("%B(%A+0x%lx): %s relocation against SEC_MERGE section"),
8653                              input_bfd, input_section,
8654                              (long) rel->r_offset, howto->name);
8655                           return FALSE;
8656                         }
8657
8658                       value = bfd_get_32 (input_bfd, contents + rel->r_offset);
8659
8660                       /* Get the (signed) value from the instruction.  */
8661                       addend = value & howto->src_mask;
8662                       if (addend & ((howto->src_mask + 1) >> 1))
8663                         {
8664                           bfd_signed_vma mask;
8665
8666                           mask = -1;
8667                           mask &= ~ howto->src_mask;
8668                           addend |= mask;
8669                         }
8670                       break;
8671                     }
8672
8673                   msec = sec;
8674                   addend =
8675                     _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend)
8676                     - relocation;
8677                   addend += msec->output_section->vma + msec->output_offset;
8678
8679                   /* Cases here must match those in the preceeding
8680                      switch statement.  */
8681                   switch (r_type)
8682                     {
8683                     case R_ARM_MOVW_ABS_NC:
8684                     case R_ARM_MOVT_ABS:
8685                       value = (value & 0xfff0f000) | ((addend & 0xf000) << 4)
8686                               | (addend & 0xfff);
8687                       bfd_put_32 (input_bfd, value, contents + rel->r_offset);
8688                       break;
8689
8690                     case R_ARM_THM_MOVW_ABS_NC:
8691                     case R_ARM_THM_MOVT_ABS:
8692                       value = (value & 0xfbf08f00) | ((addend & 0xf700) << 4)
8693                               | (addend & 0xff) | ((addend & 0x0800) << 15);
8694                       bfd_put_16 (input_bfd, value >> 16,
8695                                   contents + rel->r_offset);
8696                       bfd_put_16 (input_bfd, value,
8697                                   contents + rel->r_offset + 2);
8698                       break;
8699
8700                     default:
8701                       value = (value & ~ howto->dst_mask)
8702                               | (addend & howto->dst_mask);
8703                       bfd_put_32 (input_bfd, value, contents + rel->r_offset);
8704                       break;
8705                     }
8706                 }
8707             }
8708           else
8709             relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
8710         }
8711       else
8712         {
8713           bfd_boolean warned;
8714
8715           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
8716                                    r_symndx, symtab_hdr, sym_hashes,
8717                                    h, sec, relocation,
8718                                    unresolved_reloc, warned);
8719
8720           sym_type = h->type;
8721         }
8722
8723       if (sec != NULL && elf_discarded_section (sec))
8724         {
8725           /* For relocs against symbols from removed linkonce sections,
8726              or sections discarded by a linker script, we just want the
8727              section contents zeroed.  Avoid any special processing.  */
8728           _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
8729           rel->r_info = 0;
8730           rel->r_addend = 0;
8731           continue;
8732         }
8733
8734       if (info->relocatable)
8735         {
8736           /* This is a relocatable link.  We don't have to change
8737              anything, unless the reloc is against a section symbol,
8738              in which case we have to adjust according to where the
8739              section symbol winds up in the output section.  */
8740           if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
8741             {
8742               if (globals->use_rel)
8743                 arm_add_to_rel (input_bfd, contents + rel->r_offset,
8744                                 howto, (bfd_signed_vma) sec->output_offset);
8745               else
8746                 rel->r_addend += sec->output_offset;
8747             }
8748           continue;
8749         }
8750
8751       if (h != NULL)
8752         name = h->root.root.string;
8753       else
8754         {
8755           name = (bfd_elf_string_from_elf_section
8756                   (input_bfd, symtab_hdr->sh_link, sym->st_name));
8757           if (name == NULL || *name == '\0')
8758             name = bfd_section_name (input_bfd, sec);
8759         }
8760
8761       if (r_symndx != 0
8762           && r_type != R_ARM_NONE
8763           && (h == NULL
8764               || h->root.type == bfd_link_hash_defined
8765               || h->root.type == bfd_link_hash_defweak)
8766           && IS_ARM_TLS_RELOC (r_type) != (sym_type == STT_TLS))
8767         {
8768           (*_bfd_error_handler)
8769             ((sym_type == STT_TLS
8770               ? _("%B(%A+0x%lx): %s used with TLS symbol %s")
8771               : _("%B(%A+0x%lx): %s used with non-TLS symbol %s")),
8772              input_bfd,
8773              input_section,
8774              (long) rel->r_offset,
8775              howto->name,
8776              name);
8777         }
8778
8779       r = elf32_arm_final_link_relocate (howto, input_bfd, output_bfd,
8780                                          input_section, contents, rel,
8781                                          relocation, info, sec, name,
8782                                          (h ? ELF_ST_TYPE (h->type) :
8783                                           ELF_ST_TYPE (sym->st_info)), h,
8784                                          &unresolved_reloc, &error_message);
8785
8786       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
8787          because such sections are not SEC_ALLOC and thus ld.so will
8788          not process them.  */
8789       if (unresolved_reloc
8790           && !((input_section->flags & SEC_DEBUGGING) != 0
8791                && h->def_dynamic))
8792         {
8793           (*_bfd_error_handler)
8794             (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
8795              input_bfd,
8796              input_section,
8797              (long) rel->r_offset,
8798              howto->name,
8799              h->root.root.string);
8800           return FALSE;
8801         }
8802
8803       if (r != bfd_reloc_ok)
8804         {
8805           switch (r)
8806             {
8807             case bfd_reloc_overflow:
8808               /* If the overflowing reloc was to an undefined symbol,
8809                  we have already printed one error message and there
8810                  is no point complaining again.  */
8811               if ((! h ||
8812                    h->root.type != bfd_link_hash_undefined)
8813                   && (!((*info->callbacks->reloc_overflow)
8814                         (info, (h ? &h->root : NULL), name, howto->name,
8815                          (bfd_vma) 0, input_bfd, input_section,
8816                          rel->r_offset))))
8817                   return FALSE;
8818               break;
8819
8820             case bfd_reloc_undefined:
8821               if (!((*info->callbacks->undefined_symbol)
8822                     (info, name, input_bfd, input_section,
8823                      rel->r_offset, TRUE)))
8824                 return FALSE;
8825               break;
8826
8827             case bfd_reloc_outofrange:
8828               error_message = _("out of range");
8829               goto common_error;
8830
8831             case bfd_reloc_notsupported:
8832               error_message = _("unsupported relocation");
8833               goto common_error;
8834
8835             case bfd_reloc_dangerous:
8836               /* error_message should already be set.  */
8837               goto common_error;
8838
8839             default:
8840               error_message = _("unknown error");
8841               /* Fall through.  */
8842
8843             common_error:
8844               BFD_ASSERT (error_message != NULL);
8845               if (!((*info->callbacks->reloc_dangerous)
8846                     (info, error_message, input_bfd, input_section,
8847                      rel->r_offset)))
8848                 return FALSE;
8849               break;
8850             }
8851         }
8852     }
8853
8854   return TRUE;
8855 }
8856
8857 /* Add a new unwind edit to the list described by HEAD, TAIL.  If INDEX is zero,
8858    adds the edit to the start of the list.  (The list must be built in order of
8859    ascending INDEX: the function's callers are primarily responsible for
8860    maintaining that condition).  */
8861
8862 static void
8863 add_unwind_table_edit (arm_unwind_table_edit **head,
8864                        arm_unwind_table_edit **tail,
8865                        arm_unwind_edit_type type,
8866                        asection *linked_section,
8867                        unsigned int index)
8868 {
8869   arm_unwind_table_edit *new_edit = xmalloc (sizeof (arm_unwind_table_edit));
8870
8871   new_edit->type = type;
8872   new_edit->linked_section = linked_section;
8873   new_edit->index = index;
8874
8875   if (index > 0)
8876     {
8877       new_edit->next = NULL;
8878
8879       if (*tail)
8880         (*tail)->next = new_edit;
8881
8882       (*tail) = new_edit;
8883
8884       if (!*head)
8885         (*head) = new_edit;
8886     }
8887   else
8888     {
8889       new_edit->next = *head;
8890
8891       if (!*tail)
8892         *tail = new_edit;
8893
8894       *head = new_edit;
8895     }
8896 }
8897
8898 static _arm_elf_section_data *get_arm_elf_section_data (asection *);
8899
8900 /* Increase the size of EXIDX_SEC by ADJUST bytes.  ADJUST mau be negative.  */
8901 static void
8902 adjust_exidx_size(asection *exidx_sec, int adjust)
8903 {
8904   asection *out_sec;
8905
8906   if (!exidx_sec->rawsize)
8907     exidx_sec->rawsize = exidx_sec->size;
8908
8909   bfd_set_section_size (exidx_sec->owner, exidx_sec, exidx_sec->size + adjust);
8910   out_sec = exidx_sec->output_section;
8911   /* Adjust size of output section.  */
8912   bfd_set_section_size (out_sec->owner, out_sec, out_sec->size +adjust);
8913 }
8914
8915 /* Insert an EXIDX_CANTUNWIND marker at the end of a section.  */
8916 static void
8917 insert_cantunwind_after(asection *text_sec, asection *exidx_sec)
8918 {
8919   struct _arm_elf_section_data *exidx_arm_data;
8920
8921   exidx_arm_data = get_arm_elf_section_data (exidx_sec);
8922   add_unwind_table_edit (
8923     &exidx_arm_data->u.exidx.unwind_edit_list,
8924     &exidx_arm_data->u.exidx.unwind_edit_tail,
8925     INSERT_EXIDX_CANTUNWIND_AT_END, text_sec, UINT_MAX);
8926
8927   adjust_exidx_size(exidx_sec, 8);
8928 }
8929
8930 /* Scan .ARM.exidx tables, and create a list describing edits which should be
8931    made to those tables, such that:
8932
8933      1. Regions without unwind data are marked with EXIDX_CANTUNWIND entries.
8934      2. Duplicate entries are merged together (EXIDX_CANTUNWIND, or unwind
8935         codes which have been inlined into the index).
8936
8937    The edits are applied when the tables are written
8938    (in elf32_arm_write_section).
8939 */
8940
8941 bfd_boolean
8942 elf32_arm_fix_exidx_coverage (asection **text_section_order,
8943                               unsigned int num_text_sections,
8944                               struct bfd_link_info *info)
8945 {
8946   bfd *inp;
8947   unsigned int last_second_word = 0, i;
8948   asection *last_exidx_sec = NULL;
8949   asection *last_text_sec = NULL;
8950   int last_unwind_type = -1;
8951
8952   /* Walk over all EXIDX sections, and create backlinks from the corrsponding
8953      text sections.  */
8954   for (inp = info->input_bfds; inp != NULL; inp = inp->link_next)
8955     {
8956       asection *sec;
8957
8958       for (sec = inp->sections; sec != NULL; sec = sec->next)
8959         {
8960           struct bfd_elf_section_data *elf_sec = elf_section_data (sec);
8961           Elf_Internal_Shdr *hdr = &elf_sec->this_hdr;
8962
8963           if (hdr->sh_type != SHT_ARM_EXIDX)
8964             continue;
8965
8966           if (elf_sec->linked_to)
8967             {
8968               Elf_Internal_Shdr *linked_hdr
8969                 = &elf_section_data (elf_sec->linked_to)->this_hdr;
8970               struct _arm_elf_section_data *linked_sec_arm_data
8971                 = get_arm_elf_section_data (linked_hdr->bfd_section);
8972
8973               if (linked_sec_arm_data == NULL)
8974                 continue;
8975
8976               /* Link this .ARM.exidx section back from the text section it
8977                  describes.  */
8978               linked_sec_arm_data->u.text.arm_exidx_sec = sec;
8979             }
8980         }
8981     }
8982
8983   /* Walk all text sections in order of increasing VMA.  Eilminate duplicate
8984      index table entries (EXIDX_CANTUNWIND and inlined unwind opcodes),
8985      and add EXIDX_CANTUNWIND entries for sections with no unwind table data.
8986    */
8987
8988   for (i = 0; i < num_text_sections; i++)
8989     {
8990       asection *sec = text_section_order[i];
8991       asection *exidx_sec;
8992       struct _arm_elf_section_data *arm_data = get_arm_elf_section_data (sec);
8993       struct _arm_elf_section_data *exidx_arm_data;
8994       bfd_byte *contents = NULL;
8995       int deleted_exidx_bytes = 0;
8996       bfd_vma j;
8997       arm_unwind_table_edit *unwind_edit_head = NULL;
8998       arm_unwind_table_edit *unwind_edit_tail = NULL;
8999       Elf_Internal_Shdr *hdr;
9000       bfd *ibfd;
9001
9002       if (arm_data == NULL)
9003         continue;
9004
9005       exidx_sec = arm_data->u.text.arm_exidx_sec;
9006       if (exidx_sec == NULL)
9007         {
9008           /* Section has no unwind data.  */
9009           if (last_unwind_type == 0 || !last_exidx_sec)
9010             continue;
9011
9012           /* Ignore zero sized sections.  */
9013           if (sec->size == 0)
9014             continue;
9015
9016           insert_cantunwind_after(last_text_sec, last_exidx_sec);
9017           last_unwind_type = 0;
9018           continue;
9019         }
9020
9021       /* Skip /DISCARD/ sections.  */
9022       if (bfd_is_abs_section (exidx_sec->output_section))
9023         continue;
9024
9025       hdr = &elf_section_data (exidx_sec)->this_hdr;
9026       if (hdr->sh_type != SHT_ARM_EXIDX)
9027         continue;
9028
9029       exidx_arm_data = get_arm_elf_section_data (exidx_sec);
9030       if (exidx_arm_data == NULL)
9031         continue;
9032
9033       ibfd = exidx_sec->owner;
9034
9035       if (hdr->contents != NULL)
9036         contents = hdr->contents;
9037       else if (! bfd_malloc_and_get_section (ibfd, exidx_sec, &contents))
9038         /* An error?  */
9039         continue;
9040
9041       for (j = 0; j < hdr->sh_size; j += 8)
9042         {
9043           unsigned int second_word = bfd_get_32 (ibfd, contents + j + 4);
9044           int unwind_type;
9045           int elide = 0;
9046
9047           /* An EXIDX_CANTUNWIND entry.  */
9048           if (second_word == 1)
9049             {
9050               if (last_unwind_type == 0)
9051                 elide = 1;
9052               unwind_type = 0;
9053             }
9054           /* Inlined unwinding data.  Merge if equal to previous.  */
9055           else if ((second_word & 0x80000000) != 0)
9056             {
9057               if (last_second_word == second_word && last_unwind_type == 1)
9058                 elide = 1;
9059               unwind_type = 1;
9060               last_second_word = second_word;
9061             }
9062           /* Normal table entry.  In theory we could merge these too,
9063              but duplicate entries are likely to be much less common.  */
9064           else
9065             unwind_type = 2;
9066
9067           if (elide)
9068             {
9069               add_unwind_table_edit (&unwind_edit_head, &unwind_edit_tail,
9070                                      DELETE_EXIDX_ENTRY, NULL, j / 8);
9071
9072               deleted_exidx_bytes += 8;
9073             }
9074
9075           last_unwind_type = unwind_type;
9076         }
9077
9078       /* Free contents if we allocated it ourselves.  */
9079       if (contents != hdr->contents)
9080         free (contents);
9081
9082       /* Record edits to be applied later (in elf32_arm_write_section).  */
9083       exidx_arm_data->u.exidx.unwind_edit_list = unwind_edit_head;
9084       exidx_arm_data->u.exidx.unwind_edit_tail = unwind_edit_tail;
9085
9086       if (deleted_exidx_bytes > 0)
9087         adjust_exidx_size(exidx_sec, -deleted_exidx_bytes);
9088
9089       last_exidx_sec = exidx_sec;
9090       last_text_sec = sec;
9091     }
9092
9093   /* Add terminating CANTUNWIND entry.  */
9094   if (last_exidx_sec && last_unwind_type != 0)
9095     insert_cantunwind_after(last_text_sec, last_exidx_sec);
9096
9097   return TRUE;
9098 }
9099
9100 static bfd_boolean
9101 elf32_arm_output_glue_section (struct bfd_link_info *info, bfd *obfd,
9102                                bfd *ibfd, const char *name)
9103 {
9104   asection *sec, *osec;
9105
9106   sec = bfd_get_section_by_name (ibfd, name);
9107   if (sec == NULL || (sec->flags & SEC_EXCLUDE) != 0)
9108     return TRUE;
9109
9110   osec = sec->output_section;
9111   if (elf32_arm_write_section (obfd, info, sec, sec->contents))
9112     return TRUE;
9113
9114   if (! bfd_set_section_contents (obfd, osec, sec->contents,
9115                                   sec->output_offset, sec->size))
9116     return FALSE;
9117
9118   return TRUE;
9119 }
9120
9121 static bfd_boolean
9122 elf32_arm_final_link (bfd *abfd, struct bfd_link_info *info)
9123 {
9124   struct elf32_arm_link_hash_table *globals = elf32_arm_hash_table (info);
9125
9126   /* Invoke the regular ELF backend linker to do all the work.  */
9127   if (!bfd_elf_final_link (abfd, info))
9128     return FALSE;
9129
9130   /* Write out any glue sections now that we have created all the
9131      stubs.  */
9132   if (globals->bfd_of_glue_owner != NULL)
9133     {
9134       if (! elf32_arm_output_glue_section (info, abfd,
9135                                            globals->bfd_of_glue_owner,
9136                                            ARM2THUMB_GLUE_SECTION_NAME))
9137         return FALSE;
9138
9139       if (! elf32_arm_output_glue_section (info, abfd,
9140                                            globals->bfd_of_glue_owner,
9141                                            THUMB2ARM_GLUE_SECTION_NAME))
9142         return FALSE;
9143
9144       if (! elf32_arm_output_glue_section (info, abfd,
9145                                            globals->bfd_of_glue_owner,
9146                                            VFP11_ERRATUM_VENEER_SECTION_NAME))
9147         return FALSE;
9148
9149       if (! elf32_arm_output_glue_section (info, abfd,
9150                                            globals->bfd_of_glue_owner,
9151                                            ARM_BX_GLUE_SECTION_NAME))
9152         return FALSE;
9153     }
9154
9155   return TRUE;
9156 }
9157
9158 /* Set the right machine number.  */
9159
9160 static bfd_boolean
9161 elf32_arm_object_p (bfd *abfd)
9162 {
9163   unsigned int mach;
9164
9165   mach = bfd_arm_get_mach_from_notes (abfd, ARM_NOTE_SECTION);
9166
9167   if (mach != bfd_mach_arm_unknown)
9168     bfd_default_set_arch_mach (abfd, bfd_arch_arm, mach);
9169
9170   else if (elf_elfheader (abfd)->e_flags & EF_ARM_MAVERICK_FLOAT)
9171     bfd_default_set_arch_mach (abfd, bfd_arch_arm, bfd_mach_arm_ep9312);
9172
9173   else
9174     bfd_default_set_arch_mach (abfd, bfd_arch_arm, mach);
9175
9176   return TRUE;
9177 }
9178
9179 /* Function to keep ARM specific flags in the ELF header.  */
9180
9181 static bfd_boolean
9182 elf32_arm_set_private_flags (bfd *abfd, flagword flags)
9183 {
9184   if (elf_flags_init (abfd)
9185       && elf_elfheader (abfd)->e_flags != flags)
9186     {
9187       if (EF_ARM_EABI_VERSION (flags) == EF_ARM_EABI_UNKNOWN)
9188         {
9189           if (flags & EF_ARM_INTERWORK)
9190             (*_bfd_error_handler)
9191               (_("Warning: Not setting interworking flag of %B since it has already been specified as non-interworking"),
9192                abfd);
9193           else
9194             _bfd_error_handler
9195               (_("Warning: Clearing the interworking flag of %B due to outside request"),
9196                abfd);
9197         }
9198     }
9199   else
9200     {
9201       elf_elfheader (abfd)->e_flags = flags;
9202       elf_flags_init (abfd) = TRUE;
9203     }
9204
9205   return TRUE;
9206 }
9207
9208 /* Copy backend specific data from one object module to another.  */
9209
9210 static bfd_boolean
9211 elf32_arm_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
9212 {
9213   flagword in_flags;
9214   flagword out_flags;
9215
9216   if (! is_arm_elf (ibfd) || ! is_arm_elf (obfd))
9217     return TRUE;
9218
9219   in_flags  = elf_elfheader (ibfd)->e_flags;
9220   out_flags = elf_elfheader (obfd)->e_flags;
9221
9222   if (elf_flags_init (obfd)
9223       && EF_ARM_EABI_VERSION (out_flags) == EF_ARM_EABI_UNKNOWN
9224       && in_flags != out_flags)
9225     {
9226       /* Cannot mix APCS26 and APCS32 code.  */
9227       if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
9228         return FALSE;
9229
9230       /* Cannot mix float APCS and non-float APCS code.  */
9231       if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
9232         return FALSE;
9233
9234       /* If the src and dest have different interworking flags
9235          then turn off the interworking bit.  */
9236       if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
9237         {
9238           if (out_flags & EF_ARM_INTERWORK)
9239             _bfd_error_handler
9240               (_("Warning: Clearing the interworking flag of %B because non-interworking code in %B has been linked with it"),
9241                obfd, ibfd);
9242
9243           in_flags &= ~EF_ARM_INTERWORK;
9244         }
9245
9246       /* Likewise for PIC, though don't warn for this case.  */
9247       if ((in_flags & EF_ARM_PIC) != (out_flags & EF_ARM_PIC))
9248         in_flags &= ~EF_ARM_PIC;
9249     }
9250
9251   elf_elfheader (obfd)->e_flags = in_flags;
9252   elf_flags_init (obfd) = TRUE;
9253
9254   /* Also copy the EI_OSABI field.  */
9255   elf_elfheader (obfd)->e_ident[EI_OSABI] =
9256     elf_elfheader (ibfd)->e_ident[EI_OSABI];
9257
9258   /* Copy object attributes.  */
9259   _bfd_elf_copy_obj_attributes (ibfd, obfd);
9260
9261   return TRUE;
9262 }
9263
9264 /* Values for Tag_ABI_PCS_R9_use.  */
9265 enum
9266 {
9267   AEABI_R9_V6,
9268   AEABI_R9_SB,
9269   AEABI_R9_TLS,
9270   AEABI_R9_unused
9271 };
9272
9273 /* Values for Tag_ABI_PCS_RW_data.  */
9274 enum
9275 {
9276   AEABI_PCS_RW_data_absolute,
9277   AEABI_PCS_RW_data_PCrel,
9278   AEABI_PCS_RW_data_SBrel,
9279   AEABI_PCS_RW_data_unused
9280 };
9281
9282 /* Values for Tag_ABI_enum_size.  */
9283 enum
9284 {
9285   AEABI_enum_unused,
9286   AEABI_enum_short,
9287   AEABI_enum_wide,
9288   AEABI_enum_forced_wide
9289 };
9290
9291 /* Determine whether an object attribute tag takes an integer, a
9292    string or both.  */
9293
9294 static int
9295 elf32_arm_obj_attrs_arg_type (int tag)
9296 {
9297   if (tag == Tag_compatibility)
9298     return ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_STR_VAL;
9299   else if (tag == Tag_nodefaults)
9300     return ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_NO_DEFAULT;
9301   else if (tag == Tag_CPU_raw_name || tag == Tag_CPU_name)
9302     return ATTR_TYPE_FLAG_STR_VAL;
9303   else if (tag < 32)
9304     return ATTR_TYPE_FLAG_INT_VAL;
9305   else
9306     return (tag & 1) != 0 ? ATTR_TYPE_FLAG_STR_VAL : ATTR_TYPE_FLAG_INT_VAL;
9307 }
9308
9309 /* The ABI defines that Tag_conformance should be emitted first, and that
9310    Tag_nodefaults should be second (if either is defined).  This sets those
9311    two positions, and bumps up the position of all the remaining tags to
9312    compensate.  */
9313 static int
9314 elf32_arm_obj_attrs_order (int num)
9315 {
9316   if (num == 4)
9317     return Tag_conformance;
9318   if (num == 5)
9319     return Tag_nodefaults;
9320   if ((num - 2) < Tag_nodefaults)
9321     return num - 2;
9322   if ((num - 1) < Tag_conformance)
9323     return num - 1;
9324   return num;
9325 }
9326
9327 /* Read the architecture from the Tag_also_compatible_with attribute, if any.
9328    Returns -1 if no architecture could be read.  */
9329
9330 static int
9331 get_secondary_compatible_arch (bfd *abfd)
9332 {
9333   obj_attribute *attr =
9334     &elf_known_obj_attributes_proc (abfd)[Tag_also_compatible_with];
9335
9336   /* Note: the tag and its argument below are uleb128 values, though
9337      currently-defined values fit in one byte for each.  */
9338   if (attr->s
9339       && attr->s[0] == Tag_CPU_arch
9340       && (attr->s[1] & 128) != 128
9341       && attr->s[2] == 0)
9342    return attr->s[1];
9343
9344   /* This tag is "safely ignorable", so don't complain if it looks funny.  */
9345   return -1;
9346 }
9347
9348 /* Set, or unset, the architecture of the Tag_also_compatible_with attribute.
9349    The tag is removed if ARCH is -1.  */
9350
9351 static void
9352 set_secondary_compatible_arch (bfd *abfd, int arch)
9353 {
9354   obj_attribute *attr =
9355     &elf_known_obj_attributes_proc (abfd)[Tag_also_compatible_with];
9356
9357   if (arch == -1)
9358     {
9359       attr->s = NULL;
9360       return;
9361     }
9362
9363   /* Note: the tag and its argument below are uleb128 values, though
9364      currently-defined values fit in one byte for each.  */
9365   if (!attr->s)
9366     attr->s = bfd_alloc (abfd, 3);
9367   attr->s[0] = Tag_CPU_arch;
9368   attr->s[1] = arch;
9369   attr->s[2] = '\0';
9370 }
9371
9372 /* Combine two values for Tag_CPU_arch, taking secondary compatibility tags
9373    into account.  */
9374
9375 static int
9376 tag_cpu_arch_combine (bfd *ibfd, int oldtag, int *secondary_compat_out,
9377                       int newtag, int secondary_compat)
9378 {
9379 #define T(X) TAG_CPU_ARCH_##X
9380   int tagl, tagh, result;
9381   const int v6t2[] =
9382     {
9383       T(V6T2),   /* PRE_V4.  */
9384       T(V6T2),   /* V4.  */
9385       T(V6T2),   /* V4T.  */
9386       T(V6T2),   /* V5T.  */
9387       T(V6T2),   /* V5TE.  */
9388       T(V6T2),   /* V5TEJ.  */
9389       T(V6T2),   /* V6.  */
9390       T(V7),     /* V6KZ.  */
9391       T(V6T2)    /* V6T2.  */
9392     };
9393   const int v6k[] =
9394     {
9395       T(V6K),    /* PRE_V4.  */
9396       T(V6K),    /* V4.  */
9397       T(V6K),    /* V4T.  */
9398       T(V6K),    /* V5T.  */
9399       T(V6K),    /* V5TE.  */
9400       T(V6K),    /* V5TEJ.  */
9401       T(V6K),    /* V6.  */
9402       T(V6KZ),   /* V6KZ.  */
9403       T(V7),     /* V6T2.  */
9404       T(V6K)     /* V6K.  */
9405     };
9406   const int v7[] =
9407     {
9408       T(V7),     /* PRE_V4.  */
9409       T(V7),     /* V4.  */
9410       T(V7),     /* V4T.  */
9411       T(V7),     /* V5T.  */
9412       T(V7),     /* V5TE.  */
9413       T(V7),     /* V5TEJ.  */
9414       T(V7),     /* V6.  */
9415       T(V7),     /* V6KZ.  */
9416       T(V7),     /* V6T2.  */
9417       T(V7),     /* V6K.  */
9418       T(V7)      /* V7.  */
9419     };
9420   const int v6_m[] =
9421     {
9422       -1,        /* PRE_V4.  */
9423       -1,        /* V4.  */
9424       T(V6K),    /* V4T.  */
9425       T(V6K),    /* V5T.  */
9426       T(V6K),    /* V5TE.  */
9427       T(V6K),    /* V5TEJ.  */
9428       T(V6K),    /* V6.  */
9429       T(V6KZ),   /* V6KZ.  */
9430       T(V7),     /* V6T2.  */
9431       T(V6K),    /* V6K.  */
9432       T(V7),     /* V7.  */
9433       T(V6_M)    /* V6_M.  */
9434     };
9435   const int v6s_m[] =
9436     {
9437       -1,        /* PRE_V4.  */
9438       -1,        /* V4.  */
9439       T(V6K),    /* V4T.  */
9440       T(V6K),    /* V5T.  */
9441       T(V6K),    /* V5TE.  */
9442       T(V6K),    /* V5TEJ.  */
9443       T(V6K),    /* V6.  */
9444       T(V6KZ),   /* V6KZ.  */
9445       T(V7),     /* V6T2.  */
9446       T(V6K),    /* V6K.  */
9447       T(V7),     /* V7.  */
9448       T(V6S_M),  /* V6_M.  */
9449       T(V6S_M)   /* V6S_M.  */
9450     };
9451   const int v4t_plus_v6_m[] =
9452     {
9453       -1,               /* PRE_V4.  */
9454       -1,               /* V4.  */
9455       T(V4T),           /* V4T.  */
9456       T(V5T),           /* V5T.  */
9457       T(V5TE),          /* V5TE.  */
9458       T(V5TEJ),         /* V5TEJ.  */
9459       T(V6),            /* V6.  */
9460       T(V6KZ),          /* V6KZ.  */
9461       T(V6T2),          /* V6T2.  */
9462       T(V6K),           /* V6K.  */
9463       T(V7),            /* V7.  */
9464       T(V6_M),          /* V6_M.  */
9465       T(V6S_M),         /* V6S_M.  */
9466       T(V4T_PLUS_V6_M)  /* V4T plus V6_M.  */
9467     };
9468   const int *comb[] =
9469     {
9470       v6t2,
9471       v6k,
9472       v7,
9473       v6_m,
9474       v6s_m,
9475       /* Pseudo-architecture.  */
9476       v4t_plus_v6_m
9477     };
9478
9479   /* Check we've not got a higher architecture than we know about.  */
9480
9481   if (oldtag >= MAX_TAG_CPU_ARCH || newtag >= MAX_TAG_CPU_ARCH)
9482     {
9483       _bfd_error_handler (_("error: %B: Unknown CPU architecture"), ibfd);
9484       return -1;
9485     }
9486
9487   /* Override old tag if we have a Tag_also_compatible_with on the output.  */
9488
9489   if ((oldtag == T(V6_M) && *secondary_compat_out == T(V4T))
9490       || (oldtag == T(V4T) && *secondary_compat_out == T(V6_M)))
9491     oldtag = T(V4T_PLUS_V6_M);
9492
9493   /* And override the new tag if we have a Tag_also_compatible_with on the
9494      input.  */
9495
9496   if ((newtag == T(V6_M) && secondary_compat == T(V4T))
9497       || (newtag == T(V4T) && secondary_compat == T(V6_M)))
9498     newtag = T(V4T_PLUS_V6_M);
9499
9500   tagl = (oldtag < newtag) ? oldtag : newtag;
9501   result = tagh = (oldtag > newtag) ? oldtag : newtag;
9502
9503   /* Architectures before V6KZ add features monotonically.  */
9504   if (tagh <= TAG_CPU_ARCH_V6KZ)
9505     return result;
9506
9507   result = comb[tagh - T(V6T2)][tagl];
9508
9509   /* Use Tag_CPU_arch == V4T and Tag_also_compatible_with (Tag_CPU_arch V6_M)
9510      as the canonical version.  */
9511   if (result == T(V4T_PLUS_V6_M))
9512     {
9513       result = T(V4T);
9514       *secondary_compat_out = T(V6_M);
9515     }
9516   else
9517     *secondary_compat_out = -1;
9518
9519   if (result == -1)
9520     {
9521       _bfd_error_handler (_("error: %B: Conflicting CPU architectures %d/%d"),
9522                           ibfd, oldtag, newtag);
9523       return -1;
9524     }
9525
9526   return result;
9527 #undef T
9528 }
9529
9530 /* Merge EABI object attributes from IBFD into OBFD.  Raise an error if there
9531    are conflicting attributes.  */
9532
9533 static bfd_boolean
9534 elf32_arm_merge_eabi_attributes (bfd *ibfd, bfd *obfd)
9535 {
9536   obj_attribute *in_attr;
9537   obj_attribute *out_attr;
9538   obj_attribute_list *in_list;
9539   obj_attribute_list *out_list;
9540   obj_attribute_list **out_listp;
9541   /* Some tags have 0 = don't care, 1 = strong requirement,
9542      2 = weak requirement.  */
9543   static const int order_021[3] = {0, 2, 1};
9544   /* For use with Tag_VFP_arch.  */
9545   static const int order_01243[5] = {0, 1, 2, 4, 3};
9546   int i;
9547   bfd_boolean result = TRUE;
9548
9549   /* Skip the linker stubs file.  This preserves previous behavior
9550      of accepting unknown attributes in the first input file - but
9551      is that a bug?  */
9552   if (ibfd->flags & BFD_LINKER_CREATED)
9553     return TRUE;
9554
9555   if (!elf_known_obj_attributes_proc (obfd)[0].i)
9556     {
9557       /* This is the first object.  Copy the attributes.  */
9558       _bfd_elf_copy_obj_attributes (ibfd, obfd);
9559
9560       /* Use the Tag_null value to indicate the attributes have been
9561          initialized.  */
9562       elf_known_obj_attributes_proc (obfd)[0].i = 1;
9563
9564       return TRUE;
9565     }
9566
9567   in_attr = elf_known_obj_attributes_proc (ibfd);
9568   out_attr = elf_known_obj_attributes_proc (obfd);
9569   /* This needs to happen before Tag_ABI_FP_number_model is merged.  */
9570   if (in_attr[Tag_ABI_VFP_args].i != out_attr[Tag_ABI_VFP_args].i)
9571     {
9572       /* Ignore mismatches if the object doesn't use floating point.  */
9573       if (out_attr[Tag_ABI_FP_number_model].i == 0)
9574         out_attr[Tag_ABI_VFP_args].i = in_attr[Tag_ABI_VFP_args].i;
9575       else if (in_attr[Tag_ABI_FP_number_model].i != 0)
9576         {
9577           _bfd_error_handler
9578             (_("error: %B uses VFP register arguments, %B does not"),
9579              ibfd, obfd);
9580           result = FALSE;
9581         }
9582     }
9583
9584   for (i = 4; i < NUM_KNOWN_OBJ_ATTRIBUTES; i++)
9585     {
9586       /* Merge this attribute with existing attributes.  */
9587       switch (i)
9588         {
9589         case Tag_CPU_raw_name:
9590         case Tag_CPU_name:
9591           /* These are merged after Tag_CPU_arch. */
9592           break;
9593
9594         case Tag_ABI_optimization_goals:
9595         case Tag_ABI_FP_optimization_goals:
9596           /* Use the first value seen.  */
9597           break;
9598
9599         case Tag_CPU_arch:
9600           {
9601             int secondary_compat = -1, secondary_compat_out = -1;
9602             unsigned int saved_out_attr = out_attr[i].i;
9603             static const char *name_table[] = {
9604                 /* These aren't real CPU names, but we can't guess
9605                    that from the architecture version alone.  */
9606                 "Pre v4",
9607                 "ARM v4",
9608                 "ARM v4T",
9609                 "ARM v5T",
9610                 "ARM v5TE",
9611                 "ARM v5TEJ",
9612                 "ARM v6",
9613                 "ARM v6KZ",
9614                 "ARM v6T2",
9615                 "ARM v6K",
9616                 "ARM v7",
9617                 "ARM v6-M",
9618                 "ARM v6S-M"
9619             };
9620
9621             /* Merge Tag_CPU_arch and Tag_also_compatible_with.  */
9622             secondary_compat = get_secondary_compatible_arch (ibfd);
9623             secondary_compat_out = get_secondary_compatible_arch (obfd);
9624             out_attr[i].i = tag_cpu_arch_combine (ibfd, out_attr[i].i,
9625                                                   &secondary_compat_out,
9626                                                   in_attr[i].i,
9627                                                   secondary_compat);
9628             set_secondary_compatible_arch (obfd, secondary_compat_out);
9629
9630             /* Merge Tag_CPU_name and Tag_CPU_raw_name.  */
9631             if (out_attr[i].i == saved_out_attr)
9632               ; /* Leave the names alone.  */
9633             else if (out_attr[i].i == in_attr[i].i)
9634               {
9635                 /* The output architecture has been changed to match the
9636                    input architecture.  Use the input names.  */
9637                 out_attr[Tag_CPU_name].s = in_attr[Tag_CPU_name].s
9638                   ? _bfd_elf_attr_strdup (obfd, in_attr[Tag_CPU_name].s)
9639                   : NULL;
9640                 out_attr[Tag_CPU_raw_name].s = in_attr[Tag_CPU_raw_name].s
9641                   ? _bfd_elf_attr_strdup (obfd, in_attr[Tag_CPU_raw_name].s)
9642                   : NULL;
9643               }
9644             else
9645               {
9646                 out_attr[Tag_CPU_name].s = NULL;
9647                 out_attr[Tag_CPU_raw_name].s = NULL;
9648               }
9649
9650             /* If we still don't have a value for Tag_CPU_name,
9651                make one up now.  Tag_CPU_raw_name remains blank.  */
9652             if (out_attr[Tag_CPU_name].s == NULL
9653                 && out_attr[i].i < ARRAY_SIZE (name_table))
9654               out_attr[Tag_CPU_name].s =
9655                 _bfd_elf_attr_strdup (obfd, name_table[out_attr[i].i]);
9656           }
9657           break;
9658
9659         case Tag_ARM_ISA_use:
9660         case Tag_THUMB_ISA_use:
9661         case Tag_WMMX_arch:
9662         case Tag_Advanced_SIMD_arch:
9663           /* ??? Do Advanced_SIMD (NEON) and WMMX conflict?  */
9664         case Tag_ABI_FP_rounding:
9665         case Tag_ABI_FP_exceptions:
9666         case Tag_ABI_FP_user_exceptions:
9667         case Tag_ABI_FP_number_model:
9668         case Tag_VFP_HP_extension:
9669         case Tag_CPU_unaligned_access:
9670         case Tag_T2EE_use:
9671         case Tag_Virtualization_use:
9672         case Tag_MPextension_use:
9673           /* Use the largest value specified.  */
9674           if (in_attr[i].i > out_attr[i].i)
9675             out_attr[i].i = in_attr[i].i;
9676           break;
9677
9678         case Tag_ABI_align8_preserved:
9679         case Tag_ABI_PCS_RO_data:
9680           /* Use the smallest value specified.  */
9681           if (in_attr[i].i < out_attr[i].i)
9682             out_attr[i].i = in_attr[i].i;
9683           break;
9684
9685         case Tag_ABI_align8_needed:
9686           if ((in_attr[i].i > 0 || out_attr[i].i > 0)
9687               && (in_attr[Tag_ABI_align8_preserved].i == 0
9688                   || out_attr[Tag_ABI_align8_preserved].i == 0))
9689             {
9690               /* This error message should be enabled once all non-conformant
9691                  binaries in the toolchain have had the attributes set
9692                  properly.
9693               _bfd_error_handler
9694                 (_("error: %B: 8-byte data alignment conflicts with %B"),
9695                  obfd, ibfd);
9696               result = FALSE; */
9697             }
9698           /* Fall through.  */
9699         case Tag_ABI_FP_denormal:
9700         case Tag_ABI_PCS_GOT_use:
9701           /* Use the "greatest" from the sequence 0, 2, 1, or the largest
9702              value if greater than 2 (for future-proofing).  */
9703           if ((in_attr[i].i > 2 && in_attr[i].i > out_attr[i].i)
9704               || (in_attr[i].i <= 2 && out_attr[i].i <= 2
9705                   && order_021[in_attr[i].i] > order_021[out_attr[i].i]))
9706             out_attr[i].i = in_attr[i].i;
9707           break;
9708
9709
9710         case Tag_CPU_arch_profile:
9711           if (out_attr[i].i != in_attr[i].i)
9712             {
9713               /* 0 will merge with anything.
9714                  'A' and 'S' merge to 'A'.
9715                  'R' and 'S' merge to 'R'.
9716                  'M' and 'A|R|S' is an error.  */
9717               if (out_attr[i].i == 0
9718                   || (out_attr[i].i == 'S'
9719                       && (in_attr[i].i == 'A' || in_attr[i].i == 'R')))
9720                 out_attr[i].i = in_attr[i].i;
9721               else if (in_attr[i].i == 0
9722                        || (in_attr[i].i == 'S'
9723                            && (out_attr[i].i == 'A' || out_attr[i].i == 'R')))
9724                 ; /* Do nothing. */
9725               else
9726                 {
9727                   _bfd_error_handler
9728                     (_("error: %B: Conflicting architecture profiles %c/%c"),
9729                      ibfd,
9730                      in_attr[i].i ? in_attr[i].i : '0',
9731                      out_attr[i].i ? out_attr[i].i : '0');
9732                   result = FALSE;
9733                 }
9734             }
9735           break;
9736         case Tag_VFP_arch:
9737           /* Use the "greatest" from the sequence 0, 1, 2, 4, 3, or the
9738              largest value if greater than 4 (for future-proofing).  */
9739           if ((in_attr[i].i > 4 && in_attr[i].i > out_attr[i].i)
9740               || (in_attr[i].i <= 4 && out_attr[i].i <= 4
9741                   && order_01243[in_attr[i].i] > order_01243[out_attr[i].i]))
9742             out_attr[i].i = in_attr[i].i;
9743           break;
9744         case Tag_PCS_config:
9745           if (out_attr[i].i == 0)
9746             out_attr[i].i = in_attr[i].i;
9747           else if (in_attr[i].i != 0 && out_attr[i].i != 0)
9748             {
9749               /* It's sometimes ok to mix different configs, so this is only
9750                  a warning.  */
9751               _bfd_error_handler
9752                 (_("Warning: %B: Conflicting platform configuration"), ibfd);
9753             }
9754           break;
9755         case Tag_ABI_PCS_R9_use:
9756           if (in_attr[i].i != out_attr[i].i
9757               && out_attr[i].i != AEABI_R9_unused
9758               && in_attr[i].i != AEABI_R9_unused)
9759             {
9760               _bfd_error_handler
9761                 (_("error: %B: Conflicting use of R9"), ibfd);
9762               result = FALSE;
9763             }
9764           if (out_attr[i].i == AEABI_R9_unused)
9765             out_attr[i].i = in_attr[i].i;
9766           break;
9767         case Tag_ABI_PCS_RW_data:
9768           if (in_attr[i].i == AEABI_PCS_RW_data_SBrel
9769               && out_attr[Tag_ABI_PCS_R9_use].i != AEABI_R9_SB
9770               && out_attr[Tag_ABI_PCS_R9_use].i != AEABI_R9_unused)
9771             {
9772               _bfd_error_handler
9773                 (_("error: %B: SB relative addressing conflicts with use of R9"),
9774                  ibfd);
9775               result = FALSE;
9776             }
9777           /* Use the smallest value specified.  */
9778           if (in_attr[i].i < out_attr[i].i)
9779             out_attr[i].i = in_attr[i].i;
9780           break;
9781         case Tag_ABI_PCS_wchar_t:
9782           if (out_attr[i].i && in_attr[i].i && out_attr[i].i != in_attr[i].i
9783               && !elf_arm_tdata (obfd)->no_wchar_size_warning)
9784             {
9785               _bfd_error_handler
9786                 (_("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"),
9787                  ibfd, in_attr[i].i, out_attr[i].i);
9788             }
9789           else if (in_attr[i].i && !out_attr[i].i)
9790             out_attr[i].i = in_attr[i].i;
9791           break;
9792         case Tag_ABI_enum_size:
9793           if (in_attr[i].i != AEABI_enum_unused)
9794             {
9795               if (out_attr[i].i == AEABI_enum_unused
9796                   || out_attr[i].i == AEABI_enum_forced_wide)
9797                 {
9798                   /* The existing object is compatible with anything.
9799                      Use whatever requirements the new object has.  */
9800                   out_attr[i].i = in_attr[i].i;
9801                 }
9802               else if (in_attr[i].i != AEABI_enum_forced_wide
9803                        && out_attr[i].i != in_attr[i].i
9804                        && !elf_arm_tdata (obfd)->no_enum_size_warning)
9805                 {
9806                   static const char *aeabi_enum_names[] =
9807                     { "", "variable-size", "32-bit", "" };
9808                   const char *in_name =
9809                     in_attr[i].i < ARRAY_SIZE(aeabi_enum_names)
9810                     ? aeabi_enum_names[in_attr[i].i]
9811                     : "<unknown>";
9812                   const char *out_name =
9813                     out_attr[i].i < ARRAY_SIZE(aeabi_enum_names)
9814                     ? aeabi_enum_names[out_attr[i].i]
9815                     : "<unknown>";
9816                   _bfd_error_handler
9817                     (_("warning: %B uses %s enums yet the output is to use %s enums; use of enum values across objects may fail"),
9818                      ibfd, in_name, out_name);
9819                 }
9820             }
9821           break;
9822         case Tag_ABI_VFP_args:
9823           /* Aready done.  */
9824           break;
9825         case Tag_ABI_WMMX_args:
9826           if (in_attr[i].i != out_attr[i].i)
9827             {
9828               _bfd_error_handler
9829                 (_("error: %B uses iWMMXt register arguments, %B does not"),
9830                  ibfd, obfd);
9831               result = FALSE;
9832             }
9833           break;
9834         case Tag_compatibility:
9835           /* Merged in target-independent code.  */
9836           break;
9837         case Tag_ABI_HardFP_use:
9838           /* 1 (SP) and 2 (DP) conflict, so combine to 3 (SP & DP).  */
9839           if ((in_attr[i].i == 1 && out_attr[i].i == 2)
9840               || (in_attr[i].i == 2 && out_attr[i].i == 1))
9841             out_attr[i].i = 3;
9842           else if (in_attr[i].i > out_attr[i].i)
9843             out_attr[i].i = in_attr[i].i;
9844           break;
9845         case Tag_ABI_FP_16bit_format:
9846           if (in_attr[i].i != 0 && out_attr[i].i != 0)
9847             {
9848               if (in_attr[i].i != out_attr[i].i)
9849                 {
9850                   _bfd_error_handler
9851                     (_("error: fp16 format mismatch between %B and %B"),
9852                      ibfd, obfd);
9853                   result = FALSE;
9854                 }
9855             }
9856           if (in_attr[i].i != 0)
9857             out_attr[i].i = in_attr[i].i;
9858           break;
9859
9860         case Tag_nodefaults:
9861           /* This tag is set if it exists, but the value is unused (and is
9862              typically zero).  We don't actually need to do anything here -
9863              the merge happens automatically when the type flags are merged
9864              below.  */
9865           break;
9866         case Tag_also_compatible_with:
9867           /* Already done in Tag_CPU_arch.  */
9868           break;
9869         case Tag_conformance:
9870           /* Keep the attribute if it matches.  Throw it away otherwise.
9871              No attribute means no claim to conform.  */
9872           if (!in_attr[i].s || !out_attr[i].s
9873               || strcmp (in_attr[i].s, out_attr[i].s) != 0)
9874             out_attr[i].s = NULL;
9875           break;
9876
9877         default:
9878           {
9879             bfd *err_bfd = NULL;
9880
9881             /* The "known_obj_attributes" table does contain some undefined
9882                attributes.  Ensure that there are unused.  */
9883             if (out_attr[i].i != 0 || out_attr[i].s != NULL)
9884               err_bfd = obfd;
9885             else if (in_attr[i].i != 0 || in_attr[i].s != NULL)
9886               err_bfd = ibfd;
9887
9888             if (err_bfd != NULL)
9889               {
9890                 /* Attribute numbers >=64 (mod 128) can be safely ignored.  */
9891                 if ((i & 127) < 64)
9892                   {
9893                     _bfd_error_handler
9894                       (_("%B: Unknown mandatory EABI object attribute %d"),
9895                        err_bfd, i);
9896                     bfd_set_error (bfd_error_bad_value);
9897                     result = FALSE;
9898                   }
9899                 else
9900                   {
9901                     _bfd_error_handler
9902                       (_("Warning: %B: Unknown EABI object attribute %d"),
9903                        err_bfd, i);
9904                   }
9905               }
9906
9907             /* Only pass on attributes that match in both inputs.  */
9908             if (in_attr[i].i != out_attr[i].i
9909                 || in_attr[i].s != out_attr[i].s
9910                 || (in_attr[i].s != NULL && out_attr[i].s != NULL
9911                     && strcmp (in_attr[i].s, out_attr[i].s) != 0))
9912               {
9913                 out_attr[i].i = 0;
9914                 out_attr[i].s = NULL;
9915               }
9916           }
9917         }
9918
9919       /* If out_attr was copied from in_attr then it won't have a type yet.  */
9920       if (in_attr[i].type && !out_attr[i].type)
9921         out_attr[i].type = in_attr[i].type;
9922     }
9923
9924   /* Merge Tag_compatibility attributes and any common GNU ones.  */
9925   _bfd_elf_merge_object_attributes (ibfd, obfd);
9926
9927   /* Check for any attributes not known on ARM.  */
9928   in_list = elf_other_obj_attributes_proc (ibfd);
9929   out_listp = &elf_other_obj_attributes_proc (obfd);
9930   out_list = *out_listp;
9931
9932   for (; in_list || out_list; )
9933     {
9934       bfd *err_bfd = NULL;
9935       int err_tag = 0;
9936
9937       /* The tags for each list are in numerical order.  */
9938       /* If the tags are equal, then merge.  */
9939       if (out_list && (!in_list || in_list->tag > out_list->tag))
9940         {
9941           /* This attribute only exists in obfd.  We can't merge, and we don't
9942              know what the tag means, so delete it.  */
9943           err_bfd = obfd;
9944           err_tag = out_list->tag;
9945           *out_listp = out_list->next;
9946           out_list = *out_listp;
9947         }
9948       else if (in_list && (!out_list || in_list->tag < out_list->tag))
9949         {
9950           /* This attribute only exists in ibfd. We can't merge, and we don't
9951              know what the tag means, so ignore it.  */
9952           err_bfd = ibfd;
9953           err_tag = in_list->tag;
9954           in_list = in_list->next;
9955         }
9956       else /* The tags are equal.  */
9957         {
9958           /* As present, all attributes in the list are unknown, and
9959              therefore can't be merged meaningfully.  */
9960           err_bfd = obfd;
9961           err_tag = out_list->tag;
9962
9963           /*  Only pass on attributes that match in both inputs.  */
9964           if (in_list->attr.i != out_list->attr.i
9965               || in_list->attr.s != out_list->attr.s
9966               || (in_list->attr.s && out_list->attr.s
9967                   && strcmp (in_list->attr.s, out_list->attr.s) != 0))
9968             {
9969               /* No match.  Delete the attribute.  */
9970               *out_listp = out_list->next;
9971               out_list = *out_listp;
9972             }
9973           else
9974             {
9975               /* Matched.  Keep the attribute and move to the next.  */
9976               out_list = out_list->next;
9977               in_list = in_list->next;
9978             }
9979         }
9980
9981       if (err_bfd)
9982         {
9983           /* Attribute numbers >=64 (mod 128) can be safely ignored.  */
9984           if ((err_tag & 127) < 64)
9985             {
9986               _bfd_error_handler
9987                 (_("%B: Unknown mandatory EABI object attribute %d"),
9988                  err_bfd, err_tag);
9989               bfd_set_error (bfd_error_bad_value);
9990               result = FALSE;
9991             }
9992           else
9993             {
9994               _bfd_error_handler
9995                 (_("Warning: %B: Unknown EABI object attribute %d"),
9996                  err_bfd, err_tag);
9997             }
9998         }
9999     }
10000   return result;
10001 }
10002
10003
10004 /* Return TRUE if the two EABI versions are incompatible.  */
10005
10006 static bfd_boolean
10007 elf32_arm_versions_compatible (unsigned iver, unsigned over)
10008 {
10009   /* v4 and v5 are the same spec before and after it was released,
10010      so allow mixing them.  */
10011   if ((iver == EF_ARM_EABI_VER4 && over == EF_ARM_EABI_VER5)
10012       || (iver == EF_ARM_EABI_VER5 && over == EF_ARM_EABI_VER4))
10013     return TRUE;
10014
10015   return (iver == over);
10016 }
10017
10018 /* Merge backend specific data from an object file to the output
10019    object file when linking.  */
10020
10021 static bfd_boolean
10022 elf32_arm_merge_private_bfd_data (bfd * ibfd, bfd * obfd)
10023 {
10024   flagword out_flags;
10025   flagword in_flags;
10026   bfd_boolean flags_compatible = TRUE;
10027   asection *sec;
10028
10029   /* Check if we have the same endianess.  */
10030   if (! _bfd_generic_verify_endian_match (ibfd, obfd))
10031     return FALSE;
10032
10033   if (! is_arm_elf (ibfd) || ! is_arm_elf (obfd))
10034     return TRUE;
10035
10036   if (!elf32_arm_merge_eabi_attributes (ibfd, obfd))
10037     return FALSE;
10038
10039   /* The input BFD must have had its flags initialised.  */
10040   /* The following seems bogus to me -- The flags are initialized in
10041      the assembler but I don't think an elf_flags_init field is
10042      written into the object.  */
10043   /* BFD_ASSERT (elf_flags_init (ibfd)); */
10044
10045   in_flags  = elf_elfheader (ibfd)->e_flags;
10046   out_flags = elf_elfheader (obfd)->e_flags;
10047
10048   /* In theory there is no reason why we couldn't handle this.  However
10049      in practice it isn't even close to working and there is no real
10050      reason to want it.  */
10051   if (EF_ARM_EABI_VERSION (in_flags) >= EF_ARM_EABI_VER4
10052       && !(ibfd->flags & DYNAMIC)
10053       && (in_flags & EF_ARM_BE8))
10054     {
10055       _bfd_error_handler (_("error: %B is already in final BE8 format"),
10056                           ibfd);
10057       return FALSE;
10058     }
10059
10060   if (!elf_flags_init (obfd))
10061     {
10062       /* If the input is the default architecture and had the default
10063          flags then do not bother setting the flags for the output
10064          architecture, instead allow future merges to do this.  If no
10065          future merges ever set these flags then they will retain their
10066          uninitialised values, which surprise surprise, correspond
10067          to the default values.  */
10068       if (bfd_get_arch_info (ibfd)->the_default
10069           && elf_elfheader (ibfd)->e_flags == 0)
10070         return TRUE;
10071
10072       elf_flags_init (obfd) = TRUE;
10073       elf_elfheader (obfd)->e_flags = in_flags;
10074
10075       if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
10076           && bfd_get_arch_info (obfd)->the_default)
10077         return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
10078
10079       return TRUE;
10080     }
10081
10082   /* Determine what should happen if the input ARM architecture
10083      does not match the output ARM architecture.  */
10084   if (! bfd_arm_merge_machines (ibfd, obfd))
10085     return FALSE;
10086
10087   /* Identical flags must be compatible.  */
10088   if (in_flags == out_flags)
10089     return TRUE;
10090
10091   /* Check to see if the input BFD actually contains any sections.  If
10092      not, its flags may not have been initialised either, but it
10093      cannot actually cause any incompatiblity.  Do not short-circuit
10094      dynamic objects; their section list may be emptied by
10095     elf_link_add_object_symbols.
10096
10097     Also check to see if there are no code sections in the input.
10098     In this case there is no need to check for code specific flags.
10099     XXX - do we need to worry about floating-point format compatability
10100     in data sections ?  */
10101   if (!(ibfd->flags & DYNAMIC))
10102     {
10103       bfd_boolean null_input_bfd = TRUE;
10104       bfd_boolean only_data_sections = TRUE;
10105
10106       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
10107         {
10108           /* Ignore synthetic glue sections.  */
10109           if (strcmp (sec->name, ".glue_7")
10110               && strcmp (sec->name, ".glue_7t"))
10111             {
10112               if ((bfd_get_section_flags (ibfd, sec)
10113                    & (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS))
10114                   == (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS))
10115                 only_data_sections = FALSE;
10116
10117               null_input_bfd = FALSE;
10118               break;
10119             }
10120         }
10121
10122       if (null_input_bfd || only_data_sections)
10123         return TRUE;
10124     }
10125
10126   /* Complain about various flag mismatches.  */
10127   if (!elf32_arm_versions_compatible (EF_ARM_EABI_VERSION (in_flags),
10128                                       EF_ARM_EABI_VERSION (out_flags)))
10129     {
10130       _bfd_error_handler
10131         (_("error: Source object %B has EABI version %d, but target %B has EABI version %d"),
10132          ibfd, obfd,
10133          (in_flags & EF_ARM_EABIMASK) >> 24,
10134          (out_flags & EF_ARM_EABIMASK) >> 24);
10135       return FALSE;
10136     }
10137
10138   /* Not sure what needs to be checked for EABI versions >= 1.  */
10139   /* VxWorks libraries do not use these flags.  */
10140   if (get_elf_backend_data (obfd) != &elf32_arm_vxworks_bed
10141       && get_elf_backend_data (ibfd) != &elf32_arm_vxworks_bed
10142       && EF_ARM_EABI_VERSION (in_flags) == EF_ARM_EABI_UNKNOWN)
10143     {
10144       if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
10145         {
10146           _bfd_error_handler
10147             (_("error: %B is compiled for APCS-%d, whereas target %B uses APCS-%d"),
10148              ibfd, obfd,
10149              in_flags & EF_ARM_APCS_26 ? 26 : 32,
10150              out_flags & EF_ARM_APCS_26 ? 26 : 32);
10151           flags_compatible = FALSE;
10152         }
10153
10154       if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
10155         {
10156           if (in_flags & EF_ARM_APCS_FLOAT)
10157             _bfd_error_handler
10158               (_("error: %B passes floats in float registers, whereas %B passes them in integer registers"),
10159                ibfd, obfd);
10160           else
10161             _bfd_error_handler
10162               (_("error: %B passes floats in integer registers, whereas %B passes them in float registers"),
10163                ibfd, obfd);
10164
10165           flags_compatible = FALSE;
10166         }
10167
10168       if ((in_flags & EF_ARM_VFP_FLOAT) != (out_flags & EF_ARM_VFP_FLOAT))
10169         {
10170           if (in_flags & EF_ARM_VFP_FLOAT)
10171             _bfd_error_handler
10172               (_("error: %B uses VFP instructions, whereas %B does not"),
10173                ibfd, obfd);
10174           else
10175             _bfd_error_handler
10176               (_("error: %B uses FPA instructions, whereas %B does not"),
10177                ibfd, obfd);
10178
10179           flags_compatible = FALSE;
10180         }
10181
10182       if ((in_flags & EF_ARM_MAVERICK_FLOAT) != (out_flags & EF_ARM_MAVERICK_FLOAT))
10183         {
10184           if (in_flags & EF_ARM_MAVERICK_FLOAT)
10185             _bfd_error_handler
10186               (_("error: %B uses Maverick instructions, whereas %B does not"),
10187                ibfd, obfd);
10188           else
10189             _bfd_error_handler
10190               (_("error: %B does not use Maverick instructions, whereas %B does"),
10191                ibfd, obfd);
10192
10193           flags_compatible = FALSE;
10194         }
10195
10196 #ifdef EF_ARM_SOFT_FLOAT
10197       if ((in_flags & EF_ARM_SOFT_FLOAT) != (out_flags & EF_ARM_SOFT_FLOAT))
10198         {
10199           /* We can allow interworking between code that is VFP format
10200              layout, and uses either soft float or integer regs for
10201              passing floating point arguments and results.  We already
10202              know that the APCS_FLOAT flags match; similarly for VFP
10203              flags.  */
10204           if ((in_flags & EF_ARM_APCS_FLOAT) != 0
10205               || (in_flags & EF_ARM_VFP_FLOAT) == 0)
10206             {
10207               if (in_flags & EF_ARM_SOFT_FLOAT)
10208                 _bfd_error_handler
10209                   (_("error: %B uses software FP, whereas %B uses hardware FP"),
10210                    ibfd, obfd);
10211               else
10212                 _bfd_error_handler
10213                   (_("error: %B uses hardware FP, whereas %B uses software FP"),
10214                    ibfd, obfd);
10215
10216               flags_compatible = FALSE;
10217             }
10218         }
10219 #endif
10220
10221       /* Interworking mismatch is only a warning.  */
10222       if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
10223         {
10224           if (in_flags & EF_ARM_INTERWORK)
10225             {
10226               _bfd_error_handler
10227                 (_("Warning: %B supports interworking, whereas %B does not"),
10228                  ibfd, obfd);
10229             }
10230           else
10231             {
10232               _bfd_error_handler
10233                 (_("Warning: %B does not support interworking, whereas %B does"),
10234                  ibfd, obfd);
10235             }
10236         }
10237     }
10238
10239   return flags_compatible;
10240 }
10241
10242 /* Display the flags field.  */
10243
10244 static bfd_boolean
10245 elf32_arm_print_private_bfd_data (bfd *abfd, void * ptr)
10246 {
10247   FILE * file = (FILE *) ptr;
10248   unsigned long flags;
10249
10250   BFD_ASSERT (abfd != NULL && ptr != NULL);
10251
10252   /* Print normal ELF private data.  */
10253   _bfd_elf_print_private_bfd_data (abfd, ptr);
10254
10255   flags = elf_elfheader (abfd)->e_flags;
10256   /* Ignore init flag - it may not be set, despite the flags field
10257      containing valid data.  */
10258
10259   /* xgettext:c-format */
10260   fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
10261
10262   switch (EF_ARM_EABI_VERSION (flags))
10263     {
10264     case EF_ARM_EABI_UNKNOWN:
10265       /* The following flag bits are GNU extensions and not part of the
10266          official ARM ELF extended ABI.  Hence they are only decoded if
10267          the EABI version is not set.  */
10268       if (flags & EF_ARM_INTERWORK)
10269         fprintf (file, _(" [interworking enabled]"));
10270
10271       if (flags & EF_ARM_APCS_26)
10272         fprintf (file, " [APCS-26]");
10273       else
10274         fprintf (file, " [APCS-32]");
10275
10276       if (flags & EF_ARM_VFP_FLOAT)
10277         fprintf (file, _(" [VFP float format]"));
10278       else if (flags & EF_ARM_MAVERICK_FLOAT)
10279         fprintf (file, _(" [Maverick float format]"));
10280       else
10281         fprintf (file, _(" [FPA float format]"));
10282
10283       if (flags & EF_ARM_APCS_FLOAT)
10284         fprintf (file, _(" [floats passed in float registers]"));
10285
10286       if (flags & EF_ARM_PIC)
10287         fprintf (file, _(" [position independent]"));
10288
10289       if (flags & EF_ARM_NEW_ABI)
10290         fprintf (file, _(" [new ABI]"));
10291
10292       if (flags & EF_ARM_OLD_ABI)
10293         fprintf (file, _(" [old ABI]"));
10294
10295       if (flags & EF_ARM_SOFT_FLOAT)
10296         fprintf (file, _(" [software FP]"));
10297
10298       flags &= ~(EF_ARM_INTERWORK | EF_ARM_APCS_26 | EF_ARM_APCS_FLOAT
10299                  | EF_ARM_PIC | EF_ARM_NEW_ABI | EF_ARM_OLD_ABI
10300                  | EF_ARM_SOFT_FLOAT | EF_ARM_VFP_FLOAT
10301                  | EF_ARM_MAVERICK_FLOAT);
10302       break;
10303
10304     case EF_ARM_EABI_VER1:
10305       fprintf (file, _(" [Version1 EABI]"));
10306
10307       if (flags & EF_ARM_SYMSARESORTED)
10308         fprintf (file, _(" [sorted symbol table]"));
10309       else
10310         fprintf (file, _(" [unsorted symbol table]"));
10311
10312       flags &= ~ EF_ARM_SYMSARESORTED;
10313       break;
10314
10315     case EF_ARM_EABI_VER2:
10316       fprintf (file, _(" [Version2 EABI]"));
10317
10318       if (flags & EF_ARM_SYMSARESORTED)
10319         fprintf (file, _(" [sorted symbol table]"));
10320       else
10321         fprintf (file, _(" [unsorted symbol table]"));
10322
10323       if (flags & EF_ARM_DYNSYMSUSESEGIDX)
10324         fprintf (file, _(" [dynamic symbols use segment index]"));
10325
10326       if (flags & EF_ARM_MAPSYMSFIRST)
10327         fprintf (file, _(" [mapping symbols precede others]"));
10328
10329       flags &= ~(EF_ARM_SYMSARESORTED | EF_ARM_DYNSYMSUSESEGIDX
10330                  | EF_ARM_MAPSYMSFIRST);
10331       break;
10332
10333     case EF_ARM_EABI_VER3:
10334       fprintf (file, _(" [Version3 EABI]"));
10335       break;
10336
10337     case EF_ARM_EABI_VER4:
10338       fprintf (file, _(" [Version4 EABI]"));
10339       goto eabi;
10340
10341     case EF_ARM_EABI_VER5:
10342       fprintf (file, _(" [Version5 EABI]"));
10343     eabi:
10344       if (flags & EF_ARM_BE8)
10345         fprintf (file, _(" [BE8]"));
10346
10347       if (flags & EF_ARM_LE8)
10348         fprintf (file, _(" [LE8]"));
10349
10350       flags &= ~(EF_ARM_LE8 | EF_ARM_BE8);
10351       break;
10352
10353     default:
10354       fprintf (file, _(" <EABI version unrecognised>"));
10355       break;
10356     }
10357
10358   flags &= ~ EF_ARM_EABIMASK;
10359
10360   if (flags & EF_ARM_RELEXEC)
10361     fprintf (file, _(" [relocatable executable]"));
10362
10363   if (flags & EF_ARM_HASENTRY)
10364     fprintf (file, _(" [has entry point]"));
10365
10366   flags &= ~ (EF_ARM_RELEXEC | EF_ARM_HASENTRY);
10367
10368   if (flags)
10369     fprintf (file, _("<Unrecognised flag bits set>"));
10370
10371   fputc ('\n', file);
10372
10373   return TRUE;
10374 }
10375
10376 static int
10377 elf32_arm_get_symbol_type (Elf_Internal_Sym * elf_sym, int type)
10378 {
10379   switch (ELF_ST_TYPE (elf_sym->st_info))
10380     {
10381     case STT_ARM_TFUNC:
10382       return ELF_ST_TYPE (elf_sym->st_info);
10383
10384     case STT_ARM_16BIT:
10385       /* If the symbol is not an object, return the STT_ARM_16BIT flag.
10386          This allows us to distinguish between data used by Thumb instructions
10387          and non-data (which is probably code) inside Thumb regions of an
10388          executable.  */
10389       if (type != STT_OBJECT && type != STT_TLS)
10390         return ELF_ST_TYPE (elf_sym->st_info);
10391       break;
10392
10393     default:
10394       break;
10395     }
10396
10397   return type;
10398 }
10399
10400 static asection *
10401 elf32_arm_gc_mark_hook (asection *sec,
10402                         struct bfd_link_info *info,
10403                         Elf_Internal_Rela *rel,
10404                         struct elf_link_hash_entry *h,
10405                         Elf_Internal_Sym *sym)
10406 {
10407   if (h != NULL)
10408     switch (ELF32_R_TYPE (rel->r_info))
10409       {
10410       case R_ARM_GNU_VTINHERIT:
10411       case R_ARM_GNU_VTENTRY:
10412         return NULL;
10413       }
10414
10415   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
10416 }
10417
10418 /* Update the got entry reference counts for the section being removed.  */
10419
10420 static bfd_boolean
10421 elf32_arm_gc_sweep_hook (bfd *                     abfd,
10422                          struct bfd_link_info *    info,
10423                          asection *                sec,
10424                          const Elf_Internal_Rela * relocs)
10425 {
10426   Elf_Internal_Shdr *symtab_hdr;
10427   struct elf_link_hash_entry **sym_hashes;
10428   bfd_signed_vma *local_got_refcounts;
10429   const Elf_Internal_Rela *rel, *relend;
10430   struct elf32_arm_link_hash_table * globals;
10431
10432   if (info->relocatable)
10433     return TRUE;
10434
10435   globals = elf32_arm_hash_table (info);
10436
10437   elf_section_data (sec)->local_dynrel = NULL;
10438
10439   symtab_hdr = & elf_symtab_hdr (abfd);
10440   sym_hashes = elf_sym_hashes (abfd);
10441   local_got_refcounts = elf_local_got_refcounts (abfd);
10442
10443   check_use_blx (globals);
10444
10445   relend = relocs + sec->reloc_count;
10446   for (rel = relocs; rel < relend; rel++)
10447     {
10448       unsigned long r_symndx;
10449       struct elf_link_hash_entry *h = NULL;
10450       int r_type;
10451
10452       r_symndx = ELF32_R_SYM (rel->r_info);
10453       if (r_symndx >= symtab_hdr->sh_info)
10454         {
10455           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
10456           while (h->root.type == bfd_link_hash_indirect
10457                  || h->root.type == bfd_link_hash_warning)
10458             h = (struct elf_link_hash_entry *) h->root.u.i.link;
10459         }
10460
10461       r_type = ELF32_R_TYPE (rel->r_info);
10462       r_type = arm_real_reloc_type (globals, r_type);
10463       switch (r_type)
10464         {
10465         case R_ARM_GOT32:
10466         case R_ARM_GOT_PREL:
10467         case R_ARM_TLS_GD32:
10468         case R_ARM_TLS_IE32:
10469           if (h != NULL)
10470             {
10471               if (h->got.refcount > 0)
10472                 h->got.refcount -= 1;
10473             }
10474           else if (local_got_refcounts != NULL)
10475             {
10476               if (local_got_refcounts[r_symndx] > 0)
10477                 local_got_refcounts[r_symndx] -= 1;
10478             }
10479           break;
10480
10481         case R_ARM_TLS_LDM32:
10482           elf32_arm_hash_table (info)->tls_ldm_got.refcount -= 1;
10483           break;
10484
10485         case R_ARM_ABS32:
10486         case R_ARM_ABS32_NOI:
10487         case R_ARM_REL32:
10488         case R_ARM_REL32_NOI:
10489         case R_ARM_PC24:
10490         case R_ARM_PLT32:
10491         case R_ARM_CALL:
10492         case R_ARM_JUMP24:
10493         case R_ARM_PREL31:
10494         case R_ARM_THM_CALL:
10495         case R_ARM_THM_JUMP24:
10496         case R_ARM_THM_JUMP19:
10497         case R_ARM_MOVW_ABS_NC:
10498         case R_ARM_MOVT_ABS:
10499         case R_ARM_MOVW_PREL_NC:
10500         case R_ARM_MOVT_PREL:
10501         case R_ARM_THM_MOVW_ABS_NC:
10502         case R_ARM_THM_MOVT_ABS:
10503         case R_ARM_THM_MOVW_PREL_NC:
10504         case R_ARM_THM_MOVT_PREL:
10505           /* Should the interworking branches be here also?  */
10506
10507           if (h != NULL)
10508             {
10509               struct elf32_arm_link_hash_entry *eh;
10510               struct elf32_arm_relocs_copied **pp;
10511               struct elf32_arm_relocs_copied *p;
10512
10513               eh = (struct elf32_arm_link_hash_entry *) h;
10514
10515               if (h->plt.refcount > 0)
10516                 {
10517                   h->plt.refcount -= 1;
10518                   if (r_type == R_ARM_THM_CALL)
10519                     eh->plt_maybe_thumb_refcount--;
10520
10521                   if (r_type == R_ARM_THM_JUMP24
10522                       || r_type == R_ARM_THM_JUMP19)
10523                     eh->plt_thumb_refcount--;
10524                 }
10525
10526               if (r_type == R_ARM_ABS32
10527                   || r_type == R_ARM_REL32
10528                   || r_type == R_ARM_ABS32_NOI
10529                   || r_type == R_ARM_REL32_NOI)
10530                 {
10531                   for (pp = &eh->relocs_copied; (p = *pp) != NULL;
10532                        pp = &p->next)
10533                   if (p->section == sec)
10534                     {
10535                       p->count -= 1;
10536                       if (ELF32_R_TYPE (rel->r_info) == R_ARM_REL32
10537                           || ELF32_R_TYPE (rel->r_info) == R_ARM_REL32_NOI)
10538                         p->pc_count -= 1;
10539                       if (p->count == 0)
10540                         *pp = p->next;
10541                       break;
10542                     }
10543                 }
10544             }
10545           break;
10546
10547         default:
10548           break;
10549         }
10550     }
10551
10552   return TRUE;
10553 }
10554
10555 /* Look through the relocs for a section during the first phase.  */
10556
10557 static bfd_boolean
10558 elf32_arm_check_relocs (bfd *abfd, struct bfd_link_info *info,
10559                         asection *sec, const Elf_Internal_Rela *relocs)
10560 {
10561   Elf_Internal_Shdr *symtab_hdr;
10562   struct elf_link_hash_entry **sym_hashes;
10563   const Elf_Internal_Rela *rel;
10564   const Elf_Internal_Rela *rel_end;
10565   bfd *dynobj;
10566   asection *sreloc;
10567   bfd_vma *local_got_offsets;
10568   struct elf32_arm_link_hash_table *htab;
10569   bfd_boolean needs_plt;
10570   unsigned long nsyms;
10571
10572   if (info->relocatable)
10573     return TRUE;
10574
10575   BFD_ASSERT (is_arm_elf (abfd));
10576
10577   htab = elf32_arm_hash_table (info);
10578   sreloc = NULL;
10579
10580   /* Create dynamic sections for relocatable executables so that we can
10581      copy relocations.  */
10582   if (htab->root.is_relocatable_executable
10583       && ! htab->root.dynamic_sections_created)
10584     {
10585       if (! _bfd_elf_link_create_dynamic_sections (abfd, info))
10586         return FALSE;
10587     }
10588
10589   dynobj = elf_hash_table (info)->dynobj;
10590   local_got_offsets = elf_local_got_offsets (abfd);
10591
10592   symtab_hdr = & elf_symtab_hdr (abfd);
10593   sym_hashes = elf_sym_hashes (abfd);
10594   nsyms = NUM_SHDR_ENTRIES (symtab_hdr);
10595
10596   rel_end = relocs + sec->reloc_count;
10597   for (rel = relocs; rel < rel_end; rel++)
10598     {
10599       struct elf_link_hash_entry *h;
10600       struct elf32_arm_link_hash_entry *eh;
10601       unsigned long r_symndx;
10602       int r_type;
10603
10604       r_symndx = ELF32_R_SYM (rel->r_info);
10605       r_type = ELF32_R_TYPE (rel->r_info);
10606       r_type = arm_real_reloc_type (htab, r_type);
10607
10608       if (r_symndx >= nsyms
10609           /* PR 9934: It is possible to have relocations that do not
10610              refer to symbols, thus it is also possible to have an
10611              object file containing relocations but no symbol table.  */
10612           && (r_symndx > 0 || nsyms > 0))
10613         {
10614           (*_bfd_error_handler) (_("%B: bad symbol index: %d"), abfd,
10615                                    r_symndx);
10616           return FALSE;
10617         }
10618
10619       if (nsyms == 0 || r_symndx < symtab_hdr->sh_info)
10620         h = NULL;
10621       else
10622         {
10623           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
10624           while (h->root.type == bfd_link_hash_indirect
10625                  || h->root.type == bfd_link_hash_warning)
10626             h = (struct elf_link_hash_entry *) h->root.u.i.link;
10627         }
10628
10629       eh = (struct elf32_arm_link_hash_entry *) h;
10630
10631       switch (r_type)
10632         {
10633           case R_ARM_GOT32:
10634           case R_ARM_GOT_PREL:
10635           case R_ARM_TLS_GD32:
10636           case R_ARM_TLS_IE32:
10637             /* This symbol requires a global offset table entry.  */
10638             {
10639               int tls_type, old_tls_type;
10640
10641               switch (r_type)
10642                 {
10643                 case R_ARM_TLS_GD32: tls_type = GOT_TLS_GD; break;
10644                 case R_ARM_TLS_IE32: tls_type = GOT_TLS_IE; break;
10645                 default: tls_type = GOT_NORMAL; break;
10646                 }
10647
10648               if (h != NULL)
10649                 {
10650                   h->got.refcount++;
10651                   old_tls_type = elf32_arm_hash_entry (h)->tls_type;
10652                 }
10653               else
10654                 {
10655                   bfd_signed_vma *local_got_refcounts;
10656
10657                   /* This is a global offset table entry for a local symbol.  */
10658                   local_got_refcounts = elf_local_got_refcounts (abfd);
10659                   if (local_got_refcounts == NULL)
10660                     {
10661                       bfd_size_type size;
10662
10663                       size = symtab_hdr->sh_info;
10664                       size *= (sizeof (bfd_signed_vma) + sizeof (char));
10665                       local_got_refcounts = bfd_zalloc (abfd, size);
10666                       if (local_got_refcounts == NULL)
10667                         return FALSE;
10668                       elf_local_got_refcounts (abfd) = local_got_refcounts;
10669                       elf32_arm_local_got_tls_type (abfd)
10670                         = (char *) (local_got_refcounts + symtab_hdr->sh_info);
10671                     }
10672                   local_got_refcounts[r_symndx] += 1;
10673                   old_tls_type = elf32_arm_local_got_tls_type (abfd) [r_symndx];
10674                 }
10675
10676               /* We will already have issued an error message if there is a
10677                  TLS / non-TLS mismatch, based on the symbol type.  We don't
10678                  support any linker relaxations.  So just combine any TLS
10679                  types needed.  */
10680               if (old_tls_type != GOT_UNKNOWN && old_tls_type != GOT_NORMAL
10681                   && tls_type != GOT_NORMAL)
10682                 tls_type |= old_tls_type;
10683
10684               if (old_tls_type != tls_type)
10685                 {
10686                   if (h != NULL)
10687                     elf32_arm_hash_entry (h)->tls_type = tls_type;
10688                   else
10689                     elf32_arm_local_got_tls_type (abfd) [r_symndx] = tls_type;
10690                 }
10691             }
10692             /* Fall through.  */
10693
10694           case R_ARM_TLS_LDM32:
10695             if (r_type == R_ARM_TLS_LDM32)
10696                 htab->tls_ldm_got.refcount++;
10697             /* Fall through.  */
10698
10699           case R_ARM_GOTOFF32:
10700           case R_ARM_GOTPC:
10701             if (htab->sgot == NULL)
10702               {
10703                 if (htab->root.dynobj == NULL)
10704                   htab->root.dynobj = abfd;
10705                 if (!create_got_section (htab->root.dynobj, info))
10706                   return FALSE;
10707               }
10708             break;
10709
10710           case R_ARM_ABS12:
10711             /* VxWorks uses dynamic R_ARM_ABS12 relocations for
10712                ldr __GOTT_INDEX__ offsets.  */
10713             if (!htab->vxworks_p)
10714               break;
10715             /* Fall through.  */
10716
10717           case R_ARM_PC24:
10718           case R_ARM_PLT32:
10719           case R_ARM_CALL:
10720           case R_ARM_JUMP24:
10721           case R_ARM_PREL31:
10722           case R_ARM_THM_CALL:
10723           case R_ARM_THM_JUMP24:
10724           case R_ARM_THM_JUMP19:
10725             needs_plt = 1;
10726             goto normal_reloc;
10727
10728           case R_ARM_MOVW_ABS_NC:
10729           case R_ARM_MOVT_ABS:
10730           case R_ARM_THM_MOVW_ABS_NC:
10731           case R_ARM_THM_MOVT_ABS:
10732             if (info->shared)
10733               {
10734                 (*_bfd_error_handler)
10735                   (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
10736                    abfd, elf32_arm_howto_table_1[r_type].name,
10737                    (h) ? h->root.root.string : "a local symbol");
10738                 bfd_set_error (bfd_error_bad_value);
10739                 return FALSE;
10740               }
10741
10742             /* Fall through.  */
10743           case R_ARM_ABS32:
10744           case R_ARM_ABS32_NOI:
10745           case R_ARM_REL32:
10746           case R_ARM_REL32_NOI:
10747           case R_ARM_MOVW_PREL_NC:
10748           case R_ARM_MOVT_PREL:
10749           case R_ARM_THM_MOVW_PREL_NC:
10750           case R_ARM_THM_MOVT_PREL:
10751             needs_plt = 0;
10752           normal_reloc:
10753
10754             /* Should the interworking branches be listed here?  */
10755             if (h != NULL)
10756               {
10757                 /* If this reloc is in a read-only section, we might
10758                    need a copy reloc.  We can't check reliably at this
10759                    stage whether the section is read-only, as input
10760                    sections have not yet been mapped to output sections.
10761                    Tentatively set the flag for now, and correct in
10762                    adjust_dynamic_symbol.  */
10763                 if (!info->shared)
10764                   h->non_got_ref = 1;
10765
10766                 /* We may need a .plt entry if the function this reloc
10767                    refers to is in a different object.  We can't tell for
10768                    sure yet, because something later might force the
10769                    symbol local.  */
10770                 if (needs_plt)
10771                   h->needs_plt = 1;
10772
10773                 /* If we create a PLT entry, this relocation will reference
10774                    it, even if it's an ABS32 relocation.  */
10775                 h->plt.refcount += 1;
10776
10777                 /* It's too early to use htab->use_blx here, so we have to
10778                    record possible blx references separately from
10779                    relocs that definitely need a thumb stub.  */
10780
10781                 if (r_type == R_ARM_THM_CALL)
10782                   eh->plt_maybe_thumb_refcount += 1;
10783
10784                 if (r_type == R_ARM_THM_JUMP24
10785                     || r_type == R_ARM_THM_JUMP19)
10786                   eh->plt_thumb_refcount += 1;
10787               }
10788
10789             /* If we are creating a shared library or relocatable executable,
10790                and this is a reloc against a global symbol, or a non PC
10791                relative reloc against a local symbol, then we need to copy
10792                the reloc into the shared library.  However, if we are linking
10793                with -Bsymbolic, we do not need to copy a reloc against a
10794                global symbol which is defined in an object we are
10795                including in the link (i.e., DEF_REGULAR is set).  At
10796                this point we have not seen all the input files, so it is
10797                possible that DEF_REGULAR is not set now but will be set
10798                later (it is never cleared).  We account for that
10799                possibility below by storing information in the
10800                relocs_copied field of the hash table entry.  */
10801             if ((info->shared || htab->root.is_relocatable_executable)
10802                 && (sec->flags & SEC_ALLOC) != 0
10803                 && ((r_type == R_ARM_ABS32 || r_type == R_ARM_ABS32_NOI)
10804                     || (h != NULL && ! h->needs_plt
10805                         && (! info->symbolic || ! h->def_regular))))
10806               {
10807                 struct elf32_arm_relocs_copied *p, **head;
10808
10809                 /* When creating a shared object, we must copy these
10810                    reloc types into the output file.  We create a reloc
10811                    section in dynobj and make room for this reloc.  */
10812                 if (sreloc == NULL)
10813                   {
10814                     sreloc = _bfd_elf_make_dynamic_reloc_section
10815                       (sec, dynobj, 2, abfd, ! htab->use_rel);
10816
10817                     if (sreloc == NULL)
10818                       return FALSE;
10819
10820                     /* BPABI objects never have dynamic relocations mapped.  */
10821                     if (htab->symbian_p)
10822                       {
10823                         flagword flags;
10824
10825                         flags = bfd_get_section_flags (dynobj, sreloc);
10826                         flags &= ~(SEC_LOAD | SEC_ALLOC);
10827                         bfd_set_section_flags (dynobj, sreloc, flags);
10828                       }
10829                   }
10830
10831                 /* If this is a global symbol, we count the number of
10832                    relocations we need for this symbol.  */
10833                 if (h != NULL)
10834                   {
10835                     head = &((struct elf32_arm_link_hash_entry *) h)->relocs_copied;
10836                   }
10837                 else
10838                   {
10839                     /* Track dynamic relocs needed for local syms too.
10840                        We really need local syms available to do this
10841                        easily.  Oh well.  */
10842
10843                     asection *s;
10844                     void *vpp;
10845
10846                     s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
10847                                                    sec, r_symndx);
10848                     if (s == NULL)
10849                       return FALSE;
10850
10851                     vpp = &elf_section_data (s)->local_dynrel;
10852                     head = (struct elf32_arm_relocs_copied **) vpp;
10853                   }
10854
10855                 p = *head;
10856                 if (p == NULL || p->section != sec)
10857                   {
10858                     bfd_size_type amt = sizeof *p;
10859
10860                     p = bfd_alloc (htab->root.dynobj, amt);
10861                     if (p == NULL)
10862                       return FALSE;
10863                     p->next = *head;
10864                     *head = p;
10865                     p->section = sec;
10866                     p->count = 0;
10867                     p->pc_count = 0;
10868                   }
10869
10870                 if (r_type == R_ARM_REL32 || r_type == R_ARM_REL32_NOI)
10871                   p->pc_count += 1;
10872                 p->count += 1;
10873               }
10874             break;
10875
10876         /* This relocation describes the C++ object vtable hierarchy.
10877            Reconstruct it for later use during GC.  */
10878         case R_ARM_GNU_VTINHERIT:
10879           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
10880             return FALSE;
10881           break;
10882
10883         /* This relocation describes which C++ vtable entries are actually
10884            used.  Record for later use during GC.  */
10885         case R_ARM_GNU_VTENTRY:
10886           BFD_ASSERT (h != NULL);
10887           if (h != NULL
10888               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
10889             return FALSE;
10890           break;
10891         }
10892     }
10893
10894   return TRUE;
10895 }
10896
10897 /* Unwinding tables are not referenced directly.  This pass marks them as
10898    required if the corresponding code section is marked.  */
10899
10900 static bfd_boolean
10901 elf32_arm_gc_mark_extra_sections (struct bfd_link_info *info,
10902                                   elf_gc_mark_hook_fn gc_mark_hook)
10903 {
10904   bfd *sub;
10905   Elf_Internal_Shdr **elf_shdrp;
10906   bfd_boolean again;
10907
10908   /* Marking EH data may cause additional code sections to be marked,
10909      requiring multiple passes.  */
10910   again = TRUE;
10911   while (again)
10912     {
10913       again = FALSE;
10914       for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
10915         {
10916           asection *o;
10917
10918           if (! is_arm_elf (sub))
10919             continue;
10920
10921           elf_shdrp = elf_elfsections (sub);
10922           for (o = sub->sections; o != NULL; o = o->next)
10923             {
10924               Elf_Internal_Shdr *hdr;
10925
10926               hdr = &elf_section_data (o)->this_hdr;
10927               if (hdr->sh_type == SHT_ARM_EXIDX
10928                   && hdr->sh_link
10929                   && hdr->sh_link < elf_numsections (sub)
10930                   && !o->gc_mark
10931                   && elf_shdrp[hdr->sh_link]->bfd_section->gc_mark)
10932                 {
10933                   again = TRUE;
10934                   if (!_bfd_elf_gc_mark (info, o, gc_mark_hook))
10935                     return FALSE;
10936                 }
10937             }
10938         }
10939     }
10940
10941   return TRUE;
10942 }
10943
10944 /* Treat mapping symbols as special target symbols.  */
10945
10946 static bfd_boolean
10947 elf32_arm_is_target_special_symbol (bfd * abfd ATTRIBUTE_UNUSED, asymbol * sym)
10948 {
10949   return bfd_is_arm_special_symbol_name (sym->name,
10950                                          BFD_ARM_SPECIAL_SYM_TYPE_ANY);
10951 }
10952
10953 /* This is a copy of elf_find_function() from elf.c except that
10954    ARM mapping symbols are ignored when looking for function names
10955    and STT_ARM_TFUNC is considered to a function type.  */
10956
10957 static bfd_boolean
10958 arm_elf_find_function (bfd *         abfd ATTRIBUTE_UNUSED,
10959                        asection *    section,
10960                        asymbol **    symbols,
10961                        bfd_vma       offset,
10962                        const char ** filename_ptr,
10963                        const char ** functionname_ptr)
10964 {
10965   const char * filename = NULL;
10966   asymbol * func = NULL;
10967   bfd_vma low_func = 0;
10968   asymbol ** p;
10969
10970   for (p = symbols; *p != NULL; p++)
10971     {
10972       elf_symbol_type *q;
10973
10974       q = (elf_symbol_type *) *p;
10975
10976       switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
10977         {
10978         default:
10979           break;
10980         case STT_FILE:
10981           filename = bfd_asymbol_name (&q->symbol);
10982           break;
10983         case STT_FUNC:
10984         case STT_ARM_TFUNC:
10985         case STT_NOTYPE:
10986           /* Skip mapping symbols.  */
10987           if ((q->symbol.flags & BSF_LOCAL)
10988               && bfd_is_arm_special_symbol_name (q->symbol.name,
10989                     BFD_ARM_SPECIAL_SYM_TYPE_ANY))
10990             continue;
10991           /* Fall through.  */
10992           if (bfd_get_section (&q->symbol) == section
10993               && q->symbol.value >= low_func
10994               && q->symbol.value <= offset)
10995             {
10996               func = (asymbol *) q;
10997               low_func = q->symbol.value;
10998             }
10999           break;
11000         }
11001     }
11002
11003   if (func == NULL)
11004     return FALSE;
11005
11006   if (filename_ptr)
11007     *filename_ptr = filename;
11008   if (functionname_ptr)
11009     *functionname_ptr = bfd_asymbol_name (func);
11010
11011   return TRUE;
11012 }
11013
11014
11015 /* Find the nearest line to a particular section and offset, for error
11016    reporting.   This code is a duplicate of the code in elf.c, except
11017    that it uses arm_elf_find_function.  */
11018
11019 static bfd_boolean
11020 elf32_arm_find_nearest_line (bfd *          abfd,
11021                              asection *     section,
11022                              asymbol **     symbols,
11023                              bfd_vma        offset,
11024                              const char **  filename_ptr,
11025                              const char **  functionname_ptr,
11026                              unsigned int * line_ptr)
11027 {
11028   bfd_boolean found = FALSE;
11029
11030   /* We skip _bfd_dwarf1_find_nearest_line since no known ARM toolchain uses it.  */
11031
11032   if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
11033                                      filename_ptr, functionname_ptr,
11034                                      line_ptr, 0,
11035                                      & elf_tdata (abfd)->dwarf2_find_line_info))
11036     {
11037       if (!*functionname_ptr)
11038         arm_elf_find_function (abfd, section, symbols, offset,
11039                                *filename_ptr ? NULL : filename_ptr,
11040                                functionname_ptr);
11041
11042       return TRUE;
11043     }
11044
11045   if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
11046                                              & found, filename_ptr,
11047                                              functionname_ptr, line_ptr,
11048                                              & elf_tdata (abfd)->line_info))
11049     return FALSE;
11050
11051   if (found && (*functionname_ptr || *line_ptr))
11052     return TRUE;
11053
11054   if (symbols == NULL)
11055     return FALSE;
11056
11057   if (! arm_elf_find_function (abfd, section, symbols, offset,
11058                                filename_ptr, functionname_ptr))
11059     return FALSE;
11060
11061   *line_ptr = 0;
11062   return TRUE;
11063 }
11064
11065 static bfd_boolean
11066 elf32_arm_find_inliner_info (bfd *          abfd,
11067                              const char **  filename_ptr,
11068                              const char **  functionname_ptr,
11069                              unsigned int * line_ptr)
11070 {
11071   bfd_boolean found;
11072   found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
11073                                          functionname_ptr, line_ptr,
11074                                          & elf_tdata (abfd)->dwarf2_find_line_info);
11075   return found;
11076 }
11077
11078 /* Adjust a symbol defined by a dynamic object and referenced by a
11079    regular object.  The current definition is in some section of the
11080    dynamic object, but we're not including those sections.  We have to
11081    change the definition to something the rest of the link can
11082    understand.  */
11083
11084 static bfd_boolean
11085 elf32_arm_adjust_dynamic_symbol (struct bfd_link_info * info,
11086                                  struct elf_link_hash_entry * h)
11087 {
11088   bfd * dynobj;
11089   asection * s;
11090   struct elf32_arm_link_hash_entry * eh;
11091   struct elf32_arm_link_hash_table *globals;
11092
11093   globals = elf32_arm_hash_table (info);
11094   dynobj = elf_hash_table (info)->dynobj;
11095
11096   /* Make sure we know what is going on here.  */
11097   BFD_ASSERT (dynobj != NULL
11098               && (h->needs_plt
11099                   || h->u.weakdef != NULL
11100                   || (h->def_dynamic
11101                       && h->ref_regular
11102                       && !h->def_regular)));
11103
11104   eh = (struct elf32_arm_link_hash_entry *) h;
11105
11106   /* If this is a function, put it in the procedure linkage table.  We
11107      will fill in the contents of the procedure linkage table later,
11108      when we know the address of the .got section.  */
11109   if (h->type == STT_FUNC || h->type == STT_ARM_TFUNC
11110       || h->needs_plt)
11111     {
11112       if (h->plt.refcount <= 0
11113           || SYMBOL_CALLS_LOCAL (info, h)
11114           || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
11115               && h->root.type == bfd_link_hash_undefweak))
11116         {
11117           /* This case can occur if we saw a PLT32 reloc in an input
11118              file, but the symbol was never referred to by a dynamic
11119              object, or if all references were garbage collected.  In
11120              such a case, we don't actually need to build a procedure
11121              linkage table, and we can just do a PC24 reloc instead.  */
11122           h->plt.offset = (bfd_vma) -1;
11123           eh->plt_thumb_refcount = 0;
11124           eh->plt_maybe_thumb_refcount = 0;
11125           h->needs_plt = 0;
11126         }
11127
11128       return TRUE;
11129     }
11130   else
11131     {
11132       /* It's possible that we incorrectly decided a .plt reloc was
11133          needed for an R_ARM_PC24 or similar reloc to a non-function sym
11134          in check_relocs.  We can't decide accurately between function
11135          and non-function syms in check-relocs; Objects loaded later in
11136          the link may change h->type.  So fix it now.  */
11137       h->plt.offset = (bfd_vma) -1;
11138       eh->plt_thumb_refcount = 0;
11139       eh->plt_maybe_thumb_refcount = 0;
11140     }
11141
11142   /* If this is a weak symbol, and there is a real definition, the
11143      processor independent code will have arranged for us to see the
11144      real definition first, and we can just use the same value.  */
11145   if (h->u.weakdef != NULL)
11146     {
11147       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
11148                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
11149       h->root.u.def.section = h->u.weakdef->root.u.def.section;
11150       h->root.u.def.value = h->u.weakdef->root.u.def.value;
11151       return TRUE;
11152     }
11153
11154   /* If there are no non-GOT references, we do not need a copy
11155      relocation.  */
11156   if (!h->non_got_ref)
11157     return TRUE;
11158
11159   /* This is a reference to a symbol defined by a dynamic object which
11160      is not a function.  */
11161
11162   /* If we are creating a shared library, we must presume that the
11163      only references to the symbol are via the global offset table.
11164      For such cases we need not do anything here; the relocations will
11165      be handled correctly by relocate_section.  Relocatable executables
11166      can reference data in shared objects directly, so we don't need to
11167      do anything here.  */
11168   if (info->shared || globals->root.is_relocatable_executable)
11169     return TRUE;
11170
11171   if (h->size == 0)
11172     {
11173       (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
11174                              h->root.root.string);
11175       return TRUE;
11176     }
11177
11178   /* We must allocate the symbol in our .dynbss section, which will
11179      become part of the .bss section of the executable.  There will be
11180      an entry for this symbol in the .dynsym section.  The dynamic
11181      object will contain position independent code, so all references
11182      from the dynamic object to this symbol will go through the global
11183      offset table.  The dynamic linker will use the .dynsym entry to
11184      determine the address it must put in the global offset table, so
11185      both the dynamic object and the regular object will refer to the
11186      same memory location for the variable.  */
11187   s = bfd_get_section_by_name (dynobj, ".dynbss");
11188   BFD_ASSERT (s != NULL);
11189
11190   /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
11191      copy the initial value out of the dynamic object and into the
11192      runtime process image.  We need to remember the offset into the
11193      .rel(a).bss section we are going to use.  */
11194   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
11195     {
11196       asection *srel;
11197
11198       srel = bfd_get_section_by_name (dynobj, RELOC_SECTION (globals, ".bss"));
11199       BFD_ASSERT (srel != NULL);
11200       srel->size += RELOC_SIZE (globals);
11201       h->needs_copy = 1;
11202     }
11203
11204   return _bfd_elf_adjust_dynamic_copy (h, s);
11205 }
11206
11207 /* Allocate space in .plt, .got and associated reloc sections for
11208    dynamic relocs.  */
11209
11210 static bfd_boolean
11211 allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
11212 {
11213   struct bfd_link_info *info;
11214   struct elf32_arm_link_hash_table *htab;
11215   struct elf32_arm_link_hash_entry *eh;
11216   struct elf32_arm_relocs_copied *p;
11217   bfd_signed_vma thumb_refs;
11218
11219   eh = (struct elf32_arm_link_hash_entry *) h;
11220
11221   if (h->root.type == bfd_link_hash_indirect)
11222     return TRUE;
11223
11224   if (h->root.type == bfd_link_hash_warning)
11225     /* When warning symbols are created, they **replace** the "real"
11226        entry in the hash table, thus we never get to see the real
11227        symbol in a hash traversal.  So look at it now.  */
11228     h = (struct elf_link_hash_entry *) h->root.u.i.link;
11229
11230   info = (struct bfd_link_info *) inf;
11231   htab = elf32_arm_hash_table (info);
11232
11233   if (htab->root.dynamic_sections_created
11234       && h->plt.refcount > 0)
11235     {
11236       /* Make sure this symbol is output as a dynamic symbol.
11237          Undefined weak syms won't yet be marked as dynamic.  */
11238       if (h->dynindx == -1
11239           && !h->forced_local)
11240         {
11241           if (! bfd_elf_link_record_dynamic_symbol (info, h))
11242             return FALSE;
11243         }
11244
11245       if (info->shared
11246           || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
11247         {
11248           asection *s = htab->splt;
11249
11250           /* If this is the first .plt entry, make room for the special
11251              first entry.  */
11252           if (s->size == 0)
11253             s->size += htab->plt_header_size;
11254
11255           h->plt.offset = s->size;
11256
11257           /* If we will insert a Thumb trampoline before this PLT, leave room
11258              for it.  */
11259           thumb_refs = eh->plt_thumb_refcount;
11260           if (!htab->use_blx)
11261             thumb_refs += eh->plt_maybe_thumb_refcount;
11262
11263           if (thumb_refs > 0)
11264             {
11265               h->plt.offset += PLT_THUMB_STUB_SIZE;
11266               s->size += PLT_THUMB_STUB_SIZE;
11267             }
11268
11269           /* If this symbol is not defined in a regular file, and we are
11270              not generating a shared library, then set the symbol to this
11271              location in the .plt.  This is required to make function
11272              pointers compare as equal between the normal executable and
11273              the shared library.  */
11274           if (! info->shared
11275               && !h->def_regular)
11276             {
11277               h->root.u.def.section = s;
11278               h->root.u.def.value = h->plt.offset;
11279
11280               /* Make sure the function is not marked as Thumb, in case
11281                  it is the target of an ABS32 relocation, which will
11282                  point to the PLT entry.  */
11283               if (ELF_ST_TYPE (h->type) == STT_ARM_TFUNC)
11284                 h->type = ELF_ST_INFO (ELF_ST_BIND (h->type), STT_FUNC);
11285             }
11286
11287           /* Make room for this entry.  */
11288           s->size += htab->plt_entry_size;
11289
11290           if (!htab->symbian_p)
11291             {
11292               /* We also need to make an entry in the .got.plt section, which
11293                  will be placed in the .got section by the linker script.  */
11294               eh->plt_got_offset = htab->sgotplt->size;
11295               htab->sgotplt->size += 4;
11296             }
11297
11298           /* We also need to make an entry in the .rel(a).plt section.  */
11299           htab->srelplt->size += RELOC_SIZE (htab);
11300
11301           /* VxWorks executables have a second set of relocations for
11302              each PLT entry.  They go in a separate relocation section,
11303              which is processed by the kernel loader.  */
11304           if (htab->vxworks_p && !info->shared)
11305             {
11306               /* There is a relocation for the initial PLT entry:
11307                  an R_ARM_32 relocation for _GLOBAL_OFFSET_TABLE_.  */
11308               if (h->plt.offset == htab->plt_header_size)
11309                 htab->srelplt2->size += RELOC_SIZE (htab);
11310
11311               /* There are two extra relocations for each subsequent
11312                  PLT entry: an R_ARM_32 relocation for the GOT entry,
11313                  and an R_ARM_32 relocation for the PLT entry.  */
11314               htab->srelplt2->size += RELOC_SIZE (htab) * 2;
11315             }
11316         }
11317       else
11318         {
11319           h->plt.offset = (bfd_vma) -1;
11320           h->needs_plt = 0;
11321         }
11322     }
11323   else
11324     {
11325       h->plt.offset = (bfd_vma) -1;
11326       h->needs_plt = 0;
11327     }
11328
11329   if (h->got.refcount > 0)
11330     {
11331       asection *s;
11332       bfd_boolean dyn;
11333       int tls_type = elf32_arm_hash_entry (h)->tls_type;
11334       int indx;
11335
11336       /* Make sure this symbol is output as a dynamic symbol.
11337          Undefined weak syms won't yet be marked as dynamic.  */
11338       if (h->dynindx == -1
11339           && !h->forced_local)
11340         {
11341           if (! bfd_elf_link_record_dynamic_symbol (info, h))
11342             return FALSE;
11343         }
11344
11345       if (!htab->symbian_p)
11346         {
11347           s = htab->sgot;
11348           h->got.offset = s->size;
11349
11350           if (tls_type == GOT_UNKNOWN)
11351             abort ();
11352
11353           if (tls_type == GOT_NORMAL)
11354             /* Non-TLS symbols need one GOT slot.  */
11355             s->size += 4;
11356           else
11357             {
11358               if (tls_type & GOT_TLS_GD)
11359                 /* R_ARM_TLS_GD32 needs 2 consecutive GOT slots.  */
11360                 s->size += 8;
11361               if (tls_type & GOT_TLS_IE)
11362                 /* R_ARM_TLS_IE32 needs one GOT slot.  */
11363                 s->size += 4;
11364             }
11365
11366           dyn = htab->root.dynamic_sections_created;
11367
11368           indx = 0;
11369           if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
11370               && (!info->shared
11371                   || !SYMBOL_REFERENCES_LOCAL (info, h)))
11372             indx = h->dynindx;
11373
11374           if (tls_type != GOT_NORMAL
11375               && (info->shared || indx != 0)
11376               && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
11377                   || h->root.type != bfd_link_hash_undefweak))
11378             {
11379               if (tls_type & GOT_TLS_IE)
11380                 htab->srelgot->size += RELOC_SIZE (htab);
11381
11382               if (tls_type & GOT_TLS_GD)
11383                 htab->srelgot->size += RELOC_SIZE (htab);
11384
11385               if ((tls_type & GOT_TLS_GD) && indx != 0)
11386                 htab->srelgot->size += RELOC_SIZE (htab);
11387             }
11388           else if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
11389                     || h->root.type != bfd_link_hash_undefweak)
11390                    && (info->shared
11391                    || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
11392             htab->srelgot->size += RELOC_SIZE (htab);
11393         }
11394     }
11395   else
11396     h->got.offset = (bfd_vma) -1;
11397
11398   /* Allocate stubs for exported Thumb functions on v4t.  */
11399   if (!htab->use_blx && h->dynindx != -1
11400       && h->def_regular
11401       && ELF_ST_TYPE (h->type) == STT_ARM_TFUNC
11402       && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
11403     {
11404       struct elf_link_hash_entry * th;
11405       struct bfd_link_hash_entry * bh;
11406       struct elf_link_hash_entry * myh;
11407       char name[1024];
11408       asection *s;
11409       bh = NULL;
11410       /* Create a new symbol to regist the real location of the function.  */
11411       s = h->root.u.def.section;
11412       sprintf (name, "__real_%s", h->root.root.string);
11413       _bfd_generic_link_add_one_symbol (info, s->owner,
11414                                         name, BSF_GLOBAL, s,
11415                                         h->root.u.def.value,
11416                                         NULL, TRUE, FALSE, &bh);
11417
11418       myh = (struct elf_link_hash_entry *) bh;
11419       myh->type = ELF_ST_INFO (STB_LOCAL, STT_ARM_TFUNC);
11420       myh->forced_local = 1;
11421       eh->export_glue = myh;
11422       th = record_arm_to_thumb_glue (info, h);
11423       /* Point the symbol at the stub.  */
11424       h->type = ELF_ST_INFO (ELF_ST_BIND (h->type), STT_FUNC);
11425       h->root.u.def.section = th->root.u.def.section;
11426       h->root.u.def.value = th->root.u.def.value & ~1;
11427     }
11428
11429   if (eh->relocs_copied == NULL)
11430     return TRUE;
11431
11432   /* In the shared -Bsymbolic case, discard space allocated for
11433      dynamic pc-relative relocs against symbols which turn out to be
11434      defined in regular objects.  For the normal shared case, discard
11435      space for pc-relative relocs that have become local due to symbol
11436      visibility changes.  */
11437
11438   if (info->shared || htab->root.is_relocatable_executable)
11439     {
11440       /* The only relocs that use pc_count are R_ARM_REL32 and
11441          R_ARM_REL32_NOI, which will appear on something like
11442          ".long foo - .".  We want calls to protected symbols to resolve
11443          directly to the function rather than going via the plt.  If people
11444          want function pointer comparisons to work as expected then they
11445          should avoid writing assembly like ".long foo - .".  */
11446       if (SYMBOL_CALLS_LOCAL (info, h))
11447         {
11448           struct elf32_arm_relocs_copied **pp;
11449
11450           for (pp = &eh->relocs_copied; (p = *pp) != NULL; )
11451             {
11452               p->count -= p->pc_count;
11453               p->pc_count = 0;
11454               if (p->count == 0)
11455                 *pp = p->next;
11456               else
11457                 pp = &p->next;
11458             }
11459         }
11460
11461       if (elf32_arm_hash_table (info)->vxworks_p)
11462         {
11463           struct elf32_arm_relocs_copied **pp;
11464
11465           for (pp = &eh->relocs_copied; (p = *pp) != NULL; )
11466             {
11467               if (strcmp (p->section->output_section->name, ".tls_vars") == 0)
11468                 *pp = p->next;
11469               else
11470                 pp = &p->next;
11471             }
11472         }
11473
11474       /* Also discard relocs on undefined weak syms with non-default
11475          visibility.  */
11476       if (eh->relocs_copied != NULL
11477           && h->root.type == bfd_link_hash_undefweak)
11478         {
11479           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
11480             eh->relocs_copied = NULL;
11481
11482           /* Make sure undefined weak symbols are output as a dynamic
11483              symbol in PIEs.  */
11484           else if (h->dynindx == -1
11485                    && !h->forced_local)
11486             {
11487               if (! bfd_elf_link_record_dynamic_symbol (info, h))
11488                 return FALSE;
11489             }
11490         }
11491
11492       else if (htab->root.is_relocatable_executable && h->dynindx == -1
11493                && h->root.type == bfd_link_hash_new)
11494         {
11495           /* Output absolute symbols so that we can create relocations
11496              against them.  For normal symbols we output a relocation
11497              against the section that contains them.  */
11498           if (! bfd_elf_link_record_dynamic_symbol (info, h))
11499             return FALSE;
11500         }
11501
11502     }
11503   else
11504     {
11505       /* For the non-shared case, discard space for relocs against
11506          symbols which turn out to need copy relocs or are not
11507          dynamic.  */
11508
11509       if (!h->non_got_ref
11510           && ((h->def_dynamic
11511                && !h->def_regular)
11512               || (htab->root.dynamic_sections_created
11513                   && (h->root.type == bfd_link_hash_undefweak
11514                       || h->root.type == bfd_link_hash_undefined))))
11515         {
11516           /* Make sure this symbol is output as a dynamic symbol.
11517              Undefined weak syms won't yet be marked as dynamic.  */
11518           if (h->dynindx == -1
11519               && !h->forced_local)
11520             {
11521               if (! bfd_elf_link_record_dynamic_symbol (info, h))
11522                 return FALSE;
11523             }
11524
11525           /* If that succeeded, we know we'll be keeping all the
11526              relocs.  */
11527           if (h->dynindx != -1)
11528             goto keep;
11529         }
11530
11531       eh->relocs_copied = NULL;
11532
11533     keep: ;
11534     }
11535
11536   /* Finally, allocate space.  */
11537   for (p = eh->relocs_copied; p != NULL; p = p->next)
11538     {
11539       asection *sreloc = elf_section_data (p->section)->sreloc;
11540       sreloc->size += p->count * RELOC_SIZE (htab);
11541     }
11542
11543   return TRUE;
11544 }
11545
11546 /* Find any dynamic relocs that apply to read-only sections.  */
11547
11548 static bfd_boolean
11549 elf32_arm_readonly_dynrelocs (struct elf_link_hash_entry * h, void * inf)
11550 {
11551   struct elf32_arm_link_hash_entry * eh;
11552   struct elf32_arm_relocs_copied * p;
11553
11554   if (h->root.type == bfd_link_hash_warning)
11555     h = (struct elf_link_hash_entry *) h->root.u.i.link;
11556
11557   eh = (struct elf32_arm_link_hash_entry *) h;
11558   for (p = eh->relocs_copied; p != NULL; p = p->next)
11559     {
11560       asection *s = p->section;
11561
11562       if (s != NULL && (s->flags & SEC_READONLY) != 0)
11563         {
11564           struct bfd_link_info *info = (struct bfd_link_info *) inf;
11565
11566           info->flags |= DF_TEXTREL;
11567
11568           /* Not an error, just cut short the traversal.  */
11569           return FALSE;
11570         }
11571     }
11572   return TRUE;
11573 }
11574
11575 void
11576 bfd_elf32_arm_set_byteswap_code (struct bfd_link_info *info,
11577                                  int byteswap_code)
11578 {
11579   struct elf32_arm_link_hash_table *globals;
11580
11581   globals = elf32_arm_hash_table (info);
11582   globals->byteswap_code = byteswap_code;
11583 }
11584
11585 /* Set the sizes of the dynamic sections.  */
11586
11587 static bfd_boolean
11588 elf32_arm_size_dynamic_sections (bfd * output_bfd ATTRIBUTE_UNUSED,
11589                                  struct bfd_link_info * info)
11590 {
11591   bfd * dynobj;
11592   asection * s;
11593   bfd_boolean plt;
11594   bfd_boolean relocs;
11595   bfd *ibfd;
11596   struct elf32_arm_link_hash_table *htab;
11597
11598   htab = elf32_arm_hash_table (info);
11599   dynobj = elf_hash_table (info)->dynobj;
11600   BFD_ASSERT (dynobj != NULL);
11601   check_use_blx (htab);
11602
11603   if (elf_hash_table (info)->dynamic_sections_created)
11604     {
11605       /* Set the contents of the .interp section to the interpreter.  */
11606       if (info->executable)
11607         {
11608           s = bfd_get_section_by_name (dynobj, ".interp");
11609           BFD_ASSERT (s != NULL);
11610           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
11611           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
11612         }
11613     }
11614
11615   /* Set up .got offsets for local syms, and space for local dynamic
11616      relocs.  */
11617   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11618     {
11619       bfd_signed_vma *local_got;
11620       bfd_signed_vma *end_local_got;
11621       char *local_tls_type;
11622       bfd_size_type locsymcount;
11623       Elf_Internal_Shdr *symtab_hdr;
11624       asection *srel;
11625       bfd_boolean is_vxworks = elf32_arm_hash_table (info)->vxworks_p;
11626
11627       if (! is_arm_elf (ibfd))
11628         continue;
11629
11630       for (s = ibfd->sections; s != NULL; s = s->next)
11631         {
11632           struct elf32_arm_relocs_copied *p;
11633
11634           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
11635             {
11636               if (!bfd_is_abs_section (p->section)
11637                   && bfd_is_abs_section (p->section->output_section))
11638                 {
11639                   /* Input section has been discarded, either because
11640                      it is a copy of a linkonce section or due to
11641                      linker script /DISCARD/, so we'll be discarding
11642                      the relocs too.  */
11643                 }
11644               else if (is_vxworks
11645                        && strcmp (p->section->output_section->name,
11646                                   ".tls_vars") == 0)
11647                 {
11648                   /* Relocations in vxworks .tls_vars sections are
11649                      handled specially by the loader.  */
11650                 }
11651               else if (p->count != 0)
11652                 {
11653                   srel = elf_section_data (p->section)->sreloc;
11654                   srel->size += p->count * RELOC_SIZE (htab);
11655                   if ((p->section->output_section->flags & SEC_READONLY) != 0)
11656                     info->flags |= DF_TEXTREL;
11657                 }
11658             }
11659         }
11660
11661       local_got = elf_local_got_refcounts (ibfd);
11662       if (!local_got)
11663         continue;
11664
11665       symtab_hdr = & elf_symtab_hdr (ibfd);
11666       locsymcount = symtab_hdr->sh_info;
11667       end_local_got = local_got + locsymcount;
11668       local_tls_type = elf32_arm_local_got_tls_type (ibfd);
11669       s = htab->sgot;
11670       srel = htab->srelgot;
11671       for (; local_got < end_local_got; ++local_got, ++local_tls_type)
11672         {
11673           if (*local_got > 0)
11674             {
11675               *local_got = s->size;
11676               if (*local_tls_type & GOT_TLS_GD)
11677                 /* TLS_GD relocs need an 8-byte structure in the GOT.  */
11678                 s->size += 8;
11679               if (*local_tls_type & GOT_TLS_IE)
11680                 s->size += 4;
11681               if (*local_tls_type == GOT_NORMAL)
11682                 s->size += 4;
11683
11684               if (info->shared || *local_tls_type == GOT_TLS_GD)
11685                 srel->size += RELOC_SIZE (htab);
11686             }
11687           else
11688             *local_got = (bfd_vma) -1;
11689         }
11690     }
11691
11692   if (htab->tls_ldm_got.refcount > 0)
11693     {
11694       /* Allocate two GOT entries and one dynamic relocation (if necessary)
11695          for R_ARM_TLS_LDM32 relocations.  */
11696       htab->tls_ldm_got.offset = htab->sgot->size;
11697       htab->sgot->size += 8;
11698       if (info->shared)
11699         htab->srelgot->size += RELOC_SIZE (htab);
11700     }
11701   else
11702     htab->tls_ldm_got.offset = -1;
11703
11704   /* Allocate global sym .plt and .got entries, and space for global
11705      sym dynamic relocs.  */
11706   elf_link_hash_traverse (& htab->root, allocate_dynrelocs, info);
11707
11708   /* Here we rummage through the found bfds to collect glue information.  */
11709   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11710     {
11711       if (! is_arm_elf (ibfd))
11712         continue;
11713
11714       /* Initialise mapping tables for code/data.  */
11715       bfd_elf32_arm_init_maps (ibfd);
11716
11717       if (!bfd_elf32_arm_process_before_allocation (ibfd, info)
11718           || !bfd_elf32_arm_vfp11_erratum_scan (ibfd, info))
11719         /* xgettext:c-format */
11720         _bfd_error_handler (_("Errors encountered processing file %s"),
11721                             ibfd->filename);
11722     }
11723
11724   /* Allocate space for the glue sections now that we've sized them.  */
11725   bfd_elf32_arm_allocate_interworking_sections (info);
11726
11727   /* The check_relocs and adjust_dynamic_symbol entry points have
11728      determined the sizes of the various dynamic sections.  Allocate
11729      memory for them.  */
11730   plt = FALSE;
11731   relocs = FALSE;
11732   for (s = dynobj->sections; s != NULL; s = s->next)
11733     {
11734       const char * name;
11735
11736       if ((s->flags & SEC_LINKER_CREATED) == 0)
11737         continue;
11738
11739       /* It's OK to base decisions on the section name, because none
11740          of the dynobj section names depend upon the input files.  */
11741       name = bfd_get_section_name (dynobj, s);
11742
11743       if (strcmp (name, ".plt") == 0)
11744         {
11745           /* Remember whether there is a PLT.  */
11746           plt = s->size != 0;
11747         }
11748       else if (CONST_STRNEQ (name, ".rel"))
11749         {
11750           if (s->size != 0)
11751             {
11752               /* Remember whether there are any reloc sections other
11753                  than .rel(a).plt and .rela.plt.unloaded.  */
11754               if (s != htab->srelplt && s != htab->srelplt2)
11755                 relocs = TRUE;
11756
11757               /* We use the reloc_count field as a counter if we need
11758                  to copy relocs into the output file.  */
11759               s->reloc_count = 0;
11760             }
11761         }
11762       else if (! CONST_STRNEQ (name, ".got")
11763                && strcmp (name, ".dynbss") != 0)
11764         {
11765           /* It's not one of our sections, so don't allocate space.  */
11766           continue;
11767         }
11768
11769       if (s->size == 0)
11770         {
11771           /* If we don't need this section, strip it from the
11772              output file.  This is mostly to handle .rel(a).bss and
11773              .rel(a).plt.  We must create both sections in
11774              create_dynamic_sections, because they must be created
11775              before the linker maps input sections to output
11776              sections.  The linker does that before
11777              adjust_dynamic_symbol is called, and it is that
11778              function which decides whether anything needs to go
11779              into these sections.  */
11780           s->flags |= SEC_EXCLUDE;
11781           continue;
11782         }
11783
11784       if ((s->flags & SEC_HAS_CONTENTS) == 0)
11785         continue;
11786
11787       /* Allocate memory for the section contents.  */
11788       s->contents = bfd_zalloc (dynobj, s->size);
11789       if (s->contents == NULL)
11790         return FALSE;
11791     }
11792
11793   if (elf_hash_table (info)->dynamic_sections_created)
11794     {
11795       /* Add some entries to the .dynamic section.  We fill in the
11796          values later, in elf32_arm_finish_dynamic_sections, but we
11797          must add the entries now so that we get the correct size for
11798          the .dynamic section.  The DT_DEBUG entry is filled in by the
11799          dynamic linker and used by the debugger.  */
11800 #define add_dynamic_entry(TAG, VAL) \
11801   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
11802
11803      if (info->executable)
11804         {
11805           if (!add_dynamic_entry (DT_DEBUG, 0))
11806             return FALSE;
11807         }
11808
11809       if (plt)
11810         {
11811           if (   !add_dynamic_entry (DT_PLTGOT, 0)
11812               || !add_dynamic_entry (DT_PLTRELSZ, 0)
11813               || !add_dynamic_entry (DT_PLTREL,
11814                                      htab->use_rel ? DT_REL : DT_RELA)
11815               || !add_dynamic_entry (DT_JMPREL, 0))
11816             return FALSE;
11817         }
11818
11819       if (relocs)
11820         {
11821           if (htab->use_rel)
11822             {
11823               if (!add_dynamic_entry (DT_REL, 0)
11824                   || !add_dynamic_entry (DT_RELSZ, 0)
11825                   || !add_dynamic_entry (DT_RELENT, RELOC_SIZE (htab)))
11826                 return FALSE;
11827             }
11828           else
11829             {
11830               if (!add_dynamic_entry (DT_RELA, 0)
11831                   || !add_dynamic_entry (DT_RELASZ, 0)
11832                   || !add_dynamic_entry (DT_RELAENT, RELOC_SIZE (htab)))
11833                 return FALSE;
11834             }
11835         }
11836
11837       /* If any dynamic relocs apply to a read-only section,
11838          then we need a DT_TEXTREL entry.  */
11839       if ((info->flags & DF_TEXTREL) == 0)
11840         elf_link_hash_traverse (& htab->root, elf32_arm_readonly_dynrelocs,
11841                                 info);
11842
11843       if ((info->flags & DF_TEXTREL) != 0)
11844         {
11845           if (!add_dynamic_entry (DT_TEXTREL, 0))
11846             return FALSE;
11847         }
11848       if (htab->vxworks_p
11849           && !elf_vxworks_add_dynamic_entries (output_bfd, info))
11850         return FALSE;
11851     }
11852 #undef add_dynamic_entry
11853
11854   return TRUE;
11855 }
11856
11857 /* Finish up dynamic symbol handling.  We set the contents of various
11858    dynamic sections here.  */
11859
11860 static bfd_boolean
11861 elf32_arm_finish_dynamic_symbol (bfd * output_bfd,
11862                                  struct bfd_link_info * info,
11863                                  struct elf_link_hash_entry * h,
11864                                  Elf_Internal_Sym * sym)
11865 {
11866   bfd * dynobj;
11867   struct elf32_arm_link_hash_table *htab;
11868   struct elf32_arm_link_hash_entry *eh;
11869
11870   dynobj = elf_hash_table (info)->dynobj;
11871   htab = elf32_arm_hash_table (info);
11872   eh = (struct elf32_arm_link_hash_entry *) h;
11873
11874   if (h->plt.offset != (bfd_vma) -1)
11875     {
11876       asection * splt;
11877       asection * srel;
11878       bfd_byte *loc;
11879       bfd_vma plt_index;
11880       Elf_Internal_Rela rel;
11881
11882       /* This symbol has an entry in the procedure linkage table.  Set
11883          it up.  */
11884
11885       BFD_ASSERT (h->dynindx != -1);
11886
11887       splt = bfd_get_section_by_name (dynobj, ".plt");
11888       srel = bfd_get_section_by_name (dynobj, RELOC_SECTION (htab, ".plt"));
11889       BFD_ASSERT (splt != NULL && srel != NULL);
11890
11891       /* Fill in the entry in the procedure linkage table.  */
11892       if (htab->symbian_p)
11893         {
11894           put_arm_insn (htab, output_bfd,
11895                       elf32_arm_symbian_plt_entry[0],
11896                       splt->contents + h->plt.offset);
11897           bfd_put_32 (output_bfd,
11898                       elf32_arm_symbian_plt_entry[1],
11899                       splt->contents + h->plt.offset + 4);
11900
11901           /* Fill in the entry in the .rel.plt section.  */
11902           rel.r_offset = (splt->output_section->vma
11903                           + splt->output_offset
11904                           + h->plt.offset + 4);
11905           rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT);
11906
11907           /* Get the index in the procedure linkage table which
11908              corresponds to this symbol.  This is the index of this symbol
11909              in all the symbols for which we are making plt entries.  The
11910              first entry in the procedure linkage table is reserved.  */
11911           plt_index = ((h->plt.offset - htab->plt_header_size)
11912                        / htab->plt_entry_size);
11913         }
11914       else
11915         {
11916           bfd_vma got_offset, got_address, plt_address;
11917           bfd_vma got_displacement;
11918           asection * sgot;
11919           bfd_byte * ptr;
11920
11921           sgot = bfd_get_section_by_name (dynobj, ".got.plt");
11922           BFD_ASSERT (sgot != NULL);
11923
11924           /* Get the offset into the .got.plt table of the entry that
11925              corresponds to this function.  */
11926           got_offset = eh->plt_got_offset;
11927
11928           /* Get the index in the procedure linkage table which
11929              corresponds to this symbol.  This is the index of this symbol
11930              in all the symbols for which we are making plt entries.  The
11931              first three entries in .got.plt are reserved; after that
11932              symbols appear in the same order as in .plt.  */
11933           plt_index = (got_offset - 12) / 4;
11934
11935           /* Calculate the address of the GOT entry.  */
11936           got_address = (sgot->output_section->vma
11937                          + sgot->output_offset
11938                          + got_offset);
11939
11940           /* ...and the address of the PLT entry.  */
11941           plt_address = (splt->output_section->vma
11942                          + splt->output_offset
11943                          + h->plt.offset);
11944
11945           ptr = htab->splt->contents + h->plt.offset;
11946           if (htab->vxworks_p && info->shared)
11947             {
11948               unsigned int i;
11949               bfd_vma val;
11950
11951               for (i = 0; i != htab->plt_entry_size / 4; i++, ptr += 4)
11952                 {
11953                   val = elf32_arm_vxworks_shared_plt_entry[i];
11954                   if (i == 2)
11955                     val |= got_address - sgot->output_section->vma;
11956                   if (i == 5)
11957                     val |= plt_index * RELOC_SIZE (htab);
11958                   if (i == 2 || i == 5)
11959                     bfd_put_32 (output_bfd, val, ptr);
11960                   else
11961                     put_arm_insn (htab, output_bfd, val, ptr);
11962                 }
11963             }
11964           else if (htab->vxworks_p)
11965             {
11966               unsigned int i;
11967               bfd_vma val;
11968
11969               for (i = 0; i != htab->plt_entry_size / 4; i++, ptr += 4)
11970                 {
11971                   val = elf32_arm_vxworks_exec_plt_entry[i];
11972                   if (i == 2)
11973                     val |= got_address;
11974                   if (i == 4)
11975                     val |= 0xffffff & -((h->plt.offset + i * 4 + 8) >> 2);
11976                   if (i == 5)
11977                     val |= plt_index * RELOC_SIZE (htab);
11978                   if (i == 2 || i == 5)
11979                     bfd_put_32 (output_bfd, val, ptr);
11980                   else
11981                     put_arm_insn (htab, output_bfd, val, ptr);
11982                 }
11983
11984               loc = (htab->srelplt2->contents
11985                      + (plt_index * 2 + 1) * RELOC_SIZE (htab));
11986
11987               /* Create the .rela.plt.unloaded R_ARM_ABS32 relocation
11988                  referencing the GOT for this PLT entry.  */
11989               rel.r_offset = plt_address + 8;
11990               rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_ARM_ABS32);
11991               rel.r_addend = got_offset;
11992               SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc);
11993               loc += RELOC_SIZE (htab);
11994
11995               /* Create the R_ARM_ABS32 relocation referencing the
11996                  beginning of the PLT for this GOT entry.  */
11997               rel.r_offset = got_address;
11998               rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_ARM_ABS32);
11999               rel.r_addend = 0;
12000               SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc);
12001             }
12002           else
12003             {
12004               bfd_signed_vma thumb_refs;
12005               /* Calculate the displacement between the PLT slot and the
12006                  entry in the GOT.  The eight-byte offset accounts for the
12007                  value produced by adding to pc in the first instruction
12008                  of the PLT stub.  */
12009               got_displacement = got_address - (plt_address + 8);
12010
12011               BFD_ASSERT ((got_displacement & 0xf0000000) == 0);
12012
12013               thumb_refs = eh->plt_thumb_refcount;
12014               if (!htab->use_blx)
12015                 thumb_refs += eh->plt_maybe_thumb_refcount;
12016
12017               if (thumb_refs > 0)
12018                 {
12019                   put_thumb_insn (htab, output_bfd,
12020                                   elf32_arm_plt_thumb_stub[0], ptr - 4);
12021                   put_thumb_insn (htab, output_bfd,
12022                                   elf32_arm_plt_thumb_stub[1], ptr - 2);
12023                 }
12024
12025               put_arm_insn (htab, output_bfd,
12026                             elf32_arm_plt_entry[0]
12027                             | ((got_displacement & 0x0ff00000) >> 20),
12028                             ptr + 0);
12029               put_arm_insn (htab, output_bfd,
12030                             elf32_arm_plt_entry[1]
12031                             | ((got_displacement & 0x000ff000) >> 12),
12032                             ptr+ 4);
12033               put_arm_insn (htab, output_bfd,
12034                             elf32_arm_plt_entry[2]
12035                             | (got_displacement & 0x00000fff),
12036                             ptr + 8);
12037 #ifdef FOUR_WORD_PLT
12038               bfd_put_32 (output_bfd, elf32_arm_plt_entry[3], ptr + 12);
12039 #endif
12040             }
12041
12042           /* Fill in the entry in the global offset table.  */
12043           bfd_put_32 (output_bfd,
12044                       (splt->output_section->vma
12045                        + splt->output_offset),
12046                       sgot->contents + got_offset);
12047
12048           /* Fill in the entry in the .rel(a).plt section.  */
12049           rel.r_addend = 0;
12050           rel.r_offset = got_address;
12051           rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_JUMP_SLOT);
12052         }
12053
12054       loc = srel->contents + plt_index * RELOC_SIZE (htab);
12055       SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc);
12056
12057       if (!h->def_regular)
12058         {
12059           /* Mark the symbol as undefined, rather than as defined in
12060              the .plt section.  Leave the value alone.  */
12061           sym->st_shndx = SHN_UNDEF;
12062           /* If the symbol is weak, we do need to clear the value.
12063              Otherwise, the PLT entry would provide a definition for
12064              the symbol even if the symbol wasn't defined anywhere,
12065              and so the symbol would never be NULL.  */
12066           if (!h->ref_regular_nonweak)
12067             sym->st_value = 0;
12068         }
12069     }
12070
12071   if (h->got.offset != (bfd_vma) -1
12072       && (elf32_arm_hash_entry (h)->tls_type & GOT_TLS_GD) == 0
12073       && (elf32_arm_hash_entry (h)->tls_type & GOT_TLS_IE) == 0)
12074     {
12075       asection * sgot;
12076       asection * srel;
12077       Elf_Internal_Rela rel;
12078       bfd_byte *loc;
12079       bfd_vma offset;
12080
12081       /* This symbol has an entry in the global offset table.  Set it
12082          up.  */
12083       sgot = bfd_get_section_by_name (dynobj, ".got");
12084       srel = bfd_get_section_by_name (dynobj, RELOC_SECTION (htab, ".got"));
12085       BFD_ASSERT (sgot != NULL && srel != NULL);
12086
12087       offset = (h->got.offset & ~(bfd_vma) 1);
12088       rel.r_addend = 0;
12089       rel.r_offset = (sgot->output_section->vma
12090                       + sgot->output_offset
12091                       + offset);
12092
12093       /* If this is a static link, or it is a -Bsymbolic link and the
12094          symbol is defined locally or was forced to be local because
12095          of a version file, we just want to emit a RELATIVE reloc.
12096          The entry in the global offset table will already have been
12097          initialized in the relocate_section function.  */
12098       if (info->shared
12099           && SYMBOL_REFERENCES_LOCAL (info, h))
12100         {
12101           BFD_ASSERT ((h->got.offset & 1) != 0);
12102           rel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
12103           if (!htab->use_rel)
12104             {
12105               rel.r_addend = bfd_get_32 (output_bfd, sgot->contents + offset);
12106               bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + offset);
12107             }
12108         }
12109       else
12110         {
12111           BFD_ASSERT ((h->got.offset & 1) == 0);
12112           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + offset);
12113           rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT);
12114         }
12115
12116       loc = srel->contents + srel->reloc_count++ * RELOC_SIZE (htab);
12117       SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc);
12118     }
12119
12120   if (h->needs_copy)
12121     {
12122       asection * s;
12123       Elf_Internal_Rela rel;
12124       bfd_byte *loc;
12125
12126       /* This symbol needs a copy reloc.  Set it up.  */
12127       BFD_ASSERT (h->dynindx != -1
12128                   && (h->root.type == bfd_link_hash_defined
12129                       || h->root.type == bfd_link_hash_defweak));
12130
12131       s = bfd_get_section_by_name (h->root.u.def.section->owner,
12132                                    RELOC_SECTION (htab, ".bss"));
12133       BFD_ASSERT (s != NULL);
12134
12135       rel.r_addend = 0;
12136       rel.r_offset = (h->root.u.def.value
12137                       + h->root.u.def.section->output_section->vma
12138                       + h->root.u.def.section->output_offset);
12139       rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_COPY);
12140       loc = s->contents + s->reloc_count++ * RELOC_SIZE (htab);
12141       SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc);
12142     }
12143
12144   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  On VxWorks,
12145      the _GLOBAL_OFFSET_TABLE_ symbol is not absolute: it is relative
12146      to the ".got" section.  */
12147   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
12148       || (!htab->vxworks_p && h == htab->root.hgot))
12149     sym->st_shndx = SHN_ABS;
12150
12151   return TRUE;
12152 }
12153
12154 /* Finish up the dynamic sections.  */
12155
12156 static bfd_boolean
12157 elf32_arm_finish_dynamic_sections (bfd * output_bfd, struct bfd_link_info * info)
12158 {
12159   bfd * dynobj;
12160   asection * sgot;
12161   asection * sdyn;
12162
12163   dynobj = elf_hash_table (info)->dynobj;
12164
12165   sgot = bfd_get_section_by_name (dynobj, ".got.plt");
12166   BFD_ASSERT (elf32_arm_hash_table (info)->symbian_p || sgot != NULL);
12167   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
12168
12169   if (elf_hash_table (info)->dynamic_sections_created)
12170     {
12171       asection *splt;
12172       Elf32_External_Dyn *dyncon, *dynconend;
12173       struct elf32_arm_link_hash_table *htab;
12174
12175       htab = elf32_arm_hash_table (info);
12176       splt = bfd_get_section_by_name (dynobj, ".plt");
12177       BFD_ASSERT (splt != NULL && sdyn != NULL);
12178
12179       dyncon = (Elf32_External_Dyn *) sdyn->contents;
12180       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
12181
12182       for (; dyncon < dynconend; dyncon++)
12183         {
12184           Elf_Internal_Dyn dyn;
12185           const char * name;
12186           asection * s;
12187
12188           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
12189
12190           switch (dyn.d_tag)
12191             {
12192               unsigned int type;
12193
12194             default:
12195               if (htab->vxworks_p
12196                   && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
12197                 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
12198               break;
12199
12200             case DT_HASH:
12201               name = ".hash";
12202               goto get_vma_if_bpabi;
12203             case DT_STRTAB:
12204               name = ".dynstr";
12205               goto get_vma_if_bpabi;
12206             case DT_SYMTAB:
12207               name = ".dynsym";
12208               goto get_vma_if_bpabi;
12209             case DT_VERSYM:
12210               name = ".gnu.version";
12211               goto get_vma_if_bpabi;
12212             case DT_VERDEF:
12213               name = ".gnu.version_d";
12214               goto get_vma_if_bpabi;
12215             case DT_VERNEED:
12216               name = ".gnu.version_r";
12217               goto get_vma_if_bpabi;
12218
12219             case DT_PLTGOT:
12220               name = ".got";
12221               goto get_vma;
12222             case DT_JMPREL:
12223               name = RELOC_SECTION (htab, ".plt");
12224             get_vma:
12225               s = bfd_get_section_by_name (output_bfd, name);
12226               BFD_ASSERT (s != NULL);
12227               if (!htab->symbian_p)
12228                 dyn.d_un.d_ptr = s->vma;
12229               else
12230                 /* In the BPABI, tags in the PT_DYNAMIC section point
12231                    at the file offset, not the memory address, for the
12232                    convenience of the post linker.  */
12233                 dyn.d_un.d_ptr = s->filepos;
12234               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
12235               break;
12236
12237             get_vma_if_bpabi:
12238               if (htab->symbian_p)
12239                 goto get_vma;
12240               break;
12241
12242             case DT_PLTRELSZ:
12243               s = bfd_get_section_by_name (output_bfd,
12244                                            RELOC_SECTION (htab, ".plt"));
12245               BFD_ASSERT (s != NULL);
12246               dyn.d_un.d_val = s->size;
12247               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
12248               break;
12249
12250             case DT_RELSZ:
12251             case DT_RELASZ:
12252               if (!htab->symbian_p)
12253                 {
12254                   /* My reading of the SVR4 ABI indicates that the
12255                      procedure linkage table relocs (DT_JMPREL) should be
12256                      included in the overall relocs (DT_REL).  This is
12257                      what Solaris does.  However, UnixWare can not handle
12258                      that case.  Therefore, we override the DT_RELSZ entry
12259                      here to make it not include the JMPREL relocs.  Since
12260                      the linker script arranges for .rel(a).plt to follow all
12261                      other relocation sections, we don't have to worry
12262                      about changing the DT_REL entry.  */
12263                   s = bfd_get_section_by_name (output_bfd,
12264                                                RELOC_SECTION (htab, ".plt"));
12265                   if (s != NULL)
12266                     dyn.d_un.d_val -= s->size;
12267                   bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
12268                   break;
12269                 }
12270               /* Fall through.  */
12271
12272             case DT_REL:
12273             case DT_RELA:
12274               /* In the BPABI, the DT_REL tag must point at the file
12275                  offset, not the VMA, of the first relocation
12276                  section.  So, we use code similar to that in
12277                  elflink.c, but do not check for SHF_ALLOC on the
12278                  relcoation section, since relocations sections are
12279                  never allocated under the BPABI.  The comments above
12280                  about Unixware notwithstanding, we include all of the
12281                  relocations here.  */
12282               if (htab->symbian_p)
12283                 {
12284                   unsigned int i;
12285                   type = ((dyn.d_tag == DT_REL || dyn.d_tag == DT_RELSZ)
12286                           ? SHT_REL : SHT_RELA);
12287                   dyn.d_un.d_val = 0;
12288                   for (i = 1; i < elf_numsections (output_bfd); i++)
12289                     {
12290                       Elf_Internal_Shdr *hdr
12291                         = elf_elfsections (output_bfd)[i];
12292                       if (hdr->sh_type == type)
12293                         {
12294                           if (dyn.d_tag == DT_RELSZ
12295                               || dyn.d_tag == DT_RELASZ)
12296                             dyn.d_un.d_val += hdr->sh_size;
12297                           else if ((ufile_ptr) hdr->sh_offset
12298                                    <= dyn.d_un.d_val - 1)
12299                             dyn.d_un.d_val = hdr->sh_offset;
12300                         }
12301                     }
12302                   bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
12303                 }
12304               break;
12305
12306               /* Set the bottom bit of DT_INIT/FINI if the
12307                  corresponding function is Thumb.  */
12308             case DT_INIT:
12309               name = info->init_function;
12310               goto get_sym;
12311             case DT_FINI:
12312               name = info->fini_function;
12313             get_sym:
12314               /* If it wasn't set by elf_bfd_final_link
12315                  then there is nothing to adjust.  */
12316               if (dyn.d_un.d_val != 0)
12317                 {
12318                   struct elf_link_hash_entry * eh;
12319
12320                   eh = elf_link_hash_lookup (elf_hash_table (info), name,
12321                                              FALSE, FALSE, TRUE);
12322                   if (eh != NULL
12323                       && ELF_ST_TYPE (eh->type) == STT_ARM_TFUNC)
12324                     {
12325                       dyn.d_un.d_val |= 1;
12326                       bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
12327                     }
12328                 }
12329               break;
12330             }
12331         }
12332
12333       /* Fill in the first entry in the procedure linkage table.  */
12334       if (splt->size > 0 && elf32_arm_hash_table (info)->plt_header_size)
12335         {
12336           const bfd_vma *plt0_entry;
12337           bfd_vma got_address, plt_address, got_displacement;
12338
12339           /* Calculate the addresses of the GOT and PLT.  */
12340           got_address = sgot->output_section->vma + sgot->output_offset;
12341           plt_address = splt->output_section->vma + splt->output_offset;
12342
12343           if (htab->vxworks_p)
12344             {
12345               /* The VxWorks GOT is relocated by the dynamic linker.
12346                  Therefore, we must emit relocations rather than simply
12347                  computing the values now.  */
12348               Elf_Internal_Rela rel;
12349
12350               plt0_entry = elf32_arm_vxworks_exec_plt0_entry;
12351               put_arm_insn (htab, output_bfd, plt0_entry[0],
12352                             splt->contents + 0);
12353               put_arm_insn (htab, output_bfd, plt0_entry[1],
12354                             splt->contents + 4);
12355               put_arm_insn (htab, output_bfd, plt0_entry[2],
12356                             splt->contents + 8);
12357               bfd_put_32 (output_bfd, got_address, splt->contents + 12);
12358
12359               /* Generate a relocation for _GLOBAL_OFFSET_TABLE_.  */
12360               rel.r_offset = plt_address + 12;
12361               rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_ARM_ABS32);
12362               rel.r_addend = 0;
12363               SWAP_RELOC_OUT (htab) (output_bfd, &rel,
12364                                      htab->srelplt2->contents);
12365             }
12366           else
12367             {
12368               got_displacement = got_address - (plt_address + 16);
12369
12370               plt0_entry = elf32_arm_plt0_entry;
12371               put_arm_insn (htab, output_bfd, plt0_entry[0],
12372                             splt->contents + 0);
12373               put_arm_insn (htab, output_bfd, plt0_entry[1],
12374                             splt->contents + 4);
12375               put_arm_insn (htab, output_bfd, plt0_entry[2],
12376                             splt->contents + 8);
12377               put_arm_insn (htab, output_bfd, plt0_entry[3],
12378                             splt->contents + 12);
12379
12380 #ifdef FOUR_WORD_PLT
12381               /* The displacement value goes in the otherwise-unused
12382                  last word of the second entry.  */
12383               bfd_put_32 (output_bfd, got_displacement, splt->contents + 28);
12384 #else
12385               bfd_put_32 (output_bfd, got_displacement, splt->contents + 16);
12386 #endif
12387             }
12388         }
12389
12390       /* UnixWare sets the entsize of .plt to 4, although that doesn't
12391          really seem like the right value.  */
12392       if (splt->output_section->owner == output_bfd)
12393         elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
12394
12395       if (htab->vxworks_p && !info->shared && htab->splt->size > 0)
12396         {
12397           /* Correct the .rel(a).plt.unloaded relocations.  They will have
12398              incorrect symbol indexes.  */
12399           int num_plts;
12400           unsigned char *p;
12401
12402           num_plts = ((htab->splt->size - htab->plt_header_size)
12403                       / htab->plt_entry_size);
12404           p = htab->srelplt2->contents + RELOC_SIZE (htab);
12405
12406           for (; num_plts; num_plts--)
12407             {
12408               Elf_Internal_Rela rel;
12409
12410               SWAP_RELOC_IN (htab) (output_bfd, p, &rel);
12411               rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_ARM_ABS32);
12412               SWAP_RELOC_OUT (htab) (output_bfd, &rel, p);
12413               p += RELOC_SIZE (htab);
12414
12415               SWAP_RELOC_IN (htab) (output_bfd, p, &rel);
12416               rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_ARM_ABS32);
12417               SWAP_RELOC_OUT (htab) (output_bfd, &rel, p);
12418               p += RELOC_SIZE (htab);
12419             }
12420         }
12421     }
12422
12423   /* Fill in the first three entries in the global offset table.  */
12424   if (sgot)
12425     {
12426       if (sgot->size > 0)
12427         {
12428           if (sdyn == NULL)
12429             bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
12430           else
12431             bfd_put_32 (output_bfd,
12432                         sdyn->output_section->vma + sdyn->output_offset,
12433                         sgot->contents);
12434           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
12435           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
12436         }
12437
12438       elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
12439     }
12440
12441   return TRUE;
12442 }
12443
12444 static void
12445 elf32_arm_post_process_headers (bfd * abfd, struct bfd_link_info * link_info ATTRIBUTE_UNUSED)
12446 {
12447   Elf_Internal_Ehdr * i_ehdrp;  /* ELF file header, internal form.  */
12448   struct elf32_arm_link_hash_table *globals;
12449
12450   i_ehdrp = elf_elfheader (abfd);
12451
12452   if (EF_ARM_EABI_VERSION (i_ehdrp->e_flags) == EF_ARM_EABI_UNKNOWN)
12453     i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_ARM;
12454   else
12455     i_ehdrp->e_ident[EI_OSABI] = 0;
12456   i_ehdrp->e_ident[EI_ABIVERSION] = ARM_ELF_ABI_VERSION;
12457
12458   if (link_info)
12459     {
12460       globals = elf32_arm_hash_table (link_info);
12461       if (globals->byteswap_code)
12462         i_ehdrp->e_flags |= EF_ARM_BE8;
12463     }
12464 }
12465
12466 static enum elf_reloc_type_class
12467 elf32_arm_reloc_type_class (const Elf_Internal_Rela *rela)
12468 {
12469   switch ((int) ELF32_R_TYPE (rela->r_info))
12470     {
12471     case R_ARM_RELATIVE:
12472       return reloc_class_relative;
12473     case R_ARM_JUMP_SLOT:
12474       return reloc_class_plt;
12475     case R_ARM_COPY:
12476       return reloc_class_copy;
12477     default:
12478       return reloc_class_normal;
12479     }
12480 }
12481
12482 /* Set the right machine number for an Arm ELF file.  */
12483
12484 static bfd_boolean
12485 elf32_arm_section_flags (flagword *flags, const Elf_Internal_Shdr *hdr)
12486 {
12487   if (hdr->sh_type == SHT_NOTE)
12488     *flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_SAME_CONTENTS;
12489
12490   return TRUE;
12491 }
12492
12493 static void
12494 elf32_arm_final_write_processing (bfd *abfd, bfd_boolean linker ATTRIBUTE_UNUSED)
12495 {
12496   bfd_arm_update_notes (abfd, ARM_NOTE_SECTION);
12497 }
12498
12499 /* Return TRUE if this is an unwinding table entry.  */
12500
12501 static bfd_boolean
12502 is_arm_elf_unwind_section_name (bfd * abfd ATTRIBUTE_UNUSED, const char * name)
12503 {
12504   return (CONST_STRNEQ (name, ELF_STRING_ARM_unwind)
12505           || CONST_STRNEQ (name, ELF_STRING_ARM_unwind_once));
12506 }
12507
12508
12509 /* Set the type and flags for an ARM section.  We do this by
12510    the section name, which is a hack, but ought to work.  */
12511
12512 static bfd_boolean
12513 elf32_arm_fake_sections (bfd * abfd, Elf_Internal_Shdr * hdr, asection * sec)
12514 {
12515   const char * name;
12516
12517   name = bfd_get_section_name (abfd, sec);
12518
12519   if (is_arm_elf_unwind_section_name (abfd, name))
12520     {
12521       hdr->sh_type = SHT_ARM_EXIDX;
12522       hdr->sh_flags |= SHF_LINK_ORDER;
12523     }
12524   return TRUE;
12525 }
12526
12527 /* Handle an ARM specific section when reading an object file.  This is
12528    called when bfd_section_from_shdr finds a section with an unknown
12529    type.  */
12530
12531 static bfd_boolean
12532 elf32_arm_section_from_shdr (bfd *abfd,
12533                              Elf_Internal_Shdr * hdr,
12534                              const char *name,
12535                              int shindex)
12536 {
12537   /* There ought to be a place to keep ELF backend specific flags, but
12538      at the moment there isn't one.  We just keep track of the
12539      sections by their name, instead.  Fortunately, the ABI gives
12540      names for all the ARM specific sections, so we will probably get
12541      away with this.  */
12542   switch (hdr->sh_type)
12543     {
12544     case SHT_ARM_EXIDX:
12545     case SHT_ARM_PREEMPTMAP:
12546     case SHT_ARM_ATTRIBUTES:
12547       break;
12548
12549     default:
12550       return FALSE;
12551     }
12552
12553   if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
12554     return FALSE;
12555
12556   return TRUE;
12557 }
12558
12559 /* A structure used to record a list of sections, independently
12560    of the next and prev fields in the asection structure.  */
12561 typedef struct section_list
12562 {
12563   asection * sec;
12564   struct section_list * next;
12565   struct section_list * prev;
12566 }
12567 section_list;
12568
12569 /* Unfortunately we need to keep a list of sections for which
12570    an _arm_elf_section_data structure has been allocated.  This
12571    is because it is possible for functions like elf32_arm_write_section
12572    to be called on a section which has had an elf_data_structure
12573    allocated for it (and so the used_by_bfd field is valid) but
12574    for which the ARM extended version of this structure - the
12575    _arm_elf_section_data structure - has not been allocated.  */
12576 static section_list * sections_with_arm_elf_section_data = NULL;
12577
12578 static void
12579 record_section_with_arm_elf_section_data (asection * sec)
12580 {
12581   struct section_list * entry;
12582
12583   entry = bfd_malloc (sizeof (* entry));
12584   if (entry == NULL)
12585     return;
12586   entry->sec = sec;
12587   entry->next = sections_with_arm_elf_section_data;
12588   entry->prev = NULL;
12589   if (entry->next != NULL)
12590     entry->next->prev = entry;
12591   sections_with_arm_elf_section_data = entry;
12592 }
12593
12594 static struct section_list *
12595 find_arm_elf_section_entry (asection * sec)
12596 {
12597   struct section_list * entry;
12598   static struct section_list * last_entry = NULL;
12599
12600   /* This is a short cut for the typical case where the sections are added
12601      to the sections_with_arm_elf_section_data list in forward order and
12602      then looked up here in backwards order.  This makes a real difference
12603      to the ld-srec/sec64k.exp linker test.  */
12604   entry = sections_with_arm_elf_section_data;
12605   if (last_entry != NULL)
12606     {
12607       if (last_entry->sec == sec)
12608         entry = last_entry;
12609       else if (last_entry->next != NULL
12610                && last_entry->next->sec == sec)
12611         entry = last_entry->next;
12612     }
12613
12614   for (; entry; entry = entry->next)
12615     if (entry->sec == sec)
12616       break;
12617
12618   if (entry)
12619     /* Record the entry prior to this one - it is the entry we are most
12620        likely to want to locate next time.  Also this way if we have been
12621        called from unrecord_section_with_arm_elf_section_data() we will not
12622        be caching a pointer that is about to be freed.  */
12623     last_entry = entry->prev;
12624
12625   return entry;
12626 }
12627
12628 static _arm_elf_section_data *
12629 get_arm_elf_section_data (asection * sec)
12630 {
12631   struct section_list * entry;
12632
12633   entry = find_arm_elf_section_entry (sec);
12634
12635   if (entry)
12636     return elf32_arm_section_data (entry->sec);
12637   else
12638     return NULL;
12639 }
12640
12641 static void
12642 unrecord_section_with_arm_elf_section_data (asection * sec)
12643 {
12644   struct section_list * entry;
12645
12646   entry = find_arm_elf_section_entry (sec);
12647
12648   if (entry)
12649     {
12650       if (entry->prev != NULL)
12651         entry->prev->next = entry->next;
12652       if (entry->next != NULL)
12653         entry->next->prev = entry->prev;
12654       if (entry == sections_with_arm_elf_section_data)
12655         sections_with_arm_elf_section_data = entry->next;
12656       free (entry);
12657     }
12658 }
12659
12660
12661 typedef struct
12662 {
12663   void *finfo;
12664   struct bfd_link_info *info;
12665   asection *sec;
12666   int sec_shndx;
12667   int (*func) (void *, const char *, Elf_Internal_Sym *,
12668                asection *, struct elf_link_hash_entry *);
12669 } output_arch_syminfo;
12670
12671 enum map_symbol_type
12672 {
12673   ARM_MAP_ARM,
12674   ARM_MAP_THUMB,
12675   ARM_MAP_DATA
12676 };
12677
12678
12679 /* Output a single mapping symbol.  */
12680
12681 static bfd_boolean
12682 elf32_arm_output_map_sym (output_arch_syminfo *osi,
12683                           enum map_symbol_type type,
12684                           bfd_vma offset)
12685 {
12686   static const char *names[3] = {"$a", "$t", "$d"};
12687   struct elf32_arm_link_hash_table *htab;
12688   Elf_Internal_Sym sym;
12689
12690   htab = elf32_arm_hash_table (osi->info);
12691   sym.st_value = osi->sec->output_section->vma
12692                  + osi->sec->output_offset
12693                  + offset;
12694   sym.st_size = 0;
12695   sym.st_other = 0;
12696   sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_NOTYPE);
12697   sym.st_shndx = osi->sec_shndx;
12698   return osi->func (osi->finfo, names[type], &sym, osi->sec, NULL) == 1;
12699 }
12700
12701
12702 /* Output mapping symbols for PLT entries associated with H.  */
12703
12704 static bfd_boolean
12705 elf32_arm_output_plt_map (struct elf_link_hash_entry *h, void *inf)
12706 {
12707   output_arch_syminfo *osi = (output_arch_syminfo *) inf;
12708   struct elf32_arm_link_hash_table *htab;
12709   struct elf32_arm_link_hash_entry *eh;
12710   bfd_vma addr;
12711
12712   htab = elf32_arm_hash_table (osi->info);
12713
12714   if (h->root.type == bfd_link_hash_indirect)
12715     return TRUE;
12716
12717   if (h->root.type == bfd_link_hash_warning)
12718     /* When warning symbols are created, they **replace** the "real"
12719        entry in the hash table, thus we never get to see the real
12720        symbol in a hash traversal.  So look at it now.  */
12721     h = (struct elf_link_hash_entry *) h->root.u.i.link;
12722
12723   if (h->plt.offset == (bfd_vma) -1)
12724     return TRUE;
12725
12726   eh = (struct elf32_arm_link_hash_entry *) h;
12727   addr = h->plt.offset;
12728   if (htab->symbian_p)
12729     {
12730       if (!elf32_arm_output_map_sym (osi, ARM_MAP_ARM, addr))
12731         return FALSE;
12732       if (!elf32_arm_output_map_sym (osi, ARM_MAP_DATA, addr + 4))
12733         return FALSE;
12734     }
12735   else if (htab->vxworks_p)
12736     {
12737       if (!elf32_arm_output_map_sym (osi, ARM_MAP_ARM, addr))
12738         return FALSE;
12739       if (!elf32_arm_output_map_sym (osi, ARM_MAP_DATA, addr + 8))
12740         return FALSE;
12741       if (!elf32_arm_output_map_sym (osi, ARM_MAP_ARM, addr + 12))
12742         return FALSE;
12743       if (!elf32_arm_output_map_sym (osi, ARM_MAP_DATA, addr + 20))
12744         return FALSE;
12745     }
12746   else
12747     {
12748       bfd_signed_vma thumb_refs;
12749
12750       thumb_refs = eh->plt_thumb_refcount;
12751       if (!htab->use_blx)
12752         thumb_refs += eh->plt_maybe_thumb_refcount;
12753
12754       if (thumb_refs > 0)
12755         {
12756           if (!elf32_arm_output_map_sym (osi, ARM_MAP_THUMB, addr - 4))
12757             return FALSE;
12758         }
12759 #ifdef FOUR_WORD_PLT
12760       if (!elf32_arm_output_map_sym (osi, ARM_MAP_ARM, addr))
12761         return FALSE;
12762       if (!elf32_arm_output_map_sym (osi, ARM_MAP_DATA, addr + 12))
12763         return FALSE;
12764 #else
12765       /* A three-word PLT with no Thumb thunk contains only Arm code,
12766          so only need to output a mapping symbol for the first PLT entry and
12767          entries with thumb thunks.  */
12768       if (thumb_refs > 0 || addr == 20)
12769         {
12770           if (!elf32_arm_output_map_sym (osi, ARM_MAP_ARM, addr))
12771             return FALSE;
12772         }
12773 #endif
12774     }
12775
12776   return TRUE;
12777 }
12778
12779 /* Output a single local symbol for a generated stub.  */
12780
12781 static bfd_boolean
12782 elf32_arm_output_stub_sym (output_arch_syminfo *osi, const char *name,
12783                            bfd_vma offset, bfd_vma size)
12784 {
12785   struct elf32_arm_link_hash_table *htab;
12786   Elf_Internal_Sym sym;
12787
12788   htab = elf32_arm_hash_table (osi->info);
12789   sym.st_value = osi->sec->output_section->vma
12790                  + osi->sec->output_offset
12791                  + offset;
12792   sym.st_size = size;
12793   sym.st_other = 0;
12794   sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
12795   sym.st_shndx = osi->sec_shndx;
12796   return osi->func (osi->finfo, name, &sym, osi->sec, NULL) == 1;
12797 }
12798
12799 static bfd_boolean
12800 arm_map_one_stub (struct bfd_hash_entry * gen_entry,
12801                   void * in_arg)
12802 {
12803   struct elf32_arm_stub_hash_entry *stub_entry;
12804   struct bfd_link_info *info;
12805   struct elf32_arm_link_hash_table *htab;
12806   asection *stub_sec;
12807   bfd_vma addr;
12808   char *stub_name;
12809   output_arch_syminfo *osi;
12810   const insn_sequence *template;
12811   enum stub_insn_type prev_type;
12812   int size;
12813   int i;
12814   enum map_symbol_type sym_type;
12815
12816   /* Massage our args to the form they really have.  */
12817   stub_entry = (struct elf32_arm_stub_hash_entry *) gen_entry;
12818   osi = (output_arch_syminfo *) in_arg;
12819
12820   info = osi->info;
12821
12822   htab = elf32_arm_hash_table (info);
12823   stub_sec = stub_entry->stub_sec;
12824
12825   /* Ensure this stub is attached to the current section being
12826      processed.  */
12827   if (stub_sec != osi->sec)
12828     return TRUE;
12829
12830   addr = (bfd_vma) stub_entry->stub_offset;
12831   stub_name = stub_entry->output_name;
12832
12833   template = stub_entry->stub_template;
12834   switch (template[0].type)
12835     {
12836     case ARM_TYPE:
12837       if (!elf32_arm_output_stub_sym (osi, stub_name, addr, stub_entry->stub_size))
12838         return FALSE;
12839       break;
12840     case THUMB16_TYPE:
12841     case THUMB32_TYPE:
12842       if (!elf32_arm_output_stub_sym (osi, stub_name, addr | 1,
12843                                       stub_entry->stub_size))
12844         return FALSE;
12845       break;
12846     default:
12847       BFD_FAIL ();
12848       return 0;
12849     }
12850
12851   prev_type = DATA_TYPE;
12852   size = 0;
12853   for (i = 0; i < stub_entry->stub_template_size; i++)
12854     {
12855       switch (template[i].type)
12856         {
12857         case ARM_TYPE:
12858           sym_type = ARM_MAP_ARM;
12859           break;
12860
12861         case THUMB16_TYPE:
12862         case THUMB32_TYPE:
12863           sym_type = ARM_MAP_THUMB;
12864           break;
12865
12866         case DATA_TYPE:
12867           sym_type = ARM_MAP_DATA;
12868           break;
12869
12870         default:
12871           BFD_FAIL ();
12872           return FALSE;
12873         }
12874
12875       if (template[i].type != prev_type)
12876         {
12877           prev_type = template[i].type;
12878           if (!elf32_arm_output_map_sym (osi, sym_type, addr + size))
12879             return FALSE;
12880         }
12881
12882       switch (template[i].type)
12883         {
12884         case ARM_TYPE:
12885         case THUMB32_TYPE:
12886           size += 4;
12887           break;
12888
12889         case THUMB16_TYPE:
12890           size += 2;
12891           break;
12892
12893         case DATA_TYPE:
12894           size += 4;
12895           break;
12896
12897         default:
12898           BFD_FAIL ();
12899           return FALSE;
12900         }
12901     }
12902
12903   return TRUE;
12904 }
12905
12906 /* Output mapping symbols for linker generated sections.  */
12907
12908 static bfd_boolean
12909 elf32_arm_output_arch_local_syms (bfd *output_bfd,
12910                                   struct bfd_link_info *info,
12911                                   void *finfo,
12912                                   int (*func) (void *, const char *,
12913                                                Elf_Internal_Sym *,
12914                                                asection *,
12915                                                struct elf_link_hash_entry *))
12916 {
12917   output_arch_syminfo osi;
12918   struct elf32_arm_link_hash_table *htab;
12919   bfd_vma offset;
12920   bfd_size_type size;
12921
12922   htab = elf32_arm_hash_table (info);
12923   check_use_blx (htab);
12924
12925   osi.finfo = finfo;
12926   osi.info = info;
12927   osi.func = func;
12928
12929   /* ARM->Thumb glue.  */
12930   if (htab->arm_glue_size > 0)
12931     {
12932       osi.sec = bfd_get_section_by_name (htab->bfd_of_glue_owner,
12933                                          ARM2THUMB_GLUE_SECTION_NAME);
12934
12935       osi.sec_shndx = _bfd_elf_section_from_bfd_section
12936           (output_bfd, osi.sec->output_section);
12937       if (info->shared || htab->root.is_relocatable_executable
12938           || htab->pic_veneer)
12939         size = ARM2THUMB_PIC_GLUE_SIZE;
12940       else if (htab->use_blx)
12941         size = ARM2THUMB_V5_STATIC_GLUE_SIZE;
12942       else
12943         size = ARM2THUMB_STATIC_GLUE_SIZE;
12944
12945       for (offset = 0; offset < htab->arm_glue_size; offset += size)
12946         {
12947           elf32_arm_output_map_sym (&osi, ARM_MAP_ARM, offset);
12948           elf32_arm_output_map_sym (&osi, ARM_MAP_DATA, offset + size - 4);
12949         }
12950     }
12951
12952   /* Thumb->ARM glue.  */
12953   if (htab->thumb_glue_size > 0)
12954     {
12955       osi.sec = bfd_get_section_by_name (htab->bfd_of_glue_owner,
12956                                          THUMB2ARM_GLUE_SECTION_NAME);
12957
12958       osi.sec_shndx = _bfd_elf_section_from_bfd_section
12959           (output_bfd, osi.sec->output_section);
12960       size = THUMB2ARM_GLUE_SIZE;
12961
12962       for (offset = 0; offset < htab->thumb_glue_size; offset += size)
12963         {
12964           elf32_arm_output_map_sym (&osi, ARM_MAP_THUMB, offset);
12965           elf32_arm_output_map_sym (&osi, ARM_MAP_ARM, offset + 4);
12966         }
12967     }
12968
12969   /* ARMv4 BX veneers.  */
12970   if (htab->bx_glue_size > 0)
12971     {
12972       osi.sec = bfd_get_section_by_name (htab->bfd_of_glue_owner,
12973                                          ARM_BX_GLUE_SECTION_NAME);
12974
12975       osi.sec_shndx = _bfd_elf_section_from_bfd_section
12976           (output_bfd, osi.sec->output_section);
12977
12978       elf32_arm_output_map_sym (&osi, ARM_MAP_ARM, 0);
12979     }
12980
12981   /* Long calls stubs.  */
12982   if (htab->stub_bfd && htab->stub_bfd->sections)
12983     {
12984       asection* stub_sec;
12985
12986       for (stub_sec = htab->stub_bfd->sections;
12987            stub_sec != NULL;
12988            stub_sec = stub_sec->next)
12989         {
12990           /* Ignore non-stub sections.  */
12991           if (!strstr (stub_sec->name, STUB_SUFFIX))
12992             continue;
12993
12994           osi.sec = stub_sec;
12995
12996           osi.sec_shndx = _bfd_elf_section_from_bfd_section
12997             (output_bfd, osi.sec->output_section);
12998
12999           bfd_hash_traverse (&htab->stub_hash_table, arm_map_one_stub, &osi);
13000         }
13001     }
13002
13003   /* Finally, output mapping symbols for the PLT.  */
13004   if (!htab->splt || htab->splt->size == 0)
13005     return TRUE;
13006
13007   osi.sec_shndx = _bfd_elf_section_from_bfd_section (output_bfd,
13008                                                      htab->splt->output_section);
13009   osi.sec = htab->splt;
13010   /* Output mapping symbols for the plt header.  SymbianOS does not have a
13011      plt header.  */
13012   if (htab->vxworks_p)
13013     {
13014       /* VxWorks shared libraries have no PLT header.  */
13015       if (!info->shared)
13016         {
13017           if (!elf32_arm_output_map_sym (&osi, ARM_MAP_ARM, 0))
13018             return FALSE;
13019           if (!elf32_arm_output_map_sym (&osi, ARM_MAP_DATA, 12))
13020             return FALSE;
13021         }
13022     }
13023   else if (!htab->symbian_p)
13024     {
13025       if (!elf32_arm_output_map_sym (&osi, ARM_MAP_ARM, 0))
13026         return FALSE;
13027 #ifndef FOUR_WORD_PLT
13028       if (!elf32_arm_output_map_sym (&osi, ARM_MAP_DATA, 16))
13029         return FALSE;
13030 #endif
13031     }
13032
13033   elf_link_hash_traverse (&htab->root, elf32_arm_output_plt_map, (void *) &osi);
13034   return TRUE;
13035 }
13036
13037 /* Allocate target specific section data.  */
13038
13039 static bfd_boolean
13040 elf32_arm_new_section_hook (bfd *abfd, asection *sec)
13041 {
13042   if (!sec->used_by_bfd)
13043     {
13044       _arm_elf_section_data *sdata;
13045       bfd_size_type amt = sizeof (*sdata);
13046
13047       sdata = bfd_zalloc (abfd, amt);
13048       if (sdata == NULL)
13049         return FALSE;
13050       sec->used_by_bfd = sdata;
13051     }
13052
13053   record_section_with_arm_elf_section_data (sec);
13054
13055   return _bfd_elf_new_section_hook (abfd, sec);
13056 }
13057
13058
13059 /* Used to order a list of mapping symbols by address.  */
13060
13061 static int
13062 elf32_arm_compare_mapping (const void * a, const void * b)
13063 {
13064   const elf32_arm_section_map *amap = (const elf32_arm_section_map *) a;
13065   const elf32_arm_section_map *bmap = (const elf32_arm_section_map *) b;
13066
13067   if (amap->vma > bmap->vma)
13068     return 1;
13069   else if (amap->vma < bmap->vma)
13070     return -1;
13071   else if (amap->type > bmap->type)
13072     /* Ensure results do not depend on the host qsort for objects with
13073        multiple mapping symbols at the same address by sorting on type
13074        after vma.  */
13075     return 1;
13076   else if (amap->type < bmap->type)
13077     return -1;
13078   else
13079     return 0;
13080 }
13081
13082 /* Add OFFSET to lower 31 bits of ADDR, leaving other bits unmodified.  */
13083
13084 static unsigned long
13085 offset_prel31 (unsigned long addr, bfd_vma offset)
13086 {
13087   return (addr & ~0x7ffffffful) | ((addr + offset) & 0x7ffffffful);
13088 }
13089
13090 /* Copy an .ARM.exidx table entry, adding OFFSET to (applied) PREL31
13091    relocations.  */
13092
13093 static void
13094 copy_exidx_entry (bfd *output_bfd, bfd_byte *to, bfd_byte *from, bfd_vma offset)
13095 {
13096   unsigned long first_word = bfd_get_32 (output_bfd, from);
13097   unsigned long second_word = bfd_get_32 (output_bfd, from + 4);
13098
13099   /* High bit of first word is supposed to be zero.  */
13100   if ((first_word & 0x80000000ul) == 0)
13101     first_word = offset_prel31 (first_word, offset);
13102
13103   /* If the high bit of the first word is clear, and the bit pattern is not 0x1
13104      (EXIDX_CANTUNWIND), this is an offset to an .ARM.extab entry.  */
13105   if ((second_word != 0x1) && ((second_word & 0x80000000ul) == 0))
13106     second_word = offset_prel31 (second_word, offset);
13107
13108   bfd_put_32 (output_bfd, first_word, to);
13109   bfd_put_32 (output_bfd, second_word, to + 4);
13110 }
13111
13112 /* Data for make_branch_to_a8_stub().  */
13113
13114 struct a8_branch_to_stub_data {
13115   asection *writing_section;
13116   bfd_byte *contents;
13117 };
13118
13119
13120 /* Helper to insert branches to Cortex-A8 erratum stubs in the right
13121    places for a particular section.  */
13122
13123 static bfd_boolean
13124 make_branch_to_a8_stub (struct bfd_hash_entry *gen_entry,
13125                        void *in_arg)
13126 {
13127   struct elf32_arm_stub_hash_entry *stub_entry;
13128   struct a8_branch_to_stub_data *data;
13129   bfd_byte *contents;
13130   unsigned long branch_insn;
13131   bfd_vma veneered_insn_loc, veneer_entry_loc;
13132   bfd_signed_vma branch_offset;
13133   bfd *abfd;
13134   unsigned int index;
13135
13136   stub_entry = (struct elf32_arm_stub_hash_entry *) gen_entry;
13137   data = (struct a8_branch_to_stub_data *) in_arg;
13138
13139   if (stub_entry->target_section != data->writing_section
13140       || stub_entry->stub_type < arm_stub_a8_veneer_b_cond)
13141     return TRUE;
13142
13143   contents = data->contents;
13144
13145   veneered_insn_loc = stub_entry->target_section->output_section->vma
13146                       + stub_entry->target_section->output_offset
13147                       + stub_entry->target_value;
13148
13149   veneer_entry_loc = stub_entry->stub_sec->output_section->vma
13150                      + stub_entry->stub_sec->output_offset
13151                      + stub_entry->stub_offset;
13152
13153   if (stub_entry->stub_type == arm_stub_a8_veneer_blx)
13154     veneered_insn_loc &= ~3u;
13155
13156   branch_offset = veneer_entry_loc - veneered_insn_loc - 4;
13157
13158   abfd = stub_entry->target_section->owner;
13159   index = stub_entry->target_value;
13160
13161   /* We attempt to avoid this condition by setting stubs_always_after_branch
13162      in elf32_arm_size_stubs if we've enabled the Cortex-A8 erratum workaround.
13163      This check is just to be on the safe side...  */
13164   if ((veneered_insn_loc & ~0xfff) == (veneer_entry_loc & ~0xfff))
13165     {
13166       (*_bfd_error_handler) (_("%B: error: Cortex-A8 erratum stub is "
13167                                "allocated in unsafe location"), abfd);
13168       return FALSE;
13169     }
13170
13171   switch (stub_entry->stub_type)
13172     {
13173     case arm_stub_a8_veneer_b:
13174     case arm_stub_a8_veneer_b_cond:
13175       branch_insn = 0xf0009000;
13176       goto jump24;
13177
13178     case arm_stub_a8_veneer_blx:
13179       branch_insn = 0xf000e800;
13180       goto jump24;
13181
13182     case arm_stub_a8_veneer_bl:
13183       {
13184         unsigned int i1, j1, i2, j2, s;
13185
13186         branch_insn = 0xf000d000;
13187
13188       jump24:
13189         if (branch_offset < -16777216 || branch_offset > 16777214)
13190           {
13191             /* There's not much we can do apart from complain if this
13192                happens.  */
13193             (*_bfd_error_handler) (_("%B: error: Cortex-A8 erratum stub out "
13194                                      "of range (input file too large)"), abfd);
13195             return FALSE;
13196           }
13197
13198         /* i1 = not(j1 eor s), so:
13199            not i1 = j1 eor s
13200            j1 = (not i1) eor s.  */
13201
13202         branch_insn |= (branch_offset >> 1) & 0x7ff;
13203         branch_insn |= ((branch_offset >> 12) & 0x3ff) << 16;
13204         i2 = (branch_offset >> 22) & 1;
13205         i1 = (branch_offset >> 23) & 1;
13206         s = (branch_offset >> 24) & 1;
13207         j1 = (!i1) ^ s;
13208         j2 = (!i2) ^ s;
13209         branch_insn |= j2 << 11;
13210         branch_insn |= j1 << 13;
13211         branch_insn |= s << 26;
13212       }
13213       break;
13214
13215     default:
13216       BFD_FAIL ();
13217       return FALSE;
13218     }
13219
13220   bfd_put_16 (abfd, (branch_insn >> 16) & 0xffff, &contents[index]);
13221   bfd_put_16 (abfd, branch_insn & 0xffff, &contents[index + 2]);
13222
13223   return TRUE;
13224 }
13225
13226 /* Do code byteswapping.  Return FALSE afterwards so that the section is
13227    written out as normal.  */
13228
13229 static bfd_boolean
13230 elf32_arm_write_section (bfd *output_bfd,
13231                          struct bfd_link_info *link_info,
13232                          asection *sec,
13233                          bfd_byte *contents)
13234 {
13235   unsigned int mapcount, errcount;
13236   _arm_elf_section_data *arm_data;
13237   struct elf32_arm_link_hash_table *globals = elf32_arm_hash_table (link_info);
13238   elf32_arm_section_map *map;
13239   elf32_vfp11_erratum_list *errnode;
13240   bfd_vma ptr;
13241   bfd_vma end;
13242   bfd_vma offset = sec->output_section->vma + sec->output_offset;
13243   bfd_byte tmp;
13244   unsigned int i;
13245
13246   /* If this section has not been allocated an _arm_elf_section_data
13247      structure then we cannot record anything.  */
13248   arm_data = get_arm_elf_section_data (sec);
13249   if (arm_data == NULL)
13250     return FALSE;
13251
13252   mapcount = arm_data->mapcount;
13253   map = arm_data->map;
13254   errcount = arm_data->erratumcount;
13255
13256   if (errcount != 0)
13257     {
13258       unsigned int endianflip = bfd_big_endian (output_bfd) ? 3 : 0;
13259
13260       for (errnode = arm_data->erratumlist; errnode != 0;
13261            errnode = errnode->next)
13262         {
13263           bfd_vma index = errnode->vma - offset;
13264
13265           switch (errnode->type)
13266             {
13267             case VFP11_ERRATUM_BRANCH_TO_ARM_VENEER:
13268               {
13269                 bfd_vma branch_to_veneer;
13270                 /* Original condition code of instruction, plus bit mask for
13271                    ARM B instruction.  */
13272                 unsigned int insn = (errnode->u.b.vfp_insn & 0xf0000000)
13273                                   | 0x0a000000;
13274
13275                 /* The instruction is before the label.  */
13276                 index -= 4;
13277
13278                 /* Above offset included in -4 below.  */
13279                 branch_to_veneer = errnode->u.b.veneer->vma
13280                                    - errnode->vma - 4;
13281
13282                 if ((signed) branch_to_veneer < -(1 << 25)
13283                     || (signed) branch_to_veneer >= (1 << 25))
13284                   (*_bfd_error_handler) (_("%B: error: VFP11 veneer out of "
13285                                            "range"), output_bfd);
13286
13287                 insn |= (branch_to_veneer >> 2) & 0xffffff;
13288                 contents[endianflip ^ index] = insn & 0xff;
13289                 contents[endianflip ^ (index + 1)] = (insn >> 8) & 0xff;
13290                 contents[endianflip ^ (index + 2)] = (insn >> 16) & 0xff;
13291                 contents[endianflip ^ (index + 3)] = (insn >> 24) & 0xff;
13292               }
13293               break;
13294
13295             case VFP11_ERRATUM_ARM_VENEER:
13296               {
13297                 bfd_vma branch_from_veneer;
13298                 unsigned int insn;
13299
13300                 /* Take size of veneer into account.  */
13301                 branch_from_veneer = errnode->u.v.branch->vma
13302                                      - errnode->vma - 12;
13303
13304                 if ((signed) branch_from_veneer < -(1 << 25)
13305                     || (signed) branch_from_veneer >= (1 << 25))
13306                   (*_bfd_error_handler) (_("%B: error: VFP11 veneer out of "
13307                                            "range"), output_bfd);
13308
13309                 /* Original instruction.  */
13310                 insn = errnode->u.v.branch->u.b.vfp_insn;
13311                 contents[endianflip ^ index] = insn & 0xff;
13312                 contents[endianflip ^ (index + 1)] = (insn >> 8) & 0xff;
13313                 contents[endianflip ^ (index + 2)] = (insn >> 16) & 0xff;
13314                 contents[endianflip ^ (index + 3)] = (insn >> 24) & 0xff;
13315
13316                 /* Branch back to insn after original insn.  */
13317                 insn = 0xea000000 | ((branch_from_veneer >> 2) & 0xffffff);
13318                 contents[endianflip ^ (index + 4)] = insn & 0xff;
13319                 contents[endianflip ^ (index + 5)] = (insn >> 8) & 0xff;
13320                 contents[endianflip ^ (index + 6)] = (insn >> 16) & 0xff;
13321                 contents[endianflip ^ (index + 7)] = (insn >> 24) & 0xff;
13322               }
13323               break;
13324
13325             default:
13326               abort ();
13327             }
13328         }
13329     }
13330
13331   if (arm_data->elf.this_hdr.sh_type == SHT_ARM_EXIDX)
13332     {
13333       arm_unwind_table_edit *edit_node
13334         = arm_data->u.exidx.unwind_edit_list;
13335       /* Now, sec->size is the size of the section we will write.  The original
13336          size (before we merged duplicate entries and inserted EXIDX_CANTUNWIND
13337          markers) was sec->rawsize.  (This isn't the case if we perform no
13338          edits, then rawsize will be zero and we should use size).  */
13339       bfd_byte *edited_contents = bfd_malloc (sec->size);
13340       unsigned int input_size = sec->rawsize ? sec->rawsize : sec->size;
13341       unsigned int in_index, out_index;
13342       bfd_vma add_to_offsets = 0;
13343
13344       for (in_index = 0, out_index = 0; in_index * 8 < input_size || edit_node;)
13345         {
13346           if (edit_node)
13347             {
13348               unsigned int edit_index = edit_node->index;
13349
13350               if (in_index < edit_index && in_index * 8 < input_size)
13351                 {
13352                   copy_exidx_entry (output_bfd, edited_contents + out_index * 8,
13353                                     contents + in_index * 8, add_to_offsets);
13354                   out_index++;
13355                   in_index++;
13356                 }
13357               else if (in_index == edit_index
13358                        || (in_index * 8 >= input_size
13359                            && edit_index == UINT_MAX))
13360                 {
13361                   switch (edit_node->type)
13362                     {
13363                     case DELETE_EXIDX_ENTRY:
13364                       in_index++;
13365                       add_to_offsets += 8;
13366                       break;
13367
13368                     case INSERT_EXIDX_CANTUNWIND_AT_END:
13369                       {
13370                         asection *text_sec = edit_node->linked_section;
13371                         bfd_vma text_offset = text_sec->output_section->vma
13372                                               + text_sec->output_offset
13373                                               + text_sec->size;
13374                         bfd_vma exidx_offset = offset + out_index * 8;
13375                         unsigned long prel31_offset;
13376
13377                         /* Note: this is meant to be equivalent to an
13378                            R_ARM_PREL31 relocation.  These synthetic
13379                            EXIDX_CANTUNWIND markers are not relocated by the
13380                            usual BFD method.  */
13381                         prel31_offset = (text_offset - exidx_offset)
13382                                         & 0x7ffffffful;
13383
13384                         /* First address we can't unwind.  */
13385                         bfd_put_32 (output_bfd, prel31_offset,
13386                                     &edited_contents[out_index * 8]);
13387
13388                         /* Code for EXIDX_CANTUNWIND.  */
13389                         bfd_put_32 (output_bfd, 0x1,
13390                                     &edited_contents[out_index * 8 + 4]);
13391
13392                         out_index++;
13393                         add_to_offsets -= 8;
13394                       }
13395                       break;
13396                     }
13397
13398                   edit_node = edit_node->next;
13399                 }
13400             }
13401           else
13402             {
13403               /* No more edits, copy remaining entries verbatim.  */
13404               copy_exidx_entry (output_bfd, edited_contents + out_index * 8,
13405                                 contents + in_index * 8, add_to_offsets);
13406               out_index++;
13407               in_index++;
13408             }
13409         }
13410
13411       if (!(sec->flags & SEC_EXCLUDE) && !(sec->flags & SEC_NEVER_LOAD))
13412         bfd_set_section_contents (output_bfd, sec->output_section,
13413                                   edited_contents,
13414                                   (file_ptr) sec->output_offset, sec->size);
13415
13416       return TRUE;
13417     }
13418
13419   /* Fix code to point to Cortex-A8 erratum stubs.  */
13420   if (globals->fix_cortex_a8)
13421     {
13422       struct a8_branch_to_stub_data data;
13423
13424       data.writing_section = sec;
13425       data.contents = contents;
13426
13427       bfd_hash_traverse (&globals->stub_hash_table, make_branch_to_a8_stub,
13428                          &data);
13429     }
13430
13431   if (mapcount == 0)
13432     return FALSE;
13433
13434   if (globals->byteswap_code)
13435     {
13436       qsort (map, mapcount, sizeof (* map), elf32_arm_compare_mapping);
13437
13438       ptr = map[0].vma;
13439       for (i = 0; i < mapcount; i++)
13440         {
13441           if (i == mapcount - 1)
13442             end = sec->size;
13443           else
13444             end = map[i + 1].vma;
13445
13446           switch (map[i].type)
13447             {
13448             case 'a':
13449               /* Byte swap code words.  */
13450               while (ptr + 3 < end)
13451                 {
13452                   tmp = contents[ptr];
13453                   contents[ptr] = contents[ptr + 3];
13454                   contents[ptr + 3] = tmp;
13455                   tmp = contents[ptr + 1];
13456                   contents[ptr + 1] = contents[ptr + 2];
13457                   contents[ptr + 2] = tmp;
13458                   ptr += 4;
13459                 }
13460               break;
13461
13462             case 't':
13463               /* Byte swap code halfwords.  */
13464               while (ptr + 1 < end)
13465                 {
13466                   tmp = contents[ptr];
13467                   contents[ptr] = contents[ptr + 1];
13468                   contents[ptr + 1] = tmp;
13469                   ptr += 2;
13470                 }
13471               break;
13472
13473             case 'd':
13474               /* Leave data alone.  */
13475               break;
13476             }
13477           ptr = end;
13478         }
13479     }
13480
13481   free (map);
13482   arm_data->mapcount = 0;
13483   arm_data->mapsize = 0;
13484   arm_data->map = NULL;
13485   unrecord_section_with_arm_elf_section_data (sec);
13486
13487   return FALSE;
13488 }
13489
13490 static void
13491 unrecord_section_via_map_over_sections (bfd * abfd ATTRIBUTE_UNUSED,
13492                                         asection * sec,
13493                                         void * ignore ATTRIBUTE_UNUSED)
13494 {
13495   unrecord_section_with_arm_elf_section_data (sec);
13496 }
13497
13498 static bfd_boolean
13499 elf32_arm_close_and_cleanup (bfd * abfd)
13500 {
13501   if (abfd->sections)
13502     bfd_map_over_sections (abfd,
13503                            unrecord_section_via_map_over_sections,
13504                            NULL);
13505
13506   return _bfd_elf_close_and_cleanup (abfd);
13507 }
13508
13509 static bfd_boolean
13510 elf32_arm_bfd_free_cached_info (bfd * abfd)
13511 {
13512   if (abfd->sections)
13513     bfd_map_over_sections (abfd,
13514                            unrecord_section_via_map_over_sections,
13515                            NULL);
13516
13517   return _bfd_free_cached_info (abfd);
13518 }
13519
13520 /* Display STT_ARM_TFUNC symbols as functions.  */
13521
13522 static void
13523 elf32_arm_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED,
13524                              asymbol *asym)
13525 {
13526   elf_symbol_type *elfsym = (elf_symbol_type *) asym;
13527
13528   if (ELF_ST_TYPE (elfsym->internal_elf_sym.st_info) == STT_ARM_TFUNC)
13529     elfsym->symbol.flags |= BSF_FUNCTION;
13530 }
13531
13532
13533 /* Mangle thumb function symbols as we read them in.  */
13534
13535 static bfd_boolean
13536 elf32_arm_swap_symbol_in (bfd * abfd,
13537                           const void *psrc,
13538                           const void *pshn,
13539                           Elf_Internal_Sym *dst)
13540 {
13541   if (!bfd_elf32_swap_symbol_in (abfd, psrc, pshn, dst))
13542     return FALSE;
13543
13544   /* New EABI objects mark thumb function symbols by setting the low bit of
13545      the address.  Turn these into STT_ARM_TFUNC.  */
13546   if ((ELF_ST_TYPE (dst->st_info) == STT_FUNC)
13547       && (dst->st_value & 1))
13548     {
13549       dst->st_info = ELF_ST_INFO (ELF_ST_BIND (dst->st_info), STT_ARM_TFUNC);
13550       dst->st_value &= ~(bfd_vma) 1;
13551     }
13552   return TRUE;
13553 }
13554
13555
13556 /* Mangle thumb function symbols as we write them out.  */
13557
13558 static void
13559 elf32_arm_swap_symbol_out (bfd *abfd,
13560                            const Elf_Internal_Sym *src,
13561                            void *cdst,
13562                            void *shndx)
13563 {
13564   Elf_Internal_Sym newsym;
13565
13566   /* We convert STT_ARM_TFUNC symbols into STT_FUNC with the low bit
13567      of the address set, as per the new EABI.  We do this unconditionally
13568      because objcopy does not set the elf header flags until after
13569      it writes out the symbol table.  */
13570   if (ELF_ST_TYPE (src->st_info) == STT_ARM_TFUNC)
13571     {
13572       newsym = *src;
13573       newsym.st_info = ELF_ST_INFO (ELF_ST_BIND (src->st_info), STT_FUNC);
13574       if (newsym.st_shndx != SHN_UNDEF)
13575         {
13576           /* Do this only for defined symbols. At link type, the static
13577              linker will simulate the work of dynamic linker of resolving
13578              symbols and will carry over the thumbness of found symbols to
13579              the output symbol table. It's not clear how it happens, but
13580              the thumbness of undefined symbols can well be different at
13581              runtime, and writing '1' for them will be confusing for users
13582              and possibly for dynamic linker itself.
13583           */
13584           newsym.st_value |= 1;
13585         }
13586
13587       src = &newsym;
13588     }
13589   bfd_elf32_swap_symbol_out (abfd, src, cdst, shndx);
13590 }
13591
13592 /* Add the PT_ARM_EXIDX program header.  */
13593
13594 static bfd_boolean
13595 elf32_arm_modify_segment_map (bfd *abfd,
13596                               struct bfd_link_info *info ATTRIBUTE_UNUSED)
13597 {
13598   struct elf_segment_map *m;
13599   asection *sec;
13600
13601   sec = bfd_get_section_by_name (abfd, ".ARM.exidx");
13602   if (sec != NULL && (sec->flags & SEC_LOAD) != 0)
13603     {
13604       /* If there is already a PT_ARM_EXIDX header, then we do not
13605          want to add another one.  This situation arises when running
13606          "strip"; the input binary already has the header.  */
13607       m = elf_tdata (abfd)->segment_map;
13608       while (m && m->p_type != PT_ARM_EXIDX)
13609         m = m->next;
13610       if (!m)
13611         {
13612           m = bfd_zalloc (abfd, sizeof (struct elf_segment_map));
13613           if (m == NULL)
13614             return FALSE;
13615           m->p_type = PT_ARM_EXIDX;
13616           m->count = 1;
13617           m->sections[0] = sec;
13618
13619           m->next = elf_tdata (abfd)->segment_map;
13620           elf_tdata (abfd)->segment_map = m;
13621         }
13622     }
13623
13624   return TRUE;
13625 }
13626
13627 /* We may add a PT_ARM_EXIDX program header.  */
13628
13629 static int
13630 elf32_arm_additional_program_headers (bfd *abfd,
13631                                       struct bfd_link_info *info ATTRIBUTE_UNUSED)
13632 {
13633   asection *sec;
13634
13635   sec = bfd_get_section_by_name (abfd, ".ARM.exidx");
13636   if (sec != NULL && (sec->flags & SEC_LOAD) != 0)
13637     return 1;
13638   else
13639     return 0;
13640 }
13641
13642 /* We have two function types: STT_FUNC and STT_ARM_TFUNC.  */
13643
13644 static bfd_boolean
13645 elf32_arm_is_function_type (unsigned int type)
13646 {
13647   return (type == STT_FUNC) || (type == STT_ARM_TFUNC);
13648 }
13649
13650 /* We use this to override swap_symbol_in and swap_symbol_out.  */
13651 const struct elf_size_info elf32_arm_size_info =
13652 {
13653   sizeof (Elf32_External_Ehdr),
13654   sizeof (Elf32_External_Phdr),
13655   sizeof (Elf32_External_Shdr),
13656   sizeof (Elf32_External_Rel),
13657   sizeof (Elf32_External_Rela),
13658   sizeof (Elf32_External_Sym),
13659   sizeof (Elf32_External_Dyn),
13660   sizeof (Elf_External_Note),
13661   4,
13662   1,
13663   32, 2,
13664   ELFCLASS32, EV_CURRENT,
13665   bfd_elf32_write_out_phdrs,
13666   bfd_elf32_write_shdrs_and_ehdr,
13667   bfd_elf32_checksum_contents,
13668   bfd_elf32_write_relocs,
13669   elf32_arm_swap_symbol_in,
13670   elf32_arm_swap_symbol_out,
13671   bfd_elf32_slurp_reloc_table,
13672   bfd_elf32_slurp_symbol_table,
13673   bfd_elf32_swap_dyn_in,
13674   bfd_elf32_swap_dyn_out,
13675   bfd_elf32_swap_reloc_in,
13676   bfd_elf32_swap_reloc_out,
13677   bfd_elf32_swap_reloca_in,
13678   bfd_elf32_swap_reloca_out
13679 };
13680
13681 #define ELF_ARCH                        bfd_arch_arm
13682 #define ELF_MACHINE_CODE                EM_ARM
13683 #ifdef __QNXTARGET__
13684 #define ELF_MAXPAGESIZE                 0x1000
13685 #else
13686 #define ELF_MAXPAGESIZE                 0x8000
13687 #endif
13688 #define ELF_MINPAGESIZE                 0x1000
13689 #define ELF_COMMONPAGESIZE              0x1000
13690
13691 #define bfd_elf32_mkobject                      elf32_arm_mkobject
13692
13693 #define bfd_elf32_bfd_copy_private_bfd_data     elf32_arm_copy_private_bfd_data
13694 #define bfd_elf32_bfd_merge_private_bfd_data    elf32_arm_merge_private_bfd_data
13695 #define bfd_elf32_bfd_set_private_flags         elf32_arm_set_private_flags
13696 #define bfd_elf32_bfd_print_private_bfd_data    elf32_arm_print_private_bfd_data
13697 #define bfd_elf32_bfd_link_hash_table_create    elf32_arm_link_hash_table_create
13698 #define bfd_elf32_bfd_link_hash_table_free      elf32_arm_hash_table_free
13699 #define bfd_elf32_bfd_reloc_type_lookup         elf32_arm_reloc_type_lookup
13700 #define bfd_elf32_bfd_reloc_name_lookup elf32_arm_reloc_name_lookup
13701 #define bfd_elf32_find_nearest_line             elf32_arm_find_nearest_line
13702 #define bfd_elf32_find_inliner_info             elf32_arm_find_inliner_info
13703 #define bfd_elf32_new_section_hook              elf32_arm_new_section_hook
13704 #define bfd_elf32_bfd_is_target_special_symbol  elf32_arm_is_target_special_symbol
13705 #define bfd_elf32_close_and_cleanup             elf32_arm_close_and_cleanup
13706 #define bfd_elf32_bfd_free_cached_info          elf32_arm_bfd_free_cached_info
13707 #define bfd_elf32_bfd_final_link                elf32_arm_final_link
13708
13709 #define elf_backend_get_symbol_type             elf32_arm_get_symbol_type
13710 #define elf_backend_gc_mark_hook                elf32_arm_gc_mark_hook
13711 #define elf_backend_gc_mark_extra_sections      elf32_arm_gc_mark_extra_sections
13712 #define elf_backend_gc_sweep_hook               elf32_arm_gc_sweep_hook
13713 #define elf_backend_check_relocs                elf32_arm_check_relocs
13714 #define elf_backend_relocate_section            elf32_arm_relocate_section
13715 #define elf_backend_write_section               elf32_arm_write_section
13716 #define elf_backend_adjust_dynamic_symbol       elf32_arm_adjust_dynamic_symbol
13717 #define elf_backend_create_dynamic_sections     elf32_arm_create_dynamic_sections
13718 #define elf_backend_finish_dynamic_symbol       elf32_arm_finish_dynamic_symbol
13719 #define elf_backend_finish_dynamic_sections     elf32_arm_finish_dynamic_sections
13720 #define elf_backend_size_dynamic_sections       elf32_arm_size_dynamic_sections
13721 #define elf_backend_init_index_section          _bfd_elf_init_2_index_sections
13722 #define elf_backend_post_process_headers        elf32_arm_post_process_headers
13723 #define elf_backend_reloc_type_class            elf32_arm_reloc_type_class
13724 #define elf_backend_object_p                    elf32_arm_object_p
13725 #define elf_backend_section_flags               elf32_arm_section_flags
13726 #define elf_backend_fake_sections               elf32_arm_fake_sections
13727 #define elf_backend_section_from_shdr           elf32_arm_section_from_shdr
13728 #define elf_backend_final_write_processing      elf32_arm_final_write_processing
13729 #define elf_backend_copy_indirect_symbol        elf32_arm_copy_indirect_symbol
13730 #define elf_backend_symbol_processing           elf32_arm_symbol_processing
13731 #define elf_backend_size_info                   elf32_arm_size_info
13732 #define elf_backend_modify_segment_map          elf32_arm_modify_segment_map
13733 #define elf_backend_additional_program_headers  elf32_arm_additional_program_headers
13734 #define elf_backend_output_arch_local_syms      elf32_arm_output_arch_local_syms
13735 #define elf_backend_begin_write_processing      elf32_arm_begin_write_processing
13736 #define elf_backend_is_function_type            elf32_arm_is_function_type
13737
13738 #define elf_backend_can_refcount       1
13739 #define elf_backend_can_gc_sections    1
13740 #define elf_backend_plt_readonly       1
13741 #define elf_backend_want_got_plt       1
13742 #define elf_backend_want_plt_sym       0
13743 #define elf_backend_may_use_rel_p      1
13744 #define elf_backend_may_use_rela_p     0
13745 #define elf_backend_default_use_rela_p 0
13746
13747 #define elf_backend_got_header_size     12
13748
13749 #undef  elf_backend_obj_attrs_vendor
13750 #define elf_backend_obj_attrs_vendor            "aeabi"
13751 #undef  elf_backend_obj_attrs_section
13752 #define elf_backend_obj_attrs_section           ".ARM.attributes"
13753 #undef  elf_backend_obj_attrs_arg_type
13754 #define elf_backend_obj_attrs_arg_type          elf32_arm_obj_attrs_arg_type
13755 #undef  elf_backend_obj_attrs_section_type
13756 #define elf_backend_obj_attrs_section_type      SHT_ARM_ATTRIBUTES
13757 #define elf_backend_obj_attrs_order     elf32_arm_obj_attrs_order
13758
13759 #include "elf32-target.h"
13760
13761 /* VxWorks Targets.  */
13762
13763 #undef  TARGET_LITTLE_SYM
13764 #define TARGET_LITTLE_SYM               bfd_elf32_littlearm_vxworks_vec
13765 #undef  TARGET_LITTLE_NAME
13766 #define TARGET_LITTLE_NAME              "elf32-littlearm-vxworks"
13767 #undef  TARGET_BIG_SYM
13768 #define TARGET_BIG_SYM                  bfd_elf32_bigarm_vxworks_vec
13769 #undef  TARGET_BIG_NAME
13770 #define TARGET_BIG_NAME                 "elf32-bigarm-vxworks"
13771
13772 /* Like elf32_arm_link_hash_table_create -- but overrides
13773    appropriately for VxWorks.  */
13774
13775 static struct bfd_link_hash_table *
13776 elf32_arm_vxworks_link_hash_table_create (bfd *abfd)
13777 {
13778   struct bfd_link_hash_table *ret;
13779
13780   ret = elf32_arm_link_hash_table_create (abfd);
13781   if (ret)
13782     {
13783       struct elf32_arm_link_hash_table *htab
13784         = (struct elf32_arm_link_hash_table *) ret;
13785       htab->use_rel = 0;
13786       htab->vxworks_p = 1;
13787     }
13788   return ret;
13789 }
13790
13791 static void
13792 elf32_arm_vxworks_final_write_processing (bfd *abfd, bfd_boolean linker)
13793 {
13794   elf32_arm_final_write_processing (abfd, linker);
13795   elf_vxworks_final_write_processing (abfd, linker);
13796 }
13797
13798 #undef  elf32_bed
13799 #define elf32_bed elf32_arm_vxworks_bed
13800
13801 #undef  bfd_elf32_bfd_link_hash_table_create
13802 #define bfd_elf32_bfd_link_hash_table_create    elf32_arm_vxworks_link_hash_table_create
13803 #undef  elf_backend_add_symbol_hook
13804 #define elf_backend_add_symbol_hook             elf_vxworks_add_symbol_hook
13805 #undef  elf_backend_final_write_processing
13806 #define elf_backend_final_write_processing      elf32_arm_vxworks_final_write_processing
13807 #undef  elf_backend_emit_relocs
13808 #define elf_backend_emit_relocs                 elf_vxworks_emit_relocs
13809
13810 #undef  elf_backend_may_use_rel_p
13811 #define elf_backend_may_use_rel_p       0
13812 #undef  elf_backend_may_use_rela_p
13813 #define elf_backend_may_use_rela_p      1
13814 #undef  elf_backend_default_use_rela_p
13815 #define elf_backend_default_use_rela_p  1
13816 #undef  elf_backend_want_plt_sym
13817 #define elf_backend_want_plt_sym        1
13818 #undef  ELF_MAXPAGESIZE
13819 #define ELF_MAXPAGESIZE                 0x1000
13820
13821 #include "elf32-target.h"
13822
13823
13824 /* Symbian OS Targets.  */
13825
13826 #undef  TARGET_LITTLE_SYM
13827 #define TARGET_LITTLE_SYM               bfd_elf32_littlearm_symbian_vec
13828 #undef  TARGET_LITTLE_NAME
13829 #define TARGET_LITTLE_NAME              "elf32-littlearm-symbian"
13830 #undef  TARGET_BIG_SYM
13831 #define TARGET_BIG_SYM                  bfd_elf32_bigarm_symbian_vec
13832 #undef  TARGET_BIG_NAME
13833 #define TARGET_BIG_NAME                 "elf32-bigarm-symbian"
13834
13835 /* Like elf32_arm_link_hash_table_create -- but overrides
13836    appropriately for Symbian OS.  */
13837
13838 static struct bfd_link_hash_table *
13839 elf32_arm_symbian_link_hash_table_create (bfd *abfd)
13840 {
13841   struct bfd_link_hash_table *ret;
13842
13843   ret = elf32_arm_link_hash_table_create (abfd);
13844   if (ret)
13845     {
13846       struct elf32_arm_link_hash_table *htab
13847         = (struct elf32_arm_link_hash_table *)ret;
13848       /* There is no PLT header for Symbian OS.  */
13849       htab->plt_header_size = 0;
13850       /* The PLT entries are each one instruction and one word.  */
13851       htab->plt_entry_size = 4 * ARRAY_SIZE (elf32_arm_symbian_plt_entry);
13852       htab->symbian_p = 1;
13853       /* Symbian uses armv5t or above, so use_blx is always true.  */
13854       htab->use_blx = 1;
13855       htab->root.is_relocatable_executable = 1;
13856     }
13857   return ret;
13858 }
13859
13860 static const struct bfd_elf_special_section
13861 elf32_arm_symbian_special_sections[] =
13862 {
13863   /* In a BPABI executable, the dynamic linking sections do not go in
13864      the loadable read-only segment.  The post-linker may wish to
13865      refer to these sections, but they are not part of the final
13866      program image.  */
13867   { STRING_COMMA_LEN (".dynamic"),       0, SHT_DYNAMIC,  0 },
13868   { STRING_COMMA_LEN (".dynstr"),        0, SHT_STRTAB,   0 },
13869   { STRING_COMMA_LEN (".dynsym"),        0, SHT_DYNSYM,   0 },
13870   { STRING_COMMA_LEN (".got"),           0, SHT_PROGBITS, 0 },
13871   { STRING_COMMA_LEN (".hash"),          0, SHT_HASH,     0 },
13872   /* These sections do not need to be writable as the SymbianOS
13873      postlinker will arrange things so that no dynamic relocation is
13874      required.  */
13875   { STRING_COMMA_LEN (".init_array"),    0, SHT_INIT_ARRAY,    SHF_ALLOC },
13876   { STRING_COMMA_LEN (".fini_array"),    0, SHT_FINI_ARRAY,    SHF_ALLOC },
13877   { STRING_COMMA_LEN (".preinit_array"), 0, SHT_PREINIT_ARRAY, SHF_ALLOC },
13878   { NULL,                             0, 0, 0,                 0 }
13879 };
13880
13881 static void
13882 elf32_arm_symbian_begin_write_processing (bfd *abfd,
13883                                           struct bfd_link_info *link_info)
13884 {
13885   /* BPABI objects are never loaded directly by an OS kernel; they are
13886      processed by a postlinker first, into an OS-specific format.  If
13887      the D_PAGED bit is set on the file, BFD will align segments on
13888      page boundaries, so that an OS can directly map the file.  With
13889      BPABI objects, that just results in wasted space.  In addition,
13890      because we clear the D_PAGED bit, map_sections_to_segments will
13891      recognize that the program headers should not be mapped into any
13892      loadable segment.  */
13893   abfd->flags &= ~D_PAGED;
13894   elf32_arm_begin_write_processing (abfd, link_info);
13895 }
13896
13897 static bfd_boolean
13898 elf32_arm_symbian_modify_segment_map (bfd *abfd,
13899                                       struct bfd_link_info *info)
13900 {
13901   struct elf_segment_map *m;
13902   asection *dynsec;
13903
13904   /* BPABI shared libraries and executables should have a PT_DYNAMIC
13905      segment.  However, because the .dynamic section is not marked
13906      with SEC_LOAD, the generic ELF code will not create such a
13907      segment.  */
13908   dynsec = bfd_get_section_by_name (abfd, ".dynamic");
13909   if (dynsec)
13910     {
13911       for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
13912         if (m->p_type == PT_DYNAMIC)
13913           break;
13914
13915       if (m == NULL)
13916         {
13917           m = _bfd_elf_make_dynamic_segment (abfd, dynsec);
13918           m->next = elf_tdata (abfd)->segment_map;
13919           elf_tdata (abfd)->segment_map = m;
13920         }
13921     }
13922
13923   /* Also call the generic arm routine.  */
13924   return elf32_arm_modify_segment_map (abfd, info);
13925 }
13926
13927 /* Return address for Ith PLT stub in section PLT, for relocation REL
13928    or (bfd_vma) -1 if it should not be included.  */
13929
13930 static bfd_vma
13931 elf32_arm_symbian_plt_sym_val (bfd_vma i, const asection *plt,
13932                                const arelent *rel ATTRIBUTE_UNUSED)
13933 {
13934   return plt->vma + 4 * ARRAY_SIZE (elf32_arm_symbian_plt_entry) * i;
13935 }
13936
13937
13938 #undef  elf32_bed
13939 #define elf32_bed elf32_arm_symbian_bed
13940
13941 /* The dynamic sections are not allocated on SymbianOS; the postlinker
13942    will process them and then discard them.  */
13943 #undef  ELF_DYNAMIC_SEC_FLAGS
13944 #define ELF_DYNAMIC_SEC_FLAGS \
13945   (SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED)
13946
13947 #undef elf_backend_add_symbol_hook
13948 #undef elf_backend_emit_relocs
13949
13950 #undef  bfd_elf32_bfd_link_hash_table_create
13951 #define bfd_elf32_bfd_link_hash_table_create    elf32_arm_symbian_link_hash_table_create
13952 #undef  elf_backend_special_sections
13953 #define elf_backend_special_sections            elf32_arm_symbian_special_sections
13954 #undef  elf_backend_begin_write_processing
13955 #define elf_backend_begin_write_processing      elf32_arm_symbian_begin_write_processing
13956 #undef  elf_backend_final_write_processing
13957 #define elf_backend_final_write_processing      elf32_arm_final_write_processing
13958
13959 #undef  elf_backend_modify_segment_map
13960 #define elf_backend_modify_segment_map elf32_arm_symbian_modify_segment_map
13961
13962 /* There is no .got section for BPABI objects, and hence no header.  */
13963 #undef  elf_backend_got_header_size
13964 #define elf_backend_got_header_size 0
13965
13966 /* Similarly, there is no .got.plt section.  */
13967 #undef  elf_backend_want_got_plt
13968 #define elf_backend_want_got_plt 0
13969
13970 #undef  elf_backend_plt_sym_val
13971 #define elf_backend_plt_sym_val         elf32_arm_symbian_plt_sym_val
13972
13973 #undef  elf_backend_may_use_rel_p
13974 #define elf_backend_may_use_rel_p       1
13975 #undef  elf_backend_may_use_rela_p
13976 #define elf_backend_may_use_rela_p      0
13977 #undef  elf_backend_default_use_rela_p
13978 #define elf_backend_default_use_rela_p  0
13979 #undef  elf_backend_want_plt_sym
13980 #define elf_backend_want_plt_sym        0
13981 #undef  ELF_MAXPAGESIZE
13982 #define ELF_MAXPAGESIZE                 0x8000
13983
13984 #include "elf32-target.h"