bfd/elf32-arm.c

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