bfd/elf32-arm.h

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