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_signed_vma addend;
1646
1647   if (howto->type == R_ARM_THM_PC22)
1648     {
1649       int upper_insn, lower_insn;
1650       int upper, lower;
1651
1652       upper_insn = bfd_get_16 (abfd, address);
1653       lower_insn = bfd_get_16 (abfd, address + 2);
1654       upper = upper_insn & 0x7ff;
1655       lower = lower_insn & 0x7ff;
1656
1657       addend = (upper << 12) | (lower << 1);
1658       addend += increment;
1659       addend >>= 1;
1660
1661       upper_insn = (upper_insn & 0xf800) | ((addend >> 11) & 0x7ff);
1662       lower_insn = (lower_insn & 0xf800) | (addend & 0x7ff);
1663
1664       bfd_put_16 (abfd, upper_insn, address);
1665       bfd_put_16 (abfd, lower_insn, address + 2);
1666     }
1667   else
1668     {
1669       bfd_vma        contents;
1670
1671       contents = bfd_get_32 (abfd, address);
1672
1673       /* Get the (signed) value from the instruction.  */
1674       addend = contents & howto->src_mask;
1675       if (addend & ((howto->src_mask + 1) >> 1))
1676         {
1677           bfd_signed_vma mask;
1678
1679           mask = -1;
1680           mask &= ~ howto->src_mask;
1681           addend |= mask;
1682         }
1683
1684       /* Add in the increment, (which is a byte value).  */
1685       switch (howto->type)
1686         {
1687         default:
1688           addend += increment;
1689           break;
1690
1691         case R_ARM_PC24:
1692           addend <<= howto->size;
1693           addend +=  increment;
1694
1695           /* Should we check for overflow here ?  */
1696
1697           /* Drop any undesired bits.  */
1698           addend >>= howto->rightshift;
1699           break;
1700         }
1701
1702       contents = (contents & ~ howto->dst_mask) | (addend & howto->dst_mask);
1703
1704       bfd_put_32 (abfd, contents, address);
1705     }
1706 }
1707 #endif /* USE_REL */
1708
1709 /* Relocate an ARM ELF section.  */
1710 static boolean
1711 elf32_arm_relocate_section (output_bfd, info, input_bfd, input_section,
1712                             contents, relocs, local_syms, local_sections)
1713      bfd *                  output_bfd;
1714      struct bfd_link_info * info;
1715      bfd *                  input_bfd;
1716      asection *             input_section;
1717      bfd_byte *             contents;
1718      Elf_Internal_Rela *    relocs;
1719      Elf_Internal_Sym *     local_syms;
1720      asection **            local_sections;
1721 {
1722   Elf_Internal_Shdr *           symtab_hdr;
1723   struct elf_link_hash_entry ** sym_hashes;
1724   Elf_Internal_Rela *           rel;
1725   Elf_Internal_Rela *           relend;
1726   const char *                  name;
1727
1728   symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
1729   sym_hashes = elf_sym_hashes (input_bfd);
1730
1731   rel = relocs;
1732   relend = relocs + input_section->reloc_count;
1733   for (; rel < relend; rel++)
1734     {
1735       int                          r_type;
1736       reloc_howto_type *           howto;
1737       unsigned long                r_symndx;
1738       Elf_Internal_Sym *           sym;
1739       asection *                   sec;
1740       struct elf_link_hash_entry * h;
1741       bfd_vma                      relocation;
1742       bfd_reloc_status_type        r;
1743       arelent                      bfd_reloc;
1744
1745       r_symndx = ELF32_R_SYM (rel->r_info);
1746       r_type   = ELF32_R_TYPE (rel->r_info);
1747
1748       if (   r_type == R_ARM_GNU_VTENTRY
1749           || r_type == R_ARM_GNU_VTINHERIT)
1750         continue;
1751
1752       elf32_arm_info_to_howto (input_bfd, & bfd_reloc, rel);
1753       howto = bfd_reloc.howto;
1754
1755       if (info->relocateable)
1756         {
1757           /* This is a relocateable link.  We don't have to change
1758              anything, unless the reloc is against a section symbol,
1759              in which case we have to adjust according to where the
1760              section symbol winds up in the output section.  */
1761           if (r_symndx < symtab_hdr->sh_info)
1762             {
1763               sym = local_syms + r_symndx;
1764               if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1765                 {
1766                   sec = local_sections[r_symndx];
1767 #ifdef USE_REL
1768                   arm_add_to_rel (input_bfd, contents + rel->r_offset,
1769                                   howto, sec->output_offset + sym->st_value);
1770 #else
1771                   rel->r_addend += (sec->output_offset + sym->st_value)
1772                     >> howto->rightshift;
1773 #endif
1774                 }
1775             }
1776
1777           continue;
1778         }
1779
1780       /* This is a final link.  */
1781       h = NULL;
1782       sym = NULL;
1783       sec = NULL;
1784
1785       if (r_symndx < symtab_hdr->sh_info)
1786         {
1787           sym = local_syms + r_symndx;
1788           sec = local_sections[r_symndx];
1789           relocation = (sec->output_section->vma
1790                         + sec->output_offset
1791                         + sym->st_value);
1792         }
1793       else
1794         {
1795           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1796
1797           while (   h->root.type == bfd_link_hash_indirect
1798                  || h->root.type == bfd_link_hash_warning)
1799             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1800
1801           if (   h->root.type == bfd_link_hash_defined
1802               || h->root.type == bfd_link_hash_defweak)
1803             {
1804               int relocation_needed = 1;
1805
1806               sec = h->root.u.def.section;
1807
1808               /* In these cases, we don't need the relocation value.
1809                  We check specially because in some obscure cases
1810                  sec->output_section will be NULL.  */
1811               switch (r_type)
1812                 {
1813                 case R_ARM_PC24:
1814                 case R_ARM_ABS32:
1815                   if (info->shared
1816                       && (
1817                           (!info->symbolic && h->dynindx != -1)
1818                           || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
1819                           )
1820                       && ((input_section->flags & SEC_ALLOC) != 0
1821                           /* DWARF will emit R_ARM_ABS32 relocations in its
1822                              sections against symbols defined externally
1823                              in shared libraries.  We can't do anything
1824                              with them here.  */
1825                           || ((input_section->flags & SEC_DEBUGGING) != 0
1826                               && (h->elf_link_hash_flags
1827                                   & ELF_LINK_HASH_DEF_DYNAMIC) != 0))
1828                       )
1829                     relocation_needed = 0;
1830                   break;
1831
1832                 case R_ARM_GOTPC:
1833                   relocation_needed = 0;
1834                   break;
1835
1836                 case R_ARM_GOT32:
1837                   if (elf_hash_table(info)->dynamic_sections_created
1838                       && (!info->shared
1839                           || (!info->symbolic && h->dynindx != -1)
1840                           || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
1841                           )
1842                       )
1843                     relocation_needed = 0;
1844                   break;
1845
1846                 case R_ARM_PLT32:
1847                   if (h->plt.offset != (bfd_vma)-1)
1848                     relocation_needed = 0;
1849                   break;
1850
1851                 default:
1852                   if (sec->output_section == NULL)
1853                     {
1854                       (*_bfd_error_handler)
1855                         (_("%s: warning: unresolvable relocation against symbol `%s' from %s section"),
1856                          bfd_get_filename (input_bfd), h->root.root.string,
1857                          bfd_get_section_name (input_bfd, input_section));
1858                       relocation_needed = 0;
1859                     }
1860                 }
1861
1862               if (relocation_needed)
1863                 relocation = h->root.u.def.value
1864                   + sec->output_section->vma
1865                   + sec->output_offset;
1866               else
1867                 relocation = 0;
1868             }
1869           else if (h->root.type == bfd_link_hash_undefweak)
1870             relocation = 0;
1871           else if (info->shared && !info->symbolic
1872                    && !info->no_undefined
1873                    && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
1874             relocation = 0;
1875           else
1876             {
1877               if (!((*info->callbacks->undefined_symbol)
1878                     (info, h->root.root.string, input_bfd,
1879                      input_section, rel->r_offset,
1880                      (!info->shared || info->no_undefined
1881                       || ELF_ST_VISIBILITY (h->other)))))
1882                 return false;
1883               relocation = 0;
1884             }
1885         }
1886
1887       if (h != NULL)
1888         name = h->root.root.string;
1889       else
1890         {
1891           name = (bfd_elf_string_from_elf_section
1892                   (input_bfd, symtab_hdr->sh_link, sym->st_name));
1893           if (name == NULL || *name == '\0')
1894             name = bfd_section_name (input_bfd, sec);
1895         }
1896
1897       r = elf32_arm_final_link_relocate (howto, input_bfd, output_bfd,
1898                                          input_section, contents, rel,
1899                                          relocation, info, sec, name,
1900                                          (h ? ELF_ST_TYPE (h->type) :
1901                                           ELF_ST_TYPE (sym->st_info)), h);
1902
1903       if (r != bfd_reloc_ok)
1904         {
1905           const char * msg = (const char *) 0;
1906
1907           switch (r)
1908             {
1909             case bfd_reloc_overflow:
1910               if (!((*info->callbacks->reloc_overflow)
1911                     (info, name, howto->name, (bfd_vma) 0,
1912                      input_bfd, input_section, rel->r_offset)))
1913                 return false;
1914               break;
1915
1916             case bfd_reloc_undefined:
1917               if (!((*info->callbacks->undefined_symbol)
1918                     (info, name, input_bfd, input_section,
1919                      rel->r_offset, true)))
1920                 return false;
1921               break;
1922
1923             case bfd_reloc_outofrange:
1924               msg = _("internal error: out of range error");
1925               goto common_error;
1926
1927             case bfd_reloc_notsupported:
1928               msg = _("internal error: unsupported relocation error");
1929               goto common_error;
1930
1931             case bfd_reloc_dangerous:
1932               msg = _("internal error: dangerous error");
1933               goto common_error;
1934
1935             default:
1936               msg = _("internal error: unknown error");
1937               /* fall through */
1938
1939             common_error:
1940               if (!((*info->callbacks->warning)
1941                     (info, msg, name, input_bfd, input_section,
1942                      rel->r_offset)))
1943                 return false;
1944               break;
1945             }
1946         }
1947     }
1948
1949   return true;
1950 }
1951
1952 /* Function to keep ARM specific flags in the ELF header.  */
1953 static boolean
1954 elf32_arm_set_private_flags (abfd, flags)
1955      bfd *abfd;
1956      flagword flags;
1957 {
1958   if (elf_flags_init (abfd)
1959       && elf_elfheader (abfd)->e_flags != flags)
1960     {
1961       if (EF_ARM_EABI_VERSION (flags) == EF_ARM_EABI_UNKNOWN)
1962         {
1963           if (flags & EF_INTERWORK)
1964             _bfd_error_handler (_("\
1965 Warning: Not setting interwork flag of %s since it has already been specified as non-interworking"),
1966                                 bfd_get_filename (abfd));
1967           else
1968             _bfd_error_handler (_("\
1969 Warning: Clearing the interwork flag of %s due to outside request"),
1970                                 bfd_get_filename (abfd));
1971         }
1972     }
1973   else
1974     {
1975       elf_elfheader (abfd)->e_flags = flags;
1976       elf_flags_init (abfd) = true;
1977     }
1978
1979   return true;
1980 }
1981
1982 /* Copy backend specific data from one object module to another.  */
1983
1984 static boolean
1985 elf32_arm_copy_private_bfd_data (ibfd, obfd)
1986      bfd *ibfd;
1987      bfd *obfd;
1988 {
1989   flagword in_flags;
1990   flagword out_flags;
1991
1992   if (   bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1993       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1994     return true;
1995
1996   in_flags  = elf_elfheader (ibfd)->e_flags;
1997   out_flags = elf_elfheader (obfd)->e_flags;
1998
1999   if (elf_flags_init (obfd)
2000       && EF_ARM_EABI_VERSION (out_flags) == EF_ARM_EABI_UNKNOWN
2001       && in_flags != out_flags)
2002     {
2003       /* Cannot mix APCS26 and APCS32 code.  */
2004       if ((in_flags & EF_APCS_26) != (out_flags & EF_APCS_26))
2005         return false;
2006
2007       /* Cannot mix float APCS and non-float APCS code.  */
2008       if ((in_flags & EF_APCS_FLOAT) != (out_flags & EF_APCS_FLOAT))
2009         return false;
2010
2011       /* If the src and dest have different interworking flags
2012          then turn off the interworking bit.  */
2013       if ((in_flags & EF_INTERWORK) != (out_flags & EF_INTERWORK))
2014         {
2015           if (out_flags & EF_INTERWORK)
2016             _bfd_error_handler (_("\
2017 Warning: Clearing the interwork flag in %s because non-interworking code in %s has been linked with it"),
2018                           bfd_get_filename (obfd), bfd_get_filename (ibfd));
2019
2020           in_flags &= ~EF_INTERWORK;
2021         }
2022
2023       /* Likewise for PIC, though don't warn for this case.  */
2024       if ((in_flags & EF_PIC) != (out_flags & EF_PIC))
2025         in_flags &= ~EF_PIC;
2026     }
2027
2028   elf_elfheader (obfd)->e_flags = in_flags;
2029   elf_flags_init (obfd) = true;
2030
2031   return true;
2032 }
2033
2034 /* Merge backend specific data from an object file to the output
2035    object file when linking.  */
2036
2037 static boolean
2038 elf32_arm_merge_private_bfd_data (ibfd, obfd)
2039      bfd * ibfd;
2040      bfd * obfd;
2041 {
2042   flagword out_flags;
2043   flagword in_flags;
2044   boolean flags_compatible = true;
2045
2046   /* Check if we have the same endianess.  */
2047   if (_bfd_generic_verify_endian_match (ibfd, obfd) == false)
2048     return false;
2049
2050   if (   bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2051       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2052     return true;
2053
2054   /* The input BFD must have had its flags initialised.  */
2055   /* The following seems bogus to me -- The flags are initialized in
2056      the assembler but I don't think an elf_flags_init field is
2057      written into the object.  */
2058   /* BFD_ASSERT (elf_flags_init (ibfd)); */
2059
2060   in_flags  = elf_elfheader (ibfd)->e_flags;
2061   out_flags = elf_elfheader (obfd)->e_flags;
2062
2063   if (!elf_flags_init (obfd))
2064     {
2065       /* If the input is the default architecture and had the default
2066          flags then do not bother setting the flags for the output
2067          architecture, instead allow future merges to do this.  If no
2068          future merges ever set these flags then they will retain their
2069          uninitialised values, which surprise surprise, correspond
2070          to the default values.  */
2071       if (bfd_get_arch_info (ibfd)->the_default
2072           && elf_elfheader (ibfd)->e_flags == 0)
2073         return true;
2074
2075       elf_flags_init (obfd) = true;
2076       elf_elfheader (obfd)->e_flags = in_flags;
2077
2078       if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
2079           && bfd_get_arch_info (obfd)->the_default)
2080         return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
2081
2082       return true;
2083     }
2084
2085   /* Identical flags must be compatible.  */
2086   if (in_flags == out_flags)
2087     return true;
2088
2089   /* Complain about various flag mismatches.  */
2090   if (EF_ARM_EABI_VERSION (in_flags) != EF_ARM_EABI_VERSION (out_flags))
2091     {
2092       _bfd_error_handler (_("\
2093 Error: %s compiled for EABI version %d, whereas %s is compiled for version %d"),
2094                          bfd_get_filename (ibfd),
2095                          (in_flags & EF_ARM_EABIMASK) >> 24,
2096                          bfd_get_filename (obfd),
2097                          (out_flags & EF_ARM_EABIMASK) >> 24);
2098       return false;
2099     }
2100
2101   /* Not sure what needs to be checked for EABI versions >= 1.  */
2102   if (EF_ARM_EABI_VERSION (in_flags) == EF_ARM_EABI_UNKNOWN)
2103     {
2104       if ((in_flags & EF_APCS_26) != (out_flags & EF_APCS_26))
2105         {
2106           _bfd_error_handler (_("\
2107 Error: %s compiled for APCS-%d, whereas %s is compiled for APCS-%d"),
2108                         bfd_get_filename (ibfd),
2109                         in_flags & EF_APCS_26 ? 26 : 32,
2110                         bfd_get_filename (obfd),
2111                         out_flags & EF_APCS_26 ? 26 : 32);
2112           flags_compatible = false;
2113         }
2114
2115       if ((in_flags & EF_APCS_FLOAT) != (out_flags & EF_APCS_FLOAT))
2116         {
2117           _bfd_error_handler (_("\
2118 Error: %s passes floats in %s registers, whereas %s passes them in %s registers"),
2119                         bfd_get_filename (ibfd),
2120                      in_flags & EF_APCS_FLOAT ? _("float") : _("integer"),
2121                         bfd_get_filename (obfd),
2122                       out_flags & EF_APCS_26 ? _("float") : _("integer"));
2123           flags_compatible = false;
2124         }
2125
2126       if ((in_flags & EF_SOFT_FLOAT) != (out_flags & EF_SOFT_FLOAT))
2127         {
2128           _bfd_error_handler (_ ("\
2129 Error: %s uses %s floating point, whereas %s uses %s floating point"),
2130                               bfd_get_filename (ibfd),
2131                               in_flags & EF_SOFT_FLOAT ? _("soft") : _("hard"),
2132                               bfd_get_filename (obfd),
2133                               out_flags & EF_SOFT_FLOAT ? _("soft") : _("hard"));
2134           flags_compatible = false;
2135         }
2136
2137       /* Interworking mismatch is only a warning.  */
2138       if ((in_flags & EF_INTERWORK) != (out_flags & EF_INTERWORK))
2139         _bfd_error_handler (_("\
2140 Warning: %s %s interworking, whereas %s %s"),
2141                           bfd_get_filename (ibfd),
2142           in_flags & EF_INTERWORK ? _("supports") : _("does not support"),
2143                           bfd_get_filename (obfd),
2144                     out_flags & EF_INTERWORK ? _("does not") : _("does"));
2145     }
2146
2147   return flags_compatible;
2148 }
2149
2150 /* Display the flags field.  */
2151
2152 static boolean
2153 elf32_arm_print_private_bfd_data (abfd, ptr)
2154      bfd *abfd;
2155      PTR ptr;
2156 {
2157   FILE * file = (FILE *) ptr;
2158   unsigned long flags;
2159
2160   BFD_ASSERT (abfd != NULL && ptr != NULL);
2161
2162   /* Print normal ELF private data.  */
2163   _bfd_elf_print_private_bfd_data (abfd, ptr);
2164
2165   flags = elf_elfheader (abfd)->e_flags;
2166   /* Ignore init flag - it may not be set, despite the flags field
2167      containing valid data.  */
2168
2169   /* xgettext:c-format */
2170   fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
2171
2172   switch (EF_ARM_EABI_VERSION (flags))
2173     {
2174     case EF_ARM_EABI_UNKNOWN:
2175       /* The following flag bits are GNU extenstions and not part of the
2176          official ARM ELF extended ABI.  Hence they are only decoded if
2177          the EABI version is not set.  */
2178       if (flags & EF_INTERWORK)
2179         fprintf (file, _(" [interworking enabled]"));
2180
2181       if (flags & EF_APCS_26)
2182         fprintf (file, _(" [APCS-26]"));
2183       else
2184         fprintf (file, _(" [APCS-32]"));
2185
2186       if (flags & EF_APCS_FLOAT)
2187         fprintf (file, _(" [floats passed in float registers]"));
2188
2189       if (flags & EF_PIC)
2190         fprintf (file, _(" [position independent]"));
2191
2192       if (flags & EF_NEW_ABI)
2193         fprintf (file, _(" [new ABI]"));
2194
2195       if (flags & EF_OLD_ABI)
2196         fprintf (file, _(" [old ABI]"));
2197
2198       if (flags & EF_SOFT_FLOAT)
2199         fprintf (file, _(" [software FP]"));
2200
2201       flags &= ~(EF_INTERWORK | EF_APCS_26 | EF_APCS_FLOAT | EF_PIC
2202                  | EF_NEW_ABI | EF_OLD_ABI | EF_SOFT_FLOAT);
2203       break;
2204
2205     case EF_ARM_EABI_VER1:
2206       fprintf (file, _(" [Version1 EABI]"));
2207
2208       if (flags & EF_ARM_SYMSARESORTED)
2209         fprintf (file, _(" [sorted symbol table]"));
2210       else
2211         fprintf (file, _(" [unsorted symbol table]"));
2212
2213       flags &= ~ EF_ARM_SYMSARESORTED;
2214       break;
2215
2216     default:
2217       fprintf (file, _(" <EABI version unrecognised>"));
2218       break;
2219     }
2220
2221   flags &= ~ EF_ARM_EABIMASK;
2222
2223   if (flags & EF_ARM_RELEXEC)
2224     fprintf (file, _(" [relocatable executable]"));
2225
2226   if (flags & EF_ARM_HASENTRY)
2227     fprintf (file, _(" [has entry point]"));
2228
2229   flags &= ~ (EF_ARM_RELEXEC | EF_ARM_HASENTRY);
2230
2231   if (flags)
2232     fprintf (file, _("<Unrecognised flag bits set>"));
2233
2234   fputc ('\n', file);
2235
2236   return true;
2237 }
2238
2239 static int
2240 elf32_arm_get_symbol_type (elf_sym, type)
2241      Elf_Internal_Sym * elf_sym;
2242      int type;
2243 {
2244   switch (ELF_ST_TYPE (elf_sym->st_info))
2245     {
2246     case STT_ARM_TFUNC:
2247       return ELF_ST_TYPE (elf_sym->st_info);
2248
2249     case STT_ARM_16BIT:
2250       /* If the symbol is not an object, return the STT_ARM_16BIT flag.
2251          This allows us to distinguish between data used by Thumb instructions
2252          and non-data (which is probably code) inside Thumb regions of an
2253          executable.  */
2254       if (type != STT_OBJECT)
2255         return ELF_ST_TYPE (elf_sym->st_info);
2256       break;
2257
2258     default:
2259       break;
2260     }
2261
2262   return type;
2263 }
2264
2265 static asection *
2266 elf32_arm_gc_mark_hook (abfd, info, rel, h, sym)
2267        bfd *abfd;
2268        struct bfd_link_info *info ATTRIBUTE_UNUSED;
2269        Elf_Internal_Rela *rel;
2270        struct elf_link_hash_entry *h;
2271        Elf_Internal_Sym *sym;
2272 {
2273   if (h != NULL)
2274     {
2275       switch (ELF32_R_TYPE (rel->r_info))
2276       {
2277       case R_ARM_GNU_VTINHERIT:
2278       case R_ARM_GNU_VTENTRY:
2279         break;
2280
2281       default:
2282         switch (h->root.type)
2283           {
2284           case bfd_link_hash_defined:
2285           case bfd_link_hash_defweak:
2286             return h->root.u.def.section;
2287
2288           case bfd_link_hash_common:
2289             return h->root.u.c.p->section;
2290
2291           default:
2292             break;
2293           }
2294        }
2295      }
2296    else
2297      {
2298        if (!(elf_bad_symtab (abfd)
2299            && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
2300          && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
2301                 && sym->st_shndx != SHN_COMMON))
2302           {
2303             return bfd_section_from_elf_index (abfd, sym->st_shndx);
2304           }
2305       }
2306   return NULL;
2307 }
2308
2309 /* Update the got entry reference counts for the section being removed.  */
2310
2311 static boolean
2312 elf32_arm_gc_sweep_hook (abfd, info, sec, relocs)
2313      bfd *abfd ATTRIBUTE_UNUSED;
2314      struct bfd_link_info *info ATTRIBUTE_UNUSED;
2315      asection *sec ATTRIBUTE_UNUSED;
2316      const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
2317 {
2318   /* We don't support garbage collection of GOT and PLT relocs yet.  */
2319   return true;
2320 }
2321
2322 /* Look through the relocs for a section during the first phase.  */
2323
2324 static boolean
2325 elf32_arm_check_relocs (abfd, info, sec, relocs)
2326      bfd *                      abfd;
2327      struct bfd_link_info *     info;
2328      asection *                 sec;
2329      const Elf_Internal_Rela *  relocs;
2330 {
2331   Elf_Internal_Shdr *           symtab_hdr;
2332   struct elf_link_hash_entry ** sym_hashes;
2333   struct elf_link_hash_entry ** sym_hashes_end;
2334   const Elf_Internal_Rela *     rel;
2335   const Elf_Internal_Rela *     rel_end;
2336   bfd *                         dynobj;
2337   asection * sgot, *srelgot, *sreloc;
2338   bfd_vma * local_got_offsets;
2339
2340   if (info->relocateable)
2341     return true;
2342
2343   sgot = srelgot = sreloc = NULL;
2344
2345   dynobj = elf_hash_table (info)->dynobj;
2346   local_got_offsets = elf_local_got_offsets (abfd);
2347
2348   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2349   sym_hashes = elf_sym_hashes (abfd);
2350   sym_hashes_end = sym_hashes
2351     + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
2352
2353   if (!elf_bad_symtab (abfd))
2354     sym_hashes_end -= symtab_hdr->sh_info;
2355
2356   rel_end = relocs + sec->reloc_count;
2357   for (rel = relocs; rel < rel_end; rel++)
2358     {
2359       struct elf_link_hash_entry *h;
2360       unsigned long r_symndx;
2361
2362       r_symndx = ELF32_R_SYM (rel->r_info);
2363       if (r_symndx < symtab_hdr->sh_info)
2364         h = NULL;
2365       else
2366         h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2367
2368       /* Some relocs require a global offset table.  */
2369       if (dynobj == NULL)
2370         {
2371           switch (ELF32_R_TYPE (rel->r_info))
2372             {
2373             case R_ARM_GOT32:
2374             case R_ARM_GOTOFF:
2375             case R_ARM_GOTPC:
2376               elf_hash_table (info)->dynobj = dynobj = abfd;
2377               if (! _bfd_elf_create_got_section (dynobj, info))
2378                 return false;
2379               break;
2380
2381             default:
2382               break;
2383             }
2384         }
2385
2386       switch (ELF32_R_TYPE (rel->r_info))
2387         {
2388           case R_ARM_GOT32:
2389             /* This symbol requires a global offset table entry.  */
2390             if (sgot == NULL)
2391               {
2392                 sgot = bfd_get_section_by_name (dynobj, ".got");
2393                 BFD_ASSERT (sgot != NULL);
2394               }
2395
2396             /* Get the got relocation section if necessary.  */
2397             if (srelgot == NULL
2398                 && (h != NULL || info->shared))
2399               {
2400                 srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
2401
2402                 /* If no got relocation section, make one and initialize.  */
2403                 if (srelgot == NULL)
2404                   {
2405                     srelgot = bfd_make_section (dynobj, ".rel.got");
2406                     if (srelgot == NULL
2407                         || ! bfd_set_section_flags (dynobj, srelgot,
2408                                                     (SEC_ALLOC
2409                                                      | SEC_LOAD
2410                                                      | SEC_HAS_CONTENTS
2411                                                      | SEC_IN_MEMORY
2412                                                      | SEC_LINKER_CREATED
2413                                                      | SEC_READONLY))
2414                         || ! bfd_set_section_alignment (dynobj, srelgot, 2))
2415                       return false;
2416                   }
2417               }
2418
2419             if (h != NULL)
2420               {
2421                 if (h->got.offset != (bfd_vma) -1)
2422                   /* We have already allocated space in the .got.  */
2423                   break;
2424
2425                 h->got.offset = sgot->_raw_size;
2426
2427                 /* Make sure this symbol is output as a dynamic symbol.  */
2428                 if (h->dynindx == -1)
2429                   if (! bfd_elf32_link_record_dynamic_symbol (info, h))
2430                     return false;
2431
2432                 srelgot->_raw_size += sizeof (Elf32_External_Rel);
2433               }
2434             else
2435               {
2436                 /* This is a global offset table entry for a local
2437                    symbol.  */
2438                 if (local_got_offsets == NULL)
2439                   {
2440                     size_t size;
2441                     register unsigned int i;
2442
2443                     size = symtab_hdr->sh_info * sizeof (bfd_vma);
2444                     local_got_offsets = (bfd_vma *) bfd_alloc (abfd, size);
2445                     if (local_got_offsets == NULL)
2446                       return false;
2447                     elf_local_got_offsets (abfd) = local_got_offsets;
2448                     for (i = 0; i < symtab_hdr->sh_info; i++)
2449                       local_got_offsets[i] = (bfd_vma) -1;
2450                   }
2451
2452                 if (local_got_offsets[r_symndx] != (bfd_vma) -1)
2453                   /* We have already allocated space in the .got.  */
2454                   break;
2455
2456                 local_got_offsets[r_symndx] = sgot->_raw_size;
2457
2458                 if (info->shared)
2459                   /* If we are generating a shared object, we need to
2460                      output a R_ARM_RELATIVE reloc so that the dynamic
2461                      linker can adjust this GOT entry.  */
2462                   srelgot->_raw_size += sizeof (Elf32_External_Rel);
2463               }
2464
2465             sgot->_raw_size += 4;
2466             break;
2467
2468           case R_ARM_PLT32:
2469             /* This symbol requires a procedure linkage table entry.  We
2470                actually build the entry in adjust_dynamic_symbol,
2471                because this might be a case of linking PIC code which is
2472                never referenced by a dynamic object, in which case we
2473                don't need to generate a procedure linkage table entry
2474                after all.  */
2475
2476             /* If this is a local symbol, we resolve it directly without
2477                creating a procedure linkage table entry.  */
2478             if (h == NULL)
2479               continue;
2480
2481             h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2482             break;
2483
2484           case R_ARM_ABS32:
2485           case R_ARM_REL32:
2486           case R_ARM_PC24:
2487             /* If we are creating a shared library, and this is a reloc
2488                against a global symbol, or a non PC relative reloc
2489                against a local symbol, then we need to copy the reloc
2490                into the shared library.  However, if we are linking with
2491                -Bsymbolic, we do not need to copy a reloc against a
2492                global symbol which is defined in an object we are
2493                including in the link (i.e., DEF_REGULAR is set).  At
2494                this point we have not seen all the input files, so it is
2495                possible that DEF_REGULAR is not set now but will be set
2496                later (it is never cleared).  We account for that
2497                possibility below by storing information in the
2498                pcrel_relocs_copied field of the hash table entry.  */
2499             if (info->shared
2500               && (ELF32_R_TYPE (rel->r_info) != R_ARM_PC24
2501                 || (h != NULL
2502                   && (! info->symbolic
2503                     || (h->elf_link_hash_flags
2504                       & ELF_LINK_HASH_DEF_REGULAR) == 0))))
2505               {
2506                 /* When creating a shared object, we must copy these
2507                    reloc types into the output file.  We create a reloc
2508                    section in dynobj and make room for this reloc.  */
2509                 if (sreloc == NULL)
2510                   {
2511                     const char * name;
2512
2513                     name = (bfd_elf_string_from_elf_section
2514                             (abfd,
2515                              elf_elfheader (abfd)->e_shstrndx,
2516                              elf_section_data (sec)->rel_hdr.sh_name));
2517                     if (name == NULL)
2518                       return false;
2519
2520                     BFD_ASSERT (strncmp (name, ".rel", 4) == 0
2521                                 && strcmp (bfd_get_section_name (abfd, sec),
2522                                            name + 4) == 0);
2523
2524                     sreloc = bfd_get_section_by_name (dynobj, name);
2525                     if (sreloc == NULL)
2526                       {
2527                         flagword flags;
2528
2529                         sreloc = bfd_make_section (dynobj, name);
2530                         flags = (SEC_HAS_CONTENTS | SEC_READONLY
2531                                  | SEC_IN_MEMORY | SEC_LINKER_CREATED);
2532                         if ((sec->flags & SEC_ALLOC) != 0)
2533                           flags |= SEC_ALLOC | SEC_LOAD;
2534                         if (sreloc == NULL
2535                             || ! bfd_set_section_flags (dynobj, sreloc, flags)
2536                             || ! bfd_set_section_alignment (dynobj, sreloc, 2))
2537                           return false;
2538                       }
2539                   }
2540
2541                 sreloc->_raw_size += sizeof (Elf32_External_Rel);
2542                 /* If we are linking with -Bsymbolic, and this is a
2543                    global symbol, we count the number of PC relative
2544                    relocations we have entered for this symbol, so that
2545                    we can discard them again if the symbol is later
2546                    defined by a regular object.  Note that this function
2547                    is only called if we are using an elf_i386 linker
2548                    hash table, which means that h is really a pointer to
2549                    an elf_i386_link_hash_entry.  */
2550                 if (h != NULL && info->symbolic
2551                     && ELF32_R_TYPE (rel->r_info) == R_ARM_PC24)
2552                   {
2553                     struct elf32_arm_link_hash_entry * eh;
2554                     struct elf32_arm_pcrel_relocs_copied * p;
2555
2556                     eh = (struct elf32_arm_link_hash_entry *) h;
2557
2558                     for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next)
2559                       if (p->section == sreloc)
2560                         break;
2561
2562                     if (p == NULL)
2563                       {
2564                         p = ((struct elf32_arm_pcrel_relocs_copied *)
2565                              bfd_alloc (dynobj, sizeof * p));
2566
2567                         if (p == NULL)
2568                           return false;
2569                         p->next = eh->pcrel_relocs_copied;
2570                         eh->pcrel_relocs_copied = p;
2571                         p->section = sreloc;
2572                         p->count = 0;
2573                       }
2574
2575                     ++p->count;
2576                   }
2577               }
2578             break;
2579
2580         /* This relocation describes the C++ object vtable hierarchy.
2581            Reconstruct it for later use during GC.  */
2582         case R_ARM_GNU_VTINHERIT:
2583           if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2584             return false;
2585           break;
2586
2587         /* This relocation describes which C++ vtable entries are actually
2588            used.  Record for later use during GC.  */
2589         case R_ARM_GNU_VTENTRY:
2590           if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_offset))
2591             return false;
2592           break;
2593         }
2594     }
2595
2596   return true;
2597 }
2598
2599
2600 /* Find the nearest line to a particular section and offset, for error
2601    reporting.   This code is a duplicate of the code in elf.c, except
2602    that it also accepts STT_ARM_TFUNC as a symbol that names a function.  */
2603
2604 static boolean
2605 elf32_arm_find_nearest_line
2606   (abfd, section, symbols, offset, filename_ptr, functionname_ptr, line_ptr)
2607      bfd *          abfd;
2608      asection *     section;
2609      asymbol **     symbols;
2610      bfd_vma        offset;
2611      CONST char **  filename_ptr;
2612      CONST char **  functionname_ptr;
2613      unsigned int * line_ptr;
2614 {
2615   boolean      found;
2616   const char * filename;
2617   asymbol *    func;
2618   bfd_vma      low_func;
2619   asymbol **   p;
2620
2621   if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
2622                                      filename_ptr, functionname_ptr,
2623                                      line_ptr, 0))
2624     return true;
2625
2626   if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
2627                                              &found, filename_ptr,
2628                                              functionname_ptr, line_ptr,
2629                                              &elf_tdata (abfd)->line_info))
2630     return false;
2631
2632   if (found)
2633     return true;
2634
2635   if (symbols == NULL)
2636     return false;
2637
2638   filename = NULL;
2639   func = NULL;
2640   low_func = 0;
2641
2642   for (p = symbols; *p != NULL; p++)
2643     {
2644       elf_symbol_type *q;
2645
2646       q = (elf_symbol_type *) *p;
2647
2648       if (bfd_get_section (&q->symbol) != section)
2649         continue;
2650
2651       switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
2652         {
2653         default:
2654           break;
2655         case STT_FILE:
2656           filename = bfd_asymbol_name (&q->symbol);
2657           break;
2658         case STT_NOTYPE:
2659         case STT_FUNC:
2660         case STT_ARM_TFUNC:
2661           if (q->symbol.section == section
2662               && q->symbol.value >= low_func
2663               && q->symbol.value <= offset)
2664             {
2665               func = (asymbol *) q;
2666               low_func = q->symbol.value;
2667             }
2668           break;
2669         }
2670     }
2671
2672   if (func == NULL)
2673     return false;
2674
2675   *filename_ptr = filename;
2676   *functionname_ptr = bfd_asymbol_name (func);
2677   *line_ptr = 0;
2678
2679   return true;
2680 }
2681
2682 /* Adjust a symbol defined by a dynamic object and referenced by a
2683    regular object.  The current definition is in some section of the
2684    dynamic object, but we're not including those sections.  We have to
2685    change the definition to something the rest of the link can
2686    understand.  */
2687
2688 static boolean
2689 elf32_arm_adjust_dynamic_symbol (info, h)
2690      struct bfd_link_info * info;
2691      struct elf_link_hash_entry * h;
2692 {
2693   bfd * dynobj;
2694   asection * s;
2695   unsigned int power_of_two;
2696
2697   dynobj = elf_hash_table (info)->dynobj;
2698
2699   /* Make sure we know what is going on here.  */
2700   BFD_ASSERT (dynobj != NULL
2701               && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
2702                   || h->weakdef != NULL
2703                   || ((h->elf_link_hash_flags
2704                        & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2705                       && (h->elf_link_hash_flags
2706                           & ELF_LINK_HASH_REF_REGULAR) != 0
2707                       && (h->elf_link_hash_flags
2708                           & ELF_LINK_HASH_DEF_REGULAR) == 0)));
2709
2710   /* If this is a function, put it in the procedure linkage table.  We
2711      will fill in the contents of the procedure linkage table later,
2712      when we know the address of the .got section.  */
2713   if (h->type == STT_FUNC
2714       || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
2715     {
2716       if (! info->shared
2717           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
2718           && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0)
2719         {
2720           /* This case can occur if we saw a PLT32 reloc in an input
2721              file, but the symbol was never referred to by a dynamic
2722              object.  In such a case, we don't actually need to build
2723              a procedure linkage table, and we can just do a PC32
2724              reloc instead.  */
2725           BFD_ASSERT ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0);
2726           return true;
2727         }
2728
2729       /* Make sure this symbol is output as a dynamic symbol.  */
2730       if (h->dynindx == -1)
2731         {
2732           if (! bfd_elf32_link_record_dynamic_symbol (info, h))
2733             return false;
2734         }
2735
2736       s = bfd_get_section_by_name (dynobj, ".plt");
2737       BFD_ASSERT (s != NULL);
2738
2739       /* If this is the first .plt entry, make room for the special
2740          first entry.  */
2741       if (s->_raw_size == 0)
2742         s->_raw_size += PLT_ENTRY_SIZE;
2743
2744       /* If this symbol is not defined in a regular file, and we are
2745          not generating a shared library, then set the symbol to this
2746          location in the .plt.  This is required to make function
2747          pointers compare as equal between the normal executable and
2748          the shared library.  */
2749       if (! info->shared
2750           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2751         {
2752           h->root.u.def.section = s;
2753           h->root.u.def.value = s->_raw_size;
2754         }
2755
2756       h->plt.offset = s->_raw_size;
2757
2758       /* Make room for this entry.  */
2759       s->_raw_size += PLT_ENTRY_SIZE;
2760
2761       /* We also need to make an entry in the .got.plt section, which
2762          will be placed in the .got section by the linker script.  */
2763       s = bfd_get_section_by_name (dynobj, ".got.plt");
2764       BFD_ASSERT (s != NULL);
2765       s->_raw_size += 4;
2766
2767       /* We also need to make an entry in the .rel.plt section.  */
2768
2769       s = bfd_get_section_by_name (dynobj, ".rel.plt");
2770       BFD_ASSERT (s != NULL);
2771       s->_raw_size += sizeof (Elf32_External_Rel);
2772
2773       return true;
2774     }
2775
2776   /* If this is a weak symbol, and there is a real definition, the
2777      processor independent code will have arranged for us to see the
2778      real definition first, and we can just use the same value.  */
2779   if (h->weakdef != NULL)
2780     {
2781       BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
2782                   || h->weakdef->root.type == bfd_link_hash_defweak);
2783       h->root.u.def.section = h->weakdef->root.u.def.section;
2784       h->root.u.def.value = h->weakdef->root.u.def.value;
2785       return true;
2786     }
2787
2788   /* This is a reference to a symbol defined by a dynamic object which
2789      is not a function.  */
2790
2791   /* If we are creating a shared library, we must presume that the
2792      only references to the symbol are via the global offset table.
2793      For such cases we need not do anything here; the relocations will
2794      be handled correctly by relocate_section.  */
2795   if (info->shared)
2796     return true;
2797
2798   /* We must allocate the symbol in our .dynbss section, which will
2799      become part of the .bss section of the executable.  There will be
2800      an entry for this symbol in the .dynsym section.  The dynamic
2801      object will contain position independent code, so all references
2802      from the dynamic object to this symbol will go through the global
2803      offset table.  The dynamic linker will use the .dynsym entry to
2804      determine the address it must put in the global offset table, so
2805      both the dynamic object and the regular object will refer to the
2806      same memory location for the variable.  */
2807   s = bfd_get_section_by_name (dynobj, ".dynbss");
2808   BFD_ASSERT (s != NULL);
2809
2810   /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
2811      copy the initial value out of the dynamic object and into the
2812      runtime process image.  We need to remember the offset into the
2813      .rel.bss section we are going to use.  */
2814   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
2815     {
2816       asection *srel;
2817
2818       srel = bfd_get_section_by_name (dynobj, ".rel.bss");
2819       BFD_ASSERT (srel != NULL);
2820       srel->_raw_size += sizeof (Elf32_External_Rel);
2821       h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
2822     }
2823
2824   /* We need to figure out the alignment required for this symbol.  I
2825      have no idea how ELF linkers handle this.  */
2826   power_of_two = bfd_log2 (h->size);
2827   if (power_of_two > 3)
2828     power_of_two = 3;
2829
2830   /* Apply the required alignment.  */
2831   s->_raw_size = BFD_ALIGN (s->_raw_size,
2832                             (bfd_size_type) (1 << power_of_two));
2833   if (power_of_two > bfd_get_section_alignment (dynobj, s))
2834     {
2835       if (! bfd_set_section_alignment (dynobj, s, power_of_two))
2836         return false;
2837     }
2838
2839   /* Define the symbol as being at this point in the section.  */
2840   h->root.u.def.section = s;
2841   h->root.u.def.value = s->_raw_size;
2842
2843   /* Increment the section size to make room for the symbol.  */
2844   s->_raw_size += h->size;
2845
2846   return true;
2847 }
2848
2849 /* Set the sizes of the dynamic sections.  */
2850
2851 static boolean
2852 elf32_arm_size_dynamic_sections (output_bfd, info)
2853      bfd * output_bfd;
2854      struct bfd_link_info * info;
2855 {
2856   bfd * dynobj;
2857   asection * s;
2858   boolean plt;
2859   boolean relocs;
2860   boolean reltext;
2861
2862   dynobj = elf_hash_table (info)->dynobj;
2863   BFD_ASSERT (dynobj != NULL);
2864
2865   if (elf_hash_table (info)->dynamic_sections_created)
2866     {
2867       /* Set the contents of the .interp section to the interpreter.  */
2868       if (! info->shared)
2869         {
2870           s = bfd_get_section_by_name (dynobj, ".interp");
2871           BFD_ASSERT (s != NULL);
2872           s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
2873           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2874         }
2875     }
2876   else
2877     {
2878       /* We may have created entries in the .rel.got section.
2879          However, if we are not creating the dynamic sections, we will
2880          not actually use these entries.  Reset the size of .rel.got,
2881          which will cause it to get stripped from the output file
2882          below.  */
2883       s = bfd_get_section_by_name (dynobj, ".rel.got");
2884       if (s != NULL)
2885         s->_raw_size = 0;
2886     }
2887
2888   /* If this is a -Bsymbolic shared link, then we need to discard all
2889      PC relative relocs against symbols defined in a regular object.
2890      We allocated space for them in the check_relocs routine, but we
2891      will not fill them in in the relocate_section routine.  */
2892   if (info->shared && info->symbolic)
2893     elf32_arm_link_hash_traverse (elf32_arm_hash_table (info),
2894                                   elf32_arm_discard_copies,
2895                                   (PTR) NULL);
2896
2897   /* The check_relocs and adjust_dynamic_symbol entry points have
2898      determined the sizes of the various dynamic sections.  Allocate
2899      memory for them.  */
2900   plt = false;
2901   relocs = false;
2902   reltext = false;
2903   for (s = dynobj->sections; s != NULL; s = s->next)
2904     {
2905       const char * name;
2906       boolean strip;
2907
2908       if ((s->flags & SEC_LINKER_CREATED) == 0)
2909         continue;
2910
2911       /* It's OK to base decisions on the section name, because none
2912          of the dynobj section names depend upon the input files.  */
2913       name = bfd_get_section_name (dynobj, s);
2914
2915       strip = false;
2916
2917       if (strcmp (name, ".plt") == 0)
2918         {
2919           if (s->_raw_size == 0)
2920             {
2921               /* Strip this section if we don't need it; see the
2922                  comment below.  */
2923               strip = true;
2924             }
2925           else
2926             {
2927               /* Remember whether there is a PLT.  */
2928               plt = true;
2929             }
2930         }
2931       else if (strncmp (name, ".rel", 4) == 0)
2932         {
2933           if (s->_raw_size == 0)
2934             {
2935               /* If we don't need this section, strip it from the
2936                  output file.  This is mostly to handle .rel.bss and
2937                  .rel.plt.  We must create both sections in
2938                  create_dynamic_sections, because they must be created
2939                  before the linker maps input sections to output
2940                  sections.  The linker does that before
2941                  adjust_dynamic_symbol is called, and it is that
2942                  function which decides whether anything needs to go
2943                  into these sections.  */
2944               strip = true;
2945             }
2946           else
2947             {
2948               asection * target;
2949
2950               /* Remember whether there are any reloc sections other
2951                  than .rel.plt.  */
2952               if (strcmp (name, ".rel.plt") != 0)
2953                 {
2954                   const char *outname;
2955
2956                   relocs = true;
2957
2958                   /* If this relocation section applies to a read only
2959                      section, then we probably need a DT_TEXTREL
2960                      entry.  The entries in the .rel.plt section
2961                      really apply to the .got section, which we
2962                      created ourselves and so know is not readonly.  */
2963                   outname = bfd_get_section_name (output_bfd,
2964                                                   s->output_section);
2965                   target = bfd_get_section_by_name (output_bfd, outname + 4);
2966
2967                   if (target != NULL
2968                       && (target->flags & SEC_READONLY) != 0
2969                       && (target->flags & SEC_ALLOC) != 0)
2970                     reltext = true;
2971                 }
2972
2973               /* We use the reloc_count field as a counter if we need
2974                  to copy relocs into the output file.  */
2975               s->reloc_count = 0;
2976             }
2977         }
2978       else if (strncmp (name, ".got", 4) != 0)
2979         {
2980           /* It's not one of our sections, so don't allocate space.  */
2981           continue;
2982         }
2983
2984       if (strip)
2985         {
2986           asection ** spp;
2987
2988           for (spp = &s->output_section->owner->sections;
2989                *spp != s->output_section;
2990                spp = &(*spp)->next)
2991             ;
2992           *spp = s->output_section->next;
2993           --s->output_section->owner->section_count;
2994
2995           continue;
2996         }
2997
2998       /* Allocate memory for the section contents.  */
2999       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
3000       if (s->contents == NULL && s->_raw_size != 0)
3001         return false;
3002     }
3003
3004   if (elf_hash_table (info)->dynamic_sections_created)
3005     {
3006       /* Add some entries to the .dynamic section.  We fill in the
3007          values later, in elf32_arm_finish_dynamic_sections, but we
3008          must add the entries now so that we get the correct size for
3009          the .dynamic section.  The DT_DEBUG entry is filled in by the
3010          dynamic linker and used by the debugger.  */
3011       if (! info->shared)
3012         {
3013           if (! bfd_elf32_add_dynamic_entry (info, DT_DEBUG, 0))
3014             return false;
3015         }
3016
3017       if (plt)
3018         {
3019           if (   ! bfd_elf32_add_dynamic_entry (info, DT_PLTGOT, 0)
3020               || ! bfd_elf32_add_dynamic_entry (info, DT_PLTRELSZ, 0)
3021               || ! bfd_elf32_add_dynamic_entry (info, DT_PLTREL, DT_REL)
3022               || ! bfd_elf32_add_dynamic_entry (info, DT_JMPREL, 0))
3023             return false;
3024         }
3025
3026       if (relocs)
3027         {
3028           if (   ! bfd_elf32_add_dynamic_entry (info, DT_REL, 0)
3029               || ! bfd_elf32_add_dynamic_entry (info, DT_RELSZ, 0)
3030               || ! bfd_elf32_add_dynamic_entry (info, DT_RELENT,
3031                                                 sizeof (Elf32_External_Rel)))
3032             return false;
3033         }
3034
3035       if (reltext)
3036         {
3037           if (! bfd_elf32_add_dynamic_entry (info, DT_TEXTREL, 0))
3038             return false;
3039           info->flags |= DF_TEXTREL;
3040         }
3041     }
3042
3043   return true;
3044 }
3045
3046 /* This function is called via elf32_arm_link_hash_traverse if we are
3047    creating a shared object with -Bsymbolic.  It discards the space
3048    allocated to copy PC relative relocs against symbols which are
3049    defined in regular objects.  We allocated space for them in the
3050    check_relocs routine, but we won't fill them in in the
3051    relocate_section routine.  */
3052
3053 static boolean
3054 elf32_arm_discard_copies (h, ignore)
3055      struct elf32_arm_link_hash_entry * h;
3056      PTR ignore ATTRIBUTE_UNUSED;
3057 {
3058   struct elf32_arm_pcrel_relocs_copied * s;
3059
3060   /* We only discard relocs for symbols defined in a regular object.  */
3061   if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
3062     return true;
3063
3064   for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
3065     s->section->_raw_size -= s->count * sizeof (Elf32_External_Rel);
3066
3067   return true;
3068 }
3069
3070 /* Finish up dynamic symbol handling.  We set the contents of various
3071    dynamic sections here.  */
3072
3073 static boolean
3074 elf32_arm_finish_dynamic_symbol (output_bfd, info, h, sym)
3075      bfd * output_bfd;
3076      struct bfd_link_info * info;
3077      struct elf_link_hash_entry * h;
3078      Elf_Internal_Sym * sym;
3079 {
3080   bfd * dynobj;
3081
3082   dynobj = elf_hash_table (info)->dynobj;
3083
3084   if (h->plt.offset != (bfd_vma) -1)
3085     {
3086       asection * splt;
3087       asection * sgot;
3088       asection * srel;
3089       bfd_vma plt_index;
3090       bfd_vma got_offset;
3091       Elf_Internal_Rel rel;
3092
3093       /* This symbol has an entry in the procedure linkage table.  Set
3094          it up.  */
3095
3096       BFD_ASSERT (h->dynindx != -1);
3097
3098       splt = bfd_get_section_by_name (dynobj, ".plt");
3099       sgot = bfd_get_section_by_name (dynobj, ".got.plt");
3100       srel = bfd_get_section_by_name (dynobj, ".rel.plt");
3101       BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
3102
3103       /* Get the index in the procedure linkage table which
3104          corresponds to this symbol.  This is the index of this symbol
3105          in all the symbols for which we are making plt entries.  The
3106          first entry in the procedure linkage table is reserved.  */
3107       plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
3108
3109       /* Get the offset into the .got table of the entry that
3110          corresponds to this function.  Each .got entry is 4 bytes.
3111          The first three are reserved.  */
3112       got_offset = (plt_index + 3) * 4;
3113
3114       /* Fill in the entry in the procedure linkage table.  */
3115       memcpy (splt->contents + h->plt.offset,
3116               elf32_arm_plt_entry,
3117               PLT_ENTRY_SIZE);
3118       bfd_put_32 (output_bfd,
3119                       (sgot->output_section->vma
3120                        + sgot->output_offset
3121                        + got_offset
3122                        - splt->output_section->vma
3123                        - splt->output_offset
3124                        - h->plt.offset - 12),
3125                       splt->contents + h->plt.offset + 12);
3126
3127       /* Fill in the entry in the global offset table.  */
3128       bfd_put_32 (output_bfd,
3129                   (splt->output_section->vma
3130                    + splt->output_offset),
3131                   sgot->contents + got_offset);
3132
3133       /* Fill in the entry in the .rel.plt section.  */
3134       rel.r_offset = (sgot->output_section->vma
3135                       + sgot->output_offset
3136                       + got_offset);
3137       rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_JUMP_SLOT);
3138       bfd_elf32_swap_reloc_out (output_bfd, &rel,
3139                                 ((Elf32_External_Rel *) srel->contents
3140                                  + plt_index));
3141
3142       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
3143         {
3144           /* Mark the symbol as undefined, rather than as defined in
3145              the .plt section.  Leave the value alone.  */
3146           sym->st_shndx = SHN_UNDEF;
3147         }
3148     }
3149
3150   if (h->got.offset != (bfd_vma) -1)
3151     {
3152       asection * sgot;
3153       asection * srel;
3154       Elf_Internal_Rel rel;
3155
3156       /* This symbol has an entry in the global offset table.  Set it
3157          up.  */
3158       sgot = bfd_get_section_by_name (dynobj, ".got");
3159       srel = bfd_get_section_by_name (dynobj, ".rel.got");
3160       BFD_ASSERT (sgot != NULL && srel != NULL);
3161
3162       rel.r_offset = (sgot->output_section->vma
3163                       + sgot->output_offset
3164                       + (h->got.offset &~ 1));
3165
3166       /* If this is a -Bsymbolic link, and the symbol is defined
3167          locally, we just want to emit a RELATIVE reloc.  The entry in
3168          the global offset table will already have been initialized in
3169          the relocate_section function.  */
3170       if (info->shared
3171           && (info->symbolic || h->dynindx == -1)
3172           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
3173         rel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
3174       else
3175         {
3176           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
3177           rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT);
3178         }
3179
3180       bfd_elf32_swap_reloc_out (output_bfd, &rel,
3181                                 ((Elf32_External_Rel *) srel->contents
3182                                  + srel->reloc_count));
3183       ++srel->reloc_count;
3184     }
3185
3186   if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
3187     {
3188       asection * s;
3189       Elf_Internal_Rel rel;
3190
3191       /* This symbol needs a copy reloc.  Set it up.  */
3192       BFD_ASSERT (h->dynindx != -1
3193                   && (h->root.type == bfd_link_hash_defined
3194                       || h->root.type == bfd_link_hash_defweak));
3195
3196       s = bfd_get_section_by_name (h->root.u.def.section->owner,
3197                                    ".rel.bss");
3198       BFD_ASSERT (s != NULL);
3199
3200       rel.r_offset = (h->root.u.def.value
3201                       + h->root.u.def.section->output_section->vma
3202                       + h->root.u.def.section->output_offset);
3203       rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_COPY);
3204       bfd_elf32_swap_reloc_out (output_bfd, &rel,
3205                                 ((Elf32_External_Rel *) s->contents
3206                                  + s->reloc_count));
3207       ++s->reloc_count;
3208     }
3209
3210   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
3211   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3212       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
3213     sym->st_shndx = SHN_ABS;
3214
3215   return true;
3216 }
3217
3218 /* Finish up the dynamic sections.  */
3219
3220 static boolean
3221 elf32_arm_finish_dynamic_sections (output_bfd, info)
3222      bfd * output_bfd;
3223      struct bfd_link_info * info;
3224 {
3225   bfd * dynobj;
3226   asection * sgot;
3227   asection * sdyn;
3228
3229   dynobj = elf_hash_table (info)->dynobj;
3230
3231   sgot = bfd_get_section_by_name (dynobj, ".got.plt");
3232   BFD_ASSERT (sgot != NULL);
3233   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3234
3235   if (elf_hash_table (info)->dynamic_sections_created)
3236     {
3237       asection *splt;
3238       Elf32_External_Dyn *dyncon, *dynconend;
3239
3240       splt = bfd_get_section_by_name (dynobj, ".plt");
3241       BFD_ASSERT (splt != NULL && sdyn != NULL);
3242
3243       dyncon = (Elf32_External_Dyn *) sdyn->contents;
3244       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
3245
3246       for (; dyncon < dynconend; dyncon++)
3247         {
3248           Elf_Internal_Dyn dyn;
3249           const char * name;
3250           asection * s;
3251
3252           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3253
3254           switch (dyn.d_tag)
3255             {
3256             default:
3257               break;
3258
3259             case DT_PLTGOT:
3260               name = ".got";
3261               goto get_vma;
3262             case DT_JMPREL:
3263               name = ".rel.plt";
3264             get_vma:
3265               s = bfd_get_section_by_name (output_bfd, name);
3266               BFD_ASSERT (s != NULL);
3267               dyn.d_un.d_ptr = s->vma;
3268               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3269               break;
3270
3271             case DT_PLTRELSZ:
3272               s = bfd_get_section_by_name (output_bfd, ".rel.plt");
3273               BFD_ASSERT (s != NULL);
3274               if (s->_cooked_size != 0)
3275                 dyn.d_un.d_val = s->_cooked_size;
3276               else
3277                 dyn.d_un.d_val = s->_raw_size;
3278               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3279               break;
3280
3281             case DT_RELSZ:
3282               /* My reading of the SVR4 ABI indicates that the
3283                  procedure linkage table relocs (DT_JMPREL) should be
3284                  included in the overall relocs (DT_REL).  This is
3285                  what Solaris does.  However, UnixWare can not handle
3286                  that case.  Therefore, we override the DT_RELSZ entry
3287                  here to make it not include the JMPREL relocs.  Since
3288                  the linker script arranges for .rel.plt to follow all
3289                  other relocation sections, we don't have to worry
3290                  about changing the DT_REL entry.  */
3291               s = bfd_get_section_by_name (output_bfd, ".rel.plt");
3292               if (s != NULL)
3293                 {
3294                   if (s->_cooked_size != 0)
3295                     dyn.d_un.d_val -= s->_cooked_size;
3296                   else
3297                     dyn.d_un.d_val -= s->_raw_size;
3298                 }
3299               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3300               break;
3301             }
3302         }
3303
3304       /* Fill in the first entry in the procedure linkage table.  */
3305       if (splt->_raw_size > 0)
3306         memcpy (splt->contents, elf32_arm_plt0_entry, PLT_ENTRY_SIZE);
3307
3308       /* UnixWare sets the entsize of .plt to 4, although that doesn't
3309          really seem like the right value.  */
3310       elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
3311     }
3312
3313   /* Fill in the first three entries in the global offset table.  */
3314   if (sgot->_raw_size > 0)
3315     {
3316       if (sdyn == NULL)
3317         bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
3318       else
3319         bfd_put_32 (output_bfd,
3320                     sdyn->output_section->vma + sdyn->output_offset,
3321                     sgot->contents);
3322       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
3323       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
3324     }
3325
3326   elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
3327
3328   return true;
3329 }
3330
3331 static void
3332 elf32_arm_post_process_headers (abfd, link_info)
3333      bfd * abfd;
3334      struct bfd_link_info * link_info ATTRIBUTE_UNUSED;
3335 {
3336   Elf_Internal_Ehdr * i_ehdrp;  /* ELF file header, internal form.  */
3337
3338   i_ehdrp = elf_elfheader (abfd);
3339
3340   i_ehdrp->e_ident[EI_OSABI]      = ARM_ELF_OS_ABI_VERSION;
3341   i_ehdrp->e_ident[EI_ABIVERSION] = ARM_ELF_ABI_VERSION;
3342 }
3343
3344
3345 #define ELF_ARCH                        bfd_arch_arm
3346 #define ELF_MACHINE_CODE                EM_ARM
3347 #define ELF_MAXPAGESIZE                 0x8000
3348
3349
3350 #define bfd_elf32_bfd_copy_private_bfd_data     elf32_arm_copy_private_bfd_data
3351 #define bfd_elf32_bfd_merge_private_bfd_data    elf32_arm_merge_private_bfd_data
3352 #define bfd_elf32_bfd_set_private_flags         elf32_arm_set_private_flags
3353 #define bfd_elf32_bfd_print_private_bfd_data    elf32_arm_print_private_bfd_data
3354 #define bfd_elf32_bfd_link_hash_table_create    elf32_arm_link_hash_table_create
3355 #define bfd_elf32_bfd_reloc_type_lookup         elf32_arm_reloc_type_lookup
3356 #define bfd_elf32_find_nearest_line             elf32_arm_find_nearest_line
3357
3358 #define elf_backend_get_symbol_type             elf32_arm_get_symbol_type
3359 #define elf_backend_gc_mark_hook                elf32_arm_gc_mark_hook
3360 #define elf_backend_gc_sweep_hook               elf32_arm_gc_sweep_hook
3361 #define elf_backend_check_relocs                elf32_arm_check_relocs
3362 #define elf_backend_relocate_section            elf32_arm_relocate_section
3363 #define elf_backend_adjust_dynamic_symbol       elf32_arm_adjust_dynamic_symbol
3364 #define elf_backend_create_dynamic_sections     _bfd_elf_create_dynamic_sections
3365 #define elf_backend_finish_dynamic_symbol       elf32_arm_finish_dynamic_symbol
3366 #define elf_backend_finish_dynamic_sections     elf32_arm_finish_dynamic_sections
3367 #define elf_backend_size_dynamic_sections       elf32_arm_size_dynamic_sections
3368 #define elf_backend_post_process_headers        elf32_arm_post_process_headers
3369
3370 #define elf_backend_can_gc_sections 1
3371 #define elf_backend_plt_readonly    1
3372 #define elf_backend_want_got_plt    1
3373 #define elf_backend_want_plt_sym    0
3374
3375 #define elf_backend_got_header_size     12
3376 #define elf_backend_plt_header_size     PLT_ENTRY_SIZE
3377
3378 #include "elf32-target.h"