bfd/elf32-arm.c

   1 /* 32-bit ELF support for ARM
   2    Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
   3    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 2 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, MA 02110-1301, USA.  */
  20
  21 #include "elf/arm.h"
  22 #include "bfd.h"
  23 #include "sysdep.h"
  24 #include "libbfd.h"
  25 #include "elf-bfd.h"
  26
  27 #ifndef NUM_ELEM
  28 #define NUM_ELEM(a)  (sizeof (a) / (sizeof (a)[0]))
  29 #endif
  30
  31 #define elf_info_to_howto               0
  32 #define elf_info_to_howto_rel           elf32_arm_info_to_howto
  33
  34 #define ARM_ELF_ABI_VERSION             0
  35 #define ARM_ELF_OS_ABI_VERSION          ELFOSABI_ARM
  36
  37 /* Note: code such as elf32_arm_reloc_type_lookup expect to use e.g.
  38    R_ARM_PC24 as an index into this, and find the R_ARM_PC24 HOWTO
  39    in that slot.  */
  40
  41 static reloc_howto_type elf32_arm_howto_table_1[] =
  42 {
  43   /* No relocation */
  44   HOWTO (R_ARM_NONE,            /* type */
  45          0,                     /* rightshift */
  46          0,                     /* size (0 = byte, 1 = short, 2 = long) */
  47          0,                     /* bitsize */
  48          FALSE,                 /* pc_relative */
  49          0,                     /* bitpos */
  50          complain_overflow_dont,/* complain_on_overflow */
  51          bfd_elf_generic_reloc, /* special_function */
  52          "R_ARM_NONE",          /* name */
  53          FALSE,                 /* partial_inplace */
  54          0,                     /* src_mask */
  55          0,                     /* dst_mask */
  56          FALSE),                /* pcrel_offset */
  57
  58   HOWTO (R_ARM_PC24,            /* type */
  59          2,                     /* rightshift */
  60          2,                     /* size (0 = byte, 1 = short, 2 = long) */
  61          24,                    /* bitsize */
  62          TRUE,                  /* pc_relative */
  63          0,                     /* bitpos */
  64          complain_overflow_signed,/* complain_on_overflow */
  65          bfd_elf_generic_reloc, /* special_function */
  66          "R_ARM_PC24",          /* name */
  67          FALSE,                 /* partial_inplace */
  68          0x00ffffff,            /* src_mask */
  69          0x00ffffff,            /* dst_mask */
  70          TRUE),                 /* pcrel_offset */
  71
  72   /* 32 bit absolute */
  73   HOWTO (R_ARM_ABS32,           /* type */
  74          0,                     /* rightshift */
  75          2,                     /* size (0 = byte, 1 = short, 2 = long) */
  76          32,                    /* bitsize */
  77          FALSE,                 /* pc_relative */
  78          0,                     /* bitpos */
  79          complain_overflow_bitfield,/* complain_on_overflow */
  80          bfd_elf_generic_reloc, /* special_function */
  81          "R_ARM_ABS32",         /* name */
  82          FALSE,                 /* partial_inplace */
  83          0xffffffff,            /* src_mask */
  84          0xffffffff,            /* dst_mask */
  85          FALSE),                /* pcrel_offset */
  86
  87   /* standard 32bit pc-relative reloc */
  88   HOWTO (R_ARM_REL32,           /* type */
  89          0,                     /* rightshift */
  90          2,                     /* size (0 = byte, 1 = short, 2 = long) */
  91          32,                    /* bitsize */
  92          TRUE,                  /* pc_relative */
  93          0,                     /* bitpos */
  94          complain_overflow_bitfield,/* complain_on_overflow */
  95          bfd_elf_generic_reloc, /* special_function */
  96          "R_ARM_REL32",         /* name */
  97          FALSE,                 /* partial_inplace */
  98          0xffffffff,            /* src_mask */
  99          0xffffffff,            /* dst_mask */
 100          TRUE),                 /* pcrel_offset */
 101
 102   /* 8 bit absolute - R_ARM_LDR_PC_G0 in AAELF */
 103   HOWTO (R_ARM_PC13,            /* type */
 104          0,                     /* rightshift */
 105          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 106          8,                     /* bitsize */
 107          FALSE,                 /* pc_relative */
 108          0,                     /* bitpos */
 109          complain_overflow_bitfield,/* complain_on_overflow */
 110          bfd_elf_generic_reloc, /* special_function */
 111          "R_ARM_PC13",          /* name */
 112          FALSE,                 /* partial_inplace */
 113          0x000000ff,            /* src_mask */
 114          0x000000ff,            /* dst_mask */
 115          FALSE),                /* pcrel_offset */
 116
 117    /* 16 bit absolute */
 118   HOWTO (R_ARM_ABS16,           /* type */
 119          0,                     /* rightshift */
 120          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 121          16,                    /* bitsize */
 122          FALSE,                 /* pc_relative */
 123          0,                     /* bitpos */
 124          complain_overflow_bitfield,/* complain_on_overflow */
 125          bfd_elf_generic_reloc, /* special_function */
 126          "R_ARM_ABS16",         /* name */
 127          FALSE,                 /* partial_inplace */
 128          0x0000ffff,            /* src_mask */
 129          0x0000ffff,            /* dst_mask */
 130          FALSE),                /* pcrel_offset */
 131
 132   /* 12 bit absolute */
 133   HOWTO (R_ARM_ABS12,           /* type */
 134          0,                     /* rightshift */
 135          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 136          12,                    /* bitsize */
 137          FALSE,                 /* pc_relative */
 138          0,                     /* bitpos */
 139          complain_overflow_bitfield,/* complain_on_overflow */
 140          bfd_elf_generic_reloc, /* special_function */
 141          "R_ARM_ABS12",         /* name */
 142          FALSE,                 /* partial_inplace */
 143          0x000008ff,            /* src_mask */
 144          0x000008ff,            /* dst_mask */
 145          FALSE),                /* pcrel_offset */
 146
 147   HOWTO (R_ARM_THM_ABS5,        /* type */
 148          6,                     /* rightshift */
 149          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 150          5,                     /* bitsize */
 151          FALSE,                 /* pc_relative */
 152          0,                     /* bitpos */
 153          complain_overflow_bitfield,/* complain_on_overflow */
 154          bfd_elf_generic_reloc, /* special_function */
 155          "R_ARM_THM_ABS5",      /* name */
 156          FALSE,                 /* partial_inplace */
 157          0x000007e0,            /* src_mask */
 158          0x000007e0,            /* dst_mask */
 159          FALSE),                /* pcrel_offset */
 160
 161   /* 8 bit absolute */
 162   HOWTO (R_ARM_ABS8,            /* type */
 163          0,                     /* rightshift */
 164          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 165          8,                     /* bitsize */
 166          FALSE,                 /* pc_relative */
 167          0,                     /* bitpos */
 168          complain_overflow_bitfield,/* complain_on_overflow */
 169          bfd_elf_generic_reloc, /* special_function */
 170          "R_ARM_ABS8",          /* name */
 171          FALSE,                 /* partial_inplace */
 172          0x000000ff,            /* src_mask */
 173          0x000000ff,            /* dst_mask */
 174          FALSE),                /* pcrel_offset */
 175
 176   HOWTO (R_ARM_SBREL32,         /* type */
 177          0,                     /* rightshift */
 178          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 179          32,                    /* bitsize */
 180          FALSE,                 /* pc_relative */
 181          0,                     /* bitpos */
 182          complain_overflow_dont,/* complain_on_overflow */
 183          bfd_elf_generic_reloc, /* special_function */
 184          "R_ARM_SBREL32",       /* name */
 185          FALSE,                 /* partial_inplace */
 186          0xffffffff,            /* src_mask */
 187          0xffffffff,            /* dst_mask */
 188          FALSE),                /* pcrel_offset */
 189
 190   /* FIXME: Has two more bits of offset in Thumb32.  */
 191   HOWTO (R_ARM_THM_CALL,        /* type */
 192          1,                     /* rightshift */
 193          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 194          23,                    /* bitsize */
 195          TRUE,                  /* pc_relative */
 196          0,                     /* bitpos */
 197          complain_overflow_signed,/* complain_on_overflow */
 198          bfd_elf_generic_reloc, /* special_function */
 199          "R_ARM_THM_CALL",      /* name */
 200          FALSE,                 /* partial_inplace */
 201          0x07ff07ff,            /* src_mask */
 202          0x07ff07ff,            /* dst_mask */
 203          TRUE),                 /* pcrel_offset */
 204
 205   HOWTO (R_ARM_THM_PC8,         /* type */
 206          1,                     /* rightshift */
 207          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 208          8,                     /* bitsize */
 209          TRUE,                  /* pc_relative */
 210          0,                     /* bitpos */
 211          complain_overflow_signed,/* complain_on_overflow */
 212          bfd_elf_generic_reloc, /* special_function */
 213          "R_ARM_THM_PC8",       /* name */
 214          FALSE,                 /* partial_inplace */
 215          0x000000ff,            /* src_mask */
 216          0x000000ff,            /* dst_mask */
 217          TRUE),                 /* pcrel_offset */
 218
 219   HOWTO (R_ARM_BREL_ADJ,        /* type */
 220          1,                     /* rightshift */
 221          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 222          32,                    /* bitsize */
 223          FALSE,                 /* pc_relative */
 224          0,                     /* bitpos */
 225          complain_overflow_signed,/* complain_on_overflow */
 226          bfd_elf_generic_reloc, /* special_function */
 227          "R_ARM_BREL_ADJ",      /* name */
 228          FALSE,                 /* partial_inplace */
 229          0xffffffff,            /* src_mask */
 230          0xffffffff,            /* dst_mask */
 231          FALSE),                /* pcrel_offset */
 232
 233   HOWTO (R_ARM_SWI24,           /* type */
 234          0,                     /* rightshift */
 235          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 236          0,                     /* bitsize */
 237          FALSE,                 /* pc_relative */
 238          0,                     /* bitpos */
 239          complain_overflow_signed,/* complain_on_overflow */
 240          bfd_elf_generic_reloc, /* special_function */
 241          "R_ARM_SWI24",         /* name */
 242          FALSE,                 /* partial_inplace */
 243          0x00000000,            /* src_mask */
 244          0x00000000,            /* dst_mask */
 245          FALSE),                /* pcrel_offset */
 246
 247   HOWTO (R_ARM_THM_SWI8,        /* type */
 248          0,                     /* rightshift */
 249          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 250          0,                     /* bitsize */
 251          FALSE,                 /* pc_relative */
 252          0,                     /* bitpos */
 253          complain_overflow_signed,/* complain_on_overflow */
 254          bfd_elf_generic_reloc, /* special_function */
 255          "R_ARM_SWI8",          /* name */
 256          FALSE,                 /* partial_inplace */
 257          0x00000000,            /* src_mask */
 258          0x00000000,            /* dst_mask */
 259          FALSE),                /* pcrel_offset */
 260
 261   /* BLX instruction for the ARM.  */
 262   HOWTO (R_ARM_XPC25,           /* type */
 263          2,                     /* rightshift */
 264          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 265          25,                    /* bitsize */
 266          TRUE,                  /* pc_relative */
 267          0,                     /* bitpos */
 268          complain_overflow_signed,/* complain_on_overflow */
 269          bfd_elf_generic_reloc, /* special_function */
 270          "R_ARM_XPC25",         /* name */
 271          FALSE,                 /* partial_inplace */
 272          0x00ffffff,            /* src_mask */
 273          0x00ffffff,            /* dst_mask */
 274          TRUE),                 /* pcrel_offset */
 275
 276   /* BLX instruction for the Thumb.  */
 277   HOWTO (R_ARM_THM_XPC22,       /* type */
 278          2,                     /* rightshift */
 279          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 280          22,                    /* bitsize */
 281          TRUE,                  /* pc_relative */
 282          0,                     /* bitpos */
 283          complain_overflow_signed,/* complain_on_overflow */
 284          bfd_elf_generic_reloc, /* special_function */
 285          "R_ARM_THM_XPC22",     /* name */
 286          FALSE,                 /* partial_inplace */
 287          0x07ff07ff,            /* src_mask */
 288          0x07ff07ff,            /* dst_mask */
 289          TRUE),                 /* pcrel_offset */
 290
 291   /* Dynamic TLS relocations.  */
 292
 293   HOWTO (R_ARM_TLS_DTPMOD32,    /* type */
 294          0,                     /* rightshift */
 295          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 296          32,                    /* bitsize */
 297          FALSE,                 /* pc_relative */
 298          0,                     /* bitpos */
 299          complain_overflow_bitfield,/* complain_on_overflow */
 300          bfd_elf_generic_reloc, /* special_function */
 301          "R_ARM_TLS_DTPMOD32",  /* name */
 302          TRUE,                  /* partial_inplace */
 303          0xffffffff,            /* src_mask */
 304          0xffffffff,            /* dst_mask */
 305          FALSE),                /* pcrel_offset */
 306
 307   HOWTO (R_ARM_TLS_DTPOFF32,    /* type */
 308          0,                     /* rightshift */
 309          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 310          32,                    /* bitsize */
 311          FALSE,                 /* pc_relative */
 312          0,                     /* bitpos */
 313          complain_overflow_bitfield,/* complain_on_overflow */
 314          bfd_elf_generic_reloc, /* special_function */
 315          "R_ARM_TLS_DTPOFF32",  /* name */
 316          TRUE,                  /* partial_inplace */
 317          0xffffffff,            /* src_mask */
 318          0xffffffff,            /* dst_mask */
 319          FALSE),                /* pcrel_offset */
 320
 321   HOWTO (R_ARM_TLS_TPOFF32,     /* type */
 322          0,                     /* rightshift */
 323          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 324          32,                    /* bitsize */
 325          FALSE,                 /* pc_relative */
 326          0,                     /* bitpos */
 327          complain_overflow_bitfield,/* complain_on_overflow */
 328          bfd_elf_generic_reloc, /* special_function */
 329          "R_ARM_TLS_TPOFF32",   /* name */
 330          TRUE,                  /* partial_inplace */
 331          0xffffffff,            /* src_mask */
 332          0xffffffff,            /* dst_mask */
 333          FALSE),                /* pcrel_offset */
 334
 335   /* Relocs used in ARM Linux */
 336
 337   HOWTO (R_ARM_COPY,            /* type */
 338          0,                     /* rightshift */
 339          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 340          32,                    /* bitsize */
 341          FALSE,                 /* pc_relative */
 342          0,                     /* bitpos */
 343          complain_overflow_bitfield,/* complain_on_overflow */
 344          bfd_elf_generic_reloc, /* special_function */
 345          "R_ARM_COPY",          /* name */
 346          TRUE,                  /* partial_inplace */
 347          0xffffffff,            /* src_mask */
 348          0xffffffff,            /* dst_mask */
 349          FALSE),                /* pcrel_offset */
 350
 351   HOWTO (R_ARM_GLOB_DAT,        /* type */
 352          0,                     /* rightshift */
 353          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 354          32,                    /* bitsize */
 355          FALSE,                 /* pc_relative */
 356          0,                     /* bitpos */
 357          complain_overflow_bitfield,/* complain_on_overflow */
 358          bfd_elf_generic_reloc, /* special_function */
 359          "R_ARM_GLOB_DAT",      /* name */
 360          TRUE,                  /* partial_inplace */
 361          0xffffffff,            /* src_mask */
 362          0xffffffff,            /* dst_mask */
 363          FALSE),                /* pcrel_offset */
 364
 365   HOWTO (R_ARM_JUMP_SLOT,       /* type */
 366          0,                     /* rightshift */
 367          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 368          32,                    /* bitsize */
 369          FALSE,                 /* pc_relative */
 370          0,                     /* bitpos */
 371          complain_overflow_bitfield,/* complain_on_overflow */
 372          bfd_elf_generic_reloc, /* special_function */
 373          "R_ARM_JUMP_SLOT",     /* name */
 374          TRUE,                  /* partial_inplace */
 375          0xffffffff,            /* src_mask */
 376          0xffffffff,            /* dst_mask */
 377          FALSE),                /* pcrel_offset */
 378
 379   HOWTO (R_ARM_RELATIVE,        /* type */
 380          0,                     /* rightshift */
 381          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 382          32,                    /* bitsize */
 383          FALSE,                 /* pc_relative */
 384          0,                     /* bitpos */
 385          complain_overflow_bitfield,/* complain_on_overflow */
 386          bfd_elf_generic_reloc, /* special_function */
 387          "R_ARM_RELATIVE",      /* name */
 388          TRUE,                  /* partial_inplace */
 389          0xffffffff,            /* src_mask */
 390          0xffffffff,            /* dst_mask */
 391          FALSE),                /* pcrel_offset */
 392
 393   HOWTO (R_ARM_GOTOFF32,        /* type */
 394          0,                     /* rightshift */
 395          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 396          32,                    /* bitsize */
 397          FALSE,                 /* pc_relative */
 398          0,                     /* bitpos */
 399          complain_overflow_bitfield,/* complain_on_overflow */
 400          bfd_elf_generic_reloc, /* special_function */
 401          "R_ARM_GOTOFF32",      /* name */
 402          TRUE,                  /* partial_inplace */
 403          0xffffffff,            /* src_mask */
 404          0xffffffff,            /* dst_mask */
 405          FALSE),                /* pcrel_offset */
 406
 407   HOWTO (R_ARM_GOTPC,           /* type */
 408          0,                     /* rightshift */
 409          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 410          32,                    /* bitsize */
 411          TRUE,                  /* pc_relative */
 412          0,                     /* bitpos */
 413          complain_overflow_bitfield,/* complain_on_overflow */
 414          bfd_elf_generic_reloc, /* special_function */
 415          "R_ARM_GOTPC",         /* name */
 416          TRUE,                  /* partial_inplace */
 417          0xffffffff,            /* src_mask */
 418          0xffffffff,            /* dst_mask */
 419          TRUE),                 /* pcrel_offset */
 420
 421   HOWTO (R_ARM_GOT32,           /* type */
 422          0,                     /* rightshift */
 423          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 424          32,                    /* bitsize */
 425          FALSE,                 /* pc_relative */
 426          0,                     /* bitpos */
 427          complain_overflow_bitfield,/* complain_on_overflow */
 428          bfd_elf_generic_reloc, /* special_function */
 429          "R_ARM_GOT32",         /* name */
 430          TRUE,                  /* partial_inplace */
 431          0xffffffff,            /* src_mask */
 432          0xffffffff,            /* dst_mask */
 433          FALSE),                /* pcrel_offset */
 434
 435   HOWTO (R_ARM_PLT32,           /* type */
 436          2,                     /* rightshift */
 437          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 438          26,                    /* bitsize */
 439          TRUE,                  /* pc_relative */
 440          0,                     /* bitpos */
 441          complain_overflow_bitfield,/* complain_on_overflow */
 442          bfd_elf_generic_reloc, /* special_function */
 443          "R_ARM_PLT32",         /* name */
 444          TRUE,                  /* partial_inplace */
 445          0x00ffffff,            /* src_mask */
 446          0x00ffffff,            /* dst_mask */
 447          TRUE),                 /* pcrel_offset */
 448
 449   HOWTO (R_ARM_CALL,            /* type */
 450          2,                     /* rightshift */
 451          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 452          24,                    /* bitsize */
 453          TRUE,                  /* pc_relative */
 454          0,                     /* bitpos */
 455          complain_overflow_signed,/* complain_on_overflow */
 456          bfd_elf_generic_reloc, /* special_function */
 457          "R_ARM_CALL",          /* name */
 458          FALSE,                 /* partial_inplace */
 459          0x00ffffff,            /* src_mask */
 460          0x00ffffff,            /* dst_mask */
 461          TRUE),                 /* pcrel_offset */
 462
 463   HOWTO (R_ARM_JUMP24,          /* type */
 464          2,                     /* rightshift */
 465          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 466          24,                    /* bitsize */
 467          TRUE,                  /* pc_relative */
 468          0,                     /* bitpos */
 469          complain_overflow_signed,/* complain_on_overflow */
 470          bfd_elf_generic_reloc, /* special_function */
 471          "R_ARM_JUMP24",        /* name */
 472          FALSE,                 /* partial_inplace */
 473          0x00ffffff,            /* src_mask */
 474          0x00ffffff,            /* dst_mask */
 475          TRUE),                 /* pcrel_offset */
 476
 477   HOWTO (R_ARM_THM_JUMP24,      /* type */
 478          1,                     /* rightshift */
 479          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 480          24,                    /* bitsize */
 481          TRUE,                  /* pc_relative */
 482          0,                     /* bitpos */
 483          complain_overflow_signed,/* complain_on_overflow */
 484          bfd_elf_generic_reloc, /* special_function */
 485          "R_ARM_THM_JUMP24",    /* name */
 486          FALSE,                 /* partial_inplace */
 487          0x07ff2fff,            /* src_mask */
 488          0x07ff2fff,            /* dst_mask */
 489          TRUE),                 /* pcrel_offset */
 490
 491   HOWTO (R_ARM_BASE_ABS,        /* type */
 492          0,                     /* rightshift */
 493          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 494          32,                    /* bitsize */
 495          FALSE,                 /* pc_relative */
 496          0,                     /* bitpos */
 497          complain_overflow_dont,/* complain_on_overflow */
 498          bfd_elf_generic_reloc, /* special_function */
 499          "R_ARM_BASE_ABS",      /* name */
 500          FALSE,                 /* partial_inplace */
 501          0xffffffff,            /* src_mask */
 502          0xffffffff,            /* dst_mask */
 503          FALSE),                /* pcrel_offset */
 504
 505   HOWTO (R_ARM_ALU_PCREL7_0,    /* type */
 506          0,                     /* rightshift */
 507          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 508          12,                    /* bitsize */
 509          TRUE,                  /* pc_relative */
 510          0,                     /* bitpos */
 511          complain_overflow_dont,/* complain_on_overflow */
 512          bfd_elf_generic_reloc, /* special_function */
 513          "R_ARM_ALU_PCREL_7_0", /* name */
 514          FALSE,                 /* partial_inplace */
 515          0x00000fff,            /* src_mask */
 516          0x00000fff,            /* dst_mask */
 517          TRUE),                 /* pcrel_offset */
 518
 519   HOWTO (R_ARM_ALU_PCREL15_8,   /* type */
 520          0,                     /* rightshift */
 521          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 522          12,                    /* bitsize */
 523          TRUE,                  /* pc_relative */
 524          8,                     /* bitpos */
 525          complain_overflow_dont,/* complain_on_overflow */
 526          bfd_elf_generic_reloc, /* special_function */
 527          "R_ARM_ALU_PCREL_15_8",/* name */
 528          FALSE,                 /* partial_inplace */
 529          0x00000fff,            /* src_mask */
 530          0x00000fff,            /* dst_mask */
 531          TRUE),                 /* pcrel_offset */
 532
 533   HOWTO (R_ARM_ALU_PCREL23_15,  /* type */
 534          0,                     /* rightshift */
 535          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 536          12,                    /* bitsize */
 537          TRUE,                  /* pc_relative */
 538          16,                    /* bitpos */
 539          complain_overflow_dont,/* complain_on_overflow */
 540          bfd_elf_generic_reloc, /* special_function */
 541          "R_ARM_ALU_PCREL_23_15",/* name */
 542          FALSE,                 /* partial_inplace */
 543          0x00000fff,            /* src_mask */
 544          0x00000fff,            /* dst_mask */
 545          TRUE),                 /* pcrel_offset */
 546
 547   HOWTO (R_ARM_LDR_SBREL_11_0,  /* type */
 548          0,                     /* rightshift */
 549          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 550          12,                    /* bitsize */
 551          FALSE,                 /* pc_relative */
 552          0,                     /* bitpos */
 553          complain_overflow_dont,/* complain_on_overflow */
 554          bfd_elf_generic_reloc, /* special_function */
 555          "R_ARM_LDR_SBREL_11_0",/* name */
 556          FALSE,                 /* partial_inplace */
 557          0x00000fff,            /* src_mask */
 558          0x00000fff,            /* dst_mask */
 559          FALSE),                /* pcrel_offset */
 560
 561   HOWTO (R_ARM_ALU_SBREL_19_12, /* type */
 562          0,                     /* rightshift */
 563          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 564          8,                     /* bitsize */
 565          FALSE,                 /* pc_relative */
 566          12,                    /* bitpos */
 567          complain_overflow_dont,/* complain_on_overflow */
 568          bfd_elf_generic_reloc, /* special_function */
 569          "R_ARM_ALU_SBREL_19_12",/* name */
 570          FALSE,                 /* partial_inplace */
 571          0x000ff000,            /* src_mask */
 572          0x000ff000,            /* dst_mask */
 573          FALSE),                /* pcrel_offset */
 574
 575   HOWTO (R_ARM_ALU_SBREL_27_20, /* type */
 576          0,                     /* rightshift */
 577          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 578          8,                     /* bitsize */
 579          FALSE,                 /* pc_relative */
 580          20,                    /* bitpos */
 581          complain_overflow_dont,/* complain_on_overflow */
 582          bfd_elf_generic_reloc, /* special_function */
 583          "R_ARM_ALU_SBREL_27_20",/* name */
 584          FALSE,                 /* partial_inplace */
 585          0x0ff00000,            /* src_mask */
 586          0x0ff00000,            /* dst_mask */
 587          FALSE),                /* pcrel_offset */
 588
 589   HOWTO (R_ARM_TARGET1,         /* type */
 590          0,                     /* rightshift */
 591          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 592          32,                    /* bitsize */
 593          FALSE,                 /* pc_relative */
 594          0,                     /* bitpos */
 595          complain_overflow_dont,/* complain_on_overflow */
 596          bfd_elf_generic_reloc, /* special_function */
 597          "R_ARM_TARGET1",       /* name */
 598          FALSE,                 /* partial_inplace */
 599          0xffffffff,            /* src_mask */
 600          0xffffffff,            /* dst_mask */
 601          FALSE),                /* pcrel_offset */
 602
 603   HOWTO (R_ARM_ROSEGREL32,      /* type */
 604          0,                     /* rightshift */
 605          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 606          32,                    /* bitsize */
 607          FALSE,                 /* pc_relative */
 608          0,                     /* bitpos */
 609          complain_overflow_dont,/* complain_on_overflow */
 610          bfd_elf_generic_reloc, /* special_function */
 611          "R_ARM_ROSEGREL32",    /* name */
 612          FALSE,                 /* partial_inplace */
 613          0xffffffff,            /* src_mask */
 614          0xffffffff,            /* dst_mask */
 615          FALSE),                /* pcrel_offset */
 616
 617   HOWTO (R_ARM_V4BX,            /* type */
 618          0,                     /* rightshift */
 619          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 620          32,                    /* bitsize */
 621          FALSE,                 /* pc_relative */
 622          0,                     /* bitpos */
 623          complain_overflow_dont,/* complain_on_overflow */
 624          bfd_elf_generic_reloc, /* special_function */
 625          "R_ARM_V4BX",          /* name */
 626          FALSE,                 /* partial_inplace */
 627          0xffffffff,            /* src_mask */
 628          0xffffffff,            /* dst_mask */
 629          FALSE),                /* pcrel_offset */
 630
 631   HOWTO (R_ARM_TARGET2,         /* type */
 632          0,                     /* rightshift */
 633          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 634          32,                    /* bitsize */
 635          FALSE,                 /* pc_relative */
 636          0,                     /* bitpos */
 637          complain_overflow_signed,/* complain_on_overflow */
 638          bfd_elf_generic_reloc, /* special_function */
 639          "R_ARM_TARGET2",       /* name */
 640          FALSE,                 /* partial_inplace */
 641          0xffffffff,            /* src_mask */
 642          0xffffffff,            /* dst_mask */
 643          TRUE),                 /* pcrel_offset */
 644
 645   HOWTO (R_ARM_PREL31,          /* type */
 646          0,                     /* rightshift */
 647          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 648          31,                    /* bitsize */
 649          TRUE,                  /* pc_relative */
 650          0,                     /* bitpos */
 651          complain_overflow_signed,/* complain_on_overflow */
 652          bfd_elf_generic_reloc, /* special_function */
 653          "R_ARM_PREL31",        /* name */
 654          FALSE,                 /* partial_inplace */
 655          0x7fffffff,            /* src_mask */
 656          0x7fffffff,            /* dst_mask */
 657          TRUE),                 /* pcrel_offset */
 658
 659   HOWTO (R_ARM_MOVW_ABS_NC,     /* type */
 660          0,                     /* rightshift */
 661          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 662          16,                    /* bitsize */
 663          FALSE,                 /* pc_relative */
 664          0,                     /* bitpos */
 665          complain_overflow_dont,/* complain_on_overflow */
 666          bfd_elf_generic_reloc, /* special_function */
 667          "R_ARM_MOVW_ABS_NC",   /* name */
 668          FALSE,                 /* partial_inplace */
 669          0x0000ffff,            /* src_mask */
 670          0x0000ffff,            /* dst_mask */
 671          FALSE),                /* pcrel_offset */
 672
 673   HOWTO (R_ARM_MOVT_ABS,        /* type */
 674          0,                     /* rightshift */
 675          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 676          16,                    /* bitsize */
 677          FALSE,                 /* pc_relative */
 678          0,                     /* bitpos */
 679          complain_overflow_bitfield,/* complain_on_overflow */
 680          bfd_elf_generic_reloc, /* special_function */
 681          "R_ARM_MOVT_ABS",      /* name */
 682          FALSE,                 /* partial_inplace */
 683          0x0000ffff,            /* src_mask */
 684          0x0000ffff,            /* dst_mask */
 685          FALSE),                /* pcrel_offset */
 686
 687   HOWTO (R_ARM_MOVW_PREL_NC,    /* type */
 688          0,                     /* rightshift */
 689          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 690          16,                    /* bitsize */
 691          TRUE,                  /* pc_relative */
 692          0,                     /* bitpos */
 693          complain_overflow_dont,/* complain_on_overflow */
 694          bfd_elf_generic_reloc, /* special_function */
 695          "R_ARM_MOVW_PREL_NC",  /* name */
 696          FALSE,                 /* partial_inplace */
 697          0x0000ffff,            /* src_mask */
 698          0x0000ffff,            /* dst_mask */
 699          TRUE),                 /* pcrel_offset */
 700
 701   HOWTO (R_ARM_MOVT_PREL,       /* type */
 702          0,                     /* rightshift */
 703          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 704          16,                    /* bitsize */
 705          TRUE,                  /* pc_relative */
 706          0,                     /* bitpos */
 707          complain_overflow_bitfield,/* complain_on_overflow */
 708          bfd_elf_generic_reloc, /* special_function */
 709          "R_ARM_MOVT_PREL",     /* name */
 710          FALSE,                 /* partial_inplace */
 711          0x0000ffff,            /* src_mask */
 712          0x0000ffff,            /* dst_mask */
 713          TRUE),                 /* pcrel_offset */
 714
 715   HOWTO (R_ARM_THM_MOVW_ABS_NC, /* type */
 716          0,                     /* rightshift */
 717          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 718          16,                    /* bitsize */
 719          FALSE,                 /* pc_relative */
 720          0,                     /* bitpos */
 721          complain_overflow_dont,/* complain_on_overflow */
 722          bfd_elf_generic_reloc, /* special_function */
 723          "R_ARM_THM_MOVW_ABS_NC",/* name */
 724          FALSE,                 /* partial_inplace */
 725          0x040f70ff,            /* src_mask */
 726          0x040f70ff,            /* dst_mask */
 727          FALSE),                /* pcrel_offset */
 728
 729   HOWTO (R_ARM_THM_MOVT_ABS,    /* type */
 730          0,                     /* rightshift */
 731          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 732          16,                    /* bitsize */
 733          FALSE,                 /* pc_relative */
 734          0,                     /* bitpos */
 735          complain_overflow_bitfield,/* complain_on_overflow */
 736          bfd_elf_generic_reloc, /* special_function */
 737          "R_ARM_THM_MOVT_ABS",  /* name */
 738          FALSE,                 /* partial_inplace */
 739          0x040f70ff,            /* src_mask */
 740          0x040f70ff,            /* dst_mask */
 741          FALSE),                /* pcrel_offset */
 742
 743   HOWTO (R_ARM_THM_MOVW_PREL_NC,/* type */
 744          0,                     /* rightshift */
 745          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 746          16,                    /* bitsize */
 747          TRUE,                  /* pc_relative */
 748          0,                     /* bitpos */
 749          complain_overflow_dont,/* complain_on_overflow */
 750          bfd_elf_generic_reloc, /* special_function */
 751          "R_ARM_THM_MOVW_PREL_NC",/* name */
 752          FALSE,                 /* partial_inplace */
 753          0x040f70ff,            /* src_mask */
 754          0x040f70ff,            /* dst_mask */
 755          TRUE),                 /* pcrel_offset */
 756
 757   HOWTO (R_ARM_THM_MOVT_PREL,   /* type */
 758          0,                     /* rightshift */
 759          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 760          16,                    /* bitsize */
 761          TRUE,                  /* pc_relative */
 762          0,                     /* bitpos */
 763          complain_overflow_bitfield,/* complain_on_overflow */
 764          bfd_elf_generic_reloc, /* special_function */
 765          "R_ARM_THM_MOVT_PREL", /* name */
 766          FALSE,                 /* partial_inplace */
 767          0x040f70ff,            /* src_mask */
 768          0x040f70ff,            /* dst_mask */
 769          TRUE),                 /* pcrel_offset */
 770
 771   HOWTO (R_ARM_THM_JUMP19,      /* type */
 772          1,                     /* rightshift */
 773          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 774          19,                    /* bitsize */
 775          TRUE,                  /* pc_relative */
 776          0,                     /* bitpos */
 777          complain_overflow_signed,/* complain_on_overflow */
 778          bfd_elf_generic_reloc, /* special_function */
 779          "R_ARM_THM_JUMP19",    /* name */
 780          FALSE,                 /* partial_inplace */
 781          0x043f2fff,            /* src_mask */
 782          0x043f2fff,            /* dst_mask */
 783          TRUE),                 /* pcrel_offset */
 784
 785   HOWTO (R_ARM_THM_JUMP6,       /* type */
 786          1,                     /* rightshift */
 787          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 788          6,                     /* bitsize */
 789          TRUE,                  /* pc_relative */
 790          0,                     /* bitpos */
 791          complain_overflow_unsigned,/* complain_on_overflow */
 792          bfd_elf_generic_reloc, /* special_function */
 793          "R_ARM_THM_JUMP6",     /* name */
 794          FALSE,                 /* partial_inplace */
 795          0x02f8,                /* src_mask */
 796          0x02f8,                /* dst_mask */
 797          TRUE),                 /* pcrel_offset */
 798
 799   /* These are declared as 13-bit signed relocations because we can
 800      address -4095 .. 4095(base) by altering ADDW to SUBW or vice
 801      versa.  */
 802   HOWTO (R_ARM_THM_ALU_PREL_11_0,/* type */
 803          0,                     /* rightshift */
 804          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 805          13,                    /* 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_ALU_PREL_11_0",/* name */
 811          FALSE,                 /* partial_inplace */
 812          0x040070ff,            /* src_mask */
 813          0x040070ff,            /* dst_mask */
 814          TRUE),                 /* pcrel_offset */
 815
 816   HOWTO (R_ARM_THM_PC12,        /* type */
 817          0,                     /* rightshift */
 818          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 819          13,                    /* bitsize */
 820          TRUE,                  /* pc_relative */
 821          0,                     /* bitpos */
 822          complain_overflow_signed,/* complain_on_overflow */
 823          bfd_elf_generic_reloc, /* special_function */
 824          "R_ARM_THM_PC12",      /* name */
 825          FALSE,                 /* partial_inplace */
 826          0x040070ff,            /* src_mask */
 827          0x040070ff,            /* dst_mask */
 828          TRUE),                 /* pcrel_offset */
 829
 830   HOWTO (R_ARM_ABS32_NOI,       /* type */
 831          0,                     /* rightshift */
 832          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 833          32,                    /* bitsize */
 834          FALSE,                 /* pc_relative */
 835          0,                     /* bitpos */
 836          complain_overflow_dont,/* complain_on_overflow */
 837          bfd_elf_generic_reloc, /* special_function */
 838          "R_ARM_ABS32_NOI",     /* name */
 839          FALSE,                 /* partial_inplace */
 840          0xffffffff,            /* src_mask */
 841          0xffffffff,            /* dst_mask */
 842          FALSE),                /* pcrel_offset */
 843
 844   HOWTO (R_ARM_REL32_NOI,       /* type */
 845          0,                     /* rightshift */
 846          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 847          32,                    /* bitsize */
 848          TRUE,                  /* pc_relative */
 849          0,                     /* bitpos */
 850          complain_overflow_dont,/* complain_on_overflow */
 851          bfd_elf_generic_reloc, /* special_function */
 852          "R_ARM_REL32_NOI",     /* name */
 853          FALSE,                 /* partial_inplace */
 854          0xffffffff,            /* src_mask */
 855          0xffffffff,            /* dst_mask */
 856          FALSE),                /* pcrel_offset */
 857 };
 858
 859 /* Relocations 57 .. 83 are the "group relocations" which we do not
 860    support.  */
 861
 862 static reloc_howto_type elf32_arm_howto_table_2[] =
 863 {
 864   HOWTO (R_ARM_MOVW_BREL_NC,    /* type */
 865          0,                     /* rightshift */
 866          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 867          16,                    /* bitsize */
 868          FALSE,                 /* pc_relative */
 869          0,                     /* bitpos */
 870          complain_overflow_dont,/* complain_on_overflow */
 871          bfd_elf_generic_reloc, /* special_function */
 872          "R_ARM_MOVW_BREL_NC",  /* name */
 873          FALSE,                 /* partial_inplace */
 874          0x0000ffff,            /* src_mask */
 875          0x0000ffff,            /* dst_mask */
 876          FALSE),                /* pcrel_offset */
 877
 878   HOWTO (R_ARM_MOVT_BREL,       /* type */
 879          0,                     /* rightshift */
 880          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 881          16,                    /* bitsize */
 882          FALSE,                 /* pc_relative */
 883          0,                     /* bitpos */
 884          complain_overflow_bitfield,/* complain_on_overflow */
 885          bfd_elf_generic_reloc, /* special_function */
 886          "R_ARM_MOVT_BREL",     /* name */
 887          FALSE,                 /* partial_inplace */
 888          0x0000ffff,            /* src_mask */
 889          0x0000ffff,            /* dst_mask */
 890          FALSE),                /* pcrel_offset */
 891
 892   HOWTO (R_ARM_MOVW_BREL,       /* type */
 893          0,                     /* rightshift */
 894          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 895          16,                    /* bitsize */
 896          FALSE,                 /* pc_relative */
 897          0,                     /* bitpos */
 898          complain_overflow_dont,/* complain_on_overflow */
 899          bfd_elf_generic_reloc, /* special_function */
 900          "R_ARM_MOVW_BREL",     /* name */
 901          FALSE,                 /* partial_inplace */
 902          0x0000ffff,            /* src_mask */
 903          0x0000ffff,            /* dst_mask */
 904          FALSE),                /* pcrel_offset */
 905
 906   HOWTO (R_ARM_THM_MOVW_BREL_NC,/* type */
 907          0,                     /* rightshift */
 908          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 909          16,                    /* bitsize */
 910          FALSE,                 /* pc_relative */
 911          0,                     /* bitpos */
 912          complain_overflow_dont,/* complain_on_overflow */
 913          bfd_elf_generic_reloc, /* special_function */
 914          "R_ARM_THM_MOVW_BREL_NC",/* name */
 915          FALSE,                 /* partial_inplace */
 916          0x040f70ff,            /* src_mask */
 917          0x040f70ff,            /* dst_mask */
 918          FALSE),                /* pcrel_offset */
 919
 920   HOWTO (R_ARM_THM_MOVT_BREL,   /* type */
 921          0,                     /* rightshift */
 922          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 923          16,                    /* bitsize */
 924          FALSE,                 /* pc_relative */
 925          0,                     /* bitpos */
 926          complain_overflow_bitfield,/* complain_on_overflow */
 927          bfd_elf_generic_reloc, /* special_function */
 928          "R_ARM_THM_MOVT_BREL", /* name */
 929          FALSE,                 /* partial_inplace */
 930          0x040f70ff,            /* src_mask */
 931          0x040f70ff,            /* dst_mask */
 932          FALSE),                /* pcrel_offset */
 933
 934   HOWTO (R_ARM_THM_MOVW_BREL,   /* type */
 935          0,                     /* rightshift */
 936          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 937          16,                    /* bitsize */
 938          FALSE,                 /* pc_relative */
 939          0,                     /* bitpos */
 940          complain_overflow_dont,/* complain_on_overflow */
 941          bfd_elf_generic_reloc, /* special_function */
 942          "R_ARM_THM_MOVW_BREL", /* name */
 943          FALSE,                 /* partial_inplace */
 944          0x040f70ff,            /* src_mask */
 945          0x040f70ff,            /* dst_mask */
 946          FALSE),                /* pcrel_offset */
 947
 948   EMPTY_HOWTO (90),   /* unallocated */
 949   EMPTY_HOWTO (91),
 950   EMPTY_HOWTO (92),
 951   EMPTY_HOWTO (93),
 952
 953   HOWTO (R_ARM_PLT32_ABS,       /* type */
 954          0,                     /* rightshift */
 955          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 956          32,                    /* bitsize */
 957          FALSE,                 /* pc_relative */
 958          0,                     /* bitpos */
 959          complain_overflow_dont,/* complain_on_overflow */
 960          bfd_elf_generic_reloc, /* special_function */
 961          "R_ARM_PLT32_ABS",     /* name */
 962          FALSE,                 /* partial_inplace */
 963          0xffffffff,            /* src_mask */
 964          0xffffffff,            /* dst_mask */
 965          FALSE),                /* pcrel_offset */
 966
 967   HOWTO (R_ARM_GOT_ABS,         /* type */
 968          0,                     /* rightshift */
 969          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 970          32,                    /* bitsize */
 971          FALSE,                 /* pc_relative */
 972          0,                     /* bitpos */
 973          complain_overflow_dont,/* complain_on_overflow */
 974          bfd_elf_generic_reloc, /* special_function */
 975          "R_ARM_GOT_ABS",       /* name */
 976          FALSE,                 /* partial_inplace */
 977          0xffffffff,            /* src_mask */
 978          0xffffffff,            /* dst_mask */
 979          FALSE),                        /* pcrel_offset */
 980
 981   HOWTO (R_ARM_GOT_PREL,        /* type */
 982          0,                     /* rightshift */
 983          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 984          32,                    /* bitsize */
 985          TRUE,                  /* pc_relative */
 986          0,                     /* bitpos */
 987          complain_overflow_dont,        /* complain_on_overflow */
 988          bfd_elf_generic_reloc, /* special_function */
 989          "R_ARM_GOT_PREL",      /* name */
 990          FALSE,                 /* partial_inplace */
 991          0xffffffff,            /* src_mask */
 992          0xffffffff,            /* dst_mask */
 993          TRUE),                 /* pcrel_offset */
 994
 995   HOWTO (R_ARM_GOT_BREL12,      /* type */
 996          0,                     /* rightshift */
 997          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 998          12,                    /* bitsize */
 999          FALSE,                 /* pc_relative */
1000          0,                     /* bitpos */
1001          complain_overflow_bitfield,/* complain_on_overflow */
1002          bfd_elf_generic_reloc, /* special_function */
1003          "R_ARM_GOT_BREL12",    /* name */
1004          FALSE,                 /* partial_inplace */
1005          0x00000fff,            /* src_mask */
1006          0x00000fff,            /* dst_mask */
1007          FALSE),                /* pcrel_offset */
1008
1009   HOWTO (R_ARM_GOTOFF12,        /* type */
1010          0,                     /* rightshift */
1011          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1012          12,                    /* bitsize */
1013          FALSE,                 /* pc_relative */
1014          0,                     /* bitpos */
1015          complain_overflow_bitfield,/* complain_on_overflow */
1016          bfd_elf_generic_reloc, /* special_function */
1017          "R_ARM_GOTOFF12",      /* name */
1018          FALSE,                 /* partial_inplace */
1019          0x00000fff,            /* src_mask */
1020          0x00000fff,            /* dst_mask */
1021          FALSE),                /* pcrel_offset */
1022
1023   EMPTY_HOWTO (R_ARM_GOTRELAX),  /* reserved for future GOT-load optimizations */
1024
1025   /* GNU extension to record C++ vtable member usage */
1026   HOWTO (R_ARM_GNU_VTENTRY,     /* type */
1027          0,                     /* rightshift */
1028          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1029          0,                     /* bitsize */
1030          FALSE,                 /* pc_relative */
1031          0,                     /* bitpos */
1032          complain_overflow_dont, /* complain_on_overflow */
1033          _bfd_elf_rel_vtable_reloc_fn,  /* special_function */
1034          "R_ARM_GNU_VTENTRY",   /* name */
1035          FALSE,                 /* partial_inplace */
1036          0,                     /* src_mask */
1037          0,                     /* dst_mask */
1038          FALSE),                /* pcrel_offset */
1039
1040   /* GNU extension to record C++ vtable hierarchy */
1041   HOWTO (R_ARM_GNU_VTINHERIT, /* type */
1042          0,                     /* rightshift */
1043          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1044          0,                     /* bitsize */
1045          FALSE,                 /* pc_relative */
1046          0,                     /* bitpos */
1047          complain_overflow_dont, /* complain_on_overflow */
1048          NULL,                  /* special_function */
1049          "R_ARM_GNU_VTINHERIT", /* name */
1050          FALSE,                 /* partial_inplace */
1051          0,                     /* src_mask */
1052          0,                     /* dst_mask */
1053          FALSE),                /* pcrel_offset */
1054
1055   HOWTO (R_ARM_THM_JUMP11,      /* type */
1056          1,                     /* rightshift */
1057          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1058          11,                    /* bitsize */
1059          TRUE,                  /* pc_relative */
1060          0,                     /* bitpos */
1061          complain_overflow_signed,      /* complain_on_overflow */
1062          bfd_elf_generic_reloc, /* special_function */
1063          "R_ARM_THM_JUMP11",    /* name */
1064          FALSE,                 /* partial_inplace */
1065          0x000007ff,            /* src_mask */
1066          0x000007ff,            /* dst_mask */
1067          TRUE),                 /* pcrel_offset */
1068
1069   HOWTO (R_ARM_THM_JUMP8,       /* type */
1070          1,                     /* rightshift */
1071          1,                     /* size (0 = byte, 1 = short, 2 = long) */
1072          8,                     /* bitsize */
1073          TRUE,                  /* pc_relative */
1074          0,                     /* bitpos */
1075          complain_overflow_signed,      /* complain_on_overflow */
1076          bfd_elf_generic_reloc, /* special_function */
1077          "R_ARM_THM_JUMP8",     /* name */
1078          FALSE,                 /* partial_inplace */
1079          0x000000ff,            /* src_mask */
1080          0x000000ff,            /* dst_mask */
1081          TRUE),                 /* pcrel_offset */
1082
1083   /* TLS relocations */
1084   HOWTO (R_ARM_TLS_GD32,        /* type */
1085          0,                     /* rightshift */
1086          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1087          32,                    /* bitsize */
1088          FALSE,                 /* pc_relative */
1089          0,                     /* bitpos */
1090          complain_overflow_bitfield,/* complain_on_overflow */
1091          NULL,                  /* special_function */
1092          "R_ARM_TLS_GD32",      /* name */
1093          TRUE,                  /* partial_inplace */
1094          0xffffffff,            /* src_mask */
1095          0xffffffff,            /* dst_mask */
1096          FALSE),                /* pcrel_offset */
1097
1098   HOWTO (R_ARM_TLS_LDM32,       /* type */
1099          0,                     /* rightshift */
1100          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1101          32,                    /* bitsize */
1102          FALSE,                 /* pc_relative */
1103          0,                     /* bitpos */
1104          complain_overflow_bitfield,/* complain_on_overflow */
1105          bfd_elf_generic_reloc, /* special_function */
1106          "R_ARM_TLS_LDM32",     /* name */
1107          TRUE,                  /* partial_inplace */
1108          0xffffffff,            /* src_mask */
1109          0xffffffff,            /* dst_mask */
1110          FALSE),                /* pcrel_offset */
1111
1112   HOWTO (R_ARM_TLS_LDO32,       /* type */
1113          0,                     /* rightshift */
1114          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1115          32,                    /* bitsize */
1116          FALSE,                 /* pc_relative */
1117          0,                     /* bitpos */
1118          complain_overflow_bitfield,/* complain_on_overflow */
1119          bfd_elf_generic_reloc, /* special_function */
1120          "R_ARM_TLS_LDO32",     /* name */
1121          TRUE,                  /* partial_inplace */
1122          0xffffffff,            /* src_mask */
1123          0xffffffff,            /* dst_mask */
1124          FALSE),                /* pcrel_offset */
1125
1126   HOWTO (R_ARM_TLS_IE32,        /* type */
1127          0,                     /* rightshift */
1128          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1129          32,                    /* bitsize */
1130          FALSE,                  /* pc_relative */
1131          0,                     /* bitpos */
1132          complain_overflow_bitfield,/* complain_on_overflow */
1133          NULL,                  /* special_function */
1134          "R_ARM_TLS_IE32",      /* name */
1135          TRUE,                  /* partial_inplace */
1136          0xffffffff,            /* src_mask */
1137          0xffffffff,            /* dst_mask */
1138          FALSE),                /* pcrel_offset */
1139
1140   HOWTO (R_ARM_TLS_LE32,        /* type */
1141          0,                     /* rightshift */
1142          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1143          32,                    /* bitsize */
1144          FALSE,                 /* pc_relative */
1145          0,                     /* bitpos */
1146          complain_overflow_bitfield,/* complain_on_overflow */
1147          bfd_elf_generic_reloc, /* special_function */
1148          "R_ARM_TLS_LE32",      /* name */
1149          TRUE,                  /* partial_inplace */
1150          0xffffffff,            /* src_mask */
1151          0xffffffff,            /* dst_mask */
1152          FALSE),                /* pcrel_offset */
1153
1154   HOWTO (R_ARM_TLS_LDO12,       /* type */
1155          0,                     /* rightshift */
1156          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1157          12,                    /* bitsize */
1158          FALSE,                 /* pc_relative */
1159          0,                     /* bitpos */
1160          complain_overflow_bitfield,/* complain_on_overflow */
1161          bfd_elf_generic_reloc, /* special_function */
1162          "R_ARM_TLS_LDO12",     /* name */
1163          FALSE,                 /* partial_inplace */
1164          0x00000fff,            /* src_mask */
1165          0x00000fff,            /* dst_mask */
1166          FALSE),                /* pcrel_offset */
1167
1168   HOWTO (R_ARM_TLS_LE12,        /* type */
1169          0,                     /* rightshift */
1170          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1171          12,                    /* bitsize */
1172          FALSE,                 /* pc_relative */
1173          0,                     /* bitpos */
1174          complain_overflow_bitfield,/* complain_on_overflow */
1175          bfd_elf_generic_reloc, /* special_function */
1176          "R_ARM_TLS_LE12",      /* name */
1177          FALSE,                 /* partial_inplace */
1178          0x00000fff,            /* src_mask */
1179          0x00000fff,            /* dst_mask */
1180          FALSE),                /* pcrel_offset */
1181
1182   HOWTO (R_ARM_TLS_IE12GP,      /* type */
1183          0,                     /* rightshift */
1184          2,                     /* size (0 = byte, 1 = short, 2 = long) */
1185          12,                    /* bitsize */
1186          FALSE,                 /* pc_relative */
1187          0,                     /* bitpos */
1188          complain_overflow_bitfield,/* complain_on_overflow */
1189          bfd_elf_generic_reloc, /* special_function */
1190          "R_ARM_TLS_IE12GP",    /* name */
1191          FALSE,                 /* partial_inplace */
1192          0x00000fff,            /* src_mask */
1193          0x00000fff,            /* dst_mask */
1194          FALSE),                /* pcrel_offset */
1195 };
1196
1197 /* 112-127 private relocations
1198    128 R_ARM_ME_TOO, obsolete
1199    129-255 unallocated in AAELF.
1200
1201    249-255 extended, currently unused, relocations:  */
1202
1203 static reloc_howto_type elf32_arm_howto_table_3[4] =
1204 {
1205   HOWTO (R_ARM_RREL32,          /* type */
1206          0,                     /* rightshift */
1207          0,                     /* size (0 = byte, 1 = short, 2 = long) */
1208          0,                     /* bitsize */
1209          FALSE,                 /* pc_relative */
1210          0,                     /* bitpos */
1211          complain_overflow_dont,/* complain_on_overflow */
1212          bfd_elf_generic_reloc, /* special_function */
1213          "R_ARM_RREL32",        /* name */
1214          FALSE,                 /* partial_inplace */
1215          0,                     /* src_mask */
1216          0,                     /* dst_mask */
1217          FALSE),                /* pcrel_offset */
1218
1219   HOWTO (R_ARM_RABS32,          /* type */
1220          0,                     /* rightshift */
1221          0,                     /* size (0 = byte, 1 = short, 2 = long) */
1222          0,                     /* bitsize */
1223          FALSE,                 /* pc_relative */
1224          0,                     /* bitpos */
1225          complain_overflow_dont,/* complain_on_overflow */
1226          bfd_elf_generic_reloc, /* special_function */
1227          "R_ARM_RABS32",        /* name */
1228          FALSE,                 /* partial_inplace */
1229          0,                     /* src_mask */
1230          0,                     /* dst_mask */
1231          FALSE),                /* pcrel_offset */
1232
1233   HOWTO (R_ARM_RPC24,           /* type */
1234          0,                     /* rightshift */
1235          0,                     /* size (0 = byte, 1 = short, 2 = long) */
1236          0,                     /* bitsize */
1237          FALSE,                 /* pc_relative */
1238          0,                     /* bitpos */
1239          complain_overflow_dont,/* complain_on_overflow */
1240          bfd_elf_generic_reloc, /* special_function */
1241          "R_ARM_RPC24",         /* name */
1242          FALSE,                 /* partial_inplace */
1243          0,                     /* src_mask */
1244          0,                     /* dst_mask */
1245          FALSE),                /* pcrel_offset */
1246
1247   HOWTO (R_ARM_RBASE,           /* type */
1248          0,                     /* rightshift */
1249          0,                     /* size (0 = byte, 1 = short, 2 = long) */
1250          0,                     /* bitsize */
1251          FALSE,                 /* pc_relative */
1252          0,                     /* bitpos */
1253          complain_overflow_dont,/* complain_on_overflow */
1254          bfd_elf_generic_reloc, /* special_function */
1255          "R_ARM_RBASE",         /* name */
1256          FALSE,                 /* partial_inplace */
1257          0,                     /* src_mask */
1258          0,                     /* dst_mask */
1259          FALSE)                 /* pcrel_offset */
1260 };
1261
1262 static reloc_howto_type *
1263 elf32_arm_howto_from_type (unsigned int r_type)
1264 {
1265   if (r_type < NUM_ELEM (elf32_arm_howto_table_1))
1266     return &elf32_arm_howto_table_1[r_type];
1267
1268   if (r_type >= R_ARM_MOVW_BREL_NC
1269       && r_type < R_ARM_MOVW_BREL_NC + NUM_ELEM (elf32_arm_howto_table_2))
1270     return &elf32_arm_howto_table_2[r_type - R_ARM_MOVW_BREL_NC];
1271
1272   if (r_type >= R_ARM_RREL32
1273       && r_type < R_ARM_RREL32 + NUM_ELEM (elf32_arm_howto_table_2))
1274     return &elf32_arm_howto_table_3[r_type - R_ARM_RREL32];
1275
1276   return NULL;
1277 }
1278
1279 static void
1280 elf32_arm_info_to_howto (bfd * abfd ATTRIBUTE_UNUSED, arelent * bfd_reloc,
1281                          Elf_Internal_Rela * elf_reloc)
1282 {
1283   unsigned int r_type;
1284
1285   r_type = ELF32_R_TYPE (elf_reloc->r_info);
1286   bfd_reloc->howto = elf32_arm_howto_from_type (r_type);
1287 }
1288
1289 struct elf32_arm_reloc_map
1290   {
1291     bfd_reloc_code_real_type  bfd_reloc_val;
1292     unsigned char             elf_reloc_val;
1293   };
1294
1295 /* All entries in this list must also be present in elf32_arm_howto_table.  */
1296 static const struct elf32_arm_reloc_map elf32_arm_reloc_map[] =
1297   {
1298     {BFD_RELOC_NONE,                 R_ARM_NONE},
1299     {BFD_RELOC_ARM_PCREL_BRANCH,     R_ARM_PC24},
1300     {BFD_RELOC_ARM_PCREL_BLX,        R_ARM_XPC25},
1301     {BFD_RELOC_THUMB_PCREL_BLX,      R_ARM_THM_XPC22},
1302     {BFD_RELOC_32,                   R_ARM_ABS32},
1303     {BFD_RELOC_32_PCREL,             R_ARM_REL32},
1304     {BFD_RELOC_8,                    R_ARM_ABS8},
1305     {BFD_RELOC_16,                   R_ARM_ABS16},
1306     {BFD_RELOC_ARM_OFFSET_IMM,       R_ARM_ABS12},
1307     {BFD_RELOC_ARM_THUMB_OFFSET,     R_ARM_THM_ABS5},
1308     {BFD_RELOC_THUMB_PCREL_BRANCH25, R_ARM_THM_JUMP24},
1309     {BFD_RELOC_THUMB_PCREL_BRANCH23, R_ARM_THM_CALL},
1310     {BFD_RELOC_THUMB_PCREL_BRANCH12, R_ARM_THM_JUMP11},
1311     {BFD_RELOC_THUMB_PCREL_BRANCH20, R_ARM_THM_JUMP19},
1312     {BFD_RELOC_THUMB_PCREL_BRANCH9,  R_ARM_THM_JUMP8},
1313     {BFD_RELOC_THUMB_PCREL_BRANCH7,  R_ARM_THM_JUMP6},
1314     {BFD_RELOC_ARM_GLOB_DAT,         R_ARM_GLOB_DAT},
1315     {BFD_RELOC_ARM_JUMP_SLOT,        R_ARM_JUMP_SLOT},
1316     {BFD_RELOC_ARM_RELATIVE,         R_ARM_RELATIVE},
1317     {BFD_RELOC_ARM_GOTOFF,           R_ARM_GOTOFF32},
1318     {BFD_RELOC_ARM_GOTPC,            R_ARM_GOTPC},
1319     {BFD_RELOC_ARM_GOT32,            R_ARM_GOT32},
1320     {BFD_RELOC_ARM_PLT32,            R_ARM_PLT32},
1321     {BFD_RELOC_ARM_TARGET1,          R_ARM_TARGET1},
1322     {BFD_RELOC_ARM_ROSEGREL32,       R_ARM_ROSEGREL32},
1323     {BFD_RELOC_ARM_SBREL32,          R_ARM_SBREL32},
1324     {BFD_RELOC_ARM_PREL31,           R_ARM_PREL31},
1325     {BFD_RELOC_ARM_TARGET2,          R_ARM_TARGET2},
1326     {BFD_RELOC_ARM_PLT32,            R_ARM_PLT32},
1327     {BFD_RELOC_ARM_TLS_GD32,         R_ARM_TLS_GD32},
1328     {BFD_RELOC_ARM_TLS_LDO32,        R_ARM_TLS_LDO32},
1329     {BFD_RELOC_ARM_TLS_LDM32,        R_ARM_TLS_LDM32},
1330     {BFD_RELOC_ARM_TLS_DTPMOD32,     R_ARM_TLS_DTPMOD32},
1331     {BFD_RELOC_ARM_TLS_DTPOFF32,     R_ARM_TLS_DTPOFF32},
1332     {BFD_RELOC_ARM_TLS_TPOFF32,      R_ARM_TLS_TPOFF32},
1333     {BFD_RELOC_ARM_TLS_IE32,         R_ARM_TLS_IE32},
1334     {BFD_RELOC_ARM_TLS_LE32,         R_ARM_TLS_LE32},
1335     {BFD_RELOC_VTABLE_INHERIT,       R_ARM_GNU_VTINHERIT},
1336     {BFD_RELOC_VTABLE_ENTRY,         R_ARM_GNU_VTENTRY},
1337   };
1338
1339 static reloc_howto_type *
1340 elf32_arm_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1341                              bfd_reloc_code_real_type code)
1342 {
1343   unsigned int i;
1344   for (i = 0; i < NUM_ELEM (elf32_arm_reloc_map); i ++)
1345     if (elf32_arm_reloc_map[i].bfd_reloc_val == code)
1346       return elf32_arm_howto_from_type (elf32_arm_reloc_map[i].elf_reloc_val);
1347
1348   return NULL;
1349 }
1350
1351 /* Support for core dump NOTE sections */
1352 static bfd_boolean
1353 elf32_arm_nabi_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
1354 {
1355   int offset;
1356   size_t size;
1357
1358   switch (note->descsz)
1359     {
1360       default:
1361         return FALSE;
1362
1363       case 148:         /* Linux/ARM 32-bit*/
1364         /* pr_cursig */
1365         elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
1366
1367         /* pr_pid */
1368         elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
1369
1370         /* pr_reg */
1371         offset = 72;
1372         size = 72;
1373
1374         break;
1375     }
1376
1377   /* Make a ".reg/999" section.  */
1378   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
1379                                           size, note->descpos + offset);
1380 }
1381
1382 static bfd_boolean
1383 elf32_arm_nabi_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
1384 {
1385   switch (note->descsz)
1386     {
1387       default:
1388         return FALSE;
1389
1390       case 124:         /* Linux/ARM elf_prpsinfo */
1391         elf_tdata (abfd)->core_program
1392          = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
1393         elf_tdata (abfd)->core_command
1394          = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
1395     }
1396
1397   /* Note that for some reason, a spurious space is tacked
1398      onto the end of the args in some (at least one anyway)
1399      implementations, so strip it off if it exists.  */
1400
1401   {
1402     char *command = elf_tdata (abfd)->core_command;
1403     int n = strlen (command);
1404
1405     if (0 < n && command[n - 1] == ' ')
1406       command[n - 1] = '\0';
1407   }
1408
1409   return TRUE;
1410 }
1411
1412 #define TARGET_LITTLE_SYM               bfd_elf32_littlearm_vec
1413 #define TARGET_LITTLE_NAME              "elf32-littlearm"
1414 #define TARGET_BIG_SYM                  bfd_elf32_bigarm_vec
1415 #define TARGET_BIG_NAME                 "elf32-bigarm"
1416
1417 #define elf_backend_grok_prstatus       elf32_arm_nabi_grok_prstatus
1418 #define elf_backend_grok_psinfo         elf32_arm_nabi_grok_psinfo
1419
1420 typedef unsigned long int insn32;
1421 typedef unsigned short int insn16;
1422
1423 /* In lieu of proper flags, assume all EABIv4 objects are interworkable.  */
1424 #define INTERWORK_FLAG(abfd)  \
1425   (EF_ARM_EABI_VERSION (elf_elfheader (abfd)->e_flags) == EF_ARM_EABI_VER4 \
1426   || (elf_elfheader (abfd)->e_flags & EF_ARM_INTERWORK))
1427
1428 /* The linker script knows the section names for placement.
1429    The entry_names are used to do simple name mangling on the stubs.
1430    Given a function name, and its type, the stub can be found. The
1431    name can be changed. The only requirement is the %s be present.  */
1432 #define THUMB2ARM_GLUE_SECTION_NAME ".glue_7t"
1433 #define THUMB2ARM_GLUE_ENTRY_NAME   "__%s_from_thumb"
1434
1435 #define ARM2THUMB_GLUE_SECTION_NAME ".glue_7"
1436 #define ARM2THUMB_GLUE_ENTRY_NAME   "__%s_from_arm"
1437
1438 /* The name of the dynamic interpreter.  This is put in the .interp
1439    section.  */
1440 #define ELF_DYNAMIC_INTERPRETER     "/usr/lib/ld.so.1"
1441
1442 #ifdef FOUR_WORD_PLT
1443
1444 /* The first entry in a procedure linkage table looks like
1445    this.  It is set up so that any shared library function that is
1446    called before the relocation has been set up calls the dynamic
1447    linker first.  */
1448 static const bfd_vma elf32_arm_plt0_entry [] =
1449   {
1450     0xe52de004,         /* str   lr, [sp, #-4]! */
1451     0xe59fe010,         /* ldr   lr, [pc, #16]  */
1452     0xe08fe00e,         /* add   lr, pc, lr     */
1453     0xe5bef008,         /* ldr   pc, [lr, #8]!  */
1454   };
1455
1456 /* Subsequent entries in a procedure linkage table look like
1457    this.  */
1458 static const bfd_vma elf32_arm_plt_entry [] =
1459   {
1460     0xe28fc600,         /* add   ip, pc, #NN    */
1461     0xe28cca00,         /* add   ip, ip, #NN    */
1462     0xe5bcf000,         /* ldr   pc, [ip, #NN]! */
1463     0x00000000,         /* unused               */
1464   };
1465
1466 #else
1467
1468 /* The first entry in a procedure linkage table looks like
1469    this.  It is set up so that any shared library function that is
1470    called before the relocation has been set up calls the dynamic
1471    linker first.  */
1472 static const bfd_vma elf32_arm_plt0_entry [] =
1473   {
1474     0xe52de004,         /* str   lr, [sp, #-4]! */
1475     0xe59fe004,         /* ldr   lr, [pc, #4]   */
1476     0xe08fe00e,         /* add   lr, pc, lr     */
1477     0xe5bef008,         /* ldr   pc, [lr, #8]!  */
1478     0x00000000,         /* &GOT[0] - .          */
1479   };
1480
1481 /* Subsequent entries in a procedure linkage table look like
1482    this.  */
1483 static const bfd_vma elf32_arm_plt_entry [] =
1484   {
1485     0xe28fc600,         /* add   ip, pc, #0xNN00000 */
1486     0xe28cca00,         /* add   ip, ip, #0xNN000   */
1487     0xe5bcf000,         /* ldr   pc, [ip, #0xNNN]!  */
1488   };
1489
1490 #endif
1491
1492 /* An initial stub used if the PLT entry is referenced from Thumb code.  */
1493 #define PLT_THUMB_STUB_SIZE 4
1494 static const bfd_vma elf32_arm_plt_thumb_stub [] =
1495   {
1496     0x4778,             /* bx pc */
1497     0x46c0              /* nop   */
1498   };
1499
1500 /* The entries in a PLT when using a DLL-based target with multiple
1501    address spaces.  */
1502 static const bfd_vma elf32_arm_symbian_plt_entry [] =
1503   {
1504     0xe51ff004,         /* ldr   pc, [pc, #-4] */
1505     0x00000000,         /* dcd   R_ARM_GLOB_DAT(X) */
1506   };
1507
1508 /* Used to build a map of a section.  This is required for mixed-endian
1509    code/data.  */
1510
1511 typedef struct elf32_elf_section_map
1512 {
1513   bfd_vma vma;
1514   char type;
1515 }
1516 elf32_arm_section_map;
1517
1518 struct _arm_elf_section_data
1519 {
1520   struct bfd_elf_section_data elf;
1521   int mapcount;
1522   elf32_arm_section_map *map;
1523 };
1524
1525 #define elf32_arm_section_data(sec) \
1526   ((struct _arm_elf_section_data *) elf_section_data (sec))
1527
1528 /* The size of the thread control block.  */
1529 #define TCB_SIZE        8
1530
1531 struct elf32_arm_obj_tdata
1532 {
1533   struct elf_obj_tdata root;
1534
1535   /* tls_type for each local got entry.  */
1536   char *local_got_tls_type;
1537 };
1538
1539 #define elf32_arm_tdata(abfd) \
1540   ((struct elf32_arm_obj_tdata *) (abfd)->tdata.any)
1541
1542 #define elf32_arm_local_got_tls_type(abfd) \
1543   (elf32_arm_tdata (abfd)->local_got_tls_type)
1544
1545 static bfd_boolean
1546 elf32_arm_mkobject (bfd *abfd)
1547 {
1548   bfd_size_type amt = sizeof (struct elf32_arm_obj_tdata);
1549   abfd->tdata.any = bfd_zalloc (abfd, amt);
1550   if (abfd->tdata.any == NULL)
1551     return FALSE;
1552   return TRUE;
1553 }
1554
1555 /* The ARM linker needs to keep track of the number of relocs that it
1556    decides to copy in check_relocs for each symbol.  This is so that
1557    it can discard PC relative relocs if it doesn't need them when
1558    linking with -Bsymbolic.  We store the information in a field
1559    extending the regular ELF linker hash table.  */
1560
1561 /* This structure keeps track of the number of relocs we have copied
1562    for a given symbol.  */
1563 struct elf32_arm_relocs_copied
1564   {
1565     /* Next section.  */
1566     struct elf32_arm_relocs_copied * next;
1567     /* A section in dynobj.  */
1568     asection * section;
1569     /* Number of relocs copied in this section.  */
1570     bfd_size_type count;
1571     /* Number of PC-relative relocs copied in this section.  */
1572     bfd_size_type pc_count;
1573   };
1574
1575 #define elf32_arm_hash_entry(ent) ((struct elf32_arm_link_hash_entry *)(ent))
1576
1577 /* Arm ELF linker hash entry.  */
1578 struct elf32_arm_link_hash_entry
1579   {
1580     struct elf_link_hash_entry root;
1581
1582     /* Number of PC relative relocs copied for this symbol.  */
1583     struct elf32_arm_relocs_copied * relocs_copied;
1584
1585     /* We reference count Thumb references to a PLT entry separately,
1586        so that we can emit the Thumb trampoline only if needed.  */
1587     bfd_signed_vma plt_thumb_refcount;
1588
1589     /* Since PLT entries have variable size if the Thumb prologue is
1590        used, we need to record the index into .got.plt instead of
1591        recomputing it from the PLT offset.  */
1592     bfd_signed_vma plt_got_offset;
1593
1594 #define GOT_UNKNOWN     0
1595 #define GOT_NORMAL      1
1596 #define GOT_TLS_GD      2
1597 #define GOT_TLS_IE      4
1598     unsigned char tls_type;
1599   };
1600
1601 /* Traverse an arm ELF linker hash table.  */
1602 #define elf32_arm_link_hash_traverse(table, func, info)                 \
1603   (elf_link_hash_traverse                                               \
1604    (&(table)->root,                                                     \
1605     (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func),    \
1606     (info)))
1607
1608 /* Get the ARM elf linker hash table from a link_info structure.  */
1609 #define elf32_arm_hash_table(info) \
1610   ((struct elf32_arm_link_hash_table *) ((info)->hash))
1611
1612 /* ARM ELF linker hash table.  */
1613 struct elf32_arm_link_hash_table
1614   {
1615     /* The main hash table.  */
1616     struct elf_link_hash_table root;
1617
1618     /* The size in bytes of the section containing the Thumb-to-ARM glue.  */
1619     bfd_size_type thumb_glue_size;
1620
1621     /* The size in bytes of the section containing the ARM-to-Thumb glue.  */
1622     bfd_size_type arm_glue_size;
1623
1624     /* An arbitrary input BFD chosen to hold the glue sections.  */
1625     bfd * bfd_of_glue_owner;
1626
1627     /* Nonzero to output a BE8 image.  */
1628     int byteswap_code;
1629
1630     /* Zero if R_ARM_TARGET1 means R_ARM_ABS32.
1631        Nonzero if R_ARM_TARGET1 means R_ARM_ABS32.  */
1632     int target1_is_rel;
1633
1634     /* The relocation to use for R_ARM_TARGET2 relocations.  */
1635     int target2_reloc;
1636
1637     /* Nonzero to fix BX instructions for ARMv4 targets.  */
1638     int fix_v4bx;
1639
1640     /* Nonzero if the ARM/Thumb BLX instructions are available for use.  */
1641     int use_blx;
1642
1643     /* The number of bytes in the initial entry in the PLT.  */
1644     bfd_size_type plt_header_size;
1645
1646     /* The number of bytes in the subsequent PLT etries.  */
1647     bfd_size_type plt_entry_size;
1648
1649     /* True if the target system is Symbian OS.  */
1650     int symbian_p;
1651
1652     /* True if the target uses REL relocations.  */
1653     int use_rel;
1654
1655     /* Short-cuts to get to dynamic linker sections.  */
1656     asection *sgot;
1657     asection *sgotplt;
1658     asection *srelgot;
1659     asection *splt;
1660     asection *srelplt;
1661     asection *sdynbss;
1662     asection *srelbss;
1663
1664     /* Data for R_ARM_TLS_LDM32 relocations.  */
1665     union {
1666       bfd_signed_vma refcount;
1667       bfd_vma offset;
1668     } tls_ldm_got;
1669
1670     /* Small local sym to section mapping cache.  */
1671     struct sym_sec_cache sym_sec;
1672
1673     /* For convenience in allocate_dynrelocs.  */
1674     bfd * obfd;
1675   };
1676
1677 /* Create an entry in an ARM ELF linker hash table.  */
1678
1679 static struct bfd_hash_entry *
1680 elf32_arm_link_hash_newfunc (struct bfd_hash_entry * entry,
1681                              struct bfd_hash_table * table,
1682                              const char * string)
1683 {
1684   struct elf32_arm_link_hash_entry * ret =
1685     (struct elf32_arm_link_hash_entry *) entry;
1686
1687   /* Allocate the structure if it has not already been allocated by a
1688      subclass.  */
1689   if (ret == (struct elf32_arm_link_hash_entry *) NULL)
1690     ret = bfd_hash_allocate (table, sizeof (struct elf32_arm_link_hash_entry));
1691   if (ret == NULL)
1692     return (struct bfd_hash_entry *) ret;
1693
1694   /* Call the allocation method of the superclass.  */
1695   ret = ((struct elf32_arm_link_hash_entry *)
1696          _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
1697                                      table, string));
1698   if (ret != NULL)
1699     {
1700       ret->relocs_copied = NULL;
1701       ret->tls_type = GOT_UNKNOWN;
1702       ret->plt_thumb_refcount = 0;
1703       ret->plt_got_offset = -1;
1704     }
1705
1706   return (struct bfd_hash_entry *) ret;
1707 }
1708
1709 /* Create .got, .gotplt, and .rel.got sections in DYNOBJ, and set up
1710    shortcuts to them in our hash table.  */
1711
1712 static bfd_boolean
1713 create_got_section (bfd *dynobj, struct bfd_link_info *info)
1714 {
1715   struct elf32_arm_link_hash_table *htab;
1716
1717   htab = elf32_arm_hash_table (info);
1718   /* BPABI objects never have a GOT, or associated sections.  */
1719   if (htab->symbian_p)
1720     return TRUE;
1721
1722   if (! _bfd_elf_create_got_section (dynobj, info))
1723     return FALSE;
1724
1725   htab->sgot = bfd_get_section_by_name (dynobj, ".got");
1726   htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
1727   if (!htab->sgot || !htab->sgotplt)
1728     abort ();
1729
1730   htab->srelgot = bfd_make_section_with_flags (dynobj, ".rel.got",
1731                                                (SEC_ALLOC | SEC_LOAD
1732                                                 | SEC_HAS_CONTENTS
1733                                                 | SEC_IN_MEMORY
1734                                                 | SEC_LINKER_CREATED
1735                                                 | SEC_READONLY));
1736   if (htab->srelgot == NULL
1737       || ! bfd_set_section_alignment (dynobj, htab->srelgot, 2))
1738     return FALSE;
1739   return TRUE;
1740 }
1741
1742 /* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
1743    .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
1744    hash table.  */
1745
1746 static bfd_boolean
1747 elf32_arm_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
1748 {
1749   struct elf32_arm_link_hash_table *htab;
1750
1751   htab = elf32_arm_hash_table (info);
1752   if (!htab->sgot && !create_got_section (dynobj, info))
1753     return FALSE;
1754
1755   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
1756     return FALSE;
1757
1758   htab->splt = bfd_get_section_by_name (dynobj, ".plt");
1759   htab->srelplt = bfd_get_section_by_name (dynobj, ".rel.plt");
1760   htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
1761   if (!info->shared)
1762     htab->srelbss = bfd_get_section_by_name (dynobj, ".rel.bss");
1763
1764   if (!htab->splt
1765       || !htab->srelplt
1766       || !htab->sdynbss
1767       || (!info->shared && !htab->srelbss))
1768     abort ();
1769
1770   return TRUE;
1771 }
1772
1773 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
1774
1775 static void
1776 elf32_arm_copy_indirect_symbol (const struct elf_backend_data *bed,
1777                                 struct elf_link_hash_entry *dir,
1778                                 struct elf_link_hash_entry *ind)
1779 {
1780   struct elf32_arm_link_hash_entry *edir, *eind;
1781
1782   edir = (struct elf32_arm_link_hash_entry *) dir;
1783   eind = (struct elf32_arm_link_hash_entry *) ind;
1784
1785   if (eind->relocs_copied != NULL)
1786     {
1787       if (edir->relocs_copied != NULL)
1788         {
1789           struct elf32_arm_relocs_copied **pp;
1790           struct elf32_arm_relocs_copied *p;
1791
1792           if (ind->root.type == bfd_link_hash_indirect)
1793             abort ();
1794
1795           /* Add reloc counts against the weak sym to the strong sym
1796              list.  Merge any entries against the same section.  */
1797           for (pp = &eind->relocs_copied; (p = *pp) != NULL; )
1798             {
1799               struct elf32_arm_relocs_copied *q;
1800
1801               for (q = edir->relocs_copied; q != NULL; q = q->next)
1802                 if (q->section == p->section)
1803                   {
1804                     q->pc_count += p->pc_count;
1805                     q->count += p->count;
1806                     *pp = p->next;
1807                     break;
1808                   }
1809               if (q == NULL)
1810                 pp = &p->next;
1811             }
1812           *pp = edir->relocs_copied;
1813         }
1814
1815       edir->relocs_copied = eind->relocs_copied;
1816       eind->relocs_copied = NULL;
1817     }
1818
1819   /* If the direct symbol already has an associated PLT entry, the
1820      indirect symbol should not.  If it doesn't, swap refcount information
1821      from the indirect symbol.  */
1822   if (edir->plt_thumb_refcount == 0)
1823     {
1824       edir->plt_thumb_refcount = eind->plt_thumb_refcount;
1825       eind->plt_thumb_refcount = 0;
1826     }
1827   else
1828     BFD_ASSERT (eind->plt_thumb_refcount == 0);
1829
1830   if (ind->root.type == bfd_link_hash_indirect
1831       && dir->got.refcount <= 0)
1832     {
1833       edir->tls_type = eind->tls_type;
1834       eind->tls_type = GOT_UNKNOWN;
1835     }
1836
1837   _bfd_elf_link_hash_copy_indirect (bed, dir, ind);
1838 }
1839
1840 /* Create an ARM elf linker hash table.  */
1841
1842 static struct bfd_link_hash_table *
1843 elf32_arm_link_hash_table_create (bfd *abfd)
1844 {
1845   struct elf32_arm_link_hash_table *ret;
1846   bfd_size_type amt = sizeof (struct elf32_arm_link_hash_table);
1847
1848   ret = bfd_malloc (amt);
1849   if (ret == NULL)
1850     return NULL;
1851
1852   if (!_bfd_elf_link_hash_table_init (& ret->root, abfd,
1853                                       elf32_arm_link_hash_newfunc))
1854     {
1855       free (ret);
1856       return NULL;
1857     }
1858
1859   ret->sgot = NULL;
1860   ret->sgotplt = NULL;
1861   ret->srelgot = NULL;
1862   ret->splt = NULL;
1863   ret->srelplt = NULL;
1864   ret->sdynbss = NULL;
1865   ret->srelbss = NULL;
1866   ret->thumb_glue_size = 0;
1867   ret->arm_glue_size = 0;
1868   ret->bfd_of_glue_owner = NULL;
1869   ret->byteswap_code = 0;
1870   ret->target1_is_rel = 0;
1871   ret->target2_reloc = R_ARM_NONE;
1872 #ifdef FOUR_WORD_PLT
1873   ret->plt_header_size = 16;
1874   ret->plt_entry_size = 16;
1875 #else
1876   ret->plt_header_size = 20;
1877   ret->plt_entry_size = 12;
1878 #endif
1879   ret->fix_v4bx = 0;
1880   ret->use_blx = 0;
1881   ret->symbian_p = 0;
1882   ret->use_rel = 1;
1883   ret->sym_sec.abfd = NULL;
1884   ret->obfd = abfd;
1885   ret->tls_ldm_got.refcount = 0;
1886
1887   return &ret->root.root;
1888 }
1889
1890 /* Locate the Thumb encoded calling stub for NAME.  */
1891
1892 static struct elf_link_hash_entry *
1893 find_thumb_glue (struct bfd_link_info *link_info,
1894                  const char *name,
1895                  bfd *input_bfd)
1896 {
1897   char *tmp_name;
1898   struct elf_link_hash_entry *hash;
1899   struct elf32_arm_link_hash_table *hash_table;
1900
1901   /* We need a pointer to the armelf specific hash table.  */
1902   hash_table = elf32_arm_hash_table (link_info);
1903
1904   tmp_name = bfd_malloc ((bfd_size_type) strlen (name)
1905                          + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1);
1906
1907   BFD_ASSERT (tmp_name);
1908
1909   sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name);
1910
1911   hash = elf_link_hash_lookup
1912     (&(hash_table)->root, tmp_name, FALSE, FALSE, TRUE);
1913
1914   if (hash == NULL)
1915     /* xgettext:c-format */
1916     (*_bfd_error_handler) (_("%B: unable to find THUMB glue '%s' for `%s'"),
1917                            input_bfd, tmp_name, name);
1918
1919   free (tmp_name);
1920
1921   return hash;
1922 }
1923
1924 /* Locate the ARM encoded calling stub for NAME.  */
1925
1926 static struct elf_link_hash_entry *
1927 find_arm_glue (struct bfd_link_info *link_info,
1928                const char *name,
1929                bfd *input_bfd)
1930 {
1931   char *tmp_name;
1932   struct elf_link_hash_entry *myh;
1933   struct elf32_arm_link_hash_table *hash_table;
1934
1935   /* We need a pointer to the elfarm specific hash table.  */
1936   hash_table = elf32_arm_hash_table (link_info);
1937
1938   tmp_name = bfd_malloc ((bfd_size_type) strlen (name)
1939                          + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1);
1940
1941   BFD_ASSERT (tmp_name);
1942
1943   sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
1944
1945   myh = elf_link_hash_lookup
1946     (&(hash_table)->root, tmp_name, FALSE, FALSE, TRUE);
1947
1948   if (myh == NULL)
1949     /* xgettext:c-format */
1950     (*_bfd_error_handler) (_("%B: unable to find ARM glue '%s' for `%s'"),
1951                            input_bfd, tmp_name, name);
1952
1953   free (tmp_name);
1954
1955   return myh;
1956 }
1957
1958 /* ARM->Thumb glue (static images):
1959
1960    .arm
1961    __func_from_arm:
1962    ldr r12, __func_addr
1963    bx  r12
1964    __func_addr:
1965    .word func    @ behave as if you saw a ARM_32 reloc.
1966
1967    (relocatable images)
1968    .arm
1969    __func_from_arm:
1970    ldr r12, __func_offset
1971    add r12, r12, pc
1972    bx  r12
1973    __func_offset:
1974    .word func - .
1975    */
1976
1977 #define ARM2THUMB_STATIC_GLUE_SIZE 12
1978 static const insn32 a2t1_ldr_insn = 0xe59fc000;
1979 static const insn32 a2t2_bx_r12_insn = 0xe12fff1c;
1980 static const insn32 a2t3_func_addr_insn = 0x00000001;
1981
1982 #define ARM2THUMB_PIC_GLUE_SIZE 16
1983 static const insn32 a2t1p_ldr_insn = 0xe59fc004;
1984 static const insn32 a2t2p_add_pc_insn = 0xe08cc00f;
1985 static const insn32 a2t3p_bx_r12_insn = 0xe12fff1c;
1986
1987 /* Thumb->ARM:                          Thumb->(non-interworking aware) ARM
1988
1989    .thumb                               .thumb
1990    .align 2                             .align 2
1991    __func_from_thumb:              __func_from_thumb:
1992    bx pc                                push {r6, lr}
1993    nop                                  ldr  r6, __func_addr
1994    .arm                                         mov  lr, pc
1995    __func_change_to_arm:                        bx   r6
1996    b func                       .arm
1997    __func_back_to_thumb:
1998    ldmia r13! {r6, lr}
1999    bx    lr
2000    __func_addr:
2001    .word        func  */
2002
2003 #define THUMB2ARM_GLUE_SIZE 8
2004 static const insn16 t2a1_bx_pc_insn = 0x4778;
2005 static const insn16 t2a2_noop_insn = 0x46c0;
2006 static const insn32 t2a3_b_insn = 0xea000000;
2007
2008 #ifndef ELFARM_NABI_C_INCLUDED
2009 bfd_boolean
2010 bfd_elf32_arm_allocate_interworking_sections (struct bfd_link_info * info)
2011 {
2012   asection * s;
2013   bfd_byte * foo;
2014   struct elf32_arm_link_hash_table * globals;
2015
2016   globals = elf32_arm_hash_table (info);
2017
2018   BFD_ASSERT (globals != NULL);
2019
2020   if (globals->arm_glue_size != 0)
2021     {
2022       BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
2023
2024       s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
2025                                    ARM2THUMB_GLUE_SECTION_NAME);
2026
2027       BFD_ASSERT (s != NULL);
2028
2029       foo = bfd_alloc (globals->bfd_of_glue_owner, globals->arm_glue_size);
2030
2031       s->size = globals->arm_glue_size;
2032       s->contents = foo;
2033     }
2034
2035   if (globals->thumb_glue_size != 0)
2036     {
2037       BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
2038
2039       s = bfd_get_section_by_name
2040         (globals->bfd_of_glue_owner, THUMB2ARM_GLUE_SECTION_NAME);
2041
2042       BFD_ASSERT (s != NULL);
2043
2044       foo = bfd_alloc (globals->bfd_of_glue_owner, globals->thumb_glue_size);
2045
2046       s->size = globals->thumb_glue_size;
2047       s->contents = foo;
2048     }
2049
2050   return TRUE;
2051 }
2052
2053 static void
2054 record_arm_to_thumb_glue (struct bfd_link_info * link_info,
2055                           struct elf_link_hash_entry * h)
2056 {
2057   const char * name = h->root.root.string;
2058   asection * s;
2059   char * tmp_name;
2060   struct elf_link_hash_entry * myh;
2061   struct bfd_link_hash_entry * bh;
2062   struct elf32_arm_link_hash_table * globals;
2063   bfd_vma val;
2064
2065   globals = elf32_arm_hash_table (link_info);
2066
2067   BFD_ASSERT (globals != NULL);
2068   BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
2069
2070   s = bfd_get_section_by_name
2071     (globals->bfd_of_glue_owner, ARM2THUMB_GLUE_SECTION_NAME);
2072
2073   BFD_ASSERT (s != NULL);
2074
2075   tmp_name = bfd_malloc ((bfd_size_type) strlen (name) + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1);
2076
2077   BFD_ASSERT (tmp_name);
2078
2079   sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
2080
2081   myh = elf_link_hash_lookup
2082     (&(globals)->root, tmp_name, FALSE, FALSE, TRUE);
2083
2084   if (myh != NULL)
2085     {
2086       /* We've already seen this guy.  */
2087       free (tmp_name);
2088       return;
2089     }
2090
2091   /* The only trick here is using hash_table->arm_glue_size as the value.
2092      Even though the section isn't allocated yet, this is where we will be
2093      putting it.  */
2094   bh = NULL;
2095   val = globals->arm_glue_size + 1;
2096   _bfd_generic_link_add_one_symbol (link_info, globals->bfd_of_glue_owner,
2097                                     tmp_name, BSF_GLOBAL, s, val,
2098                                     NULL, TRUE, FALSE, &bh);
2099
2100   myh = (struct elf_link_hash_entry *) bh;
2101   myh->type = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
2102   myh->forced_local = 1;
2103
2104   free (tmp_name);
2105
2106   if ((link_info->shared || globals->root.is_relocatable_executable))
2107     globals->arm_glue_size += ARM2THUMB_PIC_GLUE_SIZE;
2108   else
2109     globals->arm_glue_size += ARM2THUMB_STATIC_GLUE_SIZE;
2110
2111   return;
2112 }
2113
2114 static void
2115 record_thumb_to_arm_glue (struct bfd_link_info *link_info,
2116                           struct elf_link_hash_entry *h)
2117 {
2118   const char *name = h->root.root.string;
2119   asection *s;
2120   char *tmp_name;
2121   struct elf_link_hash_entry *myh;
2122   struct bfd_link_hash_entry *bh;
2123   struct elf32_arm_link_hash_table *hash_table;
2124   bfd_vma val;
2125
2126   hash_table = elf32_arm_hash_table (link_info);
2127
2128   BFD_ASSERT (hash_table != NULL);
2129   BFD_ASSERT (hash_table->bfd_of_glue_owner != NULL);
2130
2131   s = bfd_get_section_by_name
2132     (hash_table->bfd_of_glue_owner, THUMB2ARM_GLUE_SECTION_NAME);
2133
2134   BFD_ASSERT (s != NULL);
2135
2136   tmp_name = bfd_malloc ((bfd_size_type) strlen (name)
2137                          + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1);
2138
2139   BFD_ASSERT (tmp_name);
2140
2141   sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name);
2142
2143   myh = elf_link_hash_lookup
2144     (&(hash_table)->root, tmp_name, FALSE, FALSE, TRUE);
2145
2146   if (myh != NULL)
2147     {
2148       /* We've already seen this guy.  */
2149       free (tmp_name);
2150       return;
2151     }
2152
2153   bh = NULL;
2154   val = hash_table->thumb_glue_size + 1;
2155   _bfd_generic_link_add_one_symbol (link_info, hash_table->bfd_of_glue_owner,
2156                                     tmp_name, BSF_GLOBAL, s, val,
2157                                     NULL, TRUE, FALSE, &bh);
2158
2159   /* If we mark it 'Thumb', the disassembler will do a better job.  */
2160   myh = (struct elf_link_hash_entry *) bh;
2161   myh->type = ELF_ST_INFO (STB_LOCAL, STT_ARM_TFUNC);
2162   myh->forced_local = 1;
2163
2164   free (tmp_name);
2165
2166 #define CHANGE_TO_ARM "__%s_change_to_arm"
2167 #define BACK_FROM_ARM "__%s_back_from_arm"
2168
2169   /* Allocate another symbol to mark where we switch to Arm mode.  */
2170   tmp_name = bfd_malloc ((bfd_size_type) strlen (name)
2171                          + strlen (CHANGE_TO_ARM) + 1);
2172
2173   BFD_ASSERT (tmp_name);
2174
2175   sprintf (tmp_name, CHANGE_TO_ARM, name);
2176
2177   bh = NULL;
2178   val = hash_table->thumb_glue_size + 4,
2179   _bfd_generic_link_add_one_symbol (link_info, hash_table->bfd_of_glue_owner,
2180                                     tmp_name, BSF_LOCAL, s, val,
2181                                     NULL, TRUE, FALSE, &bh);
2182
2183   free (tmp_name);
2184
2185   hash_table->thumb_glue_size += THUMB2ARM_GLUE_SIZE;
2186
2187   return;
2188 }
2189
2190 /* Add the glue sections to ABFD.  This function is called from the
2191    linker scripts in ld/emultempl/{armelf}.em.  */
2192
2193 bfd_boolean
2194 bfd_elf32_arm_add_glue_sections_to_bfd (bfd *abfd,
2195                                         struct bfd_link_info *info)
2196 {
2197   flagword flags;
2198   asection *sec;
2199
2200   /* If we are only performing a partial
2201      link do not bother adding the glue.  */
2202   if (info->relocatable)
2203     return TRUE;
2204
2205   sec = bfd_get_section_by_name (abfd, ARM2THUMB_GLUE_SECTION_NAME);
2206
2207   if (sec == NULL)
2208     {
2209       /* Note: we do not include the flag SEC_LINKER_CREATED, as this
2210          will prevent elf_link_input_bfd() from processing the contents
2211          of this section.  */
2212       flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_CODE | SEC_READONLY;
2213
2214       sec = bfd_make_section_with_flags (abfd,
2215                                          ARM2THUMB_GLUE_SECTION_NAME,
2216                                          flags);
2217
2218       if (sec == NULL
2219           || !bfd_set_section_alignment (abfd, sec, 2))
2220         return FALSE;
2221
2222       /* Set the gc mark to prevent the section from being removed by garbage
2223          collection, despite the fact that no relocs refer to this section.  */
2224       sec->gc_mark = 1;
2225     }
2226
2227   sec = bfd_get_section_by_name (abfd, THUMB2ARM_GLUE_SECTION_NAME);
2228
2229   if (sec == NULL)
2230     {
2231       flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
2232         | SEC_CODE | SEC_READONLY;
2233
2234       sec = bfd_make_section_with_flags (abfd,
2235                                          THUMB2ARM_GLUE_SECTION_NAME,
2236                                          flags);
2237
2238       if (sec == NULL
2239           || !bfd_set_section_alignment (abfd, sec, 2))
2240         return FALSE;
2241
2242       sec->gc_mark = 1;
2243     }
2244
2245   return TRUE;
2246 }
2247
2248 /* Select a BFD to be used to hold the sections used by the glue code.
2249    This function is called from the linker scripts in ld/emultempl/
2250    {armelf/pe}.em  */
2251
2252 bfd_boolean
2253 bfd_elf32_arm_get_bfd_for_interworking (bfd *abfd, struct bfd_link_info *info)
2254 {
2255   struct elf32_arm_link_hash_table *globals;
2256
2257   /* If we are only performing a partial link
2258      do not bother getting a bfd to hold the glue.  */
2259   if (info->relocatable)
2260     return TRUE;
2261
2262   /* Make sure we don't attach the glue sections to a dynamic object.  */
2263   BFD_ASSERT (!(abfd->flags & DYNAMIC));
2264
2265   globals = elf32_arm_hash_table (info);
2266
2267   BFD_ASSERT (globals != NULL);
2268
2269   if (globals->bfd_of_glue_owner != NULL)
2270     return TRUE;
2271
2272   /* Save the bfd for later use.  */
2273   globals->bfd_of_glue_owner = abfd;
2274
2275   return TRUE;
2276 }
2277
2278 bfd_boolean
2279 bfd_elf32_arm_process_before_allocation (bfd *abfd,
2280                                          struct bfd_link_info *link_info,
2281                                          int byteswap_code)
2282 {
2283   Elf_Internal_Shdr *symtab_hdr;
2284   Elf_Internal_Rela *internal_relocs = NULL;
2285   Elf_Internal_Rela *irel, *irelend;
2286   bfd_byte *contents = NULL;
2287
2288   asection *sec;
2289   struct elf32_arm_link_hash_table *globals;
2290
2291   /* If we are only performing a partial link do not bother
2292      to construct any glue.  */
2293   if (link_info->relocatable)
2294     return TRUE;
2295
2296   /* Here we have a bfd that is to be included on the link.  We have a hook
2297      to do reloc rummaging, before section sizes are nailed down.  */
2298   globals = elf32_arm_hash_table (link_info);
2299
2300   BFD_ASSERT (globals != NULL);
2301   BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
2302
2303   if (byteswap_code && !bfd_big_endian (abfd))
2304     {
2305       _bfd_error_handler (_("%B: BE8 images only valid in big-endian mode."),
2306                           abfd);
2307       return FALSE;
2308     }
2309   globals->byteswap_code = byteswap_code;
2310
2311   /* Rummage around all the relocs and map the glue vectors.  */
2312   sec = abfd->sections;
2313
2314   if (sec == NULL)
2315     return TRUE;
2316
2317   for (; sec != NULL; sec = sec->next)
2318     {
2319       if (sec->reloc_count == 0)
2320         continue;
2321
2322       symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2323
2324       /* Load the relocs.  */
2325       internal_relocs
2326         = _bfd_elf_link_read_relocs (abfd, sec, (void *) NULL,
2327                                      (Elf_Internal_Rela *) NULL, FALSE);
2328
2329       if (internal_relocs == NULL)
2330         goto error_return;
2331
2332       irelend = internal_relocs + sec->reloc_count;
2333       for (irel = internal_relocs; irel < irelend; irel++)
2334         {
2335           long r_type;
2336           unsigned long r_index;
2337
2338           struct elf_link_hash_entry *h;
2339
2340           r_type = ELF32_R_TYPE (irel->r_info);
2341           r_index = ELF32_R_SYM (irel->r_info);
2342
2343           /* These are the only relocation types we care about.  */
2344           if (   r_type != R_ARM_PC24
2345               && r_type != R_ARM_PLT32
2346               && r_type != R_ARM_CALL
2347               && r_type != R_ARM_JUMP24
2348               && r_type != R_ARM_THM_CALL)
2349             continue;
2350
2351           /* Get the section contents if we haven't done so already.  */
2352           if (contents == NULL)
2353             {
2354               /* Get cached copy if it exists.  */
2355               if (elf_section_data (sec)->this_hdr.contents != NULL)
2356                 contents = elf_section_data (sec)->this_hdr.contents;
2357               else
2358                 {
2359                   /* Go get them off disk.  */
2360                   if (! bfd_malloc_and_get_section (abfd, sec, &contents))
2361                     goto error_return;
2362                 }
2363             }
2364
2365           /* If the relocation is not against a symbol it cannot concern us.  */
2366           h = NULL;
2367
2368           /* We don't care about local symbols.  */
2369           if (r_index < symtab_hdr->sh_info)
2370             continue;
2371
2372           /* This is an external symbol.  */
2373           r_index -= symtab_hdr->sh_info;
2374           h = (struct elf_link_hash_entry *)
2375             elf_sym_hashes (abfd)[r_index];
2376
2377           /* If the relocation is against a static symbol it must be within
2378              the current section and so cannot be a cross ARM/Thumb relocation.  */
2379           if (h == NULL)
2380             continue;
2381
2382           /* If the call will go through a PLT entry then we do not need
2383              glue.  */
2384           if (globals->splt != NULL && h->plt.offset != (bfd_vma) -1)
2385             continue;
2386
2387           switch (r_type)
2388             {
2389             case R_ARM_PC24:
2390             case R_ARM_PLT32:
2391             case R_ARM_CALL:
2392             case R_ARM_JUMP24:
2393               /* This one is a call from arm code.  We need to look up
2394                  the target of the call.  If it is a thumb target, we
2395                  insert glue.  */
2396               if (ELF_ST_TYPE(h->type) == STT_ARM_TFUNC)
2397                 record_arm_to_thumb_glue (link_info, h);
2398               break;
2399
2400             case R_ARM_THM_CALL:
2401               /* This one is a call from thumb code.  We look
2402                  up the target of the call.  If it is not a thumb
2403                  target, we insert glue.  */
2404               if (ELF_ST_TYPE (h->type) != STT_ARM_TFUNC)
2405                 record_thumb_to_arm_glue (link_info, h);
2406               break;
2407
2408             default:
2409               abort ();
2410             }
2411         }
2412
2413       if (contents != NULL
2414           && elf_section_data (sec)->this_hdr.contents != contents)
2415         free (contents);
2416       contents = NULL;
2417
2418       if (internal_relocs != NULL
2419           && elf_section_data (sec)->relocs != internal_relocs)
2420         free (internal_relocs);
2421       internal_relocs = NULL;
2422     }
2423
2424   return TRUE;
2425
2426 error_return:
2427   if (contents != NULL
2428       && elf_section_data (sec)->this_hdr.contents != contents)
2429     free (contents);
2430   if (internal_relocs != NULL
2431       && elf_section_data (sec)->relocs != internal_relocs)
2432     free (internal_relocs);
2433
2434   return FALSE;
2435 }
2436 #endif
2437
2438
2439 /* Set target relocation values needed during linking.  */
2440
2441 void
2442 bfd_elf32_arm_set_target_relocs (struct bfd_link_info *link_info,
2443                                  int target1_is_rel,
2444                                  char * target2_type,
2445                                  int fix_v4bx,
2446                                  int use_blx)
2447 {
2448   struct elf32_arm_link_hash_table *globals;
2449
2450   globals = elf32_arm_hash_table (link_info);
2451
2452   globals->target1_is_rel = target1_is_rel;
2453   if (strcmp (target2_type, "rel") == 0)
2454     globals->target2_reloc = R_ARM_REL32;
2455   else if (strcmp (target2_type, "abs") == 0)
2456     globals->target2_reloc = R_ARM_ABS32;
2457   else if (strcmp (target2_type, "got-rel") == 0)
2458     globals->target2_reloc = R_ARM_GOT_PREL;
2459   else
2460     {
2461       _bfd_error_handler (_("Invalid TARGET2 relocation type '%s'."),
2462                           target2_type);
2463     }
2464   globals->fix_v4bx = fix_v4bx;
2465   globals->use_blx |= use_blx;
2466 }
2467
2468 /* The thumb form of a long branch is a bit finicky, because the offset
2469    encoding is split over two fields, each in it's own instruction. They
2470    can occur in any order. So given a thumb form of long branch, and an
2471    offset, insert the offset into the thumb branch and return finished
2472    instruction.
2473
2474    It takes two thumb instructions to encode the target address. Each has
2475    11 bits to invest. The upper 11 bits are stored in one (identified by
2476    H-0.. see below), the lower 11 bits are stored in the other (identified
2477    by H-1).
2478
2479    Combine together and shifted left by 1 (it's a half word address) and
2480    there you have it.
2481
2482    Op: 1111 = F,
2483    H-0, upper address-0 = 000
2484    Op: 1111 = F,
2485    H-1, lower address-0 = 800
2486
2487    They can be ordered either way, but the arm tools I've seen always put
2488    the lower one first. It probably doesn't matter. krk@cygnus.com
2489
2490    XXX:  Actually the order does matter.  The second instruction (H-1)
2491    moves the computed address into the PC, so it must be the second one
2492    in the sequence.  The problem, however is that whilst little endian code
2493    stores the instructions in HI then LOW order, big endian code does the
2494    reverse.  nickc@cygnus.com.  */
2495
2496 #define LOW_HI_ORDER      0xF800F000
2497 #define HI_LOW_ORDER      0xF000F800
2498
2499 static insn32
2500 insert_thumb_branch (insn32 br_insn, int rel_off)
2501 {
2502   unsigned int low_bits;
2503   unsigned int high_bits;
2504
2505   BFD_ASSERT ((rel_off & 1) != 1);
2506
2507   rel_off >>= 1;                                /* Half word aligned address.  */
2508   low_bits = rel_off & 0x000007FF;              /* The bottom 11 bits.  */
2509   high_bits = (rel_off >> 11) & 0x000007FF;     /* The top 11 bits.  */
2510
2511   if ((br_insn & LOW_HI_ORDER) == LOW_HI_ORDER)
2512     br_insn = LOW_HI_ORDER | (low_bits << 16) | high_bits;
2513   else if ((br_insn & HI_LOW_ORDER) == HI_LOW_ORDER)
2514     br_insn = HI_LOW_ORDER | (high_bits << 16) | low_bits;
2515   else
2516     /* FIXME: abort is probably not the right call. krk@cygnus.com  */
2517     abort ();   /* Error - not a valid branch instruction form.  */
2518
2519   return br_insn;
2520 }
2521
2522 /* Thumb code calling an ARM function.  */
2523
2524 static int
2525 elf32_thumb_to_arm_stub (struct bfd_link_info * info,
2526                          const char *           name,
2527                          bfd *                  input_bfd,
2528                          bfd *                  output_bfd,
2529                          asection *             input_section,
2530                          bfd_byte *             hit_data,
2531                          asection *             sym_sec,
2532                          bfd_vma                offset,
2533                          bfd_signed_vma         addend,
2534                          bfd_vma                val)
2535 {
2536   asection * s = 0;
2537   bfd_vma my_offset;
2538   unsigned long int tmp;
2539   long int ret_offset;
2540   struct elf_link_hash_entry * myh;
2541   struct elf32_arm_link_hash_table * globals;
2542
2543   myh = find_thumb_glue (info, name, input_bfd);
2544   if (myh == NULL)
2545     return FALSE;
2546
2547   globals = elf32_arm_hash_table (info);
2548
2549   BFD_ASSERT (globals != NULL);
2550   BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
2551
2552   my_offset = myh->root.u.def.value;
2553
2554   s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
2555                                THUMB2ARM_GLUE_SECTION_NAME);
2556
2557   BFD_ASSERT (s != NULL);
2558   BFD_ASSERT (s->contents != NULL);
2559   BFD_ASSERT (s->output_section != NULL);
2560
2561   if ((my_offset & 0x01) == 0x01)
2562     {
2563       if (sym_sec != NULL
2564           && sym_sec->owner != NULL
2565           && !INTERWORK_FLAG (sym_sec->owner))
2566         {
2567           (*_bfd_error_handler)
2568             (_("%B(%s): warning: interworking not enabled.\n"
2569                "  first occurrence: %B: thumb call to arm"),
2570              sym_sec->owner, input_bfd, name);
2571
2572           return FALSE;
2573         }
2574
2575       --my_offset;
2576       myh->root.u.def.value = my_offset;
2577
2578       bfd_put_16 (output_bfd, (bfd_vma) t2a1_bx_pc_insn,
2579                   s->contents + my_offset);
2580
2581       bfd_put_16 (output_bfd, (bfd_vma) t2a2_noop_insn,
2582                   s->contents + my_offset + 2);
2583
2584       ret_offset =
2585         /* Address of destination of the stub.  */
2586         ((bfd_signed_vma) val)
2587         - ((bfd_signed_vma)
2588            /* Offset from the start of the current section
2589               to the start of the stubs.  */
2590            (s->output_offset
2591             /* Offset of the start of this stub from the start of the stubs.  */
2592             + my_offset
2593             /* Address of the start of the current section.  */
2594             + s->output_section->vma)
2595            /* The branch instruction is 4 bytes into the stub.  */
2596            + 4
2597            /* ARM branches work from the pc of the instruction + 8.  */
2598            + 8);
2599
2600       bfd_put_32 (output_bfd,
2601                   (bfd_vma) t2a3_b_insn | ((ret_offset >> 2) & 0x00FFFFFF),
2602                   s->contents + my_offset + 4);
2603     }
2604
2605   BFD_ASSERT (my_offset <= globals->thumb_glue_size);
2606
2607   /* Now go back and fix up the original BL insn to point to here.  */
2608   ret_offset =
2609     /* Address of where the stub is located.  */
2610     (s->output_section->vma + s->output_offset + my_offset)
2611      /* Address of where the BL is located.  */
2612     - (input_section->output_section->vma + input_section->output_offset
2613        + offset)
2614     /* Addend in the relocation.  */
2615     - addend
2616     /* Biassing for PC-relative addressing.  */
2617     - 8;
2618
2619   tmp = bfd_get_32 (input_bfd, hit_data
2620                     - input_section->vma);
2621
2622   bfd_put_32 (output_bfd,
2623               (bfd_vma) insert_thumb_branch (tmp, ret_offset),
2624               hit_data - input_section->vma);
2625
2626   return TRUE;
2627 }
2628
2629 /* Arm code calling a Thumb function.  */
2630
2631 static int
2632 elf32_arm_to_thumb_stub (struct bfd_link_info * info,
2633                          const char *           name,
2634                          bfd *                  input_bfd,
2635                          bfd *                  output_bfd,
2636                          asection *             input_section,
2637                          bfd_byte *             hit_data,
2638                          asection *             sym_sec,
2639                          bfd_vma                offset,
2640                          bfd_signed_vma         addend,
2641                          bfd_vma                val)
2642 {
2643   unsigned long int tmp;
2644   bfd_vma my_offset;
2645   asection * s;
2646   long int ret_offset;
2647   struct elf_link_hash_entry * myh;
2648   struct elf32_arm_link_hash_table * globals;
2649
2650   myh = find_arm_glue (info, name, input_bfd);
2651   if (myh == NULL)
2652     return FALSE;
2653
2654   globals = elf32_arm_hash_table (info);
2655
2656   BFD_ASSERT (globals != NULL);
2657   BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
2658
2659   my_offset = myh->root.u.def.value;
2660   s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
2661                                ARM2THUMB_GLUE_SECTION_NAME);
2662   BFD_ASSERT (s != NULL);
2663   BFD_ASSERT (s->contents != NULL);
2664   BFD_ASSERT (s->output_section != NULL);
2665
2666   if ((my_offset & 0x01) == 0x01)
2667     {
2668       if (sym_sec != NULL
2669           && sym_sec->owner != NULL
2670           && !INTERWORK_FLAG (sym_sec->owner))
2671         {
2672           (*_bfd_error_handler)
2673             (_("%B(%s): warning: interworking not enabled.\n"
2674                "  first occurrence: %B: arm call to thumb"),
2675              sym_sec->owner, input_bfd, name);
2676         }
2677
2678       --my_offset;
2679       myh->root.u.def.value = my_offset;
2680
2681       if ((info->shared || globals->root.is_relocatable_executable))
2682         {
2683           /* For relocatable objects we can't use absolute addresses,
2684              so construct the address from a relative offset.  */
2685           /* TODO: If the offset is small it's probably worth
2686              constructing the address with adds.  */
2687           bfd_put_32 (output_bfd, (bfd_vma) a2t1p_ldr_insn,
2688                       s->contents + my_offset);
2689           bfd_put_32 (output_bfd, (bfd_vma) a2t2p_add_pc_insn,
2690                       s->contents + my_offset + 4);
2691           bfd_put_32 (output_bfd, (bfd_vma) a2t3p_bx_r12_insn,
2692                       s->contents + my_offset + 8);
2693           /* Adjust the offset by 4 for the position of the add,
2694              and 8 for the pipeline offset.  */
2695           ret_offset = (val - (s->output_offset
2696                                + s->output_section->vma
2697                                + my_offset + 12))
2698                        | 1;
2699           bfd_put_32 (output_bfd, ret_offset,
2700                       s->contents + my_offset + 12);
2701         }
2702       else
2703         {
2704           bfd_put_32 (output_bfd, (bfd_vma) a2t1_ldr_insn,
2705                       s->contents + my_offset);
2706
2707           bfd_put_32 (output_bfd, (bfd_vma) a2t2_bx_r12_insn,
2708                       s->contents + my_offset + 4);
2709
2710           /* It's a thumb address.  Add the low order bit.  */
2711           bfd_put_32 (output_bfd, val | a2t3_func_addr_insn,
2712                       s->contents + my_offset + 8);
2713         }
2714     }
2715
2716   BFD_ASSERT (my_offset <= globals->arm_glue_size);
2717
2718   tmp = bfd_get_32 (input_bfd, hit_data);
2719   tmp = tmp & 0xFF000000;
2720
2721   /* Somehow these are both 4 too far, so subtract 8.  */
2722   ret_offset = (s->output_offset
2723                 + my_offset
2724                 + s->output_section->vma
2725                 - (input_section->output_offset
2726                    + input_section->output_section->vma
2727                    + offset + addend)
2728                 - 8);
2729
2730   tmp = tmp | ((ret_offset >> 2) & 0x00FFFFFF);
2731
2732   bfd_put_32 (output_bfd, (bfd_vma) tmp, hit_data - input_section->vma);
2733
2734   return TRUE;
2735 }
2736
2737 /* Some relocations map to different relocations depending on the
2738    target.  Return the real relocation.  */
2739 static int
2740 arm_real_reloc_type (struct elf32_arm_link_hash_table * globals,
2741                      int r_type)
2742 {
2743   switch (r_type)
2744     {
2745     case R_ARM_TARGET1:
2746       if (globals->target1_is_rel)
2747         return R_ARM_REL32;
2748       else
2749         return R_ARM_ABS32;
2750
2751     case R_ARM_TARGET2:
2752       return globals->target2_reloc;
2753
2754     default:
2755       return r_type;
2756     }
2757 }
2758
2759 /* Return the base VMA address which should be subtracted from real addresses
2760    when resolving @dtpoff relocation.
2761    This is PT_TLS segment p_vaddr.  */
2762
2763 static bfd_vma
2764 dtpoff_base (struct bfd_link_info *info)
2765 {
2766   /* If tls_sec is NULL, we should have signalled an error already.  */
2767   if (elf_hash_table (info)->tls_sec == NULL)
2768     return 0;
2769   return elf_hash_table (info)->tls_sec->vma;
2770 }
2771
2772 /* Return the relocation value for @tpoff relocation
2773    if STT_TLS virtual address is ADDRESS.  */
2774
2775 static bfd_vma
2776 tpoff (struct bfd_link_info *info, bfd_vma address)
2777 {
2778   struct elf_link_hash_table *htab = elf_hash_table (info);
2779   bfd_vma base;
2780
2781   /* If tls_sec is NULL, we should have signalled an error already.  */
2782   if (htab->tls_sec == NULL)
2783     return 0;
2784   base = align_power ((bfd_vma) TCB_SIZE, htab->tls_sec->alignment_power);
2785   return address - htab->tls_sec->vma + base;
2786 }
2787
2788 /* Perform a relocation as part of a final link.  */
2789
2790 static bfd_reloc_status_type
2791 elf32_arm_final_link_relocate (reloc_howto_type *           howto,
2792                                bfd *                        input_bfd,
2793                                bfd *                        output_bfd,
2794                                asection *                   input_section,
2795                                bfd_byte *                   contents,
2796                                Elf_Internal_Rela *          rel,
2797                                bfd_vma                      value,
2798                                struct bfd_link_info *       info,
2799                                asection *                   sym_sec,
2800                                const char *                 sym_name,
2801                                int                          sym_flags,
2802                                struct elf_link_hash_entry * h,
2803                                bfd_boolean *                unresolved_reloc_p)
2804 {
2805   unsigned long                 r_type = howto->type;
2806   unsigned long                 r_symndx;
2807   bfd_byte *                    hit_data = contents + rel->r_offset;
2808   bfd *                         dynobj = NULL;
2809   Elf_Internal_Shdr *           symtab_hdr;
2810   struct elf_link_hash_entry ** sym_hashes;
2811   bfd_vma *                     local_got_offsets;
2812   asection *                    sgot = NULL;
2813   asection *                    splt = NULL;
2814   asection *                    sreloc = NULL;
2815   bfd_vma                       addend;
2816   bfd_signed_vma                signed_addend;
2817   struct elf32_arm_link_hash_table * globals;
2818
2819   globals = elf32_arm_hash_table (info);
2820
2821   /* Some relocation type map to different relocations depending on the
2822      target.  We pick the right one here.  */
2823   r_type = arm_real_reloc_type (globals, r_type);
2824   if (r_type != howto->type)
2825     howto = elf32_arm_howto_from_type (r_type);
2826
2827   /* If the start address has been set, then set the EF_ARM_HASENTRY
2828      flag.  Setting this more than once is redundant, but the cost is
2829      not too high, and it keeps the code simple.
2830
2831      The test is done  here, rather than somewhere else, because the
2832      start address is only set just before the final link commences.
2833
2834      Note - if the user deliberately sets a start address of 0, the
2835      flag will not be set.  */
2836   if (bfd_get_start_address (output_bfd) != 0)
2837     elf_elfheader (output_bfd)->e_flags |= EF_ARM_HASENTRY;
2838
2839   dynobj = elf_hash_table (info)->dynobj;
2840   if (dynobj)
2841     {
2842       sgot = bfd_get_section_by_name (dynobj, ".got");
2843       splt = bfd_get_section_by_name (dynobj, ".plt");
2844     }
2845   symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
2846   sym_hashes = elf_sym_hashes (input_bfd);
2847   local_got_offsets = elf_local_got_offsets (input_bfd);
2848   r_symndx = ELF32_R_SYM (rel->r_info);
2849
2850   if (globals->use_rel)
2851     {
2852       addend = bfd_get_32 (input_bfd, hit_data) & howto->src_mask;
2853
2854       if (addend & ((howto->src_mask + 1) >> 1))
2855         {
2856           signed_addend = -1;
2857           signed_addend &= ~ howto->src_mask;
2858           signed_addend |= addend;
2859         }
2860       else
2861         signed_addend = addend;
2862     }
2863   else
2864     addend = signed_addend = rel->r_addend;
2865
2866   switch (r_type)
2867     {
2868     case R_ARM_NONE:
2869       /* We don't need to find a value for this symbol.  It's just a
2870          marker.  */
2871       *unresolved_reloc_p = FALSE;
2872       return bfd_reloc_ok;
2873
2874     case R_ARM_PC24:
2875     case R_ARM_ABS32:
2876     case R_ARM_REL32:
2877     case R_ARM_CALL:
2878     case R_ARM_JUMP24:
2879     case R_ARM_XPC25:
2880     case R_ARM_PREL31:
2881     case R_ARM_PLT32:
2882       /* r_symndx will be zero only for relocs against symbols
2883          from removed linkonce sections, or sections discarded by
2884          a linker script.  */
2885       if (r_symndx == 0)
2886         return bfd_reloc_ok;
2887
2888       /* Handle relocations which should use the PLT entry.  ABS32/REL32
2889          will use the symbol's value, which may point to a PLT entry, but we
2890          don't need to handle that here.  If we created a PLT entry, all
2891          branches in this object should go to it.  */
2892       if ((r_type != R_ARM_ABS32 && r_type != R_ARM_REL32)
2893           && h != NULL
2894           && splt != NULL
2895           && h->plt.offset != (bfd_vma) -1)
2896         {
2897           /* If we've created a .plt section, and assigned a PLT entry to
2898              this function, it should not be known to bind locally.  If
2899              it were, we would have cleared the PLT entry.  */
2900           BFD_ASSERT (!SYMBOL_CALLS_LOCAL (info, h));
2901
2902           value = (splt->output_section->vma
2903                    + splt->output_offset
2904                    + h->plt.offset);
2905           *unresolved_reloc_p = FALSE;
2906           return _bfd_final_link_relocate (howto, input_bfd, input_section,
2907                                            contents, rel->r_offset, value,
2908                                            (bfd_vma) 0);
2909         }
2910
2911       /* When generating a shared object or relocatable executable, these
2912          relocations are copied into the output file to be resolved at
2913          run time.  */
2914       if ((info->shared || globals->root.is_relocatable_executable)
2915           && (input_section->flags & SEC_ALLOC)
2916           && (r_type != R_ARM_REL32
2917               || !SYMBOL_CALLS_LOCAL (info, h))
2918           && (h == NULL
2919               || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2920               || h->root.type != bfd_link_hash_undefweak)
2921           && r_type != R_ARM_PC24
2922           && r_type != R_ARM_CALL
2923           && r_type != R_ARM_JUMP24
2924           && r_type != R_ARM_PREL31
2925           && r_type != R_ARM_PLT32)
2926         {
2927           Elf_Internal_Rela outrel;
2928           bfd_byte *loc;
2929           bfd_boolean skip, relocate;
2930
2931           *unresolved_reloc_p = FALSE;
2932
2933           if (sreloc == NULL)
2934             {
2935               const char * name;
2936
2937               name = (bfd_elf_string_from_elf_section
2938                       (input_bfd,
2939                        elf_elfheader (input_bfd)->e_shstrndx,
2940                        elf_section_data (input_section)->rel_hdr.sh_name));
2941               if (name == NULL)
2942                 return bfd_reloc_notsupported;
2943
2944               BFD_ASSERT (strncmp (name, ".rel", 4) == 0
2945                           && strcmp (bfd_get_section_name (input_bfd,
2946                                                            input_section),
2947                                      name + 4) == 0);
2948
2949               sreloc = bfd_get_section_by_name (dynobj, name);
2950               BFD_ASSERT (sreloc != NULL);
2951             }
2952
2953           skip = FALSE;
2954           relocate = FALSE;
2955
2956           outrel.r_offset =
2957             _bfd_elf_section_offset (output_bfd, info, input_section,
2958                                      rel->r_offset);
2959           if (outrel.r_offset == (bfd_vma) -1)
2960             skip = TRUE;
2961           else if (outrel.r_offset == (bfd_vma) -2)
2962             skip = TRUE, relocate = TRUE;
2963           outrel.r_offset += (input_section->output_section->vma
2964                               + input_section->output_offset);
2965
2966           if (skip)
2967             memset (&outrel, 0, sizeof outrel);
2968           else if (h != NULL
2969                    && h->dynindx != -1
2970                    && (!info->shared
2971                        || !info->symbolic
2972                        || !h->def_regular))
2973             outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2974           else
2975             {
2976               int symbol;
2977
2978               /* This symbol is local, or marked to become local.  */
2979               relocate = TRUE;
2980               if (sym_flags == STT_ARM_TFUNC)
2981                 value |= 1;
2982               if (globals->symbian_p)
2983                 {
2984                   /* On Symbian OS, the data segment and text segement
2985                      can be relocated independently.  Therefore, we
2986                      must indicate the segment to which this
2987                      relocation is relative.  The BPABI allows us to
2988                      use any symbol in the right segment; we just use
2989                      the section symbol as it is convenient.  (We
2990                      cannot use the symbol given by "h" directly as it
2991                      will not appear in the dynamic symbol table.)  */
2992                   if (sym_sec)
2993                     symbol = elf_section_data (sym_sec->output_section)->dynindx;
2994                   else
2995                     symbol = elf_section_data (input_section->output_section)->dynindx;
2996                   BFD_ASSERT (symbol != 0);
2997                 }
2998               else
2999                 /* On SVR4-ish systems, the dynamic loader cannot
3000                    relocate the text and data segments independently,
3001                    so the symbol does not matter.  */
3002                 symbol = 0;
3003               outrel.r_info = ELF32_R_INFO (symbol, R_ARM_RELATIVE);
3004             }
3005
3006           loc = sreloc->contents;
3007           loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
3008           bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3009
3010           /* If this reloc is against an external symbol, we do not want to
3011              fiddle with the addend.  Otherwise, we need to include the symbol
3012              value so that it becomes an addend for the dynamic reloc.  */
3013           if (! relocate)
3014             return bfd_reloc_ok;
3015
3016           return _bfd_final_link_relocate (howto, input_bfd, input_section,
3017                                            contents, rel->r_offset, value,
3018                                            (bfd_vma) 0);
3019         }
3020       else switch (r_type)
3021         {
3022         case R_ARM_XPC25:         /* Arm BLX instruction.  */
3023         case R_ARM_CALL:
3024         case R_ARM_JUMP24:
3025         case R_ARM_PC24:          /* Arm B/BL instruction */
3026         case R_ARM_PLT32:
3027           if (r_type == R_ARM_XPC25)
3028             {
3029               /* Check for Arm calling Arm function.  */
3030               /* FIXME: Should we translate the instruction into a BL
3031                  instruction instead ?  */
3032               if (sym_flags != STT_ARM_TFUNC)
3033                 (*_bfd_error_handler)
3034                   (_("\%B: Warning: Arm BLX instruction targets Arm function '%s'."),
3035                    input_bfd,
3036                    h ? h->root.root.string : "(local)");
3037             }
3038           else
3039             {
3040               /* Check for Arm calling Thumb function.  */
3041               if (sym_flags == STT_ARM_TFUNC)
3042                 {
3043                   elf32_arm_to_thumb_stub (info, sym_name, input_bfd,
3044                                            output_bfd, input_section,
3045                                            hit_data, sym_sec, rel->r_offset,
3046                                            signed_addend, value);
3047                   return bfd_reloc_ok;
3048                 }
3049             }
3050
3051           /* The ARM ELF ABI says that this reloc is computed as: S - P + A
3052              where:
3053               S is the address of the symbol in the relocation.
3054               P is address of the instruction being relocated.
3055               A is the addend (extracted from the instruction) in bytes.
3056
3057              S is held in 'value'.
3058              P is the base address of the section containing the
3059                instruction plus the offset of the reloc into that
3060                section, ie:
3061                  (input_section->output_section->vma +
3062                   input_section->output_offset +
3063                   rel->r_offset).
3064              A is the addend, converted into bytes, ie:
3065                  (signed_addend * 4)
3066
3067              Note: None of these operations have knowledge of the pipeline
3068              size of the processor, thus it is up to the assembler to
3069              encode this information into the addend.  */
3070           value -= (input_section->output_section->vma
3071                     + input_section->output_offset);
3072           value -= rel->r_offset;
3073           if (globals->use_rel)
3074             value += (signed_addend << howto->size);
3075           else
3076             /* RELA addends do not have to be adjusted by howto->size.  */
3077             value += signed_addend;
3078
3079           signed_addend = value;
3080           signed_addend >>= howto->rightshift;
3081
3082           /* It is not an error for an undefined weak reference to be
3083              out of range.  Any program that branches to such a symbol
3084              is going to crash anyway, so there is no point worrying
3085              about getting the destination exactly right.  */
3086           if (! h || h->root.type != bfd_link_hash_undefweak)
3087             {
3088               /* Perform a signed range check.  */
3089               if (   signed_addend >   ((bfd_signed_vma)  (howto->dst_mask >> 1))
3090                   || signed_addend < - ((bfd_signed_vma) ((howto->dst_mask + 1) >> 1)))
3091                 return bfd_reloc_overflow;
3092             }
3093
3094           /* If necessary set the H bit in the BLX instruction.  */
3095           if (r_type == R_ARM_XPC25 && ((value & 2) == 2))
3096             value = (signed_addend & howto->dst_mask)
3097               | (bfd_get_32 (input_bfd, hit_data) & (~ howto->dst_mask))
3098               | (1 << 24);
3099           else
3100             value = (signed_addend & howto->dst_mask)
3101               | (bfd_get_32 (input_bfd, hit_data) & (~ howto->dst_mask));
3102           break;
3103
3104         case R_ARM_ABS32:
3105           value += addend;
3106           if (sym_flags == STT_ARM_TFUNC)
3107             value |= 1;
3108           break;
3109
3110         case R_ARM_REL32:
3111           value -= (input_section->output_section->vma
3112                     + input_section->output_offset + rel->r_offset);
3113           value += addend;
3114           break;
3115
3116         case R_ARM_PREL31:
3117           value -= (input_section->output_section->vma
3118                     + input_section->output_offset + rel->r_offset);
3119           value += signed_addend;
3120           if (! h || h->root.type != bfd_link_hash_undefweak)
3121             {
3122               /* Check for overflow */
3123               if ((value ^ (value >> 1)) & (1 << 30))
3124                 return bfd_reloc_overflow;
3125             }
3126           value &= 0x7fffffff;
3127           value |= (bfd_get_32 (input_bfd, hit_data) & 0x80000000);
3128           if (sym_flags == STT_ARM_TFUNC)
3129             value |= 1;
3130           break;
3131         }
3132
3133       bfd_put_32 (input_bfd, value, hit_data);
3134       return bfd_reloc_ok;
3135
3136     case R_ARM_ABS8:
3137       value += addend;
3138       if ((long) value > 0x7f || (long) value < -0x80)
3139         return bfd_reloc_overflow;
3140
3141       bfd_put_8 (input_bfd, value, hit_data);
3142       return bfd_reloc_ok;
3143
3144     case R_ARM_ABS16:
3145       value += addend;
3146
3147       if ((long) value > 0x7fff || (long) value < -0x8000)
3148         return bfd_reloc_overflow;
3149
3150       bfd_put_16 (input_bfd, value, hit_data);
3151       return bfd_reloc_ok;
3152
3153     case R_ARM_ABS12:
3154       /* Support ldr and str instruction for the arm */
3155       /* Also thumb b (unconditional branch).  ??? Really?  */
3156       value += addend;
3157
3158       if ((long) value > 0x7ff || (long) value < -0x800)
3159         return bfd_reloc_overflow;
3160
3161       value |= (bfd_get_32 (input_bfd, hit_data) & 0xfffff000);
3162       bfd_put_32 (input_bfd, value, hit_data);
3163       return bfd_reloc_ok;
3164
3165     case R_ARM_THM_ABS5:
3166       /* Support ldr and str instructions for the thumb.  */
3167       if (globals->use_rel)
3168         {
3169           /* Need to refetch addend.  */
3170           addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
3171           /* ??? Need to determine shift amount from operand size.  */
3172           addend >>= howto->rightshift;
3173         }
3174       value += addend;
3175
3176       /* ??? Isn't value unsigned?  */
3177       if ((long) value > 0x1f || (long) value < -0x10)
3178         return bfd_reloc_overflow;
3179
3180       /* ??? Value needs to be properly shifted into place first.  */
3181       value |= bfd_get_16 (input_bfd, hit_data) & 0xf83f;
3182       bfd_put_16 (input_bfd, value, hit_data);
3183       return bfd_reloc_ok;
3184
3185     case R_ARM_THM_XPC22:
3186     case R_ARM_THM_CALL:
3187       /* Thumb BL (branch long instruction).  */
3188       {
3189         bfd_vma relocation;
3190         bfd_boolean overflow = FALSE;
3191         bfd_vma upper_insn = bfd_get_16 (input_bfd, hit_data);
3192         bfd_vma lower_insn = bfd_get_16 (input_bfd, hit_data + 2);
3193         bfd_signed_vma reloc_signed_max = ((1 << (howto->bitsize - 1)) - 1) >> howto->rightshift;
3194         bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
3195         bfd_vma check;
3196         bfd_signed_vma signed_check;
3197         bfd_boolean thumb_plt_call = FALSE;
3198
3199         /* Need to refetch the addend and squish the two 11 bit pieces
3200            together.  */
3201         if (globals->use_rel)
3202           {
3203             bfd_vma upper = upper_insn & 0x7ff;
3204             bfd_vma lower = lower_insn & 0x7ff;
3205             upper = (upper ^ 0x400) - 0x400; /* Sign extend.  */
3206             addend = (upper << 12) | (lower << 1);
3207             signed_addend = addend;
3208           }
3209
3210         if (r_type == R_ARM_THM_XPC22)
3211           {
3212             /* Check for Thumb to Thumb call.  */
3213             /* FIXME: Should we translate the instruction into a BL
3214                instruction instead ?  */
3215             if (sym_flags == STT_ARM_TFUNC)
3216               (*_bfd_error_handler)
3217                 (_("%B: Warning: Thumb BLX instruction targets thumb function '%s'."),
3218                  input_bfd,
3219                  h ? h->root.root.string : "(local)");
3220           }
3221         else
3222           {
3223             /* If it is not a call to Thumb, assume call to Arm.
3224                If it is a call relative to a section name, then it is not a
3225                function call at all, but rather a long jump.  Calls through
3226                the PLT do not require stubs.  */
3227             if (sym_flags != STT_ARM_TFUNC && sym_flags != STT_SECTION
3228                 && (h == NULL || splt == NULL
3229                     || h->plt.offset == (bfd_vma) -1))
3230               {
3231                 if (elf32_thumb_to_arm_stub
3232                     (info, sym_name, input_bfd, output_bfd, input_section,
3233                      hit_data, sym_sec, rel->r_offset, signed_addend, value))
3234                   return bfd_reloc_ok;
3235                 else
3236                   return bfd_reloc_dangerous;
3237               }
3238           }
3239
3240         /* Handle calls via the PLT.  */
3241         if (h != NULL && splt != NULL && h->plt.offset != (bfd_vma) -1)
3242           {
3243             value = (splt->output_section->vma
3244                      + splt->output_offset
3245                      + h->plt.offset);
3246             if (globals->use_blx)
3247               {
3248                 /* If the Thumb BLX instruction is available, convert the
3249                    BL to a BLX instruction to call the ARM-mode PLT entry.  */
3250                 if ((lower_insn & (0x3 << 11)) == 0x3 << 11)
3251                   {
3252                     lower_insn = (lower_insn & ~(0x3 << 11)) | 0x1 << 11;
3253                     thumb_plt_call = TRUE;
3254                   }
3255               }
3256             else
3257               /* Target the Thumb stub before the ARM PLT entry.  */
3258               value -= PLT_THUMB_STUB_SIZE;
3259             *unresolved_reloc_p = FALSE;
3260           }
3261
3262         relocation = value + signed_addend;
3263
3264         relocation -= (input_section->output_section->vma
3265                        + input_section->output_offset
3266                        + rel->r_offset);
3267
3268         check = relocation >> howto->rightshift;
3269
3270         /* If this is a signed value, the rightshift just dropped
3271            leading 1 bits (assuming twos complement).  */
3272         if ((bfd_signed_vma) relocation >= 0)
3273           signed_check = check;
3274         else
3275           signed_check = check | ~((bfd_vma) -1 >> howto->rightshift);
3276
3277         /* Assumes two's complement.  */
3278         if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
3279           overflow = TRUE;
3280
3281         if ((r_type == R_ARM_THM_XPC22
3282              && ((lower_insn & 0x1800) == 0x0800))
3283             || thumb_plt_call)
3284           /* For a BLX instruction, make sure that the relocation is rounded up
3285              to a word boundary.  This follows the semantics of the instruction
3286              which specifies that bit 1 of the target address will come from bit
3287              1 of the base address.  */
3288           relocation = (relocation + 2) & ~ 3;
3289
3290         /* Put RELOCATION back into the insn.  */
3291         upper_insn = (upper_insn & ~(bfd_vma) 0x7ff) | ((relocation >> 12) & 0x7ff);
3292         lower_insn = (lower_insn & ~(bfd_vma) 0x7ff) | ((relocation >> 1) & 0x7ff);
3293
3294         /* Put the relocated value back in the object file:  */
3295         bfd_put_16 (input_bfd, upper_insn, hit_data);
3296         bfd_put_16 (input_bfd, lower_insn, hit_data + 2);
3297
3298         return (overflow ? bfd_reloc_overflow : bfd_reloc_ok);
3299       }
3300       break;
3301
3302     case R_ARM_THM_JUMP24:
3303       /* Thumb32 unconditional branch instruction.  */
3304       {
3305         bfd_vma relocation;
3306         bfd_boolean overflow = FALSE;
3307         bfd_vma upper_insn = bfd_get_16 (input_bfd, hit_data);
3308         bfd_vma lower_insn = bfd_get_16 (input_bfd, hit_data + 2);
3309         bfd_signed_vma reloc_signed_max = ((1 << (howto->bitsize - 1)) - 1) >> howto->rightshift;
3310         bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
3311         bfd_vma check;
3312         bfd_signed_vma signed_check;
3313
3314         /* Need to refetch the addend, reconstruct the top three bits, and glue the
3315            two pieces together.  */
3316         if (globals->use_rel)
3317           {
3318             bfd_vma S  = (upper_insn & 0x0400) >> 10;
3319             bfd_vma hi = (upper_insn & 0x03ff);
3320             bfd_vma I1 = (lower_insn & 0x2000) >> 13;
3321             bfd_vma I2 = (lower_insn & 0x0800) >> 11;
3322             bfd_vma lo = (lower_insn & 0x07ff);
3323
3324             I1 = !(I1 ^ S);
3325             I2 = !(I2 ^ S);
3326             S  = !S;
3327
3328             signed_addend = (S << 24) | (I1 << 23) | (I2 << 22) | (hi << 12) | (lo << 1);
3329             signed_addend -= (1 << 24); /* Sign extend.  */
3330           }
3331
3332         /* ??? Should handle interworking?  GCC might someday try to
3333            use this for tail calls.  */
3334
3335         relocation = value + signed_addend;
3336         relocation -= (input_section->output_section->vma
3337                        + input_section->output_offset
3338                        + rel->r_offset);
3339
3340         check = relocation >> howto->rightshift;
3341
3342         /* If this is a signed value, the rightshift just dropped
3343            leading 1 bits (assuming twos complement).  */
3344         if ((bfd_signed_vma) relocation >= 0)
3345           signed_check = check;
3346         else
3347           signed_check = check | ~((bfd_vma) -1 >> howto->rightshift);
3348
3349         /* Assumes two's complement.  */
3350         if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
3351           overflow = TRUE;
3352
3353         /* Put RELOCATION back into the insn.  */
3354         {
3355           bfd_vma S  = (relocation & 0x01000000) >> 24;
3356           bfd_vma I1 = (relocation & 0x00800000) >> 23;
3357           bfd_vma I2 = (relocation & 0x00400000) >> 22;
3358           bfd_vma hi = (relocation & 0x003ff000) >> 12;
3359           bfd_vma lo = (relocation & 0x00000ffe) >>  1;
3360
3361           I1 = !(I1 ^ S);
3362           I2 = !(I2 ^ S);
3363
3364           upper_insn = (upper_insn & (bfd_vma) 0xf800) | (S << 10) | hi;
3365           lower_insn = (lower_insn & (bfd_vma) 0xd000) | (I1 << 13) | (I2 << 11) | lo;
3366         }
3367
3368         /* Put the relocated value back in the object file:  */
3369         bfd_put_16 (input_bfd, upper_insn, hit_data);
3370         bfd_put_16 (input_bfd, lower_insn, hit_data + 2);
3371
3372         return (overflow ? bfd_reloc_overflow : bfd_reloc_ok);
3373       }
3374
3375     case R_ARM_THM_JUMP19:
3376       /* Thumb32 conditional branch instruction.  */
3377       {
3378         bfd_vma relocation;
3379         bfd_boolean overflow = FALSE;
3380         bfd_vma upper_insn = bfd_get_16 (input_bfd, hit_data);
3381         bfd_vma lower_insn = bfd_get_16 (input_bfd, hit_data + 2);
3382         bfd_signed_vma reloc_signed_max = ((1 << (howto->bitsize - 1)) - 1) >> howto->rightshift;
3383         bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
3384         bfd_vma check;
3385         bfd_signed_vma signed_check;
3386
3387         /* Need to refetch the addend, reconstruct the top three bits,
3388            and squish the two 11 bit pieces together.  */
3389         if (globals->use_rel)
3390           {
3391             bfd_vma S     = (upper_insn & 0x0400) >> 10;
3392             bfd_vma upper = (upper_insn & 0x001f);
3393             bfd_vma J1    = (lower_insn & 0x2000) >> 13;
3394             bfd_vma J2    = (lower_insn & 0x0800) >> 11;
3395             bfd_vma lower = (lower_insn & 0x07ff);
3396
3397             upper |= J2 << 6;
3398             upper |= J1 << 7;
3399             upper |= ~S << 8;
3400             upper -= 0x0100; /* Sign extend.  */
3401
3402             addend = (upper << 12) | (lower << 1);
3403             signed_addend = addend;
3404           }
3405
3406         /* ??? Should handle interworking?  GCC might someday try to
3407            use this for tail calls.  */
3408
3409         relocation = value + signed_addend;
3410         relocation -= (input_section->output_section->vma
3411                        + input_section->output_offset
3412                        + rel->r_offset);
3413
3414         check = relocation >> howto->rightshift;
3415
3416         /* If this is a signed value, the rightshift just dropped
3417            leading 1 bits (assuming twos complement).  */
3418         if ((bfd_signed_vma) relocation >= 0)
3419           signed_check = check;
3420         else
3421           signed_check = check | ~((bfd_vma) -1 >> howto->rightshift);
3422
3423         /* Assumes two's complement.  */
3424         if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
3425           overflow = TRUE;
3426
3427         /* Put RELOCATION back into the insn.  */
3428         {
3429           bfd_vma S  = (relocation & 0x00100000) >> 20;
3430           bfd_vma J2 = (relocation & 0x00080000) >> 19;
3431           bfd_vma J1 = (relocation & 0x00040000) >> 18;
3432           bfd_vma hi = (relocation & 0x0003f000) >> 12;
3433           bfd_vma lo = (relocation & 0x00000ffe) >>  1;
3434
3435           upper_insn = (upper_insn & 0xfb30) | (S << 10) | hi;
3436           lower_insn = (lower_insn & 0xd000) | (J1 << 13) | (J2 << 11) | lo;
3437         }
3438
3439         /* Put the relocated value back in the object file:  */
3440         bfd_put_16 (input_bfd, upper_insn, hit_data);
3441         bfd_put_16 (input_bfd, lower_insn, hit_data + 2);
3442
3443         return (overflow ? bfd_reloc_overflow : bfd_reloc_ok);
3444       }
3445
3446     case R_ARM_THM_JUMP11:
3447     case R_ARM_THM_JUMP8:
3448     case R_ARM_THM_JUMP6:
3449       /* Thumb B (branch) instruction).  */
3450       {
3451         bfd_signed_vma relocation;
3452         bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
3453         bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
3454         bfd_signed_vma signed_check;
3455
3456         /* CZB cannot jump backward.  */
3457         if (r_type == R_ARM_THM_JUMP6)
3458           reloc_signed_min = 0;
3459
3460         if (globals->use_rel)
3461           {
3462             /* Need to refetch addend.  */
3463             addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
3464             if (addend & ((howto->src_mask + 1) >> 1))
3465               {
3466                 signed_addend = -1;
3467                 signed_addend &= ~ howto->src_mask;
3468                 signed_addend |= addend;
3469               }
3470             else
3471               signed_addend = addend;
3472             /* The value in the insn has been right shifted.  We need to
3473                undo this, so that we can perform the address calculation
3474                in terms of bytes.  */
3475             signed_addend <<= howto->rightshift;
3476           }
3477         relocation = value + signed_addend;
3478
3479         relocation -= (input_section->output_section->vma
3480                        + input_section->output_offset
3481                        + rel->r_offset);
3482
3483         relocation >>= howto->rightshift;
3484         signed_check = relocation;
3485
3486         if (r_type == R_ARM_THM_JUMP6)
3487           relocation = ((relocation & 0x0020) << 4) | ((relocation & 0x001f) << 3);
3488         else
3489           relocation &= howto->dst_mask;
3490         relocation |= (bfd_get_16 (input_bfd, hit_data) & (~ howto->dst_mask));
3491
3492         bfd_put_16 (input_bfd, relocation, hit_data);
3493
3494         /* Assumes two's complement.  */
3495         if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
3496           return bfd_reloc_overflow;
3497
3498         return bfd_reloc_ok;
3499       }
3500
3501     case R_ARM_ALU_PCREL7_0:
3502     case R_ARM_ALU_PCREL15_8:
3503     case R_ARM_ALU_PCREL23_15:
3504       {
3505         bfd_vma insn;
3506         bfd_vma relocation;
3507
3508         insn = bfd_get_32 (input_bfd, hit_data);
3509         if (globals->use_rel)
3510           {
3511             /* Extract the addend.  */
3512             addend = (insn & 0xff) << ((insn & 0xf00) >> 7);
3513             signed_addend = addend;
3514           }
3515         relocation = value + signed_addend;
3516
3517         relocation -= (input_section->output_section->vma
3518                        + input_section->output_offset
3519                        + rel->r_offset);
3520         insn = (insn & ~0xfff)
3521                | ((howto->bitpos << 7) & 0xf00)
3522                | ((relocation >> howto->bitpos) & 0xff);
3523         bfd_put_32 (input_bfd, value, hit_data);
3524       }
3525       return bfd_reloc_ok;
3526
3527     case R_ARM_GNU_VTINHERIT:
3528     case R_ARM_GNU_VTENTRY:
3529       return bfd_reloc_ok;
3530
3531     case R_ARM_GOTOFF32:
3532       /* Relocation is relative to the start of the
3533          global offset table.  */
3534
3535       BFD_ASSERT (sgot != NULL);
3536       if (sgot == NULL)
3537         return bfd_reloc_notsupported;
3538
3539       /* If we are addressing a Thumb function, we need to adjust the
3540          address by one, so that attempts to call the function pointer will
3541          correctly interpret it as Thumb code.  */
3542       if (sym_flags == STT_ARM_TFUNC)
3543         value += 1;
3544
3545       /* Note that sgot->output_offset is not involved in this
3546          calculation.  We always want the start of .got.  If we
3547          define _GLOBAL_OFFSET_TABLE in a different way, as is
3548          permitted by the ABI, we might have to change this
3549          calculation.  */
3550       value -= sgot->output_section->vma;
3551       return _bfd_final_link_relocate (howto, input_bfd, input_section,
3552                                        contents, rel->r_offset, value,
3553                                        (bfd_vma) 0);
3554
3555     case R_ARM_GOTPC:
3556       /* Use global offset table as symbol value.  */
3557       BFD_ASSERT (sgot != NULL);
3558
3559       if (sgot == NULL)
3560         return bfd_reloc_notsupported;
3561
3562       *unresolved_reloc_p = FALSE;
3563       value = sgot->output_section->vma;
3564       return _bfd_final_link_relocate (howto, input_bfd, input_section,
3565                                        contents, rel->r_offset, value,
3566                                        (bfd_vma) 0);
3567
3568     case R_ARM_GOT32:
3569     case R_ARM_GOT_PREL:
3570       /* Relocation is to the entry for this symbol in the
3571          global offset table.  */
3572       if (sgot == NULL)
3573         return bfd_reloc_notsupported;
3574
3575       if (h != NULL)
3576         {
3577           bfd_vma off;
3578           bfd_boolean dyn;
3579
3580           off = h->got.offset;
3581           BFD_ASSERT (off != (bfd_vma) -1);
3582           dyn = globals->root.dynamic_sections_created;
3583
3584           if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
3585               || (info->shared
3586                   && SYMBOL_REFERENCES_LOCAL (info, h))
3587               || (ELF_ST_VISIBILITY (h->other)
3588                   && h->root.type == bfd_link_hash_undefweak))
3589             {
3590               /* This is actually a static link, or it is a -Bsymbolic link
3591                  and the symbol is defined locally.  We must initialize this
3592                  entry in the global offset table.  Since the offset must
3593                  always be a multiple of 4, we use the least significant bit
3594                  to record whether we have initialized it already.
3595
3596                  When doing a dynamic link, we create a .rel.got relocation
3597                  entry to initialize the value.  This is done in the
3598                  finish_dynamic_symbol routine.  */
3599               if ((off & 1) != 0)
3600                 off &= ~1;
3601               else
3602                 {
3603                   /* If we are addressing a Thumb function, we need to
3604                      adjust the address by one, so that attempts to
3605                      call the function pointer will correctly
3606                      interpret it as Thumb code.  */
3607                   if (sym_flags == STT_ARM_TFUNC)
3608                     value |= 1;
3609
3610                   bfd_put_32 (output_bfd, value, sgot->contents + off);
3611                   h->got.offset |= 1;
3612                 }
3613             }
3614           else
3615             *unresolved_reloc_p = FALSE;
3616
3617           value = sgot->output_offset + off;
3618         }
3619       else
3620         {
3621           bfd_vma off;
3622
3623           BFD_ASSERT (local_got_offsets != NULL &&
3624                       local_got_offsets[r_symndx] != (bfd_vma) -1);
3625
3626           off = local_got_offsets[r_symndx];
3627
3628           /* The offset must always be a multiple of 4.  We use the
3629              least significant bit to record whether we have already
3630              generated the necessary reloc.  */
3631           if ((off & 1) != 0)
3632             off &= ~1;
3633           else
3634             {
3635               /* If we are addressing a Thumb function, we need to
3636                  adjust the address by one, so that attempts to
3637                  call the function pointer will correctly
3638                  interpret it as Thumb code.  */
3639               if (sym_flags == STT_ARM_TFUNC)
3640                 value |= 1;
3641
3642               bfd_put_32 (output_bfd, value, sgot->contents + off);
3643
3644               if (info->shared)
3645                 {
3646                   asection * srelgot;
3647                   Elf_Internal_Rela outrel;
3648                   bfd_byte *loc;
3649
3650                   srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
3651                   BFD_ASSERT (srelgot != NULL);
3652
3653                   outrel.r_offset = (sgot->output_section->vma
3654                                      + sgot->output_offset
3655                                      + off);
3656                   outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
3657                   loc = srelgot->contents;
3658                   loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
3659                   bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3660                 }
3661
3662               local_got_offsets[r_symndx] |= 1;
3663             }
3664
3665           value = sgot->output_offset + off;
3666         }
3667       if (r_type != R_ARM_GOT32)
3668         value += sgot->output_section->vma;
3669
3670       return _bfd_final_link_relocate (howto, input_bfd, input_section,
3671                                        contents, rel->r_offset, value,
3672                                        (bfd_vma) 0);
3673
3674     case R_ARM_TLS_LDO32:
3675       value = value - dtpoff_base (info);
3676
3677       return _bfd_final_link_relocate (howto, input_bfd, input_section,
3678                                        contents, rel->r_offset, value, (bfd_vma) 0);
3679
3680     case R_ARM_TLS_LDM32:
3681       {
3682         bfd_vma off;
3683
3684         if (globals->sgot == NULL)
3685           abort ();
3686
3687         off = globals->tls_ldm_got.offset;
3688
3689         if ((off & 1) != 0)
3690           off &= ~1;
3691         else
3692           {
3693             /* If we don't know the module number, create a relocation
3694                for it.  */
3695             if (info->shared)
3696               {
3697                 Elf_Internal_Rela outrel;
3698                 bfd_byte *loc;
3699
3700                 if (globals->srelgot == NULL)
3701                   abort ();
3702
3703                 outrel.r_offset = (globals->sgot->output_section->vma
3704                                    + globals->sgot->output_offset + off);
3705                 outrel.r_info = ELF32_R_INFO (0, R_ARM_TLS_DTPMOD32);
3706
3707                 bfd_put_32 (output_bfd, 0, globals->sgot->contents + off);
3708
3709                 loc = globals->srelgot->contents;
3710                 loc += globals->srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
3711                 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3712               }
3713             else
3714               bfd_put_32 (output_bfd, 1, globals->sgot->contents + off);
3715
3716             globals->tls_ldm_got.offset |= 1;
3717           }
3718
3719         value = globals->sgot->output_section->vma + globals->sgot->output_offset + off
3720           - (input_section->output_section->vma + input_section->output_offset + rel->r_offset);
3721
3722         return _bfd_final_link_relocate (howto, input_bfd, input_section,
3723                                          contents, rel->r_offset, value,
3724                                          (bfd_vma) 0);
3725       }
3726
3727     case R_ARM_TLS_GD32:
3728     case R_ARM_TLS_IE32:
3729       {
3730         bfd_vma off;
3731         int indx;
3732         char tls_type;
3733
3734         if (globals->sgot == NULL)
3735           abort ();
3736
3737         indx = 0;
3738         if (h != NULL)
3739           {
3740             bfd_boolean dyn;
3741             dyn = globals->root.dynamic_sections_created;
3742             if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
3743                 && (!info->shared
3744                     || !SYMBOL_REFERENCES_LOCAL (info, h)))
3745               {
3746                 *unresolved_reloc_p = FALSE;
3747                 indx = h->dynindx;
3748               }
3749             off = h->got.offset;
3750             tls_type = ((struct elf32_arm_link_hash_entry *) h)->tls_type;
3751           }
3752         else
3753           {
3754             if (local_got_offsets == NULL)
3755               abort ();
3756             off = local_got_offsets[r_symndx];
3757             tls_type = elf32_arm_local_got_tls_type (input_bfd)[r_symndx];
3758           }
3759
3760         if (tls_type == GOT_UNKNOWN)
3761           abort ();
3762
3763         if ((off & 1) != 0)
3764           off &= ~1;
3765         else
3766           {
3767             bfd_boolean need_relocs = FALSE;
3768             Elf_Internal_Rela outrel;
3769             bfd_byte *loc = NULL;
3770             int cur_off = off;
3771
3772             /* The GOT entries have not been initialized yet.  Do it
3773                now, and emit any relocations.  If both an IE GOT and a
3774                GD GOT are necessary, we emit the GD first.  */
3775
3776             if ((info->shared || indx != 0)
3777                 && (h == NULL
3778                     || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3779                     || h->root.type != bfd_link_hash_undefweak))
3780               {
3781                 need_relocs = TRUE;
3782                 if (globals->srelgot == NULL)
3783                   abort ();
3784                 loc = globals->srelgot->contents;
3785                 loc += globals->srelgot->reloc_count * sizeof (Elf32_External_Rel);
3786               }
3787
3788             if (tls_type & GOT_TLS_GD)
3789               {
3790                 if (need_relocs)
3791                   {
3792                     outrel.r_offset = (globals->sgot->output_section->vma
3793                                        + globals->sgot->output_offset + cur_off);
3794                     outrel.r_info = ELF32_R_INFO (indx, R_ARM_TLS_DTPMOD32);
3795                     bfd_put_32 (output_bfd, 0, globals->sgot->contents + cur_off);
3796
3797                     bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3798                     globals->srelgot->reloc_count++;
3799                     loc += sizeof (Elf32_External_Rel);
3800
3801                     if (indx == 0)
3802                       bfd_put_32 (output_bfd, value - dtpoff_base (info),
3803                                   globals->sgot->contents + cur_off + 4);
3804                     else
3805                       {
3806                         bfd_put_32 (output_bfd, 0,
3807                                     globals->sgot->contents + cur_off + 4);
3808
3809                         outrel.r_info = ELF32_R_INFO (indx,
3810                                                       R_ARM_TLS_DTPOFF32);
3811                         outrel.r_offset += 4;
3812                         bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3813                         globals->srelgot->reloc_count++;
3814                         loc += sizeof (Elf32_External_Rel);
3815                       }
3816                   }
3817                 else
3818                   {
3819                     /* If we are not emitting relocations for a
3820                        general dynamic reference, then we must be in a
3821                        static link or an executable link with the
3822                        symbol binding locally.  Mark it as belonging
3823                        to module 1, the executable.  */
3824                     bfd_put_32 (output_bfd, 1,
3825                                 globals->sgot->contents + cur_off);
3826                     bfd_put_32 (output_bfd, value - dtpoff_base (info),
3827                                 globals->sgot->contents + cur_off + 4);
3828                   }
3829
3830                 cur_off += 8;
3831               }
3832
3833             if (tls_type & GOT_TLS_IE)
3834               {
3835                 if (need_relocs)
3836                   {
3837                     outrel.r_offset = (globals->sgot->output_section->vma
3838                                        + globals->sgot->output_offset
3839                                        + cur_off);
3840                     outrel.r_info = ELF32_R_INFO (indx, R_ARM_TLS_TPOFF32);
3841
3842                     if (indx == 0)
3843                       bfd_put_32 (output_bfd, value - dtpoff_base (info),
3844                                   globals->sgot->contents + cur_off);
3845                     else
3846                       bfd_put_32 (output_bfd, 0,
3847                                   globals->sgot->contents + cur_off);
3848
3849                     bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3850                     globals->srelgot->reloc_count++;
3851                     loc += sizeof (Elf32_External_Rel);
3852                   }
3853                 else
3854                   bfd_put_32 (output_bfd, tpoff (info, value),
3855                               globals->sgot->contents + cur_off);
3856                 cur_off += 4;
3857               }
3858
3859             if (h != NULL)
3860               h->got.offset |= 1;
3861             else
3862               local_got_offsets[r_symndx] |= 1;
3863           }
3864
3865         if ((tls_type & GOT_TLS_GD) && r_type != R_ARM_TLS_GD32)
3866           off += 8;
3867         value = globals->sgot->output_section->vma + globals->sgot->output_offset + off
3868           - (input_section->output_section->vma + input_section->output_offset + rel->r_offset);
3869
3870         return _bfd_final_link_relocate (howto, input_bfd, input_section,
3871                                          contents, rel->r_offset, value,
3872                                          (bfd_vma) 0);
3873       }
3874
3875     case R_ARM_TLS_LE32:
3876       if (info->shared)
3877         {
3878           (*_bfd_error_handler)
3879             (_("%B(%A+0x%lx): R_ARM_TLS_LE32 relocation not permitted in shared object"),
3880              input_bfd, input_section,
3881              (long) rel->r_offset, howto->name);
3882           return FALSE;
3883         }
3884       else
3885         value = tpoff (info, value);
3886
3887       return _bfd_final_link_relocate (howto, input_bfd, input_section,
3888                                        contents, rel->r_offset, value, (bfd_vma) 0);
3889
3890     case R_ARM_V4BX:
3891       if (globals->fix_v4bx)
3892         {
3893           bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
3894
3895           /* Ensure that we have a BX instruction.  */
3896           BFD_ASSERT ((insn & 0x0ffffff0) == 0x012fff10);
3897
3898           /* Preserve Rm (lowest four bits) and the condition code
3899              (highest four bits). Other bits encode MOV PC,Rm.  */
3900           insn = (insn & 0xf000000f) | 0x01a0f000;
3901
3902           bfd_put_32 (input_bfd, insn, hit_data);
3903         }
3904       return bfd_reloc_ok;
3905
3906     default:
3907       return bfd_reloc_notsupported;
3908     }
3909 }
3910
3911 /* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS.  */
3912 static void
3913 arm_add_to_rel (bfd *              abfd,
3914                 bfd_byte *         address,
3915                 reloc_howto_type * howto,
3916                 bfd_signed_vma     increment)
3917 {
3918   bfd_signed_vma addend;
3919
3920   if (howto->type == R_ARM_THM_CALL)
3921     {
3922       int upper_insn, lower_insn;
3923       int upper, lower;
3924
3925       upper_insn = bfd_get_16 (abfd, address);
3926       lower_insn = bfd_get_16 (abfd, address + 2);
3927       upper = upper_insn & 0x7ff;
3928       lower = lower_insn & 0x7ff;
3929
3930       addend = (upper << 12) | (lower << 1);
3931       addend += increment;
3932       addend >>= 1;
3933
3934       upper_insn = (upper_insn & 0xf800) | ((addend >> 11) & 0x7ff);
3935       lower_insn = (lower_insn & 0xf800) | (addend & 0x7ff);
3936
3937       bfd_put_16 (abfd, (bfd_vma) upper_insn, address);
3938       bfd_put_16 (abfd, (bfd_vma) lower_insn, address + 2);
3939     }
3940   else
3941     {
3942       bfd_vma        contents;
3943
3944       contents = bfd_get_32 (abfd, address);
3945
3946       /* Get the (signed) value from the instruction.  */
3947       addend = contents & howto->src_mask;
3948       if (addend & ((howto->src_mask + 1) >> 1))
3949         {
3950           bfd_signed_vma mask;
3951
3952           mask = -1;
3953           mask &= ~ howto->src_mask;
3954           addend |= mask;
3955         }
3956
3957       /* Add in the increment, (which is a byte value).  */
3958       switch (howto->type)
3959         {
3960         default:
3961           addend += increment;
3962           break;
3963
3964         case R_ARM_PC24:
3965         case R_ARM_PLT32:
3966         case R_ARM_CALL:
3967         case R_ARM_JUMP24:
3968           addend <<= howto->size;
3969           addend += increment;
3970
3971           /* Should we check for overflow here ?  */
3972
3973           /* Drop any undesired bits.  */
3974           addend >>= howto->rightshift;
3975           break;
3976         }
3977
3978       contents = (contents & ~ howto->dst_mask) | (addend & howto->dst_mask);
3979
3980       bfd_put_32 (abfd, contents, address);
3981     }
3982 }
3983
3984 #define IS_ARM_TLS_RELOC(R_TYPE)        \
3985   ((R_TYPE) == R_ARM_TLS_GD32           \
3986    || (R_TYPE) == R_ARM_TLS_LDO32       \
3987    || (R_TYPE) == R_ARM_TLS_LDM32       \
3988    || (R_TYPE) == R_ARM_TLS_DTPOFF32    \
3989    || (R_TYPE) == R_ARM_TLS_DTPMOD32    \
3990    || (R_TYPE) == R_ARM_TLS_TPOFF32     \
3991    || (R_TYPE) == R_ARM_TLS_LE32        \
3992    || (R_TYPE) == R_ARM_TLS_IE32)
3993
3994 /* Relocate an ARM ELF section.  */
3995 static bfd_boolean
3996 elf32_arm_relocate_section (bfd *                  output_bfd,
3997                             struct bfd_link_info * info,
3998                             bfd *                  input_bfd,
3999                             asection *             input_section,
4000                             bfd_byte *             contents,
4001                             Elf_Internal_Rela *    relocs,
4002                             Elf_Internal_Sym *     local_syms,
4003                             asection **            local_sections)
4004 {
4005   Elf_Internal_Shdr *symtab_hdr;
4006   struct elf_link_hash_entry **sym_hashes;
4007   Elf_Internal_Rela *rel;
4008   Elf_Internal_Rela *relend;
4009   const char *name;
4010   struct elf32_arm_link_hash_table * globals;
4011
4012   globals = elf32_arm_hash_table (info);
4013   if (info->relocatable && !globals->use_rel)
4014     return TRUE;
4015
4016   symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
4017   sym_hashes = elf_sym_hashes (input_bfd);
4018
4019   rel = relocs;
4020   relend = relocs + input_section->reloc_count;
4021   for (; rel < relend; rel++)
4022     {
4023       int                          r_type;
4024       reloc_howto_type *           howto;
4025       unsigned long                r_symndx;
4026       Elf_Internal_Sym *           sym;
4027       asection *                   sec;
4028       struct elf_link_hash_entry * h;
4029       bfd_vma                      relocation;
4030       bfd_reloc_status_type        r;
4031       arelent                      bfd_reloc;
4032       char                         sym_type;
4033       bfd_boolean                  unresolved_reloc = FALSE;
4034
4035       r_symndx = ELF32_R_SYM (rel->r_info);
4036       r_type   = ELF32_R_TYPE (rel->r_info);
4037       r_type   = arm_real_reloc_type (globals, r_type);
4038
4039       if (   r_type == R_ARM_GNU_VTENTRY
4040           || r_type == R_ARM_GNU_VTINHERIT)
4041         continue;
4042
4043       bfd_reloc.howto = elf32_arm_howto_from_type (r_type);
4044       howto = bfd_reloc.howto;
4045
4046       if (info->relocatable && globals->use_rel)
4047         {
4048           /* This is a relocatable link.  We don't have to change
4049              anything, unless the reloc is against a section symbol,
4050              in which case we have to adjust according to where the
4051              section symbol winds up in the output section.  */
4052           if (r_symndx < symtab_hdr->sh_info)
4053             {
4054               sym = local_syms + r_symndx;
4055               if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4056                 {
4057                   sec = local_sections[r_symndx];
4058                   arm_add_to_rel (input_bfd, contents + rel->r_offset,
4059                                   howto,
4060                                   (bfd_signed_vma) (sec->output_offset
4061                                                     + sym->st_value));
4062                 }
4063             }
4064
4065           continue;
4066         }
4067
4068       /* This is a final link.  */
4069       h = NULL;
4070       sym = NULL;
4071       sec = NULL;
4072
4073       if (r_symndx < symtab_hdr->sh_info)
4074         {
4075           sym = local_syms + r_symndx;
4076           sym_type = ELF32_ST_TYPE (sym->st_info);
4077           sec = local_sections[r_symndx];
4078           if (globals->use_rel)
4079             {
4080               relocation = (sec->output_section->vma
4081                             + sec->output_offset
4082                             + sym->st_value);
4083               if ((sec->flags & SEC_MERGE)
4084                        && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4085                 {
4086                   asection *msec;
4087                   bfd_vma addend, value;
4088
4089                   if (howto->rightshift)
4090                     {
4091                       (*_bfd_error_handler)
4092                         (_("%B(%A+0x%lx): %s relocation against SEC_MERGE section"),
4093                          input_bfd, input_section,
4094                          (long) rel->r_offset, howto->name);
4095                       return FALSE;
4096                     }
4097
4098                   value = bfd_get_32 (input_bfd, contents + rel->r_offset);
4099
4100                   /* Get the (signed) value from the instruction.  */
4101                   addend = value & howto->src_mask;
4102                   if (addend & ((howto->src_mask + 1) >> 1))
4103                     {
4104                       bfd_signed_vma mask;
4105
4106                       mask = -1;
4107                       mask &= ~ howto->src_mask;
4108                       addend |= mask;
4109                     }
4110                   msec = sec;
4111                   addend =
4112                     _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend)
4113                     - relocation;
4114                   addend += msec->output_section->vma + msec->output_offset;
4115                   value = (value & ~ howto->dst_mask) | (addend & howto->dst_mask);
4116                   bfd_put_32 (input_bfd, value, contents + rel->r_offset);
4117                 }
4118             }
4119           else
4120             relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
4121         }
4122       else
4123         {
4124           bfd_boolean warned;
4125
4126           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
4127                                    r_symndx, symtab_hdr, sym_hashes,
4128                                    h, sec, relocation,
4129                                    unresolved_reloc, warned);
4130
4131           sym_type = h->type;
4132         }
4133
4134       if (h != NULL)
4135         name = h->root.root.string;
4136       else
4137         {
4138           name = (bfd_elf_string_from_elf_section
4139                   (input_bfd, symtab_hdr->sh_link, sym->st_name));
4140           if (name == NULL || *name == '\0')
4141             name = bfd_section_name (input_bfd, sec);
4142         }
4143
4144       if (r_symndx != 0
4145           && r_type != R_ARM_NONE
4146           && (h == NULL
4147               || h->root.type == bfd_link_hash_defined
4148               || h->root.type == bfd_link_hash_defweak)
4149           && IS_ARM_TLS_RELOC (r_type) != (sym_type == STT_TLS))
4150         {
4151           (*_bfd_error_handler)
4152             ((sym_type == STT_TLS
4153               ? _("%B(%A+0x%lx): %s used with TLS symbol %s")
4154               : _("%B(%A+0x%lx): %s used with non-TLS symbol %s")),
4155              input_bfd,
4156              input_section,
4157              (long) rel->r_offset,
4158              howto->name,
4159              name);
4160         }
4161
4162       r = elf32_arm_final_link_relocate (howto, input_bfd, output_bfd,
4163                                          input_section, contents, rel,
4164                                          relocation, info, sec, name,
4165                                          (h ? ELF_ST_TYPE (h->type) :
4166                                           ELF_ST_TYPE (sym->st_info)), h,
4167                                          &unresolved_reloc);
4168
4169       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4170          because such sections are not SEC_ALLOC and thus ld.so will
4171          not process them.  */
4172       if (unresolved_reloc
4173           && !((input_section->flags & SEC_DEBUGGING) != 0
4174                && h->def_dynamic))
4175         {
4176           (*_bfd_error_handler)
4177             (_("%B(%A+0x%lx): warning: unresolvable relocation %d against symbol `%s'"),
4178              input_bfd, input_section, (long) rel->r_offset,
4179              r_type, h->root.root.string);
4180           return FALSE;
4181         }
4182
4183       if (r != bfd_reloc_ok)
4184         {
4185           const char * msg = (const char *) 0;
4186
4187           switch (r)
4188             {
4189             case bfd_reloc_overflow:
4190               /* If the overflowing reloc was to an undefined symbol,
4191                  we have already printed one error message and there
4192                  is no point complaining again.  */
4193               if ((! h ||
4194                    h->root.type != bfd_link_hash_undefined)
4195                   && (!((*info->callbacks->reloc_overflow)
4196                         (info, (h ? &h->root : NULL), name, howto->name,
4197                          (bfd_vma) 0, input_bfd, input_section,
4198                          rel->r_offset))))
4199                   return FALSE;
4200               break;
4201
4202             case bfd_reloc_undefined:
4203               if (!((*info->callbacks->undefined_symbol)
4204                     (info, name, input_bfd, input_section,
4205                      rel->r_offset, TRUE)))
4206                 return FALSE;
4207               break;
4208
4209             case bfd_reloc_outofrange:
4210               msg = _("internal error: out of range error");
4211               goto common_error;
4212
4213             case bfd_reloc_notsupported:
4214               msg = _("internal error: unsupported relocation error");
4215               goto common_error;
4216
4217             case bfd_reloc_dangerous:
4218               msg = _("internal error: dangerous error");
4219               goto common_error;
4220
4221             default:
4222               msg = _("internal error: unknown error");
4223               /* fall through */
4224
4225             common_error:
4226               if (!((*info->callbacks->warning)
4227                     (info, msg, name, input_bfd, input_section,
4228                      rel->r_offset)))
4229                 return FALSE;
4230               break;
4231             }
4232         }
4233     }
4234
4235   return TRUE;
4236 }
4237
4238 /* Set the right machine number.  */
4239
4240 static bfd_boolean
4241 elf32_arm_object_p (bfd *abfd)
4242 {
4243   unsigned int mach;
4244
4245   mach = bfd_arm_get_mach_from_notes (abfd, ARM_NOTE_SECTION);
4246
4247   if (mach != bfd_mach_arm_unknown)
4248     bfd_default_set_arch_mach (abfd, bfd_arch_arm, mach);
4249
4250   else if (elf_elfheader (abfd)->e_flags & EF_ARM_MAVERICK_FLOAT)
4251     bfd_default_set_arch_mach (abfd, bfd_arch_arm, bfd_mach_arm_ep9312);
4252
4253   else
4254     bfd_default_set_arch_mach (abfd, bfd_arch_arm, mach);
4255
4256   return TRUE;
4257 }
4258
4259 /* Function to keep ARM specific flags in the ELF header.  */
4260
4261 static bfd_boolean
4262 elf32_arm_set_private_flags (bfd *abfd, flagword flags)
4263 {
4264   if (elf_flags_init (abfd)
4265       && elf_elfheader (abfd)->e_flags != flags)
4266     {
4267       if (EF_ARM_EABI_VERSION (flags) == EF_ARM_EABI_UNKNOWN)
4268         {
4269           if (flags & EF_ARM_INTERWORK)
4270             (*_bfd_error_handler)
4271               (_("Warning: Not setting interworking flag of %B since it has already been specified as non-interworking"),
4272                abfd);
4273           else
4274             _bfd_error_handler
4275               (_("Warning: Clearing the interworking flag of %B due to outside request"),
4276                abfd);
4277         }
4278     }
4279   else
4280     {
4281       elf_elfheader (abfd)->e_flags = flags;
4282       elf_flags_init (abfd) = TRUE;
4283     }
4284
4285   return TRUE;
4286 }
4287
4288 /* Copy backend specific data from one object module to another.  */
4289
4290 static bfd_boolean
4291 elf32_arm_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
4292 {
4293   flagword in_flags;
4294   flagword out_flags;
4295
4296   if (   bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4297       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4298     return TRUE;
4299
4300   in_flags  = elf_elfheader (ibfd)->e_flags;
4301   out_flags = elf_elfheader (obfd)->e_flags;
4302
4303   if (elf_flags_init (obfd)
4304       && EF_ARM_EABI_VERSION (out_flags) == EF_ARM_EABI_UNKNOWN
4305       && in_flags != out_flags)
4306     {
4307       /* Cannot mix APCS26 and APCS32 code.  */
4308       if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
4309         return FALSE;
4310
4311       /* Cannot mix float APCS and non-float APCS code.  */
4312       if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
4313         return FALSE;
4314
4315       /* If the src and dest have different interworking flags
4316          then turn off the interworking bit.  */
4317       if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
4318         {
4319           if (out_flags & EF_ARM_INTERWORK)
4320             _bfd_error_handler
4321               (_("Warning: Clearing the interworking flag of %B because non-interworking code in %B has been linked with it"),
4322                obfd, ibfd);
4323
4324           in_flags &= ~EF_ARM_INTERWORK;
4325         }
4326
4327       /* Likewise for PIC, though don't warn for this case.  */
4328       if ((in_flags & EF_ARM_PIC) != (out_flags & EF_ARM_PIC))
4329         in_flags &= ~EF_ARM_PIC;
4330     }
4331
4332   elf_elfheader (obfd)->e_flags = in_flags;
4333   elf_flags_init (obfd) = TRUE;
4334
4335   /* Also copy the EI_OSABI field.  */
4336   elf_elfheader (obfd)->e_ident[EI_OSABI] =
4337     elf_elfheader (ibfd)->e_ident[EI_OSABI];
4338
4339   return TRUE;
4340 }
4341
4342 /* Merge backend specific data from an object file to the output
4343    object file when linking.  */
4344
4345 static bfd_boolean
4346 elf32_arm_merge_private_bfd_data (bfd * ibfd, bfd * obfd)
4347 {
4348   flagword out_flags;
4349   flagword in_flags;
4350   bfd_boolean flags_compatible = TRUE;
4351   asection *sec;
4352
4353   /* Check if we have the same endianess.  */
4354   if (! _bfd_generic_verify_endian_match (ibfd, obfd))
4355     return FALSE;
4356
4357   if (   bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4358       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4359     return TRUE;
4360
4361   /* The input BFD must have had its flags initialised.  */
4362   /* The following seems bogus to me -- The flags are initialized in
4363      the assembler but I don't think an elf_flags_init field is
4364      written into the object.  */
4365   /* BFD_ASSERT (elf_flags_init (ibfd)); */
4366
4367   in_flags  = elf_elfheader (ibfd)->e_flags;
4368   out_flags = elf_elfheader (obfd)->e_flags;
4369
4370   if (!elf_flags_init (obfd))
4371     {
4372       /* If the input is the default architecture and had the default
4373          flags then do not bother setting the flags for the output
4374          architecture, instead allow future merges to do this.  If no
4375          future merges ever set these flags then they will retain their
4376          uninitialised values, which surprise surprise, correspond
4377          to the default values.  */
4378       if (bfd_get_arch_info (ibfd)->the_default
4379           && elf_elfheader (ibfd)->e_flags == 0)
4380         return TRUE;
4381
4382       elf_flags_init (obfd) = TRUE;
4383       elf_elfheader (obfd)->e_flags = in_flags;
4384
4385       if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
4386           && bfd_get_arch_info (obfd)->the_default)
4387         return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
4388
4389       return TRUE;
4390     }
4391
4392   /* Determine what should happen if the input ARM architecture
4393      does not match the output ARM architecture.  */
4394   if (! bfd_arm_merge_machines (ibfd, obfd))
4395     return FALSE;
4396
4397   /* Identical flags must be compatible.  */
4398   if (in_flags == out_flags)
4399     return TRUE;
4400
4401   /* Check to see if the input BFD actually contains any sections.  If
4402      not, its flags may not have been initialised either, but it
4403      cannot actually cause any incompatibility.  Do not short-circuit
4404      dynamic objects; their section list may be emptied by
4405     elf_link_add_object_symbols.
4406
4407     Also check to see if there are no code sections in the input.
4408     In this case there is no need to check for code specific flags.
4409     XXX - do we need to worry about floating-point format compatability
4410     in data sections ?  */
4411   if (!(ibfd->flags & DYNAMIC))
4412     {
4413       bfd_boolean null_input_bfd = TRUE;
4414       bfd_boolean only_data_sections = TRUE;
4415
4416       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
4417         {
4418           /* Ignore synthetic glue sections.  */
4419           if (strcmp (sec->name, ".glue_7")
4420               && strcmp (sec->name, ".glue_7t"))
4421             {
4422               if ((bfd_get_section_flags (ibfd, sec)
4423                    & (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS))
4424                   == (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS))
4425                 only_data_sections = FALSE;
4426
4427               null_input_bfd = FALSE;
4428               break;
4429             }
4430         }
4431
4432       if (null_input_bfd || only_data_sections)
4433         return TRUE;
4434     }
4435
4436   /* Complain about various flag mismatches.  */
4437   if (EF_ARM_EABI_VERSION (in_flags) != EF_ARM_EABI_VERSION (out_flags))
4438     {
4439       _bfd_error_handler
4440         (_("ERROR: Source object %B has EABI version %d, but target %B has EABI version %d"),
4441          ibfd, obfd,
4442          (in_flags & EF_ARM_EABIMASK) >> 24,
4443          (out_flags & EF_ARM_EABIMASK) >> 24);
4444       return FALSE;
4445     }
4446
4447   /* Not sure what needs to be checked for EABI versions >= 1.  */
4448   if (EF_ARM_EABI_VERSION (in_flags) == EF_ARM_EABI_UNKNOWN)
4449     {
4450       if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
4451         {
4452           _bfd_error_handler
4453             (_("ERROR: %B is compiled for APCS-%d, whereas target %B uses APCS-%d"),
4454              ibfd, obfd,
4455              in_flags & EF_ARM_APCS_26 ? 26 : 32,
4456              out_flags & EF_ARM_APCS_26 ? 26 : 32);
4457           flags_compatible = FALSE;
4458         }
4459
4460       if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
4461         {
4462           if (in_flags & EF_ARM_APCS_FLOAT)
4463             _bfd_error_handler
4464               (_("ERROR: %B passes floats in float registers, whereas %B passes them in integer registers"),
4465                ibfd, obfd);
4466           else
4467             _bfd_error_handler
4468               (_("ERROR: %B passes floats in integer registers, whereas %B passes them in float registers"),
4469                ibfd, obfd);
4470
4471           flags_compatible = FALSE;
4472         }
4473
4474       if ((in_flags & EF_ARM_VFP_FLOAT) != (out_flags & EF_ARM_VFP_FLOAT))
4475         {
4476           if (in_flags & EF_ARM_VFP_FLOAT)
4477             _bfd_error_handler
4478               (_("ERROR: %B uses VFP instructions, whereas %B does not"),
4479                ibfd, obfd);
4480           else
4481             _bfd_error_handler
4482               (_("ERROR: %B uses FPA instructions, whereas %B does not"),
4483                ibfd, obfd);
4484
4485           flags_compatible = FALSE;
4486         }
4487
4488       if ((in_flags & EF_ARM_MAVERICK_FLOAT) != (out_flags & EF_ARM_MAVERICK_FLOAT))
4489         {
4490           if (in_flags & EF_ARM_MAVERICK_FLOAT)
4491             _bfd_error_handler
4492               (_("ERROR: %B uses Maverick instructions, whereas %B does not"),
4493                ibfd, obfd);
4494           else
4495             _bfd_error_handler
4496               (_("ERROR: %B does not use Maverick instructions, whereas %B does"),
4497                ibfd, obfd);
4498
4499           flags_compatible = FALSE;
4500         }
4501
4502 #ifdef EF_ARM_SOFT_FLOAT
4503       if ((in_flags & EF_ARM_SOFT_FLOAT) != (out_flags & EF_ARM_SOFT_FLOAT))
4504         {
4505           /* We can allow interworking between code that is VFP format
4506              layout, and uses either soft float or integer regs for
4507              passing floating point arguments and results.  We already
4508              know that the APCS_FLOAT flags match; similarly for VFP
4509              flags.  */
4510           if ((in_flags & EF_ARM_APCS_FLOAT) != 0
4511               || (in_flags & EF_ARM_VFP_FLOAT) == 0)
4512             {
4513               if (in_flags & EF_ARM_SOFT_FLOAT)
4514                 _bfd_error_handler
4515                   (_("ERROR: %B uses software FP, whereas %B uses hardware FP"),
4516                    ibfd, obfd);
4517               else
4518                 _bfd_error_handler
4519                   (_("ERROR: %B uses hardware FP, whereas %B uses software FP"),
4520                    ibfd, obfd);
4521
4522               flags_compatible = FALSE;
4523             }
4524         }
4525 #endif
4526
4527       /* Interworking mismatch is only a warning.  */
4528       if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
4529         {
4530           if (in_flags & EF_ARM_INTERWORK)
4531             {
4532               _bfd_error_handler
4533                 (_("Warning: %B supports interworking, whereas %B does not"),
4534                  ibfd, obfd);
4535             }
4536           else
4537             {
4538               _bfd_error_handler
4539                 (_("Warning: %B does not support interworking, whereas %B does"),
4540                  ibfd, obfd);
4541             }
4542         }
4543     }
4544
4545   return flags_compatible;
4546 }
4547
4548 /* Display the flags field.  */
4549
4550 static bfd_boolean
4551 elf32_arm_print_private_bfd_data (bfd *abfd, void * ptr)
4552 {
4553   FILE * file = (FILE *) ptr;
4554   unsigned long flags;
4555
4556   BFD_ASSERT (abfd != NULL && ptr != NULL);
4557
4558   /* Print normal ELF private data.  */
4559   _bfd_elf_print_private_bfd_data (abfd, ptr);
4560
4561   flags = elf_elfheader (abfd)->e_flags;
4562   /* Ignore init flag - it may not be set, despite the flags field
4563      containing valid data.  */
4564
4565   /* xgettext:c-format */
4566   fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
4567
4568   switch (EF_ARM_EABI_VERSION (flags))
4569     {
4570     case EF_ARM_EABI_UNKNOWN:
4571       /* The following flag bits are GNU extensions and not part of the
4572          official ARM ELF extended ABI.  Hence they are only decoded if
4573          the EABI version is not set.  */
4574       if (flags & EF_ARM_INTERWORK)
4575         fprintf (file, _(" [interworking enabled]"));
4576
4577       if (flags & EF_ARM_APCS_26)
4578         fprintf (file, " [APCS-26]");
4579       else
4580         fprintf (file, " [APCS-32]");
4581
4582       if (flags & EF_ARM_VFP_FLOAT)
4583         fprintf (file, _(" [VFP float format]"));
4584       else if (flags & EF_ARM_MAVERICK_FLOAT)
4585         fprintf (file, _(" [Maverick float format]"));
4586       else
4587         fprintf (file, _(" [FPA float format]"));
4588
4589       if (flags & EF_ARM_APCS_FLOAT)
4590         fprintf (file, _(" [floats passed in float registers]"));
4591
4592       if (flags & EF_ARM_PIC)
4593         fprintf (file, _(" [position independent]"));
4594
4595       if (flags & EF_ARM_NEW_ABI)
4596         fprintf (file, _(" [new ABI]"));
4597
4598       if (flags & EF_ARM_OLD_ABI)
4599         fprintf (file, _(" [old ABI]"));
4600
4601       if (flags & EF_ARM_SOFT_FLOAT)
4602         fprintf (file, _(" [software FP]"));
4603
4604       flags &= ~(EF_ARM_INTERWORK | EF_ARM_APCS_26 | EF_ARM_APCS_FLOAT
4605                  | EF_ARM_PIC | EF_ARM_NEW_ABI | EF_ARM_OLD_ABI
4606                  | EF_ARM_SOFT_FLOAT | EF_ARM_VFP_FLOAT
4607                  | EF_ARM_MAVERICK_FLOAT);
4608       break;
4609
4610     case EF_ARM_EABI_VER1:
4611       fprintf (file, _(" [Version1 EABI]"));
4612
4613       if (flags & EF_ARM_SYMSARESORTED)
4614         fprintf (file, _(" [sorted symbol table]"));
4615       else
4616         fprintf (file, _(" [unsorted symbol table]"));
4617
4618       flags &= ~ EF_ARM_SYMSARESORTED;
4619       break;
4620
4621     case EF_ARM_EABI_VER2:
4622       fprintf (file, _(" [Version2 EABI]"));
4623
4624       if (flags & EF_ARM_SYMSARESORTED)
4625         fprintf (file, _(" [sorted symbol table]"));
4626       else
4627         fprintf (file, _(" [unsorted symbol table]"));
4628
4629       if (flags & EF_ARM_DYNSYMSUSESEGIDX)
4630         fprintf (file, _(" [dynamic symbols use segment index]"));
4631
4632       if (flags & EF_ARM_MAPSYMSFIRST)
4633         fprintf (file, _(" [mapping symbols precede others]"));
4634
4635       flags &= ~(EF_ARM_SYMSARESORTED | EF_ARM_DYNSYMSUSESEGIDX
4636                  | EF_ARM_MAPSYMSFIRST);
4637       break;
4638
4639     case EF_ARM_EABI_VER3:
4640       fprintf (file, _(" [Version3 EABI]"));
4641       break;
4642
4643     case EF_ARM_EABI_VER4:
4644       fprintf (file, _(" [Version4 EABI]"));
4645
4646       if (flags & EF_ARM_BE8)
4647         fprintf (file, _(" [BE8]"));
4648
4649       if (flags & EF_ARM_LE8)
4650         fprintf (file, _(" [LE8]"));
4651
4652       flags &= ~(EF_ARM_LE8 | EF_ARM_BE8);
4653       break;
4654
4655     default:
4656       fprintf (file, _(" <EABI version unrecognised>"));
4657       break;
4658     }
4659
4660   flags &= ~ EF_ARM_EABIMASK;
4661
4662   if (flags & EF_ARM_RELEXEC)
4663     fprintf (file, _(" [relocatable executable]"));
4664
4665   if (flags & EF_ARM_HASENTRY)
4666     fprintf (file, _(" [has entry point]"));
4667
4668   flags &= ~ (EF_ARM_RELEXEC | EF_ARM_HASENTRY);
4669
4670   if (flags)
4671     fprintf (file, _("<Unrecognised flag bits set>"));
4672
4673   fputc ('\n', file);
4674
4675   return TRUE;
4676 }
4677
4678 static int
4679 elf32_arm_get_symbol_type (Elf_Internal_Sym * elf_sym, int type)
4680 {
4681   switch (ELF_ST_TYPE (elf_sym->st_info))
4682     {
4683     case STT_ARM_TFUNC:
4684       return ELF_ST_TYPE (elf_sym->st_info);
4685
4686     case STT_ARM_16BIT:
4687       /* If the symbol is not an object, return the STT_ARM_16BIT flag.
4688          This allows us to distinguish between data used by Thumb instructions
4689          and non-data (which is probably code) inside Thumb regions of an
4690          executable.  */
4691       if (type != STT_OBJECT)
4692         return ELF_ST_TYPE (elf_sym->st_info);
4693       break;
4694
4695     default:
4696       break;
4697     }
4698
4699   return type;
4700 }
4701
4702 static asection *
4703 elf32_arm_gc_mark_hook (asection *                   sec,
4704                         struct bfd_link_info *       info ATTRIBUTE_UNUSED,
4705                         Elf_Internal_Rela *          rel,
4706                         struct elf_link_hash_entry * h,
4707                         Elf_Internal_Sym *           sym)
4708 {
4709   if (h != NULL)
4710     {
4711       switch (ELF32_R_TYPE (rel->r_info))
4712       {
4713       case R_ARM_GNU_VTINHERIT:
4714       case R_ARM_GNU_VTENTRY:
4715         break;
4716
4717       default:
4718         switch (h->root.type)
4719           {
4720           case bfd_link_hash_defined:
4721           case bfd_link_hash_defweak:
4722             return h->root.u.def.section;
4723
4724           case bfd_link_hash_common:
4725             return h->root.u.c.p->section;
4726
4727           default:
4728             break;
4729           }
4730        }
4731      }
4732    else
4733      return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
4734
4735   return NULL;
4736 }
4737
4738 /* Update the got entry reference counts for the section being removed.  */
4739
4740 static bfd_boolean
4741 elf32_arm_gc_sweep_hook (bfd *                     abfd,
4742                          struct bfd_link_info *    info,
4743                          asection *                sec,
4744                          const Elf_Internal_Rela * relocs)
4745 {
4746   Elf_Internal_Shdr *symtab_hdr;
4747   struct elf_link_hash_entry **sym_hashes;
4748   bfd_signed_vma *local_got_refcounts;
4749   const Elf_Internal_Rela *rel, *relend;
4750   struct elf32_arm_link_hash_table * globals;
4751
4752   globals = elf32_arm_hash_table (info);
4753
4754   elf_section_data (sec)->local_dynrel = NULL;
4755
4756   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
4757   sym_hashes = elf_sym_hashes (abfd);
4758   local_got_refcounts = elf_local_got_refcounts (abfd);
4759
4760   relend = relocs + sec->reloc_count;
4761   for (rel = relocs; rel < relend; rel++)
4762     {
4763       unsigned long r_symndx;
4764       struct elf_link_hash_entry *h = NULL;
4765       int r_type;
4766
4767       r_symndx = ELF32_R_SYM (rel->r_info);
4768       if (r_symndx >= symtab_hdr->sh_info)
4769         {
4770           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4771           while (h->root.type == bfd_link_hash_indirect
4772                  || h->root.type == bfd_link_hash_warning)
4773             h = (struct elf_link_hash_entry *) h->root.u.i.link;
4774         }
4775
4776       r_type = ELF32_R_TYPE (rel->r_info);
4777       r_type = arm_real_reloc_type (globals, r_type);
4778       switch (r_type)
4779         {
4780         case R_ARM_GOT32:
4781         case R_ARM_GOT_PREL:
4782         case R_ARM_TLS_GD32:
4783         case R_ARM_TLS_IE32:
4784           if (h != NULL)
4785             {
4786               if (h->got.refcount > 0)
4787                 h->got.refcount -= 1;
4788             }
4789           else if (local_got_refcounts != NULL)
4790             {
4791               if (local_got_refcounts[r_symndx] > 0)
4792                 local_got_refcounts[r_symndx] -= 1;
4793             }
4794           break;
4795
4796         case R_ARM_TLS_LDM32:
4797           elf32_arm_hash_table (info)->tls_ldm_got.refcount -= 1;
4798           break;
4799
4800         case R_ARM_ABS32:
4801         case R_ARM_REL32:
4802         case R_ARM_PC24:
4803         case R_ARM_PLT32:
4804         case R_ARM_CALL:
4805         case R_ARM_JUMP24:
4806         case R_ARM_PREL31:
4807         case R_ARM_THM_CALL:
4808           /* Should the interworking branches be here also?  */
4809
4810           if (h != NULL)
4811             {
4812               struct elf32_arm_link_hash_entry *eh;
4813               struct elf32_arm_relocs_copied **pp;
4814               struct elf32_arm_relocs_copied *p;
4815
4816               eh = (struct elf32_arm_link_hash_entry *) h;
4817
4818               if (h->plt.refcount > 0)
4819                 {
4820                   h->plt.refcount -= 1;
4821                   if (ELF32_R_TYPE (rel->r_info) == R_ARM_THM_CALL)
4822                     eh->plt_thumb_refcount--;
4823                 }
4824
4825               if (r_type == R_ARM_ABS32
4826                   || r_type == R_ARM_REL32)
4827                 {
4828                   for (pp = &eh->relocs_copied; (p = *pp) != NULL;
4829                        pp = &p->next)
4830                   if (p->section == sec)
4831                     {
4832                       p->count -= 1;
4833                       if (ELF32_R_TYPE (rel->r_info) == R_ARM_REL32)
4834                         p->pc_count -= 1;
4835                       if (p->count == 0)
4836                         *pp = p->next;
4837                       break;
4838                     }
4839                 }
4840             }
4841           break;
4842
4843         default:
4844           break;
4845         }
4846     }
4847
4848   return TRUE;
4849 }
4850
4851 /* Look through the relocs for a section during the first phase.  */
4852
4853 static bfd_boolean
4854 elf32_arm_check_relocs (bfd *abfd, struct bfd_link_info *info,
4855                         asection *sec, const Elf_Internal_Rela *relocs)
4856 {
4857   Elf_Internal_Shdr *symtab_hdr;
4858   struct elf_link_hash_entry **sym_hashes;
4859   struct elf_link_hash_entry **sym_hashes_end;
4860   const Elf_Internal_Rela *rel;
4861   const Elf_Internal_Rela *rel_end;
4862   bfd *dynobj;
4863   asection *sreloc;
4864   bfd_vma *local_got_offsets;
4865   struct elf32_arm_link_hash_table *htab;
4866
4867   if (info->relocatable)
4868     return TRUE;
4869
4870   htab = elf32_arm_hash_table (info);
4871   sreloc = NULL;
4872
4873   /* Create dynamic sections for relocatable executables so that we can
4874      copy relocations.  */
4875   if (htab->root.is_relocatable_executable
4876       && ! htab->root.dynamic_sections_created)
4877     {
4878       if (! _bfd_elf_link_create_dynamic_sections (abfd, info))
4879         return FALSE;
4880     }
4881
4882   dynobj = elf_hash_table (info)->dynobj;
4883   local_got_offsets = elf_local_got_offsets (abfd);
4884
4885   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
4886   sym_hashes = elf_sym_hashes (abfd);
4887   sym_hashes_end = sym_hashes
4888     + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
4889
4890   if (!elf_bad_symtab (abfd))
4891     sym_hashes_end -= symtab_hdr->sh_info;
4892
4893   rel_end = relocs + sec->reloc_count;
4894   for (rel = relocs; rel < rel_end; rel++)
4895     {
4896       struct elf_link_hash_entry *h;
4897       struct elf32_arm_link_hash_entry *eh;
4898       unsigned long r_symndx;
4899       int r_type;
4900
4901       r_symndx = ELF32_R_SYM (rel->r_info);
4902       r_type = ELF32_R_TYPE (rel->r_info);
4903       r_type = arm_real_reloc_type (htab, r_type);
4904
4905       if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
4906         {
4907           (*_bfd_error_handler) (_("%B: bad symbol index: %d"), abfd,
4908                                  r_symndx);
4909           return FALSE;
4910         }
4911
4912       if (r_symndx < symtab_hdr->sh_info)
4913         h = NULL;
4914       else
4915         h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4916
4917       eh = (struct elf32_arm_link_hash_entry *) h;
4918
4919       switch (r_type)
4920         {
4921           case R_ARM_GOT32:
4922           case R_ARM_GOT_PREL:
4923           case R_ARM_TLS_GD32:
4924           case R_ARM_TLS_IE32:
4925             /* This symbol requires a global offset table entry.  */
4926             {
4927               int tls_type, old_tls_type;
4928
4929               switch (r_type)
4930                 {
4931                 case R_ARM_TLS_GD32: tls_type = GOT_TLS_GD; break;
4932                 case R_ARM_TLS_IE32: tls_type = GOT_TLS_IE; break;
4933                 default: tls_type = GOT_NORMAL; break;
4934                 }
4935
4936               if (h != NULL)
4937                 {
4938                   h->got.refcount++;
4939                   old_tls_type = elf32_arm_hash_entry (h)->tls_type;
4940                 }
4941               else
4942                 {
4943                   bfd_signed_vma *local_got_refcounts;
4944
4945                   /* This is a global offset table entry for a local symbol.  */
4946                   local_got_refcounts = elf_local_got_refcounts (abfd);
4947                   if (local_got_refcounts == NULL)
4948                     {
4949                       bfd_size_type size;
4950
4951                       size = symtab_hdr->sh_info;
4952                       size *= (sizeof (bfd_signed_vma) + sizeof(char));
4953                       local_got_refcounts = bfd_zalloc (abfd, size);
4954                       if (local_got_refcounts == NULL)
4955                         return FALSE;
4956                       elf_local_got_refcounts (abfd) = local_got_refcounts;
4957                       elf32_arm_local_got_tls_type (abfd)
4958                         = (char *) (local_got_refcounts + symtab_hdr->sh_info);
4959                     }
4960                   local_got_refcounts[r_symndx] += 1;
4961                   old_tls_type = elf32_arm_local_got_tls_type (abfd) [r_symndx];
4962                 }
4963
4964               /* We will already have issued an error message if there is a
4965                  TLS / non-TLS mismatch, based on the symbol type.  We don't
4966                  support any linker relaxations.  So just combine any TLS
4967                  types needed.  */
4968               if (old_tls_type != GOT_UNKNOWN && old_tls_type != GOT_NORMAL
4969                   && tls_type != GOT_NORMAL)
4970                 tls_type |= old_tls_type;
4971
4972               if (old_tls_type != tls_type)
4973                 {
4974                   if (h != NULL)
4975                     elf32_arm_hash_entry (h)->tls_type = tls_type;
4976                   else
4977                     elf32_arm_local_got_tls_type (abfd) [r_symndx] = tls_type;
4978                 }
4979             }
4980             /* Fall through */
4981
4982           case R_ARM_TLS_LDM32:
4983             if (r_type == R_ARM_TLS_LDM32)
4984                 htab->tls_ldm_got.refcount++;
4985             /* Fall through */
4986
4987           case R_ARM_GOTOFF32:
4988           case R_ARM_GOTPC:
4989             if (htab->sgot == NULL)
4990               {
4991                 if (htab->root.dynobj == NULL)
4992                   htab->root.dynobj = abfd;
4993                 if (!create_got_section (htab->root.dynobj, info))
4994                   return FALSE;
4995               }
4996             break;
4997
4998           case R_ARM_ABS32:
4999           case R_ARM_REL32:
5000           case R_ARM_PC24:
5001           case R_ARM_PLT32:
5002           case R_ARM_CALL:
5003           case R_ARM_JUMP24:
5004           case R_ARM_PREL31:
5005           case R_ARM_THM_CALL:
5006             /* Should the interworking branches be listed here?  */
5007             if (h != NULL)
5008               {
5009                 /* If this reloc is in a read-only section, we might
5010                    need a copy reloc.  We can't check reliably at this
5011                    stage whether the section is read-only, as input
5012                    sections have not yet been mapped to output sections.
5013                    Tentatively set the flag for now, and correct in
5014                    adjust_dynamic_symbol.  */
5015                 if (!info->shared)
5016                   h->non_got_ref = 1;
5017
5018                 /* We may need a .plt entry if the function this reloc
5019                    refers to is in a different object.  We can't tell for
5020                    sure yet, because something later might force the
5021                    symbol local.  */
5022                 if (r_type == R_ARM_PC24
5023                     || r_type == R_ARM_CALL
5024                     || r_type == R_ARM_JUMP24
5025                     || r_type == R_ARM_PREL31
5026                     || r_type == R_ARM_PLT32
5027                     || r_type == R_ARM_THM_CALL)
5028                   h->needs_plt = 1;
5029
5030                 /* If we create a PLT entry, this relocation will reference
5031                    it, even if it's an ABS32 relocation.  */
5032                 h->plt.refcount += 1;
5033
5034                 if (r_type == R_ARM_THM_CALL)
5035                   eh->plt_thumb_refcount += 1;
5036               }
5037
5038             /* If we are creating a shared library or relocatable executable,
5039                and this is a reloc against a global symbol, or a non PC
5040                relative reloc against a local symbol, then we need to copy
5041                the reloc into the shared library.  However, if we are linking
5042                with -Bsymbolic, we do not need to copy a reloc against a
5043                global symbol which is defined in an object we are
5044                including in the link (i.e., DEF_REGULAR is set).  At
5045                this point we have not seen all the input files, so it is
5046                possible that DEF_REGULAR is not set now but will be set
5047                later (it is never cleared).  We account for that
5048                possibility below by storing information in the
5049                relocs_copied field of the hash table entry.  */
5050             if ((info->shared || htab->root.is_relocatable_executable)
5051                 && (sec->flags & SEC_ALLOC) != 0
5052                 && (r_type == R_ARM_ABS32
5053                     || (h != NULL && ! h->needs_plt
5054                         && (! info->symbolic || ! h->def_regular))))
5055               {
5056                 struct elf32_arm_relocs_copied *p, **head;
5057
5058                 /* When creating a shared object, we must copy these
5059                    reloc types into the output file.  We create a reloc
5060                    section in dynobj and make room for this reloc.  */
5061                 if (sreloc == NULL)
5062                   {
5063                     const char * name;
5064
5065                     name = (bfd_elf_string_from_elf_section
5066                             (abfd,
5067                              elf_elfheader (abfd)->e_shstrndx,
5068                              elf_section_data (sec)->rel_hdr.sh_name));
5069                     if (name == NULL)
5070                       return FALSE;
5071
5072                     BFD_ASSERT (strncmp (name, ".rel", 4) == 0
5073                                 && strcmp (bfd_get_section_name (abfd, sec),
5074                                            name + 4) == 0);
5075
5076                     sreloc = bfd_get_section_by_name (dynobj, name);
5077                     if (sreloc == NULL)
5078                       {
5079                         flagword flags;
5080
5081                         flags = (SEC_HAS_CONTENTS | SEC_READONLY
5082                                  | SEC_IN_MEMORY | SEC_LINKER_CREATED);
5083                         if ((sec->flags & SEC_ALLOC) != 0
5084                             /* BPABI objects never have dynamic
5085                                relocations mapped.  */
5086                             && !htab->symbian_p)
5087                           flags |= SEC_ALLOC | SEC_LOAD;
5088                         sreloc = bfd_make_section_with_flags (dynobj,
5089                                                               name,
5090                                                               flags);
5091                         if (sreloc == NULL
5092                             || ! bfd_set_section_alignment (dynobj, sreloc, 2))
5093                           return FALSE;
5094                       }
5095
5096                     elf_section_data (sec)->sreloc = sreloc;
5097                   }
5098
5099                 /* If this is a global symbol, we count the number of
5100                    relocations we need for this symbol.  */
5101                 if (h != NULL)
5102                   {
5103                     head = &((struct elf32_arm_link_hash_entry *) h)->relocs_copied;
5104                   }
5105                 else
5106                   {
5107                     /* Track dynamic relocs needed for local syms too.
5108                        We really need local syms available to do this
5109                        easily.  Oh well.  */
5110
5111                     asection *s;
5112                     s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
5113                                                    sec, r_symndx);
5114                     if (s == NULL)
5115                       return FALSE;
5116
5117                     head = ((struct elf32_arm_relocs_copied **)
5118                             &elf_section_data (s)->local_dynrel);
5119                   }
5120
5121                 p = *head;
5122                 if (p == NULL || p->section != sec)
5123                   {
5124                     bfd_size_type amt = sizeof *p;
5125
5126                     p = bfd_alloc (htab->root.dynobj, amt);
5127                     if (p == NULL)
5128                       return FALSE;
5129                     p->next = *head;
5130                     *head = p;
5131                     p->section = sec;
5132                     p->count = 0;
5133                     p->pc_count = 0;
5134                   }
5135
5136                 if (r_type == R_ARM_REL32)
5137                   p->pc_count += 1;
5138                 p->count += 1;
5139               }
5140             break;
5141
5142         /* This relocation describes the C++ object vtable hierarchy.
5143            Reconstruct it for later use during GC.  */
5144         case R_ARM_GNU_VTINHERIT:
5145           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5146             return FALSE;
5147           break;
5148
5149         /* This relocation describes which C++ vtable entries are actually
5150            used.  Record for later use during GC.  */
5151         case R_ARM_GNU_VTENTRY:
5152           if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
5153             return FALSE;
5154           break;
5155         }
5156     }
5157
5158   return TRUE;
5159 }
5160
5161 /* Treat mapping symbols as special target symbols.  */
5162
5163 static bfd_boolean
5164 elf32_arm_is_target_special_symbol (bfd * abfd ATTRIBUTE_UNUSED, asymbol * sym)
5165 {
5166   return bfd_is_arm_mapping_symbol_name (sym->name);
5167 }
5168
5169 /* This is a copy of elf_find_function() from elf.c except that
5170    ARM mapping symbols are ignored when looking for function names
5171    and STT_ARM_TFUNC is considered to a function type.  */
5172
5173 static bfd_boolean
5174 arm_elf_find_function (bfd *         abfd ATTRIBUTE_UNUSED,
5175                        asection *    section,
5176                        asymbol **    symbols,
5177                        bfd_vma       offset,
5178                        const char ** filename_ptr,
5179                        const char ** functionname_ptr)
5180 {
5181   const char * filename = NULL;
5182   asymbol * func = NULL;
5183   bfd_vma low_func = 0;
5184   asymbol ** p;
5185
5186   for (p = symbols; *p != NULL; p++)
5187     {
5188       elf_symbol_type *q;
5189
5190       q = (elf_symbol_type *) *p;
5191
5192       switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
5193         {
5194         default:
5195           break;
5196         case STT_FILE:
5197           filename = bfd_asymbol_name (&q->symbol);
5198           break;
5199         case STT_FUNC:
5200         case STT_ARM_TFUNC:
5201         case STT_NOTYPE:
5202           /* Skip $a and $t symbols.  */
5203           if ((q->symbol.flags & BSF_LOCAL)
5204               && bfd_is_arm_mapping_symbol_name (q->symbol.name))
5205             continue;
5206           /* Fall through.  */
5207           if (bfd_get_section (&q->symbol) == section
5208               && q->symbol.value >= low_func
5209               && q->symbol.value <= offset)
5210             {
5211               func = (asymbol *) q;
5212               low_func = q->symbol.value;
5213             }
5214           break;
5215         }
5216     }
5217
5218   if (func == NULL)
5219     return FALSE;
5220
5221   if (filename_ptr)
5222     *filename_ptr = filename;
5223   if (functionname_ptr)
5224     *functionname_ptr = bfd_asymbol_name (func);
5225
5226   return TRUE;
5227 }
5228
5229
5230 /* Find the nearest line to a particular section and offset, for error
5231    reporting.   This code is a duplicate of the code in elf.c, except
5232    that it uses arm_elf_find_function.  */
5233
5234 static bfd_boolean
5235 elf32_arm_find_nearest_line (bfd *          abfd,
5236                              asection *     section,
5237                              asymbol **     symbols,
5238                              bfd_vma        offset,
5239                              const char **  filename_ptr,
5240                              const char **  functionname_ptr,
5241                              unsigned int * line_ptr)
5242 {
5243   bfd_boolean found = FALSE;
5244
5245   /* We skip _bfd_dwarf1_find_nearest_line since no known ARM toolchain uses it.  */
5246
5247   if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
5248                                      filename_ptr, functionname_ptr,
5249                                      line_ptr, 0,
5250                                      & elf_tdata (abfd)->dwarf2_find_line_info))
5251     {
5252       if (!*functionname_ptr)
5253         arm_elf_find_function (abfd, section, symbols, offset,
5254                                *filename_ptr ? NULL : filename_ptr,
5255                                functionname_ptr);
5256
5257       return TRUE;
5258     }
5259
5260   if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
5261                                              & found, filename_ptr,
5262                                              functionname_ptr, line_ptr,
5263                                              & elf_tdata (abfd)->line_info))
5264     return FALSE;
5265
5266   if (found && (*functionname_ptr || *line_ptr))
5267     return TRUE;
5268
5269   if (symbols == NULL)
5270     return FALSE;
5271
5272   if (! arm_elf_find_function (abfd, section, symbols, offset,
5273                                filename_ptr, functionname_ptr))
5274     return FALSE;
5275
5276   *line_ptr = 0;
5277   return TRUE;
5278 }
5279
5280 static bfd_boolean
5281 elf32_arm_find_inliner_info (bfd *          abfd,
5282                              const char **  filename_ptr,
5283                              const char **  functionname_ptr,
5284                              unsigned int * line_ptr)
5285 {
5286   bfd_boolean found;
5287   found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
5288                                          functionname_ptr, line_ptr,
5289                                          & elf_tdata (abfd)->dwarf2_find_line_info);
5290   return found;
5291 }
5292
5293 /* Adjust a symbol defined by a dynamic object and referenced by a
5294    regular object.  The current definition is in some section of the
5295    dynamic object, but we're not including those sections.  We have to
5296    change the definition to something the rest of the link can
5297    understand.  */
5298
5299 static bfd_boolean
5300 elf32_arm_adjust_dynamic_symbol (struct bfd_link_info * info,
5301                                  struct elf_link_hash_entry * h)
5302 {
5303   bfd * dynobj;
5304   asection * s;
5305   unsigned int power_of_two;
5306   struct elf32_arm_link_hash_entry * eh;
5307   struct elf32_arm_link_hash_table *globals;
5308
5309   globals = elf32_arm_hash_table (info);
5310   dynobj = elf_hash_table (info)->dynobj;
5311
5312   /* Make sure we know what is going on here.  */
5313   BFD_ASSERT (dynobj != NULL
5314               && (h->needs_plt
5315                   || h->u.weakdef != NULL
5316                   || (h->def_dynamic
5317                       && h->ref_regular
5318                       && !h->def_regular)));
5319
5320   eh = (struct elf32_arm_link_hash_entry *) h;
5321
5322   /* If this is a function, put it in the procedure linkage table.  We
5323      will fill in the contents of the procedure linkage table later,
5324      when we know the address of the .got section.  */
5325   if (h->type == STT_FUNC || h->type == STT_ARM_TFUNC
5326       || h->needs_plt)
5327     {
5328       if (h->plt.refcount <= 0
5329           || SYMBOL_CALLS_LOCAL (info, h)
5330           || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
5331               && h->root.type == bfd_link_hash_undefweak))
5332         {
5333           /* This case can occur if we saw a PLT32 reloc in an input
5334              file, but the symbol was never referred to by a dynamic
5335              object, or if all references were garbage collected.  In
5336              such a case, we don't actually need to build a procedure
5337              linkage table, and we can just do a PC24 reloc instead.  */
5338           h->plt.offset = (bfd_vma) -1;
5339           eh->plt_thumb_refcount = 0;
5340           h->needs_plt = 0;
5341         }
5342
5343       return TRUE;
5344     }
5345   else
5346     {
5347       /* It's possible that we incorrectly decided a .plt reloc was
5348          needed for an R_ARM_PC24 or similar reloc to a non-function sym
5349          in check_relocs.  We can't decide accurately between function
5350          and non-function syms in check-relocs; Objects loaded later in
5351          the link may change h->type.  So fix it now.  */
5352       h->plt.offset = (bfd_vma) -1;
5353       eh->plt_thumb_refcount = 0;
5354     }
5355
5356   /* If this is a weak symbol, and there is a real definition, the
5357      processor independent code will have arranged for us to see the
5358      real definition first, and we can just use the same value.  */
5359   if (h->u.weakdef != NULL)
5360     {
5361       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
5362                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
5363       h->root.u.def.section = h->u.weakdef->root.u.def.section;
5364       h->root.u.def.value = h->u.weakdef->root.u.def.value;
5365       return TRUE;
5366     }
5367
5368   /* If there are no non-GOT references, we do not need a copy
5369      relocation.  */
5370   if (!h->non_got_ref)
5371     return TRUE;
5372
5373   /* This is a reference to a symbol defined by a dynamic object which
5374      is not a function.  */
5375
5376   /* If we are creating a shared library, we must presume that the
5377      only references to the symbol are via the global offset table.
5378      For such cases we need not do anything here; the relocations will
5379      be handled correctly by relocate_section.  Relocatable executables
5380      can reference data in shared objects directly, so we don't need to
5381      do anything here.  */
5382   if (info->shared || globals->root.is_relocatable_executable)
5383     return TRUE;
5384
5385   /* We must allocate the symbol in our .dynbss section, which will
5386      become part of the .bss section of the executable.  There will be
5387      an entry for this symbol in the .dynsym section.  The dynamic
5388      object will contain position independent code, so all references
5389      from the dynamic object to this symbol will go through the global
5390      offset table.  The dynamic linker will use the .dynsym entry to
5391      determine the address it must put in the global offset table, so
5392      both the dynamic object and the regular object will refer to the
5393      same memory location for the variable.  */
5394   s = bfd_get_section_by_name (dynobj, ".dynbss");
5395   BFD_ASSERT (s != NULL);
5396
5397   /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
5398      copy the initial value out of the dynamic object and into the
5399      runtime process image.  We need to remember the offset into the
5400      .rel.bss section we are going to use.  */
5401   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
5402     {
5403       asection *srel;
5404
5405       srel = bfd_get_section_by_name (dynobj, ".rel.bss");
5406       BFD_ASSERT (srel != NULL);
5407       srel->size += sizeof (Elf32_External_Rel);
5408       h->needs_copy = 1;
5409     }
5410
5411   /* We need to figure out the alignment required for this symbol.  I
5412      have no idea how ELF linkers handle this.  */
5413   power_of_two = bfd_log2 (h->size);
5414   if (power_of_two > 3)
5415     power_of_two = 3;
5416
5417   /* Apply the required alignment.  */
5418   s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
5419   if (power_of_two > bfd_get_section_alignment (dynobj, s))
5420     {
5421       if (! bfd_set_section_alignment (dynobj, s, power_of_two))
5422         return FALSE;
5423     }
5424
5425   /* Define the symbol as being at this point in the section.  */
5426   h->root.u.def.section = s;
5427   h->root.u.def.value = s->size;
5428
5429   /* Increment the section size to make room for the symbol.  */
5430   s->size += h->size;
5431
5432   return TRUE;
5433 }
5434
5435 /* Allocate space in .plt, .got and associated reloc sections for
5436    dynamic relocs.  */
5437
5438 static bfd_boolean
5439 allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
5440 {
5441   struct bfd_link_info *info;
5442   struct elf32_arm_link_hash_table *htab;
5443   struct elf32_arm_link_hash_entry *eh;
5444   struct elf32_arm_relocs_copied *p;
5445
5446   eh = (struct elf32_arm_link_hash_entry *) h;
5447
5448   if (h->root.type == bfd_link_hash_indirect)
5449     return TRUE;
5450
5451   if (h->root.type == bfd_link_hash_warning)
5452     /* When warning symbols are created, they **replace** the "real"
5453        entry in the hash table, thus we never get to see the real
5454        symbol in a hash traversal.  So look at it now.  */
5455     h = (struct elf_link_hash_entry *) h->root.u.i.link;
5456
5457   info = (struct bfd_link_info *) inf;
5458   htab = elf32_arm_hash_table (info);
5459
5460   if (htab->root.dynamic_sections_created
5461       && h->plt.refcount > 0)
5462     {
5463       /* Make sure this symbol is output as a dynamic symbol.
5464          Undefined weak syms won't yet be marked as dynamic.  */
5465       if (h->dynindx == -1
5466           && !h->forced_local)
5467         {
5468           if (! bfd_elf_link_record_dynamic_symbol (info, h))
5469             return FALSE;
5470         }
5471
5472       if (info->shared
5473           || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
5474         {
5475           asection *s = htab->splt;
5476
5477           /* If this is the first .plt entry, make room for the special
5478              first entry.  */
5479           if (s->size == 0)
5480             s->size += htab->plt_header_size;
5481
5482           h->plt.offset = s->size;
5483
5484           /* If we will insert a Thumb trampoline before this PLT, leave room
5485              for it.  */
5486           if (!htab->use_blx && eh->plt_thumb_refcount > 0)
5487             {
5488               h->plt.offset += PLT_THUMB_STUB_SIZE;
5489               s->size += PLT_THUMB_STUB_SIZE;
5490             }
5491
5492           /* If this symbol is not defined in a regular file, and we are
5493              not generating a shared library, then set the symbol to this
5494              location in the .plt.  This is required to make function
5495              pointers compare as equal between the normal executable and
5496              the shared library.  */
5497           if (! info->shared
5498               && !h->def_regular)
5499             {
5500               h->root.u.def.section = s;
5501               h->root.u.def.value = h->plt.offset;
5502
5503               /* Make sure the function is not marked as Thumb, in case
5504                  it is the target of an ABS32 relocation, which will
5505                  point to the PLT entry.  */
5506               if (ELF_ST_TYPE (h->type) == STT_ARM_TFUNC)
5507                 h->type = ELF_ST_INFO (ELF_ST_BIND (h->type), STT_FUNC);
5508             }
5509
5510           /* Make room for this entry.  */
5511           s->size += htab->plt_entry_size;
5512
5513           if (!htab->symbian_p)
5514             {
5515               /* We also need to make an entry in the .got.plt section, which
5516                  will be placed in the .got section by the linker script.  */
5517               eh->plt_got_offset = htab->sgotplt->size;
5518               htab->sgotplt->size += 4;
5519             }
5520
5521           /* We also need to make an entry in the .rel.plt section.  */
5522           htab->srelplt->size += sizeof (Elf32_External_Rel);
5523         }
5524       else
5525         {
5526           h->plt.offset = (bfd_vma) -1;
5527           h->needs_plt = 0;
5528         }
5529     }
5530   else
5531     {
5532       h->plt.offset = (bfd_vma) -1;
5533       h->needs_plt = 0;
5534     }
5535
5536   if (h->got.refcount > 0)
5537     {
5538       asection *s;
5539       bfd_boolean dyn;
5540       int tls_type = elf32_arm_hash_entry (h)->tls_type;
5541       int indx;
5542
5543       /* Make sure this symbol is output as a dynamic symbol.
5544          Undefined weak syms won't yet be marked as dynamic.  */
5545       if (h->dynindx == -1
5546           && !h->forced_local)
5547         {
5548           if (! bfd_elf_link_record_dynamic_symbol (info, h))
5549             return FALSE;
5550         }
5551
5552       if (!htab->symbian_p)
5553         {
5554           s = htab->sgot;
5555           h->got.offset = s->size;
5556
5557           if (tls_type == GOT_UNKNOWN)
5558             abort ();
5559
5560           if (tls_type == GOT_NORMAL)
5561             /* Non-TLS symbols need one GOT slot.  */
5562             s->size += 4;
5563           else
5564             {
5565               if (tls_type & GOT_TLS_GD)
5566                 /* R_ARM_TLS_GD32 needs 2 consecutive GOT slots.  */
5567                 s->size += 8;
5568               if (tls_type & GOT_TLS_IE)
5569                 /* R_ARM_TLS_IE32 needs one GOT slot.  */
5570                 s->size += 4;
5571             }
5572
5573           dyn = htab->root.dynamic_sections_created;
5574
5575           indx = 0;
5576           if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
5577               && (!info->shared
5578                   || !SYMBOL_REFERENCES_LOCAL (info, h)))
5579             indx = h->dynindx;
5580
5581           if (tls_type != GOT_NORMAL
5582               && (info->shared || indx != 0)
5583               && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
5584                   || h->root.type != bfd_link_hash_undefweak))
5585             {
5586               if (tls_type & GOT_TLS_IE)
5587                 htab->srelgot->size += sizeof (Elf32_External_Rel);
5588
5589               if (tls_type & GOT_TLS_GD)
5590                 htab->srelgot->size += sizeof (Elf32_External_Rel);
5591
5592               if ((tls_type & GOT_TLS_GD) && indx != 0)
5593                 htab->srelgot->size += sizeof (Elf32_External_Rel);
5594             }
5595           else if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
5596                     || h->root.type != bfd_link_hash_undefweak)
5597                    && (info->shared
5598                    || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
5599             htab->srelgot->size += sizeof (Elf32_External_Rel);
5600         }
5601     }
5602   else
5603     h->got.offset = (bfd_vma) -1;
5604
5605   if (eh->relocs_copied == NULL)
5606     return TRUE;
5607
5608   /* In the shared -Bsymbolic case, discard space allocated for
5609      dynamic pc-relative relocs against symbols which turn out to be
5610      defined in regular objects.  For the normal shared case, discard
5611      space for pc-relative relocs that have become local due to symbol
5612      visibility changes.  */
5613
5614   if (info->shared || htab->root.is_relocatable_executable)
5615     {
5616       /* The only reloc that uses pc_count is R_ARM_REL32, which will
5617          appear on something like ".long foo - .".  We want calls to
5618          protected symbols to resolve directly to the function rather
5619          than going via the plt.  If people want function pointer
5620          comparisons to work as expected then they should avoid
5621          writing assembly like ".long foo - .".  */
5622       if (SYMBOL_CALLS_LOCAL (info, h))
5623         {
5624           struct elf32_arm_relocs_copied **pp;
5625
5626           for (pp = &eh->relocs_copied; (p = *pp) != NULL; )
5627             {
5628               p->count -= p->pc_count;
5629               p->pc_count = 0;
5630               if (p->count == 0)
5631                 *pp = p->next;
5632               else
5633                 pp = &p->next;
5634             }
5635         }
5636
5637       /* Also discard relocs on undefined weak syms with non-default
5638          visibility.  */
5639       if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
5640           && h->root.type == bfd_link_hash_undefweak)
5641         eh->relocs_copied = NULL;
5642       else if (htab->root.is_relocatable_executable && h->dynindx == -1
5643                && h->root.type == bfd_link_hash_new)
5644         {
5645           /* Output absolute symbols so that we can create relocations
5646              against them.  For normal symbols we output a relocation
5647              against the section that contains them.  */
5648           if (! bfd_elf_link_record_dynamic_symbol (info, h))
5649             return FALSE;
5650         }
5651
5652     }
5653   else
5654     {
5655       /* For the non-shared case, discard space for relocs against
5656          symbols which turn out to need copy relocs or are not
5657          dynamic.  */
5658
5659       if (!h->non_got_ref
5660           && ((h->def_dynamic
5661                && !h->def_regular)
5662               || (htab->root.dynamic_sections_created
5663                   && (h->root.type == bfd_link_hash_undefweak
5664                       || h->root.type == bfd_link_hash_undefined))))
5665         {
5666           /* Make sure this symbol is output as a dynamic symbol.
5667              Undefined weak syms won't yet be marked as dynamic.  */
5668           if (h->dynindx == -1
5669               && !h->forced_local)
5670             {
5671               if (! bfd_elf_link_record_dynamic_symbol (info, h))
5672                 return FALSE;
5673             }
5674
5675           /* If that succeeded, we know we'll be keeping all the
5676              relocs.  */
5677           if (h->dynindx != -1)
5678             goto keep;
5679         }
5680
5681       eh->relocs_copied = NULL;
5682
5683     keep: ;
5684     }
5685
5686   /* Finally, allocate space.  */
5687   for (p = eh->relocs_copied; p != NULL; p = p->next)
5688     {
5689       asection *sreloc = elf_section_data (p->section)->sreloc;
5690       sreloc->size += p->count * sizeof (Elf32_External_Rel);
5691     }
5692
5693   return TRUE;
5694 }
5695
5696 /* Find any dynamic relocs that apply to read-only sections.  */
5697
5698 static bfd_boolean
5699 elf32_arm_readonly_dynrelocs (struct elf_link_hash_entry *h, PTR inf)
5700 {
5701   struct elf32_arm_link_hash_entry *eh;
5702   struct elf32_arm_relocs_copied *p;
5703
5704   if (h->root.type == bfd_link_hash_warning)
5705     h = (struct elf_link_hash_entry *) h->root.u.i.link;
5706
5707   eh = (struct elf32_arm_link_hash_entry *) h;
5708   for (p = eh->relocs_copied; p != NULL; p = p->next)
5709     {
5710       asection *s = p->section;
5711
5712       if (s != NULL && (s->flags & SEC_READONLY) != 0)
5713         {
5714           struct bfd_link_info *info = (struct bfd_link_info *) inf;
5715
5716           info->flags |= DF_TEXTREL;
5717
5718           /* Not an error, just cut short the traversal.  */
5719           return FALSE;
5720         }
5721     }
5722   return TRUE;
5723 }
5724
5725 /* Set the sizes of the dynamic sections.  */
5726
5727 static bfd_boolean
5728 elf32_arm_size_dynamic_sections (bfd * output_bfd ATTRIBUTE_UNUSED,
5729                                  struct bfd_link_info * info)
5730 {
5731   bfd * dynobj;
5732   asection * s;
5733   bfd_boolean plt;
5734   bfd_boolean relocs;
5735   bfd *ibfd;
5736   struct elf32_arm_link_hash_table *htab;
5737
5738   htab = elf32_arm_hash_table (info);
5739   dynobj = elf_hash_table (info)->dynobj;
5740   BFD_ASSERT (dynobj != NULL);
5741
5742   if (elf_hash_table (info)->dynamic_sections_created)
5743     {
5744       /* Set the contents of the .interp section to the interpreter.  */
5745       if (info->executable)
5746         {
5747           s = bfd_get_section_by_name (dynobj, ".interp");
5748           BFD_ASSERT (s != NULL);
5749           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
5750           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
5751         }
5752     }
5753
5754   /* Set up .got offsets for local syms, and space for local dynamic
5755      relocs.  */
5756   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
5757     {
5758       bfd_signed_vma *local_got;
5759       bfd_signed_vma *end_local_got;
5760       char *local_tls_type;
5761       bfd_size_type locsymcount;
5762       Elf_Internal_Shdr *symtab_hdr;
5763       asection *srel;
5764
5765       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
5766         continue;
5767
5768       for (s = ibfd->sections; s != NULL; s = s->next)
5769         {
5770           struct elf32_arm_relocs_copied *p;
5771
5772           for (p = *((struct elf32_arm_relocs_copied **)
5773                      &elf_section_data (s)->local_dynrel);
5774                p != NULL;
5775                p = p->next)
5776             {
5777               if (!bfd_is_abs_section (p->section)
5778                   && bfd_is_abs_section (p->section->output_section))
5779                 {
5780                   /* Input section has been discarded, either because
5781                      it is a copy of a linkonce section or due to
5782                      linker script /DISCARD/, so we'll be discarding
5783                      the relocs too.  */
5784                 }
5785               else if (p->count != 0)
5786                 {
5787                   srel = elf_section_data (p->section)->sreloc;
5788                   srel->size += p->count * sizeof (Elf32_External_Rel);
5789                   if ((p->section->output_section->flags & SEC_READONLY) != 0)
5790                     info->flags |= DF_TEXTREL;
5791                 }
5792             }
5793         }
5794
5795       local_got = elf_local_got_refcounts (ibfd);
5796       if (!local_got)
5797         continue;
5798
5799       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
5800       locsymcount = symtab_hdr->sh_info;
5801       end_local_got = local_got + locsymcount;
5802       local_tls_type = elf32_arm_local_got_tls_type (ibfd);
5803       s = htab->sgot;
5804       srel = htab->srelgot;
5805       for (; local_got < end_local_got; ++local_got, ++local_tls_type)
5806         {
5807           if (*local_got > 0)
5808             {
5809               *local_got = s->size;
5810               if (*local_tls_type & GOT_TLS_GD)
5811                 /* TLS_GD relocs need an 8-byte structure in the GOT.  */
5812                 s->size += 8;
5813               if (*local_tls_type & GOT_TLS_IE)
5814                 s->size += 4;
5815               if (*local_tls_type == GOT_NORMAL)
5816                 s->size += 4;
5817
5818               if (info->shared || *local_tls_type == GOT_TLS_GD)
5819                 srel->size += sizeof (Elf32_External_Rel);
5820             }
5821           else
5822             *local_got = (bfd_vma) -1;
5823         }
5824     }
5825
5826   if (htab->tls_ldm_got.refcount > 0)
5827     {
5828       /* Allocate two GOT entries and one dynamic relocation (if necessary)
5829          for R_ARM_TLS_LDM32 relocations.  */
5830       htab->tls_ldm_got.offset = htab->sgot->size;
5831       htab->sgot->size += 8;
5832       if (info->shared)
5833         htab->srelgot->size += sizeof (Elf32_External_Rel);
5834     }
5835   else
5836     htab->tls_ldm_got.offset = -1;
5837
5838   /* Allocate global sym .plt and .got entries, and space for global
5839      sym dynamic relocs.  */
5840   elf_link_hash_traverse (& htab->root, allocate_dynrelocs, info);
5841
5842   /* The check_relocs and adjust_dynamic_symbol entry points have
5843      determined the sizes of the various dynamic sections.  Allocate
5844      memory for them.  */
5845   plt = FALSE;
5846   relocs = FALSE;
5847   for (s = dynobj->sections; s != NULL; s = s->next)
5848     {
5849       const char * name;
5850       bfd_boolean strip;
5851
5852       if ((s->flags & SEC_LINKER_CREATED) == 0)
5853         continue;
5854
5855       /* It's OK to base decisions on the section name, because none
5856          of the dynobj section names depend upon the input files.  */
5857       name = bfd_get_section_name (dynobj, s);
5858
5859       strip = FALSE;
5860
5861       if (strcmp (name, ".plt") == 0)
5862         {
5863           if (s->size == 0)
5864             {
5865               /* Strip this section if we don't need it; see the
5866                  comment below.  */
5867               strip = TRUE;
5868             }
5869           else
5870             {
5871               /* Remember whether there is a PLT.  */
5872               plt = TRUE;
5873             }
5874         }
5875       else if (strncmp (name, ".rel", 4) == 0)
5876         {
5877           if (s->size == 0)
5878             {
5879               /* If we don't need this section, strip it from the
5880                  output file.  This is mostly to handle .rel.bss and
5881                  .rel.plt.  We must create both sections in
5882                  create_dynamic_sections, because they must be created
5883                  before the linker maps input sections to output
5884                  sections.  The linker does that before
5885                  adjust_dynamic_symbol is called, and it is that
5886                  function which decides whether anything needs to go
5887                  into these sections.  */
5888               strip = TRUE;
5889             }
5890           else
5891             {
5892               /* Remember whether there are any reloc sections other
5893                  than .rel.plt.  */
5894               if (strcmp (name, ".rel.plt") != 0)
5895                 relocs = TRUE;
5896
5897               /* We use the reloc_count field as a counter if we need
5898                  to copy relocs into the output file.  */
5899               s->reloc_count = 0;
5900             }
5901         }
5902       else if (strncmp (name, ".got", 4) != 0)
5903         {
5904           /* It's not one of our sections, so don't allocate space.  */
5905           continue;
5906         }
5907
5908       if (strip)
5909         {
5910           s->flags |= SEC_EXCLUDE;
5911           continue;
5912         }
5913
5914       /* Allocate memory for the section contents.  */
5915       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
5916       if (s->contents == NULL && s->size != 0)
5917         return FALSE;
5918     }
5919
5920   if (elf_hash_table (info)->dynamic_sections_created)
5921     {
5922       /* Add some entries to the .dynamic section.  We fill in the
5923          values later, in elf32_arm_finish_dynamic_sections, but we
5924          must add the entries now so that we get the correct size for
5925          the .dynamic section.  The DT_DEBUG entry is filled in by the
5926          dynamic linker and used by the debugger.  */
5927 #define add_dynamic_entry(TAG, VAL) \
5928   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
5929
5930       if (!info->shared)
5931         {
5932           if (!add_dynamic_entry (DT_DEBUG, 0))
5933             return FALSE;
5934         }
5935
5936       if (plt)
5937         {
5938           if (   !add_dynamic_entry (DT_PLTGOT, 0)
5939               || !add_dynamic_entry (DT_PLTRELSZ, 0)
5940               || !add_dynamic_entry (DT_PLTREL, DT_REL)
5941               || !add_dynamic_entry (DT_JMPREL, 0))
5942             return FALSE;
5943         }
5944
5945       if (relocs)
5946         {
5947           if (   !add_dynamic_entry (DT_REL, 0)
5948               || !add_dynamic_entry (DT_RELSZ, 0)
5949               || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel)))
5950             return FALSE;
5951         }
5952
5953       /* If any dynamic relocs apply to a read-only section,
5954          then we need a DT_TEXTREL entry.  */
5955       if ((info->flags & DF_TEXTREL) == 0)
5956         elf_link_hash_traverse (&htab->root, elf32_arm_readonly_dynrelocs,
5957                                 (PTR) info);
5958
5959       if ((info->flags & DF_TEXTREL) != 0)
5960         {
5961           if (!add_dynamic_entry (DT_TEXTREL, 0))
5962             return FALSE;
5963           info->flags |= DF_TEXTREL;
5964         }
5965     }
5966 #undef add_synamic_entry
5967
5968   return TRUE;
5969 }
5970
5971 /* Finish up dynamic symbol handling.  We set the contents of various
5972    dynamic sections here.  */
5973
5974 static bfd_boolean
5975 elf32_arm_finish_dynamic_symbol (bfd * output_bfd, struct bfd_link_info * info,
5976                                  struct elf_link_hash_entry * h, Elf_Internal_Sym * sym)
5977 {
5978   bfd * dynobj;
5979   struct elf32_arm_link_hash_table *htab;
5980   struct elf32_arm_link_hash_entry *eh;
5981
5982   dynobj = elf_hash_table (info)->dynobj;
5983   htab = elf32_arm_hash_table (info);
5984   eh = (struct elf32_arm_link_hash_entry *) h;
5985
5986   if (h->plt.offset != (bfd_vma) -1)
5987     {
5988       asection * splt;
5989       asection * srel;
5990       bfd_byte *loc;
5991       bfd_vma plt_index;
5992       Elf_Internal_Rela rel;
5993
5994       /* This symbol has an entry in the procedure linkage table.  Set
5995          it up.  */
5996
5997       BFD_ASSERT (h->dynindx != -1);
5998
5999       splt = bfd_get_section_by_name (dynobj, ".plt");
6000       srel = bfd_get_section_by_name (dynobj, ".rel.plt");
6001       BFD_ASSERT (splt != NULL && srel != NULL);
6002
6003       /* Fill in the entry in the procedure linkage table.  */
6004       if (htab->symbian_p)
6005         {
6006           unsigned i;
6007           for (i = 0; i < htab->plt_entry_size / 4; ++i)
6008             bfd_put_32 (output_bfd,
6009                         elf32_arm_symbian_plt_entry[i],
6010                         splt->contents + h->plt.offset + 4 * i);
6011
6012           /* Fill in the entry in the .rel.plt section.  */
6013           rel.r_offset = (splt->output_section->vma
6014                           + splt->output_offset
6015                           + h->plt.offset + 4 * (i - 1));
6016           rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT);
6017
6018           /* Get the index in the procedure linkage table which
6019              corresponds to this symbol.  This is the index of this symbol
6020              in all the symbols for which we are making plt entries.  The
6021              first entry in the procedure linkage table is reserved.  */
6022           plt_index = ((h->plt.offset - htab->plt_header_size)
6023                        / htab->plt_entry_size);
6024         }
6025       else
6026         {
6027           bfd_vma got_offset;
6028           bfd_vma got_displacement;
6029           asection * sgot;
6030
6031           sgot = bfd_get_section_by_name (dynobj, ".got.plt");
6032           BFD_ASSERT (sgot != NULL);
6033
6034           /* Get the offset into the .got.plt table of the entry that
6035              corresponds to this function.  */
6036           got_offset = eh->plt_got_offset;
6037
6038           /* Get the index in the procedure linkage table which
6039              corresponds to this symbol.  This is the index of this symbol
6040              in all the symbols for which we are making plt entries.  The
6041              first three entries in .got.plt are reserved; after that
6042              symbols appear in the same order as in .plt.  */
6043           plt_index = (got_offset - 12) / 4;
6044
6045           /* Calculate the displacement between the PLT slot and the
6046              entry in the GOT.  The eight-byte offset accounts for the
6047              value produced by adding to pc in the first instruction
6048              of the PLT stub.  */
6049           got_displacement = (sgot->output_section->vma
6050                               + sgot->output_offset
6051                               + got_offset
6052                               - splt->output_section->vma
6053                               - splt->output_offset
6054                               - h->plt.offset
6055                               - 8);
6056
6057           BFD_ASSERT ((got_displacement & 0xf0000000) == 0);
6058
6059           if (!htab->use_blx && eh->plt_thumb_refcount > 0)
6060             {
6061               bfd_put_16 (output_bfd, elf32_arm_plt_thumb_stub[0],
6062                           splt->contents + h->plt.offset - 4);
6063               bfd_put_16 (output_bfd, elf32_arm_plt_thumb_stub[1],
6064                           splt->contents + h->plt.offset - 2);
6065             }
6066
6067           bfd_put_32 (output_bfd, elf32_arm_plt_entry[0] | ((got_displacement & 0x0ff00000) >> 20),
6068                       splt->contents + h->plt.offset + 0);
6069           bfd_put_32 (output_bfd, elf32_arm_plt_entry[1] | ((got_displacement & 0x000ff000) >> 12),
6070                       splt->contents + h->plt.offset + 4);
6071           bfd_put_32 (output_bfd, elf32_arm_plt_entry[2] | (got_displacement & 0x00000fff),
6072                       splt->contents + h->plt.offset + 8);
6073 #ifdef FOUR_WORD_PLT
6074           bfd_put_32 (output_bfd, elf32_arm_plt_entry[3],
6075                       splt->contents + h->plt.offset + 12);
6076 #endif
6077
6078           /* Fill in the entry in the global offset table.  */
6079           bfd_put_32 (output_bfd,
6080                       (splt->output_section->vma
6081                        + splt->output_offset),
6082                       sgot->contents + got_offset);
6083
6084           /* Fill in the entry in the .rel.plt section.  */
6085           rel.r_offset = (sgot->output_section->vma
6086                           + sgot->output_offset
6087                           + got_offset);
6088           rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_JUMP_SLOT);
6089         }
6090
6091       loc = srel->contents + plt_index * sizeof (Elf32_External_Rel);
6092       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
6093
6094       if (!h->def_regular)
6095         {
6096           /* Mark the symbol as undefined, rather than as defined in
6097              the .plt section.  Leave the value alone.  */
6098           sym->st_shndx = SHN_UNDEF;
6099           /* If the symbol is weak, we do need to clear the value.
6100              Otherwise, the PLT entry would provide a definition for
6101              the symbol even if the symbol wasn't defined anywhere,
6102              and so the symbol would never be NULL.  */
6103           if (!h->ref_regular_nonweak)
6104             sym->st_value = 0;
6105         }
6106     }
6107
6108   if (h->got.offset != (bfd_vma) -1
6109       && (elf32_arm_hash_entry (h)->tls_type & GOT_TLS_GD) == 0
6110       && (elf32_arm_hash_entry (h)->tls_type & GOT_TLS_IE) == 0)
6111     {
6112       asection * sgot;
6113       asection * srel;
6114       Elf_Internal_Rela rel;
6115       bfd_byte *loc;
6116
6117       /* This symbol has an entry in the global offset table.  Set it
6118          up.  */
6119       sgot = bfd_get_section_by_name (dynobj, ".got");
6120       srel = bfd_get_section_by_name (dynobj, ".rel.got");
6121       BFD_ASSERT (sgot != NULL && srel != NULL);
6122
6123       rel.r_offset = (sgot->output_section->vma
6124                       + sgot->output_offset
6125                       + (h->got.offset &~ (bfd_vma) 1));
6126
6127       /* If this is a static link, or it is a -Bsymbolic link and the
6128          symbol is defined locally or was forced to be local because
6129          of a version file, we just want to emit a RELATIVE reloc.
6130          The entry in the global offset table will already have been
6131          initialized in the relocate_section function.  */
6132       if (info->shared
6133           && SYMBOL_REFERENCES_LOCAL (info, h))
6134         {
6135           BFD_ASSERT((h->got.offset & 1) != 0);
6136           rel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
6137         }
6138       else
6139         {
6140           BFD_ASSERT((h->got.offset & 1) == 0);
6141           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
6142           rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT);
6143         }
6144
6145       loc = srel->contents + srel->reloc_count++ * sizeof (Elf32_External_Rel);
6146       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
6147     }
6148
6149   if (h->needs_copy)
6150     {
6151       asection * s;
6152       Elf_Internal_Rela rel;
6153       bfd_byte *loc;
6154
6155       /* This symbol needs a copy reloc.  Set it up.  */
6156       BFD_ASSERT (h->dynindx != -1
6157                   && (h->root.type == bfd_link_hash_defined
6158                       || h->root.type == bfd_link_hash_defweak));
6159
6160       s = bfd_get_section_by_name (h->root.u.def.section->owner,
6161                                    ".rel.bss");
6162       BFD_ASSERT (s != NULL);
6163
6164       rel.r_offset = (h->root.u.def.value
6165                       + h->root.u.def.section->output_section->vma
6166                       + h->root.u.def.section->output_offset);
6167       rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_COPY);
6168       loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rel);
6169       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
6170     }
6171
6172   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
6173   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
6174       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
6175     sym->st_shndx = SHN_ABS;
6176
6177   return TRUE;
6178 }
6179
6180 /* Finish up the dynamic sections.  */
6181
6182 static bfd_boolean
6183 elf32_arm_finish_dynamic_sections (bfd * output_bfd, struct bfd_link_info * info)
6184 {
6185   bfd * dynobj;
6186   asection * sgot;
6187   asection * sdyn;
6188
6189   dynobj = elf_hash_table (info)->dynobj;
6190
6191   sgot = bfd_get_section_by_name (dynobj, ".got.plt");
6192   BFD_ASSERT (elf32_arm_hash_table (info)->symbian_p || sgot != NULL);
6193   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
6194
6195   if (elf_hash_table (info)->dynamic_sections_created)
6196     {
6197       asection *splt;
6198       Elf32_External_Dyn *dyncon, *dynconend;
6199       struct elf32_arm_link_hash_table *htab;
6200
6201       htab = elf32_arm_hash_table (info);
6202       splt = bfd_get_section_by_name (dynobj, ".plt");
6203       BFD_ASSERT (splt != NULL && sdyn != NULL);
6204
6205       dyncon = (Elf32_External_Dyn *) sdyn->contents;
6206       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
6207
6208       for (; dyncon < dynconend; dyncon++)
6209         {
6210           Elf_Internal_Dyn dyn;
6211           const char * name;
6212           asection * s;
6213
6214           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
6215
6216           switch (dyn.d_tag)
6217             {
6218               unsigned int type;
6219
6220             default:
6221               break;
6222
6223             case DT_HASH:
6224               name = ".hash";
6225               goto get_vma_if_bpabi;
6226             case DT_STRTAB:
6227               name = ".dynstr";
6228               goto get_vma_if_bpabi;
6229             case DT_SYMTAB:
6230               name = ".dynsym";
6231               goto get_vma_if_bpabi;
6232             case DT_VERSYM:
6233               name = ".gnu.version";
6234               goto get_vma_if_bpabi;
6235             case DT_VERDEF:
6236               name = ".gnu.version_d";
6237               goto get_vma_if_bpabi;
6238             case DT_VERNEED:
6239               name = ".gnu.version_r";
6240               goto get_vma_if_bpabi;
6241
6242             case DT_PLTGOT:
6243               name = ".got";
6244               goto get_vma;
6245             case DT_JMPREL:
6246               name = ".rel.plt";
6247             get_vma:
6248               s = bfd_get_section_by_name (output_bfd, name);
6249               BFD_ASSERT (s != NULL);
6250               if (!htab->symbian_p)
6251                 dyn.d_un.d_ptr = s->vma;
6252               else
6253                 /* In the BPABI, tags in the PT_DYNAMIC section point
6254                    at the file offset, not the memory address, for the
6255                    convenience of the post linker.  */
6256                 dyn.d_un.d_ptr = s->filepos;
6257               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
6258               break;
6259
6260             get_vma_if_bpabi:
6261               if (htab->symbian_p)
6262                 goto get_vma;
6263               break;
6264
6265             case DT_PLTRELSZ:
6266               s = bfd_get_section_by_name (output_bfd, ".rel.plt");
6267               BFD_ASSERT (s != NULL);
6268               dyn.d_un.d_val = s->size;
6269               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
6270               break;
6271
6272             case DT_RELSZ:
6273               if (!htab->symbian_p)
6274                 {
6275                   /* My reading of the SVR4 ABI indicates that the
6276                      procedure linkage table relocs (DT_JMPREL) should be
6277                      included in the overall relocs (DT_REL).  This is
6278                      what Solaris does.  However, UnixWare can not handle
6279                      that case.  Therefore, we override the DT_RELSZ entry
6280                      here to make it not include the JMPREL relocs.  Since
6281                      the linker script arranges for .rel.plt to follow all
6282                      other relocation sections, we don't have to worry
6283                      about changing the DT_REL entry.  */
6284                   s = bfd_get_section_by_name (output_bfd, ".rel.plt");
6285                   if (s != NULL)
6286                     dyn.d_un.d_val -= s->size;
6287                   bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
6288                   break;
6289                 }
6290               /* Fall through */
6291
6292             case DT_REL:
6293             case DT_RELA:
6294             case DT_RELASZ:
6295               /* In the BPABI, the DT_REL tag must point at the file
6296                  offset, not the VMA, of the first relocation
6297                  section.  So, we use code similar to that in
6298                  elflink.c, but do not check for SHF_ALLOC on the
6299                  relcoation section, since relocations sections are
6300                  never allocated under the BPABI.  The comments above
6301                  about Unixware notwithstanding, we include all of the
6302                  relocations here.  */
6303               if (htab->symbian_p)
6304                 {
6305                   unsigned int i;
6306                   type = ((dyn.d_tag == DT_REL || dyn.d_tag == DT_RELSZ)
6307                           ? SHT_REL : SHT_RELA);
6308                   dyn.d_un.d_val = 0;
6309                   for (i = 1; i < elf_numsections (output_bfd); i++)
6310                     {
6311                       Elf_Internal_Shdr *hdr
6312                         = elf_elfsections (output_bfd)[i];
6313                       if (hdr->sh_type == type)
6314                         {
6315                           if (dyn.d_tag == DT_RELSZ
6316                               || dyn.d_tag == DT_RELASZ)
6317                             dyn.d_un.d_val += hdr->sh_size;
6318                           else if ((ufile_ptr) hdr->sh_offset
6319                                    <= dyn.d_un.d_val - 1)
6320                             dyn.d_un.d_val = hdr->sh_offset;
6321                         }
6322                     }
6323                   bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
6324                 }
6325               break;
6326
6327               /* Set the bottom bit of DT_INIT/FINI if the
6328                  corresponding function is Thumb.  */
6329             case DT_INIT:
6330               name = info->init_function;
6331               goto get_sym;
6332             case DT_FINI:
6333               name = info->fini_function;
6334             get_sym:
6335               /* If it wasn't set by elf_bfd_final_link
6336                  then there is nothing to adjust.  */
6337               if (dyn.d_un.d_val != 0)
6338                 {
6339                   struct elf_link_hash_entry * eh;
6340
6341                   eh = elf_link_hash_lookup (elf_hash_table (info), name,
6342                                              FALSE, FALSE, TRUE);
6343                   if (eh != (struct elf_link_hash_entry *) NULL
6344                       && ELF_ST_TYPE (eh->type) == STT_ARM_TFUNC)
6345                     {
6346                       dyn.d_un.d_val |= 1;
6347                       bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
6348                     }
6349                 }
6350               break;
6351             }
6352         }
6353
6354       /* Fill in the first entry in the procedure linkage table.  */
6355       if (splt->size > 0 && elf32_arm_hash_table (info)->plt_header_size)
6356         {
6357           bfd_vma got_displacement;
6358
6359           /* Calculate the displacement between the PLT slot and &GOT[0].  */
6360           got_displacement = (sgot->output_section->vma
6361                               + sgot->output_offset
6362                               - splt->output_section->vma
6363                               - splt->output_offset
6364                               - 16);
6365
6366           bfd_put_32 (output_bfd, elf32_arm_plt0_entry[0], splt->contents +  0);
6367           bfd_put_32 (output_bfd, elf32_arm_plt0_entry[1], splt->contents +  4);
6368           bfd_put_32 (output_bfd, elf32_arm_plt0_entry[2], splt->contents +  8);
6369           bfd_put_32 (output_bfd, elf32_arm_plt0_entry[3], splt->contents + 12);
6370 #ifdef FOUR_WORD_PLT
6371           /* The displacement value goes in the otherwise-unused last word of
6372              the second entry.  */
6373           bfd_put_32 (output_bfd, got_displacement,        splt->contents + 28);
6374 #else
6375           bfd_put_32 (output_bfd, got_displacement,        splt->contents + 16);
6376 #endif
6377         }
6378
6379       /* UnixWare sets the entsize of .plt to 4, although that doesn't
6380          really seem like the right value.  */
6381       elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
6382     }
6383
6384   /* Fill in the first three entries in the global offset table.  */
6385   if (sgot)
6386     {
6387       if (sgot->size > 0)
6388         {
6389           if (sdyn == NULL)
6390             bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
6391           else
6392             bfd_put_32 (output_bfd,
6393                         sdyn->output_section->vma + sdyn->output_offset,
6394                         sgot->contents);
6395           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
6396           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
6397         }
6398
6399       elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
6400     }
6401
6402   return TRUE;
6403 }
6404
6405 static void
6406 elf32_arm_post_process_headers (bfd * abfd, struct bfd_link_info * link_info ATTRIBUTE_UNUSED)
6407 {
6408   Elf_Internal_Ehdr * i_ehdrp;  /* ELF file header, internal form.  */
6409   struct elf32_arm_link_hash_table *globals;
6410
6411   i_ehdrp = elf_elfheader (abfd);
6412
6413   if (EF_ARM_EABI_VERSION (i_ehdrp->e_flags) == EF_ARM_EABI_UNKNOWN)
6414     i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_ARM;
6415   else
6416     i_ehdrp->e_ident[EI_OSABI] = 0;
6417   i_ehdrp->e_ident[EI_ABIVERSION] = ARM_ELF_ABI_VERSION;
6418
6419   if (link_info)
6420     {
6421       globals = elf32_arm_hash_table (link_info);
6422       if (globals->byteswap_code)
6423         i_ehdrp->e_flags |= EF_ARM_BE8;
6424     }
6425 }
6426
6427 static enum elf_reloc_type_class
6428 elf32_arm_reloc_type_class (const Elf_Internal_Rela *rela)
6429 {
6430   switch ((int) ELF32_R_TYPE (rela->r_info))
6431     {
6432     case R_ARM_RELATIVE:
6433       return reloc_class_relative;
6434     case R_ARM_JUMP_SLOT:
6435       return reloc_class_plt;
6436     case R_ARM_COPY:
6437       return reloc_class_copy;
6438     default:
6439       return reloc_class_normal;
6440     }
6441 }
6442
6443 /* Set the right machine number for an Arm ELF file.  */
6444
6445 static bfd_boolean
6446 elf32_arm_section_flags (flagword *flags, const Elf_Internal_Shdr *hdr)
6447 {
6448   if (hdr->sh_type == SHT_NOTE)
6449     *flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_SAME_CONTENTS;
6450
6451   return TRUE;
6452 }
6453
6454 static void
6455 elf32_arm_final_write_processing (bfd *abfd, bfd_boolean linker ATTRIBUTE_UNUSED)
6456 {
6457   bfd_arm_update_notes (abfd, ARM_NOTE_SECTION);
6458 }
6459
6460 /* Return TRUE if this is an unwinding table entry.  */
6461
6462 static bfd_boolean
6463 is_arm_elf_unwind_section_name (bfd * abfd ATTRIBUTE_UNUSED, const char * name)
6464 {
6465   size_t len1, len2;
6466
6467   len1 = sizeof (ELF_STRING_ARM_unwind) - 1;
6468   len2 = sizeof (ELF_STRING_ARM_unwind_once) - 1;
6469   return (strncmp (name, ELF_STRING_ARM_unwind, len1) == 0
6470           || strncmp (name, ELF_STRING_ARM_unwind_once, len2) == 0);
6471 }
6472
6473
6474 /* Set the type and flags for an ARM section.  We do this by
6475    the section name, which is a hack, but ought to work.  */
6476
6477 static bfd_boolean
6478 elf32_arm_fake_sections (bfd * abfd, Elf_Internal_Shdr * hdr, asection * sec)
6479 {
6480   const char * name;
6481
6482   name = bfd_get_section_name (abfd, sec);
6483
6484   if (is_arm_elf_unwind_section_name (abfd, name))
6485     {
6486       hdr->sh_type = SHT_ARM_EXIDX;
6487       hdr->sh_flags |= SHF_LINK_ORDER;
6488     }
6489   return TRUE;
6490 }
6491
6492 /* Handle an ARM specific section when reading an object file.  This is
6493    called when bfd_section_from_shdr finds a section with an unknown
6494    type.  */
6495
6496 static bfd_boolean
6497 elf32_arm_section_from_shdr (bfd *abfd,
6498                              Elf_Internal_Shdr * hdr,
6499                              const char *name,
6500                              int shindex)
6501 {
6502   /* There ought to be a place to keep ELF backend specific flags, but
6503      at the moment there isn't one.  We just keep track of the
6504      sections by their name, instead.  Fortunately, the ABI gives
6505      names for all the ARM specific sections, so we will probably get
6506      away with this.  */
6507   switch (hdr->sh_type)
6508     {
6509     case SHT_ARM_EXIDX:
6510       break;
6511
6512     default:
6513       return FALSE;
6514     }
6515
6516   if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
6517     return FALSE;
6518
6519   return TRUE;
6520 }
6521
6522 /* Called for each symbol.  Builds a section map based on mapping symbols.
6523    Does not alter any of the symbols.  */
6524
6525 static bfd_boolean
6526 elf32_arm_output_symbol_hook (struct bfd_link_info *info,
6527                               const char *name,
6528                               Elf_Internal_Sym *elfsym,
6529                               asection *input_sec,
6530                               struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
6531 {
6532   int mapcount;
6533   elf32_arm_section_map *map;
6534   struct elf32_arm_link_hash_table *globals;
6535
6536   /* Only do this on final link.  */
6537   if (info->relocatable)
6538     return TRUE;
6539
6540   /* Only build a map if we need to byteswap code.  */
6541   globals = elf32_arm_hash_table (info);
6542   if (!globals->byteswap_code)
6543     return TRUE;
6544
6545   /* We only want mapping symbols.  */
6546   if (! bfd_is_arm_mapping_symbol_name (name))
6547     return TRUE;
6548
6549   mapcount = ++(elf32_arm_section_data (input_sec)->mapcount);
6550   map = elf32_arm_section_data (input_sec)->map;
6551   /* TODO: This may be inefficient, but we probably don't usually have many
6552      mapping symbols per section.  */
6553   map = bfd_realloc (map, mapcount * sizeof (elf32_arm_section_map));
6554   elf32_arm_section_data (input_sec)->map = map;
6555
6556   map[mapcount - 1].vma = elfsym->st_value;
6557   map[mapcount - 1].type = name[1];
6558   return TRUE;
6559 }
6560
6561
6562 /* Allocate target specific section data.  */
6563
6564 static bfd_boolean
6565 elf32_arm_new_section_hook (bfd *abfd, asection *sec)
6566 {
6567   struct _arm_elf_section_data *sdata;
6568   bfd_size_type amt = sizeof (*sdata);
6569
6570   sdata = bfd_zalloc (abfd, amt);
6571   if (sdata == NULL)
6572     return FALSE;
6573   sec->used_by_bfd = sdata;
6574
6575   return _bfd_elf_new_section_hook (abfd, sec);
6576 }
6577
6578
6579 /* Used to order a list of mapping symbols by address.  */
6580
6581 static int
6582 elf32_arm_compare_mapping (const void * a, const void * b)
6583 {
6584   return ((const elf32_arm_section_map *) a)->vma
6585          > ((const elf32_arm_section_map *) b)->vma;
6586 }
6587
6588
6589 /* Do code byteswapping.  Return FALSE afterwards so that the section is
6590    written out as normal.  */
6591
6592 static bfd_boolean
6593 elf32_arm_write_section (bfd *output_bfd ATTRIBUTE_UNUSED, asection *sec,
6594                          bfd_byte *contents)
6595 {
6596   int mapcount;
6597   elf32_arm_section_map *map;
6598   bfd_vma ptr;
6599   bfd_vma end;
6600   bfd_vma offset;
6601   bfd_byte tmp;
6602   int i;
6603
6604   mapcount = elf32_arm_section_data (sec)->mapcount;
6605   map = elf32_arm_section_data (sec)->map;
6606
6607   if (mapcount == 0)
6608     return FALSE;
6609
6610   qsort (map, mapcount, sizeof (elf32_arm_section_map),
6611          elf32_arm_compare_mapping);
6612
6613   offset = sec->output_section->vma + sec->output_offset;
6614   ptr = map[0].vma - offset;
6615   for (i = 0; i < mapcount; i++)
6616     {
6617       if (i == mapcount - 1)
6618         end = sec->size;
6619       else
6620         end = map[i + 1].vma - offset;
6621
6622       switch (map[i].type)
6623         {
6624         case 'a':
6625           /* Byte swap code words.  */
6626           while (ptr + 3 < end)
6627             {
6628               tmp = contents[ptr];
6629               contents[ptr] = contents[ptr + 3];
6630               contents[ptr + 3] = tmp;
6631               tmp = contents[ptr + 1];
6632               contents[ptr + 1] = contents[ptr + 2];
6633               contents[ptr + 2] = tmp;
6634               ptr += 4;
6635             }
6636           break;
6637
6638         case 't':
6639           /* Byte swap code halfwords.  */
6640           while (ptr + 1 < end)
6641             {
6642               tmp = contents[ptr];
6643               contents[ptr] = contents[ptr + 1];
6644               contents[ptr + 1] = tmp;
6645               ptr += 2;
6646             }
6647           break;
6648
6649         case 'd':
6650           /* Leave data alone.  */
6651           break;
6652         }
6653       ptr = end;
6654     }
6655   free (map);
6656   return FALSE;
6657 }
6658
6659 /* Display STT_ARM_TFUNC symbols as functions.  */
6660
6661 static void
6662 elf32_arm_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED,
6663                              asymbol *asym)
6664 {
6665   elf_symbol_type *elfsym = (elf_symbol_type *) asym;
6666
6667   if (ELF_ST_TYPE (elfsym->internal_elf_sym.st_info) == STT_ARM_TFUNC)
6668     elfsym->symbol.flags |= BSF_FUNCTION;
6669 }
6670
6671
6672 /* Mangle thumb function symbols as we read them in.  */
6673
6674 static void
6675 elf32_arm_swap_symbol_in (bfd * abfd,
6676                           const void *psrc,
6677                           const void *pshn,
6678                           Elf_Internal_Sym *dst)
6679 {
6680   bfd_elf32_swap_symbol_in (abfd, psrc, pshn, dst);
6681
6682   /* New EABI objects mark thumb function symbols by setting the low bit of
6683      the address.  Turn these into STT_ARM_TFUNC.  */
6684   if (ELF_ST_TYPE (dst->st_info) == STT_FUNC
6685       && (dst->st_value & 1))
6686     {
6687       dst->st_info = ELF_ST_INFO (ELF_ST_BIND (dst->st_info), STT_ARM_TFUNC);
6688       dst->st_value &= ~(bfd_vma) 1;
6689     }
6690 }
6691
6692
6693 /* Mangle thumb function symbols as we write them out.  */
6694
6695 static void
6696 elf32_arm_swap_symbol_out (bfd *abfd,
6697                            const Elf_Internal_Sym *src,
6698                            void *cdst,
6699                            void *shndx)
6700 {
6701   Elf_Internal_Sym newsym;
6702
6703   /* We convert STT_ARM_TFUNC symbols into STT_FUNC with the low bit
6704      of the address set, as per the new EABI.  We do this unconditionally
6705      because objcopy does not set the elf header flags until after
6706      it writes out the symbol table.  */
6707   if (ELF_ST_TYPE (src->st_info) == STT_ARM_TFUNC)
6708     {
6709       newsym = *src;
6710       newsym.st_info = ELF_ST_INFO (ELF_ST_BIND (src->st_info), STT_FUNC);
6711       newsym.st_value |= 1;
6712
6713       src = &newsym;
6714     }
6715   bfd_elf32_swap_symbol_out (abfd, src, cdst, shndx);
6716 }
6717
6718 /* Add the PT_ARM_EXIDX program header.  */
6719
6720 static bfd_boolean
6721 elf32_arm_modify_segment_map (bfd *abfd,
6722                               struct bfd_link_info *info ATTRIBUTE_UNUSED)
6723 {
6724   struct elf_segment_map *m;
6725   asection *sec;
6726
6727   sec = bfd_get_section_by_name (abfd, ".ARM.exidx");
6728   if (sec != NULL && (sec->flags & SEC_LOAD) != 0)
6729     {
6730       /* If there is already a PT_ARM_EXIDX header, then we do not
6731          want to add another one.  This situation arises when running
6732          "strip"; the input binary already has the header.  */
6733       m = elf_tdata (abfd)->segment_map;
6734       while (m && m->p_type != PT_ARM_EXIDX)
6735         m = m->next;
6736       if (!m)
6737         {
6738           m = bfd_zalloc (abfd, sizeof (struct elf_segment_map));
6739           if (m == NULL)
6740             return FALSE;
6741           m->p_type = PT_ARM_EXIDX;
6742           m->count = 1;
6743           m->sections[0] = sec;
6744
6745           m->next = elf_tdata (abfd)->segment_map;
6746           elf_tdata (abfd)->segment_map = m;
6747         }
6748     }
6749
6750   return TRUE;
6751 }
6752
6753 /* We may add a PT_ARM_EXIDX program header.  */
6754
6755 static int
6756 elf32_arm_additional_program_headers (bfd *abfd)
6757 {
6758   asection *sec;
6759
6760   sec = bfd_get_section_by_name (abfd, ".ARM.exidx");
6761   if (sec != NULL && (sec->flags & SEC_LOAD) != 0)
6762     return 1;
6763   else
6764     return 0;
6765 }
6766
6767 /* We use this to override swap_symbol_in and swap_symbol_out.  */
6768 const struct elf_size_info elf32_arm_size_info = {
6769   sizeof (Elf32_External_Ehdr),
6770   sizeof (Elf32_External_Phdr),
6771   sizeof (Elf32_External_Shdr),
6772   sizeof (Elf32_External_Rel),
6773   sizeof (Elf32_External_Rela),
6774   sizeof (Elf32_External_Sym),
6775   sizeof (Elf32_External_Dyn),
6776   sizeof (Elf_External_Note),
6777   4,
6778   1,
6779   32, 2,
6780   ELFCLASS32, EV_CURRENT,
6781   bfd_elf32_write_out_phdrs,
6782   bfd_elf32_write_shdrs_and_ehdr,
6783   bfd_elf32_write_relocs,
6784   elf32_arm_swap_symbol_in,
6785   elf32_arm_swap_symbol_out,
6786   bfd_elf32_slurp_reloc_table,
6787   bfd_elf32_slurp_symbol_table,
6788   bfd_elf32_swap_dyn_in,
6789   bfd_elf32_swap_dyn_out,
6790   bfd_elf32_swap_reloc_in,
6791   bfd_elf32_swap_reloc_out,
6792   bfd_elf32_swap_reloca_in,
6793   bfd_elf32_swap_reloca_out
6794 };
6795
6796 #define ELF_ARCH                        bfd_arch_arm
6797 #define ELF_MACHINE_CODE                EM_ARM
6798 #ifdef __QNXTARGET__
6799 #define ELF_MAXPAGESIZE                 0x1000
6800 #else
6801 #define ELF_MAXPAGESIZE                 0x8000
6802 #endif
6803 #define ELF_MINPAGESIZE                 0x1000
6804
6805 #define bfd_elf32_mkobject                      elf32_arm_mkobject
6806
6807 #define bfd_elf32_bfd_copy_private_bfd_data     elf32_arm_copy_private_bfd_data
6808 #define bfd_elf32_bfd_merge_private_bfd_data    elf32_arm_merge_private_bfd_data
6809 #define bfd_elf32_bfd_set_private_flags         elf32_arm_set_private_flags
6810 #define bfd_elf32_bfd_print_private_bfd_data    elf32_arm_print_private_bfd_data
6811 #define bfd_elf32_bfd_link_hash_table_create    elf32_arm_link_hash_table_create
6812 #define bfd_elf32_bfd_reloc_type_lookup         elf32_arm_reloc_type_lookup
6813 #define bfd_elf32_find_nearest_line             elf32_arm_find_nearest_line
6814 #define bfd_elf32_find_inliner_info             elf32_arm_find_inliner_info
6815 #define bfd_elf32_new_section_hook              elf32_arm_new_section_hook
6816 #define bfd_elf32_bfd_is_target_special_symbol  elf32_arm_is_target_special_symbol
6817
6818 #define elf_backend_get_symbol_type             elf32_arm_get_symbol_type
6819 #define elf_backend_gc_mark_hook                elf32_arm_gc_mark_hook
6820 #define elf_backend_gc_sweep_hook               elf32_arm_gc_sweep_hook
6821 #define elf_backend_check_relocs                elf32_arm_check_relocs
6822 #define elf_backend_relocate_section            elf32_arm_relocate_section
6823 #define elf_backend_write_section               elf32_arm_write_section
6824 #define elf_backend_adjust_dynamic_symbol       elf32_arm_adjust_dynamic_symbol
6825 #define elf_backend_create_dynamic_sections     elf32_arm_create_dynamic_sections
6826 #define elf_backend_finish_dynamic_symbol       elf32_arm_finish_dynamic_symbol
6827 #define elf_backend_finish_dynamic_sections     elf32_arm_finish_dynamic_sections
6828 #define elf_backend_link_output_symbol_hook     elf32_arm_output_symbol_hook
6829 #define elf_backend_size_dynamic_sections       elf32_arm_size_dynamic_sections
6830 #define elf_backend_post_process_headers        elf32_arm_post_process_headers
6831 #define elf_backend_reloc_type_class            elf32_arm_reloc_type_class
6832 #define elf_backend_object_p                    elf32_arm_object_p
6833 #define elf_backend_section_flags               elf32_arm_section_flags
6834 #define elf_backend_fake_sections               elf32_arm_fake_sections
6835 #define elf_backend_section_from_shdr           elf32_arm_section_from_shdr
6836 #define elf_backend_final_write_processing      elf32_arm_final_write_processing
6837 #define elf_backend_copy_indirect_symbol        elf32_arm_copy_indirect_symbol
6838 #define elf_backend_symbol_processing           elf32_arm_symbol_processing
6839 #define elf_backend_size_info                   elf32_arm_size_info
6840 #define elf_backend_modify_segment_map          elf32_arm_modify_segment_map
6841 #define elf_backend_additional_program_headers \
6842   elf32_arm_additional_program_headers
6843
6844 #define elf_backend_can_refcount    1
6845 #define elf_backend_can_gc_sections 1
6846 #define elf_backend_plt_readonly    1
6847 #define elf_backend_want_got_plt    1
6848 #define elf_backend_want_plt_sym    0
6849 #define elf_backend_may_use_rel_p   1
6850 #define elf_backend_may_use_rela_p  0
6851 #define elf_backend_default_use_rela_p 0
6852 #define elf_backend_rela_normal     0
6853
6854 #define elf_backend_got_header_size     12
6855
6856 #include "elf32-target.h"
6857
6858 /* VxWorks Targets */
6859
6860 #undef TARGET_LITTLE_SYM
6861 #define TARGET_LITTLE_SYM               bfd_elf32_littlearm_vxworks_vec
6862 #undef TARGET_LITTLE_NAME
6863 #define TARGET_LITTLE_NAME              "elf32-littlearm-vxworks"
6864 #undef TARGET_BIG_SYM
6865 #define TARGET_BIG_SYM                  bfd_elf32_bigarm_vxworks_vec
6866 #undef TARGET_BIG_NAME
6867 #define TARGET_BIG_NAME                 "elf32-bigarm-vxworks"
6868
6869 /* Like elf32_arm_link_hash_table_create -- but overrides
6870    appropriately for VxWorks.  */
6871 static struct bfd_link_hash_table *
6872 elf32_arm_vxworks_link_hash_table_create (bfd *abfd)
6873 {
6874   struct bfd_link_hash_table *ret;
6875
6876   ret = elf32_arm_link_hash_table_create (abfd);
6877   if (ret)
6878     {
6879       struct elf32_arm_link_hash_table *htab
6880         = (struct elf32_arm_link_hash_table *)ret;
6881       htab->use_rel = 0;
6882     }
6883   return ret;
6884 }
6885
6886 #undef elf32_bed
6887 #define elf32_bed elf32_arm_vxworks_bed
6888
6889 #undef bfd_elf32_bfd_link_hash_table_create
6890 #define bfd_elf32_bfd_link_hash_table_create \
6891   elf32_arm_vxworks_link_hash_table_create
6892
6893 #undef elf_backend_may_use_rel_p
6894 #define elf_backend_may_use_rel_p   0
6895 #undef elf_backend_may_use_rela_p
6896 #define elf_backend_may_use_rela_p  1
6897 #undef elf_backend_default_use_rela_p
6898 #define elf_backend_default_use_rela_p 1
6899 #undef elf_backend_rela_normal
6900 #define elf_backend_rela_normal     1
6901
6902 #include "elf32-target.h"
6903
6904
6905 /* Symbian OS Targets */
6906
6907 #undef TARGET_LITTLE_SYM
6908 #define TARGET_LITTLE_SYM               bfd_elf32_littlearm_symbian_vec
6909 #undef TARGET_LITTLE_NAME
6910 #define TARGET_LITTLE_NAME              "elf32-littlearm-symbian"
6911 #undef TARGET_BIG_SYM
6912 #define TARGET_BIG_SYM                  bfd_elf32_bigarm_symbian_vec
6913 #undef TARGET_BIG_NAME
6914 #define TARGET_BIG_NAME                 "elf32-bigarm-symbian"
6915
6916 /* Like elf32_arm_link_hash_table_create -- but overrides
6917    appropriately for Symbian OS.  */
6918 static struct bfd_link_hash_table *
6919 elf32_arm_symbian_link_hash_table_create (bfd *abfd)
6920 {
6921   struct bfd_link_hash_table *ret;
6922
6923   ret = elf32_arm_link_hash_table_create (abfd);
6924   if (ret)
6925     {
6926       struct elf32_arm_link_hash_table *htab
6927         = (struct elf32_arm_link_hash_table *)ret;
6928       /* There is no PLT header for Symbian OS.  */
6929       htab->plt_header_size = 0;
6930       /* The PLT entries are each three instructions.  */
6931       htab->plt_entry_size = 4 * NUM_ELEM (elf32_arm_symbian_plt_entry);
6932       htab->symbian_p = 1;
6933       /* Symbian uses armv5t or above, so use_blx is always true.  */
6934       htab->use_blx = 1;
6935       htab->root.is_relocatable_executable = 1;
6936     }
6937   return ret;
6938 }
6939
6940 static struct bfd_elf_special_section const
6941   symbian_special_sections_d[]=
6942 {
6943   /* In a BPABI executable, the dynamic linking sections do not go in
6944      the loadable read-only segment.  The post-linker may wish to
6945      refer to these sections, but they are not part of the final
6946      program image.  */
6947   { ".dynamic",        8,  0, SHT_DYNAMIC,  0 },
6948   { ".dynstr",         7,  0, SHT_STRTAB,   0 },
6949   { ".dynsym",         7,  0, SHT_DYNSYM,   0 },
6950   { NULL,              0,  0, 0,            0 }
6951 };
6952
6953 static struct bfd_elf_special_section const
6954   symbian_special_sections_g[]=
6955 {
6956   /* In a BPABI executable, the dynamic linking sections do not go in
6957      the loadable read-only segment.  The post-linker may wish to
6958      refer to these sections, but they are not part of the final
6959      program image.  */
6960   { ".got",            4,  0, SHT_PROGBITS, 0 },
6961   { NULL,              0,  0, 0,            0 }
6962 };
6963
6964 static struct bfd_elf_special_section const
6965   symbian_special_sections_h[]=
6966 {
6967   /* In a BPABI executable, the dynamic linking sections do not go in
6968      the loadable read-only segment.  The post-linker may wish to
6969      refer to these sections, but they are not part of the final
6970      program image.  */
6971   { ".hash",           5,  0, SHT_HASH,     0 },
6972   { NULL,              0,  0, 0,            0 }
6973 };
6974
6975 static struct bfd_elf_special_section const
6976   symbian_special_sections_i[]=
6977 {
6978   /* These sections do not need to be writable as the SymbianOS
6979      postlinker will arrange things so that no dynamic relocation is
6980      required.  */
6981   { ".init_array",    11,  0, SHT_INIT_ARRAY, SHF_ALLOC },
6982   { NULL,              0,  0, 0,            0 }
6983 };
6984
6985 static struct bfd_elf_special_section const
6986   symbian_special_sections_f[]=
6987 {
6988   /* These sections do not need to be writable as the SymbianOS
6989      postlinker will arrange things so that no dynamic relocation is
6990      required.  */
6991   { ".fini_array",    11,  0, SHT_FINI_ARRAY, SHF_ALLOC },
6992   { NULL,              0,  0, 0,            0 }
6993 };
6994
6995 static struct bfd_elf_special_section const
6996   symbian_special_sections_p[]=
6997 {
6998   /* These sections do not need to be writable as the SymbianOS
6999      postlinker will arrange things so that no dynamic relocation is
7000      required.  */
7001   { ".preinit_array", 14,  0, SHT_PREINIT_ARRAY, SHF_ALLOC },
7002   { NULL,              0,  0, 0,            0 }
7003 };
7004
7005 static struct bfd_elf_special_section const *
7006   elf32_arm_symbian_special_sections[27]=
7007 {
7008   NULL,                         /* 'a' */
7009   NULL,                         /* 'b' */
7010   NULL,                         /* 'c' */
7011   symbian_special_sections_d,   /* 'd' */
7012   NULL,                         /* 'e' */
7013   symbian_special_sections_f,   /* 'f' */
7014   symbian_special_sections_g,   /* 'g' */
7015   symbian_special_sections_h,   /* 'h' */
7016   symbian_special_sections_i,   /* 'i' */
7017   NULL,                         /* 'j' */
7018   NULL,                         /* 'k' */
7019   NULL,                         /* 'l' */
7020   NULL,                         /* 'm' */
7021   NULL,                         /* 'n' */
7022   NULL,                         /* 'o' */
7023   symbian_special_sections_p,   /* 'p' */
7024   NULL,                         /* 'q' */
7025   NULL,                         /* 'r' */
7026   NULL,                         /* 's' */
7027   NULL,                         /* 't' */
7028   NULL,                         /* 'u' */
7029   NULL,                         /* 'v' */
7030   NULL,                         /* 'w' */
7031   NULL,                         /* 'x' */
7032   NULL,                         /* 'y' */
7033   NULL,                         /* 'z' */
7034   NULL                          /* other */
7035 };
7036
7037 static void
7038 elf32_arm_symbian_begin_write_processing (bfd *abfd,
7039                                           struct bfd_link_info *link_info
7040                                             ATTRIBUTE_UNUSED)
7041 {
7042   /* BPABI objects are never loaded directly by an OS kernel; they are
7043      processed by a postlinker first, into an OS-specific format.  If
7044      the D_PAGED bit is set on the file, BFD will align segments on
7045      page boundaries, so that an OS can directly map the file.  With
7046      BPABI objects, that just results in wasted space.  In addition,
7047      because we clear the D_PAGED bit, map_sections_to_segments will
7048      recognize that the program headers should not be mapped into any
7049      loadable segment.  */
7050   abfd->flags &= ~D_PAGED;
7051 }
7052
7053 static bfd_boolean
7054 elf32_arm_symbian_modify_segment_map (bfd *abfd,
7055                                       struct bfd_link_info *info)
7056 {
7057   struct elf_segment_map *m;
7058   asection *dynsec;
7059
7060   /* BPABI shared libraries and executables should have a PT_DYNAMIC
7061      segment.  However, because the .dynamic section is not marked
7062      with SEC_LOAD, the generic ELF code will not create such a
7063      segment.  */
7064   dynsec = bfd_get_section_by_name (abfd, ".dynamic");
7065   if (dynsec)
7066     {
7067       m = _bfd_elf_make_dynamic_segment (abfd, dynsec);
7068       m->next = elf_tdata (abfd)->segment_map;
7069       elf_tdata (abfd)->segment_map = m;
7070     }
7071
7072   /* Also call the generic arm routine.  */
7073   return elf32_arm_modify_segment_map (abfd, info);
7074 }
7075
7076 #undef elf32_bed
7077 #define elf32_bed elf32_arm_symbian_bed
7078
7079 /* The dynamic sections are not allocated on SymbianOS; the postlinker
7080    will process them and then discard them.  */
7081 #undef ELF_DYNAMIC_SEC_FLAGS
7082 #define ELF_DYNAMIC_SEC_FLAGS \
7083   (SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED)
7084
7085 #undef bfd_elf32_bfd_link_hash_table_create
7086 #define bfd_elf32_bfd_link_hash_table_create \
7087   elf32_arm_symbian_link_hash_table_create
7088
7089 #undef elf_backend_special_sections
7090 #define elf_backend_special_sections elf32_arm_symbian_special_sections
7091
7092 #undef elf_backend_begin_write_processing
7093 #define elf_backend_begin_write_processing \
7094     elf32_arm_symbian_begin_write_processing
7095
7096 #undef elf_backend_modify_segment_map
7097 #define elf_backend_modify_segment_map elf32_arm_symbian_modify_segment_map
7098
7099 /* There is no .got section for BPABI objects, and hence no header.  */
7100 #undef elf_backend_got_header_size
7101 #define elf_backend_got_header_size 0
7102
7103 /* Similarly, there is no .got.plt section.  */
7104 #undef elf_backend_want_got_plt
7105 #define elf_backend_want_got_plt 0
7106
7107 #undef elf_backend_may_use_rel_p
7108 #define elf_backend_may_use_rel_p   1
7109 #undef elf_backend_may_use_rela_p
7110 #define elf_backend_may_use_rela_p  0
7111 #undef elf_backend_default_use_rela_p
7112 #define elf_backend_default_use_rela_p 0
7113 #undef elf_backend_rela_normal
7114 #define elf_backend_rela_normal     0
7115
7116 #include "elf32-target.h"