bfd/elf32-arm.h

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