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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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 static reloc_howto_type *bfd_elf32_bfd_reloc_type_lookup 29 PARAMS ((bfd *, bfd_reloc_code_real_type)); 30 31 static void msp430_info_to_howto_rela 32 PARAMS ((bfd *, arelent *, Elf_Internal_Rela *)); 33 34 static asection *elf32_msp430_gc_mark_hook 35 PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *, 36 struct elf_link_hash_entry *, Elf_Internal_Sym *)); 37 38 static bfd_boolean elf32_msp430_gc_sweep_hook 39 PARAMS ((bfd *, struct bfd_link_info *, asection *, 40 const Elf_Internal_Rela *)); 41 42 static bfd_boolean elf32_msp430_check_relocs 43 PARAMS ((bfd *, struct bfd_link_info *, asection *, 44 const Elf_Internal_Rela *)); 45 46 static bfd_reloc_status_type msp430_final_link_relocate 47 PARAMS ((reloc_howto_type *, bfd *, asection *, bfd_byte *, 48 Elf_Internal_Rela *, bfd_vma)); 49 50 static bfd_boolean elf32_msp430_relocate_section 51 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *, 52 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **)); 53 54 static void bfd_elf_msp430_final_write_processing 55 PARAMS ((bfd *, bfd_boolean)); 56 57 static bfd_boolean elf32_msp430_object_p 58 PARAMS ((bfd *)); 59 60 static void elf32_msp430_post_process_headers 61 PARAMS ((bfd *, struct bfd_link_info *)); 62 63 /* Use RELA instead of REL. */ 64 #undef USE_REL 65 66 static reloc_howto_type elf_msp430_howto_table[] = 67 { 68 HOWTO (R_MSP430_NONE, /* type */ 69 0, /* rightshift */ 70 2, /* size (0 = byte, 1 = short, 2 = long) */ 71 32, /* bitsize */ 72 FALSE, /* pc_relative */ 73 0, /* bitpos */ 74 complain_overflow_bitfield, /* complain_on_overflow */ 75 bfd_elf_generic_reloc, /* special_function */ 76 "R_MSP430_NONE", /* name */ 77 FALSE, /* partial_inplace */ 78 0, /* src_mask */ 79 0, /* dst_mask */ 80 FALSE), /* pcrel_offset */ 81 82 HOWTO (R_MSP430_32, /* type */ 83 0, /* rightshift */ 84 2, /* size (0 = byte, 1 = short, 2 = long) */ 85 32, /* bitsize */ 86 FALSE, /* pc_relative */ 87 0, /* bitpos */ 88 complain_overflow_bitfield, /* complain_on_overflow */ 89 bfd_elf_generic_reloc, /* special_function */ 90 "R_MSP430_32", /* name */ 91 FALSE, /* partial_inplace */ 92 0xffffffff, /* src_mask */ 93 0xffffffff, /* dst_mask */ 94 FALSE), /* pcrel_offset */ 95 96 /* A 13 bit PC relative relocation. */ 97 HOWTO (R_MSP430_10_PCREL, /* type */ 98 1, /* rightshift */ 99 1, /* size (0 = byte, 1 = short, 2 = long) */ 100 10, /* bitsize */ 101 TRUE, /* pc_relative */ 102 0, /* bitpos */ 103 complain_overflow_bitfield, /* complain_on_overflow */ 104 bfd_elf_generic_reloc, /* special_function */ 105 "R_MSP430_13_PCREL", /* name */ 106 FALSE, /* partial_inplace */ 107 0xfff, /* src_mask */ 108 0xfff, /* dst_mask */ 109 TRUE), /* pcrel_offset */ 110 111 /* A 16 bit absolute relocation. */ 112 HOWTO (R_MSP430_16, /* type */ 113 0, /* rightshift */ 114 1, /* size (0 = byte, 1 = short, 2 = long) */ 115 16, /* bitsize */ 116 FALSE, /* pc_relative */ 117 0, /* bitpos */ 118 complain_overflow_dont,/* complain_on_overflow */ 119 bfd_elf_generic_reloc, /* special_function */ 120 "R_MSP430_16", /* name */ 121 FALSE, /* partial_inplace */ 122 0xffff, /* src_mask */ 123 0xffff, /* dst_mask */ 124 FALSE), /* pcrel_offset */ 125 126 /* A 16 bit absolute relocation for command address. */ 127 HOWTO (R_MSP430_16_PCREL, /* type */ 128 1, /* rightshift */ 129 1, /* size (0 = byte, 1 = short, 2 = long) */ 130 16, /* bitsize */ 131 TRUE, /* pc_relative */ 132 0, /* bitpos */ 133 complain_overflow_dont,/* complain_on_overflow */ 134 bfd_elf_generic_reloc, /* special_function */ 135 "R_MSP430_16_PCREL", /* name */ 136 FALSE, /* partial_inplace */ 137 0xffff, /* src_mask */ 138 0xffff, /* dst_mask */ 139 TRUE), /* pcrel_offset */ 140 141 /* A 16 bit absolute relocation, byte operations. */ 142 HOWTO (R_MSP430_16_BYTE, /* type */ 143 0, /* rightshift */ 144 1, /* size (0 = byte, 1 = short, 2 = long) */ 145 16, /* bitsize */ 146 FALSE, /* pc_relative */ 147 0, /* bitpos */ 148 complain_overflow_dont,/* complain_on_overflow */ 149 bfd_elf_generic_reloc, /* special_function */ 150 "R_MSP430_16_BYTE", /* name */ 151 FALSE, /* partial_inplace */ 152 0xffff, /* src_mask */ 153 0xffff, /* dst_mask */ 154 FALSE), /* pcrel_offset */ 155 156 /* A 16 bit absolute relocation for command address. */ 157 HOWTO (R_MSP430_16_PCREL_BYTE,/* type */ 158 1, /* rightshift */ 159 1, /* size (0 = byte, 1 = short, 2 = long) */ 160 16, /* bitsize */ 161 TRUE, /* pc_relative */ 162 0, /* bitpos */ 163 complain_overflow_dont,/* complain_on_overflow */ 164 bfd_elf_generic_reloc, /* special_function */ 165 "R_MSP430_16_PCREL_BYTE", /* name */ 166 FALSE, /* partial_inplace */ 167 0xffff, /* src_mask */ 168 0xffff, /* dst_mask */ 169 TRUE) /* pcrel_offset */ 170 }; 171 172 /* Map BFD reloc types to MSP430 ELF reloc types. */ 173 174 struct msp430_reloc_map 175 { 176 bfd_reloc_code_real_type bfd_reloc_val; 177 unsigned int elf_reloc_val; 178 }; 179 180 static const struct msp430_reloc_map msp430_reloc_map[] = 181 { 182 {BFD_RELOC_NONE, R_MSP430_NONE}, 183 {BFD_RELOC_32, R_MSP430_32}, 184 {BFD_RELOC_MSP430_10_PCREL, R_MSP430_10_PCREL}, 185 {BFD_RELOC_16, R_MSP430_16_BYTE}, 186 {BFD_RELOC_MSP430_16_PCREL, R_MSP430_16_PCREL}, 187 {BFD_RELOC_MSP430_16, R_MSP430_16}, 188 {BFD_RELOC_MSP430_16_PCREL_BYTE, R_MSP430_16_PCREL_BYTE}, 189 {BFD_RELOC_MSP430_16_BYTE, R_MSP430_16_BYTE} 190 }; 191 192 static reloc_howto_type * 193 bfd_elf32_bfd_reloc_type_lookup (abfd, code) 194 bfd *abfd ATTRIBUTE_UNUSED; 195 bfd_reloc_code_real_type code; 196 { 197 unsigned int i; 198 199 for (i = 0; i < ARRAY_SIZE (msp430_reloc_map); i++) 200 if (msp430_reloc_map[i].bfd_reloc_val == code) 201 return &elf_msp430_howto_table[msp430_reloc_map[i].elf_reloc_val]; 202 203 return NULL; 204 } 205 206 /* Set the howto pointer for an MSP430 ELF reloc. */ 207 208 static void 209 msp430_info_to_howto_rela (abfd, cache_ptr, dst) 210 bfd *abfd ATTRIBUTE_UNUSED; 211 arelent *cache_ptr; 212 Elf_Internal_Rela *dst; 213 { 214 unsigned int r_type; 215 216 r_type = ELF32_R_TYPE (dst->r_info); 217 BFD_ASSERT (r_type < (unsigned int) R_MSP430_max); 218 cache_ptr->howto = &elf_msp430_howto_table[r_type]; 219 } 220 221 static asection * 222 elf32_msp430_gc_mark_hook (sec, info, rel, h, sym) 223 asection *sec; 224 struct bfd_link_info *info ATTRIBUTE_UNUSED; 225 Elf_Internal_Rela *rel; 226 struct elf_link_hash_entry *h; 227 Elf_Internal_Sym *sym; 228 { 229 if (h != NULL) 230 { 231 switch (ELF32_R_TYPE (rel->r_info)) 232 { 233 default: 234 switch (h->root.type) 235 { 236 case bfd_link_hash_defined: 237 case bfd_link_hash_defweak: 238 return h->root.u.def.section; 239 240 case bfd_link_hash_common: 241 return h->root.u.c.p->section; 242 243 default: 244 break; 245 } 246 } 247 } 248 else 249 return bfd_section_from_elf_index (sec->owner, sym->st_shndx); 250 251 return NULL; 252 } 253 254 static bfd_boolean 255 elf32_msp430_gc_sweep_hook (abfd, info, sec, relocs) 256 bfd *abfd ATTRIBUTE_UNUSED; 257 struct bfd_link_info *info ATTRIBUTE_UNUSED; 258 asection *sec ATTRIBUTE_UNUSED; 259 const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED; 260 { 261 /* We don't use got and plt entries for msp430. */ 262 return TRUE; 263 } 264 265 /* Look through the relocs for a section during the first phase. 266 Since we don't do .gots or .plts, we just need to consider the 267 virtual table relocs for gc. */ 268 269 static bfd_boolean 270 elf32_msp430_check_relocs (abfd, info, sec, relocs) 271 bfd *abfd; 272 struct bfd_link_info *info; 273 asection *sec; 274 const Elf_Internal_Rela *relocs; 275 { 276 Elf_Internal_Shdr *symtab_hdr; 277 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end; 278 const Elf_Internal_Rela *rel; 279 const Elf_Internal_Rela *rel_end; 280 281 if (info->relocatable) 282 return TRUE; 283 284 symtab_hdr = &elf_tdata (abfd)->symtab_hdr; 285 sym_hashes = elf_sym_hashes (abfd); 286 sym_hashes_end = 287 sym_hashes + symtab_hdr->sh_size / sizeof (Elf32_External_Sym); 288 if (!elf_bad_symtab (abfd)) 289 sym_hashes_end -= symtab_hdr->sh_info; 290 291 rel_end = relocs + sec->reloc_count; 292 for (rel = relocs; rel < rel_end; rel++) 293 { 294 struct elf_link_hash_entry *h; 295 unsigned long r_symndx; 296 297 r_symndx = ELF32_R_SYM (rel->r_info); 298 if (r_symndx < symtab_hdr->sh_info) 299 h = NULL; 300 else 301 h = sym_hashes[r_symndx - symtab_hdr->sh_info]; 302 } 303 304 return TRUE; 305 } 306 307 /* Perform a single relocation. By default we use the standard BFD 308 routines, but a few relocs, we have to do them ourselves. */ 309 310 static bfd_reloc_status_type 311 msp430_final_link_relocate (howto, input_bfd, input_section, 312 contents, rel, relocation) 313 reloc_howto_type *howto; 314 bfd *input_bfd; 315 asection *input_section; 316 bfd_byte *contents; 317 Elf_Internal_Rela *rel; 318 bfd_vma relocation; 319 { 320 bfd_reloc_status_type r = bfd_reloc_ok; 321 bfd_vma x; 322 bfd_signed_vma srel; 323 324 switch (howto->type) 325 { 326 case R_MSP430_10_PCREL: 327 contents += rel->r_offset; 328 srel = (bfd_signed_vma) relocation; 329 srel += rel->r_addend; 330 srel -= rel->r_offset; 331 srel -= 2; /* Branch instructions add 2 to the PC... */ 332 srel -= (input_section->output_section->vma + 333 input_section->output_offset); 334 335 if (srel & 1) 336 return bfd_reloc_outofrange; 337 338 /* MSP430 addresses commands as words. */ 339 srel >>= 1; 340 341 /* Check for an overflow. */ 342 if (srel < -512 || srel > 511) 343 return bfd_reloc_overflow; 344 345 x = bfd_get_16 (input_bfd, contents); 346 x = (x & 0xfc00) | (srel & 0x3ff); 347 bfd_put_16 (input_bfd, x, contents); 348 break; 349 350 case R_MSP430_16_PCREL: 351 contents += rel->r_offset; 352 srel = (bfd_signed_vma) relocation; 353 srel += rel->r_addend; 354 srel -= rel->r_offset; 355 /* Only branch instructions add 2 to the PC... */ 356 srel -= (input_section->output_section->vma + 357 input_section->output_offset); 358 359 if (srel & 1) 360 return bfd_reloc_outofrange; 361 362 bfd_put_16 (input_bfd, srel & 0xffff, contents); 363 break; 364 365 case R_MSP430_16_PCREL_BYTE: 366 contents += rel->r_offset; 367 srel = (bfd_signed_vma) relocation; 368 srel += rel->r_addend; 369 srel -= rel->r_offset; 370 /* Only branch instructions add 2 to the PC... */ 371 srel -= (input_section->output_section->vma + 372 input_section->output_offset); 373 374 bfd_put_16 (input_bfd, srel & 0xffff, contents); 375 break; 376 377 case R_MSP430_16_BYTE: 378 contents += rel->r_offset; 379 srel = (bfd_signed_vma) relocation; 380 srel += rel->r_addend; 381 bfd_put_16 (input_bfd, srel & 0xffff, contents); 382 break; 383 384 case R_MSP430_16: 385 contents += rel->r_offset; 386 srel = (bfd_signed_vma) relocation; 387 srel += rel->r_addend; 388 389 if (srel & 1) 390 return bfd_reloc_notsupported; 391 392 bfd_put_16 (input_bfd, srel & 0xffff, contents); 393 break; 394 395 default: 396 r = _bfd_final_link_relocate (howto, input_bfd, input_section, 397 contents, rel->r_offset, 398 relocation, rel->r_addend); 399 } 400 401 return r; 402 } 403 404 /* Relocate an MSP430 ELF section. */ 405 406 static bfd_boolean 407 elf32_msp430_relocate_section (output_bfd, info, input_bfd, input_section, 408 contents, relocs, local_syms, local_sections) 409 bfd *output_bfd ATTRIBUTE_UNUSED; 410 struct bfd_link_info *info; 411 bfd *input_bfd; 412 asection *input_section; 413 bfd_byte *contents; 414 Elf_Internal_Rela *relocs; 415 Elf_Internal_Sym *local_syms; 416 asection **local_sections; 417 { 418 Elf_Internal_Shdr *symtab_hdr; 419 struct elf_link_hash_entry **sym_hashes; 420 Elf_Internal_Rela *rel; 421 Elf_Internal_Rela *relend; 422 423 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr; 424 sym_hashes = elf_sym_hashes (input_bfd); 425 relend = relocs + input_section->reloc_count; 426 427 for (rel = relocs; rel < relend; rel++) 428 { 429 reloc_howto_type *howto; 430 unsigned long r_symndx; 431 Elf_Internal_Sym *sym; 432 asection *sec; 433 struct elf_link_hash_entry *h; 434 bfd_vma relocation; 435 bfd_reloc_status_type r; 436 const char *name = NULL; 437 int r_type; 438 439 /* This is a final link. */ 440 441 r_type = ELF32_R_TYPE (rel->r_info); 442 r_symndx = ELF32_R_SYM (rel->r_info); 443 howto = elf_msp430_howto_table + ELF32_R_TYPE (rel->r_info); 444 h = NULL; 445 sym = NULL; 446 sec = NULL; 447 448 if (r_symndx < symtab_hdr->sh_info) 449 { 450 sym = local_syms + r_symndx; 451 sec = local_sections[r_symndx]; 452 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel); 453 454 name = bfd_elf_string_from_elf_section 455 (input_bfd, symtab_hdr->sh_link, sym->st_name); 456 name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name; 457 } 458 else 459 { 460 bfd_boolean unresolved_reloc, warned; 461 462 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel, 463 r_symndx, symtab_hdr, sym_hashes, 464 h, sec, relocation, 465 unresolved_reloc, warned); 466 } 467 468 r = msp430_final_link_relocate (howto, input_bfd, input_section, 469 contents, rel, relocation); 470 471 if (r != bfd_reloc_ok) 472 { 473 const char *msg = (const char *) NULL; 474 475 switch (r) 476 { 477 case bfd_reloc_overflow: 478 r = info->callbacks->reloc_overflow 479 (info, name, howto->name, (bfd_vma) 0, 480 input_bfd, input_section, rel->r_offset); 481 break; 482 483 case bfd_reloc_undefined: 484 r = info->callbacks->undefined_symbol 485 (info, name, input_bfd, input_section, rel->r_offset, TRUE); 486 break; 487 488 case bfd_reloc_outofrange: 489 msg = _("internal error: out of range error"); 490 break; 491 492 case bfd_reloc_notsupported: 493 msg = _("internal error: unsupported relocation error"); 494 break; 495 496 case bfd_reloc_dangerous: 497 msg = _("internal error: dangerous relocation"); 498 break; 499 500 default: 501 msg = _("internal error: unknown error"); 502 break; 503 } 504 505 if (msg) 506 r = info->callbacks->warning 507 (info, msg, name, input_bfd, input_section, rel->r_offset); 508 509 if (!r) 510 return FALSE; 511 } 512 513 } 514 515 return TRUE; 516 } 517 518 /* The final processing done just before writing out a MSP430 ELF object 519 file. This gets the MSP430 architecture right based on the machine 520 number. */ 521 522 static void 523 bfd_elf_msp430_final_write_processing (abfd, linker) 524 bfd *abfd; 525 bfd_boolean linker ATTRIBUTE_UNUSED; 526 { 527 unsigned long val; 528 529 switch (bfd_get_mach (abfd)) 530 { 531 default: 532 case bfd_mach_msp110: 533 val = E_MSP430_MACH_MSP430x11x1; 534 break; 535 536 case bfd_mach_msp11: 537 val = E_MSP430_MACH_MSP430x11; 538 break; 539 540 case bfd_mach_msp12: 541 val = E_MSP430_MACH_MSP430x12; 542 break; 543 544 case bfd_mach_msp13: 545 val = E_MSP430_MACH_MSP430x13; 546 break; 547 548 case bfd_mach_msp14: 549 val = E_MSP430_MACH_MSP430x14; 550 break; 551 552 case bfd_mach_msp15: 553 val = E_MSP430_MACH_MSP430x15; 554 break; 555 556 case bfd_mach_msp16: 557 val = E_MSP430_MACH_MSP430x16; 558 break; 559 560 case bfd_mach_msp31: 561 val = E_MSP430_MACH_MSP430x31; 562 break; 563 564 case bfd_mach_msp32: 565 val = E_MSP430_MACH_MSP430x32; 566 break; 567 568 case bfd_mach_msp33: 569 val = E_MSP430_MACH_MSP430x33; 570 break; 571 572 case bfd_mach_msp41: 573 val = E_MSP430_MACH_MSP430x41; 574 break; 575 576 case bfd_mach_msp42: 577 val = E_MSP430_MACH_MSP430x42; 578 break; 579 580 case bfd_mach_msp43: 581 val = E_MSP430_MACH_MSP430x43; 582 break; 583 584 case bfd_mach_msp44: 585 val = E_MSP430_MACH_MSP430x44; 586 break; 587 } 588 589 elf_elfheader (abfd)->e_machine = EM_MSP430; 590 elf_elfheader (abfd)->e_flags &= ~EF_MSP430_MACH; 591 elf_elfheader (abfd)->e_flags |= val; 592 } 593 594 /* Set the right machine number. */ 595 596 static bfd_boolean 597 elf32_msp430_object_p (abfd) 598 bfd *abfd; 599 { 600 int e_set = bfd_mach_msp14; 601 602 if (elf_elfheader (abfd)->e_machine == EM_MSP430 603 || elf_elfheader (abfd)->e_machine == EM_MSP430_OLD) 604 { 605 int e_mach = elf_elfheader (abfd)->e_flags & EF_MSP430_MACH; 606 607 switch (e_mach) 608 { 609 default: 610 case E_MSP430_MACH_MSP430x11: 611 e_set = bfd_mach_msp11; 612 break; 613 614 case E_MSP430_MACH_MSP430x11x1: 615 e_set = bfd_mach_msp110; 616 break; 617 618 case E_MSP430_MACH_MSP430x12: 619 e_set = bfd_mach_msp12; 620 break; 621 622 case E_MSP430_MACH_MSP430x13: 623 e_set = bfd_mach_msp13; 624 break; 625 626 case E_MSP430_MACH_MSP430x14: 627 e_set = bfd_mach_msp14; 628 break; 629 630 case E_MSP430_MACH_MSP430x15: 631 e_set = bfd_mach_msp15; 632 break; 633 634 case E_MSP430_MACH_MSP430x16: 635 e_set = bfd_mach_msp16; 636 break; 637 638 case E_MSP430_MACH_MSP430x31: 639 e_set = bfd_mach_msp31; 640 break; 641 642 case E_MSP430_MACH_MSP430x32: 643 e_set = bfd_mach_msp32; 644 break; 645 646 case E_MSP430_MACH_MSP430x33: 647 e_set = bfd_mach_msp33; 648 break; 649 650 case E_MSP430_MACH_MSP430x41: 651 e_set = bfd_mach_msp41; 652 break; 653 654 case E_MSP430_MACH_MSP430x42: 655 e_set = bfd_mach_msp42; 656 break; 657 658 case E_MSP430_MACH_MSP430x43: 659 e_set = bfd_mach_msp43; 660 break; 661 662 case E_MSP430_MACH_MSP430x44: 663 e_set = bfd_mach_msp44; 664 break; 665 } 666 } 667 668 return bfd_default_set_arch_mach (abfd, bfd_arch_msp430, e_set); 669 } 670 671 static void 672 elf32_msp430_post_process_headers (abfd, link_info) 673 bfd *abfd; 674 struct bfd_link_info *link_info ATTRIBUTE_UNUSED; 675 { 676 Elf_Internal_Ehdr *i_ehdrp; /* ELF file header, internal form. */ 677 678 i_ehdrp = elf_elfheader (abfd); 679 680 #ifndef ELFOSABI_STANDALONE 681 #define ELFOSABI_STANDALONE 255 682 #endif 683 684 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_STANDALONE; 685 } 686 687 688 #define ELF_ARCH bfd_arch_msp430 689 #define ELF_MACHINE_CODE EM_MSP430 690 #define ELF_MACHINE_ALT1 EM_MSP430_OLD 691 #define ELF_MAXPAGESIZE 1 692 693 #define TARGET_LITTLE_SYM bfd_elf32_msp430_vec 694 #define TARGET_LITTLE_NAME "elf32-msp430" 695 696 #define elf_info_to_howto msp430_info_to_howto_rela 697 #define elf_info_to_howto_rel NULL 698 #define elf_backend_relocate_section elf32_msp430_relocate_section 699 #define elf_backend_gc_mark_hook elf32_msp430_gc_mark_hook 700 #define elf_backend_gc_sweep_hook elf32_msp430_gc_sweep_hook 701 #define elf_backend_check_relocs elf32_msp430_check_relocs 702 #define elf_backend_can_gc_sections 1 703 #define elf_backend_final_write_processing bfd_elf_msp430_final_write_processing 704 #define elf_backend_object_p elf32_msp430_object_p 705 #define elf_backend_post_process_headers elf32_msp430_post_process_headers 706 707 #include "elf32-target.h" 708