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