bfd/coff-arm.c

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