bfd/elf32-arm.h

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