bfd/elf32-arm.h

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