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 then do not
2042          bother setting the flags for the output architecture,
2043          instead allow future merges to do this.  If no future
2044          merges ever set these flags then they will retain their
2045          unitialised values, which surprise surprise, correspond
2046          to the default values.  */
2047       if (bfd_get_arch_info (ibfd)->the_default)
2048         return true;
2049
2050       elf_flags_init (obfd) = true;
2051       elf_elfheader (obfd)->e_flags = in_flags;
2052
2053       if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
2054           && bfd_get_arch_info (obfd)->the_default)
2055         return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
2056
2057       return true;
2058     }
2059
2060   /* Check flag compatibility.  */
2061   if (in_flags == out_flags)
2062     return true;
2063
2064   /* Complain about various flag mismatches.  */
2065   if (EF_ARM_EABI_VERSION (in_flags) != EF_ARM_EABI_VERSION (out_flags))
2066     {
2067       _bfd_error_handler (_("\
2068 Error: %s compiled for EABI version %d, whereas %s is compiled for version %d"),
2069                          bfd_get_filename (ibfd),
2070                          (in_flags & EF_ARM_EABIMASK) >> 24,
2071                          bfd_get_filename (obfd),
2072                          (out_flags & EF_ARM_EABIMASK) >> 24);
2073     }
2074   else if (EF_ARM_EABI_VERSION (in_flags) != EF_ARM_EABI_UNKNOWN)
2075     /* Not sure what needs to be checked for EABI versions >= 1.  */
2076     return true;
2077
2078   if ((in_flags & EF_APCS_26) != (out_flags & EF_APCS_26))
2079     _bfd_error_handler (_("\
2080 Error: %s compiled for APCS-%d, whereas %s is compiled for APCS-%d"),
2081                         bfd_get_filename (ibfd),
2082                         in_flags & EF_APCS_26 ? 26 : 32,
2083                         bfd_get_filename (obfd),
2084                         out_flags & EF_APCS_26 ? 26 : 32);
2085
2086   if ((in_flags & EF_APCS_FLOAT) != (out_flags & EF_APCS_FLOAT))
2087     _bfd_error_handler (_("\
2088 Error: %s passes floats in %s registers, whereas %s passes them in %s registers"),
2089                         bfd_get_filename (ibfd),
2090                      in_flags & EF_APCS_FLOAT ? _("float") : _("integer"),
2091                         bfd_get_filename (obfd),
2092                       out_flags & EF_APCS_26 ? _("float") : _("integer"));
2093
2094   if ((in_flags & EF_PIC) != (out_flags & EF_PIC))
2095     _bfd_error_handler (_("\
2096 Error: %s is compiled as position %s code, whereas %s is not"),
2097                         bfd_get_filename (ibfd),
2098                     in_flags & EF_PIC ? _("independent") : _("dependent"),
2099                         bfd_get_filename (obfd));
2100
2101   /* Interworking mismatch is only a warning.  */
2102   if ((in_flags & EF_INTERWORK) != (out_flags & EF_INTERWORK))
2103     {
2104       _bfd_error_handler (_("\
2105 Warning: %s %s interworking, whereas %s %s"),
2106                           bfd_get_filename (ibfd),
2107           in_flags & EF_INTERWORK ? _("supports") : _("does not support"),
2108                           bfd_get_filename (obfd),
2109                     out_flags & EF_INTERWORK ? _("does not") : _("does"));
2110       return true;
2111     }
2112
2113   return false;
2114 }
2115
2116 /* Display the flags field.  */
2117
2118 static boolean
2119 elf32_arm_print_private_bfd_data (abfd, ptr)
2120      bfd *abfd;
2121      PTR ptr;
2122 {
2123   FILE * file = (FILE *) ptr;
2124   unsigned long flags;
2125
2126   BFD_ASSERT (abfd != NULL && ptr != NULL);
2127
2128   /* Print normal ELF private data.  */
2129   _bfd_elf_print_private_bfd_data (abfd, ptr);
2130
2131   flags = elf_elfheader (abfd)->e_flags;
2132   /* Ignore init flag - it may not be set, despite the flags field
2133      containing valid data.  */
2134
2135   /* xgettext:c-format */
2136   fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
2137
2138   switch (EF_ARM_EABI_VERSION (flags))
2139     {
2140     case EF_ARM_EABI_UNKNOWN:
2141       /* The following flag bits are GNU extenstions and not part of the
2142          official ARM ELF extended ABI.  Hence they are only decoded if
2143          the EABI version is not set.  */
2144       if (flags & EF_INTERWORK)
2145         fprintf (file, _(" [interworking enabled]"));
2146
2147       if (flags & EF_APCS_26)
2148         fprintf (file, _(" [APCS-26]"));
2149       else
2150         fprintf (file, _(" [APCS-32]"));
2151
2152       if (flags & EF_APCS_FLOAT)
2153         fprintf (file, _(" [floats passed in float registers]"));
2154
2155       if (flags & EF_PIC)
2156         fprintf (file, _(" [position independent]"));
2157
2158       if (flags & EF_NEW_ABI)
2159         fprintf (file, _(" [new ABI]"));
2160
2161       if (flags & EF_OLD_ABI)
2162         fprintf (file, _(" [old ABI]"));
2163
2164       if (flags & EF_SOFT_FLOAT)
2165         fprintf (file, _(" [software FP]"));
2166
2167       flags &= ~(EF_INTERWORK | EF_APCS_26 | EF_APCS_FLOAT | EF_PIC
2168                  | EF_NEW_ABI | EF_OLD_ABI | EF_SOFT_FLOAT);
2169       break;
2170
2171     case EF_ARM_EABI_VER1:
2172       fprintf (file, _(" [Version1 EABI]"));
2173
2174       if (flags & EF_ARM_SYMSARESORTED)
2175         fprintf (file, _(" [sorted symbol table]"));
2176       else
2177         fprintf (file, _(" [unsorted symbol table]"));
2178
2179       flags &= ~ EF_ARM_SYMSARESORTED;
2180       break;
2181
2182     default:
2183       fprintf (file, _(" <EABI version unrecognised>"));
2184       break;
2185     }
2186
2187   flags &= ~ EF_ARM_EABIMASK;
2188
2189   if (flags & EF_ARM_RELEXEC)
2190     fprintf (file, _(" [relocatable executable]"));
2191
2192   if (flags & EF_ARM_HASENTRY)
2193     fprintf (file, _(" [has entry point]"));
2194
2195   flags &= ~ (EF_ARM_RELEXEC | EF_ARM_HASENTRY);
2196
2197   if (flags)
2198     fprintf (file, _("<Unrecognised flag bits set>"));
2199
2200   fputc ('\n', file);
2201
2202   return true;
2203 }
2204
2205 static int
2206 elf32_arm_get_symbol_type (elf_sym, type)
2207      Elf_Internal_Sym * elf_sym;
2208      int type;
2209 {
2210   switch (ELF_ST_TYPE (elf_sym->st_info))
2211     {
2212     case STT_ARM_TFUNC:
2213       return ELF_ST_TYPE (elf_sym->st_info);
2214
2215     case STT_ARM_16BIT:
2216       /* If the symbol is not an object, return the STT_ARM_16BIT flag.
2217          This allows us to distinguish between data used by Thumb instructions
2218          and non-data (which is probably code) inside Thumb regions of an
2219          executable.  */
2220       if (type != STT_OBJECT)
2221         return ELF_ST_TYPE (elf_sym->st_info);
2222       break;
2223
2224     default:
2225       break;
2226     }
2227
2228   return type;
2229 }
2230
2231 static asection *
2232 elf32_arm_gc_mark_hook (abfd, info, rel, h, sym)
2233        bfd *abfd;
2234        struct bfd_link_info *info ATTRIBUTE_UNUSED;
2235        Elf_Internal_Rela *rel;
2236        struct elf_link_hash_entry *h;
2237        Elf_Internal_Sym *sym;
2238 {
2239   if (h != NULL)
2240     {
2241       switch (ELF32_R_TYPE (rel->r_info))
2242       {
2243       case R_ARM_GNU_VTINHERIT:
2244       case R_ARM_GNU_VTENTRY:
2245         break;
2246
2247       default:
2248         switch (h->root.type)
2249           {
2250           case bfd_link_hash_defined:
2251           case bfd_link_hash_defweak:
2252             return h->root.u.def.section;
2253
2254           case bfd_link_hash_common:
2255             return h->root.u.c.p->section;
2256
2257           default:
2258             break;
2259           }
2260        }
2261      }
2262    else
2263      {
2264        if (!(elf_bad_symtab (abfd)
2265            && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
2266          && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
2267                 && sym->st_shndx != SHN_COMMON))
2268           {
2269             return bfd_section_from_elf_index (abfd, sym->st_shndx);
2270           }
2271       }
2272   return NULL;
2273 }
2274
2275 /* Update the got entry reference counts for the section being removed.  */
2276
2277 static boolean
2278 elf32_arm_gc_sweep_hook (abfd, info, sec, relocs)
2279      bfd *abfd ATTRIBUTE_UNUSED;
2280      struct bfd_link_info *info ATTRIBUTE_UNUSED;
2281      asection *sec ATTRIBUTE_UNUSED;
2282      const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
2283 {
2284   /* We don't support garbage collection of GOT and PLT relocs yet.  */
2285   return true;
2286 }
2287
2288 /* Look through the relocs for a section during the first phase.  */
2289
2290 static boolean
2291 elf32_arm_check_relocs (abfd, info, sec, relocs)
2292      bfd *                      abfd;
2293      struct bfd_link_info *     info;
2294      asection *                 sec;
2295      const Elf_Internal_Rela *  relocs;
2296 {
2297   Elf_Internal_Shdr *           symtab_hdr;
2298   struct elf_link_hash_entry ** sym_hashes;
2299   struct elf_link_hash_entry ** sym_hashes_end;
2300   const Elf_Internal_Rela *     rel;
2301   const Elf_Internal_Rela *     rel_end;
2302   bfd *                         dynobj;
2303   asection * sgot, *srelgot, *sreloc;
2304   bfd_vma * local_got_offsets;
2305
2306   if (info->relocateable)
2307     return true;
2308
2309   sgot = srelgot = sreloc = NULL;
2310
2311   dynobj = elf_hash_table (info)->dynobj;
2312   local_got_offsets = elf_local_got_offsets (abfd);
2313
2314   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2315   sym_hashes = elf_sym_hashes (abfd);
2316   sym_hashes_end = sym_hashes
2317     + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
2318
2319   if (!elf_bad_symtab (abfd))
2320     sym_hashes_end -= symtab_hdr->sh_info;
2321
2322   rel_end = relocs + sec->reloc_count;
2323   for (rel = relocs; rel < rel_end; rel++)
2324     {
2325       struct elf_link_hash_entry *h;
2326       unsigned long r_symndx;
2327
2328       r_symndx = ELF32_R_SYM (rel->r_info);
2329       if (r_symndx < symtab_hdr->sh_info)
2330         h = NULL;
2331       else
2332         h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2333
2334       /* Some relocs require a global offset table.  */
2335       if (dynobj == NULL)
2336         {
2337           switch (ELF32_R_TYPE (rel->r_info))
2338             {
2339             case R_ARM_GOT32:
2340             case R_ARM_GOTOFF:
2341             case R_ARM_GOTPC:
2342               elf_hash_table (info)->dynobj = dynobj = abfd;
2343               if (! _bfd_elf_create_got_section (dynobj, info))
2344                 return false;
2345               break;
2346
2347             default:
2348               break;
2349             }
2350         }
2351
2352       switch (ELF32_R_TYPE (rel->r_info))
2353         {
2354           case R_ARM_GOT32:
2355             /* This symbol requires a global offset table entry.  */
2356             if (sgot == NULL)
2357               {
2358                 sgot = bfd_get_section_by_name (dynobj, ".got");
2359                 BFD_ASSERT (sgot != NULL);
2360               }
2361
2362             /* Get the got relocation section if necessary.  */
2363             if (srelgot == NULL
2364                 && (h != NULL || info->shared))
2365               {
2366                 srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
2367
2368                 /* If no got relocation section, make one and initialize.  */
2369                 if (srelgot == NULL)
2370                   {
2371                     srelgot = bfd_make_section (dynobj, ".rel.got");
2372                     if (srelgot == NULL
2373                         || ! bfd_set_section_flags (dynobj, srelgot,
2374                                                     (SEC_ALLOC
2375                                                      | SEC_LOAD
2376                                                      | SEC_HAS_CONTENTS
2377                                                      | SEC_IN_MEMORY
2378                                                      | SEC_LINKER_CREATED
2379                                                      | SEC_READONLY))
2380                         || ! bfd_set_section_alignment (dynobj, srelgot, 2))
2381                       return false;
2382                   }
2383               }
2384
2385             if (h != NULL)
2386               {
2387                 if (h->got.offset != (bfd_vma) -1)
2388                   /* We have already allocated space in the .got.  */
2389                   break;
2390
2391                 h->got.offset = sgot->_raw_size;
2392
2393                 /* Make sure this symbol is output as a dynamic symbol.  */
2394                 if (h->dynindx == -1)
2395                   if (! bfd_elf32_link_record_dynamic_symbol (info, h))
2396                     return false;
2397
2398                 srelgot->_raw_size += sizeof (Elf32_External_Rel);
2399               }
2400             else
2401               {
2402                 /* This is a global offset table entry for a local
2403                    symbol.  */
2404                 if (local_got_offsets == NULL)
2405                   {
2406                     size_t size;
2407                     register unsigned int i;
2408
2409                     size = symtab_hdr->sh_info * sizeof (bfd_vma);
2410                     local_got_offsets = (bfd_vma *) bfd_alloc (abfd, size);
2411                     if (local_got_offsets == NULL)
2412                       return false;
2413                     elf_local_got_offsets (abfd) = local_got_offsets;
2414                     for (i = 0; i < symtab_hdr->sh_info; i++)
2415                       local_got_offsets[i] = (bfd_vma) -1;
2416                   }
2417
2418                 if (local_got_offsets[r_symndx] != (bfd_vma) -1)
2419                   /* We have already allocated space in the .got.  */
2420                   break;
2421
2422                 local_got_offsets[r_symndx] = sgot->_raw_size;
2423
2424                 if (info->shared)
2425                   /* If we are generating a shared object, we need to
2426                      output a R_ARM_RELATIVE reloc so that the dynamic
2427                      linker can adjust this GOT entry.  */
2428                   srelgot->_raw_size += sizeof (Elf32_External_Rel);
2429               }
2430
2431             sgot->_raw_size += 4;
2432             break;
2433
2434           case R_ARM_PLT32:
2435             /* This symbol requires a procedure linkage table entry.  We
2436                actually build the entry in adjust_dynamic_symbol,
2437                because this might be a case of linking PIC code which is
2438                never referenced by a dynamic object, in which case we
2439                don't need to generate a procedure linkage table entry
2440                after all.  */
2441
2442             /* If this is a local symbol, we resolve it directly without
2443                creating a procedure linkage table entry.  */
2444             if (h == NULL)
2445               continue;
2446
2447             h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2448             break;
2449
2450           case R_ARM_ABS32:
2451           case R_ARM_REL32:
2452           case R_ARM_PC24:
2453             /* If we are creating a shared library, and this is a reloc
2454                against a global symbol, or a non PC relative reloc
2455                against a local symbol, then we need to copy the reloc
2456                into the shared library.  However, if we are linking with
2457                -Bsymbolic, we do not need to copy a reloc against a
2458                global symbol which is defined in an object we are
2459                including in the link (i.e., DEF_REGULAR is set).  At
2460                this point we have not seen all the input files, so it is
2461                possible that DEF_REGULAR is not set now but will be set
2462                later (it is never cleared).  We account for that
2463                possibility below by storing information in the
2464                pcrel_relocs_copied field of the hash table entry.  */
2465             if (info->shared
2466               && (ELF32_R_TYPE (rel->r_info) != R_ARM_PC24
2467                 || (h != NULL
2468                   && (! info->symbolic
2469                     || (h->elf_link_hash_flags
2470                       & ELF_LINK_HASH_DEF_REGULAR) == 0))))
2471               {
2472                 /* When creating a shared object, we must copy these
2473                    reloc types into the output file.  We create a reloc
2474                    section in dynobj and make room for this reloc.  */
2475                 if (sreloc == NULL)
2476                   {
2477                     const char * name;
2478
2479                     name = (bfd_elf_string_from_elf_section
2480                             (abfd,
2481                              elf_elfheader (abfd)->e_shstrndx,
2482                              elf_section_data (sec)->rel_hdr.sh_name));
2483                     if (name == NULL)
2484                       return false;
2485
2486                     BFD_ASSERT (strncmp (name, ".rel", 4) == 0
2487                                 && strcmp (bfd_get_section_name (abfd, sec),
2488                                            name + 4) == 0);
2489
2490                     sreloc = bfd_get_section_by_name (dynobj, name);
2491                     if (sreloc == NULL)
2492                       {
2493                         flagword flags;
2494
2495                         sreloc = bfd_make_section (dynobj, name);
2496                         flags = (SEC_HAS_CONTENTS | SEC_READONLY
2497                                  | SEC_IN_MEMORY | SEC_LINKER_CREATED);
2498                         if ((sec->flags & SEC_ALLOC) != 0)
2499                           flags |= SEC_ALLOC | SEC_LOAD;
2500                         if (sreloc == NULL
2501                             || ! bfd_set_section_flags (dynobj, sreloc, flags)
2502                             || ! bfd_set_section_alignment (dynobj, sreloc, 2))
2503                           return false;
2504                       }
2505                   }
2506
2507                 sreloc->_raw_size += sizeof (Elf32_External_Rel);
2508                 /* If we are linking with -Bsymbolic, and this is a
2509                    global symbol, we count the number of PC relative
2510                    relocations we have entered for this symbol, so that
2511                    we can discard them again if the symbol is later
2512                    defined by a regular object.  Note that this function
2513                    is only called if we are using an elf_i386 linker
2514                    hash table, which means that h is really a pointer to
2515                    an elf_i386_link_hash_entry.  */
2516                 if (h != NULL && info->symbolic
2517                     && ELF32_R_TYPE (rel->r_info) == R_ARM_PC24)
2518                   {
2519                     struct elf32_arm_link_hash_entry * eh;
2520                     struct elf32_arm_pcrel_relocs_copied * p;
2521
2522                     eh = (struct elf32_arm_link_hash_entry *) h;
2523
2524                     for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next)
2525                       if (p->section == sreloc)
2526                         break;
2527
2528                     if (p == NULL)
2529                       {
2530                         p = ((struct elf32_arm_pcrel_relocs_copied *)
2531                              bfd_alloc (dynobj, sizeof * p));
2532
2533                         if (p == NULL)
2534                           return false;
2535                         p->next = eh->pcrel_relocs_copied;
2536                         eh->pcrel_relocs_copied = p;
2537                         p->section = sreloc;
2538                         p->count = 0;
2539                       }
2540
2541                     ++p->count;
2542                   }
2543               }
2544             break;
2545
2546         /* This relocation describes the C++ object vtable hierarchy.
2547            Reconstruct it for later use during GC.  */
2548         case R_ARM_GNU_VTINHERIT:
2549           if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2550             return false;
2551           break;
2552
2553         /* This relocation describes which C++ vtable entries are actually
2554            used.  Record for later use during GC.  */
2555         case R_ARM_GNU_VTENTRY:
2556           if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_offset))
2557             return false;
2558           break;
2559         }
2560     }
2561
2562   return true;
2563 }
2564
2565
2566 /* Find the nearest line to a particular section and offset, for error
2567    reporting.   This code is a duplicate of the code in elf.c, except
2568    that it also accepts STT_ARM_TFUNC as a symbol that names a function.  */
2569
2570 static boolean
2571 elf32_arm_find_nearest_line
2572   (abfd, section, symbols, offset, filename_ptr, functionname_ptr, line_ptr)
2573      bfd *          abfd;
2574      asection *     section;
2575      asymbol **     symbols;
2576      bfd_vma        offset;
2577      CONST char **  filename_ptr;
2578      CONST char **  functionname_ptr;
2579      unsigned int * line_ptr;
2580 {
2581   boolean      found;
2582   const char * filename;
2583   asymbol *    func;
2584   bfd_vma      low_func;
2585   asymbol **   p;
2586
2587   if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
2588                                      filename_ptr, functionname_ptr,
2589                                      line_ptr, 0))
2590     return true;
2591
2592   if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
2593                                              &found, filename_ptr,
2594                                              functionname_ptr, line_ptr,
2595                                              &elf_tdata (abfd)->line_info))
2596     return false;
2597
2598   if (found)
2599     return true;
2600
2601   if (symbols == NULL)
2602     return false;
2603
2604   filename = NULL;
2605   func = NULL;
2606   low_func = 0;
2607
2608   for (p = symbols; *p != NULL; p++)
2609     {
2610       elf_symbol_type *q;
2611
2612       q = (elf_symbol_type *) *p;
2613
2614       if (bfd_get_section (&q->symbol) != section)
2615         continue;
2616
2617       switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
2618         {
2619         default:
2620           break;
2621         case STT_FILE:
2622           filename = bfd_asymbol_name (&q->symbol);
2623           break;
2624         case STT_NOTYPE:
2625         case STT_FUNC:
2626         case STT_ARM_TFUNC:
2627           if (q->symbol.section == section
2628               && q->symbol.value >= low_func
2629               && q->symbol.value <= offset)
2630             {
2631               func = (asymbol *) q;
2632               low_func = q->symbol.value;
2633             }
2634           break;
2635         }
2636     }
2637
2638   if (func == NULL)
2639     return false;
2640
2641   *filename_ptr = filename;
2642   *functionname_ptr = bfd_asymbol_name (func);
2643   *line_ptr = 0;
2644
2645   return true;
2646 }
2647
2648 /* Adjust a symbol defined by a dynamic object and referenced by a
2649    regular object.  The current definition is in some section of the
2650    dynamic object, but we're not including those sections.  We have to
2651    change the definition to something the rest of the link can
2652    understand.  */
2653
2654 static boolean
2655 elf32_arm_adjust_dynamic_symbol (info, h)
2656      struct bfd_link_info * info;
2657      struct elf_link_hash_entry * h;
2658 {
2659   bfd * dynobj;
2660   asection * s;
2661   unsigned int power_of_two;
2662
2663   dynobj = elf_hash_table (info)->dynobj;
2664
2665   /* Make sure we know what is going on here.  */
2666   BFD_ASSERT (dynobj != NULL
2667               && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
2668                   || h->weakdef != NULL
2669                   || ((h->elf_link_hash_flags
2670                        & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2671                       && (h->elf_link_hash_flags
2672                           & ELF_LINK_HASH_REF_REGULAR) != 0
2673                       && (h->elf_link_hash_flags
2674                           & ELF_LINK_HASH_DEF_REGULAR) == 0)));
2675
2676   /* If this is a function, put it in the procedure linkage table.  We
2677      will fill in the contents of the procedure linkage table later,
2678      when we know the address of the .got section.  */
2679   if (h->type == STT_FUNC
2680       || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
2681     {
2682       if (! info->shared
2683           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
2684           && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0)
2685         {
2686           /* This case can occur if we saw a PLT32 reloc in an input
2687              file, but the symbol was never referred to by a dynamic
2688              object.  In such a case, we don't actually need to build
2689              a procedure linkage table, and we can just do a PC32
2690              reloc instead.  */
2691           BFD_ASSERT ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0);
2692           return true;
2693         }
2694
2695       /* Make sure this symbol is output as a dynamic symbol.  */
2696       if (h->dynindx == -1)
2697         {
2698           if (! bfd_elf32_link_record_dynamic_symbol (info, h))
2699             return false;
2700         }
2701
2702       s = bfd_get_section_by_name (dynobj, ".plt");
2703       BFD_ASSERT (s != NULL);
2704
2705       /* If this is the first .plt entry, make room for the special
2706          first entry.  */
2707       if (s->_raw_size == 0)
2708         s->_raw_size += PLT_ENTRY_SIZE;
2709
2710       /* If this symbol is not defined in a regular file, and we are
2711          not generating a shared library, then set the symbol to this
2712          location in the .plt.  This is required to make function
2713          pointers compare as equal between the normal executable and
2714          the shared library.  */
2715       if (! info->shared
2716           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2717         {
2718           h->root.u.def.section = s;
2719           h->root.u.def.value = s->_raw_size;
2720         }
2721
2722       h->plt.offset = s->_raw_size;
2723
2724       /* Make room for this entry.  */
2725       s->_raw_size += PLT_ENTRY_SIZE;
2726
2727       /* We also need to make an entry in the .got.plt section, which
2728          will be placed in the .got section by the linker script.  */
2729       s = bfd_get_section_by_name (dynobj, ".got.plt");
2730       BFD_ASSERT (s != NULL);
2731       s->_raw_size += 4;
2732
2733       /* We also need to make an entry in the .rel.plt section.  */
2734
2735       s = bfd_get_section_by_name (dynobj, ".rel.plt");
2736       BFD_ASSERT (s != NULL);
2737       s->_raw_size += sizeof (Elf32_External_Rel);
2738
2739       return true;
2740     }
2741
2742   /* If this is a weak symbol, and there is a real definition, the
2743      processor independent code will have arranged for us to see the
2744      real definition first, and we can just use the same value.  */
2745   if (h->weakdef != NULL)
2746     {
2747       BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
2748                   || h->weakdef->root.type == bfd_link_hash_defweak);
2749       h->root.u.def.section = h->weakdef->root.u.def.section;
2750       h->root.u.def.value = h->weakdef->root.u.def.value;
2751       return true;
2752     }
2753
2754   /* This is a reference to a symbol defined by a dynamic object which
2755      is not a function.  */
2756
2757   /* If we are creating a shared library, we must presume that the
2758      only references to the symbol are via the global offset table.
2759      For such cases we need not do anything here; the relocations will
2760      be handled correctly by relocate_section.  */
2761   if (info->shared)
2762     return true;
2763
2764   /* We must allocate the symbol in our .dynbss section, which will
2765      become part of the .bss section of the executable.  There will be
2766      an entry for this symbol in the .dynsym section.  The dynamic
2767      object will contain position independent code, so all references
2768      from the dynamic object to this symbol will go through the global
2769      offset table.  The dynamic linker will use the .dynsym entry to
2770      determine the address it must put in the global offset table, so
2771      both the dynamic object and the regular object will refer to the
2772      same memory location for the variable.  */
2773   s = bfd_get_section_by_name (dynobj, ".dynbss");
2774   BFD_ASSERT (s != NULL);
2775
2776   /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
2777      copy the initial value out of the dynamic object and into the
2778      runtime process image.  We need to remember the offset into the
2779      .rel.bss section we are going to use.  */
2780   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
2781     {
2782       asection *srel;
2783
2784       srel = bfd_get_section_by_name (dynobj, ".rel.bss");
2785       BFD_ASSERT (srel != NULL);
2786       srel->_raw_size += sizeof (Elf32_External_Rel);
2787       h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
2788     }
2789
2790   /* We need to figure out the alignment required for this symbol.  I
2791      have no idea how ELF linkers handle this.  */
2792   power_of_two = bfd_log2 (h->size);
2793   if (power_of_two > 3)
2794     power_of_two = 3;
2795
2796   /* Apply the required alignment.  */
2797   s->_raw_size = BFD_ALIGN (s->_raw_size,
2798                             (bfd_size_type) (1 << power_of_two));
2799   if (power_of_two > bfd_get_section_alignment (dynobj, s))
2800     {
2801       if (! bfd_set_section_alignment (dynobj, s, power_of_two))
2802         return false;
2803     }
2804
2805   /* Define the symbol as being at this point in the section.  */
2806   h->root.u.def.section = s;
2807   h->root.u.def.value = s->_raw_size;
2808
2809   /* Increment the section size to make room for the symbol.  */
2810   s->_raw_size += h->size;
2811
2812   return true;
2813 }
2814
2815 /* Set the sizes of the dynamic sections.  */
2816
2817 static boolean
2818 elf32_arm_size_dynamic_sections (output_bfd, info)
2819      bfd * output_bfd;
2820      struct bfd_link_info * info;
2821 {
2822   bfd * dynobj;
2823   asection * s;
2824   boolean plt;
2825   boolean relocs;
2826   boolean reltext;
2827
2828   dynobj = elf_hash_table (info)->dynobj;
2829   BFD_ASSERT (dynobj != NULL);
2830
2831   if (elf_hash_table (info)->dynamic_sections_created)
2832     {
2833       /* Set the contents of the .interp section to the interpreter.  */
2834       if (! info->shared)
2835         {
2836           s = bfd_get_section_by_name (dynobj, ".interp");
2837           BFD_ASSERT (s != NULL);
2838           s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
2839           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2840         }
2841     }
2842   else
2843     {
2844       /* We may have created entries in the .rel.got section.
2845          However, if we are not creating the dynamic sections, we will
2846          not actually use these entries.  Reset the size of .rel.got,
2847          which will cause it to get stripped from the output file
2848          below.  */
2849       s = bfd_get_section_by_name (dynobj, ".rel.got");
2850       if (s != NULL)
2851         s->_raw_size = 0;
2852     }
2853
2854   /* If this is a -Bsymbolic shared link, then we need to discard all
2855      PC relative relocs against symbols defined in a regular object.
2856      We allocated space for them in the check_relocs routine, but we
2857      will not fill them in in the relocate_section routine.  */
2858   if (info->shared && info->symbolic)
2859     elf32_arm_link_hash_traverse (elf32_arm_hash_table (info),
2860                                   elf32_arm_discard_copies,
2861                                   (PTR) NULL);
2862
2863   /* The check_relocs and adjust_dynamic_symbol entry points have
2864      determined the sizes of the various dynamic sections.  Allocate
2865      memory for them.  */
2866   plt = false;
2867   relocs = false;
2868   reltext = false;
2869   for (s = dynobj->sections; s != NULL; s = s->next)
2870     {
2871       const char * name;
2872       boolean strip;
2873
2874       if ((s->flags & SEC_LINKER_CREATED) == 0)
2875         continue;
2876
2877       /* It's OK to base decisions on the section name, because none
2878          of the dynobj section names depend upon the input files.  */
2879       name = bfd_get_section_name (dynobj, s);
2880
2881       strip = false;
2882
2883       if (strcmp (name, ".plt") == 0)
2884         {
2885           if (s->_raw_size == 0)
2886             {
2887               /* Strip this section if we don't need it; see the
2888                  comment below.  */
2889               strip = true;
2890             }
2891           else
2892             {
2893               /* Remember whether there is a PLT.  */
2894               plt = true;
2895             }
2896         }
2897       else if (strncmp (name, ".rel", 4) == 0)
2898         {
2899           if (s->_raw_size == 0)
2900             {
2901               /* If we don't need this section, strip it from the
2902                  output file.  This is mostly to handle .rel.bss and
2903                  .rel.plt.  We must create both sections in
2904                  create_dynamic_sections, because they must be created
2905                  before the linker maps input sections to output
2906                  sections.  The linker does that before
2907                  adjust_dynamic_symbol is called, and it is that
2908                  function which decides whether anything needs to go
2909                  into these sections.  */
2910               strip = true;
2911             }
2912           else
2913             {
2914               asection * target;
2915
2916               /* Remember whether there are any reloc sections other
2917                  than .rel.plt.  */
2918               if (strcmp (name, ".rel.plt") != 0)
2919                 {
2920                   const char *outname;
2921
2922                   relocs = true;
2923
2924                   /* If this relocation section applies to a read only
2925                      section, then we probably need a DT_TEXTREL
2926                      entry.  The entries in the .rel.plt section
2927                      really apply to the .got section, which we
2928                      created ourselves and so know is not readonly.  */
2929                   outname = bfd_get_section_name (output_bfd,
2930                                                   s->output_section);
2931                   target = bfd_get_section_by_name (output_bfd, outname + 4);
2932
2933                   if (target != NULL
2934                       && (target->flags & SEC_READONLY) != 0
2935                       && (target->flags & SEC_ALLOC) != 0)
2936                     reltext = true;
2937                 }
2938
2939               /* We use the reloc_count field as a counter if we need
2940                  to copy relocs into the output file.  */
2941               s->reloc_count = 0;
2942             }
2943         }
2944       else if (strncmp (name, ".got", 4) != 0)
2945         {
2946           /* It's not one of our sections, so don't allocate space.  */
2947           continue;
2948         }
2949
2950       if (strip)
2951         {
2952           asection ** spp;
2953
2954           for (spp = &s->output_section->owner->sections;
2955                *spp != s->output_section;
2956                spp = &(*spp)->next)
2957             ;
2958           *spp = s->output_section->next;
2959           --s->output_section->owner->section_count;
2960
2961           continue;
2962         }
2963
2964       /* Allocate memory for the section contents.  */
2965       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
2966       if (s->contents == NULL && s->_raw_size != 0)
2967         return false;
2968     }
2969
2970   if (elf_hash_table (info)->dynamic_sections_created)
2971     {
2972       /* Add some entries to the .dynamic section.  We fill in the
2973          values later, in elf32_arm_finish_dynamic_sections, but we
2974          must add the entries now so that we get the correct size for
2975          the .dynamic section.  The DT_DEBUG entry is filled in by the
2976          dynamic linker and used by the debugger.  */
2977       if (! info->shared)
2978         {
2979           if (! bfd_elf32_add_dynamic_entry (info, DT_DEBUG, 0))
2980             return false;
2981         }
2982
2983       if (plt)
2984         {
2985           if (   ! bfd_elf32_add_dynamic_entry (info, DT_PLTGOT, 0)
2986               || ! bfd_elf32_add_dynamic_entry (info, DT_PLTRELSZ, 0)
2987               || ! bfd_elf32_add_dynamic_entry (info, DT_PLTREL, DT_REL)
2988               || ! bfd_elf32_add_dynamic_entry (info, DT_JMPREL, 0))
2989             return false;
2990         }
2991
2992       if (relocs)
2993         {
2994           if (   ! bfd_elf32_add_dynamic_entry (info, DT_REL, 0)
2995               || ! bfd_elf32_add_dynamic_entry (info, DT_RELSZ, 0)
2996               || ! bfd_elf32_add_dynamic_entry (info, DT_RELENT,
2997                                                 sizeof (Elf32_External_Rel)))
2998             return false;
2999         }
3000
3001       if (reltext)
3002         {
3003           if (! bfd_elf32_add_dynamic_entry (info, DT_TEXTREL, 0))
3004             return false;
3005           info->flags |= DF_TEXTREL;
3006         }
3007     }
3008
3009   return true;
3010 }
3011
3012 /* This function is called via elf32_arm_link_hash_traverse if we are
3013    creating a shared object with -Bsymbolic.  It discards the space
3014    allocated to copy PC relative relocs against symbols which are
3015    defined in regular objects.  We allocated space for them in the
3016    check_relocs routine, but we won't fill them in in the
3017    relocate_section routine.  */
3018
3019 static boolean
3020 elf32_arm_discard_copies (h, ignore)
3021      struct elf32_arm_link_hash_entry * h;
3022      PTR ignore ATTRIBUTE_UNUSED;
3023 {
3024   struct elf32_arm_pcrel_relocs_copied * s;
3025
3026   /* We only discard relocs for symbols defined in a regular object.  */
3027   if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
3028     return true;
3029
3030   for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
3031     s->section->_raw_size -= s->count * sizeof (Elf32_External_Rel);
3032
3033   return true;
3034 }
3035
3036 /* Finish up dynamic symbol handling.  We set the contents of various
3037    dynamic sections here.  */
3038
3039 static boolean
3040 elf32_arm_finish_dynamic_symbol (output_bfd, info, h, sym)
3041      bfd * output_bfd;
3042      struct bfd_link_info * info;
3043      struct elf_link_hash_entry * h;
3044      Elf_Internal_Sym * sym;
3045 {
3046   bfd * dynobj;
3047
3048   dynobj = elf_hash_table (info)->dynobj;
3049
3050   if (h->plt.offset != (bfd_vma) -1)
3051     {
3052       asection * splt;
3053       asection * sgot;
3054       asection * srel;
3055       bfd_vma plt_index;
3056       bfd_vma got_offset;
3057       Elf_Internal_Rel rel;
3058
3059       /* This symbol has an entry in the procedure linkage table.  Set
3060          it up.  */
3061
3062       BFD_ASSERT (h->dynindx != -1);
3063
3064       splt = bfd_get_section_by_name (dynobj, ".plt");
3065       sgot = bfd_get_section_by_name (dynobj, ".got.plt");
3066       srel = bfd_get_section_by_name (dynobj, ".rel.plt");
3067       BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
3068
3069       /* Get the index in the procedure linkage table which
3070          corresponds to this symbol.  This is the index of this symbol
3071          in all the symbols for which we are making plt entries.  The
3072          first entry in the procedure linkage table is reserved.  */
3073       plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
3074
3075       /* Get the offset into the .got table of the entry that
3076          corresponds to this function.  Each .got entry is 4 bytes.
3077          The first three are reserved.  */
3078       got_offset = (plt_index + 3) * 4;
3079
3080       /* Fill in the entry in the procedure linkage table.  */
3081       memcpy (splt->contents + h->plt.offset,
3082               elf32_arm_plt_entry,
3083               PLT_ENTRY_SIZE);
3084       bfd_put_32 (output_bfd,
3085                       (sgot->output_section->vma
3086                        + sgot->output_offset
3087                        + got_offset
3088                        - splt->output_section->vma
3089                        - splt->output_offset
3090                        - h->plt.offset - 12),
3091                       splt->contents + h->plt.offset + 12);
3092
3093       /* Fill in the entry in the global offset table.  */
3094       bfd_put_32 (output_bfd,
3095                   (splt->output_section->vma
3096                    + splt->output_offset),
3097                   sgot->contents + got_offset);
3098
3099       /* Fill in the entry in the .rel.plt section.  */
3100       rel.r_offset = (sgot->output_section->vma
3101                       + sgot->output_offset
3102                       + got_offset);
3103       rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_JUMP_SLOT);
3104       bfd_elf32_swap_reloc_out (output_bfd, &rel,
3105                                 ((Elf32_External_Rel *) srel->contents
3106                                  + plt_index));
3107
3108       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
3109         {
3110           /* Mark the symbol as undefined, rather than as defined in
3111              the .plt section.  Leave the value alone.  */
3112           sym->st_shndx = SHN_UNDEF;
3113         }
3114     }
3115
3116   if (h->got.offset != (bfd_vma) -1)
3117     {
3118       asection * sgot;
3119       asection * srel;
3120       Elf_Internal_Rel rel;
3121
3122       /* This symbol has an entry in the global offset table.  Set it
3123          up.  */
3124       sgot = bfd_get_section_by_name (dynobj, ".got");
3125       srel = bfd_get_section_by_name (dynobj, ".rel.got");
3126       BFD_ASSERT (sgot != NULL && srel != NULL);
3127
3128       rel.r_offset = (sgot->output_section->vma
3129                       + sgot->output_offset
3130                       + (h->got.offset &~ 1));
3131
3132       /* If this is a -Bsymbolic link, and the symbol is defined
3133          locally, we just want to emit a RELATIVE reloc.  The entry in
3134          the global offset table will already have been initialized in
3135          the relocate_section function.  */
3136       if (info->shared
3137           && (info->symbolic || h->dynindx == -1)
3138           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
3139         rel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
3140       else
3141         {
3142           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
3143           rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT);
3144         }
3145
3146       bfd_elf32_swap_reloc_out (output_bfd, &rel,
3147                                 ((Elf32_External_Rel *) srel->contents
3148                                  + srel->reloc_count));
3149       ++srel->reloc_count;
3150     }
3151
3152   if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
3153     {
3154       asection * s;
3155       Elf_Internal_Rel rel;
3156
3157       /* This symbol needs a copy reloc.  Set it up.  */
3158       BFD_ASSERT (h->dynindx != -1
3159                   && (h->root.type == bfd_link_hash_defined
3160                       || h->root.type == bfd_link_hash_defweak));
3161
3162       s = bfd_get_section_by_name (h->root.u.def.section->owner,
3163                                    ".rel.bss");
3164       BFD_ASSERT (s != NULL);
3165
3166       rel.r_offset = (h->root.u.def.value
3167                       + h->root.u.def.section->output_section->vma
3168                       + h->root.u.def.section->output_offset);
3169       rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_COPY);
3170       bfd_elf32_swap_reloc_out (output_bfd, &rel,
3171                                 ((Elf32_External_Rel *) s->contents
3172                                  + s->reloc_count));
3173       ++s->reloc_count;
3174     }
3175
3176   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
3177   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3178       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
3179     sym->st_shndx = SHN_ABS;
3180
3181   return true;
3182 }
3183
3184 /* Finish up the dynamic sections.  */
3185
3186 static boolean
3187 elf32_arm_finish_dynamic_sections (output_bfd, info)
3188      bfd * output_bfd;
3189      struct bfd_link_info * info;
3190 {
3191   bfd * dynobj;
3192   asection * sgot;
3193   asection * sdyn;
3194
3195   dynobj = elf_hash_table (info)->dynobj;
3196
3197   sgot = bfd_get_section_by_name (dynobj, ".got.plt");
3198   BFD_ASSERT (sgot != NULL);
3199   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3200
3201   if (elf_hash_table (info)->dynamic_sections_created)
3202     {
3203       asection *splt;
3204       Elf32_External_Dyn *dyncon, *dynconend;
3205
3206       splt = bfd_get_section_by_name (dynobj, ".plt");
3207       BFD_ASSERT (splt != NULL && sdyn != NULL);
3208
3209       dyncon = (Elf32_External_Dyn *) sdyn->contents;
3210       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
3211
3212       for (; dyncon < dynconend; dyncon++)
3213         {
3214           Elf_Internal_Dyn dyn;
3215           const char * name;
3216           asection * s;
3217
3218           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3219
3220           switch (dyn.d_tag)
3221             {
3222             default:
3223               break;
3224
3225             case DT_PLTGOT:
3226               name = ".got";
3227               goto get_vma;
3228             case DT_JMPREL:
3229               name = ".rel.plt";
3230             get_vma:
3231               s = bfd_get_section_by_name (output_bfd, name);
3232               BFD_ASSERT (s != NULL);
3233               dyn.d_un.d_ptr = s->vma;
3234               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3235               break;
3236
3237             case DT_PLTRELSZ:
3238               s = bfd_get_section_by_name (output_bfd, ".rel.plt");
3239               BFD_ASSERT (s != NULL);
3240               if (s->_cooked_size != 0)
3241                 dyn.d_un.d_val = s->_cooked_size;
3242               else
3243                 dyn.d_un.d_val = s->_raw_size;
3244               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3245               break;
3246
3247             case DT_RELSZ:
3248               /* My reading of the SVR4 ABI indicates that the
3249                  procedure linkage table relocs (DT_JMPREL) should be
3250                  included in the overall relocs (DT_REL).  This is
3251                  what Solaris does.  However, UnixWare can not handle
3252                  that case.  Therefore, we override the DT_RELSZ entry
3253                  here to make it not include the JMPREL relocs.  Since
3254                  the linker script arranges for .rel.plt to follow all
3255                  other relocation sections, we don't have to worry
3256                  about changing the DT_REL entry.  */
3257               s = bfd_get_section_by_name (output_bfd, ".rel.plt");
3258               if (s != NULL)
3259                 {
3260                   if (s->_cooked_size != 0)
3261                     dyn.d_un.d_val -= s->_cooked_size;
3262                   else
3263                     dyn.d_un.d_val -= s->_raw_size;
3264                 }
3265               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3266               break;
3267             }
3268         }
3269
3270       /* Fill in the first entry in the procedure linkage table.  */
3271       if (splt->_raw_size > 0)
3272         memcpy (splt->contents, elf32_arm_plt0_entry, PLT_ENTRY_SIZE);
3273
3274       /* UnixWare sets the entsize of .plt to 4, although that doesn't
3275          really seem like the right value.  */
3276       elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
3277     }
3278
3279   /* Fill in the first three entries in the global offset table.  */
3280   if (sgot->_raw_size > 0)
3281     {
3282       if (sdyn == NULL)
3283         bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
3284       else
3285         bfd_put_32 (output_bfd,
3286                     sdyn->output_section->vma + sdyn->output_offset,
3287                     sgot->contents);
3288       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
3289       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
3290     }
3291
3292   elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
3293
3294   return true;
3295 }
3296
3297 static void
3298 elf32_arm_post_process_headers (abfd, link_info)
3299      bfd * abfd;
3300      struct bfd_link_info * link_info ATTRIBUTE_UNUSED;
3301 {
3302   Elf_Internal_Ehdr * i_ehdrp;  /* ELF file header, internal form.  */
3303
3304   i_ehdrp = elf_elfheader (abfd);
3305
3306   i_ehdrp->e_ident[EI_OSABI]      = ARM_ELF_OS_ABI_VERSION;
3307   i_ehdrp->e_ident[EI_ABIVERSION] = ARM_ELF_ABI_VERSION;
3308 }
3309
3310
3311 #define ELF_ARCH                        bfd_arch_arm
3312 #define ELF_MACHINE_CODE                EM_ARM
3313 #define ELF_MAXPAGESIZE                 0x8000
3314
3315
3316 #define bfd_elf32_bfd_copy_private_bfd_data     elf32_arm_copy_private_bfd_data
3317 #define bfd_elf32_bfd_merge_private_bfd_data    elf32_arm_merge_private_bfd_data
3318 #define bfd_elf32_bfd_set_private_flags         elf32_arm_set_private_flags
3319 #define bfd_elf32_bfd_print_private_bfd_data    elf32_arm_print_private_bfd_data
3320 #define bfd_elf32_bfd_link_hash_table_create    elf32_arm_link_hash_table_create
3321 #define bfd_elf32_bfd_reloc_type_lookup         elf32_arm_reloc_type_lookup
3322 #define bfd_elf32_find_nearest_line             elf32_arm_find_nearest_line
3323
3324 #define elf_backend_get_symbol_type             elf32_arm_get_symbol_type
3325 #define elf_backend_gc_mark_hook                elf32_arm_gc_mark_hook
3326 #define elf_backend_gc_sweep_hook               elf32_arm_gc_sweep_hook
3327 #define elf_backend_check_relocs                elf32_arm_check_relocs
3328 #define elf_backend_relocate_section            elf32_arm_relocate_section
3329 #define elf_backend_adjust_dynamic_symbol       elf32_arm_adjust_dynamic_symbol
3330 #define elf_backend_create_dynamic_sections     _bfd_elf_create_dynamic_sections
3331 #define elf_backend_finish_dynamic_symbol       elf32_arm_finish_dynamic_symbol
3332 #define elf_backend_finish_dynamic_sections     elf32_arm_finish_dynamic_sections
3333 #define elf_backend_size_dynamic_sections       elf32_arm_size_dynamic_sections
3334 #define elf_backend_post_process_headers        elf32_arm_post_process_headers
3335
3336 #define elf_backend_can_gc_sections 1
3337 #define elf_backend_plt_readonly    1
3338 #define elf_backend_want_got_plt    1
3339 #define elf_backend_want_plt_sym    0
3340
3341 #define elf_backend_got_header_size     12
3342 #define elf_backend_plt_header_size     PLT_ENTRY_SIZE
3343
3344 #include "elf32-target.h"