bfd/elf32-arm.h

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