bfd/elf32-arm.h

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