bfd/elf32-arm.h

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