1 /* AVR-specific support for 32-bit ELF
2 Copyright (C) 1999-2015 Free Software Foundation, Inc.
3 Contributed by Denis Chertykov <denisc@overta.ru>
5 This file is part of BFD, the Binary File Descriptor library.
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.
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.
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,
20 Boston, MA 02110-1301, USA. */
27 #include "elf32-avr.h"
28 #include "bfd_stdint.h"
30 /* Enable debugging printout at stdout with this variable. */
31 static bfd_boolean debug_relax = FALSE;
33 /* Enable debugging printout at stdout with this variable. */
34 static bfd_boolean debug_stubs = FALSE;
36 static bfd_reloc_status_type
37 bfd_elf_avr_diff_reloc (bfd *, arelent *, asymbol *, void *,
38 asection *, bfd *, char **);
40 /* Hash table initialization and handling. Code is taken from the hppa port
41 and adapted to the needs of AVR. */
43 /* We use two hash tables to hold information for linking avr objects.
45 The first is the elf32_avr_link_hash_table which is derived from the
46 stanard ELF linker hash table. We use this as a place to attach the other
47 hash table and some static information.
49 The second is the stub hash table which is derived from the base BFD
50 hash table. The stub hash table holds the information on the linker
53 struct elf32_avr_stub_hash_entry
55 /* Base hash table entry structure. */
56 struct bfd_hash_entry bh_root;
58 /* Offset within stub_sec of the beginning of this stub. */
61 /* Given the symbol's value and its section we can determine its final
62 value when building the stubs (so the stub knows where to jump). */
65 /* This way we could mark stubs to be no longer necessary. */
66 bfd_boolean is_actually_needed;
69 struct elf32_avr_link_hash_table
71 /* The main hash table. */
72 struct elf_link_hash_table etab;
74 /* The stub hash table. */
75 struct bfd_hash_table bstab;
79 /* Linker stub bfd. */
82 /* The stub section. */
85 /* Usually 0, unless we are generating code for a bootloader. Will
86 be initialized by elf32_avr_size_stubs to the vma offset of the
87 output section associated with the stub section. */
90 /* Assorted information used by elf32_avr_size_stubs. */
91 unsigned int bfd_count;
93 asection ** input_list;
94 Elf_Internal_Sym ** all_local_syms;
96 /* Tables for mapping vma beyond the 128k boundary to the address of the
97 corresponding stub. (AMT)
98 "amt_max_entry_cnt" reflects the number of entries that memory is allocated
99 for in the "amt_stub_offsets" and "amt_destination_addr" arrays.
100 "amt_entry_cnt" informs how many of these entries actually contain
102 unsigned int amt_entry_cnt;
103 unsigned int amt_max_entry_cnt;
104 bfd_vma * amt_stub_offsets;
105 bfd_vma * amt_destination_addr;
108 /* Various hash macros and functions. */
109 #define avr_link_hash_table(p) \
110 /* PR 3874: Check that we have an AVR style hash table before using it. */\
111 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
112 == AVR_ELF_DATA ? ((struct elf32_avr_link_hash_table *) ((p)->hash)) : NULL)
114 #define avr_stub_hash_entry(ent) \
115 ((struct elf32_avr_stub_hash_entry *)(ent))
117 #define avr_stub_hash_lookup(table, string, create, copy) \
118 ((struct elf32_avr_stub_hash_entry *) \
119 bfd_hash_lookup ((table), (string), (create), (copy)))
121 static reloc_howto_type elf_avr_howto_table[] =
123 HOWTO (R_AVR_NONE, /* type */
125 3, /* size (0 = byte, 1 = short, 2 = long) */
127 FALSE, /* pc_relative */
129 complain_overflow_dont, /* complain_on_overflow */
130 bfd_elf_generic_reloc, /* special_function */
131 "R_AVR_NONE", /* name */
132 FALSE, /* partial_inplace */
135 FALSE), /* pcrel_offset */
137 HOWTO (R_AVR_32, /* type */
139 2, /* size (0 = byte, 1 = short, 2 = long) */
141 FALSE, /* pc_relative */
143 complain_overflow_bitfield, /* complain_on_overflow */
144 bfd_elf_generic_reloc, /* special_function */
145 "R_AVR_32", /* name */
146 FALSE, /* partial_inplace */
147 0xffffffff, /* src_mask */
148 0xffffffff, /* dst_mask */
149 FALSE), /* pcrel_offset */
151 /* A 7 bit PC relative relocation. */
152 HOWTO (R_AVR_7_PCREL, /* type */
154 1, /* size (0 = byte, 1 = short, 2 = long) */
156 TRUE, /* pc_relative */
158 complain_overflow_bitfield, /* complain_on_overflow */
159 bfd_elf_generic_reloc, /* special_function */
160 "R_AVR_7_PCREL", /* name */
161 FALSE, /* partial_inplace */
162 0xffff, /* src_mask */
163 0xffff, /* dst_mask */
164 TRUE), /* pcrel_offset */
166 /* A 13 bit PC relative relocation. */
167 HOWTO (R_AVR_13_PCREL, /* type */
169 1, /* size (0 = byte, 1 = short, 2 = long) */
171 TRUE, /* pc_relative */
173 complain_overflow_bitfield, /* complain_on_overflow */
174 bfd_elf_generic_reloc, /* special_function */
175 "R_AVR_13_PCREL", /* name */
176 FALSE, /* partial_inplace */
177 0xfff, /* src_mask */
178 0xfff, /* dst_mask */
179 TRUE), /* pcrel_offset */
181 /* A 16 bit absolute relocation. */
182 HOWTO (R_AVR_16, /* type */
184 1, /* size (0 = byte, 1 = short, 2 = long) */
186 FALSE, /* pc_relative */
188 complain_overflow_dont, /* complain_on_overflow */
189 bfd_elf_generic_reloc, /* special_function */
190 "R_AVR_16", /* name */
191 FALSE, /* partial_inplace */
192 0xffff, /* src_mask */
193 0xffff, /* dst_mask */
194 FALSE), /* pcrel_offset */
196 /* A 16 bit absolute relocation for command address
197 Will be changed when linker stubs are needed. */
198 HOWTO (R_AVR_16_PM, /* type */
200 1, /* size (0 = byte, 1 = short, 2 = long) */
202 FALSE, /* pc_relative */
204 complain_overflow_bitfield, /* complain_on_overflow */
205 bfd_elf_generic_reloc, /* special_function */
206 "R_AVR_16_PM", /* name */
207 FALSE, /* partial_inplace */
208 0xffff, /* src_mask */
209 0xffff, /* dst_mask */
210 FALSE), /* pcrel_offset */
211 /* A low 8 bit absolute relocation of 16 bit address.
213 HOWTO (R_AVR_LO8_LDI, /* type */
215 1, /* size (0 = byte, 1 = short, 2 = long) */
217 FALSE, /* pc_relative */
219 complain_overflow_dont, /* complain_on_overflow */
220 bfd_elf_generic_reloc, /* special_function */
221 "R_AVR_LO8_LDI", /* name */
222 FALSE, /* partial_inplace */
223 0xffff, /* src_mask */
224 0xffff, /* dst_mask */
225 FALSE), /* pcrel_offset */
226 /* A high 8 bit absolute relocation of 16 bit address.
228 HOWTO (R_AVR_HI8_LDI, /* type */
230 1, /* size (0 = byte, 1 = short, 2 = long) */
232 FALSE, /* pc_relative */
234 complain_overflow_dont, /* complain_on_overflow */
235 bfd_elf_generic_reloc, /* special_function */
236 "R_AVR_HI8_LDI", /* name */
237 FALSE, /* partial_inplace */
238 0xffff, /* src_mask */
239 0xffff, /* dst_mask */
240 FALSE), /* pcrel_offset */
241 /* A high 6 bit absolute relocation of 22 bit address.
242 For LDI command. As well second most significant 8 bit value of
243 a 32 bit link-time constant. */
244 HOWTO (R_AVR_HH8_LDI, /* type */
246 1, /* size (0 = byte, 1 = short, 2 = long) */
248 FALSE, /* pc_relative */
250 complain_overflow_dont, /* complain_on_overflow */
251 bfd_elf_generic_reloc, /* special_function */
252 "R_AVR_HH8_LDI", /* name */
253 FALSE, /* partial_inplace */
254 0xffff, /* src_mask */
255 0xffff, /* dst_mask */
256 FALSE), /* pcrel_offset */
257 /* A negative low 8 bit absolute relocation of 16 bit address.
259 HOWTO (R_AVR_LO8_LDI_NEG, /* type */
261 1, /* size (0 = byte, 1 = short, 2 = long) */
263 FALSE, /* pc_relative */
265 complain_overflow_dont, /* complain_on_overflow */
266 bfd_elf_generic_reloc, /* special_function */
267 "R_AVR_LO8_LDI_NEG", /* name */
268 FALSE, /* partial_inplace */
269 0xffff, /* src_mask */
270 0xffff, /* dst_mask */
271 FALSE), /* pcrel_offset */
272 /* A negative high 8 bit absolute relocation of 16 bit address.
274 HOWTO (R_AVR_HI8_LDI_NEG, /* type */
276 1, /* size (0 = byte, 1 = short, 2 = long) */
278 FALSE, /* pc_relative */
280 complain_overflow_dont, /* complain_on_overflow */
281 bfd_elf_generic_reloc, /* special_function */
282 "R_AVR_HI8_LDI_NEG", /* name */
283 FALSE, /* partial_inplace */
284 0xffff, /* src_mask */
285 0xffff, /* dst_mask */
286 FALSE), /* pcrel_offset */
287 /* A negative high 6 bit absolute relocation of 22 bit address.
289 HOWTO (R_AVR_HH8_LDI_NEG, /* type */
291 1, /* size (0 = byte, 1 = short, 2 = long) */
293 FALSE, /* pc_relative */
295 complain_overflow_dont, /* complain_on_overflow */
296 bfd_elf_generic_reloc, /* special_function */
297 "R_AVR_HH8_LDI_NEG", /* name */
298 FALSE, /* partial_inplace */
299 0xffff, /* src_mask */
300 0xffff, /* dst_mask */
301 FALSE), /* pcrel_offset */
302 /* A low 8 bit absolute relocation of 24 bit program memory address.
303 For LDI command. Will not be changed when linker stubs are needed. */
304 HOWTO (R_AVR_LO8_LDI_PM, /* type */
306 1, /* size (0 = byte, 1 = short, 2 = long) */
308 FALSE, /* pc_relative */
310 complain_overflow_dont, /* complain_on_overflow */
311 bfd_elf_generic_reloc, /* special_function */
312 "R_AVR_LO8_LDI_PM", /* name */
313 FALSE, /* partial_inplace */
314 0xffff, /* src_mask */
315 0xffff, /* dst_mask */
316 FALSE), /* pcrel_offset */
317 /* A low 8 bit absolute relocation of 24 bit program memory address.
318 For LDI command. Will not be changed when linker stubs are needed. */
319 HOWTO (R_AVR_HI8_LDI_PM, /* type */
321 1, /* size (0 = byte, 1 = short, 2 = long) */
323 FALSE, /* pc_relative */
325 complain_overflow_dont, /* complain_on_overflow */
326 bfd_elf_generic_reloc, /* special_function */
327 "R_AVR_HI8_LDI_PM", /* name */
328 FALSE, /* partial_inplace */
329 0xffff, /* src_mask */
330 0xffff, /* dst_mask */
331 FALSE), /* pcrel_offset */
332 /* A low 8 bit absolute relocation of 24 bit program memory address.
333 For LDI command. Will not be changed when linker stubs are needed. */
334 HOWTO (R_AVR_HH8_LDI_PM, /* type */
336 1, /* size (0 = byte, 1 = short, 2 = long) */
338 FALSE, /* pc_relative */
340 complain_overflow_dont, /* complain_on_overflow */
341 bfd_elf_generic_reloc, /* special_function */
342 "R_AVR_HH8_LDI_PM", /* name */
343 FALSE, /* partial_inplace */
344 0xffff, /* src_mask */
345 0xffff, /* dst_mask */
346 FALSE), /* pcrel_offset */
347 /* A low 8 bit absolute relocation of 24 bit program memory address.
348 For LDI command. Will not be changed when linker stubs are needed. */
349 HOWTO (R_AVR_LO8_LDI_PM_NEG, /* type */
351 1, /* size (0 = byte, 1 = short, 2 = long) */
353 FALSE, /* pc_relative */
355 complain_overflow_dont, /* complain_on_overflow */
356 bfd_elf_generic_reloc, /* special_function */
357 "R_AVR_LO8_LDI_PM_NEG", /* name */
358 FALSE, /* partial_inplace */
359 0xffff, /* src_mask */
360 0xffff, /* dst_mask */
361 FALSE), /* pcrel_offset */
362 /* A low 8 bit absolute relocation of 24 bit program memory address.
363 For LDI command. Will not be changed when linker stubs are needed. */
364 HOWTO (R_AVR_HI8_LDI_PM_NEG, /* type */
366 1, /* size (0 = byte, 1 = short, 2 = long) */
368 FALSE, /* pc_relative */
370 complain_overflow_dont, /* complain_on_overflow */
371 bfd_elf_generic_reloc, /* special_function */
372 "R_AVR_HI8_LDI_PM_NEG", /* name */
373 FALSE, /* partial_inplace */
374 0xffff, /* src_mask */
375 0xffff, /* dst_mask */
376 FALSE), /* pcrel_offset */
377 /* A low 8 bit absolute relocation of 24 bit program memory address.
378 For LDI command. Will not be changed when linker stubs are needed. */
379 HOWTO (R_AVR_HH8_LDI_PM_NEG, /* type */
381 1, /* size (0 = byte, 1 = short, 2 = long) */
383 FALSE, /* pc_relative */
385 complain_overflow_dont, /* complain_on_overflow */
386 bfd_elf_generic_reloc, /* special_function */
387 "R_AVR_HH8_LDI_PM_NEG", /* name */
388 FALSE, /* partial_inplace */
389 0xffff, /* src_mask */
390 0xffff, /* dst_mask */
391 FALSE), /* pcrel_offset */
392 /* Relocation for CALL command in ATmega. */
393 HOWTO (R_AVR_CALL, /* type */
395 2, /* size (0 = byte, 1 = short, 2 = long) */
397 FALSE, /* pc_relative */
399 complain_overflow_dont,/* complain_on_overflow */
400 bfd_elf_generic_reloc, /* special_function */
401 "R_AVR_CALL", /* name */
402 FALSE, /* partial_inplace */
403 0xffffffff, /* src_mask */
404 0xffffffff, /* dst_mask */
405 FALSE), /* pcrel_offset */
406 /* A 16 bit absolute relocation of 16 bit address.
408 HOWTO (R_AVR_LDI, /* type */
410 1, /* size (0 = byte, 1 = short, 2 = long) */
412 FALSE, /* pc_relative */
414 complain_overflow_dont,/* complain_on_overflow */
415 bfd_elf_generic_reloc, /* special_function */
416 "R_AVR_LDI", /* name */
417 FALSE, /* partial_inplace */
418 0xffff, /* src_mask */
419 0xffff, /* dst_mask */
420 FALSE), /* pcrel_offset */
421 /* A 6 bit absolute relocation of 6 bit offset.
422 For ldd/sdd command. */
423 HOWTO (R_AVR_6, /* type */
425 0, /* size (0 = byte, 1 = short, 2 = long) */
427 FALSE, /* pc_relative */
429 complain_overflow_dont,/* complain_on_overflow */
430 bfd_elf_generic_reloc, /* special_function */
431 "R_AVR_6", /* name */
432 FALSE, /* partial_inplace */
433 0xffff, /* src_mask */
434 0xffff, /* dst_mask */
435 FALSE), /* pcrel_offset */
436 /* A 6 bit absolute relocation of 6 bit offset.
437 For sbiw/adiw command. */
438 HOWTO (R_AVR_6_ADIW, /* type */
440 0, /* size (0 = byte, 1 = short, 2 = long) */
442 FALSE, /* pc_relative */
444 complain_overflow_dont,/* complain_on_overflow */
445 bfd_elf_generic_reloc, /* special_function */
446 "R_AVR_6_ADIW", /* name */
447 FALSE, /* partial_inplace */
448 0xffff, /* src_mask */
449 0xffff, /* dst_mask */
450 FALSE), /* pcrel_offset */
451 /* Most significant 8 bit value of a 32 bit link-time constant. */
452 HOWTO (R_AVR_MS8_LDI, /* type */
454 1, /* size (0 = byte, 1 = short, 2 = long) */
456 FALSE, /* pc_relative */
458 complain_overflow_dont, /* complain_on_overflow */
459 bfd_elf_generic_reloc, /* special_function */
460 "R_AVR_MS8_LDI", /* name */
461 FALSE, /* partial_inplace */
462 0xffff, /* src_mask */
463 0xffff, /* dst_mask */
464 FALSE), /* pcrel_offset */
465 /* Negative most significant 8 bit value of a 32 bit link-time constant. */
466 HOWTO (R_AVR_MS8_LDI_NEG, /* type */
468 1, /* size (0 = byte, 1 = short, 2 = long) */
470 FALSE, /* pc_relative */
472 complain_overflow_dont, /* complain_on_overflow */
473 bfd_elf_generic_reloc, /* special_function */
474 "R_AVR_MS8_LDI_NEG", /* name */
475 FALSE, /* partial_inplace */
476 0xffff, /* src_mask */
477 0xffff, /* dst_mask */
478 FALSE), /* pcrel_offset */
479 /* A low 8 bit absolute relocation of 24 bit program memory address.
480 For LDI command. Will be changed when linker stubs are needed. */
481 HOWTO (R_AVR_LO8_LDI_GS, /* type */
483 1, /* size (0 = byte, 1 = short, 2 = long) */
485 FALSE, /* pc_relative */
487 complain_overflow_dont, /* complain_on_overflow */
488 bfd_elf_generic_reloc, /* special_function */
489 "R_AVR_LO8_LDI_GS", /* name */
490 FALSE, /* partial_inplace */
491 0xffff, /* src_mask */
492 0xffff, /* dst_mask */
493 FALSE), /* pcrel_offset */
494 /* A low 8 bit absolute relocation of 24 bit program memory address.
495 For LDI command. Will be changed when linker stubs are needed. */
496 HOWTO (R_AVR_HI8_LDI_GS, /* type */
498 1, /* size (0 = byte, 1 = short, 2 = long) */
500 FALSE, /* pc_relative */
502 complain_overflow_dont, /* complain_on_overflow */
503 bfd_elf_generic_reloc, /* special_function */
504 "R_AVR_HI8_LDI_GS", /* name */
505 FALSE, /* partial_inplace */
506 0xffff, /* src_mask */
507 0xffff, /* dst_mask */
508 FALSE), /* pcrel_offset */
510 HOWTO (R_AVR_8, /* type */
512 0, /* size (0 = byte, 1 = short, 2 = long) */
514 FALSE, /* pc_relative */
516 complain_overflow_bitfield,/* complain_on_overflow */
517 bfd_elf_generic_reloc, /* special_function */
518 "R_AVR_8", /* name */
519 FALSE, /* partial_inplace */
520 0x000000ff, /* src_mask */
521 0x000000ff, /* dst_mask */
522 FALSE), /* pcrel_offset */
523 /* lo8-part to use in .byte lo8(sym). */
524 HOWTO (R_AVR_8_LO8, /* type */
526 0, /* size (0 = byte, 1 = short, 2 = long) */
528 FALSE, /* pc_relative */
530 complain_overflow_dont,/* complain_on_overflow */
531 bfd_elf_generic_reloc, /* special_function */
532 "R_AVR_8_LO8", /* name */
533 FALSE, /* partial_inplace */
534 0xffffff, /* src_mask */
535 0xffffff, /* dst_mask */
536 FALSE), /* pcrel_offset */
537 /* hi8-part to use in .byte hi8(sym). */
538 HOWTO (R_AVR_8_HI8, /* type */
540 0, /* size (0 = byte, 1 = short, 2 = long) */
542 FALSE, /* pc_relative */
544 complain_overflow_dont,/* complain_on_overflow */
545 bfd_elf_generic_reloc, /* special_function */
546 "R_AVR_8_HI8", /* name */
547 FALSE, /* partial_inplace */
548 0xffffff, /* src_mask */
549 0xffffff, /* dst_mask */
550 FALSE), /* pcrel_offset */
551 /* hlo8-part to use in .byte hlo8(sym). */
552 HOWTO (R_AVR_8_HLO8, /* type */
554 0, /* size (0 = byte, 1 = short, 2 = long) */
556 FALSE, /* pc_relative */
558 complain_overflow_dont,/* complain_on_overflow */
559 bfd_elf_generic_reloc, /* special_function */
560 "R_AVR_8_HLO8", /* name */
561 FALSE, /* partial_inplace */
562 0xffffff, /* src_mask */
563 0xffffff, /* dst_mask */
564 FALSE), /* pcrel_offset */
565 HOWTO (R_AVR_DIFF8, /* type */
567 0, /* size (0 = byte, 1 = short, 2 = long) */
569 FALSE, /* pc_relative */
571 complain_overflow_bitfield, /* complain_on_overflow */
572 bfd_elf_avr_diff_reloc, /* special_function */
573 "R_AVR_DIFF8", /* name */
574 FALSE, /* partial_inplace */
577 FALSE), /* pcrel_offset */
578 HOWTO (R_AVR_DIFF16, /* type */
580 1, /* size (0 = byte, 1 = short, 2 = long) */
582 FALSE, /* pc_relative */
584 complain_overflow_bitfield, /* complain_on_overflow */
585 bfd_elf_avr_diff_reloc,/* special_function */
586 "R_AVR_DIFF16", /* name */
587 FALSE, /* partial_inplace */
589 0xffff, /* dst_mask */
590 FALSE), /* pcrel_offset */
591 HOWTO (R_AVR_DIFF32, /* type */
593 2, /* size (0 = byte, 1 = short, 2 = long) */
595 FALSE, /* pc_relative */
597 complain_overflow_bitfield, /* complain_on_overflow */
598 bfd_elf_avr_diff_reloc,/* special_function */
599 "R_AVR_DIFF32", /* name */
600 FALSE, /* partial_inplace */
602 0xffffffff, /* dst_mask */
603 FALSE), /* pcrel_offset */
604 /* 7 bit immediate for LDS/STS in Tiny core. */
605 HOWTO (R_AVR_LDS_STS_16, /* type */
607 1, /* size (0 = byte, 1 = short, 2 = long) */
609 FALSE, /* pc_relative */
611 complain_overflow_dont,/* complain_on_overflow */
612 bfd_elf_generic_reloc, /* special_function */
613 "R_AVR_LDS_STS_16", /* name */
614 FALSE, /* partial_inplace */
615 0xffff, /* src_mask */
616 0xffff, /* dst_mask */
617 FALSE), /* pcrel_offset */
619 HOWTO (R_AVR_PORT6, /* type */
621 0, /* size (0 = byte, 1 = short, 2 = long) */
623 FALSE, /* pc_relative */
625 complain_overflow_dont,/* complain_on_overflow */
626 bfd_elf_generic_reloc, /* special_function */
627 "R_AVR_PORT6", /* name */
628 FALSE, /* partial_inplace */
629 0xffffff, /* src_mask */
630 0xffffff, /* dst_mask */
631 FALSE), /* pcrel_offset */
632 HOWTO (R_AVR_PORT5, /* type */
634 0, /* size (0 = byte, 1 = short, 2 = long) */
636 FALSE, /* pc_relative */
638 complain_overflow_dont,/* complain_on_overflow */
639 bfd_elf_generic_reloc, /* special_function */
640 "R_AVR_PORT5", /* name */
641 FALSE, /* partial_inplace */
642 0xffffff, /* src_mask */
643 0xffffff, /* dst_mask */
644 FALSE) /* pcrel_offset */
647 /* Map BFD reloc types to AVR ELF reloc types. */
651 bfd_reloc_code_real_type bfd_reloc_val;
652 unsigned int elf_reloc_val;
655 static const struct avr_reloc_map avr_reloc_map[] =
657 { BFD_RELOC_NONE, R_AVR_NONE },
658 { BFD_RELOC_32, R_AVR_32 },
659 { BFD_RELOC_AVR_7_PCREL, R_AVR_7_PCREL },
660 { BFD_RELOC_AVR_13_PCREL, R_AVR_13_PCREL },
661 { BFD_RELOC_16, R_AVR_16 },
662 { BFD_RELOC_AVR_16_PM, R_AVR_16_PM },
663 { BFD_RELOC_AVR_LO8_LDI, R_AVR_LO8_LDI},
664 { BFD_RELOC_AVR_HI8_LDI, R_AVR_HI8_LDI },
665 { BFD_RELOC_AVR_HH8_LDI, R_AVR_HH8_LDI },
666 { BFD_RELOC_AVR_MS8_LDI, R_AVR_MS8_LDI },
667 { BFD_RELOC_AVR_LO8_LDI_NEG, R_AVR_LO8_LDI_NEG },
668 { BFD_RELOC_AVR_HI8_LDI_NEG, R_AVR_HI8_LDI_NEG },
669 { BFD_RELOC_AVR_HH8_LDI_NEG, R_AVR_HH8_LDI_NEG },
670 { BFD_RELOC_AVR_MS8_LDI_NEG, R_AVR_MS8_LDI_NEG },
671 { BFD_RELOC_AVR_LO8_LDI_PM, R_AVR_LO8_LDI_PM },
672 { BFD_RELOC_AVR_LO8_LDI_GS, R_AVR_LO8_LDI_GS },
673 { BFD_RELOC_AVR_HI8_LDI_PM, R_AVR_HI8_LDI_PM },
674 { BFD_RELOC_AVR_HI8_LDI_GS, R_AVR_HI8_LDI_GS },
675 { BFD_RELOC_AVR_HH8_LDI_PM, R_AVR_HH8_LDI_PM },
676 { BFD_RELOC_AVR_LO8_LDI_PM_NEG, R_AVR_LO8_LDI_PM_NEG },
677 { BFD_RELOC_AVR_HI8_LDI_PM_NEG, R_AVR_HI8_LDI_PM_NEG },
678 { BFD_RELOC_AVR_HH8_LDI_PM_NEG, R_AVR_HH8_LDI_PM_NEG },
679 { BFD_RELOC_AVR_CALL, R_AVR_CALL },
680 { BFD_RELOC_AVR_LDI, R_AVR_LDI },
681 { BFD_RELOC_AVR_6, R_AVR_6 },
682 { BFD_RELOC_AVR_6_ADIW, R_AVR_6_ADIW },
683 { BFD_RELOC_8, R_AVR_8 },
684 { BFD_RELOC_AVR_8_LO, R_AVR_8_LO8 },
685 { BFD_RELOC_AVR_8_HI, R_AVR_8_HI8 },
686 { BFD_RELOC_AVR_8_HLO, R_AVR_8_HLO8 },
687 { BFD_RELOC_AVR_DIFF8, R_AVR_DIFF8 },
688 { BFD_RELOC_AVR_DIFF16, R_AVR_DIFF16 },
689 { BFD_RELOC_AVR_DIFF32, R_AVR_DIFF32 },
690 { BFD_RELOC_AVR_LDS_STS_16, R_AVR_LDS_STS_16},
691 { BFD_RELOC_AVR_PORT6, R_AVR_PORT6},
692 { BFD_RELOC_AVR_PORT5, R_AVR_PORT5}
695 /* Meant to be filled one day with the wrap around address for the
696 specific device. I.e. should get the value 0x4000 for 16k devices,
697 0x8000 for 32k devices and so on.
699 We initialize it here with a value of 0x1000000 resulting in
700 that we will never suggest a wrap-around jump during relaxation.
701 The logic of the source code later on assumes that in
702 avr_pc_wrap_around one single bit is set. */
703 static bfd_vma avr_pc_wrap_around = 0x10000000;
705 /* If this variable holds a value different from zero, the linker relaxation
706 machine will try to optimize call/ret sequences by a single jump
707 instruction. This option could be switched off by a linker switch. */
708 static int avr_replace_call_ret_sequences = 1;
710 /* Initialize an entry in the stub hash table. */
712 static struct bfd_hash_entry *
713 stub_hash_newfunc (struct bfd_hash_entry *entry,
714 struct bfd_hash_table *table,
717 /* Allocate the structure if it has not already been allocated by a
721 entry = bfd_hash_allocate (table,
722 sizeof (struct elf32_avr_stub_hash_entry));
727 /* Call the allocation method of the superclass. */
728 entry = bfd_hash_newfunc (entry, table, string);
731 struct elf32_avr_stub_hash_entry *hsh;
733 /* Initialize the local fields. */
734 hsh = avr_stub_hash_entry (entry);
735 hsh->stub_offset = 0;
736 hsh->target_value = 0;
742 /* This function is just a straight passthrough to the real
743 function in linker.c. Its prupose is so that its address
744 can be compared inside the avr_link_hash_table macro. */
746 static struct bfd_hash_entry *
747 elf32_avr_link_hash_newfunc (struct bfd_hash_entry * entry,
748 struct bfd_hash_table * table,
751 return _bfd_elf_link_hash_newfunc (entry, table, string);
754 /* Free the derived linker hash table. */
757 elf32_avr_link_hash_table_free (bfd *obfd)
759 struct elf32_avr_link_hash_table *htab
760 = (struct elf32_avr_link_hash_table *) obfd->link.hash;
762 /* Free the address mapping table. */
763 if (htab->amt_stub_offsets != NULL)
764 free (htab->amt_stub_offsets);
765 if (htab->amt_destination_addr != NULL)
766 free (htab->amt_destination_addr);
768 bfd_hash_table_free (&htab->bstab);
769 _bfd_elf_link_hash_table_free (obfd);
772 /* Create the derived linker hash table. The AVR ELF port uses the derived
773 hash table to keep information specific to the AVR ELF linker (without
774 using static variables). */
776 static struct bfd_link_hash_table *
777 elf32_avr_link_hash_table_create (bfd *abfd)
779 struct elf32_avr_link_hash_table *htab;
780 bfd_size_type amt = sizeof (*htab);
782 htab = bfd_zmalloc (amt);
786 if (!_bfd_elf_link_hash_table_init (&htab->etab, abfd,
787 elf32_avr_link_hash_newfunc,
788 sizeof (struct elf_link_hash_entry),
795 /* Init the stub hash table too. */
796 if (!bfd_hash_table_init (&htab->bstab, stub_hash_newfunc,
797 sizeof (struct elf32_avr_stub_hash_entry)))
799 _bfd_elf_link_hash_table_free (abfd);
802 htab->etab.root.hash_table_free = elf32_avr_link_hash_table_free;
804 return &htab->etab.root;
807 /* Calculates the effective distance of a pc relative jump/call. */
810 avr_relative_distance_considering_wrap_around (unsigned int distance)
812 unsigned int wrap_around_mask = avr_pc_wrap_around - 1;
813 int dist_with_wrap_around = distance & wrap_around_mask;
815 if (dist_with_wrap_around > ((int) (avr_pc_wrap_around >> 1)))
816 dist_with_wrap_around -= avr_pc_wrap_around;
818 return dist_with_wrap_around;
822 static reloc_howto_type *
823 bfd_elf32_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
824 bfd_reloc_code_real_type code)
829 i < sizeof (avr_reloc_map) / sizeof (struct avr_reloc_map);
831 if (avr_reloc_map[i].bfd_reloc_val == code)
832 return &elf_avr_howto_table[avr_reloc_map[i].elf_reloc_val];
837 static reloc_howto_type *
838 bfd_elf32_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
844 i < sizeof (elf_avr_howto_table) / sizeof (elf_avr_howto_table[0]);
846 if (elf_avr_howto_table[i].name != NULL
847 && strcasecmp (elf_avr_howto_table[i].name, r_name) == 0)
848 return &elf_avr_howto_table[i];
853 /* Set the howto pointer for an AVR ELF reloc. */
856 avr_info_to_howto_rela (bfd *abfd ATTRIBUTE_UNUSED,
858 Elf_Internal_Rela *dst)
862 r_type = ELF32_R_TYPE (dst->r_info);
863 if (r_type >= (unsigned int) R_AVR_max)
865 _bfd_error_handler (_("%B: invalid AVR reloc number: %d"), abfd, r_type);
868 cache_ptr->howto = &elf_avr_howto_table[r_type];
872 avr_stub_is_required_for_16_bit_reloc (bfd_vma relocation)
874 return (relocation >= 0x020000);
877 /* Returns the address of the corresponding stub if there is one.
878 Returns otherwise an address above 0x020000. This function
879 could also be used, if there is no knowledge on the section where
880 the destination is found. */
883 avr_get_stub_addr (bfd_vma srel,
884 struct elf32_avr_link_hash_table *htab)
887 bfd_vma stub_sec_addr =
888 (htab->stub_sec->output_section->vma +
889 htab->stub_sec->output_offset);
891 for (sindex = 0; sindex < htab->amt_max_entry_cnt; sindex ++)
892 if (htab->amt_destination_addr[sindex] == srel)
893 return htab->amt_stub_offsets[sindex] + stub_sec_addr;
895 /* Return an address that could not be reached by 16 bit relocs. */
899 /* Perform a diff relocation. Nothing to do, as the difference value is already
900 written into the section's contents. */
902 static bfd_reloc_status_type
903 bfd_elf_avr_diff_reloc (bfd *abfd ATTRIBUTE_UNUSED,
904 arelent *reloc_entry ATTRIBUTE_UNUSED,
905 asymbol *symbol ATTRIBUTE_UNUSED,
906 void *data ATTRIBUTE_UNUSED,
907 asection *input_section ATTRIBUTE_UNUSED,
908 bfd *output_bfd ATTRIBUTE_UNUSED,
909 char **error_message ATTRIBUTE_UNUSED)
915 /* Perform a single relocation. By default we use the standard BFD
916 routines, but a few relocs, we have to do them ourselves. */
918 static bfd_reloc_status_type
919 avr_final_link_relocate (reloc_howto_type * howto,
921 asection * input_section,
923 Elf_Internal_Rela * rel,
925 struct elf32_avr_link_hash_table * htab)
927 bfd_reloc_status_type r = bfd_reloc_ok;
930 bfd_signed_vma reloc_addr;
931 bfd_boolean use_stubs = FALSE;
932 /* Usually is 0, unless we are generating code for a bootloader. */
933 bfd_signed_vma base_addr = htab->vector_base;
935 /* Absolute addr of the reloc in the final excecutable. */
936 reloc_addr = rel->r_offset + input_section->output_section->vma
937 + input_section->output_offset;
942 contents += rel->r_offset;
943 srel = (bfd_signed_vma) relocation;
944 srel += rel->r_addend;
945 srel -= rel->r_offset;
946 srel -= 2; /* Branch instructions add 2 to the PC... */
947 srel -= (input_section->output_section->vma +
948 input_section->output_offset);
951 return bfd_reloc_outofrange;
952 if (srel > ((1 << 7) - 1) || (srel < - (1 << 7)))
953 return bfd_reloc_overflow;
954 x = bfd_get_16 (input_bfd, contents);
955 x = (x & 0xfc07) | (((srel >> 1) << 3) & 0x3f8);
956 bfd_put_16 (input_bfd, x, contents);
960 contents += rel->r_offset;
961 srel = (bfd_signed_vma) relocation;
962 srel += rel->r_addend;
963 srel -= rel->r_offset;
964 srel -= 2; /* Branch instructions add 2 to the PC... */
965 srel -= (input_section->output_section->vma +
966 input_section->output_offset);
969 return bfd_reloc_outofrange;
971 srel = avr_relative_distance_considering_wrap_around (srel);
973 /* AVR addresses commands as words. */
976 /* Check for overflow. */
977 if (srel < -2048 || srel > 2047)
979 /* Relative distance is too large. */
981 /* Always apply WRAPAROUND for avr2, avr25, and avr4. */
982 switch (bfd_get_mach (input_bfd))
990 return bfd_reloc_overflow;
994 x = bfd_get_16 (input_bfd, contents);
995 x = (x & 0xf000) | (srel & 0xfff);
996 bfd_put_16 (input_bfd, x, contents);
1000 contents += rel->r_offset;
1001 srel = (bfd_signed_vma) relocation + rel->r_addend;
1002 x = bfd_get_16 (input_bfd, contents);
1003 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1004 bfd_put_16 (input_bfd, x, contents);
1008 contents += rel->r_offset;
1009 srel = (bfd_signed_vma) relocation + rel->r_addend;
1010 if (((srel > 0) && (srel & 0xffff) > 255)
1011 || ((srel < 0) && ((-srel) & 0xffff) > 128))
1012 /* Remove offset for data/eeprom section. */
1013 return bfd_reloc_overflow;
1015 x = bfd_get_16 (input_bfd, contents);
1016 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1017 bfd_put_16 (input_bfd, x, contents);
1021 contents += rel->r_offset;
1022 srel = (bfd_signed_vma) relocation + rel->r_addend;
1023 if (((srel & 0xffff) > 63) || (srel < 0))
1024 /* Remove offset for data/eeprom section. */
1025 return bfd_reloc_overflow;
1026 x = bfd_get_16 (input_bfd, contents);
1027 x = (x & 0xd3f8) | ((srel & 7) | ((srel & (3 << 3)) << 7)
1028 | ((srel & (1 << 5)) << 8));
1029 bfd_put_16 (input_bfd, x, contents);
1033 contents += rel->r_offset;
1034 srel = (bfd_signed_vma) relocation + rel->r_addend;
1035 if (((srel & 0xffff) > 63) || (srel < 0))
1036 /* Remove offset for data/eeprom section. */
1037 return bfd_reloc_overflow;
1038 x = bfd_get_16 (input_bfd, contents);
1039 x = (x & 0xff30) | (srel & 0xf) | ((srel & 0x30) << 2);
1040 bfd_put_16 (input_bfd, x, contents);
1044 contents += rel->r_offset;
1045 srel = (bfd_signed_vma) relocation + rel->r_addend;
1046 srel = (srel >> 8) & 0xff;
1047 x = bfd_get_16 (input_bfd, contents);
1048 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1049 bfd_put_16 (input_bfd, x, contents);
1053 contents += rel->r_offset;
1054 srel = (bfd_signed_vma) relocation + rel->r_addend;
1055 srel = (srel >> 16) & 0xff;
1056 x = bfd_get_16 (input_bfd, contents);
1057 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1058 bfd_put_16 (input_bfd, x, contents);
1062 contents += rel->r_offset;
1063 srel = (bfd_signed_vma) relocation + rel->r_addend;
1064 srel = (srel >> 24) & 0xff;
1065 x = bfd_get_16 (input_bfd, contents);
1066 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1067 bfd_put_16 (input_bfd, x, contents);
1070 case R_AVR_LO8_LDI_NEG:
1071 contents += rel->r_offset;
1072 srel = (bfd_signed_vma) relocation + rel->r_addend;
1074 x = bfd_get_16 (input_bfd, contents);
1075 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1076 bfd_put_16 (input_bfd, x, contents);
1079 case R_AVR_HI8_LDI_NEG:
1080 contents += rel->r_offset;
1081 srel = (bfd_signed_vma) relocation + rel->r_addend;
1083 srel = (srel >> 8) & 0xff;
1084 x = bfd_get_16 (input_bfd, contents);
1085 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1086 bfd_put_16 (input_bfd, x, contents);
1089 case R_AVR_HH8_LDI_NEG:
1090 contents += rel->r_offset;
1091 srel = (bfd_signed_vma) relocation + rel->r_addend;
1093 srel = (srel >> 16) & 0xff;
1094 x = bfd_get_16 (input_bfd, contents);
1095 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1096 bfd_put_16 (input_bfd, x, contents);
1099 case R_AVR_MS8_LDI_NEG:
1100 contents += rel->r_offset;
1101 srel = (bfd_signed_vma) relocation + rel->r_addend;
1103 srel = (srel >> 24) & 0xff;
1104 x = bfd_get_16 (input_bfd, contents);
1105 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1106 bfd_put_16 (input_bfd, x, contents);
1109 case R_AVR_LO8_LDI_GS:
1110 use_stubs = (!htab->no_stubs);
1112 case R_AVR_LO8_LDI_PM:
1113 contents += rel->r_offset;
1114 srel = (bfd_signed_vma) relocation + rel->r_addend;
1117 && avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1119 bfd_vma old_srel = srel;
1121 /* We need to use the address of the stub instead. */
1122 srel = avr_get_stub_addr (srel, htab);
1124 printf ("LD: Using jump stub (at 0x%x) with destination 0x%x for "
1125 "reloc at address 0x%x.\n",
1126 (unsigned int) srel,
1127 (unsigned int) old_srel,
1128 (unsigned int) reloc_addr);
1130 if (avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1131 return bfd_reloc_outofrange;
1135 return bfd_reloc_outofrange;
1137 x = bfd_get_16 (input_bfd, contents);
1138 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1139 bfd_put_16 (input_bfd, x, contents);
1142 case R_AVR_HI8_LDI_GS:
1143 use_stubs = (!htab->no_stubs);
1145 case R_AVR_HI8_LDI_PM:
1146 contents += rel->r_offset;
1147 srel = (bfd_signed_vma) relocation + rel->r_addend;
1150 && avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1152 bfd_vma old_srel = srel;
1154 /* We need to use the address of the stub instead. */
1155 srel = avr_get_stub_addr (srel, htab);
1157 printf ("LD: Using jump stub (at 0x%x) with destination 0x%x for "
1158 "reloc at address 0x%x.\n",
1159 (unsigned int) srel,
1160 (unsigned int) old_srel,
1161 (unsigned int) reloc_addr);
1163 if (avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1164 return bfd_reloc_outofrange;
1168 return bfd_reloc_outofrange;
1170 srel = (srel >> 8) & 0xff;
1171 x = bfd_get_16 (input_bfd, contents);
1172 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1173 bfd_put_16 (input_bfd, x, contents);
1176 case R_AVR_HH8_LDI_PM:
1177 contents += rel->r_offset;
1178 srel = (bfd_signed_vma) relocation + rel->r_addend;
1180 return bfd_reloc_outofrange;
1182 srel = (srel >> 16) & 0xff;
1183 x = bfd_get_16 (input_bfd, contents);
1184 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1185 bfd_put_16 (input_bfd, x, contents);
1188 case R_AVR_LO8_LDI_PM_NEG:
1189 contents += rel->r_offset;
1190 srel = (bfd_signed_vma) relocation + rel->r_addend;
1193 return bfd_reloc_outofrange;
1195 x = bfd_get_16 (input_bfd, contents);
1196 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1197 bfd_put_16 (input_bfd, x, contents);
1200 case R_AVR_HI8_LDI_PM_NEG:
1201 contents += rel->r_offset;
1202 srel = (bfd_signed_vma) relocation + rel->r_addend;
1205 return bfd_reloc_outofrange;
1207 srel = (srel >> 8) & 0xff;
1208 x = bfd_get_16 (input_bfd, contents);
1209 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1210 bfd_put_16 (input_bfd, x, contents);
1213 case R_AVR_HH8_LDI_PM_NEG:
1214 contents += rel->r_offset;
1215 srel = (bfd_signed_vma) relocation + rel->r_addend;
1218 return bfd_reloc_outofrange;
1220 srel = (srel >> 16) & 0xff;
1221 x = bfd_get_16 (input_bfd, contents);
1222 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1223 bfd_put_16 (input_bfd, x, contents);
1227 contents += rel->r_offset;
1228 srel = (bfd_signed_vma) relocation + rel->r_addend;
1230 return bfd_reloc_outofrange;
1232 x = bfd_get_16 (input_bfd, contents);
1233 x |= ((srel & 0x10000) | ((srel << 3) & 0x1f00000)) >> 16;
1234 bfd_put_16 (input_bfd, x, contents);
1235 bfd_put_16 (input_bfd, (bfd_vma) srel & 0xffff, contents+2);
1239 use_stubs = (!htab->no_stubs);
1240 contents += rel->r_offset;
1241 srel = (bfd_signed_vma) relocation + rel->r_addend;
1244 && avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1246 bfd_vma old_srel = srel;
1248 /* We need to use the address of the stub instead. */
1249 srel = avr_get_stub_addr (srel,htab);
1251 printf ("LD: Using jump stub (at 0x%x) with destination 0x%x for "
1252 "reloc at address 0x%x.\n",
1253 (unsigned int) srel,
1254 (unsigned int) old_srel,
1255 (unsigned int) reloc_addr);
1257 if (avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1258 return bfd_reloc_outofrange;
1262 return bfd_reloc_outofrange;
1264 bfd_put_16 (input_bfd, (bfd_vma) srel &0x00ffff, contents);
1270 /* Nothing to do here, as contents already contains the diff value. */
1274 case R_AVR_LDS_STS_16:
1275 contents += rel->r_offset;
1276 srel = (bfd_signed_vma) relocation + rel->r_addend;
1277 if ((srel & 0xFFFF) < 0x40 || (srel & 0xFFFF) > 0xbf)
1278 return bfd_reloc_outofrange;
1280 x = bfd_get_16 (input_bfd, contents);
1281 x |= (srel & 0x0f) | ((srel & 0x30) << 5) | ((srel & 0x40) << 2);
1282 bfd_put_16 (input_bfd, x, contents);
1286 contents += rel->r_offset;
1287 srel = (bfd_signed_vma) relocation + rel->r_addend;
1288 if ((srel & 0xffff) > 0x3f)
1289 return bfd_reloc_outofrange;
1290 x = bfd_get_16 (input_bfd, contents);
1291 x = (x & 0xf9f0) | ((srel & 0x30) << 5) | (srel & 0x0f);
1292 bfd_put_16 (input_bfd, x, contents);
1296 contents += rel->r_offset;
1297 srel = (bfd_signed_vma) relocation + rel->r_addend;
1298 if ((srel & 0xffff) > 0x1f)
1299 return bfd_reloc_outofrange;
1300 x = bfd_get_16 (input_bfd, contents);
1301 x = (x & 0xff07) | ((srel & 0x1f) << 3);
1302 bfd_put_16 (input_bfd, x, contents);
1306 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1307 contents, rel->r_offset,
1308 relocation, rel->r_addend);
1314 /* Relocate an AVR ELF section. */
1317 elf32_avr_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED,
1318 struct bfd_link_info *info,
1320 asection *input_section,
1322 Elf_Internal_Rela *relocs,
1323 Elf_Internal_Sym *local_syms,
1324 asection **local_sections)
1326 Elf_Internal_Shdr * symtab_hdr;
1327 struct elf_link_hash_entry ** sym_hashes;
1328 Elf_Internal_Rela * rel;
1329 Elf_Internal_Rela * relend;
1330 struct elf32_avr_link_hash_table * htab = avr_link_hash_table (info);
1335 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
1336 sym_hashes = elf_sym_hashes (input_bfd);
1337 relend = relocs + input_section->reloc_count;
1339 for (rel = relocs; rel < relend; rel ++)
1341 reloc_howto_type * howto;
1342 unsigned long r_symndx;
1343 Elf_Internal_Sym * sym;
1345 struct elf_link_hash_entry * h;
1347 bfd_reloc_status_type r;
1351 r_type = ELF32_R_TYPE (rel->r_info);
1352 r_symndx = ELF32_R_SYM (rel->r_info);
1353 howto = elf_avr_howto_table + r_type;
1358 if (r_symndx < symtab_hdr->sh_info)
1360 sym = local_syms + r_symndx;
1361 sec = local_sections [r_symndx];
1362 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1364 name = bfd_elf_string_from_elf_section
1365 (input_bfd, symtab_hdr->sh_link, sym->st_name);
1366 name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
1370 bfd_boolean unresolved_reloc, warned, ignored;
1372 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1373 r_symndx, symtab_hdr, sym_hashes,
1375 unresolved_reloc, warned, ignored);
1377 name = h->root.root.string;
1380 if (sec != NULL && discarded_section (sec))
1381 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
1382 rel, 1, relend, howto, 0, contents);
1384 if (info->relocatable)
1387 r = avr_final_link_relocate (howto, input_bfd, input_section,
1388 contents, rel, relocation, htab);
1390 if (r != bfd_reloc_ok)
1392 const char * msg = (const char *) NULL;
1396 case bfd_reloc_overflow:
1397 r = info->callbacks->reloc_overflow
1398 (info, (h ? &h->root : NULL),
1399 name, howto->name, (bfd_vma) 0,
1400 input_bfd, input_section, rel->r_offset);
1403 case bfd_reloc_undefined:
1404 r = info->callbacks->undefined_symbol
1405 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
1408 case bfd_reloc_outofrange:
1409 msg = _("internal error: out of range error");
1412 case bfd_reloc_notsupported:
1413 msg = _("internal error: unsupported relocation error");
1416 case bfd_reloc_dangerous:
1417 msg = _("internal error: dangerous relocation");
1421 msg = _("internal error: unknown error");
1426 r = info->callbacks->warning
1427 (info, msg, name, input_bfd, input_section, rel->r_offset);
1437 /* The final processing done just before writing out a AVR ELF object
1438 file. This gets the AVR architecture right based on the machine
1442 bfd_elf_avr_final_write_processing (bfd *abfd,
1443 bfd_boolean linker ATTRIBUTE_UNUSED)
1447 switch (bfd_get_mach (abfd))
1451 val = E_AVR_MACH_AVR2;
1455 val = E_AVR_MACH_AVR1;
1458 case bfd_mach_avr25:
1459 val = E_AVR_MACH_AVR25;
1463 val = E_AVR_MACH_AVR3;
1466 case bfd_mach_avr31:
1467 val = E_AVR_MACH_AVR31;
1470 case bfd_mach_avr35:
1471 val = E_AVR_MACH_AVR35;
1475 val = E_AVR_MACH_AVR4;
1479 val = E_AVR_MACH_AVR5;
1482 case bfd_mach_avr51:
1483 val = E_AVR_MACH_AVR51;
1487 val = E_AVR_MACH_AVR6;
1490 case bfd_mach_avrxmega1:
1491 val = E_AVR_MACH_XMEGA1;
1494 case bfd_mach_avrxmega2:
1495 val = E_AVR_MACH_XMEGA2;
1498 case bfd_mach_avrxmega3:
1499 val = E_AVR_MACH_XMEGA3;
1502 case bfd_mach_avrxmega4:
1503 val = E_AVR_MACH_XMEGA4;
1506 case bfd_mach_avrxmega5:
1507 val = E_AVR_MACH_XMEGA5;
1510 case bfd_mach_avrxmega6:
1511 val = E_AVR_MACH_XMEGA6;
1514 case bfd_mach_avrxmega7:
1515 val = E_AVR_MACH_XMEGA7;
1518 case bfd_mach_avrtiny:
1519 val = E_AVR_MACH_AVRTINY;
1523 elf_elfheader (abfd)->e_machine = EM_AVR;
1524 elf_elfheader (abfd)->e_flags &= ~ EF_AVR_MACH;
1525 elf_elfheader (abfd)->e_flags |= val;
1528 /* Set the right machine number. */
1531 elf32_avr_object_p (bfd *abfd)
1533 unsigned int e_set = bfd_mach_avr2;
1535 if (elf_elfheader (abfd)->e_machine == EM_AVR
1536 || elf_elfheader (abfd)->e_machine == EM_AVR_OLD)
1538 int e_mach = elf_elfheader (abfd)->e_flags & EF_AVR_MACH;
1543 case E_AVR_MACH_AVR2:
1544 e_set = bfd_mach_avr2;
1547 case E_AVR_MACH_AVR1:
1548 e_set = bfd_mach_avr1;
1551 case E_AVR_MACH_AVR25:
1552 e_set = bfd_mach_avr25;
1555 case E_AVR_MACH_AVR3:
1556 e_set = bfd_mach_avr3;
1559 case E_AVR_MACH_AVR31:
1560 e_set = bfd_mach_avr31;
1563 case E_AVR_MACH_AVR35:
1564 e_set = bfd_mach_avr35;
1567 case E_AVR_MACH_AVR4:
1568 e_set = bfd_mach_avr4;
1571 case E_AVR_MACH_AVR5:
1572 e_set = bfd_mach_avr5;
1575 case E_AVR_MACH_AVR51:
1576 e_set = bfd_mach_avr51;
1579 case E_AVR_MACH_AVR6:
1580 e_set = bfd_mach_avr6;
1583 case E_AVR_MACH_XMEGA1:
1584 e_set = bfd_mach_avrxmega1;
1587 case E_AVR_MACH_XMEGA2:
1588 e_set = bfd_mach_avrxmega2;
1591 case E_AVR_MACH_XMEGA3:
1592 e_set = bfd_mach_avrxmega3;
1595 case E_AVR_MACH_XMEGA4:
1596 e_set = bfd_mach_avrxmega4;
1599 case E_AVR_MACH_XMEGA5:
1600 e_set = bfd_mach_avrxmega5;
1603 case E_AVR_MACH_XMEGA6:
1604 e_set = bfd_mach_avrxmega6;
1607 case E_AVR_MACH_XMEGA7:
1608 e_set = bfd_mach_avrxmega7;
1611 case E_AVR_MACH_AVRTINY:
1612 e_set = bfd_mach_avrtiny;
1616 return bfd_default_set_arch_mach (abfd, bfd_arch_avr,
1620 /* Returns whether the relocation type passed is a diff reloc. */
1623 elf32_avr_is_diff_reloc (Elf_Internal_Rela *irel)
1625 return (ELF32_R_TYPE (irel->r_info) == R_AVR_DIFF8
1626 ||ELF32_R_TYPE (irel->r_info) == R_AVR_DIFF16
1627 || ELF32_R_TYPE (irel->r_info) == R_AVR_DIFF32);
1630 /* Reduce the diff value written in the section by count if the shrinked
1631 insn address happens to fall between the two symbols for which this
1632 diff reloc was emitted. */
1635 elf32_avr_adjust_diff_reloc_value (bfd *abfd,
1636 struct bfd_section *isec,
1637 Elf_Internal_Rela *irel,
1639 bfd_vma shrinked_insn_address,
1642 unsigned char *reloc_contents = NULL;
1643 unsigned char *isec_contents = elf_section_data (isec)->this_hdr.contents;
1644 if (isec_contents == NULL)
1646 if (! bfd_malloc_and_get_section (abfd, isec, &isec_contents))
1649 elf_section_data (isec)->this_hdr.contents = isec_contents;
1652 reloc_contents = isec_contents + irel->r_offset;
1654 /* Read value written in object file. */
1656 switch (ELF32_R_TYPE (irel->r_info))
1660 x = *reloc_contents;
1665 x = bfd_get_16 (abfd, reloc_contents);
1670 x = bfd_get_32 (abfd, reloc_contents);
1679 /* For a diff reloc sym1 - sym2 the diff at assembly time (x) is written
1680 into the object file at the reloc offset. sym2's logical value is
1681 symval (<start_of_section>) + reloc addend. Compute the start and end
1682 addresses and check if the shrinked insn falls between sym1 and sym2. */
1684 bfd_vma end_address = symval + irel->r_addend;
1685 bfd_vma start_address = end_address - x;
1687 /* Reduce the diff value by count bytes and write it back into section
1690 if (shrinked_insn_address >= start_address
1691 && shrinked_insn_address <= end_address)
1693 switch (ELF32_R_TYPE (irel->r_info))
1697 *reloc_contents = (x - count);
1702 bfd_put_16 (abfd, (x - count) & 0xFFFF, reloc_contents);
1707 bfd_put_32 (abfd, (x - count) & 0xFFFFFFFF, reloc_contents);
1719 /* Delete some bytes from a section while changing the size of an instruction.
1720 The parameter "addr" denotes the section-relative offset pointing just
1721 behind the shrinked instruction. "addr+count" point at the first
1722 byte just behind the original unshrinked instruction. */
1725 elf32_avr_relax_delete_bytes (bfd *abfd,
1730 Elf_Internal_Shdr *symtab_hdr;
1731 unsigned int sec_shndx;
1733 Elf_Internal_Rela *irel, *irelend;
1734 Elf_Internal_Sym *isym;
1735 Elf_Internal_Sym *isymbuf = NULL;
1737 struct elf_link_hash_entry **sym_hashes;
1738 struct elf_link_hash_entry **end_hashes;
1739 unsigned int symcount;
1741 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1742 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1743 contents = elf_section_data (sec)->this_hdr.contents;
1747 irel = elf_section_data (sec)->relocs;
1748 irelend = irel + sec->reloc_count;
1750 /* Actually delete the bytes. */
1751 if (toaddr - addr - count > 0)
1752 memmove (contents + addr, contents + addr + count,
1753 (size_t) (toaddr - addr - count));
1756 /* Adjust all the reloc addresses. */
1757 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1759 bfd_vma old_reloc_address;
1761 old_reloc_address = (sec->output_section->vma
1762 + sec->output_offset + irel->r_offset);
1764 /* Get the new reloc address. */
1765 if ((irel->r_offset > addr
1766 && irel->r_offset < toaddr))
1769 printf ("Relocation at address 0x%x needs to be moved.\n"
1770 "Old section offset: 0x%x, New section offset: 0x%x \n",
1771 (unsigned int) old_reloc_address,
1772 (unsigned int) irel->r_offset,
1773 (unsigned int) ((irel->r_offset) - count));
1775 irel->r_offset -= count;
1780 /* The reloc's own addresses are now ok. However, we need to readjust
1781 the reloc's addend, i.e. the reloc's value if two conditions are met:
1782 1.) the reloc is relative to a symbol in this section that
1783 is located in front of the shrinked instruction
1784 2.) symbol plus addend end up behind the shrinked instruction.
1786 The most common case where this happens are relocs relative to
1787 the section-start symbol.
1789 This step needs to be done for all of the sections of the bfd. */
1792 struct bfd_section *isec;
1794 for (isec = abfd->sections; isec; isec = isec->next)
1797 bfd_vma shrinked_insn_address;
1799 if (isec->reloc_count == 0)
1802 shrinked_insn_address = (sec->output_section->vma
1803 + sec->output_offset + addr - count);
1805 irel = elf_section_data (isec)->relocs;
1806 /* PR 12161: Read in the relocs for this section if necessary. */
1808 irel = _bfd_elf_link_read_relocs (abfd, isec, NULL, NULL, TRUE);
1810 for (irelend = irel + isec->reloc_count;
1814 /* Read this BFD's local symbols if we haven't done
1816 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
1818 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1819 if (isymbuf == NULL)
1820 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
1821 symtab_hdr->sh_info, 0,
1823 if (isymbuf == NULL)
1827 /* Get the value of the symbol referred to by the reloc. */
1828 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1830 /* A local symbol. */
1833 isym = isymbuf + ELF32_R_SYM (irel->r_info);
1834 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
1835 symval = isym->st_value;
1836 /* If the reloc is absolute, it will not have
1837 a symbol or section associated with it. */
1840 symval += sym_sec->output_section->vma
1841 + sym_sec->output_offset;
1844 printf ("Checking if the relocation's "
1845 "addend needs corrections.\n"
1846 "Address of anchor symbol: 0x%x \n"
1847 "Address of relocation target: 0x%x \n"
1848 "Address of relaxed insn: 0x%x \n",
1849 (unsigned int) symval,
1850 (unsigned int) (symval + irel->r_addend),
1851 (unsigned int) shrinked_insn_address);
1853 if (symval <= shrinked_insn_address
1854 && (symval + irel->r_addend) > shrinked_insn_address)
1856 if (elf32_avr_is_diff_reloc (irel))
1858 elf32_avr_adjust_diff_reloc_value (abfd, isec, irel,
1860 shrinked_insn_address,
1864 irel->r_addend -= count;
1867 printf ("Relocation's addend needed to be fixed \n");
1870 /* else...Reference symbol is absolute. No adjustment needed. */
1872 /* else...Reference symbol is extern. No need for adjusting
1878 /* Adjust the local symbols defined in this section. */
1879 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1880 /* Fix PR 9841, there may be no local symbols. */
1883 Elf_Internal_Sym *isymend;
1885 isymend = isym + symtab_hdr->sh_info;
1886 for (; isym < isymend; isym++)
1888 if (isym->st_shndx == sec_shndx)
1890 if (isym->st_value > addr
1891 && isym->st_value <= toaddr)
1892 isym->st_value -= count;
1894 if (isym->st_value <= addr
1895 && isym->st_value + isym->st_size > addr)
1897 /* If this assert fires then we have a symbol that ends
1898 part way through an instruction. Does that make
1900 BFD_ASSERT (isym->st_value + isym->st_size >= addr + count);
1901 isym->st_size -= count;
1907 /* Now adjust the global symbols defined in this section. */
1908 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1909 - symtab_hdr->sh_info);
1910 sym_hashes = elf_sym_hashes (abfd);
1911 end_hashes = sym_hashes + symcount;
1912 for (; sym_hashes < end_hashes; sym_hashes++)
1914 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1915 if ((sym_hash->root.type == bfd_link_hash_defined
1916 || sym_hash->root.type == bfd_link_hash_defweak)
1917 && sym_hash->root.u.def.section == sec)
1919 if (sym_hash->root.u.def.value > addr
1920 && sym_hash->root.u.def.value <= toaddr)
1921 sym_hash->root.u.def.value -= count;
1923 if (sym_hash->root.u.def.value <= addr
1924 && (sym_hash->root.u.def.value + sym_hash->size > addr))
1926 /* If this assert fires then we have a symbol that ends
1927 part way through an instruction. Does that make
1929 BFD_ASSERT (sym_hash->root.u.def.value + sym_hash->size
1931 sym_hash->size -= count;
1939 static Elf_Internal_Sym *
1940 retrieve_local_syms (bfd *input_bfd)
1942 Elf_Internal_Shdr *symtab_hdr;
1943 Elf_Internal_Sym *isymbuf;
1946 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1947 locsymcount = symtab_hdr->sh_info;
1949 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1950 if (isymbuf == NULL && locsymcount != 0)
1951 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, locsymcount, 0,
1954 /* Save the symbols for this input file so they won't be read again. */
1955 if (isymbuf && isymbuf != (Elf_Internal_Sym *) symtab_hdr->contents)
1956 symtab_hdr->contents = (unsigned char *) isymbuf;
1961 /* Get the input section for a given symbol index.
1963 . a section symbol, return the section;
1964 . a common symbol, return the common section;
1965 . an undefined symbol, return the undefined section;
1966 . an indirect symbol, follow the links;
1967 . an absolute value, return the absolute section. */
1970 get_elf_r_symndx_section (bfd *abfd, unsigned long r_symndx)
1972 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1973 asection *target_sec = NULL;
1974 if (r_symndx < symtab_hdr->sh_info)
1976 Elf_Internal_Sym *isymbuf;
1977 unsigned int section_index;
1979 isymbuf = retrieve_local_syms (abfd);
1980 section_index = isymbuf[r_symndx].st_shndx;
1982 if (section_index == SHN_UNDEF)
1983 target_sec = bfd_und_section_ptr;
1984 else if (section_index == SHN_ABS)
1985 target_sec = bfd_abs_section_ptr;
1986 else if (section_index == SHN_COMMON)
1987 target_sec = bfd_com_section_ptr;
1989 target_sec = bfd_section_from_elf_index (abfd, section_index);
1993 unsigned long indx = r_symndx - symtab_hdr->sh_info;
1994 struct elf_link_hash_entry *h = elf_sym_hashes (abfd)[indx];
1996 while (h->root.type == bfd_link_hash_indirect
1997 || h->root.type == bfd_link_hash_warning)
1998 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2000 switch (h->root.type)
2002 case bfd_link_hash_defined:
2003 case bfd_link_hash_defweak:
2004 target_sec = h->root.u.def.section;
2006 case bfd_link_hash_common:
2007 target_sec = bfd_com_section_ptr;
2009 case bfd_link_hash_undefined:
2010 case bfd_link_hash_undefweak:
2011 target_sec = bfd_und_section_ptr;
2013 default: /* New indirect warning. */
2014 target_sec = bfd_und_section_ptr;
2021 /* Get the section-relative offset for a symbol number. */
2024 get_elf_r_symndx_offset (bfd *abfd, unsigned long r_symndx)
2026 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2029 if (r_symndx < symtab_hdr->sh_info)
2031 Elf_Internal_Sym *isymbuf;
2032 isymbuf = retrieve_local_syms (abfd);
2033 offset = isymbuf[r_symndx].st_value;
2037 unsigned long indx = r_symndx - symtab_hdr->sh_info;
2038 struct elf_link_hash_entry *h =
2039 elf_sym_hashes (abfd)[indx];
2041 while (h->root.type == bfd_link_hash_indirect
2042 || h->root.type == bfd_link_hash_warning)
2043 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2044 if (h->root.type == bfd_link_hash_defined
2045 || h->root.type == bfd_link_hash_defweak)
2046 offset = h->root.u.def.value;
2051 /* This function handles relaxing for the avr.
2052 Many important relaxing opportunities within functions are already
2053 realized by the compiler itself.
2054 Here we try to replace call (4 bytes) -> rcall (2 bytes)
2055 and jump -> rjmp (safes also 2 bytes).
2056 As well we now optimize seqences of
2057 - call/rcall function
2062 . In case that within a sequence
2065 the ret could no longer be reached it is optimized away. In order
2066 to check if the ret is no longer needed, it is checked that the ret's address
2067 is not the target of a branch or jump within the same section, it is checked
2068 that there is no skip instruction before the jmp/rjmp and that there
2069 is no local or global label place at the address of the ret.
2071 We refrain from relaxing within sections ".vectors" and
2072 ".jumptables" in order to maintain the position of the instructions.
2073 There, however, we substitute jmp/call by a sequence rjmp,nop/rcall,nop
2074 if possible. (In future one could possibly use the space of the nop
2075 for the first instruction of the irq service function.
2077 The .jumptables sections is meant to be used for a future tablejump variant
2078 for the devices with 3-byte program counter where the table itself
2079 contains 4-byte jump instructions whose relative offset must not
2083 elf32_avr_relax_section (bfd *abfd,
2085 struct bfd_link_info *link_info,
2088 Elf_Internal_Shdr *symtab_hdr;
2089 Elf_Internal_Rela *internal_relocs;
2090 Elf_Internal_Rela *irel, *irelend;
2091 bfd_byte *contents = NULL;
2092 Elf_Internal_Sym *isymbuf = NULL;
2093 struct elf32_avr_link_hash_table *htab;
2095 /* If 'shrinkable' is FALSE, do not shrink by deleting bytes while
2096 relaxing. Such shrinking can cause issues for the sections such
2097 as .vectors and .jumptables. Instead the unused bytes should be
2098 filled with nop instructions. */
2099 bfd_boolean shrinkable = TRUE;
2101 if (!strcmp (sec->name,".vectors")
2102 || !strcmp (sec->name,".jumptables"))
2105 if (link_info->relocatable)
2106 (*link_info->callbacks->einfo)
2107 (_("%P%F: --relax and -r may not be used together\n"));
2109 htab = avr_link_hash_table (link_info);
2113 /* Assume nothing changes. */
2116 if ((!htab->no_stubs) && (sec == htab->stub_sec))
2118 /* We are just relaxing the stub section.
2119 Let's calculate the size needed again. */
2120 bfd_size_type last_estimated_stub_section_size = htab->stub_sec->size;
2123 printf ("Relaxing the stub section. Size prior to this pass: %i\n",
2124 (int) last_estimated_stub_section_size);
2126 elf32_avr_size_stubs (htab->stub_sec->output_section->owner,
2129 /* Check if the number of trampolines changed. */
2130 if (last_estimated_stub_section_size != htab->stub_sec->size)
2134 printf ("Size of stub section after this pass: %i\n",
2135 (int) htab->stub_sec->size);
2140 /* We don't have to do anything for a relocatable link, if
2141 this section does not have relocs, or if this is not a
2143 if (link_info->relocatable
2144 || (sec->flags & SEC_RELOC) == 0
2145 || sec->reloc_count == 0
2146 || (sec->flags & SEC_CODE) == 0)
2149 /* Check if the object file to relax uses internal symbols so that we
2150 could fix up the relocations. */
2151 if (!(elf_elfheader (abfd)->e_flags & EF_AVR_LINKRELAX_PREPARED))
2154 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2156 /* Get a copy of the native relocations. */
2157 internal_relocs = (_bfd_elf_link_read_relocs
2158 (abfd, sec, NULL, NULL, link_info->keep_memory));
2159 if (internal_relocs == NULL)
2162 /* Walk through the relocs looking for relaxing opportunities. */
2163 irelend = internal_relocs + sec->reloc_count;
2164 for (irel = internal_relocs; irel < irelend; irel++)
2168 if ( ELF32_R_TYPE (irel->r_info) != R_AVR_13_PCREL
2169 && ELF32_R_TYPE (irel->r_info) != R_AVR_7_PCREL
2170 && ELF32_R_TYPE (irel->r_info) != R_AVR_CALL)
2173 /* Get the section contents if we haven't done so already. */
2174 if (contents == NULL)
2176 /* Get cached copy if it exists. */
2177 if (elf_section_data (sec)->this_hdr.contents != NULL)
2178 contents = elf_section_data (sec)->this_hdr.contents;
2181 /* Go get them off disk. */
2182 if (! bfd_malloc_and_get_section (abfd, sec, &contents))
2187 /* Read this BFD's local symbols if we haven't done so already. */
2188 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
2190 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2191 if (isymbuf == NULL)
2192 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
2193 symtab_hdr->sh_info, 0,
2195 if (isymbuf == NULL)
2200 /* Get the value of the symbol referred to by the reloc. */
2201 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
2203 /* A local symbol. */
2204 Elf_Internal_Sym *isym;
2207 isym = isymbuf + ELF32_R_SYM (irel->r_info);
2208 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
2209 symval = isym->st_value;
2210 /* If the reloc is absolute, it will not have
2211 a symbol or section associated with it. */
2213 symval += sym_sec->output_section->vma
2214 + sym_sec->output_offset;
2219 struct elf_link_hash_entry *h;
2221 /* An external symbol. */
2222 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
2223 h = elf_sym_hashes (abfd)[indx];
2224 BFD_ASSERT (h != NULL);
2225 if (h->root.type != bfd_link_hash_defined
2226 && h->root.type != bfd_link_hash_defweak)
2227 /* This appears to be a reference to an undefined
2228 symbol. Just ignore it--it will be caught by the
2229 regular reloc processing. */
2232 symval = (h->root.u.def.value
2233 + h->root.u.def.section->output_section->vma
2234 + h->root.u.def.section->output_offset);
2237 /* For simplicity of coding, we are going to modify the section
2238 contents, the section relocs, and the BFD symbol table. We
2239 must tell the rest of the code not to free up this
2240 information. It would be possible to instead create a table
2241 of changes which have to be made, as is done in coff-mips.c;
2242 that would be more work, but would require less memory when
2243 the linker is run. */
2244 switch (ELF32_R_TYPE (irel->r_info))
2246 /* Try to turn a 22-bit absolute call/jump into an 13-bit
2247 pc-relative rcall/rjmp. */
2250 bfd_vma value = symval + irel->r_addend;
2252 int distance_short_enough = 0;
2254 /* Get the address of this instruction. */
2255 dot = (sec->output_section->vma
2256 + sec->output_offset + irel->r_offset);
2258 /* Compute the distance from this insn to the branch target. */
2261 /* Check if the gap falls in the range that can be accommodated
2262 in 13bits signed (It is 12bits when encoded, as we deal with
2263 word addressing). */
2264 if (!shrinkable && ((int) gap >= -4096 && (int) gap <= 4095))
2265 distance_short_enough = 1;
2266 /* If shrinkable, then we can check for a range of distance which
2267 is two bytes farther on both the directions because the call
2268 or jump target will be closer by two bytes after the
2270 else if (shrinkable && ((int) gap >= -4094 && (int) gap <= 4097))
2271 distance_short_enough = 1;
2273 /* Here we handle the wrap-around case. E.g. for a 16k device
2274 we could use a rjmp to jump from address 0x100 to 0x3d00!
2275 In order to make this work properly, we need to fill the
2276 vaiable avr_pc_wrap_around with the appropriate value.
2277 I.e. 0x4000 for a 16k device. */
2279 /* Shrinking the code size makes the gaps larger in the
2280 case of wrap-arounds. So we use a heuristical safety
2281 margin to avoid that during relax the distance gets
2282 again too large for the short jumps. Let's assume
2283 a typical code-size reduction due to relax for a
2284 16k device of 600 bytes. So let's use twice the
2285 typical value as safety margin. */
2289 int assumed_shrink = 600;
2290 if (avr_pc_wrap_around > 0x4000)
2291 assumed_shrink = 900;
2293 safety_margin = 2 * assumed_shrink;
2295 rgap = avr_relative_distance_considering_wrap_around (gap);
2297 if (rgap >= (-4092 + safety_margin)
2298 && rgap <= (4094 - safety_margin))
2299 distance_short_enough = 1;
2302 if (distance_short_enough)
2304 unsigned char code_msb;
2305 unsigned char code_lsb;
2308 printf ("shrinking jump/call instruction at address 0x%x"
2309 " in section %s\n\n",
2310 (int) dot, sec->name);
2312 /* Note that we've changed the relocs, section contents,
2314 elf_section_data (sec)->relocs = internal_relocs;
2315 elf_section_data (sec)->this_hdr.contents = contents;
2316 symtab_hdr->contents = (unsigned char *) isymbuf;
2318 /* Get the instruction code for relaxing. */
2319 code_lsb = bfd_get_8 (abfd, contents + irel->r_offset);
2320 code_msb = bfd_get_8 (abfd, contents + irel->r_offset + 1);
2322 /* Mask out the relocation bits. */
2325 if (code_msb == 0x94 && code_lsb == 0x0E)
2327 /* we are changing call -> rcall . */
2328 bfd_put_8 (abfd, 0x00, contents + irel->r_offset);
2329 bfd_put_8 (abfd, 0xD0, contents + irel->r_offset + 1);
2331 else if (code_msb == 0x94 && code_lsb == 0x0C)
2333 /* we are changeing jump -> rjmp. */
2334 bfd_put_8 (abfd, 0x00, contents + irel->r_offset);
2335 bfd_put_8 (abfd, 0xC0, contents + irel->r_offset + 1);
2340 /* Fix the relocation's type. */
2341 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2344 /* We should not modify the ordering if 'shrinkable' is
2348 /* Let's insert a nop. */
2349 bfd_put_8 (abfd, 0x00, contents + irel->r_offset + 2);
2350 bfd_put_8 (abfd, 0x00, contents + irel->r_offset + 3);
2354 /* Delete two bytes of data. */
2355 if (!elf32_avr_relax_delete_bytes (abfd, sec,
2356 irel->r_offset + 2, 2))
2359 /* That will change things, so, we should relax again.
2360 Note that this is not required, and it may be slow. */
2368 unsigned char code_msb;
2369 unsigned char code_lsb;
2372 code_msb = bfd_get_8 (abfd, contents + irel->r_offset + 1);
2373 code_lsb = bfd_get_8 (abfd, contents + irel->r_offset + 0);
2375 /* Get the address of this instruction. */
2376 dot = (sec->output_section->vma
2377 + sec->output_offset + irel->r_offset);
2379 /* Here we look for rcall/ret or call/ret sequences that could be
2380 safely replaced by rjmp/ret or jmp/ret. */
2381 if (((code_msb & 0xf0) == 0xd0)
2382 && avr_replace_call_ret_sequences)
2384 /* This insn is a rcall. */
2385 unsigned char next_insn_msb = 0;
2386 unsigned char next_insn_lsb = 0;
2388 if (irel->r_offset + 3 < sec->size)
2391 bfd_get_8 (abfd, contents + irel->r_offset + 3);
2393 bfd_get_8 (abfd, contents + irel->r_offset + 2);
2396 if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb))
2398 /* The next insn is a ret. We now convert the rcall insn
2399 into a rjmp instruction. */
2401 bfd_put_8 (abfd, code_msb, contents + irel->r_offset + 1);
2403 printf ("converted rcall/ret sequence at address 0x%x"
2404 " into rjmp/ret sequence. Section is %s\n\n",
2405 (int) dot, sec->name);
2410 else if ((0x94 == (code_msb & 0xfe))
2411 && (0x0e == (code_lsb & 0x0e))
2412 && avr_replace_call_ret_sequences)
2414 /* This insn is a call. */
2415 unsigned char next_insn_msb = 0;
2416 unsigned char next_insn_lsb = 0;
2418 if (irel->r_offset + 5 < sec->size)
2421 bfd_get_8 (abfd, contents + irel->r_offset + 5);
2423 bfd_get_8 (abfd, contents + irel->r_offset + 4);
2426 if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb))
2428 /* The next insn is a ret. We now convert the call insn
2429 into a jmp instruction. */
2432 bfd_put_8 (abfd, code_lsb, contents + irel->r_offset);
2434 printf ("converted call/ret sequence at address 0x%x"
2435 " into jmp/ret sequence. Section is %s\n\n",
2436 (int) dot, sec->name);
2441 else if ((0xc0 == (code_msb & 0xf0))
2442 || ((0x94 == (code_msb & 0xfe))
2443 && (0x0c == (code_lsb & 0x0e))))
2445 /* This insn is a rjmp or a jmp. */
2446 unsigned char next_insn_msb = 0;
2447 unsigned char next_insn_lsb = 0;
2450 if (0xc0 == (code_msb & 0xf0))
2451 insn_size = 2; /* rjmp insn */
2453 insn_size = 4; /* jmp insn */
2455 if (irel->r_offset + insn_size + 1 < sec->size)
2458 bfd_get_8 (abfd, contents + irel->r_offset
2461 bfd_get_8 (abfd, contents + irel->r_offset
2465 if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb))
2467 /* The next insn is a ret. We possibly could delete
2468 this ret. First we need to check for preceding
2469 sbis/sbic/sbrs or cpse "skip" instructions. */
2471 int there_is_preceding_non_skip_insn = 1;
2472 bfd_vma address_of_ret;
2474 address_of_ret = dot + insn_size;
2476 if (debug_relax && (insn_size == 2))
2477 printf ("found rjmp / ret sequence at address 0x%x\n",
2479 if (debug_relax && (insn_size == 4))
2480 printf ("found jmp / ret sequence at address 0x%x\n",
2483 /* We have to make sure that there is a preceding insn. */
2484 if (irel->r_offset >= 2)
2486 unsigned char preceding_msb;
2487 unsigned char preceding_lsb;
2490 bfd_get_8 (abfd, contents + irel->r_offset - 1);
2492 bfd_get_8 (abfd, contents + irel->r_offset - 2);
2495 if (0x99 == preceding_msb)
2496 there_is_preceding_non_skip_insn = 0;
2499 if (0x9b == preceding_msb)
2500 there_is_preceding_non_skip_insn = 0;
2503 if ((0xfc == (preceding_msb & 0xfe)
2504 && (0x00 == (preceding_lsb & 0x08))))
2505 there_is_preceding_non_skip_insn = 0;
2508 if ((0xfe == (preceding_msb & 0xfe)
2509 && (0x00 == (preceding_lsb & 0x08))))
2510 there_is_preceding_non_skip_insn = 0;
2513 if (0x10 == (preceding_msb & 0xfc))
2514 there_is_preceding_non_skip_insn = 0;
2516 if (there_is_preceding_non_skip_insn == 0)
2518 printf ("preceding skip insn prevents deletion of"
2519 " ret insn at Addy 0x%x in section %s\n",
2520 (int) dot + 2, sec->name);
2524 /* There is no previous instruction. */
2525 there_is_preceding_non_skip_insn = 0;
2528 if (there_is_preceding_non_skip_insn)
2530 /* We now only have to make sure that there is no
2531 local label defined at the address of the ret
2532 instruction and that there is no local relocation
2533 in this section pointing to the ret. */
2535 int deleting_ret_is_safe = 1;
2536 unsigned int section_offset_of_ret_insn =
2537 irel->r_offset + insn_size;
2538 Elf_Internal_Sym *isym, *isymend;
2539 unsigned int sec_shndx;
2540 struct bfd_section *isec;
2543 _bfd_elf_section_from_bfd_section (abfd, sec);
2545 /* Check for local symbols. */
2546 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
2547 isymend = isym + symtab_hdr->sh_info;
2548 /* PR 6019: There may not be any local symbols. */
2549 for (; isym != NULL && isym < isymend; isym++)
2551 if (isym->st_value == section_offset_of_ret_insn
2552 && isym->st_shndx == sec_shndx)
2554 deleting_ret_is_safe = 0;
2556 printf ("local label prevents deletion of ret "
2557 "insn at address 0x%x\n",
2558 (int) dot + insn_size);
2562 /* Now check for global symbols. */
2565 struct elf_link_hash_entry **sym_hashes;
2566 struct elf_link_hash_entry **end_hashes;
2568 symcount = (symtab_hdr->sh_size
2569 / sizeof (Elf32_External_Sym)
2570 - symtab_hdr->sh_info);
2571 sym_hashes = elf_sym_hashes (abfd);
2572 end_hashes = sym_hashes + symcount;
2573 for (; sym_hashes < end_hashes; sym_hashes++)
2575 struct elf_link_hash_entry *sym_hash =
2577 if ((sym_hash->root.type == bfd_link_hash_defined
2578 || sym_hash->root.type ==
2579 bfd_link_hash_defweak)
2580 && sym_hash->root.u.def.section == sec
2581 && sym_hash->root.u.def.value == section_offset_of_ret_insn)
2583 deleting_ret_is_safe = 0;
2585 printf ("global label prevents deletion of "
2586 "ret insn at address 0x%x\n",
2587 (int) dot + insn_size);
2592 /* Now we check for relocations pointing to ret. */
2593 for (isec = abfd->sections; isec && deleting_ret_is_safe; isec = isec->next)
2595 Elf_Internal_Rela *rel;
2596 Elf_Internal_Rela *relend;
2598 rel = elf_section_data (isec)->relocs;
2600 rel = _bfd_elf_link_read_relocs (abfd, isec, NULL, NULL, TRUE);
2602 relend = rel + isec->reloc_count;
2604 for (; rel && rel < relend; rel++)
2606 bfd_vma reloc_target = 0;
2608 /* Read this BFD's local symbols if we haven't
2610 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
2612 isymbuf = (Elf_Internal_Sym *)
2613 symtab_hdr->contents;
2614 if (isymbuf == NULL)
2615 isymbuf = bfd_elf_get_elf_syms
2618 symtab_hdr->sh_info, 0,
2620 if (isymbuf == NULL)
2624 /* Get the value of the symbol referred to
2626 if (ELF32_R_SYM (rel->r_info)
2627 < symtab_hdr->sh_info)
2629 /* A local symbol. */
2633 + ELF32_R_SYM (rel->r_info);
2634 sym_sec = bfd_section_from_elf_index
2635 (abfd, isym->st_shndx);
2636 symval = isym->st_value;
2638 /* If the reloc is absolute, it will not
2639 have a symbol or section associated
2645 sym_sec->output_section->vma
2646 + sym_sec->output_offset;
2647 reloc_target = symval + rel->r_addend;
2651 reloc_target = symval + rel->r_addend;
2652 /* Reference symbol is absolute. */
2655 /* else ... reference symbol is extern. */
2657 if (address_of_ret == reloc_target)
2659 deleting_ret_is_safe = 0;
2662 "rjmp/jmp ret sequence at address"
2663 " 0x%x could not be deleted. ret"
2664 " is target of a relocation.\n",
2665 (int) address_of_ret);
2671 if (deleting_ret_is_safe)
2674 printf ("unreachable ret instruction "
2675 "at address 0x%x deleted.\n",
2676 (int) dot + insn_size);
2678 /* Delete two bytes of data. */
2679 if (!elf32_avr_relax_delete_bytes (abfd, sec,
2680 irel->r_offset + insn_size, 2))
2683 /* That will change things, so, we should relax
2684 again. Note that this is not required, and it
2697 if (contents != NULL
2698 && elf_section_data (sec)->this_hdr.contents != contents)
2700 if (! link_info->keep_memory)
2704 /* Cache the section contents for elf_link_input_bfd. */
2705 elf_section_data (sec)->this_hdr.contents = contents;
2709 if (internal_relocs != NULL
2710 && elf_section_data (sec)->relocs != internal_relocs)
2711 free (internal_relocs);
2717 && symtab_hdr->contents != (unsigned char *) isymbuf)
2719 if (contents != NULL
2720 && elf_section_data (sec)->this_hdr.contents != contents)
2722 if (internal_relocs != NULL
2723 && elf_section_data (sec)->relocs != internal_relocs)
2724 free (internal_relocs);
2729 /* This is a version of bfd_generic_get_relocated_section_contents
2730 which uses elf32_avr_relocate_section.
2732 For avr it's essentially a cut and paste taken from the H8300 port.
2733 The author of the relaxation support patch for avr had absolutely no
2734 clue what is happening here but found out that this part of the code
2735 seems to be important. */
2738 elf32_avr_get_relocated_section_contents (bfd *output_bfd,
2739 struct bfd_link_info *link_info,
2740 struct bfd_link_order *link_order,
2742 bfd_boolean relocatable,
2745 Elf_Internal_Shdr *symtab_hdr;
2746 asection *input_section = link_order->u.indirect.section;
2747 bfd *input_bfd = input_section->owner;
2748 asection **sections = NULL;
2749 Elf_Internal_Rela *internal_relocs = NULL;
2750 Elf_Internal_Sym *isymbuf = NULL;
2752 /* We only need to handle the case of relaxing, or of having a
2753 particular set of section contents, specially. */
2755 || elf_section_data (input_section)->this_hdr.contents == NULL)
2756 return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
2760 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2762 memcpy (data, elf_section_data (input_section)->this_hdr.contents,
2763 (size_t) input_section->size);
2765 if ((input_section->flags & SEC_RELOC) != 0
2766 && input_section->reloc_count > 0)
2769 Elf_Internal_Sym *isym, *isymend;
2772 internal_relocs = (_bfd_elf_link_read_relocs
2773 (input_bfd, input_section, NULL, NULL, FALSE));
2774 if (internal_relocs == NULL)
2777 if (symtab_hdr->sh_info != 0)
2779 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2780 if (isymbuf == NULL)
2781 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
2782 symtab_hdr->sh_info, 0,
2784 if (isymbuf == NULL)
2788 amt = symtab_hdr->sh_info;
2789 amt *= sizeof (asection *);
2790 sections = bfd_malloc (amt);
2791 if (sections == NULL && amt != 0)
2794 isymend = isymbuf + symtab_hdr->sh_info;
2795 for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
2799 if (isym->st_shndx == SHN_UNDEF)
2800 isec = bfd_und_section_ptr;
2801 else if (isym->st_shndx == SHN_ABS)
2802 isec = bfd_abs_section_ptr;
2803 else if (isym->st_shndx == SHN_COMMON)
2804 isec = bfd_com_section_ptr;
2806 isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
2811 if (! elf32_avr_relocate_section (output_bfd, link_info, input_bfd,
2812 input_section, data, internal_relocs,
2816 if (sections != NULL)
2819 && symtab_hdr->contents != (unsigned char *) isymbuf)
2821 if (elf_section_data (input_section)->relocs != internal_relocs)
2822 free (internal_relocs);
2828 if (sections != NULL)
2831 && symtab_hdr->contents != (unsigned char *) isymbuf)
2833 if (internal_relocs != NULL
2834 && elf_section_data (input_section)->relocs != internal_relocs)
2835 free (internal_relocs);
2840 /* Determines the hash entry name for a particular reloc. It consists of
2841 the identifier of the symbol section and the added reloc addend and
2842 symbol offset relative to the section the symbol is attached to. */
2845 avr_stub_name (const asection *symbol_section,
2846 const bfd_vma symbol_offset,
2847 const Elf_Internal_Rela *rela)
2852 len = 8 + 1 + 8 + 1 + 1;
2853 stub_name = bfd_malloc (len);
2855 sprintf (stub_name, "%08x+%08x",
2856 symbol_section->id & 0xffffffff,
2857 (unsigned int) ((rela->r_addend & 0xffffffff) + symbol_offset));
2863 /* Add a new stub entry to the stub hash. Not all fields of the new
2864 stub entry are initialised. */
2866 static struct elf32_avr_stub_hash_entry *
2867 avr_add_stub (const char *stub_name,
2868 struct elf32_avr_link_hash_table *htab)
2870 struct elf32_avr_stub_hash_entry *hsh;
2872 /* Enter this entry into the linker stub hash table. */
2873 hsh = avr_stub_hash_lookup (&htab->bstab, stub_name, TRUE, FALSE);
2877 (*_bfd_error_handler) (_("%B: cannot create stub entry %s"),
2882 hsh->stub_offset = 0;
2886 /* We assume that there is already space allocated for the stub section
2887 contents and that before building the stubs the section size is
2888 initialized to 0. We assume that within the stub hash table entry,
2889 the absolute position of the jmp target has been written in the
2890 target_value field. We write here the offset of the generated jmp insn
2891 relative to the trampoline section start to the stub_offset entry in
2892 the stub hash table entry. */
2895 avr_build_one_stub (struct bfd_hash_entry *bh, void *in_arg)
2897 struct elf32_avr_stub_hash_entry *hsh;
2898 struct bfd_link_info *info;
2899 struct elf32_avr_link_hash_table *htab;
2906 bfd_vma jmp_insn = 0x0000940c;
2908 /* Massage our args to the form they really have. */
2909 hsh = avr_stub_hash_entry (bh);
2911 if (!hsh->is_actually_needed)
2914 info = (struct bfd_link_info *) in_arg;
2916 htab = avr_link_hash_table (info);
2920 target = hsh->target_value;
2922 /* Make a note of the offset within the stubs for this entry. */
2923 hsh->stub_offset = htab->stub_sec->size;
2924 loc = htab->stub_sec->contents + hsh->stub_offset;
2926 stub_bfd = htab->stub_sec->owner;
2929 printf ("Building one Stub. Address: 0x%x, Offset: 0x%x\n",
2930 (unsigned int) target,
2931 (unsigned int) hsh->stub_offset);
2933 /* We now have to add the information on the jump target to the bare
2934 opcode bits already set in jmp_insn. */
2936 /* Check for the alignment of the address. */
2940 starget = target >> 1;
2941 jmp_insn |= ((starget & 0x10000) | ((starget << 3) & 0x1f00000)) >> 16;
2942 bfd_put_16 (stub_bfd, jmp_insn, loc);
2943 bfd_put_16 (stub_bfd, (bfd_vma) starget & 0xffff, loc + 2);
2945 htab->stub_sec->size += 4;
2947 /* Now add the entries in the address mapping table if there is still
2952 nr = htab->amt_entry_cnt + 1;
2953 if (nr <= htab->amt_max_entry_cnt)
2955 htab->amt_entry_cnt = nr;
2957 htab->amt_stub_offsets[nr - 1] = hsh->stub_offset;
2958 htab->amt_destination_addr[nr - 1] = target;
2966 avr_mark_stub_not_to_be_necessary (struct bfd_hash_entry *bh,
2967 void *in_arg ATTRIBUTE_UNUSED)
2969 struct elf32_avr_stub_hash_entry *hsh;
2971 hsh = avr_stub_hash_entry (bh);
2972 hsh->is_actually_needed = FALSE;
2978 avr_size_one_stub (struct bfd_hash_entry *bh, void *in_arg)
2980 struct elf32_avr_stub_hash_entry *hsh;
2981 struct elf32_avr_link_hash_table *htab;
2984 /* Massage our args to the form they really have. */
2985 hsh = avr_stub_hash_entry (bh);
2988 if (hsh->is_actually_needed)
2993 htab->stub_sec->size += size;
2998 elf32_avr_setup_params (struct bfd_link_info *info,
3000 asection *avr_stub_section,
3001 bfd_boolean no_stubs,
3002 bfd_boolean deb_stubs,
3003 bfd_boolean deb_relax,
3004 bfd_vma pc_wrap_around,
3005 bfd_boolean call_ret_replacement)
3007 struct elf32_avr_link_hash_table *htab = avr_link_hash_table (info);
3011 htab->stub_sec = avr_stub_section;
3012 htab->stub_bfd = avr_stub_bfd;
3013 htab->no_stubs = no_stubs;
3015 debug_relax = deb_relax;
3016 debug_stubs = deb_stubs;
3017 avr_pc_wrap_around = pc_wrap_around;
3018 avr_replace_call_ret_sequences = call_ret_replacement;
3022 /* Set up various things so that we can make a list of input sections
3023 for each output section included in the link. Returns -1 on error,
3024 0 when no stubs will be needed, and 1 on success. It also sets
3025 information on the stubs bfd and the stub section in the info
3029 elf32_avr_setup_section_lists (bfd *output_bfd,
3030 struct bfd_link_info *info)
3033 unsigned int bfd_count;
3034 int top_id, top_index;
3036 asection **input_list, **list;
3038 struct elf32_avr_link_hash_table *htab = avr_link_hash_table (info);
3040 if (htab == NULL || htab->no_stubs)
3043 /* Count the number of input BFDs and find the top input section id. */
3044 for (input_bfd = info->input_bfds, bfd_count = 0, top_id = 0;
3046 input_bfd = input_bfd->link.next)
3049 for (section = input_bfd->sections;
3051 section = section->next)
3052 if (top_id < section->id)
3053 top_id = section->id;
3056 htab->bfd_count = bfd_count;
3058 /* We can't use output_bfd->section_count here to find the top output
3059 section index as some sections may have been removed, and
3060 strip_excluded_output_sections doesn't renumber the indices. */
3061 for (section = output_bfd->sections, top_index = 0;
3063 section = section->next)
3064 if (top_index < section->index)
3065 top_index = section->index;
3067 htab->top_index = top_index;
3068 amt = sizeof (asection *) * (top_index + 1);
3069 input_list = bfd_malloc (amt);
3070 htab->input_list = input_list;
3071 if (input_list == NULL)
3074 /* For sections we aren't interested in, mark their entries with a
3075 value we can check later. */
3076 list = input_list + top_index;
3078 *list = bfd_abs_section_ptr;
3079 while (list-- != input_list);
3081 for (section = output_bfd->sections;
3083 section = section->next)
3084 if ((section->flags & SEC_CODE) != 0)
3085 input_list[section->index] = NULL;
3091 /* Read in all local syms for all input bfds, and create hash entries
3092 for export stubs if we are building a multi-subspace shared lib.
3093 Returns -1 on error, 0 otherwise. */
3096 get_local_syms (bfd *input_bfd, struct bfd_link_info *info)
3098 unsigned int bfd_indx;
3099 Elf_Internal_Sym *local_syms, **all_local_syms;
3100 struct elf32_avr_link_hash_table *htab = avr_link_hash_table (info);
3106 /* We want to read in symbol extension records only once. To do this
3107 we need to read in the local symbols in parallel and save them for
3108 later use; so hold pointers to the local symbols in an array. */
3109 amt = sizeof (Elf_Internal_Sym *) * htab->bfd_count;
3110 all_local_syms = bfd_zmalloc (amt);
3111 htab->all_local_syms = all_local_syms;
3112 if (all_local_syms == NULL)
3115 /* Walk over all the input BFDs, swapping in local symbols.
3116 If we are creating a shared library, create hash entries for the
3120 input_bfd = input_bfd->link.next, bfd_indx++)
3122 Elf_Internal_Shdr *symtab_hdr;
3124 /* We'll need the symbol table in a second. */
3125 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3126 if (symtab_hdr->sh_info == 0)
3129 /* We need an array of the local symbols attached to the input bfd. */
3130 local_syms = (Elf_Internal_Sym *) symtab_hdr->contents;
3131 if (local_syms == NULL)
3133 local_syms = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
3134 symtab_hdr->sh_info, 0,
3136 /* Cache them for elf_link_input_bfd. */
3137 symtab_hdr->contents = (unsigned char *) local_syms;
3139 if (local_syms == NULL)
3142 all_local_syms[bfd_indx] = local_syms;
3148 #define ADD_DUMMY_STUBS_FOR_DEBUGGING 0
3151 elf32_avr_size_stubs (bfd *output_bfd,
3152 struct bfd_link_info *info,
3153 bfd_boolean is_prealloc_run)
3155 struct elf32_avr_link_hash_table *htab;
3156 int stub_changed = 0;
3158 htab = avr_link_hash_table (info);
3162 /* At this point we initialize htab->vector_base
3163 To the start of the text output section. */
3164 htab->vector_base = htab->stub_sec->output_section->vma;
3166 if (get_local_syms (info->input_bfds, info))
3168 if (htab->all_local_syms)
3169 goto error_ret_free_local;
3173 if (ADD_DUMMY_STUBS_FOR_DEBUGGING)
3175 struct elf32_avr_stub_hash_entry *test;
3177 test = avr_add_stub ("Hugo",htab);
3178 test->target_value = 0x123456;
3179 test->stub_offset = 13;
3181 test = avr_add_stub ("Hugo2",htab);
3182 test->target_value = 0x84210;
3183 test->stub_offset = 14;
3189 unsigned int bfd_indx;
3191 /* We will have to re-generate the stub hash table each time anything
3192 in memory has changed. */
3194 bfd_hash_traverse (&htab->bstab, avr_mark_stub_not_to_be_necessary, htab);
3195 for (input_bfd = info->input_bfds, bfd_indx = 0;
3197 input_bfd = input_bfd->link.next, bfd_indx++)
3199 Elf_Internal_Shdr *symtab_hdr;
3201 Elf_Internal_Sym *local_syms;
3203 /* We'll need the symbol table in a second. */
3204 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3205 if (symtab_hdr->sh_info == 0)
3208 local_syms = htab->all_local_syms[bfd_indx];
3210 /* Walk over each section attached to the input bfd. */
3211 for (section = input_bfd->sections;
3213 section = section->next)
3215 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
3217 /* If there aren't any relocs, then there's nothing more
3219 if ((section->flags & SEC_RELOC) == 0
3220 || section->reloc_count == 0)
3223 /* If this section is a link-once section that will be
3224 discarded, then don't create any stubs. */
3225 if (section->output_section == NULL
3226 || section->output_section->owner != output_bfd)
3229 /* Get the relocs. */
3231 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
3233 if (internal_relocs == NULL)
3234 goto error_ret_free_local;
3236 /* Now examine each relocation. */
3237 irela = internal_relocs;
3238 irelaend = irela + section->reloc_count;
3239 for (; irela < irelaend; irela++)
3241 unsigned int r_type, r_indx;
3242 struct elf32_avr_stub_hash_entry *hsh;
3245 bfd_vma destination;
3246 struct elf_link_hash_entry *hh;
3249 r_type = ELF32_R_TYPE (irela->r_info);
3250 r_indx = ELF32_R_SYM (irela->r_info);
3252 /* Only look for 16 bit GS relocs. No other reloc will need a
3254 if (!((r_type == R_AVR_16_PM)
3255 || (r_type == R_AVR_LO8_LDI_GS)
3256 || (r_type == R_AVR_HI8_LDI_GS)))
3259 /* Now determine the call target, its name, value,
3265 if (r_indx < symtab_hdr->sh_info)
3267 /* It's a local symbol. */
3268 Elf_Internal_Sym *sym;
3269 Elf_Internal_Shdr *hdr;
3272 sym = local_syms + r_indx;
3273 if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
3274 sym_value = sym->st_value;
3275 shndx = sym->st_shndx;
3276 if (shndx < elf_numsections (input_bfd))
3278 hdr = elf_elfsections (input_bfd)[shndx];
3279 sym_sec = hdr->bfd_section;
3280 destination = (sym_value + irela->r_addend
3281 + sym_sec->output_offset
3282 + sym_sec->output_section->vma);
3287 /* It's an external symbol. */
3290 e_indx = r_indx - symtab_hdr->sh_info;
3291 hh = elf_sym_hashes (input_bfd)[e_indx];
3293 while (hh->root.type == bfd_link_hash_indirect
3294 || hh->root.type == bfd_link_hash_warning)
3295 hh = (struct elf_link_hash_entry *)
3296 (hh->root.u.i.link);
3298 if (hh->root.type == bfd_link_hash_defined
3299 || hh->root.type == bfd_link_hash_defweak)
3301 sym_sec = hh->root.u.def.section;
3302 sym_value = hh->root.u.def.value;
3303 if (sym_sec->output_section != NULL)
3304 destination = (sym_value + irela->r_addend
3305 + sym_sec->output_offset
3306 + sym_sec->output_section->vma);
3308 else if (hh->root.type == bfd_link_hash_undefweak)
3313 else if (hh->root.type == bfd_link_hash_undefined)
3315 if (! (info->unresolved_syms_in_objects == RM_IGNORE
3316 && (ELF_ST_VISIBILITY (hh->other)
3322 bfd_set_error (bfd_error_bad_value);
3324 error_ret_free_internal:
3325 if (elf_section_data (section)->relocs == NULL)
3326 free (internal_relocs);
3327 goto error_ret_free_local;
3331 if (! avr_stub_is_required_for_16_bit_reloc
3332 (destination - htab->vector_base))
3334 if (!is_prealloc_run)
3335 /* We are having a reloc that does't need a stub. */
3338 /* We don't right now know if a stub will be needed.
3339 Let's rather be on the safe side. */
3342 /* Get the name of this stub. */
3343 stub_name = avr_stub_name (sym_sec, sym_value, irela);
3346 goto error_ret_free_internal;
3349 hsh = avr_stub_hash_lookup (&htab->bstab,
3354 /* The proper stub has already been created. Mark it
3355 to be used and write the possibly changed destination
3357 hsh->is_actually_needed = TRUE;
3358 hsh->target_value = destination;
3363 hsh = avr_add_stub (stub_name, htab);
3367 goto error_ret_free_internal;
3370 hsh->is_actually_needed = TRUE;
3371 hsh->target_value = destination;
3374 printf ("Adding stub with destination 0x%x to the"
3375 " hash table.\n", (unsigned int) destination);
3377 printf ("(Pre-Alloc run: %i)\n", is_prealloc_run);
3379 stub_changed = TRUE;
3382 /* We're done with the internal relocs, free them. */
3383 if (elf_section_data (section)->relocs == NULL)
3384 free (internal_relocs);
3388 /* Re-Calculate the number of needed stubs. */
3389 htab->stub_sec->size = 0;
3390 bfd_hash_traverse (&htab->bstab, avr_size_one_stub, htab);
3395 stub_changed = FALSE;
3398 free (htab->all_local_syms);
3401 error_ret_free_local:
3402 free (htab->all_local_syms);
3407 /* Build all the stubs associated with the current output file. The
3408 stubs are kept in a hash table attached to the main linker hash
3409 table. We also set up the .plt entries for statically linked PIC
3410 functions here. This function is called via hppaelf_finish in the
3414 elf32_avr_build_stubs (struct bfd_link_info *info)
3417 struct bfd_hash_table *table;
3418 struct elf32_avr_link_hash_table *htab;
3419 bfd_size_type total_size = 0;
3421 htab = avr_link_hash_table (info);
3425 /* In case that there were several stub sections: */
3426 for (stub_sec = htab->stub_bfd->sections;
3428 stub_sec = stub_sec->next)
3432 /* Allocate memory to hold the linker stubs. */
3433 size = stub_sec->size;
3436 stub_sec->contents = bfd_zalloc (htab->stub_bfd, size);
3437 if (stub_sec->contents == NULL && size != 0)
3442 /* Allocate memory for the adress mapping table. */
3443 htab->amt_entry_cnt = 0;
3444 htab->amt_max_entry_cnt = total_size / 4;
3445 htab->amt_stub_offsets = bfd_malloc (sizeof (bfd_vma)
3446 * htab->amt_max_entry_cnt);
3447 htab->amt_destination_addr = bfd_malloc (sizeof (bfd_vma)
3448 * htab->amt_max_entry_cnt );
3451 printf ("Allocating %i entries in the AMT\n", htab->amt_max_entry_cnt);
3453 /* Build the stubs as directed by the stub hash table. */
3454 table = &htab->bstab;
3455 bfd_hash_traverse (table, avr_build_one_stub, info);
3458 printf ("Final Stub section Size: %i\n", (int) htab->stub_sec->size);
3463 /* Callback used by QSORT to order relocations AP and BP. */
3466 internal_reloc_compare (const void *ap, const void *bp)
3468 const Elf_Internal_Rela *a = (const Elf_Internal_Rela *) ap;
3469 const Elf_Internal_Rela *b = (const Elf_Internal_Rela *) bp;
3471 if (a->r_offset != b->r_offset)
3472 return (a->r_offset - b->r_offset);
3474 /* We don't need to sort on these criteria for correctness,
3475 but enforcing a more strict ordering prevents unstable qsort
3476 from behaving differently with different implementations.
3477 Without the code below we get correct but different results
3478 on Solaris 2.7 and 2.8. We would like to always produce the
3479 same results no matter the host. */
3481 if (a->r_info != b->r_info)
3482 return (a->r_info - b->r_info);
3484 return (a->r_addend - b->r_addend);
3487 /* Return true if ADDRESS is within the vma range of SECTION from ABFD. */
3490 avr_is_section_for_address (bfd *abfd, asection *section, bfd_vma address)
3495 vma = bfd_get_section_vma (abfd, section);
3499 size = section->size;
3500 if (address >= vma + size)
3506 /* Data structure used by AVR_FIND_SECTION_FOR_ADDRESS. */
3508 struct avr_find_section_data
3510 /* The address we're looking for. */
3513 /* The section we've found. */
3517 /* Helper function to locate the section holding a certain virtual memory
3518 address. This is called via bfd_map_over_sections. The DATA is an
3519 instance of STRUCT AVR_FIND_SECTION_DATA, the address field of which
3520 has been set to the address to search for, and the section field has
3521 been set to NULL. If SECTION from ABFD contains ADDRESS then the
3522 section field in DATA will be set to SECTION. As an optimisation, if
3523 the section field is already non-null then this function does not
3524 perform any checks, and just returns. */
3527 avr_find_section_for_address (bfd *abfd,
3528 asection *section, void *data)
3530 struct avr_find_section_data *fs_data
3531 = (struct avr_find_section_data *) data;
3533 /* Return if already found. */
3534 if (fs_data->section != NULL)
3537 /* If this section isn't part of the addressable code content, skip it. */
3538 if ((bfd_get_section_flags (abfd, section) & SEC_ALLOC) == 0
3539 && (bfd_get_section_flags (abfd, section) & SEC_CODE) == 0)
3542 if (avr_is_section_for_address (abfd, section, fs_data->address))
3543 fs_data->section = section;
3546 /* Load all of the property records from SEC, a section from ABFD. Return
3547 a STRUCT AVR_PROPERTY_RECORD_LIST containing all the records. The
3548 memory for the returned structure, and all of the records pointed too by
3549 the structure are allocated with a single call to malloc, so, only the
3550 pointer returned needs to be free'd. */
3552 static struct avr_property_record_list *
3553 avr_elf32_load_records_from_section (bfd *abfd, asection *sec)
3555 char *contents = NULL, *ptr;
3556 bfd_size_type size, mem_size;
3557 bfd_byte version, flags;
3558 uint16_t record_count, i;
3559 struct avr_property_record_list *r_list = NULL;
3560 Elf_Internal_Rela *internal_relocs = NULL, *rel, *rel_end;
3561 struct avr_find_section_data fs_data;
3563 fs_data.section = NULL;
3565 size = bfd_get_section_size (sec);
3566 contents = bfd_malloc (size);
3567 bfd_get_section_contents (abfd, sec, contents, 0, size);
3570 /* Load the relocations for the '.avr.prop' section if there are any, and
3572 internal_relocs = (_bfd_elf_link_read_relocs
3573 (abfd, sec, NULL, NULL, FALSE));
3574 if (internal_relocs)
3575 qsort (internal_relocs, sec->reloc_count,
3576 sizeof (Elf_Internal_Rela), internal_reloc_compare);
3578 /* There is a header at the start of the property record section SEC, the
3579 format of this header is:
3580 uint8_t : version number
3582 uint16_t : record counter
3585 /* Check we have at least got a headers worth of bytes. */
3586 if (size < AVR_PROPERTY_SECTION_HEADER_SIZE)
3589 version = *((bfd_byte *) ptr);
3591 flags = *((bfd_byte *) ptr);
3593 record_count = *((uint16_t *) ptr);
3595 BFD_ASSERT (ptr - contents == AVR_PROPERTY_SECTION_HEADER_SIZE);
3597 /* Now allocate space for the list structure, and all of the list
3598 elements in a single block. */
3599 mem_size = sizeof (struct avr_property_record_list)
3600 + sizeof (struct avr_property_record) * record_count;
3601 r_list = bfd_malloc (mem_size);
3605 r_list->version = version;
3606 r_list->flags = flags;
3607 r_list->section = sec;
3608 r_list->record_count = record_count;
3609 r_list->records = (struct avr_property_record *) (&r_list [1]);
3610 size -= AVR_PROPERTY_SECTION_HEADER_SIZE;
3612 /* Check that we understand the version number. There is only one
3613 version number right now, anything else is an error. */
3614 if (r_list->version != AVR_PROPERTY_RECORDS_VERSION)
3617 rel = internal_relocs;
3618 rel_end = rel + sec->reloc_count;
3619 for (i = 0; i < record_count; ++i)
3623 /* Each entry is a 32-bit address, followed by a single byte type.
3624 After that is the type specific data. We must take care to
3625 ensure that we don't read beyond the end of the section data. */
3629 r_list->records [i].section = NULL;
3630 r_list->records [i].offset = 0;
3634 /* The offset of the address within the .avr.prop section. */
3635 size_t offset = ptr - contents;
3637 while (rel < rel_end && rel->r_offset < offset)
3642 else if (rel->r_offset == offset)
3644 /* Find section and section offset. */
3645 unsigned long r_symndx;
3650 r_symndx = ELF32_R_SYM (rel->r_info);
3651 rel_sec = get_elf_r_symndx_section (abfd, r_symndx);
3652 sec_offset = get_elf_r_symndx_offset (abfd, r_symndx)
3655 r_list->records [i].section = rel_sec;
3656 r_list->records [i].offset = sec_offset;
3660 address = *((uint32_t *) ptr);
3664 if (r_list->records [i].section == NULL)
3666 /* Try to find section and offset from address. */
3667 if (fs_data.section != NULL
3668 && !avr_is_section_for_address (abfd, fs_data.section,
3670 fs_data.section = NULL;
3672 if (fs_data.section == NULL)
3674 fs_data.address = address;
3675 bfd_map_over_sections (abfd, avr_find_section_for_address,
3679 if (fs_data.section == NULL)
3681 fprintf (stderr, "Failed to find matching section.\n");
3685 r_list->records [i].section = fs_data.section;
3686 r_list->records [i].offset
3687 = address - bfd_get_section_vma (abfd, fs_data.section);
3690 r_list->records [i].type = *((bfd_byte *) ptr);
3694 switch (r_list->records [i].type)
3697 /* Nothing else to load. */
3699 case RECORD_ORG_AND_FILL:
3700 /* Just a 4-byte fill to load. */
3703 r_list->records [i].data.org.fill = *((uint32_t *) ptr);
3708 /* Just a 4-byte alignment to load. */
3711 r_list->records [i].data.align.bytes = *((uint32_t *) ptr);
3714 /* Just initialise PRECEDING_DELETED field, this field is
3715 used during linker relaxation. */
3716 r_list->records [i].data.align.preceding_deleted = 0;
3718 case RECORD_ALIGN_AND_FILL:
3719 /* A 4-byte alignment, and a 4-byte fill to load. */
3722 r_list->records [i].data.align.bytes = *((uint32_t *) ptr);
3724 r_list->records [i].data.align.fill = *((uint32_t *) ptr);
3727 /* Just initialise PRECEDING_DELETED field, this field is
3728 used during linker relaxation. */
3729 r_list->records [i].data.align.preceding_deleted = 0;
3737 free (internal_relocs);
3741 free (internal_relocs);
3747 /* Load all of the property records from ABFD. See
3748 AVR_ELF32_LOAD_RECORDS_FROM_SECTION for details of the return value. */
3750 struct avr_property_record_list *
3751 avr_elf32_load_property_records (bfd *abfd)
3755 /* Find the '.avr.prop' section and load the contents into memory. */
3756 sec = bfd_get_section_by_name (abfd, AVR_PROPERTY_RECORD_SECTION_NAME);
3759 return avr_elf32_load_records_from_section (abfd, sec);
3763 avr_elf32_property_record_name (struct avr_property_record *rec)
3772 case RECORD_ORG_AND_FILL:
3778 case RECORD_ALIGN_AND_FILL:
3789 #define ELF_ARCH bfd_arch_avr
3790 #define ELF_TARGET_ID AVR_ELF_DATA
3791 #define ELF_MACHINE_CODE EM_AVR
3792 #define ELF_MACHINE_ALT1 EM_AVR_OLD
3793 #define ELF_MAXPAGESIZE 1
3795 #define TARGET_LITTLE_SYM avr_elf32_vec
3796 #define TARGET_LITTLE_NAME "elf32-avr"
3798 #define bfd_elf32_bfd_link_hash_table_create elf32_avr_link_hash_table_create
3800 #define elf_info_to_howto avr_info_to_howto_rela
3801 #define elf_info_to_howto_rel NULL
3802 #define elf_backend_relocate_section elf32_avr_relocate_section
3803 #define elf_backend_can_gc_sections 1
3804 #define elf_backend_rela_normal 1
3805 #define elf_backend_final_write_processing \
3806 bfd_elf_avr_final_write_processing
3807 #define elf_backend_object_p elf32_avr_object_p
3809 #define bfd_elf32_bfd_relax_section elf32_avr_relax_section
3810 #define bfd_elf32_bfd_get_relocated_section_contents \
3811 elf32_avr_get_relocated_section_contents
3813 #include "elf32-target.h"