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, 2010, 2011  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          24,                    /* 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          0x07ff2fff,            /* src_mask */
 233          0x07ff2fff,            /* 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_TLS_DESC,        /* type */
 265          0,                     /* rightshift */
 266          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 267          32,                    /* bitsize */
 268          FALSE,                 /* pc_relative */
 269          0,                     /* bitpos */
 270          complain_overflow_bitfield,/* complain_on_overflow */
 271          bfd_elf_generic_reloc, /* special_function */
 272          "R_ARM_TLS_DESC",      /* name */
 273          FALSE,                 /* partial_inplace */
 274          0xffffffff,            /* src_mask */
 275          0xffffffff,            /* 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          24,                    /* 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          24,                    /* 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          0x07ff2fff,            /* src_mask */
 319          0x07ff2fff,            /* 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   HOWTO (R_ARM_TLS_GOTDESC,     /* type */
1356          0,                     /* rightshift */
1357          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1358          32,                    /* bitsize */
1359          FALSE,                 /* pc_relative */
1360          0,                     /* bitpos */
1361          complain_overflow_bitfield,/* complain_on_overflow */
1362          NULL,                  /* special_function */
1363          "R_ARM_TLS_GOTDESC",   /* name */
1364          TRUE,                  /* partial_inplace */
1365          0xffffffff,            /* src_mask */
1366          0xffffffff,            /* dst_mask */
1367          FALSE),                /* pcrel_offset */
1368
1369   HOWTO (R_ARM_TLS_CALL,        /* type */
1370          0,                     /* rightshift */
1371          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1372          24,                    /* bitsize */
1373          FALSE,                 /* pc_relative */
1374          0,                     /* bitpos */
1375          complain_overflow_dont,/* complain_on_overflow */
1376          bfd_elf_generic_reloc, /* special_function */
1377          "R_ARM_TLS_CALL",      /* name */
1378          FALSE,                 /* partial_inplace */
1379          0x00ffffff,            /* src_mask */
1380          0x00ffffff,            /* dst_mask */
1381          FALSE),                /* pcrel_offset */
1382
1383   HOWTO (R_ARM_TLS_DESCSEQ,     /* type */
1384          0,                     /* rightshift */
1385          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1386          0,                     /* bitsize */
1387          FALSE,                 /* pc_relative */
1388          0,                     /* bitpos */
1389          complain_overflow_bitfield,/* complain_on_overflow */
1390          bfd_elf_generic_reloc, /* special_function */
1391          "R_ARM_TLS_DESCSEQ",   /* name */
1392          FALSE,                 /* partial_inplace */
1393          0x00000000,            /* src_mask */
1394          0x00000000,            /* dst_mask */
1395          FALSE),                /* pcrel_offset */
1396
1397   HOWTO (R_ARM_THM_TLS_CALL,    /* type */
1398          0,                     /* rightshift */
1399          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1400          24,                    /* bitsize */
1401          FALSE,                 /* pc_relative */
1402          0,                     /* bitpos */
1403          complain_overflow_dont,/* complain_on_overflow */
1404          bfd_elf_generic_reloc, /* special_function */
1405          "R_ARM_THM_TLS_CALL",  /* name */
1406          FALSE,                 /* partial_inplace */
1407          0x07ff07ff,            /* src_mask */
1408          0x07ff07ff,            /* dst_mask */
1409          FALSE),                /* pcrel_offset */
1410
1411   HOWTO (R_ARM_PLT32_ABS,       /* type */
1412          0,                     /* rightshift */
1413          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1414          32,                    /* bitsize */
1415          FALSE,                 /* pc_relative */
1416          0,                     /* bitpos */
1417          complain_overflow_dont,/* complain_on_overflow */
1418          bfd_elf_generic_reloc, /* special_function */
1419          "R_ARM_PLT32_ABS",     /* name */
1420          FALSE,                 /* partial_inplace */
1421          0xffffffff,            /* src_mask */
1422          0xffffffff,            /* dst_mask */
1423          FALSE),                /* pcrel_offset */
1424
1425   HOWTO (R_ARM_GOT_ABS,         /* type */
1426          0,                     /* rightshift */
1427          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1428          32,                    /* bitsize */
1429          FALSE,                 /* pc_relative */
1430          0,                     /* bitpos */
1431          complain_overflow_dont,/* complain_on_overflow */
1432          bfd_elf_generic_reloc, /* special_function */
1433          "R_ARM_GOT_ABS",       /* name */
1434          FALSE,                 /* partial_inplace */
1435          0xffffffff,            /* src_mask */
1436          0xffffffff,            /* dst_mask */
1437          FALSE),                        /* pcrel_offset */
1438
1439   HOWTO (R_ARM_GOT_PREL,        /* type */
1440          0,                     /* rightshift */
1441          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1442          32,                    /* bitsize */
1443          TRUE,                  /* pc_relative */
1444          0,                     /* bitpos */
1445          complain_overflow_dont,        /* complain_on_overflow */
1446          bfd_elf_generic_reloc, /* special_function */
1447          "R_ARM_GOT_PREL",      /* name */
1448          FALSE,                 /* partial_inplace */
1449          0xffffffff,            /* src_mask */
1450          0xffffffff,            /* dst_mask */
1451          TRUE),                 /* pcrel_offset */
1452
1453   HOWTO (R_ARM_GOT_BREL12,      /* type */
1454          0,                     /* rightshift */
1455          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1456          12,                    /* bitsize */
1457          FALSE,                 /* pc_relative */
1458          0,                     /* bitpos */
1459          complain_overflow_bitfield,/* complain_on_overflow */
1460          bfd_elf_generic_reloc, /* special_function */
1461          "R_ARM_GOT_BREL12",    /* name */
1462          FALSE,                 /* partial_inplace */
1463          0x00000fff,            /* src_mask */
1464          0x00000fff,            /* dst_mask */
1465          FALSE),                /* pcrel_offset */
1466
1467   HOWTO (R_ARM_GOTOFF12,        /* type */
1468          0,                     /* rightshift */
1469          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1470          12,                    /* bitsize */
1471          FALSE,                 /* pc_relative */
1472          0,                     /* bitpos */
1473          complain_overflow_bitfield,/* complain_on_overflow */
1474          bfd_elf_generic_reloc, /* special_function */
1475          "R_ARM_GOTOFF12",      /* name */
1476          FALSE,                 /* partial_inplace */
1477          0x00000fff,            /* src_mask */
1478          0x00000fff,            /* dst_mask */
1479          FALSE),                /* pcrel_offset */
1480
1481   EMPTY_HOWTO (R_ARM_GOTRELAX),  /* reserved for future GOT-load optimizations */
1482
1483   /* GNU extension to record C++ vtable member usage */
1484   HOWTO (R_ARM_GNU_VTENTRY,     /* type */
1485          0,                     /* rightshift */
1486          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1487          0,                     /* bitsize */
1488          FALSE,                 /* pc_relative */
1489          0,                     /* bitpos */
1490          complain_overflow_dont, /* complain_on_overflow */
1491          _bfd_elf_rel_vtable_reloc_fn,  /* special_function */
1492          "R_ARM_GNU_VTENTRY",   /* name */
1493          FALSE,                 /* partial_inplace */
1494          0,                     /* src_mask */
1495          0,                     /* dst_mask */
1496          FALSE),                /* pcrel_offset */
1497
1498   /* GNU extension to record C++ vtable hierarchy */
1499   HOWTO (R_ARM_GNU_VTINHERIT, /* type */
1500          0,                     /* rightshift */
1501          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1502          0,                     /* bitsize */
1503          FALSE,                 /* pc_relative */
1504          0,                     /* bitpos */
1505          complain_overflow_dont, /* complain_on_overflow */
1506          NULL,                  /* special_function */
1507          "R_ARM_GNU_VTINHERIT", /* name */
1508          FALSE,                 /* partial_inplace */
1509          0,                     /* src_mask */
1510          0,                     /* dst_mask */
1511          FALSE),                /* pcrel_offset */
1512
1513   HOWTO (R_ARM_THM_JUMP11,      /* type */
1514          1,                     /* rightshift */
1515          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1516          11,                    /* bitsize */
1517          TRUE,                  /* pc_relative */
1518          0,                     /* bitpos */
1519          complain_overflow_signed,      /* complain_on_overflow */
1520          bfd_elf_generic_reloc, /* special_function */
1521          "R_ARM_THM_JUMP11",    /* name */
1522          FALSE,                 /* partial_inplace */
1523          0x000007ff,            /* src_mask */
1524          0x000007ff,            /* dst_mask */
1525          TRUE),                 /* pcrel_offset */
1526
1527   HOWTO (R_ARM_THM_JUMP8,       /* type */
1528          1,                     /* rightshift */
1529          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1530          8,                     /* bitsize */
1531          TRUE,                  /* pc_relative */
1532          0,                     /* bitpos */
1533          complain_overflow_signed,      /* complain_on_overflow */
1534          bfd_elf_generic_reloc, /* special_function */
1535          "R_ARM_THM_JUMP8",     /* name */
1536          FALSE,                 /* partial_inplace */
1537          0x000000ff,            /* src_mask */
1538          0x000000ff,            /* dst_mask */
1539          TRUE),                 /* pcrel_offset */
1540
1541   /* TLS relocations */
1542   HOWTO (R_ARM_TLS_GD32,        /* type */
1543          0,                     /* rightshift */
1544          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1545          32,                    /* bitsize */
1546          FALSE,                 /* pc_relative */
1547          0,                     /* bitpos */
1548          complain_overflow_bitfield,/* complain_on_overflow */
1549          NULL,                  /* special_function */
1550          "R_ARM_TLS_GD32",      /* name */
1551          TRUE,                  /* partial_inplace */
1552          0xffffffff,            /* src_mask */
1553          0xffffffff,            /* dst_mask */
1554          FALSE),                /* pcrel_offset */
1555
1556   HOWTO (R_ARM_TLS_LDM32,       /* type */
1557          0,                     /* rightshift */
1558          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1559          32,                    /* bitsize */
1560          FALSE,                 /* pc_relative */
1561          0,                     /* bitpos */
1562          complain_overflow_bitfield,/* complain_on_overflow */
1563          bfd_elf_generic_reloc, /* special_function */
1564          "R_ARM_TLS_LDM32",     /* name */
1565          TRUE,                  /* partial_inplace */
1566          0xffffffff,            /* src_mask */
1567          0xffffffff,            /* dst_mask */
1568          FALSE),                /* pcrel_offset */
1569
1570   HOWTO (R_ARM_TLS_LDO32,       /* type */
1571          0,                     /* rightshift */
1572          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1573          32,                    /* bitsize */
1574          FALSE,                 /* pc_relative */
1575          0,                     /* bitpos */
1576          complain_overflow_bitfield,/* complain_on_overflow */
1577          bfd_elf_generic_reloc, /* special_function */
1578          "R_ARM_TLS_LDO32",     /* name */
1579          TRUE,                  /* partial_inplace */
1580          0xffffffff,            /* src_mask */
1581          0xffffffff,            /* dst_mask */
1582          FALSE),                /* pcrel_offset */
1583
1584   HOWTO (R_ARM_TLS_IE32,        /* type */
1585          0,                     /* rightshift */
1586          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1587          32,                    /* bitsize */
1588          FALSE,                  /* pc_relative */
1589          0,                     /* bitpos */
1590          complain_overflow_bitfield,/* complain_on_overflow */
1591          NULL,                  /* special_function */
1592          "R_ARM_TLS_IE32",      /* name */
1593          TRUE,                  /* partial_inplace */
1594          0xffffffff,            /* src_mask */
1595          0xffffffff,            /* dst_mask */
1596          FALSE),                /* pcrel_offset */
1597
1598   HOWTO (R_ARM_TLS_LE32,        /* type */
1599          0,                     /* rightshift */
1600          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1601          32,                    /* bitsize */
1602          FALSE,                 /* pc_relative */
1603          0,                     /* bitpos */
1604          complain_overflow_bitfield,/* complain_on_overflow */
1605          bfd_elf_generic_reloc, /* special_function */
1606          "R_ARM_TLS_LE32",      /* name */
1607          TRUE,                  /* partial_inplace */
1608          0xffffffff,            /* src_mask */
1609          0xffffffff,            /* dst_mask */
1610          FALSE),                /* pcrel_offset */
1611
1612   HOWTO (R_ARM_TLS_LDO12,       /* type */
1613          0,                     /* rightshift */
1614          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1615          12,                    /* bitsize */
1616          FALSE,                 /* pc_relative */
1617          0,                     /* bitpos */
1618          complain_overflow_bitfield,/* complain_on_overflow */
1619          bfd_elf_generic_reloc, /* special_function */
1620          "R_ARM_TLS_LDO12",     /* name */
1621          FALSE,                 /* partial_inplace */
1622          0x00000fff,            /* src_mask */
1623          0x00000fff,            /* dst_mask */
1624          FALSE),                /* pcrel_offset */
1625
1626   HOWTO (R_ARM_TLS_LE12,        /* type */
1627          0,                     /* rightshift */
1628          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1629          12,                    /* bitsize */
1630          FALSE,                 /* pc_relative */
1631          0,                     /* bitpos */
1632          complain_overflow_bitfield,/* complain_on_overflow */
1633          bfd_elf_generic_reloc, /* special_function */
1634          "R_ARM_TLS_LE12",      /* name */
1635          FALSE,                 /* partial_inplace */
1636          0x00000fff,            /* src_mask */
1637          0x00000fff,            /* dst_mask */
1638          FALSE),                /* pcrel_offset */
1639
1640   HOWTO (R_ARM_TLS_IE12GP,      /* type */
1641          0,                     /* rightshift */
1642          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1643          12,                    /* bitsize */
1644          FALSE,                 /* pc_relative */
1645          0,                     /* bitpos */
1646          complain_overflow_bitfield,/* complain_on_overflow */
1647          bfd_elf_generic_reloc, /* special_function */
1648          "R_ARM_TLS_IE12GP",    /* name */
1649          FALSE,                 /* partial_inplace */
1650          0x00000fff,            /* src_mask */
1651          0x00000fff,            /* dst_mask */
1652          FALSE),                /* pcrel_offset */
1653
1654   /* 112-127 private relocations.  */
1655   EMPTY_HOWTO (112),
1656   EMPTY_HOWTO (113),
1657   EMPTY_HOWTO (114),
1658   EMPTY_HOWTO (115),
1659   EMPTY_HOWTO (116),
1660   EMPTY_HOWTO (117),
1661   EMPTY_HOWTO (118),
1662   EMPTY_HOWTO (119),
1663   EMPTY_HOWTO (120),
1664   EMPTY_HOWTO (121),
1665   EMPTY_HOWTO (122),
1666   EMPTY_HOWTO (123),
1667   EMPTY_HOWTO (124),
1668   EMPTY_HOWTO (125),
1669   EMPTY_HOWTO (126),
1670   EMPTY_HOWTO (127),
1671
1672   /* R_ARM_ME_TOO, obsolete.  */
1673   EMPTY_HOWTO (128),
1674
1675   HOWTO (R_ARM_THM_TLS_DESCSEQ, /* type */
1676          0,                     /* rightshift */
1677          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1678          0,                     /* bitsize */
1679          FALSE,                 /* pc_relative */
1680          0,                     /* bitpos */
1681          complain_overflow_bitfield,/* complain_on_overflow */
1682          bfd_elf_generic_reloc, /* special_function */
1683          "R_ARM_THM_TLS_DESCSEQ",/* name */
1684          FALSE,                 /* partial_inplace */
1685          0x00000000,            /* src_mask */
1686          0x00000000,            /* dst_mask */
1687          FALSE),                /* pcrel_offset */
1688 };
1689
1690 /* 160 onwards: */
1691 static reloc_howto_type elf32_arm_howto_table_2[1] =
1692 {
1693   HOWTO (R_ARM_IRELATIVE,       /* type */
1694          0,                     /* rightshift */
1695          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1696          32,                    /* bitsize */
1697          FALSE,                 /* pc_relative */
1698          0,                     /* bitpos */
1699          complain_overflow_bitfield,/* complain_on_overflow */
1700          bfd_elf_generic_reloc, /* special_function */
1701          "R_ARM_IRELATIVE",     /* name */
1702          TRUE,                  /* partial_inplace */
1703          0xffffffff,            /* src_mask */
1704          0xffffffff,            /* dst_mask */
1705          FALSE)                 /* pcrel_offset */
1706 };
1707
1708 /* 249-255 extended, currently unused, relocations:  */
1709 static reloc_howto_type elf32_arm_howto_table_3[4] =
1710 {
1711   HOWTO (R_ARM_RREL32,          /* type */
1712          0,                     /* rightshift */
1713          0,                     /* size (0 = byte, 1 = short, 2 = long) */
1714          0,                     /* bitsize */
1715          FALSE,                 /* pc_relative */
1716          0,                     /* bitpos */
1717          complain_overflow_dont,/* complain_on_overflow */
1718          bfd_elf_generic_reloc, /* special_function */
1719          "R_ARM_RREL32",        /* name */
1720          FALSE,                 /* partial_inplace */
1721          0,                     /* src_mask */
1722          0,                     /* dst_mask */
1723          FALSE),                /* pcrel_offset */
1724
1725   HOWTO (R_ARM_RABS32,          /* type */
1726          0,                     /* rightshift */
1727          0,                     /* size (0 = byte, 1 = short, 2 = long) */
1728          0,                     /* bitsize */
1729          FALSE,                 /* pc_relative */
1730          0,                     /* bitpos */
1731          complain_overflow_dont,/* complain_on_overflow */
1732          bfd_elf_generic_reloc, /* special_function */
1733          "R_ARM_RABS32",        /* name */
1734          FALSE,                 /* partial_inplace */
1735          0,                     /* src_mask */
1736          0,                     /* dst_mask */
1737          FALSE),                /* pcrel_offset */
1738
1739   HOWTO (R_ARM_RPC24,           /* type */
1740          0,                     /* rightshift */
1741          0,                     /* size (0 = byte, 1 = short, 2 = long) */
1742          0,                     /* bitsize */
1743          FALSE,                 /* pc_relative */
1744          0,                     /* bitpos */
1745          complain_overflow_dont,/* complain_on_overflow */
1746          bfd_elf_generic_reloc, /* special_function */
1747          "R_ARM_RPC24",         /* name */
1748          FALSE,                 /* partial_inplace */
1749          0,                     /* src_mask */
1750          0,                     /* dst_mask */
1751          FALSE),                /* pcrel_offset */
1752
1753   HOWTO (R_ARM_RBASE,           /* type */
1754          0,                     /* rightshift */
1755          0,                     /* size (0 = byte, 1 = short, 2 = long) */
1756          0,                     /* bitsize */
1757          FALSE,                 /* pc_relative */
1758          0,                     /* bitpos */
1759          complain_overflow_dont,/* complain_on_overflow */
1760          bfd_elf_generic_reloc, /* special_function */
1761          "R_ARM_RBASE",         /* name */
1762          FALSE,                 /* partial_inplace */
1763          0,                     /* src_mask */
1764          0,                     /* dst_mask */
1765          FALSE)                 /* pcrel_offset */
1766 };
1767
1768 static reloc_howto_type *
1769 elf32_arm_howto_from_type (unsigned int r_type)
1770 {
1771   if (r_type < ARRAY_SIZE (elf32_arm_howto_table_1))
1772     return &elf32_arm_howto_table_1[r_type];
1773
1774   if (r_type == R_ARM_IRELATIVE)
1775     return &elf32_arm_howto_table_2[r_type - R_ARM_IRELATIVE];
1776
1777   if (r_type >= R_ARM_RREL32
1778       && r_type < R_ARM_RREL32 + ARRAY_SIZE (elf32_arm_howto_table_3))
1779     return &elf32_arm_howto_table_3[r_type - R_ARM_RREL32];
1780
1781   return NULL;
1782 }
1783
1784 static void
1785 elf32_arm_info_to_howto (bfd * abfd ATTRIBUTE_UNUSED, arelent * bfd_reloc,
1786                          Elf_Internal_Rela * elf_reloc)
1787 {
1788   unsigned int r_type;
1789
1790   r_type = ELF32_R_TYPE (elf_reloc->r_info);
1791   bfd_reloc->howto = elf32_arm_howto_from_type (r_type);
1792 }
1793
1794 struct elf32_arm_reloc_map
1795   {
1796     bfd_reloc_code_real_type  bfd_reloc_val;
1797     unsigned char             elf_reloc_val;
1798   };
1799
1800 /* All entries in this list must also be present in elf32_arm_howto_table.  */
1801 static const struct elf32_arm_reloc_map elf32_arm_reloc_map[] =
1802   {
1803     {BFD_RELOC_NONE,                 R_ARM_NONE},
1804     {BFD_RELOC_ARM_PCREL_BRANCH,     R_ARM_PC24},
1805     {BFD_RELOC_ARM_PCREL_CALL,       R_ARM_CALL},
1806     {BFD_RELOC_ARM_PCREL_JUMP,       R_ARM_JUMP24},
1807     {BFD_RELOC_ARM_PCREL_BLX,        R_ARM_XPC25},
1808     {BFD_RELOC_THUMB_PCREL_BLX,      R_ARM_THM_XPC22},
1809     {BFD_RELOC_32,                   R_ARM_ABS32},
1810     {BFD_RELOC_32_PCREL,             R_ARM_REL32},
1811     {BFD_RELOC_8,                    R_ARM_ABS8},
1812     {BFD_RELOC_16,                   R_ARM_ABS16},
1813     {BFD_RELOC_ARM_OFFSET_IMM,       R_ARM_ABS12},
1814     {BFD_RELOC_ARM_THUMB_OFFSET,     R_ARM_THM_ABS5},
1815     {BFD_RELOC_THUMB_PCREL_BRANCH25, R_ARM_THM_JUMP24},
1816     {BFD_RELOC_THUMB_PCREL_BRANCH23, R_ARM_THM_CALL},
1817     {BFD_RELOC_THUMB_PCREL_BRANCH12, R_ARM_THM_JUMP11},
1818     {BFD_RELOC_THUMB_PCREL_BRANCH20, R_ARM_THM_JUMP19},
1819     {BFD_RELOC_THUMB_PCREL_BRANCH9,  R_ARM_THM_JUMP8},
1820     {BFD_RELOC_THUMB_PCREL_BRANCH7,  R_ARM_THM_JUMP6},
1821     {BFD_RELOC_ARM_GLOB_DAT,         R_ARM_GLOB_DAT},
1822     {BFD_RELOC_ARM_JUMP_SLOT,        R_ARM_JUMP_SLOT},
1823     {BFD_RELOC_ARM_RELATIVE,         R_ARM_RELATIVE},
1824     {BFD_RELOC_ARM_GOTOFF,           R_ARM_GOTOFF32},
1825     {BFD_RELOC_ARM_GOTPC,            R_ARM_GOTPC},
1826     {BFD_RELOC_ARM_GOT_PREL,         R_ARM_GOT_PREL},
1827     {BFD_RELOC_ARM_GOT32,            R_ARM_GOT32},
1828     {BFD_RELOC_ARM_PLT32,            R_ARM_PLT32},
1829     {BFD_RELOC_ARM_TARGET1,          R_ARM_TARGET1},
1830     {BFD_RELOC_ARM_ROSEGREL32,       R_ARM_ROSEGREL32},
1831     {BFD_RELOC_ARM_SBREL32,          R_ARM_SBREL32},
1832     {BFD_RELOC_ARM_PREL31,           R_ARM_PREL31},
1833     {BFD_RELOC_ARM_TARGET2,          R_ARM_TARGET2},
1834     {BFD_RELOC_ARM_PLT32,            R_ARM_PLT32},
1835     {BFD_RELOC_ARM_TLS_GOTDESC,      R_ARM_TLS_GOTDESC},
1836     {BFD_RELOC_ARM_TLS_CALL,         R_ARM_TLS_CALL},
1837     {BFD_RELOC_ARM_THM_TLS_CALL,     R_ARM_THM_TLS_CALL},
1838     {BFD_RELOC_ARM_TLS_DESCSEQ,      R_ARM_TLS_DESCSEQ},
1839     {BFD_RELOC_ARM_THM_TLS_DESCSEQ,  R_ARM_THM_TLS_DESCSEQ},
1840     {BFD_RELOC_ARM_TLS_DESC,         R_ARM_TLS_DESC},
1841     {BFD_RELOC_ARM_TLS_GD32,         R_ARM_TLS_GD32},
1842     {BFD_RELOC_ARM_TLS_LDO32,        R_ARM_TLS_LDO32},
1843     {BFD_RELOC_ARM_TLS_LDM32,        R_ARM_TLS_LDM32},
1844     {BFD_RELOC_ARM_TLS_DTPMOD32,     R_ARM_TLS_DTPMOD32},
1845     {BFD_RELOC_ARM_TLS_DTPOFF32,     R_ARM_TLS_DTPOFF32},
1846     {BFD_RELOC_ARM_TLS_TPOFF32,      R_ARM_TLS_TPOFF32},
1847     {BFD_RELOC_ARM_TLS_IE32,         R_ARM_TLS_IE32},
1848     {BFD_RELOC_ARM_TLS_LE32,         R_ARM_TLS_LE32},
1849     {BFD_RELOC_ARM_IRELATIVE,        R_ARM_IRELATIVE},
1850     {BFD_RELOC_VTABLE_INHERIT,       R_ARM_GNU_VTINHERIT},
1851     {BFD_RELOC_VTABLE_ENTRY,         R_ARM_GNU_VTENTRY},
1852     {BFD_RELOC_ARM_MOVW,             R_ARM_MOVW_ABS_NC},
1853     {BFD_RELOC_ARM_MOVT,             R_ARM_MOVT_ABS},
1854     {BFD_RELOC_ARM_MOVW_PCREL,       R_ARM_MOVW_PREL_NC},
1855     {BFD_RELOC_ARM_MOVT_PCREL,       R_ARM_MOVT_PREL},
1856     {BFD_RELOC_ARM_THUMB_MOVW,       R_ARM_THM_MOVW_ABS_NC},
1857     {BFD_RELOC_ARM_THUMB_MOVT,       R_ARM_THM_MOVT_ABS},
1858     {BFD_RELOC_ARM_THUMB_MOVW_PCREL, R_ARM_THM_MOVW_PREL_NC},
1859     {BFD_RELOC_ARM_THUMB_MOVT_PCREL, R_ARM_THM_MOVT_PREL},
1860     {BFD_RELOC_ARM_ALU_PC_G0_NC, R_ARM_ALU_PC_G0_NC},
1861     {BFD_RELOC_ARM_ALU_PC_G0, R_ARM_ALU_PC_G0},
1862     {BFD_RELOC_ARM_ALU_PC_G1_NC, R_ARM_ALU_PC_G1_NC},
1863     {BFD_RELOC_ARM_ALU_PC_G1, R_ARM_ALU_PC_G1},
1864     {BFD_RELOC_ARM_ALU_PC_G2, R_ARM_ALU_PC_G2},
1865     {BFD_RELOC_ARM_LDR_PC_G0, R_ARM_LDR_PC_G0},
1866     {BFD_RELOC_ARM_LDR_PC_G1, R_ARM_LDR_PC_G1},
1867     {BFD_RELOC_ARM_LDR_PC_G2, R_ARM_LDR_PC_G2},
1868     {BFD_RELOC_ARM_LDRS_PC_G0, R_ARM_LDRS_PC_G0},
1869     {BFD_RELOC_ARM_LDRS_PC_G1, R_ARM_LDRS_PC_G1},
1870     {BFD_RELOC_ARM_LDRS_PC_G2, R_ARM_LDRS_PC_G2},
1871     {BFD_RELOC_ARM_LDC_PC_G0, R_ARM_LDC_PC_G0},
1872     {BFD_RELOC_ARM_LDC_PC_G1, R_ARM_LDC_PC_G1},
1873     {BFD_RELOC_ARM_LDC_PC_G2, R_ARM_LDC_PC_G2},
1874     {BFD_RELOC_ARM_ALU_SB_G0_NC, R_ARM_ALU_SB_G0_NC},
1875     {BFD_RELOC_ARM_ALU_SB_G0, R_ARM_ALU_SB_G0},
1876     {BFD_RELOC_ARM_ALU_SB_G1_NC, R_ARM_ALU_SB_G1_NC},
1877     {BFD_RELOC_ARM_ALU_SB_G1, R_ARM_ALU_SB_G1},
1878     {BFD_RELOC_ARM_ALU_SB_G2, R_ARM_ALU_SB_G2},
1879     {BFD_RELOC_ARM_LDR_SB_G0, R_ARM_LDR_SB_G0},
1880     {BFD_RELOC_ARM_LDR_SB_G1, R_ARM_LDR_SB_G1},
1881     {BFD_RELOC_ARM_LDR_SB_G2, R_ARM_LDR_SB_G2},
1882     {BFD_RELOC_ARM_LDRS_SB_G0, R_ARM_LDRS_SB_G0},
1883     {BFD_RELOC_ARM_LDRS_SB_G1, R_ARM_LDRS_SB_G1},
1884     {BFD_RELOC_ARM_LDRS_SB_G2, R_ARM_LDRS_SB_G2},
1885     {BFD_RELOC_ARM_LDC_SB_G0, R_ARM_LDC_SB_G0},
1886     {BFD_RELOC_ARM_LDC_SB_G1, R_ARM_LDC_SB_G1},
1887     {BFD_RELOC_ARM_LDC_SB_G2, R_ARM_LDC_SB_G2},
1888     {BFD_RELOC_ARM_V4BX,             R_ARM_V4BX}
1889   };
1890
1891 static reloc_howto_type *
1892 elf32_arm_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1893                              bfd_reloc_code_real_type code)
1894 {
1895   unsigned int i;
1896
1897   for (i = 0; i < ARRAY_SIZE (elf32_arm_reloc_map); i ++)
1898     if (elf32_arm_reloc_map[i].bfd_reloc_val == code)
1899       return elf32_arm_howto_from_type (elf32_arm_reloc_map[i].elf_reloc_val);
1900
1901   return NULL;
1902 }
1903
1904 static reloc_howto_type *
1905 elf32_arm_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1906                              const char *r_name)
1907 {
1908   unsigned int i;
1909
1910   for (i = 0; i < ARRAY_SIZE (elf32_arm_howto_table_1); i++)
1911     if (elf32_arm_howto_table_1[i].name != NULL
1912         && strcasecmp (elf32_arm_howto_table_1[i].name, r_name) == 0)
1913       return &elf32_arm_howto_table_1[i];
1914
1915   for (i = 0; i < ARRAY_SIZE (elf32_arm_howto_table_2); i++)
1916     if (elf32_arm_howto_table_2[i].name != NULL
1917         && strcasecmp (elf32_arm_howto_table_2[i].name, r_name) == 0)
1918       return &elf32_arm_howto_table_2[i];
1919
1920   for (i = 0; i < ARRAY_SIZE (elf32_arm_howto_table_3); i++)
1921     if (elf32_arm_howto_table_3[i].name != NULL
1922         && strcasecmp (elf32_arm_howto_table_3[i].name, r_name) == 0)
1923       return &elf32_arm_howto_table_3[i];
1924
1925   return NULL;
1926 }
1927
1928 /* Support for core dump NOTE sections.  */
1929
1930 static bfd_boolean
1931 elf32_arm_nabi_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
1932 {
1933   int offset;
1934   size_t size;
1935
1936   switch (note->descsz)
1937     {
1938       default:
1939         return FALSE;
1940
1941       case 148:         /* Linux/ARM 32-bit.  */
1942         /* pr_cursig */
1943         elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
1944
1945         /* pr_pid */
1946         elf_tdata (abfd)->core_lwpid = bfd_get_32 (abfd, note->descdata + 24);
1947
1948         /* pr_reg */
1949         offset = 72;
1950         size = 72;
1951
1952         break;
1953     }
1954
1955   /* Make a ".reg/999" section.  */
1956   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
1957                                           size, note->descpos + offset);
1958 }
1959
1960 static bfd_boolean
1961 elf32_arm_nabi_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
1962 {
1963   switch (note->descsz)
1964     {
1965       default:
1966         return FALSE;
1967
1968       case 124:         /* Linux/ARM elf_prpsinfo.  */
1969         elf_tdata (abfd)->core_program
1970          = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
1971         elf_tdata (abfd)->core_command
1972          = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
1973     }
1974
1975   /* Note that for some reason, a spurious space is tacked
1976      onto the end of the args in some (at least one anyway)
1977      implementations, so strip it off if it exists.  */
1978   {
1979     char *command = elf_tdata (abfd)->core_command;
1980     int n = strlen (command);
1981
1982     if (0 < n && command[n - 1] == ' ')
1983       command[n - 1] = '\0';
1984   }
1985
1986   return TRUE;
1987 }
1988
1989 #define TARGET_LITTLE_SYM               bfd_elf32_littlearm_vec
1990 #define TARGET_LITTLE_NAME              "elf32-littlearm"
1991 #define TARGET_BIG_SYM                  bfd_elf32_bigarm_vec
1992 #define TARGET_BIG_NAME                 "elf32-bigarm"
1993
1994 #define elf_backend_grok_prstatus       elf32_arm_nabi_grok_prstatus
1995 #define elf_backend_grok_psinfo         elf32_arm_nabi_grok_psinfo
1996
1997 typedef unsigned long int insn32;
1998 typedef unsigned short int insn16;
1999
2000 /* In lieu of proper flags, assume all EABIv4 or later objects are
2001    interworkable.  */
2002 #define INTERWORK_FLAG(abfd)  \
2003   (EF_ARM_EABI_VERSION (elf_elfheader (abfd)->e_flags) >= EF_ARM_EABI_VER4 \
2004   || (elf_elfheader (abfd)->e_flags & EF_ARM_INTERWORK) \
2005   || ((abfd)->flags & BFD_LINKER_CREATED))
2006
2007 /* The linker script knows the section names for placement.
2008    The entry_names are used to do simple name mangling on the stubs.
2009    Given a function name, and its type, the stub can be found. The
2010    name can be changed. The only requirement is the %s be present.  */
2011 #define THUMB2ARM_GLUE_SECTION_NAME ".glue_7t"
2012 #define THUMB2ARM_GLUE_ENTRY_NAME   "__%s_from_thumb"
2013
2014 #define ARM2THUMB_GLUE_SECTION_NAME ".glue_7"
2015 #define ARM2THUMB_GLUE_ENTRY_NAME   "__%s_from_arm"
2016
2017 #define VFP11_ERRATUM_VENEER_SECTION_NAME ".vfp11_veneer"
2018 #define VFP11_ERRATUM_VENEER_ENTRY_NAME   "__vfp11_veneer_%x"
2019
2020 #define ARM_BX_GLUE_SECTION_NAME ".v4_bx"
2021 #define ARM_BX_GLUE_ENTRY_NAME   "__bx_r%d"
2022
2023 #define STUB_ENTRY_NAME   "__%s_veneer"
2024
2025 /* The name of the dynamic interpreter.  This is put in the .interp
2026    section.  */
2027 #define ELF_DYNAMIC_INTERPRETER     "/usr/lib/ld.so.1"
2028
2029 static const unsigned long tls_trampoline [] =
2030   {
2031     0xe08e0000,         /* add r0, lr, r0 */
2032     0xe5901004,         /* ldr r1, [r0,#4] */
2033     0xe12fff11,         /* bx  r1 */
2034   };
2035
2036 static const unsigned long dl_tlsdesc_lazy_trampoline [] =
2037   {
2038     0xe52d2004, /*      push    {r2}                    */
2039     0xe59f200c, /*      ldr     r2, [pc, #3f - . - 8]   */
2040     0xe59f100c, /*      ldr     r1, [pc, #4f - . - 8]   */
2041     0xe79f2002, /* 1:   ldr     r2, [pc, r2]            */
2042     0xe081100f, /* 2:   add     r1, pc                  */
2043     0xe12fff12, /*      bx      r2                      */
2044     0x00000014, /* 3:   .word  _GLOBAL_OFFSET_TABLE_ - 1b - 8
2045                                 + dl_tlsdesc_lazy_resolver(GOT)   */
2046     0x00000018, /* 4:   .word  _GLOBAL_OFFSET_TABLE_ - 2b - 8 */
2047   };
2048
2049 #ifdef FOUR_WORD_PLT
2050
2051 /* The first entry in a procedure linkage table looks like
2052    this.  It is set up so that any shared library function that is
2053    called before the relocation has been set up calls the dynamic
2054    linker first.  */
2055 static const bfd_vma elf32_arm_plt0_entry [] =
2056   {
2057     0xe52de004,         /* str   lr, [sp, #-4]! */
2058     0xe59fe010,         /* ldr   lr, [pc, #16]  */
2059     0xe08fe00e,         /* add   lr, pc, lr     */
2060     0xe5bef008,         /* ldr   pc, [lr, #8]!  */
2061   };
2062
2063 /* Subsequent entries in a procedure linkage table look like
2064    this.  */
2065 static const bfd_vma elf32_arm_plt_entry [] =
2066   {
2067     0xe28fc600,         /* add   ip, pc, #NN    */
2068     0xe28cca00,         /* add   ip, ip, #NN    */
2069     0xe5bcf000,         /* ldr   pc, [ip, #NN]! */
2070     0x00000000,         /* unused               */
2071   };
2072
2073 #else
2074
2075 /* The first entry in a procedure linkage table looks like
2076    this.  It is set up so that any shared library function that is
2077    called before the relocation has been set up calls the dynamic
2078    linker first.  */
2079 static const bfd_vma elf32_arm_plt0_entry [] =
2080   {
2081     0xe52de004,         /* str   lr, [sp, #-4]! */
2082     0xe59fe004,         /* ldr   lr, [pc, #4]   */
2083     0xe08fe00e,         /* add   lr, pc, lr     */
2084     0xe5bef008,         /* ldr   pc, [lr, #8]!  */
2085     0x00000000,         /* &GOT[0] - .          */
2086   };
2087
2088 /* Subsequent entries in a procedure linkage table look like
2089    this.  */
2090 static const bfd_vma elf32_arm_plt_entry [] =
2091   {
2092     0xe28fc600,         /* add   ip, pc, #0xNN00000 */
2093     0xe28cca00,         /* add   ip, ip, #0xNN000   */
2094     0xe5bcf000,         /* ldr   pc, [ip, #0xNNN]!  */
2095   };
2096
2097 #endif
2098
2099 /* The format of the first entry in the procedure linkage table
2100    for a VxWorks executable.  */
2101 static const bfd_vma elf32_arm_vxworks_exec_plt0_entry[] =
2102   {
2103     0xe52dc008,         /* str    ip,[sp,#-8]!                  */
2104     0xe59fc000,         /* ldr    ip,[pc]                       */
2105     0xe59cf008,         /* ldr    pc,[ip,#8]                    */
2106     0x00000000,         /* .long  _GLOBAL_OFFSET_TABLE_         */
2107   };
2108
2109 /* The format of subsequent entries in a VxWorks executable.  */
2110 static const bfd_vma elf32_arm_vxworks_exec_plt_entry[] =
2111   {
2112     0xe59fc000,         /* ldr    ip,[pc]                       */
2113     0xe59cf000,         /* ldr    pc,[ip]                       */
2114     0x00000000,         /* .long  @got                          */
2115     0xe59fc000,         /* ldr    ip,[pc]                       */
2116     0xea000000,         /* b      _PLT                          */
2117     0x00000000,         /* .long  @pltindex*sizeof(Elf32_Rela)  */
2118   };
2119
2120 /* The format of entries in a VxWorks shared library.  */
2121 static const bfd_vma elf32_arm_vxworks_shared_plt_entry[] =
2122   {
2123     0xe59fc000,         /* ldr    ip,[pc]                       */
2124     0xe79cf009,         /* ldr    pc,[ip,r9]                    */
2125     0x00000000,         /* .long  @got                          */
2126     0xe59fc000,         /* ldr    ip,[pc]                       */
2127     0xe599f008,         /* ldr    pc,[r9,#8]                    */
2128     0x00000000,         /* .long  @pltindex*sizeof(Elf32_Rela)  */
2129   };
2130
2131 /* An initial stub used if the PLT entry is referenced from Thumb code.  */
2132 #define PLT_THUMB_STUB_SIZE 4
2133 static const bfd_vma elf32_arm_plt_thumb_stub [] =
2134   {
2135     0x4778,             /* bx pc */
2136     0x46c0              /* nop   */
2137   };
2138
2139 /* The entries in a PLT when using a DLL-based target with multiple
2140    address spaces.  */
2141 static const bfd_vma elf32_arm_symbian_plt_entry [] =
2142   {
2143     0xe51ff004,         /* ldr   pc, [pc, #-4] */
2144     0x00000000,         /* dcd   R_ARM_GLOB_DAT(X) */
2145   };
2146
2147 #define ARM_MAX_FWD_BRANCH_OFFSET  ((((1 << 23) - 1) << 2) + 8)
2148 #define ARM_MAX_BWD_BRANCH_OFFSET  ((-((1 << 23) << 2)) + 8)
2149 #define THM_MAX_FWD_BRANCH_OFFSET  ((1 << 22) -2 + 4)
2150 #define THM_MAX_BWD_BRANCH_OFFSET  (-(1 << 22) + 4)
2151 #define THM2_MAX_FWD_BRANCH_OFFSET (((1 << 24) - 2) + 4)
2152 #define THM2_MAX_BWD_BRANCH_OFFSET (-(1 << 24) + 4)
2153
2154 enum stub_insn_type
2155   {
2156     THUMB16_TYPE = 1,
2157     THUMB32_TYPE,
2158     ARM_TYPE,
2159     DATA_TYPE
2160   };
2161
2162 #define THUMB16_INSN(X)         {(X), THUMB16_TYPE, R_ARM_NONE, 0}
2163 /* A bit of a hack.  A Thumb conditional branch, in which the proper condition
2164    is inserted in arm_build_one_stub().  */
2165 #define THUMB16_BCOND_INSN(X)   {(X), THUMB16_TYPE, R_ARM_NONE, 1}
2166 #define THUMB32_INSN(X)         {(X), THUMB32_TYPE, R_ARM_NONE, 0}
2167 #define THUMB32_B_INSN(X, Z)    {(X), THUMB32_TYPE, R_ARM_THM_JUMP24, (Z)}
2168 #define ARM_INSN(X)             {(X), ARM_TYPE, R_ARM_NONE, 0}
2169 #define ARM_REL_INSN(X, Z)      {(X), ARM_TYPE, R_ARM_JUMP24, (Z)}
2170 #define DATA_WORD(X,Y,Z)        {(X), DATA_TYPE, (Y), (Z)}
2171
2172 typedef struct
2173 {
2174   bfd_vma data;
2175   enum stub_insn_type type;
2176   unsigned int r_type;
2177   int reloc_addend;
2178 }  insn_sequence;
2179
2180 /* Arm/Thumb -> Arm/Thumb long branch stub. On V5T and above, use blx
2181    to reach the stub if necessary.  */
2182 static const insn_sequence elf32_arm_stub_long_branch_any_any[] =
2183   {
2184     ARM_INSN(0xe51ff004),            /* ldr   pc, [pc, #-4] */
2185     DATA_WORD(0, R_ARM_ABS32, 0),    /* dcd   R_ARM_ABS32(X) */
2186   };
2187
2188 /* V4T Arm -> Thumb long branch stub. Used on V4T where blx is not
2189    available.  */
2190 static const insn_sequence elf32_arm_stub_long_branch_v4t_arm_thumb[] =
2191   {
2192     ARM_INSN(0xe59fc000),            /* ldr   ip, [pc, #0] */
2193     ARM_INSN(0xe12fff1c),            /* bx    ip */
2194     DATA_WORD(0, R_ARM_ABS32, 0),    /* dcd   R_ARM_ABS32(X) */
2195   };
2196
2197 /* Thumb -> Thumb long branch stub. Used on M-profile architectures.  */
2198 static const insn_sequence elf32_arm_stub_long_branch_thumb_only[] =
2199   {
2200     THUMB16_INSN(0xb401),             /* push {r0} */
2201     THUMB16_INSN(0x4802),             /* ldr  r0, [pc, #8] */
2202     THUMB16_INSN(0x4684),             /* mov  ip, r0 */
2203     THUMB16_INSN(0xbc01),             /* pop  {r0} */
2204     THUMB16_INSN(0x4760),             /* bx   ip */
2205     THUMB16_INSN(0xbf00),             /* nop */
2206     DATA_WORD(0, R_ARM_ABS32, 0),     /* dcd  R_ARM_ABS32(X) */
2207   };
2208
2209 /* V4T Thumb -> Thumb long branch stub. Using the stack is not
2210    allowed.  */
2211 static const insn_sequence elf32_arm_stub_long_branch_v4t_thumb_thumb[] =
2212   {
2213     THUMB16_INSN(0x4778),             /* bx   pc */
2214     THUMB16_INSN(0x46c0),             /* nop */
2215     ARM_INSN(0xe59fc000),             /* ldr  ip, [pc, #0] */
2216     ARM_INSN(0xe12fff1c),             /* bx   ip */
2217     DATA_WORD(0, R_ARM_ABS32, 0),     /* dcd  R_ARM_ABS32(X) */
2218   };
2219
2220 /* V4T Thumb -> ARM long branch stub. Used on V4T where blx is not
2221    available.  */
2222 static const insn_sequence elf32_arm_stub_long_branch_v4t_thumb_arm[] =
2223   {
2224     THUMB16_INSN(0x4778),             /* bx   pc */
2225     THUMB16_INSN(0x46c0),             /* nop   */
2226     ARM_INSN(0xe51ff004),             /* ldr   pc, [pc, #-4] */
2227     DATA_WORD(0, R_ARM_ABS32, 0),     /* dcd   R_ARM_ABS32(X) */
2228   };
2229
2230 /* V4T Thumb -> ARM short branch stub. Shorter variant of the above
2231    one, when the destination is close enough.  */
2232 static const insn_sequence elf32_arm_stub_short_branch_v4t_thumb_arm[] =
2233   {
2234     THUMB16_INSN(0x4778),             /* bx   pc */
2235     THUMB16_INSN(0x46c0),             /* nop   */
2236     ARM_REL_INSN(0xea000000, -8),     /* b    (X-8) */
2237   };
2238
2239 /* ARM/Thumb -> ARM long branch stub, PIC.  On V5T and above, use
2240    blx to reach the stub if necessary.  */
2241 static const insn_sequence elf32_arm_stub_long_branch_any_arm_pic[] =
2242   {
2243     ARM_INSN(0xe59fc000),             /* ldr   ip, [pc] */
2244     ARM_INSN(0xe08ff00c),             /* add   pc, pc, ip */
2245     DATA_WORD(0, R_ARM_REL32, -4),    /* dcd   R_ARM_REL32(X-4) */
2246   };
2247
2248 /* ARM/Thumb -> Thumb long branch stub, PIC.  On V5T and above, use
2249    blx to reach the stub if necessary.  We can not add into pc;
2250    it is not guaranteed to mode switch (different in ARMv6 and
2251    ARMv7).  */
2252 static const insn_sequence elf32_arm_stub_long_branch_any_thumb_pic[] =
2253   {
2254     ARM_INSN(0xe59fc004),             /* ldr   ip, [pc, #4] */
2255     ARM_INSN(0xe08fc00c),             /* add   ip, pc, ip */
2256     ARM_INSN(0xe12fff1c),             /* bx    ip */
2257     DATA_WORD(0, R_ARM_REL32, 0),     /* dcd   R_ARM_REL32(X) */
2258   };
2259
2260 /* V4T ARM -> ARM long branch stub, PIC.  */
2261 static const insn_sequence elf32_arm_stub_long_branch_v4t_arm_thumb_pic[] =
2262   {
2263     ARM_INSN(0xe59fc004),             /* ldr   ip, [pc, #4] */
2264     ARM_INSN(0xe08fc00c),             /* add   ip, pc, ip */
2265     ARM_INSN(0xe12fff1c),             /* bx    ip */
2266     DATA_WORD(0, R_ARM_REL32, 0),     /* dcd   R_ARM_REL32(X) */
2267   };
2268
2269 /* V4T Thumb -> ARM long branch stub, PIC.  */
2270 static const insn_sequence elf32_arm_stub_long_branch_v4t_thumb_arm_pic[] =
2271   {
2272     THUMB16_INSN(0x4778),             /* bx   pc */
2273     THUMB16_INSN(0x46c0),             /* nop  */
2274     ARM_INSN(0xe59fc000),             /* ldr  ip, [pc, #0] */
2275     ARM_INSN(0xe08cf00f),             /* add  pc, ip, pc */
2276     DATA_WORD(0, R_ARM_REL32, -4),     /* dcd  R_ARM_REL32(X) */
2277   };
2278
2279 /* Thumb -> Thumb long branch stub, PIC. Used on M-profile
2280    architectures.  */
2281 static const insn_sequence elf32_arm_stub_long_branch_thumb_only_pic[] =
2282   {
2283     THUMB16_INSN(0xb401),             /* push {r0} */
2284     THUMB16_INSN(0x4802),             /* ldr  r0, [pc, #8] */
2285     THUMB16_INSN(0x46fc),             /* mov  ip, pc */
2286     THUMB16_INSN(0x4484),             /* add  ip, r0 */
2287     THUMB16_INSN(0xbc01),             /* pop  {r0} */
2288     THUMB16_INSN(0x4760),             /* bx   ip */
2289     DATA_WORD(0, R_ARM_REL32, 4),     /* dcd  R_ARM_REL32(X) */
2290   };
2291
2292 /* V4T Thumb -> Thumb long branch stub, PIC. Using the stack is not
2293    allowed.  */
2294 static const insn_sequence elf32_arm_stub_long_branch_v4t_thumb_thumb_pic[] =
2295   {
2296     THUMB16_INSN(0x4778),             /* bx   pc */
2297     THUMB16_INSN(0x46c0),             /* nop */
2298     ARM_INSN(0xe59fc004),             /* ldr  ip, [pc, #4] */
2299     ARM_INSN(0xe08fc00c),             /* add   ip, pc, ip */
2300     ARM_INSN(0xe12fff1c),             /* bx   ip */
2301     DATA_WORD(0, R_ARM_REL32, 0),     /* dcd  R_ARM_REL32(X) */
2302   };
2303
2304 /* Thumb2/ARM -> TLS trampoline.  Lowest common denominator, which is a
2305    long PIC stub.  We can use r1 as a scratch -- and cannot use ip.  */
2306 static const insn_sequence elf32_arm_stub_long_branch_any_tls_pic[] =
2307 {
2308     ARM_INSN(0xe59f1000),             /* ldr   r1, [pc] */
2309     ARM_INSN(0xe08ff001),             /* add   pc, pc, r1 */
2310     DATA_WORD(0, R_ARM_REL32, -4),    /* dcd   R_ARM_REL32(X-4) */
2311 };
2312
2313 /* V4T Thumb -> TLS trampoline.  lowest common denominator, which is a
2314    long PIC stub.  We can use r1 as a scratch -- and cannot use ip.  */
2315 static const insn_sequence elf32_arm_stub_long_branch_v4t_thumb_tls_pic[] =
2316 {
2317     THUMB16_INSN(0x4778),             /* bx   pc */
2318     THUMB16_INSN(0x46c0),             /* nop */
2319     ARM_INSN(0xe59f1000),             /* ldr  r1, [pc, #0] */
2320     ARM_INSN(0xe081f00f),             /* add  pc, r1, pc */
2321     DATA_WORD(0, R_ARM_REL32, -4),    /* dcd  R_ARM_REL32(X) */
2322 };
2323
2324 /* Cortex-A8 erratum-workaround stubs.  */
2325
2326 /* Stub used for conditional branches (which may be beyond +/-1MB away, so we
2327    can't use a conditional branch to reach this stub).  */
2328
2329 static const insn_sequence elf32_arm_stub_a8_veneer_b_cond[] =
2330   {
2331     THUMB16_BCOND_INSN(0xd001),         /* b<cond>.n true.  */
2332     THUMB32_B_INSN(0xf000b800, -4),     /* b.w insn_after_original_branch.  */
2333     THUMB32_B_INSN(0xf000b800, -4)      /* true: b.w original_branch_dest.  */
2334   };
2335
2336 /* Stub used for b.w and bl.w instructions.  */
2337
2338 static const insn_sequence elf32_arm_stub_a8_veneer_b[] =
2339   {
2340     THUMB32_B_INSN(0xf000b800, -4)      /* b.w original_branch_dest.  */
2341   };
2342
2343 static const insn_sequence elf32_arm_stub_a8_veneer_bl[] =
2344   {
2345     THUMB32_B_INSN(0xf000b800, -4)      /* b.w original_branch_dest.  */
2346   };
2347
2348 /* Stub used for Thumb-2 blx.w instructions.  We modified the original blx.w
2349    instruction (which switches to ARM mode) to point to this stub.  Jump to the
2350    real destination using an ARM-mode branch.  */
2351
2352 static const insn_sequence elf32_arm_stub_a8_veneer_blx[] =
2353   {
2354     ARM_REL_INSN(0xea000000, -8)        /* b original_branch_dest.  */
2355   };
2356
2357 /* Section name for stubs is the associated section name plus this
2358    string.  */
2359 #define STUB_SUFFIX ".stub"
2360
2361 /* One entry per long/short branch stub defined above.  */
2362 #define DEF_STUBS \
2363   DEF_STUB(long_branch_any_any) \
2364   DEF_STUB(long_branch_v4t_arm_thumb) \
2365   DEF_STUB(long_branch_thumb_only) \
2366   DEF_STUB(long_branch_v4t_thumb_thumb) \
2367   DEF_STUB(long_branch_v4t_thumb_arm) \
2368   DEF_STUB(short_branch_v4t_thumb_arm) \
2369   DEF_STUB(long_branch_any_arm_pic) \
2370   DEF_STUB(long_branch_any_thumb_pic) \
2371   DEF_STUB(long_branch_v4t_thumb_thumb_pic) \
2372   DEF_STUB(long_branch_v4t_arm_thumb_pic) \
2373   DEF_STUB(long_branch_v4t_thumb_arm_pic) \
2374   DEF_STUB(long_branch_thumb_only_pic) \
2375   DEF_STUB(long_branch_any_tls_pic) \
2376   DEF_STUB(long_branch_v4t_thumb_tls_pic) \
2377   DEF_STUB(a8_veneer_b_cond) \
2378   DEF_STUB(a8_veneer_b) \
2379   DEF_STUB(a8_veneer_bl) \
2380   DEF_STUB(a8_veneer_blx)
2381
2382 #define DEF_STUB(x) arm_stub_##x,
2383 enum elf32_arm_stub_type {
2384   arm_stub_none,
2385   DEF_STUBS
2386   /* Note the first a8_veneer type */
2387   arm_stub_a8_veneer_lwm = arm_stub_a8_veneer_b_cond
2388 };
2389 #undef DEF_STUB
2390
2391 typedef struct
2392 {
2393   const insn_sequence* template_sequence;
2394   int template_size;
2395 } stub_def;
2396
2397 #define DEF_STUB(x) {elf32_arm_stub_##x, ARRAY_SIZE(elf32_arm_stub_##x)},
2398 static const stub_def stub_definitions[] = {
2399   {NULL, 0},
2400   DEF_STUBS
2401 };
2402
2403 struct elf32_arm_stub_hash_entry
2404 {
2405   /* Base hash table entry structure.  */
2406   struct bfd_hash_entry root;
2407
2408   /* The stub section.  */
2409   asection *stub_sec;
2410
2411   /* Offset within stub_sec of the beginning of this stub.  */
2412   bfd_vma stub_offset;
2413
2414   /* Given the symbol's value and its section we can determine its final
2415      value when building the stubs (so the stub knows where to jump).  */
2416   bfd_vma target_value;
2417   asection *target_section;
2418
2419   /* Offset to apply to relocation referencing target_value.  */
2420   bfd_vma target_addend;
2421
2422   /* The instruction which caused this stub to be generated (only valid for
2423      Cortex-A8 erratum workaround stubs at present).  */
2424   unsigned long orig_insn;
2425
2426   /* The stub type.  */
2427   enum elf32_arm_stub_type stub_type;
2428   /* Its encoding size in bytes.  */
2429   int stub_size;
2430   /* Its template.  */
2431   const insn_sequence *stub_template;
2432   /* The size of the template (number of entries).  */
2433   int stub_template_size;
2434
2435   /* The symbol table entry, if any, that this was derived from.  */
2436   struct elf32_arm_link_hash_entry *h;
2437
2438   /* Type of branch.  */
2439   enum arm_st_branch_type branch_type;
2440
2441   /* Where this stub is being called from, or, in the case of combined
2442      stub sections, the first input section in the group.  */
2443   asection *id_sec;
2444
2445   /* The name for the local symbol at the start of this stub.  The
2446      stub name in the hash table has to be unique; this does not, so
2447      it can be friendlier.  */
2448   char *output_name;
2449 };
2450
2451 /* Used to build a map of a section.  This is required for mixed-endian
2452    code/data.  */
2453
2454 typedef struct elf32_elf_section_map
2455 {
2456   bfd_vma vma;
2457   char type;
2458 }
2459 elf32_arm_section_map;
2460
2461 /* Information about a VFP11 erratum veneer, or a branch to such a veneer.  */
2462
2463 typedef enum
2464 {
2465   VFP11_ERRATUM_BRANCH_TO_ARM_VENEER,
2466   VFP11_ERRATUM_BRANCH_TO_THUMB_VENEER,
2467   VFP11_ERRATUM_ARM_VENEER,
2468   VFP11_ERRATUM_THUMB_VENEER
2469 }
2470 elf32_vfp11_erratum_type;
2471
2472 typedef struct elf32_vfp11_erratum_list
2473 {
2474   struct elf32_vfp11_erratum_list *next;
2475   bfd_vma vma;
2476   union
2477   {
2478     struct
2479     {
2480       struct elf32_vfp11_erratum_list *veneer;
2481       unsigned int vfp_insn;
2482     } b;
2483     struct
2484     {
2485       struct elf32_vfp11_erratum_list *branch;
2486       unsigned int id;
2487     } v;
2488   } u;
2489   elf32_vfp11_erratum_type type;
2490 }
2491 elf32_vfp11_erratum_list;
2492
2493 typedef enum
2494 {
2495   DELETE_EXIDX_ENTRY,
2496   INSERT_EXIDX_CANTUNWIND_AT_END
2497 }
2498 arm_unwind_edit_type;
2499
2500 /* A (sorted) list of edits to apply to an unwind table.  */
2501 typedef struct arm_unwind_table_edit
2502 {
2503   arm_unwind_edit_type type;
2504   /* Note: we sometimes want to insert an unwind entry corresponding to a
2505      section different from the one we're currently writing out, so record the
2506      (text) section this edit relates to here.  */
2507   asection *linked_section;
2508   unsigned int index;
2509   struct arm_unwind_table_edit *next;
2510 }
2511 arm_unwind_table_edit;
2512
2513 typedef struct _arm_elf_section_data
2514 {
2515   /* Information about mapping symbols.  */
2516   struct bfd_elf_section_data elf;
2517   unsigned int mapcount;
2518   unsigned int mapsize;
2519   elf32_arm_section_map *map;
2520   /* Information about CPU errata.  */
2521   unsigned int erratumcount;
2522   elf32_vfp11_erratum_list *erratumlist;
2523   /* Information about unwind tables.  */
2524   union
2525   {
2526     /* Unwind info attached to a text section.  */
2527     struct
2528     {
2529       asection *arm_exidx_sec;
2530     } text;
2531
2532     /* Unwind info attached to an .ARM.exidx section.  */
2533     struct
2534     {
2535       arm_unwind_table_edit *unwind_edit_list;
2536       arm_unwind_table_edit *unwind_edit_tail;
2537     } exidx;
2538   } u;
2539 }
2540 _arm_elf_section_data;
2541
2542 #define elf32_arm_section_data(sec) \
2543   ((_arm_elf_section_data *) elf_section_data (sec))
2544
2545 /* A fix which might be required for Cortex-A8 Thumb-2 branch/TLB erratum.
2546    These fixes are subject to a relaxation procedure (in elf32_arm_size_stubs),
2547    so may be created multiple times: we use an array of these entries whilst
2548    relaxing which we can refresh easily, then create stubs for each potentially
2549    erratum-triggering instruction once we've settled on a solution.  */
2550
2551 struct a8_erratum_fix {
2552   bfd *input_bfd;
2553   asection *section;
2554   bfd_vma offset;
2555   bfd_vma addend;
2556   unsigned long orig_insn;
2557   char *stub_name;
2558   enum elf32_arm_stub_type stub_type;
2559   enum arm_st_branch_type branch_type;
2560 };
2561
2562 /* A table of relocs applied to branches which might trigger Cortex-A8
2563    erratum.  */
2564
2565 struct a8_erratum_reloc {
2566   bfd_vma from;
2567   bfd_vma destination;
2568   struct elf32_arm_link_hash_entry *hash;
2569   const char *sym_name;
2570   unsigned int r_type;
2571   enum arm_st_branch_type branch_type;
2572   bfd_boolean non_a8_stub;
2573 };
2574
2575 /* The size of the thread control block.  */
2576 #define TCB_SIZE        8
2577
2578 /* ARM-specific information about a PLT entry, over and above the usual
2579    gotplt_union.  */
2580 struct arm_plt_info {
2581   /* We reference count Thumb references to a PLT entry separately,
2582      so that we can emit the Thumb trampoline only if needed.  */
2583   bfd_signed_vma thumb_refcount;
2584
2585   /* Some references from Thumb code may be eliminated by BL->BLX
2586      conversion, so record them separately.  */
2587   bfd_signed_vma maybe_thumb_refcount;
2588
2589   /* How many of the recorded PLT accesses were from non-call relocations.
2590      This information is useful when deciding whether anything takes the
2591      address of an STT_GNU_IFUNC PLT.  A value of 0 means that all
2592      non-call references to the function should resolve directly to the
2593      real runtime target.  */
2594   unsigned int noncall_refcount;
2595
2596   /* Since PLT entries have variable size if the Thumb prologue is
2597      used, we need to record the index into .got.plt instead of
2598      recomputing it from the PLT offset.  */
2599   bfd_signed_vma got_offset;
2600 };
2601
2602 /* Information about an .iplt entry for a local STT_GNU_IFUNC symbol.  */
2603 struct arm_local_iplt_info {
2604   /* The information that is usually found in the generic ELF part of
2605      the hash table entry.  */
2606   union gotplt_union root;
2607
2608   /* The information that is usually found in the ARM-specific part of
2609      the hash table entry.  */
2610   struct arm_plt_info arm;
2611
2612   /* A list of all potential dynamic relocations against this symbol.  */
2613   struct elf_dyn_relocs *dyn_relocs;
2614 };
2615
2616 struct elf_arm_obj_tdata
2617 {
2618   struct elf_obj_tdata root;
2619
2620   /* tls_type for each local got entry.  */
2621   char *local_got_tls_type;
2622
2623   /* GOTPLT entries for TLS descriptors.  */
2624   bfd_vma *local_tlsdesc_gotent;
2625
2626   /* Information for local symbols that need entries in .iplt.  */
2627   struct arm_local_iplt_info **local_iplt;
2628
2629   /* Zero to warn when linking objects with incompatible enum sizes.  */
2630   int no_enum_size_warning;
2631
2632   /* Zero to warn when linking objects with incompatible wchar_t sizes.  */
2633   int no_wchar_size_warning;
2634 };
2635
2636 #define elf_arm_tdata(bfd) \
2637   ((struct elf_arm_obj_tdata *) (bfd)->tdata.any)
2638
2639 #define elf32_arm_local_got_tls_type(bfd) \
2640   (elf_arm_tdata (bfd)->local_got_tls_type)
2641
2642 #define elf32_arm_local_tlsdesc_gotent(bfd) \
2643   (elf_arm_tdata (bfd)->local_tlsdesc_gotent)
2644
2645 #define elf32_arm_local_iplt(bfd) \
2646   (elf_arm_tdata (bfd)->local_iplt)
2647
2648 #define is_arm_elf(bfd) \
2649   (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2650    && elf_tdata (bfd) != NULL \
2651    && elf_object_id (bfd) == ARM_ELF_DATA)
2652
2653 static bfd_boolean
2654 elf32_arm_mkobject (bfd *abfd)
2655 {
2656   return bfd_elf_allocate_object (abfd, sizeof (struct elf_arm_obj_tdata),
2657                                   ARM_ELF_DATA);
2658 }
2659
2660 #define elf32_arm_hash_entry(ent) ((struct elf32_arm_link_hash_entry *)(ent))
2661
2662 /* Arm ELF linker hash entry.  */
2663 struct elf32_arm_link_hash_entry
2664   {
2665     struct elf_link_hash_entry root;
2666
2667     /* Track dynamic relocs copied for this symbol.  */
2668     struct elf_dyn_relocs *dyn_relocs;
2669
2670     /* ARM-specific PLT information.  */
2671     struct arm_plt_info plt;
2672
2673 #define GOT_UNKNOWN     0
2674 #define GOT_NORMAL      1
2675 #define GOT_TLS_GD      2
2676 #define GOT_TLS_IE      4
2677 #define GOT_TLS_GDESC   8
2678 #define GOT_TLS_GD_ANY_P(type)  ((type & GOT_TLS_GD) || (type & GOT_TLS_GDESC))
2679     unsigned int tls_type : 8;
2680
2681     /* True if the symbol's PLT entry is in .iplt rather than .plt.  */
2682     unsigned int is_iplt : 1;
2683
2684     unsigned int unused : 23;
2685
2686     /* Offset of the GOTPLT entry reserved for the TLS descriptor,
2687        starting at the end of the jump table.  */
2688     bfd_vma tlsdesc_got;
2689
2690     /* The symbol marking the real symbol location for exported thumb
2691        symbols with Arm stubs.  */
2692     struct elf_link_hash_entry *export_glue;
2693
2694    /* A pointer to the most recently used stub hash entry against this
2695      symbol.  */
2696     struct elf32_arm_stub_hash_entry *stub_cache;
2697   };
2698
2699 /* Traverse an arm ELF linker hash table.  */
2700 #define elf32_arm_link_hash_traverse(table, func, info)                 \
2701   (elf_link_hash_traverse                                               \
2702    (&(table)->root,                                                     \
2703     (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func),    \
2704     (info)))
2705
2706 /* Get the ARM elf linker hash table from a link_info structure.  */
2707 #define elf32_arm_hash_table(info) \
2708   (elf_hash_table_id ((struct elf_link_hash_table *) ((info)->hash)) \
2709   == ARM_ELF_DATA ? ((struct elf32_arm_link_hash_table *) ((info)->hash)) : NULL)
2710
2711 #define arm_stub_hash_lookup(table, string, create, copy) \
2712   ((struct elf32_arm_stub_hash_entry *) \
2713    bfd_hash_lookup ((table), (string), (create), (copy)))
2714
2715 /* Array to keep track of which stub sections have been created, and
2716    information on stub grouping.  */
2717 struct map_stub
2718 {
2719   /* This is the section to which stubs in the group will be
2720      attached.  */
2721   asection *link_sec;
2722   /* The stub section.  */
2723   asection *stub_sec;
2724 };
2725
2726 #define elf32_arm_compute_jump_table_size(htab) \
2727   ((htab)->next_tls_desc_index * 4)
2728
2729 /* ARM ELF linker hash table.  */
2730 struct elf32_arm_link_hash_table
2731 {
2732   /* The main hash table.  */
2733   struct elf_link_hash_table root;
2734
2735   /* The size in bytes of the section containing the Thumb-to-ARM glue.  */
2736   bfd_size_type thumb_glue_size;
2737
2738   /* The size in bytes of the section containing the ARM-to-Thumb glue.  */
2739   bfd_size_type arm_glue_size;
2740
2741   /* The size in bytes of section containing the ARMv4 BX veneers.  */
2742   bfd_size_type bx_glue_size;
2743
2744   /* Offsets of ARMv4 BX veneers.  Bit1 set if present, and Bit0 set when
2745      veneer has been populated.  */
2746   bfd_vma bx_glue_offset[15];
2747
2748   /* The size in bytes of the section containing glue for VFP11 erratum
2749      veneers.  */
2750   bfd_size_type vfp11_erratum_glue_size;
2751
2752   /* A table of fix locations for Cortex-A8 Thumb-2 branch/TLB erratum.  This
2753      holds Cortex-A8 erratum fix locations between elf32_arm_size_stubs() and
2754      elf32_arm_write_section().  */
2755   struct a8_erratum_fix *a8_erratum_fixes;
2756   unsigned int num_a8_erratum_fixes;
2757
2758   /* An arbitrary input BFD chosen to hold the glue sections.  */
2759   bfd * bfd_of_glue_owner;
2760
2761   /* Nonzero to output a BE8 image.  */
2762   int byteswap_code;
2763
2764   /* Zero if R_ARM_TARGET1 means R_ARM_ABS32.
2765      Nonzero if R_ARM_TARGET1 means R_ARM_REL32.  */
2766   int target1_is_rel;
2767
2768   /* The relocation to use for R_ARM_TARGET2 relocations.  */
2769   int target2_reloc;
2770
2771   /* 0 = Ignore R_ARM_V4BX.
2772      1 = Convert BX to MOV PC.
2773      2 = Generate v4 interworing stubs.  */
2774   int fix_v4bx;
2775
2776   /* Whether we should fix the Cortex-A8 Thumb-2 branch/TLB erratum.  */
2777   int fix_cortex_a8;
2778
2779   /* Whether we should fix the ARM1176 BLX immediate issue.  */
2780   int fix_arm1176;
2781
2782   /* Nonzero if the ARM/Thumb BLX instructions are available for use.  */
2783   int use_blx;
2784
2785   /* What sort of code sequences we should look for which may trigger the
2786      VFP11 denorm erratum.  */
2787   bfd_arm_vfp11_fix vfp11_fix;
2788
2789   /* Global counter for the number of fixes we have emitted.  */
2790   int num_vfp11_fixes;
2791
2792   /* Nonzero to force PIC branch veneers.  */
2793   int pic_veneer;
2794
2795   /* The number of bytes in the initial entry in the PLT.  */
2796   bfd_size_type plt_header_size;
2797
2798   /* The number of bytes in the subsequent PLT etries.  */
2799   bfd_size_type plt_entry_size;
2800
2801   /* True if the target system is VxWorks.  */
2802   int vxworks_p;
2803
2804   /* True if the target system is Symbian OS.  */
2805   int symbian_p;
2806
2807   /* True if the target uses REL relocations.  */
2808   int use_rel;
2809
2810   /* The index of the next unused R_ARM_TLS_DESC slot in .rel.plt.  */
2811   bfd_vma next_tls_desc_index;
2812
2813   /* How many R_ARM_TLS_DESC relocations were generated so far.  */
2814   bfd_vma num_tls_desc;
2815
2816   /* Short-cuts to get to dynamic linker sections.  */
2817   asection *sdynbss;
2818   asection *srelbss;
2819
2820   /* The (unloaded but important) VxWorks .rela.plt.unloaded section.  */
2821   asection *srelplt2;
2822
2823   /* The offset into splt of the PLT entry for the TLS descriptor
2824      resolver.  Special values are 0, if not necessary (or not found
2825      to be necessary yet), and -1 if needed but not determined
2826      yet.  */
2827   bfd_vma dt_tlsdesc_plt;
2828
2829   /* The offset into sgot of the GOT entry used by the PLT entry
2830      above.  */
2831   bfd_vma dt_tlsdesc_got;
2832
2833   /* Offset in .plt section of tls_arm_trampoline.  */
2834   bfd_vma tls_trampoline;
2835
2836   /* Data for R_ARM_TLS_LDM32 relocations.  */
2837   union
2838   {
2839     bfd_signed_vma refcount;
2840     bfd_vma offset;
2841   } tls_ldm_got;
2842
2843   /* Small local sym cache.  */
2844   struct sym_cache sym_cache;
2845
2846   /* For convenience in allocate_dynrelocs.  */
2847   bfd * obfd;
2848
2849   /* The amount of space used by the reserved portion of the sgotplt
2850      section, plus whatever space is used by the jump slots.  */
2851   bfd_vma sgotplt_jump_table_size;
2852
2853   /* The stub hash table.  */
2854   struct bfd_hash_table stub_hash_table;
2855
2856   /* Linker stub bfd.  */
2857   bfd *stub_bfd;
2858
2859   /* Linker call-backs.  */
2860   asection * (*add_stub_section) (const char *, asection *);
2861   void (*layout_sections_again) (void);
2862
2863   /* Array to keep track of which stub sections have been created, and
2864      information on stub grouping.  */
2865   struct map_stub *stub_group;
2866
2867   /* Number of elements in stub_group.  */
2868   int top_id;
2869
2870   /* Assorted information used by elf32_arm_size_stubs.  */
2871   unsigned int bfd_count;
2872   int top_index;
2873   asection **input_list;
2874 };
2875
2876 /* Create an entry in an ARM ELF linker hash table.  */
2877
2878 static struct bfd_hash_entry *
2879 elf32_arm_link_hash_newfunc (struct bfd_hash_entry * entry,
2880                              struct bfd_hash_table * table,
2881                              const char * string)
2882 {
2883   struct elf32_arm_link_hash_entry * ret =
2884     (struct elf32_arm_link_hash_entry *) entry;
2885
2886   /* Allocate the structure if it has not already been allocated by a
2887      subclass.  */
2888   if (ret == NULL)
2889     ret = (struct elf32_arm_link_hash_entry *)
2890         bfd_hash_allocate (table, sizeof (struct elf32_arm_link_hash_entry));
2891   if (ret == NULL)
2892     return (struct bfd_hash_entry *) ret;
2893
2894   /* Call the allocation method of the superclass.  */
2895   ret = ((struct elf32_arm_link_hash_entry *)
2896          _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
2897                                      table, string));
2898   if (ret != NULL)
2899     {
2900       ret->dyn_relocs = NULL;
2901       ret->tls_type = GOT_UNKNOWN;
2902       ret->tlsdesc_got = (bfd_vma) -1;
2903       ret->plt.thumb_refcount = 0;
2904       ret->plt.maybe_thumb_refcount = 0;
2905       ret->plt.noncall_refcount = 0;
2906       ret->plt.got_offset = -1;
2907       ret->is_iplt = FALSE;
2908       ret->export_glue = NULL;
2909
2910       ret->stub_cache = NULL;
2911     }
2912
2913   return (struct bfd_hash_entry *) ret;
2914 }
2915
2916 /* Ensure that we have allocated bookkeeping structures for ABFD's local
2917    symbols.  */
2918
2919 static bfd_boolean
2920 elf32_arm_allocate_local_sym_info (bfd *abfd)
2921 {
2922   if (elf_local_got_refcounts (abfd) == NULL)
2923     {
2924       bfd_size_type num_syms;
2925       bfd_size_type size;
2926       char *data;
2927
2928       num_syms = elf_tdata (abfd)->symtab_hdr.sh_info;
2929       size = num_syms * (sizeof (bfd_signed_vma)
2930                          + sizeof (struct arm_local_iplt_info *)
2931                          + sizeof (bfd_vma)
2932                          + sizeof (char));
2933       data = bfd_zalloc (abfd, size);
2934       if (data == NULL)
2935         return FALSE;
2936
2937       elf_local_got_refcounts (abfd) = (bfd_signed_vma *) data;
2938       data += num_syms * sizeof (bfd_signed_vma);
2939
2940       elf32_arm_local_iplt (abfd) = (struct arm_local_iplt_info **) data;
2941       data += num_syms * sizeof (struct arm_local_iplt_info *);
2942
2943       elf32_arm_local_tlsdesc_gotent (abfd) = (bfd_vma *) data;
2944       data += num_syms * sizeof (bfd_vma);
2945
2946       elf32_arm_local_got_tls_type (abfd) = data;
2947     }
2948   return TRUE;
2949 }
2950
2951 /* Return the .iplt information for local symbol R_SYMNDX, which belongs
2952    to input bfd ABFD.  Create the information if it doesn't already exist.
2953    Return null if an allocation fails.  */
2954
2955 static struct arm_local_iplt_info *
2956 elf32_arm_create_local_iplt (bfd *abfd, unsigned long r_symndx)
2957 {
2958   struct arm_local_iplt_info **ptr;
2959
2960   if (!elf32_arm_allocate_local_sym_info (abfd))
2961     return NULL;
2962
2963   BFD_ASSERT (r_symndx < elf_tdata (abfd)->symtab_hdr.sh_info);
2964   ptr = &elf32_arm_local_iplt (abfd)[r_symndx];
2965   if (*ptr == NULL)
2966     *ptr = bfd_zalloc (abfd, sizeof (**ptr));
2967   return *ptr;
2968 }
2969
2970 /* Try to obtain PLT information for the symbol with index R_SYMNDX
2971    in ABFD's symbol table.  If the symbol is global, H points to its
2972    hash table entry, otherwise H is null.
2973
2974    Return true if the symbol does have PLT information.  When returning
2975    true, point *ROOT_PLT at the target-independent reference count/offset
2976    union and *ARM_PLT at the ARM-specific information.  */
2977
2978 static bfd_boolean
2979 elf32_arm_get_plt_info (bfd *abfd, struct elf32_arm_link_hash_entry *h,
2980                         unsigned long r_symndx, union gotplt_union **root_plt,
2981                         struct arm_plt_info **arm_plt)
2982 {
2983   struct arm_local_iplt_info *local_iplt;
2984
2985   if (h != NULL)
2986     {
2987       *root_plt = &h->root.plt;
2988       *arm_plt = &h->plt;
2989       return TRUE;
2990     }
2991
2992   if (elf32_arm_local_iplt (abfd) == NULL)
2993     return FALSE;
2994
2995   local_iplt = elf32_arm_local_iplt (abfd)[r_symndx];
2996   if (local_iplt == NULL)
2997     return FALSE;
2998
2999   *root_plt = &local_iplt->root;
3000   *arm_plt = &local_iplt->arm;
3001   return TRUE;
3002 }
3003
3004 /* Return true if the PLT described by ARM_PLT requires a Thumb stub
3005    before it.  */
3006
3007 static bfd_boolean
3008 elf32_arm_plt_needs_thumb_stub_p (struct bfd_link_info *info,
3009                                   struct arm_plt_info *arm_plt)
3010 {
3011   struct elf32_arm_link_hash_table *htab;
3012
3013   htab = elf32_arm_hash_table (info);
3014   return (arm_plt->thumb_refcount != 0
3015           || (!htab->use_blx && arm_plt->maybe_thumb_refcount != 0));
3016 }
3017
3018 /* Return a pointer to the head of the dynamic reloc list that should
3019    be used for local symbol ISYM, which is symbol number R_SYMNDX in
3020    ABFD's symbol table.  Return null if an error occurs.  */
3021
3022 static struct elf_dyn_relocs **
3023 elf32_arm_get_local_dynreloc_list (bfd *abfd, unsigned long r_symndx,
3024                                    Elf_Internal_Sym *isym)
3025 {
3026   if (ELF32_ST_TYPE (isym->st_info) == STT_GNU_IFUNC)
3027     {
3028       struct arm_local_iplt_info *local_iplt;
3029
3030       local_iplt = elf32_arm_create_local_iplt (abfd, r_symndx);
3031       if (local_iplt == NULL)
3032         return NULL;
3033       return &local_iplt->dyn_relocs;
3034     }
3035   else
3036     {
3037       /* Track dynamic relocs needed for local syms too.
3038          We really need local syms available to do this
3039          easily.  Oh well.  */
3040       asection *s;
3041       void *vpp;
3042
3043       s = bfd_section_from_elf_index (abfd, isym->st_shndx);
3044       if (s == NULL)
3045         abort ();
3046
3047       vpp = &elf_section_data (s)->local_dynrel;
3048       return (struct elf_dyn_relocs **) vpp;
3049     }
3050 }
3051
3052 /* Initialize an entry in the stub hash table.  */
3053
3054 static struct bfd_hash_entry *
3055 stub_hash_newfunc (struct bfd_hash_entry *entry,
3056                    struct bfd_hash_table *table,
3057                    const char *string)
3058 {
3059   /* Allocate the structure if it has not already been allocated by a
3060      subclass.  */
3061   if (entry == NULL)
3062     {
3063       entry = (struct bfd_hash_entry *)
3064           bfd_hash_allocate (table, sizeof (struct elf32_arm_stub_hash_entry));
3065       if (entry == NULL)
3066         return entry;
3067     }
3068
3069   /* Call the allocation method of the superclass.  */
3070   entry = bfd_hash_newfunc (entry, table, string);
3071   if (entry != NULL)
3072     {
3073       struct elf32_arm_stub_hash_entry *eh;
3074
3075       /* Initialize the local fields.  */
3076       eh = (struct elf32_arm_stub_hash_entry *) entry;
3077       eh->stub_sec = NULL;
3078       eh->stub_offset = 0;
3079       eh->target_value = 0;
3080       eh->target_section = NULL;
3081       eh->target_addend = 0;
3082       eh->orig_insn = 0;
3083       eh->stub_type = arm_stub_none;
3084       eh->stub_size = 0;
3085       eh->stub_template = NULL;
3086       eh->stub_template_size = 0;
3087       eh->h = NULL;
3088       eh->id_sec = NULL;
3089       eh->output_name = NULL;
3090     }
3091
3092   return entry;
3093 }
3094
3095 /* Create .got, .gotplt, and .rel(a).got sections in DYNOBJ, and set up
3096    shortcuts to them in our hash table.  */
3097
3098 static bfd_boolean
3099 create_got_section (bfd *dynobj, struct bfd_link_info *info)
3100 {
3101   struct elf32_arm_link_hash_table *htab;
3102
3103   htab = elf32_arm_hash_table (info);
3104   if (htab == NULL)
3105     return FALSE;
3106
3107   /* BPABI objects never have a GOT, or associated sections.  */
3108   if (htab->symbian_p)
3109     return TRUE;
3110
3111   if (! _bfd_elf_create_got_section (dynobj, info))
3112     return FALSE;
3113
3114   return TRUE;
3115 }
3116
3117 /* Create the .iplt, .rel(a).iplt and .igot.plt sections.  */
3118
3119 static bfd_boolean
3120 create_ifunc_sections (struct bfd_link_info *info)
3121 {
3122   struct elf32_arm_link_hash_table *htab;
3123   const struct elf_backend_data *bed;
3124   bfd *dynobj;
3125   asection *s;
3126   flagword flags;
3127
3128   htab = elf32_arm_hash_table (info);
3129   dynobj = htab->root.dynobj;
3130   bed = get_elf_backend_data (dynobj);
3131   flags = bed->dynamic_sec_flags;
3132
3133   if (htab->root.iplt == NULL)
3134     {
3135       s = bfd_make_section_with_flags (dynobj, ".iplt",
3136                                        flags | SEC_READONLY | SEC_CODE);
3137       if (s == NULL
3138           || !bfd_set_section_alignment (abfd, s, bed->plt_alignment))
3139         return FALSE;
3140       htab->root.iplt = s;
3141     }
3142
3143   if (htab->root.irelplt == NULL)
3144     {
3145       s = bfd_make_section_with_flags (dynobj, RELOC_SECTION (htab, ".iplt"),
3146                                        flags | SEC_READONLY);
3147       if (s == NULL
3148           || !bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
3149         return FALSE;
3150       htab->root.irelplt = s;
3151     }
3152
3153   if (htab->root.igotplt == NULL)
3154     {
3155       s = bfd_make_section_with_flags (dynobj, ".igot.plt", flags);
3156       if (s == NULL
3157           || !bfd_set_section_alignment (dynobj, s, bed->s->log_file_align))
3158         return FALSE;
3159       htab->root.igotplt = s;
3160     }
3161   return TRUE;
3162 }
3163
3164 /* Create .plt, .rel(a).plt, .got, .got.plt, .rel(a).got, .dynbss, and
3165    .rel(a).bss sections in DYNOBJ, and set up shortcuts to them in our
3166    hash table.  */
3167
3168 static bfd_boolean
3169 elf32_arm_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
3170 {
3171   struct elf32_arm_link_hash_table *htab;
3172
3173   htab = elf32_arm_hash_table (info);
3174   if (htab == NULL)
3175     return FALSE;
3176
3177   if (!htab->root.sgot && !create_got_section (dynobj, info))
3178     return FALSE;
3179
3180   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
3181     return FALSE;
3182
3183   htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
3184   if (!info->shared)
3185     htab->srelbss = bfd_get_section_by_name (dynobj,
3186                                              RELOC_SECTION (htab, ".bss"));
3187
3188   if (htab->vxworks_p)
3189     {
3190       if (!elf_vxworks_create_dynamic_sections (dynobj, info, &htab->srelplt2))
3191         return FALSE;
3192
3193       if (info->shared)
3194         {
3195           htab->plt_header_size = 0;
3196           htab->plt_entry_size
3197             = 4 * ARRAY_SIZE (elf32_arm_vxworks_shared_plt_entry);
3198         }
3199       else
3200         {
3201           htab->plt_header_size
3202             = 4 * ARRAY_SIZE (elf32_arm_vxworks_exec_plt0_entry);
3203           htab->plt_entry_size
3204             = 4 * ARRAY_SIZE (elf32_arm_vxworks_exec_plt_entry);
3205         }
3206     }
3207
3208   if (!htab->root.splt
3209       || !htab->root.srelplt
3210       || !htab->sdynbss
3211       || (!info->shared && !htab->srelbss))
3212     abort ();
3213
3214   return TRUE;
3215 }
3216
3217 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
3218
3219 static void
3220 elf32_arm_copy_indirect_symbol (struct bfd_link_info *info,
3221                                 struct elf_link_hash_entry *dir,
3222                                 struct elf_link_hash_entry *ind)
3223 {
3224   struct elf32_arm_link_hash_entry *edir, *eind;
3225
3226   edir = (struct elf32_arm_link_hash_entry *) dir;
3227   eind = (struct elf32_arm_link_hash_entry *) ind;
3228
3229   if (eind->dyn_relocs != NULL)
3230     {
3231       if (edir->dyn_relocs != NULL)
3232         {
3233           struct elf_dyn_relocs **pp;
3234           struct elf_dyn_relocs *p;
3235
3236           /* Add reloc counts against the indirect sym to the direct sym
3237              list.  Merge any entries against the same section.  */
3238           for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
3239             {
3240               struct elf_dyn_relocs *q;
3241
3242               for (q = edir->dyn_relocs; q != NULL; q = q->next)
3243                 if (q->sec == p->sec)
3244                   {
3245                     q->pc_count += p->pc_count;
3246                     q->count += p->count;
3247                     *pp = p->next;
3248                     break;
3249                   }
3250               if (q == NULL)
3251                 pp = &p->next;
3252             }
3253           *pp = edir->dyn_relocs;
3254         }
3255
3256       edir->dyn_relocs = eind->dyn_relocs;
3257       eind->dyn_relocs = NULL;
3258     }
3259
3260   if (ind->root.type == bfd_link_hash_indirect)
3261     {
3262       /* Copy over PLT info.  */
3263       edir->plt.thumb_refcount += eind->plt.thumb_refcount;
3264       eind->plt.thumb_refcount = 0;
3265       edir->plt.maybe_thumb_refcount += eind->plt.maybe_thumb_refcount;
3266       eind->plt.maybe_thumb_refcount = 0;
3267       edir->plt.noncall_refcount += eind->plt.noncall_refcount;
3268       eind->plt.noncall_refcount = 0;
3269
3270       /* We should only allocate a function to .iplt once the final
3271          symbol information is known.  */
3272       BFD_ASSERT (!eind->is_iplt);
3273
3274       if (dir->got.refcount <= 0)
3275         {
3276           edir->tls_type = eind->tls_type;
3277           eind->tls_type = GOT_UNKNOWN;
3278         }
3279     }
3280
3281   _bfd_elf_link_hash_copy_indirect (info, dir, ind);
3282 }
3283
3284 /* Create an ARM elf linker hash table.  */
3285
3286 static struct bfd_link_hash_table *
3287 elf32_arm_link_hash_table_create (bfd *abfd)
3288 {
3289   struct elf32_arm_link_hash_table *ret;
3290   bfd_size_type amt = sizeof (struct elf32_arm_link_hash_table);
3291
3292   ret = (struct elf32_arm_link_hash_table *) bfd_malloc (amt);
3293   if (ret == NULL)
3294     return NULL;
3295
3296   if (!_bfd_elf_link_hash_table_init (& ret->root, abfd,
3297                                       elf32_arm_link_hash_newfunc,
3298                                       sizeof (struct elf32_arm_link_hash_entry),
3299                                       ARM_ELF_DATA))
3300     {
3301       free (ret);
3302       return NULL;
3303     }
3304
3305   ret->sdynbss = NULL;
3306   ret->srelbss = NULL;
3307   ret->srelplt2 = NULL;
3308   ret->dt_tlsdesc_plt = 0;
3309   ret->dt_tlsdesc_got = 0;
3310   ret->tls_trampoline = 0;
3311   ret->next_tls_desc_index = 0;
3312   ret->num_tls_desc = 0;
3313   ret->thumb_glue_size = 0;
3314   ret->arm_glue_size = 0;
3315   ret->bx_glue_size = 0;
3316   memset (ret->bx_glue_offset, 0, sizeof (ret->bx_glue_offset));
3317   ret->vfp11_fix = BFD_ARM_VFP11_FIX_NONE;
3318   ret->vfp11_erratum_glue_size = 0;
3319   ret->num_vfp11_fixes = 0;
3320   ret->fix_cortex_a8 = 0;
3321   ret->fix_arm1176 = 0;
3322   ret->bfd_of_glue_owner = NULL;
3323   ret->byteswap_code = 0;
3324   ret->target1_is_rel = 0;
3325   ret->target2_reloc = R_ARM_NONE;
3326 #ifdef FOUR_WORD_PLT
3327   ret->plt_header_size = 16;
3328   ret->plt_entry_size = 16;
3329 #else
3330   ret->plt_header_size = 20;
3331   ret->plt_entry_size = 12;
3332 #endif
3333   ret->fix_v4bx = 0;
3334   ret->use_blx = 0;
3335   ret->vxworks_p = 0;
3336   ret->symbian_p = 0;
3337   ret->use_rel = 1;
3338   ret->sym_cache.abfd = NULL;
3339   ret->obfd = abfd;
3340   ret->tls_ldm_got.refcount = 0;
3341   ret->stub_bfd = NULL;
3342   ret->add_stub_section = NULL;
3343   ret->layout_sections_again = NULL;
3344   ret->stub_group = NULL;
3345   ret->top_id = 0;
3346   ret->bfd_count = 0;
3347   ret->top_index = 0;
3348   ret->input_list = NULL;
3349
3350   if (!bfd_hash_table_init (&ret->stub_hash_table, stub_hash_newfunc,
3351                             sizeof (struct elf32_arm_stub_hash_entry)))
3352     {
3353       free (ret);
3354       return NULL;
3355     }
3356
3357   return &ret->root.root;
3358 }
3359
3360 /* Free the derived linker hash table.  */
3361
3362 static void
3363 elf32_arm_hash_table_free (struct bfd_link_hash_table *hash)
3364 {
3365   struct elf32_arm_link_hash_table *ret
3366     = (struct elf32_arm_link_hash_table *) hash;
3367
3368   bfd_hash_table_free (&ret->stub_hash_table);
3369   _bfd_generic_link_hash_table_free (hash);
3370 }
3371
3372 /* Determine if we're dealing with a Thumb only architecture.  */
3373
3374 static bfd_boolean
3375 using_thumb_only (struct elf32_arm_link_hash_table *globals)
3376 {
3377   int arch = bfd_elf_get_obj_attr_int (globals->obfd, OBJ_ATTR_PROC,
3378                                        Tag_CPU_arch);
3379   int profile;
3380
3381   if (arch == TAG_CPU_ARCH_V6_M || arch == TAG_CPU_ARCH_V6S_M)
3382     return TRUE;
3383
3384   if (arch != TAG_CPU_ARCH_V7 && arch != TAG_CPU_ARCH_V7E_M)
3385     return FALSE;
3386
3387   profile = bfd_elf_get_obj_attr_int (globals->obfd, OBJ_ATTR_PROC,
3388                                       Tag_CPU_arch_profile);
3389
3390   return profile == 'M';
3391 }
3392
3393 /* Determine if we're dealing with a Thumb-2 object.  */
3394
3395 static bfd_boolean
3396 using_thumb2 (struct elf32_arm_link_hash_table *globals)
3397 {
3398   int arch = bfd_elf_get_obj_attr_int (globals->obfd, OBJ_ATTR_PROC,
3399                                        Tag_CPU_arch);
3400   return arch == TAG_CPU_ARCH_V6T2 || arch >= TAG_CPU_ARCH_V7;
3401 }
3402
3403 /* Determine what kind of NOPs are available.  */
3404
3405 static bfd_boolean
3406 arch_has_arm_nop (struct elf32_arm_link_hash_table *globals)
3407 {
3408   const int arch = bfd_elf_get_obj_attr_int (globals->obfd, OBJ_ATTR_PROC,
3409                                              Tag_CPU_arch);
3410   return arch == TAG_CPU_ARCH_V6T2
3411          || arch == TAG_CPU_ARCH_V6K
3412          || arch == TAG_CPU_ARCH_V7
3413          || arch == TAG_CPU_ARCH_V7E_M;
3414 }
3415
3416 static bfd_boolean
3417 arch_has_thumb2_nop (struct elf32_arm_link_hash_table *globals)
3418 {
3419   const int arch = bfd_elf_get_obj_attr_int (globals->obfd, OBJ_ATTR_PROC,
3420                                              Tag_CPU_arch);
3421   return (arch == TAG_CPU_ARCH_V6T2 || arch == TAG_CPU_ARCH_V7
3422           || arch == TAG_CPU_ARCH_V7E_M);
3423 }
3424
3425 static bfd_boolean
3426 arm_stub_is_thumb (enum elf32_arm_stub_type stub_type)
3427 {
3428   switch (stub_type)
3429     {
3430     case arm_stub_long_branch_thumb_only:
3431     case arm_stub_long_branch_v4t_thumb_arm:
3432     case arm_stub_short_branch_v4t_thumb_arm:
3433     case arm_stub_long_branch_v4t_thumb_arm_pic:
3434     case arm_stub_long_branch_v4t_thumb_tls_pic:
3435     case arm_stub_long_branch_thumb_only_pic:
3436       return TRUE;
3437     case arm_stub_none:
3438       BFD_FAIL ();
3439       return FALSE;
3440       break;
3441     default:
3442       return FALSE;
3443     }
3444 }
3445
3446 /* Determine the type of stub needed, if any, for a call.  */
3447
3448 static enum elf32_arm_stub_type
3449 arm_type_of_stub (struct bfd_link_info *info,
3450                   asection *input_sec,
3451                   const Elf_Internal_Rela *rel,
3452                   unsigned char st_type,
3453                   enum arm_st_branch_type *actual_branch_type,
3454                   struct elf32_arm_link_hash_entry *hash,
3455                   bfd_vma destination,
3456                   asection *sym_sec,
3457                   bfd *input_bfd,
3458                   const char *name)
3459 {
3460   bfd_vma location;
3461   bfd_signed_vma branch_offset;
3462   unsigned int r_type;
3463   struct elf32_arm_link_hash_table * globals;
3464   int thumb2;
3465   int thumb_only;
3466   enum elf32_arm_stub_type stub_type = arm_stub_none;
3467   int use_plt = 0;
3468   enum arm_st_branch_type branch_type = *actual_branch_type;
3469   union gotplt_union *root_plt;
3470   struct arm_plt_info *arm_plt;
3471
3472   if (branch_type == ST_BRANCH_LONG)
3473     return stub_type;
3474
3475   globals = elf32_arm_hash_table (info);
3476   if (globals == NULL)
3477     return stub_type;
3478
3479   thumb_only = using_thumb_only (globals);
3480
3481   thumb2 = using_thumb2 (globals);
3482
3483   /* Determine where the call point is.  */
3484   location = (input_sec->output_offset
3485               + input_sec->output_section->vma
3486               + rel->r_offset);
3487
3488   r_type = ELF32_R_TYPE (rel->r_info);
3489
3490   /* For TLS call relocs, it is the caller's responsibility to provide
3491      the address of the appropriate trampoline.  */
3492   if (r_type != R_ARM_TLS_CALL
3493       && r_type != R_ARM_THM_TLS_CALL
3494       && elf32_arm_get_plt_info (input_bfd, hash, ELF32_R_SYM (rel->r_info),
3495                                  &root_plt, &arm_plt)
3496       && root_plt->offset != (bfd_vma) -1)
3497     {
3498       asection *splt;
3499
3500       if (hash == NULL || hash->is_iplt)
3501         splt = globals->root.iplt;
3502       else
3503         splt = globals->root.splt;
3504       if (splt != NULL)
3505         {
3506           use_plt = 1;
3507
3508           /* Note when dealing with PLT entries: the main PLT stub is in
3509              ARM mode, so if the branch is in Thumb mode, another
3510              Thumb->ARM stub will be inserted later just before the ARM
3511              PLT stub. We don't take this extra distance into account
3512              here, because if a long branch stub is needed, we'll add a
3513              Thumb->Arm one and branch directly to the ARM PLT entry
3514              because it avoids spreading offset corrections in several
3515              places.  */
3516
3517           destination = (splt->output_section->vma
3518                          + splt->output_offset
3519                          + root_plt->offset);
3520           st_type = STT_FUNC;
3521           branch_type = ST_BRANCH_TO_ARM;
3522         }
3523     }
3524   /* Calls to STT_GNU_IFUNC symbols should go through a PLT.  */
3525   BFD_ASSERT (st_type != STT_GNU_IFUNC);
3526
3527   branch_offset = (bfd_signed_vma)(destination - location);
3528
3529   if (r_type == R_ARM_THM_CALL || r_type == R_ARM_THM_JUMP24
3530       || r_type == R_ARM_THM_TLS_CALL)
3531     {
3532       /* Handle cases where:
3533          - this call goes too far (different Thumb/Thumb2 max
3534            distance)
3535          - it's a Thumb->Arm call and blx is not available, or it's a
3536            Thumb->Arm branch (not bl). A stub is needed in this case,
3537            but only if this call is not through a PLT entry. Indeed,
3538            PLT stubs handle mode switching already.
3539       */
3540       if ((!thumb2
3541             && (branch_offset > THM_MAX_FWD_BRANCH_OFFSET
3542                 || (branch_offset < THM_MAX_BWD_BRANCH_OFFSET)))
3543           || (thumb2
3544               && (branch_offset > THM2_MAX_FWD_BRANCH_OFFSET
3545                   || (branch_offset < THM2_MAX_BWD_BRANCH_OFFSET)))
3546           || (branch_type == ST_BRANCH_TO_ARM
3547               && (((r_type == R_ARM_THM_CALL
3548                     || r_type == R_ARM_THM_TLS_CALL) && !globals->use_blx)
3549                   || (r_type == R_ARM_THM_JUMP24))
3550               && !use_plt))
3551         {
3552           if (branch_type == ST_BRANCH_TO_THUMB)
3553             {
3554               /* Thumb to thumb.  */
3555               if (!thumb_only)
3556                 {
3557                   stub_type = (info->shared | globals->pic_veneer)
3558                     /* PIC stubs.  */
3559                     ? ((globals->use_blx
3560                         && (r_type ==R_ARM_THM_CALL))
3561                        /* V5T and above. Stub starts with ARM code, so
3562                           we must be able to switch mode before
3563                           reaching it, which is only possible for 'bl'
3564                           (ie R_ARM_THM_CALL relocation).  */
3565                        ? arm_stub_long_branch_any_thumb_pic
3566                        /* On V4T, use Thumb code only.  */
3567                        : arm_stub_long_branch_v4t_thumb_thumb_pic)
3568
3569                     /* non-PIC stubs.  */
3570                     : ((globals->use_blx
3571                         && (r_type ==R_ARM_THM_CALL))
3572                        /* V5T and above.  */
3573                        ? arm_stub_long_branch_any_any
3574                        /* V4T.  */
3575                        : arm_stub_long_branch_v4t_thumb_thumb);
3576                 }
3577               else
3578                 {
3579                   stub_type = (info->shared | globals->pic_veneer)
3580                     /* PIC stub.  */
3581                     ? arm_stub_long_branch_thumb_only_pic
3582                     /* non-PIC stub.  */
3583                     : arm_stub_long_branch_thumb_only;
3584                 }
3585             }
3586           else
3587             {
3588               /* Thumb to arm.  */
3589               if (sym_sec != NULL
3590                   && sym_sec->owner != NULL
3591                   && !INTERWORK_FLAG (sym_sec->owner))
3592                 {
3593                   (*_bfd_error_handler)
3594                     (_("%B(%s): warning: interworking not enabled.\n"
3595                        "  first occurrence: %B: Thumb call to ARM"),
3596                      sym_sec->owner, input_bfd, name);
3597                 }
3598
3599               stub_type =
3600                 (info->shared | globals->pic_veneer)
3601                 /* PIC stubs.  */
3602                 ? (r_type == R_ARM_THM_TLS_CALL
3603                    /* TLS PIC stubs */
3604                    ? (globals->use_blx ? arm_stub_long_branch_any_tls_pic
3605                       : arm_stub_long_branch_v4t_thumb_tls_pic)
3606                    : ((globals->use_blx && r_type == R_ARM_THM_CALL)
3607                       /* V5T PIC and above.  */
3608                       ? arm_stub_long_branch_any_arm_pic
3609                       /* V4T PIC stub.  */
3610                       : arm_stub_long_branch_v4t_thumb_arm_pic))
3611
3612                 /* non-PIC stubs.  */
3613                 : ((globals->use_blx && r_type == R_ARM_THM_CALL)
3614                    /* V5T and above.  */
3615                    ? arm_stub_long_branch_any_any
3616                    /* V4T.  */
3617                    : arm_stub_long_branch_v4t_thumb_arm);
3618
3619               /* Handle v4t short branches.  */
3620               if ((stub_type == arm_stub_long_branch_v4t_thumb_arm)
3621                   && (branch_offset <= THM_MAX_FWD_BRANCH_OFFSET)
3622                   && (branch_offset >= THM_MAX_BWD_BRANCH_OFFSET))
3623                 stub_type = arm_stub_short_branch_v4t_thumb_arm;
3624             }
3625         }
3626     }
3627   else if (r_type == R_ARM_CALL
3628            || r_type == R_ARM_JUMP24
3629            || r_type == R_ARM_PLT32
3630            || r_type == R_ARM_TLS_CALL)
3631     {
3632       if (branch_type == ST_BRANCH_TO_THUMB)
3633         {
3634           /* Arm to thumb.  */
3635
3636           if (sym_sec != NULL
3637               && sym_sec->owner != NULL
3638               && !INTERWORK_FLAG (sym_sec->owner))
3639             {
3640               (*_bfd_error_handler)
3641                 (_("%B(%s): warning: interworking not enabled.\n"
3642                    "  first occurrence: %B: ARM call to Thumb"),
3643                  sym_sec->owner, input_bfd, name);
3644             }
3645
3646           /* We have an extra 2-bytes reach because of
3647              the mode change (bit 24 (H) of BLX encoding).  */
3648           if (branch_offset > (ARM_MAX_FWD_BRANCH_OFFSET + 2)
3649               || (branch_offset < ARM_MAX_BWD_BRANCH_OFFSET)
3650               || (r_type == R_ARM_CALL && !globals->use_blx)
3651               || (r_type == R_ARM_JUMP24)
3652               || (r_type == R_ARM_PLT32))
3653             {
3654               stub_type = (info->shared | globals->pic_veneer)
3655                 /* PIC stubs.  */
3656                 ? ((globals->use_blx)
3657                    /* V5T and above.  */
3658                    ? arm_stub_long_branch_any_thumb_pic
3659                    /* V4T stub.  */
3660                    : arm_stub_long_branch_v4t_arm_thumb_pic)
3661
3662                 /* non-PIC stubs.  */
3663                 : ((globals->use_blx)
3664                    /* V5T and above.  */
3665                    ? arm_stub_long_branch_any_any
3666                    /* V4T.  */
3667                    : arm_stub_long_branch_v4t_arm_thumb);
3668             }
3669         }
3670       else
3671         {
3672           /* Arm to arm.  */
3673           if (branch_offset > ARM_MAX_FWD_BRANCH_OFFSET
3674               || (branch_offset < ARM_MAX_BWD_BRANCH_OFFSET))
3675             {
3676               stub_type =
3677                 (info->shared | globals->pic_veneer)
3678                 /* PIC stubs.  */
3679                 ? (r_type == R_ARM_TLS_CALL
3680                    /* TLS PIC Stub */
3681                    ? arm_stub_long_branch_any_tls_pic
3682                    : arm_stub_long_branch_any_arm_pic)
3683                 /* non-PIC stubs.  */
3684                 : arm_stub_long_branch_any_any;
3685             }
3686         }
3687     }
3688
3689   /* If a stub is needed, record the actual destination type.  */
3690   if (stub_type != arm_stub_none)
3691     *actual_branch_type = branch_type;
3692
3693   return stub_type;
3694 }
3695
3696 /* Build a name for an entry in the stub hash table.  */
3697
3698 static char *
3699 elf32_arm_stub_name (const asection *input_section,
3700                      const asection *sym_sec,
3701                      const struct elf32_arm_link_hash_entry *hash,
3702                      const Elf_Internal_Rela *rel,
3703                      enum elf32_arm_stub_type stub_type)
3704 {
3705   char *stub_name;
3706   bfd_size_type len;
3707
3708   if (hash)
3709     {
3710       len = 8 + 1 + strlen (hash->root.root.root.string) + 1 + 8 + 1 + 2 + 1;
3711       stub_name = (char *) bfd_malloc (len);
3712       if (stub_name != NULL)
3713         sprintf (stub_name, "%08x_%s+%x_%d",
3714                  input_section->id & 0xffffffff,
3715                  hash->root.root.root.string,
3716                  (int) rel->r_addend & 0xffffffff,
3717                  (int) stub_type);
3718     }
3719   else
3720     {
3721       len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1 + 2 + 1;
3722       stub_name = (char *) bfd_malloc (len);
3723       if (stub_name != NULL)
3724         sprintf (stub_name, "%08x_%x:%x+%x_%d",
3725                  input_section->id & 0xffffffff,
3726                  sym_sec->id & 0xffffffff,
3727                  ELF32_R_TYPE (rel->r_info) == R_ARM_TLS_CALL
3728                  || ELF32_R_TYPE (rel->r_info) == R_ARM_THM_TLS_CALL
3729                  ? 0 : (int) ELF32_R_SYM (rel->r_info) & 0xffffffff,
3730                  (int) rel->r_addend & 0xffffffff,
3731                  (int) stub_type);
3732     }
3733
3734   return stub_name;
3735 }
3736
3737 /* Look up an entry in the stub hash.  Stub entries are cached because
3738    creating the stub name takes a bit of time.  */
3739
3740 static struct elf32_arm_stub_hash_entry *
3741 elf32_arm_get_stub_entry (const asection *input_section,
3742                           const asection *sym_sec,
3743                           struct elf_link_hash_entry *hash,
3744                           const Elf_Internal_Rela *rel,
3745                           struct elf32_arm_link_hash_table *htab,
3746                           enum elf32_arm_stub_type stub_type)
3747 {
3748   struct elf32_arm_stub_hash_entry *stub_entry;
3749   struct elf32_arm_link_hash_entry *h = (struct elf32_arm_link_hash_entry *) hash;
3750   const asection *id_sec;
3751
3752   if ((input_section->flags & SEC_CODE) == 0)
3753     return NULL;
3754
3755   /* If this input section is part of a group of sections sharing one
3756      stub section, then use the id of the first section in the group.
3757      Stub names need to include a section id, as there may well be
3758      more than one stub used to reach say, printf, and we need to
3759      distinguish between them.  */
3760   id_sec = htab->stub_group[input_section->id].link_sec;
3761
3762   if (h != NULL && h->stub_cache != NULL
3763       && h->stub_cache->h == h
3764       && h->stub_cache->id_sec == id_sec
3765       && h->stub_cache->stub_type == stub_type)
3766     {
3767       stub_entry = h->stub_cache;
3768     }
3769   else
3770     {
3771       char *stub_name;
3772
3773       stub_name = elf32_arm_stub_name (id_sec, sym_sec, h, rel, stub_type);
3774       if (stub_name == NULL)
3775         return NULL;
3776
3777       stub_entry = arm_stub_hash_lookup (&htab->stub_hash_table,
3778                                         stub_name, FALSE, FALSE);
3779       if (h != NULL)
3780         h->stub_cache = stub_entry;
3781
3782       free (stub_name);
3783     }
3784
3785   return stub_entry;
3786 }
3787
3788 /* Find or create a stub section.  Returns a pointer to the stub section, and
3789    the section to which the stub section will be attached (in *LINK_SEC_P).
3790    LINK_SEC_P may be NULL.  */
3791
3792 static asection *
3793 elf32_arm_create_or_find_stub_sec (asection **link_sec_p, asection *section,
3794                                    struct elf32_arm_link_hash_table *htab)
3795 {
3796   asection *link_sec;
3797   asection *stub_sec;
3798
3799   link_sec = htab->stub_group[section->id].link_sec;
3800   stub_sec = htab->stub_group[section->id].stub_sec;
3801   if (stub_sec == NULL)
3802     {
3803       stub_sec = htab->stub_group[link_sec->id].stub_sec;
3804       if (stub_sec == NULL)
3805         {
3806           size_t namelen;
3807           bfd_size_type len;
3808           char *s_name;
3809
3810           namelen = strlen (link_sec->name);
3811           len = namelen + sizeof (STUB_SUFFIX);
3812           s_name = (char *) bfd_alloc (htab->stub_bfd, len);
3813           if (s_name == NULL)
3814             return NULL;
3815
3816           memcpy (s_name, link_sec->name, namelen);
3817           memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
3818           stub_sec = (*htab->add_stub_section) (s_name, link_sec);
3819           if (stub_sec == NULL)
3820             return NULL;
3821           htab->stub_group[link_sec->id].stub_sec = stub_sec;
3822         }
3823       htab->stub_group[section->id].stub_sec = stub_sec;
3824     }
3825
3826   if (link_sec_p)
3827     *link_sec_p = link_sec;
3828
3829   return stub_sec;
3830 }
3831
3832 /* Add a new stub entry to the stub hash.  Not all fields of the new
3833    stub entry are initialised.  */
3834
3835 static struct elf32_arm_stub_hash_entry *
3836 elf32_arm_add_stub (const char *stub_name,
3837                     asection *section,
3838                     struct elf32_arm_link_hash_table *htab)
3839 {
3840   asection *link_sec;
3841   asection *stub_sec;
3842   struct elf32_arm_stub_hash_entry *stub_entry;
3843
3844   stub_sec = elf32_arm_create_or_find_stub_sec (&link_sec, section, htab);
3845   if (stub_sec == NULL)
3846     return NULL;
3847
3848   /* Enter this entry into the linker stub hash table.  */
3849   stub_entry = arm_stub_hash_lookup (&htab->stub_hash_table, stub_name,
3850                                      TRUE, FALSE);
3851   if (stub_entry == NULL)
3852     {
3853       (*_bfd_error_handler) (_("%s: cannot create stub entry %s"),
3854                              section->owner,
3855                              stub_name);
3856       return NULL;
3857     }
3858
3859   stub_entry->stub_sec = stub_sec;
3860   stub_entry->stub_offset = 0;
3861   stub_entry->id_sec = link_sec;
3862
3863   return stub_entry;
3864 }
3865
3866 /* Store an Arm insn into an output section not processed by
3867    elf32_arm_write_section.  */
3868
3869 static void
3870 put_arm_insn (struct elf32_arm_link_hash_table * htab,
3871               bfd * output_bfd, bfd_vma val, void * ptr)
3872 {
3873   if (htab->byteswap_code != bfd_little_endian (output_bfd))
3874     bfd_putl32 (val, ptr);
3875   else
3876     bfd_putb32 (val, ptr);
3877 }
3878
3879 /* Store a 16-bit Thumb insn into an output section not processed by
3880    elf32_arm_write_section.  */
3881
3882 static void
3883 put_thumb_insn (struct elf32_arm_link_hash_table * htab,
3884                 bfd * output_bfd, bfd_vma val, void * ptr)
3885 {
3886   if (htab->byteswap_code != bfd_little_endian (output_bfd))
3887     bfd_putl16 (val, ptr);
3888   else
3889     bfd_putb16 (val, ptr);
3890 }
3891
3892 /* If it's possible to change R_TYPE to a more efficient access
3893    model, return the new reloc type.  */
3894
3895 static unsigned
3896 elf32_arm_tls_transition (struct bfd_link_info *info, int r_type,
3897                           struct elf_link_hash_entry *h)
3898 {
3899   int is_local = (h == NULL);
3900
3901   if (info->shared || (h && h->root.type == bfd_link_hash_undefweak))
3902     return r_type;
3903
3904   /* We do not support relaxations for Old TLS models.  */
3905   switch (r_type)
3906     {
3907     case R_ARM_TLS_GOTDESC:
3908     case R_ARM_TLS_CALL:
3909     case R_ARM_THM_TLS_CALL:
3910     case R_ARM_TLS_DESCSEQ:
3911     case R_ARM_THM_TLS_DESCSEQ:
3912       return is_local ? R_ARM_TLS_LE32 : R_ARM_TLS_IE32;
3913     }
3914
3915   return r_type;
3916 }
3917
3918 static bfd_reloc_status_type elf32_arm_final_link_relocate
3919   (reloc_howto_type *, bfd *, bfd *, asection *, bfd_byte *,
3920    Elf_Internal_Rela *, bfd_vma, struct bfd_link_info *, asection *,
3921    const char *, unsigned char, enum arm_st_branch_type,
3922    struct elf_link_hash_entry *, bfd_boolean *, char **);
3923
3924 static unsigned int
3925 arm_stub_required_alignment (enum elf32_arm_stub_type stub_type)
3926 {
3927   switch (stub_type)
3928     {
3929     case arm_stub_a8_veneer_b_cond:
3930     case arm_stub_a8_veneer_b:
3931     case arm_stub_a8_veneer_bl:
3932       return 2;
3933
3934     case arm_stub_long_branch_any_any:
3935     case arm_stub_long_branch_v4t_arm_thumb:
3936     case arm_stub_long_branch_thumb_only:
3937     case arm_stub_long_branch_v4t_thumb_thumb:
3938     case arm_stub_long_branch_v4t_thumb_arm:
3939     case arm_stub_short_branch_v4t_thumb_arm:
3940     case arm_stub_long_branch_any_arm_pic:
3941     case arm_stub_long_branch_any_thumb_pic:
3942     case arm_stub_long_branch_v4t_thumb_thumb_pic:
3943     case arm_stub_long_branch_v4t_arm_thumb_pic:
3944     case arm_stub_long_branch_v4t_thumb_arm_pic:
3945     case arm_stub_long_branch_thumb_only_pic:
3946     case arm_stub_long_branch_any_tls_pic:
3947     case arm_stub_long_branch_v4t_thumb_tls_pic:
3948     case arm_stub_a8_veneer_blx:
3949       return 4;
3950
3951     default:
3952       abort ();  /* Should be unreachable.  */
3953     }
3954 }
3955
3956 static bfd_boolean
3957 arm_build_one_stub (struct bfd_hash_entry *gen_entry,
3958                     void * in_arg)
3959 {
3960 #define MAXRELOCS 2
3961   struct elf32_arm_stub_hash_entry *stub_entry;
3962   struct elf32_arm_link_hash_table *globals;
3963   struct bfd_link_info *info;
3964   asection *stub_sec;
3965   bfd *stub_bfd;
3966   bfd_byte *loc;
3967   bfd_vma sym_value;
3968   int template_size;
3969   int size;
3970   const insn_sequence *template_sequence;
3971   int i;
3972   int stub_reloc_idx[MAXRELOCS] = {-1, -1};
3973   int stub_reloc_offset[MAXRELOCS] = {0, 0};
3974   int nrelocs = 0;
3975
3976   /* Massage our args to the form they really have.  */
3977   stub_entry = (struct elf32_arm_stub_hash_entry *) gen_entry;
3978   info = (struct bfd_link_info *) in_arg;
3979
3980   globals = elf32_arm_hash_table (info);
3981   if (globals == NULL)
3982     return FALSE;
3983
3984   stub_sec = stub_entry->stub_sec;
3985
3986   if ((globals->fix_cortex_a8 < 0)
3987       != (arm_stub_required_alignment (stub_entry->stub_type) == 2))
3988     /* We have to do less-strictly-aligned fixes last.  */
3989     return TRUE;
3990
3991   /* Make a note of the offset within the stubs for this entry.  */
3992   stub_entry->stub_offset = stub_sec->size;
3993   loc = stub_sec->contents + stub_entry->stub_offset;
3994
3995   stub_bfd = stub_sec->owner;
3996
3997   /* This is the address of the stub destination.  */
3998   sym_value = (stub_entry->target_value
3999                + stub_entry->target_section->output_offset
4000                + stub_entry->target_section->output_section->vma);
4001
4002   template_sequence = stub_entry->stub_template;
4003   template_size = stub_entry->stub_template_size;
4004
4005   size = 0;
4006   for (i = 0; i < template_size; i++)
4007     {
4008       switch (template_sequence[i].type)
4009         {
4010         case THUMB16_TYPE:
4011           {
4012             bfd_vma data = (bfd_vma) template_sequence[i].data;
4013             if (template_sequence[i].reloc_addend != 0)
4014               {
4015                 /* We've borrowed the reloc_addend field to mean we should
4016                    insert a condition code into this (Thumb-1 branch)
4017                    instruction.  See THUMB16_BCOND_INSN.  */
4018                 BFD_ASSERT ((data & 0xff00) == 0xd000);
4019                 data |= ((stub_entry->orig_insn >> 22) & 0xf) << 8;
4020               }
4021             bfd_put_16 (stub_bfd, data, loc + size);
4022             size += 2;
4023           }
4024           break;
4025
4026         case THUMB32_TYPE:
4027           bfd_put_16 (stub_bfd,
4028                       (template_sequence[i].data >> 16) & 0xffff,
4029                       loc + size);
4030           bfd_put_16 (stub_bfd, template_sequence[i].data & 0xffff,
4031                       loc + size + 2);
4032           if (template_sequence[i].r_type != R_ARM_NONE)
4033             {
4034               stub_reloc_idx[nrelocs] = i;
4035               stub_reloc_offset[nrelocs++] = size;
4036             }
4037           size += 4;
4038           break;
4039
4040         case ARM_TYPE:
4041           bfd_put_32 (stub_bfd, template_sequence[i].data,
4042                       loc + size);
4043           /* Handle cases where the target is encoded within the
4044              instruction.  */
4045           if (template_sequence[i].r_type == R_ARM_JUMP24)
4046             {
4047               stub_reloc_idx[nrelocs] = i;
4048               stub_reloc_offset[nrelocs++] = size;
4049             }
4050           size += 4;
4051           break;
4052
4053         case DATA_TYPE:
4054           bfd_put_32 (stub_bfd, template_sequence[i].data, loc + size);
4055           stub_reloc_idx[nrelocs] = i;
4056           stub_reloc_offset[nrelocs++] = size;
4057           size += 4;
4058           break;
4059
4060         default:
4061           BFD_FAIL ();
4062           return FALSE;
4063         }
4064     }
4065
4066   stub_sec->size += size;
4067
4068   /* Stub size has already been computed in arm_size_one_stub. Check
4069      consistency.  */
4070   BFD_ASSERT (size == stub_entry->stub_size);
4071
4072   /* Destination is Thumb. Force bit 0 to 1 to reflect this.  */
4073   if (stub_entry->branch_type == ST_BRANCH_TO_THUMB)
4074     sym_value |= 1;
4075
4076   /* Assume there is at least one and at most MAXRELOCS entries to relocate
4077      in each stub.  */
4078   BFD_ASSERT (nrelocs != 0 && nrelocs <= MAXRELOCS);
4079
4080   for (i = 0; i < nrelocs; i++)
4081     if (template_sequence[stub_reloc_idx[i]].r_type == R_ARM_THM_JUMP24
4082         || template_sequence[stub_reloc_idx[i]].r_type == R_ARM_THM_JUMP19
4083         || template_sequence[stub_reloc_idx[i]].r_type == R_ARM_THM_CALL
4084         || template_sequence[stub_reloc_idx[i]].r_type == R_ARM_THM_XPC22)
4085       {
4086         Elf_Internal_Rela rel;
4087         bfd_boolean unresolved_reloc;
4088         char *error_message;
4089         enum arm_st_branch_type branch_type
4090           = (template_sequence[stub_reloc_idx[i]].r_type != R_ARM_THM_XPC22
4091              ? ST_BRANCH_TO_THUMB : ST_BRANCH_TO_ARM);
4092         bfd_vma points_to = sym_value + stub_entry->target_addend;
4093
4094         rel.r_offset = stub_entry->stub_offset + stub_reloc_offset[i];
4095         rel.r_info = ELF32_R_INFO (0,
4096                                    template_sequence[stub_reloc_idx[i]].r_type);
4097         rel.r_addend = template_sequence[stub_reloc_idx[i]].reloc_addend;
4098
4099         if (stub_entry->stub_type == arm_stub_a8_veneer_b_cond && i == 0)
4100           /* The first relocation in the elf32_arm_stub_a8_veneer_b_cond[]
4101              template should refer back to the instruction after the original
4102              branch.  */
4103           points_to = sym_value;
4104
4105         /* There may be unintended consequences if this is not true.  */
4106         BFD_ASSERT (stub_entry->h == NULL);
4107
4108         /* Note: _bfd_final_link_relocate doesn't handle these relocations
4109            properly.  We should probably use this function unconditionally,
4110            rather than only for certain relocations listed in the enclosing
4111            conditional, for the sake of consistency.  */
4112         elf32_arm_final_link_relocate (elf32_arm_howto_from_type
4113             (template_sequence[stub_reloc_idx[i]].r_type),
4114           stub_bfd, info->output_bfd, stub_sec, stub_sec->contents, &rel,
4115           points_to, info, stub_entry->target_section, "", STT_FUNC,
4116           branch_type, (struct elf_link_hash_entry *) stub_entry->h,
4117           &unresolved_reloc, &error_message);
4118       }
4119     else
4120       {
4121         Elf_Internal_Rela rel;
4122         bfd_boolean unresolved_reloc;
4123         char *error_message;
4124         bfd_vma points_to = sym_value + stub_entry->target_addend
4125           + template_sequence[stub_reloc_idx[i]].reloc_addend;
4126
4127         rel.r_offset = stub_entry->stub_offset + stub_reloc_offset[i];
4128         rel.r_info = ELF32_R_INFO (0,
4129                                    template_sequence[stub_reloc_idx[i]].r_type);
4130         rel.r_addend = 0;
4131
4132         elf32_arm_final_link_relocate (elf32_arm_howto_from_type
4133             (template_sequence[stub_reloc_idx[i]].r_type),
4134           stub_bfd, info->output_bfd, stub_sec, stub_sec->contents, &rel,
4135           points_to, info, stub_entry->target_section, "", STT_FUNC,
4136           stub_entry->branch_type,
4137           (struct elf_link_hash_entry *) stub_entry->h, &unresolved_reloc,
4138           &error_message);
4139       }
4140
4141   return TRUE;
4142 #undef MAXRELOCS
4143 }
4144
4145 /* Calculate the template, template size and instruction size for a stub.
4146    Return value is the instruction size.  */
4147
4148 static unsigned int
4149 find_stub_size_and_template (enum elf32_arm_stub_type stub_type,
4150                              const insn_sequence **stub_template,
4151                              int *stub_template_size)
4152 {
4153   const insn_sequence *template_sequence = NULL;
4154   int template_size = 0, i;
4155   unsigned int size;
4156
4157   template_sequence = stub_definitions[stub_type].template_sequence;
4158   if (stub_template)
4159     *stub_template = template_sequence;
4160
4161   template_size = stub_definitions[stub_type].template_size;
4162   if (stub_template_size)
4163     *stub_template_size = template_size;
4164
4165   size = 0;
4166   for (i = 0; i < template_size; i++)
4167     {
4168       switch (template_sequence[i].type)
4169         {
4170         case THUMB16_TYPE:
4171           size += 2;
4172           break;
4173
4174         case ARM_TYPE:
4175         case THUMB32_TYPE:
4176         case DATA_TYPE:
4177           size += 4;
4178           break;
4179
4180         default:
4181           BFD_FAIL ();
4182           return 0;
4183         }
4184     }
4185
4186   return size;
4187 }
4188
4189 /* As above, but don't actually build the stub.  Just bump offset so
4190    we know stub section sizes.  */
4191
4192 static bfd_boolean
4193 arm_size_one_stub (struct bfd_hash_entry *gen_entry,
4194                    void *in_arg ATTRIBUTE_UNUSED)
4195 {
4196   struct elf32_arm_stub_hash_entry *stub_entry;
4197   const insn_sequence *template_sequence;
4198   int template_size, size;
4199
4200   /* Massage our args to the form they really have.  */
4201   stub_entry = (struct elf32_arm_stub_hash_entry *) gen_entry;
4202
4203   BFD_ASSERT((stub_entry->stub_type > arm_stub_none)
4204              && stub_entry->stub_type < ARRAY_SIZE(stub_definitions));
4205
4206   size = find_stub_size_and_template (stub_entry->stub_type, &template_sequence,
4207                                       &template_size);
4208
4209   stub_entry->stub_size = size;
4210   stub_entry->stub_template = template_sequence;
4211   stub_entry->stub_template_size = template_size;
4212
4213   size = (size + 7) & ~7;
4214   stub_entry->stub_sec->size += size;
4215
4216   return TRUE;
4217 }
4218
4219 /* External entry points for sizing and building linker stubs.  */
4220
4221 /* Set up various things so that we can make a list of input sections
4222    for each output section included in the link.  Returns -1 on error,
4223    0 when no stubs will be needed, and 1 on success.  */
4224
4225 int
4226 elf32_arm_setup_section_lists (bfd *output_bfd,
4227                                struct bfd_link_info *info)
4228 {
4229   bfd *input_bfd;
4230   unsigned int bfd_count;
4231   int top_id, top_index;
4232   asection *section;
4233   asection **input_list, **list;
4234   bfd_size_type amt;
4235   struct elf32_arm_link_hash_table *htab = elf32_arm_hash_table (info);
4236
4237   if (htab == NULL)
4238     return 0;
4239   if (! is_elf_hash_table (htab))
4240     return 0;
4241
4242   /* Count the number of input BFDs and find the top input section id.  */
4243   for (input_bfd = info->input_bfds, bfd_count = 0, top_id = 0;
4244        input_bfd != NULL;
4245        input_bfd = input_bfd->link_next)
4246     {
4247       bfd_count += 1;
4248       for (section = input_bfd->sections;
4249            section != NULL;
4250            section = section->next)
4251         {
4252           if (top_id < section->id)
4253             top_id = section->id;
4254         }
4255     }
4256   htab->bfd_count = bfd_count;
4257
4258   amt = sizeof (struct map_stub) * (top_id + 1);
4259   htab->stub_group = (struct map_stub *) bfd_zmalloc (amt);
4260   if (htab->stub_group == NULL)
4261     return -1;
4262   htab->top_id = top_id;
4263
4264   /* We can't use output_bfd->section_count here to find the top output
4265      section index as some sections may have been removed, and
4266      _bfd_strip_section_from_output doesn't renumber the indices.  */
4267   for (section = output_bfd->sections, top_index = 0;
4268        section != NULL;
4269        section = section->next)
4270     {
4271       if (top_index < section->index)
4272         top_index = section->index;
4273     }
4274
4275   htab->top_index = top_index;
4276   amt = sizeof (asection *) * (top_index + 1);
4277   input_list = (asection **) bfd_malloc (amt);
4278   htab->input_list = input_list;
4279   if (input_list == NULL)
4280     return -1;
4281
4282   /* For sections we aren't interested in, mark their entries with a
4283      value we can check later.  */
4284   list = input_list + top_index;
4285   do
4286     *list = bfd_abs_section_ptr;
4287   while (list-- != input_list);
4288
4289   for (section = output_bfd->sections;
4290        section != NULL;
4291        section = section->next)
4292     {
4293       if ((section->flags & SEC_CODE) != 0)
4294         input_list[section->index] = NULL;
4295     }
4296
4297   return 1;
4298 }
4299
4300 /* The linker repeatedly calls this function for each input section,
4301    in the order that input sections are linked into output sections.
4302    Build lists of input sections to determine groupings between which
4303    we may insert linker stubs.  */
4304
4305 void
4306 elf32_arm_next_input_section (struct bfd_link_info *info,
4307                               asection *isec)
4308 {
4309   struct elf32_arm_link_hash_table *htab = elf32_arm_hash_table (info);
4310
4311   if (htab == NULL)
4312     return;
4313
4314   if (isec->output_section->index <= htab->top_index)
4315     {
4316       asection **list = htab->input_list + isec->output_section->index;
4317
4318       if (*list != bfd_abs_section_ptr && (isec->flags & SEC_CODE) != 0)
4319         {
4320           /* Steal the link_sec pointer for our list.  */
4321 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
4322           /* This happens to make the list in reverse order,
4323              which we reverse later.  */
4324           PREV_SEC (isec) = *list;
4325           *list = isec;
4326         }
4327     }
4328 }
4329
4330 /* See whether we can group stub sections together.  Grouping stub
4331    sections may result in fewer stubs.  More importantly, we need to
4332    put all .init* and .fini* stubs at the end of the .init or
4333    .fini output sections respectively, because glibc splits the
4334    _init and _fini functions into multiple parts.  Putting a stub in
4335    the middle of a function is not a good idea.  */
4336
4337 static void
4338 group_sections (struct elf32_arm_link_hash_table *htab,
4339                 bfd_size_type stub_group_size,
4340                 bfd_boolean stubs_always_after_branch)
4341 {
4342   asection **list = htab->input_list;
4343
4344   do
4345     {
4346       asection *tail = *list;
4347       asection *head;
4348
4349       if (tail == bfd_abs_section_ptr)
4350         continue;
4351
4352       /* Reverse the list: we must avoid placing stubs at the
4353          beginning of the section because the beginning of the text
4354          section may be required for an interrupt vector in bare metal
4355          code.  */
4356 #define NEXT_SEC PREV_SEC
4357       head = NULL;
4358       while (tail != NULL)
4359         {
4360           /* Pop from tail.  */
4361           asection *item = tail;
4362           tail = PREV_SEC (item);
4363
4364           /* Push on head.  */
4365           NEXT_SEC (item) = head;
4366           head = item;
4367         }
4368
4369       while (head != NULL)
4370         {
4371           asection *curr;
4372           asection *next;
4373           bfd_vma stub_group_start = head->output_offset;
4374           bfd_vma end_of_next;
4375
4376           curr = head;
4377           while (NEXT_SEC (curr) != NULL)
4378             {
4379               next = NEXT_SEC (curr);
4380               end_of_next = next->output_offset + next->size;
4381               if (end_of_next - stub_group_start >= stub_group_size)
4382                 /* End of NEXT is too far from start, so stop.  */
4383                 break;
4384               /* Add NEXT to the group.  */
4385               curr = next;
4386             }
4387
4388           /* OK, the size from the start to the start of CURR is less
4389              than stub_group_size and thus can be handled by one stub
4390              section.  (Or the head section is itself larger than
4391              stub_group_size, in which case we may be toast.)
4392              We should really be keeping track of the total size of
4393              stubs added here, as stubs contribute to the final output
4394              section size.  */
4395           do
4396             {
4397               next = NEXT_SEC (head);
4398               /* Set up this stub group.  */
4399               htab->stub_group[head->id].link_sec = curr;
4400             }
4401           while (head != curr && (head = next) != NULL);
4402
4403           /* But wait, there's more!  Input sections up to stub_group_size
4404              bytes after the stub section can be handled by it too.  */
4405           if (!stubs_always_after_branch)
4406             {
4407               stub_group_start = curr->output_offset + curr->size;
4408
4409               while (next != NULL)
4410                 {
4411                   end_of_next = next->output_offset + next->size;
4412                   if (end_of_next - stub_group_start >= stub_group_size)
4413                     /* End of NEXT is too far from stubs, so stop.  */
4414                     break;
4415                   /* Add NEXT to the stub group.  */
4416                   head = next;
4417                   next = NEXT_SEC (head);
4418                   htab->stub_group[head->id].link_sec = curr;
4419                 }
4420             }
4421           head = next;
4422         }
4423     }
4424   while (list++ != htab->input_list + htab->top_index);
4425
4426   free (htab->input_list);
4427 #undef PREV_SEC
4428 #undef NEXT_SEC
4429 }
4430
4431 /* Comparison function for sorting/searching relocations relating to Cortex-A8
4432    erratum fix.  */
4433
4434 static int
4435 a8_reloc_compare (const void *a, const void *b)
4436 {
4437   const struct a8_erratum_reloc *ra = (const struct a8_erratum_reloc *) a;
4438   const struct a8_erratum_reloc *rb = (const struct a8_erratum_reloc *) b;
4439
4440   if (ra->from < rb->from)
4441     return -1;
4442   else if (ra->from > rb->from)
4443     return 1;
4444   else
4445     return 0;
4446 }
4447
4448 static struct elf_link_hash_entry *find_thumb_glue (struct bfd_link_info *,
4449                                                     const char *, char **);
4450
4451 /* Helper function to scan code for sequences which might trigger the Cortex-A8
4452    branch/TLB erratum.  Fill in the table described by A8_FIXES_P,
4453    NUM_A8_FIXES_P, A8_FIX_TABLE_SIZE_P.  Returns true if an error occurs, false
4454    otherwise.  */
4455
4456 static bfd_boolean
4457 cortex_a8_erratum_scan (bfd *input_bfd,
4458                         struct bfd_link_info *info,
4459                         struct a8_erratum_fix **a8_fixes_p,
4460                         unsigned int *num_a8_fixes_p,
4461                         unsigned int *a8_fix_table_size_p,
4462                         struct a8_erratum_reloc *a8_relocs,
4463                         unsigned int num_a8_relocs,
4464                         unsigned prev_num_a8_fixes,
4465                         bfd_boolean *stub_changed_p)
4466 {
4467   asection *section;
4468   struct elf32_arm_link_hash_table *htab = elf32_arm_hash_table (info);
4469   struct a8_erratum_fix *a8_fixes = *a8_fixes_p;
4470   unsigned int num_a8_fixes = *num_a8_fixes_p;
4471   unsigned int a8_fix_table_size = *a8_fix_table_size_p;
4472
4473   if (htab == NULL)
4474     return FALSE;
4475
4476   for (section = input_bfd->sections;
4477        section != NULL;
4478        section = section->next)
4479     {
4480       bfd_byte *contents = NULL;
4481       struct _arm_elf_section_data *sec_data;
4482       unsigned int span;
4483       bfd_vma base_vma;
4484
4485       if (elf_section_type (section) != SHT_PROGBITS
4486           || (elf_section_flags (section) & SHF_EXECINSTR) == 0
4487           || (section->flags & SEC_EXCLUDE) != 0
4488           || (section->sec_info_type == ELF_INFO_TYPE_JUST_SYMS)
4489           || (section->output_section == bfd_abs_section_ptr))
4490         continue;
4491
4492       base_vma = section->output_section->vma + section->output_offset;
4493
4494       if (elf_section_data (section)->this_hdr.contents != NULL)
4495         contents = elf_section_data (section)->this_hdr.contents;
4496       else if (! bfd_malloc_and_get_section (input_bfd, section, &contents))
4497         return TRUE;
4498
4499       sec_data = elf32_arm_section_data (section);
4500
4501       for (span = 0; span < sec_data->mapcount; span++)
4502         {
4503           unsigned int span_start = sec_data->map[span].vma;
4504           unsigned int span_end = (span == sec_data->mapcount - 1)
4505             ? section->size : sec_data->map[span + 1].vma;
4506           unsigned int i;
4507           char span_type = sec_data->map[span].type;
4508           bfd_boolean last_was_32bit = FALSE, last_was_branch = FALSE;
4509
4510           if (span_type != 't')
4511             continue;
4512
4513           /* Span is entirely within a single 4KB region: skip scanning.  */
4514           if (((base_vma + span_start) & ~0xfff)
4515               == ((base_vma + span_end) & ~0xfff))
4516             continue;
4517
4518           /* Scan for 32-bit Thumb-2 branches which span two 4K regions, where:
4519
4520                * The opcode is BLX.W, BL.W, B.W, Bcc.W
4521                * The branch target is in the same 4KB region as the
4522                  first half of the branch.
4523                * The instruction before the branch is a 32-bit
4524                  length non-branch instruction.  */
4525           for (i = span_start; i < span_end;)
4526             {
4527               unsigned int insn = bfd_getl16 (&contents[i]);
4528               bfd_boolean insn_32bit = FALSE, is_blx = FALSE, is_b = FALSE;
4529               bfd_boolean is_bl = FALSE, is_bcc = FALSE, is_32bit_branch;
4530
4531               if ((insn & 0xe000) == 0xe000 && (insn & 0x1800) != 0x0000)
4532                 insn_32bit = TRUE;
4533
4534               if (insn_32bit)
4535                 {
4536                   /* Load the rest of the insn (in manual-friendly order).  */
4537                   insn = (insn << 16) | bfd_getl16 (&contents[i + 2]);
4538
4539                   /* Encoding T4: B<c>.W.  */
4540                   is_b = (insn & 0xf800d000) == 0xf0009000;
4541                   /* Encoding T1: BL<c>.W.  */
4542                   is_bl = (insn & 0xf800d000) == 0xf000d000;
4543                   /* Encoding T2: BLX<c>.W.  */
4544                   is_blx = (insn & 0xf800d000) == 0xf000c000;
4545                   /* Encoding T3: B<c>.W (not permitted in IT block).  */
4546                   is_bcc = (insn & 0xf800d000) == 0xf0008000
4547                            && (insn & 0x07f00000) != 0x03800000;
4548                 }
4549
4550               is_32bit_branch = is_b || is_bl || is_blx || is_bcc;
4551
4552               if (((base_vma + i) & 0xfff) == 0xffe
4553                   && insn_32bit
4554                   && is_32bit_branch
4555                   && last_was_32bit
4556                   && ! last_was_branch)
4557                 {
4558                   bfd_signed_vma offset = 0;
4559                   bfd_boolean force_target_arm = FALSE;
4560                   bfd_boolean force_target_thumb = FALSE;
4561                   bfd_vma target;
4562                   enum elf32_arm_stub_type stub_type = arm_stub_none;
4563                   struct a8_erratum_reloc key, *found;
4564                   bfd_boolean use_plt = FALSE;
4565
4566                   key.from = base_vma + i;
4567                   found = (struct a8_erratum_reloc *)
4568                       bsearch (&key, a8_relocs, num_a8_relocs,
4569                                sizeof (struct a8_erratum_reloc),
4570                                &a8_reloc_compare);
4571
4572                   if (found)
4573                     {
4574                       char *error_message = NULL;
4575                       struct elf_link_hash_entry *entry;
4576
4577                       /* We don't care about the error returned from this
4578                          function, only if there is glue or not.  */
4579                       entry = find_thumb_glue (info, found->sym_name,
4580                                                &error_message);
4581
4582                       if (entry)
4583                         found->non_a8_stub = TRUE;
4584
4585                       /* Keep a simpler condition, for the sake of clarity.  */
4586                       if (htab->root.splt != NULL && found->hash != NULL
4587                           && found->hash->root.plt.offset != (bfd_vma) -1)
4588                         use_plt = TRUE;
4589
4590                       if (found->r_type == R_ARM_THM_CALL)
4591                         {
4592                           if (found->branch_type == ST_BRANCH_TO_ARM
4593                               || use_plt)
4594                             force_target_arm = TRUE;
4595                           else
4596                             force_target_thumb = TRUE;
4597                         }
4598                     }
4599
4600                   /* Check if we have an offending branch instruction.  */
4601
4602                   if (found && found->non_a8_stub)
4603                     /* We've already made a stub for this instruction, e.g.
4604                        it's a long branch or a Thumb->ARM stub.  Assume that
4605                        stub will suffice to work around the A8 erratum (see
4606                        setting of always_after_branch above).  */
4607                     ;
4608                   else if (is_bcc)
4609                     {
4610                       offset = (insn & 0x7ff) << 1;
4611                       offset |= (insn & 0x3f0000) >> 4;
4612                       offset |= (insn & 0x2000) ? 0x40000 : 0;
4613                       offset |= (insn & 0x800) ? 0x80000 : 0;
4614                       offset |= (insn & 0x4000000) ? 0x100000 : 0;
4615                       if (offset & 0x100000)
4616                         offset |= ~ ((bfd_signed_vma) 0xfffff);
4617                       stub_type = arm_stub_a8_veneer_b_cond;
4618                     }
4619                   else if (is_b || is_bl || is_blx)
4620                     {
4621                       int s = (insn & 0x4000000) != 0;
4622                       int j1 = (insn & 0x2000) != 0;
4623                       int j2 = (insn & 0x800) != 0;
4624                       int i1 = !(j1 ^ s);
4625                       int i2 = !(j2 ^ s);
4626
4627                       offset = (insn & 0x7ff) << 1;
4628                       offset |= (insn & 0x3ff0000) >> 4;
4629                       offset |= i2 << 22;
4630                       offset |= i1 << 23;
4631                       offset |= s << 24;
4632                       if (offset & 0x1000000)
4633                         offset |= ~ ((bfd_signed_vma) 0xffffff);
4634
4635                       if (is_blx)
4636                         offset &= ~ ((bfd_signed_vma) 3);
4637
4638                       stub_type = is_blx ? arm_stub_a8_veneer_blx :
4639                         is_bl ? arm_stub_a8_veneer_bl : arm_stub_a8_veneer_b;
4640                     }
4641
4642                   if (stub_type != arm_stub_none)
4643                     {
4644                       bfd_vma pc_for_insn = base_vma + i + 4;
4645
4646                       /* The original instruction is a BL, but the target is
4647                          an ARM instruction.  If we were not making a stub,
4648                          the BL would have been converted to a BLX.  Use the
4649                          BLX stub instead in that case.  */
4650                       if (htab->use_blx && force_target_arm
4651                           && stub_type == arm_stub_a8_veneer_bl)
4652                         {
4653                           stub_type = arm_stub_a8_veneer_blx;
4654                           is_blx = TRUE;
4655                           is_bl = FALSE;
4656                         }
4657                       /* Conversely, if the original instruction was
4658                          BLX but the target is Thumb mode, use the BL
4659                          stub.  */
4660                       else if (force_target_thumb
4661                                && stub_type == arm_stub_a8_veneer_blx)
4662                         {
4663                           stub_type = arm_stub_a8_veneer_bl;
4664                           is_blx = FALSE;
4665                           is_bl = TRUE;
4666                         }
4667
4668                       if (is_blx)
4669                         pc_for_insn &= ~ ((bfd_vma) 3);
4670
4671                       /* If we found a relocation, use the proper destination,
4672                          not the offset in the (unrelocated) instruction.
4673                          Note this is always done if we switched the stub type
4674                          above.  */
4675                       if (found)
4676                         offset =
4677                           (bfd_signed_vma) (found->destination - pc_for_insn);
4678
4679                       /* If the stub will use a Thumb-mode branch to a
4680                          PLT target, redirect it to the preceding Thumb
4681                          entry point.  */
4682                       if (stub_type != arm_stub_a8_veneer_blx && use_plt)
4683                         offset -= PLT_THUMB_STUB_SIZE;
4684
4685                       target = pc_for_insn + offset;
4686
4687                       /* The BLX stub is ARM-mode code.  Adjust the offset to
4688                          take the different PC value (+8 instead of +4) into
4689                          account.  */
4690                       if (stub_type == arm_stub_a8_veneer_blx)
4691                         offset += 4;
4692
4693                       if (((base_vma + i) & ~0xfff) == (target & ~0xfff))
4694                         {
4695                           char *stub_name = NULL;
4696
4697                           if (num_a8_fixes == a8_fix_table_size)
4698                             {
4699                               a8_fix_table_size *= 2;
4700                               a8_fixes = (struct a8_erratum_fix *)
4701                                   bfd_realloc (a8_fixes,
4702                                                sizeof (struct a8_erratum_fix)
4703                                                * a8_fix_table_size);
4704                             }
4705
4706                           if (num_a8_fixes < prev_num_a8_fixes)
4707                             {
4708                               /* If we're doing a subsequent scan,
4709                                  check if we've found the same fix as
4710                                  before, and try and reuse the stub
4711                                  name.  */
4712                               stub_name = a8_fixes[num_a8_fixes].stub_name;
4713                               if ((a8_fixes[num_a8_fixes].section != section)
4714                                   || (a8_fixes[num_a8_fixes].offset != i))
4715                                 {
4716                                   free (stub_name);
4717                                   stub_name = NULL;
4718                                   *stub_changed_p = TRUE;
4719                                 }
4720                             }
4721
4722                           if (!stub_name)
4723                             {
4724                               stub_name = (char *) bfd_malloc (8 + 1 + 8 + 1);
4725                               if (stub_name != NULL)
4726                                 sprintf (stub_name, "%x:%x", section->id, i);
4727                             }
4728
4729                           a8_fixes[num_a8_fixes].input_bfd = input_bfd;
4730                           a8_fixes[num_a8_fixes].section = section;
4731                           a8_fixes[num_a8_fixes].offset = i;
4732                           a8_fixes[num_a8_fixes].addend = offset;
4733                           a8_fixes[num_a8_fixes].orig_insn = insn;
4734                           a8_fixes[num_a8_fixes].stub_name = stub_name;
4735                           a8_fixes[num_a8_fixes].stub_type = stub_type;
4736                           a8_fixes[num_a8_fixes].branch_type =
4737                             is_blx ? ST_BRANCH_TO_ARM : ST_BRANCH_TO_THUMB;
4738
4739                           num_a8_fixes++;
4740                         }
4741                     }
4742                 }
4743
4744               i += insn_32bit ? 4 : 2;
4745               last_was_32bit = insn_32bit;
4746               last_was_branch = is_32bit_branch;
4747             }
4748         }
4749
4750       if (elf_section_data (section)->this_hdr.contents == NULL)
4751         free (contents);
4752     }
4753
4754   *a8_fixes_p = a8_fixes;
4755   *num_a8_fixes_p = num_a8_fixes;
4756   *a8_fix_table_size_p = a8_fix_table_size;
4757
4758   return FALSE;
4759 }
4760
4761 /* Determine and set the size of the stub section for a final link.
4762
4763    The basic idea here is to examine all the relocations looking for
4764    PC-relative calls to a target that is unreachable with a "bl"
4765    instruction.  */
4766
4767 bfd_boolean
4768 elf32_arm_size_stubs (bfd *output_bfd,
4769                       bfd *stub_bfd,
4770                       struct bfd_link_info *info,
4771                       bfd_signed_vma group_size,
4772                       asection * (*add_stub_section) (const char *, asection *),
4773                       void (*layout_sections_again) (void))
4774 {
4775   bfd_size_type stub_group_size;
4776   bfd_boolean stubs_always_after_branch;
4777   struct elf32_arm_link_hash_table *htab = elf32_arm_hash_table (info);
4778   struct a8_erratum_fix *a8_fixes = NULL;
4779   unsigned int num_a8_fixes = 0, a8_fix_table_size = 10;
4780   struct a8_erratum_reloc *a8_relocs = NULL;
4781   unsigned int num_a8_relocs = 0, a8_reloc_table_size = 10, i;
4782
4783   if (htab == NULL)
4784     return FALSE;
4785
4786   if (htab->fix_cortex_a8)
4787     {
4788       a8_fixes = (struct a8_erratum_fix *)
4789           bfd_zmalloc (sizeof (struct a8_erratum_fix) * a8_fix_table_size);
4790       a8_relocs = (struct a8_erratum_reloc *)
4791           bfd_zmalloc (sizeof (struct a8_erratum_reloc) * a8_reloc_table_size);
4792     }
4793
4794   /* Propagate mach to stub bfd, because it may not have been
4795      finalized when we created stub_bfd.  */
4796   bfd_set_arch_mach (stub_bfd, bfd_get_arch (output_bfd),
4797                      bfd_get_mach (output_bfd));
4798
4799   /* Stash our params away.  */
4800   htab->stub_bfd = stub_bfd;
4801   htab->add_stub_section = add_stub_section;
4802   htab->layout_sections_again = layout_sections_again;
4803   stubs_always_after_branch = group_size < 0;
4804
4805   /* The Cortex-A8 erratum fix depends on stubs not being in the same 4K page
4806      as the first half of a 32-bit branch straddling two 4K pages.  This is a
4807      crude way of enforcing that.  */
4808   if (htab->fix_cortex_a8)
4809     stubs_always_after_branch = 1;
4810
4811   if (group_size < 0)
4812     stub_group_size = -group_size;
4813   else
4814     stub_group_size = group_size;
4815
4816   if (stub_group_size == 1)
4817     {
4818       /* Default values.  */
4819       /* Thumb branch range is +-4MB has to be used as the default
4820          maximum size (a given section can contain both ARM and Thumb
4821          code, so the worst case has to be taken into account).
4822
4823          This value is 24K less than that, which allows for 2025
4824          12-byte stubs.  If we exceed that, then we will fail to link.
4825          The user will have to relink with an explicit group size
4826          option.  */
4827       stub_group_size = 4170000;
4828     }
4829
4830   group_sections (htab, stub_group_size, stubs_always_after_branch);
4831
4832   /* If we're applying the cortex A8 fix, we need to determine the
4833      program header size now, because we cannot change it later --
4834      that could alter section placements.  Notice the A8 erratum fix
4835      ends up requiring the section addresses to remain unchanged
4836      modulo the page size.  That's something we cannot represent
4837      inside BFD, and we don't want to force the section alignment to
4838      be the page size.  */
4839   if (htab->fix_cortex_a8)
4840     (*htab->layout_sections_again) ();
4841
4842   while (1)
4843     {
4844       bfd *input_bfd;
4845       unsigned int bfd_indx;
4846       asection *stub_sec;
4847       bfd_boolean stub_changed = FALSE;
4848       unsigned prev_num_a8_fixes = num_a8_fixes;
4849
4850       num_a8_fixes = 0;
4851       for (input_bfd = info->input_bfds, bfd_indx = 0;
4852            input_bfd != NULL;
4853            input_bfd = input_bfd->link_next, bfd_indx++)
4854         {
4855           Elf_Internal_Shdr *symtab_hdr;
4856           asection *section;
4857           Elf_Internal_Sym *local_syms = NULL;
4858
4859           num_a8_relocs = 0;
4860
4861           /* We'll need the symbol table in a second.  */
4862           symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
4863           if (symtab_hdr->sh_info == 0)
4864             continue;
4865
4866           /* Walk over each section attached to the input bfd.  */
4867           for (section = input_bfd->sections;
4868                section != NULL;
4869                section = section->next)
4870             {
4871               Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
4872
4873               /* If there aren't any relocs, then there's nothing more
4874                  to do.  */
4875               if ((section->flags & SEC_RELOC) == 0
4876                   || section->reloc_count == 0
4877                   || (section->flags & SEC_CODE) == 0)
4878                 continue;
4879
4880               /* If this section is a link-once section that will be
4881                  discarded, then don't create any stubs.  */
4882               if (section->output_section == NULL
4883                   || section->output_section->owner != output_bfd)
4884                 continue;
4885
4886               /* Get the relocs.  */
4887               internal_relocs
4888                 = _bfd_elf_link_read_relocs (input_bfd, section, NULL,
4889                                              NULL, info->keep_memory);
4890               if (internal_relocs == NULL)
4891                 goto error_ret_free_local;
4892
4893               /* Now examine each relocation.  */
4894               irela = internal_relocs;
4895               irelaend = irela + section->reloc_count;
4896               for (; irela < irelaend; irela++)
4897                 {
4898                   unsigned int r_type, r_indx;
4899                   enum elf32_arm_stub_type stub_type;
4900                   struct elf32_arm_stub_hash_entry *stub_entry;
4901                   asection *sym_sec;
4902                   bfd_vma sym_value;
4903                   bfd_vma destination;
4904                   struct elf32_arm_link_hash_entry *hash;
4905                   const char *sym_name;
4906                   char *stub_name;
4907                   const asection *id_sec;
4908                   unsigned char st_type;
4909                   enum arm_st_branch_type branch_type;
4910                   bfd_boolean created_stub = FALSE;
4911
4912                   r_type = ELF32_R_TYPE (irela->r_info);
4913                   r_indx = ELF32_R_SYM (irela->r_info);
4914
4915                   if (r_type >= (unsigned int) R_ARM_max)
4916                     {
4917                       bfd_set_error (bfd_error_bad_value);
4918                     error_ret_free_internal:
4919                       if (elf_section_data (section)->relocs == NULL)
4920                         free (internal_relocs);
4921                       goto error_ret_free_local;
4922                     }
4923
4924                   hash = NULL;
4925                   if (r_indx >= symtab_hdr->sh_info)
4926                     hash = elf32_arm_hash_entry
4927                       (elf_sym_hashes (input_bfd)
4928                        [r_indx - symtab_hdr->sh_info]);
4929
4930                   /* Only look for stubs on branch instructions, or
4931                      non-relaxed TLSCALL  */
4932                   if ((r_type != (unsigned int) R_ARM_CALL)
4933                       && (r_type != (unsigned int) R_ARM_THM_CALL)
4934                       && (r_type != (unsigned int) R_ARM_JUMP24)
4935                       && (r_type != (unsigned int) R_ARM_THM_JUMP19)
4936                       && (r_type != (unsigned int) R_ARM_THM_XPC22)
4937                       && (r_type != (unsigned int) R_ARM_THM_JUMP24)
4938                       && (r_type != (unsigned int) R_ARM_PLT32)
4939                       && !((r_type == (unsigned int) R_ARM_TLS_CALL
4940                             || r_type == (unsigned int) R_ARM_THM_TLS_CALL)
4941                            && r_type == elf32_arm_tls_transition
4942                                (info, r_type, &hash->root)
4943                            && ((hash ? hash->tls_type
4944                                 : (elf32_arm_local_got_tls_type
4945                                    (input_bfd)[r_indx]))
4946                                & GOT_TLS_GDESC) != 0))
4947                     continue;
4948
4949                   /* Now determine the call target, its name, value,
4950                      section.  */
4951                   sym_sec = NULL;
4952                   sym_value = 0;
4953                   destination = 0;
4954                   sym_name = NULL;
4955
4956                   if (r_type == (unsigned int) R_ARM_TLS_CALL
4957                       || r_type == (unsigned int) R_ARM_THM_TLS_CALL)
4958                     {
4959                       /* A non-relaxed TLS call.  The target is the
4960                          plt-resident trampoline and nothing to do
4961                          with the symbol.  */
4962                       BFD_ASSERT (htab->tls_trampoline > 0);
4963                       sym_sec = htab->root.splt;
4964                       sym_value = htab->tls_trampoline;
4965                       hash = 0;
4966                       st_type = STT_FUNC;
4967                       branch_type = ST_BRANCH_TO_ARM;
4968                     }
4969                   else if (!hash)
4970                     {
4971                       /* It's a local symbol.  */
4972                       Elf_Internal_Sym *sym;
4973
4974                       if (local_syms == NULL)
4975                         {
4976                           local_syms
4977                             = (Elf_Internal_Sym *) symtab_hdr->contents;
4978                           if (local_syms == NULL)
4979                             local_syms
4980                               = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
4981                                                       symtab_hdr->sh_info, 0,
4982                                                       NULL, NULL, NULL);
4983                           if (local_syms == NULL)
4984                             goto error_ret_free_internal;
4985                         }
4986
4987                       sym = local_syms + r_indx;
4988                       if (sym->st_shndx == SHN_UNDEF)
4989                         sym_sec = bfd_und_section_ptr;
4990                       else if (sym->st_shndx == SHN_ABS)
4991                         sym_sec = bfd_abs_section_ptr;
4992                       else if (sym->st_shndx == SHN_COMMON)
4993                         sym_sec = bfd_com_section_ptr;
4994                       else
4995                         sym_sec =
4996                           bfd_section_from_elf_index (input_bfd, sym->st_shndx);
4997
4998                       if (!sym_sec)
4999                         /* This is an undefined symbol.  It can never
5000                            be resolved. */
5001                         continue;
5002
5003                       if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
5004                         sym_value = sym->st_value;
5005                       destination = (sym_value + irela->r_addend
5006                                      + sym_sec->output_offset
5007                                      + sym_sec->output_section->vma);
5008                       st_type = ELF_ST_TYPE (sym->st_info);
5009                       branch_type = ARM_SYM_BRANCH_TYPE (sym);
5010                       sym_name
5011                         = bfd_elf_string_from_elf_section (input_bfd,
5012                                                            symtab_hdr->sh_link,
5013                                                            sym->st_name);
5014                     }
5015                   else
5016                     {
5017                       /* It's an external symbol.  */
5018                       while (hash->root.root.type == bfd_link_hash_indirect
5019                              || hash->root.root.type == bfd_link_hash_warning)
5020                         hash = ((struct elf32_arm_link_hash_entry *)
5021                                 hash->root.root.u.i.link);
5022
5023                       if (hash->root.root.type == bfd_link_hash_defined
5024                           || hash->root.root.type == bfd_link_hash_defweak)
5025                         {
5026                           sym_sec = hash->root.root.u.def.section;
5027                           sym_value = hash->root.root.u.def.value;
5028
5029                           struct elf32_arm_link_hash_table *globals =
5030                                                   elf32_arm_hash_table (info);
5031
5032                           /* For a destination in a shared library,
5033                              use the PLT stub as target address to
5034                              decide whether a branch stub is
5035                              needed.  */
5036                           if (globals != NULL
5037                               && globals->root.splt != NULL
5038                               && hash != NULL
5039                               && hash->root.plt.offset != (bfd_vma) -1)
5040                             {
5041                               sym_sec = globals->root.splt;
5042                               sym_value = hash->root.plt.offset;
5043                               if (sym_sec->output_section != NULL)
5044                                 destination = (sym_value
5045                                                + sym_sec->output_offset
5046                                                + sym_sec->output_section->vma);
5047                             }
5048                           else if (sym_sec->output_section != NULL)
5049                             destination = (sym_value + irela->r_addend
5050                                            + sym_sec->output_offset
5051                                            + sym_sec->output_section->vma);
5052                         }
5053                       else if ((hash->root.root.type == bfd_link_hash_undefined)
5054                                || (hash->root.root.type == bfd_link_hash_undefweak))
5055                         {
5056                           /* For a shared library, use the PLT stub as
5057                              target address to decide whether a long
5058                              branch stub is needed.
5059                              For absolute code, they cannot be handled.  */
5060                           struct elf32_arm_link_hash_table *globals =
5061                             elf32_arm_hash_table (info);
5062
5063                           if (globals != NULL
5064                               && globals->root.splt != NULL
5065                               && hash != NULL
5066                               && hash->root.plt.offset != (bfd_vma) -1)
5067                             {
5068                               sym_sec = globals->root.splt;
5069                               sym_value = hash->root.plt.offset;
5070                               if (sym_sec->output_section != NULL)
5071                                 destination = (sym_value
5072                                                + sym_sec->output_offset
5073                                                + sym_sec->output_section->vma);
5074                             }
5075                           else
5076                             continue;
5077                         }
5078                       else
5079                         {
5080                           bfd_set_error (bfd_error_bad_value);
5081                           goto error_ret_free_internal;
5082                         }
5083                       st_type = hash->root.type;
5084                       branch_type = hash->root.target_internal;
5085                       sym_name = hash->root.root.root.string;
5086                     }
5087
5088                   do
5089                     {
5090                       /* Determine what (if any) linker stub is needed.  */
5091                       stub_type = arm_type_of_stub (info, section, irela,
5092                                                     st_type, &branch_type,
5093                                                     hash, destination, sym_sec,
5094                                                     input_bfd, sym_name);
5095                       if (stub_type == arm_stub_none)
5096                         break;
5097
5098                       /* Support for grouping stub sections.  */
5099                       id_sec = htab->stub_group[section->id].link_sec;
5100
5101                       /* Get the name of this stub.  */
5102                       stub_name = elf32_arm_stub_name (id_sec, sym_sec, hash,
5103                                                        irela, stub_type);
5104                       if (!stub_name)
5105                         goto error_ret_free_internal;
5106
5107                       /* We've either created a stub for this reloc already,
5108                          or we are about to.  */
5109                       created_stub = TRUE;
5110
5111                       stub_entry = arm_stub_hash_lookup
5112                                      (&htab->stub_hash_table, stub_name,
5113                                       FALSE, FALSE);
5114                       if (stub_entry != NULL)
5115                         {
5116                           /* The proper stub has already been created.  */
5117                           free (stub_name);
5118                           stub_entry->target_value = sym_value;
5119                           break;
5120                         }
5121
5122                       stub_entry = elf32_arm_add_stub (stub_name, section,
5123                                                        htab);
5124                       if (stub_entry == NULL)
5125                         {
5126                           free (stub_name);
5127                           goto error_ret_free_internal;
5128                         }
5129
5130                       stub_entry->target_value = sym_value;
5131                       stub_entry->target_section = sym_sec;
5132                       stub_entry->stub_type = stub_type;
5133                       stub_entry->h = hash;
5134                       stub_entry->branch_type = branch_type;
5135
5136                       if (sym_name == NULL)
5137                         sym_name = "unnamed";
5138                       stub_entry->output_name = (char *)
5139                           bfd_alloc (htab->stub_bfd,
5140                                      sizeof (THUMB2ARM_GLUE_ENTRY_NAME)
5141                                      + strlen (sym_name));
5142                       if (stub_entry->output_name == NULL)
5143                         {
5144                           free (stub_name);
5145                           goto error_ret_free_internal;
5146                         }
5147
5148                       /* For historical reasons, use the existing names for
5149                          ARM-to-Thumb and Thumb-to-ARM stubs.  */
5150                       if ((r_type == (unsigned int) R_ARM_THM_CALL
5151                            || r_type == (unsigned int) R_ARM_THM_JUMP24)
5152                           && branch_type == ST_BRANCH_TO_ARM)
5153                         sprintf (stub_entry->output_name,
5154                                  THUMB2ARM_GLUE_ENTRY_NAME, sym_name);
5155                       else if ((r_type == (unsigned int) R_ARM_CALL
5156                                || r_type == (unsigned int) R_ARM_JUMP24)
5157                                && branch_type == ST_BRANCH_TO_THUMB)
5158                         sprintf (stub_entry->output_name,
5159                                  ARM2THUMB_GLUE_ENTRY_NAME, sym_name);
5160                       else
5161                         sprintf (stub_entry->output_name, STUB_ENTRY_NAME,
5162                                  sym_name);
5163
5164                       stub_changed = TRUE;
5165                     }
5166                   while (0);
5167
5168                   /* Look for relocations which might trigger Cortex-A8
5169                      erratum.  */
5170                   if (htab->fix_cortex_a8
5171                       && (r_type == (unsigned int) R_ARM_THM_JUMP24
5172                           || r_type == (unsigned int) R_ARM_THM_JUMP19
5173                           || r_type == (unsigned int) R_ARM_THM_CALL
5174                           || r_type == (unsigned int) R_ARM_THM_XPC22))
5175                     {
5176                       bfd_vma from = section->output_section->vma
5177                                      + section->output_offset
5178                                      + irela->r_offset;
5179
5180                       if ((from & 0xfff) == 0xffe)
5181                         {
5182                           /* Found a candidate.  Note we haven't checked the
5183                              destination is within 4K here: if we do so (and
5184                              don't create an entry in a8_relocs) we can't tell
5185                              that a branch should have been relocated when
5186                              scanning later.  */
5187                           if (num_a8_relocs == a8_reloc_table_size)
5188                             {
5189                               a8_reloc_table_size *= 2;
5190                               a8_relocs = (struct a8_erratum_reloc *)
5191                                   bfd_realloc (a8_relocs,
5192                                                sizeof (struct a8_erratum_reloc)
5193                                                * a8_reloc_table_size);
5194                             }
5195
5196                           a8_relocs[num_a8_relocs].from = from;
5197                           a8_relocs[num_a8_relocs].destination = destination;
5198                           a8_relocs[num_a8_relocs].r_type = r_type;
5199                           a8_relocs[num_a8_relocs].branch_type = branch_type;
5200                           a8_relocs[num_a8_relocs].sym_name = sym_name;
5201                           a8_relocs[num_a8_relocs].non_a8_stub = created_stub;
5202                           a8_relocs[num_a8_relocs].hash = hash;
5203
5204                           num_a8_relocs++;
5205                         }
5206                     }
5207                 }
5208
5209               /* We're done with the internal relocs, free them.  */
5210               if (elf_section_data (section)->relocs == NULL)
5211                 free (internal_relocs);
5212             }
5213
5214           if (htab->fix_cortex_a8)
5215             {
5216               /* Sort relocs which might apply to Cortex-A8 erratum.  */
5217               qsort (a8_relocs, num_a8_relocs,
5218                      sizeof (struct a8_erratum_reloc),
5219                      &a8_reloc_compare);
5220
5221               /* Scan for branches which might trigger Cortex-A8 erratum.  */
5222               if (cortex_a8_erratum_scan (input_bfd, info, &a8_fixes,
5223                                           &num_a8_fixes, &a8_fix_table_size,
5224                                           a8_relocs, num_a8_relocs,
5225                                           prev_num_a8_fixes, &stub_changed)
5226                   != 0)
5227                 goto error_ret_free_local;
5228             }
5229         }
5230
5231       if (prev_num_a8_fixes != num_a8_fixes)
5232         stub_changed = TRUE;
5233
5234       if (!stub_changed)
5235         break;
5236
5237       /* OK, we've added some stubs.  Find out the new size of the
5238          stub sections.  */
5239       for (stub_sec = htab->stub_bfd->sections;
5240            stub_sec != NULL;
5241            stub_sec = stub_sec->next)
5242         {
5243           /* Ignore non-stub sections.  */
5244           if (!strstr (stub_sec->name, STUB_SUFFIX))
5245             continue;
5246
5247           stub_sec->size = 0;
5248         }
5249
5250       bfd_hash_traverse (&htab->stub_hash_table, arm_size_one_stub, htab);
5251
5252       /* Add Cortex-A8 erratum veneers to stub section sizes too.  */
5253       if (htab->fix_cortex_a8)
5254         for (i = 0; i < num_a8_fixes; i++)
5255           {
5256             stub_sec = elf32_arm_create_or_find_stub_sec (NULL,
5257                          a8_fixes[i].section, htab);
5258
5259             if (stub_sec == NULL)
5260               goto error_ret_free_local;
5261
5262             stub_sec->size
5263               += find_stub_size_and_template (a8_fixes[i].stub_type, NULL,
5264                                               NULL);
5265           }
5266
5267
5268       /* Ask the linker to do its stuff.  */
5269       (*htab->layout_sections_again) ();
5270     }
5271
5272   /* Add stubs for Cortex-A8 erratum fixes now.  */
5273   if (htab->fix_cortex_a8)
5274     {
5275       for (i = 0; i < num_a8_fixes; i++)
5276         {
5277           struct elf32_arm_stub_hash_entry *stub_entry;
5278           char *stub_name = a8_fixes[i].stub_name;
5279           asection *section = a8_fixes[i].section;
5280           unsigned int section_id = a8_fixes[i].section->id;
5281           asection *link_sec = htab->stub_group[section_id].link_sec;
5282           asection *stub_sec = htab->stub_group[section_id].stub_sec;
5283           const insn_sequence *template_sequence;
5284           int template_size, size = 0;
5285
5286           stub_entry = arm_stub_hash_lookup (&htab->stub_hash_table, stub_name,
5287                                              TRUE, FALSE);
5288           if (stub_entry == NULL)
5289             {
5290               (*_bfd_error_handler) (_("%s: cannot create stub entry %s"),
5291                                      section->owner,
5292                                      stub_name);
5293               return FALSE;
5294             }
5295
5296           stub_entry->stub_sec = stub_sec;
5297           stub_entry->stub_offset = 0;
5298           stub_entry->id_sec = link_sec;
5299           stub_entry->stub_type = a8_fixes[i].stub_type;
5300           stub_entry->target_section = a8_fixes[i].section;
5301           stub_entry->target_value = a8_fixes[i].offset;
5302           stub_entry->target_addend = a8_fixes[i].addend;
5303           stub_entry->orig_insn = a8_fixes[i].orig_insn;
5304           stub_entry->branch_type = a8_fixes[i].branch_type;
5305
5306           size = find_stub_size_and_template (a8_fixes[i].stub_type,
5307                                               &template_sequence,
5308                                               &template_size);
5309
5310           stub_entry->stub_size = size;
5311           stub_entry->stub_template = template_sequence;
5312           stub_entry->stub_template_size = template_size;
5313         }
5314
5315       /* Stash the Cortex-A8 erratum fix array for use later in
5316          elf32_arm_write_section().  */
5317       htab->a8_erratum_fixes = a8_fixes;
5318       htab->num_a8_erratum_fixes = num_a8_fixes;
5319     }
5320   else
5321     {
5322       htab->a8_erratum_fixes = NULL;
5323       htab->num_a8_erratum_fixes = 0;
5324     }
5325   return TRUE;
5326
5327  error_ret_free_local:
5328   return FALSE;
5329 }
5330
5331 /* Build all the stubs associated with the current output file.  The
5332    stubs are kept in a hash table attached to the main linker hash
5333    table.  We also set up the .plt entries for statically linked PIC
5334    functions here.  This function is called via arm_elf_finish in the
5335    linker.  */
5336
5337 bfd_boolean
5338 elf32_arm_build_stubs (struct bfd_link_info *info)
5339 {
5340   asection *stub_sec;
5341   struct bfd_hash_table *table;
5342   struct elf32_arm_link_hash_table *htab;
5343
5344   htab = elf32_arm_hash_table (info);
5345   if (htab == NULL)
5346     return FALSE;
5347
5348   for (stub_sec = htab->stub_bfd->sections;
5349        stub_sec != NULL;
5350        stub_sec = stub_sec->next)
5351     {
5352       bfd_size_type size;
5353
5354       /* Ignore non-stub sections.  */
5355       if (!strstr (stub_sec->name, STUB_SUFFIX))
5356         continue;
5357
5358       /* Allocate memory to hold the linker stubs.  */
5359       size = stub_sec->size;
5360       stub_sec->contents = (unsigned char *) bfd_zalloc (htab->stub_bfd, size);
5361       if (stub_sec->contents == NULL && size != 0)
5362         return FALSE;
5363       stub_sec->size = 0;
5364     }
5365
5366   /* Build the stubs as directed by the stub hash table.  */
5367   table = &htab->stub_hash_table;
5368   bfd_hash_traverse (table, arm_build_one_stub, info);
5369   if (htab->fix_cortex_a8)
5370     {
5371       /* Place the cortex a8 stubs last.  */
5372       htab->fix_cortex_a8 = -1;
5373       bfd_hash_traverse (table, arm_build_one_stub, info);
5374     }
5375
5376   return TRUE;
5377 }
5378
5379 /* Locate the Thumb encoded calling stub for NAME.  */
5380
5381 static struct elf_link_hash_entry *
5382 find_thumb_glue (struct bfd_link_info *link_info,
5383                  const char *name,
5384                  char **error_message)
5385 {
5386   char *tmp_name;
5387   struct elf_link_hash_entry *hash;
5388   struct elf32_arm_link_hash_table *hash_table;
5389
5390   /* We need a pointer to the armelf specific hash table.  */
5391   hash_table = elf32_arm_hash_table (link_info);
5392   if (hash_table == NULL)
5393     return NULL;
5394
5395   tmp_name = (char *) bfd_malloc ((bfd_size_type) strlen (name)
5396                                   + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1);
5397
5398   BFD_ASSERT (tmp_name);
5399
5400   sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name);
5401
5402   hash = elf_link_hash_lookup
5403     (&(hash_table)->root, tmp_name, FALSE, FALSE, TRUE);
5404
5405   if (hash == NULL
5406       && asprintf (error_message, _("unable to find THUMB glue '%s' for '%s'"),
5407                    tmp_name, name) == -1)
5408     *error_message = (char *) bfd_errmsg (bfd_error_system_call);
5409
5410   free (tmp_name);
5411
5412   return hash;
5413 }
5414
5415 /* Locate the ARM encoded calling stub for NAME.  */
5416
5417 static struct elf_link_hash_entry *
5418 find_arm_glue (struct bfd_link_info *link_info,
5419                const char *name,
5420                char **error_message)
5421 {
5422   char *tmp_name;
5423   struct elf_link_hash_entry *myh;
5424   struct elf32_arm_link_hash_table *hash_table;
5425
5426   /* We need a pointer to the elfarm specific hash table.  */
5427   hash_table = elf32_arm_hash_table (link_info);
5428   if (hash_table == NULL)
5429     return NULL;
5430
5431   tmp_name = (char *) bfd_malloc ((bfd_size_type) strlen (name)
5432                                   + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1);
5433
5434   BFD_ASSERT (tmp_name);
5435
5436   sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
5437
5438   myh = elf_link_hash_lookup
5439     (&(hash_table)->root, tmp_name, FALSE, FALSE, TRUE);
5440
5441   if (myh == NULL
5442       && asprintf (error_message, _("unable to find ARM glue '%s' for '%s'"),
5443                    tmp_name, name) == -1)
5444     *error_message = (char *) bfd_errmsg (bfd_error_system_call);
5445
5446   free (tmp_name);
5447
5448   return myh;
5449 }
5450
5451 /* ARM->Thumb glue (static images):
5452
5453    .arm
5454    __func_from_arm:
5455    ldr r12, __func_addr
5456    bx  r12
5457    __func_addr:
5458    .word func    @ behave as if you saw a ARM_32 reloc.
5459
5460    (v5t static images)
5461    .arm
5462    __func_from_arm:
5463    ldr pc, __func_addr
5464    __func_addr:
5465    .word func    @ behave as if you saw a ARM_32 reloc.
5466
5467    (relocatable images)
5468    .arm
5469    __func_from_arm:
5470    ldr r12, __func_offset
5471    add r12, r12, pc
5472    bx  r12
5473    __func_offset:
5474    .word func - .   */
5475
5476 #define ARM2THUMB_STATIC_GLUE_SIZE 12
5477 static const insn32 a2t1_ldr_insn = 0xe59fc000;
5478 static const insn32 a2t2_bx_r12_insn = 0xe12fff1c;
5479 static const insn32 a2t3_func_addr_insn = 0x00000001;
5480
5481 #define ARM2THUMB_V5_STATIC_GLUE_SIZE 8
5482 static const insn32 a2t1v5_ldr_insn = 0xe51ff004;
5483 static const insn32 a2t2v5_func_addr_insn = 0x00000001;
5484
5485 #define ARM2THUMB_PIC_GLUE_SIZE 16
5486 static const insn32 a2t1p_ldr_insn = 0xe59fc004;
5487 static const insn32 a2t2p_add_pc_insn = 0xe08cc00f;
5488 static const insn32 a2t3p_bx_r12_insn = 0xe12fff1c;
5489
5490 /* Thumb->ARM:                          Thumb->(non-interworking aware) ARM
5491
5492      .thumb                             .thumb
5493      .align 2                           .align 2
5494  __func_from_thumb:                 __func_from_thumb:
5495      bx pc                              push {r6, lr}
5496      nop                                ldr  r6, __func_addr
5497      .arm                               mov  lr, pc
5498      b func                             bx   r6
5499                                         .arm
5500                                     ;; back_to_thumb
5501                                         ldmia r13! {r6, lr}
5502                                         bx    lr
5503                                     __func_addr:
5504                                         .word        func  */
5505
5506 #define THUMB2ARM_GLUE_SIZE 8
5507 static const insn16 t2a1_bx_pc_insn = 0x4778;
5508 static const insn16 t2a2_noop_insn = 0x46c0;
5509 static const insn32 t2a3_b_insn = 0xea000000;
5510
5511 #define VFP11_ERRATUM_VENEER_SIZE 8
5512
5513 #define ARM_BX_VENEER_SIZE 12
5514 static const insn32 armbx1_tst_insn = 0xe3100001;
5515 static const insn32 armbx2_moveq_insn = 0x01a0f000;
5516 static const insn32 armbx3_bx_insn = 0xe12fff10;
5517
5518 #ifndef ELFARM_NABI_C_INCLUDED
5519 static void
5520 arm_allocate_glue_section_space (bfd * abfd, bfd_size_type size, const char * name)
5521 {
5522   asection * s;
5523   bfd_byte * contents;
5524
5525   if (size == 0)
5526     {
5527       /* Do not include empty glue sections in the output.  */
5528       if (abfd != NULL)
5529         {
5530           s = bfd_get_section_by_name (abfd, name);
5531           if (s != NULL)
5532             s->flags |= SEC_EXCLUDE;
5533         }
5534       return;
5535     }
5536
5537   BFD_ASSERT (abfd != NULL);
5538
5539   s = bfd_get_section_by_name (abfd, name);
5540   BFD_ASSERT (s != NULL);
5541
5542   contents = (bfd_byte *) bfd_alloc (abfd, size);
5543
5544   BFD_ASSERT (s->size == size);
5545   s->contents = contents;
5546 }
5547
5548 bfd_boolean
5549 bfd_elf32_arm_allocate_interworking_sections (struct bfd_link_info * info)
5550 {
5551   struct elf32_arm_link_hash_table * globals;
5552
5553   globals = elf32_arm_hash_table (info);
5554   BFD_ASSERT (globals != NULL);
5555
5556   arm_allocate_glue_section_space (globals->bfd_of_glue_owner,
5557                                    globals->arm_glue_size,
5558                                    ARM2THUMB_GLUE_SECTION_NAME);
5559
5560   arm_allocate_glue_section_space (globals->bfd_of_glue_owner,
5561                                    globals->thumb_glue_size,
5562                                    THUMB2ARM_GLUE_SECTION_NAME);
5563
5564   arm_allocate_glue_section_space (globals->bfd_of_glue_owner,
5565                                    globals->vfp11_erratum_glue_size,
5566                                    VFP11_ERRATUM_VENEER_SECTION_NAME);
5567
5568   arm_allocate_glue_section_space (globals->bfd_of_glue_owner,
5569                                    globals->bx_glue_size,
5570                                    ARM_BX_GLUE_SECTION_NAME);
5571
5572   return TRUE;
5573 }
5574
5575 /* Allocate space and symbols for calling a Thumb function from Arm mode.
5576    returns the symbol identifying the stub.  */
5577
5578 static struct elf_link_hash_entry *
5579 record_arm_to_thumb_glue (struct bfd_link_info * link_info,
5580                           struct elf_link_hash_entry * h)
5581 {
5582   const char * name = h->root.root.string;
5583   asection * s;
5584   char * tmp_name;
5585   struct elf_link_hash_entry * myh;
5586   struct bfd_link_hash_entry * bh;
5587   struct elf32_arm_link_hash_table * globals;
5588   bfd_vma val;
5589   bfd_size_type size;
5590
5591   globals = elf32_arm_hash_table (link_info);
5592   BFD_ASSERT (globals != NULL);
5593   BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
5594
5595   s = bfd_get_section_by_name
5596     (globals->bfd_of_glue_owner, ARM2THUMB_GLUE_SECTION_NAME);
5597
5598   BFD_ASSERT (s != NULL);
5599
5600   tmp_name = (char *) bfd_malloc ((bfd_size_type) strlen (name)
5601                                   + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1);
5602
5603   BFD_ASSERT (tmp_name);
5604
5605   sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
5606
5607   myh = elf_link_hash_lookup
5608     (&(globals)->root, tmp_name, FALSE, FALSE, TRUE);
5609
5610   if (myh != NULL)
5611     {
5612       /* We've already seen this guy.  */
5613       free (tmp_name);
5614       return myh;
5615     }
5616
5617   /* The only trick here is using hash_table->arm_glue_size as the value.
5618      Even though the section isn't allocated yet, this is where we will be
5619      putting it.  The +1 on the value marks that the stub has not been
5620      output yet - not that it is a Thumb function.  */
5621   bh = NULL;
5622   val = globals->arm_glue_size + 1;
5623   _bfd_generic_link_add_one_symbol (link_info, globals->bfd_of_glue_owner,
5624                                     tmp_name, BSF_GLOBAL, s, val,
5625                                     NULL, TRUE, FALSE, &bh);
5626
5627   myh = (struct elf_link_hash_entry *) bh;
5628   myh->type = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
5629   myh->forced_local = 1;
5630
5631   free (tmp_name);
5632
5633   if (link_info->shared || globals->root.is_relocatable_executable
5634       || globals->pic_veneer)
5635     size = ARM2THUMB_PIC_GLUE_SIZE;
5636   else if (globals->use_blx)
5637     size = ARM2THUMB_V5_STATIC_GLUE_SIZE;
5638   else
5639     size = ARM2THUMB_STATIC_GLUE_SIZE;
5640
5641   s->size += size;
5642   globals->arm_glue_size += size;
5643
5644   return myh;
5645 }
5646
5647 /* Allocate space for ARMv4 BX veneers.  */
5648
5649 static void
5650 record_arm_bx_glue (struct bfd_link_info * link_info, int reg)
5651 {
5652   asection * s;
5653   struct elf32_arm_link_hash_table *globals;
5654   char *tmp_name;
5655   struct elf_link_hash_entry *myh;
5656   struct bfd_link_hash_entry *bh;
5657   bfd_vma val;
5658
5659   /* BX PC does not need a veneer.  */
5660   if (reg == 15)
5661     return;
5662
5663   globals = elf32_arm_hash_table (link_info);
5664   BFD_ASSERT (globals != NULL);
5665   BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
5666
5667   /* Check if this veneer has already been allocated.  */
5668   if (globals->bx_glue_offset[reg])
5669     return;
5670
5671   s = bfd_get_section_by_name
5672     (globals->bfd_of_glue_owner, ARM_BX_GLUE_SECTION_NAME);
5673
5674   BFD_ASSERT (s != NULL);
5675
5676   /* Add symbol for veneer.  */
5677   tmp_name = (char *)
5678       bfd_malloc ((bfd_size_type) strlen (ARM_BX_GLUE_ENTRY_NAME) + 1);
5679
5680   BFD_ASSERT (tmp_name);
5681
5682   sprintf (tmp_name, ARM_BX_GLUE_ENTRY_NAME, reg);
5683
5684   myh = elf_link_hash_lookup
5685     (&(globals)->root, tmp_name, FALSE, FALSE, FALSE);
5686
5687   BFD_ASSERT (myh == NULL);
5688
5689   bh = NULL;
5690   val = globals->bx_glue_size;
5691   _bfd_generic_link_add_one_symbol (link_info, globals->bfd_of_glue_owner,
5692                                     tmp_name, BSF_FUNCTION | BSF_LOCAL, s, val,
5693                                     NULL, TRUE, FALSE, &bh);
5694
5695   myh = (struct elf_link_hash_entry *) bh;
5696   myh->type = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
5697   myh->forced_local = 1;
5698
5699   s->size += ARM_BX_VENEER_SIZE;
5700   globals->bx_glue_offset[reg] = globals->bx_glue_size | 2;
5701   globals->bx_glue_size += ARM_BX_VENEER_SIZE;
5702 }
5703
5704
5705 /* Add an entry to the code/data map for section SEC.  */
5706
5707 static void
5708 elf32_arm_section_map_add (asection *sec, char type, bfd_vma vma)
5709 {
5710   struct _arm_elf_section_data *sec_data = elf32_arm_section_data (sec);
5711   unsigned int newidx;
5712
5713   if (sec_data->map == NULL)
5714     {
5715       sec_data->map = (elf32_arm_section_map *)
5716           bfd_malloc (sizeof (elf32_arm_section_map));
5717       sec_data->mapcount = 0;
5718       sec_data->mapsize = 1;
5719     }
5720
5721   newidx = sec_data->mapcount++;
5722
5723   if (sec_data->mapcount > sec_data->mapsize)
5724     {
5725       sec_data->mapsize *= 2;
5726       sec_data->map = (elf32_arm_section_map *)
5727           bfd_realloc_or_free (sec_data->map, sec_data->mapsize
5728                                * sizeof (elf32_arm_section_map));
5729     }
5730
5731   if (sec_data->map)
5732     {
5733       sec_data->map[newidx].vma = vma;
5734       sec_data->map[newidx].type = type;
5735     }
5736 }
5737
5738
5739 /* Record information about a VFP11 denorm-erratum veneer.  Only ARM-mode
5740    veneers are handled for now.  */
5741
5742 static bfd_vma
5743 record_vfp11_erratum_veneer (struct bfd_link_info *link_info,
5744                              elf32_vfp11_erratum_list *branch,
5745                              bfd *branch_bfd,
5746                              asection *branch_sec,
5747                              unsigned int offset)
5748 {
5749   asection *s;
5750   struct elf32_arm_link_hash_table *hash_table;
5751   char *tmp_name;
5752   struct elf_link_hash_entry *myh;
5753   struct bfd_link_hash_entry *bh;
5754   bfd_vma val;
5755   struct _arm_elf_section_data *sec_data;
5756   elf32_vfp11_erratum_list *newerr;
5757
5758   hash_table = elf32_arm_hash_table (link_info);
5759   BFD_ASSERT (hash_table != NULL);
5760   BFD_ASSERT (hash_table->bfd_of_glue_owner != NULL);
5761
5762   s = bfd_get_section_by_name
5763     (hash_table->bfd_of_glue_owner, VFP11_ERRATUM_VENEER_SECTION_NAME);
5764
5765   sec_data = elf32_arm_section_data (s);
5766
5767   BFD_ASSERT (s != NULL);
5768
5769   tmp_name = (char *) bfd_malloc ((bfd_size_type) strlen
5770                                   (VFP11_ERRATUM_VENEER_ENTRY_NAME) + 10);
5771
5772   BFD_ASSERT (tmp_name);
5773
5774   sprintf (tmp_name, VFP11_ERRATUM_VENEER_ENTRY_NAME,
5775            hash_table->num_vfp11_fixes);
5776
5777   myh = elf_link_hash_lookup
5778     (&(hash_table)->root, tmp_name, FALSE, FALSE, FALSE);
5779
5780   BFD_ASSERT (myh == NULL);
5781
5782   bh = NULL;
5783   val = hash_table->vfp11_erratum_glue_size;
5784   _bfd_generic_link_add_one_symbol (link_info, hash_table->bfd_of_glue_owner,
5785                                     tmp_name, BSF_FUNCTION | BSF_LOCAL, s, val,
5786                                     NULL, TRUE, FALSE, &bh);
5787
5788   myh = (struct elf_link_hash_entry *) bh;
5789   myh->type = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
5790   myh->forced_local = 1;
5791
5792   /* Link veneer back to calling location.  */
5793   sec_data->erratumcount += 1;
5794   newerr = (elf32_vfp11_erratum_list *)
5795       bfd_zmalloc (sizeof (elf32_vfp11_erratum_list));
5796
5797   newerr->type = VFP11_ERRATUM_ARM_VENEER;
5798   newerr->vma = -1;
5799   newerr->u.v.branch = branch;
5800   newerr->u.v.id = hash_table->num_vfp11_fixes;
5801   branch->u.b.veneer = newerr;
5802
5803   newerr->next = sec_data->erratumlist;
5804   sec_data->erratumlist = newerr;
5805
5806   /* A symbol for the return from the veneer.  */
5807   sprintf (tmp_name, VFP11_ERRATUM_VENEER_ENTRY_NAME "_r",
5808            hash_table->num_vfp11_fixes);
5809
5810   myh = elf_link_hash_lookup
5811     (&(hash_table)->root, tmp_name, FALSE, FALSE, FALSE);
5812
5813   if (myh != NULL)
5814     abort ();
5815
5816   bh = NULL;
5817   val = offset + 4;
5818   _bfd_generic_link_add_one_symbol (link_info, branch_bfd, tmp_name, BSF_LOCAL,
5819                                     branch_sec, val, NULL, TRUE, FALSE, &bh);
5820
5821   myh = (struct elf_link_hash_entry *) bh;
5822   myh->type = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
5823   myh->forced_local = 1;
5824
5825   free (tmp_name);
5826
5827   /* Generate a mapping symbol for the veneer section, and explicitly add an
5828      entry for that symbol to the code/data map for the section.  */
5829   if (hash_table->vfp11_erratum_glue_size == 0)
5830     {
5831       bh = NULL;
5832       /* FIXME: Creates an ARM symbol.  Thumb mode will need attention if it
5833          ever requires this erratum fix.  */
5834       _bfd_generic_link_add_one_symbol (link_info,
5835                                         hash_table->bfd_of_glue_owner, "$a",
5836                                         BSF_LOCAL, s, 0, NULL,
5837                                         TRUE, FALSE, &bh);
5838
5839       myh = (struct elf_link_hash_entry *) bh;
5840       myh->type = ELF_ST_INFO (STB_LOCAL, STT_NOTYPE);
5841       myh->forced_local = 1;
5842
5843       /* The elf32_arm_init_maps function only cares about symbols from input
5844          BFDs.  We must make a note of this generated mapping symbol
5845          ourselves so that code byteswapping works properly in
5846          elf32_arm_write_section.  */
5847       elf32_arm_section_map_add (s, 'a', 0);
5848     }
5849
5850   s->size += VFP11_ERRATUM_VENEER_SIZE;
5851   hash_table->vfp11_erratum_glue_size += VFP11_ERRATUM_VENEER_SIZE;
5852   hash_table->num_vfp11_fixes++;
5853
5854   /* The offset of the veneer.  */
5855   return val;
5856 }
5857
5858 #define ARM_GLUE_SECTION_FLAGS \
5859   (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_CODE \
5860    | SEC_READONLY | SEC_LINKER_CREATED)
5861
5862 /* Create a fake section for use by the ARM backend of the linker.  */
5863
5864 static bfd_boolean
5865 arm_make_glue_section (bfd * abfd, const char * name)
5866 {
5867   asection * sec;
5868
5869   sec = bfd_get_section_by_name (abfd, name);
5870   if (sec != NULL)
5871     /* Already made.  */
5872     return TRUE;
5873
5874   sec = bfd_make_section_with_flags (abfd, name, ARM_GLUE_SECTION_FLAGS);
5875
5876   if (sec == NULL
5877       || !bfd_set_section_alignment (abfd, sec, 2))
5878     return FALSE;
5879
5880   /* Set the gc mark to prevent the section from being removed by garbage
5881      collection, despite the fact that no relocs refer to this section.  */
5882   sec->gc_mark = 1;
5883
5884   return TRUE;
5885 }
5886
5887 /* Add the glue sections to ABFD.  This function is called from the
5888    linker scripts in ld/emultempl/{armelf}.em.  */
5889
5890 bfd_boolean
5891 bfd_elf32_arm_add_glue_sections_to_bfd (bfd *abfd,
5892                                         struct bfd_link_info *info)
5893 {
5894   /* If we are only performing a partial
5895      link do not bother adding the glue.  */
5896   if (info->relocatable)
5897     return TRUE;
5898
5899   return arm_make_glue_section (abfd, ARM2THUMB_GLUE_SECTION_NAME)
5900     && arm_make_glue_section (abfd, THUMB2ARM_GLUE_SECTION_NAME)
5901     && arm_make_glue_section (abfd, VFP11_ERRATUM_VENEER_SECTION_NAME)
5902     && arm_make_glue_section (abfd, ARM_BX_GLUE_SECTION_NAME);
5903 }
5904
5905 /* Select a BFD to be used to hold the sections used by the glue code.
5906    This function is called from the linker scripts in ld/emultempl/
5907    {armelf/pe}.em.  */
5908
5909 bfd_boolean
5910 bfd_elf32_arm_get_bfd_for_interworking (bfd *abfd, struct bfd_link_info *info)
5911 {
5912   struct elf32_arm_link_hash_table *globals;
5913
5914   /* If we are only performing a partial link
5915      do not bother getting a bfd to hold the glue.  */
5916   if (info->relocatable)
5917     return TRUE;
5918
5919   /* Make sure we don't attach the glue sections to a dynamic object.  */
5920   BFD_ASSERT (!(abfd->flags & DYNAMIC));
5921
5922   globals = elf32_arm_hash_table (info);
5923   BFD_ASSERT (globals != NULL);
5924
5925   if (globals->bfd_of_glue_owner != NULL)
5926     return TRUE;
5927
5928   /* Save the bfd for later use.  */
5929   globals->bfd_of_glue_owner = abfd;
5930
5931   return TRUE;
5932 }
5933
5934 static void
5935 check_use_blx (struct elf32_arm_link_hash_table *globals)
5936 {
5937   int cpu_arch;
5938
5939   cpu_arch = bfd_elf_get_obj_attr_int (globals->obfd, OBJ_ATTR_PROC,
5940                                        Tag_CPU_arch);
5941
5942   if (globals->fix_arm1176)
5943     {
5944       if (cpu_arch == TAG_CPU_ARCH_V6T2 || cpu_arch > TAG_CPU_ARCH_V6K)
5945         globals->use_blx = 1;
5946     }
5947   else
5948     {
5949       if (cpu_arch > TAG_CPU_ARCH_V4T)
5950         globals->use_blx = 1;
5951     }
5952 }
5953
5954 bfd_boolean
5955 bfd_elf32_arm_process_before_allocation (bfd *abfd,
5956                                          struct bfd_link_info *link_info)
5957 {
5958   Elf_Internal_Shdr *symtab_hdr;
5959   Elf_Internal_Rela *internal_relocs = NULL;
5960   Elf_Internal_Rela *irel, *irelend;
5961   bfd_byte *contents = NULL;
5962
5963   asection *sec;
5964   struct elf32_arm_link_hash_table *globals;
5965
5966   /* If we are only performing a partial link do not bother
5967      to construct any glue.  */
5968   if (link_info->relocatable)
5969     return TRUE;
5970
5971   /* Here we have a bfd that is to be included on the link.  We have a
5972      hook to do reloc rummaging, before section sizes are nailed down.  */
5973   globals = elf32_arm_hash_table (link_info);
5974   BFD_ASSERT (globals != NULL);
5975
5976   check_use_blx (globals);
5977
5978   if (globals->byteswap_code && !bfd_big_endian (abfd))
5979     {
5980       _bfd_error_handler (_("%B: BE8 images only valid in big-endian mode."),
5981                           abfd);
5982       return FALSE;
5983     }
5984
5985   /* PR 5398: If we have not decided to include any loadable sections in
5986      the output then we will not have a glue owner bfd.  This is OK, it
5987      just means that there is nothing else for us to do here.  */
5988   if (globals->bfd_of_glue_owner == NULL)
5989     return TRUE;
5990
5991   /* Rummage around all the relocs and map the glue vectors.  */
5992   sec = abfd->sections;
5993
5994   if (sec == NULL)
5995     return TRUE;
5996
5997   for (; sec != NULL; sec = sec->next)
5998     {
5999       if (sec->reloc_count == 0)
6000         continue;
6001
6002       if ((sec->flags & SEC_EXCLUDE) != 0)
6003         continue;
6004
6005       symtab_hdr = & elf_symtab_hdr (abfd);
6006
6007       /* Load the relocs.  */
6008       internal_relocs
6009         = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL, FALSE);
6010
6011       if (internal_relocs == NULL)
6012         goto error_return;
6013
6014       irelend = internal_relocs + sec->reloc_count;
6015       for (irel = internal_relocs; irel < irelend; irel++)
6016         {
6017           long r_type;
6018           unsigned long r_index;
6019
6020           struct elf_link_hash_entry *h;
6021
6022           r_type = ELF32_R_TYPE (irel->r_info);
6023           r_index = ELF32_R_SYM (irel->r_info);
6024
6025           /* These are the only relocation types we care about.  */
6026           if (   r_type != R_ARM_PC24
6027               && (r_type != R_ARM_V4BX || globals->fix_v4bx < 2))
6028             continue;
6029
6030           /* Get the section contents if we haven't done so already.  */
6031           if (contents == NULL)
6032             {
6033               /* Get cached copy if it exists.  */
6034               if (elf_section_data (sec)->this_hdr.contents != NULL)
6035                 contents = elf_section_data (sec)->this_hdr.contents;
6036               else
6037                 {
6038                   /* Go get them off disk.  */
6039                   if (! bfd_malloc_and_get_section (abfd, sec, &contents))
6040                     goto error_return;
6041                 }
6042             }
6043
6044           if (r_type == R_ARM_V4BX)
6045             {
6046               int reg;
6047
6048               reg = bfd_get_32 (abfd, contents + irel->r_offset) & 0xf;
6049               record_arm_bx_glue (link_info, reg);
6050               continue;
6051             }
6052
6053           /* If the relocation is not against a symbol it cannot concern us.  */
6054           h = NULL;
6055
6056           /* We don't care about local symbols.  */
6057           if (r_index < symtab_hdr->sh_info)
6058             continue;
6059
6060           /* This is an external symbol.  */
6061           r_index -= symtab_hdr->sh_info;
6062           h = (struct elf_link_hash_entry *)
6063             elf_sym_hashes (abfd)[r_index];
6064
6065           /* If the relocation is against a static symbol it must be within
6066              the current section and so cannot be a cross ARM/Thumb relocation.  */
6067           if (h == NULL)
6068             continue;
6069
6070           /* If the call will go through a PLT entry then we do not need
6071              glue.  */
6072           if (globals->root.splt != NULL && h->plt.offset != (bfd_vma) -1)
6073             continue;
6074
6075           switch (r_type)
6076             {
6077             case R_ARM_PC24:
6078               /* This one is a call from arm code.  We need to look up
6079                  the target of the call.  If it is a thumb target, we
6080                  insert glue.  */
6081               if (h->target_internal == ST_BRANCH_TO_THUMB)
6082                 record_arm_to_thumb_glue (link_info, h);
6083               break;
6084
6085             default:
6086               abort ();
6087             }
6088         }
6089
6090       if (contents != NULL
6091           && elf_section_data (sec)->this_hdr.contents != contents)
6092         free (contents);
6093       contents = NULL;
6094
6095       if (internal_relocs != NULL
6096           && elf_section_data (sec)->relocs != internal_relocs)
6097         free (internal_relocs);
6098       internal_relocs = NULL;
6099     }
6100
6101   return TRUE;
6102
6103 error_return:
6104   if (contents != NULL
6105       && elf_section_data (sec)->this_hdr.contents != contents)
6106     free (contents);
6107   if (internal_relocs != NULL
6108       && elf_section_data (sec)->relocs != internal_relocs)
6109     free (internal_relocs);
6110
6111   return FALSE;
6112 }
6113 #endif
6114
6115
6116 /* Initialise maps of ARM/Thumb/data for input BFDs.  */
6117
6118 void
6119 bfd_elf32_arm_init_maps (bfd *abfd)
6120 {
6121   Elf_Internal_Sym *isymbuf;
6122   Elf_Internal_Shdr *hdr;
6123   unsigned int i, localsyms;
6124
6125   /* PR 7093: Make sure that we are dealing with an arm elf binary.  */
6126   if (! is_arm_elf (abfd))
6127     return;
6128
6129   if ((abfd->flags & DYNAMIC) != 0)
6130     return;
6131
6132   hdr = & elf_symtab_hdr (abfd);
6133   localsyms = hdr->sh_info;
6134
6135   /* Obtain a buffer full of symbols for this BFD. The hdr->sh_info field
6136      should contain the number of local symbols, which should come before any
6137      global symbols.  Mapping symbols are always local.  */
6138   isymbuf = bfd_elf_get_elf_syms (abfd, hdr, localsyms, 0, NULL, NULL,
6139                                   NULL);
6140
6141   /* No internal symbols read?  Skip this BFD.  */
6142   if (isymbuf == NULL)
6143     return;
6144
6145   for (i = 0; i < localsyms; i++)
6146     {
6147       Elf_Internal_Sym *isym = &isymbuf[i];
6148       asection *sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
6149       const char *name;
6150
6151       if (sec != NULL
6152           && ELF_ST_BIND (isym->st_info) == STB_LOCAL)
6153         {
6154           name = bfd_elf_string_from_elf_section (abfd,
6155             hdr->sh_link, isym->st_name);
6156
6157           if (bfd_is_arm_special_symbol_name (name,
6158                                               BFD_ARM_SPECIAL_SYM_TYPE_MAP))
6159             elf32_arm_section_map_add (sec, name[1], isym->st_value);
6160         }
6161     }
6162 }
6163
6164
6165 /* Auto-select enabling of Cortex-A8 erratum fix if the user didn't explicitly
6166    say what they wanted.  */
6167
6168 void
6169 bfd_elf32_arm_set_cortex_a8_fix (bfd *obfd, struct bfd_link_info *link_info)
6170 {
6171   struct elf32_arm_link_hash_table *globals = elf32_arm_hash_table (link_info);
6172   obj_attribute *out_attr = elf_known_obj_attributes_proc (obfd);
6173
6174   if (globals == NULL)
6175     return;
6176
6177   if (globals->fix_cortex_a8 == -1)
6178     {
6179       /* Turn on Cortex-A8 erratum workaround for ARMv7-A.  */
6180       if (out_attr[Tag_CPU_arch].i == TAG_CPU_ARCH_V7
6181           && (out_attr[Tag_CPU_arch_profile].i == 'A'
6182               || out_attr[Tag_CPU_arch_profile].i == 0))
6183         globals->fix_cortex_a8 = 1;
6184       else
6185         globals->fix_cortex_a8 = 0;
6186     }
6187 }
6188
6189
6190 void
6191 bfd_elf32_arm_set_vfp11_fix (bfd *obfd, struct bfd_link_info *link_info)
6192 {
6193   struct elf32_arm_link_hash_table *globals = elf32_arm_hash_table (link_info);
6194   obj_attribute *out_attr = elf_known_obj_attributes_proc (obfd);
6195
6196   if (globals == NULL)
6197     return;
6198   /* We assume that ARMv7+ does not need the VFP11 denorm erratum fix.  */
6199   if (out_attr[Tag_CPU_arch].i >= TAG_CPU_ARCH_V7)
6200     {
6201       switch (globals->vfp11_fix)
6202         {
6203         case BFD_ARM_VFP11_FIX_DEFAULT:
6204         case BFD_ARM_VFP11_FIX_NONE:
6205           globals->vfp11_fix = BFD_ARM_VFP11_FIX_NONE;
6206           break;
6207
6208         default:
6209           /* Give a warning, but do as the user requests anyway.  */
6210           (*_bfd_error_handler) (_("%B: warning: selected VFP11 erratum "
6211             "workaround is not necessary for target architecture"), obfd);
6212         }
6213     }
6214   else if (globals->vfp11_fix == BFD_ARM_VFP11_FIX_DEFAULT)
6215     /* For earlier architectures, we might need the workaround, but do not
6216        enable it by default.  If users is running with broken hardware, they
6217        must enable the erratum fix explicitly.  */
6218     globals->vfp11_fix = BFD_ARM_VFP11_FIX_NONE;
6219 }
6220
6221
6222 enum bfd_arm_vfp11_pipe
6223 {
6224   VFP11_FMAC,
6225   VFP11_LS,
6226   VFP11_DS,
6227   VFP11_BAD
6228 };
6229
6230 /* Return a VFP register number.  This is encoded as RX:X for single-precision
6231    registers, or X:RX for double-precision registers, where RX is the group of
6232    four bits in the instruction encoding and X is the single extension bit.
6233    RX and X fields are specified using their lowest (starting) bit.  The return
6234    value is:
6235
6236      0...31: single-precision registers s0...s31
6237      32...63: double-precision registers d0...d31.
6238
6239    Although X should be zero for VFP11 (encoding d0...d15 only), we might
6240    encounter VFP3 instructions, so we allow the full range for DP registers.  */
6241
6242 static unsigned int
6243 bfd_arm_vfp11_regno (unsigned int insn, bfd_boolean is_double, unsigned int rx,
6244                      unsigned int x)
6245 {
6246   if (is_double)
6247     return (((insn >> rx) & 0xf) | (((insn >> x) & 1) << 4)) + 32;
6248   else
6249     return (((insn >> rx) & 0xf) << 1) | ((insn >> x) & 1);
6250 }
6251
6252 /* Set bits in *WMASK according to a register number REG as encoded by
6253    bfd_arm_vfp11_regno().  Ignore d16-d31.  */
6254
6255 static void
6256 bfd_arm_vfp11_write_mask (unsigned int *wmask, unsigned int reg)
6257 {
6258   if (reg < 32)
6259     *wmask |= 1 << reg;
6260   else if (reg < 48)
6261     *wmask |= 3 << ((reg - 32) * 2);
6262 }
6263
6264 /* Return TRUE if WMASK overwrites anything in REGS.  */
6265
6266 static bfd_boolean
6267 bfd_arm_vfp11_antidependency (unsigned int wmask, int *regs, int numregs)
6268 {
6269   int i;
6270
6271   for (i = 0; i < numregs; i++)
6272     {
6273       unsigned int reg = regs[i];
6274
6275       if (reg < 32 && (wmask & (1 << reg)) != 0)
6276         return TRUE;
6277
6278       reg -= 32;
6279
6280       if (reg >= 16)
6281         continue;
6282
6283       if ((wmask & (3 << (reg * 2))) != 0)
6284         return TRUE;
6285     }
6286
6287   return FALSE;
6288 }
6289
6290 /* In this function, we're interested in two things: finding input registers
6291    for VFP data-processing instructions, and finding the set of registers which
6292    arbitrary VFP instructions may write to.  We use a 32-bit unsigned int to
6293    hold the written set, so FLDM etc. are easy to deal with (we're only
6294    interested in 32 SP registers or 16 dp registers, due to the VFP version
6295    implemented by the chip in question).  DP registers are marked by setting
6296    both SP registers in the write mask).  */
6297
6298 static enum bfd_arm_vfp11_pipe
6299 bfd_arm_vfp11_insn_decode (unsigned int insn, unsigned int *destmask, int *regs,
6300                            int *numregs)
6301 {
6302   enum bfd_arm_vfp11_pipe vpipe = VFP11_BAD;
6303   bfd_boolean is_double = ((insn & 0xf00) == 0xb00) ? 1 : 0;
6304
6305   if ((insn & 0x0f000e10) == 0x0e000a00)  /* A data-processing insn.  */
6306     {
6307       unsigned int pqrs;
6308       unsigned int fd = bfd_arm_vfp11_regno (insn, is_double, 12, 22);
6309       unsigned int fm = bfd_arm_vfp11_regno (insn, is_double, 0, 5);
6310
6311       pqrs = ((insn & 0x00800000) >> 20)
6312            | ((insn & 0x00300000) >> 19)
6313            | ((insn & 0x00000040) >> 6);
6314
6315       switch (pqrs)
6316         {
6317         case 0: /* fmac[sd].  */
6318         case 1: /* fnmac[sd].  */
6319         case 2: /* fmsc[sd].  */
6320         case 3: /* fnmsc[sd].  */
6321           vpipe = VFP11_FMAC;
6322           bfd_arm_vfp11_write_mask (destmask, fd);
6323           regs[0] = fd;
6324           regs[1] = bfd_arm_vfp11_regno (insn, is_double, 16, 7);  /* Fn.  */
6325           regs[2] = fm;
6326           *numregs = 3;
6327           break;
6328
6329         case 4: /* fmul[sd].  */
6330         case 5: /* fnmul[sd].  */
6331         case 6: /* fadd[sd].  */
6332         case 7: /* fsub[sd].  */
6333           vpipe = VFP11_FMAC;
6334           goto vfp_binop;
6335
6336         case 8: /* fdiv[sd].  */
6337           vpipe = VFP11_DS;
6338           vfp_binop:
6339           bfd_arm_vfp11_write_mask (destmask, fd);
6340           regs[0] = bfd_arm_vfp11_regno (insn, is_double, 16, 7);   /* Fn.  */
6341           regs[1] = fm;
6342           *numregs = 2;
6343           break;
6344
6345         case 15: /* extended opcode.  */
6346           {
6347             unsigned int extn = ((insn >> 15) & 0x1e)
6348                               | ((insn >> 7) & 1);
6349
6350             switch (extn)
6351               {
6352               case 0: /* fcpy[sd].  */
6353               case 1: /* fabs[sd].  */
6354               case 2: /* fneg[sd].  */
6355               case 8: /* fcmp[sd].  */
6356               case 9: /* fcmpe[sd].  */
6357               case 10: /* fcmpz[sd].  */
6358               case 11: /* fcmpez[sd].  */
6359               case 16: /* fuito[sd].  */
6360               case 17: /* fsito[sd].  */
6361               case 24: /* ftoui[sd].  */
6362               case 25: /* ftouiz[sd].  */
6363               case 26: /* ftosi[sd].  */
6364               case 27: /* ftosiz[sd].  */
6365                 /* These instructions will not bounce due to underflow.  */
6366                 *numregs = 0;
6367                 vpipe = VFP11_FMAC;
6368                 break;
6369
6370               case 3: /* fsqrt[sd].  */
6371                 /* fsqrt cannot underflow, but it can (perhaps) overwrite
6372                    registers to cause the erratum in previous instructions.  */
6373                 bfd_arm_vfp11_write_mask (destmask, fd);
6374                 vpipe = VFP11_DS;
6375                 break;
6376
6377               case 15: /* fcvt{ds,sd}.  */
6378                 {
6379                   int rnum = 0;
6380
6381                   bfd_arm_vfp11_write_mask (destmask, fd);
6382
6383                   /* Only FCVTSD can underflow.  */
6384                   if ((insn & 0x100) != 0)
6385                     regs[rnum++] = fm;
6386
6387                   *numregs = rnum;
6388
6389                   vpipe = VFP11_FMAC;
6390                 }
6391                 break;
6392
6393               default:
6394                 return VFP11_BAD;
6395               }
6396           }
6397           break;
6398
6399         default:
6400           return VFP11_BAD;
6401         }
6402     }
6403   /* Two-register transfer.  */
6404   else if ((insn & 0x0fe00ed0) == 0x0c400a10)
6405     {
6406       unsigned int fm = bfd_arm_vfp11_regno (insn, is_double, 0, 5);
6407
6408       if ((insn & 0x100000) == 0)
6409         {
6410           if (is_double)
6411             bfd_arm_vfp11_write_mask (destmask, fm);
6412           else
6413             {
6414               bfd_arm_vfp11_write_mask (destmask, fm);
6415               bfd_arm_vfp11_write_mask (destmask, fm + 1);
6416             }
6417         }
6418
6419       vpipe = VFP11_LS;
6420     }
6421   else if ((insn & 0x0e100e00) == 0x0c100a00)  /* A load insn.  */
6422     {
6423       int fd = bfd_arm_vfp11_regno (insn, is_double, 12, 22);
6424       unsigned int puw = ((insn >> 21) & 0x1) | (((insn >> 23) & 3) << 1);
6425
6426       switch (puw)
6427         {
6428         case 0: /* Two-reg transfer.  We should catch these above.  */
6429           abort ();
6430
6431         case 2: /* fldm[sdx].  */
6432         case 3:
6433         case 5:
6434           {
6435             unsigned int i, offset = insn & 0xff;
6436
6437             if (is_double)
6438               offset >>= 1;
6439
6440             for (i = fd; i < fd + offset; i++)
6441               bfd_arm_vfp11_write_mask (destmask, i);
6442           }
6443           break;
6444
6445         case 4: /* fld[sd].  */
6446         case 6:
6447           bfd_arm_vfp11_write_mask (destmask, fd);
6448           break;
6449
6450         default:
6451           return VFP11_BAD;
6452         }
6453
6454       vpipe = VFP11_LS;
6455     }
6456   /* Single-register transfer. Note L==0.  */
6457   else if ((insn & 0x0f100e10) == 0x0e000a10)
6458     {
6459       unsigned int opcode = (insn >> 21) & 7;
6460       unsigned int fn = bfd_arm_vfp11_regno (insn, is_double, 16, 7);
6461
6462       switch (opcode)
6463         {
6464         case 0: /* fmsr/fmdlr.  */
6465         case 1: /* fmdhr.  */
6466           /* Mark fmdhr and fmdlr as writing to the whole of the DP
6467              destination register.  I don't know if this is exactly right,
6468              but it is the conservative choice.  */
6469           bfd_arm_vfp11_write_mask (destmask, fn);
6470           break;
6471
6472         case 7: /* fmxr.  */
6473           break;
6474         }
6475
6476       vpipe = VFP11_LS;
6477     }
6478
6479   return vpipe;
6480 }
6481
6482
6483 static int elf32_arm_compare_mapping (const void * a, const void * b);
6484
6485
6486 /* Look for potentially-troublesome code sequences which might trigger the
6487    VFP11 denormal/antidependency erratum.  See, e.g., the ARM1136 errata sheet
6488    (available from ARM) for details of the erratum.  A short version is
6489    described in ld.texinfo.  */
6490
6491 bfd_boolean
6492 bfd_elf32_arm_vfp11_erratum_scan (bfd *abfd, struct bfd_link_info *link_info)
6493 {
6494   asection *sec;
6495   bfd_byte *contents = NULL;
6496   int state = 0;
6497   int regs[3], numregs = 0;
6498   struct elf32_arm_link_hash_table *globals = elf32_arm_hash_table (link_info);
6499   int use_vector = (globals->vfp11_fix == BFD_ARM_VFP11_FIX_VECTOR);
6500
6501   if (globals == NULL)
6502     return FALSE;
6503
6504   /* We use a simple FSM to match troublesome VFP11 instruction sequences.
6505      The states transition as follows:
6506
6507        0 -> 1 (vector) or 0 -> 2 (scalar)
6508            A VFP FMAC-pipeline instruction has been seen. Fill
6509            regs[0]..regs[numregs-1] with its input operands. Remember this
6510            instruction in 'first_fmac'.
6511
6512        1 -> 2
6513            Any instruction, except for a VFP instruction which overwrites
6514            regs[*].
6515
6516        1 -> 3 [ -> 0 ]  or
6517        2 -> 3 [ -> 0 ]
6518            A VFP instruction has been seen which overwrites any of regs[*].
6519            We must make a veneer!  Reset state to 0 before examining next
6520            instruction.
6521
6522        2 -> 0
6523            If we fail to match anything in state 2, reset to state 0 and reset
6524            the instruction pointer to the instruction after 'first_fmac'.
6525
6526      If the VFP11 vector mode is in use, there must be at least two unrelated
6527      instructions between anti-dependent VFP11 instructions to properly avoid
6528      triggering the erratum, hence the use of the extra state 1.  */
6529
6530   /* If we are only performing a partial link do not bother
6531      to construct any glue.  */
6532   if (link_info->relocatable)
6533     return TRUE;
6534
6535   /* Skip if this bfd does not correspond to an ELF image.  */
6536   if (! is_arm_elf (abfd))
6537     return TRUE;
6538
6539   /* We should have chosen a fix type by the time we get here.  */
6540   BFD_ASSERT (globals->vfp11_fix != BFD_ARM_VFP11_FIX_DEFAULT);
6541
6542   if (globals->vfp11_fix == BFD_ARM_VFP11_FIX_NONE)
6543     return TRUE;
6544
6545   /* Skip this BFD if it corresponds to an executable or dynamic object.  */
6546   if ((abfd->flags & (EXEC_P | DYNAMIC)) != 0)
6547     return TRUE;
6548
6549   for (sec = abfd->sections; sec != NULL; sec = sec->next)
6550     {
6551       unsigned int i, span, first_fmac = 0, veneer_of_insn = 0;
6552       struct _arm_elf_section_data *sec_data;
6553
6554       /* If we don't have executable progbits, we're not interested in this
6555          section.  Also skip if section is to be excluded.  */
6556       if (elf_section_type (sec) != SHT_PROGBITS
6557           || (elf_section_flags (sec) & SHF_EXECINSTR) == 0
6558           || (sec->flags & SEC_EXCLUDE) != 0
6559           || sec->sec_info_type == ELF_INFO_TYPE_JUST_SYMS
6560           || sec->output_section == bfd_abs_section_ptr
6561           || strcmp (sec->name, VFP11_ERRATUM_VENEER_SECTION_NAME) == 0)
6562         continue;
6563
6564       sec_data = elf32_arm_section_data (sec);
6565
6566       if (sec_data->mapcount == 0)
6567         continue;
6568
6569       if (elf_section_data (sec)->this_hdr.contents != NULL)
6570         contents = elf_section_data (sec)->this_hdr.contents;
6571       else if (! bfd_malloc_and_get_section (abfd, sec, &contents))
6572         goto error_return;
6573
6574       qsort (sec_data->map, sec_data->mapcount, sizeof (elf32_arm_section_map),
6575              elf32_arm_compare_mapping);
6576
6577       for (span = 0; span < sec_data->mapcount; span++)
6578         {
6579           unsigned int span_start = sec_data->map[span].vma;
6580           unsigned int span_end = (span == sec_data->mapcount - 1)
6581                                   ? sec->size : sec_data->map[span + 1].vma;
6582           char span_type = sec_data->map[span].type;
6583
6584           /* FIXME: Only ARM mode is supported at present.  We may need to
6585              support Thumb-2 mode also at some point.  */
6586           if (span_type != 'a')
6587             continue;
6588
6589           for (i = span_start; i < span_end;)
6590             {
6591               unsigned int next_i = i + 4;
6592               unsigned int insn = bfd_big_endian (abfd)
6593                 ? (contents[i] << 24)
6594                   | (contents[i + 1] << 16)
6595                   | (contents[i + 2] << 8)
6596                   | contents[i + 3]
6597                 : (contents[i + 3] << 24)
6598                   | (contents[i + 2] << 16)
6599                   | (contents[i + 1] << 8)
6600                   | contents[i];
6601               unsigned int writemask = 0;
6602               enum bfd_arm_vfp11_pipe vpipe;
6603
6604               switch (state)
6605                 {
6606                 case 0:
6607                   vpipe = bfd_arm_vfp11_insn_decode (insn, &writemask, regs,
6608                                                     &numregs);
6609                   /* I'm assuming the VFP11 erratum can trigger with denorm
6610                      operands on either the FMAC or the DS pipeline. This might
6611                      lead to slightly overenthusiastic veneer insertion.  */
6612                   if (vpipe == VFP11_FMAC || vpipe == VFP11_DS)
6613                     {
6614                       state = use_vector ? 1 : 2;
6615                       first_fmac = i;
6616                       veneer_of_insn = insn;
6617                     }
6618                   break;
6619
6620                 case 1:
6621                   {
6622                     int other_regs[3], other_numregs;
6623                     vpipe = bfd_arm_vfp11_insn_decode (insn, &writemask,
6624                                                       other_regs,
6625                                                       &other_numregs);
6626                     if (vpipe != VFP11_BAD
6627                         && bfd_arm_vfp11_antidependency (writemask, regs,
6628                                                          numregs))
6629                       state = 3;
6630                     else
6631                       state = 2;
6632                   }
6633                   break;
6634
6635                 case 2:
6636                   {
6637                     int other_regs[3], other_numregs;
6638                     vpipe = bfd_arm_vfp11_insn_decode (insn, &writemask,
6639                                                       other_regs,
6640                                                       &other_numregs);
6641                     if (vpipe != VFP11_BAD
6642                         && bfd_arm_vfp11_antidependency (writemask, regs,
6643                                                          numregs))
6644                       state = 3;
6645                     else
6646                       {
6647                         state = 0;
6648                         next_i = first_fmac + 4;
6649                       }
6650                   }
6651                   break;
6652
6653                 case 3:
6654                   abort ();  /* Should be unreachable.  */
6655                 }
6656
6657               if (state == 3)
6658                 {
6659                   elf32_vfp11_erratum_list *newerr =(elf32_vfp11_erratum_list *)
6660                       bfd_zmalloc (sizeof (elf32_vfp11_erratum_list));
6661
6662                   elf32_arm_section_data (sec)->erratumcount += 1;
6663
6664                   newerr->u.b.vfp_insn = veneer_of_insn;
6665
6666                   switch (span_type)
6667                     {
6668                     case 'a':
6669                       newerr->type = VFP11_ERRATUM_BRANCH_TO_ARM_VENEER;
6670                       break;
6671
6672                     default:
6673                       abort ();
6674                     }
6675
6676                   record_vfp11_erratum_veneer (link_info, newerr, abfd, sec,
6677                                                first_fmac);
6678
6679                   newerr->vma = -1;
6680
6681                   newerr->next = sec_data->erratumlist;
6682                   sec_data->erratumlist = newerr;
6683
6684                   state = 0;
6685                 }
6686
6687               i = next_i;
6688             }
6689         }
6690
6691       if (contents != NULL
6692           && elf_section_data (sec)->this_hdr.contents != contents)
6693         free (contents);
6694       contents = NULL;
6695     }
6696
6697   return TRUE;
6698
6699 error_return:
6700   if (contents != NULL
6701       && elf_section_data (sec)->this_hdr.contents != contents)
6702     free (contents);
6703
6704   return FALSE;
6705 }
6706
6707 /* Find virtual-memory addresses for VFP11 erratum veneers and return locations
6708    after sections have been laid out, using specially-named symbols.  */
6709
6710 void
6711 bfd_elf32_arm_vfp11_fix_veneer_locations (bfd *abfd,
6712                                           struct bfd_link_info *link_info)
6713 {
6714   asection *sec;
6715   struct elf32_arm_link_hash_table *globals;
6716   char *tmp_name;
6717
6718   if (link_info->relocatable)
6719     return;
6720
6721   /* Skip if this bfd does not correspond to an ELF image.  */
6722   if (! is_arm_elf (abfd))
6723     return;
6724
6725   globals = elf32_arm_hash_table (link_info);
6726   if (globals == NULL)
6727     return;
6728
6729   tmp_name = (char *) bfd_malloc ((bfd_size_type) strlen
6730                                   (VFP11_ERRATUM_VENEER_ENTRY_NAME) + 10);
6731
6732   for (sec = abfd->sections; sec != NULL; sec = sec->next)
6733     {
6734       struct _arm_elf_section_data *sec_data = elf32_arm_section_data (sec);
6735       elf32_vfp11_erratum_list *errnode = sec_data->erratumlist;
6736
6737       for (; errnode != NULL; errnode = errnode->next)
6738         {
6739           struct elf_link_hash_entry *myh;
6740           bfd_vma vma;
6741
6742           switch (errnode->type)
6743             {
6744             case VFP11_ERRATUM_BRANCH_TO_ARM_VENEER:
6745             case VFP11_ERRATUM_BRANCH_TO_THUMB_VENEER:
6746               /* Find veneer symbol.  */
6747               sprintf (tmp_name, VFP11_ERRATUM_VENEER_ENTRY_NAME,
6748                        errnode->u.b.veneer->u.v.id);
6749
6750               myh = elf_link_hash_lookup
6751                 (&(globals)->root, tmp_name, FALSE, FALSE, TRUE);
6752
6753               if (myh == NULL)
6754                 (*_bfd_error_handler) (_("%B: unable to find VFP11 veneer "
6755                                          "`%s'"), abfd, tmp_name);
6756
6757               vma = myh->root.u.def.section->output_section->vma
6758                     + myh->root.u.def.section->output_offset
6759                     + myh->root.u.def.value;
6760
6761               errnode->u.b.veneer->vma = vma;
6762               break;
6763
6764             case VFP11_ERRATUM_ARM_VENEER:
6765             case VFP11_ERRATUM_THUMB_VENEER:
6766               /* Find return location.  */
6767               sprintf (tmp_name, VFP11_ERRATUM_VENEER_ENTRY_NAME "_r",
6768                        errnode->u.v.id);
6769
6770               myh = elf_link_hash_lookup
6771                 (&(globals)->root, tmp_name, FALSE, FALSE, TRUE);
6772
6773               if (myh == NULL)
6774                 (*_bfd_error_handler) (_("%B: unable to find VFP11 veneer "
6775                                          "`%s'"), abfd, tmp_name);
6776
6777               vma = myh->root.u.def.section->output_section->vma
6778                     + myh->root.u.def.section->output_offset
6779                     + myh->root.u.def.value;
6780
6781               errnode->u.v.branch->vma = vma;
6782               break;
6783
6784             default:
6785               abort ();
6786             }
6787         }
6788     }
6789
6790   free (tmp_name);
6791 }
6792
6793
6794 /* Set target relocation values needed during linking.  */
6795
6796 void
6797 bfd_elf32_arm_set_target_relocs (struct bfd *output_bfd,
6798                                  struct bfd_link_info *link_info,
6799                                  int target1_is_rel,
6800                                  char * target2_type,
6801                                  int fix_v4bx,
6802                                  int use_blx,
6803                                  bfd_arm_vfp11_fix vfp11_fix,
6804                                  int no_enum_warn, int no_wchar_warn,
6805                                  int pic_veneer, int fix_cortex_a8,
6806                                  int fix_arm1176)
6807 {
6808   struct elf32_arm_link_hash_table *globals;
6809
6810   globals = elf32_arm_hash_table (link_info);
6811   if (globals == NULL)
6812     return;
6813
6814   globals->target1_is_rel = target1_is_rel;
6815   if (strcmp (target2_type, "rel") == 0)
6816     globals->target2_reloc = R_ARM_REL32;
6817   else if (strcmp (target2_type, "abs") == 0)
6818     globals->target2_reloc = R_ARM_ABS32;
6819   else if (strcmp (target2_type, "got-rel") == 0)
6820     globals->target2_reloc = R_ARM_GOT_PREL;
6821   else
6822     {
6823       _bfd_error_handler (_("Invalid TARGET2 relocation type '%s'."),
6824                           target2_type);
6825     }
6826   globals->fix_v4bx = fix_v4bx;
6827   globals->use_blx |= use_blx;
6828   globals->vfp11_fix = vfp11_fix;
6829   globals->pic_veneer = pic_veneer;
6830   globals->fix_cortex_a8 = fix_cortex_a8;
6831   globals->fix_arm1176 = fix_arm1176;
6832
6833   BFD_ASSERT (is_arm_elf (output_bfd));
6834   elf_arm_tdata (output_bfd)->no_enum_size_warning = no_enum_warn;
6835   elf_arm_tdata (output_bfd)->no_wchar_size_warning = no_wchar_warn;
6836 }
6837
6838 /* Replace the target offset of a Thumb bl or b.w instruction.  */
6839
6840 static void
6841 insert_thumb_branch (bfd *abfd, long int offset, bfd_byte *insn)
6842 {
6843   bfd_vma upper;
6844   bfd_vma lower;
6845   int reloc_sign;
6846
6847   BFD_ASSERT ((offset & 1) == 0);
6848
6849   upper = bfd_get_16 (abfd, insn);
6850   lower = bfd_get_16 (abfd, insn + 2);
6851   reloc_sign = (offset < 0) ? 1 : 0;
6852   upper = (upper & ~(bfd_vma) 0x7ff)
6853           | ((offset >> 12) & 0x3ff)
6854           | (reloc_sign << 10);
6855   lower = (lower & ~(bfd_vma) 0x2fff)
6856           | (((!((offset >> 23) & 1)) ^ reloc_sign) << 13)
6857           | (((!((offset >> 22) & 1)) ^ reloc_sign) << 11)
6858           | ((offset >> 1) & 0x7ff);
6859   bfd_put_16 (abfd, upper, insn);
6860   bfd_put_16 (abfd, lower, insn + 2);
6861 }
6862
6863 /* Thumb code calling an ARM function.  */
6864
6865 static int
6866 elf32_thumb_to_arm_stub (struct bfd_link_info * info,
6867                          const char *           name,
6868                          bfd *                  input_bfd,
6869                          bfd *                  output_bfd,
6870                          asection *             input_section,
6871                          bfd_byte *             hit_data,
6872                          asection *             sym_sec,
6873                          bfd_vma                offset,
6874                          bfd_signed_vma         addend,
6875                          bfd_vma                val,
6876                          char **error_message)
6877 {
6878   asection * s = 0;
6879   bfd_vma my_offset;
6880   long int ret_offset;
6881   struct elf_link_hash_entry * myh;
6882   struct elf32_arm_link_hash_table * globals;
6883
6884   myh = find_thumb_glue (info, name, error_message);
6885   if (myh == NULL)
6886     return FALSE;
6887
6888   globals = elf32_arm_hash_table (info);
6889   BFD_ASSERT (globals != NULL);
6890   BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
6891
6892   my_offset = myh->root.u.def.value;
6893
6894   s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
6895                                THUMB2ARM_GLUE_SECTION_NAME);
6896
6897   BFD_ASSERT (s != NULL);
6898   BFD_ASSERT (s->contents != NULL);
6899   BFD_ASSERT (s->output_section != NULL);
6900
6901   if ((my_offset & 0x01) == 0x01)
6902     {
6903       if (sym_sec != NULL
6904           && sym_sec->owner != NULL
6905           && !INTERWORK_FLAG (sym_sec->owner))
6906         {
6907           (*_bfd_error_handler)
6908             (_("%B(%s): warning: interworking not enabled.\n"
6909                "  first occurrence: %B: thumb call to arm"),
6910              sym_sec->owner, input_bfd, name);
6911
6912           return FALSE;
6913         }
6914
6915       --my_offset;
6916       myh->root.u.def.value = my_offset;
6917
6918       put_thumb_insn (globals, output_bfd, (bfd_vma) t2a1_bx_pc_insn,
6919                       s->contents + my_offset);
6920
6921       put_thumb_insn (globals, output_bfd, (bfd_vma) t2a2_noop_insn,
6922                       s->contents + my_offset + 2);
6923
6924       ret_offset =
6925         /* Address of destination of the stub.  */
6926         ((bfd_signed_vma) val)
6927         - ((bfd_signed_vma)
6928            /* Offset from the start of the current section
6929               to the start of the stubs.  */
6930            (s->output_offset
6931             /* Offset of the start of this stub from the start of the stubs.  */
6932             + my_offset
6933             /* Address of the start of the current section.  */
6934             + s->output_section->vma)
6935            /* The branch instruction is 4 bytes into the stub.  */
6936            + 4
6937            /* ARM branches work from the pc of the instruction + 8.  */
6938            + 8);
6939
6940       put_arm_insn (globals, output_bfd,
6941                     (bfd_vma) t2a3_b_insn | ((ret_offset >> 2) & 0x00FFFFFF),
6942                     s->contents + my_offset + 4);
6943     }
6944
6945   BFD_ASSERT (my_offset <= globals->thumb_glue_size);
6946
6947   /* Now go back and fix up the original BL insn to point to here.  */
6948   ret_offset =
6949     /* Address of where the stub is located.  */
6950     (s->output_section->vma + s->output_offset + my_offset)
6951      /* Address of where the BL is located.  */
6952     - (input_section->output_section->vma + input_section->output_offset
6953        + offset)
6954     /* Addend in the relocation.  */
6955     - addend
6956     /* Biassing for PC-relative addressing.  */
6957     - 8;
6958
6959   insert_thumb_branch (input_bfd, ret_offset, hit_data - input_section->vma);
6960
6961   return TRUE;
6962 }
6963
6964 /* Populate an Arm to Thumb stub.  Returns the stub symbol.  */
6965
6966 static struct elf_link_hash_entry *
6967 elf32_arm_create_thumb_stub (struct bfd_link_info * info,
6968                              const char *           name,
6969                              bfd *                  input_bfd,
6970                              bfd *                  output_bfd,
6971                              asection *             sym_sec,
6972                              bfd_vma                val,
6973                              asection *             s,
6974                              char **                error_message)
6975 {
6976   bfd_vma my_offset;
6977   long int ret_offset;
6978   struct elf_link_hash_entry * myh;
6979   struct elf32_arm_link_hash_table * globals;
6980
6981   myh = find_arm_glue (info, name, error_message);
6982   if (myh == NULL)
6983     return NULL;
6984
6985   globals = elf32_arm_hash_table (info);
6986   BFD_ASSERT (globals != NULL);
6987   BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
6988
6989   my_offset = myh->root.u.def.value;
6990
6991   if ((my_offset & 0x01) == 0x01)
6992     {
6993       if (sym_sec != NULL
6994           && sym_sec->owner != NULL
6995           && !INTERWORK_FLAG (sym_sec->owner))
6996         {
6997           (*_bfd_error_handler)
6998             (_("%B(%s): warning: interworking not enabled.\n"
6999                "  first occurrence: %B: arm call to thumb"),
7000              sym_sec->owner, input_bfd, name);
7001         }
7002
7003       --my_offset;
7004       myh->root.u.def.value = my_offset;
7005
7006       if (info->shared || globals->root.is_relocatable_executable
7007           || globals->pic_veneer)
7008         {
7009           /* For relocatable objects we can't use absolute addresses,
7010              so construct the address from a relative offset.  */
7011           /* TODO: If the offset is small it's probably worth
7012              constructing the address with adds.  */
7013           put_arm_insn (globals, output_bfd, (bfd_vma) a2t1p_ldr_insn,
7014                         s->contents + my_offset);
7015           put_arm_insn (globals, output_bfd, (bfd_vma) a2t2p_add_pc_insn,
7016                         s->contents + my_offset + 4);
7017           put_arm_insn (globals, output_bfd, (bfd_vma) a2t3p_bx_r12_insn,
7018                         s->contents + my_offset + 8);
7019           /* Adjust the offset by 4 for the position of the add,
7020              and 8 for the pipeline offset.  */
7021           ret_offset = (val - (s->output_offset
7022                                + s->output_section->vma
7023                                + my_offset + 12))
7024                        | 1;
7025           bfd_put_32 (output_bfd, ret_offset,
7026                       s->contents + my_offset + 12);
7027         }
7028       else if (globals->use_blx)
7029         {
7030           put_arm_insn (globals, output_bfd, (bfd_vma) a2t1v5_ldr_insn,
7031                         s->contents + my_offset);
7032
7033           /* It's a thumb address.  Add the low order bit.  */
7034           bfd_put_32 (output_bfd, val | a2t2v5_func_addr_insn,
7035                       s->contents + my_offset + 4);
7036         }
7037       else
7038         {
7039           put_arm_insn (globals, output_bfd, (bfd_vma) a2t1_ldr_insn,
7040                         s->contents + my_offset);
7041
7042           put_arm_insn (globals, output_bfd, (bfd_vma) a2t2_bx_r12_insn,
7043                         s->contents + my_offset + 4);
7044
7045           /* It's a thumb address.  Add the low order bit.  */
7046           bfd_put_32 (output_bfd, val | a2t3_func_addr_insn,
7047                       s->contents + my_offset + 8);
7048
7049           my_offset += 12;
7050         }
7051     }
7052
7053   BFD_ASSERT (my_offset <= globals->arm_glue_size);
7054
7055   return myh;
7056 }
7057
7058 /* Arm code calling a Thumb function.  */
7059
7060 static int
7061 elf32_arm_to_thumb_stub (struct bfd_link_info * info,
7062                          const char *           name,
7063                          bfd *                  input_bfd,
7064                          bfd *                  output_bfd,
7065                          asection *             input_section,
7066                          bfd_byte *             hit_data,
7067                          asection *             sym_sec,
7068                          bfd_vma                offset,
7069                          bfd_signed_vma         addend,
7070                          bfd_vma                val,
7071                          char **error_message)
7072 {
7073   unsigned long int tmp;
7074   bfd_vma my_offset;
7075   asection * s;
7076   long int ret_offset;
7077   struct elf_link_hash_entry * myh;
7078   struct elf32_arm_link_hash_table * globals;
7079
7080   globals = elf32_arm_hash_table (info);
7081   BFD_ASSERT (globals != NULL);
7082   BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
7083
7084   s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
7085                                ARM2THUMB_GLUE_SECTION_NAME);
7086   BFD_ASSERT (s != NULL);
7087   BFD_ASSERT (s->contents != NULL);
7088   BFD_ASSERT (s->output_section != NULL);
7089
7090   myh = elf32_arm_create_thumb_stub (info, name, input_bfd, output_bfd,
7091                                      sym_sec, val, s, error_message);
7092   if (!myh)
7093     return FALSE;
7094
7095   my_offset = myh->root.u.def.value;
7096   tmp = bfd_get_32 (input_bfd, hit_data);
7097   tmp = tmp & 0xFF000000;
7098
7099   /* Somehow these are both 4 too far, so subtract 8.  */
7100   ret_offset = (s->output_offset
7101                 + my_offset
7102                 + s->output_section->vma
7103                 - (input_section->output_offset
7104                    + input_section->output_section->vma
7105                    + offset + addend)
7106                 - 8);
7107
7108   tmp = tmp | ((ret_offset >> 2) & 0x00FFFFFF);
7109
7110   bfd_put_32 (output_bfd, (bfd_vma) tmp, hit_data - input_section->vma);
7111
7112   return TRUE;
7113 }
7114
7115 /* Populate Arm stub for an exported Thumb function.  */
7116
7117 static bfd_boolean
7118 elf32_arm_to_thumb_export_stub (struct elf_link_hash_entry *h, void * inf)
7119 {
7120   struct bfd_link_info * info = (struct bfd_link_info *) inf;
7121   asection * s;
7122   struct elf_link_hash_entry * myh;
7123   struct elf32_arm_link_hash_entry *eh;
7124   struct elf32_arm_link_hash_table * globals;
7125   asection *sec;
7126   bfd_vma val;
7127   char *error_message;
7128
7129   eh = elf32_arm_hash_entry (h);
7130   /* Allocate stubs for exported Thumb functions on v4t.  */
7131   if (eh->export_glue == NULL)
7132     return TRUE;
7133
7134   globals = elf32_arm_hash_table (info);
7135   BFD_ASSERT (globals != NULL);
7136   BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
7137
7138   s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
7139                                ARM2THUMB_GLUE_SECTION_NAME);
7140   BFD_ASSERT (s != NULL);
7141   BFD_ASSERT (s->contents != NULL);
7142   BFD_ASSERT (s->output_section != NULL);
7143
7144   sec = eh->export_glue->root.u.def.section;
7145
7146   BFD_ASSERT (sec->output_section != NULL);
7147
7148   val = eh->export_glue->root.u.def.value + sec->output_offset
7149         + sec->output_section->vma;
7150
7151   myh = elf32_arm_create_thumb_stub (info, h->root.root.string,
7152                                      h->root.u.def.section->owner,
7153                                      globals->obfd, sec, val, s,
7154                                      &error_message);
7155   BFD_ASSERT (myh);
7156   return TRUE;
7157 }
7158
7159 /* Populate ARMv4 BX veneers.  Returns the absolute adress of the veneer.  */
7160
7161 static bfd_vma
7162 elf32_arm_bx_glue (struct bfd_link_info * info, int reg)
7163 {
7164   bfd_byte *p;
7165   bfd_vma glue_addr;
7166   asection *s;
7167   struct elf32_arm_link_hash_table *globals;
7168
7169   globals = elf32_arm_hash_table (info);
7170   BFD_ASSERT (globals != NULL);
7171   BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
7172
7173   s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
7174                                ARM_BX_GLUE_SECTION_NAME);
7175   BFD_ASSERT (s != NULL);
7176   BFD_ASSERT (s->contents != NULL);
7177   BFD_ASSERT (s->output_section != NULL);
7178
7179   BFD_ASSERT (globals->bx_glue_offset[reg] & 2);
7180
7181   glue_addr = globals->bx_glue_offset[reg] & ~(bfd_vma)3;
7182
7183   if ((globals->bx_glue_offset[reg] & 1) == 0)
7184     {
7185       p = s->contents + glue_addr;
7186       bfd_put_32 (globals->obfd, armbx1_tst_insn + (reg << 16), p);
7187       bfd_put_32 (globals->obfd, armbx2_moveq_insn + reg, p + 4);
7188       bfd_put_32 (globals->obfd, armbx3_bx_insn + reg, p + 8);
7189       globals->bx_glue_offset[reg] |= 1;
7190     }
7191
7192   return glue_addr + s->output_section->vma + s->output_offset;
7193 }
7194
7195 /* Generate Arm stubs for exported Thumb symbols.  */
7196 static void
7197 elf32_arm_begin_write_processing (bfd *abfd ATTRIBUTE_UNUSED,
7198                                   struct bfd_link_info *link_info)
7199 {
7200   struct elf32_arm_link_hash_table * globals;
7201
7202   if (link_info == NULL)
7203     /* Ignore this if we are not called by the ELF backend linker.  */
7204     return;
7205
7206   globals = elf32_arm_hash_table (link_info);
7207   if (globals == NULL)
7208     return;
7209
7210   /* If blx is available then exported Thumb symbols are OK and there is
7211      nothing to do.  */
7212   if (globals->use_blx)
7213     return;
7214
7215   elf_link_hash_traverse (&globals->root, elf32_arm_to_thumb_export_stub,
7216                           link_info);
7217 }
7218
7219 /* Reserve space for COUNT dynamic relocations in relocation selection
7220    SRELOC.  */
7221
7222 static void
7223 elf32_arm_allocate_dynrelocs (struct bfd_link_info *info, asection *sreloc,
7224                               bfd_size_type count)
7225 {
7226   struct elf32_arm_link_hash_table *htab;
7227
7228   htab = elf32_arm_hash_table (info);
7229   BFD_ASSERT (htab->root.dynamic_sections_created);
7230   if (sreloc == NULL)
7231     abort ();
7232   sreloc->size += RELOC_SIZE (htab) * count;
7233 }
7234
7235 /* Reserve space for COUNT R_ARM_IRELATIVE relocations.  If the link is
7236    dynamic, the relocations should go in SRELOC, otherwise they should
7237    go in the special .rel.iplt section.  */
7238
7239 static void
7240 elf32_arm_allocate_irelocs (struct bfd_link_info *info, asection *sreloc,
7241                             bfd_size_type count)
7242 {
7243   struct elf32_arm_link_hash_table *htab;
7244
7245   htab = elf32_arm_hash_table (info);
7246   if (!htab->root.dynamic_sections_created)
7247     htab->root.irelplt->size += RELOC_SIZE (htab) * count;
7248   else
7249     {
7250       BFD_ASSERT (sreloc != NULL);
7251       sreloc->size += RELOC_SIZE (htab) * count;
7252     }
7253 }
7254
7255 /* Add relocation REL to the end of relocation section SRELOC.  */
7256
7257 static void
7258 elf32_arm_add_dynreloc (bfd *output_bfd, struct bfd_link_info *info,
7259                         asection *sreloc, Elf_Internal_Rela *rel)
7260 {
7261   bfd_byte *loc;
7262   struct elf32_arm_link_hash_table *htab;
7263
7264   htab = elf32_arm_hash_table (info);
7265   if (!htab->root.dynamic_sections_created
7266       && ELF32_R_TYPE (rel->r_info) == R_ARM_IRELATIVE)
7267     sreloc = htab->root.irelplt;
7268   if (sreloc == NULL)
7269     abort ();
7270   loc = sreloc->contents;
7271   loc += sreloc->reloc_count++ * RELOC_SIZE (htab);
7272   if (sreloc->reloc_count * RELOC_SIZE (htab) > sreloc->size)
7273     abort ();
7274   SWAP_RELOC_OUT (htab) (output_bfd, rel, loc);
7275 }
7276
7277 /* Allocate room for a PLT entry described by ROOT_PLT and ARM_PLT.
7278    IS_IPLT_ENTRY says whether the entry belongs to .iplt rather than
7279    to .plt.  */
7280
7281 static void
7282 elf32_arm_allocate_plt_entry (struct bfd_link_info *info,
7283                               bfd_boolean is_iplt_entry,
7284                               union gotplt_union *root_plt,
7285                               struct arm_plt_info *arm_plt)
7286 {
7287   struct elf32_arm_link_hash_table *htab;
7288   asection *splt;
7289   asection *sgotplt;
7290
7291   htab = elf32_arm_hash_table (info);
7292
7293   if (is_iplt_entry)
7294     {
7295       splt = htab->root.iplt;
7296       sgotplt = htab->root.igotplt;
7297
7298       /* Allocate room for an R_ARM_IRELATIVE relocation in .rel.iplt.  */
7299       elf32_arm_allocate_irelocs (info, htab->root.irelplt, 1);
7300     }
7301   else
7302     {
7303       splt = htab->root.splt;
7304       sgotplt = htab->root.sgotplt;
7305
7306       /* Allocate room for an R_JUMP_SLOT relocation in .rel.plt.  */
7307       elf32_arm_allocate_dynrelocs (info, htab->root.srelplt, 1);
7308
7309       /* If this is the first .plt entry, make room for the special
7310          first entry.  */
7311       if (splt->size == 0)
7312         splt->size += htab->plt_header_size;
7313     }
7314
7315   /* Allocate the PLT entry itself, including any leading Thumb stub.  */
7316   if (elf32_arm_plt_needs_thumb_stub_p (info, arm_plt))
7317     splt->size += PLT_THUMB_STUB_SIZE;
7318   root_plt->offset = splt->size;
7319   splt->size += htab->plt_entry_size;
7320
7321   if (!htab->symbian_p)
7322     {
7323       /* We also need to make an entry in the .got.plt section, which
7324          will be placed in the .got section by the linker script.  */
7325       arm_plt->got_offset = sgotplt->size - 8 * htab->num_tls_desc;
7326       sgotplt->size += 4;
7327     }
7328 }
7329
7330 /* Fill in a PLT entry and its associated GOT slot.  If DYNINDX == -1,
7331    the entry lives in .iplt and resolves to (*SYM_VALUE)().
7332    Otherwise, DYNINDX is the index of the symbol in the dynamic
7333    symbol table and SYM_VALUE is undefined.
7334
7335    ROOT_PLT points to the offset of the PLT entry from the start of its
7336    section (.iplt or .plt).  ARM_PLT points to the symbol's ARM-specific
7337    bookkeeping information.  */
7338
7339 static void
7340 elf32_arm_populate_plt_entry (bfd *output_bfd, struct bfd_link_info *info,
7341                               union gotplt_union *root_plt,
7342                               struct arm_plt_info *arm_plt,
7343                               int dynindx, bfd_vma sym_value)
7344 {
7345   struct elf32_arm_link_hash_table *htab;
7346   asection *sgot;
7347   asection *splt;
7348   asection *srel;
7349   bfd_byte *loc;
7350   bfd_vma plt_index;
7351   Elf_Internal_Rela rel;
7352   bfd_vma plt_header_size;
7353   bfd_vma got_header_size;
7354
7355   htab = elf32_arm_hash_table (info);
7356
7357   /* Pick the appropriate sections and sizes.  */
7358   if (dynindx == -1)
7359     {
7360       splt = htab->root.iplt;
7361       sgot = htab->root.igotplt;
7362       srel = htab->root.irelplt;
7363
7364       /* There are no reserved entries in .igot.plt, and no special
7365          first entry in .iplt.  */
7366       got_header_size = 0;
7367       plt_header_size = 0;
7368     }
7369   else
7370     {
7371       splt = htab->root.splt;
7372       sgot = htab->root.sgotplt;
7373       srel = htab->root.srelplt;
7374
7375       got_header_size = get_elf_backend_data (output_bfd)->got_header_size;
7376       plt_header_size = htab->plt_header_size;
7377     }
7378   BFD_ASSERT (splt != NULL && srel != NULL);
7379
7380   /* Fill in the entry in the procedure linkage table.  */
7381   if (htab->symbian_p)
7382     {
7383       BFD_ASSERT (dynindx >= 0);
7384       put_arm_insn (htab, output_bfd,
7385                     elf32_arm_symbian_plt_entry[0],
7386                     splt->contents + root_plt->offset);
7387       bfd_put_32 (output_bfd,
7388                   elf32_arm_symbian_plt_entry[1],
7389                   splt->contents + root_plt->offset + 4);
7390
7391       /* Fill in the entry in the .rel.plt section.  */
7392       rel.r_offset = (splt->output_section->vma
7393                       + splt->output_offset
7394                       + root_plt->offset + 4);
7395       rel.r_info = ELF32_R_INFO (dynindx, R_ARM_GLOB_DAT);
7396
7397       /* Get the index in the procedure linkage table which
7398          corresponds to this symbol.  This is the index of this symbol
7399          in all the symbols for which we are making plt entries.  The
7400          first entry in the procedure linkage table is reserved.  */
7401       plt_index = ((root_plt->offset - plt_header_size)
7402                    / htab->plt_entry_size);
7403     }
7404   else
7405     {
7406       bfd_vma got_offset, got_address, plt_address;
7407       bfd_vma got_displacement, initial_got_entry;
7408       bfd_byte * ptr;
7409
7410       BFD_ASSERT (sgot != NULL);
7411
7412       /* Get the offset into the .(i)got.plt table of the entry that
7413          corresponds to this function.  */
7414       got_offset = (arm_plt->got_offset & -2);
7415
7416       /* Get the index in the procedure linkage table which
7417          corresponds to this symbol.  This is the index of this symbol
7418          in all the symbols for which we are making plt entries.
7419          After the reserved .got.plt entries, all symbols appear in
7420          the same order as in .plt.  */
7421       plt_index = (got_offset - got_header_size) / 4;
7422
7423       /* Calculate the address of the GOT entry.  */
7424       got_address = (sgot->output_section->vma
7425                      + sgot->output_offset
7426                      + got_offset);
7427
7428       /* ...and the address of the PLT entry.  */
7429       plt_address = (splt->output_section->vma
7430                      + splt->output_offset
7431                      + root_plt->offset);
7432
7433       ptr = splt->contents + root_plt->offset;
7434       if (htab->vxworks_p && info->shared)
7435         {
7436           unsigned int i;
7437           bfd_vma val;
7438
7439           for (i = 0; i != htab->plt_entry_size / 4; i++, ptr += 4)
7440             {
7441               val = elf32_arm_vxworks_shared_plt_entry[i];
7442               if (i == 2)
7443                 val |= got_address - sgot->output_section->vma;
7444               if (i == 5)
7445                 val |= plt_index * RELOC_SIZE (htab);
7446               if (i == 2 || i == 5)
7447                 bfd_put_32 (output_bfd, val, ptr);
7448               else
7449                 put_arm_insn (htab, output_bfd, val, ptr);
7450             }
7451         }
7452       else if (htab->vxworks_p)
7453         {
7454           unsigned int i;
7455           bfd_vma val;
7456
7457           for (i = 0; i != htab->plt_entry_size / 4; i++, ptr += 4)
7458             {
7459               val = elf32_arm_vxworks_exec_plt_entry[i];
7460               if (i == 2)
7461                 val |= got_address;
7462               if (i == 4)
7463                 val |= 0xffffff & -((root_plt->offset + i * 4 + 8) >> 2);
7464               if (i == 5)
7465                 val |= plt_index * RELOC_SIZE (htab);
7466               if (i == 2 || i == 5)
7467                 bfd_put_32 (output_bfd, val, ptr);
7468               else
7469                 put_arm_insn (htab, output_bfd, val, ptr);
7470             }
7471
7472           loc = (htab->srelplt2->contents
7473                  + (plt_index * 2 + 1) * RELOC_SIZE (htab));
7474
7475           /* Create the .rela.plt.unloaded R_ARM_ABS32 relocation
7476              referencing the GOT for this PLT entry.  */
7477           rel.r_offset = plt_address + 8;
7478           rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_ARM_ABS32);
7479           rel.r_addend = got_offset;
7480           SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc);
7481           loc += RELOC_SIZE (htab);
7482
7483           /* Create the R_ARM_ABS32 relocation referencing the
7484              beginning of the PLT for this GOT entry.  */
7485           rel.r_offset = got_address;
7486           rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_ARM_ABS32);
7487           rel.r_addend = 0;
7488           SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc);
7489         }
7490       else
7491         {
7492           /* Calculate the displacement between the PLT slot and the
7493              entry in the GOT.  The eight-byte offset accounts for the
7494              value produced by adding to pc in the first instruction
7495              of the PLT stub.  */
7496           got_displacement = got_address - (plt_address + 8);
7497
7498           BFD_ASSERT ((got_displacement & 0xf0000000) == 0);
7499
7500           if (elf32_arm_plt_needs_thumb_stub_p (info, arm_plt))
7501             {
7502               put_thumb_insn (htab, output_bfd,
7503                               elf32_arm_plt_thumb_stub[0], ptr - 4);
7504               put_thumb_insn (htab, output_bfd,
7505                               elf32_arm_plt_thumb_stub[1], ptr - 2);
7506             }
7507
7508           put_arm_insn (htab, output_bfd,
7509                         elf32_arm_plt_entry[0]
7510                         | ((got_displacement & 0x0ff00000) >> 20),
7511                         ptr + 0);
7512           put_arm_insn (htab, output_bfd,
7513                         elf32_arm_plt_entry[1]
7514                         | ((got_displacement & 0x000ff000) >> 12),
7515                         ptr+ 4);
7516           put_arm_insn (htab, output_bfd,
7517                         elf32_arm_plt_entry[2]
7518                         | (got_displacement & 0x00000fff),
7519                         ptr + 8);
7520 #ifdef FOUR_WORD_PLT
7521           bfd_put_32 (output_bfd, elf32_arm_plt_entry[3], ptr + 12);
7522 #endif
7523         }
7524
7525       /* Fill in the entry in the .rel(a).(i)plt section.  */
7526       rel.r_offset = got_address;
7527       rel.r_addend = 0;
7528       if (dynindx == -1)
7529         {
7530           /* .igot.plt entries use IRELATIVE relocations against SYM_VALUE.
7531              The dynamic linker or static executable then calls SYM_VALUE
7532              to determine the correct run-time value of the .igot.plt entry.  */
7533           rel.r_info = ELF32_R_INFO (0, R_ARM_IRELATIVE);
7534           initial_got_entry = sym_value;
7535         }
7536       else
7537         {
7538           rel.r_info = ELF32_R_INFO (dynindx, R_ARM_JUMP_SLOT);
7539           initial_got_entry = (splt->output_section->vma
7540                                + splt->output_offset);
7541         }
7542
7543       /* Fill in the entry in the global offset table.  */
7544       bfd_put_32 (output_bfd, initial_got_entry,
7545                   sgot->contents + got_offset);
7546     }
7547
7548   loc = srel->contents + plt_index * RELOC_SIZE (htab);
7549   SWAP_RELOC_OUT (htab) (output_bfd, &rel, loc);
7550 }
7551
7552 /* Some relocations map to different relocations depending on the
7553    target.  Return the real relocation.  */
7554
7555 static int
7556 arm_real_reloc_type (struct elf32_arm_link_hash_table * globals,
7557                      int r_type)
7558 {
7559   switch (r_type)
7560     {
7561     case R_ARM_TARGET1:
7562       if (globals->target1_is_rel)
7563         return R_ARM_REL32;
7564       else
7565         return R_ARM_ABS32;
7566
7567     case R_ARM_TARGET2:
7568       return globals->target2_reloc;
7569
7570     default:
7571       return r_type;
7572     }
7573 }
7574
7575 /* Return the base VMA address which should be subtracted from real addresses
7576    when resolving @dtpoff relocation.
7577    This is PT_TLS segment p_vaddr.  */
7578
7579 static bfd_vma
7580 dtpoff_base (struct bfd_link_info *info)
7581 {
7582   /* If tls_sec is NULL, we should have signalled an error already.  */
7583   if (elf_hash_table (info)->tls_sec == NULL)
7584     return 0;
7585   return elf_hash_table (info)->tls_sec->vma;
7586 }
7587
7588 /* Return the relocation value for @tpoff relocation
7589    if STT_TLS virtual address is ADDRESS.  */
7590
7591 static bfd_vma
7592 tpoff (struct bfd_link_info *info, bfd_vma address)
7593 {
7594   struct elf_link_hash_table *htab = elf_hash_table (info);
7595   bfd_vma base;
7596
7597   /* If tls_sec is NULL, we should have signalled an error already.  */
7598   if (htab->tls_sec == NULL)
7599     return 0;
7600   base = align_power ((bfd_vma) TCB_SIZE, htab->tls_sec->alignment_power);
7601   return address - htab->tls_sec->vma + base;
7602 }
7603
7604 /* Perform an R_ARM_ABS12 relocation on the field pointed to by DATA.
7605    VALUE is the relocation value.  */
7606
7607 static bfd_reloc_status_type
7608 elf32_arm_abs12_reloc (bfd *abfd, void *data, bfd_vma value)
7609 {
7610   if (value > 0xfff)
7611     return bfd_reloc_overflow;
7612
7613   value |= bfd_get_32 (abfd, data) & 0xfffff000;
7614   bfd_put_32 (abfd, value, data);
7615   return bfd_reloc_ok;
7616 }
7617
7618 /* Handle TLS relaxations.  Relaxing is possible for symbols that use
7619    R_ARM_GOTDESC, R_ARM_{,THM_}TLS_CALL or
7620    R_ARM_{,THM_}TLS_DESCSEQ relocations, during a static link.
7621
7622    Return bfd_reloc_ok if we're done, bfd_reloc_continue if the caller
7623    is to then call final_link_relocate.  Return other values in the
7624    case of error.
7625
7626    FIXME:When --emit-relocs is in effect, we'll emit relocs describing
7627    the pre-relaxed code.  It would be nice if the relocs were updated
7628    to match the optimization.   */
7629
7630 static bfd_reloc_status_type
7631 elf32_arm_tls_relax (struct elf32_arm_link_hash_table *globals,
7632                      bfd *input_bfd, asection *input_sec, bfd_byte *contents,
7633                      Elf_Internal_Rela *rel, unsigned long is_local)
7634 {
7635   unsigned long insn;
7636
7637   switch (ELF32_R_TYPE (rel->r_info))
7638     {
7639     default:
7640       return bfd_reloc_notsupported;
7641
7642     case R_ARM_TLS_GOTDESC:
7643       if (is_local)
7644         insn = 0;
7645       else
7646         {
7647           insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
7648           if (insn & 1)
7649             insn -= 5; /* THUMB */
7650           else
7651             insn -= 8; /* ARM */
7652         }
7653       bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
7654       return bfd_reloc_continue;
7655
7656     case R_ARM_THM_TLS_DESCSEQ:
7657       /* Thumb insn.  */
7658       insn = bfd_get_16 (input_bfd, contents + rel->r_offset);
7659       if ((insn & 0xff78) == 0x4478)      /* add rx, pc */
7660         {
7661           if (is_local)
7662             /* nop */
7663             bfd_put_16 (input_bfd, 0x46c0, contents + rel->r_offset);
7664         }
7665       else if ((insn & 0xffc0) == 0x6840)  /* ldr rx,[ry,#4] */
7666         {
7667           if (is_local)
7668             /* nop */
7669             bfd_put_16 (input_bfd, 0x46c0, contents + rel->r_offset);
7670           else
7671             /* ldr rx,[ry] */
7672             bfd_put_16 (input_bfd, insn & 0xf83f, contents + rel->r_offset);
7673         }
7674       else if ((insn & 0xff87) == 0x4780)  /* blx rx */
7675         {
7676           if (is_local)
7677             /* nop */
7678             bfd_put_16 (input_bfd, 0x46c0, contents + rel->r_offset);
7679           else
7680             /* mov r0, rx */
7681             bfd_put_16 (input_bfd, 0x4600 | (insn & 0x78),
7682                         contents + rel->r_offset);
7683         }
7684       else
7685         {
7686           if ((insn & 0xf000) == 0xf000 || (insn & 0xf800) == 0xe800)
7687             /* It's a 32 bit instruction, fetch the rest of it for
7688                error generation.  */
7689             insn = (insn << 16)
7690               | bfd_get_16 (input_bfd, contents + rel->r_offset + 2);
7691           (*_bfd_error_handler)
7692             (_("%B(%A+0x%lx):unexpected Thumb instruction '0x%x' in TLS trampoline"),
7693              input_bfd, input_sec, (unsigned long)rel->r_offset, insn);
7694           return bfd_reloc_notsupported;
7695         }
7696       break;
7697
7698     case R_ARM_TLS_DESCSEQ:
7699       /* arm insn.  */
7700       insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
7701       if ((insn & 0xffff0ff0) == 0xe08f0000) /* add rx,pc,ry */
7702         {
7703           if (is_local)
7704             /* mov rx, ry */
7705             bfd_put_32 (input_bfd, 0xe1a00000 | (insn & 0xffff),
7706                         contents + rel->r_offset);
7707         }
7708       else if ((insn & 0xfff00fff) == 0xe5900004) /* ldr rx,[ry,#4]*/
7709         {
7710           if (is_local)
7711             /* nop */
7712             bfd_put_32 (input_bfd, 0xe1a00000, contents + rel->r_offset);
7713           else
7714             /* ldr rx,[ry] */
7715             bfd_put_32 (input_bfd, insn & 0xfffff000,
7716                         contents + rel->r_offset);
7717         }
7718       else if ((insn & 0xfffffff0) == 0xe12fff30) /* blx rx */
7719         {
7720           if (is_local)
7721             /* nop */
7722             bfd_put_32 (input_bfd, 0xe1a00000, contents + rel->r_offset);
7723           else
7724             /* mov r0, rx */
7725             bfd_put_32 (input_bfd, 0xe1a00000 | (insn & 0xf),
7726                         contents + rel->r_offset);
7727         }
7728       else
7729         {
7730           (*_bfd_error_handler)
7731             (_("%B(%A+0x%lx):unexpected ARM instruction '0x%x' in TLS trampoline"),
7732              input_bfd, input_sec, (unsigned long)rel->r_offset, insn);
7733           return bfd_reloc_notsupported;
7734         }
7735       break;
7736
7737     case R_ARM_TLS_CALL:
7738       /* GD->IE relaxation, turn the instruction into 'nop' or
7739          'ldr r0, [pc,r0]'  */
7740       insn = is_local ? 0xe1a00000 : 0xe79f0000;
7741       bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
7742       break;
7743
7744     case R_ARM_THM_TLS_CALL:
7745       /* GD->IE relaxation */
7746       if (!is_local)
7747         /* add r0,pc; ldr r0, [r0]  */
7748         insn = 0x44786800;
7749       else if (arch_has_thumb2_nop (globals))
7750         /* nop.w */
7751         insn = 0xf3af8000;
7752       else
7753         /* nop; nop */
7754         insn = 0xbf00bf00;
7755
7756       bfd_put_16 (input_bfd, insn >> 16, contents + rel->r_offset);
7757       bfd_put_16 (input_bfd, insn & 0xffff, contents + rel->r_offset + 2);
7758       break;
7759     }
7760   return bfd_reloc_ok;
7761 }
7762
7763 /* For a given value of n, calculate the value of G_n as required to
7764    deal with group relocations.  We return it in the form of an
7765    encoded constant-and-rotation, together with the final residual.  If n is
7766    specified as less than zero, then final_residual is filled with the
7767    input value and no further action is performed.  */
7768
7769 static bfd_vma
7770 calculate_group_reloc_mask (bfd_vma value, int n, bfd_vma *final_residual)
7771 {
7772   int current_n;
7773   bfd_vma g_n;
7774   bfd_vma encoded_g_n = 0;
7775   bfd_vma residual = value; /* Also known as Y_n.  */
7776
7777   for (current_n = 0; current_n <= n; current_n++)
7778     {
7779       int shift;
7780
7781       /* Calculate which part of the value to mask.  */
7782       if (residual == 0)
7783         shift = 0;
7784       else
7785         {
7786           int msb;
7787
7788           /* Determine the most significant bit in the residual and
7789              align the resulting value to a 2-bit boundary.  */
7790           for (msb = 30; msb >= 0; msb -= 2)
7791             if (residual & (3 << msb))
7792               break;
7793
7794           /* The desired shift is now (msb - 6), or zero, whichever
7795              is the greater.  */
7796           shift = msb - 6;
7797           if (shift < 0)
7798             shift = 0;
7799         }
7800
7801       /* Calculate g_n in 32-bit as well as encoded constant+rotation form.  */
7802       g_n = residual & (0xff << shift);
7803       encoded_g_n = (g_n >> shift)
7804                     | ((g_n <= 0xff ? 0 : (32 - shift) / 2) << 8);
7805
7806       /* Calculate the residual for the next time around.  */
7807       residual &= ~g_n;
7808     }
7809
7810   *final_residual = residual;
7811
7812   return encoded_g_n;
7813 }
7814
7815 /* Given an ARM instruction, determine whether it is an ADD or a SUB.
7816    Returns 1 if it is an ADD, -1 if it is a SUB, and 0 otherwise.  */
7817
7818 static int
7819 identify_add_or_sub (bfd_vma insn)
7820 {
7821   int opcode = insn & 0x1e00000;
7822
7823   if (opcode == 1 << 23) /* ADD */
7824     return 1;
7825
7826   if (opcode == 1 << 22) /* SUB */
7827     return -1;
7828
7829   return 0;
7830 }
7831
7832 /* Perform a relocation as part of a final link.  */
7833
7834 static bfd_reloc_status_type
7835 elf32_arm_final_link_relocate (reloc_howto_type *           howto,
7836                                bfd *                        input_bfd,
7837                                bfd *                        output_bfd,
7838                                asection *                   input_section,
7839                                bfd_byte *                   contents,
7840                                Elf_Internal_Rela *          rel,
7841                                bfd_vma                      value,
7842                                struct bfd_link_info *       info,
7843                                asection *                   sym_sec,
7844                                const char *                 sym_name,
7845                                unsigned char                st_type,
7846                                enum arm_st_branch_type      branch_type,
7847                                struct elf_link_hash_entry * h,
7848                                bfd_boolean *                unresolved_reloc_p,
7849                                char **                      error_message)
7850 {
7851   unsigned long                 r_type = howto->type;
7852   unsigned long                 r_symndx;
7853   bfd_byte *                    hit_data = contents + rel->r_offset;
7854   bfd_vma *                     local_got_offsets;
7855   bfd_vma *                     local_tlsdesc_gotents;
7856   asection *                    sgot;
7857   asection *                    splt;
7858   asection *                    sreloc = NULL;
7859   asection *                    srelgot;
7860   bfd_vma                       addend;
7861   bfd_signed_vma                signed_addend;
7862   unsigned char                 dynreloc_st_type;
7863   bfd_vma                       dynreloc_value;
7864   struct elf32_arm_link_hash_table * globals;
7865   struct elf32_arm_link_hash_entry *eh;
7866   union gotplt_union           *root_plt;
7867   struct arm_plt_info          *arm_plt;
7868   bfd_vma                       plt_offset;
7869   bfd_vma                       gotplt_offset;
7870   bfd_boolean                   has_iplt_entry;
7871
7872   globals = elf32_arm_hash_table (info);
7873   if (globals == NULL)
7874     return bfd_reloc_notsupported;
7875
7876   BFD_ASSERT (is_arm_elf (input_bfd));
7877
7878   /* Some relocation types map to different relocations depending on the
7879      target.  We pick the right one here.  */
7880   r_type = arm_real_reloc_type (globals, r_type);
7881
7882   /* It is possible to have linker relaxations on some TLS access
7883      models.  Update our information here.  */
7884   r_type = elf32_arm_tls_transition (info, r_type, h);
7885
7886   if (r_type != howto->type)
7887     howto = elf32_arm_howto_from_type (r_type);
7888
7889   /* If the start address has been set, then set the EF_ARM_HASENTRY
7890      flag.  Setting this more than once is redundant, but the cost is
7891      not too high, and it keeps the code simple.
7892
7893      The test is done  here, rather than somewhere else, because the
7894      start address is only set just before the final link commences.
7895
7896      Note - if the user deliberately sets a start address of 0, the
7897      flag will not be set.  */
7898   if (bfd_get_start_address (output_bfd) != 0)
7899     elf_elfheader (output_bfd)->e_flags |= EF_ARM_HASENTRY;
7900
7901   eh = (struct elf32_arm_link_hash_entry *) h;
7902   sgot = globals->root.sgot;
7903   local_got_offsets = elf_local_got_offsets (input_bfd);
7904   local_tlsdesc_gotents = elf32_arm_local_tlsdesc_gotent (input_bfd);
7905
7906   if (globals->root.dynamic_sections_created)
7907     srelgot = globals->root.srelgot;
7908   else
7909     srelgot = NULL;
7910
7911   r_symndx = ELF32_R_SYM (rel->r_info);
7912
7913   if (globals->use_rel)
7914     {
7915       addend = bfd_get_32 (input_bfd, hit_data) & howto->src_mask;
7916
7917       if (addend & ((howto->src_mask + 1) >> 1))
7918         {
7919           signed_addend = -1;
7920           signed_addend &= ~ howto->src_mask;
7921           signed_addend |= addend;
7922         }
7923       else
7924         signed_addend = addend;
7925     }
7926   else
7927     addend = signed_addend = rel->r_addend;
7928
7929   /* Record the symbol information that should be used in dynamic
7930      relocations.  */
7931   dynreloc_st_type = st_type;
7932   dynreloc_value = value;
7933   if (branch_type == ST_BRANCH_TO_THUMB)
7934     dynreloc_value |= 1;
7935
7936   /* Find out whether the symbol has a PLT.  Set ST_VALUE, BRANCH_TYPE and
7937      VALUE appropriately for relocations that we resolve at link time.  */
7938   has_iplt_entry = FALSE;
7939   if (elf32_arm_get_plt_info (input_bfd, eh, r_symndx, &root_plt, &arm_plt)
7940       && root_plt->offset != (bfd_vma) -1)
7941     {
7942       plt_offset = root_plt->offset;
7943       gotplt_offset = arm_plt->got_offset;
7944
7945       if (h == NULL || eh->is_iplt)
7946         {
7947           has_iplt_entry = TRUE;
7948           splt = globals->root.iplt;
7949
7950           /* Populate .iplt entries here, because not all of them will
7951              be seen by finish_dynamic_symbol.  The lower bit is set if
7952              we have already populated the entry.  */
7953           if (plt_offset & 1)
7954             plt_offset--;
7955           else
7956             {
7957               elf32_arm_populate_plt_entry (output_bfd, info, root_plt, arm_plt,
7958                                             -1, dynreloc_value);
7959               root_plt->offset |= 1;
7960             }
7961
7962           /* Static relocations always resolve to the .iplt entry.  */
7963           st_type = STT_FUNC;
7964           value = (splt->output_section->vma
7965                    + splt->output_offset
7966                    + plt_offset);
7967           branch_type = ST_BRANCH_TO_ARM;
7968
7969           /* If there are non-call relocations that resolve to the .iplt
7970              entry, then all dynamic ones must too.  */
7971           if (arm_plt->noncall_refcount != 0)
7972             {
7973               dynreloc_st_type = st_type;
7974               dynreloc_value = value;
7975             }
7976         }
7977       else
7978         /* We populate the .plt entry in finish_dynamic_symbol.  */
7979         splt = globals->root.splt;
7980     }
7981   else
7982     {
7983       splt = NULL;
7984       plt_offset = (bfd_vma) -1;
7985       gotplt_offset = (bfd_vma) -1;
7986     }
7987
7988   switch (r_type)
7989     {
7990     case R_ARM_NONE:
7991       /* We don't need to find a value for this symbol.  It's just a
7992          marker.  */
7993       *unresolved_reloc_p = FALSE;
7994       return bfd_reloc_ok;
7995
7996     case R_ARM_ABS12:
7997       if (!globals->vxworks_p)
7998         return elf32_arm_abs12_reloc (input_bfd, hit_data, value + addend);
7999
8000     case R_ARM_PC24:
8001     case R_ARM_ABS32:
8002     case R_ARM_ABS32_NOI:
8003     case R_ARM_REL32:
8004     case R_ARM_REL32_NOI:
8005     case R_ARM_CALL:
8006     case R_ARM_JUMP24:
8007     case R_ARM_XPC25:
8008     case R_ARM_PREL31:
8009     case R_ARM_PLT32:
8010       /* Handle relocations which should use the PLT entry.  ABS32/REL32
8011          will use the symbol's value, which may point to a PLT entry, but we
8012          don't need to handle that here.  If we created a PLT entry, all
8013          branches in this object should go to it, except if the PLT is too
8014          far away, in which case a long branch stub should be inserted.  */
8015       if ((r_type != R_ARM_ABS32 && r_type != R_ARM_REL32
8016            && r_type != R_ARM_ABS32_NOI && r_type != R_ARM_REL32_NOI
8017            && r_type != R_ARM_CALL
8018            && r_type != R_ARM_JUMP24
8019            && r_type != R_ARM_PLT32)
8020           && plt_offset != (bfd_vma) -1)
8021         {
8022           /* If we've created a .plt section, and assigned a PLT entry
8023              to this function, it must either be a STT_GNU_IFUNC reference
8024              or not be known to bind locally.  In other cases, we should
8025              have cleared the PLT entry by now.  */
8026           BFD_ASSERT (has_iplt_entry || !SYMBOL_CALLS_LOCAL (info, h));
8027
8028           value = (splt->output_section->vma
8029                    + splt->output_offset
8030                    + plt_offset);
8031           *unresolved_reloc_p = FALSE;
8032           return _bfd_final_link_relocate (howto, input_bfd, input_section,
8033                                            contents, rel->r_offset, value,
8034                                            rel->r_addend);
8035         }
8036
8037       /* When generating a shared object or relocatable executable, these
8038          relocations are copied into the output file to be resolved at
8039          run time.  */
8040       if ((info->shared || globals->root.is_relocatable_executable)
8041           && (input_section->flags & SEC_ALLOC)
8042           && !(globals->vxworks_p
8043                && strcmp (input_section->output_section->name,
8044                           ".tls_vars") == 0)
8045           && ((r_type != R_ARM_REL32 && r_type != R_ARM_REL32_NOI)
8046               || !SYMBOL_CALLS_LOCAL (info, h))
8047           && (!strstr (input_section->name, STUB_SUFFIX))
8048           && (h == NULL
8049               || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
8050               || h->root.type != bfd_link_hash_undefweak)
8051           && r_type != R_ARM_PC24
8052           && r_type != R_ARM_CALL
8053           && r_type != R_ARM_JUMP24
8054           && r_type != R_ARM_PREL31
8055           && r_type != R_ARM_PLT32)
8056         {
8057           Elf_Internal_Rela outrel;
8058           bfd_boolean skip, relocate;
8059
8060           *unresolved_reloc_p = FALSE;
8061
8062           if (sreloc == NULL && globals->root.dynamic_sections_created)
8063             {
8064               sreloc = _bfd_elf_get_dynamic_reloc_section (input_bfd, input_section,
8065                                                            ! globals->use_rel);
8066
8067               if (sreloc == NULL)
8068                 return bfd_reloc_notsupported;
8069             }
8070
8071           skip = FALSE;
8072           relocate = FALSE;
8073
8074           outrel.r_addend = addend;
8075           outrel.r_offset =
8076             _bfd_elf_section_offset (output_bfd, info, input_section,
8077                                      rel->r_offset);
8078           if (outrel.r_offset == (bfd_vma) -1)
8079             skip = TRUE;
8080           else if (outrel.r_offset == (bfd_vma) -2)
8081             skip = TRUE, relocate = TRUE;
8082           outrel.r_offset += (input_section->output_section->vma
8083                               + input_section->output_offset);
8084
8085           if (skip)
8086             memset (&outrel, 0, sizeof outrel);
8087           else if (h != NULL
8088                    && h->dynindx != -1
8089                    && (!info->shared
8090                        || !info->symbolic
8091                        || !h->def_regular))
8092             outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
8093           else
8094             {
8095               int symbol;
8096
8097               /* This symbol is local, or marked to become local.  */
8098               BFD_ASSERT (r_type == R_ARM_ABS32 || r_type == R_ARM_ABS32_NOI);
8099               if (globals->symbian_p)
8100                 {
8101                   asection *osec;
8102
8103                   /* On Symbian OS, the data segment and text segement
8104                      can be relocated independently.  Therefore, we
8105                      must indicate the segment to which this
8106                      relocation is relative.  The BPABI allows us to
8107                      use any symbol in the right segment; we just use
8108                      the section symbol as it is convenient.  (We
8109                      cannot use the symbol given by "h" directly as it
8110                      will not appear in the dynamic symbol table.)
8111
8112                      Note that the dynamic linker ignores the section
8113                      symbol value, so we don't subtract osec->vma
8114                      from the emitted reloc addend.  */
8115                   if (sym_sec)
8116                     osec = sym_sec->output_section;
8117                   else
8118                     osec = input_section->output_section;
8119                   symbol = elf_section_data (osec)->dynindx;
8120                   if (symbol == 0)
8121                     {
8122                       struct elf_link_hash_table *htab = elf_hash_table (info);
8123
8124                       if ((osec->flags & SEC_READONLY) == 0
8125                           && htab->data_index_section != NULL)
8126                         osec = htab->data_index_section;
8127                       else
8128                         osec = htab->text_index_section;
8129                       symbol = elf_section_data (osec)->dynindx;
8130                     }
8131                   BFD_ASSERT (symbol != 0);
8132                 }
8133               else
8134                 /* On SVR4-ish systems, the dynamic loader cannot
8135                    relocate the text and data segments independently,
8136                    so the symbol does not matter.  */
8137                 symbol = 0;
8138               if (dynreloc_st_type == STT_GNU_IFUNC)
8139                 /* We have an STT_GNU_IFUNC symbol that doesn't resolve
8140                    to the .iplt entry.  Instead, every non-call reference
8141                    must use an R_ARM_IRELATIVE relocation to obtain the
8142                    correct run-time address.  */
8143                 outrel.r_info = ELF32_R_INFO (symbol, R_ARM_IRELATIVE);
8144               else
8145                 outrel.r_info = ELF32_R_INFO (symbol, R_ARM_RELATIVE);
8146               if (globals->use_rel)
8147                 relocate = TRUE;
8148               else
8149                 outrel.r_addend += dynreloc_value;
8150             }
8151
8152           elf32_arm_add_dynreloc (output_bfd, info, sreloc, &outrel);
8153
8154           /* If this reloc is against an external symbol, we do not want to
8155              fiddle with the addend.  Otherwise, we need to include the symbol
8156              value so that it becomes an addend for the dynamic reloc.  */
8157           if (! relocate)
8158             return bfd_reloc_ok;
8159
8160           return _bfd_final_link_relocate (howto, input_bfd, input_section,
8161                                            contents, rel->r_offset,
8162                                            dynreloc_value, (bfd_vma) 0);
8163         }
8164       else switch (r_type)
8165         {
8166         case R_ARM_ABS12:
8167           return elf32_arm_abs12_reloc (input_bfd, hit_data, value + addend);
8168
8169         case R_ARM_XPC25:         /* Arm BLX instruction.  */
8170         case R_ARM_CALL:
8171         case R_ARM_JUMP24:
8172         case R_ARM_PC24:          /* Arm B/BL instruction.  */
8173         case R_ARM_PLT32:
8174           {
8175           struct elf32_arm_stub_hash_entry *stub_entry = NULL;
8176
8177           if (r_type == R_ARM_XPC25)
8178             {
8179               /* Check for Arm calling Arm function.  */
8180               /* FIXME: Should we translate the instruction into a BL
8181                  instruction instead ?  */
8182               if (branch_type != ST_BRANCH_TO_THUMB)
8183                 (*_bfd_error_handler)
8184                   (_("\%B: Warning: Arm BLX instruction targets Arm function '%s'."),
8185                    input_bfd,
8186                    h ? h->root.root.string : "(local)");
8187             }
8188           else if (r_type == R_ARM_PC24)
8189             {
8190               /* Check for Arm calling Thumb function.  */
8191               if (branch_type == ST_BRANCH_TO_THUMB)
8192                 {
8193                   if (elf32_arm_to_thumb_stub (info, sym_name, input_bfd,
8194                                                output_bfd, input_section,
8195                                                hit_data, sym_sec, rel->r_offset,
8196                                                signed_addend, value,
8197                                                error_message))
8198                     return bfd_reloc_ok;
8199                   else
8200                     return bfd_reloc_dangerous;
8201                 }
8202             }
8203
8204           /* Check if a stub has to be inserted because the
8205              destination is too far or we are changing mode.  */
8206           if (   r_type == R_ARM_CALL
8207               || r_type == R_ARM_JUMP24
8208               || r_type == R_ARM_PLT32)
8209             {
8210               enum elf32_arm_stub_type stub_type = arm_stub_none;
8211               struct elf32_arm_link_hash_entry *hash;
8212
8213               hash = (struct elf32_arm_link_hash_entry *) h;
8214               stub_type = arm_type_of_stub (info, input_section, rel,
8215                                             st_type, &branch_type,
8216                                             hash, value, sym_sec,
8217                                             input_bfd, sym_name);
8218
8219               if (stub_type != arm_stub_none)
8220                 {
8221                   /* The target is out of reach, so redirect the
8222                      branch to the local stub for this function.  */
8223                   stub_entry = elf32_arm_get_stub_entry (input_section,
8224                                                          sym_sec, h,
8225                                                          rel, globals,
8226                                                          stub_type);
8227                   {
8228                     if (stub_entry != NULL)
8229                       value = (stub_entry->stub_offset
8230                                + stub_entry->stub_sec->output_offset
8231                                + stub_entry->stub_sec->output_section->vma);
8232
8233                     if (plt_offset != (bfd_vma) -1)
8234                       *unresolved_reloc_p = FALSE;
8235                   }
8236                 }
8237               else
8238                 {
8239                   /* If the call goes through a PLT entry, make sure to
8240                      check distance to the right destination address.  */
8241                   if (plt_offset != (bfd_vma) -1)
8242                     {
8243                       value = (splt->output_section->vma
8244                                + splt->output_offset
8245                                + plt_offset);
8246                       *unresolved_reloc_p = FALSE;
8247                       /* The PLT entry is in ARM mode, regardless of the
8248                          target function.  */
8249                       branch_type = ST_BRANCH_TO_ARM;
8250                     }
8251                 }
8252             }
8253
8254           /* The ARM ELF ABI says that this reloc is computed as: S - P + A
8255              where:
8256               S is the address of the symbol in the relocation.
8257               P is address of the instruction being relocated.
8258               A is the addend (extracted from the instruction) in bytes.
8259
8260              S is held in 'value'.
8261              P is the base address of the section containing the
8262                instruction plus the offset of the reloc into that
8263                section, ie:
8264                  (input_section->output_section->vma +
8265                   input_section->output_offset +
8266                   rel->r_offset).
8267              A is the addend, converted into bytes, ie:
8268                  (signed_addend * 4)
8269
8270              Note: None of these operations have knowledge of the pipeline
8271              size of the processor, thus it is up to the assembler to
8272              encode this information into the addend.  */
8273           value -= (input_section->output_section->vma
8274                     + input_section->output_offset);
8275           value -= rel->r_offset;
8276           if (globals->use_rel)
8277             value += (signed_addend << howto->size);
8278           else
8279             /* RELA addends do not have to be adjusted by howto->size.  */
8280             value += signed_addend;
8281
8282           signed_addend = value;
8283           signed_addend >>= howto->rightshift;
8284
8285           /* A branch to an undefined weak symbol is turned into a jump to
8286              the next instruction unless a PLT entry will be created.
8287              Do the same for local undefined symbols (but not for STN_UNDEF).
8288              The jump to the next instruction is optimized as a NOP depending
8289              on the architecture.  */
8290           if (h ? (h->root.type == bfd_link_hash_undefweak
8291                    && plt_offset == (bfd_vma) -1)
8292               : r_symndx != STN_UNDEF && bfd_is_und_section (sym_sec))
8293             {
8294               value = (bfd_get_32 (input_bfd, hit_data) & 0xf0000000);
8295
8296               if (arch_has_arm_nop (globals))
8297                 value |= 0x0320f000;
8298               else
8299                 value |= 0x01a00000; /* Using pre-UAL nop: mov r0, r0.  */
8300             }
8301           else
8302             {
8303               /* Perform a signed range check.  */
8304               if (   signed_addend >   ((bfd_signed_vma)  (howto->dst_mask >> 1))
8305                   || signed_addend < - ((bfd_signed_vma) ((howto->dst_mask + 1) >> 1)))
8306                 return bfd_reloc_overflow;
8307
8308               addend = (value & 2);
8309
8310               value = (signed_addend & howto->dst_mask)
8311                 | (bfd_get_32 (input_bfd, hit_data) & (~ howto->dst_mask));
8312
8313               if (r_type == R_ARM_CALL)
8314                 {
8315                   /* Set the H bit in the BLX instruction.  */
8316                   if (branch_type == ST_BRANCH_TO_THUMB)
8317                     {
8318                       if (addend)
8319                         value |= (1 << 24);
8320                       else
8321                         value &= ~(bfd_vma)(1 << 24);
8322                     }
8323
8324                   /* Select the correct instruction (BL or BLX).  */
8325                   /* Only if we are not handling a BL to a stub. In this
8326                      case, mode switching is performed by the stub.  */
8327                   if (branch_type == ST_BRANCH_TO_THUMB && !stub_entry)
8328                     value |= (1 << 28);
8329                   else if (stub_entry || branch_type != ST_BRANCH_UNKNOWN)
8330                     {
8331                       value &= ~(bfd_vma)(1 << 28);
8332                       value |= (1 << 24);
8333                     }
8334                 }
8335             }
8336           }
8337           break;
8338
8339         case R_ARM_ABS32:
8340           value += addend;
8341           if (branch_type == ST_BRANCH_TO_THUMB)
8342             value |= 1;
8343           break;
8344
8345         case R_ARM_ABS32_NOI:
8346           value += addend;
8347           break;
8348
8349         case R_ARM_REL32:
8350           value += addend;
8351           if (branch_type == ST_BRANCH_TO_THUMB)
8352             value |= 1;
8353           value -= (input_section->output_section->vma
8354                     + input_section->output_offset + rel->r_offset);
8355           break;
8356
8357         case R_ARM_REL32_NOI:
8358           value += addend;
8359           value -= (input_section->output_section->vma
8360                     + input_section->output_offset + rel->r_offset);
8361           break;
8362
8363         case R_ARM_PREL31:
8364           value -= (input_section->output_section->vma
8365                     + input_section->output_offset + rel->r_offset);
8366           value += signed_addend;
8367           if (! h || h->root.type != bfd_link_hash_undefweak)
8368             {
8369               /* Check for overflow.  */
8370               if ((value ^ (value >> 1)) & (1 << 30))
8371                 return bfd_reloc_overflow;
8372             }
8373           value &= 0x7fffffff;
8374           value |= (bfd_get_32 (input_bfd, hit_data) & 0x80000000);
8375           if (branch_type == ST_BRANCH_TO_THUMB)
8376             value |= 1;
8377           break;
8378         }
8379
8380       bfd_put_32 (input_bfd, value, hit_data);
8381       return bfd_reloc_ok;
8382
8383     case R_ARM_ABS8:
8384       value += addend;
8385
8386       /* There is no way to tell whether the user intended to use a signed or
8387          unsigned addend.  When checking for overflow we accept either,
8388          as specified by the AAELF.  */
8389       if ((long) value > 0xff || (long) value < -0x80)
8390         return bfd_reloc_overflow;
8391
8392       bfd_put_8 (input_bfd, value, hit_data);
8393       return bfd_reloc_ok;
8394
8395     case R_ARM_ABS16:
8396       value += addend;
8397
8398       /* See comment for R_ARM_ABS8.  */
8399       if ((long) value > 0xffff || (long) value < -0x8000)
8400         return bfd_reloc_overflow;
8401
8402       bfd_put_16 (input_bfd, value, hit_data);
8403       return bfd_reloc_ok;
8404
8405     case R_ARM_THM_ABS5:
8406       /* Support ldr and str instructions for the thumb.  */
8407       if (globals->use_rel)
8408         {
8409           /* Need to refetch addend.  */
8410           addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
8411           /* ??? Need to determine shift amount from operand size.  */
8412           addend >>= howto->rightshift;
8413         }
8414       value += addend;
8415
8416       /* ??? Isn't value unsigned?  */
8417       if ((long) value > 0x1f || (long) value < -0x10)
8418         return bfd_reloc_overflow;
8419
8420       /* ??? Value needs to be properly shifted into place first.  */
8421       value |= bfd_get_16 (input_bfd, hit_data) & 0xf83f;
8422       bfd_put_16 (input_bfd, value, hit_data);
8423       return bfd_reloc_ok;
8424
8425     case R_ARM_THM_ALU_PREL_11_0:
8426       /* Corresponds to: addw.w reg, pc, #offset (and similarly for subw).  */
8427       {
8428         bfd_vma insn;
8429         bfd_signed_vma relocation;
8430
8431         insn = (bfd_get_16 (input_bfd, hit_data) << 16)
8432              | bfd_get_16 (input_bfd, hit_data + 2);
8433
8434         if (globals->use_rel)
8435           {
8436             signed_addend = (insn & 0xff) | ((insn & 0x7000) >> 4)
8437                           | ((insn & (1 << 26)) >> 15);
8438             if (insn & 0xf00000)
8439               signed_addend = -signed_addend;
8440           }
8441
8442         relocation = value + signed_addend;
8443         relocation -= (input_section->output_section->vma
8444                        + input_section->output_offset
8445                        + rel->r_offset);
8446
8447         value = abs (relocation);
8448
8449         if (value >= 0x1000)
8450           return bfd_reloc_overflow;
8451
8452         insn = (insn & 0xfb0f8f00) | (value & 0xff)
8453              | ((value & 0x700) << 4)
8454              | ((value & 0x800) << 15);
8455         if (relocation < 0)
8456           insn |= 0xa00000;
8457
8458         bfd_put_16 (input_bfd, insn >> 16, hit_data);
8459         bfd_put_16 (input_bfd, insn & 0xffff, hit_data + 2);
8460
8461         return bfd_reloc_ok;
8462       }
8463
8464     case R_ARM_THM_PC8:
8465       /* PR 10073:  This reloc is not generated by the GNU toolchain,
8466          but it is supported for compatibility with third party libraries
8467          generated by other compilers, specifically the ARM/IAR.  */
8468       {
8469         bfd_vma insn;
8470         bfd_signed_vma relocation;
8471
8472         insn = bfd_get_16 (input_bfd, hit_data);
8473
8474         if (globals->use_rel)
8475           addend = (insn & 0x00ff) << 2;
8476
8477         relocation = value + addend;
8478         relocation -= (input_section->output_section->vma
8479                        + input_section->output_offset
8480                        + rel->r_offset);
8481
8482         value = abs (relocation);
8483
8484         /* We do not check for overflow of this reloc.  Although strictly
8485            speaking this is incorrect, it appears to be necessary in order
8486            to work with IAR generated relocs.  Since GCC and GAS do not
8487            generate R_ARM_THM_PC8 relocs, the lack of a check should not be
8488            a problem for them.  */
8489         value &= 0x3fc;
8490
8491         insn = (insn & 0xff00) | (value >> 2);
8492
8493         bfd_put_16 (input_bfd, insn, hit_data);
8494
8495         return bfd_reloc_ok;
8496       }
8497
8498     case R_ARM_THM_PC12:
8499       /* Corresponds to: ldr.w reg, [pc, #offset].  */
8500       {
8501         bfd_vma insn;
8502         bfd_signed_vma relocation;
8503
8504         insn = (bfd_get_16 (input_bfd, hit_data) << 16)
8505              | bfd_get_16 (input_bfd, hit_data + 2);
8506
8507         if (globals->use_rel)
8508           {
8509             signed_addend = insn & 0xfff;
8510             if (!(insn & (1 << 23)))
8511               signed_addend = -signed_addend;
8512           }
8513
8514         relocation = value + signed_addend;
8515         relocation -= (input_section->output_section->vma
8516                        + input_section->output_offset
8517                        + rel->r_offset);
8518
8519         value = abs (relocation);
8520
8521         if (value >= 0x1000)
8522           return bfd_reloc_overflow;
8523
8524         insn = (insn & 0xff7ff000) | value;
8525         if (relocation >= 0)
8526           insn |= (1 << 23);
8527
8528         bfd_put_16 (input_bfd, insn >> 16, hit_data);
8529         bfd_put_16 (input_bfd, insn & 0xffff, hit_data + 2);
8530
8531         return bfd_reloc_ok;
8532       }
8533
8534     case R_ARM_THM_XPC22:
8535     case R_ARM_THM_CALL:
8536     case R_ARM_THM_JUMP24:
8537       /* Thumb BL (branch long instruction).  */
8538       {
8539         bfd_vma relocation;
8540         bfd_vma reloc_sign;
8541         bfd_boolean overflow = FALSE;
8542         bfd_vma upper_insn = bfd_get_16 (input_bfd, hit_data);
8543         bfd_vma lower_insn = bfd_get_16 (input_bfd, hit_data + 2);
8544         bfd_signed_vma reloc_signed_max;
8545         bfd_signed_vma reloc_signed_min;
8546         bfd_vma check;
8547         bfd_signed_vma signed_check;
8548         int bitsize;
8549         const int thumb2 = using_thumb2 (globals);
8550
8551         /* A branch to an undefined weak symbol is turned into a jump to
8552            the next instruction unless a PLT entry will be created.
8553            The jump to the next instruction is optimized as a NOP.W for
8554            Thumb-2 enabled architectures.  */
8555         if (h && h->root.type == bfd_link_hash_undefweak
8556             && plt_offset == (bfd_vma) -1)
8557           {
8558             if (arch_has_thumb2_nop (globals))
8559               {
8560                 bfd_put_16 (input_bfd, 0xf3af, hit_data);
8561                 bfd_put_16 (input_bfd, 0x8000, hit_data + 2);
8562               }
8563             else
8564               {
8565                 bfd_put_16 (input_bfd, 0xe000, hit_data);
8566                 bfd_put_16 (input_bfd, 0xbf00, hit_data + 2);
8567               }
8568             return bfd_reloc_ok;
8569           }
8570
8571         /* Fetch the addend.  We use the Thumb-2 encoding (backwards compatible
8572            with Thumb-1) involving the J1 and J2 bits.  */
8573         if (globals->use_rel)
8574           {
8575             bfd_vma s = (upper_insn & (1 << 10)) >> 10;
8576             bfd_vma upper = upper_insn & 0x3ff;
8577             bfd_vma lower = lower_insn & 0x7ff;
8578             bfd_vma j1 = (lower_insn & (1 << 13)) >> 13;
8579             bfd_vma j2 = (lower_insn & (1 << 11)) >> 11;
8580             bfd_vma i1 = j1 ^ s ? 0 : 1;
8581             bfd_vma i2 = j2 ^ s ? 0 : 1;
8582
8583             addend = (i1 << 23) | (i2 << 22) | (upper << 12) | (lower << 1);
8584             /* Sign extend.  */
8585             addend = (addend | ((s ? 0 : 1) << 24)) - (1 << 24);
8586
8587             signed_addend = addend;
8588           }
8589
8590         if (r_type == R_ARM_THM_XPC22)
8591           {
8592             /* Check for Thumb to Thumb call.  */
8593             /* FIXME: Should we translate the instruction into a BL
8594                instruction instead ?  */
8595             if (branch_type == ST_BRANCH_TO_THUMB)
8596               (*_bfd_error_handler)
8597                 (_("%B: Warning: Thumb BLX instruction targets thumb function '%s'."),
8598                  input_bfd,
8599                  h ? h->root.root.string : "(local)");
8600           }
8601         else
8602           {
8603             /* If it is not a call to Thumb, assume call to Arm.
8604                If it is a call relative to a section name, then it is not a
8605                function call at all, but rather a long jump.  Calls through
8606                the PLT do not require stubs.  */
8607             if (branch_type == ST_BRANCH_TO_ARM && plt_offset == (bfd_vma) -1)
8608               {
8609                 if (globals->use_blx && r_type == R_ARM_THM_CALL)
8610                   {
8611                     /* Convert BL to BLX.  */
8612                     lower_insn = (lower_insn & ~0x1000) | 0x0800;
8613                   }
8614                 else if ((   r_type != R_ARM_THM_CALL)
8615                          && (r_type != R_ARM_THM_JUMP24))
8616                   {
8617                     if (elf32_thumb_to_arm_stub
8618                         (info, sym_name, input_bfd, output_bfd, input_section,
8619                          hit_data, sym_sec, rel->r_offset, signed_addend, value,
8620                          error_message))
8621                       return bfd_reloc_ok;
8622                     else
8623                       return bfd_reloc_dangerous;
8624                   }
8625               }
8626             else if (branch_type == ST_BRANCH_TO_THUMB
8627                      && globals->use_blx
8628                      && r_type == R_ARM_THM_CALL)
8629               {
8630                 /* Make sure this is a BL.  */
8631                 lower_insn |= 0x1800;
8632               }
8633           }
8634
8635         enum elf32_arm_stub_type stub_type = arm_stub_none;
8636         if (r_type == R_ARM_THM_CALL || r_type == R_ARM_THM_JUMP24)
8637           {
8638             /* Check if a stub has to be inserted because the destination
8639                is too far.  */
8640             struct elf32_arm_stub_hash_entry *stub_entry;
8641             struct elf32_arm_link_hash_entry *hash;
8642
8643             hash = (struct elf32_arm_link_hash_entry *) h;
8644
8645             stub_type = arm_type_of_stub (info, input_section, rel,
8646                                           st_type, &branch_type,
8647                                           hash, value, sym_sec,
8648                                           input_bfd, sym_name);
8649
8650             if (stub_type != arm_stub_none)
8651               {
8652                 /* The target is out of reach or we are changing modes, so
8653                    redirect the branch to the local stub for this
8654                    function.  */
8655                 stub_entry = elf32_arm_get_stub_entry (input_section,
8656                                                        sym_sec, h,
8657                                                        rel, globals,
8658                                                        stub_type);
8659                 if (stub_entry != NULL)
8660                   {
8661                     value = (stub_entry->stub_offset
8662                              + stub_entry->stub_sec->output_offset
8663                              + stub_entry->stub_sec->output_section->vma);
8664
8665                     if (plt_offset != (bfd_vma) -1)
8666                       *unresolved_reloc_p = FALSE;
8667                   }
8668
8669                 /* If this call becomes a call to Arm, force BLX.  */
8670                 if (globals->use_blx && (r_type == R_ARM_THM_CALL))
8671                   {
8672                     if ((stub_entry
8673                          && !arm_stub_is_thumb (stub_entry->stub_type))
8674                         || branch_type != ST_BRANCH_TO_THUMB)
8675                       lower_insn = (lower_insn & ~0x1000) | 0x0800;
8676                   }
8677               }
8678           }
8679
8680         /* Handle calls via the PLT.  */
8681         if (stub_type == arm_stub_none && plt_offset != (bfd_vma) -1)
8682           {
8683             value = (splt->output_section->vma
8684                      + splt->output_offset
8685                      + plt_offset);
8686
8687             if (globals->use_blx && r_type == R_ARM_THM_CALL)
8688               {
8689                 /* If the Thumb BLX instruction is available, convert
8690                    the BL to a BLX instruction to call the ARM-mode
8691                    PLT entry.  */
8692                 lower_insn = (lower_insn & ~0x1000) | 0x0800;
8693                 branch_type = ST_BRANCH_TO_ARM;
8694               }
8695             else
8696               {
8697                 /* Target the Thumb stub before the ARM PLT entry.  */
8698                 value -= PLT_THUMB_STUB_SIZE;
8699                 branch_type = ST_BRANCH_TO_THUMB;
8700               }
8701             *unresolved_reloc_p = FALSE;
8702           }
8703
8704         relocation = value + signed_addend;
8705
8706         relocation -= (input_section->output_section->vma
8707                        + input_section->output_offset
8708                        + rel->r_offset);
8709
8710         check = relocation >> howto->rightshift;
8711
8712         /* If this is a signed value, the rightshift just dropped
8713            leading 1 bits (assuming twos complement).  */
8714         if ((bfd_signed_vma) relocation >= 0)
8715           signed_check = check;
8716         else
8717           signed_check = check | ~((bfd_vma) -1 >> howto->rightshift);
8718
8719         /* Calculate the permissable maximum and minimum values for
8720            this relocation according to whether we're relocating for
8721            Thumb-2 or not.  */
8722         bitsize = howto->bitsize;
8723         if (!thumb2)
8724           bitsize -= 2;
8725         reloc_signed_max = (1 << (bitsize - 1)) - 1;
8726         reloc_signed_min = ~reloc_signed_max;
8727
8728         /* Assumes two's complement.  */
8729         if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
8730           overflow = TRUE;
8731
8732         if ((lower_insn & 0x5000) == 0x4000)
8733           /* For a BLX instruction, make sure that the relocation is rounded up
8734              to a word boundary.  This follows the semantics of the instruction
8735              which specifies that bit 1 of the target address will come from bit
8736              1 of the base address.  */
8737           relocation = (relocation + 2) & ~ 3;
8738
8739         /* Put RELOCATION back into the insn.  Assumes two's complement.
8740            We use the Thumb-2 encoding, which is safe even if dealing with
8741            a Thumb-1 instruction by virtue of our overflow check above.  */
8742         reloc_sign = (signed_check < 0) ? 1 : 0;
8743         upper_insn = (upper_insn & ~(bfd_vma) 0x7ff)
8744                      | ((relocation >> 12) & 0x3ff)
8745                      | (reloc_sign << 10);
8746         lower_insn = (lower_insn & ~(bfd_vma) 0x2fff)
8747                      | (((!((relocation >> 23) & 1)) ^ reloc_sign) << 13)
8748                      | (((!((relocation >> 22) & 1)) ^ reloc_sign) << 11)
8749                      | ((relocation >> 1) & 0x7ff);
8750
8751         /* Put the relocated value back in the object file:  */
8752         bfd_put_16 (input_bfd, upper_insn, hit_data);
8753         bfd_put_16 (input_bfd, lower_insn, hit_data + 2);
8754
8755         return (overflow ? bfd_reloc_overflow : bfd_reloc_ok);
8756       }
8757       break;
8758
8759     case R_ARM_THM_JUMP19:
8760       /* Thumb32 conditional branch instruction.  */
8761       {
8762         bfd_vma relocation;
8763         bfd_boolean overflow = FALSE;
8764         bfd_vma upper_insn = bfd_get_16 (input_bfd, hit_data);
8765         bfd_vma lower_insn = bfd_get_16 (input_bfd, hit_data + 2);
8766         bfd_signed_vma reloc_signed_max = 0xffffe;
8767         bfd_signed_vma reloc_signed_min = -0x100000;
8768         bfd_signed_vma signed_check;
8769
8770         /* Need to refetch the addend, reconstruct the top three bits,
8771            and squish the two 11 bit pieces together.  */
8772         if (globals->use_rel)
8773           {
8774             bfd_vma S     = (upper_insn & 0x0400) >> 10;
8775             bfd_vma upper = (upper_insn & 0x003f);
8776             bfd_vma J1    = (lower_insn & 0x2000) >> 13;
8777             bfd_vma J2    = (lower_insn & 0x0800) >> 11;
8778             bfd_vma lower = (lower_insn & 0x07ff);
8779
8780             upper |= J1 << 6;
8781             upper |= J2 << 7;
8782             upper |= (!S) << 8;
8783             upper -= 0x0100; /* Sign extend.  */
8784
8785             addend = (upper << 12) | (lower << 1);
8786             signed_addend = addend;
8787           }
8788
8789         /* Handle calls via the PLT.  */
8790         if (plt_offset != (bfd_vma) -1)
8791           {
8792             value = (splt->output_section->vma
8793                      + splt->output_offset
8794                      + plt_offset);
8795             /* Target the Thumb stub before the ARM PLT entry.  */
8796             value -= PLT_THUMB_STUB_SIZE;
8797             *unresolved_reloc_p = FALSE;
8798           }
8799
8800         /* ??? Should handle interworking?  GCC might someday try to
8801            use this for tail calls.  */
8802
8803         relocation = value + signed_addend;
8804         relocation -= (input_section->output_section->vma
8805                        + input_section->output_offset
8806                        + rel->r_offset);
8807         signed_check = (bfd_signed_vma) relocation;
8808
8809         if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
8810           overflow = TRUE;
8811
8812         /* Put RELOCATION back into the insn.  */
8813         {
8814           bfd_vma S  = (relocation & 0x00100000) >> 20;
8815           bfd_vma J2 = (relocation & 0x00080000) >> 19;
8816           bfd_vma J1 = (relocation & 0x00040000) >> 18;
8817           bfd_vma hi = (relocation & 0x0003f000) >> 12;
8818           bfd_vma lo = (relocation & 0x00000ffe) >>  1;
8819
8820           upper_insn = (upper_insn & 0xfbc0) | (S << 10) | hi;
8821           lower_insn = (lower_insn & 0xd000) | (J1 << 13) | (J2 << 11) | lo;
8822         }
8823
8824         /* Put the relocated value back in the object file:  */
8825         bfd_put_16 (input_bfd, upper_insn, hit_data);
8826         bfd_put_16 (input_bfd, lower_insn, hit_data + 2);
8827
8828         return (overflow ? bfd_reloc_overflow : bfd_reloc_ok);
8829       }
8830
8831     case R_ARM_THM_JUMP11:
8832     case R_ARM_THM_JUMP8:
8833     case R_ARM_THM_JUMP6:
8834       /* Thumb B (branch) instruction).  */
8835       {
8836         bfd_signed_vma relocation;
8837         bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
8838         bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
8839         bfd_signed_vma signed_check;
8840
8841         /* CZB cannot jump backward.  */
8842         if (r_type == R_ARM_THM_JUMP6)
8843           reloc_signed_min = 0;
8844
8845         if (globals->use_rel)
8846           {
8847             /* Need to refetch addend.  */
8848             addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
8849             if (addend & ((howto->src_mask + 1) >> 1))
8850               {
8851                 signed_addend = -1;
8852                 signed_addend &= ~ howto->src_mask;
8853                 signed_addend |= addend;
8854               }
8855             else
8856               signed_addend = addend;
8857             /* The value in the insn has been right shifted.  We need to
8858                undo this, so that we can perform the address calculation
8859                in terms of bytes.  */
8860             signed_addend <<= howto->rightshift;
8861           }
8862         relocation = value + signed_addend;
8863
8864         relocation -= (input_section->output_section->vma
8865                        + input_section->output_offset
8866                        + rel->r_offset);
8867
8868         relocation >>= howto->rightshift;
8869         signed_check = relocation;
8870
8871         if (r_type == R_ARM_THM_JUMP6)
8872           relocation = ((relocation & 0x0020) << 4) | ((relocation & 0x001f) << 3);
8873         else
8874           relocation &= howto->dst_mask;
8875         relocation |= (bfd_get_16 (input_bfd, hit_data) & (~ howto->dst_mask));
8876
8877         bfd_put_16 (input_bfd, relocation, hit_data);
8878
8879         /* Assumes two's complement.  */
8880         if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
8881           return bfd_reloc_overflow;
8882
8883         return bfd_reloc_ok;
8884       }
8885
8886     case R_ARM_ALU_PCREL7_0:
8887     case R_ARM_ALU_PCREL15_8:
8888     case R_ARM_ALU_PCREL23_15:
8889       {
8890         bfd_vma insn;
8891         bfd_vma relocation;
8892
8893         insn = bfd_get_32 (input_bfd, hit_data);
8894         if (globals->use_rel)
8895           {
8896             /* Extract the addend.  */
8897             addend = (insn & 0xff) << ((insn & 0xf00) >> 7);
8898             signed_addend = addend;
8899           }
8900         relocation = value + signed_addend;
8901
8902         relocation -= (input_section->output_section->vma
8903                        + input_section->output_offset
8904                        + rel->r_offset);
8905         insn = (insn & ~0xfff)
8906                | ((howto->bitpos << 7) & 0xf00)
8907                | ((relocation >> howto->bitpos) & 0xff);
8908         bfd_put_32 (input_bfd, value, hit_data);
8909       }
8910       return bfd_reloc_ok;
8911
8912     case R_ARM_GNU_VTINHERIT:
8913     case R_ARM_GNU_VTENTRY:
8914       return bfd_reloc_ok;
8915
8916     case R_ARM_GOTOFF32:
8917       /* Relocation is relative to the start of the
8918          global offset table.  */
8919
8920       BFD_ASSERT (sgot != NULL);
8921       if (sgot == NULL)
8922         return bfd_reloc_notsupported;
8923
8924       /* If we are addressing a Thumb function, we need to adjust the
8925          address by one, so that attempts to call the function pointer will
8926          correctly interpret it as Thumb code.  */
8927       if (branch_type == ST_BRANCH_TO_THUMB)
8928         value += 1;
8929
8930       /* Note that sgot->output_offset is not involved in this
8931          calculation.  We always want the start of .got.  If we
8932          define _GLOBAL_OFFSET_TABLE in a different way, as is
8933          permitted by the ABI, we might have to change this
8934          calculation.  */
8935       value -= sgot->output_section->vma;
8936       return _bfd_final_link_relocate (howto, input_bfd, input_section,
8937                                        contents, rel->r_offset, value,
8938                                        rel->r_addend);
8939
8940     case R_ARM_GOTPC:
8941       /* Use global offset table as symbol value.  */
8942       BFD_ASSERT (sgot != NULL);
8943
8944       if (sgot == NULL)
8945         return bfd_reloc_notsupported;
8946
8947       *unresolved_reloc_p = FALSE;
8948       value = sgot->output_section->vma;
8949       return _bfd_final_link_relocate (howto, input_bfd, input_section,
8950                                        contents, rel->r_offset, value,
8951                                        rel->r_addend);
8952
8953     case R_ARM_GOT32:
8954     case R_ARM_GOT_PREL:
8955       /* Relocation is to the entry for this symbol in the
8956          global offset table.  */
8957       if (sgot == NULL)
8958         return bfd_reloc_notsupported;
8959
8960       if (dynreloc_st_type == STT_GNU_IFUNC
8961           && plt_offset != (bfd_vma) -1
8962           && (h == NULL || SYMBOL_REFERENCES_LOCAL (info, h)))
8963         {
8964           /* We have a relocation against a locally-binding STT_GNU_IFUNC
8965              symbol, and the relocation resolves directly to the runtime
8966              target rather than to the .iplt entry.  This means that any
8967              .got entry would be the same value as the .igot.plt entry,
8968              so there's no point creating both.  */
8969           sgot = globals->root.igotplt;
8970           value = sgot->output_offset + gotplt_offset;
8971         }
8972       else if (h != NULL)
8973         {
8974           bfd_vma off;
8975
8976           off = h->got.offset;
8977           BFD_ASSERT (off != (bfd_vma) -1);
8978           if ((off & 1) != 0)
8979             {
8980               /* We have already processsed one GOT relocation against
8981                  this symbol.  */
8982               off &= ~1;
8983               if (globals->root.dynamic_sections_created
8984                   && !SYMBOL_REFERENCES_LOCAL (info, h))
8985                 *unresolved_reloc_p = FALSE;
8986             }
8987           else
8988             {
8989               Elf_Internal_Rela outrel;
8990
8991               if (!SYMBOL_REFERENCES_LOCAL (info, h))
8992                 {
8993                   /* If the symbol doesn't resolve locally in a static
8994                      object, we have an undefined reference.  If the
8995                      symbol doesn't resolve locally in a dynamic object,
8996                      it should be resolved by the dynamic linker.  */
8997                   if (globals->root.dynamic_sections_created)
8998                     {
8999                       outrel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT);
9000                       *unresolved_reloc_p = FALSE;
9001                     }
9002                   else
9003                     outrel.r_info = 0;
9004                   outrel.r_addend = 0;
9005                 }
9006               else
9007                 {
9008                   if (dynreloc_st_type == STT_GNU_IFUNC)
9009                     outrel.r_info = ELF32_R_INFO (0, R_ARM_IRELATIVE);
9010                   else if (info->shared)
9011                     outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
9012                   else
9013                     outrel.r_info = 0;
9014                   outrel.r_addend = dynreloc_value;
9015                 }
9016
9017               /* The GOT entry is initialized to zero by default.
9018                  See if we should install a different value.  */
9019               if (outrel.r_addend != 0
9020                   && (outrel.r_info == 0 || globals->use_rel))
9021                 {
9022                   bfd_put_32 (output_bfd, outrel.r_addend,
9023                               sgot->contents + off);
9024                   outrel.r_addend = 0;
9025                 }
9026
9027               if (outrel.r_info != 0)
9028                 {
9029                   outrel.r_offset = (sgot->output_section->vma
9030                                      + sgot->output_offset
9031                                      + off);
9032                   elf32_arm_add_dynreloc (output_bfd, info, srelgot, &outrel);
9033                 }
9034               h->got.offset |= 1;
9035             }
9036           value = sgot->output_offset + off;
9037         }
9038       else
9039         {
9040           bfd_vma off;
9041
9042           BFD_ASSERT (local_got_offsets != NULL &&
9043                       local_got_offsets[r_symndx] != (bfd_vma) -1);
9044
9045           off = local_got_offsets[r_symndx];
9046
9047           /* The offset must always be a multiple of 4.  We use the
9048              least significant bit to record whether we have already
9049              generated the necessary reloc.  */
9050           if ((off & 1) != 0)
9051             off &= ~1;
9052           else
9053             {
9054               if (globals->use_rel)
9055                 bfd_put_32 (output_bfd, dynreloc_value, sgot->contents + off);
9056
9057               if (info->shared || dynreloc_st_type == STT_GNU_IFUNC)
9058                 {
9059                   Elf_Internal_Rela outrel;
9060
9061                   outrel.r_addend = addend + dynreloc_value;
9062                   outrel.r_offset = (sgot->output_section->vma
9063                                      + sgot->output_offset
9064                                      + off);
9065                   if (dynreloc_st_type == STT_GNU_IFUNC)
9066                     outrel.r_info = ELF32_R_INFO (0, R_ARM_IRELATIVE);
9067                   else
9068                     outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
9069                   elf32_arm_add_dynreloc (output_bfd, info, srelgot, &outrel);
9070                 }
9071
9072               local_got_offsets[r_symndx] |= 1;
9073             }
9074
9075           value = sgot->output_offset + off;
9076         }
9077       if (r_type != R_ARM_GOT32)
9078         value += sgot->output_section->vma;
9079
9080       return _bfd_final_link_relocate (howto, input_bfd, input_section,
9081                                        contents, rel->r_offset, value,
9082                                        rel->r_addend);
9083
9084     case R_ARM_TLS_LDO32:
9085       value = value - dtpoff_base (info);
9086
9087       return _bfd_final_link_relocate (howto, input_bfd, input_section,
9088                                        contents, rel->r_offset, value,
9089                                        rel->r_addend);
9090
9091     case R_ARM_TLS_LDM32:
9092       {
9093         bfd_vma off;
9094
9095         if (sgot == NULL)
9096           abort ();
9097
9098         off = globals->tls_ldm_got.offset;
9099
9100         if ((off & 1) != 0)
9101           off &= ~1;
9102         else
9103           {
9104             /* If we don't know the module number, create a relocation
9105                for it.  */
9106             if (info->shared)
9107               {
9108                 Elf_Internal_Rela outrel;
9109
9110                 if (srelgot == NULL)
9111                   abort ();
9112
9113                 outrel.r_addend = 0;
9114                 outrel.r_offset = (sgot->output_section->vma
9115                                    + sgot->output_offset + off);
9116                 outrel.r_info = ELF32_R_INFO (0, R_ARM_TLS_DTPMOD32);
9117
9118                 if (globals->use_rel)
9119                   bfd_put_32 (output_bfd, outrel.r_addend,
9120                               sgot->contents + off);
9121
9122                 elf32_arm_add_dynreloc (output_bfd, info, srelgot, &outrel);
9123               }
9124             else
9125               bfd_put_32 (output_bfd, 1, sgot->contents + off);
9126
9127             globals->tls_ldm_got.offset |= 1;
9128           }
9129
9130         value = sgot->output_section->vma + sgot->output_offset + off
9131           - (input_section->output_section->vma + input_section->output_offset + rel->r_offset);
9132
9133         return _bfd_final_link_relocate (howto, input_bfd, input_section,
9134                                          contents, rel->r_offset, value,
9135                                          rel->r_addend);
9136       }
9137
9138     case R_ARM_TLS_CALL:
9139     case R_ARM_THM_TLS_CALL:
9140     case R_ARM_TLS_GD32:
9141     case R_ARM_TLS_IE32:
9142     case R_ARM_TLS_GOTDESC:
9143     case R_ARM_TLS_DESCSEQ:
9144     case R_ARM_THM_TLS_DESCSEQ:
9145       {
9146         bfd_vma off, offplt;
9147         int indx = 0;
9148         char tls_type;
9149
9150         BFD_ASSERT (sgot != NULL);
9151
9152         if (h != NULL)
9153           {
9154             bfd_boolean dyn;
9155             dyn = globals->root.dynamic_sections_created;
9156             if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
9157                 && (!info->shared
9158                     || !SYMBOL_REFERENCES_LOCAL (info, h)))
9159               {
9160                 *unresolved_reloc_p = FALSE;
9161                 indx = h->dynindx;
9162               }
9163             off = h->got.offset;
9164             offplt = elf32_arm_hash_entry (h)->tlsdesc_got;
9165             tls_type = ((struct elf32_arm_link_hash_entry *) h)->tls_type;
9166           }
9167         else
9168           {
9169             BFD_ASSERT (local_got_offsets != NULL);
9170             off = local_got_offsets[r_symndx];
9171             offplt = local_tlsdesc_gotents[r_symndx];
9172             tls_type = elf32_arm_local_got_tls_type (input_bfd)[r_symndx];
9173           }
9174
9175         /* Linker relaxations happens from one of the
9176            R_ARM_{GOTDESC,CALL,DESCSEQ} relocations to IE or LE.  */
9177         if (ELF32_R_TYPE(rel->r_info) != r_type)
9178           tls_type = GOT_TLS_IE;
9179
9180         BFD_ASSERT (tls_type != GOT_UNKNOWN);
9181
9182         if ((off & 1) != 0)
9183           off &= ~1;
9184         else
9185           {
9186             bfd_boolean need_relocs = FALSE;
9187             Elf_Internal_Rela outrel;
9188             int cur_off = off;
9189
9190             /* The GOT entries have not been initialized yet.  Do it
9191                now, and emit any relocations.  If both an IE GOT and a
9192                GD GOT are necessary, we emit the GD first.  */
9193
9194             if ((info->shared || indx != 0)
9195                 && (h == NULL
9196                     || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
9197                     || h->root.type != bfd_link_hash_undefweak))
9198               {
9199                 need_relocs = TRUE;
9200                 BFD_ASSERT (srelgot != NULL);
9201               }
9202
9203             if (tls_type & GOT_TLS_GDESC)
9204               {
9205                 bfd_byte *loc;
9206
9207                 /* We should have relaxed, unless this is an undefined
9208                    weak symbol.  */
9209                 BFD_ASSERT ((h && (h->root.type == bfd_link_hash_undefweak))
9210                             || info->shared);
9211                 BFD_ASSERT (globals->sgotplt_jump_table_size + offplt + 8
9212                             <= globals->root.sgotplt->size);
9213
9214                 outrel.r_addend = 0;
9215                 outrel.r_offset = (globals->root.sgotplt->output_section->vma
9216                                    + globals->root.sgotplt->output_offset
9217                                    + offplt
9218                                    + globals->sgotplt_jump_table_size);
9219
9220                 outrel.r_info = ELF32_R_INFO (indx, R_ARM_TLS_DESC);
9221                 sreloc = globals->root.srelplt;
9222                 loc = sreloc->contents;
9223                 loc += globals->next_tls_desc_index++ * RELOC_SIZE (globals);
9224                 BFD_ASSERT (loc + RELOC_SIZE (globals)
9225                            <= sreloc->contents + sreloc->size);
9226
9227                 SWAP_RELOC_OUT (globals) (output_bfd, &outrel, loc);
9228
9229                 /* For globals, the first word in the relocation gets
9230                    the relocation index and the top bit set, or zero,
9231                    if we're binding now.  For locals, it gets the
9232                    symbol's offset in the tls section.  */
9233                 bfd_put_32 (output_bfd,
9234                             !h ? value - elf_hash_table (info)->tls_sec->vma
9235                             : info->flags & DF_BIND_NOW ? 0
9236                             : 0x80000000 | ELF32_R_SYM (outrel.r_info),
9237                             globals->root.sgotplt->contents + offplt +
9238                             globals->sgotplt_jump_table_size);
9239
9240                 /* Second word in the relocation is always zero.  */
9241                 bfd_put_32 (output_bfd, 0,
9242                             globals->root.sgotplt->contents + offplt +
9243                             globals->sgotplt_jump_table_size + 4);
9244               }
9245             if (tls_type & GOT_TLS_GD)
9246               {
9247                 if (need_relocs)
9248                   {
9249                     outrel.r_addend = 0;
9250                     outrel.r_offset = (sgot->output_section->vma
9251                                        + sgot->output_offset
9252                                        + cur_off);
9253                     outrel.r_info = ELF32_R_INFO (indx, R_ARM_TLS_DTPMOD32);
9254
9255                     if (globals->use_rel)
9256                       bfd_put_32 (output_bfd, outrel.r_addend,
9257                                   sgot->contents + cur_off);
9258
9259                     elf32_arm_add_dynreloc (output_bfd, info, srelgot, &outrel);
9260
9261                     if (indx == 0)
9262                       bfd_put_32 (output_bfd, value - dtpoff_base (info),
9263                                   sgot->contents + cur_off + 4);
9264                     else
9265                       {
9266                         outrel.r_addend = 0;
9267                         outrel.r_info = ELF32_R_INFO (indx,
9268                                                       R_ARM_TLS_DTPOFF32);
9269                         outrel.r_offset += 4;
9270
9271                         if (globals->use_rel)
9272                           bfd_put_32 (output_bfd, outrel.r_addend,
9273                                       sgot->contents + cur_off + 4);
9274
9275                         elf32_arm_add_dynreloc (output_bfd, info,
9276                                                 srelgot, &outrel);
9277                       }
9278                   }
9279                 else
9280                   {
9281                     /* If we are not emitting relocations for a
9282                        general dynamic reference, then we must be in a
9283                        static link or an executable link with the
9284                        symbol binding locally.  Mark it as belonging
9285                        to module 1, the executable.  */
9286                     bfd_put_32 (output_bfd, 1,
9287                                 sgot->contents + cur_off);
9288                     bfd_put_32 (output_bfd, value - dtpoff_base (info),
9289                                 sgot->contents + cur_off + 4);
9290                   }
9291
9292                 cur_off += 8;
9293               }
9294
9295             if (tls_type & GOT_TLS_IE)
9296               {
9297                 if (need_relocs)
9298                   {
9299                     if (indx == 0)
9300                       outrel.r_addend = value - dtpoff_base (info);
9301                     else
9302                       outrel.r_addend = 0;
9303                     outrel.r_offset = (sgot->output_section->vma
9304                                        + sgot->output_offset
9305                                        + cur_off);
9306                     outrel.r_info = ELF32_R_INFO (indx, R_ARM_TLS_TPOFF32);
9307
9308                     if (globals->use_rel)
9309                       bfd_put_32 (output_bfd, outrel.r_addend,
9310                                   sgot->contents + cur_off);
9311
9312                     elf32_arm_add_dynreloc (output_bfd, info, srelgot, &outrel);
9313                   }
9314                 else
9315                   bfd_put_32 (output_bfd, tpoff (info, value),
9316                               sgot->contents + cur_off);
9317                 cur_off += 4;
9318               }
9319
9320             if (h != NULL)
9321               h->got.offset |= 1;
9322             else
9323               local_got_offsets[r_symndx] |= 1;
9324           }
9325
9326         if ((tls_type & GOT_TLS_GD) && r_type != R_ARM_TLS_GD32)
9327           off += 8;
9328         else if (tls_type & GOT_TLS_GDESC)
9329           off = offplt;
9330
9331         if (ELF32_R_TYPE(rel->r_info) == R_ARM_TLS_CALL
9332             || ELF32_R_TYPE(rel->r_info) == R_ARM_THM_TLS_CALL)
9333           {
9334             bfd_signed_vma offset;
9335             /* TLS stubs are arm mode.  The original symbol is a
9336                data object, so branch_type is bogus.  */
9337             branch_type = ST_BRANCH_TO_ARM;
9338             enum elf32_arm_stub_type stub_type
9339               = arm_type_of_stub (info, input_section, rel,
9340                                   st_type, &branch_type,
9341                                   (struct elf32_arm_link_hash_entry *)h,
9342                                   globals->tls_trampoline, globals->root.splt,
9343                                   input_bfd, sym_name);
9344
9345             if (stub_type != arm_stub_none)
9346               {
9347                 struct elf32_arm_stub_hash_entry *stub_entry
9348                   = elf32_arm_get_stub_entry
9349                   (input_section, globals->root.splt, 0, rel,
9350                    globals, stub_type);
9351                 offset = (stub_entry->stub_offset
9352                           + stub_entry->stub_sec->output_offset
9353                           + stub_entry->stub_sec->output_section->vma);
9354               }
9355             else
9356               offset = (globals->root.splt->output_section->vma
9357                         + globals->root.splt->output_offset
9358                         + globals->tls_trampoline);
9359
9360             if (ELF32_R_TYPE(rel->r_info) == R_ARM_TLS_CALL)
9361               {
9362                 unsigned long inst;
9363
9364                 offset -= (input_section->output_section->vma +
9365                            input_section->output_offset + rel->r_offset + 8);
9366
9367                 inst = offset >> 2;
9368                 inst &= 0x00ffffff;
9369                 value = inst | (globals->use_blx ? 0xfa000000 : 0xeb000000);
9370               }
9371             else
9372               {
9373                 /* Thumb blx encodes the offset in a complicated
9374                    fashion.  */
9375                 unsigned upper_insn, lower_insn;
9376                 unsigned neg;
9377
9378                 offset -= (input_section->output_section->vma +
9379                            input_section->output_offset
9380                            + rel->r_offset + 4);
9381
9382                 if (stub_type != arm_stub_none
9383                     && arm_stub_is_thumb (stub_type))
9384                   {
9385                     lower_insn = 0xd000;
9386                   }
9387                 else
9388                   {
9389                     lower_insn = 0xc000;
9390                     /* Round up the offset to a word boundary */
9391                     offset = (offset + 2) & ~2;
9392                   }
9393
9394                 neg = offset < 0;
9395                 upper_insn = (0xf000
9396                               | ((offset >> 12) & 0x3ff)
9397                               | (neg << 10));
9398                 lower_insn |= (((!((offset >> 23) & 1)) ^ neg) << 13)
9399                               | (((!((offset >> 22) & 1)) ^ neg) << 11)
9400                               | ((offset >> 1) & 0x7ff);
9401                 bfd_put_16 (input_bfd, upper_insn, hit_data);
9402                 bfd_put_16 (input_bfd, lower_insn, hit_data + 2);
9403                 return bfd_reloc_ok;
9404               }
9405           }
9406         /* These relocations needs special care, as besides the fact
9407            they point somewhere in .gotplt, the addend must be
9408            adjusted accordingly depending on the type of instruction
9409            we refer to */
9410         else if ((r_type == R_ARM_TLS_GOTDESC) && (tls_type & GOT_TLS_GDESC))
9411           {
9412             unsigned long data, insn;
9413             unsigned thumb;
9414
9415             data = bfd_get_32 (input_bfd, hit_data);
9416             thumb = data & 1;
9417             data &= ~1u;
9418
9419             if (thumb)
9420               {
9421                 insn = bfd_get_16 (input_bfd, contents + rel->r_offset - data);
9422                 if ((insn & 0xf000) == 0xf000 || (insn & 0xf800) == 0xe800)
9423                   insn = (insn << 16)
9424                     | bfd_get_16 (input_bfd,
9425                                   contents + rel->r_offset - data + 2);
9426                 if ((insn & 0xf800c000) == 0xf000c000)
9427                   /* bl/blx */
9428                   value = -6;
9429                 else if ((insn & 0xffffff00) == 0x4400)
9430                   /* add */
9431                   value = -5;
9432                 else
9433                   {
9434                     (*_bfd_error_handler)
9435                       (_("%B(%A+0x%lx):unexpected Thumb instruction '0x%x' referenced by TLS_GOTDESC"),
9436                        input_bfd, input_section,
9437                        (unsigned long)rel->r_offset, insn);
9438                     return bfd_reloc_notsupported;
9439                   }
9440               }
9441             else
9442               {
9443                 insn = bfd_get_32 (input_bfd, contents + rel->r_offset - data);
9444
9445                 switch (insn >> 24)
9446                   {
9447                   case 0xeb:  /* bl */
9448                   case 0xfa:  /* blx */
9449                     value = -4;
9450                     break;
9451
9452                   case 0xe0:    /* add */
9453                     value = -8;
9454                     break;
9455
9456                   default:
9457                     (*_bfd_error_handler)
9458                       (_("%B(%A+0x%lx):unexpected ARM instruction '0x%x' referenced by TLS_GOTDESC"),
9459                        input_bfd, input_section,
9460                        (unsigned long)rel->r_offset, insn);
9461                     return bfd_reloc_notsupported;
9462                   }
9463               }
9464
9465             value += ((globals->root.sgotplt->output_section->vma
9466                        + globals->root.sgotplt->output_offset + off)
9467                       - (input_section->output_section->vma
9468                          + input_section->output_offset
9469                          + rel->r_offset)
9470                       + globals->sgotplt_jump_table_size);
9471           }
9472         else
9473           value = ((globals->root.sgot->output_section->vma
9474                     + globals->root.sgot->output_offset + off)
9475                    - (input_section->output_section->vma
9476                       + input_section->output_offset + rel->r_offset));
9477
9478         return _bfd_final_link_relocate (howto, input_bfd, input_section,
9479                                          contents, rel->r_offset, value,
9480                                          rel->r_addend);
9481       }
9482
9483     case R_ARM_TLS_LE32:
9484       if (info->shared && !info->pie)
9485         {
9486           (*_bfd_error_handler)
9487             (_("%B(%A+0x%lx): R_ARM_TLS_LE32 relocation not permitted in shared object"),
9488              input_bfd, input_section,
9489              (long) rel->r_offset, howto->name);
9490           return (bfd_reloc_status_type) FALSE;
9491         }
9492       else
9493         value = tpoff (info, value);
9494
9495       return _bfd_final_link_relocate (howto, input_bfd, input_section,
9496                                        contents, rel->r_offset, value,
9497                                        rel->r_addend);
9498
9499     case R_ARM_V4BX:
9500       if (globals->fix_v4bx)
9501         {
9502           bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
9503
9504           /* Ensure that we have a BX instruction.  */
9505           BFD_ASSERT ((insn & 0x0ffffff0) == 0x012fff10);
9506
9507           if (globals->fix_v4bx == 2 && (insn & 0xf) != 0xf)
9508             {
9509               /* Branch to veneer.  */
9510               bfd_vma glue_addr;
9511               glue_addr = elf32_arm_bx_glue (info, insn & 0xf);
9512               glue_addr -= input_section->output_section->vma
9513                            + input_section->output_offset
9514                            + rel->r_offset + 8;
9515               insn = (insn & 0xf0000000) | 0x0a000000
9516                      | ((glue_addr >> 2) & 0x00ffffff);
9517             }
9518           else
9519             {
9520               /* Preserve Rm (lowest four bits) and the condition code
9521                  (highest four bits). Other bits encode MOV PC,Rm.  */
9522               insn = (insn & 0xf000000f) | 0x01a0f000;
9523             }
9524
9525           bfd_put_32 (input_bfd, insn, hit_data);
9526         }
9527       return bfd_reloc_ok;
9528
9529     case R_ARM_MOVW_ABS_NC:
9530     case R_ARM_MOVT_ABS:
9531     case R_ARM_MOVW_PREL_NC:
9532     case R_ARM_MOVT_PREL:
9533     /* Until we properly support segment-base-relative addressing then
9534        we assume the segment base to be zero, as for the group relocations.
9535        Thus R_ARM_MOVW_BREL_NC has the same semantics as R_ARM_MOVW_ABS_NC
9536        and R_ARM_MOVT_BREL has the same semantics as R_ARM_MOVT_ABS.  */
9537     case R_ARM_MOVW_BREL_NC:
9538     case R_ARM_MOVW_BREL:
9539     case R_ARM_MOVT_BREL:
9540       {
9541         bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
9542
9543         if (globals->use_rel)
9544           {
9545             addend = ((insn >> 4) & 0xf000) | (insn & 0xfff);
9546             signed_addend = (addend ^ 0x8000) - 0x8000;
9547           }
9548
9549         value += signed_addend;
9550
9551         if (r_type == R_ARM_MOVW_PREL_NC || r_type == R_ARM_MOVT_PREL)
9552           value -= (input_section->output_section->vma
9553                     + input_section->output_offset + rel->r_offset);
9554
9555         if (r_type == R_ARM_MOVW_BREL && value >= 0x10000)
9556           return bfd_reloc_overflow;
9557
9558         if (branch_type == ST_BRANCH_TO_THUMB)
9559           value |= 1;
9560
9561         if (r_type == R_ARM_MOVT_ABS || r_type == R_ARM_MOVT_PREL
9562             || r_type == R_ARM_MOVT_BREL)
9563           value >>= 16;
9564
9565         insn &= 0xfff0f000;
9566         insn |= value & 0xfff;
9567         insn |= (value & 0xf000) << 4;
9568         bfd_put_32 (input_bfd, insn, hit_data);
9569       }
9570       return bfd_reloc_ok;
9571
9572     case R_ARM_THM_MOVW_ABS_NC:
9573     case R_ARM_THM_MOVT_ABS:
9574     case R_ARM_THM_MOVW_PREL_NC:
9575     case R_ARM_THM_MOVT_PREL:
9576     /* Until we properly support segment-base-relative addressing then
9577        we assume the segment base to be zero, as for the above relocations.
9578        Thus R_ARM_THM_MOVW_BREL_NC has the same semantics as
9579        R_ARM_THM_MOVW_ABS_NC and R_ARM_THM_MOVT_BREL has the same semantics
9580        as R_ARM_THM_MOVT_ABS.  */
9581     case R_ARM_THM_MOVW_BREL_NC:
9582     case R_ARM_THM_MOVW_BREL:
9583     case R_ARM_THM_MOVT_BREL:
9584       {
9585         bfd_vma insn;
9586
9587         insn = bfd_get_16 (input_bfd, hit_data) << 16;
9588         insn |= bfd_get_16 (input_bfd, hit_data + 2);
9589
9590         if (globals->use_rel)
9591           {
9592             addend = ((insn >> 4)  & 0xf000)
9593                    | ((insn >> 15) & 0x0800)
9594                    | ((insn >> 4)  & 0x0700)
9595                    | (insn         & 0x00ff);
9596             signed_addend = (addend ^ 0x8000) - 0x8000;
9597           }
9598
9599         value += signed_addend;
9600
9601         if (r_type == R_ARM_THM_MOVW_PREL_NC || r_type == R_ARM_THM_MOVT_PREL)
9602           value -= (input_section->output_section->vma
9603                     + input_section->output_offset + rel->r_offset);
9604
9605         if (r_type == R_ARM_THM_MOVW_BREL && value >= 0x10000)
9606           return bfd_reloc_overflow;
9607
9608         if (branch_type == ST_BRANCH_TO_THUMB)
9609           value |= 1;
9610
9611         if (r_type == R_ARM_THM_MOVT_ABS || r_type == R_ARM_THM_MOVT_PREL
9612             || r_type == R_ARM_THM_MOVT_BREL)
9613           value >>= 16;
9614
9615         insn &= 0xfbf08f00;
9616         insn |= (value & 0xf000) << 4;
9617         insn |= (value & 0x0800) << 15;
9618         insn |= (value & 0x0700) << 4;
9619         insn |= (value & 0x00ff);
9620
9621         bfd_put_16 (input_bfd, insn >> 16, hit_data);
9622         bfd_put_16 (input_bfd, insn & 0xffff, hit_data + 2);
9623       }
9624       return bfd_reloc_ok;
9625
9626     case R_ARM_ALU_PC_G0_NC:
9627     case R_ARM_ALU_PC_G1_NC:
9628     case R_ARM_ALU_PC_G0:
9629     case R_ARM_ALU_PC_G1:
9630     case R_ARM_ALU_PC_G2:
9631     case R_ARM_ALU_SB_G0_NC:
9632     case R_ARM_ALU_SB_G1_NC:
9633     case R_ARM_ALU_SB_G0:
9634     case R_ARM_ALU_SB_G1:
9635     case R_ARM_ALU_SB_G2:
9636       {
9637         bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
9638         bfd_vma pc = input_section->output_section->vma
9639                      + input_section->output_offset + rel->r_offset;
9640         /* sb should be the origin of the *segment* containing the symbol.
9641            It is not clear how to obtain this OS-dependent value, so we
9642            make an arbitrary choice of zero.  */
9643         bfd_vma sb = 0;
9644         bfd_vma residual;
9645         bfd_vma g_n;
9646         bfd_signed_vma signed_value;
9647         int group = 0;
9648
9649         /* Determine which group of bits to select.  */
9650         switch (r_type)
9651           {
9652           case R_ARM_ALU_PC_G0_NC:
9653           case R_ARM_ALU_PC_G0:
9654           case R_ARM_ALU_SB_G0_NC:
9655           case R_ARM_ALU_SB_G0:
9656             group = 0;
9657             break;
9658
9659           case R_ARM_ALU_PC_G1_NC:
9660           case R_ARM_ALU_PC_G1:
9661           case R_ARM_ALU_SB_G1_NC:
9662           case R_ARM_ALU_SB_G1:
9663             group = 1;
9664             break;
9665
9666           case R_ARM_ALU_PC_G2:
9667           case R_ARM_ALU_SB_G2:
9668             group = 2;
9669             break;
9670
9671           default:
9672             abort ();
9673           }
9674
9675         /* If REL, extract the addend from the insn.  If RELA, it will
9676            have already been fetched for us.  */
9677         if (globals->use_rel)
9678           {
9679             int negative;
9680             bfd_vma constant = insn & 0xff;
9681             bfd_vma rotation = (insn & 0xf00) >> 8;
9682
9683             if (rotation == 0)
9684               signed_addend = constant;
9685             else
9686               {
9687                 /* Compensate for the fact that in the instruction, the
9688                    rotation is stored in multiples of 2 bits.  */
9689                 rotation *= 2;
9690
9691                 /* Rotate "constant" right by "rotation" bits.  */
9692                 signed_addend = (constant >> rotation) |
9693                                 (constant << (8 * sizeof (bfd_vma) - rotation));
9694               }
9695
9696             /* Determine if the instruction is an ADD or a SUB.
9697                (For REL, this determines the sign of the addend.)  */
9698             negative = identify_add_or_sub (insn);
9699             if (negative == 0)
9700               {
9701                 (*_bfd_error_handler)
9702                   (_("%B(%A+0x%lx): Only ADD or SUB instructions are allowed for ALU group relocations"),
9703                   input_bfd, input_section,
9704                   (long) rel->r_offset, howto->name);
9705                 return bfd_reloc_overflow;
9706               }
9707
9708             signed_addend *= negative;
9709           }
9710
9711         /* Compute the value (X) to go in the place.  */
9712         if (r_type == R_ARM_ALU_PC_G0_NC
9713             || r_type == R_ARM_ALU_PC_G1_NC
9714             || r_type == R_ARM_ALU_PC_G0
9715             || r_type == R_ARM_ALU_PC_G1
9716             || r_type == R_ARM_ALU_PC_G2)
9717           /* PC relative.  */
9718           signed_value = value - pc + signed_addend;
9719         else
9720           /* Section base relative.  */
9721           signed_value = value - sb + signed_addend;
9722
9723         /* If the target symbol is a Thumb function, then set the
9724            Thumb bit in the address.  */
9725         if (branch_type == ST_BRANCH_TO_THUMB)
9726           signed_value |= 1;
9727
9728         /* Calculate the value of the relevant G_n, in encoded
9729            constant-with-rotation format.  */
9730         g_n = calculate_group_reloc_mask (abs (signed_value), group,
9731                                           &residual);
9732
9733         /* Check for overflow if required.  */
9734         if ((r_type == R_ARM_ALU_PC_G0
9735              || r_type == R_ARM_ALU_PC_G1
9736              || r_type == R_ARM_ALU_PC_G2
9737              || r_type == R_ARM_ALU_SB_G0
9738              || r_type == R_ARM_ALU_SB_G1
9739              || r_type == R_ARM_ALU_SB_G2) && residual != 0)
9740           {
9741             (*_bfd_error_handler)
9742               (_("%B(%A+0x%lx): Overflow whilst splitting 0x%lx for group relocation %s"),
9743               input_bfd, input_section,
9744               (long) rel->r_offset, abs (signed_value), howto->name);
9745             return bfd_reloc_overflow;
9746           }
9747
9748         /* Mask out the value and the ADD/SUB part of the opcode; take care
9749            not to destroy the S bit.  */
9750         insn &= 0xff1ff000;
9751
9752         /* Set the opcode according to whether the value to go in the
9753            place is negative.  */
9754         if (signed_value < 0)
9755           insn |= 1 << 22;
9756         else
9757           insn |= 1 << 23;
9758
9759         /* Encode the offset.  */
9760         insn |= g_n;
9761
9762         bfd_put_32 (input_bfd, insn, hit_data);
9763       }
9764       return bfd_reloc_ok;
9765
9766     case R_ARM_LDR_PC_G0:
9767     case R_ARM_LDR_PC_G1:
9768     case R_ARM_LDR_PC_G2:
9769     case R_ARM_LDR_SB_G0:
9770     case R_ARM_LDR_SB_G1:
9771     case R_ARM_LDR_SB_G2:
9772       {
9773         bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
9774         bfd_vma pc = input_section->output_section->vma
9775                      + input_section->output_offset + rel->r_offset;
9776         bfd_vma sb = 0; /* See note above.  */
9777         bfd_vma residual;
9778         bfd_signed_vma signed_value;
9779         int group = 0;
9780
9781         /* Determine which groups of bits to calculate.  */
9782         switch (r_type)
9783           {
9784           case R_ARM_LDR_PC_G0:
9785           case R_ARM_LDR_SB_G0:
9786             group = 0;
9787             break;
9788
9789           case R_ARM_LDR_PC_G1:
9790           case R_ARM_LDR_SB_G1:
9791             group = 1;
9792             break;
9793
9794           case R_ARM_LDR_PC_G2:
9795           case R_ARM_LDR_SB_G2:
9796             group = 2;
9797             break;
9798
9799           default:
9800             abort ();
9801           }
9802
9803         /* If REL, extract the addend from the insn.  If RELA, it will
9804            have already been fetched for us.  */
9805         if (globals->use_rel)
9806           {
9807             int negative = (insn & (1 << 23)) ? 1 : -1;
9808             signed_addend = negative * (insn & 0xfff);
9809           }
9810
9811         /* Compute the value (X) to go in the place.  */
9812         if (r_type == R_ARM_LDR_PC_G0
9813             || r_type == R_ARM_LDR_PC_G1
9814             || r_type == R_ARM_LDR_PC_G2)
9815           /* PC relative.  */
9816           signed_value = value - pc + signed_addend;
9817         else
9818           /* Section base relative.  */
9819           signed_value = value - sb + signed_addend;
9820
9821         /* Calculate the value of the relevant G_{n-1} to obtain
9822            the residual at that stage.  */
9823         calculate_group_reloc_mask (abs (signed_value), group - 1, &residual);
9824
9825         /* Check for overflow.  */
9826         if (residual >= 0x1000)
9827           {
9828             (*_bfd_error_handler)
9829               (_("%B(%A+0x%lx): Overflow whilst splitting 0x%lx for group relocation %s"),
9830               input_bfd, input_section,
9831               (long) rel->r_offset, abs (signed_value), howto->name);
9832             return bfd_reloc_overflow;
9833           }
9834
9835         /* Mask out the value and U bit.  */
9836         insn &= 0xff7ff000;
9837
9838         /* Set the U bit if the value to go in the place is non-negative.  */
9839         if (signed_value >= 0)
9840           insn |= 1 << 23;
9841
9842         /* Encode the offset.  */
9843         insn |= residual;
9844
9845         bfd_put_32 (input_bfd, insn, hit_data);
9846       }
9847       return bfd_reloc_ok;
9848
9849     case R_ARM_LDRS_PC_G0:
9850     case R_ARM_LDRS_PC_G1:
9851     case R_ARM_LDRS_PC_G2:
9852     case R_ARM_LDRS_SB_G0:
9853     case R_ARM_LDRS_SB_G1:
9854     case R_ARM_LDRS_SB_G2:
9855       {
9856         bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
9857         bfd_vma pc = input_section->output_section->vma
9858                      + input_section->output_offset + rel->r_offset;
9859         bfd_vma sb = 0; /* See note above.  */
9860         bfd_vma residual;
9861         bfd_signed_vma signed_value;
9862         int group = 0;
9863
9864         /* Determine which groups of bits to calculate.  */
9865         switch (r_type)
9866           {
9867           case R_ARM_LDRS_PC_G0:
9868           case R_ARM_LDRS_SB_G0:
9869             group = 0;
9870             break;
9871
9872           case R_ARM_LDRS_PC_G1:
9873           case R_ARM_LDRS_SB_G1:
9874             group = 1;
9875             break;
9876
9877           case R_ARM_LDRS_PC_G2:
9878           case R_ARM_LDRS_SB_G2:
9879             group = 2;
9880             break;
9881
9882           default:
9883             abort ();
9884           }
9885
9886         /* If REL, extract the addend from the insn.  If RELA, it will
9887            have already been fetched for us.  */
9888         if (globals->use_rel)
9889           {
9890             int negative = (insn & (1 << 23)) ? 1 : -1;
9891             signed_addend = negative * (((insn & 0xf00) >> 4) + (insn & 0xf));
9892           }
9893
9894         /* Compute the value (X) to go in the place.  */
9895         if (r_type == R_ARM_LDRS_PC_G0
9896             || r_type == R_ARM_LDRS_PC_G1
9897             || r_type == R_ARM_LDRS_PC_G2)
9898           /* PC relative.  */
9899           signed_value = value - pc + signed_addend;
9900         else
9901           /* Section base relative.  */
9902           signed_value = value - sb + signed_addend;
9903
9904         /* Calculate the value of the relevant G_{n-1} to obtain
9905            the residual at that stage.  */
9906         calculate_group_reloc_mask (abs (signed_value), group - 1, &residual);
9907
9908         /* Check for overflow.  */
9909         if (residual >= 0x100)
9910           {
9911             (*_bfd_error_handler)
9912               (_("%B(%A+0x%lx): Overflow whilst splitting 0x%lx for group relocation %s"),
9913               input_bfd, input_section,
9914               (long) rel->r_offset, abs (signed_value), howto->name);
9915             return bfd_reloc_overflow;
9916           }
9917
9918         /* Mask out the value and U bit.  */
9919         insn &= 0xff7ff0f0;
9920
9921         /* Set the U bit if the value to go in the place is non-negative.  */
9922         if (signed_value >= 0)
9923           insn |= 1 << 23;
9924
9925         /* Encode the offset.  */
9926         insn |= ((residual & 0xf0) << 4) | (residual & 0xf);
9927
9928         bfd_put_32 (input_bfd, insn, hit_data);
9929       }
9930       return bfd_reloc_ok;
9931
9932     case R_ARM_LDC_PC_G0:
9933     case R_ARM_LDC_PC_G1:
9934     case R_ARM_LDC_PC_G2:
9935     case R_ARM_LDC_SB_G0:
9936     case R_ARM_LDC_SB_G1:
9937     case R_ARM_LDC_SB_G2:
9938       {
9939         bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
9940         bfd_vma pc = input_section->output_section->vma
9941                      + input_section->output_offset + rel->r_offset;
9942         bfd_vma sb = 0; /* See note above.  */
9943         bfd_vma residual;
9944         bfd_signed_vma signed_value;
9945         int group = 0;
9946
9947         /* Determine which groups of bits to calculate.  */
9948         switch (r_type)
9949           {
9950           case R_ARM_LDC_PC_G0:
9951           case R_ARM_LDC_SB_G0:
9952             group = 0;
9953             break;
9954
9955           case R_ARM_LDC_PC_G1:
9956           case R_ARM_LDC_SB_G1:
9957             group = 1;
9958             break;
9959
9960           case R_ARM_LDC_PC_G2:
9961           case R_ARM_LDC_SB_G2:
9962             group = 2;
9963             break;
9964
9965           default:
9966             abort ();
9967           }
9968
9969         /* If REL, extract the addend from the insn.  If RELA, it will
9970            have already been fetched for us.  */
9971         if (globals->use_rel)
9972           {
9973             int negative = (insn & (1 << 23)) ? 1 : -1;
9974             signed_addend = negative * ((insn & 0xff) << 2);
9975           }
9976
9977         /* Compute the value (X) to go in the place.  */
9978         if (r_type == R_ARM_LDC_PC_G0
9979             || r_type == R_ARM_LDC_PC_G1
9980             || r_type == R_ARM_LDC_PC_G2)
9981           /* PC relative.  */
9982           signed_value = value - pc + signed_addend;
9983         else
9984           /* Section base relative.  */
9985           signed_value = value - sb + signed_addend;
9986
9987         /* Calculate the value of the relevant G_{n-1} to obtain
9988            the residual at that stage.  */
9989         calculate_group_reloc_mask (abs (signed_value), group - 1, &residual);
9990
9991         /* Check for overflow.  (The absolute value to go in the place must be
9992            divisible by four and, after having been divided by four, must
9993            fit in eight bits.)  */
9994         if ((residual & 0x3) != 0 || residual >= 0x400)
9995           {
9996             (*_bfd_error_handler)
9997               (_("%B(%A+0x%lx): Overflow whilst splitting 0x%lx for group relocation %s"),
9998               input_bfd, input_section,
9999               (long) rel->r_offset, abs (signed_value), howto->name);
10000             return bfd_reloc_overflow;
10001           }
10002
10003         /* Mask out the value and U bit.  */
10004         insn &= 0xff7fff00;
10005
10006         /* Set the U bit if the value to go in the place is non-negative.  */
10007         if (signed_value >= 0)
10008           insn |= 1 << 23;
10009
10010         /* Encode the offset.  */
10011         insn |= residual >> 2;
10012
10013         bfd_put_32 (input_bfd, insn, hit_data);
10014       }
10015       return bfd_reloc_ok;
10016
10017     default:
10018       return bfd_reloc_notsupported;
10019     }
10020 }
10021
10022 /* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS.  */
10023 static void
10024 arm_add_to_rel (bfd *              abfd,
10025                 bfd_byte *         address,
10026                 reloc_howto_type * howto,
10027                 bfd_signed_vma     increment)
10028 {
10029   bfd_signed_vma addend;
10030
10031   if (howto->type == R_ARM_THM_CALL
10032       || howto->type == R_ARM_THM_JUMP24)
10033     {
10034       int upper_insn, lower_insn;
10035       int upper, lower;
10036
10037       upper_insn = bfd_get_16 (abfd, address);
10038       lower_insn = bfd_get_16 (abfd, address + 2);
10039       upper = upper_insn & 0x7ff;
10040       lower = lower_insn & 0x7ff;
10041
10042       addend = (upper << 12) | (lower << 1);
10043       addend += increment;
10044       addend >>= 1;
10045
10046       upper_insn = (upper_insn & 0xf800) | ((addend >> 11) & 0x7ff);
10047       lower_insn = (lower_insn & 0xf800) | (addend & 0x7ff);
10048
10049       bfd_put_16 (abfd, (bfd_vma) upper_insn, address);
10050       bfd_put_16 (abfd, (bfd_vma) lower_insn, address + 2);
10051     }
10052   else
10053     {
10054       bfd_vma        contents;
10055
10056       contents = bfd_get_32 (abfd, address);
10057
10058       /* Get the (signed) value from the instruction.  */
10059       addend = contents & howto->src_mask;
10060       if (addend & ((howto->src_mask + 1) >> 1))
10061         {
10062           bfd_signed_vma mask;
10063
10064           mask = -1;
10065           mask &= ~ howto->src_mask;
10066           addend |= mask;
10067         }
10068
10069       /* Add in the increment, (which is a byte value).  */
10070       switch (howto->type)
10071         {
10072         default:
10073           addend += increment;
10074           break;
10075
10076         case R_ARM_PC24:
10077         case R_ARM_PLT32:
10078         case R_ARM_CALL:
10079         case R_ARM_JUMP24:
10080           addend <<= howto->size;
10081           addend += increment;
10082
10083           /* Should we check for overflow here ?  */
10084
10085           /* Drop any undesired bits.  */
10086           addend >>= howto->rightshift;
10087           break;
10088         }
10089
10090       contents = (contents & ~ howto->dst_mask) | (addend & howto->dst_mask);
10091
10092       bfd_put_32 (abfd, contents, address);
10093     }
10094 }
10095
10096 #define IS_ARM_TLS_RELOC(R_TYPE)        \
10097   ((R_TYPE) == R_ARM_TLS_GD32           \
10098    || (R_TYPE) == R_ARM_TLS_LDO32       \
10099    || (R_TYPE) == R_ARM_TLS_LDM32       \
10100    || (R_TYPE) == R_ARM_TLS_DTPOFF32    \
10101    || (R_TYPE) == R_ARM_TLS_DTPMOD32    \
10102    || (R_TYPE) == R_ARM_TLS_TPOFF32     \
10103    || (R_TYPE) == R_ARM_TLS_LE32        \
10104    || (R_TYPE) == R_ARM_TLS_IE32        \
10105    || IS_ARM_TLS_GNU_RELOC (R_TYPE))
10106
10107 /* Specific set of relocations for the gnu tls dialect.  */
10108 #define IS_ARM_TLS_GNU_RELOC(R_TYPE)    \
10109   ((R_TYPE) == R_ARM_TLS_GOTDESC        \
10110    || (R_TYPE) == R_ARM_TLS_CALL        \
10111    || (R_TYPE) == R_ARM_THM_TLS_CALL    \
10112    || (R_TYPE) == R_ARM_TLS_DESCSEQ     \
10113    || (R_TYPE) == R_ARM_THM_TLS_DESCSEQ)
10114
10115 /* Relocate an ARM ELF section.  */
10116
10117 static bfd_boolean
10118 elf32_arm_relocate_section (bfd *                  output_bfd,
10119                             struct bfd_link_info * info,
10120                             bfd *                  input_bfd,
10121                             asection *             input_section,
10122                             bfd_byte *             contents,
10123                             Elf_Internal_Rela *    relocs,
10124                             Elf_Internal_Sym *     local_syms,
10125                             asection **            local_sections)
10126 {
10127   Elf_Internal_Shdr *symtab_hdr;
10128   struct elf_link_hash_entry **sym_hashes;
10129   Elf_Internal_Rela *rel;
10130   Elf_Internal_Rela *relend;
10131   const char *name;
10132   struct elf32_arm_link_hash_table * globals;
10133
10134   globals = elf32_arm_hash_table (info);
10135   if (globals == NULL)
10136     return FALSE;
10137
10138   symtab_hdr = & elf_symtab_hdr (input_bfd);
10139   sym_hashes = elf_sym_hashes (input_bfd);
10140
10141   rel = relocs;
10142   relend = relocs + input_section->reloc_count;
10143   for (; rel < relend; rel++)
10144     {
10145       int                          r_type;
10146       reloc_howto_type *           howto;
10147       unsigned long                r_symndx;
10148       Elf_Internal_Sym *           sym;
10149       asection *                   sec;
10150       struct elf_link_hash_entry * h;
10151       bfd_vma                      relocation;
10152       bfd_reloc_status_type        r;
10153       arelent                      bfd_reloc;
10154       char                         sym_type;
10155       bfd_boolean                  unresolved_reloc = FALSE;
10156       char *error_message = NULL;
10157
10158       r_symndx = ELF32_R_SYM (rel->r_info);
10159       r_type   = ELF32_R_TYPE (rel->r_info);
10160       r_type   = arm_real_reloc_type (globals, r_type);
10161
10162       if (   r_type == R_ARM_GNU_VTENTRY
10163           || r_type == R_ARM_GNU_VTINHERIT)
10164         continue;
10165
10166       bfd_reloc.howto = elf32_arm_howto_from_type (r_type);
10167       howto = bfd_reloc.howto;
10168
10169       h = NULL;
10170       sym = NULL;
10171       sec = NULL;
10172
10173       if (r_symndx < symtab_hdr->sh_info)
10174         {
10175           sym = local_syms + r_symndx;
10176           sym_type = ELF32_ST_TYPE (sym->st_info);
10177           sec = local_sections[r_symndx];
10178
10179           /* An object file might have a reference to a local
10180              undefined symbol.  This is a daft object file, but we
10181              should at least do something about it.  V4BX & NONE
10182              relocations do not use the symbol and are explicitly
10183              allowed to use the undefined symbol, so allow those.
10184              Likewise for relocations against STN_UNDEF.  */
10185           if (r_type != R_ARM_V4BX
10186               && r_type != R_ARM_NONE
10187               && r_symndx != STN_UNDEF
10188               && bfd_is_und_section (sec)
10189               && ELF_ST_BIND (sym->st_info) != STB_WEAK)
10190             {
10191               if (!info->callbacks->undefined_symbol
10192                   (info, bfd_elf_string_from_elf_section
10193                    (input_bfd, symtab_hdr->sh_link, sym->st_name),
10194                    input_bfd, input_section,
10195                    rel->r_offset, TRUE))
10196                 return FALSE;
10197             }
10198
10199           if (globals->use_rel)
10200             {
10201               relocation = (sec->output_section->vma
10202                             + sec->output_offset
10203                             + sym->st_value);
10204               if (!info->relocatable
10205                   && (sec->flags & SEC_MERGE)
10206                   && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
10207                 {
10208                   asection *msec;
10209                   bfd_vma addend, value;
10210
10211                   switch (r_type)
10212                     {
10213                     case R_ARM_MOVW_ABS_NC:
10214                     case R_ARM_MOVT_ABS:
10215                       value = bfd_get_32 (input_bfd, contents + rel->r_offset);
10216                       addend = ((value & 0xf0000) >> 4) | (value & 0xfff);
10217                       addend = (addend ^ 0x8000) - 0x8000;
10218                       break;
10219
10220                     case R_ARM_THM_MOVW_ABS_NC:
10221                     case R_ARM_THM_MOVT_ABS:
10222                       value = bfd_get_16 (input_bfd, contents + rel->r_offset)
10223                               << 16;
10224                       value |= bfd_get_16 (input_bfd,
10225                                            contents + rel->r_offset + 2);
10226                       addend = ((value & 0xf7000) >> 4) | (value & 0xff)
10227                                | ((value & 0x04000000) >> 15);
10228                       addend = (addend ^ 0x8000) - 0x8000;
10229                       break;
10230
10231                     default:
10232                       if (howto->rightshift
10233                           || (howto->src_mask & (howto->src_mask + 1)))
10234                         {
10235                           (*_bfd_error_handler)
10236                             (_("%B(%A+0x%lx): %s relocation against SEC_MERGE section"),
10237                              input_bfd, input_section,
10238                              (long) rel->r_offset, howto->name);
10239                           return FALSE;
10240                         }
10241
10242                       value = bfd_get_32 (input_bfd, contents + rel->r_offset);
10243
10244                       /* Get the (signed) value from the instruction.  */
10245                       addend = value & howto->src_mask;
10246                       if (addend & ((howto->src_mask + 1) >> 1))
10247                         {
10248                           bfd_signed_vma mask;
10249
10250                           mask = -1;
10251                           mask &= ~ howto->src_mask;
10252                           addend |= mask;
10253                         }
10254                       break;
10255                     }
10256
10257                   msec = sec;
10258                   addend =
10259                     _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend)
10260                     - relocation;
10261                   addend += msec->output_section->vma + msec->output_offset;
10262
10263                   /* Cases here must match those in the preceding
10264                      switch statement.  */
10265                   switch (r_type)
10266                     {
10267                     case R_ARM_MOVW_ABS_NC:
10268                     case R_ARM_MOVT_ABS:
10269                       value = (value & 0xfff0f000) | ((addend & 0xf000) << 4)
10270                               | (addend & 0xfff);
10271                       bfd_put_32 (input_bfd, value, contents + rel->r_offset);
10272                       break;
10273
10274                     case R_ARM_THM_MOVW_ABS_NC:
10275                     case R_ARM_THM_MOVT_ABS:
10276                       value = (value & 0xfbf08f00) | ((addend & 0xf700) << 4)
10277                               | (addend & 0xff) | ((addend & 0x0800) << 15);
10278                       bfd_put_16 (input_bfd, value >> 16,
10279                                   contents + rel->r_offset);
10280                       bfd_put_16 (input_bfd, value,
10281                                   contents + rel->r_offset + 2);
10282                       break;
10283
10284                     default:
10285                       value = (value & ~ howto->dst_mask)
10286                               | (addend & howto->dst_mask);
10287                       bfd_put_32 (input_bfd, value, contents + rel->r_offset);
10288                       break;
10289                     }
10290                 }
10291             }
10292           else
10293             relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
10294         }
10295       else
10296         {
10297           bfd_boolean warned;
10298
10299           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
10300                                    r_symndx, symtab_hdr, sym_hashes,
10301                                    h, sec, relocation,
10302                                    unresolved_reloc, warned);
10303
10304           sym_type = h->type;
10305         }
10306
10307       if (sec != NULL && elf_discarded_section (sec))
10308         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
10309                                          rel, relend, howto, contents);
10310
10311       if (info->relocatable)
10312         {
10313           /* This is a relocatable link.  We don't have to change
10314              anything, unless the reloc is against a section symbol,
10315              in which case we have to adjust according to where the
10316              section symbol winds up in the output section.  */
10317           if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
10318             {
10319               if (globals->use_rel)
10320                 arm_add_to_rel (input_bfd, contents + rel->r_offset,
10321                                 howto, (bfd_signed_vma) sec->output_offset);
10322               else
10323                 rel->r_addend += sec->output_offset;
10324             }
10325           continue;
10326         }
10327
10328       if (h != NULL)
10329         name = h->root.root.string;
10330       else
10331         {
10332           name = (bfd_elf_string_from_elf_section
10333                   (input_bfd, symtab_hdr->sh_link, sym->st_name));
10334           if (name == NULL || *name == '\0')
10335             name = bfd_section_name (input_bfd, sec);
10336         }
10337
10338       if (r_symndx != STN_UNDEF
10339           && r_type != R_ARM_NONE
10340           && (h == NULL
10341               || h->root.type == bfd_link_hash_defined
10342               || h->root.type == bfd_link_hash_defweak)
10343           && IS_ARM_TLS_RELOC (r_type) != (sym_type == STT_TLS))
10344         {
10345           (*_bfd_error_handler)
10346             ((sym_type == STT_TLS
10347               ? _("%B(%A+0x%lx): %s used with TLS symbol %s")
10348               : _("%B(%A+0x%lx): %s used with non-TLS symbol %s")),
10349              input_bfd,
10350              input_section,
10351              (long) rel->r_offset,
10352              howto->name,
10353              name);
10354         }
10355
10356       /* We call elf32_arm_final_link_relocate unless we're completely
10357          done, i.e., the relaxation produced the final output we want,
10358          and we won't let anybody mess with it. Also, we have to do
10359          addend adjustments in case of a R_ARM_TLS_GOTDESC relocation
10360          both in relaxed and non-relaxed cases */
10361      if ((elf32_arm_tls_transition (info, r_type, h) != (unsigned)r_type)
10362          || (IS_ARM_TLS_GNU_RELOC (r_type)
10363              && !((h ? elf32_arm_hash_entry (h)->tls_type :
10364                    elf32_arm_local_got_tls_type (input_bfd)[r_symndx])
10365                   & GOT_TLS_GDESC)))
10366        {
10367          r = elf32_arm_tls_relax (globals, input_bfd, input_section,
10368                                   contents, rel, h == NULL);
10369          /* This may have been marked unresolved because it came from
10370             a shared library.  But we've just dealt with that.  */
10371          unresolved_reloc = 0;
10372        }
10373      else
10374        r = bfd_reloc_continue;
10375
10376      if (r == bfd_reloc_continue)
10377        r = elf32_arm_final_link_relocate (howto, input_bfd, output_bfd,
10378                                           input_section, contents, rel,
10379                                           relocation, info, sec, name, sym_type,
10380                                           (h ? h->target_internal
10381                                            : ARM_SYM_BRANCH_TYPE (sym)), h,
10382                                           &unresolved_reloc, &error_message);
10383
10384       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
10385          because such sections are not SEC_ALLOC and thus ld.so will
10386          not process them.  */
10387       if (unresolved_reloc
10388           && !((input_section->flags & SEC_DEBUGGING) != 0
10389                && h->def_dynamic))
10390         {
10391           (*_bfd_error_handler)
10392             (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
10393              input_bfd,
10394              input_section,
10395              (long) rel->r_offset,
10396              howto->name,
10397              h->root.root.string);
10398           return FALSE;
10399         }
10400
10401       if (r != bfd_reloc_ok)
10402         {
10403           switch (r)
10404             {
10405             case bfd_reloc_overflow:
10406               /* If the overflowing reloc was to an undefined symbol,
10407                  we have already printed one error message and there
10408                  is no point complaining again.  */
10409               if ((! h ||
10410                    h->root.type != bfd_link_hash_undefined)
10411                   && (!((*info->callbacks->reloc_overflow)
10412                         (info, (h ? &h->root : NULL), name, howto->name,
10413                          (bfd_vma) 0, input_bfd, input_section,
10414                          rel->r_offset))))
10415                   return FALSE;
10416               break;
10417
10418             case bfd_reloc_undefined:
10419               if (!((*info->callbacks->undefined_symbol)
10420                     (info, name, input_bfd, input_section,
10421                      rel->r_offset, TRUE)))
10422                 return FALSE;
10423               break;
10424
10425             case bfd_reloc_outofrange:
10426               error_message = _("out of range");
10427               goto common_error;
10428
10429             case bfd_reloc_notsupported:
10430               error_message = _("unsupported relocation");
10431               goto common_error;
10432
10433             case bfd_reloc_dangerous:
10434               /* error_message should already be set.  */
10435               goto common_error;
10436
10437             default:
10438               error_message = _("unknown error");
10439               /* Fall through.  */
10440
10441             common_error:
10442               BFD_ASSERT (error_message != NULL);
10443               if (!((*info->callbacks->reloc_dangerous)
10444                     (info, error_message, input_bfd, input_section,
10445                      rel->r_offset)))
10446                 return FALSE;
10447               break;
10448             }
10449         }
10450     }
10451
10452   return TRUE;
10453 }
10454
10455 /* Add a new unwind edit to the list described by HEAD, TAIL.  If TINDEX is zero,
10456    adds the edit to the start of the list.  (The list must be built in order of
10457    ascending TINDEX: the function's callers are primarily responsible for
10458    maintaining that condition).  */
10459
10460 static void
10461 add_unwind_table_edit (arm_unwind_table_edit **head,
10462                        arm_unwind_table_edit **tail,
10463                        arm_unwind_edit_type type,
10464                        asection *linked_section,
10465                        unsigned int tindex)
10466 {
10467   arm_unwind_table_edit *new_edit = (arm_unwind_table_edit *)
10468       xmalloc (sizeof (arm_unwind_table_edit));
10469
10470   new_edit->type = type;
10471   new_edit->linked_section = linked_section;
10472   new_edit->index = tindex;
10473
10474   if (tindex > 0)
10475     {
10476       new_edit->next = NULL;
10477
10478       if (*tail)
10479         (*tail)->next = new_edit;
10480
10481       (*tail) = new_edit;
10482
10483       if (!*head)
10484         (*head) = new_edit;
10485     }
10486   else
10487     {
10488       new_edit->next = *head;
10489
10490       if (!*tail)
10491         *tail = new_edit;
10492
10493       *head = new_edit;
10494     }
10495 }
10496
10497 static _arm_elf_section_data *get_arm_elf_section_data (asection *);
10498
10499 /* Increase the size of EXIDX_SEC by ADJUST bytes.  ADJUST mau be negative.  */
10500 static void
10501 adjust_exidx_size(asection *exidx_sec, int adjust)
10502 {
10503   asection *out_sec;
10504
10505   if (!exidx_sec->rawsize)
10506     exidx_sec->rawsize = exidx_sec->size;
10507
10508   bfd_set_section_size (exidx_sec->owner, exidx_sec, exidx_sec->size + adjust);
10509   out_sec = exidx_sec->output_section;
10510   /* Adjust size of output section.  */
10511   bfd_set_section_size (out_sec->owner, out_sec, out_sec->size +adjust);
10512 }
10513
10514 /* Insert an EXIDX_CANTUNWIND marker at the end of a section.  */
10515 static void
10516 insert_cantunwind_after(asection *text_sec, asection *exidx_sec)
10517 {
10518   struct _arm_elf_section_data *exidx_arm_data;
10519
10520   exidx_arm_data = get_arm_elf_section_data (exidx_sec);
10521   add_unwind_table_edit (
10522     &exidx_arm_data->u.exidx.unwind_edit_list,
10523     &exidx_arm_data->u.exidx.unwind_edit_tail,
10524     INSERT_EXIDX_CANTUNWIND_AT_END, text_sec, UINT_MAX);
10525
10526   adjust_exidx_size(exidx_sec, 8);
10527 }
10528
10529 /* Scan .ARM.exidx tables, and create a list describing edits which should be
10530    made to those tables, such that:
10531
10532      1. Regions without unwind data are marked with EXIDX_CANTUNWIND entries.
10533      2. Duplicate entries are merged together (EXIDX_CANTUNWIND, or unwind
10534         codes which have been inlined into the index).
10535
10536    If MERGE_EXIDX_ENTRIES is false, duplicate entries are not merged.
10537
10538    The edits are applied when the tables are written
10539    (in elf32_arm_write_section).
10540 */
10541
10542 bfd_boolean
10543 elf32_arm_fix_exidx_coverage (asection **text_section_order,
10544                               unsigned int num_text_sections,
10545                               struct bfd_link_info *info,
10546                               bfd_boolean merge_exidx_entries)
10547 {
10548   bfd *inp;
10549   unsigned int last_second_word = 0, i;
10550   asection *last_exidx_sec = NULL;
10551   asection *last_text_sec = NULL;
10552   int last_unwind_type = -1;
10553
10554   /* Walk over all EXIDX sections, and create backlinks from the corrsponding
10555      text sections.  */
10556   for (inp = info->input_bfds; inp != NULL; inp = inp->link_next)
10557     {
10558       asection *sec;
10559
10560       for (sec = inp->sections; sec != NULL; sec = sec->next)
10561         {
10562           struct bfd_elf_section_data *elf_sec = elf_section_data (sec);
10563           Elf_Internal_Shdr *hdr = &elf_sec->this_hdr;
10564
10565           if (!hdr || hdr->sh_type != SHT_ARM_EXIDX)
10566             continue;
10567
10568           if (elf_sec->linked_to)
10569             {
10570               Elf_Internal_Shdr *linked_hdr
10571                 = &elf_section_data (elf_sec->linked_to)->this_hdr;
10572               struct _arm_elf_section_data *linked_sec_arm_data
10573                 = get_arm_elf_section_data (linked_hdr->bfd_section);
10574
10575               if (linked_sec_arm_data == NULL)
10576                 continue;
10577
10578               /* Link this .ARM.exidx section back from the text section it
10579                  describes.  */
10580               linked_sec_arm_data->u.text.arm_exidx_sec = sec;
10581             }
10582         }
10583     }
10584
10585   /* Walk all text sections in order of increasing VMA.  Eilminate duplicate
10586      index table entries (EXIDX_CANTUNWIND and inlined unwind opcodes),
10587      and add EXIDX_CANTUNWIND entries for sections with no unwind table data.  */
10588
10589   for (i = 0; i < num_text_sections; i++)
10590     {
10591       asection *sec = text_section_order[i];
10592       asection *exidx_sec;
10593       struct _arm_elf_section_data *arm_data = get_arm_elf_section_data (sec);
10594       struct _arm_elf_section_data *exidx_arm_data;
10595       bfd_byte *contents = NULL;
10596       int deleted_exidx_bytes = 0;
10597       bfd_vma j;
10598       arm_unwind_table_edit *unwind_edit_head = NULL;
10599       arm_unwind_table_edit *unwind_edit_tail = NULL;
10600       Elf_Internal_Shdr *hdr;
10601       bfd *ibfd;
10602
10603       if (arm_data == NULL)
10604         continue;
10605
10606       exidx_sec = arm_data->u.text.arm_exidx_sec;
10607       if (exidx_sec == NULL)
10608         {
10609           /* Section has no unwind data.  */
10610           if (last_unwind_type == 0 || !last_exidx_sec)
10611             continue;
10612
10613           /* Ignore zero sized sections.  */
10614           if (sec->size == 0)
10615             continue;
10616
10617           insert_cantunwind_after(last_text_sec, last_exidx_sec);
10618           last_unwind_type = 0;
10619           continue;
10620         }
10621
10622       /* Skip /DISCARD/ sections.  */
10623       if (bfd_is_abs_section (exidx_sec->output_section))
10624         continue;
10625
10626       hdr = &elf_section_data (exidx_sec)->this_hdr;
10627       if (hdr->sh_type != SHT_ARM_EXIDX)
10628         continue;
10629
10630       exidx_arm_data = get_arm_elf_section_data (exidx_sec);
10631       if (exidx_arm_data == NULL)
10632         continue;
10633
10634       ibfd = exidx_sec->owner;
10635
10636       if (hdr->contents != NULL)
10637         contents = hdr->contents;
10638       else if (! bfd_malloc_and_get_section (ibfd, exidx_sec, &contents))
10639         /* An error?  */
10640         continue;
10641
10642       for (j = 0; j < hdr->sh_size; j += 8)
10643         {
10644           unsigned int second_word = bfd_get_32 (ibfd, contents + j + 4);
10645           int unwind_type;
10646           int elide = 0;
10647
10648           /* An EXIDX_CANTUNWIND entry.  */
10649           if (second_word == 1)
10650             {
10651               if (last_unwind_type == 0)
10652                 elide = 1;
10653               unwind_type = 0;
10654             }
10655           /* Inlined unwinding data.  Merge if equal to previous.  */
10656           else if ((second_word & 0x80000000) != 0)
10657             {
10658               if (merge_exidx_entries
10659                    && last_second_word == second_word && last_unwind_type == 1)
10660                 elide = 1;
10661               unwind_type = 1;
10662               last_second_word = second_word;
10663             }
10664           /* Normal table entry.  In theory we could merge these too,
10665              but duplicate entries are likely to be much less common.  */
10666           else
10667             unwind_type = 2;
10668
10669           if (elide)
10670             {
10671               add_unwind_table_edit (&unwind_edit_head, &unwind_edit_tail,
10672                                      DELETE_EXIDX_ENTRY, NULL, j / 8);
10673
10674               deleted_exidx_bytes += 8;
10675             }
10676
10677           last_unwind_type = unwind_type;
10678         }
10679
10680       /* Free contents if we allocated it ourselves.  */
10681       if (contents != hdr->contents)
10682         free (contents);
10683
10684       /* Record edits to be applied later (in elf32_arm_write_section).  */
10685       exidx_arm_data->u.exidx.unwind_edit_list = unwind_edit_head;
10686       exidx_arm_data->u.exidx.unwind_edit_tail = unwind_edit_tail;
10687
10688       if (deleted_exidx_bytes > 0)
10689         adjust_exidx_size(exidx_sec, -deleted_exidx_bytes);
10690
10691       last_exidx_sec = exidx_sec;
10692       last_text_sec = sec;
10693     }
10694
10695   /* Add terminating CANTUNWIND entry.  */
10696   if (last_exidx_sec && last_unwind_type != 0)
10697     insert_cantunwind_after(last_text_sec, last_exidx_sec);
10698
10699   return TRUE;
10700 }
10701
10702 static bfd_boolean
10703 elf32_arm_output_glue_section (struct bfd_link_info *info, bfd *obfd,
10704                                bfd *ibfd, const char *name)
10705 {
10706   asection *sec, *osec;
10707
10708   sec = bfd_get_section_by_name (ibfd, name);
10709   if (sec == NULL || (sec->flags & SEC_EXCLUDE) != 0)
10710     return TRUE;
10711
10712   osec = sec->output_section;
10713   if (elf32_arm_write_section (obfd, info, sec, sec->contents))
10714     return TRUE;
10715
10716   if (! bfd_set_section_contents (obfd, osec, sec->contents,
10717                                   sec->output_offset, sec->size))
10718     return FALSE;
10719
10720   return TRUE;
10721 }
10722
10723 static bfd_boolean
10724 elf32_arm_final_link (bfd *abfd, struct bfd_link_info *info)
10725 {
10726   struct elf32_arm_link_hash_table *globals = elf32_arm_hash_table (info);
10727   asection *sec, *osec;
10728
10729   if (globals == NULL)
10730     return FALSE;
10731
10732   /* Invoke the regular ELF backend linker to do all the work.  */
10733   if (!bfd_elf_final_link (abfd, info))
10734     return FALSE;
10735
10736   /* Process stub sections (eg BE8 encoding, ...).  */
10737   struct elf32_arm_link_hash_table *htab = elf32_arm_hash_table (info);
10738   int i;
10739   for (i=0; i<htab->top_id; i++)
10740     {
10741       sec = htab->stub_group[i].stub_sec;
10742       /* Only process it once, in its link_sec slot.  */
10743       if (sec && i == htab->stub_group[i].link_sec->id)
10744         {
10745           osec = sec->output_section;
10746           elf32_arm_write_section (abfd, info, sec, sec->contents);
10747           if (! bfd_set_section_contents (abfd, osec, sec->contents,
10748                                           sec->output_offset, sec->size))
10749             return FALSE;
10750         }
10751     }
10752
10753   /* Write out any glue sections now that we have created all the
10754      stubs.  */
10755   if (globals->bfd_of_glue_owner != NULL)
10756     {
10757       if (! elf32_arm_output_glue_section (info, abfd,
10758                                            globals->bfd_of_glue_owner,
10759                                            ARM2THUMB_GLUE_SECTION_NAME))
10760         return FALSE;
10761
10762       if (! elf32_arm_output_glue_section (info, abfd,
10763                                            globals->bfd_of_glue_owner,
10764                                            THUMB2ARM_GLUE_SECTION_NAME))
10765         return FALSE;
10766
10767       if (! elf32_arm_output_glue_section (info, abfd,
10768                                            globals->bfd_of_glue_owner,
10769                                            VFP11_ERRATUM_VENEER_SECTION_NAME))
10770         return FALSE;
10771
10772       if (! elf32_arm_output_glue_section (info, abfd,
10773                                            globals->bfd_of_glue_owner,
10774                                            ARM_BX_GLUE_SECTION_NAME))
10775         return FALSE;
10776     }
10777
10778   return TRUE;
10779 }
10780
10781 /* Set the right machine number.  */
10782
10783 static bfd_boolean
10784 elf32_arm_object_p (bfd *abfd)
10785 {
10786   unsigned int mach;
10787
10788   mach = bfd_arm_get_mach_from_notes (abfd, ARM_NOTE_SECTION);
10789
10790   if (mach != bfd_mach_arm_unknown)
10791     bfd_default_set_arch_mach (abfd, bfd_arch_arm, mach);
10792
10793   else if (elf_elfheader (abfd)->e_flags & EF_ARM_MAVERICK_FLOAT)
10794     bfd_default_set_arch_mach (abfd, bfd_arch_arm, bfd_mach_arm_ep9312);
10795
10796   else
10797     bfd_default_set_arch_mach (abfd, bfd_arch_arm, mach);
10798
10799   return TRUE;
10800 }
10801
10802 /* Function to keep ARM specific flags in the ELF header.  */
10803
10804 static bfd_boolean
10805 elf32_arm_set_private_flags (bfd *abfd, flagword flags)
10806 {
10807   if (elf_flags_init (abfd)
10808       && elf_elfheader (abfd)->e_flags != flags)
10809     {
10810       if (EF_ARM_EABI_VERSION (flags) == EF_ARM_EABI_UNKNOWN)
10811         {
10812           if (flags & EF_ARM_INTERWORK)
10813             (*_bfd_error_handler)
10814               (_("Warning: Not setting interworking flag of %B since it has already been specified as non-interworking"),
10815                abfd);
10816           else
10817             _bfd_error_handler
10818               (_("Warning: Clearing the interworking flag of %B due to outside request"),
10819                abfd);
10820         }
10821     }
10822   else
10823     {
10824       elf_elfheader (abfd)->e_flags = flags;
10825       elf_flags_init (abfd) = TRUE;
10826     }
10827
10828   return TRUE;
10829 }
10830
10831 /* Copy backend specific data from one object module to another.  */
10832
10833 static bfd_boolean
10834 elf32_arm_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
10835 {
10836   flagword in_flags;
10837   flagword out_flags;
10838
10839   if (! is_arm_elf (ibfd) || ! is_arm_elf (obfd))
10840     return TRUE;
10841
10842   in_flags  = elf_elfheader (ibfd)->e_flags;
10843   out_flags = elf_elfheader (obfd)->e_flags;
10844
10845   if (elf_flags_init (obfd)
10846       && EF_ARM_EABI_VERSION (out_flags) == EF_ARM_EABI_UNKNOWN
10847       && in_flags != out_flags)
10848     {
10849       /* Cannot mix APCS26 and APCS32 code.  */
10850       if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
10851         return FALSE;
10852
10853       /* Cannot mix float APCS and non-float APCS code.  */
10854       if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
10855         return FALSE;
10856
10857       /* If the src and dest have different interworking flags
10858          then turn off the interworking bit.  */
10859       if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
10860         {
10861           if (out_flags & EF_ARM_INTERWORK)
10862             _bfd_error_handler
10863               (_("Warning: Clearing the interworking flag of %B because non-interworking code in %B has been linked with it"),
10864                obfd, ibfd);
10865
10866           in_flags &= ~EF_ARM_INTERWORK;
10867         }
10868
10869       /* Likewise for PIC, though don't warn for this case.  */
10870       if ((in_flags & EF_ARM_PIC) != (out_flags & EF_ARM_PIC))
10871         in_flags &= ~EF_ARM_PIC;
10872     }
10873
10874   elf_elfheader (obfd)->e_flags = in_flags;
10875   elf_flags_init (obfd) = TRUE;
10876
10877   /* Also copy the EI_OSABI field.  */
10878   elf_elfheader (obfd)->e_ident[EI_OSABI] =
10879     elf_elfheader (ibfd)->e_ident[EI_OSABI];
10880
10881   /* Copy object attributes.  */
10882   _bfd_elf_copy_obj_attributes (ibfd, obfd);
10883
10884   return TRUE;
10885 }
10886
10887 /* Values for Tag_ABI_PCS_R9_use.  */
10888 enum
10889 {
10890   AEABI_R9_V6,
10891   AEABI_R9_SB,
10892   AEABI_R9_TLS,
10893   AEABI_R9_unused
10894 };
10895
10896 /* Values for Tag_ABI_PCS_RW_data.  */
10897 enum
10898 {
10899   AEABI_PCS_RW_data_absolute,
10900   AEABI_PCS_RW_data_PCrel,
10901   AEABI_PCS_RW_data_SBrel,
10902   AEABI_PCS_RW_data_unused
10903 };
10904
10905 /* Values for Tag_ABI_enum_size.  */
10906 enum
10907 {
10908   AEABI_enum_unused,
10909   AEABI_enum_short,
10910   AEABI_enum_wide,
10911   AEABI_enum_forced_wide
10912 };
10913
10914 /* Determine whether an object attribute tag takes an integer, a
10915    string or both.  */
10916
10917 static int
10918 elf32_arm_obj_attrs_arg_type (int tag)
10919 {
10920   if (tag == Tag_compatibility)
10921     return ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_STR_VAL;
10922   else if (tag == Tag_nodefaults)
10923     return ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_NO_DEFAULT;
10924   else if (tag == Tag_CPU_raw_name || tag == Tag_CPU_name)
10925     return ATTR_TYPE_FLAG_STR_VAL;
10926   else if (tag < 32)
10927     return ATTR_TYPE_FLAG_INT_VAL;
10928   else
10929     return (tag & 1) != 0 ? ATTR_TYPE_FLAG_STR_VAL : ATTR_TYPE_FLAG_INT_VAL;
10930 }
10931
10932 /* The ABI defines that Tag_conformance should be emitted first, and that
10933    Tag_nodefaults should be second (if either is defined).  This sets those
10934    two positions, and bumps up the position of all the remaining tags to
10935    compensate.  */
10936 static int
10937 elf32_arm_obj_attrs_order (int num)
10938 {
10939   if (num == LEAST_KNOWN_OBJ_ATTRIBUTE)
10940     return Tag_conformance;
10941   if (num == LEAST_KNOWN_OBJ_ATTRIBUTE + 1)
10942     return Tag_nodefaults;
10943   if ((num - 2) < Tag_nodefaults)
10944     return num - 2;
10945   if ((num - 1) < Tag_conformance)
10946     return num - 1;
10947   return num;
10948 }
10949
10950 /* Attribute numbers >=64 (mod 128) can be safely ignored.  */
10951 static bfd_boolean
10952 elf32_arm_obj_attrs_handle_unknown (bfd *abfd, int tag)
10953 {
10954   if ((tag & 127) < 64)
10955     {
10956       _bfd_error_handler
10957         (_("%B: Unknown mandatory EABI object attribute %d"),
10958          abfd, tag);
10959       bfd_set_error (bfd_error_bad_value);
10960       return FALSE;
10961     }
10962   else
10963     {
10964       _bfd_error_handler
10965         (_("Warning: %B: Unknown EABI object attribute %d"),
10966          abfd, tag);
10967       return TRUE;
10968     }
10969 }
10970
10971 /* Read the architecture from the Tag_also_compatible_with attribute, if any.
10972    Returns -1 if no architecture could be read.  */
10973
10974 static int
10975 get_secondary_compatible_arch (bfd *abfd)
10976 {
10977   obj_attribute *attr =
10978     &elf_known_obj_attributes_proc (abfd)[Tag_also_compatible_with];
10979
10980   /* Note: the tag and its argument below are uleb128 values, though
10981      currently-defined values fit in one byte for each.  */
10982   if (attr->s
10983       && attr->s[0] == Tag_CPU_arch
10984       && (attr->s[1] & 128) != 128
10985       && attr->s[2] == 0)
10986    return attr->s[1];
10987
10988   /* This tag is "safely ignorable", so don't complain if it looks funny.  */
10989   return -1;
10990 }
10991
10992 /* Set, or unset, the architecture of the Tag_also_compatible_with attribute.
10993    The tag is removed if ARCH is -1.  */
10994
10995 static void
10996 set_secondary_compatible_arch (bfd *abfd, int arch)
10997 {
10998   obj_attribute *attr =
10999     &elf_known_obj_attributes_proc (abfd)[Tag_also_compatible_with];
11000
11001   if (arch == -1)
11002     {
11003       attr->s = NULL;
11004       return;
11005     }
11006
11007   /* Note: the tag and its argument below are uleb128 values, though
11008      currently-defined values fit in one byte for each.  */
11009   if (!attr->s)
11010     attr->s = (char *) bfd_alloc (abfd, 3);
11011   attr->s[0] = Tag_CPU_arch;
11012   attr->s[1] = arch;
11013   attr->s[2] = '\0';
11014 }
11015
11016 /* Combine two values for Tag_CPU_arch, taking secondary compatibility tags
11017    into account.  */
11018
11019 static int
11020 tag_cpu_arch_combine (bfd *ibfd, int oldtag, int *secondary_compat_out,
11021                       int newtag, int secondary_compat)
11022 {
11023 #define T(X) TAG_CPU_ARCH_##X
11024   int tagl, tagh, result;
11025   const int v6t2[] =
11026     {
11027       T(V6T2),   /* PRE_V4.  */
11028       T(V6T2),   /* V4.  */
11029       T(V6T2),   /* V4T.  */
11030       T(V6T2),   /* V5T.  */
11031       T(V6T2),   /* V5TE.  */
11032       T(V6T2),   /* V5TEJ.  */
11033       T(V6T2),   /* V6.  */
11034       T(V7),     /* V6KZ.  */
11035       T(V6T2)    /* V6T2.  */
11036     };
11037   const int v6k[] =
11038     {
11039       T(V6K),    /* PRE_V4.  */
11040       T(V6K),    /* V4.  */
11041       T(V6K),    /* V4T.  */
11042       T(V6K),    /* V5T.  */
11043       T(V6K),    /* V5TE.  */
11044       T(V6K),    /* V5TEJ.  */
11045       T(V6K),    /* V6.  */
11046       T(V6KZ),   /* V6KZ.  */
11047       T(V7),     /* V6T2.  */
11048       T(V6K)     /* V6K.  */
11049     };
11050   const int v7[] =
11051     {
11052       T(V7),     /* PRE_V4.  */
11053       T(V7),     /* V4.  */
11054       T(V7),     /* V4T.  */
11055       T(V7),     /* V5T.  */
11056       T(V7),     /* V5TE.  */
11057       T(V7),     /* V5TEJ.  */
11058       T(V7),     /* V6.  */
11059       T(V7),     /* V6KZ.  */
11060       T(V7),     /* V6T2.  */
11061       T(V7),     /* V6K.  */
11062       T(V7)      /* V7.  */
11063     };
11064   const int v6_m[] =
11065     {
11066       -1,        /* PRE_V4.  */
11067       -1,        /* V4.  */
11068       T(V6K),    /* V4T.  */
11069       T(V6K),    /* V5T.  */
11070       T(V6K),    /* V5TE.  */
11071       T(V6K),    /* V5TEJ.  */
11072       T(V6K),    /* V6.  */
11073       T(V6KZ),   /* V6KZ.  */
11074       T(V7),     /* V6T2.  */
11075       T(V6K),    /* V6K.  */
11076       T(V7),     /* V7.  */
11077       T(V6_M)    /* V6_M.  */
11078     };
11079   const int v6s_m[] =
11080     {
11081       -1,        /* PRE_V4.  */
11082       -1,        /* V4.  */
11083       T(V6K),    /* V4T.  */
11084       T(V6K),    /* V5T.  */
11085       T(V6K),    /* V5TE.  */
11086       T(V6K),    /* V5TEJ.  */
11087       T(V6K),    /* V6.  */
11088       T(V6KZ),   /* V6KZ.  */
11089       T(V7),     /* V6T2.  */
11090       T(V6K),    /* V6K.  */
11091       T(V7),     /* V7.  */
11092       T(V6S_M),  /* V6_M.  */
11093       T(V6S_M)   /* V6S_M.  */
11094     };
11095   const int v7e_m[] =
11096     {
11097       -1,        /* PRE_V4.  */
11098       -1,        /* V4.  */
11099       T(V7E_M),  /* V4T.  */
11100       T(V7E_M),  /* V5T.  */
11101       T(V7E_M),  /* V5TE.  */
11102       T(V7E_M),  /* V5TEJ.  */
11103       T(V7E_M),  /* V6.  */
11104       T(V7E_M),  /* V6KZ.  */
11105       T(V7E_M),  /* V6T2.  */
11106       T(V7E_M),  /* V6K.  */
11107       T(V7E_M),  /* V7.  */
11108       T(V7E_M),  /* V6_M.  */
11109       T(V7E_M),  /* V6S_M.  */
11110       T(V7E_M)   /* V7E_M.  */
11111     };
11112   const int v4t_plus_v6_m[] =
11113     {
11114       -1,               /* PRE_V4.  */
11115       -1,               /* V4.  */
11116       T(V4T),           /* V4T.  */
11117       T(V5T),           /* V5T.  */
11118       T(V5TE),          /* V5TE.  */
11119       T(V5TEJ),         /* V5TEJ.  */
11120       T(V6),            /* V6.  */
11121       T(V6KZ),          /* V6KZ.  */
11122       T(V6T2),          /* V6T2.  */
11123       T(V6K),           /* V6K.  */
11124       T(V7),            /* V7.  */
11125       T(V6_M),          /* V6_M.  */
11126       T(V6S_M),         /* V6S_M.  */
11127       T(V7E_M),         /* V7E_M.  */
11128       T(V4T_PLUS_V6_M)  /* V4T plus V6_M.  */
11129     };
11130   const int *comb[] =
11131     {
11132       v6t2,
11133       v6k,
11134       v7,
11135       v6_m,
11136       v6s_m,
11137       v7e_m,
11138       /* Pseudo-architecture.  */
11139       v4t_plus_v6_m
11140     };
11141
11142   /* Check we've not got a higher architecture than we know about.  */
11143
11144   if (oldtag > MAX_TAG_CPU_ARCH || newtag > MAX_TAG_CPU_ARCH)
11145     {
11146       _bfd_error_handler (_("error: %B: Unknown CPU architecture"), ibfd);
11147       return -1;
11148     }
11149
11150   /* Override old tag if we have a Tag_also_compatible_with on the output.  */
11151
11152   if ((oldtag == T(V6_M) && *secondary_compat_out == T(V4T))
11153       || (oldtag == T(V4T) && *secondary_compat_out == T(V6_M)))
11154     oldtag = T(V4T_PLUS_V6_M);
11155
11156   /* And override the new tag if we have a Tag_also_compatible_with on the
11157      input.  */
11158
11159   if ((newtag == T(V6_M) && secondary_compat == T(V4T))
11160       || (newtag == T(V4T) && secondary_compat == T(V6_M)))
11161     newtag = T(V4T_PLUS_V6_M);
11162
11163   tagl = (oldtag < newtag) ? oldtag : newtag;
11164   result = tagh = (oldtag > newtag) ? oldtag : newtag;
11165
11166   /* Architectures before V6KZ add features monotonically.  */
11167   if (tagh <= TAG_CPU_ARCH_V6KZ)
11168     return result;
11169
11170   result = comb[tagh - T(V6T2)][tagl];
11171
11172   /* Use Tag_CPU_arch == V4T and Tag_also_compatible_with (Tag_CPU_arch V6_M)
11173      as the canonical version.  */
11174   if (result == T(V4T_PLUS_V6_M))
11175     {
11176       result = T(V4T);
11177       *secondary_compat_out = T(V6_M);
11178     }
11179   else
11180     *secondary_compat_out = -1;
11181
11182   if (result == -1)
11183     {
11184       _bfd_error_handler (_("error: %B: Conflicting CPU architectures %d/%d"),
11185                           ibfd, oldtag, newtag);
11186       return -1;
11187     }
11188
11189   return result;
11190 #undef T
11191 }
11192
11193 /* Merge EABI object attributes from IBFD into OBFD.  Raise an error if there
11194    are conflicting attributes.  */
11195
11196 static bfd_boolean
11197 elf32_arm_merge_eabi_attributes (bfd *ibfd, bfd *obfd)
11198 {
11199   obj_attribute *in_attr;
11200   obj_attribute *out_attr;
11201   /* Some tags have 0 = don't care, 1 = strong requirement,
11202      2 = weak requirement.  */
11203   static const int order_021[3] = {0, 2, 1};
11204   int i;
11205   bfd_boolean result = TRUE;
11206
11207   /* Skip the linker stubs file.  This preserves previous behavior
11208      of accepting unknown attributes in the first input file - but
11209      is that a bug?  */
11210   if (ibfd->flags & BFD_LINKER_CREATED)
11211     return TRUE;
11212
11213   if (!elf_known_obj_attributes_proc (obfd)[0].i)
11214     {
11215       /* This is the first object.  Copy the attributes.  */
11216       _bfd_elf_copy_obj_attributes (ibfd, obfd);
11217
11218       out_attr = elf_known_obj_attributes_proc (obfd);
11219
11220       /* Use the Tag_null value to indicate the attributes have been
11221          initialized.  */
11222       out_attr[0].i = 1;
11223
11224       /* We do not output objects with Tag_MPextension_use_legacy - we move
11225          the attribute's value to Tag_MPextension_use.  */
11226       if (out_attr[Tag_MPextension_use_legacy].i != 0)
11227         {
11228           if (out_attr[Tag_MPextension_use].i != 0
11229               && out_attr[Tag_MPextension_use_legacy].i
11230                 != out_attr[Tag_MPextension_use].i)
11231             {
11232               _bfd_error_handler
11233                 (_("Error: %B has both the current and legacy "
11234                    "Tag_MPextension_use attributes"), ibfd);
11235               result = FALSE;
11236             }
11237
11238           out_attr[Tag_MPextension_use] =
11239             out_attr[Tag_MPextension_use_legacy];
11240           out_attr[Tag_MPextension_use_legacy].type = 0;
11241           out_attr[Tag_MPextension_use_legacy].i = 0;
11242         }
11243
11244       return result;
11245     }
11246
11247   in_attr = elf_known_obj_attributes_proc (ibfd);
11248   out_attr = elf_known_obj_attributes_proc (obfd);
11249   /* This needs to happen before Tag_ABI_FP_number_model is merged.  */
11250   if (in_attr[Tag_ABI_VFP_args].i != out_attr[Tag_ABI_VFP_args].i)
11251     {
11252       /* Ignore mismatches if the object doesn't use floating point.  */
11253       if (out_attr[Tag_ABI_FP_number_model].i == 0)
11254         out_attr[Tag_ABI_VFP_args].i = in_attr[Tag_ABI_VFP_args].i;
11255       else if (in_attr[Tag_ABI_FP_number_model].i != 0)
11256         {
11257           _bfd_error_handler
11258             (_("error: %B uses VFP register arguments, %B does not"),
11259              in_attr[Tag_ABI_VFP_args].i ? ibfd : obfd,
11260              in_attr[Tag_ABI_VFP_args].i ? obfd : ibfd);
11261           result = FALSE;
11262         }
11263     }
11264
11265   for (i = LEAST_KNOWN_OBJ_ATTRIBUTE; i < NUM_KNOWN_OBJ_ATTRIBUTES; i++)
11266     {
11267       /* Merge this attribute with existing attributes.  */
11268       switch (i)
11269         {
11270         case Tag_CPU_raw_name:
11271         case Tag_CPU_name:
11272           /* These are merged after Tag_CPU_arch. */
11273           break;
11274
11275         case Tag_ABI_optimization_goals:
11276         case Tag_ABI_FP_optimization_goals:
11277           /* Use the first value seen.  */
11278           break;
11279
11280         case Tag_CPU_arch:
11281           {
11282             int secondary_compat = -1, secondary_compat_out = -1;
11283             unsigned int saved_out_attr = out_attr[i].i;
11284             static const char *name_table[] = {
11285                 /* These aren't real CPU names, but we can't guess
11286                    that from the architecture version alone.  */
11287                 "Pre v4",
11288                 "ARM v4",
11289                 "ARM v4T",
11290                 "ARM v5T",
11291                 "ARM v5TE",
11292                 "ARM v5TEJ",
11293                 "ARM v6",
11294                 "ARM v6KZ",
11295                 "ARM v6T2",
11296                 "ARM v6K",
11297                 "ARM v7",
11298                 "ARM v6-M",
11299                 "ARM v6S-M"
11300             };
11301
11302             /* Merge Tag_CPU_arch and Tag_also_compatible_with.  */
11303             secondary_compat = get_secondary_compatible_arch (ibfd);
11304             secondary_compat_out = get_secondary_compatible_arch (obfd);
11305             out_attr[i].i = tag_cpu_arch_combine (ibfd, out_attr[i].i,
11306                                                   &secondary_compat_out,
11307                                                   in_attr[i].i,
11308                                                   secondary_compat);
11309             set_secondary_compatible_arch (obfd, secondary_compat_out);
11310
11311             /* Merge Tag_CPU_name and Tag_CPU_raw_name.  */
11312             if (out_attr[i].i == saved_out_attr)
11313               ; /* Leave the names alone.  */
11314             else if (out_attr[i].i == in_attr[i].i)
11315               {
11316                 /* The output architecture has been changed to match the
11317                    input architecture.  Use the input names.  */
11318                 out_attr[Tag_CPU_name].s = in_attr[Tag_CPU_name].s
11319                   ? _bfd_elf_attr_strdup (obfd, in_attr[Tag_CPU_name].s)
11320                   : NULL;
11321                 out_attr[Tag_CPU_raw_name].s = in_attr[Tag_CPU_raw_name].s
11322                   ? _bfd_elf_attr_strdup (obfd, in_attr[Tag_CPU_raw_name].s)
11323                   : NULL;
11324               }
11325             else
11326               {
11327                 out_attr[Tag_CPU_name].s = NULL;
11328                 out_attr[Tag_CPU_raw_name].s = NULL;
11329               }
11330
11331             /* If we still don't have a value for Tag_CPU_name,
11332                make one up now.  Tag_CPU_raw_name remains blank.  */
11333             if (out_attr[Tag_CPU_name].s == NULL
11334                 && out_attr[i].i < ARRAY_SIZE (name_table))
11335               out_attr[Tag_CPU_name].s =
11336                 _bfd_elf_attr_strdup (obfd, name_table[out_attr[i].i]);
11337           }
11338           break;
11339
11340         case Tag_ARM_ISA_use:
11341         case Tag_THUMB_ISA_use:
11342         case Tag_WMMX_arch:
11343         case Tag_Advanced_SIMD_arch:
11344           /* ??? Do Advanced_SIMD (NEON) and WMMX conflict?  */
11345         case Tag_ABI_FP_rounding:
11346         case Tag_ABI_FP_exceptions:
11347         case Tag_ABI_FP_user_exceptions:
11348         case Tag_ABI_FP_number_model:
11349         case Tag_FP_HP_extension:
11350         case Tag_CPU_unaligned_access:
11351         case Tag_T2EE_use:
11352         case Tag_MPextension_use:
11353           /* Use the largest value specified.  */
11354           if (in_attr[i].i > out_attr[i].i)
11355             out_attr[i].i = in_attr[i].i;
11356           break;
11357
11358         case Tag_ABI_align_preserved:
11359         case Tag_ABI_PCS_RO_data:
11360           /* Use the smallest value specified.  */
11361           if (in_attr[i].i < out_attr[i].i)
11362             out_attr[i].i = in_attr[i].i;
11363           break;
11364
11365         case Tag_ABI_align_needed:
11366           if ((in_attr[i].i > 0 || out_attr[i].i > 0)
11367               && (in_attr[Tag_ABI_align_preserved].i == 0
11368                   || out_attr[Tag_ABI_align_preserved].i == 0))
11369             {
11370               /* This error message should be enabled once all non-conformant
11371                  binaries in the toolchain have had the attributes set
11372                  properly.
11373               _bfd_error_handler
11374                 (_("error: %B: 8-byte data alignment conflicts with %B"),
11375                  obfd, ibfd);
11376               result = FALSE; */
11377             }
11378           /* Fall through.  */
11379         case Tag_ABI_FP_denormal:
11380         case Tag_ABI_PCS_GOT_use:
11381           /* Use the "greatest" from the sequence 0, 2, 1, or the largest
11382              value if greater than 2 (for future-proofing).  */
11383           if ((in_attr[i].i > 2 && in_attr[i].i > out_attr[i].i)
11384               || (in_attr[i].i <= 2 && out_attr[i].i <= 2
11385                   && order_021[in_attr[i].i] > order_021[out_attr[i].i]))
11386             out_attr[i].i = in_attr[i].i;
11387           break;
11388
11389         case Tag_Virtualization_use:
11390           /* The virtualization tag effectively stores two bits of
11391              information: the intended use of TrustZone (in bit 0), and the
11392              intended use of Virtualization (in bit 1).  */
11393           if (out_attr[i].i == 0)
11394             out_attr[i].i = in_attr[i].i;
11395           else if (in_attr[i].i != 0
11396                    && in_attr[i].i != out_attr[i].i)
11397             {
11398               if (in_attr[i].i <= 3 && out_attr[i].i <= 3)
11399                 out_attr[i].i = 3;
11400               else
11401                 {
11402                   _bfd_error_handler
11403                     (_("error: %B: unable to merge virtualization attributes "
11404                        "with %B"),
11405                      obfd, ibfd);
11406                   result = FALSE;
11407                 }
11408             }
11409           break;
11410
11411         case Tag_CPU_arch_profile:
11412           if (out_attr[i].i != in_attr[i].i)
11413             {
11414               /* 0 will merge with anything.
11415                  'A' and 'S' merge to 'A'.
11416                  'R' and 'S' merge to 'R'.
11417                  'M' and 'A|R|S' is an error.  */
11418               if (out_attr[i].i == 0
11419                   || (out_attr[i].i == 'S'
11420                       && (in_attr[i].i == 'A' || in_attr[i].i == 'R')))
11421                 out_attr[i].i = in_attr[i].i;
11422               else if (in_attr[i].i == 0
11423                        || (in_attr[i].i == 'S'
11424                            && (out_attr[i].i == 'A' || out_attr[i].i == 'R')))
11425                 ; /* Do nothing. */
11426               else
11427                 {
11428                   _bfd_error_handler
11429                     (_("error: %B: Conflicting architecture profiles %c/%c"),
11430                      ibfd,
11431                      in_attr[i].i ? in_attr[i].i : '0',
11432                      out_attr[i].i ? out_attr[i].i : '0');
11433                   result = FALSE;
11434                 }
11435             }
11436           break;
11437         case Tag_FP_arch:
11438             {
11439               /* Tag_ABI_HardFP_use is handled along with Tag_FP_arch since
11440                  the meaning of Tag_ABI_HardFP_use depends on Tag_FP_arch
11441                  when it's 0.  It might mean absence of FP hardware if
11442                  Tag_FP_arch is zero, otherwise it is effectively SP + DP.  */
11443
11444               static const struct
11445               {
11446                   int ver;
11447                   int regs;
11448               } vfp_versions[7] =
11449                 {
11450                   {0, 0},
11451                   {1, 16},
11452                   {2, 16},
11453                   {3, 32},
11454                   {3, 16},
11455                   {4, 32},
11456                   {4, 16}
11457                 };
11458               int ver;
11459               int regs;
11460               int newval;
11461
11462               /* If the output has no requirement about FP hardware,
11463                  follow the requirement of the input.  */
11464               if (out_attr[i].i == 0)
11465                 {
11466                   BFD_ASSERT (out_attr[Tag_ABI_HardFP_use].i == 0);
11467                   out_attr[i].i = in_attr[i].i;
11468                   out_attr[Tag_ABI_HardFP_use].i
11469                     = in_attr[Tag_ABI_HardFP_use].i;
11470                   break;
11471                 }
11472               /* If the input has no requirement about FP hardware, do
11473                  nothing.  */
11474               else if (in_attr[i].i == 0)
11475                 {
11476                   BFD_ASSERT (in_attr[Tag_ABI_HardFP_use].i == 0);
11477                   break;
11478                 }
11479
11480               /* Both the input and the output have nonzero Tag_FP_arch.
11481                  So Tag_ABI_HardFP_use is (SP & DP) when it's zero.  */
11482
11483               /* If both the input and the output have zero Tag_ABI_HardFP_use,
11484                  do nothing.  */
11485               if (in_attr[Tag_ABI_HardFP_use].i == 0
11486                   && out_attr[Tag_ABI_HardFP_use].i == 0)
11487                 ;
11488               /* If the input and the output have different Tag_ABI_HardFP_use,
11489                  the combination of them is 3 (SP & DP).  */
11490               else if (in_attr[Tag_ABI_HardFP_use].i
11491                        != out_attr[Tag_ABI_HardFP_use].i)
11492                 out_attr[Tag_ABI_HardFP_use].i = 3;
11493
11494               /* Now we can handle Tag_FP_arch.  */
11495
11496               /* Values greater than 6 aren't defined, so just pick the
11497                  biggest */
11498               if (in_attr[i].i > 6 && in_attr[i].i > out_attr[i].i)
11499                 {
11500                   out_attr[i] = in_attr[i];
11501                   break;
11502                 }
11503               /* The output uses the superset of input features
11504                  (ISA version) and registers.  */
11505               ver = vfp_versions[in_attr[i].i].ver;
11506               if (ver < vfp_versions[out_attr[i].i].ver)
11507                 ver = vfp_versions[out_attr[i].i].ver;
11508               regs = vfp_versions[in_attr[i].i].regs;
11509               if (regs < vfp_versions[out_attr[i].i].regs)
11510                 regs = vfp_versions[out_attr[i].i].regs;
11511               /* This assumes all possible supersets are also a valid
11512                  options.  */
11513               for (newval = 6; newval > 0; newval--)
11514                 {
11515                   if (regs == vfp_versions[newval].regs
11516                       && ver == vfp_versions[newval].ver)
11517                     break;
11518                 }
11519               out_attr[i].i = newval;
11520             }
11521           break;
11522         case Tag_PCS_config:
11523           if (out_attr[i].i == 0)
11524             out_attr[i].i = in_attr[i].i;
11525           else if (in_attr[i].i != 0 && out_attr[i].i != 0)
11526             {
11527               /* It's sometimes ok to mix different configs, so this is only
11528                  a warning.  */
11529               _bfd_error_handler
11530                 (_("Warning: %B: Conflicting platform configuration"), ibfd);
11531             }
11532           break;
11533         case Tag_ABI_PCS_R9_use:
11534           if (in_attr[i].i != out_attr[i].i
11535               && out_attr[i].i != AEABI_R9_unused
11536               && in_attr[i].i != AEABI_R9_unused)
11537             {
11538               _bfd_error_handler
11539                 (_("error: %B: Conflicting use of R9"), ibfd);
11540               result = FALSE;
11541             }
11542           if (out_attr[i].i == AEABI_R9_unused)
11543             out_attr[i].i = in_attr[i].i;
11544           break;
11545         case Tag_ABI_PCS_RW_data:
11546           if (in_attr[i].i == AEABI_PCS_RW_data_SBrel
11547               && out_attr[Tag_ABI_PCS_R9_use].i != AEABI_R9_SB
11548               && out_attr[Tag_ABI_PCS_R9_use].i != AEABI_R9_unused)
11549             {
11550               _bfd_error_handler
11551                 (_("error: %B: SB relative addressing conflicts with use of R9"),
11552                  ibfd);
11553               result = FALSE;
11554             }
11555           /* Use the smallest value specified.  */
11556           if (in_attr[i].i < out_attr[i].i)
11557             out_attr[i].i = in_attr[i].i;
11558           break;
11559         case Tag_ABI_PCS_wchar_t:
11560           if (out_attr[i].i && in_attr[i].i && out_attr[i].i != in_attr[i].i
11561               && !elf_arm_tdata (obfd)->no_wchar_size_warning)
11562             {
11563               _bfd_error_handler
11564                 (_("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"),
11565                  ibfd, in_attr[i].i, out_attr[i].i);
11566             }
11567           else if (in_attr[i].i && !out_attr[i].i)
11568             out_attr[i].i = in_attr[i].i;
11569           break;
11570         case Tag_ABI_enum_size:
11571           if (in_attr[i].i != AEABI_enum_unused)
11572             {
11573               if (out_attr[i].i == AEABI_enum_unused
11574                   || out_attr[i].i == AEABI_enum_forced_wide)
11575                 {
11576                   /* The existing object is compatible with anything.
11577                      Use whatever requirements the new object has.  */
11578                   out_attr[i].i = in_attr[i].i;
11579                 }
11580               else if (in_attr[i].i != AEABI_enum_forced_wide
11581                        && out_attr[i].i != in_attr[i].i
11582                        && !elf_arm_tdata (obfd)->no_enum_size_warning)
11583                 {
11584                   static const char *aeabi_enum_names[] =
11585                     { "", "variable-size", "32-bit", "" };
11586                   const char *in_name =
11587                     in_attr[i].i < ARRAY_SIZE(aeabi_enum_names)
11588                     ? aeabi_enum_names[in_attr[i].i]
11589                     : "<unknown>";
11590                   const char *out_name =
11591                     out_attr[i].i < ARRAY_SIZE(aeabi_enum_names)
11592                     ? aeabi_enum_names[out_attr[i].i]
11593                     : "<unknown>";
11594                   _bfd_error_handler
11595                     (_("warning: %B uses %s enums yet the output is to use %s enums; use of enum values across objects may fail"),
11596                      ibfd, in_name, out_name);
11597                 }
11598             }
11599           break;
11600         case Tag_ABI_VFP_args:
11601           /* Aready done.  */
11602           break;
11603         case Tag_ABI_WMMX_args:
11604           if (in_attr[i].i != out_attr[i].i)
11605             {
11606               _bfd_error_handler
11607                 (_("error: %B uses iWMMXt register arguments, %B does not"),
11608                  ibfd, obfd);
11609               result = FALSE;
11610             }
11611           break;
11612         case Tag_compatibility:
11613           /* Merged in target-independent code.  */
11614           break;
11615         case Tag_ABI_HardFP_use:
11616           /* This is handled along with Tag_FP_arch.  */
11617           break;
11618         case Tag_ABI_FP_16bit_format:
11619           if (in_attr[i].i != 0 && out_attr[i].i != 0)
11620             {
11621               if (in_attr[i].i != out_attr[i].i)
11622                 {
11623                   _bfd_error_handler
11624                     (_("error: fp16 format mismatch between %B and %B"),
11625                      ibfd, obfd);
11626                   result = FALSE;
11627                 }
11628             }
11629           if (in_attr[i].i != 0)
11630             out_attr[i].i = in_attr[i].i;
11631           break;
11632
11633         case Tag_DIV_use:
11634           /* This tag is set to zero if we can use UDIV and SDIV in Thumb
11635              mode on a v7-M or v7-R CPU; to one if we can not use UDIV or
11636              SDIV at all; and to two if we can use UDIV or SDIV on a v7-A
11637              CPU.  We will merge as follows: If the input attribute's value
11638              is one then the output attribute's value remains unchanged.  If
11639              the input attribute's value is zero or two then if the output
11640              attribute's value is one the output value is set to the input
11641              value, otherwise the output value must be the same as the
11642              inputs.  */
11643           if (in_attr[i].i != 1 && out_attr[i].i != 1)
11644             {
11645               if (in_attr[i].i != out_attr[i].i)
11646                 {
11647                   _bfd_error_handler
11648                     (_("DIV usage mismatch between %B and %B"),
11649                      ibfd, obfd);
11650                   result = FALSE;
11651                 }
11652             }
11653
11654           if (in_attr[i].i != 1)
11655             out_attr[i].i = in_attr[i].i;
11656
11657           break;
11658
11659         case Tag_MPextension_use_legacy:
11660           /* We don't output objects with Tag_MPextension_use_legacy - we
11661              move the value to Tag_MPextension_use.  */
11662           if (in_attr[i].i != 0 && in_attr[Tag_MPextension_use].i != 0)
11663             {
11664               if (in_attr[Tag_MPextension_use].i != in_attr[i].i)
11665                 {
11666                   _bfd_error_handler
11667                     (_("%B has has both the current and legacy "
11668                        "Tag_MPextension_use attributes"),
11669                      ibfd);
11670                   result = FALSE;
11671                 }
11672             }
11673
11674           if (in_attr[i].i > out_attr[Tag_MPextension_use].i)
11675             out_attr[Tag_MPextension_use] = in_attr[i];
11676
11677           break;
11678
11679         case Tag_nodefaults:
11680           /* This tag is set if it exists, but the value is unused (and is
11681              typically zero).  We don't actually need to do anything here -
11682              the merge happens automatically when the type flags are merged
11683              below.  */
11684           break;
11685         case Tag_also_compatible_with:
11686           /* Already done in Tag_CPU_arch.  */
11687           break;
11688         case Tag_conformance:
11689           /* Keep the attribute if it matches.  Throw it away otherwise.
11690              No attribute means no claim to conform.  */
11691           if (!in_attr[i].s || !out_attr[i].s
11692               || strcmp (in_attr[i].s, out_attr[i].s) != 0)
11693             out_attr[i].s = NULL;
11694           break;
11695
11696         default:
11697           result
11698             = result && _bfd_elf_merge_unknown_attribute_low (ibfd, obfd, i);
11699         }
11700
11701       /* If out_attr was copied from in_attr then it won't have a type yet.  */
11702       if (in_attr[i].type && !out_attr[i].type)
11703         out_attr[i].type = in_attr[i].type;
11704     }
11705
11706   /* Merge Tag_compatibility attributes and any common GNU ones.  */
11707   if (!_bfd_elf_merge_object_attributes (ibfd, obfd))
11708     return FALSE;
11709
11710   /* Check for any attributes not known on ARM.  */
11711   result &= _bfd_elf_merge_unknown_attribute_list (ibfd, obfd);
11712
11713   return result;
11714 }
11715
11716
11717 /* Return TRUE if the two EABI versions are incompatible.  */
11718
11719 static bfd_boolean
11720 elf32_arm_versions_compatible (unsigned iver, unsigned over)
11721 {
11722   /* v4 and v5 are the same spec before and after it was released,
11723      so allow mixing them.  */
11724   if ((iver == EF_ARM_EABI_VER4 && over == EF_ARM_EABI_VER5)
11725       || (iver == EF_ARM_EABI_VER5 && over == EF_ARM_EABI_VER4))
11726     return TRUE;
11727
11728   return (iver == over);
11729 }
11730
11731 /* Merge backend specific data from an object file to the output
11732    object file when linking.  */
11733
11734 static bfd_boolean
11735 elf32_arm_merge_private_bfd_data (bfd * ibfd, bfd * obfd);
11736
11737 /* Display the flags field.  */
11738
11739 static bfd_boolean
11740 elf32_arm_print_private_bfd_data (bfd *abfd, void * ptr)
11741 {
11742   FILE * file = (FILE *) ptr;
11743   unsigned long flags;
11744
11745   BFD_ASSERT (abfd != NULL && ptr != NULL);
11746
11747   /* Print normal ELF private data.  */
11748   _bfd_elf_print_private_bfd_data (abfd, ptr);
11749
11750   flags = elf_elfheader (abfd)->e_flags;
11751   /* Ignore init flag - it may not be set, despite the flags field
11752      containing valid data.  */
11753
11754   /* xgettext:c-format */
11755   fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
11756
11757   switch (EF_ARM_EABI_VERSION (flags))
11758     {
11759     case EF_ARM_EABI_UNKNOWN:
11760       /* The following flag bits are GNU extensions and not part of the
11761          official ARM ELF extended ABI.  Hence they are only decoded if
11762          the EABI version is not set.  */
11763       if (flags & EF_ARM_INTERWORK)
11764         fprintf (file, _(" [interworking enabled]"));
11765
11766       if (flags & EF_ARM_APCS_26)
11767         fprintf (file, " [APCS-26]");
11768       else
11769         fprintf (file, " [APCS-32]");
11770
11771       if (flags & EF_ARM_VFP_FLOAT)
11772         fprintf (file, _(" [VFP float format]"));
11773       else if (flags & EF_ARM_MAVERICK_FLOAT)
11774         fprintf (file, _(" [Maverick float format]"));
11775       else
11776         fprintf (file, _(" [FPA float format]"));
11777
11778       if (flags & EF_ARM_APCS_FLOAT)
11779         fprintf (file, _(" [floats passed in float registers]"));
11780
11781       if (flags & EF_ARM_PIC)
11782         fprintf (file, _(" [position independent]"));
11783
11784       if (flags & EF_ARM_NEW_ABI)
11785         fprintf (file, _(" [new ABI]"));
11786
11787       if (flags & EF_ARM_OLD_ABI)
11788         fprintf (file, _(" [old ABI]"));
11789
11790       if (flags & EF_ARM_SOFT_FLOAT)
11791         fprintf (file, _(" [software FP]"));
11792
11793       flags &= ~(EF_ARM_INTERWORK | EF_ARM_APCS_26 | EF_ARM_APCS_FLOAT
11794                  | EF_ARM_PIC | EF_ARM_NEW_ABI | EF_ARM_OLD_ABI
11795                  | EF_ARM_SOFT_FLOAT | EF_ARM_VFP_FLOAT
11796                  | EF_ARM_MAVERICK_FLOAT);
11797       break;
11798
11799     case EF_ARM_EABI_VER1:
11800       fprintf (file, _(" [Version1 EABI]"));
11801
11802       if (flags & EF_ARM_SYMSARESORTED)
11803         fprintf (file, _(" [sorted symbol table]"));
11804       else
11805         fprintf (file, _(" [unsorted symbol table]"));
11806
11807       flags &= ~ EF_ARM_SYMSARESORTED;
11808       break;
11809
11810     case EF_ARM_EABI_VER2:
11811       fprintf (file, _(" [Version2 EABI]"));
11812
11813       if (flags & EF_ARM_SYMSARESORTED)
11814         fprintf (file, _(" [sorted symbol table]"));
11815       else
11816         fprintf (file, _(" [unsorted symbol table]"));
11817
11818       if (flags & EF_ARM_DYNSYMSUSESEGIDX)
11819         fprintf (file, _(" [dynamic symbols use segment index]"));
11820
11821       if (flags & EF_ARM_MAPSYMSFIRST)
11822         fprintf (file, _(" [mapping symbols precede others]"));
11823
11824       flags &= ~(EF_ARM_SYMSARESORTED | EF_ARM_DYNSYMSUSESEGIDX
11825                  | EF_ARM_MAPSYMSFIRST);
11826       break;
11827
11828     case EF_ARM_EABI_VER3:
11829       fprintf (file, _(" [Version3 EABI]"));
11830       break;
11831
11832     case EF_ARM_EABI_VER4:
11833       fprintf (file, _(" [Version4 EABI]"));
11834       goto eabi;
11835
11836     case EF_ARM_EABI_VER5:
11837       fprintf (file, _(" [Version5 EABI]"));
11838     eabi:
11839       if (flags & EF_ARM_BE8)
11840         fprintf (file, _(" [BE8]"));
11841
11842       if (flags & EF_ARM_LE8)
11843         fprintf (file, _(" [LE8]"));
11844
11845       flags &= ~(EF_ARM_LE8 | EF_ARM_BE8);
11846       break;
11847
11848     default:
11849       fprintf (file, _(" <EABI version unrecognised>"));
11850       break;
11851     }
11852
11853   flags &= ~ EF_ARM_EABIMASK;
11854
11855   if (flags & EF_ARM_RELEXEC)
11856     fprintf (file, _(" [relocatable executable]"));
11857
11858   if (flags & EF_ARM_HASENTRY)
11859     fprintf (file, _(" [has entry point]"));
11860
11861   flags &= ~ (EF_ARM_RELEXEC | EF_ARM_HASENTRY);
11862
11863   if (flags)
11864     fprintf (file, _("<Unrecognised flag bits set>"));
11865
11866   fputc ('\n', file);
11867
11868   return TRUE;
11869 }
11870
11871 static int
11872 elf32_arm_get_symbol_type (Elf_Internal_Sym * elf_sym, int type)
11873 {
11874   switch (ELF_ST_TYPE (elf_sym->st_info))
11875     {
11876     case STT_ARM_TFUNC:
11877       return ELF_ST_TYPE (elf_sym->st_info);
11878
11879     case STT_ARM_16BIT:
11880       /* If the symbol is not an object, return the STT_ARM_16BIT flag.
11881          This allows us to distinguish between data used by Thumb instructions
11882          and non-data (which is probably code) inside Thumb regions of an
11883          executable.  */
11884       if (type != STT_OBJECT && type != STT_TLS)
11885         return ELF_ST_TYPE (elf_sym->st_info);
11886       break;
11887
11888     default:
11889       break;
11890     }
11891
11892   return type;
11893 }
11894
11895 static asection *
11896 elf32_arm_gc_mark_hook (asection *sec,
11897                         struct bfd_link_info *info,
11898                         Elf_Internal_Rela *rel,
11899                         struct elf_link_hash_entry *h,
11900                         Elf_Internal_Sym *sym)
11901 {
11902   if (h != NULL)
11903     switch (ELF32_R_TYPE (rel->r_info))
11904       {
11905       case R_ARM_GNU_VTINHERIT:
11906       case R_ARM_GNU_VTENTRY:
11907         return NULL;
11908       }
11909
11910   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
11911 }
11912
11913 /* Update the got entry reference counts for the section being removed.  */
11914
11915 static bfd_boolean
11916 elf32_arm_gc_sweep_hook (bfd *                     abfd,
11917                          struct bfd_link_info *    info,
11918                          asection *                sec,
11919                          const Elf_Internal_Rela * relocs)
11920 {
11921   Elf_Internal_Shdr *symtab_hdr;
11922   struct elf_link_hash_entry **sym_hashes;
11923   bfd_signed_vma *local_got_refcounts;
11924   const Elf_Internal_Rela *rel, *relend;
11925   struct elf32_arm_link_hash_table * globals;
11926
11927   if (info->relocatable)
11928     return TRUE;
11929
11930   globals = elf32_arm_hash_table (info);
11931   if (globals == NULL)
11932     return FALSE;
11933
11934   elf_section_data (sec)->local_dynrel = NULL;
11935
11936   symtab_hdr = & elf_symtab_hdr (abfd);
11937   sym_hashes = elf_sym_hashes (abfd);
11938   local_got_refcounts = elf_local_got_refcounts (abfd);
11939
11940   check_use_blx (globals);
11941
11942   relend = relocs + sec->reloc_count;
11943   for (rel = relocs; rel < relend; rel++)
11944     {
11945       unsigned long r_symndx;
11946       struct elf_link_hash_entry *h = NULL;
11947       struct elf32_arm_link_hash_entry *eh;
11948       int r_type;
11949       bfd_boolean call_reloc_p;
11950       bfd_boolean may_become_dynamic_p;
11951       bfd_boolean may_need_local_target_p;
11952       union gotplt_union *root_plt;
11953       struct arm_plt_info *arm_plt;
11954
11955       r_symndx = ELF32_R_SYM (rel->r_info);
11956       if (r_symndx >= symtab_hdr->sh_info)
11957         {
11958           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
11959           while (h->root.type == bfd_link_hash_indirect
11960                  || h->root.type == bfd_link_hash_warning)
11961             h = (struct elf_link_hash_entry *) h->root.u.i.link;
11962         }
11963       eh = (struct elf32_arm_link_hash_entry *) h;
11964
11965       call_reloc_p = FALSE;
11966       may_become_dynamic_p = FALSE;
11967       may_need_local_target_p = FALSE;
11968
11969       r_type = ELF32_R_TYPE (rel->r_info);
11970       r_type = arm_real_reloc_type (globals, r_type);
11971       switch (r_type)
11972         {
11973         case R_ARM_GOT32:
11974         case R_ARM_GOT_PREL:
11975         case R_ARM_TLS_GD32:
11976         case R_ARM_TLS_IE32:
11977           if (h != NULL)
11978             {
11979               if (h->got.refcount > 0)
11980                 h->got.refcount -= 1;
11981             }
11982           else if (local_got_refcounts != NULL)
11983             {
11984               if (local_got_refcounts[r_symndx] > 0)
11985                 local_got_refcounts[r_symndx] -= 1;
11986             }
11987           break;
11988
11989         case R_ARM_TLS_LDM32:
11990           globals->tls_ldm_got.refcount -= 1;
11991           break;
11992
11993         case R_ARM_PC24:
11994         case R_ARM_PLT32:
11995         case R_ARM_CALL:
11996         case R_ARM_JUMP24:
11997         case R_ARM_PREL31:
11998         case R_ARM_THM_CALL:
11999         case R_ARM_THM_JUMP24:
12000         case R_ARM_THM_JUMP19:
12001           call_reloc_p = TRUE;
12002           may_need_local_target_p = TRUE;
12003           break;
12004
12005         case R_ARM_ABS12:
12006           if (!globals->vxworks_p)
12007             {
12008               may_need_local_target_p = TRUE;
12009               break;
12010             }
12011           /* Fall through.  */
12012         case R_ARM_ABS32:
12013         case R_ARM_ABS32_NOI:
12014         case R_ARM_REL32:
12015         case R_ARM_REL32_NOI:
12016         case R_ARM_MOVW_ABS_NC:
12017         case R_ARM_MOVT_ABS:
12018         case R_ARM_MOVW_PREL_NC:
12019         case R_ARM_MOVT_PREL:
12020         case R_ARM_THM_MOVW_ABS_NC:
12021         case R_ARM_THM_MOVT_ABS:
12022         case R_ARM_THM_MOVW_PREL_NC:
12023         case R_ARM_THM_MOVT_PREL:
12024           /* Should the interworking branches be here also?  */
12025           if ((info->shared || globals->root.is_relocatable_executable)
12026               && (sec->flags & SEC_ALLOC) != 0)
12027             {
12028               if (h == NULL
12029                   && (r_type == R_ARM_REL32 || r_type == R_ARM_REL32_NOI))
12030                 {
12031                   call_reloc_p = TRUE;
12032                   may_need_local_target_p = TRUE;
12033                 }
12034               else
12035                 may_become_dynamic_p = TRUE;
12036             }
12037           else
12038             may_need_local_target_p = TRUE;
12039           break;
12040
12041         default:
12042           break;
12043         }
12044
12045       if (may_need_local_target_p
12046           && elf32_arm_get_plt_info (abfd, eh, r_symndx, &root_plt, &arm_plt))
12047         {
12048           BFD_ASSERT (root_plt->refcount > 0);
12049           root_plt->refcount -= 1;
12050
12051           if (!call_reloc_p)
12052             arm_plt->noncall_refcount--;
12053
12054           if (r_type == R_ARM_THM_CALL)
12055             arm_plt->maybe_thumb_refcount--;
12056
12057           if (r_type == R_ARM_THM_JUMP24
12058               || r_type == R_ARM_THM_JUMP19)
12059             arm_plt->thumb_refcount--;
12060         }
12061
12062       if (may_become_dynamic_p)
12063         {
12064           struct elf_dyn_relocs **pp;
12065           struct elf_dyn_relocs *p;
12066
12067           if (h != NULL)
12068             pp = &(eh->dyn_relocs);
12069           else
12070             {
12071               Elf_Internal_Sym *isym;
12072
12073               isym = bfd_sym_from_r_symndx (&globals->sym_cache,
12074                                             abfd, r_symndx);
12075               if (isym == NULL)
12076                 return FALSE;
12077               pp = elf32_arm_get_local_dynreloc_list (abfd, r_symndx, isym);
12078               if (pp == NULL)
12079                 return FALSE;
12080             }
12081           for (; (p = *pp) != NULL; pp = &p->next)
12082             if (p->sec == sec)
12083               {
12084                 /* Everything must go for SEC.  */
12085                 *pp = p->next;
12086                 break;
12087               }
12088         }
12089     }
12090
12091   return TRUE;
12092 }
12093
12094 /* Look through the relocs for a section during the first phase.  */
12095
12096 static bfd_boolean
12097 elf32_arm_check_relocs (bfd *abfd, struct bfd_link_info *info,
12098                         asection *sec, const Elf_Internal_Rela *relocs)
12099 {
12100   Elf_Internal_Shdr *symtab_hdr;
12101   struct elf_link_hash_entry **sym_hashes;
12102   const Elf_Internal_Rela *rel;
12103   const Elf_Internal_Rela *rel_end;
12104   bfd *dynobj;
12105   asection *sreloc;
12106   struct elf32_arm_link_hash_table *htab;
12107   bfd_boolean call_reloc_p;
12108   bfd_boolean may_become_dynamic_p;
12109   bfd_boolean may_need_local_target_p;
12110   unsigned long nsyms;
12111
12112   if (info->relocatable)
12113     return TRUE;
12114
12115   BFD_ASSERT (is_arm_elf (abfd));
12116
12117   htab = elf32_arm_hash_table (info);
12118   if (htab == NULL)
12119     return FALSE;
12120
12121   sreloc = NULL;
12122
12123   /* Create dynamic sections for relocatable executables so that we can
12124      copy relocations.  */
12125   if (htab->root.is_relocatable_executable
12126       && ! htab->root.dynamic_sections_created)
12127     {
12128       if (! _bfd_elf_link_create_dynamic_sections (abfd, info))
12129         return FALSE;
12130     }
12131
12132   if (htab->root.dynobj == NULL)
12133     htab->root.dynobj = abfd;
12134   if (!create_ifunc_sections (info))
12135     return FALSE;
12136
12137   dynobj = htab->root.dynobj;
12138
12139   symtab_hdr = & elf_symtab_hdr (abfd);
12140   sym_hashes = elf_sym_hashes (abfd);
12141   nsyms = NUM_SHDR_ENTRIES (symtab_hdr);
12142
12143   rel_end = relocs + sec->reloc_count;
12144   for (rel = relocs; rel < rel_end; rel++)
12145     {
12146       Elf_Internal_Sym *isym;
12147       struct elf_link_hash_entry *h;
12148       struct elf32_arm_link_hash_entry *eh;
12149       unsigned long r_symndx;
12150       int r_type;
12151
12152       r_symndx = ELF32_R_SYM (rel->r_info);
12153       r_type = ELF32_R_TYPE (rel->r_info);
12154       r_type = arm_real_reloc_type (htab, r_type);
12155
12156       if (r_symndx >= nsyms
12157           /* PR 9934: It is possible to have relocations that do not
12158              refer to symbols, thus it is also possible to have an
12159              object file containing relocations but no symbol table.  */
12160           && (r_symndx > STN_UNDEF || nsyms > 0))
12161         {
12162           (*_bfd_error_handler) (_("%B: bad symbol index: %d"), abfd,
12163                                    r_symndx);
12164           return FALSE;
12165         }
12166
12167       h = NULL;
12168       isym = NULL;
12169       if (nsyms > 0)
12170         {
12171           if (r_symndx < symtab_hdr->sh_info)
12172             {
12173               /* A local symbol.  */
12174               isym = bfd_sym_from_r_symndx (&htab->sym_cache,
12175                                             abfd, r_symndx);
12176               if (isym == NULL)
12177                 return FALSE;
12178             }
12179           else
12180             {
12181               h = sym_hashes[r_symndx - symtab_hdr->sh_info];
12182               while (h->root.type == bfd_link_hash_indirect
12183                      || h->root.type == bfd_link_hash_warning)
12184                 h = (struct elf_link_hash_entry *) h->root.u.i.link;
12185             }
12186         }
12187
12188       eh = (struct elf32_arm_link_hash_entry *) h;
12189
12190       call_reloc_p = FALSE;
12191       may_become_dynamic_p = FALSE;
12192       may_need_local_target_p = FALSE;
12193
12194       /* Could be done earlier, if h were already available.  */
12195       r_type = elf32_arm_tls_transition (info, r_type, h);
12196       switch (r_type)
12197         {
12198           case R_ARM_GOT32:
12199           case R_ARM_GOT_PREL:
12200           case R_ARM_TLS_GD32:
12201           case R_ARM_TLS_IE32:
12202           case R_ARM_TLS_GOTDESC:
12203           case R_ARM_TLS_DESCSEQ:
12204           case R_ARM_THM_TLS_DESCSEQ:
12205           case R_ARM_TLS_CALL:
12206           case R_ARM_THM_TLS_CALL:
12207             /* This symbol requires a global offset table entry.  */
12208             {
12209               int tls_type, old_tls_type;
12210
12211               switch (r_type)
12212                 {
12213                 case R_ARM_TLS_GD32: tls_type = GOT_TLS_GD; break;
12214
12215                 case R_ARM_TLS_IE32: tls_type = GOT_TLS_IE; break;
12216
12217                 case R_ARM_TLS_GOTDESC:
12218                 case R_ARM_TLS_CALL: case R_ARM_THM_TLS_CALL:
12219                 case R_ARM_TLS_DESCSEQ: case R_ARM_THM_TLS_DESCSEQ:
12220                   tls_type = GOT_TLS_GDESC; break;
12221
12222                 default: tls_type = GOT_NORMAL; break;
12223                 }
12224
12225               if (h != NULL)
12226                 {
12227                   h->got.refcount++;
12228                   old_tls_type = elf32_arm_hash_entry (h)->tls_type;
12229                 }
12230               else
12231                 {
12232                   /* This is a global offset table entry for a local symbol.  */
12233                   if (!elf32_arm_allocate_local_sym_info (abfd))
12234                     return FALSE;
12235                   elf_local_got_refcounts (abfd)[r_symndx] += 1;
12236                   old_tls_type = elf32_arm_local_got_tls_type (abfd) [r_symndx];
12237                 }
12238
12239               /* If a variable is accessed with both tls methods, two
12240                  slots may be created.  */
12241               if (GOT_TLS_GD_ANY_P (old_tls_type)
12242                   && GOT_TLS_GD_ANY_P (tls_type))
12243                 tls_type |= old_tls_type;
12244
12245               /* We will already have issued an error message if there
12246                  is a TLS/non-TLS mismatch, based on the symbol
12247                  type.  So just combine any TLS types needed.  */
12248               if (old_tls_type != GOT_UNKNOWN && old_tls_type != GOT_NORMAL
12249                   && tls_type != GOT_NORMAL)
12250                 tls_type |= old_tls_type;
12251
12252               /* If the symbol is accessed in both IE and GDESC
12253                  method, we're able to relax. Turn off the GDESC flag,
12254                  without messing up with any other kind of tls types
12255                  that may be involved */
12256               if ((tls_type & GOT_TLS_IE) && (tls_type & GOT_TLS_GDESC))
12257                 tls_type &= ~GOT_TLS_GDESC;
12258
12259               if (old_tls_type != tls_type)
12260                 {
12261                   if (h != NULL)
12262                     elf32_arm_hash_entry (h)->tls_type = tls_type;
12263                   else
12264                     elf32_arm_local_got_tls_type (abfd) [r_symndx] = tls_type;
12265                 }
12266             }
12267             /* Fall through.  */
12268
12269           case R_ARM_TLS_LDM32:
12270             if (r_type == R_ARM_TLS_LDM32)
12271                 htab->tls_ldm_got.refcount++;
12272             /* Fall through.  */
12273
12274           case R_ARM_GOTOFF32:
12275           case R_ARM_GOTPC:
12276             if (htab->root.sgot == NULL
12277                 && !create_got_section (htab->root.dynobj, info))
12278               return FALSE;
12279             break;
12280
12281           case R_ARM_PC24:
12282           case R_ARM_PLT32:
12283           case R_ARM_CALL:
12284           case R_ARM_JUMP24:
12285           case R_ARM_PREL31:
12286           case R_ARM_THM_CALL:
12287           case R_ARM_THM_JUMP24:
12288           case R_ARM_THM_JUMP19:
12289             call_reloc_p = TRUE;
12290             may_need_local_target_p = TRUE;
12291             break;
12292
12293           case R_ARM_ABS12:
12294             /* VxWorks uses dynamic R_ARM_ABS12 relocations for
12295                ldr __GOTT_INDEX__ offsets.  */
12296             if (!htab->vxworks_p)
12297               {
12298                 may_need_local_target_p = TRUE;
12299                 break;
12300               }
12301             /* Fall through.  */
12302
12303           case R_ARM_MOVW_ABS_NC:
12304           case R_ARM_MOVT_ABS:
12305           case R_ARM_THM_MOVW_ABS_NC:
12306           case R_ARM_THM_MOVT_ABS:
12307             if (info->shared)
12308               {
12309                 (*_bfd_error_handler)
12310                   (_("%B: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
12311                    abfd, elf32_arm_howto_table_1[r_type].name,
12312                    (h) ? h->root.root.string : "a local symbol");
12313                 bfd_set_error (bfd_error_bad_value);
12314                 return FALSE;
12315               }
12316
12317             /* Fall through.  */
12318           case R_ARM_ABS32:
12319           case R_ARM_ABS32_NOI:
12320           case R_ARM_REL32:
12321           case R_ARM_REL32_NOI:
12322           case R_ARM_MOVW_PREL_NC:
12323           case R_ARM_MOVT_PREL:
12324           case R_ARM_THM_MOVW_PREL_NC:
12325           case R_ARM_THM_MOVT_PREL:
12326
12327             /* Should the interworking branches be listed here?  */
12328             if ((info->shared || htab->root.is_relocatable_executable)
12329                 && (sec->flags & SEC_ALLOC) != 0)
12330               {
12331                 if (h == NULL
12332                     && (r_type == R_ARM_REL32 || r_type == R_ARM_REL32_NOI))
12333                   {
12334                     /* In shared libraries and relocatable executables,
12335                        we treat local relative references as calls;
12336                        see the related SYMBOL_CALLS_LOCAL code in
12337                        allocate_dynrelocs.  */
12338                     call_reloc_p = TRUE;
12339                     may_need_local_target_p = TRUE;
12340                   }
12341                 else
12342                   /* We are creating a shared library or relocatable
12343                      executable, and this is a reloc against a global symbol,
12344                      or a non-PC-relative reloc against a local symbol.
12345                      We may need to copy the reloc into the output.  */
12346                   may_become_dynamic_p = TRUE;
12347               }
12348             else
12349               may_need_local_target_p = TRUE;
12350             break;
12351
12352         /* This relocation describes the C++ object vtable hierarchy.
12353            Reconstruct it for later use during GC.  */
12354         case R_ARM_GNU_VTINHERIT:
12355           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
12356             return FALSE;
12357           break;
12358
12359         /* This relocation describes which C++ vtable entries are actually
12360            used.  Record for later use during GC.  */
12361         case R_ARM_GNU_VTENTRY:
12362           BFD_ASSERT (h != NULL);
12363           if (h != NULL
12364               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
12365             return FALSE;
12366           break;
12367         }
12368
12369       if (h != NULL)
12370         {
12371           if (call_reloc_p)
12372             /* We may need a .plt entry if the function this reloc
12373                refers to is in a different object, regardless of the
12374                symbol's type.  We can't tell for sure yet, because
12375                something later might force the symbol local.  */
12376             h->needs_plt = 1;
12377           else if (may_need_local_target_p)
12378             /* If this reloc is in a read-only section, we might
12379                need a copy reloc.  We can't check reliably at this
12380                stage whether the section is read-only, as input
12381                sections have not yet been mapped to output sections.
12382                Tentatively set the flag for now, and correct in
12383                adjust_dynamic_symbol.  */
12384             h->non_got_ref = 1;
12385         }
12386
12387       if (may_need_local_target_p
12388           && (h != NULL || ELF32_ST_TYPE (isym->st_info) == STT_GNU_IFUNC))
12389         {
12390           union gotplt_union *root_plt;
12391           struct arm_plt_info *arm_plt;
12392           struct arm_local_iplt_info *local_iplt;
12393
12394           if (h != NULL)
12395             {
12396               root_plt = &h->plt;
12397               arm_plt = &eh->plt;
12398             }
12399           else
12400             {
12401               local_iplt = elf32_arm_create_local_iplt (abfd, r_symndx);
12402               if (local_iplt == NULL)
12403                 return FALSE;
12404               root_plt = &local_iplt->root;
12405               arm_plt = &local_iplt->arm;
12406             }
12407
12408           /* If the symbol is a function that doesn't bind locally,
12409              this relocation will need a PLT entry.  */
12410           root_plt->refcount += 1;
12411
12412           if (!call_reloc_p)
12413             arm_plt->noncall_refcount++;
12414
12415           /* It's too early to use htab->use_blx here, so we have to
12416              record possible blx references separately from
12417              relocs that definitely need a thumb stub.  */
12418
12419           if (r_type == R_ARM_THM_CALL)
12420             arm_plt->maybe_thumb_refcount += 1;
12421
12422           if (r_type == R_ARM_THM_JUMP24
12423               || r_type == R_ARM_THM_JUMP19)
12424             arm_plt->thumb_refcount += 1;
12425         }
12426
12427       if (may_become_dynamic_p)
12428         {
12429           struct elf_dyn_relocs *p, **head;
12430
12431           /* Create a reloc section in dynobj.  */
12432           if (sreloc == NULL)
12433             {
12434               sreloc = _bfd_elf_make_dynamic_reloc_section
12435                 (sec, dynobj, 2, abfd, ! htab->use_rel);
12436
12437               if (sreloc == NULL)
12438                 return FALSE;
12439
12440               /* BPABI objects never have dynamic relocations mapped.  */
12441               if (htab->symbian_p)
12442                 {
12443                   flagword flags;
12444
12445                   flags = bfd_get_section_flags (dynobj, sreloc);
12446                   flags &= ~(SEC_LOAD | SEC_ALLOC);
12447                   bfd_set_section_flags (dynobj, sreloc, flags);
12448                 }
12449             }
12450
12451           /* If this is a global symbol, count the number of
12452              relocations we need for this symbol.  */
12453           if (h != NULL)
12454             head = &((struct elf32_arm_link_hash_entry *) h)->dyn_relocs;
12455           else
12456             {
12457               head = elf32_arm_get_local_dynreloc_list (abfd, r_symndx, isym);
12458               if (head == NULL)
12459                 return FALSE;
12460             }
12461
12462           p = *head;
12463           if (p == NULL || p->sec != sec)
12464             {
12465               bfd_size_type amt = sizeof *p;
12466
12467               p = (struct elf_dyn_relocs *) bfd_alloc (htab->root.dynobj, amt);
12468               if (p == NULL)
12469                 return FALSE;
12470               p->next = *head;
12471               *head = p;
12472               p->sec = sec;
12473               p->count = 0;
12474               p->pc_count = 0;
12475             }
12476
12477           if (r_type == R_ARM_REL32 || r_type == R_ARM_REL32_NOI)
12478             p->pc_count += 1;
12479           p->count += 1;
12480         }
12481     }
12482
12483   return TRUE;
12484 }
12485
12486 /* Unwinding tables are not referenced directly.  This pass marks them as
12487    required if the corresponding code section is marked.  */
12488
12489 static bfd_boolean
12490 elf32_arm_gc_mark_extra_sections (struct bfd_link_info *info,
12491                                   elf_gc_mark_hook_fn gc_mark_hook)
12492 {
12493   bfd *sub;
12494   Elf_Internal_Shdr **elf_shdrp;
12495   bfd_boolean again;
12496
12497   _bfd_elf_gc_mark_extra_sections (info, gc_mark_hook);
12498
12499   /* Marking EH data may cause additional code sections to be marked,
12500      requiring multiple passes.  */
12501   again = TRUE;
12502   while (again)
12503     {
12504       again = FALSE;
12505       for (sub = info->input_bfds; sub != NULL; sub = sub->link_next)
12506         {
12507           asection *o;
12508
12509           if (! is_arm_elf (sub))
12510             continue;
12511
12512           elf_shdrp = elf_elfsections (sub);
12513           for (o = sub->sections; o != NULL; o = o->next)
12514             {
12515               Elf_Internal_Shdr *hdr;
12516
12517               hdr = &elf_section_data (o)->this_hdr;
12518               if (hdr->sh_type == SHT_ARM_EXIDX
12519                   && hdr->sh_link
12520                   && hdr->sh_link < elf_numsections (sub)
12521                   && !o->gc_mark
12522                   && elf_shdrp[hdr->sh_link]->bfd_section->gc_mark)
12523                 {
12524                   again = TRUE;
12525                   if (!_bfd_elf_gc_mark (info, o, gc_mark_hook))
12526                     return FALSE;
12527                 }
12528             }
12529         }
12530     }
12531
12532   return TRUE;
12533 }
12534
12535 /* Treat mapping symbols as special target symbols.  */
12536
12537 static bfd_boolean
12538 elf32_arm_is_target_special_symbol (bfd * abfd ATTRIBUTE_UNUSED, asymbol * sym)
12539 {
12540   return bfd_is_arm_special_symbol_name (sym->name,
12541                                          BFD_ARM_SPECIAL_SYM_TYPE_ANY);
12542 }
12543
12544 /* This is a copy of elf_find_function() from elf.c except that
12545    ARM mapping symbols are ignored when looking for function names
12546    and STT_ARM_TFUNC is considered to a function type.  */
12547
12548 static bfd_boolean
12549 arm_elf_find_function (bfd *         abfd ATTRIBUTE_UNUSED,
12550                        asection *    section,
12551                        asymbol **    symbols,
12552                        bfd_vma       offset,
12553                        const char ** filename_ptr,
12554                        const char ** functionname_ptr)
12555 {
12556   const char * filename = NULL;
12557   asymbol * func = NULL;
12558   bfd_vma low_func = 0;
12559   asymbol ** p;
12560
12561   for (p = symbols; *p != NULL; p++)
12562     {
12563       elf_symbol_type *q;
12564
12565       q = (elf_symbol_type *) *p;
12566
12567       switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
12568         {
12569         default:
12570           break;
12571         case STT_FILE:
12572           filename = bfd_asymbol_name (&q->symbol);
12573           break;
12574         case STT_FUNC:
12575         case STT_ARM_TFUNC:
12576         case STT_NOTYPE:
12577           /* Skip mapping symbols.  */
12578           if ((q->symbol.flags & BSF_LOCAL)
12579               && bfd_is_arm_special_symbol_name (q->symbol.name,
12580                     BFD_ARM_SPECIAL_SYM_TYPE_ANY))
12581             continue;
12582           /* Fall through.  */
12583           if (bfd_get_section (&q->symbol) == section
12584               && q->symbol.value >= low_func
12585               && q->symbol.value <= offset)
12586             {
12587               func = (asymbol *) q;
12588               low_func = q->symbol.value;
12589             }
12590           break;
12591         }
12592     }
12593
12594   if (func == NULL)
12595     return FALSE;
12596
12597   if (filename_ptr)
12598     *filename_ptr = filename;
12599   if (functionname_ptr)
12600     *functionname_ptr = bfd_asymbol_name (func);
12601
12602   return TRUE;
12603 }
12604
12605
12606 /* Find the nearest line to a particular section and offset, for error
12607    reporting.   This code is a duplicate of the code in elf.c, except
12608    that it uses arm_elf_find_function.  */
12609
12610 static bfd_boolean
12611 elf32_arm_find_nearest_line (bfd *          abfd,
12612                              asection *     section,
12613                              asymbol **     symbols,
12614                              bfd_vma        offset,
12615                              const char **  filename_ptr,
12616                              const char **  functionname_ptr,
12617                              unsigned int * line_ptr)
12618 {
12619   bfd_boolean found = FALSE;
12620
12621   /* We skip _bfd_dwarf1_find_nearest_line since no known ARM toolchain uses it.  */
12622
12623   if (_bfd_dwarf2_find_nearest_line (abfd, dwarf_debug_sections,
12624                                      section, symbols, offset,
12625                                      filename_ptr, functionname_ptr,
12626                                      line_ptr, 0,
12627                                      & elf_tdata (abfd)->dwarf2_find_line_info))
12628     {
12629       if (!*functionname_ptr)
12630         arm_elf_find_function (abfd, section, symbols, offset,
12631                                *filename_ptr ? NULL : filename_ptr,
12632                                functionname_ptr);
12633
12634       return TRUE;
12635     }
12636
12637   if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
12638                                              & found, filename_ptr,
12639                                              functionname_ptr, line_ptr,
12640                                              & elf_tdata (abfd)->line_info))
12641     return FALSE;
12642
12643   if (found && (*functionname_ptr || *line_ptr))
12644     return TRUE;
12645
12646   if (symbols == NULL)
12647     return FALSE;
12648
12649   if (! arm_elf_find_function (abfd, section, symbols, offset,
12650                                filename_ptr, functionname_ptr))
12651     return FALSE;
12652
12653   *line_ptr = 0;
12654   return TRUE;
12655 }
12656
12657 static bfd_boolean
12658 elf32_arm_find_inliner_info (bfd *          abfd,
12659                              const char **  filename_ptr,
12660                              const char **  functionname_ptr,
12661                              unsigned int * line_ptr)
12662 {
12663   bfd_boolean found;
12664   found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
12665                                          functionname_ptr, line_ptr,
12666                                          & elf_tdata (abfd)->dwarf2_find_line_info);
12667   return found;
12668 }
12669
12670 /* Adjust a symbol defined by a dynamic object and referenced by a
12671    regular object.  The current definition is in some section of the
12672    dynamic object, but we're not including those sections.  We have to
12673    change the definition to something the rest of the link can
12674    understand.  */
12675
12676 static bfd_boolean
12677 elf32_arm_adjust_dynamic_symbol (struct bfd_link_info * info,
12678                                  struct elf_link_hash_entry * h)
12679 {
12680   bfd * dynobj;
12681   asection * s;
12682   struct elf32_arm_link_hash_entry * eh;
12683   struct elf32_arm_link_hash_table *globals;
12684
12685   globals = elf32_arm_hash_table (info);
12686   if (globals == NULL)
12687     return FALSE;
12688
12689   dynobj = elf_hash_table (info)->dynobj;
12690
12691   /* Make sure we know what is going on here.  */
12692   BFD_ASSERT (dynobj != NULL
12693               && (h->needs_plt
12694                   || h->type == STT_GNU_IFUNC
12695                   || h->u.weakdef != NULL
12696                   || (h->def_dynamic
12697                       && h->ref_regular
12698                       && !h->def_regular)));
12699
12700   eh = (struct elf32_arm_link_hash_entry *) h;
12701
12702   /* If this is a function, put it in the procedure linkage table.  We
12703      will fill in the contents of the procedure linkage table later,
12704      when we know the address of the .got section.  */
12705   if (h->type == STT_FUNC || h->type == STT_GNU_IFUNC || h->needs_plt)
12706     {
12707       /* Calls to STT_GNU_IFUNC symbols always use a PLT, even if the
12708          symbol binds locally.  */
12709       if (h->plt.refcount <= 0
12710           || (h->type != STT_GNU_IFUNC
12711               && (SYMBOL_CALLS_LOCAL (info, h)
12712                   || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
12713                       && h->root.type == bfd_link_hash_undefweak))))
12714         {
12715           /* This case can occur if we saw a PLT32 reloc in an input
12716              file, but the symbol was never referred to by a dynamic
12717              object, or if all references were garbage collected.  In
12718              such a case, we don't actually need to build a procedure
12719              linkage table, and we can just do a PC24 reloc instead.  */
12720           h->plt.offset = (bfd_vma) -1;
12721           eh->plt.thumb_refcount = 0;
12722           eh->plt.maybe_thumb_refcount = 0;
12723           eh->plt.noncall_refcount = 0;
12724           h->needs_plt = 0;
12725         }
12726
12727       return TRUE;
12728     }
12729   else
12730     {
12731       /* It's possible that we incorrectly decided a .plt reloc was
12732          needed for an R_ARM_PC24 or similar reloc to a non-function sym
12733          in check_relocs.  We can't decide accurately between function
12734          and non-function syms in check-relocs; Objects loaded later in
12735          the link may change h->type.  So fix it now.  */
12736       h->plt.offset = (bfd_vma) -1;
12737       eh->plt.thumb_refcount = 0;
12738       eh->plt.maybe_thumb_refcount = 0;
12739       eh->plt.noncall_refcount = 0;
12740     }
12741
12742   /* If this is a weak symbol, and there is a real definition, the
12743      processor independent code will have arranged for us to see the
12744      real definition first, and we can just use the same value.  */
12745   if (h->u.weakdef != NULL)
12746     {
12747       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
12748                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
12749       h->root.u.def.section = h->u.weakdef->root.u.def.section;
12750       h->root.u.def.value = h->u.weakdef->root.u.def.value;
12751       return TRUE;
12752     }
12753
12754   /* If there are no non-GOT references, we do not need a copy
12755      relocation.  */
12756   if (!h->non_got_ref)
12757     return TRUE;
12758
12759   /* This is a reference to a symbol defined by a dynamic object which
12760      is not a function.  */
12761
12762   /* If we are creating a shared library, we must presume that the
12763      only references to the symbol are via the global offset table.
12764      For such cases we need not do anything here; the relocations will
12765      be handled correctly by relocate_section.  Relocatable executables
12766      can reference data in shared objects directly, so we don't need to
12767      do anything here.  */
12768   if (info->shared || globals->root.is_relocatable_executable)
12769     return TRUE;
12770
12771   if (h->size == 0)
12772     {
12773       (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
12774                              h->root.root.string);
12775       return TRUE;
12776     }
12777
12778   /* We must allocate the symbol in our .dynbss section, which will
12779      become part of the .bss section of the executable.  There will be
12780      an entry for this symbol in the .dynsym section.  The dynamic
12781      object will contain position independent code, so all references
12782      from the dynamic object to this symbol will go through the global
12783      offset table.  The dynamic linker will use the .dynsym entry to
12784      determine the address it must put in the global offset table, so
12785      both the dynamic object and the regular object will refer to the
12786      same memory location for the variable.  */
12787   s = bfd_get_section_by_name (dynobj, ".dynbss");
12788   BFD_ASSERT (s != NULL);
12789
12790   /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
12791      copy the initial value out of the dynamic object and into the
12792      runtime process image.  We need to remember the offset into the
12793      .rel(a).bss section we are going to use.  */
12794   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
12795     {
12796       asection *srel;
12797
12798       srel = bfd_get_section_by_name (dynobj, RELOC_SECTION (globals, ".bss"));
12799       elf32_arm_allocate_dynrelocs (info, srel, 1);
12800       h->needs_copy = 1;
12801     }
12802
12803   return _bfd_elf_adjust_dynamic_copy (h, s);
12804 }
12805
12806 /* Allocate space in .plt, .got and associated reloc sections for
12807    dynamic relocs.  */
12808
12809 static bfd_boolean
12810 allocate_dynrelocs_for_symbol (struct elf_link_hash_entry *h, void * inf)
12811 {
12812   struct bfd_link_info *info;
12813   struct elf32_arm_link_hash_table *htab;
12814   struct elf32_arm_link_hash_entry *eh;
12815   struct elf_dyn_relocs *p;
12816
12817   if (h->root.type == bfd_link_hash_indirect)
12818     return TRUE;
12819
12820   eh = (struct elf32_arm_link_hash_entry *) h;
12821
12822   info = (struct bfd_link_info *) inf;
12823   htab = elf32_arm_hash_table (info);
12824   if (htab == NULL)
12825     return FALSE;
12826
12827   if ((htab->root.dynamic_sections_created || h->type == STT_GNU_IFUNC)
12828       && h->plt.refcount > 0)
12829     {
12830       /* Make sure this symbol is output as a dynamic symbol.
12831          Undefined weak syms won't yet be marked as dynamic.  */
12832       if (h->dynindx == -1
12833           && !h->forced_local)
12834         {
12835           if (! bfd_elf_link_record_dynamic_symbol (info, h))
12836             return FALSE;
12837         }
12838
12839       /* If the call in the PLT entry binds locally, the associated
12840          GOT entry should use an R_ARM_IRELATIVE relocation instead of
12841          the usual R_ARM_JUMP_SLOT.  Put it in the .iplt section rather
12842          than the .plt section.  */
12843       if (h->type == STT_GNU_IFUNC && SYMBOL_CALLS_LOCAL (info, h))
12844         {
12845           eh->is_iplt = 1;
12846           if (eh->plt.noncall_refcount == 0
12847               && SYMBOL_REFERENCES_LOCAL (info, h))
12848             /* All non-call references can be resolved directly.
12849                This means that they can (and in some cases, must)
12850                resolve directly to the run-time target, rather than
12851                to the PLT.  That in turns means that any .got entry
12852                would be equal to the .igot.plt entry, so there's
12853                no point having both.  */
12854             h->got.refcount = 0;
12855         }
12856
12857       if (info->shared
12858           || eh->is_iplt
12859           || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
12860         {
12861           elf32_arm_allocate_plt_entry (info, eh->is_iplt, &h->plt, &eh->plt);
12862
12863           /* If this symbol is not defined in a regular file, and we are
12864              not generating a shared library, then set the symbol to this
12865              location in the .plt.  This is required to make function
12866              pointers compare as equal between the normal executable and
12867              the shared library.  */
12868           if (! info->shared
12869               && !h->def_regular)
12870             {
12871               h->root.u.def.section = htab->root.splt;
12872               h->root.u.def.value = h->plt.offset;
12873
12874               /* Make sure the function is not marked as Thumb, in case
12875                  it is the target of an ABS32 relocation, which will
12876                  point to the PLT entry.  */
12877               h->target_internal = ST_BRANCH_TO_ARM;
12878             }
12879
12880           htab->next_tls_desc_index++;
12881
12882           /* VxWorks executables have a second set of relocations for
12883              each PLT entry.  They go in a separate relocation section,
12884              which is processed by the kernel loader.  */
12885           if (htab->vxworks_p && !info->shared)
12886             {
12887               /* There is a relocation for the initial PLT entry:
12888                  an R_ARM_32 relocation for _GLOBAL_OFFSET_TABLE_.  */
12889               if (h->plt.offset == htab->plt_header_size)
12890                 elf32_arm_allocate_dynrelocs (info, htab->srelplt2, 1);
12891
12892               /* There are two extra relocations for each subsequent
12893                  PLT entry: an R_ARM_32 relocation for the GOT entry,
12894                  and an R_ARM_32 relocation for the PLT entry.  */
12895               elf32_arm_allocate_dynrelocs (info, htab->srelplt2, 2);
12896             }
12897         }
12898       else
12899         {
12900           h->plt.offset = (bfd_vma) -1;
12901           h->needs_plt = 0;
12902         }
12903     }
12904   else
12905     {
12906       h->plt.offset = (bfd_vma) -1;
12907       h->needs_plt = 0;
12908     }
12909
12910   eh = (struct elf32_arm_link_hash_entry *) h;
12911   eh->tlsdesc_got = (bfd_vma) -1;
12912
12913   if (h->got.refcount > 0)
12914     {
12915       asection *s;
12916       bfd_boolean dyn;
12917       int tls_type = elf32_arm_hash_entry (h)->tls_type;
12918       int indx;
12919
12920       /* Make sure this symbol is output as a dynamic symbol.
12921          Undefined weak syms won't yet be marked as dynamic.  */
12922       if (h->dynindx == -1
12923           && !h->forced_local)
12924         {
12925           if (! bfd_elf_link_record_dynamic_symbol (info, h))
12926             return FALSE;
12927         }
12928
12929       if (!htab->symbian_p)
12930         {
12931           s = htab->root.sgot;
12932           h->got.offset = s->size;
12933
12934           if (tls_type == GOT_UNKNOWN)
12935             abort ();
12936
12937           if (tls_type == GOT_NORMAL)
12938             /* Non-TLS symbols need one GOT slot.  */
12939             s->size += 4;
12940           else
12941             {
12942               if (tls_type & GOT_TLS_GDESC)
12943                 {
12944                   /* R_ARM_TLS_DESC needs 2 GOT slots.  */
12945                   eh->tlsdesc_got
12946                     = (htab->root.sgotplt->size
12947                        - elf32_arm_compute_jump_table_size (htab));
12948                   htab->root.sgotplt->size += 8;
12949                   h->got.offset = (bfd_vma) -2;
12950                   /* plt.got_offset needs to know there's a TLS_DESC
12951                      reloc in the middle of .got.plt.  */
12952                   htab->num_tls_desc++;
12953                 }
12954
12955               if (tls_type & GOT_TLS_GD)
12956                 {
12957                   /* R_ARM_TLS_GD32 needs 2 consecutive GOT slots.  If
12958                      the symbol is both GD and GDESC, got.offset may
12959                      have been overwritten.  */
12960                   h->got.offset = s->size;
12961                   s->size += 8;
12962                 }
12963
12964               if (tls_type & GOT_TLS_IE)
12965                 /* R_ARM_TLS_IE32 needs one GOT slot.  */
12966                 s->size += 4;
12967             }
12968
12969           dyn = htab->root.dynamic_sections_created;
12970
12971           indx = 0;
12972           if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
12973               && (!info->shared
12974                   || !SYMBOL_REFERENCES_LOCAL (info, h)))
12975             indx = h->dynindx;
12976
12977           if (tls_type != GOT_NORMAL
12978               && (info->shared || indx != 0)
12979               && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
12980                   || h->root.type != bfd_link_hash_undefweak))
12981             {
12982               if (tls_type & GOT_TLS_IE)
12983                 elf32_arm_allocate_dynrelocs (info, htab->root.srelgot, 1);
12984
12985               if (tls_type & GOT_TLS_GD)
12986                 elf32_arm_allocate_dynrelocs (info, htab->root.srelgot, 1);
12987
12988               if (tls_type & GOT_TLS_GDESC)
12989                 {
12990                   elf32_arm_allocate_dynrelocs (info, htab->root.srelplt, 1);
12991                   /* GDESC needs a trampoline to jump to.  */
12992                   htab->tls_trampoline = -1;
12993                 }
12994
12995               /* Only GD needs it.  GDESC just emits one relocation per
12996                  2 entries.  */
12997               if ((tls_type & GOT_TLS_GD) && indx != 0)
12998                 elf32_arm_allocate_dynrelocs (info, htab->root.srelgot, 1);
12999             }
13000           else if (!SYMBOL_REFERENCES_LOCAL (info, h))
13001             {
13002               if (htab->root.dynamic_sections_created)
13003                 /* Reserve room for the GOT entry's R_ARM_GLOB_DAT relocation.  */
13004                 elf32_arm_allocate_dynrelocs (info, htab->root.srelgot, 1);
13005             }
13006           else if (h->type == STT_GNU_IFUNC
13007                    && eh->plt.noncall_refcount == 0)
13008             /* No non-call references resolve the STT_GNU_IFUNC's PLT entry;
13009                they all resolve dynamically instead.  Reserve room for the
13010                GOT entry's R_ARM_IRELATIVE relocation.  */
13011             elf32_arm_allocate_irelocs (info, htab->root.srelgot, 1);
13012           else if (info->shared)
13013             /* Reserve room for the GOT entry's R_ARM_RELATIVE relocation.  */
13014             elf32_arm_allocate_dynrelocs (info, htab->root.srelgot, 1);
13015         }
13016     }
13017   else
13018     h->got.offset = (bfd_vma) -1;
13019
13020   /* Allocate stubs for exported Thumb functions on v4t.  */
13021   if (!htab->use_blx && h->dynindx != -1
13022       && h->def_regular
13023       && h->target_internal == ST_BRANCH_TO_THUMB
13024       && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
13025     {
13026       struct elf_link_hash_entry * th;
13027       struct bfd_link_hash_entry * bh;
13028       struct elf_link_hash_entry * myh;
13029       char name[1024];
13030       asection *s;
13031       bh = NULL;
13032       /* Create a new symbol to regist the real location of the function.  */
13033       s = h->root.u.def.section;
13034       sprintf (name, "__real_%s", h->root.root.string);
13035       _bfd_generic_link_add_one_symbol (info, s->owner,
13036                                         name, BSF_GLOBAL, s,
13037                                         h->root.u.def.value,
13038                                         NULL, TRUE, FALSE, &bh);
13039
13040       myh = (struct elf_link_hash_entry *) bh;
13041       myh->type = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
13042       myh->forced_local = 1;
13043       myh->target_internal = ST_BRANCH_TO_THUMB;
13044       eh->export_glue = myh;
13045       th = record_arm_to_thumb_glue (info, h);
13046       /* Point the symbol at the stub.  */
13047       h->type = ELF_ST_INFO (ELF_ST_BIND (h->type), STT_FUNC);
13048       h->target_internal = ST_BRANCH_TO_ARM;
13049       h->root.u.def.section = th->root.u.def.section;
13050       h->root.u.def.value = th->root.u.def.value & ~1;
13051     }
13052
13053   if (eh->dyn_relocs == NULL)
13054     return TRUE;
13055
13056   /* In the shared -Bsymbolic case, discard space allocated for
13057      dynamic pc-relative relocs against symbols which turn out to be
13058      defined in regular objects.  For the normal shared case, discard
13059      space for pc-relative relocs that have become local due to symbol
13060      visibility changes.  */
13061
13062   if (info->shared || htab->root.is_relocatable_executable)
13063     {
13064       /* The only relocs that use pc_count are R_ARM_REL32 and
13065          R_ARM_REL32_NOI, which will appear on something like
13066          ".long foo - .".  We want calls to protected symbols to resolve
13067          directly to the function rather than going via the plt.  If people
13068          want function pointer comparisons to work as expected then they
13069          should avoid writing assembly like ".long foo - .".  */
13070       if (SYMBOL_CALLS_LOCAL (info, h))
13071         {
13072           struct elf_dyn_relocs **pp;
13073
13074           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
13075             {
13076               p->count -= p->pc_count;
13077               p->pc_count = 0;
13078               if (p->count == 0)
13079                 *pp = p->next;
13080               else
13081                 pp = &p->next;
13082             }
13083         }
13084
13085       if (htab->vxworks_p)
13086         {
13087           struct elf_dyn_relocs **pp;
13088
13089           for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
13090             {
13091               if (strcmp (p->sec->output_section->name, ".tls_vars") == 0)
13092                 *pp = p->next;
13093               else
13094                 pp = &p->next;
13095             }
13096         }
13097
13098       /* Also discard relocs on undefined weak syms with non-default
13099          visibility.  */
13100       if (eh->dyn_relocs != NULL
13101           && h->root.type == bfd_link_hash_undefweak)
13102         {
13103           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
13104             eh->dyn_relocs = NULL;
13105
13106           /* Make sure undefined weak symbols are output as a dynamic
13107              symbol in PIEs.  */
13108           else if (h->dynindx == -1
13109                    && !h->forced_local)
13110             {
13111               if (! bfd_elf_link_record_dynamic_symbol (info, h))
13112                 return FALSE;
13113             }
13114         }
13115
13116       else if (htab->root.is_relocatable_executable && h->dynindx == -1
13117                && h->root.type == bfd_link_hash_new)
13118         {
13119           /* Output absolute symbols so that we can create relocations
13120              against them.  For normal symbols we output a relocation
13121              against the section that contains them.  */
13122           if (! bfd_elf_link_record_dynamic_symbol (info, h))
13123             return FALSE;
13124         }
13125
13126     }
13127   else
13128     {
13129       /* For the non-shared case, discard space for relocs against
13130          symbols which turn out to need copy relocs or are not
13131          dynamic.  */
13132
13133       if (!h->non_got_ref
13134           && ((h->def_dynamic
13135                && !h->def_regular)
13136               || (htab->root.dynamic_sections_created
13137                   && (h->root.type == bfd_link_hash_undefweak
13138                       || h->root.type == bfd_link_hash_undefined))))
13139         {
13140           /* Make sure this symbol is output as a dynamic symbol.
13141              Undefined weak syms won't yet be marked as dynamic.  */
13142           if (h->dynindx == -1
13143               && !h->forced_local)
13144             {
13145               if (! bfd_elf_link_record_dynamic_symbol (info, h))
13146                 return FALSE;
13147             }
13148
13149           /* If that succeeded, we know we'll be keeping all the
13150              relocs.  */
13151           if (h->dynindx != -1)
13152             goto keep;
13153         }
13154
13155       eh->dyn_relocs = NULL;
13156
13157     keep: ;
13158     }
13159
13160   /* Finally, allocate space.  */
13161   for (p = eh->dyn_relocs; p != NULL; p = p->next)
13162     {
13163       asection *sreloc = elf_section_data (p->sec)->sreloc;
13164       if (h->type == STT_GNU_IFUNC
13165           && eh->plt.noncall_refcount == 0
13166           && SYMBOL_REFERENCES_LOCAL (info, h))
13167         elf32_arm_allocate_irelocs (info, sreloc, p->count);
13168       else
13169         elf32_arm_allocate_dynrelocs (info, sreloc, p->count);
13170     }
13171
13172   return TRUE;
13173 }
13174
13175 /* Find any dynamic relocs that apply to read-only sections.  */
13176
13177 static bfd_boolean
13178 elf32_arm_readonly_dynrelocs (struct elf_link_hash_entry * h, void * inf)
13179 {
13180   struct elf32_arm_link_hash_entry * eh;
13181   struct elf_dyn_relocs * p;
13182
13183   eh = (struct elf32_arm_link_hash_entry *) h;
13184   for (p = eh->dyn_relocs; p != NULL; p = p->next)
13185     {
13186       asection *s = p->sec;
13187
13188       if (s != NULL && (s->flags & SEC_READONLY) != 0)
13189         {
13190           struct bfd_link_info *info = (struct bfd_link_info *) inf;
13191
13192           info->flags |= DF_TEXTREL;
13193
13194           /* Not an error, just cut short the traversal.  */
13195           return FALSE;
13196         }
13197     }
13198   return TRUE;
13199 }
13200
13201 void
13202 bfd_elf32_arm_set_byteswap_code (struct bfd_link_info *info,
13203                                  int byteswap_code)
13204 {
13205   struct elf32_arm_link_hash_table *globals;
13206
13207   globals = elf32_arm_hash_table (info);
13208   if (globals == NULL)
13209     return;
13210
13211   globals->byteswap_code = byteswap_code;
13212 }
13213
13214 /* Set the sizes of the dynamic sections.  */
13215
13216 static bfd_boolean
13217 elf32_arm_size_dynamic_sections (bfd * output_bfd ATTRIBUTE_UNUSED,
13218                                  struct bfd_link_info * info)
13219 {
13220   bfd * dynobj;
13221   asection * s;
13222   bfd_boolean plt;
13223   bfd_boolean relocs;
13224   bfd *ibfd;
13225   struct elf32_arm_link_hash_table *htab;
13226
13227   htab = elf32_arm_hash_table (info);
13228   if (htab == NULL)
13229     return FALSE;
13230
13231   dynobj = elf_hash_table (info)->dynobj;
13232   BFD_ASSERT (dynobj != NULL);
13233   check_use_blx (htab);
13234
13235   if (elf_hash_table (info)->dynamic_sections_created)
13236     {
13237       /* Set the contents of the .interp section to the interpreter.  */
13238       if (info->executable)
13239         {
13240           s = bfd_get_section_by_name (dynobj, ".interp");
13241           BFD_ASSERT (s != NULL);
13242           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
13243           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
13244         }
13245     }
13246
13247   /* Set up .got offsets for local syms, and space for local dynamic
13248      relocs.  */
13249   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
13250     {
13251       bfd_signed_vma *local_got;
13252       bfd_signed_vma *end_local_got;
13253       struct arm_local_iplt_info **local_iplt_ptr, *local_iplt;
13254       char *local_tls_type;
13255       bfd_vma *local_tlsdesc_gotent;
13256       bfd_size_type locsymcount;
13257       Elf_Internal_Shdr *symtab_hdr;
13258       asection *srel;
13259       bfd_boolean is_vxworks = htab->vxworks_p;
13260       unsigned int symndx;
13261
13262       if (! is_arm_elf (ibfd))
13263         continue;
13264
13265       for (s = ibfd->sections; s != NULL; s = s->next)
13266         {
13267           struct elf_dyn_relocs *p;
13268
13269           for (p = (struct elf_dyn_relocs *)
13270                    elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
13271             {
13272               if (!bfd_is_abs_section (p->sec)
13273                   && bfd_is_abs_section (p->sec->output_section))
13274                 {
13275                   /* Input section has been discarded, either because
13276                      it is a copy of a linkonce section or due to
13277                      linker script /DISCARD/, so we'll be discarding
13278                      the relocs too.  */
13279                 }
13280               else if (is_vxworks
13281                        && strcmp (p->sec->output_section->name,
13282                                   ".tls_vars") == 0)
13283                 {
13284                   /* Relocations in vxworks .tls_vars sections are
13285                      handled specially by the loader.  */
13286                 }
13287               else if (p->count != 0)
13288                 {
13289                   srel = elf_section_data (p->sec)->sreloc;
13290                   elf32_arm_allocate_dynrelocs (info, srel, p->count);
13291                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
13292                     info->flags |= DF_TEXTREL;
13293                 }
13294             }
13295         }
13296
13297       local_got = elf_local_got_refcounts (ibfd);
13298       if (!local_got)
13299         continue;
13300
13301       symtab_hdr = & elf_symtab_hdr (ibfd);
13302       locsymcount = symtab_hdr->sh_info;
13303       end_local_got = local_got + locsymcount;
13304       local_iplt_ptr = elf32_arm_local_iplt (ibfd);
13305       local_tls_type = elf32_arm_local_got_tls_type (ibfd);
13306       local_tlsdesc_gotent = elf32_arm_local_tlsdesc_gotent (ibfd);
13307       symndx = 0;
13308       s = htab->root.sgot;
13309       srel = htab->root.srelgot;
13310       for (; local_got < end_local_got;
13311            ++local_got, ++local_iplt_ptr, ++local_tls_type,
13312            ++local_tlsdesc_gotent, ++symndx)
13313         {
13314           *local_tlsdesc_gotent = (bfd_vma) -1;
13315           local_iplt = *local_iplt_ptr;
13316           if (local_iplt != NULL)
13317             {
13318               struct elf_dyn_relocs *p;
13319
13320               if (local_iplt->root.refcount > 0)
13321                 {
13322                   elf32_arm_allocate_plt_entry (info, TRUE,
13323                                                 &local_iplt->root,
13324                                                 &local_iplt->arm);
13325                   if (local_iplt->arm.noncall_refcount == 0)
13326                     /* All references to the PLT are calls, so all
13327                        non-call references can resolve directly to the
13328                        run-time target.  This means that the .got entry
13329                        would be the same as the .igot.plt entry, so there's
13330                        no point creating both.  */
13331                     *local_got = 0;
13332                 }
13333               else
13334                 {
13335                   BFD_ASSERT (local_iplt->arm.noncall_refcount == 0);
13336                   local_iplt->root.offset = (bfd_vma) -1;
13337                 }
13338
13339               for (p = local_iplt->dyn_relocs; p != NULL; p = p->next)
13340                 {
13341                   asection *psrel;
13342
13343                   psrel = elf_section_data (p->sec)->sreloc;
13344                   if (local_iplt->arm.noncall_refcount == 0)
13345                     elf32_arm_allocate_irelocs (info, psrel, p->count);
13346                   else
13347                     elf32_arm_allocate_dynrelocs (info, psrel, p->count);
13348                 }
13349             }
13350           if (*local_got > 0)
13351             {
13352               Elf_Internal_Sym *isym;
13353
13354               *local_got = s->size;
13355               if (*local_tls_type & GOT_TLS_GD)
13356                 /* TLS_GD relocs need an 8-byte structure in the GOT.  */
13357                 s->size += 8;
13358               if (*local_tls_type & GOT_TLS_GDESC)
13359                 {
13360                   *local_tlsdesc_gotent = htab->root.sgotplt->size
13361                     - elf32_arm_compute_jump_table_size (htab);
13362                   htab->root.sgotplt->size += 8;
13363                   *local_got = (bfd_vma) -2;
13364                   /* plt.got_offset needs to know there's a TLS_DESC
13365                      reloc in the middle of .got.plt.  */
13366                   htab->num_tls_desc++;
13367                 }
13368               if (*local_tls_type & GOT_TLS_IE)
13369                 s->size += 4;
13370
13371               if (*local_tls_type & GOT_NORMAL)
13372                 {
13373                   /* If the symbol is both GD and GDESC, *local_got
13374                      may have been overwritten.  */
13375                   *local_got = s->size;
13376                   s->size += 4;
13377                 }
13378
13379               isym = bfd_sym_from_r_symndx (&htab->sym_cache, ibfd, symndx);
13380               if (isym == NULL)
13381                 return FALSE;
13382
13383               /* If all references to an STT_GNU_IFUNC PLT are calls,
13384                  then all non-call references, including this GOT entry,
13385                  resolve directly to the run-time target.  */
13386               if (ELF32_ST_TYPE (isym->st_info) == STT_GNU_IFUNC
13387                   && (local_iplt == NULL
13388                       || local_iplt->arm.noncall_refcount == 0))
13389                 elf32_arm_allocate_irelocs (info, srel, 1);
13390               else if ((info->shared && !(*local_tls_type & GOT_TLS_GDESC))
13391                        || *local_tls_type & GOT_TLS_GD)
13392                 elf32_arm_allocate_dynrelocs (info, srel, 1);
13393
13394               if (info->shared && *local_tls_type & GOT_TLS_GDESC)
13395                 {
13396                   elf32_arm_allocate_dynrelocs (info, htab->root.srelplt, 1);
13397                   htab->tls_trampoline = -1;
13398                 }
13399             }
13400           else
13401             *local_got = (bfd_vma) -1;
13402         }
13403     }
13404
13405   if (htab->tls_ldm_got.refcount > 0)
13406     {
13407       /* Allocate two GOT entries and one dynamic relocation (if necessary)
13408          for R_ARM_TLS_LDM32 relocations.  */
13409       htab->tls_ldm_got.offset = htab->root.sgot->size;
13410       htab->root.sgot->size += 8;
13411       if (info->shared)
13412         elf32_arm_allocate_dynrelocs (info, htab->root.srelgot, 1);
13413     }
13414   else
13415     htab->tls_ldm_got.offset = -1;
13416
13417   /* Allocate global sym .plt and .got entries, and space for global
13418      sym dynamic relocs.  */
13419   elf_link_hash_traverse (& htab->root, allocate_dynrelocs_for_symbol, info);
13420
13421   /* Here we rummage through the found bfds to collect glue information.  */
13422   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
13423     {
13424       if (! is_arm_elf (ibfd))
13425         continue;
13426
13427       /* Initialise mapping tables for code/data.  */
13428       bfd_elf32_arm_init_maps (ibfd);
13429
13430       if (!bfd_elf32_arm_process_before_allocation (ibfd, info)
13431           || !bfd_elf32_arm_vfp11_erratum_scan (ibfd, info))
13432         /* xgettext:c-format */
13433         _bfd_error_handler (_("Errors encountered processing file %s"),
13434                             ibfd->filename);
13435     }
13436
13437   /* Allocate space for the glue sections now that we've sized them.  */
13438   bfd_elf32_arm_allocate_interworking_sections (info);
13439
13440   /* For every jump slot reserved in the sgotplt, reloc_count is
13441      incremented.  However, when we reserve space for TLS descriptors,
13442      it's not incremented, so in order to compute the space reserved
13443      for them, it suffices to multiply the reloc count by the jump
13444      slot size.  */
13445   if (htab->root.srelplt)
13446     htab->sgotplt_jump_table_size = elf32_arm_compute_jump_table_size(htab);
13447
13448   if (htab->tls_trampoline)
13449     {
13450       if (htab->root.splt->size == 0)
13451         htab->root.splt->size += htab->plt_header_size;
13452
13453       htab->tls_trampoline = htab->root.splt->size;
13454       htab->root.splt->size += htab->plt_entry_size;
13455
13456       /* If we're not using lazy TLS relocations, don't generate the
13457          PLT and GOT entries they require.  */
13458       if (!(info->flags & DF_BIND_NOW))
13459         {
13460           htab->dt_tlsdesc_got = htab->root.sgot->size;
13461           htab->root.sgot->size += 4;
13462
13463           htab->dt_tlsdesc_plt = htab->root.splt->size;
13464           htab->root.splt->size += 4 * ARRAY_SIZE (dl_tlsdesc_lazy_trampoline);
13465         }
13466     }
13467
13468   /* The check_relocs and adjust_dynamic_symbol entry points have
13469      determined the sizes of the various dynamic sections.  Allocate
13470      memory for them.  */
13471   plt = FALSE;
13472   relocs = FALSE;
13473   for (s = dynobj->sections; s != NULL; s = s->next)
13474     {
13475       const char * name;
13476
13477       if ((s->flags & SEC_LINKER_CREATED) == 0)
13478         continue;
13479
13480       /* It's OK to base decisions on the section name, because none
13481          of the dynobj section names depend upon the input files.  */
13482       name = bfd_get_section_name (dynobj, s);
13483
13484       if (s == htab->root.splt)
13485         {
13486           /* Remember whether there is a PLT.  */
13487           plt = s->size != 0;
13488         }
13489       else if (CONST_STRNEQ (name, ".rel"))
13490         {
13491           if (s->size != 0)
13492             {
13493               /* Remember whether there are any reloc sections other
13494                  than .rel(a).plt and .rela.plt.unloaded.  */
13495               if (s != htab->root.srelplt && s != htab->srelplt2)
13496                 relocs = TRUE;
13497
13498               /* We use the reloc_count field as a counter if we need
13499                  to copy relocs into the output file.  */
13500               s->reloc_count = 0;
13501             }
13502         }
13503       else if (s != htab->root.sgot
13504                && s != htab->root.sgotplt
13505                && s != htab->root.iplt
13506                && s != htab->root.igotplt
13507                && s != htab->sdynbss)
13508         {
13509           /* It's not one of our sections, so don't allocate space.  */
13510           continue;
13511         }
13512
13513       if (s->size == 0)
13514         {
13515           /* If we don't need this section, strip it from the
13516              output file.  This is mostly to handle .rel(a).bss and
13517              .rel(a).plt.  We must create both sections in
13518              create_dynamic_sections, because they must be created
13519              before the linker maps input sections to output
13520              sections.  The linker does that before
13521              adjust_dynamic_symbol is called, and it is that
13522              function which decides whether anything needs to go
13523              into these sections.  */
13524           s->flags |= SEC_EXCLUDE;
13525           continue;
13526         }
13527
13528       if ((s->flags & SEC_HAS_CONTENTS) == 0)
13529         continue;
13530
13531       /* Allocate memory for the section contents.  */
13532       s->contents = (unsigned char *) bfd_zalloc (dynobj, s->size);
13533       if (s->contents == NULL)
13534         return FALSE;
13535     }
13536
13537   if (elf_hash_table (info)->dynamic_sections_created)
13538     {
13539       /* Add some entries to the .dynamic section.  We fill in the
13540          values later, in elf32_arm_finish_dynamic_sections, but we
13541          must add the entries now so that we get the correct size for
13542          the .dynamic section.  The DT_DEBUG entry is filled in by the
13543          dynamic linker and used by the debugger.  */
13544 #define add_dynamic_entry(TAG, VAL) \
13545   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
13546
13547      if (info->executable)
13548         {
13549           if (!add_dynamic_entry (DT_DEBUG, 0))
13550             return FALSE;
13551         }
13552
13553       if (plt)
13554         {
13555           if (   !add_dynamic_entry (DT_PLTGOT, 0)
13556               || !add_dynamic_entry (DT_PLTRELSZ, 0)
13557               || !add_dynamic_entry (DT_PLTREL,
13558                                      htab->use_rel ? DT_REL : DT_RELA)
13559               || !add_dynamic_entry (DT_JMPREL, 0))
13560             return FALSE;
13561
13562           if (htab->dt_tlsdesc_plt &&
13563                 (!add_dynamic_entry (DT_TLSDESC_PLT,0)
13564                  || !add_dynamic_entry (DT_TLSDESC_GOT,0)))
13565             return FALSE;
13566         }
13567
13568       if (relocs)
13569         {
13570           if (htab->use_rel)
13571             {
13572               if (!add_dynamic_entry (DT_REL, 0)
13573                   || !add_dynamic_entry (DT_RELSZ, 0)
13574                   || !add_dynamic_entry (DT_RELENT, RELOC_SIZE (htab)))
13575                 return FALSE;
13576             }
13577           else
13578             {
13579               if (!add_dynamic_entry (DT_RELA, 0)
13580                   || !add_dynamic_entry (DT_RELASZ, 0)
13581                   || !add_dynamic_entry (DT_RELAENT, RELOC_SIZE (htab)))
13582                 return FALSE;
13583             }
13584         }
13585
13586       /* If any dynamic relocs apply to a read-only section,
13587          then we need a DT_TEXTREL entry.  */
13588       if ((info->flags & DF_TEXTREL) == 0)
13589         elf_link_hash_traverse (& htab->root, elf32_arm_readonly_dynrelocs,
13590                                 info);
13591
13592       if ((info->flags & DF_TEXTREL) != 0)
13593         {
13594           if (!add_dynamic_entry (DT_TEXTREL, 0))
13595             return FALSE;
13596         }
13597       if (htab->vxworks_p
13598           && !elf_vxworks_add_dynamic_entries (output_bfd, info))
13599         return FALSE;
13600     }
13601 #undef add_dynamic_entry
13602
13603   return TRUE;
13604 }
13605
13606 /* Size sections even though they're not dynamic.  We use it to setup
13607    _TLS_MODULE_BASE_, if needed.  */
13608
13609 static bfd_boolean
13610 elf32_arm_always_size_sections (bfd *output_bfd,
13611                                 struct bfd_link_info *info)
13612 {
13613   asection *tls_sec;
13614
13615   if (info->relocatable)
13616     return TRUE;
13617
13618   tls_sec = elf_hash_table (info)->tls_sec;
13619
13620   if (tls_sec)
13621     {
13622       struct elf_link_hash_entry *tlsbase;
13623
13624       tlsbase = elf_link_hash_lookup
13625         (elf_hash_table (info), "_TLS_MODULE_BASE_", TRUE, TRUE, FALSE);
13626
13627       if (tlsbase)
13628         {
13629           struct bfd_link_hash_entry *bh = NULL;
13630           const struct elf_backend_data *bed
13631             = get_elf_backend_data (output_bfd);
13632
13633           if (!(_bfd_generic_link_add_one_symbol
13634                 (info, output_bfd, "_TLS_MODULE_BASE_", BSF_LOCAL,
13635                  tls_sec, 0, NULL, FALSE,
13636                  bed->collect, &bh)))
13637             return FALSE;
13638
13639           tlsbase->type = STT_TLS;
13640           tlsbase = (struct elf_link_hash_entry *)bh;
13641           tlsbase->def_regular = 1;
13642           tlsbase->other = STV_HIDDEN;
13643           (*bed->elf_backend_hide_symbol) (info, tlsbase, TRUE);
13644         }
13645     }
13646   return TRUE;
13647 }
13648
13649 /* Finish up dynamic symbol handling.  We set the contents of various
13650    dynamic sections here.  */
13651
13652 static bfd_boolean
13653 elf32_arm_finish_dynamic_symbol (bfd * output_bfd,
13654                                  struct bfd_link_info * info,
13655                                  struct elf_link_hash_entry * h,
13656                                  Elf_Internal_Sym * sym)
13657 {
13658   struct elf32_arm_link_hash_table *htab;
13659   struct elf32_arm_link_hash_entry *eh;
13660
13661   htab = elf32_arm_hash_table (info);
13662   if (htab == NULL)
13663     return FALSE;
13664
13665   eh = (struct elf32_arm_link_hash_entry *) h;
13666
13667   if (h->plt.offset != (bfd_vma) -1)
13668     {
13669       if (!eh->is_iplt)
13670         {
13671           BFD_ASSERT (h->dynindx != -1);
13672           elf32_arm_populate_plt_entry (output_bfd, info, &h->plt, &eh->plt,
13673                                         h->dynindx, 0);
13674         }
13675
13676       if (!h->def_regular)
13677         {
13678           /* Mark the symbol as undefined, rather than as defined in
13679              the .plt section.  Leave the value alone.  */
13680           sym->st_shndx = SHN_UNDEF;
13681           /* If the symbol is weak, we do need to clear the value.
13682              Otherwise, the PLT entry would provide a definition for
13683              the symbol even if the symbol wasn't defined anywhere,
13684              and so the symbol would never be NULL.  */
13685           if (!h->ref_regular_nonweak)
13686             sym->st_value = 0;
13687         }
13688       else if (eh->is_iplt && eh->plt.noncall_refcount != 0)
13689         {
13690           /* At least one non-call relocation references this .iplt entry,
13691              so the .iplt entry is the function's canonical address.  */
13692           sym->st_info = ELF_ST_INFO (ELF_ST_BIND (sym->st_info), STT_FUNC);
13693           sym->st_target_internal = ST_BRANCH_TO_ARM;
13694           sym->st_shndx = (_bfd_elf_section_from_bfd_section
13695                            (output_bfd, htab->root.iplt->output_section));
13696           sym->st_value = (h->plt.offset
13697                            + htab->root.iplt->output_section->vma
13698                            + htab->root.iplt->output_offset);
13699         }
13700     }
13701
13702   if (h->needs_copy)
13703     {
13704       asection * s;
13705       Elf_Internal_Rela rel;
13706
13707       /* This symbol needs a copy reloc.  Set it up.  */
13708       BFD_ASSERT (h->dynindx != -1
13709                   && (h->root.type == bfd_link_hash_defined
13710                       || h->root.type == bfd_link_hash_defweak));
13711
13712       s = htab->srelbss;
13713       BFD_ASSERT (s != NULL);
13714
13715       rel.r_addend = 0;
13716       rel.r_offset = (h->root.u.def.value
13717                       + h->root.u.def.section->output_section->vma
13718                       + h->root.u.def.section->output_offset);
13719       rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_COPY);
13720       elf32_arm_add_dynreloc (output_bfd, info, s, &rel);
13721     }
13722
13723   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  On VxWorks,
13724      the _GLOBAL_OFFSET_TABLE_ symbol is not absolute: it is relative
13725      to the ".got" section.  */
13726   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
13727       || (!htab->vxworks_p && h == htab->root.hgot))
13728     sym->st_shndx = SHN_ABS;
13729
13730   return TRUE;
13731 }
13732
13733 static void
13734 arm_put_trampoline (struct elf32_arm_link_hash_table *htab, bfd *output_bfd,
13735                     void *contents,
13736                     const unsigned long *template, unsigned count)
13737 {
13738   unsigned ix;
13739
13740   for (ix = 0; ix != count; ix++)
13741     {
13742       unsigned long insn = template[ix];
13743
13744       /* Emit mov pc,rx if bx is not permitted.  */
13745       if (htab->fix_v4bx == 1 && (insn & 0x0ffffff0) == 0x012fff10)
13746         insn = (insn & 0xf000000f) | 0x01a0f000;
13747       put_arm_insn (htab, output_bfd, insn, (char *)contents + ix*4);
13748     }
13749 }
13750
13751 /* Finish up the dynamic sections.  */
13752
13753 static bfd_boolean
13754 elf32_arm_finish_dynamic_sections (bfd * output_bfd, struct bfd_link_info * info)
13755 {
13756   bfd * dynobj;
13757   asection * sgot;
13758   asection * sdyn;
13759   struct elf32_arm_link_hash_table *htab;
13760
13761   htab = elf32_arm_hash_table (info);
13762   if (htab == NULL)
13763     return FALSE;
13764
13765   dynobj = elf_hash_table (info)->dynobj;
13766
13767   sgot = htab->root.sgotplt;
13768   /* A broken linker script might have discarded the dynamic sections.
13769      Catch this here so that we do not seg-fault later on.  */
13770   if (sgot != NULL && bfd_is_abs_section (sgot->output_section))
13771     return FALSE;
13772   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
13773
13774   if (elf_hash_table (info)->dynamic_sections_created)
13775     {
13776       asection *splt;
13777       Elf32_External_Dyn *dyncon, *dynconend;
13778
13779       splt = htab->root.splt;
13780       BFD_ASSERT (splt != NULL && sdyn != NULL);
13781       BFD_ASSERT (htab->symbian_p || sgot != NULL);
13782
13783       dyncon = (Elf32_External_Dyn *) sdyn->contents;
13784       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
13785
13786       for (; dyncon < dynconend; dyncon++)
13787         {
13788           Elf_Internal_Dyn dyn;
13789           const char * name;
13790           asection * s;
13791
13792           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
13793
13794           switch (dyn.d_tag)
13795             {
13796               unsigned int type;
13797
13798             default:
13799               if (htab->vxworks_p
13800                   && elf_vxworks_finish_dynamic_entry (output_bfd, &dyn))
13801                 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
13802               break;
13803
13804             case DT_HASH:
13805               name = ".hash";
13806               goto get_vma_if_bpabi;
13807             case DT_STRTAB:
13808               name = ".dynstr";
13809               goto get_vma_if_bpabi;
13810             case DT_SYMTAB:
13811               name = ".dynsym";
13812               goto get_vma_if_bpabi;
13813             case DT_VERSYM:
13814               name = ".gnu.version";
13815               goto get_vma_if_bpabi;
13816             case DT_VERDEF:
13817               name = ".gnu.version_d";
13818               goto get_vma_if_bpabi;
13819             case DT_VERNEED:
13820               name = ".gnu.version_r";
13821               goto get_vma_if_bpabi;
13822
13823             case DT_PLTGOT:
13824               name = ".got";
13825               goto get_vma;
13826             case DT_JMPREL:
13827               name = RELOC_SECTION (htab, ".plt");
13828             get_vma:
13829               s = bfd_get_section_by_name (output_bfd, name);
13830               BFD_ASSERT (s != NULL);
13831               if (!htab->symbian_p)
13832                 dyn.d_un.d_ptr = s->vma;
13833               else
13834                 /* In the BPABI, tags in the PT_DYNAMIC section point
13835                    at the file offset, not the memory address, for the
13836                    convenience of the post linker.  */
13837                 dyn.d_un.d_ptr = s->filepos;
13838               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
13839               break;
13840
13841             get_vma_if_bpabi:
13842               if (htab->symbian_p)
13843                 goto get_vma;
13844               break;
13845
13846             case DT_PLTRELSZ:
13847               s = htab->root.srelplt;
13848               BFD_ASSERT (s != NULL);
13849               dyn.d_un.d_val = s->size;
13850               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
13851               break;
13852
13853             case DT_RELSZ:
13854             case DT_RELASZ:
13855               if (!htab->symbian_p)
13856                 {
13857                   /* My reading of the SVR4 ABI indicates that the
13858                      procedure linkage table relocs (DT_JMPREL) should be
13859                      included in the overall relocs (DT_REL).  This is
13860                      what Solaris does.  However, UnixWare can not handle
13861                      that case.  Therefore, we override the DT_RELSZ entry
13862                      here to make it not include the JMPREL relocs.  Since
13863                      the linker script arranges for .rel(a).plt to follow all
13864                      other relocation sections, we don't have to worry
13865                      about changing the DT_REL entry.  */
13866                   s = htab->root.srelplt;
13867                   if (s != NULL)
13868                     dyn.d_un.d_val -= s->size;
13869                   bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
13870                   break;
13871                 }
13872               /* Fall through.  */
13873
13874             case DT_REL:
13875             case DT_RELA:
13876               /* In the BPABI, the DT_REL tag must point at the file
13877                  offset, not the VMA, of the first relocation
13878                  section.  So, we use code similar to that in
13879                  elflink.c, but do not check for SHF_ALLOC on the
13880                  relcoation section, since relocations sections are
13881                  never allocated under the BPABI.  The comments above
13882                  about Unixware notwithstanding, we include all of the
13883                  relocations here.  */
13884               if (htab->symbian_p)
13885                 {
13886                   unsigned int i;
13887                   type = ((dyn.d_tag == DT_REL || dyn.d_tag == DT_RELSZ)
13888                           ? SHT_REL : SHT_RELA);
13889                   dyn.d_un.d_val = 0;
13890                   for (i = 1; i < elf_numsections (output_bfd); i++)
13891                     {
13892                       Elf_Internal_Shdr *hdr
13893                         = elf_elfsections (output_bfd)[i];
13894                       if (hdr->sh_type == type)
13895                         {
13896                           if (dyn.d_tag == DT_RELSZ
13897                               || dyn.d_tag == DT_RELASZ)
13898                             dyn.d_un.d_val += hdr->sh_size;
13899                           else if ((ufile_ptr) hdr->sh_offset
13900                                    <= dyn.d_un.d_val - 1)
13901                             dyn.d_un.d_val = hdr->sh_offset;
13902                         }
13903                     }
13904                   bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
13905                 }
13906               break;
13907
13908             case DT_TLSDESC_PLT:
13909               s = htab->root.splt;
13910               dyn.d_un.d_ptr = (s->output_section->vma + s->output_offset
13911                                 + htab->dt_tlsdesc_plt);
13912               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
13913               break;
13914
13915             case DT_TLSDESC_GOT:
13916               s = htab->root.sgot;
13917               dyn.d_un.d_ptr = (s->output_section->vma + s->output_offset
13918                                 + htab->dt_tlsdesc_got);
13919               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
13920               break;
13921
13922               /* Set the bottom bit of DT_INIT/FINI if the
13923                  corresponding function is Thumb.  */
13924             case DT_INIT:
13925               name = info->init_function;
13926               goto get_sym;
13927             case DT_FINI:
13928               name = info->fini_function;
13929             get_sym:
13930               /* If it wasn't set by elf_bfd_final_link
13931                  then there is nothing to adjust.  */
13932               if (dyn.d_un.d_val != 0)
13933                 {
13934                   struct elf_link_hash_entry * eh;
13935
13936                   eh = elf_link_hash_lookup (elf_hash_table (info), name,
13937                                              FALSE, FALSE, TRUE);
13938                   if (eh != NULL && eh->target_internal == ST_BRANCH_TO_THUMB)
13939                     {
13940                       dyn.d_un.d_val |= 1;
13941                       bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
13942                     }
13943                 }
13944               break;
13945             }
13946         }
13947
13948       /* Fill in the first entry in the procedure linkage table.  */
13949       if (splt->size > 0 && htab->plt_header_size)
13950         {
13951           const bfd_vma *plt0_entry;
13952           bfd_vma got_address, plt_address, got_displacement;
13953
13954           /* Calculate the addresses of the GOT and PLT.  */
13955           got_address = sgot->output_section->vma + sgot->output_offset;
13956           plt_address = splt->output_section->vma + splt->output_offset;
13957
13958           if (htab->vxworks_p)
13959             {
13960               /* The VxWorks GOT is relocated by the dynamic linker.
13961                  Therefore, we must emit relocations rather than simply
13962                  computing the values now.  */
13963               Elf_Internal_Rela rel;
13964
13965               plt0_entry = elf32_arm_vxworks_exec_plt0_entry;
13966               put_arm_insn (htab, output_bfd, plt0_entry[0],
13967                             splt->contents + 0);
13968               put_arm_insn (htab, output_bfd, plt0_entry[1],
13969                             splt->contents + 4);
13970               put_arm_insn (htab, output_bfd, plt0_entry[2],
13971                             splt->contents + 8);
13972               bfd_put_32 (output_bfd, got_address, splt->contents + 12);
13973
13974               /* Generate a relocation for _GLOBAL_OFFSET_TABLE_.  */
13975               rel.r_offset = plt_address + 12;
13976               rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_ARM_ABS32);
13977               rel.r_addend = 0;
13978               SWAP_RELOC_OUT (htab) (output_bfd, &rel,
13979                                      htab->srelplt2->contents);
13980             }
13981           else
13982             {
13983               got_displacement = got_address - (plt_address + 16);
13984
13985               plt0_entry = elf32_arm_plt0_entry;
13986               put_arm_insn (htab, output_bfd, plt0_entry[0],
13987                             splt->contents + 0);
13988               put_arm_insn (htab, output_bfd, plt0_entry[1],
13989                             splt->contents + 4);
13990               put_arm_insn (htab, output_bfd, plt0_entry[2],
13991                             splt->contents + 8);
13992               put_arm_insn (htab, output_bfd, plt0_entry[3],
13993                             splt->contents + 12);
13994
13995 #ifdef FOUR_WORD_PLT
13996               /* The displacement value goes in the otherwise-unused
13997                  last word of the second entry.  */
13998               bfd_put_32 (output_bfd, got_displacement, splt->contents + 28);
13999 #else
14000               bfd_put_32 (output_bfd, got_displacement, splt->contents + 16);
14001 #endif
14002             }
14003         }
14004
14005       /* UnixWare sets the entsize of .plt to 4, although that doesn't
14006          really seem like the right value.  */
14007       if (splt->output_section->owner == output_bfd)
14008         elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
14009
14010       if (htab->dt_tlsdesc_plt)
14011         {
14012           bfd_vma got_address
14013             = sgot->output_section->vma + sgot->output_offset;
14014           bfd_vma gotplt_address = (htab->root.sgot->output_section->vma
14015                                     + htab->root.sgot->output_offset);
14016           bfd_vma plt_address
14017             = splt->output_section->vma + splt->output_offset;
14018
14019           arm_put_trampoline (htab, output_bfd,
14020                               splt->contents + htab->dt_tlsdesc_plt,
14021                               dl_tlsdesc_lazy_trampoline, 6);
14022
14023           bfd_put_32 (output_bfd,
14024                       gotplt_address + htab->dt_tlsdesc_got
14025                       - (plt_address + htab->dt_tlsdesc_plt)
14026                       - dl_tlsdesc_lazy_trampoline[6],
14027                       splt->contents + htab->dt_tlsdesc_plt + 24);
14028           bfd_put_32 (output_bfd,
14029                       got_address - (plt_address + htab->dt_tlsdesc_plt)
14030                       - dl_tlsdesc_lazy_trampoline[7],
14031                       splt->contents + htab->dt_tlsdesc_plt + 24 + 4);
14032         }
14033
14034       if (htab->tls_trampoline)
14035         {
14036           arm_put_trampoline (htab, output_bfd,
14037                               splt->contents + htab->tls_trampoline,
14038                               tls_trampoline, 3);
14039 #ifdef FOUR_WORD_PLT
14040           bfd_put_32 (output_bfd, 0x00000000,
14041                       splt->contents + htab->tls_trampoline + 12);
14042 #endif
14043         }
14044
14045       if (htab->vxworks_p && !info->shared && htab->root.splt->size > 0)
14046         {
14047           /* Correct the .rel(a).plt.unloaded relocations.  They will have
14048              incorrect symbol indexes.  */
14049           int num_plts;
14050           unsigned char *p;
14051
14052           num_plts = ((htab->root.splt->size - htab->plt_header_size)
14053                       / htab->plt_entry_size);
14054           p = htab->srelplt2->contents + RELOC_SIZE (htab);
14055
14056           for (; num_plts; num_plts--)
14057             {
14058               Elf_Internal_Rela rel;
14059
14060               SWAP_RELOC_IN (htab) (output_bfd, p, &rel);
14061               rel.r_info = ELF32_R_INFO (htab->root.hgot->indx, R_ARM_ABS32);
14062               SWAP_RELOC_OUT (htab) (output_bfd, &rel, p);
14063               p += RELOC_SIZE (htab);
14064
14065               SWAP_RELOC_IN (htab) (output_bfd, p, &rel);
14066               rel.r_info = ELF32_R_INFO (htab->root.hplt->indx, R_ARM_ABS32);
14067               SWAP_RELOC_OUT (htab) (output_bfd, &rel, p);
14068               p += RELOC_SIZE (htab);
14069             }
14070         }
14071     }
14072
14073   /* Fill in the first three entries in the global offset table.  */
14074   if (sgot)
14075     {
14076       if (sgot->size > 0)
14077         {
14078           if (sdyn == NULL)
14079             bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
14080           else
14081             bfd_put_32 (output_bfd,
14082                         sdyn->output_section->vma + sdyn->output_offset,
14083                         sgot->contents);
14084           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
14085           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
14086         }
14087
14088       elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
14089     }
14090
14091   return TRUE;
14092 }
14093
14094 static void
14095 elf32_arm_post_process_headers (bfd * abfd, struct bfd_link_info * link_info ATTRIBUTE_UNUSED)
14096 {
14097   Elf_Internal_Ehdr * i_ehdrp;  /* ELF file header, internal form.  */
14098   struct elf32_arm_link_hash_table *globals;
14099
14100   i_ehdrp = elf_elfheader (abfd);
14101
14102   if (EF_ARM_EABI_VERSION (i_ehdrp->e_flags) == EF_ARM_EABI_UNKNOWN)
14103     i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_ARM;
14104   else
14105     i_ehdrp->e_ident[EI_OSABI] = 0;
14106   i_ehdrp->e_ident[EI_ABIVERSION] = ARM_ELF_ABI_VERSION;
14107
14108   if (link_info)
14109     {
14110       globals = elf32_arm_hash_table (link_info);
14111       if (globals != NULL && globals->byteswap_code)
14112         i_ehdrp->e_flags |= EF_ARM_BE8;
14113     }
14114 }
14115
14116 static enum elf_reloc_type_class
14117 elf32_arm_reloc_type_class (const Elf_Internal_Rela *rela)
14118 {
14119   switch ((int) ELF32_R_TYPE (rela->r_info))
14120     {
14121     case R_ARM_RELATIVE:
14122       return reloc_class_relative;
14123     case R_ARM_JUMP_SLOT:
14124       return reloc_class_plt;
14125     case R_ARM_COPY:
14126       return reloc_class_copy;
14127     default:
14128       return reloc_class_normal;
14129     }
14130 }
14131
14132 static void
14133 elf32_arm_final_write_processing (bfd *abfd, bfd_boolean linker ATTRIBUTE_UNUSED)
14134 {
14135   bfd_arm_update_notes (abfd, ARM_NOTE_SECTION);
14136 }
14137
14138 /* Return TRUE if this is an unwinding table entry.  */
14139
14140 static bfd_boolean
14141 is_arm_elf_unwind_section_name (bfd * abfd ATTRIBUTE_UNUSED, const char * name)
14142 {
14143   return (CONST_STRNEQ (name, ELF_STRING_ARM_unwind)
14144           || CONST_STRNEQ (name, ELF_STRING_ARM_unwind_once));
14145 }
14146
14147
14148 /* Set the type and flags for an ARM section.  We do this by
14149    the section name, which is a hack, but ought to work.  */
14150
14151 static bfd_boolean
14152 elf32_arm_fake_sections (bfd * abfd, Elf_Internal_Shdr * hdr, asection * sec)
14153 {
14154   const char * name;
14155
14156   name = bfd_get_section_name (abfd, sec);
14157
14158   if (is_arm_elf_unwind_section_name (abfd, name))
14159     {
14160       hdr->sh_type = SHT_ARM_EXIDX;
14161       hdr->sh_flags |= SHF_LINK_ORDER;
14162     }
14163   return TRUE;
14164 }
14165
14166 /* Handle an ARM specific section when reading an object file.  This is
14167    called when bfd_section_from_shdr finds a section with an unknown
14168    type.  */
14169
14170 static bfd_boolean
14171 elf32_arm_section_from_shdr (bfd *abfd,
14172                              Elf_Internal_Shdr * hdr,
14173                              const char *name,
14174                              int shindex)
14175 {
14176   /* There ought to be a place to keep ELF backend specific flags, but
14177      at the moment there isn't one.  We just keep track of the
14178      sections by their name, instead.  Fortunately, the ABI gives
14179      names for all the ARM specific sections, so we will probably get
14180      away with this.  */
14181   switch (hdr->sh_type)
14182     {
14183     case SHT_ARM_EXIDX:
14184     case SHT_ARM_PREEMPTMAP:
14185     case SHT_ARM_ATTRIBUTES:
14186       break;
14187
14188     default:
14189       return FALSE;
14190     }
14191
14192   if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
14193     return FALSE;
14194
14195   return TRUE;
14196 }
14197
14198 static _arm_elf_section_data *
14199 get_arm_elf_section_data (asection * sec)
14200 {
14201   if (sec && sec->owner && is_arm_elf (sec->owner))
14202     return elf32_arm_section_data (sec);
14203   else
14204     return NULL;
14205 }
14206
14207 typedef struct
14208 {
14209   void *finfo;
14210   struct bfd_link_info *info;
14211   asection *sec;
14212   int sec_shndx;
14213   int (*func) (void *, const char *, Elf_Internal_Sym *,
14214                asection *, struct elf_link_hash_entry *);
14215 } output_arch_syminfo;
14216
14217 enum map_symbol_type
14218 {
14219   ARM_MAP_ARM,
14220   ARM_MAP_THUMB,
14221   ARM_MAP_DATA
14222 };
14223
14224
14225 /* Output a single mapping symbol.  */
14226
14227 static bfd_boolean
14228 elf32_arm_output_map_sym (output_arch_syminfo *osi,
14229                           enum map_symbol_type type,
14230                           bfd_vma offset)
14231 {
14232   static const char *names[3] = {"$a", "$t", "$d"};
14233   Elf_Internal_Sym sym;
14234
14235   sym.st_value = osi->sec->output_section->vma
14236                  + osi->sec->output_offset
14237                  + offset;
14238   sym.st_size = 0;
14239   sym.st_other = 0;
14240   sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_NOTYPE);
14241   sym.st_shndx = osi->sec_shndx;
14242   sym.st_target_internal = 0;
14243   elf32_arm_section_map_add (osi->sec, names[type][1], offset);
14244   return osi->func (osi->finfo, names[type], &sym, osi->sec, NULL) == 1;
14245 }
14246
14247 /* Output mapping symbols for the PLT entry described by ROOT_PLT and ARM_PLT.
14248    IS_IPLT_ENTRY_P says whether the PLT is in .iplt rather than .plt.  */
14249
14250 static bfd_boolean
14251 elf32_arm_output_plt_map_1 (output_arch_syminfo *osi,
14252                             bfd_boolean is_iplt_entry_p,
14253                             union gotplt_union *root_plt,
14254                             struct arm_plt_info *arm_plt)
14255 {
14256   struct elf32_arm_link_hash_table *htab;
14257   bfd_vma addr, plt_header_size;
14258
14259   if (root_plt->offset == (bfd_vma) -1)
14260     return TRUE;
14261
14262   htab = elf32_arm_hash_table (osi->info);
14263   if (htab == NULL)
14264     return FALSE;
14265
14266   if (is_iplt_entry_p)
14267     {
14268       osi->sec = htab->root.iplt;
14269       plt_header_size = 0;
14270     }
14271   else
14272     {
14273       osi->sec = htab->root.splt;
14274       plt_header_size = htab->plt_header_size;
14275     }
14276   osi->sec_shndx = (_bfd_elf_section_from_bfd_section
14277                     (osi->info->output_bfd, osi->sec->output_section));
14278
14279   addr = root_plt->offset & -2;
14280   if (htab->symbian_p)
14281     {
14282       if (!elf32_arm_output_map_sym (osi, ARM_MAP_ARM, addr))
14283         return FALSE;
14284       if (!elf32_arm_output_map_sym (osi, ARM_MAP_DATA, addr + 4))
14285         return FALSE;
14286     }
14287   else if (htab->vxworks_p)
14288     {
14289       if (!elf32_arm_output_map_sym (osi, ARM_MAP_ARM, addr))
14290         return FALSE;
14291       if (!elf32_arm_output_map_sym (osi, ARM_MAP_DATA, addr + 8))
14292         return FALSE;
14293       if (!elf32_arm_output_map_sym (osi, ARM_MAP_ARM, addr + 12))
14294         return FALSE;
14295       if (!elf32_arm_output_map_sym (osi, ARM_MAP_DATA, addr + 20))
14296         return FALSE;
14297     }
14298   else
14299     {
14300       bfd_boolean thumb_stub_p;
14301
14302       thumb_stub_p = elf32_arm_plt_needs_thumb_stub_p (osi->info, arm_plt);
14303       if (thumb_stub_p)
14304         {
14305           if (!elf32_arm_output_map_sym (osi, ARM_MAP_THUMB, addr - 4))
14306             return FALSE;
14307         }
14308 #ifdef FOUR_WORD_PLT
14309       if (!elf32_arm_output_map_sym (osi, ARM_MAP_ARM, addr))
14310         return FALSE;
14311       if (!elf32_arm_output_map_sym (osi, ARM_MAP_DATA, addr + 12))
14312         return FALSE;
14313 #else
14314       /* A three-word PLT with no Thumb thunk contains only Arm code,
14315          so only need to output a mapping symbol for the first PLT entry and
14316          entries with thumb thunks.  */
14317       if (thumb_stub_p || addr == plt_header_size)
14318         {
14319           if (!elf32_arm_output_map_sym (osi, ARM_MAP_ARM, addr))
14320             return FALSE;
14321         }
14322 #endif
14323     }
14324
14325   return TRUE;
14326 }
14327
14328 /* Output mapping symbols for PLT entries associated with H.  */
14329
14330 static bfd_boolean
14331 elf32_arm_output_plt_map (struct elf_link_hash_entry *h, void *inf)
14332 {
14333   output_arch_syminfo *osi = (output_arch_syminfo *) inf;
14334   struct elf32_arm_link_hash_entry *eh;
14335
14336   if (h->root.type == bfd_link_hash_indirect)
14337     return TRUE;
14338
14339   if (h->root.type == bfd_link_hash_warning)
14340     /* When warning symbols are created, they **replace** the "real"
14341        entry in the hash table, thus we never get to see the real
14342        symbol in a hash traversal.  So look at it now.  */
14343     h = (struct elf_link_hash_entry *) h->root.u.i.link;
14344
14345   eh = (struct elf32_arm_link_hash_entry *) h;
14346   return elf32_arm_output_plt_map_1 (osi, SYMBOL_CALLS_LOCAL (osi->info, h),
14347                                      &h->plt, &eh->plt);
14348 }
14349
14350 /* Output a single local symbol for a generated stub.  */
14351
14352 static bfd_boolean
14353 elf32_arm_output_stub_sym (output_arch_syminfo *osi, const char *name,
14354                            bfd_vma offset, bfd_vma size)
14355 {
14356   Elf_Internal_Sym sym;
14357
14358   sym.st_value = osi->sec->output_section->vma
14359                  + osi->sec->output_offset
14360                  + offset;
14361   sym.st_size = size;
14362   sym.st_other = 0;
14363   sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
14364   sym.st_shndx = osi->sec_shndx;
14365   sym.st_target_internal = 0;
14366   return osi->func (osi->finfo, name, &sym, osi->sec, NULL) == 1;
14367 }
14368
14369 static bfd_boolean
14370 arm_map_one_stub (struct bfd_hash_entry * gen_entry,
14371                   void * in_arg)
14372 {
14373   struct elf32_arm_stub_hash_entry *stub_entry;
14374   asection *stub_sec;
14375   bfd_vma addr;
14376   char *stub_name;
14377   output_arch_syminfo *osi;
14378   const insn_sequence *template_sequence;
14379   enum stub_insn_type prev_type;
14380   int size;
14381   int i;
14382   enum map_symbol_type sym_type;
14383
14384   /* Massage our args to the form they really have.  */
14385   stub_entry = (struct elf32_arm_stub_hash_entry *) gen_entry;
14386   osi = (output_arch_syminfo *) in_arg;
14387
14388   stub_sec = stub_entry->stub_sec;
14389
14390   /* Ensure this stub is attached to the current section being
14391      processed.  */
14392   if (stub_sec != osi->sec)
14393     return TRUE;
14394
14395   addr = (bfd_vma) stub_entry->stub_offset;
14396   stub_name = stub_entry->output_name;
14397
14398   template_sequence = stub_entry->stub_template;
14399   switch (template_sequence[0].type)
14400     {
14401     case ARM_TYPE:
14402       if (!elf32_arm_output_stub_sym (osi, stub_name, addr, stub_entry->stub_size))
14403         return FALSE;
14404       break;
14405     case THUMB16_TYPE:
14406     case THUMB32_TYPE:
14407       if (!elf32_arm_output_stub_sym (osi, stub_name, addr | 1,
14408                                       stub_entry->stub_size))
14409         return FALSE;
14410       break;
14411     default:
14412       BFD_FAIL ();
14413       return 0;
14414     }
14415
14416   prev_type = DATA_TYPE;
14417   size = 0;
14418   for (i = 0; i < stub_entry->stub_template_size; i++)
14419     {
14420       switch (template_sequence[i].type)
14421         {
14422         case ARM_TYPE:
14423           sym_type = ARM_MAP_ARM;
14424           break;
14425
14426         case THUMB16_TYPE:
14427         case THUMB32_TYPE:
14428           sym_type = ARM_MAP_THUMB;
14429           break;
14430
14431         case DATA_TYPE:
14432           sym_type = ARM_MAP_DATA;
14433           break;
14434
14435         default:
14436           BFD_FAIL ();
14437           return FALSE;
14438         }
14439
14440       if (template_sequence[i].type != prev_type)
14441         {
14442           prev_type = template_sequence[i].type;
14443           if (!elf32_arm_output_map_sym (osi, sym_type, addr + size))
14444             return FALSE;
14445         }
14446
14447       switch (template_sequence[i].type)
14448         {
14449         case ARM_TYPE:
14450         case THUMB32_TYPE:
14451           size += 4;
14452           break;
14453
14454         case THUMB16_TYPE:
14455           size += 2;
14456           break;
14457
14458         case DATA_TYPE:
14459           size += 4;
14460           break;
14461
14462         default:
14463           BFD_FAIL ();
14464           return FALSE;
14465         }
14466     }
14467
14468   return TRUE;
14469 }
14470
14471 /* Output mapping symbols for linker generated sections,
14472    and for those data-only sections that do not have a
14473    $d.  */
14474
14475 static bfd_boolean
14476 elf32_arm_output_arch_local_syms (bfd *output_bfd,
14477                                   struct bfd_link_info *info,
14478                                   void *finfo,
14479                                   int (*func) (void *, const char *,
14480                                                Elf_Internal_Sym *,
14481                                                asection *,
14482                                                struct elf_link_hash_entry *))
14483 {
14484   output_arch_syminfo osi;
14485   struct elf32_arm_link_hash_table *htab;
14486   bfd_vma offset;
14487   bfd_size_type size;
14488   bfd *input_bfd;
14489
14490   htab = elf32_arm_hash_table (info);
14491   if (htab == NULL)
14492     return FALSE;
14493
14494   check_use_blx (htab);
14495
14496   osi.finfo = finfo;
14497   osi.info = info;
14498   osi.func = func;
14499
14500   /* Add a $d mapping symbol to data-only sections that
14501      don't have any mapping symbol.  This may result in (harmless) redundant
14502      mapping symbols.  */
14503   for (input_bfd = info->input_bfds;
14504        input_bfd != NULL;
14505        input_bfd = input_bfd->link_next)
14506     {
14507       if ((input_bfd->flags & (BFD_LINKER_CREATED | HAS_SYMS)) == HAS_SYMS)
14508         for (osi.sec = input_bfd->sections;
14509              osi.sec != NULL;
14510              osi.sec = osi.sec->next)
14511           {
14512             if (osi.sec->output_section != NULL
14513                 && ((osi.sec->output_section->flags & (SEC_ALLOC | SEC_CODE))
14514                     != 0)
14515                 && (osi.sec->flags & (SEC_HAS_CONTENTS | SEC_LINKER_CREATED))
14516                    == SEC_HAS_CONTENTS
14517                 && get_arm_elf_section_data (osi.sec) != NULL
14518                 && get_arm_elf_section_data (osi.sec)->mapcount == 0
14519                 && osi.sec->size > 0
14520                 && (osi.sec->flags & SEC_EXCLUDE) == 0)
14521               {
14522                 osi.sec_shndx = _bfd_elf_section_from_bfd_section
14523                   (output_bfd, osi.sec->output_section);
14524                 if (osi.sec_shndx != (int)SHN_BAD)
14525                   elf32_arm_output_map_sym (&osi, ARM_MAP_DATA, 0);
14526               }
14527           }
14528     }
14529
14530   /* ARM->Thumb glue.  */
14531   if (htab->arm_glue_size > 0)
14532     {
14533       osi.sec = bfd_get_section_by_name (htab->bfd_of_glue_owner,
14534                                          ARM2THUMB_GLUE_SECTION_NAME);
14535
14536       osi.sec_shndx = _bfd_elf_section_from_bfd_section
14537           (output_bfd, osi.sec->output_section);
14538       if (info->shared || htab->root.is_relocatable_executable
14539           || htab->pic_veneer)
14540         size = ARM2THUMB_PIC_GLUE_SIZE;
14541       else if (htab->use_blx)
14542         size = ARM2THUMB_V5_STATIC_GLUE_SIZE;
14543       else
14544         size = ARM2THUMB_STATIC_GLUE_SIZE;
14545
14546       for (offset = 0; offset < htab->arm_glue_size; offset += size)
14547         {
14548           elf32_arm_output_map_sym (&osi, ARM_MAP_ARM, offset);
14549           elf32_arm_output_map_sym (&osi, ARM_MAP_DATA, offset + size - 4);
14550         }
14551     }
14552
14553   /* Thumb->ARM glue.  */
14554   if (htab->thumb_glue_size > 0)
14555     {
14556       osi.sec = bfd_get_section_by_name (htab->bfd_of_glue_owner,
14557                                          THUMB2ARM_GLUE_SECTION_NAME);
14558
14559       osi.sec_shndx = _bfd_elf_section_from_bfd_section
14560           (output_bfd, osi.sec->output_section);
14561       size = THUMB2ARM_GLUE_SIZE;
14562
14563       for (offset = 0; offset < htab->thumb_glue_size; offset += size)
14564         {
14565           elf32_arm_output_map_sym (&osi, ARM_MAP_THUMB, offset);
14566           elf32_arm_output_map_sym (&osi, ARM_MAP_ARM, offset + 4);
14567         }
14568     }
14569
14570   /* ARMv4 BX veneers.  */
14571   if (htab->bx_glue_size > 0)
14572     {
14573       osi.sec = bfd_get_section_by_name (htab->bfd_of_glue_owner,
14574                                          ARM_BX_GLUE_SECTION_NAME);
14575
14576       osi.sec_shndx = _bfd_elf_section_from_bfd_section
14577           (output_bfd, osi.sec->output_section);
14578
14579       elf32_arm_output_map_sym (&osi, ARM_MAP_ARM, 0);
14580     }
14581
14582   /* Long calls stubs.  */
14583   if (htab->stub_bfd && htab->stub_bfd->sections)
14584     {
14585       asection* stub_sec;
14586
14587       for (stub_sec = htab->stub_bfd->sections;
14588            stub_sec != NULL;
14589            stub_sec = stub_sec->next)
14590         {
14591           /* Ignore non-stub sections.  */
14592           if (!strstr (stub_sec->name, STUB_SUFFIX))
14593             continue;
14594
14595           osi.sec = stub_sec;
14596
14597           osi.sec_shndx = _bfd_elf_section_from_bfd_section
14598             (output_bfd, osi.sec->output_section);
14599
14600           bfd_hash_traverse (&htab->stub_hash_table, arm_map_one_stub, &osi);
14601         }
14602     }
14603
14604   /* Finally, output mapping symbols for the PLT.  */
14605   if (htab->root.splt && htab->root.splt->size > 0)
14606     {
14607       osi.sec = htab->root.splt;
14608       osi.sec_shndx = (_bfd_elf_section_from_bfd_section
14609                        (output_bfd, osi.sec->output_section));
14610
14611       /* Output mapping symbols for the plt header.  SymbianOS does not have a
14612          plt header.  */
14613       if (htab->vxworks_p)
14614         {
14615           /* VxWorks shared libraries have no PLT header.  */
14616           if (!info->shared)
14617             {
14618               if (!elf32_arm_output_map_sym (&osi, ARM_MAP_ARM, 0))
14619                 return FALSE;
14620               if (!elf32_arm_output_map_sym (&osi, ARM_MAP_DATA, 12))
14621                 return FALSE;
14622             }
14623         }
14624       else if (!htab->symbian_p)
14625         {
14626           if (!elf32_arm_output_map_sym (&osi, ARM_MAP_ARM, 0))
14627             return FALSE;
14628 #ifndef FOUR_WORD_PLT
14629           if (!elf32_arm_output_map_sym (&osi, ARM_MAP_DATA, 16))
14630             return FALSE;
14631 #endif
14632         }
14633     }
14634   if ((htab->root.splt && htab->root.splt->size > 0)
14635       || (htab->root.iplt && htab->root.iplt->size > 0))
14636     {
14637       elf_link_hash_traverse (&htab->root, elf32_arm_output_plt_map, &osi);
14638       for (input_bfd = info->input_bfds;
14639            input_bfd != NULL;
14640            input_bfd = input_bfd->link_next)
14641         {
14642           struct arm_local_iplt_info **local_iplt;
14643           unsigned int i, num_syms;
14644
14645           local_iplt = elf32_arm_local_iplt (input_bfd);
14646           if (local_iplt != NULL)
14647             {
14648               num_syms = elf_symtab_hdr (input_bfd).sh_info;
14649               for (i = 0; i < num_syms; i++)
14650                 if (local_iplt[i] != NULL
14651                     && !elf32_arm_output_plt_map_1 (&osi, TRUE,
14652                                                     &local_iplt[i]->root,
14653                                                     &local_iplt[i]->arm))
14654                   return FALSE;
14655             }
14656         }
14657     }
14658   if (htab->dt_tlsdesc_plt != 0)
14659     {
14660       /* Mapping symbols for the lazy tls trampoline.  */
14661       if (!elf32_arm_output_map_sym (&osi, ARM_MAP_ARM, htab->dt_tlsdesc_plt))
14662         return FALSE;
14663
14664       if (!elf32_arm_output_map_sym (&osi, ARM_MAP_DATA,
14665                                      htab->dt_tlsdesc_plt + 24))
14666         return FALSE;
14667     }
14668   if (htab->tls_trampoline != 0)
14669     {
14670       /* Mapping symbols for the tls trampoline.  */
14671       if (!elf32_arm_output_map_sym (&osi, ARM_MAP_ARM, htab->tls_trampoline))
14672         return FALSE;
14673 #ifdef FOUR_WORD_PLT
14674       if (!elf32_arm_output_map_sym (&osi, ARM_MAP_DATA,
14675                                      htab->tls_trampoline + 12))
14676         return FALSE;
14677 #endif
14678     }
14679
14680   return TRUE;
14681 }
14682
14683 /* Allocate target specific section data.  */
14684
14685 static bfd_boolean
14686 elf32_arm_new_section_hook (bfd *abfd, asection *sec)
14687 {
14688   if (!sec->used_by_bfd)
14689     {
14690       _arm_elf_section_data *sdata;
14691       bfd_size_type amt = sizeof (*sdata);
14692
14693       sdata = (_arm_elf_section_data *) bfd_zalloc (abfd, amt);
14694       if (sdata == NULL)
14695         return FALSE;
14696       sec->used_by_bfd = sdata;
14697     }
14698
14699   return _bfd_elf_new_section_hook (abfd, sec);
14700 }
14701
14702
14703 /* Used to order a list of mapping symbols by address.  */
14704
14705 static int
14706 elf32_arm_compare_mapping (const void * a, const void * b)
14707 {
14708   const elf32_arm_section_map *amap = (const elf32_arm_section_map *) a;
14709   const elf32_arm_section_map *bmap = (const elf32_arm_section_map *) b;
14710
14711   if (amap->vma > bmap->vma)
14712     return 1;
14713   else if (amap->vma < bmap->vma)
14714     return -1;
14715   else if (amap->type > bmap->type)
14716     /* Ensure results do not depend on the host qsort for objects with
14717        multiple mapping symbols at the same address by sorting on type
14718        after vma.  */
14719     return 1;
14720   else if (amap->type < bmap->type)
14721     return -1;
14722   else
14723     return 0;
14724 }
14725
14726 /* Add OFFSET to lower 31 bits of ADDR, leaving other bits unmodified.  */
14727
14728 static unsigned long
14729 offset_prel31 (unsigned long addr, bfd_vma offset)
14730 {
14731   return (addr & ~0x7ffffffful) | ((addr + offset) & 0x7ffffffful);
14732 }
14733
14734 /* Copy an .ARM.exidx table entry, adding OFFSET to (applied) PREL31
14735    relocations.  */
14736
14737 static void
14738 copy_exidx_entry (bfd *output_bfd, bfd_byte *to, bfd_byte *from, bfd_vma offset)
14739 {
14740   unsigned long first_word = bfd_get_32 (output_bfd, from);
14741   unsigned long second_word = bfd_get_32 (output_bfd, from + 4);
14742
14743   /* High bit of first word is supposed to be zero.  */
14744   if ((first_word & 0x80000000ul) == 0)
14745     first_word = offset_prel31 (first_word, offset);
14746
14747   /* If the high bit of the first word is clear, and the bit pattern is not 0x1
14748      (EXIDX_CANTUNWIND), this is an offset to an .ARM.extab entry.  */
14749   if ((second_word != 0x1) && ((second_word & 0x80000000ul) == 0))
14750     second_word = offset_prel31 (second_word, offset);
14751
14752   bfd_put_32 (output_bfd, first_word, to);
14753   bfd_put_32 (output_bfd, second_word, to + 4);
14754 }
14755
14756 /* Data for make_branch_to_a8_stub().  */
14757
14758 struct a8_branch_to_stub_data {
14759   asection *writing_section;
14760   bfd_byte *contents;
14761 };
14762
14763
14764 /* Helper to insert branches to Cortex-A8 erratum stubs in the right
14765    places for a particular section.  */
14766
14767 static bfd_boolean
14768 make_branch_to_a8_stub (struct bfd_hash_entry *gen_entry,
14769                        void *in_arg)
14770 {
14771   struct elf32_arm_stub_hash_entry *stub_entry;
14772   struct a8_branch_to_stub_data *data;
14773   bfd_byte *contents;
14774   unsigned long branch_insn;
14775   bfd_vma veneered_insn_loc, veneer_entry_loc;
14776   bfd_signed_vma branch_offset;
14777   bfd *abfd;
14778   unsigned int target;
14779
14780   stub_entry = (struct elf32_arm_stub_hash_entry *) gen_entry;
14781   data = (struct a8_branch_to_stub_data *) in_arg;
14782
14783   if (stub_entry->target_section != data->writing_section
14784       || stub_entry->stub_type < arm_stub_a8_veneer_lwm)
14785     return TRUE;
14786
14787   contents = data->contents;
14788
14789   veneered_insn_loc = stub_entry->target_section->output_section->vma
14790                       + stub_entry->target_section->output_offset
14791                       + stub_entry->target_value;
14792
14793   veneer_entry_loc = stub_entry->stub_sec->output_section->vma
14794                      + stub_entry->stub_sec->output_offset
14795                      + stub_entry->stub_offset;
14796
14797   if (stub_entry->stub_type == arm_stub_a8_veneer_blx)
14798     veneered_insn_loc &= ~3u;
14799
14800   branch_offset = veneer_entry_loc - veneered_insn_loc - 4;
14801
14802   abfd = stub_entry->target_section->owner;
14803   target = stub_entry->target_value;
14804
14805   /* We attempt to avoid this condition by setting stubs_always_after_branch
14806      in elf32_arm_size_stubs if we've enabled the Cortex-A8 erratum workaround.
14807      This check is just to be on the safe side...  */
14808   if ((veneered_insn_loc & ~0xfff) == (veneer_entry_loc & ~0xfff))
14809     {
14810       (*_bfd_error_handler) (_("%B: error: Cortex-A8 erratum stub is "
14811                                "allocated in unsafe location"), abfd);
14812       return FALSE;
14813     }
14814
14815   switch (stub_entry->stub_type)
14816     {
14817     case arm_stub_a8_veneer_b:
14818     case arm_stub_a8_veneer_b_cond:
14819       branch_insn = 0xf0009000;
14820       goto jump24;
14821
14822     case arm_stub_a8_veneer_blx:
14823       branch_insn = 0xf000e800;
14824       goto jump24;
14825
14826     case arm_stub_a8_veneer_bl:
14827       {
14828         unsigned int i1, j1, i2, j2, s;
14829
14830         branch_insn = 0xf000d000;
14831
14832       jump24:
14833         if (branch_offset < -16777216 || branch_offset > 16777214)
14834           {
14835             /* There's not much we can do apart from complain if this
14836                happens.  */
14837             (*_bfd_error_handler) (_("%B: error: Cortex-A8 erratum stub out "
14838                                      "of range (input file too large)"), abfd);
14839             return FALSE;
14840           }
14841
14842         /* i1 = not(j1 eor s), so:
14843            not i1 = j1 eor s
14844            j1 = (not i1) eor s.  */
14845
14846         branch_insn |= (branch_offset >> 1) & 0x7ff;
14847         branch_insn |= ((branch_offset >> 12) & 0x3ff) << 16;
14848         i2 = (branch_offset >> 22) & 1;
14849         i1 = (branch_offset >> 23) & 1;
14850         s = (branch_offset >> 24) & 1;
14851         j1 = (!i1) ^ s;
14852         j2 = (!i2) ^ s;
14853         branch_insn |= j2 << 11;
14854         branch_insn |= j1 << 13;
14855         branch_insn |= s << 26;
14856       }
14857       break;
14858
14859     default:
14860       BFD_FAIL ();
14861       return FALSE;
14862     }
14863
14864   bfd_put_16 (abfd, (branch_insn >> 16) & 0xffff, &contents[target]);
14865   bfd_put_16 (abfd, branch_insn & 0xffff, &contents[target + 2]);
14866
14867   return TRUE;
14868 }
14869
14870 /* Do code byteswapping.  Return FALSE afterwards so that the section is
14871    written out as normal.  */
14872
14873 static bfd_boolean
14874 elf32_arm_write_section (bfd *output_bfd,
14875                          struct bfd_link_info *link_info,
14876                          asection *sec,
14877                          bfd_byte *contents)
14878 {
14879   unsigned int mapcount, errcount;
14880   _arm_elf_section_data *arm_data;
14881   struct elf32_arm_link_hash_table *globals = elf32_arm_hash_table (link_info);
14882   elf32_arm_section_map *map;
14883   elf32_vfp11_erratum_list *errnode;
14884   bfd_vma ptr;
14885   bfd_vma end;
14886   bfd_vma offset = sec->output_section->vma + sec->output_offset;
14887   bfd_byte tmp;
14888   unsigned int i;
14889
14890   if (globals == NULL)
14891     return FALSE;
14892
14893   /* If this section has not been allocated an _arm_elf_section_data
14894      structure then we cannot record anything.  */
14895   arm_data = get_arm_elf_section_data (sec);
14896   if (arm_data == NULL)
14897     return FALSE;
14898
14899   mapcount = arm_data->mapcount;
14900   map = arm_data->map;
14901   errcount = arm_data->erratumcount;
14902
14903   if (errcount != 0)
14904     {
14905       unsigned int endianflip = bfd_big_endian (output_bfd) ? 3 : 0;
14906
14907       for (errnode = arm_data->erratumlist; errnode != 0;
14908            errnode = errnode->next)
14909         {
14910           bfd_vma target = errnode->vma - offset;
14911
14912           switch (errnode->type)
14913             {
14914             case VFP11_ERRATUM_BRANCH_TO_ARM_VENEER:
14915               {
14916                 bfd_vma branch_to_veneer;
14917                 /* Original condition code of instruction, plus bit mask for
14918                    ARM B instruction.  */
14919                 unsigned int insn = (errnode->u.b.vfp_insn & 0xf0000000)
14920                                   | 0x0a000000;
14921
14922                 /* The instruction is before the label.  */
14923                 target -= 4;
14924
14925                 /* Above offset included in -4 below.  */
14926                 branch_to_veneer = errnode->u.b.veneer->vma
14927                                    - errnode->vma - 4;
14928
14929                 if ((signed) branch_to_veneer < -(1 << 25)
14930                     || (signed) branch_to_veneer >= (1 << 25))
14931                   (*_bfd_error_handler) (_("%B: error: VFP11 veneer out of "
14932                                            "range"), output_bfd);
14933
14934                 insn |= (branch_to_veneer >> 2) & 0xffffff;
14935                 contents[endianflip ^ target] = insn & 0xff;
14936                 contents[endianflip ^ (target + 1)] = (insn >> 8) & 0xff;
14937                 contents[endianflip ^ (target + 2)] = (insn >> 16) & 0xff;
14938                 contents[endianflip ^ (target + 3)] = (insn >> 24) & 0xff;
14939               }
14940               break;
14941
14942             case VFP11_ERRATUM_ARM_VENEER:
14943               {
14944                 bfd_vma branch_from_veneer;
14945                 unsigned int insn;
14946
14947                 /* Take size of veneer into account.  */
14948                 branch_from_veneer = errnode->u.v.branch->vma
14949                                      - errnode->vma - 12;
14950
14951                 if ((signed) branch_from_veneer < -(1 << 25)
14952                     || (signed) branch_from_veneer >= (1 << 25))
14953                   (*_bfd_error_handler) (_("%B: error: VFP11 veneer out of "
14954                                            "range"), output_bfd);
14955
14956                 /* Original instruction.  */
14957                 insn = errnode->u.v.branch->u.b.vfp_insn;
14958                 contents[endianflip ^ target] = insn & 0xff;
14959                 contents[endianflip ^ (target + 1)] = (insn >> 8) & 0xff;
14960                 contents[endianflip ^ (target + 2)] = (insn >> 16) & 0xff;
14961                 contents[endianflip ^ (target + 3)] = (insn >> 24) & 0xff;
14962
14963                 /* Branch back to insn after original insn.  */
14964                 insn = 0xea000000 | ((branch_from_veneer >> 2) & 0xffffff);
14965                 contents[endianflip ^ (target + 4)] = insn & 0xff;
14966                 contents[endianflip ^ (target + 5)] = (insn >> 8) & 0xff;
14967                 contents[endianflip ^ (target + 6)] = (insn >> 16) & 0xff;
14968                 contents[endianflip ^ (target + 7)] = (insn >> 24) & 0xff;
14969               }
14970               break;
14971
14972             default:
14973               abort ();
14974             }
14975         }
14976     }
14977
14978   if (arm_data->elf.this_hdr.sh_type == SHT_ARM_EXIDX)
14979     {
14980       arm_unwind_table_edit *edit_node
14981         = arm_data->u.exidx.unwind_edit_list;
14982       /* Now, sec->size is the size of the section we will write.  The original
14983          size (before we merged duplicate entries and inserted EXIDX_CANTUNWIND
14984          markers) was sec->rawsize.  (This isn't the case if we perform no
14985          edits, then rawsize will be zero and we should use size).  */
14986       bfd_byte *edited_contents = (bfd_byte *) bfd_malloc (sec->size);
14987       unsigned int input_size = sec->rawsize ? sec->rawsize : sec->size;
14988       unsigned int in_index, out_index;
14989       bfd_vma add_to_offsets = 0;
14990
14991       for (in_index = 0, out_index = 0; in_index * 8 < input_size || edit_node;)
14992         {
14993           if (edit_node)
14994             {
14995               unsigned int edit_index = edit_node->index;
14996
14997               if (in_index < edit_index && in_index * 8 < input_size)
14998                 {
14999                   copy_exidx_entry (output_bfd, edited_contents + out_index * 8,
15000                                     contents + in_index * 8, add_to_offsets);
15001                   out_index++;
15002                   in_index++;
15003                 }
15004               else if (in_index == edit_index
15005                        || (in_index * 8 >= input_size
15006                            && edit_index == UINT_MAX))
15007                 {
15008                   switch (edit_node->type)
15009                     {
15010                     case DELETE_EXIDX_ENTRY:
15011                       in_index++;
15012                       add_to_offsets += 8;
15013                       break;
15014
15015                     case INSERT_EXIDX_CANTUNWIND_AT_END:
15016                       {
15017                         asection *text_sec = edit_node->linked_section;
15018                         bfd_vma text_offset = text_sec->output_section->vma
15019                                               + text_sec->output_offset
15020                                               + text_sec->size;
15021                         bfd_vma exidx_offset = offset + out_index * 8;
15022                         unsigned long prel31_offset;
15023
15024                         /* Note: this is meant to be equivalent to an
15025                            R_ARM_PREL31 relocation.  These synthetic
15026                            EXIDX_CANTUNWIND markers are not relocated by the
15027                            usual BFD method.  */
15028                         prel31_offset = (text_offset - exidx_offset)
15029                                         & 0x7ffffffful;
15030
15031                         /* First address we can't unwind.  */
15032                         bfd_put_32 (output_bfd, prel31_offset,
15033                                     &edited_contents[out_index * 8]);
15034
15035                         /* Code for EXIDX_CANTUNWIND.  */
15036                         bfd_put_32 (output_bfd, 0x1,
15037                                     &edited_contents[out_index * 8 + 4]);
15038
15039                         out_index++;
15040                         add_to_offsets -= 8;
15041                       }
15042                       break;
15043                     }
15044
15045                   edit_node = edit_node->next;
15046                 }
15047             }
15048           else
15049             {
15050               /* No more edits, copy remaining entries verbatim.  */
15051               copy_exidx_entry (output_bfd, edited_contents + out_index * 8,
15052                                 contents + in_index * 8, add_to_offsets);
15053               out_index++;
15054               in_index++;
15055             }
15056         }
15057
15058       if (!(sec->flags & SEC_EXCLUDE) && !(sec->flags & SEC_NEVER_LOAD))
15059         bfd_set_section_contents (output_bfd, sec->output_section,
15060                                   edited_contents,
15061                                   (file_ptr) sec->output_offset, sec->size);
15062
15063       return TRUE;
15064     }
15065
15066   /* Fix code to point to Cortex-A8 erratum stubs.  */
15067   if (globals->fix_cortex_a8)
15068     {
15069       struct a8_branch_to_stub_data data;
15070
15071       data.writing_section = sec;
15072       data.contents = contents;
15073
15074       bfd_hash_traverse (&globals->stub_hash_table, make_branch_to_a8_stub,
15075                          &data);
15076     }
15077
15078   if (mapcount == 0)
15079     return FALSE;
15080
15081   if (globals->byteswap_code)
15082     {
15083       qsort (map, mapcount, sizeof (* map), elf32_arm_compare_mapping);
15084
15085       ptr = map[0].vma;
15086       for (i = 0; i < mapcount; i++)
15087         {
15088           if (i == mapcount - 1)
15089             end = sec->size;
15090           else
15091             end = map[i + 1].vma;
15092
15093           switch (map[i].type)
15094             {
15095             case 'a':
15096               /* Byte swap code words.  */
15097               while (ptr + 3 < end)
15098                 {
15099                   tmp = contents[ptr];
15100                   contents[ptr] = contents[ptr + 3];
15101                   contents[ptr + 3] = tmp;
15102                   tmp = contents[ptr + 1];
15103                   contents[ptr + 1] = contents[ptr + 2];
15104                   contents[ptr + 2] = tmp;
15105                   ptr += 4;
15106                 }
15107               break;
15108
15109             case 't':
15110               /* Byte swap code halfwords.  */
15111               while (ptr + 1 < end)
15112                 {
15113                   tmp = contents[ptr];
15114                   contents[ptr] = contents[ptr + 1];
15115                   contents[ptr + 1] = tmp;
15116                   ptr += 2;
15117                 }
15118               break;
15119
15120             case 'd':
15121               /* Leave data alone.  */
15122               break;
15123             }
15124           ptr = end;
15125         }
15126     }
15127
15128   free (map);
15129   arm_data->mapcount = -1;
15130   arm_data->mapsize = 0;
15131   arm_data->map = NULL;
15132
15133   return FALSE;
15134 }
15135
15136 /* Mangle thumb function symbols as we read them in.  */
15137
15138 static bfd_boolean
15139 elf32_arm_swap_symbol_in (bfd * abfd,
15140                           const void *psrc,
15141                           const void *pshn,
15142                           Elf_Internal_Sym *dst)
15143 {
15144   if (!bfd_elf32_swap_symbol_in (abfd, psrc, pshn, dst))
15145     return FALSE;
15146
15147   /* New EABI objects mark thumb function symbols by setting the low bit of
15148      the address.  */
15149   if (ELF_ST_TYPE (dst->st_info) == STT_FUNC
15150       || ELF_ST_TYPE (dst->st_info) == STT_GNU_IFUNC)
15151     {
15152       if (dst->st_value & 1)
15153         {
15154           dst->st_value &= ~(bfd_vma) 1;
15155           dst->st_target_internal = ST_BRANCH_TO_THUMB;
15156         }
15157       else
15158         dst->st_target_internal = ST_BRANCH_TO_ARM;
15159     }
15160   else if (ELF_ST_TYPE (dst->st_info) == STT_ARM_TFUNC)
15161     {
15162       dst->st_info = ELF_ST_INFO (ELF_ST_BIND (dst->st_info), STT_FUNC);
15163       dst->st_target_internal = ST_BRANCH_TO_THUMB;
15164     }
15165   else if (ELF_ST_TYPE (dst->st_info) == STT_SECTION)
15166     dst->st_target_internal = ST_BRANCH_LONG;
15167   else
15168     dst->st_target_internal = ST_BRANCH_UNKNOWN;
15169
15170   return TRUE;
15171 }
15172
15173
15174 /* Mangle thumb function symbols as we write them out.  */
15175
15176 static void
15177 elf32_arm_swap_symbol_out (bfd *abfd,
15178                            const Elf_Internal_Sym *src,
15179                            void *cdst,
15180                            void *shndx)
15181 {
15182   Elf_Internal_Sym newsym;
15183
15184   /* We convert STT_ARM_TFUNC symbols into STT_FUNC with the low bit
15185      of the address set, as per the new EABI.  We do this unconditionally
15186      because objcopy does not set the elf header flags until after
15187      it writes out the symbol table.  */
15188   if (src->st_target_internal == ST_BRANCH_TO_THUMB)
15189     {
15190       newsym = *src;
15191       if (ELF_ST_TYPE (src->st_info) != STT_GNU_IFUNC)
15192         newsym.st_info = ELF_ST_INFO (ELF_ST_BIND (src->st_info), STT_FUNC);
15193       if (newsym.st_shndx != SHN_UNDEF)
15194         {
15195           /* Do this only for defined symbols. At link type, the static
15196              linker will simulate the work of dynamic linker of resolving
15197              symbols and will carry over the thumbness of found symbols to
15198              the output symbol table. It's not clear how it happens, but
15199              the thumbness of undefined symbols can well be different at
15200              runtime, and writing '1' for them will be confusing for users
15201              and possibly for dynamic linker itself.
15202           */
15203           newsym.st_value |= 1;
15204         }
15205
15206       src = &newsym;
15207     }
15208   bfd_elf32_swap_symbol_out (abfd, src, cdst, shndx);
15209 }
15210
15211 /* Add the PT_ARM_EXIDX program header.  */
15212
15213 static bfd_boolean
15214 elf32_arm_modify_segment_map (bfd *abfd,
15215                               struct bfd_link_info *info ATTRIBUTE_UNUSED)
15216 {
15217   struct elf_segment_map *m;
15218   asection *sec;
15219
15220   sec = bfd_get_section_by_name (abfd, ".ARM.exidx");
15221   if (sec != NULL && (sec->flags & SEC_LOAD) != 0)
15222     {
15223       /* If there is already a PT_ARM_EXIDX header, then we do not
15224          want to add another one.  This situation arises when running
15225          "strip"; the input binary already has the header.  */
15226       m = elf_tdata (abfd)->segment_map;
15227       while (m && m->p_type != PT_ARM_EXIDX)
15228         m = m->next;
15229       if (!m)
15230         {
15231           m = (struct elf_segment_map *)
15232               bfd_zalloc (abfd, sizeof (struct elf_segment_map));
15233           if (m == NULL)
15234             return FALSE;
15235           m->p_type = PT_ARM_EXIDX;
15236           m->count = 1;
15237           m->sections[0] = sec;
15238
15239           m->next = elf_tdata (abfd)->segment_map;
15240           elf_tdata (abfd)->segment_map = m;
15241         }
15242     }
15243
15244   return TRUE;
15245 }
15246
15247 /* We may add a PT_ARM_EXIDX program header.  */
15248
15249 static int
15250 elf32_arm_additional_program_headers (bfd *abfd,
15251                                       struct bfd_link_info *info ATTRIBUTE_UNUSED)
15252 {
15253   asection *sec;
15254
15255   sec = bfd_get_section_by_name (abfd, ".ARM.exidx");
15256   if (sec != NULL && (sec->flags & SEC_LOAD) != 0)
15257     return 1;
15258   else
15259     return 0;
15260 }
15261
15262 /* Hook called by the linker routine which adds symbols from an object
15263    file.  */
15264
15265 static bfd_boolean
15266 elf32_arm_add_symbol_hook (bfd *abfd, struct bfd_link_info *info,
15267                            Elf_Internal_Sym *sym, const char **namep,
15268                            flagword *flagsp, asection **secp, bfd_vma *valp)
15269 {
15270   if ((abfd->flags & DYNAMIC) == 0
15271       && (ELF_ST_TYPE (sym->st_info) == STT_GNU_IFUNC
15272           || ELF_ST_BIND (sym->st_info) == STB_GNU_UNIQUE))
15273     elf_tdata (info->output_bfd)->has_gnu_symbols = TRUE;
15274
15275   if (elf32_arm_hash_table (info)->vxworks_p
15276       && !elf_vxworks_add_symbol_hook (abfd, info, sym, namep,
15277                                        flagsp, secp, valp))
15278     return FALSE;
15279
15280   return TRUE;
15281 }
15282
15283 /* We use this to override swap_symbol_in and swap_symbol_out.  */
15284 const struct elf_size_info elf32_arm_size_info =
15285 {
15286   sizeof (Elf32_External_Ehdr),
15287   sizeof (Elf32_External_Phdr),
15288   sizeof (Elf32_External_Shdr),
15289   sizeof (Elf32_External_Rel),
15290   sizeof (Elf32_External_Rela),
15291   sizeof (Elf32_External_Sym),
15292   sizeof (Elf32_External_Dyn),
15293   sizeof (Elf_External_Note),
15294   4,
15295   1,
15296   32, 2,
15297   ELFCLASS32, EV_CURRENT,
15298   bfd_elf32_write_out_phdrs,
15299   bfd_elf32_write_shdrs_and_ehdr,
15300   bfd_elf32_checksum_contents,
15301   bfd_elf32_write_relocs,
15302   elf32_arm_swap_symbol_in,
15303   elf32_arm_swap_symbol_out,
15304   bfd_elf32_slurp_reloc_table,
15305   bfd_elf32_slurp_symbol_table,
15306   bfd_elf32_swap_dyn_in,
15307   bfd_elf32_swap_dyn_out,
15308   bfd_elf32_swap_reloc_in,
15309   bfd_elf32_swap_reloc_out,
15310   bfd_elf32_swap_reloca_in,
15311   bfd_elf32_swap_reloca_out
15312 };
15313
15314 #define ELF_ARCH                        bfd_arch_arm
15315 #define ELF_TARGET_ID                   ARM_ELF_DATA
15316 #define ELF_MACHINE_CODE                EM_ARM
15317 #ifdef __QNXTARGET__
15318 #define ELF_MAXPAGESIZE                 0x1000
15319 #else
15320 #define ELF_MAXPAGESIZE                 0x8000
15321 #endif
15322 #define ELF_MINPAGESIZE                 0x1000
15323 #define ELF_COMMONPAGESIZE              0x1000
15324
15325 #define bfd_elf32_mkobject                      elf32_arm_mkobject
15326
15327 #define bfd_elf32_bfd_copy_private_bfd_data     elf32_arm_copy_private_bfd_data
15328 #define bfd_elf32_bfd_merge_private_bfd_data    elf32_arm_merge_private_bfd_data
15329 #define bfd_elf32_bfd_set_private_flags         elf32_arm_set_private_flags
15330 #define bfd_elf32_bfd_print_private_bfd_data    elf32_arm_print_private_bfd_data
15331 #define bfd_elf32_bfd_link_hash_table_create    elf32_arm_link_hash_table_create
15332 #define bfd_elf32_bfd_link_hash_table_free      elf32_arm_hash_table_free
15333 #define bfd_elf32_bfd_reloc_type_lookup         elf32_arm_reloc_type_lookup
15334 #define bfd_elf32_bfd_reloc_name_lookup elf32_arm_reloc_name_lookup
15335 #define bfd_elf32_find_nearest_line             elf32_arm_find_nearest_line
15336 #define bfd_elf32_find_inliner_info             elf32_arm_find_inliner_info
15337 #define bfd_elf32_new_section_hook              elf32_arm_new_section_hook
15338 #define bfd_elf32_bfd_is_target_special_symbol  elf32_arm_is_target_special_symbol
15339 #define bfd_elf32_bfd_final_link                elf32_arm_final_link
15340
15341 #define elf_backend_get_symbol_type             elf32_arm_get_symbol_type
15342 #define elf_backend_gc_mark_hook                elf32_arm_gc_mark_hook
15343 #define elf_backend_gc_mark_extra_sections      elf32_arm_gc_mark_extra_sections
15344 #define elf_backend_gc_sweep_hook               elf32_arm_gc_sweep_hook
15345 #define elf_backend_check_relocs                elf32_arm_check_relocs
15346 #define elf_backend_relocate_section            elf32_arm_relocate_section
15347 #define elf_backend_write_section               elf32_arm_write_section
15348 #define elf_backend_adjust_dynamic_symbol       elf32_arm_adjust_dynamic_symbol
15349 #define elf_backend_create_dynamic_sections     elf32_arm_create_dynamic_sections
15350 #define elf_backend_finish_dynamic_symbol       elf32_arm_finish_dynamic_symbol
15351 #define elf_backend_finish_dynamic_sections     elf32_arm_finish_dynamic_sections
15352 #define elf_backend_size_dynamic_sections       elf32_arm_size_dynamic_sections
15353 #define elf_backend_always_size_sections        elf32_arm_always_size_sections
15354 #define elf_backend_init_index_section          _bfd_elf_init_2_index_sections
15355 #define elf_backend_post_process_headers        elf32_arm_post_process_headers
15356 #define elf_backend_reloc_type_class            elf32_arm_reloc_type_class
15357 #define elf_backend_object_p                    elf32_arm_object_p
15358 #define elf_backend_fake_sections               elf32_arm_fake_sections
15359 #define elf_backend_section_from_shdr           elf32_arm_section_from_shdr
15360 #define elf_backend_final_write_processing      elf32_arm_final_write_processing
15361 #define elf_backend_copy_indirect_symbol        elf32_arm_copy_indirect_symbol
15362 #define elf_backend_size_info                   elf32_arm_size_info
15363 #define elf_backend_modify_segment_map          elf32_arm_modify_segment_map
15364 #define elf_backend_additional_program_headers  elf32_arm_additional_program_headers
15365 #define elf_backend_output_arch_local_syms      elf32_arm_output_arch_local_syms
15366 #define elf_backend_begin_write_processing      elf32_arm_begin_write_processing
15367 #define elf_backend_add_symbol_hook             elf32_arm_add_symbol_hook
15368
15369 #define elf_backend_can_refcount       1
15370 #define elf_backend_can_gc_sections    1
15371 #define elf_backend_plt_readonly       1
15372 #define elf_backend_want_got_plt       1
15373 #define elf_backend_want_plt_sym       0
15374 #define elf_backend_may_use_rel_p      1
15375 #define elf_backend_may_use_rela_p     0
15376 #define elf_backend_default_use_rela_p 0
15377
15378 #define elf_backend_got_header_size     12
15379
15380 #undef  elf_backend_obj_attrs_vendor
15381 #define elf_backend_obj_attrs_vendor            "aeabi"
15382 #undef  elf_backend_obj_attrs_section
15383 #define elf_backend_obj_attrs_section           ".ARM.attributes"
15384 #undef  elf_backend_obj_attrs_arg_type
15385 #define elf_backend_obj_attrs_arg_type          elf32_arm_obj_attrs_arg_type
15386 #undef  elf_backend_obj_attrs_section_type
15387 #define elf_backend_obj_attrs_section_type      SHT_ARM_ATTRIBUTES
15388 #define elf_backend_obj_attrs_order     elf32_arm_obj_attrs_order
15389 #define elf_backend_obj_attrs_handle_unknown elf32_arm_obj_attrs_handle_unknown
15390
15391 #include "elf32-target.h"
15392
15393 /* VxWorks Targets.  */
15394
15395 #undef  TARGET_LITTLE_SYM
15396 #define TARGET_LITTLE_SYM               bfd_elf32_littlearm_vxworks_vec
15397 #undef  TARGET_LITTLE_NAME
15398 #define TARGET_LITTLE_NAME              "elf32-littlearm-vxworks"
15399 #undef  TARGET_BIG_SYM
15400 #define TARGET_BIG_SYM                  bfd_elf32_bigarm_vxworks_vec
15401 #undef  TARGET_BIG_NAME
15402 #define TARGET_BIG_NAME                 "elf32-bigarm-vxworks"
15403
15404 /* Like elf32_arm_link_hash_table_create -- but overrides
15405    appropriately for VxWorks.  */
15406
15407 static struct bfd_link_hash_table *
15408 elf32_arm_vxworks_link_hash_table_create (bfd *abfd)
15409 {
15410   struct bfd_link_hash_table *ret;
15411
15412   ret = elf32_arm_link_hash_table_create (abfd);
15413   if (ret)
15414     {
15415       struct elf32_arm_link_hash_table *htab
15416         = (struct elf32_arm_link_hash_table *) ret;
15417       htab->use_rel = 0;
15418       htab->vxworks_p = 1;
15419     }
15420   return ret;
15421 }
15422
15423 static void
15424 elf32_arm_vxworks_final_write_processing (bfd *abfd, bfd_boolean linker)
15425 {
15426   elf32_arm_final_write_processing (abfd, linker);
15427   elf_vxworks_final_write_processing (abfd, linker);
15428 }
15429
15430 #undef  elf32_bed
15431 #define elf32_bed elf32_arm_vxworks_bed
15432
15433 #undef  bfd_elf32_bfd_link_hash_table_create
15434 #define bfd_elf32_bfd_link_hash_table_create    elf32_arm_vxworks_link_hash_table_create
15435 #undef  elf_backend_final_write_processing
15436 #define elf_backend_final_write_processing      elf32_arm_vxworks_final_write_processing
15437 #undef  elf_backend_emit_relocs
15438 #define elf_backend_emit_relocs                 elf_vxworks_emit_relocs
15439
15440 #undef  elf_backend_may_use_rel_p
15441 #define elf_backend_may_use_rel_p       0
15442 #undef  elf_backend_may_use_rela_p
15443 #define elf_backend_may_use_rela_p      1
15444 #undef  elf_backend_default_use_rela_p
15445 #define elf_backend_default_use_rela_p  1
15446 #undef  elf_backend_want_plt_sym
15447 #define elf_backend_want_plt_sym        1
15448 #undef  ELF_MAXPAGESIZE
15449 #define ELF_MAXPAGESIZE                 0x1000
15450
15451 #include "elf32-target.h"
15452
15453
15454 /* Merge backend specific data from an object file to the output
15455    object file when linking.  */
15456
15457 static bfd_boolean
15458 elf32_arm_merge_private_bfd_data (bfd * ibfd, bfd * obfd)
15459 {
15460   flagword out_flags;
15461   flagword in_flags;
15462   bfd_boolean flags_compatible = TRUE;
15463   asection *sec;
15464
15465   /* Check if we have the same endianness.  */
15466   if (! _bfd_generic_verify_endian_match (ibfd, obfd))
15467     return FALSE;
15468
15469   if (! is_arm_elf (ibfd) || ! is_arm_elf (obfd))
15470     return TRUE;
15471
15472   if (!elf32_arm_merge_eabi_attributes (ibfd, obfd))
15473     return FALSE;
15474
15475   /* The input BFD must have had its flags initialised.  */
15476   /* The following seems bogus to me -- The flags are initialized in
15477      the assembler but I don't think an elf_flags_init field is
15478      written into the object.  */
15479   /* BFD_ASSERT (elf_flags_init (ibfd)); */
15480
15481   in_flags  = elf_elfheader (ibfd)->e_flags;
15482   out_flags = elf_elfheader (obfd)->e_flags;
15483
15484   /* In theory there is no reason why we couldn't handle this.  However
15485      in practice it isn't even close to working and there is no real
15486      reason to want it.  */
15487   if (EF_ARM_EABI_VERSION (in_flags) >= EF_ARM_EABI_VER4
15488       && !(ibfd->flags & DYNAMIC)
15489       && (in_flags & EF_ARM_BE8))
15490     {
15491       _bfd_error_handler (_("error: %B is already in final BE8 format"),
15492                           ibfd);
15493       return FALSE;
15494     }
15495
15496   if (!elf_flags_init (obfd))
15497     {
15498       /* If the input is the default architecture and had the default
15499          flags then do not bother setting the flags for the output
15500          architecture, instead allow future merges to do this.  If no
15501          future merges ever set these flags then they will retain their
15502          uninitialised values, which surprise surprise, correspond
15503          to the default values.  */
15504       if (bfd_get_arch_info (ibfd)->the_default
15505           && elf_elfheader (ibfd)->e_flags == 0)
15506         return TRUE;
15507
15508       elf_flags_init (obfd) = TRUE;
15509       elf_elfheader (obfd)->e_flags = in_flags;
15510
15511       if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
15512           && bfd_get_arch_info (obfd)->the_default)
15513         return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
15514
15515       return TRUE;
15516     }
15517
15518   /* Determine what should happen if the input ARM architecture
15519      does not match the output ARM architecture.  */
15520   if (! bfd_arm_merge_machines (ibfd, obfd))
15521     return FALSE;
15522
15523   /* Identical flags must be compatible.  */
15524   if (in_flags == out_flags)
15525     return TRUE;
15526
15527   /* Check to see if the input BFD actually contains any sections.  If
15528      not, its flags may not have been initialised either, but it
15529      cannot actually cause any incompatiblity.  Do not short-circuit
15530      dynamic objects; their section list may be emptied by
15531     elf_link_add_object_symbols.
15532
15533     Also check to see if there are no code sections in the input.
15534     In this case there is no need to check for code specific flags.
15535     XXX - do we need to worry about floating-point format compatability
15536     in data sections ?  */
15537   if (!(ibfd->flags & DYNAMIC))
15538     {
15539       bfd_boolean null_input_bfd = TRUE;
15540       bfd_boolean only_data_sections = TRUE;
15541
15542       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
15543         {
15544           /* Ignore synthetic glue sections.  */
15545           if (strcmp (sec->name, ".glue_7")
15546               && strcmp (sec->name, ".glue_7t"))
15547             {
15548               if ((bfd_get_section_flags (ibfd, sec)
15549                    & (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS))
15550                   == (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS))
15551                 only_data_sections = FALSE;
15552
15553               null_input_bfd = FALSE;
15554               break;
15555             }
15556         }
15557
15558       if (null_input_bfd || only_data_sections)
15559         return TRUE;
15560     }
15561
15562   /* Complain about various flag mismatches.  */
15563   if (!elf32_arm_versions_compatible (EF_ARM_EABI_VERSION (in_flags),
15564                                       EF_ARM_EABI_VERSION (out_flags)))
15565     {
15566       _bfd_error_handler
15567         (_("error: Source object %B has EABI version %d, but target %B has EABI version %d"),
15568          ibfd, obfd,
15569          (in_flags & EF_ARM_EABIMASK) >> 24,
15570          (out_flags & EF_ARM_EABIMASK) >> 24);
15571       return FALSE;
15572     }
15573
15574   /* Not sure what needs to be checked for EABI versions >= 1.  */
15575   /* VxWorks libraries do not use these flags.  */
15576   if (get_elf_backend_data (obfd) != &elf32_arm_vxworks_bed
15577       && get_elf_backend_data (ibfd) != &elf32_arm_vxworks_bed
15578       && EF_ARM_EABI_VERSION (in_flags) == EF_ARM_EABI_UNKNOWN)
15579     {
15580       if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
15581         {
15582           _bfd_error_handler
15583             (_("error: %B is compiled for APCS-%d, whereas target %B uses APCS-%d"),
15584              ibfd, obfd,
15585              in_flags & EF_ARM_APCS_26 ? 26 : 32,
15586              out_flags & EF_ARM_APCS_26 ? 26 : 32);
15587           flags_compatible = FALSE;
15588         }
15589
15590       if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
15591         {
15592           if (in_flags & EF_ARM_APCS_FLOAT)
15593             _bfd_error_handler
15594               (_("error: %B passes floats in float registers, whereas %B passes them in integer registers"),
15595                ibfd, obfd);
15596           else
15597             _bfd_error_handler
15598               (_("error: %B passes floats in integer registers, whereas %B passes them in float registers"),
15599                ibfd, obfd);
15600
15601           flags_compatible = FALSE;
15602         }
15603
15604       if ((in_flags & EF_ARM_VFP_FLOAT) != (out_flags & EF_ARM_VFP_FLOAT))
15605         {
15606           if (in_flags & EF_ARM_VFP_FLOAT)
15607             _bfd_error_handler
15608               (_("error: %B uses VFP instructions, whereas %B does not"),
15609                ibfd, obfd);
15610           else
15611             _bfd_error_handler
15612               (_("error: %B uses FPA instructions, whereas %B does not"),
15613                ibfd, obfd);
15614
15615           flags_compatible = FALSE;
15616         }
15617
15618       if ((in_flags & EF_ARM_MAVERICK_FLOAT) != (out_flags & EF_ARM_MAVERICK_FLOAT))
15619         {
15620           if (in_flags & EF_ARM_MAVERICK_FLOAT)
15621             _bfd_error_handler
15622               (_("error: %B uses Maverick instructions, whereas %B does not"),
15623                ibfd, obfd);
15624           else
15625             _bfd_error_handler
15626               (_("error: %B does not use Maverick instructions, whereas %B does"),
15627                ibfd, obfd);
15628
15629           flags_compatible = FALSE;
15630         }
15631
15632 #ifdef EF_ARM_SOFT_FLOAT
15633       if ((in_flags & EF_ARM_SOFT_FLOAT) != (out_flags & EF_ARM_SOFT_FLOAT))
15634         {
15635           /* We can allow interworking between code that is VFP format
15636              layout, and uses either soft float or integer regs for
15637              passing floating point arguments and results.  We already
15638              know that the APCS_FLOAT flags match; similarly for VFP
15639              flags.  */
15640           if ((in_flags & EF_ARM_APCS_FLOAT) != 0
15641               || (in_flags & EF_ARM_VFP_FLOAT) == 0)
15642             {
15643               if (in_flags & EF_ARM_SOFT_FLOAT)
15644                 _bfd_error_handler
15645                   (_("error: %B uses software FP, whereas %B uses hardware FP"),
15646                    ibfd, obfd);
15647               else
15648                 _bfd_error_handler
15649                   (_("error: %B uses hardware FP, whereas %B uses software FP"),
15650                    ibfd, obfd);
15651
15652               flags_compatible = FALSE;
15653             }
15654         }
15655 #endif
15656
15657       /* Interworking mismatch is only a warning.  */
15658       if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
15659         {
15660           if (in_flags & EF_ARM_INTERWORK)
15661             {
15662               _bfd_error_handler
15663                 (_("Warning: %B supports interworking, whereas %B does not"),
15664                  ibfd, obfd);
15665             }
15666           else
15667             {
15668               _bfd_error_handler
15669                 (_("Warning: %B does not support interworking, whereas %B does"),
15670                  ibfd, obfd);
15671             }
15672         }
15673     }
15674
15675   return flags_compatible;
15676 }
15677
15678
15679 /* Symbian OS Targets.  */
15680
15681 #undef  TARGET_LITTLE_SYM
15682 #define TARGET_LITTLE_SYM               bfd_elf32_littlearm_symbian_vec
15683 #undef  TARGET_LITTLE_NAME
15684 #define TARGET_LITTLE_NAME              "elf32-littlearm-symbian"
15685 #undef  TARGET_BIG_SYM
15686 #define TARGET_BIG_SYM                  bfd_elf32_bigarm_symbian_vec
15687 #undef  TARGET_BIG_NAME
15688 #define TARGET_BIG_NAME                 "elf32-bigarm-symbian"
15689
15690 /* Like elf32_arm_link_hash_table_create -- but overrides
15691    appropriately for Symbian OS.  */
15692
15693 static struct bfd_link_hash_table *
15694 elf32_arm_symbian_link_hash_table_create (bfd *abfd)
15695 {
15696   struct bfd_link_hash_table *ret;
15697
15698   ret = elf32_arm_link_hash_table_create (abfd);
15699   if (ret)
15700     {
15701       struct elf32_arm_link_hash_table *htab
15702         = (struct elf32_arm_link_hash_table *)ret;
15703       /* There is no PLT header for Symbian OS.  */
15704       htab->plt_header_size = 0;
15705       /* The PLT entries are each one instruction and one word.  */
15706       htab->plt_entry_size = 4 * ARRAY_SIZE (elf32_arm_symbian_plt_entry);
15707       htab->symbian_p = 1;
15708       /* Symbian uses armv5t or above, so use_blx is always true.  */
15709       htab->use_blx = 1;
15710       htab->root.is_relocatable_executable = 1;
15711     }
15712   return ret;
15713 }
15714
15715 static const struct bfd_elf_special_section
15716 elf32_arm_symbian_special_sections[] =
15717 {
15718   /* In a BPABI executable, the dynamic linking sections do not go in
15719      the loadable read-only segment.  The post-linker may wish to
15720      refer to these sections, but they are not part of the final
15721      program image.  */
15722   { STRING_COMMA_LEN (".dynamic"),       0, SHT_DYNAMIC,  0 },
15723   { STRING_COMMA_LEN (".dynstr"),        0, SHT_STRTAB,   0 },
15724   { STRING_COMMA_LEN (".dynsym"),        0, SHT_DYNSYM,   0 },
15725   { STRING_COMMA_LEN (".got"),           0, SHT_PROGBITS, 0 },
15726   { STRING_COMMA_LEN (".hash"),          0, SHT_HASH,     0 },
15727   /* These sections do not need to be writable as the SymbianOS
15728      postlinker will arrange things so that no dynamic relocation is
15729      required.  */
15730   { STRING_COMMA_LEN (".init_array"),    0, SHT_INIT_ARRAY,    SHF_ALLOC },
15731   { STRING_COMMA_LEN (".fini_array"),    0, SHT_FINI_ARRAY,    SHF_ALLOC },
15732   { STRING_COMMA_LEN (".preinit_array"), 0, SHT_PREINIT_ARRAY, SHF_ALLOC },
15733   { NULL,                             0, 0, 0,                 0 }
15734 };
15735
15736 static void
15737 elf32_arm_symbian_begin_write_processing (bfd *abfd,
15738                                           struct bfd_link_info *link_info)
15739 {
15740   /* BPABI objects are never loaded directly by an OS kernel; they are
15741      processed by a postlinker first, into an OS-specific format.  If
15742      the D_PAGED bit is set on the file, BFD will align segments on
15743      page boundaries, so that an OS can directly map the file.  With
15744      BPABI objects, that just results in wasted space.  In addition,
15745      because we clear the D_PAGED bit, map_sections_to_segments will
15746      recognize that the program headers should not be mapped into any
15747      loadable segment.  */
15748   abfd->flags &= ~D_PAGED;
15749   elf32_arm_begin_write_processing (abfd, link_info);
15750 }
15751
15752 static bfd_boolean
15753 elf32_arm_symbian_modify_segment_map (bfd *abfd,
15754                                       struct bfd_link_info *info)
15755 {
15756   struct elf_segment_map *m;
15757   asection *dynsec;
15758
15759   /* BPABI shared libraries and executables should have a PT_DYNAMIC
15760      segment.  However, because the .dynamic section is not marked
15761      with SEC_LOAD, the generic ELF code will not create such a
15762      segment.  */
15763   dynsec = bfd_get_section_by_name (abfd, ".dynamic");
15764   if (dynsec)
15765     {
15766       for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
15767         if (m->p_type == PT_DYNAMIC)
15768           break;
15769
15770       if (m == NULL)
15771         {
15772           m = _bfd_elf_make_dynamic_segment (abfd, dynsec);
15773           m->next = elf_tdata (abfd)->segment_map;
15774           elf_tdata (abfd)->segment_map = m;
15775         }
15776     }
15777
15778   /* Also call the generic arm routine.  */
15779   return elf32_arm_modify_segment_map (abfd, info);
15780 }
15781
15782 /* Return address for Ith PLT stub in section PLT, for relocation REL
15783    or (bfd_vma) -1 if it should not be included.  */
15784
15785 static bfd_vma
15786 elf32_arm_symbian_plt_sym_val (bfd_vma i, const asection *plt,
15787                                const arelent *rel ATTRIBUTE_UNUSED)
15788 {
15789   return plt->vma + 4 * ARRAY_SIZE (elf32_arm_symbian_plt_entry) * i;
15790 }
15791
15792
15793 #undef  elf32_bed
15794 #define elf32_bed elf32_arm_symbian_bed
15795
15796 /* The dynamic sections are not allocated on SymbianOS; the postlinker
15797    will process them and then discard them.  */
15798 #undef  ELF_DYNAMIC_SEC_FLAGS
15799 #define ELF_DYNAMIC_SEC_FLAGS \
15800   (SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED)
15801
15802 #undef elf_backend_emit_relocs
15803
15804 #undef  bfd_elf32_bfd_link_hash_table_create
15805 #define bfd_elf32_bfd_link_hash_table_create    elf32_arm_symbian_link_hash_table_create
15806 #undef  elf_backend_special_sections
15807 #define elf_backend_special_sections            elf32_arm_symbian_special_sections
15808 #undef  elf_backend_begin_write_processing
15809 #define elf_backend_begin_write_processing      elf32_arm_symbian_begin_write_processing
15810 #undef  elf_backend_final_write_processing
15811 #define elf_backend_final_write_processing      elf32_arm_final_write_processing
15812
15813 #undef  elf_backend_modify_segment_map
15814 #define elf_backend_modify_segment_map elf32_arm_symbian_modify_segment_map
15815
15816 /* There is no .got section for BPABI objects, and hence no header.  */
15817 #undef  elf_backend_got_header_size
15818 #define elf_backend_got_header_size 0
15819
15820 /* Similarly, there is no .got.plt section.  */
15821 #undef  elf_backend_want_got_plt
15822 #define elf_backend_want_got_plt 0
15823
15824 #undef  elf_backend_plt_sym_val
15825 #define elf_backend_plt_sym_val         elf32_arm_symbian_plt_sym_val
15826
15827 #undef  elf_backend_may_use_rel_p
15828 #define elf_backend_may_use_rel_p       1
15829 #undef  elf_backend_may_use_rela_p
15830 #define elf_backend_may_use_rela_p      0
15831 #undef  elf_backend_default_use_rela_p
15832 #define elf_backend_default_use_rela_p  0
15833 #undef  elf_backend_want_plt_sym
15834 #define elf_backend_want_plt_sym        0
15835 #undef  ELF_MAXPAGESIZE
15836 #define ELF_MAXPAGESIZE                 0x8000
15837
15838 #include "elf32-target.h"