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