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