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, 2009  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 bfd_boolean elf32_arm_write_section (bfd *output_bfd,
  65                                             struct bfd_link_info *link_info,
  66                                             asection *sec,
  67                                             bfd_byte *contents);
  68
  69 /* Note: code such as elf32_arm_reloc_type_lookup expect to use e.g.
  70    R_ARM_PC24 as an index into this, and find the R_ARM_PC24 HOWTO
  71    in that slot.  */
  72
  73 static reloc_howto_type elf32_arm_howto_table_1[] =
  74 {
  75   /* No relocation.  */
  76   HOWTO (R_ARM_NONE,            /* type */
  77          0,                     /* rightshift */
  78          0,                     /* size (0 = byte, 1 = short, 2 = long) */
  79          0,                     /* bitsize */
  80          FALSE,                 /* pc_relative */
  81          0,                     /* bitpos */
  82          complain_overflow_dont,/* complain_on_overflow */
  83          bfd_elf_generic_reloc, /* special_function */
  84          "R_ARM_NONE",          /* name */
  85          FALSE,                 /* partial_inplace */
  86          0,                     /* src_mask */
  87          0,                     /* dst_mask */
  88          FALSE),                /* pcrel_offset */
  89
  90   HOWTO (R_ARM_PC24,            /* type */
  91          2,                     /* rightshift */
  92          2,                     /* size (0 = byte, 1 = short, 2 = long) */
  93          24,                    /* bitsize */
  94          TRUE,                  /* pc_relative */
  95          0,                     /* bitpos */
  96          complain_overflow_signed,/* complain_on_overflow */
  97          bfd_elf_generic_reloc, /* special_function */
  98          "R_ARM_PC24",          /* name */
  99          FALSE,                 /* partial_inplace */
 100          0x00ffffff,            /* src_mask */
 101          0x00ffffff,            /* dst_mask */
 102          TRUE),                 /* pcrel_offset */
 103
 104   /* 32 bit absolute */
 105   HOWTO (R_ARM_ABS32,           /* type */
 106          0,                     /* rightshift */
 107          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 108          32,                    /* bitsize */
 109          FALSE,                 /* pc_relative */
 110          0,                     /* bitpos */
 111          complain_overflow_bitfield,/* complain_on_overflow */
 112          bfd_elf_generic_reloc, /* special_function */
 113          "R_ARM_ABS32",         /* name */
 114          FALSE,                 /* partial_inplace */
 115          0xffffffff,            /* src_mask */
 116          0xffffffff,            /* dst_mask */
 117          FALSE),                /* pcrel_offset */
 118
 119   /* standard 32bit pc-relative reloc */
 120   HOWTO (R_ARM_REL32,           /* type */
 121          0,                     /* rightshift */
 122          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 123          32,                    /* bitsize */
 124          TRUE,                  /* pc_relative */
 125          0,                     /* bitpos */
 126          complain_overflow_bitfield,/* complain_on_overflow */
 127          bfd_elf_generic_reloc, /* special_function */
 128          "R_ARM_REL32",         /* name */
 129          FALSE,                 /* partial_inplace */
 130          0xffffffff,            /* src_mask */
 131          0xffffffff,            /* dst_mask */
 132          TRUE),                 /* pcrel_offset */
 133
 134   /* 8 bit absolute - R_ARM_LDR_PC_G0 in AAELF */
 135   HOWTO (R_ARM_LDR_PC_G0,       /* type */
 136          0,                     /* rightshift */
 137          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 138          32,                    /* bitsize */
 139          TRUE,                  /* pc_relative */
 140          0,                     /* bitpos */
 141          complain_overflow_dont,/* complain_on_overflow */
 142          bfd_elf_generic_reloc, /* special_function */
 143          "R_ARM_LDR_PC_G0",     /* name */
 144          FALSE,                 /* partial_inplace */
 145          0xffffffff,            /* src_mask */
 146          0xffffffff,            /* dst_mask */
 147          TRUE),                 /* pcrel_offset */
 148
 149    /* 16 bit absolute */
 150   HOWTO (R_ARM_ABS16,           /* type */
 151          0,                     /* rightshift */
 152          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 153          16,                    /* bitsize */
 154          FALSE,                 /* pc_relative */
 155          0,                     /* bitpos */
 156          complain_overflow_bitfield,/* complain_on_overflow */
 157          bfd_elf_generic_reloc, /* special_function */
 158          "R_ARM_ABS16",         /* name */
 159          FALSE,                 /* partial_inplace */
 160          0x0000ffff,            /* src_mask */
 161          0x0000ffff,            /* dst_mask */
 162          FALSE),                /* pcrel_offset */
 163
 164   /* 12 bit absolute */
 165   HOWTO (R_ARM_ABS12,           /* type */
 166          0,                     /* rightshift */
 167          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 168          12,                    /* bitsize */
 169          FALSE,                 /* pc_relative */
 170          0,                     /* bitpos */
 171          complain_overflow_bitfield,/* complain_on_overflow */
 172          bfd_elf_generic_reloc, /* special_function */
 173          "R_ARM_ABS12",         /* name */
 174          FALSE,                 /* partial_inplace */
 175          0x00000fff,            /* src_mask */
 176          0x00000fff,            /* dst_mask */
 177          FALSE),                /* pcrel_offset */
 178
 179   HOWTO (R_ARM_THM_ABS5,        /* type */
 180          6,                     /* rightshift */
 181          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 182          5,                     /* bitsize */
 183          FALSE,                 /* pc_relative */
 184          0,                     /* bitpos */
 185          complain_overflow_bitfield,/* complain_on_overflow */
 186          bfd_elf_generic_reloc, /* special_function */
 187          "R_ARM_THM_ABS5",      /* name */
 188          FALSE,                 /* partial_inplace */
 189          0x000007e0,            /* src_mask */
 190          0x000007e0,            /* dst_mask */
 191          FALSE),                /* pcrel_offset */
 192
 193   /* 8 bit absolute */
 194   HOWTO (R_ARM_ABS8,            /* type */
 195          0,                     /* rightshift */
 196          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 197          8,                     /* bitsize */
 198          FALSE,                 /* pc_relative */
 199          0,                     /* bitpos */
 200          complain_overflow_bitfield,/* complain_on_overflow */
 201          bfd_elf_generic_reloc, /* special_function */
 202          "R_ARM_ABS8",          /* name */
 203          FALSE,                 /* partial_inplace */
 204          0x000000ff,            /* src_mask */
 205          0x000000ff,            /* dst_mask */
 206          FALSE),                /* pcrel_offset */
 207
 208   HOWTO (R_ARM_SBREL32,         /* type */
 209          0,                     /* rightshift */
 210          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 211          32,                    /* bitsize */
 212          FALSE,                 /* pc_relative */
 213          0,                     /* bitpos */
 214          complain_overflow_dont,/* complain_on_overflow */
 215          bfd_elf_generic_reloc, /* special_function */
 216          "R_ARM_SBREL32",       /* name */
 217          FALSE,                 /* partial_inplace */
 218          0xffffffff,            /* src_mask */
 219          0xffffffff,            /* dst_mask */
 220          FALSE),                /* pcrel_offset */
 221
 222   HOWTO (R_ARM_THM_CALL,        /* type */
 223          1,                     /* rightshift */
 224          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 225          25,                    /* bitsize */
 226          TRUE,                  /* pc_relative */
 227          0,                     /* bitpos */
 228          complain_overflow_signed,/* complain_on_overflow */
 229          bfd_elf_generic_reloc, /* special_function */
 230          "R_ARM_THM_CALL",      /* name */
 231          FALSE,                 /* partial_inplace */
 232          0x07ff07ff,            /* src_mask */
 233          0x07ff07ff,            /* dst_mask */
 234          TRUE),                 /* pcrel_offset */
 235
 236   HOWTO (R_ARM_THM_PC8,         /* type */
 237          1,                     /* rightshift */
 238          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 239          8,                     /* bitsize */
 240          TRUE,                  /* pc_relative */
 241          0,                     /* bitpos */
 242          complain_overflow_signed,/* complain_on_overflow */
 243          bfd_elf_generic_reloc, /* special_function */
 244          "R_ARM_THM_PC8",       /* name */
 245          FALSE,                 /* partial_inplace */
 246          0x000000ff,            /* src_mask */
 247          0x000000ff,            /* dst_mask */
 248          TRUE),                 /* pcrel_offset */
 249
 250   HOWTO (R_ARM_BREL_ADJ,        /* type */
 251          1,                     /* rightshift */
 252          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 253          32,                    /* bitsize */
 254          FALSE,                 /* pc_relative */
 255          0,                     /* bitpos */
 256          complain_overflow_signed,/* complain_on_overflow */
 257          bfd_elf_generic_reloc, /* special_function */
 258          "R_ARM_BREL_ADJ",      /* name */
 259          FALSE,                 /* partial_inplace */
 260          0xffffffff,            /* src_mask */
 261          0xffffffff,            /* dst_mask */
 262          FALSE),                /* pcrel_offset */
 263
 264   HOWTO (R_ARM_SWI24,           /* type */
 265          0,                     /* rightshift */
 266          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 267          0,                     /* bitsize */
 268          FALSE,                 /* pc_relative */
 269          0,                     /* bitpos */
 270          complain_overflow_signed,/* complain_on_overflow */
 271          bfd_elf_generic_reloc, /* special_function */
 272          "R_ARM_SWI24",         /* name */
 273          FALSE,                 /* partial_inplace */
 274          0x00000000,            /* src_mask */
 275          0x00000000,            /* dst_mask */
 276          FALSE),                /* pcrel_offset */
 277
 278   HOWTO (R_ARM_THM_SWI8,        /* type */
 279          0,                     /* rightshift */
 280          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 281          0,                     /* bitsize */
 282          FALSE,                 /* pc_relative */
 283          0,                     /* bitpos */
 284          complain_overflow_signed,/* complain_on_overflow */
 285          bfd_elf_generic_reloc, /* special_function */
 286          "R_ARM_SWI8",          /* name */
 287          FALSE,                 /* partial_inplace */
 288          0x00000000,            /* src_mask */
 289          0x00000000,            /* dst_mask */
 290          FALSE),                /* pcrel_offset */
 291
 292   /* BLX instruction for the ARM.  */
 293   HOWTO (R_ARM_XPC25,           /* type */
 294          2,                     /* rightshift */
 295          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 296          25,                    /* bitsize */
 297          TRUE,                  /* pc_relative */
 298          0,                     /* bitpos */
 299          complain_overflow_signed,/* complain_on_overflow */
 300          bfd_elf_generic_reloc, /* special_function */
 301          "R_ARM_XPC25",         /* name */
 302          FALSE,                 /* partial_inplace */
 303          0x00ffffff,            /* src_mask */
 304          0x00ffffff,            /* dst_mask */
 305          TRUE),                 /* pcrel_offset */
 306
 307   /* BLX instruction for the Thumb.  */
 308   HOWTO (R_ARM_THM_XPC22,       /* type */
 309          2,                     /* rightshift */
 310          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 311          22,                    /* bitsize */
 312          TRUE,                  /* pc_relative */
 313          0,                     /* bitpos */
 314          complain_overflow_signed,/* complain_on_overflow */
 315          bfd_elf_generic_reloc, /* special_function */
 316          "R_ARM_THM_XPC22",     /* name */
 317          FALSE,                 /* partial_inplace */
 318          0x07ff07ff,            /* src_mask */
 319          0x07ff07ff,            /* dst_mask */
 320          TRUE),                 /* pcrel_offset */
 321
 322   /* Dynamic TLS relocations.  */
 323
 324   HOWTO (R_ARM_TLS_DTPMOD32,    /* type */
 325          0,                     /* rightshift */
 326          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 327          32,                    /* bitsize */
 328          FALSE,                 /* pc_relative */
 329          0,                     /* bitpos */
 330          complain_overflow_bitfield,/* complain_on_overflow */
 331          bfd_elf_generic_reloc, /* special_function */
 332          "R_ARM_TLS_DTPMOD32",  /* name */
 333          TRUE,                  /* partial_inplace */
 334          0xffffffff,            /* src_mask */
 335          0xffffffff,            /* dst_mask */
 336          FALSE),                /* pcrel_offset */
 337
 338   HOWTO (R_ARM_TLS_DTPOFF32,    /* type */
 339          0,                     /* rightshift */
 340          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 341          32,                    /* bitsize */
 342          FALSE,                 /* pc_relative */
 343          0,                     /* bitpos */
 344          complain_overflow_bitfield,/* complain_on_overflow */
 345          bfd_elf_generic_reloc, /* special_function */
 346          "R_ARM_TLS_DTPOFF32",  /* name */
 347          TRUE,                  /* partial_inplace */
 348          0xffffffff,            /* src_mask */
 349          0xffffffff,            /* dst_mask */
 350          FALSE),                /* pcrel_offset */
 351
 352   HOWTO (R_ARM_TLS_TPOFF32,     /* type */
 353          0,                     /* rightshift */
 354          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 355          32,                    /* bitsize */
 356          FALSE,                 /* pc_relative */
 357          0,                     /* bitpos */
 358          complain_overflow_bitfield,/* complain_on_overflow */
 359          bfd_elf_generic_reloc, /* special_function */
 360          "R_ARM_TLS_TPOFF32",   /* name */
 361          TRUE,                  /* partial_inplace */
 362          0xffffffff,            /* src_mask */
 363          0xffffffff,            /* dst_mask */
 364          FALSE),                /* pcrel_offset */
 365
 366   /* Relocs used in ARM Linux */
 367
 368   HOWTO (R_ARM_COPY,            /* type */
 369          0,                     /* rightshift */
 370          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 371          32,                    /* bitsize */
 372          FALSE,                 /* pc_relative */
 373          0,                     /* bitpos */
 374          complain_overflow_bitfield,/* complain_on_overflow */
 375          bfd_elf_generic_reloc, /* special_function */
 376          "R_ARM_COPY",          /* name */
 377          TRUE,                  /* partial_inplace */
 378          0xffffffff,            /* src_mask */
 379          0xffffffff,            /* dst_mask */
 380          FALSE),                /* pcrel_offset */
 381
 382   HOWTO (R_ARM_GLOB_DAT,        /* type */
 383          0,                     /* rightshift */
 384          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 385          32,                    /* bitsize */
 386          FALSE,                 /* pc_relative */
 387          0,                     /* bitpos */
 388          complain_overflow_bitfield,/* complain_on_overflow */
 389          bfd_elf_generic_reloc, /* special_function */
 390          "R_ARM_GLOB_DAT",      /* name */
 391          TRUE,                  /* partial_inplace */
 392          0xffffffff,            /* src_mask */
 393          0xffffffff,            /* dst_mask */
 394          FALSE),                /* pcrel_offset */
 395
 396   HOWTO (R_ARM_JUMP_SLOT,       /* type */
 397          0,                     /* rightshift */
 398          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 399          32,                    /* bitsize */
 400          FALSE,                 /* pc_relative */
 401          0,                     /* bitpos */
 402          complain_overflow_bitfield,/* complain_on_overflow */
 403          bfd_elf_generic_reloc, /* special_function */
 404          "R_ARM_JUMP_SLOT",     /* name */
 405          TRUE,                  /* partial_inplace */
 406          0xffffffff,            /* src_mask */
 407          0xffffffff,            /* dst_mask */
 408          FALSE),                /* pcrel_offset */
 409
 410   HOWTO (R_ARM_RELATIVE,        /* type */
 411          0,                     /* rightshift */
 412          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 413          32,                    /* bitsize */
 414          FALSE,                 /* pc_relative */
 415          0,                     /* bitpos */
 416          complain_overflow_bitfield,/* complain_on_overflow */
 417          bfd_elf_generic_reloc, /* special_function */
 418          "R_ARM_RELATIVE",      /* name */
 419          TRUE,                  /* partial_inplace */
 420          0xffffffff,            /* src_mask */
 421          0xffffffff,            /* dst_mask */
 422          FALSE),                /* pcrel_offset */
 423
 424   HOWTO (R_ARM_GOTOFF32,        /* type */
 425          0,                     /* rightshift */
 426          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 427          32,                    /* bitsize */
 428          FALSE,                 /* pc_relative */
 429          0,                     /* bitpos */
 430          complain_overflow_bitfield,/* complain_on_overflow */
 431          bfd_elf_generic_reloc, /* special_function */
 432          "R_ARM_GOTOFF32",      /* name */
 433          TRUE,                  /* partial_inplace */
 434          0xffffffff,            /* src_mask */
 435          0xffffffff,            /* dst_mask */
 436          FALSE),                /* pcrel_offset */
 437
 438   HOWTO (R_ARM_GOTPC,           /* type */
 439          0,                     /* rightshift */
 440          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 441          32,                    /* bitsize */
 442          TRUE,                  /* pc_relative */
 443          0,                     /* bitpos */
 444          complain_overflow_bitfield,/* complain_on_overflow */
 445          bfd_elf_generic_reloc, /* special_function */
 446          "R_ARM_GOTPC",         /* name */
 447          TRUE,                  /* partial_inplace */
 448          0xffffffff,            /* src_mask */
 449          0xffffffff,            /* dst_mask */
 450          TRUE),                 /* pcrel_offset */
 451
 452   HOWTO (R_ARM_GOT32,           /* type */
 453          0,                     /* rightshift */
 454          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 455          32,                    /* bitsize */
 456          FALSE,                 /* pc_relative */
 457          0,                     /* bitpos */
 458          complain_overflow_bitfield,/* complain_on_overflow */
 459          bfd_elf_generic_reloc, /* special_function */
 460          "R_ARM_GOT32",         /* name */
 461          TRUE,                  /* partial_inplace */
 462          0xffffffff,            /* src_mask */
 463          0xffffffff,            /* dst_mask */
 464          FALSE),                /* pcrel_offset */
 465
 466   HOWTO (R_ARM_PLT32,           /* type */
 467          2,                     /* rightshift */
 468          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 469          24,                    /* bitsize */
 470          TRUE,                  /* pc_relative */
 471          0,                     /* bitpos */
 472          complain_overflow_bitfield,/* complain_on_overflow */
 473          bfd_elf_generic_reloc, /* special_function */
 474          "R_ARM_PLT32",         /* name */
 475          FALSE,                 /* partial_inplace */
 476          0x00ffffff,            /* src_mask */
 477          0x00ffffff,            /* dst_mask */
 478          TRUE),                 /* pcrel_offset */
 479
 480   HOWTO (R_ARM_CALL,            /* type */
 481          2,                     /* rightshift */
 482          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 483          24,                    /* bitsize */
 484          TRUE,                  /* pc_relative */
 485          0,                     /* bitpos */
 486          complain_overflow_signed,/* complain_on_overflow */
 487          bfd_elf_generic_reloc, /* special_function */
 488          "R_ARM_CALL",          /* name */
 489          FALSE,                 /* partial_inplace */
 490          0x00ffffff,            /* src_mask */
 491          0x00ffffff,            /* dst_mask */
 492          TRUE),                 /* pcrel_offset */
 493
 494   HOWTO (R_ARM_JUMP24,          /* type */
 495          2,                     /* rightshift */
 496          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 497          24,                    /* bitsize */
 498          TRUE,                  /* pc_relative */
 499          0,                     /* bitpos */
 500          complain_overflow_signed,/* complain_on_overflow */
 501          bfd_elf_generic_reloc, /* special_function */
 502          "R_ARM_JUMP24",        /* name */
 503          FALSE,                 /* partial_inplace */
 504          0x00ffffff,            /* src_mask */
 505          0x00ffffff,            /* dst_mask */
 506          TRUE),                 /* pcrel_offset */
 507
 508   HOWTO (R_ARM_THM_JUMP24,      /* type */
 509          1,                     /* rightshift */
 510          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 511          24,                    /* bitsize */
 512          TRUE,                  /* pc_relative */
 513          0,                     /* bitpos */
 514          complain_overflow_signed,/* complain_on_overflow */
 515          bfd_elf_generic_reloc, /* special_function */
 516          "R_ARM_THM_JUMP24",    /* name */
 517          FALSE,                 /* partial_inplace */
 518          0x07ff2fff,            /* src_mask */
 519          0x07ff2fff,            /* dst_mask */
 520          TRUE),                 /* pcrel_offset */
 521
 522   HOWTO (R_ARM_BASE_ABS,        /* type */
 523          0,                     /* rightshift */
 524          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 525          32,                    /* bitsize */
 526          FALSE,                 /* pc_relative */
 527          0,                     /* bitpos */
 528          complain_overflow_dont,/* complain_on_overflow */
 529          bfd_elf_generic_reloc, /* special_function */
 530          "R_ARM_BASE_ABS",      /* name */
 531          FALSE,                 /* partial_inplace */
 532          0xffffffff,            /* src_mask */
 533          0xffffffff,            /* dst_mask */
 534          FALSE),                /* pcrel_offset */
 535
 536   HOWTO (R_ARM_ALU_PCREL7_0,    /* type */
 537          0,                     /* rightshift */
 538          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 539          12,                    /* bitsize */
 540          TRUE,                  /* pc_relative */
 541          0,                     /* bitpos */
 542          complain_overflow_dont,/* complain_on_overflow */
 543          bfd_elf_generic_reloc, /* special_function */
 544          "R_ARM_ALU_PCREL_7_0", /* name */
 545          FALSE,                 /* partial_inplace */
 546          0x00000fff,            /* src_mask */
 547          0x00000fff,            /* dst_mask */
 548          TRUE),                 /* pcrel_offset */
 549
 550   HOWTO (R_ARM_ALU_PCREL15_8,   /* type */
 551          0,                     /* rightshift */
 552          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 553          12,                    /* bitsize */
 554          TRUE,                  /* pc_relative */
 555          8,                     /* bitpos */
 556          complain_overflow_dont,/* complain_on_overflow */
 557          bfd_elf_generic_reloc, /* special_function */
 558          "R_ARM_ALU_PCREL_15_8",/* name */
 559          FALSE,                 /* partial_inplace */
 560          0x00000fff,            /* src_mask */
 561          0x00000fff,            /* dst_mask */
 562          TRUE),                 /* pcrel_offset */
 563
 564   HOWTO (R_ARM_ALU_PCREL23_15,  /* type */
 565          0,                     /* rightshift */
 566          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 567          12,                    /* bitsize */
 568          TRUE,                  /* pc_relative */
 569          16,                    /* bitpos */
 570          complain_overflow_dont,/* complain_on_overflow */
 571          bfd_elf_generic_reloc, /* special_function */
 572          "R_ARM_ALU_PCREL_23_15",/* name */
 573          FALSE,                 /* partial_inplace */
 574          0x00000fff,            /* src_mask */
 575          0x00000fff,            /* dst_mask */
 576          TRUE),                 /* pcrel_offset */
 577
 578   HOWTO (R_ARM_LDR_SBREL_11_0,  /* type */
 579          0,                     /* rightshift */
 580          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 581          12,                    /* bitsize */
 582          FALSE,                 /* pc_relative */
 583          0,                     /* bitpos */
 584          complain_overflow_dont,/* complain_on_overflow */
 585          bfd_elf_generic_reloc, /* special_function */
 586          "R_ARM_LDR_SBREL_11_0",/* name */
 587          FALSE,                 /* partial_inplace */
 588          0x00000fff,            /* src_mask */
 589          0x00000fff,            /* dst_mask */
 590          FALSE),                /* pcrel_offset */
 591
 592   HOWTO (R_ARM_ALU_SBREL_19_12, /* type */
 593          0,                     /* rightshift */
 594          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 595          8,                     /* bitsize */
 596          FALSE,                 /* pc_relative */
 597          12,                    /* bitpos */
 598          complain_overflow_dont,/* complain_on_overflow */
 599          bfd_elf_generic_reloc, /* special_function */
 600          "R_ARM_ALU_SBREL_19_12",/* name */
 601          FALSE,                 /* partial_inplace */
 602          0x000ff000,            /* src_mask */
 603          0x000ff000,            /* dst_mask */
 604          FALSE),                /* pcrel_offset */
 605
 606   HOWTO (R_ARM_ALU_SBREL_27_20, /* type */
 607          0,                     /* rightshift */
 608          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 609          8,                     /* bitsize */
 610          FALSE,                 /* pc_relative */
 611          20,                    /* bitpos */
 612          complain_overflow_dont,/* complain_on_overflow */
 613          bfd_elf_generic_reloc, /* special_function */
 614          "R_ARM_ALU_SBREL_27_20",/* name */
 615          FALSE,                 /* partial_inplace */
 616          0x0ff00000,            /* src_mask */
 617          0x0ff00000,            /* dst_mask */
 618          FALSE),                /* pcrel_offset */
 619
 620   HOWTO (R_ARM_TARGET1,         /* type */
 621          0,                     /* rightshift */
 622          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 623          32,                    /* bitsize */
 624          FALSE,                 /* pc_relative */
 625          0,                     /* bitpos */
 626          complain_overflow_dont,/* complain_on_overflow */
 627          bfd_elf_generic_reloc, /* special_function */
 628          "R_ARM_TARGET1",       /* name */
 629          FALSE,                 /* partial_inplace */
 630          0xffffffff,            /* src_mask */
 631          0xffffffff,            /* dst_mask */
 632          FALSE),                /* pcrel_offset */
 633
 634   HOWTO (R_ARM_ROSEGREL32,      /* type */
 635          0,                     /* rightshift */
 636          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 637          32,                    /* bitsize */
 638          FALSE,                 /* pc_relative */
 639          0,                     /* bitpos */
 640          complain_overflow_dont,/* complain_on_overflow */
 641          bfd_elf_generic_reloc, /* special_function */
 642          "R_ARM_ROSEGREL32",    /* name */
 643          FALSE,                 /* partial_inplace */
 644          0xffffffff,            /* src_mask */
 645          0xffffffff,            /* dst_mask */
 646          FALSE),                /* pcrel_offset */
 647
 648   HOWTO (R_ARM_V4BX,            /* type */
 649          0,                     /* rightshift */
 650          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 651          32,                    /* bitsize */
 652          FALSE,                 /* pc_relative */
 653          0,                     /* bitpos */
 654          complain_overflow_dont,/* complain_on_overflow */
 655          bfd_elf_generic_reloc, /* special_function */
 656          "R_ARM_V4BX",          /* name */
 657          FALSE,                 /* partial_inplace */
 658          0xffffffff,            /* src_mask */
 659          0xffffffff,            /* dst_mask */
 660          FALSE),                /* pcrel_offset */
 661
 662   HOWTO (R_ARM_TARGET2,         /* type */
 663          0,                     /* rightshift */
 664          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 665          32,                    /* bitsize */
 666          FALSE,                 /* pc_relative */
 667          0,                     /* bitpos */
 668          complain_overflow_signed,/* complain_on_overflow */
 669          bfd_elf_generic_reloc, /* special_function */
 670          "R_ARM_TARGET2",       /* name */
 671          FALSE,                 /* partial_inplace */
 672          0xffffffff,            /* src_mask */
 673          0xffffffff,            /* dst_mask */
 674          TRUE),                 /* pcrel_offset */
 675
 676   HOWTO (R_ARM_PREL31,          /* type */
 677          0,                     /* rightshift */
 678          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 679          31,                    /* bitsize */
 680          TRUE,                  /* pc_relative */
 681          0,                     /* bitpos */
 682          complain_overflow_signed,/* complain_on_overflow */
 683          bfd_elf_generic_reloc, /* special_function */
 684          "R_ARM_PREL31",        /* name */
 685          FALSE,                 /* partial_inplace */
 686          0x7fffffff,            /* src_mask */
 687          0x7fffffff,            /* dst_mask */
 688          TRUE),                 /* pcrel_offset */
 689
 690   HOWTO (R_ARM_MOVW_ABS_NC,     /* type */
 691          0,                     /* rightshift */
 692          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 693          16,                    /* bitsize */
 694          FALSE,                 /* pc_relative */
 695          0,                     /* bitpos */
 696          complain_overflow_dont,/* complain_on_overflow */
 697          bfd_elf_generic_reloc, /* special_function */
 698          "R_ARM_MOVW_ABS_NC",   /* name */
 699          FALSE,                 /* partial_inplace */
 700          0x000f0fff,            /* src_mask */
 701          0x000f0fff,            /* dst_mask */
 702          FALSE),                /* pcrel_offset */
 703
 704   HOWTO (R_ARM_MOVT_ABS,        /* type */
 705          0,                     /* rightshift */
 706          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 707          16,                    /* bitsize */
 708          FALSE,                 /* pc_relative */
 709          0,                     /* bitpos */
 710          complain_overflow_bitfield,/* complain_on_overflow */
 711          bfd_elf_generic_reloc, /* special_function */
 712          "R_ARM_MOVT_ABS",      /* name */
 713          FALSE,                 /* partial_inplace */
 714          0x000f0fff,            /* src_mask */
 715          0x000f0fff,            /* dst_mask */
 716          FALSE),                /* pcrel_offset */
 717
 718   HOWTO (R_ARM_MOVW_PREL_NC,    /* type */
 719          0,                     /* rightshift */
 720          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 721          16,                    /* bitsize */
 722          TRUE,                  /* pc_relative */
 723          0,                     /* bitpos */
 724          complain_overflow_dont,/* complain_on_overflow */
 725          bfd_elf_generic_reloc, /* special_function */
 726          "R_ARM_MOVW_PREL_NC",  /* name */
 727          FALSE,                 /* partial_inplace */
 728          0x000f0fff,            /* src_mask */
 729          0x000f0fff,            /* dst_mask */
 730          TRUE),                 /* pcrel_offset */
 731
 732   HOWTO (R_ARM_MOVT_PREL,       /* type */
 733          0,                     /* rightshift */
 734          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 735          16,                    /* bitsize */
 736          TRUE,                  /* pc_relative */
 737          0,                     /* bitpos */
 738          complain_overflow_bitfield,/* complain_on_overflow */
 739          bfd_elf_generic_reloc, /* special_function */
 740          "R_ARM_MOVT_PREL",     /* name */
 741          FALSE,                 /* partial_inplace */
 742          0x000f0fff,            /* src_mask */
 743          0x000f0fff,            /* dst_mask */
 744          TRUE),                 /* pcrel_offset */
 745
 746   HOWTO (R_ARM_THM_MOVW_ABS_NC, /* type */
 747          0,                     /* rightshift */
 748          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 749          16,                    /* bitsize */
 750          FALSE,                 /* pc_relative */
 751          0,                     /* bitpos */
 752          complain_overflow_dont,/* complain_on_overflow */
 753          bfd_elf_generic_reloc, /* special_function */
 754          "R_ARM_THM_MOVW_ABS_NC",/* name */
 755          FALSE,                 /* partial_inplace */
 756          0x040f70ff,            /* src_mask */
 757          0x040f70ff,            /* dst_mask */
 758          FALSE),                /* pcrel_offset */
 759
 760   HOWTO (R_ARM_THM_MOVT_ABS,    /* type */
 761          0,                     /* rightshift */
 762          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 763          16,                    /* bitsize */
 764          FALSE,                 /* pc_relative */
 765          0,                     /* bitpos */
 766          complain_overflow_bitfield,/* complain_on_overflow */
 767          bfd_elf_generic_reloc, /* special_function */
 768          "R_ARM_THM_MOVT_ABS",  /* name */
 769          FALSE,                 /* partial_inplace */
 770          0x040f70ff,            /* src_mask */
 771          0x040f70ff,            /* dst_mask */
 772          FALSE),                /* pcrel_offset */
 773
 774   HOWTO (R_ARM_THM_MOVW_PREL_NC,/* type */
 775          0,                     /* rightshift */
 776          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 777          16,                    /* bitsize */
 778          TRUE,                  /* pc_relative */
 779          0,                     /* bitpos */
 780          complain_overflow_dont,/* complain_on_overflow */
 781          bfd_elf_generic_reloc, /* special_function */
 782          "R_ARM_THM_MOVW_PREL_NC",/* name */
 783          FALSE,                 /* partial_inplace */
 784          0x040f70ff,            /* src_mask */
 785          0x040f70ff,            /* dst_mask */
 786          TRUE),                 /* pcrel_offset */
 787
 788   HOWTO (R_ARM_THM_MOVT_PREL,   /* type */
 789          0,                     /* rightshift */
 790          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 791          16,                    /* bitsize */
 792          TRUE,                  /* pc_relative */
 793          0,                     /* bitpos */
 794          complain_overflow_bitfield,/* complain_on_overflow */
 795          bfd_elf_generic_reloc, /* special_function */
 796          "R_ARM_THM_MOVT_PREL", /* name */
 797          FALSE,                 /* partial_inplace */
 798          0x040f70ff,            /* src_mask */
 799          0x040f70ff,            /* dst_mask */
 800          TRUE),                 /* pcrel_offset */
 801
 802   HOWTO (R_ARM_THM_JUMP19,      /* type */
 803          1,                     /* rightshift */
 804          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 805          19,                    /* bitsize */
 806          TRUE,                  /* pc_relative */
 807          0,                     /* bitpos */
 808          complain_overflow_signed,/* complain_on_overflow */
 809          bfd_elf_generic_reloc, /* special_function */
 810          "R_ARM_THM_JUMP19",    /* name */
 811          FALSE,                 /* partial_inplace */
 812          0x043f2fff,            /* src_mask */
 813          0x043f2fff,            /* dst_mask */
 814          TRUE),                 /* pcrel_offset */
 815
 816   HOWTO (R_ARM_THM_JUMP6,       /* type */
 817          1,                     /* rightshift */
 818          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 819          6,                     /* bitsize */
 820          TRUE,                  /* pc_relative */
 821          0,                     /* bitpos */
 822          complain_overflow_unsigned,/* complain_on_overflow */
 823          bfd_elf_generic_reloc, /* special_function */
 824          "R_ARM_THM_JUMP6",     /* name */
 825          FALSE,                 /* partial_inplace */
 826          0x02f8,                /* src_mask */
 827          0x02f8,                /* dst_mask */
 828          TRUE),                 /* pcrel_offset */
 829
 830   /* These are declared as 13-bit signed relocations because we can
 831      address -4095 .. 4095(base) by altering ADDW to SUBW or vice
 832      versa.  */
 833   HOWTO (R_ARM_THM_ALU_PREL_11_0,/* type */
 834          0,                     /* rightshift */
 835          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 836          13,                    /* bitsize */
 837          TRUE,                  /* pc_relative */
 838          0,                     /* bitpos */
 839          complain_overflow_dont,/* complain_on_overflow */
 840          bfd_elf_generic_reloc, /* special_function */
 841          "R_ARM_THM_ALU_PREL_11_0",/* name */
 842          FALSE,                 /* partial_inplace */
 843          0xffffffff,            /* src_mask */
 844          0xffffffff,            /* dst_mask */
 845          TRUE),                 /* pcrel_offset */
 846
 847   HOWTO (R_ARM_THM_PC12,        /* type */
 848          0,                     /* rightshift */
 849          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 850          13,                    /* bitsize */
 851          TRUE,                  /* pc_relative */
 852          0,                     /* bitpos */
 853          complain_overflow_dont,/* complain_on_overflow */
 854          bfd_elf_generic_reloc, /* special_function */
 855          "R_ARM_THM_PC12",      /* name */
 856          FALSE,                 /* partial_inplace */
 857          0xffffffff,            /* src_mask */
 858          0xffffffff,            /* dst_mask */
 859          TRUE),                 /* pcrel_offset */
 860
 861   HOWTO (R_ARM_ABS32_NOI,       /* type */
 862          0,                     /* rightshift */
 863          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 864          32,                    /* bitsize */
 865          FALSE,                 /* pc_relative */
 866          0,                     /* bitpos */
 867          complain_overflow_dont,/* complain_on_overflow */
 868          bfd_elf_generic_reloc, /* special_function */
 869          "R_ARM_ABS32_NOI",     /* name */
 870          FALSE,                 /* partial_inplace */
 871          0xffffffff,            /* src_mask */
 872          0xffffffff,            /* dst_mask */
 873          FALSE),                /* pcrel_offset */
 874
 875   HOWTO (R_ARM_REL32_NOI,       /* type */
 876          0,                     /* rightshift */
 877          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 878          32,                    /* bitsize */
 879          TRUE,                  /* pc_relative */
 880          0,                     /* bitpos */
 881          complain_overflow_dont,/* complain_on_overflow */
 882          bfd_elf_generic_reloc, /* special_function */
 883          "R_ARM_REL32_NOI",     /* name */
 884          FALSE,                 /* partial_inplace */
 885          0xffffffff,            /* src_mask */
 886          0xffffffff,            /* dst_mask */
 887          FALSE),                /* pcrel_offset */
 888
 889   /* Group relocations.  */
 890
 891   HOWTO (R_ARM_ALU_PC_G0_NC,    /* type */
 892          0,                     /* rightshift */
 893          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 894          32,                    /* bitsize */
 895          TRUE,                  /* pc_relative */
 896          0,                     /* bitpos */
 897          complain_overflow_dont,/* complain_on_overflow */
 898          bfd_elf_generic_reloc, /* special_function */
 899          "R_ARM_ALU_PC_G0_NC",  /* name */
 900          FALSE,                 /* partial_inplace */
 901          0xffffffff,            /* src_mask */
 902          0xffffffff,            /* dst_mask */
 903          TRUE),                 /* pcrel_offset */
 904
 905   HOWTO (R_ARM_ALU_PC_G0,       /* type */
 906          0,                     /* rightshift */
 907          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 908          32,                    /* bitsize */
 909          TRUE,                  /* pc_relative */
 910          0,                     /* bitpos */
 911          complain_overflow_dont,/* complain_on_overflow */
 912          bfd_elf_generic_reloc, /* special_function */
 913          "R_ARM_ALU_PC_G0",     /* name */
 914          FALSE,                 /* partial_inplace */
 915          0xffffffff,            /* src_mask */
 916          0xffffffff,            /* dst_mask */
 917          TRUE),                 /* pcrel_offset */
 918
 919   HOWTO (R_ARM_ALU_PC_G1_NC,    /* type */
 920          0,                     /* rightshift */
 921          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 922          32,                    /* bitsize */
 923          TRUE,                  /* pc_relative */
 924          0,                     /* bitpos */
 925          complain_overflow_dont,/* complain_on_overflow */
 926          bfd_elf_generic_reloc, /* special_function */
 927          "R_ARM_ALU_PC_G1_NC",  /* name */
 928          FALSE,                 /* partial_inplace */
 929          0xffffffff,            /* src_mask */
 930          0xffffffff,            /* dst_mask */
 931          TRUE),                 /* pcrel_offset */
 932
 933   HOWTO (R_ARM_ALU_PC_G1,       /* type */
 934          0,                     /* rightshift */
 935          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 936          32,                    /* bitsize */
 937          TRUE,                  /* pc_relative */
 938          0,                     /* bitpos */
 939          complain_overflow_dont,/* complain_on_overflow */
 940          bfd_elf_generic_reloc, /* special_function */
 941          "R_ARM_ALU_PC_G1",     /* name */
 942          FALSE,                 /* partial_inplace */
 943          0xffffffff,            /* src_mask */
 944          0xffffffff,            /* dst_mask */
 945          TRUE),                 /* pcrel_offset */
 946
 947   HOWTO (R_ARM_ALU_PC_G2,       /* type */
 948          0,                     /* rightshift */
 949          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 950          32,                    /* bitsize */
 951          TRUE,                  /* pc_relative */
 952          0,                     /* bitpos */
 953          complain_overflow_dont,/* complain_on_overflow */
 954          bfd_elf_generic_reloc, /* special_function */
 955          "R_ARM_ALU_PC_G2",     /* name */
 956          FALSE,                 /* partial_inplace */
 957          0xffffffff,            /* src_mask */
 958          0xffffffff,            /* dst_mask */
 959          TRUE),                 /* pcrel_offset */
 960
 961   HOWTO (R_ARM_LDR_PC_G1,       /* type */
 962          0,                     /* rightshift */
 963          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 964          32,                    /* bitsize */
 965          TRUE,                  /* pc_relative */
 966          0,                     /* bitpos */
 967          complain_overflow_dont,/* complain_on_overflow */
 968          bfd_elf_generic_reloc, /* special_function */
 969          "R_ARM_LDR_PC_G1",     /* name */
 970          FALSE,                 /* partial_inplace */
 971          0xffffffff,            /* src_mask */
 972          0xffffffff,            /* dst_mask */
 973          TRUE),                 /* pcrel_offset */
 974
 975   HOWTO (R_ARM_LDR_PC_G2,       /* type */
 976          0,                     /* rightshift */
 977          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 978          32,                    /* bitsize */
 979          TRUE,                  /* pc_relative */
 980          0,                     /* bitpos */
 981          complain_overflow_dont,/* complain_on_overflow */
 982          bfd_elf_generic_reloc, /* special_function */
 983          "R_ARM_LDR_PC_G2",     /* name */
 984          FALSE,                 /* partial_inplace */
 985          0xffffffff,            /* src_mask */
 986          0xffffffff,            /* dst_mask */
 987          TRUE),                 /* pcrel_offset */
 988
 989   HOWTO (R_ARM_LDRS_PC_G0,      /* type */
 990          0,                     /* rightshift */
 991          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 992          32,                    /* bitsize */
 993          TRUE,                  /* pc_relative */
 994          0,                     /* bitpos */
 995          complain_overflow_dont,/* complain_on_overflow */
 996          bfd_elf_generic_reloc, /* special_function */
 997          "R_ARM_LDRS_PC_G0",    /* name */
 998          FALSE,                 /* partial_inplace */
 999          0xffffffff,            /* src_mask */
1000          0xffffffff,            /* dst_mask */
1001          TRUE),                 /* pcrel_offset */
1002
1003   HOWTO (R_ARM_LDRS_PC_G1,      /* type */
1004          0,                     /* rightshift */
1005          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1006          32,                    /* bitsize */
1007          TRUE,                  /* pc_relative */
1008          0,                     /* bitpos */
1009          complain_overflow_dont,/* complain_on_overflow */
1010          bfd_elf_generic_reloc, /* special_function */
1011          "R_ARM_LDRS_PC_G1",    /* name */
1012          FALSE,                 /* partial_inplace */
1013          0xffffffff,            /* src_mask */
1014          0xffffffff,            /* dst_mask */
1015          TRUE),                 /* pcrel_offset */
1016
1017   HOWTO (R_ARM_LDRS_PC_G2,      /* type */
1018          0,                     /* rightshift */
1019          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1020          32,                    /* bitsize */
1021          TRUE,                  /* pc_relative */
1022          0,                     /* bitpos */
1023          complain_overflow_dont,/* complain_on_overflow */
1024          bfd_elf_generic_reloc, /* special_function */
1025          "R_ARM_LDRS_PC_G2",    /* name */
1026          FALSE,                 /* partial_inplace */
1027          0xffffffff,            /* src_mask */
1028          0xffffffff,            /* dst_mask */
1029          TRUE),                 /* pcrel_offset */
1030
1031   HOWTO (R_ARM_LDC_PC_G0,       /* type */
1032          0,                     /* rightshift */
1033          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1034          32,                    /* bitsize */
1035          TRUE,                  /* pc_relative */
1036          0,                     /* bitpos */
1037          complain_overflow_dont,/* complain_on_overflow */
1038          bfd_elf_generic_reloc, /* special_function */
1039          "R_ARM_LDC_PC_G0",     /* name */
1040          FALSE,                 /* partial_inplace */
1041          0xffffffff,            /* src_mask */
1042          0xffffffff,            /* dst_mask */
1043          TRUE),                 /* pcrel_offset */
1044
1045   HOWTO (R_ARM_LDC_PC_G1,       /* type */
1046          0,                     /* rightshift */
1047          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1048          32,                    /* bitsize */
1049          TRUE,                  /* pc_relative */
1050          0,                     /* bitpos */
1051          complain_overflow_dont,/* complain_on_overflow */
1052          bfd_elf_generic_reloc, /* special_function */
1053          "R_ARM_LDC_PC_G1",     /* name */
1054          FALSE,                 /* partial_inplace */
1055          0xffffffff,            /* src_mask */
1056          0xffffffff,            /* dst_mask */
1057          TRUE),                 /* pcrel_offset */
1058
1059   HOWTO (R_ARM_LDC_PC_G2,       /* type */
1060          0,                     /* rightshift */
1061          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1062          32,                    /* bitsize */
1063          TRUE,                  /* pc_relative */
1064          0,                     /* bitpos */
1065          complain_overflow_dont,/* complain_on_overflow */
1066          bfd_elf_generic_reloc, /* special_function */
1067          "R_ARM_LDC_PC_G2",     /* name */
1068          FALSE,                 /* partial_inplace */
1069          0xffffffff,            /* src_mask */
1070          0xffffffff,            /* dst_mask */
1071          TRUE),                 /* pcrel_offset */
1072
1073   HOWTO (R_ARM_ALU_SB_G0_NC,    /* type */
1074          0,                     /* rightshift */
1075          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1076          32,                    /* bitsize */
1077          TRUE,                  /* pc_relative */
1078          0,                     /* bitpos */
1079          complain_overflow_dont,/* complain_on_overflow */
1080          bfd_elf_generic_reloc, /* special_function */
1081          "R_ARM_ALU_SB_G0_NC",  /* name */
1082          FALSE,                 /* partial_inplace */
1083          0xffffffff,            /* src_mask */
1084          0xffffffff,            /* dst_mask */
1085          TRUE),                 /* pcrel_offset */
1086
1087   HOWTO (R_ARM_ALU_SB_G0,       /* type */
1088          0,                     /* rightshift */
1089          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1090          32,                    /* bitsize */
1091          TRUE,                  /* pc_relative */
1092          0,                     /* bitpos */
1093          complain_overflow_dont,/* complain_on_overflow */
1094          bfd_elf_generic_reloc, /* special_function */
1095          "R_ARM_ALU_SB_G0",     /* name */
1096          FALSE,                 /* partial_inplace */
1097          0xffffffff,            /* src_mask */
1098          0xffffffff,            /* dst_mask */
1099          TRUE),                 /* pcrel_offset */
1100
1101   HOWTO (R_ARM_ALU_SB_G1_NC,    /* type */
1102          0,                     /* rightshift */
1103          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1104          32,                    /* bitsize */
1105          TRUE,                  /* pc_relative */
1106          0,                     /* bitpos */
1107          complain_overflow_dont,/* complain_on_overflow */
1108          bfd_elf_generic_reloc, /* special_function */
1109          "R_ARM_ALU_SB_G1_NC",  /* name */
1110          FALSE,                 /* partial_inplace */
1111          0xffffffff,            /* src_mask */
1112          0xffffffff,            /* dst_mask */
1113          TRUE),                 /* pcrel_offset */
1114
1115   HOWTO (R_ARM_ALU_SB_G1,       /* type */
1116          0,                     /* rightshift */
1117          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1118          32,                    /* bitsize */
1119          TRUE,                  /* pc_relative */
1120          0,                     /* bitpos */
1121          complain_overflow_dont,/* complain_on_overflow */
1122          bfd_elf_generic_reloc, /* special_function */
1123          "R_ARM_ALU_SB_G1",     /* name */
1124          FALSE,                 /* partial_inplace */
1125          0xffffffff,            /* src_mask */
1126          0xffffffff,            /* dst_mask */
1127          TRUE),                 /* pcrel_offset */
1128
1129   HOWTO (R_ARM_ALU_SB_G2,       /* type */
1130          0,                     /* rightshift */
1131          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1132          32,                    /* bitsize */
1133          TRUE,                  /* pc_relative */
1134          0,                     /* bitpos */
1135          complain_overflow_dont,/* complain_on_overflow */
1136          bfd_elf_generic_reloc, /* special_function */
1137          "R_ARM_ALU_SB_G2",     /* name */
1138          FALSE,                 /* partial_inplace */
1139          0xffffffff,            /* src_mask */
1140          0xffffffff,            /* dst_mask */
1141          TRUE),                 /* pcrel_offset */
1142
1143   HOWTO (R_ARM_LDR_SB_G0,       /* type */
1144          0,                     /* rightshift */
1145          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1146          32,                    /* bitsize */
1147          TRUE,                  /* pc_relative */
1148          0,                     /* bitpos */
1149          complain_overflow_dont,/* complain_on_overflow */
1150          bfd_elf_generic_reloc, /* special_function */
1151          "R_ARM_LDR_SB_G0",     /* name */
1152          FALSE,                 /* partial_inplace */
1153          0xffffffff,            /* src_mask */
1154          0xffffffff,            /* dst_mask */
1155          TRUE),                 /* pcrel_offset */
1156
1157   HOWTO (R_ARM_LDR_SB_G1,       /* type */
1158          0,                     /* rightshift */
1159          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1160          32,                    /* bitsize */
1161          TRUE,                  /* pc_relative */
1162          0,                     /* bitpos */
1163          complain_overflow_dont,/* complain_on_overflow */
1164          bfd_elf_generic_reloc, /* special_function */
1165          "R_ARM_LDR_SB_G1",     /* name */
1166          FALSE,                 /* partial_inplace */
1167          0xffffffff,            /* src_mask */
1168          0xffffffff,            /* dst_mask */
1169          TRUE),                 /* pcrel_offset */
1170
1171   HOWTO (R_ARM_LDR_SB_G2,       /* type */
1172          0,                     /* rightshift */
1173          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1174          32,                    /* bitsize */
1175          TRUE,                  /* pc_relative */
1176          0,                     /* bitpos */
1177          complain_overflow_dont,/* complain_on_overflow */
1178          bfd_elf_generic_reloc, /* special_function */
1179          "R_ARM_LDR_SB_G2",     /* name */
1180          FALSE,                 /* partial_inplace */
1181          0xffffffff,            /* src_mask */
1182          0xffffffff,            /* dst_mask */
1183          TRUE),                 /* pcrel_offset */
1184
1185   HOWTO (R_ARM_LDRS_SB_G0,      /* type */
1186          0,                     /* rightshift */
1187          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1188          32,                    /* bitsize */
1189          TRUE,                  /* pc_relative */
1190          0,                     /* bitpos */
1191          complain_overflow_dont,/* complain_on_overflow */
1192          bfd_elf_generic_reloc, /* special_function */
1193          "R_ARM_LDRS_SB_G0",    /* name */
1194          FALSE,                 /* partial_inplace */
1195          0xffffffff,            /* src_mask */
1196          0xffffffff,            /* dst_mask */
1197          TRUE),                 /* pcrel_offset */
1198
1199   HOWTO (R_ARM_LDRS_SB_G1,      /* type */
1200          0,                     /* rightshift */
1201          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1202          32,                    /* bitsize */
1203          TRUE,                  /* pc_relative */
1204          0,                     /* bitpos */
1205          complain_overflow_dont,/* complain_on_overflow */
1206          bfd_elf_generic_reloc, /* special_function */
1207          "R_ARM_LDRS_SB_G1",    /* name */
1208          FALSE,                 /* partial_inplace */
1209          0xffffffff,            /* src_mask */
1210          0xffffffff,            /* dst_mask */
1211          TRUE),                 /* pcrel_offset */
1212
1213   HOWTO (R_ARM_LDRS_SB_G2,      /* type */
1214          0,                     /* rightshift */
1215          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1216          32,                    /* bitsize */
1217          TRUE,                  /* pc_relative */
1218          0,                     /* bitpos */
1219          complain_overflow_dont,/* complain_on_overflow */
1220          bfd_elf_generic_reloc, /* special_function */
1221          "R_ARM_LDRS_SB_G2",    /* name */
1222          FALSE,                 /* partial_inplace */
1223          0xffffffff,            /* src_mask */
1224          0xffffffff,            /* dst_mask */
1225          TRUE),                 /* pcrel_offset */
1226
1227   HOWTO (R_ARM_LDC_SB_G0,       /* type */
1228          0,                     /* rightshift */
1229          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1230          32,                    /* bitsize */
1231          TRUE,                  /* pc_relative */
1232          0,                     /* bitpos */
1233          complain_overflow_dont,/* complain_on_overflow */
1234          bfd_elf_generic_reloc, /* special_function */
1235          "R_ARM_LDC_SB_G0",     /* name */
1236          FALSE,                 /* partial_inplace */
1237          0xffffffff,            /* src_mask */
1238          0xffffffff,            /* dst_mask */
1239          TRUE),                 /* pcrel_offset */
1240
1241   HOWTO (R_ARM_LDC_SB_G1,       /* type */
1242          0,                     /* rightshift */
1243          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1244          32,                    /* bitsize */
1245          TRUE,                  /* pc_relative */
1246          0,                     /* bitpos */
1247          complain_overflow_dont,/* complain_on_overflow */
1248          bfd_elf_generic_reloc, /* special_function */
1249          "R_ARM_LDC_SB_G1",     /* name */
1250          FALSE,                 /* partial_inplace */
1251          0xffffffff,            /* src_mask */
1252          0xffffffff,            /* dst_mask */
1253          TRUE),                 /* pcrel_offset */
1254
1255   HOWTO (R_ARM_LDC_SB_G2,       /* type */
1256          0,                     /* rightshift */
1257          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1258          32,                    /* bitsize */
1259          TRUE,                  /* pc_relative */
1260          0,                     /* bitpos */
1261          complain_overflow_dont,/* complain_on_overflow */
1262          bfd_elf_generic_reloc, /* special_function */
1263          "R_ARM_LDC_SB_G2",     /* name */
1264          FALSE,                 /* partial_inplace */
1265          0xffffffff,            /* src_mask */
1266          0xffffffff,            /* dst_mask */
1267          TRUE),                 /* pcrel_offset */
1268
1269   /* End of group relocations.  */
1270
1271   HOWTO (R_ARM_MOVW_BREL_NC,    /* type */
1272          0,                     /* rightshift */
1273          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1274          16,                    /* bitsize */
1275          FALSE,                 /* pc_relative */
1276          0,                     /* bitpos */
1277          complain_overflow_dont,/* complain_on_overflow */
1278          bfd_elf_generic_reloc, /* special_function */
1279          "R_ARM_MOVW_BREL_NC",  /* name */
1280          FALSE,                 /* partial_inplace */
1281          0x0000ffff,            /* src_mask */
1282          0x0000ffff,            /* dst_mask */
1283          FALSE),                /* pcrel_offset */
1284
1285   HOWTO (R_ARM_MOVT_BREL,       /* type */
1286          0,                     /* rightshift */
1287          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1288          16,                    /* bitsize */
1289          FALSE,                 /* pc_relative */
1290          0,                     /* bitpos */
1291          complain_overflow_bitfield,/* complain_on_overflow */
1292          bfd_elf_generic_reloc, /* special_function */
1293          "R_ARM_MOVT_BREL",     /* name */
1294          FALSE,                 /* partial_inplace */
1295          0x0000ffff,            /* src_mask */
1296          0x0000ffff,            /* dst_mask */
1297          FALSE),                /* pcrel_offset */
1298
1299   HOWTO (R_ARM_MOVW_BREL,       /* type */
1300          0,                     /* rightshift */
1301          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1302          16,                    /* bitsize */
1303          FALSE,                 /* pc_relative */
1304          0,                     /* bitpos */
1305          complain_overflow_dont,/* complain_on_overflow */
1306          bfd_elf_generic_reloc, /* special_function */
1307          "R_ARM_MOVW_BREL",     /* name */
1308          FALSE,                 /* partial_inplace */
1309          0x0000ffff,            /* src_mask */
1310          0x0000ffff,            /* dst_mask */
1311          FALSE),                /* pcrel_offset */
1312
1313   HOWTO (R_ARM_THM_MOVW_BREL_NC,/* type */
1314          0,                     /* rightshift */
1315          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1316          16,                    /* bitsize */
1317          FALSE,                 /* pc_relative */
1318          0,                     /* bitpos */
1319          complain_overflow_dont,/* complain_on_overflow */
1320          bfd_elf_generic_reloc, /* special_function */
1321          "R_ARM_THM_MOVW_BREL_NC",/* name */
1322          FALSE,                 /* partial_inplace */
1323          0x040f70ff,            /* src_mask */
1324          0x040f70ff,            /* dst_mask */
1325          FALSE),                /* pcrel_offset */
1326
1327   HOWTO (R_ARM_THM_MOVT_BREL,   /* type */
1328          0,                     /* rightshift */
1329          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1330          16,                    /* bitsize */
1331          FALSE,                 /* pc_relative */
1332          0,                     /* bitpos */
1333          complain_overflow_bitfield,/* complain_on_overflow */
1334          bfd_elf_generic_reloc, /* special_function */
1335          "R_ARM_THM_MOVT_BREL", /* name */
1336          FALSE,                 /* partial_inplace */
1337          0x040f70ff,            /* src_mask */
1338          0x040f70ff,            /* dst_mask */
1339          FALSE),                /* pcrel_offset */
1340
1341   HOWTO (R_ARM_THM_MOVW_BREL,   /* type */
1342          0,                     /* rightshift */
1343          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1344          16,                    /* bitsize */
1345          FALSE,                 /* pc_relative */
1346          0,                     /* bitpos */
1347          complain_overflow_dont,/* complain_on_overflow */
1348          bfd_elf_generic_reloc, /* special_function */
1349          "R_ARM_THM_MOVW_BREL", /* name */
1350          FALSE,                 /* partial_inplace */
1351          0x040f70ff,            /* src_mask */
1352          0x040f70ff,            /* dst_mask */
1353          FALSE),                /* pcrel_offset */
1354
1355   EMPTY_HOWTO (90),   /* Unallocated.  */
1356   EMPTY_HOWTO (91),
1357   EMPTY_HOWTO (92),
1358   EMPTY_HOWTO (93),
1359
1360   HOWTO (R_ARM_PLT32_ABS,       /* type */
1361          0,                     /* rightshift */
1362          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1363          32,                    /* bitsize */
1364          FALSE,                 /* pc_relative */
1365          0,                     /* bitpos */
1366          complain_overflow_dont,/* complain_on_overflow */
1367          bfd_elf_generic_reloc, /* special_function */
1368          "R_ARM_PLT32_ABS",     /* name */
1369          FALSE,                 /* partial_inplace */
1370          0xffffffff,            /* src_mask */
1371          0xffffffff,            /* dst_mask */
1372          FALSE),                /* pcrel_offset */
1373
1374   HOWTO (R_ARM_GOT_ABS,         /* type */
1375          0,                     /* rightshift */
1376          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1377          32,                    /* bitsize */
1378          FALSE,                 /* pc_relative */
1379          0,                     /* bitpos */
1380          complain_overflow_dont,/* complain_on_overflow */
1381          bfd_elf_generic_reloc, /* special_function */
1382          "R_ARM_GOT_ABS",       /* name */
1383          FALSE,                 /* partial_inplace */
1384          0xffffffff,            /* src_mask */
1385          0xffffffff,            /* dst_mask */
1386          FALSE),                        /* pcrel_offset */
1387
1388   HOWTO (R_ARM_GOT_PREL,        /* type */
1389          0,                     /* rightshift */
1390          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1391          32,                    /* bitsize */
1392          TRUE,                  /* pc_relative */
1393          0,                     /* bitpos */
1394          complain_overflow_dont,        /* complain_on_overflow */
1395          bfd_elf_generic_reloc, /* special_function */
1396          "R_ARM_GOT_PREL",      /* name */
1397          FALSE,                 /* partial_inplace */
1398          0xffffffff,            /* src_mask */
1399          0xffffffff,            /* dst_mask */
1400          TRUE),                 /* pcrel_offset */
1401
1402   HOWTO (R_ARM_GOT_BREL12,      /* type */
1403          0,                     /* rightshift */
1404          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1405          12,                    /* bitsize */
1406          FALSE,                 /* pc_relative */
1407          0,                     /* bitpos */
1408          complain_overflow_bitfield,/* complain_on_overflow */
1409          bfd_elf_generic_reloc, /* special_function */
1410          "R_ARM_GOT_BREL12",    /* name */
1411          FALSE,                 /* partial_inplace */
1412          0x00000fff,            /* src_mask */
1413          0x00000fff,            /* dst_mask */
1414          FALSE),                /* pcrel_offset */
1415
1416   HOWTO (R_ARM_GOTOFF12,        /* type */
1417          0,                     /* rightshift */
1418          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1419          12,                    /* bitsize */
1420          FALSE,                 /* pc_relative */
1421          0,                     /* bitpos */
1422          complain_overflow_bitfield,/* complain_on_overflow */
1423          bfd_elf_generic_reloc, /* special_function */
1424          "R_ARM_GOTOFF12",      /* name */
1425          FALSE,                 /* partial_inplace */
1426          0x00000fff,            /* src_mask */
1427          0x00000fff,            /* dst_mask */
1428          FALSE),                /* pcrel_offset */
1429
1430   EMPTY_HOWTO (R_ARM_GOTRELAX),  /* reserved for future GOT-load optimizations */
1431
1432   /* GNU extension to record C++ vtable member usage */
1433   HOWTO (R_ARM_GNU_VTENTRY,     /* type */
1434          0,                     /* rightshift */
1435          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1436          0,                     /* bitsize */
1437          FALSE,                 /* pc_relative */
1438          0,                     /* bitpos */
1439          complain_overflow_dont, /* complain_on_overflow */
1440          _bfd_elf_rel_vtable_reloc_fn,  /* special_function */
1441          "R_ARM_GNU_VTENTRY",   /* name */
1442          FALSE,                 /* partial_inplace */
1443          0,                     /* src_mask */
1444          0,                     /* dst_mask */
1445          FALSE),                /* pcrel_offset */
1446
1447   /* GNU extension to record C++ vtable hierarchy */
1448   HOWTO (R_ARM_GNU_VTINHERIT, /* type */
1449          0,                     /* rightshift */
1450          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1451          0,                     /* bitsize */
1452          FALSE,                 /* pc_relative */
1453          0,                     /* bitpos */
1454          complain_overflow_dont, /* complain_on_overflow */
1455          NULL,                  /* special_function */
1456          "R_ARM_GNU_VTINHERIT", /* name */
1457          FALSE,                 /* partial_inplace */
1458          0,                     /* src_mask */
1459          0,                     /* dst_mask */
1460          FALSE),                /* pcrel_offset */
1461
1462   HOWTO (R_ARM_THM_JUMP11,      /* type */
1463          1,                     /* rightshift */
1464          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1465          11,                    /* bitsize */
1466          TRUE,                  /* pc_relative */
1467          0,                     /* bitpos */
1468          complain_overflow_signed,      /* complain_on_overflow */
1469          bfd_elf_generic_reloc, /* special_function */
1470          "R_ARM_THM_JUMP11",    /* name */
1471          FALSE,                 /* partial_inplace */
1472          0x000007ff,            /* src_mask */
1473          0x000007ff,            /* dst_mask */
1474          TRUE),                 /* pcrel_offset */
1475
1476   HOWTO (R_ARM_THM_JUMP8,       /* type */
1477          1,                     /* rightshift */
1478          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1479          8,                     /* bitsize */
1480          TRUE,                  /* pc_relative */
1481          0,                     /* bitpos */
1482          complain_overflow_signed,      /* complain_on_overflow */
1483          bfd_elf_generic_reloc, /* special_function */
1484          "R_ARM_THM_JUMP8",     /* name */
1485          FALSE,                 /* partial_inplace */
1486          0x000000ff,            /* src_mask */
1487          0x000000ff,            /* dst_mask */
1488          TRUE),                 /* pcrel_offset */
1489
1490   /* TLS relocations */
1491   HOWTO (R_ARM_TLS_GD32,        /* type */
1492          0,                     /* rightshift */
1493          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1494          32,                    /* bitsize */
1495          FALSE,                 /* pc_relative */
1496          0,                     /* bitpos */
1497          complain_overflow_bitfield,/* complain_on_overflow */
1498          NULL,                  /* special_function */
1499          "R_ARM_TLS_GD32",      /* name */
1500          TRUE,                  /* partial_inplace */
1501          0xffffffff,            /* src_mask */
1502          0xffffffff,            /* dst_mask */
1503          FALSE),                /* pcrel_offset */
1504
1505   HOWTO (R_ARM_TLS_LDM32,       /* type */
1506          0,                     /* rightshift */
1507          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1508          32,                    /* bitsize */
1509          FALSE,                 /* pc_relative */
1510          0,                     /* bitpos */
1511          complain_overflow_bitfield,/* complain_on_overflow */
1512          bfd_elf_generic_reloc, /* special_function */
1513          "R_ARM_TLS_LDM32",     /* name */
1514          TRUE,                  /* partial_inplace */
1515          0xffffffff,            /* src_mask */
1516          0xffffffff,            /* dst_mask */
1517          FALSE),                /* pcrel_offset */
1518
1519   HOWTO (R_ARM_TLS_LDO32,       /* type */
1520          0,                     /* rightshift */
1521          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1522          32,                    /* bitsize */
1523          FALSE,                 /* pc_relative */
1524          0,                     /* bitpos */
1525          complain_overflow_bitfield,/* complain_on_overflow */
1526          bfd_elf_generic_reloc, /* special_function */
1527          "R_ARM_TLS_LDO32",     /* name */
1528          TRUE,                  /* partial_inplace */
1529          0xffffffff,            /* src_mask */
1530          0xffffffff,            /* dst_mask */
1531          FALSE),                /* pcrel_offset */
1532
1533   HOWTO (R_ARM_TLS_IE32,        /* type */
1534          0,                     /* rightshift */
1535          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1536          32,                    /* bitsize */
1537          FALSE,                  /* pc_relative */
1538          0,                     /* bitpos */
1539          complain_overflow_bitfield,/* complain_on_overflow */
1540          NULL,                  /* special_function */
1541          "R_ARM_TLS_IE32",      /* name */
1542          TRUE,                  /* partial_inplace */
1543          0xffffffff,            /* src_mask */
1544          0xffffffff,            /* dst_mask */
1545          FALSE),                /* pcrel_offset */
1546
1547   HOWTO (R_ARM_TLS_LE32,        /* type */
1548          0,                     /* rightshift */
1549          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1550          32,                    /* bitsize */
1551          FALSE,                 /* pc_relative */
1552          0,                     /* bitpos */
1553          complain_overflow_bitfield,/* complain_on_overflow */
1554          bfd_elf_generic_reloc, /* special_function */
1555          "R_ARM_TLS_LE32",      /* name */
1556          TRUE,                  /* partial_inplace */
1557          0xffffffff,            /* src_mask */
1558          0xffffffff,            /* dst_mask */
1559          FALSE),                /* pcrel_offset */
1560
1561   HOWTO (R_ARM_TLS_LDO12,       /* type */
1562          0,                     /* rightshift */
1563          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1564          12,                    /* bitsize */
1565          FALSE,                 /* pc_relative */
1566          0,                     /* bitpos */
1567          complain_overflow_bitfield,/* complain_on_overflow */
1568          bfd_elf_generic_reloc, /* special_function */
1569          "R_ARM_TLS_LDO12",     /* name */
1570          FALSE,                 /* partial_inplace */
1571          0x00000fff,            /* src_mask */
1572          0x00000fff,            /* dst_mask */
1573          FALSE),                /* pcrel_offset */
1574
1575   HOWTO (R_ARM_TLS_LE12,        /* type */
1576          0,                     /* rightshift */
1577          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1578          12,                    /* bitsize */
1579          FALSE,                 /* pc_relative */
1580          0,                     /* bitpos */
1581          complain_overflow_bitfield,/* complain_on_overflow */
1582          bfd_elf_generic_reloc, /* special_function */
1583          "R_ARM_TLS_LE12",      /* name */
1584          FALSE,                 /* partial_inplace */
1585          0x00000fff,            /* src_mask */
1586          0x00000fff,            /* dst_mask */
1587          FALSE),                /* pcrel_offset */
1588
1589   HOWTO (R_ARM_TLS_IE12GP,      /* type */
1590          0,                     /* rightshift */
1591          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1592          12,                    /* bitsize */
1593          FALSE,                 /* pc_relative */
1594          0,                     /* bitpos */
1595          complain_overflow_bitfield,/* complain_on_overflow */
1596          bfd_elf_generic_reloc, /* special_function */
1597          "R_ARM_TLS_IE12GP",    /* name */
1598          FALSE,                 /* partial_inplace */
1599          0x00000fff,            /* src_mask */
1600          0x00000fff,            /* dst_mask */
1601          FALSE),                /* pcrel_offset */
1602 };
1603
1604 /* 112-127 private relocations
1605    128 R_ARM_ME_TOO, obsolete
1606    129-255 unallocated in AAELF.
1607
1608    249-255 extended, currently unused, relocations:  */
1609
1610 static reloc_howto_type elf32_arm_howto_table_2[4] =
1611 {
1612   HOWTO (R_ARM_RREL32,          /* type */
1613          0,                     /* rightshift */
1614          0,                     /* size (0 = byte, 1 = short, 2 = long) */
1615          0,                     /* bitsize */
1616          FALSE,                 /* pc_relative */
1617          0,                     /* bitpos */
1618          complain_overflow_dont,/* complain_on_overflow */
1619          bfd_elf_generic_reloc, /* special_function */
1620          "R_ARM_RREL32",        /* name */
1621          FALSE,                 /* partial_inplace */
1622          0,                     /* src_mask */
1623          0,                     /* dst_mask */
1624          FALSE),                /* pcrel_offset */
1625
1626   HOWTO (R_ARM_RABS32,          /* type */
1627          0,                     /* rightshift */
1628          0,                     /* size (0 = byte, 1 = short, 2 = long) */
1629          0,                     /* bitsize */
1630          FALSE,                 /* pc_relative */
1631          0,                     /* bitpos */
1632          complain_overflow_dont,/* complain_on_overflow */
1633          bfd_elf_generic_reloc, /* special_function */
1634          "R_ARM_RABS32",        /* name */
1635          FALSE,                 /* partial_inplace */
1636          0,                     /* src_mask */
1637          0,                     /* dst_mask */
1638          FALSE),                /* pcrel_offset */
1639
1640   HOWTO (R_ARM_RPC24,           /* type */
1641          0,                     /* rightshift */
1642          0,                     /* size (0 = byte, 1 = short, 2 = long) */
1643          0,                     /* bitsize */
1644          FALSE,                 /* pc_relative */
1645          0,                     /* bitpos */
1646          complain_overflow_dont,/* complain_on_overflow */
1647          bfd_elf_generic_reloc, /* special_function */
1648          "R_ARM_RPC24",         /* name */
1649          FALSE,                 /* partial_inplace */
1650          0,                     /* src_mask */
1651          0,                     /* dst_mask */
1652          FALSE),                /* pcrel_offset */
1653
1654   HOWTO (R_ARM_RBASE,           /* type */
1655          0,                     /* rightshift */
1656          0,                     /* size (0 = byte, 1 = short, 2 = long) */
1657          0,                     /* bitsize */
1658          FALSE,                 /* pc_relative */
1659          0,                     /* bitpos */
1660          complain_overflow_dont,/* complain_on_overflow */
1661          bfd_elf_generic_reloc, /* special_function */
1662          "R_ARM_RBASE",         /* name */
1663          FALSE,                 /* partial_inplace */
1664          0,                     /* src_mask */
1665          0,                     /* dst_mask */
1666          FALSE)                 /* pcrel_offset */
1667 };
1668
1669 static reloc_howto_type *
1670 elf32_arm_howto_from_type (unsigned int r_type)
1671 {
1672   if (r_type < ARRAY_SIZE (elf32_arm_howto_table_1))
1673     return &elf32_arm_howto_table_1[r_type];
1674
1675   if (r_type >= R_ARM_RREL32
1676       && r_type < R_ARM_RREL32 + ARRAY_SIZE (elf32_arm_howto_table_2))
1677     return &elf32_arm_howto_table_2[r_type - R_ARM_RREL32];
1678
1679   return NULL;
1680 }
1681
1682 static void
1683 elf32_arm_info_to_howto (bfd * abfd ATTRIBUTE_UNUSED, arelent * bfd_reloc,
1684                          Elf_Internal_Rela * elf_reloc)
1685 {
1686   unsigned int r_type;
1687
1688   r_type = ELF32_R_TYPE (elf_reloc->r_info);
1689   bfd_reloc->howto = elf32_arm_howto_from_type (r_type);
1690 }
1691
1692 struct elf32_arm_reloc_map
1693   {
1694     bfd_reloc_code_real_type  bfd_reloc_val;
1695     unsigned char             elf_reloc_val;
1696   };
1697
1698 /* All entries in this list must also be present in elf32_arm_howto_table.  */
1699 static const struct elf32_arm_reloc_map elf32_arm_reloc_map[] =
1700   {
1701     {BFD_RELOC_NONE,                 R_ARM_NONE},
1702     {BFD_RELOC_ARM_PCREL_BRANCH,     R_ARM_PC24},
1703     {BFD_RELOC_ARM_PCREL_CALL,       R_ARM_CALL},
1704     {BFD_RELOC_ARM_PCREL_JUMP,       R_ARM_JUMP24},
1705     {BFD_RELOC_ARM_PCREL_BLX,        R_ARM_XPC25},
1706     {BFD_RELOC_THUMB_PCREL_BLX,      R_ARM_THM_XPC22},
1707     {BFD_RELOC_32,                   R_ARM_ABS32},
1708     {BFD_RELOC_32_PCREL,             R_ARM_REL32},
1709     {BFD_RELOC_8,                    R_ARM_ABS8},
1710     {BFD_RELOC_16,                   R_ARM_ABS16},
1711     {BFD_RELOC_ARM_OFFSET_IMM,       R_ARM_ABS12},
1712     {BFD_RELOC_ARM_THUMB_OFFSET,     R_ARM_THM_ABS5},
1713     {BFD_RELOC_THUMB_PCREL_BRANCH25, R_ARM_THM_JUMP24},
1714     {BFD_RELOC_THUMB_PCREL_BRANCH23, R_ARM_THM_CALL},
1715     {BFD_RELOC_THUMB_PCREL_BRANCH12, R_ARM_THM_JUMP11},
1716     {BFD_RELOC_THUMB_PCREL_BRANCH20, R_ARM_THM_JUMP19},
1717     {BFD_RELOC_THUMB_PCREL_BRANCH9,  R_ARM_THM_JUMP8},
1718     {BFD_RELOC_THUMB_PCREL_BRANCH7,  R_ARM_THM_JUMP6},
1719     {BFD_RELOC_ARM_GLOB_DAT,         R_ARM_GLOB_DAT},
1720     {BFD_RELOC_ARM_JUMP_SLOT,        R_ARM_JUMP_SLOT},
1721     {BFD_RELOC_ARM_RELATIVE,         R_ARM_RELATIVE},
1722     {BFD_RELOC_ARM_GOTOFF,           R_ARM_GOTOFF32},
1723     {BFD_RELOC_ARM_GOTPC,            R_ARM_GOTPC},
1724     {BFD_RELOC_ARM_GOT32,            R_ARM_GOT32},
1725     {BFD_RELOC_ARM_PLT32,            R_ARM_PLT32},
1726     {BFD_RELOC_ARM_TARGET1,          R_ARM_TARGET1},
1727     {BFD_RELOC_ARM_ROSEGREL32,       R_ARM_ROSEGREL32},
1728     {BFD_RELOC_ARM_SBREL32,          R_ARM_SBREL32},
1729     {BFD_RELOC_ARM_PREL31,           R_ARM_PREL31},
1730     {BFD_RELOC_ARM_TARGET2,          R_ARM_TARGET2},
1731     {BFD_RELOC_ARM_PLT32,            R_ARM_PLT32},
1732     {BFD_RELOC_ARM_TLS_GD32,         R_ARM_TLS_GD32},
1733     {BFD_RELOC_ARM_TLS_LDO32,        R_ARM_TLS_LDO32},
1734     {BFD_RELOC_ARM_TLS_LDM32,        R_ARM_TLS_LDM32},
1735     {BFD_RELOC_ARM_TLS_DTPMOD32,     R_ARM_TLS_DTPMOD32},
1736     {BFD_RELOC_ARM_TLS_DTPOFF32,     R_ARM_TLS_DTPOFF32},
1737     {BFD_RELOC_ARM_TLS_TPOFF32,      R_ARM_TLS_TPOFF32},
1738     {BFD_RELOC_ARM_TLS_IE32,         R_ARM_TLS_IE32},
1739     {BFD_RELOC_ARM_TLS_LE32,         R_ARM_TLS_LE32},
1740     {BFD_RELOC_VTABLE_INHERIT,       R_ARM_GNU_VTINHERIT},
1741     {BFD_RELOC_VTABLE_ENTRY,         R_ARM_GNU_VTENTRY},
1742     {BFD_RELOC_ARM_MOVW,             R_ARM_MOVW_ABS_NC},
1743     {BFD_RELOC_ARM_MOVT,             R_ARM_MOVT_ABS},
1744     {BFD_RELOC_ARM_MOVW_PCREL,       R_ARM_MOVW_PREL_NC},
1745     {BFD_RELOC_ARM_MOVT_PCREL,       R_ARM_MOVT_PREL},
1746     {BFD_RELOC_ARM_THUMB_MOVW,       R_ARM_THM_MOVW_ABS_NC},
1747     {BFD_RELOC_ARM_THUMB_MOVT,       R_ARM_THM_MOVT_ABS},
1748     {BFD_RELOC_ARM_THUMB_MOVW_PCREL, R_ARM_THM_MOVW_PREL_NC},
1749     {BFD_RELOC_ARM_THUMB_MOVT_PCREL, R_ARM_THM_MOVT_PREL},
1750     {BFD_RELOC_ARM_ALU_PC_G0_NC, R_ARM_ALU_PC_G0_NC},
1751     {BFD_RELOC_ARM_ALU_PC_G0, R_ARM_ALU_PC_G0},
1752     {BFD_RELOC_ARM_ALU_PC_G1_NC, R_ARM_ALU_PC_G1_NC},
1753     {BFD_RELOC_ARM_ALU_PC_G1, R_ARM_ALU_PC_G1},
1754     {BFD_RELOC_ARM_ALU_PC_G2, R_ARM_ALU_PC_G2},
1755     {BFD_RELOC_ARM_LDR_PC_G0, R_ARM_LDR_PC_G0},
1756     {BFD_RELOC_ARM_LDR_PC_G1, R_ARM_LDR_PC_G1},
1757     {BFD_RELOC_ARM_LDR_PC_G2, R_ARM_LDR_PC_G2},
1758     {BFD_RELOC_ARM_LDRS_PC_G0, R_ARM_LDRS_PC_G0},
1759     {BFD_RELOC_ARM_LDRS_PC_G1, R_ARM_LDRS_PC_G1},
1760     {BFD_RELOC_ARM_LDRS_PC_G2, R_ARM_LDRS_PC_G2},
1761     {BFD_RELOC_ARM_LDC_PC_G0, R_ARM_LDC_PC_G0},
1762     {BFD_RELOC_ARM_LDC_PC_G1, R_ARM_LDC_PC_G1},
1763     {BFD_RELOC_ARM_LDC_PC_G2, R_ARM_LDC_PC_G2},
1764     {BFD_RELOC_ARM_ALU_SB_G0_NC, R_ARM_ALU_SB_G0_NC},
1765     {BFD_RELOC_ARM_ALU_SB_G0, R_ARM_ALU_SB_G0},
1766     {BFD_RELOC_ARM_ALU_SB_G1_NC, R_ARM_ALU_SB_G1_NC},
1767     {BFD_RELOC_ARM_ALU_SB_G1, R_ARM_ALU_SB_G1},
1768     {BFD_RELOC_ARM_ALU_SB_G2, R_ARM_ALU_SB_G2},
1769     {BFD_RELOC_ARM_LDR_SB_G0, R_ARM_LDR_SB_G0},
1770     {BFD_RELOC_ARM_LDR_SB_G1, R_ARM_LDR_SB_G1},
1771     {BFD_RELOC_ARM_LDR_SB_G2, R_ARM_LDR_SB_G2},
1772     {BFD_RELOC_ARM_LDRS_SB_G0, R_ARM_LDRS_SB_G0},
1773     {BFD_RELOC_ARM_LDRS_SB_G1, R_ARM_LDRS_SB_G1},
1774     {BFD_RELOC_ARM_LDRS_SB_G2, R_ARM_LDRS_SB_G2},
1775     {BFD_RELOC_ARM_LDC_SB_G0, R_ARM_LDC_SB_G0},
1776     {BFD_RELOC_ARM_LDC_SB_G1, R_ARM_LDC_SB_G1},
1777     {BFD_RELOC_ARM_LDC_SB_G2, R_ARM_LDC_SB_G2},
1778     {BFD_RELOC_ARM_V4BX,             R_ARM_V4BX}
1779   };
1780
1781 static reloc_howto_type *
1782 elf32_arm_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1783                              bfd_reloc_code_real_type code)
1784 {
1785   unsigned int i;
1786
1787   for (i = 0; i < ARRAY_SIZE (elf32_arm_reloc_map); i ++)
1788     if (elf32_arm_reloc_map[i].bfd_reloc_val == code)
1789       return elf32_arm_howto_from_type (elf32_arm_reloc_map[i].elf_reloc_val);
1790
1791   return NULL;
1792 }
1793
1794 static reloc_howto_type *
1795 elf32_arm_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1796                              const char *r_name)
1797 {
1798   unsigned int i;
1799
1800   for (i = 0; i < ARRAY_SIZE (elf32_arm_howto_table_1); i++)
1801     if (elf32_arm_howto_table_1[i].name != NULL
1802         && strcasecmp (elf32_arm_howto_table_1[i].name, r_name) == 0)
1803       return &elf32_arm_howto_table_1[i];
1804
1805   for (i = 0; i < ARRAY_SIZE (elf32_arm_howto_table_2); i++)
1806     if (elf32_arm_howto_table_2[i].name != NULL
1807         && strcasecmp (elf32_arm_howto_table_2[i].name, r_name) == 0)
1808       return &elf32_arm_howto_table_2[i];
1809
1810   return NULL;
1811 }
1812
1813 /* Support for core dump NOTE sections.  */
1814
1815 static bfd_boolean
1816 elf32_arm_nabi_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
1817 {
1818   int offset;
1819   size_t size;
1820
1821   switch (note->descsz)
1822     {
1823       default:
1824         return FALSE;
1825
1826       case 148:         /* Linux/ARM 32-bit.  */
1827         /* pr_cursig */
1828         elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
1829
1830         /* pr_pid */
1831         elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
1832
1833         /* pr_reg */
1834         offset = 72;
1835         size = 72;
1836
1837         break;
1838     }
1839
1840   /* Make a ".reg/999" section.  */
1841   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
1842                                           size, note->descpos + offset);
1843 }
1844
1845 static bfd_boolean
1846 elf32_arm_nabi_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
1847 {
1848   switch (note->descsz)
1849     {
1850       default:
1851         return FALSE;
1852
1853       case 124:         /* Linux/ARM elf_prpsinfo.  */
1854         elf_tdata (abfd)->core_program
1855          = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
1856         elf_tdata (abfd)->core_command
1857          = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
1858     }
1859
1860   /* Note that for some reason, a spurious space is tacked
1861      onto the end of the args in some (at least one anyway)
1862      implementations, so strip it off if it exists.  */
1863   {
1864     char *command = elf_tdata (abfd)->core_command;
1865     int n = strlen (command);
1866
1867     if (0 < n && command[n - 1] == ' ')
1868       command[n - 1] = '\0';
1869   }
1870
1871   return TRUE;
1872 }
1873
1874 #define TARGET_LITTLE_SYM               bfd_elf32_littlearm_vec
1875 #define TARGET_LITTLE_NAME              "elf32-littlearm"
1876 #define TARGET_BIG_SYM                  bfd_elf32_bigarm_vec
1877 #define TARGET_BIG_NAME                 "elf32-bigarm"
1878
1879 #define elf_backend_grok_prstatus       elf32_arm_nabi_grok_prstatus
1880 #define elf_backend_grok_psinfo         elf32_arm_nabi_grok_psinfo
1881
1882 typedef unsigned long int insn32;
1883 typedef unsigned short int insn16;
1884
1885 /* In lieu of proper flags, assume all EABIv4 or later objects are
1886    interworkable.  */
1887 #define INTERWORK_FLAG(abfd)  \
1888   (EF_ARM_EABI_VERSION (elf_elfheader (abfd)->e_flags) >= EF_ARM_EABI_VER4 \
1889   || (elf_elfheader (abfd)->e_flags & EF_ARM_INTERWORK) \
1890   || ((abfd)->flags & BFD_LINKER_CREATED))
1891
1892 /* The linker script knows the section names for placement.
1893    The entry_names are used to do simple name mangling on the stubs.
1894    Given a function name, and its type, the stub can be found. The
1895    name can be changed. The only requirement is the %s be present.  */
1896 #define THUMB2ARM_GLUE_SECTION_NAME ".glue_7t"
1897 #define THUMB2ARM_GLUE_ENTRY_NAME   "__%s_from_thumb"
1898
1899 #define ARM2THUMB_GLUE_SECTION_NAME ".glue_7"
1900 #define ARM2THUMB_GLUE_ENTRY_NAME   "__%s_from_arm"
1901
1902 #define VFP11_ERRATUM_VENEER_SECTION_NAME ".vfp11_veneer"
1903 #define VFP11_ERRATUM_VENEER_ENTRY_NAME   "__vfp11_veneer_%x"
1904
1905 #define ARM_BX_GLUE_SECTION_NAME ".v4_bx"
1906 #define ARM_BX_GLUE_ENTRY_NAME   "__bx_r%d"
1907
1908 #define STUB_ENTRY_NAME   "__%s_veneer"
1909
1910 /* The name of the dynamic interpreter.  This is put in the .interp
1911    section.  */
1912 #define ELF_DYNAMIC_INTERPRETER     "/usr/lib/ld.so.1"
1913
1914 #ifdef FOUR_WORD_PLT
1915
1916 /* The first entry in a procedure linkage table looks like
1917    this.  It is set up so that any shared library function that is
1918    called before the relocation has been set up calls the dynamic
1919    linker first.  */
1920 static const bfd_vma elf32_arm_plt0_entry [] =
1921   {
1922     0xe52de004,         /* str   lr, [sp, #-4]! */
1923     0xe59fe010,         /* ldr   lr, [pc, #16]  */
1924     0xe08fe00e,         /* add   lr, pc, lr     */
1925     0xe5bef008,         /* ldr   pc, [lr, #8]!  */
1926   };
1927
1928 /* Subsequent entries in a procedure linkage table look like
1929    this.  */
1930 static const bfd_vma elf32_arm_plt_entry [] =
1931   {
1932     0xe28fc600,         /* add   ip, pc, #NN    */
1933     0xe28cca00,         /* add   ip, ip, #NN    */
1934     0xe5bcf000,         /* ldr   pc, [ip, #NN]! */
1935     0x00000000,         /* unused               */
1936   };
1937
1938 #else
1939
1940 /* The first entry in a procedure linkage table looks like
1941    this.  It is set up so that any shared library function that is
1942    called before the relocation has been set up calls the dynamic
1943    linker first.  */
1944 static const bfd_vma elf32_arm_plt0_entry [] =
1945   {
1946     0xe52de004,         /* str   lr, [sp, #-4]! */
1947     0xe59fe004,         /* ldr   lr, [pc, #4]   */
1948     0xe08fe00e,         /* add   lr, pc, lr     */
1949     0xe5bef008,         /* ldr   pc, [lr, #8]!  */
1950     0x00000000,         /* &GOT[0] - .          */
1951   };
1952
1953 /* Subsequent entries in a procedure linkage table look like
1954    this.  */
1955 static const bfd_vma elf32_arm_plt_entry [] =
1956   {
1957     0xe28fc600,         /* add   ip, pc, #0xNN00000 */
1958     0xe28cca00,         /* add   ip, ip, #0xNN000   */
1959     0xe5bcf000,         /* ldr   pc, [ip, #0xNNN]!  */
1960   };
1961
1962 #endif
1963
1964 /* The format of the first entry in the procedure linkage table
1965    for a VxWorks executable.  */
1966 static const bfd_vma elf32_arm_vxworks_exec_plt0_entry[] =
1967   {
1968     0xe52dc008,         /* str    ip,[sp,#-8]!                  */
1969     0xe59fc000,         /* ldr    ip,[pc]                       */
1970     0xe59cf008,         /* ldr    pc,[ip,#8]                    */
1971     0x00000000,         /* .long  _GLOBAL_OFFSET_TABLE_         */
1972   };
1973
1974 /* The format of subsequent entries in a VxWorks executable.  */
1975 static const bfd_vma elf32_arm_vxworks_exec_plt_entry[] =
1976   {
1977     0xe59fc000,         /* ldr    ip,[pc]                       */
1978     0xe59cf000,         /* ldr    pc,[ip]                       */
1979     0x00000000,         /* .long  @got                          */
1980     0xe59fc000,         /* ldr    ip,[pc]                       */
1981     0xea000000,         /* b      _PLT                          */
1982     0x00000000,         /* .long  @pltindex*sizeof(Elf32_Rela)  */
1983   };
1984
1985 /* The format of entries in a VxWorks shared library.  */
1986 static const bfd_vma elf32_arm_vxworks_shared_plt_entry[] =
1987   {
1988     0xe59fc000,         /* ldr    ip,[pc]                       */
1989     0xe79cf009,         /* ldr    pc,[ip,r9]                    */
1990     0x00000000,         /* .long  @got                          */
1991     0xe59fc000,         /* ldr    ip,[pc]                       */
1992     0xe599f008,         /* ldr    pc,[r9,#8]                    */
1993     0x00000000,         /* .long  @pltindex*sizeof(Elf32_Rela)  */
1994   };
1995
1996 /* An initial stub used if the PLT entry is referenced from Thumb code.  */
1997 #define PLT_THUMB_STUB_SIZE 4
1998 static const bfd_vma elf32_arm_plt_thumb_stub [] =
1999   {
2000     0x4778,             /* bx pc */
2001     0x46c0              /* nop   */
2002   };
2003
2004 /* The entries in a PLT when using a DLL-based target with multiple
2005    address spaces.  */
2006 static const bfd_vma elf32_arm_symbian_plt_entry [] =
2007   {
2008     0xe51ff004,         /* ldr   pc, [pc, #-4] */
2009     0x00000000,         /* dcd   R_ARM_GLOB_DAT(X) */
2010   };
2011
2012 #define ARM_MAX_FWD_BRANCH_OFFSET  ((((1 << 23) - 1) << 2) + 8)
2013 #define ARM_MAX_BWD_BRANCH_OFFSET  ((-((1 << 23) << 2)) + 8)
2014 #define THM_MAX_FWD_BRANCH_OFFSET  ((1 << 22) -2 + 4)
2015 #define THM_MAX_BWD_BRANCH_OFFSET  (-(1 << 22) + 4)
2016 #define THM2_MAX_FWD_BRANCH_OFFSET (((1 << 24) - 2) + 4)
2017 #define THM2_MAX_BWD_BRANCH_OFFSET (-(1 << 24) + 4)
2018
2019 enum stub_insn_type
2020   {
2021     THUMB16_TYPE = 1,
2022     THUMB32_TYPE,
2023     ARM_TYPE,
2024     DATA_TYPE
2025   };
2026
2027 #define THUMB16_INSN(X)         {(X), THUMB16_TYPE, R_ARM_NONE, 0}
2028 /* A bit of a hack.  A Thumb conditional branch, in which the proper condition
2029    is inserted in arm_build_one_stub().  */
2030 #define THUMB16_BCOND_INSN(X)   {(X), THUMB16_TYPE, R_ARM_NONE, 1}
2031 #define THUMB32_INSN(X)         {(X), THUMB32_TYPE, R_ARM_NONE, 0}
2032 #define THUMB32_B_INSN(X, Z)    {(X), THUMB32_TYPE, R_ARM_THM_JUMP24, (Z)}
2033 #define ARM_INSN(X)             {(X), ARM_TYPE, R_ARM_NONE, 0}
2034 #define ARM_REL_INSN(X, Z)      {(X), ARM_TYPE, R_ARM_JUMP24, (Z)}
2035 #define DATA_WORD(X,Y,Z)        {(X), DATA_TYPE, (Y), (Z)}
2036
2037 typedef struct
2038 {
2039   bfd_vma data;
2040   enum stub_insn_type type;
2041   unsigned int r_type;
2042   int reloc_addend;
2043 }  insn_sequence;
2044
2045 /* Arm/Thumb -> Arm/Thumb long branch stub. On V5T and above, use blx
2046    to reach the stub if necessary.  */
2047 static const insn_sequence elf32_arm_stub_long_branch_any_any[] =
2048   {
2049     ARM_INSN(0xe51ff004),            /* ldr   pc, [pc, #-4] */
2050     DATA_WORD(0, R_ARM_ABS32, 0),    /* dcd   R_ARM_ABS32(X) */
2051   };
2052
2053 /* V4T Arm -> Thumb long branch stub. Used on V4T where blx is not
2054    available.  */
2055 static const insn_sequence elf32_arm_stub_long_branch_v4t_arm_thumb[] =
2056   {
2057     ARM_INSN(0xe59fc000),            /* ldr   ip, [pc, #0] */
2058     ARM_INSN(0xe12fff1c),            /* bx    ip */
2059     DATA_WORD(0, R_ARM_ABS32, 0),    /* dcd   R_ARM_ABS32(X) */
2060   };
2061
2062 /* Thumb -> Thumb long branch stub. Used on M-profile architectures.  */
2063 static const insn_sequence elf32_arm_stub_long_branch_thumb_only[] =
2064   {
2065     THUMB16_INSN(0xb401),             /* push {r0} */
2066     THUMB16_INSN(0x4802),             /* ldr  r0, [pc, #8] */
2067     THUMB16_INSN(0x4684),             /* mov  ip, r0 */
2068     THUMB16_INSN(0xbc01),             /* pop  {r0} */
2069     THUMB16_INSN(0x4760),             /* bx   ip */
2070     THUMB16_INSN(0xbf00),             /* nop */
2071     DATA_WORD(0, R_ARM_ABS32, 0),     /* dcd  R_ARM_ABS32(X) */
2072   };
2073
2074 /* V4T Thumb -> Thumb long branch stub. Using the stack is not
2075    allowed.  */
2076 static const insn_sequence elf32_arm_stub_long_branch_v4t_thumb_thumb[] =
2077   {
2078     THUMB16_INSN(0x4778),             /* bx   pc */
2079     THUMB16_INSN(0x46c0),             /* nop */
2080     ARM_INSN(0xe59fc000),             /* ldr  ip, [pc, #0] */
2081     ARM_INSN(0xe12fff1c),             /* bx   ip */
2082     DATA_WORD(0, R_ARM_ABS32, 0),     /* dcd  R_ARM_ABS32(X) */
2083   };
2084
2085 /* V4T Thumb -> ARM long branch stub. Used on V4T where blx is not
2086    available.  */
2087 static const insn_sequence elf32_arm_stub_long_branch_v4t_thumb_arm[] =
2088   {
2089     THUMB16_INSN(0x4778),             /* bx   pc */
2090     THUMB16_INSN(0x46c0),             /* nop   */
2091     ARM_INSN(0xe51ff004),             /* ldr   pc, [pc, #-4] */
2092     DATA_WORD(0, R_ARM_ABS32, 0),     /* dcd   R_ARM_ABS32(X) */
2093   };
2094
2095 /* V4T Thumb -> ARM short branch stub. Shorter variant of the above
2096    one, when the destination is close enough.  */
2097 static const insn_sequence elf32_arm_stub_short_branch_v4t_thumb_arm[] =
2098   {
2099     THUMB16_INSN(0x4778),             /* bx   pc */
2100     THUMB16_INSN(0x46c0),             /* nop   */
2101     ARM_REL_INSN(0xea000000, -8),     /* b    (X-8) */
2102   };
2103
2104 /* ARM/Thumb -> ARM long branch stub, PIC.  On V5T and above, use
2105    blx to reach the stub if necessary.  */
2106 static const insn_sequence elf32_arm_stub_long_branch_any_arm_pic[] =
2107   {
2108     ARM_INSN(0xe59fc000),             /* ldr   r12, [pc] */
2109     ARM_INSN(0xe08ff00c),             /* add   pc, pc, ip */
2110     DATA_WORD(0, R_ARM_REL32, -4),    /* dcd   R_ARM_REL32(X-4) */
2111   };
2112
2113 /* ARM/Thumb -> Thumb long branch stub, PIC.  On V5T and above, use
2114    blx to reach the stub if necessary.  We can not add into pc;
2115    it is not guaranteed to mode switch (different in ARMv6 and
2116    ARMv7).  */
2117 static const insn_sequence elf32_arm_stub_long_branch_any_thumb_pic[] =
2118   {
2119     ARM_INSN(0xe59fc004),             /* ldr   r12, [pc, #4] */
2120     ARM_INSN(0xe08fc00c),             /* add   ip, pc, ip */
2121     ARM_INSN(0xe12fff1c),             /* bx    ip */
2122     DATA_WORD(0, R_ARM_REL32, 0),     /* dcd   R_ARM_REL32(X) */
2123   };
2124
2125 /* V4T ARM -> ARM long branch stub, PIC.  */
2126 static const insn_sequence elf32_arm_stub_long_branch_v4t_arm_thumb_pic[] =
2127   {
2128     ARM_INSN(0xe59fc004),             /* ldr   ip, [pc, #4] */
2129     ARM_INSN(0xe08fc00c),             /* add   ip, pc, ip */
2130     ARM_INSN(0xe12fff1c),             /* bx    ip */
2131     DATA_WORD(0, R_ARM_REL32, 0),     /* dcd   R_ARM_REL32(X) */
2132   };
2133
2134 /* V4T Thumb -> ARM long branch stub, PIC.  */
2135 static const insn_sequence elf32_arm_stub_long_branch_v4t_thumb_arm_pic[] =
2136   {
2137     THUMB16_INSN(0x4778),             /* bx   pc */
2138     THUMB16_INSN(0x46c0),             /* nop  */
2139     ARM_INSN(0xe59fc000),             /* ldr  ip, [pc, #0] */
2140     ARM_INSN(0xe08cf00f),             /* add  pc, ip, pc */
2141     DATA_WORD(0, R_ARM_REL32, -4),     /* dcd  R_ARM_REL32(X) */
2142   };
2143
2144 /* Thumb -> Thumb long branch stub, PIC. Used on M-profile
2145    architectures.  */
2146 static const insn_sequence elf32_arm_stub_long_branch_thumb_only_pic[] =
2147   {
2148     THUMB16_INSN(0xb401),             /* push {r0} */
2149     THUMB16_INSN(0x4802),             /* ldr  r0, [pc, #8] */
2150     THUMB16_INSN(0x46fc),             /* mov  ip, pc */
2151     THUMB16_INSN(0x4484),             /* add  ip, r0 */
2152     THUMB16_INSN(0xbc01),             /* pop  {r0} */
2153     THUMB16_INSN(0x4760),             /* bx   ip */
2154     DATA_WORD(0, R_ARM_REL32, 4),     /* dcd  R_ARM_REL32(X) */
2155   };
2156
2157 /* V4T Thumb -> Thumb long branch stub, PIC. Using the stack is not
2158    allowed.  */
2159 static const insn_sequence elf32_arm_stub_long_branch_v4t_thumb_thumb_pic[] =
2160   {
2161     THUMB16_INSN(0x4778),             /* bx   pc */
2162     THUMB16_INSN(0x46c0),             /* nop */
2163     ARM_INSN(0xe59fc004),             /* ldr  ip, [pc, #4] */
2164     ARM_INSN(0xe08fc00c),             /* add   ip, pc, ip */
2165     ARM_INSN(0xe12fff1c),             /* bx   ip */
2166     DATA_WORD(0, R_ARM_REL32, 0),     /* dcd  R_ARM_REL32(X) */
2167   };
2168
2169 /* Cortex-A8 erratum-workaround stubs.  */
2170
2171 /* Stub used for conditional branches (which may be beyond +/-1MB away, so we
2172    can't use a conditional branch to reach this stub).  */
2173
2174 static const insn_sequence elf32_arm_stub_a8_veneer_b_cond[] =
2175   {
2176     THUMB16_BCOND_INSN(0xd001),         /* b<cond>.n true.  */
2177     THUMB32_B_INSN(0xf000b800, -4),     /* b.w insn_after_original_branch.  */
2178     THUMB32_B_INSN(0xf000b800, -4)      /* true: b.w original_branch_dest.  */
2179   };
2180
2181 /* Stub used for b.w and bl.w instructions.  */
2182
2183 static const insn_sequence elf32_arm_stub_a8_veneer_b[] =
2184   {
2185     THUMB32_B_INSN(0xf000b800, -4)      /* b.w original_branch_dest.  */
2186   };
2187
2188 static const insn_sequence elf32_arm_stub_a8_veneer_bl[] =
2189   {
2190     THUMB32_B_INSN(0xf000b800, -4)      /* b.w original_branch_dest.  */
2191   };
2192
2193 /* Stub used for Thumb-2 blx.w instructions.  We modified the original blx.w
2194    instruction (which switches to ARM mode) to point to this stub.  Jump to the
2195    real destination using an ARM-mode branch.  */
2196
2197 static const insn_sequence elf32_arm_stub_a8_veneer_blx[] =
2198   {
2199     ARM_REL_INSN(0xea000000, -8)        /* b original_branch_dest.  */
2200   };
2201
2202 /* Section name for stubs is the associated section name plus this
2203    string.  */
2204 #define STUB_SUFFIX ".stub"
2205
2206 /* One entry per long/short branch stub defined above.  */
2207 #define DEF_STUBS \
2208   DEF_STUB(long_branch_any_any) \
2209   DEF_STUB(long_branch_v4t_arm_thumb) \
2210   DEF_STUB(long_branch_thumb_only) \
2211   DEF_STUB(long_branch_v4t_thumb_thumb) \
2212   DEF_STUB(long_branch_v4t_thumb_arm) \
2213   DEF_STUB(short_branch_v4t_thumb_arm) \
2214   DEF_STUB(long_branch_any_arm_pic) \
2215   DEF_STUB(long_branch_any_thumb_pic) \
2216   DEF_STUB(long_branch_v4t_thumb_thumb_pic) \
2217   DEF_STUB(long_branch_v4t_arm_thumb_pic) \
2218   DEF_STUB(long_branch_v4t_thumb_arm_pic) \
2219   DEF_STUB(long_branch_thumb_only_pic) \
2220   DEF_STUB(a8_veneer_b_cond) \
2221   DEF_STUB(a8_veneer_b) \
2222   DEF_STUB(a8_veneer_bl) \
2223   DEF_STUB(a8_veneer_blx)
2224
2225 #define DEF_STUB(x) arm_stub_##x,
2226 enum elf32_arm_stub_type {
2227   arm_stub_none,
2228   DEF_STUBS
2229   /* Note the first a8_veneer type */
2230   arm_stub_a8_veneer_lwm = arm_stub_a8_veneer_b_cond
2231 };
2232 #undef DEF_STUB
2233
2234 typedef struct
2235 {
2236   const insn_sequence* template_sequence;
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 /* Array to keep track of which stub sections have been created, and
2525    information on stub grouping.  */
2526 struct map_stub
2527 {
2528   /* This is the section to which stubs in the group will be
2529      attached.  */
2530   asection *link_sec;
2531   /* The stub section.  */
2532   asection *stub_sec;
2533 };
2534
2535 /* ARM ELF linker hash table.  */
2536 struct elf32_arm_link_hash_table
2537 {
2538   /* The main hash table.  */
2539   struct elf_link_hash_table root;
2540
2541   /* The size in bytes of the section containing the Thumb-to-ARM glue.  */
2542   bfd_size_type thumb_glue_size;
2543
2544   /* The size in bytes of the section containing the ARM-to-Thumb glue.  */
2545   bfd_size_type arm_glue_size;
2546
2547   /* The size in bytes of section containing the ARMv4 BX veneers.  */
2548   bfd_size_type bx_glue_size;
2549
2550   /* Offsets of ARMv4 BX veneers.  Bit1 set if present, and Bit0 set when
2551      veneer has been populated.  */
2552   bfd_vma bx_glue_offset[15];
2553
2554   /* The size in bytes of the section containing glue for VFP11 erratum
2555      veneers.  */
2556   bfd_size_type vfp11_erratum_glue_size;
2557
2558   /* A table of fix locations for Cortex-A8 Thumb-2 branch/TLB erratum.  This
2559      holds Cortex-A8 erratum fix locations between elf32_arm_size_stubs() and
2560      elf32_arm_write_section().  */
2561   struct a8_erratum_fix *a8_erratum_fixes;
2562   unsigned int num_a8_erratum_fixes;
2563
2564   /* An arbitrary input BFD chosen to hold the glue sections.  */
2565   bfd * bfd_of_glue_owner;
2566
2567   /* Nonzero to output a BE8 image.  */
2568   int byteswap_code;
2569
2570   /* Zero if R_ARM_TARGET1 means R_ARM_ABS32.
2571      Nonzero if R_ARM_TARGET1 means R_ARM_REL32.  */
2572   int target1_is_rel;
2573
2574   /* The relocation to use for R_ARM_TARGET2 relocations.  */
2575   int target2_reloc;
2576
2577   /* 0 = Ignore R_ARM_V4BX.
2578      1 = Convert BX to MOV PC.
2579      2 = Generate v4 interworing stubs.  */
2580   int fix_v4bx;
2581
2582   /* Whether we should fix the Cortex-A8 Thumb-2 branch/TLB erratum.  */
2583   int fix_cortex_a8;
2584
2585   /* Nonzero if the ARM/Thumb BLX instructions are available for use.  */
2586   int use_blx;
2587
2588   /* What sort of code sequences we should look for which may trigger the
2589      VFP11 denorm erratum.  */
2590   bfd_arm_vfp11_fix vfp11_fix;
2591
2592   /* Global counter for the number of fixes we have emitted.  */
2593   int num_vfp11_fixes;
2594
2595   /* Nonzero to force PIC branch veneers.  */
2596   int pic_veneer;
2597
2598   /* The number of bytes in the initial entry in the PLT.  */
2599   bfd_size_type plt_header_size;
2600
2601   /* The number of bytes in the subsequent PLT etries.  */
2602   bfd_size_type plt_entry_size;
2603
2604   /* True if the target system is VxWorks.  */
2605   int vxworks_p;
2606
2607   /* True if the target system is Symbian OS.  */
2608   int symbian_p;
2609
2610   /* True if the target uses REL relocations.  */
2611   int use_rel;
2612
2613   /* Short-cuts to get to dynamic linker sections.  */
2614   asection *sgot;
2615   asection *sgotplt;
2616   asection *srelgot;
2617   asection *splt;
2618   asection *srelplt;
2619   asection *sdynbss;
2620   asection *srelbss;
2621
2622   /* The (unloaded but important) VxWorks .rela.plt.unloaded section.  */
2623   asection *srelplt2;
2624
2625   /* Data for R_ARM_TLS_LDM32 relocations.  */
2626   union
2627   {
2628     bfd_signed_vma refcount;
2629     bfd_vma offset;
2630   } tls_ldm_got;
2631
2632   /* Small local sym cache.  */
2633   struct sym_cache sym_cache;
2634
2635   /* For convenience in allocate_dynrelocs.  */
2636   bfd * obfd;
2637
2638   /* The stub hash table.  */
2639   struct bfd_hash_table stub_hash_table;
2640
2641   /* Linker stub bfd.  */
2642   bfd *stub_bfd;
2643
2644   /* Linker call-backs.  */
2645   asection * (*add_stub_section) (const char *, asection *);
2646   void (*layout_sections_again) (void);
2647
2648   /* Array to keep track of which stub sections have been created, and
2649      information on stub grouping.  */
2650   struct map_stub *stub_group;
2651
2652   /* Assorted information used by elf32_arm_size_stubs.  */
2653   unsigned int bfd_count;
2654   int top_index;
2655   asection **input_list;
2656 };
2657
2658 /* Create an entry in an ARM ELF linker hash table.  */
2659
2660 static struct bfd_hash_entry *
2661 elf32_arm_link_hash_newfunc (struct bfd_hash_entry * entry,
2662                              struct bfd_hash_table * table,
2663                              const char * string)
2664 {
2665   struct elf32_arm_link_hash_entry * ret =
2666     (struct elf32_arm_link_hash_entry *) entry;
2667
2668   /* Allocate the structure if it has not already been allocated by a
2669      subclass.  */
2670   if (ret == NULL)
2671     ret = (struct elf32_arm_link_hash_entry *)
2672         bfd_hash_allocate (table, sizeof (struct elf32_arm_link_hash_entry));
2673   if (ret == NULL)
2674     return (struct bfd_hash_entry *) ret;
2675
2676   /* Call the allocation method of the superclass.  */
2677   ret = ((struct elf32_arm_link_hash_entry *)
2678          _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
2679                                      table, string));
2680   if (ret != NULL)
2681     {
2682       ret->relocs_copied = NULL;
2683       ret->tls_type = GOT_UNKNOWN;
2684       ret->plt_thumb_refcount = 0;
2685       ret->plt_maybe_thumb_refcount = 0;
2686       ret->plt_got_offset = -1;
2687       ret->export_glue = NULL;
2688
2689       ret->stub_cache = NULL;
2690     }
2691
2692   return (struct bfd_hash_entry *) ret;
2693 }
2694
2695 /* Initialize an entry in the stub hash table.  */
2696
2697 static struct bfd_hash_entry *
2698 stub_hash_newfunc (struct bfd_hash_entry *entry,
2699                    struct bfd_hash_table *table,
2700                    const char *string)
2701 {
2702   /* Allocate the structure if it has not already been allocated by a
2703      subclass.  */
2704   if (entry == NULL)
2705     {
2706       entry = (struct bfd_hash_entry *)
2707           bfd_hash_allocate (table, sizeof (struct elf32_arm_stub_hash_entry));
2708       if (entry == NULL)
2709         return entry;
2710     }
2711
2712   /* Call the allocation method of the superclass.  */
2713   entry = bfd_hash_newfunc (entry, table, string);
2714   if (entry != NULL)
2715     {
2716       struct elf32_arm_stub_hash_entry *eh;
2717
2718       /* Initialize the local fields.  */
2719       eh = (struct elf32_arm_stub_hash_entry *) entry;
2720       eh->stub_sec = NULL;
2721       eh->stub_offset = 0;
2722       eh->target_value = 0;
2723       eh->target_section = NULL;
2724       eh->target_addend = 0;
2725       eh->orig_insn = 0;
2726       eh->stub_type = arm_stub_none;
2727       eh->stub_size = 0;
2728       eh->stub_template = NULL;
2729       eh->stub_template_size = 0;
2730       eh->h = NULL;
2731       eh->id_sec = NULL;
2732       eh->output_name = NULL;
2733     }
2734
2735   return entry;
2736 }
2737
2738 /* Create .got, .gotplt, and .rel(a).got sections in DYNOBJ, and set up
2739    shortcuts to them in our hash table.  */
2740
2741 static bfd_boolean
2742 create_got_section (bfd *dynobj, struct bfd_link_info *info)
2743 {
2744   struct elf32_arm_link_hash_table *htab;
2745
2746   htab = elf32_arm_hash_table (info);
2747   /* BPABI objects never have a GOT, or associated sections.  */
2748   if (htab->symbian_p)
2749     return TRUE;
2750
2751   if (! _bfd_elf_create_got_section (dynobj, info))
2752     return FALSE;
2753
2754   htab->sgot = bfd_get_section_by_name (dynobj, ".got");
2755   htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
2756   if (!htab->sgot || !htab->sgotplt)
2757     abort ();
2758
2759   htab->srelgot = bfd_get_section_by_name (dynobj,
2760                                            RELOC_SECTION (htab, ".got"));
2761   if (htab->srelgot == NULL)
2762     return FALSE;
2763   return TRUE;
2764 }
2765
2766 /* Create .plt, .rel(a).plt, .got, .got.plt, .rel(a).got, .dynbss, and
2767    .rel(a).bss sections in DYNOBJ, and set up shortcuts to them in our
2768    hash table.  */
2769
2770 static bfd_boolean
2771 elf32_arm_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
2772 {
2773   struct elf32_arm_link_hash_table *htab;
2774
2775   htab = elf32_arm_hash_table (info);
2776   if (!htab->sgot && !create_got_section (dynobj, info))
2777     return FALSE;
2778
2779   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
2780     return FALSE;
2781
2782   htab->splt = bfd_get_section_by_name (dynobj, ".plt");
2783   htab->srelplt = bfd_get_section_by_name (dynobj,
2784                                            RELOC_SECTION (htab, ".plt"));
2785   htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
2786   if (!info->shared)
2787     htab->srelbss = bfd_get_section_by_name (dynobj,
2788                                              RELOC_SECTION (htab, ".bss"));
2789
2790   if (htab->vxworks_p)
2791     {
2792       if (!elf_vxworks_create_dynamic_sections (dynobj, info, &htab->srelplt2))
2793         return FALSE;
2794
2795       if (info->shared)
2796         {
2797           htab->plt_header_size = 0;
2798           htab->plt_entry_size
2799             = 4 * ARRAY_SIZE (elf32_arm_vxworks_shared_plt_entry);
2800         }
2801       else
2802         {
2803           htab->plt_header_size
2804             = 4 * ARRAY_SIZE (elf32_arm_vxworks_exec_plt0_entry);
2805           htab->plt_entry_size
2806             = 4 * ARRAY_SIZE (elf32_arm_vxworks_exec_plt_entry);
2807         }
2808     }
2809
2810   if (!htab->splt
2811       || !htab->srelplt
2812       || !htab->sdynbss
2813       || (!info->shared && !htab->srelbss))
2814     abort ();
2815
2816   return TRUE;
2817 }
2818
2819 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
2820
2821 static void
2822 elf32_arm_copy_indirect_symbol (struct bfd_link_info *info,
2823                                 struct elf_link_hash_entry *dir,
2824                                 struct elf_link_hash_entry *ind)
2825 {
2826   struct elf32_arm_link_hash_entry *edir, *eind;
2827
2828   edir = (struct elf32_arm_link_hash_entry *) dir;
2829   eind = (struct elf32_arm_link_hash_entry *) ind;
2830
2831   if (eind->relocs_copied != NULL)
2832     {
2833       if (edir->relocs_copied != NULL)
2834         {
2835           struct elf32_arm_relocs_copied **pp;
2836           struct elf32_arm_relocs_copied *p;
2837
2838           /* Add reloc counts against the indirect sym to the direct sym
2839              list.  Merge any entries against the same section.  */
2840           for (pp = &eind->relocs_copied; (p = *pp) != NULL; )
2841             {
2842               struct elf32_arm_relocs_copied *q;
2843
2844               for (q = edir->relocs_copied; q != NULL; q = q->next)
2845                 if (q->section == p->section)
2846                   {
2847                     q->pc_count += p->pc_count;
2848                     q->count += p->count;
2849                     *pp = p->next;
2850                     break;
2851                   }
2852               if (q == NULL)
2853                 pp = &p->next;
2854             }
2855           *pp = edir->relocs_copied;
2856         }
2857
2858       edir->relocs_copied = eind->relocs_copied;
2859       eind->relocs_copied = NULL;
2860     }
2861
2862   if (ind->root.type == bfd_link_hash_indirect)
2863     {
2864       /* Copy over PLT info.  */
2865       edir->plt_thumb_refcount += eind->plt_thumb_refcount;
2866       eind->plt_thumb_refcount = 0;
2867       edir->plt_maybe_thumb_refcount += eind->plt_maybe_thumb_refcount;
2868       eind->plt_maybe_thumb_refcount = 0;
2869
2870       if (dir->got.refcount <= 0)
2871         {
2872           edir->tls_type = eind->tls_type;
2873           eind->tls_type = GOT_UNKNOWN;
2874         }
2875     }
2876
2877   _bfd_elf_link_hash_copy_indirect (info, dir, ind);
2878 }
2879
2880 /* Create an ARM elf linker hash table.  */
2881
2882 static struct bfd_link_hash_table *
2883 elf32_arm_link_hash_table_create (bfd *abfd)
2884 {
2885   struct elf32_arm_link_hash_table *ret;
2886   bfd_size_type amt = sizeof (struct elf32_arm_link_hash_table);
2887
2888   ret = (struct elf32_arm_link_hash_table *) bfd_malloc (amt);
2889   if (ret == NULL)
2890     return NULL;
2891
2892   if (!_bfd_elf_link_hash_table_init (& ret->root, abfd,
2893                                       elf32_arm_link_hash_newfunc,
2894                                       sizeof (struct elf32_arm_link_hash_entry)))
2895     {
2896       free (ret);
2897       return NULL;
2898     }
2899
2900   ret->sgot = NULL;
2901   ret->sgotplt = NULL;
2902   ret->srelgot = NULL;
2903   ret->splt = NULL;
2904   ret->srelplt = NULL;
2905   ret->sdynbss = NULL;
2906   ret->srelbss = NULL;
2907   ret->srelplt2 = NULL;
2908   ret->thumb_glue_size = 0;
2909   ret->arm_glue_size = 0;
2910   ret->bx_glue_size = 0;
2911   memset (ret->bx_glue_offset, 0, sizeof (ret->bx_glue_offset));
2912   ret->vfp11_fix = BFD_ARM_VFP11_FIX_NONE;
2913   ret->vfp11_erratum_glue_size = 0;
2914   ret->num_vfp11_fixes = 0;
2915   ret->fix_cortex_a8 = 0;
2916   ret->bfd_of_glue_owner = NULL;
2917   ret->byteswap_code = 0;
2918   ret->target1_is_rel = 0;
2919   ret->target2_reloc = R_ARM_NONE;
2920 #ifdef FOUR_WORD_PLT
2921   ret->plt_header_size = 16;
2922   ret->plt_entry_size = 16;
2923 #else
2924   ret->plt_header_size = 20;
2925   ret->plt_entry_size = 12;
2926 #endif
2927   ret->fix_v4bx = 0;
2928   ret->use_blx = 0;
2929   ret->vxworks_p = 0;
2930   ret->symbian_p = 0;
2931   ret->use_rel = 1;
2932   ret->sym_cache.abfd = NULL;
2933   ret->obfd = abfd;
2934   ret->tls_ldm_got.refcount = 0;
2935   ret->stub_bfd = NULL;
2936   ret->add_stub_section = NULL;
2937   ret->layout_sections_again = NULL;
2938   ret->stub_group = NULL;
2939   ret->bfd_count = 0;
2940   ret->top_index = 0;
2941   ret->input_list = NULL;
2942
2943   if (!bfd_hash_table_init (&ret->stub_hash_table, stub_hash_newfunc,
2944                             sizeof (struct elf32_arm_stub_hash_entry)))
2945     {
2946       free (ret);
2947       return NULL;
2948     }
2949
2950   return &ret->root.root;
2951 }
2952
2953 /* Free the derived linker hash table.  */
2954
2955 static void
2956 elf32_arm_hash_table_free (struct bfd_link_hash_table *hash)
2957 {
2958   struct elf32_arm_link_hash_table *ret
2959     = (struct elf32_arm_link_hash_table *) hash;
2960
2961   bfd_hash_table_free (&ret->stub_hash_table);
2962   _bfd_generic_link_hash_table_free (hash);
2963 }
2964
2965 /* Determine if we're dealing with a Thumb only architecture.  */
2966
2967 static bfd_boolean
2968 using_thumb_only (struct elf32_arm_link_hash_table *globals)
2969 {
2970   int arch = bfd_elf_get_obj_attr_int (globals->obfd, OBJ_ATTR_PROC,
2971                                        Tag_CPU_arch);
2972   int profile;
2973
2974   if (arch != TAG_CPU_ARCH_V7 && arch != TAG_CPU_ARCH_V7E_M)
2975     return FALSE;
2976
2977   profile = bfd_elf_get_obj_attr_int (globals->obfd, OBJ_ATTR_PROC,
2978                                       Tag_CPU_arch_profile);
2979
2980   return profile == 'M';
2981 }
2982
2983 /* Determine if we're dealing with a Thumb-2 object.  */
2984
2985 static bfd_boolean
2986 using_thumb2 (struct elf32_arm_link_hash_table *globals)
2987 {
2988   int arch = bfd_elf_get_obj_attr_int (globals->obfd, OBJ_ATTR_PROC,
2989                                        Tag_CPU_arch);
2990   return arch == TAG_CPU_ARCH_V6T2 || arch >= TAG_CPU_ARCH_V7;
2991 }
2992
2993 /* Determine what kind of NOPs are available.  */
2994
2995 static bfd_boolean
2996 arch_has_arm_nop (struct elf32_arm_link_hash_table *globals)
2997 {
2998   const int arch = bfd_elf_get_obj_attr_int (globals->obfd, OBJ_ATTR_PROC,
2999                                              Tag_CPU_arch);
3000   return arch == TAG_CPU_ARCH_V6T2
3001          || arch == TAG_CPU_ARCH_V6K
3002          || arch == TAG_CPU_ARCH_V7
3003          || arch == TAG_CPU_ARCH_V7E_M;
3004 }
3005
3006 static bfd_boolean
3007 arch_has_thumb2_nop (struct elf32_arm_link_hash_table *globals)
3008 {
3009   const int arch = bfd_elf_get_obj_attr_int (globals->obfd, OBJ_ATTR_PROC,
3010                                              Tag_CPU_arch);
3011   return (arch == TAG_CPU_ARCH_V6T2 || arch == TAG_CPU_ARCH_V7
3012           || arch == TAG_CPU_ARCH_V7E_M);
3013 }
3014
3015 static bfd_boolean
3016 arm_stub_is_thumb (enum elf32_arm_stub_type stub_type)
3017 {
3018   switch (stub_type)
3019     {
3020     case arm_stub_long_branch_thumb_only:
3021     case arm_stub_long_branch_v4t_thumb_arm:
3022     case arm_stub_short_branch_v4t_thumb_arm:
3023     case arm_stub_long_branch_v4t_thumb_arm_pic:
3024     case arm_stub_long_branch_thumb_only_pic:
3025       return TRUE;
3026     case arm_stub_none:
3027       BFD_FAIL ();
3028       return FALSE;
3029       break;
3030     default:
3031       return FALSE;
3032     }
3033 }
3034
3035 /* Determine the type of stub needed, if any, for a call.  */
3036
3037 static enum elf32_arm_stub_type
3038 arm_type_of_stub (struct bfd_link_info *info,
3039                   asection *input_sec,
3040                   const Elf_Internal_Rela *rel,
3041                   unsigned char st_type,
3042                   struct elf32_arm_link_hash_entry *hash,
3043                   bfd_vma destination,
3044                   asection *sym_sec,
3045                   bfd *input_bfd,
3046                   const char *name)
3047 {
3048   bfd_vma location;
3049   bfd_signed_vma branch_offset;
3050   unsigned int r_type;
3051   struct elf32_arm_link_hash_table * globals;
3052   int thumb2;
3053   int thumb_only;
3054   enum elf32_arm_stub_type stub_type = arm_stub_none;
3055   int use_plt = 0;
3056
3057   /* We don't know the actual type of destination in case it is of
3058      type STT_SECTION: give up.  */
3059   if (st_type == STT_SECTION)
3060     return stub_type;
3061
3062   globals = elf32_arm_hash_table (info);
3063
3064   thumb_only = using_thumb_only (globals);
3065
3066   thumb2 = using_thumb2 (globals);
3067
3068   /* Determine where the call point is.  */
3069   location = (input_sec->output_offset
3070               + input_sec->output_section->vma
3071               + rel->r_offset);
3072
3073   branch_offset = (bfd_signed_vma)(destination - location);
3074
3075   r_type = ELF32_R_TYPE (rel->r_info);
3076
3077   /* Keep a simpler condition, for the sake of clarity.  */
3078   if (globals->splt != NULL && hash != NULL && hash->root.plt.offset != (bfd_vma) -1)
3079     {
3080       use_plt = 1;
3081       /* Note when dealing with PLT entries: the main PLT stub is in
3082          ARM mode, so if the branch is in Thumb mode, another
3083          Thumb->ARM stub will be inserted later just before the ARM
3084          PLT stub. We don't take this extra distance into account
3085          here, because if a long branch stub is needed, we'll add a
3086          Thumb->Arm one and branch directly to the ARM PLT entry
3087          because it avoids spreading offset corrections in several
3088          places.  */
3089     }
3090
3091   if (r_type == R_ARM_THM_CALL || r_type == R_ARM_THM_JUMP24)
3092     {
3093       /* Handle cases where:
3094          - this call goes too far (different Thumb/Thumb2 max
3095            distance)
3096          - it's a Thumb->Arm call and blx is not available, or it's a
3097            Thumb->Arm branch (not bl). A stub is needed in this case,
3098            but only if this call is not through a PLT entry. Indeed,
3099            PLT stubs handle mode switching already.
3100       */
3101       if ((!thumb2
3102             && (branch_offset > THM_MAX_FWD_BRANCH_OFFSET
3103                 || (branch_offset < THM_MAX_BWD_BRANCH_OFFSET)))
3104           || (thumb2
3105               && (branch_offset > THM2_MAX_FWD_BRANCH_OFFSET
3106                   || (branch_offset < THM2_MAX_BWD_BRANCH_OFFSET)))
3107           || ((st_type != STT_ARM_TFUNC)
3108               && (((r_type == R_ARM_THM_CALL) && !globals->use_blx)
3109                   || (r_type == R_ARM_THM_JUMP24))
3110               && !use_plt))
3111         {
3112           if (st_type == STT_ARM_TFUNC)
3113             {
3114               /* Thumb to thumb.  */
3115               if (!thumb_only)
3116                 {
3117                   stub_type = (info->shared | globals->pic_veneer)
3118                     /* PIC stubs.  */
3119                     ? ((globals->use_blx
3120                         && (r_type ==R_ARM_THM_CALL))
3121                        /* V5T and above. Stub starts with ARM code, so
3122                           we must be able to switch mode before
3123                           reaching it, which is only possible for 'bl'
3124                           (ie R_ARM_THM_CALL relocation).  */
3125                        ? arm_stub_long_branch_any_thumb_pic
3126                        /* On V4T, use Thumb code only.  */
3127                        : arm_stub_long_branch_v4t_thumb_thumb_pic)
3128
3129                     /* non-PIC stubs.  */
3130                     : ((globals->use_blx
3131                         && (r_type ==R_ARM_THM_CALL))
3132                        /* V5T and above.  */
3133                        ? arm_stub_long_branch_any_any
3134                        /* V4T.  */
3135                        : arm_stub_long_branch_v4t_thumb_thumb);
3136                 }
3137               else
3138                 {
3139                   stub_type = (info->shared | globals->pic_veneer)
3140                     /* PIC stub.  */
3141                     ? arm_stub_long_branch_thumb_only_pic
3142                     /* non-PIC stub.  */
3143                     : arm_stub_long_branch_thumb_only;
3144                 }
3145             }
3146           else
3147             {
3148               /* Thumb to arm.  */
3149               if (sym_sec != NULL
3150                   && sym_sec->owner != NULL
3151                   && !INTERWORK_FLAG (sym_sec->owner))
3152                 {
3153                   (*_bfd_error_handler)
3154                     (_("%B(%s): warning: interworking not enabled.\n"
3155                        "  first occurrence: %B: Thumb call to ARM"),
3156                      sym_sec->owner, input_bfd, name);
3157                 }
3158
3159               stub_type = (info->shared | globals->pic_veneer)
3160                 /* PIC stubs.  */
3161                 ? ((globals->use_blx
3162                     && (r_type ==R_ARM_THM_CALL))
3163                    /* V5T and above.  */
3164                    ? arm_stub_long_branch_any_arm_pic
3165                    /* V4T PIC stub.  */
3166                    : arm_stub_long_branch_v4t_thumb_arm_pic)
3167
3168                 /* non-PIC stubs.  */
3169                 : ((globals->use_blx
3170                     && (r_type ==R_ARM_THM_CALL))
3171                    /* V5T and above.  */
3172                    ? arm_stub_long_branch_any_any
3173                    /* V4T.  */
3174                    : arm_stub_long_branch_v4t_thumb_arm);
3175
3176               /* Handle v4t short branches.  */
3177               if ((stub_type == arm_stub_long_branch_v4t_thumb_arm)
3178                   && (branch_offset <= THM_MAX_FWD_BRANCH_OFFSET)
3179                   && (branch_offset >= THM_MAX_BWD_BRANCH_OFFSET))
3180                 stub_type = arm_stub_short_branch_v4t_thumb_arm;
3181             }
3182         }
3183     }
3184   else if (r_type == R_ARM_CALL || r_type == R_ARM_JUMP24 || r_type == R_ARM_PLT32)
3185     {
3186       if (st_type == STT_ARM_TFUNC)
3187         {
3188           /* Arm to thumb.  */
3189
3190           if (sym_sec != NULL
3191               && sym_sec->owner != NULL
3192               && !INTERWORK_FLAG (sym_sec->owner))
3193             {
3194               (*_bfd_error_handler)
3195                 (_("%B(%s): warning: interworking not enabled.\n"
3196                    "  first occurrence: %B: ARM call to Thumb"),
3197                  sym_sec->owner, input_bfd, name);
3198             }
3199
3200           /* We have an extra 2-bytes reach because of
3201              the mode change (bit 24 (H) of BLX encoding).  */
3202           if (branch_offset > (ARM_MAX_FWD_BRANCH_OFFSET + 2)
3203               || (branch_offset < ARM_MAX_BWD_BRANCH_OFFSET)
3204               || ((r_type == R_ARM_CALL) && !globals->use_blx)
3205               || (r_type == R_ARM_JUMP24)
3206               || (r_type == R_ARM_PLT32))
3207             {
3208               stub_type = (info->shared | globals->pic_veneer)
3209                 /* PIC stubs.  */
3210                 ? ((globals->use_blx)
3211                    /* V5T and above.  */
3212                    ? arm_stub_long_branch_any_thumb_pic
3213                    /* V4T stub.  */
3214                    : arm_stub_long_branch_v4t_arm_thumb_pic)
3215
3216                 /* non-PIC stubs.  */
3217                 : ((globals->use_blx)
3218                    /* V5T and above.  */
3219                    ? arm_stub_long_branch_any_any
3220                    /* V4T.  */
3221                    : arm_stub_long_branch_v4t_arm_thumb);
3222             }
3223         }
3224       else
3225         {
3226           /* Arm to arm.  */
3227           if (branch_offset > ARM_MAX_FWD_BRANCH_OFFSET
3228               || (branch_offset < ARM_MAX_BWD_BRANCH_OFFSET))
3229             {
3230               stub_type = (info->shared | globals->pic_veneer)
3231                 /* PIC stubs.  */
3232                 ? arm_stub_long_branch_any_arm_pic
3233                 /* non-PIC stubs.  */
3234                 : arm_stub_long_branch_any_any;
3235             }
3236         }
3237     }
3238
3239   return stub_type;
3240 }
3241
3242 /* Build a name for an entry in the stub hash table.  */
3243
3244 static char *
3245 elf32_arm_stub_name (const asection *input_section,
3246                      const asection *sym_sec,
3247                      const struct elf32_arm_link_hash_entry *hash,
3248                      const Elf_Internal_Rela *rel)
3249 {
3250   char *stub_name;
3251   bfd_size_type len;
3252
3253   if (hash)
3254     {
3255       len = 8 + 1 + strlen (hash->root.root.root.string) + 1 + 8 + 1;
3256       stub_name = (char *) bfd_malloc (len);
3257       if (stub_name != NULL)
3258         sprintf (stub_name, "%08x_%s+%x",
3259                  input_section->id & 0xffffffff,
3260                  hash->root.root.root.string,
3261                  (int) rel->r_addend & 0xffffffff);
3262     }
3263   else
3264     {
3265       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
3266       stub_name = (char *) bfd_malloc (len);
3267       if (stub_name != NULL)
3268         sprintf (stub_name, "%08x_%x:%x+%x",
3269                  input_section->id & 0xffffffff,
3270                  sym_sec->id & 0xffffffff,
3271                  (int) ELF32_R_SYM (rel->r_info) & 0xffffffff,
3272                  (int) rel->r_addend & 0xffffffff);
3273     }
3274
3275   return stub_name;
3276 }
3277
3278 /* Look up an entry in the stub hash.  Stub entries are cached because
3279    creating the stub name takes a bit of time.  */
3280
3281 static struct elf32_arm_stub_hash_entry *
3282 elf32_arm_get_stub_entry (const asection *input_section,
3283                           const asection *sym_sec,
3284                           struct elf_link_hash_entry *hash,
3285                           const Elf_Internal_Rela *rel,
3286                           struct elf32_arm_link_hash_table *htab)
3287 {
3288   struct elf32_arm_stub_hash_entry *stub_entry;
3289   struct elf32_arm_link_hash_entry *h = (struct elf32_arm_link_hash_entry *) hash;
3290   const asection *id_sec;
3291
3292   if ((input_section->flags & SEC_CODE) == 0)
3293     return NULL;
3294
3295   /* If this input section is part of a group of sections sharing one
3296      stub section, then use the id of the first section in the group.
3297      Stub names need to include a section id, as there may well be
3298      more than one stub used to reach say, printf, and we need to
3299      distinguish between them.  */
3300   id_sec = htab->stub_group[input_section->id].link_sec;
3301
3302   if (h != NULL && h->stub_cache != NULL
3303       && h->stub_cache->h == h
3304       && h->stub_cache->id_sec == id_sec)
3305     {
3306       stub_entry = h->stub_cache;
3307     }
3308   else
3309     {
3310       char *stub_name;
3311
3312       stub_name = elf32_arm_stub_name (id_sec, sym_sec, h, rel);
3313       if (stub_name == NULL)
3314         return NULL;
3315
3316       stub_entry = arm_stub_hash_lookup (&htab->stub_hash_table,
3317                                         stub_name, FALSE, FALSE);
3318       if (h != NULL)
3319         h->stub_cache = stub_entry;
3320
3321       free (stub_name);
3322     }
3323
3324   return stub_entry;
3325 }
3326
3327 /* Find or create a stub section.  Returns a pointer to the stub section, and
3328    the section to which the stub section will be attached (in *LINK_SEC_P).
3329    LINK_SEC_P may be NULL.  */
3330
3331 static asection *
3332 elf32_arm_create_or_find_stub_sec (asection **link_sec_p, asection *section,
3333                                    struct elf32_arm_link_hash_table *htab)
3334 {
3335   asection *link_sec;
3336   asection *stub_sec;
3337
3338   link_sec = htab->stub_group[section->id].link_sec;
3339   stub_sec = htab->stub_group[section->id].stub_sec;
3340   if (stub_sec == NULL)
3341     {
3342       stub_sec = htab->stub_group[link_sec->id].stub_sec;
3343       if (stub_sec == NULL)
3344         {
3345           size_t namelen;
3346           bfd_size_type len;
3347           char *s_name;
3348
3349           namelen = strlen (link_sec->name);
3350           len = namelen + sizeof (STUB_SUFFIX);
3351           s_name = (char *) bfd_alloc (htab->stub_bfd, len);
3352           if (s_name == NULL)
3353             return NULL;
3354
3355           memcpy (s_name, link_sec->name, namelen);
3356           memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
3357           stub_sec = (*htab->add_stub_section) (s_name, link_sec);
3358           if (stub_sec == NULL)
3359             return NULL;
3360           htab->stub_group[link_sec->id].stub_sec = stub_sec;
3361         }
3362       htab->stub_group[section->id].stub_sec = stub_sec;
3363     }
3364
3365   if (link_sec_p)
3366     *link_sec_p = link_sec;
3367
3368   return stub_sec;
3369 }
3370
3371 /* Add a new stub entry to the stub hash.  Not all fields of the new
3372    stub entry are initialised.  */
3373
3374 static struct elf32_arm_stub_hash_entry *
3375 elf32_arm_add_stub (const char *stub_name,
3376                     asection *section,
3377                     struct elf32_arm_link_hash_table *htab)
3378 {
3379   asection *link_sec;
3380   asection *stub_sec;
3381   struct elf32_arm_stub_hash_entry *stub_entry;
3382
3383   stub_sec = elf32_arm_create_or_find_stub_sec (&link_sec, section, htab);
3384   if (stub_sec == NULL)
3385     return NULL;
3386
3387   /* Enter this entry into the linker stub hash table.  */
3388   stub_entry = arm_stub_hash_lookup (&htab->stub_hash_table, stub_name,
3389                                      TRUE, FALSE);
3390   if (stub_entry == NULL)
3391     {
3392       (*_bfd_error_handler) (_("%s: cannot create stub entry %s"),
3393                              section->owner,
3394                              stub_name);
3395       return NULL;
3396     }
3397
3398   stub_entry->stub_sec = stub_sec;
3399   stub_entry->stub_offset = 0;
3400   stub_entry->id_sec = link_sec;
3401
3402   return stub_entry;
3403 }
3404
3405 /* Store an Arm insn into an output section not processed by
3406    elf32_arm_write_section.  */
3407
3408 static void
3409 put_arm_insn (struct elf32_arm_link_hash_table * htab,
3410               bfd * output_bfd, bfd_vma val, void * ptr)
3411 {
3412   if (htab->byteswap_code != bfd_little_endian (output_bfd))
3413     bfd_putl32 (val, ptr);
3414   else
3415     bfd_putb32 (val, ptr);
3416 }
3417
3418 /* Store a 16-bit Thumb insn into an output section not processed by
3419    elf32_arm_write_section.  */
3420
3421 static void
3422 put_thumb_insn (struct elf32_arm_link_hash_table * htab,
3423                 bfd * output_bfd, bfd_vma val, void * ptr)
3424 {
3425   if (htab->byteswap_code != bfd_little_endian (output_bfd))
3426     bfd_putl16 (val, ptr);
3427   else
3428     bfd_putb16 (val, ptr);
3429 }
3430
3431 static bfd_reloc_status_type elf32_arm_final_link_relocate
3432   (reloc_howto_type *, bfd *, bfd *, asection *, bfd_byte *,
3433    Elf_Internal_Rela *, bfd_vma, struct bfd_link_info *, asection *,
3434    const char *, int, struct elf_link_hash_entry *, bfd_boolean *, char **);
3435
3436 static bfd_boolean
3437 arm_build_one_stub (struct bfd_hash_entry *gen_entry,
3438                     void * in_arg)
3439 {
3440 #define MAXRELOCS 2
3441   struct elf32_arm_stub_hash_entry *stub_entry;
3442   struct bfd_link_info *info;
3443   struct elf32_arm_link_hash_table *htab;
3444   asection *stub_sec;
3445   bfd *stub_bfd;
3446   bfd_vma stub_addr;
3447   bfd_byte *loc;
3448   bfd_vma sym_value;
3449   int template_size;
3450   int size;
3451   const insn_sequence *template_sequence;
3452   int i;
3453   struct elf32_arm_link_hash_table * globals;
3454   int stub_reloc_idx[MAXRELOCS] = {-1, -1};
3455   int stub_reloc_offset[MAXRELOCS] = {0, 0};
3456   int nrelocs = 0;
3457
3458   /* Massage our args to the form they really have.  */
3459   stub_entry = (struct elf32_arm_stub_hash_entry *) gen_entry;
3460   info = (struct bfd_link_info *) in_arg;
3461
3462   globals = elf32_arm_hash_table (info);
3463
3464   htab = elf32_arm_hash_table (info);
3465   stub_sec = stub_entry->stub_sec;
3466
3467   if ((htab->fix_cortex_a8 < 0)
3468       != (stub_entry->stub_type >= arm_stub_a8_veneer_lwm))
3469     /* We have to do the a8 fixes last, as they are less aligned than
3470        the other veneers.  */
3471     return TRUE;
3472
3473   /* Make a note of the offset within the stubs for this entry.  */
3474   stub_entry->stub_offset = stub_sec->size;
3475   loc = stub_sec->contents + stub_entry->stub_offset;
3476
3477   stub_bfd = stub_sec->owner;
3478
3479   /* This is the address of the start of the stub.  */
3480   stub_addr = stub_sec->output_section->vma + stub_sec->output_offset
3481     + stub_entry->stub_offset;
3482
3483   /* This is the address of the stub destination.  */
3484   sym_value = (stub_entry->target_value
3485                + stub_entry->target_section->output_offset
3486                + stub_entry->target_section->output_section->vma);
3487
3488   template_sequence = stub_entry->stub_template;
3489   template_size = stub_entry->stub_template_size;
3490
3491   size = 0;
3492   for (i = 0; i < template_size; i++)
3493     {
3494       switch (template_sequence[i].type)
3495         {
3496         case THUMB16_TYPE:
3497           {
3498             bfd_vma data = (bfd_vma) template_sequence[i].data;
3499             if (template_sequence[i].reloc_addend != 0)
3500               {
3501                 /* We've borrowed the reloc_addend field to mean we should
3502                    insert a condition code into this (Thumb-1 branch)
3503                    instruction.  See THUMB16_BCOND_INSN.  */
3504                 BFD_ASSERT ((data & 0xff00) == 0xd000);
3505                 data |= ((stub_entry->orig_insn >> 22) & 0xf) << 8;
3506               }
3507             put_thumb_insn (globals, stub_bfd, data, loc + size);
3508             size += 2;
3509           }
3510           break;
3511
3512         case THUMB32_TYPE:
3513           put_thumb_insn (globals, stub_bfd,
3514                           (template_sequence[i].data >> 16) & 0xffff,
3515                           loc + size);
3516           put_thumb_insn (globals, stub_bfd, template_sequence[i].data & 0xffff,
3517                           loc + size + 2);
3518           if (template_sequence[i].r_type != R_ARM_NONE)
3519             {
3520               stub_reloc_idx[nrelocs] = i;
3521               stub_reloc_offset[nrelocs++] = size;
3522             }
3523           size += 4;
3524           break;
3525
3526         case ARM_TYPE:
3527           put_arm_insn (globals, stub_bfd, template_sequence[i].data,
3528                         loc + size);
3529           /* Handle cases where the target is encoded within the
3530              instruction.  */
3531           if (template_sequence[i].r_type == R_ARM_JUMP24)
3532             {
3533               stub_reloc_idx[nrelocs] = i;
3534               stub_reloc_offset[nrelocs++] = size;
3535             }
3536           size += 4;
3537           break;
3538
3539         case DATA_TYPE:
3540           bfd_put_32 (stub_bfd, template_sequence[i].data, loc + size);
3541           stub_reloc_idx[nrelocs] = i;
3542           stub_reloc_offset[nrelocs++] = size;
3543           size += 4;
3544           break;
3545
3546         default:
3547           BFD_FAIL ();
3548           return FALSE;
3549         }
3550     }
3551
3552   stub_sec->size += size;
3553
3554   /* Stub size has already been computed in arm_size_one_stub. Check
3555      consistency.  */
3556   BFD_ASSERT (size == stub_entry->stub_size);
3557
3558   /* Destination is Thumb. Force bit 0 to 1 to reflect this.  */
3559   if (stub_entry->st_type == STT_ARM_TFUNC)
3560     sym_value |= 1;
3561
3562   /* Assume there is at least one and at most MAXRELOCS entries to relocate
3563      in each stub.  */
3564   BFD_ASSERT (nrelocs != 0 && nrelocs <= MAXRELOCS);
3565
3566   for (i = 0; i < nrelocs; i++)
3567     if (template_sequence[stub_reloc_idx[i]].r_type == R_ARM_THM_JUMP24
3568         || template_sequence[stub_reloc_idx[i]].r_type == R_ARM_THM_JUMP19
3569         || template_sequence[stub_reloc_idx[i]].r_type == R_ARM_THM_CALL
3570         || template_sequence[stub_reloc_idx[i]].r_type == R_ARM_THM_XPC22)
3571       {
3572         Elf_Internal_Rela rel;
3573         bfd_boolean unresolved_reloc;
3574         char *error_message;
3575         int sym_flags
3576           = (template_sequence[stub_reloc_idx[i]].r_type != R_ARM_THM_XPC22)
3577             ? STT_ARM_TFUNC : 0;
3578         bfd_vma points_to = sym_value + stub_entry->target_addend;
3579
3580         rel.r_offset = stub_entry->stub_offset + stub_reloc_offset[i];
3581         rel.r_info = ELF32_R_INFO (0,
3582                                    template_sequence[stub_reloc_idx[i]].r_type);
3583         rel.r_addend = template_sequence[stub_reloc_idx[i]].reloc_addend;
3584
3585         if (stub_entry->stub_type == arm_stub_a8_veneer_b_cond && i == 0)
3586           /* The first relocation in the elf32_arm_stub_a8_veneer_b_cond[]
3587              template should refer back to the instruction after the original
3588              branch.  */
3589           points_to = sym_value;
3590
3591         /* There may be unintended consequences if this is not true.  */
3592         BFD_ASSERT (stub_entry->h == NULL);
3593
3594         /* Note: _bfd_final_link_relocate doesn't handle these relocations
3595            properly.  We should probably use this function unconditionally,
3596            rather than only for certain relocations listed in the enclosing
3597            conditional, for the sake of consistency.  */
3598         elf32_arm_final_link_relocate (elf32_arm_howto_from_type
3599             (template_sequence[stub_reloc_idx[i]].r_type),
3600           stub_bfd, info->output_bfd, stub_sec, stub_sec->contents, &rel,
3601           points_to, info, stub_entry->target_section, "", sym_flags,
3602           (struct elf_link_hash_entry *) stub_entry->h, &unresolved_reloc,
3603           &error_message);
3604       }
3605     else
3606       {
3607         _bfd_final_link_relocate (elf32_arm_howto_from_type
3608             (template_sequence[stub_reloc_idx[i]].r_type), stub_bfd, stub_sec,
3609           stub_sec->contents, stub_entry->stub_offset + stub_reloc_offset[i],
3610           sym_value + stub_entry->target_addend,
3611           template_sequence[stub_reloc_idx[i]].reloc_addend);
3612       }
3613
3614   return TRUE;
3615 #undef MAXRELOCS
3616 }
3617
3618 /* Calculate the template, template size and instruction size for a stub.
3619    Return value is the instruction size.  */
3620
3621 static unsigned int
3622 find_stub_size_and_template (enum elf32_arm_stub_type stub_type,
3623                              const insn_sequence **stub_template,
3624                              int *stub_template_size)
3625 {
3626   const insn_sequence *template_sequence = NULL;
3627   int template_size = 0, i;
3628   unsigned int size;
3629
3630   template_sequence = stub_definitions[stub_type].template_sequence;
3631   template_size = stub_definitions[stub_type].template_size;
3632
3633   size = 0;
3634   for (i = 0; i < template_size; i++)
3635     {
3636       switch (template_sequence[i].type)
3637         {
3638         case THUMB16_TYPE:
3639           size += 2;
3640           break;
3641
3642         case ARM_TYPE:
3643         case THUMB32_TYPE:
3644         case DATA_TYPE:
3645           size += 4;
3646           break;
3647
3648         default:
3649           BFD_FAIL ();
3650           return FALSE;
3651         }
3652     }
3653
3654   if (stub_template)
3655     *stub_template = template_sequence;
3656
3657   if (stub_template_size)
3658     *stub_template_size = template_size;
3659
3660   return size;
3661 }
3662
3663 /* As above, but don't actually build the stub.  Just bump offset so
3664    we know stub section sizes.  */
3665
3666 static bfd_boolean
3667 arm_size_one_stub (struct bfd_hash_entry *gen_entry,
3668                    void * in_arg)
3669 {
3670   struct elf32_arm_stub_hash_entry *stub_entry;
3671   struct elf32_arm_link_hash_table *htab;
3672   const insn_sequence *template_sequence;
3673   int template_size, size;
3674
3675   /* Massage our args to the form they really have.  */
3676   stub_entry = (struct elf32_arm_stub_hash_entry *) gen_entry;
3677   htab = (struct elf32_arm_link_hash_table *) in_arg;
3678
3679   BFD_ASSERT((stub_entry->stub_type > arm_stub_none)
3680              && stub_entry->stub_type < ARRAY_SIZE(stub_definitions));
3681
3682   size = find_stub_size_and_template (stub_entry->stub_type, &template_sequence,
3683                                       &template_size);
3684
3685   stub_entry->stub_size = size;
3686   stub_entry->stub_template = template_sequence;
3687   stub_entry->stub_template_size = template_size;
3688
3689   size = (size + 7) & ~7;
3690   stub_entry->stub_sec->size += size;
3691
3692   return TRUE;
3693 }
3694
3695 /* External entry points for sizing and building linker stubs.  */
3696
3697 /* Set up various things so that we can make a list of input sections
3698    for each output section included in the link.  Returns -1 on error,
3699    0 when no stubs will be needed, and 1 on success.  */
3700
3701 int
3702 elf32_arm_setup_section_lists (bfd *output_bfd,
3703                                struct bfd_link_info *info)
3704 {
3705   bfd *input_bfd;
3706   unsigned int bfd_count;
3707   int top_id, top_index;
3708   asection *section;
3709   asection **input_list, **list;
3710   bfd_size_type amt;
3711   struct elf32_arm_link_hash_table *htab = elf32_arm_hash_table (info);
3712
3713   if (! is_elf_hash_table (htab))
3714     return 0;
3715
3716   /* Count the number of input BFDs and find the top input section id.  */
3717   for (input_bfd = info->input_bfds, bfd_count = 0, top_id = 0;
3718        input_bfd != NULL;
3719        input_bfd = input_bfd->link_next)
3720     {
3721       bfd_count += 1;
3722       for (section = input_bfd->sections;
3723            section != NULL;
3724            section = section->next)
3725         {
3726           if (top_id < section->id)
3727             top_id = section->id;
3728         }
3729     }
3730   htab->bfd_count = bfd_count;
3731
3732   amt = sizeof (struct map_stub) * (top_id + 1);
3733   htab->stub_group = (struct map_stub *) bfd_zmalloc (amt);
3734   if (htab->stub_group == NULL)
3735     return -1;
3736
3737   /* We can't use output_bfd->section_count here to find the top output
3738      section index as some sections may have been removed, and
3739      _bfd_strip_section_from_output doesn't renumber the indices.  */
3740   for (section = output_bfd->sections, top_index = 0;
3741        section != NULL;
3742        section = section->next)
3743     {
3744       if (top_index < section->index)
3745         top_index = section->index;
3746     }
3747
3748   htab->top_index = top_index;
3749   amt = sizeof (asection *) * (top_index + 1);
3750   input_list = (asection **) bfd_malloc (amt);
3751   htab->input_list = input_list;
3752   if (input_list == NULL)
3753     return -1;
3754
3755   /* For sections we aren't interested in, mark their entries with a
3756      value we can check later.  */
3757   list = input_list + top_index;
3758   do
3759     *list = bfd_abs_section_ptr;
3760   while (list-- != input_list);
3761
3762   for (section = output_bfd->sections;
3763        section != NULL;
3764        section = section->next)
3765     {
3766       if ((section->flags & SEC_CODE) != 0)
3767         input_list[section->index] = NULL;
3768     }
3769
3770   return 1;
3771 }
3772
3773 /* The linker repeatedly calls this function for each input section,
3774    in the order that input sections are linked into output sections.
3775    Build lists of input sections to determine groupings between which
3776    we may insert linker stubs.  */
3777
3778 void
3779 elf32_arm_next_input_section (struct bfd_link_info *info,
3780                               asection *isec)
3781 {
3782   struct elf32_arm_link_hash_table *htab = elf32_arm_hash_table (info);
3783
3784   if (isec->output_section->index <= htab->top_index)
3785     {
3786       asection **list = htab->input_list + isec->output_section->index;
3787
3788       if (*list != bfd_abs_section_ptr && (isec->flags & SEC_CODE) != 0)
3789         {
3790           /* Steal the link_sec pointer for our list.  */
3791 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
3792           /* This happens to make the list in reverse order,
3793              which we reverse later.  */
3794           PREV_SEC (isec) = *list;
3795           *list = isec;
3796         }
3797     }
3798 }
3799
3800 /* See whether we can group stub sections together.  Grouping stub
3801    sections may result in fewer stubs.  More importantly, we need to
3802    put all .init* and .fini* stubs at the end of the .init or
3803    .fini output sections respectively, because glibc splits the
3804    _init and _fini functions into multiple parts.  Putting a stub in
3805    the middle of a function is not a good idea.  */
3806
3807 static void
3808 group_sections (struct elf32_arm_link_hash_table *htab,
3809                 bfd_size_type stub_group_size,
3810                 bfd_boolean stubs_always_after_branch)
3811 {
3812   asection **list = htab->input_list;
3813
3814   do
3815     {
3816       asection *tail = *list;
3817       asection *head;
3818
3819       if (tail == bfd_abs_section_ptr)
3820         continue;
3821
3822       /* Reverse the list: we must avoid placing stubs at the
3823          beginning of the section because the beginning of the text
3824          section may be required for an interrupt vector in bare metal
3825          code.  */
3826 #define NEXT_SEC PREV_SEC
3827       head = NULL;
3828       while (tail != NULL)
3829         {
3830           /* Pop from tail.  */
3831           asection *item = tail;
3832           tail = PREV_SEC (item);
3833
3834           /* Push on head.  */
3835           NEXT_SEC (item) = head;
3836           head = item;
3837         }
3838
3839       while (head != NULL)
3840         {
3841           asection *curr;
3842           asection *next;
3843           bfd_vma stub_group_start = head->output_offset;
3844           bfd_vma end_of_next;
3845
3846           curr = head;
3847           while (NEXT_SEC (curr) != NULL)
3848             {
3849               next = NEXT_SEC (curr);
3850               end_of_next = next->output_offset + next->size;
3851               if (end_of_next - stub_group_start >= stub_group_size)
3852                 /* End of NEXT is too far from start, so stop.  */
3853                 break;
3854               /* Add NEXT to the group.  */
3855               curr = next;
3856             }
3857
3858           /* OK, the size from the start to the start of CURR is less
3859              than stub_group_size and thus can be handled by one stub
3860              section.  (Or the head section is itself larger than
3861              stub_group_size, in which case we may be toast.)
3862              We should really be keeping track of the total size of
3863              stubs added here, as stubs contribute to the final output
3864              section size.  */
3865           do
3866             {
3867               next = NEXT_SEC (head);
3868               /* Set up this stub group.  */
3869               htab->stub_group[head->id].link_sec = curr;
3870             }
3871           while (head != curr && (head = next) != NULL);
3872
3873           /* But wait, there's more!  Input sections up to stub_group_size
3874              bytes after the stub section can be handled by it too.  */
3875           if (!stubs_always_after_branch)
3876             {
3877               stub_group_start = curr->output_offset + curr->size;
3878
3879               while (next != NULL)
3880                 {
3881                   end_of_next = next->output_offset + next->size;
3882                   if (end_of_next - stub_group_start >= stub_group_size)
3883                     /* End of NEXT is too far from stubs, so stop.  */
3884                     break;
3885                   /* Add NEXT to the stub group.  */
3886                   head = next;
3887                   next = NEXT_SEC (head);
3888                   htab->stub_group[head->id].link_sec = curr;
3889                 }
3890             }
3891           head = next;
3892         }
3893     }
3894   while (list++ != htab->input_list + htab->top_index);
3895
3896   free (htab->input_list);
3897 #undef PREV_SEC
3898 #undef NEXT_SEC
3899 }
3900
3901 /* Comparison function for sorting/searching relocations relating to Cortex-A8
3902    erratum fix.  */
3903
3904 static int
3905 a8_reloc_compare (const void *a, const void *b)
3906 {
3907   const struct a8_erratum_reloc *ra = (const struct a8_erratum_reloc *) a;
3908   const struct a8_erratum_reloc *rb = (const struct a8_erratum_reloc *) b;
3909
3910   if (ra->from < rb->from)
3911     return -1;
3912   else if (ra->from > rb->from)
3913     return 1;
3914   else
3915     return 0;
3916 }
3917
3918 static struct elf_link_hash_entry *find_thumb_glue (struct bfd_link_info *,
3919                                                     const char *, char **);
3920
3921 /* Helper function to scan code for sequences which might trigger the Cortex-A8
3922    branch/TLB erratum.  Fill in the table described by A8_FIXES_P,
3923    NUM_A8_FIXES_P, A8_FIX_TABLE_SIZE_P.  Returns true if an error occurs, false
3924    otherwise.  */
3925
3926 static bfd_boolean
3927 cortex_a8_erratum_scan (bfd *input_bfd,
3928                         struct bfd_link_info *info,
3929                         struct a8_erratum_fix **a8_fixes_p,
3930                         unsigned int *num_a8_fixes_p,
3931                         unsigned int *a8_fix_table_size_p,
3932                         struct a8_erratum_reloc *a8_relocs,
3933                         unsigned int num_a8_relocs,
3934                         unsigned prev_num_a8_fixes,
3935                         bfd_boolean *stub_changed_p)
3936 {
3937   asection *section;
3938   struct elf32_arm_link_hash_table *htab = elf32_arm_hash_table (info);
3939   struct a8_erratum_fix *a8_fixes = *a8_fixes_p;
3940   unsigned int num_a8_fixes = *num_a8_fixes_p;
3941   unsigned int a8_fix_table_size = *a8_fix_table_size_p;
3942
3943   for (section = input_bfd->sections;
3944        section != NULL;
3945        section = section->next)
3946     {
3947       bfd_byte *contents = NULL;
3948       struct _arm_elf_section_data *sec_data;
3949       unsigned int span;
3950       bfd_vma base_vma;
3951
3952       if (elf_section_type (section) != SHT_PROGBITS
3953           || (elf_section_flags (section) & SHF_EXECINSTR) == 0
3954           || (section->flags & SEC_EXCLUDE) != 0
3955           || (section->sec_info_type == ELF_INFO_TYPE_JUST_SYMS)
3956           || (section->output_section == bfd_abs_section_ptr))
3957         continue;
3958
3959       base_vma = section->output_section->vma + section->output_offset;
3960
3961       if (elf_section_data (section)->this_hdr.contents != NULL)
3962         contents = elf_section_data (section)->this_hdr.contents;
3963       else if (! bfd_malloc_and_get_section (input_bfd, section, &contents))
3964         return TRUE;
3965
3966       sec_data = elf32_arm_section_data (section);
3967
3968       for (span = 0; span < sec_data->mapcount; span++)
3969         {
3970           unsigned int span_start = sec_data->map[span].vma;
3971           unsigned int span_end = (span == sec_data->mapcount - 1)
3972             ? section->size : sec_data->map[span + 1].vma;
3973           unsigned int i;
3974           char span_type = sec_data->map[span].type;
3975           bfd_boolean last_was_32bit = FALSE, last_was_branch = FALSE;
3976
3977           if (span_type != 't')
3978             continue;
3979
3980           /* Span is entirely within a single 4KB region: skip scanning.  */
3981           if (((base_vma + span_start) & ~0xfff)
3982               == ((base_vma + span_end) & ~0xfff))
3983             continue;
3984
3985           /* Scan for 32-bit Thumb-2 branches which span two 4K regions, where:
3986
3987                * The opcode is BLX.W, BL.W, B.W, Bcc.W
3988                * The branch target is in the same 4KB region as the
3989                  first half of the branch.
3990                * The instruction before the branch is a 32-bit
3991                  length non-branch instruction.  */
3992           for (i = span_start; i < span_end;)
3993             {
3994               unsigned int insn = bfd_getl16 (&contents[i]);
3995               bfd_boolean insn_32bit = FALSE, is_blx = FALSE, is_b = FALSE;
3996               bfd_boolean is_bl = FALSE, is_bcc = FALSE, is_32bit_branch;
3997
3998               if ((insn & 0xe000) == 0xe000 && (insn & 0x1800) != 0x0000)
3999                 insn_32bit = TRUE;
4000
4001               if (insn_32bit)
4002                 {
4003                   /* Load the rest of the insn (in manual-friendly order).  */
4004                   insn = (insn << 16) | bfd_getl16 (&contents[i + 2]);
4005
4006                   /* Encoding T4: B<c>.W.  */
4007                   is_b = (insn & 0xf800d000) == 0xf0009000;
4008                   /* Encoding T1: BL<c>.W.  */
4009                   is_bl = (insn & 0xf800d000) == 0xf000d000;
4010                   /* Encoding T2: BLX<c>.W.  */
4011                   is_blx = (insn & 0xf800d000) == 0xf000c000;
4012                   /* Encoding T3: B<c>.W (not permitted in IT block).  */
4013                   is_bcc = (insn & 0xf800d000) == 0xf0008000
4014                            && (insn & 0x07f00000) != 0x03800000;
4015                 }
4016
4017               is_32bit_branch = is_b || is_bl || is_blx || is_bcc;
4018
4019               if (((base_vma + i) & 0xfff) == 0xffe
4020                   && insn_32bit
4021                   && is_32bit_branch
4022                   && last_was_32bit
4023                   && ! last_was_branch)
4024                 {
4025                   bfd_signed_vma offset;
4026                   bfd_boolean force_target_arm = FALSE;
4027                   bfd_boolean force_target_thumb = FALSE;
4028                   bfd_vma target;
4029                   enum elf32_arm_stub_type stub_type = arm_stub_none;
4030                   struct a8_erratum_reloc key, *found;
4031
4032                   key.from = base_vma + i;
4033                   found = (struct a8_erratum_reloc *)
4034                       bsearch (&key, a8_relocs, num_a8_relocs,
4035                                sizeof (struct a8_erratum_reloc),
4036                                &a8_reloc_compare);
4037
4038                   if (found)
4039                     {
4040                       char *error_message = NULL;
4041                       struct elf_link_hash_entry *entry;
4042
4043                       /* We don't care about the error returned from this
4044                          function, only if there is glue or not.  */
4045                       entry = find_thumb_glue (info, found->sym_name,
4046                                                &error_message);
4047
4048                       if (entry)
4049                         found->non_a8_stub = TRUE;
4050
4051                       if (found->r_type == R_ARM_THM_CALL
4052                           && found->st_type != STT_ARM_TFUNC)
4053                         force_target_arm = TRUE;
4054                       else if (found->r_type == R_ARM_THM_CALL
4055                                && found->st_type == STT_ARM_TFUNC)
4056                         force_target_thumb = TRUE;
4057                     }
4058
4059                   /* Check if we have an offending branch instruction.  */
4060
4061                   if (found && found->non_a8_stub)
4062                     /* We've already made a stub for this instruction, e.g.
4063                        it's a long branch or a Thumb->ARM stub.  Assume that
4064                        stub will suffice to work around the A8 erratum (see
4065                        setting of always_after_branch above).  */
4066                     ;
4067                   else if (is_bcc)
4068                     {
4069                       offset = (insn & 0x7ff) << 1;
4070                       offset |= (insn & 0x3f0000) >> 4;
4071                       offset |= (insn & 0x2000) ? 0x40000 : 0;
4072                       offset |= (insn & 0x800) ? 0x80000 : 0;
4073                       offset |= (insn & 0x4000000) ? 0x100000 : 0;
4074                       if (offset & 0x100000)
4075                         offset |= ~ ((bfd_signed_vma) 0xfffff);
4076                       stub_type = arm_stub_a8_veneer_b_cond;
4077                     }
4078                   else if (is_b || is_bl || is_blx)
4079                     {
4080                       int s = (insn & 0x4000000) != 0;
4081                       int j1 = (insn & 0x2000) != 0;
4082                       int j2 = (insn & 0x800) != 0;
4083                       int i1 = !(j1 ^ s);
4084                       int i2 = !(j2 ^ s);
4085
4086                       offset = (insn & 0x7ff) << 1;
4087                       offset |= (insn & 0x3ff0000) >> 4;
4088                       offset |= i2 << 22;
4089                       offset |= i1 << 23;
4090                       offset |= s << 24;
4091                       if (offset & 0x1000000)
4092                         offset |= ~ ((bfd_signed_vma) 0xffffff);
4093
4094                       if (is_blx)
4095                         offset &= ~ ((bfd_signed_vma) 3);
4096
4097                       stub_type = is_blx ? arm_stub_a8_veneer_blx :
4098                         is_bl ? arm_stub_a8_veneer_bl : arm_stub_a8_veneer_b;
4099                     }
4100
4101                   if (stub_type != arm_stub_none)
4102                     {
4103                       bfd_vma pc_for_insn = base_vma + i + 4;
4104
4105                       /* The original instruction is a BL, but the target is
4106                          an ARM instruction.  If we were not making a stub,
4107                          the BL would have been converted to a BLX.  Use the
4108                          BLX stub instead in that case.  */
4109                       if (htab->use_blx && force_target_arm
4110                           && stub_type == arm_stub_a8_veneer_bl)
4111                         {
4112                           stub_type = arm_stub_a8_veneer_blx;
4113                           is_blx = TRUE;
4114                           is_bl = FALSE;
4115                         }
4116                       /* Conversely, if the original instruction was
4117                          BLX but the target is Thumb mode, use the BL
4118                          stub.  */
4119                       else if (force_target_thumb
4120                                && stub_type == arm_stub_a8_veneer_blx)
4121                         {
4122                           stub_type = arm_stub_a8_veneer_bl;
4123                           is_blx = FALSE;
4124                           is_bl = TRUE;
4125                         }
4126
4127                       if (is_blx)
4128                         pc_for_insn &= ~ ((bfd_vma) 3);
4129
4130                       /* If we found a relocation, use the proper destination,
4131                          not the offset in the (unrelocated) instruction.
4132                          Note this is always done if we switched the stub type
4133                          above.  */
4134                       if (found)
4135                         offset =
4136                           (bfd_signed_vma) (found->destination - pc_for_insn);
4137
4138                       target = pc_for_insn + offset;
4139
4140                       /* The BLX stub is ARM-mode code.  Adjust the offset to
4141                          take the different PC value (+8 instead of +4) into
4142                          account.  */
4143                       if (stub_type == arm_stub_a8_veneer_blx)
4144                         offset += 4;
4145
4146                       if (((base_vma + i) & ~0xfff) == (target & ~0xfff))
4147                         {
4148                           char *stub_name = NULL;
4149
4150                           if (num_a8_fixes == a8_fix_table_size)
4151                             {
4152                               a8_fix_table_size *= 2;
4153                               a8_fixes = (struct a8_erratum_fix *)
4154                                   bfd_realloc (a8_fixes,
4155                                                sizeof (struct a8_erratum_fix)
4156                                                * a8_fix_table_size);
4157                             }
4158
4159                           if (num_a8_fixes < prev_num_a8_fixes)
4160                             {
4161                               /* If we're doing a subsequent scan,
4162                                  check if we've found the same fix as
4163                                  before, and try and reuse the stub
4164                                  name.  */
4165                               stub_name = a8_fixes[num_a8_fixes].stub_name;
4166                               if ((a8_fixes[num_a8_fixes].section != section)
4167                                   || (a8_fixes[num_a8_fixes].offset != i))
4168                                 {
4169                                   free (stub_name);
4170                                   stub_name = NULL;
4171                                   *stub_changed_p = TRUE;
4172                                 }
4173                             }
4174
4175                           if (!stub_name)
4176                             {
4177                               stub_name = (char *) bfd_malloc (8 + 1 + 8 + 1);
4178                               if (stub_name != NULL)
4179                                 sprintf (stub_name, "%x:%x", section->id, i);
4180                             }
4181
4182                           a8_fixes[num_a8_fixes].input_bfd = input_bfd;
4183                           a8_fixes[num_a8_fixes].section = section;
4184                           a8_fixes[num_a8_fixes].offset = i;
4185                           a8_fixes[num_a8_fixes].addend = offset;
4186                           a8_fixes[num_a8_fixes].orig_insn = insn;
4187                           a8_fixes[num_a8_fixes].stub_name = stub_name;
4188                           a8_fixes[num_a8_fixes].stub_type = stub_type;
4189
4190                           num_a8_fixes++;
4191                         }
4192                     }
4193                 }
4194
4195               i += insn_32bit ? 4 : 2;
4196               last_was_32bit = insn_32bit;
4197               last_was_branch = is_32bit_branch;
4198             }
4199         }
4200
4201       if (elf_section_data (section)->this_hdr.contents == NULL)
4202         free (contents);
4203     }
4204
4205   *a8_fixes_p = a8_fixes;
4206   *num_a8_fixes_p = num_a8_fixes;
4207   *a8_fix_table_size_p = a8_fix_table_size;
4208
4209   return FALSE;
4210 }
4211
4212 /* Determine and set the size of the stub section for a final link.
4213
4214    The basic idea here is to examine all the relocations looking for
4215    PC-relative calls to a target that is unreachable with a "bl"
4216    instruction.  */
4217
4218 bfd_boolean
4219 elf32_arm_size_stubs (bfd *output_bfd,
4220                       bfd *stub_bfd,
4221                       struct bfd_link_info *info,
4222                       bfd_signed_vma group_size,
4223                       asection * (*add_stub_section) (const char *, asection *),
4224                       void (*layout_sections_again) (void))
4225 {
4226   bfd_size_type stub_group_size;
4227   bfd_boolean stubs_always_after_branch;
4228   struct elf32_arm_link_hash_table *htab = elf32_arm_hash_table (info);
4229   struct a8_erratum_fix *a8_fixes = NULL;
4230   unsigned int num_a8_fixes = 0, a8_fix_table_size = 10;
4231   struct a8_erratum_reloc *a8_relocs = NULL;
4232   unsigned int num_a8_relocs = 0, a8_reloc_table_size = 10, i;
4233
4234   if (htab->fix_cortex_a8)
4235     {
4236       a8_fixes = (struct a8_erratum_fix *)
4237           bfd_zmalloc (sizeof (struct a8_erratum_fix) * a8_fix_table_size);
4238       a8_relocs = (struct a8_erratum_reloc *)
4239           bfd_zmalloc (sizeof (struct a8_erratum_reloc) * a8_reloc_table_size);
4240     }
4241
4242   /* Propagate mach to stub bfd, because it may not have been
4243      finalized when we created stub_bfd.  */
4244   bfd_set_arch_mach (stub_bfd, bfd_get_arch (output_bfd),
4245                      bfd_get_mach (output_bfd));
4246
4247   /* Stash our params away.  */
4248   htab->stub_bfd = stub_bfd;
4249   htab->add_stub_section = add_stub_section;
4250   htab->layout_sections_again = layout_sections_again;
4251   stubs_always_after_branch = group_size < 0;
4252
4253   /* The Cortex-A8 erratum fix depends on stubs not being in the same 4K page
4254      as the first half of a 32-bit branch straddling two 4K pages.  This is a
4255      crude way of enforcing that.  */
4256   if (htab->fix_cortex_a8)
4257     stubs_always_after_branch = 1;
4258
4259   if (group_size < 0)
4260     stub_group_size = -group_size;
4261   else
4262     stub_group_size = group_size;
4263
4264   if (stub_group_size == 1)
4265     {
4266       /* Default values.  */
4267       /* Thumb branch range is +-4MB has to be used as the default
4268          maximum size (a given section can contain both ARM and Thumb
4269          code, so the worst case has to be taken into account).
4270
4271          This value is 24K less than that, which allows for 2025
4272          12-byte stubs.  If we exceed that, then we will fail to link.
4273          The user will have to relink with an explicit group size
4274          option.  */
4275       stub_group_size = 4170000;
4276     }
4277
4278   group_sections (htab, stub_group_size, stubs_always_after_branch);
4279
4280   /* If we're applying the cortex A8 fix, we need to determine the
4281      program header size now, because we cannot change it later --
4282      that could alter section placements.  Notice the A8 erratum fix
4283      ends up requiring the section addresses to remain unchanged
4284      modulo the page size.  That's something we cannot represent
4285      inside BFD, and we don't want to force the section alignment to
4286      be the page size.  */
4287   if (htab->fix_cortex_a8)
4288     (*htab->layout_sections_again) ();
4289
4290   while (1)
4291     {
4292       bfd *input_bfd;
4293       unsigned int bfd_indx;
4294       asection *stub_sec;
4295       bfd_boolean stub_changed = FALSE;
4296       unsigned prev_num_a8_fixes = num_a8_fixes;
4297
4298       num_a8_fixes = 0;
4299       for (input_bfd = info->input_bfds, bfd_indx = 0;
4300            input_bfd != NULL;
4301            input_bfd = input_bfd->link_next, bfd_indx++)
4302         {
4303           Elf_Internal_Shdr *symtab_hdr;
4304           asection *section;
4305           Elf_Internal_Sym *local_syms = NULL;
4306
4307           num_a8_relocs = 0;
4308
4309           /* We'll need the symbol table in a second.  */
4310           symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
4311           if (symtab_hdr->sh_info == 0)
4312             continue;
4313
4314           /* Walk over each section attached to the input bfd.  */
4315           for (section = input_bfd->sections;
4316                section != NULL;
4317                section = section->next)
4318             {
4319               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
4320
4321               /* If there aren't any relocs, then there's nothing more
4322                  to do.  */
4323               if ((section->flags & SEC_RELOC) == 0
4324                   || section->reloc_count == 0
4325                   || (section->flags & SEC_CODE) == 0)
4326                 continue;
4327
4328               /* If this section is a link-once section that will be
4329                  discarded, then don't create any stubs.  */
4330               if (section->output_section == NULL
4331                   || section->output_section->owner != output_bfd)
4332                 continue;
4333
4334               /* Get the relocs.  */
4335               internal_relocs
4336                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL,
4337                                              NULL, info->keep_memory);
4338               if (internal_relocs == NULL)
4339                 goto error_ret_free_local;
4340
4341               /* Now examine each relocation.  */
4342               irela = internal_relocs;
4343               irelaend = irela + section->reloc_count;
4344               for (; irela < irelaend; irela++)
4345                 {
4346                   unsigned int r_type, r_indx;
4347                   enum elf32_arm_stub_type stub_type;
4348                   struct elf32_arm_stub_hash_entry *stub_entry;
4349                   asection *sym_sec;
4350                   bfd_vma sym_value;
4351                   bfd_vma destination;
4352                   struct elf32_arm_link_hash_entry *hash;
4353                   const char *sym_name;
4354                   char *stub_name;
4355                   const asection *id_sec;
4356                   unsigned char st_type;
4357                   bfd_boolean created_stub = FALSE;
4358
4359                   r_type = ELF32_R_TYPE (irela->r_info);
4360                   r_indx = ELF32_R_SYM (irela->r_info);
4361
4362                   if (r_type >= (unsigned int) R_ARM_max)
4363                     {
4364                       bfd_set_error (bfd_error_bad_value);
4365                     error_ret_free_internal:
4366                       if (elf_section_data (section)->relocs == NULL)
4367                         free (internal_relocs);
4368                       goto error_ret_free_local;
4369                     }
4370
4371                   /* Only look for stubs on branch instructions.  */
4372                   if ((r_type != (unsigned int) R_ARM_CALL)
4373                       && (r_type != (unsigned int) R_ARM_THM_CALL)
4374                       && (r_type != (unsigned int) R_ARM_JUMP24)
4375                       && (r_type != (unsigned int) R_ARM_THM_JUMP19)
4376                       && (r_type != (unsigned int) R_ARM_THM_XPC22)
4377                       && (r_type != (unsigned int) R_ARM_THM_JUMP24)
4378                       && (r_type != (unsigned int) R_ARM_PLT32))
4379                     continue;
4380
4381                   /* Now determine the call target, its name, value,
4382                      section.  */
4383                   sym_sec = NULL;
4384                   sym_value = 0;
4385                   destination = 0;
4386                   hash = NULL;
4387                   sym_name = NULL;
4388                   if (r_indx < symtab_hdr->sh_info)
4389                     {
4390                       /* It's a local symbol.  */
4391                       Elf_Internal_Sym *sym;
4392                       Elf_Internal_Shdr *hdr;
4393
4394                       if (local_syms == NULL)
4395                         {
4396                           local_syms
4397                             = (Elf_Internal_Sym *) symtab_hdr->contents;
4398                           if (local_syms == NULL)
4399                             local_syms
4400                               = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
4401                                                       symtab_hdr->sh_info, 0,
4402                                                       NULL, NULL, NULL);
4403                           if (local_syms == NULL)
4404                             goto error_ret_free_internal;
4405                         }
4406
4407                       sym = local_syms + r_indx;
4408                       hdr = elf_elfsections (input_bfd)[sym->st_shndx];
4409                       sym_sec = hdr->bfd_section;
4410                       if (!sym_sec)
4411                         /* This is an undefined symbol.  It can never
4412                            be resolved. */
4413                         continue;
4414
4415                       if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
4416                         sym_value = sym->st_value;
4417                       destination = (sym_value + irela->r_addend
4418                                      + sym_sec->output_offset
4419                                      + sym_sec->output_section->vma);
4420                       st_type = ELF_ST_TYPE (sym->st_info);
4421                       sym_name
4422                         = bfd_elf_string_from_elf_section (input_bfd,
4423                                                            symtab_hdr->sh_link,
4424                                                            sym->st_name);
4425                     }
4426                   else
4427                     {
4428                       /* It's an external symbol.  */
4429                       int e_indx;
4430
4431                       e_indx = r_indx - symtab_hdr->sh_info;
4432                       hash = ((struct elf32_arm_link_hash_entry *)
4433                               elf_sym_hashes (input_bfd)[e_indx]);
4434
4435                       while (hash->root.root.type == bfd_link_hash_indirect
4436                              || hash->root.root.type == bfd_link_hash_warning)
4437                         hash = ((struct elf32_arm_link_hash_entry *)
4438                                 hash->root.root.u.i.link);
4439
4440                       if (hash->root.root.type == bfd_link_hash_defined
4441                           || hash->root.root.type == bfd_link_hash_defweak)
4442                         {
4443                           sym_sec = hash->root.root.u.def.section;
4444                           sym_value = hash->root.root.u.def.value;
4445
4446                           struct elf32_arm_link_hash_table *globals =
4447                                                   elf32_arm_hash_table (info);
4448
4449                           /* For a destination in a shared library,
4450                              use the PLT stub as target address to
4451                              decide whether a branch stub is
4452                              needed.  */
4453                           if (globals->splt != NULL && hash != NULL
4454                               && hash->root.plt.offset != (bfd_vma) -1)
4455                             {
4456                               sym_sec = globals->splt;
4457                               sym_value = hash->root.plt.offset;
4458                               if (sym_sec->output_section != NULL)
4459                                 destination = (sym_value
4460                                                + sym_sec->output_offset
4461                                                + sym_sec->output_section->vma);
4462                             }
4463                           else if (sym_sec->output_section != NULL)
4464                             destination = (sym_value + irela->r_addend
4465                                            + sym_sec->output_offset
4466                                            + sym_sec->output_section->vma);
4467                         }
4468                       else if ((hash->root.root.type == bfd_link_hash_undefined)
4469                                || (hash->root.root.type == bfd_link_hash_undefweak))
4470                         {
4471                           /* For a shared library, use the PLT stub as
4472                              target address to decide whether a long
4473                              branch stub is needed.
4474                              For absolute code, they cannot be handled.  */
4475                           struct elf32_arm_link_hash_table *globals =
4476                             elf32_arm_hash_table (info);
4477
4478                           if (globals->splt != NULL && hash != NULL
4479                               && hash->root.plt.offset != (bfd_vma) -1)
4480                             {
4481                               sym_sec = globals->splt;
4482                               sym_value = hash->root.plt.offset;
4483                               if (sym_sec->output_section != NULL)
4484                                 destination = (sym_value
4485                                                + sym_sec->output_offset
4486                                                + sym_sec->output_section->vma);
4487                             }
4488                           else
4489                             continue;
4490                         }
4491                       else
4492                         {
4493                           bfd_set_error (bfd_error_bad_value);
4494                           goto error_ret_free_internal;
4495                         }
4496                       st_type = ELF_ST_TYPE (hash->root.type);
4497                       sym_name = hash->root.root.root.string;
4498                     }
4499
4500                   do
4501                     {
4502                       /* Determine what (if any) linker stub is needed.  */
4503                       stub_type = arm_type_of_stub (info, section, irela,
4504                                                     st_type, hash,
4505                                                     destination, sym_sec,
4506                                                     input_bfd, sym_name);
4507                       if (stub_type == arm_stub_none)
4508                         break;
4509
4510                       /* Support for grouping stub sections.  */
4511                       id_sec = htab->stub_group[section->id].link_sec;
4512
4513                       /* Get the name of this stub.  */
4514                       stub_name = elf32_arm_stub_name (id_sec, sym_sec, hash,
4515                                                        irela);
4516                       if (!stub_name)
4517                         goto error_ret_free_internal;
4518
4519                       /* We've either created a stub for this reloc already,
4520                          or we are about to.  */
4521                       created_stub = TRUE;
4522
4523                       stub_entry = arm_stub_hash_lookup
4524                                      (&htab->stub_hash_table, stub_name,
4525                                       FALSE, FALSE);
4526                       if (stub_entry != NULL)
4527                         {
4528                           /* The proper stub has already been created.  */
4529                           free (stub_name);
4530                           stub_entry->target_value = sym_value;
4531                           break;
4532                         }
4533
4534                       stub_entry = elf32_arm_add_stub (stub_name, section,
4535                                                        htab);
4536                       if (stub_entry == NULL)
4537                         {
4538                           free (stub_name);
4539                           goto error_ret_free_internal;
4540                         }
4541
4542                       stub_entry->target_value = sym_value;
4543                       stub_entry->target_section = sym_sec;
4544                       stub_entry->stub_type = stub_type;
4545                       stub_entry->h = hash;
4546                       stub_entry->st_type = st_type;
4547
4548                       if (sym_name == NULL)
4549                         sym_name = "unnamed";
4550                       stub_entry->output_name = (char *)
4551                           bfd_alloc (htab->stub_bfd,
4552                                      sizeof (THUMB2ARM_GLUE_ENTRY_NAME)
4553                                      + strlen (sym_name));
4554                       if (stub_entry->output_name == NULL)
4555                         {
4556                           free (stub_name);
4557                           goto error_ret_free_internal;
4558                         }
4559
4560                       /* For historical reasons, use the existing names for
4561                          ARM-to-Thumb and Thumb-to-ARM stubs.  */
4562                       if ( ((r_type == (unsigned int) R_ARM_THM_CALL)
4563                             || (r_type == (unsigned int) R_ARM_THM_JUMP24))
4564                            && st_type != STT_ARM_TFUNC)
4565                         sprintf (stub_entry->output_name,
4566                                  THUMB2ARM_GLUE_ENTRY_NAME, sym_name);
4567                       else if ( ((r_type == (unsigned int) R_ARM_CALL)
4568                                  || (r_type == (unsigned int) R_ARM_JUMP24))
4569                                && st_type == STT_ARM_TFUNC)
4570                         sprintf (stub_entry->output_name,
4571                                  ARM2THUMB_GLUE_ENTRY_NAME, sym_name);
4572                       else
4573                         sprintf (stub_entry->output_name, STUB_ENTRY_NAME,
4574                                  sym_name);
4575
4576                       stub_changed = TRUE;
4577                     }
4578                   while (0);
4579
4580                   /* Look for relocations which might trigger Cortex-A8
4581                      erratum.  */
4582                   if (htab->fix_cortex_a8
4583                       && (r_type == (unsigned int) R_ARM_THM_JUMP24
4584                           || r_type == (unsigned int) R_ARM_THM_JUMP19
4585                           || r_type == (unsigned int) R_ARM_THM_CALL
4586                           || r_type == (unsigned int) R_ARM_THM_XPC22))
4587                     {
4588                       bfd_vma from = section->output_section->vma
4589                                      + section->output_offset
4590                                      + irela->r_offset;
4591
4592                       if ((from & 0xfff) == 0xffe)
4593                         {
4594                           /* Found a candidate.  Note we haven't checked the
4595                              destination is within 4K here: if we do so (and
4596                              don't create an entry in a8_relocs) we can't tell
4597                              that a branch should have been relocated when
4598                              scanning later.  */
4599                           if (num_a8_relocs == a8_reloc_table_size)
4600                             {
4601                               a8_reloc_table_size *= 2;
4602                               a8_relocs = (struct a8_erratum_reloc *)
4603                                   bfd_realloc (a8_relocs,
4604                                                sizeof (struct a8_erratum_reloc)
4605                                                * a8_reloc_table_size);
4606                             }
4607
4608                           a8_relocs[num_a8_relocs].from = from;
4609                           a8_relocs[num_a8_relocs].destination = destination;
4610                           a8_relocs[num_a8_relocs].r_type = r_type;
4611                           a8_relocs[num_a8_relocs].st_type = st_type;
4612                           a8_relocs[num_a8_relocs].sym_name = sym_name;
4613                           a8_relocs[num_a8_relocs].non_a8_stub = created_stub;
4614
4615                           num_a8_relocs++;
4616                         }
4617                     }
4618                 }
4619
4620               /* We're done with the internal relocs, free them.  */
4621               if (elf_section_data (section)->relocs == NULL)
4622                 free (internal_relocs);
4623             }
4624
4625           if (htab->fix_cortex_a8)
4626             {
4627               /* Sort relocs which might apply to Cortex-A8 erratum.  */
4628               qsort (a8_relocs, num_a8_relocs,
4629                      sizeof (struct a8_erratum_reloc),
4630                      &a8_reloc_compare);
4631
4632               /* Scan for branches which might trigger Cortex-A8 erratum.  */
4633               if (cortex_a8_erratum_scan (input_bfd, info, &a8_fixes,
4634                                           &num_a8_fixes, &a8_fix_table_size,
4635                                           a8_relocs, num_a8_relocs,
4636                                           prev_num_a8_fixes, &stub_changed)
4637                   != 0)
4638                 goto error_ret_free_local;
4639             }
4640         }
4641
4642       if (prev_num_a8_fixes != num_a8_fixes)
4643         stub_changed = TRUE;
4644
4645       if (!stub_changed)
4646         break;
4647
4648       /* OK, we've added some stubs.  Find out the new size of the
4649          stub sections.  */
4650       for (stub_sec = htab->stub_bfd->sections;
4651            stub_sec != NULL;
4652            stub_sec = stub_sec->next)
4653         {
4654           /* Ignore non-stub sections.  */
4655           if (!strstr (stub_sec->name, STUB_SUFFIX))
4656             continue;
4657
4658           stub_sec->size = 0;
4659         }
4660
4661       bfd_hash_traverse (&htab->stub_hash_table, arm_size_one_stub, htab);
4662
4663       /* Add Cortex-A8 erratum veneers to stub section sizes too.  */
4664       if (htab->fix_cortex_a8)
4665         for (i = 0; i < num_a8_fixes; i++)
4666           {
4667             stub_sec = elf32_arm_create_or_find_stub_sec (NULL,
4668                          a8_fixes[i].section, htab);
4669
4670             if (stub_sec == NULL)
4671               goto error_ret_free_local;
4672
4673             stub_sec->size
4674               += find_stub_size_and_template (a8_fixes[i].stub_type, NULL,
4675                                               NULL);
4676           }
4677
4678
4679       /* Ask the linker to do its stuff.  */
4680       (*htab->layout_sections_again) ();
4681     }
4682
4683   /* Add stubs for Cortex-A8 erratum fixes now.  */
4684   if (htab->fix_cortex_a8)
4685     {
4686       for (i = 0; i < num_a8_fixes; i++)
4687         {
4688           struct elf32_arm_stub_hash_entry *stub_entry;
4689           char *stub_name = a8_fixes[i].stub_name;
4690           asection *section = a8_fixes[i].section;
4691           unsigned int section_id = a8_fixes[i].section->id;
4692           asection *link_sec = htab->stub_group[section_id].link_sec;
4693           asection *stub_sec = htab->stub_group[section_id].stub_sec;
4694           const insn_sequence *template_sequence;
4695           int template_size, size = 0;
4696
4697           stub_entry = arm_stub_hash_lookup (&htab->stub_hash_table, stub_name,
4698                                              TRUE, FALSE);
4699           if (stub_entry == NULL)
4700             {
4701               (*_bfd_error_handler) (_("%s: cannot create stub entry %s"),
4702                                      section->owner,
4703                                      stub_name);
4704               return FALSE;
4705             }
4706
4707           stub_entry->stub_sec = stub_sec;
4708           stub_entry->stub_offset = 0;
4709           stub_entry->id_sec = link_sec;
4710           stub_entry->stub_type = a8_fixes[i].stub_type;
4711           stub_entry->target_section = a8_fixes[i].section;
4712           stub_entry->target_value = a8_fixes[i].offset;
4713           stub_entry->target_addend = a8_fixes[i].addend;
4714           stub_entry->orig_insn = a8_fixes[i].orig_insn;
4715           stub_entry->st_type = STT_ARM_TFUNC;
4716
4717           size = find_stub_size_and_template (a8_fixes[i].stub_type,
4718                                               &template_sequence,
4719                                               &template_size);
4720
4721           stub_entry->stub_size = size;
4722           stub_entry->stub_template = template_sequence;
4723           stub_entry->stub_template_size = template_size;
4724         }
4725
4726       /* Stash the Cortex-A8 erratum fix array for use later in
4727          elf32_arm_write_section().  */
4728       htab->a8_erratum_fixes = a8_fixes;
4729       htab->num_a8_erratum_fixes = num_a8_fixes;
4730     }
4731   else
4732     {
4733       htab->a8_erratum_fixes = NULL;
4734       htab->num_a8_erratum_fixes = 0;
4735     }
4736   return TRUE;
4737
4738  error_ret_free_local:
4739   return FALSE;
4740 }
4741
4742 /* Build all the stubs associated with the current output file.  The
4743    stubs are kept in a hash table attached to the main linker hash
4744    table.  We also set up the .plt entries for statically linked PIC
4745    functions here.  This function is called via arm_elf_finish in the
4746    linker.  */
4747
4748 bfd_boolean
4749 elf32_arm_build_stubs (struct bfd_link_info *info)
4750 {
4751   asection *stub_sec;
4752   struct bfd_hash_table *table;
4753   struct elf32_arm_link_hash_table *htab;
4754
4755   htab = elf32_arm_hash_table (info);
4756
4757   for (stub_sec = htab->stub_bfd->sections;
4758        stub_sec != NULL;
4759        stub_sec = stub_sec->next)
4760     {
4761       bfd_size_type size;
4762
4763       /* Ignore non-stub sections.  */
4764       if (!strstr (stub_sec->name, STUB_SUFFIX))
4765         continue;
4766
4767       /* Allocate memory to hold the linker stubs.  */
4768       size = stub_sec->size;
4769       stub_sec->contents = (unsigned char *) bfd_zalloc (htab->stub_bfd, size);
4770       if (stub_sec->contents == NULL && size != 0)
4771         return FALSE;
4772       stub_sec->size = 0;
4773     }
4774
4775   /* Build the stubs as directed by the stub hash table.  */
4776   table = &htab->stub_hash_table;
4777   bfd_hash_traverse (table, arm_build_one_stub, info);
4778   if (htab->fix_cortex_a8)
4779     {
4780       /* Place the cortex a8 stubs last.  */
4781       htab->fix_cortex_a8 = -1;
4782       bfd_hash_traverse (table, arm_build_one_stub, info);
4783     }
4784
4785   return TRUE;
4786 }
4787
4788 /* Locate the Thumb encoded calling stub for NAME.  */
4789
4790 static struct elf_link_hash_entry *
4791 find_thumb_glue (struct bfd_link_info *link_info,
4792                  const char *name,
4793                  char **error_message)
4794 {
4795   char *tmp_name;
4796   struct elf_link_hash_entry *hash;
4797   struct elf32_arm_link_hash_table *hash_table;
4798
4799   /* We need a pointer to the armelf specific hash table.  */
4800   hash_table = elf32_arm_hash_table (link_info);
4801
4802   tmp_name = (char *) bfd_malloc ((bfd_size_type) strlen (name)
4803                                   + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1);
4804
4805   BFD_ASSERT (tmp_name);
4806
4807   sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name);
4808
4809   hash = elf_link_hash_lookup
4810     (&(hash_table)->root, tmp_name, FALSE, FALSE, TRUE);
4811
4812   if (hash == NULL
4813       && asprintf (error_message, _("unable to find THUMB glue '%s' for '%s'"),
4814                    tmp_name, name) == -1)
4815     *error_message = (char *) bfd_errmsg (bfd_error_system_call);
4816
4817   free (tmp_name);
4818
4819   return hash;
4820 }
4821
4822 /* Locate the ARM encoded calling stub for NAME.  */
4823
4824 static struct elf_link_hash_entry *
4825 find_arm_glue (struct bfd_link_info *link_info,
4826                const char *name,
4827                char **error_message)
4828 {
4829   char *tmp_name;
4830   struct elf_link_hash_entry *myh;
4831   struct elf32_arm_link_hash_table *hash_table;
4832
4833   /* We need a pointer to the elfarm specific hash table.  */
4834   hash_table = elf32_arm_hash_table (link_info);
4835
4836   tmp_name = (char *) bfd_malloc ((bfd_size_type) strlen (name)
4837                                   + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1);
4838
4839   BFD_ASSERT (tmp_name);
4840
4841   sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
4842
4843   myh = elf_link_hash_lookup
4844     (&(hash_table)->root, tmp_name, FALSE, FALSE, TRUE);
4845
4846   if (myh == NULL
4847       && asprintf (error_message, _("unable to find ARM glue '%s' for '%s'"),
4848                    tmp_name, name) == -1)
4849     *error_message = (char *) bfd_errmsg (bfd_error_system_call);
4850
4851   free (tmp_name);
4852
4853   return myh;
4854 }
4855
4856 /* ARM->Thumb glue (static images):
4857
4858    .arm
4859    __func_from_arm:
4860    ldr r12, __func_addr
4861    bx  r12
4862    __func_addr:
4863    .word func    @ behave as if you saw a ARM_32 reloc.
4864
4865    (v5t static images)
4866    .arm
4867    __func_from_arm:
4868    ldr pc, __func_addr
4869    __func_addr:
4870    .word func    @ behave as if you saw a ARM_32 reloc.
4871
4872    (relocatable images)
4873    .arm
4874    __func_from_arm:
4875    ldr r12, __func_offset
4876    add r12, r12, pc
4877    bx  r12
4878    __func_offset:
4879    .word func - .   */
4880
4881 #define ARM2THUMB_STATIC_GLUE_SIZE 12
4882 static const insn32 a2t1_ldr_insn = 0xe59fc000;
4883 static const insn32 a2t2_bx_r12_insn = 0xe12fff1c;
4884 static const insn32 a2t3_func_addr_insn = 0x00000001;
4885
4886 #define ARM2THUMB_V5_STATIC_GLUE_SIZE 8
4887 static const insn32 a2t1v5_ldr_insn = 0xe51ff004;
4888 static const insn32 a2t2v5_func_addr_insn = 0x00000001;
4889
4890 #define ARM2THUMB_PIC_GLUE_SIZE 16
4891 static const insn32 a2t1p_ldr_insn = 0xe59fc004;
4892 static const insn32 a2t2p_add_pc_insn = 0xe08cc00f;
4893 static const insn32 a2t3p_bx_r12_insn = 0xe12fff1c;
4894
4895 /* Thumb->ARM:                          Thumb->(non-interworking aware) ARM
4896
4897      .thumb                             .thumb
4898      .align 2                           .align 2
4899  __func_from_thumb:                 __func_from_thumb:
4900      bx pc                              push {r6, lr}
4901      nop                                ldr  r6, __func_addr
4902      .arm                               mov  lr, pc
4903      b func                             bx   r6
4904                                         .arm
4905                                     ;; back_to_thumb
4906                                         ldmia r13! {r6, lr}
4907                                         bx    lr
4908                                     __func_addr:
4909                                         .word        func  */
4910
4911 #define THUMB2ARM_GLUE_SIZE 8
4912 static const insn16 t2a1_bx_pc_insn = 0x4778;
4913 static const insn16 t2a2_noop_insn = 0x46c0;
4914 static const insn32 t2a3_b_insn = 0xea000000;
4915
4916 #define VFP11_ERRATUM_VENEER_SIZE 8
4917
4918 #define ARM_BX_VENEER_SIZE 12
4919 static const insn32 armbx1_tst_insn = 0xe3100001;
4920 static const insn32 armbx2_moveq_insn = 0x01a0f000;
4921 static const insn32 armbx3_bx_insn = 0xe12fff10;
4922
4923 #ifndef ELFARM_NABI_C_INCLUDED
4924 static void
4925 arm_allocate_glue_section_space (bfd * abfd, bfd_size_type size, const char * name)
4926 {
4927   asection * s;
4928   bfd_byte * contents;
4929
4930   if (size == 0)
4931     {
4932       /* Do not include empty glue sections in the output.  */
4933       if (abfd != NULL)
4934         {
4935           s = bfd_get_section_by_name (abfd, name);
4936           if (s != NULL)
4937             s->flags |= SEC_EXCLUDE;
4938         }
4939       return;
4940     }
4941
4942   BFD_ASSERT (abfd != NULL);
4943
4944   s = bfd_get_section_by_name (abfd, name);
4945   BFD_ASSERT (s != NULL);
4946
4947   contents = (bfd_byte *) bfd_alloc (abfd, size);
4948
4949   BFD_ASSERT (s->size == size);
4950   s->contents = contents;
4951 }
4952
4953 bfd_boolean
4954 bfd_elf32_arm_allocate_interworking_sections (struct bfd_link_info * info)
4955 {
4956   struct elf32_arm_link_hash_table * globals;
4957
4958   globals = elf32_arm_hash_table (info);
4959   BFD_ASSERT (globals != NULL);
4960
4961   arm_allocate_glue_section_space (globals->bfd_of_glue_owner,
4962                                    globals->arm_glue_size,
4963                                    ARM2THUMB_GLUE_SECTION_NAME);
4964
4965   arm_allocate_glue_section_space (globals->bfd_of_glue_owner,
4966                                    globals->thumb_glue_size,
4967                                    THUMB2ARM_GLUE_SECTION_NAME);
4968
4969   arm_allocate_glue_section_space (globals->bfd_of_glue_owner,
4970                                    globals->vfp11_erratum_glue_size,
4971                                    VFP11_ERRATUM_VENEER_SECTION_NAME);
4972
4973   arm_allocate_glue_section_space (globals->bfd_of_glue_owner,
4974                                    globals->bx_glue_size,
4975                                    ARM_BX_GLUE_SECTION_NAME);
4976
4977   return TRUE;
4978 }
4979
4980 /* Allocate space and symbols for calling a Thumb function from Arm mode.
4981    returns the symbol identifying the stub.  */
4982
4983 static struct elf_link_hash_entry *
4984 record_arm_to_thumb_glue (struct bfd_link_info * link_info,
4985                           struct elf_link_hash_entry * h)
4986 {
4987   const char * name = h->root.root.string;
4988   asection * s;
4989   char * tmp_name;
4990   struct elf_link_hash_entry * myh;
4991   struct bfd_link_hash_entry * bh;
4992   struct elf32_arm_link_hash_table * globals;
4993   bfd_vma val;
4994   bfd_size_type size;
4995
4996   globals = elf32_arm_hash_table (link_info);
4997
4998   BFD_ASSERT (globals != NULL);
4999   BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
5000
5001   s = bfd_get_section_by_name
5002     (globals->bfd_of_glue_owner, ARM2THUMB_GLUE_SECTION_NAME);
5003
5004   BFD_ASSERT (s != NULL);
5005
5006   tmp_name = (char *) bfd_malloc ((bfd_size_type) strlen (name)
5007                                   + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1);
5008
5009   BFD_ASSERT (tmp_name);
5010
5011   sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
5012
5013   myh = elf_link_hash_lookup
5014     (&(globals)->root, tmp_name, FALSE, FALSE, TRUE);
5015
5016   if (myh != NULL)
5017     {
5018       /* We've already seen this guy.  */
5019       free (tmp_name);
5020       return myh;
5021     }
5022
5023   /* The only trick here is using hash_table->arm_glue_size as the value.
5024      Even though the section isn't allocated yet, this is where we will be
5025      putting it.  The +1 on the value marks that the stub has not been
5026      output yet - not that it is a Thumb function.  */
5027   bh = NULL;
5028   val = globals->arm_glue_size + 1;
5029   _bfd_generic_link_add_one_symbol (link_info, globals->bfd_of_glue_owner,
5030                                     tmp_name, BSF_GLOBAL, s, val,
5031                                     NULL, TRUE, FALSE, &bh);
5032
5033   myh = (struct elf_link_hash_entry *) bh;
5034   myh->type = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
5035   myh->forced_local = 1;
5036
5037   free (tmp_name);
5038
5039   if (link_info->shared || globals->root.is_relocatable_executable
5040       || globals->pic_veneer)
5041     size = ARM2THUMB_PIC_GLUE_SIZE;
5042   else if (globals->use_blx)
5043     size = ARM2THUMB_V5_STATIC_GLUE_SIZE;
5044   else
5045     size = ARM2THUMB_STATIC_GLUE_SIZE;
5046
5047   s->size += size;
5048   globals->arm_glue_size += size;
5049
5050   return myh;
5051 }
5052
5053 /* Allocate space for ARMv4 BX veneers.  */
5054
5055 static void
5056 record_arm_bx_glue (struct bfd_link_info * link_info, int reg)
5057 {
5058   asection * s;
5059   struct elf32_arm_link_hash_table *globals;
5060   char *tmp_name;
5061   struct elf_link_hash_entry *myh;
5062   struct bfd_link_hash_entry *bh;
5063   bfd_vma val;
5064
5065   /* BX PC does not need a veneer.  */
5066   if (reg == 15)
5067     return;
5068
5069   globals = elf32_arm_hash_table (link_info);
5070
5071   BFD_ASSERT (globals != NULL);
5072   BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
5073
5074   /* Check if this veneer has already been allocated.  */
5075   if (globals->bx_glue_offset[reg])
5076     return;
5077
5078   s = bfd_get_section_by_name
5079     (globals->bfd_of_glue_owner, ARM_BX_GLUE_SECTION_NAME);
5080
5081   BFD_ASSERT (s != NULL);
5082
5083   /* Add symbol for veneer.  */
5084   tmp_name = (char *)
5085       bfd_malloc ((bfd_size_type) strlen (ARM_BX_GLUE_ENTRY_NAME) + 1);
5086
5087   BFD_ASSERT (tmp_name);
5088
5089   sprintf (tmp_name, ARM_BX_GLUE_ENTRY_NAME, reg);
5090
5091   myh = elf_link_hash_lookup
5092     (&(globals)->root, tmp_name, FALSE, FALSE, FALSE);
5093
5094   BFD_ASSERT (myh == NULL);
5095
5096   bh = NULL;
5097   val = globals->bx_glue_size;
5098   _bfd_generic_link_add_one_symbol (link_info, globals->bfd_of_glue_owner,
5099                                     tmp_name, BSF_FUNCTION | BSF_LOCAL, s, val,
5100                                     NULL, TRUE, FALSE, &bh);
5101
5102   myh = (struct elf_link_hash_entry *) bh;
5103   myh->type = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
5104   myh->forced_local = 1;
5105
5106   s->size += ARM_BX_VENEER_SIZE;
5107   globals->bx_glue_offset[reg] = globals->bx_glue_size | 2;
5108   globals->bx_glue_size += ARM_BX_VENEER_SIZE;
5109 }
5110
5111
5112 /* Add an entry to the code/data map for section SEC.  */
5113
5114 static void
5115 elf32_arm_section_map_add (asection *sec, char type, bfd_vma vma)
5116 {
5117   struct _arm_elf_section_data *sec_data = elf32_arm_section_data (sec);
5118   unsigned int newidx;
5119
5120   if (sec_data->map == NULL)
5121     {
5122       sec_data->map = (elf32_arm_section_map *)
5123           bfd_malloc (sizeof (elf32_arm_section_map));
5124       sec_data->mapcount = 0;
5125       sec_data->mapsize = 1;
5126     }
5127
5128   newidx = sec_data->mapcount++;
5129
5130   if (sec_data->mapcount > sec_data->mapsize)
5131     {
5132       sec_data->mapsize *= 2;
5133       sec_data->map = (elf32_arm_section_map *)
5134           bfd_realloc_or_free (sec_data->map, sec_data->mapsize
5135                                * sizeof (elf32_arm_section_map));
5136     }
5137
5138   if (sec_data->map)
5139     {
5140       sec_data->map[newidx].vma = vma;
5141       sec_data->map[newidx].type = type;
5142     }
5143 }
5144
5145
5146 /* Record information about a VFP11 denorm-erratum veneer.  Only ARM-mode
5147    veneers are handled for now.  */
5148
5149 static bfd_vma
5150 record_vfp11_erratum_veneer (struct bfd_link_info *link_info,
5151                              elf32_vfp11_erratum_list *branch,
5152                              bfd *branch_bfd,
5153                              asection *branch_sec,
5154                              unsigned int offset)
5155 {
5156   asection *s;
5157   struct elf32_arm_link_hash_table *hash_table;
5158   char *tmp_name;
5159   struct elf_link_hash_entry *myh;
5160   struct bfd_link_hash_entry *bh;
5161   bfd_vma val;
5162   struct _arm_elf_section_data *sec_data;
5163   int errcount;
5164   elf32_vfp11_erratum_list *newerr;
5165
5166   hash_table = elf32_arm_hash_table (link_info);
5167
5168   BFD_ASSERT (hash_table != NULL);
5169   BFD_ASSERT (hash_table->bfd_of_glue_owner != NULL);
5170
5171   s = bfd_get_section_by_name
5172     (hash_table->bfd_of_glue_owner, VFP11_ERRATUM_VENEER_SECTION_NAME);
5173
5174   sec_data = elf32_arm_section_data (s);
5175
5176   BFD_ASSERT (s != NULL);
5177
5178   tmp_name = (char *) bfd_malloc ((bfd_size_type) strlen
5179                                   (VFP11_ERRATUM_VENEER_ENTRY_NAME) + 10);
5180
5181   BFD_ASSERT (tmp_name);
5182
5183   sprintf (tmp_name, VFP11_ERRATUM_VENEER_ENTRY_NAME,
5184            hash_table->num_vfp11_fixes);
5185
5186   myh = elf_link_hash_lookup
5187     (&(hash_table)->root, tmp_name, FALSE, FALSE, FALSE);
5188
5189   BFD_ASSERT (myh == NULL);
5190
5191   bh = NULL;
5192   val = hash_table->vfp11_erratum_glue_size;
5193   _bfd_generic_link_add_one_symbol (link_info, hash_table->bfd_of_glue_owner,
5194                                     tmp_name, BSF_FUNCTION | BSF_LOCAL, s, val,
5195                                     NULL, TRUE, FALSE, &bh);
5196
5197   myh = (struct elf_link_hash_entry *) bh;
5198   myh->type = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
5199   myh->forced_local = 1;
5200
5201   /* Link veneer back to calling location.  */
5202   errcount = ++(sec_data->erratumcount);
5203   newerr = (elf32_vfp11_erratum_list *)
5204       bfd_zmalloc (sizeof (elf32_vfp11_erratum_list));
5205
5206   newerr->type = VFP11_ERRATUM_ARM_VENEER;
5207   newerr->vma = -1;
5208   newerr->u.v.branch = branch;
5209   newerr->u.v.id = hash_table->num_vfp11_fixes;
5210   branch->u.b.veneer = newerr;
5211
5212   newerr->next = sec_data->erratumlist;
5213   sec_data->erratumlist = newerr;
5214
5215   /* A symbol for the return from the veneer.  */
5216   sprintf (tmp_name, VFP11_ERRATUM_VENEER_ENTRY_NAME "_r",
5217            hash_table->num_vfp11_fixes);
5218
5219   myh = elf_link_hash_lookup
5220     (&(hash_table)->root, tmp_name, FALSE, FALSE, FALSE);
5221
5222   if (myh != NULL)
5223     abort ();
5224
5225   bh = NULL;
5226   val = offset + 4;
5227   _bfd_generic_link_add_one_symbol (link_info, branch_bfd, tmp_name, BSF_LOCAL,
5228                                     branch_sec, val, NULL, TRUE, FALSE, &bh);
5229
5230   myh = (struct elf_link_hash_entry *) bh;
5231   myh->type = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
5232   myh->forced_local = 1;
5233
5234   free (tmp_name);
5235
5236   /* Generate a mapping symbol for the veneer section, and explicitly add an
5237      entry for that symbol to the code/data map for the section.  */
5238   if (hash_table->vfp11_erratum_glue_size == 0)
5239     {
5240       bh = NULL;
5241       /* FIXME: Creates an ARM symbol.  Thumb mode will need attention if it
5242          ever requires this erratum fix.  */
5243       _bfd_generic_link_add_one_symbol (link_info,
5244                                         hash_table->bfd_of_glue_owner, "$a",
5245                                         BSF_LOCAL, s, 0, NULL,
5246                                         TRUE, FALSE, &bh);
5247
5248       myh = (struct elf_link_hash_entry *) bh;
5249       myh->type = ELF_ST_INFO (STB_LOCAL, STT_NOTYPE);
5250       myh->forced_local = 1;
5251
5252       /* The elf32_arm_init_maps function only cares about symbols from input
5253          BFDs.  We must make a note of this generated mapping symbol
5254          ourselves so that code byteswapping works properly in
5255          elf32_arm_write_section.  */
5256       elf32_arm_section_map_add (s, 'a', 0);
5257     }
5258
5259   s->size += VFP11_ERRATUM_VENEER_SIZE;
5260   hash_table->vfp11_erratum_glue_size += VFP11_ERRATUM_VENEER_SIZE;
5261   hash_table->num_vfp11_fixes++;
5262
5263   /* The offset of the veneer.  */
5264   return val;
5265 }
5266
5267 #define ARM_GLUE_SECTION_FLAGS \
5268   (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_CODE \
5269    | SEC_READONLY | SEC_LINKER_CREATED)
5270
5271 /* Create a fake section for use by the ARM backend of the linker.  */
5272
5273 static bfd_boolean
5274 arm_make_glue_section (bfd * abfd, const char * name)
5275 {
5276   asection * sec;
5277
5278   sec = bfd_get_section_by_name (abfd, name);
5279   if (sec != NULL)
5280     /* Already made.  */
5281     return TRUE;
5282
5283   sec = bfd_make_section_with_flags (abfd, name, ARM_GLUE_SECTION_FLAGS);
5284
5285   if (sec == NULL
5286       || !bfd_set_section_alignment (abfd, sec, 2))
5287     return FALSE;
5288
5289   /* Set the gc mark to prevent the section from being removed by garbage
5290      collection, despite the fact that no relocs refer to this section.  */
5291   sec->gc_mark = 1;
5292
5293   return TRUE;
5294 }
5295
5296 /* Add the glue sections to ABFD.  This function is called from the
5297    linker scripts in ld/emultempl/{armelf}.em.  */
5298
5299 bfd_boolean
5300 bfd_elf32_arm_add_glue_sections_to_bfd (bfd *abfd,
5301                                         struct bfd_link_info *info)
5302 {
5303   /* If we are only performing a partial
5304      link do not bother adding the glue.  */
5305   if (info->relocatable)
5306     return TRUE;
5307
5308   return arm_make_glue_section (abfd, ARM2THUMB_GLUE_SECTION_NAME)
5309     && arm_make_glue_section (abfd, THUMB2ARM_GLUE_SECTION_NAME)
5310     && arm_make_glue_section (abfd, VFP11_ERRATUM_VENEER_SECTION_NAME)
5311     && arm_make_glue_section (abfd, ARM_BX_GLUE_SECTION_NAME);
5312 }
5313
5314 /* Select a BFD to be used to hold the sections used by the glue code.
5315    This function is called from the linker scripts in ld/emultempl/
5316    {armelf/pe}.em.  */
5317
5318 bfd_boolean
5319 bfd_elf32_arm_get_bfd_for_interworking (bfd *abfd, struct bfd_link_info *info)
5320 {
5321   struct elf32_arm_link_hash_table *globals;
5322
5323   /* If we are only performing a partial link
5324      do not bother getting a bfd to hold the glue.  */
5325   if (info->relocatable)
5326     return TRUE;
5327
5328   /* Make sure we don't attach the glue sections to a dynamic object.  */
5329   BFD_ASSERT (!(abfd->flags & DYNAMIC));
5330
5331   globals = elf32_arm_hash_table (info);
5332
5333   BFD_ASSERT (globals != NULL);
5334
5335   if (globals->bfd_of_glue_owner != NULL)
5336     return TRUE;
5337
5338   /* Save the bfd for later use.  */
5339   globals->bfd_of_glue_owner = abfd;
5340
5341   return TRUE;
5342 }
5343
5344 static void
5345 check_use_blx (struct elf32_arm_link_hash_table *globals)
5346 {
5347   if (bfd_elf_get_obj_attr_int (globals->obfd, OBJ_ATTR_PROC,
5348                                 Tag_CPU_arch) > 2)
5349     globals->use_blx = 1;
5350 }
5351
5352 bfd_boolean
5353 bfd_elf32_arm_process_before_allocation (bfd *abfd,
5354                                          struct bfd_link_info *link_info)
5355 {
5356   Elf_Internal_Shdr *symtab_hdr;
5357   Elf_Internal_Rela *internal_relocs = NULL;
5358   Elf_Internal_Rela *irel, *irelend;
5359   bfd_byte *contents = NULL;
5360
5361   asection *sec;
5362   struct elf32_arm_link_hash_table *globals;
5363
5364   /* If we are only performing a partial link do not bother
5365      to construct any glue.  */
5366   if (link_info->relocatable)
5367     return TRUE;
5368
5369   /* Here we have a bfd that is to be included on the link.  We have a
5370      hook to do reloc rummaging, before section sizes are nailed down.  */
5371   globals = elf32_arm_hash_table (link_info);
5372
5373   BFD_ASSERT (globals != NULL);
5374
5375   check_use_blx (globals);
5376
5377   if (globals->byteswap_code && !bfd_big_endian (abfd))
5378     {
5379       _bfd_error_handler (_("%B: BE8 images only valid in big-endian mode."),
5380                           abfd);
5381       return FALSE;
5382     }
5383
5384   /* PR 5398: If we have not decided to include any loadable sections in
5385      the output then we will not have a glue owner bfd.  This is OK, it
5386      just means that there is nothing else for us to do here.  */
5387   if (globals->bfd_of_glue_owner == NULL)
5388     return TRUE;
5389
5390   /* Rummage around all the relocs and map the glue vectors.  */
5391   sec = abfd->sections;
5392
5393   if (sec == NULL)
5394     return TRUE;
5395
5396   for (; sec != NULL; sec = sec->next)
5397     {
5398       if (sec->reloc_count == 0)
5399         continue;
5400
5401       if ((sec->flags & SEC_EXCLUDE) != 0)
5402         continue;
5403
5404       symtab_hdr = & elf_symtab_hdr (abfd);
5405
5406       /* Load the relocs.  */
5407       internal_relocs
5408         = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL, FALSE);
5409
5410       if (internal_relocs == NULL)
5411         goto error_return;
5412
5413       irelend = internal_relocs + sec->reloc_count;
5414       for (irel = internal_relocs; irel < irelend; irel++)
5415         {
5416           long r_type;
5417           unsigned long r_index;
5418
5419           struct elf_link_hash_entry *h;
5420
5421           r_type = ELF32_R_TYPE (irel->r_info);
5422           r_index = ELF32_R_SYM (irel->r_info);
5423
5424           /* These are the only relocation types we care about.  */
5425           if (   r_type != R_ARM_PC24
5426               && (r_type != R_ARM_V4BX || globals->fix_v4bx < 2))
5427             continue;
5428
5429           /* Get the section contents if we haven't done so already.  */
5430           if (contents == NULL)
5431             {
5432               /* Get cached copy if it exists.  */
5433               if (elf_section_data (sec)->this_hdr.contents != NULL)
5434                 contents = elf_section_data (sec)->this_hdr.contents;
5435               else
5436                 {
5437                   /* Go get them off disk.  */
5438                   if (! bfd_malloc_and_get_section (abfd, sec, &contents))
5439                     goto error_return;
5440                 }
5441             }
5442
5443           if (r_type == R_ARM_V4BX)
5444             {
5445               int reg;
5446
5447               reg = bfd_get_32 (abfd, contents + irel->r_offset) & 0xf;
5448               record_arm_bx_glue (link_info, reg);
5449               continue;
5450             }
5451
5452           /* If the relocation is not against a symbol it cannot concern us.  */
5453           h = NULL;
5454
5455           /* We don't care about local symbols.  */
5456           if (r_index < symtab_hdr->sh_info)
5457             continue;
5458
5459           /* This is an external symbol.  */
5460           r_index -= symtab_hdr->sh_info;
5461           h = (struct elf_link_hash_entry *)
5462             elf_sym_hashes (abfd)[r_index];
5463
5464           /* If the relocation is against a static symbol it must be within
5465              the current section and so cannot be a cross ARM/Thumb relocation.  */
5466           if (h == NULL)
5467             continue;
5468
5469           /* If the call will go through a PLT entry then we do not need
5470              glue.  */
5471           if (globals->splt != NULL && h->plt.offset != (bfd_vma) -1)
5472             continue;
5473
5474           switch (r_type)
5475             {
5476             case R_ARM_PC24:
5477               /* This one is a call from arm code.  We need to look up
5478                  the target of the call.  If it is a thumb target, we
5479                  insert glue.  */
5480               if (ELF_ST_TYPE (h->type) == STT_ARM_TFUNC)
5481                 record_arm_to_thumb_glue (link_info, h);
5482               break;
5483
5484             default:
5485               abort ();
5486             }
5487         }
5488
5489       if (contents != NULL
5490           && elf_section_data (sec)->this_hdr.contents != contents)
5491         free (contents);
5492       contents = NULL;
5493
5494       if (internal_relocs != NULL
5495           && elf_section_data (sec)->relocs != internal_relocs)
5496         free (internal_relocs);
5497       internal_relocs = NULL;
5498     }
5499
5500   return TRUE;
5501
5502 error_return:
5503   if (contents != NULL
5504       && elf_section_data (sec)->this_hdr.contents != contents)
5505     free (contents);
5506   if (internal_relocs != NULL
5507       && elf_section_data (sec)->relocs != internal_relocs)
5508     free (internal_relocs);
5509
5510   return FALSE;
5511 }
5512 #endif
5513
5514
5515 /* Initialise maps of ARM/Thumb/data for input BFDs.  */
5516
5517 void
5518 bfd_elf32_arm_init_maps (bfd *abfd)
5519 {
5520   Elf_Internal_Sym *isymbuf;
5521   Elf_Internal_Shdr *hdr;
5522   unsigned int i, localsyms;
5523
5524   /* PR 7093: Make sure that we are dealing with an arm elf binary.  */
5525   if (! is_arm_elf (abfd))
5526     return;
5527
5528   if ((abfd->flags & DYNAMIC) != 0)
5529     return;
5530
5531   hdr = & elf_symtab_hdr (abfd);
5532   localsyms = hdr->sh_info;
5533
5534   /* Obtain a buffer full of symbols for this BFD. The hdr->sh_info field
5535      should contain the number of local symbols, which should come before any
5536      global symbols.  Mapping symbols are always local.  */
5537   isymbuf = bfd_elf_get_elf_syms (abfd, hdr, localsyms, 0, NULL, NULL,
5538                                   NULL);
5539
5540   /* No internal symbols read?  Skip this BFD.  */
5541   if (isymbuf == NULL)
5542     return;
5543
5544   for (i = 0; i < localsyms; i++)
5545     {
5546       Elf_Internal_Sym *isym = &isymbuf[i];
5547       asection *sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
5548       const char *name;
5549
5550       if (sec != NULL
5551           && ELF_ST_BIND (isym->st_info) == STB_LOCAL)
5552         {
5553           name = bfd_elf_string_from_elf_section (abfd,
5554             hdr->sh_link, isym->st_name);
5555
5556           if (bfd_is_arm_special_symbol_name (name,
5557                                               BFD_ARM_SPECIAL_SYM_TYPE_MAP))
5558             elf32_arm_section_map_add (sec, name[1], isym->st_value);
5559         }
5560     }
5561 }
5562
5563
5564 /* Auto-select enabling of Cortex-A8 erratum fix if the user didn't explicitly
5565    say what they wanted.  */
5566
5567 void
5568 bfd_elf32_arm_set_cortex_a8_fix (bfd *obfd, struct bfd_link_info *link_info)
5569 {
5570   struct elf32_arm_link_hash_table *globals = elf32_arm_hash_table (link_info);
5571   obj_attribute *out_attr = elf_known_obj_attributes_proc (obfd);
5572
5573   if (globals->fix_cortex_a8 == -1)
5574     {
5575       /* Turn on Cortex-A8 erratum workaround for ARMv7-A.  */
5576       if (out_attr[Tag_CPU_arch].i == TAG_CPU_ARCH_V7
5577           && (out_attr[Tag_CPU_arch_profile].i == 'A'
5578               || out_attr[Tag_CPU_arch_profile].i == 0))
5579         globals->fix_cortex_a8 = 1;
5580       else
5581         globals->fix_cortex_a8 = 0;
5582     }
5583 }
5584
5585
5586 void
5587 bfd_elf32_arm_set_vfp11_fix (bfd *obfd, struct bfd_link_info *link_info)
5588 {
5589   struct elf32_arm_link_hash_table *globals = elf32_arm_hash_table (link_info);
5590   obj_attribute *out_attr = elf_known_obj_attributes_proc (obfd);
5591
5592   /* We assume that ARMv7+ does not need the VFP11 denorm erratum fix.  */
5593   if (out_attr[Tag_CPU_arch].i >= TAG_CPU_ARCH_V7)
5594     {
5595       switch (globals->vfp11_fix)
5596         {
5597         case BFD_ARM_VFP11_FIX_DEFAULT:
5598         case BFD_ARM_VFP11_FIX_NONE:
5599           globals->vfp11_fix = BFD_ARM_VFP11_FIX_NONE;
5600           break;
5601
5602         default:
5603           /* Give a warning, but do as the user requests anyway.  */
5604           (*_bfd_error_handler) (_("%B: warning: selected VFP11 erratum "
5605             "workaround is not necessary for target architecture"), obfd);
5606         }
5607     }
5608   else if (globals->vfp11_fix == BFD_ARM_VFP11_FIX_DEFAULT)
5609     /* For earlier architectures, we might need the workaround, but do not
5610        enable it by default.  If users is running with broken hardware, they
5611        must enable the erratum fix explicitly.  */
5612     globals->vfp11_fix = BFD_ARM_VFP11_FIX_NONE;
5613 }
5614
5615
5616 enum bfd_arm_vfp11_pipe
5617 {
5618   VFP11_FMAC,
5619   VFP11_LS,
5620   VFP11_DS,
5621   VFP11_BAD
5622 };
5623
5624 /* Return a VFP register number.  This is encoded as RX:X for single-precision
5625    registers, or X:RX for double-precision registers, where RX is the group of
5626    four bits in the instruction encoding and X is the single extension bit.
5627    RX and X fields are specified using their lowest (starting) bit.  The return
5628    value is:
5629
5630      0...31: single-precision registers s0...s31
5631      32...63: double-precision registers d0...d31.
5632
5633    Although X should be zero for VFP11 (encoding d0...d15 only), we might
5634    encounter VFP3 instructions, so we allow the full range for DP registers.  */
5635
5636 static unsigned int
5637 bfd_arm_vfp11_regno (unsigned int insn, bfd_boolean is_double, unsigned int rx,
5638                      unsigned int x)
5639 {
5640   if (is_double)
5641     return (((insn >> rx) & 0xf) | (((insn >> x) & 1) << 4)) + 32;
5642   else
5643     return (((insn >> rx) & 0xf) << 1) | ((insn >> x) & 1);
5644 }
5645
5646 /* Set bits in *WMASK according to a register number REG as encoded by
5647    bfd_arm_vfp11_regno().  Ignore d16-d31.  */
5648
5649 static void
5650 bfd_arm_vfp11_write_mask (unsigned int *wmask, unsigned int reg)
5651 {
5652   if (reg < 32)
5653     *wmask |= 1 << reg;
5654   else if (reg < 48)
5655     *wmask |= 3 << ((reg - 32) * 2);
5656 }
5657
5658 /* Return TRUE if WMASK overwrites anything in REGS.  */
5659
5660 static bfd_boolean
5661 bfd_arm_vfp11_antidependency (unsigned int wmask, int *regs, int numregs)
5662 {
5663   int i;
5664
5665   for (i = 0; i < numregs; i++)
5666     {
5667       unsigned int reg = regs[i];
5668
5669       if (reg < 32 && (wmask & (1 << reg)) != 0)
5670         return TRUE;
5671
5672       reg -= 32;
5673
5674       if (reg >= 16)
5675         continue;
5676
5677       if ((wmask & (3 << (reg * 2))) != 0)
5678         return TRUE;
5679     }
5680
5681   return FALSE;
5682 }
5683
5684 /* In this function, we're interested in two things: finding input registers
5685    for VFP data-processing instructions, and finding the set of registers which
5686    arbitrary VFP instructions may write to.  We use a 32-bit unsigned int to
5687    hold the written set, so FLDM etc. are easy to deal with (we're only
5688    interested in 32 SP registers or 16 dp registers, due to the VFP version
5689    implemented by the chip in question).  DP registers are marked by setting
5690    both SP registers in the write mask).  */
5691
5692 static enum bfd_arm_vfp11_pipe
5693 bfd_arm_vfp11_insn_decode (unsigned int insn, unsigned int *destmask, int *regs,
5694                            int *numregs)
5695 {
5696   enum bfd_arm_vfp11_pipe vpipe = VFP11_BAD;
5697   bfd_boolean is_double = ((insn & 0xf00) == 0xb00) ? 1 : 0;
5698
5699   if ((insn & 0x0f000e10) == 0x0e000a00)  /* A data-processing insn.  */
5700     {
5701       unsigned int pqrs;
5702       unsigned int fd = bfd_arm_vfp11_regno (insn, is_double, 12, 22);
5703       unsigned int fm = bfd_arm_vfp11_regno (insn, is_double, 0, 5);
5704
5705       pqrs = ((insn & 0x00800000) >> 20)
5706            | ((insn & 0x00300000) >> 19)
5707            | ((insn & 0x00000040) >> 6);
5708
5709       switch (pqrs)
5710         {
5711         case 0: /* fmac[sd].  */
5712         case 1: /* fnmac[sd].  */
5713         case 2: /* fmsc[sd].  */
5714         case 3: /* fnmsc[sd].  */
5715           vpipe = VFP11_FMAC;
5716           bfd_arm_vfp11_write_mask (destmask, fd);
5717           regs[0] = fd;
5718           regs[1] = bfd_arm_vfp11_regno (insn, is_double, 16, 7);  /* Fn.  */
5719           regs[2] = fm;
5720           *numregs = 3;
5721           break;
5722
5723         case 4: /* fmul[sd].  */
5724         case 5: /* fnmul[sd].  */
5725         case 6: /* fadd[sd].  */
5726         case 7: /* fsub[sd].  */
5727           vpipe = VFP11_FMAC;
5728           goto vfp_binop;
5729
5730         case 8: /* fdiv[sd].  */
5731           vpipe = VFP11_DS;
5732           vfp_binop:
5733           bfd_arm_vfp11_write_mask (destmask, fd);
5734           regs[0] = bfd_arm_vfp11_regno (insn, is_double, 16, 7);   /* Fn.  */
5735           regs[1] = fm;
5736           *numregs = 2;
5737           break;
5738
5739         case 15: /* extended opcode.  */
5740           {
5741             unsigned int extn = ((insn >> 15) & 0x1e)
5742                               | ((insn >> 7) & 1);
5743
5744             switch (extn)
5745               {
5746               case 0: /* fcpy[sd].  */
5747               case 1: /* fabs[sd].  */
5748               case 2: /* fneg[sd].  */
5749               case 8: /* fcmp[sd].  */
5750               case 9: /* fcmpe[sd].  */
5751               case 10: /* fcmpz[sd].  */
5752               case 11: /* fcmpez[sd].  */
5753               case 16: /* fuito[sd].  */
5754               case 17: /* fsito[sd].  */
5755               case 24: /* ftoui[sd].  */
5756               case 25: /* ftouiz[sd].  */
5757               case 26: /* ftosi[sd].  */
5758               case 27: /* ftosiz[sd].  */
5759                 /* These instructions will not bounce due to underflow.  */
5760                 *numregs = 0;
5761                 vpipe = VFP11_FMAC;
5762                 break;
5763
5764               case 3: /* fsqrt[sd].  */
5765                 /* fsqrt cannot underflow, but it can (perhaps) overwrite
5766                    registers to cause the erratum in previous instructions.  */
5767                 bfd_arm_vfp11_write_mask (destmask, fd);
5768                 vpipe = VFP11_DS;
5769                 break;
5770
5771               case 15: /* fcvt{ds,sd}.  */
5772                 {
5773                   int rnum = 0;
5774
5775                   bfd_arm_vfp11_write_mask (destmask, fd);
5776
5777                   /* Only FCVTSD can underflow.  */
5778                   if ((insn & 0x100) != 0)
5779                     regs[rnum++] = fm;
5780
5781                   *numregs = rnum;
5782
5783                   vpipe = VFP11_FMAC;
5784                 }
5785                 break;
5786
5787               default:
5788                 return VFP11_BAD;
5789               }
5790           }
5791           break;
5792
5793         default:
5794           return VFP11_BAD;
5795         }
5796     }
5797   /* Two-register transfer.  */
5798   else if ((insn & 0x0fe00ed0) == 0x0c400a10)
5799     {
5800       unsigned int fm = bfd_arm_vfp11_regno (insn, is_double, 0, 5);
5801
5802       if ((insn & 0x100000) == 0)
5803         {
5804           if (is_double)
5805             bfd_arm_vfp11_write_mask (destmask, fm);
5806           else
5807             {
5808               bfd_arm_vfp11_write_mask (destmask, fm);
5809               bfd_arm_vfp11_write_mask (destmask, fm + 1);
5810             }
5811         }
5812
5813       vpipe = VFP11_LS;
5814     }
5815   else if ((insn & 0x0e100e00) == 0x0c100a00)  /* A load insn.  */
5816     {
5817       int fd = bfd_arm_vfp11_regno (insn, is_double, 12, 22);
5818       unsigned int puw = ((insn >> 21) & 0x1) | (((insn >> 23) & 3) << 1);
5819
5820       switch (puw)
5821         {
5822         case 0: /* Two-reg transfer.  We should catch these above.  */
5823           abort ();
5824
5825         case 2: /* fldm[sdx].  */
5826         case 3:
5827         case 5:
5828           {
5829             unsigned int i, offset = insn & 0xff;
5830
5831             if (is_double)
5832               offset >>= 1;
5833
5834             for (i = fd; i < fd + offset; i++)
5835               bfd_arm_vfp11_write_mask (destmask, i);
5836           }
5837           break;
5838
5839         case 4: /* fld[sd].  */
5840         case 6:
5841           bfd_arm_vfp11_write_mask (destmask, fd);
5842           break;
5843
5844         default:
5845           return VFP11_BAD;
5846         }
5847
5848       vpipe = VFP11_LS;
5849     }
5850   /* Single-register transfer. Note L==0.  */
5851   else if ((insn & 0x0f100e10) == 0x0e000a10)
5852     {
5853       unsigned int opcode = (insn >> 21) & 7;
5854       unsigned int fn = bfd_arm_vfp11_regno (insn, is_double, 16, 7);
5855
5856       switch (opcode)
5857         {
5858         case 0: /* fmsr/fmdlr.  */
5859         case 1: /* fmdhr.  */
5860           /* Mark fmdhr and fmdlr as writing to the whole of the DP
5861              destination register.  I don't know if this is exactly right,
5862              but it is the conservative choice.  */
5863           bfd_arm_vfp11_write_mask (destmask, fn);
5864           break;
5865
5866         case 7: /* fmxr.  */
5867           break;
5868         }
5869
5870       vpipe = VFP11_LS;
5871     }
5872
5873   return vpipe;
5874 }
5875
5876
5877 static int elf32_arm_compare_mapping (const void * a, const void * b);
5878
5879
5880 /* Look for potentially-troublesome code sequences which might trigger the
5881    VFP11 denormal/antidependency erratum.  See, e.g., the ARM1136 errata sheet
5882    (available from ARM) for details of the erratum.  A short version is
5883    described in ld.texinfo.  */
5884
5885 bfd_boolean
5886 bfd_elf32_arm_vfp11_erratum_scan (bfd *abfd, struct bfd_link_info *link_info)
5887 {
5888   asection *sec;
5889   bfd_byte *contents = NULL;
5890   int state = 0;
5891   int regs[3], numregs = 0;
5892   struct elf32_arm_link_hash_table *globals = elf32_arm_hash_table (link_info);
5893   int use_vector = (globals->vfp11_fix == BFD_ARM_VFP11_FIX_VECTOR);
5894
5895   /* We use a simple FSM to match troublesome VFP11 instruction sequences.
5896      The states transition as follows:
5897
5898        0 -> 1 (vector) or 0 -> 2 (scalar)
5899            A VFP FMAC-pipeline instruction has been seen. Fill
5900            regs[0]..regs[numregs-1] with its input operands. Remember this
5901            instruction in 'first_fmac'.
5902
5903        1 -> 2
5904            Any instruction, except for a VFP instruction which overwrites
5905            regs[*].
5906
5907        1 -> 3 [ -> 0 ]  or
5908        2 -> 3 [ -> 0 ]
5909            A VFP instruction has been seen which overwrites any of regs[*].
5910            We must make a veneer!  Reset state to 0 before examining next
5911            instruction.
5912
5913        2 -> 0
5914            If we fail to match anything in state 2, reset to state 0 and reset
5915            the instruction pointer to the instruction after 'first_fmac'.
5916
5917      If the VFP11 vector mode is in use, there must be at least two unrelated
5918      instructions between anti-dependent VFP11 instructions to properly avoid
5919      triggering the erratum, hence the use of the extra state 1.  */
5920
5921   /* If we are only performing a partial link do not bother
5922      to construct any glue.  */
5923   if (link_info->relocatable)
5924     return TRUE;
5925
5926   /* Skip if this bfd does not correspond to an ELF image.  */
5927   if (! is_arm_elf (abfd))
5928     return TRUE;
5929
5930   /* We should have chosen a fix type by the time we get here.  */
5931   BFD_ASSERT (globals->vfp11_fix != BFD_ARM_VFP11_FIX_DEFAULT);
5932
5933   if (globals->vfp11_fix == BFD_ARM_VFP11_FIX_NONE)
5934     return TRUE;
5935
5936   /* Skip this BFD if it corresponds to an executable or dynamic object.  */
5937   if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
5938     return TRUE;
5939
5940   for (sec = abfd->sections; sec != NULL; sec = sec->next)
5941     {
5942       unsigned int i, span, first_fmac = 0, veneer_of_insn = 0;
5943       struct _arm_elf_section_data *sec_data;
5944
5945       /* If we don't have executable progbits, we're not interested in this
5946          section.  Also skip if section is to be excluded.  */
5947       if (elf_section_type (sec) != SHT_PROGBITS
5948           || (elf_section_flags (sec) & SHF_EXECINSTR) == 0
5949           || (sec->flags & SEC_EXCLUDE) != 0
5950           || sec->sec_info_type == ELF_INFO_TYPE_JUST_SYMS
5951           || sec->output_section == bfd_abs_section_ptr
5952           || strcmp (sec->name, VFP11_ERRATUM_VENEER_SECTION_NAME) == 0)
5953         continue;
5954
5955       sec_data = elf32_arm_section_data (sec);
5956
5957       if (sec_data->mapcount == 0)
5958         continue;
5959
5960       if (elf_section_data (sec)->this_hdr.contents != NULL)
5961         contents = elf_section_data (sec)->this_hdr.contents;
5962       else if (! bfd_malloc_and_get_section (abfd, sec, &contents))
5963         goto error_return;
5964
5965       qsort (sec_data->map, sec_data->mapcount, sizeof (elf32_arm_section_map),
5966              elf32_arm_compare_mapping);
5967
5968       for (span = 0; span < sec_data->mapcount; span++)
5969         {
5970           unsigned int span_start = sec_data->map[span].vma;
5971           unsigned int span_end = (span == sec_data->mapcount - 1)
5972                                   ? sec->size : sec_data->map[span + 1].vma;
5973           char span_type = sec_data->map[span].type;
5974
5975           /* FIXME: Only ARM mode is supported at present.  We may need to
5976              support Thumb-2 mode also at some point.  */
5977           if (span_type != 'a')
5978             continue;
5979
5980           for (i = span_start; i < span_end;)
5981             {
5982               unsigned int next_i = i + 4;
5983               unsigned int insn = bfd_big_endian (abfd)
5984                 ? (contents[i] << 24)
5985                   | (contents[i + 1] << 16)
5986                   | (contents[i + 2] << 8)
5987                   | contents[i + 3]
5988                 : (contents[i + 3] << 24)
5989                   | (contents[i + 2] << 16)
5990                   | (contents[i + 1] << 8)
5991                   | contents[i];
5992               unsigned int writemask = 0;
5993               enum bfd_arm_vfp11_pipe vpipe;
5994
5995               switch (state)
5996                 {
5997                 case 0:
5998                   vpipe = bfd_arm_vfp11_insn_decode (insn, &writemask, regs,
5999                                                     &numregs);
6000                   /* I'm assuming the VFP11 erratum can trigger with denorm
6001                      operands on either the FMAC or the DS pipeline. This might
6002                      lead to slightly overenthusiastic veneer insertion.  */
6003                   if (vpipe == VFP11_FMAC || vpipe == VFP11_DS)
6004                     {
6005                       state = use_vector ? 1 : 2;
6006                       first_fmac = i;
6007                       veneer_of_insn = insn;
6008                     }
6009                   break;
6010
6011                 case 1:
6012                   {
6013                     int other_regs[3], other_numregs;
6014                     vpipe = bfd_arm_vfp11_insn_decode (insn, &writemask,
6015                                                       other_regs,
6016                                                       &other_numregs);
6017                     if (vpipe != VFP11_BAD
6018                         && bfd_arm_vfp11_antidependency (writemask, regs,
6019                                                          numregs))
6020                       state = 3;
6021                     else
6022                       state = 2;
6023                   }
6024                   break;
6025
6026                 case 2:
6027                   {
6028                     int other_regs[3], other_numregs;
6029                     vpipe = bfd_arm_vfp11_insn_decode (insn, &writemask,
6030                                                       other_regs,
6031                                                       &other_numregs);
6032                     if (vpipe != VFP11_BAD
6033                         && bfd_arm_vfp11_antidependency (writemask, regs,
6034                                                          numregs))
6035                       state = 3;
6036                     else
6037                       {
6038                         state = 0;
6039                         next_i = first_fmac + 4;
6040                       }
6041                   }
6042                   break;
6043
6044                 case 3:
6045                   abort ();  /* Should be unreachable.  */
6046                 }
6047
6048               if (state == 3)
6049                 {
6050                   elf32_vfp11_erratum_list *newerr =(elf32_vfp11_erratum_list *)
6051                       bfd_zmalloc (sizeof (elf32_vfp11_erratum_list));
6052                   int errcount;
6053
6054                   errcount = ++(elf32_arm_section_data (sec)->erratumcount);
6055
6056                   newerr->u.b.vfp_insn = veneer_of_insn;
6057
6058                   switch (span_type)
6059                     {
6060                     case 'a':
6061                       newerr->type = VFP11_ERRATUM_BRANCH_TO_ARM_VENEER;
6062                       break;
6063
6064                     default:
6065                       abort ();
6066                     }
6067
6068                   record_vfp11_erratum_veneer (link_info, newerr, abfd, sec,
6069                                                first_fmac);
6070
6071                   newerr->vma = -1;
6072
6073                   newerr->next = sec_data->erratumlist;
6074                   sec_data->erratumlist = newerr;
6075
6076                   state = 0;
6077                 }
6078
6079               i = next_i;
6080             }
6081         }
6082
6083       if (contents != NULL
6084           && elf_section_data (sec)->this_hdr.contents != contents)
6085         free (contents);
6086       contents = NULL;
6087     }
6088
6089   return TRUE;
6090
6091 error_return:
6092   if (contents != NULL
6093       && elf_section_data (sec)->this_hdr.contents != contents)
6094     free (contents);
6095
6096   return FALSE;
6097 }
6098
6099 /* Find virtual-memory addresses for VFP11 erratum veneers and return locations
6100    after sections have been laid out, using specially-named symbols.  */
6101
6102 void
6103 bfd_elf32_arm_vfp11_fix_veneer_locations (bfd *abfd,
6104                                           struct bfd_link_info *link_info)
6105 {
6106   asection *sec;
6107   struct elf32_arm_link_hash_table *globals;
6108   char *tmp_name;
6109
6110   if (link_info->relocatable)
6111     return;
6112
6113   /* Skip if this bfd does not correspond to an ELF image.  */
6114   if (! is_arm_elf (abfd))
6115     return;
6116
6117   globals = elf32_arm_hash_table (link_info);
6118
6119   tmp_name = (char *) bfd_malloc ((bfd_size_type) strlen
6120                                   (VFP11_ERRATUM_VENEER_ENTRY_NAME) + 10);
6121
6122   for (sec = abfd->sections; sec != NULL; sec = sec->next)
6123     {
6124       struct _arm_elf_section_data *sec_data = elf32_arm_section_data (sec);
6125       elf32_vfp11_erratum_list *errnode = sec_data->erratumlist;
6126
6127       for (; errnode != NULL; errnode = errnode->next)
6128         {
6129           struct elf_link_hash_entry *myh;
6130           bfd_vma vma;
6131
6132           switch (errnode->type)
6133             {
6134             case VFP11_ERRATUM_BRANCH_TO_ARM_VENEER:
6135             case VFP11_ERRATUM_BRANCH_TO_THUMB_VENEER:
6136               /* Find veneer symbol.  */
6137               sprintf (tmp_name, VFP11_ERRATUM_VENEER_ENTRY_NAME,
6138                        errnode->u.b.veneer->u.v.id);
6139
6140               myh = elf_link_hash_lookup
6141                 (&(globals)->root, tmp_name, FALSE, FALSE, TRUE);
6142
6143               if (myh == NULL)
6144                 (*_bfd_error_handler) (_("%B: unable to find VFP11 veneer "
6145                                          "`%s'"), abfd, tmp_name);
6146
6147               vma = myh->root.u.def.section->output_section->vma
6148                     + myh->root.u.def.section->output_offset
6149                     + myh->root.u.def.value;
6150
6151               errnode->u.b.veneer->vma = vma;
6152               break;
6153
6154             case VFP11_ERRATUM_ARM_VENEER:
6155             case VFP11_ERRATUM_THUMB_VENEER:
6156               /* Find return location.  */
6157               sprintf (tmp_name, VFP11_ERRATUM_VENEER_ENTRY_NAME "_r",
6158                        errnode->u.v.id);
6159
6160               myh = elf_link_hash_lookup
6161                 (&(globals)->root, tmp_name, FALSE, FALSE, TRUE);
6162
6163               if (myh == NULL)
6164                 (*_bfd_error_handler) (_("%B: unable to find VFP11 veneer "
6165                                          "`%s'"), abfd, tmp_name);
6166
6167               vma = myh->root.u.def.section->output_section->vma
6168                     + myh->root.u.def.section->output_offset
6169                     + myh->root.u.def.value;
6170
6171               errnode->u.v.branch->vma = vma;
6172               break;
6173
6174             default:
6175               abort ();
6176             }
6177         }
6178     }
6179
6180   free (tmp_name);
6181 }
6182
6183
6184 /* Set target relocation values needed during linking.  */
6185
6186 void
6187 bfd_elf32_arm_set_target_relocs (struct bfd *output_bfd,
6188                                  struct bfd_link_info *link_info,
6189                                  int target1_is_rel,
6190                                  char * target2_type,
6191                                  int fix_v4bx,
6192                                  int use_blx,
6193                                  bfd_arm_vfp11_fix vfp11_fix,
6194                                  int no_enum_warn, int no_wchar_warn,
6195                                  int pic_veneer, int fix_cortex_a8)
6196 {
6197   struct elf32_arm_link_hash_table *globals;
6198
6199   globals = elf32_arm_hash_table (link_info);
6200
6201   globals->target1_is_rel = target1_is_rel;
6202   if (strcmp (target2_type, "rel") == 0)
6203     globals->target2_reloc = R_ARM_REL32;
6204   else if (strcmp (target2_type, "abs") == 0)
6205     globals->target2_reloc = R_ARM_ABS32;
6206   else if (strcmp (target2_type, "got-rel") == 0)
6207     globals->target2_reloc = R_ARM_GOT_PREL;
6208   else
6209     {
6210       _bfd_error_handler (_("Invalid TARGET2 relocation type '%s'."),
6211                           target2_type);
6212     }
6213   globals->fix_v4bx = fix_v4bx;
6214   globals->use_blx |= use_blx;
6215   globals->vfp11_fix = vfp11_fix;
6216   globals->pic_veneer = pic_veneer;
6217   globals->fix_cortex_a8 = fix_cortex_a8;
6218
6219   BFD_ASSERT (is_arm_elf (output_bfd));
6220   elf_arm_tdata (output_bfd)->no_enum_size_warning = no_enum_warn;
6221   elf_arm_tdata (output_bfd)->no_wchar_size_warning = no_wchar_warn;
6222 }
6223
6224 /* Replace the target offset of a Thumb bl or b.w instruction.  */
6225
6226 static void
6227 insert_thumb_branch (bfd *abfd, long int offset, bfd_byte *insn)
6228 {
6229   bfd_vma upper;
6230   bfd_vma lower;
6231   int reloc_sign;
6232
6233   BFD_ASSERT ((offset & 1) == 0);
6234
6235   upper = bfd_get_16 (abfd, insn);
6236   lower = bfd_get_16 (abfd, insn + 2);
6237   reloc_sign = (offset < 0) ? 1 : 0;
6238   upper = (upper & ~(bfd_vma) 0x7ff)
6239           | ((offset >> 12) & 0x3ff)
6240           | (reloc_sign << 10);
6241   lower = (lower & ~(bfd_vma) 0x2fff)
6242           | (((!((offset >> 23) & 1)) ^ reloc_sign) << 13)
6243           | (((!((offset >> 22) & 1)) ^ reloc_sign) << 11)
6244           | ((offset >> 1) & 0x7ff);
6245   bfd_put_16 (abfd, upper, insn);
6246   bfd_put_16 (abfd, lower, insn + 2);
6247 }
6248
6249 /* Thumb code calling an ARM function.  */
6250
6251 static int
6252 elf32_thumb_to_arm_stub (struct bfd_link_info * info,
6253                          const char *           name,
6254                          bfd *                  input_bfd,
6255                          bfd *                  output_bfd,
6256                          asection *             input_section,
6257                          bfd_byte *             hit_data,
6258                          asection *             sym_sec,
6259                          bfd_vma                offset,
6260                          bfd_signed_vma         addend,
6261                          bfd_vma                val,
6262                          char **error_message)
6263 {
6264   asection * s = 0;
6265   bfd_vma my_offset;
6266   long int ret_offset;
6267   struct elf_link_hash_entry * myh;
6268   struct elf32_arm_link_hash_table * globals;
6269
6270   myh = find_thumb_glue (info, name, error_message);
6271   if (myh == NULL)
6272     return FALSE;
6273
6274   globals = elf32_arm_hash_table (info);
6275
6276   BFD_ASSERT (globals != NULL);
6277   BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
6278
6279   my_offset = myh->root.u.def.value;
6280
6281   s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
6282                                THUMB2ARM_GLUE_SECTION_NAME);
6283
6284   BFD_ASSERT (s != NULL);
6285   BFD_ASSERT (s->contents != NULL);
6286   BFD_ASSERT (s->output_section != NULL);
6287
6288   if ((my_offset & 0x01) == 0x01)
6289     {
6290       if (sym_sec != NULL
6291           && sym_sec->owner != NULL
6292           && !INTERWORK_FLAG (sym_sec->owner))
6293         {
6294           (*_bfd_error_handler)
6295             (_("%B(%s): warning: interworking not enabled.\n"
6296                "  first occurrence: %B: thumb call to arm"),
6297              sym_sec->owner, input_bfd, name);
6298
6299           return FALSE;
6300         }
6301
6302       --my_offset;
6303       myh->root.u.def.value = my_offset;
6304
6305       put_thumb_insn (globals, output_bfd, (bfd_vma) t2a1_bx_pc_insn,
6306                       s->contents + my_offset);
6307
6308       put_thumb_insn (globals, output_bfd, (bfd_vma) t2a2_noop_insn,
6309                       s->contents + my_offset + 2);
6310
6311       ret_offset =
6312         /* Address of destination of the stub.  */
6313         ((bfd_signed_vma) val)
6314         - ((bfd_signed_vma)
6315            /* Offset from the start of the current section
6316               to the start of the stubs.  */
6317            (s->output_offset
6318             /* Offset of the start of this stub from the start of the stubs.  */
6319             + my_offset
6320             /* Address of the start of the current section.  */
6321             + s->output_section->vma)
6322            /* The branch instruction is 4 bytes into the stub.  */
6323            + 4
6324            /* ARM branches work from the pc of the instruction + 8.  */
6325            + 8);
6326
6327       put_arm_insn (globals, output_bfd,
6328                     (bfd_vma) t2a3_b_insn | ((ret_offset >> 2) & 0x00FFFFFF),
6329                     s->contents + my_offset + 4);
6330     }
6331
6332   BFD_ASSERT (my_offset <= globals->thumb_glue_size);
6333
6334   /* Now go back and fix up the original BL insn to point to here.  */
6335   ret_offset =
6336     /* Address of where the stub is located.  */
6337     (s->output_section->vma + s->output_offset + my_offset)
6338      /* Address of where the BL is located.  */
6339     - (input_section->output_section->vma + input_section->output_offset
6340        + offset)
6341     /* Addend in the relocation.  */
6342     - addend
6343     /* Biassing for PC-relative addressing.  */
6344     - 8;
6345
6346   insert_thumb_branch (input_bfd, ret_offset, hit_data - input_section->vma);
6347
6348   return TRUE;
6349 }
6350
6351 /* Populate an Arm to Thumb stub.  Returns the stub symbol.  */
6352
6353 static struct elf_link_hash_entry *
6354 elf32_arm_create_thumb_stub (struct bfd_link_info * info,
6355                              const char *           name,
6356                              bfd *                  input_bfd,
6357                              bfd *                  output_bfd,
6358                              asection *             sym_sec,
6359                              bfd_vma                val,
6360                              asection *             s,
6361                              char **                error_message)
6362 {
6363   bfd_vma my_offset;
6364   long int ret_offset;
6365   struct elf_link_hash_entry * myh;
6366   struct elf32_arm_link_hash_table * globals;
6367
6368   myh = find_arm_glue (info, name, error_message);
6369   if (myh == NULL)
6370     return NULL;
6371
6372   globals = elf32_arm_hash_table (info);
6373
6374   BFD_ASSERT (globals != NULL);
6375   BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
6376
6377   my_offset = myh->root.u.def.value;
6378
6379   if ((my_offset & 0x01) == 0x01)
6380     {
6381       if (sym_sec != NULL
6382           && sym_sec->owner != NULL
6383           && !INTERWORK_FLAG (sym_sec->owner))
6384         {
6385           (*_bfd_error_handler)
6386             (_("%B(%s): warning: interworking not enabled.\n"
6387                "  first occurrence: %B: arm call to thumb"),
6388              sym_sec->owner, input_bfd, name);
6389         }
6390
6391       --my_offset;
6392       myh->root.u.def.value = my_offset;
6393
6394       if (info->shared || globals->root.is_relocatable_executable
6395           || globals->pic_veneer)
6396         {
6397           /* For relocatable objects we can't use absolute addresses,
6398              so construct the address from a relative offset.  */
6399           /* TODO: If the offset is small it's probably worth
6400              constructing the address with adds.  */
6401           put_arm_insn (globals, output_bfd, (bfd_vma) a2t1p_ldr_insn,
6402                         s->contents + my_offset);
6403           put_arm_insn (globals, output_bfd, (bfd_vma) a2t2p_add_pc_insn,
6404                         s->contents + my_offset + 4);
6405           put_arm_insn (globals, output_bfd, (bfd_vma) a2t3p_bx_r12_insn,
6406                         s->contents + my_offset + 8);
6407           /* Adjust the offset by 4 for the position of the add,
6408              and 8 for the pipeline offset.  */
6409           ret_offset = (val - (s->output_offset
6410                                + s->output_section->vma
6411                                + my_offset + 12))
6412                        | 1;
6413           bfd_put_32 (output_bfd, ret_offset,
6414                       s->contents + my_offset + 12);
6415         }
6416       else if (globals->use_blx)
6417         {
6418           put_arm_insn (globals, output_bfd, (bfd_vma) a2t1v5_ldr_insn,
6419                         s->contents + my_offset);
6420
6421           /* It's a thumb address.  Add the low order bit.  */
6422           bfd_put_32 (output_bfd, val | a2t2v5_func_addr_insn,
6423                       s->contents + my_offset + 4);
6424         }
6425       else
6426         {
6427           put_arm_insn (globals, output_bfd, (bfd_vma) a2t1_ldr_insn,
6428                         s->contents + my_offset);
6429
6430           put_arm_insn (globals, output_bfd, (bfd_vma) a2t2_bx_r12_insn,
6431                         s->contents + my_offset + 4);
6432
6433           /* It's a thumb address.  Add the low order bit.  */
6434           bfd_put_32 (output_bfd, val | a2t3_func_addr_insn,
6435                       s->contents + my_offset + 8);
6436
6437           my_offset += 12;
6438         }
6439     }
6440
6441   BFD_ASSERT (my_offset <= globals->arm_glue_size);
6442
6443   return myh;
6444 }
6445
6446 /* Arm code calling a Thumb function.  */
6447
6448 static int
6449 elf32_arm_to_thumb_stub (struct bfd_link_info * info,
6450                          const char *           name,
6451                          bfd *                  input_bfd,
6452                          bfd *                  output_bfd,
6453                          asection *             input_section,
6454                          bfd_byte *             hit_data,
6455                          asection *             sym_sec,
6456                          bfd_vma                offset,
6457                          bfd_signed_vma         addend,
6458                          bfd_vma                val,
6459                          char **error_message)
6460 {
6461   unsigned long int tmp;
6462   bfd_vma my_offset;
6463   asection * s;
6464   long int ret_offset;
6465   struct elf_link_hash_entry * myh;
6466   struct elf32_arm_link_hash_table * globals;
6467
6468   globals = elf32_arm_hash_table (info);
6469
6470   BFD_ASSERT (globals != NULL);
6471   BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
6472
6473   s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
6474                                ARM2THUMB_GLUE_SECTION_NAME);
6475   BFD_ASSERT (s != NULL);
6476   BFD_ASSERT (s->contents != NULL);
6477   BFD_ASSERT (s->output_section != NULL);
6478
6479   myh = elf32_arm_create_thumb_stub (info, name, input_bfd, output_bfd,
6480                                      sym_sec, val, s, error_message);
6481   if (!myh)
6482     return FALSE;
6483
6484   my_offset = myh->root.u.def.value;
6485   tmp = bfd_get_32 (input_bfd, hit_data);
6486   tmp = tmp & 0xFF000000;
6487
6488   /* Somehow these are both 4 too far, so subtract 8.  */
6489   ret_offset = (s->output_offset
6490                 + my_offset
6491                 + s->output_section->vma
6492                 - (input_section->output_offset
6493                    + input_section->output_section->vma
6494                    + offset + addend)
6495                 - 8);
6496
6497   tmp = tmp | ((ret_offset >> 2) & 0x00FFFFFF);
6498
6499   bfd_put_32 (output_bfd, (bfd_vma) tmp, hit_data - input_section->vma);
6500
6501   return TRUE;
6502 }
6503
6504 /* Populate Arm stub for an exported Thumb function.  */
6505
6506 static bfd_boolean
6507 elf32_arm_to_thumb_export_stub (struct elf_link_hash_entry *h, void * inf)
6508 {
6509   struct bfd_link_info * info = (struct bfd_link_info *) inf;
6510   asection * s;
6511   struct elf_link_hash_entry * myh;
6512   struct elf32_arm_link_hash_entry *eh;
6513   struct elf32_arm_link_hash_table * globals;
6514   asection *sec;
6515   bfd_vma val;
6516   char *error_message;
6517
6518   eh = elf32_arm_hash_entry (h);
6519   /* Allocate stubs for exported Thumb functions on v4t.  */
6520   if (eh->export_glue == NULL)
6521     return TRUE;
6522
6523   globals = elf32_arm_hash_table (info);
6524
6525   BFD_ASSERT (globals != NULL);
6526   BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
6527
6528   s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
6529                                ARM2THUMB_GLUE_SECTION_NAME);
6530   BFD_ASSERT (s != NULL);
6531   BFD_ASSERT (s->contents != NULL);
6532   BFD_ASSERT (s->output_section != NULL);
6533
6534   sec = eh->export_glue->root.u.def.section;
6535
6536   BFD_ASSERT (sec->output_section != NULL);
6537
6538   val = eh->export_glue->root.u.def.value + sec->output_offset
6539         + sec->output_section->vma;
6540
6541   myh = elf32_arm_create_thumb_stub (info, h->root.root.string,
6542                                      h->root.u.def.section->owner,
6543                                      globals->obfd, sec, val, s,
6544                                      &error_message);
6545   BFD_ASSERT (myh);
6546   return TRUE;
6547 }
6548
6549 /* Populate ARMv4 BX veneers.  Returns the absolute adress of the veneer.  */
6550
6551 static bfd_vma
6552 elf32_arm_bx_glue (struct bfd_link_info * info, int reg)
6553 {
6554   bfd_byte *p;
6555   bfd_vma glue_addr;
6556   asection *s;
6557   struct elf32_arm_link_hash_table *globals;
6558
6559   globals = elf32_arm_hash_table (info);
6560
6561   BFD_ASSERT (globals != NULL);
6562   BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
6563
6564   s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
6565                                ARM_BX_GLUE_SECTION_NAME);
6566   BFD_ASSERT (s != NULL);
6567   BFD_ASSERT (s->contents != NULL);
6568   BFD_ASSERT (s->output_section != NULL);
6569
6570   BFD_ASSERT (globals->bx_glue_offset[reg] & 2);
6571
6572   glue_addr = globals->bx_glue_offset[reg] & ~(bfd_vma)3;
6573
6574   if ((globals->bx_glue_offset[reg] & 1) == 0)
6575     {
6576       p = s->contents + glue_addr;
6577       bfd_put_32 (globals->obfd, armbx1_tst_insn + (reg << 16), p);
6578       bfd_put_32 (globals->obfd, armbx2_moveq_insn + reg, p + 4);
6579       bfd_put_32 (globals->obfd, armbx3_bx_insn + reg, p + 8);
6580       globals->bx_glue_offset[reg] |= 1;
6581     }
6582
6583   return glue_addr + s->output_section->vma + s->output_offset;
6584 }
6585
6586 /* Generate Arm stubs for exported Thumb symbols.  */
6587 static void
6588 elf32_arm_begin_write_processing (bfd *abfd ATTRIBUTE_UNUSED,
6589                                   struct bfd_link_info *link_info)
6590 {
6591   struct elf32_arm_link_hash_table * globals;
6592
6593   if (link_info == NULL)
6594     /* Ignore this if we are not called by the ELF backend linker.  */
6595     return;
6596
6597   globals = elf32_arm_hash_table (link_info);
6598   /* If blx is available then exported Thumb symbols are OK and there is
6599      nothing to do.  */
6600   if (globals->use_blx)
6601     return;
6602
6603   elf_link_hash_traverse (&globals->root, elf32_arm_to_thumb_export_stub,
6604                           link_info);
6605 }
6606
6607 /* Some relocations map to different relocations depending on the
6608    target.  Return the real relocation.  */
6609
6610 static int
6611 arm_real_reloc_type (struct elf32_arm_link_hash_table * globals,
6612                      int r_type)
6613 {
6614   switch (r_type)
6615     {
6616     case R_ARM_TARGET1:
6617       if (globals->target1_is_rel)
6618         return R_ARM_REL32;
6619       else
6620         return R_ARM_ABS32;
6621
6622     case R_ARM_TARGET2:
6623       return globals->target2_reloc;
6624
6625     default:
6626       return r_type;
6627     }
6628 }
6629
6630 /* Return the base VMA address which should be subtracted from real addresses
6631    when resolving @dtpoff relocation.
6632    This is PT_TLS segment p_vaddr.  */
6633
6634 static bfd_vma
6635 dtpoff_base (struct bfd_link_info *info)
6636 {
6637   /* If tls_sec is NULL, we should have signalled an error already.  */
6638   if (elf_hash_table (info)->tls_sec == NULL)
6639     return 0;
6640   return elf_hash_table (info)->tls_sec->vma;
6641 }
6642
6643 /* Return the relocation value for @tpoff relocation
6644    if STT_TLS virtual address is ADDRESS.  */
6645
6646 static bfd_vma
6647 tpoff (struct bfd_link_info *info, bfd_vma address)
6648 {
6649   struct elf_link_hash_table *htab = elf_hash_table (info);
6650   bfd_vma base;
6651
6652   /* If tls_sec is NULL, we should have signalled an error already.  */
6653   if (htab->tls_sec == NULL)
6654     return 0;
6655   base = align_power ((bfd_vma) TCB_SIZE, htab->tls_sec->alignment_power);
6656   return address - htab->tls_sec->vma + base;
6657 }
6658
6659 /* Perform an R_ARM_ABS12 relocation on the field pointed to by DATA.
6660    VALUE is the relocation value.  */
6661
6662 static bfd_reloc_status_type
6663 elf32_arm_abs12_reloc (bfd *abfd, void *data, bfd_vma value)
6664 {
6665   if (value > 0xfff)
6666     return bfd_reloc_overflow;
6667
6668   value |= bfd_get_32 (abfd, data) & 0xfffff000;
6669   bfd_put_32 (abfd, value, data);
6670   return bfd_reloc_ok;
6671 }
6672
6673 /* For a given value of n, calculate the value of G_n as required to
6674    deal with group relocations.  We return it in the form of an
6675    encoded constant-and-rotation, together with the final residual.  If n is
6676    specified as less than zero, then final_residual is filled with the
6677    input value and no further action is performed.  */
6678
6679 static bfd_vma
6680 calculate_group_reloc_mask (bfd_vma value, int n, bfd_vma *final_residual)
6681 {
6682   int current_n;
6683   bfd_vma g_n;
6684   bfd_vma encoded_g_n = 0;
6685   bfd_vma residual = value; /* Also known as Y_n.  */
6686
6687   for (current_n = 0; current_n <= n; current_n++)
6688     {
6689       int shift;
6690
6691       /* Calculate which part of the value to mask.  */
6692       if (residual == 0)
6693         shift = 0;
6694       else
6695         {
6696           int msb;
6697
6698           /* Determine the most significant bit in the residual and
6699              align the resulting value to a 2-bit boundary.  */
6700           for (msb = 30; msb >= 0; msb -= 2)
6701             if (residual & (3 << msb))
6702               break;
6703
6704           /* The desired shift is now (msb - 6), or zero, whichever
6705              is the greater.  */
6706           shift = msb - 6;
6707           if (shift < 0)
6708             shift = 0;
6709         }
6710
6711       /* Calculate g_n in 32-bit as well as encoded constant+rotation form.  */
6712       g_n = residual & (0xff << shift);
6713       encoded_g_n = (g_n >> shift)
6714                     | ((g_n <= 0xff ? 0 : (32 - shift) / 2) << 8);
6715
6716       /* Calculate the residual for the next time around.  */
6717       residual &= ~g_n;
6718     }
6719
6720   *final_residual = residual;
6721
6722   return encoded_g_n;
6723 }
6724
6725 /* Given an ARM instruction, determine whether it is an ADD or a SUB.
6726    Returns 1 if it is an ADD, -1 if it is a SUB, and 0 otherwise.  */
6727
6728 static int
6729 identify_add_or_sub (bfd_vma insn)
6730 {
6731   int opcode = insn & 0x1e00000;
6732
6733   if (opcode == 1 << 23) /* ADD */
6734     return 1;
6735
6736   if (opcode == 1 << 22) /* SUB */
6737     return -1;
6738
6739   return 0;
6740 }
6741
6742 /* Perform a relocation as part of a final link.  */
6743
6744 static bfd_reloc_status_type
6745 elf32_arm_final_link_relocate (reloc_howto_type *           howto,
6746                                bfd *                        input_bfd,
6747                                bfd *                        output_bfd,
6748                                asection *                   input_section,
6749                                bfd_byte *                   contents,
6750                                Elf_Internal_Rela *          rel,
6751                                bfd_vma                      value,
6752                                struct bfd_link_info *       info,
6753                                asection *                   sym_sec,
6754                                const char *                 sym_name,
6755                                int                          sym_flags,
6756                                struct elf_link_hash_entry * h,
6757                                bfd_boolean *                unresolved_reloc_p,
6758                                char **                      error_message)
6759 {
6760   unsigned long                 r_type = howto->type;
6761   unsigned long                 r_symndx;
6762   bfd_byte *                    hit_data = contents + rel->r_offset;
6763   bfd *                         dynobj = NULL;
6764   Elf_Internal_Shdr *           symtab_hdr;
6765   struct elf_link_hash_entry ** sym_hashes;
6766   bfd_vma *                     local_got_offsets;
6767   asection *                    sgot = NULL;
6768   asection *                    splt = NULL;
6769   asection *                    sreloc = NULL;
6770   bfd_vma                       addend;
6771   bfd_signed_vma                signed_addend;
6772   struct elf32_arm_link_hash_table * globals;
6773
6774   globals = elf32_arm_hash_table (info);
6775
6776   BFD_ASSERT (is_arm_elf (input_bfd));
6777
6778   /* Some relocation types map to different relocations depending on the
6779      target.  We pick the right one here.  */
6780   r_type = arm_real_reloc_type (globals, r_type);
6781   if (r_type != howto->type)
6782     howto = elf32_arm_howto_from_type (r_type);
6783
6784   /* If the start address has been set, then set the EF_ARM_HASENTRY
6785      flag.  Setting this more than once is redundant, but the cost is
6786      not too high, and it keeps the code simple.
6787
6788      The test is done  here, rather than somewhere else, because the
6789      start address is only set just before the final link commences.
6790
6791      Note - if the user deliberately sets a start address of 0, the
6792      flag will not be set.  */
6793   if (bfd_get_start_address (output_bfd) != 0)
6794     elf_elfheader (output_bfd)->e_flags |= EF_ARM_HASENTRY;
6795
6796   dynobj = elf_hash_table (info)->dynobj;
6797   if (dynobj)
6798     {
6799       sgot = bfd_get_section_by_name (dynobj, ".got");
6800       splt = bfd_get_section_by_name (dynobj, ".plt");
6801     }
6802   symtab_hdr = & elf_symtab_hdr (input_bfd);
6803   sym_hashes = elf_sym_hashes (input_bfd);
6804   local_got_offsets = elf_local_got_offsets (input_bfd);
6805   r_symndx = ELF32_R_SYM (rel->r_info);
6806
6807   if (globals->use_rel)
6808     {
6809       addend = bfd_get_32 (input_bfd, hit_data) & howto->src_mask;
6810
6811       if (addend & ((howto->src_mask + 1) >> 1))
6812         {
6813           signed_addend = -1;
6814           signed_addend &= ~ howto->src_mask;
6815           signed_addend |= addend;
6816         }
6817       else
6818         signed_addend = addend;
6819     }
6820   else
6821     addend = signed_addend = rel->r_addend;
6822
6823   switch (r_type)
6824     {
6825     case R_ARM_NONE:
6826       /* We don't need to find a value for this symbol.  It's just a
6827          marker.  */
6828       *unresolved_reloc_p = FALSE;
6829       return bfd_reloc_ok;
6830
6831     case R_ARM_ABS12:
6832       if (!globals->vxworks_p)
6833         return elf32_arm_abs12_reloc (input_bfd, hit_data, value + addend);
6834
6835     case R_ARM_PC24:
6836     case R_ARM_ABS32:
6837     case R_ARM_ABS32_NOI:
6838     case R_ARM_REL32:
6839     case R_ARM_REL32_NOI:
6840     case R_ARM_CALL:
6841     case R_ARM_JUMP24:
6842     case R_ARM_XPC25:
6843     case R_ARM_PREL31:
6844     case R_ARM_PLT32:
6845       /* Handle relocations which should use the PLT entry.  ABS32/REL32
6846          will use the symbol's value, which may point to a PLT entry, but we
6847          don't need to handle that here.  If we created a PLT entry, all
6848          branches in this object should go to it, except if the PLT is too
6849          far away, in which case a long branch stub should be inserted.  */
6850       if ((r_type != R_ARM_ABS32 && r_type != R_ARM_REL32
6851            && r_type != R_ARM_ABS32_NOI && r_type != R_ARM_REL32_NOI
6852            && r_type != R_ARM_CALL
6853            && r_type != R_ARM_JUMP24
6854            && r_type != R_ARM_PLT32)
6855           && h != NULL
6856           && splt != NULL
6857           && h->plt.offset != (bfd_vma) -1)
6858         {
6859           /* If we've created a .plt section, and assigned a PLT entry to
6860              this function, it should not be known to bind locally.  If
6861              it were, we would have cleared the PLT entry.  */
6862           BFD_ASSERT (!SYMBOL_CALLS_LOCAL (info, h));
6863
6864           value = (splt->output_section->vma
6865                    + splt->output_offset
6866                    + h->plt.offset);
6867           *unresolved_reloc_p = FALSE;
6868           return _bfd_final_link_relocate (howto, input_bfd, input_section,
6869                                            contents, rel->r_offset, value,
6870                                            rel->r_addend);
6871         }
6872
6873       /* When generating a shared object or relocatable executable, these
6874          relocations are copied into the output file to be resolved at
6875          run time.  */
6876       if ((info->shared || globals->root.is_relocatable_executable)
6877           && (input_section->flags & SEC_ALLOC)
6878           && !(elf32_arm_hash_table (info)->vxworks_p
6879                && strcmp (input_section->output_section->name,
6880                           ".tls_vars") == 0)
6881           && ((r_type != R_ARM_REL32 && r_type != R_ARM_REL32_NOI)
6882               || !SYMBOL_CALLS_LOCAL (info, h))
6883           && (h == NULL
6884               || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
6885               || h->root.type != bfd_link_hash_undefweak)
6886           && r_type != R_ARM_PC24
6887           && r_type != R_ARM_CALL
6888           && r_type != R_ARM_JUMP24
6889           && r_type != R_ARM_PREL31
6890           && r_type != R_ARM_PLT32)
6891         {
6892           Elf_Internal_Rela outrel;
6893           bfd_byte *loc;
6894           bfd_boolean skip, relocate;
6895
6896           *unresolved_reloc_p = FALSE;
6897
6898           if (sreloc == NULL)
6899             {
6900               sreloc = _bfd_elf_get_dynamic_reloc_section (input_bfd, input_section,
6901                                                            ! globals->use_rel);
6902
6903               if (sreloc == NULL)
6904                 return bfd_reloc_notsupported;
6905             }
6906
6907           skip = FALSE;
6908           relocate = FALSE;
6909
6910           outrel.r_addend = addend;
6911           outrel.r_offset =
6912             _bfd_elf_section_offset (output_bfd, info, input_section,
6913                                      rel->r_offset);
6914           if (outrel.r_offset == (bfd_vma) -1)
6915             skip = TRUE;
6916           else if (outrel.r_offset == (bfd_vma) -2)
6917             skip = TRUE, relocate = TRUE;
6918           outrel.r_offset += (input_section->output_section->vma
6919                               + input_section->output_offset);
6920
6921           if (skip)
6922             memset (&outrel, 0, sizeof outrel);
6923           else if (h != NULL
6924                    && h->dynindx != -1
6925                    && (!info->shared
6926                        || !info->symbolic
6927                        || !h->def_regular))
6928             outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
6929           else
6930             {
6931               int symbol;
6932
6933               /* This symbol is local, or marked to become local.  */
6934               if (sym_flags == STT_ARM_TFUNC)
6935                 value |= 1;
6936               if (globals->symbian_p)
6937                 {
6938                   asection *osec;
6939
6940                   /* On Symbian OS, the data segment and text segement
6941                      can be relocated independently.  Therefore, we
6942                      must indicate the segment to which this
6943                      relocation is relative.  The BPABI allows us to
6944                      use any symbol in the right segment; we just use
6945                      the section symbol as it is convenient.  (We
6946                      cannot use the symbol given by "h" directly as it
6947                      will not appear in the dynamic symbol table.)
6948
6949                      Note that the dynamic linker ignores the section
6950                      symbol value, so we don't subtract osec->vma
6951                      from the emitted reloc addend.  */
6952                   if (sym_sec)
6953                     osec = sym_sec->output_section;
6954                   else
6955                     osec = input_section->output_section;
6956                   symbol = elf_section_data (osec)->dynindx;
6957                   if (symbol == 0)
6958                     {
6959                       struct elf_link_hash_table *htab = elf_hash_table (info);
6960
6961                       if ((osec->flags & SEC_READONLY) == 0
6962                           && htab->data_index_section != NULL)
6963                         osec = htab->data_index_section;
6964                       else
6965                         osec = htab->text_index_section;
6966                       symbol = elf_section_data (osec)->dynindx;
6967                     }
6968                   BFD_ASSERT (symbol != 0);
6969                 }
6970               else
6971                 /* On SVR4-ish systems, the dynamic loader cannot
6972                    relocate the text and data segments independently,
6973                    so the symbol does not matter.  */
6974                 symbol = 0;
6975               outrel.r_info = ELF32_R_INFO (symbol, R_ARM_RELATIVE);
6976               if (globals->use_rel)
6977                 relocate = TRUE;
6978               else
6979                 outrel.r_addend += value;
6980             }
6981
6982           loc = sreloc->contents;
6983           loc += sreloc->reloc_count++ * RELOC_SIZE (globals);
6984           SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
6985
6986           /* If this reloc is against an external symbol, we do not want to
6987              fiddle with the addend.  Otherwise, we need to include the symbol
6988              value so that it becomes an addend for the dynamic reloc.  */
6989           if (! relocate)
6990             return bfd_reloc_ok;
6991
6992           return _bfd_final_link_relocate (howto, input_bfd, input_section,
6993                                            contents, rel->r_offset, value,
6994                                            (bfd_vma) 0);
6995         }
6996       else switch (r_type)
6997         {
6998         case R_ARM_ABS12:
6999           return elf32_arm_abs12_reloc (input_bfd, hit_data, value + addend);
7000
7001         case R_ARM_XPC25:         /* Arm BLX instruction.  */
7002         case R_ARM_CALL:
7003         case R_ARM_JUMP24:
7004         case R_ARM_PC24:          /* Arm B/BL instruction.  */
7005         case R_ARM_PLT32:
7006           {
7007           bfd_signed_vma branch_offset;
7008           struct elf32_arm_stub_hash_entry *stub_entry = NULL;
7009
7010           if (r_type == R_ARM_XPC25)
7011             {
7012               /* Check for Arm calling Arm function.  */
7013               /* FIXME: Should we translate the instruction into a BL
7014                  instruction instead ?  */
7015               if (sym_flags != STT_ARM_TFUNC)
7016                 (*_bfd_error_handler)
7017                   (_("\%B: Warning: Arm BLX instruction targets Arm function '%s'."),
7018                    input_bfd,
7019                    h ? h->root.root.string : "(local)");
7020             }
7021           else if (r_type == R_ARM_PC24)
7022             {
7023               /* Check for Arm calling Thumb function.  */
7024               if (sym_flags == STT_ARM_TFUNC)
7025                 {
7026                   if (elf32_arm_to_thumb_stub (info, sym_name, input_bfd,
7027                                                output_bfd, input_section,
7028                                                hit_data, sym_sec, rel->r_offset,
7029                                                signed_addend, value,
7030                                                error_message))
7031                     return bfd_reloc_ok;
7032                   else
7033                     return bfd_reloc_dangerous;
7034                 }
7035             }
7036
7037           /* Check if a stub has to be inserted because the
7038              destination is too far or we are changing mode.  */
7039           if (   r_type == R_ARM_CALL
7040               || r_type == R_ARM_JUMP24
7041               || r_type == R_ARM_PLT32)
7042             {
7043               bfd_vma from;
7044
7045               /* If the call goes through a PLT entry, make sure to
7046                  check distance to the right destination address.  */
7047               if (h != NULL && splt != NULL && h->plt.offset != (bfd_vma) -1)
7048                 {
7049                   value = (splt->output_section->vma
7050                            + splt->output_offset
7051                            + h->plt.offset);
7052                   *unresolved_reloc_p = FALSE;
7053                   /* The PLT entry is in ARM mode, regardless of the
7054                      target function.  */
7055                   sym_flags = STT_FUNC;
7056                 }
7057
7058               from = (input_section->output_section->vma
7059                       + input_section->output_offset
7060                       + rel->r_offset);
7061               branch_offset = (bfd_signed_vma)(value - from);
7062
7063               if (branch_offset > ARM_MAX_FWD_BRANCH_OFFSET
7064                   || branch_offset < ARM_MAX_BWD_BRANCH_OFFSET
7065                   || ((sym_flags == STT_ARM_TFUNC)
7066                       && (((r_type == R_ARM_CALL) && !globals->use_blx)
7067                           || (r_type == R_ARM_JUMP24)
7068                           || (r_type == R_ARM_PLT32) ))
7069                   )
7070                 {
7071                   /* The target is out of reach, so redirect the
7072                      branch to the local stub for this function.  */
7073
7074                   stub_entry = elf32_arm_get_stub_entry (input_section,
7075                                                          sym_sec, h,
7076                                                          rel, globals);
7077                   if (stub_entry != NULL)
7078                     value = (stub_entry->stub_offset
7079                              + stub_entry->stub_sec->output_offset
7080                              + stub_entry->stub_sec->output_section->vma);
7081                 }
7082             }
7083
7084           /* The ARM ELF ABI says that this reloc is computed as: S - P + A
7085              where:
7086               S is the address of the symbol in the relocation.
7087               P is address of the instruction being relocated.
7088               A is the addend (extracted from the instruction) in bytes.
7089
7090              S is held in 'value'.
7091              P is the base address of the section containing the
7092                instruction plus the offset of the reloc into that
7093                section, ie:
7094                  (input_section->output_section->vma +
7095                   input_section->output_offset +
7096                   rel->r_offset).
7097              A is the addend, converted into bytes, ie:
7098                  (signed_addend * 4)
7099
7100              Note: None of these operations have knowledge of the pipeline
7101              size of the processor, thus it is up to the assembler to
7102              encode this information into the addend.  */
7103           value -= (input_section->output_section->vma
7104                     + input_section->output_offset);
7105           value -= rel->r_offset;
7106           if (globals->use_rel)
7107             value += (signed_addend << howto->size);
7108           else
7109             /* RELA addends do not have to be adjusted by howto->size.  */
7110             value += signed_addend;
7111
7112           signed_addend = value;
7113           signed_addend >>= howto->rightshift;
7114
7115           /* A branch to an undefined weak symbol is turned into a jump to
7116              the next instruction unless a PLT entry will be created.
7117              Do the same for local undefined symbols.
7118              The jump to the next instruction is optimized as a NOP depending
7119              on the architecture.  */
7120           if (h ? (h->root.type == bfd_link_hash_undefweak
7121                    && !(splt != NULL && h->plt.offset != (bfd_vma) -1))
7122               : bfd_is_und_section (sym_sec))
7123             {
7124               value = (bfd_get_32 (input_bfd, hit_data) & 0xf0000000);
7125
7126               if (arch_has_arm_nop (globals))
7127                 value |= 0x0320f000;
7128               else
7129                 value |= 0x01a00000; /* Using pre-UAL nop: mov r0, r0.  */
7130             }
7131           else
7132             {
7133               /* Perform a signed range check.  */
7134               if (   signed_addend >   ((bfd_signed_vma)  (howto->dst_mask >> 1))
7135                   || signed_addend < - ((bfd_signed_vma) ((howto->dst_mask + 1) >> 1)))
7136                 return bfd_reloc_overflow;
7137
7138               addend = (value & 2);
7139
7140               value = (signed_addend & howto->dst_mask)
7141                 | (bfd_get_32 (input_bfd, hit_data) & (~ howto->dst_mask));
7142
7143               if (r_type == R_ARM_CALL)
7144                 {
7145                   /* Set the H bit in the BLX instruction.  */
7146                   if (sym_flags == STT_ARM_TFUNC)
7147                     {
7148                       if (addend)
7149                         value |= (1 << 24);
7150                       else
7151                         value &= ~(bfd_vma)(1 << 24);
7152                     }
7153
7154                   /* Select the correct instruction (BL or BLX).  */
7155                   /* Only if we are not handling a BL to a stub. In this
7156                      case, mode switching is performed by the stub.  */
7157                   if (sym_flags == STT_ARM_TFUNC && !stub_entry)
7158                     value |= (1 << 28);
7159                   else
7160                     {
7161                       value &= ~(bfd_vma)(1 << 28);
7162                       value |= (1 << 24);
7163                     }
7164                 }
7165             }
7166           }
7167           break;
7168
7169         case R_ARM_ABS32:
7170           value += addend;
7171           if (sym_flags == STT_ARM_TFUNC)
7172             value |= 1;
7173           break;
7174
7175         case R_ARM_ABS32_NOI:
7176           value += addend;
7177           break;
7178
7179         case R_ARM_REL32:
7180           value += addend;
7181           if (sym_flags == STT_ARM_TFUNC)
7182             value |= 1;
7183           value -= (input_section->output_section->vma
7184                     + input_section->output_offset + rel->r_offset);
7185           break;
7186
7187         case R_ARM_REL32_NOI:
7188           value += addend;
7189           value -= (input_section->output_section->vma
7190                     + input_section->output_offset + rel->r_offset);
7191           break;
7192
7193         case R_ARM_PREL31:
7194           value -= (input_section->output_section->vma
7195                     + input_section->output_offset + rel->r_offset);
7196           value += signed_addend;
7197           if (! h || h->root.type != bfd_link_hash_undefweak)
7198             {
7199               /* Check for overflow.  */
7200               if ((value ^ (value >> 1)) & (1 << 30))
7201                 return bfd_reloc_overflow;
7202             }
7203           value &= 0x7fffffff;
7204           value |= (bfd_get_32 (input_bfd, hit_data) & 0x80000000);
7205           if (sym_flags == STT_ARM_TFUNC)
7206             value |= 1;
7207           break;
7208         }
7209
7210       bfd_put_32 (input_bfd, value, hit_data);
7211       return bfd_reloc_ok;
7212
7213     case R_ARM_ABS8:
7214       value += addend;
7215       if ((long) value > 0x7f || (long) value < -0x80)
7216         return bfd_reloc_overflow;
7217
7218       bfd_put_8 (input_bfd, value, hit_data);
7219       return bfd_reloc_ok;
7220
7221     case R_ARM_ABS16:
7222       value += addend;
7223
7224       if ((long) value > 0x7fff || (long) value < -0x8000)
7225         return bfd_reloc_overflow;
7226
7227       bfd_put_16 (input_bfd, value, hit_data);
7228       return bfd_reloc_ok;
7229
7230     case R_ARM_THM_ABS5:
7231       /* Support ldr and str instructions for the thumb.  */
7232       if (globals->use_rel)
7233         {
7234           /* Need to refetch addend.  */
7235           addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
7236           /* ??? Need to determine shift amount from operand size.  */
7237           addend >>= howto->rightshift;
7238         }
7239       value += addend;
7240
7241       /* ??? Isn't value unsigned?  */
7242       if ((long) value > 0x1f || (long) value < -0x10)
7243         return bfd_reloc_overflow;
7244
7245       /* ??? Value needs to be properly shifted into place first.  */
7246       value |= bfd_get_16 (input_bfd, hit_data) & 0xf83f;
7247       bfd_put_16 (input_bfd, value, hit_data);
7248       return bfd_reloc_ok;
7249
7250     case R_ARM_THM_ALU_PREL_11_0:
7251       /* Corresponds to: addw.w reg, pc, #offset (and similarly for subw).  */
7252       {
7253         bfd_vma insn;
7254         bfd_signed_vma relocation;
7255
7256         insn = (bfd_get_16 (input_bfd, hit_data) << 16)
7257              | bfd_get_16 (input_bfd, hit_data + 2);
7258
7259         if (globals->use_rel)
7260           {
7261             signed_addend = (insn & 0xff) | ((insn & 0x7000) >> 4)
7262                           | ((insn & (1 << 26)) >> 15);
7263             if (insn & 0xf00000)
7264               signed_addend = -signed_addend;
7265           }
7266
7267         relocation = value + signed_addend;
7268         relocation -= (input_section->output_section->vma
7269                        + input_section->output_offset
7270                        + rel->r_offset);
7271
7272         value = abs (relocation);
7273
7274         if (value >= 0x1000)
7275           return bfd_reloc_overflow;
7276
7277         insn = (insn & 0xfb0f8f00) | (value & 0xff)
7278              | ((value & 0x700) << 4)
7279              | ((value & 0x800) << 15);
7280         if (relocation < 0)
7281           insn |= 0xa00000;
7282
7283         bfd_put_16 (input_bfd, insn >> 16, hit_data);
7284         bfd_put_16 (input_bfd, insn & 0xffff, hit_data + 2);
7285
7286         return bfd_reloc_ok;
7287       }
7288
7289     case R_ARM_THM_PC8:
7290       /* PR 10073:  This reloc is not generated by the GNU toolchain,
7291          but it is supported for compatibility with third party libraries
7292          generated by other compilers, specifically the ARM/IAR.  */
7293       {
7294         bfd_vma insn;
7295         bfd_signed_vma relocation;
7296
7297         insn = bfd_get_16 (input_bfd, hit_data);
7298
7299         if (globals->use_rel)
7300           addend = (insn & 0x00ff) << 2;
7301
7302         relocation = value + addend;
7303         relocation -= (input_section->output_section->vma
7304                        + input_section->output_offset
7305                        + rel->r_offset);
7306
7307         value = abs (relocation);
7308
7309         /* We do not check for overflow of this reloc.  Although strictly
7310            speaking this is incorrect, it appears to be necessary in order
7311            to work with IAR generated relocs.  Since GCC and GAS do not
7312            generate R_ARM_THM_PC8 relocs, the lack of a check should not be
7313            a problem for them.  */
7314         value &= 0x3fc;
7315
7316         insn = (insn & 0xff00) | (value >> 2);
7317
7318         bfd_put_16 (input_bfd, insn, hit_data);
7319
7320         return bfd_reloc_ok;
7321       }
7322
7323     case R_ARM_THM_PC12:
7324       /* Corresponds to: ldr.w reg, [pc, #offset].  */
7325       {
7326         bfd_vma insn;
7327         bfd_signed_vma relocation;
7328
7329         insn = (bfd_get_16 (input_bfd, hit_data) << 16)
7330              | bfd_get_16 (input_bfd, hit_data + 2);
7331
7332         if (globals->use_rel)
7333           {
7334             signed_addend = insn & 0xfff;
7335             if (!(insn & (1 << 23)))
7336               signed_addend = -signed_addend;
7337           }
7338
7339         relocation = value + signed_addend;
7340         relocation -= (input_section->output_section->vma
7341                        + input_section->output_offset
7342                        + rel->r_offset);
7343
7344         value = abs (relocation);
7345
7346         if (value >= 0x1000)
7347           return bfd_reloc_overflow;
7348
7349         insn = (insn & 0xff7ff000) | value;
7350         if (relocation >= 0)
7351           insn |= (1 << 23);
7352
7353         bfd_put_16 (input_bfd, insn >> 16, hit_data);
7354         bfd_put_16 (input_bfd, insn & 0xffff, hit_data + 2);
7355
7356         return bfd_reloc_ok;
7357       }
7358
7359     case R_ARM_THM_XPC22:
7360     case R_ARM_THM_CALL:
7361     case R_ARM_THM_JUMP24:
7362       /* Thumb BL (branch long instruction).  */
7363       {
7364         bfd_vma relocation;
7365         bfd_vma reloc_sign;
7366         bfd_boolean overflow = FALSE;
7367         bfd_vma upper_insn = bfd_get_16 (input_bfd, hit_data);
7368         bfd_vma lower_insn = bfd_get_16 (input_bfd, hit_data + 2);
7369         bfd_signed_vma reloc_signed_max;
7370         bfd_signed_vma reloc_signed_min;
7371         bfd_vma check;
7372         bfd_signed_vma signed_check;
7373         int bitsize;
7374         const int thumb2 = using_thumb2 (globals);
7375
7376         /* A branch to an undefined weak symbol is turned into a jump to
7377            the next instruction unless a PLT entry will be created.
7378            The jump to the next instruction is optimized as a NOP.W for
7379            Thumb-2 enabled architectures.  */
7380         if (h && h->root.type == bfd_link_hash_undefweak
7381             && !(splt != NULL && h->plt.offset != (bfd_vma) -1))
7382           {
7383             if (arch_has_thumb2_nop (globals))
7384               {
7385                 bfd_put_16 (input_bfd, 0xf3af, hit_data);
7386                 bfd_put_16 (input_bfd, 0x8000, hit_data + 2);
7387               }
7388             else
7389               {
7390                 bfd_put_16 (input_bfd, 0xe000, hit_data);
7391                 bfd_put_16 (input_bfd, 0xbf00, hit_data + 2);
7392               }
7393             return bfd_reloc_ok;
7394           }
7395
7396         /* Fetch the addend.  We use the Thumb-2 encoding (backwards compatible
7397            with Thumb-1) involving the J1 and J2 bits.  */
7398         if (globals->use_rel)
7399           {
7400             bfd_vma s = (upper_insn & (1 << 10)) >> 10;
7401             bfd_vma upper = upper_insn & 0x3ff;
7402             bfd_vma lower = lower_insn & 0x7ff;
7403             bfd_vma j1 = (lower_insn & (1 << 13)) >> 13;
7404             bfd_vma j2 = (lower_insn & (1 << 11)) >> 11;
7405             bfd_vma i1 = j1 ^ s ? 0 : 1;
7406             bfd_vma i2 = j2 ^ s ? 0 : 1;
7407
7408             addend = (i1 << 23) | (i2 << 22) | (upper << 12) | (lower << 1);
7409             /* Sign extend.  */
7410             addend = (addend | ((s ? 0 : 1) << 24)) - (1 << 24);
7411
7412             signed_addend = addend;
7413           }
7414
7415         if (r_type == R_ARM_THM_XPC22)
7416           {
7417             /* Check for Thumb to Thumb call.  */
7418             /* FIXME: Should we translate the instruction into a BL
7419                instruction instead ?  */
7420             if (sym_flags == STT_ARM_TFUNC)
7421               (*_bfd_error_handler)
7422                 (_("%B: Warning: Thumb BLX instruction targets thumb function '%s'."),
7423                  input_bfd,
7424                  h ? h->root.root.string : "(local)");
7425           }
7426         else
7427           {
7428             /* If it is not a call to Thumb, assume call to Arm.
7429                If it is a call relative to a section name, then it is not a
7430                function call at all, but rather a long jump.  Calls through
7431                the PLT do not require stubs.  */
7432             if (sym_flags != STT_ARM_TFUNC && sym_flags != STT_SECTION
7433                 && (h == NULL || splt == NULL
7434                     || h->plt.offset == (bfd_vma) -1))
7435               {
7436                 if (globals->use_blx && r_type == R_ARM_THM_CALL)
7437                   {
7438                     /* Convert BL to BLX.  */
7439                     lower_insn = (lower_insn & ~0x1000) | 0x0800;
7440                   }
7441                 else if ((   r_type != R_ARM_THM_CALL)
7442                          && (r_type != R_ARM_THM_JUMP24))
7443                   {
7444                     if (elf32_thumb_to_arm_stub
7445                         (info, sym_name, input_bfd, output_bfd, input_section,
7446                          hit_data, sym_sec, rel->r_offset, signed_addend, value,
7447                          error_message))
7448                       return bfd_reloc_ok;
7449                     else
7450                       return bfd_reloc_dangerous;
7451                   }
7452               }
7453             else if (sym_flags == STT_ARM_TFUNC && globals->use_blx
7454                      && r_type == R_ARM_THM_CALL)
7455               {
7456                 /* Make sure this is a BL.  */
7457                 lower_insn |= 0x1800;
7458               }
7459           }
7460
7461         /* Handle calls via the PLT.  */
7462         if (h != NULL && splt != NULL && h->plt.offset != (bfd_vma) -1)
7463           {
7464             value = (splt->output_section->vma
7465                      + splt->output_offset
7466                      + h->plt.offset);
7467             if (globals->use_blx && r_type == R_ARM_THM_CALL)
7468               {
7469                 /* If the Thumb BLX instruction is available, convert the
7470                    BL to a BLX instruction to call the ARM-mode PLT entry.  */
7471                 lower_insn = (lower_insn & ~0x1000) | 0x0800;
7472                 sym_flags = STT_FUNC;
7473               }
7474             else
7475               {
7476                 /* Target the Thumb stub before the ARM PLT entry.  */
7477                 value -= PLT_THUMB_STUB_SIZE;
7478                 sym_flags = STT_ARM_TFUNC;
7479               }
7480             *unresolved_reloc_p = FALSE;
7481           }
7482
7483         if (r_type == R_ARM_THM_CALL || r_type == R_ARM_THM_JUMP24)
7484           {
7485             /* Check if a stub has to be inserted because the destination
7486                is too far.  */
7487             bfd_vma from;
7488             bfd_signed_vma branch_offset;
7489             struct elf32_arm_stub_hash_entry *stub_entry = NULL;
7490
7491             from = (input_section->output_section->vma
7492                     + input_section->output_offset
7493                     + rel->r_offset);
7494             branch_offset = (bfd_signed_vma)(value - from);
7495
7496             if ((!thumb2
7497                  && (branch_offset > THM_MAX_FWD_BRANCH_OFFSET
7498                      || (branch_offset < THM_MAX_BWD_BRANCH_OFFSET)))
7499                 ||
7500                 (thumb2
7501                  && (branch_offset > THM2_MAX_FWD_BRANCH_OFFSET
7502                      || (branch_offset < THM2_MAX_BWD_BRANCH_OFFSET)))
7503                 || ((sym_flags != STT_ARM_TFUNC)
7504                     && (((r_type == R_ARM_THM_CALL) && !globals->use_blx)
7505                         || r_type == R_ARM_THM_JUMP24)))
7506               {
7507                 /* The target is out of reach or we are changing modes, so
7508                    redirect the branch to the local stub for this
7509                    function.  */
7510                 stub_entry = elf32_arm_get_stub_entry (input_section,
7511                                                        sym_sec, h,
7512                                                        rel, globals);
7513                 if (stub_entry != NULL)
7514                   value = (stub_entry->stub_offset
7515                            + stub_entry->stub_sec->output_offset
7516                            + stub_entry->stub_sec->output_section->vma);
7517
7518                 /* If this call becomes a call to Arm, force BLX.  */
7519                 if (globals->use_blx && (r_type == R_ARM_THM_CALL))
7520                   {
7521                     if ((stub_entry
7522                          && !arm_stub_is_thumb (stub_entry->stub_type))
7523                         || (sym_flags != STT_ARM_TFUNC))
7524                       lower_insn = (lower_insn & ~0x1000) | 0x0800;
7525                   }
7526               }
7527           }
7528
7529         relocation = value + signed_addend;
7530
7531         relocation -= (input_section->output_section->vma
7532                        + input_section->output_offset
7533                        + rel->r_offset);
7534
7535         check = relocation >> howto->rightshift;
7536
7537         /* If this is a signed value, the rightshift just dropped
7538            leading 1 bits (assuming twos complement).  */
7539         if ((bfd_signed_vma) relocation >= 0)
7540           signed_check = check;
7541         else
7542           signed_check = check | ~((bfd_vma) -1 >> howto->rightshift);
7543
7544         /* Calculate the permissable maximum and minimum values for
7545            this relocation according to whether we're relocating for
7546            Thumb-2 or not.  */
7547         bitsize = howto->bitsize;
7548         if (!thumb2)
7549           bitsize -= 2;
7550         reloc_signed_max = ((1 << (bitsize - 1)) - 1) >> howto->rightshift;
7551         reloc_signed_min = ~reloc_signed_max;
7552
7553         /* Assumes two's complement.  */
7554         if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
7555           overflow = TRUE;
7556
7557         if ((lower_insn & 0x5000) == 0x4000)
7558           /* For a BLX instruction, make sure that the relocation is rounded up
7559              to a word boundary.  This follows the semantics of the instruction
7560              which specifies that bit 1 of the target address will come from bit
7561              1 of the base address.  */
7562           relocation = (relocation + 2) & ~ 3;
7563
7564         /* Put RELOCATION back into the insn.  Assumes two's complement.
7565            We use the Thumb-2 encoding, which is safe even if dealing with
7566            a Thumb-1 instruction by virtue of our overflow check above.  */
7567         reloc_sign = (signed_check < 0) ? 1 : 0;
7568         upper_insn = (upper_insn & ~(bfd_vma) 0x7ff)
7569                      | ((relocation >> 12) & 0x3ff)
7570                      | (reloc_sign << 10);
7571         lower_insn = (lower_insn & ~(bfd_vma) 0x2fff)
7572                      | (((!((relocation >> 23) & 1)) ^ reloc_sign) << 13)
7573                      | (((!((relocation >> 22) & 1)) ^ reloc_sign) << 11)
7574                      | ((relocation >> 1) & 0x7ff);
7575
7576         /* Put the relocated value back in the object file:  */
7577         bfd_put_16 (input_bfd, upper_insn, hit_data);
7578         bfd_put_16 (input_bfd, lower_insn, hit_data + 2);
7579
7580         return (overflow ? bfd_reloc_overflow : bfd_reloc_ok);
7581       }
7582       break;
7583
7584     case R_ARM_THM_JUMP19:
7585       /* Thumb32 conditional branch instruction.  */
7586       {
7587         bfd_vma relocation;
7588         bfd_boolean overflow = FALSE;
7589         bfd_vma upper_insn = bfd_get_16 (input_bfd, hit_data);
7590         bfd_vma lower_insn = bfd_get_16 (input_bfd, hit_data + 2);
7591         bfd_signed_vma reloc_signed_max = 0xffffe;
7592         bfd_signed_vma reloc_signed_min = -0x100000;
7593         bfd_signed_vma signed_check;
7594
7595         /* Need to refetch the addend, reconstruct the top three bits,
7596            and squish the two 11 bit pieces together.  */
7597         if (globals->use_rel)
7598           {
7599             bfd_vma S     = (upper_insn & 0x0400) >> 10;
7600             bfd_vma upper = (upper_insn & 0x003f);
7601             bfd_vma J1    = (lower_insn & 0x2000) >> 13;
7602             bfd_vma J2    = (lower_insn & 0x0800) >> 11;
7603             bfd_vma lower = (lower_insn & 0x07ff);
7604
7605             upper |= J1 << 6;
7606             upper |= J2 << 7;
7607             upper |= (!S) << 8;
7608             upper -= 0x0100; /* Sign extend.  */
7609
7610             addend = (upper << 12) | (lower << 1);
7611             signed_addend = addend;
7612           }
7613
7614         /* Handle calls via the PLT.  */
7615         if (h != NULL && splt != NULL && h->plt.offset != (bfd_vma) -1)
7616           {
7617             value = (splt->output_section->vma
7618                      + splt->output_offset
7619                      + h->plt.offset);
7620             /* Target the Thumb stub before the ARM PLT entry.  */
7621             value -= PLT_THUMB_STUB_SIZE;
7622             *unresolved_reloc_p = FALSE;
7623           }
7624
7625         /* ??? Should handle interworking?  GCC might someday try to
7626            use this for tail calls.  */
7627
7628         relocation = value + signed_addend;
7629         relocation -= (input_section->output_section->vma
7630                        + input_section->output_offset
7631                        + rel->r_offset);
7632         signed_check = (bfd_signed_vma) relocation;
7633
7634         if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
7635           overflow = TRUE;
7636
7637         /* Put RELOCATION back into the insn.  */
7638         {
7639           bfd_vma S  = (relocation & 0x00100000) >> 20;
7640           bfd_vma J2 = (relocation & 0x00080000) >> 19;
7641           bfd_vma J1 = (relocation & 0x00040000) >> 18;
7642           bfd_vma hi = (relocation & 0x0003f000) >> 12;
7643           bfd_vma lo = (relocation & 0x00000ffe) >>  1;
7644
7645           upper_insn = (upper_insn & 0xfbc0) | (S << 10) | hi;
7646           lower_insn = (lower_insn & 0xd000) | (J1 << 13) | (J2 << 11) | lo;
7647         }
7648
7649         /* Put the relocated value back in the object file:  */
7650         bfd_put_16 (input_bfd, upper_insn, hit_data);
7651         bfd_put_16 (input_bfd, lower_insn, hit_data + 2);
7652
7653         return (overflow ? bfd_reloc_overflow : bfd_reloc_ok);
7654       }
7655
7656     case R_ARM_THM_JUMP11:
7657     case R_ARM_THM_JUMP8:
7658     case R_ARM_THM_JUMP6:
7659       /* Thumb B (branch) instruction).  */
7660       {
7661         bfd_signed_vma relocation;
7662         bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
7663         bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
7664         bfd_signed_vma signed_check;
7665
7666         /* CZB cannot jump backward.  */
7667         if (r_type == R_ARM_THM_JUMP6)
7668           reloc_signed_min = 0;
7669
7670         if (globals->use_rel)
7671           {
7672             /* Need to refetch addend.  */
7673             addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
7674             if (addend & ((howto->src_mask + 1) >> 1))
7675               {
7676                 signed_addend = -1;
7677                 signed_addend &= ~ howto->src_mask;
7678                 signed_addend |= addend;
7679               }
7680             else
7681               signed_addend = addend;
7682             /* The value in the insn has been right shifted.  We need to
7683                undo this, so that we can perform the address calculation
7684                in terms of bytes.  */
7685             signed_addend <<= howto->rightshift;
7686           }
7687         relocation = value + signed_addend;
7688
7689         relocation -= (input_section->output_section->vma
7690                        + input_section->output_offset
7691                        + rel->r_offset);
7692
7693         relocation >>= howto->rightshift;
7694         signed_check = relocation;
7695
7696         if (r_type == R_ARM_THM_JUMP6)
7697           relocation = ((relocation & 0x0020) << 4) | ((relocation & 0x001f) << 3);
7698         else
7699           relocation &= howto->dst_mask;
7700         relocation |= (bfd_get_16 (input_bfd, hit_data) & (~ howto->dst_mask));
7701
7702         bfd_put_16 (input_bfd, relocation, hit_data);
7703
7704         /* Assumes two's complement.  */
7705         if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
7706           return bfd_reloc_overflow;
7707
7708         return bfd_reloc_ok;
7709       }
7710
7711     case R_ARM_ALU_PCREL7_0:
7712     case R_ARM_ALU_PCREL15_8:
7713     case R_ARM_ALU_PCREL23_15:
7714       {
7715         bfd_vma insn;
7716         bfd_vma relocation;
7717
7718         insn = bfd_get_32 (input_bfd, hit_data);
7719         if (globals->use_rel)
7720           {
7721             /* Extract the addend.  */
7722             addend = (insn & 0xff) << ((insn & 0xf00) >> 7);
7723             signed_addend = addend;
7724           }
7725         relocation = value + signed_addend;
7726
7727         relocation -= (input_section->output_section->vma
7728                        + input_section->output_offset
7729                        + rel->r_offset);
7730         insn = (insn & ~0xfff)
7731                | ((howto->bitpos << 7) & 0xf00)
7732                | ((relocation >> howto->bitpos) & 0xff);
7733         bfd_put_32 (input_bfd, value, hit_data);
7734       }
7735       return bfd_reloc_ok;
7736
7737     case R_ARM_GNU_VTINHERIT:
7738     case R_ARM_GNU_VTENTRY:
7739       return bfd_reloc_ok;
7740
7741     case R_ARM_GOTOFF32:
7742       /* Relocation is relative to the start of the
7743          global offset table.  */
7744
7745       BFD_ASSERT (sgot != NULL);
7746       if (sgot == NULL)
7747         return bfd_reloc_notsupported;
7748
7749       /* If we are addressing a Thumb function, we need to adjust the
7750          address by one, so that attempts to call the function pointer will
7751          correctly interpret it as Thumb code.  */
7752       if (sym_flags == STT_ARM_TFUNC)
7753         value += 1;
7754
7755       /* Note that sgot->output_offset is not involved in this
7756          calculation.  We always want the start of .got.  If we
7757          define _GLOBAL_OFFSET_TABLE in a different way, as is
7758          permitted by the ABI, we might have to change this
7759          calculation.  */
7760       value -= sgot->output_section->vma;
7761       return _bfd_final_link_relocate (howto, input_bfd, input_section,
7762                                        contents, rel->r_offset, value,
7763                                        rel->r_addend);
7764
7765     case R_ARM_GOTPC:
7766       /* Use global offset table as symbol value.  */
7767       BFD_ASSERT (sgot != NULL);
7768
7769       if (sgot == NULL)
7770         return bfd_reloc_notsupported;
7771
7772       *unresolved_reloc_p = FALSE;
7773       value = sgot->output_section->vma;
7774       return _bfd_final_link_relocate (howto, input_bfd, input_section,
7775                                        contents, rel->r_offset, value,
7776                                        rel->r_addend);
7777
7778     case R_ARM_GOT32:
7779     case R_ARM_GOT_PREL:
7780       /* Relocation is to the entry for this symbol in the
7781          global offset table.  */
7782       if (sgot == NULL)
7783         return bfd_reloc_notsupported;
7784
7785       if (h != NULL)
7786         {
7787           bfd_vma off;
7788           bfd_boolean dyn;
7789
7790           off = h->got.offset;
7791           BFD_ASSERT (off != (bfd_vma) -1);
7792           dyn = globals->root.dynamic_sections_created;
7793
7794           if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
7795               || (info->shared
7796                   && SYMBOL_REFERENCES_LOCAL (info, h))
7797               || (ELF_ST_VISIBILITY (h->other)
7798                   && h->root.type == bfd_link_hash_undefweak))
7799             {
7800               /* This is actually a static link, or it is a -Bsymbolic link
7801                  and the symbol is defined locally.  We must initialize this
7802                  entry in the global offset table.  Since the offset must
7803                  always be a multiple of 4, we use the least significant bit
7804                  to record whether we have initialized it already.
7805
7806                  When doing a dynamic link, we create a .rel(a).got relocation
7807                  entry to initialize the value.  This is done in the
7808                  finish_dynamic_symbol routine.  */
7809               if ((off & 1) != 0)
7810                 off &= ~1;
7811               else
7812                 {
7813                   /* If we are addressing a Thumb function, we need to
7814                      adjust the address by one, so that attempts to
7815                      call the function pointer will correctly
7816                      interpret it as Thumb code.  */
7817                   if (sym_flags == STT_ARM_TFUNC)
7818                     value |= 1;
7819
7820                   bfd_put_32 (output_bfd, value, sgot->contents + off);
7821                   h->got.offset |= 1;
7822                 }
7823             }
7824           else
7825             *unresolved_reloc_p = FALSE;
7826
7827           value = sgot->output_offset + off;
7828         }
7829       else
7830         {
7831           bfd_vma off;
7832
7833           BFD_ASSERT (local_got_offsets != NULL &&
7834                       local_got_offsets[r_symndx] != (bfd_vma) -1);
7835
7836           off = local_got_offsets[r_symndx];
7837
7838           /* The offset must always be a multiple of 4.  We use the
7839              least significant bit to record whether we have already
7840              generated the necessary reloc.  */
7841           if ((off & 1) != 0)
7842             off &= ~1;
7843           else
7844             {
7845               /* If we are addressing a Thumb function, we need to
7846                  adjust the address by one, so that attempts to
7847                  call the function pointer will correctly
7848                  interpret it as Thumb code.  */
7849               if (sym_flags == STT_ARM_TFUNC)
7850                 value |= 1;
7851
7852               if (globals->use_rel)
7853                 bfd_put_32 (output_bfd, value, sgot->contents + off);
7854
7855               if (info->shared)
7856                 {
7857                   asection * srelgot;
7858                   Elf_Internal_Rela outrel;
7859                   bfd_byte *loc;
7860
7861                   srelgot = (bfd_get_section_by_name
7862                              (dynobj, RELOC_SECTION (globals, ".got")));
7863                   BFD_ASSERT (srelgot != NULL);
7864
7865                   outrel.r_addend = addend + value;
7866                   outrel.r_offset = (sgot->output_section->vma
7867                                      + sgot->output_offset
7868                                      + off);
7869                   outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
7870                   loc = srelgot->contents;
7871                   loc += srelgot->reloc_count++ * RELOC_SIZE (globals);
7872                   SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
7873                 }
7874
7875               local_got_offsets[r_symndx] |= 1;
7876             }
7877
7878           value = sgot->output_offset + off;
7879         }
7880       if (r_type != R_ARM_GOT32)
7881         value += sgot->output_section->vma;
7882
7883       return _bfd_final_link_relocate (howto, input_bfd, input_section,
7884                                        contents, rel->r_offset, value,
7885                                        rel->r_addend);
7886
7887     case R_ARM_TLS_LDO32:
7888       value = value - dtpoff_base (info);
7889
7890       return _bfd_final_link_relocate (howto, input_bfd, input_section,
7891                                        contents, rel->r_offset, value,
7892                                        rel->r_addend);
7893
7894     case R_ARM_TLS_LDM32:
7895       {
7896         bfd_vma off;
7897
7898         if (globals->sgot == NULL)
7899           abort ();
7900
7901         off = globals->tls_ldm_got.offset;
7902
7903         if ((off & 1) != 0)
7904           off &= ~1;
7905         else
7906           {
7907             /* If we don't know the module number, create a relocation
7908                for it.  */
7909             if (info->shared)
7910               {
7911                 Elf_Internal_Rela outrel;
7912                 bfd_byte *loc;
7913
7914                 if (globals->srelgot == NULL)
7915                   abort ();
7916
7917                 outrel.r_addend = 0;
7918                 outrel.r_offset = (globals->sgot->output_section->vma
7919                                    + globals->sgot->output_offset + off);
7920                 outrel.r_info = ELF32_R_INFO (0, R_ARM_TLS_DTPMOD32);
7921
7922                 if (globals->use_rel)
7923                   bfd_put_32 (output_bfd, outrel.r_addend,
7924                               globals->sgot->contents + off);
7925
7926                 loc = globals->srelgot->contents;
7927                 loc += globals->srelgot->reloc_count++ * RELOC_SIZE (globals);
7928                 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
7929               }
7930             else
7931               bfd_put_32 (output_bfd, 1, globals->sgot->contents + off);
7932
7933             globals->tls_ldm_got.offset |= 1;
7934           }
7935
7936         value = globals->sgot->output_section->vma + globals->sgot->output_offset + off
7937           - (input_section->output_section->vma + input_section->output_offset + rel->r_offset);
7938
7939         return _bfd_final_link_relocate (howto, input_bfd, input_section,
7940                                          contents, rel->r_offset, value,
7941                                          rel->r_addend);
7942       }
7943
7944     case R_ARM_TLS_GD32:
7945     case R_ARM_TLS_IE32:
7946       {
7947         bfd_vma off;
7948         int indx;
7949         char tls_type;
7950
7951         if (globals->sgot == NULL)
7952           abort ();
7953
7954         indx = 0;
7955         if (h != NULL)
7956           {
7957             bfd_boolean dyn;
7958             dyn = globals->root.dynamic_sections_created;
7959             if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
7960                 && (!info->shared
7961                     || !SYMBOL_REFERENCES_LOCAL (info, h)))
7962               {
7963                 *unresolved_reloc_p = FALSE;
7964                 indx = h->dynindx;
7965               }
7966             off = h->got.offset;
7967             tls_type = ((struct elf32_arm_link_hash_entry *) h)->tls_type;
7968           }
7969         else
7970           {
7971             if (local_got_offsets == NULL)
7972               abort ();
7973             off = local_got_offsets[r_symndx];
7974             tls_type = elf32_arm_local_got_tls_type (input_bfd)[r_symndx];
7975           }
7976
7977         if (tls_type == GOT_UNKNOWN)
7978           abort ();
7979
7980         if ((off & 1) != 0)
7981           off &= ~1;
7982         else
7983           {
7984             bfd_boolean need_relocs = FALSE;
7985             Elf_Internal_Rela outrel;
7986             bfd_byte *loc = NULL;
7987             int cur_off = off;
7988
7989             /* The GOT entries have not been initialized yet.  Do it
7990                now, and emit any relocations.  If both an IE GOT and a
7991                GD GOT are necessary, we emit the GD first.  */
7992
7993             if ((info->shared || indx != 0)
7994                 && (h == NULL
7995                     || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
7996                     || h->root.type != bfd_link_hash_undefweak))
7997               {
7998                 need_relocs = TRUE;
7999                 if (globals->srelgot == NULL)
8000                   abort ();
8001                 loc = globals->srelgot->contents;
8002                 loc += globals->srelgot->reloc_count * RELOC_SIZE (globals);
8003               }
8004
8005             if (tls_type & GOT_TLS_GD)
8006               {
8007                 if (need_relocs)
8008                   {
8009                     outrel.r_addend = 0;
8010                     outrel.r_offset = (globals->sgot->output_section->vma
8011                                        + globals->sgot->output_offset
8012                                        + cur_off);
8013                     outrel.r_info = ELF32_R_INFO (indx, R_ARM_TLS_DTPMOD32);
8014
8015                     if (globals->use_rel)
8016                       bfd_put_32 (output_bfd, outrel.r_addend,
8017                                   globals->sgot->contents + cur_off);
8018
8019                     SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
8020                     globals->srelgot->reloc_count++;
8021                     loc += RELOC_SIZE (globals);
8022
8023                     if (indx == 0)
8024                       bfd_put_32 (output_bfd, value - dtpoff_base (info),
8025                                   globals->sgot->contents + cur_off + 4);
8026                     else
8027                       {
8028                         outrel.r_addend = 0;
8029                         outrel.r_info = ELF32_R_INFO (indx,
8030                                                       R_ARM_TLS_DTPOFF32);
8031                         outrel.r_offset += 4;
8032
8033                         if (globals->use_rel)
8034                           bfd_put_32 (output_bfd, outrel.r_addend,
8035                                       globals->sgot->contents + cur_off + 4);
8036
8037
8038                         SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
8039                         globals->srelgot->reloc_count++;
8040                         loc += RELOC_SIZE (globals);
8041                       }
8042                   }
8043                 else
8044                   {
8045                     /* If we are not emitting relocations for a
8046                        general dynamic reference, then we must be in a
8047                        static link or an executable link with the
8048                        symbol binding locally.  Mark it as belonging
8049                        to module 1, the executable.  */
8050                     bfd_put_32 (output_bfd, 1,
8051                                 globals->sgot->contents + cur_off);
8052                     bfd_put_32 (output_bfd, value - dtpoff_base (info),
8053                                 globals->sgot->contents + cur_off + 4);
8054                   }
8055
8056                 cur_off += 8;
8057               }
8058
8059             if (tls_type & GOT_TLS_IE)
8060               {
8061                 if (need_relocs)
8062                   {
8063                     if (indx == 0)
8064                       outrel.r_addend = value - dtpoff_base (info);
8065                     else
8066                       outrel.r_addend = 0;
8067                     outrel.r_offset = (globals->sgot->output_section->vma
8068                                        + globals->sgot->output_offset
8069                                        + cur_off);
8070                     outrel.r_info = ELF32_R_INFO (indx, R_ARM_TLS_TPOFF32);
8071
8072                     if (globals->use_rel)
8073                       bfd_put_32 (output_bfd, outrel.r_addend,
8074                                   globals->sgot->contents + cur_off);
8075
8076                     SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
8077                     globals->srelgot->reloc_count++;
8078                     loc += RELOC_SIZE (globals);
8079                   }
8080                 else
8081                   bfd_put_32 (output_bfd, tpoff (info, value),
8082                               globals->sgot->contents + cur_off);
8083                 cur_off += 4;
8084               }
8085
8086             if (h != NULL)
8087               h->got.offset |= 1;
8088             else
8089               local_got_offsets[r_symndx] |= 1;
8090           }
8091
8092         if ((tls_type & GOT_TLS_GD) && r_type != R_ARM_TLS_GD32)
8093           off += 8;
8094         value = globals->sgot->output_section->vma + globals->sgot->output_offset + off
8095           - (input_section->output_section->vma + input_section->output_offset + rel->r_offset);
8096
8097         return _bfd_final_link_relocate (howto, input_bfd, input_section,
8098                                          contents, rel->r_offset, value,
8099                                          rel->r_addend);
8100       }
8101
8102     case R_ARM_TLS_LE32:
8103       if (info->shared)
8104         {
8105           (*_bfd_error_handler)
8106             (_("%B(%A+0x%lx): R_ARM_TLS_LE32 relocation not permitted in shared object"),
8107              input_bfd, input_section,
8108              (long) rel->r_offset, howto->name);
8109           return (bfd_reloc_status_type) FALSE;
8110         }
8111       else
8112         value = tpoff (info, value);
8113
8114       return _bfd_final_link_relocate (howto, input_bfd, input_section,
8115                                        contents, rel->r_offset, value,
8116                                        rel->r_addend);
8117
8118     case R_ARM_V4BX:
8119       if (globals->fix_v4bx)
8120         {
8121           bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
8122
8123           /* Ensure that we have a BX instruction.  */
8124           BFD_ASSERT ((insn & 0x0ffffff0) == 0x012fff10);
8125
8126           if (globals->fix_v4bx == 2 && (insn & 0xf) != 0xf)
8127             {
8128               /* Branch to veneer.  */
8129               bfd_vma glue_addr;
8130               glue_addr = elf32_arm_bx_glue (info, insn & 0xf);
8131               glue_addr -= input_section->output_section->vma
8132                            + input_section->output_offset
8133                            + rel->r_offset + 8;
8134               insn = (insn & 0xf0000000) | 0x0a000000
8135                      | ((glue_addr >> 2) & 0x00ffffff);
8136             }
8137           else
8138             {
8139               /* Preserve Rm (lowest four bits) and the condition code
8140                  (highest four bits). Other bits encode MOV PC,Rm.  */
8141               insn = (insn & 0xf000000f) | 0x01a0f000;
8142             }
8143
8144           bfd_put_32 (input_bfd, insn, hit_data);
8145         }
8146       return bfd_reloc_ok;
8147
8148     case R_ARM_MOVW_ABS_NC:
8149     case R_ARM_MOVT_ABS:
8150     case R_ARM_MOVW_PREL_NC:
8151     case R_ARM_MOVT_PREL:
8152     /* Until we properly support segment-base-relative addressing then
8153        we assume the segment base to be zero, as for the group relocations.
8154        Thus R_ARM_MOVW_BREL_NC has the same semantics as R_ARM_MOVW_ABS_NC
8155        and R_ARM_MOVT_BREL has the same semantics as R_ARM_MOVT_ABS.  */
8156     case R_ARM_MOVW_BREL_NC:
8157     case R_ARM_MOVW_BREL:
8158     case R_ARM_MOVT_BREL:
8159       {
8160         bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
8161
8162         if (globals->use_rel)
8163           {
8164             addend = ((insn >> 4) & 0xf000) | (insn & 0xfff);
8165             signed_addend = (addend ^ 0x8000) - 0x8000;
8166           }
8167
8168         value += signed_addend;
8169
8170         if (r_type == R_ARM_MOVW_PREL_NC || r_type == R_ARM_MOVT_PREL)
8171           value -= (input_section->output_section->vma
8172                     + input_section->output_offset + rel->r_offset);
8173
8174         if (r_type == R_ARM_MOVW_BREL && value >= 0x10000)
8175           return bfd_reloc_overflow;
8176
8177         if (sym_flags == STT_ARM_TFUNC)
8178           value |= 1;
8179
8180         if (r_type == R_ARM_MOVT_ABS || r_type == R_ARM_MOVT_PREL
8181             || r_type == R_ARM_MOVT_BREL)
8182           value >>= 16;
8183
8184         insn &= 0xfff0f000;
8185         insn |= value & 0xfff;
8186         insn |= (value & 0xf000) << 4;
8187         bfd_put_32 (input_bfd, insn, hit_data);
8188       }
8189       return bfd_reloc_ok;
8190
8191     case R_ARM_THM_MOVW_ABS_NC:
8192     case R_ARM_THM_MOVT_ABS:
8193     case R_ARM_THM_MOVW_PREL_NC:
8194     case R_ARM_THM_MOVT_PREL:
8195     /* Until we properly support segment-base-relative addressing then
8196        we assume the segment base to be zero, as for the above relocations.
8197        Thus R_ARM_THM_MOVW_BREL_NC has the same semantics as
8198        R_ARM_THM_MOVW_ABS_NC and R_ARM_THM_MOVT_BREL has the same semantics
8199        as R_ARM_THM_MOVT_ABS.  */
8200     case R_ARM_THM_MOVW_BREL_NC:
8201     case R_ARM_THM_MOVW_BREL:
8202     case R_ARM_THM_MOVT_BREL:
8203       {
8204         bfd_vma insn;
8205
8206         insn = bfd_get_16 (input_bfd, hit_data) << 16;
8207         insn |= bfd_get_16 (input_bfd, hit_data + 2);
8208
8209         if (globals->use_rel)
8210           {
8211             addend = ((insn >> 4)  & 0xf000)
8212                    | ((insn >> 15) & 0x0800)
8213                    | ((insn >> 4)  & 0x0700)
8214                    | (insn         & 0x00ff);
8215             signed_addend = (addend ^ 0x8000) - 0x8000;
8216           }
8217
8218         value += signed_addend;
8219
8220         if (r_type == R_ARM_THM_MOVW_PREL_NC || r_type == R_ARM_THM_MOVT_PREL)
8221           value -= (input_section->output_section->vma
8222                     + input_section->output_offset + rel->r_offset);
8223
8224         if (r_type == R_ARM_THM_MOVW_BREL && value >= 0x10000)
8225           return bfd_reloc_overflow;
8226
8227         if (sym_flags == STT_ARM_TFUNC)
8228           value |= 1;
8229
8230         if (r_type == R_ARM_THM_MOVT_ABS || r_type == R_ARM_THM_MOVT_PREL
8231             || r_type == R_ARM_THM_MOVT_BREL)
8232           value >>= 16;
8233
8234         insn &= 0xfbf08f00;
8235         insn |= (value & 0xf000) << 4;
8236         insn |= (value & 0x0800) << 15;
8237         insn |= (value & 0x0700) << 4;
8238         insn |= (value & 0x00ff);
8239
8240         bfd_put_16 (input_bfd, insn >> 16, hit_data);
8241         bfd_put_16 (input_bfd, insn & 0xffff, hit_data + 2);
8242       }
8243       return bfd_reloc_ok;
8244
8245     case R_ARM_ALU_PC_G0_NC:
8246     case R_ARM_ALU_PC_G1_NC:
8247     case R_ARM_ALU_PC_G0:
8248     case R_ARM_ALU_PC_G1:
8249     case R_ARM_ALU_PC_G2:
8250     case R_ARM_ALU_SB_G0_NC:
8251     case R_ARM_ALU_SB_G1_NC:
8252     case R_ARM_ALU_SB_G0:
8253     case R_ARM_ALU_SB_G1:
8254     case R_ARM_ALU_SB_G2:
8255       {
8256         bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
8257         bfd_vma pc = input_section->output_section->vma
8258                      + input_section->output_offset + rel->r_offset;
8259         /* sb should be the origin of the *segment* containing the symbol.
8260            It is not clear how to obtain this OS-dependent value, so we
8261            make an arbitrary choice of zero.  */
8262         bfd_vma sb = 0;
8263         bfd_vma residual;
8264         bfd_vma g_n;
8265         bfd_signed_vma signed_value;
8266         int group = 0;
8267
8268         /* Determine which group of bits to select.  */
8269         switch (r_type)
8270           {
8271           case R_ARM_ALU_PC_G0_NC:
8272           case R_ARM_ALU_PC_G0:
8273           case R_ARM_ALU_SB_G0_NC:
8274           case R_ARM_ALU_SB_G0:
8275             group = 0;
8276             break;
8277
8278           case R_ARM_ALU_PC_G1_NC:
8279           case R_ARM_ALU_PC_G1:
8280           case R_ARM_ALU_SB_G1_NC:
8281           case R_ARM_ALU_SB_G1:
8282             group = 1;
8283             break;
8284
8285           case R_ARM_ALU_PC_G2:
8286           case R_ARM_ALU_SB_G2:
8287             group = 2;
8288             break;
8289
8290           default:
8291             abort ();
8292           }
8293
8294         /* If REL, extract the addend from the insn.  If RELA, it will
8295            have already been fetched for us.  */
8296         if (globals->use_rel)
8297           {
8298             int negative;
8299             bfd_vma constant = insn & 0xff;
8300             bfd_vma rotation = (insn & 0xf00) >> 8;
8301
8302             if (rotation == 0)
8303               signed_addend = constant;
8304             else
8305               {
8306                 /* Compensate for the fact that in the instruction, the
8307                    rotation is stored in multiples of 2 bits.  */
8308                 rotation *= 2;
8309
8310                 /* Rotate "constant" right by "rotation" bits.  */
8311                 signed_addend = (constant >> rotation) |
8312                                 (constant << (8 * sizeof (bfd_vma) - rotation));
8313               }
8314
8315             /* Determine if the instruction is an ADD or a SUB.
8316                (For REL, this determines the sign of the addend.)  */
8317             negative = identify_add_or_sub (insn);
8318             if (negative == 0)
8319               {
8320                 (*_bfd_error_handler)
8321                   (_("%B(%A+0x%lx): Only ADD or SUB instructions are allowed for ALU group relocations"),
8322                   input_bfd, input_section,
8323                   (long) rel->r_offset, howto->name);
8324                 return bfd_reloc_overflow;
8325               }
8326
8327             signed_addend *= negative;
8328           }
8329
8330         /* Compute the value (X) to go in the place.  */
8331         if (r_type == R_ARM_ALU_PC_G0_NC
8332             || r_type == R_ARM_ALU_PC_G1_NC
8333             || r_type == R_ARM_ALU_PC_G0
8334             || r_type == R_ARM_ALU_PC_G1
8335             || r_type == R_ARM_ALU_PC_G2)
8336           /* PC relative.  */
8337           signed_value = value - pc + signed_addend;
8338         else
8339           /* Section base relative.  */
8340           signed_value = value - sb + signed_addend;
8341
8342         /* If the target symbol is a Thumb function, then set the
8343            Thumb bit in the address.  */
8344         if (sym_flags == STT_ARM_TFUNC)
8345           signed_value |= 1;
8346
8347         /* Calculate the value of the relevant G_n, in encoded
8348            constant-with-rotation format.  */
8349         g_n = calculate_group_reloc_mask (abs (signed_value), group,
8350                                           &residual);
8351
8352         /* Check for overflow if required.  */
8353         if ((r_type == R_ARM_ALU_PC_G0
8354              || r_type == R_ARM_ALU_PC_G1
8355              || r_type == R_ARM_ALU_PC_G2
8356              || r_type == R_ARM_ALU_SB_G0
8357              || r_type == R_ARM_ALU_SB_G1
8358              || r_type == R_ARM_ALU_SB_G2) && residual != 0)
8359           {
8360             (*_bfd_error_handler)
8361               (_("%B(%A+0x%lx): Overflow whilst splitting 0x%lx for group relocation %s"),
8362               input_bfd, input_section,
8363               (long) rel->r_offset, abs (signed_value), howto->name);
8364             return bfd_reloc_overflow;
8365           }
8366
8367         /* Mask out the value and the ADD/SUB part of the opcode; take care
8368            not to destroy the S bit.  */
8369         insn &= 0xff1ff000;
8370
8371         /* Set the opcode according to whether the value to go in the
8372            place is negative.  */
8373         if (signed_value < 0)
8374           insn |= 1 << 22;
8375         else
8376           insn |= 1 << 23;
8377
8378         /* Encode the offset.  */
8379         insn |= g_n;
8380
8381         bfd_put_32 (input_bfd, insn, hit_data);
8382       }
8383       return bfd_reloc_ok;
8384
8385     case R_ARM_LDR_PC_G0:
8386     case R_ARM_LDR_PC_G1:
8387     case R_ARM_LDR_PC_G2:
8388     case R_ARM_LDR_SB_G0:
8389     case R_ARM_LDR_SB_G1:
8390     case R_ARM_LDR_SB_G2:
8391       {
8392         bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
8393         bfd_vma pc = input_section->output_section->vma
8394                      + input_section->output_offset + rel->r_offset;
8395         bfd_vma sb = 0; /* See note above.  */
8396         bfd_vma residual;
8397         bfd_signed_vma signed_value;
8398         int group = 0;
8399
8400         /* Determine which groups of bits to calculate.  */
8401         switch (r_type)
8402           {
8403           case R_ARM_LDR_PC_G0:
8404           case R_ARM_LDR_SB_G0:
8405             group = 0;
8406             break;
8407
8408           case R_ARM_LDR_PC_G1:
8409           case R_ARM_LDR_SB_G1:
8410             group = 1;
8411             break;
8412
8413           case R_ARM_LDR_PC_G2:
8414           case R_ARM_LDR_SB_G2:
8415             group = 2;
8416             break;
8417
8418           default:
8419             abort ();
8420           }
8421
8422         /* If REL, extract the addend from the insn.  If RELA, it will
8423            have already been fetched for us.  */
8424         if (globals->use_rel)
8425           {
8426             int negative = (insn & (1 << 23)) ? 1 : -1;
8427             signed_addend = negative * (insn & 0xfff);
8428           }
8429
8430         /* Compute the value (X) to go in the place.  */
8431         if (r_type == R_ARM_LDR_PC_G0
8432             || r_type == R_ARM_LDR_PC_G1
8433             || r_type == R_ARM_LDR_PC_G2)
8434           /* PC relative.  */
8435           signed_value = value - pc + signed_addend;
8436         else
8437           /* Section base relative.  */
8438           signed_value = value - sb + signed_addend;
8439
8440         /* Calculate the value of the relevant G_{n-1} to obtain
8441            the residual at that stage.  */
8442         calculate_group_reloc_mask (abs (signed_value), group - 1, &residual);
8443
8444         /* Check for overflow.  */
8445         if (residual >= 0x1000)
8446           {
8447             (*_bfd_error_handler)
8448               (_("%B(%A+0x%lx): Overflow whilst splitting 0x%lx for group relocation %s"),
8449               input_bfd, input_section,
8450               (long) rel->r_offset, abs (signed_value), howto->name);
8451             return bfd_reloc_overflow;
8452           }
8453
8454         /* Mask out the value and U bit.  */
8455         insn &= 0xff7ff000;
8456
8457         /* Set the U bit if the value to go in the place is non-negative.  */
8458         if (signed_value >= 0)
8459           insn |= 1 << 23;
8460
8461         /* Encode the offset.  */
8462         insn |= residual;
8463
8464         bfd_put_32 (input_bfd, insn, hit_data);
8465       }
8466       return bfd_reloc_ok;
8467
8468     case R_ARM_LDRS_PC_G0:
8469     case R_ARM_LDRS_PC_G1:
8470     case R_ARM_LDRS_PC_G2:
8471     case R_ARM_LDRS_SB_G0:
8472     case R_ARM_LDRS_SB_G1:
8473     case R_ARM_LDRS_SB_G2:
8474       {
8475         bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
8476         bfd_vma pc = input_section->output_section->vma
8477                      + input_section->output_offset + rel->r_offset;
8478         bfd_vma sb = 0; /* See note above.  */
8479         bfd_vma residual;
8480         bfd_signed_vma signed_value;
8481         int group = 0;
8482
8483         /* Determine which groups of bits to calculate.  */
8484         switch (r_type)
8485           {
8486           case R_ARM_LDRS_PC_G0:
8487           case R_ARM_LDRS_SB_G0:
8488             group = 0;
8489             break;
8490
8491           case R_ARM_LDRS_PC_G1:
8492           case R_ARM_LDRS_SB_G1:
8493             group = 1;
8494             break;
8495
8496           case R_ARM_LDRS_PC_G2:
8497           case R_ARM_LDRS_SB_G2:
8498             group = 2;
8499             break;
8500
8501           default:
8502             abort ();
8503           }
8504
8505         /* If REL, extract the addend from the insn.  If RELA, it will
8506            have already been fetched for us.  */
8507         if (globals->use_rel)
8508           {
8509             int negative = (insn & (1 << 23)) ? 1 : -1;
8510             signed_addend = negative * (((insn & 0xf00) >> 4) + (insn & 0xf));
8511           }
8512
8513         /* Compute the value (X) to go in the place.  */
8514         if (r_type == R_ARM_LDRS_PC_G0
8515             || r_type == R_ARM_LDRS_PC_G1
8516             || r_type == R_ARM_LDRS_PC_G2)
8517           /* PC relative.  */
8518           signed_value = value - pc + signed_addend;
8519         else
8520           /* Section base relative.  */
8521           signed_value = value - sb + signed_addend;
8522
8523         /* Calculate the value of the relevant G_{n-1} to obtain
8524            the residual at that stage.  */
8525         calculate_group_reloc_mask (abs (signed_value), group - 1, &residual);
8526
8527         /* Check for overflow.  */
8528         if (residual >= 0x100)
8529           {
8530             (*_bfd_error_handler)
8531               (_("%B(%A+0x%lx): Overflow whilst splitting 0x%lx for group relocation %s"),
8532               input_bfd, input_section,
8533               (long) rel->r_offset, abs (signed_value), howto->name);
8534             return bfd_reloc_overflow;
8535           }
8536
8537         /* Mask out the value and U bit.  */
8538         insn &= 0xff7ff0f0;
8539
8540         /* Set the U bit if the value to go in the place is non-negative.  */
8541         if (signed_value >= 0)
8542           insn |= 1 << 23;
8543
8544         /* Encode the offset.  */
8545         insn |= ((residual & 0xf0) << 4) | (residual & 0xf);
8546
8547         bfd_put_32 (input_bfd, insn, hit_data);
8548       }
8549       return bfd_reloc_ok;
8550
8551     case R_ARM_LDC_PC_G0:
8552     case R_ARM_LDC_PC_G1:
8553     case R_ARM_LDC_PC_G2:
8554     case R_ARM_LDC_SB_G0:
8555     case R_ARM_LDC_SB_G1:
8556     case R_ARM_LDC_SB_G2:
8557       {
8558         bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
8559         bfd_vma pc = input_section->output_section->vma
8560                      + input_section->output_offset + rel->r_offset;
8561         bfd_vma sb = 0; /* See note above.  */
8562         bfd_vma residual;
8563         bfd_signed_vma signed_value;
8564         int group = 0;
8565
8566         /* Determine which groups of bits to calculate.  */
8567         switch (r_type)
8568           {
8569           case R_ARM_LDC_PC_G0:
8570           case R_ARM_LDC_SB_G0:
8571             group = 0;
8572             break;
8573
8574           case R_ARM_LDC_PC_G1:
8575           case R_ARM_LDC_SB_G1:
8576             group = 1;
8577             break;
8578
8579           case R_ARM_LDC_PC_G2:
8580           case R_ARM_LDC_SB_G2:
8581             group = 2;
8582             break;
8583
8584           default:
8585             abort ();
8586           }
8587
8588         /* If REL, extract the addend from the insn.  If RELA, it will
8589            have already been fetched for us.  */
8590         if (globals->use_rel)
8591           {
8592             int negative = (insn & (1 << 23)) ? 1 : -1;
8593             signed_addend = negative * ((insn & 0xff) << 2);
8594           }
8595
8596         /* Compute the value (X) to go in the place.  */
8597         if (r_type == R_ARM_LDC_PC_G0
8598             || r_type == R_ARM_LDC_PC_G1
8599             || r_type == R_ARM_LDC_PC_G2)
8600           /* PC relative.  */
8601           signed_value = value - pc + signed_addend;
8602         else
8603           /* Section base relative.  */
8604           signed_value = value - sb + signed_addend;
8605
8606         /* Calculate the value of the relevant G_{n-1} to obtain
8607            the residual at that stage.  */
8608         calculate_group_reloc_mask (abs (signed_value), group - 1, &residual);
8609
8610         /* Check for overflow.  (The absolute value to go in the place must be
8611            divisible by four and, after having been divided by four, must
8612            fit in eight bits.)  */
8613         if ((residual & 0x3) != 0 || residual >= 0x400)
8614           {
8615             (*_bfd_error_handler)
8616               (_("%B(%A+0x%lx): Overflow whilst splitting 0x%lx for group relocation %s"),
8617               input_bfd, input_section,
8618               (long) rel->r_offset, abs (signed_value), howto->name);
8619             return bfd_reloc_overflow;
8620           }
8621
8622         /* Mask out the value and U bit.  */
8623         insn &= 0xff7fff00;
8624
8625         /* Set the U bit if the value to go in the place is non-negative.  */
8626         if (signed_value >= 0)
8627           insn |= 1 << 23;
8628
8629         /* Encode the offset.  */
8630         insn |= residual >> 2;
8631
8632         bfd_put_32 (input_bfd, insn, hit_data);
8633       }
8634       return bfd_reloc_ok;
8635
8636     default:
8637       return bfd_reloc_notsupported;
8638     }
8639 }
8640
8641 /* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS.  */
8642 static void
8643 arm_add_to_rel (bfd *              abfd,
8644                 bfd_byte *         address,
8645                 reloc_howto_type * howto,
8646                 bfd_signed_vma     increment)
8647 {
8648   bfd_signed_vma addend;
8649
8650   if (howto->type == R_ARM_THM_CALL
8651       || howto->type == R_ARM_THM_JUMP24)
8652     {
8653       int upper_insn, lower_insn;
8654       int upper, lower;
8655
8656       upper_insn = bfd_get_16 (abfd, address);
8657       lower_insn = bfd_get_16 (abfd, address + 2);
8658       upper = upper_insn & 0x7ff;
8659       lower = lower_insn & 0x7ff;
8660
8661       addend = (upper << 12) | (lower << 1);
8662       addend += increment;
8663       addend >>= 1;
8664
8665       upper_insn = (upper_insn & 0xf800) | ((addend >> 11) & 0x7ff);
8666       lower_insn = (lower_insn & 0xf800) | (addend & 0x7ff);
8667
8668       bfd_put_16 (abfd, (bfd_vma) upper_insn, address);
8669       bfd_put_16 (abfd, (bfd_vma) lower_insn, address + 2);
8670     }
8671   else
8672     {
8673       bfd_vma        contents;
8674
8675       contents = bfd_get_32 (abfd, address);
8676
8677       /* Get the (signed) value from the instruction.  */
8678       addend = contents & howto->src_mask;
8679       if (addend & ((howto->src_mask + 1) >> 1))
8680         {
8681           bfd_signed_vma mask;
8682
8683           mask = -1;
8684           mask &= ~ howto->src_mask;
8685           addend |= mask;
8686         }
8687
8688       /* Add in the increment, (which is a byte value).  */
8689       switch (howto->type)
8690         {
8691         default:
8692           addend += increment;
8693           break;
8694
8695         case R_ARM_PC24:
8696         case R_ARM_PLT32:
8697         case R_ARM_CALL:
8698         case R_ARM_JUMP24:
8699           addend <<= howto->size;
8700           addend += increment;
8701
8702           /* Should we check for overflow here ?  */
8703
8704           /* Drop any undesired bits.  */
8705           addend >>= howto->rightshift;
8706           break;
8707         }
8708
8709       contents = (contents & ~ howto->dst_mask) | (addend & howto->dst_mask);
8710
8711       bfd_put_32 (abfd, contents, address);
8712     }
8713 }
8714
8715 #define IS_ARM_TLS_RELOC(R_TYPE)        \
8716   ((R_TYPE) == R_ARM_TLS_GD32           \
8717    || (R_TYPE) == R_ARM_TLS_LDO32       \
8718    || (R_TYPE) == R_ARM_TLS_LDM32       \
8719    || (R_TYPE) == R_ARM_TLS_DTPOFF32    \
8720    || (R_TYPE) == R_ARM_TLS_DTPMOD32    \
8721    || (R_TYPE) == R_ARM_TLS_TPOFF32     \
8722    || (R_TYPE) == R_ARM_TLS_LE32        \
8723    || (R_TYPE) == R_ARM_TLS_IE32)
8724
8725 /* Relocate an ARM ELF section.  */
8726
8727 static bfd_boolean
8728 elf32_arm_relocate_section (bfd *                  output_bfd,
8729                             struct bfd_link_info * info,
8730                             bfd *                  input_bfd,
8731                             asection *             input_section,
8732                             bfd_byte *             contents,
8733                             Elf_Internal_Rela *    relocs,
8734                             Elf_Internal_Sym *     local_syms,
8735                             asection **            local_sections)
8736 {
8737   Elf_Internal_Shdr *symtab_hdr;
8738   struct elf_link_hash_entry **sym_hashes;
8739   Elf_Internal_Rela *rel;
8740   Elf_Internal_Rela *relend;
8741   const char *name;
8742   struct elf32_arm_link_hash_table * globals;
8743
8744   globals = elf32_arm_hash_table (info);
8745
8746   symtab_hdr = & elf_symtab_hdr (input_bfd);
8747   sym_hashes = elf_sym_hashes (input_bfd);
8748
8749   rel = relocs;
8750   relend = relocs + input_section->reloc_count;
8751   for (; rel < relend; rel++)
8752     {
8753       int                          r_type;
8754       reloc_howto_type *           howto;
8755       unsigned long                r_symndx;
8756       Elf_Internal_Sym *           sym;
8757       asection *                   sec;
8758       struct elf_link_hash_entry * h;
8759       bfd_vma                      relocation;
8760       bfd_reloc_status_type        r;
8761       arelent                      bfd_reloc;
8762       char                         sym_type;
8763       bfd_boolean                  unresolved_reloc = FALSE;
8764       char *error_message = NULL;
8765
8766       r_symndx = ELF32_R_SYM (rel->r_info);
8767       r_type   = ELF32_R_TYPE (rel->r_info);
8768       r_type   = arm_real_reloc_type (globals, r_type);
8769
8770       if (   r_type == R_ARM_GNU_VTENTRY
8771           || r_type == R_ARM_GNU_VTINHERIT)
8772         continue;
8773
8774       bfd_reloc.howto = elf32_arm_howto_from_type (r_type);
8775       howto = bfd_reloc.howto;
8776
8777       h = NULL;
8778       sym = NULL;
8779       sec = NULL;
8780
8781       if (r_symndx < symtab_hdr->sh_info)
8782         {
8783           sym = local_syms + r_symndx;
8784           sym_type = ELF32_ST_TYPE (sym->st_info);
8785           sec = local_sections[r_symndx];
8786
8787           /* An object file might have a reference to a local
8788              undefined symbol.  This is a daft object file, but we
8789              should at least do something about it.  V4BX & NONE
8790              relocations do not use the symbol and are explicitly
8791              allowed to use the undefined symbol, so allow those.  */
8792           if (r_type != R_ARM_V4BX
8793               && r_type != R_ARM_NONE
8794               && bfd_is_und_section (sec)
8795               && ELF_ST_BIND (sym->st_info) != STB_WEAK)
8796             {
8797               if (!info->callbacks->undefined_symbol
8798                   (info, bfd_elf_string_from_elf_section
8799                    (input_bfd, symtab_hdr->sh_link, sym->st_name),
8800                    input_bfd, input_section,
8801                    rel->r_offset, TRUE))
8802                 return FALSE;
8803             }
8804
8805           if (globals->use_rel)
8806             {
8807               relocation = (sec->output_section->vma
8808                             + sec->output_offset
8809                             + sym->st_value);
8810               if (!info->relocatable
8811                   && (sec->flags & SEC_MERGE)
8812                   && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
8813                 {
8814                   asection *msec;
8815                   bfd_vma addend, value;
8816
8817                   switch (r_type)
8818                     {
8819                     case R_ARM_MOVW_ABS_NC:
8820                     case R_ARM_MOVT_ABS:
8821                       value = bfd_get_32 (input_bfd, contents + rel->r_offset);
8822                       addend = ((value & 0xf0000) >> 4) | (value & 0xfff);
8823                       addend = (addend ^ 0x8000) - 0x8000;
8824                       break;
8825
8826                     case R_ARM_THM_MOVW_ABS_NC:
8827                     case R_ARM_THM_MOVT_ABS:
8828                       value = bfd_get_16 (input_bfd, contents + rel->r_offset)
8829                               << 16;
8830                       value |= bfd_get_16 (input_bfd,
8831                                            contents + rel->r_offset + 2);
8832                       addend = ((value & 0xf7000) >> 4) | (value & 0xff)
8833                                | ((value & 0x04000000) >> 15);
8834                       addend = (addend ^ 0x8000) - 0x8000;
8835                       break;
8836
8837                     default:
8838                       if (howto->rightshift
8839                           || (howto->src_mask & (howto->src_mask + 1)))
8840                         {
8841                           (*_bfd_error_handler)
8842                             (_("%B(%A+0x%lx): %s relocation against SEC_MERGE section"),
8843                              input_bfd, input_section,
8844                              (long) rel->r_offset, howto->name);
8845                           return FALSE;
8846                         }
8847
8848                       value = bfd_get_32 (input_bfd, contents + rel->r_offset);
8849
8850                       /* Get the (signed) value from the instruction.  */
8851                       addend = value & howto->src_mask;
8852                       if (addend & ((howto->src_mask + 1) >> 1))
8853                         {
8854                           bfd_signed_vma mask;
8855
8856                           mask = -1;
8857                           mask &= ~ howto->src_mask;
8858                           addend |= mask;
8859                         }
8860                       break;
8861                     }
8862
8863                   msec = sec;
8864                   addend =
8865                     _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend)
8866                     - relocation;
8867                   addend += msec->output_section->vma + msec->output_offset;
8868
8869                   /* Cases here must match those in the preceeding
8870                      switch statement.  */
8871                   switch (r_type)
8872                     {
8873                     case R_ARM_MOVW_ABS_NC:
8874                     case R_ARM_MOVT_ABS:
8875                       value = (value & 0xfff0f000) | ((addend & 0xf000) << 4)
8876                               | (addend & 0xfff);
8877                       bfd_put_32 (input_bfd, value, contents + rel->r_offset);
8878                       break;
8879
8880                     case R_ARM_THM_MOVW_ABS_NC:
8881                     case R_ARM_THM_MOVT_ABS:
8882                       value = (value & 0xfbf08f00) | ((addend & 0xf700) << 4)
8883                               | (addend & 0xff) | ((addend & 0x0800) << 15);
8884                       bfd_put_16 (input_bfd, value >> 16,
8885                                   contents + rel->r_offset);
8886                       bfd_put_16 (input_bfd, value,
8887                                   contents + rel->r_offset + 2);
8888                       break;
8889
8890                     default:
8891                       value = (value & ~ howto->dst_mask)
8892                               | (addend & howto->dst_mask);
8893                       bfd_put_32 (input_bfd, value, contents + rel->r_offset);
8894                       break;
8895                     }
8896                 }
8897             }
8898           else
8899             relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
8900         }
8901       else
8902         {
8903           bfd_boolean warned;
8904
8905           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
8906                                    r_symndx, symtab_hdr, sym_hashes,
8907                                    h, sec, relocation,
8908                                    unresolved_reloc, warned);
8909
8910           sym_type = h->type;
8911         }
8912
8913       if (sec != NULL && elf_discarded_section (sec))
8914         {
8915           /* For relocs against symbols from removed linkonce sections,
8916              or sections discarded by a linker script, we just want the
8917              section contents zeroed.  Avoid any special processing.  */
8918           _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
8919           rel->r_info = 0;
8920           rel->r_addend = 0;
8921           continue;
8922         }
8923
8924       if (info->relocatable)
8925         {
8926           /* This is a relocatable link.  We don't have to change
8927              anything, unless the reloc is against a section symbol,
8928              in which case we have to adjust according to where the
8929              section symbol winds up in the output section.  */
8930           if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
8931             {
8932               if (globals->use_rel)
8933                 arm_add_to_rel (input_bfd, contents + rel->r_offset,
8934                                 howto, (bfd_signed_vma) sec->output_offset);
8935               else
8936                 rel->r_addend += sec->output_offset;
8937             }
8938           continue;
8939         }
8940
8941       if (h != NULL)
8942         name = h->root.root.string;
8943       else
8944         {
8945           name = (bfd_elf_string_from_elf_section
8946                   (input_bfd, symtab_hdr->sh_link, sym->st_name));
8947           if (name == NULL || *name == '\0')
8948             name = bfd_section_name (input_bfd, sec);
8949         }
8950
8951       if (r_symndx != 0
8952           && r_type != R_ARM_NONE
8953           && (h == NULL
8954               || h->root.type == bfd_link_hash_defined
8955               || h->root.type == bfd_link_hash_defweak)
8956           && IS_ARM_TLS_RELOC (r_type) != (sym_type == STT_TLS))
8957         {
8958           (*_bfd_error_handler)
8959             ((sym_type == STT_TLS
8960               ? _("%B(%A+0x%lx): %s used with TLS symbol %s")
8961               : _("%B(%A+0x%lx): %s used with non-TLS symbol %s")),
8962              input_bfd,
8963              input_section,
8964              (long) rel->r_offset,
8965              howto->name,
8966              name);
8967         }
8968
8969       r = elf32_arm_final_link_relocate (howto, input_bfd, output_bfd,
8970                                          input_section, contents, rel,
8971                                          relocation, info, sec, name,
8972                                          (h ? ELF_ST_TYPE (h->type) :
8973                                           ELF_ST_TYPE (sym->st_info)), h,
8974                                          &unresolved_reloc, &error_message);
8975
8976       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
8977          because such sections are not SEC_ALLOC and thus ld.so will
8978          not process them.  */
8979       if (unresolved_reloc
8980           && !((input_section->flags & SEC_DEBUGGING) != 0
8981                && h->def_dynamic))
8982         {
8983           (*_bfd_error_handler)
8984             (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
8985              input_bfd,
8986              input_section,
8987              (long) rel->r_offset,
8988              howto->name,
8989              h->root.root.string);
8990           return FALSE;
8991         }
8992
8993       if (r != bfd_reloc_ok)
8994         {
8995           switch (r)
8996             {
8997             case bfd_reloc_overflow:
8998               /* If the overflowing reloc was to an undefined symbol,
8999                  we have already printed one error message and there
9000                  is no point complaining again.  */
9001               if ((! h ||
9002                    h->root.type != bfd_link_hash_undefined)
9003                   && (!((*info->callbacks->reloc_overflow)
9004                         (info, (h ? &h->root : NULL), name, howto->name,
9005                          (bfd_vma) 0, input_bfd, input_section,
9006                          rel->r_offset))))
9007                   return FALSE;
9008               break;
9009
9010             case bfd_reloc_undefined:
9011               if (!((*info->callbacks->undefined_symbol)
9012                     (info, name, input_bfd, input_section,
9013                      rel->r_offset, TRUE)))
9014                 return FALSE;
9015               break;
9016
9017             case bfd_reloc_outofrange:
9018               error_message = _("out of range");
9019               goto common_error;
9020
9021             case bfd_reloc_notsupported:
9022               error_message = _("unsupported relocation");
9023               goto common_error;
9024
9025             case bfd_reloc_dangerous:
9026               /* error_message should already be set.  */
9027               goto common_error;
9028
9029             default:
9030               error_message = _("unknown error");
9031               /* Fall through.  */
9032
9033             common_error:
9034               BFD_ASSERT (error_message != NULL);
9035               if (!((*info->callbacks->reloc_dangerous)
9036                     (info, error_message, input_bfd, input_section,
9037                      rel->r_offset)))
9038                 return FALSE;
9039               break;
9040             }
9041         }
9042     }
9043
9044   return TRUE;
9045 }
9046
9047 /* Add a new unwind edit to the list described by HEAD, TAIL.  If TINDEX is zero,
9048    adds the edit to the start of the list.  (The list must be built in order of
9049    ascending TINDEX: the function's callers are primarily responsible for
9050    maintaining that condition).  */
9051
9052 static void
9053 add_unwind_table_edit (arm_unwind_table_edit **head,
9054                        arm_unwind_table_edit **tail,
9055                        arm_unwind_edit_type type,
9056                        asection *linked_section,
9057                        unsigned int tindex)
9058 {
9059   arm_unwind_table_edit *new_edit = (arm_unwind_table_edit *)
9060       xmalloc (sizeof (arm_unwind_table_edit));
9061
9062   new_edit->type = type;
9063   new_edit->linked_section = linked_section;
9064   new_edit->index = tindex;
9065
9066   if (tindex > 0)
9067     {
9068       new_edit->next = NULL;
9069
9070       if (*tail)
9071         (*tail)->next = new_edit;
9072
9073       (*tail) = new_edit;
9074
9075       if (!*head)
9076         (*head) = new_edit;
9077     }
9078   else
9079     {
9080       new_edit->next = *head;
9081
9082       if (!*tail)
9083         *tail = new_edit;
9084
9085       *head = new_edit;
9086     }
9087 }
9088
9089 static _arm_elf_section_data *get_arm_elf_section_data (asection *);
9090
9091 /* Increase the size of EXIDX_SEC by ADJUST bytes.  ADJUST mau be negative.  */
9092 static void
9093 adjust_exidx_size(asection *exidx_sec, int adjust)
9094 {
9095   asection *out_sec;
9096
9097   if (!exidx_sec->rawsize)
9098     exidx_sec->rawsize = exidx_sec->size;
9099
9100   bfd_set_section_size (exidx_sec->owner, exidx_sec, exidx_sec->size + adjust);
9101   out_sec = exidx_sec->output_section;
9102   /* Adjust size of output section.  */
9103   bfd_set_section_size (out_sec->owner, out_sec, out_sec->size +adjust);
9104 }
9105
9106 /* Insert an EXIDX_CANTUNWIND marker at the end of a section.  */
9107 static void
9108 insert_cantunwind_after(asection *text_sec, asection *exidx_sec)
9109 {
9110   struct _arm_elf_section_data *exidx_arm_data;
9111
9112   exidx_arm_data = get_arm_elf_section_data (exidx_sec);
9113   add_unwind_table_edit (
9114     &exidx_arm_data->u.exidx.unwind_edit_list,
9115     &exidx_arm_data->u.exidx.unwind_edit_tail,
9116     INSERT_EXIDX_CANTUNWIND_AT_END, text_sec, UINT_MAX);
9117
9118   adjust_exidx_size(exidx_sec, 8);
9119 }
9120
9121 /* Scan .ARM.exidx tables, and create a list describing edits which should be
9122    made to those tables, such that:
9123
9124      1. Regions without unwind data are marked with EXIDX_CANTUNWIND entries.
9125      2. Duplicate entries are merged together (EXIDX_CANTUNWIND, or unwind
9126         codes which have been inlined into the index).
9127
9128    The edits are applied when the tables are written
9129    (in elf32_arm_write_section).
9130 */
9131
9132 bfd_boolean
9133 elf32_arm_fix_exidx_coverage (asection **text_section_order,
9134                               unsigned int num_text_sections,
9135                               struct bfd_link_info *info)
9136 {
9137   bfd *inp;
9138   unsigned int last_second_word = 0, i;
9139   asection *last_exidx_sec = NULL;
9140   asection *last_text_sec = NULL;
9141   int last_unwind_type = -1;
9142
9143   /* Walk over all EXIDX sections, and create backlinks from the corrsponding
9144      text sections.  */
9145   for (inp = info->input_bfds; inp != NULL; inp = inp->link_next)
9146     {
9147       asection *sec;
9148
9149       for (sec = inp->sections; sec != NULL; sec = sec->next)
9150         {
9151           struct bfd_elf_section_data *elf_sec = elf_section_data (sec);
9152           Elf_Internal_Shdr *hdr = &elf_sec->this_hdr;
9153
9154           if (!hdr || hdr->sh_type != SHT_ARM_EXIDX)
9155             continue;
9156
9157           if (elf_sec->linked_to)
9158             {
9159               Elf_Internal_Shdr *linked_hdr
9160                 = &elf_section_data (elf_sec->linked_to)->this_hdr;
9161               struct _arm_elf_section_data *linked_sec_arm_data
9162                 = get_arm_elf_section_data (linked_hdr->bfd_section);
9163
9164               if (linked_sec_arm_data == NULL)
9165                 continue;
9166
9167               /* Link this .ARM.exidx section back from the text section it
9168                  describes.  */
9169               linked_sec_arm_data->u.text.arm_exidx_sec = sec;
9170             }
9171         }
9172     }
9173
9174   /* Walk all text sections in order of increasing VMA.  Eilminate duplicate
9175      index table entries (EXIDX_CANTUNWIND and inlined unwind opcodes),
9176      and add EXIDX_CANTUNWIND entries for sections with no unwind table data.  */
9177
9178   for (i = 0; i < num_text_sections; i++)
9179     {
9180       asection *sec = text_section_order[i];
9181       asection *exidx_sec;
9182       struct _arm_elf_section_data *arm_data = get_arm_elf_section_data (sec);
9183       struct _arm_elf_section_data *exidx_arm_data;
9184       bfd_byte *contents = NULL;
9185       int deleted_exidx_bytes = 0;
9186       bfd_vma j;
9187       arm_unwind_table_edit *unwind_edit_head = NULL;
9188       arm_unwind_table_edit *unwind_edit_tail = NULL;
9189       Elf_Internal_Shdr *hdr;
9190       bfd *ibfd;
9191
9192       if (arm_data == NULL)
9193         continue;
9194
9195       exidx_sec = arm_data->u.text.arm_exidx_sec;
9196       if (exidx_sec == NULL)
9197         {
9198           /* Section has no unwind data.  */
9199           if (last_unwind_type == 0 || !last_exidx_sec)
9200             continue;
9201
9202           /* Ignore zero sized sections.  */
9203           if (sec->size == 0)
9204             continue;
9205
9206           insert_cantunwind_after(last_text_sec, last_exidx_sec);
9207           last_unwind_type = 0;
9208           continue;
9209         }
9210
9211       /* Skip /DISCARD/ sections.  */
9212       if (bfd_is_abs_section (exidx_sec->output_section))
9213         continue;
9214
9215       hdr = &elf_section_data (exidx_sec)->this_hdr;
9216       if (hdr->sh_type != SHT_ARM_EXIDX)
9217         continue;
9218
9219       exidx_arm_data = get_arm_elf_section_data (exidx_sec);
9220       if (exidx_arm_data == NULL)
9221         continue;
9222
9223       ibfd = exidx_sec->owner;
9224
9225       if (hdr->contents != NULL)
9226         contents = hdr->contents;
9227       else if (! bfd_malloc_and_get_section (ibfd, exidx_sec, &contents))
9228         /* An error?  */
9229         continue;
9230
9231       for (j = 0; j < hdr->sh_size; j += 8)
9232         {
9233           unsigned int second_word = bfd_get_32 (ibfd, contents + j + 4);
9234           int unwind_type;
9235           int elide = 0;
9236
9237           /* An EXIDX_CANTUNWIND entry.  */
9238           if (second_word == 1)
9239             {
9240               if (last_unwind_type == 0)
9241                 elide = 1;
9242               unwind_type = 0;
9243             }
9244           /* Inlined unwinding data.  Merge if equal to previous.  */
9245           else if ((second_word & 0x80000000) != 0)
9246             {
9247               if (last_second_word == second_word && last_unwind_type == 1)
9248                 elide = 1;
9249               unwind_type = 1;
9250               last_second_word = second_word;
9251             }
9252           /* Normal table entry.  In theory we could merge these too,
9253              but duplicate entries are likely to be much less common.  */
9254           else
9255             unwind_type = 2;
9256
9257           if (elide)
9258             {
9259               add_unwind_table_edit (&unwind_edit_head, &unwind_edit_tail,
9260                                      DELETE_EXIDX_ENTRY, NULL, j / 8);
9261
9262               deleted_exidx_bytes += 8;
9263             }
9264
9265           last_unwind_type = unwind_type;
9266         }
9267
9268       /* Free contents if we allocated it ourselves.  */
9269       if (contents != hdr->contents)
9270         free (contents);
9271
9272       /* Record edits to be applied later (in elf32_arm_write_section).  */
9273       exidx_arm_data->u.exidx.unwind_edit_list = unwind_edit_head;
9274       exidx_arm_data->u.exidx.unwind_edit_tail = unwind_edit_tail;
9275
9276       if (deleted_exidx_bytes > 0)
9277         adjust_exidx_size(exidx_sec, -deleted_exidx_bytes);
9278
9279       last_exidx_sec = exidx_sec;
9280       last_text_sec = sec;
9281     }
9282
9283   /* Add terminating CANTUNWIND entry.  */
9284   if (last_exidx_sec && last_unwind_type != 0)
9285     insert_cantunwind_after(last_text_sec, last_exidx_sec);
9286
9287   return TRUE;
9288 }
9289
9290 static bfd_boolean
9291 elf32_arm_output_glue_section (struct bfd_link_info *info, bfd *obfd,
9292                                bfd *ibfd, const char *name)
9293 {
9294   asection *sec, *osec;
9295
9296   sec = bfd_get_section_by_name (ibfd, name);
9297   if (sec == NULL || (sec->flags & SEC_EXCLUDE) != 0)
9298     return TRUE;
9299
9300   osec = sec->output_section;
9301   if (elf32_arm_write_section (obfd, info, sec, sec->contents))
9302     return TRUE;
9303
9304   if (! bfd_set_section_contents (obfd, osec, sec->contents,
9305                                   sec->output_offset, sec->size))
9306     return FALSE;
9307
9308   return TRUE;
9309 }
9310
9311 static bfd_boolean
9312 elf32_arm_final_link (bfd *abfd, struct bfd_link_info *info)
9313 {
9314   struct elf32_arm_link_hash_table *globals = elf32_arm_hash_table (info);
9315
9316   /* Invoke the regular ELF backend linker to do all the work.  */
9317   if (!bfd_elf_final_link (abfd, info))
9318     return FALSE;
9319
9320   /* Write out any glue sections now that we have created all the
9321      stubs.  */
9322   if (globals->bfd_of_glue_owner != NULL)
9323     {
9324       if (! elf32_arm_output_glue_section (info, abfd,
9325                                            globals->bfd_of_glue_owner,
9326                                            ARM2THUMB_GLUE_SECTION_NAME))
9327         return FALSE;
9328
9329       if (! elf32_arm_output_glue_section (info, abfd,
9330                                            globals->bfd_of_glue_owner,
9331                                            THUMB2ARM_GLUE_SECTION_NAME))
9332         return FALSE;
9333
9334       if (! elf32_arm_output_glue_section (info, abfd,
9335                                            globals->bfd_of_glue_owner,
9336                                            VFP11_ERRATUM_VENEER_SECTION_NAME))
9337         return FALSE;
9338
9339       if (! elf32_arm_output_glue_section (info, abfd,
9340                                            globals->bfd_of_glue_owner,
9341                                            ARM_BX_GLUE_SECTION_NAME))
9342         return FALSE;
9343     }
9344
9345   return TRUE;
9346 }
9347
9348 /* Set the right machine number.  */
9349
9350 static bfd_boolean
9351 elf32_arm_object_p (bfd *abfd)
9352 {
9353   unsigned int mach;
9354
9355   mach = bfd_arm_get_mach_from_notes (abfd, ARM_NOTE_SECTION);
9356
9357   if (mach != bfd_mach_arm_unknown)
9358     bfd_default_set_arch_mach (abfd, bfd_arch_arm, mach);
9359
9360   else if (elf_elfheader (abfd)->e_flags & EF_ARM_MAVERICK_FLOAT)
9361     bfd_default_set_arch_mach (abfd, bfd_arch_arm, bfd_mach_arm_ep9312);
9362
9363   else
9364     bfd_default_set_arch_mach (abfd, bfd_arch_arm, mach);
9365
9366   return TRUE;
9367 }
9368
9369 /* Function to keep ARM specific flags in the ELF header.  */
9370
9371 static bfd_boolean
9372 elf32_arm_set_private_flags (bfd *abfd, flagword flags)
9373 {
9374   if (elf_flags_init (abfd)
9375       && elf_elfheader (abfd)->e_flags != flags)
9376     {
9377       if (EF_ARM_EABI_VERSION (flags) == EF_ARM_EABI_UNKNOWN)
9378         {
9379           if (flags & EF_ARM_INTERWORK)
9380             (*_bfd_error_handler)
9381               (_("Warning: Not setting interworking flag of %B since it has already been specified as non-interworking"),
9382                abfd);
9383           else
9384             _bfd_error_handler
9385               (_("Warning: Clearing the interworking flag of %B due to outside request"),
9386                abfd);
9387         }
9388     }
9389   else
9390     {
9391       elf_elfheader (abfd)->e_flags = flags;
9392       elf_flags_init (abfd) = TRUE;
9393     }
9394
9395   return TRUE;
9396 }
9397
9398 /* Copy backend specific data from one object module to another.  */
9399
9400 static bfd_boolean
9401 elf32_arm_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
9402 {
9403   flagword in_flags;
9404   flagword out_flags;
9405
9406   if (! is_arm_elf (ibfd) || ! is_arm_elf (obfd))
9407     return TRUE;
9408
9409   in_flags  = elf_elfheader (ibfd)->e_flags;
9410   out_flags = elf_elfheader (obfd)->e_flags;
9411
9412   if (elf_flags_init (obfd)
9413       && EF_ARM_EABI_VERSION (out_flags) == EF_ARM_EABI_UNKNOWN
9414       && in_flags != out_flags)
9415     {
9416       /* Cannot mix APCS26 and APCS32 code.  */
9417       if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
9418         return FALSE;
9419
9420       /* Cannot mix float APCS and non-float APCS code.  */
9421       if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
9422         return FALSE;
9423
9424       /* If the src and dest have different interworking flags
9425          then turn off the interworking bit.  */
9426       if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
9427         {
9428           if (out_flags & EF_ARM_INTERWORK)
9429             _bfd_error_handler
9430               (_("Warning: Clearing the interworking flag of %B because non-interworking code in %B has been linked with it"),
9431                obfd, ibfd);
9432
9433           in_flags &= ~EF_ARM_INTERWORK;
9434         }
9435
9436       /* Likewise for PIC, though don't warn for this case.  */
9437       if ((in_flags & EF_ARM_PIC) != (out_flags & EF_ARM_PIC))
9438         in_flags &= ~EF_ARM_PIC;
9439     }
9440
9441   elf_elfheader (obfd)->e_flags = in_flags;
9442   elf_flags_init (obfd) = TRUE;
9443
9444   /* Also copy the EI_OSABI field.  */
9445   elf_elfheader (obfd)->e_ident[EI_OSABI] =
9446     elf_elfheader (ibfd)->e_ident[EI_OSABI];
9447
9448   /* Copy object attributes.  */
9449   _bfd_elf_copy_obj_attributes (ibfd, obfd);
9450
9451   return TRUE;
9452 }
9453
9454 /* Values for Tag_ABI_PCS_R9_use.  */
9455 enum
9456 {
9457   AEABI_R9_V6,
9458   AEABI_R9_SB,
9459   AEABI_R9_TLS,
9460   AEABI_R9_unused
9461 };
9462
9463 /* Values for Tag_ABI_PCS_RW_data.  */
9464 enum
9465 {
9466   AEABI_PCS_RW_data_absolute,
9467   AEABI_PCS_RW_data_PCrel,
9468   AEABI_PCS_RW_data_SBrel,
9469   AEABI_PCS_RW_data_unused
9470 };
9471
9472 /* Values for Tag_ABI_enum_size.  */
9473 enum
9474 {
9475   AEABI_enum_unused,
9476   AEABI_enum_short,
9477   AEABI_enum_wide,
9478   AEABI_enum_forced_wide
9479 };
9480
9481 /* Determine whether an object attribute tag takes an integer, a
9482    string or both.  */
9483
9484 static int
9485 elf32_arm_obj_attrs_arg_type (int tag)
9486 {
9487   if (tag == Tag_compatibility)
9488     return ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_STR_VAL;
9489   else if (tag == Tag_nodefaults)
9490     return ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_NO_DEFAULT;
9491   else if (tag == Tag_CPU_raw_name || tag == Tag_CPU_name)
9492     return ATTR_TYPE_FLAG_STR_VAL;
9493   else if (tag < 32)
9494     return ATTR_TYPE_FLAG_INT_VAL;
9495   else
9496     return (tag & 1) != 0 ? ATTR_TYPE_FLAG_STR_VAL : ATTR_TYPE_FLAG_INT_VAL;
9497 }
9498
9499 /* The ABI defines that Tag_conformance should be emitted first, and that
9500    Tag_nodefaults should be second (if either is defined).  This sets those
9501    two positions, and bumps up the position of all the remaining tags to
9502    compensate.  */
9503 static int
9504 elf32_arm_obj_attrs_order (int num)
9505 {
9506   if (num == 4)
9507     return Tag_conformance;
9508   if (num == 5)
9509     return Tag_nodefaults;
9510   if ((num - 2) < Tag_nodefaults)
9511     return num - 2;
9512   if ((num - 1) < Tag_conformance)
9513     return num - 1;
9514   return num;
9515 }
9516
9517 /* Read the architecture from the Tag_also_compatible_with attribute, if any.
9518    Returns -1 if no architecture could be read.  */
9519
9520 static int
9521 get_secondary_compatible_arch (bfd *abfd)
9522 {
9523   obj_attribute *attr =
9524     &elf_known_obj_attributes_proc (abfd)[Tag_also_compatible_with];
9525
9526   /* Note: the tag and its argument below are uleb128 values, though
9527      currently-defined values fit in one byte for each.  */
9528   if (attr->s
9529       && attr->s[0] == Tag_CPU_arch
9530       && (attr->s[1] & 128) != 128
9531       && attr->s[2] == 0)
9532    return attr->s[1];
9533
9534   /* This tag is "safely ignorable", so don't complain if it looks funny.  */
9535   return -1;
9536 }
9537
9538 /* Set, or unset, the architecture of the Tag_also_compatible_with attribute.
9539    The tag is removed if ARCH is -1.  */
9540
9541 static void
9542 set_secondary_compatible_arch (bfd *abfd, int arch)
9543 {
9544   obj_attribute *attr =
9545     &elf_known_obj_attributes_proc (abfd)[Tag_also_compatible_with];
9546
9547   if (arch == -1)
9548     {
9549       attr->s = NULL;
9550       return;
9551     }
9552
9553   /* Note: the tag and its argument below are uleb128 values, though
9554      currently-defined values fit in one byte for each.  */
9555   if (!attr->s)
9556     attr->s = (char *) bfd_alloc (abfd, 3);
9557   attr->s[0] = Tag_CPU_arch;
9558   attr->s[1] = arch;
9559   attr->s[2] = '\0';
9560 }
9561
9562 /* Combine two values for Tag_CPU_arch, taking secondary compatibility tags
9563    into account.  */
9564
9565 static int
9566 tag_cpu_arch_combine (bfd *ibfd, int oldtag, int *secondary_compat_out,
9567                       int newtag, int secondary_compat)
9568 {
9569 #define T(X) TAG_CPU_ARCH_##X
9570   int tagl, tagh, result;
9571   const int v6t2[] =
9572     {
9573       T(V6T2),   /* PRE_V4.  */
9574       T(V6T2),   /* V4.  */
9575       T(V6T2),   /* V4T.  */
9576       T(V6T2),   /* V5T.  */
9577       T(V6T2),   /* V5TE.  */
9578       T(V6T2),   /* V5TEJ.  */
9579       T(V6T2),   /* V6.  */
9580       T(V7),     /* V6KZ.  */
9581       T(V6T2)    /* V6T2.  */
9582     };
9583   const int v6k[] =
9584     {
9585       T(V6K),    /* PRE_V4.  */
9586       T(V6K),    /* V4.  */
9587       T(V6K),    /* V4T.  */
9588       T(V6K),    /* V5T.  */
9589       T(V6K),    /* V5TE.  */
9590       T(V6K),    /* V5TEJ.  */
9591       T(V6K),    /* V6.  */
9592       T(V6KZ),   /* V6KZ.  */
9593       T(V7),     /* V6T2.  */
9594       T(V6K)     /* V6K.  */
9595     };
9596   const int v7[] =
9597     {
9598       T(V7),     /* PRE_V4.  */
9599       T(V7),     /* V4.  */
9600       T(V7),     /* V4T.  */
9601       T(V7),     /* V5T.  */
9602       T(V7),     /* V5TE.  */
9603       T(V7),     /* V5TEJ.  */
9604       T(V7),     /* V6.  */
9605       T(V7),     /* V6KZ.  */
9606       T(V7),     /* V6T2.  */
9607       T(V7),     /* V6K.  */
9608       T(V7)      /* V7.  */
9609     };
9610   const int v6_m[] =
9611     {
9612       -1,        /* PRE_V4.  */
9613       -1,        /* V4.  */
9614       T(V6K),    /* V4T.  */
9615       T(V6K),    /* V5T.  */
9616       T(V6K),    /* V5TE.  */
9617       T(V6K),    /* V5TEJ.  */
9618       T(V6K),    /* V6.  */
9619       T(V6KZ),   /* V6KZ.  */
9620       T(V7),     /* V6T2.  */
9621       T(V6K),    /* V6K.  */
9622       T(V7),     /* V7.  */
9623       T(V6_M)    /* V6_M.  */
9624     };
9625   const int v6s_m[] =
9626     {
9627       -1,        /* PRE_V4.  */
9628       -1,        /* V4.  */
9629       T(V6K),    /* V4T.  */
9630       T(V6K),    /* V5T.  */
9631       T(V6K),    /* V5TE.  */
9632       T(V6K),    /* V5TEJ.  */
9633       T(V6K),    /* V6.  */
9634       T(V6KZ),   /* V6KZ.  */
9635       T(V7),     /* V6T2.  */
9636       T(V6K),    /* V6K.  */
9637       T(V7),     /* V7.  */
9638       T(V6S_M),  /* V6_M.  */
9639       T(V6S_M)   /* V6S_M.  */
9640     };
9641   const int v7e_m[] =
9642     {
9643       -1,        /* PRE_V4.  */
9644       -1,        /* V4.  */
9645       T(V7E_M),  /* V4T.  */
9646       T(V7E_M),  /* V5T.  */
9647       T(V7E_M),  /* V5TE.  */
9648       T(V7E_M),  /* V5TEJ.  */
9649       T(V7E_M),  /* V6.  */
9650       T(V7E_M),  /* V6KZ.  */
9651       T(V7E_M),  /* V6T2.  */
9652       T(V7E_M),  /* V6K.  */
9653       T(V7E_M),  /* V7.  */
9654       T(V7E_M),  /* V6_M.  */
9655       T(V7E_M),  /* V6S_M.  */
9656       T(V7E_M)   /* V7E_M.  */
9657     };
9658   const int v4t_plus_v6_m[] =
9659     {
9660       -1,               /* PRE_V4.  */
9661       -1,               /* V4.  */
9662       T(V4T),           /* V4T.  */
9663       T(V5T),           /* V5T.  */
9664       T(V5TE),          /* V5TE.  */
9665       T(V5TEJ),         /* V5TEJ.  */
9666       T(V6),            /* V6.  */
9667       T(V6KZ),          /* V6KZ.  */
9668       T(V6T2),          /* V6T2.  */
9669       T(V6K),           /* V6K.  */
9670       T(V7),            /* V7.  */
9671       T(V6_M),          /* V6_M.  */
9672       T(V6S_M),         /* V6S_M.  */
9673       T(V7E_M),         /* V7E_M.  */
9674       T(V4T_PLUS_V6_M)  /* V4T plus V6_M.  */
9675     };
9676   const int *comb[] =
9677     {
9678       v6t2,
9679       v6k,
9680       v7,
9681       v6_m,
9682       v6s_m,
9683       v7e_m,
9684       /* Pseudo-architecture.  */
9685       v4t_plus_v6_m
9686     };
9687
9688   /* Check we've not got a higher architecture than we know about.  */
9689
9690   if (oldtag > MAX_TAG_CPU_ARCH || newtag > MAX_TAG_CPU_ARCH)
9691     {
9692       _bfd_error_handler (_("error: %B: Unknown CPU architecture"), ibfd);
9693       return -1;
9694     }
9695
9696   /* Override old tag if we have a Tag_also_compatible_with on the output.  */
9697
9698   if ((oldtag == T(V6_M) && *secondary_compat_out == T(V4T))
9699       || (oldtag == T(V4T) && *secondary_compat_out == T(V6_M)))
9700     oldtag = T(V4T_PLUS_V6_M);
9701
9702   /* And override the new tag if we have a Tag_also_compatible_with on the
9703      input.  */
9704
9705   if ((newtag == T(V6_M) && secondary_compat == T(V4T))
9706       || (newtag == T(V4T) && secondary_compat == T(V6_M)))
9707     newtag = T(V4T_PLUS_V6_M);
9708
9709   tagl = (oldtag < newtag) ? oldtag : newtag;
9710   result = tagh = (oldtag > newtag) ? oldtag : newtag;
9711
9712   /* Architectures before V6KZ add features monotonically.  */
9713   if (tagh <= TAG_CPU_ARCH_V6KZ)
9714     return result;
9715
9716   result = comb[tagh - T(V6T2)][tagl];
9717
9718   /* Use Tag_CPU_arch == V4T and Tag_also_compatible_with (Tag_CPU_arch V6_M)
9719      as the canonical version.  */
9720   if (result == T(V4T_PLUS_V6_M))
9721     {
9722       result = T(V4T);
9723       *secondary_compat_out = T(V6_M);
9724     }
9725   else
9726     *secondary_compat_out = -1;
9727
9728   if (result == -1)
9729     {
9730       _bfd_error_handler (_("error: %B: Conflicting CPU architectures %d/%d"),
9731                           ibfd, oldtag, newtag);
9732       return -1;
9733     }
9734
9735   return result;
9736 #undef T
9737 }
9738
9739 /* Merge EABI object attributes from IBFD into OBFD.  Raise an error if there
9740    are conflicting attributes.  */
9741
9742 static bfd_boolean
9743 elf32_arm_merge_eabi_attributes (bfd *ibfd, bfd *obfd)
9744 {
9745   obj_attribute *in_attr;
9746   obj_attribute *out_attr;
9747   obj_attribute_list *in_list;
9748   obj_attribute_list *out_list;
9749   obj_attribute_list **out_listp;
9750   /* Some tags have 0 = don't care, 1 = strong requirement,
9751      2 = weak requirement.  */
9752   static const int order_021[3] = {0, 2, 1};
9753   int i;
9754   bfd_boolean result = TRUE;
9755
9756   /* Skip the linker stubs file.  This preserves previous behavior
9757      of accepting unknown attributes in the first input file - but
9758      is that a bug?  */
9759   if (ibfd->flags & BFD_LINKER_CREATED)
9760     return TRUE;
9761
9762   if (!elf_known_obj_attributes_proc (obfd)[0].i)
9763     {
9764       /* This is the first object.  Copy the attributes.  */
9765       _bfd_elf_copy_obj_attributes (ibfd, obfd);
9766
9767       /* Use the Tag_null value to indicate the attributes have been
9768          initialized.  */
9769       elf_known_obj_attributes_proc (obfd)[0].i = 1;
9770
9771       return TRUE;
9772     }
9773
9774   in_attr = elf_known_obj_attributes_proc (ibfd);
9775   out_attr = elf_known_obj_attributes_proc (obfd);
9776   /* This needs to happen before Tag_ABI_FP_number_model is merged.  */
9777   if (in_attr[Tag_ABI_VFP_args].i != out_attr[Tag_ABI_VFP_args].i)
9778     {
9779       /* Ignore mismatches if the object doesn't use floating point.  */
9780       if (out_attr[Tag_ABI_FP_number_model].i == 0)
9781         out_attr[Tag_ABI_VFP_args].i = in_attr[Tag_ABI_VFP_args].i;
9782       else if (in_attr[Tag_ABI_FP_number_model].i != 0)
9783         {
9784           _bfd_error_handler
9785             (_("error: %B uses VFP register arguments, %B does not"),
9786              ibfd, obfd);
9787           result = FALSE;
9788         }
9789     }
9790
9791   for (i = 4; i < NUM_KNOWN_OBJ_ATTRIBUTES; i++)
9792     {
9793       /* Merge this attribute with existing attributes.  */
9794       switch (i)
9795         {
9796         case Tag_CPU_raw_name:
9797         case Tag_CPU_name:
9798           /* These are merged after Tag_CPU_arch. */
9799           break;
9800
9801         case Tag_ABI_optimization_goals:
9802         case Tag_ABI_FP_optimization_goals:
9803           /* Use the first value seen.  */
9804           break;
9805
9806         case Tag_CPU_arch:
9807           {
9808             int secondary_compat = -1, secondary_compat_out = -1;
9809             unsigned int saved_out_attr = out_attr[i].i;
9810             static const char *name_table[] = {
9811                 /* These aren't real CPU names, but we can't guess
9812                    that from the architecture version alone.  */
9813                 "Pre v4",
9814                 "ARM v4",
9815                 "ARM v4T",
9816                 "ARM v5T",
9817                 "ARM v5TE",
9818                 "ARM v5TEJ",
9819                 "ARM v6",
9820                 "ARM v6KZ",
9821                 "ARM v6T2",
9822                 "ARM v6K",
9823                 "ARM v7",
9824                 "ARM v6-M",
9825                 "ARM v6S-M"
9826             };
9827
9828             /* Merge Tag_CPU_arch and Tag_also_compatible_with.  */
9829             secondary_compat = get_secondary_compatible_arch (ibfd);
9830             secondary_compat_out = get_secondary_compatible_arch (obfd);
9831             out_attr[i].i = tag_cpu_arch_combine (ibfd, out_attr[i].i,
9832                                                   &secondary_compat_out,
9833                                                   in_attr[i].i,
9834                                                   secondary_compat);
9835             set_secondary_compatible_arch (obfd, secondary_compat_out);
9836
9837             /* Merge Tag_CPU_name and Tag_CPU_raw_name.  */
9838             if (out_attr[i].i == saved_out_attr)
9839               ; /* Leave the names alone.  */
9840             else if (out_attr[i].i == in_attr[i].i)
9841               {
9842                 /* The output architecture has been changed to match the
9843                    input architecture.  Use the input names.  */
9844                 out_attr[Tag_CPU_name].s = in_attr[Tag_CPU_name].s
9845                   ? _bfd_elf_attr_strdup (obfd, in_attr[Tag_CPU_name].s)
9846                   : NULL;
9847                 out_attr[Tag_CPU_raw_name].s = in_attr[Tag_CPU_raw_name].s
9848                   ? _bfd_elf_attr_strdup (obfd, in_attr[Tag_CPU_raw_name].s)
9849                   : NULL;
9850               }
9851             else
9852               {
9853                 out_attr[Tag_CPU_name].s = NULL;
9854                 out_attr[Tag_CPU_raw_name].s = NULL;
9855               }
9856
9857             /* If we still don't have a value for Tag_CPU_name,
9858                make one up now.  Tag_CPU_raw_name remains blank.  */
9859             if (out_attr[Tag_CPU_name].s == NULL
9860                 && out_attr[i].i < ARRAY_SIZE (name_table))
9861               out_attr[Tag_CPU_name].s =
9862                 _bfd_elf_attr_strdup (obfd, name_table[out_attr[i].i]);
9863           }
9864           break;
9865
9866         case Tag_ARM_ISA_use:
9867         case Tag_THUMB_ISA_use:
9868         case Tag_WMMX_arch:
9869         case Tag_Advanced_SIMD_arch:
9870           /* ??? Do Advanced_SIMD (NEON) and WMMX conflict?  */
9871         case Tag_ABI_FP_rounding:
9872         case Tag_ABI_FP_exceptions:
9873         case Tag_ABI_FP_user_exceptions:
9874         case Tag_ABI_FP_number_model:
9875         case Tag_VFP_HP_extension:
9876         case Tag_CPU_unaligned_access:
9877         case Tag_T2EE_use:
9878         case Tag_Virtualization_use:
9879         case Tag_MPextension_use:
9880           /* Use the largest value specified.  */
9881           if (in_attr[i].i > out_attr[i].i)
9882             out_attr[i].i = in_attr[i].i;
9883           break;
9884
9885         case Tag_ABI_align8_preserved:
9886         case Tag_ABI_PCS_RO_data:
9887           /* Use the smallest value specified.  */
9888           if (in_attr[i].i < out_attr[i].i)
9889             out_attr[i].i = in_attr[i].i;
9890           break;
9891
9892         case Tag_ABI_align8_needed:
9893           if ((in_attr[i].i > 0 || out_attr[i].i > 0)
9894               && (in_attr[Tag_ABI_align8_preserved].i == 0
9895                   || out_attr[Tag_ABI_align8_preserved].i == 0))
9896             {
9897               /* This error message should be enabled once all non-conformant
9898                  binaries in the toolchain have had the attributes set
9899                  properly.
9900               _bfd_error_handler
9901                 (_("error: %B: 8-byte data alignment conflicts with %B"),
9902                  obfd, ibfd);
9903               result = FALSE; */
9904             }
9905           /* Fall through.  */
9906         case Tag_ABI_FP_denormal:
9907         case Tag_ABI_PCS_GOT_use:
9908           /* Use the "greatest" from the sequence 0, 2, 1, or the largest
9909              value if greater than 2 (for future-proofing).  */
9910           if ((in_attr[i].i > 2 && in_attr[i].i > out_attr[i].i)
9911               || (in_attr[i].i <= 2 && out_attr[i].i <= 2
9912                   && order_021[in_attr[i].i] > order_021[out_attr[i].i]))
9913             out_attr[i].i = in_attr[i].i;
9914           break;
9915
9916
9917         case Tag_CPU_arch_profile:
9918           if (out_attr[i].i != in_attr[i].i)
9919             {
9920               /* 0 will merge with anything.
9921                  'A' and 'S' merge to 'A'.
9922                  'R' and 'S' merge to 'R'.
9923                  'M' and 'A|R|S' is an error.  */
9924               if (out_attr[i].i == 0
9925                   || (out_attr[i].i == 'S'
9926                       && (in_attr[i].i == 'A' || in_attr[i].i == 'R')))
9927                 out_attr[i].i = in_attr[i].i;
9928               else if (in_attr[i].i == 0
9929                        || (in_attr[i].i == 'S'
9930                            && (out_attr[i].i == 'A' || out_attr[i].i == 'R')))
9931                 ; /* Do nothing. */
9932               else
9933                 {
9934                   _bfd_error_handler
9935                     (_("error: %B: Conflicting architecture profiles %c/%c"),
9936                      ibfd,
9937                      in_attr[i].i ? in_attr[i].i : '0',
9938                      out_attr[i].i ? out_attr[i].i : '0');
9939                   result = FALSE;
9940                 }
9941             }
9942           break;
9943         case Tag_VFP_arch:
9944             {
9945               static const struct
9946               {
9947                   int ver;
9948                   int regs;
9949               } vfp_versions[7] =
9950                 {
9951                   {0, 0},
9952                   {1, 16},
9953                   {2, 16},
9954                   {3, 32},
9955                   {3, 16},
9956                   {4, 32},
9957                   {4, 16}
9958                 };
9959               int ver;
9960               int regs;
9961               int newval;
9962
9963               /* Values greater than 6 aren't defined, so just pick the
9964                  biggest */
9965               if (in_attr[i].i > 6 && in_attr[i].i > out_attr[i].i)
9966                 {
9967                   out_attr[i] = in_attr[i];
9968                   break;
9969                 }
9970               /* The output uses the superset of input features
9971                  (ISA version) and registers.  */
9972               ver = vfp_versions[in_attr[i].i].ver;
9973               if (ver < vfp_versions[out_attr[i].i].ver)
9974                 ver = vfp_versions[out_attr[i].i].ver;
9975               regs = vfp_versions[in_attr[i].i].regs;
9976               if (regs < vfp_versions[out_attr[i].i].regs)
9977                 regs = vfp_versions[out_attr[i].i].regs;
9978               /* This assumes all possible supersets are also a valid
9979                  options.  */
9980               for (newval = 6; newval > 0; newval--)
9981                 {
9982                   if (regs == vfp_versions[newval].regs
9983                       && ver == vfp_versions[newval].ver)
9984                     break;
9985                 }
9986               out_attr[i].i = newval;
9987             }
9988           break;
9989         case Tag_PCS_config:
9990           if (out_attr[i].i == 0)
9991             out_attr[i].i = in_attr[i].i;
9992           else if (in_attr[i].i != 0 && out_attr[i].i != 0)
9993             {
9994               /* It's sometimes ok to mix different configs, so this is only
9995                  a warning.  */
9996               _bfd_error_handler
9997                 (_("Warning: %B: Conflicting platform configuration"), ibfd);
9998             }
9999           break;
10000         case Tag_ABI_PCS_R9_use:
10001           if (in_attr[i].i != out_attr[i].i
10002               && out_attr[i].i != AEABI_R9_unused
10003               && in_attr[i].i != AEABI_R9_unused)
10004             {
10005               _bfd_error_handler
10006                 (_("error: %B: Conflicting use of R9"), ibfd);
10007               result = FALSE;
10008             }
10009           if (out_attr[i].i == AEABI_R9_unused)
10010             out_attr[i].i = in_attr[i].i;
10011           break;
10012         case Tag_ABI_PCS_RW_data:
10013           if (in_attr[i].i == AEABI_PCS_RW_data_SBrel
10014               && out_attr[Tag_ABI_PCS_R9_use].i != AEABI_R9_SB
10015               && out_attr[Tag_ABI_PCS_R9_use].i != AEABI_R9_unused)
10016             {
10017               _bfd_error_handler
10018                 (_("error: %B: SB relative addressing conflicts with use of R9"),
10019                  ibfd);
10020               result = FALSE;
10021             }
10022           /* Use the smallest value specified.  */
10023           if (in_attr[i].i < out_attr[i].i)
10024             out_attr[i].i = in_attr[i].i;
10025           break;
10026         case Tag_ABI_PCS_wchar_t:
10027           if (out_attr[i].i && in_attr[i].i && out_attr[i].i != in_attr[i].i
10028               && !elf_arm_tdata (obfd)->no_wchar_size_warning)
10029             {
10030               _bfd_error_handler
10031                 (_("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"),
10032                  ibfd, in_attr[i].i, out_attr[i].i);
10033             }
10034           else if (in_attr[i].i && !out_attr[i].i)
10035             out_attr[i].i = in_attr[i].i;
10036           break;
10037         case Tag_ABI_enum_size:
10038           if (in_attr[i].i != AEABI_enum_unused)
10039             {
10040               if (out_attr[i].i == AEABI_enum_unused
10041                   || out_attr[i].i == AEABI_enum_forced_wide)
10042                 {
10043                   /* The existing object is compatible with anything.
10044                      Use whatever requirements the new object has.  */
10045                   out_attr[i].i = in_attr[i].i;
10046                 }
10047               else if (in_attr[i].i != AEABI_enum_forced_wide
10048                        && out_attr[i].i != in_attr[i].i
10049                        && !elf_arm_tdata (obfd)->no_enum_size_warning)
10050                 {
10051                   static const char *aeabi_enum_names[] =
10052                     { "", "variable-size", "32-bit", "" };
10053                   const char *in_name =
10054                     in_attr[i].i < ARRAY_SIZE(aeabi_enum_names)
10055                     ? aeabi_enum_names[in_attr[i].i]
10056                     : "<unknown>";
10057                   const char *out_name =
10058                     out_attr[i].i < ARRAY_SIZE(aeabi_enum_names)
10059                     ? aeabi_enum_names[out_attr[i].i]
10060                     : "<unknown>";
10061                   _bfd_error_handler
10062                     (_("warning: %B uses %s enums yet the output is to use %s enums; use of enum values across objects may fail"),
10063                      ibfd, in_name, out_name);
10064                 }
10065             }
10066           break;
10067         case Tag_ABI_VFP_args:
10068           /* Aready done.  */
10069           break;
10070         case Tag_ABI_WMMX_args:
10071           if (in_attr[i].i != out_attr[i].i)
10072             {
10073               _bfd_error_handler
10074                 (_("error: %B uses iWMMXt register arguments, %B does not"),
10075                  ibfd, obfd);
10076               result = FALSE;
10077             }
10078           break;
10079         case Tag_compatibility:
10080           /* Merged in target-independent code.  */
10081           break;
10082         case Tag_ABI_HardFP_use:
10083           /* 1 (SP) and 2 (DP) conflict, so combine to 3 (SP & DP).  */
10084           if ((in_attr[i].i == 1 && out_attr[i].i == 2)
10085               || (in_attr[i].i == 2 && out_attr[i].i == 1))
10086             out_attr[i].i = 3;
10087           else if (in_attr[i].i > out_attr[i].i)
10088             out_attr[i].i = in_attr[i].i;
10089           break;
10090         case Tag_ABI_FP_16bit_format:
10091           if (in_attr[i].i != 0 && out_attr[i].i != 0)
10092             {
10093               if (in_attr[i].i != out_attr[i].i)
10094                 {
10095                   _bfd_error_handler
10096                     (_("error: fp16 format mismatch between %B and %B"),
10097                      ibfd, obfd);
10098                   result = FALSE;
10099                 }
10100             }
10101           if (in_attr[i].i != 0)
10102             out_attr[i].i = in_attr[i].i;
10103           break;
10104
10105         case Tag_nodefaults:
10106           /* This tag is set if it exists, but the value is unused (and is
10107              typically zero).  We don't actually need to do anything here -
10108              the merge happens automatically when the type flags are merged
10109              below.  */
10110           break;
10111         case Tag_also_compatible_with:
10112           /* Already done in Tag_CPU_arch.  */
10113           break;
10114         case Tag_conformance:
10115           /* Keep the attribute if it matches.  Throw it away otherwise.
10116              No attribute means no claim to conform.  */
10117           if (!in_attr[i].s || !out_attr[i].s
10118               || strcmp (in_attr[i].s, out_attr[i].s) != 0)
10119             out_attr[i].s = NULL;
10120           break;
10121
10122         default:
10123           {
10124             bfd *err_bfd = NULL;
10125
10126             /* The "known_obj_attributes" table does contain some undefined
10127                attributes.  Ensure that there are unused.  */
10128             if (out_attr[i].i != 0 || out_attr[i].s != NULL)
10129               err_bfd = obfd;
10130             else if (in_attr[i].i != 0 || in_attr[i].s != NULL)
10131               err_bfd = ibfd;
10132
10133             if (err_bfd != NULL)
10134               {
10135                 /* Attribute numbers >=64 (mod 128) can be safely ignored.  */
10136                 if ((i & 127) < 64)
10137                   {
10138                     _bfd_error_handler
10139                       (_("%B: Unknown mandatory EABI object attribute %d"),
10140                        err_bfd, i);
10141                     bfd_set_error (bfd_error_bad_value);
10142                     result = FALSE;
10143                   }
10144                 else
10145                   {
10146                     _bfd_error_handler
10147                       (_("Warning: %B: Unknown EABI object attribute %d"),
10148                        err_bfd, i);
10149                   }
10150               }
10151
10152             /* Only pass on attributes that match in both inputs.  */
10153             if (in_attr[i].i != out_attr[i].i
10154                 || in_attr[i].s != out_attr[i].s
10155                 || (in_attr[i].s != NULL && out_attr[i].s != NULL
10156                     && strcmp (in_attr[i].s, out_attr[i].s) != 0))
10157               {
10158                 out_attr[i].i = 0;
10159                 out_attr[i].s = NULL;
10160               }
10161           }
10162         }
10163
10164       /* If out_attr was copied from in_attr then it won't have a type yet.  */
10165       if (in_attr[i].type && !out_attr[i].type)
10166         out_attr[i].type = in_attr[i].type;
10167     }
10168
10169   /* Merge Tag_compatibility attributes and any common GNU ones.  */
10170   _bfd_elf_merge_object_attributes (ibfd, obfd);
10171
10172   /* Check for any attributes not known on ARM.  */
10173   in_list = elf_other_obj_attributes_proc (ibfd);
10174   out_listp = &elf_other_obj_attributes_proc (obfd);
10175   out_list = *out_listp;
10176
10177   for (; in_list || out_list; )
10178     {
10179       bfd *err_bfd = NULL;
10180       int err_tag = 0;
10181
10182       /* The tags for each list are in numerical order.  */
10183       /* If the tags are equal, then merge.  */
10184       if (out_list && (!in_list || in_list->tag > out_list->tag))
10185         {
10186           /* This attribute only exists in obfd.  We can't merge, and we don't
10187              know what the tag means, so delete it.  */
10188           err_bfd = obfd;
10189           err_tag = out_list->tag;
10190           *out_listp = out_list->next;
10191           out_list = *out_listp;
10192         }
10193       else if (in_list && (!out_list || in_list->tag < out_list->tag))
10194         {
10195           /* This attribute only exists in ibfd. We can't merge, and we don't
10196              know what the tag means, so ignore it.  */
10197           err_bfd = ibfd;
10198           err_tag = in_list->tag;
10199           in_list = in_list->next;
10200         }
10201       else /* The tags are equal.  */
10202         {
10203           /* As present, all attributes in the list are unknown, and
10204              therefore can't be merged meaningfully.  */
10205           err_bfd = obfd;
10206           err_tag = out_list->tag;
10207
10208           /*  Only pass on attributes that match in both inputs.  */
10209           if (in_list->attr.i != out_list->attr.i
10210               || in_list->attr.s != out_list->attr.s
10211               || (in_list->attr.s && out_list->attr.s
10212                   && strcmp (in_list->attr.s, out_list->attr.s) != 0))
10213             {
10214               /* No match.  Delete the attribute.  */
10215               *out_listp = out_list->next;
10216               out_list = *out_listp;
10217             }
10218           else
10219             {
10220               /* Matched.  Keep the attribute and move to the next.  */
10221               out_list = out_list->next;
10222               in_list = in_list->next;
10223             }
10224         }
10225
10226       if (err_bfd)
10227         {
10228           /* Attribute numbers >=64 (mod 128) can be safely ignored.  */
10229           if ((err_tag & 127) < 64)
10230             {
10231               _bfd_error_handler
10232                 (_("%B: Unknown mandatory EABI object attribute %d"),
10233                  err_bfd, err_tag);
10234               bfd_set_error (bfd_error_bad_value);
10235               result = FALSE;
10236             }
10237           else
10238             {
10239               _bfd_error_handler
10240                 (_("Warning: %B: Unknown EABI object attribute %d"),
10241                  err_bfd, err_tag);
10242             }
10243         }
10244     }
10245   return result;
10246 }
10247
10248
10249 /* Return TRUE if the two EABI versions are incompatible.  */
10250
10251 static bfd_boolean
10252 elf32_arm_versions_compatible (unsigned iver, unsigned over)
10253 {
10254   /* v4 and v5 are the same spec before and after it was released,
10255      so allow mixing them.  */
10256   if ((iver == EF_ARM_EABI_VER4 && over == EF_ARM_EABI_VER5)
10257       || (iver == EF_ARM_EABI_VER5 && over == EF_ARM_EABI_VER4))
10258     return TRUE;
10259
10260   return (iver == over);
10261 }
10262
10263 /* Merge backend specific data from an object file to the output
10264    object file when linking.  */
10265
10266 static bfd_boolean
10267 elf32_arm_merge_private_bfd_data (bfd * ibfd, bfd * obfd);
10268
10269 /* Display the flags field.  */
10270
10271 static bfd_boolean
10272 elf32_arm_print_private_bfd_data (bfd *abfd, void * ptr)
10273 {
10274   FILE * file = (FILE *) ptr;
10275   unsigned long flags;
10276
10277   BFD_ASSERT (abfd != NULL && ptr != NULL);
10278
10279   /* Print normal ELF private data.  */
10280   _bfd_elf_print_private_bfd_data (abfd, ptr);
10281
10282   flags = elf_elfheader (abfd)->e_flags;
10283   /* Ignore init flag - it may not be set, despite the flags field
10284      containing valid data.  */
10285
10286   /* xgettext:c-format */
10287   fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
10288
10289   switch (EF_ARM_EABI_VERSION (flags))
10290     {
10291     case EF_ARM_EABI_UNKNOWN:
10292       /* The following flag bits are GNU extensions and not part of the
10293          official ARM ELF extended ABI.  Hence they are only decoded if
10294          the EABI version is not set.  */
10295       if (flags & EF_ARM_INTERWORK)
10296         fprintf (file, _(" [interworking enabled]"));
10297
10298       if (flags & EF_ARM_APCS_26)
10299         fprintf (file, " [APCS-26]");
10300       else
10301         fprintf (file, " [APCS-32]");
10302
10303       if (flags & EF_ARM_VFP_FLOAT)
10304         fprintf (file, _(" [VFP float format]"));
10305       else if (flags & EF_ARM_MAVERICK_FLOAT)
10306         fprintf (file, _(" [Maverick float format]"));
10307       else
10308         fprintf (file, _(" [FPA float format]"));
10309
10310       if (flags & EF_ARM_APCS_FLOAT)
10311         fprintf (file, _(" [floats passed in float registers]"));
10312
10313       if (flags & EF_ARM_PIC)
10314         fprintf (file, _(" [position independent]"));
10315
10316       if (flags & EF_ARM_NEW_ABI)
10317         fprintf (file, _(" [new ABI]"));
10318
10319       if (flags & EF_ARM_OLD_ABI)
10320         fprintf (file, _(" [old ABI]"));
10321
10322       if (flags & EF_ARM_SOFT_FLOAT)
10323         fprintf (file, _(" [software FP]"));
10324
10325       flags &= ~(EF_ARM_INTERWORK | EF_ARM_APCS_26 | EF_ARM_APCS_FLOAT
10326                  | EF_ARM_PIC | EF_ARM_NEW_ABI | EF_ARM_OLD_ABI
10327                  | EF_ARM_SOFT_FLOAT | EF_ARM_VFP_FLOAT
10328                  | EF_ARM_MAVERICK_FLOAT);
10329       break;
10330
10331     case EF_ARM_EABI_VER1:
10332       fprintf (file, _(" [Version1 EABI]"));
10333
10334       if (flags & EF_ARM_SYMSARESORTED)
10335         fprintf (file, _(" [sorted symbol table]"));
10336       else
10337         fprintf (file, _(" [unsorted symbol table]"));
10338
10339       flags &= ~ EF_ARM_SYMSARESORTED;
10340       break;
10341
10342     case EF_ARM_EABI_VER2:
10343       fprintf (file, _(" [Version2 EABI]"));
10344
10345       if (flags & EF_ARM_SYMSARESORTED)
10346         fprintf (file, _(" [sorted symbol table]"));
10347       else
10348         fprintf (file, _(" [unsorted symbol table]"));
10349
10350       if (flags & EF_ARM_DYNSYMSUSESEGIDX)
10351         fprintf (file, _(" [dynamic symbols use segment index]"));
10352
10353       if (flags & EF_ARM_MAPSYMSFIRST)
10354         fprintf (file, _(" [mapping symbols precede others]"));
10355
10356       flags &= ~(EF_ARM_SYMSARESORTED | EF_ARM_DYNSYMSUSESEGIDX
10357                  | EF_ARM_MAPSYMSFIRST);
10358       break;
10359
10360     case EF_ARM_EABI_VER3:
10361       fprintf (file, _(" [Version3 EABI]"));
10362       break;
10363
10364     case EF_ARM_EABI_VER4:
10365       fprintf (file, _(" [Version4 EABI]"));
10366       goto eabi;
10367
10368     case EF_ARM_EABI_VER5:
10369       fprintf (file, _(" [Version5 EABI]"));
10370     eabi:
10371       if (flags & EF_ARM_BE8)
10372         fprintf (file, _(" [BE8]"));
10373
10374       if (flags & EF_ARM_LE8)
10375         fprintf (file, _(" [LE8]"));
10376
10377       flags &= ~(EF_ARM_LE8 | EF_ARM_BE8);
10378       break;
10379
10380     default:
10381       fprintf (file, _(" <EABI version unrecognised>"));
10382       break;
10383     }
10384
10385   flags &= ~ EF_ARM_EABIMASK;
10386
10387   if (flags & EF_ARM_RELEXEC)
10388     fprintf (file, _(" [relocatable executable]"));
10389
10390   if (flags & EF_ARM_HASENTRY)
10391     fprintf (file, _(" [has entry point]"));
10392
10393   flags &= ~ (EF_ARM_RELEXEC | EF_ARM_HASENTRY);
10394
10395   if (flags)
10396     fprintf (file, _("<Unrecognised flag bits set>"));
10397
10398   fputc ('\n', file);
10399
10400   return TRUE;
10401 }
10402
10403 static int
10404 elf32_arm_get_symbol_type (Elf_Internal_Sym * elf_sym, int type)
10405 {
10406   switch (ELF_ST_TYPE (elf_sym->st_info))
10407     {
10408     case STT_ARM_TFUNC:
10409       return ELF_ST_TYPE (elf_sym->st_info);
10410
10411     case STT_ARM_16BIT:
10412       /* If the symbol is not an object, return the STT_ARM_16BIT flag.
10413          This allows us to distinguish between data used by Thumb instructions
10414          and non-data (which is probably code) inside Thumb regions of an
10415          executable.  */
10416       if (type != STT_OBJECT && type != STT_TLS)
10417         return ELF_ST_TYPE (elf_sym->st_info);
10418       break;
10419
10420     default:
10421       break;
10422     }
10423
10424   return type;
10425 }
10426
10427 static asection *
10428 elf32_arm_gc_mark_hook (asection *sec,
10429                         struct bfd_link_info *info,
10430                         Elf_Internal_Rela *rel,
10431                         struct elf_link_hash_entry *h,
10432                         Elf_Internal_Sym *sym)
10433 {
10434   if (h != NULL)
10435     switch (ELF32_R_TYPE (rel->r_info))
10436       {
10437       case R_ARM_GNU_VTINHERIT:
10438       case R_ARM_GNU_VTENTRY:
10439         return NULL;
10440       }
10441
10442   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
10443 }
10444
10445 /* Update the got entry reference counts for the section being removed.  */
10446
10447 static bfd_boolean
10448 elf32_arm_gc_sweep_hook (bfd *                     abfd,
10449                          struct bfd_link_info *    info,
10450                          asection *                sec,
10451                          const Elf_Internal_Rela * relocs)
10452 {
10453   Elf_Internal_Shdr *symtab_hdr;
10454   struct elf_link_hash_entry **sym_hashes;
10455   bfd_signed_vma *local_got_refcounts;
10456   const Elf_Internal_Rela *rel, *relend;
10457   struct elf32_arm_link_hash_table * globals;
10458
10459   if (info->relocatable)
10460     return TRUE;
10461
10462   globals = elf32_arm_hash_table (info);
10463
10464   elf_section_data (sec)->local_dynrel = NULL;
10465
10466   symtab_hdr = & elf_symtab_hdr (abfd);
10467   sym_hashes = elf_sym_hashes (abfd);
10468   local_got_refcounts = elf_local_got_refcounts (abfd);
10469
10470   check_use_blx (globals);
10471
10472   relend = relocs + sec->reloc_count;
10473   for (rel = relocs; rel < relend; rel++)
10474     {
10475       unsigned long r_symndx;
10476       struct elf_link_hash_entry *h = NULL;
10477       int r_type;
10478
10479       r_symndx = ELF32_R_SYM (rel->r_info);
10480       if (r_symndx >= symtab_hdr->sh_info)
10481         {
10482           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
10483           while (h->root.type == bfd_link_hash_indirect
10484                  || h->root.type == bfd_link_hash_warning)
10485             h = (struct elf_link_hash_entry *) h->root.u.i.link;
10486         }
10487
10488       r_type = ELF32_R_TYPE (rel->r_info);
10489       r_type = arm_real_reloc_type (globals, r_type);
10490       switch (r_type)
10491         {
10492         case R_ARM_GOT32:
10493         case R_ARM_GOT_PREL:
10494         case R_ARM_TLS_GD32:
10495         case R_ARM_TLS_IE32:
10496           if (h != NULL)
10497             {
10498               if (h->got.refcount > 0)
10499                 h->got.refcount -= 1;
10500             }
10501           else if (local_got_refcounts != NULL)
10502             {
10503               if (local_got_refcounts[r_symndx] > 0)
10504                 local_got_refcounts[r_symndx] -= 1;
10505             }
10506           break;
10507
10508         case R_ARM_TLS_LDM32:
10509           elf32_arm_hash_table (info)->tls_ldm_got.refcount -= 1;
10510           break;
10511
10512         case R_ARM_ABS32:
10513         case R_ARM_ABS32_NOI:
10514         case R_ARM_REL32:
10515         case R_ARM_REL32_NOI:
10516         case R_ARM_PC24:
10517         case R_ARM_PLT32:
10518         case R_ARM_CALL:
10519         case R_ARM_JUMP24:
10520         case R_ARM_PREL31:
10521         case R_ARM_THM_CALL:
10522         case R_ARM_THM_JUMP24:
10523         case R_ARM_THM_JUMP19:
10524         case R_ARM_MOVW_ABS_NC:
10525         case R_ARM_MOVT_ABS:
10526         case R_ARM_MOVW_PREL_NC:
10527         case R_ARM_MOVT_PREL:
10528         case R_ARM_THM_MOVW_ABS_NC:
10529         case R_ARM_THM_MOVT_ABS:
10530         case R_ARM_THM_MOVW_PREL_NC:
10531         case R_ARM_THM_MOVT_PREL:
10532           /* Should the interworking branches be here also?  */
10533
10534           if (h != NULL)
10535             {
10536               struct elf32_arm_link_hash_entry *eh;
10537               struct elf32_arm_relocs_copied **pp;
10538               struct elf32_arm_relocs_copied *p;
10539
10540               eh = (struct elf32_arm_link_hash_entry *) h;
10541
10542               if (h->plt.refcount > 0)
10543                 {
10544                   h->plt.refcount -= 1;
10545                   if (r_type == R_ARM_THM_CALL)
10546                     eh->plt_maybe_thumb_refcount--;
10547
10548                   if (r_type == R_ARM_THM_JUMP24
10549                       || r_type == R_ARM_THM_JUMP19)
10550                     eh->plt_thumb_refcount--;
10551                 }
10552
10553               if (r_type == R_ARM_ABS32
10554                   || r_type == R_ARM_REL32
10555                   || r_type == R_ARM_ABS32_NOI
10556                   || r_type == R_ARM_REL32_NOI)
10557                 {
10558                   for (pp = &eh->relocs_copied; (p = *pp) != NULL;
10559                        pp = &p->next)
10560                   if (p->section == sec)
10561                     {
10562                       p->count -= 1;
10563                       if (ELF32_R_TYPE (rel->r_info) == R_ARM_REL32
10564                           || ELF32_R_TYPE (rel->r_info) == R_ARM_REL32_NOI)
10565                         p->pc_count -= 1;
10566                       if (p->count == 0)
10567                         *pp = p->next;
10568                       break;
10569                     }
10570                 }
10571             }
10572           break;
10573
10574         default:
10575           break;
10576         }
10577     }
10578
10579   return TRUE;
10580 }
10581
10582 /* Look through the relocs for a section during the first phase.  */
10583
10584 static bfd_boolean
10585 elf32_arm_check_relocs (bfd *abfd, struct bfd_link_info *info,
10586                         asection *sec, const Elf_Internal_Rela *relocs)
10587 {
10588   Elf_Internal_Shdr *symtab_hdr;
10589   struct elf_link_hash_entry **sym_hashes;
10590   const Elf_Internal_Rela *rel;
10591   const Elf_Internal_Rela *rel_end;
10592   bfd *dynobj;
10593   asection *sreloc;
10594   bfd_vma *local_got_offsets;
10595   struct elf32_arm_link_hash_table *htab;
10596   bfd_boolean needs_plt;
10597   unsigned long nsyms;
10598
10599   if (info->relocatable)
10600     return TRUE;
10601
10602   BFD_ASSERT (is_arm_elf (abfd));
10603
10604   htab = elf32_arm_hash_table (info);
10605   sreloc = NULL;
10606
10607   /* Create dynamic sections for relocatable executables so that we can
10608      copy relocations.  */
10609   if (htab->root.is_relocatable_executable
10610       && ! htab->root.dynamic_sections_created)
10611     {
10612       if (! _bfd_elf_link_create_dynamic_sections (abfd, info))
10613         return FALSE;
10614     }
10615
10616   dynobj = elf_hash_table (info)->dynobj;
10617   local_got_offsets = elf_local_got_offsets (abfd);
10618
10619   symtab_hdr = & elf_symtab_hdr (abfd);
10620   sym_hashes = elf_sym_hashes (abfd);
10621   nsyms = NUM_SHDR_ENTRIES (symtab_hdr);
10622
10623   rel_end = relocs + sec->reloc_count;
10624   for (rel = relocs; rel < rel_end; rel++)
10625     {
10626       struct elf_link_hash_entry *h;
10627       struct elf32_arm_link_hash_entry *eh;
10628       unsigned long r_symndx;
10629       int r_type;
10630
10631       r_symndx = ELF32_R_SYM (rel->r_info);
10632       r_type = ELF32_R_TYPE (rel->r_info);
10633       r_type = arm_real_reloc_type (htab, r_type);
10634
10635       if (r_symndx >= nsyms
10636           /* PR 9934: It is possible to have relocations that do not
10637              refer to symbols, thus it is also possible to have an
10638              object file containing relocations but no symbol table.  */
10639           && (r_symndx > 0 || nsyms > 0))
10640         {
10641           (*_bfd_error_handler) (_("%B: bad symbol index: %d"), abfd,
10642                                    r_symndx);
10643           return FALSE;
10644         }
10645
10646       if (nsyms == 0 || r_symndx < symtab_hdr->sh_info)
10647         h = NULL;
10648       else
10649         {
10650           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
10651           while (h->root.type == bfd_link_hash_indirect
10652                  || h->root.type == bfd_link_hash_warning)
10653             h = (struct elf_link_hash_entry *) h->root.u.i.link;
10654         }
10655
10656       eh = (struct elf32_arm_link_hash_entry *) h;
10657
10658       switch (r_type)
10659         {
10660           case R_ARM_GOT32:
10661           case R_ARM_GOT_PREL:
10662           case R_ARM_TLS_GD32:
10663           case R_ARM_TLS_IE32:
10664             /* This symbol requires a global offset table entry.  */
10665             {
10666               int tls_type, old_tls_type;
10667
10668               switch (r_type)
10669                 {
10670                 case R_ARM_TLS_GD32: tls_type = GOT_TLS_GD; break;
10671                 case R_ARM_TLS_IE32: tls_type = GOT_TLS_IE; break;
10672                 default: tls_type = GOT_NORMAL; break;
10673                 }
10674
10675               if (h != NULL)
10676                 {
10677                   h->got.refcount++;
10678                   old_tls_type = elf32_arm_hash_entry (h)->tls_type;
10679                 }
10680               else
10681                 {
10682                   bfd_signed_vma *local_got_refcounts;
10683
10684                   /* This is a global offset table entry for a local symbol.  */
10685                   local_got_refcounts = elf_local_got_refcounts (abfd);
10686                   if (local_got_refcounts == NULL)
10687                     {
10688                       bfd_size_type size;
10689
10690                       size = symtab_hdr->sh_info;
10691                       size *= (sizeof (bfd_signed_vma) + sizeof (char));
10692                       local_got_refcounts = (bfd_signed_vma *)
10693                           bfd_zalloc (abfd, size);
10694                       if (local_got_refcounts == NULL)
10695                         return FALSE;
10696                       elf_local_got_refcounts (abfd) = local_got_refcounts;
10697                       elf32_arm_local_got_tls_type (abfd)
10698                         = (char *) (local_got_refcounts + symtab_hdr->sh_info);
10699                     }
10700                   local_got_refcounts[r_symndx] += 1;
10701                   old_tls_type = elf32_arm_local_got_tls_type (abfd) [r_symndx];
10702                 }
10703
10704               /* We will already have issued an error message if there is a
10705                  TLS / non-TLS mismatch, based on the symbol type.  We don't
10706                  support any linker relaxations.  So just combine any TLS
10707                  types needed.  */
10708               if (old_tls_type != GOT_UNKNOWN && old_tls_type != GOT_NORMAL
10709                   && tls_type != GOT_NORMAL)
10710                 tls_type |= old_tls_type;
10711
10712               if (old_tls_type != tls_type)
10713                 {
10714                   if (h != NULL)
10715                     elf32_arm_hash_entry (h)->tls_type = tls_type;
10716                   else
10717                     elf32_arm_local_got_tls_type (abfd) [r_symndx] = tls_type;
10718                 }
10719             }
10720             /* Fall through.  */
10721
10722           case R_ARM_TLS_LDM32:
10723             if (r_type == R_ARM_TLS_LDM32)
10724                 htab->tls_ldm_got.refcount++;
10725             /* Fall through.  */
10726
10727           case R_ARM_GOTOFF32:
10728           case R_ARM_GOTPC:
10729             if (htab->sgot == NULL)
10730               {
10731                 if (htab->root.dynobj == NULL)
10732                   htab->root.dynobj = abfd;
10733                 if (!create_got_section (htab->root.dynobj, info))
10734                   return FALSE;
10735               }
10736             break;
10737
10738           case R_ARM_ABS12:
10739             /* VxWorks uses dynamic R_ARM_ABS12 relocations for
10740                ldr __GOTT_INDEX__ offsets.  */
10741             if (!htab->vxworks_p)
10742               break;
10743             /* Fall through.  */
10744
10745           case R_ARM_PC24:
10746           case R_ARM_PLT32:
10747           case R_ARM_CALL:
10748           case R_ARM_JUMP24:
10749           case R_ARM_PREL31:
10750           case R_ARM_THM_CALL:
10751           case R_ARM_THM_JUMP24:
10752           case R_ARM_THM_JUMP19:
10753             needs_plt = 1;
10754             goto normal_reloc;
10755
10756           case R_ARM_MOVW_ABS_NC:
10757           case R_ARM_MOVT_ABS:
10758           case R_ARM_THM_MOVW_ABS_NC:
10759           case R_ARM_THM_MOVT_ABS:
10760             if (info->shared)
10761               {
10762                 (*_bfd_error_handler)
10763                   (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
10764                    abfd, elf32_arm_howto_table_1[r_type].name,
10765                    (h) ? h->root.root.string : "a local symbol");
10766                 bfd_set_error (bfd_error_bad_value);
10767                 return FALSE;
10768               }
10769
10770             /* Fall through.  */
10771           case R_ARM_ABS32:
10772           case R_ARM_ABS32_NOI:
10773           case R_ARM_REL32:
10774           case R_ARM_REL32_NOI:
10775           case R_ARM_MOVW_PREL_NC:
10776           case R_ARM_MOVT_PREL:
10777           case R_ARM_THM_MOVW_PREL_NC:
10778           case R_ARM_THM_MOVT_PREL:
10779             needs_plt = 0;
10780           normal_reloc:
10781
10782             /* Should the interworking branches be listed here?  */
10783             if (h != NULL)
10784               {
10785                 /* If this reloc is in a read-only section, we might
10786                    need a copy reloc.  We can't check reliably at this
10787                    stage whether the section is read-only, as input
10788                    sections have not yet been mapped to output sections.
10789                    Tentatively set the flag for now, and correct in
10790                    adjust_dynamic_symbol.  */
10791                 if (!info->shared)
10792                   h->non_got_ref = 1;
10793
10794                 /* We may need a .plt entry if the function this reloc
10795                    refers to is in a different object.  We can't tell for
10796                    sure yet, because something later might force the
10797                    symbol local.  */
10798                 if (needs_plt)
10799                   h->needs_plt = 1;
10800
10801                 /* If we create a PLT entry, this relocation will reference
10802                    it, even if it's an ABS32 relocation.  */
10803                 h->plt.refcount += 1;
10804
10805                 /* It's too early to use htab->use_blx here, so we have to
10806                    record possible blx references separately from
10807                    relocs that definitely need a thumb stub.  */
10808
10809                 if (r_type == R_ARM_THM_CALL)
10810                   eh->plt_maybe_thumb_refcount += 1;
10811
10812                 if (r_type == R_ARM_THM_JUMP24
10813                     || r_type == R_ARM_THM_JUMP19)
10814                   eh->plt_thumb_refcount += 1;
10815               }
10816
10817             /* If we are creating a shared library or relocatable executable,
10818                and this is a reloc against a global symbol, or a non PC
10819                relative reloc against a local symbol, then we need to copy
10820                the reloc into the shared library.  However, if we are linking
10821                with -Bsymbolic, we do not need to copy a reloc against a
10822                global symbol which is defined in an object we are
10823                including in the link (i.e., DEF_REGULAR is set).  At
10824                this point we have not seen all the input files, so it is
10825                possible that DEF_REGULAR is not set now but will be set
10826                later (it is never cleared).  We account for that
10827                possibility below by storing information in the
10828                relocs_copied field of the hash table entry.  */
10829             if ((info->shared || htab->root.is_relocatable_executable)
10830                 && (sec->flags & SEC_ALLOC) != 0
10831                 && ((r_type == R_ARM_ABS32 || r_type == R_ARM_ABS32_NOI)
10832                     || (h != NULL && ! h->needs_plt
10833                         && (! info->symbolic || ! h->def_regular))))
10834               {
10835                 struct elf32_arm_relocs_copied *p, **head;
10836
10837                 /* When creating a shared object, we must copy these
10838                    reloc types into the output file.  We create a reloc
10839                    section in dynobj and make room for this reloc.  */
10840                 if (sreloc == NULL)
10841                   {
10842                     sreloc = _bfd_elf_make_dynamic_reloc_section
10843                       (sec, dynobj, 2, abfd, ! htab->use_rel);
10844
10845                     if (sreloc == NULL)
10846                       return FALSE;
10847
10848                     /* BPABI objects never have dynamic relocations mapped.  */
10849                     if (htab->symbian_p)
10850                       {
10851                         flagword flags;
10852
10853                         flags = bfd_get_section_flags (dynobj, sreloc);
10854                         flags &= ~(SEC_LOAD | SEC_ALLOC);
10855                         bfd_set_section_flags (dynobj, sreloc, flags);
10856                       }
10857                   }
10858
10859                 /* If this is a global symbol, we count the number of
10860                    relocations we need for this symbol.  */
10861                 if (h != NULL)
10862                   {
10863                     head = &((struct elf32_arm_link_hash_entry *) h)->relocs_copied;
10864                   }
10865                 else
10866                   {
10867                     /* Track dynamic relocs needed for local syms too.
10868                        We really need local syms available to do this
10869                        easily.  Oh well.  */
10870                     asection *s;
10871                     void *vpp;
10872                     Elf_Internal_Sym *isym;
10873
10874                     isym = bfd_sym_from_r_symndx (&htab->sym_cache,
10875                                                   abfd, r_symndx);
10876                     if (isym == NULL)
10877                       return FALSE;
10878
10879                     s = bfd_section_from_elf_index (abfd, isym->st_shndx);
10880                     if (s == NULL)
10881                       s = sec;
10882
10883                     vpp = &elf_section_data (s)->local_dynrel;
10884                     head = (struct elf32_arm_relocs_copied **) vpp;
10885                   }
10886
10887                 p = *head;
10888                 if (p == NULL || p->section != sec)
10889                   {
10890                     bfd_size_type amt = sizeof *p;
10891
10892                     p = (struct elf32_arm_relocs_copied *)
10893                         bfd_alloc (htab->root.dynobj, amt);
10894                     if (p == NULL)
10895                       return FALSE;
10896                     p->next = *head;
10897                     *head = p;
10898                     p->section = sec;
10899                     p->count = 0;
10900                     p->pc_count = 0;
10901                   }
10902
10903                 if (r_type == R_ARM_REL32 || r_type == R_ARM_REL32_NOI)
10904                   p->pc_count += 1;
10905                 p->count += 1;
10906               }
10907             break;
10908
10909         /* This relocation describes the C++ object vtable hierarchy.
10910            Reconstruct it for later use during GC.  */
10911         case R_ARM_GNU_VTINHERIT:
10912           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
10913             return FALSE;
10914           break;
10915
10916         /* This relocation describes which C++ vtable entries are actually
10917            used.  Record for later use during GC.  */
10918         case R_ARM_GNU_VTENTRY:
10919           BFD_ASSERT (h != NULL);
10920           if (h != NULL
10921               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
10922             return FALSE;
10923           break;
10924         }
10925     }
10926
10927   return TRUE;
10928 }
10929
10930 /* Unwinding tables are not referenced directly.  This pass marks them as
10931    required if the corresponding code section is marked.  */
10932
10933 static bfd_boolean
10934 elf32_arm_gc_mark_extra_sections (struct bfd_link_info *info,
10935                                   elf_gc_mark_hook_fn gc_mark_hook)
10936 {
10937   bfd *sub;
10938   Elf_Internal_Shdr **elf_shdrp;
10939   bfd_boolean again;
10940
10941   /* Marking EH data may cause additional code sections to be marked,
10942      requiring multiple passes.  */
10943   again = TRUE;
10944   while (again)
10945     {
10946       again = FALSE;
10947       for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
10948         {
10949           asection *o;
10950
10951           if (! is_arm_elf (sub))
10952             continue;
10953
10954           elf_shdrp = elf_elfsections (sub);
10955           for (o = sub->sections; o != NULL; o = o->next)
10956             {
10957               Elf_Internal_Shdr *hdr;
10958
10959               hdr = &elf_section_data (o)->this_hdr;
10960               if (hdr->sh_type == SHT_ARM_EXIDX
10961                   && hdr->sh_link
10962                   && hdr->sh_link < elf_numsections (sub)
10963                   && !o->gc_mark
10964                   && elf_shdrp[hdr->sh_link]->bfd_section->gc_mark)
10965                 {
10966                   again = TRUE;
10967                   if (!_bfd_elf_gc_mark (info, o, gc_mark_hook))
10968                     return FALSE;
10969                 }
10970             }
10971         }
10972     }
10973
10974   return TRUE;
10975 }
10976
10977 /* Treat mapping symbols as special target symbols.  */
10978
10979 static bfd_boolean
10980 elf32_arm_is_target_special_symbol (bfd * abfd ATTRIBUTE_UNUSED, asymbol * sym)
10981 {
10982   return bfd_is_arm_special_symbol_name (sym->name,
10983                                          BFD_ARM_SPECIAL_SYM_TYPE_ANY);
10984 }
10985
10986 /* This is a copy of elf_find_function() from elf.c except that
10987    ARM mapping symbols are ignored when looking for function names
10988    and STT_ARM_TFUNC is considered to a function type.  */
10989
10990 static bfd_boolean
10991 arm_elf_find_function (bfd *         abfd ATTRIBUTE_UNUSED,
10992                        asection *    section,
10993                        asymbol **    symbols,
10994                        bfd_vma       offset,
10995                        const char ** filename_ptr,
10996                        const char ** functionname_ptr)
10997 {
10998   const char * filename = NULL;
10999   asymbol * func = NULL;
11000   bfd_vma low_func = 0;
11001   asymbol ** p;
11002
11003   for (p = symbols; *p != NULL; p++)
11004     {
11005       elf_symbol_type *q;
11006
11007       q = (elf_symbol_type *) *p;
11008
11009       switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
11010         {
11011         default:
11012           break;
11013         case STT_FILE:
11014           filename = bfd_asymbol_name (&q->symbol);
11015           break;
11016         case STT_FUNC:
11017         case STT_ARM_TFUNC:
11018         case STT_NOTYPE:
11019           /* Skip mapping symbols.  */
11020           if ((q->symbol.flags & BSF_LOCAL)
11021               && bfd_is_arm_special_symbol_name (q->symbol.name,
11022                     BFD_ARM_SPECIAL_SYM_TYPE_ANY))
11023             continue;
11024           /* Fall through.  */
11025           if (bfd_get_section (&q->symbol) == section
11026               && q->symbol.value >= low_func
11027               && q->symbol.value <= offset)
11028             {
11029               func = (asymbol *) q;
11030               low_func = q->symbol.value;
11031             }
11032           break;
11033         }
11034     }
11035
11036   if (func == NULL)
11037     return FALSE;
11038
11039   if (filename_ptr)
11040     *filename_ptr = filename;
11041   if (functionname_ptr)
11042     *functionname_ptr = bfd_asymbol_name (func);
11043
11044   return TRUE;
11045 }
11046
11047
11048 /* Find the nearest line to a particular section and offset, for error
11049    reporting.   This code is a duplicate of the code in elf.c, except
11050    that it uses arm_elf_find_function.  */
11051
11052 static bfd_boolean
11053 elf32_arm_find_nearest_line (bfd *          abfd,
11054                              asection *     section,
11055                              asymbol **     symbols,
11056                              bfd_vma        offset,
11057                              const char **  filename_ptr,
11058                              const char **  functionname_ptr,
11059                              unsigned int * line_ptr)
11060 {
11061   bfd_boolean found = FALSE;
11062
11063   /* We skip _bfd_dwarf1_find_nearest_line since no known ARM toolchain uses it.  */
11064
11065   if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
11066                                      filename_ptr, functionname_ptr,
11067                                      line_ptr, 0,
11068                                      & elf_tdata (abfd)->dwarf2_find_line_info))
11069     {
11070       if (!*functionname_ptr)
11071         arm_elf_find_function (abfd, section, symbols, offset,
11072                                *filename_ptr ? NULL : filename_ptr,
11073                                functionname_ptr);
11074
11075       return TRUE;
11076     }
11077
11078   if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
11079                                              & found, filename_ptr,
11080                                              functionname_ptr, line_ptr,
11081                                              & elf_tdata (abfd)->line_info))
11082     return FALSE;
11083
11084   if (found && (*functionname_ptr || *line_ptr))
11085     return TRUE;
11086
11087   if (symbols == NULL)
11088     return FALSE;
11089
11090   if (! arm_elf_find_function (abfd, section, symbols, offset,
11091                                filename_ptr, functionname_ptr))
11092     return FALSE;
11093
11094   *line_ptr = 0;
11095   return TRUE;
11096 }
11097
11098 static bfd_boolean
11099 elf32_arm_find_inliner_info (bfd *          abfd,
11100                              const char **  filename_ptr,
11101                              const char **  functionname_ptr,
11102                              unsigned int * line_ptr)
11103 {
11104   bfd_boolean found;
11105   found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
11106                                          functionname_ptr, line_ptr,
11107                                          & elf_tdata (abfd)->dwarf2_find_line_info);
11108   return found;
11109 }
11110
11111 /* Adjust a symbol defined by a dynamic object and referenced by a
11112    regular object.  The current definition is in some section of the
11113    dynamic object, but we're not including those sections.  We have to
11114    change the definition to something the rest of the link can
11115    understand.  */
11116
11117 static bfd_boolean
11118 elf32_arm_adjust_dynamic_symbol (struct bfd_link_info * info,
11119                                  struct elf_link_hash_entry * h)
11120 {
11121   bfd * dynobj;
11122   asection * s;
11123   struct elf32_arm_link_hash_entry * eh;
11124   struct elf32_arm_link_hash_table *globals;
11125
11126   globals = elf32_arm_hash_table (info);
11127   dynobj = elf_hash_table (info)->dynobj;
11128
11129   /* Make sure we know what is going on here.  */
11130   BFD_ASSERT (dynobj != NULL
11131               && (h->needs_plt
11132                   || h->u.weakdef != NULL
11133                   || (h->def_dynamic
11134                       && h->ref_regular
11135                       && !h->def_regular)));
11136
11137   eh = (struct elf32_arm_link_hash_entry *) h;
11138
11139   /* If this is a function, put it in the procedure linkage table.  We
11140      will fill in the contents of the procedure linkage table later,
11141      when we know the address of the .got section.  */
11142   if (h->type == STT_FUNC || h->type == STT_ARM_TFUNC
11143       || h->needs_plt)
11144     {
11145       if (h->plt.refcount <= 0
11146           || SYMBOL_CALLS_LOCAL (info, h)
11147           || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
11148               && h->root.type == bfd_link_hash_undefweak))
11149         {
11150           /* This case can occur if we saw a PLT32 reloc in an input
11151              file, but the symbol was never referred to by a dynamic
11152              object, or if all references were garbage collected.  In
11153              such a case, we don't actually need to build a procedure
11154              linkage table, and we can just do a PC24 reloc instead.  */
11155           h->plt.offset = (bfd_vma) -1;
11156           eh->plt_thumb_refcount = 0;
11157           eh->plt_maybe_thumb_refcount = 0;
11158           h->needs_plt = 0;
11159         }
11160
11161       return TRUE;
11162     }
11163   else
11164     {
11165       /* It's possible that we incorrectly decided a .plt reloc was
11166          needed for an R_ARM_PC24 or similar reloc to a non-function sym
11167          in check_relocs.  We can't decide accurately between function
11168          and non-function syms in check-relocs; Objects loaded later in
11169          the link may change h->type.  So fix it now.  */
11170       h->plt.offset = (bfd_vma) -1;
11171       eh->plt_thumb_refcount = 0;
11172       eh->plt_maybe_thumb_refcount = 0;
11173     }
11174
11175   /* If this is a weak symbol, and there is a real definition, the
11176      processor independent code will have arranged for us to see the
11177      real definition first, and we can just use the same value.  */
11178   if (h->u.weakdef != NULL)
11179     {
11180       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
11181                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
11182       h->root.u.def.section = h->u.weakdef->root.u.def.section;
11183       h->root.u.def.value = h->u.weakdef->root.u.def.value;
11184       return TRUE;
11185     }
11186
11187   /* If there are no non-GOT references, we do not need a copy
11188      relocation.  */
11189   if (!h->non_got_ref)
11190     return TRUE;
11191
11192   /* This is a reference to a symbol defined by a dynamic object which
11193      is not a function.  */
11194
11195   /* If we are creating a shared library, we must presume that the
11196      only references to the symbol are via the global offset table.
11197      For such cases we need not do anything here; the relocations will
11198      be handled correctly by relocate_section.  Relocatable executables
11199      can reference data in shared objects directly, so we don't need to
11200      do anything here.  */
11201   if (info->shared || globals->root.is_relocatable_executable)
11202     return TRUE;
11203
11204   if (h->size == 0)
11205     {
11206       (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
11207                              h->root.root.string);
11208       return TRUE;
11209     }
11210
11211   /* We must allocate the symbol in our .dynbss section, which will
11212      become part of the .bss section of the executable.  There will be
11213      an entry for this symbol in the .dynsym section.  The dynamic
11214      object will contain position independent code, so all references
11215      from the dynamic object to this symbol will go through the global
11216      offset table.  The dynamic linker will use the .dynsym entry to
11217      determine the address it must put in the global offset table, so
11218      both the dynamic object and the regular object will refer to the
11219      same memory location for the variable.  */
11220   s = bfd_get_section_by_name (dynobj, ".dynbss");
11221   BFD_ASSERT (s != NULL);
11222
11223   /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
11224      copy the initial value out of the dynamic object and into the
11225      runtime process image.  We need to remember the offset into the
11226      .rel(a).bss section we are going to use.  */
11227   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
11228     {
11229       asection *srel;
11230
11231       srel = bfd_get_section_by_name (dynobj, RELOC_SECTION (globals, ".bss"));
11232       BFD_ASSERT (srel != NULL);
11233       srel->size += RELOC_SIZE (globals);
11234       h->needs_copy = 1;
11235     }
11236
11237   return _bfd_elf_adjust_dynamic_copy (h, s);
11238 }
11239
11240 /* Allocate space in .plt, .got and associated reloc sections for
11241    dynamic relocs.  */
11242
11243 static bfd_boolean
11244 allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
11245 {
11246   struct bfd_link_info *info;
11247   struct elf32_arm_link_hash_table *htab;
11248   struct elf32_arm_link_hash_entry *eh;
11249   struct elf32_arm_relocs_copied *p;
11250   bfd_signed_vma thumb_refs;
11251
11252   eh = (struct elf32_arm_link_hash_entry *) h;
11253
11254   if (h->root.type == bfd_link_hash_indirect)
11255     return TRUE;
11256
11257   if (h->root.type == bfd_link_hash_warning)
11258     /* When warning symbols are created, they **replace** the "real"
11259        entry in the hash table, thus we never get to see the real
11260        symbol in a hash traversal.  So look at it now.  */
11261     h = (struct elf_link_hash_entry *) h->root.u.i.link;
11262
11263   info = (struct bfd_link_info *) inf;
11264   htab = elf32_arm_hash_table (info);
11265
11266   if (htab->root.dynamic_sections_created
11267       && h->plt.refcount > 0)
11268     {
11269       /* Make sure this symbol is output as a dynamic symbol.
11270          Undefined weak syms won't yet be marked as dynamic.  */
11271       if (h->dynindx == -1
11272           && !h->forced_local)
11273         {
11274           if (! bfd_elf_link_record_dynamic_symbol (info, h))
11275             return FALSE;
11276         }
11277
11278       if (info->shared
11279           || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
11280         {
11281           asection *s = htab->splt;
11282
11283           /* If this is the first .plt entry, make room for the special
11284              first entry.  */
11285           if (s->size == 0)
11286             s->size += htab->plt_header_size;
11287
11288           h->plt.offset = s->size;
11289
11290           /* If we will insert a Thumb trampoline before this PLT, leave room
11291              for it.  */
11292           thumb_refs = eh->plt_thumb_refcount;
11293           if (!htab->use_blx)
11294             thumb_refs += eh->plt_maybe_thumb_refcount;
11295
11296           if (thumb_refs > 0)
11297             {
11298               h->plt.offset += PLT_THUMB_STUB_SIZE;
11299               s->size += PLT_THUMB_STUB_SIZE;
11300             }
11301
11302           /* If this symbol is not defined in a regular file, and we are
11303              not generating a shared library, then set the symbol to this
11304              location in the .plt.  This is required to make function
11305              pointers compare as equal between the normal executable and
11306              the shared library.  */
11307           if (! info->shared
11308               && !h->def_regular)
11309             {
11310               h->root.u.def.section = s;
11311               h->root.u.def.value = h->plt.offset;
11312
11313               /* Make sure the function is not marked as Thumb, in case
11314                  it is the target of an ABS32 relocation, which will
11315                  point to the PLT entry.  */
11316               if (ELF_ST_TYPE (h->type) == STT_ARM_TFUNC)
11317                 h->type = ELF_ST_INFO (ELF_ST_BIND (h->type), STT_FUNC);
11318             }
11319
11320           /* Make room for this entry.  */
11321           s->size += htab->plt_entry_size;
11322
11323           if (!htab->symbian_p)
11324             {
11325               /* We also need to make an entry in the .got.plt section, which
11326                  will be placed in the .got section by the linker script.  */
11327               eh->plt_got_offset = htab->sgotplt->size;
11328               htab->sgotplt->size += 4;
11329             }
11330
11331           /* We also need to make an entry in the .rel(a).plt section.  */
11332           htab->srelplt->size += RELOC_SIZE (htab);
11333
11334           /* VxWorks executables have a second set of relocations for
11335              each PLT entry.  They go in a separate relocation section,
11336              which is processed by the kernel loader.  */
11337           if (htab->vxworks_p && !info->shared)
11338             {
11339               /* There is a relocation for the initial PLT entry:
11340                  an R_ARM_32 relocation for _GLOBAL_OFFSET_TABLE_.  */
11341               if (h->plt.offset == htab->plt_header_size)
11342                 htab->srelplt2->size += RELOC_SIZE (htab);
11343
11344               /* There are two extra relocations for each subsequent
11345                  PLT entry: an R_ARM_32 relocation for the GOT entry,
11346                  and an R_ARM_32 relocation for the PLT entry.  */
11347               htab->srelplt2->size += RELOC_SIZE (htab) * 2;
11348             }
11349         }
11350       else
11351         {
11352           h->plt.offset = (bfd_vma) -1;
11353           h->needs_plt = 0;
11354         }
11355     }
11356   else
11357     {
11358       h->plt.offset = (bfd_vma) -1;
11359       h->needs_plt = 0;
11360     }
11361
11362   if (h->got.refcount > 0)
11363     {
11364       asection *s;
11365       bfd_boolean dyn;
11366       int tls_type = elf32_arm_hash_entry (h)->tls_type;
11367       int indx;
11368
11369       /* Make sure this symbol is output as a dynamic symbol.
11370          Undefined weak syms won't yet be marked as dynamic.  */
11371       if (h->dynindx == -1
11372           && !h->forced_local)
11373         {
11374           if (! bfd_elf_link_record_dynamic_symbol (info, h))
11375             return FALSE;
11376         }
11377
11378       if (!htab->symbian_p)
11379         {
11380           s = htab->sgot;
11381           h->got.offset = s->size;
11382
11383           if (tls_type == GOT_UNKNOWN)
11384             abort ();
11385
11386           if (tls_type == GOT_NORMAL)
11387             /* Non-TLS symbols need one GOT slot.  */
11388             s->size += 4;
11389           else
11390             {
11391               if (tls_type & GOT_TLS_GD)
11392                 /* R_ARM_TLS_GD32 needs 2 consecutive GOT slots.  */
11393                 s->size += 8;
11394               if (tls_type & GOT_TLS_IE)
11395                 /* R_ARM_TLS_IE32 needs one GOT slot.  */
11396                 s->size += 4;
11397             }
11398
11399           dyn = htab->root.dynamic_sections_created;
11400
11401           indx = 0;
11402           if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
11403               && (!info->shared
11404                   || !SYMBOL_REFERENCES_LOCAL (info, h)))
11405             indx = h->dynindx;
11406
11407           if (tls_type != GOT_NORMAL
11408               && (info->shared || indx != 0)
11409               && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
11410                   || h->root.type != bfd_link_hash_undefweak))
11411             {
11412               if (tls_type & GOT_TLS_IE)
11413                 htab->srelgot->size += RELOC_SIZE (htab);
11414
11415               if (tls_type & GOT_TLS_GD)
11416                 htab->srelgot->size += RELOC_SIZE (htab);
11417
11418               if ((tls_type & GOT_TLS_GD) && indx != 0)
11419                 htab->srelgot->size += RELOC_SIZE (htab);
11420             }
11421           else if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
11422                     || h->root.type != bfd_link_hash_undefweak)
11423                    && (info->shared
11424                    || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
11425             htab->srelgot->size += RELOC_SIZE (htab);
11426         }
11427     }
11428   else
11429     h->got.offset = (bfd_vma) -1;
11430
11431   /* Allocate stubs for exported Thumb functions on v4t.  */
11432   if (!htab->use_blx && h->dynindx != -1
11433       && h->def_regular
11434       && ELF_ST_TYPE (h->type) == STT_ARM_TFUNC
11435       && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
11436     {
11437       struct elf_link_hash_entry * th;
11438       struct bfd_link_hash_entry * bh;
11439       struct elf_link_hash_entry * myh;
11440       char name[1024];
11441       asection *s;
11442       bh = NULL;
11443       /* Create a new symbol to regist the real location of the function.  */
11444       s = h->root.u.def.section;
11445       sprintf (name, "__real_%s", h->root.root.string);
11446       _bfd_generic_link_add_one_symbol (info, s->owner,
11447                                         name, BSF_GLOBAL, s,
11448                                         h->root.u.def.value,
11449                                         NULL, TRUE, FALSE, &bh);
11450
11451       myh = (struct elf_link_hash_entry *) bh;
11452       myh->type = ELF_ST_INFO (STB_LOCAL, STT_ARM_TFUNC);
11453       myh->forced_local = 1;
11454       eh->export_glue = myh;
11455       th = record_arm_to_thumb_glue (info, h);
11456       /* Point the symbol at the stub.  */
11457       h->type = ELF_ST_INFO (ELF_ST_BIND (h->type), STT_FUNC);
11458       h->root.u.def.section = th->root.u.def.section;
11459       h->root.u.def.value = th->root.u.def.value & ~1;
11460     }
11461
11462   if (eh->relocs_copied == NULL)
11463     return TRUE;
11464
11465   /* In the shared -Bsymbolic case, discard space allocated for
11466      dynamic pc-relative relocs against symbols which turn out to be
11467      defined in regular objects.  For the normal shared case, discard
11468      space for pc-relative relocs that have become local due to symbol
11469      visibility changes.  */
11470
11471   if (info->shared || htab->root.is_relocatable_executable)
11472     {
11473       /* The only relocs that use pc_count are R_ARM_REL32 and
11474          R_ARM_REL32_NOI, which will appear on something like
11475          ".long foo - .".  We want calls to protected symbols to resolve
11476          directly to the function rather than going via the plt.  If people
11477          want function pointer comparisons to work as expected then they
11478          should avoid writing assembly like ".long foo - .".  */
11479       if (SYMBOL_CALLS_LOCAL (info, h))
11480         {
11481           struct elf32_arm_relocs_copied **pp;
11482
11483           for (pp = &eh->relocs_copied; (p = *pp) != NULL; )
11484             {
11485               p->count -= p->pc_count;
11486               p->pc_count = 0;
11487               if (p->count == 0)
11488                 *pp = p->next;
11489               else
11490                 pp = &p->next;
11491             }
11492         }
11493
11494       if (elf32_arm_hash_table (info)->vxworks_p)
11495         {
11496           struct elf32_arm_relocs_copied **pp;
11497
11498           for (pp = &eh->relocs_copied; (p = *pp) != NULL; )
11499             {
11500               if (strcmp (p->section->output_section->name, ".tls_vars") == 0)
11501                 *pp = p->next;
11502               else
11503                 pp = &p->next;
11504             }
11505         }
11506
11507       /* Also discard relocs on undefined weak syms with non-default
11508          visibility.  */
11509       if (eh->relocs_copied != NULL
11510           && h->root.type == bfd_link_hash_undefweak)
11511         {
11512           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
11513             eh->relocs_copied = NULL;
11514
11515           /* Make sure undefined weak symbols are output as a dynamic
11516              symbol in PIEs.  */
11517           else if (h->dynindx == -1
11518                    && !h->forced_local)
11519             {
11520               if (! bfd_elf_link_record_dynamic_symbol (info, h))
11521                 return FALSE;
11522             }
11523         }
11524
11525       else if (htab->root.is_relocatable_executable && h->dynindx == -1
11526                && h->root.type == bfd_link_hash_new)
11527         {
11528           /* Output absolute symbols so that we can create relocations
11529              against them.  For normal symbols we output a relocation
11530              against the section that contains them.  */
11531           if (! bfd_elf_link_record_dynamic_symbol (info, h))
11532             return FALSE;
11533         }
11534
11535     }
11536   else
11537     {
11538       /* For the non-shared case, discard space for relocs against
11539          symbols which turn out to need copy relocs or are not
11540          dynamic.  */
11541
11542       if (!h->non_got_ref
11543           && ((h->def_dynamic
11544                && !h->def_regular)
11545               || (htab->root.dynamic_sections_created
11546                   && (h->root.type == bfd_link_hash_undefweak
11547                       || h->root.type == bfd_link_hash_undefined))))
11548         {
11549           /* Make sure this symbol is output as a dynamic symbol.
11550              Undefined weak syms won't yet be marked as dynamic.  */
11551           if (h->dynindx == -1
11552               && !h->forced_local)
11553             {
11554               if (! bfd_elf_link_record_dynamic_symbol (info, h))
11555                 return FALSE;
11556             }
11557
11558           /* If that succeeded, we know we'll be keeping all the
11559              relocs.  */
11560           if (h->dynindx != -1)
11561             goto keep;
11562         }
11563
11564       eh->relocs_copied = NULL;
11565
11566     keep: ;
11567     }
11568
11569   /* Finally, allocate space.  */
11570   for (p = eh->relocs_copied; p != NULL; p = p->next)
11571     {
11572       asection *sreloc = elf_section_data (p->section)->sreloc;
11573       sreloc->size += p->count * RELOC_SIZE (htab);
11574     }
11575
11576   return TRUE;
11577 }
11578
11579 /* Find any dynamic relocs that apply to read-only sections.  */
11580
11581 static bfd_boolean
11582 elf32_arm_readonly_dynrelocs (struct elf_link_hash_entry * h, void * inf)
11583 {
11584   struct elf32_arm_link_hash_entry * eh;
11585   struct elf32_arm_relocs_copied * p;
11586
11587   if (h->root.type == bfd_link_hash_warning)
11588     h = (struct elf_link_hash_entry *) h->root.u.i.link;
11589
11590   eh = (struct elf32_arm_link_hash_entry *) h;
11591   for (p = eh->relocs_copied; p != NULL; p = p->next)
11592     {
11593       asection *s = p->section;
11594
11595       if (s != NULL && (s->flags & SEC_READONLY) != 0)
11596         {
11597           struct bfd_link_info *info = (struct bfd_link_info *) inf;
11598
11599           info->flags |= DF_TEXTREL;
11600
11601           /* Not an error, just cut short the traversal.  */
11602           return FALSE;
11603         }
11604     }
11605   return TRUE;
11606 }
11607
11608 void
11609 bfd_elf32_arm_set_byteswap_code (struct bfd_link_info *info,
11610                                  int byteswap_code)
11611 {
11612   struct elf32_arm_link_hash_table *globals;
11613
11614   globals = elf32_arm_hash_table (info);
11615   globals->byteswap_code = byteswap_code;
11616 }
11617
11618 /* Set the sizes of the dynamic sections.  */
11619
11620 static bfd_boolean
11621 elf32_arm_size_dynamic_sections (bfd * output_bfd ATTRIBUTE_UNUSED,
11622                                  struct bfd_link_info * info)
11623 {
11624   bfd * dynobj;
11625   asection * s;
11626   bfd_boolean plt;
11627   bfd_boolean relocs;
11628   bfd *ibfd;
11629   struct elf32_arm_link_hash_table *htab;
11630
11631   htab = elf32_arm_hash_table (info);
11632   dynobj = elf_hash_table (info)->dynobj;
11633   BFD_ASSERT (dynobj != NULL);
11634   check_use_blx (htab);
11635
11636   if (elf_hash_table (info)->dynamic_sections_created)
11637     {
11638       /* Set the contents of the .interp section to the interpreter.  */
11639       if (info->executable)
11640         {
11641           s = bfd_get_section_by_name (dynobj, ".interp");
11642           BFD_ASSERT (s != NULL);
11643           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
11644           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
11645         }
11646     }
11647
11648   /* Set up .got offsets for local syms, and space for local dynamic
11649      relocs.  */
11650   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11651     {
11652       bfd_signed_vma *local_got;
11653       bfd_signed_vma *end_local_got;
11654       char *local_tls_type;
11655       bfd_size_type locsymcount;
11656       Elf_Internal_Shdr *symtab_hdr;
11657       asection *srel;
11658       bfd_boolean is_vxworks = elf32_arm_hash_table (info)->vxworks_p;
11659
11660       if (! is_arm_elf (ibfd))
11661         continue;
11662
11663       for (s = ibfd->sections; s != NULL; s = s->next)
11664         {
11665           struct elf32_arm_relocs_copied *p;
11666
11667           for (p = (struct elf32_arm_relocs_copied *)
11668                    elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
11669             {
11670               if (!bfd_is_abs_section (p->section)
11671                   && bfd_is_abs_section (p->section->output_section))
11672                 {
11673                   /* Input section has been discarded, either because
11674                      it is a copy of a linkonce section or due to
11675                      linker script /DISCARD/, so we'll be discarding
11676                      the relocs too.  */
11677                 }
11678               else if (is_vxworks
11679                        && strcmp (p->section->output_section->name,
11680                                   ".tls_vars") == 0)
11681                 {
11682                   /* Relocations in vxworks .tls_vars sections are
11683                      handled specially by the loader.  */
11684                 }
11685               else if (p->count != 0)
11686                 {
11687                   srel = elf_section_data (p->section)->sreloc;
11688                   srel->size += p->count * RELOC_SIZE (htab);
11689                   if ((p->section->output_section->flags & SEC_READONLY) != 0)
11690                     info->flags |= DF_TEXTREL;
11691                 }
11692             }
11693         }
11694
11695       local_got = elf_local_got_refcounts (ibfd);
11696       if (!local_got)
11697         continue;
11698
11699       symtab_hdr = & elf_symtab_hdr (ibfd);
11700       locsymcount = symtab_hdr->sh_info;
11701       end_local_got = local_got + locsymcount;
11702       local_tls_type = elf32_arm_local_got_tls_type (ibfd);
11703       s = htab->sgot;
11704       srel = htab->srelgot;
11705       for (; local_got < end_local_got; ++local_got, ++local_tls_type)
11706         {
11707           if (*local_got > 0)
11708             {
11709               *local_got = s->size;
11710               if (*local_tls_type & GOT_TLS_GD)
11711                 /* TLS_GD relocs need an 8-byte structure in the GOT.  */
11712                 s->size += 8;
11713               if (*local_tls_type & GOT_TLS_IE)
11714                 s->size += 4;
11715               if (*local_tls_type == GOT_NORMAL)
11716                 s->size += 4;
11717
11718               if (info->shared || *local_tls_type == GOT_TLS_GD)
11719                 srel->size += RELOC_SIZE (htab);
11720             }
11721           else
11722             *local_got = (bfd_vma) -1;
11723         }
11724     }
11725
11726   if (htab->tls_ldm_got.refcount > 0)
11727     {
11728       /* Allocate two GOT entries and one dynamic relocation (if necessary)
11729          for R_ARM_TLS_LDM32 relocations.  */
11730       htab->tls_ldm_got.offset = htab->sgot->size;
11731       htab->sgot->size += 8;
11732       if (info->shared)
11733         htab->srelgot->size += RELOC_SIZE (htab);
11734     }
11735   else
11736     htab->tls_ldm_got.offset = -1;
11737
11738   /* Allocate global sym .plt and .got entries, and space for global
11739      sym dynamic relocs.  */
11740   elf_link_hash_traverse (& htab->root, allocate_dynrelocs, info);
11741
11742   /* Here we rummage through the found bfds to collect glue information.  */
11743   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
11744     {
11745       if (! is_arm_elf (ibfd))
11746         continue;
11747
11748       /* Initialise mapping tables for code/data.  */
11749       bfd_elf32_arm_init_maps (ibfd);
11750
11751       if (!bfd_elf32_arm_process_before_allocation (ibfd, info)
11752           || !bfd_elf32_arm_vfp11_erratum_scan (ibfd, info))
11753         /* xgettext:c-format */
11754         _bfd_error_handler (_("Errors encountered processing file %s"),
11755                             ibfd->filename);
11756     }
11757
11758   /* Allocate space for the glue sections now that we've sized them.  */
11759   bfd_elf32_arm_allocate_interworking_sections (info);
11760
11761   /* The check_relocs and adjust_dynamic_symbol entry points have
11762      determined the sizes of the various dynamic sections.  Allocate
11763      memory for them.  */
11764   plt = FALSE;
11765   relocs = FALSE;
11766   for (s = dynobj->sections; s != NULL; s = s->next)
11767     {
11768       const char * name;
11769
11770       if ((s->flags & SEC_LINKER_CREATED) == 0)
11771         continue;
11772
11773       /* It's OK to base decisions on the section name, because none
11774          of the dynobj section names depend upon the input files.  */
11775       name = bfd_get_section_name (dynobj, s);
11776
11777       if (strcmp (name, ".plt") == 0)
11778         {
11779           /* Remember whether there is a PLT.  */
11780           plt = s->size != 0;
11781         }
11782       else if (CONST_STRNEQ (name, ".rel"))
11783         {
11784           if (s->size != 0)
11785             {
11786               /* Remember whether there are any reloc sections other
11787                  than .rel(a).plt and .rela.plt.unloaded.  */
11788               if (s != htab->srelplt && s != htab->srelplt2)
11789                 relocs = TRUE;
11790
11791               /* We use the reloc_count field as a counter if we need
11792                  to copy relocs into the output file.  */
11793               s->reloc_count = 0;
11794             }
11795         }
11796       else if (! CONST_STRNEQ (name, ".got")
11797                && strcmp (name, ".dynbss") != 0)
11798         {
11799           /* It's not one of our sections, so don't allocate space.  */
11800           continue;
11801         }
11802
11803       if (s->size == 0)
11804         {
11805           /* If we don't need this section, strip it from the
11806              output file.  This is mostly to handle .rel(a).bss and
11807              .rel(a).plt.  We must create both sections in
11808              create_dynamic_sections, because they must be created
11809              before the linker maps input sections to output
11810              sections.  The linker does that before
11811              adjust_dynamic_symbol is called, and it is that
11812              function which decides whether anything needs to go
11813              into these sections.  */
11814           s->flags |= SEC_EXCLUDE;
11815           continue;
11816         }
11817
11818       if ((s->flags & SEC_HAS_CONTENTS) == 0)
11819         continue;
11820
11821       /* Allocate memory for the section contents.  */
11822       s->contents = (unsigned char *) bfd_zalloc (dynobj, s->size);
11823       if (s->contents == NULL)
11824         return FALSE;
11825     }
11826
11827   if (elf_hash_table (info)->dynamic_sections_created)
11828     {
11829       /* Add some entries to the .dynamic section.  We fill in the
11830          values later, in elf32_arm_finish_dynamic_sections, but we
11831          must add the entries now so that we get the correct size for
11832          the .dynamic section.  The DT_DEBUG entry is filled in by the
11833          dynamic linker and used by the debugger.  */
11834 #define add_dynamic_entry(TAG, VAL) \
11835   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
11836
11837      if (info->executable)
11838         {
11839           if (!add_dynamic_entry (DT_DEBUG, 0))
11840             return FALSE;
11841         }
11842
11843       if (plt)
11844         {
11845           if (   !add_dynamic_entry (DT_PLTGOT, 0)
11846               || !add_dynamic_entry (DT_PLTRELSZ, 0)
11847               || !add_dynamic_entry (DT_PLTREL,
11848                                      htab->use_rel ? DT_REL : DT_RELA)
11849               || !add_dynamic_entry (DT_JMPREL, 0))
11850             return FALSE;
11851         }
11852
11853       if (relocs)
11854         {
11855           if (htab->use_rel)
11856             {
11857               if (!add_dynamic_entry (DT_REL, 0)
11858                   || !add_dynamic_entry (DT_RELSZ, 0)
11859                   || !add_dynamic_entry (DT_RELENT, RELOC_SIZE (htab)))
11860                 return FALSE;
11861             }
11862           else
11863             {
11864               if (!add_dynamic_entry (DT_RELA, 0)
11865                   || !add_dynamic_entry (DT_RELASZ, 0)
11866                   || !add_dynamic_entry (DT_RELAENT, RELOC_SIZE (htab)))
11867                 return FALSE;
11868             }
11869         }
11870
11871       /* If any dynamic relocs apply to a read-only section,
11872          then we need a DT_TEXTREL entry.  */
11873       if ((info->flags & DF_TEXTREL) == 0)
11874         elf_link_hash_traverse (& htab->root, elf32_arm_readonly_dynrelocs,
11875                                 info);
11876
11877       if ((info->flags & DF_TEXTREL) != 0)
11878         {
11879           if (!add_dynamic_entry (DT_TEXTREL, 0))
11880             return FALSE;
11881         }
11882       if (htab->vxworks_p
11883           && !elf_vxworks_add_dynamic_entries (output_bfd, info))
11884         return FALSE;
11885     }
11886 #undef add_dynamic_entry
11887
11888   return TRUE;
11889 }
11890
11891 /* Finish up dynamic symbol handling.  We set the contents of various
11892    dynamic sections here.  */
11893
11894 static bfd_boolean
11895 elf32_arm_finish_dynamic_symbol (bfd * output_bfd,
11896                                  struct bfd_link_info * info,
11897                                  struct elf_link_hash_entry * h,
11898                                  Elf_Internal_Sym * sym)
11899 {
11900   bfd * dynobj;
11901   struct elf32_arm_link_hash_table *htab;
11902   struct elf32_arm_link_hash_entry *eh;
11903
11904   dynobj = elf_hash_table (info)->dynobj;
11905   htab = elf32_arm_hash_table (info);
11906   eh = (struct elf32_arm_link_hash_entry *) h;
11907
11908   if (h->plt.offset != (bfd_vma) -1)
11909     {
11910       asection * splt;
11911       asection * srel;
11912       bfd_byte *loc;
11913       bfd_vma plt_index;
11914       Elf_Internal_Rela rel;
11915
11916       /* This symbol has an entry in the procedure linkage table.  Set
11917          it up.  */
11918
11919       BFD_ASSERT (h->dynindx != -1);
11920
11921       splt = bfd_get_section_by_name (dynobj, ".plt");
11922       srel = bfd_get_section_by_name (dynobj, RELOC_SECTION (htab, ".plt"));
11923       BFD_ASSERT (splt != NULL && srel != NULL);
11924
11925       /* Fill in the entry in the procedure linkage table.  */
11926       if (htab->symbian_p)
11927         {
11928           put_arm_insn (htab, output_bfd,
11929                       elf32_arm_symbian_plt_entry[0],
11930                       splt->contents + h->plt.offset);
11931           bfd_put_32 (output_bfd,
11932                       elf32_arm_symbian_plt_entry[1],
11933                       splt->contents + h->plt.offset + 4);
11934
11935           /* Fill in the entry in the .rel.plt section.  */
11936           rel.r_offset = (splt->output_section->vma
11937                           + splt->output_offset
11938                           + h->plt.offset + 4);
11939           rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT);
11940
11941           /* Get the index in the procedure linkage table which
11942              corresponds to this symbol.  This is the index of this symbol
11943              in all the symbols for which we are making plt entries.  The
11944              first entry in the procedure linkage table is reserved.  */
11945           plt_index = ((h->plt.offset - htab->plt_header_size)
11946                        / htab->plt_entry_size);
11947         }
11948       else
11949         {
11950           bfd_vma got_offset, got_address, plt_address;
11951           bfd_vma got_displacement;
11952           asection * sgot;
11953           bfd_byte * ptr;
11954
11955           sgot = bfd_get_section_by_name (dynobj, ".got.plt");
11956           BFD_ASSERT (sgot != NULL);
11957
11958           /* Get the offset into the .got.plt table of the entry that
11959              corresponds to this function.  */
11960           got_offset = eh->plt_got_offset;
11961
11962           /* Get the index in the procedure linkage table which
11963              corresponds to this symbol.  This is the index of this symbol
11964              in all the symbols for which we are making plt entries.  The
11965              first three entries in .got.plt are reserved; after that
11966              symbols appear in the same order as in .plt.  */
11967           plt_index = (got_offset - 12) / 4;
11968
11969           /* Calculate the address of the GOT entry.  */
11970           got_address = (sgot->output_section->vma
11971                          + sgot->output_offset
11972                          + got_offset);
11973
11974           /* ...and the address of the PLT entry.  */
11975           plt_address = (splt->output_section->vma
11976                          + splt->output_offset
11977                          + h->plt.offset);
11978
11979           ptr = htab->splt->contents + h->plt.offset;
11980           if (htab->vxworks_p && info->shared)
11981             {
11982               unsigned int i;
11983               bfd_vma val;
11984
11985               for (i = 0; i != htab->plt_entry_size / 4; i++, ptr += 4)
11986                 {
11987                   val = elf32_arm_vxworks_shared_plt_entry[i];
11988                   if (i == 2)
11989                     val |= got_address - sgot->output_section->vma;
11990                   if (i == 5)
11991                     val |= plt_index * RELOC_SIZE (htab);
11992                   if (i == 2 || i == 5)
11993                     bfd_put_32 (output_bfd, val, ptr);
11994                   else
11995                     put_arm_insn (htab, output_bfd, val, ptr);
11996                 }
11997             }
11998           else if (htab->vxworks_p)
11999             {
12000               unsigned int i;
12001               bfd_vma val;
12002
12003               for (i = 0; i != htab->plt_entry_size / 4; i++, ptr += 4)
12004                 {
12005                   val = elf32_arm_vxworks_exec_plt_entry[i];
12006                   if (i == 2)
12007                     val |= got_address;
12008                   if (i == 4)
12009                     val |= 0xffffff & -((h->plt.offset + i * 4 + 8) >> 2);
12010                   if (i == 5)
12011                     val |= plt_index * RELOC_SIZE (htab);
12012                   if (i == 2 || i == 5)
12013                     bfd_put_32 (output_bfd, val, ptr);
12014                   else
12015                     put_arm_insn (htab, output_bfd, val, ptr);
12016                 }
12017
12018               loc = (htab->srelplt2->contents
12019                      + (plt_index * 2 + 1) * RELOC_SIZE (htab));
12020
12021               /* Create the .rela.plt.unloaded R_ARM_ABS32 relocation
12022                  referencing the GOT for this PLT entry.  */
12023               rel.r_offset = plt_address + 8;
12024               rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_ARM_ABS32);
12025               rel.r_addend = got_offset;
12026               SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc);
12027               loc += RELOC_SIZE (htab);
12028
12029               /* Create the R_ARM_ABS32 relocation referencing the
12030                  beginning of the PLT for this GOT entry.  */
12031               rel.r_offset = got_address;
12032               rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_ARM_ABS32);
12033               rel.r_addend = 0;
12034               SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc);
12035             }
12036           else
12037             {
12038               bfd_signed_vma thumb_refs;
12039               /* Calculate the displacement between the PLT slot and the
12040                  entry in the GOT.  The eight-byte offset accounts for the
12041                  value produced by adding to pc in the first instruction
12042                  of the PLT stub.  */
12043               got_displacement = got_address - (plt_address + 8);
12044
12045               BFD_ASSERT ((got_displacement & 0xf0000000) == 0);
12046
12047               thumb_refs = eh->plt_thumb_refcount;
12048               if (!htab->use_blx)
12049                 thumb_refs += eh->plt_maybe_thumb_refcount;
12050
12051               if (thumb_refs > 0)
12052                 {
12053                   put_thumb_insn (htab, output_bfd,
12054                                   elf32_arm_plt_thumb_stub[0], ptr - 4);
12055                   put_thumb_insn (htab, output_bfd,
12056                                   elf32_arm_plt_thumb_stub[1], ptr - 2);
12057                 }
12058
12059               put_arm_insn (htab, output_bfd,
12060                             elf32_arm_plt_entry[0]
12061                             | ((got_displacement & 0x0ff00000) >> 20),
12062                             ptr + 0);
12063               put_arm_insn (htab, output_bfd,
12064                             elf32_arm_plt_entry[1]
12065                             | ((got_displacement & 0x000ff000) >> 12),
12066                             ptr+ 4);
12067               put_arm_insn (htab, output_bfd,
12068                             elf32_arm_plt_entry[2]
12069                             | (got_displacement & 0x00000fff),
12070                             ptr + 8);
12071 #ifdef FOUR_WORD_PLT
12072               bfd_put_32 (output_bfd, elf32_arm_plt_entry[3], ptr + 12);
12073 #endif
12074             }
12075
12076           /* Fill in the entry in the global offset table.  */
12077           bfd_put_32 (output_bfd,
12078                       (splt->output_section->vma
12079                        + splt->output_offset),
12080                       sgot->contents + got_offset);
12081
12082           /* Fill in the entry in the .rel(a).plt section.  */
12083           rel.r_addend = 0;
12084           rel.r_offset = got_address;
12085           rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_JUMP_SLOT);
12086         }
12087
12088       loc = srel->contents + plt_index * RELOC_SIZE (htab);
12089       SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc);
12090
12091       if (!h->def_regular)
12092         {
12093           /* Mark the symbol as undefined, rather than as defined in
12094              the .plt section.  Leave the value alone.  */
12095           sym->st_shndx = SHN_UNDEF;
12096           /* If the symbol is weak, we do need to clear the value.
12097              Otherwise, the PLT entry would provide a definition for
12098              the symbol even if the symbol wasn't defined anywhere,
12099              and so the symbol would never be NULL.  */
12100           if (!h->ref_regular_nonweak)
12101             sym->st_value = 0;
12102         }
12103     }
12104
12105   if (h->got.offset != (bfd_vma) -1
12106       && (elf32_arm_hash_entry (h)->tls_type & GOT_TLS_GD) == 0
12107       && (elf32_arm_hash_entry (h)->tls_type & GOT_TLS_IE) == 0)
12108     {
12109       asection * sgot;
12110       asection * srel;
12111       Elf_Internal_Rela rel;
12112       bfd_byte *loc;
12113       bfd_vma offset;
12114
12115       /* This symbol has an entry in the global offset table.  Set it
12116          up.  */
12117       sgot = bfd_get_section_by_name (dynobj, ".got");
12118       srel = bfd_get_section_by_name (dynobj, RELOC_SECTION (htab, ".got"));
12119       BFD_ASSERT (sgot != NULL && srel != NULL);
12120
12121       offset = (h->got.offset & ~(bfd_vma) 1);
12122       rel.r_addend = 0;
12123       rel.r_offset = (sgot->output_section->vma
12124                       + sgot->output_offset
12125                       + offset);
12126
12127       /* If this is a static link, or it is a -Bsymbolic link and the
12128          symbol is defined locally or was forced to be local because
12129          of a version file, we just want to emit a RELATIVE reloc.
12130          The entry in the global offset table will already have been
12131          initialized in the relocate_section function.  */
12132       if (info->shared
12133           && SYMBOL_REFERENCES_LOCAL (info, h))
12134         {
12135           BFD_ASSERT ((h->got.offset & 1) != 0);
12136           rel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
12137           if (!htab->use_rel)
12138             {
12139               rel.r_addend = bfd_get_32 (output_bfd, sgot->contents + offset);
12140               bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + offset);
12141             }
12142         }
12143       else
12144         {
12145           BFD_ASSERT ((h->got.offset & 1) == 0);
12146           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + offset);
12147           rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT);
12148         }
12149
12150       loc = srel->contents + srel->reloc_count++ * RELOC_SIZE (htab);
12151       SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc);
12152     }
12153
12154   if (h->needs_copy)
12155     {
12156       asection * s;
12157       Elf_Internal_Rela rel;
12158       bfd_byte *loc;
12159
12160       /* This symbol needs a copy reloc.  Set it up.  */
12161       BFD_ASSERT (h->dynindx != -1
12162                   && (h->root.type == bfd_link_hash_defined
12163                       || h->root.type == bfd_link_hash_defweak));
12164
12165       s = bfd_get_section_by_name (h->root.u.def.section->owner,
12166                                    RELOC_SECTION (htab, ".bss"));
12167       BFD_ASSERT (s != NULL);
12168
12169       rel.r_addend = 0;
12170       rel.r_offset = (h->root.u.def.value
12171                       + h->root.u.def.section->output_section->vma
12172                       + h->root.u.def.section->output_offset);
12173       rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_COPY);
12174       loc = s->contents + s->reloc_count++ * RELOC_SIZE (htab);
12175       SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc);
12176     }
12177
12178   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  On VxWorks,
12179      the _GLOBAL_OFFSET_TABLE_ symbol is not absolute: it is relative
12180      to the ".got" section.  */
12181   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
12182       || (!htab->vxworks_p && h == htab->root.hgot))
12183     sym->st_shndx = SHN_ABS;
12184
12185   return TRUE;
12186 }
12187
12188 /* Finish up the dynamic sections.  */
12189
12190 static bfd_boolean
12191 elf32_arm_finish_dynamic_sections (bfd * output_bfd, struct bfd_link_info * info)
12192 {
12193   bfd * dynobj;
12194   asection * sgot;
12195   asection * sdyn;
12196
12197   dynobj = elf_hash_table (info)->dynobj;
12198
12199   sgot = bfd_get_section_by_name (dynobj, ".got.plt");
12200   BFD_ASSERT (elf32_arm_hash_table (info)->symbian_p || sgot != NULL);
12201   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
12202
12203   if (elf_hash_table (info)->dynamic_sections_created)
12204     {
12205       asection *splt;
12206       Elf32_External_Dyn *dyncon, *dynconend;
12207       struct elf32_arm_link_hash_table *htab;
12208
12209       htab = elf32_arm_hash_table (info);
12210       splt = bfd_get_section_by_name (dynobj, ".plt");
12211       BFD_ASSERT (splt != NULL && sdyn != NULL);
12212
12213       dyncon = (Elf32_External_Dyn *) sdyn->contents;
12214       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
12215
12216       for (; dyncon < dynconend; dyncon++)
12217         {
12218           Elf_Internal_Dyn dyn;
12219           const char * name;
12220           asection * s;
12221
12222           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
12223
12224           switch (dyn.d_tag)
12225             {
12226               unsigned int type;
12227
12228             default:
12229               if (htab->vxworks_p
12230                   && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
12231                 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
12232               break;
12233
12234             case DT_HASH:
12235               name = ".hash";
12236               goto get_vma_if_bpabi;
12237             case DT_STRTAB:
12238               name = ".dynstr";
12239               goto get_vma_if_bpabi;
12240             case DT_SYMTAB:
12241               name = ".dynsym";
12242               goto get_vma_if_bpabi;
12243             case DT_VERSYM:
12244               name = ".gnu.version";
12245               goto get_vma_if_bpabi;
12246             case DT_VERDEF:
12247               name = ".gnu.version_d";
12248               goto get_vma_if_bpabi;
12249             case DT_VERNEED:
12250               name = ".gnu.version_r";
12251               goto get_vma_if_bpabi;
12252
12253             case DT_PLTGOT:
12254               name = ".got";
12255               goto get_vma;
12256             case DT_JMPREL:
12257               name = RELOC_SECTION (htab, ".plt");
12258             get_vma:
12259               s = bfd_get_section_by_name (output_bfd, name);
12260               BFD_ASSERT (s != NULL);
12261               if (!htab->symbian_p)
12262                 dyn.d_un.d_ptr = s->vma;
12263               else
12264                 /* In the BPABI, tags in the PT_DYNAMIC section point
12265                    at the file offset, not the memory address, for the
12266                    convenience of the post linker.  */
12267                 dyn.d_un.d_ptr = s->filepos;
12268               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
12269               break;
12270
12271             get_vma_if_bpabi:
12272               if (htab->symbian_p)
12273                 goto get_vma;
12274               break;
12275
12276             case DT_PLTRELSZ:
12277               s = bfd_get_section_by_name (output_bfd,
12278                                            RELOC_SECTION (htab, ".plt"));
12279               BFD_ASSERT (s != NULL);
12280               dyn.d_un.d_val = s->size;
12281               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
12282               break;
12283
12284             case DT_RELSZ:
12285             case DT_RELASZ:
12286               if (!htab->symbian_p)
12287                 {
12288                   /* My reading of the SVR4 ABI indicates that the
12289                      procedure linkage table relocs (DT_JMPREL) should be
12290                      included in the overall relocs (DT_REL).  This is
12291                      what Solaris does.  However, UnixWare can not handle
12292                      that case.  Therefore, we override the DT_RELSZ entry
12293                      here to make it not include the JMPREL relocs.  Since
12294                      the linker script arranges for .rel(a).plt to follow all
12295                      other relocation sections, we don't have to worry
12296                      about changing the DT_REL entry.  */
12297                   s = bfd_get_section_by_name (output_bfd,
12298                                                RELOC_SECTION (htab, ".plt"));
12299                   if (s != NULL)
12300                     dyn.d_un.d_val -= s->size;
12301                   bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
12302                   break;
12303                 }
12304               /* Fall through.  */
12305
12306             case DT_REL:
12307             case DT_RELA:
12308               /* In the BPABI, the DT_REL tag must point at the file
12309                  offset, not the VMA, of the first relocation
12310                  section.  So, we use code similar to that in
12311                  elflink.c, but do not check for SHF_ALLOC on the
12312                  relcoation section, since relocations sections are
12313                  never allocated under the BPABI.  The comments above
12314                  about Unixware notwithstanding, we include all of the
12315                  relocations here.  */
12316               if (htab->symbian_p)
12317                 {
12318                   unsigned int i;
12319                   type = ((dyn.d_tag == DT_REL || dyn.d_tag == DT_RELSZ)
12320                           ? SHT_REL : SHT_RELA);
12321                   dyn.d_un.d_val = 0;
12322                   for (i = 1; i < elf_numsections (output_bfd); i++)
12323                     {
12324                       Elf_Internal_Shdr *hdr
12325                         = elf_elfsections (output_bfd)[i];
12326                       if (hdr->sh_type == type)
12327                         {
12328                           if (dyn.d_tag == DT_RELSZ
12329                               || dyn.d_tag == DT_RELASZ)
12330                             dyn.d_un.d_val += hdr->sh_size;
12331                           else if ((ufile_ptr) hdr->sh_offset
12332                                    <= dyn.d_un.d_val - 1)
12333                             dyn.d_un.d_val = hdr->sh_offset;
12334                         }
12335                     }
12336                   bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
12337                 }
12338               break;
12339
12340               /* Set the bottom bit of DT_INIT/FINI if the
12341                  corresponding function is Thumb.  */
12342             case DT_INIT:
12343               name = info->init_function;
12344               goto get_sym;
12345             case DT_FINI:
12346               name = info->fini_function;
12347             get_sym:
12348               /* If it wasn't set by elf_bfd_final_link
12349                  then there is nothing to adjust.  */
12350               if (dyn.d_un.d_val != 0)
12351                 {
12352                   struct elf_link_hash_entry * eh;
12353
12354                   eh = elf_link_hash_lookup (elf_hash_table (info), name,
12355                                              FALSE, FALSE, TRUE);
12356                   if (eh != NULL
12357                       && ELF_ST_TYPE (eh->type) == STT_ARM_TFUNC)
12358                     {
12359                       dyn.d_un.d_val |= 1;
12360                       bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
12361                     }
12362                 }
12363               break;
12364             }
12365         }
12366
12367       /* Fill in the first entry in the procedure linkage table.  */
12368       if (splt->size > 0 && elf32_arm_hash_table (info)->plt_header_size)
12369         {
12370           const bfd_vma *plt0_entry;
12371           bfd_vma got_address, plt_address, got_displacement;
12372
12373           /* Calculate the addresses of the GOT and PLT.  */
12374           got_address = sgot->output_section->vma + sgot->output_offset;
12375           plt_address = splt->output_section->vma + splt->output_offset;
12376
12377           if (htab->vxworks_p)
12378             {
12379               /* The VxWorks GOT is relocated by the dynamic linker.
12380                  Therefore, we must emit relocations rather than simply
12381                  computing the values now.  */
12382               Elf_Internal_Rela rel;
12383
12384               plt0_entry = elf32_arm_vxworks_exec_plt0_entry;
12385               put_arm_insn (htab, output_bfd, plt0_entry[0],
12386                             splt->contents + 0);
12387               put_arm_insn (htab, output_bfd, plt0_entry[1],
12388                             splt->contents + 4);
12389               put_arm_insn (htab, output_bfd, plt0_entry[2],
12390                             splt->contents + 8);
12391               bfd_put_32 (output_bfd, got_address, splt->contents + 12);
12392
12393               /* Generate a relocation for _GLOBAL_OFFSET_TABLE_.  */
12394               rel.r_offset = plt_address + 12;
12395               rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_ARM_ABS32);
12396               rel.r_addend = 0;
12397               SWAP_RELOC_OUT (htab) (output_bfd, &rel,
12398                                      htab->srelplt2->contents);
12399             }
12400           else
12401             {
12402               got_displacement = got_address - (plt_address + 16);
12403
12404               plt0_entry = elf32_arm_plt0_entry;
12405               put_arm_insn (htab, output_bfd, plt0_entry[0],
12406                             splt->contents + 0);
12407               put_arm_insn (htab, output_bfd, plt0_entry[1],
12408                             splt->contents + 4);
12409               put_arm_insn (htab, output_bfd, plt0_entry[2],
12410                             splt->contents + 8);
12411               put_arm_insn (htab, output_bfd, plt0_entry[3],
12412                             splt->contents + 12);
12413
12414 #ifdef FOUR_WORD_PLT
12415               /* The displacement value goes in the otherwise-unused
12416                  last word of the second entry.  */
12417               bfd_put_32 (output_bfd, got_displacement, splt->contents + 28);
12418 #else
12419               bfd_put_32 (output_bfd, got_displacement, splt->contents + 16);
12420 #endif
12421             }
12422         }
12423
12424       /* UnixWare sets the entsize of .plt to 4, although that doesn't
12425          really seem like the right value.  */
12426       if (splt->output_section->owner == output_bfd)
12427         elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
12428
12429       if (htab->vxworks_p && !info->shared && htab->splt->size > 0)
12430         {
12431           /* Correct the .rel(a).plt.unloaded relocations.  They will have
12432              incorrect symbol indexes.  */
12433           int num_plts;
12434           unsigned char *p;
12435
12436           num_plts = ((htab->splt->size - htab->plt_header_size)
12437                       / htab->plt_entry_size);
12438           p = htab->srelplt2->contents + RELOC_SIZE (htab);
12439
12440           for (; num_plts; num_plts--)
12441             {
12442               Elf_Internal_Rela rel;
12443
12444               SWAP_RELOC_IN (htab) (output_bfd, p, &rel);
12445               rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_ARM_ABS32);
12446               SWAP_RELOC_OUT (htab) (output_bfd, &rel, p);
12447               p += RELOC_SIZE (htab);
12448
12449               SWAP_RELOC_IN (htab) (output_bfd, p, &rel);
12450               rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_ARM_ABS32);
12451               SWAP_RELOC_OUT (htab) (output_bfd, &rel, p);
12452               p += RELOC_SIZE (htab);
12453             }
12454         }
12455     }
12456
12457   /* Fill in the first three entries in the global offset table.  */
12458   if (sgot)
12459     {
12460       if (sgot->size > 0)
12461         {
12462           if (sdyn == NULL)
12463             bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
12464           else
12465             bfd_put_32 (output_bfd,
12466                         sdyn->output_section->vma + sdyn->output_offset,
12467                         sgot->contents);
12468           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
12469           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
12470         }
12471
12472       elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
12473     }
12474
12475   return TRUE;
12476 }
12477
12478 static void
12479 elf32_arm_post_process_headers (bfd * abfd, struct bfd_link_info * link_info ATTRIBUTE_UNUSED)
12480 {
12481   Elf_Internal_Ehdr * i_ehdrp;  /* ELF file header, internal form.  */
12482   struct elf32_arm_link_hash_table *globals;
12483
12484   i_ehdrp = elf_elfheader (abfd);
12485
12486   if (EF_ARM_EABI_VERSION (i_ehdrp->e_flags) == EF_ARM_EABI_UNKNOWN)
12487     i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_ARM;
12488   else
12489     i_ehdrp->e_ident[EI_OSABI] = 0;
12490   i_ehdrp->e_ident[EI_ABIVERSION] = ARM_ELF_ABI_VERSION;
12491
12492   if (link_info)
12493     {
12494       globals = elf32_arm_hash_table (link_info);
12495       if (globals->byteswap_code)
12496         i_ehdrp->e_flags |= EF_ARM_BE8;
12497     }
12498 }
12499
12500 static enum elf_reloc_type_class
12501 elf32_arm_reloc_type_class (const Elf_Internal_Rela *rela)
12502 {
12503   switch ((int) ELF32_R_TYPE (rela->r_info))
12504     {
12505     case R_ARM_RELATIVE:
12506       return reloc_class_relative;
12507     case R_ARM_JUMP_SLOT:
12508       return reloc_class_plt;
12509     case R_ARM_COPY:
12510       return reloc_class_copy;
12511     default:
12512       return reloc_class_normal;
12513     }
12514 }
12515
12516 /* Set the right machine number for an Arm ELF file.  */
12517
12518 static bfd_boolean
12519 elf32_arm_section_flags (flagword *flags, const Elf_Internal_Shdr *hdr)
12520 {
12521   if (hdr->sh_type == SHT_NOTE)
12522     *flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_SAME_CONTENTS;
12523
12524   return TRUE;
12525 }
12526
12527 static void
12528 elf32_arm_final_write_processing (bfd *abfd, bfd_boolean linker ATTRIBUTE_UNUSED)
12529 {
12530   bfd_arm_update_notes (abfd, ARM_NOTE_SECTION);
12531 }
12532
12533 /* Return TRUE if this is an unwinding table entry.  */
12534
12535 static bfd_boolean
12536 is_arm_elf_unwind_section_name (bfd * abfd ATTRIBUTE_UNUSED, const char * name)
12537 {
12538   return (CONST_STRNEQ (name, ELF_STRING_ARM_unwind)
12539           || CONST_STRNEQ (name, ELF_STRING_ARM_unwind_once));
12540 }
12541
12542
12543 /* Set the type and flags for an ARM section.  We do this by
12544    the section name, which is a hack, but ought to work.  */
12545
12546 static bfd_boolean
12547 elf32_arm_fake_sections (bfd * abfd, Elf_Internal_Shdr * hdr, asection * sec)
12548 {
12549   const char * name;
12550
12551   name = bfd_get_section_name (abfd, sec);
12552
12553   if (is_arm_elf_unwind_section_name (abfd, name))
12554     {
12555       hdr->sh_type = SHT_ARM_EXIDX;
12556       hdr->sh_flags |= SHF_LINK_ORDER;
12557     }
12558   return TRUE;
12559 }
12560
12561 /* Handle an ARM specific section when reading an object file.  This is
12562    called when bfd_section_from_shdr finds a section with an unknown
12563    type.  */
12564
12565 static bfd_boolean
12566 elf32_arm_section_from_shdr (bfd *abfd,
12567                              Elf_Internal_Shdr * hdr,
12568                              const char *name,
12569                              int shindex)
12570 {
12571   /* There ought to be a place to keep ELF backend specific flags, but
12572      at the moment there isn't one.  We just keep track of the
12573      sections by their name, instead.  Fortunately, the ABI gives
12574      names for all the ARM specific sections, so we will probably get
12575      away with this.  */
12576   switch (hdr->sh_type)
12577     {
12578     case SHT_ARM_EXIDX:
12579     case SHT_ARM_PREEMPTMAP:
12580     case SHT_ARM_ATTRIBUTES:
12581       break;
12582
12583     default:
12584       return FALSE;
12585     }
12586
12587   if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
12588     return FALSE;
12589
12590   return TRUE;
12591 }
12592
12593 /* A structure used to record a list of sections, independently
12594    of the next and prev fields in the asection structure.  */
12595 typedef struct section_list
12596 {
12597   asection * sec;
12598   struct section_list * next;
12599   struct section_list * prev;
12600 }
12601 section_list;
12602
12603 /* Unfortunately we need to keep a list of sections for which
12604    an _arm_elf_section_data structure has been allocated.  This
12605    is because it is possible for functions like elf32_arm_write_section
12606    to be called on a section which has had an elf_data_structure
12607    allocated for it (and so the used_by_bfd field is valid) but
12608    for which the ARM extended version of this structure - the
12609    _arm_elf_section_data structure - has not been allocated.  */
12610 static section_list * sections_with_arm_elf_section_data = NULL;
12611
12612 static void
12613 record_section_with_arm_elf_section_data (asection * sec)
12614 {
12615   struct section_list * entry;
12616
12617   entry = (struct section_list *) bfd_malloc (sizeof (* entry));
12618   if (entry == NULL)
12619     return;
12620   entry->sec = sec;
12621   entry->next = sections_with_arm_elf_section_data;
12622   entry->prev = NULL;
12623   if (entry->next != NULL)
12624     entry->next->prev = entry;
12625   sections_with_arm_elf_section_data = entry;
12626 }
12627
12628 static struct section_list *
12629 find_arm_elf_section_entry (asection * sec)
12630 {
12631   struct section_list * entry;
12632   static struct section_list * last_entry = NULL;
12633
12634   /* This is a short cut for the typical case where the sections are added
12635      to the sections_with_arm_elf_section_data list in forward order and
12636      then looked up here in backwards order.  This makes a real difference
12637      to the ld-srec/sec64k.exp linker test.  */
12638   entry = sections_with_arm_elf_section_data;
12639   if (last_entry != NULL)
12640     {
12641       if (last_entry->sec == sec)
12642         entry = last_entry;
12643       else if (last_entry->next != NULL
12644                && last_entry->next->sec == sec)
12645         entry = last_entry->next;
12646     }
12647
12648   for (; entry; entry = entry->next)
12649     if (entry->sec == sec)
12650       break;
12651
12652   if (entry)
12653     /* Record the entry prior to this one - it is the entry we are most
12654        likely to want to locate next time.  Also this way if we have been
12655        called from unrecord_section_with_arm_elf_section_data() we will not
12656        be caching a pointer that is about to be freed.  */
12657     last_entry = entry->prev;
12658
12659   return entry;
12660 }
12661
12662 static _arm_elf_section_data *
12663 get_arm_elf_section_data (asection * sec)
12664 {
12665   struct section_list * entry;
12666
12667   entry = find_arm_elf_section_entry (sec);
12668
12669   if (entry)
12670     return elf32_arm_section_data (entry->sec);
12671   else
12672     return NULL;
12673 }
12674
12675 static void
12676 unrecord_section_with_arm_elf_section_data (asection * sec)
12677 {
12678   struct section_list * entry;
12679
12680   entry = find_arm_elf_section_entry (sec);
12681
12682   if (entry)
12683     {
12684       if (entry->prev != NULL)
12685         entry->prev->next = entry->next;
12686       if (entry->next != NULL)
12687         entry->next->prev = entry->prev;
12688       if (entry == sections_with_arm_elf_section_data)
12689         sections_with_arm_elf_section_data = entry->next;
12690       free (entry);
12691     }
12692 }
12693
12694
12695 typedef struct
12696 {
12697   void *finfo;
12698   struct bfd_link_info *info;
12699   asection *sec;
12700   int sec_shndx;
12701   int (*func) (void *, const char *, Elf_Internal_Sym *,
12702                asection *, struct elf_link_hash_entry *);
12703 } output_arch_syminfo;
12704
12705 enum map_symbol_type
12706 {
12707   ARM_MAP_ARM,
12708   ARM_MAP_THUMB,
12709   ARM_MAP_DATA
12710 };
12711
12712
12713 /* Output a single mapping symbol.  */
12714
12715 static bfd_boolean
12716 elf32_arm_output_map_sym (output_arch_syminfo *osi,
12717                           enum map_symbol_type type,
12718                           bfd_vma offset)
12719 {
12720   static const char *names[3] = {"$a", "$t", "$d"};
12721   struct elf32_arm_link_hash_table *htab;
12722   Elf_Internal_Sym sym;
12723
12724   htab = elf32_arm_hash_table (osi->info);
12725   sym.st_value = osi->sec->output_section->vma
12726                  + osi->sec->output_offset
12727                  + offset;
12728   sym.st_size = 0;
12729   sym.st_other = 0;
12730   sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_NOTYPE);
12731   sym.st_shndx = osi->sec_shndx;
12732   return osi->func (osi->finfo, names[type], &sym, osi->sec, NULL) == 1;
12733 }
12734
12735
12736 /* Output mapping symbols for PLT entries associated with H.  */
12737
12738 static bfd_boolean
12739 elf32_arm_output_plt_map (struct elf_link_hash_entry *h, void *inf)
12740 {
12741   output_arch_syminfo *osi = (output_arch_syminfo *) inf;
12742   struct elf32_arm_link_hash_table *htab;
12743   struct elf32_arm_link_hash_entry *eh;
12744   bfd_vma addr;
12745
12746   htab = elf32_arm_hash_table (osi->info);
12747
12748   if (h->root.type == bfd_link_hash_indirect)
12749     return TRUE;
12750
12751   if (h->root.type == bfd_link_hash_warning)
12752     /* When warning symbols are created, they **replace** the "real"
12753        entry in the hash table, thus we never get to see the real
12754        symbol in a hash traversal.  So look at it now.  */
12755     h = (struct elf_link_hash_entry *) h->root.u.i.link;
12756
12757   if (h->plt.offset == (bfd_vma) -1)
12758     return TRUE;
12759
12760   eh = (struct elf32_arm_link_hash_entry *) h;
12761   addr = h->plt.offset;
12762   if (htab->symbian_p)
12763     {
12764       if (!elf32_arm_output_map_sym (osi, ARM_MAP_ARM, addr))
12765         return FALSE;
12766       if (!elf32_arm_output_map_sym (osi, ARM_MAP_DATA, addr + 4))
12767         return FALSE;
12768     }
12769   else if (htab->vxworks_p)
12770     {
12771       if (!elf32_arm_output_map_sym (osi, ARM_MAP_ARM, addr))
12772         return FALSE;
12773       if (!elf32_arm_output_map_sym (osi, ARM_MAP_DATA, addr + 8))
12774         return FALSE;
12775       if (!elf32_arm_output_map_sym (osi, ARM_MAP_ARM, addr + 12))
12776         return FALSE;
12777       if (!elf32_arm_output_map_sym (osi, ARM_MAP_DATA, addr + 20))
12778         return FALSE;
12779     }
12780   else
12781     {
12782       bfd_signed_vma thumb_refs;
12783
12784       thumb_refs = eh->plt_thumb_refcount;
12785       if (!htab->use_blx)
12786         thumb_refs += eh->plt_maybe_thumb_refcount;
12787
12788       if (thumb_refs > 0)
12789         {
12790           if (!elf32_arm_output_map_sym (osi, ARM_MAP_THUMB, addr - 4))
12791             return FALSE;
12792         }
12793 #ifdef FOUR_WORD_PLT
12794       if (!elf32_arm_output_map_sym (osi, ARM_MAP_ARM, addr))
12795         return FALSE;
12796       if (!elf32_arm_output_map_sym (osi, ARM_MAP_DATA, addr + 12))
12797         return FALSE;
12798 #else
12799       /* A three-word PLT with no Thumb thunk contains only Arm code,
12800          so only need to output a mapping symbol for the first PLT entry and
12801          entries with thumb thunks.  */
12802       if (thumb_refs > 0 || addr == 20)
12803         {
12804           if (!elf32_arm_output_map_sym (osi, ARM_MAP_ARM, addr))
12805             return FALSE;
12806         }
12807 #endif
12808     }
12809
12810   return TRUE;
12811 }
12812
12813 /* Output a single local symbol for a generated stub.  */
12814
12815 static bfd_boolean
12816 elf32_arm_output_stub_sym (output_arch_syminfo *osi, const char *name,
12817                            bfd_vma offset, bfd_vma size)
12818 {
12819   struct elf32_arm_link_hash_table *htab;
12820   Elf_Internal_Sym sym;
12821
12822   htab = elf32_arm_hash_table (osi->info);
12823   sym.st_value = osi->sec->output_section->vma
12824                  + osi->sec->output_offset
12825                  + offset;
12826   sym.st_size = size;
12827   sym.st_other = 0;
12828   sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
12829   sym.st_shndx = osi->sec_shndx;
12830   return osi->func (osi->finfo, name, &sym, osi->sec, NULL) == 1;
12831 }
12832
12833 static bfd_boolean
12834 arm_map_one_stub (struct bfd_hash_entry * gen_entry,
12835                   void * in_arg)
12836 {
12837   struct elf32_arm_stub_hash_entry *stub_entry;
12838   struct bfd_link_info *info;
12839   struct elf32_arm_link_hash_table *htab;
12840   asection *stub_sec;
12841   bfd_vma addr;
12842   char *stub_name;
12843   output_arch_syminfo *osi;
12844   const insn_sequence *template_sequence;
12845   enum stub_insn_type prev_type;
12846   int size;
12847   int i;
12848   enum map_symbol_type sym_type;
12849
12850   /* Massage our args to the form they really have.  */
12851   stub_entry = (struct elf32_arm_stub_hash_entry *) gen_entry;
12852   osi = (output_arch_syminfo *) in_arg;
12853
12854   info = osi->info;
12855
12856   htab = elf32_arm_hash_table (info);
12857   stub_sec = stub_entry->stub_sec;
12858
12859   /* Ensure this stub is attached to the current section being
12860      processed.  */
12861   if (stub_sec != osi->sec)
12862     return TRUE;
12863
12864   addr = (bfd_vma) stub_entry->stub_offset;
12865   stub_name = stub_entry->output_name;
12866
12867   template_sequence = stub_entry->stub_template;
12868   switch (template_sequence[0].type)
12869     {
12870     case ARM_TYPE:
12871       if (!elf32_arm_output_stub_sym (osi, stub_name, addr, stub_entry->stub_size))
12872         return FALSE;
12873       break;
12874     case THUMB16_TYPE:
12875     case THUMB32_TYPE:
12876       if (!elf32_arm_output_stub_sym (osi, stub_name, addr | 1,
12877                                       stub_entry->stub_size))
12878         return FALSE;
12879       break;
12880     default:
12881       BFD_FAIL ();
12882       return 0;
12883     }
12884
12885   prev_type = DATA_TYPE;
12886   size = 0;
12887   for (i = 0; i < stub_entry->stub_template_size; i++)
12888     {
12889       switch (template_sequence[i].type)
12890         {
12891         case ARM_TYPE:
12892           sym_type = ARM_MAP_ARM;
12893           break;
12894
12895         case THUMB16_TYPE:
12896         case THUMB32_TYPE:
12897           sym_type = ARM_MAP_THUMB;
12898           break;
12899
12900         case DATA_TYPE:
12901           sym_type = ARM_MAP_DATA;
12902           break;
12903
12904         default:
12905           BFD_FAIL ();
12906           return FALSE;
12907         }
12908
12909       if (template_sequence[i].type != prev_type)
12910         {
12911           prev_type = template_sequence[i].type;
12912           if (!elf32_arm_output_map_sym (osi, sym_type, addr + size))
12913             return FALSE;
12914         }
12915
12916       switch (template_sequence[i].type)
12917         {
12918         case ARM_TYPE:
12919         case THUMB32_TYPE:
12920           size += 4;
12921           break;
12922
12923         case THUMB16_TYPE:
12924           size += 2;
12925           break;
12926
12927         case DATA_TYPE:
12928           size += 4;
12929           break;
12930
12931         default:
12932           BFD_FAIL ();
12933           return FALSE;
12934         }
12935     }
12936
12937   return TRUE;
12938 }
12939
12940 /* Output mapping symbols for linker generated sections.  */
12941
12942 static bfd_boolean
12943 elf32_arm_output_arch_local_syms (bfd *output_bfd,
12944                                   struct bfd_link_info *info,
12945                                   void *finfo,
12946                                   int (*func) (void *, const char *,
12947                                                Elf_Internal_Sym *,
12948                                                asection *,
12949                                                struct elf_link_hash_entry *))
12950 {
12951   output_arch_syminfo osi;
12952   struct elf32_arm_link_hash_table *htab;
12953   bfd_vma offset;
12954   bfd_size_type size;
12955
12956   htab = elf32_arm_hash_table (info);
12957   check_use_blx (htab);
12958
12959   osi.finfo = finfo;
12960   osi.info = info;
12961   osi.func = func;
12962
12963   /* ARM->Thumb glue.  */
12964   if (htab->arm_glue_size > 0)
12965     {
12966       osi.sec = bfd_get_section_by_name (htab->bfd_of_glue_owner,
12967                                          ARM2THUMB_GLUE_SECTION_NAME);
12968
12969       osi.sec_shndx = _bfd_elf_section_from_bfd_section
12970           (output_bfd, osi.sec->output_section);
12971       if (info->shared || htab->root.is_relocatable_executable
12972           || htab->pic_veneer)
12973         size = ARM2THUMB_PIC_GLUE_SIZE;
12974       else if (htab->use_blx)
12975         size = ARM2THUMB_V5_STATIC_GLUE_SIZE;
12976       else
12977         size = ARM2THUMB_STATIC_GLUE_SIZE;
12978
12979       for (offset = 0; offset < htab->arm_glue_size; offset += size)
12980         {
12981           elf32_arm_output_map_sym (&osi, ARM_MAP_ARM, offset);
12982           elf32_arm_output_map_sym (&osi, ARM_MAP_DATA, offset + size - 4);
12983         }
12984     }
12985
12986   /* Thumb->ARM glue.  */
12987   if (htab->thumb_glue_size > 0)
12988     {
12989       osi.sec = bfd_get_section_by_name (htab->bfd_of_glue_owner,
12990                                          THUMB2ARM_GLUE_SECTION_NAME);
12991
12992       osi.sec_shndx = _bfd_elf_section_from_bfd_section
12993           (output_bfd, osi.sec->output_section);
12994       size = THUMB2ARM_GLUE_SIZE;
12995
12996       for (offset = 0; offset < htab->thumb_glue_size; offset += size)
12997         {
12998           elf32_arm_output_map_sym (&osi, ARM_MAP_THUMB, offset);
12999           elf32_arm_output_map_sym (&osi, ARM_MAP_ARM, offset + 4);
13000         }
13001     }
13002
13003   /* ARMv4 BX veneers.  */
13004   if (htab->bx_glue_size > 0)
13005     {
13006       osi.sec = bfd_get_section_by_name (htab->bfd_of_glue_owner,
13007                                          ARM_BX_GLUE_SECTION_NAME);
13008
13009       osi.sec_shndx = _bfd_elf_section_from_bfd_section
13010           (output_bfd, osi.sec->output_section);
13011
13012       elf32_arm_output_map_sym (&osi, ARM_MAP_ARM, 0);
13013     }
13014
13015   /* Long calls stubs.  */
13016   if (htab->stub_bfd && htab->stub_bfd->sections)
13017     {
13018       asection* stub_sec;
13019
13020       for (stub_sec = htab->stub_bfd->sections;
13021            stub_sec != NULL;
13022            stub_sec = stub_sec->next)
13023         {
13024           /* Ignore non-stub sections.  */
13025           if (!strstr (stub_sec->name, STUB_SUFFIX))
13026             continue;
13027
13028           osi.sec = stub_sec;
13029
13030           osi.sec_shndx = _bfd_elf_section_from_bfd_section
13031             (output_bfd, osi.sec->output_section);
13032
13033           bfd_hash_traverse (&htab->stub_hash_table, arm_map_one_stub, &osi);
13034         }
13035     }
13036
13037   /* Finally, output mapping symbols for the PLT.  */
13038   if (!htab->splt || htab->splt->size == 0)
13039     return TRUE;
13040
13041   osi.sec_shndx = _bfd_elf_section_from_bfd_section (output_bfd,
13042                                                      htab->splt->output_section);
13043   osi.sec = htab->splt;
13044   /* Output mapping symbols for the plt header.  SymbianOS does not have a
13045      plt header.  */
13046   if (htab->vxworks_p)
13047     {
13048       /* VxWorks shared libraries have no PLT header.  */
13049       if (!info->shared)
13050         {
13051           if (!elf32_arm_output_map_sym (&osi, ARM_MAP_ARM, 0))
13052             return FALSE;
13053           if (!elf32_arm_output_map_sym (&osi, ARM_MAP_DATA, 12))
13054             return FALSE;
13055         }
13056     }
13057   else if (!htab->symbian_p)
13058     {
13059       if (!elf32_arm_output_map_sym (&osi, ARM_MAP_ARM, 0))
13060         return FALSE;
13061 #ifndef FOUR_WORD_PLT
13062       if (!elf32_arm_output_map_sym (&osi, ARM_MAP_DATA, 16))
13063         return FALSE;
13064 #endif
13065     }
13066
13067   elf_link_hash_traverse (&htab->root, elf32_arm_output_plt_map, (void *) &osi);
13068   return TRUE;
13069 }
13070
13071 /* Allocate target specific section data.  */
13072
13073 static bfd_boolean
13074 elf32_arm_new_section_hook (bfd *abfd, asection *sec)
13075 {
13076   if (!sec->used_by_bfd)
13077     {
13078       _arm_elf_section_data *sdata;
13079       bfd_size_type amt = sizeof (*sdata);
13080
13081       sdata = (_arm_elf_section_data *) bfd_zalloc (abfd, amt);
13082       if (sdata == NULL)
13083         return FALSE;
13084       sec->used_by_bfd = sdata;
13085     }
13086
13087   record_section_with_arm_elf_section_data (sec);
13088
13089   return _bfd_elf_new_section_hook (abfd, sec);
13090 }
13091
13092
13093 /* Used to order a list of mapping symbols by address.  */
13094
13095 static int
13096 elf32_arm_compare_mapping (const void * a, const void * b)
13097 {
13098   const elf32_arm_section_map *amap = (const elf32_arm_section_map *) a;
13099   const elf32_arm_section_map *bmap = (const elf32_arm_section_map *) b;
13100
13101   if (amap->vma > bmap->vma)
13102     return 1;
13103   else if (amap->vma < bmap->vma)
13104     return -1;
13105   else if (amap->type > bmap->type)
13106     /* Ensure results do not depend on the host qsort for objects with
13107        multiple mapping symbols at the same address by sorting on type
13108        after vma.  */
13109     return 1;
13110   else if (amap->type < bmap->type)
13111     return -1;
13112   else
13113     return 0;
13114 }
13115
13116 /* Add OFFSET to lower 31 bits of ADDR, leaving other bits unmodified.  */
13117
13118 static unsigned long
13119 offset_prel31 (unsigned long addr, bfd_vma offset)
13120 {
13121   return (addr & ~0x7ffffffful) | ((addr + offset) & 0x7ffffffful);
13122 }
13123
13124 /* Copy an .ARM.exidx table entry, adding OFFSET to (applied) PREL31
13125    relocations.  */
13126
13127 static void
13128 copy_exidx_entry (bfd *output_bfd, bfd_byte *to, bfd_byte *from, bfd_vma offset)
13129 {
13130   unsigned long first_word = bfd_get_32 (output_bfd, from);
13131   unsigned long second_word = bfd_get_32 (output_bfd, from + 4);
13132
13133   /* High bit of first word is supposed to be zero.  */
13134   if ((first_word & 0x80000000ul) == 0)
13135     first_word = offset_prel31 (first_word, offset);
13136
13137   /* If the high bit of the first word is clear, and the bit pattern is not 0x1
13138      (EXIDX_CANTUNWIND), this is an offset to an .ARM.extab entry.  */
13139   if ((second_word != 0x1) && ((second_word & 0x80000000ul) == 0))
13140     second_word = offset_prel31 (second_word, offset);
13141
13142   bfd_put_32 (output_bfd, first_word, to);
13143   bfd_put_32 (output_bfd, second_word, to + 4);
13144 }
13145
13146 /* Data for make_branch_to_a8_stub().  */
13147
13148 struct a8_branch_to_stub_data {
13149   asection *writing_section;
13150   bfd_byte *contents;
13151 };
13152
13153
13154 /* Helper to insert branches to Cortex-A8 erratum stubs in the right
13155    places for a particular section.  */
13156
13157 static bfd_boolean
13158 make_branch_to_a8_stub (struct bfd_hash_entry *gen_entry,
13159                        void *in_arg)
13160 {
13161   struct elf32_arm_stub_hash_entry *stub_entry;
13162   struct a8_branch_to_stub_data *data;
13163   bfd_byte *contents;
13164   unsigned long branch_insn;
13165   bfd_vma veneered_insn_loc, veneer_entry_loc;
13166   bfd_signed_vma branch_offset;
13167   bfd *abfd;
13168   unsigned int target;
13169
13170   stub_entry = (struct elf32_arm_stub_hash_entry *) gen_entry;
13171   data = (struct a8_branch_to_stub_data *) in_arg;
13172
13173   if (stub_entry->target_section != data->writing_section
13174       || stub_entry->stub_type < arm_stub_a8_veneer_b_cond)
13175     return TRUE;
13176
13177   contents = data->contents;
13178
13179   veneered_insn_loc = stub_entry->target_section->output_section->vma
13180                       + stub_entry->target_section->output_offset
13181                       + stub_entry->target_value;
13182
13183   veneer_entry_loc = stub_entry->stub_sec->output_section->vma
13184                      + stub_entry->stub_sec->output_offset
13185                      + stub_entry->stub_offset;
13186
13187   if (stub_entry->stub_type == arm_stub_a8_veneer_blx)
13188     veneered_insn_loc &= ~3u;
13189
13190   branch_offset = veneer_entry_loc - veneered_insn_loc - 4;
13191
13192   abfd = stub_entry->target_section->owner;
13193   target = stub_entry->target_value;
13194
13195   /* We attempt to avoid this condition by setting stubs_always_after_branch
13196      in elf32_arm_size_stubs if we've enabled the Cortex-A8 erratum workaround.
13197      This check is just to be on the safe side...  */
13198   if ((veneered_insn_loc & ~0xfff) == (veneer_entry_loc & ~0xfff))
13199     {
13200       (*_bfd_error_handler) (_("%B: error: Cortex-A8 erratum stub is "
13201                                "allocated in unsafe location"), abfd);
13202       return FALSE;
13203     }
13204
13205   switch (stub_entry->stub_type)
13206     {
13207     case arm_stub_a8_veneer_b:
13208     case arm_stub_a8_veneer_b_cond:
13209       branch_insn = 0xf0009000;
13210       goto jump24;
13211
13212     case arm_stub_a8_veneer_blx:
13213       branch_insn = 0xf000e800;
13214       goto jump24;
13215
13216     case arm_stub_a8_veneer_bl:
13217       {
13218         unsigned int i1, j1, i2, j2, s;
13219
13220         branch_insn = 0xf000d000;
13221
13222       jump24:
13223         if (branch_offset < -16777216 || branch_offset > 16777214)
13224           {
13225             /* There's not much we can do apart from complain if this
13226                happens.  */
13227             (*_bfd_error_handler) (_("%B: error: Cortex-A8 erratum stub out "
13228                                      "of range (input file too large)"), abfd);
13229             return FALSE;
13230           }
13231
13232         /* i1 = not(j1 eor s), so:
13233            not i1 = j1 eor s
13234            j1 = (not i1) eor s.  */
13235
13236         branch_insn |= (branch_offset >> 1) & 0x7ff;
13237         branch_insn |= ((branch_offset >> 12) & 0x3ff) << 16;
13238         i2 = (branch_offset >> 22) & 1;
13239         i1 = (branch_offset >> 23) & 1;
13240         s = (branch_offset >> 24) & 1;
13241         j1 = (!i1) ^ s;
13242         j2 = (!i2) ^ s;
13243         branch_insn |= j2 << 11;
13244         branch_insn |= j1 << 13;
13245         branch_insn |= s << 26;
13246       }
13247       break;
13248
13249     default:
13250       BFD_FAIL ();
13251       return FALSE;
13252     }
13253
13254   bfd_put_16 (abfd, (branch_insn >> 16) & 0xffff, &contents[target]);
13255   bfd_put_16 (abfd, branch_insn & 0xffff, &contents[target + 2]);
13256
13257   return TRUE;
13258 }
13259
13260 /* Do code byteswapping.  Return FALSE afterwards so that the section is
13261    written out as normal.  */
13262
13263 static bfd_boolean
13264 elf32_arm_write_section (bfd *output_bfd,
13265                          struct bfd_link_info *link_info,
13266                          asection *sec,
13267                          bfd_byte *contents)
13268 {
13269   unsigned int mapcount, errcount;
13270   _arm_elf_section_data *arm_data;
13271   struct elf32_arm_link_hash_table *globals = elf32_arm_hash_table (link_info);
13272   elf32_arm_section_map *map;
13273   elf32_vfp11_erratum_list *errnode;
13274   bfd_vma ptr;
13275   bfd_vma end;
13276   bfd_vma offset = sec->output_section->vma + sec->output_offset;
13277   bfd_byte tmp;
13278   unsigned int i;
13279
13280   /* If this section has not been allocated an _arm_elf_section_data
13281      structure then we cannot record anything.  */
13282   arm_data = get_arm_elf_section_data (sec);
13283   if (arm_data == NULL)
13284     return FALSE;
13285
13286   mapcount = arm_data->mapcount;
13287   map = arm_data->map;
13288   errcount = arm_data->erratumcount;
13289
13290   if (errcount != 0)
13291     {
13292       unsigned int endianflip = bfd_big_endian (output_bfd) ? 3 : 0;
13293
13294       for (errnode = arm_data->erratumlist; errnode != 0;
13295            errnode = errnode->next)
13296         {
13297           bfd_vma target = errnode->vma - offset;
13298
13299           switch (errnode->type)
13300             {
13301             case VFP11_ERRATUM_BRANCH_TO_ARM_VENEER:
13302               {
13303                 bfd_vma branch_to_veneer;
13304                 /* Original condition code of instruction, plus bit mask for
13305                    ARM B instruction.  */
13306                 unsigned int insn = (errnode->u.b.vfp_insn & 0xf0000000)
13307                                   | 0x0a000000;
13308
13309                 /* The instruction is before the label.  */
13310                 target -= 4;
13311
13312                 /* Above offset included in -4 below.  */
13313                 branch_to_veneer = errnode->u.b.veneer->vma
13314                                    - errnode->vma - 4;
13315
13316                 if ((signed) branch_to_veneer < -(1 << 25)
13317                     || (signed) branch_to_veneer >= (1 << 25))
13318                   (*_bfd_error_handler) (_("%B: error: VFP11 veneer out of "
13319                                            "range"), output_bfd);
13320
13321                 insn |= (branch_to_veneer >> 2) & 0xffffff;
13322                 contents[endianflip ^ target] = insn & 0xff;
13323                 contents[endianflip ^ (target + 1)] = (insn >> 8) & 0xff;
13324                 contents[endianflip ^ (target + 2)] = (insn >> 16) & 0xff;
13325                 contents[endianflip ^ (target + 3)] = (insn >> 24) & 0xff;
13326               }
13327               break;
13328
13329             case VFP11_ERRATUM_ARM_VENEER:
13330               {
13331                 bfd_vma branch_from_veneer;
13332                 unsigned int insn;
13333
13334                 /* Take size of veneer into account.  */
13335                 branch_from_veneer = errnode->u.v.branch->vma
13336                                      - errnode->vma - 12;
13337
13338                 if ((signed) branch_from_veneer < -(1 << 25)
13339                     || (signed) branch_from_veneer >= (1 << 25))
13340                   (*_bfd_error_handler) (_("%B: error: VFP11 veneer out of "
13341                                            "range"), output_bfd);
13342
13343                 /* Original instruction.  */
13344                 insn = errnode->u.v.branch->u.b.vfp_insn;
13345                 contents[endianflip ^ target] = insn & 0xff;
13346                 contents[endianflip ^ (target + 1)] = (insn >> 8) & 0xff;
13347                 contents[endianflip ^ (target + 2)] = (insn >> 16) & 0xff;
13348                 contents[endianflip ^ (target + 3)] = (insn >> 24) & 0xff;
13349
13350                 /* Branch back to insn after original insn.  */
13351                 insn = 0xea000000 | ((branch_from_veneer >> 2) & 0xffffff);
13352                 contents[endianflip ^ (target + 4)] = insn & 0xff;
13353                 contents[endianflip ^ (target + 5)] = (insn >> 8) & 0xff;
13354                 contents[endianflip ^ (target + 6)] = (insn >> 16) & 0xff;
13355                 contents[endianflip ^ (target + 7)] = (insn >> 24) & 0xff;
13356               }
13357               break;
13358
13359             default:
13360               abort ();
13361             }
13362         }
13363     }
13364
13365   if (arm_data->elf.this_hdr.sh_type == SHT_ARM_EXIDX)
13366     {
13367       arm_unwind_table_edit *edit_node
13368         = arm_data->u.exidx.unwind_edit_list;
13369       /* Now, sec->size is the size of the section we will write.  The original
13370          size (before we merged duplicate entries and inserted EXIDX_CANTUNWIND
13371          markers) was sec->rawsize.  (This isn't the case if we perform no
13372          edits, then rawsize will be zero and we should use size).  */
13373       bfd_byte *edited_contents = (bfd_byte *) bfd_malloc (sec->size);
13374       unsigned int input_size = sec->rawsize ? sec->rawsize : sec->size;
13375       unsigned int in_index, out_index;
13376       bfd_vma add_to_offsets = 0;
13377
13378       for (in_index = 0, out_index = 0; in_index * 8 < input_size || edit_node;)
13379         {
13380           if (edit_node)
13381             {
13382               unsigned int edit_index = edit_node->index;
13383
13384               if (in_index < edit_index && in_index * 8 < input_size)
13385                 {
13386                   copy_exidx_entry (output_bfd, edited_contents + out_index * 8,
13387                                     contents + in_index * 8, add_to_offsets);
13388                   out_index++;
13389                   in_index++;
13390                 }
13391               else if (in_index == edit_index
13392                        || (in_index * 8 >= input_size
13393                            && edit_index == UINT_MAX))
13394                 {
13395                   switch (edit_node->type)
13396                     {
13397                     case DELETE_EXIDX_ENTRY:
13398                       in_index++;
13399                       add_to_offsets += 8;
13400                       break;
13401
13402                     case INSERT_EXIDX_CANTUNWIND_AT_END:
13403                       {
13404                         asection *text_sec = edit_node->linked_section;
13405                         bfd_vma text_offset = text_sec->output_section->vma
13406                                               + text_sec->output_offset
13407                                               + text_sec->size;
13408                         bfd_vma exidx_offset = offset + out_index * 8;
13409                         unsigned long prel31_offset;
13410
13411                         /* Note: this is meant to be equivalent to an
13412                            R_ARM_PREL31 relocation.  These synthetic
13413                            EXIDX_CANTUNWIND markers are not relocated by the
13414                            usual BFD method.  */
13415                         prel31_offset = (text_offset - exidx_offset)
13416                                         & 0x7ffffffful;
13417
13418                         /* First address we can't unwind.  */
13419                         bfd_put_32 (output_bfd, prel31_offset,
13420                                     &edited_contents[out_index * 8]);
13421
13422                         /* Code for EXIDX_CANTUNWIND.  */
13423                         bfd_put_32 (output_bfd, 0x1,
13424                                     &edited_contents[out_index * 8 + 4]);
13425
13426                         out_index++;
13427                         add_to_offsets -= 8;
13428                       }
13429                       break;
13430                     }
13431
13432                   edit_node = edit_node->next;
13433                 }
13434             }
13435           else
13436             {
13437               /* No more edits, copy remaining entries verbatim.  */
13438               copy_exidx_entry (output_bfd, edited_contents + out_index * 8,
13439                                 contents + in_index * 8, add_to_offsets);
13440               out_index++;
13441               in_index++;
13442             }
13443         }
13444
13445       if (!(sec->flags & SEC_EXCLUDE) && !(sec->flags & SEC_NEVER_LOAD))
13446         bfd_set_section_contents (output_bfd, sec->output_section,
13447                                   edited_contents,
13448                                   (file_ptr) sec->output_offset, sec->size);
13449
13450       return TRUE;
13451     }
13452
13453   /* Fix code to point to Cortex-A8 erratum stubs.  */
13454   if (globals->fix_cortex_a8)
13455     {
13456       struct a8_branch_to_stub_data data;
13457
13458       data.writing_section = sec;
13459       data.contents = contents;
13460
13461       bfd_hash_traverse (&globals->stub_hash_table, make_branch_to_a8_stub,
13462                          &data);
13463     }
13464
13465   if (mapcount == 0)
13466     return FALSE;
13467
13468   if (globals->byteswap_code)
13469     {
13470       qsort (map, mapcount, sizeof (* map), elf32_arm_compare_mapping);
13471
13472       ptr = map[0].vma;
13473       for (i = 0; i < mapcount; i++)
13474         {
13475           if (i == mapcount - 1)
13476             end = sec->size;
13477           else
13478             end = map[i + 1].vma;
13479
13480           switch (map[i].type)
13481             {
13482             case 'a':
13483               /* Byte swap code words.  */
13484               while (ptr + 3 < end)
13485                 {
13486                   tmp = contents[ptr];
13487                   contents[ptr] = contents[ptr + 3];
13488                   contents[ptr + 3] = tmp;
13489                   tmp = contents[ptr + 1];
13490                   contents[ptr + 1] = contents[ptr + 2];
13491                   contents[ptr + 2] = tmp;
13492                   ptr += 4;
13493                 }
13494               break;
13495
13496             case 't':
13497               /* Byte swap code halfwords.  */
13498               while (ptr + 1 < end)
13499                 {
13500                   tmp = contents[ptr];
13501                   contents[ptr] = contents[ptr + 1];
13502                   contents[ptr + 1] = tmp;
13503                   ptr += 2;
13504                 }
13505               break;
13506
13507             case 'd':
13508               /* Leave data alone.  */
13509               break;
13510             }
13511           ptr = end;
13512         }
13513     }
13514
13515   free (map);
13516   arm_data->mapcount = 0;
13517   arm_data->mapsize = 0;
13518   arm_data->map = NULL;
13519   unrecord_section_with_arm_elf_section_data (sec);
13520
13521   return FALSE;
13522 }
13523
13524 static void
13525 unrecord_section_via_map_over_sections (bfd * abfd ATTRIBUTE_UNUSED,
13526                                         asection * sec,
13527                                         void * ignore ATTRIBUTE_UNUSED)
13528 {
13529   unrecord_section_with_arm_elf_section_data (sec);
13530 }
13531
13532 static bfd_boolean
13533 elf32_arm_close_and_cleanup (bfd * abfd)
13534 {
13535   if (abfd->sections)
13536     bfd_map_over_sections (abfd,
13537                            unrecord_section_via_map_over_sections,
13538                            NULL);
13539
13540   return _bfd_elf_close_and_cleanup (abfd);
13541 }
13542
13543 static bfd_boolean
13544 elf32_arm_bfd_free_cached_info (bfd * abfd)
13545 {
13546   if (abfd->sections)
13547     bfd_map_over_sections (abfd,
13548                            unrecord_section_via_map_over_sections,
13549                            NULL);
13550
13551   return _bfd_free_cached_info (abfd);
13552 }
13553
13554 /* Display STT_ARM_TFUNC symbols as functions.  */
13555
13556 static void
13557 elf32_arm_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED,
13558                              asymbol *asym)
13559 {
13560   elf_symbol_type *elfsym = (elf_symbol_type *) asym;
13561
13562   if (ELF_ST_TYPE (elfsym->internal_elf_sym.st_info) == STT_ARM_TFUNC)
13563     elfsym->symbol.flags |= BSF_FUNCTION;
13564 }
13565
13566
13567 /* Mangle thumb function symbols as we read them in.  */
13568
13569 static bfd_boolean
13570 elf32_arm_swap_symbol_in (bfd * abfd,
13571                           const void *psrc,
13572                           const void *pshn,
13573                           Elf_Internal_Sym *dst)
13574 {
13575   if (!bfd_elf32_swap_symbol_in (abfd, psrc, pshn, dst))
13576     return FALSE;
13577
13578   /* New EABI objects mark thumb function symbols by setting the low bit of
13579      the address.  Turn these into STT_ARM_TFUNC.  */
13580   if ((ELF_ST_TYPE (dst->st_info) == STT_FUNC)
13581       && (dst->st_value & 1))
13582     {
13583       dst->st_info = ELF_ST_INFO (ELF_ST_BIND (dst->st_info), STT_ARM_TFUNC);
13584       dst->st_value &= ~(bfd_vma) 1;
13585     }
13586   return TRUE;
13587 }
13588
13589
13590 /* Mangle thumb function symbols as we write them out.  */
13591
13592 static void
13593 elf32_arm_swap_symbol_out (bfd *abfd,
13594                            const Elf_Internal_Sym *src,
13595                            void *cdst,
13596                            void *shndx)
13597 {
13598   Elf_Internal_Sym newsym;
13599
13600   /* We convert STT_ARM_TFUNC symbols into STT_FUNC with the low bit
13601      of the address set, as per the new EABI.  We do this unconditionally
13602      because objcopy does not set the elf header flags until after
13603      it writes out the symbol table.  */
13604   if (ELF_ST_TYPE (src->st_info) == STT_ARM_TFUNC)
13605     {
13606       newsym = *src;
13607       newsym.st_info = ELF_ST_INFO (ELF_ST_BIND (src->st_info), STT_FUNC);
13608       if (newsym.st_shndx != SHN_UNDEF)
13609         {
13610           /* Do this only for defined symbols. At link type, the static
13611              linker will simulate the work of dynamic linker of resolving
13612              symbols and will carry over the thumbness of found symbols to
13613              the output symbol table. It's not clear how it happens, but
13614              the thumbness of undefined symbols can well be different at
13615              runtime, and writing '1' for them will be confusing for users
13616              and possibly for dynamic linker itself.
13617           */
13618           newsym.st_value |= 1;
13619         }
13620
13621       src = &newsym;
13622     }
13623   bfd_elf32_swap_symbol_out (abfd, src, cdst, shndx);
13624 }
13625
13626 /* Add the PT_ARM_EXIDX program header.  */
13627
13628 static bfd_boolean
13629 elf32_arm_modify_segment_map (bfd *abfd,
13630                               struct bfd_link_info *info ATTRIBUTE_UNUSED)
13631 {
13632   struct elf_segment_map *m;
13633   asection *sec;
13634
13635   sec = bfd_get_section_by_name (abfd, ".ARM.exidx");
13636   if (sec != NULL && (sec->flags & SEC_LOAD) != 0)
13637     {
13638       /* If there is already a PT_ARM_EXIDX header, then we do not
13639          want to add another one.  This situation arises when running
13640          "strip"; the input binary already has the header.  */
13641       m = elf_tdata (abfd)->segment_map;
13642       while (m && m->p_type != PT_ARM_EXIDX)
13643         m = m->next;
13644       if (!m)
13645         {
13646           m = (struct elf_segment_map *)
13647               bfd_zalloc (abfd, sizeof (struct elf_segment_map));
13648           if (m == NULL)
13649             return FALSE;
13650           m->p_type = PT_ARM_EXIDX;
13651           m->count = 1;
13652           m->sections[0] = sec;
13653
13654           m->next = elf_tdata (abfd)->segment_map;
13655           elf_tdata (abfd)->segment_map = m;
13656         }
13657     }
13658
13659   return TRUE;
13660 }
13661
13662 /* We may add a PT_ARM_EXIDX program header.  */
13663
13664 static int
13665 elf32_arm_additional_program_headers (bfd *abfd,
13666                                       struct bfd_link_info *info ATTRIBUTE_UNUSED)
13667 {
13668   asection *sec;
13669
13670   sec = bfd_get_section_by_name (abfd, ".ARM.exidx");
13671   if (sec != NULL && (sec->flags & SEC_LOAD) != 0)
13672     return 1;
13673   else
13674     return 0;
13675 }
13676
13677 /* We have two function types: STT_FUNC and STT_ARM_TFUNC.  */
13678
13679 static bfd_boolean
13680 elf32_arm_is_function_type (unsigned int type)
13681 {
13682   return (type == STT_FUNC) || (type == STT_ARM_TFUNC);
13683 }
13684
13685 /* We use this to override swap_symbol_in and swap_symbol_out.  */
13686 const struct elf_size_info elf32_arm_size_info =
13687 {
13688   sizeof (Elf32_External_Ehdr),
13689   sizeof (Elf32_External_Phdr),
13690   sizeof (Elf32_External_Shdr),
13691   sizeof (Elf32_External_Rel),
13692   sizeof (Elf32_External_Rela),
13693   sizeof (Elf32_External_Sym),
13694   sizeof (Elf32_External_Dyn),
13695   sizeof (Elf_External_Note),
13696   4,
13697   1,
13698   32, 2,
13699   ELFCLASS32, EV_CURRENT,
13700   bfd_elf32_write_out_phdrs,
13701   bfd_elf32_write_shdrs_and_ehdr,
13702   bfd_elf32_checksum_contents,
13703   bfd_elf32_write_relocs,
13704   elf32_arm_swap_symbol_in,
13705   elf32_arm_swap_symbol_out,
13706   bfd_elf32_slurp_reloc_table,
13707   bfd_elf32_slurp_symbol_table,
13708   bfd_elf32_swap_dyn_in,
13709   bfd_elf32_swap_dyn_out,
13710   bfd_elf32_swap_reloc_in,
13711   bfd_elf32_swap_reloc_out,
13712   bfd_elf32_swap_reloca_in,
13713   bfd_elf32_swap_reloca_out
13714 };
13715
13716 #define ELF_ARCH                        bfd_arch_arm
13717 #define ELF_MACHINE_CODE                EM_ARM
13718 #ifdef __QNXTARGET__
13719 #define ELF_MAXPAGESIZE                 0x1000
13720 #else
13721 #define ELF_MAXPAGESIZE                 0x8000
13722 #endif
13723 #define ELF_MINPAGESIZE                 0x1000
13724 #define ELF_COMMONPAGESIZE              0x1000
13725
13726 #define bfd_elf32_mkobject                      elf32_arm_mkobject
13727
13728 #define bfd_elf32_bfd_copy_private_bfd_data     elf32_arm_copy_private_bfd_data
13729 #define bfd_elf32_bfd_merge_private_bfd_data    elf32_arm_merge_private_bfd_data
13730 #define bfd_elf32_bfd_set_private_flags         elf32_arm_set_private_flags
13731 #define bfd_elf32_bfd_print_private_bfd_data    elf32_arm_print_private_bfd_data
13732 #define bfd_elf32_bfd_link_hash_table_create    elf32_arm_link_hash_table_create
13733 #define bfd_elf32_bfd_link_hash_table_free      elf32_arm_hash_table_free
13734 #define bfd_elf32_bfd_reloc_type_lookup         elf32_arm_reloc_type_lookup
13735 #define bfd_elf32_bfd_reloc_name_lookup elf32_arm_reloc_name_lookup
13736 #define bfd_elf32_find_nearest_line             elf32_arm_find_nearest_line
13737 #define bfd_elf32_find_inliner_info             elf32_arm_find_inliner_info
13738 #define bfd_elf32_new_section_hook              elf32_arm_new_section_hook
13739 #define bfd_elf32_bfd_is_target_special_symbol  elf32_arm_is_target_special_symbol
13740 #define bfd_elf32_close_and_cleanup             elf32_arm_close_and_cleanup
13741 #define bfd_elf32_bfd_free_cached_info          elf32_arm_bfd_free_cached_info
13742 #define bfd_elf32_bfd_final_link                elf32_arm_final_link
13743
13744 #define elf_backend_get_symbol_type             elf32_arm_get_symbol_type
13745 #define elf_backend_gc_mark_hook                elf32_arm_gc_mark_hook
13746 #define elf_backend_gc_mark_extra_sections      elf32_arm_gc_mark_extra_sections
13747 #define elf_backend_gc_sweep_hook               elf32_arm_gc_sweep_hook
13748 #define elf_backend_check_relocs                elf32_arm_check_relocs
13749 #define elf_backend_relocate_section            elf32_arm_relocate_section
13750 #define elf_backend_write_section               elf32_arm_write_section
13751 #define elf_backend_adjust_dynamic_symbol       elf32_arm_adjust_dynamic_symbol
13752 #define elf_backend_create_dynamic_sections     elf32_arm_create_dynamic_sections
13753 #define elf_backend_finish_dynamic_symbol       elf32_arm_finish_dynamic_symbol
13754 #define elf_backend_finish_dynamic_sections     elf32_arm_finish_dynamic_sections
13755 #define elf_backend_size_dynamic_sections       elf32_arm_size_dynamic_sections
13756 #define elf_backend_init_index_section          _bfd_elf_init_2_index_sections
13757 #define elf_backend_post_process_headers        elf32_arm_post_process_headers
13758 #define elf_backend_reloc_type_class            elf32_arm_reloc_type_class
13759 #define elf_backend_object_p                    elf32_arm_object_p
13760 #define elf_backend_section_flags               elf32_arm_section_flags
13761 #define elf_backend_fake_sections               elf32_arm_fake_sections
13762 #define elf_backend_section_from_shdr           elf32_arm_section_from_shdr
13763 #define elf_backend_final_write_processing      elf32_arm_final_write_processing
13764 #define elf_backend_copy_indirect_symbol        elf32_arm_copy_indirect_symbol
13765 #define elf_backend_symbol_processing           elf32_arm_symbol_processing
13766 #define elf_backend_size_info                   elf32_arm_size_info
13767 #define elf_backend_modify_segment_map          elf32_arm_modify_segment_map
13768 #define elf_backend_additional_program_headers  elf32_arm_additional_program_headers
13769 #define elf_backend_output_arch_local_syms      elf32_arm_output_arch_local_syms
13770 #define elf_backend_begin_write_processing      elf32_arm_begin_write_processing
13771 #define elf_backend_is_function_type            elf32_arm_is_function_type
13772
13773 #define elf_backend_can_refcount       1
13774 #define elf_backend_can_gc_sections    1
13775 #define elf_backend_plt_readonly       1
13776 #define elf_backend_want_got_plt       1
13777 #define elf_backend_want_plt_sym       0
13778 #define elf_backend_may_use_rel_p      1
13779 #define elf_backend_may_use_rela_p     0
13780 #define elf_backend_default_use_rela_p 0
13781
13782 #define elf_backend_got_header_size     12
13783
13784 #undef  elf_backend_obj_attrs_vendor
13785 #define elf_backend_obj_attrs_vendor            "aeabi"
13786 #undef  elf_backend_obj_attrs_section
13787 #define elf_backend_obj_attrs_section           ".ARM.attributes"
13788 #undef  elf_backend_obj_attrs_arg_type
13789 #define elf_backend_obj_attrs_arg_type          elf32_arm_obj_attrs_arg_type
13790 #undef  elf_backend_obj_attrs_section_type
13791 #define elf_backend_obj_attrs_section_type      SHT_ARM_ATTRIBUTES
13792 #define elf_backend_obj_attrs_order     elf32_arm_obj_attrs_order
13793
13794 #include "elf32-target.h"
13795
13796 /* VxWorks Targets.  */
13797
13798 #undef  TARGET_LITTLE_SYM
13799 #define TARGET_LITTLE_SYM               bfd_elf32_littlearm_vxworks_vec
13800 #undef  TARGET_LITTLE_NAME
13801 #define TARGET_LITTLE_NAME              "elf32-littlearm-vxworks"
13802 #undef  TARGET_BIG_SYM
13803 #define TARGET_BIG_SYM                  bfd_elf32_bigarm_vxworks_vec
13804 #undef  TARGET_BIG_NAME
13805 #define TARGET_BIG_NAME                 "elf32-bigarm-vxworks"
13806
13807 /* Like elf32_arm_link_hash_table_create -- but overrides
13808    appropriately for VxWorks.  */
13809
13810 static struct bfd_link_hash_table *
13811 elf32_arm_vxworks_link_hash_table_create (bfd *abfd)
13812 {
13813   struct bfd_link_hash_table *ret;
13814
13815   ret = elf32_arm_link_hash_table_create (abfd);
13816   if (ret)
13817     {
13818       struct elf32_arm_link_hash_table *htab
13819         = (struct elf32_arm_link_hash_table *) ret;
13820       htab->use_rel = 0;
13821       htab->vxworks_p = 1;
13822     }
13823   return ret;
13824 }
13825
13826 static void
13827 elf32_arm_vxworks_final_write_processing (bfd *abfd, bfd_boolean linker)
13828 {
13829   elf32_arm_final_write_processing (abfd, linker);
13830   elf_vxworks_final_write_processing (abfd, linker);
13831 }
13832
13833 #undef  elf32_bed
13834 #define elf32_bed elf32_arm_vxworks_bed
13835
13836 #undef  bfd_elf32_bfd_link_hash_table_create
13837 #define bfd_elf32_bfd_link_hash_table_create    elf32_arm_vxworks_link_hash_table_create
13838 #undef  elf_backend_add_symbol_hook
13839 #define elf_backend_add_symbol_hook             elf_vxworks_add_symbol_hook
13840 #undef  elf_backend_final_write_processing
13841 #define elf_backend_final_write_processing      elf32_arm_vxworks_final_write_processing
13842 #undef  elf_backend_emit_relocs
13843 #define elf_backend_emit_relocs                 elf_vxworks_emit_relocs
13844
13845 #undef  elf_backend_may_use_rel_p
13846 #define elf_backend_may_use_rel_p       0
13847 #undef  elf_backend_may_use_rela_p
13848 #define elf_backend_may_use_rela_p      1
13849 #undef  elf_backend_default_use_rela_p
13850 #define elf_backend_default_use_rela_p  1
13851 #undef  elf_backend_want_plt_sym
13852 #define elf_backend_want_plt_sym        1
13853 #undef  ELF_MAXPAGESIZE
13854 #define ELF_MAXPAGESIZE                 0x1000
13855
13856 #include "elf32-target.h"
13857
13858
13859 /* Merge backend specific data from an object file to the output
13860    object file when linking.  */
13861
13862 static bfd_boolean
13863 elf32_arm_merge_private_bfd_data (bfd * ibfd, bfd * obfd)
13864 {
13865   flagword out_flags;
13866   flagword in_flags;
13867   bfd_boolean flags_compatible = TRUE;
13868   asection *sec;
13869
13870   /* Check if we have the same endianess.  */
13871   if (! _bfd_generic_verify_endian_match (ibfd, obfd))
13872     return FALSE;
13873
13874   if (! is_arm_elf (ibfd) || ! is_arm_elf (obfd))
13875     return TRUE;
13876
13877   if (!elf32_arm_merge_eabi_attributes (ibfd, obfd))
13878     return FALSE;
13879
13880   /* The input BFD must have had its flags initialised.  */
13881   /* The following seems bogus to me -- The flags are initialized in
13882      the assembler but I don't think an elf_flags_init field is
13883      written into the object.  */
13884   /* BFD_ASSERT (elf_flags_init (ibfd)); */
13885
13886   in_flags  = elf_elfheader (ibfd)->e_flags;
13887   out_flags = elf_elfheader (obfd)->e_flags;
13888
13889   /* In theory there is no reason why we couldn't handle this.  However
13890      in practice it isn't even close to working and there is no real
13891      reason to want it.  */
13892   if (EF_ARM_EABI_VERSION (in_flags) >= EF_ARM_EABI_VER4
13893       && !(ibfd->flags & DYNAMIC)
13894       && (in_flags & EF_ARM_BE8))
13895     {
13896       _bfd_error_handler (_("error: %B is already in final BE8 format"),
13897                           ibfd);
13898       return FALSE;
13899     }
13900
13901   if (!elf_flags_init (obfd))
13902     {
13903       /* If the input is the default architecture and had the default
13904          flags then do not bother setting the flags for the output
13905          architecture, instead allow future merges to do this.  If no
13906          future merges ever set these flags then they will retain their
13907          uninitialised values, which surprise surprise, correspond
13908          to the default values.  */
13909       if (bfd_get_arch_info (ibfd)->the_default
13910           && elf_elfheader (ibfd)->e_flags == 0)
13911         return TRUE;
13912
13913       elf_flags_init (obfd) = TRUE;
13914       elf_elfheader (obfd)->e_flags = in_flags;
13915
13916       if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
13917           && bfd_get_arch_info (obfd)->the_default)
13918         return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
13919
13920       return TRUE;
13921     }
13922
13923   /* Determine what should happen if the input ARM architecture
13924      does not match the output ARM architecture.  */
13925   if (! bfd_arm_merge_machines (ibfd, obfd))
13926     return FALSE;
13927
13928   /* Identical flags must be compatible.  */
13929   if (in_flags == out_flags)
13930     return TRUE;
13931
13932   /* Check to see if the input BFD actually contains any sections.  If
13933      not, its flags may not have been initialised either, but it
13934      cannot actually cause any incompatiblity.  Do not short-circuit
13935      dynamic objects; their section list may be emptied by
13936     elf_link_add_object_symbols.
13937
13938     Also check to see if there are no code sections in the input.
13939     In this case there is no need to check for code specific flags.
13940     XXX - do we need to worry about floating-point format compatability
13941     in data sections ?  */
13942   if (!(ibfd->flags & DYNAMIC))
13943     {
13944       bfd_boolean null_input_bfd = TRUE;
13945       bfd_boolean only_data_sections = TRUE;
13946
13947       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
13948         {
13949           /* Ignore synthetic glue sections.  */
13950           if (strcmp (sec->name, ".glue_7")
13951               && strcmp (sec->name, ".glue_7t"))
13952             {
13953               if ((bfd_get_section_flags (ibfd, sec)
13954                    & (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS))
13955                   == (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS))
13956                 only_data_sections = FALSE;
13957
13958               null_input_bfd = FALSE;
13959               break;
13960             }
13961         }
13962
13963       if (null_input_bfd || only_data_sections)
13964         return TRUE;
13965     }
13966
13967   /* Complain about various flag mismatches.  */
13968   if (!elf32_arm_versions_compatible (EF_ARM_EABI_VERSION (in_flags),
13969                                       EF_ARM_EABI_VERSION (out_flags)))
13970     {
13971       _bfd_error_handler
13972         (_("error: Source object %B has EABI version %d, but target %B has EABI version %d"),
13973          ibfd, obfd,
13974          (in_flags & EF_ARM_EABIMASK) >> 24,
13975          (out_flags & EF_ARM_EABIMASK) >> 24);
13976       return FALSE;
13977     }
13978
13979   /* Not sure what needs to be checked for EABI versions >= 1.  */
13980   /* VxWorks libraries do not use these flags.  */
13981   if (get_elf_backend_data (obfd) != &elf32_arm_vxworks_bed
13982       && get_elf_backend_data (ibfd) != &elf32_arm_vxworks_bed
13983       && EF_ARM_EABI_VERSION (in_flags) == EF_ARM_EABI_UNKNOWN)
13984     {
13985       if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
13986         {
13987           _bfd_error_handler
13988             (_("error: %B is compiled for APCS-%d, whereas target %B uses APCS-%d"),
13989              ibfd, obfd,
13990              in_flags & EF_ARM_APCS_26 ? 26 : 32,
13991              out_flags & EF_ARM_APCS_26 ? 26 : 32);
13992           flags_compatible = FALSE;
13993         }
13994
13995       if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
13996         {
13997           if (in_flags & EF_ARM_APCS_FLOAT)
13998             _bfd_error_handler
13999               (_("error: %B passes floats in float registers, whereas %B passes them in integer registers"),
14000                ibfd, obfd);
14001           else
14002             _bfd_error_handler
14003               (_("error: %B passes floats in integer registers, whereas %B passes them in float registers"),
14004                ibfd, obfd);
14005
14006           flags_compatible = FALSE;
14007         }
14008
14009       if ((in_flags & EF_ARM_VFP_FLOAT) != (out_flags & EF_ARM_VFP_FLOAT))
14010         {
14011           if (in_flags & EF_ARM_VFP_FLOAT)
14012             _bfd_error_handler
14013               (_("error: %B uses VFP instructions, whereas %B does not"),
14014                ibfd, obfd);
14015           else
14016             _bfd_error_handler
14017               (_("error: %B uses FPA instructions, whereas %B does not"),
14018                ibfd, obfd);
14019
14020           flags_compatible = FALSE;
14021         }
14022
14023       if ((in_flags & EF_ARM_MAVERICK_FLOAT) != (out_flags & EF_ARM_MAVERICK_FLOAT))
14024         {
14025           if (in_flags & EF_ARM_MAVERICK_FLOAT)
14026             _bfd_error_handler
14027               (_("error: %B uses Maverick instructions, whereas %B does not"),
14028                ibfd, obfd);
14029           else
14030             _bfd_error_handler
14031               (_("error: %B does not use Maverick instructions, whereas %B does"),
14032                ibfd, obfd);
14033
14034           flags_compatible = FALSE;
14035         }
14036
14037 #ifdef EF_ARM_SOFT_FLOAT
14038       if ((in_flags & EF_ARM_SOFT_FLOAT) != (out_flags & EF_ARM_SOFT_FLOAT))
14039         {
14040           /* We can allow interworking between code that is VFP format
14041              layout, and uses either soft float or integer regs for
14042              passing floating point arguments and results.  We already
14043              know that the APCS_FLOAT flags match; similarly for VFP
14044              flags.  */
14045           if ((in_flags & EF_ARM_APCS_FLOAT) != 0
14046               || (in_flags & EF_ARM_VFP_FLOAT) == 0)
14047             {
14048               if (in_flags & EF_ARM_SOFT_FLOAT)
14049                 _bfd_error_handler
14050                   (_("error: %B uses software FP, whereas %B uses hardware FP"),
14051                    ibfd, obfd);
14052               else
14053                 _bfd_error_handler
14054                   (_("error: %B uses hardware FP, whereas %B uses software FP"),
14055                    ibfd, obfd);
14056
14057               flags_compatible = FALSE;
14058             }
14059         }
14060 #endif
14061
14062       /* Interworking mismatch is only a warning.  */
14063       if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
14064         {
14065           if (in_flags & EF_ARM_INTERWORK)
14066             {
14067               _bfd_error_handler
14068                 (_("Warning: %B supports interworking, whereas %B does not"),
14069                  ibfd, obfd);
14070             }
14071           else
14072             {
14073               _bfd_error_handler
14074                 (_("Warning: %B does not support interworking, whereas %B does"),
14075                  ibfd, obfd);
14076             }
14077         }
14078     }
14079
14080   return flags_compatible;
14081 }
14082
14083
14084 /* Symbian OS Targets.  */
14085
14086 #undef  TARGET_LITTLE_SYM
14087 #define TARGET_LITTLE_SYM               bfd_elf32_littlearm_symbian_vec
14088 #undef  TARGET_LITTLE_NAME
14089 #define TARGET_LITTLE_NAME              "elf32-littlearm-symbian"
14090 #undef  TARGET_BIG_SYM
14091 #define TARGET_BIG_SYM                  bfd_elf32_bigarm_symbian_vec
14092 #undef  TARGET_BIG_NAME
14093 #define TARGET_BIG_NAME                 "elf32-bigarm-symbian"
14094
14095 /* Like elf32_arm_link_hash_table_create -- but overrides
14096    appropriately for Symbian OS.  */
14097
14098 static struct bfd_link_hash_table *
14099 elf32_arm_symbian_link_hash_table_create (bfd *abfd)
14100 {
14101   struct bfd_link_hash_table *ret;
14102
14103   ret = elf32_arm_link_hash_table_create (abfd);
14104   if (ret)
14105     {
14106       struct elf32_arm_link_hash_table *htab
14107         = (struct elf32_arm_link_hash_table *)ret;
14108       /* There is no PLT header for Symbian OS.  */
14109       htab->plt_header_size = 0;
14110       /* The PLT entries are each one instruction and one word.  */
14111       htab->plt_entry_size = 4 * ARRAY_SIZE (elf32_arm_symbian_plt_entry);
14112       htab->symbian_p = 1;
14113       /* Symbian uses armv5t or above, so use_blx is always true.  */
14114       htab->use_blx = 1;
14115       htab->root.is_relocatable_executable = 1;
14116     }
14117   return ret;
14118 }
14119
14120 static const struct bfd_elf_special_section
14121 elf32_arm_symbian_special_sections[] =
14122 {
14123   /* In a BPABI executable, the dynamic linking sections do not go in
14124      the loadable read-only segment.  The post-linker may wish to
14125      refer to these sections, but they are not part of the final
14126      program image.  */
14127   { STRING_COMMA_LEN (".dynamic"),       0, SHT_DYNAMIC,  0 },
14128   { STRING_COMMA_LEN (".dynstr"),        0, SHT_STRTAB,   0 },
14129   { STRING_COMMA_LEN (".dynsym"),        0, SHT_DYNSYM,   0 },
14130   { STRING_COMMA_LEN (".got"),           0, SHT_PROGBITS, 0 },
14131   { STRING_COMMA_LEN (".hash"),          0, SHT_HASH,     0 },
14132   /* These sections do not need to be writable as the SymbianOS
14133      postlinker will arrange things so that no dynamic relocation is
14134      required.  */
14135   { STRING_COMMA_LEN (".init_array"),    0, SHT_INIT_ARRAY,    SHF_ALLOC },
14136   { STRING_COMMA_LEN (".fini_array"),    0, SHT_FINI_ARRAY,    SHF_ALLOC },
14137   { STRING_COMMA_LEN (".preinit_array"), 0, SHT_PREINIT_ARRAY, SHF_ALLOC },
14138   { NULL,                             0, 0, 0,                 0 }
14139 };
14140
14141 static void
14142 elf32_arm_symbian_begin_write_processing (bfd *abfd,
14143                                           struct bfd_link_info *link_info)
14144 {
14145   /* BPABI objects are never loaded directly by an OS kernel; they are
14146      processed by a postlinker first, into an OS-specific format.  If
14147      the D_PAGED bit is set on the file, BFD will align segments on
14148      page boundaries, so that an OS can directly map the file.  With
14149      BPABI objects, that just results in wasted space.  In addition,
14150      because we clear the D_PAGED bit, map_sections_to_segments will
14151      recognize that the program headers should not be mapped into any
14152      loadable segment.  */
14153   abfd->flags &= ~D_PAGED;
14154   elf32_arm_begin_write_processing (abfd, link_info);
14155 }
14156
14157 static bfd_boolean
14158 elf32_arm_symbian_modify_segment_map (bfd *abfd,
14159                                       struct bfd_link_info *info)
14160 {
14161   struct elf_segment_map *m;
14162   asection *dynsec;
14163
14164   /* BPABI shared libraries and executables should have a PT_DYNAMIC
14165      segment.  However, because the .dynamic section is not marked
14166      with SEC_LOAD, the generic ELF code will not create such a
14167      segment.  */
14168   dynsec = bfd_get_section_by_name (abfd, ".dynamic");
14169   if (dynsec)
14170     {
14171       for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
14172         if (m->p_type == PT_DYNAMIC)
14173           break;
14174
14175       if (m == NULL)
14176         {
14177           m = _bfd_elf_make_dynamic_segment (abfd, dynsec);
14178           m->next = elf_tdata (abfd)->segment_map;
14179           elf_tdata (abfd)->segment_map = m;
14180         }
14181     }
14182
14183   /* Also call the generic arm routine.  */
14184   return elf32_arm_modify_segment_map (abfd, info);
14185 }
14186
14187 /* Return address for Ith PLT stub in section PLT, for relocation REL
14188    or (bfd_vma) -1 if it should not be included.  */
14189
14190 static bfd_vma
14191 elf32_arm_symbian_plt_sym_val (bfd_vma i, const asection *plt,
14192                                const arelent *rel ATTRIBUTE_UNUSED)
14193 {
14194   return plt->vma + 4 * ARRAY_SIZE (elf32_arm_symbian_plt_entry) * i;
14195 }
14196
14197
14198 #undef  elf32_bed
14199 #define elf32_bed elf32_arm_symbian_bed
14200
14201 /* The dynamic sections are not allocated on SymbianOS; the postlinker
14202    will process them and then discard them.  */
14203 #undef  ELF_DYNAMIC_SEC_FLAGS
14204 #define ELF_DYNAMIC_SEC_FLAGS \
14205   (SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED)
14206
14207 #undef elf_backend_add_symbol_hook
14208 #undef elf_backend_emit_relocs
14209
14210 #undef  bfd_elf32_bfd_link_hash_table_create
14211 #define bfd_elf32_bfd_link_hash_table_create    elf32_arm_symbian_link_hash_table_create
14212 #undef  elf_backend_special_sections
14213 #define elf_backend_special_sections            elf32_arm_symbian_special_sections
14214 #undef  elf_backend_begin_write_processing
14215 #define elf_backend_begin_write_processing      elf32_arm_symbian_begin_write_processing
14216 #undef  elf_backend_final_write_processing
14217 #define elf_backend_final_write_processing      elf32_arm_final_write_processing
14218
14219 #undef  elf_backend_modify_segment_map
14220 #define elf_backend_modify_segment_map elf32_arm_symbian_modify_segment_map
14221
14222 /* There is no .got section for BPABI objects, and hence no header.  */
14223 #undef  elf_backend_got_header_size
14224 #define elf_backend_got_header_size 0
14225
14226 /* Similarly, there is no .got.plt section.  */
14227 #undef  elf_backend_want_got_plt
14228 #define elf_backend_want_got_plt 0
14229
14230 #undef  elf_backend_plt_sym_val
14231 #define elf_backend_plt_sym_val         elf32_arm_symbian_plt_sym_val
14232
14233 #undef  elf_backend_may_use_rel_p
14234 #define elf_backend_may_use_rel_p       1
14235 #undef  elf_backend_may_use_rela_p
14236 #define elf_backend_may_use_rela_p      0
14237 #undef  elf_backend_default_use_rela_p
14238 #define elf_backend_default_use_rela_p  0
14239 #undef  elf_backend_want_plt_sym
14240 #define elf_backend_want_plt_sym        0
14241 #undef  ELF_MAXPAGESIZE
14242 #define ELF_MAXPAGESIZE                 0x8000
14243
14244 #include "elf32-target.h"