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