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