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