bfd/elf32-arm.h

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