bfd/elf32-arm.h

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