bfd/coff-arm.c

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