bfd/elf32-arm.h

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