]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blob - bfd/elf32-msp430.c
projects / thirdparty / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Update year range in copyright notice of all files.
[thirdparty/binutils-gdb.git] / bfd / elf32-msp430.c
1 /* MSP430-specific support for 32-bit ELF
2 Copyright (C) 2002-2017 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 /* xgettext:c-format */
648 _bfd_error_handler (_("%B: invalid MSP430X reloc number: %d"), abfd, r_type);
649 r_type = 0;
650 }
651 cache_ptr->howto = elf_msp430x_howto_table + r_type;
652 return;
653 }
654
655 if (r_type >= (unsigned int) R_MSP430_max)
656 {
657 /* xgettext:c-format */
658 _bfd_error_handler (_("%B: invalid MSP430 reloc number: %d"), abfd, r_type);
659 r_type = 0;
660 }
661 cache_ptr->howto = &elf_msp430_howto_table[r_type];
662 }
663
664 /* Look through the relocs for a section during the first phase.
665 Since we don't do .gots or .plts, we just need to consider the
666 virtual table relocs for gc. */
667
668 static bfd_boolean
669 elf32_msp430_check_relocs (bfd * abfd, struct bfd_link_info * info,
670 asection * sec, const Elf_Internal_Rela * relocs)
671 {
672 Elf_Internal_Shdr *symtab_hdr;
673 struct elf_link_hash_entry **sym_hashes;
674 const Elf_Internal_Rela *rel;
675 const Elf_Internal_Rela *rel_end;
676
677 if (bfd_link_relocatable (info))
678 return TRUE;
679
680 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
681 sym_hashes = elf_sym_hashes (abfd);
682
683 rel_end = relocs + sec->reloc_count;
684 for (rel = relocs; rel < rel_end; rel++)
685 {
686 struct elf_link_hash_entry *h;
687 unsigned long r_symndx;
688
689 r_symndx = ELF32_R_SYM (rel->r_info);
690 if (r_symndx < symtab_hdr->sh_info)
691 h = NULL;
692 else
693 {
694 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
695 while (h->root.type == bfd_link_hash_indirect
696 || h->root.type == bfd_link_hash_warning)
697 h = (struct elf_link_hash_entry *) h->root.u.i.link;
698
699 /* PR15323, ref flags aren't set for references in the same
700 object. */
701 h->root.non_ir_ref = 1;
702 }
703 }
704
705 return TRUE;
706 }
707
708 /* Perform a single relocation. By default we use the standard BFD
709 routines, but a few relocs, we have to do them ourselves. */
710
711 static bfd_reloc_status_type
712 msp430_final_link_relocate (reloc_howto_type * howto,
713 bfd * input_bfd,
714 asection * input_section,
715 bfd_byte * contents,
716 Elf_Internal_Rela * rel,
717 bfd_vma relocation,
718 struct bfd_link_info * info)
719 {
720 static asection * sym_diff_section;
721 static bfd_vma sym_diff_value;
722
723 struct bfd_elf_section_data * esd = elf_section_data (input_section);
724 bfd_reloc_status_type r = bfd_reloc_ok;
725 bfd_vma x;
726 bfd_signed_vma srel;
727 bfd_boolean is_rel_reloc = FALSE;
728
729 if (uses_msp430x_relocs (input_bfd))
730 {
731 /* See if we have a REL type relocation. */
732 is_rel_reloc = (esd->rel.hdr != NULL);
733 /* Sanity check - only one type of relocation per section.
734 FIXME: Theoretically it is possible to have both types,
735 but if that happens how can we distinguish between the two ? */
736 BFD_ASSERT (! is_rel_reloc || ! esd->rela.hdr);
737 /* If we are using a REL relocation then the addend should be empty. */
738 BFD_ASSERT (! is_rel_reloc || rel->r_addend == 0);
739 }
740
741 if (sym_diff_section != NULL)
742 {
743 BFD_ASSERT (sym_diff_section == input_section);
744
745 if (uses_msp430x_relocs (input_bfd))
746 switch (howto->type)
747 {
748 case R_MSP430_ABS32:
749 /* If we are computing a 32-bit value for the location lists
750 and the result is 0 then we add one to the value. A zero
751 value can result because of linker relaxation deleteing
752 prologue instructions and using a value of 1 (for the begin
753 and end offsets in the location list entry) results in a
754 nul entry which does not prevent the following entries from
755 being parsed. */
756 if (relocation == sym_diff_value
757 && strcmp (input_section->name, ".debug_loc") == 0)
758 ++ relocation;
759 /* Fall through. */
760 case R_MSP430_ABS16:
761 case R_MSP430X_ABS16:
762 case R_MSP430_ABS8:
763 BFD_ASSERT (! is_rel_reloc);
764 relocation -= sym_diff_value;
765 break;
766
767 default:
768 return bfd_reloc_dangerous;
769 }
770 else
771 switch (howto->type)
772 {
773 case R_MSP430_32:
774 case R_MSP430_16:
775 case R_MSP430_16_BYTE:
776 case R_MSP430_8:
777 relocation -= sym_diff_value;
778 break;
779
780 default:
781 return bfd_reloc_dangerous;
782 }
783
784 sym_diff_section = NULL;
785 }
786
787 if (uses_msp430x_relocs (input_bfd))
788 switch (howto->type)
789 {
790 case R_MSP430X_SYM_DIFF:
791 /* Cache the input section and value.
792 The offset is unreliable, since relaxation may
793 have reduced the following reloc's offset. */
794 BFD_ASSERT (! is_rel_reloc);
795 sym_diff_section = input_section;
796 sym_diff_value = relocation;
797 return bfd_reloc_ok;
798
799 case R_MSP430_ABS16:
800 contents += rel->r_offset;
801 srel = (bfd_signed_vma) relocation;
802 if (is_rel_reloc)
803 srel += bfd_get_16 (input_bfd, contents);
804 else
805 srel += rel->r_addend;
806 bfd_put_16 (input_bfd, srel & 0xffff, contents);
807 break;
808
809 case R_MSP430X_10_PCREL:
810 contents += rel->r_offset;
811 srel = (bfd_signed_vma) relocation;
812 if (is_rel_reloc)
813 srel += bfd_get_16 (input_bfd, contents) & 0x3ff;
814 else
815 srel += rel->r_addend;
816 srel -= rel->r_offset;
817 srel -= 2; /* Branch instructions add 2 to the PC... */
818 srel -= (input_section->output_section->vma +
819 input_section->output_offset);
820 if (srel & 1)
821 return bfd_reloc_outofrange;
822
823 /* MSP430 addresses commands as words. */
824 srel >>= 1;
825
826 /* Check for an overflow. */
827 if (srel < -512 || srel > 511)
828 {
829 if (info->disable_target_specific_optimizations < 0)
830 {
831 static bfd_boolean warned = FALSE;
832 if (! warned)
833 {
834 info->callbacks->warning
835 (info,
836 _("Try enabling relaxation to avoid relocation truncations"),
837 NULL, input_bfd, input_section, relocation);
838 warned = TRUE;
839 }
840 }
841 return bfd_reloc_overflow;
842 }
843
844 x = bfd_get_16 (input_bfd, contents);
845 x = (x & 0xfc00) | (srel & 0x3ff);
846 bfd_put_16 (input_bfd, x, contents);
847 break;
848
849 case R_MSP430X_PCR20_EXT_ODST:
850 /* [0,4]+[48,16] = ---F ---- ---- FFFF */
851 contents += rel->r_offset;
852 srel = (bfd_signed_vma) relocation;
853 if (is_rel_reloc)
854 {
855 bfd_vma addend;
856 addend = (bfd_get_16 (input_bfd, contents) & 0xf) << 16;
857 addend |= bfd_get_16 (input_bfd, contents + 6);
858 srel += addend;
859
860 }
861 else
862 srel += rel->r_addend;
863 srel -= rel->r_offset;
864 srel -= (input_section->output_section->vma +
865 input_section->output_offset);
866 bfd_put_16 (input_bfd, (srel & 0xffff), contents + 6);
867 x = bfd_get_16 (input_bfd, contents);
868 x = (x & 0xfff0) | ((srel >> 16) & 0xf);
869 bfd_put_16 (input_bfd, x, contents);
870 break;
871
872 case R_MSP430X_ABS20_EXT_SRC:
873 /* [7,4]+[32,16] = -78- ---- FFFF */
874 contents += rel->r_offset;
875 srel = (bfd_signed_vma) relocation;
876 if (is_rel_reloc)
877 {
878 bfd_vma addend;
879 addend = (bfd_get_16 (input_bfd, contents) & 0x0780) << 9;
880 addend |= bfd_get_16 (input_bfd, contents + 4);
881 srel += addend;
882 }
883 else
884 srel += rel->r_addend;
885 bfd_put_16 (input_bfd, (srel & 0xffff), contents + 4);
886 srel >>= 16;
887 x = bfd_get_16 (input_bfd, contents);
888 x = (x & 0xf87f) | ((srel << 7) & 0x0780);
889 bfd_put_16 (input_bfd, x, contents);
890 break;
891
892 case R_MSP430_16_PCREL:
893 contents += rel->r_offset;
894 srel = (bfd_signed_vma) relocation;
895 if (is_rel_reloc)
896 srel += bfd_get_16 (input_bfd, contents);
897 else
898 srel += rel->r_addend;
899 srel -= rel->r_offset;
900 /* Only branch instructions add 2 to the PC... */
901 srel -= (input_section->output_section->vma +
902 input_section->output_offset);
903 if (srel & 1)
904 return bfd_reloc_outofrange;
905 bfd_put_16 (input_bfd, srel & 0xffff, contents);
906 break;
907
908 case R_MSP430X_PCR20_EXT_DST:
909 /* [0,4]+[32,16] = ---F ---- FFFF */
910 contents += rel->r_offset;
911 srel = (bfd_signed_vma) relocation;
912 if (is_rel_reloc)
913 {
914 bfd_vma addend;
915 addend = (bfd_get_16 (input_bfd, contents) & 0xf) << 16;
916 addend |= bfd_get_16 (input_bfd, contents + 4);
917 srel += addend;
918 }
919 else
920 srel += rel->r_addend;
921 srel -= rel->r_offset;
922 srel -= (input_section->output_section->vma +
923 input_section->output_offset);
924 bfd_put_16 (input_bfd, (srel & 0xffff), contents + 4);
925 srel >>= 16;
926 x = bfd_get_16 (input_bfd, contents);
927 x = (x & 0xfff0) | (srel & 0xf);
928 bfd_put_16 (input_bfd, x, contents);
929 break;
930
931 case R_MSP430X_PCR20_EXT_SRC:
932 /* [7,4]+[32,16] = -78- ---- FFFF */
933 contents += rel->r_offset;
934 srel = (bfd_signed_vma) relocation;
935 if (is_rel_reloc)
936 {
937 bfd_vma addend;
938 addend = ((bfd_get_16 (input_bfd, contents) & 0x0780) << 9);
939 addend |= bfd_get_16 (input_bfd, contents + 4);
940 srel += addend;;
941 }
942 else
943 srel += rel->r_addend;
944 srel -= rel->r_offset;
945 /* Only branch instructions add 2 to the PC... */
946 srel -= (input_section->output_section->vma +
947 input_section->output_offset);
948 bfd_put_16 (input_bfd, (srel & 0xffff), contents + 4);
949 srel >>= 16;
950 x = bfd_get_16 (input_bfd, contents);
951 x = (x & 0xf87f) | ((srel << 7) & 0x0780);
952 bfd_put_16 (input_bfd, x, contents);
953 break;
954
955 case R_MSP430_ABS8:
956 contents += rel->r_offset;
957 srel = (bfd_signed_vma) relocation;
958 if (is_rel_reloc)
959 srel += bfd_get_8 (input_bfd, contents);
960 else
961 srel += rel->r_addend;
962 bfd_put_8 (input_bfd, srel & 0xff, contents);
963 break;
964
965 case R_MSP430X_ABS20_EXT_DST:
966 /* [0,4]+[32,16] = ---F ---- FFFF */
967 contents += rel->r_offset;
968 srel = (bfd_signed_vma) relocation;
969 if (is_rel_reloc)
970 {
971 bfd_vma addend;
972 addend = (bfd_get_16 (input_bfd, contents) & 0xf) << 16;
973 addend |= bfd_get_16 (input_bfd, contents + 4);
974 srel += addend;
975 }
976 else
977 srel += rel->r_addend;
978 bfd_put_16 (input_bfd, (srel & 0xffff), contents + 4);
979 srel >>= 16;
980 x = bfd_get_16 (input_bfd, contents);
981 x = (x & 0xfff0) | (srel & 0xf);
982 bfd_put_16 (input_bfd, x, contents);
983 break;
984
985 case R_MSP430X_ABS20_EXT_ODST:
986 /* [0,4]+[48,16] = ---F ---- ---- FFFF */
987 contents += rel->r_offset;
988 srel = (bfd_signed_vma) relocation;
989 if (is_rel_reloc)
990 {
991 bfd_vma addend;
992 addend = (bfd_get_16 (input_bfd, contents) & 0xf) << 16;
993 addend |= bfd_get_16 (input_bfd, contents + 6);
994 srel += addend;
995 }
996 else
997 srel += rel->r_addend;
998 bfd_put_16 (input_bfd, (srel & 0xffff), contents + 6);
999 srel >>= 16;
1000 x = bfd_get_16 (input_bfd, contents);
1001 x = (x & 0xfff0) | (srel & 0xf);
1002 bfd_put_16 (input_bfd, x, contents);
1003 break;
1004
1005 case R_MSP430X_ABS20_ADR_SRC:
1006 /* [8,4]+[16,16] = -F-- FFFF */
1007 contents += rel->r_offset;
1008 srel = (bfd_signed_vma) relocation;
1009 if (is_rel_reloc)
1010 {
1011 bfd_vma addend;
1012
1013 addend = ((bfd_get_16 (input_bfd, contents) & 0xf00) << 8);
1014 addend |= bfd_get_16 (input_bfd, contents + 2);
1015 srel += addend;
1016 }
1017 else
1018 srel += rel->r_addend;
1019 bfd_put_16 (input_bfd, (srel & 0xffff), contents + 2);
1020 srel >>= 16;
1021 x = bfd_get_16 (input_bfd, contents);
1022 x = (x & 0xf0ff) | ((srel << 8) & 0x0f00);
1023 bfd_put_16 (input_bfd, x, contents);
1024 break;
1025
1026 case R_MSP430X_ABS20_ADR_DST:
1027 /* [0,4]+[16,16] = ---F FFFF */
1028 contents += rel->r_offset;
1029 srel = (bfd_signed_vma) relocation;
1030 if (is_rel_reloc)
1031 {
1032 bfd_vma addend;
1033 addend = ((bfd_get_16 (input_bfd, contents) & 0xf) << 16);
1034 addend |= bfd_get_16 (input_bfd, contents + 2);
1035 srel += addend;
1036 }
1037 else
1038 srel += rel->r_addend;
1039 bfd_put_16 (input_bfd, (srel & 0xffff), contents + 2);
1040 srel >>= 16;
1041 x = bfd_get_16 (input_bfd, contents);
1042 x = (x & 0xfff0) | (srel & 0xf);
1043 bfd_put_16 (input_bfd, x, contents);
1044 break;
1045
1046 case R_MSP430X_ABS16:
1047 contents += rel->r_offset;
1048 srel = (bfd_signed_vma) relocation;
1049 if (is_rel_reloc)
1050 srel += bfd_get_16 (input_bfd, contents);
1051 else
1052 srel += rel->r_addend;
1053 x = srel;
1054 if (x > 0xffff)
1055 return bfd_reloc_overflow;
1056 bfd_put_16 (input_bfd, srel & 0xffff, contents);
1057 break;
1058
1059 case R_MSP430_ABS_HI16:
1060 /* The EABI specifies that this must be a RELA reloc. */
1061 BFD_ASSERT (! is_rel_reloc);
1062 contents += rel->r_offset;
1063 srel = (bfd_signed_vma) relocation;
1064 srel += rel->r_addend;
1065 bfd_put_16 (input_bfd, (srel >> 16) & 0xffff, contents);
1066 break;
1067
1068 case R_MSP430X_PCR20_CALL:
1069 /* [0,4]+[16,16] = ---F FFFF*/
1070 contents += rel->r_offset;
1071 srel = (bfd_signed_vma) relocation;
1072 if (is_rel_reloc)
1073 {
1074 bfd_vma addend;
1075 addend = (bfd_get_16 (input_bfd, contents) & 0xf) << 16;
1076 addend |= bfd_get_16 (input_bfd, contents + 2);
1077 srel += addend;
1078 }
1079 else
1080 srel += rel->r_addend;
1081 srel -= rel->r_offset;
1082 srel -= (input_section->output_section->vma +
1083 input_section->output_offset);
1084 bfd_put_16 (input_bfd, srel & 0xffff, contents + 2);
1085 srel >>= 16;
1086 x = bfd_get_16 (input_bfd, contents);
1087 x = (x & 0xfff0) | (srel & 0xf);
1088 bfd_put_16 (input_bfd, x, contents);
1089 break;
1090
1091 case R_MSP430X_PCR16:
1092 contents += rel->r_offset;
1093 srel = (bfd_signed_vma) relocation;
1094 if (is_rel_reloc)
1095 srel += bfd_get_16 (input_bfd, contents);
1096 else
1097 srel += rel->r_addend;
1098 srel -= rel->r_offset;
1099 srel -= (input_section->output_section->vma +
1100 input_section->output_offset);
1101 bfd_put_16 (input_bfd, srel & 0xffff, contents);
1102 break;
1103
1104 case R_MSP430_PREL31:
1105 contents += rel->r_offset;
1106 srel = (bfd_signed_vma) relocation;
1107 if (is_rel_reloc)
1108 srel += (bfd_get_32 (input_bfd, contents) & 0x7fffffff);
1109 else
1110 srel += rel->r_addend;
1111 srel += rel->r_addend;
1112 x = bfd_get_32 (input_bfd, contents);
1113 x = (x & 0x80000000) | ((srel >> 31) & 0x7fffffff);
1114 bfd_put_32 (input_bfd, x, contents);
1115 break;
1116
1117 default:
1118 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1119 contents, rel->r_offset,
1120 relocation, rel->r_addend);
1121 }
1122 else
1123 switch (howto->type)
1124 {
1125 case R_MSP430_10_PCREL:
1126 contents += rel->r_offset;
1127 srel = (bfd_signed_vma) relocation;
1128 srel += rel->r_addend;
1129 srel -= rel->r_offset;
1130 srel -= 2; /* Branch instructions add 2 to the PC... */
1131 srel -= (input_section->output_section->vma +
1132 input_section->output_offset);
1133
1134 if (srel & 1)
1135 return bfd_reloc_outofrange;
1136
1137 /* MSP430 addresses commands as words. */
1138 srel >>= 1;
1139
1140 /* Check for an overflow. */
1141 if (srel < -512 || srel > 511)
1142 {
1143 if (info->disable_target_specific_optimizations < 0)
1144 {
1145 static bfd_boolean warned = FALSE;
1146 if (! warned)
1147 {
1148 info->callbacks->warning
1149 (info,
1150 _("Try enabling relaxation to avoid relocation truncations"),
1151 NULL, input_bfd, input_section, relocation);
1152 warned = TRUE;
1153 }
1154 }
1155 return bfd_reloc_overflow;
1156 }
1157
1158 x = bfd_get_16 (input_bfd, contents);
1159 x = (x & 0xfc00) | (srel & 0x3ff);
1160 bfd_put_16 (input_bfd, x, contents);
1161 break;
1162
1163 case R_MSP430_2X_PCREL:
1164 contents += rel->r_offset;
1165 srel = (bfd_signed_vma) relocation;
1166 srel += rel->r_addend;
1167 srel -= rel->r_offset;
1168 srel -= 2; /* Branch instructions add 2 to the PC... */
1169 srel -= (input_section->output_section->vma +
1170 input_section->output_offset);
1171
1172 if (srel & 1)
1173 return bfd_reloc_outofrange;
1174
1175 /* MSP430 addresses commands as words. */
1176 srel >>= 1;
1177
1178 /* Check for an overflow. */
1179 if (srel < -512 || srel > 511)
1180 return bfd_reloc_overflow;
1181
1182 x = bfd_get_16 (input_bfd, contents);
1183 x = (x & 0xfc00) | (srel & 0x3ff);
1184 bfd_put_16 (input_bfd, x, contents);
1185 /* Handle second jump instruction. */
1186 x = bfd_get_16 (input_bfd, contents - 2);
1187 srel += 1;
1188 x = (x & 0xfc00) | (srel & 0x3ff);
1189 bfd_put_16 (input_bfd, x, contents - 2);
1190 break;
1191
1192 case R_MSP430_RL_PCREL:
1193 case R_MSP430_16_PCREL:
1194 contents += rel->r_offset;
1195 srel = (bfd_signed_vma) relocation;
1196 srel += rel->r_addend;
1197 srel -= rel->r_offset;
1198 /* Only branch instructions add 2 to the PC... */
1199 srel -= (input_section->output_section->vma +
1200 input_section->output_offset);
1201
1202 if (srel & 1)
1203 return bfd_reloc_outofrange;
1204
1205 bfd_put_16 (input_bfd, srel & 0xffff, contents);
1206 break;
1207
1208 case R_MSP430_16_PCREL_BYTE:
1209 contents += rel->r_offset;
1210 srel = (bfd_signed_vma) relocation;
1211 srel += rel->r_addend;
1212 srel -= rel->r_offset;
1213 /* Only branch instructions add 2 to the PC... */
1214 srel -= (input_section->output_section->vma +
1215 input_section->output_offset);
1216
1217 bfd_put_16 (input_bfd, srel & 0xffff, contents);
1218 break;
1219
1220 case R_MSP430_16_BYTE:
1221 contents += rel->r_offset;
1222 srel = (bfd_signed_vma) relocation;
1223 srel += rel->r_addend;
1224 bfd_put_16 (input_bfd, srel & 0xffff, contents);
1225 break;
1226
1227 case R_MSP430_16:
1228 contents += rel->r_offset;
1229 srel = (bfd_signed_vma) relocation;
1230 srel += rel->r_addend;
1231
1232 if (srel & 1)
1233 return bfd_reloc_notsupported;
1234
1235 bfd_put_16 (input_bfd, srel & 0xffff, contents);
1236 break;
1237
1238 case R_MSP430_8:
1239 contents += rel->r_offset;
1240 srel = (bfd_signed_vma) relocation;
1241 srel += rel->r_addend;
1242
1243 bfd_put_8 (input_bfd, srel & 0xff, contents);
1244 break;
1245
1246 case R_MSP430_SYM_DIFF:
1247 /* Cache the input section and value.
1248 The offset is unreliable, since relaxation may
1249 have reduced the following reloc's offset. */
1250 sym_diff_section = input_section;
1251 sym_diff_value = relocation;
1252 return bfd_reloc_ok;
1253
1254 default:
1255 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1256 contents, rel->r_offset,
1257 relocation, rel->r_addend);
1258 }
1259
1260 return r;
1261 }
1262
1263 /* Relocate an MSP430 ELF section. */
1264
1265 static bfd_boolean
1266 elf32_msp430_relocate_section (bfd * output_bfd ATTRIBUTE_UNUSED,
1267 struct bfd_link_info * info,
1268 bfd * input_bfd,
1269 asection * input_section,
1270 bfd_byte * contents,
1271 Elf_Internal_Rela * relocs,
1272 Elf_Internal_Sym * local_syms,
1273 asection ** local_sections)
1274 {
1275 Elf_Internal_Shdr *symtab_hdr;
1276 struct elf_link_hash_entry **sym_hashes;
1277 Elf_Internal_Rela *rel;
1278 Elf_Internal_Rela *relend;
1279
1280 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1281 sym_hashes = elf_sym_hashes (input_bfd);
1282 relend = relocs + input_section->reloc_count;
1283
1284 for (rel = relocs; rel < relend; rel++)
1285 {
1286 reloc_howto_type *howto;
1287 unsigned long r_symndx;
1288 Elf_Internal_Sym *sym;
1289 asection *sec;
1290 struct elf_link_hash_entry *h;
1291 bfd_vma relocation;
1292 bfd_reloc_status_type r;
1293 const char *name = NULL;
1294 int r_type;
1295
1296 r_type = ELF32_R_TYPE (rel->r_info);
1297 r_symndx = ELF32_R_SYM (rel->r_info);
1298
1299 if (uses_msp430x_relocs (input_bfd))
1300 howto = elf_msp430x_howto_table + r_type;
1301 else
1302 howto = elf_msp430_howto_table + r_type;
1303
1304 h = NULL;
1305 sym = NULL;
1306 sec = NULL;
1307
1308 if (r_symndx < symtab_hdr->sh_info)
1309 {
1310 sym = local_syms + r_symndx;
1311 sec = local_sections[r_symndx];
1312 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1313
1314 name = bfd_elf_string_from_elf_section
1315 (input_bfd, symtab_hdr->sh_link, sym->st_name);
1316 name = (name == NULL || * name == 0) ? bfd_section_name (input_bfd, sec) : name;
1317 }
1318 else
1319 {
1320 bfd_boolean unresolved_reloc, warned, ignored;
1321
1322 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1323 r_symndx, symtab_hdr, sym_hashes,
1324 h, sec, relocation,
1325 unresolved_reloc, warned, ignored);
1326 name = h->root.root.string;
1327 }
1328
1329 if (sec != NULL && discarded_section (sec))
1330 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
1331 rel, 1, relend, howto, 0, contents);
1332
1333 if (bfd_link_relocatable (info))
1334 continue;
1335
1336 r = msp430_final_link_relocate (howto, input_bfd, input_section,
1337 contents, rel, relocation, info);
1338
1339 if (r != bfd_reloc_ok)
1340 {
1341 const char *msg = (const char *) NULL;
1342
1343 switch (r)
1344 {
1345 case bfd_reloc_overflow:
1346 (*info->callbacks->reloc_overflow)
1347 (info, (h ? &h->root : NULL), name, howto->name,
1348 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
1349 break;
1350
1351 case bfd_reloc_undefined:
1352 (*info->callbacks->undefined_symbol)
1353 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
1354 break;
1355
1356 case bfd_reloc_outofrange:
1357 msg = _("internal error: branch/jump to an odd address detected");
1358 break;
1359
1360 case bfd_reloc_notsupported:
1361 msg = _("internal error: unsupported relocation error");
1362 break;
1363
1364 case bfd_reloc_dangerous:
1365 msg = _("internal error: dangerous relocation");
1366 break;
1367
1368 default:
1369 msg = _("internal error: unknown error");
1370 break;
1371 }
1372
1373 if (msg)
1374 (*info->callbacks->warning) (info, msg, name, input_bfd,
1375 input_section, rel->r_offset);
1376 }
1377
1378 }
1379
1380 return TRUE;
1381 }
1382
1383 /* The final processing done just before writing out a MSP430 ELF object
1384 file. This gets the MSP430 architecture right based on the machine
1385 number. */
1386
1387 static void
1388 bfd_elf_msp430_final_write_processing (bfd * abfd,
1389 bfd_boolean linker ATTRIBUTE_UNUSED)
1390 {
1391 unsigned long val;
1392
1393 switch (bfd_get_mach (abfd))
1394 {
1395 default:
1396 case bfd_mach_msp110: val = E_MSP430_MACH_MSP430x11x1; break;
1397 case bfd_mach_msp11: val = E_MSP430_MACH_MSP430x11; break;
1398 case bfd_mach_msp12: val = E_MSP430_MACH_MSP430x12; break;
1399 case bfd_mach_msp13: val = E_MSP430_MACH_MSP430x13; break;
1400 case bfd_mach_msp14: val = E_MSP430_MACH_MSP430x14; break;
1401 case bfd_mach_msp15: val = E_MSP430_MACH_MSP430x15; break;
1402 case bfd_mach_msp16: val = E_MSP430_MACH_MSP430x16; break;
1403 case bfd_mach_msp31: val = E_MSP430_MACH_MSP430x31; break;
1404 case bfd_mach_msp32: val = E_MSP430_MACH_MSP430x32; break;
1405 case bfd_mach_msp33: val = E_MSP430_MACH_MSP430x33; break;
1406 case bfd_mach_msp41: val = E_MSP430_MACH_MSP430x41; break;
1407 case bfd_mach_msp42: val = E_MSP430_MACH_MSP430x42; break;
1408 case bfd_mach_msp43: val = E_MSP430_MACH_MSP430x43; break;
1409 case bfd_mach_msp44: val = E_MSP430_MACH_MSP430x44; break;
1410 case bfd_mach_msp20: val = E_MSP430_MACH_MSP430x20; break;
1411 case bfd_mach_msp22: val = E_MSP430_MACH_MSP430x22; break;
1412 case bfd_mach_msp23: val = E_MSP430_MACH_MSP430x23; break;
1413 case bfd_mach_msp24: val = E_MSP430_MACH_MSP430x24; break;
1414 case bfd_mach_msp26: val = E_MSP430_MACH_MSP430x26; break;
1415 case bfd_mach_msp46: val = E_MSP430_MACH_MSP430x46; break;
1416 case bfd_mach_msp47: val = E_MSP430_MACH_MSP430x47; break;
1417 case bfd_mach_msp54: val = E_MSP430_MACH_MSP430x54; break;
1418 case bfd_mach_msp430x: val = E_MSP430_MACH_MSP430X; break;
1419 }
1420
1421 elf_elfheader (abfd)->e_machine = EM_MSP430;
1422 elf_elfheader (abfd)->e_flags &= ~EF_MSP430_MACH;
1423 elf_elfheader (abfd)->e_flags |= val;
1424 }
1425
1426 /* Set the right machine number. */
1427
1428 static bfd_boolean
1429 elf32_msp430_object_p (bfd * abfd)
1430 {
1431 int e_set = bfd_mach_msp14;
1432
1433 if (elf_elfheader (abfd)->e_machine == EM_MSP430
1434 || elf_elfheader (abfd)->e_machine == EM_MSP430_OLD)
1435 {
1436 int e_mach = elf_elfheader (abfd)->e_flags & EF_MSP430_MACH;
1437
1438 switch (e_mach)
1439 {
1440 default:
1441 case E_MSP430_MACH_MSP430x11: e_set = bfd_mach_msp11; break;
1442 case E_MSP430_MACH_MSP430x11x1: e_set = bfd_mach_msp110; break;
1443 case E_MSP430_MACH_MSP430x12: e_set = bfd_mach_msp12; break;
1444 case E_MSP430_MACH_MSP430x13: e_set = bfd_mach_msp13; break;
1445 case E_MSP430_MACH_MSP430x14: e_set = bfd_mach_msp14; break;
1446 case E_MSP430_MACH_MSP430x15: e_set = bfd_mach_msp15; break;
1447 case E_MSP430_MACH_MSP430x16: e_set = bfd_mach_msp16; break;
1448 case E_MSP430_MACH_MSP430x31: e_set = bfd_mach_msp31; break;
1449 case E_MSP430_MACH_MSP430x32: e_set = bfd_mach_msp32; break;
1450 case E_MSP430_MACH_MSP430x33: e_set = bfd_mach_msp33; break;
1451 case E_MSP430_MACH_MSP430x41: e_set = bfd_mach_msp41; break;
1452 case E_MSP430_MACH_MSP430x42: e_set = bfd_mach_msp42; break;
1453 case E_MSP430_MACH_MSP430x43: e_set = bfd_mach_msp43; break;
1454 case E_MSP430_MACH_MSP430x44: e_set = bfd_mach_msp44; break;
1455 case E_MSP430_MACH_MSP430x20: e_set = bfd_mach_msp20; break;
1456 case E_MSP430_MACH_MSP430x22: e_set = bfd_mach_msp22; break;
1457 case E_MSP430_MACH_MSP430x23: e_set = bfd_mach_msp23; break;
1458 case E_MSP430_MACH_MSP430x24: e_set = bfd_mach_msp24; break;
1459 case E_MSP430_MACH_MSP430x26: e_set = bfd_mach_msp26; break;
1460 case E_MSP430_MACH_MSP430x46: e_set = bfd_mach_msp46; break;
1461 case E_MSP430_MACH_MSP430x47: e_set = bfd_mach_msp47; break;
1462 case E_MSP430_MACH_MSP430x54: e_set = bfd_mach_msp54; break;
1463 case E_MSP430_MACH_MSP430X: e_set = bfd_mach_msp430x; break;
1464 }
1465 }
1466
1467 return bfd_default_set_arch_mach (abfd, bfd_arch_msp430, e_set);
1468 }
1469
1470 /* These functions handle relaxing for the msp430.
1471 Relaxation required only in two cases:
1472 - Bad hand coding like jumps from one section to another or
1473 from file to file.
1474 - Sibling calls. This will affect only 'jump label' polymorph. Without
1475 relaxing this enlarges code by 2 bytes. Sibcalls implemented but
1476 do not work in gcc's port by the reason I do not know.
1477 - To convert out of range conditional jump instructions (found inside
1478 a function) into inverted jumps over an unconditional branch instruction.
1479 Anyway, if a relaxation required, user should pass -relax option to the
1480 linker.
1481
1482 There are quite a few relaxing opportunities available on the msp430:
1483
1484 ================================================================
1485
1486 1. 3 words -> 1 word
1487
1488 eq == jeq label jne +4; br lab
1489 ne != jne label jeq +4; br lab
1490 lt < jl label jge +4; br lab
1491 ltu < jlo label lhs +4; br lab
1492 ge >= jge label jl +4; br lab
1493 geu >= jhs label jlo +4; br lab
1494
1495 2. 4 words -> 1 word
1496
1497 ltn < jn jn +2; jmp +4; br lab
1498
1499 3. 4 words -> 2 words
1500
1501 gt > jeq +2; jge label jeq +6; jl +4; br label
1502 gtu > jeq +2; jhs label jeq +6; jlo +4; br label
1503
1504 4. 4 words -> 2 words and 2 labels
1505
1506 leu <= jeq label; jlo label jeq +2; jhs +4; br label
1507 le <= jeq label; jl label jeq +2; jge +4; br label
1508 =================================================================
1509
1510 codemap for first cases is (labels masked ):
1511 eq: 0x2002,0x4010,0x0000 -> 0x2400
1512 ne: 0x2402,0x4010,0x0000 -> 0x2000
1513 lt: 0x3402,0x4010,0x0000 -> 0x3800
1514 ltu: 0x2c02,0x4010,0x0000 -> 0x2800
1515 ge: 0x3802,0x4010,0x0000 -> 0x3400
1516 geu: 0x2802,0x4010,0x0000 -> 0x2c00
1517
1518 second case:
1519 ltn: 0x3001,0x3c02,0x4010,0x0000 -> 0x3000
1520
1521 third case:
1522 gt: 0x2403,0x3802,0x4010,0x0000 -> 0x2401,0x3400
1523 gtu: 0x2403,0x2802,0x4010,0x0000 -> 0x2401,0x2c00
1524
1525 fourth case:
1526 leu: 0x2401,0x2c02,0x4010,0x0000 -> 0x2400,0x2800
1527 le: 0x2401,0x3402,0x4010,0x0000 -> 0x2400,0x3800
1528
1529 Unspecified case :)
1530 jump: 0x4010,0x0000 -> 0x3c00. */
1531
1532 #define NUMB_RELAX_CODES 12
1533 static struct rcodes_s
1534 {
1535 int f0, f1; /* From code. */
1536 int t0, t1; /* To code. */
1537 int labels; /* Position of labels: 1 - one label at first
1538 word, 2 - one at second word, 3 - two
1539 labels at both. */
1540 int cdx; /* Words to match. */
1541 int bs; /* Shrink bytes. */
1542 int off; /* Offset from old label for new code. */
1543 int ncl; /* New code length. */
1544 } rcode[] =
1545 {/* lab,cdx,bs,off,ncl */
1546 { 0x0000, 0x0000, 0x3c00, 0x0000, 1, 0, 2, 2, 2}, /* jump */
1547 { 0x0000, 0x2002, 0x2400, 0x0000, 1, 1, 4, 4, 2}, /* eq */
1548 { 0x0000, 0x2402, 0x2000, 0x0000, 1, 1, 4, 4, 2}, /* ne */
1549 { 0x0000, 0x3402, 0x3800, 0x0000, 1, 1, 4, 4, 2}, /* lt */
1550 { 0x0000, 0x2c02, 0x2800, 0x0000, 1, 1, 4, 4, 2}, /* ltu */
1551 { 0x0000, 0x3802, 0x3400, 0x0000, 1, 1, 4, 4, 2}, /* ge */
1552 { 0x0000, 0x2802, 0x2c00, 0x0000, 1, 1, 4, 4, 2}, /* geu */
1553 { 0x3001, 0x3c02, 0x3000, 0x0000, 1, 2, 6, 6, 2}, /* ltn */
1554 { 0x2403, 0x3802, 0x2401, 0x3400, 2, 2, 4, 6, 4}, /* gt */
1555 { 0x2403, 0x2802, 0x2401, 0x2c00, 2, 2, 4, 6, 4}, /* gtu */
1556 { 0x2401, 0x2c02, 0x2400, 0x2800, 3, 2, 4, 6, 4}, /* leu , 2 labels */
1557 { 0x2401, 0x2c02, 0x2400, 0x2800, 3, 2, 4, 6, 4}, /* le , 2 labels */
1558 { 0, 0, 0, 0, 0, 0, 0, 0, 0}
1559 };
1560
1561 /* Return TRUE if a symbol exists at the given address. */
1562
1563 static bfd_boolean
1564 msp430_elf_symbol_address_p (bfd * abfd,
1565 asection * sec,
1566 Elf_Internal_Sym * isym,
1567 bfd_vma addr)
1568 {
1569 Elf_Internal_Shdr *symtab_hdr;
1570 unsigned int sec_shndx;
1571 Elf_Internal_Sym *isymend;
1572 struct elf_link_hash_entry **sym_hashes;
1573 struct elf_link_hash_entry **end_hashes;
1574 unsigned int symcount;
1575
1576 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1577
1578 /* Examine all the local symbols. */
1579 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1580 for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
1581 if (isym->st_shndx == sec_shndx && isym->st_value == addr)
1582 return TRUE;
1583
1584 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1585 - symtab_hdr->sh_info);
1586 sym_hashes = elf_sym_hashes (abfd);
1587 end_hashes = sym_hashes + symcount;
1588 for (; sym_hashes < end_hashes; sym_hashes++)
1589 {
1590 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1591
1592 if ((sym_hash->root.type == bfd_link_hash_defined
1593 || sym_hash->root.type == bfd_link_hash_defweak)
1594 && sym_hash->root.u.def.section == sec
1595 && sym_hash->root.u.def.value == addr)
1596 return TRUE;
1597 }
1598
1599 return FALSE;
1600 }
1601
1602 /* Adjust all local symbols defined as '.section + 0xXXXX' (.section has
1603 sec_shndx) referenced from current and other sections. */
1604
1605 static bfd_boolean
1606 msp430_elf_relax_adjust_locals (bfd * abfd, asection * sec, bfd_vma addr,
1607 int count, unsigned int sec_shndx,
1608 bfd_vma toaddr)
1609 {
1610 Elf_Internal_Shdr *symtab_hdr;
1611 Elf_Internal_Rela *irel;
1612 Elf_Internal_Rela *irelend;
1613 Elf_Internal_Sym *isym;
1614
1615 irel = elf_section_data (sec)->relocs;
1616 if (irel == NULL)
1617 return TRUE;
1618
1619 irelend = irel + sec->reloc_count;
1620 symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
1621 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1622
1623 for (;irel < irelend; irel++)
1624 {
1625 unsigned int sidx = ELF32_R_SYM(irel->r_info);
1626 Elf_Internal_Sym *lsym = isym + sidx;
1627
1628 /* Adjust symbols referenced by .sec+0xXX. */
1629 if (irel->r_addend > addr && irel->r_addend < toaddr
1630 && sidx < symtab_hdr->sh_info
1631 && lsym->st_shndx == sec_shndx)
1632 irel->r_addend -= count;
1633 }
1634
1635 return TRUE;
1636 }
1637
1638 /* Delete some bytes from a section while relaxing. */
1639
1640 static bfd_boolean
1641 msp430_elf_relax_delete_bytes (bfd * abfd, asection * sec, bfd_vma addr,
1642 int count)
1643 {
1644 Elf_Internal_Shdr *symtab_hdr;
1645 unsigned int sec_shndx;
1646 bfd_byte *contents;
1647 Elf_Internal_Rela *irel;
1648 Elf_Internal_Rela *irelend;
1649 bfd_vma toaddr;
1650 Elf_Internal_Sym *isym;
1651 Elf_Internal_Sym *isymend;
1652 struct elf_link_hash_entry **sym_hashes;
1653 struct elf_link_hash_entry **end_hashes;
1654 unsigned int symcount;
1655 asection *p;
1656
1657 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1658
1659 contents = elf_section_data (sec)->this_hdr.contents;
1660
1661 toaddr = sec->size;
1662
1663 irel = elf_section_data (sec)->relocs;
1664 irelend = irel + sec->reloc_count;
1665
1666 /* Actually delete the bytes. */
1667 memmove (contents + addr, contents + addr + count,
1668 (size_t) (toaddr - addr - count));
1669 sec->size -= count;
1670
1671 /* Adjust all the relocs. */
1672 symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
1673 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1674 for (; irel < irelend; irel++)
1675 {
1676 /* Get the new reloc address. */
1677 if ((irel->r_offset > addr && irel->r_offset < toaddr))
1678 irel->r_offset -= count;
1679 }
1680
1681 for (p = abfd->sections; p != NULL; p = p->next)
1682 msp430_elf_relax_adjust_locals (abfd,p,addr,count,sec_shndx,toaddr);
1683
1684 /* Adjust the local symbols defined in this section. */
1685 symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
1686 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1687 for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
1688 {
1689 const char * name;
1690
1691 name = bfd_elf_string_from_elf_section
1692 (abfd, symtab_hdr->sh_link, isym->st_name);
1693 name = (name == NULL || * name == 0) ? bfd_section_name (abfd, sec) : name;
1694
1695 if (isym->st_shndx != sec_shndx)
1696 continue;
1697
1698 if (isym->st_value > addr
1699 && (isym->st_value < toaddr
1700 /* We also adjust a symbol at the end of the section if its name is
1701 on the list below. These symbols are used for debug info
1702 generation and they refer to the end of the current section, not
1703 the start of the next section. */
1704 || (isym->st_value == toaddr
1705 && name != NULL
1706 && (CONST_STRNEQ (name, ".Letext")
1707 || CONST_STRNEQ (name, ".LFE")))))
1708 {
1709 if (isym->st_value < addr + count)
1710 isym->st_value = addr;
1711 else
1712 isym->st_value -= count;
1713 }
1714 /* Adjust the function symbol's size as well. */
1715 else if (ELF_ST_TYPE (isym->st_info) == STT_FUNC
1716 && isym->st_value + isym->st_size > addr
1717 && isym->st_value + isym->st_size < toaddr)
1718 isym->st_size -= count;
1719 }
1720
1721 /* Now adjust the global symbols defined in this section. */
1722 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1723 - symtab_hdr->sh_info);
1724 sym_hashes = elf_sym_hashes (abfd);
1725 end_hashes = sym_hashes + symcount;
1726 for (; sym_hashes < end_hashes; sym_hashes++)
1727 {
1728 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1729
1730 if ((sym_hash->root.type == bfd_link_hash_defined
1731 || sym_hash->root.type == bfd_link_hash_defweak)
1732 && sym_hash->root.u.def.section == sec
1733 && sym_hash->root.u.def.value > addr
1734 && sym_hash->root.u.def.value < toaddr)
1735 {
1736 if (sym_hash->root.u.def.value < addr + count)
1737 sym_hash->root.u.def.value = addr;
1738 else
1739 sym_hash->root.u.def.value -= count;
1740 }
1741 /* Adjust the function symbol's size as well. */
1742 else if (sym_hash->root.type == bfd_link_hash_defined
1743 && sym_hash->root.u.def.section == sec
1744 && sym_hash->type == STT_FUNC
1745 && sym_hash->root.u.def.value + sym_hash->size > addr
1746 && sym_hash->root.u.def.value + sym_hash->size < toaddr)
1747 sym_hash->size -= count;
1748 }
1749
1750 return TRUE;
1751 }
1752
1753 /* Insert two words into a section whilst relaxing. */
1754
1755 static bfd_byte *
1756 msp430_elf_relax_add_two_words (bfd * abfd, asection * sec, bfd_vma addr,
1757 int word1, int word2)
1758 {
1759 Elf_Internal_Shdr *symtab_hdr;
1760 unsigned int sec_shndx;
1761 bfd_byte *contents;
1762 Elf_Internal_Rela *irel;
1763 Elf_Internal_Rela *irelend;
1764 Elf_Internal_Sym *isym;
1765 Elf_Internal_Sym *isymend;
1766 struct elf_link_hash_entry **sym_hashes;
1767 struct elf_link_hash_entry **end_hashes;
1768 unsigned int symcount;
1769 bfd_vma sec_end;
1770 asection *p;
1771
1772 contents = elf_section_data (sec)->this_hdr.contents;
1773 sec_end = sec->size;
1774
1775 /* Make space for the new words. */
1776 contents = bfd_realloc (contents, sec_end + 4);
1777 memmove (contents + addr + 4, contents + addr, sec_end - addr);
1778
1779 /* Insert the new words. */
1780 bfd_put_16 (abfd, word1, contents + addr);
1781 bfd_put_16 (abfd, word2, contents + addr + 2);
1782
1783 /* Update the section information. */
1784 sec->size += 4;
1785 elf_section_data (sec)->this_hdr.contents = contents;
1786
1787 /* Adjust all the relocs. */
1788 irel = elf_section_data (sec)->relocs;
1789 irelend = irel + sec->reloc_count;
1790
1791 for (; irel < irelend; irel++)
1792 if ((irel->r_offset >= addr && irel->r_offset < sec_end))
1793 irel->r_offset += 4;
1794
1795 /* Adjust the local symbols defined in this section. */
1796 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1797 for (p = abfd->sections; p != NULL; p = p->next)
1798 msp430_elf_relax_adjust_locals (abfd, p, addr, -4,
1799 sec_shndx, sec_end);
1800
1801 /* Adjust the global symbols affected by the move. */
1802 symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
1803 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1804 for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
1805 if (isym->st_shndx == sec_shndx
1806 && isym->st_value >= addr && isym->st_value < sec_end)
1807 isym->st_value += 4;
1808
1809 /* Now adjust the global symbols defined in this section. */
1810 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1811 - symtab_hdr->sh_info);
1812 sym_hashes = elf_sym_hashes (abfd);
1813 end_hashes = sym_hashes + symcount;
1814 for (; sym_hashes < end_hashes; sym_hashes++)
1815 {
1816 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1817
1818 if ((sym_hash->root.type == bfd_link_hash_defined
1819 || sym_hash->root.type == bfd_link_hash_defweak)
1820 && sym_hash->root.u.def.section == sec
1821 && sym_hash->root.u.def.value >= addr
1822 && sym_hash->root.u.def.value < sec_end)
1823 sym_hash->root.u.def.value += 4;
1824 }
1825
1826 return contents;
1827 }
1828
1829 static bfd_boolean
1830 msp430_elf_relax_section (bfd * abfd, asection * sec,
1831 struct bfd_link_info * link_info,
1832 bfd_boolean * again)
1833 {
1834 Elf_Internal_Shdr * symtab_hdr;
1835 Elf_Internal_Rela * internal_relocs;
1836 Elf_Internal_Rela * irel;
1837 Elf_Internal_Rela * irelend;
1838 bfd_byte * contents = NULL;
1839 Elf_Internal_Sym * isymbuf = NULL;
1840
1841 /* Assume nothing changes. */
1842 *again = FALSE;
1843
1844 /* We don't have to do anything for a relocatable link, if
1845 this section does not have relocs, or if this is not a
1846 code section. */
1847 if (bfd_link_relocatable (link_info)
1848 || (sec->flags & SEC_RELOC) == 0
1849 || sec->reloc_count == 0 || (sec->flags & SEC_CODE) == 0)
1850 return TRUE;
1851
1852 symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
1853
1854 /* Get a copy of the native relocations. */
1855 internal_relocs =
1856 _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL, link_info->keep_memory);
1857 if (internal_relocs == NULL)
1858 goto error_return;
1859
1860 /* Walk through them looking for relaxing opportunities. */
1861 irelend = internal_relocs + sec->reloc_count;
1862
1863 /* Do code size growing relocs first. */
1864 for (irel = internal_relocs; irel < irelend; irel++)
1865 {
1866 bfd_vma symval;
1867
1868 /* If this isn't something that can be relaxed, then ignore
1869 this reloc. */
1870 if (uses_msp430x_relocs (abfd)
1871 && ELF32_R_TYPE (irel->r_info) == (int) R_MSP430X_10_PCREL)
1872 ;
1873 else if (! uses_msp430x_relocs (abfd)
1874 && ELF32_R_TYPE (irel->r_info) == (int) R_MSP430_10_PCREL)
1875 ;
1876 else
1877 continue;
1878
1879 /* Get the section contents if we haven't done so already. */
1880 if (contents == NULL)
1881 {
1882 /* Get cached copy if it exists. */
1883 if (elf_section_data (sec)->this_hdr.contents != NULL)
1884 contents = elf_section_data (sec)->this_hdr.contents;
1885 else if (! bfd_malloc_and_get_section (abfd, sec, &contents))
1886 goto error_return;
1887 }
1888
1889 /* Read this BFD's local symbols if we haven't done so already. */
1890 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
1891 {
1892 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1893 if (isymbuf == NULL)
1894 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
1895 symtab_hdr->sh_info, 0,
1896 NULL, NULL, NULL);
1897 if (isymbuf == NULL)
1898 goto error_return;
1899 }
1900
1901 /* Get the value of the symbol referred to by the reloc. */
1902 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1903 {
1904 /* A local symbol. */
1905 Elf_Internal_Sym *isym;
1906 asection *sym_sec;
1907
1908 isym = isymbuf + ELF32_R_SYM (irel->r_info);
1909 if (isym->st_shndx == SHN_UNDEF)
1910 sym_sec = bfd_und_section_ptr;
1911 else if (isym->st_shndx == SHN_ABS)
1912 sym_sec = bfd_abs_section_ptr;
1913 else if (isym->st_shndx == SHN_COMMON)
1914 sym_sec = bfd_com_section_ptr;
1915 else
1916 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
1917 symval = (isym->st_value
1918 + sym_sec->output_section->vma + sym_sec->output_offset);
1919 }
1920 else
1921 {
1922 unsigned long indx;
1923 struct elf_link_hash_entry *h;
1924
1925 /* An external symbol. */
1926 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
1927 h = elf_sym_hashes (abfd)[indx];
1928 BFD_ASSERT (h != NULL);
1929
1930 if (h->root.type != bfd_link_hash_defined
1931 && h->root.type != bfd_link_hash_defweak)
1932 /* This appears to be a reference to an undefined
1933 symbol. Just ignore it--it will be caught by the
1934 regular reloc processing. */
1935 continue;
1936
1937 symval = (h->root.u.def.value
1938 + h->root.u.def.section->output_section->vma
1939 + h->root.u.def.section->output_offset);
1940 }
1941
1942 /* For simplicity of coding, we are going to modify the section
1943 contents, the section relocs, and the BFD symbol table. We
1944 must tell the rest of the code not to free up this
1945 information. It would be possible to instead create a table
1946 of changes which have to be made, as is done in coff-mips.c;
1947 that would be more work, but would require less memory when
1948 the linker is run. */
1949
1950 bfd_signed_vma value = symval;
1951 int opcode;
1952
1953 /* Compute the value that will be relocated. */
1954 value += irel->r_addend;
1955 /* Convert to PC relative. */
1956 value -= (sec->output_section->vma + sec->output_offset);
1957 value -= irel->r_offset;
1958 value -= 2;
1959 /* Scale. */
1960 value >>= 1;
1961
1962 /* If it is in range then no modifications are needed. */
1963 if (value >= -512 && value <= 511)
1964 continue;
1965
1966 /* Get the opcode. */
1967 opcode = bfd_get_16 (abfd, contents + irel->r_offset);
1968
1969 /* Compute the new opcode. We are going to convert:
1970 J<cond> label
1971 into:
1972 J<inv-cond> 1f
1973 BR[A] #label
1974 1: */
1975 switch (opcode & 0xfc00)
1976 {
1977 case 0x3800: opcode = 0x3402; break; /* Jl -> Jge +2 */
1978 case 0x3400: opcode = 0x3802; break; /* Jge -> Jl +2 */
1979 case 0x2c00: opcode = 0x2802; break; /* Jhs -> Jlo +2 */
1980 case 0x2800: opcode = 0x2c02; break; /* Jlo -> Jhs +2 */
1981 case 0x2400: opcode = 0x2002; break; /* Jeq -> Jne +2 */
1982 case 0x2000: opcode = 0x2402; break; /* jne -> Jeq +2 */
1983 case 0x3000: /* jn */
1984 /* There is no direct inverse of the Jn insn.
1985 FIXME: we could do this as:
1986 Jn 1f
1987 br 2f
1988 1: br label
1989 2: */
1990 continue;
1991 default:
1992 /* Not a conditional branch instruction. */
1993 /* fprintf (stderr, "unrecog: %x\n", opcode); */
1994 continue;
1995 }
1996
1997 /* Note that we've changed the relocs, section contents, etc. */
1998 elf_section_data (sec)->relocs = internal_relocs;
1999 elf_section_data (sec)->this_hdr.contents = contents;
2000 symtab_hdr->contents = (unsigned char *) isymbuf;
2001
2002 /* Install the new opcode. */
2003 bfd_put_16 (abfd, opcode, contents + irel->r_offset);
2004
2005 /* Insert the new branch instruction. */
2006 if (uses_msp430x_relocs (abfd))
2007 {
2008 /* Insert an absolute branch (aka MOVA) instruction. */
2009 contents = msp430_elf_relax_add_two_words
2010 (abfd, sec, irel->r_offset + 2, 0x0080, 0x0000);
2011
2012 /* Update the relocation to point to the inserted branch
2013 instruction. Note - we are changing a PC-relative reloc
2014 into an absolute reloc, but this is OK because we have
2015 arranged with the assembler to have the reloc's value be
2016 a (local) symbol, not a section+offset value. */
2017 irel->r_offset += 2;
2018 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2019 R_MSP430X_ABS20_ADR_SRC);
2020 }
2021 else
2022 {
2023 contents = msp430_elf_relax_add_two_words
2024 (abfd, sec, irel->r_offset + 2, 0x4030, 0x0000);
2025
2026 /* See comment above about converting a 10-bit PC-rel
2027 relocation into a 16-bit absolute relocation. */
2028 irel->r_offset += 4;
2029 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2030 R_MSP430_16);
2031 }
2032
2033 /* Growing the section may mean that other
2034 conditional branches need to be fixed. */
2035 *again = TRUE;
2036 }
2037
2038 for (irel = internal_relocs; irel < irelend; irel++)
2039 {
2040 bfd_vma symval;
2041
2042 /* Get the section contents if we haven't done so already. */
2043 if (contents == NULL)
2044 {
2045 /* Get cached copy if it exists. */
2046 if (elf_section_data (sec)->this_hdr.contents != NULL)
2047 contents = elf_section_data (sec)->this_hdr.contents;
2048 else if (! bfd_malloc_and_get_section (abfd, sec, &contents))
2049 goto error_return;
2050 }
2051
2052 /* Read this BFD's local symbols if we haven't done so already. */
2053 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
2054 {
2055 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2056 if (isymbuf == NULL)
2057 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
2058 symtab_hdr->sh_info, 0,
2059 NULL, NULL, NULL);
2060 if (isymbuf == NULL)
2061 goto error_return;
2062 }
2063
2064 /* Get the value of the symbol referred to by the reloc. */
2065 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
2066 {
2067 /* A local symbol. */
2068 Elf_Internal_Sym *isym;
2069 asection *sym_sec;
2070
2071 isym = isymbuf + ELF32_R_SYM (irel->r_info);
2072 if (isym->st_shndx == SHN_UNDEF)
2073 sym_sec = bfd_und_section_ptr;
2074 else if (isym->st_shndx == SHN_ABS)
2075 sym_sec = bfd_abs_section_ptr;
2076 else if (isym->st_shndx == SHN_COMMON)
2077 sym_sec = bfd_com_section_ptr;
2078 else
2079 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
2080 symval = (isym->st_value
2081 + sym_sec->output_section->vma + sym_sec->output_offset);
2082 }
2083 else
2084 {
2085 unsigned long indx;
2086 struct elf_link_hash_entry *h;
2087
2088 /* An external symbol. */
2089 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
2090 h = elf_sym_hashes (abfd)[indx];
2091 BFD_ASSERT (h != NULL);
2092
2093 if (h->root.type != bfd_link_hash_defined
2094 && h->root.type != bfd_link_hash_defweak)
2095 /* This appears to be a reference to an undefined
2096 symbol. Just ignore it--it will be caught by the
2097 regular reloc processing. */
2098 continue;
2099
2100 symval = (h->root.u.def.value
2101 + h->root.u.def.section->output_section->vma
2102 + h->root.u.def.section->output_offset);
2103 }
2104
2105 /* For simplicity of coding, we are going to modify the section
2106 contents, the section relocs, and the BFD symbol table. We
2107 must tell the rest of the code not to free up this
2108 information. It would be possible to instead create a table
2109 of changes which have to be made, as is done in coff-mips.c;
2110 that would be more work, but would require less memory when
2111 the linker is run. */
2112
2113 /* Try to turn a 16bit pc-relative branch into a 10bit pc-relative
2114 branch. */
2115 /* Paranoia? paranoia... */
2116 if (! uses_msp430x_relocs (abfd)
2117 && ELF32_R_TYPE (irel->r_info) == (int) R_MSP430_RL_PCREL)
2118 {
2119 bfd_vma value = symval;
2120
2121 /* Deal with pc-relative gunk. */
2122 value -= (sec->output_section->vma + sec->output_offset);
2123 value -= irel->r_offset;
2124 value += irel->r_addend;
2125
2126 /* See if the value will fit in 10 bits, note the high value is
2127 1016 as the target will be two bytes closer if we are
2128 able to relax. */
2129 if ((long) value < 1016 && (long) value > -1016)
2130 {
2131 int code0 = 0, code1 = 0, code2 = 0;
2132 int i;
2133 struct rcodes_s *rx;
2134
2135 /* Get the opcode. */
2136 if (irel->r_offset >= 6)
2137 code0 = bfd_get_16 (abfd, contents + irel->r_offset - 6);
2138
2139 if (irel->r_offset >= 4)
2140 code1 = bfd_get_16 (abfd, contents + irel->r_offset - 4);
2141
2142 code2 = bfd_get_16 (abfd, contents + irel->r_offset - 2);
2143
2144 if (code2 != 0x4010)
2145 continue;
2146
2147 /* Check r4 and r3. */
2148 for (i = NUMB_RELAX_CODES - 1; i >= 0; i--)
2149 {
2150 rx = &rcode[i];
2151 if (rx->cdx == 2 && rx->f0 == code0 && rx->f1 == code1)
2152 break;
2153 else if (rx->cdx == 1 && rx->f1 == code1)
2154 break;
2155 else if (rx->cdx == 0) /* This is an unconditional jump. */
2156 break;
2157 }
2158
2159 /* Check labels:
2160 .Label0: ; we do not care about this label
2161 jeq +6
2162 .Label1: ; make sure there is no label here
2163 jl +4
2164 .Label2: ; make sure there is no label here
2165 br .Label_dst
2166
2167 So, if there is .Label1 or .Label2 we cannot relax this code.
2168 This actually should not happen, cause for relaxable
2169 instructions we use RL_PCREL reloc instead of 16_PCREL.
2170 Will change this in the future. */
2171
2172 if (rx->cdx > 0
2173 && msp430_elf_symbol_address_p (abfd, sec, isymbuf,
2174 irel->r_offset - 2))
2175 continue;
2176 if (rx->cdx > 1
2177 && msp430_elf_symbol_address_p (abfd, sec, isymbuf,
2178 irel->r_offset - 4))
2179 continue;
2180
2181 /* Note that we've changed the relocs, section contents, etc. */
2182 elf_section_data (sec)->relocs = internal_relocs;
2183 elf_section_data (sec)->this_hdr.contents = contents;
2184 symtab_hdr->contents = (unsigned char *) isymbuf;
2185
2186 /* Fix the relocation's type. */
2187 if (uses_msp430x_relocs (abfd))
2188 {
2189 if (rx->labels == 3) /* Handle special cases. */
2190 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2191 R_MSP430X_2X_PCREL);
2192 else
2193 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2194 R_MSP430X_10_PCREL);
2195 }
2196 else
2197 {
2198 if (rx->labels == 3) /* Handle special cases. */
2199 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2200 R_MSP430_2X_PCREL);
2201 else
2202 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2203 R_MSP430_10_PCREL);
2204 }
2205
2206 /* Fix the opcode right way. */
2207 bfd_put_16 (abfd, rx->t0, contents + irel->r_offset - rx->off);
2208 if (rx->t1)
2209 bfd_put_16 (abfd, rx->t1,
2210 contents + irel->r_offset - rx->off + 2);
2211
2212 /* Delete bytes. */
2213 if (!msp430_elf_relax_delete_bytes (abfd, sec,
2214 irel->r_offset - rx->off +
2215 rx->ncl, rx->bs))
2216 goto error_return;
2217
2218 /* Handle unconditional jumps. */
2219 if (rx->cdx == 0)
2220 irel->r_offset -= 2;
2221
2222 /* That will change things, so, we should relax again.
2223 Note that this is not required, and it may be slow. */
2224 *again = TRUE;
2225 }
2226 }
2227
2228 /* Try to turn a 16-bit absolute branch into a 10-bit pc-relative
2229 branch. */
2230 if (uses_msp430x_relocs (abfd)
2231 && ELF32_R_TYPE (irel->r_info) == R_MSP430X_ABS16)
2232 {
2233 bfd_vma value = symval;
2234
2235 value -= (sec->output_section->vma + sec->output_offset);
2236 value -= irel->r_offset;
2237 value += irel->r_addend;
2238
2239 /* See if the value will fit in 10 bits, note the high value is
2240 1016 as the target will be two bytes closer if we are
2241 able to relax. */
2242 if ((long) value < 1016 && (long) value > -1016)
2243 {
2244 int code2;
2245
2246 /* Get the opcode. */
2247 code2 = bfd_get_16 (abfd, contents + irel->r_offset - 2);
2248 if (code2 != 0x4030)
2249 continue;
2250 /* FIXME: check r4 and r3 ? */
2251 /* FIXME: Handle 0x4010 as well ? */
2252
2253 /* Note that we've changed the relocs, section contents, etc. */
2254 elf_section_data (sec)->relocs = internal_relocs;
2255 elf_section_data (sec)->this_hdr.contents = contents;
2256 symtab_hdr->contents = (unsigned char *) isymbuf;
2257
2258 /* Fix the relocation's type. */
2259 if (uses_msp430x_relocs (abfd))
2260 {
2261 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2262 R_MSP430X_10_PCREL);
2263 }
2264 else
2265 {
2266 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2267 R_MSP430_10_PCREL);
2268 }
2269
2270 /* Fix the opcode right way. */
2271 bfd_put_16 (abfd, 0x3c00, contents + irel->r_offset - 2);
2272 irel->r_offset -= 2;
2273
2274 /* Delete bytes. */
2275 if (!msp430_elf_relax_delete_bytes (abfd, sec,
2276 irel->r_offset + 2, 2))
2277 goto error_return;
2278
2279 /* That will change things, so, we should relax again.
2280 Note that this is not required, and it may be slow. */
2281 *again = TRUE;
2282 }
2283 }
2284 }
2285
2286 if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
2287 {
2288 if (!link_info->keep_memory)
2289 free (isymbuf);
2290 else
2291 {
2292 /* Cache the symbols for elf_link_input_bfd. */
2293 symtab_hdr->contents = (unsigned char *) isymbuf;
2294 }
2295 }
2296
2297 if (contents != NULL
2298 && elf_section_data (sec)->this_hdr.contents != contents)
2299 {
2300 if (!link_info->keep_memory)
2301 free (contents);
2302 else
2303 {
2304 /* Cache the section contents for elf_link_input_bfd. */
2305 elf_section_data (sec)->this_hdr.contents = contents;
2306 }
2307 }
2308
2309 if (internal_relocs != NULL
2310 && elf_section_data (sec)->relocs != internal_relocs)
2311 free (internal_relocs);
2312
2313 return TRUE;
2314
2315 error_return:
2316 if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
2317 free (isymbuf);
2318 if (contents != NULL
2319 && elf_section_data (sec)->this_hdr.contents != contents)
2320 free (contents);
2321 if (internal_relocs != NULL
2322 && elf_section_data (sec)->relocs != internal_relocs)
2323 free (internal_relocs);
2324
2325 return FALSE;
2326 }
2327
2328 /* Handle an MSP430 specific section when reading an object file.
2329 This is called when bfd_section_from_shdr finds a section with
2330 an unknown type. */
2331
2332 static bfd_boolean
2333 elf32_msp430_section_from_shdr (bfd *abfd,
2334 Elf_Internal_Shdr * hdr,
2335 const char *name,
2336 int shindex)
2337 {
2338 switch (hdr->sh_type)
2339 {
2340 case SHT_MSP430_SEC_FLAGS:
2341 case SHT_MSP430_SYM_ALIASES:
2342 case SHT_MSP430_ATTRIBUTES:
2343 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2344 default:
2345 return FALSE;
2346 }
2347 }
2348
2349 static bfd_boolean
2350 elf32_msp430_obj_attrs_handle_unknown (bfd *abfd, int tag)
2351 {
2352 _bfd_error_handler
2353 /* xgettext:c-format */
2354 (_("Warning: %B: Unknown MSPABI object attribute %d"),
2355 abfd, tag);
2356 return TRUE;
2357 }
2358
2359 /* Determine whether an object attribute tag takes an integer, a
2360 string or both. */
2361
2362 static int
2363 elf32_msp430_obj_attrs_arg_type (int tag)
2364 {
2365 if (tag == Tag_compatibility)
2366 return ATTR_TYPE_FLAG_INT_VAL | ATTR_TYPE_FLAG_STR_VAL;
2367
2368 if (tag < 32)
2369 return ATTR_TYPE_FLAG_INT_VAL;
2370
2371 return (tag & 1) != 0 ? ATTR_TYPE_FLAG_STR_VAL : ATTR_TYPE_FLAG_INT_VAL;
2372 }
2373
2374 static inline const char *
2375 isa_type (int isa)
2376 {
2377 switch (isa)
2378 {
2379 case 1: return "MSP430";
2380 case 2: return "MSP430X";
2381 default: return "unknown";
2382 }
2383 }
2384
2385 static inline const char *
2386 code_model (int model)
2387 {
2388 switch (model)
2389 {
2390 case 1: return "small";
2391 case 2: return "large";
2392 default: return "unknown";
2393 }
2394 }
2395
2396 static inline const char *
2397 data_model (int model)
2398 {
2399 switch (model)
2400 {
2401 case 1: return "small";
2402 case 2: return "large";
2403 case 3: return "restricted large";
2404 default: return "unknown";
2405 }
2406 }
2407
2408 /* Merge MSPABI object attributes from IBFD into OBFD.
2409 Raise an error if there are conflicting attributes. */
2410
2411 static bfd_boolean
2412 elf32_msp430_merge_mspabi_attributes (bfd *ibfd, struct bfd_link_info *info)
2413 {
2414 bfd *obfd = info->output_bfd;
2415 obj_attribute *in_attr;
2416 obj_attribute *out_attr;
2417 bfd_boolean result = TRUE;
2418 static bfd * first_input_bfd = NULL;
2419
2420 /* Skip linker created files. */
2421 if (ibfd->flags & BFD_LINKER_CREATED)
2422 return TRUE;
2423
2424 /* If this is the first real object just copy the attributes. */
2425 if (!elf_known_obj_attributes_proc (obfd)[0].i)
2426 {
2427 _bfd_elf_copy_obj_attributes (ibfd, obfd);
2428
2429 out_attr = elf_known_obj_attributes_proc (obfd);
2430
2431 /* Use the Tag_null value to indicate that
2432 the attributes have been initialized. */
2433 out_attr[0].i = 1;
2434
2435 first_input_bfd = ibfd;
2436 return TRUE;
2437 }
2438
2439 in_attr = elf_known_obj_attributes_proc (ibfd);
2440 out_attr = elf_known_obj_attributes_proc (obfd);
2441
2442 /* The ISAs must be the same. */
2443 if (in_attr[OFBA_MSPABI_Tag_ISA].i != out_attr[OFBA_MSPABI_Tag_ISA].i)
2444 {
2445 _bfd_error_handler
2446 /* xgettext:c-format */
2447 (_("error: %B uses %s instructions but %B uses %s"),
2448 ibfd, first_input_bfd,
2449 isa_type (in_attr[OFBA_MSPABI_Tag_ISA].i),
2450 isa_type (out_attr[OFBA_MSPABI_Tag_ISA].i));
2451 result = FALSE;
2452 }
2453
2454 /* The code models must be the same. */
2455 if (in_attr[OFBA_MSPABI_Tag_Code_Model].i !=
2456 out_attr[OFBA_MSPABI_Tag_Code_Model].i)
2457 {
2458 _bfd_error_handler
2459 /* xgettext:c-format */
2460 (_("error: %B uses the %s code model whereas %B uses the %s code model"),
2461 ibfd, first_input_bfd,
2462 code_model (in_attr[OFBA_MSPABI_Tag_Code_Model].i),
2463 code_model (out_attr[OFBA_MSPABI_Tag_Code_Model].i));
2464 result = FALSE;
2465 }
2466
2467 /* The large code model is only supported by the MSP430X. */
2468 if (in_attr[OFBA_MSPABI_Tag_Code_Model].i == 2
2469 && out_attr[OFBA_MSPABI_Tag_ISA].i != 2)
2470 {
2471 _bfd_error_handler
2472 /* xgettext:c-format */
2473 (_("error: %B uses the large code model but %B uses MSP430 instructions"),
2474 ibfd, first_input_bfd);
2475 result = FALSE;
2476 }
2477
2478 /* The data models must be the same. */
2479 if (in_attr[OFBA_MSPABI_Tag_Data_Model].i !=
2480 out_attr[OFBA_MSPABI_Tag_Data_Model].i)
2481 {
2482 _bfd_error_handler
2483 /* xgettext:c-format */
2484 (_("error: %B uses the %s data model whereas %B uses the %s data model"),
2485 ibfd, first_input_bfd,
2486 data_model (in_attr[OFBA_MSPABI_Tag_Data_Model].i),
2487 data_model (out_attr[OFBA_MSPABI_Tag_Data_Model].i));
2488 result = FALSE;
2489 }
2490
2491 /* The small code model requires the use of the small data model. */
2492 if (in_attr[OFBA_MSPABI_Tag_Code_Model].i == 1
2493 && out_attr[OFBA_MSPABI_Tag_Data_Model].i != 1)
2494 {
2495 _bfd_error_handler
2496 /* xgettext:c-format */
2497 (_("error: %B uses the small code model but %B uses the %s data model"),
2498 ibfd, first_input_bfd,
2499 data_model (out_attr[OFBA_MSPABI_Tag_Data_Model].i));
2500 result = FALSE;
2501 }
2502
2503 /* The large data models are only supported by the MSP430X. */
2504 if (in_attr[OFBA_MSPABI_Tag_Data_Model].i > 1
2505 && out_attr[OFBA_MSPABI_Tag_ISA].i != 2)
2506 {
2507 _bfd_error_handler
2508 /* xgettext:c-format */
2509 (_("error: %B uses the %s data model but %B only uses MSP430 instructions"),
2510 ibfd, first_input_bfd,
2511 data_model (in_attr[OFBA_MSPABI_Tag_Data_Model].i));
2512 result = FALSE;
2513 }
2514
2515 return result;
2516 }
2517
2518 /* Merge backend specific data from an object file to the output
2519 object file when linking. */
2520
2521 static bfd_boolean
2522 elf32_msp430_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
2523 {
2524 bfd *obfd = info->output_bfd;
2525 /* Make sure that the machine number reflects the most
2526 advanced version of the MSP architecture required. */
2527 #define max(a,b) ((a) > (b) ? (a) : (b))
2528 if (bfd_get_mach (ibfd) != bfd_get_mach (obfd))
2529 bfd_default_set_arch_mach (obfd, bfd_get_arch (obfd),
2530 max (bfd_get_mach (ibfd), bfd_get_mach (obfd)));
2531 #undef max
2532
2533 return elf32_msp430_merge_mspabi_attributes (ibfd, info);
2534 }
2535
2536 static bfd_boolean
2537 msp430_elf_is_target_special_symbol (bfd *abfd, asymbol *sym)
2538 {
2539 return _bfd_elf_is_local_label_name (abfd, sym->name);
2540 }
2541
2542 static bfd_boolean
2543 uses_large_model (bfd *abfd)
2544 {
2545 obj_attribute * attr;
2546
2547 if (abfd->flags & BFD_LINKER_CREATED)
2548 return FALSE;
2549
2550 attr = elf_known_obj_attributes_proc (abfd);
2551 if (attr == NULL)
2552 return FALSE;
2553
2554 return attr[OFBA_MSPABI_Tag_Code_Model].i == 2;
2555 }
2556
2557 static unsigned int
2558 elf32_msp430_eh_frame_address_size (bfd *abfd, asection *sec ATTRIBUTE_UNUSED)
2559 {
2560 return uses_large_model (abfd) ? 4 : 2;
2561 }
2562
2563 /* This is gross. The MSP430 EABI says that (sec 11.5):
2564
2565 "An implementation may choose to use Rel or Rela
2566 type relocations for other relocations."
2567
2568 But it also says that:
2569
2570 "Certain relocations are identified as Rela only. [snip]
2571 Where Rela is specified, an implementation must honor
2572 this requirement."
2573
2574 There is one relocation marked as requiring RELA - R_MSP430_ABS_HI16 - but
2575 to keep things simple we choose to use RELA relocations throughout. The
2576 problem is that the TI compiler generates REL relocations, so we have to
2577 be able to accept those as well. */
2578
2579 #define elf_backend_may_use_rel_p 1
2580 #define elf_backend_may_use_rela_p 1
2581 #define elf_backend_default_use_rela_p 1
2582
2583 #undef elf_backend_obj_attrs_vendor
2584 #define elf_backend_obj_attrs_vendor "mspabi"
2585 #undef elf_backend_obj_attrs_section
2586 #define elf_backend_obj_attrs_section ".MSP430.attributes"
2587 #undef elf_backend_obj_attrs_section_type
2588 #define elf_backend_obj_attrs_section_type SHT_MSP430_ATTRIBUTES
2589 #define elf_backend_section_from_shdr elf32_msp430_section_from_shdr
2590 #define elf_backend_obj_attrs_handle_unknown elf32_msp430_obj_attrs_handle_unknown
2591 #undef elf_backend_obj_attrs_arg_type
2592 #define elf_backend_obj_attrs_arg_type elf32_msp430_obj_attrs_arg_type
2593 #define bfd_elf32_bfd_merge_private_bfd_data elf32_msp430_merge_private_bfd_data
2594 #define elf_backend_eh_frame_address_size elf32_msp430_eh_frame_address_size
2595
2596 #define ELF_ARCH bfd_arch_msp430
2597 #define ELF_MACHINE_CODE EM_MSP430
2598 #define ELF_MACHINE_ALT1 EM_MSP430_OLD
2599 #define ELF_MAXPAGESIZE 4
2600 #define ELF_OSABI ELFOSABI_STANDALONE
2601
2602 #define TARGET_LITTLE_SYM msp430_elf32_vec
2603 #define TARGET_LITTLE_NAME "elf32-msp430"
2604
2605 #define elf_info_to_howto msp430_info_to_howto_rela
2606 #define elf_info_to_howto_rel NULL
2607 #define elf_backend_relocate_section elf32_msp430_relocate_section
2608 #define elf_backend_check_relocs elf32_msp430_check_relocs
2609 #define elf_backend_can_gc_sections 1
2610 #define elf_backend_final_write_processing bfd_elf_msp430_final_write_processing
2611 #define elf_backend_object_p elf32_msp430_object_p
2612 #define bfd_elf32_bfd_relax_section msp430_elf_relax_section
2613 #define bfd_elf32_bfd_is_target_special_symbol msp430_elf_is_target_special_symbol
2614
2615 #undef elf32_bed
2616 #define elf32_bed elf32_msp430_bed
2617
2618 #include "elf32-target.h"
2619
2620 /* The TI compiler sets the OSABI field to ELFOSABI_NONE. */
2621 #undef TARGET_LITTLE_SYM
2622 #define TARGET_LITTLE_SYM msp430_elf32_ti_vec
2623
2624 #undef elf32_bed
2625 #define elf32_bed elf32_msp430_ti_bed
2626
2627 #undef ELF_OSABI
2628 #define ELF_OSABI ELFOSABI_NONE
2629
2630 static const struct bfd_elf_special_section msp430_ti_elf_special_sections[] =
2631 {
2632 /* prefix, prefix_length, suffix_len, type, attributes. */
2633 { STRING_COMMA_LEN (".TI.symbol.alias"), 0, SHT_MSP430_SYM_ALIASES, 0 },
2634 { STRING_COMMA_LEN (".TI.section.flags"), 0, SHT_MSP430_SEC_FLAGS, 0 },
2635 { STRING_COMMA_LEN ("_TI_build_attrib"), 0, SHT_MSP430_ATTRIBUTES, 0 },
2636 { NULL, 0, 0, 0, 0 }
2637 };
2638
2639 #undef elf_backend_special_sections
2640 #define elf_backend_special_sections msp430_ti_elf_special_sections
2641
2642 #include "elf32-target.h"
A mirror of the official binutils-gdb repository