bfd/elf32-arm.h

   1 /* 32-bit ELF support for ARM
   2    Copyright 1998, 1999 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 error_return:
 741   if (free_relocs != NULL)
 742     free (free_relocs);
 743   if (free_contents != NULL)
 744     free (free_contents);
 745   if (free_extsyms != NULL)
 746     free (free_extsyms);
 747   return false;
 748
 749 }
 750
 751 /* The thumb form of a long branch is a bit finicky, because the offset
 752    encoding is split over two fields, each in it's own instruction. They
 753    can occur in any order. So given a thumb form of long branch, and an
 754    offset, insert the offset into the thumb branch and return finished
 755    instruction.
 756
 757    It takes two thumb instructions to encode the target address. Each has
 758    11 bits to invest. The upper 11 bits are stored in one (identifed by
 759    H-0.. see below), the lower 11 bits are stored in the other (identified
 760    by H-1).
 761
 762    Combine together and shifted left by 1 (it's a half word address) and
 763    there you have it.
 764
 765    Op: 1111 = F,
 766    H-0, upper address-0 = 000
 767    Op: 1111 = F,
 768    H-1, lower address-0 = 800
 769
 770    They can be ordered either way, but the arm tools I've seen always put
 771    the lower one first. It probably doesn't matter. krk@cygnus.com
 772
 773    XXX:  Actually the order does matter.  The second instruction (H-1)
 774    moves the computed address into the PC, so it must be the second one
 775    in the sequence.  The problem, however is that whilst little endian code
 776    stores the instructions in HI then LOW order, big endian code does the
 777    reverse.  nickc@cygnus.com  */
 778
 779 #define LOW_HI_ORDER 0xF800F000
 780 #define HI_LOW_ORDER 0xF000F800
 781
 782 static insn32
 783 insert_thumb_branch (br_insn, rel_off)
 784      insn32 br_insn;
 785      int rel_off;
 786 {
 787   unsigned int low_bits;
 788   unsigned int high_bits;
 789
 790
 791   BFD_ASSERT ((rel_off & 1) != 1);
 792
 793   rel_off >>= 1;                /* half word aligned address */
 794   low_bits = rel_off & 0x000007FF;      /* the bottom 11 bits */
 795   high_bits = (rel_off >> 11) & 0x000007FF;     /* the top 11 bits */
 796
 797   if ((br_insn & LOW_HI_ORDER) == LOW_HI_ORDER)
 798     br_insn = LOW_HI_ORDER | (low_bits << 16) | high_bits;
 799   else if ((br_insn & HI_LOW_ORDER) == HI_LOW_ORDER)
 800     br_insn = HI_LOW_ORDER | (high_bits << 16) | low_bits;
 801   else
 802     abort ();                   /* error - not a valid branch instruction form */
 803
 804   /* FIXME: abort is probably not the right call. krk@cygnus.com */
 805
 806   return br_insn;
 807 }
 808
 809 /* Thumb code calling an ARM function */
 810 static int
 811 elf32_thumb_to_arm_stub (info, name, input_bfd, output_bfd, input_section,
 812                          hit_data, sym_sec, offset, addend, val)
 813      struct bfd_link_info * info;
 814      const char *           name;
 815      bfd *                  input_bfd;
 816      bfd *                  output_bfd;
 817      asection *             input_section;
 818      bfd_byte *             hit_data;
 819      asection *             sym_sec;
 820      bfd_vma                offset;
 821      bfd_signed_vma         addend;
 822      bfd_vma                val;
 823 {
 824   asection * s = 0;
 825   long int my_offset;
 826   unsigned long int tmp;
 827   long int ret_offset;
 828   struct elf_link_hash_entry * myh;
 829   struct elf32_arm_link_hash_table * globals;
 830
 831   myh = find_thumb_glue (info, name, input_bfd);
 832   if (myh == NULL)
 833     return false;
 834
 835   globals = elf32_arm_hash_table (info);
 836
 837   BFD_ASSERT (globals != NULL);
 838   BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
 839
 840   my_offset = myh->root.u.def.value;
 841
 842   s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
 843                                THUMB2ARM_GLUE_SECTION_NAME);
 844
 845   BFD_ASSERT (s != NULL);
 846   BFD_ASSERT (s->contents != NULL);
 847   BFD_ASSERT (s->output_section != NULL);
 848
 849   if ((my_offset & 0x01) == 0x01)
 850     {
 851       if (sym_sec != NULL
 852           && sym_sec->owner != NULL
 853           && !INTERWORK_FLAG (sym_sec->owner))
 854         {
 855           _bfd_error_handler
 856             (_ ("%s(%s): warning: interworking not enabled."),
 857              bfd_get_filename (sym_sec->owner), name);
 858           _bfd_error_handler
 859             (_ ("  first occurrence: %s: thumb call to arm"),
 860              bfd_get_filename (input_bfd));
 861
 862           return false;
 863         }
 864
 865       --my_offset;
 866       myh->root.u.def.value = my_offset;
 867
 868       bfd_put_16 (output_bfd, t2a1_bx_pc_insn,
 869                   s->contents + my_offset);
 870
 871       bfd_put_16 (output_bfd, t2a2_noop_insn,
 872                   s->contents + my_offset + 2);
 873
 874       ret_offset =
 875         ((bfd_signed_vma) val)  /* Address of destination of the stub */
 876         - ((bfd_signed_vma)
 877            (s->output_offset    /* Offset from the start of the current section to the start of the stubs.  */
 878             + my_offset         /* Offset of the start of this stub from the start of the stubs.  */
 879             + s->output_section->vma)   /* Address of the start of the current section.  */
 880            + 4                  /* The branch instruction is 4 bytes into the stub.  */
 881            + 8);                /* ARM branches work from the pc of the instruction + 8.  */
 882
 883       bfd_put_32 (output_bfd,
 884                   t2a3_b_insn | ((ret_offset >> 2) & 0x00FFFFFF),
 885                   s->contents + my_offset + 4);
 886     }
 887
 888   BFD_ASSERT (my_offset <= globals->thumb_glue_size);
 889
 890   /* Now go back and fix up the original BL insn to point
 891      to here.  */
 892   ret_offset =
 893     s->output_offset
 894     + my_offset
 895     - (input_section->output_offset
 896        + offset + addend)
 897     - 4;
 898
 899   tmp = bfd_get_32 (input_bfd, hit_data
 900                     - input_section->vma);
 901
 902   bfd_put_32 (output_bfd,
 903               insert_thumb_branch (tmp, ret_offset),
 904               hit_data - input_section->vma);
 905
 906   return true;
 907 }
 908
 909 /* Arm code calling a Thumb function */
 910 static int
 911 elf32_arm_to_thumb_stub (info, name, input_bfd, output_bfd, input_section,
 912                          hit_data, sym_sec, offset, addend, val)
 913      struct bfd_link_info * info;
 914      const char *           name;
 915      bfd *                  input_bfd;
 916      bfd *                  output_bfd;
 917      asection *             input_section;
 918      bfd_byte *             hit_data;
 919      asection *             sym_sec;
 920      bfd_vma                offset;
 921      bfd_signed_vma         addend;
 922      bfd_vma                val;
 923 {
 924   unsigned long int tmp;
 925   long int my_offset;
 926   asection * s;
 927   long int ret_offset;
 928   struct elf_link_hash_entry * myh;
 929   struct elf32_arm_link_hash_table * globals;
 930
 931   myh = find_arm_glue (info, name, input_bfd);
 932   if (myh == NULL)
 933     return false;
 934
 935   globals = elf32_arm_hash_table (info);
 936
 937   BFD_ASSERT (globals != NULL);
 938   BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
 939
 940   my_offset = myh->root.u.def.value;
 941   s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
 942                                ARM2THUMB_GLUE_SECTION_NAME);
 943   BFD_ASSERT (s != NULL);
 944   BFD_ASSERT (s->contents != NULL);
 945   BFD_ASSERT (s->output_section != NULL);
 946
 947   if ((my_offset & 0x01) == 0x01)
 948     {
 949       if (sym_sec != NULL
 950           && sym_sec->owner != NULL
 951           && !INTERWORK_FLAG (sym_sec->owner))
 952         {
 953           _bfd_error_handler
 954             (_ ("%s(%s): warning: interworking not enabled."),
 955              bfd_get_filename (sym_sec->owner), name);
 956           _bfd_error_handler
 957             (_ ("  first occurrence: %s: arm call to thumb"),
 958              bfd_get_filename (input_bfd));
 959         }
 960       --my_offset;
 961       myh->root.u.def.value = my_offset;
 962
 963       bfd_put_32 (output_bfd, a2t1_ldr_insn,
 964                   s->contents + my_offset);
 965
 966       bfd_put_32 (output_bfd, a2t2_bx_r12_insn,
 967                   s->contents + my_offset + 4);
 968
 969       /* It's a thumb address.  Add the low order bit.  */
 970       bfd_put_32 (output_bfd, val | a2t3_func_addr_insn,
 971                   s->contents + my_offset + 8);
 972     }
 973
 974   BFD_ASSERT (my_offset <= globals->arm_glue_size);
 975
 976   tmp = bfd_get_32 (input_bfd, hit_data);
 977   tmp = tmp & 0xFF000000;
 978
 979   /* Somehow these are both 4 too far, so subtract 8. */
 980   ret_offset = s->output_offset
 981     + my_offset
 982     + s->output_section->vma
 983     - (input_section->output_offset
 984        + input_section->output_section->vma
 985        + offset + addend)
 986     - 8;
 987
 988   tmp = tmp | ((ret_offset >> 2) & 0x00FFFFFF);
 989
 990   bfd_put_32 (output_bfd, tmp, hit_data
 991               - input_section->vma);
 992
 993   return true;
 994 }
 995
 996 /* Perform a relocation as part of a final link.  */
 997 static bfd_reloc_status_type
 998 elf32_arm_final_link_relocate (howto, input_bfd, output_bfd,
 999                                input_section, contents, rel, value,
1000                                info, sym_sec, sym_name, sym_flags, h)
1001      reloc_howto_type *     howto;
1002      bfd *                  input_bfd;
1003      bfd *                  output_bfd;
1004      asection *             input_section;
1005      bfd_byte *             contents;
1006      Elf_Internal_Rela *    rel;
1007      bfd_vma                value;
1008      struct bfd_link_info * info;
1009      asection *             sym_sec;
1010      const char *           sym_name;
1011      unsigned char          sym_flags;
1012      struct elf_link_hash_entry * h;
1013 {
1014   unsigned long                 r_type = howto->type;
1015   unsigned long                 r_symndx;
1016   bfd_byte *                    hit_data = contents + rel->r_offset;
1017   bfd *                         dynobj = NULL;
1018   Elf_Internal_Shdr *           symtab_hdr;
1019   struct elf_link_hash_entry ** sym_hashes;
1020   bfd_vma *                     local_got_offsets;
1021   asection *                    sgot = NULL;
1022   asection *                    splt = NULL;
1023   asection *                    sreloc = NULL;
1024   bfd_vma                       addend;
1025   bfd_signed_vma                signed_addend;
1026   struct elf32_arm_link_hash_table * globals;
1027
1028   globals = elf32_arm_hash_table (info);
1029
1030   dynobj = elf_hash_table (info)->dynobj;
1031   if (dynobj)
1032     {
1033       sgot = bfd_get_section_by_name (dynobj, ".got");
1034       splt = bfd_get_section_by_name (dynobj, ".plt");
1035     }
1036   symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
1037   sym_hashes = elf_sym_hashes (input_bfd);
1038   local_got_offsets = elf_local_got_offsets (input_bfd);
1039   r_symndx = ELF32_R_SYM (rel->r_info);
1040
1041 #ifdef USE_REL
1042   addend = bfd_get_32 (input_bfd, hit_data) & howto->src_mask;
1043
1044   if (addend & ((howto->src_mask + 1) >> 1))
1045     {
1046       signed_addend = -1;
1047       signed_addend &= ~ howto->src_mask;
1048       signed_addend |= addend;
1049     }
1050   else
1051     signed_addend = addend;
1052 #else
1053   addend = signed_addend = rel->r_addend;
1054 #endif
1055
1056   switch (r_type)
1057     {
1058     case R_ARM_NONE:
1059       return bfd_reloc_ok;
1060
1061     case R_ARM_PC24:
1062     case R_ARM_ABS32:
1063     case R_ARM_REL32:
1064       /* When generating a shared object, these relocations are copied
1065          into the output file to be resolved at run time. */
1066
1067       if (info->shared
1068           && (r_type != R_ARM_PC24
1069               || (h != NULL
1070                   && h->dynindx != -1
1071                   && (! info->symbolic
1072                       || (h->elf_link_hash_flags
1073                           & ELF_LINK_HASH_DEF_REGULAR) == 0))))
1074         {
1075           Elf_Internal_Rel outrel;
1076           boolean skip, relocate;
1077
1078           if (sreloc == NULL)
1079             {
1080               const char * name;
1081
1082               name = (bfd_elf_string_from_elf_section
1083                       (input_bfd,
1084                        elf_elfheader (input_bfd)->e_shstrndx,
1085                        elf_section_data (input_section)->rel_hdr.sh_name));
1086               if (name == NULL)
1087                 return bfd_reloc_notsupported;
1088
1089               BFD_ASSERT (strncmp (name, ".rel", 4) == 0
1090                           && strcmp (bfd_get_section_name (input_bfd,
1091                                                            input_section),
1092                                      name + 4) == 0);
1093
1094               sreloc = bfd_get_section_by_name (dynobj, name);
1095               BFD_ASSERT (sreloc != NULL);
1096             }
1097
1098           skip = false;
1099
1100           if (elf_section_data (input_section)->stab_info == NULL)
1101             outrel.r_offset = rel->r_offset;
1102           else
1103             {
1104               bfd_vma off;
1105
1106               off = (_bfd_stab_section_offset
1107                      (output_bfd, &elf_hash_table (info)->stab_info,
1108                       input_section,
1109                       & elf_section_data (input_section)->stab_info,
1110                       rel->r_offset));
1111               if (off == (bfd_vma) -1)
1112                 skip = true;
1113               outrel.r_offset = off;
1114             }
1115
1116           outrel.r_offset += (input_section->output_section->vma
1117                               + input_section->output_offset);
1118
1119           if (skip)
1120             {
1121               memset (&outrel, 0, sizeof outrel);
1122               relocate = false;
1123             }
1124           else if (r_type == R_ARM_PC24)
1125             {
1126               BFD_ASSERT (h != NULL && h->dynindx != -1);
1127               if ((input_section->flags & SEC_ALLOC) != 0)
1128                 relocate = false;
1129               else
1130                 relocate = true;
1131               outrel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_PC24);
1132             }
1133           else
1134             {
1135               if (h == NULL
1136                   || ((info->symbolic || h->dynindx == -1)
1137                       && (h->elf_link_hash_flags
1138                           & ELF_LINK_HASH_DEF_REGULAR) != 0))
1139                 {
1140                   relocate = true;
1141                   outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
1142                 }
1143               else
1144                 {
1145                   BFD_ASSERT (h->dynindx != -1);
1146                   if ((input_section->flags & SEC_ALLOC) != 0)
1147                     relocate = false;
1148                   else
1149                     relocate = true;
1150                   outrel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_ABS32);
1151                 }
1152             }
1153
1154           bfd_elf32_swap_reloc_out (output_bfd, &outrel,
1155                                     (((Elf32_External_Rel *)
1156                                       sreloc->contents)
1157                                      + sreloc->reloc_count));
1158           ++sreloc->reloc_count;
1159
1160           /* If this reloc is against an external symbol, we do not want to
1161              fiddle with the addend.  Otherwise, we need to include the symbol
1162              value so that it becomes an addend for the dynamic reloc. */
1163           if (! relocate)
1164             return bfd_reloc_ok;
1165
1166
1167           return _bfd_final_link_relocate (howto, input_bfd, input_section,
1168                                            contents, rel->r_offset, value,
1169                                            (bfd_vma) 0);
1170         }
1171       else switch (r_type)
1172         {
1173         case R_ARM_PC24:
1174           /* Arm B/BL instruction */
1175
1176           /* Check for arm calling thumb function.  */
1177           if (sym_flags == STT_ARM_TFUNC)
1178             {
1179               elf32_arm_to_thumb_stub (info, sym_name, input_bfd, output_bfd,
1180                                        input_section, hit_data, sym_sec, rel->r_offset,
1181                                        signed_addend, value);
1182               return bfd_reloc_ok;
1183             }
1184
1185           if (   strcmp (bfd_get_target (input_bfd), "elf32-littlearm-oabi") == 0
1186               || strcmp (bfd_get_target (input_bfd), "elf32-bigarm-oabi") == 0)
1187             {
1188               /* The old way of doing things.  Trearing the addend as a
1189                  byte sized field and adding in the pipeline offset.  */
1190
1191               value -= (input_section->output_section->vma
1192                         + input_section->output_offset);
1193               value -= rel->r_offset;
1194               value += addend;
1195
1196               if (! globals->no_pipeline_knowledge)
1197                 value -= 8;
1198             }
1199           else
1200             {
1201               /* The ARM ELF ABI says that this reloc is computed as: S - P + A
1202                  where:
1203                   S is the address of the symbol in the relocation.
1204                   P is address of the instruction being relocated.
1205                   A is the addend (extracted from the instruction) in bytes.
1206
1207                  S is held in 'value'.
1208                  P is the base address of the section containing the instruction
1209                    plus the offset of the reloc into that section, ie:
1210                      (input_section->output_section->vma +
1211                       input_section->output_offset +
1212                       rel->r_offset).
1213                  A is the addend, converted into bytes, ie:
1214                      (signed_addend * 4)
1215
1216                  Note: None of these operations have knowledge of the pipeline
1217                  size of the processor, thus it is up to the assembler to encode
1218                  this information into the addend.  */
1219
1220               value -= (input_section->output_section->vma
1221                         + input_section->output_offset);
1222               value -= rel->r_offset;
1223               value += (signed_addend << howto->size);
1224
1225               /* Previous versions of this code also used to add in the pipeline
1226                  offset here.  This is wrong because the linker is not supposed
1227                  to know about such things, and one day it might change.  In order
1228                  to support old binaries that need the old behaviour however, so
1229                  we attempt to detect which ABI was used to create the reloc.  */
1230               if (! globals->no_pipeline_knowledge)
1231                 {
1232                   Elf_Internal_Ehdr * i_ehdrp; /* Elf file header, internal form */
1233
1234                   i_ehdrp = elf_elfheader (input_bfd);
1235
1236                   if (i_ehdrp->e_ident[EI_OSABI] == 0)
1237                     value -= 8;
1238                 }
1239             }
1240
1241           /* It is not an error for an undefined weak reference to be
1242              out of range.  Any program that branches to such a symbol
1243              is going to crash anyway, so there is no point worrying
1244              about getting the destination exactly right.  */
1245           if (! h || h->root.type != bfd_link_hash_undefweak)
1246             {
1247               /* Perform a signed range check.  */
1248               signed_addend = value;
1249               signed_addend >>= howto->rightshift;
1250               if (signed_addend > ((bfd_signed_vma)(howto->dst_mask >> 1))
1251                   || signed_addend < - ((bfd_signed_vma) ((howto->dst_mask + 1) >> 1)))
1252                 return bfd_reloc_overflow;
1253             }
1254
1255           value = (signed_addend & howto->dst_mask)
1256             | (bfd_get_32 (input_bfd, hit_data) & (~ howto->dst_mask));
1257           break;
1258
1259         case R_ARM_ABS32:
1260           value += addend;
1261           if (sym_flags == STT_ARM_TFUNC)
1262             value |= 1;
1263           break;
1264
1265         case R_ARM_REL32:
1266           value -= (input_section->output_section->vma
1267                     + input_section->output_offset);
1268           value += addend;
1269           break;
1270         }
1271
1272       bfd_put_32 (input_bfd, value, hit_data);
1273       return bfd_reloc_ok;
1274
1275     case R_ARM_ABS8:
1276       value += addend;
1277       if ((long) value > 0x7f || (long) value < -0x80)
1278         return bfd_reloc_overflow;
1279
1280       bfd_put_8 (input_bfd, value, hit_data);
1281       return bfd_reloc_ok;
1282
1283     case R_ARM_ABS16:
1284       value += addend;
1285
1286       if ((long) value > 0x7fff || (long) value < -0x8000)
1287         return bfd_reloc_overflow;
1288
1289       bfd_put_16 (input_bfd, value, hit_data);
1290       return bfd_reloc_ok;
1291
1292     case R_ARM_ABS12:
1293       /* Support ldr and str instruction for the arm */
1294       /* Also thumb b (unconditional branch).  ??? Really?  */
1295       value += addend;
1296
1297       if ((long) value > 0x7ff || (long) value < -0x800)
1298         return bfd_reloc_overflow;
1299
1300       value |= (bfd_get_32 (input_bfd, hit_data) & 0xfffff000);
1301       bfd_put_32 (input_bfd, value, hit_data);
1302       return bfd_reloc_ok;
1303
1304     case R_ARM_THM_ABS5:
1305       /* Support ldr and str instructions for the thumb. */
1306 #ifdef USE_REL
1307       /* Need to refetch addend.  */
1308       addend = bfd_get_16 (input_bfd, hit_data) & howto->src_mask;
1309       /* ??? Need to determine shift amount from operand size.  */
1310       addend >>= howto->rightshift;
1311 #endif
1312       value += addend;
1313
1314       /* ??? Isn't value unsigned?  */
1315       if ((long) value > 0x1f || (long) value < -0x10)
1316         return bfd_reloc_overflow;
1317
1318       /* ??? Value needs to be properly shifted into place first.  */
1319       value |= bfd_get_16 (input_bfd, hit_data) & 0xf83f;
1320       bfd_put_16 (input_bfd, value, hit_data);
1321       return bfd_reloc_ok;
1322
1323     case R_ARM_THM_PC22:
1324       /* Thumb BL (branch long instruction). */
1325       {
1326         bfd_vma        relocation;
1327         boolean        overflow = false;
1328         bfd_vma        upper_insn = bfd_get_16 (input_bfd, hit_data);
1329         bfd_vma        lower_insn = bfd_get_16 (input_bfd, hit_data + 2);
1330         bfd_signed_vma reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
1331         bfd_signed_vma reloc_signed_min = ~ reloc_signed_max;
1332         bfd_vma        check;
1333         bfd_signed_vma signed_check;
1334
1335 #ifdef USE_REL
1336         /* Need to refetch the addend and squish the two 11 bit pieces
1337            together.  */
1338         {
1339           bfd_vma upper = upper_insn & 0x7ff;
1340           bfd_vma lower = lower_insn & 0x7ff;
1341           upper = (upper ^ 0x400) - 0x400; /* sign extend */
1342           addend = (upper << 12) | (lower << 1);
1343           signed_addend = addend;
1344         }
1345 #endif
1346
1347         /* If it is not a call to thumb, assume call to arm.
1348            If it is a call relative to a section name, then it is not a
1349            function call at all, but rather a long jump.  */
1350         if (sym_flags != STT_ARM_TFUNC && sym_flags != STT_SECTION)
1351           {
1352             if (elf32_thumb_to_arm_stub
1353                 (info, sym_name, input_bfd, output_bfd, input_section,
1354                  hit_data, sym_sec, rel->r_offset, signed_addend, value))
1355               return bfd_reloc_ok;
1356             else
1357               return bfd_reloc_dangerous;
1358           }
1359
1360         relocation = value + signed_addend;
1361
1362         relocation -= (input_section->output_section->vma
1363                        + input_section->output_offset
1364                        + rel->r_offset);
1365
1366         if (! globals->no_pipeline_knowledge)
1367           {
1368             Elf_Internal_Ehdr * i_ehdrp; /* Elf file header, internal form */
1369
1370             i_ehdrp = elf_elfheader (input_bfd);
1371
1372             /* Previous versions of this code also used to add in the pipline
1373                offset here.  This is wrong because the linker is not supposed
1374                to know about such things, and one day it might change.  In order
1375                to support old binaries that need the old behaviour however, so
1376                we attempt to detect which ABI was used to create the reloc.  */
1377             if (   strcmp (bfd_get_target (input_bfd), "elf32-littlearm-oabi") == 0
1378                 || strcmp (bfd_get_target (input_bfd), "elf32-bigarm-oabi") == 0
1379                 || i_ehdrp->e_ident[EI_OSABI] == 0)
1380               relocation += 4;
1381           }
1382
1383         check = relocation >> howto->rightshift;
1384
1385         /* If this is a signed value, the rightshift just dropped
1386            leading 1 bits (assuming twos complement).  */
1387         if ((bfd_signed_vma) relocation >= 0)
1388           signed_check = check;
1389         else
1390           signed_check = check | ~((bfd_vma) -1 >> howto->rightshift);
1391
1392         /* Assumes two's complement.  */
1393         if (signed_check > reloc_signed_max || signed_check < reloc_signed_min)
1394           overflow = true;
1395
1396         /* Put RELOCATION back into the insn.  */
1397         upper_insn = (upper_insn & ~(bfd_vma) 0x7ff) | ((relocation >> 12) & 0x7ff);
1398         lower_insn = (lower_insn & ~(bfd_vma) 0x7ff) | ((relocation >> 1) & 0x7ff);
1399
1400         /* Put the relocated value back in the object file:  */
1401         bfd_put_16 (input_bfd, upper_insn, hit_data);
1402         bfd_put_16 (input_bfd, lower_insn, hit_data + 2);
1403
1404         return (overflow ? bfd_reloc_overflow : bfd_reloc_ok);
1405       }
1406       break;
1407
1408     case R_ARM_GNU_VTINHERIT:
1409     case R_ARM_GNU_VTENTRY:
1410       return bfd_reloc_ok;
1411
1412     case R_ARM_COPY:
1413       return bfd_reloc_notsupported;
1414
1415     case R_ARM_GLOB_DAT:
1416       return bfd_reloc_notsupported;
1417
1418     case R_ARM_JUMP_SLOT:
1419       return bfd_reloc_notsupported;
1420
1421     case R_ARM_RELATIVE:
1422       return bfd_reloc_notsupported;
1423
1424     case R_ARM_GOTOFF:
1425       /* Relocation is relative to the start of the
1426          global offset table.  */
1427
1428       BFD_ASSERT (sgot != NULL);
1429       if (sgot == NULL)
1430         return bfd_reloc_notsupported;
1431
1432       /* Note that sgot->output_offset is not involved in this
1433          calculation.  We always want the start of .got.  If we
1434          define _GLOBAL_OFFSET_TABLE in a different way, as is
1435          permitted by the ABI, we might have to change this
1436          calculation. */
1437
1438       value -= sgot->output_section->vma;
1439       return _bfd_final_link_relocate (howto, input_bfd, input_section,
1440                                        contents, rel->r_offset, value,
1441                                        (bfd_vma) 0);
1442
1443     case R_ARM_GOTPC:
1444       /* Use global offset table as symbol value. */
1445
1446       BFD_ASSERT (sgot != NULL);
1447
1448       if (sgot == NULL)
1449         return bfd_reloc_notsupported;
1450
1451       value = sgot->output_section->vma;
1452       return _bfd_final_link_relocate (howto, input_bfd, input_section,
1453                                        contents, rel->r_offset, value,
1454                                        (bfd_vma) 0);
1455
1456     case R_ARM_GOT32:
1457       /* Relocation is to the entry for this symbol in the
1458          global offset table. */
1459       if (sgot == NULL)
1460         return bfd_reloc_notsupported;
1461
1462       if (h != NULL)
1463         {
1464           bfd_vma off;
1465
1466           off = h->got.offset;
1467           BFD_ASSERT (off != (bfd_vma) -1);
1468
1469           if (!elf_hash_table (info)->dynamic_sections_created ||
1470               (info->shared && (info->symbolic || h->dynindx == -1)
1471                && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR)))
1472             {
1473               /* This is actually a static link, or it is a -Bsymbolic link
1474                  and the symbol is defined locally.  We must initialize this
1475                  entry in the global offset table.  Since the offset must
1476                  always be a multiple of 4, we use the least significant bit
1477                  to record whether we have initialized it already.
1478
1479                  When doing a dynamic link, we create a .rel.got relocation
1480                  entry to initialize the value.  This is done in the
1481                  finish_dynamic_symbol routine. */
1482
1483               if ((off & 1) != 0)
1484                 off &= ~1;
1485               else
1486                 {
1487                   bfd_put_32 (output_bfd, value, sgot->contents + off);
1488                   h->got.offset |= 1;
1489                 }
1490             }
1491
1492           value = sgot->output_offset + off;
1493         }
1494       else
1495         {
1496           bfd_vma off;
1497
1498           BFD_ASSERT (local_got_offsets != NULL &&
1499                       local_got_offsets[r_symndx] != (bfd_vma) -1);
1500
1501           off = local_got_offsets[r_symndx];
1502
1503           /* The offset must always be a multiple of 4.  We use the
1504              least significant bit to record whether we have already
1505              generated the necessary reloc. */
1506           if ((off & 1) != 0)
1507             off &= ~1;
1508           else
1509             {
1510               bfd_put_32 (output_bfd, value, sgot->contents + off);
1511
1512               if (info->shared)
1513                 {
1514                   asection * srelgot;
1515                   Elf_Internal_Rel outrel;
1516
1517                   srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
1518                   BFD_ASSERT (srelgot != NULL);
1519
1520                   outrel.r_offset = (sgot->output_section->vma
1521                                      + sgot->output_offset
1522                                      + off);
1523                   outrel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
1524                   bfd_elf32_swap_reloc_out (output_bfd, &outrel,
1525                                             (((Elf32_External_Rel *)
1526                                               srelgot->contents)
1527                                              + srelgot->reloc_count));
1528                   ++srelgot->reloc_count;
1529                 }
1530
1531               local_got_offsets[r_symndx] |= 1;
1532             }
1533
1534           value = sgot->output_offset + off;
1535         }
1536
1537       return _bfd_final_link_relocate (howto, input_bfd, input_section,
1538                                        contents, rel->r_offset, value,
1539                                        (bfd_vma) 0);
1540
1541     case R_ARM_PLT32:
1542       /* Relocation is to the entry for this symbol in the
1543          procedure linkage table.  */
1544
1545       /* Resolve a PLT32 reloc against a local symbol directly,
1546          without using the procedure linkage table. */
1547       if (h == NULL)
1548         return _bfd_final_link_relocate (howto, input_bfd, input_section,
1549                                          contents, rel->r_offset, value,
1550                                          (bfd_vma) 0);
1551
1552       if (h->plt.offset == (bfd_vma) -1)
1553         /* We didn't make a PLT entry for this symbol.  This
1554            happens when statically linking PIC code, or when
1555            using -Bsymbolic.  */
1556         return _bfd_final_link_relocate (howto, input_bfd, input_section,
1557                                          contents, rel->r_offset, value,
1558                                          (bfd_vma) 0);
1559
1560       BFD_ASSERT(splt != NULL);
1561       if (splt == NULL)
1562         return bfd_reloc_notsupported;
1563
1564       value = (splt->output_section->vma
1565                + splt->output_offset
1566                + h->plt.offset);
1567       return _bfd_final_link_relocate (howto, input_bfd, input_section,
1568                                        contents, rel->r_offset, value,
1569                                        (bfd_vma) 0);
1570
1571     case R_ARM_SBREL32:
1572       return bfd_reloc_notsupported;
1573
1574     case R_ARM_AMP_VCALL9:
1575       return bfd_reloc_notsupported;
1576
1577     case R_ARM_RSBREL32:
1578       return bfd_reloc_notsupported;
1579
1580     case R_ARM_THM_RPC22:
1581       return bfd_reloc_notsupported;
1582
1583     case R_ARM_RREL32:
1584       return bfd_reloc_notsupported;
1585
1586     case R_ARM_RABS32:
1587       return bfd_reloc_notsupported;
1588
1589     case R_ARM_RPC24:
1590       return bfd_reloc_notsupported;
1591
1592     case R_ARM_RBASE:
1593       return bfd_reloc_notsupported;
1594
1595     default:
1596       return bfd_reloc_notsupported;
1597     }
1598 }
1599
1600 #ifdef USE_REL
1601 /* Add INCREMENT to the reloc (of type HOWTO) at ADDRESS.  */
1602 static void
1603 arm_add_to_rel (abfd, address, howto, increment)
1604      bfd *              abfd;
1605      bfd_byte *         address;
1606      reloc_howto_type * howto;
1607      bfd_signed_vma     increment;
1608 {
1609   bfd_vma        contents;
1610   bfd_signed_vma addend;
1611
1612   contents = bfd_get_32 (abfd, address);
1613
1614   /* Get the (signed) value from the instruction.  */
1615   addend = contents & howto->src_mask;
1616   if (addend & ((howto->src_mask + 1) >> 1))
1617     {
1618       bfd_signed_vma mask;
1619
1620       mask = -1;
1621       mask &= ~ howto->src_mask;
1622       addend |= mask;
1623     }
1624
1625   /* Add in the increment, (which is a byte value).  */
1626   switch (howto->type)
1627     {
1628     case R_ARM_THM_PC22:
1629     default:
1630       addend += increment;
1631       break;
1632
1633     case R_ARM_PC24:
1634       addend <<= howto->size;
1635       addend +=  increment;
1636
1637       /* Should we check for overflow here ?  */
1638
1639       /* Drop any undesired bits.  */
1640       addend >>= howto->rightshift;
1641       break;
1642     }
1643
1644   contents = (contents & ~ howto->dst_mask) | (addend & howto->dst_mask);
1645
1646   bfd_put_32 (abfd, contents, address);
1647 }
1648 #endif /* USE_REL */
1649
1650 /* Relocate an ARM ELF section.  */
1651 static boolean
1652 elf32_arm_relocate_section (output_bfd, info, input_bfd, input_section,
1653                             contents, relocs, local_syms, local_sections)
1654      bfd *                  output_bfd;
1655      struct bfd_link_info * info;
1656      bfd *                  input_bfd;
1657      asection *             input_section;
1658      bfd_byte *             contents;
1659      Elf_Internal_Rela *    relocs;
1660      Elf_Internal_Sym *     local_syms;
1661      asection **            local_sections;
1662 {
1663   Elf_Internal_Shdr *           symtab_hdr;
1664   struct elf_link_hash_entry ** sym_hashes;
1665   Elf_Internal_Rela *           rel;
1666   Elf_Internal_Rela *           relend;
1667   const char *                  name;
1668
1669   symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
1670   sym_hashes = elf_sym_hashes (input_bfd);
1671
1672   rel = relocs;
1673   relend = relocs + input_section->reloc_count;
1674   for (; rel < relend; rel++)
1675     {
1676       int                          r_type;
1677       reloc_howto_type *           howto;
1678       unsigned long                r_symndx;
1679       Elf_Internal_Sym *           sym;
1680       asection *                   sec;
1681       struct elf_link_hash_entry * h;
1682       bfd_vma                      relocation;
1683       bfd_reloc_status_type        r;
1684       arelent                      bfd_reloc;
1685
1686       r_symndx = ELF32_R_SYM (rel->r_info);
1687       r_type   = ELF32_R_TYPE (rel->r_info);
1688
1689       if (   r_type == R_ARM_GNU_VTENTRY
1690           || r_type == R_ARM_GNU_VTINHERIT)
1691         continue;
1692
1693       elf32_arm_info_to_howto (input_bfd, & bfd_reloc, rel);
1694       howto = bfd_reloc.howto;
1695
1696       if (info->relocateable)
1697         {
1698           /* This is a relocateable link.  We don't have to change
1699              anything, unless the reloc is against a section symbol,
1700              in which case we have to adjust according to where the
1701              section symbol winds up in the output section.  */
1702           if (r_symndx < symtab_hdr->sh_info)
1703             {
1704               sym = local_syms + r_symndx;
1705               if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
1706                 {
1707                   sec = local_sections[r_symndx];
1708 #ifdef USE_REL
1709                   arm_add_to_rel (input_bfd, contents + rel->r_offset,
1710                                   howto, sec->output_offset + sym->st_value);
1711 #else
1712                   rel->r_addend += (sec->output_offset + sym->st_value)
1713                     >> howto->rightshift;
1714 #endif
1715                 }
1716             }
1717
1718           continue;
1719         }
1720
1721       /* This is a final link.  */
1722       h = NULL;
1723       sym = NULL;
1724       sec = NULL;
1725       if (r_symndx < symtab_hdr->sh_info)
1726         {
1727           sym = local_syms + r_symndx;
1728           sec = local_sections[r_symndx];
1729           relocation = (sec->output_section->vma
1730                         + sec->output_offset
1731                         + sym->st_value);
1732         }
1733       else
1734         {
1735           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1736           while (h->root.type == bfd_link_hash_indirect
1737                  || h->root.type == bfd_link_hash_warning)
1738             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1739           if (h->root.type == bfd_link_hash_defined
1740               || h->root.type == bfd_link_hash_defweak)
1741             {
1742               int relocation_needed = 1;
1743
1744               sec = h->root.u.def.section;
1745
1746               /* In these cases, we don't need the relocation value.
1747                  We check specially because in some obscure cases
1748                  sec->output_section will be NULL. */
1749               switch (r_type)
1750                 {
1751                 case R_ARM_PC24:
1752                 case R_ARM_ABS32:
1753                   if (info->shared
1754                       && (
1755                           (!info->symbolic && h->dynindx != -1)
1756                           || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
1757                           )
1758                       && ((input_section->flags & SEC_ALLOC) != 0)
1759                       )
1760                     relocation_needed = 0;
1761                   break;
1762
1763                 case R_ARM_GOTPC:
1764                   relocation_needed = 0;
1765                   break;
1766
1767                 case R_ARM_GOT32:
1768                   if (elf_hash_table(info)->dynamic_sections_created
1769                       && (!info->shared
1770                           || (!info->symbolic && h->dynindx != -1)
1771                           || (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0
1772                           )
1773                       )
1774                     relocation_needed = 0;
1775                   break;
1776
1777                 case R_ARM_PLT32:
1778                   if (h->plt.offset != (bfd_vma)-1)
1779                     relocation_needed = 0;
1780                   break;
1781
1782                 default:
1783                   if (sec->output_section == NULL)
1784                     {
1785                       (*_bfd_error_handler)
1786                         (_("%s: warning: unresolvable relocation against symbol `%s' from %s section"),
1787                          bfd_get_filename (input_bfd), h->root.root.string,
1788                          bfd_get_section_name (input_bfd, input_section));
1789                       relocation_needed = 0;
1790                     }
1791                 }
1792
1793               if (relocation_needed)
1794                 relocation = h->root.u.def.value
1795                   + sec->output_section->vma
1796                   + sec->output_offset;
1797               else
1798                 relocation = 0;
1799             }
1800           else if (h->root.type == bfd_link_hash_undefweak)
1801             relocation = 0;
1802           else if (info->shared && !info->symbolic && !info->no_undefined)
1803             relocation = 0;
1804           else
1805             {
1806               if (!((*info->callbacks->undefined_symbol)
1807                     (info, h->root.root.string, input_bfd,
1808                      input_section, rel->r_offset)))
1809                 return false;
1810               relocation = 0;
1811             }
1812         }
1813
1814       if (h != NULL)
1815         name = h->root.root.string;
1816       else
1817         {
1818           name = (bfd_elf_string_from_elf_section
1819                   (input_bfd, symtab_hdr->sh_link, sym->st_name));
1820           if (name == NULL || *name == '\0')
1821             name = bfd_section_name (input_bfd, sec);
1822         }
1823
1824       r = elf32_arm_final_link_relocate (howto, input_bfd, output_bfd,
1825                                          input_section, contents, rel,
1826                                          relocation, info, sec, name,
1827                                          (h ? ELF_ST_TYPE (h->type) :
1828                                           ELF_ST_TYPE (sym->st_info)), h);
1829
1830       if (r != bfd_reloc_ok)
1831         {
1832           const char * msg = (const char *) 0;
1833
1834           switch (r)
1835             {
1836             case bfd_reloc_overflow:
1837               if (!((*info->callbacks->reloc_overflow)
1838                     (info, name, howto->name, (bfd_vma) 0,
1839                      input_bfd, input_section, rel->r_offset)))
1840                 return false;
1841               break;
1842
1843             case bfd_reloc_undefined:
1844               if (!((*info->callbacks->undefined_symbol)
1845                     (info, name, input_bfd, input_section,
1846                      rel->r_offset)))
1847                 return false;
1848               break;
1849
1850             case bfd_reloc_outofrange:
1851               msg = _ ("internal error: out of range error");
1852               goto common_error;
1853
1854             case bfd_reloc_notsupported:
1855               msg = _ ("internal error: unsupported relocation error");
1856               goto common_error;
1857
1858             case bfd_reloc_dangerous:
1859               msg = _ ("internal error: dangerous error");
1860               goto common_error;
1861
1862             default:
1863               msg = _ ("internal error: unknown error");
1864               /* fall through */
1865
1866             common_error:
1867               if (!((*info->callbacks->warning)
1868                     (info, msg, name, input_bfd, input_section,
1869                      rel->r_offset)))
1870                 return false;
1871               break;
1872             }
1873         }
1874     }
1875
1876   return true;
1877 }
1878
1879 /* Function to keep ARM specific flags in the ELF header. */
1880 static boolean
1881 elf32_arm_set_private_flags (abfd, flags)
1882      bfd *abfd;
1883      flagword flags;
1884 {
1885   if (elf_flags_init (abfd)
1886       && elf_elfheader (abfd)->e_flags != flags)
1887     {
1888       if (flags & EF_INTERWORK)
1889         _bfd_error_handler (_ ("\
1890 Warning: Not setting interwork flag of %s since it has already been specified as non-interworking"),
1891                             bfd_get_filename (abfd));
1892       else
1893         _bfd_error_handler (_ ("\
1894 Warning: Clearing the interwork flag of %s due to outside request"),
1895                             bfd_get_filename (abfd));
1896     }
1897   else
1898     {
1899       elf_elfheader (abfd)->e_flags = flags;
1900       elf_flags_init (abfd) = true;
1901     }
1902
1903   return true;
1904 }
1905
1906 /* Copy backend specific data from one object module to another */
1907 static boolean
1908 elf32_arm_copy_private_bfd_data (ibfd, obfd)
1909      bfd *ibfd;
1910      bfd *obfd;
1911 {
1912   flagword in_flags;
1913   flagword out_flags;
1914
1915   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1916       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1917     return true;
1918
1919   in_flags = elf_elfheader (ibfd)->e_flags;
1920   out_flags = elf_elfheader (obfd)->e_flags;
1921
1922   if (elf_flags_init (obfd) && in_flags != out_flags)
1923     {
1924       /* Cannot mix PIC and non-PIC code.  */
1925       if ((in_flags & EF_PIC) != (out_flags & EF_PIC))
1926         return false;
1927
1928       /* Cannot mix APCS26 and APCS32 code.  */
1929       if ((in_flags & EF_APCS_26) != (out_flags & EF_APCS_26))
1930         return false;
1931
1932       /* Cannot mix float APCS and non-float APCS code.  */
1933       if ((in_flags & EF_APCS_FLOAT) != (out_flags & EF_APCS_FLOAT))
1934         return false;
1935
1936       /* If the src and dest have different interworking flags
1937          then turn off the interworking bit.  */
1938       if ((in_flags & EF_INTERWORK) != (out_flags & EF_INTERWORK))
1939         {
1940           if (out_flags & EF_INTERWORK)
1941             _bfd_error_handler (_ ("\
1942 Warning: Clearing the interwork flag in %s because non-interworking code in %s has been linked with it"),
1943                           bfd_get_filename (obfd), bfd_get_filename (ibfd));
1944
1945           in_flags &= ~EF_INTERWORK;
1946         }
1947     }
1948
1949   elf_elfheader (obfd)->e_flags = in_flags;
1950   elf_flags_init (obfd) = true;
1951
1952   return true;
1953 }
1954
1955 /* Merge backend specific data from an object file to the output
1956    object file when linking.  */
1957 static boolean
1958 elf32_arm_merge_private_bfd_data (ibfd, obfd)
1959      bfd *ibfd;
1960      bfd *obfd;
1961 {
1962   flagword out_flags;
1963   flagword in_flags;
1964
1965   if (   bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1966       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1967     return true;
1968
1969   /* Check if we have the same endianess */
1970   if (   ibfd->xvec->byteorder != obfd->xvec->byteorder
1971       && obfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN
1972       && ibfd->xvec->byteorder != BFD_ENDIAN_UNKNOWN)
1973     {
1974       (*_bfd_error_handler)
1975         (_("%s: compiled for a %s endian system and target is %s endian"),
1976          bfd_get_filename (ibfd),
1977          bfd_big_endian (ibfd) ? "big" : "little",
1978          bfd_big_endian (obfd) ? "big" : "little");
1979
1980       bfd_set_error (bfd_error_wrong_format);
1981       return false;
1982     }
1983
1984   /* The input BFD must have had its flags initialised.  */
1985   /* The following seems bogus to me -- The flags are initialized in
1986      the assembler but I don't think an elf_flags_init field is
1987      written into the object */
1988   /* BFD_ASSERT (elf_flags_init (ibfd)); */
1989
1990   in_flags  = elf_elfheader (ibfd)->e_flags;
1991   out_flags = elf_elfheader (obfd)->e_flags;
1992
1993   if (!elf_flags_init (obfd))
1994     {
1995       /* If the input is the default architecture then do not
1996          bother setting the flags for the output architecture,
1997          instead allow future merges to do this.  If no future
1998          merges ever set these flags then they will retain their
1999          unitialised values, which surprise surprise, correspond
2000          to the default values.  */
2001       if (bfd_get_arch_info (ibfd)->the_default)
2002         return true;
2003
2004       elf_flags_init (obfd) = true;
2005       elf_elfheader (obfd)->e_flags = in_flags;
2006
2007       if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
2008           && bfd_get_arch_info (obfd)->the_default)
2009         return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
2010
2011       return true;
2012     }
2013
2014   /* Check flag compatibility.  */
2015   if (in_flags == out_flags)
2016     return true;
2017
2018   /* Complain about various flag mismatches.  */
2019
2020   if ((in_flags & EF_APCS_26) != (out_flags & EF_APCS_26))
2021     _bfd_error_handler (_ ("\
2022 Error: %s compiled for APCS-%d, whereas %s is compiled for APCS-%d"),
2023                         bfd_get_filename (ibfd),
2024                         in_flags & EF_APCS_26 ? 26 : 32,
2025                         bfd_get_filename (obfd),
2026                         out_flags & EF_APCS_26 ? 26 : 32);
2027
2028   if ((in_flags & EF_APCS_FLOAT) != (out_flags & EF_APCS_FLOAT))
2029     _bfd_error_handler (_ ("\
2030 Error: %s passes floats in %s registers, whereas %s passes them in %s registers"),
2031                         bfd_get_filename (ibfd),
2032                      in_flags & EF_APCS_FLOAT ? _ ("float") : _ ("integer"),
2033                         bfd_get_filename (obfd),
2034                       out_flags & EF_APCS_26 ? _ ("float") : _ ("integer"));
2035
2036   if ((in_flags & EF_PIC) != (out_flags & EF_PIC))
2037     _bfd_error_handler (_ ("\
2038 Error: %s is compiled as position %s code, whereas %s is not"),
2039                         bfd_get_filename (ibfd),
2040                     in_flags & EF_PIC ? _ ("independent") : _ ("dependent"),
2041                         bfd_get_filename (obfd));
2042
2043   /* Interworking mismatch is only a warning. */
2044   if ((in_flags & EF_INTERWORK) != (out_flags & EF_INTERWORK))
2045     {
2046       _bfd_error_handler (_ ("\
2047 Warning: %s %s interworking, whereas %s %s"),
2048                           bfd_get_filename (ibfd),
2049           in_flags & EF_INTERWORK ? _ ("supports") : _ ("does not support"),
2050                           bfd_get_filename (obfd),
2051                     out_flags & EF_INTERWORK ? _ ("does not") : _ ("does"));
2052       return true;
2053     }
2054
2055   return false;
2056 }
2057
2058 /* Display the flags field */
2059 static boolean
2060 elf32_arm_print_private_bfd_data (abfd, ptr)
2061      bfd *abfd;
2062      PTR ptr;
2063 {
2064   FILE *file = (FILE *) ptr;
2065
2066   BFD_ASSERT (abfd != NULL && ptr != NULL);
2067
2068   /* Print normal ELF private data.  */
2069   _bfd_elf_print_private_bfd_data (abfd, ptr);
2070
2071   /* Ignore init flag - it may not be set, despite the flags field containing valid data.  */
2072
2073   /* xgettext:c-format */
2074   fprintf (file, _ ("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
2075
2076   if (elf_elfheader (abfd)->e_flags & EF_INTERWORK)
2077     fprintf (file, _ (" [interworking enabled]"));
2078   else
2079     fprintf (file, _ (" [interworking not enabled]"));
2080
2081   if (elf_elfheader (abfd)->e_flags & EF_APCS_26)
2082     fprintf (file, _ (" [APCS-26]"));
2083   else
2084     fprintf (file, _ (" [APCS-32]"));
2085
2086   if (elf_elfheader (abfd)->e_flags & EF_APCS_FLOAT)
2087     fprintf (file, _ (" [floats passed in float registers]"));
2088   else
2089     fprintf (file, _ (" [floats passed in integer registers]"));
2090
2091   if (elf_elfheader (abfd)->e_flags & EF_PIC)
2092     fprintf (file, _ (" [position independent]"));
2093   else
2094     fprintf (file, _ (" [absolute position]"));
2095
2096   fputc ('\n', file);
2097
2098   return true;
2099 }
2100
2101 static int
2102 elf32_arm_get_symbol_type (elf_sym, type)
2103      Elf_Internal_Sym * elf_sym;
2104      int type;
2105 {
2106   if (ELF_ST_TYPE (elf_sym->st_info) == STT_ARM_TFUNC)
2107     return ELF_ST_TYPE (elf_sym->st_info);
2108   else
2109     return type;
2110 }
2111
2112 static asection *
2113 elf32_arm_gc_mark_hook (abfd, info, rel, h, sym)
2114        bfd *abfd;
2115        struct bfd_link_info *info ATTRIBUTE_UNUSED;
2116        Elf_Internal_Rela *rel;
2117        struct elf_link_hash_entry *h;
2118        Elf_Internal_Sym *sym;
2119 {
2120   if (h != NULL)
2121     {
2122       switch (ELF32_R_TYPE (rel->r_info))
2123       {
2124       case R_ARM_GNU_VTINHERIT:
2125       case R_ARM_GNU_VTENTRY:
2126         break;
2127
2128       default:
2129         switch (h->root.type)
2130           {
2131           case bfd_link_hash_defined:
2132           case bfd_link_hash_defweak:
2133             return h->root.u.def.section;
2134
2135           case bfd_link_hash_common:
2136             return h->root.u.c.p->section;
2137
2138           default:
2139             break;
2140           }
2141        }
2142      }
2143    else
2144      {
2145        if (!(elf_bad_symtab (abfd)
2146            && ELF_ST_BIND (sym->st_info) != STB_LOCAL)
2147          && ! ((sym->st_shndx <= 0 || sym->st_shndx >= SHN_LORESERVE)
2148                 && sym->st_shndx != SHN_COMMON))
2149           {
2150             return bfd_section_from_elf_index (abfd, sym->st_shndx);
2151           }
2152       }
2153   return NULL;
2154 }
2155
2156 /* Update the got entry reference counts for the section being removed.  */
2157
2158 static boolean
2159 elf32_arm_gc_sweep_hook (abfd, info, sec, relocs)
2160      bfd *abfd ATTRIBUTE_UNUSED;
2161      struct bfd_link_info *info ATTRIBUTE_UNUSED;
2162      asection *sec ATTRIBUTE_UNUSED;
2163      const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
2164 {
2165   /* We don't support garbage collection of GOT and PLT relocs yet.  */
2166   return true;
2167 }
2168
2169 /* Look through the relocs for a section during the first phase.  */
2170
2171 static boolean
2172 elf32_arm_check_relocs (abfd, info, sec, relocs)
2173      bfd *                      abfd;
2174      struct bfd_link_info *     info;
2175      asection *                 sec;
2176      const Elf_Internal_Rela *  relocs;
2177 {
2178   Elf_Internal_Shdr *           symtab_hdr;
2179   struct elf_link_hash_entry ** sym_hashes;
2180   struct elf_link_hash_entry ** sym_hashes_end;
2181   const Elf_Internal_Rela *     rel;
2182   const Elf_Internal_Rela *     rel_end;
2183   bfd *                         dynobj;
2184   asection * sgot, *srelgot, *sreloc;
2185   bfd_vma * local_got_offsets;
2186
2187   if (info->relocateable)
2188     return true;
2189
2190   sgot = srelgot = sreloc = NULL;
2191
2192   dynobj = elf_hash_table (info)->dynobj;
2193   local_got_offsets = elf_local_got_offsets (abfd);
2194
2195   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2196   sym_hashes = elf_sym_hashes (abfd);
2197   sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof(Elf32_External_Sym);
2198   if (!elf_bad_symtab (abfd))
2199     sym_hashes_end -= symtab_hdr->sh_info;
2200
2201   rel_end = relocs + sec->reloc_count;
2202   for (rel = relocs; rel < rel_end; rel++)
2203     {
2204       struct elf_link_hash_entry *h;
2205       unsigned long r_symndx;
2206
2207       r_symndx = ELF32_R_SYM (rel->r_info);
2208       if (r_symndx < symtab_hdr->sh_info)
2209         h = NULL;
2210       else
2211         h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2212
2213       /* Some relocs require a global offset table.  */
2214       if (dynobj == NULL)
2215         {
2216           switch (ELF32_R_TYPE (rel->r_info))
2217             {
2218             case R_ARM_GOT32:
2219             case R_ARM_GOTOFF:
2220             case R_ARM_GOTPC:
2221               elf_hash_table (info)->dynobj = dynobj = abfd;
2222               if (! _bfd_elf_create_got_section (dynobj, info))
2223                 return false;
2224               break;
2225
2226             default:
2227               break;
2228             }
2229         }
2230
2231       switch (ELF32_R_TYPE (rel->r_info))
2232         {
2233           case R_ARM_GOT32:
2234             /* This symbol requires a global offset table entry.  */
2235             if (sgot == NULL)
2236               {
2237                 sgot = bfd_get_section_by_name (dynobj, ".got");
2238                 BFD_ASSERT (sgot != NULL);
2239               }
2240
2241             /* Get the got relocation section if necessary.  */
2242             if (srelgot == NULL
2243                 && (h != NULL || info->shared))
2244               {
2245                 srelgot = bfd_get_section_by_name (dynobj, ".rel.got");
2246
2247                 /* If no got relocation section, make one and initialize.  */
2248                 if (srelgot == NULL)
2249                   {
2250                     srelgot = bfd_make_section (dynobj, ".rel.got");
2251                     if (srelgot == NULL
2252                         || ! bfd_set_section_flags (dynobj, srelgot,
2253                                                     (SEC_ALLOC
2254                                                      | SEC_LOAD
2255                                                      | SEC_HAS_CONTENTS
2256                                                      | SEC_IN_MEMORY
2257                                                      | SEC_LINKER_CREATED
2258                                                      | SEC_READONLY))
2259                         || ! bfd_set_section_alignment (dynobj, srelgot, 2))
2260                       return false;
2261                   }
2262               }
2263
2264             if (h != NULL)
2265               {
2266                 if (h->got.offset != (bfd_vma) -1)
2267                   /* We have already allocated space in the .got.  */
2268                   break;
2269
2270                 h->got.offset = sgot->_raw_size;
2271
2272                 /* Make sure this symbol is output as a dynamic symbol.  */
2273                 if (h->dynindx == -1)
2274                   if (! bfd_elf32_link_record_dynamic_symbol (info, h))
2275                     return false;
2276
2277                 srelgot->_raw_size += sizeof (Elf32_External_Rel);
2278               }
2279             else
2280               {
2281                 /* This is a global offset table entry for a local
2282                    symbol.  */
2283                 if (local_got_offsets == NULL)
2284                   {
2285                     size_t size;
2286                     register unsigned int i;
2287
2288                     size = symtab_hdr->sh_info * sizeof (bfd_vma);
2289                     local_got_offsets = (bfd_vma *) bfd_alloc (abfd, size);
2290                     if (local_got_offsets == NULL)
2291                       return false;
2292                     elf_local_got_offsets (abfd) = local_got_offsets;
2293                     for (i = 0; i < symtab_hdr->sh_info; i++)
2294                       local_got_offsets[i] = (bfd_vma) -1;
2295                   }
2296
2297                 if (local_got_offsets[r_symndx] != (bfd_vma) -1)
2298                   /* We have already allocated space in the .got.  */
2299                   break;
2300
2301                 local_got_offsets[r_symndx] = sgot->_raw_size;
2302
2303                 if (info->shared)
2304                   /* If we are generating a shared object, we need to
2305                      output a R_ARM_RELATIVE reloc so that the dynamic
2306                      linker can adjust this GOT entry.  */
2307                   srelgot->_raw_size += sizeof (Elf32_External_Rel);
2308               }
2309
2310             sgot->_raw_size += 4;
2311             break;
2312
2313           case R_ARM_PLT32:
2314             /* This symbol requires a procedure linkage table entry.  We
2315                actually build the entry in adjust_dynamic_symbol,
2316                because this might be a case of linking PIC code which is
2317                never referenced by a dynamic object, in which case we
2318                don't need to generate a procedure linkage table entry
2319                after all.  */
2320
2321             /* If this is a local symbol, we resolve it directly without
2322                creating a procedure linkage table entry.  */
2323             if (h == NULL)
2324               continue;
2325
2326             h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_PLT;
2327             break;
2328
2329           case R_ARM_ABS32:
2330           case R_ARM_REL32:
2331           case R_ARM_PC24:
2332             /* If we are creating a shared library, and this is a reloc
2333                against a global symbol, or a non PC relative reloc
2334                against a local symbol, then we need to copy the reloc
2335                into the shared library.  However, if we are linking with
2336                -Bsymbolic, we do not need to copy a reloc against a
2337                global symbol which is defined in an object we are
2338                including in the link (i.e., DEF_REGULAR is set).  At
2339                this point we have not seen all the input files, so it is
2340                possible that DEF_REGULAR is not set now but will be set
2341                later (it is never cleared).  We account for that
2342                possibility below by storing information in the
2343                pcrel_relocs_copied field of the hash table entry.  */
2344             if (info->shared
2345               && (ELF32_R_TYPE (rel->r_info) != R_ARM_PC24
2346                 || (h != NULL
2347                   && (! info->symbolic
2348                     || (h->elf_link_hash_flags
2349                       & ELF_LINK_HASH_DEF_REGULAR) == 0))))
2350               {
2351                 /* When creating a shared object, we must copy these
2352                    reloc types into the output file.  We create a reloc
2353                    section in dynobj and make room for this reloc.  */
2354                 if (sreloc == NULL)
2355                   {
2356                     const char * name;
2357
2358                     name = (bfd_elf_string_from_elf_section
2359                             (abfd,
2360                              elf_elfheader (abfd)->e_shstrndx,
2361                              elf_section_data (sec)->rel_hdr.sh_name));
2362                     if (name == NULL)
2363                       return false;
2364
2365                     BFD_ASSERT (strncmp (name, ".rel", 4) == 0
2366                                 && strcmp (bfd_get_section_name (abfd, sec),
2367                                            name + 4) == 0);
2368
2369                     sreloc = bfd_get_section_by_name (dynobj, name);
2370                     if (sreloc == NULL)
2371                       {
2372                         flagword flags;
2373
2374                         sreloc = bfd_make_section (dynobj, name);
2375                         flags = (SEC_HAS_CONTENTS | SEC_READONLY
2376                                  | SEC_IN_MEMORY | SEC_LINKER_CREATED);
2377                         if ((sec->flags & SEC_ALLOC) != 0)
2378                           flags |= SEC_ALLOC | SEC_LOAD;
2379                         if (sreloc == NULL
2380                             || ! bfd_set_section_flags (dynobj, sreloc, flags)
2381                             || ! bfd_set_section_alignment (dynobj, sreloc, 2))
2382                           return false;
2383                       }
2384                   }
2385
2386                 sreloc->_raw_size += sizeof (Elf32_External_Rel);
2387                 /* If we are linking with -Bsymbolic, and this is a
2388                    global symbol, we count the number of PC relative
2389                    relocations we have entered for this symbol, so that
2390                    we can discard them again if the symbol is later
2391                    defined by a regular object.  Note that this function
2392                    is only called if we are using an elf_i386 linker
2393                    hash table, which means that h is really a pointer to
2394                    an elf_i386_link_hash_entry.  */
2395                 if (h != NULL && info->symbolic
2396                     && ELF32_R_TYPE (rel->r_info) == R_ARM_PC24)
2397                   {
2398                     struct elf32_arm_link_hash_entry * eh;
2399                     struct elf32_arm_pcrel_relocs_copied * p;
2400
2401                     eh = (struct elf32_arm_link_hash_entry *) h;
2402
2403                     for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next)
2404                       if (p->section == sreloc)
2405                         break;
2406
2407                     if (p == NULL)
2408                       {
2409                         p = ((struct elf32_arm_pcrel_relocs_copied *)
2410                              bfd_alloc (dynobj, sizeof * p));
2411
2412                         if (p == NULL)
2413                           return false;
2414                         p->next = eh->pcrel_relocs_copied;
2415                         eh->pcrel_relocs_copied = p;
2416                         p->section = sreloc;
2417                         p->count = 0;
2418                       }
2419
2420                     ++p->count;
2421                   }
2422               }
2423             break;
2424
2425         /* This relocation describes the C++ object vtable hierarchy.
2426            Reconstruct it for later use during GC.  */
2427         case R_ARM_GNU_VTINHERIT:
2428           if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2429             return false;
2430           break;
2431
2432         /* This relocation describes which C++ vtable entries are actually
2433            used.  Record for later use during GC.  */
2434         case R_ARM_GNU_VTENTRY:
2435           if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_offset))
2436             return false;
2437           break;
2438         }
2439     }
2440
2441   return true;
2442 }
2443
2444
2445 /* Find the nearest line to a particular section and offset, for error
2446    reporting.   This code is a duplicate of the code in elf.c, except
2447    that it also accepts STT_ARM_TFUNC as a symbol that names a function. */
2448
2449 static boolean
2450 elf32_arm_find_nearest_line
2451   (abfd, section, symbols, offset, filename_ptr, functionname_ptr, line_ptr)
2452      bfd *          abfd;
2453      asection *     section;
2454      asymbol **     symbols;
2455      bfd_vma        offset;
2456      CONST char **  filename_ptr;
2457      CONST char **  functionname_ptr;
2458      unsigned int * line_ptr;
2459 {
2460   boolean      found;
2461   const char * filename;
2462   asymbol *    func;
2463   bfd_vma      low_func;
2464   asymbol **   p;
2465
2466   if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
2467                                      filename_ptr, functionname_ptr,
2468                                      line_ptr, 0))
2469     return true;
2470
2471   if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
2472                                              &found, filename_ptr,
2473                                              functionname_ptr, line_ptr,
2474                                              &elf_tdata (abfd)->line_info))
2475     return false;
2476
2477   if (found)
2478     return true;
2479
2480   if (symbols == NULL)
2481     return false;
2482
2483   filename = NULL;
2484   func = NULL;
2485   low_func = 0;
2486
2487   for (p = symbols; *p != NULL; p++)
2488     {
2489       elf_symbol_type *q;
2490
2491       q = (elf_symbol_type *) *p;
2492
2493       if (bfd_get_section (&q->symbol) != section)
2494         continue;
2495
2496       switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
2497         {
2498         default:
2499           break;
2500         case STT_FILE:
2501           filename = bfd_asymbol_name (&q->symbol);
2502           break;
2503         case STT_NOTYPE:
2504         case STT_FUNC:
2505         case STT_ARM_TFUNC:
2506           if (q->symbol.section == section
2507               && q->symbol.value >= low_func
2508               && q->symbol.value <= offset)
2509             {
2510               func = (asymbol *) q;
2511               low_func = q->symbol.value;
2512             }
2513           break;
2514         }
2515     }
2516
2517   if (func == NULL)
2518     return false;
2519
2520   *filename_ptr = filename;
2521   *functionname_ptr = bfd_asymbol_name (func);
2522   *line_ptr = 0;
2523
2524   return true;
2525 }
2526
2527 /* Adjust a symbol defined by a dynamic object and referenced by a
2528    regular object.  The current definition is in some section of the
2529    dynamic object, but we're not including those sections.  We have to
2530    change the definition to something the rest of the link can
2531    understand.  */
2532
2533 static boolean
2534 elf32_arm_adjust_dynamic_symbol (info, h)
2535      struct bfd_link_info * info;
2536      struct elf_link_hash_entry * h;
2537 {
2538   bfd * dynobj;
2539   asection * s;
2540   unsigned int power_of_two;
2541
2542   dynobj = elf_hash_table (info)->dynobj;
2543
2544   /* Make sure we know what is going on here.  */
2545   BFD_ASSERT (dynobj != NULL
2546               && ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT)
2547                   || h->weakdef != NULL
2548                   || ((h->elf_link_hash_flags
2549                        & ELF_LINK_HASH_DEF_DYNAMIC) != 0
2550                       && (h->elf_link_hash_flags
2551                           & ELF_LINK_HASH_REF_REGULAR) != 0
2552                       && (h->elf_link_hash_flags
2553                           & ELF_LINK_HASH_DEF_REGULAR) == 0)));
2554
2555   /* If this is a function, put it in the procedure linkage table.  We
2556      will fill in the contents of the procedure linkage table later,
2557      when we know the address of the .got section.  */
2558   if (h->type == STT_FUNC
2559       || (h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0)
2560     {
2561       if (! info->shared
2562           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_DYNAMIC) == 0
2563           && (h->elf_link_hash_flags & ELF_LINK_HASH_REF_DYNAMIC) == 0)
2564         {
2565           /* This case can occur if we saw a PLT32 reloc in an input
2566              file, but the symbol was never referred to by a dynamic
2567              object.  In such a case, we don't actually need to build
2568              a procedure linkage table, and we can just do a PC32
2569              reloc instead.  */
2570           BFD_ASSERT ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_PLT) != 0);
2571           return true;
2572         }
2573
2574       /* Make sure this symbol is output as a dynamic symbol.  */
2575       if (h->dynindx == -1)
2576         {
2577           if (! bfd_elf32_link_record_dynamic_symbol (info, h))
2578             return false;
2579         }
2580
2581       s = bfd_get_section_by_name (dynobj, ".plt");
2582       BFD_ASSERT (s != NULL);
2583
2584       /* If this is the first .plt entry, make room for the special
2585          first entry.  */
2586       if (s->_raw_size == 0)
2587         s->_raw_size += PLT_ENTRY_SIZE;
2588
2589       /* If this symbol is not defined in a regular file, and we are
2590          not generating a shared library, then set the symbol to this
2591          location in the .plt.  This is required to make function
2592          pointers compare as equal between the normal executable and
2593          the shared library.  */
2594       if (! info->shared
2595           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2596         {
2597           h->root.u.def.section = s;
2598           h->root.u.def.value = s->_raw_size;
2599         }
2600
2601       h->plt.offset = s->_raw_size;
2602
2603       /* Make room for this entry.  */
2604       s->_raw_size += PLT_ENTRY_SIZE;
2605
2606       /* We also need to make an entry in the .got.plt section, which
2607          will be placed in the .got section by the linker script.  */
2608
2609       s = bfd_get_section_by_name (dynobj, ".got.plt");
2610       BFD_ASSERT (s != NULL);
2611       s->_raw_size += 4;
2612
2613       /* We also need to make an entry in the .rel.plt section.  */
2614
2615       s = bfd_get_section_by_name (dynobj, ".rel.plt");
2616       BFD_ASSERT (s != NULL);
2617       s->_raw_size += sizeof (Elf32_External_Rel);
2618
2619       return true;
2620     }
2621
2622   /* If this is a weak symbol, and there is a real definition, the
2623      processor independent code will have arranged for us to see the
2624      real definition first, and we can just use the same value.  */
2625   if (h->weakdef != NULL)
2626     {
2627       BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
2628                   || h->weakdef->root.type == bfd_link_hash_defweak);
2629       h->root.u.def.section = h->weakdef->root.u.def.section;
2630       h->root.u.def.value = h->weakdef->root.u.def.value;
2631       return true;
2632     }
2633
2634   /* This is a reference to a symbol defined by a dynamic object which
2635      is not a function.  */
2636
2637   /* If we are creating a shared library, we must presume that the
2638      only references to the symbol are via the global offset table.
2639      For such cases we need not do anything here; the relocations will
2640      be handled correctly by relocate_section.  */
2641   if (info->shared)
2642     return true;
2643
2644   /* We must allocate the symbol in our .dynbss section, which will
2645      become part of the .bss section of the executable.  There will be
2646      an entry for this symbol in the .dynsym section.  The dynamic
2647      object will contain position independent code, so all references
2648      from the dynamic object to this symbol will go through the global
2649      offset table.  The dynamic linker will use the .dynsym entry to
2650      determine the address it must put in the global offset table, so
2651      both the dynamic object and the regular object will refer to the
2652      same memory location for the variable.  */
2653
2654   s = bfd_get_section_by_name (dynobj, ".dynbss");
2655   BFD_ASSERT (s != NULL);
2656
2657   /* We must generate a R_ARM_COPY reloc to tell the dynamic linker to
2658      copy the initial value out of the dynamic object and into the
2659      runtime process image.  We need to remember the offset into the
2660      .rel.bss section we are going to use.  */
2661   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
2662     {
2663       asection *srel;
2664
2665       srel = bfd_get_section_by_name (dynobj, ".rel.bss");
2666       BFD_ASSERT (srel != NULL);
2667       srel->_raw_size += sizeof (Elf32_External_Rel);
2668       h->elf_link_hash_flags |= ELF_LINK_HASH_NEEDS_COPY;
2669     }
2670
2671   /* We need to figure out the alignment required for this symbol.  I
2672      have no idea how ELF linkers handle this.  */
2673   power_of_two = bfd_log2 (h->size);
2674   if (power_of_two > 3)
2675     power_of_two = 3;
2676
2677   /* Apply the required alignment.  */
2678   s->_raw_size = BFD_ALIGN (s->_raw_size,
2679                             (bfd_size_type) (1 << power_of_two));
2680   if (power_of_two > bfd_get_section_alignment (dynobj, s))
2681     {
2682       if (! bfd_set_section_alignment (dynobj, s, power_of_two))
2683         return false;
2684     }
2685
2686   /* Define the symbol as being at this point in the section.  */
2687   h->root.u.def.section = s;
2688   h->root.u.def.value = s->_raw_size;
2689
2690   /* Increment the section size to make room for the symbol.  */
2691   s->_raw_size += h->size;
2692
2693   return true;
2694 }
2695
2696 /* Set the sizes of the dynamic sections.  */
2697
2698 static boolean
2699 elf32_arm_size_dynamic_sections (output_bfd, info)
2700      bfd * output_bfd;
2701      struct bfd_link_info * info;
2702 {
2703   bfd * dynobj;
2704   asection * s;
2705   boolean plt;
2706   boolean relocs;
2707   boolean reltext;
2708
2709   dynobj = elf_hash_table (info)->dynobj;
2710   BFD_ASSERT (dynobj != NULL);
2711
2712   if (elf_hash_table (info)->dynamic_sections_created)
2713     {
2714       /* Set the contents of the .interp section to the interpreter.  */
2715       if (! info->shared)
2716         {
2717           s = bfd_get_section_by_name (dynobj, ".interp");
2718           BFD_ASSERT (s != NULL);
2719           s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
2720           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2721         }
2722     }
2723   else
2724     {
2725       /* We may have created entries in the .rel.got section.
2726          However, if we are not creating the dynamic sections, we will
2727          not actually use these entries.  Reset the size of .rel.got,
2728          which will cause it to get stripped from the output file
2729          below.  */
2730       s = bfd_get_section_by_name (dynobj, ".rel.got");
2731       if (s != NULL)
2732         s->_raw_size = 0;
2733     }
2734
2735   /* If this is a -Bsymbolic shared link, then we need to discard all
2736      PC relative relocs against symbols defined in a regular object.
2737      We allocated space for them in the check_relocs routine, but we
2738      will not fill them in in the relocate_section routine.  */
2739   if (info->shared && info->symbolic)
2740     elf32_arm_link_hash_traverse (elf32_arm_hash_table (info),
2741                                   elf32_arm_discard_copies,
2742                                   (PTR) NULL);
2743
2744   /* The check_relocs and adjust_dynamic_symbol entry points have
2745      determined the sizes of the various dynamic sections.  Allocate
2746      memory for them.  */
2747   plt = false;
2748   relocs = false;
2749   reltext = false;
2750   for (s = dynobj->sections; s != NULL; s = s->next)
2751     {
2752       const char * name;
2753       boolean strip;
2754
2755       if ((s->flags & SEC_LINKER_CREATED) == 0)
2756         continue;
2757
2758       /* It's OK to base decisions on the section name, because none
2759          of the dynobj section names depend upon the input files.  */
2760       name = bfd_get_section_name (dynobj, s);
2761
2762       strip = false;
2763
2764       if (strcmp (name, ".plt") == 0)
2765         {
2766           if (s->_raw_size == 0)
2767             {
2768               /* Strip this section if we don't need it; see the
2769                  comment below.  */
2770               strip = true;
2771             }
2772           else
2773             {
2774               /* Remember whether there is a PLT.  */
2775               plt = true;
2776             }
2777         }
2778       else if (strncmp (name, ".rel", 4) == 0)
2779         {
2780           if (s->_raw_size == 0)
2781             {
2782               /* If we don't need this section, strip it from the
2783                  output file.  This is mostly to handle .rel.bss and
2784                  .rel.plt.  We must create both sections in
2785                  create_dynamic_sections, because they must be created
2786                  before the linker maps input sections to output
2787                  sections.  The linker does that before
2788                  adjust_dynamic_symbol is called, and it is that
2789                  function which decides whether anything needs to go
2790                  into these sections.  */
2791               strip = true;
2792             }
2793           else
2794             {
2795               asection * target;
2796
2797               /* Remember whether there are any reloc sections other
2798                  than .rel.plt.  */
2799               if (strcmp (name, ".rel.plt") != 0)
2800                 {
2801                   const char *outname;
2802
2803                   relocs = true;
2804
2805                   /* If this relocation section applies to a read only
2806                      section, then we probably need a DT_TEXTREL
2807                      entry.  The entries in the .rel.plt section
2808                      really apply to the .got section, which we
2809                      created ourselves and so know is not readonly.  */
2810                   outname = bfd_get_section_name (output_bfd,
2811                                                   s->output_section);
2812                   target = bfd_get_section_by_name (output_bfd, outname + 4);
2813
2814                   if (target != NULL
2815                       && (target->flags & SEC_READONLY) != 0
2816                       && (target->flags & SEC_ALLOC) != 0)
2817                     reltext = true;
2818                 }
2819
2820               /* We use the reloc_count field as a counter if we need
2821                  to copy relocs into the output file.  */
2822               s->reloc_count = 0;
2823             }
2824         }
2825       else if (strncmp (name, ".got", 4) != 0)
2826         {
2827           /* It's not one of our sections, so don't allocate space.  */
2828           continue;
2829         }
2830
2831       if (strip)
2832         {
2833           asection ** spp;
2834
2835           for (spp = &s->output_section->owner->sections;
2836                *spp != s->output_section;
2837                spp = &(*spp)->next)
2838             ;
2839           *spp = s->output_section->next;
2840           --s->output_section->owner->section_count;
2841
2842           continue;
2843         }
2844
2845       /* Allocate memory for the section contents.  */
2846       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->_raw_size);
2847       if (s->contents == NULL && s->_raw_size != 0)
2848         return false;
2849     }
2850
2851   if (elf_hash_table (info)->dynamic_sections_created)
2852     {
2853       /* Add some entries to the .dynamic section.  We fill in the
2854          values later, in elf32_arm_finish_dynamic_sections, but we
2855          must add the entries now so that we get the correct size for
2856          the .dynamic section.  The DT_DEBUG entry is filled in by the
2857          dynamic linker and used by the debugger.  */
2858       if (! info->shared)
2859         {
2860           if (! bfd_elf32_add_dynamic_entry (info, DT_DEBUG, 0))
2861             return false;
2862         }
2863
2864       if (plt)
2865         {
2866           if (! bfd_elf32_add_dynamic_entry (info, DT_PLTGOT, 0)
2867               || ! bfd_elf32_add_dynamic_entry (info, DT_PLTRELSZ, 0)
2868               || ! bfd_elf32_add_dynamic_entry (info, DT_PLTREL, DT_REL)
2869               || ! bfd_elf32_add_dynamic_entry (info, DT_JMPREL, 0))
2870             return false;
2871         }
2872
2873       if (relocs)
2874         {
2875           if (! bfd_elf32_add_dynamic_entry (info, DT_REL, 0)
2876               || ! bfd_elf32_add_dynamic_entry (info, DT_RELSZ, 0)
2877               || ! bfd_elf32_add_dynamic_entry (info, DT_RELENT,
2878                                                 sizeof (Elf32_External_Rel)))
2879             return false;
2880         }
2881
2882       if (reltext)
2883         {
2884           if (! bfd_elf32_add_dynamic_entry (info, DT_TEXTREL, 0))
2885             return false;
2886         }
2887     }
2888
2889   return true;
2890 }
2891
2892 /* This function is called via elf32_arm_link_hash_traverse if we are
2893    creating a shared object with -Bsymbolic.  It discards the space
2894    allocated to copy PC relative relocs against symbols which are
2895    defined in regular objects.  We allocated space for them in the
2896    check_relocs routine, but we won't fill them in in the
2897    relocate_section routine.  */
2898
2899 static boolean
2900 elf32_arm_discard_copies (h, ignore)
2901      struct elf32_arm_link_hash_entry * h;
2902      PTR ignore ATTRIBUTE_UNUSED;
2903 {
2904   struct elf32_arm_pcrel_relocs_copied * s;
2905
2906   /* We only discard relocs for symbols defined in a regular object.  */
2907   if ((h->root.elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2908     return true;
2909
2910   for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
2911     s->section->_raw_size -= s->count * sizeof (Elf32_External_Rel);
2912
2913   return true;
2914 }
2915
2916 /* Finish up dynamic symbol handling.  We set the contents of various
2917    dynamic sections here.  */
2918
2919 static boolean
2920 elf32_arm_finish_dynamic_symbol (output_bfd, info, h, sym)
2921      bfd * output_bfd;
2922      struct bfd_link_info * info;
2923      struct elf_link_hash_entry * h;
2924      Elf_Internal_Sym * sym;
2925 {
2926   bfd * dynobj;
2927
2928   dynobj = elf_hash_table (info)->dynobj;
2929
2930   if (h->plt.offset != (bfd_vma) -1)
2931     {
2932       asection * splt;
2933       asection * sgot;
2934       asection * srel;
2935       bfd_vma plt_index;
2936       bfd_vma got_offset;
2937       Elf_Internal_Rel rel;
2938
2939       /* This symbol has an entry in the procedure linkage table.  Set
2940          it up.  */
2941
2942       BFD_ASSERT (h->dynindx != -1);
2943
2944       splt = bfd_get_section_by_name (dynobj, ".plt");
2945       sgot = bfd_get_section_by_name (dynobj, ".got.plt");
2946       srel = bfd_get_section_by_name (dynobj, ".rel.plt");
2947       BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
2948
2949       /* Get the index in the procedure linkage table which
2950          corresponds to this symbol.  This is the index of this symbol
2951          in all the symbols for which we are making plt entries.  The
2952          first entry in the procedure linkage table is reserved.  */
2953       plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
2954
2955       /* Get the offset into the .got table of the entry that
2956          corresponds to this function.  Each .got entry is 4 bytes.
2957          The first three are reserved.  */
2958       got_offset = (plt_index + 3) * 4;
2959
2960       /* Fill in the entry in the procedure linkage table.  */
2961       memcpy (splt->contents + h->plt.offset,
2962               elf32_arm_plt_entry,
2963               PLT_ENTRY_SIZE);
2964       bfd_put_32 (output_bfd,
2965                       (sgot->output_section->vma
2966                        + sgot->output_offset
2967                        + got_offset
2968                        - splt->output_section->vma
2969                        - splt->output_offset
2970                        - h->plt.offset - 12),
2971                       splt->contents + h->plt.offset + 12);
2972
2973       /* Fill in the entry in the global offset table.  */
2974       bfd_put_32 (output_bfd,
2975                   (splt->output_section->vma
2976                    + splt->output_offset),
2977                   sgot->contents + got_offset);
2978
2979       /* Fill in the entry in the .rel.plt section.  */
2980       rel.r_offset = (sgot->output_section->vma
2981                       + sgot->output_offset
2982                       + got_offset);
2983       rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_JUMP_SLOT);
2984       bfd_elf32_swap_reloc_out (output_bfd, &rel,
2985                                 ((Elf32_External_Rel *) srel->contents
2986                                  + plt_index));
2987
2988       if ((h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR) == 0)
2989         {
2990           /* Mark the symbol as undefined, rather than as defined in
2991              the .plt section.  Leave the value alone.  */
2992           sym->st_shndx = SHN_UNDEF;
2993         }
2994     }
2995
2996   if (h->got.offset != (bfd_vma) -1)
2997     {
2998       asection * sgot;
2999       asection * srel;
3000       Elf_Internal_Rel rel;
3001
3002       /* This symbol has an entry in the global offset table.  Set it
3003          up.  */
3004
3005       sgot = bfd_get_section_by_name (dynobj, ".got");
3006       srel = bfd_get_section_by_name (dynobj, ".rel.got");
3007       BFD_ASSERT (sgot != NULL && srel != NULL);
3008
3009       rel.r_offset = (sgot->output_section->vma
3010                       + sgot->output_offset
3011                       + (h->got.offset &~ 1));
3012
3013       /* If this is a -Bsymbolic link, and the symbol is defined
3014          locally, we just want to emit a RELATIVE reloc.  The entry in
3015          the global offset table will already have been initialized in
3016          the relocate_section function.  */
3017       if (info->shared
3018           && (info->symbolic || h->dynindx == -1)
3019           && (h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
3020         rel.r_info = ELF32_R_INFO (0, R_ARM_RELATIVE);
3021       else
3022         {
3023           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
3024           rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_GLOB_DAT);
3025         }
3026
3027       bfd_elf32_swap_reloc_out (output_bfd, &rel,
3028                                 ((Elf32_External_Rel *) srel->contents
3029                                  + srel->reloc_count));
3030       ++srel->reloc_count;
3031     }
3032
3033   if ((h->elf_link_hash_flags & ELF_LINK_HASH_NEEDS_COPY) != 0)
3034     {
3035       asection * s;
3036       Elf_Internal_Rel rel;
3037
3038       /* This symbol needs a copy reloc.  Set it up.  */
3039
3040       BFD_ASSERT (h->dynindx != -1
3041                   && (h->root.type == bfd_link_hash_defined
3042                       || h->root.type == bfd_link_hash_defweak));
3043
3044       s = bfd_get_section_by_name (h->root.u.def.section->owner,
3045                                    ".rel.bss");
3046       BFD_ASSERT (s != NULL);
3047
3048       rel.r_offset = (h->root.u.def.value
3049                       + h->root.u.def.section->output_section->vma
3050                       + h->root.u.def.section->output_offset);
3051       rel.r_info = ELF32_R_INFO (h->dynindx, R_ARM_COPY);
3052       bfd_elf32_swap_reloc_out (output_bfd, &rel,
3053                                 ((Elf32_External_Rel *) s->contents
3054                                  + s->reloc_count));
3055       ++s->reloc_count;
3056     }
3057
3058   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
3059   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3060       || strcmp (h->root.root.string, "_GLOBAL_OFFSET_TABLE_") == 0)
3061     sym->st_shndx = SHN_ABS;
3062
3063   return true;
3064 }
3065
3066 /* Finish up the dynamic sections.  */
3067
3068 static boolean
3069 elf32_arm_finish_dynamic_sections (output_bfd, info)
3070      bfd * output_bfd;
3071      struct bfd_link_info * info;
3072 {
3073   bfd * dynobj;
3074   asection * sgot;
3075   asection * sdyn;
3076
3077   dynobj = elf_hash_table (info)->dynobj;
3078
3079   sgot = bfd_get_section_by_name (dynobj, ".got.plt");
3080   BFD_ASSERT (sgot != NULL);
3081   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3082
3083   if (elf_hash_table (info)->dynamic_sections_created)
3084     {
3085       asection *splt;
3086       Elf32_External_Dyn *dyncon, *dynconend;
3087
3088       splt = bfd_get_section_by_name (dynobj, ".plt");
3089       BFD_ASSERT (splt != NULL && sdyn != NULL);
3090
3091       dyncon = (Elf32_External_Dyn *) sdyn->contents;
3092       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
3093       for (; dyncon < dynconend; dyncon++)
3094         {
3095           Elf_Internal_Dyn dyn;
3096           const char * name;
3097           asection * s;
3098
3099           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3100
3101           switch (dyn.d_tag)
3102             {
3103             default:
3104               break;
3105
3106             case DT_PLTGOT:
3107               name = ".got";
3108               goto get_vma;
3109             case DT_JMPREL:
3110               name = ".rel.plt";
3111             get_vma:
3112               s = bfd_get_section_by_name (output_bfd, name);
3113               BFD_ASSERT (s != NULL);
3114               dyn.d_un.d_ptr = s->vma;
3115               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3116               break;
3117
3118             case DT_PLTRELSZ:
3119               s = bfd_get_section_by_name (output_bfd, ".rel.plt");
3120               BFD_ASSERT (s != NULL);
3121               if (s->_cooked_size != 0)
3122                 dyn.d_un.d_val = s->_cooked_size;
3123               else
3124                 dyn.d_un.d_val = s->_raw_size;
3125               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3126               break;
3127
3128             case DT_RELSZ:
3129               /* My reading of the SVR4 ABI indicates that the
3130                  procedure linkage table relocs (DT_JMPREL) should be
3131                  included in the overall relocs (DT_REL).  This is
3132                  what Solaris does.  However, UnixWare can not handle
3133                  that case.  Therefore, we override the DT_RELSZ entry
3134                  here to make it not include the JMPREL relocs.  Since
3135                  the linker script arranges for .rel.plt to follow all
3136                  other relocation sections, we don't have to worry
3137                  about changing the DT_REL entry.  */
3138               s = bfd_get_section_by_name (output_bfd, ".rel.plt");
3139               if (s != NULL)
3140                 {
3141                   if (s->_cooked_size != 0)
3142                     dyn.d_un.d_val -= s->_cooked_size;
3143                   else
3144                     dyn.d_un.d_val -= s->_raw_size;
3145                 }
3146               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3147               break;
3148             }
3149         }
3150
3151       /* Fill in the first entry in the procedure linkage table.  */
3152       if (splt->_raw_size > 0)
3153         memcpy (splt->contents, elf32_arm_plt0_entry, PLT_ENTRY_SIZE);
3154
3155       /* UnixWare sets the entsize of .plt to 4, although that doesn't
3156          really seem like the right value.  */
3157       elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
3158     }
3159
3160   /* Fill in the first three entries in the global offset table.  */
3161   if (sgot->_raw_size > 0)
3162     {
3163       if (sdyn == NULL)
3164         bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
3165       else
3166         bfd_put_32 (output_bfd,
3167                     sdyn->output_section->vma + sdyn->output_offset,
3168                     sgot->contents);
3169       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
3170       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
3171     }
3172
3173   elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
3174
3175   return true;
3176 }
3177
3178 static void
3179 elf32_arm_post_process_headers (abfd, link_info)
3180      bfd * abfd;
3181      struct bfd_link_info * link_info ATTRIBUTE_UNUSED;
3182 {
3183   Elf_Internal_Ehdr * i_ehdrp;  /* Elf file header, internal form */
3184
3185   i_ehdrp = elf_elfheader (abfd);
3186
3187   i_ehdrp->e_ident[EI_OSABI]      = ARM_ELF_OS_ABI_VERSION;
3188   i_ehdrp->e_ident[EI_ABIVERSION] = ARM_ELF_ABI_VERSION;
3189 }
3190
3191
3192 #define ELF_ARCH                        bfd_arch_arm
3193 #define ELF_MACHINE_CODE                EM_ARM
3194 #define ELF_MAXPAGESIZE                 0x8000
3195
3196
3197 #define bfd_elf32_bfd_copy_private_bfd_data     elf32_arm_copy_private_bfd_data
3198 #define bfd_elf32_bfd_merge_private_bfd_data    elf32_arm_merge_private_bfd_data
3199 #define bfd_elf32_bfd_set_private_flags         elf32_arm_set_private_flags
3200 #define bfd_elf32_bfd_print_private_bfd_data    elf32_arm_print_private_bfd_data
3201 #define bfd_elf32_bfd_link_hash_table_create    elf32_arm_link_hash_table_create
3202 #define bfd_elf32_bfd_reloc_type_lookup         elf32_arm_reloc_type_lookup
3203 #define bfd_elf32_find_nearest_line             elf32_arm_find_nearest_line
3204
3205 #define elf_backend_get_symbol_type             elf32_arm_get_symbol_type
3206 #define elf_backend_gc_mark_hook                elf32_arm_gc_mark_hook
3207 #define elf_backend_gc_sweep_hook               elf32_arm_gc_sweep_hook
3208 #define elf_backend_check_relocs                elf32_arm_check_relocs
3209 #define elf_backend_relocate_section            elf32_arm_relocate_section
3210 #define elf_backend_adjust_dynamic_symbol       elf32_arm_adjust_dynamic_symbol
3211 #define elf_backend_create_dynamic_sections     _bfd_elf_create_dynamic_sections
3212 #define elf_backend_finish_dynamic_symbol       elf32_arm_finish_dynamic_symbol
3213 #define elf_backend_finish_dynamic_sections     elf32_arm_finish_dynamic_sections
3214 #define elf_backend_size_dynamic_sections       elf32_arm_size_dynamic_sections
3215 #define elf_backend_post_process_headers        elf32_arm_post_process_headers
3216
3217 #define elf_backend_can_gc_sections 1
3218 #define elf_backend_plt_readonly    1
3219 #define elf_backend_want_got_plt    1
3220 #define elf_backend_want_plt_sym    0
3221
3222 #define elf_backend_got_header_size     12
3223 #define elf_backend_plt_header_size     PLT_ENTRY_SIZE
3224
3225 #include "elf32-target.h"