bfd/elf32-arm.h

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