bfd/elf32-arm.c

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