bfd/elf32-arm.h

   1 /* 32-bit ELF support for ARM
   2    Copyright 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
   3
   4    This file is part of BFD, the Binary File Descriptor library.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  19
  20 typedef unsigned long int insn32;
  21 typedef unsigned short int insn16;
  22
  23 static boolean elf32_arm_set_private_flags
  24   PARAMS ((bfd *, flagword));
  25 static boolean elf32_arm_copy_private_bfd_data
  26   PARAMS ((bfd *, bfd *));
  27 static boolean elf32_arm_merge_private_bfd_data
  28   PARAMS ((bfd *, bfd *));
  29 static boolean elf32_arm_print_private_bfd_data
  30   PARAMS ((bfd *, PTR));
  31 static int elf32_arm_get_symbol_type
  32   PARAMS (( Elf_Internal_Sym *, int));
  33 static struct bfd_link_hash_table *elf32_arm_link_hash_table_create
  34   PARAMS ((bfd *));
  35 static bfd_reloc_status_type elf32_arm_final_link_relocate
  36   PARAMS ((reloc_howto_type *, bfd *, bfd *, asection *, bfd_byte *,
  37            Elf_Internal_Rela *, bfd_vma, struct bfd_link_info *, asection *,
  38            const char *, int, struct elf_link_hash_entry *));
  39 static insn32 insert_thumb_branch
  40   PARAMS ((insn32, int));
  41 static struct elf_link_hash_entry *find_thumb_glue
  42   PARAMS ((struct bfd_link_info *, const char *, bfd *));
  43 static struct elf_link_hash_entry *find_arm_glue
  44   PARAMS ((struct bfd_link_info *, const char *, bfd *));
  45 static void record_arm_to_thumb_glue
  46   PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
  47 static void record_thumb_to_arm_glue
  48   PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
  49 static void elf32_arm_post_process_headers
  50   PARAMS ((bfd *, struct bfd_link_info *));
  51 static int elf32_arm_to_thumb_stub
  52   PARAMS ((struct bfd_link_info *, const char *, bfd *, bfd *, asection *,
  53            bfd_byte *, asection *, bfd_vma, bfd_signed_vma, bfd_vma));
  54 static int elf32_thumb_to_arm_stub
  55   PARAMS ((struct bfd_link_info *, const char *, bfd *, bfd *, asection *,
  56            bfd_byte *, asection *, bfd_vma, bfd_signed_vma, bfd_vma));
  57 static boolean elf32_arm_relocate_section
  58   PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
  59            Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
  60 static asection * elf32_arm_gc_mark_hook
  61   PARAMS ((bfd *, struct bfd_link_info *, Elf_Internal_Rela *,
  62            struct elf_link_hash_entry *, Elf_Internal_Sym *));
  63 static boolean elf32_arm_gc_sweep_hook
  64   PARAMS ((bfd *, struct bfd_link_info *, asection *,
  65            const Elf_Internal_Rela *));
  66 static boolean elf32_arm_check_relocs
  67   PARAMS ((bfd *, struct bfd_link_info *, asection *,
  68            const Elf_Internal_Rela *));
  69 static boolean elf32_arm_find_nearest_line
  70   PARAMS ((bfd *, asection *, asymbol **, bfd_vma, const char **,
  71            const char **, unsigned int *));
  72 static boolean elf32_arm_adjust_dynamic_symbol
  73   PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
  74 static boolean elf32_arm_size_dynamic_sections
  75   PARAMS ((bfd *, struct bfd_link_info *));
  76 static boolean elf32_arm_finish_dynamic_symbol
  77   PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
  78            Elf_Internal_Sym *));
  79 static boolean elf32_arm_finish_dynamic_sections
  80   PARAMS ((bfd *, struct bfd_link_info *));
  81 static struct bfd_hash_entry * elf32_arm_link_hash_newfunc
  82   PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
  83 #ifdef USE_REL
  84 static void arm_add_to_rel
  85   PARAMS ((bfd *, bfd_byte *, reloc_howto_type *, bfd_signed_vma));
  86 #endif
  87
  88 boolean bfd_elf32_arm_allocate_interworking_sections
  89   PARAMS ((struct bfd_link_info *));
  90 boolean bfd_elf32_arm_get_bfd_for_interworking
  91   PARAMS ((bfd *, struct bfd_link_info *));
  92 boolean bfd_elf32_arm_process_before_allocation
  93   PARAMS ((bfd *, struct bfd_link_info *, int));
  94 static enum elf_reloc_type_class elf32_arm_reloc_type_class
  95   PARAMS ((const Elf_Internal_Rela *));
  96
  97 #define INTERWORK_FLAG(abfd)   (elf_elfheader (abfd)->e_flags & EF_ARM_INTERWORK)
  98
  99 /* The linker script knows the section names for placement.
 100    The entry_names are used to do simple name mangling on the stubs.
 101    Given a function name, and its type, the stub can be found. The
 102    name can be changed. The only requirement is the %s be present.  */
 103 #define THUMB2ARM_GLUE_SECTION_NAME ".glue_7t"
 104 #define THUMB2ARM_GLUE_ENTRY_NAME   "__%s_from_thumb"
 105
 106 #define ARM2THUMB_GLUE_SECTION_NAME ".glue_7"
 107 #define ARM2THUMB_GLUE_ENTRY_NAME   "__%s_from_arm"
 108
 109 /* The name of the dynamic interpreter.  This is put in the .interp
 110    section.  */
 111 #define ELF_DYNAMIC_INTERPRETER     "/usr/lib/ld.so.1"
 112
 113 /* The size in bytes of an entry in the procedure linkage table.  */
 114 #define PLT_ENTRY_SIZE 16
 115
 116 /* The first entry in a procedure linkage table looks like
 117    this.  It is set up so that any shared library function that is
 118    called before the relocation has been set up calls the dynamic
 119    linker first.  */
 120 static const bfd_vma elf32_arm_plt0_entry [PLT_ENTRY_SIZE / 4] =
 121   {
 122     0xe52de004, /* str   lr, [sp, #-4]!     */
 123     0xe59fe010, /* ldr   lr, [pc, #16]      */
 124     0xe08fe00e, /* add   lr, pc, lr         */
 125     0xe5bef008  /* ldr   pc, [lr, #8]!      */
 126   };
 127
 128 /* Subsequent entries in a procedure linkage table look like
 129    this.  */
 130 static const bfd_vma elf32_arm_plt_entry [PLT_ENTRY_SIZE / 4] =
 131  {
 132    0xe59fc004,  /* ldr   ip, [pc, #4]       */
 133    0xe08fc00c,  /* add   ip, pc, ip         */
 134    0xe59cf000,  /* ldr   pc, [ip]           */
 135    0x00000000   /* offset to symbol in got  */
 136  };
 137
 138 /* The ARM linker needs to keep track of the number of relocs that it
 139    decides to copy in check_relocs for each symbol.  This is so that
 140    it can discard PC relative relocs if it doesn't need them when
 141    linking with -Bsymbolic.  We store the information in a field
 142    extending the regular ELF linker hash table.  */
 143
 144 /* This structure keeps track of the number of PC relative relocs we
 145    have copied for a given symbol.  */
 146 struct elf32_arm_pcrel_relocs_copied
 147   {
 148     /* Next section.  */
 149     struct elf32_arm_pcrel_relocs_copied * next;
 150     /* A section in dynobj.  */
 151     asection * section;
 152     /* Number of relocs copied in this section.  */
 153     bfd_size_type count;
 154   };
 155
 156 /* Arm ELF linker hash entry.  */
 157 struct elf32_arm_link_hash_entry
 158   {
 159     struct elf_link_hash_entry root;
 160
 161     /* Number of PC relative relocs copied for this symbol.  */
 162     struct elf32_arm_pcrel_relocs_copied * pcrel_relocs_copied;
 163   };
 164
 165 /* Declare this now that the above structures are defined.  */
 166 static boolean elf32_arm_discard_copies
 167   PARAMS ((struct elf32_arm_link_hash_entry *, PTR));
 168
 169 /* Traverse an arm ELF linker hash table.  */
 170 #define elf32_arm_link_hash_traverse(table, func, info)                 \
 171   (elf_link_hash_traverse                                               \
 172    (&(table)->root,                                                     \
 173     (boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func),  \
 174     (info)))
 175
 176 /* Get the ARM elf linker hash table from a link_info structure.  */
 177 #define elf32_arm_hash_table(info) \
 178   ((struct elf32_arm_link_hash_table *) ((info)->hash))
 179
 180 /* ARM ELF linker hash table.  */
 181 struct elf32_arm_link_hash_table
 182   {
 183     /* The main hash table.  */
 184     struct elf_link_hash_table root;
 185
 186     /* The size in bytes of the section containg the Thumb-to-ARM glue.  */
 187     bfd_size_type thumb_glue_size;
 188
 189     /* The size in bytes of the section containg the ARM-to-Thumb glue.  */
 190     bfd_size_type arm_glue_size;
 191
 192     /* An arbitary input BFD chosen to hold the glue sections.  */
 193     bfd * bfd_of_glue_owner;
 194
 195     /* A boolean indicating whether knowledge of the ARM's pipeline
 196        length should be applied by the linker.  */
 197     int no_pipeline_knowledge;
 198   };
 199
 200 /* Create an entry in an ARM ELF linker hash table.  */
 201
 202 static struct bfd_hash_entry *
 203 elf32_arm_link_hash_newfunc (entry, table, string)
 204      struct bfd_hash_entry * entry;
 205      struct bfd_hash_table * table;
 206      const char * string;
 207 {
 208   struct elf32_arm_link_hash_entry * ret =
 209     (struct elf32_arm_link_hash_entry *) entry;
 210
 211   /* Allocate the structure if it has not already been allocated by a
 212      subclass.  */
 213   if (ret == (struct elf32_arm_link_hash_entry *) NULL)
 214     ret = ((struct elf32_arm_link_hash_entry *)
 215            bfd_hash_allocate (table,
 216                               sizeof (struct elf32_arm_link_hash_entry)));
 217   if (ret == (struct elf32_arm_link_hash_entry *) NULL)
 218     return (struct bfd_hash_entry *) ret;
 219
 220   /* Call the allocation method of the superclass.  */
 221   ret = ((struct elf32_arm_link_hash_entry *)
 222          _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
 223                                      table, string));
 224   if (ret != (struct elf32_arm_link_hash_entry *) NULL)
 225     ret->pcrel_relocs_copied = NULL;
 226
 227   return (struct bfd_hash_entry *) ret;
 228 }
 229
 230 /* Create an ARM elf linker hash table.  */
 231
 232 static struct bfd_link_hash_table *
 233 elf32_arm_link_hash_table_create (abfd)
 234      bfd *abfd;
 235 {
 236   struct elf32_arm_link_hash_table *ret;
 237   bfd_size_type amt = sizeof (struct elf32_arm_link_hash_table);
 238
 239   ret = (struct elf32_arm_link_hash_table *) bfd_malloc (amt);
 240   if (ret == (struct elf32_arm_link_hash_table *) NULL)
 241     return NULL;
 242
 243   if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
 244                                       elf32_arm_link_hash_newfunc))
 245     {
 246       free (ret);
 247       return NULL;
 248     }
 249
 250   ret->thumb_glue_size = 0;
 251   ret->arm_glue_size = 0;
 252   ret->bfd_of_glue_owner = NULL;
 253   ret->no_pipeline_knowledge = 0;
 254
 255   return &ret->root.root;
 256 }
 257
 258 /* Locate the Thumb encoded calling stub for NAME.  */
 259
 260 static struct elf_link_hash_entry *
 261 find_thumb_glue (link_info, name, input_bfd)
 262      struct bfd_link_info *link_info;
 263      const char *name;
 264      bfd *input_bfd;
 265 {
 266   char *tmp_name;
 267   struct elf_link_hash_entry *hash;
 268   struct elf32_arm_link_hash_table *hash_table;
 269
 270   /* We need a pointer to the armelf specific hash table.  */
 271   hash_table = elf32_arm_hash_table (link_info);
 272
 273   tmp_name = (char *) bfd_malloc ((bfd_size_type) strlen (name)
 274                                   + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1);
 275
 276   BFD_ASSERT (tmp_name);
 277
 278   sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name);
 279
 280   hash = elf_link_hash_lookup
 281     (&(hash_table)->root, tmp_name, false, false, true);
 282
 283   if (hash == NULL)
 284     /* xgettext:c-format */
 285     (*_bfd_error_handler) (_("%s: unable to find THUMB glue '%s' for `%s'"),
 286                            bfd_archive_filename (input_bfd), tmp_name, name);
 287
 288   free (tmp_name);
 289
 290   return hash;
 291 }
 292
 293 /* Locate the ARM encoded calling stub for NAME.  */
 294
 295 static struct elf_link_hash_entry *
 296 find_arm_glue (link_info, name, input_bfd)
 297      struct bfd_link_info *link_info;
 298      const char *name;
 299      bfd *input_bfd;
 300 {
 301   char *tmp_name;
 302   struct elf_link_hash_entry *myh;
 303   struct elf32_arm_link_hash_table *hash_table;
 304
 305   /* We need a pointer to the elfarm specific hash table.  */
 306   hash_table = elf32_arm_hash_table (link_info);
 307
 308   tmp_name = (char *) bfd_malloc ((bfd_size_type) strlen (name)
 309                                   + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1);
 310
 311   BFD_ASSERT (tmp_name);
 312
 313   sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
 314
 315   myh = elf_link_hash_lookup
 316     (&(hash_table)->root, tmp_name, false, false, true);
 317
 318   if (myh == NULL)
 319     /* xgettext:c-format */
 320     (*_bfd_error_handler) (_("%s: unable to find ARM glue '%s' for `%s'"),
 321                            bfd_archive_filename (input_bfd), tmp_name, name);
 322
 323   free (tmp_name);
 324
 325   return myh;
 326 }
 327
 328 /* ARM->Thumb glue:
 329
 330    .arm
 331    __func_from_arm:
 332    ldr r12, __func_addr
 333    bx  r12
 334    __func_addr:
 335    .word func    @ behave as if you saw a ARM_32 reloc.  */
 336
 337 #define ARM2THUMB_GLUE_SIZE 12
 338 static const insn32 a2t1_ldr_insn = 0xe59fc000;
 339 static const insn32 a2t2_bx_r12_insn = 0xe12fff1c;
 340 static const insn32 a2t3_func_addr_insn = 0x00000001;
 341
 342 /* Thumb->ARM:                          Thumb->(non-interworking aware) ARM
 343
 344    .thumb                               .thumb
 345    .align 2                             .align 2
 346    __func_from_thumb:              __func_from_thumb:
 347    bx pc                                push {r6, lr}
 348    nop                                  ldr  r6, __func_addr
 349    .arm                                         mov  lr, pc
 350    __func_change_to_arm:                        bx   r6
 351    b func                       .arm
 352    __func_back_to_thumb:
 353    ldmia r13! {r6, lr}
 354    bx    lr
 355    __func_addr:
 356    .word        func  */
 357
 358 #define THUMB2ARM_GLUE_SIZE 8
 359 static const insn16 t2a1_bx_pc_insn = 0x4778;
 360 static const insn16 t2a2_noop_insn = 0x46c0;
 361 static const insn32 t2a3_b_insn = 0xea000000;
 362
 363 static const insn16 t2a1_push_insn = 0xb540;
 364 static const insn16 t2a2_ldr_insn = 0x4e03;
 365 static const insn16 t2a3_mov_insn = 0x46fe;
 366 static const insn16 t2a4_bx_insn = 0x4730;
 367 static const insn32 t2a5_pop_insn = 0xe8bd4040;
 368 static const insn32 t2a6_bx_insn = 0xe12fff1e;
 369
 370 boolean
 371 bfd_elf32_arm_allocate_interworking_sections (info)
 372      struct bfd_link_info * info;
 373 {
 374   asection * s;
 375   bfd_byte * foo;
 376   struct elf32_arm_link_hash_table * globals;
 377
 378   globals = elf32_arm_hash_table (info);
 379
 380   BFD_ASSERT (globals != NULL);
 381
 382   if (globals->arm_glue_size != 0)
 383     {
 384       BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
 385
 386       s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
 387                                    ARM2THUMB_GLUE_SECTION_NAME);
 388
 389       BFD_ASSERT (s != NULL);
 390
 391       foo = (bfd_byte *) bfd_alloc (globals->bfd_of_glue_owner,
 392                                     globals->arm_glue_size);
 393
 394       s->_raw_size = s->_cooked_size = globals->arm_glue_size;
 395       s->contents = foo;
 396     }
 397
 398   if (globals->thumb_glue_size != 0)
 399     {
 400       BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
 401
 402       s = bfd_get_section_by_name
 403         (globals->bfd_of_glue_owner, THUMB2ARM_GLUE_SECTION_NAME);
 404
 405       BFD_ASSERT (s != NULL);
 406
 407       foo = (bfd_byte *) bfd_alloc (globals->bfd_of_glue_owner,
 408                                     globals->thumb_glue_size);
 409
 410       s->_raw_size = s->_cooked_size = globals->thumb_glue_size;
 411       s->contents = foo;
 412     }
 413
 414   return true;
 415 }
 416
 417 static void
 418 record_arm_to_thumb_glue (link_info, h)
 419      struct bfd_link_info * link_info;
 420      struct elf_link_hash_entry * h;
 421 {
 422   const char * name = h->root.root.string;
 423   asection * s;
 424   char * tmp_name;
 425   struct elf_link_hash_entry * myh;
 426   struct elf32_arm_link_hash_table * globals;
 427   bfd_vma val;
 428
 429   globals = elf32_arm_hash_table (link_info);
 430
 431   BFD_ASSERT (globals != NULL);
 432   BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
 433
 434   s = bfd_get_section_by_name
 435     (globals->bfd_of_glue_owner, ARM2THUMB_GLUE_SECTION_NAME);
 436
 437   BFD_ASSERT (s != NULL);
 438
 439   tmp_name = (char *) bfd_malloc ((bfd_size_type) strlen (name)
 440                                   + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1);
 441
 442   BFD_ASSERT (tmp_name);
 443
 444   sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
 445
 446   myh = elf_link_hash_lookup
 447     (&(globals)->root, tmp_name, false, false, true);
 448
 449   if (myh != NULL)
 450     {
 451       /* We've already seen this guy.  */
 452       free (tmp_name);
 453       return;
 454     }
 455
 456   /* The only trick here is using hash_table->arm_glue_size as the value. Even
 457      though the section isn't allocated yet, this is where we will be putting
 458      it.  */
 459   val = globals->arm_glue_size + 1;
 460   _bfd_generic_link_add_one_symbol (link_info, globals->bfd_of_glue_owner,
 461                                     tmp_name, BSF_GLOBAL, s, val,
 462                                     NULL, true, false,
 463                                     (struct bfd_link_hash_entry **) &myh);
 464
 465   free (tmp_name);
 466
 467   globals->arm_glue_size += ARM2THUMB_GLUE_SIZE;
 468
 469   return;
 470 }
 471
 472 static void
 473 record_thumb_to_arm_glue (link_info, h)
 474      struct bfd_link_info *link_info;
 475      struct elf_link_hash_entry *h;
 476 {
 477   const char *name = h->root.root.string;
 478   asection *s;
 479   char *tmp_name;
 480   struct elf_link_hash_entry *myh;
 481   struct elf32_arm_link_hash_table *hash_table;
 482   char bind;
 483   bfd_vma val;
 484
 485   hash_table = elf32_arm_hash_table (link_info);
 486
 487   BFD_ASSERT (hash_table != NULL);
 488   BFD_ASSERT (hash_table->bfd_of_glue_owner != NULL);
 489
 490   s = bfd_get_section_by_name
 491     (hash_table->bfd_of_glue_owner, THUMB2ARM_GLUE_SECTION_NAME);
 492
 493   BFD_ASSERT (s != NULL);
 494
 495   tmp_name = (char *) bfd_malloc ((bfd_size_type) strlen (name)
 496                                   + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1);
 497
 498   BFD_ASSERT (tmp_name);
 499
 500   sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name);
 501
 502   myh = elf_link_hash_lookup
 503     (&(hash_table)->root, tmp_name, false, false, true);
 504
 505   if (myh != NULL)
 506     {
 507       /* We've already seen this guy.  */
 508       free (tmp_name);
 509       return;
 510     }
 511
 512   val = hash_table->thumb_glue_size + 1;
 513   _bfd_generic_link_add_one_symbol (link_info, hash_table->bfd_of_glue_owner,
 514                                     tmp_name, BSF_GLOBAL, s, val,
 515                                     NULL, true, false,
 516                                     (struct bfd_link_hash_entry **) &myh);
 517
 518   /* If we mark it 'Thumb', the disassembler will do a better job.  */
 519   bind = ELF_ST_BIND (myh->type);
 520   myh->type = ELF_ST_INFO (bind, STT_ARM_TFUNC);
 521
 522   free (tmp_name);
 523
 524 #define CHANGE_TO_ARM "__%s_change_to_arm"
 525 #define BACK_FROM_ARM "__%s_back_from_arm"
 526
 527   /* Allocate another symbol to mark where we switch to Arm mode.  */
 528   tmp_name = (char *) bfd_malloc ((bfd_size_type) strlen (name)
 529                                   + strlen (CHANGE_TO_ARM) + 1);
 530
 531   BFD_ASSERT (tmp_name);
 532
 533   sprintf (tmp_name, CHANGE_TO_ARM, name);
 534
 535   myh = NULL;
 536
 537   val = hash_table->thumb_glue_size + 4,
 538   _bfd_generic_link_add_one_symbol (link_info, hash_table->bfd_of_glue_owner,
 539                                     tmp_name, BSF_LOCAL, s, val,
 540                                     NULL, true, false,
 541                                     (struct bfd_link_hash_entry **) &myh);
 542
 543   free (tmp_name);
 544
 545   hash_table->thumb_glue_size += THUMB2ARM_GLUE_SIZE;
 546
 547   return;
 548 }
 549
 550 /* Select a BFD to be used to hold the sections used by the glue code.
 551    This function is called from the linker scripts in ld/emultempl/
 552    {armelf/pe}.em  */
 553
 554 boolean
 555 bfd_elf32_arm_get_bfd_for_interworking (abfd, info)
 556      bfd *abfd;
 557      struct bfd_link_info *info;
 558 {
 559   struct elf32_arm_link_hash_table *globals;
 560   flagword flags;
 561   asection *sec;
 562
 563   /* If we are only performing a partial link do not bother
 564      getting a bfd to hold the glue.  */
 565   if (info->relocateable)
 566     return true;
 567
 568   globals = elf32_arm_hash_table (info);
 569
 570   BFD_ASSERT (globals != NULL);
 571
 572   if (globals->bfd_of_glue_owner != NULL)
 573     return true;
 574
 575   sec = bfd_get_section_by_name (abfd, ARM2THUMB_GLUE_SECTION_NAME);
 576
 577   if (sec == NULL)
 578     {
 579       /* Note: we do not include the flag SEC_LINKER_CREATED, as this
 580          will prevent elf_link_input_bfd() from processing the contents
 581          of this section.  */
 582       flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_CODE | SEC_READONLY;
 583
 584       sec = bfd_make_section (abfd, ARM2THUMB_GLUE_SECTION_NAME);
 585
 586       if (sec == NULL
 587           || !bfd_set_section_flags (abfd, sec, flags)
 588           || !bfd_set_section_alignment (abfd, sec, 2))
 589         return false;
 590
 591       /* Set the gc mark to prevent the section from being removed by garbage
 592          collection, despite the fact that no relocs refer to this section.  */
 593       sec->gc_mark = 1;
 594     }
 595
 596   sec = bfd_get_section_by_name (abfd, THUMB2ARM_GLUE_SECTION_NAME);
 597
 598   if (sec == NULL)
 599     {
 600       flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_CODE | SEC_READONLY;
 601
 602       sec = bfd_make_section (abfd, THUMB2ARM_GLUE_SECTION_NAME);
 603
 604       if (sec == NULL
 605           || !bfd_set_section_flags (abfd, sec, flags)
 606           || !bfd_set_section_alignment (abfd, sec, 2))
 607         return false;
 608
 609       sec->gc_mark = 1;
 610     }
 611
 612   /* Save the bfd for later use.  */
 613   globals->bfd_of_glue_owner = abfd;
 614
 615   return true;
 616 }
 617
 618 boolean
 619 bfd_elf32_arm_process_before_allocation (abfd, link_info, no_pipeline_knowledge)
 620      bfd *abfd;
 621      struct bfd_link_info *link_info;
 622      int no_pipeline_knowledge;
 623 {
 624   Elf_Internal_Shdr *symtab_hdr;
 625   Elf_Internal_Rela *free_relocs = NULL;
 626   Elf_Internal_Rela *irel, *irelend;
 627   bfd_byte *contents = NULL;
 628   bfd_byte *free_contents = NULL;
 629   Elf32_External_Sym *extsyms = NULL;
 630   Elf32_External_Sym *free_extsyms = NULL;
 631
 632   asection *sec;
 633   struct elf32_arm_link_hash_table *globals;
 634
 635   /* If we are only performing a partial link do not bother
 636      to construct any glue.  */
 637   if (link_info->relocateable)
 638     return true;
 639
 640   /* Here we have a bfd that is to be included on the link.  We have a hook
 641      to do reloc rummaging, before section sizes are nailed down.  */
 642   globals = elf32_arm_hash_table (link_info);
 643
 644   BFD_ASSERT (globals != NULL);
 645   BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
 646
 647   globals->no_pipeline_knowledge = no_pipeline_knowledge;
 648
 649   /* Rummage around all the relocs and map the glue vectors.  */
 650   sec = abfd->sections;
 651
 652   if (sec == NULL)
 653     return true;
 654
 655   for (; sec != NULL; sec = sec->next)
 656     {
 657       if (sec->reloc_count == 0)
 658         continue;
 659
 660       symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 661
 662       /* Load the relocs.  */
 663       irel = (_bfd_elf32_link_read_relocs (abfd, sec, (PTR) NULL,
 664                                            (Elf_Internal_Rela *) NULL, false));
 665
 666       BFD_ASSERT (irel != 0);
 667
 668       irelend = irel + sec->reloc_count;
 669       for (; irel < irelend; irel++)
 670         {
 671           long r_type;
 672           unsigned long r_index;
 673
 674           struct elf_link_hash_entry *h;
 675
 676           r_type = ELF32_R_TYPE (irel->r_info);
 677           r_index = ELF32_R_SYM (irel->r_info);
 678
 679           /* These are the only relocation types we care about.  */
 680           if (   r_type != R_ARM_PC24
 681               && r_type != R_ARM_THM_PC22)
 682             continue;
 683
 684           /* Get the section contents if we haven't done so already.  */
 685           if (contents == NULL)
 686             {
 687               /* Get cached copy if it exists.  */
 688               if (elf_section_data (sec)->this_hdr.contents != NULL)
 689                 contents = elf_section_data (sec)->this_hdr.contents;
 690               else
 691                 {
 692                   /* Go get them off disk.  */
 693                   contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
 694                   if (contents == NULL)
 695                     goto error_return;
 696
 697                   free_contents = contents;
 698
 699                   if (!bfd_get_section_contents (abfd, sec, contents,
 700                                                  (file_ptr) 0, sec->_raw_size))
 701                     goto error_return;
 702                 }
 703             }
 704
 705           /* Read this BFD's symbols if we haven't done so already.  */
 706           if (extsyms == NULL)
 707             {
 708               /* Get cached copy if it exists.  */
 709               if (symtab_hdr->contents != NULL)
 710                 extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
 711               else
 712                 {
 713                   /* Go get them off disk.  */
 714                   extsyms = ((Elf32_External_Sym *)
 715                              bfd_malloc (symtab_hdr->sh_size));
 716                   if (extsyms == NULL)
 717                     goto error_return;
 718
 719                   free_extsyms = extsyms;
 720
 721                   if (bfd_seek (abfd, symtab_hdr->sh_offset, SEEK_SET) != 0
 722                       || (bfd_bread (extsyms, symtab_hdr->sh_size, abfd)
 723                           != symtab_hdr->sh_size))
 724                     goto error_return;
 725                 }
 726             }
 727
 728           /* If the relocation is not against a symbol it cannot concern us.  */
 729           h = NULL;
 730
 731           /* We don't care about local symbols.  */
 732           if (r_index < symtab_hdr->sh_info)
 733             continue;
 734
 735           /* This is an external symbol.  */
 736           r_index -= symtab_hdr->sh_info;
 737           h = (struct elf_link_hash_entry *)
 738             elf_sym_hashes (abfd)[r_index];
 739
 740           /* If the relocation is against a static symbol it must be within
 741              the current section and so cannot be a cross ARM/Thumb relocation.  */
 742           if (h == NULL)
 743             continue;
 744
 745           switch (r_type)
 746             {
 747             case R_ARM_PC24:
 748               /* This one is a call from arm code.  We need to look up
 749                  the target of the call.  If it is a thumb target, we
 750                  insert glue.  */
 751               if (ELF_ST_TYPE(h->type) == STT_ARM_TFUNC)
 752                 record_arm_to_thumb_glue (link_info, h);
 753               break;
 754
 755             case R_ARM_THM_PC22:
 756               /* This one is a call from thumb code.  We look
 757                  up the target of the call.  If it is not a thumb
 758                  target, we insert glue.  */
 759               if (ELF_ST_TYPE (h->type) != STT_ARM_TFUNC)
 760                 record_thumb_to_arm_glue (link_info, h);
 761               break;
 762
 763             default:
 764               break;
 765             }
 766         }
 767     }
 768
 769   return true;
 770
 771 error_return:
 772   if (free_relocs != NULL)
 773     free (free_relocs);
 774   if (free_contents != NULL)
 775     free (free_contents);
 776   if (free_extsyms != NULL)
 777     free (free_extsyms);
 778
 779   return false;
 780 }
 781
 782 /* The thumb form of a long branch is a bit finicky, because the offset
 783    encoding is split over two fields, each in it's own instruction. They
 784    can occur in any order. So given a thumb form of long branch, and an
 785    offset, insert the offset into the thumb branch and return finished
 786    instruction.
 787
 788    It takes two thumb instructions to encode the target address. Each has
 789    11 bits to invest. The upper 11 bits are stored in one (identifed by
 790    H-0.. see below), the lower 11 bits are stored in the other (identified
 791    by H-1).
 792
 793    Combine together and shifted left by 1 (it's a half word address) and
 794    there you have it.
 795
 796    Op: 1111 = F,
 797    H-0, upper address-0 = 000
 798    Op: 1111 = F,
 799    H-1, lower address-0 = 800
 800
 801    They can be ordered either way, but the arm tools I've seen always put
 802    the lower one first. It probably doesn't matter. krk@cygnus.com
 803
 804    XXX:  Actually the order does matter.  The second instruction (H-1)
 805    moves the computed address into the PC, so it must be the second one
 806    in the sequence.  The problem, however is that whilst little endian code
 807    stores the instructions in HI then LOW order, big endian code does the
 808    reverse.  nickc@cygnus.com.  */
 809
 810 #define LOW_HI_ORDER      0xF800F000
 811 #define HI_LOW_ORDER      0xF000F800
 812
 813 static insn32
 814 insert_thumb_branch (br_insn, rel_off)
 815      insn32 br_insn;
 816      int rel_off;
 817 {
 818   unsigned int low_bits;
 819   unsigned int high_bits;
 820
 821   BFD_ASSERT ((rel_off & 1) != 1);
 822
 823   rel_off >>= 1;                                /* Half word aligned address.  */
 824   low_bits = rel_off & 0x000007FF;              /* The bottom 11 bits.  */
 825   high_bits = (rel_off >> 11) & 0x000007FF;     /* The top 11 bits.  */
 826
 827   if ((br_insn & LOW_HI_ORDER) == LOW_HI_ORDER)
 828     br_insn = LOW_HI_ORDER | (low_bits << 16) | high_bits;
 829   else if ((br_insn & HI_LOW_ORDER) == HI_LOW_ORDER)
 830     br_insn = HI_LOW_ORDER | (high_bits << 16) | low_bits;
 831   else
 832     /* FIXME: abort is probably not the right call. krk@cygnus.com  */
 833     abort ();                   /* error - not a valid branch instruction form.  */
 834
 835   return br_insn;
 836 }
 837
 838 /* Thumb code calling an ARM function.  */
 839
 840 static int
 841 elf32_thumb_to_arm_stub (info, name, input_bfd, output_bfd, input_section,
 842                          hit_data, sym_sec, offset, addend, val)
 843      struct bfd_link_info * info;
 844      const char *           name;
 845      bfd *                  input_bfd;
 846      bfd *                  output_bfd;
 847      asection *             input_section;
 848      bfd_byte *             hit_data;
 849      asection *             sym_sec;
 850      bfd_vma                offset;
 851      bfd_signed_vma         addend;
 852      bfd_vma                val;
 853 {
 854   asection * s = 0;
 855   bfd_vma my_offset;
 856   unsigned long int tmp;
 857   long int ret_offset;
 858   struct elf_link_hash_entry * myh;
 859   struct elf32_arm_link_hash_table * globals;
 860
 861   myh = find_thumb_glue (info, name, input_bfd);
 862   if (myh == NULL)
 863     return false;
 864
 865   globals = elf32_arm_hash_table (info);
 866
 867   BFD_ASSERT (globals != NULL);
 868   BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
 869
 870   my_offset = myh->root.u.def.value;
 871
 872   s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
 873                                THUMB2ARM_GLUE_SECTION_NAME);
 874
 875   BFD_ASSERT (s != NULL);
 876   BFD_ASSERT (s->contents != NULL);
 877   BFD_ASSERT (s->output_section != NULL);
 878
 879   if ((my_offset & 0x01) == 0x01)
 880     {
 881       if (sym_sec != NULL
 882           && sym_sec->owner != NULL
 883           && !INTERWORK_FLAG (sym_sec->owner))
 884         {
 885           (*_bfd_error_handler)
 886             (_("%s(%s): warning: interworking not enabled."),
 887              bfd_archive_filename (sym_sec->owner), name);
 888           (*_bfd_error_handler)
 889             (_("  first occurrence: %s: thumb call to arm"),
 890              bfd_archive_filename (input_bfd));
 891
 892           return false;
 893         }
 894
 895       --my_offset;
 896       myh->root.u.def.value = my_offset;
 897
 898       bfd_put_16 (output_bfd, (bfd_vma) t2a1_bx_pc_insn,
 899                   s->contents + my_offset);
 900
 901       bfd_put_16 (output_bfd, (bfd_vma) t2a2_noop_insn,
 902                   s->contents + my_offset + 2);
 903
 904       ret_offset =
 905         /* Address of destination of the stub.  */
 906         ((bfd_signed_vma) val)
 907         - ((bfd_signed_vma)
 908            /* Offset from the start of the current section to the start of the stubs.  */
 909            (s->output_offset
 910             /* Offset of the start of this stub from the start of the stubs.  */
 911             + my_offset
 912             /* Address of the start of the current section.  */
 913             + s->output_section->vma)
 914            /* The branch instruction is 4 bytes into the stub.  */
 915            + 4
 916            /* ARM branches work from the pc of the instruction + 8.  */
 917            + 8);
 918
 919       bfd_put_32 (output_bfd,
 920                   (bfd_vma) t2a3_b_insn | ((ret_offset >> 2) & 0x00FFFFFF),
 921                   s->contents + my_offset + 4);
 922     }
 923
 924   BFD_ASSERT (my_offset <= globals->thumb_glue_size);
 925
 926   /* Now go back and fix up the original BL insn to point
 927      to here.  */
 928   ret_offset = (s->output_offset
 929                 + my_offset
 930                 - (input_section->output_offset
 931                    + offset + addend)
 932                 - 8);
 933
 934   tmp = bfd_get_32 (input_bfd, hit_data
 935                     - input_section->vma);
 936
 937   bfd_put_32 (output_bfd,
 938               (bfd_vma) insert_thumb_branch (tmp, ret_offset),
 939               hit_data - input_section->vma);
 940
 941   return true;
 942 }
 943
 944 /* Arm code calling a Thumb function.  */
 945
 946 static int
 947 elf32_arm_to_thumb_stub (info, name, input_bfd, output_bfd, input_section,
 948                          hit_data, sym_sec, offset, addend, val)
 949      struct bfd_link_info * info;
 950      const char *           name;
 951      bfd *                  input_bfd;
 952      bfd *                  output_bfd;
 953      asection *             input_section;
 954      bfd_byte *             hit_data;
 955      asection *             sym_sec;
 956      bfd_vma                offset;
 957      bfd_signed_vma         addend;
 958      bfd_vma                val;
 959 {
 960   unsigned long int tmp;
 961   bfd_vma my_offset;
 962   asection * s;
 963   long int ret_offset;
 964   struct elf_link_hash_entry * myh;
 965   struct elf32_arm_link_hash_table * globals;
 966
 967   myh = find_arm_glue (info, name, input_bfd);
 968   if (myh == NULL)
 969     return false;
 970
 971   globals = elf32_arm_hash_table (info);
 972
 973   BFD_ASSERT (globals != NULL);
 974   BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
 975
 976   my_offset = myh->root.u.def.value;
 977   s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
 978                                ARM2THUMB_GLUE_SECTION_NAME);
 979   BFD_ASSERT (s != NULL);
 980   BFD_ASSERT (s->contents != NULL);
 981   BFD_ASSERT (s->output_section != NULL);
 982
 983   if ((my_offset & 0x01) == 0x01)
 984     {
 985       if (sym_sec != NULL
 986           && sym_sec->owner != NULL
 987           && !INTERWORK_FLAG (sym_sec->owner))
 988         {
 989           (*_bfd_error_handler)
 990             (_("%s(%s): warning: interworking not enabled."),
 991              bfd_archive_filename (sym_sec->owner), name);
 992           (*_bfd_error_handler)
 993             (_("  first occurrence: %s: arm call to thumb"),
 994              bfd_archive_filename (input_bfd));
 995         }
 996
 997       --my_offset;
 998       myh->root.u.def.value = my_offset;
 999
1000       bfd_put_32 (output_bfd, (bfd_vma) a2t1_ldr_insn,
1001                   s->contents + my_offset);
1002
1003       bfd_put_32 (output_bfd, (bfd_vma) a2t2_bx_r12_insn,
1004                   s->contents + my_offset + 4);
1005
1006       /* It's a thumb address.  Add the low order bit.  */
1007       bfd_put_32 (output_bfd, val | a2t3_func_addr_insn,
1008                   s->contents + my_offset + 8);
1009     }
1010
1011   BFD_ASSERT (my_offset <= globals->arm_glue_size);
1012
1013   tmp = bfd_get_32 (input_bfd, hit_data);
1014   tmp = tmp & 0xFF000000;
1015
1016   /* Somehow these are both 4 too far, so subtract 8.  */
1017   ret_offset = (s->output_offset
1018                 + my_offset
1019                 + s->output_section->vma
1020                 - (input_section->output_offset
1021                    + input_section->output_section->vma
1022                    + offset + addend)
1023                 - 8);
1024
1025   tmp = tmp | ((ret_offset >> 2) & 0x00FFFFFF);
1026
1027   bfd_put_32 (output_bfd, (bfd_vma) tmp, hit_data - input_section->vma);
1028
1029   return true;
1030 }
1031
1032 /* Perform a relocation as part of a final link.  */
1033
1034 static bfd_reloc_status_type
1035 elf32_arm_final_link_relocate (howto, input_bfd, output_bfd,
1036                                input_section, contents, rel, value,
1037                                info, sym_sec, sym_name, sym_flags, h)
1038      reloc_howto_type *     howto;
1039      bfd *                  input_bfd;
1040      bfd *                  output_bfd;
1041      asection *             input_section;
1042      bfd_byte *             contents;
1043      Elf_Internal_Rela *    rel;
1044      bfd_vma                value;
1045      struct bfd_link_info * info;
1046      asection *             sym_sec;
1047      const char *           sym_name;
1048      int                    sym_flags;
1049      struct elf_link_hash_entry * h;
1050 {
1051   unsigned long                 r_type = howto->type;
1052   unsigned long                 r_symndx;
1053   bfd_byte *                    hit_data = contents + rel->r_offset;
1054   bfd *                         dynobj = NULL;
1055   Elf_Internal_Shdr *           symtab_hdr;
1056   struct elf_link_hash_entry ** sym_hashes;
1057   bfd_vma *                     local_got_offsets;
1058   asection *                    sgot = NULL;
1059   asection *                    splt = NULL;
1060   asection *                    sreloc = NULL;
1061   bfd_vma                       addend;
1062   bfd_signed_vma                signed_addend;
1063   struct elf32_arm_link_hash_table * globals;
1064
1065   /* If the start address has been set, then set the EF_ARM_HASENTRY
1066      flag.  Setting this more than once is redundant, but the cost is
1067      not too high, and it keeps the code simple.
1068
1069      The test is done  here, rather than somewhere else, because the
1070      start address is only set just before the final link commences.
1071
1072      Note - if the user deliberately sets a start address of 0, the
1073      flag will not be set.  */
1074   if (bfd_get_start_address (output_bfd) != 0)
1075     elf_elfheader (output_bfd)->e_flags |= EF_ARM_HASENTRY;
1076
1077   globals = elf32_arm_hash_table (info);
1078
1079   dynobj = elf_hash_table (info)->dynobj;
1080   if (dynobj)
1081     {
1082       sgot = bfd_get_section_by_name (dynobj, ".got");
1083       splt = bfd_get_section_by_name (dynobj, ".plt");
1084     }
1085   symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
1086   sym_hashes = elf_sym_hashes (input_bfd);
1087   local_got_offsets = elf_local_got_offsets (input_bfd);
1088   r_symndx = ELF32_R_SYM (rel->r_info);
1089
1090 #ifdef USE_REL
1091   addend = bfd_get_32 (input_bfd, hit_data) & howto->src_mask;
1092
1093   if (addend & ((howto->src_mask + 1) >> 1))
1094     {
1095       signed_addend = -1;
1096       signed_addend &= ~ howto->src_mask;
1097       signed_addend |= addend;
1098     }
1099   else
1100     signed_addend = addend;
1101 #else
1102   addend = signed_addend = rel->r_addend;
1103 #endif
1104
1105   switch (r_type)
1106     {
1107     case R_ARM_NONE:
1108       return bfd_reloc_ok;
1109
1110     case R_ARM_PC24:
1111     case R_ARM_ABS32:
1112     case R_ARM_REL32:
1113 #ifndef OLD_ARM_ABI
1114     case R_ARM_XPC25:
1115 #endif
1116       /* When generating a shared object, these relocations are copied
1117          into the output file to be resolved at run time.  */
1118       if (info->shared
1119           && r_symndx != 0
1120           && (r_type != R_ARM_PC24
1121               || (h != NULL
1122                   && h->dynindx != -1
1123                   && (! info->symbolic
1124                       || (h->elf_link_hash_flags
1125                           & ELF_LINK_HASH_DEF_REGULAR) == 0))))
1126         {
1127           Elf_Internal_Rel outrel;
1128           boolean skip, relocate;
1129
1130           if (sreloc == NULL)
1131             {
1132               const char * name;
1133
1134               name = (bfd_elf_string_from_elf_section
1135                       (input_bfd,
1136                        elf_elfheader (input_bfd)->e_shstrndx,
1137                        elf_section_data (input_section)->rel_hdr.sh_name));
1138               if (name == NULL)
1139                 return bfd_reloc_notsupported;
1140
1141               BFD_ASSERT (strncmp (name, ".rel", 4) == 0
1142                           && strcmp (bfd_get_section_name (input_bfd,
1143                                                            input_section),
1144                                      name + 4) == 0);
1145
1146               sreloc = bfd_get_section_by_name (dynobj, name);
1147               BFD_ASSERT (sreloc != NULL);
1148             }
1149
1150           skip = false;
1151           relocate = false;
1152
1153           outrel.r_offset =
1154             _bfd_elf_section_offset (output_bfd, info, input_section,
1155                                      rel->r_offset);
1156           if (outrel.r_offset == (bfd_vma) -1)
1157             skip = true;
1158           else if (outrel.r_offset == (bfd_vma) -2)
1159             skip = true, relocate = true;
1160           outrel.r_offset += (input_section->output_section->vma
1161                               + input_section->output_offset);
1162
1163           if (skip)
1164             memset (&outrel, 0, sizeof outrel);
1165           else if (r_type == R_ARM_PC24)
1166             {
1167               BFD_ASSERT (h != NULL && h->dynindx != -1);
1168               if ((input_section->flags & SEC_ALLOC) == 0)
1169                 relocate = true;
1170               outrel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_PC24);
1171             }
1172           else
1173             {
1174               if (h == NULL
1175                   || ((info->symbolic || h->dynindx == -1)
1176                       && (h->elf_link_hash_flags
1177                           & ELF_LINK_HASH_DEF_REGULAR) != 0))
1178                 {
1179                   relocate = true;
1180                   outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
1181                 }
1182               else
1183                 {
1184                   BFD_ASSERT (h->dynindx != -1);
1185                   if ((input_section->flags & SEC_ALLOC) == 0)
1186                     relocate = true;
1187                   outrel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_ABS32);
1188                 }
1189             }
1190
1191           bfd_elf32_swap_reloc_out (output_bfd, &outrel,
1192                                     (((Elf32_External_Rel *)
1193                                       sreloc->contents)
1194                                      + sreloc->reloc_count));
1195           ++sreloc->reloc_count;
1196
1197           /* If this reloc is against an external symbol, we do not want to
1198              fiddle with the addend.  Otherwise, we need to include the symbol
1199              value so that it becomes an addend for the dynamic reloc.  */
1200           if (! relocate)
1201             return bfd_reloc_ok;
1202
1203           return _bfd_final_link_relocate (howto, input_bfd, input_section,
1204                                            contents, rel->r_offset, value,
1205                                            (bfd_vma) 0);
1206         }
1207       else switch (r_type)
1208         {
1209 #ifndef OLD_ARM_ABI
1210         case R_ARM_XPC25:         /* Arm BLX instruction.  */
1211 #endif
1212         case R_ARM_PC24:          /* Arm B/BL instruction */
1213 #ifndef OLD_ARM_ABI
1214           if (r_type == R_ARM_XPC25)
1215             {
1216               /* Check for Arm calling Arm function.  */
1217               /* FIXME: Should we translate the instruction into a BL
1218                  instruction instead ?  */
1219               if (sym_flags != STT_ARM_TFUNC)
1220                 (*_bfd_error_handler) (_("\
1221 %s: Warning: Arm BLX instruction targets Arm function '%s'."),
1222                                        bfd_archive_filename (input_bfd),
1223                                        h ? h->root.root.string : "(local)");
1224             }
1225           else
1226 #endif
1227             {
1228               /* Check for Arm calling Thumb function.  */
1229               if (sym_flags == STT_ARM_TFUNC)
1230                 {
1231                   elf32_arm_to_thumb_stub (info, sym_name, input_bfd, output_bfd,
1232                                            input_section, hit_data, sym_sec, rel->r_offset,
1233                                            signed_addend, value);
1234                   return bfd_reloc_ok;
1235                 }
1236             }
1237
1238           if (   strcmp (bfd_get_target (input_bfd), "elf32-littlearm-oabi") == 0
1239               || strcmp (bfd_get_target (input_bfd), "elf32-bigarm-oabi") == 0)
1240             {
1241               /* The old way of doing things.  Trearing the addend as a
1242                  byte sized field and adding in the pipeline offset.  */
1243               value -= (input_section->output_section->vma
1244                         + input_section->output_offset);
1245               value -= rel->r_offset;
1246               value += addend;
1247
1248               if (! globals->no_pipeline_knowledge)
1249                 value -= 8;
1250             }
1251           else
1252             {
1253               /* The ARM ELF ABI says that this reloc is computed as: S - P + A
1254                  where:
1255                   S is the address of the symbol in the relocation.
1256                   P is address of the instruction being relocated.
1257                   A is the addend (extracted from the instruction) in bytes.
1258
1259                  S is held in 'value'.
1260                  P is the base address of the section containing the instruction
1261                    plus the offset of the reloc into that section, ie:
1262                      (input_section->output_section->vma +
1263                       input_section->output_offset +
1264                       rel->r_offset).
1265                  A is the addend, converted into bytes, ie:
1266                      (signed_addend * 4)
1267
1268                  Note: None of these operations have knowledge of the pipeline
1269                  size of the processor, thus it is up to the assembler to encode
1270                  this information into the addend.  */
1271               value -= (input_section->output_section->vma
1272                         + input_section->output_offset);
1273               value -= rel->r_offset;
1274               value += (signed_addend << howto->size);
1275
1276               /* Previous versions of this code also used to add in the pipeline
1277                  offset here.  This is wrong because the linker is not supposed
1278                  to know about such things, and one day it might change.  In order
1279                  to support old binaries that need the old behaviour however, so
1280                  we attempt to detect which ABI was used to create the reloc.  */
1281               if (! globals->no_pipeline_knowledge)
1282                 {
1283                   Elf_Internal_Ehdr * i_ehdrp; /* Elf file header, internal form */
1284
1285                   i_ehdrp = elf_elfheader (input_bfd);
1286
1287                   if (i_ehdrp->e_ident[EI_OSABI] == 0)
1288                     value -= 8;
1289                 }
1290             }
1291
1292           signed_addend = value;
1293           signed_addend >>= howto->rightshift;
1294
1295           /* It is not an error for an undefined weak reference to be
1296              out of range.  Any program that branches to such a symbol
1297              is going to crash anyway, so there is no point worrying
1298              about getting the destination exactly right.  */
1299           if (! h || h->root.type != bfd_link_hash_undefweak)
1300             {
1301               /* Perform a signed range check.  */
1302               if (   signed_addend >   ((bfd_signed_vma)  (howto->dst_mask >> 1))
1303                   || signed_addend < - ((bfd_signed_vma) ((howto->dst_mask + 1) >> 1)))
1304                 return bfd_reloc_overflow;
1305             }
1306
1307 #ifndef OLD_ARM_ABI
1308           /* If necessary set the H bit in the BLX instruction.  */
1309           if (r_type == R_ARM_XPC25 && ((value & 2) == 2))
1310             value = (signed_addend & howto->dst_mask)
1311               | (bfd_get_32 (input_bfd, hit_data) & (~ howto->dst_mask))
1312               | (1 << 24);
1313           else
1314 #endif
1315             value = (signed_addend & howto->dst_mask)
1316               | (bfd_get_32 (input_bfd, hit_data) & (~ howto->dst_mask));
1317           break;
1318
1319         case R_ARM_ABS32:
1320           value += addend;
1321           if (sym_flags == STT_ARM_TFUNC)
1322             value |= 1;
1323           break;
1324
1325         case R_ARM_REL32:
1326           value -= (input_section->output_section->vma
1327                     + input_section->output_offset + rel->r_offset);
1328           value += addend;
1329           break;
1330         }
1331
1332       bfd_put_32 (input_bfd, value, hit_data);
1333       return bfd_reloc_ok;
1334
1335     case R_ARM_ABS8:
1336       value += addend;
1337       if ((long) value > 0x7f || (long) value < -0x80)
1338         return bfd_reloc_overflow;
1339
1340       bfd_put_8 (input_bfd, value, hit_data);
1341       return bfd_reloc_ok;
1342
1343     case R_ARM_ABS16:
1344       value += addend;
1345
1346       if ((long) value > 0x7fff || (long) value < -0x8000)
1347         return bfd_reloc_overflow;
1348
1349       bfd_put_16 (input_bfd, value, hit_data);
1350       return bfd_reloc_ok;
1351
1352     case R_ARM_ABS12:
1353       /* Support ldr and str instruction for the arm */
1354       /* Also thumb b (unconditional branch).  ??? Really?  */
1355       value += addend;
1356
1357       if ((long) value > 0x7ff || (long) value < -0x800)
1358         return bfd_reloc_overflow;
1359
1360       value |= (bfd_get_32 (input_bfd, hit_data) & 0xfffff000);
1361       bfd_put_32 (input_bfd, value, hit_data);
1362       return bfd_reloc_ok;
1363
1364     case R_ARM_THM_ABS5:
1365       /* Support ldr and str instructions for the thumb.  */
1366 #ifdef USE_REL
1367       /* Need to refetch addend.  */
1368       addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
1369       /* ??? Need to determine shift amount from operand size.  */
1370       addend >>= howto->rightshift;
1371 #endif
1372       value += addend;
1373
1374       /* ??? Isn't value unsigned?  */
1375       if ((long) value > 0x1f || (long) value < -0x10)
1376         return bfd_reloc_overflow;
1377
1378       /* ??? Value needs to be properly shifted into place first.  */
1379       value |= bfd_get_16 (input_bfd, hit_data) & 0xf83f;
1380       bfd_put_16 (input_bfd, value, hit_data);
1381       return bfd_reloc_ok;
1382
1383 #ifndef OLD_ARM_ABI
1384     case R_ARM_THM_XPC22:
1385 #endif
1386     case R_ARM_THM_PC22:
1387       /* Thumb BL (branch long instruction).  */
1388       {
1389         bfd_vma        relocation;
1390         boolean        overflow = false;
1391         bfd_vma        upper_insn = bfd_get_16 (input_bfd, hit_data);
1392         bfd_vma        lower_insn = bfd_get_16 (input_bfd, hit_data + 2);
1393         bfd_signed_vma reloc_signed_max = ((1 << (howto->bitsize - 1)) - 1) >> howto->rightshift;
1394         bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
1395         bfd_vma        check;
1396         bfd_signed_vma signed_check;
1397
1398 #ifdef USE_REL
1399         /* Need to refetch the addend and squish the two 11 bit pieces
1400            together.  */
1401         {
1402           bfd_vma upper = upper_insn & 0x7ff;
1403           bfd_vma lower = lower_insn & 0x7ff;
1404           upper = (upper ^ 0x400) - 0x400; /* Sign extend.  */
1405           addend = (upper << 12) | (lower << 1);
1406           signed_addend = addend;
1407         }
1408 #endif
1409 #ifndef OLD_ARM_ABI
1410         if (r_type == R_ARM_THM_XPC22)
1411           {
1412             /* Check for Thumb to Thumb call.  */
1413             /* FIXME: Should we translate the instruction into a BL
1414                instruction instead ?  */
1415             if (sym_flags == STT_ARM_TFUNC)
1416               (*_bfd_error_handler) (_("\
1417 %s: Warning: Thumb BLX instruction targets thumb function '%s'."),
1418                                      bfd_archive_filename (input_bfd),
1419                                      h ? h->root.root.string : "(local)");
1420           }
1421         else
1422 #endif
1423           {
1424             /* If it is not a call to Thumb, assume call to Arm.
1425                If it is a call relative to a section name, then it is not a
1426                function call at all, but rather a long jump.  */
1427             if (sym_flags != STT_ARM_TFUNC && sym_flags != STT_SECTION)
1428               {
1429                 if (elf32_thumb_to_arm_stub
1430                     (info, sym_name, input_bfd, output_bfd, input_section,
1431                      hit_data, sym_sec, rel->r_offset, signed_addend, value))
1432                   return bfd_reloc_ok;
1433                 else
1434                   return bfd_reloc_dangerous;
1435               }
1436           }
1437
1438         relocation = value + signed_addend;
1439
1440         relocation -= (input_section->output_section->vma
1441                        + input_section->output_offset
1442                        + rel->r_offset);
1443
1444         if (! globals->no_pipeline_knowledge)
1445           {
1446             Elf_Internal_Ehdr * i_ehdrp; /* Elf file header, internal form.  */
1447
1448             i_ehdrp = elf_elfheader (input_bfd);
1449
1450             /* Previous versions of this code also used to add in the pipline
1451                offset here.  This is wrong because the linker is not supposed
1452                to know about such things, and one day it might change.  In order
1453                to support old binaries that need the old behaviour however, so
1454                we attempt to detect which ABI was used to create the reloc.  */
1455             if (   strcmp (bfd_get_target (input_bfd), "elf32-littlearm-oabi") == 0
1456                 || strcmp (bfd_get_target (input_bfd), "elf32-bigarm-oabi") == 0
1457                 || i_ehdrp->e_ident[EI_OSABI] == 0)
1458               relocation += 4;
1459           }
1460
1461         check = relocation >> howto->rightshift;
1462
1463         /* If this is a signed value, the rightshift just dropped
1464            leading 1 bits (assuming twos complement).  */
1465         if ((bfd_signed_vma) relocation >= 0)
1466           signed_check = check;
1467         else
1468           signed_check = check | ~((bfd_vma) -1 >> howto->rightshift);
1469
1470         /* Assumes two's complement.  */
1471         if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
1472           overflow = true;
1473
1474         /* Put RELOCATION back into the insn.  */
1475         upper_insn = (upper_insn & ~(bfd_vma) 0x7ff) | ((relocation >> 12) & 0x7ff);
1476         lower_insn = (lower_insn & ~(bfd_vma) 0x7ff) | ((relocation >> 1) & 0x7ff);
1477
1478 #ifndef OLD_ARM_ABI
1479         if (r_type == R_ARM_THM_XPC22
1480             && ((lower_insn & 0x1800) == 0x0800))
1481           /* Remove bit zero of the adjusted offset.  Bit zero can only be
1482              set if the upper insn is at a half-word boundary, since the
1483              destination address, an ARM instruction, must always be on a
1484              word boundary.  The semantics of the BLX (1) instruction, however,
1485              are that bit zero in the offset must always be zero, and the
1486              corresponding bit one in the target address will be set from bit
1487              one of the source address.  */
1488           lower_insn &= ~1;
1489 #endif
1490         /* Put the relocated value back in the object file:  */
1491         bfd_put_16 (input_bfd, upper_insn, hit_data);
1492         bfd_put_16 (input_bfd, lower_insn, hit_data + 2);
1493
1494         return (overflow ? bfd_reloc_overflow : bfd_reloc_ok);
1495       }
1496       break;
1497
1498     case R_ARM_THM_PC11:
1499       /* Thumb B (branch) instruction).  */
1500       {
1501         bfd_vma        relocation;
1502         bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
1503         bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
1504         bfd_vma        check;
1505         bfd_signed_vma signed_check;
1506
1507 #ifdef USE_REL
1508         /* Need to refetch addend.  */
1509         addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
1510         /* ??? Need to determine shift amount from operand size.  */
1511         addend >>= howto->rightshift;
1512 #endif
1513         relocation = value + addend;
1514
1515         relocation -= (input_section->output_section->vma
1516                        + input_section->output_offset
1517                        + rel->r_offset);
1518
1519         check = relocation >> howto->rightshift;
1520
1521         /* If this is a signed value, the rightshift just
1522            dropped leading 1 bits (assuming twos complement).  */
1523         if ((bfd_signed_vma) relocation >= 0)
1524           signed_check = check;
1525         else
1526           signed_check = check | ~((bfd_vma) -1 >> howto->rightshift);
1527
1528         relocation |= (bfd_get_16 (input_bfd, hit_data) & (~ howto->dst_mask));
1529
1530         bfd_put_16 (input_bfd, relocation, hit_data);
1531
1532         /* Assumes two's complement.  */
1533         if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
1534           return bfd_reloc_overflow;
1535
1536         return bfd_reloc_ok;
1537       }
1538
1539     case R_ARM_GNU_VTINHERIT:
1540     case R_ARM_GNU_VTENTRY:
1541       return bfd_reloc_ok;
1542
1543     case R_ARM_COPY:
1544       return bfd_reloc_notsupported;
1545
1546     case R_ARM_GLOB_DAT:
1547       return bfd_reloc_notsupported;
1548
1549     case R_ARM_JUMP_SLOT:
1550       return bfd_reloc_notsupported;
1551
1552     case R_ARM_RELATIVE:
1553       return bfd_reloc_notsupported;
1554
1555     case R_ARM_GOTOFF:
1556       /* Relocation is relative to the start of the
1557          global offset table.  */
1558
1559       BFD_ASSERT (sgot != NULL);
1560       if (sgot == NULL)
1561         return bfd_reloc_notsupported;
1562
1563       /* If we are addressing a Thumb function, we need to adjust the
1564          address by one, so that attempts to call the function pointer will
1565          correctly interpret it as Thumb code.  */
1566       if (sym_flags == STT_ARM_TFUNC)
1567         value += 1;
1568
1569       /* Note that sgot->output_offset is not involved in this
1570          calculation.  We always want the start of .got.  If we
1571          define _GLOBAL_OFFSET_TABLE in a different way, as is
1572          permitted by the ABI, we might have to change this
1573          calculation.  */
1574       value -= sgot->output_section->vma;
1575       return _bfd_final_link_relocate (howto, input_bfd, input_section,
1576                                        contents, rel->r_offset, value,
1577                                        (bfd_vma) 0);
1578
1579     case R_ARM_GOTPC:
1580       /* Use global offset table as symbol value.  */
1581       BFD_ASSERT (sgot != NULL);
1582
1583       if (sgot == NULL)
1584         return bfd_reloc_notsupported;
1585
1586       value = sgot->output_section->vma;
1587       return _bfd_final_link_relocate (howto, input_bfd, input_section,
1588                                        contents, rel->r_offset, value,
1589                                        (bfd_vma) 0);
1590
1591     case R_ARM_GOT32:
1592       /* Relocation is to the entry for this symbol in the
1593          global offset table.  */
1594       if (sgot == NULL)
1595         return bfd_reloc_notsupported;
1596
1597       if (h != NULL)
1598         {
1599           bfd_vma off;
1600
1601           off = h->got.offset;
1602           BFD_ASSERT (off != (bfd_vma) -1);
1603
1604           if (!elf_hash_table (info)->dynamic_sections_created ||
1605               (info->shared && (info->symbolic || h->dynindx == -1)
1606                && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1607             {
1608               /* This is actually a static link, or it is a -Bsymbolic link
1609                  and the symbol is defined locally.  We must initialize this
1610                  entry in the global offset table.  Since the offset must
1611                  always be a multiple of 4, we use the least significant bit
1612                  to record whether we have initialized it already.
1613
1614                  When doing a dynamic link, we create a .rel.got relocation
1615                  entry to initialize the value.  This is done in the
1616                  finish_dynamic_symbol routine.  */
1617               if ((off & 1) != 0)
1618                 off &= ~1;
1619               else
1620                 {
1621                   /* If we are addressing a Thumb function, we need to
1622                      adjust the address by one, so that attempts to
1623                      call the function pointer will correctly
1624                      interpret it as Thumb code.  */
1625                   if (sym_flags == STT_ARM_TFUNC)
1626                     value |= 1;
1627
1628                   bfd_put_32 (output_bfd, value, sgot->contents + off);
1629                   h->got.offset |= 1;
1630                 }
1631             }
1632
1633           value = sgot->output_offset + off;
1634         }
1635       else
1636         {
1637           bfd_vma off;
1638
1639           BFD_ASSERT (local_got_offsets != NULL &&
1640                       local_got_offsets[r_symndx] != (bfd_vma) -1);
1641
1642           off = local_got_offsets[r_symndx];
1643
1644           /* The offset must always be a multiple of 4.  We use the
1645              least significant bit to record whether we have already
1646              generated the necessary reloc.  */
1647           if ((off & 1) != 0)
1648             off &= ~1;
1649           else
1650             {
1651               bfd_put_32 (output_bfd, value, sgot->contents + off);
1652
1653               if (info->shared)
1654                 {
1655                   asection * srelgot;
1656                   Elf_Internal_Rel outrel;
1657
1658                   srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
1659                   BFD_ASSERT (srelgot != NULL);
1660
1661                   outrel.r_offset = (sgot->output_section->vma
1662                                      + sgot->output_offset
1663                                      + off);
1664                   outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
1665                   bfd_elf32_swap_reloc_out (output_bfd, &outrel,
1666                                             (((Elf32_External_Rel *)
1667                                               srelgot->contents)
1668                                              + srelgot->reloc_count));
1669                   ++srelgot->reloc_count;
1670                 }
1671
1672               local_got_offsets[r_symndx] |= 1;
1673             }
1674
1675           value = sgot->output_offset + off;
1676         }
1677
1678       return _bfd_final_link_relocate (howto, input_bfd, input_section,
1679                                        contents, rel->r_offset, value,
1680                                        (bfd_vma) 0);
1681
1682     case R_ARM_PLT32:
1683       /* Relocation is to the entry for this symbol in the
1684          procedure linkage table.  */
1685
1686       /* Resolve a PLT32 reloc against a local symbol directly,
1687          without using the procedure linkage table.  */
1688       if (h == NULL)
1689         return _bfd_final_link_relocate (howto, input_bfd, input_section,
1690                                  contents, rel->r_offset, value,
1691                                  (bfd_vma) 0);
1692
1693       if (h->plt.offset == (bfd_vma) -1)
1694         /* We didn't make a PLT entry for this symbol.  This
1695            happens when statically linking PIC code, or when
1696            using -Bsymbolic.  */
1697         return _bfd_final_link_relocate (howto, input_bfd, input_section,
1698                                          contents, rel->r_offset, value,
1699                                          (bfd_vma) 0);
1700
1701       BFD_ASSERT(splt != NULL);
1702       if (splt == NULL)
1703         return bfd_reloc_notsupported;
1704
1705       value = (splt->output_section->vma
1706                + splt->output_offset
1707                + h->plt.offset);
1708       return _bfd_final_link_relocate (howto, input_bfd, input_section,
1709                                contents, rel->r_offset, value,
1710                                (bfd_vma) 0);
1711
1712     case R_ARM_SBREL32:
1713       return bfd_reloc_notsupported;
1714
1715     case R_ARM_AMP_VCALL9:
1716       return bfd_reloc_notsupported;
1717
1718     case R_ARM_RSBREL32:
1719       return bfd_reloc_notsupported;
1720
1721     case R_ARM_THM_RPC22:
1722       return bfd_reloc_notsupported;
1723
1724     case R_ARM_RREL32:
1725       return bfd_reloc_notsupported;
1726
1727     case R_ARM_RABS32:
1728       return bfd_reloc_notsupported;
1729
1730     case R_ARM_RPC24:
1731       return bfd_reloc_notsupported;
1732
1733     case R_ARM_RBASE:
1734       return bfd_reloc_notsupported;
1735
1736     default:
1737       return bfd_reloc_notsupported;
1738     }
1739 }
1740
1741 #ifdef USE_REL
1742 /* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS.  */
1743 static void
1744 arm_add_to_rel (abfd, address, howto, increment)
1745      bfd *              abfd;
1746      bfd_byte *         address;
1747      reloc_howto_type * howto;
1748      bfd_signed_vma     increment;
1749 {
1750   bfd_signed_vma addend;
1751
1752   if (howto->type == R_ARM_THM_PC22)
1753     {
1754       int upper_insn, lower_insn;
1755       int upper, lower;
1756
1757       upper_insn = bfd_get_16 (abfd, address);
1758       lower_insn = bfd_get_16 (abfd, address + 2);
1759       upper = upper_insn & 0x7ff;
1760       lower = lower_insn & 0x7ff;
1761
1762       addend = (upper << 12) | (lower << 1);
1763       addend += increment;
1764       addend >>= 1;
1765
1766       upper_insn = (upper_insn & 0xf800) | ((addend >> 11) & 0x7ff);
1767       lower_insn = (lower_insn & 0xf800) | (addend & 0x7ff);
1768
1769       bfd_put_16 (abfd, (bfd_vma) upper_insn, address);
1770       bfd_put_16 (abfd, (bfd_vma) lower_insn, address + 2);
1771     }
1772   else
1773     {
1774       bfd_vma        contents;
1775
1776       contents = bfd_get_32 (abfd, address);
1777
1778       /* Get the (signed) value from the instruction.  */
1779       addend = contents & howto->src_mask;
1780       if (addend & ((howto->src_mask + 1) >> 1))
1781         {
1782           bfd_signed_vma mask;
1783
1784           mask = -1;
1785           mask &= ~ howto->src_mask;
1786           addend |= mask;
1787         }
1788
1789       /* Add in the increment, (which is a byte value).  */
1790       switch (howto->type)
1791         {
1792         default:
1793           addend += increment;
1794           break;
1795
1796         case R_ARM_PC24:
1797           addend <<= howto->size;
1798           addend += increment;
1799
1800           /* Should we check for overflow here ?  */
1801
1802           /* Drop any undesired bits.  */
1803           addend >>= howto->rightshift;
1804           break;
1805         }
1806
1807       contents = (contents & ~ howto->dst_mask) | (addend & howto->dst_mask);
1808
1809       bfd_put_32 (abfd, contents, address);
1810     }
1811 }
1812 #endif /* USE_REL */
1813
1814 /* Relocate an ARM ELF section.  */
1815 static boolean
1816 elf32_arm_relocate_section (output_bfd, info, input_bfd, input_section,
1817                             contents, relocs, local_syms, local_sections)
1818      bfd *                  output_bfd;
1819      struct bfd_link_info * info;
1820      bfd *                  input_bfd;
1821      asection *             input_section;
1822      bfd_byte *             contents;
1823      Elf_Internal_Rela *    relocs;
1824      Elf_Internal_Sym *     local_syms;
1825      asection **            local_sections;
1826 {
1827   Elf_Internal_Shdr *           symtab_hdr;
1828   struct elf_link_hash_entry ** sym_hashes;
1829   Elf_Internal_Rela *           rel;
1830   Elf_Internal_Rela *           relend;
1831   const char *                  name;
1832
1833   symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
1834   sym_hashes = elf_sym_hashes (input_bfd);
1835
1836   rel = relocs;
1837   relend = relocs + input_section->reloc_count;
1838   for (; rel < relend; rel++)
1839     {
1840       int                          r_type;
1841       reloc_howto_type *           howto;
1842       unsigned long                r_symndx;
1843       Elf_Internal_Sym *           sym;
1844       asection *                   sec;
1845       struct elf_link_hash_entry * h;
1846       bfd_vma                      relocation;
1847       bfd_reloc_status_type        r;
1848       arelent                      bfd_reloc;
1849
1850       r_symndx = ELF32_R_SYM (rel->r_info);
1851       r_type   = ELF32_R_TYPE (rel->r_info);
1852
1853       if (   r_type == R_ARM_GNU_VTENTRY
1854           || r_type == R_ARM_GNU_VTINHERIT)
1855         continue;
1856
1857 #ifdef USE_REL
1858       elf32_arm_info_to_howto (input_bfd, & bfd_reloc,
1859                                (Elf_Internal_Rel *) rel);
1860 #else
1861       elf32_arm_info_to_howto (input_bfd, & bfd_reloc, rel);
1862 #endif
1863       howto = bfd_reloc.howto;
1864
1865       if (info->relocateable)
1866         {
1867           /* This is a relocateable link.  We don't have to change
1868              anything, unless the reloc is against a section symbol,
1869              in which case we have to adjust according to where the
1870              section symbol winds up in the output section.  */
1871           if (r_symndx < symtab_hdr->sh_info)
1872             {
1873               sym = local_syms + r_symndx;
1874               if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1875                 {
1876                   sec = local_sections[r_symndx];
1877 #ifdef USE_REL
1878                   arm_add_to_rel (input_bfd, contents + rel->r_offset,
1879                                   howto,
1880                                   (bfd_signed_vma) (sec->output_offset
1881                                                     + sym->st_value));
1882 #else
1883                   rel->r_addend += (sec->output_offset + sym->st_value);
1884 #endif
1885                 }
1886             }
1887
1888           continue;
1889         }
1890
1891       /* This is a final link.  */
1892       h = NULL;
1893       sym = NULL;
1894       sec = NULL;
1895
1896       if (r_symndx < symtab_hdr->sh_info)
1897         {
1898           sym = local_syms + r_symndx;
1899           sec = local_sections[r_symndx];
1900 #ifdef USE_REL
1901           relocation = (sec->output_section->vma
1902                         + sec->output_offset
1903                         + sym->st_value);
1904           if ((sec->flags & SEC_MERGE)
1905                    && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1906             {
1907               asection *msec;
1908               bfd_vma addend, value;
1909
1910               if (howto->rightshift)
1911                 {
1912                   (*_bfd_error_handler)
1913                     (_("%s(%s+0x%lx): %s relocation against SEC_MERGE section"),
1914                      bfd_archive_filename (input_bfd),
1915                      bfd_get_section_name (input_bfd, input_section),
1916                      (long) rel->r_offset, howto->name);
1917                   return false;
1918                 }
1919
1920               value = bfd_get_32 (input_bfd, contents + rel->r_offset);
1921
1922               /* Get the (signed) value from the instruction.  */
1923               addend = value & howto->src_mask;
1924               if (addend & ((howto->src_mask + 1) >> 1))
1925                 {
1926                   bfd_signed_vma mask;
1927
1928                   mask = -1;
1929                   mask &= ~ howto->src_mask;
1930                   addend |= mask;
1931                 }
1932               msec = sec;
1933               addend =
1934                 _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend)
1935                 - relocation;
1936               addend += msec->output_section->vma + msec->output_offset;
1937               value = (value & ~ howto->dst_mask) | (addend & howto->dst_mask);
1938               bfd_put_32 (input_bfd, value, contents + rel->r_offset);
1939             }
1940 #else
1941           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
1942 #endif
1943         }
1944       else
1945         {
1946           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1947
1948           while (   h->root.type == bfd_link_hash_indirect
1949                  || h->root.type == bfd_link_hash_warning)
1950             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1951
1952           if (   h->root.type == bfd_link_hash_defined
1953               || h->root.type == bfd_link_hash_defweak)
1954             {
1955               int relocation_needed = 1;
1956
1957               sec = h->root.u.def.section;
1958
1959               /* In these cases, we don't need the relocation value.
1960                  We check specially because in some obscure cases
1961                  sec->output_section will be NULL.  */
1962               switch (r_type)
1963                 {
1964                 case R_ARM_PC24:
1965                 case R_ARM_ABS32:
1966                 case R_ARM_THM_PC22:
1967                   if (info->shared
1968                       && (
1969                   (!info->symbolic && h->dynindx != -1)
1970                           || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
1971                           )
1972                       && ((input_section->flags & SEC_ALLOC) != 0
1973                           /* DWARF will emit R_ARM_ABS32 relocations in its
1974                              sections against symbols defined externally
1975                              in shared libraries.  We can't do anything
1976                              with them here.  */
1977                           || ((input_section->flags & SEC_DEBUGGING) != 0
1978                               && (h->elf_link_hash_flags
1979                                   & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
1980                       )
1981                     relocation_needed = 0;
1982                   break;
1983
1984                 case R_ARM_GOTPC:
1985                   relocation_needed = 0;
1986                   break;
1987
1988                 case R_ARM_GOT32:
1989                   if (elf_hash_table(info)->dynamic_sections_created
1990                       && (!info->shared
1991                           || (!info->symbolic && h->dynindx != -1)
1992                           || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
1993                           )
1994                       )
1995                     relocation_needed = 0;
1996                   break;
1997
1998                 case R_ARM_PLT32:
1999                   if (h->plt.offset != (bfd_vma)-1)
2000                     relocation_needed = 0;
2001                   break;
2002
2003                 default:
2004                   if (sec->output_section == NULL)
2005                     {
2006                       (*_bfd_error_handler)
2007                         (_("%s: warning: unresolvable relocation %d against symbol `%s' from %s section"),
2008                          bfd_archive_filename (input_bfd),
2009                          r_type,
2010                          h->root.root.string,
2011                          bfd_get_section_name (input_bfd, input_section));
2012                       relocation_needed = 0;
2013                     }
2014                 }
2015
2016               if (relocation_needed)
2017                 relocation = h->root.u.def.value
2018                   + sec->output_section->vma
2019                   + sec->output_offset;
2020               else
2021                 relocation = 0;
2022             }
2023           else if (h->root.type == bfd_link_hash_undefweak)
2024             relocation = 0;
2025           else if (info->shared && !info->symbolic
2026                    && !info->no_undefined
2027                    && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
2028             relocation = 0;
2029           else
2030             {
2031               if (!((*info->callbacks->undefined_symbol)
2032                     (info, h->root.root.string, input_bfd,
2033                      input_section, rel->r_offset,
2034                      (!info->shared || info->no_undefined
2035                       || ELF_ST_VISIBILITY (h->other)))))
2036                 return false;
2037               relocation = 0;
2038             }
2039         }
2040
2041       if (h != NULL)
2042         name = h->root.root.string;
2043       else
2044         {
2045           name = (bfd_elf_string_from_elf_section
2046                   (input_bfd, symtab_hdr->sh_link, sym->st_name));
2047           if (name == NULL || *name == '\0')
2048             name = bfd_section_name (input_bfd, sec);
2049         }
2050
2051       r = elf32_arm_final_link_relocate (howto, input_bfd, output_bfd,
2052                                          input_section, contents, rel,
2053                                          relocation, info, sec, name,
2054                                          (h ? ELF_ST_TYPE (h->type) :
2055                                           ELF_ST_TYPE (sym->st_info)), h);
2056
2057       if (r != bfd_reloc_ok)
2058         {
2059           const char * msg = (const char *) 0;
2060
2061           switch (r)
2062             {
2063             case bfd_reloc_overflow:
2064               /* If the overflowing reloc was to an undefined symbol,
2065                  we have already printed one error message and there
2066                  is no point complaining again.  */
2067               if ((! h ||
2068                    h->root.type != bfd_link_hash_undefined)
2069                   && (!((*info->callbacks->reloc_overflow)
2070                         (info, name, howto->name, (bfd_vma) 0,
2071                          input_bfd, input_section, rel->r_offset))))
2072                   return false;
2073               break;
2074
2075             case bfd_reloc_undefined:
2076               if (!((*info->callbacks->undefined_symbol)
2077                     (info, name, input_bfd, input_section,
2078                      rel->r_offset, true)))
2079                 return false;
2080               break;
2081
2082             case bfd_reloc_outofrange:
2083               msg = _("internal error: out of range error");
2084               goto common_error;
2085
2086             case bfd_reloc_notsupported:
2087               msg = _("internal error: unsupported relocation error");
2088               goto common_error;
2089
2090             case bfd_reloc_dangerous:
2091               msg = _("internal error: dangerous error");
2092               goto common_error;
2093
2094             default:
2095               msg = _("internal error: unknown error");
2096               /* fall through */
2097
2098             common_error:
2099               if (!((*info->callbacks->warning)
2100                     (info, msg, name, input_bfd, input_section,
2101                      rel->r_offset)))
2102                 return false;
2103               break;
2104             }
2105         }
2106     }
2107
2108   return true;
2109 }
2110
2111 /* Function to keep ARM specific flags in the ELF header.  */
2112 static boolean
2113 elf32_arm_set_private_flags (abfd, flags)
2114      bfd *abfd;
2115      flagword flags;
2116 {
2117   if (elf_flags_init (abfd)
2118       && elf_elfheader (abfd)->e_flags != flags)
2119     {
2120       if (EF_ARM_EABI_VERSION (flags) == EF_ARM_EABI_UNKNOWN)
2121         {
2122           if (flags & EF_ARM_INTERWORK)
2123             (*_bfd_error_handler) (_("\
2124 Warning: Not setting interworking flag of %s since it has already been specified as non-interworking"),
2125                                    bfd_archive_filename (abfd));
2126           else
2127             _bfd_error_handler (_("\
2128 Warning: Clearing the interworking flag of %s due to outside request"),
2129                                 bfd_archive_filename (abfd));
2130         }
2131     }
2132   else
2133     {
2134       elf_elfheader (abfd)->e_flags = flags;
2135       elf_flags_init (abfd) = true;
2136     }
2137
2138   return true;
2139 }
2140
2141 /* Copy backend specific data from one object module to another.  */
2142
2143 static boolean
2144 elf32_arm_copy_private_bfd_data (ibfd, obfd)
2145      bfd *ibfd;
2146      bfd *obfd;
2147 {
2148   flagword in_flags;
2149   flagword out_flags;
2150
2151   if (   bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2152       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2153     return true;
2154
2155   in_flags  = elf_elfheader (ibfd)->e_flags;
2156   out_flags = elf_elfheader (obfd)->e_flags;
2157
2158   if (elf_flags_init (obfd)
2159       && EF_ARM_EABI_VERSION (out_flags) == EF_ARM_EABI_UNKNOWN
2160       && in_flags != out_flags)
2161     {
2162       /* Cannot mix APCS26 and APCS32 code.  */
2163       if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
2164         return false;
2165
2166       /* Cannot mix float APCS and non-float APCS code.  */
2167       if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
2168         return false;
2169
2170       /* If the src and dest have different interworking flags
2171          then turn off the interworking bit.  */
2172       if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
2173         {
2174           if (out_flags & EF_ARM_INTERWORK)
2175             _bfd_error_handler (_("\
2176 Warning: Clearing the interworking flag of %s because non-interworking code in %s has been linked with it"),
2177                                 bfd_get_filename (obfd),
2178                                 bfd_archive_filename (ibfd));
2179
2180           in_flags &= ~EF_ARM_INTERWORK;
2181         }
2182
2183       /* Likewise for PIC, though don't warn for this case.  */
2184       if ((in_flags & EF_ARM_PIC) != (out_flags & EF_ARM_PIC))
2185         in_flags &= ~EF_ARM_PIC;
2186     }
2187
2188   elf_elfheader (obfd)->e_flags = in_flags;
2189   elf_flags_init (obfd) = true;
2190
2191   return true;
2192 }
2193
2194 /* Merge backend specific data from an object file to the output
2195    object file when linking.  */
2196
2197 static boolean
2198 elf32_arm_merge_private_bfd_data (ibfd, obfd)
2199      bfd * ibfd;
2200      bfd * obfd;
2201 {
2202   flagword out_flags;
2203   flagword in_flags;
2204   boolean flags_compatible = true;
2205   boolean null_input_bfd = true;
2206   asection *sec;
2207
2208   /* Check if we have the same endianess.  */
2209   if (_bfd_generic_verify_endian_match (ibfd, obfd) == false)
2210     return false;
2211
2212   if (   bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2213       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2214     return true;
2215
2216   /* The input BFD must have had its flags initialised.  */
2217   /* The following seems bogus to me -- The flags are initialized in
2218      the assembler but I don't think an elf_flags_init field is
2219      written into the object.  */
2220   /* BFD_ASSERT (elf_flags_init (ibfd)); */
2221
2222   in_flags  = elf_elfheader (ibfd)->e_flags;
2223   out_flags = elf_elfheader (obfd)->e_flags;
2224
2225   if (!elf_flags_init (obfd))
2226     {
2227       /* If the input is the default architecture and had the default
2228          flags then do not bother setting the flags for the output
2229          architecture, instead allow future merges to do this.  If no
2230          future merges ever set these flags then they will retain their
2231          uninitialised values, which surprise surprise, correspond
2232          to the default values.  */
2233       if (bfd_get_arch_info (ibfd)->the_default
2234           && elf_elfheader (ibfd)->e_flags == 0)
2235         return true;
2236
2237       elf_flags_init (obfd) = true;
2238       elf_elfheader (obfd)->e_flags = in_flags;
2239
2240       if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
2241           && bfd_get_arch_info (obfd)->the_default)
2242         return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
2243
2244       return true;
2245     }
2246
2247   /* Identical flags must be compatible.  */
2248   if (in_flags == out_flags)
2249     return true;
2250
2251   /* Check to see if the input BFD actually contains any sections.
2252      If not, its flags may not have been initialised either, but it cannot
2253      actually cause any incompatibility.  */
2254   for (sec = ibfd->sections; sec != NULL; sec = sec->next)
2255     {
2256       /* Ignore synthetic glue sections.  */
2257       if (strcmp (sec->name, ".glue_7")
2258           && strcmp (sec->name, ".glue_7t"))
2259         {
2260           null_input_bfd = false;
2261           break;
2262         }
2263     }
2264   if (null_input_bfd)
2265     return true;
2266
2267   /* Complain about various flag mismatches.  */
2268   if (EF_ARM_EABI_VERSION (in_flags) != EF_ARM_EABI_VERSION (out_flags))
2269     {
2270       _bfd_error_handler (_("\
2271 ERROR: %s is compiled for EABI version %d, whereas %s is compiled for version %d"),
2272                           bfd_archive_filename (ibfd),
2273                           (in_flags & EF_ARM_EABIMASK) >> 24,
2274                           bfd_get_filename (obfd),
2275                           (out_flags & EF_ARM_EABIMASK) >> 24);
2276       return false;
2277     }
2278
2279   /* Not sure what needs to be checked for EABI versions >= 1.  */
2280   if (EF_ARM_EABI_VERSION (in_flags) == EF_ARM_EABI_UNKNOWN)
2281     {
2282       if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
2283         {
2284           _bfd_error_handler (_("\
2285 ERROR: %s is compiled for APCS-%d, whereas target %s uses APCS-%d"),
2286                               bfd_archive_filename (ibfd),
2287                               in_flags & EF_ARM_APCS_26 ? 26 : 32,
2288                               bfd_get_filename (obfd),
2289                               out_flags & EF_ARM_APCS_26 ? 26 : 32);
2290           flags_compatible = false;
2291         }
2292
2293       if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
2294         {
2295           if (in_flags & EF_ARM_APCS_FLOAT)
2296             _bfd_error_handler (_("\
2297 ERROR: %s passes floats in float registers, whereas %s passes them in integer registers"),
2298                                 bfd_archive_filename (ibfd),
2299                                 bfd_get_filename (obfd));
2300           else
2301             _bfd_error_handler (_("\
2302 ERROR: %s passes floats in integer registers, whereas %s passes them in float registers"),
2303                                 bfd_archive_filename (ibfd),
2304                                 bfd_get_filename (obfd));
2305
2306           flags_compatible = false;
2307         }
2308
2309       if ((in_flags & EF_ARM_VFP_FLOAT) != (out_flags & EF_ARM_VFP_FLOAT))
2310         {
2311           if (in_flags & EF_ARM_VFP_FLOAT)
2312             _bfd_error_handler (_("\
2313 ERROR: %s uses VFP instructions, whereas %s uses FPA instructions"),
2314                                 bfd_archive_filename (ibfd),
2315                                 bfd_get_filename (obfd));
2316           else
2317             _bfd_error_handler (_("\
2318 ERROR: %s uses FPA instructions, whereas %s uses VFP instructions"),
2319                                 bfd_archive_filename (ibfd),
2320                                 bfd_get_filename (obfd));
2321
2322           flags_compatible = false;
2323         }
2324
2325 #ifdef EF_ARM_SOFT_FLOAT
2326       if ((in_flags & EF_ARM_SOFT_FLOAT) != (out_flags & EF_ARM_SOFT_FLOAT))
2327         {
2328           /* We can allow interworking between code that is VFP format
2329              layout, and uses either soft float or integer regs for
2330              passing floating point arguments and results.  We already
2331              know that the APCS_FLOAT flags match; similarly for VFP
2332              flags.  */
2333           if ((in_flags & EF_ARM_APCS_FLOAT) != 0
2334               || (in_flags & EF_ARM_VFP_FLOAT) == 0)
2335             {
2336               if (in_flags & EF_ARM_SOFT_FLOAT)
2337                 _bfd_error_handler (_("\
2338 ERROR: %s uses software FP, whereas %s uses hardware FP"),
2339                                     bfd_archive_filename (ibfd),
2340                                     bfd_get_filename (obfd));
2341               else
2342                 _bfd_error_handler (_("\
2343 ERROR: %s uses hardware FP, whereas %s uses software FP"),
2344                                     bfd_archive_filename (ibfd),
2345                                     bfd_get_filename (obfd));
2346
2347               flags_compatible = false;
2348             }
2349         }
2350 #endif
2351
2352       /* Interworking mismatch is only a warning.  */
2353       if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
2354         {
2355           if (in_flags & EF_ARM_INTERWORK)
2356             {
2357               _bfd_error_handler (_("\
2358 Warning: %s supports interworking, whereas %s does not"),
2359                                   bfd_archive_filename (ibfd),
2360                                   bfd_get_filename (obfd));
2361             }
2362           else
2363             {
2364               _bfd_error_handler (_("\
2365 Warning: %s does not support interworking, whereas %s does"),
2366                                   bfd_archive_filename (ibfd),
2367                                   bfd_get_filename (obfd));
2368             }
2369         }
2370     }
2371
2372   return flags_compatible;
2373 }
2374
2375 /* Display the flags field.  */
2376
2377 static boolean
2378 elf32_arm_print_private_bfd_data (abfd, ptr)
2379      bfd *abfd;
2380      PTR ptr;
2381 {
2382   FILE * file = (FILE *) ptr;
2383   unsigned long flags;
2384
2385   BFD_ASSERT (abfd != NULL && ptr != NULL);
2386
2387   /* Print normal ELF private data.  */
2388   _bfd_elf_print_private_bfd_data (abfd, ptr);
2389
2390   flags = elf_elfheader (abfd)->e_flags;
2391   /* Ignore init flag - it may not be set, despite the flags field
2392      containing valid data.  */
2393
2394   /* xgettext:c-format */
2395   fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
2396
2397   switch (EF_ARM_EABI_VERSION (flags))
2398     {
2399     case EF_ARM_EABI_UNKNOWN:
2400       /* The following flag bits are GNU extenstions and not part of the
2401          official ARM ELF extended ABI.  Hence they are only decoded if
2402          the EABI version is not set.  */
2403       if (flags & EF_ARM_INTERWORK)
2404         fprintf (file, _(" [interworking enabled]"));
2405
2406       if (flags & EF_ARM_APCS_26)
2407         fprintf (file, " [APCS-26]");
2408       else
2409         fprintf (file, " [APCS-32]");
2410
2411       if (flags & EF_ARM_VFP_FLOAT)
2412         fprintf (file, _(" [VFP float format]"));
2413       else
2414         fprintf (file, _(" [FPA float format]"));
2415
2416       if (flags & EF_ARM_APCS_FLOAT)
2417         fprintf (file, _(" [floats passed in float registers]"));
2418
2419       if (flags & EF_ARM_PIC)
2420         fprintf (file, _(" [position independent]"));
2421
2422       if (flags & EF_ARM_NEW_ABI)
2423         fprintf (file, _(" [new ABI]"));
2424
2425       if (flags & EF_ARM_OLD_ABI)
2426         fprintf (file, _(" [old ABI]"));
2427
2428       if (flags & EF_ARM_SOFT_FLOAT)
2429         fprintf (file, _(" [software FP]"));
2430
2431       flags &= ~(EF_ARM_INTERWORK | EF_ARM_APCS_26 | EF_ARM_APCS_FLOAT
2432                  | EF_ARM_PIC | EF_ARM_NEW_ABI | EF_ARM_OLD_ABI
2433                  | EF_ARM_SOFT_FLOAT | EF_ARM_VFP_FLOAT);
2434       break;
2435
2436     case EF_ARM_EABI_VER1:
2437       fprintf (file, _(" [Version1 EABI]"));
2438
2439       if (flags & EF_ARM_SYMSARESORTED)
2440         fprintf (file, _(" [sorted symbol table]"));
2441       else
2442         fprintf (file, _(" [unsorted symbol table]"));
2443
2444       flags &= ~ EF_ARM_SYMSARESORTED;
2445       break;
2446
2447     case EF_ARM_EABI_VER2:
2448       fprintf (file, _(" [Version2 EABI]"));
2449
2450       if (flags & EF_ARM_SYMSARESORTED)
2451         fprintf (file, _(" [sorted symbol table]"));
2452       else
2453         fprintf (file, _(" [unsorted symbol table]"));
2454
2455       if (flags & EF_ARM_DYNSYMSUSESEGIDX)
2456         fprintf (file, _(" [dynamic symbols use segment index]"));
2457
2458       if (flags & EF_ARM_MAPSYMSFIRST)
2459         fprintf (file, _(" [mapping symbols precede others]"));
2460
2461       flags &= ~(EF_ARM_SYMSARESORTED | EF_ARM_DYNSYMSUSESEGIDX
2462                  | EF_ARM_MAPSYMSFIRST);
2463       break;
2464
2465     default:
2466       fprintf (file, _(" <EABI version unrecognised>"));
2467       break;
2468     }
2469
2470   flags &= ~ EF_ARM_EABIMASK;
2471
2472   if (flags & EF_ARM_RELEXEC)
2473     fprintf (file, _(" [relocatable executable]"));
2474
2475   if (flags & EF_ARM_HASENTRY)
2476     fprintf (file, _(" [has entry point]"));
2477
2478   flags &= ~ (EF_ARM_RELEXEC | EF_ARM_HASENTRY);
2479
2480   if (flags)
2481     fprintf (file, _("<Unrecognised flag bits set>"));
2482
2483   fputc ('\n', file);
2484
2485   return true;
2486 }
2487
2488 static int
2489 elf32_arm_get_symbol_type (elf_sym, type)
2490      Elf_Internal_Sym * elf_sym;
2491      int type;
2492 {
2493   switch (ELF_ST_TYPE (elf_sym->st_info))
2494     {
2495     case STT_ARM_TFUNC:
2496       return ELF_ST_TYPE (elf_sym->st_info);
2497
2498     case STT_ARM_16BIT:
2499       /* If the symbol is not an object, return the STT_ARM_16BIT flag.
2500          This allows us to distinguish between data used by Thumb instructions
2501          and non-data (which is probably code) inside Thumb regions of an
2502          executable.  */
2503       if (type != STT_OBJECT)
2504         return ELF_ST_TYPE (elf_sym->st_info);
2505       break;
2506
2507     default:
2508       break;
2509     }
2510
2511   return type;
2512 }
2513
2514 static asection *
2515 elf32_arm_gc_mark_hook (abfd, info, rel, h, sym)
2516        bfd *abfd;
2517        struct bfd_link_info *info ATTRIBUTE_UNUSED;
2518        Elf_Internal_Rela *rel;
2519        struct elf_link_hash_entry *h;
2520        Elf_Internal_Sym *sym;
2521 {
2522   if (h != NULL)
2523     {
2524       switch (ELF32_R_TYPE (rel->r_info))
2525       {
2526       case R_ARM_GNU_VTINHERIT:
2527       case R_ARM_GNU_VTENTRY:
2528         break;
2529
2530       default:
2531         switch (h->root.type)
2532           {
2533           case bfd_link_hash_defined:
2534           case bfd_link_hash_defweak:
2535             return h->root.u.def.section;
2536
2537           case bfd_link_hash_common:
2538             return h->root.u.c.p->section;
2539
2540           default:
2541             break;
2542           }
2543        }
2544      }
2545    else
2546      {
2547        return bfd_section_from_elf_index (abfd, sym->st_shndx);
2548      }
2549
2550   return NULL;
2551 }
2552
2553 /* Update the got entry reference counts for the section being removed.  */
2554
2555 static boolean
2556 elf32_arm_gc_sweep_hook (abfd, info, sec, relocs)
2557      bfd *abfd ATTRIBUTE_UNUSED;
2558      struct bfd_link_info *info ATTRIBUTE_UNUSED;
2559      asection *sec ATTRIBUTE_UNUSED;
2560      const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
2561 {
2562   /* We don't support garbage collection of GOT and PLT relocs yet.  */
2563   return true;
2564 }
2565
2566 /* Look through the relocs for a section during the first phase.  */
2567
2568 static boolean
2569 elf32_arm_check_relocs (abfd, info, sec, relocs)
2570      bfd *                      abfd;
2571      struct bfd_link_info *     info;
2572      asection *                 sec;
2573      const Elf_Internal_Rela *  relocs;
2574 {
2575   Elf_Internal_Shdr *           symtab_hdr;
2576   struct elf_link_hash_entry ** sym_hashes;
2577   struct elf_link_hash_entry ** sym_hashes_end;
2578   const Elf_Internal_Rela *     rel;
2579   const Elf_Internal_Rela *     rel_end;
2580   bfd *                         dynobj;
2581   asection * sgot, *srelgot, *sreloc;
2582   bfd_vma * local_got_offsets;
2583
2584   if (info->relocateable)
2585     return true;
2586
2587   sgot = srelgot = sreloc = NULL;
2588
2589   dynobj = elf_hash_table (info)->dynobj;
2590   local_got_offsets = elf_local_got_offsets (abfd);
2591
2592   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2593   sym_hashes = elf_sym_hashes (abfd);
2594   sym_hashes_end = sym_hashes
2595     + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
2596
2597   if (!elf_bad_symtab (abfd))
2598     sym_hashes_end -= symtab_hdr->sh_info;
2599
2600   rel_end = relocs + sec->reloc_count;
2601   for (rel = relocs; rel < rel_end; rel++)
2602     {
2603       struct elf_link_hash_entry *h;
2604       unsigned long r_symndx;
2605
2606       r_symndx = ELF32_R_SYM (rel->r_info);
2607       if (r_symndx < symtab_hdr->sh_info)
2608         h = NULL;
2609       else
2610         h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2611
2612       /* Some relocs require a global offset table.  */
2613       if (dynobj == NULL)
2614         {
2615           switch (ELF32_R_TYPE (rel->r_info))
2616             {
2617             case R_ARM_GOT32:
2618             case R_ARM_GOTOFF:
2619             case R_ARM_GOTPC:
2620               elf_hash_table (info)->dynobj = dynobj = abfd;
2621               if (! _bfd_elf_create_got_section (dynobj, info))
2622                 return false;
2623               break;
2624
2625             default:
2626               break;
2627             }
2628         }
2629
2630       switch (ELF32_R_TYPE (rel->r_info))
2631         {
2632           case R_ARM_GOT32:
2633             /* This symbol requires a global offset table entry.  */
2634             if (sgot == NULL)
2635               {
2636                 sgot = bfd_get_section_by_name (dynobj, ".got");
2637                 BFD_ASSERT (sgot != NULL);
2638               }
2639
2640             /* Get the got relocation section if necessary.  */
2641             if (srelgot == NULL
2642                 && (h != NULL || info->shared))
2643               {
2644                 srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
2645
2646                 /* If no got relocation section, make one and initialize.  */
2647                 if (srelgot == NULL)
2648                   {
2649                     srelgot = bfd_make_section (dynobj, ".rel.got");
2650                     if (srelgot == NULL
2651                         || ! bfd_set_section_flags (dynobj, srelgot,
2652                                                     (SEC_ALLOC
2653                                                      | SEC_LOAD
2654                                                      | SEC_HAS_CONTENTS
2655                                                      | SEC_IN_MEMORY
2656                                                      | SEC_LINKER_CREATED
2657                                                      | SEC_READONLY))
2658                         || ! bfd_set_section_alignment (dynobj, srelgot, 2))
2659                       return false;
2660                   }
2661               }
2662
2663             if (h != NULL)
2664               {
2665                 if (h->got.offset != (bfd_vma) -1)
2666                   /* We have already allocated space in the .got.  */
2667                   break;
2668
2669                 h->got.offset = sgot->_raw_size;
2670
2671                 /* Make sure this symbol is output as a dynamic symbol.  */
2672                 if (h->dynindx == -1)
2673                   if (! bfd_elf32_link_record_dynamic_symbol (info, h))
2674                     return false;
2675
2676                 srelgot->_raw_size += sizeof (Elf32_External_Rel);
2677               }
2678             else
2679               {
2680                 /* This is a global offset table entry for a local
2681                    symbol.  */
2682                 if (local_got_offsets == NULL)
2683                   {
2684                     bfd_size_type size;
2685                     unsigned int i;
2686
2687                     size = symtab_hdr->sh_info;
2688                     size *= sizeof (bfd_vma);
2689                     local_got_offsets = (bfd_vma *) bfd_alloc (abfd, size);
2690                     if (local_got_offsets == NULL)
2691                       return false;
2692                     elf_local_got_offsets (abfd) = local_got_offsets;
2693                     for (i = 0; i < symtab_hdr->sh_info; i++)
2694                       local_got_offsets[i] = (bfd_vma) -1;
2695                   }
2696
2697                 if (local_got_offsets[r_symndx] != (bfd_vma) -1)
2698                   /* We have already allocated space in the .got.  */
2699                   break;
2700
2701                 local_got_offsets[r_symndx] = sgot->_raw_size;
2702
2703                 if (info->shared)
2704                   /* If we are generating a shared object, we need to
2705                      output a R_ARM_RELATIVE reloc so that the dynamic
2706                      linker can adjust this GOT entry.  */
2707                   srelgot->_raw_size += sizeof (Elf32_External_Rel);
2708               }
2709
2710             sgot->_raw_size += 4;
2711             break;
2712
2713           case R_ARM_PLT32:
2714             /* This symbol requires a procedure linkage table entry.  We
2715                actually build the entry in adjust_dynamic_symbol,
2716                because this might be a case of linking PIC code which is
2717                never referenced by a dynamic object, in which case we
2718                don't need to generate a procedure linkage table entry
2719                after all.  */
2720
2721             /* If this is a local symbol, we resolve it directly without
2722                creating a procedure linkage table entry.  */
2723             if (h == NULL)
2724               continue;
2725
2726             h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2727             break;
2728
2729           case R_ARM_ABS32:
2730           case R_ARM_REL32:
2731           case R_ARM_PC24:
2732             /* If we are creating a shared library, and this is a reloc
2733                against a global symbol, or a non PC relative reloc
2734                against a local symbol, then we need to copy the reloc
2735                into the shared library.  However, if we are linking with
2736                -Bsymbolic, we do not need to copy a reloc against a
2737                global symbol which is defined in an object we are
2738                including in the link (i.e., DEF_REGULAR is set).  At
2739                this point we have not seen all the input files, so it is
2740                possible that DEF_REGULAR is not set now but will be set
2741                later (it is never cleared).  We account for that
2742                possibility below by storing information in the
2743                pcrel_relocs_copied field of the hash table entry.  */
2744             if (info->shared
2745               && (ELF32_R_TYPE (rel->r_info) != R_ARM_PC24
2746                 || (h != NULL
2747                   && (! info->symbolic
2748                     || (h->elf_link_hash_flags
2749                       & ELF_LINK_HASH_DEF_REGULAR) == 0))))
2750               {
2751                 /* When creating a shared object, we must copy these
2752                    reloc types into the output file.  We create a reloc
2753                    section in dynobj and make room for this reloc.  */
2754                 if (sreloc == NULL)
2755                   {
2756                     const char * name;
2757
2758                     name = (bfd_elf_string_from_elf_section
2759                             (abfd,
2760                              elf_elfheader (abfd)->e_shstrndx,
2761                              elf_section_data (sec)->rel_hdr.sh_name));
2762                     if (name == NULL)
2763                       return false;
2764
2765                     BFD_ASSERT (strncmp (name, ".rel", 4) == 0
2766                                 && strcmp (bfd_get_section_name (abfd, sec),
2767                                            name + 4) == 0);
2768
2769                     sreloc = bfd_get_section_by_name (dynobj, name);
2770                     if (sreloc == NULL)
2771                       {
2772                         flagword flags;
2773
2774                         sreloc = bfd_make_section (dynobj, name);
2775                         flags = (SEC_HAS_CONTENTS | SEC_READONLY
2776                                  | SEC_IN_MEMORY | SEC_LINKER_CREATED);
2777                         if ((sec->flags & SEC_ALLOC) != 0)
2778                           flags |= SEC_ALLOC | SEC_LOAD;
2779                         if (sreloc == NULL
2780                             || ! bfd_set_section_flags (dynobj, sreloc, flags)
2781                             || ! bfd_set_section_alignment (dynobj, sreloc, 2))
2782                           return false;
2783                       }
2784                   if (sec->flags & SEC_READONLY)
2785                     info->flags |= DF_TEXTREL;
2786                   }
2787
2788                 sreloc->_raw_size += sizeof (Elf32_External_Rel);
2789                 /* If we are linking with -Bsymbolic, and this is a
2790                    global symbol, we count the number of PC relative
2791                    relocations we have entered for this symbol, so that
2792                    we can discard them again if the symbol is later
2793                    defined by a regular object.  Note that this function
2794                    is only called if we are using an elf_i386 linker
2795                    hash table, which means that h is really a pointer to
2796                    an elf_i386_link_hash_entry.  */
2797                 if (h != NULL && info->symbolic
2798                     && ELF32_R_TYPE (rel->r_info) == R_ARM_PC24)
2799                   {
2800                     struct elf32_arm_link_hash_entry * eh;
2801                     struct elf32_arm_pcrel_relocs_copied * p;
2802
2803                     eh = (struct elf32_arm_link_hash_entry *) h;
2804
2805                     for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next)
2806                       if (p->section == sreloc)
2807                         break;
2808
2809                     if (p == NULL)
2810                       {
2811                         p = ((struct elf32_arm_pcrel_relocs_copied *)
2812                              bfd_alloc (dynobj, (bfd_size_type) sizeof * p));
2813                         if (p == NULL)
2814                           return false;
2815                         p->next = eh->pcrel_relocs_copied;
2816                         eh->pcrel_relocs_copied = p;
2817                         p->section = sreloc;
2818                         p->count = 0;
2819                       }
2820
2821                     ++p->count;
2822                   }
2823               }
2824             break;
2825
2826         /* This relocation describes the C++ object vtable hierarchy.
2827            Reconstruct it for later use during GC.  */
2828         case R_ARM_GNU_VTINHERIT:
2829           if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2830             return false;
2831           break;
2832
2833         /* This relocation describes which C++ vtable entries are actually
2834            used.  Record for later use during GC.  */
2835         case R_ARM_GNU_VTENTRY:
2836           if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_offset))
2837             return false;
2838           break;
2839         }
2840     }
2841
2842   return true;
2843 }
2844
2845 /* Find the nearest line to a particular section and offset, for error
2846    reporting.   This code is a duplicate of the code in elf.c, except
2847    that it also accepts STT_ARM_TFUNC as a symbol that names a function.  */
2848
2849 static boolean
2850 elf32_arm_find_nearest_line
2851   (abfd, section, symbols, offset, filename_ptr, functionname_ptr, line_ptr)
2852      bfd *          abfd;
2853      asection *     section;
2854      asymbol **     symbols;
2855      bfd_vma        offset;
2856      const char **  filename_ptr;
2857      const char **  functionname_ptr;
2858      unsigned int * line_ptr;
2859 {
2860   boolean      found;
2861   const char * filename;
2862   asymbol *    func;
2863   bfd_vma      low_func;
2864   asymbol **   p;
2865
2866   if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
2867                                      filename_ptr, functionname_ptr,
2868                                      line_ptr, 0,
2869                                      &elf_tdata (abfd)->dwarf2_find_line_info))
2870     return true;
2871
2872   if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
2873                                              &found, filename_ptr,
2874                                              functionname_ptr, line_ptr,
2875                                              &elf_tdata (abfd)->line_info))
2876     return false;
2877
2878   if (found)
2879     return true;
2880
2881   if (symbols == NULL)
2882     return false;
2883
2884   filename = NULL;
2885   func = NULL;
2886   low_func = 0;
2887
2888   for (p = symbols; *p != NULL; p++)
2889     {
2890       elf_symbol_type *q;
2891
2892       q = (elf_symbol_type *) *p;
2893
2894       if (bfd_get_section (&q->symbol) != section)
2895         continue;
2896
2897       switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
2898         {
2899         default:
2900           break;
2901         case STT_FILE:
2902           filename = bfd_asymbol_name (&q->symbol);
2903           break;
2904         case STT_NOTYPE:
2905         case STT_FUNC:
2906         case STT_ARM_TFUNC:
2907           if (q->symbol.section == section
2908               && q->symbol.value >= low_func
2909               && q->symbol.value <= offset)
2910             {
2911               func = (asymbol *) q;
2912               low_func = q->symbol.value;
2913             }
2914           break;
2915         }
2916     }
2917
2918   if (func == NULL)
2919     return false;
2920
2921   *filename_ptr = filename;
2922   *functionname_ptr = bfd_asymbol_name (func);
2923   *line_ptr = 0;
2924
2925   return true;
2926 }
2927
2928 /* Adjust a symbol defined by a dynamic object and referenced by a
2929    regular object.  The current definition is in some section of the
2930    dynamic object, but we're not including those sections.  We have to
2931    change the definition to something the rest of the link can
2932    understand.  */
2933
2934 static boolean
2935 elf32_arm_adjust_dynamic_symbol (info, h)
2936      struct bfd_link_info * info;
2937      struct elf_link_hash_entry * h;
2938 {
2939   bfd * dynobj;
2940   asection * s;
2941   unsigned int power_of_two;
2942
2943   dynobj = elf_hash_table (info)->dynobj;
2944
2945   /* Make sure we know what is going on here.  */
2946   BFD_ASSERT (dynobj != NULL
2947               && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
2948                   || h->weakdef != NULL
2949                   || ((h->elf_link_hash_flags
2950                        & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2951                       && (h->elf_link_hash_flags
2952                           & ELF_LINK_HASH_REF_REGULAR) != 0
2953                       && (h->elf_link_hash_flags
2954                           & ELF_LINK_HASH_DEF_REGULAR) == 0)));
2955
2956   /* If this is a function, put it in the procedure linkage table.  We
2957      will fill in the contents of the procedure linkage table later,
2958      when we know the address of the .got section.  */
2959   if (h->type == STT_FUNC
2960       || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
2961     {
2962       if (! info->shared
2963           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
2964           && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0)
2965         {
2966           /* This case can occur if we saw a PLT32 reloc in an input
2967              file, but the symbol was never referred to by a dynamic
2968              object.  In such a case, we don't actually need to build
2969              a procedure linkage table, and we can just do a PC32
2970              reloc instead.  */
2971           BFD_ASSERT ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0);
2972           return true;
2973         }
2974
2975       /* Make sure this symbol is output as a dynamic symbol.  */
2976       if (h->dynindx == -1)
2977         {
2978           if (! bfd_elf32_link_record_dynamic_symbol (info, h))
2979             return false;
2980         }
2981
2982       s = bfd_get_section_by_name (dynobj, ".plt");
2983       BFD_ASSERT (s != NULL);
2984
2985       /* If this is the first .plt entry, make room for the special
2986          first entry.  */
2987       if (s->_raw_size == 0)
2988         s->_raw_size += PLT_ENTRY_SIZE;
2989
2990       /* If this symbol is not defined in a regular file, and we are
2991          not generating a shared library, then set the symbol to this
2992          location in the .plt.  This is required to make function
2993          pointers compare as equal between the normal executable and
2994          the shared library.  */
2995       if (! info->shared
2996           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2997         {
2998           h->root.u.def.section = s;
2999           h->root.u.def.value = s->_raw_size;
3000         }
3001
3002       h->plt.offset = s->_raw_size;
3003
3004       /* Make room for this entry.  */
3005       s->_raw_size += PLT_ENTRY_SIZE;
3006
3007       /* We also need to make an entry in the .got.plt section, which
3008          will be placed in the .got section by the linker script.  */
3009       s = bfd_get_section_by_name (dynobj, ".got.plt");
3010       BFD_ASSERT (s != NULL);
3011       s->_raw_size += 4;
3012
3013       /* We also need to make an entry in the .rel.plt section.  */
3014
3015       s = bfd_get_section_by_name (dynobj, ".rel.plt");
3016       BFD_ASSERT (s != NULL);
3017       s->_raw_size += sizeof (Elf32_External_Rel);
3018
3019       return true;
3020     }
3021
3022   /* If this is a weak symbol, and there is a real definition, the
3023      processor independent code will have arranged for us to see the
3024      real definition first, and we can just use the same value.  */
3025   if (h->weakdef != NULL)
3026     {
3027       BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
3028                   || h->weakdef->root.type == bfd_link_hash_defweak);
3029       h->root.u.def.section = h->weakdef->root.u.def.section;
3030       h->root.u.def.value = h->weakdef->root.u.def.value;
3031       return true;
3032     }
3033
3034   /* This is a reference to a symbol defined by a dynamic object which
3035      is not a function.  */
3036
3037   /* If we are creating a shared library, we must presume that the
3038      only references to the symbol are via the global offset table.
3039      For such cases we need not do anything here; the relocations will
3040      be handled correctly by relocate_section.  */
3041   if (info->shared)
3042     return true;
3043
3044   /* We must allocate the symbol in our .dynbss section, which will
3045      become part of the .bss section of the executable.  There will be
3046      an entry for this symbol in the .dynsym section.  The dynamic
3047      object will contain position independent code, so all references
3048      from the dynamic object to this symbol will go through the global
3049      offset table.  The dynamic linker will use the .dynsym entry to
3050      determine the address it must put in the global offset table, so
3051      both the dynamic object and the regular object will refer to the
3052      same memory location for the variable.  */
3053   s = bfd_get_section_by_name (dynobj, ".dynbss");
3054   BFD_ASSERT (s != NULL);
3055
3056   /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
3057      copy the initial value out of the dynamic object and into the
3058      runtime process image.  We need to remember the offset into the
3059      .rel.bss section we are going to use.  */
3060   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
3061     {
3062       asection *srel;
3063
3064       srel = bfd_get_section_by_name (dynobj, ".rel.bss");
3065       BFD_ASSERT (srel != NULL);
3066       srel->_raw_size += sizeof (Elf32_External_Rel);
3067       h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
3068     }
3069
3070   /* We need to figure out the alignment required for this symbol.  I
3071      have no idea how ELF linkers handle this.  */
3072   power_of_two = bfd_log2 (h->size);
3073   if (power_of_two > 3)
3074     power_of_two = 3;
3075
3076   /* Apply the required alignment.  */
3077   s->_raw_size = BFD_ALIGN (s->_raw_size,
3078                             (bfd_size_type) (1 << power_of_two));
3079   if (power_of_two > bfd_get_section_alignment (dynobj, s))
3080     {
3081       if (! bfd_set_section_alignment (dynobj, s, power_of_two))
3082         return false;
3083     }
3084
3085   /* Define the symbol as being at this point in the section.  */
3086   h->root.u.def.section = s;
3087   h->root.u.def.value = s->_raw_size;
3088
3089   /* Increment the section size to make room for the symbol.  */
3090   s->_raw_size += h->size;
3091
3092   return true;
3093 }
3094
3095 /* Set the sizes of the dynamic sections.  */
3096
3097 static boolean
3098 elf32_arm_size_dynamic_sections (output_bfd, info)
3099      bfd * output_bfd ATTRIBUTE_UNUSED;
3100      struct bfd_link_info * info;
3101 {
3102   bfd * dynobj;
3103   asection * s;
3104   boolean plt;
3105   boolean relocs;
3106
3107   dynobj = elf_hash_table (info)->dynobj;
3108   BFD_ASSERT (dynobj != NULL);
3109
3110   if (elf_hash_table (info)->dynamic_sections_created)
3111     {
3112       /* Set the contents of the .interp section to the interpreter.  */
3113       if (! info->shared)
3114         {
3115           s = bfd_get_section_by_name (dynobj, ".interp");
3116           BFD_ASSERT (s != NULL);
3117           s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
3118           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3119         }
3120     }
3121   else
3122     {
3123       /* We may have created entries in the .rel.got section.
3124          However, if we are not creating the dynamic sections, we will
3125          not actually use these entries.  Reset the size of .rel.got,
3126          which will cause it to get stripped from the output file
3127          below.  */
3128       s = bfd_get_section_by_name (dynobj, ".rel.got");
3129       if (s != NULL)
3130         s->_raw_size = 0;
3131     }
3132
3133   /* If this is a -Bsymbolic shared link, then we need to discard all
3134      PC relative relocs against symbols defined in a regular object.
3135      We allocated space for them in the check_relocs routine, but we
3136      will not fill them in in the relocate_section routine.  */
3137   if (info->shared && info->symbolic)
3138     elf32_arm_link_hash_traverse (elf32_arm_hash_table (info),
3139                                   elf32_arm_discard_copies,
3140                                   (PTR) NULL);
3141
3142   /* The check_relocs and adjust_dynamic_symbol entry points have
3143      determined the sizes of the various dynamic sections.  Allocate
3144      memory for them.  */
3145   plt = false;
3146   relocs = false;
3147   for (s = dynobj->sections; s != NULL; s = s->next)
3148     {
3149       const char * name;
3150       boolean strip;
3151
3152       if ((s->flags & SEC_LINKER_CREATED) == 0)
3153         continue;
3154
3155       /* It's OK to base decisions on the section name, because none
3156          of the dynobj section names depend upon the input files.  */
3157       name = bfd_get_section_name (dynobj, s);
3158
3159       strip = false;
3160
3161       if (strcmp (name, ".plt") == 0)
3162         {
3163           if (s->_raw_size == 0)
3164             {
3165               /* Strip this section if we don't need it; see the
3166                  comment below.  */
3167               strip = true;
3168             }
3169           else
3170             {
3171               /* Remember whether there is a PLT.  */
3172               plt = true;
3173             }
3174         }
3175       else if (strncmp (name, ".rel", 4) == 0)
3176         {
3177           if (s->_raw_size == 0)
3178             {
3179               /* If we don't need this section, strip it from the
3180                  output file.  This is mostly to handle .rel.bss and
3181                  .rel.plt.  We must create both sections in
3182                  create_dynamic_sections, because they must be created
3183                  before the linker maps input sections to output
3184                  sections.  The linker does that before
3185                  adjust_dynamic_symbol is called, and it is that
3186                  function which decides whether anything needs to go
3187                  into these sections.  */
3188               strip = true;
3189             }
3190           else
3191             {
3192               /* Remember whether there are any reloc sections other
3193                  than .rel.plt.  */
3194               if (strcmp (name, ".rel.plt") != 0)
3195                 relocs = true;
3196
3197               /* We use the reloc_count field as a counter if we need
3198                  to copy relocs into the output file.  */
3199               s->reloc_count = 0;
3200             }
3201         }
3202       else if (strncmp (name, ".got", 4) != 0)
3203         {
3204           /* It's not one of our sections, so don't allocate space.  */
3205           continue;
3206         }
3207
3208       if (strip)
3209         {
3210           asection ** spp;
3211
3212           for (spp = &s->output_section->owner->sections;
3213                *spp != NULL;
3214                spp = &(*spp)->next)
3215             {
3216               if (*spp == s->output_section)
3217                 {
3218                   bfd_section_list_remove (s->output_section->owner, spp);
3219                   --s->output_section->owner->section_count;
3220                   break;
3221                 }
3222             }
3223           continue;
3224         }
3225
3226       /* Allocate memory for the section contents.  */
3227       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
3228       if (s->contents == NULL && s->_raw_size != 0)
3229         return false;
3230     }
3231
3232   if (elf_hash_table (info)->dynamic_sections_created)
3233     {
3234       /* Add some entries to the .dynamic section.  We fill in the
3235          values later, in elf32_arm_finish_dynamic_sections, but we
3236          must add the entries now so that we get the correct size for
3237          the .dynamic section.  The DT_DEBUG entry is filled in by the
3238          dynamic linker and used by the debugger.  */
3239 #define add_dynamic_entry(TAG, VAL) \
3240   bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
3241
3242       if (!info->shared)
3243         {
3244           if (!add_dynamic_entry (DT_DEBUG, 0))
3245             return false;
3246         }
3247
3248       if (plt)
3249         {
3250           if (   !add_dynamic_entry (DT_PLTGOT, 0)
3251               || !add_dynamic_entry (DT_PLTRELSZ, 0)
3252               || !add_dynamic_entry (DT_PLTREL, DT_REL)
3253               || !add_dynamic_entry (DT_JMPREL, 0))
3254             return false;
3255         }
3256
3257       if (relocs)
3258         {
3259           if (   !add_dynamic_entry (DT_REL, 0)
3260               || !add_dynamic_entry (DT_RELSZ, 0)
3261               || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel)))
3262             return false;
3263         }
3264
3265       if ((info->flags & DF_TEXTREL) != 0)
3266         {
3267           if (!add_dynamic_entry (DT_TEXTREL, 0))
3268             return false;
3269           info->flags |= DF_TEXTREL;
3270         }
3271     }
3272 #undef add_synamic_entry
3273
3274   return true;
3275 }
3276
3277 /* This function is called via elf32_arm_link_hash_traverse if we are
3278    creating a shared object with -Bsymbolic.  It discards the space
3279    allocated to copy PC relative relocs against symbols which are
3280    defined in regular objects.  We allocated space for them in the
3281    check_relocs routine, but we won't fill them in in the
3282    relocate_section routine.  */
3283
3284 static boolean
3285 elf32_arm_discard_copies (h, ignore)
3286      struct elf32_arm_link_hash_entry * h;
3287      PTR ignore ATTRIBUTE_UNUSED;
3288 {
3289   struct elf32_arm_pcrel_relocs_copied * s;
3290
3291   if (h->root.root.type == bfd_link_hash_warning)
3292     h = (struct elf32_arm_link_hash_entry *) h->root.root.u.i.link;
3293
3294   /* We only discard relocs for symbols defined in a regular object.  */
3295   if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
3296     return true;
3297
3298   for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
3299     s->section->_raw_size -= s->count * sizeof (Elf32_External_Rel);
3300
3301   return true;
3302 }
3303
3304 /* Finish up dynamic symbol handling.  We set the contents of various
3305    dynamic sections here.  */
3306
3307 static boolean
3308 elf32_arm_finish_dynamic_symbol (output_bfd, info, h, sym)
3309      bfd * output_bfd;
3310      struct bfd_link_info * info;
3311      struct elf_link_hash_entry * h;
3312      Elf_Internal_Sym * sym;
3313 {
3314   bfd * dynobj;
3315
3316   dynobj = elf_hash_table (info)->dynobj;
3317
3318   if (h->plt.offset != (bfd_vma) -1)
3319     {
3320       asection * splt;
3321       asection * sgot;
3322       asection * srel;
3323       bfd_vma plt_index;
3324       bfd_vma got_offset;
3325       Elf_Internal_Rel rel;
3326
3327       /* This symbol has an entry in the procedure linkage table.  Set
3328          it up.  */
3329
3330       BFD_ASSERT (h->dynindx != -1);
3331
3332       splt = bfd_get_section_by_name (dynobj, ".plt");
3333       sgot = bfd_get_section_by_name (dynobj, ".got.plt");
3334       srel = bfd_get_section_by_name (dynobj, ".rel.plt");
3335       BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
3336
3337       /* Get the index in the procedure linkage table which
3338          corresponds to this symbol.  This is the index of this symbol
3339          in all the symbols for which we are making plt entries.  The
3340          first entry in the procedure linkage table is reserved.  */
3341       plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
3342
3343       /* Get the offset into the .got table of the entry that
3344          corresponds to this function.  Each .got entry is 4 bytes.
3345          The first three are reserved.  */
3346       got_offset = (plt_index + 3) * 4;
3347
3348       /* Fill in the entry in the procedure linkage table.  */
3349       bfd_put_32 (output_bfd, elf32_arm_plt_entry[0],
3350                   splt->contents + h->plt.offset + 0);
3351       bfd_put_32 (output_bfd, elf32_arm_plt_entry[1],
3352                   splt->contents + h->plt.offset + 4);
3353       bfd_put_32 (output_bfd, elf32_arm_plt_entry[2],
3354                   splt->contents + h->plt.offset + 8);
3355       bfd_put_32 (output_bfd,
3356                       (sgot->output_section->vma
3357                        + sgot->output_offset
3358                        + got_offset
3359                        - splt->output_section->vma
3360                        - splt->output_offset
3361                        - h->plt.offset - 12),
3362                       splt->contents + h->plt.offset + 12);
3363
3364       /* Fill in the entry in the global offset table.  */
3365       bfd_put_32 (output_bfd,
3366                   (splt->output_section->vma
3367                    + splt->output_offset),
3368                   sgot->contents + got_offset);
3369
3370       /* Fill in the entry in the .rel.plt section.  */
3371       rel.r_offset = (sgot->output_section->vma
3372                       + sgot->output_offset
3373                       + got_offset);
3374       rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_JUMP_SLOT);
3375       bfd_elf32_swap_reloc_out (output_bfd, &rel,
3376                                 ((Elf32_External_Rel *) srel->contents
3377                                  + plt_index));
3378
3379       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
3380         {
3381           /* Mark the symbol as undefined, rather than as defined in
3382              the .plt section.  Leave the value alone.  */
3383           sym->st_shndx = SHN_UNDEF;
3384           /* If the symbol is weak, we do need to clear the value.
3385              Otherwise, the PLT entry would provide a definition for
3386              the symbol even if the symbol wasn't defined anywhere,
3387              and so the symbol would never be NULL.  */
3388           if ((h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR_NONWEAK)
3389               == 0)
3390             sym->st_value = 0;
3391         }
3392     }
3393
3394   if (h->got.offset != (bfd_vma) -1)
3395     {
3396       asection * sgot;
3397       asection * srel;
3398       Elf_Internal_Rel rel;
3399
3400       /* This symbol has an entry in the global offset table.  Set it
3401          up.  */
3402       sgot = bfd_get_section_by_name (dynobj, ".got");
3403       srel = bfd_get_section_by_name (dynobj, ".rel.got");
3404       BFD_ASSERT (sgot != NULL && srel != NULL);
3405
3406       rel.r_offset = (sgot->output_section->vma
3407                       + sgot->output_offset
3408                       + (h->got.offset &~ (bfd_vma) 1));
3409
3410       /* If this is a -Bsymbolic link, and the symbol is defined
3411          locally, we just want to emit a RELATIVE reloc.  The entry in
3412          the global offset table will already have been initialized in
3413          the relocate_section function.  */
3414       if (info->shared
3415           && (info->symbolic || h->dynindx == -1)
3416           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
3417         rel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
3418       else
3419         {
3420           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
3421           rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT);
3422         }
3423
3424       bfd_elf32_swap_reloc_out (output_bfd, &rel,
3425                                 ((Elf32_External_Rel *) srel->contents
3426                                  + srel->reloc_count));
3427       ++srel->reloc_count;
3428     }
3429
3430   if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
3431     {
3432       asection * s;
3433       Elf_Internal_Rel rel;
3434
3435       /* This symbol needs a copy reloc.  Set it up.  */
3436       BFD_ASSERT (h->dynindx != -1
3437                   && (h->root.type == bfd_link_hash_defined
3438                       || h->root.type == bfd_link_hash_defweak));
3439
3440       s = bfd_get_section_by_name (h->root.u.def.section->owner,
3441                                    ".rel.bss");
3442       BFD_ASSERT (s != NULL);
3443
3444       rel.r_offset = (h->root.u.def.value
3445                       + h->root.u.def.section->output_section->vma
3446                       + h->root.u.def.section->output_offset);
3447       rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_COPY);
3448       bfd_elf32_swap_reloc_out (output_bfd, &rel,
3449                                 ((Elf32_External_Rel *) s->contents
3450                                  + s->reloc_count));
3451       ++s->reloc_count;
3452     }
3453
3454   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
3455   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3456       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
3457     sym->st_shndx = SHN_ABS;
3458
3459   return true;
3460 }
3461
3462 /* Finish up the dynamic sections.  */
3463
3464 static boolean
3465 elf32_arm_finish_dynamic_sections (output_bfd, info)
3466      bfd * output_bfd;
3467      struct bfd_link_info * info;
3468 {
3469   bfd * dynobj;
3470   asection * sgot;
3471   asection * sdyn;
3472
3473   dynobj = elf_hash_table (info)->dynobj;
3474
3475   sgot = bfd_get_section_by_name (dynobj, ".got.plt");
3476   BFD_ASSERT (sgot != NULL);
3477   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3478
3479   if (elf_hash_table (info)->dynamic_sections_created)
3480     {
3481       asection *splt;
3482       Elf32_External_Dyn *dyncon, *dynconend;
3483
3484       splt = bfd_get_section_by_name (dynobj, ".plt");
3485       BFD_ASSERT (splt != NULL && sdyn != NULL);
3486
3487       dyncon = (Elf32_External_Dyn *) sdyn->contents;
3488       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
3489
3490       for (; dyncon < dynconend; dyncon++)
3491         {
3492           Elf_Internal_Dyn dyn;
3493           const char * name;
3494           asection * s;
3495
3496           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3497
3498           switch (dyn.d_tag)
3499             {
3500             default:
3501               break;
3502
3503             case DT_PLTGOT:
3504               name = ".got";
3505               goto get_vma;
3506             case DT_JMPREL:
3507               name = ".rel.plt";
3508             get_vma:
3509               s = bfd_get_section_by_name (output_bfd, name);
3510               BFD_ASSERT (s != NULL);
3511               dyn.d_un.d_ptr = s->vma;
3512               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3513               break;
3514
3515             case DT_PLTRELSZ:
3516               s = bfd_get_section_by_name (output_bfd, ".rel.plt");
3517               BFD_ASSERT (s != NULL);
3518               if (s->_cooked_size != 0)
3519                 dyn.d_un.d_val = s->_cooked_size;
3520               else
3521                 dyn.d_un.d_val = s->_raw_size;
3522               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3523               break;
3524
3525             case DT_RELSZ:
3526               /* My reading of the SVR4 ABI indicates that the
3527                  procedure linkage table relocs (DT_JMPREL) should be
3528                  included in the overall relocs (DT_REL).  This is
3529                  what Solaris does.  However, UnixWare can not handle
3530                  that case.  Therefore, we override the DT_RELSZ entry
3531                  here to make it not include the JMPREL relocs.  Since
3532                  the linker script arranges for .rel.plt to follow all
3533                  other relocation sections, we don't have to worry
3534                  about changing the DT_REL entry.  */
3535               s = bfd_get_section_by_name (output_bfd, ".rel.plt");
3536               if (s != NULL)
3537                 {
3538                   if (s->_cooked_size != 0)
3539                     dyn.d_un.d_val -= s->_cooked_size;
3540                   else
3541                     dyn.d_un.d_val -= s->_raw_size;
3542                 }
3543               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3544               break;
3545             }
3546         }
3547
3548       /* Fill in the first entry in the procedure linkage table.  */
3549       if (splt->_raw_size > 0)
3550         {
3551           bfd_put_32 (output_bfd, elf32_arm_plt0_entry[0], splt->contents +  0);
3552           bfd_put_32 (output_bfd, elf32_arm_plt0_entry[1], splt->contents +  4);
3553           bfd_put_32 (output_bfd, elf32_arm_plt0_entry[2], splt->contents +  8);
3554           bfd_put_32 (output_bfd, elf32_arm_plt0_entry[3], splt->contents + 12);
3555         }
3556
3557       /* UnixWare sets the entsize of .plt to 4, although that doesn't
3558          really seem like the right value.  */
3559       elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
3560     }
3561
3562   /* Fill in the first three entries in the global offset table.  */
3563   if (sgot->_raw_size > 0)
3564     {
3565       if (sdyn == NULL)
3566         bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
3567       else
3568         bfd_put_32 (output_bfd,
3569                     sdyn->output_section->vma + sdyn->output_offset,
3570                     sgot->contents);
3571       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
3572       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
3573     }
3574
3575   elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
3576
3577   return true;
3578 }
3579
3580 static void
3581 elf32_arm_post_process_headers (abfd, link_info)
3582      bfd * abfd;
3583      struct bfd_link_info * link_info ATTRIBUTE_UNUSED;
3584 {
3585   Elf_Internal_Ehdr * i_ehdrp;  /* ELF file header, internal form.  */
3586
3587   i_ehdrp = elf_elfheader (abfd);
3588
3589   i_ehdrp->e_ident[EI_OSABI]      = ARM_ELF_OS_ABI_VERSION;
3590   i_ehdrp->e_ident[EI_ABIVERSION] = ARM_ELF_ABI_VERSION;
3591 }
3592
3593 static enum elf_reloc_type_class
3594 elf32_arm_reloc_type_class (rela)
3595      const Elf_Internal_Rela *rela;
3596 {
3597   switch ((int) ELF32_R_TYPE (rela->r_info))
3598     {
3599     case R_ARM_RELATIVE:
3600       return reloc_class_relative;
3601     case R_ARM_JUMP_SLOT:
3602       return reloc_class_plt;
3603     case R_ARM_COPY:
3604       return reloc_class_copy;
3605     default:
3606       return reloc_class_normal;
3607     }
3608 }
3609
3610
3611 #define ELF_ARCH                        bfd_arch_arm
3612 #define ELF_MACHINE_CODE                EM_ARM
3613 #define ELF_MAXPAGESIZE                 0x8000
3614
3615 #define bfd_elf32_bfd_copy_private_bfd_data     elf32_arm_copy_private_bfd_data
3616 #define bfd_elf32_bfd_merge_private_bfd_data    elf32_arm_merge_private_bfd_data
3617 #define bfd_elf32_bfd_set_private_flags         elf32_arm_set_private_flags
3618 #define bfd_elf32_bfd_print_private_bfd_data    elf32_arm_print_private_bfd_data
3619 #define bfd_elf32_bfd_link_hash_table_create    elf32_arm_link_hash_table_create
3620 #define bfd_elf32_bfd_reloc_type_lookup         elf32_arm_reloc_type_lookup
3621 #define bfd_elf32_find_nearest_line             elf32_arm_find_nearest_line
3622
3623 #define elf_backend_get_symbol_type             elf32_arm_get_symbol_type
3624 #define elf_backend_gc_mark_hook                elf32_arm_gc_mark_hook
3625 #define elf_backend_gc_sweep_hook               elf32_arm_gc_sweep_hook
3626 #define elf_backend_check_relocs                elf32_arm_check_relocs
3627 #define elf_backend_relocate_section            elf32_arm_relocate_section
3628 #define elf_backend_adjust_dynamic_symbol       elf32_arm_adjust_dynamic_symbol
3629 #define elf_backend_create_dynamic_sections     _bfd_elf_create_dynamic_sections
3630 #define elf_backend_finish_dynamic_symbol       elf32_arm_finish_dynamic_symbol
3631 #define elf_backend_finish_dynamic_sections     elf32_arm_finish_dynamic_sections
3632 #define elf_backend_size_dynamic_sections       elf32_arm_size_dynamic_sections
3633 #define elf_backend_post_process_headers        elf32_arm_post_process_headers
3634 #define elf_backend_reloc_type_class            elf32_arm_reloc_type_class
3635
3636 #define elf_backend_can_gc_sections 1
3637 #define elf_backend_plt_readonly    1
3638 #define elf_backend_want_got_plt    1
3639 #define elf_backend_want_plt_sym    0
3640
3641 #define elf_backend_got_header_size     12
3642 #define elf_backend_plt_header_size     PLT_ENTRY_SIZE
3643
3644 #include "elf32-target.h"