bfd/elf32-arm.h

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