projects / deliverable / binutils-gdb.git / blob
? search:


edd49f7e4897d7f2b6bcffe0afcedc1ec72974c4
[deliverable/binutils-gdb.git] / bfd / elf32-msp430.c
1 /* MSP430-specific support for 32-bit ELF
2 Copyright (C) 2002-2015 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 3 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,
20 MA 02110-1301, USA. */
21
22 #include "sysdep.h"
23 #include "bfd.h"
24 #include "libiberty.h"
25 #include "libbfd.h"
26 #include "elf-bfd.h"
27 #include "elf/msp430.h"
28
29 static bfd_reloc_status_type
30 rl78_sym_diff_handler (bfd * abfd,
31 arelent * reloc,
32 asymbol * sym ATTRIBUTE_UNUSED,
33 void * addr ATTRIBUTE_UNUSED,
34 asection * input_sec,
35 bfd * out_bfd ATTRIBUTE_UNUSED,
36 char ** error_message ATTRIBUTE_UNUSED)
37 {
38 bfd_size_type octets;
39 octets = reloc->address * bfd_octets_per_byte (abfd);
40
41 /* Catch the case where bfd_install_relocation would return
42 bfd_reloc_outofrange because the SYM_DIFF reloc is being used in a very
43 small section. It does not actually matter if this happens because all
44 that SYM_DIFF does is compute a (4-byte) value. A second reloc then uses
45 this value, and it is that reloc that must fit into the section.
46
47 This happens in eg, gcc/testsuite/gcc.c-torture/compile/labels-3.c. */
48 if ((octets + bfd_get_reloc_size (reloc->howto))
49 > bfd_get_section_limit_octets (abfd, input_sec))
50 return bfd_reloc_ok;
51 return bfd_reloc_continue;
52 }
53
54 static reloc_howto_type elf_msp430_howto_table[] =
55 {
56 HOWTO (R_MSP430_NONE, /* type */
57 0, /* rightshift */
58 3, /* size (0 = byte, 1 = short, 2 = long) */
59 0, /* bitsize */
60 FALSE, /* pc_relative */
61 0, /* bitpos */
62 complain_overflow_dont,/* complain_on_overflow */
63 bfd_elf_generic_reloc, /* special_function */
64 "R_MSP430_NONE", /* name */
65 FALSE, /* partial_inplace */
66 0, /* src_mask */
67 0, /* dst_mask */
68 FALSE), /* pcrel_offset */
69
70 HOWTO (R_MSP430_32, /* type */
71 0, /* rightshift */
72 2, /* size (0 = byte, 1 = short, 2 = long) */
73 32, /* bitsize */
74 FALSE, /* pc_relative */
75 0, /* bitpos */
76 complain_overflow_bitfield,/* complain_on_overflow */
77 bfd_elf_generic_reloc, /* special_function */
78 "R_MSP430_32", /* name */
79 FALSE, /* partial_inplace */
80 0xffffffff, /* src_mask */
81 0xffffffff, /* dst_mask */
82 FALSE), /* pcrel_offset */
83
84 /* A 10 bit PC relative relocation. */
85 HOWTO (R_MSP430_10_PCREL, /* type */
86 1, /* rightshift */
87 1, /* size (0 = byte, 1 = short, 2 = long) */
88 10, /* bitsize */
89 TRUE, /* pc_relative */
90 0, /* bitpos */
91 complain_overflow_bitfield,/* complain_on_overflow */
92 bfd_elf_generic_reloc, /* special_function */
93 "R_MSP430_10_PCREL", /* name */
94 FALSE, /* partial_inplace */
95 0x3ff, /* src_mask */
96 0x3ff, /* dst_mask */
97 TRUE), /* pcrel_offset */
98
99 /* A 16 bit absolute relocation. */
100 HOWTO (R_MSP430_16, /* type */
101 0, /* rightshift */
102 1, /* size (0 = byte, 1 = short, 2 = long) */
103 16, /* bitsize */
104 FALSE, /* pc_relative */
105 0, /* bitpos */
106 complain_overflow_dont,/* complain_on_overflow */
107 bfd_elf_generic_reloc, /* special_function */
108 "R_MSP430_16", /* name */
109 FALSE, /* partial_inplace */
110 0, /* src_mask */
111 0xffff, /* dst_mask */
112 FALSE), /* pcrel_offset */
113
114 /* A 16 bit PC relative relocation for command address. */
115 HOWTO (R_MSP430_16_PCREL, /* type */
116 1, /* rightshift */
117 1, /* size (0 = byte, 1 = short, 2 = long) */
118 16, /* bitsize */
119 TRUE, /* pc_relative */
120 0, /* bitpos */
121 complain_overflow_dont,/* complain_on_overflow */
122 bfd_elf_generic_reloc, /* special_function */
123 "R_MSP430_16_PCREL", /* name */
124 FALSE, /* partial_inplace */
125 0, /* src_mask */
126 0xffff, /* dst_mask */
127 TRUE), /* pcrel_offset */
128
129 /* A 16 bit absolute relocation, byte operations. */
130 HOWTO (R_MSP430_16_BYTE, /* type */
131 0, /* rightshift */
132 1, /* size (0 = byte, 1 = short, 2 = long) */
133 16, /* bitsize */
134 FALSE, /* pc_relative */
135 0, /* bitpos */
136 complain_overflow_dont,/* complain_on_overflow */
137 bfd_elf_generic_reloc, /* special_function */
138 "R_MSP430_16_BYTE", /* name */
139 FALSE, /* partial_inplace */
140 0xffff, /* src_mask */
141 0xffff, /* dst_mask */
142 FALSE), /* pcrel_offset */
143
144 /* A 16 bit absolute relocation for command address. */
145 HOWTO (R_MSP430_16_PCREL_BYTE,/* type */
146 1, /* rightshift */
147 1, /* size (0 = byte, 1 = short, 2 = long) */
148 16, /* bitsize */
149 TRUE, /* pc_relative */
150 0, /* bitpos */
151 complain_overflow_dont,/* complain_on_overflow */
152 bfd_elf_generic_reloc, /* special_function */
153 "R_MSP430_16_PCREL_BYTE",/* name */
154 FALSE, /* partial_inplace */
155 0xffff, /* src_mask */
156 0xffff, /* dst_mask */
157 TRUE), /* pcrel_offset */
158
159 /* A 10 bit PC relative relocation for complicated polymorphs. */
160 HOWTO (R_MSP430_2X_PCREL, /* type */
161 1, /* rightshift */
162 2, /* size (0 = byte, 1 = short, 2 = long) */
163 10, /* bitsize */
164 TRUE, /* pc_relative */
165 0, /* bitpos */
166 complain_overflow_bitfield,/* complain_on_overflow */
167 bfd_elf_generic_reloc, /* special_function */
168 "R_MSP430_2X_PCREL", /* name */
169 FALSE, /* partial_inplace */
170 0x3ff, /* src_mask */
171 0x3ff, /* dst_mask */
172 TRUE), /* pcrel_offset */
173
174 /* A 16 bit relaxable relocation for command address. */
175 HOWTO (R_MSP430_RL_PCREL, /* type */
176 1, /* rightshift */
177 1, /* size (0 = byte, 1 = short, 2 = long) */
178 16, /* bitsize */
179 TRUE, /* pc_relative */
180 0, /* bitpos */
181 complain_overflow_dont,/* complain_on_overflow */
182 bfd_elf_generic_reloc, /* special_function */
183 "R_MSP430_RL_PCREL", /* name */
184 FALSE, /* partial_inplace */
185 0, /* src_mask */
186 0xffff, /* dst_mask */
187 TRUE) /* pcrel_offset */
188
189 /* A 8-bit absolute relocation. */
190 , HOWTO (R_MSP430_8, /* type */
191 0, /* rightshift */
192 0, /* size (0 = byte, 1 = short, 2 = long) */
193 8, /* bitsize */
194 FALSE, /* pc_relative */
195 0, /* bitpos */
196 complain_overflow_dont,/* complain_on_overflow */
197 bfd_elf_generic_reloc, /* special_function */
198 "R_MSP430_8", /* name */
199 FALSE, /* partial_inplace */
200 0, /* src_mask */
201 0xffff, /* dst_mask */
202 FALSE), /* pcrel_offset */
203
204 /* Together with a following reloc, allows for the difference
205 between two symbols to be the real addend of the second reloc. */
206 HOWTO (R_MSP430_SYM_DIFF, /* type */
207 0, /* rightshift */
208 2, /* size (0 = byte, 1 = short, 2 = long) */
209 32, /* bitsize */
210 FALSE, /* pc_relative */
211 0, /* bitpos */
212 complain_overflow_dont,/* complain_on_overflow */
213 rl78_sym_diff_handler, /* special handler. */
214 "R_MSP430_SYM_DIFF", /* name */
215 FALSE, /* partial_inplace */
216 0xffffffff, /* src_mask */
217 0xffffffff, /* dst_mask */
218 FALSE) /* pcrel_offset */
219 };
220
221 static reloc_howto_type elf_msp430x_howto_table[] =
222 {
223 HOWTO (R_MSP430_NONE, /* type */
224 0, /* rightshift */
225 3, /* size (0 = byte, 1 = short, 2 = long) */
226 0, /* bitsize */
227 FALSE, /* pc_relative */
228 0, /* bitpos */
229 complain_overflow_dont,/* complain_on_overflow */
230 bfd_elf_generic_reloc, /* special_function */
231 "R_MSP430_NONE", /* name */
232 FALSE, /* partial_inplace */
233 0, /* src_mask */
234 0, /* dst_mask */
235 FALSE), /* pcrel_offset */
236
237 HOWTO (R_MSP430_ABS32, /* type */
238 0, /* rightshift */
239 2, /* size (0 = byte, 1 = short, 2 = long) */
240 32, /* bitsize */
241 FALSE, /* pc_relative */
242 0, /* bitpos */
243 complain_overflow_bitfield,/* complain_on_overflow */
244 bfd_elf_generic_reloc, /* special_function */
245 "R_MSP430_ABS32", /* name */
246 FALSE, /* partial_inplace */
247 0xffffffff, /* src_mask */
248 0xffffffff, /* dst_mask */
249 FALSE), /* pcrel_offset */
250
251 HOWTO (R_MSP430_ABS16, /* type */
252 0, /* rightshift */
253 1, /* size (0 = byte, 1 = short, 2 = long) */
254 16, /* bitsize */
255 FALSE, /* pc_relative */
256 0, /* bitpos */
257 complain_overflow_dont,/* complain_on_overflow */
258 bfd_elf_generic_reloc, /* special_function */
259 "R_MSP430_ABS16", /* name */
260 FALSE, /* partial_inplace */
261 0, /* src_mask */
262 0xffff, /* dst_mask */
263 FALSE), /* pcrel_offset */
264
265 HOWTO (R_MSP430_ABS8, /* type */
266 0, /* rightshift */
267 0, /* size (0 = byte, 1 = short, 2 = long) */
268 8, /* bitsize */
269 FALSE, /* pc_relative */
270 0, /* bitpos */
271 complain_overflow_bitfield,/* complain_on_overflow */
272 bfd_elf_generic_reloc, /* special_function */
273 "R_MSP430_ABS8", /* name */
274 FALSE, /* partial_inplace */
275 0xff, /* src_mask */
276 0xff, /* dst_mask */
277 FALSE), /* pcrel_offset */
278
279 HOWTO (R_MSP430_PCR16, /* type */
280 1, /* rightshift */
281 1, /* size (0 = byte, 1 = short, 2 = long) */
282 16, /* bitsize */
283 TRUE, /* pc_relative */
284 0, /* bitpos */
285 complain_overflow_dont,/* complain_on_overflow */
286 bfd_elf_generic_reloc, /* special_function */
287 "R_MSP430_PCR16", /* name */
288 FALSE, /* partial_inplace */
289 0, /* src_mask */
290 0xffff, /* dst_mask */
291 TRUE), /* pcrel_offset */
292
293 HOWTO (R_MSP430X_PCR20_EXT_SRC,/* type */
294 0, /* rightshift */
295 2, /* size (0 = byte, 1 = short, 2 = long) */
296 32, /* bitsize */
297 TRUE, /* pc_relative */
298 0, /* bitpos */
299 complain_overflow_dont,/* complain_on_overflow */
300 bfd_elf_generic_reloc, /* special_function */
301 "R_MSP430X_PCR20_EXT_SRC",/* name */
302 FALSE, /* partial_inplace */
303 0, /* src_mask */
304 0xffff, /* dst_mask */
305 TRUE), /* pcrel_offset */
306
307 HOWTO (R_MSP430X_PCR20_EXT_DST,/* type */
308 0, /* rightshift */
309 2, /* size (0 = byte, 1 = short, 2 = long) */
310 32, /* bitsize */
311 TRUE, /* pc_relative */
312 0, /* bitpos */
313 complain_overflow_dont,/* complain_on_overflow */
314 bfd_elf_generic_reloc, /* special_function */
315 "R_MSP430X_PCR20_EXT_DST",/* name */
316 FALSE, /* partial_inplace */
317 0, /* src_mask */
318 0xffff, /* dst_mask */
319 TRUE), /* pcrel_offset */
320
321 HOWTO (R_MSP430X_PCR20_EXT_ODST,/* type */
322 0, /* rightshift */
323 2, /* size (0 = byte, 1 = short, 2 = long) */
324 32, /* bitsize */
325 TRUE, /* pc_relative */
326 0, /* bitpos */
327 complain_overflow_dont,/* complain_on_overflow */
328 bfd_elf_generic_reloc, /* special_function */
329 "R_MSP430X_PCR20_EXT_ODST",/* name */
330 FALSE, /* partial_inplace */
331 0, /* src_mask */
332 0xffff, /* dst_mask */
333 TRUE), /* pcrel_offset */
334
335 HOWTO (R_MSP430X_ABS20_EXT_SRC,/* type */
336 0, /* rightshift */
337 2, /* size (0 = byte, 1 = short, 2 = long) */
338 32, /* bitsize */
339 TRUE, /* pc_relative */
340 0, /* bitpos */
341 complain_overflow_dont,/* complain_on_overflow */
342 bfd_elf_generic_reloc, /* special_function */
343 "R_MSP430X_ABS20_EXT_SRC",/* name */
344 FALSE, /* partial_inplace */
345 0, /* src_mask */
346 0xffff, /* dst_mask */
347 TRUE), /* pcrel_offset */
348
349 HOWTO (R_MSP430X_ABS20_EXT_DST,/* type */
350 0, /* rightshift */
351 2, /* size (0 = byte, 1 = short, 2 = long) */
352 32, /* bitsize */
353 TRUE, /* pc_relative */
354 0, /* bitpos */
355 complain_overflow_dont,/* complain_on_overflow */
356 bfd_elf_generic_reloc, /* special_function */
357 "R_MSP430X_ABS20_EXT_DST",/* name */
358 FALSE, /* partial_inplace */
359 0, /* src_mask */
360 0xffff, /* dst_mask */
361 TRUE), /* pcrel_offset */
362
363 HOWTO (R_MSP430X_ABS20_EXT_ODST,/* type */
364 0, /* rightshift */
365 2, /* size (0 = byte, 1 = short, 2 = long) */
366 32, /* bitsize */
367 TRUE, /* pc_relative */
368 0, /* bitpos */
369 complain_overflow_dont,/* complain_on_overflow */
370 bfd_elf_generic_reloc, /* special_function */
371 "R_MSP430X_ABS20_EXT_ODST",/* name */
372 FALSE, /* partial_inplace */
373 0, /* src_mask */
374 0xffff, /* dst_mask */
375 TRUE), /* pcrel_offset */
376
377 HOWTO (R_MSP430X_ABS20_ADR_SRC,/* type */
378 0, /* rightshift */
379 2, /* size (0 = byte, 1 = short, 2 = long) */
380 32, /* bitsize */
381 TRUE, /* pc_relative */
382 0, /* bitpos */
383 complain_overflow_dont,/* complain_on_overflow */
384 bfd_elf_generic_reloc, /* special_function */
385 "R_MSP430X_ABS20_ADR_SRC",/* name */
386 FALSE, /* partial_inplace */
387 0, /* src_mask */
388 0xffff, /* dst_mask */
389 TRUE), /* pcrel_offset */
390
391 HOWTO (R_MSP430X_ABS20_ADR_DST,/* type */
392 0, /* rightshift */
393 2, /* size (0 = byte, 1 = short, 2 = long) */
394 32, /* bitsize */
395 TRUE, /* pc_relative */
396 0, /* bitpos */
397 complain_overflow_dont,/* complain_on_overflow */
398 bfd_elf_generic_reloc, /* special_function */
399 "R_MSP430X_ABS20_ADR_DST",/* name */
400 FALSE, /* partial_inplace */
401 0, /* src_mask */
402 0xffff, /* dst_mask */
403 TRUE), /* pcrel_offset */
404
405 HOWTO (R_MSP430X_PCR16, /* type */
406 0, /* rightshift */
407 2, /* size (0 = byte, 1 = short, 2 = long) */
408 32, /* bitsize */
409 TRUE, /* pc_relative */
410 0, /* bitpos */
411 complain_overflow_dont,/* complain_on_overflow */
412 bfd_elf_generic_reloc, /* special_function */
413 "R_MSP430X_PCR16", /* name */
414 FALSE, /* partial_inplace */
415 0, /* src_mask */
416 0xffff, /* dst_mask */
417 TRUE), /* pcrel_offset */
418
419 HOWTO (R_MSP430X_PCR20_CALL, /* type */
420 0, /* rightshift */
421 2, /* size (0 = byte, 1 = short, 2 = long) */
422 32, /* bitsize */
423 TRUE, /* pc_relative */
424 0, /* bitpos */
425 complain_overflow_dont,/* complain_on_overflow */
426 bfd_elf_generic_reloc, /* special_function */
427 "R_MSP430X_PCR20_CALL",/* name */
428 FALSE, /* partial_inplace */
429 0, /* src_mask */
430 0xffff, /* dst_mask */
431 TRUE), /* pcrel_offset */
432
433 HOWTO (R_MSP430X_ABS16, /* type */
434 0, /* rightshift */
435 2, /* size (0 = byte, 1 = short, 2 = long) */
436 32, /* bitsize */
437 TRUE, /* pc_relative */
438 0, /* bitpos */
439 complain_overflow_dont,/* complain_on_overflow */
440 bfd_elf_generic_reloc, /* special_function */
441 "R_MSP430X_ABS16", /* name */
442 FALSE, /* partial_inplace */
443 0, /* src_mask */
444 0xffff, /* dst_mask */
445 TRUE), /* pcrel_offset */
446
447 HOWTO (R_MSP430_ABS_HI16, /* type */
448 0, /* rightshift */
449 2, /* size (0 = byte, 1 = short, 2 = long) */
450 32, /* bitsize */
451 TRUE, /* pc_relative */
452 0, /* bitpos */
453 complain_overflow_dont,/* complain_on_overflow */
454 bfd_elf_generic_reloc, /* special_function */
455 "R_MSP430_ABS_HI16", /* name */
456 FALSE, /* partial_inplace */
457 0, /* src_mask */
458 0xffff, /* dst_mask */
459 TRUE), /* pcrel_offset */
460
461 HOWTO (R_MSP430_PREL31, /* type */
462 0, /* rightshift */
463 2, /* size (0 = byte, 1 = short, 2 = long) */
464 32, /* bitsize */
465 TRUE, /* pc_relative */
466 0, /* bitpos */
467 complain_overflow_dont,/* complain_on_overflow */
468 bfd_elf_generic_reloc, /* special_function */
469 "R_MSP430_PREL31", /* name */
470 FALSE, /* partial_inplace */
471 0, /* src_mask */
472 0xffff, /* dst_mask */
473 TRUE), /* pcrel_offset */
474
475 EMPTY_HOWTO (R_MSP430_EHTYPE),
476
477 /* A 10 bit PC relative relocation. */
478 HOWTO (R_MSP430X_10_PCREL, /* type */
479 1, /* rightshift */
480 1, /* size (0 = byte, 1 = short, 2 = long) */
481 10, /* bitsize */
482 TRUE, /* pc_relative */
483 0, /* bitpos */
484 complain_overflow_bitfield,/* complain_on_overflow */
485 bfd_elf_generic_reloc, /* special_function */
486 "R_MSP430X_10_PCREL", /* name */
487 FALSE, /* partial_inplace */
488 0x3ff, /* src_mask */
489 0x3ff, /* dst_mask */
490 TRUE), /* pcrel_offset */
491
492 /* A 10 bit PC relative relocation for complicated polymorphs. */
493 HOWTO (R_MSP430X_2X_PCREL, /* type */
494 1, /* rightshift */
495 2, /* size (0 = byte, 1 = short, 2 = long) */
496 10, /* bitsize */
497 TRUE, /* pc_relative */
498 0, /* bitpos */
499 complain_overflow_bitfield,/* complain_on_overflow */
500 bfd_elf_generic_reloc, /* special_function */
501 "R_MSP430X_2X_PCREL", /* name */
502 FALSE, /* partial_inplace */
503 0x3ff, /* src_mask */
504 0x3ff, /* dst_mask */
505 TRUE), /* pcrel_offset */
506
507 /* Together with a following reloc, allows for the difference
508 between two symbols to be the real addend of the second reloc. */
509 HOWTO (R_MSP430X_SYM_DIFF, /* type */
510 0, /* rightshift */
511 2, /* size (0 = byte, 1 = short, 2 = long) */
512 32, /* bitsize */
513 FALSE, /* pc_relative */
514 0, /* bitpos */
515 complain_overflow_dont,/* complain_on_overflow */
516 rl78_sym_diff_handler, /* special handler. */
517 "R_MSP430X_SYM_DIFF", /* name */
518 FALSE, /* partial_inplace */
519 0xffffffff, /* src_mask */
520 0xffffffff, /* dst_mask */
521 FALSE) /* pcrel_offset */
522 };
523
524 /* Map BFD reloc types to MSP430 ELF reloc types. */
525
526 struct msp430_reloc_map
527 {
528 bfd_reloc_code_real_type bfd_reloc_val;
529 unsigned int elf_reloc_val;
530 };
531
532 static const struct msp430_reloc_map msp430_reloc_map[] =
533 {
534 {BFD_RELOC_NONE, R_MSP430_NONE},
535 {BFD_RELOC_32, R_MSP430_32},
536 {BFD_RELOC_MSP430_10_PCREL, R_MSP430_10_PCREL},
537 {BFD_RELOC_16, R_MSP430_16_BYTE},
538 {BFD_RELOC_MSP430_16_PCREL, R_MSP430_16_PCREL},
539 {BFD_RELOC_MSP430_16, R_MSP430_16},
540 {BFD_RELOC_MSP430_16_PCREL_BYTE, R_MSP430_16_PCREL_BYTE},
541 {BFD_RELOC_MSP430_16_BYTE, R_MSP430_16_BYTE},
542 {BFD_RELOC_MSP430_2X_PCREL, R_MSP430_2X_PCREL},
543 {BFD_RELOC_MSP430_RL_PCREL, R_MSP430_RL_PCREL},
544 {BFD_RELOC_8, R_MSP430_8},
545 {BFD_RELOC_MSP430_SYM_DIFF, R_MSP430_SYM_DIFF}
546 };
547
548 static const struct msp430_reloc_map msp430x_reloc_map[] =
549 {
550 {BFD_RELOC_NONE, R_MSP430_NONE},
551 {BFD_RELOC_32, R_MSP430_ABS32},
552 {BFD_RELOC_16, R_MSP430_ABS16},
553 {BFD_RELOC_8, R_MSP430_ABS8},
554 {BFD_RELOC_MSP430_ABS8, R_MSP430_ABS8},
555 {BFD_RELOC_MSP430X_PCR20_EXT_SRC, R_MSP430X_PCR20_EXT_SRC},
556 {BFD_RELOC_MSP430X_PCR20_EXT_DST, R_MSP430X_PCR20_EXT_DST},
557 {BFD_RELOC_MSP430X_PCR20_EXT_ODST, R_MSP430X_PCR20_EXT_ODST},
558 {BFD_RELOC_MSP430X_ABS20_EXT_SRC, R_MSP430X_ABS20_EXT_SRC},
559 {BFD_RELOC_MSP430X_ABS20_EXT_DST, R_MSP430X_ABS20_EXT_DST},
560 {BFD_RELOC_MSP430X_ABS20_EXT_ODST, R_MSP430X_ABS20_EXT_ODST},
561 {BFD_RELOC_MSP430X_ABS20_ADR_SRC, R_MSP430X_ABS20_ADR_SRC},
562 {BFD_RELOC_MSP430X_ABS20_ADR_DST, R_MSP430X_ABS20_ADR_DST},
563 {BFD_RELOC_MSP430X_PCR16, R_MSP430X_PCR16},
564 {BFD_RELOC_MSP430X_PCR20_CALL, R_MSP430X_PCR20_CALL},
565 {BFD_RELOC_MSP430X_ABS16, R_MSP430X_ABS16},
566 {BFD_RELOC_MSP430_ABS_HI16, R_MSP430_ABS_HI16},
567 {BFD_RELOC_MSP430_PREL31, R_MSP430_PREL31},
568 {BFD_RELOC_MSP430_10_PCREL, R_MSP430X_10_PCREL},
569 {BFD_RELOC_MSP430_2X_PCREL, R_MSP430X_2X_PCREL},
570 {BFD_RELOC_MSP430_RL_PCREL, R_MSP430X_PCR16},
571 {BFD_RELOC_MSP430_SYM_DIFF, R_MSP430X_SYM_DIFF}
572 };
573
574 static inline bfd_boolean
575 uses_msp430x_relocs (bfd * abfd)
576 {
577 extern const bfd_target msp430_elf32_ti_vec;
578
579 return bfd_get_mach (abfd) == bfd_mach_msp430x
580 || abfd->xvec == & msp430_elf32_ti_vec;
581 }
582
583 static reloc_howto_type *
584 bfd_elf32_bfd_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
585 bfd_reloc_code_real_type code)
586 {
587 unsigned int i;
588
589 if (uses_msp430x_relocs (abfd))
590 {
591 for (i = ARRAY_SIZE (msp430x_reloc_map); i--;)
592 if (msp430x_reloc_map[i].bfd_reloc_val == code)
593 return elf_msp430x_howto_table + msp430x_reloc_map[i].elf_reloc_val;
594 }
595 else
596 {
597 for (i = 0; i < ARRAY_SIZE (msp430_reloc_map); i++)
598 if (msp430_reloc_map[i].bfd_reloc_val == code)
599 return &elf_msp430_howto_table[msp430_reloc_map[i].elf_reloc_val];
600 }
601
602 return NULL;
603 }
604
605 static reloc_howto_type *
606 bfd_elf32_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
607 const char *r_name)
608 {
609 unsigned int i;
610
611 if (uses_msp430x_relocs (abfd))
612 {
613 for (i = ARRAY_SIZE (elf_msp430x_howto_table); i--;)
614 if (elf_msp430x_howto_table[i].name != NULL
615 && strcasecmp (elf_msp430x_howto_table[i].name, r_name) == 0)
616 return elf_msp430x_howto_table + i;
617 }
618 else
619 {
620 for (i = 0;
621 i < (sizeof (elf_msp430_howto_table)
622 / sizeof (elf_msp430_howto_table[0]));
623 i++)
624 if (elf_msp430_howto_table[i].name != NULL
625 && strcasecmp (elf_msp430_howto_table[i].name, r_name) == 0)
626 return &elf_msp430_howto_table[i];
627 }
628
629 return NULL;
630 }
631
632 /* Set the howto pointer for an MSP430 ELF reloc. */
633
634 static void
635 msp430_info_to_howto_rela (bfd * abfd ATTRIBUTE_UNUSED,
636 arelent * cache_ptr,
637 Elf_Internal_Rela * dst)
638 {
639 unsigned int r_type;
640
641 r_type = ELF32_R_TYPE (dst->r_info);
642
643 if (uses_msp430x_relocs (abfd))
644 {
645 if (r_type >= (unsigned int) R_MSP430x_max)
646 {
647 _bfd_error_handler (_("%B: invalid MSP430X reloc number: %d"), abfd, r_type);
648 r_type = 0;
649 }
650 cache_ptr->howto = elf_msp430x_howto_table + r_type;
651 return;
652 }
653
654 if (r_type >= (unsigned int) R_MSP430_max)
655 {
656 _bfd_error_handler (_("%B: invalid MSP430 reloc number: %d"), abfd, r_type);
657 r_type = 0;
658 }
659 cache_ptr->howto = &elf_msp430_howto_table[r_type];
660 }
661
662 /* Look through the relocs for a section during the first phase.
663 Since we don't do .gots or .plts, we just need to consider the
664 virtual table relocs for gc. */
665
666 static bfd_boolean
667 elf32_msp430_check_relocs (bfd * abfd, struct bfd_link_info * info,
668 asection * sec, const Elf_Internal_Rela * relocs)
669 {
670 Elf_Internal_Shdr *symtab_hdr;
671 struct elf_link_hash_entry **sym_hashes;
672 const Elf_Internal_Rela *rel;
673 const Elf_Internal_Rela *rel_end;
674
675 if (info->relocatable)
676 return TRUE;
677
678 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
679 sym_hashes = elf_sym_hashes (abfd);
680
681 rel_end = relocs + sec->reloc_count;
682 for (rel = relocs; rel < rel_end; rel++)
683 {
684 struct elf_link_hash_entry *h;
685 unsigned long r_symndx;
686
687 r_symndx = ELF32_R_SYM (rel->r_info);
688 if (r_symndx < symtab_hdr->sh_info)
689 h = NULL;
690 else
691 {
692 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
693 while (h->root.type == bfd_link_hash_indirect
694 || h->root.type == bfd_link_hash_warning)
695 h = (struct elf_link_hash_entry *) h->root.u.i.link;
696
697 /* PR15323, ref flags aren't set for references in the same
698 object. */
699 h->root.non_ir_ref = 1;
700 }
701 }
702
703 return TRUE;
704 }
705
706 /* Perform a single relocation. By default we use the standard BFD
707 routines, but a few relocs, we have to do them ourselves. */
708
709 static bfd_reloc_status_type
710 msp430_final_link_relocate (reloc_howto_type * howto,
711 bfd * input_bfd,
712 asection * input_section,
713 bfd_byte * contents,
714 Elf_Internal_Rela * rel,
715 bfd_vma relocation,
716 struct bfd_link_info * info)
717 {
718 static asection * sym_diff_section;
719 static bfd_vma sym_diff_value;
720
721 struct bfd_elf_section_data * esd = elf_section_data (input_section);
722 bfd_reloc_status_type r = bfd_reloc_ok;
723 bfd_vma x;
724 bfd_signed_vma srel;
725 bfd_boolean is_rel_reloc = FALSE;
726
727 if (uses_msp430x_relocs (input_bfd))
728 {
729 /* See if we have a REL type relocation. */
730 is_rel_reloc = (esd->rel.hdr != NULL);
731 /* Sanity check - only one type of relocation per section.
732 FIXME: Theoretically it is possible to have both types,
733 but if that happens how can we distinguish between the two ? */
734 BFD_ASSERT (! is_rel_reloc || ! esd->rela.hdr);
735 /* If we are using a REL relocation then the addend should be empty. */
736 BFD_ASSERT (! is_rel_reloc || rel->r_addend == 0);
737 }
738
739 if (sym_diff_section != NULL)
740 {
741 BFD_ASSERT (sym_diff_section == input_section);
742
743 if (uses_msp430x_relocs (input_bfd))
744 switch (howto->type)
745 {
746 case R_MSP430_ABS32:
747 /* If we are computing a 32-bit value for the location lists
748 and the result is 0 then we add one to the value. A zero
749 value can result because of linker relaxation deleteing
750 prologue instructions and using a value of 1 (for the begin
751 and end offsets in the location list entry) results in a
752 nul entry which does not prevent the following entries from
753 being parsed. */
754 if (relocation == sym_diff_value
755 && strcmp (input_section->name, ".debug_loc") == 0)
756 ++ relocation;
757 /* Fall through. */
758 case R_MSP430_ABS16:
759 case R_MSP430X_ABS16:
760 case R_MSP430_ABS8:
761 BFD_ASSERT (! is_rel_reloc);
762 relocation -= sym_diff_value;
763 break;
764
765 default:
766 return bfd_reloc_dangerous;
767 }
768 else
769 switch (howto->type)
770 {
771 case R_MSP430_32:
772 case R_MSP430_16:
773 case R_MSP430_16_BYTE:
774 case R_MSP430_8:
775 relocation -= sym_diff_value;
776 break;
777
778 default:
779 return bfd_reloc_dangerous;
780 }
781
782 sym_diff_section = NULL;
783 }
784
785 if (uses_msp430x_relocs (input_bfd))
786 switch (howto->type)
787 {
788 case R_MSP430X_SYM_DIFF:
789 /* Cache the input section and value.
790 The offset is unreliable, since relaxation may
791 have reduced the following reloc's offset. */
792 BFD_ASSERT (! is_rel_reloc);
793 sym_diff_section = input_section;
794 sym_diff_value = relocation;
795 return bfd_reloc_ok;
796
797 case R_MSP430_ABS16:
798 contents += rel->r_offset;
799 srel = (bfd_signed_vma) relocation;
800 if (is_rel_reloc)
801 srel += bfd_get_16 (input_bfd, contents);
802 else
803 srel += rel->r_addend;
804 bfd_put_16 (input_bfd, srel & 0xffff, contents);
805 break;
806
807 case R_MSP430X_10_PCREL:
808 contents += rel->r_offset;
809 srel = (bfd_signed_vma) relocation;
810 if (is_rel_reloc)
811 srel += bfd_get_16 (input_bfd, contents) & 0x3ff;
812 else
813 srel += rel->r_addend;
814 srel -= rel->r_offset;
815 srel -= 2; /* Branch instructions add 2 to the PC... */
816 srel -= (input_section->output_section->vma +
817 input_section->output_offset);
818 if (srel & 1)
819 return bfd_reloc_outofrange;
820
821 /* MSP430 addresses commands as words. */
822 srel >>= 1;
823
824 /* Check for an overflow. */
825 if (srel < -512 || srel > 511)
826 {
827 if (info->disable_target_specific_optimizations < 0)
828 {
829 static bfd_boolean warned = FALSE;
830 if (! warned)
831 {
832 info->callbacks->warning
833 (info,
834 _("Try enabling relaxation to avoid relocation truncations"),
835 NULL, input_bfd, input_section, relocation);
836 warned = TRUE;
837 }
838 }
839 return bfd_reloc_overflow;
840 }
841
842 x = bfd_get_16 (input_bfd, contents);
843 x = (x & 0xfc00) | (srel & 0x3ff);
844 bfd_put_16 (input_bfd, x, contents);
845 break;
846
847 case R_MSP430X_PCR20_EXT_ODST:
848 /* [0,4]+[48,16] = ---F ---- FFFF */
849 contents += rel->r_offset;
850 srel = (bfd_signed_vma) relocation;
851 if (is_rel_reloc)
852 {
853 bfd_vma addend;
854 addend = (bfd_get_16 (input_bfd, contents) & 0xf) << 16;
855 addend |= bfd_get_16 (input_bfd, contents+4);
856 srel += addend;
857
858 }
859 else
860 srel += rel->r_addend;
861 srel -= rel->r_offset;
862 srel -= (input_section->output_section->vma +
863 input_section->output_offset);
864 bfd_put_16 (input_bfd, (srel & 0xffff), contents + 6);
865 x = bfd_get_16 (input_bfd, contents);
866 x = (x & 0xfff0) | ((srel >> 16) & 0xf);
867 bfd_put_16 (input_bfd, x, contents);
868 break;
869
870 case R_MSP430X_ABS20_EXT_SRC:
871 /* [7,4]+[32,16] = -78- FFFF */
872 contents += rel->r_offset;
873 srel = (bfd_signed_vma) relocation;
874 if (is_rel_reloc)
875 {
876 bfd_vma addend;
877 addend = (bfd_get_16 (input_bfd, contents) & 0x0780) << 9;
878 addend |= bfd_get_16 (input_bfd, contents+2);
879 srel += addend;
880 }
881 else
882 srel += rel->r_addend;
883 bfd_put_16 (input_bfd, (srel & 0xffff), contents + 4);
884 srel >>= 16;
885 x = bfd_get_16 (input_bfd, contents);
886 x = (x & 0xf87f) | ((srel << 7) & 0x0780);
887 bfd_put_16 (input_bfd, x, contents);
888 break;
889
890 case R_MSP430_16_PCREL:
891 contents += rel->r_offset;
892 srel = (bfd_signed_vma) relocation;
893 if (is_rel_reloc)
894 srel += bfd_get_16 (input_bfd, contents);
895 else
896 srel += rel->r_addend;
897 srel -= rel->r_offset;
898 /* Only branch instructions add 2 to the PC... */
899 srel -= (input_section->output_section->vma +
900 input_section->output_offset);
901 if (srel & 1)
902 return bfd_reloc_outofrange;
903 bfd_put_16 (input_bfd, srel & 0xffff, contents);
904 break;
905
906 case R_MSP430X_PCR20_EXT_DST:
907 /* [0,4]+[32,16] = ---F FFFF */
908 contents += rel->r_offset;
909 srel = (bfd_signed_vma) relocation;
910 if (is_rel_reloc)
911 {
912 bfd_vma addend;
913 addend = (bfd_get_16 (input_bfd, contents) & 0xf) << 16;
914 addend |= bfd_get_16 (input_bfd, contents+2);
915 srel += addend;
916 }
917 else
918 srel += rel->r_addend;
919 srel -= rel->r_offset;
920 srel -= (input_section->output_section->vma +
921 input_section->output_offset);
922 bfd_put_16 (input_bfd, (srel & 0xffff), contents + 4);
923 srel >>= 16;
924 x = bfd_get_16 (input_bfd, contents);
925 x = (x & 0xfff0) | (srel & 0xf);
926 bfd_put_16 (input_bfd, x, contents);
927 break;
928
929 case R_MSP430X_PCR20_EXT_SRC:
930 /* [7,4]+32,16] = -78- FFFF */
931 contents += rel->r_offset;
932 srel = (bfd_signed_vma) relocation;
933 if (is_rel_reloc)
934 {
935 bfd_vma addend;
936 addend = ((bfd_get_16 (input_bfd, contents) & 0x0780) << 9);
937 addend |= bfd_get_16 (input_bfd, contents+2);
938 srel += addend;;
939 }
940 else
941 srel += rel->r_addend;
942 srel -= rel->r_offset;
943 /* Only branch instructions add 2 to the PC... */
944 srel -= (input_section->output_section->vma +
945 input_section->output_offset);
946 bfd_put_16 (input_bfd, (srel & 0xffff), contents + 4);
947 srel >>= 16;
948 x = bfd_get_16 (input_bfd, contents);
949 x = (x & 0xf87f) | ((srel << 7) & 0x0780);
950 bfd_put_16 (input_bfd, x, contents);
951 break;
952
953 case R_MSP430_ABS8:
954 contents += rel->r_offset;
955 srel = (bfd_signed_vma) relocation;
956 if (is_rel_reloc)
957 srel += bfd_get_8 (input_bfd, contents);
958 else
959 srel += rel->r_addend;
960 bfd_put_8 (input_bfd, srel & 0xff, contents);
961 break;
962
963 case R_MSP430X_ABS20_EXT_DST:
964 contents += rel->r_offset;
965 srel = (bfd_signed_vma) relocation;
966 if (is_rel_reloc)
967 srel += bfd_get_16 (input_bfd, contents) & 0xf;
968 else
969 srel += rel->r_addend;
970 bfd_put_16 (input_bfd, (srel & 0xffff), contents + 4);
971 srel >>= 16;
972 x = bfd_get_16 (input_bfd, contents);
973 x = (x & 0xfff0) | (srel & 0xf);
974 bfd_put_16 (input_bfd, x, contents);
975 break;
976
977 case R_MSP430X_ABS20_EXT_ODST:
978 /* [0,4]+[48,16] = ---F ---- FFFF */
979 contents += rel->r_offset;
980 srel = (bfd_signed_vma) relocation;
981 if (is_rel_reloc)
982 {
983 bfd_vma addend;
984 addend = (bfd_get_16 (input_bfd, contents) & 0xf) << 16;
985 addend |= bfd_get_16 (input_bfd, contents+4);
986 srel += addend;
987 }
988 else
989 srel += rel->r_addend;
990 bfd_put_16 (input_bfd, (srel & 0xffff), contents + 6);
991 srel >>= 16;
992 x = bfd_get_16 (input_bfd, contents);
993 x = (x & 0xfff0) | (srel & 0xf);
994 bfd_put_16 (input_bfd, x, contents);
995 break;
996
997 case R_MSP430X_ABS20_ADR_SRC:
998 /* [8,4]+[32,16] = -F-- FFFF */
999 contents += rel->r_offset;
1000 srel = (bfd_signed_vma) relocation;
1001 if (is_rel_reloc)
1002 {
1003 bfd_vma addend;
1004
1005 addend = ((bfd_get_16 (input_bfd, contents) & 0xf00) << 8);
1006 addend |= bfd_get_16 (input_bfd, contents+2);
1007 srel += addend;
1008 }
1009 else
1010 srel += rel->r_addend;
1011 bfd_put_16 (input_bfd, (srel & 0xffff), contents + 2);
1012 srel >>= 16;
1013 x = bfd_get_16 (input_bfd, contents);
1014 x = (x & 0xf0ff) | ((srel << 8) & 0x0f00);
1015 bfd_put_16 (input_bfd, x, contents);
1016 break;
1017
1018 case R_MSP430X_ABS20_ADR_DST:
1019 /* [0,4]+[32,16] = ---F FFFF */
1020 contents += rel->r_offset;
1021 srel = (bfd_signed_vma) relocation;
1022 if (is_rel_reloc)
1023 {
1024 bfd_vma addend;
1025 addend = ((bfd_get_16 (input_bfd, contents) & 0xf) << 16);
1026 addend |= bfd_get_16 (input_bfd, contents+2);
1027 srel += addend;
1028 }
1029 else
1030 srel += rel->r_addend;
1031 bfd_put_16 (input_bfd, (srel & 0xffff), contents + 2);
1032 srel >>= 16;
1033 x = bfd_get_16 (input_bfd, contents);
1034 x = (x & 0xfff0) | (srel & 0xf);
1035 bfd_put_16 (input_bfd, x, contents);
1036 break;
1037
1038 case R_MSP430X_ABS16:
1039 contents += rel->r_offset;
1040 srel = (bfd_signed_vma) relocation;
1041 if (is_rel_reloc)
1042 srel += bfd_get_16 (input_bfd, contents);
1043 else
1044 srel += rel->r_addend;
1045 x = srel;
1046 if (x > 0xffff)
1047 return bfd_reloc_overflow;
1048 bfd_put_16 (input_bfd, srel & 0xffff, contents);
1049 break;
1050
1051 case R_MSP430_ABS_HI16:
1052 /* The EABI specifies that this must be a RELA reloc. */
1053 BFD_ASSERT (! is_rel_reloc);
1054 contents += rel->r_offset;
1055 srel = (bfd_signed_vma) relocation;
1056 srel += rel->r_addend;
1057 bfd_put_16 (input_bfd, (srel >> 16) & 0xffff, contents);
1058 break;
1059
1060 case R_MSP430X_PCR20_CALL:
1061 /* [0,4]+[32,16] = ---F FFFF*/
1062 contents += rel->r_offset;
1063 srel = (bfd_signed_vma) relocation;
1064 if (is_rel_reloc)
1065 {
1066 bfd_vma addend;
1067 addend = (bfd_get_16 (input_bfd, contents) & 0xf) << 16;
1068 addend |= bfd_get_16 (input_bfd, contents+2);
1069 srel += addend;
1070 }
1071 else
1072 srel += rel->r_addend;
1073 srel -= rel->r_offset;
1074 srel -= (input_section->output_section->vma +
1075 input_section->output_offset);
1076 bfd_put_16 (input_bfd, srel & 0xffff, contents + 2);
1077 srel >>= 16;
1078 x = bfd_get_16 (input_bfd, contents);
1079 x = (x & 0xfff0) | (srel & 0xf);
1080 bfd_put_16 (input_bfd, x, contents);
1081 break;
1082
1083 case R_MSP430X_PCR16:
1084 contents += rel->r_offset;
1085 srel = (bfd_signed_vma) relocation;
1086 if (is_rel_reloc)
1087 srel += bfd_get_16 (input_bfd, contents);
1088 else
1089 srel += rel->r_addend;
1090 srel -= rel->r_offset;
1091 srel -= (input_section->output_section->vma +
1092 input_section->output_offset);
1093 bfd_put_16 (input_bfd, srel & 0xffff, contents);
1094 break;
1095
1096 case R_MSP430_PREL31:
1097 contents += rel->r_offset;
1098 srel = (bfd_signed_vma) relocation;
1099 if (is_rel_reloc)
1100 srel += (bfd_get_32 (input_bfd, contents) & 0x7fffffff);
1101 else
1102 srel += rel->r_addend;
1103 srel += rel->r_addend;
1104 x = bfd_get_32 (input_bfd, contents);
1105 x = (x & 0x80000000) | ((srel >> 31) & 0x7fffffff);
1106 bfd_put_32 (input_bfd, x, contents);
1107 break;
1108
1109 default:
1110 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1111 contents, rel->r_offset,
1112 relocation, rel->r_addend);
1113 }
1114 else
1115 switch (howto->type)
1116 {
1117 case R_MSP430_10_PCREL:
1118 contents += rel->r_offset;
1119 srel = (bfd_signed_vma) relocation;
1120 srel += rel->r_addend;
1121 srel -= rel->r_offset;
1122 srel -= 2; /* Branch instructions add 2 to the PC... */
1123 srel -= (input_section->output_section->vma +
1124 input_section->output_offset);
1125
1126 if (srel & 1)
1127 return bfd_reloc_outofrange;
1128
1129 /* MSP430 addresses commands as words. */
1130 srel >>= 1;
1131
1132 /* Check for an overflow. */
1133 if (srel < -512 || srel > 511)
1134 {
1135 if (info->disable_target_specific_optimizations < 0)
1136 {
1137 static bfd_boolean warned = FALSE;
1138 if (! warned)
1139 {
1140 info->callbacks->warning
1141 (info,
1142 _("Try enabling relaxation to avoid relocation truncations"),
1143 NULL, input_bfd, input_section, relocation);
1144 warned = TRUE;
1145 }
1146 }
1147 return bfd_reloc_overflow;
1148 }
1149
1150 x = bfd_get_16 (input_bfd, contents);
1151 x = (x & 0xfc00) | (srel & 0x3ff);
1152 bfd_put_16 (input_bfd, x, contents);
1153 break;
1154
1155 case R_MSP430_2X_PCREL:
1156 contents += rel->r_offset;
1157 srel = (bfd_signed_vma) relocation;
1158 srel += rel->r_addend;
1159 srel -= rel->r_offset;
1160 srel -= 2; /* Branch instructions add 2 to the PC... */
1161 srel -= (input_section->output_section->vma +
1162 input_section->output_offset);
1163
1164 if (srel & 1)
1165 return bfd_reloc_outofrange;
1166
1167 /* MSP430 addresses commands as words. */
1168 srel >>= 1;
1169
1170 /* Check for an overflow. */
1171 if (srel < -512 || srel > 511)
1172 return bfd_reloc_overflow;
1173
1174 x = bfd_get_16 (input_bfd, contents);
1175 x = (x & 0xfc00) | (srel & 0x3ff);
1176 bfd_put_16 (input_bfd, x, contents);
1177 /* Handle second jump instruction. */
1178 x = bfd_get_16 (input_bfd, contents - 2);
1179 srel += 1;
1180 x = (x & 0xfc00) | (srel & 0x3ff);
1181 bfd_put_16 (input_bfd, x, contents - 2);
1182 break;
1183
1184 case R_MSP430_RL_PCREL:
1185 case R_MSP430_16_PCREL:
1186 contents += rel->r_offset;
1187 srel = (bfd_signed_vma) relocation;
1188 srel += rel->r_addend;
1189 srel -= rel->r_offset;
1190 /* Only branch instructions add 2 to the PC... */
1191 srel -= (input_section->output_section->vma +
1192 input_section->output_offset);
1193
1194 if (srel & 1)
1195 return bfd_reloc_outofrange;
1196
1197 bfd_put_16 (input_bfd, srel & 0xffff, contents);
1198 break;
1199
1200 case R_MSP430_16_PCREL_BYTE:
1201 contents += rel->r_offset;
1202 srel = (bfd_signed_vma) relocation;
1203 srel += rel->r_addend;
1204 srel -= rel->r_offset;
1205 /* Only branch instructions add 2 to the PC... */
1206 srel -= (input_section->output_section->vma +
1207 input_section->output_offset);
1208
1209 bfd_put_16 (input_bfd, srel & 0xffff, contents);
1210 break;
1211
1212 case R_MSP430_16_BYTE:
1213 contents += rel->r_offset;
1214 srel = (bfd_signed_vma) relocation;
1215 srel += rel->r_addend;
1216 bfd_put_16 (input_bfd, srel & 0xffff, contents);
1217 break;
1218
1219 case R_MSP430_16:
1220 contents += rel->r_offset;
1221 srel = (bfd_signed_vma) relocation;
1222 srel += rel->r_addend;
1223
1224 if (srel & 1)
1225 return bfd_reloc_notsupported;
1226
1227 bfd_put_16 (input_bfd, srel & 0xffff, contents);
1228 break;
1229
1230 case R_MSP430_8:
1231 contents += rel->r_offset;
1232 srel = (bfd_signed_vma) relocation;
1233 srel += rel->r_addend;
1234
1235 bfd_put_8 (input_bfd, srel & 0xff, contents);
1236 break;
1237
1238 case R_MSP430_SYM_DIFF:
1239 /* Cache the input section and value.
1240 The offset is unreliable, since relaxation may
1241 have reduced the following reloc's offset. */
1242 sym_diff_section = input_section;
1243 sym_diff_value = relocation;
1244 return bfd_reloc_ok;
1245
1246 default:
1247 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1248 contents, rel->r_offset,
1249 relocation, rel->r_addend);
1250 }
1251
1252 return r;
1253 }
1254
1255 /* Relocate an MSP430 ELF section. */
1256
1257 static bfd_boolean
1258 elf32_msp430_relocate_section (bfd * output_bfd ATTRIBUTE_UNUSED,
1259 struct bfd_link_info * info,
1260 bfd * input_bfd,
1261 asection * input_section,
1262 bfd_byte * contents,
1263 Elf_Internal_Rela * relocs,
1264 Elf_Internal_Sym * local_syms,
1265 asection ** local_sections)
1266 {
1267 Elf_Internal_Shdr *symtab_hdr;
1268 struct elf_link_hash_entry **sym_hashes;
1269 Elf_Internal_Rela *rel;
1270 Elf_Internal_Rela *relend;
1271
1272 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1273 sym_hashes = elf_sym_hashes (input_bfd);
1274 relend = relocs + input_section->reloc_count;
1275
1276 for (rel = relocs; rel < relend; rel++)
1277 {
1278 reloc_howto_type *howto;
1279 unsigned long r_symndx;
1280 Elf_Internal_Sym *sym;
1281 asection *sec;
1282 struct elf_link_hash_entry *h;
1283 bfd_vma relocation;
1284 bfd_reloc_status_type r;
1285 const char *name = NULL;
1286 int r_type;
1287
1288 r_type = ELF32_R_TYPE (rel->r_info);
1289 r_symndx = ELF32_R_SYM (rel->r_info);
1290
1291 if (uses_msp430x_relocs (input_bfd))
1292 howto = elf_msp430x_howto_table + r_type;
1293 else
1294 howto = elf_msp430_howto_table + r_type;
1295
1296 h = NULL;
1297 sym = NULL;
1298 sec = NULL;
1299
1300 if (r_symndx < symtab_hdr->sh_info)
1301 {
1302 sym = local_syms + r_symndx;
1303 sec = local_sections[r_symndx];
1304 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1305
1306 name = bfd_elf_string_from_elf_section
1307 (input_bfd, symtab_hdr->sh_link, sym->st_name);
1308 name = (name == NULL || * name == 0) ? bfd_section_name (input_bfd, sec) : name;
1309 }
1310 else
1311 {
1312 bfd_boolean unresolved_reloc, warned, ignored;
1313
1314 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1315 r_symndx, symtab_hdr, sym_hashes,
1316 h, sec, relocation,
1317 unresolved_reloc, warned, ignored);
1318 name = h->root.root.string;
1319 }
1320
1321 if (sec != NULL && discarded_section (sec))
1322 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
1323 rel, 1, relend, howto, 0, contents);
1324
1325 if (info->relocatable)
1326 continue;
1327
1328 r = msp430_final_link_relocate (howto, input_bfd, input_section,
1329 contents, rel, relocation, info);
1330
1331 if (r != bfd_reloc_ok)
1332 {
1333 const char *msg = (const char *) NULL;
1334
1335 switch (r)
1336 {
1337 case bfd_reloc_overflow:
1338 r = info->callbacks->reloc_overflow
1339 (info, (h ? &h->root : NULL), name, howto->name,
1340 (bfd_vma) 0, input_bfd, input_section,
1341 rel->r_offset);
1342 break;
1343
1344 case bfd_reloc_undefined:
1345 r = info->callbacks->undefined_symbol
1346 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
1347 break;
1348
1349 case bfd_reloc_outofrange:
1350 msg = _("internal error: branch/jump to an odd address detected");
1351 break;
1352
1353 case bfd_reloc_notsupported:
1354 msg = _("internal error: unsupported relocation error");
1355 break;
1356
1357 case bfd_reloc_dangerous:
1358 msg = _("internal error: dangerous relocation");
1359 break;
1360
1361 default:
1362 msg = _("internal error: unknown error");
1363 break;
1364 }
1365
1366 if (msg)
1367 r = info->callbacks->warning
1368 (info, msg, name, input_bfd, input_section, rel->r_offset);
1369
1370 if (!r)
1371 return FALSE;
1372 }
1373
1374 }
1375
1376 return TRUE;
1377 }
1378
1379 /* The final processing done just before writing out a MSP430 ELF object
1380 file. This gets the MSP430 architecture right based on the machine
1381 number. */
1382
1383 static void
1384 bfd_elf_msp430_final_write_processing (bfd * abfd,
1385 bfd_boolean linker ATTRIBUTE_UNUSED)
1386 {
1387 unsigned long val;
1388
1389 switch (bfd_get_mach (abfd))
1390 {
1391 default:
1392 case bfd_mach_msp110: val = E_MSP430_MACH_MSP430x11x1; break;
1393 case bfd_mach_msp11: val = E_MSP430_MACH_MSP430x11; break;
1394 case bfd_mach_msp12: val = E_MSP430_MACH_MSP430x12; break;
1395 case bfd_mach_msp13: val = E_MSP430_MACH_MSP430x13; break;
1396 case bfd_mach_msp14: val = E_MSP430_MACH_MSP430x14; break;
1397 case bfd_mach_msp15: val = E_MSP430_MACH_MSP430x15; break;
1398 case bfd_mach_msp16: val = E_MSP430_MACH_MSP430x16; break;
1399 case bfd_mach_msp31: val = E_MSP430_MACH_MSP430x31; break;
1400 case bfd_mach_msp32: val = E_MSP430_MACH_MSP430x32; break;
1401 case bfd_mach_msp33: val = E_MSP430_MACH_MSP430x33; break;
1402 case bfd_mach_msp41: val = E_MSP430_MACH_MSP430x41; break;
1403 case bfd_mach_msp42: val = E_MSP430_MACH_MSP430x42; break;
1404 case bfd_mach_msp43: val = E_MSP430_MACH_MSP430x43; break;
1405 case bfd_mach_msp44: val = E_MSP430_MACH_MSP430x44; break;
1406 case bfd_mach_msp20: val = E_MSP430_MACH_MSP430x20; break;
1407 case bfd_mach_msp22: val = E_MSP430_MACH_MSP430x22; break;
1408 case bfd_mach_msp23: val = E_MSP430_MACH_MSP430x23; break;
1409 case bfd_mach_msp24: val = E_MSP430_MACH_MSP430x24; break;
1410 case bfd_mach_msp26: val = E_MSP430_MACH_MSP430x26; break;
1411 case bfd_mach_msp46: val = E_MSP430_MACH_MSP430x46; break;
1412 case bfd_mach_msp47: val = E_MSP430_MACH_MSP430x47; break;
1413 case bfd_mach_msp54: val = E_MSP430_MACH_MSP430x54; break;
1414 case bfd_mach_msp430x: val = E_MSP430_MACH_MSP430X; break;
1415 }
1416
1417 elf_elfheader (abfd)->e_machine = EM_MSP430;
1418 elf_elfheader (abfd)->e_flags &= ~EF_MSP430_MACH;
1419 elf_elfheader (abfd)->e_flags |= val;
1420 }
1421
1422 /* Set the right machine number. */
1423
1424 static bfd_boolean
1425 elf32_msp430_object_p (bfd * abfd)
1426 {
1427 int e_set = bfd_mach_msp14;
1428
1429 if (elf_elfheader (abfd)->e_machine == EM_MSP430
1430 || elf_elfheader (abfd)->e_machine == EM_MSP430_OLD)
1431 {
1432 int e_mach = elf_elfheader (abfd)->e_flags & EF_MSP430_MACH;
1433
1434 switch (e_mach)
1435 {
1436 default:
1437 case E_MSP430_MACH_MSP430x11: e_set = bfd_mach_msp11; break;
1438 case E_MSP430_MACH_MSP430x11x1: e_set = bfd_mach_msp110; break;
1439 case E_MSP430_MACH_MSP430x12: e_set = bfd_mach_msp12; break;
1440 case E_MSP430_MACH_MSP430x13: e_set = bfd_mach_msp13; break;
1441 case E_MSP430_MACH_MSP430x14: e_set = bfd_mach_msp14; break;
1442 case E_MSP430_MACH_MSP430x15: e_set = bfd_mach_msp15; break;
1443 case E_MSP430_MACH_MSP430x16: e_set = bfd_mach_msp16; break;
1444 case E_MSP430_MACH_MSP430x31: e_set = bfd_mach_msp31; break;
1445 case E_MSP430_MACH_MSP430x32: e_set = bfd_mach_msp32; break;
1446 case E_MSP430_MACH_MSP430x33: e_set = bfd_mach_msp33; break;
1447 case E_MSP430_MACH_MSP430x41: e_set = bfd_mach_msp41; break;
1448 case E_MSP430_MACH_MSP430x42: e_set = bfd_mach_msp42; break;
1449 case E_MSP430_MACH_MSP430x43: e_set = bfd_mach_msp43; break;
1450 case E_MSP430_MACH_MSP430x44: e_set = bfd_mach_msp44; break;
1451 case E_MSP430_MACH_MSP430x20: e_set = bfd_mach_msp20; break;
1452 case E_MSP430_MACH_MSP430x22: e_set = bfd_mach_msp22; break;
1453 case E_MSP430_MACH_MSP430x23: e_set = bfd_mach_msp23; break;
1454 case E_MSP430_MACH_MSP430x24: e_set = bfd_mach_msp24; break;
1455 case E_MSP430_MACH_MSP430x26: e_set = bfd_mach_msp26; break;
1456 case E_MSP430_MACH_MSP430x46: e_set = bfd_mach_msp46; break;
1457 case E_MSP430_MACH_MSP430x47: e_set = bfd_mach_msp47; break;
1458 case E_MSP430_MACH_MSP430x54: e_set = bfd_mach_msp54; break;
1459 case E_MSP430_MACH_MSP430X: e_set = bfd_mach_msp430x; break;
1460 }
1461 }
1462
1463 return bfd_default_set_arch_mach (abfd, bfd_arch_msp430, e_set);
1464 }
1465
1466 /* These functions handle relaxing for the msp430.
1467 Relaxation required only in two cases:
1468 - Bad hand coding like jumps from one section to another or
1469 from file to file.
1470 - Sibling calls. This will affect only 'jump label' polymorph. Without
1471 relaxing this enlarges code by 2 bytes. Sibcalls implemented but
1472 do not work in gcc's port by the reason I do not know.
1473 - To convert out of range conditional jump instructions (found inside
1474 a function) into inverted jumps over an unconditional branch instruction.
1475 Anyway, if a relaxation required, user should pass -relax option to the
1476 linker.
1477
1478 There are quite a few relaxing opportunities available on the msp430:
1479
1480 ================================================================
1481
1482 1. 3 words -> 1 word
1483
1484 eq == jeq label jne +4; br lab
1485 ne != jne label jeq +4; br lab
1486 lt < jl label jge +4; br lab
1487 ltu < jlo label lhs +4; br lab
1488 ge >= jge label jl +4; br lab
1489 geu >= jhs label jlo +4; br lab
1490
1491 2. 4 words -> 1 word
1492
1493 ltn < jn jn +2; jmp +4; br lab
1494
1495 3. 4 words -> 2 words
1496
1497 gt > jeq +2; jge label jeq +6; jl +4; br label
1498 gtu > jeq +2; jhs label jeq +6; jlo +4; br label
1499
1500 4. 4 words -> 2 words and 2 labels
1501
1502 leu <= jeq label; jlo label jeq +2; jhs +4; br label
1503 le <= jeq label; jl label jeq +2; jge +4; br label
1504 =================================================================
1505
1506 codemap for first cases is (labels masked ):
1507 eq: 0x2002,0x4010,0x0000 -> 0x2400
1508 ne: 0x2402,0x4010,0x0000 -> 0x2000
1509 lt: 0x3402,0x4010,0x0000 -> 0x3800
1510 ltu: 0x2c02,0x4010,0x0000 -> 0x2800
1511 ge: 0x3802,0x4010,0x0000 -> 0x3400
1512 geu: 0x2802,0x4010,0x0000 -> 0x2c00
1513
1514 second case:
1515 ltn: 0x3001,0x3c02,0x4010,0x0000 -> 0x3000
1516
1517 third case:
1518 gt: 0x2403,0x3802,0x4010,0x0000 -> 0x2401,0x3400
1519 gtu: 0x2403,0x2802,0x4010,0x0000 -> 0x2401,0x2c00
1520
1521 fourth case:
1522 leu: 0x2401,0x2c02,0x4010,0x0000 -> 0x2400,0x2800
1523 le: 0x2401,0x3402,0x4010,0x0000 -> 0x2400,0x3800
1524
1525 Unspecified case :)
1526 jump: 0x4010,0x0000 -> 0x3c00. */
1527
1528 #define NUMB_RELAX_CODES 12
1529 static struct rcodes_s
1530 {
1531 int f0, f1; /* From code. */
1532 int t0, t1; /* To code. */
1533 int labels; /* Position of labels: 1 - one label at first
1534 word, 2 - one at second word, 3 - two
1535 labels at both. */
1536 int cdx; /* Words to match. */
1537 int bs; /* Shrink bytes. */
1538 int off; /* Offset from old label for new code. */
1539 int ncl; /* New code length. */
1540 } rcode[] =
1541 {/* lab,cdx,bs,off,ncl */
1542 { 0x0000, 0x0000, 0x3c00, 0x0000, 1, 0, 2, 2, 2}, /* jump */
1543 { 0x0000, 0x2002, 0x2400, 0x0000, 1, 1, 4, 4, 2}, /* eq */
1544 { 0x0000, 0x2402, 0x2000, 0x0000, 1, 1, 4, 4, 2}, /* ne */
1545 { 0x0000, 0x3402, 0x3800, 0x0000, 1, 1, 4, 4, 2}, /* lt */
1546 { 0x0000, 0x2c02, 0x2800, 0x0000, 1, 1, 4, 4, 2}, /* ltu */
1547 { 0x0000, 0x3802, 0x3400, 0x0000, 1, 1, 4, 4, 2}, /* ge */
1548 { 0x0000, 0x2802, 0x2c00, 0x0000, 1, 1, 4, 4, 2}, /* geu */
1549 { 0x3001, 0x3c02, 0x3000, 0x0000, 1, 2, 6, 6, 2}, /* ltn */
1550 { 0x2403, 0x3802, 0x2401, 0x3400, 2, 2, 4, 6, 4}, /* gt */
1551 { 0x2403, 0x2802, 0x2401, 0x2c00, 2, 2, 4, 6, 4}, /* gtu */
1552 { 0x2401, 0x2c02, 0x2400, 0x2800, 3, 2, 4, 6, 4}, /* leu , 2 labels */
1553 { 0x2401, 0x2c02, 0x2400, 0x2800, 3, 2, 4, 6, 4}, /* le , 2 labels */
1554 { 0, 0, 0, 0, 0, 0, 0, 0, 0}
1555 };
1556
1557 /* Return TRUE if a symbol exists at the given address. */
1558
1559 static bfd_boolean
1560 msp430_elf_symbol_address_p (bfd * abfd,
1561 asection * sec,
1562 Elf_Internal_Sym * isym,
1563 bfd_vma addr)
1564 {
1565 Elf_Internal_Shdr *symtab_hdr;
1566 unsigned int sec_shndx;
1567 Elf_Internal_Sym *isymend;
1568 struct elf_link_hash_entry **sym_hashes;
1569 struct elf_link_hash_entry **end_hashes;
1570 unsigned int symcount;
1571
1572 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1573
1574 /* Examine all the local symbols. */
1575 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1576 for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
1577 if (isym->st_shndx == sec_shndx && isym->st_value == addr)
1578 return TRUE;
1579
1580 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1581 - symtab_hdr->sh_info);
1582 sym_hashes = elf_sym_hashes (abfd);
1583 end_hashes = sym_hashes + symcount;
1584 for (; sym_hashes < end_hashes; sym_hashes++)
1585 {
1586 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1587
1588 if ((sym_hash->root.type == bfd_link_hash_defined
1589 || sym_hash->root.type == bfd_link_hash_defweak)
1590 && sym_hash->root.u.def.section == sec
1591 && sym_hash->root.u.def.value == addr)
1592 return TRUE;
1593 }
1594
1595 return FALSE;
1596 }
1597
1598 /* Adjust all local symbols defined as '.section + 0xXXXX' (.section has
1599 sec_shndx) referenced from current and other sections. */
1600
1601 static bfd_boolean
1602 msp430_elf_relax_adjust_locals (bfd * abfd, asection * sec, bfd_vma addr,
1603 int count, unsigned int sec_shndx,
1604 bfd_vma toaddr)
1605 {
1606 Elf_Internal_Shdr *symtab_hdr;
1607 Elf_Internal_Rela *irel;
1608 Elf_Internal_Rela *irelend;
1609 Elf_Internal_Sym *isym;
1610
1611 irel = elf_section_data (sec)->relocs;
1612 if (irel == NULL)
1613 return TRUE;
1614
1615 irelend = irel + sec->reloc_count;
1616 symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
1617 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1618
1619 for (;irel < irelend; irel++)
1620 {
1621 unsigned int sidx = ELF32_R_SYM(irel->r_info);
1622 Elf_Internal_Sym *lsym = isym + sidx;
1623
1624 /* Adjust symbols referenced by .sec+0xXX. */
1625 if (irel->r_addend > addr && irel->r_addend < toaddr
1626 && sidx < symtab_hdr->sh_info
1627 && lsym->st_shndx == sec_shndx)
1628 irel->r_addend -= count;
1629 }
1630
1631 return TRUE;
1632 }
1633
1634 /* Delete some bytes from a section while relaxing. */
1635
1636 static bfd_boolean
1637 msp430_elf_relax_delete_bytes (bfd * abfd, asection * sec, bfd_vma addr,
1638 int count)
1639 {
1640 Elf_Internal_Shdr *symtab_hdr;
1641 unsigned int sec_shndx;
1642 bfd_byte *contents;
1643 Elf_Internal_Rela *irel;
1644 Elf_Internal_Rela *irelend;
1645 bfd_vma toaddr;
1646 Elf_Internal_Sym *isym;
1647 Elf_Internal_Sym *isymend;
1648 struct elf_link_hash_entry **sym_hashes;
1649 struct elf_link_hash_entry **end_hashes;
1650 unsigned int symcount;
1651 asection *p;
1652
1653 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1654
1655 contents = elf_section_data (sec)->this_hdr.contents;
1656
1657 toaddr = sec->size;
1658
1659 irel = elf_section_data (sec)->relocs;
1660 irelend = irel + sec->reloc_count;
1661
1662 /* Actually delete the bytes. */
1663 memmove (contents + addr, contents + addr + count,
1664 (size_t) (toaddr - addr - count));
1665 sec->size -= count;
1666
1667 /* Adjust all the relocs. */
1668 symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
1669 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1670 for (; irel < irelend; irel++)
1671 {
1672 /* Get the new reloc address. */
1673 if ((irel->r_offset > addr && irel->r_offset < toaddr))
1674 irel->r_offset -= count;
1675 }
1676
1677 for (p = abfd->sections; p != NULL; p = p->next)
1678 msp430_elf_relax_adjust_locals (abfd,p,addr,count,sec_shndx,toaddr);
1679
1680 /* Adjust the local symbols defined in this section. */
1681 symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
1682 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1683 for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
1684 {
1685 const char * name;
1686
1687 name = bfd_elf_string_from_elf_section
1688 (abfd, symtab_hdr->sh_link, isym->st_name);
1689 name = (name == NULL || * name == 0) ? bfd_section_name (abfd, sec) : name;
1690
1691 if (isym->st_shndx != sec_shndx)
1692 continue;
1693
1694 if (isym->st_value > addr
1695 && (isym->st_value < toaddr
1696 /* We also adjust a symbol at the end of the section if its name is
1697 on the list below. These symbols are used for debug info
1698 generation and they refer to the end of the current section, not
1699 the start of the next section. */
1700 || (isym->st_value == toaddr
1701 && name != NULL
1702 && (CONST_STRNEQ (name, ".Letext")
1703 || CONST_STRNEQ (name, ".LFE")))))
1704 {
1705 if (isym->st_value < addr + count)
1706 isym->st_value = addr;
1707 else
1708 isym->st_value -= count;
1709 }
1710 /* Adjust the function symbol's size as well. */
1711 else if (ELF_ST_TYPE (isym->st_info) == STT_FUNC
1712 && isym->st_value + isym->st_size > addr
1713 && isym->st_value + isym->st_size < toaddr)
1714 isym->st_size -= count;
1715 }
1716
1717 /* Now adjust the global symbols defined in this section. */
1718 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1719 - symtab_hdr->sh_info);
1720 sym_hashes = elf_sym_hashes (abfd);
1721 end_hashes = sym_hashes + symcount;
1722 for (; sym_hashes < end_hashes; sym_hashes++)
1723 {
1724 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1725
1726 if ((sym_hash->root.type == bfd_link_hash_defined
1727 || sym_hash->root.type == bfd_link_hash_defweak)
1728 && sym_hash->root.u.def.section == sec
1729 && sym_hash->root.u.def.value > addr
1730 && sym_hash->root.u.def.value < toaddr)
1731 {
1732 if (sym_hash->root.u.def.value < addr + count)
1733 sym_hash->root.u.def.value = addr;
1734 else
1735 sym_hash->root.u.def.value -= count;
1736 }
1737 /* Adjust the function symbol's size as well. */
1738 else if (sym_hash->root.type == bfd_link_hash_defined
1739 && sym_hash->root.u.def.section == sec
1740 && sym_hash->type == STT_FUNC
1741 && sym_hash->root.u.def.value + sym_hash->size > addr
1742 && sym_hash->root.u.def.value + sym_hash->size < toaddr)
1743 sym_hash->size -= count;
1744 }
1745
1746 return TRUE;
1747 }
1748
1749 /* Insert two words into a section whilst relaxing. */
1750
1751 static bfd_byte *
1752 msp430_elf_relax_add_two_words (bfd * abfd, asection * sec, bfd_vma addr,
1753 int word1, int word2)
1754 {
1755 Elf_Internal_Shdr *symtab_hdr;
1756 unsigned int sec_shndx;
1757 bfd_byte *contents;
1758 Elf_Internal_Rela *irel;
1759 Elf_Internal_Rela *irelend;
1760 Elf_Internal_Sym *isym;
1761 Elf_Internal_Sym *isymend;
1762 struct elf_link_hash_entry **sym_hashes;
1763 struct elf_link_hash_entry **end_hashes;
1764 unsigned int symcount;
1765 bfd_vma sec_end;
1766 asection *p;
1767
1768 contents = elf_section_data (sec)->this_hdr.contents;
1769 sec_end = sec->size;
1770
1771 /* Make space for the new words. */
1772 contents = bfd_realloc (contents, sec_end + 4);
1773 memmove (contents + addr + 4, contents + addr, sec_end - addr);
1774
1775 /* Insert the new words. */
1776 bfd_put_16 (abfd, word1, contents + addr);
1777 bfd_put_16 (abfd, word2, contents + addr + 2);
1778
1779 /* Update the section information. */
1780 sec->size += 4;
1781 elf_section_data (sec)->this_hdr.contents = contents;
1782
1783 /* Adjust all the relocs. */
1784 irel = elf_section_data (sec)->relocs;
1785 irelend = irel + sec->reloc_count;
1786
1787 for (; irel < irelend; irel++)
1788 if ((irel->r_offset >= addr && irel->r_offset < sec_end))
1789 irel->r_offset += 4;
1790
1791 /* Adjust the local symbols defined in this section. */
1792 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1793 for (p = abfd->sections; p != NULL; p = p->next)
1794 msp430_elf_relax_adjust_locals (abfd, p, addr, -4,
1795 sec_shndx, sec_end);
1796
1797 /* Adjust the global symbols affected by the move. */
1798 symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
1799 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1800 for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
1801 if (isym->st_shndx == sec_shndx
1802 && isym->st_value >= addr && isym->st_value < sec_end)
1803 isym->st_value += 4;
1804
1805 /* Now adjust the global symbols defined in this section. */
1806 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1807 - symtab_hdr->sh_info);
1808 sym_hashes = elf_sym_hashes (abfd);
1809 end_hashes = sym_hashes + symcount;
1810 for (; sym_hashes < end_hashes; sym_hashes++)
1811 {
1812 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1813
1814 if ((sym_hash->root.type == bfd_link_hash_defined
1815 || sym_hash->root.type == bfd_link_hash_defweak)
1816 && sym_hash->root.u.def.section == sec
1817 && sym_hash->root.u.def.value >= addr
1818 && sym_hash->root.u.def.value < sec_end)
1819 sym_hash->root.u.def.value += 4;
1820 }
1821
1822 return contents;
1823 }
1824
1825 static bfd_boolean
1826 msp430_elf_relax_section (bfd * abfd, asection * sec,
1827 struct bfd_link_info * link_info,
1828 bfd_boolean * again)
1829 {
1830 Elf_Internal_Shdr * symtab_hdr;
1831 Elf_Internal_Rela * internal_relocs;
1832 Elf_Internal_Rela * irel;
1833 Elf_Internal_Rela * irelend;
1834 bfd_byte * contents = NULL;
1835 Elf_Internal_Sym * isymbuf = NULL;
1836
1837 /* Assume nothing changes. */
1838 *again = FALSE;
1839
1840 /* We don't have to do anything for a relocatable link, if
1841 this section does not have relocs, or if this is not a
1842 code section. */
1843 if (link_info->relocatable
1844 || (sec->flags & SEC_RELOC) == 0
1845 || sec->reloc_count == 0 || (sec->flags & SEC_CODE) == 0)
1846 return TRUE;
1847
1848 symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
1849
1850 /* Get a copy of the native relocations. */
1851 internal_relocs =
1852 _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL, link_info->keep_memory);
1853 if (internal_relocs == NULL)
1854 goto error_return;
1855
1856 /* Walk through them looking for relaxing opportunities. */
1857 irelend = internal_relocs + sec->reloc_count;
1858
1859 /* Do code size growing relocs first. */
1860 for (irel = internal_relocs; irel < irelend; irel++)
1861 {
1862 bfd_vma symval;
1863
1864 /* If this isn't something that can be relaxed, then ignore
1865 this reloc. */
1866 if (uses_msp430x_relocs (abfd)
1867 && ELF32_R_TYPE (irel->r_info) == (int) R_MSP430X_10_PCREL)
1868 ;
1869 else if (! uses_msp430x_relocs (abfd)
1870 && ELF32_R_TYPE (irel->r_info) == (int) R_MSP430_10_PCREL)
1871 ;
1872 else
1873 continue;
1874
1875 /* Get the section contents if we haven't done so already. */
1876 if (contents == NULL)
1877 {
1878 /* Get cached copy if it exists. */
1879 if (elf_section_data (sec)->this_hdr.contents != NULL)
1880 contents = elf_section_data (sec)->this_hdr.contents;
1881 else if (! bfd_malloc_and_get_section (abfd, sec, &contents))
1882 goto error_return;
1883 }
1884
1885 /* Read this BFD's local symbols if we haven't done so already. */
1886 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
1887 {
1888 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1889 if (isymbuf == NULL)
1890 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
1891 symtab_hdr->sh_info, 0,
1892 NULL, NULL, NULL);
1893 if (isymbuf == NULL)
1894 goto error_return;
1895 }
1896
1897 /* Get the value of the symbol referred to by the reloc. */
1898 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1899 {
1900 /* A local symbol. */
1901 Elf_Internal_Sym *isym;
1902 asection *sym_sec;
1903
1904 isym = isymbuf + ELF32_R_SYM (irel->r_info);
1905 if (isym->st_shndx == SHN_UNDEF)
1906 sym_sec = bfd_und_section_ptr;
1907 else if (isym->st_shndx == SHN_ABS)
1908 sym_sec = bfd_abs_section_ptr;
1909 else if (isym->st_shndx == SHN_COMMON)
1910 sym_sec = bfd_com_section_ptr;
1911 else
1912 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
1913 symval = (isym->st_value
1914 + sym_sec->output_section->vma + sym_sec->output_offset);
1915 }
1916 else
1917 {
1918 unsigned long indx;
1919 struct elf_link_hash_entry *h;
1920
1921 /* An external symbol. */
1922 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
1923 h = elf_sym_hashes (abfd)[indx];
1924 BFD_ASSERT (h != NULL);
1925
1926 if (h->root.type != bfd_link_hash_defined
1927 && h->root.type != bfd_link_hash_defweak)
1928 /* This appears to be a reference to an undefined
1929 symbol. Just ignore it--it will be caught by the
1930 regular reloc processing. */
1931 continue;
1932
1933 symval = (h->root.u.def.value
1934 + h->root.u.def.section->output_section->vma
1935 + h->root.u.def.section->output_offset);
1936 }
1937
1938 /* For simplicity of coding, we are going to modify the section
1939 contents, the section relocs, and the BFD symbol table. We
1940 must tell the rest of the code not to free up this
1941 information. It would be possible to instead create a table
1942 of changes which have to be made, as is done in coff-mips.c;
1943 that would be more work, but would require less memory when
1944 the linker is run. */
1945
1946 bfd_signed_vma value = symval;
1947 int opcode;
1948
1949 /* Compute the value that will be relocated. */
1950 value += irel->r_addend;
1951 /* Convert to PC relative. */
1952 value -= (sec->output_section->vma + sec->output_offset);
1953 value -= irel->r_offset;
1954 value -= 2;
1955 /* Scale. */
1956 value >>= 1;
1957
1958 /* If it is in range then no modifications are needed. */
1959 if (value >= -512 && value <= 511)
1960 continue;
1961
1962 /* Get the opcode. */
1963 opcode = bfd_get_16 (abfd, contents + irel->r_offset);
1964
1965 /* Compute the new opcode. We are going to convert:
1966 J<cond> label
1967 into:
1968 J<inv-cond> 1f
1969 BR[A] #label
1970 1: */
1971 switch (opcode & 0xfc00)
1972 {
1973 case 0x3800: opcode = 0x3402; break; /* Jl -> Jge +2 */
1974 case 0x3400: opcode = 0x3802; break; /* Jge -> Jl +2 */
1975 case 0x2c00: opcode = 0x2802; break; /* Jhs -> Jlo +2 */
1976 case 0x2800: opcode = 0x2c02; break; /* Jlo -> Jhs +2 */
1977 case 0x2400: opcode = 0x2002; break; /* Jeq -> Jne +2 */
1978 case 0x2000: opcode = 0x2402; break; /* jne -> Jeq +2 */
1979 case 0x3000: /* jn */
1980 /* There is no direct inverse of the Jn insn.
1981 FIXME: we could do this as:
1982 Jn 1f
1983 br 2f
1984 1: br label
1985 2: */
1986 continue;
1987 default:
1988 /* Not a conditional branch instruction. */
1989 /* fprintf (stderr, "unrecog: %x\n", opcode); */
1990 continue;
1991 }
1992
1993 /* Note that we've changed the relocs, section contents, etc. */
1994 elf_section_data (sec)->relocs = internal_relocs;
1995 elf_section_data (sec)->this_hdr.contents = contents;
1996 symtab_hdr->contents = (unsigned char *) isymbuf;
1997
1998 /* Install the new opcode. */
1999 bfd_put_16 (abfd, opcode, contents + irel->r_offset);
2000
2001 /* Insert the new branch instruction. */
2002 if (uses_msp430x_relocs (abfd))
2003 {
2004 /* Insert an absolute branch (aka MOVA) instruction. */
2005 contents = msp430_elf_relax_add_two_words
2006 (abfd, sec, irel->r_offset + 2, 0x0080, 0x0000);
2007
2008 /* Update the relocation to point to the inserted branch
2009 instruction. Note - we are changing a PC-relative reloc
2010 into an absolute reloc, but this is OK because we have
2011 arranged with the assembler to have the reloc's value be
2012 a (local) symbol, not a section+offset value. */
2013 irel->r_offset += 2;
2014 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2015 R_MSP430X_ABS20_ADR_SRC);
2016 }
2017 else
2018 {
2019 contents = msp430_elf_relax_add_two_words
2020 (abfd, sec, irel->r_offset + 2, 0x4030, 0x0000);
2021
2022 /* See comment above about converting a 10-bit PC-rel
2023 relocation into a 16-bit absolute relocation. */
2024 irel->r_offset += 4;
2025 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2026 R_MSP430_16);
2027 }
2028
2029 /* Growing the section may mean that other
2030 conditional branches need to be fixed. */
2031 *again = TRUE;
2032 }
2033
2034 for (irel = internal_relocs; irel < irelend; irel++)
2035 {
2036 bfd_vma symval;
2037
2038 /* Get the section contents if we haven't done so already. */
2039 if (contents == NULL)
2040 {
2041 /* Get cached copy if it exists. */
2042 if (elf_section_data (sec)->this_hdr.contents != NULL)
2043 contents = elf_section_data (sec)->this_hdr.contents;
2044 else if (! bfd_malloc_and_get_section (abfd, sec, &contents))
2045 goto error_return;
2046 }
2047
2048 /* Read this BFD's local symbols if we haven't done so already. */
2049 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
2050 {
2051 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2052 if (isymbuf == NULL)
2053 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
2054 symtab_hdr->sh_info, 0,
2055 NULL, NULL, NULL);
2056 if (isymbuf == NULL)
2057 goto error_return;
2058 }
2059
2060 /* Get the value of the symbol referred to by the reloc. */
2061 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
2062 {
2063 /* A local symbol. */
2064 Elf_Internal_Sym *isym;
2065 asection *sym_sec;
2066
2067 isym = isymbuf + ELF32_R_SYM (irel->r_info);
2068 if (isym->st_shndx == SHN_UNDEF)
2069 sym_sec = bfd_und_section_ptr;
2070 else if (isym->st_shndx == SHN_ABS)
2071 sym_sec = bfd_abs_section_ptr;
2072 else if (isym->st_shndx == SHN_COMMON)
2073 sym_sec = bfd_com_section_ptr;
2074 else
2075 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
2076 symval = (isym->st_value
2077 + sym_sec->output_section->vma + sym_sec->output_offset);
2078 }
2079 else
2080 {
2081 unsigned long indx;
2082 struct elf_link_hash_entry *h;
2083
2084 /* An external symbol. */
2085 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
2086 h = elf_sym_hashes (abfd)[indx];
2087 BFD_ASSERT (h != NULL);
2088
2089 if (h->root.type != bfd_link_hash_defined
2090 && h->root.type != bfd_link_hash_defweak)
2091 /* This appears to be a reference to an undefined
2092 symbol. Just ignore it--it will be caught by the
2093 regular reloc processing. */
2094 continue;
2095
2096 symval = (h->root.u.def.value
2097 + h->root.u.def.section->output_section->vma
2098 + h->root.u.def.section->output_offset);
2099 }
2100
2101 /* For simplicity of coding, we are going to modify the section
2102 contents, the section relocs, and the BFD symbol table. We
2103 must tell the rest of the code not to free up this
2104 information. It would be possible to instead create a table
2105 of changes which have to be made, as is done in coff-mips.c;
2106 that would be more work, but would require less memory when
2107 the linker is run. */
2108
2109 /* Try to turn a 16bit pc-relative branch into a 10bit pc-relative
2110 branch. */
2111 /* Paranoia? paranoia... */
2112 if (! uses_msp430x_relocs (abfd)
2113 && ELF32_R_TYPE (irel->r_info) == (int) R_MSP430_RL_PCREL)
2114 {
2115 bfd_vma value = symval;
2116
2117 /* Deal with pc-relative gunk. */
2118 value -= (sec->output_section->vma + sec->output_offset);
2119 value -= irel->r_offset;
2120 value += irel->r_addend;
2121
2122 /* See if the value will fit in 10 bits, note the high value is
2123 1016 as the target will be two bytes closer if we are
2124 able to relax. */
2125 if ((long) value < 1016 && (long) value > -1016)
2126 {
2127 int code0 = 0, code1 = 0, code2 = 0;
2128 int i;
2129 struct rcodes_s *rx;
2130
2131 /* Get the opcode. */
2132 if (irel->r_offset >= 6)
2133 code0 = bfd_get_16 (abfd, contents + irel->r_offset - 6);
2134
2135 if (irel->r_offset >= 4)
2136 code1 = bfd_get_16 (abfd, contents + irel->r_offset - 4);
2137
2138 code2 = bfd_get_16 (abfd, contents + irel->r_offset - 2);
2139
2140 if (code2 != 0x4010)
2141 continue;
2142
2143 /* Check r4 and r3. */
2144 for (i = NUMB_RELAX_CODES - 1; i >= 0; i--)
2145 {
2146 rx = &rcode[i];
2147 if (rx->cdx == 2 && rx->f0 == code0 && rx->f1 == code1)
2148 break;
2149 else if (rx->cdx == 1 && rx->f1 == code1)
2150 break;
2151 else if (rx->cdx == 0) /* This is an unconditional jump. */
2152 break;
2153 }
2154
2155 /* Check labels:
2156 .Label0: ; we do not care about this label
2157 jeq +6
2158 .Label1: ; make sure there is no label here
2159 jl +4
2160 .Label2: ; make sure there is no label here
2161 br .Label_dst
2162
2163 So, if there is .Label1 or .Label2 we cannot relax this code.
2164 This actually should not happen, cause for relaxable
2165 instructions we use RL_PCREL reloc instead of 16_PCREL.
2166 Will change this in the future. */
2167
2168 if (rx->cdx > 0
2169 && msp430_elf_symbol_address_p (abfd, sec, isymbuf,
2170 irel->r_offset - 2))
2171 continue;
2172 if (rx->cdx > 1
2173 && msp430_elf_symbol_address_p (abfd, sec, isymbuf,
2174 irel->r_offset - 4))
2175 continue;
2176
2177 /* Note that we've changed the relocs, section contents, etc. */
2178 elf_section_data (sec)->relocs = internal_relocs;
2179 elf_section_data (sec)->this_hdr.contents = contents;
2180 symtab_hdr->contents = (unsigned char *) isymbuf;
2181
2182 /* Fix the relocation's type. */
2183 if (uses_msp430x_relocs (abfd))
2184 {
2185 if (rx->labels == 3) /* Handle special cases. */
2186 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2187 R_MSP430X_2X_PCREL);
2188 else
2189 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2190 R_MSP430X_10_PCREL);
2191 }
2192 else
2193 {
2194 if (rx->labels == 3) /* Handle special cases. */
2195 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2196 R_MSP430_2X_PCREL);
2197 else
2198 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2199 R_MSP430_10_PCREL);
2200 }
2201
2202 /* Fix the opcode right way. */
2203 bfd_put_16 (abfd, rx->t0, contents + irel->r_offset - rx->off);
2204 if (rx->t1)
2205 bfd_put_16 (abfd, rx->t1,
2206 contents + irel->r_offset - rx->off + 2);
2207
2208 /* Delete bytes. */
2209 if (!msp430_elf_relax_delete_bytes (abfd, sec,
2210 irel->r_offset - rx->off +
2211 rx->ncl, rx->bs))
2212 goto error_return;
2213
2214 /* Handle unconditional jumps. */
2215 if (rx->cdx == 0)
2216 irel->r_offset -= 2;
2217
2218 /* That will change things, so, we should relax again.
2219 Note that this is not required, and it may be slow. */
2220 *again = TRUE;
2221 }
2222 }
2223
2224 /* Try to turn a 16-bit absolute branch into a 10-bit pc-relative
2225 branch. */
2226 if (uses_msp430x_relocs (abfd)
2227 && ELF32_R_TYPE (irel->r_info) == R_MSP430X_ABS16)
2228 {
2229 bfd_vma value = symval;
2230
2231 value -= (sec->output_section->vma + sec->output_offset);
2232 value -= irel->r_offset;
2233 value += irel->r_addend;
2234
2235 /* See if the value will fit in 10 bits, note the high value is
2236 1016 as the target will be two bytes closer if we are
2237 able to relax. */
2238 if ((long) value < 1016 && (long) value > -1016)
2239 {
2240 int code2;
2241
2242 /* Get the opcode. */
2243 code2 = bfd_get_16 (abfd, contents + irel->r_offset - 2);
2244 if (code2 != 0x4030)
2245 continue;
2246 /* FIXME: check r4 and r3 ? */
2247 /* FIXME: Handle 0x4010 as well ? */
2248
2249 /* Note that we've changed the relocs, section contents, etc. */
2250 elf_section_data (sec)->relocs = internal_relocs;
2251 elf_section_data (sec)->this_hdr.contents = contents;
2252 symtab_hdr->contents = (unsigned char *) isymbuf;
2253
2254 /* Fix the relocation's type. */
2255 if (uses_msp430x_relocs (abfd))
2256 {
2257 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2258 R_MSP430X_10_PCREL);
2259 }
2260 else
2261 {
2262 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2263 R_MSP430_10_PCREL);
2264 }
2265
2266 /* Fix the opcode right way. */
2267 bfd_put_16 (abfd, 0x3c00, contents + irel->r_offset - 2);
2268 irel->r_offset -= 2;
2269
2270 /* Delete bytes. */
2271 if (!msp430_elf_relax_delete_bytes (abfd, sec,
2272 irel->r_offset + 2, 2))
2273 goto error_return;
2274
2275 /* That will change things, so, we should relax again.
2276 Note that this is not required, and it may be slow. */
2277 *again = TRUE;
2278 }
2279 }
2280 }
2281
2282 if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
2283 {
2284 if (!link_info->keep_memory)
2285 free (isymbuf);
2286 else
2287 {
2288 /* Cache the symbols for elf_link_input_bfd. */
2289 symtab_hdr->contents = (unsigned char *) isymbuf;
2290 }
2291 }
2292
2293 if (contents != NULL
2294 && elf_section_data (sec)->this_hdr.contents != contents)
2295 {
2296 if (!link_info->keep_memory)
2297 free (contents);
2298 else
2299 {
2300 /* Cache the section contents for elf_link_input_bfd. */
2301 elf_section_data (sec)->this_hdr.contents = contents;
2302 }
2303 }
2304
2305 if (internal_relocs != NULL
2306 && elf_section_data (sec)->relocs != internal_relocs)
2307 free (internal_relocs);
2308
2309 return TRUE;
2310
2311 error_return:
2312 if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
2313 free (isymbuf);
2314 if (contents != NULL
2315 && elf_section_data (sec)->this_hdr.contents != contents)
2316 free (contents);
2317 if (internal_relocs != NULL
2318 && elf_section_data (sec)->relocs != internal_relocs)
2319 free (internal_relocs);
2320
2321 return FALSE;
2322 }
2323
2324 /* Handle an MSP430 specific section when reading an object file.
2325 This is called when bfd_section_from_shdr finds a section with
2326 an unknown type. */
2327
2328 static bfd_boolean
2329 elf32_msp430_section_from_shdr (bfd *abfd,
2330 Elf_Internal_Shdr * hdr,
2331 const char *name,
2332 int shindex)
2333 {
2334 switch (hdr->sh_type)
2335 {
2336 case SHT_MSP430_SEC_FLAGS:
2337 case SHT_MSP430_SYM_ALIASES:
2338 case SHT_MSP430_ATTRIBUTES:
2339 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2340 default:
2341 return FALSE;
2342 }
2343 }
2344
2345 static bfd_boolean
2346 elf32_msp430_obj_attrs_handle_unknown (bfd *abfd, int tag)
2347 {
2348 _bfd_error_handler
2349 (_("Warning: %B: Unknown MSPABI object attribute %d"),
2350 abfd, tag);
2351 return TRUE;
2352 }
2353
2354 /* Determine whether an object attribute tag takes an integer, a
2355 string or both. */
2356
2357 static int
2358 elf32_msp430_obj_attrs_arg_type (int tag)
2359 {
2360 if (tag == Tag_compatibility)
2361 return ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_STR_VAL;
2362
2363 if (tag < 32)
2364 return ATTR_TYPE_FLAG_INT_VAL;
2365
2366 return (tag & 1) != 0 ? ATTR_TYPE_FLAG_STR_VAL : ATTR_TYPE_FLAG_INT_VAL;
2367 }
2368
2369 static inline const char *
2370 isa_type (int isa)
2371 {
2372 switch (isa)
2373 {
2374 case 1: return "MSP430";
2375 case 2: return "MSP430X";
2376 default: return "unknown";
2377 }
2378 }
2379
2380 static inline const char *
2381 code_model (int model)
2382 {
2383 switch (model)
2384 {
2385 case 1: return "small";
2386 case 2: return "large";
2387 default: return "unknown";
2388 }
2389 }
2390
2391 static inline const char *
2392 data_model (int model)
2393 {
2394 switch (model)
2395 {
2396 case 1: return "small";
2397 case 2: return "large";
2398 case 3: return "restricted large";
2399 default: return "unknown";
2400 }
2401 }
2402
2403 /* Merge MSPABI object attributes from IBFD into OBFD.
2404 Raise an error if there are conflicting attributes. */
2405
2406 static bfd_boolean
2407 elf32_msp430_merge_mspabi_attributes (bfd *ibfd, bfd *obfd)
2408 {
2409 obj_attribute *in_attr;
2410 obj_attribute *out_attr;
2411 bfd_boolean result = TRUE;
2412 static bfd * first_input_bfd = NULL;
2413
2414 /* Skip linker created files. */
2415 if (ibfd->flags & BFD_LINKER_CREATED)
2416 return TRUE;
2417
2418 /* If this is the first real object just copy the attributes. */
2419 if (!elf_known_obj_attributes_proc (obfd)[0].i)
2420 {
2421 _bfd_elf_copy_obj_attributes (ibfd, obfd);
2422
2423 out_attr = elf_known_obj_attributes_proc (obfd);
2424
2425 /* Use the Tag_null value to indicate that
2426 the attributes have been initialized. */
2427 out_attr[0].i = 1;
2428
2429 first_input_bfd = ibfd;
2430 return TRUE;
2431 }
2432
2433 in_attr = elf_known_obj_attributes_proc (ibfd);
2434 out_attr = elf_known_obj_attributes_proc (obfd);
2435
2436 /* The ISAs must be the same. */
2437 if (in_attr[OFBA_MSPABI_Tag_ISA].i != out_attr[OFBA_MSPABI_Tag_ISA].i)
2438 {
2439 _bfd_error_handler
2440 (_("error: %B uses %s instructions but %B uses %s"),
2441 ibfd, first_input_bfd,
2442 isa_type (in_attr[OFBA_MSPABI_Tag_ISA].i),
2443 isa_type (out_attr[OFBA_MSPABI_Tag_ISA].i));
2444 result = FALSE;
2445 }
2446
2447 /* The code models must be the same. */
2448 if (in_attr[OFBA_MSPABI_Tag_Code_Model].i !=
2449 out_attr[OFBA_MSPABI_Tag_Code_Model].i)
2450 {
2451 _bfd_error_handler
2452 (_("error: %B uses the %s code model whereas %B uses the %s code model"),
2453 ibfd, first_input_bfd,
2454 code_model (in_attr[OFBA_MSPABI_Tag_Code_Model].i),
2455 code_model (out_attr[OFBA_MSPABI_Tag_Code_Model].i));
2456 result = FALSE;
2457 }
2458
2459 /* The large code model is only supported by the MSP430X. */
2460 if (in_attr[OFBA_MSPABI_Tag_Code_Model].i == 2
2461 && out_attr[OFBA_MSPABI_Tag_ISA].i != 2)
2462 {
2463 _bfd_error_handler
2464 (_("error: %B uses the large code model but %B uses MSP430 instructions"),
2465 ibfd, first_input_bfd);
2466 result = FALSE;
2467 }
2468
2469 /* The data models must be the same. */
2470 if (in_attr[OFBA_MSPABI_Tag_Data_Model].i !=
2471 out_attr[OFBA_MSPABI_Tag_Data_Model].i)
2472 {
2473 _bfd_error_handler
2474 (_("error: %B uses the %s data model whereas %B uses the %s data model"),
2475 ibfd, first_input_bfd,
2476 data_model (in_attr[OFBA_MSPABI_Tag_Data_Model].i),
2477 data_model (out_attr[OFBA_MSPABI_Tag_Data_Model].i));
2478 result = FALSE;
2479 }
2480
2481 /* The small code model requires the use of the small data model. */
2482 if (in_attr[OFBA_MSPABI_Tag_Code_Model].i == 1
2483 && out_attr[OFBA_MSPABI_Tag_Data_Model].i != 1)
2484 {
2485 _bfd_error_handler
2486 (_("error: %B uses the small code model but %B uses the %s data model"),
2487 ibfd, first_input_bfd,
2488 data_model (out_attr[OFBA_MSPABI_Tag_Data_Model].i));
2489 result = FALSE;
2490 }
2491
2492 /* The large data models are only supported by the MSP430X. */
2493 if (in_attr[OFBA_MSPABI_Tag_Data_Model].i > 1
2494 && out_attr[OFBA_MSPABI_Tag_ISA].i != 2)
2495 {
2496 _bfd_error_handler
2497 (_("error: %B uses the %s data model but %B only uses MSP430 instructions"),
2498 ibfd, first_input_bfd,
2499 data_model (in_attr[OFBA_MSPABI_Tag_Data_Model].i));
2500 result = FALSE;
2501 }
2502
2503 return result;
2504 }
2505
2506 /* Merge backend specific data from an object file to the output
2507 object file when linking. */
2508
2509 static bfd_boolean
2510 elf32_msp430_merge_private_bfd_data (bfd * ibfd, bfd * obfd)
2511 {
2512 /* Make sure that the machine number reflects the most
2513 advanced version of the MSP architecture required. */
2514 #define max(a,b) ((a) > (b) ? (a) : (b))
2515 if (bfd_get_mach (ibfd) != bfd_get_mach (obfd))
2516 bfd_default_set_arch_mach (obfd, bfd_get_arch (obfd),
2517 max (bfd_get_mach (ibfd), bfd_get_mach (obfd)));
2518 #undef max
2519
2520 return elf32_msp430_merge_mspabi_attributes (ibfd, obfd);
2521 }
2522
2523 static bfd_boolean
2524 msp430_elf_is_target_special_symbol (bfd *abfd, asymbol *sym)
2525 {
2526 return _bfd_elf_is_local_label_name (abfd, sym->name);
2527 }
2528
2529 /* This is gross. The MSP430 EABI says that (sec 11.5):
2530
2531 "An implementation may choose to use Rel or Rela
2532 type relocations for other relocations."
2533
2534 But it also says that:
2535
2536 "Certain relocations are identified as Rela only. [snip]
2537 Where Rela is specified, an implementation must honor
2538 this requirement."
2539
2540 There is one relocation marked as requiring RELA - R_MSP430_ABS_HI16 - but
2541 to keep things simple we choose to use RELA relocations throughout. The
2542 problem is that the TI compiler generates REL relocations, so we have to
2543 be able to accept those as well. */
2544
2545 #define elf_backend_may_use_rel_p 1
2546 #define elf_backend_may_use_rela_p 1
2547 #define elf_backend_default_use_rela_p 1
2548
2549 #undef elf_backend_obj_attrs_vendor
2550 #define elf_backend_obj_attrs_vendor "mspabi"
2551 #undef elf_backend_obj_attrs_section
2552 #define elf_backend_obj_attrs_section ".MSP430.attributes"
2553 #undef elf_backend_obj_attrs_section_type
2554 #define elf_backend_obj_attrs_section_type SHT_MSP430_ATTRIBUTES
2555 #define elf_backend_section_from_shdr elf32_msp430_section_from_shdr
2556 #define elf_backend_obj_attrs_handle_unknown elf32_msp430_obj_attrs_handle_unknown
2557 #undef elf_backend_obj_attrs_arg_type
2558 #define elf_backend_obj_attrs_arg_type elf32_msp430_obj_attrs_arg_type
2559 #define bfd_elf32_bfd_merge_private_bfd_data elf32_msp430_merge_private_bfd_data
2560
2561 #define ELF_ARCH bfd_arch_msp430
2562 #define ELF_MACHINE_CODE EM_MSP430
2563 #define ELF_MACHINE_ALT1 EM_MSP430_OLD
2564 #define ELF_MAXPAGESIZE 4
2565 #define ELF_OSABI ELFOSABI_STANDALONE
2566
2567 #define TARGET_LITTLE_SYM msp430_elf32_vec
2568 #define TARGET_LITTLE_NAME "elf32-msp430"
2569
2570 #define elf_info_to_howto msp430_info_to_howto_rela
2571 #define elf_info_to_howto_rel NULL
2572 #define elf_backend_relocate_section elf32_msp430_relocate_section
2573 #define elf_backend_check_relocs elf32_msp430_check_relocs
2574 #define elf_backend_can_gc_sections 1
2575 #define elf_backend_final_write_processing bfd_elf_msp430_final_write_processing
2576 #define elf_backend_object_p elf32_msp430_object_p
2577 #define bfd_elf32_bfd_relax_section msp430_elf_relax_section
2578 #define bfd_elf32_bfd_is_target_special_symbol msp430_elf_is_target_special_symbol
2579
2580 #undef elf32_bed
2581 #define elf32_bed elf32_msp430_bed
2582
2583 #include "elf32-target.h"
2584
2585 /* The TI compiler sets the OSABI field to ELFOSABI_NONE. */
2586 #undef TARGET_LITTLE_SYM
2587 #define TARGET_LITTLE_SYM msp430_elf32_ti_vec
2588
2589 #undef elf32_bed
2590 #define elf32_bed elf32_msp430_ti_bed
2591
2592 #undef ELF_OSABI
2593 #define ELF_OSABI ELFOSABI_NONE
2594
2595 static const struct bfd_elf_special_section msp430_ti_elf_special_sections[] =
2596 {
2597 /* prefix, prefix_length, suffix_len, type, attributes. */
2598 { STRING_COMMA_LEN (".TI.symbol.alias"), 0, SHT_MSP430_SYM_ALIASES, 0 },
2599 { STRING_COMMA_LEN (".TI.section.flags"), 0, SHT_MSP430_SEC_FLAGS, 0 },
2600 { STRING_COMMA_LEN ("_TI_build_attrib"), 0, SHT_MSP430_ATTRIBUTES, 0 },
2601 { NULL, 0, 0, 0, 0 }
2602 };
2603
2604 #include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.082001 seconds and 4 git commands to generate.