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 {
2247   unsigned long                 r_type = howto->type;
2248   unsigned long                 r_symndx;
2249   bfd_byte *                    hit_data = contents + rel->r_offset;
2250   bfd *                         dynobj = NULL;
2251   Elf_Internal_Shdr *           symtab_hdr;
2252   struct elf_link_hash_entry ** sym_hashes;
2253   bfd_vma *                     local_got_offsets;
2254   asection *                    sgot = NULL;
2255   asection *                    splt = NULL;
2256   asection *                    sreloc = NULL;
2257   bfd_vma                       addend;
2258   bfd_signed_vma                signed_addend;
2259   struct elf32_arm_link_hash_table * globals;
2260
2261   globals = elf32_arm_hash_table (info);
2262
2263 #ifndef OLD_ARM_ABI
2264   /* Some relocation type map to different relocations depending on the
2265      target.  We pick the right one here.  */
2266   r_type = arm_real_reloc_type (globals, r_type);
2267   if (r_type != howto->type)
2268     howto = elf32_arm_howto_from_type (r_type);
2269 #endif /* OLD_ARM_ABI */
2270
2271   /* If the start address has been set, then set the EF_ARM_HASENTRY
2272      flag.  Setting this more than once is redundant, but the cost is
2273      not too high, and it keeps the code simple.
2274
2275      The test is done  here, rather than somewhere else, because the
2276      start address is only set just before the final link commences.
2277
2278      Note - if the user deliberately sets a start address of 0, the
2279      flag will not be set.  */
2280   if (bfd_get_start_address (output_bfd) != 0)
2281     elf_elfheader (output_bfd)->e_flags |= EF_ARM_HASENTRY;
2282
2283   dynobj = elf_hash_table (info)->dynobj;
2284   if (dynobj)
2285     {
2286       sgot = bfd_get_section_by_name (dynobj, ".got");
2287       splt = bfd_get_section_by_name (dynobj, ".plt");
2288     }
2289   symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
2290   sym_hashes = elf_sym_hashes (input_bfd);
2291   local_got_offsets = elf_local_got_offsets (input_bfd);
2292   r_symndx = ELF32_R_SYM (rel->r_info);
2293
2294   if (globals->use_rel)
2295     {
2296       addend = bfd_get_32 (input_bfd, hit_data) & howto->src_mask;
2297
2298       if (addend & ((howto->src_mask + 1) >> 1))
2299         {
2300           signed_addend = -1;
2301           signed_addend &= ~ howto->src_mask;
2302           signed_addend |= addend;
2303         }
2304       else
2305         signed_addend = addend;
2306     }
2307   else
2308     addend = signed_addend = rel->r_addend;
2309
2310   switch (r_type)
2311     {
2312     case R_ARM_NONE:
2313       return bfd_reloc_ok;
2314
2315     case R_ARM_PC24:
2316     case R_ARM_ABS32:
2317     case R_ARM_REL32:
2318 #ifndef OLD_ARM_ABI
2319     case R_ARM_CALL:
2320     case R_ARM_JUMP24:
2321     case R_ARM_XPC25:
2322     case R_ARM_PREL31:
2323 #endif
2324     case R_ARM_PLT32:
2325       /* r_symndx will be zero only for relocs against symbols
2326          from removed linkonce sections, or sections discarded by
2327          a linker script.  */
2328       if (r_symndx == 0)
2329         return bfd_reloc_ok;
2330
2331       /* Handle relocations which should use the PLT entry.  ABS32/REL32
2332          will use the symbol's value, which may point to a PLT entry, but we
2333          don't need to handle that here.  If we created a PLT entry, all
2334          branches in this object should go to it.  */
2335       if ((r_type != R_ARM_ABS32 && r_type != R_ARM_REL32)
2336           && h != NULL
2337           && splt != NULL
2338           && h->plt.offset != (bfd_vma) -1)
2339         {
2340           /* If we've created a .plt section, and assigned a PLT entry to
2341              this function, it should not be known to bind locally.  If
2342              it were, we would have cleared the PLT entry.  */
2343           BFD_ASSERT (!SYMBOL_CALLS_LOCAL (info, h));
2344
2345           value = (splt->output_section->vma
2346                    + splt->output_offset
2347                    + h->plt.offset);
2348           return _bfd_final_link_relocate (howto, input_bfd, input_section,
2349                                            contents, rel->r_offset, value,
2350                                            (bfd_vma) 0);
2351         }
2352
2353       /* When generating a shared object or relocatable executable, these
2354          relocations are copied into the output file to be resolved at
2355          run time.  */
2356       if ((info->shared || globals->root.is_relocatable_executable)
2357           && (input_section->flags & SEC_ALLOC)
2358           && (r_type != R_ARM_REL32
2359               || !SYMBOL_CALLS_LOCAL (info, h))
2360           && (h == NULL
2361               || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2362               || h->root.type != bfd_link_hash_undefweak)
2363           && r_type != R_ARM_PC24
2364 #ifndef OLD_ARM_ABI
2365           && r_type != R_ARM_CALL
2366           && r_type != R_ARM_JUMP24
2367           && r_type != R_ARM_PREL31
2368 #endif
2369           && r_type != R_ARM_PLT32)
2370         {
2371           Elf_Internal_Rela outrel;
2372           bfd_byte *loc;
2373           bfd_boolean skip, relocate;
2374
2375           if (sreloc == NULL)
2376             {
2377               const char * name;
2378
2379               name = (bfd_elf_string_from_elf_section
2380                       (input_bfd,
2381                        elf_elfheader (input_bfd)->e_shstrndx,
2382                        elf_section_data (input_section)->rel_hdr.sh_name));
2383               if (name == NULL)
2384                 return bfd_reloc_notsupported;
2385
2386               BFD_ASSERT (strncmp (name, ".rel", 4) == 0
2387                           && strcmp (bfd_get_section_name (input_bfd,
2388                                                            input_section),
2389                                      name + 4) == 0);
2390
2391               sreloc = bfd_get_section_by_name (dynobj, name);
2392               BFD_ASSERT (sreloc != NULL);
2393             }
2394
2395           skip = FALSE;
2396           relocate = FALSE;
2397
2398           outrel.r_offset =
2399             _bfd_elf_section_offset (output_bfd, info, input_section,
2400                                      rel->r_offset);
2401           if (outrel.r_offset == (bfd_vma) -1)
2402             skip = TRUE;
2403           else if (outrel.r_offset == (bfd_vma) -2)
2404             skip = TRUE, relocate = TRUE;
2405           outrel.r_offset += (input_section->output_section->vma
2406                               + input_section->output_offset);
2407
2408           if (skip)
2409             memset (&outrel, 0, sizeof outrel);
2410           else if (h != NULL
2411                    && h->dynindx != -1
2412                    && (!info->shared
2413                        || !info->symbolic
2414                        || !h->def_regular))
2415             outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2416           else
2417             {
2418               int symbol;
2419
2420               /* This symbol is local, or marked to become local.  */
2421               relocate = TRUE;
2422               if (sym_flags == STT_ARM_TFUNC)
2423                 value |= 1;
2424               if (globals->symbian_p)
2425                 {
2426                   /* On Symbian OS, the data segment and text segement
2427                      can be relocated independently.  Therefore, we
2428                      must indicate the segment to which this
2429                      relocation is relative.  The BPABI allows us to
2430                      use any symbol in the right segment; we just use
2431                      the section symbol as it is convenient.  (We
2432                      cannot use the symbol given by "h" directly as it
2433                      will not appear in the dynamic symbol table.)  */
2434                   symbol = elf_section_data (sym_sec->output_section)->dynindx;
2435                   BFD_ASSERT (symbol != 0);
2436                 }
2437               else
2438                 /* On SVR4-ish systems, the dynamic loader cannot
2439                    relocate the text and data segments independently,
2440                    so the symbol does not matter.  */
2441                 symbol = 0;
2442               outrel.r_info = ELF32_R_INFO (symbol, R_ARM_RELATIVE);
2443             }
2444
2445           loc = sreloc->contents;
2446           loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rel);
2447           bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2448
2449           /* If this reloc is against an external symbol, we do not want to
2450              fiddle with the addend.  Otherwise, we need to include the symbol
2451              value so that it becomes an addend for the dynamic reloc.  */
2452           if (! relocate)
2453             return bfd_reloc_ok;
2454
2455           return _bfd_final_link_relocate (howto, input_bfd, input_section,
2456                                            contents, rel->r_offset, value,
2457                                            (bfd_vma) 0);
2458         }
2459       else switch (r_type)
2460         {
2461 #ifndef OLD_ARM_ABI
2462         case R_ARM_XPC25:         /* Arm BLX instruction.  */
2463         case R_ARM_CALL:
2464         case R_ARM_JUMP24:
2465 #endif
2466         case R_ARM_PC24:          /* Arm B/BL instruction */
2467         case R_ARM_PLT32:
2468 #ifndef OLD_ARM_ABI
2469           if (r_type == R_ARM_XPC25)
2470             {
2471               /* Check for Arm calling Arm function.  */
2472               /* FIXME: Should we translate the instruction into a BL
2473                  instruction instead ?  */
2474               if (sym_flags != STT_ARM_TFUNC)
2475                 (*_bfd_error_handler)
2476                   (_("\%B: Warning: Arm BLX instruction targets Arm function '%s'."),
2477                    input_bfd,
2478                    h ? h->root.root.string : "(local)");
2479             }
2480           else
2481 #endif
2482             {
2483               /* Check for Arm calling Thumb function.  */
2484               if (sym_flags == STT_ARM_TFUNC)
2485                 {
2486                   elf32_arm_to_thumb_stub (info, sym_name, input_bfd,
2487                                            output_bfd, input_section,
2488                                            hit_data, sym_sec, rel->r_offset,
2489                                            signed_addend, value);
2490                   return bfd_reloc_ok;
2491                 }
2492             }
2493
2494           /* The ARM ELF ABI says that this reloc is computed as: S - P + A
2495              where:
2496               S is the address of the symbol in the relocation.
2497               P is address of the instruction being relocated.
2498               A is the addend (extracted from the instruction) in bytes.
2499
2500              S is held in 'value'.
2501              P is the base address of the section containing the
2502                instruction plus the offset of the reloc into that
2503                section, ie:
2504                  (input_section->output_section->vma +
2505                   input_section->output_offset +
2506                   rel->r_offset).
2507              A is the addend, converted into bytes, ie:
2508                  (signed_addend * 4)
2509
2510              Note: None of these operations have knowledge of the pipeline
2511              size of the processor, thus it is up to the assembler to
2512              encode this information into the addend.  */
2513           value -= (input_section->output_section->vma
2514                     + input_section->output_offset);
2515           value -= rel->r_offset;
2516           if (globals->use_rel)
2517             value += (signed_addend << howto->size);
2518           else
2519             /* RELA addends do not have to be adjusted by howto->size.  */
2520             value += signed_addend;
2521
2522           signed_addend = value;
2523           signed_addend >>= howto->rightshift;
2524
2525           /* It is not an error for an undefined weak reference to be
2526              out of range.  Any program that branches to such a symbol
2527              is going to crash anyway, so there is no point worrying
2528              about getting the destination exactly right.  */
2529           if (! h || h->root.type != bfd_link_hash_undefweak)
2530             {
2531               /* Perform a signed range check.  */
2532               if (   signed_addend >   ((bfd_signed_vma)  (howto->dst_mask >> 1))
2533                   || signed_addend < - ((bfd_signed_vma) ((howto->dst_mask + 1) >> 1)))
2534                 return bfd_reloc_overflow;
2535             }
2536
2537 #ifndef OLD_ARM_ABI
2538           /* If necessary set the H bit in the BLX instruction.  */
2539           if (r_type == R_ARM_XPC25 && ((value & 2) == 2))
2540             value = (signed_addend & howto->dst_mask)
2541               | (bfd_get_32 (input_bfd, hit_data) & (~ howto->dst_mask))
2542               | (1 << 24);
2543           else
2544 #endif
2545             value = (signed_addend & howto->dst_mask)
2546               | (bfd_get_32 (input_bfd, hit_data) & (~ howto->dst_mask));
2547           break;
2548
2549         case R_ARM_ABS32:
2550           value += addend;
2551           if (sym_flags == STT_ARM_TFUNC)
2552             value |= 1;
2553           break;
2554
2555         case R_ARM_REL32:
2556           value -= (input_section->output_section->vma
2557                     + input_section->output_offset + rel->r_offset);
2558           value += addend;
2559           break;
2560
2561 #ifndef OLD_ARM_ABI
2562         case R_ARM_PREL31:
2563           value -= (input_section->output_section->vma
2564                     + input_section->output_offset + rel->r_offset);
2565           value += signed_addend;
2566           if (! h || h->root.type != bfd_link_hash_undefweak)
2567             {
2568               /* Check for overflow */
2569               if ((value ^ (value >> 1)) & (1 << 30))
2570                 return bfd_reloc_overflow;
2571             }
2572           value &= 0x7fffffff;
2573           value |= (bfd_get_32 (input_bfd, hit_data) & 0x80000000);
2574           if (sym_flags == STT_ARM_TFUNC)
2575             value |= 1;
2576           break;
2577 #endif
2578         }
2579
2580       bfd_put_32 (input_bfd, value, hit_data);
2581       return bfd_reloc_ok;
2582
2583     case R_ARM_ABS8:
2584       value += addend;
2585       if ((long) value > 0x7f || (long) value < -0x80)
2586         return bfd_reloc_overflow;
2587
2588       bfd_put_8 (input_bfd, value, hit_data);
2589       return bfd_reloc_ok;
2590
2591     case R_ARM_ABS16:
2592       value += addend;
2593
2594       if ((long) value > 0x7fff || (long) value < -0x8000)
2595         return bfd_reloc_overflow;
2596
2597       bfd_put_16 (input_bfd, value, hit_data);
2598       return bfd_reloc_ok;
2599
2600     case R_ARM_ABS12:
2601       /* Support ldr and str instruction for the arm */
2602       /* Also thumb b (unconditional branch).  ??? Really?  */
2603       value += addend;
2604
2605       if ((long) value > 0x7ff || (long) value < -0x800)
2606         return bfd_reloc_overflow;
2607
2608       value |= (bfd_get_32 (input_bfd, hit_data) & 0xfffff000);
2609       bfd_put_32 (input_bfd, value, hit_data);
2610       return bfd_reloc_ok;
2611
2612     case R_ARM_THM_ABS5:
2613       /* Support ldr and str instructions for the thumb.  */
2614       if (globals->use_rel)
2615         {
2616           /* Need to refetch addend.  */
2617           addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
2618           /* ??? Need to determine shift amount from operand size.  */
2619           addend >>= howto->rightshift;
2620         }
2621       value += addend;
2622
2623       /* ??? Isn't value unsigned?  */
2624       if ((long) value > 0x1f || (long) value < -0x10)
2625         return bfd_reloc_overflow;
2626
2627       /* ??? Value needs to be properly shifted into place first.  */
2628       value |= bfd_get_16 (input_bfd, hit_data) & 0xf83f;
2629       bfd_put_16 (input_bfd, value, hit_data);
2630       return bfd_reloc_ok;
2631
2632 #ifndef OLD_ARM_ABI
2633     case R_ARM_THM_XPC22:
2634 #endif
2635     case R_ARM_THM_PC22:
2636       /* Thumb BL (branch long instruction).  */
2637       {
2638         bfd_vma relocation;
2639         bfd_boolean overflow = FALSE;
2640         bfd_vma upper_insn = bfd_get_16 (input_bfd, hit_data);
2641         bfd_vma lower_insn = bfd_get_16 (input_bfd, hit_data + 2);
2642         bfd_signed_vma reloc_signed_max = ((1 << (howto->bitsize - 1)) - 1) >> howto->rightshift;
2643         bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
2644         bfd_vma check;
2645         bfd_signed_vma signed_check;
2646
2647         /* Need to refetch the addend and squish the two 11 bit pieces
2648            together.  */
2649         if (globals->use_rel)
2650           {
2651             bfd_vma upper = upper_insn & 0x7ff;
2652             bfd_vma lower = lower_insn & 0x7ff;
2653             upper = (upper ^ 0x400) - 0x400; /* Sign extend.  */
2654             addend = (upper << 12) | (lower << 1);
2655             signed_addend = addend;
2656           }
2657 #ifndef OLD_ARM_ABI
2658         if (r_type == R_ARM_THM_XPC22)
2659           {
2660             /* Check for Thumb to Thumb call.  */
2661             /* FIXME: Should we translate the instruction into a BL
2662                instruction instead ?  */
2663             if (sym_flags == STT_ARM_TFUNC)
2664               (*_bfd_error_handler)
2665                 (_("%B: Warning: Thumb BLX instruction targets thumb function '%s'."),
2666                  input_bfd,
2667                  h ? h->root.root.string : "(local)");
2668           }
2669         else
2670 #endif
2671           {
2672             /* If it is not a call to Thumb, assume call to Arm.
2673                If it is a call relative to a section name, then it is not a
2674                function call at all, but rather a long jump.  Calls through
2675                the PLT do not require stubs.  */
2676             if (sym_flags != STT_ARM_TFUNC && sym_flags != STT_SECTION
2677                 && (h == NULL || splt == NULL
2678                     || h->plt.offset == (bfd_vma) -1))
2679               {
2680                 if (elf32_thumb_to_arm_stub
2681                     (info, sym_name, input_bfd, output_bfd, input_section,
2682                      hit_data, sym_sec, rel->r_offset, signed_addend, value))
2683                   return bfd_reloc_ok;
2684                 else
2685                   return bfd_reloc_dangerous;
2686               }
2687           }
2688
2689         /* Handle calls via the PLT.  */
2690         if (h != NULL && splt != NULL && h->plt.offset != (bfd_vma) -1)
2691           {
2692             value = (splt->output_section->vma
2693                      + splt->output_offset
2694                      + h->plt.offset);
2695             /* Target the Thumb stub before the ARM PLT entry.  */
2696             value -= 4;
2697           }
2698
2699         relocation = value + signed_addend;
2700
2701         relocation -= (input_section->output_section->vma
2702                        + input_section->output_offset
2703                        + rel->r_offset);
2704
2705         check = relocation >> howto->rightshift;
2706
2707         /* If this is a signed value, the rightshift just dropped
2708            leading 1 bits (assuming twos complement).  */
2709         if ((bfd_signed_vma) relocation >= 0)
2710           signed_check = check;
2711         else
2712           signed_check = check | ~((bfd_vma) -1 >> howto->rightshift);
2713
2714         /* Assumes two's complement.  */
2715         if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
2716           overflow = TRUE;
2717
2718 #ifndef OLD_ARM_ABI
2719         if (r_type == R_ARM_THM_XPC22
2720             && ((lower_insn & 0x1800) == 0x0800))
2721           /* For a BLX instruction, make sure that the relocation is rounded up
2722              to a word boundary.  This follows the semantics of the instruction
2723              which specifies that bit 1 of the target address will come from bit
2724              1 of the base address.  */
2725           relocation = (relocation + 2) & ~ 3;
2726 #endif
2727         /* Put RELOCATION back into the insn.  */
2728         upper_insn = (upper_insn & ~(bfd_vma) 0x7ff) | ((relocation >> 12) & 0x7ff);
2729         lower_insn = (lower_insn & ~(bfd_vma) 0x7ff) | ((relocation >> 1) & 0x7ff);
2730
2731         /* Put the relocated value back in the object file:  */
2732         bfd_put_16 (input_bfd, upper_insn, hit_data);
2733         bfd_put_16 (input_bfd, lower_insn, hit_data + 2);
2734
2735         return (overflow ? bfd_reloc_overflow : bfd_reloc_ok);
2736       }
2737       break;
2738
2739     case R_ARM_THM_PC11:
2740     case R_ARM_THM_PC9:
2741       /* Thumb B (branch) instruction).  */
2742       {
2743         bfd_signed_vma relocation;
2744         bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
2745         bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
2746         bfd_signed_vma signed_check;
2747
2748         if (globals->use_rel)
2749           {
2750             /* Need to refetch addend.  */
2751             addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
2752             if (addend & ((howto->src_mask + 1) >> 1))
2753               {
2754                 signed_addend = -1;
2755                 signed_addend &= ~ howto->src_mask;
2756                 signed_addend |= addend;
2757               }
2758             else
2759               signed_addend = addend;
2760             /* The value in the insn has been right shifted.  We need to
2761                undo this, so that we can perform the address calculation
2762                in terms of bytes.  */
2763             signed_addend <<= howto->rightshift;
2764           }
2765         relocation = value + signed_addend;
2766
2767         relocation -= (input_section->output_section->vma
2768                        + input_section->output_offset
2769                        + rel->r_offset);
2770
2771         relocation >>= howto->rightshift;
2772         signed_check = relocation;
2773         relocation &= howto->dst_mask;
2774         relocation |= (bfd_get_16 (input_bfd, hit_data) & (~ howto->dst_mask));
2775
2776         bfd_put_16 (input_bfd, relocation, hit_data);
2777
2778         /* Assumes two's complement.  */
2779         if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
2780           return bfd_reloc_overflow;
2781
2782         return bfd_reloc_ok;
2783       }
2784
2785 #ifndef OLD_ARM_ABI
2786     case R_ARM_ALU_PCREL7_0:
2787     case R_ARM_ALU_PCREL15_8:
2788     case R_ARM_ALU_PCREL23_15:
2789       {
2790         bfd_vma insn;
2791         bfd_vma relocation;
2792
2793         insn = bfd_get_32 (input_bfd, hit_data);
2794         if (globals->use_rel)
2795           {
2796             /* Extract the addend.  */
2797             addend = (insn & 0xff) << ((insn & 0xf00) >> 7);
2798             signed_addend = addend;
2799           }
2800         relocation = value + signed_addend;
2801
2802         relocation -= (input_section->output_section->vma
2803                        + input_section->output_offset
2804                        + rel->r_offset);
2805         insn = (insn & ~0xfff)
2806                | ((howto->bitpos << 7) & 0xf00)
2807                | ((relocation >> howto->bitpos) & 0xff);
2808         bfd_put_32 (input_bfd, value, hit_data);
2809       }
2810       return bfd_reloc_ok;
2811 #endif
2812
2813     case R_ARM_GNU_VTINHERIT:
2814     case R_ARM_GNU_VTENTRY:
2815       return bfd_reloc_ok;
2816
2817     case R_ARM_COPY:
2818       return bfd_reloc_notsupported;
2819
2820     case R_ARM_GLOB_DAT:
2821       return bfd_reloc_notsupported;
2822
2823     case R_ARM_JUMP_SLOT:
2824       return bfd_reloc_notsupported;
2825
2826     case R_ARM_RELATIVE:
2827       return bfd_reloc_notsupported;
2828
2829     case R_ARM_GOTOFF:
2830       /* Relocation is relative to the start of the
2831          global offset table.  */
2832
2833       BFD_ASSERT (sgot != NULL);
2834       if (sgot == NULL)
2835         return bfd_reloc_notsupported;
2836
2837       /* If we are addressing a Thumb function, we need to adjust the
2838          address by one, so that attempts to call the function pointer will
2839          correctly interpret it as Thumb code.  */
2840       if (sym_flags == STT_ARM_TFUNC)
2841         value += 1;
2842
2843       /* Note that sgot->output_offset is not involved in this
2844          calculation.  We always want the start of .got.  If we
2845          define _GLOBAL_OFFSET_TABLE in a different way, as is
2846          permitted by the ABI, we might have to change this
2847          calculation.  */
2848       value -= sgot->output_section->vma;
2849       return _bfd_final_link_relocate (howto, input_bfd, input_section,
2850                                        contents, rel->r_offset, value,
2851                                        (bfd_vma) 0);
2852
2853     case R_ARM_GOTPC:
2854       /* Use global offset table as symbol value.  */
2855       BFD_ASSERT (sgot != NULL);
2856
2857       if (sgot == NULL)
2858         return bfd_reloc_notsupported;
2859
2860       value = sgot->output_section->vma;
2861       return _bfd_final_link_relocate (howto, input_bfd, input_section,
2862                                        contents, rel->r_offset, value,
2863                                        (bfd_vma) 0);
2864
2865     case R_ARM_GOT32:
2866 #ifndef OLD_ARM_ABI
2867     case R_ARM_GOT_PREL:
2868 #endif
2869       /* Relocation is to the entry for this symbol in the
2870          global offset table.  */
2871       if (sgot == NULL)
2872         return bfd_reloc_notsupported;
2873
2874       if (h != NULL)
2875         {
2876           bfd_vma off;
2877           bfd_boolean dyn;
2878
2879           off = h->got.offset;
2880           BFD_ASSERT (off != (bfd_vma) -1);
2881           dyn = globals->root.dynamic_sections_created;
2882
2883           if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2884               || (info->shared
2885                   && SYMBOL_REFERENCES_LOCAL (info, h))
2886               || (ELF_ST_VISIBILITY (h->other)
2887                   && h->root.type == bfd_link_hash_undefweak))
2888             {
2889               /* This is actually a static link, or it is a -Bsymbolic link
2890                  and the symbol is defined locally.  We must initialize this
2891                  entry in the global offset table.  Since the offset must
2892                  always be a multiple of 4, we use the least significant bit
2893                  to record whether we have initialized it already.
2894
2895                  When doing a dynamic link, we create a .rel.got relocation
2896                  entry to initialize the value.  This is done in the
2897                  finish_dynamic_symbol routine.  */
2898               if ((off & 1) != 0)
2899                 off &= ~1;
2900               else
2901                 {
2902                   /* If we are addressing a Thumb function, we need to
2903                      adjust the address by one, so that attempts to
2904                      call the function pointer will correctly
2905                      interpret it as Thumb code.  */
2906                   if (sym_flags == STT_ARM_TFUNC)
2907                     value |= 1;
2908
2909                   bfd_put_32 (output_bfd, value, sgot->contents + off);
2910                   h->got.offset |= 1;
2911                 }
2912             }
2913
2914           value = sgot->output_offset + off;
2915         }
2916       else
2917         {
2918           bfd_vma off;
2919
2920           BFD_ASSERT (local_got_offsets != NULL &&
2921                       local_got_offsets[r_symndx] != (bfd_vma) -1);
2922
2923           off = local_got_offsets[r_symndx];
2924
2925           /* The offset must always be a multiple of 4.  We use the
2926              least significant bit to record whether we have already
2927              generated the necessary reloc.  */
2928           if ((off & 1) != 0)
2929             off &= ~1;
2930           else
2931             {
2932               /* If we are addressing a Thumb function, we need to
2933                  adjust the address by one, so that attempts to
2934                  call the function pointer will correctly
2935                  interpret it as Thumb code.  */
2936               if (sym_flags == STT_ARM_TFUNC)
2937                 value |= 1;
2938
2939               bfd_put_32 (output_bfd, value, sgot->contents + off);
2940
2941               if (info->shared)
2942                 {
2943                   asection * srelgot;
2944                   Elf_Internal_Rela outrel;
2945                   bfd_byte *loc;
2946
2947                   srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
2948                   BFD_ASSERT (srelgot != NULL);
2949
2950                   outrel.r_offset = (sgot->output_section->vma
2951                                      + sgot->output_offset
2952                                      + off);
2953                   outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
2954                   loc = srelgot->contents;
2955                   loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rel);
2956                   bfd_elf32_swap_reloc_out (output_bfd, &outrel, loc);
2957                 }
2958
2959               local_got_offsets[r_symndx] |= 1;
2960             }
2961
2962           value = sgot->output_offset + off;
2963         }
2964       if (r_type != R_ARM_GOT32)
2965         value += sgot->output_section->vma;
2966
2967       return _bfd_final_link_relocate (howto, input_bfd, input_section,
2968                                        contents, rel->r_offset, value,
2969                                        (bfd_vma) 0);
2970
2971     case R_ARM_SBREL32:
2972       return bfd_reloc_notsupported;
2973
2974     case R_ARM_AMP_VCALL9:
2975       return bfd_reloc_notsupported;
2976
2977     case R_ARM_RSBREL32:
2978       return bfd_reloc_notsupported;
2979
2980     case R_ARM_THM_RPC22:
2981       return bfd_reloc_notsupported;
2982
2983     case R_ARM_RREL32:
2984       return bfd_reloc_notsupported;
2985
2986     case R_ARM_RABS32:
2987       return bfd_reloc_notsupported;
2988
2989     case R_ARM_RPC24:
2990       return bfd_reloc_notsupported;
2991
2992     case R_ARM_RBASE:
2993       return bfd_reloc_notsupported;
2994
2995     case R_ARM_V4BX:
2996       if (globals->fix_v4bx)
2997         {
2998           bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
2999
3000           /* Ensure that we have a BX instruction.  */
3001           BFD_ASSERT ((insn & 0x0ffffff0) == 0x012fff10);
3002
3003           /* Preserve Rm (lowest four bits) and the condition code
3004              (highest four bits). Other bits encode MOV PC,Rm.  */
3005           insn = (insn & 0xf000000f) | 0x01a0f000;
3006
3007           bfd_put_32 (input_bfd, insn, hit_data);
3008         }
3009       return bfd_reloc_ok;
3010
3011     default:
3012       return bfd_reloc_notsupported;
3013     }
3014 }
3015
3016 /* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS.  */
3017 static void
3018 arm_add_to_rel (bfd *              abfd,
3019                 bfd_byte *         address,
3020                 reloc_howto_type * howto,
3021                 bfd_signed_vma     increment)
3022 {
3023   bfd_signed_vma addend;
3024
3025   if (howto->type == R_ARM_THM_PC22)
3026     {
3027       int upper_insn, lower_insn;
3028       int upper, lower;
3029
3030       upper_insn = bfd_get_16 (abfd, address);
3031       lower_insn = bfd_get_16 (abfd, address + 2);
3032       upper = upper_insn & 0x7ff;
3033       lower = lower_insn & 0x7ff;
3034
3035       addend = (upper << 12) | (lower << 1);
3036       addend += increment;
3037       addend >>= 1;
3038
3039       upper_insn = (upper_insn & 0xf800) | ((addend >> 11) & 0x7ff);
3040       lower_insn = (lower_insn & 0xf800) | (addend & 0x7ff);
3041
3042       bfd_put_16 (abfd, (bfd_vma) upper_insn, address);
3043       bfd_put_16 (abfd, (bfd_vma) lower_insn, address + 2);
3044     }
3045   else
3046     {
3047       bfd_vma        contents;
3048
3049       contents = bfd_get_32 (abfd, address);
3050
3051       /* Get the (signed) value from the instruction.  */
3052       addend = contents & howto->src_mask;
3053       if (addend & ((howto->src_mask + 1) >> 1))
3054         {
3055           bfd_signed_vma mask;
3056
3057           mask = -1;
3058           mask &= ~ howto->src_mask;
3059           addend |= mask;
3060         }
3061
3062       /* Add in the increment, (which is a byte value).  */
3063       switch (howto->type)
3064         {
3065         default:
3066           addend += increment;
3067           break;
3068
3069         case R_ARM_PC24:
3070 #ifndef OLD_ARM_ABI
3071         case R_ARM_CALL:
3072         case R_ARM_JUMP24:
3073 #endif
3074           addend <<= howto->size;
3075           addend += increment;
3076
3077           /* Should we check for overflow here ?  */
3078
3079           /* Drop any undesired bits.  */
3080           addend >>= howto->rightshift;
3081           break;
3082         }
3083
3084       contents = (contents & ~ howto->dst_mask) | (addend & howto->dst_mask);
3085
3086       bfd_put_32 (abfd, contents, address);
3087     }
3088 }
3089
3090 /* Relocate an ARM ELF section.  */
3091 static bfd_boolean
3092 elf32_arm_relocate_section (bfd *                  output_bfd,
3093                             struct bfd_link_info * info,
3094                             bfd *                  input_bfd,
3095                             asection *             input_section,
3096                             bfd_byte *             contents,
3097                             Elf_Internal_Rela *    relocs,
3098                             Elf_Internal_Sym *     local_syms,
3099                             asection **            local_sections)
3100 {
3101   Elf_Internal_Shdr *symtab_hdr;
3102   struct elf_link_hash_entry **sym_hashes;
3103   Elf_Internal_Rela *rel;
3104   Elf_Internal_Rela *relend;
3105   const char *name;
3106   struct elf32_arm_link_hash_table * globals;
3107
3108   globals = elf32_arm_hash_table (info);
3109   if (info->relocatable && !globals->use_rel)
3110     return TRUE;
3111
3112   symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
3113   sym_hashes = elf_sym_hashes (input_bfd);
3114
3115   rel = relocs;
3116   relend = relocs + input_section->reloc_count;
3117   for (; rel < relend; rel++)
3118     {
3119       int                          r_type;
3120       reloc_howto_type *           howto;
3121       unsigned long                r_symndx;
3122       Elf_Internal_Sym *           sym;
3123       asection *                   sec;
3124       struct elf_link_hash_entry * h;
3125       bfd_vma                      relocation;
3126       bfd_reloc_status_type        r;
3127       arelent                      bfd_reloc;
3128
3129       r_symndx = ELF32_R_SYM (rel->r_info);
3130       r_type   = ELF32_R_TYPE (rel->r_info);
3131       r_type   = arm_real_reloc_type (globals, r_type);
3132
3133       if (   r_type == R_ARM_GNU_VTENTRY
3134           || r_type == R_ARM_GNU_VTINHERIT)
3135         continue;
3136
3137       bfd_reloc.howto = elf32_arm_howto_from_type (r_type);
3138       howto = bfd_reloc.howto;
3139
3140       if (info->relocatable && globals->use_rel)
3141         {
3142           /* This is a relocatable link.  We don't have to change
3143              anything, unless the reloc is against a section symbol,
3144              in which case we have to adjust according to where the
3145              section symbol winds up in the output section.  */
3146           if (r_symndx < symtab_hdr->sh_info)
3147             {
3148               sym = local_syms + r_symndx;
3149               if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
3150                 {
3151                   sec = local_sections[r_symndx];
3152                   arm_add_to_rel (input_bfd, contents + rel->r_offset,
3153                                   howto,
3154                                   (bfd_signed_vma) (sec->output_offset
3155                                                     + sym->st_value));
3156                 }
3157             }
3158
3159           continue;
3160         }
3161
3162       /* This is a final link.  */
3163       h = NULL;
3164       sym = NULL;
3165       sec = NULL;
3166
3167       if (r_symndx < symtab_hdr->sh_info)
3168         {
3169           sym = local_syms + r_symndx;
3170           sec = local_sections[r_symndx];
3171           if (globals->use_rel)
3172             {
3173               relocation = (sec->output_section->vma
3174                             + sec->output_offset
3175                             + sym->st_value);
3176               if ((sec->flags & SEC_MERGE)
3177                        && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
3178                 {
3179                   asection *msec;
3180                   bfd_vma addend, value;
3181
3182                   if (howto->rightshift)
3183                     {
3184                       (*_bfd_error_handler)
3185                         (_("%B(%A+0x%lx): %s relocation against SEC_MERGE section"),
3186                          input_bfd, input_section,
3187                          (long) rel->r_offset, howto->name);
3188                       return FALSE;
3189                     }
3190
3191                   value = bfd_get_32 (input_bfd, contents + rel->r_offset);
3192
3193                   /* Get the (signed) value from the instruction.  */
3194                   addend = value & howto->src_mask;
3195                   if (addend & ((howto->src_mask + 1) >> 1))
3196                     {
3197                       bfd_signed_vma mask;
3198
3199                       mask = -1;
3200                       mask &= ~ howto->src_mask;
3201                       addend |= mask;
3202                     }
3203                   msec = sec;
3204                   addend =
3205                     _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend)
3206                     - relocation;
3207                   addend += msec->output_section->vma + msec->output_offset;
3208                   value = (value & ~ howto->dst_mask) | (addend & howto->dst_mask);
3209                   bfd_put_32 (input_bfd, value, contents + rel->r_offset);
3210                 }
3211             }
3212           else
3213             relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
3214         }
3215       else
3216         {
3217           bfd_boolean warned;
3218           bfd_boolean unresolved_reloc;
3219
3220           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
3221                                    r_symndx, symtab_hdr, sym_hashes,
3222                                    h, sec, relocation,
3223                                    unresolved_reloc, warned);
3224
3225           if (unresolved_reloc || relocation != 0)
3226             {
3227               /* In these cases, we don't need the relocation value.
3228                  We check specially because in some obscure cases
3229                  sec->output_section will be NULL.  */
3230               switch (r_type)
3231                 {
3232                 case R_ARM_PC24:
3233 #ifndef OLD_ARM_ABI
3234                 case R_ARM_CALL:
3235                 case R_ARM_JUMP24:
3236                 case R_ARM_PREL31:
3237 #endif
3238                 case R_ARM_ABS32:
3239                 case R_ARM_THM_PC22:
3240                 case R_ARM_PLT32:
3241
3242                   if (info->shared
3243                       && ((!info->symbolic && h->dynindx != -1)
3244                           || !h->def_regular)
3245                       && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3246                       && ((input_section->flags & SEC_ALLOC) != 0
3247                           /* DWARF will emit R_ARM_ABS32 relocations in its
3248                              sections against symbols defined externally
3249                              in shared libraries.  We can't do anything
3250                              with them here.  */
3251                           || ((input_section->flags & SEC_DEBUGGING) != 0
3252                               && h->def_dynamic))
3253                       )
3254                     relocation = 0;
3255                   break;
3256
3257                 case R_ARM_GOTPC:
3258                   relocation = 0;
3259                   break;
3260
3261                 case R_ARM_GOT32:
3262 #ifndef OLD_ARM_ABI
3263                 case R_ARM_GOT_PREL:
3264 #endif
3265                   if ((WILL_CALL_FINISH_DYNAMIC_SYMBOL
3266                        (elf_hash_table (info)->dynamic_sections_created,
3267                         info->shared, h))
3268                       && (!info->shared
3269                           || (!info->symbolic && h->dynindx != -1)
3270                           || !h->def_regular))
3271                     relocation = 0;
3272                   break;
3273
3274                 default:
3275                   if (unresolved_reloc)
3276                     _bfd_error_handler
3277                       (_("%B(%A): warning: unresolvable relocation %d against symbol `%s'"),
3278                        input_bfd, input_section,
3279                        r_type,
3280                        h->root.root.string);
3281                   break;
3282                 }
3283             }
3284         }
3285
3286       if (h != NULL)
3287         name = h->root.root.string;
3288       else
3289         {
3290           name = (bfd_elf_string_from_elf_section
3291                   (input_bfd, symtab_hdr->sh_link, sym->st_name));
3292           if (name == NULL || *name == '\0')
3293             name = bfd_section_name (input_bfd, sec);
3294         }
3295
3296       r = elf32_arm_final_link_relocate (howto, input_bfd, output_bfd,
3297                                          input_section, contents, rel,
3298                                          relocation, info, sec, name,
3299                                          (h ? ELF_ST_TYPE (h->type) :
3300                                           ELF_ST_TYPE (sym->st_info)), h);
3301
3302       if (r != bfd_reloc_ok)
3303         {
3304           const char * msg = (const char *) 0;
3305
3306           switch (r)
3307             {
3308             case bfd_reloc_overflow:
3309               /* If the overflowing reloc was to an undefined symbol,
3310                  we have already printed one error message and there
3311                  is no point complaining again.  */
3312               if ((! h ||
3313                    h->root.type != bfd_link_hash_undefined)
3314                   && (!((*info->callbacks->reloc_overflow)
3315                         (info, (h ? &h->root : NULL), name, howto->name,
3316                          (bfd_vma) 0, input_bfd, input_section,
3317                          rel->r_offset))))
3318                   return FALSE;
3319               break;
3320
3321             case bfd_reloc_undefined:
3322               if (!((*info->callbacks->undefined_symbol)
3323                     (info, name, input_bfd, input_section,
3324                      rel->r_offset, TRUE)))
3325                 return FALSE;
3326               break;
3327
3328             case bfd_reloc_outofrange:
3329               msg = _("internal error: out of range error");
3330               goto common_error;
3331
3332             case bfd_reloc_notsupported:
3333               msg = _("internal error: unsupported relocation error");
3334               goto common_error;
3335
3336             case bfd_reloc_dangerous:
3337               msg = _("internal error: dangerous error");
3338               goto common_error;
3339
3340             default:
3341               msg = _("internal error: unknown error");
3342               /* fall through */
3343
3344             common_error:
3345               if (!((*info->callbacks->warning)
3346                     (info, msg, name, input_bfd, input_section,
3347                      rel->r_offset)))
3348                 return FALSE;
3349               break;
3350             }
3351         }
3352     }
3353
3354   return TRUE;
3355 }
3356
3357 /* Set the right machine number.  */
3358
3359 static bfd_boolean
3360 elf32_arm_object_p (bfd *abfd)
3361 {
3362   unsigned int mach;
3363
3364   mach = bfd_arm_get_mach_from_notes (abfd, ARM_NOTE_SECTION);
3365
3366   if (mach != bfd_mach_arm_unknown)
3367     bfd_default_set_arch_mach (abfd, bfd_arch_arm, mach);
3368
3369   else if (elf_elfheader (abfd)->e_flags & EF_ARM_MAVERICK_FLOAT)
3370     bfd_default_set_arch_mach (abfd, bfd_arch_arm, bfd_mach_arm_ep9312);
3371
3372   else
3373     bfd_default_set_arch_mach (abfd, bfd_arch_arm, mach);
3374
3375   return TRUE;
3376 }
3377
3378 /* Function to keep ARM specific flags in the ELF header.  */
3379
3380 static bfd_boolean
3381 elf32_arm_set_private_flags (bfd *abfd, flagword flags)
3382 {
3383   if (elf_flags_init (abfd)
3384       && elf_elfheader (abfd)->e_flags != flags)
3385     {
3386       if (EF_ARM_EABI_VERSION (flags) == EF_ARM_EABI_UNKNOWN)
3387         {
3388           if (flags & EF_ARM_INTERWORK)
3389             (*_bfd_error_handler)
3390               (_("Warning: Not setting interworking flag of %B since it has already been specified as non-interworking"),
3391                abfd);
3392           else
3393             _bfd_error_handler
3394               (_("Warning: Clearing the interworking flag of %B due to outside request"),
3395                abfd);
3396         }
3397     }
3398   else
3399     {
3400       elf_elfheader (abfd)->e_flags = flags;
3401       elf_flags_init (abfd) = TRUE;
3402     }
3403
3404   return TRUE;
3405 }
3406
3407 /* Copy backend specific data from one object module to another.  */
3408
3409 static bfd_boolean
3410 elf32_arm_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
3411 {
3412   flagword in_flags;
3413   flagword out_flags;
3414
3415   if (   bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3416       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
3417     return TRUE;
3418
3419   in_flags  = elf_elfheader (ibfd)->e_flags;
3420   out_flags = elf_elfheader (obfd)->e_flags;
3421
3422   if (elf_flags_init (obfd)
3423       && EF_ARM_EABI_VERSION (out_flags) == EF_ARM_EABI_UNKNOWN
3424       && in_flags != out_flags)
3425     {
3426       /* Cannot mix APCS26 and APCS32 code.  */
3427       if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
3428         return FALSE;
3429
3430       /* Cannot mix float APCS and non-float APCS code.  */
3431       if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
3432         return FALSE;
3433
3434       /* If the src and dest have different interworking flags
3435          then turn off the interworking bit.  */
3436       if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
3437         {
3438           if (out_flags & EF_ARM_INTERWORK)
3439             _bfd_error_handler
3440               (_("Warning: Clearing the interworking flag of %B because non-interworking code in %B has been linked with it"),
3441                obfd, ibfd);
3442
3443           in_flags &= ~EF_ARM_INTERWORK;
3444         }
3445
3446       /* Likewise for PIC, though don't warn for this case.  */
3447       if ((in_flags & EF_ARM_PIC) != (out_flags & EF_ARM_PIC))
3448         in_flags &= ~EF_ARM_PIC;
3449     }
3450
3451   elf_elfheader (obfd)->e_flags = in_flags;
3452   elf_flags_init (obfd) = TRUE;
3453
3454   /* Also copy the EI_OSABI field.  */
3455   elf_elfheader (obfd)->e_ident[EI_OSABI] =
3456     elf_elfheader (ibfd)->e_ident[EI_OSABI];
3457
3458   return TRUE;
3459 }
3460
3461 /* Merge backend specific data from an object file to the output
3462    object file when linking.  */
3463
3464 static bfd_boolean
3465 elf32_arm_merge_private_bfd_data (bfd * ibfd, bfd * obfd)
3466 {
3467   flagword out_flags;
3468   flagword in_flags;
3469   bfd_boolean flags_compatible = TRUE;
3470   asection *sec;
3471
3472   /* Check if we have the same endianess.  */
3473   if (! _bfd_generic_verify_endian_match (ibfd, obfd))
3474     return FALSE;
3475
3476   if (   bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3477       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
3478     return TRUE;
3479
3480   /* The input BFD must have had its flags initialised.  */
3481   /* The following seems bogus to me -- The flags are initialized in
3482      the assembler but I don't think an elf_flags_init field is
3483      written into the object.  */
3484   /* BFD_ASSERT (elf_flags_init (ibfd)); */
3485
3486   in_flags  = elf_elfheader (ibfd)->e_flags;
3487   out_flags = elf_elfheader (obfd)->e_flags;
3488
3489   if (!elf_flags_init (obfd))
3490     {
3491       /* If the input is the default architecture and had the default
3492          flags then do not bother setting the flags for the output
3493          architecture, instead allow future merges to do this.  If no
3494          future merges ever set these flags then they will retain their
3495          uninitialised values, which surprise surprise, correspond
3496          to the default values.  */
3497       if (bfd_get_arch_info (ibfd)->the_default
3498           && elf_elfheader (ibfd)->e_flags == 0)
3499         return TRUE;
3500
3501       elf_flags_init (obfd) = TRUE;
3502       elf_elfheader (obfd)->e_flags = in_flags;
3503
3504       if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
3505           && bfd_get_arch_info (obfd)->the_default)
3506         return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
3507
3508       return TRUE;
3509     }
3510
3511   /* Determine what should happen if the input ARM architecture
3512      does not match the output ARM architecture.  */
3513   if (! bfd_arm_merge_machines (ibfd, obfd))
3514     return FALSE;
3515
3516   /* Identical flags must be compatible.  */
3517   if (in_flags == out_flags)
3518     return TRUE;
3519
3520   /* Check to see if the input BFD actually contains any sections.  If
3521      not, its flags may not have been initialised either, but it
3522      cannot actually cause any incompatibility.  Do not short-circuit
3523      dynamic objects; their section list may be emptied by
3524     elf_link_add_object_symbols.
3525
3526     Also check to see if there are no code sections in the input.
3527     In this case there is no need to check for code specific flags.
3528     XXX - do we need to worry about floating-point format compatability
3529     in data sections ?  */
3530   if (!(ibfd->flags & DYNAMIC))
3531     {
3532       bfd_boolean null_input_bfd = TRUE;
3533       bfd_boolean only_data_sections = TRUE;
3534
3535       for (sec = ibfd->sections; sec != NULL; sec = sec->next)
3536         {
3537           /* Ignore synthetic glue sections.  */
3538           if (strcmp (sec->name, ".glue_7")
3539               && strcmp (sec->name, ".glue_7t"))
3540             {
3541               if ((bfd_get_section_flags (ibfd, sec)
3542                    & (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS))
3543                   == (SEC_LOAD | SEC_CODE | SEC_HAS_CONTENTS))
3544                 only_data_sections = FALSE;
3545
3546               null_input_bfd = FALSE;
3547               break;
3548             }
3549         }
3550
3551       if (null_input_bfd || only_data_sections)
3552         return TRUE;
3553     }
3554
3555   /* Complain about various flag mismatches.  */
3556   if (EF_ARM_EABI_VERSION (in_flags) != EF_ARM_EABI_VERSION (out_flags))
3557     {
3558       _bfd_error_handler
3559         (_("ERROR: Source object %B has EABI version %d, but target %B has EABI version %d"),
3560          ibfd, obfd,
3561          (in_flags & EF_ARM_EABIMASK) >> 24,
3562          (out_flags & EF_ARM_EABIMASK) >> 24);
3563       return FALSE;
3564     }
3565
3566   /* Not sure what needs to be checked for EABI versions >= 1.  */
3567   if (EF_ARM_EABI_VERSION (in_flags) == EF_ARM_EABI_UNKNOWN)
3568     {
3569       if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
3570         {
3571           _bfd_error_handler
3572             (_("ERROR: %B is compiled for APCS-%d, whereas target %B uses APCS-%d"),
3573              ibfd, obfd,
3574              in_flags & EF_ARM_APCS_26 ? 26 : 32,
3575              out_flags & EF_ARM_APCS_26 ? 26 : 32);
3576           flags_compatible = FALSE;
3577         }
3578
3579       if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
3580         {
3581           if (in_flags & EF_ARM_APCS_FLOAT)
3582             _bfd_error_handler
3583               (_("ERROR: %B passes floats in float registers, whereas %B passes them in integer registers"),
3584                ibfd, obfd);
3585           else
3586             _bfd_error_handler
3587               (_("ERROR: %B passes floats in integer registers, whereas %B passes them in float registers"),
3588                ibfd, obfd);
3589
3590           flags_compatible = FALSE;
3591         }
3592
3593       if ((in_flags & EF_ARM_VFP_FLOAT) != (out_flags & EF_ARM_VFP_FLOAT))
3594         {
3595           if (in_flags & EF_ARM_VFP_FLOAT)
3596             _bfd_error_handler
3597               (_("ERROR: %B uses VFP instructions, whereas %B does not"),
3598                ibfd, obfd);
3599           else
3600             _bfd_error_handler
3601               (_("ERROR: %B uses FPA instructions, whereas %B does not"),
3602                ibfd, obfd);
3603
3604           flags_compatible = FALSE;
3605         }
3606
3607       if ((in_flags & EF_ARM_MAVERICK_FLOAT) != (out_flags & EF_ARM_MAVERICK_FLOAT))
3608         {
3609           if (in_flags & EF_ARM_MAVERICK_FLOAT)
3610             _bfd_error_handler
3611               (_("ERROR: %B uses Maverick instructions, whereas %B does not"),
3612                ibfd, obfd);
3613           else
3614             _bfd_error_handler
3615               (_("ERROR: %B does not use Maverick instructions, whereas %B does"),
3616                ibfd, obfd);
3617
3618           flags_compatible = FALSE;
3619         }
3620
3621 #ifdef EF_ARM_SOFT_FLOAT
3622       if ((in_flags & EF_ARM_SOFT_FLOAT) != (out_flags & EF_ARM_SOFT_FLOAT))
3623         {
3624           /* We can allow interworking between code that is VFP format
3625              layout, and uses either soft float or integer regs for
3626              passing floating point arguments and results.  We already
3627              know that the APCS_FLOAT flags match; similarly for VFP
3628              flags.  */
3629           if ((in_flags & EF_ARM_APCS_FLOAT) != 0
3630               || (in_flags & EF_ARM_VFP_FLOAT) == 0)
3631             {
3632               if (in_flags & EF_ARM_SOFT_FLOAT)
3633                 _bfd_error_handler
3634                   (_("ERROR: %B uses software FP, whereas %B uses hardware FP"),
3635                    ibfd, obfd);
3636               else
3637                 _bfd_error_handler
3638                   (_("ERROR: %B uses hardware FP, whereas %B uses software FP"),
3639                    ibfd, obfd);
3640
3641               flags_compatible = FALSE;
3642             }
3643         }
3644 #endif
3645
3646       /* Interworking mismatch is only a warning.  */
3647       if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
3648         {
3649           if (in_flags & EF_ARM_INTERWORK)
3650             {
3651               _bfd_error_handler
3652                 (_("Warning: %B supports interworking, whereas %B does not"),
3653                  ibfd, obfd);
3654             }
3655           else
3656             {
3657               _bfd_error_handler
3658                 (_("Warning: %B does not support interworking, whereas %B does"),
3659                  ibfd, obfd);
3660             }
3661         }
3662     }
3663
3664   return flags_compatible;
3665 }
3666
3667 /* Display the flags field.  */
3668
3669 static bfd_boolean
3670 elf32_arm_print_private_bfd_data (bfd *abfd, void * ptr)
3671 {
3672   FILE * file = (FILE *) ptr;
3673   unsigned long flags;
3674
3675   BFD_ASSERT (abfd != NULL && ptr != NULL);
3676
3677   /* Print normal ELF private data.  */
3678   _bfd_elf_print_private_bfd_data (abfd, ptr);
3679
3680   flags = elf_elfheader (abfd)->e_flags;
3681   /* Ignore init flag - it may not be set, despite the flags field
3682      containing valid data.  */
3683
3684   /* xgettext:c-format */
3685   fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
3686
3687   switch (EF_ARM_EABI_VERSION (flags))
3688     {
3689     case EF_ARM_EABI_UNKNOWN:
3690       /* The following flag bits are GNU extensions and not part of the
3691          official ARM ELF extended ABI.  Hence they are only decoded if
3692          the EABI version is not set.  */
3693       if (flags & EF_ARM_INTERWORK)
3694         fprintf (file, _(" [interworking enabled]"));
3695
3696       if (flags & EF_ARM_APCS_26)
3697         fprintf (file, " [APCS-26]");
3698       else
3699         fprintf (file, " [APCS-32]");
3700
3701       if (flags & EF_ARM_VFP_FLOAT)
3702         fprintf (file, _(" [VFP float format]"));
3703       else if (flags & EF_ARM_MAVERICK_FLOAT)
3704         fprintf (file, _(" [Maverick float format]"));
3705       else
3706         fprintf (file, _(" [FPA float format]"));
3707
3708       if (flags & EF_ARM_APCS_FLOAT)
3709         fprintf (file, _(" [floats passed in float registers]"));
3710
3711       if (flags & EF_ARM_PIC)
3712         fprintf (file, _(" [position independent]"));
3713
3714       if (flags & EF_ARM_NEW_ABI)
3715         fprintf (file, _(" [new ABI]"));
3716
3717       if (flags & EF_ARM_OLD_ABI)
3718         fprintf (file, _(" [old ABI]"));
3719
3720       if (flags & EF_ARM_SOFT_FLOAT)
3721         fprintf (file, _(" [software FP]"));
3722
3723       flags &= ~(EF_ARM_INTERWORK | EF_ARM_APCS_26 | EF_ARM_APCS_FLOAT
3724                  | EF_ARM_PIC | EF_ARM_NEW_ABI | EF_ARM_OLD_ABI
3725                  | EF_ARM_SOFT_FLOAT | EF_ARM_VFP_FLOAT
3726                  | EF_ARM_MAVERICK_FLOAT);
3727       break;
3728
3729     case EF_ARM_EABI_VER1:
3730       fprintf (file, _(" [Version1 EABI]"));
3731
3732       if (flags & EF_ARM_SYMSARESORTED)
3733         fprintf (file, _(" [sorted symbol table]"));
3734       else
3735         fprintf (file, _(" [unsorted symbol table]"));
3736
3737       flags &= ~ EF_ARM_SYMSARESORTED;
3738       break;
3739
3740     case EF_ARM_EABI_VER2:
3741       fprintf (file, _(" [Version2 EABI]"));
3742
3743       if (flags & EF_ARM_SYMSARESORTED)
3744         fprintf (file, _(" [sorted symbol table]"));
3745       else
3746         fprintf (file, _(" [unsorted symbol table]"));
3747
3748       if (flags & EF_ARM_DYNSYMSUSESEGIDX)
3749         fprintf (file, _(" [dynamic symbols use segment index]"));
3750
3751       if (flags & EF_ARM_MAPSYMSFIRST)
3752         fprintf (file, _(" [mapping symbols precede others]"));
3753
3754       flags &= ~(EF_ARM_SYMSARESORTED | EF_ARM_DYNSYMSUSESEGIDX
3755                  | EF_ARM_MAPSYMSFIRST);
3756       break;
3757
3758     case EF_ARM_EABI_VER3:
3759       fprintf (file, _(" [Version3 EABI]"));
3760       break;
3761
3762     case EF_ARM_EABI_VER4:
3763       fprintf (file, _(" [Version4 EABI]"));
3764
3765       if (flags & EF_ARM_BE8)
3766         fprintf (file, _(" [BE8]"));
3767
3768       if (flags & EF_ARM_LE8)
3769         fprintf (file, _(" [LE8]"));
3770
3771       flags &= ~(EF_ARM_LE8 | EF_ARM_BE8);
3772       break;
3773
3774     default:
3775       fprintf (file, _(" <EABI version unrecognised>"));
3776       break;
3777     }
3778
3779   flags &= ~ EF_ARM_EABIMASK;
3780
3781   if (flags & EF_ARM_RELEXEC)
3782     fprintf (file, _(" [relocatable executable]"));
3783
3784   if (flags & EF_ARM_HASENTRY)
3785     fprintf (file, _(" [has entry point]"));
3786
3787   flags &= ~ (EF_ARM_RELEXEC | EF_ARM_HASENTRY);
3788
3789   if (flags)
3790     fprintf (file, _("<Unrecognised flag bits set>"));
3791
3792   fputc ('\n', file);
3793
3794   return TRUE;
3795 }
3796
3797 static int
3798 elf32_arm_get_symbol_type (Elf_Internal_Sym * elf_sym, int type)
3799 {
3800   switch (ELF_ST_TYPE (elf_sym->st_info))
3801     {
3802     case STT_ARM_TFUNC:
3803       return ELF_ST_TYPE (elf_sym->st_info);
3804
3805     case STT_ARM_16BIT:
3806       /* If the symbol is not an object, return the STT_ARM_16BIT flag.
3807          This allows us to distinguish between data used by Thumb instructions
3808          and non-data (which is probably code) inside Thumb regions of an
3809          executable.  */
3810       if (type != STT_OBJECT)
3811         return ELF_ST_TYPE (elf_sym->st_info);
3812       break;
3813
3814     default:
3815       break;
3816     }
3817
3818   return type;
3819 }
3820
3821 static asection *
3822 elf32_arm_gc_mark_hook (asection *                   sec,
3823                         struct bfd_link_info *       info ATTRIBUTE_UNUSED,
3824                         Elf_Internal_Rela *          rel,
3825                         struct elf_link_hash_entry * h,
3826                         Elf_Internal_Sym *           sym)
3827 {
3828   if (h != NULL)
3829     {
3830       switch (ELF32_R_TYPE (rel->r_info))
3831       {
3832       case R_ARM_GNU_VTINHERIT:
3833       case R_ARM_GNU_VTENTRY:
3834         break;
3835
3836       default:
3837         switch (h->root.type)
3838           {
3839           case bfd_link_hash_defined:
3840           case bfd_link_hash_defweak:
3841             return h->root.u.def.section;
3842
3843           case bfd_link_hash_common:
3844             return h->root.u.c.p->section;
3845
3846           default:
3847             break;
3848           }
3849        }
3850      }
3851    else
3852      return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
3853
3854   return NULL;
3855 }
3856
3857 /* Update the got entry reference counts for the section being removed.  */
3858
3859 static bfd_boolean
3860 elf32_arm_gc_sweep_hook (bfd *                     abfd ATTRIBUTE_UNUSED,
3861                          struct bfd_link_info *    info ATTRIBUTE_UNUSED,
3862                          asection *                sec ATTRIBUTE_UNUSED,
3863                          const Elf_Internal_Rela * relocs ATTRIBUTE_UNUSED)
3864 {
3865   Elf_Internal_Shdr *symtab_hdr;
3866   struct elf_link_hash_entry **sym_hashes;
3867   bfd_signed_vma *local_got_refcounts;
3868   const Elf_Internal_Rela *rel, *relend;
3869   struct elf32_arm_link_hash_table * globals;
3870
3871   globals = elf32_arm_hash_table (info);
3872
3873   elf_section_data (sec)->local_dynrel = NULL;
3874
3875   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3876   sym_hashes = elf_sym_hashes (abfd);
3877   local_got_refcounts = elf_local_got_refcounts (abfd);
3878
3879   relend = relocs + sec->reloc_count;
3880   for (rel = relocs; rel < relend; rel++)
3881     {
3882       unsigned long r_symndx;
3883       struct elf_link_hash_entry *h = NULL;
3884       int r_type;
3885
3886       r_symndx = ELF32_R_SYM (rel->r_info);
3887       if (r_symndx >= symtab_hdr->sh_info)
3888         {
3889           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3890           while (h->root.type == bfd_link_hash_indirect
3891                  || h->root.type == bfd_link_hash_warning)
3892             h = (struct elf_link_hash_entry *) h->root.u.i.link;
3893         }
3894
3895       r_type = ELF32_R_TYPE (rel->r_info);
3896 #ifndef OLD_ARM_ABI
3897       r_type = arm_real_reloc_type (globals, r_type);
3898 #endif
3899       switch (r_type)
3900         {
3901         case R_ARM_GOT32:
3902 #ifndef OLD_ARM_ABI
3903         case R_ARM_GOT_PREL:
3904 #endif
3905           if (h != NULL)
3906             {
3907               if (h->got.refcount > 0)
3908                 h->got.refcount -= 1;
3909             }
3910           else if (local_got_refcounts != NULL)
3911             {
3912               if (local_got_refcounts[r_symndx] > 0)
3913                 local_got_refcounts[r_symndx] -= 1;
3914             }
3915           break;
3916
3917         case R_ARM_ABS32:
3918         case R_ARM_REL32:
3919         case R_ARM_PC24:
3920         case R_ARM_PLT32:
3921 #ifndef OLD_ARM_ABI
3922         case R_ARM_CALL:
3923         case R_ARM_JUMP24:
3924         case R_ARM_PREL31:
3925 #endif
3926         case R_ARM_THM_PC22:
3927           /* Should the interworking branches be here also?  */
3928
3929           if (h != NULL)
3930             {
3931               struct elf32_arm_link_hash_entry *eh;
3932               struct elf32_arm_relocs_copied **pp;
3933               struct elf32_arm_relocs_copied *p;
3934
3935               eh = (struct elf32_arm_link_hash_entry *) h;
3936
3937               if (h->plt.refcount > 0)
3938                 {
3939                   h->plt.refcount -= 1;
3940                   if (ELF32_R_TYPE (rel->r_info) == R_ARM_THM_PC22)
3941                     eh->plt_thumb_refcount--;
3942                 }
3943
3944               if (r_type == R_ARM_ABS32
3945                   || r_type == R_ARM_REL32)
3946                 {
3947                   for (pp = &eh->relocs_copied; (p = *pp) != NULL;
3948                        pp = &p->next)
3949                   if (p->section == sec)
3950                     {
3951                       p->count -= 1;
3952                       if (p->count == 0)
3953                         *pp = p->next;
3954                       break;
3955                     }
3956                 }
3957             }
3958           break;
3959
3960         default:
3961           break;
3962         }
3963     }
3964
3965   return TRUE;
3966 }
3967
3968 /* Look through the relocs for a section during the first phase.  */
3969
3970 static bfd_boolean
3971 elf32_arm_check_relocs (bfd *abfd, struct bfd_link_info *info,
3972                         asection *sec, const Elf_Internal_Rela *relocs)
3973 {
3974   Elf_Internal_Shdr *symtab_hdr;
3975   struct elf_link_hash_entry **sym_hashes;
3976   struct elf_link_hash_entry **sym_hashes_end;
3977   const Elf_Internal_Rela *rel;
3978   const Elf_Internal_Rela *rel_end;
3979   bfd *dynobj;
3980   asection *sreloc;
3981   bfd_vma *local_got_offsets;
3982   struct elf32_arm_link_hash_table *htab;
3983
3984   if (info->relocatable)
3985     return TRUE;
3986
3987   htab = elf32_arm_hash_table (info);
3988   sreloc = NULL;
3989
3990   /* Create dynamic sections for relocatable executables so that we can
3991      copy relocations.  */
3992   if (htab->root.is_relocatable_executable
3993       && ! htab->root.dynamic_sections_created)
3994     {
3995       if (! _bfd_elf_link_create_dynamic_sections (abfd, info))
3996         return FALSE;
3997     }
3998
3999   dynobj = elf_hash_table (info)->dynobj;
4000   local_got_offsets = elf_local_got_offsets (abfd);
4001
4002   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
4003   sym_hashes = elf_sym_hashes (abfd);
4004   sym_hashes_end = sym_hashes
4005     + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
4006
4007   if (!elf_bad_symtab (abfd))
4008     sym_hashes_end -= symtab_hdr->sh_info;
4009
4010   rel_end = relocs + sec->reloc_count;
4011   for (rel = relocs; rel < rel_end; rel++)
4012     {
4013       struct elf_link_hash_entry *h;
4014       struct elf32_arm_link_hash_entry *eh;
4015       unsigned long r_symndx;
4016       int r_type;
4017
4018       r_symndx = ELF32_R_SYM (rel->r_info);
4019       r_type = ELF32_R_TYPE (rel->r_info);
4020 #ifndef OLD_ARM_ABI
4021       r_type = arm_real_reloc_type (htab, r_type);
4022 #endif
4023       if (r_symndx < symtab_hdr->sh_info)
4024         h = NULL;
4025       else
4026         h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4027
4028       eh = (struct elf32_arm_link_hash_entry *) h;
4029
4030       switch (r_type)
4031         {
4032           case R_ARM_GOT32:
4033 #ifndef OLD_ARM_ABI
4034           case R_ARM_GOT_PREL:
4035 #endif
4036             /* This symbol requires a global offset table entry.  */
4037             if (h != NULL)
4038               {
4039                 h->got.refcount++;
4040               }
4041             else
4042               {
4043                 bfd_signed_vma *local_got_refcounts;
4044
4045                 /* This is a global offset table entry for a local symbol.  */
4046                 local_got_refcounts = elf_local_got_refcounts (abfd);
4047                 if (local_got_refcounts == NULL)
4048                   {
4049                     bfd_size_type size;
4050
4051                     size = symtab_hdr->sh_info;
4052                     size *= (sizeof (bfd_signed_vma) + sizeof (char));
4053                     local_got_refcounts = bfd_zalloc (abfd, size);
4054                     if (local_got_refcounts == NULL)
4055                       return FALSE;
4056                     elf_local_got_refcounts (abfd) = local_got_refcounts;
4057                   }
4058                 local_got_refcounts[r_symndx] += 1;
4059               }
4060             if (r_type == R_ARM_GOT32)
4061               break;
4062             /* Fall through.  */
4063
4064           case R_ARM_GOTOFF:
4065           case R_ARM_GOTPC:
4066             if (htab->sgot == NULL)
4067               {
4068                 if (htab->root.dynobj == NULL)
4069                   htab->root.dynobj = abfd;
4070                 if (!create_got_section (htab->root.dynobj, info))
4071                   return FALSE;
4072               }
4073             break;
4074
4075           case R_ARM_ABS32:
4076           case R_ARM_REL32:
4077           case R_ARM_PC24:
4078           case R_ARM_PLT32:
4079 #ifndef OLD_ARM_ABI
4080           case R_ARM_CALL:
4081           case R_ARM_JUMP24:
4082           case R_ARM_PREL31:
4083 #endif
4084           case R_ARM_THM_PC22:
4085             /* Should the interworking branches be listed here?  */
4086             if (h != NULL)
4087               {
4088                 /* If this reloc is in a read-only section, we might
4089                    need a copy reloc.  We can't check reliably at this
4090                    stage whether the section is read-only, as input
4091                    sections have not yet been mapped to output sections.
4092                    Tentatively set the flag for now, and correct in
4093                    adjust_dynamic_symbol.  */
4094                 if (!info->shared)
4095                   h->non_got_ref = 1;
4096
4097                 /* We may need a .plt entry if the function this reloc
4098                    refers to is in a different object.  We can't tell for
4099                    sure yet, because something later might force the
4100                    symbol local.  */
4101                 if (r_type == R_ARM_PC24
4102 #ifndef OLD_ARM_ABI
4103                     || r_type == R_ARM_CALL
4104                     || r_type == R_ARM_JUMP24
4105                     || r_type == R_ARM_PREL31
4106 #endif
4107                     || r_type == R_ARM_PLT32
4108                     || r_type == R_ARM_THM_PC22)
4109                   h->needs_plt = 1;
4110
4111                 /* If we create a PLT entry, this relocation will reference
4112                    it, even if it's an ABS32 relocation.  */
4113                 h->plt.refcount += 1;
4114
4115                 if (r_type == R_ARM_THM_PC22)
4116                   eh->plt_thumb_refcount += 1;
4117               }
4118
4119             /* If we are creating a shared library or relocatable executable,
4120                and this is a reloc against a global symbol, or a non PC
4121                relative reloc against a local symbol, then we need to copy
4122                the reloc into the shared library.  However, if we are linking
4123                with -Bsymbolic, we do not need to copy a reloc against a
4124                global symbol which is defined in an object we are
4125                including in the link (i.e., DEF_REGULAR is set).  At
4126                this point we have not seen all the input files, so it is
4127                possible that DEF_REGULAR is not set now but will be set
4128                later (it is never cleared).  We account for that
4129                possibility below by storing information in the
4130                relocs_copied field of the hash table entry.  */
4131             if ((info->shared || htab->root.is_relocatable_executable)
4132                 && (sec->flags & SEC_ALLOC) != 0
4133                 && ((r_type != R_ARM_PC24
4134                      && r_type != R_ARM_PLT32
4135 #ifndef OLD_ARM_ABI
4136                      && r_type != R_ARM_CALL
4137                      && r_type != R_ARM_JUMP24
4138                      && r_type != R_ARM_PREL31
4139 #endif
4140                      && r_type != R_ARM_REL32
4141                      && r_type != R_ARM_THM_PC22)
4142                     || (h != NULL
4143                         && (! info->symbolic
4144                             || !h->def_regular))))
4145               {
4146                 struct elf32_arm_relocs_copied *p, **head;
4147
4148                 /* When creating a shared object, we must copy these
4149                    reloc types into the output file.  We create a reloc
4150                    section in dynobj and make room for this reloc.  */
4151                 if (sreloc == NULL)
4152                   {
4153                     const char * name;
4154
4155                     name = (bfd_elf_string_from_elf_section
4156                             (abfd,
4157                              elf_elfheader (abfd)->e_shstrndx,
4158                              elf_section_data (sec)->rel_hdr.sh_name));
4159                     if (name == NULL)
4160                       return FALSE;
4161
4162                     BFD_ASSERT (strncmp (name, ".rel", 4) == 0
4163                                 && strcmp (bfd_get_section_name (abfd, sec),
4164                                            name + 4) == 0);
4165
4166                     sreloc = bfd_get_section_by_name (dynobj, name);
4167                     if (sreloc == NULL)
4168                       {
4169                         flagword flags;
4170
4171                         sreloc = bfd_make_section (dynobj, name);
4172                         flags = (SEC_HAS_CONTENTS | SEC_READONLY
4173                                  | SEC_IN_MEMORY | SEC_LINKER_CREATED);
4174                         if ((sec->flags & SEC_ALLOC) != 0
4175                             /* BPABI objects never have dynamic
4176                                relocations mapped.  */
4177                             && !htab->symbian_p)
4178                           flags |= SEC_ALLOC | SEC_LOAD;
4179                         if (sreloc == NULL
4180                             || ! bfd_set_section_flags (dynobj, sreloc, flags)
4181                             || ! bfd_set_section_alignment (dynobj, sreloc, 2))
4182                           return FALSE;
4183                       }
4184
4185                     elf_section_data (sec)->sreloc = sreloc;
4186                   }
4187
4188                 /* If this is a global symbol, we count the number of
4189                    relocations we need for this symbol.  */
4190                 if (h != NULL)
4191                   {
4192                     head = &((struct elf32_arm_link_hash_entry *) h)->relocs_copied;
4193                   }
4194                 else
4195                   {
4196                     /* Track dynamic relocs needed for local syms too.
4197                        We really need local syms available to do this
4198                        easily.  Oh well.  */
4199
4200                     asection *s;
4201                     s = bfd_section_from_r_symndx (abfd, &htab->sym_sec,
4202                                                    sec, r_symndx);
4203                     if (s == NULL)
4204                       return FALSE;
4205
4206                     head = ((struct elf32_arm_relocs_copied **)
4207                             &elf_section_data (s)->local_dynrel);
4208                   }
4209
4210                 p = *head;
4211                 if (p == NULL || p->section != sec)
4212                   {
4213                     bfd_size_type amt = sizeof *p;
4214
4215                     p = bfd_alloc (htab->root.dynobj, amt);
4216                     if (p == NULL)
4217                       return FALSE;
4218                     p->next = *head;
4219                     *head = p;
4220                     p->section = sec;
4221                     p->count = 0;
4222                   }
4223
4224                 if (r_type == R_ARM_ABS32
4225                     || r_type == R_ARM_REL32)
4226                   p->count += 1;
4227               }
4228             break;
4229
4230         /* This relocation describes the C++ object vtable hierarchy.
4231            Reconstruct it for later use during GC.  */
4232         case R_ARM_GNU_VTINHERIT:
4233           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
4234             return FALSE;
4235           break;
4236
4237         /* This relocation describes which C++ vtable entries are actually
4238            used.  Record for later use during GC.  */
4239         case R_ARM_GNU_VTENTRY:
4240           if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
4241             return FALSE;
4242           break;
4243         }
4244     }
4245
4246   return TRUE;
4247 }
4248
4249 static bfd_boolean
4250 is_arm_mapping_symbol_name (const char * name)
4251 {
4252   return (name != NULL)
4253     && (name[0] == '$')
4254     && ((name[1] == 'a') || (name[1] == 't') || (name[1] == 'd'))
4255     && (name[2] == 0);
4256 }
4257
4258 /* Treat mapping symbols as special target symbols.  */
4259
4260 static bfd_boolean
4261 elf32_arm_is_target_special_symbol (bfd * abfd ATTRIBUTE_UNUSED, asymbol * sym)
4262 {
4263   return is_arm_mapping_symbol_name (sym->name);
4264 }
4265
4266 /* This is a copy of elf_find_function() from elf.c except that
4267    ARM mapping symbols are ignored when looking for function names
4268    and STT_ARM_TFUNC is considered to a function type.  */
4269
4270 static bfd_boolean
4271 arm_elf_find_function (bfd *         abfd ATTRIBUTE_UNUSED,
4272                        asection *    section,
4273                        asymbol **    symbols,
4274                        bfd_vma       offset,
4275                        const char ** filename_ptr,
4276                        const char ** functionname_ptr)
4277 {
4278   const char * filename = NULL;
4279   asymbol * func = NULL;
4280   bfd_vma low_func = 0;
4281   asymbol ** p;
4282
4283   for (p = symbols; *p != NULL; p++)
4284     {
4285       elf_symbol_type *q;
4286
4287       q = (elf_symbol_type *) *p;
4288
4289       switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
4290         {
4291         default:
4292           break;
4293         case STT_FILE:
4294           filename = bfd_asymbol_name (&q->symbol);
4295           break;
4296         case STT_FUNC:
4297         case STT_ARM_TFUNC:
4298           /* Skip $a and $t symbols.  */
4299           if ((q->symbol.flags & BSF_LOCAL)
4300               && is_arm_mapping_symbol_name (q->symbol.name))
4301             continue;
4302           /* Fall through.  */
4303         case STT_NOTYPE:
4304           if (bfd_get_section (&q->symbol) == section
4305               && q->symbol.value >= low_func
4306               && q->symbol.value <= offset)
4307             {
4308               func = (asymbol *) q;
4309               low_func = q->symbol.value;
4310             }
4311           break;
4312         }
4313     }
4314
4315   if (func == NULL)
4316     return FALSE;
4317
4318   if (filename_ptr)
4319     *filename_ptr = filename;
4320   if (functionname_ptr)
4321     *functionname_ptr = bfd_asymbol_name (func);
4322
4323   return TRUE;
4324 }
4325
4326
4327 /* Find the nearest line to a particular section and offset, for error
4328    reporting.   This code is a duplicate of the code in elf.c, except
4329    that it uses arm_elf_find_function.  */
4330
4331 static bfd_boolean
4332 elf32_arm_find_nearest_line (bfd *          abfd,
4333                              asection *     section,
4334                              asymbol **     symbols,
4335                              bfd_vma        offset,
4336                              const char **  filename_ptr,
4337                              const char **  functionname_ptr,
4338                              unsigned int * line_ptr)
4339 {
4340   bfd_boolean found = FALSE;
4341
4342   /* We skip _bfd_dwarf1_find_nearest_line since no known ARM toolchain uses it.  */
4343
4344   if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
4345                                      filename_ptr, functionname_ptr,
4346                                      line_ptr, 0,
4347                                      & elf_tdata (abfd)->dwarf2_find_line_info))
4348     {
4349       if (!*functionname_ptr)
4350         arm_elf_find_function (abfd, section, symbols, offset,
4351                                *filename_ptr ? NULL : filename_ptr,
4352                                functionname_ptr);
4353
4354       return TRUE;
4355     }
4356
4357   if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
4358                                              & found, filename_ptr,
4359                                              functionname_ptr, line_ptr,
4360                                              & elf_tdata (abfd)->line_info))
4361     return FALSE;
4362
4363   if (found && (*functionname_ptr || *line_ptr))
4364     return TRUE;
4365
4366   if (symbols == NULL)
4367     return FALSE;
4368
4369   if (! arm_elf_find_function (abfd, section, symbols, offset,
4370                                filename_ptr, functionname_ptr))
4371     return FALSE;
4372
4373   *line_ptr = 0;
4374   return TRUE;
4375 }
4376
4377 /* Adjust a symbol defined by a dynamic object and referenced by a
4378    regular object.  The current definition is in some section of the
4379    dynamic object, but we're not including those sections.  We have to
4380    change the definition to something the rest of the link can
4381    understand.  */
4382
4383 static bfd_boolean
4384 elf32_arm_adjust_dynamic_symbol (struct bfd_link_info * info,
4385                                  struct elf_link_hash_entry * h)
4386 {
4387   bfd * dynobj;
4388   asection * s;
4389   unsigned int power_of_two;
4390   struct elf32_arm_link_hash_entry * eh;
4391   struct elf32_arm_link_hash_table *globals;
4392
4393   globals = elf32_arm_hash_table (info);
4394   dynobj = elf_hash_table (info)->dynobj;
4395
4396   /* Make sure we know what is going on here.  */
4397   BFD_ASSERT (dynobj != NULL
4398               && (h->needs_plt
4399                   || h->u.weakdef != NULL
4400                   || (h->def_dynamic
4401                       && h->ref_regular
4402                       && !h->def_regular)));
4403
4404   eh = (struct elf32_arm_link_hash_entry *) h;
4405
4406   /* If this is a function, put it in the procedure linkage table.  We
4407      will fill in the contents of the procedure linkage table later,
4408      when we know the address of the .got section.  */
4409   if (h->type == STT_FUNC || h->type == STT_ARM_TFUNC
4410       || h->needs_plt)
4411     {
4412       if (h->plt.refcount <= 0
4413           || SYMBOL_CALLS_LOCAL (info, h)
4414           || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
4415               && h->root.type == bfd_link_hash_undefweak))
4416         {
4417           /* This case can occur if we saw a PLT32 reloc in an input
4418              file, but the symbol was never referred to by a dynamic
4419              object, or if all references were garbage collected.  In
4420              such a case, we don't actually need to build a procedure
4421              linkage table, and we can just do a PC24 reloc instead.  */
4422           h->plt.offset = (bfd_vma) -1;
4423           eh->plt_thumb_refcount = 0;
4424           h->needs_plt = 0;
4425         }
4426
4427       return TRUE;
4428     }
4429   else
4430     {
4431       /* It's possible that we incorrectly decided a .plt reloc was
4432          needed for an R_ARM_PC24 or similar reloc to a non-function sym
4433          in check_relocs.  We can't decide accurately between function
4434          and non-function syms in check-relocs; Objects loaded later in
4435          the link may change h->type.  So fix it now.  */
4436       h->plt.offset = (bfd_vma) -1;
4437       eh->plt_thumb_refcount = 0;
4438     }
4439
4440   /* If this is a weak symbol, and there is a real definition, the
4441      processor independent code will have arranged for us to see the
4442      real definition first, and we can just use the same value.  */
4443   if (h->u.weakdef != NULL)
4444     {
4445       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
4446                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
4447       h->root.u.def.section = h->u.weakdef->root.u.def.section;
4448       h->root.u.def.value = h->u.weakdef->root.u.def.value;
4449       return TRUE;
4450     }
4451
4452   /* This is a reference to a symbol defined by a dynamic object which
4453      is not a function.  */
4454
4455   /* If we are creating a shared library, we must presume that the
4456      only references to the symbol are via the global offset table.
4457      For such cases we need not do anything here; the relocations will
4458      be handled correctly by relocate_section.  Relocatable executables
4459      can reference data in shared objects directly, so we don't need to
4460      do anything here.  */
4461   if (info->shared || globals->root.is_relocatable_executable)
4462     return TRUE;
4463
4464   /* We must allocate the symbol in our .dynbss section, which will
4465      become part of the .bss section of the executable.  There will be
4466      an entry for this symbol in the .dynsym section.  The dynamic
4467      object will contain position independent code, so all references
4468      from the dynamic object to this symbol will go through the global
4469      offset table.  The dynamic linker will use the .dynsym entry to
4470      determine the address it must put in the global offset table, so
4471      both the dynamic object and the regular object will refer to the
4472      same memory location for the variable.  */
4473   s = bfd_get_section_by_name (dynobj, ".dynbss");
4474   BFD_ASSERT (s != NULL);
4475
4476   /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
4477      copy the initial value out of the dynamic object and into the
4478      runtime process image.  We need to remember the offset into the
4479      .rel.bss section we are going to use.  */
4480   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
4481     {
4482       asection *srel;
4483
4484       srel = bfd_get_section_by_name (dynobj, ".rel.bss");
4485       BFD_ASSERT (srel != NULL);
4486       srel->size += sizeof (Elf32_External_Rel);
4487       h->needs_copy = 1;
4488     }
4489
4490   /* We need to figure out the alignment required for this symbol.  I
4491      have no idea how ELF linkers handle this.  */
4492   power_of_two = bfd_log2 (h->size);
4493   if (power_of_two > 3)
4494     power_of_two = 3;
4495
4496   /* Apply the required alignment.  */
4497   s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
4498   if (power_of_two > bfd_get_section_alignment (dynobj, s))
4499     {
4500       if (! bfd_set_section_alignment (dynobj, s, power_of_two))
4501         return FALSE;
4502     }
4503
4504   /* Define the symbol as being at this point in the section.  */
4505   h->root.u.def.section = s;
4506   h->root.u.def.value = s->size;
4507
4508   /* Increment the section size to make room for the symbol.  */
4509   s->size += h->size;
4510
4511   return TRUE;
4512 }
4513
4514 /* Allocate space in .plt, .got and associated reloc sections for
4515    dynamic relocs.  */
4516
4517 static bfd_boolean
4518 allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
4519 {
4520   struct bfd_link_info *info;
4521   struct elf32_arm_link_hash_table *htab;
4522   struct elf32_arm_link_hash_entry *eh;
4523   struct elf32_arm_relocs_copied *p;
4524
4525   eh = (struct elf32_arm_link_hash_entry *) h;
4526
4527   if (h->root.type == bfd_link_hash_indirect)
4528     return TRUE;
4529
4530   if (h->root.type == bfd_link_hash_warning)
4531     /* When warning symbols are created, they **replace** the "real"
4532        entry in the hash table, thus we never get to see the real
4533        symbol in a hash traversal.  So look at it now.  */
4534     h = (struct elf_link_hash_entry *) h->root.u.i.link;
4535
4536   info = (struct bfd_link_info *) inf;
4537   htab = elf32_arm_hash_table (info);
4538
4539   if (htab->root.dynamic_sections_created
4540       && h->plt.refcount > 0)
4541     {
4542       /* Make sure this symbol is output as a dynamic symbol.
4543          Undefined weak syms won't yet be marked as dynamic.  */
4544       if (h->dynindx == -1
4545           && !h->forced_local)
4546         {
4547           if (! bfd_elf_link_record_dynamic_symbol (info, h))
4548             return FALSE;
4549         }
4550
4551       if (info->shared
4552           || WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, 0, h))
4553         {
4554           asection *s = htab->splt;
4555
4556           /* If this is the first .plt entry, make room for the special
4557              first entry.  */
4558           if (s->size == 0)
4559             s->size += htab->plt_header_size;
4560
4561           h->plt.offset = s->size;
4562
4563           /* If we will insert a Thumb trampoline before this PLT, leave room
4564              for it.  */
4565           if (!htab->symbian_p && eh->plt_thumb_refcount > 0)
4566             {
4567               h->plt.offset += PLT_THUMB_STUB_SIZE;
4568               s->size += PLT_THUMB_STUB_SIZE;
4569             }
4570
4571           /* If this symbol is not defined in a regular file, and we are
4572              not generating a shared library, then set the symbol to this
4573              location in the .plt.  This is required to make function
4574              pointers compare as equal between the normal executable and
4575              the shared library.  */
4576           if (! info->shared
4577               && !h->def_regular)
4578             {
4579               h->root.u.def.section = s;
4580               h->root.u.def.value = h->plt.offset;
4581
4582               /* Make sure the function is not marked as Thumb, in case
4583                  it is the target of an ABS32 relocation, which will
4584                  point to the PLT entry.  */
4585               if (ELF_ST_TYPE (h->type) == STT_ARM_TFUNC)
4586                 h->type = ELF_ST_INFO (ELF_ST_BIND (h->type), STT_FUNC);
4587             }
4588
4589           /* Make room for this entry.  */
4590           s->size += htab->plt_entry_size;
4591
4592           if (!htab->symbian_p)
4593             {
4594               /* We also need to make an entry in the .got.plt section, which
4595                  will be placed in the .got section by the linker script.  */
4596               eh->plt_got_offset = htab->sgotplt->size;
4597               htab->sgotplt->size += 4;
4598             }
4599
4600           /* We also need to make an entry in the .rel.plt section.  */
4601           htab->srelplt->size += sizeof (Elf32_External_Rel);
4602         }
4603       else
4604         {
4605           h->plt.offset = (bfd_vma) -1;
4606           h->needs_plt = 0;
4607         }
4608     }
4609   else
4610     {
4611       h->plt.offset = (bfd_vma) -1;
4612       h->needs_plt = 0;
4613     }
4614
4615   if (h->got.refcount > 0)
4616     {
4617       asection *s;
4618       bfd_boolean dyn;
4619
4620       /* Make sure this symbol is output as a dynamic symbol.
4621          Undefined weak syms won't yet be marked as dynamic.  */
4622       if (h->dynindx == -1
4623           && !h->forced_local)
4624         {
4625           if (! bfd_elf_link_record_dynamic_symbol (info, h))
4626             return FALSE;
4627         }
4628
4629       if (!htab->symbian_p)
4630         {
4631           s = htab->sgot;
4632           h->got.offset = s->size;
4633           s->size += 4;
4634           dyn = htab->root.dynamic_sections_created;
4635           if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
4636                || h->root.type != bfd_link_hash_undefweak)
4637               && (info->shared
4638                   || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
4639             htab->srelgot->size += sizeof (Elf32_External_Rel);
4640         }
4641     }
4642   else
4643     h->got.offset = (bfd_vma) -1;
4644
4645   if (eh->relocs_copied == NULL)
4646     return TRUE;
4647
4648   /* In the shared -Bsymbolic case, discard space allocated for
4649      dynamic pc-relative relocs against symbols which turn out to be
4650      defined in regular objects.  For the normal shared case, discard
4651      space for pc-relative relocs that have become local due to symbol
4652      visibility changes.  */
4653
4654   if (info->shared || htab->root.is_relocatable_executable)
4655     {
4656       /* Discard relocs on undefined weak syms with non-default
4657          visibility.  */
4658       if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
4659           && h->root.type == bfd_link_hash_undefweak)
4660         eh->relocs_copied = NULL;
4661       else if (htab->root.is_relocatable_executable && h->dynindx == -1
4662                && h->root.type == bfd_link_hash_new)
4663         {
4664           /* Output absolute symbols so that we can create relocations
4665              against them.  For normal symbols we output a relocation
4666              against the section that contains them.  */
4667           if (! bfd_elf_link_record_dynamic_symbol (info, h))
4668             return FALSE;
4669         }
4670
4671     }
4672   else
4673     {
4674       /* For the non-shared case, discard space for relocs against
4675          symbols which turn out to need copy relocs or are not
4676          dynamic.  */
4677
4678       if (!h->non_got_ref
4679           && ((h->def_dynamic
4680                && !h->def_regular)
4681               || (htab->root.dynamic_sections_created
4682                   && (h->root.type == bfd_link_hash_undefweak
4683                       || h->root.type == bfd_link_hash_undefined))))
4684         {
4685           /* Make sure this symbol is output as a dynamic symbol.
4686              Undefined weak syms won't yet be marked as dynamic.  */
4687           if (h->dynindx == -1
4688               && !h->forced_local)
4689             {
4690               if (! bfd_elf_link_record_dynamic_symbol (info, h))
4691                 return FALSE;
4692             }
4693
4694           /* If that succeeded, we know we'll be keeping all the
4695              relocs.  */
4696           if (h->dynindx != -1)
4697             goto keep;
4698         }
4699
4700       eh->relocs_copied = NULL;
4701
4702     keep: ;
4703     }
4704
4705   /* Finally, allocate space.  */
4706   for (p = eh->relocs_copied; p != NULL; p = p->next)
4707     {
4708       asection *sreloc = elf_section_data (p->section)->sreloc;
4709       sreloc->size += p->count * sizeof (Elf32_External_Rel);
4710     }
4711
4712   return TRUE;
4713 }
4714
4715 /* Find any dynamic relocs that apply to read-only sections.  */
4716
4717 static bfd_boolean
4718 elf32_arm_readonly_dynrelocs (struct elf_link_hash_entry *h, PTR inf)
4719 {
4720   struct elf32_arm_link_hash_entry *eh;
4721   struct elf32_arm_relocs_copied *p;
4722
4723   if (h->root.type == bfd_link_hash_warning)
4724     h = (struct elf_link_hash_entry *) h->root.u.i.link;
4725
4726   eh = (struct elf32_arm_link_hash_entry *) h;
4727   for (p = eh->relocs_copied; p != NULL; p = p->next)
4728     {
4729       asection *s = p->section;
4730
4731       if (s != NULL && (s->flags & SEC_READONLY) != 0)
4732         {
4733           struct bfd_link_info *info = (struct bfd_link_info *) inf;
4734
4735           info->flags |= DF_TEXTREL;
4736
4737           /* Not an error, just cut short the traversal.  */
4738           return FALSE;
4739         }
4740     }
4741   return TRUE;
4742 }
4743
4744 /* Set the sizes of the dynamic sections.  */
4745
4746 static bfd_boolean
4747 elf32_arm_size_dynamic_sections (bfd * output_bfd ATTRIBUTE_UNUSED,
4748                                  struct bfd_link_info * info)
4749 {
4750   bfd * dynobj;
4751   asection * s;
4752   bfd_boolean plt;
4753   bfd_boolean relocs;
4754   bfd *ibfd;
4755   struct elf32_arm_link_hash_table *htab;
4756
4757   htab = elf32_arm_hash_table (info);
4758   dynobj = elf_hash_table (info)->dynobj;
4759   BFD_ASSERT (dynobj != NULL);
4760
4761   if (elf_hash_table (info)->dynamic_sections_created)
4762     {
4763       /* Set the contents of the .interp section to the interpreter.  */
4764       if (info->executable)
4765         {
4766           s = bfd_get_section_by_name (dynobj, ".interp");
4767           BFD_ASSERT (s != NULL);
4768           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
4769           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
4770         }
4771     }
4772
4773   /* Set up .got offsets for local syms, and space for local dynamic
4774      relocs.  */
4775   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
4776     {
4777       bfd_signed_vma *local_got;
4778       bfd_signed_vma *end_local_got;
4779       char *local_tls_type;
4780       bfd_size_type locsymcount;
4781       Elf_Internal_Shdr *symtab_hdr;
4782       asection *srel;
4783
4784       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
4785         continue;
4786
4787       for (s = ibfd->sections; s != NULL; s = s->next)
4788         {
4789           struct elf32_arm_relocs_copied *p;
4790
4791           for (p = *((struct elf32_arm_relocs_copied **)
4792                      &elf_section_data (s)->local_dynrel);
4793                p != NULL;
4794                p = p->next)
4795             {
4796               if (!bfd_is_abs_section (p->section)
4797                   && bfd_is_abs_section (p->section->output_section))
4798                 {
4799                   /* Input section has been discarded, either because
4800                      it is a copy of a linkonce section or due to
4801                      linker script /DISCARD/, so we'll be discarding
4802                      the relocs too.  */
4803                 }
4804               else if (p->count != 0)
4805                 {
4806                   srel = elf_section_data (p->section)->sreloc;
4807                   srel->size += p->count * sizeof (Elf32_External_Rel);
4808                   if ((p->section->output_section->flags & SEC_READONLY) != 0)
4809                     info->flags |= DF_TEXTREL;
4810                 }
4811             }
4812         }
4813
4814       local_got = elf_local_got_refcounts (ibfd);
4815       if (!local_got)
4816         continue;
4817
4818       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
4819       locsymcount = symtab_hdr->sh_info;
4820       end_local_got = local_got + locsymcount;
4821       s = htab->sgot;
4822       srel = htab->srelgot;
4823       for (; local_got < end_local_got; ++local_got, ++local_tls_type)
4824         {
4825           if (*local_got > 0)
4826             {
4827               *local_got = s->size;
4828               s->size += 4;
4829               if (info->shared)
4830                 srel->size += sizeof (Elf32_External_Rel);
4831             }
4832           else
4833             *local_got = (bfd_vma) -1;
4834         }
4835     }
4836
4837   /* Allocate global sym .plt and .got entries, and space for global
4838      sym dynamic relocs.  */
4839   elf_link_hash_traverse (& htab->root, allocate_dynrelocs, info);
4840
4841   /* The check_relocs and adjust_dynamic_symbol entry points have
4842      determined the sizes of the various dynamic sections.  Allocate
4843      memory for them.  */
4844   plt = FALSE;
4845   relocs = FALSE;
4846   for (s = dynobj->sections; s != NULL; s = s->next)
4847     {
4848       const char * name;
4849       bfd_boolean strip;
4850
4851       if ((s->flags & SEC_LINKER_CREATED) == 0)
4852         continue;
4853
4854       /* It's OK to base decisions on the section name, because none
4855          of the dynobj section names depend upon the input files.  */
4856       name = bfd_get_section_name (dynobj, s);
4857
4858       strip = FALSE;
4859
4860       if (strcmp (name, ".plt") == 0)
4861         {
4862           if (s->size == 0)
4863             {
4864               /* Strip this section if we don't need it; see the
4865                  comment below.  */
4866               strip = TRUE;
4867             }
4868           else
4869             {
4870               /* Remember whether there is a PLT.  */
4871               plt = TRUE;
4872             }
4873         }
4874       else if (strncmp (name, ".rel", 4) == 0)
4875         {
4876           if (s->size == 0)
4877             {
4878               /* If we don't need this section, strip it from the
4879                  output file.  This is mostly to handle .rel.bss and
4880                  .rel.plt.  We must create both sections in
4881                  create_dynamic_sections, because they must be created
4882                  before the linker maps input sections to output
4883                  sections.  The linker does that before
4884                  adjust_dynamic_symbol is called, and it is that
4885                  function which decides whether anything needs to go
4886                  into these sections.  */
4887               strip = TRUE;
4888             }
4889           else
4890             {
4891               /* Remember whether there are any reloc sections other
4892                  than .rel.plt.  */
4893               if (strcmp (name, ".rel.plt") != 0)
4894                 relocs = TRUE;
4895
4896               /* We use the reloc_count field as a counter if we need
4897                  to copy relocs into the output file.  */
4898               s->reloc_count = 0;
4899             }
4900         }
4901       else if (strncmp (name, ".got", 4) != 0)
4902         {
4903           /* It's not one of our sections, so don't allocate space.  */
4904           continue;
4905         }
4906
4907       if (strip)
4908         {
4909           _bfd_strip_section_from_output (info, s);
4910           continue;
4911         }
4912
4913       /* Allocate memory for the section contents.  */
4914       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
4915       if (s->contents == NULL && s->size != 0)
4916         return FALSE;
4917     }
4918
4919   if (elf_hash_table (info)->dynamic_sections_created)
4920     {
4921       /* Add some entries to the .dynamic section.  We fill in the
4922          values later, in elf32_arm_finish_dynamic_sections, but we
4923          must add the entries now so that we get the correct size for
4924          the .dynamic section.  The DT_DEBUG entry is filled in by the
4925          dynamic linker and used by the debugger.  */
4926 #define add_dynamic_entry(TAG, VAL) \
4927   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
4928
4929       if (!info->shared)
4930         {
4931           if (!add_dynamic_entry (DT_DEBUG, 0))
4932             return FALSE;
4933         }
4934
4935       if (plt)
4936         {
4937           if (   !add_dynamic_entry (DT_PLTGOT, 0)
4938               || !add_dynamic_entry (DT_PLTRELSZ, 0)
4939               || !add_dynamic_entry (DT_PLTREL, DT_REL)
4940               || !add_dynamic_entry (DT_JMPREL, 0))
4941             return FALSE;
4942         }
4943
4944       if (relocs)
4945         {
4946           if (   !add_dynamic_entry (DT_REL, 0)
4947               || !add_dynamic_entry (DT_RELSZ, 0)
4948               || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel)))
4949             return FALSE;
4950         }
4951
4952       /* If any dynamic relocs apply to a read-only section,
4953          then we need a DT_TEXTREL entry.  */
4954       if ((info->flags & DF_TEXTREL) == 0)
4955         elf_link_hash_traverse (&htab->root, elf32_arm_readonly_dynrelocs,
4956                                 (PTR) info);
4957
4958       if ((info->flags & DF_TEXTREL) != 0)
4959         {
4960           if (!add_dynamic_entry (DT_TEXTREL, 0))
4961             return FALSE;
4962           info->flags |= DF_TEXTREL;
4963         }
4964     }
4965 #undef add_synamic_entry
4966
4967   return TRUE;
4968 }
4969
4970 /* Finish up dynamic symbol handling.  We set the contents of various
4971    dynamic sections here.  */
4972
4973 static bfd_boolean
4974 elf32_arm_finish_dynamic_symbol (bfd * output_bfd, struct bfd_link_info * info,
4975                                  struct elf_link_hash_entry * h, Elf_Internal_Sym * sym)
4976 {
4977   bfd * dynobj;
4978   struct elf32_arm_link_hash_table *htab;
4979   struct elf32_arm_link_hash_entry *eh;
4980
4981   dynobj = elf_hash_table (info)->dynobj;
4982   htab = elf32_arm_hash_table (info);
4983   eh = (struct elf32_arm_link_hash_entry *) h;
4984
4985   if (h->plt.offset != (bfd_vma) -1)
4986     {
4987       asection * splt;
4988       asection * srel;
4989       bfd_byte *loc;
4990       bfd_vma plt_index;
4991       Elf_Internal_Rela rel;
4992
4993       /* This symbol has an entry in the procedure linkage table.  Set
4994          it up.  */
4995
4996       BFD_ASSERT (h->dynindx != -1);
4997
4998       splt = bfd_get_section_by_name (dynobj, ".plt");
4999       srel = bfd_get_section_by_name (dynobj, ".rel.plt");
5000       BFD_ASSERT (splt != NULL && srel != NULL);
5001
5002       /* Fill in the entry in the procedure linkage table.  */
5003       if (htab->symbian_p)
5004         {
5005           unsigned i;
5006           for (i = 0; i < htab->plt_entry_size / 4; ++i)
5007             bfd_put_32 (output_bfd,
5008                         elf32_arm_symbian_plt_entry[i],
5009                         splt->contents + h->plt.offset + 4 * i);
5010
5011           /* Fill in the entry in the .rel.plt section.  */
5012           rel.r_offset = (splt->output_section->vma
5013                           + splt->output_offset
5014                           + h->plt.offset + 4 * (i - 1));
5015           rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT);
5016
5017           /* Get the index in the procedure linkage table which
5018              corresponds to this symbol.  This is the index of this symbol
5019              in all the symbols for which we are making plt entries.  The
5020              first entry in the procedure linkage table is reserved.  */
5021           plt_index = ((h->plt.offset - htab->plt_header_size)
5022                        / htab->plt_entry_size);
5023         }
5024       else
5025         {
5026           bfd_vma got_offset;
5027           bfd_vma got_displacement;
5028           asection * sgot;
5029
5030           sgot = bfd_get_section_by_name (dynobj, ".got.plt");
5031           BFD_ASSERT (sgot != NULL);
5032
5033           /* Get the offset into the .got.plt table of the entry that
5034              corresponds to this function.  */
5035           got_offset = eh->plt_got_offset;
5036
5037           /* Get the index in the procedure linkage table which
5038              corresponds to this symbol.  This is the index of this symbol
5039              in all the symbols for which we are making plt entries.  The
5040              first three entries in .got.plt are reserved; after that
5041              symbols appear in the same order as in .plt.  */
5042           plt_index = (got_offset - 12) / 4;
5043
5044           /* Calculate the displacement between the PLT slot and the
5045              entry in the GOT.  The eight-byte offset accounts for the
5046              value produced by adding to pc in the first instruction
5047              of the PLT stub.  */
5048           got_displacement = (sgot->output_section->vma
5049                               + sgot->output_offset
5050                               + got_offset
5051                               - splt->output_section->vma
5052                               - splt->output_offset
5053                               - h->plt.offset
5054                               - 8);
5055
5056           BFD_ASSERT ((got_displacement & 0xf0000000) == 0);
5057
5058           if (eh->plt_thumb_refcount > 0)
5059             {
5060               bfd_put_16 (output_bfd, elf32_arm_plt_thumb_stub[0],
5061                           splt->contents + h->plt.offset - 4);
5062               bfd_put_16 (output_bfd, elf32_arm_plt_thumb_stub[1],
5063                           splt->contents + h->plt.offset - 2);
5064             }
5065
5066           bfd_put_32 (output_bfd, elf32_arm_plt_entry[0] | ((got_displacement & 0x0ff00000) >> 20),
5067                       splt->contents + h->plt.offset + 0);
5068           bfd_put_32 (output_bfd, elf32_arm_plt_entry[1] | ((got_displacement & 0x000ff000) >> 12),
5069                       splt->contents + h->plt.offset + 4);
5070           bfd_put_32 (output_bfd, elf32_arm_plt_entry[2] | (got_displacement & 0x00000fff),
5071                       splt->contents + h->plt.offset + 8);
5072 #ifdef FOUR_WORD_PLT
5073           bfd_put_32 (output_bfd, elf32_arm_plt_entry[3],
5074                       splt->contents + h->plt.offset + 12);
5075 #endif
5076
5077           /* Fill in the entry in the global offset table.  */
5078           bfd_put_32 (output_bfd,
5079                       (splt->output_section->vma
5080                        + splt->output_offset),
5081                       sgot->contents + got_offset);
5082
5083           /* Fill in the entry in the .rel.plt section.  */
5084           rel.r_offset = (sgot->output_section->vma
5085                           + sgot->output_offset
5086                           + got_offset);
5087           rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_JUMP_SLOT);
5088         }
5089
5090       loc = srel->contents + plt_index * sizeof (Elf32_External_Rel);
5091       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
5092
5093       if (!h->def_regular)
5094         {
5095           /* Mark the symbol as undefined, rather than as defined in
5096              the .plt section.  Leave the value alone.  */
5097           sym->st_shndx = SHN_UNDEF;
5098           /* If the symbol is weak, we do need to clear the value.
5099              Otherwise, the PLT entry would provide a definition for
5100              the symbol even if the symbol wasn't defined anywhere,
5101              and so the symbol would never be NULL.  */
5102           if (!h->ref_regular_nonweak)
5103             sym->st_value = 0;
5104         }
5105     }
5106
5107   if (h->got.offset != (bfd_vma) -1)
5108     {
5109       asection * sgot;
5110       asection * srel;
5111       Elf_Internal_Rela rel;
5112       bfd_byte *loc;
5113
5114       /* This symbol has an entry in the global offset table.  Set it
5115          up.  */
5116       sgot = bfd_get_section_by_name (dynobj, ".got");
5117       srel = bfd_get_section_by_name (dynobj, ".rel.got");
5118       BFD_ASSERT (sgot != NULL && srel != NULL);
5119
5120       rel.r_offset = (sgot->output_section->vma
5121                       + sgot->output_offset
5122                       + (h->got.offset &~ (bfd_vma) 1));
5123
5124       /* If this is a static link, or it is a -Bsymbolic link and the
5125          symbol is defined locally or was forced to be local because
5126          of a version file, we just want to emit a RELATIVE reloc.
5127          The entry in the global offset table will already have been
5128          initialized in the relocate_section function.  */
5129       if (info->shared
5130           && SYMBOL_REFERENCES_LOCAL (info, h))
5131         {
5132           BFD_ASSERT((h->got.offset & 1) != 0);
5133           rel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
5134         }
5135       else
5136         {
5137           BFD_ASSERT((h->got.offset & 1) == 0);
5138           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
5139           rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT);
5140         }
5141
5142       loc = srel->contents + srel->reloc_count++ * sizeof (Elf32_External_Rel);
5143       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
5144     }
5145
5146   if (h->needs_copy)
5147     {
5148       asection * s;
5149       Elf_Internal_Rela rel;
5150       bfd_byte *loc;
5151
5152       /* This symbol needs a copy reloc.  Set it up.  */
5153       BFD_ASSERT (h->dynindx != -1
5154                   && (h->root.type == bfd_link_hash_defined
5155                       || h->root.type == bfd_link_hash_defweak));
5156
5157       s = bfd_get_section_by_name (h->root.u.def.section->owner,
5158                                    ".rel.bss");
5159       BFD_ASSERT (s != NULL);
5160
5161       rel.r_offset = (h->root.u.def.value
5162                       + h->root.u.def.section->output_section->vma
5163                       + h->root.u.def.section->output_offset);
5164       rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_COPY);
5165       loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rel);
5166       bfd_elf32_swap_reloc_out (output_bfd, &rel, loc);
5167     }
5168
5169   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
5170   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
5171       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
5172     sym->st_shndx = SHN_ABS;
5173
5174   return TRUE;
5175 }
5176
5177 /* Finish up the dynamic sections.  */
5178
5179 static bfd_boolean
5180 elf32_arm_finish_dynamic_sections (bfd * output_bfd, struct bfd_link_info * info)
5181 {
5182   bfd * dynobj;
5183   asection * sgot;
5184   asection * sdyn;
5185
5186   dynobj = elf_hash_table (info)->dynobj;
5187
5188   sgot = bfd_get_section_by_name (dynobj, ".got.plt");
5189   BFD_ASSERT (elf32_arm_hash_table (info)->symbian_p || sgot != NULL);
5190   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
5191
5192   if (elf_hash_table (info)->dynamic_sections_created)
5193     {
5194       asection *splt;
5195       Elf32_External_Dyn *dyncon, *dynconend;
5196       struct elf32_arm_link_hash_table *htab;
5197
5198       htab = elf32_arm_hash_table (info);
5199       splt = bfd_get_section_by_name (dynobj, ".plt");
5200       BFD_ASSERT (splt != NULL && sdyn != NULL);
5201
5202       dyncon = (Elf32_External_Dyn *) sdyn->contents;
5203       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
5204
5205       for (; dyncon < dynconend; dyncon++)
5206         {
5207           Elf_Internal_Dyn dyn;
5208           const char * name;
5209           asection * s;
5210
5211           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
5212
5213           switch (dyn.d_tag)
5214             {
5215               unsigned int type;
5216
5217             default:
5218               break;
5219
5220             case DT_HASH:
5221               name = ".hash";
5222               goto get_vma_if_bpabi;
5223             case DT_STRTAB:
5224               name = ".dynstr";
5225               goto get_vma_if_bpabi;
5226             case DT_SYMTAB:
5227               name = ".dynsym";
5228               goto get_vma_if_bpabi;
5229             case DT_VERSYM:
5230               name = ".gnu.version";
5231               goto get_vma_if_bpabi;
5232             case DT_VERDEF:
5233               name = ".gnu.version_d";
5234               goto get_vma_if_bpabi;
5235             case DT_VERNEED:
5236               name = ".gnu.version_r";
5237               goto get_vma_if_bpabi;
5238
5239             case DT_PLTGOT:
5240               name = ".got";
5241               goto get_vma;
5242             case DT_JMPREL:
5243               name = ".rel.plt";
5244             get_vma:
5245               s = bfd_get_section_by_name (output_bfd, name);
5246               BFD_ASSERT (s != NULL);
5247               if (!htab->symbian_p)
5248                 dyn.d_un.d_ptr = s->vma;
5249               else
5250                 /* In the BPABI, tags in the PT_DYNAMIC section point
5251                    at the file offset, not the memory address, for the
5252                    convenience of the post linker.  */
5253                 dyn.d_un.d_ptr = s->filepos;
5254               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5255               break;
5256
5257             get_vma_if_bpabi:
5258               if (htab->symbian_p)
5259                 goto get_vma;
5260               break;
5261
5262             case DT_PLTRELSZ:
5263               s = bfd_get_section_by_name (output_bfd, ".rel.plt");
5264               BFD_ASSERT (s != NULL);
5265               dyn.d_un.d_val = s->size;
5266               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5267               break;
5268
5269             case DT_RELSZ:
5270               if (!htab->symbian_p)
5271                 {
5272                   /* My reading of the SVR4 ABI indicates that the
5273                      procedure linkage table relocs (DT_JMPREL) should be
5274                      included in the overall relocs (DT_REL).  This is
5275                      what Solaris does.  However, UnixWare can not handle
5276                      that case.  Therefore, we override the DT_RELSZ entry
5277                      here to make it not include the JMPREL relocs.  Since
5278                      the linker script arranges for .rel.plt to follow all
5279                      other relocation sections, we don't have to worry
5280                      about changing the DT_REL entry.  */
5281                   s = bfd_get_section_by_name (output_bfd, ".rel.plt");
5282                   if (s != NULL)
5283                     dyn.d_un.d_val -= s->size;
5284                   bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5285                   break;
5286                 }
5287               /* Fall through */
5288
5289             case DT_REL:
5290             case DT_RELA:
5291             case DT_RELASZ:
5292               /* In the BPABI, the DT_REL tag must point at the file
5293                  offset, not the VMA, of the first relocation
5294                  section.  So, we use code similar to that in
5295                  elflink.c, but do not check for SHF_ALLOC on the
5296                  relcoation section, since relocations sections are
5297                  never allocated under the BPABI.  The comments above
5298                  about Unixware notwithstanding, we include all of the
5299                  relocations here.  */
5300               if (htab->symbian_p)
5301                 {
5302                   unsigned int i;
5303                   type = ((dyn.d_tag == DT_REL || dyn.d_tag == DT_RELSZ)
5304                           ? SHT_REL : SHT_RELA);
5305                   dyn.d_un.d_val = 0;
5306                   for (i = 1; i < elf_numsections (output_bfd); i++)
5307                     {
5308                       Elf_Internal_Shdr *hdr
5309                         = elf_elfsections (output_bfd)[i];
5310                       if (hdr->sh_type == type)
5311                         {
5312                           if (dyn.d_tag == DT_RELSZ
5313                               || dyn.d_tag == DT_RELASZ)
5314                             dyn.d_un.d_val += hdr->sh_size;
5315                           else if ((ufile_ptr) hdr->sh_offset
5316                                    <= dyn.d_un.d_val - 1)
5317                             dyn.d_un.d_val = hdr->sh_offset;
5318                         }
5319                     }
5320                   bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5321                 }
5322               break;
5323
5324               /* Set the bottom bit of DT_INIT/FINI if the
5325                  corresponding function is Thumb.  */
5326             case DT_INIT:
5327               name = info->init_function;
5328               goto get_sym;
5329             case DT_FINI:
5330               name = info->fini_function;
5331             get_sym:
5332               /* If it wasn't set by elf_bfd_final_link
5333                  then there is nothing to adjust.  */
5334               if (dyn.d_un.d_val != 0)
5335                 {
5336                   struct elf_link_hash_entry * eh;
5337
5338                   eh = elf_link_hash_lookup (elf_hash_table (info), name,
5339                                              FALSE, FALSE, TRUE);
5340                   if (eh != (struct elf_link_hash_entry *) NULL
5341                       && ELF_ST_TYPE (eh->type) == STT_ARM_TFUNC)
5342                     {
5343                       dyn.d_un.d_val |= 1;
5344                       bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5345                     }
5346                 }
5347               break;
5348             }
5349         }
5350
5351       /* Fill in the first entry in the procedure linkage table.  */
5352       if (splt->size > 0 && elf32_arm_hash_table (info)->plt_header_size)
5353         {
5354           bfd_vma got_displacement;
5355
5356           /* Calculate the displacement between the PLT slot and &GOT[0].  */
5357           got_displacement = (sgot->output_section->vma
5358                               + sgot->output_offset
5359                               - splt->output_section->vma
5360                               - splt->output_offset
5361                               - 16);
5362
5363           bfd_put_32 (output_bfd, elf32_arm_plt0_entry[0], splt->contents +  0);
5364           bfd_put_32 (output_bfd, elf32_arm_plt0_entry[1], splt->contents +  4);
5365           bfd_put_32 (output_bfd, elf32_arm_plt0_entry[2], splt->contents +  8);
5366           bfd_put_32 (output_bfd, elf32_arm_plt0_entry[3], splt->contents + 12);
5367 #ifdef FOUR_WORD_PLT
5368           /* The displacement value goes in the otherwise-unused last word of
5369              the second entry.  */
5370           bfd_put_32 (output_bfd, got_displacement,        splt->contents + 28);
5371 #else
5372           bfd_put_32 (output_bfd, got_displacement,        splt->contents + 16);
5373 #endif
5374         }
5375
5376       /* UnixWare sets the entsize of .plt to 4, although that doesn't
5377          really seem like the right value.  */
5378       elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
5379     }
5380
5381   /* Fill in the first three entries in the global offset table.  */
5382   if (sgot)
5383     {
5384       if (sgot->size > 0)
5385         {
5386           if (sdyn == NULL)
5387             bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
5388           else
5389             bfd_put_32 (output_bfd,
5390                         sdyn->output_section->vma + sdyn->output_offset,
5391                         sgot->contents);
5392           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
5393           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
5394         }
5395
5396       elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
5397     }
5398
5399   return TRUE;
5400 }
5401
5402 static void
5403 elf32_arm_post_process_headers (bfd * abfd, struct bfd_link_info * link_info ATTRIBUTE_UNUSED)
5404 {
5405   Elf_Internal_Ehdr * i_ehdrp;  /* ELF file header, internal form.  */
5406   struct elf32_arm_link_hash_table *globals;
5407
5408   i_ehdrp = elf_elfheader (abfd);
5409
5410   if (EF_ARM_EABI_VERSION (i_ehdrp->e_flags) == EF_ARM_EABI_UNKNOWN)
5411     i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_ARM;
5412   else
5413     i_ehdrp->e_ident[EI_OSABI] = 0;
5414   i_ehdrp->e_ident[EI_ABIVERSION] = ARM_ELF_ABI_VERSION;
5415
5416   if (link_info)
5417     {
5418       globals = elf32_arm_hash_table (link_info);
5419       if (globals->byteswap_code)
5420         i_ehdrp->e_flags |= EF_ARM_BE8;
5421     }
5422 }
5423
5424 static enum elf_reloc_type_class
5425 elf32_arm_reloc_type_class (const Elf_Internal_Rela *rela)
5426 {
5427   switch ((int) ELF32_R_TYPE (rela->r_info))
5428     {
5429     case R_ARM_RELATIVE:
5430       return reloc_class_relative;
5431     case R_ARM_JUMP_SLOT:
5432       return reloc_class_plt;
5433     case R_ARM_COPY:
5434       return reloc_class_copy;
5435     default:
5436       return reloc_class_normal;
5437     }
5438 }
5439
5440 /* Set the right machine number for an Arm ELF file.  */
5441
5442 static bfd_boolean
5443 elf32_arm_section_flags (flagword *flags, const Elf_Internal_Shdr *hdr)
5444 {
5445   if (hdr->sh_type == SHT_NOTE)
5446     *flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_SAME_CONTENTS;
5447
5448   return TRUE;
5449 }
5450
5451 static void
5452 elf32_arm_final_write_processing (bfd *abfd, bfd_boolean linker ATTRIBUTE_UNUSED)
5453 {
5454   bfd_arm_update_notes (abfd, ARM_NOTE_SECTION);
5455 }
5456
5457 /* Return TRUE if this is an unwinding table entry.  */
5458
5459 static bfd_boolean
5460 is_arm_elf_unwind_section_name (bfd * abfd ATTRIBUTE_UNUSED, const char * name)
5461 {
5462   size_t len1, len2;
5463
5464   len1 = sizeof (ELF_STRING_ARM_unwind) - 1;
5465   len2 = sizeof (ELF_STRING_ARM_unwind_once) - 1;
5466   return (strncmp (name, ELF_STRING_ARM_unwind, len1) == 0
5467           || strncmp (name, ELF_STRING_ARM_unwind_once, len2) == 0);
5468 }
5469
5470
5471 /* Set the type and flags for an ARM section.  We do this by
5472    the section name, which is a hack, but ought to work.  */
5473
5474 static bfd_boolean
5475 elf32_arm_fake_sections (bfd * abfd, Elf_Internal_Shdr * hdr, asection * sec)
5476 {
5477   const char * name;
5478
5479   name = bfd_get_section_name (abfd, sec);
5480
5481   if (is_arm_elf_unwind_section_name (abfd, name))
5482     {
5483       hdr->sh_type = SHT_ARM_EXIDX;
5484       hdr->sh_flags |= SHF_LINK_ORDER;
5485     }
5486   return TRUE;
5487 }
5488
5489 /* Handle an ARM specific section when reading an object file.
5490    This is called when elf.c finds a section with an unknown type.  */
5491
5492 static bfd_boolean
5493 elf32_arm_section_from_shdr (bfd *abfd,
5494                              Elf_Internal_Shdr * hdr,
5495                              const char *name)
5496 {
5497   /* There ought to be a place to keep ELF backend specific flags, but
5498      at the moment there isn't one.  We just keep track of the
5499      sections by their name, instead.  Fortunately, the ABI gives
5500      names for all the ARM specific sections, so we will probably get
5501      away with this.  */
5502   switch (hdr->sh_type)
5503     {
5504     case SHT_ARM_EXIDX:
5505       break;
5506
5507     default:
5508       return FALSE;
5509     }
5510
5511   if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name))
5512     return FALSE;
5513
5514   return TRUE;
5515 }
5516
5517 /* Called for each symbol.  Builds a section map based on mapping symbols.
5518    Does not alter any of the symbols.  */
5519
5520 static bfd_boolean
5521 elf32_arm_output_symbol_hook (struct bfd_link_info *info,
5522                               const char *name,
5523                               Elf_Internal_Sym *elfsym,
5524                               asection *input_sec,
5525                               struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
5526 {
5527   int mapcount;
5528   elf32_arm_section_map *map;
5529   struct elf32_arm_link_hash_table *globals;
5530
5531   /* Only do this on final link.  */
5532   if (info->relocatable)
5533     return TRUE;
5534
5535   /* Only build a map if we need to byteswap code.  */
5536   globals = elf32_arm_hash_table (info);
5537   if (!globals->byteswap_code)
5538     return TRUE;
5539
5540   /* We only want mapping symbols.  */
5541   if (! is_arm_mapping_symbol_name (name))
5542     return TRUE;
5543
5544   mapcount = ++(elf32_arm_section_data (input_sec)->mapcount);
5545   map = elf32_arm_section_data (input_sec)->map;
5546   /* TODO: This may be inefficient, but we probably don't usually have many
5547      mapping symbols per section.  */
5548   map = bfd_realloc (map, mapcount * sizeof (elf32_arm_section_map));
5549   elf32_arm_section_data (input_sec)->map = map;
5550
5551   map[mapcount - 1].vma = elfsym->st_value;
5552   map[mapcount - 1].type = name[1];
5553   return TRUE;
5554 }
5555
5556
5557 /* Allocate target specific section data.  */
5558
5559 static bfd_boolean
5560 elf32_arm_new_section_hook (bfd *abfd, asection *sec)
5561 {
5562   struct _arm_elf_section_data *sdata;
5563   bfd_size_type amt = sizeof (*sdata);
5564
5565   sdata = bfd_zalloc (abfd, amt);
5566   if (sdata == NULL)
5567     return FALSE;
5568   sec->used_by_bfd = sdata;
5569
5570   return _bfd_elf_new_section_hook (abfd, sec);
5571 }
5572
5573
5574 /* Used to order a list of mapping symbols by address.  */
5575
5576 static int
5577 elf32_arm_compare_mapping (const void * a, const void * b)
5578 {
5579   return ((const elf32_arm_section_map *) a)->vma
5580          > ((const elf32_arm_section_map *) b)->vma;
5581 }
5582
5583
5584 /* Do code byteswapping.  Return FALSE afterwards so that the section is
5585    written out as normal.  */
5586
5587 static bfd_boolean
5588 elf32_arm_write_section (bfd *output_bfd ATTRIBUTE_UNUSED, asection *sec,
5589                          bfd_byte *contents)
5590 {
5591   int mapcount;
5592   elf32_arm_section_map *map;
5593   bfd_vma ptr;
5594   bfd_vma end;
5595   bfd_vma offset;
5596   bfd_byte tmp;
5597   int i;
5598
5599   mapcount = elf32_arm_section_data (sec)->mapcount;
5600   map = elf32_arm_section_data (sec)->map;
5601
5602   if (mapcount == 0)
5603     return FALSE;
5604
5605   qsort (map, mapcount, sizeof (elf32_arm_section_map),
5606          elf32_arm_compare_mapping);
5607
5608   offset = sec->output_section->vma + sec->output_offset;
5609   ptr = map[0].vma - offset;
5610   for (i = 0; i < mapcount; i++)
5611     {
5612       if (i == mapcount - 1)
5613         end = sec->size;
5614       else
5615         end = map[i + 1].vma - offset;
5616
5617       switch (map[i].type)
5618         {
5619         case 'a':
5620           /* Byte swap code words.  */
5621           while (ptr + 3 < end)
5622             {
5623               tmp = contents[ptr];
5624               contents[ptr] = contents[ptr + 3];
5625               contents[ptr + 3] = tmp;
5626               tmp = contents[ptr + 1];
5627               contents[ptr + 1] = contents[ptr + 2];
5628               contents[ptr + 2] = tmp;
5629               ptr += 4;
5630             }
5631           break;
5632
5633         case 't':
5634           /* Byte swap code halfwords.  */
5635           while (ptr + 1 < end)
5636             {
5637               tmp = contents[ptr];
5638               contents[ptr] = contents[ptr + 1];
5639               contents[ptr + 1] = tmp;
5640               ptr += 2;
5641             }
5642           break;
5643
5644         case 'd':
5645           /* Leave data alone.  */
5646           break;
5647         }
5648       ptr = end;
5649     }
5650   free (map);
5651   return FALSE;
5652 }
5653
5654 /* Display STT_ARM_TFUNC symbols as functions.  */
5655
5656 static void
5657 elf32_arm_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED,
5658                              asymbol *asym)
5659 {
5660   elf_symbol_type *elfsym = (elf_symbol_type *) asym;
5661
5662   if (ELF_ST_TYPE (elfsym->internal_elf_sym.st_info) == STT_ARM_TFUNC)
5663     elfsym->symbol.flags |= BSF_FUNCTION;
5664 }
5665
5666
5667 /* Mangle thumb function symbols as we read them in.  */
5668
5669 static void
5670 elf32_arm_swap_symbol_in (bfd * abfd,
5671                           const void *psrc,
5672                           const void *pshn,
5673                           Elf_Internal_Sym *dst)
5674 {
5675   bfd_elf32_swap_symbol_in (abfd, psrc, pshn, dst);
5676
5677   /* New EABI objects mark thumb function symbols by setting the low bit of
5678      the address.  Turn these into STT_ARM_TFUNC.  */
5679   if (ELF_ST_TYPE (dst->st_info) == STT_FUNC
5680       && (dst->st_value & 1))
5681     {
5682       dst->st_info = ELF_ST_INFO (ELF_ST_BIND (dst->st_info), STT_ARM_TFUNC);
5683       dst->st_value &= ~(bfd_vma) 1;
5684     }
5685 }
5686
5687
5688 /* Mangle thumb function symbols as we write them out.  */
5689
5690 static void
5691 elf32_arm_swap_symbol_out (bfd *abfd,
5692                            const Elf_Internal_Sym *src,
5693                            void *cdst,
5694                            void *shndx)
5695 {
5696   Elf_Internal_Sym newsym;
5697
5698   /* We convert STT_ARM_TFUNC symbols into STT_FUNC with the low bit
5699      of the address set, as per the new EABI.  We do this unconditionally
5700      because objcopy does not set the elf header flags until after
5701      it writes out the symbol table.  */
5702   if (ELF_ST_TYPE (src->st_info) == STT_ARM_TFUNC)
5703     {
5704       newsym = *src;
5705       newsym.st_info = ELF_ST_INFO (ELF_ST_BIND (src->st_info), STT_FUNC);
5706       newsym.st_value |= 1;
5707
5708       src = &newsym;
5709     }
5710   bfd_elf32_swap_symbol_out (abfd, src, cdst, shndx);
5711 }
5712
5713 /* We use this to override swap_symbol_in and swap_symbol_out.  */
5714 const struct elf_size_info elf32_arm_size_info = {
5715   sizeof (Elf32_External_Ehdr),
5716   sizeof (Elf32_External_Phdr),
5717   sizeof (Elf32_External_Shdr),
5718   sizeof (Elf32_External_Rel),
5719   sizeof (Elf32_External_Rela),
5720   sizeof (Elf32_External_Sym),
5721   sizeof (Elf32_External_Dyn),
5722   sizeof (Elf_External_Note),
5723   4,
5724   1,
5725   32, 2,
5726   ELFCLASS32, EV_CURRENT,
5727   bfd_elf32_write_out_phdrs,
5728   bfd_elf32_write_shdrs_and_ehdr,
5729   bfd_elf32_write_relocs,
5730   elf32_arm_swap_symbol_in,
5731   elf32_arm_swap_symbol_out,
5732   bfd_elf32_slurp_reloc_table,
5733   bfd_elf32_slurp_symbol_table,
5734   bfd_elf32_swap_dyn_in,
5735   bfd_elf32_swap_dyn_out,
5736   bfd_elf32_swap_reloc_in,
5737   bfd_elf32_swap_reloc_out,
5738   bfd_elf32_swap_reloca_in,
5739   bfd_elf32_swap_reloca_out
5740 };
5741
5742 #define ELF_ARCH                        bfd_arch_arm
5743 #define ELF_MACHINE_CODE                EM_ARM
5744 #ifdef __QNXTARGET__
5745 #define ELF_MAXPAGESIZE                 0x1000
5746 #else
5747 #define ELF_MAXPAGESIZE                 0x8000
5748 #endif
5749 #define ELF_MINPAGESIZE                 0x1000
5750
5751 #define bfd_elf32_bfd_copy_private_bfd_data     elf32_arm_copy_private_bfd_data
5752 #define bfd_elf32_bfd_merge_private_bfd_data    elf32_arm_merge_private_bfd_data
5753 #define bfd_elf32_bfd_set_private_flags         elf32_arm_set_private_flags
5754 #define bfd_elf32_bfd_print_private_bfd_data    elf32_arm_print_private_bfd_data
5755 #define bfd_elf32_bfd_link_hash_table_create    elf32_arm_link_hash_table_create
5756 #define bfd_elf32_bfd_reloc_type_lookup         elf32_arm_reloc_type_lookup
5757 #define bfd_elf32_find_nearest_line             elf32_arm_find_nearest_line
5758 #define bfd_elf32_new_section_hook              elf32_arm_new_section_hook
5759 #define bfd_elf32_bfd_is_target_special_symbol  elf32_arm_is_target_special_symbol
5760
5761 #define elf_backend_get_symbol_type             elf32_arm_get_symbol_type
5762 #define elf_backend_gc_mark_hook                elf32_arm_gc_mark_hook
5763 #define elf_backend_gc_sweep_hook               elf32_arm_gc_sweep_hook
5764 #define elf_backend_check_relocs                elf32_arm_check_relocs
5765 #define elf_backend_relocate_section            elf32_arm_relocate_section
5766 #define elf_backend_write_section               elf32_arm_write_section
5767 #define elf_backend_adjust_dynamic_symbol       elf32_arm_adjust_dynamic_symbol
5768 #define elf_backend_create_dynamic_sections     elf32_arm_create_dynamic_sections
5769 #define elf_backend_finish_dynamic_symbol       elf32_arm_finish_dynamic_symbol
5770 #define elf_backend_finish_dynamic_sections     elf32_arm_finish_dynamic_sections
5771 #define elf_backend_link_output_symbol_hook     elf32_arm_output_symbol_hook
5772 #define elf_backend_size_dynamic_sections       elf32_arm_size_dynamic_sections
5773 #define elf_backend_post_process_headers        elf32_arm_post_process_headers
5774 #define elf_backend_reloc_type_class            elf32_arm_reloc_type_class
5775 #define elf_backend_object_p                    elf32_arm_object_p
5776 #define elf_backend_section_flags               elf32_arm_section_flags
5777 #define elf_backend_fake_sections               elf32_arm_fake_sections
5778 #define elf_backend_section_from_shdr           elf32_arm_section_from_shdr
5779 #define elf_backend_final_write_processing      elf32_arm_final_write_processing
5780 #define elf_backend_copy_indirect_symbol        elf32_arm_copy_indirect_symbol
5781 #define elf_backend_symbol_processing           elf32_arm_symbol_processing
5782 #define elf_backend_size_info                   elf32_arm_size_info
5783
5784 #define elf_backend_can_refcount    1
5785 #define elf_backend_can_gc_sections 1
5786 #define elf_backend_plt_readonly    1
5787 #define elf_backend_want_got_plt    1
5788 #define elf_backend_want_plt_sym    0
5789 #define elf_backend_may_use_rel_p   1
5790 #define elf_backend_may_use_rela_p  0
5791 #define elf_backend_default_use_rela_p 0
5792 #define elf_backend_rela_normal     0
5793
5794 #define elf_backend_got_header_size     12
5795
5796 #include "elf32-target.h"
5797
5798 /* VxWorks Targets */
5799
5800 #undef TARGET_LITTLE_SYM
5801 #define TARGET_LITTLE_SYM               bfd_elf32_littlearm_vxworks_vec
5802 #undef TARGET_LITTLE_NAME
5803 #define TARGET_LITTLE_NAME              "elf32-littlearm-vxworks"
5804 #undef TARGET_BIG_SYM
5805 #define TARGET_BIG_SYM                  bfd_elf32_bigarm_vxworks_vec
5806 #undef TARGET_BIG_NAME
5807 #define TARGET_BIG_NAME                 "elf32-bigarm-vxworks"
5808
5809 /* Like elf32_arm_link_hash_table_create -- but overrides
5810    appropriately for VxWorks.  */
5811 static struct bfd_link_hash_table *
5812 elf32_arm_vxworks_link_hash_table_create (bfd *abfd)
5813 {
5814   struct bfd_link_hash_table *ret;
5815
5816   ret = elf32_arm_link_hash_table_create (abfd);
5817   if (ret)
5818     {
5819       struct elf32_arm_link_hash_table *htab
5820         = (struct elf32_arm_link_hash_table *)ret;
5821       htab->use_rel = 0;
5822     }
5823   return ret;
5824 }
5825
5826 #undef elf32_bed
5827 #define elf32_bed elf32_arm_vxworks_bed
5828
5829 #undef bfd_elf32_bfd_link_hash_table_create
5830 #define bfd_elf32_bfd_link_hash_table_create \
5831   elf32_arm_vxworks_link_hash_table_create
5832
5833 #undef elf_backend_may_use_rel_p
5834 #define elf_backend_may_use_rel_p   0
5835 #undef elf_backend_may_use_rela_p
5836 #define elf_backend_may_use_rela_p  1
5837 #undef elf_backend_default_use_rela_p
5838 #define elf_backend_default_use_rela_p 1
5839 #undef elf_backend_rela_normal
5840 #define elf_backend_rela_normal     1
5841
5842 #include "elf32-target.h"
5843
5844
5845 /* Symbian OS Targets */
5846
5847 #undef TARGET_LITTLE_SYM
5848 #define TARGET_LITTLE_SYM               bfd_elf32_littlearm_symbian_vec
5849 #undef TARGET_LITTLE_NAME
5850 #define TARGET_LITTLE_NAME              "elf32-littlearm-symbian"
5851 #undef TARGET_BIG_SYM
5852 #define TARGET_BIG_SYM                  bfd_elf32_bigarm_symbian_vec
5853 #undef TARGET_BIG_NAME
5854 #define TARGET_BIG_NAME                 "elf32-bigarm-symbian"
5855
5856 /* Like elf32_arm_link_hash_table_create -- but overrides
5857    appropriately for Symbian OS.  */
5858 static struct bfd_link_hash_table *
5859 elf32_arm_symbian_link_hash_table_create (bfd *abfd)
5860 {
5861   struct bfd_link_hash_table *ret;
5862
5863   ret = elf32_arm_link_hash_table_create (abfd);
5864   if (ret)
5865     {
5866       struct elf32_arm_link_hash_table *htab
5867         = (struct elf32_arm_link_hash_table *)ret;
5868       /* There is no PLT header for Symbian OS.  */
5869       htab->plt_header_size = 0;
5870       /* The PLT entries are each three instructions.  */
5871       htab->plt_entry_size = 4 * NUM_ELEM (elf32_arm_symbian_plt_entry);
5872       htab->symbian_p = 1;
5873       htab->root.is_relocatable_executable = 1;
5874     }
5875   return ret;
5876 }
5877
5878 static struct bfd_elf_special_section const
5879   elf32_arm_symbian_special_sections[]=
5880 {
5881   /* In a BPABI executable, the dynamic linking sections do not go in
5882      the loadable read-only segment.  The post-linker may wish to
5883      refer to these sections, but they are not part of the final
5884      program image.  */
5885   { ".dynamic",        8,  0, SHT_DYNAMIC,  0 },
5886   { ".dynstr",         7,  0, SHT_STRTAB,   0 },
5887   { ".dynsym",         7,  0, SHT_DYNSYM,   0 },
5888   { ".got",            4,  0, SHT_PROGBITS, 0 },
5889   { ".hash",           5,  0, SHT_HASH,     0 },
5890   /* These sections do not need to be writable as the SymbianOS
5891      postlinker will arrange things so that no dynamic relocation is
5892      required.  */
5893   { ".init_array",    11,  0, SHT_INIT_ARRAY, SHF_ALLOC },
5894   { ".fini_array",    11,  0, SHT_FINI_ARRAY, SHF_ALLOC },
5895   { ".preinit_array", 14,  0, SHT_PREINIT_ARRAY, SHF_ALLOC },
5896   { NULL,              0,  0, 0,            0 }
5897 };
5898
5899 static void
5900 elf32_arm_symbian_begin_write_processing (bfd *abfd,
5901                                           struct bfd_link_info *link_info
5902                                             ATTRIBUTE_UNUSED)
5903 {
5904   /* BPABI objects are never loaded directly by an OS kernel; they are
5905      processed by a postlinker first, into an OS-specific format.  If
5906      the D_PAGED bit is set on the file, BFD will align segments on
5907      page boundaries, so that an OS can directly map the file.  With
5908      BPABI objects, that just results in wasted space.  In addition,
5909      because we clear the D_PAGED bit, map_sections_to_segments will
5910      recognize that the program headers should not be mapped into any
5911      loadable segment.  */
5912   abfd->flags &= ~D_PAGED;
5913 }
5914
5915 static bfd_boolean
5916 elf32_arm_symbian_modify_segment_map (bfd *abfd,
5917                                       struct bfd_link_info *info
5918                                         ATTRIBUTE_UNUSED)
5919 {
5920   struct elf_segment_map *m;
5921   asection *dynsec;
5922
5923   /* BPABI shared libraries and executables should have a PT_DYNAMIC
5924      segment.  However, because the .dynamic section is not marked
5925      with SEC_LOAD, the generic ELF code will not create such a
5926      segment.  */
5927   dynsec = bfd_get_section_by_name (abfd, ".dynamic");
5928   if (dynsec)
5929     {
5930       m = _bfd_elf_make_dynamic_segment (abfd, dynsec);
5931       m->next = elf_tdata (abfd)->segment_map;
5932       elf_tdata (abfd)->segment_map = m;
5933     }
5934
5935   return TRUE;
5936 }
5937
5938 #undef elf32_bed
5939 #define elf32_bed elf32_arm_symbian_bed
5940
5941 /* The dynamic sections are not allocated on SymbianOS; the postlinker
5942    will process them and then discard them.  */
5943 #undef ELF_DYNAMIC_SEC_FLAGS
5944 #define ELF_DYNAMIC_SEC_FLAGS \
5945   (SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_LINKER_CREATED)
5946
5947 #undef bfd_elf32_bfd_link_hash_table_create
5948 #define bfd_elf32_bfd_link_hash_table_create \
5949   elf32_arm_symbian_link_hash_table_create
5950
5951 #undef elf_backend_special_sections
5952 #define elf_backend_special_sections elf32_arm_symbian_special_sections
5953
5954 #undef elf_backend_begin_write_processing
5955 #define elf_backend_begin_write_processing \
5956     elf32_arm_symbian_begin_write_processing
5957
5958 #undef elf_backend_modify_segment_map
5959 #define elf_backend_modify_segment_map elf32_arm_symbian_modify_segment_map
5960
5961 /* There is no .got section for BPABI objects, and hence no header.  */
5962 #undef elf_backend_got_header_size
5963 #define elf_backend_got_header_size 0
5964
5965 /* Similarly, there is no .got.plt section.  */
5966 #undef elf_backend_want_got_plt
5967 #define elf_backend_want_got_plt 0
5968
5969 #undef elf_backend_may_use_rel_p
5970 #define elf_backend_may_use_rel_p   1
5971 #undef elf_backend_may_use_rela_p
5972 #define elf_backend_may_use_rela_p  0
5973 #undef elf_backend_default_use_rela_p
5974 #define elf_backend_default_use_rela_p 0
5975 #undef elf_backend_rela_normal
5976 #define elf_backend_rela_normal     0
5977
5978 #include "elf32-target.h"