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 calls 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, #8]!      */
  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 | SEC_LINKER_CREATED;
 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 | SEC_LINKER_CREATED;
 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. krk@cygnus.com
 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.  nickc@cygnus.com  */
 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. krk@cygnus.com */
 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           /* It is not an error for an undefined weak reference to be
1233              out of range.  Any program that branches to such a symbol
1234              is going to crash anyway, so there is no point worrying
1235              about getting the destination exactly right.  */
1236           if (! h || h->root.type != bfd_link_hash_undefweak)
1237             {
1238               /* Perform a signed range check.  */
1239               signed_addend = value;
1240               signed_addend >>= howto->rightshift;
1241               if (signed_addend > ((bfd_signed_vma)(howto->dst_mask >> 1))
1242                   || signed_addend < - ((bfd_signed_vma) ((howto->dst_mask + 1) >> 1)))
1243                 return bfd_reloc_overflow;
1244             }
1245
1246           value = (signed_addend & howto->dst_mask)
1247             | (bfd_get_32 (input_bfd, hit_data) & (~ howto->dst_mask));
1248           break;
1249
1250         case R_ARM_ABS32:
1251           value += addend;
1252           if (sym_flags == STT_ARM_TFUNC)
1253             value |= 1;
1254           break;
1255
1256         case R_ARM_REL32:
1257           value -= (input_section->output_section->vma
1258                     + input_section->output_offset);
1259           value += addend;
1260           break;
1261         }
1262
1263       bfd_put_32 (input_bfd, value, hit_data);
1264       return bfd_reloc_ok;
1265
1266     case R_ARM_ABS8:
1267       value += addend;
1268       if ((long) value > 0x7f || (long) value < -0x80)
1269         return bfd_reloc_overflow;
1270
1271       bfd_put_8 (input_bfd, value, hit_data);
1272       return bfd_reloc_ok;
1273
1274     case R_ARM_ABS16:
1275       value += addend;
1276
1277       if ((long) value > 0x7fff || (long) value < -0x8000)
1278         return bfd_reloc_overflow;
1279
1280       bfd_put_16 (input_bfd, value, hit_data);
1281       return bfd_reloc_ok;
1282
1283     case R_ARM_ABS12:
1284       /* Support ldr and str instruction for the arm */
1285       /* Also thumb b (unconditional branch).  ??? Really?  */
1286       value += addend;
1287
1288       if ((long) value > 0x7ff || (long) value < -0x800)
1289         return bfd_reloc_overflow;
1290
1291       value |= (bfd_get_32 (input_bfd, hit_data) & 0xfffff000);
1292       bfd_put_32 (input_bfd, value, hit_data);
1293       return bfd_reloc_ok;
1294
1295     case R_ARM_THM_ABS5:
1296       /* Support ldr and str instructions for the thumb. */
1297 #ifdef USE_REL
1298       /* Need to refetch addend.  */
1299       addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
1300       /* ??? Need to determine shift amount from operand size.  */
1301       addend >>= howto->rightshift;
1302 #endif
1303       value += addend;
1304
1305       /* ??? Isn't value unsigned?  */
1306       if ((long) value > 0x1f || (long) value < -0x10)
1307         return bfd_reloc_overflow;
1308
1309       /* ??? Value needs to be properly shifted into place first.  */
1310       value |= bfd_get_16 (input_bfd, hit_data) & 0xf83f;
1311       bfd_put_16 (input_bfd, value, hit_data);
1312       return bfd_reloc_ok;
1313
1314     case R_ARM_THM_PC22:
1315       /* Thumb BL (branch long instruction). */
1316       {
1317         bfd_vma        relocation;
1318         boolean        overflow = false;
1319         bfd_vma        upper_insn = bfd_get_16 (input_bfd, hit_data);
1320         bfd_vma        lower_insn = bfd_get_16 (input_bfd, hit_data + 2);
1321         bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
1322         bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
1323         bfd_vma        check;
1324         bfd_signed_vma signed_check;
1325
1326 #ifdef USE_REL
1327         /* Need to refetch the addend and squish the two 11 bit pieces
1328            together.  */
1329         {
1330           bfd_vma upper = upper_insn & 0x7ff;
1331           bfd_vma lower = lower_insn & 0x7ff;
1332           upper = (upper ^ 0x400) - 0x400; /* sign extend */
1333           addend = (upper << 12) | (lower << 1);
1334           signed_addend = addend;
1335         }
1336 #endif
1337
1338         /* If it is not a call to thumb, assume call to arm.
1339            If it is a call relative to a section name, then it is not a
1340            function call at all, but rather a long jump.  */
1341         if (sym_flags != STT_ARM_TFUNC && sym_flags != STT_SECTION)
1342           {
1343             if (elf32_thumb_to_arm_stub
1344                 (info, sym_name, input_bfd, output_bfd, input_section,
1345                  hit_data, sym_sec, rel->r_offset, signed_addend, value))
1346               return bfd_reloc_ok;
1347             else
1348               return bfd_reloc_dangerous;
1349           }
1350
1351         relocation = value + signed_addend;
1352
1353         relocation -= (input_section->output_section->vma
1354                        + input_section->output_offset
1355                        + rel->r_offset);
1356
1357         if (! globals->no_pipeline_knowledge)
1358           {
1359             Elf_Internal_Ehdr * i_ehdrp; /* Elf file header, internal form */
1360
1361             i_ehdrp = elf_elfheader (input_bfd);
1362
1363             /* Previous versions of this code also used to add in the pipline
1364                offset here.  This is wrong because the linker is not supposed
1365                to know about such things, and one day it might change.  In order
1366                to support old binaries that need the old behaviour however, so
1367                we attempt to detect which ABI was used to create the reloc.  */
1368             if (   strcmp (bfd_get_target (input_bfd), "elf32-littlearm-oabi") == 0
1369                 || strcmp (bfd_get_target (input_bfd), "elf32-bigarm-oabi") == 0
1370                 || i_ehdrp->e_ident[EI_OSABI] == 0)
1371               relocation += 4;
1372           }
1373
1374         check = relocation >> howto->rightshift;
1375
1376         /* If this is a signed value, the rightshift just dropped
1377            leading 1 bits (assuming twos complement).  */
1378         if ((bfd_signed_vma) relocation >= 0)
1379           signed_check = check;
1380         else
1381           signed_check = check | ~((bfd_vma) -1 >> howto->rightshift);
1382
1383         /* Assumes two's complement.  */
1384         if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
1385           overflow = true;
1386
1387         /* Put RELOCATION back into the insn.  */
1388         upper_insn = (upper_insn & ~(bfd_vma) 0x7ff) | ((relocation >> 12) & 0x7ff);
1389         lower_insn = (lower_insn & ~(bfd_vma) 0x7ff) | ((relocation >> 1) & 0x7ff);
1390
1391         /* Put the relocated value back in the object file:  */
1392         bfd_put_16 (input_bfd, upper_insn, hit_data);
1393         bfd_put_16 (input_bfd, lower_insn, hit_data + 2);
1394
1395         return (overflow ? bfd_reloc_overflow : bfd_reloc_ok);
1396       }
1397       break;
1398
1399     case R_ARM_GNU_VTINHERIT:
1400     case R_ARM_GNU_VTENTRY:
1401       return bfd_reloc_ok;
1402
1403     case R_ARM_COPY:
1404       return bfd_reloc_notsupported;
1405
1406     case R_ARM_GLOB_DAT:
1407       return bfd_reloc_notsupported;
1408
1409     case R_ARM_JUMP_SLOT:
1410       return bfd_reloc_notsupported;
1411
1412     case R_ARM_RELATIVE:
1413       return bfd_reloc_notsupported;
1414
1415     case R_ARM_GOTOFF:
1416       /* Relocation is relative to the start of the
1417          global offset table.  */
1418
1419       BFD_ASSERT (sgot != NULL);
1420       if (sgot == NULL)
1421         return bfd_reloc_notsupported;
1422
1423       /* Note that sgot->output_offset is not involved in this
1424          calculation.  We always want the start of .got.  If we
1425          define _GLOBAL_OFFSET_TABLE in a different way, as is
1426          permitted by the ABI, we might have to change this
1427          calculation. */
1428
1429       value -= sgot->output_section->vma;
1430       return _bfd_final_link_relocate (howto, input_bfd, input_section,
1431                                        contents, rel->r_offset, value,
1432                                        (bfd_vma) 0);
1433
1434     case R_ARM_GOTPC:
1435       /* Use global offset table as symbol value. */
1436
1437       BFD_ASSERT (sgot != NULL);
1438
1439       if (sgot == NULL)
1440         return bfd_reloc_notsupported;
1441
1442       value = sgot->output_section->vma;
1443       return _bfd_final_link_relocate (howto, input_bfd, input_section,
1444                                        contents, rel->r_offset, value,
1445                                        (bfd_vma) 0);
1446
1447     case R_ARM_GOT32:
1448       /* Relocation is to the entry for this symbol in the
1449          global offset table. */
1450       if (sgot == NULL)
1451         return bfd_reloc_notsupported;
1452
1453       if (h != NULL)
1454         {
1455           bfd_vma off;
1456
1457           off = h->got.offset;
1458           BFD_ASSERT (off != (bfd_vma) -1);
1459
1460           if (!elf_hash_table (info)->dynamic_sections_created ||
1461               (info->shared && (info->symbolic || h->dynindx == -1)
1462                && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1463             {
1464               /* This is actually a static link, or it is a -Bsymbolic link
1465                  and the symbol is defined locally.  We must initialize this
1466                  entry in the global offset table.  Since the offset must
1467                  always be a multiple of 4, we use the least significant bit
1468                  to record whether we have initialized it already.
1469
1470                  When doing a dynamic link, we create a .rel.got relocation
1471                  entry to initialize the value.  This is done in the
1472                  finish_dynamic_symbol routine. */
1473
1474               if ((off & 1) != 0)
1475                 off &= ~1;
1476               else
1477                 {
1478                   bfd_put_32 (output_bfd, value, sgot->contents + off);
1479                   h->got.offset |= 1;
1480                 }
1481             }
1482
1483           value = sgot->output_offset + off;
1484         }
1485       else
1486         {
1487           bfd_vma off;
1488
1489           BFD_ASSERT (local_got_offsets != NULL &&
1490                       local_got_offsets[r_symndx] != (bfd_vma) -1);
1491
1492           off = local_got_offsets[r_symndx];
1493
1494           /* The offset must always be a multiple of 4.  We use the
1495              least significant bit to record whether we have already
1496              generated the necessary reloc. */
1497           if ((off & 1) != 0)
1498             off &= ~1;
1499           else
1500             {
1501               bfd_put_32 (output_bfd, value, sgot->contents + off);
1502
1503               if (info->shared)
1504                 {
1505                   asection * srelgot;
1506                   Elf_Internal_Rel outrel;
1507
1508                   srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
1509                   BFD_ASSERT (srelgot != NULL);
1510
1511                   outrel.r_offset = (sgot->output_section->vma
1512                                      + sgot->output_offset
1513                                      + off);
1514                   outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
1515                   bfd_elf32_swap_reloc_out (output_bfd, &outrel,
1516                                             (((Elf32_External_Rel *)
1517                                               srelgot->contents)
1518                                              + srelgot->reloc_count));
1519                   ++srelgot->reloc_count;
1520                 }
1521
1522               local_got_offsets[r_symndx] |= 1;
1523             }
1524
1525           value = sgot->output_offset + off;
1526         }
1527
1528       return _bfd_final_link_relocate (howto, input_bfd, input_section,
1529                                        contents, rel->r_offset, value,
1530                                        (bfd_vma) 0);
1531
1532     case R_ARM_PLT32:
1533       /* Relocation is to the entry for this symbol in the
1534          procedure linkage table.  */
1535
1536       /* Resolve a PLT32 reloc against a local symbol directly,
1537          without using the procedure linkage table. */
1538       if (h == NULL)
1539         return _bfd_final_link_relocate (howto, input_bfd, input_section,
1540                                          contents, rel->r_offset, value,
1541                                          (bfd_vma) 0);
1542
1543       if (h->plt.offset == (bfd_vma) -1)
1544         /* We didn't make a PLT entry for this symbol.  This
1545            happens when statically linking PIC code, or when
1546            using -Bsymbolic.  */
1547         return _bfd_final_link_relocate (howto, input_bfd, input_section,
1548                                          contents, rel->r_offset, value,
1549                                          (bfd_vma) 0);
1550
1551       BFD_ASSERT(splt != NULL);
1552       if (splt == NULL)
1553         return bfd_reloc_notsupported;
1554
1555       value = (splt->output_section->vma
1556                + splt->output_offset
1557                + h->plt.offset);
1558       return _bfd_final_link_relocate (howto, input_bfd, input_section,
1559                                        contents, rel->r_offset, value,
1560                                        (bfd_vma) 0);
1561
1562     case R_ARM_SBREL32:
1563       return bfd_reloc_notsupported;
1564
1565     case R_ARM_AMP_VCALL9:
1566       return bfd_reloc_notsupported;
1567
1568     case R_ARM_RSBREL32:
1569       return bfd_reloc_notsupported;
1570
1571     case R_ARM_THM_RPC22:
1572       return bfd_reloc_notsupported;
1573
1574     case R_ARM_RREL32:
1575       return bfd_reloc_notsupported;
1576
1577     case R_ARM_RABS32:
1578       return bfd_reloc_notsupported;
1579
1580     case R_ARM_RPC24:
1581       return bfd_reloc_notsupported;
1582
1583     case R_ARM_RBASE:
1584       return bfd_reloc_notsupported;
1585
1586     default:
1587       return bfd_reloc_notsupported;
1588     }
1589 }
1590
1591 #ifdef USE_REL
1592 /* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS.  */
1593 static void
1594 arm_add_to_rel (abfd, address, howto, increment)
1595      bfd *              abfd;
1596      bfd_byte *         address;
1597      reloc_howto_type * howto;
1598      bfd_signed_vma     increment;
1599 {
1600   bfd_vma        contents;
1601   bfd_signed_vma addend;
1602
1603   contents = bfd_get_32 (abfd, address);
1604
1605   /* Get the (signed) value from the instruction.  */
1606   addend = contents & howto->src_mask;
1607   if (addend & ((howto->src_mask + 1) >> 1))
1608     {
1609       bfd_signed_vma mask;
1610
1611       mask = -1;
1612       mask &= ~ howto->src_mask;
1613       addend |= mask;
1614     }
1615
1616   /* Add in the increment, (which is a byte value).  */
1617   switch (howto->type)
1618     {
1619     case R_ARM_THM_PC22:
1620     default:
1621       addend += increment;
1622       break;
1623
1624     case R_ARM_PC24:
1625       addend <<= howto->size;
1626       addend +=  increment;
1627
1628       /* Should we check for overflow here ?  */
1629
1630       /* Drop any undesired bits.  */
1631       addend >>= howto->rightshift;
1632       break;
1633     }
1634
1635   contents = (contents & ~ howto->dst_mask) | (addend & howto->dst_mask);
1636
1637   bfd_put_32 (abfd, contents, address);
1638 }
1639 #endif /* USE_REL */
1640
1641 /* Relocate an ARM ELF section.  */
1642 static boolean
1643 elf32_arm_relocate_section (output_bfd, info, input_bfd, input_section,
1644                             contents, relocs, local_syms, local_sections)
1645      bfd *                  output_bfd;
1646      struct bfd_link_info * info;
1647      bfd *                  input_bfd;
1648      asection *             input_section;
1649      bfd_byte *             contents;
1650      Elf_Internal_Rela *    relocs;
1651      Elf_Internal_Sym *     local_syms;
1652      asection **            local_sections;
1653 {
1654   Elf_Internal_Shdr *           symtab_hdr;
1655   struct elf_link_hash_entry ** sym_hashes;
1656   Elf_Internal_Rela *           rel;
1657   Elf_Internal_Rela *           relend;
1658   const char *                  name;
1659
1660   symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
1661   sym_hashes = elf_sym_hashes (input_bfd);
1662
1663   rel = relocs;
1664   relend = relocs + input_section->reloc_count;
1665   for (; rel < relend; rel++)
1666     {
1667       int                          r_type;
1668       reloc_howto_type *           howto;
1669       unsigned long                r_symndx;
1670       Elf_Internal_Sym *           sym;
1671       asection *                   sec;
1672       struct elf_link_hash_entry * h;
1673       bfd_vma                      relocation;
1674       bfd_reloc_status_type        r;
1675       arelent                      bfd_reloc;
1676
1677       r_symndx = ELF32_R_SYM (rel->r_info);
1678       r_type   = ELF32_R_TYPE (rel->r_info);
1679
1680       if (   r_type == R_ARM_GNU_VTENTRY
1681           || r_type == R_ARM_GNU_VTINHERIT)
1682         continue;
1683
1684       elf32_arm_info_to_howto (input_bfd, & bfd_reloc, rel);
1685       howto = bfd_reloc.howto;
1686
1687       if (info->relocateable)
1688         {
1689           /* This is a relocateable link.  We don't have to change
1690              anything, unless the reloc is against a section symbol,
1691              in which case we have to adjust according to where the
1692              section symbol winds up in the output section.  */
1693           if (r_symndx < symtab_hdr->sh_info)
1694             {
1695               sym = local_syms + r_symndx;
1696               if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1697                 {
1698                   sec = local_sections[r_symndx];
1699 #ifdef USE_REL
1700                   arm_add_to_rel (input_bfd, contents + rel->r_offset,
1701                                   howto, sec->output_offset + sym->st_value);
1702 #else
1703                   rel->r_addend += (sec->output_offset + sym->st_value)
1704                     >> howto->rightshift;
1705 #endif
1706                 }
1707             }
1708
1709           continue;
1710         }
1711
1712       /* This is a final link.  */
1713       h = NULL;
1714       sym = NULL;
1715       sec = NULL;
1716       if (r_symndx < symtab_hdr->sh_info)
1717         {
1718           sym = local_syms + r_symndx;
1719           sec = local_sections[r_symndx];
1720           relocation = (sec->output_section->vma
1721                         + sec->output_offset
1722                         + sym->st_value);
1723         }
1724       else
1725         {
1726           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1727           while (h->root.type == bfd_link_hash_indirect
1728                  || h->root.type == bfd_link_hash_warning)
1729             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1730           if (h->root.type == bfd_link_hash_defined
1731               || h->root.type == bfd_link_hash_defweak)
1732             {
1733               int relocation_needed = 1;
1734
1735               sec = h->root.u.def.section;
1736
1737               /* In these cases, we don't need the relocation value.
1738                  We check specially because in some obscure cases
1739                  sec->output_section will be NULL. */
1740               switch (r_type)
1741                 {
1742                 case R_ARM_PC24:
1743                 case R_ARM_ABS32:
1744                   if (info->shared
1745                       && (
1746                           (!info->symbolic && h->dynindx != -1)
1747                           || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
1748                           )
1749                       && ((input_section->flags & SEC_ALLOC) != 0)
1750                       )
1751                     relocation_needed = 0;
1752                   break;
1753
1754                 case R_ARM_GOTPC:
1755                   relocation_needed = 0;
1756                   break;
1757
1758                 case R_ARM_GOT32:
1759                   if (elf_hash_table(info)->dynamic_sections_created
1760                       && (!info->shared
1761                           || (!info->symbolic && h->dynindx != -1)
1762                           || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
1763                           )
1764                       )
1765                     relocation_needed = 0;
1766                   break;
1767
1768                 case R_ARM_PLT32:
1769                   if (h->plt.offset != (bfd_vma)-1)
1770                     relocation_needed = 0;
1771                   break;
1772
1773                 default:
1774                   if (sec->output_section == NULL)
1775                     {
1776                       (*_bfd_error_handler)
1777                         (_("%s: warning: unresolvable relocation against symbol `%s' from %s section"),
1778                          bfd_get_filename (input_bfd), h->root.root.string,
1779                          bfd_get_section_name (input_bfd, input_section));
1780                       relocation_needed = 0;
1781                     }
1782                 }
1783
1784               if (relocation_needed)
1785                 relocation = h->root.u.def.value
1786                   + sec->output_section->vma
1787                   + sec->output_offset;
1788               else
1789                 relocation = 0;
1790             }
1791           else if (h->root.type == bfd_link_hash_undefweak)
1792             relocation = 0;
1793           else if (info->shared && !info->symbolic && !info->no_undefined)
1794             relocation = 0;
1795           else
1796             {
1797               if (!((*info->callbacks->undefined_symbol)
1798                     (info, h->root.root.string, input_bfd,
1799                      input_section, rel->r_offset)))
1800                 return false;
1801               relocation = 0;
1802             }
1803         }
1804
1805       if (h != NULL)
1806         name = h->root.root.string;
1807       else
1808         {
1809           name = (bfd_elf_string_from_elf_section
1810                   (input_bfd, symtab_hdr->sh_link, sym->st_name));
1811           if (name == NULL || *name == '\0')
1812             name = bfd_section_name (input_bfd, sec);
1813         }
1814
1815       r = elf32_arm_final_link_relocate (howto, input_bfd, output_bfd,
1816                                          input_section, contents, rel,
1817                                          relocation, info, sec, name,
1818                                          (h ? ELF_ST_TYPE (h->type) :
1819                                           ELF_ST_TYPE (sym->st_info)), h);
1820
1821       if (r != bfd_reloc_ok)
1822         {
1823           const char * msg = (const char *) 0;
1824
1825           switch (r)
1826             {
1827             case bfd_reloc_overflow:
1828               if (!((*info->callbacks->reloc_overflow)
1829                     (info, name, howto->name, (bfd_vma) 0,
1830                      input_bfd, input_section, rel->r_offset)))
1831                 return false;
1832               break;
1833
1834             case bfd_reloc_undefined:
1835               if (!((*info->callbacks->undefined_symbol)
1836                     (info, name, input_bfd, input_section,
1837                      rel->r_offset)))
1838                 return false;
1839               break;
1840
1841             case bfd_reloc_outofrange:
1842               msg = _ ("internal error: out of range error");
1843               goto common_error;
1844
1845             case bfd_reloc_notsupported:
1846               msg = _ ("internal error: unsupported relocation error");
1847               goto common_error;
1848
1849             case bfd_reloc_dangerous:
1850               msg = _ ("internal error: dangerous error");
1851               goto common_error;
1852
1853             default:
1854               msg = _ ("internal error: unknown error");
1855               /* fall through */
1856
1857             common_error:
1858               if (!((*info->callbacks->warning)
1859                     (info, msg, name, input_bfd, input_section,
1860                      rel->r_offset)))
1861                 return false;
1862               break;
1863             }
1864         }
1865     }
1866
1867   return true;
1868 }
1869
1870 /* Function to keep ARM specific flags in the ELF header. */
1871 static boolean
1872 elf32_arm_set_private_flags (abfd, flags)
1873      bfd *abfd;
1874      flagword flags;
1875 {
1876   if (elf_flags_init (abfd)
1877       && elf_elfheader (abfd)->e_flags != flags)
1878     {
1879       if (flags & EF_INTERWORK)
1880         _bfd_error_handler (_ ("\
1881 Warning: Not setting interwork flag of %s since it has already been specified as non-interworking"),
1882                             bfd_get_filename (abfd));
1883       else
1884         _bfd_error_handler (_ ("\
1885 Warning: Clearing the interwork flag of %s due to outside request"),
1886                             bfd_get_filename (abfd));
1887     }
1888   else
1889     {
1890       elf_elfheader (abfd)->e_flags = flags;
1891       elf_flags_init (abfd) = true;
1892     }
1893
1894   return true;
1895 }
1896
1897 /* Copy backend specific data from one object module to another */
1898 static boolean
1899 elf32_arm_copy_private_bfd_data (ibfd, obfd)
1900      bfd *ibfd;
1901      bfd *obfd;
1902 {
1903   flagword in_flags;
1904   flagword out_flags;
1905
1906   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1907       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1908     return true;
1909
1910   in_flags = elf_elfheader (ibfd)->e_flags;
1911   out_flags = elf_elfheader (obfd)->e_flags;
1912
1913   if (elf_flags_init (obfd) && in_flags != out_flags)
1914     {
1915       /* Cannot mix PIC and non-PIC code.  */
1916       if ((in_flags & EF_PIC) != (out_flags & EF_PIC))
1917         return false;
1918
1919       /* Cannot mix APCS26 and APCS32 code.  */
1920       if ((in_flags & EF_APCS_26) != (out_flags & EF_APCS_26))
1921         return false;
1922
1923       /* Cannot mix float APCS and non-float APCS code.  */
1924       if ((in_flags & EF_APCS_FLOAT) != (out_flags & EF_APCS_FLOAT))
1925         return false;
1926
1927       /* If the src and dest have different interworking flags
1928          then turn off the interworking bit.  */
1929       if ((in_flags & EF_INTERWORK) != (out_flags & EF_INTERWORK))
1930         {
1931           if (out_flags & EF_INTERWORK)
1932             _bfd_error_handler (_ ("\
1933 Warning: Clearing the interwork flag in %s because non-interworking code in %s has been linked with it"),
1934                           bfd_get_filename (obfd), bfd_get_filename (ibfd));
1935
1936           in_flags &= ~EF_INTERWORK;
1937         }
1938     }
1939
1940   elf_elfheader (obfd)->e_flags = in_flags;
1941   elf_flags_init (obfd) = true;
1942
1943   return true;
1944 }
1945
1946 /* Merge backend specific data from an object file to the output
1947    object file when linking.  */
1948 static boolean
1949 elf32_arm_merge_private_bfd_data (ibfd, obfd)
1950      bfd *ibfd;
1951      bfd *obfd;
1952 {
1953   flagword out_flags;
1954   flagword in_flags;
1955
1956   if (   bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1957       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1958     return true;
1959
1960   /* Check if we have the same endianess */
1961   if (   ibfd->xvec->byteorder != obfd->xvec->byteorder
1962       && obfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN
1963       && ibfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN)
1964     {
1965       (*_bfd_error_handler)
1966         (_("%s: compiled for a %s endian system and target is %s endian"),
1967          bfd_get_filename (ibfd),
1968          bfd_big_endian (ibfd) ? "big" : "little",
1969          bfd_big_endian (obfd) ? "big" : "little");
1970
1971       bfd_set_error (bfd_error_wrong_format);
1972       return false;
1973     }
1974
1975   /* The input BFD must have had its flags initialised.  */
1976   /* The following seems bogus to me -- The flags are initialized in
1977      the assembler but I don't think an elf_flags_init field is
1978      written into the object */
1979   /* BFD_ASSERT (elf_flags_init (ibfd)); */
1980
1981   in_flags  = elf_elfheader (ibfd)->e_flags;
1982   out_flags = elf_elfheader (obfd)->e_flags;
1983
1984   if (!elf_flags_init (obfd))
1985     {
1986       /* If the input is the default architecture then do not
1987          bother setting the flags for the output architecture,
1988          instead allow future merges to do this.  If no future
1989          merges ever set these flags then they will retain their
1990          unitialised values, which surprise surprise, correspond
1991          to the default values.  */
1992       if (bfd_get_arch_info (ibfd)->the_default)
1993         return true;
1994
1995       elf_flags_init (obfd) = true;
1996       elf_elfheader (obfd)->e_flags = in_flags;
1997
1998       if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
1999           && bfd_get_arch_info (obfd)->the_default)
2000         return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
2001
2002       return true;
2003     }
2004
2005   /* Check flag compatibility.  */
2006   if (in_flags == out_flags)
2007     return true;
2008
2009   /* Complain about various flag mismatches.  */
2010
2011   if ((in_flags & EF_APCS_26) != (out_flags & EF_APCS_26))
2012     _bfd_error_handler (_ ("\
2013 Error: %s compiled for APCS-%d, whereas %s is compiled for APCS-%d"),
2014                         bfd_get_filename (ibfd),
2015                         in_flags & EF_APCS_26 ? 26 : 32,
2016                         bfd_get_filename (obfd),
2017                         out_flags & EF_APCS_26 ? 26 : 32);
2018
2019   if ((in_flags & EF_APCS_FLOAT) != (out_flags & EF_APCS_FLOAT))
2020     _bfd_error_handler (_ ("\
2021 Error: %s passes floats in %s registers, whereas %s passes them in %s registers"),
2022                         bfd_get_filename (ibfd),
2023                      in_flags & EF_APCS_FLOAT ? _ ("float") : _ ("integer"),
2024                         bfd_get_filename (obfd),
2025                       out_flags & EF_APCS_26 ? _ ("float") : _ ("integer"));
2026
2027   if ((in_flags & EF_PIC) != (out_flags & EF_PIC))
2028     _bfd_error_handler (_ ("\
2029 Error: %s is compiled as position %s code, whereas %s is not"),
2030                         bfd_get_filename (ibfd),
2031                     in_flags & EF_PIC ? _ ("independent") : _ ("dependent"),
2032                         bfd_get_filename (obfd));
2033
2034   /* Interworking mismatch is only a warning. */
2035   if ((in_flags & EF_INTERWORK) != (out_flags & EF_INTERWORK))
2036     {
2037       _bfd_error_handler (_ ("\
2038 Warning: %s %s interworking, whereas %s %s"),
2039                           bfd_get_filename (ibfd),
2040           in_flags & EF_INTERWORK ? _ ("supports") : _ ("does not support"),
2041                           bfd_get_filename (obfd),
2042                     out_flags & EF_INTERWORK ? _ ("does not") : _ ("does"));
2043       return true;
2044     }
2045
2046   return false;
2047 }
2048
2049 /* Display the flags field */
2050 static boolean
2051 elf32_arm_print_private_bfd_data (abfd, ptr)
2052      bfd *abfd;
2053      PTR ptr;
2054 {
2055   FILE *file = (FILE *) ptr;
2056
2057   BFD_ASSERT (abfd != NULL && ptr != NULL);
2058
2059   /* Print normal ELF private data.  */
2060   _bfd_elf_print_private_bfd_data (abfd, ptr);
2061
2062   /* Ignore init flag - it may not be set, despite the flags field containing valid data.  */
2063
2064   /* xgettext:c-format */
2065   fprintf (file, _ ("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
2066
2067   if (elf_elfheader (abfd)->e_flags & EF_INTERWORK)
2068     fprintf (file, _ (" [interworking enabled]"));
2069   else
2070     fprintf (file, _ (" [interworking not enabled]"));
2071
2072   if (elf_elfheader (abfd)->e_flags & EF_APCS_26)
2073     fprintf (file, _ (" [APCS-26]"));
2074   else
2075     fprintf (file, _ (" [APCS-32]"));
2076
2077   if (elf_elfheader (abfd)->e_flags & EF_APCS_FLOAT)
2078     fprintf (file, _ (" [floats passed in float registers]"));
2079   else
2080     fprintf (file, _ (" [floats passed in integer registers]"));
2081
2082   if (elf_elfheader (abfd)->e_flags & EF_PIC)
2083     fprintf (file, _ (" [position independent]"));
2084   else
2085     fprintf (file, _ (" [absolute position]"));
2086
2087   fputc ('\n', file);
2088
2089   return true;
2090 }
2091
2092 static int
2093 elf32_arm_get_symbol_type (elf_sym, type)
2094      Elf_Internal_Sym * elf_sym;
2095      int type;
2096 {
2097   if (ELF_ST_TYPE (elf_sym->st_info) == STT_ARM_TFUNC)
2098     return ELF_ST_TYPE (elf_sym->st_info);
2099   else
2100     return type;
2101 }
2102
2103 static asection *
2104 elf32_arm_gc_mark_hook (abfd, info, rel, h, sym)
2105        bfd *abfd;
2106        struct bfd_link_info *info ATTRIBUTE_UNUSED;
2107        Elf_Internal_Rela *rel;
2108        struct elf_link_hash_entry *h;
2109        Elf_Internal_Sym *sym;
2110 {
2111   if (h != NULL)
2112     {
2113       switch (ELF32_R_TYPE (rel->r_info))
2114       {
2115       case R_ARM_GNU_VTINHERIT:
2116       case R_ARM_GNU_VTENTRY:
2117         break;
2118
2119       default:
2120         switch (h->root.type)
2121           {
2122           case bfd_link_hash_defined:
2123           case bfd_link_hash_defweak:
2124             return h->root.u.def.section;
2125
2126           case bfd_link_hash_common:
2127             return h->root.u.c.p->section;
2128
2129           default:
2130             break;
2131           }
2132        }
2133      }
2134    else
2135      {
2136        if (!(elf_bad_symtab (abfd)
2137            && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
2138          && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
2139                 && sym->st_shndx != SHN_COMMON))
2140           {
2141             return bfd_section_from_elf_index (abfd, sym->st_shndx);
2142           }
2143       }
2144   return NULL;
2145 }
2146
2147 /* Update the got entry reference counts for the section being removed.  */
2148
2149 static boolean
2150 elf32_arm_gc_sweep_hook (abfd, info, sec, relocs)
2151      bfd *abfd ATTRIBUTE_UNUSED;
2152      struct bfd_link_info *info ATTRIBUTE_UNUSED;
2153      asection *sec ATTRIBUTE_UNUSED;
2154      const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
2155 {
2156   /* We don't support garbage collection of GOT and PLT relocs yet.  */
2157   return true;
2158 }
2159
2160 /* Look through the relocs for a section during the first phase.  */
2161
2162 static boolean
2163 elf32_arm_check_relocs (abfd, info, sec, relocs)
2164      bfd *                      abfd;
2165      struct bfd_link_info *     info;
2166      asection *                 sec;
2167      const Elf_Internal_Rela *  relocs;
2168 {
2169   Elf_Internal_Shdr *           symtab_hdr;
2170   struct elf_link_hash_entry ** sym_hashes;
2171   struct elf_link_hash_entry ** sym_hashes_end;
2172   const Elf_Internal_Rela *     rel;
2173   const Elf_Internal_Rela *     rel_end;
2174   bfd *                         dynobj;
2175   asection * sgot, *srelgot, *sreloc;
2176   bfd_vma * local_got_offsets;
2177
2178   if (info->relocateable)
2179     return true;
2180
2181   sgot = srelgot = sreloc = NULL;
2182
2183   dynobj = elf_hash_table (info)->dynobj;
2184   local_got_offsets = elf_local_got_offsets (abfd);
2185
2186   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2187   sym_hashes = elf_sym_hashes (abfd);
2188   sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof(Elf32_External_Sym);
2189   if (!elf_bad_symtab (abfd))
2190     sym_hashes_end -= symtab_hdr->sh_info;
2191
2192   rel_end = relocs + sec->reloc_count;
2193   for (rel = relocs; rel < rel_end; rel++)
2194     {
2195       struct elf_link_hash_entry *h;
2196       unsigned long r_symndx;
2197
2198       r_symndx = ELF32_R_SYM (rel->r_info);
2199       if (r_symndx < symtab_hdr->sh_info)
2200         h = NULL;
2201       else
2202         h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2203
2204       /* Some relocs require a global offset table.  */
2205       if (dynobj == NULL)
2206         {
2207           switch (ELF32_R_TYPE (rel->r_info))
2208             {
2209             case R_ARM_GOT32:
2210             case R_ARM_GOTOFF:
2211             case R_ARM_GOTPC:
2212               elf_hash_table (info)->dynobj = dynobj = abfd;
2213               if (! _bfd_elf_create_got_section (dynobj, info))
2214                 return false;
2215               break;
2216
2217             default:
2218               break;
2219             }
2220         }
2221
2222       switch (ELF32_R_TYPE (rel->r_info))
2223         {
2224           case R_ARM_GOT32:
2225             /* This symbol requires a global offset table entry.  */
2226             if (sgot == NULL)
2227               {
2228                 sgot = bfd_get_section_by_name (dynobj, ".got");
2229                 BFD_ASSERT (sgot != NULL);
2230               }
2231
2232             /* Get the got relocation section if necessary.  */
2233             if (srelgot == NULL
2234                 && (h != NULL || info->shared))
2235               {
2236                 srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
2237
2238                 /* If no got relocation section, make one and initialize.  */
2239                 if (srelgot == NULL)
2240                   {
2241                     srelgot = bfd_make_section (dynobj, ".rel.got");
2242                     if (srelgot == NULL
2243                         || ! bfd_set_section_flags (dynobj, srelgot,
2244                                                     (SEC_ALLOC
2245                                                      | SEC_LOAD
2246                                                      | SEC_HAS_CONTENTS
2247                                                      | SEC_IN_MEMORY
2248                                                      | SEC_LINKER_CREATED
2249                                                      | SEC_READONLY))
2250                         || ! bfd_set_section_alignment (dynobj, srelgot, 2))
2251                       return false;
2252                   }
2253               }
2254
2255             if (h != NULL)
2256               {
2257                 if (h->got.offset != (bfd_vma) -1)
2258                   /* We have already allocated space in the .got.  */
2259                   break;
2260
2261                 h->got.offset = sgot->_raw_size;
2262
2263                 /* Make sure this symbol is output as a dynamic symbol.  */
2264                 if (h->dynindx == -1)
2265                   if (! bfd_elf32_link_record_dynamic_symbol (info, h))
2266                     return false;
2267
2268                 srelgot->_raw_size += sizeof (Elf32_External_Rel);
2269               }
2270             else
2271               {
2272                 /* This is a global offset table entry for a local
2273                    symbol.  */
2274                 if (local_got_offsets == NULL)
2275                   {
2276                     size_t size;
2277                     register unsigned int i;
2278
2279                     size = symtab_hdr->sh_info * sizeof (bfd_vma);
2280                     local_got_offsets = (bfd_vma *) bfd_alloc (abfd, size);
2281                     if (local_got_offsets == NULL)
2282                       return false;
2283                     elf_local_got_offsets (abfd) = local_got_offsets;
2284                     for (i = 0; i < symtab_hdr->sh_info; i++)
2285                       local_got_offsets[i] = (bfd_vma) -1;
2286                   }
2287
2288                 if (local_got_offsets[r_symndx] != (bfd_vma) -1)
2289                   /* We have already allocated space in the .got.  */
2290                   break;
2291
2292                 local_got_offsets[r_symndx] = sgot->_raw_size;
2293
2294                 if (info->shared)
2295                   /* If we are generating a shared object, we need to
2296                      output a R_ARM_RELATIVE reloc so that the dynamic
2297                      linker can adjust this GOT entry.  */
2298                   srelgot->_raw_size += sizeof (Elf32_External_Rel);
2299               }
2300
2301             sgot->_raw_size += 4;
2302             break;
2303
2304           case R_ARM_PLT32:
2305             /* This symbol requires a procedure linkage table entry.  We
2306                actually build the entry in adjust_dynamic_symbol,
2307                because this might be a case of linking PIC code which is
2308                never referenced by a dynamic object, in which case we
2309                don't need to generate a procedure linkage table entry
2310                after all.  */
2311
2312             /* If this is a local symbol, we resolve it directly without
2313                creating a procedure linkage table entry.  */
2314             if (h == NULL)
2315               continue;
2316
2317             h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2318             break;
2319
2320           case R_ARM_ABS32:
2321           case R_ARM_REL32:
2322           case R_ARM_PC24:
2323             /* If we are creating a shared library, and this is a reloc
2324                against a global symbol, or a non PC relative reloc
2325                against a local symbol, then we need to copy the reloc
2326                into the shared library.  However, if we are linking with
2327                -Bsymbolic, we do not need to copy a reloc against a
2328                global symbol which is defined in an object we are
2329                including in the link (i.e., DEF_REGULAR is set).  At
2330                this point we have not seen all the input files, so it is
2331                possible that DEF_REGULAR is not set now but will be set
2332                later (it is never cleared).  We account for that
2333                possibility below by storing information in the
2334                pcrel_relocs_copied field of the hash table entry.  */
2335             if (info->shared
2336               && (ELF32_R_TYPE (rel->r_info) != R_ARM_PC24
2337                 || (h != NULL
2338                   && (! info->symbolic
2339                     || (h->elf_link_hash_flags
2340                       & ELF_LINK_HASH_DEF_REGULAR) == 0))))
2341               {
2342                 /* When creating a shared object, we must copy these
2343                    reloc types into the output file.  We create a reloc
2344                    section in dynobj and make room for this reloc.  */
2345                 if (sreloc == NULL)
2346                   {
2347                     const char * name;
2348
2349                     name = (bfd_elf_string_from_elf_section
2350                             (abfd,
2351                              elf_elfheader (abfd)->e_shstrndx,
2352                              elf_section_data (sec)->rel_hdr.sh_name));
2353                     if (name == NULL)
2354                       return false;
2355
2356                     BFD_ASSERT (strncmp (name, ".rel", 4) == 0
2357                                 && strcmp (bfd_get_section_name (abfd, sec),
2358                                            name + 4) == 0);
2359
2360                     sreloc = bfd_get_section_by_name (dynobj, name);
2361                     if (sreloc == NULL)
2362                       {
2363                         flagword flags;
2364
2365                         sreloc = bfd_make_section (dynobj, name);
2366                         flags = (SEC_HAS_CONTENTS | SEC_READONLY
2367                                  | SEC_IN_MEMORY | SEC_LINKER_CREATED);
2368                         if ((sec->flags & SEC_ALLOC) != 0)
2369                           flags |= SEC_ALLOC | SEC_LOAD;
2370                         if (sreloc == NULL
2371                             || ! bfd_set_section_flags (dynobj, sreloc, flags)
2372                             || ! bfd_set_section_alignment (dynobj, sreloc, 2))
2373                           return false;
2374                       }
2375                   }
2376
2377                 sreloc->_raw_size += sizeof (Elf32_External_Rel);
2378                 /* If we are linking with -Bsymbolic, and this is a
2379                    global symbol, we count the number of PC relative
2380                    relocations we have entered for this symbol, so that
2381                    we can discard them again if the symbol is later
2382                    defined by a regular object.  Note that this function
2383                    is only called if we are using an elf_i386 linker
2384                    hash table, which means that h is really a pointer to
2385                    an elf_i386_link_hash_entry.  */
2386                 if (h != NULL && info->symbolic
2387                     && ELF32_R_TYPE (rel->r_info) == R_ARM_PC24)
2388                   {
2389                     struct elf32_arm_link_hash_entry * eh;
2390                     struct elf32_arm_pcrel_relocs_copied * p;
2391
2392                     eh = (struct elf32_arm_link_hash_entry *) h;
2393
2394                     for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next)
2395                       if (p->section == sreloc)
2396                         break;
2397
2398                     if (p == NULL)
2399                       {
2400                         p = ((struct elf32_arm_pcrel_relocs_copied *)
2401                              bfd_alloc (dynobj, sizeof * p));
2402
2403                         if (p == NULL)
2404                           return false;
2405                         p->next = eh->pcrel_relocs_copied;
2406                         eh->pcrel_relocs_copied = p;
2407                         p->section = sreloc;
2408                         p->count = 0;
2409                       }
2410
2411                     ++p->count;
2412                   }
2413               }
2414             break;
2415
2416         /* This relocation describes the C++ object vtable hierarchy.
2417            Reconstruct it for later use during GC.  */
2418         case R_ARM_GNU_VTINHERIT:
2419           if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2420             return false;
2421           break;
2422
2423         /* This relocation describes which C++ vtable entries are actually
2424            used.  Record for later use during GC.  */
2425         case R_ARM_GNU_VTENTRY:
2426           if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_offset))
2427             return false;
2428           break;
2429         }
2430     }
2431
2432   return true;
2433 }
2434
2435
2436 /* Find the nearest line to a particular section and offset, for error
2437    reporting.   This code is a duplicate of the code in elf.c, except
2438    that it also accepts STT_ARM_TFUNC as a symbol that names a function. */
2439
2440 static boolean
2441 elf32_arm_find_nearest_line
2442   (abfd, section, symbols, offset, filename_ptr, functionname_ptr, line_ptr)
2443      bfd *          abfd;
2444      asection *     section;
2445      asymbol **     symbols;
2446      bfd_vma        offset;
2447      CONST char **  filename_ptr;
2448      CONST char **  functionname_ptr;
2449      unsigned int * line_ptr;
2450 {
2451   boolean      found;
2452   const char * filename;
2453   asymbol *    func;
2454   bfd_vma      low_func;
2455   asymbol **   p;
2456
2457   if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
2458                                      filename_ptr, functionname_ptr,
2459                                      line_ptr, 0))
2460     return true;
2461
2462   if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
2463                                              &found, filename_ptr,
2464                                              functionname_ptr, line_ptr,
2465                                              &elf_tdata (abfd)->line_info))
2466     return false;
2467
2468   if (found)
2469     return true;
2470
2471   if (symbols == NULL)
2472     return false;
2473
2474   filename = NULL;
2475   func = NULL;
2476   low_func = 0;
2477
2478   for (p = symbols; *p != NULL; p++)
2479     {
2480       elf_symbol_type *q;
2481
2482       q = (elf_symbol_type *) *p;
2483
2484       if (bfd_get_section (&q->symbol) != section)
2485         continue;
2486
2487       switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
2488         {
2489         default:
2490           break;
2491         case STT_FILE:
2492           filename = bfd_asymbol_name (&q->symbol);
2493           break;
2494         case STT_NOTYPE:
2495         case STT_FUNC:
2496         case STT_ARM_TFUNC:
2497           if (q->symbol.section == section
2498               && q->symbol.value >= low_func
2499               && q->symbol.value <= offset)
2500             {
2501               func = (asymbol *) q;
2502               low_func = q->symbol.value;
2503             }
2504           break;
2505         }
2506     }
2507
2508   if (func == NULL)
2509     return false;
2510
2511   *filename_ptr = filename;
2512   *functionname_ptr = bfd_asymbol_name (func);
2513   *line_ptr = 0;
2514
2515   return true;
2516 }
2517
2518 /* Adjust a symbol defined by a dynamic object and referenced by a
2519    regular object.  The current definition is in some section of the
2520    dynamic object, but we're not including those sections.  We have to
2521    change the definition to something the rest of the link can
2522    understand.  */
2523
2524 static boolean
2525 elf32_arm_adjust_dynamic_symbol (info, h)
2526      struct bfd_link_info * info;
2527      struct elf_link_hash_entry * h;
2528 {
2529   bfd * dynobj;
2530   asection * s;
2531   unsigned int power_of_two;
2532
2533   dynobj = elf_hash_table (info)->dynobj;
2534
2535   /* Make sure we know what is going on here.  */
2536   BFD_ASSERT (dynobj != NULL
2537               && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
2538                   || h->weakdef != NULL
2539                   || ((h->elf_link_hash_flags
2540                        & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2541                       && (h->elf_link_hash_flags
2542                           & ELF_LINK_HASH_REF_REGULAR) != 0
2543                       && (h->elf_link_hash_flags
2544                           & ELF_LINK_HASH_DEF_REGULAR) == 0)));
2545
2546   /* If this is a function, put it in the procedure linkage table.  We
2547      will fill in the contents of the procedure linkage table later,
2548      when we know the address of the .got section.  */
2549   if (h->type == STT_FUNC
2550       || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
2551     {
2552       if (! info->shared
2553           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
2554           && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0)
2555         {
2556           /* This case can occur if we saw a PLT32 reloc in an input
2557              file, but the symbol was never referred to by a dynamic
2558              object.  In such a case, we don't actually need to build
2559              a procedure linkage table, and we can just do a PC32
2560              reloc instead.  */
2561           BFD_ASSERT ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0);
2562           return true;
2563         }
2564
2565       /* Make sure this symbol is output as a dynamic symbol.  */
2566       if (h->dynindx == -1)
2567         {
2568           if (! bfd_elf32_link_record_dynamic_symbol (info, h))
2569             return false;
2570         }
2571
2572       s = bfd_get_section_by_name (dynobj, ".plt");
2573       BFD_ASSERT (s != NULL);
2574
2575       /* If this is the first .plt entry, make room for the special
2576          first entry.  */
2577       if (s->_raw_size == 0)
2578         s->_raw_size += PLT_ENTRY_SIZE;
2579
2580       /* If this symbol is not defined in a regular file, and we are
2581          not generating a shared library, then set the symbol to this
2582          location in the .plt.  This is required to make function
2583          pointers compare as equal between the normal executable and
2584          the shared library.  */
2585       if (! info->shared
2586           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2587         {
2588           h->root.u.def.section = s;
2589           h->root.u.def.value = s->_raw_size;
2590         }
2591
2592       h->plt.offset = s->_raw_size;
2593
2594       /* Make room for this entry.  */
2595       s->_raw_size += PLT_ENTRY_SIZE;
2596
2597       /* We also need to make an entry in the .got.plt section, which
2598          will be placed in the .got section by the linker script.  */
2599
2600       s = bfd_get_section_by_name (dynobj, ".got.plt");
2601       BFD_ASSERT (s != NULL);
2602       s->_raw_size += 4;
2603
2604       /* We also need to make an entry in the .rel.plt section.  */
2605
2606       s = bfd_get_section_by_name (dynobj, ".rel.plt");
2607       BFD_ASSERT (s != NULL);
2608       s->_raw_size += sizeof (Elf32_External_Rel);
2609
2610       return true;
2611     }
2612
2613   /* If this is a weak symbol, and there is a real definition, the
2614      processor independent code will have arranged for us to see the
2615      real definition first, and we can just use the same value.  */
2616   if (h->weakdef != NULL)
2617     {
2618       BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
2619                   || h->weakdef->root.type == bfd_link_hash_defweak);
2620       h->root.u.def.section = h->weakdef->root.u.def.section;
2621       h->root.u.def.value = h->weakdef->root.u.def.value;
2622       return true;
2623     }
2624
2625   /* This is a reference to a symbol defined by a dynamic object which
2626      is not a function.  */
2627
2628   /* If we are creating a shared library, we must presume that the
2629      only references to the symbol are via the global offset table.
2630      For such cases we need not do anything here; the relocations will
2631      be handled correctly by relocate_section.  */
2632   if (info->shared)
2633     return true;
2634
2635   /* We must allocate the symbol in our .dynbss section, which will
2636      become part of the .bss section of the executable.  There will be
2637      an entry for this symbol in the .dynsym section.  The dynamic
2638      object will contain position independent code, so all references
2639      from the dynamic object to this symbol will go through the global
2640      offset table.  The dynamic linker will use the .dynsym entry to
2641      determine the address it must put in the global offset table, so
2642      both the dynamic object and the regular object will refer to the
2643      same memory location for the variable.  */
2644
2645   s = bfd_get_section_by_name (dynobj, ".dynbss");
2646   BFD_ASSERT (s != NULL);
2647
2648   /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
2649      copy the initial value out of the dynamic object and into the
2650      runtime process image.  We need to remember the offset into the
2651      .rel.bss section we are going to use.  */
2652   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
2653     {
2654       asection *srel;
2655
2656       srel = bfd_get_section_by_name (dynobj, ".rel.bss");
2657       BFD_ASSERT (srel != NULL);
2658       srel->_raw_size += sizeof (Elf32_External_Rel);
2659       h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
2660     }
2661
2662   /* We need to figure out the alignment required for this symbol.  I
2663      have no idea how ELF linkers handle this.  */
2664   power_of_two = bfd_log2 (h->size);
2665   if (power_of_two > 3)
2666     power_of_two = 3;
2667
2668   /* Apply the required alignment.  */
2669   s->_raw_size = BFD_ALIGN (s->_raw_size,
2670                             (bfd_size_type) (1 << power_of_two));
2671   if (power_of_two > bfd_get_section_alignment (dynobj, s))
2672     {
2673       if (! bfd_set_section_alignment (dynobj, s, power_of_two))
2674         return false;
2675     }
2676
2677   /* Define the symbol as being at this point in the section.  */
2678   h->root.u.def.section = s;
2679   h->root.u.def.value = s->_raw_size;
2680
2681   /* Increment the section size to make room for the symbol.  */
2682   s->_raw_size += h->size;
2683
2684   return true;
2685 }
2686
2687 /* Set the sizes of the dynamic sections.  */
2688
2689 static boolean
2690 elf32_arm_size_dynamic_sections (output_bfd, info)
2691      bfd * output_bfd;
2692      struct bfd_link_info * info;
2693 {
2694   bfd * dynobj;
2695   asection * s;
2696   boolean plt;
2697   boolean relocs;
2698   boolean reltext;
2699
2700   dynobj = elf_hash_table (info)->dynobj;
2701   BFD_ASSERT (dynobj != NULL);
2702
2703   if (elf_hash_table (info)->dynamic_sections_created)
2704     {
2705       /* Set the contents of the .interp section to the interpreter.  */
2706       if (! info->shared)
2707         {
2708           s = bfd_get_section_by_name (dynobj, ".interp");
2709           BFD_ASSERT (s != NULL);
2710           s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
2711           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2712         }
2713     }
2714   else
2715     {
2716       /* We may have created entries in the .rel.got section.
2717          However, if we are not creating the dynamic sections, we will
2718          not actually use these entries.  Reset the size of .rel.got,
2719          which will cause it to get stripped from the output file
2720          below.  */
2721       s = bfd_get_section_by_name (dynobj, ".rel.got");
2722       if (s != NULL)
2723         s->_raw_size = 0;
2724     }
2725
2726   /* If this is a -Bsymbolic shared link, then we need to discard all
2727      PC relative relocs against symbols defined in a regular object.
2728      We allocated space for them in the check_relocs routine, but we
2729      will not fill them in in the relocate_section routine.  */
2730   if (info->shared && info->symbolic)
2731     elf32_arm_link_hash_traverse (elf32_arm_hash_table (info),
2732                                   elf32_arm_discard_copies,
2733                                   (PTR) NULL);
2734
2735   /* The check_relocs and adjust_dynamic_symbol entry points have
2736      determined the sizes of the various dynamic sections.  Allocate
2737      memory for them.  */
2738   plt = false;
2739   relocs = false;
2740   reltext = false;
2741   for (s = dynobj->sections; s != NULL; s = s->next)
2742     {
2743       const char * name;
2744       boolean strip;
2745
2746       if ((s->flags & SEC_LINKER_CREATED) == 0)
2747         continue;
2748
2749       /* It's OK to base decisions on the section name, because none
2750          of the dynobj section names depend upon the input files.  */
2751       name = bfd_get_section_name (dynobj, s);
2752
2753       strip = false;
2754
2755       if (strcmp (name, ".plt") == 0)
2756         {
2757           if (s->_raw_size == 0)
2758             {
2759               /* Strip this section if we don't need it; see the
2760                  comment below.  */
2761               strip = true;
2762             }
2763           else
2764             {
2765               /* Remember whether there is a PLT.  */
2766               plt = true;
2767             }
2768         }
2769       else if (strncmp (name, ".rel", 4) == 0)
2770         {
2771           if (s->_raw_size == 0)
2772             {
2773               /* If we don't need this section, strip it from the
2774                  output file.  This is mostly to handle .rel.bss and
2775                  .rel.plt.  We must create both sections in
2776                  create_dynamic_sections, because they must be created
2777                  before the linker maps input sections to output
2778                  sections.  The linker does that before
2779                  adjust_dynamic_symbol is called, and it is that
2780                  function which decides whether anything needs to go
2781                  into these sections.  */
2782               strip = true;
2783             }
2784           else
2785             {
2786               asection * target;
2787
2788               /* Remember whether there are any reloc sections other
2789                  than .rel.plt.  */
2790               if (strcmp (name, ".rel.plt") != 0)
2791                 {
2792                   const char *outname;
2793
2794                   relocs = true;
2795
2796                   /* If this relocation section applies to a read only
2797                      section, then we probably need a DT_TEXTREL
2798                      entry.  The entries in the .rel.plt section
2799                      really apply to the .got section, which we
2800                      created ourselves and so know is not readonly.  */
2801                   outname = bfd_get_section_name (output_bfd,
2802                                                   s->output_section);
2803                   target = bfd_get_section_by_name (output_bfd, outname + 4);
2804                   if (target != NULL
2805                       && (target->flags & SEC_READONLY) != 0
2806                       && (target->flags & SEC_ALLOC) != 0)
2807                     reltext = true;
2808                 }
2809
2810               /* We use the reloc_count field as a counter if we need
2811                  to copy relocs into the output file.  */
2812               s->reloc_count = 0;
2813             }
2814         }
2815       else if (strncmp (name, ".got", 4) != 0)
2816         {
2817           /* It's not one of our sections, so don't allocate space.  */
2818           continue;
2819         }
2820
2821       if (strip)
2822         {
2823           asection ** spp;
2824
2825           for (spp = &s->output_section->owner->sections;
2826                *spp != s->output_section;
2827                spp = &(*spp)->next)
2828             ;
2829           *spp = s->output_section->next;
2830           --s->output_section->owner->section_count;
2831
2832           continue;
2833         }
2834
2835       /* Allocate memory for the section contents.  */
2836       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
2837       if (s->contents == NULL && s->_raw_size != 0)
2838         return false;
2839     }
2840
2841   if (elf_hash_table (info)->dynamic_sections_created)
2842     {
2843       /* Add some entries to the .dynamic section.  We fill in the
2844          values later, in elf32_arm_finish_dynamic_sections, but we
2845          must add the entries now so that we get the correct size for
2846          the .dynamic section.  The DT_DEBUG entry is filled in by the
2847          dynamic linker and used by the debugger.  */
2848       if (! info->shared)
2849         {
2850           if (! bfd_elf32_add_dynamic_entry (info, DT_DEBUG, 0))
2851             return false;
2852         }
2853
2854       if (plt)
2855         {
2856           if (! bfd_elf32_add_dynamic_entry (info, DT_PLTGOT, 0)
2857               || ! bfd_elf32_add_dynamic_entry (info, DT_PLTRELSZ, 0)
2858               || ! bfd_elf32_add_dynamic_entry (info, DT_PLTREL, DT_REL)
2859               || ! bfd_elf32_add_dynamic_entry (info, DT_JMPREL, 0))
2860             return false;
2861         }
2862
2863       if (relocs)
2864         {
2865           if (! bfd_elf32_add_dynamic_entry (info, DT_REL, 0)
2866               || ! bfd_elf32_add_dynamic_entry (info, DT_RELSZ, 0)
2867               || ! bfd_elf32_add_dynamic_entry (info, DT_RELENT,
2868                                                 sizeof (Elf32_External_Rel)))
2869             return false;
2870         }
2871
2872       if (reltext)
2873         {
2874           if (! bfd_elf32_add_dynamic_entry (info, DT_TEXTREL, 0))
2875             return false;
2876         }
2877     }
2878
2879   return true;
2880 }
2881
2882 /* This function is called via elf32_arm_link_hash_traverse if we are
2883    creating a shared object with -Bsymbolic.  It discards the space
2884    allocated to copy PC relative relocs against symbols which are
2885    defined in regular objects.  We allocated space for them in the
2886    check_relocs routine, but we won't fill them in in the
2887    relocate_section routine.  */
2888
2889 static boolean
2890 elf32_arm_discard_copies (h, ignore)
2891      struct elf32_arm_link_hash_entry * h;
2892      PTR ignore ATTRIBUTE_UNUSED;
2893 {
2894   struct elf32_arm_pcrel_relocs_copied * s;
2895
2896   /* We only discard relocs for symbols defined in a regular object.  */
2897   if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2898     return true;
2899
2900   for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
2901     s->section->_raw_size -= s->count * sizeof (Elf32_External_Rel);
2902
2903   return true;
2904 }
2905
2906 /* Finish up dynamic symbol handling.  We set the contents of various
2907    dynamic sections here.  */
2908
2909 static boolean
2910 elf32_arm_finish_dynamic_symbol (output_bfd, info, h, sym)
2911      bfd * output_bfd;
2912      struct bfd_link_info * info;
2913      struct elf_link_hash_entry * h;
2914      Elf_Internal_Sym * sym;
2915 {
2916   bfd * dynobj;
2917
2918   dynobj = elf_hash_table (info)->dynobj;
2919
2920   if (h->plt.offset != (bfd_vma) -1)
2921     {
2922       asection * splt;
2923       asection * sgot;
2924       asection * srel;
2925       bfd_vma plt_index;
2926       bfd_vma got_offset;
2927       Elf_Internal_Rel rel;
2928
2929       /* This symbol has an entry in the procedure linkage table.  Set
2930          it up.  */
2931
2932       BFD_ASSERT (h->dynindx != -1);
2933
2934       splt = bfd_get_section_by_name (dynobj, ".plt");
2935       sgot = bfd_get_section_by_name (dynobj, ".got.plt");
2936       srel = bfd_get_section_by_name (dynobj, ".rel.plt");
2937       BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
2938
2939       /* Get the index in the procedure linkage table which
2940          corresponds to this symbol.  This is the index of this symbol
2941          in all the symbols for which we are making plt entries.  The
2942          first entry in the procedure linkage table is reserved.  */
2943       plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
2944
2945       /* Get the offset into the .got table of the entry that
2946          corresponds to this function.  Each .got entry is 4 bytes.
2947          The first three are reserved.  */
2948       got_offset = (plt_index + 3) * 4;
2949
2950       /* Fill in the entry in the procedure linkage table.  */
2951       memcpy (splt->contents + h->plt.offset,
2952               elf32_arm_plt_entry,
2953               PLT_ENTRY_SIZE);
2954       bfd_put_32 (output_bfd,
2955                       (sgot->output_section->vma
2956                        + sgot->output_offset
2957                        + got_offset
2958                        - splt->output_section->vma
2959                        - splt->output_offset
2960                        - h->plt.offset - 12),
2961                       splt->contents + h->plt.offset + 12);
2962
2963       /* Fill in the entry in the global offset table.  */
2964       bfd_put_32 (output_bfd,
2965                   (splt->output_section->vma
2966                    + splt->output_offset),
2967                   sgot->contents + got_offset);
2968
2969       /* Fill in the entry in the .rel.plt section.  */
2970       rel.r_offset = (sgot->output_section->vma
2971                       + sgot->output_offset
2972                       + got_offset);
2973       rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_JUMP_SLOT);
2974       bfd_elf32_swap_reloc_out (output_bfd, &rel,
2975                                 ((Elf32_External_Rel *) srel->contents
2976                                  + plt_index));
2977
2978       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2979         {
2980           /* Mark the symbol as undefined, rather than as defined in
2981              the .plt section.  Leave the value alone.  */
2982           sym->st_shndx = SHN_UNDEF;
2983         }
2984     }
2985
2986   if (h->got.offset != (bfd_vma) -1)
2987     {
2988       asection * sgot;
2989       asection * srel;
2990       Elf_Internal_Rel rel;
2991
2992       /* This symbol has an entry in the global offset table.  Set it
2993          up.  */
2994
2995       sgot = bfd_get_section_by_name (dynobj, ".got");
2996       srel = bfd_get_section_by_name (dynobj, ".rel.got");
2997       BFD_ASSERT (sgot != NULL && srel != NULL);
2998
2999       rel.r_offset = (sgot->output_section->vma
3000                       + sgot->output_offset
3001                       + (h->got.offset &~ 1));
3002
3003       /* If this is a -Bsymbolic link, and the symbol is defined
3004          locally, we just want to emit a RELATIVE reloc.  The entry in
3005          the global offset table will already have been initialized in
3006          the relocate_section function.  */
3007       if (info->shared
3008           && (info->symbolic || h->dynindx == -1)
3009           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
3010         rel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
3011       else
3012         {
3013           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
3014           rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT);
3015         }
3016
3017       bfd_elf32_swap_reloc_out (output_bfd, &rel,
3018                                 ((Elf32_External_Rel *) srel->contents
3019                                  + srel->reloc_count));
3020       ++srel->reloc_count;
3021     }
3022
3023   if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
3024     {
3025       asection * s;
3026       Elf_Internal_Rel rel;
3027
3028       /* This symbol needs a copy reloc.  Set it up.  */
3029
3030       BFD_ASSERT (h->dynindx != -1
3031                   && (h->root.type == bfd_link_hash_defined
3032                       || h->root.type == bfd_link_hash_defweak));
3033
3034       s = bfd_get_section_by_name (h->root.u.def.section->owner,
3035                                    ".rel.bss");
3036       BFD_ASSERT (s != NULL);
3037
3038       rel.r_offset = (h->root.u.def.value
3039                       + h->root.u.def.section->output_section->vma
3040                       + h->root.u.def.section->output_offset);
3041       rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_COPY);
3042       bfd_elf32_swap_reloc_out (output_bfd, &rel,
3043                                 ((Elf32_External_Rel *) s->contents
3044                                  + s->reloc_count));
3045       ++s->reloc_count;
3046     }
3047
3048   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
3049   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3050       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
3051     sym->st_shndx = SHN_ABS;
3052
3053   return true;
3054 }
3055
3056 /* Finish up the dynamic sections.  */
3057
3058 static boolean
3059 elf32_arm_finish_dynamic_sections (output_bfd, info)
3060      bfd * output_bfd;
3061      struct bfd_link_info * info;
3062 {
3063   bfd * dynobj;
3064   asection * sgot;
3065   asection * sdyn;
3066
3067   dynobj = elf_hash_table (info)->dynobj;
3068
3069   sgot = bfd_get_section_by_name (dynobj, ".got.plt");
3070   BFD_ASSERT (sgot != NULL);
3071   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3072
3073   if (elf_hash_table (info)->dynamic_sections_created)
3074     {
3075       asection *splt;
3076       Elf32_External_Dyn *dyncon, *dynconend;
3077
3078       splt = bfd_get_section_by_name (dynobj, ".plt");
3079       BFD_ASSERT (splt != NULL && sdyn != NULL);
3080
3081       dyncon = (Elf32_External_Dyn *) sdyn->contents;
3082       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
3083       for (; dyncon < dynconend; dyncon++)
3084         {
3085           Elf_Internal_Dyn dyn;
3086           const char * name;
3087           asection * s;
3088
3089           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3090
3091           switch (dyn.d_tag)
3092             {
3093             default:
3094               break;
3095
3096             case DT_PLTGOT:
3097               name = ".got";
3098               goto get_vma;
3099             case DT_JMPREL:
3100               name = ".rel.plt";
3101             get_vma:
3102               s = bfd_get_section_by_name (output_bfd, name);
3103               BFD_ASSERT (s != NULL);
3104               dyn.d_un.d_ptr = s->vma;
3105               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3106               break;
3107
3108             case DT_PLTRELSZ:
3109               s = bfd_get_section_by_name (output_bfd, ".rel.plt");
3110               BFD_ASSERT (s != NULL);
3111               if (s->_cooked_size != 0)
3112                 dyn.d_un.d_val = s->_cooked_size;
3113               else
3114                 dyn.d_un.d_val = s->_raw_size;
3115               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3116               break;
3117
3118             case DT_RELSZ:
3119               /* My reading of the SVR4 ABI indicates that the
3120                  procedure linkage table relocs (DT_JMPREL) should be
3121                  included in the overall relocs (DT_REL).  This is
3122                  what Solaris does.  However, UnixWare can not handle
3123                  that case.  Therefore, we override the DT_RELSZ entry
3124                  here to make it not include the JMPREL relocs.  Since
3125                  the linker script arranges for .rel.plt to follow all
3126                  other relocation sections, we don't have to worry
3127                  about changing the DT_REL entry.  */
3128               s = bfd_get_section_by_name (output_bfd, ".rel.plt");
3129               if (s != NULL)
3130                 {
3131                   if (s->_cooked_size != 0)
3132                     dyn.d_un.d_val -= s->_cooked_size;
3133                   else
3134                     dyn.d_un.d_val -= s->_raw_size;
3135                 }
3136               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3137               break;
3138             }
3139         }
3140
3141       /* Fill in the first entry in the procedure linkage table.  */
3142       if (splt->_raw_size > 0)
3143         memcpy (splt->contents, elf32_arm_plt0_entry, PLT_ENTRY_SIZE);
3144
3145       /* UnixWare sets the entsize of .plt to 4, although that doesn't
3146          really seem like the right value.  */
3147       elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
3148     }
3149
3150   /* Fill in the first three entries in the global offset table.  */
3151   if (sgot->_raw_size > 0)
3152     {
3153       if (sdyn == NULL)
3154         bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
3155       else
3156         bfd_put_32 (output_bfd,
3157                     sdyn->output_section->vma + sdyn->output_offset,
3158                     sgot->contents);
3159       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
3160       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
3161     }
3162
3163   elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
3164
3165   return true;
3166 }
3167
3168 static void
3169 elf32_arm_post_process_headers (abfd, link_info)
3170      bfd * abfd;
3171      struct bfd_link_info * link_info ATTRIBUTE_UNUSED;
3172 {
3173   Elf_Internal_Ehdr * i_ehdrp;  /* Elf file header, internal form */
3174
3175   i_ehdrp = elf_elfheader (abfd);
3176
3177   i_ehdrp->e_ident[EI_OSABI]      = ARM_ELF_OS_ABI_VERSION;
3178   i_ehdrp->e_ident[EI_ABIVERSION] = ARM_ELF_ABI_VERSION;
3179 }
3180
3181
3182 #define ELF_ARCH                        bfd_arch_arm
3183 #define ELF_MACHINE_CODE                EM_ARM
3184 #define ELF_MAXPAGESIZE                 0x8000
3185
3186
3187 #define bfd_elf32_bfd_copy_private_bfd_data     elf32_arm_copy_private_bfd_data
3188 #define bfd_elf32_bfd_merge_private_bfd_data    elf32_arm_merge_private_bfd_data
3189 #define bfd_elf32_bfd_set_private_flags         elf32_arm_set_private_flags
3190 #define bfd_elf32_bfd_print_private_bfd_data    elf32_arm_print_private_bfd_data
3191 #define bfd_elf32_bfd_link_hash_table_create    elf32_arm_link_hash_table_create
3192 #define bfd_elf32_bfd_reloc_type_lookup         elf32_arm_reloc_type_lookup
3193 #define bfd_elf32_find_nearest_line             elf32_arm_find_nearest_line
3194
3195 #define elf_backend_get_symbol_type             elf32_arm_get_symbol_type
3196 #define elf_backend_gc_mark_hook                elf32_arm_gc_mark_hook
3197 #define elf_backend_gc_sweep_hook               elf32_arm_gc_sweep_hook
3198 #define elf_backend_check_relocs                elf32_arm_check_relocs
3199 #define elf_backend_relocate_section            elf32_arm_relocate_section
3200 #define elf_backend_adjust_dynamic_symbol       elf32_arm_adjust_dynamic_symbol
3201 #define elf_backend_create_dynamic_sections     _bfd_elf_create_dynamic_sections
3202 #define elf_backend_finish_dynamic_symbol       elf32_arm_finish_dynamic_symbol
3203 #define elf_backend_finish_dynamic_sections     elf32_arm_finish_dynamic_sections
3204 #define elf_backend_size_dynamic_sections       elf32_arm_size_dynamic_sections
3205 #define elf_backend_post_process_headers        elf32_arm_post_process_headers
3206
3207 #define elf_backend_can_gc_sections 1
3208 #define elf_backend_plt_readonly    1
3209 #define elf_backend_want_got_plt    1
3210 #define elf_backend_want_plt_sym    0
3211
3212 #define elf_backend_got_header_size     12
3213 #define elf_backend_plt_header_size     PLT_ENTRY_SIZE
3214
3215 #include "elf32-target.h"