bfd/elf32-arm.c

   1 /* 32-bit ELF support for ARM
   2    Copyright 1993, 1995, 1998 Free Software Foundation, Inc.
   3
   4    This file is part of BFD, the Binary File Descriptor library.
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  19
  20 #include "bfd.h"
  21 #include "sysdep.h"
  22 #include "libbfd.h"
  23 #include "elf-bfd.h"
  24
  25 #include "elf/arm.h"
  26
  27 typedef unsigned long int insn32;
  28 typedef unsigned short int insn16;
  29
  30 static reloc_howto_type *elf32_arm_reloc_type_lookup
  31   PARAMS ((bfd * abfd, bfd_reloc_code_real_type code));
  32 static void elf32_arm_info_to_howto
  33   PARAMS ((bfd *, arelent *, Elf32_Internal_Rela *));
  34 static boolean elf32_arm_set_private_flags
  35   PARAMS ((bfd *, flagword));
  36 static boolean elf32_arm_copy_private_bfd_data
  37   PARAMS ((bfd *, bfd *));
  38 static boolean elf32_arm_merge_private_bfd_data
  39   PARAMS ((bfd *, bfd *));
  40 static boolean elf32_arm_print_private_bfd_data
  41   PARAMS ((bfd *, PTR));
  42 static int elf32_arm_get_symbol_type
  43   PARAMS (( Elf_Internal_Sym *, int));
  44 static struct bfd_link_hash_table *elf32_arm_link_hash_table_create
  45   PARAMS ((bfd *));
  46
  47
  48 static insn32 insert_thumb_branch
  49   PARAMS ((insn32, int));
  50 static struct elf_link_hash_entry *find_thumb_glue
  51   PARAMS ((struct bfd_link_info *, CONST char *, bfd *));
  52 static struct elf_link_hash_entry *find_arm_glue
  53   PARAMS ((struct bfd_link_info *, CONST char *, bfd *));
  54 static void record_arm_to_thumb_glue
  55   PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
  56 static void record_thumb_to_arm_glue
  57   PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
  58
  59 /* The linker script knows the section names for placement.
  60    The entry_names are used to do simple name mangling on the stubs.
  61    Given a function name, and its type, the stub can be found. The
  62    name can be changed. The only requirement is the %s be present.
  63  */
  64
  65 #define INTERWORK_FLAG( abfd )   (elf_elfheader (abfd)->e_flags & EF_INTERWORK)
  66
  67 #define THUMB2ARM_GLUE_SECTION_NAME ".glue_7t"
  68 #define THUMB2ARM_GLUE_ENTRY_NAME   "__%s_from_thumb"
  69
  70 #define ARM2THUMB_GLUE_SECTION_NAME ".glue_7"
  71 #define ARM2THUMB_GLUE_ENTRY_NAME   "__%s_from_arm"
  72
  73 /* Get the ARM elf linker hash table from a link_info structure.  */
  74 #define elf32_arm_hash_table(info) \
  75   ((struct elf32_arm_link_hash_table *) ((info)->hash))
  76
  77 /* ARM ELF linker hash table */
  78 struct elf32_arm_link_hash_table
  79   {
  80     /* The main hash table.  */
  81     struct elf_link_hash_table root;
  82
  83     /* The size in bytes of the section containg the Thumb-to-ARM glue.  */
  84     long int thumb_glue_size;
  85
  86     /* The size in bytes of the section containg the ARM-to-Thumb glue.  */
  87     long int arm_glue_size;
  88
  89     /* An arbitary input BFD chosen to hold the glue sections.  */
  90     bfd *bfd_of_glue_owner;
  91
  92   };
  93
  94
  95
  96 /* Create an ARM elf linker hash table */
  97
  98 static struct bfd_link_hash_table *
  99 elf32_arm_link_hash_table_create (abfd)
 100      bfd *abfd;
 101 {
 102   struct elf32_arm_link_hash_table *ret;
 103
 104   ret = ((struct elf32_arm_link_hash_table *)
 105          bfd_alloc (abfd, sizeof (struct elf32_arm_link_hash_table)));
 106   if (ret == (struct elf32_arm_link_hash_table *) NULL)
 107     return NULL;
 108
 109   if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
 110                                       _bfd_elf_link_hash_newfunc))
 111     {
 112       bfd_release (abfd, ret);
 113       return NULL;
 114     }
 115
 116   ret->thumb_glue_size = 0;
 117   ret->arm_glue_size = 0;
 118   ret->bfd_of_glue_owner = NULL;
 119
 120   return &ret->root.root;
 121 }
 122
 123 static struct elf_link_hash_entry *
 124 find_thumb_glue (link_info, name, input_bfd)
 125      struct bfd_link_info *link_info;
 126      CONST char *name;
 127      bfd *input_bfd;
 128 {
 129   char *tmp_name;
 130   struct elf_link_hash_entry *hash;
 131   struct elf32_arm_link_hash_table *hash_table;
 132
 133   /* We need a pointer to the armelf specific hash table.  */
 134   hash_table = elf32_arm_hash_table (link_info);
 135
 136
 137   tmp_name = ((char *)
 138        bfd_malloc (strlen (name) + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1));
 139
 140   BFD_ASSERT (tmp_name);
 141
 142   sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name);
 143
 144   hash = elf_link_hash_lookup
 145     (&(hash_table)->root, tmp_name, false, false, true);
 146
 147   if (hash == NULL)
 148     /* xgettext:c-format */
 149     _bfd_error_handler (_ ("%s: unable to find THUMB glue '%s' for `%s'"),
 150                         bfd_get_filename (input_bfd), tmp_name, name);
 151
 152   free (tmp_name);
 153
 154   return hash;
 155 }
 156
 157 static struct elf_link_hash_entry *
 158 find_arm_glue (link_info, name, input_bfd)
 159      struct bfd_link_info *link_info;
 160      CONST char *name;
 161      bfd *input_bfd;
 162 {
 163   char *tmp_name;
 164   struct elf_link_hash_entry *myh;
 165   struct elf32_arm_link_hash_table *hash_table;
 166
 167   /* We need a pointer to the elfarm specific hash table.  */
 168   hash_table = elf32_arm_hash_table (link_info);
 169
 170   tmp_name = ((char *)
 171        bfd_malloc (strlen (name) + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1));
 172
 173   BFD_ASSERT (tmp_name);
 174
 175   sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
 176
 177   myh = elf_link_hash_lookup
 178     (&(hash_table)->root, tmp_name, false, false, true);
 179
 180   if (myh == NULL)
 181     /* xgettext:c-format */
 182     _bfd_error_handler (_ ("%s: unable to find ARM glue '%s' for `%s'"),
 183                         bfd_get_filename (input_bfd), tmp_name, name);
 184
 185   free (tmp_name);
 186
 187   return myh;
 188 }
 189
 190 /*
 191    ARM->Thumb glue:
 192
 193    .arm
 194    __func_from_arm:
 195    ldr r12, __func_addr
 196    bx  r12
 197    __func_addr:
 198    .word func    @ behave as if you saw a ARM_32 reloc
 199  */
 200
 201 #define ARM2THUMB_GLUE_SIZE 12
 202 static const insn32 a2t1_ldr_insn = 0xe59fc000;
 203 static const insn32 a2t2_bx_r12_insn = 0xe12fff1c;
 204 static const insn32 a2t3_func_addr_insn = 0x00000001;
 205
 206 /*
 207    Thumb->ARM:                          Thumb->(non-interworking aware) ARM
 208
 209    .thumb                               .thumb
 210    .align 2                             .align 2
 211    __func_from_thumb:              __func_from_thumb:
 212    bx pc                                push {r6, lr}
 213    nop                                  ldr  r6, __func_addr
 214    .arm                                         mov  lr, pc
 215    __func_change_to_arm:                        bx   r6
 216    b func                       .arm
 217    __func_back_to_thumb:
 218    ldmia r13! {r6, lr}
 219    bx    lr
 220    __func_addr:
 221    .word        func
 222  */
 223
 224 #define THUMB2ARM_GLUE_SIZE 8
 225 static const insn16 t2a1_bx_pc_insn = 0x4778;
 226 static const insn16 t2a2_noop_insn = 0x46c0;
 227 static const insn32 t2a3_b_insn = 0xea000000;
 228
 229 static const insn16 t2a1_push_insn = 0xb540;
 230 static const insn16 t2a2_ldr_insn = 0x4e03;
 231 static const insn16 t2a3_mov_insn = 0x46fe;
 232 static const insn16 t2a4_bx_insn = 0x4730;
 233 static const insn32 t2a5_pop_insn = 0xe8bd4040;
 234 static const insn32 t2a6_bx_insn = 0xe12fff1e;
 235
 236 boolean
 237 bfd_elf32_arm_allocate_interworking_sections (info)
 238      struct bfd_link_info *info;
 239 {
 240   asection *s;
 241   bfd_byte *foo;
 242   struct elf32_arm_link_hash_table *globals;
 243
 244   globals = elf32_arm_hash_table (info);
 245
 246   BFD_ASSERT (globals != NULL);
 247
 248   if (globals->arm_glue_size != 0)
 249     {
 250       BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
 251
 252       s = bfd_get_section_by_name
 253         (globals->bfd_of_glue_owner, ARM2THUMB_GLUE_SECTION_NAME);
 254
 255       BFD_ASSERT (s != NULL);
 256
 257       foo = (bfd_byte *) bfd_alloc
 258         (globals->bfd_of_glue_owner, globals->arm_glue_size);
 259
 260       s->_raw_size = s->_cooked_size = globals->arm_glue_size;
 261       s->contents = foo;
 262     }
 263
 264   if (globals->thumb_glue_size != 0)
 265     {
 266       BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
 267
 268       s = bfd_get_section_by_name
 269         (globals->bfd_of_glue_owner, THUMB2ARM_GLUE_SECTION_NAME);
 270
 271       BFD_ASSERT (s != NULL);
 272
 273       foo = (bfd_byte *) bfd_alloc
 274         (globals->bfd_of_glue_owner, globals->thumb_glue_size);
 275
 276       s->_raw_size = s->_cooked_size = globals->thumb_glue_size;
 277       s->contents = foo;
 278     }
 279
 280   return true;
 281 }
 282
 283 static void
 284 record_arm_to_thumb_glue (link_info, h)
 285      struct bfd_link_info *link_info;
 286      struct elf_link_hash_entry *h;
 287 {
 288   const char *name = h->root.root.string;
 289   register asection *s;
 290   char *tmp_name;
 291   struct elf_link_hash_entry *myh;
 292   struct elf32_arm_link_hash_table *globals;
 293
 294   globals = elf32_arm_hash_table (link_info);
 295
 296   BFD_ASSERT (globals != NULL);
 297   BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
 298
 299   s = bfd_get_section_by_name
 300     (globals->bfd_of_glue_owner, ARM2THUMB_GLUE_SECTION_NAME);
 301
 302
 303   BFD_ASSERT (s != NULL);
 304
 305   tmp_name = ((char *)
 306        bfd_malloc (strlen (name) + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1));
 307
 308   BFD_ASSERT (tmp_name);
 309
 310   sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
 311
 312   myh = elf_link_hash_lookup
 313     (&(globals)->root, tmp_name, false, false, true);
 314
 315   if (myh != NULL)
 316     {
 317       free (tmp_name);
 318       return;                   /* we've already seen this guy */
 319     }
 320
 321   /* The only trick here is using hash_table->arm_glue_size as the value. Even
 322      though the section isn't allocated yet, this is where we will be putting
 323      it.  */
 324
 325   _bfd_generic_link_add_one_symbol (link_info, globals->bfd_of_glue_owner, tmp_name,
 326                                     BSF_GLOBAL,
 327                                     s, globals->arm_glue_size + 1,
 328                                     NULL, true, false,
 329                                     (struct bfd_link_hash_entry **) &myh);
 330
 331   free (tmp_name);
 332
 333   globals->arm_glue_size += ARM2THUMB_GLUE_SIZE;
 334
 335   return;
 336 }
 337
 338 static void
 339 record_thumb_to_arm_glue (link_info, h)
 340      struct bfd_link_info *link_info;
 341      struct elf_link_hash_entry *h;
 342 {
 343   const char *name = h->root.root.string;
 344   register asection *s;
 345   char *tmp_name;
 346   struct elf_link_hash_entry *myh;
 347   struct elf32_arm_link_hash_table *hash_table;
 348   char bind;
 349
 350   hash_table = elf32_arm_hash_table (link_info);
 351
 352   BFD_ASSERT (hash_table != NULL);
 353   BFD_ASSERT (hash_table->bfd_of_glue_owner != NULL);
 354
 355   s = bfd_get_section_by_name
 356     (hash_table->bfd_of_glue_owner, THUMB2ARM_GLUE_SECTION_NAME);
 357
 358   BFD_ASSERT (s != NULL);
 359
 360   tmp_name = (char *) bfd_malloc (strlen (name) + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1);
 361
 362   BFD_ASSERT (tmp_name);
 363
 364   sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name);
 365
 366   myh = elf_link_hash_lookup
 367     (&(hash_table)->root, tmp_name, false, false, true);
 368
 369   if (myh != NULL)
 370     {
 371       free (tmp_name);
 372       return;                   /* we've already seen this guy */
 373     }
 374
 375   _bfd_generic_link_add_one_symbol (link_info, hash_table->bfd_of_glue_owner, tmp_name,
 376                              BSF_GLOBAL, s, hash_table->thumb_glue_size + 1,
 377                                     NULL, true, false,
 378                                     (struct bfd_link_hash_entry **) &myh);
 379
 380   /* If we mark it 'thumb', the disassembler will do a better job.  */
 381   bind = ELF_ST_BIND (myh->type);
 382   myh->type = ELF_ST_INFO (bind, STT_ARM_TFUNC);
 383
 384   free (tmp_name);
 385
 386   /* Allocate another symbol to mark where we switch to arm mode.  */
 387
 388 #define CHANGE_TO_ARM "__%s_change_to_arm"
 389 #define BACK_FROM_ARM "__%s_back_from_arm"
 390
 391   tmp_name = (char *) bfd_malloc (strlen (name) + strlen (CHANGE_TO_ARM) + 1);
 392
 393   BFD_ASSERT (tmp_name);
 394
 395   sprintf (tmp_name, CHANGE_TO_ARM, name);
 396
 397   myh = NULL;
 398
 399   _bfd_generic_link_add_one_symbol (link_info, hash_table->bfd_of_glue_owner, tmp_name,
 400                               BSF_LOCAL, s, hash_table->thumb_glue_size + 4,
 401                                     NULL, true, false,
 402                                     (struct bfd_link_hash_entry **) &myh);
 403
 404   free (tmp_name);
 405
 406   hash_table->thumb_glue_size += THUMB2ARM_GLUE_SIZE;
 407
 408   return;
 409 }
 410
 411 /* Select a BFD to be used to hold the sections used by the glue code.
 412    This function is called from the linker scripts in ld/emultempl/
 413    {armelf/pe}.em  */
 414 boolean
 415 bfd_elf32_arm_get_bfd_for_interworking (abfd, info)
 416      bfd *abfd;
 417      struct bfd_link_info *info;
 418 {
 419   struct elf32_arm_link_hash_table *globals;
 420   flagword flags;
 421   asection *sec;
 422
 423   /* If we are only performing a partial link do not bother
 424      getting a bfd to hold the glue.  */
 425   if (info->relocateable)
 426     return true;
 427
 428   globals = elf32_arm_hash_table (info);
 429
 430   BFD_ASSERT (globals != NULL);
 431
 432   if (globals->bfd_of_glue_owner != NULL)
 433     return true;
 434
 435   sec = bfd_get_section_by_name (abfd, ARM2THUMB_GLUE_SECTION_NAME);
 436
 437   if (sec == NULL)
 438     {
 439       flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY;
 440
 441       sec = bfd_make_section (abfd, ARM2THUMB_GLUE_SECTION_NAME);
 442
 443       if (sec == NULL
 444           || !bfd_set_section_flags (abfd, sec, flags)
 445           || !bfd_set_section_alignment (abfd, sec, 2))
 446         return false;
 447     }
 448
 449   sec = bfd_get_section_by_name (abfd, THUMB2ARM_GLUE_SECTION_NAME);
 450
 451   if (sec == NULL)
 452     {
 453       flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY;
 454
 455       sec = bfd_make_section (abfd, THUMB2ARM_GLUE_SECTION_NAME);
 456
 457       if (sec == NULL
 458           || !bfd_set_section_flags (abfd, sec, flags)
 459           || !bfd_set_section_alignment (abfd, sec, 2))
 460         return false;
 461     }
 462
 463   /* Save the bfd for later use.  */
 464   globals->bfd_of_glue_owner = abfd;
 465
 466   return true;
 467 }
 468
 469 boolean
 470 bfd_elf32_arm_process_before_allocation (abfd, link_info)
 471      bfd *abfd;
 472      struct bfd_link_info *link_info;
 473 {
 474   Elf_Internal_Shdr *symtab_hdr;
 475   Elf_Internal_Rela *free_relocs = NULL;
 476   Elf_Internal_Rela *irel, *irelend;
 477   bfd_byte *contents = NULL;
 478   bfd_byte *free_contents = NULL;
 479   Elf32_External_Sym *extsyms = NULL;
 480   Elf32_External_Sym *free_extsyms = NULL;
 481
 482   asection *sec;
 483   struct elf32_arm_link_hash_table *globals;
 484
 485   /* If we are only performing a partial link do not bother
 486      to construct any glue.  */
 487   if (link_info->relocateable)
 488     return true;
 489
 490   /* Here we have a bfd that is to be included on the link.  We have a hook
 491      to do reloc rummaging, before section sizes are nailed down.  */
 492
 493   globals = elf32_arm_hash_table (link_info);
 494
 495   BFD_ASSERT (globals != NULL);
 496   BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
 497
 498   /* Rummage around all the relocs and map the glue vectors.  */
 499   sec = abfd->sections;
 500
 501   if (sec == NULL)
 502     return true;
 503
 504   for (; sec != NULL; sec = sec->next)
 505     {
 506       if (sec->reloc_count == 0)
 507         continue;
 508
 509       symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
 510       /* Load the relocs.  */
 511
 512       irel = (_bfd_elf32_link_read_relocs (abfd, sec, (PTR) NULL,
 513                                         (Elf_Internal_Rela *) NULL, false));
 514
 515       BFD_ASSERT (irel != 0);
 516
 517       irelend = irel + sec->reloc_count;
 518       for (; irel < irelend; irel++)
 519         {
 520           long r_type;
 521           unsigned long r_index;
 522           unsigned char code;
 523
 524           struct elf_link_hash_entry *h;
 525
 526           r_type = ELF32_R_TYPE (irel->r_info);
 527           r_index = ELF32_R_SYM (irel->r_info);
 528
 529           /* These are the only relocation types we care about */
 530           if (r_type != R_ARM_PC24
 531               && r_type != R_ARM_THM_PC22)
 532             continue;
 533
 534           /* Get the section contents if we haven't done so already.  */
 535           if (contents == NULL)
 536             {
 537               /* Get cached copy if it exists.  */
 538               if (elf_section_data (sec)->this_hdr.contents != NULL)
 539                 contents = elf_section_data (sec)->this_hdr.contents;
 540               else
 541                 {
 542                   /* Go get them off disk.  */
 543                   contents = (bfd_byte *) bfd_malloc (sec->_raw_size);
 544                   if (contents == NULL)
 545                     goto error_return;
 546                   free_contents = contents;
 547
 548                   if (!bfd_get_section_contents (abfd, sec, contents,
 549                                               (file_ptr) 0, sec->_raw_size))
 550                     goto error_return;
 551                 }
 552             }
 553
 554           /* Read this BFD's symbols if we haven't done so already.  */
 555           if (extsyms == NULL)
 556             {
 557               /* Get cached copy if it exists.  */
 558               if (symtab_hdr->contents != NULL)
 559                 extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
 560               else
 561                 {
 562                   /* Go get them off disk.  */
 563                   extsyms = ((Elf32_External_Sym *)
 564                              bfd_malloc (symtab_hdr->sh_size));
 565                   if (extsyms == NULL)
 566                     goto error_return;
 567                   free_extsyms = extsyms;
 568                   if (bfd_seek (abfd, symtab_hdr->sh_offset, SEEK_SET) != 0
 569                       || (bfd_read (extsyms, 1, symtab_hdr->sh_size, abfd)
 570                           != symtab_hdr->sh_size))
 571                     goto error_return;
 572                 }
 573             }
 574
 575           /* If the relocation is not against a symbol it cannot concern us. */
 576
 577           h = NULL;
 578
 579           /* We don't care about local symbols */
 580           if (r_index < symtab_hdr->sh_info)
 581             continue;
 582
 583           /* This is an external symbol */
 584           r_index -= symtab_hdr->sh_info;
 585           h = (struct elf_link_hash_entry *)
 586             elf_sym_hashes (abfd)[r_index];
 587
 588           /* If the relocation is against a static symbol it must be within
 589              the current section and so cannot be a cross ARM/Thumb relocation.  */
 590           if (h == NULL)
 591             continue;
 592
 593           switch (r_type)
 594             {
 595             case R_ARM_PC24:
 596               /* This one is a call from arm code.  We need to look up
 597                  the target of the call. If it is a thumb target, we
 598                  insert glue.  */
 599
 600               if (ELF_ST_TYPE(h->type) == STT_ARM_TFUNC)
 601                 record_arm_to_thumb_glue (link_info, h);
 602               break;
 603
 604             case R_ARM_THM_PC22:
 605               /* This one is a call from thumb code.  We look
 606                  up the target of the call. If it is not a thumb
 607                  target, we insert glue. */
 608
 609               if (ELF_ST_TYPE (h->type) != STT_ARM_TFUNC)
 610                 record_thumb_to_arm_glue (link_info, h);
 611               break;
 612
 613             default:
 614               break;
 615             }
 616         }
 617     }
 618
 619   return true;
 620 error_return:
 621   if (free_relocs != NULL)
 622     free (free_relocs);
 623   if (free_contents != NULL)
 624     free (free_contents);
 625   if (free_extsyms != NULL)
 626     free (free_extsyms);
 627   return false;
 628
 629 }
 630
 631 #define USE_RELA
 632 #define TARGET_UNDERSCORE '_'
 633
 634 static reloc_howto_type elf32_arm_howto_table[] =
 635 {
 636   /* No relocation */
 637   HOWTO (R_ARM_NONE,            /* type */
 638          0,                     /* rightshift */
 639          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 640          0,                     /* bitsize */
 641          false,                 /* pc_relative */
 642          0,                     /* bitpos */
 643          complain_overflow_dont,        /* complain_on_overflow */
 644          bfd_elf_generic_reloc, /* special_function */
 645          "R_ARM_NONE",          /* name */
 646          false,                 /* partial_inplace */
 647          0,                     /* src_mask */
 648          0,                     /* dst_mask */
 649          false),                /* pcrel_offset */
 650
 651   HOWTO (R_ARM_PC24,            /* type */
 652          2,                     /* rightshift */
 653          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 654          24,                    /* bitsize */
 655          true,                  /* pc_relative */
 656          0,                     /* bitpos */
 657          complain_overflow_signed,      /* complain_on_overflow */
 658          bfd_elf_generic_reloc, /* special_function */
 659          "R_ARM_PC24",          /* name */
 660          false,                 /* partial_inplace */
 661          0x00ffffff,            /* src_mask */
 662          0x00ffffff,            /* dst_mask */
 663          true),                 /* pcrel_offset */
 664
 665   /* 32 bit absolute */
 666   HOWTO (R_ARM_ABS32,           /* type */
 667          0,                     /* rightshift */
 668          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 669          32,                    /* bitsize */
 670          false,                 /* pc_relative */
 671          0,                     /* bitpos */
 672          complain_overflow_bitfield,    /* complain_on_overflow */
 673          bfd_elf_generic_reloc, /* special_function */
 674          "R_ARM_ABS32",         /* name */
 675          false,                 /* partial_inplace */
 676          0xffffffff,            /* src_mask */
 677          0xffffffff,            /* dst_mask */
 678          false),                /* pcrel_offset */
 679
 680   /* standard 32bit pc-relative reloc */
 681   HOWTO (R_ARM_REL32,           /* type */
 682          0,                     /* rightshift */
 683          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 684          32,                    /* bitsize */
 685          true,                  /* pc_relative */
 686          0,                     /* bitpos */
 687          complain_overflow_bitfield,    /* complain_on_overflow */
 688          bfd_elf_generic_reloc, /* special_function */
 689          "R_ARM_REL32",         /* name */
 690          false,                 /* partial_inplace */
 691          0xffffffff,            /* src_mask */
 692          0xffffffff,            /* dst_mask */
 693          true),                 /* pcrel_offset */
 694
 695   /* 8 bit absolute */
 696   HOWTO (R_ARM_ABS8,            /* type */
 697          0,                     /* rightshift */
 698          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 699          8,                     /* bitsize */
 700          false,                 /* pc_relative */
 701          0,                     /* bitpos */
 702          complain_overflow_bitfield,    /* complain_on_overflow */
 703          bfd_elf_generic_reloc, /* special_function */
 704          "R_ARM_ABS8",          /* name */
 705          false,                 /* partial_inplace */
 706          0x000000ff,            /* src_mask */
 707          0x000000ff,            /* dst_mask */
 708          false),                /* pcrel_offset */
 709
 710    /* 16 bit absolute */
 711   HOWTO (R_ARM_ABS16,           /* type */
 712          0,                     /* rightshift */
 713          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 714          16,                    /* bitsize */
 715          false,                 /* pc_relative */
 716          0,                     /* bitpos */
 717          complain_overflow_bitfield,    /* complain_on_overflow */
 718          bfd_elf_generic_reloc, /* special_function */
 719          "R_ARM_ABS16",         /* name */
 720          false,                 /* partial_inplace */
 721          0,                     /* src_mask */
 722          0,                     /* dst_mask */
 723          false),                /* pcrel_offset */
 724
 725   /* 12 bit absolute */
 726   HOWTO (R_ARM_ABS12,           /* type */
 727          0,                     /* rightshift */
 728          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 729          12,                    /* bitsize */
 730          false,                 /* pc_relative */
 731          0,                     /* bitpos */
 732          complain_overflow_bitfield,    /* complain_on_overflow */
 733          bfd_elf_generic_reloc, /* special_function */
 734          "R_ARM_ABS12",         /* name */
 735          false,                 /* partial_inplace */
 736          0x000008ff,            /* src_mask */
 737          0x000008ff,            /* dst_mask */
 738          false),                /* pcrel_offset */
 739
 740   HOWTO (R_ARM_THM_ABS5,        /* type */
 741          0,                     /* rightshift */
 742          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 743          5,                     /* bitsize */
 744          false,                 /* pc_relative */
 745          0,                     /* bitpos */
 746          complain_overflow_bitfield,    /* complain_on_overflow */
 747          bfd_elf_generic_reloc, /* special_function */
 748          "R_ARM_THM_ABS5",      /* name */
 749          false,                 /* partial_inplace */
 750          0x000007e0,            /* src_mask */
 751          0x000007e0,            /* dst_mask */
 752          false),                /* pcrel_offset */
 753
 754   HOWTO (R_ARM_THM_PC22,        /* type */
 755          1,                     /* rightshift */
 756          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 757          22,                    /* bitsize */
 758          true,                  /* pc_relative */
 759          0,                     /* bitpos */
 760          complain_overflow_signed,      /* complain_on_overflow */
 761          bfd_elf_generic_reloc, /* special_function */
 762          "R_ARM_THM_PC22",      /* name */
 763          false,                 /* partial_inplace */
 764          0x07ff07ff,            /* src_mask */
 765          0x07ff07ff,            /* dst_mask */
 766          true),                 /* pcrel_offset */
 767
 768   HOWTO (R_ARM_SBREL32,         /* type */
 769          0,                     /* rightshift */
 770          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 771          0,                     /* bitsize */
 772          false,                 /* pc_relative */
 773          0,                     /* bitpos */
 774          complain_overflow_dont,        /* complain_on_overflow */
 775          bfd_elf_generic_reloc, /* special_function */
 776          "R_ARM_SBREL32",       /* name */
 777          false,                 /* partial_inplace */
 778          0,                     /* src_mask */
 779          0,                     /* dst_mask */
 780          false),                /* pcrel_offset */
 781
 782   HOWTO (R_ARM_AMP_VCALL9,      /* type */
 783          1,                     /* rightshift */
 784          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 785          8,                     /* bitsize */
 786          true,                  /* pc_relative */
 787          0,                     /* bitpos */
 788          complain_overflow_signed,      /* complain_on_overflow */
 789          bfd_elf_generic_reloc, /* special_function */
 790          "R_ARM_AMP_VCALL9",    /* name */
 791          false,                 /* partial_inplace */
 792          0x000000ff,            /* src_mask */
 793          0x000000ff,            /* dst_mask */
 794          true),                 /* pcrel_offset */
 795
 796   /* 12 bit pc relative */
 797   HOWTO (R_ARM_THM_PC11,        /* type */
 798          1,                     /* rightshift */
 799          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 800          11,                    /* bitsize */
 801          true,                  /* pc_relative */
 802          0,                     /* bitpos */
 803          complain_overflow_signed,      /* complain_on_overflow */
 804          bfd_elf_generic_reloc, /* special_function */
 805          "R_ARM_THM_PC11",      /* name */
 806          false,                 /* partial_inplace */
 807          0x000007ff,            /* src_mask */
 808          0x000007ff,            /* dst_mask */
 809          true),                 /* pcrel_offset */
 810
 811   /* 12 bit pc relative */
 812   HOWTO (R_ARM_THM_PC9,         /* type */
 813          1,                     /* rightshift */
 814          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 815          8,                     /* bitsize */
 816          true,                  /* pc_relative */
 817          0,                     /* bitpos */
 818          complain_overflow_signed,      /* complain_on_overflow */
 819          bfd_elf_generic_reloc, /* special_function */
 820          "R_ARM_THM_PC9",       /* name */
 821          false,                 /* partial_inplace */
 822          0x000000ff,            /* src_mask */
 823          0x000000ff,            /* dst_mask */
 824          true),                 /* pcrel_offset */
 825
 826   /* GNU extension to record C++ vtable hierarchy */
 827   HOWTO (R_ARM_GNU_VTINHERIT, /* type */
 828          0,                     /* rightshift */
 829          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 830          0,                     /* bitsize */
 831          false,                 /* pc_relative */
 832          0,                     /* bitpos */
 833          complain_overflow_dont, /* complain_on_overflow */
 834          NULL,                  /* special_function */
 835          "R_ARM_GNU_VTINHERIT", /* name */
 836          false,                 /* partial_inplace */
 837          0,                     /* src_mask */
 838          0,                     /* dst_mask */
 839          false),                /* pcrel_offset */
 840
 841   /* GNU extension to record C++ vtable member usage */
 842   HOWTO (R_ARM_GNU_VTENTRY,     /* type */
 843          0,                     /* rightshift */
 844          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 845          0,                     /* bitsize */
 846          false,                 /* pc_relative */
 847          0,                     /* bitpos */
 848          complain_overflow_dont, /* complain_on_overflow */
 849          _bfd_elf_rel_vtable_reloc_fn,  /* special_function */
 850          "R_ARM_GNU_VTENTRY",   /* name */
 851          false,                 /* partial_inplace */
 852          0,                     /* src_mask */
 853          0,                     /* dst_mask */
 854          false),                /* pcrel_offset */
 855
 856
 857   HOWTO (R_ARM_RREL32,          /* type */
 858          0,                     /* rightshift */
 859          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 860          0,                     /* bitsize */
 861          false,                 /* pc_relative */
 862          0,                     /* bitpos */
 863          complain_overflow_dont,        /* complain_on_overflow */
 864          bfd_elf_generic_reloc, /* special_function */
 865          "R_ARM_RREL32",        /* name */
 866          false,                 /* partial_inplace */
 867          0,                     /* src_mask */
 868          0,                     /* dst_mask */
 869          false),                /* pcrel_offset */
 870
 871   HOWTO (R_ARM_RABS32,          /* type */
 872          0,                     /* rightshift */
 873          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 874          0,                     /* bitsize */
 875          false,                 /* pc_relative */
 876          0,                     /* bitpos */
 877          complain_overflow_dont,        /* complain_on_overflow */
 878          bfd_elf_generic_reloc, /* special_function */
 879          "R_ARM_RABS32",        /* name */
 880          false,                 /* partial_inplace */
 881          0,                     /* src_mask */
 882          0,                     /* dst_mask */
 883          false),                /* pcrel_offset */
 884
 885   HOWTO (R_ARM_RPC24,           /* type */
 886          0,                     /* rightshift */
 887          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 888          0,                     /* bitsize */
 889          false,                 /* pc_relative */
 890          0,                     /* bitpos */
 891          complain_overflow_dont,        /* complain_on_overflow */
 892          bfd_elf_generic_reloc, /* special_function */
 893          "R_ARM_RPC24",         /* name */
 894          false,                 /* partial_inplace */
 895          0,                     /* src_mask */
 896          0,                     /* dst_mask */
 897          false),                /* pcrel_offset */
 898
 899   HOWTO (R_ARM_RBASE,           /* type */
 900          0,                     /* rightshift */
 901          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 902          0,                     /* bitsize */
 903          false,                 /* pc_relative */
 904          0,                     /* bitpos */
 905          complain_overflow_dont,        /* complain_on_overflow */
 906          bfd_elf_generic_reloc, /* special_function */
 907          "R_ARM_RBASE",         /* name */
 908          false,                 /* partial_inplace */
 909          0,                     /* src_mask */
 910          0,                     /* dst_mask */
 911          false),                /* pcrel_offset */
 912
 913 };
 914 struct elf32_arm_reloc_map
 915   {
 916     unsigned char bfd_reloc_val;
 917     unsigned char elf_reloc_val;
 918   };
 919
 920 static const struct elf32_arm_reloc_map elf32_arm_reloc_map[] =
 921 {
 922   {BFD_RELOC_NONE, R_ARM_NONE,},
 923   {BFD_RELOC_ARM_PCREL_BRANCH, R_ARM_PC24,},
 924   {BFD_RELOC_32, R_ARM_ABS32,},
 925   {BFD_RELOC_32_PCREL, R_ARM_REL32,},
 926   {BFD_RELOC_8, R_ARM_ABS8,},
 927   {BFD_RELOC_16, R_ARM_ABS16,},
 928   {BFD_RELOC_ARM_OFFSET_IMM, R_ARM_ABS12,},
 929   {BFD_RELOC_ARM_THUMB_OFFSET, R_ARM_THM_ABS5,},
 930   {BFD_RELOC_THUMB_PCREL_BRANCH23, R_ARM_THM_PC22,},
 931   {BFD_RELOC_VTABLE_INHERIT, R_ARM_GNU_VTINHERIT },
 932   {BFD_RELOC_VTABLE_ENTRY, R_ARM_GNU_VTENTRY },
 933   {BFD_RELOC_NONE, R_ARM_SBREL32,},
 934   {BFD_RELOC_NONE, R_ARM_AMP_VCALL9,},
 935   {BFD_RELOC_THUMB_PCREL_BRANCH12, R_ARM_THM_PC11,},
 936   {BFD_RELOC_THUMB_PCREL_BRANCH9, R_ARM_THM_PC9,}
 937 };
 938
 939 static reloc_howto_type *
 940 elf32_arm_reloc_type_lookup (abfd, code)
 941      bfd *abfd;
 942      bfd_reloc_code_real_type code;
 943 {
 944   unsigned int i;
 945
 946   for (i = 0;
 947      i < sizeof (elf32_arm_reloc_map) / sizeof (struct elf32_arm_reloc_map);
 948        i++)
 949     {
 950       if (elf32_arm_reloc_map[i].bfd_reloc_val == code)
 951         return &elf32_arm_howto_table[elf32_arm_reloc_map[i].elf_reloc_val];
 952     }
 953
 954   return NULL;
 955 }
 956
 957 static void
 958 elf32_arm_info_to_howto (abfd, bfd_reloc, elf_reloc)
 959      bfd *abfd;
 960      arelent *bfd_reloc;
 961      Elf32_Internal_Rela *elf_reloc;
 962 {
 963   unsigned int r_type;
 964
 965   r_type = ELF32_R_TYPE (elf_reloc->r_info);
 966   /* fixme: need range test */
 967   /* BFD_ASSERT (r_type < (unsigned int) R_ELF32_ARM_MAX); */
 968   bfd_reloc->howto = &elf32_arm_howto_table[r_type];
 969 }
 970
 971 /* The thumb form of a long branch is a bit finicky, because the offset
 972    encoding is split over two fields, each in it's own instruction. They
 973    can occur in any order. So given a thumb form of long branch, and an
 974    offset, insert the offset into the thumb branch and return finished
 975    instruction.
 976
 977    It takes two thumb instructions to encode the target address. Each has
 978    11 bits to invest. The upper 11 bits are stored in one (identifed by
 979    H-0.. see below), the lower 11 bits are stored in the other (identified
 980    by H-1).
 981
 982    Combine together and shifted left by 1 (it's a half word address) and
 983    there you have it.
 984
 985    Op: 1111 = F,
 986    H-0, upper address-0 = 000
 987    Op: 1111 = F,
 988    H-1, lower address-0 = 800
 989
 990    They can be ordered either way, but the arm tools I've seen always put
 991    the lower one first. It probably doesn't matter. krk@cygnus.com
 992
 993    XXX:  Actually the order does matter.  The second instruction (H-1)
 994    moves the computed address into the PC, so it must be the second one
 995    in the sequence.  The problem, however is that whilst little endian code
 996    stores the instructions in HI then LOW order, big endian code does the
 997    reverse.  nickc@cygnus.com  */
 998
 999 #define LOW_HI_ORDER 0xF800F000
1000 #define HI_LOW_ORDER 0xF000F800
1001
1002 static insn32
1003 insert_thumb_branch (br_insn, rel_off)
1004      insn32 br_insn;
1005      int rel_off;
1006 {
1007   unsigned int low_bits;
1008   unsigned int high_bits;
1009
1010
1011   BFD_ASSERT ((rel_off & 1) != 1);
1012
1013   rel_off >>= 1;                /* half word aligned address */
1014   low_bits = rel_off & 0x000007FF;      /* the bottom 11 bits */
1015   high_bits = (rel_off >> 11) & 0x000007FF;     /* the top 11 bits */
1016
1017   if ((br_insn & LOW_HI_ORDER) == LOW_HI_ORDER)
1018     br_insn = LOW_HI_ORDER | (low_bits << 16) | high_bits;
1019   else if ((br_insn & HI_LOW_ORDER) == HI_LOW_ORDER)
1020     br_insn = HI_LOW_ORDER | (high_bits << 16) | low_bits;
1021   else
1022     abort ();                   /* error - not a valid branch instruction form */
1023
1024   /* FIXME: abort is probably not the right call. krk@cygnus.com */
1025
1026   return br_insn;
1027 }
1028
1029 /* Thumb code calling an ARM function */
1030 int
1031 elf32_thumb_to_arm_stub (info, name, input_bfd, output_bfd, input_section,
1032                          hit_data, sym_sec, offset, addend, val)
1033      struct bfd_link_info *info;
1034      char *name;
1035      bfd *input_bfd;
1036      bfd *output_bfd;
1037      asection *input_section;
1038      bfd_byte *hit_data;
1039      asection *sym_sec;
1040      int offset;
1041      int addend;
1042      bfd_vma val;
1043 {
1044   asection *s = 0;
1045   long int my_offset;
1046   unsigned long int tmp;
1047   long int ret_offset;
1048   struct elf_link_hash_entry *myh;
1049   struct elf32_arm_link_hash_table *globals;
1050
1051   myh = find_thumb_glue (info, name, input_bfd);
1052   if (myh == NULL)
1053     return false;
1054
1055   globals = elf32_arm_hash_table (info);
1056
1057   BFD_ASSERT (globals != NULL);
1058   BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
1059
1060   my_offset = myh->root.u.def.value;
1061
1062   s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
1063                                THUMB2ARM_GLUE_SECTION_NAME);
1064
1065   BFD_ASSERT (s != NULL);
1066   BFD_ASSERT (s->contents != NULL);
1067   BFD_ASSERT (s->output_section != NULL);
1068
1069   if ((my_offset & 0x01) == 0x01)
1070     {
1071       if (sym_sec != NULL
1072           && sym_sec->owner != NULL
1073           && !INTERWORK_FLAG (sym_sec->owner))
1074         {
1075           _bfd_error_handler
1076             (_ ("%s(%s): warning: interworking not enabled."),
1077              bfd_get_filename (sym_sec->owner), name);
1078           _bfd_error_handler
1079             (_ ("  first occurrence: %s: thumb call to arm"),
1080              bfd_get_filename (input_bfd));
1081
1082           return false;
1083         }
1084
1085       --my_offset;
1086       myh->root.u.def.value = my_offset;
1087
1088       bfd_put_16 (output_bfd, t2a1_bx_pc_insn,
1089                   s->contents + my_offset);
1090
1091       bfd_put_16 (output_bfd, t2a2_noop_insn,
1092                   s->contents + my_offset + 2);
1093
1094       ret_offset =
1095         ((bfd_signed_vma) val)  /* Address of destination of the stub */
1096         - ((bfd_signed_vma)
1097            (s->output_offset    /* Offset from the start of the current section to the start of the stubs.  */
1098             + my_offset         /* Offset of the start of this stub from the start of the stubs.  */
1099             + s->output_section->vma)   /* Address of the start of the current section.  */
1100            + 4                  /* The branch instruction is 4 bytes into the stub.  */
1101            + 8);                /* ARM branches work from the pc of the instruction + 8.  */
1102
1103       bfd_put_32 (output_bfd,
1104                   t2a3_b_insn | ((ret_offset >> 2) & 0x00FFFFFF),
1105                   s->contents + my_offset + 4);
1106     }
1107
1108   BFD_ASSERT (my_offset <= globals->thumb_glue_size);
1109
1110   /* Now go back and fix up the original BL insn to point
1111      to here.  */
1112   ret_offset =
1113     s->output_offset
1114     + my_offset
1115     - (input_section->output_offset
1116        + offset + addend)
1117     - 4;
1118
1119   tmp = bfd_get_32 (input_bfd, hit_data
1120                     - input_section->vma);
1121
1122   bfd_put_32 (output_bfd,
1123               insert_thumb_branch (tmp, ret_offset),
1124               hit_data - input_section->vma);
1125
1126   return true;
1127 }
1128
1129 /* Arm code calling a Thumb function */
1130 int
1131 elf32_arm_to_thumb_stub (info, name, input_bfd, output_bfd, input_section,
1132                          hit_data, sym_sec, offset, addend, val)
1133
1134      struct bfd_link_info *info;
1135      char *name;
1136      bfd *input_bfd;
1137      bfd *output_bfd;
1138      asection *input_section;
1139      bfd_byte *hit_data;
1140      asection *sym_sec;
1141      int offset;
1142      int addend;
1143      bfd_vma val;
1144 {
1145   unsigned long int tmp;
1146   long int my_offset;
1147   asection *s;
1148   long int ret_offset;
1149   struct elf_link_hash_entry *myh;
1150   struct elf32_arm_link_hash_table *globals;
1151
1152   myh = find_arm_glue (info, name, input_bfd);
1153   if (myh == NULL)
1154     return false;
1155
1156   globals = elf32_arm_hash_table (info);
1157
1158   BFD_ASSERT (globals != NULL);
1159   BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
1160
1161   my_offset = myh->root.u.def.value;
1162   s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
1163                                ARM2THUMB_GLUE_SECTION_NAME);
1164   BFD_ASSERT (s != NULL);
1165   BFD_ASSERT (s->contents != NULL);
1166   BFD_ASSERT (s->output_section != NULL);
1167
1168   if ((my_offset & 0x01) == 0x01)
1169     {
1170       if (sym_sec != NULL
1171           && sym_sec->owner != NULL
1172           && !INTERWORK_FLAG (sym_sec->owner))
1173         {
1174           _bfd_error_handler
1175             (_ ("%s(%s): warning: interworking not enabled."),
1176              bfd_get_filename (sym_sec->owner), name);
1177           _bfd_error_handler
1178             (_ ("  first occurrence: %s: arm call to thumb"),
1179              bfd_get_filename (input_bfd));
1180         }
1181       --my_offset;
1182       myh->root.u.def.value = my_offset;
1183
1184       bfd_put_32 (output_bfd, a2t1_ldr_insn,
1185                   s->contents + my_offset);
1186
1187       bfd_put_32 (output_bfd, a2t2_bx_r12_insn,
1188                   s->contents + my_offset + 4);
1189
1190       /* It's a thumb address.  Add the low order bit.  */
1191       bfd_put_32 (output_bfd, val | a2t3_func_addr_insn,
1192                   s->contents + my_offset + 8);
1193     }
1194
1195   BFD_ASSERT (my_offset <= globals->arm_glue_size);
1196
1197   tmp = bfd_get_32 (input_bfd, hit_data);
1198   tmp = tmp & 0xFF000000;
1199
1200   /* Somehow these are both 4 too far, so subtract 8. */
1201   ret_offset = s->output_offset
1202     + my_offset
1203     + s->output_section->vma
1204     - (input_section->output_offset
1205        + input_section->output_section->vma
1206        + offset + addend)
1207     - 8;
1208
1209   tmp = tmp | ((ret_offset >> 2) & 0x00FFFFFF);
1210
1211   bfd_put_32 (output_bfd, tmp, hit_data
1212               - input_section->vma);
1213
1214
1215   return true;
1216 }
1217
1218 /* Perform a relocation as part of a final link.  */
1219 static bfd_reloc_status_type
1220 elf32_arm_final_link_relocate (howto, input_bfd, output_bfd,
1221                                input_section, contents, offset, value,
1222                                addend, info, sym_sec, sym_name, sym_flags)
1223      reloc_howto_type *howto;
1224      bfd *input_bfd;
1225      bfd *output_bfd;
1226      asection *input_section;
1227      bfd_byte *contents;
1228      bfd_vma offset;
1229      bfd_vma value;
1230      bfd_vma addend;
1231      struct bfd_link_info *info;
1232      asection *sym_sec;
1233      const char *sym_name;
1234      unsigned char sym_flags;
1235 {
1236   unsigned long r_type = howto->type;
1237   bfd_byte *hit_data = contents + offset;
1238
1239   switch (r_type)
1240     {
1241
1242     case R_ARM_NONE:
1243       return bfd_reloc_ok;
1244
1245     case R_ARM_PC24:
1246       /* Arm B/BL instruction */
1247
1248       /* check for arm calling thumb function */
1249       if (sym_flags == STT_ARM_TFUNC)
1250         {
1251           elf32_arm_to_thumb_stub (info, sym_name, input_bfd, output_bfd,
1252                    input_section, hit_data, sym_sec, offset, addend, value);
1253           return bfd_reloc_ok;
1254         }
1255
1256       value = value + addend;
1257       value -= (input_section->output_section->vma
1258                 + input_section->output_offset + 8);
1259       value -= offset;
1260       value = value >> howto->rightshift;
1261
1262       value &= 0xffffff;
1263       value |= (bfd_get_32 (input_bfd, hit_data) & 0xff000000);
1264       bfd_put_32 (input_bfd, value, hit_data);
1265       return bfd_reloc_ok;
1266
1267     case R_ARM_ABS32:
1268       value += addend;
1269       if (sym_flags == STT_ARM_TFUNC)
1270         value |= 1;
1271       bfd_put_32 (input_bfd, value, hit_data);
1272       return bfd_reloc_ok;
1273
1274     case R_ARM_REL32:
1275       value -= (input_section->output_section->vma
1276                 + input_section->output_offset);
1277       value += addend;
1278
1279       bfd_put_32 (input_bfd, value, hit_data);
1280       return bfd_reloc_ok;
1281
1282     case R_ARM_ABS8:
1283       value += addend;
1284
1285       if ((long) value > 0x7f || (long) value < -0x80)
1286         return bfd_reloc_overflow;
1287
1288       bfd_put_8 (input_bfd, value, hit_data);
1289       return bfd_reloc_ok;
1290
1291     case R_ARM_ABS16:
1292       value += addend;
1293
1294       if ((long) value > 0x7fff || (long) value < -0x8000)
1295         return bfd_reloc_overflow;
1296
1297       bfd_put_16 (input_bfd, value, hit_data);
1298       return bfd_reloc_ok;
1299
1300     case R_ARM_ABS12:
1301       /* Support ldr and str instruction for the arm */
1302       /* Also thumb b (unconditional branch) */
1303       value += addend;
1304
1305       if ((long) value > 0x7ff || (long) value < -0x800)
1306         return bfd_reloc_overflow;
1307
1308       value |= (bfd_get_32 (input_bfd, hit_data) & 0xfffff000);
1309       bfd_put_32 (input_bfd, value, hit_data);
1310       return bfd_reloc_ok;
1311
1312     case R_ARM_THM_ABS5:
1313       /* Support ldr and str instructions for the thumb. */
1314       value += addend;
1315
1316       if ((long) value > 0x1f || (long) value < -0x10)
1317         return bfd_reloc_overflow;
1318
1319       value |= bfd_get_16 (input_bfd, hit_data) & 0xf82f;
1320       bfd_put_16 (input_bfd, value, hit_data);
1321       return bfd_reloc_ok;
1322
1323
1324     case R_ARM_THM_PC22:
1325       /* thumb BL (branch long instruction). */
1326       {
1327         bfd_vma relocation;
1328         boolean overflow = false;
1329         bfd_vma insn = bfd_get_32 (input_bfd, hit_data);
1330         bfd_vma src_mask = 0x007FFFFE;
1331         bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
1332         bfd_signed_vma reloc_signed_min = ~reloc_signed_max;
1333         bfd_vma check;
1334         bfd_signed_vma signed_check;
1335         bfd_vma add;
1336         bfd_signed_vma signed_add;
1337
1338         /* If it's not a call to thumb, assume call to arm */
1339         if (sym_flags != STT_ARM_TFUNC)
1340           {
1341             if (elf32_thumb_to_arm_stub
1342                 (info, sym_name, input_bfd, output_bfd, input_section,
1343                  hit_data, sym_sec, offset, addend, value))
1344               return bfd_reloc_ok;
1345             else
1346               return bfd_reloc_dangerous;
1347           }
1348
1349         relocation = value + addend;
1350         relocation -= (input_section->output_section->vma + input_section->output_offset);
1351         relocation -= offset;
1352
1353         check = relocation >> howto->rightshift;
1354
1355         /* If this is a signed value, the rightshift just dropped
1356            leading 1 bits (assuming twos complement).  */
1357         if ((bfd_signed_vma) relocation >= 0)
1358           signed_check = check;
1359         else
1360           signed_check = (check | ((bfd_vma) - 1 & ~((bfd_vma) - 1 >> howto->rightshift)));
1361
1362         /* Get the value from the object file.  */
1363         if (bfd_big_endian (input_bfd))
1364           add = (((insn) & 0x07ff0000) >> 4) | (((insn) & 0x7ff) << 1);
1365         else
1366           add = ((((insn) & 0x7ff) << 12) | (((insn) & 0x07ff0000) >> 15));
1367
1368         /* Get the value from the object file with an appropriate sign.
1369            The expression involving howto->src_mask isolates the upper
1370            bit of src_mask.  If that bit is set in the value we are
1371            adding, it is negative, and we subtract out that number times
1372            two.  If src_mask includes the highest possible bit, then we
1373            can not get the upper bit, but that does not matter since
1374            signed_add needs no adjustment to become negative in that case.  */
1375
1376         signed_add = add;
1377
1378         if ((add & (((~src_mask) >> 1) & src_mask)) != 0)
1379           signed_add -= (((~src_mask) >> 1) & src_mask) << 1;
1380
1381         /* Add the value from the object file, shifted so that it is a
1382            straight number.  */
1383         /* howto->bitpos == 0 */
1384
1385         signed_check += signed_add;
1386         relocation += signed_add;
1387
1388         /* Assumes two's complement.  */
1389         if (signed_check > reloc_signed_max
1390             || signed_check < reloc_signed_min)
1391           overflow = true;
1392
1393         /* Put RELOCATION into the correct bits:  */
1394
1395         if (bfd_big_endian (input_bfd))
1396           relocation = (((relocation & 0xffe) >> 1) | ((relocation << 4) & 0x07ff0000));
1397         else
1398           relocation = (((relocation & 0xffe) << 15) | ((relocation >> 12) & 0x7ff));
1399
1400         /* Add RELOCATION to the correct bits of X:  */
1401         insn = ((insn & ~howto->dst_mask) | relocation);
1402
1403         /* Put the relocated value back in the object file:  */
1404         bfd_put_32 (input_bfd, insn, hit_data);
1405
1406         return (overflow ? bfd_reloc_overflow : bfd_reloc_ok);
1407       }
1408       break;
1409
1410     case R_ARM_GNU_VTINHERIT:
1411     case R_ARM_GNU_VTENTRY:
1412       return bfd_reloc_ok;
1413
1414     case R_ARM_SBREL32:
1415       return bfd_reloc_notsupported;
1416
1417     case R_ARM_AMP_VCALL9:
1418       return bfd_reloc_notsupported;
1419
1420     case R_ARM_RSBREL32:
1421       return bfd_reloc_notsupported;
1422
1423     case R_ARM_THM_RPC22:
1424       return bfd_reloc_notsupported;
1425
1426     case R_ARM_RREL32:
1427       return bfd_reloc_notsupported;
1428
1429     case R_ARM_RABS32:
1430       return bfd_reloc_notsupported;
1431
1432     case R_ARM_RPC24:
1433       return bfd_reloc_notsupported;
1434
1435     case R_ARM_RBASE:
1436       return bfd_reloc_notsupported;
1437
1438     default:
1439       return bfd_reloc_notsupported;
1440     }
1441 }
1442
1443
1444 /* Relocate an ARM ELF section.  */
1445 static boolean
1446 elf32_arm_relocate_section (output_bfd, info, input_bfd, input_section,
1447                             contents, relocs, local_syms, local_sections)
1448      bfd *output_bfd;
1449      struct bfd_link_info *info;
1450      bfd *input_bfd;
1451      asection *input_section;
1452      bfd_byte *contents;
1453      Elf_Internal_Rela *relocs;
1454      Elf_Internal_Sym *local_syms;
1455      asection **local_sections;
1456 {
1457   Elf_Internal_Shdr *symtab_hdr;
1458   struct elf_link_hash_entry **sym_hashes;
1459   Elf_Internal_Rela *rel, *relend;
1460   const char *name;
1461
1462   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1463   sym_hashes = elf_sym_hashes (input_bfd);
1464
1465   rel = relocs;
1466   relend = relocs + input_section->reloc_count;
1467   for (; rel < relend; rel++)
1468     {
1469       int r_type;
1470       reloc_howto_type *howto;
1471       unsigned long r_symndx;
1472       Elf_Internal_Sym *sym;
1473       asection *sec;
1474       struct elf_link_hash_entry *h;
1475       bfd_vma relocation;
1476       bfd_reloc_status_type r;
1477
1478       r_symndx = ELF32_R_SYM (rel->r_info);
1479       r_type = ELF32_R_TYPE (rel->r_info);
1480
1481       if (r_type == R_ARM_GNU_VTENTRY
1482           || r_type == R_ARM_GNU_VTINHERIT )
1483         continue;
1484
1485       howto = elf32_arm_howto_table + r_type;
1486
1487       if (info->relocateable)
1488         {
1489           /* This is a relocateable link.  We don't have to change
1490              anything, unless the reloc is against a section symbol,
1491              in which case we have to adjust according to where the
1492              section symbol winds up in the output section.  */
1493           if (r_symndx < symtab_hdr->sh_info)
1494             {
1495               sym = local_syms + r_symndx;
1496               if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1497                 {
1498                   sec = local_sections[r_symndx];
1499                   rel->r_addend += sec->output_offset + sym->st_value;
1500                 }
1501             }
1502
1503           continue;
1504         }
1505
1506       /* This is a final link.  */
1507       h = NULL;
1508       sym = NULL;
1509       sec = NULL;
1510       if (r_symndx < symtab_hdr->sh_info)
1511         {
1512           sym = local_syms + r_symndx;
1513           sec = local_sections[r_symndx];
1514           relocation = (sec->output_section->vma
1515                         + sec->output_offset
1516                         + sym->st_value);
1517         }
1518       else
1519         {
1520           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1521           while (h->root.type == bfd_link_hash_indirect
1522                  || h->root.type == bfd_link_hash_warning)
1523             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1524           if (h->root.type == bfd_link_hash_defined
1525               || h->root.type == bfd_link_hash_defweak)
1526             {
1527               sec = h->root.u.def.section;
1528               relocation = (h->root.u.def.value
1529                             + sec->output_section->vma
1530                             + sec->output_offset);
1531             }
1532           else if (h->root.type == bfd_link_hash_undefweak)
1533             relocation = 0;
1534           else
1535             {
1536               if (!((*info->callbacks->undefined_symbol)
1537                     (info, h->root.root.string, input_bfd,
1538                      input_section, rel->r_offset)))
1539                 return false;
1540               relocation = 0;
1541             }
1542         }
1543
1544       if (h != NULL)
1545         name = h->root.root.string;
1546       else
1547         {
1548           name = (bfd_elf_string_from_elf_section
1549                   (input_bfd, symtab_hdr->sh_link, sym->st_name));
1550           if (name == NULL || *name == '\0')
1551             name = bfd_section_name (input_bfd, sec);
1552         }
1553
1554       r = elf32_arm_final_link_relocate (howto, input_bfd, output_bfd,
1555                                          input_section,
1556                                          contents, rel->r_offset,
1557                                          relocation, rel->r_addend,
1558                                          info, sec, name,
1559                                          (h ? ELF_ST_TYPE (h->type) :
1560                                           ELF_ST_TYPE (sym->st_info)));
1561
1562       if (r != bfd_reloc_ok)
1563         {
1564           const char * msg = (const char *) 0;
1565
1566           switch (r)
1567             {
1568             case bfd_reloc_overflow:
1569               if (!((*info->callbacks->reloc_overflow)
1570                     (info, name, howto->name, (bfd_vma) 0,
1571                      input_bfd, input_section, rel->r_offset)))
1572                 return false;
1573               break;
1574
1575             case bfd_reloc_undefined:
1576               if (!((*info->callbacks->undefined_symbol)
1577                     (info, name, input_bfd, input_section,
1578                      rel->r_offset)))
1579                 return false;
1580               break;
1581
1582             case bfd_reloc_outofrange:
1583               msg = _ ("internal error: out of range error");
1584               goto common_error;
1585
1586             case bfd_reloc_notsupported:
1587               msg = _ ("internal error: unsupported relocation error");
1588               goto common_error;
1589
1590             case bfd_reloc_dangerous:
1591               msg = _ ("internal error: dangerous error");
1592               goto common_error;
1593
1594             default:
1595               msg = _ ("internal error: unknown error");
1596               /* fall through */
1597
1598             common_error:
1599               if (!((*info->callbacks->warning)
1600                     (info, msg, name, input_bfd, input_section,
1601                      rel->r_offset)))
1602                 return false;
1603               break;
1604             }
1605         }
1606     }
1607
1608   return true;
1609 }
1610
1611 /* Function to keep ARM specific flags in the ELF header. */
1612 static boolean
1613 elf32_arm_set_private_flags (abfd, flags)
1614      bfd *abfd;
1615      flagword flags;
1616 {
1617   if (elf_flags_init (abfd)
1618       && elf_elfheader (abfd)->e_flags != flags)
1619     {
1620       if (flags & EF_INTERWORK)
1621         _bfd_error_handler (_ ("\
1622 Warning: Not setting interwork flag of %s since it has already been specified as non-interworking"),
1623                             bfd_get_filename (abfd));
1624       else
1625         _bfd_error_handler (_ ("\
1626 Warning: Clearing the interwork flag of %s due to outside request"),
1627                             bfd_get_filename (abfd));
1628     }
1629   else
1630     {
1631       elf_elfheader (abfd)->e_flags = flags;
1632       elf_flags_init (abfd) = true;
1633     }
1634
1635   return true;
1636 }
1637
1638 /* Copy backend specific data from one object module to another */
1639 static boolean
1640 elf32_arm_copy_private_bfd_data (ibfd, obfd)
1641      bfd *ibfd;
1642      bfd *obfd;
1643 {
1644   flagword in_flags;
1645   flagword out_flags;
1646
1647   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1648       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1649     return true;
1650
1651   in_flags = elf_elfheader (ibfd)->e_flags;
1652   out_flags = elf_elfheader (obfd)->e_flags;
1653
1654   if (elf_flags_init (obfd) && in_flags != out_flags)
1655     {
1656       /* Cannot mix PIC and non-PIC code.  */
1657       if ((in_flags & EF_PIC) != (out_flags & EF_PIC))
1658         return false;
1659
1660       /* Cannot mix APCS26 and APCS32 code.  */
1661       if ((in_flags & EF_APCS_26) != (out_flags & EF_APCS_26))
1662         return false;
1663
1664       /* Cannot mix float APCS and non-float APCS code.  */
1665       if ((in_flags & EF_APCS_FLOAT) != (out_flags & EF_APCS_FLOAT))
1666         return false;
1667
1668       /* If the src and dest have different interworking flags
1669          then turn off the interworking bit.  */
1670       if ((in_flags & EF_INTERWORK) != (out_flags & EF_INTERWORK))
1671         {
1672           if (out_flags & EF_INTERWORK)
1673             _bfd_error_handler (_ ("\
1674 Warning: Clearing the interwork flag in %s because non-interworking code in %s has been linked with it"),
1675                           bfd_get_filename (obfd), bfd_get_filename (ibfd));
1676
1677           in_flags &= ~EF_INTERWORK;
1678         }
1679     }
1680
1681   elf_elfheader (obfd)->e_flags = in_flags;
1682   elf_flags_init (obfd) = true;
1683
1684   return true;
1685 }
1686
1687 /* Merge backend specific data from an object file to the output
1688    object file when linking.  */
1689 static boolean
1690 elf32_arm_merge_private_bfd_data (ibfd, obfd)
1691      bfd *ibfd;
1692      bfd *obfd;
1693 {
1694   flagword out_flags;
1695   flagword in_flags;
1696
1697   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1698       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1699     return true;
1700
1701   /* The input BFD must have had its flags initialised.  */
1702   /* The following seems bogus to me -- The flags are initialized in
1703      the assembler but I don't think an elf_flags_init field is
1704      written into the object */
1705   /* BFD_ASSERT (elf_flags_init (ibfd)); */
1706
1707   in_flags = elf_elfheader (ibfd)->e_flags;
1708   out_flags = elf_elfheader (obfd)->e_flags;
1709
1710   if (!elf_flags_init (obfd))
1711     {
1712       /* If the input is the default architecture then do not
1713          bother setting the flags for the output architecture,
1714          instead allow future merges to do this.  If no future
1715          merges ever set these flags then they will retain their
1716          unitialised values, which surprise surprise, correspond
1717          to the default values.  */
1718       if (bfd_get_arch_info (ibfd)->the_default)
1719         return true;
1720
1721       elf_flags_init (obfd) = true;
1722       elf_elfheader (obfd)->e_flags = in_flags;
1723
1724       if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
1725           && bfd_get_arch_info (obfd)->the_default)
1726         return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
1727
1728       return true;
1729     }
1730
1731   /* Check flag compatibility.  */
1732   if (in_flags == out_flags)
1733     return true;
1734
1735   /* Complain about various flag mismatches.  */
1736
1737   if ((in_flags & EF_APCS_26) != (out_flags & EF_APCS_26))
1738     _bfd_error_handler (_ ("\
1739 Error: %s compiled for APCS-%d, whereas %s is compiled for APCS-%d"),
1740                         bfd_get_filename (ibfd),
1741                         in_flags & EF_APCS_26 ? 26 : 32,
1742                         bfd_get_filename (obfd),
1743                         out_flags & EF_APCS_26 ? 26 : 32);
1744
1745   if ((in_flags & EF_APCS_FLOAT) != (out_flags & EF_APCS_FLOAT))
1746     _bfd_error_handler (_ ("\
1747 Error: %s passes floats in %s registers, whereas %s passes them in %s registers"),
1748                         bfd_get_filename (ibfd),
1749                      in_flags & EF_APCS_FLOAT ? _ ("float") : _ ("integer"),
1750                         bfd_get_filename (obfd),
1751                       out_flags & EF_APCS_26 ? _ ("float") : _ ("integer"));
1752
1753   if ((in_flags & EF_PIC) != (out_flags & EF_PIC))
1754     _bfd_error_handler (_ ("\
1755 Error: %s is compiled as position %s code, whereas %s is not"),
1756                         bfd_get_filename (ibfd),
1757                     in_flags & EF_PIC ? _ ("independent") : _ ("dependent"),
1758                         bfd_get_filename (obfd));
1759
1760   /* Interworking mismatch is only a warning. */
1761   if ((in_flags & EF_INTERWORK) != (out_flags & EF_INTERWORK))
1762     {
1763       _bfd_error_handler (_ ("\
1764 Warning: %s %s interworking, whereas %s %s"),
1765                           bfd_get_filename (ibfd),
1766           in_flags & EF_INTERWORK ? _ ("supports") : _ ("does not support"),
1767                           bfd_get_filename (obfd),
1768                     out_flags & EF_INTERWORK ? _ ("does not") : _ ("does"));
1769       return true;
1770     }
1771
1772   return false;
1773 }
1774
1775 /* Display the flags field */
1776 static boolean
1777 elf32_arm_print_private_bfd_data (abfd, ptr)
1778      bfd *abfd;
1779      PTR ptr;
1780 {
1781   FILE *file = (FILE *) ptr;
1782
1783   BFD_ASSERT (abfd != NULL && ptr != NULL);
1784
1785   /* Print normal ELF private data.  */
1786   _bfd_elf_print_private_bfd_data (abfd, ptr);
1787
1788   /* Ignore init flag - it may not be set, despite the flags field containing valid data.  */
1789
1790   /* xgettext:c-format */
1791   fprintf (file, _ ("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
1792
1793   if (elf_elfheader (abfd)->e_flags & EF_INTERWORK)
1794     fprintf (file, _ (" [interworking enabled]"));
1795   else
1796     fprintf (file, _ (" [interworking not enabled]"));
1797
1798   if (elf_elfheader (abfd)->e_flags & EF_APCS_26)
1799     fprintf (file, _ (" [APCS-26]"));
1800   else
1801     fprintf (file, _ (" [APCS-32]"));
1802
1803   if (elf_elfheader (abfd)->e_flags & EF_APCS_FLOAT)
1804     fprintf (file, _ (" [floats passed in float registers]"));
1805   else
1806     fprintf (file, _ (" [floats passed in integer registers]"));
1807
1808   if (elf_elfheader (abfd)->e_flags & EF_PIC)
1809     fprintf (file, _ (" [position independent]"));
1810   else
1811     fprintf (file, _ (" [absolute position]"));
1812
1813   fputc ('\n', file);
1814
1815   return true;
1816 }
1817
1818 static int
1819 elf32_arm_get_symbol_type (elf_sym, type)
1820      Elf_Internal_Sym * elf_sym;
1821      int type;
1822 {
1823   if (ELF_ST_TYPE (elf_sym->st_info) == STT_ARM_TFUNC)
1824     return ELF_ST_TYPE (elf_sym->st_info);
1825   else
1826     return type;
1827 }
1828
1829 static asection *
1830 elf32_arm_gc_mark_hook (abfd, info, rel, h, sym)
1831        bfd *abfd;
1832        struct bfd_link_info *info;
1833        Elf_Internal_Rela *rel;
1834        struct elf_link_hash_entry *h;
1835        Elf_Internal_Sym *sym;
1836 {
1837   if (h != NULL)
1838     {
1839       switch (ELF32_R_TYPE (rel->r_info))
1840       {
1841       case R_ARM_GNU_VTINHERIT:
1842       case R_ARM_GNU_VTENTRY:
1843         break;
1844
1845       default:
1846         printf("h is %s\n", h->root.root.string);
1847         switch (h->root.type)
1848           {
1849           case bfd_link_hash_defined:
1850           case bfd_link_hash_defweak:
1851             return h->root.u.def.section;
1852
1853           case bfd_link_hash_common:
1854             return h->root.u.c.p->section;
1855           }
1856        }
1857      }
1858    else
1859      {
1860        if (!(elf_bad_symtab (abfd)
1861            && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
1862          && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
1863                 && sym->st_shndx != SHN_COMMON))
1864           {
1865             return bfd_section_from_elf_index (abfd, sym->st_shndx);
1866           }
1867       }
1868   return NULL;
1869 }
1870
1871 static boolean
1872 elf32_arm_gc_sweep_hook (abfd, info, sec, relocs)
1873      bfd *abfd;
1874      struct bfd_link_info *info;
1875      asection *sec;
1876      const Elf_Internal_Rela *relocs;
1877 {
1878   /* we don't use got and plt entries for armelf */
1879   return true;
1880 }
1881
1882 /* Look through the relocs for a section during the first phase.
1883    Since we don't do .gots or .plts, we just need to consider the
1884    virtual table relocs for gc.  */
1885
1886 static boolean
1887 elf32_arm_check_relocs (abfd, info, sec, relocs)
1888      bfd *abfd;
1889      struct bfd_link_info *info;
1890      asection *sec;
1891      const Elf_Internal_Rela *relocs;
1892 {
1893   Elf_Internal_Shdr *symtab_hdr;
1894   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
1895   const Elf_Internal_Rela *rel;
1896   const Elf_Internal_Rela *rel_end;
1897
1898   if (info->relocateable)
1899     return true;
1900
1901   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1902   sym_hashes = elf_sym_hashes (abfd);
1903   sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof(Elf32_External_Sym);
1904   if (!elf_bad_symtab (abfd))
1905     sym_hashes_end -= symtab_hdr->sh_info;
1906
1907   rel_end = relocs + sec->reloc_count;
1908   for (rel = relocs; rel < rel_end; rel++)
1909     {
1910       struct elf_link_hash_entry *h;
1911       unsigned long r_symndx;
1912
1913       r_symndx = ELF32_R_SYM (rel->r_info);
1914       if (r_symndx < symtab_hdr->sh_info)
1915         h = NULL;
1916       else
1917         h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1918
1919       switch (ELF32_R_TYPE (rel->r_info))
1920         {
1921         /* This relocation describes the C++ object vtable hierarchy.
1922            Reconstruct it for later use during GC.  */
1923         case R_ARM_GNU_VTINHERIT:
1924           if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1925             return false;
1926           break;
1927
1928         /* This relocation describes which C++ vtable entries are actually
1929            used.  Record for later use during GC.  */
1930         case R_ARM_GNU_VTENTRY:
1931           if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1932             return false;
1933           break;
1934         }
1935     }
1936
1937   return true;
1938 }
1939
1940
1941 /* Find the nearest line to a particular section and offset, for error
1942    reporting.   This code is a duplicate of the code in elf.c, except
1943    that it also accepts STT_ARM_TFUNC as a symbol that names a function. */
1944
1945 boolean
1946 elf32_arm_find_nearest_line
1947   (abfd, section, symbols, offset, filename_ptr, functionname_ptr, line_ptr)
1948      bfd *          abfd;
1949      asection *     section;
1950      asymbol **     symbols;
1951      bfd_vma        offset;
1952      CONST char **  filename_ptr;
1953      CONST char **  functionname_ptr;
1954      unsigned int * line_ptr;
1955 {
1956   boolean      found;
1957   const char * filename;
1958   asymbol *    func;
1959   bfd_vma      low_func;
1960   asymbol **   p;
1961
1962   if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
1963                                      filename_ptr, functionname_ptr,
1964                                      line_ptr))
1965     return true;
1966
1967   if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
1968                                              &found, filename_ptr,
1969                                              functionname_ptr, line_ptr,
1970                                              &elf_tdata (abfd)->line_info))
1971     return false;
1972
1973   if (found)
1974     return true;
1975
1976   if (symbols == NULL)
1977     return false;
1978
1979   filename = NULL;
1980   func = NULL;
1981   low_func = 0;
1982
1983   for (p = symbols; *p != NULL; p++)
1984     {
1985       elf_symbol_type *q;
1986
1987       q = (elf_symbol_type *) *p;
1988
1989       if (bfd_get_section (&q->symbol) != section)
1990         continue;
1991
1992       switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
1993         {
1994         default:
1995           break;
1996         case STT_FILE:
1997           filename = bfd_asymbol_name (&q->symbol);
1998           break;
1999         case STT_NOTYPE:
2000         case STT_FUNC:
2001         case STT_ARM_TFUNC:
2002           if (q->symbol.section == section
2003               && q->symbol.value >= low_func
2004               && q->symbol.value <= offset)
2005             {
2006               func = (asymbol *) q;
2007               low_func = q->symbol.value;
2008             }
2009           break;
2010         }
2011     }
2012
2013   if (func == NULL)
2014     return false;
2015
2016   *filename_ptr = filename;
2017   *functionname_ptr = bfd_asymbol_name (func);
2018   *line_ptr = 0;
2019
2020   return true;
2021 }
2022
2023
2024 #define TARGET_LITTLE_SYM               bfd_elf32_littlearm_vec
2025 #define TARGET_LITTLE_NAME              "elf32-littlearm"
2026 #define TARGET_BIG_SYM                  bfd_elf32_bigarm_vec
2027 #define TARGET_BIG_NAME                 "elf32-bigarm"
2028 #define ELF_ARCH                        bfd_arch_arm
2029 #define ELF_MACHINE_CODE                EM_ARM
2030
2031 #define bfd_elf32_bfd_reloc_type_lookup         elf32_arm_reloc_type_lookup
2032 #define elf_info_to_howto                       elf32_arm_info_to_howto
2033 #define elf_info_to_howto_rel                   0
2034 #define elf_backend_relocate_section            elf32_arm_relocate_section
2035 #define bfd_elf32_bfd_copy_private_bfd_data     elf32_arm_copy_private_bfd_data
2036 #define bfd_elf32_bfd_merge_private_bfd_data    elf32_arm_merge_private_bfd_data
2037 #define bfd_elf32_bfd_set_private_flags         elf32_arm_set_private_flags
2038 #define bfd_elf32_bfd_print_private_bfd_data    elf32_arm_print_private_bfd_data
2039 #define bfd_elf32_bfd_link_hash_table_create    elf32_arm_link_hash_table_create
2040 #define bfd_elf32_find_nearest_line             elf32_arm_find_nearest_line
2041 #define elf_backend_get_symbol_type             elf32_arm_get_symbol_type
2042 #define elf_backend_gc_mark_hook                elf32_arm_gc_mark_hook
2043 #define elf_backend_gc_sweep_hook               elf32_arm_gc_sweep_hook
2044 #define elf_backend_check_relocs                elf32_arm_check_relocs
2045
2046 #define elf_backend_can_gc_sections 1
2047 #define elf_symbol_leading_char '_'
2048
2049 #include "elf32-target.h"