bfd/elf32-arm.h

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