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