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