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