bfd/coff-arm.c

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