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