?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* config/m68k-parse.h: Use ISO C90.
[binutils.git] / bfd / elf32-msp430.c
blobda4278267c39bca3373020c932c7a0ce8111c50a
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
31 static 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
169 struct msp430_reloc_map
170 {
171 bfd_reloc_code_real_type bfd_reloc_val;
172 unsigned int elf_reloc_val;
173 };
174
175 static 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
189 static reloc_howto_type *
190 bfd_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
204 static void
205 msp430_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
216 static asection *
217 elf32_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
248 static bfd_boolean
249 elf32_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
262 static bfd_boolean
263 elf32_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
305 static bfd_reloc_status_type
306 msp430_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
426 static bfd_boolean
427 elf32_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
541 static void
542 bfd_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
614 static bfd_boolean
615 elf32_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
688 static void
689 elf32_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
764 static 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
794 static bfd_boolean
795 msp430_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 /* Delete some bytes from a section while relaxing. */
834
835 static bfd_boolean
836 msp430_elf_relax_delete_bytes (bfd * abfd, asection * sec, bfd_vma addr,
837 int count)
838 {
839 Elf_Internal_Shdr *symtab_hdr;
840 unsigned int sec_shndx;
841 bfd_byte *contents;
842 Elf_Internal_Rela *irel;
843 Elf_Internal_Rela *irelend;
844 Elf_Internal_Rela *irelalign;
845 bfd_vma toaddr;
846 Elf_Internal_Sym *isym;
847 Elf_Internal_Sym *isymend;
848 struct elf_link_hash_entry **sym_hashes;
849 struct elf_link_hash_entry **end_hashes;
850 unsigned int symcount;
851
852 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
853
854 contents = elf_section_data (sec)->this_hdr.contents;
855
856 /* The deletion must stop at the next ALIGN reloc for an aligment
857 power larger than the number of bytes we are deleting. */
858
859 irelalign = NULL;
860 toaddr = sec->size;
861
862 irel = elf_section_data (sec)->relocs;
863 irelend = irel + sec->reloc_count;
864
865 /* Actually delete the bytes. */
866 memmove (contents + addr, contents + addr + count,
867 (size_t) (toaddr - addr - count));
868 sec->size -= count;
869
870 /* Adjust all the relocs. */
871 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
872 /* Get the new reloc address. */
873 if ((irel->r_offset > addr && irel->r_offset < toaddr))
874 irel->r_offset -= count;
875
876 /* Adjust the local symbols defined in this section. */
877 symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
878 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
879 for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
880 if (isym->st_shndx == sec_shndx
881 && isym->st_value > addr && isym->st_value < toaddr)
882 isym->st_value -= count;
883
884 /* Now adjust the global symbols defined in this section. */
885 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
886 - symtab_hdr->sh_info);
887 sym_hashes = elf_sym_hashes (abfd);
888 end_hashes = sym_hashes + symcount;
889 for (; sym_hashes < end_hashes; sym_hashes++)
890 {
891 struct elf_link_hash_entry *sym_hash = *sym_hashes;
892
893 if ((sym_hash->root.type == bfd_link_hash_defined
894 || sym_hash->root.type == bfd_link_hash_defweak)
895 && sym_hash->root.u.def.section == sec
896 && sym_hash->root.u.def.value > addr
897 && sym_hash->root.u.def.value < toaddr)
898 sym_hash->root.u.def.value -= count;
899 }
900
901 return TRUE;
902 }
903
904
905 static bfd_boolean
906 msp430_elf_relax_section (bfd * abfd, asection * sec,
907 struct bfd_link_info * link_info,
908 bfd_boolean * again)
909 {
910 Elf_Internal_Shdr * symtab_hdr;
911 Elf_Internal_Rela * internal_relocs;
912 Elf_Internal_Rela * irel;
913 Elf_Internal_Rela * irelend;
914 bfd_byte * contents = NULL;
915 Elf_Internal_Sym * isymbuf = NULL;
916
917 /* Assume nothing changes. */
918 *again = FALSE;
919
920 /* We don't have to do anything for a relocatable link, if
921 this section does not have relocs, or if this is not a
922 code section. */
923 if (link_info->relocatable
924 || (sec->flags & SEC_RELOC) == 0
925 || sec->reloc_count == 0 || (sec->flags & SEC_CODE) == 0)
926 return TRUE;
927
928 symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
929
930 /* Get a copy of the native relocations. */
931 internal_relocs =
932 _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL, link_info->keep_memory);
933 if (internal_relocs == NULL)
934 goto error_return;
935
936 /* Walk through them looking for relaxing opportunities. */
937 irelend = internal_relocs + sec->reloc_count;
938 for (irel = internal_relocs; irel < irelend; irel++)
939 {
940 bfd_vma symval;
941
942 /* If this isn't something that can be relaxed, then ignore
943 this reloc. */
944 if (ELF32_R_TYPE (irel->r_info) != (int) R_MSP430_RL_PCREL)
945 continue;
946
947 /* Get the section contents if we haven't done so already. */
948 if (contents == NULL)
949 {
950 /* Get cached copy if it exists. */
951 if (elf_section_data (sec)->this_hdr.contents != NULL)
952 contents = elf_section_data (sec)->this_hdr.contents;
953 else if (! bfd_malloc_and_get_section (abfd, sec, &contents))
954 goto error_return;
955 }
956
957 /* Read this BFD's local symbols if we haven't done so already. */
958 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
959 {
960 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
961 if (isymbuf == NULL)
962 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
963 symtab_hdr->sh_info, 0,
964 NULL, NULL, NULL);
965 if (isymbuf == NULL)
966 goto error_return;
967 }
968
969 /* Get the value of the symbol referred to by the reloc. */
970 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
971 {
972 /* A local symbol. */
973 Elf_Internal_Sym *isym;
974 asection *sym_sec;
975
976 isym = isymbuf + ELF32_R_SYM (irel->r_info);
977 if (isym->st_shndx == SHN_UNDEF)
978 sym_sec = bfd_und_section_ptr;
979 else if (isym->st_shndx == SHN_ABS)
980 sym_sec = bfd_abs_section_ptr;
981 else if (isym->st_shndx == SHN_COMMON)
982 sym_sec = bfd_com_section_ptr;
983 else
984 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
985 symval = (isym->st_value
986 + sym_sec->output_section->vma + sym_sec->output_offset);
987 }
988 else
989 {
990 unsigned long indx;
991 struct elf_link_hash_entry *h;
992
993 /* An external symbol. */
994 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
995 h = elf_sym_hashes (abfd)[indx];
996 BFD_ASSERT (h != NULL);
997
998 if (h->root.type != bfd_link_hash_defined
999 && h->root.type != bfd_link_hash_defweak)
1000 /* This appears to be a reference to an undefined
1001 symbol. Just ignore it--it will be caught by the
1002 regular reloc processing. */
1003 continue;
1004
1005 symval = (h->root.u.def.value
1006 + h->root.u.def.section->output_section->vma
1007 + h->root.u.def.section->output_offset);
1008 }
1009
1010 /* For simplicity of coding, we are going to modify the section
1011 contents, the section relocs, and the BFD symbol table. We
1012 must tell the rest of the code not to free up this
1013 information. It would be possible to instead create a table
1014 of changes which have to be made, as is done in coff-mips.c;
1015 that would be more work, but would require less memory when
1016 the linker is run. */
1017
1018 /* Try to turn a 16bit pc-relative branch into a 10bit pc-relative
1019 branch. */
1020 /* Paranoia? paranoia... */
1021 if (ELF32_R_TYPE (irel->r_info) == (int) R_MSP430_RL_PCREL)
1022 {
1023 bfd_vma value = symval;
1024
1025 /* Deal with pc-relative gunk. */
1026 value -= (sec->output_section->vma + sec->output_offset);
1027 value -= irel->r_offset;
1028 value += irel->r_addend;
1029
1030 /* See if the value will fit in 10 bits, note the high value is
1031 1016 as the target will be two bytes closer if we are
1032 able to relax. */
1033 if ((long) value < 1016 && (long) value > -1016)
1034 {
1035 int code0 = 0, code1 = 0, code2 = 0;
1036 int i;
1037 struct rcodes_s *rx;
1038
1039 /* Get the opcode. */
1040 if (irel->r_offset >= 6)
1041 code0 = bfd_get_16 (abfd, contents + irel->r_offset - 6);
1042
1043 if (irel->r_offset >= 4)
1044 code1 = bfd_get_16 (abfd, contents + irel->r_offset - 4);
1045
1046 code2 = bfd_get_16 (abfd, contents + irel->r_offset - 2);
1047
1048 if (code2 != 0x4010)
1049 continue;
1050
1051 /* Check r4 and r3. */
1052 for (i = NUMB_RELAX_CODES - 1; i >= 0; i--)
1053 {
1054 rx = &rcode[i];
1055 if (rx->cdx == 2 && rx->f0 == code0 && rx->f1 == code1)
1056 break;
1057 else if (rx->cdx == 1 && rx->f1 == code1)
1058 break;
1059 else if (rx->cdx == 0) /* This is an unconditional jump. */
1060 break;
1061 }
1062
1063 /* Check labels:
1064 .Label0: ; we do not care about this label
1065 jeq +6
1066 .Label1: ; make sure there is no label here
1067 jl +4
1068 .Label2: ; make sure there is no label here
1069 br .Label_dst
1070
1071 So, if there is .Label1 or .Label2 we cannot relax this code.
1072 This actually should not happen, cause for relaxable
1073 instructions we use RL_PCREL reloc instead of 16_PCREL.
1074 Will change this in the future. */
1075
1076 if (rx->cdx > 0
1077 && msp430_elf_symbol_address_p (abfd, sec, isymbuf,
1078 irel->r_offset - 2))
1079 continue;
1080 if (rx->cdx > 1
1081 && msp430_elf_symbol_address_p (abfd, sec, isymbuf,
1082 irel->r_offset - 4))
1083 continue;
1084
1085 /* Note that we've changed the relocs, section contents, etc. */
1086 elf_section_data (sec)->relocs = internal_relocs;
1087 elf_section_data (sec)->this_hdr.contents = contents;
1088 symtab_hdr->contents = (unsigned char *) isymbuf;
1089
1090 /* Fix the relocation's type. */
1091 if (rx->labels == 3) /* Handle special cases. */
1092 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1093 R_MSP430_2X_PCREL);
1094 else
1095 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1096 R_MSP430_10_PCREL);
1097
1098 /* Fix the opcode right way. */
1099 bfd_put_16 (abfd, rx->t0, contents + irel->r_offset - rx->off);
1100 if (rx->t1)
1101 bfd_put_16 (abfd, rx->t1,
1102 contents + irel->r_offset - rx->off + 2);
1103
1104 /* Delete bytes. */
1105 if (!msp430_elf_relax_delete_bytes (abfd, sec,
1106 irel->r_offset - rx->off +
1107 rx->ncl, rx->bs))
1108 goto error_return;
1109
1110 /* Handle unconditional jumps. */
1111 if (rx->cdx == 0)
1112 irel->r_offset -= 2;
1113
1114 /* That will change things, so, we should relax again.
1115 Note that this is not required, and it may be slow. */
1116 *again = TRUE;
1117 }
1118 }
1119 }
1120
1121 if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
1122 {
1123 if (!link_info->keep_memory)
1124 free (isymbuf);
1125 else
1126 {
1127 /* Cache the symbols for elf_link_input_bfd. */
1128 symtab_hdr->contents = (unsigned char *) isymbuf;
1129 }
1130 }
1131
1132 if (contents != NULL
1133 && elf_section_data (sec)->this_hdr.contents != contents)
1134 {
1135 if (!link_info->keep_memory)
1136 free (contents);
1137 else
1138 {
1139 /* Cache the section contents for elf_link_input_bfd. */
1140 elf_section_data (sec)->this_hdr.contents = contents;
1141 }
1142 }
1143
1144 if (internal_relocs != NULL
1145 && elf_section_data (sec)->relocs != internal_relocs)
1146 free (internal_relocs);
1147
1148 return TRUE;
1149
1150 error_return:
1151 if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
1152 free (isymbuf);
1153 if (contents != NULL
1154 && elf_section_data (sec)->this_hdr.contents != contents)
1155 free (contents);
1156 if (internal_relocs != NULL
1157 && elf_section_data (sec)->relocs != internal_relocs)
1158 free (internal_relocs);
1159
1160 return FALSE;
1161 }
1162
1163
1164 #define ELF_ARCH bfd_arch_msp430
1165 #define ELF_MACHINE_CODE EM_MSP430
1166 #define ELF_MACHINE_ALT1 EM_MSP430_OLD
1167 #define ELF_MAXPAGESIZE 1
1168
1169 #define TARGET_LITTLE_SYM bfd_elf32_msp430_vec
1170 #define TARGET_LITTLE_NAME "elf32-msp430"
1171
1172 #define elf_info_to_howto msp430_info_to_howto_rela
1173 #define elf_info_to_howto_rel NULL
1174 #define elf_backend_relocate_section elf32_msp430_relocate_section
1175 #define elf_backend_gc_mark_hook elf32_msp430_gc_mark_hook
1176 #define elf_backend_gc_sweep_hook elf32_msp430_gc_sweep_hook
1177 #define elf_backend_check_relocs elf32_msp430_check_relocs
1178 #define elf_backend_can_gc_sections 1
1179 #define elf_backend_final_write_processing bfd_elf_msp430_final_write_processing
1180 #define elf_backend_object_p elf32_msp430_object_p
1181 #define elf_backend_post_process_headers elf32_msp430_post_process_headers
1182 #define bfd_elf32_bfd_relax_section msp430_elf_relax_section
1183
1184 #include "elf32-target.h"
git-cvsimport of binutils cvsroot