bfd/coff-arm.c

   1 /* BFD back-end for ARM COFF files.
   2    Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
   3    2000, 2001
   4    Free Software Foundation, Inc.
   5    Written by Cygnus Support.
   6
   7 This file is part of BFD, the Binary File Descriptor library.
   8
   9 This program is free software; you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation; either version 2 of the License, or
  12 (at your option) any later version.
  13
  14 This program is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with this program; if not, write to the Free Software
  21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  22
  23 #include "bfd.h"
  24 #include "sysdep.h"
  25 #include "libbfd.h"
  26
  27 #include "coff/arm.h"
  28
  29 #include "coff/internal.h"
  30
  31 #ifdef COFF_WITH_PE
  32 #include "coff/pe.h"
  33 #endif
  34
  35 #include "libcoff.h"
  36
  37 /* Macros for manipulation the bits in the flags field of the coff data
  38    structure.  */
  39 #define APCS_26_FLAG(       abfd )      (coff_data (abfd)->flags & F_APCS_26)
  40 #define APCS_FLOAT_FLAG(    abfd )      (coff_data (abfd)->flags & F_APCS_FLOAT)
  41 #define PIC_FLAG(           abfd )      (coff_data (abfd)->flags & F_PIC)
  42 #define APCS_SET(           abfd )      (coff_data (abfd)->flags & F_APCS_SET)
  43 #define SET_APCS_FLAGS(     abfd, flgs) (coff_data (abfd)->flags = \
  44                                         (coff_data (abfd)->flags & ~ (F_APCS_26 | F_APCS_FLOAT | F_PIC)) \
  45                                          | (flgs | F_APCS_SET))
  46 #define INTERWORK_FLAG(     abfd )      (coff_data (abfd)->flags & F_INTERWORK)
  47 #define INTERWORK_SET(      abfd )      (coff_data (abfd)->flags & F_INTERWORK_SET)
  48 #define SET_INTERWORK_FLAG( abfd, flg ) (coff_data (abfd)->flags = \
  49                                         (coff_data (abfd)->flags & ~ F_INTERWORK) \
  50                                          | (flg | F_INTERWORK_SET))
  51
  52 #ifndef NUM_ELEM
  53 #define NUM_ELEM(a) ((sizeof (a)) / sizeof ((a)[0]))
  54 #endif
  55
  56 typedef enum {bunknown, b9, b12, b23} thumb_pcrel_branchtype;
  57 /* some typedefs for holding instructions */
  58 typedef unsigned long int insn32;
  59 typedef unsigned short int insn16;
  60
  61      /* Forward declarations for stupid compilers.  */
  62 static boolean coff_arm_relocate_section
  63   PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
  64            struct internal_reloc *, struct internal_syment *, asection **));
  65 static bfd_reloc_status_type aoutarm_fix_pcrel_26_done
  66   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  67 static bfd_reloc_status_type aoutarm_fix_pcrel_26
  68   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  69 static bfd_reloc_status_type coff_thumb_pcrel_23
  70   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  71 static bfd_reloc_status_type coff_thumb_pcrel_12
  72   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  73 static bfd_reloc_status_type coff_thumb_pcrel_9
  74   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  75 static bfd_reloc_status_type coff_arm_reloc
  76   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  77 static boolean coff_arm_adjust_symndx
  78   PARAMS ((bfd *, struct bfd_link_info *, bfd *,
  79            asection *, struct internal_reloc *, boolean *));
  80 static reloc_howto_type * coff_arm_rtype_to_howto
  81   PARAMS ((bfd *, asection *, struct internal_reloc *,
  82            struct coff_link_hash_entry *, struct internal_syment *, bfd_vma *));
  83 static bfd_reloc_status_type coff_thumb_pcrel_common
  84   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **,
  85            thumb_pcrel_branchtype));
  86 static CONST struct reloc_howto_struct * coff_arm_reloc_type_lookup
  87   PARAMS ((bfd *, bfd_reloc_code_real_type));
  88 static struct bfd_link_hash_table * coff_arm_link_hash_table_create
  89   PARAMS ((bfd *));
  90 static insn32 insert_thumb_branch
  91   PARAMS ((insn32, int));
  92 static struct coff_link_hash_entry * find_thumb_glue
  93   PARAMS ((struct bfd_link_info *, CONST char *, bfd *));
  94 static struct coff_link_hash_entry * find_arm_glue
  95   PARAMS ((struct bfd_link_info *, CONST char *, bfd *));
  96 #ifndef COFF_IMAGE_WITH_PE
  97 static void record_arm_to_thumb_glue
  98   PARAMS ((struct bfd_link_info *, struct coff_link_hash_entry *));
  99 static void record_thumb_to_arm_glue
 100   PARAMS ((struct bfd_link_info *, struct coff_link_hash_entry *));
 101 #endif
 102 static boolean coff_arm_merge_private_bfd_data
 103   PARAMS ((bfd *, bfd *));
 104 static boolean coff_arm_print_private_bfd_data
 105   PARAMS ((bfd *, PTR));
 106 static boolean _bfd_coff_arm_set_private_flags
 107   PARAMS ((bfd *, flagword));
 108 static boolean coff_arm_copy_private_bfd_data
 109   PARAMS ((bfd *, bfd *));
 110 static boolean coff_arm_is_local_label_name
 111   PARAMS ((bfd *, const char *));
 112 static boolean coff_arm_link_output_has_begun
 113   PARAMS ((bfd *, struct coff_final_link_info *));
 114 static boolean coff_arm_final_link_postscript
 115   PARAMS ((bfd *, struct coff_final_link_info *));
 116 static void arm_emit_base_file_entry
 117   PARAMS ((struct bfd_link_info *, bfd *, asection *, bfd_vma));
 118
 119 /* The linker script knows the section names for placement.
 120    The entry_names are used to do simple name mangling on the stubs.
 121    Given a function name, and its type, the stub can be found. The
 122    name can be changed. The only requirement is the %s be present.  */
 123
 124 #define THUMB2ARM_GLUE_SECTION_NAME ".glue_7t"
 125 #define THUMB2ARM_GLUE_ENTRY_NAME   "__%s_from_thumb"
 126
 127 #define ARM2THUMB_GLUE_SECTION_NAME ".glue_7"
 128 #define ARM2THUMB_GLUE_ENTRY_NAME   "__%s_from_arm"
 129
 130 /* Used by the assembler.  */
 131
 132 static bfd_reloc_status_type
 133 coff_arm_reloc (abfd, reloc_entry, symbol, data, input_section, output_bfd,
 134                  error_message)
 135      bfd *abfd;
 136      arelent *reloc_entry;
 137      asymbol *symbol ATTRIBUTE_UNUSED;
 138      PTR data;
 139      asection *input_section ATTRIBUTE_UNUSED;
 140      bfd *output_bfd;
 141      char **error_message ATTRIBUTE_UNUSED;
 142 {
 143   symvalue diff;
 144   if (output_bfd == (bfd *) NULL)
 145     return bfd_reloc_continue;
 146
 147   diff = reloc_entry->addend;
 148
 149 #define DOIT(x) \
 150   x = ((x & ~howto->dst_mask) | (((x & howto->src_mask) + diff) & howto->dst_mask))
 151
 152     if (diff != 0)
 153       {
 154         reloc_howto_type *howto = reloc_entry->howto;
 155         unsigned char *addr = (unsigned char *) data + reloc_entry->address;
 156
 157         switch (howto->size)
 158           {
 159           case 0:
 160             {
 161               char x = bfd_get_8 (abfd, addr);
 162               DOIT (x);
 163               bfd_put_8 (abfd, x, addr);
 164             }
 165             break;
 166
 167           case 1:
 168             {
 169               short x = bfd_get_16 (abfd, addr);
 170               DOIT (x);
 171               bfd_put_16 (abfd, x, addr);
 172             }
 173             break;
 174
 175           case 2:
 176             {
 177               long x = bfd_get_32 (abfd, addr);
 178               DOIT (x);
 179               bfd_put_32 (abfd, x, addr);
 180             }
 181             break;
 182
 183           default:
 184             abort ();
 185           }
 186       }
 187
 188   /* Now let bfd_perform_relocation finish everything up.  */
 189   return bfd_reloc_continue;
 190 }
 191
 192 /* If USER_LABEL_PREFIX is defined as "_" (see coff_arm_is_local_label_name()
 193    in this file), then TARGET_UNDERSCORE should be defined, otherwise it
 194    should not.  */
 195 #ifndef TARGET_UNDERSCORE
 196 #define TARGET_UNDERSCORE '_'
 197 #endif
 198
 199 #ifndef PCRELOFFSET
 200 #define PCRELOFFSET true
 201 #endif
 202
 203 /* These most certainly belong somewhere else. Just had to get rid of
 204    the manifest constants in the code.  */
 205 #define ARM_8        0
 206 #define ARM_16       1
 207 #define ARM_32       2
 208 #define ARM_26       3
 209 #define ARM_DISP8    4
 210 #define ARM_DISP16   5
 211 #define ARM_DISP32   6
 212 #define ARM_26D      7
 213 /* 8 is unused */
 214 #define ARM_NEG16    9
 215 #define ARM_NEG32   10
 216 #define ARM_RVA32   11
 217 #define ARM_THUMB9  12
 218 #define ARM_THUMB12 13
 219 #define ARM_THUMB23 14
 220
 221 #ifdef ARM_WINCE
 222 #undef  ARM_32
 223 #undef  ARM_RVA32
 224 #undef  ARM_26
 225 #undef  ARM_THUMB12
 226 #undef  ARM_26D
 227
 228 #define ARM_32       1
 229 #define ARM_RVA32    2
 230 #define ARM_26       3
 231 #define ARM_THUMB12  4
 232 #define ARM_26D      5
 233 #define ARM_SECTION  14
 234 #define ARM_SECREL   15
 235 #endif
 236
 237 static reloc_howto_type aoutarm_std_reloc_howto[] =
 238   {
 239 #ifdef ARM_WINCE
 240     EMPTY_HOWTO (-1),
 241     HOWTO (ARM_32,
 242            0,
 243            2,
 244            32,
 245            false,
 246            0,
 247            complain_overflow_bitfield,
 248            coff_arm_reloc,
 249            "ARM_32",
 250            true,
 251            0xffffffff,
 252            0xffffffff,
 253            PCRELOFFSET),
 254     HOWTO (ARM_RVA32,
 255            0,
 256            2,
 257            32,
 258            false,
 259            0,
 260            complain_overflow_bitfield,
 261            coff_arm_reloc,
 262            "ARM_RVA32",
 263            true,
 264            0xffffffff,
 265            0xffffffff,
 266            PCRELOFFSET),
 267     HOWTO (ARM_26,
 268            2,
 269            2,
 270            24,
 271            true,
 272            0,
 273            complain_overflow_signed,
 274            aoutarm_fix_pcrel_26 ,
 275            "ARM_26",
 276            false,
 277            0x00ffffff,
 278            0x00ffffff,
 279            PCRELOFFSET),
 280     HOWTO (ARM_THUMB12,
 281            1,
 282            1,
 283            11,
 284            true,
 285            0,
 286            complain_overflow_signed,
 287            coff_thumb_pcrel_12 ,
 288            "ARM_THUMB12",
 289            false,
 290            0x000007ff,
 291            0x000007ff,
 292            PCRELOFFSET),
 293     HOWTO (ARM_26D,
 294            2,
 295            2,
 296            24,
 297            false,
 298            0,
 299            complain_overflow_dont,
 300            aoutarm_fix_pcrel_26_done,
 301            "ARM_26D",
 302            true,
 303            0x00ffffff,
 304            0x0,
 305            false),
 306     EMPTY_HOWTO (-1),
 307     EMPTY_HOWTO (-1),
 308     EMPTY_HOWTO (-1),
 309     EMPTY_HOWTO (-1),
 310     EMPTY_HOWTO (-1),
 311     EMPTY_HOWTO (-1),
 312     EMPTY_HOWTO (-1),
 313     EMPTY_HOWTO (-1),
 314     HOWTO (ARM_SECTION,
 315            0,
 316            1,
 317            16,
 318            false,
 319            0,
 320            complain_overflow_bitfield,
 321            coff_arm_reloc,
 322            "ARM_16",
 323            true,
 324            0x0000ffff,
 325            0x0000ffff,
 326            PCRELOFFSET),
 327     HOWTO (ARM_SECREL,
 328            0,
 329            2,
 330            32,
 331            false,
 332            0,
 333            complain_overflow_bitfield,
 334            coff_arm_reloc,
 335            "ARM_32",
 336            true,
 337            0xffffffff,
 338            0xffffffff,
 339            PCRELOFFSET),
 340 #else /* not ARM_WINCE */
 341     HOWTO (ARM_8,                       /* type */
 342            0,                   /* rightshift */
 343            0,                   /* size */
 344            8,                   /* bitsize */
 345            false,                       /* pc_relative */
 346            0,                   /* bitpos */
 347            complain_overflow_bitfield, /* complain_on_overflow */
 348            coff_arm_reloc,              /* special_function */
 349            "ARM_8",             /* name */
 350            true,                        /* partial_inplace */
 351            0x000000ff,          /* src_mask */
 352            0x000000ff,          /* dst_mask */
 353            PCRELOFFSET          /* pcrel_offset */),
 354     HOWTO (ARM_16,
 355            0,
 356            1,
 357            16,
 358            false,
 359            0,
 360            complain_overflow_bitfield,
 361            coff_arm_reloc,
 362            "ARM_16",
 363            true,
 364            0x0000ffff,
 365            0x0000ffff,
 366            PCRELOFFSET),
 367     HOWTO (ARM_32,
 368            0,
 369            2,
 370            32,
 371            false,
 372            0,
 373            complain_overflow_bitfield,
 374            coff_arm_reloc,
 375            "ARM_32",
 376            true,
 377            0xffffffff,
 378            0xffffffff,
 379            PCRELOFFSET),
 380     HOWTO (ARM_26,
 381            2,
 382            2,
 383            24,
 384            true,
 385            0,
 386            complain_overflow_signed,
 387            aoutarm_fix_pcrel_26 ,
 388            "ARM_26",
 389            false,
 390            0x00ffffff,
 391            0x00ffffff,
 392            PCRELOFFSET),
 393     HOWTO (ARM_DISP8,
 394            0,
 395            0,
 396            8,
 397            true,
 398            0,
 399            complain_overflow_signed,
 400            coff_arm_reloc,
 401            "ARM_DISP8",
 402            true,
 403            0x000000ff,
 404            0x000000ff,
 405            true),
 406     HOWTO (ARM_DISP16,
 407            0,
 408            1,
 409            16,
 410            true,
 411            0,
 412            complain_overflow_signed,
 413            coff_arm_reloc,
 414            "ARM_DISP16",
 415            true,
 416            0x0000ffff,
 417            0x0000ffff,
 418            true),
 419     HOWTO (ARM_DISP32,
 420            0,
 421            2,
 422            32,
 423            true,
 424            0,
 425            complain_overflow_signed,
 426            coff_arm_reloc,
 427            "ARM_DISP32",
 428            true,
 429            0xffffffff,
 430            0xffffffff,
 431            true),
 432     HOWTO (ARM_26D,
 433            2,
 434            2,
 435            24,
 436            false,
 437            0,
 438            complain_overflow_dont,
 439            aoutarm_fix_pcrel_26_done,
 440            "ARM_26D",
 441            true,
 442            0x00ffffff,
 443            0x0,
 444            false),
 445     /* 8 is unused */
 446     EMPTY_HOWTO (-1),
 447     HOWTO (ARM_NEG16,
 448            0,
 449            -1,
 450            16,
 451            false,
 452            0,
 453            complain_overflow_bitfield,
 454            coff_arm_reloc,
 455            "ARM_NEG16",
 456            true,
 457            0x0000ffff,
 458            0x0000ffff,
 459            false),
 460     HOWTO (ARM_NEG32,
 461            0,
 462            -2,
 463            32,
 464            false,
 465            0,
 466            complain_overflow_bitfield,
 467            coff_arm_reloc,
 468            "ARM_NEG32",
 469            true,
 470            0xffffffff,
 471            0xffffffff,
 472            false),
 473     HOWTO (ARM_RVA32,
 474            0,
 475            2,
 476            32,
 477            false,
 478            0,
 479            complain_overflow_bitfield,
 480            coff_arm_reloc,
 481            "ARM_RVA32",
 482            true,
 483            0xffffffff,
 484            0xffffffff,
 485            PCRELOFFSET),
 486     HOWTO (ARM_THUMB9,
 487            1,
 488            1,
 489            8,
 490            true,
 491            0,
 492            complain_overflow_signed,
 493            coff_thumb_pcrel_9 ,
 494            "ARM_THUMB9",
 495            false,
 496            0x000000ff,
 497            0x000000ff,
 498            PCRELOFFSET),
 499     HOWTO (ARM_THUMB12,
 500            1,
 501            1,
 502            11,
 503            true,
 504            0,
 505            complain_overflow_signed,
 506            coff_thumb_pcrel_12 ,
 507            "ARM_THUMB12",
 508            false,
 509            0x000007ff,
 510            0x000007ff,
 511            PCRELOFFSET),
 512     HOWTO (ARM_THUMB23,
 513            1,
 514            2,
 515            22,
 516            true,
 517            0,
 518            complain_overflow_signed,
 519            coff_thumb_pcrel_23 ,
 520            "ARM_THUMB23",
 521            false,
 522            0x07ff07ff,
 523            0x07ff07ff,
 524            PCRELOFFSET)
 525 #endif /* not ARM_WINCE */
 526   };
 527
 528 #define NUM_RELOCS NUM_ELEM (aoutarm_std_reloc_howto)
 529
 530 #ifdef COFF_WITH_PE
 531 static boolean in_reloc_p PARAMS ((bfd *, reloc_howto_type *));
 532 /* Return true if this relocation should
 533    appear in the output .reloc section.  */
 534
 535 static boolean
 536 in_reloc_p (abfd, howto)
 537      bfd * abfd ATTRIBUTE_UNUSED;
 538      reloc_howto_type * howto;
 539 {
 540   return !howto->pc_relative && howto->type != ARM_RVA32;
 541 }
 542 #endif
 543
 544 #define RTYPE2HOWTO(cache_ptr, dst)             \
 545   (cache_ptr)->howto =                          \
 546     (dst)->r_type < NUM_RELOCS                  \
 547     ? aoutarm_std_reloc_howto + (dst)->r_type   \
 548     : NULL
 549
 550 #define coff_rtype_to_howto coff_arm_rtype_to_howto
 551
 552 static reloc_howto_type *
 553 coff_arm_rtype_to_howto (abfd, sec, rel, h, sym, addendp)
 554      bfd *abfd ATTRIBUTE_UNUSED;
 555      asection *sec;
 556      struct internal_reloc *rel;
 557      struct coff_link_hash_entry *h ATTRIBUTE_UNUSED;
 558      struct internal_syment *sym ATTRIBUTE_UNUSED;
 559      bfd_vma *addendp;
 560 {
 561   reloc_howto_type * howto;
 562
 563   if (rel->r_type >= NUM_RELOCS)
 564     return NULL;
 565
 566   howto = aoutarm_std_reloc_howto + rel->r_type;
 567
 568   if (rel->r_type == ARM_RVA32)
 569     *addendp -= pe_data (sec->output_section->owner)->pe_opthdr.ImageBase;
 570
 571   return howto;
 572 }
 573
 574 /* Used by the assembler.  */
 575
 576 static bfd_reloc_status_type
 577 aoutarm_fix_pcrel_26_done (abfd, reloc_entry, symbol, data, input_section,
 578                           output_bfd, error_message)
 579      bfd *abfd ATTRIBUTE_UNUSED;
 580      arelent *reloc_entry ATTRIBUTE_UNUSED;
 581      asymbol *symbol ATTRIBUTE_UNUSED;
 582      PTR data ATTRIBUTE_UNUSED;
 583      asection *input_section ATTRIBUTE_UNUSED;
 584      bfd *output_bfd ATTRIBUTE_UNUSED;
 585      char **error_message ATTRIBUTE_UNUSED;
 586 {
 587   /* This is dead simple at present.  */
 588   return bfd_reloc_ok;
 589 }
 590
 591 /* Used by the assembler.  */
 592
 593 static bfd_reloc_status_type
 594 aoutarm_fix_pcrel_26 (abfd, reloc_entry, symbol, data, input_section,
 595                      output_bfd, error_message)
 596      bfd *abfd;
 597      arelent *reloc_entry;
 598      asymbol *symbol;
 599      PTR data;
 600      asection *input_section;
 601      bfd *output_bfd;
 602      char **error_message ATTRIBUTE_UNUSED;
 603 {
 604   bfd_vma relocation;
 605   bfd_size_type addr = reloc_entry->address;
 606   long target = bfd_get_32 (abfd, (bfd_byte *) data + addr);
 607   bfd_reloc_status_type flag = bfd_reloc_ok;
 608
 609   /* If this is an undefined symbol, return error.  */
 610   if (symbol->section == &bfd_und_section
 611       && (symbol->flags & BSF_WEAK) == 0)
 612     return output_bfd ? bfd_reloc_continue : bfd_reloc_undefined;
 613
 614   /* If the sections are different, and we are doing a partial relocation,
 615      just ignore it for now.  */
 616   if (symbol->section->name != input_section->name
 617       && output_bfd != (bfd *)NULL)
 618     return bfd_reloc_continue;
 619
 620   relocation = (target & 0x00ffffff) << 2;
 621   relocation = (relocation ^ 0x02000000) - 0x02000000; /* Sign extend.  */
 622   relocation += symbol->value;
 623   relocation += symbol->section->output_section->vma;
 624   relocation += symbol->section->output_offset;
 625   relocation += reloc_entry->addend;
 626   relocation -= input_section->output_section->vma;
 627   relocation -= input_section->output_offset;
 628   relocation -= addr;
 629
 630   if (relocation & 3)
 631     return bfd_reloc_overflow;
 632
 633   /* Check for overflow.  */
 634   if (relocation & 0x02000000)
 635     {
 636       if ((relocation & ~ (bfd_vma) 0x03ffffff) != ~ (bfd_vma) 0x03ffffff)
 637         flag = bfd_reloc_overflow;
 638     }
 639   else if (relocation & ~0x03ffffff)
 640     flag = bfd_reloc_overflow;
 641
 642   target &= ~0x00ffffff;
 643   target |= (relocation >> 2) & 0x00ffffff;
 644   bfd_put_32 (abfd, target, (bfd_byte *) data + addr);
 645
 646   /* Now the ARM magic... Change the reloc type so that it is marked as done.
 647      Strictly this is only necessary if we are doing a partial relocation.  */
 648   reloc_entry->howto = &aoutarm_std_reloc_howto[ARM_26D];
 649
 650   return flag;
 651 }
 652
 653 static bfd_reloc_status_type
 654 coff_thumb_pcrel_common (abfd, reloc_entry, symbol, data, input_section,
 655                      output_bfd, error_message, btype)
 656      bfd *abfd;
 657      arelent *reloc_entry;
 658      asymbol *symbol;
 659      PTR data;
 660      asection *input_section;
 661      bfd *output_bfd;
 662      char **error_message ATTRIBUTE_UNUSED;
 663      thumb_pcrel_branchtype btype;
 664 {
 665   bfd_vma relocation = 0;
 666   bfd_size_type addr = reloc_entry->address;
 667   long target = bfd_get_32 (abfd, (bfd_byte *) data + addr);
 668   bfd_reloc_status_type flag = bfd_reloc_ok;
 669   bfd_vma dstmsk;
 670   bfd_vma offmsk;
 671   bfd_vma signbit;
 672
 673   /* NOTE: This routine is currently used by GAS, but not by the link
 674      phase.  */
 675
 676   switch (btype)
 677     {
 678     case b9:
 679       dstmsk  = 0x000000ff;
 680       offmsk  = 0x000001fe;
 681       signbit = 0x00000100;
 682       break;
 683
 684     case b12:
 685       dstmsk  = 0x000007ff;
 686       offmsk  = 0x00000ffe;
 687       signbit = 0x00000800;
 688       break;
 689
 690     case b23:
 691       dstmsk  = 0x07ff07ff;
 692       offmsk  = 0x007fffff;
 693       signbit = 0x00400000;
 694       break;
 695
 696     default:
 697       abort ();
 698     }
 699
 700   /* If this is an undefined symbol, return error.  */
 701   if (symbol->section == &bfd_und_section
 702       && (symbol->flags & BSF_WEAK) == 0)
 703     return output_bfd ? bfd_reloc_continue : bfd_reloc_undefined;
 704
 705   /* If the sections are different, and we are doing a partial relocation,
 706      just ignore it for now.  */
 707   if (symbol->section->name != input_section->name
 708       && output_bfd != (bfd *)NULL)
 709     return bfd_reloc_continue;
 710
 711   switch (btype)
 712     {
 713     case b9:
 714     case b12:
 715       relocation = ((target & dstmsk) << 1);
 716       break;
 717
 718     case b23:
 719       if (bfd_big_endian (abfd))
 720         relocation = ((target & 0x7ff) << 1)  | ((target & 0x07ff0000) >> 4);
 721       else
 722         relocation = ((target & 0x7ff) << 12) | ((target & 0x07ff0000) >> 15);
 723       break;
 724
 725     default:
 726       abort ();
 727     }
 728
 729   relocation = (relocation ^ signbit) - signbit; /* Sign extend.  */
 730   relocation += symbol->value;
 731   relocation += symbol->section->output_section->vma;
 732   relocation += symbol->section->output_offset;
 733   relocation += reloc_entry->addend;
 734   relocation -= input_section->output_section->vma;
 735   relocation -= input_section->output_offset;
 736   relocation -= addr;
 737
 738   if (relocation & 1)
 739     return bfd_reloc_overflow;
 740
 741   /* Check for overflow.  */
 742   if (relocation & signbit)
 743     {
 744       if ((relocation & ~offmsk) != ~offmsk)
 745         flag = bfd_reloc_overflow;
 746     }
 747   else if (relocation & ~offmsk)
 748     flag = bfd_reloc_overflow;
 749
 750   target &= ~dstmsk;
 751   switch (btype)
 752    {
 753    case b9:
 754    case b12:
 755      target |= (relocation >> 1);
 756      break;
 757
 758    case b23:
 759      if (bfd_big_endian (abfd))
 760        target |= ((relocation & 0xfff) >> 1)  | ((relocation << 4)  & 0x07ff0000);
 761      else
 762        target |= ((relocation & 0xffe) << 15) | ((relocation >> 12) & 0x7ff);
 763      break;
 764
 765    default:
 766      abort ();
 767    }
 768
 769   bfd_put_32 (abfd, target, (bfd_byte *) data + addr);
 770
 771   /* Now the ARM magic... Change the reloc type so that it is marked as done.
 772      Strictly this is only necessary if we are doing a partial relocation.  */
 773   reloc_entry->howto = & aoutarm_std_reloc_howto [ARM_26D];
 774
 775   /* TODO: We should possibly have DONE entries for the THUMB PCREL relocations.  */
 776   return flag;
 777 }
 778
 779 static bfd_reloc_status_type
 780 coff_thumb_pcrel_23 (abfd, reloc_entry, symbol, data, input_section,
 781                      output_bfd, error_message)
 782      bfd *abfd;
 783      arelent *reloc_entry;
 784      asymbol *symbol;
 785      PTR data;
 786      asection *input_section;
 787      bfd *output_bfd;
 788      char **error_message;
 789 {
 790   return coff_thumb_pcrel_common (abfd, reloc_entry, symbol, data,
 791                                   input_section, output_bfd, error_message, b23);
 792 }
 793
 794 static bfd_reloc_status_type
 795 coff_thumb_pcrel_12 (abfd, reloc_entry, symbol, data, input_section,
 796                      output_bfd, error_message)
 797      bfd *abfd;
 798      arelent *reloc_entry;
 799      asymbol *symbol;
 800      PTR data;
 801      asection *input_section;
 802      bfd *output_bfd;
 803      char **error_message;
 804 {
 805   return coff_thumb_pcrel_common (abfd, reloc_entry, symbol, data,
 806                                   input_section, output_bfd, error_message, b12);
 807 }
 808
 809 static bfd_reloc_status_type
 810 coff_thumb_pcrel_9 (abfd, reloc_entry, symbol, data, input_section,
 811                      output_bfd, error_message)
 812      bfd *abfd;
 813      arelent *reloc_entry;
 814      asymbol *symbol;
 815      PTR data;
 816      asection *input_section;
 817      bfd *output_bfd;
 818      char **error_message;
 819 {
 820   return coff_thumb_pcrel_common (abfd, reloc_entry, symbol, data,
 821                                   input_section, output_bfd, error_message, b9);
 822 }
 823
 824 static CONST struct reloc_howto_struct *
 825 coff_arm_reloc_type_lookup (abfd, code)
 826       bfd * abfd;
 827       bfd_reloc_code_real_type code;
 828 {
 829 #define ASTD(i,j)       case i: return aoutarm_std_reloc_howto + j
 830
 831   if (code == BFD_RELOC_CTOR)
 832     switch (bfd_get_arch_info (abfd)->bits_per_address)
 833       {
 834       case 32:
 835         code = BFD_RELOC_32;
 836         break;
 837       default:
 838         return (CONST struct reloc_howto_struct *) 0;
 839       }
 840
 841   switch (code)
 842     {
 843 #ifdef ARM_WINCE
 844       ASTD (BFD_RELOC_32,                   ARM_32);
 845       ASTD (BFD_RELOC_RVA,                  ARM_RVA32);
 846       ASTD (BFD_RELOC_ARM_PCREL_BRANCH,     ARM_26);
 847       ASTD (BFD_RELOC_THUMB_PCREL_BRANCH12, ARM_THUMB12);
 848 #else
 849       ASTD (BFD_RELOC_8,                    ARM_8);
 850       ASTD (BFD_RELOC_16,                   ARM_16);
 851       ASTD (BFD_RELOC_32,                   ARM_32);
 852       ASTD (BFD_RELOC_ARM_PCREL_BRANCH,     ARM_26);
 853       ASTD (BFD_RELOC_ARM_PCREL_BLX,        ARM_26);
 854       ASTD (BFD_RELOC_8_PCREL,              ARM_DISP8);
 855       ASTD (BFD_RELOC_16_PCREL,             ARM_DISP16);
 856       ASTD (BFD_RELOC_32_PCREL,             ARM_DISP32);
 857       ASTD (BFD_RELOC_RVA,                  ARM_RVA32);
 858       ASTD (BFD_RELOC_THUMB_PCREL_BRANCH9,  ARM_THUMB9);
 859       ASTD (BFD_RELOC_THUMB_PCREL_BRANCH12, ARM_THUMB12);
 860       ASTD (BFD_RELOC_THUMB_PCREL_BRANCH23, ARM_THUMB23);
 861       ASTD (BFD_RELOC_THUMB_PCREL_BLX,      ARM_THUMB23);
 862 #endif
 863     default: return (CONST struct reloc_howto_struct *) 0;
 864     }
 865 }
 866
 867 #define COFF_DEFAULT_SECTION_ALIGNMENT_POWER (2)
 868 #define COFF_PAGE_SIZE 0x1000
 869 /* Turn a howto into a reloc  nunmber */
 870
 871 #define SELECT_RELOC(x,howto) { x.r_type = howto->type; }
 872 #define BADMAG(x) ARMBADMAG(x)
 873 #define ARM 1                   /* Customize coffcode.h */
 874
 875 /* Extend the coff_link_hash_table structure with a few ARM specific fields.
 876    This allows us to store global data here without actually creating any
 877    global variables, which is a no-no in the BFD world.  */
 878 struct coff_arm_link_hash_table
 879   {
 880     /* The original coff_link_hash_table structure.  MUST be first field.  */
 881     struct coff_link_hash_table root;
 882
 883     /* The size in bytes of the section containg the Thumb-to-ARM glue.  */
 884     long int                    thumb_glue_size;
 885
 886     /* The size in bytes of the section containg the ARM-to-Thumb glue.  */
 887     long int                    arm_glue_size;
 888
 889     /* An arbitary input BFD chosen to hold the glue sections.  */
 890     bfd *                       bfd_of_glue_owner;
 891
 892     /* Support interworking with old, non-interworking aware ARM code.  */
 893     int                         support_old_code;
 894 };
 895
 896 /* Get the ARM coff linker hash table from a link_info structure.  */
 897 #define coff_arm_hash_table(info) \
 898   ((struct coff_arm_link_hash_table *) ((info)->hash))
 899
 900 /* Create an ARM coff linker hash table.  */
 901
 902 static struct bfd_link_hash_table *
 903 coff_arm_link_hash_table_create (abfd)
 904      bfd * abfd;
 905 {
 906   struct coff_arm_link_hash_table * ret;
 907
 908   ret = ((struct coff_arm_link_hash_table *)
 909          bfd_alloc (abfd, sizeof (struct coff_arm_link_hash_table)));
 910   if (ret == (struct coff_arm_link_hash_table *) NULL)
 911     return NULL;
 912
 913   if (! _bfd_coff_link_hash_table_init
 914       (& ret->root, abfd, _bfd_coff_link_hash_newfunc))
 915     {
 916       bfd_release (abfd, ret);
 917       return (struct bfd_link_hash_table *) NULL;
 918     }
 919
 920   ret->thumb_glue_size   = 0;
 921   ret->arm_glue_size     = 0;
 922   ret->bfd_of_glue_owner = NULL;
 923
 924   return & ret->root.root;
 925 }
 926
 927 static void
 928 arm_emit_base_file_entry (info, output_bfd, input_section, reloc_offset)
 929       struct bfd_link_info *info;
 930       bfd *output_bfd;
 931       asection *input_section;
 932       bfd_vma reloc_offset;
 933 {
 934   bfd_vma addr = reloc_offset
 935                 - input_section->vma
 936                 + input_section->output_offset
 937                   + input_section->output_section->vma;
 938
 939   if (coff_data (output_bfd)->pe)
 940      addr -= pe_data (output_bfd)->pe_opthdr.ImageBase;
 941   fwrite (& addr, 1, sizeof (addr), (FILE *) info->base_file);
 942
 943 }
 944 \f
 945 /* The thumb form of a long branch is a bit finicky, because the offset
 946    encoding is split over two fields, each in it's own instruction. They
 947    can occur in any order. So given a thumb form of long branch, and an
 948    offset, insert the offset into the thumb branch and return finished
 949    instruction.
 950
 951    It takes two thumb instructions to encode the target address. Each has
 952    11 bits to invest. The upper 11 bits are stored in one (identifed by
 953    H-0.. see below), the lower 11 bits are stored in the other (identified
 954    by H-1).
 955
 956    Combine together and shifted left by 1 (it's a half word address) and
 957    there you have it.
 958
 959      Op: 1111 = F,
 960      H-0, upper address-0 = 000
 961      Op: 1111 = F,
 962      H-1, lower address-0 = 800
 963
 964    They can be ordered either way, but the arm tools I've seen always put
 965    the lower one first. It probably doesn't matter. krk@cygnus.com
 966
 967    XXX:  Actually the order does matter.  The second instruction (H-1)
 968    moves the computed address into the PC, so it must be the second one
 969    in the sequence.  The problem, however is that whilst little endian code
 970    stores the instructions in HI then LOW order, big endian code does the
 971    reverse.  nickc@cygnus.com.  */
 972
 973 #define LOW_HI_ORDER 0xF800F000
 974 #define HI_LOW_ORDER 0xF000F800
 975
 976 static insn32
 977 insert_thumb_branch (br_insn, rel_off)
 978      insn32 br_insn;
 979      int rel_off;
 980 {
 981   unsigned int low_bits;
 982   unsigned int high_bits;
 983
 984   BFD_ASSERT((rel_off & 1) != 1);
 985
 986   rel_off >>= 1;                              /* half word aligned address */
 987   low_bits = rel_off & 0x000007FF;            /* the bottom 11 bits */
 988   high_bits = (rel_off >> 11) & 0x000007FF;   /* the top 11 bits */
 989
 990   if ((br_insn & LOW_HI_ORDER) == LOW_HI_ORDER)
 991     br_insn = LOW_HI_ORDER | (low_bits << 16) | high_bits;
 992   else if ((br_insn & HI_LOW_ORDER) == HI_LOW_ORDER)
 993     br_insn = HI_LOW_ORDER | (high_bits << 16) | low_bits;
 994   else
 995     /* FIXME: the BFD library should never abort - it should return an error status.  */
 996     abort (); /* Error - not a valid branch instruction form.  */
 997
 998   return br_insn;
 999 }
1000 \f
1001 static struct coff_link_hash_entry *
1002 find_thumb_glue (info, name, input_bfd)
1003      struct bfd_link_info * info;
1004      CONST char *           name;
1005      bfd *                  input_bfd;
1006 {
1007   char *                        tmp_name;
1008   struct coff_link_hash_entry * myh;
1009
1010   tmp_name = ((char *)
1011          bfd_malloc (strlen (name) + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1));
1012
1013   BFD_ASSERT (tmp_name);
1014
1015   sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name);
1016
1017   myh = coff_link_hash_lookup
1018     (coff_hash_table (info), tmp_name, false, false, true);
1019
1020   if (myh == NULL)
1021     /* xgettext:c-format */
1022     _bfd_error_handler (_("%s: unable to find THUMB glue '%s' for `%s'"),
1023                         bfd_get_filename (input_bfd), tmp_name, name);
1024
1025   free (tmp_name);
1026
1027   return myh;
1028 }
1029
1030 static struct coff_link_hash_entry *
1031 find_arm_glue (info, name, input_bfd)
1032      struct bfd_link_info * info;
1033      CONST char *           name;
1034      bfd *                  input_bfd;
1035 {
1036   char *                        tmp_name;
1037   struct coff_link_hash_entry * myh;
1038
1039   tmp_name = ((char *)
1040               bfd_malloc (strlen (name) + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1));
1041
1042   BFD_ASSERT (tmp_name);
1043
1044   sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
1045
1046   myh = coff_link_hash_lookup
1047     (coff_hash_table (info), tmp_name, false, false, true);
1048
1049   if (myh == NULL)
1050     /* xgettext:c-format */
1051     _bfd_error_handler (_("%s: unable to find ARM glue '%s' for `%s'"),
1052                         bfd_get_filename (input_bfd), tmp_name, name);
1053
1054   free (tmp_name);
1055
1056   return myh;
1057 }
1058
1059 /*
1060   ARM->Thumb glue:
1061
1062        .arm
1063        __func_from_arm:
1064              ldr r12, __func_addr
1065              bx  r12
1066        __func_addr:
1067             .word func    @ behave as if you saw a ARM_32 reloc
1068 */
1069
1070 #define ARM2THUMB_GLUE_SIZE 12
1071 static const insn32 a2t1_ldr_insn       = 0xe59fc000;
1072 static const insn32 a2t2_bx_r12_insn    = 0xe12fff1c;
1073 static const insn32 a2t3_func_addr_insn = 0x00000001;
1074
1075 /*
1076    Thumb->ARM:                          Thumb->(non-interworking aware) ARM
1077
1078    .thumb                               .thumb
1079    .align 2                             .align 2
1080       __func_from_thumb:                   __func_from_thumb:
1081            bx pc                                push {r6, lr}
1082            nop                                  ldr  r6, __func_addr
1083    .arm                                         mov  lr, pc
1084       __func_change_to_arm:                     bx   r6
1085            b func                       .arm
1086                                            __func_back_to_thumb:
1087                                                 ldmia r13! {r6, lr}
1088                                                 bx    lr
1089                                            __func_addr:
1090                                                 .word   func
1091 */
1092
1093 #define THUMB2ARM_GLUE_SIZE (globals->support_old_code ? 20 : 8)
1094 static const insn16 t2a1_bx_pc_insn = 0x4778;
1095 static const insn16 t2a2_noop_insn  = 0x46c0;
1096 static const insn32 t2a3_b_insn     = 0xea000000;
1097
1098 static const insn16 t2a1_push_insn  = 0xb540;
1099 static const insn16 t2a2_ldr_insn   = 0x4e03;
1100 static const insn16 t2a3_mov_insn   = 0x46fe;
1101 static const insn16 t2a4_bx_insn    = 0x4730;
1102 static const insn32 t2a5_pop_insn   = 0xe8bd4040;
1103 static const insn32 t2a6_bx_insn    = 0xe12fff1e;
1104
1105 /* TODO:
1106      We should really create new local (static) symbols in destination
1107      object for each stub we create.  We should also create local
1108      (static) symbols within the stubs when switching between ARM and
1109      Thumb code.  This will ensure that the debugger and disassembler
1110      can present a better view of stubs.
1111
1112      We can treat stubs like literal sections, and for the THUMB9 ones
1113      (short addressing range) we should be able to insert the stubs
1114      between sections. i.e. the simplest approach (since relocations
1115      are done on a section basis) is to dump the stubs at the end of
1116      processing a section. That way we can always try and minimise the
1117      offset to and from a stub. However, this does not map well onto
1118      the way that the linker/BFD does its work: mapping all input
1119      sections to output sections via the linker script before doing
1120      all the processing.
1121
1122      Unfortunately it may be easier to just to disallow short range
1123      Thumb->ARM stubs (i.e. no conditional inter-working branches,
1124      only branch-and-link (BL) calls.  This will simplify the processing
1125      since we can then put all of the stubs into their own section.
1126
1127   TODO:
1128      On a different subject, rather than complaining when a
1129      branch cannot fit in the number of bits available for the
1130      instruction we should generate a trampoline stub (needed to
1131      address the complete 32bit address space).  */
1132
1133 /* The standard COFF backend linker does not cope with the special
1134    Thumb BRANCH23 relocation.  The alternative would be to split the
1135    BRANCH23 into seperate HI23 and LO23 relocations. However, it is a
1136    bit simpler simply providing our own relocation driver.  */
1137
1138 /* The reloc processing routine for the ARM/Thumb COFF linker.  NOTE:
1139    This code is a very slightly modified copy of
1140    _bfd_coff_generic_relocate_section.  It would be a much more
1141    maintainable solution to have a MACRO that could be expanded within
1142    _bfd_coff_generic_relocate_section that would only be provided for
1143    ARM/Thumb builds.  It is only the code marked THUMBEXTENSION that
1144    is different from the original.  */
1145
1146 static boolean
1147 coff_arm_relocate_section (output_bfd, info, input_bfd, input_section,
1148                            contents, relocs, syms, sections)
1149      bfd *output_bfd;
1150      struct bfd_link_info *info;
1151      bfd *input_bfd;
1152      asection *input_section;
1153      bfd_byte *contents;
1154      struct internal_reloc *relocs;
1155      struct internal_syment *syms;
1156      asection **sections;
1157 {
1158   struct internal_reloc * rel;
1159   struct internal_reloc * relend;
1160
1161   rel = relocs;
1162   relend = rel + input_section->reloc_count;
1163
1164   for (; rel < relend; rel++)
1165     {
1166       int                            done = 0;
1167       long                           symndx;
1168       struct coff_link_hash_entry *  h;
1169       struct internal_syment *       sym;
1170       bfd_vma                        addend;
1171       bfd_vma                        val;
1172       reloc_howto_type *             howto;
1173       bfd_reloc_status_type          rstat;
1174       bfd_vma                        h_val;
1175
1176       symndx = rel->r_symndx;
1177
1178       if (symndx == -1)
1179         {
1180           h = NULL;
1181           sym = NULL;
1182         }
1183       else
1184         {
1185           h = obj_coff_sym_hashes (input_bfd)[symndx];
1186           sym = syms + symndx;
1187         }
1188
1189       /* COFF treats common symbols in one of two ways.  Either the
1190          size of the symbol is included in the section contents, or it
1191          is not.  We assume that the size is not included, and force
1192          the rtype_to_howto function to adjust the addend as needed.  */
1193
1194       if (sym != NULL && sym->n_scnum != 0)
1195         addend = - sym->n_value;
1196       else
1197         addend = 0;
1198
1199       howto = coff_rtype_to_howto (input_bfd, input_section, rel, h,
1200                                        sym, &addend);
1201       if (howto == NULL)
1202         return false;
1203
1204       /* The relocation_section function will skip pcrel_offset relocs
1205          when doing a relocateable link.  However, we want to convert
1206          ARM26 to ARM26D relocs if possible.  We return a fake howto in
1207          this case without pcrel_offset set, and adjust the addend to
1208          compensate.  */
1209       if (rel->r_type == ARM_26
1210           && h != NULL
1211           && info->relocateable
1212           && (h->root.type == bfd_link_hash_defined
1213               || h->root.type == bfd_link_hash_defweak)
1214           && h->root.u.def.section->output_section == input_section->output_section)
1215         {
1216           static reloc_howto_type fake_arm26_reloc =
1217             HOWTO (ARM_26,
1218                2,
1219                2,
1220                24,
1221                true,
1222                0,
1223                complain_overflow_signed,
1224                aoutarm_fix_pcrel_26 ,
1225                "ARM_26",
1226                false,
1227                0x00ffffff,
1228                0x00ffffff,
1229                false);
1230
1231           addend -= rel->r_vaddr - input_section->vma;
1232           howto = &fake_arm26_reloc;
1233         }
1234
1235 #ifdef ARM_WINCE
1236       /* MS ARM-CE makes the reloc relative to the opcode's pc, not
1237          the next opcode's pc, so is off by one.  */
1238       if (howto->pc_relative && !info->relocateable)
1239         addend -= 8;
1240 #endif
1241
1242       /* If we are doing a relocateable link, then we can just ignore
1243          a PC relative reloc that is pcrel_offset.  It will already
1244          have the correct value.  If this is not a relocateable link,
1245          then we should ignore the symbol value.  */
1246       if (howto->pc_relative && howto->pcrel_offset)
1247         {
1248           if (info->relocateable)
1249             continue;
1250           /* FIXME - it is not clear which targets need this next test
1251              and which do not.  It is known that it is needed for the
1252              VxWorks and EPOC-PE targets, but it is also known that it
1253              was supressed for other ARM targets.  This ought to be
1254              sorted out one day.  */
1255 #ifdef ARM_COFF_BUGFIX
1256           /* We must not ignore the symbol value.  If the symbol is
1257              within the same section, the relocation should have already
1258              been fixed, but if it is not, we'll be handed a reloc into
1259              the beginning of the symbol's section, so we must not cancel
1260              out the symbol's value, otherwise we'll be adding it in
1261              twice.  */
1262           if (sym != NULL && sym->n_scnum != 0)
1263             addend += sym->n_value;
1264 #endif
1265         }
1266
1267       val = 0;
1268
1269       if (h == NULL)
1270         {
1271           asection *sec;
1272
1273           if (symndx == -1)
1274             {
1275               sec = bfd_abs_section_ptr;
1276               val = 0;
1277             }
1278           else
1279             {
1280               sec = sections[symndx];
1281               val = (sec->output_section->vma
1282                      + sec->output_offset
1283                      + sym->n_value
1284                      - sec->vma);
1285             }
1286         }
1287       else
1288         {
1289 #if 1 /* THUMBEXTENSION */
1290           /* We don't output the stubs if we are generating a
1291              relocatable output file, since we may as well leave the
1292              stub generation to the final linker pass. If we fail to
1293              verify that the name is defined, we'll try to build stubs
1294              for an undefined name...  */
1295           if (! info->relocateable
1296               && (   h->root.type == bfd_link_hash_defined
1297                   || h->root.type == bfd_link_hash_defweak))
1298             {
1299               asection *   h_sec = h->root.u.def.section;
1300               const char * name  = h->root.root.string;
1301
1302               /* h locates the symbol referenced in the reloc.  */
1303               h_val = (h->root.u.def.value
1304                        + h_sec->output_section->vma
1305                        + h_sec->output_offset);
1306
1307               if (howto->type == ARM_26)
1308                 {
1309                   if (   h->class == C_THUMBSTATFUNC
1310                       || h->class == C_THUMBEXTFUNC)
1311                     {
1312                       /* Arm code calling a Thumb function.  */
1313                       unsigned long int                 tmp;
1314                       long int                          my_offset;
1315                       asection *                        s;
1316                       long int                          ret_offset;
1317                       struct coff_link_hash_entry *     myh;
1318                       struct coff_arm_link_hash_table * globals;
1319
1320                       myh = find_arm_glue (info, name, input_bfd);
1321                       if (myh == NULL)
1322                         return false;
1323
1324                       globals = coff_arm_hash_table (info);
1325
1326                       BFD_ASSERT (globals != NULL);
1327                       BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
1328
1329                       my_offset = myh->root.u.def.value;
1330
1331                       s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
1332                                                   ARM2THUMB_GLUE_SECTION_NAME);
1333                       BFD_ASSERT (s != NULL);
1334                       BFD_ASSERT (s->contents != NULL);
1335                       BFD_ASSERT (s->output_section != NULL);
1336
1337                       if ((my_offset & 0x01) == 0x01)
1338                         {
1339                           if (h_sec->owner != NULL
1340                               && INTERWORK_SET (h_sec->owner)
1341                               && ! INTERWORK_FLAG (h_sec->owner))
1342                             {
1343                               _bfd_error_handler
1344                                 /* xgettext:c-format */
1345                                 (_("%s(%s): warning: interworking not enabled."),
1346                                  bfd_get_filename (h_sec->owner), name);
1347                               _bfd_error_handler
1348                                 /* xgettext:c-format */
1349                                 (_("  first occurrence: %s: arm call to thumb"),
1350                                  bfd_get_filename (input_bfd));
1351                             }
1352
1353                           --my_offset;
1354                           myh->root.u.def.value = my_offset;
1355
1356                           bfd_put_32 (output_bfd, a2t1_ldr_insn,
1357                                       s->contents + my_offset);
1358
1359                           bfd_put_32 (output_bfd, a2t2_bx_r12_insn,
1360                                       s->contents + my_offset + 4);
1361
1362                           /* It's a thumb address.  Add the low order bit.  */
1363                           bfd_put_32 (output_bfd, h_val | a2t3_func_addr_insn,
1364                                       s->contents + my_offset + 8);
1365
1366                           if (info->base_file)
1367                             arm_emit_base_file_entry (info, output_bfd, s,
1368                                                             my_offset + 8);
1369
1370                         }
1371
1372                       BFD_ASSERT (my_offset <= globals->arm_glue_size);
1373
1374                       tmp = bfd_get_32 (input_bfd, contents + rel->r_vaddr
1375                                         - input_section->vma);
1376
1377                       tmp = tmp & 0xFF000000;
1378
1379                       /* Somehow these are both 4 too far, so subtract 8.  */
1380                       ret_offset =
1381                         s->output_offset
1382                         + my_offset
1383                         + s->output_section->vma
1384                         - (input_section->output_offset
1385                            + input_section->output_section->vma
1386                            + rel->r_vaddr)
1387                         - 8;
1388
1389                       tmp = tmp | ((ret_offset >> 2) & 0x00FFFFFF);
1390
1391                       bfd_put_32 (output_bfd, tmp, contents + rel->r_vaddr
1392                                   - input_section->vma);
1393                       done = 1;
1394                     }
1395                 }
1396
1397 #ifndef ARM_WINCE
1398               /* Note: We used to check for ARM_THUMB9 and ARM_THUMB12.  */
1399               else if (howto->type == ARM_THUMB23)
1400                 {
1401                   if (   h->class == C_EXT
1402                       || h->class == C_STAT
1403                       || h->class == C_LABEL)
1404                     {
1405                       /* Thumb code calling an ARM function */
1406                       asection *                         s = 0;
1407                       long int                           my_offset;
1408                       unsigned long int                  tmp;
1409                       long int                           ret_offset;
1410                       struct coff_link_hash_entry *      myh;
1411                       struct coff_arm_link_hash_table *  globals;
1412
1413                       myh = find_thumb_glue (info, name, input_bfd);
1414                       if (myh == NULL)
1415                         return false;
1416
1417                       globals = coff_arm_hash_table (info);
1418
1419                       BFD_ASSERT (globals != NULL);
1420                       BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
1421
1422                       my_offset = myh->root.u.def.value;
1423
1424                       s = bfd_get_section_by_name (globals->bfd_of_glue_owner,
1425                                                    THUMB2ARM_GLUE_SECTION_NAME);
1426
1427                       BFD_ASSERT (s != NULL);
1428                       BFD_ASSERT (s->contents != NULL);
1429                       BFD_ASSERT (s->output_section != NULL);
1430
1431                       if ((my_offset & 0x01) == 0x01)
1432                         {
1433                           if (h_sec->owner != NULL
1434                               && INTERWORK_SET (h_sec->owner)
1435                               && ! INTERWORK_FLAG (h_sec->owner)
1436                               && ! globals->support_old_code)
1437                             {
1438                               _bfd_error_handler
1439                                 /* xgettext:c-format */
1440                                 (_("%s(%s): warning: interworking not enabled."),
1441                                  bfd_get_filename (h_sec->owner), name);
1442                               _bfd_error_handler
1443                                 /* xgettext:c-format */
1444                                 (_("  first occurrence: %s: thumb call to arm"),
1445                                  bfd_get_filename (input_bfd));
1446                               _bfd_error_handler
1447                                 (_("  consider relinking with --support-old-code enabled"));
1448                             }
1449
1450                           -- my_offset;
1451                           myh->root.u.def.value = my_offset;
1452
1453                           if (globals->support_old_code)
1454                             {
1455                               bfd_put_16 (output_bfd, t2a1_push_insn,
1456                                           s->contents + my_offset);
1457
1458                               bfd_put_16 (output_bfd, t2a2_ldr_insn,
1459                                           s->contents + my_offset + 2);
1460
1461                               bfd_put_16 (output_bfd, t2a3_mov_insn,
1462                                           s->contents + my_offset + 4);
1463
1464                               bfd_put_16 (output_bfd, t2a4_bx_insn,
1465                                           s->contents + my_offset + 6);
1466
1467                               bfd_put_32 (output_bfd, t2a5_pop_insn,
1468                                           s->contents + my_offset + 8);
1469
1470                               bfd_put_32 (output_bfd, t2a6_bx_insn,
1471                                           s->contents + my_offset + 12);
1472
1473                               /* Store the address of the function in the last word of the stub.  */
1474                               bfd_put_32 (output_bfd, h_val,
1475                                           s->contents + my_offset + 16);
1476
1477                               if (info->base_file)
1478                                 arm_emit_base_file_entry (info, output_bfd, s, my_offset + 16);
1479                             }
1480                           else
1481                             {
1482                               bfd_put_16 (output_bfd, t2a1_bx_pc_insn,
1483                                           s->contents + my_offset);
1484
1485                               bfd_put_16 (output_bfd, t2a2_noop_insn,
1486                                           s->contents + my_offset + 2);
1487
1488                               ret_offset =
1489                                 ((bfd_signed_vma) h_val)        /* Address of destination of the stub.  */
1490                                 - ((bfd_signed_vma)
1491                                    (s->output_offset            /* Offset from the start of the current section to the start of the stubs.  */
1492                                     + my_offset                 /* Offset of the start of this stub from the start of the stubs.  */
1493                                     + s->output_section->vma)   /* Address of the start of the current section.  */
1494                                    + 4                          /* The branch instruction is 4 bytes into the stub.  */
1495                                    + 8);                        /* ARM branches work from the pc of the instruction + 8.  */
1496
1497                               bfd_put_32 (output_bfd,
1498                                           t2a3_b_insn | ((ret_offset >> 2) & 0x00FFFFFF),
1499                                           s->contents + my_offset + 4);
1500
1501                             }
1502                         }
1503
1504                       BFD_ASSERT (my_offset <= globals->thumb_glue_size);
1505
1506                       /* Now go back and fix up the original BL insn to point
1507                          to here.  */
1508                       ret_offset =
1509                         s->output_offset
1510                         + my_offset
1511                         - (input_section->output_offset
1512                            + rel->r_vaddr)
1513                         -4;
1514
1515                       tmp = bfd_get_32 (input_bfd, contents + rel->r_vaddr
1516                                         - input_section->vma);
1517
1518                       bfd_put_32 (output_bfd,
1519                                   insert_thumb_branch (tmp, ret_offset),
1520                                   contents + rel->r_vaddr
1521                                   - input_section->vma);
1522
1523                       done = 1;
1524                     }
1525                 }
1526 #endif
1527             }
1528
1529           /* If the relocation type and destination symbol does not
1530              fall into one of the above categories, then we can just
1531              perform a direct link.  */
1532
1533           if (done)
1534             rstat = bfd_reloc_ok;
1535           else
1536 #endif /* THUMBEXTENSION */
1537             if (   h->root.type == bfd_link_hash_defined
1538                 || h->root.type == bfd_link_hash_defweak)
1539             {
1540               asection *sec;
1541
1542               sec = h->root.u.def.section;
1543               val = (h->root.u.def.value
1544                      + sec->output_section->vma
1545                      + sec->output_offset);
1546               }
1547
1548           else if (! info->relocateable)
1549             {
1550               if (! ((*info->callbacks->undefined_symbol)
1551                      (info, h->root.root.string, input_bfd, input_section,
1552                       rel->r_vaddr - input_section->vma, true)))
1553                 return false;
1554             }
1555         }
1556
1557       if (info->base_file)
1558         {
1559           /* Emit a reloc if the backend thinks it needs it.  */
1560           if (sym && pe_data(output_bfd)->in_reloc_p(output_bfd, howto))
1561             arm_emit_base_file_entry (info, output_bfd, input_section, rel->r_vaddr);
1562         }
1563
1564 #if 1 /* THUMBEXTENSION */
1565       if (done)
1566         rstat = bfd_reloc_ok;
1567 #ifndef ARM_WINCE
1568       /* Only perform this fix during the final link, not a relocatable link.  nickc@cygnus.com  */
1569       else if (! info->relocateable
1570                && howto->type == ARM_THUMB23)
1571         {
1572           /* This is pretty much a copy of what the default
1573              _bfd_final_link_relocate and _bfd_relocate_contents
1574              routines do to perform a relocation, with special
1575              processing for the split addressing of the Thumb BL
1576              instruction.  Again, it would probably be simpler adding a
1577              ThumbBRANCH23 specific macro expansion into the default
1578              code.  */
1579
1580           bfd_vma address = rel->r_vaddr - input_section->vma;
1581
1582           if (address > input_section->_raw_size)
1583             rstat = bfd_reloc_outofrange;
1584           else
1585             {
1586               bfd_vma         relocation       = val + addend;
1587               int             size             = bfd_get_reloc_size (howto);
1588               boolean         overflow         = false;
1589               bfd_byte *      location         = contents + address;
1590               bfd_vma         x                = bfd_get_32 (input_bfd, location);
1591               bfd_vma         src_mask         = 0x007FFFFE;
1592               bfd_signed_vma  reloc_signed_max = (1 << (howto->bitsize - 1)) - 1;
1593               bfd_signed_vma  reloc_signed_min = ~reloc_signed_max;
1594               bfd_vma         check;
1595               bfd_signed_vma  signed_check;
1596               bfd_vma         add;
1597               bfd_signed_vma  signed_add;
1598
1599               BFD_ASSERT (size == 4);
1600
1601               /* howto->pc_relative should be TRUE for type 14 BRANCH23.  */
1602               relocation -= (input_section->output_section->vma
1603                              + input_section->output_offset);
1604
1605               /* howto->pcrel_offset should be TRUE for type 14 BRANCH23.  */
1606               relocation -= address;
1607
1608               /* No need to negate the relocation with BRANCH23.  */
1609               /* howto->complain_on_overflow == complain_overflow_signed for BRANCH23.  */
1610               /* howto->rightshift == 1 */
1611
1612               /* Drop unwanted bits from the value we are relocating to.  */
1613               check = relocation >> howto->rightshift;
1614
1615               /* If this is a signed value, the rightshift just dropped
1616                  leading 1 bits (assuming twos complement).  */
1617               if ((bfd_signed_vma) relocation >= 0)
1618                 signed_check = check;
1619               else
1620                 signed_check = (check
1621                                 | ((bfd_vma) - 1
1622                                    & ~((bfd_vma) - 1 >> howto->rightshift)));
1623
1624               /* Get the value from the object file.  */
1625               if (bfd_big_endian (input_bfd))
1626                 add = (((x) & 0x07ff0000) >> 4) | (((x) & 0x7ff) << 1);
1627               else
1628                 add = ((((x) & 0x7ff) << 12) | (((x) & 0x07ff0000) >> 15));
1629
1630               /* Get the value from the object file with an appropriate sign.
1631                  The expression involving howto->src_mask isolates the upper
1632                  bit of src_mask.  If that bit is set in the value we are
1633                  adding, it is negative, and we subtract out that number times
1634                  two.  If src_mask includes the highest possible bit, then we
1635                  can not get the upper bit, but that does not matter since
1636                  signed_add needs no adjustment to become negative in that
1637                  case.  */
1638               signed_add = add;
1639
1640               if ((add & (((~ src_mask) >> 1) & src_mask)) != 0)
1641                 signed_add -= (((~ src_mask) >> 1) & src_mask) << 1;
1642
1643               /* howto->bitpos == 0 */
1644               /* Add the value from the object file, shifted so that it is a
1645                  straight number.  */
1646               signed_check += signed_add;
1647               relocation   += signed_add;
1648
1649               BFD_ASSERT (howto->complain_on_overflow == complain_overflow_signed);
1650
1651               /* Assumes two's complement.  */
1652               if (   signed_check > reloc_signed_max
1653                   || signed_check < reloc_signed_min)
1654                 overflow = true;
1655
1656               /* For the BLX(1) instruction remove bit 0 of the adjusted offset.
1657                  Bit 0 can only be set if the upper insn is at a half-word boundary,
1658                  since the destination address, an ARM instruction, must always be
1659                  on a word boundary.  The semantics of the BLX (1) instruction,
1660                  however, are that bit 0 in the offset must always be 0, and the
1661                  corresponding bit 1 in the target address will be set from bit
1662                  1 of the source address.  */
1663               if ((x & 0x18000000) == 0x08000000)
1664                 relocation &= ~0x2;
1665
1666               /* Put the relocation into the correct bits.  */
1667               if (bfd_big_endian (input_bfd))
1668                 relocation = (((relocation & 0xffe) >> 1)  | ((relocation << 4) & 0x07ff0000));
1669               else
1670                 relocation = (((relocation & 0xffe) << 15) | ((relocation >> 12) & 0x7ff));
1671
1672               /* Add the relocation to the correct bits of X.  */
1673               x = ((x & ~howto->dst_mask) | relocation);
1674
1675               /* Put the relocated value back in the object file.  */
1676               bfd_put_32 (input_bfd, x, location);
1677
1678               rstat = overflow ? bfd_reloc_overflow : bfd_reloc_ok;
1679             }
1680         }
1681 #endif
1682       else
1683 #endif /* THUMBEXTENSION */
1684         rstat = _bfd_final_link_relocate (howto, input_bfd, input_section,
1685                                           contents,
1686                                           rel->r_vaddr - input_section->vma,
1687                                           val, addend);
1688 #if 1 /* THUMBEXTENSION */
1689       /* FIXME:
1690          Is this the best way to fix up thumb addresses? krk@cygnus.com
1691          Probably not, but it works, and if it works it don't need fixing!  nickc@cygnus.com */
1692       /* Only perform this fix during the final link, not a relocatable link.  nickc@cygnus.com  */
1693       if (! info->relocateable
1694           && (rel->r_type == ARM_32 || rel->r_type == ARM_RVA32))
1695         {
1696           /* Determine if we need to set the bottom bit of a relocated address
1697              because the address is the address of a Thumb code symbol.  */
1698
1699           int patchit = false;
1700
1701           if (h != NULL
1702               && (   h->class == C_THUMBSTATFUNC
1703                   || h->class == C_THUMBEXTFUNC))
1704             {
1705               patchit = true;
1706             }
1707           else if (sym != NULL
1708                    && sym->n_scnum > N_UNDEF)
1709             {
1710               /* No hash entry - use the symbol instead.  */
1711
1712               if (   sym->n_sclass == C_THUMBSTATFUNC
1713                   || sym->n_sclass == C_THUMBEXTFUNC)
1714                 patchit = true;
1715             }
1716
1717           if (patchit)
1718             {
1719               bfd_byte * location = contents + rel->r_vaddr - input_section->vma;
1720               bfd_vma    x        = bfd_get_32 (input_bfd, location);
1721
1722               bfd_put_32 (input_bfd, x | 1, location);
1723             }
1724         }
1725 #endif /* THUMBEXTENSION */
1726
1727       switch (rstat)
1728         {
1729         default:
1730           abort ();
1731         case bfd_reloc_ok:
1732           break;
1733         case bfd_reloc_outofrange:
1734           (*_bfd_error_handler)
1735             (_("%s: bad reloc address 0x%lx in section `%s'"),
1736              bfd_get_filename (input_bfd),
1737              (unsigned long) rel->r_vaddr,
1738              bfd_get_section_name (input_bfd, input_section));
1739           return false;
1740         case bfd_reloc_overflow:
1741           {
1742             const char *name;
1743             char buf[SYMNMLEN + 1];
1744
1745             if (symndx == -1)
1746               name = "*ABS*";
1747             else if (h != NULL)
1748               name = h->root.root.string;
1749             else
1750               {
1751                 name = _bfd_coff_internal_syment_name (input_bfd, sym, buf);
1752                 if (name == NULL)
1753                   return false;
1754               }
1755
1756             if (! ((*info->callbacks->reloc_overflow)
1757                    (info, name, howto->name, (bfd_vma) 0, input_bfd,
1758                     input_section, rel->r_vaddr - input_section->vma)))
1759               return false;
1760           }
1761         }
1762     }
1763
1764   return true;
1765 }
1766
1767 #ifndef COFF_IMAGE_WITH_PE
1768
1769 boolean
1770 bfd_arm_allocate_interworking_sections (info)
1771      struct bfd_link_info * info;
1772 {
1773   asection *                        s;
1774   bfd_byte *                        foo;
1775   struct coff_arm_link_hash_table * globals;
1776 #if 0
1777   static char                       test_char = '1';
1778 #endif
1779
1780   globals = coff_arm_hash_table (info);
1781
1782   BFD_ASSERT (globals != NULL);
1783
1784   if (globals->arm_glue_size != 0)
1785     {
1786       BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
1787
1788       s = bfd_get_section_by_name
1789         (globals->bfd_of_glue_owner, ARM2THUMB_GLUE_SECTION_NAME);
1790
1791       BFD_ASSERT (s != NULL);
1792
1793       foo = (bfd_byte *) bfd_alloc
1794         (globals->bfd_of_glue_owner, globals->arm_glue_size);
1795 #if 0
1796       memset (foo, test_char, globals->arm_glue_size);
1797 #endif
1798
1799       s->_raw_size = s->_cooked_size = globals->arm_glue_size;
1800       s->contents = foo;
1801     }
1802
1803   if (globals->thumb_glue_size != 0)
1804     {
1805       BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
1806
1807       s = bfd_get_section_by_name
1808         (globals->bfd_of_glue_owner, THUMB2ARM_GLUE_SECTION_NAME);
1809
1810       BFD_ASSERT (s != NULL);
1811
1812       foo = (bfd_byte *) bfd_alloc
1813         (globals->bfd_of_glue_owner, globals->thumb_glue_size);
1814 #if 0
1815       memset (foo, test_char, globals->thumb_glue_size);
1816 #endif
1817
1818       s->_raw_size = s->_cooked_size = globals->thumb_glue_size;
1819       s->contents = foo;
1820     }
1821
1822   return true;
1823 }
1824
1825 static void
1826 record_arm_to_thumb_glue (info, h)
1827      struct bfd_link_info *        info;
1828      struct coff_link_hash_entry * h;
1829 {
1830   const char *                      name = h->root.root.string;
1831   register asection *               s;
1832   char *                            tmp_name;
1833   struct coff_link_hash_entry *     myh;
1834   struct coff_arm_link_hash_table * globals;
1835
1836   globals = coff_arm_hash_table (info);
1837
1838   BFD_ASSERT (globals != NULL);
1839   BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
1840
1841   s = bfd_get_section_by_name
1842     (globals->bfd_of_glue_owner, ARM2THUMB_GLUE_SECTION_NAME);
1843
1844   BFD_ASSERT (s != NULL);
1845
1846   tmp_name = ((char *)
1847               bfd_malloc (strlen (name) + strlen (ARM2THUMB_GLUE_ENTRY_NAME) + 1));
1848
1849   BFD_ASSERT (tmp_name);
1850
1851   sprintf (tmp_name, ARM2THUMB_GLUE_ENTRY_NAME, name);
1852
1853   myh = coff_link_hash_lookup
1854     (coff_hash_table (info), tmp_name, false, false, true);
1855
1856   if (myh != NULL)
1857     {
1858       free (tmp_name);
1859       return; /* we've already seen this guy */
1860     }
1861
1862   /* The only trick here is using globals->arm_glue_size as the value. Even
1863      though the section isn't allocated yet, this is where we will be putting
1864      it.  */
1865
1866   bfd_coff_link_add_one_symbol (info, globals->bfd_of_glue_owner, tmp_name,
1867                                 BSF_GLOBAL,
1868                                 s, globals->arm_glue_size + 1,
1869                                 NULL, true, false,
1870                                 (struct bfd_link_hash_entry **) & myh);
1871
1872   free (tmp_name);
1873
1874   globals->arm_glue_size += ARM2THUMB_GLUE_SIZE;
1875
1876   return;
1877 }
1878
1879 static void
1880 record_thumb_to_arm_glue (info, h)
1881      struct bfd_link_info *        info;
1882      struct coff_link_hash_entry * h;
1883 {
1884   const char *                       name = h->root.root.string;
1885   register asection *                s;
1886   char *                             tmp_name;
1887   struct coff_link_hash_entry *      myh;
1888   struct coff_arm_link_hash_table *  globals;
1889
1890   globals = coff_arm_hash_table (info);
1891
1892   BFD_ASSERT (globals != NULL);
1893   BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
1894
1895   s = bfd_get_section_by_name
1896     (globals->bfd_of_glue_owner, THUMB2ARM_GLUE_SECTION_NAME);
1897
1898   BFD_ASSERT (s != NULL);
1899
1900   tmp_name = (char *) bfd_malloc (strlen (name) + strlen (THUMB2ARM_GLUE_ENTRY_NAME) + 1);
1901
1902   BFD_ASSERT (tmp_name);
1903
1904   sprintf (tmp_name, THUMB2ARM_GLUE_ENTRY_NAME, name);
1905
1906   myh = coff_link_hash_lookup
1907     (coff_hash_table (info), tmp_name, false, false, true);
1908
1909   if (myh != NULL)
1910     {
1911       free (tmp_name);
1912       return; /* we've already seen this guy */
1913     }
1914
1915   bfd_coff_link_add_one_symbol (info, globals->bfd_of_glue_owner, tmp_name,
1916                                 BSF_GLOBAL, s, globals->thumb_glue_size + 1,
1917                                 NULL, true, false,
1918                                 (struct bfd_link_hash_entry **) & myh);
1919
1920   /* If we mark it 'thumb', the disassembler will do a better job.  */
1921   myh->class = C_THUMBEXTFUNC;
1922
1923   free (tmp_name);
1924
1925   /* Allocate another symbol to mark where we switch to arm mode.  */
1926
1927 #define CHANGE_TO_ARM "__%s_change_to_arm"
1928 #define BACK_FROM_ARM "__%s_back_from_arm"
1929
1930   tmp_name = (char *) bfd_malloc (strlen (name) + strlen (CHANGE_TO_ARM) + 1);
1931
1932   BFD_ASSERT (tmp_name);
1933
1934   sprintf (tmp_name, globals->support_old_code ? BACK_FROM_ARM : CHANGE_TO_ARM, name);
1935
1936   myh = NULL;
1937
1938   bfd_coff_link_add_one_symbol (info, globals->bfd_of_glue_owner, tmp_name,
1939                                 BSF_LOCAL, s, globals->thumb_glue_size
1940                                 + (globals->support_old_code ? 8 : 4),
1941                                 NULL, true, false,
1942                                 (struct bfd_link_hash_entry **) & myh);
1943
1944   free (tmp_name);
1945
1946   globals->thumb_glue_size += THUMB2ARM_GLUE_SIZE;
1947
1948   return;
1949 }
1950
1951 /* Select a BFD to be used to hold the sections used by the glue code.
1952    This function is called from the linker scripts in ld/emultempl/
1953    {armcoff/pe}.em  */
1954
1955 boolean
1956 bfd_arm_get_bfd_for_interworking (abfd, info)
1957      bfd *                  abfd;
1958      struct bfd_link_info * info;
1959 {
1960   struct coff_arm_link_hash_table * globals;
1961   flagword                          flags;
1962   asection *                        sec;
1963
1964   /* If we are only performing a partial link do not bother
1965      getting a bfd to hold the glue.  */
1966   if (info->relocateable)
1967     return true;
1968
1969   globals = coff_arm_hash_table (info);
1970
1971   BFD_ASSERT (globals != NULL);
1972
1973   if (globals->bfd_of_glue_owner != NULL)
1974     return true;
1975
1976   sec = bfd_get_section_by_name (abfd, ARM2THUMB_GLUE_SECTION_NAME);
1977
1978   if (sec == NULL)
1979     {
1980       flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_CODE | SEC_READONLY;
1981
1982       sec = bfd_make_section (abfd, ARM2THUMB_GLUE_SECTION_NAME);
1983
1984       if (sec == NULL
1985           || ! bfd_set_section_flags (abfd, sec, flags)
1986           || ! bfd_set_section_alignment (abfd, sec, 2))
1987         return false;
1988     }
1989
1990   sec = bfd_get_section_by_name (abfd, THUMB2ARM_GLUE_SECTION_NAME);
1991
1992   if (sec == NULL)
1993     {
1994       flags = SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_CODE | SEC_READONLY;
1995
1996       sec = bfd_make_section (abfd, THUMB2ARM_GLUE_SECTION_NAME);
1997
1998       if (sec == NULL
1999           || ! bfd_set_section_flags (abfd, sec, flags)
2000           || ! bfd_set_section_alignment (abfd, sec, 2))
2001         return false;
2002     }
2003
2004   /* Save the bfd for later use.  */
2005   globals->bfd_of_glue_owner = abfd;
2006
2007   return true;
2008 }
2009
2010 boolean
2011 bfd_arm_process_before_allocation (abfd, info, support_old_code)
2012      bfd *                   abfd;
2013      struct bfd_link_info *  info;
2014      int                     support_old_code;
2015 {
2016   asection * sec;
2017   struct coff_arm_link_hash_table * globals;
2018
2019   /* If we are only performing a partial link do not bother
2020      to construct any glue.  */
2021   if (info->relocateable)
2022     return true;
2023
2024   /* Here we have a bfd that is to be included on the link.  We have a hook
2025      to do reloc rummaging, before section sizes are nailed down.  */
2026
2027   _bfd_coff_get_external_symbols (abfd);
2028
2029   globals = coff_arm_hash_table (info);
2030
2031   BFD_ASSERT (globals != NULL);
2032   BFD_ASSERT (globals->bfd_of_glue_owner != NULL);
2033
2034   globals->support_old_code = support_old_code;
2035
2036   /* Rummage around all the relocs and map the glue vectors.  */
2037   sec = abfd->sections;
2038
2039   if (sec == NULL)
2040     return true;
2041
2042   for (; sec != NULL; sec = sec->next)
2043     {
2044       struct internal_reloc * i;
2045       struct internal_reloc * rel;
2046
2047       if (sec->reloc_count == 0)
2048         continue;
2049
2050       /* Load the relocs.  */
2051       /* FIXME: there may be a storage leak here.  */
2052
2053       i = _bfd_coff_read_internal_relocs (abfd, sec, 1, 0, 0, 0);
2054
2055       BFD_ASSERT (i != 0);
2056
2057       for (rel = i; rel < i + sec->reloc_count; ++rel)
2058         {
2059           unsigned short                 r_type  = rel->r_type;
2060           long                           symndx;
2061           struct coff_link_hash_entry *  h;
2062
2063           symndx = rel->r_symndx;
2064
2065           /* If the relocation is not against a symbol it cannot concern us.  */
2066           if (symndx == -1)
2067             continue;
2068
2069           /* If the index is outside of the range of our table, something has gone wrong.  */
2070           if (symndx >= obj_conv_table_size (abfd))
2071             {
2072               _bfd_error_handler (_("%s: illegal symbol index in reloc: %d"),
2073                                   bfd_get_filename (abfd), symndx);
2074               continue;
2075             }
2076
2077           h = obj_coff_sym_hashes (abfd)[symndx];
2078
2079           /* If the relocation is against a static symbol it must be within
2080              the current section and so cannot be a cross ARM/Thumb relocation.  */
2081           if (h == NULL)
2082             continue;
2083
2084           switch (r_type)
2085             {
2086             case ARM_26:
2087               /* This one is a call from arm code.  We need to look up
2088                  the target of the call. If it is a thumb target, we
2089                  insert glue.  */
2090
2091               if (h->class == C_THUMBEXTFUNC)
2092                 record_arm_to_thumb_glue (info, h);
2093               break;
2094
2095 #ifndef ARM_WINCE
2096             case ARM_THUMB23:
2097               /* This one is a call from thumb code.  We used to look
2098                  for ARM_THUMB9 and ARM_THUMB12 as well.  We need to look
2099                  up the target of the call. If it is an arm target, we
2100                  insert glue.  If the symbol does not exist it will be
2101                  given a class of C_EXT and so we will generate a stub
2102                  for it.  This is not really a problem, since the link
2103                  is doomed anyway.  */
2104
2105               switch (h->class)
2106                 {
2107                 case C_EXT:
2108                 case C_STAT:
2109                 case C_LABEL:
2110                   record_thumb_to_arm_glue (info, h);
2111                   break;
2112                 default:
2113                   ;
2114                 }
2115               break;
2116 #endif
2117
2118             default:
2119               break;
2120             }
2121         }
2122     }
2123
2124   return true;
2125 }
2126
2127 #endif /* ! defined (COFF_IMAGE_WITH_PE) */
2128
2129 #define coff_bfd_reloc_type_lookup              coff_arm_reloc_type_lookup
2130 #define coff_relocate_section                   coff_arm_relocate_section
2131 #define coff_bfd_is_local_label_name            coff_arm_is_local_label_name
2132 #define coff_adjust_symndx                      coff_arm_adjust_symndx
2133 #define coff_link_output_has_begun              coff_arm_link_output_has_begun
2134 #define coff_final_link_postscript              coff_arm_final_link_postscript
2135 #define coff_bfd_merge_private_bfd_data         coff_arm_merge_private_bfd_data
2136 #define coff_bfd_print_private_bfd_data         coff_arm_print_private_bfd_data
2137 #define coff_bfd_set_private_flags              _bfd_coff_arm_set_private_flags
2138 #define coff_bfd_copy_private_bfd_data          coff_arm_copy_private_bfd_data
2139 #define coff_bfd_link_hash_table_create         coff_arm_link_hash_table_create
2140
2141 /* When doing a relocateable link, we want to convert ARM26 relocs
2142    into ARM26D relocs.  */
2143
2144 static boolean
2145 coff_arm_adjust_symndx (obfd, info, ibfd, sec, irel, adjustedp)
2146      bfd *obfd ATTRIBUTE_UNUSED;
2147      struct bfd_link_info *info ATTRIBUTE_UNUSED;
2148      bfd *ibfd;
2149      asection *sec;
2150      struct internal_reloc *irel;
2151      boolean *adjustedp;
2152 {
2153   if (irel->r_type == 3)
2154     {
2155       struct coff_link_hash_entry *h;
2156
2157       h = obj_coff_sym_hashes (ibfd)[irel->r_symndx];
2158       if (h != NULL
2159           && (h->root.type == bfd_link_hash_defined
2160               || h->root.type == bfd_link_hash_defweak)
2161           && h->root.u.def.section->output_section == sec->output_section)
2162         irel->r_type = 7;
2163     }
2164   *adjustedp = false;
2165   return true;
2166 }
2167
2168 /* Called when merging the private data areas of two BFDs.
2169    This is important as it allows us to detect if we are
2170    attempting to merge binaries compiled for different ARM
2171    targets, eg different CPUs or differents APCS's.     */
2172
2173 static boolean
2174 coff_arm_merge_private_bfd_data (ibfd, obfd)
2175      bfd *   ibfd;
2176      bfd *   obfd;
2177 {
2178   BFD_ASSERT (ibfd != NULL && obfd != NULL);
2179
2180   if (ibfd == obfd)
2181     return true;
2182
2183   /* If the two formats are different we cannot merge anything.
2184      This is not an error, since it is permissable to change the
2185      input and output formats.  */
2186   if (   ibfd->xvec->flavour != bfd_target_coff_flavour
2187       || obfd->xvec->flavour != bfd_target_coff_flavour)
2188     return true;
2189
2190   /* Verify that the APCS is the same for the two BFDs */
2191   if (APCS_SET (ibfd))
2192     {
2193       if (APCS_SET (obfd))
2194         {
2195           /* If the src and dest have different APCS flag bits set, fail.  */
2196           if (APCS_26_FLAG (obfd) != APCS_26_FLAG (ibfd))
2197             {
2198               _bfd_error_handler
2199                 /* xgettext: c-format */
2200                 (_("%s: ERROR: compiled for APCS-%d whereas target %s uses APCS-%d"),
2201                  bfd_get_filename (ibfd), APCS_26_FLAG (ibfd) ? 26 : 32,
2202                  bfd_get_filename (obfd), APCS_26_FLAG (obfd) ? 26 : 32
2203                  );
2204
2205               bfd_set_error (bfd_error_wrong_format);
2206               return false;
2207             }
2208
2209           if (APCS_FLOAT_FLAG (obfd) != APCS_FLOAT_FLAG (ibfd))
2210             {
2211               const char *msg;
2212
2213               if (APCS_FLOAT_FLAG (ibfd))
2214                 /* xgettext: c-format */
2215                 msg = _("%s: ERROR: passes floats in float registers whereas target %s uses integer registers");
2216               else
2217                 /* xgettext: c-format */
2218                 msg = _("%s: ERROR: passes floats in integer registers whereas target %s uses float registers");
2219
2220               _bfd_error_handler (msg, bfd_get_filename (ibfd),
2221                                   bfd_get_filename (obfd));
2222
2223               bfd_set_error (bfd_error_wrong_format);
2224               return false;
2225             }
2226
2227           if (PIC_FLAG (obfd) != PIC_FLAG (ibfd))
2228             {
2229               const char * msg;
2230
2231               if (PIC_FLAG (ibfd))
2232                 /* xgettext: c-format */
2233                 msg = _("%s: ERROR: compiled as position independent code, whereas target %s is absolute position");
2234               else
2235                 /* xgettext: c-format */
2236                 msg = _("%s: ERROR: compiled as absolute position code, whereas target %s is position independent");
2237               _bfd_error_handler (msg, bfd_get_filename (ibfd),
2238                                   bfd_get_filename (obfd));
2239
2240               bfd_set_error (bfd_error_wrong_format);
2241               return false;
2242             }
2243         }
2244       else
2245         {
2246           SET_APCS_FLAGS (obfd, APCS_26_FLAG (ibfd) | APCS_FLOAT_FLAG (ibfd) | PIC_FLAG (ibfd));
2247
2248           /* Set up the arch and fields as well as these are probably wrong.  */
2249           bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
2250         }
2251     }
2252
2253   /* Check the interworking support.  */
2254   if (INTERWORK_SET (ibfd))
2255     {
2256       if (INTERWORK_SET (obfd))
2257         {
2258           /* If the src and dest differ in their interworking issue a warning.  */
2259           if (INTERWORK_FLAG (obfd) != INTERWORK_FLAG (ibfd))
2260             {
2261               const char * msg;
2262
2263               if (INTERWORK_FLAG (ibfd))
2264                 /* xgettext: c-format */
2265                 msg = _("Warning: input file %s supports interworking, whereas %s does not.");
2266               else
2267                 /* xgettext: c-format */
2268                 msg = _("Warning: input file %s does not support interworking, whereas %s does.");
2269
2270               _bfd_error_handler (msg, bfd_get_filename (ibfd),
2271                                   bfd_get_filename (obfd));
2272             }
2273         }
2274       else
2275         {
2276           SET_INTERWORK_FLAG (obfd, INTERWORK_FLAG (ibfd));
2277         }
2278     }
2279
2280   return true;
2281 }
2282
2283 /* Display the flags field.  */
2284
2285 static boolean
2286 coff_arm_print_private_bfd_data (abfd, ptr)
2287      bfd *   abfd;
2288      PTR     ptr;
2289 {
2290   FILE * file = (FILE *) ptr;
2291
2292   BFD_ASSERT (abfd != NULL && ptr != NULL);
2293
2294   /* xgettext:c-format */
2295   fprintf (file, _("private flags = %x:"), coff_data (abfd)->flags);
2296
2297   if (APCS_SET (abfd))
2298     {
2299       /* xgettext: APCS is ARM Prodecure Call Standard, it should not be translated.  */
2300       fprintf (file, " [APCS-%d]", APCS_26_FLAG (abfd) ? 26 : 32);
2301
2302       if (APCS_FLOAT_FLAG (abfd))
2303         fprintf (file, _(" [floats passed in float registers]"));
2304       else
2305         fprintf (file, _(" [floats passed in integer registers]"));
2306
2307       if (PIC_FLAG (abfd))
2308         fprintf (file, _(" [position independent]"));
2309       else
2310         fprintf (file, _(" [absolute position]"));
2311     }
2312
2313   if (! INTERWORK_SET (abfd))
2314     fprintf (file, _(" [interworking flag not initialised]"));
2315   else if (INTERWORK_FLAG (abfd))
2316     fprintf (file, _(" [interworking supported]"));
2317   else
2318     fprintf (file, _(" [interworking not supported]"));
2319
2320   fputc ('\n', file);
2321
2322   return true;
2323 }
2324
2325 /* Copies the given flags into the coff_tdata.flags field.
2326    Typically these flags come from the f_flags[] field of
2327    the COFF filehdr structure, which contains important,
2328    target specific information.
2329    Note: Although this function is static, it is explicitly
2330    called from both coffcode.h and peicode.h.  */
2331
2332 static boolean
2333 _bfd_coff_arm_set_private_flags (abfd, flags)
2334         bfd *      abfd;
2335         flagword   flags;
2336 {
2337   flagword flag;
2338
2339   BFD_ASSERT (abfd != NULL);
2340
2341   flag = (flags & F_APCS26) ? F_APCS_26 : 0;
2342
2343   /* Make sure that the APCS field has not been initialised to the opposite
2344      value.  */
2345   if (APCS_SET (abfd)
2346       && (   (APCS_26_FLAG    (abfd) != flag)
2347           || (APCS_FLOAT_FLAG (abfd) != (flags & F_APCS_FLOAT))
2348           || (PIC_FLAG        (abfd) != (flags & F_PIC))
2349           ))
2350     return false;
2351
2352   flag |= (flags & (F_APCS_FLOAT | F_PIC));
2353
2354   SET_APCS_FLAGS (abfd, flag);
2355
2356   flag = (flags & F_INTERWORK);
2357
2358   /* If the BFD has already had its interworking flag set, but it
2359      is different from the value that we have been asked to set,
2360      then assume that that merged code will not support interworking
2361      and set the flag accordingly.  */
2362   if (INTERWORK_SET (abfd) && (INTERWORK_FLAG (abfd) != flag))
2363     {
2364       if (flag)
2365         /* xgettext: c-format */
2366         _bfd_error_handler (_("Warning: Not setting interworking flag of %s, since it has already been specified as non-interworking"),
2367                             bfd_get_filename (abfd));
2368       else
2369         /* xgettext: c-format */
2370         _bfd_error_handler (_("Warning: Clearing the interworking flag of %s due to outside request"),
2371                             bfd_get_filename (abfd));
2372       flag = 0;
2373     }
2374
2375   SET_INTERWORK_FLAG (abfd, flag);
2376
2377   return true;
2378 }
2379
2380 /* Copy the important parts of the target specific data
2381    from one instance of a BFD to another.  */
2382
2383 static boolean
2384 coff_arm_copy_private_bfd_data (src, dest)
2385      bfd *  src;
2386      bfd *  dest;
2387 {
2388   BFD_ASSERT (src != NULL && dest != NULL);
2389
2390   if (src == dest)
2391     return true;
2392
2393   /* If the destination is not in the same format as the source, do not do
2394      the copy.  */
2395   if (src->xvec != dest->xvec)
2396     return true;
2397
2398   /* copy the flags field */
2399   if (APCS_SET (src))
2400     {
2401       if (APCS_SET (dest))
2402         {
2403           /* If the src and dest have different APCS flag bits set, fail.  */
2404           if (APCS_26_FLAG (dest) != APCS_26_FLAG (src))
2405             return false;
2406
2407           if (APCS_FLOAT_FLAG (dest) != APCS_FLOAT_FLAG (src))
2408             return false;
2409
2410           if (PIC_FLAG (dest) != PIC_FLAG (src))
2411             return false;
2412         }
2413       else
2414         SET_APCS_FLAGS (dest, APCS_26_FLAG (src) | APCS_FLOAT_FLAG (src)
2415                         | PIC_FLAG (src));
2416     }
2417
2418   if (INTERWORK_SET (src))
2419     {
2420       if (INTERWORK_SET (dest))
2421         {
2422           /* If the src and dest have different interworking flags then turn
2423              off the interworking bit.  */
2424           if (INTERWORK_FLAG (dest) != INTERWORK_FLAG (src))
2425             {
2426               if (INTERWORK_FLAG (dest))
2427                 {
2428                   /* xgettext:c-format */
2429                   _bfd_error_handler (("Warning: Clearing the interworking bit of %s, because the non-interworking code in %s has been copied into it"),
2430                                       bfd_get_filename (dest),
2431                                       bfd_get_filename (src));
2432                 }
2433
2434               SET_INTERWORK_FLAG (dest, 0);
2435             }
2436         }
2437       else
2438         {
2439           SET_INTERWORK_FLAG (dest, INTERWORK_FLAG (src));
2440         }
2441     }
2442
2443   return true;
2444 }
2445
2446 /* Note:  the definitions here of LOCAL_LABEL_PREFIX and USER_LABEL_PREIFX
2447    *must* match the definitions in gcc/config/arm/{coff|semi|aout}.h.  */
2448 #define LOCAL_LABEL_PREFIX ""
2449 #ifndef USER_LABEL_PREFIX
2450 #define USER_LABEL_PREFIX "_"
2451 #endif
2452
2453 /* Like _bfd_coff_is_local_label_name, but
2454    a) test against USER_LABEL_PREFIX, to avoid stripping labels known to be
2455       non-local.
2456    b) Allow other prefixes than ".", e.g. an empty prefix would cause all
2457       labels of the form Lxxx to be stripped.  */
2458 static boolean
2459 coff_arm_is_local_label_name (abfd, name)
2460      bfd *        abfd ATTRIBUTE_UNUSED;
2461      const char * name;
2462 {
2463 #ifdef USER_LABEL_PREFIX
2464   if (USER_LABEL_PREFIX[0] != 0)
2465     {
2466       if (strncmp (name, USER_LABEL_PREFIX, strlen (USER_LABEL_PREFIX)) == 0)
2467         return false;
2468     }
2469 #endif
2470
2471 #ifdef LOCAL_LABEL_PREFIX
2472   /* If there is a prefix for local labels then look for this.
2473      If the prefix exists, but it is empty, then ignore the test.  */
2474
2475   if (LOCAL_LABEL_PREFIX[0] != 0)
2476     {
2477       int len = strlen (LOCAL_LABEL_PREFIX);
2478
2479       if (strncmp (name, LOCAL_LABEL_PREFIX, len) != 0)
2480         return false;
2481
2482       /* Perform the checks below for the rest of the name.  */
2483       name += len;
2484     }
2485 #endif
2486
2487   return name[0] == 'L';
2488 }
2489
2490 /* This piece of machinery exists only to guarantee that the bfd that holds
2491    the glue section is written last.
2492
2493    This does depend on bfd_make_section attaching a new section to the
2494    end of the section list for the bfd.
2495
2496    krk@cygnus.com  */
2497
2498 static boolean
2499 coff_arm_link_output_has_begun (sub, info)
2500      bfd * sub;
2501      struct coff_final_link_info * info;
2502 {
2503   return (sub->output_has_begun
2504           || sub == coff_arm_hash_table (info->info)->bfd_of_glue_owner);
2505 }
2506
2507 static boolean
2508 coff_arm_final_link_postscript (abfd, pfinfo)
2509      bfd * abfd ATTRIBUTE_UNUSED;
2510      struct coff_final_link_info * pfinfo;
2511 {
2512   struct coff_arm_link_hash_table * globals;
2513
2514   globals = coff_arm_hash_table (pfinfo->info);
2515
2516   BFD_ASSERT (globals != NULL);
2517
2518   if (globals->bfd_of_glue_owner != NULL)
2519     {
2520       if (! _bfd_coff_link_input_bfd (pfinfo, globals->bfd_of_glue_owner))
2521         return false;
2522
2523       globals->bfd_of_glue_owner->output_has_begun = true;
2524     }
2525
2526   return true;
2527 }
2528
2529 #include "coffcode.h"
2530
2531 #ifndef TARGET_LITTLE_SYM
2532 #define TARGET_LITTLE_SYM armcoff_little_vec
2533 #endif
2534 #ifndef TARGET_LITTLE_NAME
2535 #define TARGET_LITTLE_NAME "coff-arm-little"
2536 #endif
2537 #ifndef TARGET_BIG_SYM
2538 #define TARGET_BIG_SYM armcoff_big_vec
2539 #endif
2540 #ifndef TARGET_BIG_NAME
2541 #define TARGET_BIG_NAME "coff-arm-big"
2542 #endif
2543
2544 #ifndef TARGET_UNDERSCORE
2545 #define TARGET_UNDERSCORE 0
2546 #endif
2547
2548 #ifndef EXTRA_S_FLAGS
2549 #ifdef COFF_WITH_PE
2550 #define EXTRA_S_FLAGS (SEC_LINK_ONCE | SEC_LINK_DUPLICATES)
2551 #else
2552 #define EXTRA_S_FLAGS 0
2553 #endif
2554 #endif
2555
2556 /* Forward declaration for use initialising alternative_target field.  */
2557 extern const bfd_target TARGET_BIG_SYM ;
2558
2559 /* Target vectors.  */
2560 CREATE_LITTLE_COFF_TARGET_VEC (TARGET_LITTLE_SYM, TARGET_LITTLE_NAME, D_PAGED, EXTRA_S_FLAGS, TARGET_UNDERSCORE, & TARGET_BIG_SYM)
2561 CREATE_BIG_COFF_TARGET_VEC (TARGET_BIG_SYM, TARGET_BIG_NAME, D_PAGED, EXTRA_S_FLAGS, TARGET_UNDERSCORE, & TARGET_LITTLE_SYM)