bfd/elf32-arm.c

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