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