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 "bfd.h"
  22 #include "sysdep.h"
  23 #include "libbfd.h"
  24 #include "elf-bfd.h"
  25 #include "elf/arm.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          24,                    /* 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          FALSE,                 /* 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 typedef struct _arm_elf_section_data
1519 {
1520   struct bfd_elf_section_data elf;
1521   unsigned int mapcount;
1522   elf32_arm_section_map *map;
1523 }
1524 _arm_elf_section_data;
1525
1526 #define elf32_arm_section_data(sec) \
1527   ((_arm_elf_section_data *) elf_section_data (sec))
1528
1529 /* The size of the thread control block.  */
1530 #define TCB_SIZE        8
1531
1532 #define NUM_KNOWN_ATTRIBUTES 32
1533
1534 typedef struct aeabi_attribute
1535 {
1536   int type;
1537   unsigned int i;
1538   char *s;
1539 } aeabi_attribute;
1540
1541 typedef struct aeabi_attribute_list
1542 {
1543   struct aeabi_attribute_list *next;
1544   int tag;
1545   aeabi_attribute attr;
1546 } aeabi_attribute_list;
1547
1548 struct elf32_arm_obj_tdata
1549 {
1550   struct elf_obj_tdata root;
1551
1552   /* tls_type for each local got entry.  */
1553   char *local_got_tls_type;
1554
1555   aeabi_attribute known_eabi_attributes[NUM_KNOWN_ATTRIBUTES];
1556   aeabi_attribute_list *other_eabi_attributes;
1557 };
1558
1559 #define elf32_arm_tdata(abfd) \
1560   ((struct elf32_arm_obj_tdata *) (abfd)->tdata.any)
1561
1562 #define elf32_arm_local_got_tls_type(abfd) \
1563   (elf32_arm_tdata (abfd)->local_got_tls_type)
1564
1565 static bfd_boolean
1566 elf32_arm_mkobject (bfd *abfd)
1567 {
1568   bfd_size_type amt = sizeof (struct elf32_arm_obj_tdata);
1569   abfd->tdata.any = bfd_zalloc (abfd, amt);
1570   if (abfd->tdata.any == NULL)
1571     return FALSE;
1572   return TRUE;
1573 }
1574
1575 /* The ARM linker needs to keep track of the number of relocs that it
1576    decides to copy in check_relocs for each symbol.  This is so that
1577    it can discard PC relative relocs if it doesn't need them when
1578    linking with -Bsymbolic.  We store the information in a field
1579    extending the regular ELF linker hash table.  */
1580
1581 /* This structure keeps track of the number of relocs we have copied
1582    for a given symbol.  */
1583 struct elf32_arm_relocs_copied
1584   {
1585     /* Next section.  */
1586     struct elf32_arm_relocs_copied * next;
1587     /* A section in dynobj.  */
1588     asection * section;
1589     /* Number of relocs copied in this section.  */
1590     bfd_size_type count;
1591     /* Number of PC-relative relocs copied in this section.  */
1592     bfd_size_type pc_count;
1593   };
1594
1595 #define elf32_arm_hash_entry(ent) ((struct elf32_arm_link_hash_entry *)(ent))
1596
1597 /* Arm ELF linker hash entry.  */
1598 struct elf32_arm_link_hash_entry
1599   {
1600     struct elf_link_hash_entry root;
1601
1602     /* Number of PC relative relocs copied for this symbol.  */
1603     struct elf32_arm_relocs_copied * relocs_copied;
1604
1605     /* We reference count Thumb references to a PLT entry separately,
1606        so that we can emit the Thumb trampoline only if needed.  */
1607     bfd_signed_vma plt_thumb_refcount;
1608
1609     /* Since PLT entries have variable size if the Thumb prologue is
1610        used, we need to record the index into .got.plt instead of
1611        recomputing it from the PLT offset.  */
1612     bfd_signed_vma plt_got_offset;
1613
1614 #define GOT_UNKNOWN     0
1615 #define GOT_NORMAL      1
1616 #define GOT_TLS_GD      2
1617 #define GOT_TLS_IE      4
1618     unsigned char tls_type;
1619   };
1620
1621 /* Traverse an arm ELF linker hash table.  */
1622 #define elf32_arm_link_hash_traverse(table, func, info)                 \
1623   (elf_link_hash_traverse                                               \
1624    (&(table)->root,                                                     \
1625     (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func),    \
1626     (info)))
1627
1628 /* Get the ARM elf linker hash table from a link_info structure.  */
1629 #define elf32_arm_hash_table(info) \
1630   ((struct elf32_arm_link_hash_table *) ((info)->hash))
1631
1632 /* ARM ELF linker hash table.  */
1633 struct elf32_arm_link_hash_table
1634   {
1635     /* The main hash table.  */
1636     struct elf_link_hash_table root;
1637
1638     /* The size in bytes of the section containing the Thumb-to-ARM glue.  */
1639     bfd_size_type thumb_glue_size;
1640
1641     /* The size in bytes of the section containing the ARM-to-Thumb glue.  */
1642     bfd_size_type arm_glue_size;
1643
1644     /* An arbitrary input BFD chosen to hold the glue sections.  */
1645     bfd * bfd_of_glue_owner;
1646
1647     /* Nonzero to output a BE8 image.  */
1648     int byteswap_code;
1649
1650     /* Zero if R_ARM_TARGET1 means R_ARM_ABS32.
1651        Nonzero if R_ARM_TARGET1 means R_ARM_ABS32.  */
1652     int target1_is_rel;
1653
1654     /* The relocation to use for R_ARM_TARGET2 relocations.  */
1655     int target2_reloc;
1656
1657     /* Nonzero to fix BX instructions for ARMv4 targets.  */
1658     int fix_v4bx;
1659
1660     /* Nonzero if the ARM/Thumb BLX instructions are available for use.  */
1661     int use_blx;
1662
1663     /* The number of bytes in the initial entry in the PLT.  */
1664     bfd_size_type plt_header_size;
1665
1666     /* The number of bytes in the subsequent PLT etries.  */
1667     bfd_size_type plt_entry_size;
1668
1669     /* True if the target system is Symbian OS.  */
1670     int symbian_p;
1671
1672     /* True if the target uses REL relocations.  */
1673     int use_rel;
1674
1675     /* Short-cuts to get to dynamic linker sections.  */
1676     asection *sgot;
1677     asection *sgotplt;
1678     asection *srelgot;
1679     asection *splt;
1680     asection *srelplt;
1681     asection *sdynbss;
1682     asection *srelbss;
1683
1684     /* Data for R_ARM_TLS_LDM32 relocations.  */
1685     union {
1686       bfd_signed_vma refcount;
1687       bfd_vma offset;
1688     } tls_ldm_got;
1689
1690     /* Small local sym to section mapping cache.  */
1691     struct sym_sec_cache sym_sec;
1692
1693     /* For convenience in allocate_dynrelocs.  */
1694     bfd * obfd;
1695   };
1696
1697 /* Create an entry in an ARM ELF linker hash table.  */
1698
1699 static struct bfd_hash_entry *
1700 elf32_arm_link_hash_newfunc (struct bfd_hash_entry * entry,
1701                              struct bfd_hash_table * table,
1702                              const char * string)
1703 {
1704   struct elf32_arm_link_hash_entry * ret =
1705     (struct elf32_arm_link_hash_entry *) entry;
1706
1707   /* Allocate the structure if it has not already been allocated by a
1708      subclass.  */
1709   if (ret == (struct elf32_arm_link_hash_entry *) NULL)
1710     ret = bfd_hash_allocate (table, sizeof (struct elf32_arm_link_hash_entry));
1711   if (ret == NULL)
1712     return (struct bfd_hash_entry *) ret;
1713
1714   /* Call the allocation method of the superclass.  */
1715   ret = ((struct elf32_arm_link_hash_entry *)
1716          _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
1717                                      table, string));
1718   if (ret != NULL)
1719     {
1720       ret->relocs_copied = NULL;
1721       ret->tls_type = GOT_UNKNOWN;
1722       ret->plt_thumb_refcount = 0;
1723       ret->plt_got_offset = -1;
1724     }
1725
1726   return (struct bfd_hash_entry *) ret;
1727 }
1728
1729 /* Create .got, .gotplt, and .rel.got sections in DYNOBJ, and set up
1730    shortcuts to them in our hash table.  */
1731
1732 static bfd_boolean
1733 create_got_section (bfd *dynobj, struct bfd_link_info *info)
1734 {
1735   struct elf32_arm_link_hash_table *htab;
1736
1737   htab = elf32_arm_hash_table (info);
1738   /* BPABI objects never have a GOT, or associated sections.  */
1739   if (htab->symbian_p)
1740     return TRUE;
1741
1742   if (! _bfd_elf_create_got_section (dynobj, info))
1743     return FALSE;
1744
1745   htab->sgot = bfd_get_section_by_name (dynobj, ".got");
1746   htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
1747   if (!htab->sgot || !htab->sgotplt)
1748     abort ();
1749
1750   htab->srelgot = bfd_make_section_with_flags (dynobj, ".rel.got",
1751                                                (SEC_ALLOC | SEC_LOAD
1752                                                 | SEC_HAS_CONTENTS
1753                                                 | SEC_IN_MEMORY
1754                                                 | SEC_LINKER_CREATED
1755                                                 | SEC_READONLY));
1756   if (htab->srelgot == NULL
1757       || ! bfd_set_section_alignment (dynobj, htab->srelgot, 2))
1758     return FALSE;
1759   return TRUE;
1760 }
1761
1762 /* Create .plt, .rel.plt, .got, .got.plt, .rel.got, .dynbss, and
1763    .rel.bss sections in DYNOBJ, and set up shortcuts to them in our
1764    hash table.  */
1765
1766 static bfd_boolean
1767 elf32_arm_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
1768 {
1769   struct elf32_arm_link_hash_table *htab;
1770
1771   htab = elf32_arm_hash_table (info);
1772   if (!htab->sgot && !create_got_section (dynobj, info))
1773     return FALSE;
1774
1775   if (!_bfd_elf_create_dynamic_sections (dynobj, info))
1776     return FALSE;
1777
1778   htab->splt = bfd_get_section_by_name (dynobj, ".plt");
1779   htab->srelplt = bfd_get_section_by_name (dynobj, ".rel.plt");
1780   htab->sdynbss = bfd_get_section_by_name (dynobj, ".dynbss");
1781   if (!info->shared)
1782     htab->srelbss = bfd_get_section_by_name (dynobj, ".rel.bss");
1783
1784   if (!htab->splt
1785       || !htab->srelplt
1786       || !htab->sdynbss
1787       || (!info->shared && !htab->srelbss))
1788     abort ();
1789
1790   return TRUE;
1791 }
1792
1793 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
1794
1795 static void
1796 elf32_arm_copy_indirect_symbol (struct bfd_link_info *info,
1797                                 struct elf_link_hash_entry *dir,
1798                                 struct elf_link_hash_entry *ind)
1799 {
1800   struct elf32_arm_link_hash_entry *edir, *eind;
1801
1802   edir = (struct elf32_arm_link_hash_entry *) dir;
1803   eind = (struct elf32_arm_link_hash_entry *) ind;
1804
1805   if (eind->relocs_copied != NULL)
1806     {
1807       if (edir->relocs_copied != NULL)
1808         {
1809           struct elf32_arm_relocs_copied **pp;
1810           struct elf32_arm_relocs_copied *p;
1811
1812           /* Add reloc counts against the indirect sym to the direct sym
1813              list.  Merge any entries against the same section.  */
1814           for (pp = &eind->relocs_copied; (p = *pp) != NULL; )
1815             {
1816               struct elf32_arm_relocs_copied *q;
1817
1818               for (q = edir->relocs_copied; q != NULL; q = q->next)
1819                 if (q->section == p->section)
1820                   {
1821                     q->pc_count += p->pc_count;
1822                     q->count += p->count;
1823                     *pp = p->next;
1824                     break;
1825                   }
1826               if (q == NULL)
1827                 pp = &p->next;
1828             }
1829           *pp = edir->relocs_copied;
1830         }
1831
1832       edir->relocs_copied = eind->relocs_copied;
1833       eind->relocs_copied = NULL;
1834     }
1835
1836   /* Copy over PLT info.  */
1837   edir->plt_thumb_refcount += eind->plt_thumb_refcount;
1838   eind->plt_thumb_refcount = 0;
1839
1840   if (ind->root.type == bfd_link_hash_indirect
1841       && dir->got.refcount <= 0)
1842     {
1843       edir->tls_type = eind->tls_type;
1844       eind->tls_type = GOT_UNKNOWN;
1845     }
1846
1847   _bfd_elf_link_hash_copy_indirect (info, dir, ind);
1848 }
1849
1850 /* Create an ARM elf linker hash table.  */
1851
1852 static struct bfd_link_hash_table *
1853 elf32_arm_link_hash_table_create (bfd *abfd)
1854 {
1855   struct elf32_arm_link_hash_table *ret;
1856   bfd_size_type amt = sizeof (struct elf32_arm_link_hash_table);
1857
1858   ret = bfd_malloc (amt);
1859   if (ret == NULL)
1860     return NULL;
1861
1862   if (!_bfd_elf_link_hash_table_init (& ret->root, abfd,
1863                                       elf32_arm_link_hash_newfunc))
1864     {
1865       free (ret);
1866       return NULL;
1867     }
1868
1869   ret->sgot = NULL;
1870   ret->sgotplt = NULL;
1871   ret->srelgot = NULL;
1872   ret->splt = NULL;
1873   ret->srelplt = NULL;
1874   ret->sdynbss = NULL;
1875   ret->srelbss = NULL;
1876   ret->thumb_glue_size = 0;
1877   ret->arm_glue_size = 0;
1878   ret->bfd_of_glue_owner = NULL;
1879   ret->byteswap_code = 0;
1880   ret->target1_is_rel = 0;
1881   ret->target2_reloc = R_ARM_NONE;
1882 #ifdef FOUR_WORD_PLT
1883   ret->plt_header_size = 16;
1884   ret->plt_entry_size = 16;
1885 #else
1886   ret->plt_header_size = 20;
1887   ret->plt_entry_size = 12;
1888 #endif
1889   ret->fix_v4bx = 0;
1890   ret->use_blx = 0;
1891   ret->symbian_p = 0;
1892   ret->use_rel = 1;
1893   ret->sym_sec.abfd = NULL;
1894   ret->obfd = abfd;
1895   ret->tls_ldm_got.refcount = 0;
1896
1897   return &ret->root.root;
1898 }
1899
1900 /* Locate the Thumb encoded calling stub for NAME.  */
1901
1902 static struct elf_link_hash_entry *
1903 find_thumb_glue (struct bfd_link_info *link_info,
1904                  const char *name,
1905                  bfd *input_bfd)
1906 {
1907   char *tmp_name;
1908   struct elf_link_hash_entry *hash;
1909   struct elf32_arm_link_hash_table *hash_table;
1910
1911   /* We need a pointer to the armelf specific hash table.  */
1912   hash_table = elf32_arm_hash_table (link_info);
1913
1914   tmp_name = bfd_malloc ((bfd_size_type) strlen (name)
1915                          + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1);
1916
1917   BFD_ASSERT (tmp_name);
1918
1919   sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name);
1920
1921   hash = elf_link_hash_lookup
1922     (&(hash_table)->root, tmp_name, FALSE, FALSE, TRUE);
1923
1924   if (hash == NULL)
1925     /* xgettext:c-format */
1926     (*_bfd_error_handler) (_("%B: unable to find THUMB glue '%s' for `%s'"),
1927                            input_bfd, tmp_name, name);
1928
1929   free (tmp_name);
1930
1931   return hash;
1932 }
1933
1934 /* Locate the ARM encoded calling stub for NAME.  */
1935
1936 static struct elf_link_hash_entry *
1937 find_arm_glue (struct bfd_link_info *link_info,
1938                const char *name,
1939                bfd *input_bfd)
1940 {
1941   char *tmp_name;
1942   struct elf_link_hash_entry *myh;
1943   struct elf32_arm_link_hash_table *hash_table;
1944
1945   /* We need a pointer to the elfarm specific hash table.  */
1946   hash_table = elf32_arm_hash_table (link_info);
1947
1948   tmp_name = bfd_malloc ((bfd_size_type) strlen (name)
1949                          + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1);
1950
1951   BFD_ASSERT (tmp_name);
1952
1953   sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
1954
1955   myh = elf_link_hash_lookup
1956     (&(hash_table)->root, tmp_name, FALSE, FALSE, TRUE);
1957
1958   if (myh == NULL)
1959     /* xgettext:c-format */
1960     (*_bfd_error_handler) (_("%B: unable to find ARM glue '%s' for `%s'"),
1961                            input_bfd, tmp_name, name);
1962
1963   free (tmp_name);
1964
1965   return myh;
1966 }
1967
1968 /* ARM->Thumb glue (static images):
1969
1970    .arm
1971    __func_from_arm:
1972    ldr r12, __func_addr
1973    bx  r12
1974    __func_addr:
1975    .word func    @ behave as if you saw a ARM_32 reloc.
1976
1977    (relocatable images)
1978    .arm
1979    __func_from_arm:
1980    ldr r12, __func_offset
1981    add r12, r12, pc
1982    bx  r12
1983    __func_offset:
1984    .word func - .
1985    */
1986
1987 #define ARM2THUMB_STATIC_GLUE_SIZE 12
1988 static const insn32 a2t1_ldr_insn = 0xe59fc000;
1989 static const insn32 a2t2_bx_r12_insn = 0xe12fff1c;
1990 static const insn32 a2t3_func_addr_insn = 0x00000001;
1991
1992 #define ARM2THUMB_PIC_GLUE_SIZE 16
1993 static const insn32 a2t1p_ldr_insn = 0xe59fc004;
1994 static const insn32 a2t2p_add_pc_insn = 0xe08cc00f;
1995 static const insn32 a2t3p_bx_r12_insn = 0xe12fff1c;
1996
1997 /* Thumb->ARM:                          Thumb->(non-interworking aware) ARM
1998
1999    .thumb                               .thumb
2000    .align 2                             .align 2
2001    __func_from_thumb:              __func_from_thumb:
2002    bx pc                                push {r6, lr}
2003    nop                                  ldr  r6, __func_addr
2004    .arm                                         mov  lr, pc
2005    __func_change_to_arm:                        bx   r6
2006    b func                       .arm
2007    __func_back_to_thumb:
2008    ldmia r13! {r6, lr}
2009    bx    lr
2010    __func_addr:
2011    .word        func  */
2012
2013 #define THUMB2ARM_GLUE_SIZE 8
2014 static const insn16 t2a1_bx_pc_insn = 0x4778;
2015 static const insn16 t2a2_noop_insn = 0x46c0;
2016 static const insn32 t2a3_b_insn = 0xea000000;
2017
2018 #ifndef ELFARM_NABI_C_INCLUDED
2019 bfd_boolean
2020 bfd_elf32_arm_allocate_interworking_sections (struct bfd_link_info * info)
2021 {
2022   asection * s;
2023   bfd_byte * foo;
2024   struct elf32_arm_link_hash_table * globals;
2025
2026   globals = elf32_arm_hash_table (info);
2027
2028   BFD_ASSERT (globals != NULL);
2029
2030   if (globals->arm_glue_size != 0)
2031     {
2032       BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
2033
2034       s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
2035                                    ARM2THUMB_GLUE_SECTION_NAME);
2036
2037       BFD_ASSERT (s != NULL);
2038
2039       foo = bfd_alloc (globals->bfd_of_glue_owner, globals->arm_glue_size);
2040
2041       s->size = globals->arm_glue_size;
2042       s->contents = foo;
2043     }
2044
2045   if (globals->thumb_glue_size != 0)
2046     {
2047       BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
2048
2049       s = bfd_get_section_by_name
2050         (globals->bfd_of_glue_owner, THUMB2ARM_GLUE_SECTION_NAME);
2051
2052       BFD_ASSERT (s != NULL);
2053
2054       foo = bfd_alloc (globals->bfd_of_glue_owner, globals->thumb_glue_size);
2055
2056       s->size = globals->thumb_glue_size;
2057       s->contents = foo;
2058     }
2059
2060   return TRUE;
2061 }
2062
2063 static void
2064 record_arm_to_thumb_glue (struct bfd_link_info * link_info,
2065                           struct elf_link_hash_entry * h)
2066 {
2067   const char * name = h->root.root.string;
2068   asection * s;
2069   char * tmp_name;
2070   struct elf_link_hash_entry * myh;
2071   struct bfd_link_hash_entry * bh;
2072   struct elf32_arm_link_hash_table * globals;
2073   bfd_vma val;
2074
2075   globals = elf32_arm_hash_table (link_info);
2076
2077   BFD_ASSERT (globals != NULL);
2078   BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
2079
2080   s = bfd_get_section_by_name
2081     (globals->bfd_of_glue_owner, ARM2THUMB_GLUE_SECTION_NAME);
2082
2083   BFD_ASSERT (s != NULL);
2084
2085   tmp_name = bfd_malloc ((bfd_size_type) strlen (name) + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1);
2086
2087   BFD_ASSERT (tmp_name);
2088
2089   sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
2090
2091   myh = elf_link_hash_lookup
2092     (&(globals)->root, tmp_name, FALSE, FALSE, TRUE);
2093
2094   if (myh != NULL)
2095     {
2096       /* We've already seen this guy.  */
2097       free (tmp_name);
2098       return;
2099     }
2100
2101   /* The only trick here is using hash_table->arm_glue_size as the value.
2102      Even though the section isn't allocated yet, this is where we will be
2103      putting it.  */
2104   bh = NULL;
2105   val = globals->arm_glue_size + 1;
2106   _bfd_generic_link_add_one_symbol (link_info, globals->bfd_of_glue_owner,
2107                                     tmp_name, BSF_GLOBAL, s, val,
2108                                     NULL, TRUE, FALSE, &bh);
2109
2110   myh = (struct elf_link_hash_entry *) bh;
2111   myh->type = ELF_ST_INFO (STB_LOCAL, STT_FUNC);
2112   myh->forced_local = 1;
2113
2114   free (tmp_name);
2115
2116   if ((link_info->shared || globals->root.is_relocatable_executable))
2117     globals->arm_glue_size += ARM2THUMB_PIC_GLUE_SIZE;
2118   else
2119     globals->arm_glue_size += ARM2THUMB_STATIC_GLUE_SIZE;
2120
2121   return;
2122 }
2123
2124 static void
2125 record_thumb_to_arm_glue (struct bfd_link_info *link_info,
2126                           struct elf_link_hash_entry *h)
2127 {
2128   const char *name = h->root.root.string;
2129   asection *s;
2130   char *tmp_name;
2131   struct elf_link_hash_entry *myh;
2132   struct bfd_link_hash_entry *bh;
2133   struct elf32_arm_link_hash_table *hash_table;
2134   bfd_vma val;
2135
2136   hash_table = elf32_arm_hash_table (link_info);
2137
2138   BFD_ASSERT (hash_table != NULL);
2139   BFD_ASSERT (hash_table->bfd_of_glue_owner != NULL);
2140
2141   s = bfd_get_section_by_name
2142     (hash_table->bfd_of_glue_owner, THUMB2ARM_GLUE_SECTION_NAME);
2143
2144   BFD_ASSERT (s != NULL);
2145
2146   tmp_name = bfd_malloc ((bfd_size_type) strlen (name)
2147                          + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1);
2148
2149   BFD_ASSERT (tmp_name);
2150
2151   sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name);
2152
2153   myh = elf_link_hash_lookup
2154     (&(hash_table)->root, tmp_name, FALSE, FALSE, TRUE);
2155
2156   if (myh != NULL)
2157     {
2158       /* We've already seen this guy.  */
2159       free (tmp_name);
2160       return;
2161     }
2162
2163   bh = NULL;
2164   val = hash_table->thumb_glue_size + 1;
2165   _bfd_generic_link_add_one_symbol (link_info, hash_table->bfd_of_glue_owner,
2166                                     tmp_name, BSF_GLOBAL, s, val,
2167                                     NULL, TRUE, FALSE, &bh);
2168
2169   /* If we mark it 'Thumb', the disassembler will do a better job.  */
2170   myh = (struct elf_link_hash_entry *) bh;
2171   myh->type = ELF_ST_INFO (STB_LOCAL, STT_ARM_TFUNC);
2172   myh->forced_local = 1;
2173
2174   free (tmp_name);
2175
2176 #define CHANGE_TO_ARM "__%s_change_to_arm"
2177 #define BACK_FROM_ARM "__%s_back_from_arm"
2178
2179   /* Allocate another symbol to mark where we switch to Arm mode.  */
2180   tmp_name = bfd_malloc ((bfd_size_type) strlen (name)
2181                          + strlen (CHANGE_TO_ARM) + 1);
2182
2183   BFD_ASSERT (tmp_name);
2184
2185   sprintf (tmp_name, CHANGE_TO_ARM, name);
2186
2187   bh = NULL;
2188   val = hash_table->thumb_glue_size + 4,
2189   _bfd_generic_link_add_one_symbol (link_info, hash_table->bfd_of_glue_owner,
2190                                     tmp_name, BSF_LOCAL, s, val,
2191                                     NULL, TRUE, FALSE, &bh);
2192
2193   free (tmp_name);
2194
2195   hash_table->thumb_glue_size += THUMB2ARM_GLUE_SIZE;
2196
2197   return;
2198 }
2199
2200 /* Add the glue sections to ABFD.  This function is called from the
2201    linker scripts in ld/emultempl/{armelf}.em.  */
2202
2203 bfd_boolean
2204 bfd_elf32_arm_add_glue_sections_to_bfd (bfd *abfd,
2205                                         struct bfd_link_info *info)
2206 {
2207   flagword flags;
2208   asection *sec;
2209
2210   /* If we are only performing a partial
2211      link do not bother adding the glue.  */
2212   if (info->relocatable)
2213     return TRUE;
2214
2215   sec = bfd_get_section_by_name (abfd, ARM2THUMB_GLUE_SECTION_NAME);
2216
2217   if (sec == NULL)
2218     {
2219       /* Note: we do not include the flag SEC_LINKER_CREATED, as this
2220          will prevent elf_link_input_bfd() from processing the contents
2221          of this section.  */
2222       flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_CODE | SEC_READONLY;
2223
2224       sec = bfd_make_section_with_flags (abfd,
2225                                          ARM2THUMB_GLUE_SECTION_NAME,
2226                                          flags);
2227
2228       if (sec == NULL
2229           || !bfd_set_section_alignment (abfd, sec, 2))
2230         return FALSE;
2231
2232       /* Set the gc mark to prevent the section from being removed by garbage
2233          collection, despite the fact that no relocs refer to this section.  */
2234       sec->gc_mark = 1;
2235     }
2236
2237   sec = bfd_get_section_by_name (abfd, THUMB2ARM_GLUE_SECTION_NAME);
2238
2239   if (sec == NULL)
2240     {
2241       flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
2242         | SEC_CODE | SEC_READONLY;
2243
2244       sec = bfd_make_section_with_flags (abfd,
2245                                          THUMB2ARM_GLUE_SECTION_NAME,
2246                                          flags);
2247
2248       if (sec == NULL
2249           || !bfd_set_section_alignment (abfd, sec, 2))
2250         return FALSE;
2251
2252       sec->gc_mark = 1;
2253     }
2254
2255   return TRUE;
2256 }
2257
2258 /* Select a BFD to be used to hold the sections used by the glue code.
2259    This function is called from the linker scripts in ld/emultempl/
2260    {armelf/pe}.em  */
2261
2262 bfd_boolean
2263 bfd_elf32_arm_get_bfd_for_interworking (bfd *abfd, struct bfd_link_info *info)
2264 {
2265   struct elf32_arm_link_hash_table *globals;
2266
2267   /* If we are only performing a partial link
2268      do not bother getting a bfd to hold the glue.  */
2269   if (info->relocatable)
2270     return TRUE;
2271
2272   /* Make sure we don't attach the glue sections to a dynamic object.  */
2273   BFD_ASSERT (!(abfd->flags & DYNAMIC));
2274
2275   globals = elf32_arm_hash_table (info);
2276
2277   BFD_ASSERT (globals != NULL);
2278
2279   if (globals->bfd_of_glue_owner != NULL)
2280     return TRUE;
2281
2282   /* Save the bfd for later use.  */
2283   globals->bfd_of_glue_owner = abfd;
2284
2285   return TRUE;
2286 }
2287
2288 bfd_boolean
2289 bfd_elf32_arm_process_before_allocation (bfd *abfd,
2290                                          struct bfd_link_info *link_info,
2291                                          int byteswap_code)
2292 {
2293   Elf_Internal_Shdr *symtab_hdr;
2294   Elf_Internal_Rela *internal_relocs = NULL;
2295   Elf_Internal_Rela *irel, *irelend;
2296   bfd_byte *contents = NULL;
2297
2298   asection *sec;
2299   struct elf32_arm_link_hash_table *globals;
2300
2301   /* If we are only performing a partial link do not bother
2302      to construct any glue.  */
2303   if (link_info->relocatable)
2304     return TRUE;
2305
2306   /* Here we have a bfd that is to be included on the link.  We have a hook
2307      to do reloc rummaging, before section sizes are nailed down.  */
2308   globals = elf32_arm_hash_table (link_info);
2309
2310   BFD_ASSERT (globals != NULL);
2311   BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
2312
2313   if (byteswap_code && !bfd_big_endian (abfd))
2314     {
2315       _bfd_error_handler (_("%B: BE8 images only valid in big-endian mode."),
2316                           abfd);
2317       return FALSE;
2318     }
2319   globals->byteswap_code = byteswap_code;
2320
2321   /* Rummage around all the relocs and map the glue vectors.  */
2322   sec = abfd->sections;
2323
2324   if (sec == NULL)
2325     return TRUE;
2326
2327   for (; sec != NULL; sec = sec->next)
2328     {
2329       if (sec->reloc_count == 0)
2330         continue;
2331
2332       symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2333
2334       /* Load the relocs.  */
2335       internal_relocs
2336         = _bfd_elf_link_read_relocs (abfd, sec, (void *) NULL,
2337                                      (Elf_Internal_Rela *) NULL, FALSE);
2338
2339       if (internal_relocs == NULL)
2340         goto error_return;
2341
2342       irelend = internal_relocs + sec->reloc_count;
2343       for (irel = internal_relocs; irel < irelend; irel++)
2344         {
2345           long r_type;
2346           unsigned long r_index;
2347
2348           struct elf_link_hash_entry *h;
2349
2350           r_type = ELF32_R_TYPE (irel->r_info);
2351           r_index = ELF32_R_SYM (irel->r_info);
2352
2353           /* These are the only relocation types we care about.  */
2354           if (   r_type != R_ARM_PC24
2355               && r_type != R_ARM_PLT32
2356               && r_type != R_ARM_CALL
2357               && r_type != R_ARM_JUMP24
2358               && r_type != R_ARM_THM_CALL)
2359             continue;
2360
2361           /* Get the section contents if we haven't done so already.  */
2362           if (contents == NULL)
2363             {
2364               /* Get cached copy if it exists.  */
2365               if (elf_section_data (sec)->this_hdr.contents != NULL)
2366                 contents = elf_section_data (sec)->this_hdr.contents;
2367               else
2368                 {
2369                   /* Go get them off disk.  */
2370                   if (! bfd_malloc_and_get_section (abfd, sec, &contents))
2371                     goto error_return;
2372                 }
2373             }
2374
2375           /* If the relocation is not against a symbol it cannot concern us.  */
2376           h = NULL;
2377
2378           /* We don't care about local symbols.  */
2379           if (r_index < symtab_hdr->sh_info)
2380             continue;
2381
2382           /* This is an external symbol.  */
2383           r_index -= symtab_hdr->sh_info;
2384           h = (struct elf_link_hash_entry *)
2385             elf_sym_hashes (abfd)[r_index];
2386
2387           /* If the relocation is against a static symbol it must be within
2388              the current section and so cannot be a cross ARM/Thumb relocation.  */
2389           if (h == NULL)
2390             continue;
2391
2392           /* If the call will go through a PLT entry then we do not need
2393              glue.  */
2394           if (globals->splt != NULL && h->plt.offset != (bfd_vma) -1)
2395             continue;
2396
2397           switch (r_type)
2398             {
2399             case R_ARM_PC24:
2400             case R_ARM_PLT32:
2401             case R_ARM_CALL:
2402             case R_ARM_JUMP24:
2403               /* This one is a call from arm code.  We need to look up
2404                  the target of the call.  If it is a thumb target, we
2405                  insert glue.  */
2406               if (ELF_ST_TYPE(h->type) == STT_ARM_TFUNC)
2407                 record_arm_to_thumb_glue (link_info, h);
2408               break;
2409
2410             case R_ARM_THM_CALL:
2411               /* This one is a call from thumb code.  We look
2412                  up the target of the call.  If it is not a thumb
2413                  target, we insert glue.  */
2414               if (ELF_ST_TYPE (h->type) != STT_ARM_TFUNC)
2415                 record_thumb_to_arm_glue (link_info, h);
2416               break;
2417
2418             default:
2419               abort ();
2420             }
2421         }
2422
2423       if (contents != NULL
2424           && elf_section_data (sec)->this_hdr.contents != contents)
2425         free (contents);
2426       contents = NULL;
2427
2428       if (internal_relocs != NULL
2429           && elf_section_data (sec)->relocs != internal_relocs)
2430         free (internal_relocs);
2431       internal_relocs = NULL;
2432     }
2433
2434   return TRUE;
2435
2436 error_return:
2437   if (contents != NULL
2438       && elf_section_data (sec)->this_hdr.contents != contents)
2439     free (contents);
2440   if (internal_relocs != NULL
2441       && elf_section_data (sec)->relocs != internal_relocs)
2442     free (internal_relocs);
2443
2444   return FALSE;
2445 }
2446 #endif
2447
2448
2449 /* Set target relocation values needed during linking.  */
2450
2451 void
2452 bfd_elf32_arm_set_target_relocs (struct bfd_link_info *link_info,
2453                                  int target1_is_rel,
2454                                  char * target2_type,
2455                                  int fix_v4bx,
2456                                  int use_blx)
2457 {
2458   struct elf32_arm_link_hash_table *globals;
2459
2460   globals = elf32_arm_hash_table (link_info);
2461
2462   globals->target1_is_rel = target1_is_rel;
2463   if (strcmp (target2_type, "rel") == 0)
2464     globals->target2_reloc = R_ARM_REL32;
2465   else if (strcmp (target2_type, "abs") == 0)
2466     globals->target2_reloc = R_ARM_ABS32;
2467   else if (strcmp (target2_type, "got-rel") == 0)
2468     globals->target2_reloc = R_ARM_GOT_PREL;
2469   else
2470     {
2471       _bfd_error_handler (_("Invalid TARGET2 relocation type '%s'."),
2472                           target2_type);
2473     }
2474   globals->fix_v4bx = fix_v4bx;
2475   globals->use_blx |= use_blx;
2476 }
2477
2478 /* The thumb form of a long branch is a bit finicky, because the offset
2479    encoding is split over two fields, each in it's own instruction. They
2480    can occur in any order. So given a thumb form of long branch, and an
2481    offset, insert the offset into the thumb branch and return finished
2482    instruction.
2483
2484    It takes two thumb instructions to encode the target address. Each has
2485    11 bits to invest. The upper 11 bits are stored in one (identified by
2486    H-0.. see below), the lower 11 bits are stored in the other (identified
2487    by H-1).
2488
2489    Combine together and shifted left by 1 (it's a half word address) and
2490    there you have it.
2491
2492    Op: 1111 = F,
2493    H-0, upper address-0 = 000
2494    Op: 1111 = F,
2495    H-1, lower address-0 = 800
2496
2497    They can be ordered either way, but the arm tools I've seen always put
2498    the lower one first. It probably doesn't matter. krk@cygnus.com
2499
2500    XXX:  Actually the order does matter.  The second instruction (H-1)
2501    moves the computed address into the PC, so it must be the second one
2502    in the sequence.  The problem, however is that whilst little endian code
2503    stores the instructions in HI then LOW order, big endian code does the
2504    reverse.  nickc@cygnus.com.  */
2505
2506 #define LOW_HI_ORDER      0xF800F000
2507 #define HI_LOW_ORDER      0xF000F800
2508
2509 static insn32
2510 insert_thumb_branch (insn32 br_insn, int rel_off)
2511 {
2512   unsigned int low_bits;
2513   unsigned int high_bits;
2514
2515   BFD_ASSERT ((rel_off & 1) != 1);
2516
2517   rel_off >>= 1;                                /* Half word aligned address.  */
2518   low_bits = rel_off & 0x000007FF;              /* The bottom 11 bits.  */
2519   high_bits = (rel_off >> 11) & 0x000007FF;     /* The top 11 bits.  */
2520
2521   if ((br_insn & LOW_HI_ORDER) == LOW_HI_ORDER)
2522     br_insn = LOW_HI_ORDER | (low_bits << 16) | high_bits;
2523   else if ((br_insn & HI_LOW_ORDER) == HI_LOW_ORDER)
2524     br_insn = HI_LOW_ORDER | (high_bits << 16) | low_bits;
2525   else
2526     /* FIXME: abort is probably not the right call. krk@cygnus.com  */
2527     abort ();   /* Error - not a valid branch instruction form.  */
2528
2529   return br_insn;
2530 }
2531
2532 /* Thumb code calling an ARM function.  */
2533
2534 static int
2535 elf32_thumb_to_arm_stub (struct bfd_link_info * info,
2536                          const char *           name,
2537                          bfd *                  input_bfd,
2538                          bfd *                  output_bfd,
2539                          asection *             input_section,
2540                          bfd_byte *             hit_data,
2541                          asection *             sym_sec,
2542                          bfd_vma                offset,
2543                          bfd_signed_vma         addend,
2544                          bfd_vma                val)
2545 {
2546   asection * s = 0;
2547   bfd_vma my_offset;
2548   unsigned long int tmp;
2549   long int ret_offset;
2550   struct elf_link_hash_entry * myh;
2551   struct elf32_arm_link_hash_table * globals;
2552
2553   myh = find_thumb_glue (info, name, input_bfd);
2554   if (myh == NULL)
2555     return FALSE;
2556
2557   globals = elf32_arm_hash_table (info);
2558
2559   BFD_ASSERT (globals != NULL);
2560   BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
2561
2562   my_offset = myh->root.u.def.value;
2563
2564   s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
2565                                THUMB2ARM_GLUE_SECTION_NAME);
2566
2567   BFD_ASSERT (s != NULL);
2568   BFD_ASSERT (s->contents != NULL);
2569   BFD_ASSERT (s->output_section != NULL);
2570
2571   if ((my_offset & 0x01) == 0x01)
2572     {
2573       if (sym_sec != NULL
2574           && sym_sec->owner != NULL
2575           && !INTERWORK_FLAG (sym_sec->owner))
2576         {
2577           (*_bfd_error_handler)
2578             (_("%B(%s): warning: interworking not enabled.\n"
2579                "  first occurrence: %B: thumb call to arm"),
2580              sym_sec->owner, input_bfd, name);
2581
2582           return FALSE;
2583         }
2584
2585       --my_offset;
2586       myh->root.u.def.value = my_offset;
2587
2588       bfd_put_16 (output_bfd, (bfd_vma) t2a1_bx_pc_insn,
2589                   s->contents + my_offset);
2590
2591       bfd_put_16 (output_bfd, (bfd_vma) t2a2_noop_insn,
2592                   s->contents + my_offset + 2);
2593
2594       ret_offset =
2595         /* Address of destination of the stub.  */
2596         ((bfd_signed_vma) val)
2597         - ((bfd_signed_vma)
2598            /* Offset from the start of the current section
2599               to the start of the stubs.  */
2600            (s->output_offset
2601             /* Offset of the start of this stub from the start of the stubs.  */
2602             + my_offset
2603             /* Address of the start of the current section.  */
2604             + s->output_section->vma)
2605            /* The branch instruction is 4 bytes into the stub.  */
2606            + 4
2607            /* ARM branches work from the pc of the instruction + 8.  */
2608            + 8);
2609
2610       bfd_put_32 (output_bfd,
2611                   (bfd_vma) t2a3_b_insn | ((ret_offset >> 2) & 0x00FFFFFF),
2612                   s->contents + my_offset + 4);
2613     }
2614
2615   BFD_ASSERT (my_offset <= globals->thumb_glue_size);
2616
2617   /* Now go back and fix up the original BL insn to point to here.  */
2618   ret_offset =
2619     /* Address of where the stub is located.  */
2620     (s->output_section->vma + s->output_offset + my_offset)
2621      /* Address of where the BL is located.  */
2622     - (input_section->output_section->vma + input_section->output_offset
2623        + offset)
2624     /* Addend in the relocation.  */
2625     - addend
2626     /* Biassing for PC-relative addressing.  */
2627     - 8;
2628
2629   tmp = bfd_get_32 (input_bfd, hit_data
2630                     - input_section->vma);
2631
2632   bfd_put_32 (output_bfd,
2633               (bfd_vma) insert_thumb_branch (tmp, ret_offset),
2634               hit_data - input_section->vma);
2635
2636   return TRUE;
2637 }
2638
2639 /* Arm code calling a Thumb function.  */
2640
2641 static int
2642 elf32_arm_to_thumb_stub (struct bfd_link_info * info,
2643                          const char *           name,
2644                          bfd *                  input_bfd,
2645                          bfd *                  output_bfd,
2646                          asection *             input_section,
2647                          bfd_byte *             hit_data,
2648                          asection *             sym_sec,
2649                          bfd_vma                offset,
2650                          bfd_signed_vma         addend,
2651                          bfd_vma                val)
2652 {
2653   unsigned long int tmp;
2654   bfd_vma my_offset;
2655   asection * s;
2656   long int ret_offset;
2657   struct elf_link_hash_entry * myh;
2658   struct elf32_arm_link_hash_table * globals;
2659
2660   myh = find_arm_glue (info, name, input_bfd);
2661   if (myh == NULL)
2662     return FALSE;
2663
2664   globals = elf32_arm_hash_table (info);
2665
2666   BFD_ASSERT (globals != NULL);
2667   BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
2668
2669   my_offset = myh->root.u.def.value;
2670   s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
2671                                ARM2THUMB_GLUE_SECTION_NAME);
2672   BFD_ASSERT (s != NULL);
2673   BFD_ASSERT (s->contents != NULL);
2674   BFD_ASSERT (s->output_section != NULL);
2675
2676   if ((my_offset & 0x01) == 0x01)
2677     {
2678       if (sym_sec != NULL
2679           && sym_sec->owner != NULL
2680           && !INTERWORK_FLAG (sym_sec->owner))
2681         {
2682           (*_bfd_error_handler)
2683             (_("%B(%s): warning: interworking not enabled.\n"
2684                "  first occurrence: %B: arm call to thumb"),
2685              sym_sec->owner, input_bfd, name);
2686         }
2687
2688       --my_offset;
2689       myh->root.u.def.value = my_offset;
2690
2691       if ((info->shared || globals->root.is_relocatable_executable))
2692         {
2693           /* For relocatable objects we can't use absolute addresses,
2694              so construct the address from a relative offset.  */
2695           /* TODO: If the offset is small it's probably worth
2696              constructing the address with adds.  */
2697           bfd_put_32 (output_bfd, (bfd_vma) a2t1p_ldr_insn,
2698                       s->contents + my_offset);
2699           bfd_put_32 (output_bfd, (bfd_vma) a2t2p_add_pc_insn,
2700                       s->contents + my_offset + 4);
2701           bfd_put_32 (output_bfd, (bfd_vma) a2t3p_bx_r12_insn,
2702                       s->contents + my_offset + 8);
2703           /* Adjust the offset by 4 for the position of the add,
2704              and 8 for the pipeline offset.  */
2705           ret_offset = (val - (s->output_offset
2706                                + s->output_section->vma
2707                                + my_offset + 12))
2708                        | 1;
2709           bfd_put_32 (output_bfd, ret_offset,
2710                       s->contents + my_offset + 12);
2711         }
2712       else
2713         {
2714           bfd_put_32 (output_bfd, (bfd_vma) a2t1_ldr_insn,
2715                       s->contents + my_offset);
2716
2717           bfd_put_32 (output_bfd, (bfd_vma) a2t2_bx_r12_insn,
2718                       s->contents + my_offset + 4);
2719
2720           /* It's a thumb address.  Add the low order bit.  */
2721           bfd_put_32 (output_bfd, val | a2t3_func_addr_insn,
2722                       s->contents + my_offset + 8);
2723         }
2724     }
2725
2726   BFD_ASSERT (my_offset <= globals->arm_glue_size);
2727
2728   tmp = bfd_get_32 (input_bfd, hit_data);
2729   tmp = tmp & 0xFF000000;
2730
2731   /* Somehow these are both 4 too far, so subtract 8.  */
2732   ret_offset = (s->output_offset
2733                 + my_offset
2734                 + s->output_section->vma
2735                 - (input_section->output_offset
2736                    + input_section->output_section->vma
2737                    + offset + addend)
2738                 - 8);
2739
2740   tmp = tmp | ((ret_offset >> 2) & 0x00FFFFFF);
2741
2742   bfd_put_32 (output_bfd, (bfd_vma) tmp, hit_data - input_section->vma);
2743
2744   return TRUE;
2745 }
2746
2747 /* Some relocations map to different relocations depending on the
2748    target.  Return the real relocation.  */
2749 static int
2750 arm_real_reloc_type (struct elf32_arm_link_hash_table * globals,
2751                      int r_type)
2752 {
2753   switch (r_type)
2754     {
2755     case R_ARM_TARGET1:
2756       if (globals->target1_is_rel)
2757         return R_ARM_REL32;
2758       else
2759         return R_ARM_ABS32;
2760
2761     case R_ARM_TARGET2:
2762       return globals->target2_reloc;
2763
2764     default:
2765       return r_type;
2766     }
2767 }
2768
2769 /* Return the base VMA address which should be subtracted from real addresses
2770    when resolving @dtpoff relocation.
2771    This is PT_TLS segment p_vaddr.  */
2772
2773 static bfd_vma
2774 dtpoff_base (struct bfd_link_info *info)
2775 {
2776   /* If tls_sec is NULL, we should have signalled an error already.  */
2777   if (elf_hash_table (info)->tls_sec == NULL)
2778     return 0;
2779   return elf_hash_table (info)->tls_sec->vma;
2780 }
2781
2782 /* Return the relocation value for @tpoff relocation
2783    if STT_TLS virtual address is ADDRESS.  */
2784
2785 static bfd_vma
2786 tpoff (struct bfd_link_info *info, bfd_vma address)
2787 {
2788   struct elf_link_hash_table *htab = elf_hash_table (info);
2789   bfd_vma base;
2790
2791   /* If tls_sec is NULL, we should have signalled an error already.  */
2792   if (htab->tls_sec == NULL)
2793     return 0;
2794   base = align_power ((bfd_vma) TCB_SIZE, htab->tls_sec->alignment_power);
2795   return address - htab->tls_sec->vma + base;
2796 }
2797
2798 /* Perform a relocation as part of a final link.  */
2799
2800 static bfd_reloc_status_type
2801 elf32_arm_final_link_relocate (reloc_howto_type *           howto,
2802                                bfd *                        input_bfd,
2803                                bfd *                        output_bfd,
2804                                asection *                   input_section,
2805                                bfd_byte *                   contents,
2806                                Elf_Internal_Rela *          rel,
2807                                bfd_vma                      value,
2808                                struct bfd_link_info *       info,
2809                                asection *                   sym_sec,
2810                                const char *                 sym_name,
2811                                int                          sym_flags,
2812                                struct elf_link_hash_entry * h,
2813                                bfd_boolean *                unresolved_reloc_p)
2814 {
2815   unsigned long                 r_type = howto->type;
2816   unsigned long                 r_symndx;
2817   bfd_byte *                    hit_data = contents + rel->r_offset;
2818   bfd *                         dynobj = NULL;
2819   Elf_Internal_Shdr *           symtab_hdr;
2820   struct elf_link_hash_entry ** sym_hashes;
2821   bfd_vma *                     local_got_offsets;
2822   asection *                    sgot = NULL;
2823   asection *                    splt = NULL;
2824   asection *                    sreloc = NULL;
2825   bfd_vma                       addend;
2826   bfd_signed_vma                signed_addend;
2827   struct elf32_arm_link_hash_table * globals;
2828
2829   globals = elf32_arm_hash_table (info);
2830
2831   /* Some relocation type map to different relocations depending on the
2832      target.  We pick the right one here.  */
2833   r_type = arm_real_reloc_type (globals, r_type);
2834   if (r_type != howto->type)
2835     howto = elf32_arm_howto_from_type (r_type);
2836
2837   /* If the start address has been set, then set the EF_ARM_HASENTRY
2838      flag.  Setting this more than once is redundant, but the cost is
2839      not too high, and it keeps the code simple.
2840
2841      The test is done  here, rather than somewhere else, because the
2842      start address is only set just before the final link commences.
2843
2844      Note - if the user deliberately sets a start address of 0, the
2845      flag will not be set.  */
2846   if (bfd_get_start_address (output_bfd) != 0)
2847     elf_elfheader (output_bfd)->e_flags |= EF_ARM_HASENTRY;
2848
2849   dynobj = elf_hash_table (info)->dynobj;
2850   if (dynobj)
2851     {
2852       sgot = bfd_get_section_by_name (dynobj, ".got");
2853       splt = bfd_get_section_by_name (dynobj, ".plt");
2854     }
2855   symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
2856   sym_hashes = elf_sym_hashes (input_bfd);
2857   local_got_offsets = elf_local_got_offsets (input_bfd);
2858   r_symndx = ELF32_R_SYM (rel->r_info);
2859
2860   if (globals->use_rel)
2861     {
2862       addend = bfd_get_32 (input_bfd, hit_data) & howto->src_mask;
2863
2864       if (addend & ((howto->src_mask + 1) >> 1))
2865         {
2866           signed_addend = -1;
2867           signed_addend &= ~ howto->src_mask;
2868           signed_addend |= addend;
2869         }
2870       else
2871         signed_addend = addend;
2872     }
2873   else
2874     addend = signed_addend = rel->r_addend;
2875
2876   switch (r_type)
2877     {
2878     case R_ARM_NONE:
2879       /* We don't need to find a value for this symbol.  It's just a
2880          marker.  */
2881       *unresolved_reloc_p = FALSE;
2882       return bfd_reloc_ok;
2883
2884     case R_ARM_PC24:
2885     case R_ARM_ABS32:
2886     case R_ARM_REL32:
2887     case R_ARM_CALL:
2888     case R_ARM_JUMP24:
2889     case R_ARM_XPC25:
2890     case R_ARM_PREL31:
2891     case R_ARM_PLT32:
2892       /* r_symndx will be zero only for relocs against symbols
2893          from removed linkonce sections, or sections discarded by
2894          a linker script.  */
2895       if (r_symndx == 0)
2896         return bfd_reloc_ok;
2897
2898       /* Handle relocations which should use the PLT entry.  ABS32/REL32
2899          will use the symbol's value, which may point to a PLT entry, but we
2900          don't need to handle that here.  If we created a PLT entry, all
2901          branches in this object should go to it.  */
2902       if ((r_type != R_ARM_ABS32 && r_type != R_ARM_REL32)
2903           && h != NULL
2904           && splt != NULL
2905           && h->plt.offset != (bfd_vma) -1)
2906         {
2907           /* If we've created a .plt section, and assigned a PLT entry to
2908              this function, it should not be known to bind locally.  If
2909              it were, we would have cleared the PLT entry.  */
2910           BFD_ASSERT (!SYMBOL_CALLS_LOCAL (info, h));
2911
2912           value = (splt->output_section->vma
2913                    + splt->output_offset
2914                    + h->plt.offset);
2915           *unresolved_reloc_p = FALSE;
2916           return _bfd_final_link_relocate (howto, input_bfd, input_section,
2917                                            contents, rel->r_offset, value,
2918                                            (bfd_vma) 0);
2919         }
2920
2921       /* When generating a shared object or relocatable executable, these
2922          relocations are copied into the output file to be resolved at
2923          run time.  */
2924       if ((info->shared || globals->root.is_relocatable_executable)
2925           && (input_section->flags & SEC_ALLOC)
2926           && (r_type != R_ARM_REL32
2927               || !SYMBOL_CALLS_LOCAL (info, h))
2928           && (h == NULL
2929               || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2930               || h->root.type != bfd_link_hash_undefweak)
2931           && r_type != R_ARM_PC24
2932           && r_type != R_ARM_CALL
2933           && r_type != R_ARM_JUMP24
2934           && r_type != R_ARM_PREL31
2935           && r_type != R_ARM_PLT32)
2936         {
2937           Elf_Internal_Rela outrel;
2938           bfd_byte *loc;
2939           bfd_boolean skip, relocate;
2940
2941           *unresolved_reloc_p = FALSE;
2942
2943           if (sreloc == NULL)
2944             {
2945               const char * name;
2946
2947               name = (bfd_elf_string_from_elf_section
2948                       (input_bfd,
2949                        elf_elfheader (input_bfd)->e_shstrndx,
2950                        elf_section_data (input_section)->rel_hdr.sh_name));
2951               if (name == NULL)
2952                 return bfd_reloc_notsupported;
2953
2954               BFD_ASSERT (strncmp (name, ".rel", 4) == 0
2955                           && strcmp (bfd_get_section_name (input_bfd,
2956                                                            input_section),
2957                                      name + 4) == 0);
2958
2959               sreloc = bfd_get_section_by_name (dynobj, name);
2960               BFD_ASSERT (sreloc != NULL);
2961             }
2962
2963           skip = FALSE;
2964           relocate = FALSE;
2965
2966           outrel.r_offset =
2967             _bfd_elf_section_offset (output_bfd, info, input_section,
2968                                      rel->r_offset);
2969           if (outrel.r_offset == (bfd_vma) -1)
2970             skip = TRUE;
2971           else if (outrel.r_offset == (bfd_vma) -2)
2972             skip = TRUE, relocate = TRUE;
2973           outrel.r_offset += (input_section->output_section->vma
2974                               + input_section->output_offset);
2975
2976           if (skip)
2977             memset (&outrel, 0, sizeof outrel);
2978           else if (h != NULL
2979                    && h->dynindx != -1
2980                    && (!info->shared
2981                        || !info->symbolic
2982                        || !h->def_regular))
2983             outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2984           else
2985             {
2986               int symbol;
2987
2988               /* This symbol is local, or marked to become local.  */
2989               relocate = TRUE;
2990               if (sym_flags == STT_ARM_TFUNC)
2991                 value |= 1;
2992               if (globals->symbian_p)
2993                 {
2994                   /* On Symbian OS, the data segment and text segement
2995                      can be relocated independently.  Therefore, we
2996                      must indicate the segment to which this
2997                      relocation is relative.  The BPABI allows us to
2998                      use any symbol in the right segment; we just use
2999                      the section symbol as it is convenient.  (We
3000                      cannot use the symbol given by "h" directly as it
3001                      will not appear in the dynamic symbol table.)  */
3002                   if (sym_sec)
3003                     symbol = elf_section_data (sym_sec->output_section)->dynindx;
3004                   else
3005                     symbol = elf_section_data (input_section->output_section)->dynindx;
3006                   BFD_ASSERT (symbol != 0);
3007                 }
3008               else
3009                 /* On SVR4-ish systems, the dynamic loader cannot
3010                    relocate the text and data segments independently,
3011                    so the symbol does not matter.  */
3012                 symbol = 0;
3013               outrel.r_info = ELF32_R_INFO (symbol, R_ARM_RELATIVE);
3014             }
3015
3016           loc = sreloc->contents;
3017           loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
3018           bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3019
3020           /* If this reloc is against an external symbol, we do not want to
3021              fiddle with the addend.  Otherwise, we need to include the symbol
3022              value so that it becomes an addend for the dynamic reloc.  */
3023           if (! relocate)
3024             return bfd_reloc_ok;
3025
3026           return _bfd_final_link_relocate (howto, input_bfd, input_section,
3027                                            contents, rel->r_offset, value,
3028                                            (bfd_vma) 0);
3029         }
3030       else switch (r_type)
3031         {
3032         case R_ARM_XPC25:         /* Arm BLX instruction.  */
3033         case R_ARM_CALL:
3034         case R_ARM_JUMP24:
3035         case R_ARM_PC24:          /* Arm B/BL instruction */
3036         case R_ARM_PLT32:
3037           if (r_type == R_ARM_XPC25)
3038             {
3039               /* Check for Arm calling Arm function.  */
3040               /* FIXME: Should we translate the instruction into a BL
3041                  instruction instead ?  */
3042               if (sym_flags != STT_ARM_TFUNC)
3043                 (*_bfd_error_handler)
3044                   (_("\%B: Warning: Arm BLX instruction targets Arm function '%s'."),
3045                    input_bfd,
3046                    h ? h->root.root.string : "(local)");
3047             }
3048           else
3049             {
3050               /* Check for Arm calling Thumb function.  */
3051               if (sym_flags == STT_ARM_TFUNC)
3052                 {
3053                   elf32_arm_to_thumb_stub (info, sym_name, input_bfd,
3054                                            output_bfd, input_section,
3055                                            hit_data, sym_sec, rel->r_offset,
3056                                            signed_addend, value);
3057                   return bfd_reloc_ok;
3058                 }
3059             }
3060
3061           /* The ARM ELF ABI says that this reloc is computed as: S - P + A
3062              where:
3063               S is the address of the symbol in the relocation.
3064               P is address of the instruction being relocated.
3065               A is the addend (extracted from the instruction) in bytes.
3066
3067              S is held in 'value'.
3068              P is the base address of the section containing the
3069                instruction plus the offset of the reloc into that
3070                section, ie:
3071                  (input_section->output_section->vma +
3072                   input_section->output_offset +
3073                   rel->r_offset).
3074              A is the addend, converted into bytes, ie:
3075                  (signed_addend * 4)
3076
3077              Note: None of these operations have knowledge of the pipeline
3078              size of the processor, thus it is up to the assembler to
3079              encode this information into the addend.  */
3080           value -= (input_section->output_section->vma
3081                     + input_section->output_offset);
3082           value -= rel->r_offset;
3083           if (globals->use_rel)
3084             value += (signed_addend << howto->size);
3085           else
3086             /* RELA addends do not have to be adjusted by howto->size.  */
3087             value += signed_addend;
3088
3089           signed_addend = value;
3090           signed_addend >>= howto->rightshift;
3091
3092           /* It is not an error for an undefined weak reference to be
3093              out of range.  Any program that branches to such a symbol
3094              is going to crash anyway, so there is no point worrying
3095              about getting the destination exactly right.  */
3096           if (! h || h->root.type != bfd_link_hash_undefweak)
3097             {
3098               /* Perform a signed range check.  */
3099               if (   signed_addend >   ((bfd_signed_vma)  (howto->dst_mask >> 1))
3100                   || signed_addend < - ((bfd_signed_vma) ((howto->dst_mask + 1) >> 1)))
3101                 return bfd_reloc_overflow;
3102             }
3103
3104           /* If necessary set the H bit in the BLX instruction.  */
3105           if (r_type == R_ARM_XPC25 && ((value & 2) == 2))
3106             value = (signed_addend & howto->dst_mask)
3107               | (bfd_get_32 (input_bfd, hit_data) & (~ howto->dst_mask))
3108               | (1 << 24);
3109           else
3110             value = (signed_addend & howto->dst_mask)
3111               | (bfd_get_32 (input_bfd, hit_data) & (~ howto->dst_mask));
3112           break;
3113
3114         case R_ARM_ABS32:
3115           value += addend;
3116           if (sym_flags == STT_ARM_TFUNC)
3117             value |= 1;
3118           break;
3119
3120         case R_ARM_REL32:
3121           value -= (input_section->output_section->vma
3122                     + input_section->output_offset + rel->r_offset);
3123           value += addend;
3124           break;
3125
3126         case R_ARM_PREL31:
3127           value -= (input_section->output_section->vma
3128                     + input_section->output_offset + rel->r_offset);
3129           value += signed_addend;
3130           if (! h || h->root.type != bfd_link_hash_undefweak)
3131             {
3132               /* Check for overflow */
3133               if ((value ^ (value >> 1)) & (1 << 30))
3134                 return bfd_reloc_overflow;
3135             }
3136           value &= 0x7fffffff;
3137           value |= (bfd_get_32 (input_bfd, hit_data) & 0x80000000);
3138           if (sym_flags == STT_ARM_TFUNC)
3139             value |= 1;
3140           break;
3141         }
3142
3143       bfd_put_32 (input_bfd, value, hit_data);
3144       return bfd_reloc_ok;
3145
3146     case R_ARM_ABS8:
3147       value += addend;
3148       if ((long) value > 0x7f || (long) value < -0x80)
3149         return bfd_reloc_overflow;
3150
3151       bfd_put_8 (input_bfd, value, hit_data);
3152       return bfd_reloc_ok;
3153
3154     case R_ARM_ABS16:
3155       value += addend;
3156
3157       if ((long) value > 0x7fff || (long) value < -0x8000)
3158         return bfd_reloc_overflow;
3159
3160       bfd_put_16 (input_bfd, value, hit_data);
3161       return bfd_reloc_ok;
3162
3163     case R_ARM_ABS12:
3164       /* Support ldr and str instruction for the arm */
3165       /* Also thumb b (unconditional branch).  ??? Really?  */
3166       value += addend;
3167
3168       if ((long) value > 0x7ff || (long) value < -0x800)
3169         return bfd_reloc_overflow;
3170
3171       value |= (bfd_get_32 (input_bfd, hit_data) & 0xfffff000);
3172       bfd_put_32 (input_bfd, value, hit_data);
3173       return bfd_reloc_ok;
3174
3175     case R_ARM_THM_ABS5:
3176       /* Support ldr and str instructions for the thumb.  */
3177       if (globals->use_rel)
3178         {
3179           /* Need to refetch addend.  */
3180           addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
3181           /* ??? Need to determine shift amount from operand size.  */
3182           addend >>= howto->rightshift;
3183         }
3184       value += addend;
3185
3186       /* ??? Isn't value unsigned?  */
3187       if ((long) value > 0x1f || (long) value < -0x10)
3188         return bfd_reloc_overflow;
3189
3190       /* ??? Value needs to be properly shifted into place first.  */
3191       value |= bfd_get_16 (input_bfd, hit_data) & 0xf83f;
3192       bfd_put_16 (input_bfd, value, hit_data);
3193       return bfd_reloc_ok;
3194
3195     case R_ARM_THM_XPC22:
3196     case R_ARM_THM_CALL:
3197       /* Thumb BL (branch long instruction).  */
3198       {
3199         bfd_vma relocation;
3200         bfd_boolean overflow = FALSE;
3201         bfd_vma upper_insn = bfd_get_16 (input_bfd, hit_data);
3202         bfd_vma lower_insn = bfd_get_16 (input_bfd, hit_data + 2);
3203         bfd_signed_vma reloc_signed_max = ((1 << (howto->bitsize - 1)) - 1) >> howto->rightshift;
3204         bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
3205         bfd_vma check;
3206         bfd_signed_vma signed_check;
3207         bfd_boolean thumb_plt_call = FALSE;
3208
3209         /* Need to refetch the addend and squish the two 11 bit pieces
3210            together.  */
3211         if (globals->use_rel)
3212           {
3213             bfd_vma upper = upper_insn & 0x7ff;
3214             bfd_vma lower = lower_insn & 0x7ff;
3215             upper = (upper ^ 0x400) - 0x400; /* Sign extend.  */
3216             addend = (upper << 12) | (lower << 1);
3217             signed_addend = addend;
3218           }
3219
3220         if (r_type == R_ARM_THM_XPC22)
3221           {
3222             /* Check for Thumb to Thumb call.  */
3223             /* FIXME: Should we translate the instruction into a BL
3224                instruction instead ?  */
3225             if (sym_flags == STT_ARM_TFUNC)
3226               (*_bfd_error_handler)
3227                 (_("%B: Warning: Thumb BLX instruction targets thumb function '%s'."),
3228                  input_bfd,
3229                  h ? h->root.root.string : "(local)");
3230           }
3231         else
3232           {
3233             /* If it is not a call to Thumb, assume call to Arm.
3234                If it is a call relative to a section name, then it is not a
3235                function call at all, but rather a long jump.  Calls through
3236                the PLT do not require stubs.  */
3237             if (sym_flags != STT_ARM_TFUNC && sym_flags != STT_SECTION
3238                 && (h == NULL || splt == NULL
3239                     || h->plt.offset == (bfd_vma) -1))
3240               {
3241                 if (elf32_thumb_to_arm_stub
3242                     (info, sym_name, input_bfd, output_bfd, input_section,
3243                      hit_data, sym_sec, rel->r_offset, signed_addend, value))
3244                   return bfd_reloc_ok;
3245                 else
3246                   return bfd_reloc_dangerous;
3247               }
3248           }
3249
3250         /* Handle calls via the PLT.  */
3251         if (h != NULL && splt != NULL && h->plt.offset != (bfd_vma) -1)
3252           {
3253             value = (splt->output_section->vma
3254                      + splt->output_offset
3255                      + h->plt.offset);
3256             if (globals->use_blx)
3257               {
3258                 /* If the Thumb BLX instruction is available, convert the
3259                    BL to a BLX instruction to call the ARM-mode PLT entry.  */
3260                 if ((lower_insn & (0x3 << 11)) == 0x3 << 11)
3261                   {
3262                     lower_insn = (lower_insn & ~(0x3 << 11)) | 0x1 << 11;
3263                     thumb_plt_call = TRUE;
3264                   }
3265               }
3266             else
3267               /* Target the Thumb stub before the ARM PLT entry.  */
3268               value -= PLT_THUMB_STUB_SIZE;
3269             *unresolved_reloc_p = FALSE;
3270           }
3271
3272         relocation = value + signed_addend;
3273
3274         relocation -= (input_section->output_section->vma
3275                        + input_section->output_offset
3276                        + rel->r_offset);
3277
3278         check = relocation >> howto->rightshift;
3279
3280         /* If this is a signed value, the rightshift just dropped
3281            leading 1 bits (assuming twos complement).  */
3282         if ((bfd_signed_vma) relocation >= 0)
3283           signed_check = check;
3284         else
3285           signed_check = check | ~((bfd_vma) -1 >> howto->rightshift);
3286
3287         /* Assumes two's complement.  */
3288         if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
3289           overflow = TRUE;
3290
3291         if ((r_type == R_ARM_THM_XPC22
3292              && ((lower_insn & 0x1800) == 0x0800))
3293             || thumb_plt_call)
3294           /* For a BLX instruction, make sure that the relocation is rounded up
3295              to a word boundary.  This follows the semantics of the instruction
3296              which specifies that bit 1 of the target address will come from bit
3297              1 of the base address.  */
3298           relocation = (relocation + 2) & ~ 3;
3299
3300         /* Put RELOCATION back into the insn.  */
3301         upper_insn = (upper_insn & ~(bfd_vma) 0x7ff) | ((relocation >> 12) & 0x7ff);
3302         lower_insn = (lower_insn & ~(bfd_vma) 0x7ff) | ((relocation >> 1) & 0x7ff);
3303
3304         /* Put the relocated value back in the object file:  */
3305         bfd_put_16 (input_bfd, upper_insn, hit_data);
3306         bfd_put_16 (input_bfd, lower_insn, hit_data + 2);
3307
3308         return (overflow ? bfd_reloc_overflow : bfd_reloc_ok);
3309       }
3310       break;
3311
3312     case R_ARM_THM_JUMP24:
3313       /* Thumb32 unconditional branch instruction.  */
3314       {
3315         bfd_vma relocation;
3316         bfd_boolean overflow = FALSE;
3317         bfd_vma upper_insn = bfd_get_16 (input_bfd, hit_data);
3318         bfd_vma lower_insn = bfd_get_16 (input_bfd, hit_data + 2);
3319         bfd_signed_vma reloc_signed_max = ((1 << (howto->bitsize - 1)) - 1) >> howto->rightshift;
3320         bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
3321         bfd_vma check;
3322         bfd_signed_vma signed_check;
3323
3324         /* Need to refetch the addend, reconstruct the top three bits, and glue the
3325            two pieces together.  */
3326         if (globals->use_rel)
3327           {
3328             bfd_vma S  = (upper_insn & 0x0400) >> 10;
3329             bfd_vma hi = (upper_insn & 0x03ff);
3330             bfd_vma I1 = (lower_insn & 0x2000) >> 13;
3331             bfd_vma I2 = (lower_insn & 0x0800) >> 11;
3332             bfd_vma lo = (lower_insn & 0x07ff);
3333
3334             I1 = !(I1 ^ S);
3335             I2 = !(I2 ^ S);
3336             S  = !S;
3337
3338             signed_addend = (S << 24) | (I1 << 23) | (I2 << 22) | (hi << 12) | (lo << 1);
3339             signed_addend -= (1 << 24); /* Sign extend.  */
3340           }
3341
3342         /* ??? Should handle interworking?  GCC might someday try to
3343            use this for tail calls.  */
3344
3345         relocation = value + signed_addend;
3346         relocation -= (input_section->output_section->vma
3347                        + input_section->output_offset
3348                        + rel->r_offset);
3349
3350         check = relocation >> howto->rightshift;
3351
3352         /* If this is a signed value, the rightshift just dropped
3353            leading 1 bits (assuming twos complement).  */
3354         if ((bfd_signed_vma) relocation >= 0)
3355           signed_check = check;
3356         else
3357           signed_check = check | ~((bfd_vma) -1 >> howto->rightshift);
3358
3359         /* Assumes two's complement.  */
3360         if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
3361           overflow = TRUE;
3362
3363         /* Put RELOCATION back into the insn.  */
3364         {
3365           bfd_vma S  = (relocation & 0x01000000) >> 24;
3366           bfd_vma I1 = (relocation & 0x00800000) >> 23;
3367           bfd_vma I2 = (relocation & 0x00400000) >> 22;
3368           bfd_vma hi = (relocation & 0x003ff000) >> 12;
3369           bfd_vma lo = (relocation & 0x00000ffe) >>  1;
3370
3371           I1 = !(I1 ^ S);
3372           I2 = !(I2 ^ S);
3373
3374           upper_insn = (upper_insn & (bfd_vma) 0xf800) | (S << 10) | hi;
3375           lower_insn = (lower_insn & (bfd_vma) 0xd000) | (I1 << 13) | (I2 << 11) | lo;
3376         }
3377
3378         /* Put the relocated value back in the object file:  */
3379         bfd_put_16 (input_bfd, upper_insn, hit_data);
3380         bfd_put_16 (input_bfd, lower_insn, hit_data + 2);
3381
3382         return (overflow ? bfd_reloc_overflow : bfd_reloc_ok);
3383       }
3384
3385     case R_ARM_THM_JUMP19:
3386       /* Thumb32 conditional branch instruction.  */
3387       {
3388         bfd_vma relocation;
3389         bfd_boolean overflow = FALSE;
3390         bfd_vma upper_insn = bfd_get_16 (input_bfd, hit_data);
3391         bfd_vma lower_insn = bfd_get_16 (input_bfd, hit_data + 2);
3392         bfd_signed_vma reloc_signed_max = ((1 << (howto->bitsize - 1)) - 1) >> howto->rightshift;
3393         bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
3394         bfd_vma check;
3395         bfd_signed_vma signed_check;
3396
3397         /* Need to refetch the addend, reconstruct the top three bits,
3398            and squish the two 11 bit pieces together.  */
3399         if (globals->use_rel)
3400           {
3401             bfd_vma S     = (upper_insn & 0x0400) >> 10;
3402             bfd_vma upper = (upper_insn & 0x001f);
3403             bfd_vma J1    = (lower_insn & 0x2000) >> 13;
3404             bfd_vma J2    = (lower_insn & 0x0800) >> 11;
3405             bfd_vma lower = (lower_insn & 0x07ff);
3406
3407             upper |= J2 << 6;
3408             upper |= J1 << 7;
3409             upper |= ~S << 8;
3410             upper -= 0x0100; /* Sign extend.  */
3411
3412             addend = (upper << 12) | (lower << 1);
3413             signed_addend = addend;
3414           }
3415
3416         /* ??? Should handle interworking?  GCC might someday try to
3417            use this for tail calls.  */
3418
3419         relocation = value + signed_addend;
3420         relocation -= (input_section->output_section->vma
3421                        + input_section->output_offset
3422                        + rel->r_offset);
3423
3424         check = relocation >> howto->rightshift;
3425
3426         /* If this is a signed value, the rightshift just dropped
3427            leading 1 bits (assuming twos complement).  */
3428         if ((bfd_signed_vma) relocation >= 0)
3429           signed_check = check;
3430         else
3431           signed_check = check | ~((bfd_vma) -1 >> howto->rightshift);
3432
3433         /* Assumes two's complement.  */
3434         if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
3435           overflow = TRUE;
3436
3437         /* Put RELOCATION back into the insn.  */
3438         {
3439           bfd_vma S  = (relocation & 0x00100000) >> 20;
3440           bfd_vma J2 = (relocation & 0x00080000) >> 19;
3441           bfd_vma J1 = (relocation & 0x00040000) >> 18;
3442           bfd_vma hi = (relocation & 0x0003f000) >> 12;
3443           bfd_vma lo = (relocation & 0x00000ffe) >>  1;
3444
3445           upper_insn = (upper_insn & 0xfb30) | (S << 10) | hi;
3446           lower_insn = (lower_insn & 0xd000) | (J1 << 13) | (J2 << 11) | lo;
3447         }
3448
3449         /* Put the relocated value back in the object file:  */
3450         bfd_put_16 (input_bfd, upper_insn, hit_data);
3451         bfd_put_16 (input_bfd, lower_insn, hit_data + 2);
3452
3453         return (overflow ? bfd_reloc_overflow : bfd_reloc_ok);
3454       }
3455
3456     case R_ARM_THM_JUMP11:
3457     case R_ARM_THM_JUMP8:
3458     case R_ARM_THM_JUMP6:
3459       /* Thumb B (branch) instruction).  */
3460       {
3461         bfd_signed_vma relocation;
3462         bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
3463         bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
3464         bfd_signed_vma signed_check;
3465
3466         /* CZB cannot jump backward.  */
3467         if (r_type == R_ARM_THM_JUMP6)
3468           reloc_signed_min = 0;
3469
3470         if (globals->use_rel)
3471           {
3472             /* Need to refetch addend.  */
3473             addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
3474             if (addend & ((howto->src_mask + 1) >> 1))
3475               {
3476                 signed_addend = -1;
3477                 signed_addend &= ~ howto->src_mask;
3478                 signed_addend |= addend;
3479               }
3480             else
3481               signed_addend = addend;
3482             /* The value in the insn has been right shifted.  We need to
3483                undo this, so that we can perform the address calculation
3484                in terms of bytes.  */
3485             signed_addend <<= howto->rightshift;
3486           }
3487         relocation = value + signed_addend;
3488
3489         relocation -= (input_section->output_section->vma
3490                        + input_section->output_offset
3491                        + rel->r_offset);
3492
3493         relocation >>= howto->rightshift;
3494         signed_check = relocation;
3495
3496         if (r_type == R_ARM_THM_JUMP6)
3497           relocation = ((relocation & 0x0020) << 4) | ((relocation & 0x001f) << 3);
3498         else
3499           relocation &= howto->dst_mask;
3500         relocation |= (bfd_get_16 (input_bfd, hit_data) & (~ howto->dst_mask));
3501
3502         bfd_put_16 (input_bfd, relocation, hit_data);
3503
3504         /* Assumes two's complement.  */
3505         if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
3506           return bfd_reloc_overflow;
3507
3508         return bfd_reloc_ok;
3509       }
3510
3511     case R_ARM_ALU_PCREL7_0:
3512     case R_ARM_ALU_PCREL15_8:
3513     case R_ARM_ALU_PCREL23_15:
3514       {
3515         bfd_vma insn;
3516         bfd_vma relocation;
3517
3518         insn = bfd_get_32 (input_bfd, hit_data);
3519         if (globals->use_rel)
3520           {
3521             /* Extract the addend.  */
3522             addend = (insn & 0xff) << ((insn & 0xf00) >> 7);
3523             signed_addend = addend;
3524           }
3525         relocation = value + signed_addend;
3526
3527         relocation -= (input_section->output_section->vma
3528                        + input_section->output_offset
3529                        + rel->r_offset);
3530         insn = (insn & ~0xfff)
3531                | ((howto->bitpos << 7) & 0xf00)
3532                | ((relocation >> howto->bitpos) & 0xff);
3533         bfd_put_32 (input_bfd, value, hit_data);
3534       }
3535       return bfd_reloc_ok;
3536
3537     case R_ARM_GNU_VTINHERIT:
3538     case R_ARM_GNU_VTENTRY:
3539       return bfd_reloc_ok;
3540
3541     case R_ARM_GOTOFF32:
3542       /* Relocation is relative to the start of the
3543          global offset table.  */
3544
3545       BFD_ASSERT (sgot != NULL);
3546       if (sgot == NULL)
3547         return bfd_reloc_notsupported;
3548
3549       /* If we are addressing a Thumb function, we need to adjust the
3550          address by one, so that attempts to call the function pointer will
3551          correctly interpret it as Thumb code.  */
3552       if (sym_flags == STT_ARM_TFUNC)
3553         value += 1;
3554
3555       /* Note that sgot->output_offset is not involved in this
3556          calculation.  We always want the start of .got.  If we
3557          define _GLOBAL_OFFSET_TABLE in a different way, as is
3558          permitted by the ABI, we might have to change this
3559          calculation.  */
3560       value -= sgot->output_section->vma;
3561       return _bfd_final_link_relocate (howto, input_bfd, input_section,
3562                                        contents, rel->r_offset, value,
3563                                        (bfd_vma) 0);
3564
3565     case R_ARM_GOTPC:
3566       /* Use global offset table as symbol value.  */
3567       BFD_ASSERT (sgot != NULL);
3568
3569       if (sgot == NULL)
3570         return bfd_reloc_notsupported;
3571
3572       *unresolved_reloc_p = FALSE;
3573       value = sgot->output_section->vma;
3574       return _bfd_final_link_relocate (howto, input_bfd, input_section,
3575                                        contents, rel->r_offset, value,
3576                                        (bfd_vma) 0);
3577
3578     case R_ARM_GOT32:
3579     case R_ARM_GOT_PREL:
3580       /* Relocation is to the entry for this symbol in the
3581          global offset table.  */
3582       if (sgot == NULL)
3583         return bfd_reloc_notsupported;
3584
3585       if (h != NULL)
3586         {
3587           bfd_vma off;
3588           bfd_boolean dyn;
3589
3590           off = h->got.offset;
3591           BFD_ASSERT (off != (bfd_vma) -1);
3592           dyn = globals->root.dynamic_sections_created;
3593
3594           if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
3595               || (info->shared
3596                   && SYMBOL_REFERENCES_LOCAL (info, h))
3597               || (ELF_ST_VISIBILITY (h->other)
3598                   && h->root.type == bfd_link_hash_undefweak))
3599             {
3600               /* This is actually a static link, or it is a -Bsymbolic link
3601                  and the symbol is defined locally.  We must initialize this
3602                  entry in the global offset table.  Since the offset must
3603                  always be a multiple of 4, we use the least significant bit
3604                  to record whether we have initialized it already.
3605
3606                  When doing a dynamic link, we create a .rel.got relocation
3607                  entry to initialize the value.  This is done in the
3608                  finish_dynamic_symbol routine.  */
3609               if ((off & 1) != 0)
3610                 off &= ~1;
3611               else
3612                 {
3613                   /* If we are addressing a Thumb function, we need to
3614                      adjust the address by one, so that attempts to
3615                      call the function pointer will correctly
3616                      interpret it as Thumb code.  */
3617                   if (sym_flags == STT_ARM_TFUNC)
3618                     value |= 1;
3619
3620                   bfd_put_32 (output_bfd, value, sgot->contents + off);
3621                   h->got.offset |= 1;
3622                 }
3623             }
3624           else
3625             *unresolved_reloc_p = FALSE;
3626
3627           value = sgot->output_offset + off;
3628         }
3629       else
3630         {
3631           bfd_vma off;
3632
3633           BFD_ASSERT (local_got_offsets != NULL &&
3634                       local_got_offsets[r_symndx] != (bfd_vma) -1);
3635
3636           off = local_got_offsets[r_symndx];
3637
3638           /* The offset must always be a multiple of 4.  We use the
3639              least significant bit to record whether we have already
3640              generated the necessary reloc.  */
3641           if ((off & 1) != 0)
3642             off &= ~1;
3643           else
3644             {
3645               /* If we are addressing a Thumb function, we need to
3646                  adjust the address by one, so that attempts to
3647                  call the function pointer will correctly
3648                  interpret it as Thumb code.  */
3649               if (sym_flags == STT_ARM_TFUNC)
3650                 value |= 1;
3651
3652               bfd_put_32 (output_bfd, value, sgot->contents + off);
3653
3654               if (info->shared)
3655                 {
3656                   asection * srelgot;
3657                   Elf_Internal_Rela outrel;
3658                   bfd_byte *loc;
3659
3660                   srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
3661                   BFD_ASSERT (srelgot != NULL);
3662
3663                   outrel.r_offset = (sgot->output_section->vma
3664                                      + sgot->output_offset
3665                                      + off);
3666                   outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
3667                   loc = srelgot->contents;
3668                   loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
3669                   bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3670                 }
3671
3672               local_got_offsets[r_symndx] |= 1;
3673             }
3674
3675           value = sgot->output_offset + off;
3676         }
3677       if (r_type != R_ARM_GOT32)
3678         value += sgot->output_section->vma;
3679
3680       return _bfd_final_link_relocate (howto, input_bfd, input_section,
3681                                        contents, rel->r_offset, value,
3682                                        (bfd_vma) 0);
3683
3684     case R_ARM_TLS_LDO32:
3685       value = value - dtpoff_base (info);
3686
3687       return _bfd_final_link_relocate (howto, input_bfd, input_section,
3688                                        contents, rel->r_offset, value, (bfd_vma) 0);
3689
3690     case R_ARM_TLS_LDM32:
3691       {
3692         bfd_vma off;
3693
3694         if (globals->sgot == NULL)
3695           abort ();
3696
3697         off = globals->tls_ldm_got.offset;
3698
3699         if ((off & 1) != 0)
3700           off &= ~1;
3701         else
3702           {
3703             /* If we don't know the module number, create a relocation
3704                for it.  */
3705             if (info->shared)
3706               {
3707                 Elf_Internal_Rela outrel;
3708                 bfd_byte *loc;
3709
3710                 if (globals->srelgot == NULL)
3711                   abort ();
3712
3713                 outrel.r_offset = (globals->sgot->output_section->vma
3714                                    + globals->sgot->output_offset + off);
3715                 outrel.r_info = ELF32_R_INFO (0, R_ARM_TLS_DTPMOD32);
3716
3717                 bfd_put_32 (output_bfd, 0, globals->sgot->contents + off);
3718
3719                 loc = globals->srelgot->contents;
3720                 loc += globals->srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
3721                 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3722               }
3723             else
3724               bfd_put_32 (output_bfd, 1, globals->sgot->contents + off);
3725
3726             globals->tls_ldm_got.offset |= 1;
3727           }
3728
3729         value = globals->sgot->output_section->vma + globals->sgot->output_offset + off
3730           - (input_section->output_section->vma + input_section->output_offset + rel->r_offset);
3731
3732         return _bfd_final_link_relocate (howto, input_bfd, input_section,
3733                                          contents, rel->r_offset, value,
3734                                          (bfd_vma) 0);
3735       }
3736
3737     case R_ARM_TLS_GD32:
3738     case R_ARM_TLS_IE32:
3739       {
3740         bfd_vma off;
3741         int indx;
3742         char tls_type;
3743
3744         if (globals->sgot == NULL)
3745           abort ();
3746
3747         indx = 0;
3748         if (h != NULL)
3749           {
3750             bfd_boolean dyn;
3751             dyn = globals->root.dynamic_sections_created;
3752             if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
3753                 && (!info->shared
3754                     || !SYMBOL_REFERENCES_LOCAL (info, h)))
3755               {
3756                 *unresolved_reloc_p = FALSE;
3757                 indx = h->dynindx;
3758               }
3759             off = h->got.offset;
3760             tls_type = ((struct elf32_arm_link_hash_entry *) h)->tls_type;
3761           }
3762         else
3763           {
3764             if (local_got_offsets == NULL)
3765               abort ();
3766             off = local_got_offsets[r_symndx];
3767             tls_type = elf32_arm_local_got_tls_type (input_bfd)[r_symndx];
3768           }
3769
3770         if (tls_type == GOT_UNKNOWN)
3771           abort ();
3772
3773         if ((off & 1) != 0)
3774           off &= ~1;
3775         else
3776           {
3777             bfd_boolean need_relocs = FALSE;
3778             Elf_Internal_Rela outrel;
3779             bfd_byte *loc = NULL;
3780             int cur_off = off;
3781
3782             /* The GOT entries have not been initialized yet.  Do it
3783                now, and emit any relocations.  If both an IE GOT and a
3784                GD GOT are necessary, we emit the GD first.  */
3785
3786             if ((info->shared || indx != 0)
3787                 && (h == NULL
3788                     || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3789                     || h->root.type != bfd_link_hash_undefweak))
3790               {
3791                 need_relocs = TRUE;
3792                 if (globals->srelgot == NULL)
3793                   abort ();
3794                 loc = globals->srelgot->contents;
3795                 loc += globals->srelgot->reloc_count * sizeof (Elf32_External_Rel);
3796               }
3797
3798             if (tls_type & GOT_TLS_GD)
3799               {
3800                 if (need_relocs)
3801                   {
3802                     outrel.r_offset = (globals->sgot->output_section->vma
3803                                        + globals->sgot->output_offset + cur_off);
3804                     outrel.r_info = ELF32_R_INFO (indx, R_ARM_TLS_DTPMOD32);
3805                     bfd_put_32 (output_bfd, 0, globals->sgot->contents + cur_off);
3806
3807                     bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3808                     globals->srelgot->reloc_count++;
3809                     loc += sizeof (Elf32_External_Rel);
3810
3811                     if (indx == 0)
3812                       bfd_put_32 (output_bfd, value - dtpoff_base (info),
3813                                   globals->sgot->contents + cur_off + 4);
3814                     else
3815                       {
3816                         bfd_put_32 (output_bfd, 0,
3817                                     globals->sgot->contents + cur_off + 4);
3818
3819                         outrel.r_info = ELF32_R_INFO (indx,
3820                                                       R_ARM_TLS_DTPOFF32);
3821                         outrel.r_offset += 4;
3822                         bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3823                         globals->srelgot->reloc_count++;
3824                         loc += sizeof (Elf32_External_Rel);
3825                       }
3826                   }
3827                 else
3828                   {
3829                     /* If we are not emitting relocations for a
3830                        general dynamic reference, then we must be in a
3831                        static link or an executable link with the
3832                        symbol binding locally.  Mark it as belonging
3833                        to module 1, the executable.  */
3834                     bfd_put_32 (output_bfd, 1,
3835                                 globals->sgot->contents + cur_off);
3836                     bfd_put_32 (output_bfd, value - dtpoff_base (info),
3837                                 globals->sgot->contents + cur_off + 4);
3838                   }
3839
3840                 cur_off += 8;
3841               }
3842
3843             if (tls_type & GOT_TLS_IE)
3844               {
3845                 if (need_relocs)
3846                   {
3847                     outrel.r_offset = (globals->sgot->output_section->vma
3848                                        + globals->sgot->output_offset
3849                                        + cur_off);
3850                     outrel.r_info = ELF32_R_INFO (indx, R_ARM_TLS_TPOFF32);
3851
3852                     if (indx == 0)
3853                       bfd_put_32 (output_bfd, value - dtpoff_base (info),
3854                                   globals->sgot->contents + cur_off);
3855                     else
3856                       bfd_put_32 (output_bfd, 0,
3857                                   globals->sgot->contents + cur_off);
3858
3859                     bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3860                     globals->srelgot->reloc_count++;
3861                     loc += sizeof (Elf32_External_Rel);
3862                   }
3863                 else
3864                   bfd_put_32 (output_bfd, tpoff (info, value),
3865                               globals->sgot->contents + cur_off);
3866                 cur_off += 4;
3867               }
3868
3869             if (h != NULL)
3870               h->got.offset |= 1;
3871             else
3872               local_got_offsets[r_symndx] |= 1;
3873           }
3874
3875         if ((tls_type & GOT_TLS_GD) && r_type != R_ARM_TLS_GD32)
3876           off += 8;
3877         value = globals->sgot->output_section->vma + globals->sgot->output_offset + off
3878           - (input_section->output_section->vma + input_section->output_offset + rel->r_offset);
3879
3880         return _bfd_final_link_relocate (howto, input_bfd, input_section,
3881                                          contents, rel->r_offset, value,
3882                                          (bfd_vma) 0);
3883       }
3884
3885     case R_ARM_TLS_LE32:
3886       if (info->shared)
3887         {
3888           (*_bfd_error_handler)
3889             (_("%B(%A+0x%lx): R_ARM_TLS_LE32 relocation not permitted in shared object"),
3890              input_bfd, input_section,
3891              (long) rel->r_offset, howto->name);
3892           return FALSE;
3893         }
3894       else
3895         value = tpoff (info, value);
3896
3897       return _bfd_final_link_relocate (howto, input_bfd, input_section,
3898                                        contents, rel->r_offset, value, (bfd_vma) 0);
3899
3900     case R_ARM_V4BX:
3901       if (globals->fix_v4bx)
3902         {
3903           bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
3904
3905           /* Ensure that we have a BX instruction.  */
3906           BFD_ASSERT ((insn & 0x0ffffff0) == 0x012fff10);
3907
3908           /* Preserve Rm (lowest four bits) and the condition code
3909              (highest four bits). Other bits encode MOV PC,Rm.  */
3910           insn = (insn & 0xf000000f) | 0x01a0f000;
3911
3912           bfd_put_32 (input_bfd, insn, hit_data);
3913         }
3914       return bfd_reloc_ok;
3915
3916     default:
3917       return bfd_reloc_notsupported;
3918     }
3919 }
3920
3921
3922 static int
3923 uleb128_size (unsigned int i)
3924 {
3925   int size;
3926   size = 1;
3927   while (i >= 0x80)
3928     {
3929       i >>= 7;
3930       size++;
3931     }
3932   return size;
3933 }
3934
3935 /* Return TRUE if the attribute has the default value (0/"").  */
3936 static bfd_boolean
3937 is_default_attr (aeabi_attribute *attr)
3938 {
3939   if ((attr->type & 1) && attr->i != 0)
3940     return FALSE;
3941   if ((attr->type & 2) && attr->s && *attr->s)
3942     return FALSE;
3943
3944   return TRUE;
3945 }
3946
3947 /* Return the size of a single attribute.  */
3948 static bfd_vma
3949 eabi_attr_size(int tag, aeabi_attribute *attr)
3950 {
3951   bfd_vma size;
3952
3953   if (is_default_attr (attr))
3954     return 0;
3955
3956   size = uleb128_size (tag);
3957   if (attr->type & 1)
3958     size += uleb128_size (attr->i);
3959   if (attr->type & 2)
3960     size += strlen ((char *)attr->s) + 1;
3961   return size;
3962 }
3963
3964 /* Returns the size of the eabi object attributess section.  */
3965 bfd_vma
3966 elf32_arm_eabi_attr_size (bfd *abfd)
3967 {
3968   bfd_vma size;
3969   aeabi_attribute *attr;
3970   aeabi_attribute_list *list;
3971   int i;
3972
3973   attr = elf32_arm_tdata (abfd)->known_eabi_attributes;
3974   size = 16; /* 'A' <size> "aeabi" 0x1 <size>.  */
3975   for (i = 4; i < NUM_KNOWN_ATTRIBUTES; i++)
3976     size += eabi_attr_size (i, &attr[i]);
3977
3978   for (list = elf32_arm_tdata (abfd)->other_eabi_attributes;
3979        list;
3980        list = list->next)
3981     size += eabi_attr_size (list->tag, &list->attr);
3982
3983   return size;
3984 }
3985
3986 static bfd_byte *
3987 write_uleb128 (bfd_byte *p, unsigned int val)
3988 {
3989   bfd_byte c;
3990   do
3991     {
3992       c = val & 0x7f;
3993       val >>= 7;
3994       if (val)
3995         c |= 0x80;
3996       *(p++) = c;
3997     }
3998   while (val);
3999   return p;
4000 }
4001
4002 /* Write attribute ATTR to butter P, and return a pointer to the following
4003    byte.  */
4004 static bfd_byte *
4005 write_eabi_attribute (bfd_byte *p, int tag, aeabi_attribute *attr)
4006 {
4007   /* Suppress default entries.  */
4008   if (is_default_attr(attr))
4009     return p;
4010
4011   p = write_uleb128 (p, tag);
4012   if (attr->type & 1)
4013     p = write_uleb128 (p, attr->i);
4014   if (attr->type & 2)
4015     {
4016       int len;
4017
4018       len = strlen (attr->s) + 1;
4019       memcpy (p, attr->s, len);
4020       p += len;
4021     }
4022
4023   return p;
4024 }
4025
4026 /* Write the contents of the eabi attributes section to p.  */
4027 void
4028 elf32_arm_set_eabi_attr_contents (bfd *abfd, bfd_byte *contents, bfd_vma size)
4029 {
4030   bfd_byte *p;
4031   aeabi_attribute *attr;
4032   aeabi_attribute_list *list;
4033   int i;
4034
4035   p = contents;
4036   *(p++) = 'A';
4037   bfd_put_32 (abfd, size - 1, p);
4038   p += 4;
4039   memcpy (p, "aeabi", 6);
4040   p += 6;
4041   *(p++) = Tag_File;
4042   bfd_put_32 (abfd, size - 11, p);
4043   p += 4;
4044
4045   attr = elf32_arm_tdata (abfd)->known_eabi_attributes;
4046   for (i = 4; i < NUM_KNOWN_ATTRIBUTES; i++)
4047     p = write_eabi_attribute (p, i, &attr[i]);
4048
4049   for (list = elf32_arm_tdata (abfd)->other_eabi_attributes;
4050        list;
4051        list = list->next)
4052     p = write_eabi_attribute (p, list->tag, &list->attr);
4053 }
4054
4055 /* Override final_link to handle EABI object attribute sections.  */
4056
4057 static bfd_boolean
4058 elf32_arm_bfd_final_link (bfd *abfd, struct bfd_link_info *info)
4059 {
4060   asection *o;
4061   struct bfd_link_order *p;
4062   asection *attr_section = NULL;
4063   bfd_byte *contents;
4064   bfd_vma size = 0;
4065
4066   /* elf32_arm_merge_private_bfd_data will already have merged the
4067      object attributes.  Remove the input sections from the link, and set
4068      the contents of the output secton.  */
4069   for (o = abfd->sections; o != NULL; o = o->next)
4070     {
4071       if (strcmp (o->name, ".ARM.attributes") == 0)
4072         {
4073           for (p = o->map_head.link_order; p != NULL; p = p->next)
4074             {
4075               asection *input_section;
4076
4077               if (p->type != bfd_indirect_link_order)
4078                 continue;
4079               input_section = p->u.indirect.section;
4080               /* Hack: reset the SEC_HAS_CONTENTS flag so that
4081                  elf_link_input_bfd ignores this section.  */
4082               input_section->flags &= ~SEC_HAS_CONTENTS;
4083             }
4084
4085           size = elf32_arm_eabi_attr_size (abfd);
4086           bfd_set_section_size (abfd, o, size);
4087           attr_section = o;
4088           /* Skip this section later on.  */
4089           o->map_head.link_order = NULL;
4090         }
4091     }
4092   /* Invoke the ELF linker to do all the work.  */
4093   if (!bfd_elf_final_link (abfd, info))
4094     return FALSE;
4095
4096   if (attr_section)
4097     {
4098       contents = bfd_malloc(size);
4099       if (contents == NULL)
4100         return FALSE;
4101       elf32_arm_set_eabi_attr_contents (abfd, contents, size);
4102       bfd_set_section_contents (abfd, attr_section, contents, 0, size);
4103       free (contents);
4104     }
4105   return TRUE;
4106 }
4107
4108
4109 /* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS.  */
4110 static void
4111 arm_add_to_rel (bfd *              abfd,
4112                 bfd_byte *         address,
4113                 reloc_howto_type * howto,
4114                 bfd_signed_vma     increment)
4115 {
4116   bfd_signed_vma addend;
4117
4118   if (howto->type == R_ARM_THM_CALL)
4119     {
4120       int upper_insn, lower_insn;
4121       int upper, lower;
4122
4123       upper_insn = bfd_get_16 (abfd, address);
4124       lower_insn = bfd_get_16 (abfd, address + 2);
4125       upper = upper_insn & 0x7ff;
4126       lower = lower_insn & 0x7ff;
4127
4128       addend = (upper << 12) | (lower << 1);
4129       addend += increment;
4130       addend >>= 1;
4131
4132       upper_insn = (upper_insn & 0xf800) | ((addend >> 11) & 0x7ff);
4133       lower_insn = (lower_insn & 0xf800) | (addend & 0x7ff);
4134
4135       bfd_put_16 (abfd, (bfd_vma) upper_insn, address);
4136       bfd_put_16 (abfd, (bfd_vma) lower_insn, address + 2);
4137     }
4138   else
4139     {
4140       bfd_vma        contents;
4141
4142       contents = bfd_get_32 (abfd, address);
4143
4144       /* Get the (signed) value from the instruction.  */
4145       addend = contents & howto->src_mask;
4146       if (addend & ((howto->src_mask + 1) >> 1))
4147         {
4148           bfd_signed_vma mask;
4149
4150           mask = -1;
4151           mask &= ~ howto->src_mask;
4152           addend |= mask;
4153         }
4154
4155       /* Add in the increment, (which is a byte value).  */
4156       switch (howto->type)
4157         {
4158         default:
4159           addend += increment;
4160           break;
4161
4162         case R_ARM_PC24:
4163         case R_ARM_PLT32:
4164         case R_ARM_CALL:
4165         case R_ARM_JUMP24:
4166           addend <<= howto->size;
4167           addend += increment;
4168
4169           /* Should we check for overflow here ?  */
4170
4171           /* Drop any undesired bits.  */
4172           addend >>= howto->rightshift;
4173           break;
4174         }
4175
4176       contents = (contents & ~ howto->dst_mask) | (addend & howto->dst_mask);
4177
4178       bfd_put_32 (abfd, contents, address);
4179     }
4180 }
4181
4182 #define IS_ARM_TLS_RELOC(R_TYPE)        \
4183   ((R_TYPE) == R_ARM_TLS_GD32           \
4184    || (R_TYPE) == R_ARM_TLS_LDO32       \
4185    || (R_TYPE) == R_ARM_TLS_LDM32       \
4186    || (R_TYPE) == R_ARM_TLS_DTPOFF32    \
4187    || (R_TYPE) == R_ARM_TLS_DTPMOD32    \
4188    || (R_TYPE) == R_ARM_TLS_TPOFF32     \
4189    || (R_TYPE) == R_ARM_TLS_LE32        \
4190    || (R_TYPE) == R_ARM_TLS_IE32)
4191
4192 /* Relocate an ARM ELF section.  */
4193 static bfd_boolean
4194 elf32_arm_relocate_section (bfd *                  output_bfd,
4195                             struct bfd_link_info * info,
4196                             bfd *                  input_bfd,
4197                             asection *             input_section,
4198                             bfd_byte *             contents,
4199                             Elf_Internal_Rela *    relocs,
4200                             Elf_Internal_Sym *     local_syms,
4201                             asection **            local_sections)
4202 {
4203   Elf_Internal_Shdr *symtab_hdr;
4204   struct elf_link_hash_entry **sym_hashes;
4205   Elf_Internal_Rela *rel;
4206   Elf_Internal_Rela *relend;
4207   const char *name;
4208   struct elf32_arm_link_hash_table * globals;
4209
4210   globals = elf32_arm_hash_table (info);
4211   if (info->relocatable && !globals->use_rel)
4212     return TRUE;
4213
4214   symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
4215   sym_hashes = elf_sym_hashes (input_bfd);
4216
4217   rel = relocs;
4218   relend = relocs + input_section->reloc_count;
4219   for (; rel < relend; rel++)
4220     {
4221       int                          r_type;
4222       reloc_howto_type *           howto;
4223       unsigned long                r_symndx;
4224       Elf_Internal_Sym *           sym;
4225       asection *                   sec;
4226       struct elf_link_hash_entry * h;
4227       bfd_vma                      relocation;
4228       bfd_reloc_status_type        r;
4229       arelent                      bfd_reloc;
4230       char                         sym_type;
4231       bfd_boolean                  unresolved_reloc = FALSE;
4232
4233       r_symndx = ELF32_R_SYM (rel->r_info);
4234       r_type   = ELF32_R_TYPE (rel->r_info);
4235       r_type   = arm_real_reloc_type (globals, r_type);
4236
4237       if (   r_type == R_ARM_GNU_VTENTRY
4238           || r_type == R_ARM_GNU_VTINHERIT)
4239         continue;
4240
4241       bfd_reloc.howto = elf32_arm_howto_from_type (r_type);
4242       howto = bfd_reloc.howto;
4243
4244       if (info->relocatable && globals->use_rel)
4245         {
4246           /* This is a relocatable link.  We don't have to change
4247              anything, unless the reloc is against a section symbol,
4248              in which case we have to adjust according to where the
4249              section symbol winds up in the output section.  */
4250           if (r_symndx < symtab_hdr->sh_info)
4251             {
4252               sym = local_syms + r_symndx;
4253               if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4254                 {
4255                   sec = local_sections[r_symndx];
4256                   arm_add_to_rel (input_bfd, contents + rel->r_offset,
4257                                   howto,
4258                                   (bfd_signed_vma) (sec->output_offset
4259                                                     + sym->st_value));
4260                 }
4261             }
4262
4263           continue;
4264         }
4265
4266       /* This is a final link.  */
4267       h = NULL;
4268       sym = NULL;
4269       sec = NULL;
4270
4271       if (r_symndx < symtab_hdr->sh_info)
4272         {
4273           sym = local_syms + r_symndx;
4274           sym_type = ELF32_ST_TYPE (sym->st_info);
4275           sec = local_sections[r_symndx];
4276           if (globals->use_rel)
4277             {
4278               relocation = (sec->output_section->vma
4279                             + sec->output_offset
4280                             + sym->st_value);
4281               if ((sec->flags & SEC_MERGE)
4282                        && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4283                 {
4284                   asection *msec;
4285                   bfd_vma addend, value;
4286
4287                   if (howto->rightshift)
4288                     {
4289                       (*_bfd_error_handler)
4290                         (_("%B(%A+0x%lx): %s relocation against SEC_MERGE section"),
4291                          input_bfd, input_section,
4292                          (long) rel->r_offset, howto->name);
4293                       return FALSE;
4294                     }
4295
4296                   value = bfd_get_32 (input_bfd, contents + rel->r_offset);
4297
4298                   /* Get the (signed) value from the instruction.  */
4299                   addend = value & howto->src_mask;
4300                   if (addend & ((howto->src_mask + 1) >> 1))
4301                     {
4302                       bfd_signed_vma mask;
4303
4304                       mask = -1;
4305                       mask &= ~ howto->src_mask;
4306                       addend |= mask;
4307                     }
4308                   msec = sec;
4309                   addend =
4310                     _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend)
4311                     - relocation;
4312                   addend += msec->output_section->vma + msec->output_offset;
4313                   value = (value & ~ howto->dst_mask) | (addend & howto->dst_mask);
4314                   bfd_put_32 (input_bfd, value, contents + rel->r_offset);
4315                 }
4316             }
4317           else
4318             relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
4319         }
4320       else
4321         {
4322           bfd_boolean warned;
4323
4324           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
4325                                    r_symndx, symtab_hdr, sym_hashes,
4326                                    h, sec, relocation,
4327                                    unresolved_reloc, warned);
4328
4329           sym_type = h->type;
4330         }
4331
4332       if (h != NULL)
4333         name = h->root.root.string;
4334       else
4335         {
4336           name = (bfd_elf_string_from_elf_section
4337                   (input_bfd, symtab_hdr->sh_link, sym->st_name));
4338           if (name == NULL || *name == '\0')
4339             name = bfd_section_name (input_bfd, sec);
4340         }
4341
4342       if (r_symndx != 0
4343           && r_type != R_ARM_NONE
4344           && (h == NULL
4345               || h->root.type == bfd_link_hash_defined
4346               || h->root.type == bfd_link_hash_defweak)
4347           && IS_ARM_TLS_RELOC (r_type) != (sym_type == STT_TLS))
4348         {
4349           (*_bfd_error_handler)
4350             ((sym_type == STT_TLS
4351               ? _("%B(%A+0x%lx): %s used with TLS symbol %s")
4352               : _("%B(%A+0x%lx): %s used with non-TLS symbol %s")),
4353              input_bfd,
4354              input_section,
4355              (long) rel->r_offset,
4356              howto->name,
4357              name);
4358         }
4359
4360       r = elf32_arm_final_link_relocate (howto, input_bfd, output_bfd,
4361                                          input_section, contents, rel,
4362                                          relocation, info, sec, name,
4363                                          (h ? ELF_ST_TYPE (h->type) :
4364                                           ELF_ST_TYPE (sym->st_info)), h,
4365                                          &unresolved_reloc);
4366
4367       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
4368          because such sections are not SEC_ALLOC and thus ld.so will
4369          not process them.  */
4370       if (unresolved_reloc
4371           && !((input_section->flags & SEC_DEBUGGING) != 0
4372                && h->def_dynamic))
4373         {
4374           (*_bfd_error_handler)
4375             (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
4376              input_bfd,
4377              input_section,
4378              (long) rel->r_offset,
4379              howto->name,
4380              h->root.root.string);
4381           return FALSE;
4382         }
4383
4384       if (r != bfd_reloc_ok)
4385         {
4386           const char * msg = (const char *) 0;
4387
4388           switch (r)
4389             {
4390             case bfd_reloc_overflow:
4391               /* If the overflowing reloc was to an undefined symbol,
4392                  we have already printed one error message and there
4393                  is no point complaining again.  */
4394               if ((! h ||
4395                    h->root.type != bfd_link_hash_undefined)
4396                   && (!((*info->callbacks->reloc_overflow)
4397                         (info, (h ? &h->root : NULL), name, howto->name,
4398                          (bfd_vma) 0, input_bfd, input_section,
4399                          rel->r_offset))))
4400                   return FALSE;
4401               break;
4402
4403             case bfd_reloc_undefined:
4404               if (!((*info->callbacks->undefined_symbol)
4405                     (info, name, input_bfd, input_section,
4406                      rel->r_offset, TRUE)))
4407                 return FALSE;
4408               break;
4409
4410             case bfd_reloc_outofrange:
4411               msg = _("internal error: out of range error");
4412               goto common_error;
4413
4414             case bfd_reloc_notsupported:
4415               msg = _("internal error: unsupported relocation error");
4416               goto common_error;
4417
4418             case bfd_reloc_dangerous:
4419               msg = _("internal error: dangerous error");
4420               goto common_error;
4421
4422             default:
4423               msg = _("internal error: unknown error");
4424               /* fall through */
4425
4426             common_error:
4427               if (!((*info->callbacks->warning)
4428                     (info, msg, name, input_bfd, input_section,
4429                      rel->r_offset)))
4430                 return FALSE;
4431               break;
4432             }
4433         }
4434     }
4435
4436   return TRUE;
4437 }
4438
4439 /* Allocate/find an object attribute.  */
4440 static aeabi_attribute *
4441 elf32_arm_new_eabi_attr (bfd *abfd, int tag)
4442 {
4443   aeabi_attribute *attr;
4444   aeabi_attribute_list *list;
4445   aeabi_attribute_list *p;
4446   aeabi_attribute_list **lastp;
4447
4448
4449   if (tag < NUM_KNOWN_ATTRIBUTES)
4450     {
4451       /* Knwon tags are preallocated.  */
4452       attr = &elf32_arm_tdata (abfd)->known_eabi_attributes[tag];
4453     }
4454   else
4455     {
4456       /* Create a new tag.  */
4457       list = (aeabi_attribute_list *)
4458         bfd_alloc (abfd, sizeof (aeabi_attribute_list));
4459       memset (list, 0, sizeof (aeabi_attribute_list));
4460       list->tag = tag;
4461       /* Keep the tag list in order.  */
4462       lastp = &elf32_arm_tdata (abfd)->other_eabi_attributes;
4463       for (p = *lastp; p; p = p->next)
4464         {
4465           if (tag < p->tag)
4466             break;
4467           lastp = &p->next;
4468         }
4469       list->next = *lastp;
4470       *lastp = list;
4471       attr = &list->attr;
4472     }
4473
4474   return attr;
4475 }
4476
4477 void
4478 elf32_arm_add_eabi_attr_int (bfd *abfd, int tag, unsigned int i)
4479 {
4480   aeabi_attribute *attr;
4481
4482   attr = elf32_arm_new_eabi_attr (abfd, tag);
4483   attr->type = 1;
4484   attr->i = i;
4485 }
4486
4487 static char *
4488 attr_strdup (bfd *abfd, const char * s)
4489 {
4490   char * p;
4491   int len;
4492
4493   len = strlen (s) + 1;
4494   p = (char *)bfd_alloc(abfd, len);
4495   return memcpy (p, s, len);
4496 }
4497
4498 void
4499 elf32_arm_add_eabi_attr_string (bfd *abfd, int tag, const char *s)
4500 {
4501   aeabi_attribute *attr;
4502
4503   attr = elf32_arm_new_eabi_attr (abfd, tag);
4504   attr->type = 2;
4505   attr->s = attr_strdup (abfd, s);
4506 }
4507
4508 void
4509 elf32_arm_add_eabi_attr_compat (bfd *abfd, unsigned int i, const char *s)
4510 {
4511   aeabi_attribute_list *list;
4512   aeabi_attribute_list *p;
4513   aeabi_attribute_list **lastp;
4514
4515   list = (aeabi_attribute_list *)
4516     bfd_alloc (abfd, sizeof (aeabi_attribute_list));
4517   memset (list, 0, sizeof (aeabi_attribute_list));
4518   list->tag = Tag_compatibility;
4519   list->attr.type = 3;
4520   list->attr.i = i;
4521   list->attr.s = attr_strdup (abfd, s);
4522
4523   lastp = &elf32_arm_tdata (abfd)->other_eabi_attributes;
4524   for (p = *lastp; p; p = p->next)
4525     {
4526       int cmp;
4527       if (p->tag != Tag_compatibility)
4528         break;
4529       cmp = strcmp(s, p->attr.s);
4530       if (cmp < 0 || (cmp == 0 && i < p->attr.i))
4531         break;
4532       lastp = &p->next;
4533     }
4534   list->next = *lastp;
4535   *lastp = list;
4536 }
4537
4538 /* Set the right machine number.  */
4539
4540 static bfd_boolean
4541 elf32_arm_object_p (bfd *abfd)
4542 {
4543   unsigned int mach;
4544
4545   mach = bfd_arm_get_mach_from_notes (abfd, ARM_NOTE_SECTION);
4546
4547   if (mach != bfd_mach_arm_unknown)
4548     bfd_default_set_arch_mach (abfd, bfd_arch_arm, mach);
4549
4550   else if (elf_elfheader (abfd)->e_flags & EF_ARM_MAVERICK_FLOAT)
4551     bfd_default_set_arch_mach (abfd, bfd_arch_arm, bfd_mach_arm_ep9312);
4552
4553   else
4554     bfd_default_set_arch_mach (abfd, bfd_arch_arm, mach);
4555
4556   return TRUE;
4557 }
4558
4559 /* Function to keep ARM specific flags in the ELF header.  */
4560
4561 static bfd_boolean
4562 elf32_arm_set_private_flags (bfd *abfd, flagword flags)
4563 {
4564   if (elf_flags_init (abfd)
4565       && elf_elfheader (abfd)->e_flags != flags)
4566     {
4567       if (EF_ARM_EABI_VERSION (flags) == EF_ARM_EABI_UNKNOWN)
4568         {
4569           if (flags & EF_ARM_INTERWORK)
4570             (*_bfd_error_handler)
4571               (_("Warning: Not setting interworking flag of %B since it has already been specified as non-interworking"),
4572                abfd);
4573           else
4574             _bfd_error_handler
4575               (_("Warning: Clearing the interworking flag of %B due to outside request"),
4576                abfd);
4577         }
4578     }
4579   else
4580     {
4581       elf_elfheader (abfd)->e_flags = flags;
4582       elf_flags_init (abfd) = TRUE;
4583     }
4584
4585   return TRUE;
4586 }
4587
4588 /* Copy the eabi object attribute from IBFD to OBFD.  */
4589 static void
4590 copy_eabi_attributes (bfd *ibfd, bfd *obfd)
4591 {
4592   aeabi_attribute *in_attr;
4593   aeabi_attribute *out_attr;
4594   aeabi_attribute_list *list;
4595   int i;
4596
4597   in_attr = elf32_arm_tdata (ibfd)->known_eabi_attributes;
4598   out_attr = elf32_arm_tdata (obfd)->known_eabi_attributes;
4599   for (i = 4; i < NUM_KNOWN_ATTRIBUTES; i++)
4600     {
4601       out_attr->i = in_attr->i;
4602       if (in_attr->s && *in_attr->s)
4603         out_attr->s = attr_strdup (obfd, in_attr->s);
4604       in_attr++;
4605       out_attr++;
4606     }
4607
4608   for (list = elf32_arm_tdata (ibfd)->other_eabi_attributes;
4609        list;
4610        list = list->next)
4611     {
4612       in_attr = &list->attr;
4613       switch (in_attr->type)
4614         {
4615         case 1:
4616           elf32_arm_add_eabi_attr_int (obfd, list->tag, in_attr->i);
4617           break;
4618         case 2:
4619           elf32_arm_add_eabi_attr_string (obfd, list->tag, in_attr->s);
4620           break;
4621         case 3:
4622           elf32_arm_add_eabi_attr_compat (obfd, in_attr->i, in_attr->s);
4623           break;
4624         default:
4625           abort();
4626         }
4627     }
4628 }
4629
4630
4631 /* Copy backend specific data from one object module to another.  */
4632
4633 static bfd_boolean
4634 elf32_arm_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
4635 {
4636   flagword in_flags;
4637   flagword out_flags;
4638
4639   if (   bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4640       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4641     return TRUE;
4642
4643   in_flags  = elf_elfheader (ibfd)->e_flags;
4644   out_flags = elf_elfheader (obfd)->e_flags;
4645
4646   if (elf_flags_init (obfd)
4647       && EF_ARM_EABI_VERSION (out_flags) == EF_ARM_EABI_UNKNOWN
4648       && in_flags != out_flags)
4649     {
4650       /* Cannot mix APCS26 and APCS32 code.  */
4651       if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
4652         return FALSE;
4653
4654       /* Cannot mix float APCS and non-float APCS code.  */
4655       if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
4656         return FALSE;
4657
4658       /* If the src and dest have different interworking flags
4659          then turn off the interworking bit.  */
4660       if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
4661         {
4662           if (out_flags & EF_ARM_INTERWORK)
4663             _bfd_error_handler
4664               (_("Warning: Clearing the interworking flag of %B because non-interworking code in %B has been linked with it"),
4665                obfd, ibfd);
4666
4667           in_flags &= ~EF_ARM_INTERWORK;
4668         }
4669
4670       /* Likewise for PIC, though don't warn for this case.  */
4671       if ((in_flags & EF_ARM_PIC) != (out_flags & EF_ARM_PIC))
4672         in_flags &= ~EF_ARM_PIC;
4673     }
4674
4675   elf_elfheader (obfd)->e_flags = in_flags;
4676   elf_flags_init (obfd) = TRUE;
4677
4678   /* Also copy the EI_OSABI field.  */
4679   elf_elfheader (obfd)->e_ident[EI_OSABI] =
4680     elf_elfheader (ibfd)->e_ident[EI_OSABI];
4681
4682   /* Copy EABI object attributes.  */
4683   copy_eabi_attributes (ibfd, obfd);
4684
4685   return TRUE;
4686 }
4687
4688 /* Values for Tag_ABI_PCS_R9_use.  */
4689 enum
4690 {
4691   AEABI_R9_V6,
4692   AEABI_R9_SB,
4693   AEABI_R9_TLS,
4694   AEABI_R9_unused
4695 };
4696
4697 /* Values for Tag_ABI_PCS_RW_data.  */
4698 enum
4699 {
4700   AEABI_PCS_RW_data_absolute,
4701   AEABI_PCS_RW_data_PCrel,
4702   AEABI_PCS_RW_data_SBrel,
4703   AEABI_PCS_RW_data_unused
4704 };
4705
4706 /* Values for Tag_ABI_enum_size.  */
4707 enum
4708 {
4709   AEABI_enum_unused,
4710   AEABI_enum_short,
4711   AEABI_enum_wide,
4712   AEABI_enum_forced_wide
4713 };
4714
4715 /* Merge EABI object attributes from IBFD into OBFD.  Raise an error if there
4716    are conflicting attributes.  */
4717 static bfd_boolean
4718 elf32_arm_merge_eabi_attributes (bfd *ibfd, bfd *obfd)
4719 {
4720   aeabi_attribute *in_attr;
4721   aeabi_attribute *out_attr;
4722   aeabi_attribute_list *in_list;
4723   aeabi_attribute_list *out_list;
4724   /* Some tags have 0 = don't care, 1 = strong requirement,
4725      2 = weak requirement.  */
4726   static const int order_312[3] = {3, 1, 2};
4727   int i;
4728
4729   if (!elf32_arm_tdata (ibfd)->known_eabi_attributes[0].i)
4730     {
4731       /* This is the first object.  Copy the attributes.  */
4732       copy_eabi_attributes (ibfd, obfd);
4733       return TRUE;
4734     }
4735
4736   /* Use the Tag_null value to indicate the attributes have been
4737      initialized.  */
4738   elf32_arm_tdata (ibfd)->known_eabi_attributes[0].i = 1;
4739
4740   in_attr = elf32_arm_tdata (ibfd)->known_eabi_attributes;
4741   out_attr = elf32_arm_tdata (obfd)->known_eabi_attributes;
4742   /* This needs to happen before Tag_ABI_FP_number_model is merged.  */
4743   if (in_attr[Tag_ABI_VFP_args].i != out_attr[Tag_ABI_VFP_args].i)
4744     {
4745       /* Ignore mismatches if teh object doesn't use floating point.  */
4746       if (out_attr[Tag_ABI_FP_number_model].i == 0)
4747         out_attr[Tag_ABI_VFP_args].i = in_attr[Tag_ABI_VFP_args].i;
4748       else if (in_attr[Tag_ABI_FP_number_model].i != 0)
4749         {
4750           _bfd_error_handler
4751             (_("ERROR: %B uses VFP register arguments, %B does not"),
4752              ibfd, obfd);
4753           return FALSE;
4754         }
4755     }
4756
4757   for (i = 4; i < NUM_KNOWN_ATTRIBUTES; i++)
4758     {
4759       /* Merge this attribute with existing attributes.  */
4760       switch (i)
4761         {
4762         case Tag_CPU_raw_name:
4763         case Tag_CPU_name:
4764           /* Use whichever has the greatest architecture requirements.  */
4765           if (in_attr[Tag_CPU_arch].i > out_attr[Tag_CPU_arch].i)
4766             out_attr[i].s = attr_strdup(obfd, in_attr[i].s);
4767           break;
4768
4769         case Tag_ABI_optimization_goals:
4770         case Tag_ABI_FP_optimization_goals:
4771           /* Use the first value seen.  */
4772           break;
4773
4774         case Tag_CPU_arch:
4775         case Tag_ARM_ISA_use:
4776         case Tag_THUMB_ISA_use:
4777         case Tag_VFP_arch:
4778         case Tag_WMMX_arch:
4779         case Tag_NEON_arch:
4780           /* ??? Do NEON and WMMX conflict?  */
4781         case Tag_ABI_FP_rounding:
4782         case Tag_ABI_FP_denormal:
4783         case Tag_ABI_FP_exceptions:
4784         case Tag_ABI_FP_user_exceptions:
4785         case Tag_ABI_FP_number_model:
4786         case Tag_ABI_align8_preserved:
4787         case Tag_ABI_HardFP_use:
4788           /* Use the largest value specified.  */
4789           if (in_attr[i].i > out_attr[i].i)
4790             out_attr[i].i = in_attr[i].i;
4791           break;
4792
4793         case Tag_CPU_arch_profile:
4794           /* Warn if conflicting architecture profiles used.  */
4795           if (out_attr[i].i && in_attr[i].i && in_attr[i].i != out_attr[i].i)
4796             {
4797               _bfd_error_handler
4798                 (_("ERROR: %B: Conflicting architecture profiles %c/%c"),
4799                  ibfd, in_attr[i].i, out_attr[i].i);
4800               return FALSE;
4801             }
4802           if (in_attr[i].i)
4803             out_attr[i].i = in_attr[i].i;
4804           break;
4805         case Tag_PCS_config:
4806           if (out_attr[i].i == 0)
4807             out_attr[i].i = in_attr[i].i;
4808           else if (in_attr[i].i != 0 && out_attr[i].i != 0)
4809             {
4810               /* It's sometimes ok to mix different configs, so this is only
4811                  a warning.  */
4812               _bfd_error_handler
4813                 (_("Warning: %B: Conflicting platform configuration"), ibfd);
4814             }
4815           break;
4816         case Tag_ABI_PCS_R9_use:
4817           if (out_attr[i].i != AEABI_R9_unused
4818               && in_attr[i].i != AEABI_R9_unused)
4819             {
4820               _bfd_error_handler
4821                 (_("ERROR: %B: Conflicting use of R9"), ibfd);
4822               return FALSE;
4823             }
4824           if (out_attr[i].i == AEABI_R9_unused)
4825             out_attr[i].i = in_attr[i].i;
4826           break;
4827         case Tag_ABI_PCS_RW_data:
4828           if (in_attr[i].i == AEABI_PCS_RW_data_SBrel
4829               && out_attr[Tag_ABI_PCS_R9_use].i != AEABI_R9_SB
4830               && out_attr[Tag_ABI_PCS_R9_use].i != AEABI_R9_unused)
4831             {
4832               _bfd_error_handler
4833                 (_("ERROR: %B: SB relative addressing conflicts with use of R9"),
4834                  ibfd);
4835               return FALSE;
4836             }
4837           /* Use the smallest value specified.  */
4838           if (in_attr[i].i < out_attr[i].i)
4839             out_attr[i].i = in_attr[i].i;
4840           break;
4841         case Tag_ABI_PCS_RO_data:
4842           /* Use the smallest value specified.  */
4843           if (in_attr[i].i < out_attr[i].i)
4844             out_attr[i].i = in_attr[i].i;
4845           break;
4846         case Tag_ABI_PCS_GOT_use:
4847           if (in_attr[i].i > 2 || out_attr[i].i > 2
4848               || order_312[in_attr[i].i] < order_312[out_attr[i].i])
4849             out_attr[i].i = in_attr[i].i;
4850           break;
4851         case Tag_ABI_PCS_wchar_t:
4852           if (out_attr[i].i && in_attr[i].i && out_attr[i].i != in_attr[i].i)
4853             {
4854               _bfd_error_handler
4855                 (_("ERROR: %B: Conflicting definitions of wchar_t"), ibfd);
4856               return FALSE;
4857             }
4858           if (in_attr[i].i)
4859             out_attr[i].i = in_attr[i].i;
4860           break;
4861         case Tag_ABI_align8_needed:
4862           /* ??? Check against Tag_ABI_align8_preserved.  */
4863           if (in_attr[i].i > 2 || out_attr[i].i > 2
4864               || order_312[in_attr[i].i] < order_312[out_attr[i].i])
4865             out_attr[i].i = in_attr[i].i;
4866           break;
4867         case Tag_ABI_enum_size:
4868           if (in_attr[i].i != AEABI_enum_unused)
4869             {
4870               if (out_attr[i].i == AEABI_enum_unused
4871                   || out_attr[i].i == AEABI_enum_forced_wide)
4872                 {
4873                   /* The existing object is compatible with anything.
4874                      Use whatever requirements the new object has.  */
4875                   out_attr[i].i = in_attr[i].i;
4876                 }
4877               else if (in_attr[i].i != AEABI_enum_forced_wide
4878                        && out_attr[i].i != in_attr[i].i)
4879                 {
4880                   _bfd_error_handler
4881                     (_("ERROR: %B: Conflicting enum sizes"), ibfd);
4882                 }
4883             }
4884           break;
4885         case Tag_ABI_VFP_args:
4886           /* Aready done.  */
4887           break;
4888         case Tag_ABI_WMMX_args:
4889           if (in_attr[i].i != out_attr[i].i)
4890             {
4891               _bfd_error_handler
4892                 (_("ERROR: %B uses iWMMXt register arguments, %B does not"),
4893                  ibfd, obfd);
4894               return FALSE;
4895             }
4896           break;
4897         default: /* All known attributes should be explicitly covered.   */
4898           abort ();
4899         }
4900     }
4901
4902   in_list = elf32_arm_tdata (ibfd)->other_eabi_attributes;
4903   out_list = elf32_arm_tdata (ibfd)->other_eabi_attributes;
4904   while (in_list && in_list->tag == Tag_compatibility)
4905     {
4906       in_attr = &in_list->attr;
4907       if (in_attr->i == 0)
4908         continue;
4909       if (in_attr->i == 1)
4910         {
4911           _bfd_error_handler
4912             (_("ERROR: %B: Must be processed by '%s' toolchain"),
4913              ibfd, in_attr->s);
4914           return FALSE;
4915         }
4916       if (!out_list || out_list->tag != Tag_compatibility
4917           || strcmp (in_attr->s, out_list->attr.s) != 0)
4918         {
4919           /* Add this compatibility tag to the output.  */
4920           elf32_arm_add_eabi_attr_compat (obfd, in_attr->i, in_attr->s);
4921           continue;
4922         }
4923       out_attr = &out_list->attr;
4924       /* Check all the input tags with the same identifier.  */
4925       for (;;)
4926         {
4927           if (out_list->tag != Tag_compatibility
4928               || in_attr->i != out_attr->i
4929               || strcmp (in_attr->s, out_attr->s) != 0)
4930             {
4931               _bfd_error_handler
4932                 (_("ERROR: %B: Incompatible object tag '%s':%d"),
4933                  ibfd, in_attr->s, in_attr->i);
4934               return FALSE;
4935             }
4936           in_list = in_list->next;
4937           if (in_list->tag != Tag_compatibility
4938               || strcmp (in_attr->s, in_list->attr.s) != 0)
4939             break;
4940           in_attr = &in_list->attr;
4941           out_list = out_list->next;
4942           if (out_list)
4943             out_attr = &out_list->attr;
4944         }
4945
4946       /* Check the output doesn't have extra tags with this identifier.  */
4947       if (out_list && out_list->tag == Tag_compatibility
4948           && strcmp (in_attr->s, out_list->attr.s) == 0)
4949         {
4950           _bfd_error_handler
4951             (_("ERROR: %B: Incompatible object tag '%s':%d"),
4952              ibfd, in_attr->s, out_list->attr.i);
4953           return FALSE;
4954         }
4955     }
4956
4957   for (; in_list; in_list = in_list->next)
4958     {
4959       if ((in_list->tag & 128) < 64)
4960         _bfd_error_handler
4961           (_("Warning: %B: Unknown EABI object attribute %d"),
4962            ibfd, in_list->tag);
4963       break;
4964     }
4965   return TRUE;
4966 }
4967
4968 /* Merge backend specific data from an object file to the output
4969    object file when linking.  */
4970
4971 static bfd_boolean
4972 elf32_arm_merge_private_bfd_data (bfd * ibfd, bfd * obfd)
4973 {
4974   flagword out_flags;
4975   flagword in_flags;
4976   bfd_boolean flags_compatible = TRUE;
4977   asection *sec;
4978
4979   /* Check if we have the same endianess.  */
4980   if (! _bfd_generic_verify_endian_match (ibfd, obfd))
4981     return FALSE;
4982
4983   if (   bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4984       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4985     return TRUE;
4986
4987   if (!elf32_arm_merge_eabi_attributes (ibfd, obfd))
4988     return FALSE;
4989
4990   /* The input BFD must have had its flags initialised.  */
4991   /* The following seems bogus to me -- The flags are initialized in
4992      the assembler but I don't think an elf_flags_init field is
4993      written into the object.  */
4994   /* BFD_ASSERT (elf_flags_init (ibfd)); */
4995
4996   in_flags  = elf_elfheader (ibfd)->e_flags;
4997   out_flags = elf_elfheader (obfd)->e_flags;
4998
4999   if (!elf_flags_init (obfd))
5000     {
5001       /* If the input is the default architecture and had the default
5002          flags then do not bother setting the flags for the output
5003          architecture, instead allow future merges to do this.  If no
5004          future merges ever set these flags then they will retain their
5005          uninitialised values, which surprise surprise, correspond
5006          to the default values.  */
5007       if (bfd_get_arch_info (ibfd)->the_default
5008           && elf_elfheader (ibfd)->e_flags == 0)
5009         return TRUE;
5010
5011       elf_flags_init (obfd) = TRUE;
5012       elf_elfheader (obfd)->e_flags = in_flags;
5013
5014       if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
5015           && bfd_get_arch_info (obfd)->the_default)
5016         return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
5017
5018       return TRUE;
5019     }
5020
5021   /* Determine what should happen if the input ARM architecture
5022      does not match the output ARM architecture.  */
5023   if (! bfd_arm_merge_machines (ibfd, obfd))
5024     return FALSE;
5025
5026   /* Identical flags must be compatible.  */
5027   if (in_flags == out_flags)
5028     return TRUE;
5029
5030   /* Check to see if the input BFD actually contains any sections.  If
5031      not, its flags may not have been initialised either, but it
5032      cannot actually cause any incompatiblity.  Do not short-circuit
5033      dynamic objects; their section list may be emptied by
5034     elf_link_add_object_symbols.
5035
5036     Also check to see if there are no code sections in the input.
5037     In this case there is no need to check for code specific flags.
5038     XXX - do we need to worry about floating-point format compatability
5039     in data sections ?  */
5040   if (!(ibfd->flags & DYNAMIC))
5041     {
5042       bfd_boolean null_input_bfd = TRUE;
5043       bfd_boolean only_data_sections = TRUE;
5044
5045       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
5046         {
5047           /* Ignore synthetic glue sections.  */
5048           if (strcmp (sec->name, ".glue_7")
5049               && strcmp (sec->name, ".glue_7t"))
5050             {
5051               if ((bfd_get_section_flags (ibfd, sec)
5052                    & (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS))
5053                   == (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS))
5054                 only_data_sections = FALSE;
5055
5056               null_input_bfd = FALSE;
5057               break;
5058             }
5059         }
5060
5061       if (null_input_bfd || only_data_sections)
5062         return TRUE;
5063     }
5064
5065   /* Complain about various flag mismatches.  */
5066   if (EF_ARM_EABI_VERSION (in_flags) != EF_ARM_EABI_VERSION (out_flags))
5067     {
5068       _bfd_error_handler
5069         (_("ERROR: Source object %B has EABI version %d, but target %B has EABI version %d"),
5070          ibfd, obfd,
5071          (in_flags & EF_ARM_EABIMASK) >> 24,
5072          (out_flags & EF_ARM_EABIMASK) >> 24);
5073       return FALSE;
5074     }
5075
5076   /* Not sure what needs to be checked for EABI versions >= 1.  */
5077   if (EF_ARM_EABI_VERSION (in_flags) == EF_ARM_EABI_UNKNOWN)
5078     {
5079       if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
5080         {
5081           _bfd_error_handler
5082             (_("ERROR: %B is compiled for APCS-%d, whereas target %B uses APCS-%d"),
5083              ibfd, obfd,
5084              in_flags & EF_ARM_APCS_26 ? 26 : 32,
5085              out_flags & EF_ARM_APCS_26 ? 26 : 32);
5086           flags_compatible = FALSE;
5087         }
5088
5089       if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
5090         {
5091           if (in_flags & EF_ARM_APCS_FLOAT)
5092             _bfd_error_handler
5093               (_("ERROR: %B passes floats in float registers, whereas %B passes them in integer registers"),
5094                ibfd, obfd);
5095           else
5096             _bfd_error_handler
5097               (_("ERROR: %B passes floats in integer registers, whereas %B passes them in float registers"),
5098                ibfd, obfd);
5099
5100           flags_compatible = FALSE;
5101         }
5102
5103       if ((in_flags & EF_ARM_VFP_FLOAT) != (out_flags & EF_ARM_VFP_FLOAT))
5104         {
5105           if (in_flags & EF_ARM_VFP_FLOAT)
5106             _bfd_error_handler
5107               (_("ERROR: %B uses VFP instructions, whereas %B does not"),
5108                ibfd, obfd);
5109           else
5110             _bfd_error_handler
5111               (_("ERROR: %B uses FPA instructions, whereas %B does not"),
5112                ibfd, obfd);
5113
5114           flags_compatible = FALSE;
5115         }
5116
5117       if ((in_flags & EF_ARM_MAVERICK_FLOAT) != (out_flags & EF_ARM_MAVERICK_FLOAT))
5118         {
5119           if (in_flags & EF_ARM_MAVERICK_FLOAT)
5120             _bfd_error_handler
5121               (_("ERROR: %B uses Maverick instructions, whereas %B does not"),
5122                ibfd, obfd);
5123           else
5124             _bfd_error_handler
5125               (_("ERROR: %B does not use Maverick instructions, whereas %B does"),
5126                ibfd, obfd);
5127
5128           flags_compatible = FALSE;
5129         }
5130
5131 #ifdef EF_ARM_SOFT_FLOAT
5132       if ((in_flags & EF_ARM_SOFT_FLOAT) != (out_flags & EF_ARM_SOFT_FLOAT))
5133         {
5134           /* We can allow interworking between code that is VFP format
5135              layout, and uses either soft float or integer regs for
5136              passing floating point arguments and results.  We already
5137              know that the APCS_FLOAT flags match; similarly for VFP
5138              flags.  */
5139           if ((in_flags & EF_ARM_APCS_FLOAT) != 0
5140               || (in_flags & EF_ARM_VFP_FLOAT) == 0)
5141             {
5142               if (in_flags & EF_ARM_SOFT_FLOAT)
5143                 _bfd_error_handler
5144                   (_("ERROR: %B uses software FP, whereas %B uses hardware FP"),
5145                    ibfd, obfd);
5146               else
5147                 _bfd_error_handler
5148                   (_("ERROR: %B uses hardware FP, whereas %B uses software FP"),
5149                    ibfd, obfd);
5150
5151               flags_compatible = FALSE;
5152             }
5153         }
5154 #endif
5155
5156       /* Interworking mismatch is only a warning.  */
5157       if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
5158         {
5159           if (in_flags & EF_ARM_INTERWORK)
5160             {
5161               _bfd_error_handler
5162                 (_("Warning: %B supports interworking, whereas %B does not"),
5163                  ibfd, obfd);
5164             }
5165           else
5166             {
5167               _bfd_error_handler
5168                 (_("Warning: %B does not support interworking, whereas %B does"),
5169                  ibfd, obfd);
5170             }
5171         }
5172     }
5173
5174   return flags_compatible;
5175 }
5176
5177 /* Display the flags field.  */
5178
5179 static bfd_boolean
5180 elf32_arm_print_private_bfd_data (bfd *abfd, void * ptr)
5181 {
5182   FILE * file = (FILE *) ptr;
5183   unsigned long flags;
5184
5185   BFD_ASSERT (abfd != NULL && ptr != NULL);
5186
5187   /* Print normal ELF private data.  */
5188   _bfd_elf_print_private_bfd_data (abfd, ptr);
5189
5190   flags = elf_elfheader (abfd)->e_flags;
5191   /* Ignore init flag - it may not be set, despite the flags field
5192      containing valid data.  */
5193
5194   /* xgettext:c-format */
5195   fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
5196
5197   switch (EF_ARM_EABI_VERSION (flags))
5198     {
5199     case EF_ARM_EABI_UNKNOWN:
5200       /* The following flag bits are GNU extensions and not part of the
5201          official ARM ELF extended ABI.  Hence they are only decoded if
5202          the EABI version is not set.  */
5203       if (flags & EF_ARM_INTERWORK)
5204         fprintf (file, _(" [interworking enabled]"));
5205
5206       if (flags & EF_ARM_APCS_26)
5207         fprintf (file, " [APCS-26]");
5208       else
5209         fprintf (file, " [APCS-32]");
5210
5211       if (flags & EF_ARM_VFP_FLOAT)
5212         fprintf (file, _(" [VFP float format]"));
5213       else if (flags & EF_ARM_MAVERICK_FLOAT)
5214         fprintf (file, _(" [Maverick float format]"));
5215       else
5216         fprintf (file, _(" [FPA float format]"));
5217
5218       if (flags & EF_ARM_APCS_FLOAT)
5219         fprintf (file, _(" [floats passed in float registers]"));
5220
5221       if (flags & EF_ARM_PIC)
5222         fprintf (file, _(" [position independent]"));
5223
5224       if (flags & EF_ARM_NEW_ABI)
5225         fprintf (file, _(" [new ABI]"));
5226
5227       if (flags & EF_ARM_OLD_ABI)
5228         fprintf (file, _(" [old ABI]"));
5229
5230       if (flags & EF_ARM_SOFT_FLOAT)
5231         fprintf (file, _(" [software FP]"));
5232
5233       flags &= ~(EF_ARM_INTERWORK | EF_ARM_APCS_26 | EF_ARM_APCS_FLOAT
5234                  | EF_ARM_PIC | EF_ARM_NEW_ABI | EF_ARM_OLD_ABI
5235                  | EF_ARM_SOFT_FLOAT | EF_ARM_VFP_FLOAT
5236                  | EF_ARM_MAVERICK_FLOAT);
5237       break;
5238
5239     case EF_ARM_EABI_VER1:
5240       fprintf (file, _(" [Version1 EABI]"));
5241
5242       if (flags & EF_ARM_SYMSARESORTED)
5243         fprintf (file, _(" [sorted symbol table]"));
5244       else
5245         fprintf (file, _(" [unsorted symbol table]"));
5246
5247       flags &= ~ EF_ARM_SYMSARESORTED;
5248       break;
5249
5250     case EF_ARM_EABI_VER2:
5251       fprintf (file, _(" [Version2 EABI]"));
5252
5253       if (flags & EF_ARM_SYMSARESORTED)
5254         fprintf (file, _(" [sorted symbol table]"));
5255       else
5256         fprintf (file, _(" [unsorted symbol table]"));
5257
5258       if (flags & EF_ARM_DYNSYMSUSESEGIDX)
5259         fprintf (file, _(" [dynamic symbols use segment index]"));
5260
5261       if (flags & EF_ARM_MAPSYMSFIRST)
5262         fprintf (file, _(" [mapping symbols precede others]"));
5263
5264       flags &= ~(EF_ARM_SYMSARESORTED | EF_ARM_DYNSYMSUSESEGIDX
5265                  | EF_ARM_MAPSYMSFIRST);
5266       break;
5267
5268     case EF_ARM_EABI_VER3:
5269       fprintf (file, _(" [Version3 EABI]"));
5270       break;
5271
5272     case EF_ARM_EABI_VER4:
5273       fprintf (file, _(" [Version4 EABI]"));
5274
5275       if (flags & EF_ARM_BE8)
5276         fprintf (file, _(" [BE8]"));
5277
5278       if (flags & EF_ARM_LE8)
5279         fprintf (file, _(" [LE8]"));
5280
5281       flags &= ~(EF_ARM_LE8 | EF_ARM_BE8);
5282       break;
5283
5284     default:
5285       fprintf (file, _(" <EABI version unrecognised>"));
5286       break;
5287     }
5288
5289   flags &= ~ EF_ARM_EABIMASK;
5290
5291   if (flags & EF_ARM_RELEXEC)
5292     fprintf (file, _(" [relocatable executable]"));
5293
5294   if (flags & EF_ARM_HASENTRY)
5295     fprintf (file, _(" [has entry point]"));
5296
5297   flags &= ~ (EF_ARM_RELEXEC | EF_ARM_HASENTRY);
5298
5299   if (flags)
5300     fprintf (file, _("<Unrecognised flag bits set>"));
5301
5302   fputc ('\n', file);
5303
5304   return TRUE;
5305 }
5306
5307 static int
5308 elf32_arm_get_symbol_type (Elf_Internal_Sym * elf_sym, int type)
5309 {
5310   switch (ELF_ST_TYPE (elf_sym->st_info))
5311     {
5312     case STT_ARM_TFUNC:
5313       return ELF_ST_TYPE (elf_sym->st_info);
5314
5315     case STT_ARM_16BIT:
5316       /* If the symbol is not an object, return the STT_ARM_16BIT flag.
5317          This allows us to distinguish between data used by Thumb instructions
5318          and non-data (which is probably code) inside Thumb regions of an
5319          executable.  */
5320       if (type != STT_OBJECT)
5321         return ELF_ST_TYPE (elf_sym->st_info);
5322       break;
5323
5324     default:
5325       break;
5326     }
5327
5328   return type;
5329 }
5330
5331 static asection *
5332 elf32_arm_gc_mark_hook (asection *                   sec,
5333                         struct bfd_link_info *       info ATTRIBUTE_UNUSED,
5334                         Elf_Internal_Rela *          rel,
5335                         struct elf_link_hash_entry * h,
5336                         Elf_Internal_Sym *           sym)
5337 {
5338   if (h != NULL)
5339     {
5340       switch (ELF32_R_TYPE (rel->r_info))
5341       {
5342       case R_ARM_GNU_VTINHERIT:
5343       case R_ARM_GNU_VTENTRY:
5344         break;
5345
5346       default:
5347         switch (h->root.type)
5348           {
5349           case bfd_link_hash_defined:
5350           case bfd_link_hash_defweak:
5351             return h->root.u.def.section;
5352
5353           case bfd_link_hash_common:
5354             return h->root.u.c.p->section;
5355
5356           default:
5357             break;
5358           }
5359        }
5360      }
5361    else
5362      return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
5363
5364   return NULL;
5365 }
5366
5367 /* Update the got entry reference counts for the section being removed.  */
5368
5369 static bfd_boolean
5370 elf32_arm_gc_sweep_hook (bfd *                     abfd,
5371                          struct bfd_link_info *    info,
5372                          asection *                sec,
5373                          const Elf_Internal_Rela * relocs)
5374 {
5375   Elf_Internal_Shdr *symtab_hdr;
5376   struct elf_link_hash_entry **sym_hashes;
5377   bfd_signed_vma *local_got_refcounts;
5378   const Elf_Internal_Rela *rel, *relend;
5379   struct elf32_arm_link_hash_table * globals;
5380
5381   globals = elf32_arm_hash_table (info);
5382
5383   elf_section_data (sec)->local_dynrel = NULL;
5384
5385   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5386   sym_hashes = elf_sym_hashes (abfd);
5387   local_got_refcounts = elf_local_got_refcounts (abfd);
5388
5389   relend = relocs + sec->reloc_count;
5390   for (rel = relocs; rel < relend; rel++)
5391     {
5392       unsigned long r_symndx;
5393       struct elf_link_hash_entry *h = NULL;
5394       int r_type;
5395
5396       r_symndx = ELF32_R_SYM (rel->r_info);
5397       if (r_symndx >= symtab_hdr->sh_info)
5398         {
5399           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5400           while (h->root.type == bfd_link_hash_indirect
5401                  || h->root.type == bfd_link_hash_warning)
5402             h = (struct elf_link_hash_entry *) h->root.u.i.link;
5403         }
5404
5405       r_type = ELF32_R_TYPE (rel->r_info);
5406       r_type = arm_real_reloc_type (globals, r_type);
5407       switch (r_type)
5408         {
5409         case R_ARM_GOT32:
5410         case R_ARM_GOT_PREL:
5411         case R_ARM_TLS_GD32:
5412         case R_ARM_TLS_IE32:
5413           if (h != NULL)
5414             {
5415               if (h->got.refcount > 0)
5416                 h->got.refcount -= 1;
5417             }
5418           else if (local_got_refcounts != NULL)
5419             {
5420               if (local_got_refcounts[r_symndx] > 0)
5421                 local_got_refcounts[r_symndx] -= 1;
5422             }
5423           break;
5424
5425         case R_ARM_TLS_LDM32:
5426           elf32_arm_hash_table (info)->tls_ldm_got.refcount -= 1;
5427           break;
5428
5429         case R_ARM_ABS32:
5430         case R_ARM_REL32:
5431         case R_ARM_PC24:
5432         case R_ARM_PLT32:
5433         case R_ARM_CALL:
5434         case R_ARM_JUMP24:
5435         case R_ARM_PREL31:
5436         case R_ARM_THM_CALL:
5437           /* Should the interworking branches be here also?  */
5438
5439           if (h != NULL)
5440             {
5441               struct elf32_arm_link_hash_entry *eh;
5442               struct elf32_arm_relocs_copied **pp;
5443               struct elf32_arm_relocs_copied *p;
5444
5445               eh = (struct elf32_arm_link_hash_entry *) h;
5446
5447               if (h->plt.refcount > 0)
5448                 {
5449                   h->plt.refcount -= 1;
5450                   if (ELF32_R_TYPE (rel->r_info) == R_ARM_THM_CALL)
5451                     eh->plt_thumb_refcount--;
5452                 }
5453
5454               if (r_type == R_ARM_ABS32
5455                   || r_type == R_ARM_REL32)
5456                 {
5457                   for (pp = &eh->relocs_copied; (p = *pp) != NULL;
5458                        pp = &p->next)
5459                   if (p->section == sec)
5460                     {
5461                       p->count -= 1;
5462                       if (ELF32_R_TYPE (rel->r_info) == R_ARM_REL32)
5463                         p->pc_count -= 1;
5464                       if (p->count == 0)
5465                         *pp = p->next;
5466                       break;
5467                     }
5468                 }
5469             }
5470           break;
5471
5472         default:
5473           break;
5474         }
5475     }
5476
5477   return TRUE;
5478 }
5479
5480 /* Look through the relocs for a section during the first phase.  */
5481
5482 static bfd_boolean
5483 elf32_arm_check_relocs (bfd *abfd, struct bfd_link_info *info,
5484                         asection *sec, const Elf_Internal_Rela *relocs)
5485 {
5486   Elf_Internal_Shdr *symtab_hdr;
5487   struct elf_link_hash_entry **sym_hashes;
5488   struct elf_link_hash_entry **sym_hashes_end;
5489   const Elf_Internal_Rela *rel;
5490   const Elf_Internal_Rela *rel_end;
5491   bfd *dynobj;
5492   asection *sreloc;
5493   bfd_vma *local_got_offsets;
5494   struct elf32_arm_link_hash_table *htab;
5495
5496   if (info->relocatable)
5497     return TRUE;
5498
5499   htab = elf32_arm_hash_table (info);
5500   sreloc = NULL;
5501
5502   /* Create dynamic sections for relocatable executables so that we can
5503      copy relocations.  */
5504   if (htab->root.is_relocatable_executable
5505       && ! htab->root.dynamic_sections_created)
5506     {
5507       if (! _bfd_elf_link_create_dynamic_sections (abfd, info))
5508         return FALSE;
5509     }
5510
5511   dynobj = elf_hash_table (info)->dynobj;
5512   local_got_offsets = elf_local_got_offsets (abfd);
5513
5514   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5515   sym_hashes = elf_sym_hashes (abfd);
5516   sym_hashes_end = sym_hashes
5517     + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
5518
5519   if (!elf_bad_symtab (abfd))
5520     sym_hashes_end -= symtab_hdr->sh_info;
5521
5522   rel_end = relocs + sec->reloc_count;
5523   for (rel = relocs; rel < rel_end; rel++)
5524     {
5525       struct elf_link_hash_entry *h;
5526       struct elf32_arm_link_hash_entry *eh;
5527       unsigned long r_symndx;
5528       int r_type;
5529
5530       r_symndx = ELF32_R_SYM (rel->r_info);
5531       r_type = ELF32_R_TYPE (rel->r_info);
5532       r_type = arm_real_reloc_type (htab, r_type);
5533
5534       if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
5535         {
5536           (*_bfd_error_handler) (_("%B: bad symbol index: %d"), abfd,
5537                                  r_symndx);
5538           return FALSE;
5539         }
5540
5541       if (r_symndx < symtab_hdr->sh_info)
5542         h = NULL;
5543       else
5544         {
5545           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5546           while (h->root.type == bfd_link_hash_indirect
5547                  || h->root.type == bfd_link_hash_warning)
5548             h = (struct elf_link_hash_entry *) h->root.u.i.link;
5549         }
5550
5551       eh = (struct elf32_arm_link_hash_entry *) h;
5552
5553       switch (r_type)
5554         {
5555           case R_ARM_GOT32:
5556           case R_ARM_GOT_PREL:
5557           case R_ARM_TLS_GD32:
5558           case R_ARM_TLS_IE32:
5559             /* This symbol requires a global offset table entry.  */
5560             {
5561               int tls_type, old_tls_type;
5562
5563               switch (r_type)
5564                 {
5565                 case R_ARM_TLS_GD32: tls_type = GOT_TLS_GD; break;
5566                 case R_ARM_TLS_IE32: tls_type = GOT_TLS_IE; break;
5567                 default: tls_type = GOT_NORMAL; break;
5568                 }
5569
5570               if (h != NULL)
5571                 {
5572                   h->got.refcount++;
5573                   old_tls_type = elf32_arm_hash_entry (h)->tls_type;
5574                 }
5575               else
5576                 {
5577                   bfd_signed_vma *local_got_refcounts;
5578
5579                   /* This is a global offset table entry for a local symbol.  */
5580                   local_got_refcounts = elf_local_got_refcounts (abfd);
5581                   if (local_got_refcounts == NULL)
5582                     {
5583                       bfd_size_type size;
5584
5585                       size = symtab_hdr->sh_info;
5586                       size *= (sizeof (bfd_signed_vma) + sizeof(char));
5587                       local_got_refcounts = bfd_zalloc (abfd, size);
5588                       if (local_got_refcounts == NULL)
5589                         return FALSE;
5590                       elf_local_got_refcounts (abfd) = local_got_refcounts;
5591                       elf32_arm_local_got_tls_type (abfd)
5592                         = (char *) (local_got_refcounts + symtab_hdr->sh_info);
5593                     }
5594                   local_got_refcounts[r_symndx] += 1;
5595                   old_tls_type = elf32_arm_local_got_tls_type (abfd) [r_symndx];
5596                 }
5597
5598               /* We will already have issued an error message if there is a
5599                  TLS / non-TLS mismatch, based on the symbol type.  We don't
5600                  support any linker relaxations.  So just combine any TLS
5601                  types needed.  */
5602               if (old_tls_type != GOT_UNKNOWN && old_tls_type != GOT_NORMAL
5603                   && tls_type != GOT_NORMAL)
5604                 tls_type |= old_tls_type;
5605
5606               if (old_tls_type != tls_type)
5607                 {
5608                   if (h != NULL)
5609                     elf32_arm_hash_entry (h)->tls_type = tls_type;
5610                   else
5611                     elf32_arm_local_got_tls_type (abfd) [r_symndx] = tls_type;
5612                 }
5613             }
5614             /* Fall through */
5615
5616           case R_ARM_TLS_LDM32:
5617             if (r_type == R_ARM_TLS_LDM32)
5618                 htab->tls_ldm_got.refcount++;
5619             /* Fall through */
5620
5621           case R_ARM_GOTOFF32:
5622           case R_ARM_GOTPC:
5623             if (htab->sgot == NULL)
5624               {
5625                 if (htab->root.dynobj == NULL)
5626                   htab->root.dynobj = abfd;
5627                 if (!create_got_section (htab->root.dynobj, info))
5628                   return FALSE;
5629               }
5630             break;
5631
5632           case R_ARM_ABS32:
5633           case R_ARM_REL32:
5634           case R_ARM_PC24:
5635           case R_ARM_PLT32:
5636           case R_ARM_CALL:
5637           case R_ARM_JUMP24:
5638           case R_ARM_PREL31:
5639           case R_ARM_THM_CALL:
5640             /* Should the interworking branches be listed here?  */
5641             if (h != NULL)
5642               {
5643                 /* If this reloc is in a read-only section, we might
5644                    need a copy reloc.  We can't check reliably at this
5645                    stage whether the section is read-only, as input
5646                    sections have not yet been mapped to output sections.
5647                    Tentatively set the flag for now, and correct in
5648                    adjust_dynamic_symbol.  */
5649                 if (!info->shared)
5650                   h->non_got_ref = 1;
5651
5652                 /* We may need a .plt entry if the function this reloc
5653                    refers to is in a different object.  We can't tell for
5654                    sure yet, because something later might force the
5655                    symbol local.  */
5656                 if (r_type == R_ARM_PC24
5657                     || r_type == R_ARM_CALL
5658                     || r_type == R_ARM_JUMP24
5659                     || r_type == R_ARM_PREL31
5660                     || r_type == R_ARM_PLT32
5661                     || r_type == R_ARM_THM_CALL)
5662                   h->needs_plt = 1;
5663
5664                 /* If we create a PLT entry, this relocation will reference
5665                    it, even if it's an ABS32 relocation.  */
5666                 h->plt.refcount += 1;
5667
5668                 if (r_type == R_ARM_THM_CALL)
5669                   eh->plt_thumb_refcount += 1;
5670               }
5671
5672             /* If we are creating a shared library or relocatable executable,
5673                and this is a reloc against a global symbol, or a non PC
5674                relative reloc against a local symbol, then we need to copy
5675                the reloc into the shared library.  However, if we are linking
5676                with -Bsymbolic, we do not need to copy a reloc against a
5677                global symbol which is defined in an object we are
5678                including in the link (i.e., DEF_REGULAR is set).  At
5679                this point we have not seen all the input files, so it is
5680                possible that DEF_REGULAR is not set now but will be set
5681                later (it is never cleared).  We account for that
5682                possibility below by storing information in the
5683                relocs_copied field of the hash table entry.  */
5684             if ((info->shared || htab->root.is_relocatable_executable)
5685                 && (sec->flags & SEC_ALLOC) != 0
5686                 && (r_type == R_ARM_ABS32
5687                     || (h != NULL && ! h->needs_plt
5688                         && (! info->symbolic || ! h->def_regular))))
5689               {
5690                 struct elf32_arm_relocs_copied *p, **head;
5691
5692                 /* When creating a shared object, we must copy these
5693                    reloc types into the output file.  We create a reloc
5694                    section in dynobj and make room for this reloc.  */
5695                 if (sreloc == NULL)
5696                   {
5697                     const char * name;
5698
5699                     name = (bfd_elf_string_from_elf_section
5700                             (abfd,
5701                              elf_elfheader (abfd)->e_shstrndx,
5702                              elf_section_data (sec)->rel_hdr.sh_name));
5703                     if (name == NULL)
5704                       return FALSE;
5705
5706                     BFD_ASSERT (strncmp (name, ".rel", 4) == 0
5707                                 && strcmp (bfd_get_section_name (abfd, sec),
5708                                            name + 4) == 0);
5709
5710                     sreloc = bfd_get_section_by_name (dynobj, name);
5711                     if (sreloc == NULL)
5712                       {
5713                         flagword flags;
5714
5715                         flags = (SEC_HAS_CONTENTS | SEC_READONLY
5716                                  | SEC_IN_MEMORY | SEC_LINKER_CREATED);
5717                         if ((sec->flags & SEC_ALLOC) != 0
5718                             /* BPABI objects never have dynamic
5719                                relocations mapped.  */
5720                             && !htab->symbian_p)
5721                           flags |= SEC_ALLOC | SEC_LOAD;
5722                         sreloc = bfd_make_section_with_flags (dynobj,
5723                                                               name,
5724                                                               flags);
5725                         if (sreloc == NULL
5726                             || ! bfd_set_section_alignment (dynobj, sreloc, 2))
5727                           return FALSE;
5728                       }
5729
5730                     elf_section_data (sec)->sreloc = sreloc;
5731                   }
5732
5733                 /* If this is a global symbol, we count the number of
5734                    relocations we need for this symbol.  */
5735                 if (h != NULL)
5736                   {
5737                     head = &((struct elf32_arm_link_hash_entry *) h)->relocs_copied;
5738                   }
5739                 else
5740                   {
5741                     /* Track dynamic relocs needed for local syms too.
5742                        We really need local syms available to do this
5743                        easily.  Oh well.  */
5744
5745                     asection *s;
5746                     void *vpp;
5747
5748                     s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
5749                                                    sec, r_symndx);
5750                     if (s == NULL)
5751                       return FALSE;
5752
5753                     vpp = &elf_section_data (s)->local_dynrel;
5754                     head = (struct elf32_arm_relocs_copied **) vpp;
5755                   }
5756
5757                 p = *head;
5758                 if (p == NULL || p->section != sec)
5759                   {
5760                     bfd_size_type amt = sizeof *p;
5761
5762                     p = bfd_alloc (htab->root.dynobj, amt);
5763                     if (p == NULL)
5764                       return FALSE;
5765                     p->next = *head;
5766                     *head = p;
5767                     p->section = sec;
5768                     p->count = 0;
5769                     p->pc_count = 0;
5770                   }
5771
5772                 if (r_type == R_ARM_REL32)
5773                   p->pc_count += 1;
5774                 p->count += 1;
5775               }
5776             break;
5777
5778         /* This relocation describes the C++ object vtable hierarchy.
5779            Reconstruct it for later use during GC.  */
5780         case R_ARM_GNU_VTINHERIT:
5781           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
5782             return FALSE;
5783           break;
5784
5785         /* This relocation describes which C++ vtable entries are actually
5786            used.  Record for later use during GC.  */
5787         case R_ARM_GNU_VTENTRY:
5788           if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
5789             return FALSE;
5790           break;
5791         }
5792     }
5793
5794   return TRUE;
5795 }
5796
5797 /* Treat mapping symbols as special target symbols.  */
5798
5799 static bfd_boolean
5800 elf32_arm_is_target_special_symbol (bfd * abfd ATTRIBUTE_UNUSED, asymbol * sym)
5801 {
5802   return bfd_is_arm_mapping_symbol_name (sym->name);
5803 }
5804
5805 /* This is a copy of elf_find_function() from elf.c except that
5806    ARM mapping symbols are ignored when looking for function names
5807    and STT_ARM_TFUNC is considered to a function type.  */
5808
5809 static bfd_boolean
5810 arm_elf_find_function (bfd *         abfd ATTRIBUTE_UNUSED,
5811                        asection *    section,
5812                        asymbol **    symbols,
5813                        bfd_vma       offset,
5814                        const char ** filename_ptr,
5815                        const char ** functionname_ptr)
5816 {
5817   const char * filename = NULL;
5818   asymbol * func = NULL;
5819   bfd_vma low_func = 0;
5820   asymbol ** p;
5821
5822   for (p = symbols; *p != NULL; p++)
5823     {
5824       elf_symbol_type *q;
5825
5826       q = (elf_symbol_type *) *p;
5827
5828       switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
5829         {
5830         default:
5831           break;
5832         case STT_FILE:
5833           filename = bfd_asymbol_name (&q->symbol);
5834           break;
5835         case STT_FUNC:
5836         case STT_ARM_TFUNC:
5837         case STT_NOTYPE:
5838           /* Skip $a and $t symbols.  */
5839           if ((q->symbol.flags & BSF_LOCAL)
5840               && bfd_is_arm_mapping_symbol_name (q->symbol.name))
5841             continue;
5842           /* Fall through.  */
5843           if (bfd_get_section (&q->symbol) == section
5844               && q->symbol.value >= low_func
5845               && q->symbol.value <= offset)
5846             {
5847               func = (asymbol *) q;
5848               low_func = q->symbol.value;
5849             }
5850           break;
5851         }
5852     }
5853
5854   if (func == NULL)
5855     return FALSE;
5856
5857   if (filename_ptr)
5858     *filename_ptr = filename;
5859   if (functionname_ptr)
5860     *functionname_ptr = bfd_asymbol_name (func);
5861
5862   return TRUE;
5863 }
5864
5865
5866 /* Find the nearest line to a particular section and offset, for error
5867    reporting.   This code is a duplicate of the code in elf.c, except
5868    that it uses arm_elf_find_function.  */
5869
5870 static bfd_boolean
5871 elf32_arm_find_nearest_line (bfd *          abfd,
5872                              asection *     section,
5873                              asymbol **     symbols,
5874                              bfd_vma        offset,
5875                              const char **  filename_ptr,
5876                              const char **  functionname_ptr,
5877                              unsigned int * line_ptr)
5878 {
5879   bfd_boolean found = FALSE;
5880
5881   /* We skip _bfd_dwarf1_find_nearest_line since no known ARM toolchain uses it.  */
5882
5883   if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
5884                                      filename_ptr, functionname_ptr,
5885                                      line_ptr, 0,
5886                                      & elf_tdata (abfd)->dwarf2_find_line_info))
5887     {
5888       if (!*functionname_ptr)
5889         arm_elf_find_function (abfd, section, symbols, offset,
5890                                *filename_ptr ? NULL : filename_ptr,
5891                                functionname_ptr);
5892
5893       return TRUE;
5894     }
5895
5896   if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
5897                                              & found, filename_ptr,
5898                                              functionname_ptr, line_ptr,
5899                                              & elf_tdata (abfd)->line_info))
5900     return FALSE;
5901
5902   if (found && (*functionname_ptr || *line_ptr))
5903     return TRUE;
5904
5905   if (symbols == NULL)
5906     return FALSE;
5907
5908   if (! arm_elf_find_function (abfd, section, symbols, offset,
5909                                filename_ptr, functionname_ptr))
5910     return FALSE;
5911
5912   *line_ptr = 0;
5913   return TRUE;
5914 }
5915
5916 static bfd_boolean
5917 elf32_arm_find_inliner_info (bfd *          abfd,
5918                              const char **  filename_ptr,
5919                              const char **  functionname_ptr,
5920                              unsigned int * line_ptr)
5921 {
5922   bfd_boolean found;
5923   found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
5924                                          functionname_ptr, line_ptr,
5925                                          & elf_tdata (abfd)->dwarf2_find_line_info);
5926   return found;
5927 }
5928
5929 /* Adjust a symbol defined by a dynamic object and referenced by a
5930    regular object.  The current definition is in some section of the
5931    dynamic object, but we're not including those sections.  We have to
5932    change the definition to something the rest of the link can
5933    understand.  */
5934
5935 static bfd_boolean
5936 elf32_arm_adjust_dynamic_symbol (struct bfd_link_info * info,
5937                                  struct elf_link_hash_entry * h)
5938 {
5939   bfd * dynobj;
5940   asection * s;
5941   unsigned int power_of_two;
5942   struct elf32_arm_link_hash_entry * eh;
5943   struct elf32_arm_link_hash_table *globals;
5944
5945   globals = elf32_arm_hash_table (info);
5946   dynobj = elf_hash_table (info)->dynobj;
5947
5948   /* Make sure we know what is going on here.  */
5949   BFD_ASSERT (dynobj != NULL
5950               && (h->needs_plt
5951                   || h->u.weakdef != NULL
5952                   || (h->def_dynamic
5953                       && h->ref_regular
5954                       && !h->def_regular)));
5955
5956   eh = (struct elf32_arm_link_hash_entry *) h;
5957
5958   /* If this is a function, put it in the procedure linkage table.  We
5959      will fill in the contents of the procedure linkage table later,
5960      when we know the address of the .got section.  */
5961   if (h->type == STT_FUNC || h->type == STT_ARM_TFUNC
5962       || h->needs_plt)
5963     {
5964       if (h->plt.refcount <= 0
5965           || SYMBOL_CALLS_LOCAL (info, h)
5966           || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
5967               && h->root.type == bfd_link_hash_undefweak))
5968         {
5969           /* This case can occur if we saw a PLT32 reloc in an input
5970              file, but the symbol was never referred to by a dynamic
5971              object, or if all references were garbage collected.  In
5972              such a case, we don't actually need to build a procedure
5973              linkage table, and we can just do a PC24 reloc instead.  */
5974           h->plt.offset = (bfd_vma) -1;
5975           eh->plt_thumb_refcount = 0;
5976           h->needs_plt = 0;
5977         }
5978
5979       return TRUE;
5980     }
5981   else
5982     {
5983       /* It's possible that we incorrectly decided a .plt reloc was
5984          needed for an R_ARM_PC24 or similar reloc to a non-function sym
5985          in check_relocs.  We can't decide accurately between function
5986          and non-function syms in check-relocs; Objects loaded later in
5987          the link may change h->type.  So fix it now.  */
5988       h->plt.offset = (bfd_vma) -1;
5989       eh->plt_thumb_refcount = 0;
5990     }
5991
5992   /* If this is a weak symbol, and there is a real definition, the
5993      processor independent code will have arranged for us to see the
5994      real definition first, and we can just use the same value.  */
5995   if (h->u.weakdef != NULL)
5996     {
5997       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
5998                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
5999       h->root.u.def.section = h->u.weakdef->root.u.def.section;
6000       h->root.u.def.value = h->u.weakdef->root.u.def.value;
6001       return TRUE;
6002     }
6003
6004   /* If there are no non-GOT references, we do not need a copy
6005      relocation.  */
6006   if (!h->non_got_ref)
6007     return TRUE;
6008
6009   /* This is a reference to a symbol defined by a dynamic object which
6010      is not a function.  */
6011
6012   /* If we are creating a shared library, we must presume that the
6013      only references to the symbol are via the global offset table.
6014      For such cases we need not do anything here; the relocations will
6015      be handled correctly by relocate_section.  Relocatable executables
6016      can reference data in shared objects directly, so we don't need to
6017      do anything here.  */
6018   if (info->shared || globals->root.is_relocatable_executable)
6019     return TRUE;
6020
6021   if (h->size == 0)
6022     {
6023       (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
6024                              h->root.root.string);
6025       return TRUE;
6026     }
6027
6028   /* We must allocate the symbol in our .dynbss section, which will
6029      become part of the .bss section of the executable.  There will be
6030      an entry for this symbol in the .dynsym section.  The dynamic
6031      object will contain position independent code, so all references
6032      from the dynamic object to this symbol will go through the global
6033      offset table.  The dynamic linker will use the .dynsym entry to
6034      determine the address it must put in the global offset table, so
6035      both the dynamic object and the regular object will refer to the
6036      same memory location for the variable.  */
6037   s = bfd_get_section_by_name (dynobj, ".dynbss");
6038   BFD_ASSERT (s != NULL);
6039
6040   /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
6041      copy the initial value out of the dynamic object and into the
6042      runtime process image.  We need to remember the offset into the
6043      .rel.bss section we are going to use.  */
6044   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
6045     {
6046       asection *srel;
6047
6048       srel = bfd_get_section_by_name (dynobj, ".rel.bss");
6049       BFD_ASSERT (srel != NULL);
6050       srel->size += sizeof (Elf32_External_Rel);
6051       h->needs_copy = 1;
6052     }
6053
6054   /* We need to figure out the alignment required for this symbol.  I
6055      have no idea how ELF linkers handle this.  */
6056   power_of_two = bfd_log2 (h->size);
6057   if (power_of_two > 3)
6058     power_of_two = 3;
6059
6060   /* Apply the required alignment.  */
6061   s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
6062   if (power_of_two > bfd_get_section_alignment (dynobj, s))
6063     {
6064       if (! bfd_set_section_alignment (dynobj, s, power_of_two))
6065         return FALSE;
6066     }
6067
6068   /* Define the symbol as being at this point in the section.  */
6069   h->root.u.def.section = s;
6070   h->root.u.def.value = s->size;
6071
6072   /* Increment the section size to make room for the symbol.  */
6073   s->size += h->size;
6074
6075   return TRUE;
6076 }
6077
6078 /* Allocate space in .plt, .got and associated reloc sections for
6079    dynamic relocs.  */
6080
6081 static bfd_boolean
6082 allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
6083 {
6084   struct bfd_link_info *info;
6085   struct elf32_arm_link_hash_table *htab;
6086   struct elf32_arm_link_hash_entry *eh;
6087   struct elf32_arm_relocs_copied *p;
6088
6089   eh = (struct elf32_arm_link_hash_entry *) h;
6090
6091   if (h->root.type == bfd_link_hash_indirect)
6092     return TRUE;
6093
6094   if (h->root.type == bfd_link_hash_warning)
6095     /* When warning symbols are created, they **replace** the "real"
6096        entry in the hash table, thus we never get to see the real
6097        symbol in a hash traversal.  So look at it now.  */
6098     h = (struct elf_link_hash_entry *) h->root.u.i.link;
6099
6100   info = (struct bfd_link_info *) inf;
6101   htab = elf32_arm_hash_table (info);
6102
6103   if (htab->root.dynamic_sections_created
6104       && h->plt.refcount > 0)
6105     {
6106       /* Make sure this symbol is output as a dynamic symbol.
6107          Undefined weak syms won't yet be marked as dynamic.  */
6108       if (h->dynindx == -1
6109           && !h->forced_local)
6110         {
6111           if (! bfd_elf_link_record_dynamic_symbol (info, h))
6112             return FALSE;
6113         }
6114
6115       if (info->shared
6116           || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
6117         {
6118           asection *s = htab->splt;
6119
6120           /* If this is the first .plt entry, make room for the special
6121              first entry.  */
6122           if (s->size == 0)
6123             s->size += htab->plt_header_size;
6124
6125           h->plt.offset = s->size;
6126
6127           /* If we will insert a Thumb trampoline before this PLT, leave room
6128              for it.  */
6129           if (!htab->use_blx && eh->plt_thumb_refcount > 0)
6130             {
6131               h->plt.offset += PLT_THUMB_STUB_SIZE;
6132               s->size += PLT_THUMB_STUB_SIZE;
6133             }
6134
6135           /* If this symbol is not defined in a regular file, and we are
6136              not generating a shared library, then set the symbol to this
6137              location in the .plt.  This is required to make function
6138              pointers compare as equal between the normal executable and
6139              the shared library.  */
6140           if (! info->shared
6141               && !h->def_regular)
6142             {
6143               h->root.u.def.section = s;
6144               h->root.u.def.value = h->plt.offset;
6145
6146               /* Make sure the function is not marked as Thumb, in case
6147                  it is the target of an ABS32 relocation, which will
6148                  point to the PLT entry.  */
6149               if (ELF_ST_TYPE (h->type) == STT_ARM_TFUNC)
6150                 h->type = ELF_ST_INFO (ELF_ST_BIND (h->type), STT_FUNC);
6151             }
6152
6153           /* Make room for this entry.  */
6154           s->size += htab->plt_entry_size;
6155
6156           if (!htab->symbian_p)
6157             {
6158               /* We also need to make an entry in the .got.plt section, which
6159                  will be placed in the .got section by the linker script.  */
6160               eh->plt_got_offset = htab->sgotplt->size;
6161               htab->sgotplt->size += 4;
6162             }
6163
6164           /* We also need to make an entry in the .rel.plt section.  */
6165           htab->srelplt->size += sizeof (Elf32_External_Rel);
6166         }
6167       else
6168         {
6169           h->plt.offset = (bfd_vma) -1;
6170           h->needs_plt = 0;
6171         }
6172     }
6173   else
6174     {
6175       h->plt.offset = (bfd_vma) -1;
6176       h->needs_plt = 0;
6177     }
6178
6179   if (h->got.refcount > 0)
6180     {
6181       asection *s;
6182       bfd_boolean dyn;
6183       int tls_type = elf32_arm_hash_entry (h)->tls_type;
6184       int indx;
6185
6186       /* Make sure this symbol is output as a dynamic symbol.
6187          Undefined weak syms won't yet be marked as dynamic.  */
6188       if (h->dynindx == -1
6189           && !h->forced_local)
6190         {
6191           if (! bfd_elf_link_record_dynamic_symbol (info, h))
6192             return FALSE;
6193         }
6194
6195       if (!htab->symbian_p)
6196         {
6197           s = htab->sgot;
6198           h->got.offset = s->size;
6199
6200           if (tls_type == GOT_UNKNOWN)
6201             abort ();
6202
6203           if (tls_type == GOT_NORMAL)
6204             /* Non-TLS symbols need one GOT slot.  */
6205             s->size += 4;
6206           else
6207             {
6208               if (tls_type & GOT_TLS_GD)
6209                 /* R_ARM_TLS_GD32 needs 2 consecutive GOT slots.  */
6210                 s->size += 8;
6211               if (tls_type & GOT_TLS_IE)
6212                 /* R_ARM_TLS_IE32 needs one GOT slot.  */
6213                 s->size += 4;
6214             }
6215
6216           dyn = htab->root.dynamic_sections_created;
6217
6218           indx = 0;
6219           if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
6220               && (!info->shared
6221                   || !SYMBOL_REFERENCES_LOCAL (info, h)))
6222             indx = h->dynindx;
6223
6224           if (tls_type != GOT_NORMAL
6225               && (info->shared || indx != 0)
6226               && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
6227                   || h->root.type != bfd_link_hash_undefweak))
6228             {
6229               if (tls_type & GOT_TLS_IE)
6230                 htab->srelgot->size += sizeof (Elf32_External_Rel);
6231
6232               if (tls_type & GOT_TLS_GD)
6233                 htab->srelgot->size += sizeof (Elf32_External_Rel);
6234
6235               if ((tls_type & GOT_TLS_GD) && indx != 0)
6236                 htab->srelgot->size += sizeof (Elf32_External_Rel);
6237             }
6238           else if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
6239                     || h->root.type != bfd_link_hash_undefweak)
6240                    && (info->shared
6241                    || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
6242             htab->srelgot->size += sizeof (Elf32_External_Rel);
6243         }
6244     }
6245   else
6246     h->got.offset = (bfd_vma) -1;
6247
6248   if (eh->relocs_copied == NULL)
6249     return TRUE;
6250
6251   /* In the shared -Bsymbolic case, discard space allocated for
6252      dynamic pc-relative relocs against symbols which turn out to be
6253      defined in regular objects.  For the normal shared case, discard
6254      space for pc-relative relocs that have become local due to symbol
6255      visibility changes.  */
6256
6257   if (info->shared || htab->root.is_relocatable_executable)
6258     {
6259       /* The only reloc that uses pc_count is R_ARM_REL32, which will
6260          appear on something like ".long foo - .".  We want calls to
6261          protected symbols to resolve directly to the function rather
6262          than going via the plt.  If people want function pointer
6263          comparisons to work as expected then they should avoid
6264          writing assembly like ".long foo - .".  */
6265       if (SYMBOL_CALLS_LOCAL (info, h))
6266         {
6267           struct elf32_arm_relocs_copied **pp;
6268
6269           for (pp = &eh->relocs_copied; (p = *pp) != NULL; )
6270             {
6271               p->count -= p->pc_count;
6272               p->pc_count = 0;
6273               if (p->count == 0)
6274                 *pp = p->next;
6275               else
6276                 pp = &p->next;
6277             }
6278         }
6279
6280       /* Also discard relocs on undefined weak syms with non-default
6281          visibility.  */
6282       if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
6283           && h->root.type == bfd_link_hash_undefweak)
6284         eh->relocs_copied = NULL;
6285       else if (htab->root.is_relocatable_executable && h->dynindx == -1
6286                && h->root.type == bfd_link_hash_new)
6287         {
6288           /* Output absolute symbols so that we can create relocations
6289              against them.  For normal symbols we output a relocation
6290              against the section that contains them.  */
6291           if (! bfd_elf_link_record_dynamic_symbol (info, h))
6292             return FALSE;
6293         }
6294
6295     }
6296   else
6297     {
6298       /* For the non-shared case, discard space for relocs against
6299          symbols which turn out to need copy relocs or are not
6300          dynamic.  */
6301
6302       if (!h->non_got_ref
6303           && ((h->def_dynamic
6304                && !h->def_regular)
6305               || (htab->root.dynamic_sections_created
6306                   && (h->root.type == bfd_link_hash_undefweak
6307                       || h->root.type == bfd_link_hash_undefined))))
6308         {
6309           /* Make sure this symbol is output as a dynamic symbol.
6310              Undefined weak syms won't yet be marked as dynamic.  */
6311           if (h->dynindx == -1
6312               && !h->forced_local)
6313             {
6314               if (! bfd_elf_link_record_dynamic_symbol (info, h))
6315                 return FALSE;
6316             }
6317
6318           /* If that succeeded, we know we'll be keeping all the
6319              relocs.  */
6320           if (h->dynindx != -1)
6321             goto keep;
6322         }
6323
6324       eh->relocs_copied = NULL;
6325
6326     keep: ;
6327     }
6328
6329   /* Finally, allocate space.  */
6330   for (p = eh->relocs_copied; p != NULL; p = p->next)
6331     {
6332       asection *sreloc = elf_section_data (p->section)->sreloc;
6333       sreloc->size += p->count * sizeof (Elf32_External_Rel);
6334     }
6335
6336   return TRUE;
6337 }
6338
6339 /* Find any dynamic relocs that apply to read-only sections.  */
6340
6341 static bfd_boolean
6342 elf32_arm_readonly_dynrelocs (struct elf_link_hash_entry *h, PTR inf)
6343 {
6344   struct elf32_arm_link_hash_entry *eh;
6345   struct elf32_arm_relocs_copied *p;
6346
6347   if (h->root.type == bfd_link_hash_warning)
6348     h = (struct elf_link_hash_entry *) h->root.u.i.link;
6349
6350   eh = (struct elf32_arm_link_hash_entry *) h;
6351   for (p = eh->relocs_copied; p != NULL; p = p->next)
6352     {
6353       asection *s = p->section;
6354
6355       if (s != NULL && (s->flags & SEC_READONLY) != 0)
6356         {
6357           struct bfd_link_info *info = (struct bfd_link_info *) inf;
6358
6359           info->flags |= DF_TEXTREL;
6360
6361           /* Not an error, just cut short the traversal.  */
6362           return FALSE;
6363         }
6364     }
6365   return TRUE;
6366 }
6367
6368 /* Set the sizes of the dynamic sections.  */
6369
6370 static bfd_boolean
6371 elf32_arm_size_dynamic_sections (bfd * output_bfd ATTRIBUTE_UNUSED,
6372                                  struct bfd_link_info * info)
6373 {
6374   bfd * dynobj;
6375   asection * s;
6376   bfd_boolean plt;
6377   bfd_boolean relocs;
6378   bfd *ibfd;
6379   struct elf32_arm_link_hash_table *htab;
6380
6381   htab = elf32_arm_hash_table (info);
6382   dynobj = elf_hash_table (info)->dynobj;
6383   BFD_ASSERT (dynobj != NULL);
6384
6385   if (elf_hash_table (info)->dynamic_sections_created)
6386     {
6387       /* Set the contents of the .interp section to the interpreter.  */
6388       if (info->executable)
6389         {
6390           s = bfd_get_section_by_name (dynobj, ".interp");
6391           BFD_ASSERT (s != NULL);
6392           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
6393           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
6394         }
6395     }
6396
6397   /* Set up .got offsets for local syms, and space for local dynamic
6398      relocs.  */
6399   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
6400     {
6401       bfd_signed_vma *local_got;
6402       bfd_signed_vma *end_local_got;
6403       char *local_tls_type;
6404       bfd_size_type locsymcount;
6405       Elf_Internal_Shdr *symtab_hdr;
6406       asection *srel;
6407
6408       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
6409         continue;
6410
6411       for (s = ibfd->sections; s != NULL; s = s->next)
6412         {
6413           struct elf32_arm_relocs_copied *p;
6414
6415           for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
6416             {
6417               if (!bfd_is_abs_section (p->section)
6418                   && bfd_is_abs_section (p->section->output_section))
6419                 {
6420                   /* Input section has been discarded, either because
6421                      it is a copy of a linkonce section or due to
6422                      linker script /DISCARD/, so we'll be discarding
6423                      the relocs too.  */
6424                 }
6425               else if (p->count != 0)
6426                 {
6427                   srel = elf_section_data (p->section)->sreloc;
6428                   srel->size += p->count * sizeof (Elf32_External_Rel);
6429                   if ((p->section->output_section->flags & SEC_READONLY) != 0)
6430                     info->flags |= DF_TEXTREL;
6431                 }
6432             }
6433         }
6434
6435       local_got = elf_local_got_refcounts (ibfd);
6436       if (!local_got)
6437         continue;
6438
6439       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
6440       locsymcount = symtab_hdr->sh_info;
6441       end_local_got = local_got + locsymcount;
6442       local_tls_type = elf32_arm_local_got_tls_type (ibfd);
6443       s = htab->sgot;
6444       srel = htab->srelgot;
6445       for (; local_got < end_local_got; ++local_got, ++local_tls_type)
6446         {
6447           if (*local_got > 0)
6448             {
6449               *local_got = s->size;
6450               if (*local_tls_type & GOT_TLS_GD)
6451                 /* TLS_GD relocs need an 8-byte structure in the GOT.  */
6452                 s->size += 8;
6453               if (*local_tls_type & GOT_TLS_IE)
6454                 s->size += 4;
6455               if (*local_tls_type == GOT_NORMAL)
6456                 s->size += 4;
6457
6458               if (info->shared || *local_tls_type == GOT_TLS_GD)
6459                 srel->size += sizeof (Elf32_External_Rel);
6460             }
6461           else
6462             *local_got = (bfd_vma) -1;
6463         }
6464     }
6465
6466   if (htab->tls_ldm_got.refcount > 0)
6467     {
6468       /* Allocate two GOT entries and one dynamic relocation (if necessary)
6469          for R_ARM_TLS_LDM32 relocations.  */
6470       htab->tls_ldm_got.offset = htab->sgot->size;
6471       htab->sgot->size += 8;
6472       if (info->shared)
6473         htab->srelgot->size += sizeof (Elf32_External_Rel);
6474     }
6475   else
6476     htab->tls_ldm_got.offset = -1;
6477
6478   /* Allocate global sym .plt and .got entries, and space for global
6479      sym dynamic relocs.  */
6480   elf_link_hash_traverse (& htab->root, allocate_dynrelocs, info);
6481
6482   /* The check_relocs and adjust_dynamic_symbol entry points have
6483      determined the sizes of the various dynamic sections.  Allocate
6484      memory for them.  */
6485   plt = FALSE;
6486   relocs = FALSE;
6487   for (s = dynobj->sections; s != NULL; s = s->next)
6488     {
6489       const char * name;
6490
6491       if ((s->flags & SEC_LINKER_CREATED) == 0)
6492         continue;
6493
6494       /* It's OK to base decisions on the section name, because none
6495          of the dynobj section names depend upon the input files.  */
6496       name = bfd_get_section_name (dynobj, s);
6497
6498       if (strcmp (name, ".plt") == 0)
6499         {
6500           /* Remember whether there is a PLT.  */
6501           plt = s->size != 0;
6502         }
6503       else if (strncmp (name, ".rel", 4) == 0)
6504         {
6505           if (s->size != 0)
6506             {
6507               /* Remember whether there are any reloc sections other
6508                  than .rel.plt.  */
6509               if (strcmp (name, ".rel.plt") != 0)
6510                 relocs = TRUE;
6511
6512               /* We use the reloc_count field as a counter if we need
6513                  to copy relocs into the output file.  */
6514               s->reloc_count = 0;
6515             }
6516         }
6517       else if (strncmp (name, ".got", 4) != 0
6518                && strcmp (name, ".dynbss") != 0)
6519         {
6520           /* It's not one of our sections, so don't allocate space.  */
6521           continue;
6522         }
6523
6524       if (s->size == 0)
6525         {
6526           /* If we don't need this section, strip it from the
6527              output file.  This is mostly to handle .rel.bss and
6528              .rel.plt.  We must create both sections in
6529              create_dynamic_sections, because they must be created
6530              before the linker maps input sections to output
6531              sections.  The linker does that before
6532              adjust_dynamic_symbol is called, and it is that
6533              function which decides whether anything needs to go
6534              into these sections.  */
6535           s->flags |= SEC_EXCLUDE;
6536           continue;
6537         }
6538
6539       if ((s->flags & SEC_HAS_CONTENTS) == 0)
6540         continue;
6541
6542       /* Allocate memory for the section contents.  */
6543       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
6544       if (s->contents == NULL)
6545         return FALSE;
6546     }
6547
6548   if (elf_hash_table (info)->dynamic_sections_created)
6549     {
6550       /* Add some entries to the .dynamic section.  We fill in the
6551          values later, in elf32_arm_finish_dynamic_sections, but we
6552          must add the entries now so that we get the correct size for
6553          the .dynamic section.  The DT_DEBUG entry is filled in by the
6554          dynamic linker and used by the debugger.  */
6555 #define add_dynamic_entry(TAG, VAL) \
6556   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
6557
6558      if (info->executable)
6559         {
6560           if (!add_dynamic_entry (DT_DEBUG, 0))
6561             return FALSE;
6562         }
6563
6564       if (plt)
6565         {
6566           if (   !add_dynamic_entry (DT_PLTGOT, 0)
6567               || !add_dynamic_entry (DT_PLTRELSZ, 0)
6568               || !add_dynamic_entry (DT_PLTREL, DT_REL)
6569               || !add_dynamic_entry (DT_JMPREL, 0))
6570             return FALSE;
6571         }
6572
6573       if (relocs)
6574         {
6575           if (   !add_dynamic_entry (DT_REL, 0)
6576               || !add_dynamic_entry (DT_RELSZ, 0)
6577               || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel)))
6578             return FALSE;
6579         }
6580
6581       /* If any dynamic relocs apply to a read-only section,
6582          then we need a DT_TEXTREL entry.  */
6583       if ((info->flags & DF_TEXTREL) == 0)
6584         elf_link_hash_traverse (&htab->root, elf32_arm_readonly_dynrelocs,
6585                                 (PTR) info);
6586
6587       if ((info->flags & DF_TEXTREL) != 0)
6588         {
6589           if (!add_dynamic_entry (DT_TEXTREL, 0))
6590             return FALSE;
6591         }
6592     }
6593 #undef add_dynamic_entry
6594
6595   return TRUE;
6596 }
6597
6598 /* Finish up dynamic symbol handling.  We set the contents of various
6599    dynamic sections here.  */
6600
6601 static bfd_boolean
6602 elf32_arm_finish_dynamic_symbol (bfd * output_bfd, struct bfd_link_info * info,
6603                                  struct elf_link_hash_entry * h, Elf_Internal_Sym * sym)
6604 {
6605   bfd * dynobj;
6606   struct elf32_arm_link_hash_table *htab;
6607   struct elf32_arm_link_hash_entry *eh;
6608
6609   dynobj = elf_hash_table (info)->dynobj;
6610   htab = elf32_arm_hash_table (info);
6611   eh = (struct elf32_arm_link_hash_entry *) h;
6612
6613   if (h->plt.offset != (bfd_vma) -1)
6614     {
6615       asection * splt;
6616       asection * srel;
6617       bfd_byte *loc;
6618       bfd_vma plt_index;
6619       Elf_Internal_Rela rel;
6620
6621       /* This symbol has an entry in the procedure linkage table.  Set
6622          it up.  */
6623
6624       BFD_ASSERT (h->dynindx != -1);
6625
6626       splt = bfd_get_section_by_name (dynobj, ".plt");
6627       srel = bfd_get_section_by_name (dynobj, ".rel.plt");
6628       BFD_ASSERT (splt != NULL && srel != NULL);
6629
6630       /* Fill in the entry in the procedure linkage table.  */
6631       if (htab->symbian_p)
6632         {
6633           unsigned i;
6634           for (i = 0; i < htab->plt_entry_size / 4; ++i)
6635             bfd_put_32 (output_bfd,
6636                         elf32_arm_symbian_plt_entry[i],
6637                         splt->contents + h->plt.offset + 4 * i);
6638
6639           /* Fill in the entry in the .rel.plt section.  */
6640           rel.r_offset = (splt->output_section->vma
6641                           + splt->output_offset
6642                           + h->plt.offset + 4 * (i - 1));
6643           rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT);
6644
6645           /* Get the index in the procedure linkage table which
6646              corresponds to this symbol.  This is the index of this symbol
6647              in all the symbols for which we are making plt entries.  The
6648              first entry in the procedure linkage table is reserved.  */
6649           plt_index = ((h->plt.offset - htab->plt_header_size)
6650                        / htab->plt_entry_size);
6651         }
6652       else
6653         {
6654           bfd_vma got_offset;
6655           bfd_vma got_displacement;
6656           asection * sgot;
6657
6658           sgot = bfd_get_section_by_name (dynobj, ".got.plt");
6659           BFD_ASSERT (sgot != NULL);
6660
6661           /* Get the offset into the .got.plt table of the entry that
6662              corresponds to this function.  */
6663           got_offset = eh->plt_got_offset;
6664
6665           /* Get the index in the procedure linkage table which
6666              corresponds to this symbol.  This is the index of this symbol
6667              in all the symbols for which we are making plt entries.  The
6668              first three entries in .got.plt are reserved; after that
6669              symbols appear in the same order as in .plt.  */
6670           plt_index = (got_offset - 12) / 4;
6671
6672           /* Calculate the displacement between the PLT slot and the
6673              entry in the GOT.  The eight-byte offset accounts for the
6674              value produced by adding to pc in the first instruction
6675              of the PLT stub.  */
6676           got_displacement = (sgot->output_section->vma
6677                               + sgot->output_offset
6678                               + got_offset
6679                               - splt->output_section->vma
6680                               - splt->output_offset
6681                               - h->plt.offset
6682                               - 8);
6683
6684           BFD_ASSERT ((got_displacement & 0xf0000000) == 0);
6685
6686           if (!htab->use_blx && eh->plt_thumb_refcount > 0)
6687             {
6688               bfd_put_16 (output_bfd, elf32_arm_plt_thumb_stub[0],
6689                           splt->contents + h->plt.offset - 4);
6690               bfd_put_16 (output_bfd, elf32_arm_plt_thumb_stub[1],
6691                           splt->contents + h->plt.offset - 2);
6692             }
6693
6694           bfd_put_32 (output_bfd, elf32_arm_plt_entry[0] | ((got_displacement & 0x0ff00000) >> 20),
6695                       splt->contents + h->plt.offset + 0);
6696           bfd_put_32 (output_bfd, elf32_arm_plt_entry[1] | ((got_displacement & 0x000ff000) >> 12),
6697                       splt->contents + h->plt.offset + 4);
6698           bfd_put_32 (output_bfd, elf32_arm_plt_entry[2] | (got_displacement & 0x00000fff),
6699                       splt->contents + h->plt.offset + 8);
6700 #ifdef FOUR_WORD_PLT
6701           bfd_put_32 (output_bfd, elf32_arm_plt_entry[3],
6702                       splt->contents + h->plt.offset + 12);
6703 #endif
6704
6705           /* Fill in the entry in the global offset table.  */
6706           bfd_put_32 (output_bfd,
6707                       (splt->output_section->vma
6708                        + splt->output_offset),
6709                       sgot->contents + got_offset);
6710
6711           /* Fill in the entry in the .rel.plt section.  */
6712           rel.r_offset = (sgot->output_section->vma
6713                           + sgot->output_offset
6714                           + got_offset);
6715           rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_JUMP_SLOT);
6716         }
6717
6718       loc = srel->contents + plt_index * sizeof (Elf32_External_Rel);
6719       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
6720
6721       if (!h->def_regular)
6722         {
6723           /* Mark the symbol as undefined, rather than as defined in
6724              the .plt section.  Leave the value alone.  */
6725           sym->st_shndx = SHN_UNDEF;
6726           /* If the symbol is weak, we do need to clear the value.
6727              Otherwise, the PLT entry would provide a definition for
6728              the symbol even if the symbol wasn't defined anywhere,
6729              and so the symbol would never be NULL.  */
6730           if (!h->ref_regular_nonweak)
6731             sym->st_value = 0;
6732         }
6733     }
6734
6735   if (h->got.offset != (bfd_vma) -1
6736       && (elf32_arm_hash_entry (h)->tls_type & GOT_TLS_GD) == 0
6737       && (elf32_arm_hash_entry (h)->tls_type & GOT_TLS_IE) == 0)
6738     {
6739       asection * sgot;
6740       asection * srel;
6741       Elf_Internal_Rela rel;
6742       bfd_byte *loc;
6743
6744       /* This symbol has an entry in the global offset table.  Set it
6745          up.  */
6746       sgot = bfd_get_section_by_name (dynobj, ".got");
6747       srel = bfd_get_section_by_name (dynobj, ".rel.got");
6748       BFD_ASSERT (sgot != NULL && srel != NULL);
6749
6750       rel.r_offset = (sgot->output_section->vma
6751                       + sgot->output_offset
6752                       + (h->got.offset &~ (bfd_vma) 1));
6753
6754       /* If this is a static link, or it is a -Bsymbolic link and the
6755          symbol is defined locally or was forced to be local because
6756          of a version file, we just want to emit a RELATIVE reloc.
6757          The entry in the global offset table will already have been
6758          initialized in the relocate_section function.  */
6759       if (info->shared
6760           && SYMBOL_REFERENCES_LOCAL (info, h))
6761         {
6762           BFD_ASSERT((h->got.offset & 1) != 0);
6763           rel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
6764         }
6765       else
6766         {
6767           BFD_ASSERT((h->got.offset & 1) == 0);
6768           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
6769           rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT);
6770         }
6771
6772       loc = srel->contents + srel->reloc_count++ * sizeof (Elf32_External_Rel);
6773       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
6774     }
6775
6776   if (h->needs_copy)
6777     {
6778       asection * s;
6779       Elf_Internal_Rela rel;
6780       bfd_byte *loc;
6781
6782       /* This symbol needs a copy reloc.  Set it up.  */
6783       BFD_ASSERT (h->dynindx != -1
6784                   && (h->root.type == bfd_link_hash_defined
6785                       || h->root.type == bfd_link_hash_defweak));
6786
6787       s = bfd_get_section_by_name (h->root.u.def.section->owner,
6788                                    ".rel.bss");
6789       BFD_ASSERT (s != NULL);
6790
6791       rel.r_offset = (h->root.u.def.value
6792                       + h->root.u.def.section->output_section->vma
6793                       + h->root.u.def.section->output_offset);
6794       rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_COPY);
6795       loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rel);
6796       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
6797     }
6798
6799   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
6800   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
6801       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
6802     sym->st_shndx = SHN_ABS;
6803
6804   return TRUE;
6805 }
6806
6807 /* Finish up the dynamic sections.  */
6808
6809 static bfd_boolean
6810 elf32_arm_finish_dynamic_sections (bfd * output_bfd, struct bfd_link_info * info)
6811 {
6812   bfd * dynobj;
6813   asection * sgot;
6814   asection * sdyn;
6815
6816   dynobj = elf_hash_table (info)->dynobj;
6817
6818   sgot = bfd_get_section_by_name (dynobj, ".got.plt");
6819   BFD_ASSERT (elf32_arm_hash_table (info)->symbian_p || sgot != NULL);
6820   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
6821
6822   if (elf_hash_table (info)->dynamic_sections_created)
6823     {
6824       asection *splt;
6825       Elf32_External_Dyn *dyncon, *dynconend;
6826       struct elf32_arm_link_hash_table *htab;
6827
6828       htab = elf32_arm_hash_table (info);
6829       splt = bfd_get_section_by_name (dynobj, ".plt");
6830       BFD_ASSERT (splt != NULL && sdyn != NULL);
6831
6832       dyncon = (Elf32_External_Dyn *) sdyn->contents;
6833       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
6834
6835       for (; dyncon < dynconend; dyncon++)
6836         {
6837           Elf_Internal_Dyn dyn;
6838           const char * name;
6839           asection * s;
6840
6841           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
6842
6843           switch (dyn.d_tag)
6844             {
6845               unsigned int type;
6846
6847             default:
6848               break;
6849
6850             case DT_HASH:
6851               name = ".hash";
6852               goto get_vma_if_bpabi;
6853             case DT_STRTAB:
6854               name = ".dynstr";
6855               goto get_vma_if_bpabi;
6856             case DT_SYMTAB:
6857               name = ".dynsym";
6858               goto get_vma_if_bpabi;
6859             case DT_VERSYM:
6860               name = ".gnu.version";
6861               goto get_vma_if_bpabi;
6862             case DT_VERDEF:
6863               name = ".gnu.version_d";
6864               goto get_vma_if_bpabi;
6865             case DT_VERNEED:
6866               name = ".gnu.version_r";
6867               goto get_vma_if_bpabi;
6868
6869             case DT_PLTGOT:
6870               name = ".got";
6871               goto get_vma;
6872             case DT_JMPREL:
6873               name = ".rel.plt";
6874             get_vma:
6875               s = bfd_get_section_by_name (output_bfd, name);
6876               BFD_ASSERT (s != NULL);
6877               if (!htab->symbian_p)
6878                 dyn.d_un.d_ptr = s->vma;
6879               else
6880                 /* In the BPABI, tags in the PT_DYNAMIC section point
6881                    at the file offset, not the memory address, for the
6882                    convenience of the post linker.  */
6883                 dyn.d_un.d_ptr = s->filepos;
6884               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
6885               break;
6886
6887             get_vma_if_bpabi:
6888               if (htab->symbian_p)
6889                 goto get_vma;
6890               break;
6891
6892             case DT_PLTRELSZ:
6893               s = bfd_get_section_by_name (output_bfd, ".rel.plt");
6894               BFD_ASSERT (s != NULL);
6895               dyn.d_un.d_val = s->size;
6896               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
6897               break;
6898
6899             case DT_RELSZ:
6900               if (!htab->symbian_p)
6901                 {
6902                   /* My reading of the SVR4 ABI indicates that the
6903                      procedure linkage table relocs (DT_JMPREL) should be
6904                      included in the overall relocs (DT_REL).  This is
6905                      what Solaris does.  However, UnixWare can not handle
6906                      that case.  Therefore, we override the DT_RELSZ entry
6907                      here to make it not include the JMPREL relocs.  Since
6908                      the linker script arranges for .rel.plt to follow all
6909                      other relocation sections, we don't have to worry
6910                      about changing the DT_REL entry.  */
6911                   s = bfd_get_section_by_name (output_bfd, ".rel.plt");
6912                   if (s != NULL)
6913                     dyn.d_un.d_val -= s->size;
6914                   bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
6915                   break;
6916                 }
6917               /* Fall through */
6918
6919             case DT_REL:
6920             case DT_RELA:
6921             case DT_RELASZ:
6922               /* In the BPABI, the DT_REL tag must point at the file
6923                  offset, not the VMA, of the first relocation
6924                  section.  So, we use code similar to that in
6925                  elflink.c, but do not check for SHF_ALLOC on the
6926                  relcoation section, since relocations sections are
6927                  never allocated under the BPABI.  The comments above
6928                  about Unixware notwithstanding, we include all of the
6929                  relocations here.  */
6930               if (htab->symbian_p)
6931                 {
6932                   unsigned int i;
6933                   type = ((dyn.d_tag == DT_REL || dyn.d_tag == DT_RELSZ)
6934                           ? SHT_REL : SHT_RELA);
6935                   dyn.d_un.d_val = 0;
6936                   for (i = 1; i < elf_numsections (output_bfd); i++)
6937                     {
6938                       Elf_Internal_Shdr *hdr
6939                         = elf_elfsections (output_bfd)[i];
6940                       if (hdr->sh_type == type)
6941                         {
6942                           if (dyn.d_tag == DT_RELSZ
6943                               || dyn.d_tag == DT_RELASZ)
6944                             dyn.d_un.d_val += hdr->sh_size;
6945                           else if ((ufile_ptr) hdr->sh_offset
6946                                    <= dyn.d_un.d_val - 1)
6947                             dyn.d_un.d_val = hdr->sh_offset;
6948                         }
6949                     }
6950                   bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
6951                 }
6952               break;
6953
6954               /* Set the bottom bit of DT_INIT/FINI if the
6955                  corresponding function is Thumb.  */
6956             case DT_INIT:
6957               name = info->init_function;
6958               goto get_sym;
6959             case DT_FINI:
6960               name = info->fini_function;
6961             get_sym:
6962               /* If it wasn't set by elf_bfd_final_link
6963                  then there is nothing to adjust.  */
6964               if (dyn.d_un.d_val != 0)
6965                 {
6966                   struct elf_link_hash_entry * eh;
6967
6968                   eh = elf_link_hash_lookup (elf_hash_table (info), name,
6969                                              FALSE, FALSE, TRUE);
6970                   if (eh != (struct elf_link_hash_entry *) NULL
6971                       && ELF_ST_TYPE (eh->type) == STT_ARM_TFUNC)
6972                     {
6973                       dyn.d_un.d_val |= 1;
6974                       bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
6975                     }
6976                 }
6977               break;
6978             }
6979         }
6980
6981       /* Fill in the first entry in the procedure linkage table.  */
6982       if (splt->size > 0 && elf32_arm_hash_table (info)->plt_header_size)
6983         {
6984           bfd_vma got_displacement;
6985
6986           /* Calculate the displacement between the PLT slot and &GOT[0].  */
6987           got_displacement = (sgot->output_section->vma
6988                               + sgot->output_offset
6989                               - splt->output_section->vma
6990                               - splt->output_offset
6991                               - 16);
6992
6993           bfd_put_32 (output_bfd, elf32_arm_plt0_entry[0], splt->contents +  0);
6994           bfd_put_32 (output_bfd, elf32_arm_plt0_entry[1], splt->contents +  4);
6995           bfd_put_32 (output_bfd, elf32_arm_plt0_entry[2], splt->contents +  8);
6996           bfd_put_32 (output_bfd, elf32_arm_plt0_entry[3], splt->contents + 12);
6997 #ifdef FOUR_WORD_PLT
6998           /* The displacement value goes in the otherwise-unused last word of
6999              the second entry.  */
7000           bfd_put_32 (output_bfd, got_displacement,        splt->contents + 28);
7001 #else
7002           bfd_put_32 (output_bfd, got_displacement,        splt->contents + 16);
7003 #endif
7004         }
7005
7006       /* UnixWare sets the entsize of .plt to 4, although that doesn't
7007          really seem like the right value.  */
7008       elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
7009     }
7010
7011   /* Fill in the first three entries in the global offset table.  */
7012   if (sgot)
7013     {
7014       if (sgot->size > 0)
7015         {
7016           if (sdyn == NULL)
7017             bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
7018           else
7019             bfd_put_32 (output_bfd,
7020                         sdyn->output_section->vma + sdyn->output_offset,
7021                         sgot->contents);
7022           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
7023           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
7024         }
7025
7026       elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
7027     }
7028
7029   return TRUE;
7030 }
7031
7032 static void
7033 elf32_arm_post_process_headers (bfd * abfd, struct bfd_link_info * link_info ATTRIBUTE_UNUSED)
7034 {
7035   Elf_Internal_Ehdr * i_ehdrp;  /* ELF file header, internal form.  */
7036   struct elf32_arm_link_hash_table *globals;
7037
7038   i_ehdrp = elf_elfheader (abfd);
7039
7040   if (EF_ARM_EABI_VERSION (i_ehdrp->e_flags) == EF_ARM_EABI_UNKNOWN)
7041     i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_ARM;
7042   else
7043     i_ehdrp->e_ident[EI_OSABI] = 0;
7044   i_ehdrp->e_ident[EI_ABIVERSION] = ARM_ELF_ABI_VERSION;
7045
7046   if (link_info)
7047     {
7048       globals = elf32_arm_hash_table (link_info);
7049       if (globals->byteswap_code)
7050         i_ehdrp->e_flags |= EF_ARM_BE8;
7051     }
7052 }
7053
7054 static enum elf_reloc_type_class
7055 elf32_arm_reloc_type_class (const Elf_Internal_Rela *rela)
7056 {
7057   switch ((int) ELF32_R_TYPE (rela->r_info))
7058     {
7059     case R_ARM_RELATIVE:
7060       return reloc_class_relative;
7061     case R_ARM_JUMP_SLOT:
7062       return reloc_class_plt;
7063     case R_ARM_COPY:
7064       return reloc_class_copy;
7065     default:
7066       return reloc_class_normal;
7067     }
7068 }
7069
7070 /* Set the right machine number for an Arm ELF file.  */
7071
7072 static bfd_boolean
7073 elf32_arm_section_flags (flagword *flags, const Elf_Internal_Shdr *hdr)
7074 {
7075   if (hdr->sh_type == SHT_NOTE)
7076     *flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_SAME_CONTENTS;
7077
7078   return TRUE;
7079 }
7080
7081 static void
7082 elf32_arm_final_write_processing (bfd *abfd, bfd_boolean linker ATTRIBUTE_UNUSED)
7083 {
7084   bfd_arm_update_notes (abfd, ARM_NOTE_SECTION);
7085 }
7086
7087 /* Return TRUE if this is an unwinding table entry.  */
7088
7089 static bfd_boolean
7090 is_arm_elf_unwind_section_name (bfd * abfd ATTRIBUTE_UNUSED, const char * name)
7091 {
7092   size_t len1, len2;
7093
7094   len1 = sizeof (ELF_STRING_ARM_unwind) - 1;
7095   len2 = sizeof (ELF_STRING_ARM_unwind_once) - 1;
7096   return (strncmp (name, ELF_STRING_ARM_unwind, len1) == 0
7097           || strncmp (name, ELF_STRING_ARM_unwind_once, len2) == 0);
7098 }
7099
7100
7101 /* Set the type and flags for an ARM section.  We do this by
7102    the section name, which is a hack, but ought to work.  */
7103
7104 static bfd_boolean
7105 elf32_arm_fake_sections (bfd * abfd, Elf_Internal_Shdr * hdr, asection * sec)
7106 {
7107   const char * name;
7108
7109   name = bfd_get_section_name (abfd, sec);
7110
7111   if (is_arm_elf_unwind_section_name (abfd, name))
7112     {
7113       hdr->sh_type = SHT_ARM_EXIDX;
7114       hdr->sh_flags |= SHF_LINK_ORDER;
7115     }
7116   else if (strcmp(name, ".ARM.attributes") == 0)
7117     {
7118       hdr->sh_type = SHT_ARM_ATTRIBUTES;
7119     }
7120   return TRUE;
7121 }
7122
7123 /* Parse an Arm EABI attributes section.  */
7124 static void
7125 elf32_arm_parse_attributes (bfd *abfd, Elf_Internal_Shdr * hdr)
7126 {
7127   bfd_byte *contents;
7128   bfd_byte *p;
7129   bfd_vma len;
7130
7131   contents = bfd_malloc (hdr->sh_size);
7132   if (!contents)
7133     return;
7134   if (!bfd_get_section_contents (abfd, hdr->bfd_section, contents, 0,
7135                                  hdr->sh_size))
7136     {
7137       free (contents);
7138       return;
7139     }
7140   p = contents;
7141   if (*(p++) == 'A')
7142     {
7143       len = hdr->sh_size - 1;
7144       while (len > 0)
7145         {
7146           int namelen;
7147           bfd_vma section_len;
7148
7149           section_len = bfd_get_32 (abfd, p);
7150           p += 4;
7151           if (section_len > len)
7152             section_len = len;
7153           len -= section_len;
7154           namelen = strlen ((char *)p) + 1;
7155           section_len -= namelen + 4;
7156           if (strcmp((char *)p, "aeabi") != 0)
7157             {
7158               /* Vendor section.  Ignore it.  */
7159               p += namelen + section_len;
7160             }
7161           else
7162             {
7163               p += namelen;
7164               while (section_len > 0)
7165                 {
7166                   int tag;
7167                   unsigned int n;
7168                   unsigned int val;
7169                   bfd_vma subsection_len;
7170                   bfd_byte *end;
7171
7172                   tag = read_unsigned_leb128 (abfd, p, &n);
7173                   p += n;
7174                   subsection_len = bfd_get_32 (abfd, p);
7175                   p += 4;
7176                   if (subsection_len > section_len)
7177                     subsection_len = section_len;
7178                   section_len -= subsection_len;
7179                   subsection_len -= n + 4;
7180                   end = p + subsection_len;
7181                   switch (tag)
7182                     {
7183                     case Tag_File:
7184                       while (p < end)
7185                         {
7186                           bfd_boolean is_string;
7187
7188                           tag = read_unsigned_leb128 (abfd, p, &n);
7189                           p += n;
7190                           if (tag == 4 || tag == 5)
7191                             is_string = 1;
7192                           else if (tag < 32)
7193                             is_string = 0;
7194                           else
7195                             is_string = (tag & 1) != 0;
7196                           if (tag == Tag_compatibility)
7197                             {
7198                               val = read_unsigned_leb128 (abfd, p, &n);
7199                               p += n;
7200                               elf32_arm_add_eabi_attr_compat (abfd, val,
7201                                                               (char *)p);
7202                               p += strlen ((char *)p) + 1;
7203                             }
7204                           else if (is_string)
7205                             {
7206                               elf32_arm_add_eabi_attr_string (abfd, tag,
7207                                                               (char *)p);
7208                               p += strlen ((char *)p) + 1;
7209                             }
7210                           else
7211                             {
7212                               val = read_unsigned_leb128 (abfd, p, &n);
7213                               p += n;
7214                               elf32_arm_add_eabi_attr_int (abfd, tag, val);
7215                             }
7216                         }
7217                       break;
7218                     case Tag_Section:
7219                     case Tag_Symbol:
7220                       /* Don't have anywhere convenient to attach these.
7221                          Fall through for now.  */
7222                     default:
7223                       /* Ignore things we don't kow about.  */
7224                       p += subsection_len;
7225                       subsection_len = 0;
7226                       break;
7227                     }
7228                 }
7229             }
7230         }
7231     }
7232   free (contents);
7233 }
7234
7235 /* Handle an ARM specific section when reading an object file.  This is
7236    called when bfd_section_from_shdr finds a section with an unknown
7237    type.  */
7238
7239 static bfd_boolean
7240 elf32_arm_section_from_shdr (bfd *abfd,
7241                              Elf_Internal_Shdr * hdr,
7242                              const char *name,
7243                              int shindex)
7244 {
7245   /* There ought to be a place to keep ELF backend specific flags, but
7246      at the moment there isn't one.  We just keep track of the
7247      sections by their name, instead.  Fortunately, the ABI gives
7248      names for all the ARM specific sections, so we will probably get
7249      away with this.  */
7250   switch (hdr->sh_type)
7251     {
7252     case SHT_ARM_EXIDX:
7253     case SHT_ARM_PREEMPTMAP:
7254     case SHT_ARM_ATTRIBUTES:
7255       break;
7256
7257     default:
7258       return FALSE;
7259     }
7260
7261   if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
7262     return FALSE;
7263
7264   if (hdr->sh_type == SHT_ARM_ATTRIBUTES)
7265     elf32_arm_parse_attributes(abfd, hdr);
7266   return TRUE;
7267 }
7268
7269 /* A structure used to record a list of sections, independently
7270    of the next and prev fields in the asection structure.  */
7271 typedef struct section_list
7272 {
7273   asection * sec;
7274   struct section_list * next;
7275   struct section_list * prev;
7276 }
7277 section_list;
7278
7279 /* Unfortunately we need to keep a list of sections for which
7280    an _arm_elf_section_data structure has been allocated.  This
7281    is because it is possible for functions like elf32_arm_write_section
7282    to be called on a section which has had an elf_data_structure
7283    allocated for it (and so the used_by_bfd field is valid) but
7284    for which the ARM extended version of this structure - the
7285    _arm_elf_section_data structure - has not been allocated.  */
7286 static section_list * sections_with_arm_elf_section_data = NULL;
7287
7288 static void
7289 record_section_with_arm_elf_section_data (asection * sec)
7290 {
7291   struct section_list * entry;
7292
7293   entry = bfd_malloc (sizeof (* entry));
7294   if (entry == NULL)
7295     return;
7296   entry->sec = sec;
7297   entry->next = sections_with_arm_elf_section_data;
7298   entry->prev = NULL;
7299   if (entry->next != NULL)
7300     entry->next->prev = entry;
7301   sections_with_arm_elf_section_data = entry;
7302 }
7303
7304 static struct section_list *
7305 find_arm_elf_section_entry (asection * sec)
7306 {
7307   struct section_list * entry;
7308   static struct section_list * last_entry = NULL;
7309
7310   /* This is a short cut for the typical case where the sections are added
7311      to the sections_with_arm_elf_section_data list in forward order and
7312      then looked up here in backwards order.  This makes a real difference
7313      to the ld-srec/sec64k.exp linker test.  */
7314   entry = sections_with_arm_elf_section_data;
7315   if (last_entry != NULL)
7316     {
7317       if (last_entry->sec == sec)
7318         entry = last_entry;
7319       else if (last_entry->next != NULL
7320                && last_entry->next->sec == sec)
7321         entry = last_entry->next;
7322     }
7323
7324   for (; entry; entry = entry->next)
7325     if (entry->sec == sec)
7326       break;
7327
7328   if (entry)
7329     /* Record the entry prior to this one - it is the entry we are most
7330        likely to want to locate next time.  Also this way if we have been
7331        called from unrecord_section_with_arm_elf_section_data() we will not
7332        be caching a pointer that is about to be freed.  */
7333     last_entry = entry->prev;
7334
7335   return entry;
7336 }
7337
7338 static _arm_elf_section_data *
7339 get_arm_elf_section_data (asection * sec)
7340 {
7341   struct section_list * entry;
7342
7343   entry = find_arm_elf_section_entry (sec);
7344
7345   if (entry)
7346     return elf32_arm_section_data (entry->sec);
7347   else
7348     return NULL;
7349 }
7350
7351 static void
7352 unrecord_section_with_arm_elf_section_data (asection * sec)
7353 {
7354   struct section_list * entry;
7355
7356   entry = find_arm_elf_section_entry (sec);
7357
7358   if (entry)
7359     {
7360       if (entry->prev != NULL)
7361         entry->prev->next = entry->next;
7362       if (entry->next != NULL)
7363         entry->next->prev = entry->prev;
7364       if (entry == sections_with_arm_elf_section_data)
7365         sections_with_arm_elf_section_data = entry->next;
7366       free (entry);
7367     }
7368 }
7369
7370 /* Called for each symbol.  Builds a section map based on mapping symbols.
7371    Does not alter any of the symbols.  */
7372
7373 static bfd_boolean
7374 elf32_arm_output_symbol_hook (struct bfd_link_info *info,
7375                               const char *name,
7376                               Elf_Internal_Sym *elfsym,
7377                               asection *input_sec,
7378                               struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
7379 {
7380   int mapcount;
7381   elf32_arm_section_map *map;
7382   elf32_arm_section_map *newmap;
7383   _arm_elf_section_data *arm_data;
7384   struct elf32_arm_link_hash_table *globals;
7385
7386   /* Only do this on final link.  */
7387   if (info->relocatable)
7388     return TRUE;
7389
7390   /* Only build a map if we need to byteswap code.  */
7391   globals = elf32_arm_hash_table (info);
7392   if (!globals->byteswap_code)
7393     return TRUE;
7394
7395   /* We only want mapping symbols.  */
7396   if (! bfd_is_arm_mapping_symbol_name (name))
7397     return TRUE;
7398
7399   /* If this section has not been allocated an _arm_elf_section_data
7400      structure then we cannot record anything.  */
7401   arm_data = get_arm_elf_section_data (input_sec);
7402   if (arm_data == NULL)
7403     return TRUE;
7404
7405   mapcount = arm_data->mapcount + 1;
7406   map = arm_data->map;
7407   /* TODO: This may be inefficient, but we probably don't usually have many
7408      mapping symbols per section.  */
7409   newmap = bfd_realloc (map, mapcount * sizeof (* map));
7410   if (newmap != NULL)
7411     {
7412       arm_data->map = newmap;
7413       arm_data->mapcount = mapcount;
7414
7415       map[mapcount - 1].vma = elfsym->st_value;
7416       map[mapcount - 1].type = name[1];
7417     }
7418
7419   return TRUE;
7420 }
7421
7422 /* Allocate target specific section data.  */
7423
7424 static bfd_boolean
7425 elf32_arm_new_section_hook (bfd *abfd, asection *sec)
7426 {
7427   _arm_elf_section_data *sdata;
7428   bfd_size_type amt = sizeof (*sdata);
7429
7430   sdata = bfd_zalloc (abfd, amt);
7431   if (sdata == NULL)
7432     return FALSE;
7433   sec->used_by_bfd = sdata;
7434
7435   record_section_with_arm_elf_section_data (sec);
7436
7437   return _bfd_elf_new_section_hook (abfd, sec);
7438 }
7439
7440
7441 /* Used to order a list of mapping symbols by address.  */
7442
7443 static int
7444 elf32_arm_compare_mapping (const void * a, const void * b)
7445 {
7446   return ((const elf32_arm_section_map *) a)->vma
7447          > ((const elf32_arm_section_map *) b)->vma;
7448 }
7449
7450
7451 /* Do code byteswapping.  Return FALSE afterwards so that the section is
7452    written out as normal.  */
7453
7454 static bfd_boolean
7455 elf32_arm_write_section (bfd *output_bfd ATTRIBUTE_UNUSED, asection *sec,
7456                          bfd_byte *contents)
7457 {
7458   int mapcount;
7459   _arm_elf_section_data *arm_data;
7460   elf32_arm_section_map *map;
7461   bfd_vma ptr;
7462   bfd_vma end;
7463   bfd_vma offset;
7464   bfd_byte tmp;
7465   int i;
7466
7467   /* If this section has not been allocated an _arm_elf_section_data
7468      structure then we cannot record anything.  */
7469   arm_data = get_arm_elf_section_data (sec);
7470   if (arm_data == NULL)
7471     return FALSE;
7472
7473   mapcount = arm_data->mapcount;
7474   map = arm_data->map;
7475
7476   if (mapcount == 0)
7477     return FALSE;
7478
7479   qsort (map, mapcount, sizeof (* map), elf32_arm_compare_mapping);
7480
7481   offset = sec->output_section->vma + sec->output_offset;
7482   ptr = map[0].vma - offset;
7483   for (i = 0; i < mapcount; i++)
7484     {
7485       if (i == mapcount - 1)
7486         end = sec->size;
7487       else
7488         end = map[i + 1].vma - offset;
7489
7490       switch (map[i].type)
7491         {
7492         case 'a':
7493           /* Byte swap code words.  */
7494           while (ptr + 3 < end)
7495             {
7496               tmp = contents[ptr];
7497               contents[ptr] = contents[ptr + 3];
7498               contents[ptr + 3] = tmp;
7499               tmp = contents[ptr + 1];
7500               contents[ptr + 1] = contents[ptr + 2];
7501               contents[ptr + 2] = tmp;
7502               ptr += 4;
7503             }
7504           break;
7505
7506         case 't':
7507           /* Byte swap code halfwords.  */
7508           while (ptr + 1 < end)
7509             {
7510               tmp = contents[ptr];
7511               contents[ptr] = contents[ptr + 1];
7512               contents[ptr + 1] = tmp;
7513               ptr += 2;
7514             }
7515           break;
7516
7517         case 'd':
7518           /* Leave data alone.  */
7519           break;
7520         }
7521       ptr = end;
7522     }
7523
7524   free (map);
7525   arm_data->mapcount = 0;
7526   arm_data->map = NULL;
7527   unrecord_section_with_arm_elf_section_data (sec);
7528
7529   return FALSE;
7530 }
7531
7532 static void
7533 unrecord_section_via_map_over_sections (bfd * abfd ATTRIBUTE_UNUSED,
7534                                         asection * sec,
7535                                         void * ignore ATTRIBUTE_UNUSED)
7536 {
7537   unrecord_section_with_arm_elf_section_data (sec);
7538 }
7539
7540 static bfd_boolean
7541 elf32_arm_close_and_cleanup (bfd * abfd)
7542 {
7543   bfd_map_over_sections (abfd, unrecord_section_via_map_over_sections, NULL);
7544
7545   return _bfd_elf_close_and_cleanup (abfd);
7546 }
7547
7548 /* Display STT_ARM_TFUNC symbols as functions.  */
7549
7550 static void
7551 elf32_arm_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED,
7552                              asymbol *asym)
7553 {
7554   elf_symbol_type *elfsym = (elf_symbol_type *) asym;
7555
7556   if (ELF_ST_TYPE (elfsym->internal_elf_sym.st_info) == STT_ARM_TFUNC)
7557     elfsym->symbol.flags |= BSF_FUNCTION;
7558 }
7559
7560
7561 /* Mangle thumb function symbols as we read them in.  */
7562
7563 static void
7564 elf32_arm_swap_symbol_in (bfd * abfd,
7565                           const void *psrc,
7566                           const void *pshn,
7567                           Elf_Internal_Sym *dst)
7568 {
7569   bfd_elf32_swap_symbol_in (abfd, psrc, pshn, dst);
7570
7571   /* New EABI objects mark thumb function symbols by setting the low bit of
7572      the address.  Turn these into STT_ARM_TFUNC.  */
7573   if (ELF_ST_TYPE (dst->st_info) == STT_FUNC
7574       && (dst->st_value & 1))
7575     {
7576       dst->st_info = ELF_ST_INFO (ELF_ST_BIND (dst->st_info), STT_ARM_TFUNC);
7577       dst->st_value &= ~(bfd_vma) 1;
7578     }
7579 }
7580
7581
7582 /* Mangle thumb function symbols as we write them out.  */
7583
7584 static void
7585 elf32_arm_swap_symbol_out (bfd *abfd,
7586                            const Elf_Internal_Sym *src,
7587                            void *cdst,
7588                            void *shndx)
7589 {
7590   Elf_Internal_Sym newsym;
7591
7592   /* We convert STT_ARM_TFUNC symbols into STT_FUNC with the low bit
7593      of the address set, as per the new EABI.  We do this unconditionally
7594      because objcopy does not set the elf header flags until after
7595      it writes out the symbol table.  */
7596   if (ELF_ST_TYPE (src->st_info) == STT_ARM_TFUNC)
7597     {
7598       newsym = *src;
7599       newsym.st_info = ELF_ST_INFO (ELF_ST_BIND (src->st_info), STT_FUNC);
7600       newsym.st_value |= 1;
7601
7602       src = &newsym;
7603     }
7604   bfd_elf32_swap_symbol_out (abfd, src, cdst, shndx);
7605 }
7606
7607 /* Add the PT_ARM_EXIDX program header.  */
7608
7609 static bfd_boolean
7610 elf32_arm_modify_segment_map (bfd *abfd,
7611                               struct bfd_link_info *info ATTRIBUTE_UNUSED)
7612 {
7613   struct elf_segment_map *m;
7614   asection *sec;
7615
7616   sec = bfd_get_section_by_name (abfd, ".ARM.exidx");
7617   if (sec != NULL && (sec->flags & SEC_LOAD) != 0)
7618     {
7619       /* If there is already a PT_ARM_EXIDX header, then we do not
7620          want to add another one.  This situation arises when running
7621          "strip"; the input binary already has the header.  */
7622       m = elf_tdata (abfd)->segment_map;
7623       while (m && m->p_type != PT_ARM_EXIDX)
7624         m = m->next;
7625       if (!m)
7626         {
7627           m = bfd_zalloc (abfd, sizeof (struct elf_segment_map));
7628           if (m == NULL)
7629             return FALSE;
7630           m->p_type = PT_ARM_EXIDX;
7631           m->count = 1;
7632           m->sections[0] = sec;
7633
7634           m->next = elf_tdata (abfd)->segment_map;
7635           elf_tdata (abfd)->segment_map = m;
7636         }
7637     }
7638
7639   return TRUE;
7640 }
7641
7642 /* We may add a PT_ARM_EXIDX program header.  */
7643
7644 static int
7645 elf32_arm_additional_program_headers (bfd *abfd)
7646 {
7647   asection *sec;
7648
7649   sec = bfd_get_section_by_name (abfd, ".ARM.exidx");
7650   if (sec != NULL && (sec->flags & SEC_LOAD) != 0)
7651     return 1;
7652   else
7653     return 0;
7654 }
7655
7656 /* We use this to override swap_symbol_in and swap_symbol_out.  */
7657 const struct elf_size_info elf32_arm_size_info = {
7658   sizeof (Elf32_External_Ehdr),
7659   sizeof (Elf32_External_Phdr),
7660   sizeof (Elf32_External_Shdr),
7661   sizeof (Elf32_External_Rel),
7662   sizeof (Elf32_External_Rela),
7663   sizeof (Elf32_External_Sym),
7664   sizeof (Elf32_External_Dyn),
7665   sizeof (Elf_External_Note),
7666   4,
7667   1,
7668   32, 2,
7669   ELFCLASS32, EV_CURRENT,
7670   bfd_elf32_write_out_phdrs,
7671   bfd_elf32_write_shdrs_and_ehdr,
7672   bfd_elf32_write_relocs,
7673   elf32_arm_swap_symbol_in,
7674   elf32_arm_swap_symbol_out,
7675   bfd_elf32_slurp_reloc_table,
7676   bfd_elf32_slurp_symbol_table,
7677   bfd_elf32_swap_dyn_in,
7678   bfd_elf32_swap_dyn_out,
7679   bfd_elf32_swap_reloc_in,
7680   bfd_elf32_swap_reloc_out,
7681   bfd_elf32_swap_reloca_in,
7682   bfd_elf32_swap_reloca_out
7683 };
7684
7685 #define ELF_ARCH                        bfd_arch_arm
7686 #define ELF_MACHINE_CODE                EM_ARM
7687 #ifdef __QNXTARGET__
7688 #define ELF_MAXPAGESIZE                 0x1000
7689 #else
7690 #define ELF_MAXPAGESIZE                 0x8000
7691 #endif
7692 #define ELF_MINPAGESIZE                 0x1000
7693
7694 #define bfd_elf32_mkobject                      elf32_arm_mkobject
7695
7696 #define bfd_elf32_bfd_copy_private_bfd_data     elf32_arm_copy_private_bfd_data
7697 #define bfd_elf32_bfd_merge_private_bfd_data    elf32_arm_merge_private_bfd_data
7698 #define bfd_elf32_bfd_set_private_flags         elf32_arm_set_private_flags
7699 #define bfd_elf32_bfd_print_private_bfd_data    elf32_arm_print_private_bfd_data
7700 #define bfd_elf32_bfd_link_hash_table_create    elf32_arm_link_hash_table_create
7701 #define bfd_elf32_bfd_reloc_type_lookup         elf32_arm_reloc_type_lookup
7702 #define bfd_elf32_find_nearest_line             elf32_arm_find_nearest_line
7703 #define bfd_elf32_find_inliner_info             elf32_arm_find_inliner_info
7704 #define bfd_elf32_new_section_hook              elf32_arm_new_section_hook
7705 #define bfd_elf32_bfd_is_target_special_symbol  elf32_arm_is_target_special_symbol
7706 #define bfd_elf32_close_and_cleanup             elf32_arm_close_and_cleanup
7707 #define bfd_elf32_bfd_final_link                elf32_arm_bfd_final_link
7708
7709 #define elf_backend_get_symbol_type             elf32_arm_get_symbol_type
7710 #define elf_backend_gc_mark_hook                elf32_arm_gc_mark_hook
7711 #define elf_backend_gc_sweep_hook               elf32_arm_gc_sweep_hook
7712 #define elf_backend_check_relocs                elf32_arm_check_relocs
7713 #define elf_backend_relocate_section            elf32_arm_relocate_section
7714 #define elf_backend_write_section               elf32_arm_write_section
7715 #define elf_backend_adjust_dynamic_symbol       elf32_arm_adjust_dynamic_symbol
7716 #define elf_backend_create_dynamic_sections     elf32_arm_create_dynamic_sections
7717 #define elf_backend_finish_dynamic_symbol       elf32_arm_finish_dynamic_symbol
7718 #define elf_backend_finish_dynamic_sections     elf32_arm_finish_dynamic_sections
7719 #define elf_backend_link_output_symbol_hook     elf32_arm_output_symbol_hook
7720 #define elf_backend_size_dynamic_sections       elf32_arm_size_dynamic_sections
7721 #define elf_backend_post_process_headers        elf32_arm_post_process_headers
7722 #define elf_backend_reloc_type_class            elf32_arm_reloc_type_class
7723 #define elf_backend_object_p                    elf32_arm_object_p
7724 #define elf_backend_section_flags               elf32_arm_section_flags
7725 #define elf_backend_fake_sections               elf32_arm_fake_sections
7726 #define elf_backend_section_from_shdr           elf32_arm_section_from_shdr
7727 #define elf_backend_final_write_processing      elf32_arm_final_write_processing
7728 #define elf_backend_copy_indirect_symbol        elf32_arm_copy_indirect_symbol
7729 #define elf_backend_symbol_processing           elf32_arm_symbol_processing
7730 #define elf_backend_size_info                   elf32_arm_size_info
7731 #define elf_backend_modify_segment_map          elf32_arm_modify_segment_map
7732 #define elf_backend_additional_program_headers \
7733   elf32_arm_additional_program_headers
7734
7735 #define elf_backend_can_refcount    1
7736 #define elf_backend_can_gc_sections 1
7737 #define elf_backend_plt_readonly    1
7738 #define elf_backend_want_got_plt    1
7739 #define elf_backend_want_plt_sym    0
7740 #define elf_backend_may_use_rel_p   1
7741 #define elf_backend_may_use_rela_p  0
7742 #define elf_backend_default_use_rela_p 0
7743 #define elf_backend_rela_normal     0
7744
7745 #define elf_backend_got_header_size     12
7746
7747 #include "elf32-target.h"
7748
7749 /* VxWorks Targets */
7750
7751 #undef TARGET_LITTLE_SYM
7752 #define TARGET_LITTLE_SYM               bfd_elf32_littlearm_vxworks_vec
7753 #undef TARGET_LITTLE_NAME
7754 #define TARGET_LITTLE_NAME              "elf32-littlearm-vxworks"
7755 #undef TARGET_BIG_SYM
7756 #define TARGET_BIG_SYM                  bfd_elf32_bigarm_vxworks_vec
7757 #undef TARGET_BIG_NAME
7758 #define TARGET_BIG_NAME                 "elf32-bigarm-vxworks"
7759
7760 /* Like elf32_arm_link_hash_table_create -- but overrides
7761    appropriately for VxWorks.  */
7762 static struct bfd_link_hash_table *
7763 elf32_arm_vxworks_link_hash_table_create (bfd *abfd)
7764 {
7765   struct bfd_link_hash_table *ret;
7766
7767   ret = elf32_arm_link_hash_table_create (abfd);
7768   if (ret)
7769     {
7770       struct elf32_arm_link_hash_table *htab
7771         = (struct elf32_arm_link_hash_table *)ret;
7772       htab->use_rel = 0;
7773     }
7774   return ret;
7775 }
7776
7777 #undef elf32_bed
7778 #define elf32_bed elf32_arm_vxworks_bed
7779
7780 #undef bfd_elf32_bfd_link_hash_table_create
7781 #define bfd_elf32_bfd_link_hash_table_create \
7782   elf32_arm_vxworks_link_hash_table_create
7783
7784 #undef elf_backend_may_use_rel_p
7785 #define elf_backend_may_use_rel_p   0
7786 #undef elf_backend_may_use_rela_p
7787 #define elf_backend_may_use_rela_p  1
7788 #undef elf_backend_default_use_rela_p
7789 #define elf_backend_default_use_rela_p 1
7790 #undef elf_backend_rela_normal
7791 #define elf_backend_rela_normal     1
7792
7793 #include "elf32-target.h"
7794
7795
7796 /* Symbian OS Targets */
7797
7798 #undef TARGET_LITTLE_SYM
7799 #define TARGET_LITTLE_SYM               bfd_elf32_littlearm_symbian_vec
7800 #undef TARGET_LITTLE_NAME
7801 #define TARGET_LITTLE_NAME              "elf32-littlearm-symbian"
7802 #undef TARGET_BIG_SYM
7803 #define TARGET_BIG_SYM                  bfd_elf32_bigarm_symbian_vec
7804 #undef TARGET_BIG_NAME
7805 #define TARGET_BIG_NAME                 "elf32-bigarm-symbian"
7806
7807 /* Like elf32_arm_link_hash_table_create -- but overrides
7808    appropriately for Symbian OS.  */
7809 static struct bfd_link_hash_table *
7810 elf32_arm_symbian_link_hash_table_create (bfd *abfd)
7811 {
7812   struct bfd_link_hash_table *ret;
7813
7814   ret = elf32_arm_link_hash_table_create (abfd);
7815   if (ret)
7816     {
7817       struct elf32_arm_link_hash_table *htab
7818         = (struct elf32_arm_link_hash_table *)ret;
7819       /* There is no PLT header for Symbian OS.  */
7820       htab->plt_header_size = 0;
7821       /* The PLT entries are each three instructions.  */
7822       htab->plt_entry_size = 4 * NUM_ELEM (elf32_arm_symbian_plt_entry);
7823       htab->symbian_p = 1;
7824       /* Symbian uses armv5t or above, so use_blx is always true.  */
7825       htab->use_blx = 1;
7826       htab->root.is_relocatable_executable = 1;
7827     }
7828   return ret;
7829 }
7830
7831 static const struct bfd_elf_special_section
7832 elf32_arm_symbian_special_sections[] =
7833 {
7834   /* In a BPABI executable, the dynamic linking sections do not go in
7835      the loadable read-only segment.  The post-linker may wish to
7836      refer to these sections, but they are not part of the final
7837      program image.  */
7838   { ".dynamic",        8,  0, SHT_DYNAMIC,  0 },
7839   { ".dynstr",         7,  0, SHT_STRTAB,   0 },
7840   { ".dynsym",         7,  0, SHT_DYNSYM,   0 },
7841   { ".got",            4,  0, SHT_PROGBITS, 0 },
7842   { ".hash",           5,  0, SHT_HASH,     0 },
7843   /* These sections do not need to be writable as the SymbianOS
7844      postlinker will arrange things so that no dynamic relocation is
7845      required.  */
7846   { ".init_array",    11,  0, SHT_INIT_ARRAY, SHF_ALLOC },
7847   { ".fini_array",    11,  0, SHT_FINI_ARRAY, SHF_ALLOC },
7848   { ".preinit_array", 14,  0, SHT_PREINIT_ARRAY, SHF_ALLOC },
7849   { NULL,              0,  0, 0,            0 }
7850 };
7851
7852 static void
7853 elf32_arm_symbian_begin_write_processing (bfd *abfd,
7854                                           struct bfd_link_info *link_info
7855                                             ATTRIBUTE_UNUSED)
7856 {
7857   /* BPABI objects are never loaded directly by an OS kernel; they are
7858      processed by a postlinker first, into an OS-specific format.  If
7859      the D_PAGED bit is set on the file, BFD will align segments on
7860      page boundaries, so that an OS can directly map the file.  With
7861      BPABI objects, that just results in wasted space.  In addition,
7862      because we clear the D_PAGED bit, map_sections_to_segments will
7863      recognize that the program headers should not be mapped into any
7864      loadable segment.  */
7865   abfd->flags &= ~D_PAGED;
7866 }
7867
7868 static bfd_boolean
7869 elf32_arm_symbian_modify_segment_map (bfd *abfd,
7870                                       struct bfd_link_info *info)
7871 {
7872   struct elf_segment_map *m;
7873   asection *dynsec;
7874
7875   /* BPABI shared libraries and executables should have a PT_DYNAMIC
7876      segment.  However, because the .dynamic section is not marked
7877      with SEC_LOAD, the generic ELF code will not create such a
7878      segment.  */
7879   dynsec = bfd_get_section_by_name (abfd, ".dynamic");
7880   if (dynsec)
7881     {
7882       m = _bfd_elf_make_dynamic_segment (abfd, dynsec);
7883       m->next = elf_tdata (abfd)->segment_map;
7884       elf_tdata (abfd)->segment_map = m;
7885     }
7886
7887   /* Also call the generic arm routine.  */
7888   return elf32_arm_modify_segment_map (abfd, info);
7889 }
7890
7891 #undef elf32_bed
7892 #define elf32_bed elf32_arm_symbian_bed
7893
7894 /* The dynamic sections are not allocated on SymbianOS; the postlinker
7895    will process them and then discard them.  */
7896 #undef ELF_DYNAMIC_SEC_FLAGS
7897 #define ELF_DYNAMIC_SEC_FLAGS \
7898   (SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED)
7899
7900 #undef bfd_elf32_bfd_link_hash_table_create
7901 #define bfd_elf32_bfd_link_hash_table_create \
7902   elf32_arm_symbian_link_hash_table_create
7903
7904 #undef elf_backend_special_sections
7905 #define elf_backend_special_sections elf32_arm_symbian_special_sections
7906
7907 #undef elf_backend_begin_write_processing
7908 #define elf_backend_begin_write_processing \
7909     elf32_arm_symbian_begin_write_processing
7910
7911 #undef elf_backend_modify_segment_map
7912 #define elf_backend_modify_segment_map elf32_arm_symbian_modify_segment_map
7913
7914 /* There is no .got section for BPABI objects, and hence no header.  */
7915 #undef elf_backend_got_header_size
7916 #define elf_backend_got_header_size 0
7917
7918 /* Similarly, there is no .got.plt section.  */
7919 #undef elf_backend_want_got_plt
7920 #define elf_backend_want_got_plt 0
7921
7922 #undef elf_backend_may_use_rel_p
7923 #define elf_backend_may_use_rel_p   1
7924 #undef elf_backend_may_use_rela_p
7925 #define elf_backend_may_use_rela_p  0
7926 #undef elf_backend_default_use_rela_p
7927 #define elf_backend_default_use_rela_p 0
7928 #undef elf_backend_rela_normal
7929 #define elf_backend_rela_normal     0
7930
7931 #include "elf32-target.h"