?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
daily update
[binutils.git] / bfd / elf32-msp430.c
blob306a79889bcb46e00835a260813c0bfce4297bb8
1 /* MSP430-specific support for 32-bit ELF
2 Copyright (C) 2002, 2003 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 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
461
462 while (h->root.type == bfd_link_hash_indirect
463 || h->root.type == bfd_link_hash_warning)
464 h = (struct elf_link_hash_entry *) h->root.u.i.link;
465
466 name = h->root.root.string;
467
468 if (h->root.type == bfd_link_hash_defined
469 || h->root.type == bfd_link_hash_defweak)
470 {
471 sec = h->root.u.def.section;
472 relocation = (h->root.u.def.value
473 + sec->output_section->vma + sec->output_offset);
474 }
475 else if (h->root.type == bfd_link_hash_undefweak)
476 {
477 relocation = 0;
478 }
479 else
480 {
481 if (!((*info->callbacks->undefined_symbol)
482 (info, h->root.root.string, input_bfd,
483 input_section, rel->r_offset, TRUE)))
484 return FALSE;
485 relocation = 0;
486 }
487 }
488
489 r = msp430_final_link_relocate (howto, input_bfd, input_section,
490 contents, rel, relocation);
491
492 if (r != bfd_reloc_ok)
493 {
494 const char *msg = (const char *) NULL;
495
496 switch (r)
497 {
498 case bfd_reloc_overflow:
499 r = info->callbacks->reloc_overflow
500 (info, name, howto->name, (bfd_vma) 0,
501 input_bfd, input_section, rel->r_offset);
502 break;
503
504 case bfd_reloc_undefined:
505 r = info->callbacks->undefined_symbol
506 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
507 break;
508
509 case bfd_reloc_outofrange:
510 msg = _("internal error: out of range error");
511 break;
512
513 case bfd_reloc_notsupported:
514 msg = _("internal error: unsupported relocation error");
515 break;
516
517 case bfd_reloc_dangerous:
518 msg = _("internal error: dangerous relocation");
519 break;
520
521 default:
522 msg = _("internal error: unknown error");
523 break;
524 }
525
526 if (msg)
527 r = info->callbacks->warning
528 (info, msg, name, input_bfd, input_section, rel->r_offset);
529
530 if (!r)
531 return FALSE;
532 }
533
534 }
535
536 return TRUE;
537 }
538
539 /* The final processing done just before writing out a MSP430 ELF object
540 file. This gets the MSP430 architecture right based on the machine
541 number. */
542
543 static void
544 bfd_elf_msp430_final_write_processing (abfd, linker)
545 bfd *abfd;
546 bfd_boolean linker ATTRIBUTE_UNUSED;
547 {
548 unsigned long val;
549
550 switch (bfd_get_mach (abfd))
551 {
552 default:
553 case bfd_mach_msp110:
554 val = E_MSP430_MACH_MSP430x11x1;
555 break;
556
557 case bfd_mach_msp11:
558 val = E_MSP430_MACH_MSP430x11;
559 break;
560
561 case bfd_mach_msp12:
562 val = E_MSP430_MACH_MSP430x12;
563 break;
564
565 case bfd_mach_msp13:
566 val = E_MSP430_MACH_MSP430x13;
567 break;
568
569 case bfd_mach_msp14:
570 val = E_MSP430_MACH_MSP430x14;
571 break;
572
573 case bfd_mach_msp15:
574 val = E_MSP430_MACH_MSP430x15;
575 break;
576
577 case bfd_mach_msp16:
578 val = E_MSP430_MACH_MSP430x16;
579 break;
580
581 case bfd_mach_msp31:
582 val = E_MSP430_MACH_MSP430x31;
583 break;
584
585 case bfd_mach_msp32:
586 val = E_MSP430_MACH_MSP430x32;
587 break;
588
589 case bfd_mach_msp33:
590 val = E_MSP430_MACH_MSP430x33;
591 break;
592
593 case bfd_mach_msp41:
594 val = E_MSP430_MACH_MSP430x41;
595 break;
596
597 case bfd_mach_msp42:
598 val = E_MSP430_MACH_MSP430x42;
599 break;
600
601 case bfd_mach_msp43:
602 val = E_MSP430_MACH_MSP430x43;
603 break;
604
605 case bfd_mach_msp44:
606 val = E_MSP430_MACH_MSP430x44;
607 break;
608 }
609
610 elf_elfheader (abfd)->e_machine = EM_MSP430;
611 elf_elfheader (abfd)->e_flags &= ~EF_MSP430_MACH;
612 elf_elfheader (abfd)->e_flags |= val;
613 }
614
615 /* Set the right machine number. */
616
617 static bfd_boolean
618 elf32_msp430_object_p (abfd)
619 bfd *abfd;
620 {
621 int e_set = bfd_mach_msp14;
622
623 if (elf_elfheader (abfd)->e_machine == EM_MSP430
624 || elf_elfheader (abfd)->e_machine == EM_MSP430_OLD)
625 {
626 int e_mach = elf_elfheader (abfd)->e_flags & EF_MSP430_MACH;
627
628 switch (e_mach)
629 {
630 default:
631 case E_MSP430_MACH_MSP430x11:
632 e_set = bfd_mach_msp11;
633 break;
634
635 case E_MSP430_MACH_MSP430x11x1:
636 e_set = bfd_mach_msp110;
637 break;
638
639 case E_MSP430_MACH_MSP430x12:
640 e_set = bfd_mach_msp12;
641 break;
642
643 case E_MSP430_MACH_MSP430x13:
644 e_set = bfd_mach_msp13;
645 break;
646
647 case E_MSP430_MACH_MSP430x14:
648 e_set = bfd_mach_msp14;
649 break;
650
651 case E_MSP430_MACH_MSP430x15:
652 e_set = bfd_mach_msp15;
653 break;
654
655 case E_MSP430_MACH_MSP430x16:
656 e_set = bfd_mach_msp16;
657 break;
658
659 case E_MSP430_MACH_MSP430x31:
660 e_set = bfd_mach_msp31;
661 break;
662
663 case E_MSP430_MACH_MSP430x32:
664 e_set = bfd_mach_msp32;
665 break;
666
667 case E_MSP430_MACH_MSP430x33:
668 e_set = bfd_mach_msp33;
669 break;
670
671 case E_MSP430_MACH_MSP430x41:
672 e_set = bfd_mach_msp41;
673 break;
674
675 case E_MSP430_MACH_MSP430x42:
676 e_set = bfd_mach_msp42;
677 break;
678
679 case E_MSP430_MACH_MSP430x43:
680 e_set = bfd_mach_msp43;
681 break;
682
683 case E_MSP430_MACH_MSP430x44:
684 e_set = bfd_mach_msp44;
685 break;
686 }
687 }
688
689 return bfd_default_set_arch_mach (abfd, bfd_arch_msp430, e_set);
690 }
691
692 static void
693 elf32_msp430_post_process_headers (abfd, link_info)
694 bfd *abfd;
695 struct bfd_link_info *link_info ATTRIBUTE_UNUSED;
696 {
697 Elf_Internal_Ehdr *i_ehdrp; /* ELF file header, internal form. */
698
699 i_ehdrp = elf_elfheader (abfd);
700
701 #ifndef ELFOSABI_STANDALONE
702 #define ELFOSABI_STANDALONE 255
703 #endif
704
705 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_STANDALONE;
706 }
707
708
709 #define ELF_ARCH bfd_arch_msp430
710 #define ELF_MACHINE_CODE EM_MSP430
711 #define ELF_MACHINE_ALT1 EM_MSP430_OLD
712 #define ELF_MAXPAGESIZE 1
713
714 #define TARGET_LITTLE_SYM bfd_elf32_msp430_vec
715 #define TARGET_LITTLE_NAME "elf32-msp430"
716
717 #define elf_info_to_howto msp430_info_to_howto_rela
718 #define elf_info_to_howto_rel NULL
719 #define elf_backend_relocate_section elf32_msp430_relocate_section
720 #define elf_backend_gc_mark_hook elf32_msp430_gc_mark_hook
721 #define elf_backend_gc_sweep_hook elf32_msp430_gc_sweep_hook
722 #define elf_backend_check_relocs elf32_msp430_check_relocs
723 #define elf_backend_can_gc_sections 1
724 #define elf_backend_final_write_processing bfd_elf_msp430_final_write_processing
725 #define elf_backend_object_p elf32_msp430_object_p
726 #define elf_backend_post_process_headers elf32_msp430_post_process_headers
727
728 #include "elf32-target.h"
git-cvsimport of binutils cvsroot