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                   symbol = elf_section_data (sym_sec->output_section)->dynindx;
2696                   BFD_ASSERT (symbol != 0);
2697                 }
2698               else
2699                 /* On SVR4-ish systems, the dynamic loader cannot
2700                    relocate the text and data segments independently,
2701                    so the symbol does not matter.  */
2702                 symbol = 0;
2703               outrel.r_info = ELF32_R_INFO (symbol, R_ARM_RELATIVE);
2704             }
2705
2706           loc = sreloc->contents;
2707           loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
2708           bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2709
2710           /* If this reloc is against an external symbol, we do not want to
2711              fiddle with the addend.  Otherwise, we need to include the symbol
2712              value so that it becomes an addend for the dynamic reloc.  */
2713           if (! relocate)
2714             return bfd_reloc_ok;
2715
2716           return _bfd_final_link_relocate (howto, input_bfd, input_section,
2717                                            contents, rel->r_offset, value,
2718                                            (bfd_vma) 0);
2719         }
2720       else switch (r_type)
2721         {
2722 #ifndef OLD_ARM_ABI
2723         case R_ARM_XPC25:         /* Arm BLX instruction.  */
2724         case R_ARM_CALL:
2725         case R_ARM_JUMP24:
2726 #endif
2727         case R_ARM_PC24:          /* Arm B/BL instruction */
2728         case R_ARM_PLT32:
2729 #ifndef OLD_ARM_ABI
2730           if (r_type == R_ARM_XPC25)
2731             {
2732               /* Check for Arm calling Arm function.  */
2733               /* FIXME: Should we translate the instruction into a BL
2734                  instruction instead ?  */
2735               if (sym_flags != STT_ARM_TFUNC)
2736                 (*_bfd_error_handler)
2737                   (_("\%B: Warning: Arm BLX instruction targets Arm function '%s'."),
2738                    input_bfd,
2739                    h ? h->root.root.string : "(local)");
2740             }
2741           else
2742 #endif
2743             {
2744               /* Check for Arm calling Thumb function.  */
2745               if (sym_flags == STT_ARM_TFUNC)
2746                 {
2747                   elf32_arm_to_thumb_stub (info, sym_name, input_bfd,
2748                                            output_bfd, input_section,
2749                                            hit_data, sym_sec, rel->r_offset,
2750                                            signed_addend, value);
2751                   return bfd_reloc_ok;
2752                 }
2753             }
2754
2755           /* The ARM ELF ABI says that this reloc is computed as: S - P + A
2756              where:
2757               S is the address of the symbol in the relocation.
2758               P is address of the instruction being relocated.
2759               A is the addend (extracted from the instruction) in bytes.
2760
2761              S is held in 'value'.
2762              P is the base address of the section containing the
2763                instruction plus the offset of the reloc into that
2764                section, ie:
2765                  (input_section->output_section->vma +
2766                   input_section->output_offset +
2767                   rel->r_offset).
2768              A is the addend, converted into bytes, ie:
2769                  (signed_addend * 4)
2770
2771              Note: None of these operations have knowledge of the pipeline
2772              size of the processor, thus it is up to the assembler to
2773              encode this information into the addend.  */
2774           value -= (input_section->output_section->vma
2775                     + input_section->output_offset);
2776           value -= rel->r_offset;
2777           if (globals->use_rel)
2778             value += (signed_addend << howto->size);
2779           else
2780             /* RELA addends do not have to be adjusted by howto->size.  */
2781             value += signed_addend;
2782
2783           signed_addend = value;
2784           signed_addend >>= howto->rightshift;
2785
2786           /* It is not an error for an undefined weak reference to be
2787              out of range.  Any program that branches to such a symbol
2788              is going to crash anyway, so there is no point worrying
2789              about getting the destination exactly right.  */
2790           if (! h || h->root.type != bfd_link_hash_undefweak)
2791             {
2792               /* Perform a signed range check.  */
2793               if (   signed_addend >   ((bfd_signed_vma)  (howto->dst_mask >> 1))
2794                   || signed_addend < - ((bfd_signed_vma) ((howto->dst_mask + 1) >> 1)))
2795                 return bfd_reloc_overflow;
2796             }
2797
2798 #ifndef OLD_ARM_ABI
2799           /* If necessary set the H bit in the BLX instruction.  */
2800           if (r_type == R_ARM_XPC25 && ((value & 2) == 2))
2801             value = (signed_addend & howto->dst_mask)
2802               | (bfd_get_32 (input_bfd, hit_data) & (~ howto->dst_mask))
2803               | (1 << 24);
2804           else
2805 #endif
2806             value = (signed_addend & howto->dst_mask)
2807               | (bfd_get_32 (input_bfd, hit_data) & (~ howto->dst_mask));
2808           break;
2809
2810         case R_ARM_ABS32:
2811           value += addend;
2812           if (sym_flags == STT_ARM_TFUNC)
2813             value |= 1;
2814           break;
2815
2816         case R_ARM_REL32:
2817           value -= (input_section->output_section->vma
2818                     + input_section->output_offset + rel->r_offset);
2819           value += addend;
2820           break;
2821
2822 #ifndef OLD_ARM_ABI
2823         case R_ARM_PREL31:
2824           value -= (input_section->output_section->vma
2825                     + input_section->output_offset + rel->r_offset);
2826           value += signed_addend;
2827           if (! h || h->root.type != bfd_link_hash_undefweak)
2828             {
2829               /* Check for overflow */
2830               if ((value ^ (value >> 1)) & (1 << 30))
2831                 return bfd_reloc_overflow;
2832             }
2833           value &= 0x7fffffff;
2834           value |= (bfd_get_32 (input_bfd, hit_data) & 0x80000000);
2835           if (sym_flags == STT_ARM_TFUNC)
2836             value |= 1;
2837           break;
2838 #endif
2839         }
2840
2841       bfd_put_32 (input_bfd, value, hit_data);
2842       return bfd_reloc_ok;
2843
2844     case R_ARM_ABS8:
2845       value += addend;
2846       if ((long) value > 0x7f || (long) value < -0x80)
2847         return bfd_reloc_overflow;
2848
2849       bfd_put_8 (input_bfd, value, hit_data);
2850       return bfd_reloc_ok;
2851
2852     case R_ARM_ABS16:
2853       value += addend;
2854
2855       if ((long) value > 0x7fff || (long) value < -0x8000)
2856         return bfd_reloc_overflow;
2857
2858       bfd_put_16 (input_bfd, value, hit_data);
2859       return bfd_reloc_ok;
2860
2861     case R_ARM_ABS12:
2862       /* Support ldr and str instruction for the arm */
2863       /* Also thumb b (unconditional branch).  ??? Really?  */
2864       value += addend;
2865
2866       if ((long) value > 0x7ff || (long) value < -0x800)
2867         return bfd_reloc_overflow;
2868
2869       value |= (bfd_get_32 (input_bfd, hit_data) & 0xfffff000);
2870       bfd_put_32 (input_bfd, value, hit_data);
2871       return bfd_reloc_ok;
2872
2873     case R_ARM_THM_ABS5:
2874       /* Support ldr and str instructions for the thumb.  */
2875       if (globals->use_rel)
2876         {
2877           /* Need to refetch addend.  */
2878           addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
2879           /* ??? Need to determine shift amount from operand size.  */
2880           addend >>= howto->rightshift;
2881         }
2882       value += addend;
2883
2884       /* ??? Isn't value unsigned?  */
2885       if ((long) value > 0x1f || (long) value < -0x10)
2886         return bfd_reloc_overflow;
2887
2888       /* ??? Value needs to be properly shifted into place first.  */
2889       value |= bfd_get_16 (input_bfd, hit_data) & 0xf83f;
2890       bfd_put_16 (input_bfd, value, hit_data);
2891       return bfd_reloc_ok;
2892
2893 #ifndef OLD_ARM_ABI
2894     case R_ARM_THM_XPC22:
2895 #endif
2896     case R_ARM_THM_PC22:
2897       /* Thumb BL (branch long instruction).  */
2898       {
2899         bfd_vma relocation;
2900         bfd_boolean overflow = FALSE;
2901         bfd_vma upper_insn = bfd_get_16 (input_bfd, hit_data);
2902         bfd_vma lower_insn = bfd_get_16 (input_bfd, hit_data + 2);
2903         bfd_signed_vma reloc_signed_max = ((1 << (howto->bitsize - 1)) - 1) >> howto->rightshift;
2904         bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
2905         bfd_vma check;
2906         bfd_signed_vma signed_check;
2907         bfd_boolean thumb_plt_call = FALSE;
2908
2909         /* Need to refetch the addend and squish the two 11 bit pieces
2910            together.  */
2911         if (globals->use_rel)
2912           {
2913             bfd_vma upper = upper_insn & 0x7ff;
2914             bfd_vma lower = lower_insn & 0x7ff;
2915             upper = (upper ^ 0x400) - 0x400; /* Sign extend.  */
2916             addend = (upper << 12) | (lower << 1);
2917             signed_addend = addend;
2918           }
2919 #ifndef OLD_ARM_ABI
2920         if (r_type == R_ARM_THM_XPC22)
2921           {
2922             /* Check for Thumb to Thumb call.  */
2923             /* FIXME: Should we translate the instruction into a BL
2924                instruction instead ?  */
2925             if (sym_flags == STT_ARM_TFUNC)
2926               (*_bfd_error_handler)
2927                 (_("%B: Warning: Thumb BLX instruction targets thumb function '%s'."),
2928                  input_bfd,
2929                  h ? h->root.root.string : "(local)");
2930           }
2931         else
2932 #endif
2933           {
2934             /* If it is not a call to Thumb, assume call to Arm.
2935                If it is a call relative to a section name, then it is not a
2936                function call at all, but rather a long jump.  Calls through
2937                the PLT do not require stubs.  */
2938             if (sym_flags != STT_ARM_TFUNC && sym_flags != STT_SECTION
2939                 && (h == NULL || splt == NULL
2940                     || h->plt.offset == (bfd_vma) -1))
2941               {
2942                 if (elf32_thumb_to_arm_stub
2943                     (info, sym_name, input_bfd, output_bfd, input_section,
2944                      hit_data, sym_sec, rel->r_offset, signed_addend, value))
2945                   return bfd_reloc_ok;
2946                 else
2947                   return bfd_reloc_dangerous;
2948               }
2949           }
2950
2951         /* Handle calls via the PLT.  */
2952         if (h != NULL && splt != NULL && h->plt.offset != (bfd_vma) -1)
2953           {
2954             value = (splt->output_section->vma
2955                      + splt->output_offset
2956                      + h->plt.offset);
2957             if (globals->use_blx)
2958               {
2959                 /* If the Thumb BLX instruction is available, convert the
2960                    BL to a BLX instruction to call the ARM-mode PLT entry.  */
2961                 if ((lower_insn & (0x3 << 11)) == 0x3 << 11)
2962                   {
2963                     lower_insn = (lower_insn & ~(0x3 << 11)) | 0x1 << 11;
2964                     thumb_plt_call = TRUE;
2965                   }
2966               }
2967             else
2968               /* Target the Thumb stub before the ARM PLT entry.  */
2969               value -= PLT_THUMB_STUB_SIZE;
2970             *unresolved_reloc_p = FALSE;
2971           }
2972
2973         relocation = value + signed_addend;
2974
2975         relocation -= (input_section->output_section->vma
2976                        + input_section->output_offset
2977                        + rel->r_offset);
2978
2979         check = relocation >> howto->rightshift;
2980
2981         /* If this is a signed value, the rightshift just dropped
2982            leading 1 bits (assuming twos complement).  */
2983         if ((bfd_signed_vma) relocation >= 0)
2984           signed_check = check;
2985         else
2986           signed_check = check | ~((bfd_vma) -1 >> howto->rightshift);
2987
2988         /* Assumes two's complement.  */
2989         if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
2990           overflow = TRUE;
2991
2992 #ifndef OLD_ARM_ABI
2993         if ((r_type == R_ARM_THM_XPC22
2994              && ((lower_insn & 0x1800) == 0x0800))
2995             || thumb_plt_call)
2996           /* For a BLX instruction, make sure that the relocation is rounded up
2997              to a word boundary.  This follows the semantics of the instruction
2998              which specifies that bit 1 of the target address will come from bit
2999              1 of the base address.  */
3000           relocation = (relocation + 2) & ~ 3;
3001 #endif
3002         /* Put RELOCATION back into the insn.  */
3003         upper_insn = (upper_insn & ~(bfd_vma) 0x7ff) | ((relocation >> 12) & 0x7ff);
3004         lower_insn = (lower_insn & ~(bfd_vma) 0x7ff) | ((relocation >> 1) & 0x7ff);
3005
3006         /* Put the relocated value back in the object file:  */
3007         bfd_put_16 (input_bfd, upper_insn, hit_data);
3008         bfd_put_16 (input_bfd, lower_insn, hit_data + 2);
3009
3010         return (overflow ? bfd_reloc_overflow : bfd_reloc_ok);
3011       }
3012       break;
3013
3014     case R_ARM_THM_PC11:
3015     case R_ARM_THM_PC9:
3016       /* Thumb B (branch) instruction).  */
3017       {
3018         bfd_signed_vma relocation;
3019         bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
3020         bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
3021         bfd_signed_vma signed_check;
3022
3023         if (globals->use_rel)
3024           {
3025             /* Need to refetch addend.  */
3026             addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
3027             if (addend & ((howto->src_mask + 1) >> 1))
3028               {
3029                 signed_addend = -1;
3030                 signed_addend &= ~ howto->src_mask;
3031                 signed_addend |= addend;
3032               }
3033             else
3034               signed_addend = addend;
3035             /* The value in the insn has been right shifted.  We need to
3036                undo this, so that we can perform the address calculation
3037                in terms of bytes.  */
3038             signed_addend <<= howto->rightshift;
3039           }
3040         relocation = value + signed_addend;
3041
3042         relocation -= (input_section->output_section->vma
3043                        + input_section->output_offset
3044                        + rel->r_offset);
3045
3046         relocation >>= howto->rightshift;
3047         signed_check = relocation;
3048         relocation &= howto->dst_mask;
3049         relocation |= (bfd_get_16 (input_bfd, hit_data) & (~ howto->dst_mask));
3050
3051         bfd_put_16 (input_bfd, relocation, hit_data);
3052
3053         /* Assumes two's complement.  */
3054         if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
3055           return bfd_reloc_overflow;
3056
3057         return bfd_reloc_ok;
3058       }
3059
3060 #ifndef OLD_ARM_ABI
3061     case R_ARM_ALU_PCREL7_0:
3062     case R_ARM_ALU_PCREL15_8:
3063     case R_ARM_ALU_PCREL23_15:
3064       {
3065         bfd_vma insn;
3066         bfd_vma relocation;
3067
3068         insn = bfd_get_32 (input_bfd, hit_data);
3069         if (globals->use_rel)
3070           {
3071             /* Extract the addend.  */
3072             addend = (insn & 0xff) << ((insn & 0xf00) >> 7);
3073             signed_addend = addend;
3074           }
3075         relocation = value + signed_addend;
3076
3077         relocation -= (input_section->output_section->vma
3078                        + input_section->output_offset
3079                        + rel->r_offset);
3080         insn = (insn & ~0xfff)
3081                | ((howto->bitpos << 7) & 0xf00)
3082                | ((relocation >> howto->bitpos) & 0xff);
3083         bfd_put_32 (input_bfd, value, hit_data);
3084       }
3085       return bfd_reloc_ok;
3086 #endif
3087
3088     case R_ARM_GNU_VTINHERIT:
3089     case R_ARM_GNU_VTENTRY:
3090       return bfd_reloc_ok;
3091
3092     case R_ARM_COPY:
3093       return bfd_reloc_notsupported;
3094
3095     case R_ARM_GLOB_DAT:
3096       return bfd_reloc_notsupported;
3097
3098     case R_ARM_JUMP_SLOT:
3099       return bfd_reloc_notsupported;
3100
3101     case R_ARM_RELATIVE:
3102       return bfd_reloc_notsupported;
3103
3104     case R_ARM_GOTOFF:
3105       /* Relocation is relative to the start of the
3106          global offset table.  */
3107
3108       BFD_ASSERT (sgot != NULL);
3109       if (sgot == NULL)
3110         return bfd_reloc_notsupported;
3111
3112       /* If we are addressing a Thumb function, we need to adjust the
3113          address by one, so that attempts to call the function pointer will
3114          correctly interpret it as Thumb code.  */
3115       if (sym_flags == STT_ARM_TFUNC)
3116         value += 1;
3117
3118       /* Note that sgot->output_offset is not involved in this
3119          calculation.  We always want the start of .got.  If we
3120          define _GLOBAL_OFFSET_TABLE in a different way, as is
3121          permitted by the ABI, we might have to change this
3122          calculation.  */
3123       value -= sgot->output_section->vma;
3124       return _bfd_final_link_relocate (howto, input_bfd, input_section,
3125                                        contents, rel->r_offset, value,
3126                                        (bfd_vma) 0);
3127
3128     case R_ARM_GOTPC:
3129       /* Use global offset table as symbol value.  */
3130       BFD_ASSERT (sgot != NULL);
3131
3132       if (sgot == NULL)
3133         return bfd_reloc_notsupported;
3134
3135       *unresolved_reloc_p = FALSE;
3136       value = sgot->output_section->vma;
3137       return _bfd_final_link_relocate (howto, input_bfd, input_section,
3138                                        contents, rel->r_offset, value,
3139                                        (bfd_vma) 0);
3140
3141     case R_ARM_GOT32:
3142 #ifndef OLD_ARM_ABI
3143     case R_ARM_GOT_PREL:
3144 #endif
3145       /* Relocation is to the entry for this symbol in the
3146          global offset table.  */
3147       if (sgot == NULL)
3148         return bfd_reloc_notsupported;
3149
3150       if (h != NULL)
3151         {
3152           bfd_vma off;
3153           bfd_boolean dyn;
3154
3155           off = h->got.offset;
3156           BFD_ASSERT (off != (bfd_vma) -1);
3157           dyn = globals->root.dynamic_sections_created;
3158
3159           if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
3160               || (info->shared
3161                   && SYMBOL_REFERENCES_LOCAL (info, h))
3162               || (ELF_ST_VISIBILITY (h->other)
3163                   && h->root.type == bfd_link_hash_undefweak))
3164             {
3165               /* This is actually a static link, or it is a -Bsymbolic link
3166                  and the symbol is defined locally.  We must initialize this
3167                  entry in the global offset table.  Since the offset must
3168                  always be a multiple of 4, we use the least significant bit
3169                  to record whether we have initialized it already.
3170
3171                  When doing a dynamic link, we create a .rel.got relocation
3172                  entry to initialize the value.  This is done in the
3173                  finish_dynamic_symbol routine.  */
3174               if ((off & 1) != 0)
3175                 off &= ~1;
3176               else
3177                 {
3178                   /* If we are addressing a Thumb function, we need to
3179                      adjust the address by one, so that attempts to
3180                      call the function pointer will correctly
3181                      interpret it as Thumb code.  */
3182                   if (sym_flags == STT_ARM_TFUNC)
3183                     value |= 1;
3184
3185                   bfd_put_32 (output_bfd, value, sgot->contents + off);
3186                   h->got.offset |= 1;
3187                 }
3188             }
3189           else
3190             *unresolved_reloc_p = FALSE;
3191
3192           value = sgot->output_offset + off;
3193         }
3194       else
3195         {
3196           bfd_vma off;
3197
3198           BFD_ASSERT (local_got_offsets != NULL &&
3199                       local_got_offsets[r_symndx] != (bfd_vma) -1);
3200
3201           off = local_got_offsets[r_symndx];
3202
3203           /* The offset must always be a multiple of 4.  We use the
3204              least significant bit to record whether we have already
3205              generated the necessary reloc.  */
3206           if ((off & 1) != 0)
3207             off &= ~1;
3208           else
3209             {
3210               /* If we are addressing a Thumb function, we need to
3211                  adjust the address by one, so that attempts to
3212                  call the function pointer will correctly
3213                  interpret it as Thumb code.  */
3214               if (sym_flags == STT_ARM_TFUNC)
3215                 value |= 1;
3216
3217               bfd_put_32 (output_bfd, value, sgot->contents + off);
3218
3219               if (info->shared)
3220                 {
3221                   asection * srelgot;
3222                   Elf_Internal_Rela outrel;
3223                   bfd_byte *loc;
3224
3225                   srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
3226                   BFD_ASSERT (srelgot != NULL);
3227
3228                   outrel.r_offset = (sgot->output_section->vma
3229                                      + sgot->output_offset
3230                                      + off);
3231                   outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
3232                   loc = srelgot->contents;
3233                   loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
3234                   bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3235                 }
3236
3237               local_got_offsets[r_symndx] |= 1;
3238             }
3239
3240           value = sgot->output_offset + off;
3241         }
3242       if (r_type != R_ARM_GOT32)
3243         value += sgot->output_section->vma;
3244
3245       return _bfd_final_link_relocate (howto, input_bfd, input_section,
3246                                        contents, rel->r_offset, value,
3247                                        (bfd_vma) 0);
3248
3249     case R_ARM_TLS_LDO32:
3250       value = value - dtpoff_base (info);
3251
3252       return _bfd_final_link_relocate (howto, input_bfd, input_section,
3253                                        contents, rel->r_offset, value, (bfd_vma) 0);
3254
3255     case R_ARM_TLS_LDM32:
3256       {
3257         bfd_vma off;
3258
3259         if (globals->sgot == NULL)
3260           abort ();
3261
3262         off = globals->tls_ldm_got.offset;
3263
3264         if ((off & 1) != 0)
3265           off &= ~1;
3266         else
3267           {
3268             /* If we don't know the module number, create a relocation
3269                for it.  */
3270             if (info->shared)
3271               {
3272                 Elf_Internal_Rela outrel;
3273                 bfd_byte *loc;
3274
3275                 if (globals->srelgot == NULL)
3276                   abort ();
3277
3278                 outrel.r_offset = (globals->sgot->output_section->vma
3279                                    + globals->sgot->output_offset + off);
3280                 outrel.r_info = ELF32_R_INFO (0, R_ARM_TLS_DTPMOD32);
3281
3282                 bfd_put_32 (output_bfd, 0, globals->sgot->contents + off);
3283
3284                 loc = globals->srelgot->contents;
3285                 loc += globals->srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
3286                 bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3287               }
3288             else
3289               bfd_put_32 (output_bfd, 1, globals->sgot->contents + off);
3290
3291             globals->tls_ldm_got.offset |= 1;
3292           }
3293
3294         value = globals->sgot->output_section->vma + globals->sgot->output_offset + off
3295           - (input_section->output_section->vma + input_section->output_offset + rel->r_offset);
3296
3297         return _bfd_final_link_relocate (howto, input_bfd, input_section,
3298                                          contents, rel->r_offset, value,
3299                                          (bfd_vma) 0);
3300       }
3301
3302     case R_ARM_TLS_GD32:
3303     case R_ARM_TLS_IE32:
3304       {
3305         bfd_vma off;
3306         int indx;
3307         char tls_type;
3308
3309         if (globals->sgot == NULL)
3310           abort ();
3311
3312         indx = 0;
3313         if (h != NULL)
3314           {
3315             bfd_boolean dyn;
3316             dyn = globals->root.dynamic_sections_created;
3317             if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
3318                 && (!info->shared
3319                     || !SYMBOL_REFERENCES_LOCAL (info, h)))
3320               {
3321                 *unresolved_reloc_p = FALSE;
3322                 indx = h->dynindx;
3323               }
3324             off = h->got.offset;
3325             tls_type = ((struct elf32_arm_link_hash_entry *) h)->tls_type;
3326           }
3327         else
3328           {
3329             if (local_got_offsets == NULL)
3330               abort ();
3331             off = local_got_offsets[r_symndx];
3332             tls_type = elf32_arm_local_got_tls_type (input_bfd)[r_symndx];
3333           }
3334
3335         if (tls_type == GOT_UNKNOWN)
3336           abort ();
3337
3338         if ((off & 1) != 0)
3339           off &= ~1;
3340         else
3341           {
3342             bfd_boolean need_relocs = FALSE;
3343             Elf_Internal_Rela outrel;
3344             bfd_byte *loc = NULL;
3345             int cur_off = off;
3346
3347             /* The GOT entries have not been initialized yet.  Do it
3348                now, and emit any relocations.  If both an IE GOT and a
3349                GD GOT are necessary, we emit the GD first.  */
3350
3351             if ((info->shared || indx != 0)
3352                 && (h == NULL
3353                     || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3354                     || h->root.type != bfd_link_hash_undefweak))
3355               {
3356                 need_relocs = TRUE;
3357                 if (globals->srelgot == NULL)
3358                   abort ();
3359                 loc = globals->srelgot->contents;
3360                 loc += globals->srelgot->reloc_count * sizeof (Elf32_External_Rel);
3361               }
3362
3363             if (tls_type & GOT_TLS_GD)
3364               {
3365                 if (need_relocs)
3366                   {
3367                     outrel.r_offset = (globals->sgot->output_section->vma
3368                                        + globals->sgot->output_offset + cur_off);
3369                     outrel.r_info = ELF32_R_INFO (indx, R_ARM_TLS_DTPMOD32);
3370                     bfd_put_32 (output_bfd, 0, globals->sgot->contents + cur_off);
3371
3372                     bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3373                     globals->srelgot->reloc_count++;
3374                     loc += sizeof (Elf32_External_Rel);
3375
3376                     if (indx == 0)
3377                       bfd_put_32 (output_bfd, value - dtpoff_base (info),
3378                                   globals->sgot->contents + cur_off + 4);
3379                     else
3380                       {
3381                         bfd_put_32 (output_bfd, 0,
3382                                     globals->sgot->contents + cur_off + 4);
3383
3384                         outrel.r_info = ELF32_R_INFO (indx,
3385                                                       R_ARM_TLS_DTPOFF32);
3386                         outrel.r_offset += 4;
3387                         bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3388                         globals->srelgot->reloc_count++;
3389                         loc += sizeof (Elf32_External_Rel);
3390                       }
3391                   }
3392                 else
3393                   {
3394                     /* If we are not emitting relocations for a
3395                        general dynamic reference, then we must be in a
3396                        static link or an executable link with the
3397                        symbol binding locally.  Mark it as belonging
3398                        to module 1, the executable.  */
3399                     bfd_put_32 (output_bfd, 1,
3400                                 globals->sgot->contents + cur_off);
3401                     bfd_put_32 (output_bfd, value - dtpoff_base (info),
3402                                 globals->sgot->contents + cur_off + 4);
3403                   }
3404
3405                 cur_off += 8;
3406               }
3407
3408             if (tls_type & GOT_TLS_IE)
3409               {
3410                 if (need_relocs)
3411                   {
3412                     outrel.r_offset = (globals->sgot->output_section->vma
3413                                        + globals->sgot->output_offset
3414                                        + cur_off);
3415                     outrel.r_info = ELF32_R_INFO (indx, R_ARM_TLS_TPOFF32);
3416
3417                     if (indx == 0)
3418                       bfd_put_32 (output_bfd, value - dtpoff_base (info),
3419                                   globals->sgot->contents + cur_off);
3420                     else
3421                       bfd_put_32 (output_bfd, 0,
3422                                   globals->sgot->contents + cur_off);
3423
3424                     bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
3425                     globals->srelgot->reloc_count++;
3426                     loc += sizeof (Elf32_External_Rel);
3427                   }
3428                 else
3429                   bfd_put_32 (output_bfd, tpoff (info, value),
3430                               globals->sgot->contents + cur_off);
3431                 cur_off += 4;
3432               }
3433
3434             if (h != NULL)
3435               h->got.offset |= 1;
3436             else
3437               local_got_offsets[r_symndx] |= 1;
3438           }
3439
3440         if ((tls_type & GOT_TLS_GD) && r_type != R_ARM_TLS_GD32)
3441           off += 8;
3442         value = globals->sgot->output_section->vma + globals->sgot->output_offset + off
3443           - (input_section->output_section->vma + input_section->output_offset + rel->r_offset);
3444
3445         return _bfd_final_link_relocate (howto, input_bfd, input_section,
3446                                          contents, rel->r_offset, value,
3447                                          (bfd_vma) 0);
3448       }
3449
3450     case R_ARM_TLS_LE32:
3451       if (info->shared)
3452         {
3453           (*_bfd_error_handler)
3454             (_("%B(%A+0x%lx): R_ARM_TLS_LE32 relocation not permitted in shared object"),
3455              input_bfd, input_section,
3456              (long) rel->r_offset, howto->name);
3457           return FALSE;
3458         }
3459       else
3460         value = tpoff (info, value);
3461
3462       return _bfd_final_link_relocate (howto, input_bfd, input_section,
3463                                        contents, rel->r_offset, value, (bfd_vma) 0);
3464
3465     case R_ARM_SBREL32:
3466       return bfd_reloc_notsupported;
3467
3468     case R_ARM_AMP_VCALL9:
3469       return bfd_reloc_notsupported;
3470
3471     case R_ARM_RSBREL32:
3472       return bfd_reloc_notsupported;
3473
3474     case R_ARM_THM_RPC22:
3475       return bfd_reloc_notsupported;
3476
3477     case R_ARM_RREL32:
3478       return bfd_reloc_notsupported;
3479
3480     case R_ARM_RABS32:
3481       return bfd_reloc_notsupported;
3482
3483     case R_ARM_RPC24:
3484       return bfd_reloc_notsupported;
3485
3486     case R_ARM_RBASE:
3487       return bfd_reloc_notsupported;
3488
3489     case R_ARM_V4BX:
3490       if (globals->fix_v4bx)
3491         {
3492           bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
3493
3494           /* Ensure that we have a BX instruction.  */
3495           BFD_ASSERT ((insn & 0x0ffffff0) == 0x012fff10);
3496
3497           /* Preserve Rm (lowest four bits) and the condition code
3498              (highest four bits). Other bits encode MOV PC,Rm.  */
3499           insn = (insn & 0xf000000f) | 0x01a0f000;
3500
3501           bfd_put_32 (input_bfd, insn, hit_data);
3502         }
3503       return bfd_reloc_ok;
3504
3505     default:
3506       return bfd_reloc_notsupported;
3507     }
3508 }
3509
3510 /* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS.  */
3511 static void
3512 arm_add_to_rel (bfd *              abfd,
3513                 bfd_byte *         address,
3514                 reloc_howto_type * howto,
3515                 bfd_signed_vma     increment)
3516 {
3517   bfd_signed_vma addend;
3518
3519   if (howto->type == R_ARM_THM_PC22)
3520     {
3521       int upper_insn, lower_insn;
3522       int upper, lower;
3523
3524       upper_insn = bfd_get_16 (abfd, address);
3525       lower_insn = bfd_get_16 (abfd, address + 2);
3526       upper = upper_insn & 0x7ff;
3527       lower = lower_insn & 0x7ff;
3528
3529       addend = (upper << 12) | (lower << 1);
3530       addend += increment;
3531       addend >>= 1;
3532
3533       upper_insn = (upper_insn & 0xf800) | ((addend >> 11) & 0x7ff);
3534       lower_insn = (lower_insn & 0xf800) | (addend & 0x7ff);
3535
3536       bfd_put_16 (abfd, (bfd_vma) upper_insn, address);
3537       bfd_put_16 (abfd, (bfd_vma) lower_insn, address + 2);
3538     }
3539   else
3540     {
3541       bfd_vma        contents;
3542
3543       contents = bfd_get_32 (abfd, address);
3544
3545       /* Get the (signed) value from the instruction.  */
3546       addend = contents & howto->src_mask;
3547       if (addend & ((howto->src_mask + 1) >> 1))
3548         {
3549           bfd_signed_vma mask;
3550
3551           mask = -1;
3552           mask &= ~ howto->src_mask;
3553           addend |= mask;
3554         }
3555
3556       /* Add in the increment, (which is a byte value).  */
3557       switch (howto->type)
3558         {
3559         default:
3560           addend += increment;
3561           break;
3562
3563         case R_ARM_PC24:
3564         case R_ARM_PLT32:
3565 #ifndef OLD_ARM_ABI
3566         case R_ARM_CALL:
3567         case R_ARM_JUMP24:
3568 #endif
3569           addend <<= howto->size;
3570           addend += increment;
3571
3572           /* Should we check for overflow here ?  */
3573
3574           /* Drop any undesired bits.  */
3575           addend >>= howto->rightshift;
3576           break;
3577         }
3578
3579       contents = (contents & ~ howto->dst_mask) | (addend & howto->dst_mask);
3580
3581       bfd_put_32 (abfd, contents, address);
3582     }
3583 }
3584
3585 #define IS_ARM_TLS_RELOC(R_TYPE)        \
3586   ((R_TYPE) == R_ARM_TLS_GD32           \
3587    || (R_TYPE) == R_ARM_TLS_LDO32       \
3588    || (R_TYPE) == R_ARM_TLS_LDM32       \
3589    || (R_TYPE) == R_ARM_TLS_DTPOFF32    \
3590    || (R_TYPE) == R_ARM_TLS_DTPMOD32    \
3591    || (R_TYPE) == R_ARM_TLS_TPOFF32     \
3592    || (R_TYPE) == R_ARM_TLS_LE32        \
3593    || (R_TYPE) == R_ARM_TLS_IE32)
3594
3595 /* Relocate an ARM ELF section.  */
3596 static bfd_boolean
3597 elf32_arm_relocate_section (bfd *                  output_bfd,
3598                             struct bfd_link_info * info,
3599                             bfd *                  input_bfd,
3600                             asection *             input_section,
3601                             bfd_byte *             contents,
3602                             Elf_Internal_Rela *    relocs,
3603                             Elf_Internal_Sym *     local_syms,
3604                             asection **            local_sections)
3605 {
3606   Elf_Internal_Shdr *symtab_hdr;
3607   struct elf_link_hash_entry **sym_hashes;
3608   Elf_Internal_Rela *rel;
3609   Elf_Internal_Rela *relend;
3610   const char *name;
3611   struct elf32_arm_link_hash_table * globals;
3612
3613   globals = elf32_arm_hash_table (info);
3614   if (info->relocatable && !globals->use_rel)
3615     return TRUE;
3616
3617   symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
3618   sym_hashes = elf_sym_hashes (input_bfd);
3619
3620   rel = relocs;
3621   relend = relocs + input_section->reloc_count;
3622   for (; rel < relend; rel++)
3623     {
3624       int                          r_type;
3625       reloc_howto_type *           howto;
3626       unsigned long                r_symndx;
3627       Elf_Internal_Sym *           sym;
3628       asection *                   sec;
3629       struct elf_link_hash_entry * h;
3630       bfd_vma                      relocation;
3631       bfd_reloc_status_type        r;
3632       arelent                      bfd_reloc;
3633       char                         sym_type;
3634       bfd_boolean                  unresolved_reloc = FALSE;
3635
3636       r_symndx = ELF32_R_SYM (rel->r_info);
3637       r_type   = ELF32_R_TYPE (rel->r_info);
3638       r_type   = arm_real_reloc_type (globals, r_type);
3639
3640       if (   r_type == R_ARM_GNU_VTENTRY
3641           || r_type == R_ARM_GNU_VTINHERIT)
3642         continue;
3643
3644       bfd_reloc.howto = elf32_arm_howto_from_type (r_type);
3645       howto = bfd_reloc.howto;
3646
3647       if (info->relocatable && globals->use_rel)
3648         {
3649           /* This is a relocatable link.  We don't have to change
3650              anything, unless the reloc is against a section symbol,
3651              in which case we have to adjust according to where the
3652              section symbol winds up in the output section.  */
3653           if (r_symndx < symtab_hdr->sh_info)
3654             {
3655               sym = local_syms + r_symndx;
3656               if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
3657                 {
3658                   sec = local_sections[r_symndx];
3659                   arm_add_to_rel (input_bfd, contents + rel->r_offset,
3660                                   howto,
3661                                   (bfd_signed_vma) (sec->output_offset
3662                                                     + sym->st_value));
3663                 }
3664             }
3665
3666           continue;
3667         }
3668
3669       /* This is a final link.  */
3670       h = NULL;
3671       sym = NULL;
3672       sec = NULL;
3673
3674       if (r_symndx < symtab_hdr->sh_info)
3675         {
3676           sym = local_syms + r_symndx;
3677           sym_type = ELF32_ST_TYPE (sym->st_info);
3678           sec = local_sections[r_symndx];
3679           if (globals->use_rel)
3680             {
3681               relocation = (sec->output_section->vma
3682                             + sec->output_offset
3683                             + sym->st_value);
3684               if ((sec->flags & SEC_MERGE)
3685                        && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
3686                 {
3687                   asection *msec;
3688                   bfd_vma addend, value;
3689
3690                   if (howto->rightshift)
3691                     {
3692                       (*_bfd_error_handler)
3693                         (_("%B(%A+0x%lx): %s relocation against SEC_MERGE section"),
3694                          input_bfd, input_section,
3695                          (long) rel->r_offset, howto->name);
3696                       return FALSE;
3697                     }
3698
3699                   value = bfd_get_32 (input_bfd, contents + rel->r_offset);
3700
3701                   /* Get the (signed) value from the instruction.  */
3702                   addend = value & howto->src_mask;
3703                   if (addend & ((howto->src_mask + 1) >> 1))
3704                     {
3705                       bfd_signed_vma mask;
3706
3707                       mask = -1;
3708                       mask &= ~ howto->src_mask;
3709                       addend |= mask;
3710                     }
3711                   msec = sec;
3712                   addend =
3713                     _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend)
3714                     - relocation;
3715                   addend += msec->output_section->vma + msec->output_offset;
3716                   value = (value & ~ howto->dst_mask) | (addend & howto->dst_mask);
3717                   bfd_put_32 (input_bfd, value, contents + rel->r_offset);
3718                 }
3719             }
3720           else
3721             relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
3722         }
3723       else
3724         {
3725           bfd_boolean warned;
3726
3727           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
3728                                    r_symndx, symtab_hdr, sym_hashes,
3729                                    h, sec, relocation,
3730                                    unresolved_reloc, warned);
3731
3732           sym_type = h->type;
3733         }
3734
3735       if (h != NULL)
3736         name = h->root.root.string;
3737       else
3738         {
3739           name = (bfd_elf_string_from_elf_section
3740                   (input_bfd, symtab_hdr->sh_link, sym->st_name));
3741           if (name == NULL || *name == '\0')
3742             name = bfd_section_name (input_bfd, sec);
3743         }
3744
3745       if (r_symndx != 0
3746           && r_type != R_ARM_NONE
3747           && (h == NULL
3748               || h->root.type == bfd_link_hash_defined
3749               || h->root.type == bfd_link_hash_defweak)
3750           && IS_ARM_TLS_RELOC (r_type) != (sym_type == STT_TLS))
3751         {
3752           (*_bfd_error_handler)
3753             ((sym_type == STT_TLS
3754               ? _("%B(%A+0x%lx): %s used with TLS symbol %s")
3755               : _("%B(%A+0x%lx): %s used with non-TLS symbol %s")),
3756              input_bfd,
3757              input_section,
3758              (long) rel->r_offset,
3759              howto->name,
3760              name);
3761         }
3762
3763       r = elf32_arm_final_link_relocate (howto, input_bfd, output_bfd,
3764                                          input_section, contents, rel,
3765                                          relocation, info, sec, name,
3766                                          (h ? ELF_ST_TYPE (h->type) :
3767                                           ELF_ST_TYPE (sym->st_info)), h,
3768                                          &unresolved_reloc);
3769
3770       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3771          because such sections are not SEC_ALLOC and thus ld.so will
3772          not process them.  */
3773       if (unresolved_reloc
3774           && !((input_section->flags & SEC_DEBUGGING) != 0
3775                && h->def_dynamic))
3776         {
3777           (*_bfd_error_handler)
3778             (_("%B(%A+0x%lx): warning: unresolvable relocation %d against symbol `%s'"),
3779              input_bfd, input_section, (long) rel->r_offset,
3780              r_type, h->root.root.string);
3781           return FALSE;
3782         }
3783
3784       if (r != bfd_reloc_ok)
3785         {
3786           const char * msg = (const char *) 0;
3787
3788           switch (r)
3789             {
3790             case bfd_reloc_overflow:
3791               /* If the overflowing reloc was to an undefined symbol,
3792                  we have already printed one error message and there
3793                  is no point complaining again.  */
3794               if ((! h ||
3795                    h->root.type != bfd_link_hash_undefined)
3796                   && (!((*info->callbacks->reloc_overflow)
3797                         (info, (h ? &h->root : NULL), name, howto->name,
3798                          (bfd_vma) 0, input_bfd, input_section,
3799                          rel->r_offset))))
3800                   return FALSE;
3801               break;
3802
3803             case bfd_reloc_undefined:
3804               if (!((*info->callbacks->undefined_symbol)
3805                     (info, name, input_bfd, input_section,
3806                      rel->r_offset, TRUE)))
3807                 return FALSE;
3808               break;
3809
3810             case bfd_reloc_outofrange:
3811               msg = _("internal error: out of range error");
3812               goto common_error;
3813
3814             case bfd_reloc_notsupported:
3815               msg = _("internal error: unsupported relocation error");
3816               goto common_error;
3817
3818             case bfd_reloc_dangerous:
3819               msg = _("internal error: dangerous error");
3820               goto common_error;
3821
3822             default:
3823               msg = _("internal error: unknown error");
3824               /* fall through */
3825
3826             common_error:
3827               if (!((*info->callbacks->warning)
3828                     (info, msg, name, input_bfd, input_section,
3829                      rel->r_offset)))
3830                 return FALSE;
3831               break;
3832             }
3833         }
3834     }
3835
3836   return TRUE;
3837 }
3838
3839 /* Set the right machine number.  */
3840
3841 static bfd_boolean
3842 elf32_arm_object_p (bfd *abfd)
3843 {
3844   unsigned int mach;
3845
3846   mach = bfd_arm_get_mach_from_notes (abfd, ARM_NOTE_SECTION);
3847
3848   if (mach != bfd_mach_arm_unknown)
3849     bfd_default_set_arch_mach (abfd, bfd_arch_arm, mach);
3850
3851   else if (elf_elfheader (abfd)->e_flags & EF_ARM_MAVERICK_FLOAT)
3852     bfd_default_set_arch_mach (abfd, bfd_arch_arm, bfd_mach_arm_ep9312);
3853
3854   else
3855     bfd_default_set_arch_mach (abfd, bfd_arch_arm, mach);
3856
3857   return TRUE;
3858 }
3859
3860 /* Function to keep ARM specific flags in the ELF header.  */
3861
3862 static bfd_boolean
3863 elf32_arm_set_private_flags (bfd *abfd, flagword flags)
3864 {
3865   if (elf_flags_init (abfd)
3866       && elf_elfheader (abfd)->e_flags != flags)
3867     {
3868       if (EF_ARM_EABI_VERSION (flags) == EF_ARM_EABI_UNKNOWN)
3869         {
3870           if (flags & EF_ARM_INTERWORK)
3871             (*_bfd_error_handler)
3872               (_("Warning: Not setting interworking flag of %B since it has already been specified as non-interworking"),
3873                abfd);
3874           else
3875             _bfd_error_handler
3876               (_("Warning: Clearing the interworking flag of %B due to outside request"),
3877                abfd);
3878         }
3879     }
3880   else
3881     {
3882       elf_elfheader (abfd)->e_flags = flags;
3883       elf_flags_init (abfd) = TRUE;
3884     }
3885
3886   return TRUE;
3887 }
3888
3889 /* Copy backend specific data from one object module to another.  */
3890
3891 static bfd_boolean
3892 elf32_arm_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
3893 {
3894   flagword in_flags;
3895   flagword out_flags;
3896
3897   if (   bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3898       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
3899     return TRUE;
3900
3901   in_flags  = elf_elfheader (ibfd)->e_flags;
3902   out_flags = elf_elfheader (obfd)->e_flags;
3903
3904   if (elf_flags_init (obfd)
3905       && EF_ARM_EABI_VERSION (out_flags) == EF_ARM_EABI_UNKNOWN
3906       && in_flags != out_flags)
3907     {
3908       /* Cannot mix APCS26 and APCS32 code.  */
3909       if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
3910         return FALSE;
3911
3912       /* Cannot mix float APCS and non-float APCS code.  */
3913       if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
3914         return FALSE;
3915
3916       /* If the src and dest have different interworking flags
3917          then turn off the interworking bit.  */
3918       if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
3919         {
3920           if (out_flags & EF_ARM_INTERWORK)
3921             _bfd_error_handler
3922               (_("Warning: Clearing the interworking flag of %B because non-interworking code in %B has been linked with it"),
3923                obfd, ibfd);
3924
3925           in_flags &= ~EF_ARM_INTERWORK;
3926         }
3927
3928       /* Likewise for PIC, though don't warn for this case.  */
3929       if ((in_flags & EF_ARM_PIC) != (out_flags & EF_ARM_PIC))
3930         in_flags &= ~EF_ARM_PIC;
3931     }
3932
3933   elf_elfheader (obfd)->e_flags = in_flags;
3934   elf_flags_init (obfd) = TRUE;
3935
3936   /* Also copy the EI_OSABI field.  */
3937   elf_elfheader (obfd)->e_ident[EI_OSABI] =
3938     elf_elfheader (ibfd)->e_ident[EI_OSABI];
3939
3940   return TRUE;
3941 }
3942
3943 /* Merge backend specific data from an object file to the output
3944    object file when linking.  */
3945
3946 static bfd_boolean
3947 elf32_arm_merge_private_bfd_data (bfd * ibfd, bfd * obfd)
3948 {
3949   flagword out_flags;
3950   flagword in_flags;
3951   bfd_boolean flags_compatible = TRUE;
3952   asection *sec;
3953
3954   /* Check if we have the same endianess.  */
3955   if (! _bfd_generic_verify_endian_match (ibfd, obfd))
3956     return FALSE;
3957
3958   if (   bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3959       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
3960     return TRUE;
3961
3962   /* The input BFD must have had its flags initialised.  */
3963   /* The following seems bogus to me -- The flags are initialized in
3964      the assembler but I don't think an elf_flags_init field is
3965      written into the object.  */
3966   /* BFD_ASSERT (elf_flags_init (ibfd)); */
3967
3968   in_flags  = elf_elfheader (ibfd)->e_flags;
3969   out_flags = elf_elfheader (obfd)->e_flags;
3970
3971   if (!elf_flags_init (obfd))
3972     {
3973       /* If the input is the default architecture and had the default
3974          flags then do not bother setting the flags for the output
3975          architecture, instead allow future merges to do this.  If no
3976          future merges ever set these flags then they will retain their
3977          uninitialised values, which surprise surprise, correspond
3978          to the default values.  */
3979       if (bfd_get_arch_info (ibfd)->the_default
3980           && elf_elfheader (ibfd)->e_flags == 0)
3981         return TRUE;
3982
3983       elf_flags_init (obfd) = TRUE;
3984       elf_elfheader (obfd)->e_flags = in_flags;
3985
3986       if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
3987           && bfd_get_arch_info (obfd)->the_default)
3988         return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
3989
3990       return TRUE;
3991     }
3992
3993   /* Determine what should happen if the input ARM architecture
3994      does not match the output ARM architecture.  */
3995   if (! bfd_arm_merge_machines (ibfd, obfd))
3996     return FALSE;
3997
3998   /* Identical flags must be compatible.  */
3999   if (in_flags == out_flags)
4000     return TRUE;
4001
4002   /* Check to see if the input BFD actually contains any sections.  If
4003      not, its flags may not have been initialised either, but it
4004      cannot actually cause any incompatibility.  Do not short-circuit
4005      dynamic objects; their section list may be emptied by
4006     elf_link_add_object_symbols.
4007
4008     Also check to see if there are no code sections in the input.
4009     In this case there is no need to check for code specific flags.
4010     XXX - do we need to worry about floating-point format compatability
4011     in data sections ?  */
4012   if (!(ibfd->flags & DYNAMIC))
4013     {
4014       bfd_boolean null_input_bfd = TRUE;
4015       bfd_boolean only_data_sections = TRUE;
4016
4017       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
4018         {
4019           /* Ignore synthetic glue sections.  */
4020           if (strcmp (sec->name, ".glue_7")
4021               && strcmp (sec->name, ".glue_7t"))
4022             {
4023               if ((bfd_get_section_flags (ibfd, sec)
4024                    & (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS))
4025                   == (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS))
4026                 only_data_sections = FALSE;
4027
4028               null_input_bfd = FALSE;
4029               break;
4030             }
4031         }
4032
4033       if (null_input_bfd || only_data_sections)
4034         return TRUE;
4035     }
4036
4037   /* Complain about various flag mismatches.  */
4038   if (EF_ARM_EABI_VERSION (in_flags) != EF_ARM_EABI_VERSION (out_flags))
4039     {
4040       _bfd_error_handler
4041         (_("ERROR: Source object %B has EABI version %d, but target %B has EABI version %d"),
4042          ibfd, obfd,
4043          (in_flags & EF_ARM_EABIMASK) >> 24,
4044          (out_flags & EF_ARM_EABIMASK) >> 24);
4045       return FALSE;
4046     }
4047
4048   /* Not sure what needs to be checked for EABI versions >= 1.  */
4049   if (EF_ARM_EABI_VERSION (in_flags) == EF_ARM_EABI_UNKNOWN)
4050     {
4051       if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
4052         {
4053           _bfd_error_handler
4054             (_("ERROR: %B is compiled for APCS-%d, whereas target %B uses APCS-%d"),
4055              ibfd, obfd,
4056              in_flags & EF_ARM_APCS_26 ? 26 : 32,
4057              out_flags & EF_ARM_APCS_26 ? 26 : 32);
4058           flags_compatible = FALSE;
4059         }
4060
4061       if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
4062         {
4063           if (in_flags & EF_ARM_APCS_FLOAT)
4064             _bfd_error_handler
4065               (_("ERROR: %B passes floats in float registers, whereas %B passes them in integer registers"),
4066                ibfd, obfd);
4067           else
4068             _bfd_error_handler
4069               (_("ERROR: %B passes floats in integer registers, whereas %B passes them in float registers"),
4070                ibfd, obfd);
4071
4072           flags_compatible = FALSE;
4073         }
4074
4075       if ((in_flags & EF_ARM_VFP_FLOAT) != (out_flags & EF_ARM_VFP_FLOAT))
4076         {
4077           if (in_flags & EF_ARM_VFP_FLOAT)
4078             _bfd_error_handler
4079               (_("ERROR: %B uses VFP instructions, whereas %B does not"),
4080                ibfd, obfd);
4081           else
4082             _bfd_error_handler
4083               (_("ERROR: %B uses FPA instructions, whereas %B does not"),
4084                ibfd, obfd);
4085
4086           flags_compatible = FALSE;
4087         }
4088
4089       if ((in_flags & EF_ARM_MAVERICK_FLOAT) != (out_flags & EF_ARM_MAVERICK_FLOAT))
4090         {
4091           if (in_flags & EF_ARM_MAVERICK_FLOAT)
4092             _bfd_error_handler
4093               (_("ERROR: %B uses Maverick instructions, whereas %B does not"),
4094                ibfd, obfd);
4095           else
4096             _bfd_error_handler
4097               (_("ERROR: %B does not use Maverick instructions, whereas %B does"),
4098                ibfd, obfd);
4099
4100           flags_compatible = FALSE;
4101         }
4102
4103 #ifdef EF_ARM_SOFT_FLOAT
4104       if ((in_flags & EF_ARM_SOFT_FLOAT) != (out_flags & EF_ARM_SOFT_FLOAT))
4105         {
4106           /* We can allow interworking between code that is VFP format
4107              layout, and uses either soft float or integer regs for
4108              passing floating point arguments and results.  We already
4109              know that the APCS_FLOAT flags match; similarly for VFP
4110              flags.  */
4111           if ((in_flags & EF_ARM_APCS_FLOAT) != 0
4112               || (in_flags & EF_ARM_VFP_FLOAT) == 0)
4113             {
4114               if (in_flags & EF_ARM_SOFT_FLOAT)
4115                 _bfd_error_handler
4116                   (_("ERROR: %B uses software FP, whereas %B uses hardware FP"),
4117                    ibfd, obfd);
4118               else
4119                 _bfd_error_handler
4120                   (_("ERROR: %B uses hardware FP, whereas %B uses software FP"),
4121                    ibfd, obfd);
4122
4123               flags_compatible = FALSE;
4124             }
4125         }
4126 #endif
4127
4128       /* Interworking mismatch is only a warning.  */
4129       if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
4130         {
4131           if (in_flags & EF_ARM_INTERWORK)
4132             {
4133               _bfd_error_handler
4134                 (_("Warning: %B supports interworking, whereas %B does not"),
4135                  ibfd, obfd);
4136             }
4137           else
4138             {
4139               _bfd_error_handler
4140                 (_("Warning: %B does not support interworking, whereas %B does"),
4141                  ibfd, obfd);
4142             }
4143         }
4144     }
4145
4146   return flags_compatible;
4147 }
4148
4149 /* Display the flags field.  */
4150
4151 static bfd_boolean
4152 elf32_arm_print_private_bfd_data (bfd *abfd, void * ptr)
4153 {
4154   FILE * file = (FILE *) ptr;
4155   unsigned long flags;
4156
4157   BFD_ASSERT (abfd != NULL && ptr != NULL);
4158
4159   /* Print normal ELF private data.  */
4160   _bfd_elf_print_private_bfd_data (abfd, ptr);
4161
4162   flags = elf_elfheader (abfd)->e_flags;
4163   /* Ignore init flag - it may not be set, despite the flags field
4164      containing valid data.  */
4165
4166   /* xgettext:c-format */
4167   fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
4168
4169   switch (EF_ARM_EABI_VERSION (flags))
4170     {
4171     case EF_ARM_EABI_UNKNOWN:
4172       /* The following flag bits are GNU extensions and not part of the
4173          official ARM ELF extended ABI.  Hence they are only decoded if
4174          the EABI version is not set.  */
4175       if (flags & EF_ARM_INTERWORK)
4176         fprintf (file, _(" [interworking enabled]"));
4177
4178       if (flags & EF_ARM_APCS_26)
4179         fprintf (file, " [APCS-26]");
4180       else
4181         fprintf (file, " [APCS-32]");
4182
4183       if (flags & EF_ARM_VFP_FLOAT)
4184         fprintf (file, _(" [VFP float format]"));
4185       else if (flags & EF_ARM_MAVERICK_FLOAT)
4186         fprintf (file, _(" [Maverick float format]"));
4187       else
4188         fprintf (file, _(" [FPA float format]"));
4189
4190       if (flags & EF_ARM_APCS_FLOAT)
4191         fprintf (file, _(" [floats passed in float registers]"));
4192
4193       if (flags & EF_ARM_PIC)
4194         fprintf (file, _(" [position independent]"));
4195
4196       if (flags & EF_ARM_NEW_ABI)
4197         fprintf (file, _(" [new ABI]"));
4198
4199       if (flags & EF_ARM_OLD_ABI)
4200         fprintf (file, _(" [old ABI]"));
4201
4202       if (flags & EF_ARM_SOFT_FLOAT)
4203         fprintf (file, _(" [software FP]"));
4204
4205       flags &= ~(EF_ARM_INTERWORK | EF_ARM_APCS_26 | EF_ARM_APCS_FLOAT
4206                  | EF_ARM_PIC | EF_ARM_NEW_ABI | EF_ARM_OLD_ABI
4207                  | EF_ARM_SOFT_FLOAT | EF_ARM_VFP_FLOAT
4208                  | EF_ARM_MAVERICK_FLOAT);
4209       break;
4210
4211     case EF_ARM_EABI_VER1:
4212       fprintf (file, _(" [Version1 EABI]"));
4213
4214       if (flags & EF_ARM_SYMSARESORTED)
4215         fprintf (file, _(" [sorted symbol table]"));
4216       else
4217         fprintf (file, _(" [unsorted symbol table]"));
4218
4219       flags &= ~ EF_ARM_SYMSARESORTED;
4220       break;
4221
4222     case EF_ARM_EABI_VER2:
4223       fprintf (file, _(" [Version2 EABI]"));
4224
4225       if (flags & EF_ARM_SYMSARESORTED)
4226         fprintf (file, _(" [sorted symbol table]"));
4227       else
4228         fprintf (file, _(" [unsorted symbol table]"));
4229
4230       if (flags & EF_ARM_DYNSYMSUSESEGIDX)
4231         fprintf (file, _(" [dynamic symbols use segment index]"));
4232
4233       if (flags & EF_ARM_MAPSYMSFIRST)
4234         fprintf (file, _(" [mapping symbols precede others]"));
4235
4236       flags &= ~(EF_ARM_SYMSARESORTED | EF_ARM_DYNSYMSUSESEGIDX
4237                  | EF_ARM_MAPSYMSFIRST);
4238       break;
4239
4240     case EF_ARM_EABI_VER3:
4241       fprintf (file, _(" [Version3 EABI]"));
4242       break;
4243
4244     case EF_ARM_EABI_VER4:
4245       fprintf (file, _(" [Version4 EABI]"));
4246
4247       if (flags & EF_ARM_BE8)
4248         fprintf (file, _(" [BE8]"));
4249
4250       if (flags & EF_ARM_LE8)
4251         fprintf (file, _(" [LE8]"));
4252
4253       flags &= ~(EF_ARM_LE8 | EF_ARM_BE8);
4254       break;
4255
4256     default:
4257       fprintf (file, _(" <EABI version unrecognised>"));
4258       break;
4259     }
4260
4261   flags &= ~ EF_ARM_EABIMASK;
4262
4263   if (flags & EF_ARM_RELEXEC)
4264     fprintf (file, _(" [relocatable executable]"));
4265
4266   if (flags & EF_ARM_HASENTRY)
4267     fprintf (file, _(" [has entry point]"));
4268
4269   flags &= ~ (EF_ARM_RELEXEC | EF_ARM_HASENTRY);
4270
4271   if (flags)
4272     fprintf (file, _("<Unrecognised flag bits set>"));
4273
4274   fputc ('\n', file);
4275
4276   return TRUE;
4277 }
4278
4279 static int
4280 elf32_arm_get_symbol_type (Elf_Internal_Sym * elf_sym, int type)
4281 {
4282   switch (ELF_ST_TYPE (elf_sym->st_info))
4283     {
4284     case STT_ARM_TFUNC:
4285       return ELF_ST_TYPE (elf_sym->st_info);
4286
4287     case STT_ARM_16BIT:
4288       /* If the symbol is not an object, return the STT_ARM_16BIT flag.
4289          This allows us to distinguish between data used by Thumb instructions
4290          and non-data (which is probably code) inside Thumb regions of an
4291          executable.  */
4292       if (type != STT_OBJECT)
4293         return ELF_ST_TYPE (elf_sym->st_info);
4294       break;
4295
4296     default:
4297       break;
4298     }
4299
4300   return type;
4301 }
4302
4303 static asection *
4304 elf32_arm_gc_mark_hook (asection *                   sec,
4305                         struct bfd_link_info *       info ATTRIBUTE_UNUSED,
4306                         Elf_Internal_Rela *          rel,
4307                         struct elf_link_hash_entry * h,
4308                         Elf_Internal_Sym *           sym)
4309 {
4310   if (h != NULL)
4311     {
4312       switch (ELF32_R_TYPE (rel->r_info))
4313       {
4314       case R_ARM_GNU_VTINHERIT:
4315       case R_ARM_GNU_VTENTRY:
4316         break;
4317
4318       default:
4319         switch (h->root.type)
4320           {
4321           case bfd_link_hash_defined:
4322           case bfd_link_hash_defweak:
4323             return h->root.u.def.section;
4324
4325           case bfd_link_hash_common:
4326             return h->root.u.c.p->section;
4327
4328           default:
4329             break;
4330           }
4331        }
4332      }
4333    else
4334      return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
4335
4336   return NULL;
4337 }
4338
4339 /* Update the got entry reference counts for the section being removed.  */
4340
4341 static bfd_boolean
4342 elf32_arm_gc_sweep_hook (bfd *                     abfd,
4343                          struct bfd_link_info *    info,
4344                          asection *                sec,
4345                          const Elf_Internal_Rela * relocs)
4346 {
4347   Elf_Internal_Shdr *symtab_hdr;
4348   struct elf_link_hash_entry **sym_hashes;
4349   bfd_signed_vma *local_got_refcounts;
4350   const Elf_Internal_Rela *rel, *relend;
4351   struct elf32_arm_link_hash_table * globals;
4352
4353   globals = elf32_arm_hash_table (info);
4354
4355   elf_section_data (sec)->local_dynrel = NULL;
4356
4357   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
4358   sym_hashes = elf_sym_hashes (abfd);
4359   local_got_refcounts = elf_local_got_refcounts (abfd);
4360
4361   relend = relocs + sec->reloc_count;
4362   for (rel = relocs; rel < relend; rel++)
4363     {
4364       unsigned long r_symndx;
4365       struct elf_link_hash_entry *h = NULL;
4366       int r_type;
4367
4368       r_symndx = ELF32_R_SYM (rel->r_info);
4369       if (r_symndx >= symtab_hdr->sh_info)
4370         {
4371           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4372           while (h->root.type == bfd_link_hash_indirect
4373                  || h->root.type == bfd_link_hash_warning)
4374             h = (struct elf_link_hash_entry *) h->root.u.i.link;
4375         }
4376
4377       r_type = ELF32_R_TYPE (rel->r_info);
4378 #ifndef OLD_ARM_ABI
4379       r_type = arm_real_reloc_type (globals, r_type);
4380 #endif
4381       switch (r_type)
4382         {
4383         case R_ARM_GOT32:
4384 #ifndef OLD_ARM_ABI
4385         case R_ARM_GOT_PREL:
4386 #endif
4387         case R_ARM_TLS_GD32:
4388         case R_ARM_TLS_IE32:
4389           if (h != NULL)
4390             {
4391               if (h->got.refcount > 0)
4392                 h->got.refcount -= 1;
4393             }
4394           else if (local_got_refcounts != NULL)
4395             {
4396               if (local_got_refcounts[r_symndx] > 0)
4397                 local_got_refcounts[r_symndx] -= 1;
4398             }
4399           break;
4400
4401         case R_ARM_TLS_LDM32:
4402           elf32_arm_hash_table (info)->tls_ldm_got.refcount -= 1;
4403           break;
4404
4405         case R_ARM_ABS32:
4406         case R_ARM_REL32:
4407         case R_ARM_PC24:
4408         case R_ARM_PLT32:
4409 #ifndef OLD_ARM_ABI
4410         case R_ARM_CALL:
4411         case R_ARM_JUMP24:
4412         case R_ARM_PREL31:
4413 #endif
4414         case R_ARM_THM_PC22:
4415           /* Should the interworking branches be here also?  */
4416
4417           if (h != NULL)
4418             {
4419               struct elf32_arm_link_hash_entry *eh;
4420               struct elf32_arm_relocs_copied **pp;
4421               struct elf32_arm_relocs_copied *p;
4422
4423               eh = (struct elf32_arm_link_hash_entry *) h;
4424
4425               if (h->plt.refcount > 0)
4426                 {
4427                   h->plt.refcount -= 1;
4428                   if (ELF32_R_TYPE (rel->r_info) == R_ARM_THM_PC22)
4429                     eh->plt_thumb_refcount--;
4430                 }
4431
4432               if (r_type == R_ARM_ABS32
4433                   || r_type == R_ARM_REL32)
4434                 {
4435                   for (pp = &eh->relocs_copied; (p = *pp) != NULL;
4436                        pp = &p->next)
4437                   if (p->section == sec)
4438                     {
4439                       p->count -= 1;
4440                       if (ELF32_R_TYPE (rel->r_info) == R_ARM_REL32)
4441                         p->pc_count -= 1;
4442                       if (p->count == 0)
4443                         *pp = p->next;
4444                       break;
4445                     }
4446                 }
4447             }
4448           break;
4449
4450         default:
4451           break;
4452         }
4453     }
4454
4455   return TRUE;
4456 }
4457
4458 /* Look through the relocs for a section during the first phase.  */
4459
4460 static bfd_boolean
4461 elf32_arm_check_relocs (bfd *abfd, struct bfd_link_info *info,
4462                         asection *sec, const Elf_Internal_Rela *relocs)
4463 {
4464   Elf_Internal_Shdr *symtab_hdr;
4465   struct elf_link_hash_entry **sym_hashes;
4466   struct elf_link_hash_entry **sym_hashes_end;
4467   const Elf_Internal_Rela *rel;
4468   const Elf_Internal_Rela *rel_end;
4469   bfd *dynobj;
4470   asection *sreloc;
4471   bfd_vma *local_got_offsets;
4472   struct elf32_arm_link_hash_table *htab;
4473
4474   if (info->relocatable)
4475     return TRUE;
4476
4477   htab = elf32_arm_hash_table (info);
4478   sreloc = NULL;
4479
4480   /* Create dynamic sections for relocatable executables so that we can
4481      copy relocations.  */
4482   if (htab->root.is_relocatable_executable
4483       && ! htab->root.dynamic_sections_created)
4484     {
4485       if (! _bfd_elf_link_create_dynamic_sections (abfd, info))
4486         return FALSE;
4487     }
4488
4489   dynobj = elf_hash_table (info)->dynobj;
4490   local_got_offsets = elf_local_got_offsets (abfd);
4491
4492   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
4493   sym_hashes = elf_sym_hashes (abfd);
4494   sym_hashes_end = sym_hashes
4495     + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
4496
4497   if (!elf_bad_symtab (abfd))
4498     sym_hashes_end -= symtab_hdr->sh_info;
4499
4500   rel_end = relocs + sec->reloc_count;
4501   for (rel = relocs; rel < rel_end; rel++)
4502     {
4503       struct elf_link_hash_entry *h;
4504       struct elf32_arm_link_hash_entry *eh;
4505       unsigned long r_symndx;
4506       int r_type;
4507
4508       r_symndx = ELF32_R_SYM (rel->r_info);
4509       r_type = ELF32_R_TYPE (rel->r_info);
4510 #ifndef OLD_ARM_ABI
4511       r_type = arm_real_reloc_type (htab, r_type);
4512 #endif
4513
4514       if (r_symndx >= NUM_SHDR_ENTRIES (symtab_hdr))
4515         {
4516           (*_bfd_error_handler) (_("%B: bad symbol index: %d"), abfd,
4517                                  r_symndx);
4518           return FALSE;
4519         }
4520
4521       if (r_symndx < symtab_hdr->sh_info)
4522         h = NULL;
4523       else
4524         h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4525
4526       eh = (struct elf32_arm_link_hash_entry *) h;
4527
4528       switch (r_type)
4529         {
4530           case R_ARM_GOT32:
4531 #ifndef OLD_ARM_ABI
4532           case R_ARM_GOT_PREL:
4533 #endif
4534           case R_ARM_TLS_GD32:
4535           case R_ARM_TLS_IE32:
4536             /* This symbol requires a global offset table entry.  */
4537             {
4538               int tls_type, old_tls_type;
4539
4540               switch (r_type)
4541                 {
4542                 case R_ARM_TLS_GD32: tls_type = GOT_TLS_GD; break;
4543                 case R_ARM_TLS_IE32: tls_type = GOT_TLS_IE; break;
4544                 default: tls_type = GOT_NORMAL; break;
4545                 }
4546
4547               if (h != NULL)
4548                 {
4549                   h->got.refcount++;
4550                   old_tls_type = elf32_arm_hash_entry (h)->tls_type;
4551                 }
4552               else
4553                 {
4554                   bfd_signed_vma *local_got_refcounts;
4555
4556                   /* This is a global offset table entry for a local symbol.  */
4557                   local_got_refcounts = elf_local_got_refcounts (abfd);
4558                   if (local_got_refcounts == NULL)
4559                     {
4560                       bfd_size_type size;
4561
4562                       size = symtab_hdr->sh_info;
4563                       size *= (sizeof (bfd_signed_vma) + sizeof(char));
4564                       local_got_refcounts = bfd_zalloc (abfd, size);
4565                       if (local_got_refcounts == NULL)
4566                         return FALSE;
4567                       elf_local_got_refcounts (abfd) = local_got_refcounts;
4568                       elf32_arm_local_got_tls_type (abfd)
4569                         = (char *) (local_got_refcounts + symtab_hdr->sh_info);
4570                     }
4571                   local_got_refcounts[r_symndx] += 1;
4572                   old_tls_type = elf32_arm_local_got_tls_type (abfd) [r_symndx];
4573                 }
4574
4575               /* We will already have issued an error message if there is a
4576                  TLS / non-TLS mismatch, based on the symbol type.  We don't
4577                  support any linker relaxations.  So just combine any TLS
4578                  types needed.  */
4579               if (old_tls_type != GOT_UNKNOWN && old_tls_type != GOT_NORMAL
4580                   && tls_type != GOT_NORMAL)
4581                 tls_type |= old_tls_type;
4582
4583               if (old_tls_type != tls_type)
4584                 {
4585                   if (h != NULL)
4586                     elf32_arm_hash_entry (h)->tls_type = tls_type;
4587                   else
4588                     elf32_arm_local_got_tls_type (abfd) [r_symndx] = tls_type;
4589                 }
4590             }
4591             /* Fall through */
4592
4593           case R_ARM_TLS_LDM32:
4594             if (r_type == R_ARM_TLS_LDM32)
4595                 htab->tls_ldm_got.refcount++;
4596             /* Fall through */
4597
4598           case R_ARM_GOTOFF:
4599           case R_ARM_GOTPC:
4600             if (htab->sgot == NULL)
4601               {
4602                 if (htab->root.dynobj == NULL)
4603                   htab->root.dynobj = abfd;
4604                 if (!create_got_section (htab->root.dynobj, info))
4605                   return FALSE;
4606               }
4607             break;
4608
4609           case R_ARM_ABS32:
4610           case R_ARM_REL32:
4611           case R_ARM_PC24:
4612           case R_ARM_PLT32:
4613 #ifndef OLD_ARM_ABI
4614           case R_ARM_CALL:
4615           case R_ARM_JUMP24:
4616           case R_ARM_PREL31:
4617 #endif
4618           case R_ARM_THM_PC22:
4619             /* Should the interworking branches be listed here?  */
4620             if (h != NULL)
4621               {
4622                 /* If this reloc is in a read-only section, we might
4623                    need a copy reloc.  We can't check reliably at this
4624                    stage whether the section is read-only, as input
4625                    sections have not yet been mapped to output sections.
4626                    Tentatively set the flag for now, and correct in
4627                    adjust_dynamic_symbol.  */
4628                 if (!info->shared)
4629                   h->non_got_ref = 1;
4630
4631                 /* We may need a .plt entry if the function this reloc
4632                    refers to is in a different object.  We can't tell for
4633                    sure yet, because something later might force the
4634                    symbol local.  */
4635                 if (r_type == R_ARM_PC24
4636 #ifndef OLD_ARM_ABI
4637                     || r_type == R_ARM_CALL
4638                     || r_type == R_ARM_JUMP24
4639                     || r_type == R_ARM_PREL31
4640 #endif
4641                     || r_type == R_ARM_PLT32
4642                     || r_type == R_ARM_THM_PC22)
4643                   h->needs_plt = 1;
4644
4645                 /* If we create a PLT entry, this relocation will reference
4646                    it, even if it's an ABS32 relocation.  */
4647                 h->plt.refcount += 1;
4648
4649                 if (r_type == R_ARM_THM_PC22)
4650                   eh->plt_thumb_refcount += 1;
4651               }
4652
4653             /* If we are creating a shared library or relocatable executable,
4654                and this is a reloc against a global symbol, or a non PC
4655                relative reloc against a local symbol, then we need to copy
4656                the reloc into the shared library.  However, if we are linking
4657                with -Bsymbolic, we do not need to copy a reloc against a
4658                global symbol which is defined in an object we are
4659                including in the link (i.e., DEF_REGULAR is set).  At
4660                this point we have not seen all the input files, so it is
4661                possible that DEF_REGULAR is not set now but will be set
4662                later (it is never cleared).  We account for that
4663                possibility below by storing information in the
4664                relocs_copied field of the hash table entry.  */
4665             if ((info->shared || htab->root.is_relocatable_executable)
4666                 && (sec->flags & SEC_ALLOC) != 0
4667                 && (r_type == R_ARM_ABS32
4668                     || (h != NULL && ! h->needs_plt
4669                         && (! info->symbolic || ! h->def_regular))))
4670               {
4671                 struct elf32_arm_relocs_copied *p, **head;
4672
4673                 /* When creating a shared object, we must copy these
4674                    reloc types into the output file.  We create a reloc
4675                    section in dynobj and make room for this reloc.  */
4676                 if (sreloc == NULL)
4677                   {
4678                     const char * name;
4679
4680                     name = (bfd_elf_string_from_elf_section
4681                             (abfd,
4682                              elf_elfheader (abfd)->e_shstrndx,
4683                              elf_section_data (sec)->rel_hdr.sh_name));
4684                     if (name == NULL)
4685                       return FALSE;
4686
4687                     BFD_ASSERT (strncmp (name, ".rel", 4) == 0
4688                                 && strcmp (bfd_get_section_name (abfd, sec),
4689                                            name + 4) == 0);
4690
4691                     sreloc = bfd_get_section_by_name (dynobj, name);
4692                     if (sreloc == NULL)
4693                       {
4694                         flagword flags;
4695
4696                         flags = (SEC_HAS_CONTENTS | SEC_READONLY
4697                                  | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4698                         if ((sec->flags & SEC_ALLOC) != 0
4699                             /* BPABI objects never have dynamic
4700                                relocations mapped.  */
4701                             && !htab->symbian_p)
4702                           flags |= SEC_ALLOC | SEC_LOAD;
4703                         sreloc = bfd_make_section_with_flags (dynobj,
4704                                                               name,
4705                                                               flags);
4706                         if (sreloc == NULL
4707                             || ! bfd_set_section_alignment (dynobj, sreloc, 2))
4708                           return FALSE;
4709                       }
4710
4711                     elf_section_data (sec)->sreloc = sreloc;
4712                   }
4713
4714                 /* If this is a global symbol, we count the number of
4715                    relocations we need for this symbol.  */
4716                 if (h != NULL)
4717                   {
4718                     head = &((struct elf32_arm_link_hash_entry *) h)->relocs_copied;
4719                   }
4720                 else
4721                   {
4722                     /* Track dynamic relocs needed for local syms too.
4723                        We really need local syms available to do this
4724                        easily.  Oh well.  */
4725
4726                     asection *s;
4727                     s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
4728                                                    sec, r_symndx);
4729                     if (s == NULL)
4730                       return FALSE;
4731
4732                     head = ((struct elf32_arm_relocs_copied **)
4733                             &elf_section_data (s)->local_dynrel);
4734                   }
4735
4736                 p = *head;
4737                 if (p == NULL || p->section != sec)
4738                   {
4739                     bfd_size_type amt = sizeof *p;
4740
4741                     p = bfd_alloc (htab->root.dynobj, amt);
4742                     if (p == NULL)
4743                       return FALSE;
4744                     p->next = *head;
4745                     *head = p;
4746                     p->section = sec;
4747                     p->count = 0;
4748                     p->pc_count = 0;
4749                   }
4750
4751                 if (r_type == R_ARM_REL32)
4752                   p->pc_count += 1;
4753                 p->count += 1;
4754               }
4755             break;
4756
4757         /* This relocation describes the C++ object vtable hierarchy.
4758            Reconstruct it for later use during GC.  */
4759         case R_ARM_GNU_VTINHERIT:
4760           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
4761             return FALSE;
4762           break;
4763
4764         /* This relocation describes which C++ vtable entries are actually
4765            used.  Record for later use during GC.  */
4766         case R_ARM_GNU_VTENTRY:
4767           if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
4768             return FALSE;
4769           break;
4770         }
4771     }
4772
4773   return TRUE;
4774 }
4775
4776 /* Treat mapping symbols as special target symbols.  */
4777
4778 static bfd_boolean
4779 elf32_arm_is_target_special_symbol (bfd * abfd ATTRIBUTE_UNUSED, asymbol * sym)
4780 {
4781   return bfd_is_arm_mapping_symbol_name (sym->name);
4782 }
4783
4784 /* This is a copy of elf_find_function() from elf.c except that
4785    ARM mapping symbols are ignored when looking for function names
4786    and STT_ARM_TFUNC is considered to a function type.  */
4787
4788 static bfd_boolean
4789 arm_elf_find_function (bfd *         abfd ATTRIBUTE_UNUSED,
4790                        asection *    section,
4791                        asymbol **    symbols,
4792                        bfd_vma       offset,
4793                        const char ** filename_ptr,
4794                        const char ** functionname_ptr)
4795 {
4796   const char * filename = NULL;
4797   asymbol * func = NULL;
4798   bfd_vma low_func = 0;
4799   asymbol ** p;
4800
4801   for (p = symbols; *p != NULL; p++)
4802     {
4803       elf_symbol_type *q;
4804
4805       q = (elf_symbol_type *) *p;
4806
4807       switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
4808         {
4809         default:
4810           break;
4811         case STT_FILE:
4812           filename = bfd_asymbol_name (&q->symbol);
4813           break;
4814         case STT_FUNC:
4815         case STT_ARM_TFUNC:
4816         case STT_NOTYPE:
4817           /* Skip $a and $t symbols.  */
4818           if ((q->symbol.flags & BSF_LOCAL)
4819               && bfd_is_arm_mapping_symbol_name (q->symbol.name))
4820             continue;
4821           /* Fall through.  */
4822           if (bfd_get_section (&q->symbol) == section
4823               && q->symbol.value >= low_func
4824               && q->symbol.value <= offset)
4825             {
4826               func = (asymbol *) q;
4827               low_func = q->symbol.value;
4828             }
4829           break;
4830         }
4831     }
4832
4833   if (func == NULL)
4834     return FALSE;
4835
4836   if (filename_ptr)
4837     *filename_ptr = filename;
4838   if (functionname_ptr)
4839     *functionname_ptr = bfd_asymbol_name (func);
4840
4841   return TRUE;
4842 }
4843
4844
4845 /* Find the nearest line to a particular section and offset, for error
4846    reporting.   This code is a duplicate of the code in elf.c, except
4847    that it uses arm_elf_find_function.  */
4848
4849 static bfd_boolean
4850 elf32_arm_find_nearest_line (bfd *          abfd,
4851                              asection *     section,
4852                              asymbol **     symbols,
4853                              bfd_vma        offset,
4854                              const char **  filename_ptr,
4855                              const char **  functionname_ptr,
4856                              unsigned int * line_ptr)
4857 {
4858   bfd_boolean found = FALSE;
4859
4860   /* We skip _bfd_dwarf1_find_nearest_line since no known ARM toolchain uses it.  */
4861
4862   if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
4863                                      filename_ptr, functionname_ptr,
4864                                      line_ptr, 0,
4865                                      & elf_tdata (abfd)->dwarf2_find_line_info))
4866     {
4867       if (!*functionname_ptr)
4868         arm_elf_find_function (abfd, section, symbols, offset,
4869                                *filename_ptr ? NULL : filename_ptr,
4870                                functionname_ptr);
4871
4872       return TRUE;
4873     }
4874
4875   if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
4876                                              & found, filename_ptr,
4877                                              functionname_ptr, line_ptr,
4878                                              & elf_tdata (abfd)->line_info))
4879     return FALSE;
4880
4881   if (found && (*functionname_ptr || *line_ptr))
4882     return TRUE;
4883
4884   if (symbols == NULL)
4885     return FALSE;
4886
4887   if (! arm_elf_find_function (abfd, section, symbols, offset,
4888                                filename_ptr, functionname_ptr))
4889     return FALSE;
4890
4891   *line_ptr = 0;
4892   return TRUE;
4893 }
4894
4895 /* Adjust a symbol defined by a dynamic object and referenced by a
4896    regular object.  The current definition is in some section of the
4897    dynamic object, but we're not including those sections.  We have to
4898    change the definition to something the rest of the link can
4899    understand.  */
4900
4901 static bfd_boolean
4902 elf32_arm_adjust_dynamic_symbol (struct bfd_link_info * info,
4903                                  struct elf_link_hash_entry * h)
4904 {
4905   bfd * dynobj;
4906   asection * s;
4907   unsigned int power_of_two;
4908   struct elf32_arm_link_hash_entry * eh;
4909   struct elf32_arm_link_hash_table *globals;
4910
4911   globals = elf32_arm_hash_table (info);
4912   dynobj = elf_hash_table (info)->dynobj;
4913
4914   /* Make sure we know what is going on here.  */
4915   BFD_ASSERT (dynobj != NULL
4916               && (h->needs_plt
4917                   || h->u.weakdef != NULL
4918                   || (h->def_dynamic
4919                       && h->ref_regular
4920                       && !h->def_regular)));
4921
4922   eh = (struct elf32_arm_link_hash_entry *) h;
4923
4924   /* If this is a function, put it in the procedure linkage table.  We
4925      will fill in the contents of the procedure linkage table later,
4926      when we know the address of the .got section.  */
4927   if (h->type == STT_FUNC || h->type == STT_ARM_TFUNC
4928       || h->needs_plt)
4929     {
4930       if (h->plt.refcount <= 0
4931           || SYMBOL_CALLS_LOCAL (info, h)
4932           || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
4933               && h->root.type == bfd_link_hash_undefweak))
4934         {
4935           /* This case can occur if we saw a PLT32 reloc in an input
4936              file, but the symbol was never referred to by a dynamic
4937              object, or if all references were garbage collected.  In
4938              such a case, we don't actually need to build a procedure
4939              linkage table, and we can just do a PC24 reloc instead.  */
4940           h->plt.offset = (bfd_vma) -1;
4941           eh->plt_thumb_refcount = 0;
4942           h->needs_plt = 0;
4943         }
4944
4945       return TRUE;
4946     }
4947   else
4948     {
4949       /* It's possible that we incorrectly decided a .plt reloc was
4950          needed for an R_ARM_PC24 or similar reloc to a non-function sym
4951          in check_relocs.  We can't decide accurately between function
4952          and non-function syms in check-relocs; Objects loaded later in
4953          the link may change h->type.  So fix it now.  */
4954       h->plt.offset = (bfd_vma) -1;
4955       eh->plt_thumb_refcount = 0;
4956     }
4957
4958   /* If this is a weak symbol, and there is a real definition, the
4959      processor independent code will have arranged for us to see the
4960      real definition first, and we can just use the same value.  */
4961   if (h->u.weakdef != NULL)
4962     {
4963       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
4964                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
4965       h->root.u.def.section = h->u.weakdef->root.u.def.section;
4966       h->root.u.def.value = h->u.weakdef->root.u.def.value;
4967       return TRUE;
4968     }
4969
4970   /* If there are no non-GOT references, we do not need a copy
4971      relocation.  */
4972   if (!h->non_got_ref)
4973     return TRUE;
4974
4975   /* This is a reference to a symbol defined by a dynamic object which
4976      is not a function.  */
4977
4978   /* If we are creating a shared library, we must presume that the
4979      only references to the symbol are via the global offset table.
4980      For such cases we need not do anything here; the relocations will
4981      be handled correctly by relocate_section.  Relocatable executables
4982      can reference data in shared objects directly, so we don't need to
4983      do anything here.  */
4984   if (info->shared || globals->root.is_relocatable_executable)
4985     return TRUE;
4986
4987   /* We must allocate the symbol in our .dynbss section, which will
4988      become part of the .bss section of the executable.  There will be
4989      an entry for this symbol in the .dynsym section.  The dynamic
4990      object will contain position independent code, so all references
4991      from the dynamic object to this symbol will go through the global
4992      offset table.  The dynamic linker will use the .dynsym entry to
4993      determine the address it must put in the global offset table, so
4994      both the dynamic object and the regular object will refer to the
4995      same memory location for the variable.  */
4996   s = bfd_get_section_by_name (dynobj, ".dynbss");
4997   BFD_ASSERT (s != NULL);
4998
4999   /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
5000      copy the initial value out of the dynamic object and into the
5001      runtime process image.  We need to remember the offset into the
5002      .rel.bss section we are going to use.  */
5003   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
5004     {
5005       asection *srel;
5006
5007       srel = bfd_get_section_by_name (dynobj, ".rel.bss");
5008       BFD_ASSERT (srel != NULL);
5009       srel->size += sizeof (Elf32_External_Rel);
5010       h->needs_copy = 1;
5011     }
5012
5013   /* We need to figure out the alignment required for this symbol.  I
5014      have no idea how ELF linkers handle this.  */
5015   power_of_two = bfd_log2 (h->size);
5016   if (power_of_two > 3)
5017     power_of_two = 3;
5018
5019   /* Apply the required alignment.  */
5020   s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
5021   if (power_of_two > bfd_get_section_alignment (dynobj, s))
5022     {
5023       if (! bfd_set_section_alignment (dynobj, s, power_of_two))
5024         return FALSE;
5025     }
5026
5027   /* Define the symbol as being at this point in the section.  */
5028   h->root.u.def.section = s;
5029   h->root.u.def.value = s->size;
5030
5031   /* Increment the section size to make room for the symbol.  */
5032   s->size += h->size;
5033
5034   return TRUE;
5035 }
5036
5037 /* Allocate space in .plt, .got and associated reloc sections for
5038    dynamic relocs.  */
5039
5040 static bfd_boolean
5041 allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
5042 {
5043   struct bfd_link_info *info;
5044   struct elf32_arm_link_hash_table *htab;
5045   struct elf32_arm_link_hash_entry *eh;
5046   struct elf32_arm_relocs_copied *p;
5047
5048   eh = (struct elf32_arm_link_hash_entry *) h;
5049
5050   if (h->root.type == bfd_link_hash_indirect)
5051     return TRUE;
5052
5053   if (h->root.type == bfd_link_hash_warning)
5054     /* When warning symbols are created, they **replace** the "real"
5055        entry in the hash table, thus we never get to see the real
5056        symbol in a hash traversal.  So look at it now.  */
5057     h = (struct elf_link_hash_entry *) h->root.u.i.link;
5058
5059   info = (struct bfd_link_info *) inf;
5060   htab = elf32_arm_hash_table (info);
5061
5062   if (htab->root.dynamic_sections_created
5063       && h->plt.refcount > 0)
5064     {
5065       /* Make sure this symbol is output as a dynamic symbol.
5066          Undefined weak syms won't yet be marked as dynamic.  */
5067       if (h->dynindx == -1
5068           && !h->forced_local)
5069         {
5070           if (! bfd_elf_link_record_dynamic_symbol (info, h))
5071             return FALSE;
5072         }
5073
5074       if (info->shared
5075           || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
5076         {
5077           asection *s = htab->splt;
5078
5079           /* If this is the first .plt entry, make room for the special
5080              first entry.  */
5081           if (s->size == 0)
5082             s->size += htab->plt_header_size;
5083
5084           h->plt.offset = s->size;
5085
5086           /* If we will insert a Thumb trampoline before this PLT, leave room
5087              for it.  */
5088           if (!htab->use_blx && eh->plt_thumb_refcount > 0)
5089             {
5090               h->plt.offset += PLT_THUMB_STUB_SIZE;
5091               s->size += PLT_THUMB_STUB_SIZE;
5092             }
5093
5094           /* If this symbol is not defined in a regular file, and we are
5095              not generating a shared library, then set the symbol to this
5096              location in the .plt.  This is required to make function
5097              pointers compare as equal between the normal executable and
5098              the shared library.  */
5099           if (! info->shared
5100               && !h->def_regular)
5101             {
5102               h->root.u.def.section = s;
5103               h->root.u.def.value = h->plt.offset;
5104
5105               /* Make sure the function is not marked as Thumb, in case
5106                  it is the target of an ABS32 relocation, which will
5107                  point to the PLT entry.  */
5108               if (ELF_ST_TYPE (h->type) == STT_ARM_TFUNC)
5109                 h->type = ELF_ST_INFO (ELF_ST_BIND (h->type), STT_FUNC);
5110             }
5111
5112           /* Make room for this entry.  */
5113           s->size += htab->plt_entry_size;
5114
5115           if (!htab->symbian_p)
5116             {
5117               /* We also need to make an entry in the .got.plt section, which
5118                  will be placed in the .got section by the linker script.  */
5119               eh->plt_got_offset = htab->sgotplt->size;
5120               htab->sgotplt->size += 4;
5121             }
5122
5123           /* We also need to make an entry in the .rel.plt section.  */
5124           htab->srelplt->size += sizeof (Elf32_External_Rel);
5125         }
5126       else
5127         {
5128           h->plt.offset = (bfd_vma) -1;
5129           h->needs_plt = 0;
5130         }
5131     }
5132   else
5133     {
5134       h->plt.offset = (bfd_vma) -1;
5135       h->needs_plt = 0;
5136     }
5137
5138   if (h->got.refcount > 0)
5139     {
5140       asection *s;
5141       bfd_boolean dyn;
5142       int tls_type = elf32_arm_hash_entry (h)->tls_type;
5143       int indx;
5144
5145       /* Make sure this symbol is output as a dynamic symbol.
5146          Undefined weak syms won't yet be marked as dynamic.  */
5147       if (h->dynindx == -1
5148           && !h->forced_local)
5149         {
5150           if (! bfd_elf_link_record_dynamic_symbol (info, h))
5151             return FALSE;
5152         }
5153
5154       if (!htab->symbian_p)
5155         {
5156           s = htab->sgot;
5157           h->got.offset = s->size;
5158
5159           if (tls_type == GOT_UNKNOWN)
5160             abort ();
5161
5162           if (tls_type == GOT_NORMAL)
5163             /* Non-TLS symbols need one GOT slot.  */
5164             s->size += 4;
5165           else
5166             {
5167               if (tls_type & GOT_TLS_GD)
5168                 /* R_ARM_TLS_GD32 needs 2 consecutive GOT slots.  */
5169                 s->size += 8;
5170               if (tls_type & GOT_TLS_IE)
5171                 /* R_ARM_TLS_IE32 needs one GOT slot.  */
5172                 s->size += 4;
5173             }
5174
5175           dyn = htab->root.dynamic_sections_created;
5176
5177           indx = 0;
5178           if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
5179               && (!info->shared
5180                   || !SYMBOL_REFERENCES_LOCAL (info, h)))
5181             indx = h->dynindx;
5182
5183           if (tls_type != GOT_NORMAL
5184               && (info->shared || indx != 0)
5185               && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
5186                   || h->root.type != bfd_link_hash_undefweak))
5187             {
5188               if (tls_type & GOT_TLS_IE)
5189                 htab->srelgot->size += sizeof (Elf32_External_Rel);
5190
5191               if (tls_type & GOT_TLS_GD)
5192                 htab->srelgot->size += sizeof (Elf32_External_Rel);
5193
5194               if ((tls_type & GOT_TLS_GD) && indx != 0)
5195                 htab->srelgot->size += sizeof (Elf32_External_Rel);
5196             }
5197           else if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
5198                     || h->root.type != bfd_link_hash_undefweak)
5199                    && (info->shared
5200                    || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
5201             htab->srelgot->size += sizeof (Elf32_External_Rel);
5202         }
5203     }
5204   else
5205     h->got.offset = (bfd_vma) -1;
5206
5207   if (eh->relocs_copied == NULL)
5208     return TRUE;
5209
5210   /* In the shared -Bsymbolic case, discard space allocated for
5211      dynamic pc-relative relocs against symbols which turn out to be
5212      defined in regular objects.  For the normal shared case, discard
5213      space for pc-relative relocs that have become local due to symbol
5214      visibility changes.  */
5215
5216   if (info->shared || htab->root.is_relocatable_executable)
5217     {
5218       /* The only reloc that uses pc_count is R_ARM_REL32, which will
5219          appear on something like ".long foo - .".  We want calls to
5220          protected symbols to resolve directly to the function rather
5221          than going via the plt.  If people want function pointer
5222          comparisons to work as expected then they should avoid
5223          writing assembly like ".long foo - .".  */
5224       if (SYMBOL_CALLS_LOCAL (info, h))
5225         {
5226           struct elf32_arm_relocs_copied **pp;
5227
5228           for (pp = &eh->relocs_copied; (p = *pp) != NULL; )
5229             {
5230               p->count -= p->pc_count;
5231               p->pc_count = 0;
5232               if (p->count == 0)
5233                 *pp = p->next;
5234               else
5235                 pp = &p->next;
5236             }
5237         }
5238
5239       /* Also discard relocs on undefined weak syms with non-default
5240          visibility.  */
5241       if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
5242           && h->root.type == bfd_link_hash_undefweak)
5243         eh->relocs_copied = NULL;
5244       else if (htab->root.is_relocatable_executable && h->dynindx == -1
5245                && h->root.type == bfd_link_hash_new)
5246         {
5247           /* Output absolute symbols so that we can create relocations
5248              against them.  For normal symbols we output a relocation
5249              against the section that contains them.  */
5250           if (! bfd_elf_link_record_dynamic_symbol (info, h))
5251             return FALSE;
5252         }
5253
5254     }
5255   else
5256     {
5257       /* For the non-shared case, discard space for relocs against
5258          symbols which turn out to need copy relocs or are not
5259          dynamic.  */
5260
5261       if (!h->non_got_ref
5262           && ((h->def_dynamic
5263                && !h->def_regular)
5264               || (htab->root.dynamic_sections_created
5265                   && (h->root.type == bfd_link_hash_undefweak
5266                       || h->root.type == bfd_link_hash_undefined))))
5267         {
5268           /* Make sure this symbol is output as a dynamic symbol.
5269              Undefined weak syms won't yet be marked as dynamic.  */
5270           if (h->dynindx == -1
5271               && !h->forced_local)
5272             {
5273               if (! bfd_elf_link_record_dynamic_symbol (info, h))
5274                 return FALSE;
5275             }
5276
5277           /* If that succeeded, we know we'll be keeping all the
5278              relocs.  */
5279           if (h->dynindx != -1)
5280             goto keep;
5281         }
5282
5283       eh->relocs_copied = NULL;
5284
5285     keep: ;
5286     }
5287
5288   /* Finally, allocate space.  */
5289   for (p = eh->relocs_copied; p != NULL; p = p->next)
5290     {
5291       asection *sreloc = elf_section_data (p->section)->sreloc;
5292       sreloc->size += p->count * sizeof (Elf32_External_Rel);
5293     }
5294
5295   return TRUE;
5296 }
5297
5298 /* Find any dynamic relocs that apply to read-only sections.  */
5299
5300 static bfd_boolean
5301 elf32_arm_readonly_dynrelocs (struct elf_link_hash_entry *h, PTR inf)
5302 {
5303   struct elf32_arm_link_hash_entry *eh;
5304   struct elf32_arm_relocs_copied *p;
5305
5306   if (h->root.type == bfd_link_hash_warning)
5307     h = (struct elf_link_hash_entry *) h->root.u.i.link;
5308
5309   eh = (struct elf32_arm_link_hash_entry *) h;
5310   for (p = eh->relocs_copied; p != NULL; p = p->next)
5311     {
5312       asection *s = p->section;
5313
5314       if (s != NULL && (s->flags & SEC_READONLY) != 0)
5315         {
5316           struct bfd_link_info *info = (struct bfd_link_info *) inf;
5317
5318           info->flags |= DF_TEXTREL;
5319
5320           /* Not an error, just cut short the traversal.  */
5321           return FALSE;
5322         }
5323     }
5324   return TRUE;
5325 }
5326
5327 /* Set the sizes of the dynamic sections.  */
5328
5329 static bfd_boolean
5330 elf32_arm_size_dynamic_sections (bfd * output_bfd ATTRIBUTE_UNUSED,
5331                                  struct bfd_link_info * info)
5332 {
5333   bfd * dynobj;
5334   asection * s;
5335   bfd_boolean plt;
5336   bfd_boolean relocs;
5337   bfd *ibfd;
5338   struct elf32_arm_link_hash_table *htab;
5339
5340   htab = elf32_arm_hash_table (info);
5341   dynobj = elf_hash_table (info)->dynobj;
5342   BFD_ASSERT (dynobj != NULL);
5343
5344   if (elf_hash_table (info)->dynamic_sections_created)
5345     {
5346       /* Set the contents of the .interp section to the interpreter.  */
5347       if (info->executable)
5348         {
5349           s = bfd_get_section_by_name (dynobj, ".interp");
5350           BFD_ASSERT (s != NULL);
5351           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
5352           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
5353         }
5354     }
5355
5356   /* Set up .got offsets for local syms, and space for local dynamic
5357      relocs.  */
5358   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
5359     {
5360       bfd_signed_vma *local_got;
5361       bfd_signed_vma *end_local_got;
5362       char *local_tls_type;
5363       bfd_size_type locsymcount;
5364       Elf_Internal_Shdr *symtab_hdr;
5365       asection *srel;
5366
5367       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
5368         continue;
5369
5370       for (s = ibfd->sections; s != NULL; s = s->next)
5371         {
5372           struct elf32_arm_relocs_copied *p;
5373
5374           for (p = *((struct elf32_arm_relocs_copied **)
5375                      &elf_section_data (s)->local_dynrel);
5376                p != NULL;
5377                p = p->next)
5378             {
5379               if (!bfd_is_abs_section (p->section)
5380                   && bfd_is_abs_section (p->section->output_section))
5381                 {
5382                   /* Input section has been discarded, either because
5383                      it is a copy of a linkonce section or due to
5384                      linker script /DISCARD/, so we'll be discarding
5385                      the relocs too.  */
5386                 }
5387               else if (p->count != 0)
5388                 {
5389                   srel = elf_section_data (p->section)->sreloc;
5390                   srel->size += p->count * sizeof (Elf32_External_Rel);
5391                   if ((p->section->output_section->flags & SEC_READONLY) != 0)
5392                     info->flags |= DF_TEXTREL;
5393                 }
5394             }
5395         }
5396
5397       local_got = elf_local_got_refcounts (ibfd);
5398       if (!local_got)
5399         continue;
5400
5401       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
5402       locsymcount = symtab_hdr->sh_info;
5403       end_local_got = local_got + locsymcount;
5404       local_tls_type = elf32_arm_local_got_tls_type (ibfd);
5405       s = htab->sgot;
5406       srel = htab->srelgot;
5407       for (; local_got < end_local_got; ++local_got, ++local_tls_type)
5408         {
5409           if (*local_got > 0)
5410             {
5411               *local_got = s->size;
5412               if (*local_tls_type & GOT_TLS_GD)
5413                 /* TLS_GD relocs need an 8-byte structure in the GOT.  */
5414                 s->size += 8;
5415               if (*local_tls_type & GOT_TLS_IE)
5416                 s->size += 4;
5417               if (*local_tls_type == GOT_NORMAL)
5418                 s->size += 4;
5419
5420               if (info->shared || *local_tls_type == GOT_TLS_GD)
5421                 srel->size += sizeof (Elf32_External_Rel);
5422             }
5423           else
5424             *local_got = (bfd_vma) -1;
5425         }
5426     }
5427
5428   if (htab->tls_ldm_got.refcount > 0)
5429     {
5430       /* Allocate two GOT entries and one dynamic relocation (if necessary)
5431          for R_ARM_TLS_LDM32 relocations.  */
5432       htab->tls_ldm_got.offset = htab->sgot->size;
5433       htab->sgot->size += 8;
5434       if (info->shared)
5435         htab->srelgot->size += sizeof (Elf32_External_Rel);
5436     }
5437   else
5438     htab->tls_ldm_got.offset = -1;
5439
5440   /* Allocate global sym .plt and .got entries, and space for global
5441      sym dynamic relocs.  */
5442   elf_link_hash_traverse (& htab->root, allocate_dynrelocs, info);
5443
5444   /* The check_relocs and adjust_dynamic_symbol entry points have
5445      determined the sizes of the various dynamic sections.  Allocate
5446      memory for them.  */
5447   plt = FALSE;
5448   relocs = FALSE;
5449   for (s = dynobj->sections; s != NULL; s = s->next)
5450     {
5451       const char * name;
5452       bfd_boolean strip;
5453
5454       if ((s->flags & SEC_LINKER_CREATED) == 0)
5455         continue;
5456
5457       /* It's OK to base decisions on the section name, because none
5458          of the dynobj section names depend upon the input files.  */
5459       name = bfd_get_section_name (dynobj, s);
5460
5461       strip = FALSE;
5462
5463       if (strcmp (name, ".plt") == 0)
5464         {
5465           if (s->size == 0)
5466             {
5467               /* Strip this section if we don't need it; see the
5468                  comment below.  */
5469               strip = TRUE;
5470             }
5471           else
5472             {
5473               /* Remember whether there is a PLT.  */
5474               plt = TRUE;
5475             }
5476         }
5477       else if (strncmp (name, ".rel", 4) == 0)
5478         {
5479           if (s->size == 0)
5480             {
5481               /* If we don't need this section, strip it from the
5482                  output file.  This is mostly to handle .rel.bss and
5483                  .rel.plt.  We must create both sections in
5484                  create_dynamic_sections, because they must be created
5485                  before the linker maps input sections to output
5486                  sections.  The linker does that before
5487                  adjust_dynamic_symbol is called, and it is that
5488                  function which decides whether anything needs to go
5489                  into these sections.  */
5490               strip = TRUE;
5491             }
5492           else
5493             {
5494               /* Remember whether there are any reloc sections other
5495                  than .rel.plt.  */
5496               if (strcmp (name, ".rel.plt") != 0)
5497                 relocs = TRUE;
5498
5499               /* We use the reloc_count field as a counter if we need
5500                  to copy relocs into the output file.  */
5501               s->reloc_count = 0;
5502             }
5503         }
5504       else if (strncmp (name, ".got", 4) != 0)
5505         {
5506           /* It's not one of our sections, so don't allocate space.  */
5507           continue;
5508         }
5509
5510       if (strip)
5511         {
5512           s->flags |= SEC_EXCLUDE;
5513           continue;
5514         }
5515
5516       /* Allocate memory for the section contents.  */
5517       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
5518       if (s->contents == NULL && s->size != 0)
5519         return FALSE;
5520     }
5521
5522   if (elf_hash_table (info)->dynamic_sections_created)
5523     {
5524       /* Add some entries to the .dynamic section.  We fill in the
5525          values later, in elf32_arm_finish_dynamic_sections, but we
5526          must add the entries now so that we get the correct size for
5527          the .dynamic section.  The DT_DEBUG entry is filled in by the
5528          dynamic linker and used by the debugger.  */
5529 #define add_dynamic_entry(TAG, VAL) \
5530   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
5531
5532       if (!info->shared)
5533         {
5534           if (!add_dynamic_entry (DT_DEBUG, 0))
5535             return FALSE;
5536         }
5537
5538       if (plt)
5539         {
5540           if (   !add_dynamic_entry (DT_PLTGOT, 0)
5541               || !add_dynamic_entry (DT_PLTRELSZ, 0)
5542               || !add_dynamic_entry (DT_PLTREL, DT_REL)
5543               || !add_dynamic_entry (DT_JMPREL, 0))
5544             return FALSE;
5545         }
5546
5547       if (relocs)
5548         {
5549           if (   !add_dynamic_entry (DT_REL, 0)
5550               || !add_dynamic_entry (DT_RELSZ, 0)
5551               || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel)))
5552             return FALSE;
5553         }
5554
5555       /* If any dynamic relocs apply to a read-only section,
5556          then we need a DT_TEXTREL entry.  */
5557       if ((info->flags & DF_TEXTREL) == 0)
5558         elf_link_hash_traverse (&htab->root, elf32_arm_readonly_dynrelocs,
5559                                 (PTR) info);
5560
5561       if ((info->flags & DF_TEXTREL) != 0)
5562         {
5563           if (!add_dynamic_entry (DT_TEXTREL, 0))
5564             return FALSE;
5565           info->flags |= DF_TEXTREL;
5566         }
5567     }
5568 #undef add_synamic_entry
5569
5570   return TRUE;
5571 }
5572
5573 /* Finish up dynamic symbol handling.  We set the contents of various
5574    dynamic sections here.  */
5575
5576 static bfd_boolean
5577 elf32_arm_finish_dynamic_symbol (bfd * output_bfd, struct bfd_link_info * info,
5578                                  struct elf_link_hash_entry * h, Elf_Internal_Sym * sym)
5579 {
5580   bfd * dynobj;
5581   struct elf32_arm_link_hash_table *htab;
5582   struct elf32_arm_link_hash_entry *eh;
5583
5584   dynobj = elf_hash_table (info)->dynobj;
5585   htab = elf32_arm_hash_table (info);
5586   eh = (struct elf32_arm_link_hash_entry *) h;
5587
5588   if (h->plt.offset != (bfd_vma) -1)
5589     {
5590       asection * splt;
5591       asection * srel;
5592       bfd_byte *loc;
5593       bfd_vma plt_index;
5594       Elf_Internal_Rela rel;
5595
5596       /* This symbol has an entry in the procedure linkage table.  Set
5597          it up.  */
5598
5599       BFD_ASSERT (h->dynindx != -1);
5600
5601       splt = bfd_get_section_by_name (dynobj, ".plt");
5602       srel = bfd_get_section_by_name (dynobj, ".rel.plt");
5603       BFD_ASSERT (splt != NULL && srel != NULL);
5604
5605       /* Fill in the entry in the procedure linkage table.  */
5606       if (htab->symbian_p)
5607         {
5608           unsigned i;
5609           for (i = 0; i < htab->plt_entry_size / 4; ++i)
5610             bfd_put_32 (output_bfd,
5611                         elf32_arm_symbian_plt_entry[i],
5612                         splt->contents + h->plt.offset + 4 * i);
5613
5614           /* Fill in the entry in the .rel.plt section.  */
5615           rel.r_offset = (splt->output_section->vma
5616                           + splt->output_offset
5617                           + h->plt.offset + 4 * (i - 1));
5618           rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT);
5619
5620           /* Get the index in the procedure linkage table which
5621              corresponds to this symbol.  This is the index of this symbol
5622              in all the symbols for which we are making plt entries.  The
5623              first entry in the procedure linkage table is reserved.  */
5624           plt_index = ((h->plt.offset - htab->plt_header_size)
5625                        / htab->plt_entry_size);
5626         }
5627       else
5628         {
5629           bfd_vma got_offset;
5630           bfd_vma got_displacement;
5631           asection * sgot;
5632
5633           sgot = bfd_get_section_by_name (dynobj, ".got.plt");
5634           BFD_ASSERT (sgot != NULL);
5635
5636           /* Get the offset into the .got.plt table of the entry that
5637              corresponds to this function.  */
5638           got_offset = eh->plt_got_offset;
5639
5640           /* Get the index in the procedure linkage table which
5641              corresponds to this symbol.  This is the index of this symbol
5642              in all the symbols for which we are making plt entries.  The
5643              first three entries in .got.plt are reserved; after that
5644              symbols appear in the same order as in .plt.  */
5645           plt_index = (got_offset - 12) / 4;
5646
5647           /* Calculate the displacement between the PLT slot and the
5648              entry in the GOT.  The eight-byte offset accounts for the
5649              value produced by adding to pc in the first instruction
5650              of the PLT stub.  */
5651           got_displacement = (sgot->output_section->vma
5652                               + sgot->output_offset
5653                               + got_offset
5654                               - splt->output_section->vma
5655                               - splt->output_offset
5656                               - h->plt.offset
5657                               - 8);
5658
5659           BFD_ASSERT ((got_displacement & 0xf0000000) == 0);
5660
5661           if (!htab->use_blx && eh->plt_thumb_refcount > 0)
5662             {
5663               bfd_put_16 (output_bfd, elf32_arm_plt_thumb_stub[0],
5664                           splt->contents + h->plt.offset - 4);
5665               bfd_put_16 (output_bfd, elf32_arm_plt_thumb_stub[1],
5666                           splt->contents + h->plt.offset - 2);
5667             }
5668
5669           bfd_put_32 (output_bfd, elf32_arm_plt_entry[0] | ((got_displacement & 0x0ff00000) >> 20),
5670                       splt->contents + h->plt.offset + 0);
5671           bfd_put_32 (output_bfd, elf32_arm_plt_entry[1] | ((got_displacement & 0x000ff000) >> 12),
5672                       splt->contents + h->plt.offset + 4);
5673           bfd_put_32 (output_bfd, elf32_arm_plt_entry[2] | (got_displacement & 0x00000fff),
5674                       splt->contents + h->plt.offset + 8);
5675 #ifdef FOUR_WORD_PLT
5676           bfd_put_32 (output_bfd, elf32_arm_plt_entry[3],
5677                       splt->contents + h->plt.offset + 12);
5678 #endif
5679
5680           /* Fill in the entry in the global offset table.  */
5681           bfd_put_32 (output_bfd,
5682                       (splt->output_section->vma
5683                        + splt->output_offset),
5684                       sgot->contents + got_offset);
5685
5686           /* Fill in the entry in the .rel.plt section.  */
5687           rel.r_offset = (sgot->output_section->vma
5688                           + sgot->output_offset
5689                           + got_offset);
5690           rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_JUMP_SLOT);
5691         }
5692
5693       loc = srel->contents + plt_index * sizeof (Elf32_External_Rel);
5694       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
5695
5696       if (!h->def_regular)
5697         {
5698           /* Mark the symbol as undefined, rather than as defined in
5699              the .plt section.  Leave the value alone.  */
5700           sym->st_shndx = SHN_UNDEF;
5701           /* If the symbol is weak, we do need to clear the value.
5702              Otherwise, the PLT entry would provide a definition for
5703              the symbol even if the symbol wasn't defined anywhere,
5704              and so the symbol would never be NULL.  */
5705           if (!h->ref_regular_nonweak)
5706             sym->st_value = 0;
5707         }
5708     }
5709
5710   if (h->got.offset != (bfd_vma) -1
5711       && (elf32_arm_hash_entry (h)->tls_type & GOT_TLS_GD) == 0
5712       && (elf32_arm_hash_entry (h)->tls_type & GOT_TLS_IE) == 0)
5713     {
5714       asection * sgot;
5715       asection * srel;
5716       Elf_Internal_Rela rel;
5717       bfd_byte *loc;
5718
5719       /* This symbol has an entry in the global offset table.  Set it
5720          up.  */
5721       sgot = bfd_get_section_by_name (dynobj, ".got");
5722       srel = bfd_get_section_by_name (dynobj, ".rel.got");
5723       BFD_ASSERT (sgot != NULL && srel != NULL);
5724
5725       rel.r_offset = (sgot->output_section->vma
5726                       + sgot->output_offset
5727                       + (h->got.offset &~ (bfd_vma) 1));
5728
5729       /* If this is a static link, or it is a -Bsymbolic link and the
5730          symbol is defined locally or was forced to be local because
5731          of a version file, we just want to emit a RELATIVE reloc.
5732          The entry in the global offset table will already have been
5733          initialized in the relocate_section function.  */
5734       if (info->shared
5735           && SYMBOL_REFERENCES_LOCAL (info, h))
5736         {
5737           BFD_ASSERT((h->got.offset & 1) != 0);
5738           rel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
5739         }
5740       else
5741         {
5742           BFD_ASSERT((h->got.offset & 1) == 0);
5743           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
5744           rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT);
5745         }
5746
5747       loc = srel->contents + srel->reloc_count++ * sizeof (Elf32_External_Rel);
5748       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
5749     }
5750
5751   if (h->needs_copy)
5752     {
5753       asection * s;
5754       Elf_Internal_Rela rel;
5755       bfd_byte *loc;
5756
5757       /* This symbol needs a copy reloc.  Set it up.  */
5758       BFD_ASSERT (h->dynindx != -1
5759                   && (h->root.type == bfd_link_hash_defined
5760                       || h->root.type == bfd_link_hash_defweak));
5761
5762       s = bfd_get_section_by_name (h->root.u.def.section->owner,
5763                                    ".rel.bss");
5764       BFD_ASSERT (s != NULL);
5765
5766       rel.r_offset = (h->root.u.def.value
5767                       + h->root.u.def.section->output_section->vma
5768                       + h->root.u.def.section->output_offset);
5769       rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_COPY);
5770       loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rel);
5771       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
5772     }
5773
5774   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
5775   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
5776       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
5777     sym->st_shndx = SHN_ABS;
5778
5779   return TRUE;
5780 }
5781
5782 /* Finish up the dynamic sections.  */
5783
5784 static bfd_boolean
5785 elf32_arm_finish_dynamic_sections (bfd * output_bfd, struct bfd_link_info * info)
5786 {
5787   bfd * dynobj;
5788   asection * sgot;
5789   asection * sdyn;
5790
5791   dynobj = elf_hash_table (info)->dynobj;
5792
5793   sgot = bfd_get_section_by_name (dynobj, ".got.plt");
5794   BFD_ASSERT (elf32_arm_hash_table (info)->symbian_p || sgot != NULL);
5795   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
5796
5797   if (elf_hash_table (info)->dynamic_sections_created)
5798     {
5799       asection *splt;
5800       Elf32_External_Dyn *dyncon, *dynconend;
5801       struct elf32_arm_link_hash_table *htab;
5802
5803       htab = elf32_arm_hash_table (info);
5804       splt = bfd_get_section_by_name (dynobj, ".plt");
5805       BFD_ASSERT (splt != NULL && sdyn != NULL);
5806
5807       dyncon = (Elf32_External_Dyn *) sdyn->contents;
5808       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
5809
5810       for (; dyncon < dynconend; dyncon++)
5811         {
5812           Elf_Internal_Dyn dyn;
5813           const char * name;
5814           asection * s;
5815
5816           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
5817
5818           switch (dyn.d_tag)
5819             {
5820               unsigned int type;
5821
5822             default:
5823               break;
5824
5825             case DT_HASH:
5826               name = ".hash";
5827               goto get_vma_if_bpabi;
5828             case DT_STRTAB:
5829               name = ".dynstr";
5830               goto get_vma_if_bpabi;
5831             case DT_SYMTAB:
5832               name = ".dynsym";
5833               goto get_vma_if_bpabi;
5834             case DT_VERSYM:
5835               name = ".gnu.version";
5836               goto get_vma_if_bpabi;
5837             case DT_VERDEF:
5838               name = ".gnu.version_d";
5839               goto get_vma_if_bpabi;
5840             case DT_VERNEED:
5841               name = ".gnu.version_r";
5842               goto get_vma_if_bpabi;
5843
5844             case DT_PLTGOT:
5845               name = ".got";
5846               goto get_vma;
5847             case DT_JMPREL:
5848               name = ".rel.plt";
5849             get_vma:
5850               s = bfd_get_section_by_name (output_bfd, name);
5851               BFD_ASSERT (s != NULL);
5852               if (!htab->symbian_p)
5853                 dyn.d_un.d_ptr = s->vma;
5854               else
5855                 /* In the BPABI, tags in the PT_DYNAMIC section point
5856                    at the file offset, not the memory address, for the
5857                    convenience of the post linker.  */
5858                 dyn.d_un.d_ptr = s->filepos;
5859               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5860               break;
5861
5862             get_vma_if_bpabi:
5863               if (htab->symbian_p)
5864                 goto get_vma;
5865               break;
5866
5867             case DT_PLTRELSZ:
5868               s = bfd_get_section_by_name (output_bfd, ".rel.plt");
5869               BFD_ASSERT (s != NULL);
5870               dyn.d_un.d_val = s->size;
5871               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5872               break;
5873
5874             case DT_RELSZ:
5875               if (!htab->symbian_p)
5876                 {
5877                   /* My reading of the SVR4 ABI indicates that the
5878                      procedure linkage table relocs (DT_JMPREL) should be
5879                      included in the overall relocs (DT_REL).  This is
5880                      what Solaris does.  However, UnixWare can not handle
5881                      that case.  Therefore, we override the DT_RELSZ entry
5882                      here to make it not include the JMPREL relocs.  Since
5883                      the linker script arranges for .rel.plt to follow all
5884                      other relocation sections, we don't have to worry
5885                      about changing the DT_REL entry.  */
5886                   s = bfd_get_section_by_name (output_bfd, ".rel.plt");
5887                   if (s != NULL)
5888                     dyn.d_un.d_val -= s->size;
5889                   bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5890                   break;
5891                 }
5892               /* Fall through */
5893
5894             case DT_REL:
5895             case DT_RELA:
5896             case DT_RELASZ:
5897               /* In the BPABI, the DT_REL tag must point at the file
5898                  offset, not the VMA, of the first relocation
5899                  section.  So, we use code similar to that in
5900                  elflink.c, but do not check for SHF_ALLOC on the
5901                  relcoation section, since relocations sections are
5902                  never allocated under the BPABI.  The comments above
5903                  about Unixware notwithstanding, we include all of the
5904                  relocations here.  */
5905               if (htab->symbian_p)
5906                 {
5907                   unsigned int i;
5908                   type = ((dyn.d_tag == DT_REL || dyn.d_tag == DT_RELSZ)
5909                           ? SHT_REL : SHT_RELA);
5910                   dyn.d_un.d_val = 0;
5911                   for (i = 1; i < elf_numsections (output_bfd); i++)
5912                     {
5913                       Elf_Internal_Shdr *hdr
5914                         = elf_elfsections (output_bfd)[i];
5915                       if (hdr->sh_type == type)
5916                         {
5917                           if (dyn.d_tag == DT_RELSZ
5918                               || dyn.d_tag == DT_RELASZ)
5919                             dyn.d_un.d_val += hdr->sh_size;
5920                           else if ((ufile_ptr) hdr->sh_offset
5921                                    <= dyn.d_un.d_val - 1)
5922                             dyn.d_un.d_val = hdr->sh_offset;
5923                         }
5924                     }
5925                   bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5926                 }
5927               break;
5928
5929               /* Set the bottom bit of DT_INIT/FINI if the
5930                  corresponding function is Thumb.  */
5931             case DT_INIT:
5932               name = info->init_function;
5933               goto get_sym;
5934             case DT_FINI:
5935               name = info->fini_function;
5936             get_sym:
5937               /* If it wasn't set by elf_bfd_final_link
5938                  then there is nothing to adjust.  */
5939               if (dyn.d_un.d_val != 0)
5940                 {
5941                   struct elf_link_hash_entry * eh;
5942
5943                   eh = elf_link_hash_lookup (elf_hash_table (info), name,
5944                                              FALSE, FALSE, TRUE);
5945                   if (eh != (struct elf_link_hash_entry *) NULL
5946                       && ELF_ST_TYPE (eh->type) == STT_ARM_TFUNC)
5947                     {
5948                       dyn.d_un.d_val |= 1;
5949                       bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5950                     }
5951                 }
5952               break;
5953             }
5954         }
5955
5956       /* Fill in the first entry in the procedure linkage table.  */
5957       if (splt->size > 0 && elf32_arm_hash_table (info)->plt_header_size)
5958         {
5959           bfd_vma got_displacement;
5960
5961           /* Calculate the displacement between the PLT slot and &GOT[0].  */
5962           got_displacement = (sgot->output_section->vma
5963                               + sgot->output_offset
5964                               - splt->output_section->vma
5965                               - splt->output_offset
5966                               - 16);
5967
5968           bfd_put_32 (output_bfd, elf32_arm_plt0_entry[0], splt->contents +  0);
5969           bfd_put_32 (output_bfd, elf32_arm_plt0_entry[1], splt->contents +  4);
5970           bfd_put_32 (output_bfd, elf32_arm_plt0_entry[2], splt->contents +  8);
5971           bfd_put_32 (output_bfd, elf32_arm_plt0_entry[3], splt->contents + 12);
5972 #ifdef FOUR_WORD_PLT
5973           /* The displacement value goes in the otherwise-unused last word of
5974              the second entry.  */
5975           bfd_put_32 (output_bfd, got_displacement,        splt->contents + 28);
5976 #else
5977           bfd_put_32 (output_bfd, got_displacement,        splt->contents + 16);
5978 #endif
5979         }
5980
5981       /* UnixWare sets the entsize of .plt to 4, although that doesn't
5982          really seem like the right value.  */
5983       elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
5984     }
5985
5986   /* Fill in the first three entries in the global offset table.  */
5987   if (sgot)
5988     {
5989       if (sgot->size > 0)
5990         {
5991           if (sdyn == NULL)
5992             bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
5993           else
5994             bfd_put_32 (output_bfd,
5995                         sdyn->output_section->vma + sdyn->output_offset,
5996                         sgot->contents);
5997           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
5998           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
5999         }
6000
6001       elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
6002     }
6003
6004   return TRUE;
6005 }
6006
6007 static void
6008 elf32_arm_post_process_headers (bfd * abfd, struct bfd_link_info * link_info ATTRIBUTE_UNUSED)
6009 {
6010   Elf_Internal_Ehdr * i_ehdrp;  /* ELF file header, internal form.  */
6011   struct elf32_arm_link_hash_table *globals;
6012
6013   i_ehdrp = elf_elfheader (abfd);
6014
6015   if (EF_ARM_EABI_VERSION (i_ehdrp->e_flags) == EF_ARM_EABI_UNKNOWN)
6016     i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_ARM;
6017   else
6018     i_ehdrp->e_ident[EI_OSABI] = 0;
6019   i_ehdrp->e_ident[EI_ABIVERSION] = ARM_ELF_ABI_VERSION;
6020
6021   if (link_info)
6022     {
6023       globals = elf32_arm_hash_table (link_info);
6024       if (globals->byteswap_code)
6025         i_ehdrp->e_flags |= EF_ARM_BE8;
6026     }
6027 }
6028
6029 static enum elf_reloc_type_class
6030 elf32_arm_reloc_type_class (const Elf_Internal_Rela *rela)
6031 {
6032   switch ((int) ELF32_R_TYPE (rela->r_info))
6033     {
6034     case R_ARM_RELATIVE:
6035       return reloc_class_relative;
6036     case R_ARM_JUMP_SLOT:
6037       return reloc_class_plt;
6038     case R_ARM_COPY:
6039       return reloc_class_copy;
6040     default:
6041       return reloc_class_normal;
6042     }
6043 }
6044
6045 /* Set the right machine number for an Arm ELF file.  */
6046
6047 static bfd_boolean
6048 elf32_arm_section_flags (flagword *flags, const Elf_Internal_Shdr *hdr)
6049 {
6050   if (hdr->sh_type == SHT_NOTE)
6051     *flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_SAME_CONTENTS;
6052
6053   return TRUE;
6054 }
6055
6056 static void
6057 elf32_arm_final_write_processing (bfd *abfd, bfd_boolean linker ATTRIBUTE_UNUSED)
6058 {
6059   bfd_arm_update_notes (abfd, ARM_NOTE_SECTION);
6060 }
6061
6062 /* Return TRUE if this is an unwinding table entry.  */
6063
6064 static bfd_boolean
6065 is_arm_elf_unwind_section_name (bfd * abfd ATTRIBUTE_UNUSED, const char * name)
6066 {
6067   size_t len1, len2;
6068
6069   len1 = sizeof (ELF_STRING_ARM_unwind) - 1;
6070   len2 = sizeof (ELF_STRING_ARM_unwind_once) - 1;
6071   return (strncmp (name, ELF_STRING_ARM_unwind, len1) == 0
6072           || strncmp (name, ELF_STRING_ARM_unwind_once, len2) == 0);
6073 }
6074
6075
6076 /* Set the type and flags for an ARM section.  We do this by
6077    the section name, which is a hack, but ought to work.  */
6078
6079 static bfd_boolean
6080 elf32_arm_fake_sections (bfd * abfd, Elf_Internal_Shdr * hdr, asection * sec)
6081 {
6082   const char * name;
6083
6084   name = bfd_get_section_name (abfd, sec);
6085
6086   if (is_arm_elf_unwind_section_name (abfd, name))
6087     {
6088       hdr->sh_type = SHT_ARM_EXIDX;
6089       hdr->sh_flags |= SHF_LINK_ORDER;
6090     }
6091   return TRUE;
6092 }
6093
6094 /* Handle an ARM specific section when reading an object file.  This is
6095    called when bfd_section_from_shdr finds a section with an unknown
6096    type.  */
6097
6098 static bfd_boolean
6099 elf32_arm_section_from_shdr (bfd *abfd,
6100                              Elf_Internal_Shdr * hdr,
6101                              const char *name,
6102                              int shindex)
6103 {
6104   /* There ought to be a place to keep ELF backend specific flags, but
6105      at the moment there isn't one.  We just keep track of the
6106      sections by their name, instead.  Fortunately, the ABI gives
6107      names for all the ARM specific sections, so we will probably get
6108      away with this.  */
6109   switch (hdr->sh_type)
6110     {
6111     case SHT_ARM_EXIDX:
6112       break;
6113
6114     default:
6115       return FALSE;
6116     }
6117
6118   if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
6119     return FALSE;
6120
6121   return TRUE;
6122 }
6123
6124 /* Called for each symbol.  Builds a section map based on mapping symbols.
6125    Does not alter any of the symbols.  */
6126
6127 static bfd_boolean
6128 elf32_arm_output_symbol_hook (struct bfd_link_info *info,
6129                               const char *name,
6130                               Elf_Internal_Sym *elfsym,
6131                               asection *input_sec,
6132                               struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
6133 {
6134   int mapcount;
6135   elf32_arm_section_map *map;
6136   struct elf32_arm_link_hash_table *globals;
6137
6138   /* Only do this on final link.  */
6139   if (info->relocatable)
6140     return TRUE;
6141
6142   /* Only build a map if we need to byteswap code.  */
6143   globals = elf32_arm_hash_table (info);
6144   if (!globals->byteswap_code)
6145     return TRUE;
6146
6147   /* We only want mapping symbols.  */
6148   if (! bfd_is_arm_mapping_symbol_name (name))
6149     return TRUE;
6150
6151   mapcount = ++(elf32_arm_section_data (input_sec)->mapcount);
6152   map = elf32_arm_section_data (input_sec)->map;
6153   /* TODO: This may be inefficient, but we probably don't usually have many
6154      mapping symbols per section.  */
6155   map = bfd_realloc (map, mapcount * sizeof (elf32_arm_section_map));
6156   elf32_arm_section_data (input_sec)->map = map;
6157
6158   map[mapcount - 1].vma = elfsym->st_value;
6159   map[mapcount - 1].type = name[1];
6160   return TRUE;
6161 }
6162
6163
6164 /* Allocate target specific section data.  */
6165
6166 static bfd_boolean
6167 elf32_arm_new_section_hook (bfd *abfd, asection *sec)
6168 {
6169   struct _arm_elf_section_data *sdata;
6170   bfd_size_type amt = sizeof (*sdata);
6171
6172   sdata = bfd_zalloc (abfd, amt);
6173   if (sdata == NULL)
6174     return FALSE;
6175   sec->used_by_bfd = sdata;
6176
6177   return _bfd_elf_new_section_hook (abfd, sec);
6178 }
6179
6180
6181 /* Used to order a list of mapping symbols by address.  */
6182
6183 static int
6184 elf32_arm_compare_mapping (const void * a, const void * b)
6185 {
6186   return ((const elf32_arm_section_map *) a)->vma
6187          > ((const elf32_arm_section_map *) b)->vma;
6188 }
6189
6190
6191 /* Do code byteswapping.  Return FALSE afterwards so that the section is
6192    written out as normal.  */
6193
6194 static bfd_boolean
6195 elf32_arm_write_section (bfd *output_bfd ATTRIBUTE_UNUSED, asection *sec,
6196                          bfd_byte *contents)
6197 {
6198   int mapcount;
6199   elf32_arm_section_map *map;
6200   bfd_vma ptr;
6201   bfd_vma end;
6202   bfd_vma offset;
6203   bfd_byte tmp;
6204   int i;
6205
6206   mapcount = elf32_arm_section_data (sec)->mapcount;
6207   map = elf32_arm_section_data (sec)->map;
6208
6209   if (mapcount == 0)
6210     return FALSE;
6211
6212   qsort (map, mapcount, sizeof (elf32_arm_section_map),
6213          elf32_arm_compare_mapping);
6214
6215   offset = sec->output_section->vma + sec->output_offset;
6216   ptr = map[0].vma - offset;
6217   for (i = 0; i < mapcount; i++)
6218     {
6219       if (i == mapcount - 1)
6220         end = sec->size;
6221       else
6222         end = map[i + 1].vma - offset;
6223
6224       switch (map[i].type)
6225         {
6226         case 'a':
6227           /* Byte swap code words.  */
6228           while (ptr + 3 < end)
6229             {
6230               tmp = contents[ptr];
6231               contents[ptr] = contents[ptr + 3];
6232               contents[ptr + 3] = tmp;
6233               tmp = contents[ptr + 1];
6234               contents[ptr + 1] = contents[ptr + 2];
6235               contents[ptr + 2] = tmp;
6236               ptr += 4;
6237             }
6238           break;
6239
6240         case 't':
6241           /* Byte swap code halfwords.  */
6242           while (ptr + 1 < end)
6243             {
6244               tmp = contents[ptr];
6245               contents[ptr] = contents[ptr + 1];
6246               contents[ptr + 1] = tmp;
6247               ptr += 2;
6248             }
6249           break;
6250
6251         case 'd':
6252           /* Leave data alone.  */
6253           break;
6254         }
6255       ptr = end;
6256     }
6257   free (map);
6258   return FALSE;
6259 }
6260
6261 /* Display STT_ARM_TFUNC symbols as functions.  */
6262
6263 static void
6264 elf32_arm_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED,
6265                              asymbol *asym)
6266 {
6267   elf_symbol_type *elfsym = (elf_symbol_type *) asym;
6268
6269   if (ELF_ST_TYPE (elfsym->internal_elf_sym.st_info) == STT_ARM_TFUNC)
6270     elfsym->symbol.flags |= BSF_FUNCTION;
6271 }
6272
6273
6274 /* Mangle thumb function symbols as we read them in.  */
6275
6276 static void
6277 elf32_arm_swap_symbol_in (bfd * abfd,
6278                           const void *psrc,
6279                           const void *pshn,
6280                           Elf_Internal_Sym *dst)
6281 {
6282   bfd_elf32_swap_symbol_in (abfd, psrc, pshn, dst);
6283
6284   /* New EABI objects mark thumb function symbols by setting the low bit of
6285      the address.  Turn these into STT_ARM_TFUNC.  */
6286   if (ELF_ST_TYPE (dst->st_info) == STT_FUNC
6287       && (dst->st_value & 1))
6288     {
6289       dst->st_info = ELF_ST_INFO (ELF_ST_BIND (dst->st_info), STT_ARM_TFUNC);
6290       dst->st_value &= ~(bfd_vma) 1;
6291     }
6292 }
6293
6294
6295 /* Mangle thumb function symbols as we write them out.  */
6296
6297 static void
6298 elf32_arm_swap_symbol_out (bfd *abfd,
6299                            const Elf_Internal_Sym *src,
6300                            void *cdst,
6301                            void *shndx)
6302 {
6303   Elf_Internal_Sym newsym;
6304
6305   /* We convert STT_ARM_TFUNC symbols into STT_FUNC with the low bit
6306      of the address set, as per the new EABI.  We do this unconditionally
6307      because objcopy does not set the elf header flags until after
6308      it writes out the symbol table.  */
6309   if (ELF_ST_TYPE (src->st_info) == STT_ARM_TFUNC)
6310     {
6311       newsym = *src;
6312       newsym.st_info = ELF_ST_INFO (ELF_ST_BIND (src->st_info), STT_FUNC);
6313       newsym.st_value |= 1;
6314
6315       src = &newsym;
6316     }
6317   bfd_elf32_swap_symbol_out (abfd, src, cdst, shndx);
6318 }
6319
6320 /* Add the PT_ARM_EXIDX program header.  */
6321
6322 static bfd_boolean
6323 elf32_arm_modify_segment_map (bfd *abfd,
6324                               struct bfd_link_info *info ATTRIBUTE_UNUSED)
6325 {
6326   struct elf_segment_map *m;
6327   asection *sec;
6328
6329   sec = bfd_get_section_by_name (abfd, ".ARM.exidx");
6330   if (sec != NULL && (sec->flags & SEC_LOAD) != 0)
6331     {
6332       /* If there is already a PT_ARM_EXIDX header, then we do not
6333          want to add another one.  This situation arises when running
6334          "strip"; the input binary already has the header.  */
6335       m = elf_tdata (abfd)->segment_map;
6336       while (m && m->p_type != PT_ARM_EXIDX)
6337         m = m->next;
6338       if (!m)
6339         {
6340           m = bfd_zalloc (abfd, sizeof (struct elf_segment_map));
6341           if (m == NULL)
6342             return FALSE;
6343           m->p_type = PT_ARM_EXIDX;
6344           m->count = 1;
6345           m->sections[0] = sec;
6346
6347           m->next = elf_tdata (abfd)->segment_map;
6348           elf_tdata (abfd)->segment_map = m;
6349         }
6350     }
6351
6352   return TRUE;
6353 }
6354
6355 /* We may add a PT_ARM_EXIDX program header.  */
6356
6357 static int
6358 elf32_arm_additional_program_headers (bfd *abfd)
6359 {
6360   asection *sec;
6361
6362   sec = bfd_get_section_by_name (abfd, ".ARM.exidx");
6363   if (sec != NULL && (sec->flags & SEC_LOAD) != 0)
6364     return 1;
6365   else
6366     return 0;
6367 }
6368
6369 /* We use this to override swap_symbol_in and swap_symbol_out.  */
6370 const struct elf_size_info elf32_arm_size_info = {
6371   sizeof (Elf32_External_Ehdr),
6372   sizeof (Elf32_External_Phdr),
6373   sizeof (Elf32_External_Shdr),
6374   sizeof (Elf32_External_Rel),
6375   sizeof (Elf32_External_Rela),
6376   sizeof (Elf32_External_Sym),
6377   sizeof (Elf32_External_Dyn),
6378   sizeof (Elf_External_Note),
6379   4,
6380   1,
6381   32, 2,
6382   ELFCLASS32, EV_CURRENT,
6383   bfd_elf32_write_out_phdrs,
6384   bfd_elf32_write_shdrs_and_ehdr,
6385   bfd_elf32_write_relocs,
6386   elf32_arm_swap_symbol_in,
6387   elf32_arm_swap_symbol_out,
6388   bfd_elf32_slurp_reloc_table,
6389   bfd_elf32_slurp_symbol_table,
6390   bfd_elf32_swap_dyn_in,
6391   bfd_elf32_swap_dyn_out,
6392   bfd_elf32_swap_reloc_in,
6393   bfd_elf32_swap_reloc_out,
6394   bfd_elf32_swap_reloca_in,
6395   bfd_elf32_swap_reloca_out
6396 };
6397
6398 #define ELF_ARCH                        bfd_arch_arm
6399 #define ELF_MACHINE_CODE                EM_ARM
6400 #ifdef __QNXTARGET__
6401 #define ELF_MAXPAGESIZE                 0x1000
6402 #else
6403 #define ELF_MAXPAGESIZE                 0x8000
6404 #endif
6405 #define ELF_MINPAGESIZE                 0x1000
6406
6407 #define bfd_elf32_mkobject                      elf32_arm_mkobject
6408
6409 #define bfd_elf32_bfd_copy_private_bfd_data     elf32_arm_copy_private_bfd_data
6410 #define bfd_elf32_bfd_merge_private_bfd_data    elf32_arm_merge_private_bfd_data
6411 #define bfd_elf32_bfd_set_private_flags         elf32_arm_set_private_flags
6412 #define bfd_elf32_bfd_print_private_bfd_data    elf32_arm_print_private_bfd_data
6413 #define bfd_elf32_bfd_link_hash_table_create    elf32_arm_link_hash_table_create
6414 #define bfd_elf32_bfd_reloc_type_lookup         elf32_arm_reloc_type_lookup
6415 #define bfd_elf32_find_nearest_line             elf32_arm_find_nearest_line
6416 #define bfd_elf32_new_section_hook              elf32_arm_new_section_hook
6417 #define bfd_elf32_bfd_is_target_special_symbol  elf32_arm_is_target_special_symbol
6418
6419 #define elf_backend_get_symbol_type             elf32_arm_get_symbol_type
6420 #define elf_backend_gc_mark_hook                elf32_arm_gc_mark_hook
6421 #define elf_backend_gc_sweep_hook               elf32_arm_gc_sweep_hook
6422 #define elf_backend_check_relocs                elf32_arm_check_relocs
6423 #define elf_backend_relocate_section            elf32_arm_relocate_section
6424 #define elf_backend_write_section               elf32_arm_write_section
6425 #define elf_backend_adjust_dynamic_symbol       elf32_arm_adjust_dynamic_symbol
6426 #define elf_backend_create_dynamic_sections     elf32_arm_create_dynamic_sections
6427 #define elf_backend_finish_dynamic_symbol       elf32_arm_finish_dynamic_symbol
6428 #define elf_backend_finish_dynamic_sections     elf32_arm_finish_dynamic_sections
6429 #define elf_backend_link_output_symbol_hook     elf32_arm_output_symbol_hook
6430 #define elf_backend_size_dynamic_sections       elf32_arm_size_dynamic_sections
6431 #define elf_backend_post_process_headers        elf32_arm_post_process_headers
6432 #define elf_backend_reloc_type_class            elf32_arm_reloc_type_class
6433 #define elf_backend_object_p                    elf32_arm_object_p
6434 #define elf_backend_section_flags               elf32_arm_section_flags
6435 #define elf_backend_fake_sections               elf32_arm_fake_sections
6436 #define elf_backend_section_from_shdr           elf32_arm_section_from_shdr
6437 #define elf_backend_final_write_processing      elf32_arm_final_write_processing
6438 #define elf_backend_copy_indirect_symbol        elf32_arm_copy_indirect_symbol
6439 #define elf_backend_symbol_processing           elf32_arm_symbol_processing
6440 #define elf_backend_size_info                   elf32_arm_size_info
6441 #define elf_backend_modify_segment_map          elf32_arm_modify_segment_map
6442 #define elf_backend_additional_program_headers \
6443   elf32_arm_additional_program_headers
6444
6445 #define elf_backend_can_refcount    1
6446 #define elf_backend_can_gc_sections 1
6447 #define elf_backend_plt_readonly    1
6448 #define elf_backend_want_got_plt    1
6449 #define elf_backend_want_plt_sym    0
6450 #define elf_backend_may_use_rel_p   1
6451 #define elf_backend_may_use_rela_p  0
6452 #define elf_backend_default_use_rela_p 0
6453 #define elf_backend_rela_normal     0
6454
6455 #define elf_backend_got_header_size     12
6456
6457 #include "elf32-target.h"
6458
6459 /* VxWorks Targets */
6460
6461 #undef TARGET_LITTLE_SYM
6462 #define TARGET_LITTLE_SYM               bfd_elf32_littlearm_vxworks_vec
6463 #undef TARGET_LITTLE_NAME
6464 #define TARGET_LITTLE_NAME              "elf32-littlearm-vxworks"
6465 #undef TARGET_BIG_SYM
6466 #define TARGET_BIG_SYM                  bfd_elf32_bigarm_vxworks_vec
6467 #undef TARGET_BIG_NAME
6468 #define TARGET_BIG_NAME                 "elf32-bigarm-vxworks"
6469
6470 /* Like elf32_arm_link_hash_table_create -- but overrides
6471    appropriately for VxWorks.  */
6472 static struct bfd_link_hash_table *
6473 elf32_arm_vxworks_link_hash_table_create (bfd *abfd)
6474 {
6475   struct bfd_link_hash_table *ret;
6476
6477   ret = elf32_arm_link_hash_table_create (abfd);
6478   if (ret)
6479     {
6480       struct elf32_arm_link_hash_table *htab
6481         = (struct elf32_arm_link_hash_table *)ret;
6482       htab->use_rel = 0;
6483     }
6484   return ret;
6485 }
6486
6487 #undef elf32_bed
6488 #define elf32_bed elf32_arm_vxworks_bed
6489
6490 #undef bfd_elf32_bfd_link_hash_table_create
6491 #define bfd_elf32_bfd_link_hash_table_create \
6492   elf32_arm_vxworks_link_hash_table_create
6493
6494 #undef elf_backend_may_use_rel_p
6495 #define elf_backend_may_use_rel_p   0
6496 #undef elf_backend_may_use_rela_p
6497 #define elf_backend_may_use_rela_p  1
6498 #undef elf_backend_default_use_rela_p
6499 #define elf_backend_default_use_rela_p 1
6500 #undef elf_backend_rela_normal
6501 #define elf_backend_rela_normal     1
6502
6503 #include "elf32-target.h"
6504
6505
6506 /* Symbian OS Targets */
6507
6508 #undef TARGET_LITTLE_SYM
6509 #define TARGET_LITTLE_SYM               bfd_elf32_littlearm_symbian_vec
6510 #undef TARGET_LITTLE_NAME
6511 #define TARGET_LITTLE_NAME              "elf32-littlearm-symbian"
6512 #undef TARGET_BIG_SYM
6513 #define TARGET_BIG_SYM                  bfd_elf32_bigarm_symbian_vec
6514 #undef TARGET_BIG_NAME
6515 #define TARGET_BIG_NAME                 "elf32-bigarm-symbian"
6516
6517 /* Like elf32_arm_link_hash_table_create -- but overrides
6518    appropriately for Symbian OS.  */
6519 static struct bfd_link_hash_table *
6520 elf32_arm_symbian_link_hash_table_create (bfd *abfd)
6521 {
6522   struct bfd_link_hash_table *ret;
6523
6524   ret = elf32_arm_link_hash_table_create (abfd);
6525   if (ret)
6526     {
6527       struct elf32_arm_link_hash_table *htab
6528         = (struct elf32_arm_link_hash_table *)ret;
6529       /* There is no PLT header for Symbian OS.  */
6530       htab->plt_header_size = 0;
6531       /* The PLT entries are each three instructions.  */
6532       htab->plt_entry_size = 4 * NUM_ELEM (elf32_arm_symbian_plt_entry);
6533       htab->symbian_p = 1;
6534       /* Symbian uses armv5t or above, so use_blx is always true.  */
6535       htab->use_blx = 1;
6536       htab->root.is_relocatable_executable = 1;
6537     }
6538   return ret;
6539 }
6540
6541 static struct bfd_elf_special_section const
6542   elf32_arm_symbian_special_sections[]=
6543 {
6544   /* In a BPABI executable, the dynamic linking sections do not go in
6545      the loadable read-only segment.  The post-linker may wish to
6546      refer to these sections, but they are not part of the final
6547      program image.  */
6548   { ".dynamic",        8,  0, SHT_DYNAMIC,  0 },
6549   { ".dynstr",         7,  0, SHT_STRTAB,   0 },
6550   { ".dynsym",         7,  0, SHT_DYNSYM,   0 },
6551   { ".got",            4,  0, SHT_PROGBITS, 0 },
6552   { ".hash",           5,  0, SHT_HASH,     0 },
6553   /* These sections do not need to be writable as the SymbianOS
6554      postlinker will arrange things so that no dynamic relocation is
6555      required.  */
6556   { ".init_array",    11,  0, SHT_INIT_ARRAY, SHF_ALLOC },
6557   { ".fini_array",    11,  0, SHT_FINI_ARRAY, SHF_ALLOC },
6558   { ".preinit_array", 14,  0, SHT_PREINIT_ARRAY, SHF_ALLOC },
6559   { NULL,              0,  0, 0,            0 }
6560 };
6561
6562 static void
6563 elf32_arm_symbian_begin_write_processing (bfd *abfd,
6564                                           struct bfd_link_info *link_info
6565                                             ATTRIBUTE_UNUSED)
6566 {
6567   /* BPABI objects are never loaded directly by an OS kernel; they are
6568      processed by a postlinker first, into an OS-specific format.  If
6569      the D_PAGED bit is set on the file, BFD will align segments on
6570      page boundaries, so that an OS can directly map the file.  With
6571      BPABI objects, that just results in wasted space.  In addition,
6572      because we clear the D_PAGED bit, map_sections_to_segments will
6573      recognize that the program headers should not be mapped into any
6574      loadable segment.  */
6575   abfd->flags &= ~D_PAGED;
6576 }
6577
6578 static bfd_boolean
6579 elf32_arm_symbian_modify_segment_map (bfd *abfd,
6580                                       struct bfd_link_info *info)
6581 {
6582   struct elf_segment_map *m;
6583   asection *dynsec;
6584
6585   /* BPABI shared libraries and executables should have a PT_DYNAMIC
6586      segment.  However, because the .dynamic section is not marked
6587      with SEC_LOAD, the generic ELF code will not create such a
6588      segment.  */
6589   dynsec = bfd_get_section_by_name (abfd, ".dynamic");
6590   if (dynsec)
6591     {
6592       m = _bfd_elf_make_dynamic_segment (abfd, dynsec);
6593       m->next = elf_tdata (abfd)->segment_map;
6594       elf_tdata (abfd)->segment_map = m;
6595     }
6596
6597   /* Also call the generic arm routine.  */
6598   return elf32_arm_modify_segment_map (abfd, info);
6599 }
6600
6601 #undef elf32_bed
6602 #define elf32_bed elf32_arm_symbian_bed
6603
6604 /* The dynamic sections are not allocated on SymbianOS; the postlinker
6605    will process them and then discard them.  */
6606 #undef ELF_DYNAMIC_SEC_FLAGS
6607 #define ELF_DYNAMIC_SEC_FLAGS \
6608   (SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED)
6609
6610 #undef bfd_elf32_bfd_link_hash_table_create
6611 #define bfd_elf32_bfd_link_hash_table_create \
6612   elf32_arm_symbian_link_hash_table_create
6613
6614 #undef elf_backend_special_sections
6615 #define elf_backend_special_sections elf32_arm_symbian_special_sections
6616
6617 #undef elf_backend_begin_write_processing
6618 #define elf_backend_begin_write_processing \
6619     elf32_arm_symbian_begin_write_processing
6620
6621 #undef elf_backend_modify_segment_map
6622 #define elf_backend_modify_segment_map elf32_arm_symbian_modify_segment_map
6623
6624 /* There is no .got section for BPABI objects, and hence no header.  */
6625 #undef elf_backend_got_header_size
6626 #define elf_backend_got_header_size 0
6627
6628 /* Similarly, there is no .got.plt section.  */
6629 #undef elf_backend_want_got_plt
6630 #define elf_backend_want_got_plt 0
6631
6632 #undef elf_backend_may_use_rel_p
6633 #define elf_backend_may_use_rel_p   1
6634 #undef elf_backend_may_use_rela_p
6635 #define elf_backend_may_use_rela_p  0
6636 #undef elf_backend_default_use_rela_p
6637 #define elf_backend_default_use_rela_p 0
6638 #undef elf_backend_rela_normal
6639 #define elf_backend_rela_normal     0
6640
6641 #include "elf32-target.h"