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_alloc (abfd, 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       bfd_release (abfd, 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;
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       /* Note that sgot->output_offset is not involved in this
1564          calculation.  We always want the start of .got.  If we
1565          define _GLOBAL_OFFSET_TABLE in a different way, as is
1566          permitted by the ABI, we might have to change this
1567          calculation.  */
1568       value -= sgot->output_section->vma;
1569       return _bfd_final_link_relocate (howto, input_bfd, input_section,
1570                                        contents, rel->r_offset, value,
1571                                        (bfd_vma) 0);
1572
1573     case R_ARM_GOTPC:
1574       /* Use global offset table as symbol value.  */
1575       BFD_ASSERT (sgot != NULL);
1576
1577       if (sgot == NULL)
1578         return bfd_reloc_notsupported;
1579
1580       value = sgot->output_section->vma;
1581       return _bfd_final_link_relocate (howto, input_bfd, input_section,
1582                                        contents, rel->r_offset, value,
1583                                        (bfd_vma) 0);
1584
1585     case R_ARM_GOT32:
1586       /* Relocation is to the entry for this symbol in the
1587          global offset table.  */
1588       if (sgot == NULL)
1589         return bfd_reloc_notsupported;
1590
1591       if (h != NULL)
1592         {
1593           bfd_vma off;
1594
1595           off = h->got.offset;
1596           BFD_ASSERT (off != (bfd_vma) -1);
1597
1598           if (!elf_hash_table (info)->dynamic_sections_created ||
1599               (info->shared && (info->symbolic || h->dynindx == -1)
1600                && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1601             {
1602               /* This is actually a static link, or it is a -Bsymbolic link
1603                  and the symbol is defined locally.  We must initialize this
1604                  entry in the global offset table.  Since the offset must
1605                  always be a multiple of 4, we use the least significant bit
1606                  to record whether we have initialized it already.
1607
1608                  When doing a dynamic link, we create a .rel.got relocation
1609                  entry to initialize the value.  This is done in the
1610                  finish_dynamic_symbol routine.  */
1611               if ((off & 1) != 0)
1612                 off &= ~1;
1613               else
1614                 {
1615                   bfd_put_32 (output_bfd, value, sgot->contents + off);
1616                   h->got.offset |= 1;
1617                 }
1618             }
1619
1620           value = sgot->output_offset + off;
1621         }
1622       else
1623         {
1624           bfd_vma off;
1625
1626           BFD_ASSERT (local_got_offsets != NULL &&
1627                       local_got_offsets[r_symndx] != (bfd_vma) -1);
1628
1629           off = local_got_offsets[r_symndx];
1630
1631           /* The offset must always be a multiple of 4.  We use the
1632              least significant bit to record whether we have already
1633              generated the necessary reloc.  */
1634           if ((off & 1) != 0)
1635             off &= ~1;
1636           else
1637             {
1638               bfd_put_32 (output_bfd, value, sgot->contents + off);
1639
1640               if (info->shared)
1641                 {
1642                   asection * srelgot;
1643                   Elf_Internal_Rel outrel;
1644
1645                   srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
1646                   BFD_ASSERT (srelgot != NULL);
1647
1648                   outrel.r_offset = (sgot->output_section->vma
1649                                      + sgot->output_offset
1650                                      + off);
1651                   outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
1652                   bfd_elf32_swap_reloc_out (output_bfd, &outrel,
1653                                             (((Elf32_External_Rel *)
1654                                               srelgot->contents)
1655                                              + srelgot->reloc_count));
1656                   ++srelgot->reloc_count;
1657                 }
1658
1659               local_got_offsets[r_symndx] |= 1;
1660             }
1661
1662           value = sgot->output_offset + off;
1663         }
1664
1665       return _bfd_final_link_relocate (howto, input_bfd, input_section,
1666                                        contents, rel->r_offset, value,
1667                                        (bfd_vma) 0);
1668
1669     case R_ARM_PLT32:
1670       /* Relocation is to the entry for this symbol in the
1671          procedure linkage table.  */
1672
1673       /* Resolve a PLT32 reloc against a local symbol directly,
1674          without using the procedure linkage table.  */
1675       if (h == NULL)
1676         return _bfd_final_link_relocate (howto, input_bfd, input_section,
1677                                  contents, rel->r_offset, value,
1678                                  (bfd_vma) 0);
1679
1680       if (h->plt.offset == (bfd_vma) -1)
1681         /* We didn't make a PLT entry for this symbol.  This
1682            happens when statically linking PIC code, or when
1683            using -Bsymbolic.  */
1684         return _bfd_final_link_relocate (howto, input_bfd, input_section,
1685                                          contents, rel->r_offset, value,
1686                                          (bfd_vma) 0);
1687
1688       BFD_ASSERT(splt != NULL);
1689       if (splt == NULL)
1690         return bfd_reloc_notsupported;
1691
1692       value = (splt->output_section->vma
1693                + splt->output_offset
1694                + h->plt.offset);
1695       return _bfd_final_link_relocate (howto, input_bfd, input_section,
1696                                contents, rel->r_offset, value,
1697                                (bfd_vma) 0);
1698
1699     case R_ARM_SBREL32:
1700       return bfd_reloc_notsupported;
1701
1702     case R_ARM_AMP_VCALL9:
1703       return bfd_reloc_notsupported;
1704
1705     case R_ARM_RSBREL32:
1706       return bfd_reloc_notsupported;
1707
1708     case R_ARM_THM_RPC22:
1709       return bfd_reloc_notsupported;
1710
1711     case R_ARM_RREL32:
1712       return bfd_reloc_notsupported;
1713
1714     case R_ARM_RABS32:
1715       return bfd_reloc_notsupported;
1716
1717     case R_ARM_RPC24:
1718       return bfd_reloc_notsupported;
1719
1720     case R_ARM_RBASE:
1721       return bfd_reloc_notsupported;
1722
1723     default:
1724       return bfd_reloc_notsupported;
1725     }
1726 }
1727
1728 #ifdef USE_REL
1729 /* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS.  */
1730 static void
1731 arm_add_to_rel (abfd, address, howto, increment)
1732      bfd *              abfd;
1733      bfd_byte *         address;
1734      reloc_howto_type * howto;
1735      bfd_signed_vma     increment;
1736 {
1737   bfd_signed_vma addend;
1738
1739   if (howto->type == R_ARM_THM_PC22)
1740     {
1741       int upper_insn, lower_insn;
1742       int upper, lower;
1743
1744       upper_insn = bfd_get_16 (abfd, address);
1745       lower_insn = bfd_get_16 (abfd, address + 2);
1746       upper = upper_insn & 0x7ff;
1747       lower = lower_insn & 0x7ff;
1748
1749       addend = (upper << 12) | (lower << 1);
1750       addend += increment;
1751       addend >>= 1;
1752
1753       upper_insn = (upper_insn & 0xf800) | ((addend >> 11) & 0x7ff);
1754       lower_insn = (lower_insn & 0xf800) | (addend & 0x7ff);
1755
1756       bfd_put_16 (abfd, (bfd_vma) upper_insn, address);
1757       bfd_put_16 (abfd, (bfd_vma) lower_insn, address + 2);
1758     }
1759   else
1760     {
1761       bfd_vma        contents;
1762
1763       contents = bfd_get_32 (abfd, address);
1764
1765       /* Get the (signed) value from the instruction.  */
1766       addend = contents & howto->src_mask;
1767       if (addend & ((howto->src_mask + 1) >> 1))
1768         {
1769           bfd_signed_vma mask;
1770
1771           mask = -1;
1772           mask &= ~ howto->src_mask;
1773           addend |= mask;
1774         }
1775
1776       /* Add in the increment, (which is a byte value).  */
1777       switch (howto->type)
1778         {
1779         default:
1780           addend += increment;
1781           break;
1782
1783         case R_ARM_PC24:
1784           addend <<= howto->size;
1785           addend += increment;
1786
1787           /* Should we check for overflow here ?  */
1788
1789           /* Drop any undesired bits.  */
1790           addend >>= howto->rightshift;
1791           break;
1792         }
1793
1794       contents = (contents & ~ howto->dst_mask) | (addend & howto->dst_mask);
1795
1796       bfd_put_32 (abfd, contents, address);
1797     }
1798 }
1799 #endif /* USE_REL */
1800
1801 /* Relocate an ARM ELF section.  */
1802 static boolean
1803 elf32_arm_relocate_section (output_bfd, info, input_bfd, input_section,
1804                             contents, relocs, local_syms, local_sections)
1805      bfd *                  output_bfd;
1806      struct bfd_link_info * info;
1807      bfd *                  input_bfd;
1808      asection *             input_section;
1809      bfd_byte *             contents;
1810      Elf_Internal_Rela *    relocs;
1811      Elf_Internal_Sym *     local_syms;
1812      asection **            local_sections;
1813 {
1814   Elf_Internal_Shdr *           symtab_hdr;
1815   struct elf_link_hash_entry ** sym_hashes;
1816   Elf_Internal_Rela *           rel;
1817   Elf_Internal_Rela *           relend;
1818   const char *                  name;
1819
1820   symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
1821   sym_hashes = elf_sym_hashes (input_bfd);
1822
1823   rel = relocs;
1824   relend = relocs + input_section->reloc_count;
1825   for (; rel < relend; rel++)
1826     {
1827       int                          r_type;
1828       reloc_howto_type *           howto;
1829       unsigned long                r_symndx;
1830       Elf_Internal_Sym *           sym;
1831       asection *                   sec;
1832       struct elf_link_hash_entry * h;
1833       bfd_vma                      relocation;
1834       bfd_reloc_status_type        r;
1835       arelent                      bfd_reloc;
1836
1837       r_symndx = ELF32_R_SYM (rel->r_info);
1838       r_type   = ELF32_R_TYPE (rel->r_info);
1839
1840       if (   r_type == R_ARM_GNU_VTENTRY
1841           || r_type == R_ARM_GNU_VTINHERIT)
1842         continue;
1843
1844 #ifdef USE_REL
1845       elf32_arm_info_to_howto (input_bfd, & bfd_reloc,
1846                                (Elf_Internal_Rel *) rel);
1847 #else
1848       elf32_arm_info_to_howto (input_bfd, & bfd_reloc, rel);
1849 #endif
1850       howto = bfd_reloc.howto;
1851
1852       if (info->relocateable)
1853         {
1854           /* This is a relocateable link.  We don't have to change
1855              anything, unless the reloc is against a section symbol,
1856              in which case we have to adjust according to where the
1857              section symbol winds up in the output section.  */
1858           if (r_symndx < symtab_hdr->sh_info)
1859             {
1860               sym = local_syms + r_symndx;
1861               if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1862                 {
1863                   sec = local_sections[r_symndx];
1864 #ifdef USE_REL
1865                   arm_add_to_rel (input_bfd, contents + rel->r_offset,
1866                                   howto,
1867                                   (bfd_signed_vma) (sec->output_offset
1868                                                     + sym->st_value));
1869 #else
1870                   rel->r_addend += (sec->output_offset + sym->st_value);
1871 #endif
1872                 }
1873             }
1874
1875           continue;
1876         }
1877
1878       /* This is a final link.  */
1879       h = NULL;
1880       sym = NULL;
1881       sec = NULL;
1882
1883       if (r_symndx < symtab_hdr->sh_info)
1884         {
1885           sym = local_syms + r_symndx;
1886           sec = local_sections[r_symndx];
1887 #ifdef USE_REL
1888           relocation = (sec->output_section->vma
1889                         + sec->output_offset
1890                         + sym->st_value);
1891           if ((sec->flags & SEC_MERGE)
1892                    && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1893             {
1894               asection *msec;
1895               bfd_vma addend, value;
1896
1897               if (howto->rightshift)
1898                 {
1899                   (*_bfd_error_handler)
1900                     (_("%s(%s+0x%lx): %s relocation against SEC_MERGE section"),
1901                      bfd_archive_filename (input_bfd),
1902                      bfd_get_section_name (input_bfd, input_section),
1903                      (long) rel->r_offset, howto->name);
1904                   return false;
1905                 }
1906
1907               value = bfd_get_32 (input_bfd, contents + rel->r_offset);
1908
1909               /* Get the (signed) value from the instruction.  */
1910               addend = value & howto->src_mask;
1911               if (addend & ((howto->src_mask + 1) >> 1))
1912                 {
1913                   bfd_signed_vma mask;
1914
1915                   mask = -1;
1916                   mask &= ~ howto->src_mask;
1917                   addend |= mask;
1918                 }
1919               msec = sec;
1920               addend =
1921                 _bfd_elf_rel_local_sym (output_bfd, sym, &msec, addend)
1922                 - relocation;
1923               addend += msec->output_section->vma + msec->output_offset;
1924               value = (value & ~ howto->dst_mask) | (addend & howto->dst_mask);
1925               bfd_put_32 (input_bfd, value, contents + rel->r_offset);
1926             }
1927 #else
1928           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
1929 #endif
1930         }
1931       else
1932         {
1933           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1934
1935           while (   h->root.type == bfd_link_hash_indirect
1936                  || h->root.type == bfd_link_hash_warning)
1937             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1938
1939           if (   h->root.type == bfd_link_hash_defined
1940               || h->root.type == bfd_link_hash_defweak)
1941             {
1942               int relocation_needed = 1;
1943
1944               sec = h->root.u.def.section;
1945
1946               /* In these cases, we don't need the relocation value.
1947                  We check specially because in some obscure cases
1948                  sec->output_section will be NULL.  */
1949               switch (r_type)
1950                 {
1951                 case R_ARM_PC24:
1952                 case R_ARM_ABS32:
1953                 case R_ARM_THM_PC22:
1954                   if (info->shared
1955                       && (
1956                   (!info->symbolic && h->dynindx != -1)
1957                           || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
1958                           )
1959                       && ((input_section->flags & SEC_ALLOC) != 0
1960                           /* DWARF will emit R_ARM_ABS32 relocations in its
1961                              sections against symbols defined externally
1962                              in shared libraries.  We can't do anything
1963                              with them here.  */
1964                           || ((input_section->flags & SEC_DEBUGGING) != 0
1965                               && (h->elf_link_hash_flags
1966                                   & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
1967                       )
1968                     relocation_needed = 0;
1969                   break;
1970
1971                 case R_ARM_GOTPC:
1972                   relocation_needed = 0;
1973                   break;
1974
1975                 case R_ARM_GOT32:
1976                   if (elf_hash_table(info)->dynamic_sections_created
1977                       && (!info->shared
1978                           || (!info->symbolic && h->dynindx != -1)
1979                           || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
1980                           )
1981                       )
1982                     relocation_needed = 0;
1983                   break;
1984
1985                 case R_ARM_PLT32:
1986                   if (h->plt.offset != (bfd_vma)-1)
1987                     relocation_needed = 0;
1988                   break;
1989
1990                 default:
1991                   if (sec->output_section == NULL)
1992                     {
1993                       (*_bfd_error_handler)
1994                         (_("%s: warning: unresolvable relocation %d against symbol `%s' from %s section"),
1995                          bfd_archive_filename (input_bfd),
1996                          r_type,
1997                          h->root.root.string,
1998                          bfd_get_section_name (input_bfd, input_section));
1999                       relocation_needed = 0;
2000                     }
2001                 }
2002
2003               if (relocation_needed)
2004                 relocation = h->root.u.def.value
2005                   + sec->output_section->vma
2006                   + sec->output_offset;
2007               else
2008                 relocation = 0;
2009             }
2010           else if (h->root.type == bfd_link_hash_undefweak)
2011             relocation = 0;
2012           else if (info->shared && !info->symbolic
2013                    && !info->no_undefined
2014                    && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
2015             relocation = 0;
2016           else
2017             {
2018               if (!((*info->callbacks->undefined_symbol)
2019                     (info, h->root.root.string, input_bfd,
2020                      input_section, rel->r_offset,
2021                      (!info->shared || info->no_undefined
2022                       || ELF_ST_VISIBILITY (h->other)))))
2023                 return false;
2024               relocation = 0;
2025             }
2026         }
2027
2028       if (h != NULL)
2029         name = h->root.root.string;
2030       else
2031         {
2032           name = (bfd_elf_string_from_elf_section
2033                   (input_bfd, symtab_hdr->sh_link, sym->st_name));
2034           if (name == NULL || *name == '\0')
2035             name = bfd_section_name (input_bfd, sec);
2036         }
2037
2038       r = elf32_arm_final_link_relocate (howto, input_bfd, output_bfd,
2039                                          input_section, contents, rel,
2040                                          relocation, info, sec, name,
2041                                          (h ? ELF_ST_TYPE (h->type) :
2042                                           ELF_ST_TYPE (sym->st_info)), h);
2043
2044       if (r != bfd_reloc_ok)
2045         {
2046           const char * msg = (const char *) 0;
2047
2048           switch (r)
2049             {
2050             case bfd_reloc_overflow:
2051               /* If the overflowing reloc was to an undefined symbol,
2052                  we have already printed one error message and there
2053                  is no point complaining again.  */
2054               if ((! h ||
2055                    h->root.type != bfd_link_hash_undefined)
2056                   && (!((*info->callbacks->reloc_overflow)
2057                         (info, name, howto->name, (bfd_vma) 0,
2058                          input_bfd, input_section, rel->r_offset))))
2059                   return false;
2060               break;
2061
2062             case bfd_reloc_undefined:
2063               if (!((*info->callbacks->undefined_symbol)
2064                     (info, name, input_bfd, input_section,
2065                      rel->r_offset, true)))
2066                 return false;
2067               break;
2068
2069             case bfd_reloc_outofrange:
2070               msg = _("internal error: out of range error");
2071               goto common_error;
2072
2073             case bfd_reloc_notsupported:
2074               msg = _("internal error: unsupported relocation error");
2075               goto common_error;
2076
2077             case bfd_reloc_dangerous:
2078               msg = _("internal error: dangerous error");
2079               goto common_error;
2080
2081             default:
2082               msg = _("internal error: unknown error");
2083               /* fall through */
2084
2085             common_error:
2086               if (!((*info->callbacks->warning)
2087                     (info, msg, name, input_bfd, input_section,
2088                      rel->r_offset)))
2089                 return false;
2090               break;
2091             }
2092         }
2093     }
2094
2095   return true;
2096 }
2097
2098 /* Function to keep ARM specific flags in the ELF header.  */
2099 static boolean
2100 elf32_arm_set_private_flags (abfd, flags)
2101      bfd *abfd;
2102      flagword flags;
2103 {
2104   if (elf_flags_init (abfd)
2105       && elf_elfheader (abfd)->e_flags != flags)
2106     {
2107       if (EF_ARM_EABI_VERSION (flags) == EF_ARM_EABI_UNKNOWN)
2108         {
2109           if (flags & EF_ARM_INTERWORK)
2110             (*_bfd_error_handler) (_("\
2111 Warning: Not setting interworking flag of %s since it has already been specified as non-interworking"),
2112                                    bfd_archive_filename (abfd));
2113           else
2114             _bfd_error_handler (_("\
2115 Warning: Clearing the interworking flag of %s due to outside request"),
2116                                 bfd_archive_filename (abfd));
2117         }
2118     }
2119   else
2120     {
2121       elf_elfheader (abfd)->e_flags = flags;
2122       elf_flags_init (abfd) = true;
2123     }
2124
2125   return true;
2126 }
2127
2128 /* Copy backend specific data from one object module to another.  */
2129
2130 static boolean
2131 elf32_arm_copy_private_bfd_data (ibfd, obfd)
2132      bfd *ibfd;
2133      bfd *obfd;
2134 {
2135   flagword in_flags;
2136   flagword out_flags;
2137
2138   if (   bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2139       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2140     return true;
2141
2142   in_flags  = elf_elfheader (ibfd)->e_flags;
2143   out_flags = elf_elfheader (obfd)->e_flags;
2144
2145   if (elf_flags_init (obfd)
2146       && EF_ARM_EABI_VERSION (out_flags) == EF_ARM_EABI_UNKNOWN
2147       && in_flags != out_flags)
2148     {
2149       /* Cannot mix APCS26 and APCS32 code.  */
2150       if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
2151         return false;
2152
2153       /* Cannot mix float APCS and non-float APCS code.  */
2154       if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
2155         return false;
2156
2157       /* If the src and dest have different interworking flags
2158          then turn off the interworking bit.  */
2159       if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
2160         {
2161           if (out_flags & EF_ARM_INTERWORK)
2162             _bfd_error_handler (_("\
2163 Warning: Clearing the interworking flag of %s because non-interworking code in %s has been linked with it"),
2164                                 bfd_get_filename (obfd),
2165                                 bfd_archive_filename (ibfd));
2166
2167           in_flags &= ~EF_ARM_INTERWORK;
2168         }
2169
2170       /* Likewise for PIC, though don't warn for this case.  */
2171       if ((in_flags & EF_ARM_PIC) != (out_flags & EF_ARM_PIC))
2172         in_flags &= ~EF_ARM_PIC;
2173     }
2174
2175   elf_elfheader (obfd)->e_flags = in_flags;
2176   elf_flags_init (obfd) = true;
2177
2178   return true;
2179 }
2180
2181 /* Merge backend specific data from an object file to the output
2182    object file when linking.  */
2183
2184 static boolean
2185 elf32_arm_merge_private_bfd_data (ibfd, obfd)
2186      bfd * ibfd;
2187      bfd * obfd;
2188 {
2189   flagword out_flags;
2190   flagword in_flags;
2191   boolean flags_compatible = true;
2192   boolean null_input_bfd = true;
2193   asection *sec;
2194
2195   /* Check if we have the same endianess.  */
2196   if (_bfd_generic_verify_endian_match (ibfd, obfd) == false)
2197     return false;
2198
2199   if (   bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2200       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2201     return true;
2202
2203   /* The input BFD must have had its flags initialised.  */
2204   /* The following seems bogus to me -- The flags are initialized in
2205      the assembler but I don't think an elf_flags_init field is
2206      written into the object.  */
2207   /* BFD_ASSERT (elf_flags_init (ibfd)); */
2208
2209   in_flags  = elf_elfheader (ibfd)->e_flags;
2210   out_flags = elf_elfheader (obfd)->e_flags;
2211
2212   if (!elf_flags_init (obfd))
2213     {
2214       /* If the input is the default architecture and had the default
2215          flags then do not bother setting the flags for the output
2216          architecture, instead allow future merges to do this.  If no
2217          future merges ever set these flags then they will retain their
2218          uninitialised values, which surprise surprise, correspond
2219          to the default values.  */
2220       if (bfd_get_arch_info (ibfd)->the_default
2221           && elf_elfheader (ibfd)->e_flags == 0)
2222         return true;
2223
2224       elf_flags_init (obfd) = true;
2225       elf_elfheader (obfd)->e_flags = in_flags;
2226
2227       if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
2228           && bfd_get_arch_info (obfd)->the_default)
2229         return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
2230
2231       return true;
2232     }
2233
2234   /* Identical flags must be compatible.  */
2235   if (in_flags == out_flags)
2236     return true;
2237
2238   /* Check to see if the input BFD actually contains any sections.
2239      If not, its flags may not have been initialised either, but it cannot
2240      actually cause any incompatibility.  */
2241   for (sec = ibfd->sections; sec != NULL; sec = sec->next)
2242     {
2243       /* Ignore synthetic glue sections.  */
2244       if (strcmp (sec->name, ".glue_7")
2245           && strcmp (sec->name, ".glue_7t"))
2246         {
2247           null_input_bfd = false;
2248           break;
2249         }
2250     }
2251   if (null_input_bfd)
2252     return true;
2253
2254   /* Complain about various flag mismatches.  */
2255   if (EF_ARM_EABI_VERSION (in_flags) != EF_ARM_EABI_VERSION (out_flags))
2256     {
2257       _bfd_error_handler (_("\
2258 ERROR: %s is compiled for EABI version %d, whereas %s is compiled for version %d"),
2259                           bfd_archive_filename (ibfd),
2260                           (in_flags & EF_ARM_EABIMASK) >> 24,
2261                           bfd_get_filename (obfd),
2262                           (out_flags & EF_ARM_EABIMASK) >> 24);
2263       return false;
2264     }
2265
2266   /* Not sure what needs to be checked for EABI versions >= 1.  */
2267   if (EF_ARM_EABI_VERSION (in_flags) == EF_ARM_EABI_UNKNOWN)
2268     {
2269       if ((in_flags & EF_ARM_APCS_26) != (out_flags & EF_ARM_APCS_26))
2270         {
2271           _bfd_error_handler (_("\
2272 ERROR: %s is compiled for APCS-%d, whereas target %s uses APCS-%d"),
2273                               bfd_archive_filename (ibfd),
2274                               in_flags & EF_ARM_APCS_26 ? 26 : 32,
2275                               bfd_get_filename (obfd),
2276                               out_flags & EF_ARM_APCS_26 ? 26 : 32);
2277           flags_compatible = false;
2278         }
2279
2280       if ((in_flags & EF_ARM_APCS_FLOAT) != (out_flags & EF_ARM_APCS_FLOAT))
2281         {
2282           if (in_flags & EF_ARM_APCS_FLOAT)
2283             _bfd_error_handler (_("\
2284 ERROR: %s passes floats in float registers, whereas %s passes them in integer registers"),
2285                                 bfd_archive_filename (ibfd),
2286                                 bfd_get_filename (obfd));
2287           else
2288             _bfd_error_handler (_("\
2289 ERROR: %s passes floats in integer registers, whereas %s passes them in float registers"),
2290                                 bfd_archive_filename (ibfd),
2291                                 bfd_get_filename (obfd));
2292
2293           flags_compatible = false;
2294         }
2295
2296       if ((in_flags & EF_ARM_VFP_FLOAT) != (out_flags & EF_ARM_VFP_FLOAT))
2297         {
2298           if (in_flags & EF_ARM_VFP_FLOAT)
2299             _bfd_error_handler (_("\
2300 ERROR: %s uses VFP instructions, whereas %s uses FPA instructions"),
2301                                 bfd_archive_filename (ibfd),
2302                                 bfd_get_filename (obfd));
2303           else
2304             _bfd_error_handler (_("\
2305 ERROR: %s uses FPA instructions, whereas %s uses VFP instructions"),
2306                                 bfd_archive_filename (ibfd),
2307                                 bfd_get_filename (obfd));
2308
2309           flags_compatible = false;
2310         }
2311
2312 #ifdef EF_ARM_SOFT_FLOAT
2313       if ((in_flags & EF_ARM_SOFT_FLOAT) != (out_flags & EF_ARM_SOFT_FLOAT))
2314         {
2315           /* We can allow interworking between code that is VFP format
2316              layout, and uses either soft float or integer regs for
2317              passing floating point arguments and results.  We already
2318              know that the APCS_FLOAT flags match; similarly for VFP
2319              flags.  */
2320           if ((in_flags & EF_ARM_APCS_FLOAT) != 0
2321               || (in_flags & EF_ARM_VFP_FLOAT) == 0)
2322             {
2323               if (in_flags & EF_ARM_SOFT_FLOAT)
2324                 _bfd_error_handler (_("\
2325 ERROR: %s uses software FP, whereas %s uses hardware FP"),
2326                                     bfd_archive_filename (ibfd),
2327                                     bfd_get_filename (obfd));
2328               else
2329                 _bfd_error_handler (_("\
2330 ERROR: %s uses hardware FP, whereas %s uses software FP"),
2331                                     bfd_archive_filename (ibfd),
2332                                     bfd_get_filename (obfd));
2333
2334               flags_compatible = false;
2335             }
2336         }
2337 #endif
2338
2339       /* Interworking mismatch is only a warning.  */
2340       if ((in_flags & EF_ARM_INTERWORK) != (out_flags & EF_ARM_INTERWORK))
2341         {
2342           if (in_flags & EF_ARM_INTERWORK)
2343             {
2344               _bfd_error_handler (_("\
2345 Warning: %s supports interworking, whereas %s does not"),
2346                                   bfd_archive_filename (ibfd),
2347                                   bfd_get_filename (obfd));
2348             }
2349           else
2350             {
2351               _bfd_error_handler (_("\
2352 Warning: %s does not support interworking, whereas %s does"),
2353                                   bfd_archive_filename (ibfd),
2354                                   bfd_get_filename (obfd));
2355             }
2356         }
2357     }
2358
2359   return flags_compatible;
2360 }
2361
2362 /* Display the flags field.  */
2363
2364 static boolean
2365 elf32_arm_print_private_bfd_data (abfd, ptr)
2366      bfd *abfd;
2367      PTR ptr;
2368 {
2369   FILE * file = (FILE *) ptr;
2370   unsigned long flags;
2371
2372   BFD_ASSERT (abfd != NULL && ptr != NULL);
2373
2374   /* Print normal ELF private data.  */
2375   _bfd_elf_print_private_bfd_data (abfd, ptr);
2376
2377   flags = elf_elfheader (abfd)->e_flags;
2378   /* Ignore init flag - it may not be set, despite the flags field
2379      containing valid data.  */
2380
2381   /* xgettext:c-format */
2382   fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
2383
2384   switch (EF_ARM_EABI_VERSION (flags))
2385     {
2386     case EF_ARM_EABI_UNKNOWN:
2387       /* The following flag bits are GNU extenstions and not part of the
2388          official ARM ELF extended ABI.  Hence they are only decoded if
2389          the EABI version is not set.  */
2390       if (flags & EF_ARM_INTERWORK)
2391         fprintf (file, _(" [interworking enabled]"));
2392
2393       if (flags & EF_ARM_APCS_26)
2394         fprintf (file, " [APCS-26]");
2395       else
2396         fprintf (file, " [APCS-32]");
2397
2398       if (flags & EF_ARM_VFP_FLOAT)
2399         fprintf (file, _(" [VFP float format]"));
2400       else
2401         fprintf (file, _(" [FPA float format]"));
2402
2403       if (flags & EF_ARM_APCS_FLOAT)
2404         fprintf (file, _(" [floats passed in float registers]"));
2405
2406       if (flags & EF_ARM_PIC)
2407         fprintf (file, _(" [position independent]"));
2408
2409       if (flags & EF_ARM_NEW_ABI)
2410         fprintf (file, _(" [new ABI]"));
2411
2412       if (flags & EF_ARM_OLD_ABI)
2413         fprintf (file, _(" [old ABI]"));
2414
2415       if (flags & EF_ARM_SOFT_FLOAT)
2416         fprintf (file, _(" [software FP]"));
2417
2418       flags &= ~(EF_ARM_INTERWORK | EF_ARM_APCS_26 | EF_ARM_APCS_FLOAT
2419                  | EF_ARM_PIC | EF_ARM_NEW_ABI | EF_ARM_OLD_ABI
2420                  | EF_ARM_SOFT_FLOAT | EF_ARM_VFP_FLOAT);
2421       break;
2422
2423     case EF_ARM_EABI_VER1:
2424       fprintf (file, _(" [Version1 EABI]"));
2425
2426       if (flags & EF_ARM_SYMSARESORTED)
2427         fprintf (file, _(" [sorted symbol table]"));
2428       else
2429         fprintf (file, _(" [unsorted symbol table]"));
2430
2431       flags &= ~ EF_ARM_SYMSARESORTED;
2432       break;
2433
2434     case EF_ARM_EABI_VER2:
2435       fprintf (file, _(" [Version2 EABI]"));
2436
2437       if (flags & EF_ARM_SYMSARESORTED)
2438         fprintf (file, _(" [sorted symbol table]"));
2439       else
2440         fprintf (file, _(" [unsorted symbol table]"));
2441
2442       if (flags & EF_ARM_DYNSYMSUSESEGIDX)
2443         fprintf (file, _(" [dynamic symbols use segment index]"));
2444
2445       if (flags & EF_ARM_MAPSYMSFIRST)
2446         fprintf (file, _(" [mapping symbols precede others]"));
2447
2448       flags &= ~(EF_ARM_SYMSARESORTED | EF_ARM_DYNSYMSUSESEGIDX
2449                  | EF_ARM_MAPSYMSFIRST);
2450       break;
2451
2452     default:
2453       fprintf (file, _(" <EABI version unrecognised>"));
2454       break;
2455     }
2456
2457   flags &= ~ EF_ARM_EABIMASK;
2458
2459   if (flags & EF_ARM_RELEXEC)
2460     fprintf (file, _(" [relocatable executable]"));
2461
2462   if (flags & EF_ARM_HASENTRY)
2463     fprintf (file, _(" [has entry point]"));
2464
2465   flags &= ~ (EF_ARM_RELEXEC | EF_ARM_HASENTRY);
2466
2467   if (flags)
2468     fprintf (file, _("<Unrecognised flag bits set>"));
2469
2470   fputc ('\n', file);
2471
2472   return true;
2473 }
2474
2475 static int
2476 elf32_arm_get_symbol_type (elf_sym, type)
2477      Elf_Internal_Sym * elf_sym;
2478      int type;
2479 {
2480   switch (ELF_ST_TYPE (elf_sym->st_info))
2481     {
2482     case STT_ARM_TFUNC:
2483       return ELF_ST_TYPE (elf_sym->st_info);
2484
2485     case STT_ARM_16BIT:
2486       /* If the symbol is not an object, return the STT_ARM_16BIT flag.
2487          This allows us to distinguish between data used by Thumb instructions
2488          and non-data (which is probably code) inside Thumb regions of an
2489          executable.  */
2490       if (type != STT_OBJECT)
2491         return ELF_ST_TYPE (elf_sym->st_info);
2492       break;
2493
2494     default:
2495       break;
2496     }
2497
2498   return type;
2499 }
2500
2501 static asection *
2502 elf32_arm_gc_mark_hook (abfd, info, rel, h, sym)
2503        bfd *abfd;
2504        struct bfd_link_info *info ATTRIBUTE_UNUSED;
2505        Elf_Internal_Rela *rel;
2506        struct elf_link_hash_entry *h;
2507        Elf_Internal_Sym *sym;
2508 {
2509   if (h != NULL)
2510     {
2511       switch (ELF32_R_TYPE (rel->r_info))
2512       {
2513       case R_ARM_GNU_VTINHERIT:
2514       case R_ARM_GNU_VTENTRY:
2515         break;
2516
2517       default:
2518         switch (h->root.type)
2519           {
2520           case bfd_link_hash_defined:
2521           case bfd_link_hash_defweak:
2522             return h->root.u.def.section;
2523
2524           case bfd_link_hash_common:
2525             return h->root.u.c.p->section;
2526
2527           default:
2528             break;
2529           }
2530        }
2531      }
2532    else
2533      {
2534        return bfd_section_from_elf_index (abfd, sym->st_shndx);
2535      }
2536
2537   return NULL;
2538 }
2539
2540 /* Update the got entry reference counts for the section being removed.  */
2541
2542 static boolean
2543 elf32_arm_gc_sweep_hook (abfd, info, sec, relocs)
2544      bfd *abfd ATTRIBUTE_UNUSED;
2545      struct bfd_link_info *info ATTRIBUTE_UNUSED;
2546      asection *sec ATTRIBUTE_UNUSED;
2547      const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
2548 {
2549   /* We don't support garbage collection of GOT and PLT relocs yet.  */
2550   return true;
2551 }
2552
2553 /* Look through the relocs for a section during the first phase.  */
2554
2555 static boolean
2556 elf32_arm_check_relocs (abfd, info, sec, relocs)
2557      bfd *                      abfd;
2558      struct bfd_link_info *     info;
2559      asection *                 sec;
2560      const Elf_Internal_Rela *  relocs;
2561 {
2562   Elf_Internal_Shdr *           symtab_hdr;
2563   struct elf_link_hash_entry ** sym_hashes;
2564   struct elf_link_hash_entry ** sym_hashes_end;
2565   const Elf_Internal_Rela *     rel;
2566   const Elf_Internal_Rela *     rel_end;
2567   bfd *                         dynobj;
2568   asection * sgot, *srelgot, *sreloc;
2569   bfd_vma * local_got_offsets;
2570
2571   if (info->relocateable)
2572     return true;
2573
2574   sgot = srelgot = sreloc = NULL;
2575
2576   dynobj = elf_hash_table (info)->dynobj;
2577   local_got_offsets = elf_local_got_offsets (abfd);
2578
2579   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2580   sym_hashes = elf_sym_hashes (abfd);
2581   sym_hashes_end = sym_hashes
2582     + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
2583
2584   if (!elf_bad_symtab (abfd))
2585     sym_hashes_end -= symtab_hdr->sh_info;
2586
2587   rel_end = relocs + sec->reloc_count;
2588   for (rel = relocs; rel < rel_end; rel++)
2589     {
2590       struct elf_link_hash_entry *h;
2591       unsigned long r_symndx;
2592
2593       r_symndx = ELF32_R_SYM (rel->r_info);
2594       if (r_symndx < symtab_hdr->sh_info)
2595         h = NULL;
2596       else
2597         h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2598
2599       /* Some relocs require a global offset table.  */
2600       if (dynobj == NULL)
2601         {
2602           switch (ELF32_R_TYPE (rel->r_info))
2603             {
2604             case R_ARM_GOT32:
2605             case R_ARM_GOTOFF:
2606             case R_ARM_GOTPC:
2607               elf_hash_table (info)->dynobj = dynobj = abfd;
2608               if (! _bfd_elf_create_got_section (dynobj, info))
2609                 return false;
2610               break;
2611
2612             default:
2613               break;
2614             }
2615         }
2616
2617       switch (ELF32_R_TYPE (rel->r_info))
2618         {
2619           case R_ARM_GOT32:
2620             /* This symbol requires a global offset table entry.  */
2621             if (sgot == NULL)
2622               {
2623                 sgot = bfd_get_section_by_name (dynobj, ".got");
2624                 BFD_ASSERT (sgot != NULL);
2625               }
2626
2627             /* Get the got relocation section if necessary.  */
2628             if (srelgot == NULL
2629                 && (h != NULL || info->shared))
2630               {
2631                 srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
2632
2633                 /* If no got relocation section, make one and initialize.  */
2634                 if (srelgot == NULL)
2635                   {
2636                     srelgot = bfd_make_section (dynobj, ".rel.got");
2637                     if (srelgot == NULL
2638                         || ! bfd_set_section_flags (dynobj, srelgot,
2639                                                     (SEC_ALLOC
2640                                                      | SEC_LOAD
2641                                                      | SEC_HAS_CONTENTS
2642                                                      | SEC_IN_MEMORY
2643                                                      | SEC_LINKER_CREATED
2644                                                      | SEC_READONLY))
2645                         || ! bfd_set_section_alignment (dynobj, srelgot, 2))
2646                       return false;
2647                   }
2648               }
2649
2650             if (h != NULL)
2651               {
2652                 if (h->got.offset != (bfd_vma) -1)
2653                   /* We have already allocated space in the .got.  */
2654                   break;
2655
2656                 h->got.offset = sgot->_raw_size;
2657
2658                 /* Make sure this symbol is output as a dynamic symbol.  */
2659                 if (h->dynindx == -1)
2660                   if (! bfd_elf32_link_record_dynamic_symbol (info, h))
2661                     return false;
2662
2663                 srelgot->_raw_size += sizeof (Elf32_External_Rel);
2664               }
2665             else
2666               {
2667                 /* This is a global offset table entry for a local
2668                    symbol.  */
2669                 if (local_got_offsets == NULL)
2670                   {
2671                     bfd_size_type size;
2672                     unsigned int i;
2673
2674                     size = symtab_hdr->sh_info;
2675                     size *= sizeof (bfd_vma);
2676                     local_got_offsets = (bfd_vma *) bfd_alloc (abfd, size);
2677                     if (local_got_offsets == NULL)
2678                       return false;
2679                     elf_local_got_offsets (abfd) = local_got_offsets;
2680                     for (i = 0; i < symtab_hdr->sh_info; i++)
2681                       local_got_offsets[i] = (bfd_vma) -1;
2682                   }
2683
2684                 if (local_got_offsets[r_symndx] != (bfd_vma) -1)
2685                   /* We have already allocated space in the .got.  */
2686                   break;
2687
2688                 local_got_offsets[r_symndx] = sgot->_raw_size;
2689
2690                 if (info->shared)
2691                   /* If we are generating a shared object, we need to
2692                      output a R_ARM_RELATIVE reloc so that the dynamic
2693                      linker can adjust this GOT entry.  */
2694                   srelgot->_raw_size += sizeof (Elf32_External_Rel);
2695               }
2696
2697             sgot->_raw_size += 4;
2698             break;
2699
2700           case R_ARM_PLT32:
2701             /* This symbol requires a procedure linkage table entry.  We
2702                actually build the entry in adjust_dynamic_symbol,
2703                because this might be a case of linking PIC code which is
2704                never referenced by a dynamic object, in which case we
2705                don't need to generate a procedure linkage table entry
2706                after all.  */
2707
2708             /* If this is a local symbol, we resolve it directly without
2709                creating a procedure linkage table entry.  */
2710             if (h == NULL)
2711               continue;
2712
2713             h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2714             break;
2715
2716           case R_ARM_ABS32:
2717           case R_ARM_REL32:
2718           case R_ARM_PC24:
2719             /* If we are creating a shared library, and this is a reloc
2720                against a global symbol, or a non PC relative reloc
2721                against a local symbol, then we need to copy the reloc
2722                into the shared library.  However, if we are linking with
2723                -Bsymbolic, we do not need to copy a reloc against a
2724                global symbol which is defined in an object we are
2725                including in the link (i.e., DEF_REGULAR is set).  At
2726                this point we have not seen all the input files, so it is
2727                possible that DEF_REGULAR is not set now but will be set
2728                later (it is never cleared).  We account for that
2729                possibility below by storing information in the
2730                pcrel_relocs_copied field of the hash table entry.  */
2731             if (info->shared
2732               && (ELF32_R_TYPE (rel->r_info) != R_ARM_PC24
2733                 || (h != NULL
2734                   && (! info->symbolic
2735                     || (h->elf_link_hash_flags
2736                       & ELF_LINK_HASH_DEF_REGULAR) == 0))))
2737               {
2738                 /* When creating a shared object, we must copy these
2739                    reloc types into the output file.  We create a reloc
2740                    section in dynobj and make room for this reloc.  */
2741                 if (sreloc == NULL)
2742                   {
2743                     const char * name;
2744
2745                     name = (bfd_elf_string_from_elf_section
2746                             (abfd,
2747                              elf_elfheader (abfd)->e_shstrndx,
2748                              elf_section_data (sec)->rel_hdr.sh_name));
2749                     if (name == NULL)
2750                       return false;
2751
2752                     BFD_ASSERT (strncmp (name, ".rel", 4) == 0
2753                                 && strcmp (bfd_get_section_name (abfd, sec),
2754                                            name + 4) == 0);
2755
2756                     sreloc = bfd_get_section_by_name (dynobj, name);
2757                     if (sreloc == NULL)
2758                       {
2759                         flagword flags;
2760
2761                         sreloc = bfd_make_section (dynobj, name);
2762                         flags = (SEC_HAS_CONTENTS | SEC_READONLY
2763                                  | SEC_IN_MEMORY | SEC_LINKER_CREATED);
2764                         if ((sec->flags & SEC_ALLOC) != 0)
2765                           flags |= SEC_ALLOC | SEC_LOAD;
2766                         if (sreloc == NULL
2767                             || ! bfd_set_section_flags (dynobj, sreloc, flags)
2768                             || ! bfd_set_section_alignment (dynobj, sreloc, 2))
2769                           return false;
2770                       }
2771                   if (sec->flags & SEC_READONLY)
2772                     info->flags |= DF_TEXTREL;
2773                   }
2774
2775                 sreloc->_raw_size += sizeof (Elf32_External_Rel);
2776                 /* If we are linking with -Bsymbolic, and this is a
2777                    global symbol, we count the number of PC relative
2778                    relocations we have entered for this symbol, so that
2779                    we can discard them again if the symbol is later
2780                    defined by a regular object.  Note that this function
2781                    is only called if we are using an elf_i386 linker
2782                    hash table, which means that h is really a pointer to
2783                    an elf_i386_link_hash_entry.  */
2784                 if (h != NULL && info->symbolic
2785                     && ELF32_R_TYPE (rel->r_info) == R_ARM_PC24)
2786                   {
2787                     struct elf32_arm_link_hash_entry * eh;
2788                     struct elf32_arm_pcrel_relocs_copied * p;
2789
2790                     eh = (struct elf32_arm_link_hash_entry *) h;
2791
2792                     for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next)
2793                       if (p->section == sreloc)
2794                         break;
2795
2796                     if (p == NULL)
2797                       {
2798                         p = ((struct elf32_arm_pcrel_relocs_copied *)
2799                              bfd_alloc (dynobj, (bfd_size_type) sizeof * p));
2800                         if (p == NULL)
2801                           return false;
2802                         p->next = eh->pcrel_relocs_copied;
2803                         eh->pcrel_relocs_copied = p;
2804                         p->section = sreloc;
2805                         p->count = 0;
2806                       }
2807
2808                     ++p->count;
2809                   }
2810               }
2811             break;
2812
2813         /* This relocation describes the C++ object vtable hierarchy.
2814            Reconstruct it for later use during GC.  */
2815         case R_ARM_GNU_VTINHERIT:
2816           if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2817             return false;
2818           break;
2819
2820         /* This relocation describes which C++ vtable entries are actually
2821            used.  Record for later use during GC.  */
2822         case R_ARM_GNU_VTENTRY:
2823           if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_offset))
2824             return false;
2825           break;
2826         }
2827     }
2828
2829   return true;
2830 }
2831
2832 /* Find the nearest line to a particular section and offset, for error
2833    reporting.   This code is a duplicate of the code in elf.c, except
2834    that it also accepts STT_ARM_TFUNC as a symbol that names a function.  */
2835
2836 static boolean
2837 elf32_arm_find_nearest_line
2838   (abfd, section, symbols, offset, filename_ptr, functionname_ptr, line_ptr)
2839      bfd *          abfd;
2840      asection *     section;
2841      asymbol **     symbols;
2842      bfd_vma        offset;
2843      const char **  filename_ptr;
2844      const char **  functionname_ptr;
2845      unsigned int * line_ptr;
2846 {
2847   boolean      found;
2848   const char * filename;
2849   asymbol *    func;
2850   bfd_vma      low_func;
2851   asymbol **   p;
2852
2853   if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
2854                                      filename_ptr, functionname_ptr,
2855                                      line_ptr, 0,
2856                                      &elf_tdata (abfd)->dwarf2_find_line_info))
2857     return true;
2858
2859   if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
2860                                              &found, filename_ptr,
2861                                              functionname_ptr, line_ptr,
2862                                              &elf_tdata (abfd)->line_info))
2863     return false;
2864
2865   if (found)
2866     return true;
2867
2868   if (symbols == NULL)
2869     return false;
2870
2871   filename = NULL;
2872   func = NULL;
2873   low_func = 0;
2874
2875   for (p = symbols; *p != NULL; p++)
2876     {
2877       elf_symbol_type *q;
2878
2879       q = (elf_symbol_type *) *p;
2880
2881       if (bfd_get_section (&q->symbol) != section)
2882         continue;
2883
2884       switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
2885         {
2886         default:
2887           break;
2888         case STT_FILE:
2889           filename = bfd_asymbol_name (&q->symbol);
2890           break;
2891         case STT_NOTYPE:
2892         case STT_FUNC:
2893         case STT_ARM_TFUNC:
2894           if (q->symbol.section == section
2895               && q->symbol.value >= low_func
2896               && q->symbol.value <= offset)
2897             {
2898               func = (asymbol *) q;
2899               low_func = q->symbol.value;
2900             }
2901           break;
2902         }
2903     }
2904
2905   if (func == NULL)
2906     return false;
2907
2908   *filename_ptr = filename;
2909   *functionname_ptr = bfd_asymbol_name (func);
2910   *line_ptr = 0;
2911
2912   return true;
2913 }
2914
2915 /* Adjust a symbol defined by a dynamic object and referenced by a
2916    regular object.  The current definition is in some section of the
2917    dynamic object, but we're not including those sections.  We have to
2918    change the definition to something the rest of the link can
2919    understand.  */
2920
2921 static boolean
2922 elf32_arm_adjust_dynamic_symbol (info, h)
2923      struct bfd_link_info * info;
2924      struct elf_link_hash_entry * h;
2925 {
2926   bfd * dynobj;
2927   asection * s;
2928   unsigned int power_of_two;
2929
2930   dynobj = elf_hash_table (info)->dynobj;
2931
2932   /* Make sure we know what is going on here.  */
2933   BFD_ASSERT (dynobj != NULL
2934               && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
2935                   || h->weakdef != NULL
2936                   || ((h->elf_link_hash_flags
2937                        & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2938                       && (h->elf_link_hash_flags
2939                           & ELF_LINK_HASH_REF_REGULAR) != 0
2940                       && (h->elf_link_hash_flags
2941                           & ELF_LINK_HASH_DEF_REGULAR) == 0)));
2942
2943   /* If this is a function, put it in the procedure linkage table.  We
2944      will fill in the contents of the procedure linkage table later,
2945      when we know the address of the .got section.  */
2946   if (h->type == STT_FUNC
2947       || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
2948     {
2949       if (! info->shared
2950           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
2951           && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0)
2952         {
2953           /* This case can occur if we saw a PLT32 reloc in an input
2954              file, but the symbol was never referred to by a dynamic
2955              object.  In such a case, we don't actually need to build
2956              a procedure linkage table, and we can just do a PC32
2957              reloc instead.  */
2958           BFD_ASSERT ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0);
2959           return true;
2960         }
2961
2962       /* Make sure this symbol is output as a dynamic symbol.  */
2963       if (h->dynindx == -1)
2964         {
2965           if (! bfd_elf32_link_record_dynamic_symbol (info, h))
2966             return false;
2967         }
2968
2969       s = bfd_get_section_by_name (dynobj, ".plt");
2970       BFD_ASSERT (s != NULL);
2971
2972       /* If this is the first .plt entry, make room for the special
2973          first entry.  */
2974       if (s->_raw_size == 0)
2975         s->_raw_size += PLT_ENTRY_SIZE;
2976
2977       /* If this symbol is not defined in a regular file, and we are
2978          not generating a shared library, then set the symbol to this
2979          location in the .plt.  This is required to make function
2980          pointers compare as equal between the normal executable and
2981          the shared library.  */
2982       if (! info->shared
2983           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2984         {
2985           h->root.u.def.section = s;
2986           h->root.u.def.value = s->_raw_size;
2987         }
2988
2989       h->plt.offset = s->_raw_size;
2990
2991       /* Make room for this entry.  */
2992       s->_raw_size += PLT_ENTRY_SIZE;
2993
2994       /* We also need to make an entry in the .got.plt section, which
2995          will be placed in the .got section by the linker script.  */
2996       s = bfd_get_section_by_name (dynobj, ".got.plt");
2997       BFD_ASSERT (s != NULL);
2998       s->_raw_size += 4;
2999
3000       /* We also need to make an entry in the .rel.plt section.  */
3001
3002       s = bfd_get_section_by_name (dynobj, ".rel.plt");
3003       BFD_ASSERT (s != NULL);
3004       s->_raw_size += sizeof (Elf32_External_Rel);
3005
3006       return true;
3007     }
3008
3009   /* If this is a weak symbol, and there is a real definition, the
3010      processor independent code will have arranged for us to see the
3011      real definition first, and we can just use the same value.  */
3012   if (h->weakdef != NULL)
3013     {
3014       BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
3015                   || h->weakdef->root.type == bfd_link_hash_defweak);
3016       h->root.u.def.section = h->weakdef->root.u.def.section;
3017       h->root.u.def.value = h->weakdef->root.u.def.value;
3018       return true;
3019     }
3020
3021   /* This is a reference to a symbol defined by a dynamic object which
3022      is not a function.  */
3023
3024   /* If we are creating a shared library, we must presume that the
3025      only references to the symbol are via the global offset table.
3026      For such cases we need not do anything here; the relocations will
3027      be handled correctly by relocate_section.  */
3028   if (info->shared)
3029     return true;
3030
3031   /* We must allocate the symbol in our .dynbss section, which will
3032      become part of the .bss section of the executable.  There will be
3033      an entry for this symbol in the .dynsym section.  The dynamic
3034      object will contain position independent code, so all references
3035      from the dynamic object to this symbol will go through the global
3036      offset table.  The dynamic linker will use the .dynsym entry to
3037      determine the address it must put in the global offset table, so
3038      both the dynamic object and the regular object will refer to the
3039      same memory location for the variable.  */
3040   s = bfd_get_section_by_name (dynobj, ".dynbss");
3041   BFD_ASSERT (s != NULL);
3042
3043   /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
3044      copy the initial value out of the dynamic object and into the
3045      runtime process image.  We need to remember the offset into the
3046      .rel.bss section we are going to use.  */
3047   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
3048     {
3049       asection *srel;
3050
3051       srel = bfd_get_section_by_name (dynobj, ".rel.bss");
3052       BFD_ASSERT (srel != NULL);
3053       srel->_raw_size += sizeof (Elf32_External_Rel);
3054       h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
3055     }
3056
3057   /* We need to figure out the alignment required for this symbol.  I
3058      have no idea how ELF linkers handle this.  */
3059   power_of_two = bfd_log2 (h->size);
3060   if (power_of_two > 3)
3061     power_of_two = 3;
3062
3063   /* Apply the required alignment.  */
3064   s->_raw_size = BFD_ALIGN (s->_raw_size,
3065                             (bfd_size_type) (1 << power_of_two));
3066   if (power_of_two > bfd_get_section_alignment (dynobj, s))
3067     {
3068       if (! bfd_set_section_alignment (dynobj, s, power_of_two))
3069         return false;
3070     }
3071
3072   /* Define the symbol as being at this point in the section.  */
3073   h->root.u.def.section = s;
3074   h->root.u.def.value = s->_raw_size;
3075
3076   /* Increment the section size to make room for the symbol.  */
3077   s->_raw_size += h->size;
3078
3079   return true;
3080 }
3081
3082 /* Set the sizes of the dynamic sections.  */
3083
3084 static boolean
3085 elf32_arm_size_dynamic_sections (output_bfd, info)
3086      bfd * output_bfd ATTRIBUTE_UNUSED;
3087      struct bfd_link_info * info;
3088 {
3089   bfd * dynobj;
3090   asection * s;
3091   boolean plt;
3092   boolean relocs;
3093
3094   dynobj = elf_hash_table (info)->dynobj;
3095   BFD_ASSERT (dynobj != NULL);
3096
3097   if (elf_hash_table (info)->dynamic_sections_created)
3098     {
3099       /* Set the contents of the .interp section to the interpreter.  */
3100       if (! info->shared)
3101         {
3102           s = bfd_get_section_by_name (dynobj, ".interp");
3103           BFD_ASSERT (s != NULL);
3104           s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
3105           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3106         }
3107     }
3108   else
3109     {
3110       /* We may have created entries in the .rel.got section.
3111          However, if we are not creating the dynamic sections, we will
3112          not actually use these entries.  Reset the size of .rel.got,
3113          which will cause it to get stripped from the output file
3114          below.  */
3115       s = bfd_get_section_by_name (dynobj, ".rel.got");
3116       if (s != NULL)
3117         s->_raw_size = 0;
3118     }
3119
3120   /* If this is a -Bsymbolic shared link, then we need to discard all
3121      PC relative relocs against symbols defined in a regular object.
3122      We allocated space for them in the check_relocs routine, but we
3123      will not fill them in in the relocate_section routine.  */
3124   if (info->shared && info->symbolic)
3125     elf32_arm_link_hash_traverse (elf32_arm_hash_table (info),
3126                                   elf32_arm_discard_copies,
3127                                   (PTR) NULL);
3128
3129   /* The check_relocs and adjust_dynamic_symbol entry points have
3130      determined the sizes of the various dynamic sections.  Allocate
3131      memory for them.  */
3132   plt = false;
3133   relocs = false;
3134   for (s = dynobj->sections; s != NULL; s = s->next)
3135     {
3136       const char * name;
3137       boolean strip;
3138
3139       if ((s->flags & SEC_LINKER_CREATED) == 0)
3140         continue;
3141
3142       /* It's OK to base decisions on the section name, because none
3143          of the dynobj section names depend upon the input files.  */
3144       name = bfd_get_section_name (dynobj, s);
3145
3146       strip = false;
3147
3148       if (strcmp (name, ".plt") == 0)
3149         {
3150           if (s->_raw_size == 0)
3151             {
3152               /* Strip this section if we don't need it; see the
3153                  comment below.  */
3154               strip = true;
3155             }
3156           else
3157             {
3158               /* Remember whether there is a PLT.  */
3159               plt = true;
3160             }
3161         }
3162       else if (strncmp (name, ".rel", 4) == 0)
3163         {
3164           if (s->_raw_size == 0)
3165             {
3166               /* If we don't need this section, strip it from the
3167                  output file.  This is mostly to handle .rel.bss and
3168                  .rel.plt.  We must create both sections in
3169                  create_dynamic_sections, because they must be created
3170                  before the linker maps input sections to output
3171                  sections.  The linker does that before
3172                  adjust_dynamic_symbol is called, and it is that
3173                  function which decides whether anything needs to go
3174                  into these sections.  */
3175               strip = true;
3176             }
3177           else
3178             {
3179               /* Remember whether there are any reloc sections other
3180                  than .rel.plt.  */
3181               if (strcmp (name, ".rel.plt") != 0)
3182                 relocs = true;
3183
3184               /* We use the reloc_count field as a counter if we need
3185                  to copy relocs into the output file.  */
3186               s->reloc_count = 0;
3187             }
3188         }
3189       else if (strncmp (name, ".got", 4) != 0)
3190         {
3191           /* It's not one of our sections, so don't allocate space.  */
3192           continue;
3193         }
3194
3195       if (strip)
3196         {
3197           asection ** spp;
3198
3199           for (spp = &s->output_section->owner->sections;
3200                *spp != NULL;
3201                spp = &(*spp)->next)
3202             {
3203               if (*spp == s->output_section)
3204                 {
3205                   bfd_section_list_remove (s->output_section->owner, spp);
3206                   --s->output_section->owner->section_count;
3207                   break;
3208                 }
3209             }
3210           continue;
3211         }
3212
3213       /* Allocate memory for the section contents.  */
3214       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
3215       if (s->contents == NULL && s->_raw_size != 0)
3216         return false;
3217     }
3218
3219   if (elf_hash_table (info)->dynamic_sections_created)
3220     {
3221       /* Add some entries to the .dynamic section.  We fill in the
3222          values later, in elf32_arm_finish_dynamic_sections, but we
3223          must add the entries now so that we get the correct size for
3224          the .dynamic section.  The DT_DEBUG entry is filled in by the
3225          dynamic linker and used by the debugger.  */
3226 #define add_dynamic_entry(TAG, VAL) \
3227   bfd_elf32_add_dynamic_entry (info, (bfd_vma) (TAG), (bfd_vma) (VAL))
3228
3229       if (!info->shared)
3230         {
3231           if (!add_dynamic_entry (DT_DEBUG, 0))
3232             return false;
3233         }
3234
3235       if (plt)
3236         {
3237           if (   !add_dynamic_entry (DT_PLTGOT, 0)
3238               || !add_dynamic_entry (DT_PLTRELSZ, 0)
3239               || !add_dynamic_entry (DT_PLTREL, DT_REL)
3240               || !add_dynamic_entry (DT_JMPREL, 0))
3241             return false;
3242         }
3243
3244       if (relocs)
3245         {
3246           if (   !add_dynamic_entry (DT_REL, 0)
3247               || !add_dynamic_entry (DT_RELSZ, 0)
3248               || !add_dynamic_entry (DT_RELENT, sizeof (Elf32_External_Rel)))
3249             return false;
3250         }
3251
3252       if ((info->flags & DF_TEXTREL) != 0)
3253         {
3254           if (!add_dynamic_entry (DT_TEXTREL, 0))
3255             return false;
3256           info->flags |= DF_TEXTREL;
3257         }
3258     }
3259 #undef add_synamic_entry
3260
3261   return true;
3262 }
3263
3264 /* This function is called via elf32_arm_link_hash_traverse if we are
3265    creating a shared object with -Bsymbolic.  It discards the space
3266    allocated to copy PC relative relocs against symbols which are
3267    defined in regular objects.  We allocated space for them in the
3268    check_relocs routine, but we won't fill them in in the
3269    relocate_section routine.  */
3270
3271 static boolean
3272 elf32_arm_discard_copies (h, ignore)
3273      struct elf32_arm_link_hash_entry * h;
3274      PTR ignore ATTRIBUTE_UNUSED;
3275 {
3276   struct elf32_arm_pcrel_relocs_copied * s;
3277
3278   /* We only discard relocs for symbols defined in a regular object.  */
3279   if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
3280     return true;
3281
3282   for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
3283     s->section->_raw_size -= s->count * sizeof (Elf32_External_Rel);
3284
3285   return true;
3286 }
3287
3288 /* Finish up dynamic symbol handling.  We set the contents of various
3289    dynamic sections here.  */
3290
3291 static boolean
3292 elf32_arm_finish_dynamic_symbol (output_bfd, info, h, sym)
3293      bfd * output_bfd;
3294      struct bfd_link_info * info;
3295      struct elf_link_hash_entry * h;
3296      Elf_Internal_Sym * sym;
3297 {
3298   bfd * dynobj;
3299
3300   dynobj = elf_hash_table (info)->dynobj;
3301
3302   if (h->plt.offset != (bfd_vma) -1)
3303     {
3304       asection * splt;
3305       asection * sgot;
3306       asection * srel;
3307       bfd_vma plt_index;
3308       bfd_vma got_offset;
3309       Elf_Internal_Rel rel;
3310
3311       /* This symbol has an entry in the procedure linkage table.  Set
3312          it up.  */
3313
3314       BFD_ASSERT (h->dynindx != -1);
3315
3316       splt = bfd_get_section_by_name (dynobj, ".plt");
3317       sgot = bfd_get_section_by_name (dynobj, ".got.plt");
3318       srel = bfd_get_section_by_name (dynobj, ".rel.plt");
3319       BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
3320
3321       /* Get the index in the procedure linkage table which
3322          corresponds to this symbol.  This is the index of this symbol
3323          in all the symbols for which we are making plt entries.  The
3324          first entry in the procedure linkage table is reserved.  */
3325       plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
3326
3327       /* Get the offset into the .got table of the entry that
3328          corresponds to this function.  Each .got entry is 4 bytes.
3329          The first three are reserved.  */
3330       got_offset = (plt_index + 3) * 4;
3331
3332       /* Fill in the entry in the procedure linkage table.  */
3333       bfd_put_32 (output_bfd, elf32_arm_plt_entry[0],
3334                   splt->contents + h->plt.offset + 0);
3335       bfd_put_32 (output_bfd, elf32_arm_plt_entry[1],
3336                   splt->contents + h->plt.offset + 4);
3337       bfd_put_32 (output_bfd, elf32_arm_plt_entry[2],
3338                   splt->contents + h->plt.offset + 8);
3339       bfd_put_32 (output_bfd,
3340                       (sgot->output_section->vma
3341                        + sgot->output_offset
3342                        + got_offset
3343                        - splt->output_section->vma
3344                        - splt->output_offset
3345                        - h->plt.offset - 12),
3346                       splt->contents + h->plt.offset + 12);
3347
3348       /* Fill in the entry in the global offset table.  */
3349       bfd_put_32 (output_bfd,
3350                   (splt->output_section->vma
3351                    + splt->output_offset),
3352                   sgot->contents + got_offset);
3353
3354       /* Fill in the entry in the .rel.plt section.  */
3355       rel.r_offset = (sgot->output_section->vma
3356                       + sgot->output_offset
3357                       + got_offset);
3358       rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_JUMP_SLOT);
3359       bfd_elf32_swap_reloc_out (output_bfd, &rel,
3360                                 ((Elf32_External_Rel *) srel->contents
3361                                  + plt_index));
3362
3363       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
3364         {
3365           /* Mark the symbol as undefined, rather than as defined in
3366              the .plt section.  Leave the value alone.  */
3367           sym->st_shndx = SHN_UNDEF;
3368           /* If the symbol is weak, we do need to clear the value.
3369              Otherwise, the PLT entry would provide a definition for
3370              the symbol even if the symbol wasn't defined anywhere,
3371              and so the symbol would never be NULL.  */
3372           if ((h->elf_link_hash_flags & ELF_LINK_HASH_REF_REGULAR_NONWEAK)
3373               == 0)
3374             sym->st_value = 0;
3375         }
3376     }
3377
3378   if (h->got.offset != (bfd_vma) -1)
3379     {
3380       asection * sgot;
3381       asection * srel;
3382       Elf_Internal_Rel rel;
3383
3384       /* This symbol has an entry in the global offset table.  Set it
3385          up.  */
3386       sgot = bfd_get_section_by_name (dynobj, ".got");
3387       srel = bfd_get_section_by_name (dynobj, ".rel.got");
3388       BFD_ASSERT (sgot != NULL && srel != NULL);
3389
3390       rel.r_offset = (sgot->output_section->vma
3391                       + sgot->output_offset
3392                       + (h->got.offset &~ (bfd_vma) 1));
3393
3394       /* If this is a -Bsymbolic link, and the symbol is defined
3395          locally, we just want to emit a RELATIVE reloc.  The entry in
3396          the global offset table will already have been initialized in
3397          the relocate_section function.  */
3398       if (info->shared
3399           && (info->symbolic || h->dynindx == -1)
3400           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
3401         rel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
3402       else
3403         {
3404           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
3405           rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT);
3406         }
3407
3408       bfd_elf32_swap_reloc_out (output_bfd, &rel,
3409                                 ((Elf32_External_Rel *) srel->contents
3410                                  + srel->reloc_count));
3411       ++srel->reloc_count;
3412     }
3413
3414   if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
3415     {
3416       asection * s;
3417       Elf_Internal_Rel rel;
3418
3419       /* This symbol needs a copy reloc.  Set it up.  */
3420       BFD_ASSERT (h->dynindx != -1
3421                   && (h->root.type == bfd_link_hash_defined
3422                       || h->root.type == bfd_link_hash_defweak));
3423
3424       s = bfd_get_section_by_name (h->root.u.def.section->owner,
3425                                    ".rel.bss");
3426       BFD_ASSERT (s != NULL);
3427
3428       rel.r_offset = (h->root.u.def.value
3429                       + h->root.u.def.section->output_section->vma
3430                       + h->root.u.def.section->output_offset);
3431       rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_COPY);
3432       bfd_elf32_swap_reloc_out (output_bfd, &rel,
3433                                 ((Elf32_External_Rel *) s->contents
3434                                  + s->reloc_count));
3435       ++s->reloc_count;
3436     }
3437
3438   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
3439   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3440       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
3441     sym->st_shndx = SHN_ABS;
3442
3443   return true;
3444 }
3445
3446 /* Finish up the dynamic sections.  */
3447
3448 static boolean
3449 elf32_arm_finish_dynamic_sections (output_bfd, info)
3450      bfd * output_bfd;
3451      struct bfd_link_info * info;
3452 {
3453   bfd * dynobj;
3454   asection * sgot;
3455   asection * sdyn;
3456
3457   dynobj = elf_hash_table (info)->dynobj;
3458
3459   sgot = bfd_get_section_by_name (dynobj, ".got.plt");
3460   BFD_ASSERT (sgot != NULL);
3461   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3462
3463   if (elf_hash_table (info)->dynamic_sections_created)
3464     {
3465       asection *splt;
3466       Elf32_External_Dyn *dyncon, *dynconend;
3467
3468       splt = bfd_get_section_by_name (dynobj, ".plt");
3469       BFD_ASSERT (splt != NULL && sdyn != NULL);
3470
3471       dyncon = (Elf32_External_Dyn *) sdyn->contents;
3472       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
3473
3474       for (; dyncon < dynconend; dyncon++)
3475         {
3476           Elf_Internal_Dyn dyn;
3477           const char * name;
3478           asection * s;
3479
3480           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3481
3482           switch (dyn.d_tag)
3483             {
3484             default:
3485               break;
3486
3487             case DT_PLTGOT:
3488               name = ".got";
3489               goto get_vma;
3490             case DT_JMPREL:
3491               name = ".rel.plt";
3492             get_vma:
3493               s = bfd_get_section_by_name (output_bfd, name);
3494               BFD_ASSERT (s != NULL);
3495               dyn.d_un.d_ptr = s->vma;
3496               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3497               break;
3498
3499             case DT_PLTRELSZ:
3500               s = bfd_get_section_by_name (output_bfd, ".rel.plt");
3501               BFD_ASSERT (s != NULL);
3502               if (s->_cooked_size != 0)
3503                 dyn.d_un.d_val = s->_cooked_size;
3504               else
3505                 dyn.d_un.d_val = s->_raw_size;
3506               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3507               break;
3508
3509             case DT_RELSZ:
3510               /* My reading of the SVR4 ABI indicates that the
3511                  procedure linkage table relocs (DT_JMPREL) should be
3512                  included in the overall relocs (DT_REL).  This is
3513                  what Solaris does.  However, UnixWare can not handle
3514                  that case.  Therefore, we override the DT_RELSZ entry
3515                  here to make it not include the JMPREL relocs.  Since
3516                  the linker script arranges for .rel.plt to follow all
3517                  other relocation sections, we don't have to worry
3518                  about changing the DT_REL entry.  */
3519               s = bfd_get_section_by_name (output_bfd, ".rel.plt");
3520               if (s != NULL)
3521                 {
3522                   if (s->_cooked_size != 0)
3523                     dyn.d_un.d_val -= s->_cooked_size;
3524                   else
3525                     dyn.d_un.d_val -= s->_raw_size;
3526                 }
3527               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3528               break;
3529             }
3530         }
3531
3532       /* Fill in the first entry in the procedure linkage table.  */
3533       if (splt->_raw_size > 0)
3534         {
3535           bfd_put_32 (output_bfd, elf32_arm_plt0_entry[0], splt->contents +  0);
3536           bfd_put_32 (output_bfd, elf32_arm_plt0_entry[1], splt->contents +  4);
3537           bfd_put_32 (output_bfd, elf32_arm_plt0_entry[2], splt->contents +  8);
3538           bfd_put_32 (output_bfd, elf32_arm_plt0_entry[3], splt->contents + 12);
3539         }
3540
3541       /* UnixWare sets the entsize of .plt to 4, although that doesn't
3542          really seem like the right value.  */
3543       elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
3544     }
3545
3546   /* Fill in the first three entries in the global offset table.  */
3547   if (sgot->_raw_size > 0)
3548     {
3549       if (sdyn == NULL)
3550         bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
3551       else
3552         bfd_put_32 (output_bfd,
3553                     sdyn->output_section->vma + sdyn->output_offset,
3554                     sgot->contents);
3555       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
3556       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
3557     }
3558
3559   elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
3560
3561   return true;
3562 }
3563
3564 static void
3565 elf32_arm_post_process_headers (abfd, link_info)
3566      bfd * abfd;
3567      struct bfd_link_info * link_info ATTRIBUTE_UNUSED;
3568 {
3569   Elf_Internal_Ehdr * i_ehdrp;  /* ELF file header, internal form.  */
3570
3571   i_ehdrp = elf_elfheader (abfd);
3572
3573   i_ehdrp->e_ident[EI_OSABI]      = ARM_ELF_OS_ABI_VERSION;
3574   i_ehdrp->e_ident[EI_ABIVERSION] = ARM_ELF_ABI_VERSION;
3575 }
3576
3577 static enum elf_reloc_type_class
3578 elf32_arm_reloc_type_class (rela)
3579      const Elf_Internal_Rela *rela;
3580 {
3581   switch ((int) ELF32_R_TYPE (rela->r_info))
3582     {
3583     case R_ARM_RELATIVE:
3584       return reloc_class_relative;
3585     case R_ARM_JUMP_SLOT:
3586       return reloc_class_plt;
3587     case R_ARM_COPY:
3588       return reloc_class_copy;
3589     default:
3590       return reloc_class_normal;
3591     }
3592 }
3593
3594
3595 #define ELF_ARCH                        bfd_arch_arm
3596 #define ELF_MACHINE_CODE                EM_ARM
3597 #define ELF_MAXPAGESIZE                 0x8000
3598
3599 #define bfd_elf32_bfd_copy_private_bfd_data     elf32_arm_copy_private_bfd_data
3600 #define bfd_elf32_bfd_merge_private_bfd_data    elf32_arm_merge_private_bfd_data
3601 #define bfd_elf32_bfd_set_private_flags         elf32_arm_set_private_flags
3602 #define bfd_elf32_bfd_print_private_bfd_data    elf32_arm_print_private_bfd_data
3603 #define bfd_elf32_bfd_link_hash_table_create    elf32_arm_link_hash_table_create
3604 #define bfd_elf32_bfd_reloc_type_lookup         elf32_arm_reloc_type_lookup
3605 #define bfd_elf32_find_nearest_line             elf32_arm_find_nearest_line
3606
3607 #define elf_backend_get_symbol_type             elf32_arm_get_symbol_type
3608 #define elf_backend_gc_mark_hook                elf32_arm_gc_mark_hook
3609 #define elf_backend_gc_sweep_hook               elf32_arm_gc_sweep_hook
3610 #define elf_backend_check_relocs                elf32_arm_check_relocs
3611 #define elf_backend_relocate_section            elf32_arm_relocate_section
3612 #define elf_backend_adjust_dynamic_symbol       elf32_arm_adjust_dynamic_symbol
3613 #define elf_backend_create_dynamic_sections     _bfd_elf_create_dynamic_sections
3614 #define elf_backend_finish_dynamic_symbol       elf32_arm_finish_dynamic_symbol
3615 #define elf_backend_finish_dynamic_sections     elf32_arm_finish_dynamic_sections
3616 #define elf_backend_size_dynamic_sections       elf32_arm_size_dynamic_sections
3617 #define elf_backend_post_process_headers        elf32_arm_post_process_headers
3618 #define elf_backend_reloc_type_class            elf32_arm_reloc_type_class
3619
3620 #define elf_backend_can_gc_sections 1
3621 #define elf_backend_plt_readonly    1
3622 #define elf_backend_want_got_plt    1
3623 #define elf_backend_want_plt_sym    0
3624
3625 #define elf_backend_got_header_size     12
3626 #define elf_backend_plt_header_size     PLT_ENTRY_SIZE
3627
3628 #include "elf32-target.h"