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