1/* MSP430-specific support for 32-bit ELF 2 Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc. 3 Contributed by Dmitry Diky <diwil@mail.ru> 4 5 This file is part of BFD, the Binary File Descriptor library. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 2 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program; if not, write to the Free Software 19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ 20 21#include "bfd.h" 22#include "sysdep.h" 23#include "libiberty.h" 24#include "libbfd.h" 25#include "elf-bfd.h" 26#include "elf/msp430.h" 27 28/* Use RELA instead of REL. */ 29#undef USE_REL 30 31static reloc_howto_type elf_msp430_howto_table[] = 32{ 33 HOWTO (R_MSP430_NONE, /* type */ 34 0, /* rightshift */ 35 2, /* size (0 = byte, 1 = short, 2 = long) */ 36 32, /* bitsize */ 37 FALSE, /* pc_relative */ 38 0, /* bitpos */ 39 complain_overflow_bitfield,/* complain_on_overflow */ 40 bfd_elf_generic_reloc, /* special_function */ 41 "R_MSP430_NONE", /* name */ 42 FALSE, /* partial_inplace */ 43 0, /* src_mask */ 44 0, /* dst_mask */ 45 FALSE), /* pcrel_offset */ 46 47 HOWTO (R_MSP430_32, /* type */ 48 0, /* rightshift */ 49 2, /* size (0 = byte, 1 = short, 2 = long) */ 50 32, /* bitsize */ 51 FALSE, /* pc_relative */ 52 0, /* bitpos */ 53 complain_overflow_bitfield,/* complain_on_overflow */ 54 bfd_elf_generic_reloc, /* special_function */ 55 "R_MSP430_32", /* name */ 56 FALSE, /* partial_inplace */ 57 0xffffffff, /* src_mask */ 58 0xffffffff, /* dst_mask */ 59 FALSE), /* pcrel_offset */ 60 61 /* A 13 bit PC relative relocation. */ 62 HOWTO (R_MSP430_10_PCREL, /* type */ 63 1, /* rightshift */ 64 1, /* size (0 = byte, 1 = short, 2 = long) */ 65 10, /* bitsize */ 66 TRUE, /* pc_relative */ 67 0, /* bitpos */ 68 complain_overflow_bitfield,/* complain_on_overflow */ 69 bfd_elf_generic_reloc, /* special_function */ 70 "R_MSP430_13_PCREL", /* name */ 71 FALSE, /* partial_inplace */ 72 0xfff, /* src_mask */ 73 0xfff, /* dst_mask */ 74 TRUE), /* pcrel_offset */ 75 76 /* A 16 bit absolute relocation. */ 77 HOWTO (R_MSP430_16, /* type */ 78 0, /* rightshift */ 79 1, /* size (0 = byte, 1 = short, 2 = long) */ 80 16, /* bitsize */ 81 FALSE, /* pc_relative */ 82 0, /* bitpos */ 83 complain_overflow_dont,/* complain_on_overflow */ 84 bfd_elf_generic_reloc, /* special_function */ 85 "R_MSP430_16", /* name */ 86 FALSE, /* partial_inplace */ 87 0, /* src_mask */ 88 0xffff, /* dst_mask */ 89 FALSE), /* pcrel_offset */ 90 91 /* A 16 bit absolute relocation for command address. */ 92 HOWTO (R_MSP430_16_PCREL, /* type */ 93 1, /* rightshift */ 94 1, /* size (0 = byte, 1 = short, 2 = long) */ 95 16, /* bitsize */ 96 TRUE, /* pc_relative */ 97 0, /* bitpos */ 98 complain_overflow_dont,/* complain_on_overflow */ 99 bfd_elf_generic_reloc, /* special_function */ 100 "R_MSP430_16_PCREL", /* name */ 101 FALSE, /* partial_inplace */ 102 0, /* src_mask */ 103 0xffff, /* dst_mask */ 104 TRUE), /* pcrel_offset */ 105 106 /* A 16 bit absolute relocation, byte operations. */ 107 HOWTO (R_MSP430_16_BYTE, /* type */ 108 0, /* rightshift */ 109 1, /* size (0 = byte, 1 = short, 2 = long) */ 110 16, /* bitsize */ 111 FALSE, /* pc_relative */ 112 0, /* bitpos */ 113 complain_overflow_dont,/* complain_on_overflow */ 114 bfd_elf_generic_reloc, /* special_function */ 115 "R_MSP430_16_BYTE", /* name */ 116 FALSE, /* partial_inplace */ 117 0xffff, /* src_mask */ 118 0xffff, /* dst_mask */ 119 FALSE), /* pcrel_offset */ 120 121 /* A 16 bit absolute relocation for command address. */ 122 HOWTO (R_MSP430_16_PCREL_BYTE,/* type */ 123 1, /* rightshift */ 124 1, /* size (0 = byte, 1 = short, 2 = long) */ 125 16, /* bitsize */ 126 TRUE, /* pc_relative */ 127 0, /* bitpos */ 128 complain_overflow_dont,/* complain_on_overflow */ 129 bfd_elf_generic_reloc, /* special_function */ 130 "R_MSP430_16_PCREL_BYTE",/* name */ 131 FALSE, /* partial_inplace */ 132 0xffff, /* src_mask */ 133 0xffff, /* dst_mask */ 134 TRUE), /* pcrel_offset */ 135 136 /* A 13 bit PC relative relocation for complicated polymorphs. */ 137 HOWTO (R_MSP430_2X_PCREL, /* type */ 138 1, /* rightshift */ 139 2, /* size (0 = byte, 1 = short, 2 = long) */ 140 10, /* bitsize */ 141 TRUE, /* pc_relative */ 142 0, /* bitpos */ 143 complain_overflow_bitfield,/* complain_on_overflow */ 144 bfd_elf_generic_reloc, /* special_function */ 145 "R_MSP430_2X_PCREL", /* name */ 146 FALSE, /* partial_inplace */ 147 0xfff, /* src_mask */ 148 0xfff, /* dst_mask */ 149 TRUE), /* pcrel_offset */ 150 151 /* A 16 bit relaxable relocation for command address. */ 152 HOWTO (R_MSP430_RL_PCREL, /* type */ 153 1, /* rightshift */ 154 1, /* size (0 = byte, 1 = short, 2 = long) */ 155 16, /* bitsize */ 156 TRUE, /* pc_relative */ 157 0, /* bitpos */ 158 complain_overflow_dont,/* complain_on_overflow */ 159 bfd_elf_generic_reloc, /* special_function */ 160 "R_MSP430_RL_PCREL", /* name */ 161 FALSE, /* partial_inplace */ 162 0, /* src_mask */ 163 0xffff, /* dst_mask */ 164 TRUE) /* pcrel_offset */ 165}; 166 167/* Map BFD reloc types to MSP430 ELF reloc types. */ 168 169struct msp430_reloc_map 170{ 171 bfd_reloc_code_real_type bfd_reloc_val; 172 unsigned int elf_reloc_val; 173}; 174 175static const struct msp430_reloc_map msp430_reloc_map[] = 176 { 177 {BFD_RELOC_NONE, R_MSP430_NONE}, 178 {BFD_RELOC_32, R_MSP430_32}, 179 {BFD_RELOC_MSP430_10_PCREL, R_MSP430_10_PCREL}, 180 {BFD_RELOC_16, R_MSP430_16_BYTE}, 181 {BFD_RELOC_MSP430_16_PCREL, R_MSP430_16_PCREL}, 182 {BFD_RELOC_MSP430_16, R_MSP430_16}, 183 {BFD_RELOC_MSP430_16_PCREL_BYTE, R_MSP430_16_PCREL_BYTE}, 184 {BFD_RELOC_MSP430_16_BYTE, R_MSP430_16_BYTE}, 185 {BFD_RELOC_MSP430_2X_PCREL, R_MSP430_2X_PCREL}, 186 {BFD_RELOC_MSP430_RL_PCREL, R_MSP430_RL_PCREL} 187 }; 188 189static reloc_howto_type * 190bfd_elf32_bfd_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED, 191 bfd_reloc_code_real_type code) 192{ 193 unsigned int i; 194 195 for (i = 0; i < ARRAY_SIZE (msp430_reloc_map); i++) 196 if (msp430_reloc_map[i].bfd_reloc_val == code) 197 return &elf_msp430_howto_table[msp430_reloc_map[i].elf_reloc_val]; 198 199 return NULL; 200} 201 202/* Set the howto pointer for an MSP430 ELF reloc. */ 203 204static void 205msp430_info_to_howto_rela (bfd * abfd ATTRIBUTE_UNUSED, 206 arelent * cache_ptr, 207 Elf_Internal_Rela * dst) 208{ 209 unsigned int r_type; 210 211 r_type = ELF32_R_TYPE (dst->r_info); 212 BFD_ASSERT (r_type < (unsigned int) R_MSP430_max); 213 cache_ptr->howto = &elf_msp430_howto_table[r_type]; 214} 215 216static asection * 217elf32_msp430_gc_mark_hook (asection * sec, 218 struct bfd_link_info * info ATTRIBUTE_UNUSED, 219 Elf_Internal_Rela * rel, 220 struct elf_link_hash_entry * h, 221 Elf_Internal_Sym * sym) 222{ 223 if (h != NULL) 224 { 225 switch (ELF32_R_TYPE (rel->r_info)) 226 { 227 default: 228 switch (h->root.type) 229 { 230 case bfd_link_hash_defined: 231 case bfd_link_hash_defweak: 232 return h->root.u.def.section; 233 234 case bfd_link_hash_common: 235 return h->root.u.c.p->section; 236 237 default: 238 break; 239 } 240 } 241 } 242 else 243 return bfd_section_from_elf_index (sec->owner, sym->st_shndx); 244 245 return NULL; 246} 247 248static bfd_boolean 249elf32_msp430_gc_sweep_hook (bfd * abfd ATTRIBUTE_UNUSED, 250 struct bfd_link_info * info ATTRIBUTE_UNUSED, 251 asection * sec ATTRIBUTE_UNUSED, 252 const Elf_Internal_Rela * relocs ATTRIBUTE_UNUSED) 253{ 254 /* We don't use got and plt entries for msp430. */ 255 return TRUE; 256} 257 258/* Look through the relocs for a section during the first phase. 259 Since we don't do .gots or .plts, we just need to consider the 260 virtual table relocs for gc. */ 261 262static bfd_boolean 263elf32_msp430_check_relocs (bfd * abfd, struct bfd_link_info * info, 264 asection * sec, const Elf_Internal_Rela * relocs) 265{ 266 Elf_Internal_Shdr *symtab_hdr; 267 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end; 268 const Elf_Internal_Rela *rel; 269 const Elf_Internal_Rela *rel_end; 270 271 if (info->relocatable) 272 return TRUE; 273 274 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 275 sym_hashes = elf_sym_hashes (abfd); 276 sym_hashes_end = 277 sym_hashes + symtab_hdr->sh_size / sizeof (Elf32_External_Sym); 278 if (!elf_bad_symtab (abfd)) 279 sym_hashes_end -= symtab_hdr->sh_info; 280 281 rel_end = relocs + sec->reloc_count; 282 for (rel = relocs; rel < rel_end; rel++) 283 { 284 struct elf_link_hash_entry *h; 285 unsigned long r_symndx; 286 287 r_symndx = ELF32_R_SYM (rel->r_info); 288 if (r_symndx < symtab_hdr->sh_info) 289 h = NULL; 290 else 291 { 292 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 293 while (h->root.type == bfd_link_hash_indirect 294 || h->root.type == bfd_link_hash_warning) 295 h = (struct elf_link_hash_entry *) h->root.u.i.link; 296 } 297 } 298 299 return TRUE; 300} 301 302/* Perform a single relocation. By default we use the standard BFD 303 routines, but a few relocs, we have to do them ourselves. */ 304 305static bfd_reloc_status_type 306msp430_final_link_relocate (reloc_howto_type * howto, bfd * input_bfd, 307 asection * input_section, bfd_byte * contents, 308 Elf_Internal_Rela * rel, bfd_vma relocation) 309{ 310 bfd_reloc_status_type r = bfd_reloc_ok; 311 bfd_vma x; 312 bfd_signed_vma srel; 313 314 switch (howto->type) 315 { 316 case R_MSP430_10_PCREL: 317 contents += rel->r_offset; 318 srel = (bfd_signed_vma) relocation; 319 srel += rel->r_addend; 320 srel -= rel->r_offset; 321 srel -= 2; /* Branch instructions add 2 to the PC... */ 322 srel -= (input_section->output_section->vma + 323 input_section->output_offset); 324 325 if (srel & 1) 326 return bfd_reloc_outofrange; 327 328 /* MSP430 addresses commands as words. */ 329 srel >>= 1; 330 331 /* Check for an overflow. */ 332 if (srel < -512 || srel > 511) 333 return bfd_reloc_overflow; 334 335 x = bfd_get_16 (input_bfd, contents); 336 x = (x & 0xfc00) | (srel & 0x3ff); 337 bfd_put_16 (input_bfd, x, contents); 338 break; 339 340 case R_MSP430_2X_PCREL: 341 contents += rel->r_offset; 342 srel = (bfd_signed_vma) relocation; 343 srel += rel->r_addend; 344 srel -= rel->r_offset; 345 srel -= 2; /* Branch instructions add 2 to the PC... */ 346 srel -= (input_section->output_section->vma + 347 input_section->output_offset); 348 349 if (srel & 1) 350 return bfd_reloc_outofrange; 351 352 /* MSP430 addresses commands as words. */ 353 srel >>= 1; 354 355 /* Check for an overflow. */ 356 if (srel < -512 || srel > 511) 357 return bfd_reloc_overflow; 358 359 x = bfd_get_16 (input_bfd, contents); 360 x = (x & 0xfc00) | (srel & 0x3ff); 361 bfd_put_16 (input_bfd, x, contents); 362 /* Handle second jump instruction. */ 363 x = bfd_get_16 (input_bfd, contents - 2); 364 srel += 1; 365 x = (x & 0xfc00) | (srel & 0x3ff); 366 bfd_put_16 (input_bfd, x, contents - 2); 367 break; 368 369 case R_MSP430_16_PCREL: 370 case R_MSP430_RL_PCREL: 371 contents += rel->r_offset; 372 srel = (bfd_signed_vma) relocation; 373 srel += rel->r_addend; 374 srel -= rel->r_offset; 375 /* Only branch instructions add 2 to the PC... */ 376 srel -= (input_section->output_section->vma + 377 input_section->output_offset); 378 379 if (srel & 1) 380 return bfd_reloc_outofrange; 381 382 bfd_put_16 (input_bfd, srel & 0xffff, contents); 383 break; 384 385 case R_MSP430_16_PCREL_BYTE: 386 contents += rel->r_offset; 387 srel = (bfd_signed_vma) relocation; 388 srel += rel->r_addend; 389 srel -= rel->r_offset; 390 /* Only branch instructions add 2 to the PC... */ 391 srel -= (input_section->output_section->vma + 392 input_section->output_offset); 393 394 bfd_put_16 (input_bfd, srel & 0xffff, contents); 395 break; 396 397 case R_MSP430_16_BYTE: 398 contents += rel->r_offset; 399 srel = (bfd_signed_vma) relocation; 400 srel += rel->r_addend; 401 bfd_put_16 (input_bfd, srel & 0xffff, contents); 402 break; 403 404 case R_MSP430_16: 405 contents += rel->r_offset; 406 srel = (bfd_signed_vma) relocation; 407 srel += rel->r_addend; 408 409 if (srel & 1) 410 return bfd_reloc_notsupported; 411 412 bfd_put_16 (input_bfd, srel & 0xffff, contents); 413 break; 414 415 default: 416 r = _bfd_final_link_relocate (howto, input_bfd, input_section, 417 contents, rel->r_offset, 418 relocation, rel->r_addend); 419 } 420 421 return r; 422} 423 424/* Relocate an MSP430 ELF section. */ 425 426static bfd_boolean 427elf32_msp430_relocate_section (bfd * output_bfd ATTRIBUTE_UNUSED, 428 struct bfd_link_info * info, 429 bfd * input_bfd, 430 asection * input_section, 431 bfd_byte * contents, 432 Elf_Internal_Rela * relocs, 433 Elf_Internal_Sym * local_syms, 434 asection ** local_sections) 435{ 436 Elf_Internal_Shdr *symtab_hdr; 437 struct elf_link_hash_entry **sym_hashes; 438 Elf_Internal_Rela *rel; 439 Elf_Internal_Rela *relend; 440 441 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 442 sym_hashes = elf_sym_hashes (input_bfd); 443 relend = relocs + input_section->reloc_count; 444 445 for (rel = relocs; rel < relend; rel++) 446 { 447 reloc_howto_type *howto; 448 unsigned long r_symndx; 449 Elf_Internal_Sym *sym; 450 asection *sec; 451 struct elf_link_hash_entry *h; 452 bfd_vma relocation; 453 bfd_reloc_status_type r; 454 const char *name = NULL; 455 int r_type; 456 457 /* This is a final link. */ 458 459 r_type = ELF32_R_TYPE (rel->r_info); 460 r_symndx = ELF32_R_SYM (rel->r_info); 461 howto = elf_msp430_howto_table + ELF32_R_TYPE (rel->r_info); 462 h = NULL; 463 sym = NULL; 464 sec = NULL; 465 466 if (r_symndx < symtab_hdr->sh_info) 467 { 468 sym = local_syms + r_symndx; 469 sec = local_sections[r_symndx]; 470 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel); 471 472 name = bfd_elf_string_from_elf_section 473 (input_bfd, symtab_hdr->sh_link, sym->st_name); 474 name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name; 475 } 476 else 477 { 478 bfd_boolean unresolved_reloc, warned; 479 480 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel, 481 r_symndx, symtab_hdr, sym_hashes, 482 h, sec, relocation, 483 unresolved_reloc, warned); 484 } 485 486 r = msp430_final_link_relocate (howto, input_bfd, input_section, 487 contents, rel, relocation); 488 489 if (r != bfd_reloc_ok) 490 { 491 const char *msg = (const char *) NULL; 492 493 switch (r) 494 { 495 case bfd_reloc_overflow: 496 r = info->callbacks->reloc_overflow 497 (info, (h ? &h->root : NULL), name, howto->name, 498 (bfd_vma) 0, input_bfd, input_section, 499 rel->r_offset); 500 break; 501 502 case bfd_reloc_undefined: 503 r = info->callbacks->undefined_symbol 504 (info, name, input_bfd, input_section, rel->r_offset, TRUE); 505 break; 506 507 case bfd_reloc_outofrange: 508 msg = _("internal error: out of range error"); 509 break; 510 511 case bfd_reloc_notsupported: 512 msg = _("internal error: unsupported relocation error"); 513 break; 514 515 case bfd_reloc_dangerous: 516 msg = _("internal error: dangerous relocation"); 517 break; 518 519 default: 520 msg = _("internal error: unknown error"); 521 break; 522 } 523 524 if (msg) 525 r = info->callbacks->warning 526 (info, msg, name, input_bfd, input_section, rel->r_offset); 527 528 if (!r) 529 return FALSE; 530 } 531 532 } 533 534 return TRUE; 535} 536 537/* The final processing done just before writing out a MSP430 ELF object 538 file. This gets the MSP430 architecture right based on the machine 539 number. */ 540 541static void 542bfd_elf_msp430_final_write_processing (bfd * abfd, 543 bfd_boolean linker ATTRIBUTE_UNUSED) 544{ 545 unsigned long val; 546 547 switch (bfd_get_mach (abfd)) 548 { 549 default: 550 case bfd_mach_msp110: 551 val = E_MSP430_MACH_MSP430x11x1; 552 break; 553 554 case bfd_mach_msp11: 555 val = E_MSP430_MACH_MSP430x11; 556 break; 557 558 case bfd_mach_msp12: 559 val = E_MSP430_MACH_MSP430x12; 560 break; 561 562 case bfd_mach_msp13: 563 val = E_MSP430_MACH_MSP430x13; 564 break; 565 566 case bfd_mach_msp14: 567 val = E_MSP430_MACH_MSP430x14; 568 break; 569 570 case bfd_mach_msp15: 571 val = E_MSP430_MACH_MSP430x15; 572 break; 573 574 case bfd_mach_msp16: 575 val = E_MSP430_MACH_MSP430x16; 576 break; 577 578 case bfd_mach_msp31: 579 val = E_MSP430_MACH_MSP430x31; 580 break; 581 582 case bfd_mach_msp32: 583 val = E_MSP430_MACH_MSP430x32; 584 break; 585 586 case bfd_mach_msp33: 587 val = E_MSP430_MACH_MSP430x33; 588 break; 589 590 case bfd_mach_msp41: 591 val = E_MSP430_MACH_MSP430x41; 592 break; 593 594 case bfd_mach_msp42: 595 val = E_MSP430_MACH_MSP430x42; 596 break; 597 598 case bfd_mach_msp43: 599 val = E_MSP430_MACH_MSP430x43; 600 break; 601 602 case bfd_mach_msp44: 603 val = E_MSP430_MACH_MSP430x44; 604 break; 605 } 606 607 elf_elfheader (abfd)->e_machine = EM_MSP430; 608 elf_elfheader (abfd)->e_flags &= ~EF_MSP430_MACH; 609 elf_elfheader (abfd)->e_flags |= val; 610} 611 612/* Set the right machine number. */ 613 614static bfd_boolean 615elf32_msp430_object_p (bfd * abfd) 616{ 617 int e_set = bfd_mach_msp14; 618 619 if (elf_elfheader (abfd)->e_machine == EM_MSP430 620 || elf_elfheader (abfd)->e_machine == EM_MSP430_OLD) 621 { 622 int e_mach = elf_elfheader (abfd)->e_flags & EF_MSP430_MACH; 623 624 switch (e_mach) 625 { 626 default: 627 case E_MSP430_MACH_MSP430x11: 628 e_set = bfd_mach_msp11; 629 break; 630 631 case E_MSP430_MACH_MSP430x11x1: 632 e_set = bfd_mach_msp110; 633 break; 634 635 case E_MSP430_MACH_MSP430x12: 636 e_set = bfd_mach_msp12; 637 break; 638 639 case E_MSP430_MACH_MSP430x13: 640 e_set = bfd_mach_msp13; 641 break; 642 643 case E_MSP430_MACH_MSP430x14: 644 e_set = bfd_mach_msp14; 645 break; 646 647 case E_MSP430_MACH_MSP430x15: 648 e_set = bfd_mach_msp15; 649 break; 650 651 case E_MSP430_MACH_MSP430x16: 652 e_set = bfd_mach_msp16; 653 break; 654 655 case E_MSP430_MACH_MSP430x31: 656 e_set = bfd_mach_msp31; 657 break; 658 659 case E_MSP430_MACH_MSP430x32: 660 e_set = bfd_mach_msp32; 661 break; 662 663 case E_MSP430_MACH_MSP430x33: 664 e_set = bfd_mach_msp33; 665 break; 666 667 case E_MSP430_MACH_MSP430x41: 668 e_set = bfd_mach_msp41; 669 break; 670 671 case E_MSP430_MACH_MSP430x42: 672 e_set = bfd_mach_msp42; 673 break; 674 675 case E_MSP430_MACH_MSP430x43: 676 e_set = bfd_mach_msp43; 677 break; 678 679 case E_MSP430_MACH_MSP430x44: 680 e_set = bfd_mach_msp44; 681 break; 682 } 683 } 684 685 return bfd_default_set_arch_mach (abfd, bfd_arch_msp430, e_set); 686} 687 688static void 689elf32_msp430_post_process_headers (bfd * abfd, 690 struct bfd_link_info * link_info ATTRIBUTE_UNUSED) 691{ 692 Elf_Internal_Ehdr * i_ehdrp; /* ELF file header, internal form. */ 693 694 i_ehdrp = elf_elfheader (abfd); 695 696#ifndef ELFOSABI_STANDALONE 697#define ELFOSABI_STANDALONE 255 698#endif 699 700 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_STANDALONE; 701} 702 703/* These functions handle relaxing for the msp430. 704 Relaxation required only in two cases: 705 - Bad hand coding like jumps from one section to another or 706 from file to file. 707 - Sibling calls. This will affect onlu 'jump label' polymorph. Without 708 relaxing this enlarges code by 2 bytes. Sibcalls implemented but 709 do not work in gcc's port by the reason I do not know. 710 Anyway, if a relaxation required, user should pass -relax option to the 711 linker. 712 713 There are quite a few relaxing opportunities available on the msp430: 714 715 ================================================================ 716 717 1. 3 words -> 1 word 718 719 eq == jeq label jne +4; br lab 720 ne != jne label jeq +4; br lab 721 lt < jl label jge +4; br lab 722 ltu < jlo label lhs +4; br lab 723 ge >= jge label jl +4; br lab 724 geu >= jhs label jlo +4; br lab 725 726 2. 4 words -> 1 word 727 728 ltn < jn jn +2; jmp +4; br lab 729 730 3. 4 words -> 2 words 731 732 gt > jeq +2; jge label jeq +6; jl +4; br label 733 gtu > jeq +2; jhs label jeq +6; jlo +4; br label 734 735 4. 4 words -> 2 words and 2 labels 736 737 leu <= jeq label; jlo label jeq +2; jhs +4; br label 738 le <= jeq label; jl label jeq +2; jge +4; br label 739 ================================================================= 740 741 codemap for first cases is (labels masked ): 742 eq: 0x2002,0x4010,0x0000 -> 0x2400 743 ne: 0x2402,0x4010,0x0000 -> 0x2000 744 lt: 0x3402,0x4010,0x0000 -> 0x3800 745 ltu: 0x2c02,0x4010,0x0000 -> 0x2800 746 ge: 0x3802,0x4010,0x0000 -> 0x3400 747 geu: 0x2802,0x4010,0x0000 -> 0x2c00 748 749 second case: 750 ltn: 0x3001,0x3c02,0x4010,0x0000 -> 0x3000 751 752 third case: 753 gt: 0x2403,0x3802,0x4010,0x0000 -> 0x2401,0x3400 754 gtu: 0x2403,0x2802,0x4010,0x0000 -> 0x2401,0x2c00 755 756 fourth case: 757 leu: 0x2401,0x2c02,0x4010,0x0000 -> 0x2400,0x2800 758 le: 0x2401,0x3402,0x4010,0x0000 -> 0x2400,0x3800 759 760 Unspecified case :) 761 jump: 0x4010,0x0000 -> 0x3c00. */ 762 763#define NUMB_RELAX_CODES 12 764static struct rcodes_s 765{ 766 int f0, f1; /* From code. */ 767 int t0, t1; /* To code. */ 768 int labels; /* Position of labels: 1 - one label at first 769 word, 2 - one at second word, 3 - two 770 labels at both. */ 771 int cdx; /* Words to match. */ 772 int bs; /* Shrink bytes. */ 773 int off; /* Offset from old label for new code. */ 774 int ncl; /* New code length. */ 775} rcode[] = 776{/* lab,cdx,bs,off,ncl */ 777 { 0x0000, 0x0000, 0x3c00, 0x0000, 1, 0, 2, 2, 2}, /* jump */ 778 { 0x0000, 0x2002, 0x2400, 0x0000, 1, 1, 4, 4, 2}, /* eq */ 779 { 0x0000, 0x2402, 0x2000, 0x0000, 1, 1, 4, 4, 2}, /* ne */ 780 { 0x0000, 0x3402, 0x3800, 0x0000, 1, 1, 4, 4, 2}, /* lt */ 781 { 0x0000, 0x2c02, 0x2800, 0x0000, 1, 1, 4, 4, 2}, /* ltu */ 782 { 0x0000, 0x3802, 0x3400, 0x0000, 1, 1, 4, 4, 2}, /* ge */ 783 { 0x0000, 0x2802, 0x2c00, 0x0000, 1, 1, 4, 4, 2}, /* geu */ 784 { 0x3001, 0x3c02, 0x3000, 0x0000, 1, 2, 6, 6, 2}, /* ltn */ 785 { 0x2403, 0x3802, 0x2401, 0x3400, 2, 2, 4, 6, 4}, /* gt */ 786 { 0x2403, 0x2802, 0x2401, 0x2c00, 2, 2, 4, 6, 4}, /* gtu */ 787 { 0x2401, 0x2c02, 0x2400, 0x2800, 3, 2, 4, 6, 4}, /* leu , 2 labels */ 788 { 0x2401, 0x2c02, 0x2400, 0x2800, 3, 2, 4, 6, 4}, /* le , 2 labels */ 789 { 0, 0, 0, 0, 0, 0, 0, 0, 0} 790}; 791 792/* Return TRUE if a symbol exists at the given address. */ 793 794static bfd_boolean 795msp430_elf_symbol_address_p (bfd * abfd, 796 asection * sec, 797 Elf_Internal_Sym * isym, 798 bfd_vma addr) 799{ 800 Elf_Internal_Shdr *symtab_hdr; 801 unsigned int sec_shndx; 802 Elf_Internal_Sym *isymend; 803 struct elf_link_hash_entry **sym_hashes; 804 struct elf_link_hash_entry **end_hashes; 805 unsigned int symcount; 806 807 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec); 808 809 /* Examine all the local symbols. */ 810 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 811 for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++) 812 if (isym->st_shndx == sec_shndx && isym->st_value == addr) 813 return TRUE; 814 815 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym) 816 - symtab_hdr->sh_info); 817 sym_hashes = elf_sym_hashes (abfd); 818 end_hashes = sym_hashes + symcount; 819 for (; sym_hashes < end_hashes; sym_hashes++) 820 { 821 struct elf_link_hash_entry *sym_hash = *sym_hashes; 822 823 if ((sym_hash->root.type == bfd_link_hash_defined 824 || sym_hash->root.type == bfd_link_hash_defweak) 825 && sym_hash->root.u.def.section == sec 826 && sym_hash->root.u.def.value == addr) 827 return TRUE; 828 } 829 830 return FALSE; 831} 832 833/* Adjust all local symbols defined as '.section + 0xXXXX' (.section has sec_shndx) 834 referenced from current and other sections */ 835static bfd_boolean 836msp430_elf_relax_adjust_locals(bfd * abfd, asection * sec, bfd_vma addr, 837 int count, unsigned int sec_shndx, bfd_vma toaddr) 838{ 839 Elf_Internal_Shdr *symtab_hdr; 840 Elf_Internal_Rela *irel; 841 Elf_Internal_Rela *irelend; 842 Elf_Internal_Sym *isym; 843 844 irel = elf_section_data (sec)->relocs; 845 irelend = irel + sec->reloc_count; 846 symtab_hdr = & elf_tdata (abfd)->symtab_hdr; 847 isym = (Elf_Internal_Sym *) symtab_hdr->contents; 848 849 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++) 850 { 851 int sidx = ELF32_R_SYM(irel->r_info); 852 Elf_Internal_Sym *lsym = isym + sidx; 853 854 /* Adjust symbols referenced by .sec+0xXX */ 855 if (irel->r_addend > addr && irel->r_addend < toaddr 856 && lsym->st_shndx == sec_shndx) 857 irel->r_addend -= count; 858 } 859 860 return TRUE; 861} 862 863/* Delete some bytes from a section while relaxing. */ 864 865static bfd_boolean 866msp430_elf_relax_delete_bytes (bfd * abfd, asection * sec, bfd_vma addr, 867 int count) 868{ 869 Elf_Internal_Shdr *symtab_hdr; 870 unsigned int sec_shndx; 871 bfd_byte *contents; 872 Elf_Internal_Rela *irel; 873 Elf_Internal_Rela *irelend; 874 Elf_Internal_Rela *irelalign; 875 bfd_vma toaddr; 876 Elf_Internal_Sym *isym; 877 Elf_Internal_Sym *isymend; 878 struct elf_link_hash_entry **sym_hashes; 879 struct elf_link_hash_entry **end_hashes; 880 unsigned int symcount; 881 asection *p; 882 883 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec); 884 885 contents = elf_section_data (sec)->this_hdr.contents; 886 887 /* The deletion must stop at the next ALIGN reloc for an aligment 888 power larger than the number of bytes we are deleting. */ 889 890 irelalign = NULL; 891 toaddr = sec->size; 892 893 irel = elf_section_data (sec)->relocs; 894 irelend = irel + sec->reloc_count; 895 896 /* Actually delete the bytes. */ 897 memmove (contents + addr, contents + addr + count, 898 (size_t) (toaddr - addr - count)); 899 sec->size -= count; 900 901 /* Adjust all the relocs. */ 902 symtab_hdr = & elf_tdata (abfd)->symtab_hdr; 903 isym = (Elf_Internal_Sym *) symtab_hdr->contents; 904 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++) 905 { 906 /* Get the new reloc address. */ 907 if ((irel->r_offset > addr && irel->r_offset < toaddr)) 908 irel->r_offset -= count; 909 } 910 911 for (p = abfd->sections; p != NULL; p = p->next) 912 msp430_elf_relax_adjust_locals(abfd,p,addr,count,sec_shndx,toaddr); 913 914 /* Adjust the local symbols defined in this section. */ 915 symtab_hdr = & elf_tdata (abfd)->symtab_hdr; 916 isym = (Elf_Internal_Sym *) symtab_hdr->contents; 917 for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++) 918 if (isym->st_shndx == sec_shndx 919 && isym->st_value > addr && isym->st_value < toaddr) 920 isym->st_value -= count; 921 922 /* Now adjust the global symbols defined in this section. */ 923 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym) 924 - symtab_hdr->sh_info); 925 sym_hashes = elf_sym_hashes (abfd); 926 end_hashes = sym_hashes + symcount; 927 for (; sym_hashes < end_hashes; sym_hashes++) 928 { 929 struct elf_link_hash_entry *sym_hash = *sym_hashes; 930 931 if ((sym_hash->root.type == bfd_link_hash_defined 932 || sym_hash->root.type == bfd_link_hash_defweak) 933 && sym_hash->root.u.def.section == sec 934 && sym_hash->root.u.def.value > addr 935 && sym_hash->root.u.def.value < toaddr) 936 sym_hash->root.u.def.value -= count; 937 } 938 939 return TRUE; 940} 941 942 943static bfd_boolean 944msp430_elf_relax_section (bfd * abfd, asection * sec, 945 struct bfd_link_info * link_info, 946 bfd_boolean * again) 947{ 948 Elf_Internal_Shdr * symtab_hdr; 949 Elf_Internal_Rela * internal_relocs; 950 Elf_Internal_Rela * irel; 951 Elf_Internal_Rela * irelend; 952 bfd_byte * contents = NULL; 953 Elf_Internal_Sym * isymbuf = NULL; 954 955 /* Assume nothing changes. */ 956 *again = FALSE; 957 958 /* We don't have to do anything for a relocatable link, if 959 this section does not have relocs, or if this is not a 960 code section. */ 961 if (link_info->relocatable 962 || (sec->flags & SEC_RELOC) == 0 963 || sec->reloc_count == 0 || (sec->flags & SEC_CODE) == 0) 964 return TRUE; 965 966 symtab_hdr = & elf_tdata (abfd)->symtab_hdr; 967 968 /* Get a copy of the native relocations. */ 969 internal_relocs = 970 _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL, link_info->keep_memory); 971 if (internal_relocs == NULL) 972 goto error_return; 973 974 /* Walk through them looking for relaxing opportunities. */ 975 irelend = internal_relocs + sec->reloc_count; 976 for (irel = internal_relocs; irel < irelend; irel++) 977 { 978 bfd_vma symval; 979 980 /* If this isn't something that can be relaxed, then ignore 981 this reloc. */ 982 if (ELF32_R_TYPE (irel->r_info) != (int) R_MSP430_RL_PCREL) 983 continue; 984 985 /* Get the section contents if we haven't done so already. */ 986 if (contents == NULL) 987 { 988 /* Get cached copy if it exists. */ 989 if (elf_section_data (sec)->this_hdr.contents != NULL) 990 contents = elf_section_data (sec)->this_hdr.contents; 991 else if (! bfd_malloc_and_get_section (abfd, sec, &contents)) 992 goto error_return; 993 } 994 995 /* Read this BFD's local symbols if we haven't done so already. */ 996 if (isymbuf == NULL && symtab_hdr->sh_info != 0) 997 { 998 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents; 999 if (isymbuf == NULL) 1000 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr, 1001 symtab_hdr->sh_info, 0, 1002 NULL, NULL, NULL); 1003 if (isymbuf == NULL) 1004 goto error_return; 1005 } 1006 1007 /* Get the value of the symbol referred to by the reloc. */ 1008 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info) 1009 { 1010 /* A local symbol. */ 1011 Elf_Internal_Sym *isym; 1012 asection *sym_sec; 1013 1014 isym = isymbuf + ELF32_R_SYM (irel->r_info); 1015 if (isym->st_shndx == SHN_UNDEF) 1016 sym_sec = bfd_und_section_ptr; 1017 else if (isym->st_shndx == SHN_ABS) 1018 sym_sec = bfd_abs_section_ptr; 1019 else if (isym->st_shndx == SHN_COMMON) 1020 sym_sec = bfd_com_section_ptr; 1021 else 1022 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx); 1023 symval = (isym->st_value 1024 + sym_sec->output_section->vma + sym_sec->output_offset); 1025 } 1026 else 1027 { 1028 unsigned long indx; 1029 struct elf_link_hash_entry *h; 1030 1031 /* An external symbol. */ 1032 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info; 1033 h = elf_sym_hashes (abfd)[indx]; 1034 BFD_ASSERT (h != NULL); 1035 1036 if (h->root.type != bfd_link_hash_defined 1037 && h->root.type != bfd_link_hash_defweak) 1038 /* This appears to be a reference to an undefined 1039 symbol. Just ignore it--it will be caught by the 1040 regular reloc processing. */ 1041 continue; 1042 1043 symval = (h->root.u.def.value 1044 + h->root.u.def.section->output_section->vma 1045 + h->root.u.def.section->output_offset); 1046 } 1047 1048 /* For simplicity of coding, we are going to modify the section 1049 contents, the section relocs, and the BFD symbol table. We 1050 must tell the rest of the code not to free up this 1051 information. It would be possible to instead create a table 1052 of changes which have to be made, as is done in coff-mips.c; 1053 that would be more work, but would require less memory when 1054 the linker is run. */ 1055 1056 /* Try to turn a 16bit pc-relative branch into a 10bit pc-relative 1057 branch. */ 1058 /* Paranoia? paranoia... */ 1059 if (ELF32_R_TYPE (irel->r_info) == (int) R_MSP430_RL_PCREL) 1060 { 1061 bfd_vma value = symval; 1062 1063 /* Deal with pc-relative gunk. */ 1064 value -= (sec->output_section->vma + sec->output_offset); 1065 value -= irel->r_offset; 1066 value += irel->r_addend; 1067 1068 /* See if the value will fit in 10 bits, note the high value is 1069 1016 as the target will be two bytes closer if we are 1070 able to relax. */ 1071 if ((long) value < 1016 && (long) value > -1016) 1072 { 1073 int code0 = 0, code1 = 0, code2 = 0; 1074 int i; 1075 struct rcodes_s *rx; 1076 1077 /* Get the opcode. */ 1078 if (irel->r_offset >= 6) 1079 code0 = bfd_get_16 (abfd, contents + irel->r_offset - 6); 1080 1081 if (irel->r_offset >= 4) 1082 code1 = bfd_get_16 (abfd, contents + irel->r_offset - 4); 1083 1084 code2 = bfd_get_16 (abfd, contents + irel->r_offset - 2); 1085 1086 if (code2 != 0x4010) 1087 continue; 1088 1089 /* Check r4 and r3. */ 1090 for (i = NUMB_RELAX_CODES - 1; i >= 0; i--) 1091 { 1092 rx = &rcode[i]; 1093 if (rx->cdx == 2 && rx->f0 == code0 && rx->f1 == code1) 1094 break; 1095 else if (rx->cdx == 1 && rx->f1 == code1) 1096 break; 1097 else if (rx->cdx == 0) /* This is an unconditional jump. */ 1098 break; 1099 } 1100 1101 /* Check labels: 1102 .Label0: ; we do not care about this label 1103 jeq +6 1104 .Label1: ; make sure there is no label here 1105 jl +4 1106 .Label2: ; make sure there is no label here 1107 br .Label_dst 1108 1109 So, if there is .Label1 or .Label2 we cannot relax this code. 1110 This actually should not happen, cause for relaxable 1111 instructions we use RL_PCREL reloc instead of 16_PCREL. 1112 Will change this in the future. */ 1113 1114 if (rx->cdx > 0 1115 && msp430_elf_symbol_address_p (abfd, sec, isymbuf, 1116 irel->r_offset - 2)) 1117 continue; 1118 if (rx->cdx > 1 1119 && msp430_elf_symbol_address_p (abfd, sec, isymbuf, 1120 irel->r_offset - 4)) 1121 continue; 1122 1123 /* Note that we've changed the relocs, section contents, etc. */ 1124 elf_section_data (sec)->relocs = internal_relocs; 1125 elf_section_data (sec)->this_hdr.contents = contents; 1126 symtab_hdr->contents = (unsigned char *) isymbuf; 1127 1128 /* Fix the relocation's type. */ 1129 if (rx->labels == 3) /* Handle special cases. */ 1130 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), 1131 R_MSP430_2X_PCREL); 1132 else 1133 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), 1134 R_MSP430_10_PCREL); 1135 1136 /* Fix the opcode right way. */ 1137 bfd_put_16 (abfd, rx->t0, contents + irel->r_offset - rx->off); 1138 if (rx->t1) 1139 bfd_put_16 (abfd, rx->t1, 1140 contents + irel->r_offset - rx->off + 2); 1141 1142 /* Delete bytes. */ 1143 if (!msp430_elf_relax_delete_bytes (abfd, sec, 1144 irel->r_offset - rx->off + 1145 rx->ncl, rx->bs)) 1146 goto error_return; 1147 1148 /* Handle unconditional jumps. */ 1149 if (rx->cdx == 0) 1150 irel->r_offset -= 2; 1151 1152 /* That will change things, so, we should relax again. 1153 Note that this is not required, and it may be slow. */ 1154 *again = TRUE; 1155 } 1156 } 1157 } 1158 1159 if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf) 1160 { 1161 if (!link_info->keep_memory) 1162 free (isymbuf); 1163 else 1164 { 1165 /* Cache the symbols for elf_link_input_bfd. */ 1166 symtab_hdr->contents = (unsigned char *) isymbuf; 1167 } 1168 } 1169 1170 if (contents != NULL 1171 && elf_section_data (sec)->this_hdr.contents != contents) 1172 { 1173 if (!link_info->keep_memory) 1174 free (contents); 1175 else 1176 { 1177 /* Cache the section contents for elf_link_input_bfd. */ 1178 elf_section_data (sec)->this_hdr.contents = contents; 1179 } 1180 } 1181 1182 if (internal_relocs != NULL 1183 && elf_section_data (sec)->relocs != internal_relocs) 1184 free (internal_relocs); 1185 1186 return TRUE; 1187 1188error_return: 1189 if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf) 1190 free (isymbuf); 1191 if (contents != NULL 1192 && elf_section_data (sec)->this_hdr.contents != contents) 1193 free (contents); 1194 if (internal_relocs != NULL 1195 && elf_section_data (sec)->relocs != internal_relocs) 1196 free (internal_relocs); 1197 1198 return FALSE; 1199} 1200 1201 1202#define ELF_ARCH bfd_arch_msp430 1203#define ELF_MACHINE_CODE EM_MSP430 1204#define ELF_MACHINE_ALT1 EM_MSP430_OLD 1205#define ELF_MAXPAGESIZE 1 1206 1207#define TARGET_LITTLE_SYM bfd_elf32_msp430_vec 1208#define TARGET_LITTLE_NAME "elf32-msp430" 1209 1210#define elf_info_to_howto msp430_info_to_howto_rela 1211#define elf_info_to_howto_rel NULL 1212#define elf_backend_relocate_section elf32_msp430_relocate_section 1213#define elf_backend_gc_mark_hook elf32_msp430_gc_mark_hook 1214#define elf_backend_gc_sweep_hook elf32_msp430_gc_sweep_hook 1215#define elf_backend_check_relocs elf32_msp430_check_relocs 1216#define elf_backend_can_gc_sections 1 1217#define elf_backend_final_write_processing bfd_elf_msp430_final_write_processing 1218#define elf_backend_object_p elf32_msp430_object_p 1219#define elf_backend_post_process_headers elf32_msp430_post_process_headers 1220#define bfd_elf32_bfd_relax_section msp430_elf_relax_section 1221 1222#include "elf32-target.h" 1223