1 /* AVR-specific support for 32-bit ELF
2 Copyright (C) 1999-2014 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"
29 /* Enable debugging printout at stdout with this variable. */
30 static bfd_boolean debug_relax = FALSE;
32 /* Enable debugging printout at stdout with this variable. */
33 static bfd_boolean debug_stubs = FALSE;
35 static bfd_reloc_status_type
36 bfd_elf_avr_diff_reloc (bfd *, arelent *, asymbol *, void *,
37 asection *, bfd *, char **);
39 /* Hash table initialization and handling. Code is taken from the hppa port
40 and adapted to the needs of AVR. */
42 /* We use two hash tables to hold information for linking avr objects.
44 The first is the elf32_avr_link_hash_table which is derived from the
45 stanard ELF linker hash table. We use this as a place to attach the other
46 hash table and some static information.
48 The second is the stub hash table which is derived from the base BFD
49 hash table. The stub hash table holds the information on the linker
52 struct elf32_avr_stub_hash_entry
54 /* Base hash table entry structure. */
55 struct bfd_hash_entry bh_root;
57 /* Offset within stub_sec of the beginning of this stub. */
60 /* Given the symbol's value and its section we can determine its final
61 value when building the stubs (so the stub knows where to jump). */
64 /* This way we could mark stubs to be no longer necessary. */
65 bfd_boolean is_actually_needed;
68 struct elf32_avr_link_hash_table
70 /* The main hash table. */
71 struct elf_link_hash_table etab;
73 /* The stub hash table. */
74 struct bfd_hash_table bstab;
78 /* Linker stub bfd. */
81 /* The stub section. */
84 /* Usually 0, unless we are generating code for a bootloader. Will
85 be initialized by elf32_avr_size_stubs to the vma offset of the
86 output section associated with the stub section. */
89 /* Assorted information used by elf32_avr_size_stubs. */
90 unsigned int bfd_count;
92 asection ** input_list;
93 Elf_Internal_Sym ** all_local_syms;
95 /* Tables for mapping vma beyond the 128k boundary to the address of the
96 corresponding stub. (AMT)
97 "amt_max_entry_cnt" reflects the number of entries that memory is allocated
98 for in the "amt_stub_offsets" and "amt_destination_addr" arrays.
99 "amt_entry_cnt" informs how many of these entries actually contain
101 unsigned int amt_entry_cnt;
102 unsigned int amt_max_entry_cnt;
103 bfd_vma * amt_stub_offsets;
104 bfd_vma * amt_destination_addr;
107 /* Various hash macros and functions. */
108 #define avr_link_hash_table(p) \
109 /* PR 3874: Check that we have an AVR style hash table before using it. */\
110 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
111 == AVR_ELF_DATA ? ((struct elf32_avr_link_hash_table *) ((p)->hash)) : NULL)
113 #define avr_stub_hash_entry(ent) \
114 ((struct elf32_avr_stub_hash_entry *)(ent))
116 #define avr_stub_hash_lookup(table, string, create, copy) \
117 ((struct elf32_avr_stub_hash_entry *) \
118 bfd_hash_lookup ((table), (string), (create), (copy)))
120 static reloc_howto_type elf_avr_howto_table[] =
122 HOWTO (R_AVR_NONE, /* type */
124 2, /* size (0 = byte, 1 = short, 2 = long) */
126 FALSE, /* pc_relative */
128 complain_overflow_bitfield, /* complain_on_overflow */
129 bfd_elf_generic_reloc, /* special_function */
130 "R_AVR_NONE", /* name */
131 FALSE, /* partial_inplace */
134 FALSE), /* pcrel_offset */
136 HOWTO (R_AVR_32, /* type */
138 2, /* size (0 = byte, 1 = short, 2 = long) */
140 FALSE, /* pc_relative */
142 complain_overflow_bitfield, /* complain_on_overflow */
143 bfd_elf_generic_reloc, /* special_function */
144 "R_AVR_32", /* name */
145 FALSE, /* partial_inplace */
146 0xffffffff, /* src_mask */
147 0xffffffff, /* dst_mask */
148 FALSE), /* pcrel_offset */
150 /* A 7 bit PC relative relocation. */
151 HOWTO (R_AVR_7_PCREL, /* type */
153 1, /* size (0 = byte, 1 = short, 2 = long) */
155 TRUE, /* pc_relative */
157 complain_overflow_bitfield, /* complain_on_overflow */
158 bfd_elf_generic_reloc, /* special_function */
159 "R_AVR_7_PCREL", /* name */
160 FALSE, /* partial_inplace */
161 0xffff, /* src_mask */
162 0xffff, /* dst_mask */
163 TRUE), /* pcrel_offset */
165 /* A 13 bit PC relative relocation. */
166 HOWTO (R_AVR_13_PCREL, /* type */
168 1, /* size (0 = byte, 1 = short, 2 = long) */
170 TRUE, /* pc_relative */
172 complain_overflow_bitfield, /* complain_on_overflow */
173 bfd_elf_generic_reloc, /* special_function */
174 "R_AVR_13_PCREL", /* name */
175 FALSE, /* partial_inplace */
176 0xfff, /* src_mask */
177 0xfff, /* dst_mask */
178 TRUE), /* pcrel_offset */
180 /* A 16 bit absolute relocation. */
181 HOWTO (R_AVR_16, /* type */
183 1, /* size (0 = byte, 1 = short, 2 = long) */
185 FALSE, /* pc_relative */
187 complain_overflow_dont, /* complain_on_overflow */
188 bfd_elf_generic_reloc, /* special_function */
189 "R_AVR_16", /* name */
190 FALSE, /* partial_inplace */
191 0xffff, /* src_mask */
192 0xffff, /* dst_mask */
193 FALSE), /* pcrel_offset */
195 /* A 16 bit absolute relocation for command address
196 Will be changed when linker stubs are needed. */
197 HOWTO (R_AVR_16_PM, /* type */
199 1, /* size (0 = byte, 1 = short, 2 = long) */
201 FALSE, /* pc_relative */
203 complain_overflow_bitfield, /* complain_on_overflow */
204 bfd_elf_generic_reloc, /* special_function */
205 "R_AVR_16_PM", /* name */
206 FALSE, /* partial_inplace */
207 0xffff, /* src_mask */
208 0xffff, /* dst_mask */
209 FALSE), /* pcrel_offset */
210 /* A low 8 bit absolute relocation of 16 bit address.
212 HOWTO (R_AVR_LO8_LDI, /* type */
214 1, /* size (0 = byte, 1 = short, 2 = long) */
216 FALSE, /* pc_relative */
218 complain_overflow_dont, /* complain_on_overflow */
219 bfd_elf_generic_reloc, /* special_function */
220 "R_AVR_LO8_LDI", /* name */
221 FALSE, /* partial_inplace */
222 0xffff, /* src_mask */
223 0xffff, /* dst_mask */
224 FALSE), /* pcrel_offset */
225 /* A high 8 bit absolute relocation of 16 bit address.
227 HOWTO (R_AVR_HI8_LDI, /* type */
229 1, /* size (0 = byte, 1 = short, 2 = long) */
231 FALSE, /* pc_relative */
233 complain_overflow_dont, /* complain_on_overflow */
234 bfd_elf_generic_reloc, /* special_function */
235 "R_AVR_HI8_LDI", /* name */
236 FALSE, /* partial_inplace */
237 0xffff, /* src_mask */
238 0xffff, /* dst_mask */
239 FALSE), /* pcrel_offset */
240 /* A high 6 bit absolute relocation of 22 bit address.
241 For LDI command. As well second most significant 8 bit value of
242 a 32 bit link-time constant. */
243 HOWTO (R_AVR_HH8_LDI, /* type */
245 1, /* size (0 = byte, 1 = short, 2 = long) */
247 FALSE, /* pc_relative */
249 complain_overflow_dont, /* complain_on_overflow */
250 bfd_elf_generic_reloc, /* special_function */
251 "R_AVR_HH8_LDI", /* name */
252 FALSE, /* partial_inplace */
253 0xffff, /* src_mask */
254 0xffff, /* dst_mask */
255 FALSE), /* pcrel_offset */
256 /* A negative low 8 bit absolute relocation of 16 bit address.
258 HOWTO (R_AVR_LO8_LDI_NEG, /* type */
260 1, /* size (0 = byte, 1 = short, 2 = long) */
262 FALSE, /* pc_relative */
264 complain_overflow_dont, /* complain_on_overflow */
265 bfd_elf_generic_reloc, /* special_function */
266 "R_AVR_LO8_LDI_NEG", /* name */
267 FALSE, /* partial_inplace */
268 0xffff, /* src_mask */
269 0xffff, /* dst_mask */
270 FALSE), /* pcrel_offset */
271 /* A negative high 8 bit absolute relocation of 16 bit address.
273 HOWTO (R_AVR_HI8_LDI_NEG, /* type */
275 1, /* size (0 = byte, 1 = short, 2 = long) */
277 FALSE, /* pc_relative */
279 complain_overflow_dont, /* complain_on_overflow */
280 bfd_elf_generic_reloc, /* special_function */
281 "R_AVR_HI8_LDI_NEG", /* name */
282 FALSE, /* partial_inplace */
283 0xffff, /* src_mask */
284 0xffff, /* dst_mask */
285 FALSE), /* pcrel_offset */
286 /* A negative high 6 bit absolute relocation of 22 bit address.
288 HOWTO (R_AVR_HH8_LDI_NEG, /* type */
290 1, /* size (0 = byte, 1 = short, 2 = long) */
292 FALSE, /* pc_relative */
294 complain_overflow_dont, /* complain_on_overflow */
295 bfd_elf_generic_reloc, /* special_function */
296 "R_AVR_HH8_LDI_NEG", /* name */
297 FALSE, /* partial_inplace */
298 0xffff, /* src_mask */
299 0xffff, /* dst_mask */
300 FALSE), /* pcrel_offset */
301 /* A low 8 bit absolute relocation of 24 bit program memory address.
302 For LDI command. Will not be changed when linker stubs are needed. */
303 HOWTO (R_AVR_LO8_LDI_PM, /* type */
305 1, /* size (0 = byte, 1 = short, 2 = long) */
307 FALSE, /* pc_relative */
309 complain_overflow_dont, /* complain_on_overflow */
310 bfd_elf_generic_reloc, /* special_function */
311 "R_AVR_LO8_LDI_PM", /* name */
312 FALSE, /* partial_inplace */
313 0xffff, /* src_mask */
314 0xffff, /* dst_mask */
315 FALSE), /* pcrel_offset */
316 /* A low 8 bit absolute relocation of 24 bit program memory address.
317 For LDI command. Will not be changed when linker stubs are needed. */
318 HOWTO (R_AVR_HI8_LDI_PM, /* type */
320 1, /* size (0 = byte, 1 = short, 2 = long) */
322 FALSE, /* pc_relative */
324 complain_overflow_dont, /* complain_on_overflow */
325 bfd_elf_generic_reloc, /* special_function */
326 "R_AVR_HI8_LDI_PM", /* name */
327 FALSE, /* partial_inplace */
328 0xffff, /* src_mask */
329 0xffff, /* dst_mask */
330 FALSE), /* pcrel_offset */
331 /* A low 8 bit absolute relocation of 24 bit program memory address.
332 For LDI command. Will not be changed when linker stubs are needed. */
333 HOWTO (R_AVR_HH8_LDI_PM, /* type */
335 1, /* size (0 = byte, 1 = short, 2 = long) */
337 FALSE, /* pc_relative */
339 complain_overflow_dont, /* complain_on_overflow */
340 bfd_elf_generic_reloc, /* special_function */
341 "R_AVR_HH8_LDI_PM", /* name */
342 FALSE, /* partial_inplace */
343 0xffff, /* src_mask */
344 0xffff, /* dst_mask */
345 FALSE), /* pcrel_offset */
346 /* A low 8 bit absolute relocation of 24 bit program memory address.
347 For LDI command. Will not be changed when linker stubs are needed. */
348 HOWTO (R_AVR_LO8_LDI_PM_NEG, /* type */
350 1, /* size (0 = byte, 1 = short, 2 = long) */
352 FALSE, /* pc_relative */
354 complain_overflow_dont, /* complain_on_overflow */
355 bfd_elf_generic_reloc, /* special_function */
356 "R_AVR_LO8_LDI_PM_NEG", /* name */
357 FALSE, /* partial_inplace */
358 0xffff, /* src_mask */
359 0xffff, /* dst_mask */
360 FALSE), /* pcrel_offset */
361 /* A low 8 bit absolute relocation of 24 bit program memory address.
362 For LDI command. Will not be changed when linker stubs are needed. */
363 HOWTO (R_AVR_HI8_LDI_PM_NEG, /* type */
365 1, /* size (0 = byte, 1 = short, 2 = long) */
367 FALSE, /* pc_relative */
369 complain_overflow_dont, /* complain_on_overflow */
370 bfd_elf_generic_reloc, /* special_function */
371 "R_AVR_HI8_LDI_PM_NEG", /* name */
372 FALSE, /* partial_inplace */
373 0xffff, /* src_mask */
374 0xffff, /* dst_mask */
375 FALSE), /* pcrel_offset */
376 /* A low 8 bit absolute relocation of 24 bit program memory address.
377 For LDI command. Will not be changed when linker stubs are needed. */
378 HOWTO (R_AVR_HH8_LDI_PM_NEG, /* type */
380 1, /* size (0 = byte, 1 = short, 2 = long) */
382 FALSE, /* pc_relative */
384 complain_overflow_dont, /* complain_on_overflow */
385 bfd_elf_generic_reloc, /* special_function */
386 "R_AVR_HH8_LDI_PM_NEG", /* name */
387 FALSE, /* partial_inplace */
388 0xffff, /* src_mask */
389 0xffff, /* dst_mask */
390 FALSE), /* pcrel_offset */
391 /* Relocation for CALL command in ATmega. */
392 HOWTO (R_AVR_CALL, /* type */
394 2, /* size (0 = byte, 1 = short, 2 = long) */
396 FALSE, /* pc_relative */
398 complain_overflow_dont,/* complain_on_overflow */
399 bfd_elf_generic_reloc, /* special_function */
400 "R_AVR_CALL", /* name */
401 FALSE, /* partial_inplace */
402 0xffffffff, /* src_mask */
403 0xffffffff, /* dst_mask */
404 FALSE), /* pcrel_offset */
405 /* A 16 bit absolute relocation of 16 bit address.
407 HOWTO (R_AVR_LDI, /* type */
409 1, /* size (0 = byte, 1 = short, 2 = long) */
411 FALSE, /* pc_relative */
413 complain_overflow_dont,/* complain_on_overflow */
414 bfd_elf_generic_reloc, /* special_function */
415 "R_AVR_LDI", /* name */
416 FALSE, /* partial_inplace */
417 0xffff, /* src_mask */
418 0xffff, /* dst_mask */
419 FALSE), /* pcrel_offset */
420 /* A 6 bit absolute relocation of 6 bit offset.
421 For ldd/sdd command. */
422 HOWTO (R_AVR_6, /* type */
424 0, /* size (0 = byte, 1 = short, 2 = long) */
426 FALSE, /* pc_relative */
428 complain_overflow_dont,/* complain_on_overflow */
429 bfd_elf_generic_reloc, /* special_function */
430 "R_AVR_6", /* name */
431 FALSE, /* partial_inplace */
432 0xffff, /* src_mask */
433 0xffff, /* dst_mask */
434 FALSE), /* pcrel_offset */
435 /* A 6 bit absolute relocation of 6 bit offset.
436 For sbiw/adiw command. */
437 HOWTO (R_AVR_6_ADIW, /* type */
439 0, /* size (0 = byte, 1 = short, 2 = long) */
441 FALSE, /* pc_relative */
443 complain_overflow_dont,/* complain_on_overflow */
444 bfd_elf_generic_reloc, /* special_function */
445 "R_AVR_6_ADIW", /* name */
446 FALSE, /* partial_inplace */
447 0xffff, /* src_mask */
448 0xffff, /* dst_mask */
449 FALSE), /* pcrel_offset */
450 /* Most significant 8 bit value of a 32 bit link-time constant. */
451 HOWTO (R_AVR_MS8_LDI, /* type */
453 1, /* size (0 = byte, 1 = short, 2 = long) */
455 FALSE, /* pc_relative */
457 complain_overflow_dont, /* complain_on_overflow */
458 bfd_elf_generic_reloc, /* special_function */
459 "R_AVR_MS8_LDI", /* name */
460 FALSE, /* partial_inplace */
461 0xffff, /* src_mask */
462 0xffff, /* dst_mask */
463 FALSE), /* pcrel_offset */
464 /* Negative most significant 8 bit value of a 32 bit link-time constant. */
465 HOWTO (R_AVR_MS8_LDI_NEG, /* type */
467 1, /* size (0 = byte, 1 = short, 2 = long) */
469 FALSE, /* pc_relative */
471 complain_overflow_dont, /* complain_on_overflow */
472 bfd_elf_generic_reloc, /* special_function */
473 "R_AVR_MS8_LDI_NEG", /* name */
474 FALSE, /* partial_inplace */
475 0xffff, /* src_mask */
476 0xffff, /* dst_mask */
477 FALSE), /* pcrel_offset */
478 /* A low 8 bit absolute relocation of 24 bit program memory address.
479 For LDI command. Will be changed when linker stubs are needed. */
480 HOWTO (R_AVR_LO8_LDI_GS, /* type */
482 1, /* size (0 = byte, 1 = short, 2 = long) */
484 FALSE, /* pc_relative */
486 complain_overflow_dont, /* complain_on_overflow */
487 bfd_elf_generic_reloc, /* special_function */
488 "R_AVR_LO8_LDI_GS", /* name */
489 FALSE, /* partial_inplace */
490 0xffff, /* src_mask */
491 0xffff, /* dst_mask */
492 FALSE), /* pcrel_offset */
493 /* A low 8 bit absolute relocation of 24 bit program memory address.
494 For LDI command. Will be changed when linker stubs are needed. */
495 HOWTO (R_AVR_HI8_LDI_GS, /* type */
497 1, /* size (0 = byte, 1 = short, 2 = long) */
499 FALSE, /* pc_relative */
501 complain_overflow_dont, /* complain_on_overflow */
502 bfd_elf_generic_reloc, /* special_function */
503 "R_AVR_HI8_LDI_GS", /* name */
504 FALSE, /* partial_inplace */
505 0xffff, /* src_mask */
506 0xffff, /* dst_mask */
507 FALSE), /* pcrel_offset */
509 HOWTO (R_AVR_8, /* type */
511 0, /* size (0 = byte, 1 = short, 2 = long) */
513 FALSE, /* pc_relative */
515 complain_overflow_bitfield,/* complain_on_overflow */
516 bfd_elf_generic_reloc, /* special_function */
517 "R_AVR_8", /* name */
518 FALSE, /* partial_inplace */
519 0x000000ff, /* src_mask */
520 0x000000ff, /* dst_mask */
521 FALSE), /* pcrel_offset */
522 /* lo8-part to use in .byte lo8(sym). */
523 HOWTO (R_AVR_8_LO8, /* type */
525 0, /* size (0 = byte, 1 = short, 2 = long) */
527 FALSE, /* pc_relative */
529 complain_overflow_dont,/* complain_on_overflow */
530 bfd_elf_generic_reloc, /* special_function */
531 "R_AVR_8_LO8", /* name */
532 FALSE, /* partial_inplace */
533 0xffffff, /* src_mask */
534 0xffffff, /* dst_mask */
535 FALSE), /* pcrel_offset */
536 /* hi8-part to use in .byte hi8(sym). */
537 HOWTO (R_AVR_8_HI8, /* type */
539 0, /* size (0 = byte, 1 = short, 2 = long) */
541 FALSE, /* pc_relative */
543 complain_overflow_dont,/* complain_on_overflow */
544 bfd_elf_generic_reloc, /* special_function */
545 "R_AVR_8_HI8", /* name */
546 FALSE, /* partial_inplace */
547 0xffffff, /* src_mask */
548 0xffffff, /* dst_mask */
549 FALSE), /* pcrel_offset */
550 /* hlo8-part to use in .byte hlo8(sym). */
551 HOWTO (R_AVR_8_HLO8, /* type */
553 0, /* size (0 = byte, 1 = short, 2 = long) */
555 FALSE, /* pc_relative */
557 complain_overflow_dont,/* complain_on_overflow */
558 bfd_elf_generic_reloc, /* special_function */
559 "R_AVR_8_HLO8", /* name */
560 FALSE, /* partial_inplace */
561 0xffffff, /* src_mask */
562 0xffffff, /* dst_mask */
563 FALSE), /* pcrel_offset */
564 HOWTO (R_AVR_DIFF8, /* type */
566 0, /* size (0 = byte, 1 = short, 2 = long) */
568 FALSE, /* pc_relative */
570 complain_overflow_bitfield, /* complain_on_overflow */
571 bfd_elf_avr_diff_reloc, /* special_function */
572 "R_AVR_DIFF8", /* name */
573 FALSE, /* partial_inplace */
576 FALSE), /* pcrel_offset */
577 HOWTO (R_AVR_DIFF16, /* type */
579 1, /* size (0 = byte, 1 = short, 2 = long) */
581 FALSE, /* pc_relative */
583 complain_overflow_bitfield, /* complain_on_overflow */
584 bfd_elf_avr_diff_reloc,/* special_function */
585 "R_AVR_DIFF16", /* name */
586 FALSE, /* partial_inplace */
588 0xffff, /* dst_mask */
589 FALSE), /* pcrel_offset */
590 HOWTO (R_AVR_DIFF32, /* type */
592 2, /* size (0 = byte, 1 = short, 2 = long) */
594 FALSE, /* pc_relative */
596 complain_overflow_bitfield, /* complain_on_overflow */
597 bfd_elf_avr_diff_reloc,/* special_function */
598 "R_AVR_DIFF32", /* name */
599 FALSE, /* partial_inplace */
601 0xffffffff, /* dst_mask */
602 FALSE), /* pcrel_offset */
603 /* 7 bit immediate for LDS/STS in Tiny core. */
604 HOWTO (R_AVR_LDS_STS_16, /* type */
606 1, /* size (0 = byte, 1 = short, 2 = long) */
608 FALSE, /* pc_relative */
610 complain_overflow_dont,/* complain_on_overflow */
611 bfd_elf_generic_reloc, /* special_function */
612 "R_AVR_LDS_STS_16", /* name */
613 FALSE, /* partial_inplace */
614 0xffff, /* src_mask */
615 0xffff, /* dst_mask */
616 FALSE), /* pcrel_offset */
618 HOWTO (R_AVR_PORT6, /* type */
620 0, /* size (0 = byte, 1 = short, 2 = long) */
622 FALSE, /* pc_relative */
624 complain_overflow_dont,/* complain_on_overflow */
625 bfd_elf_generic_reloc, /* special_function */
626 "R_AVR_PORT6", /* name */
627 FALSE, /* partial_inplace */
628 0xffffff, /* src_mask */
629 0xffffff, /* dst_mask */
630 FALSE), /* pcrel_offset */
631 HOWTO (R_AVR_PORT5, /* type */
633 0, /* size (0 = byte, 1 = short, 2 = long) */
635 FALSE, /* pc_relative */
637 complain_overflow_dont,/* complain_on_overflow */
638 bfd_elf_generic_reloc, /* special_function */
639 "R_AVR_PORT5", /* name */
640 FALSE, /* partial_inplace */
641 0xffffff, /* src_mask */
642 0xffffff, /* dst_mask */
643 FALSE) /* pcrel_offset */
646 /* Map BFD reloc types to AVR ELF reloc types. */
650 bfd_reloc_code_real_type bfd_reloc_val;
651 unsigned int elf_reloc_val;
654 static const struct avr_reloc_map avr_reloc_map[] =
656 { BFD_RELOC_NONE, R_AVR_NONE },
657 { BFD_RELOC_32, R_AVR_32 },
658 { BFD_RELOC_AVR_7_PCREL, R_AVR_7_PCREL },
659 { BFD_RELOC_AVR_13_PCREL, R_AVR_13_PCREL },
660 { BFD_RELOC_16, R_AVR_16 },
661 { BFD_RELOC_AVR_16_PM, R_AVR_16_PM },
662 { BFD_RELOC_AVR_LO8_LDI, R_AVR_LO8_LDI},
663 { BFD_RELOC_AVR_HI8_LDI, R_AVR_HI8_LDI },
664 { BFD_RELOC_AVR_HH8_LDI, R_AVR_HH8_LDI },
665 { BFD_RELOC_AVR_MS8_LDI, R_AVR_MS8_LDI },
666 { BFD_RELOC_AVR_LO8_LDI_NEG, R_AVR_LO8_LDI_NEG },
667 { BFD_RELOC_AVR_HI8_LDI_NEG, R_AVR_HI8_LDI_NEG },
668 { BFD_RELOC_AVR_HH8_LDI_NEG, R_AVR_HH8_LDI_NEG },
669 { BFD_RELOC_AVR_MS8_LDI_NEG, R_AVR_MS8_LDI_NEG },
670 { BFD_RELOC_AVR_LO8_LDI_PM, R_AVR_LO8_LDI_PM },
671 { BFD_RELOC_AVR_LO8_LDI_GS, R_AVR_LO8_LDI_GS },
672 { BFD_RELOC_AVR_HI8_LDI_PM, R_AVR_HI8_LDI_PM },
673 { BFD_RELOC_AVR_HI8_LDI_GS, R_AVR_HI8_LDI_GS },
674 { BFD_RELOC_AVR_HH8_LDI_PM, R_AVR_HH8_LDI_PM },
675 { BFD_RELOC_AVR_LO8_LDI_PM_NEG, R_AVR_LO8_LDI_PM_NEG },
676 { BFD_RELOC_AVR_HI8_LDI_PM_NEG, R_AVR_HI8_LDI_PM_NEG },
677 { BFD_RELOC_AVR_HH8_LDI_PM_NEG, R_AVR_HH8_LDI_PM_NEG },
678 { BFD_RELOC_AVR_CALL, R_AVR_CALL },
679 { BFD_RELOC_AVR_LDI, R_AVR_LDI },
680 { BFD_RELOC_AVR_6, R_AVR_6 },
681 { BFD_RELOC_AVR_6_ADIW, R_AVR_6_ADIW },
682 { BFD_RELOC_8, R_AVR_8 },
683 { BFD_RELOC_AVR_8_LO, R_AVR_8_LO8 },
684 { BFD_RELOC_AVR_8_HI, R_AVR_8_HI8 },
685 { BFD_RELOC_AVR_8_HLO, R_AVR_8_HLO8 },
686 { BFD_RELOC_AVR_DIFF8, R_AVR_DIFF8 },
687 { BFD_RELOC_AVR_DIFF16, R_AVR_DIFF16 },
688 { BFD_RELOC_AVR_DIFF32, R_AVR_DIFF32 },
689 { BFD_RELOC_AVR_LDS_STS_16, R_AVR_LDS_STS_16},
690 { BFD_RELOC_AVR_PORT6, R_AVR_PORT6},
691 { BFD_RELOC_AVR_PORT5, R_AVR_PORT5}
694 /* Meant to be filled one day with the wrap around address for the
695 specific device. I.e. should get the value 0x4000 for 16k devices,
696 0x8000 for 32k devices and so on.
698 We initialize it here with a value of 0x1000000 resulting in
699 that we will never suggest a wrap-around jump during relaxation.
700 The logic of the source code later on assumes that in
701 avr_pc_wrap_around one single bit is set. */
702 static bfd_vma avr_pc_wrap_around = 0x10000000;
704 /* If this variable holds a value different from zero, the linker relaxation
705 machine will try to optimize call/ret sequences by a single jump
706 instruction. This option could be switched off by a linker switch. */
707 static int avr_replace_call_ret_sequences = 1;
709 /* Initialize an entry in the stub hash table. */
711 static struct bfd_hash_entry *
712 stub_hash_newfunc (struct bfd_hash_entry *entry,
713 struct bfd_hash_table *table,
716 /* Allocate the structure if it has not already been allocated by a
720 entry = bfd_hash_allocate (table,
721 sizeof (struct elf32_avr_stub_hash_entry));
726 /* Call the allocation method of the superclass. */
727 entry = bfd_hash_newfunc (entry, table, string);
730 struct elf32_avr_stub_hash_entry *hsh;
732 /* Initialize the local fields. */
733 hsh = avr_stub_hash_entry (entry);
734 hsh->stub_offset = 0;
735 hsh->target_value = 0;
741 /* This function is just a straight passthrough to the real
742 function in linker.c. Its prupose is so that its address
743 can be compared inside the avr_link_hash_table macro. */
745 static struct bfd_hash_entry *
746 elf32_avr_link_hash_newfunc (struct bfd_hash_entry * entry,
747 struct bfd_hash_table * table,
750 return _bfd_elf_link_hash_newfunc (entry, table, string);
753 /* Free the derived linker hash table. */
756 elf32_avr_link_hash_table_free (bfd *obfd)
758 struct elf32_avr_link_hash_table *htab
759 = (struct elf32_avr_link_hash_table *) obfd->link.hash;
761 /* Free the address mapping table. */
762 if (htab->amt_stub_offsets != NULL)
763 free (htab->amt_stub_offsets);
764 if (htab->amt_destination_addr != NULL)
765 free (htab->amt_destination_addr);
767 bfd_hash_table_free (&htab->bstab);
768 _bfd_elf_link_hash_table_free (obfd);
771 /* Create the derived linker hash table. The AVR ELF port uses the derived
772 hash table to keep information specific to the AVR ELF linker (without
773 using static variables). */
775 static struct bfd_link_hash_table *
776 elf32_avr_link_hash_table_create (bfd *abfd)
778 struct elf32_avr_link_hash_table *htab;
779 bfd_size_type amt = sizeof (*htab);
781 htab = bfd_zmalloc (amt);
785 if (!_bfd_elf_link_hash_table_init (&htab->etab, abfd,
786 elf32_avr_link_hash_newfunc,
787 sizeof (struct elf_link_hash_entry),
794 /* Init the stub hash table too. */
795 if (!bfd_hash_table_init (&htab->bstab, stub_hash_newfunc,
796 sizeof (struct elf32_avr_stub_hash_entry)))
798 _bfd_elf_link_hash_table_free (abfd);
801 htab->etab.root.hash_table_free = elf32_avr_link_hash_table_free;
803 return &htab->etab.root;
806 /* Calculates the effective distance of a pc relative jump/call. */
809 avr_relative_distance_considering_wrap_around (unsigned int distance)
811 unsigned int wrap_around_mask = avr_pc_wrap_around - 1;
812 int dist_with_wrap_around = distance & wrap_around_mask;
814 if (dist_with_wrap_around > ((int) (avr_pc_wrap_around >> 1)))
815 dist_with_wrap_around -= avr_pc_wrap_around;
817 return dist_with_wrap_around;
821 static reloc_howto_type *
822 bfd_elf32_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
823 bfd_reloc_code_real_type code)
828 i < sizeof (avr_reloc_map) / sizeof (struct avr_reloc_map);
830 if (avr_reloc_map[i].bfd_reloc_val == code)
831 return &elf_avr_howto_table[avr_reloc_map[i].elf_reloc_val];
836 static reloc_howto_type *
837 bfd_elf32_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
843 i < sizeof (elf_avr_howto_table) / sizeof (elf_avr_howto_table[0]);
845 if (elf_avr_howto_table[i].name != NULL
846 && strcasecmp (elf_avr_howto_table[i].name, r_name) == 0)
847 return &elf_avr_howto_table[i];
852 /* Set the howto pointer for an AVR ELF reloc. */
855 avr_info_to_howto_rela (bfd *abfd ATTRIBUTE_UNUSED,
857 Elf_Internal_Rela *dst)
861 r_type = ELF32_R_TYPE (dst->r_info);
862 if (r_type >= (unsigned int) R_AVR_max)
864 _bfd_error_handler (_("%A: invalid AVR reloc number: %d"), abfd, r_type);
867 cache_ptr->howto = &elf_avr_howto_table[r_type];
871 avr_stub_is_required_for_16_bit_reloc (bfd_vma relocation)
873 return (relocation >= 0x020000);
876 /* Returns the address of the corresponding stub if there is one.
877 Returns otherwise an address above 0x020000. This function
878 could also be used, if there is no knowledge on the section where
879 the destination is found. */
882 avr_get_stub_addr (bfd_vma srel,
883 struct elf32_avr_link_hash_table *htab)
886 bfd_vma stub_sec_addr =
887 (htab->stub_sec->output_section->vma +
888 htab->stub_sec->output_offset);
890 for (sindex = 0; sindex < htab->amt_max_entry_cnt; sindex ++)
891 if (htab->amt_destination_addr[sindex] == srel)
892 return htab->amt_stub_offsets[sindex] + stub_sec_addr;
894 /* Return an address that could not be reached by 16 bit relocs. */
898 /* Perform a diff relocation. Nothing to do, as the difference value is already
899 written into the section's contents. */
901 static bfd_reloc_status_type
902 bfd_elf_avr_diff_reloc (bfd *abfd ATTRIBUTE_UNUSED,
903 arelent *reloc_entry ATTRIBUTE_UNUSED,
904 asymbol *symbol ATTRIBUTE_UNUSED,
905 void *data ATTRIBUTE_UNUSED,
906 asection *input_section ATTRIBUTE_UNUSED,
907 bfd *output_bfd ATTRIBUTE_UNUSED,
908 char **error_message ATTRIBUTE_UNUSED)
914 /* Perform a single relocation. By default we use the standard BFD
915 routines, but a few relocs, we have to do them ourselves. */
917 static bfd_reloc_status_type
918 avr_final_link_relocate (reloc_howto_type * howto,
920 asection * input_section,
922 Elf_Internal_Rela * rel,
924 struct elf32_avr_link_hash_table * htab)
926 bfd_reloc_status_type r = bfd_reloc_ok;
929 bfd_signed_vma reloc_addr;
930 bfd_boolean use_stubs = FALSE;
931 /* Usually is 0, unless we are generating code for a bootloader. */
932 bfd_signed_vma base_addr = htab->vector_base;
934 /* Absolute addr of the reloc in the final excecutable. */
935 reloc_addr = rel->r_offset + input_section->output_section->vma
936 + input_section->output_offset;
941 contents += rel->r_offset;
942 srel = (bfd_signed_vma) relocation;
943 srel += rel->r_addend;
944 srel -= rel->r_offset;
945 srel -= 2; /* Branch instructions add 2 to the PC... */
946 srel -= (input_section->output_section->vma +
947 input_section->output_offset);
950 return bfd_reloc_outofrange;
951 if (srel > ((1 << 7) - 1) || (srel < - (1 << 7)))
952 return bfd_reloc_overflow;
953 x = bfd_get_16 (input_bfd, contents);
954 x = (x & 0xfc07) | (((srel >> 1) << 3) & 0x3f8);
955 bfd_put_16 (input_bfd, x, contents);
959 contents += rel->r_offset;
960 srel = (bfd_signed_vma) relocation;
961 srel += rel->r_addend;
962 srel -= rel->r_offset;
963 srel -= 2; /* Branch instructions add 2 to the PC... */
964 srel -= (input_section->output_section->vma +
965 input_section->output_offset);
968 return bfd_reloc_outofrange;
970 srel = avr_relative_distance_considering_wrap_around (srel);
972 /* AVR addresses commands as words. */
975 /* Check for overflow. */
976 if (srel < -2048 || srel > 2047)
978 /* Relative distance is too large. */
980 /* Always apply WRAPAROUND for avr2, avr25, and avr4. */
981 switch (bfd_get_mach (input_bfd))
989 return bfd_reloc_overflow;
993 x = bfd_get_16 (input_bfd, contents);
994 x = (x & 0xf000) | (srel & 0xfff);
995 bfd_put_16 (input_bfd, x, contents);
999 contents += rel->r_offset;
1000 srel = (bfd_signed_vma) relocation + rel->r_addend;
1001 x = bfd_get_16 (input_bfd, contents);
1002 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1003 bfd_put_16 (input_bfd, x, contents);
1007 contents += rel->r_offset;
1008 srel = (bfd_signed_vma) relocation + rel->r_addend;
1009 if (((srel > 0) && (srel & 0xffff) > 255)
1010 || ((srel < 0) && ((-srel) & 0xffff) > 128))
1011 /* Remove offset for data/eeprom section. */
1012 return bfd_reloc_overflow;
1014 x = bfd_get_16 (input_bfd, contents);
1015 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1016 bfd_put_16 (input_bfd, x, contents);
1020 contents += rel->r_offset;
1021 srel = (bfd_signed_vma) relocation + rel->r_addend;
1022 if (((srel & 0xffff) > 63) || (srel < 0))
1023 /* Remove offset for data/eeprom section. */
1024 return bfd_reloc_overflow;
1025 x = bfd_get_16 (input_bfd, contents);
1026 x = (x & 0xd3f8) | ((srel & 7) | ((srel & (3 << 3)) << 7)
1027 | ((srel & (1 << 5)) << 8));
1028 bfd_put_16 (input_bfd, x, contents);
1032 contents += rel->r_offset;
1033 srel = (bfd_signed_vma) relocation + rel->r_addend;
1034 if (((srel & 0xffff) > 63) || (srel < 0))
1035 /* Remove offset for data/eeprom section. */
1036 return bfd_reloc_overflow;
1037 x = bfd_get_16 (input_bfd, contents);
1038 x = (x & 0xff30) | (srel & 0xf) | ((srel & 0x30) << 2);
1039 bfd_put_16 (input_bfd, x, contents);
1043 contents += rel->r_offset;
1044 srel = (bfd_signed_vma) relocation + rel->r_addend;
1045 srel = (srel >> 8) & 0xff;
1046 x = bfd_get_16 (input_bfd, contents);
1047 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1048 bfd_put_16 (input_bfd, x, contents);
1052 contents += rel->r_offset;
1053 srel = (bfd_signed_vma) relocation + rel->r_addend;
1054 srel = (srel >> 16) & 0xff;
1055 x = bfd_get_16 (input_bfd, contents);
1056 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1057 bfd_put_16 (input_bfd, x, contents);
1061 contents += rel->r_offset;
1062 srel = (bfd_signed_vma) relocation + rel->r_addend;
1063 srel = (srel >> 24) & 0xff;
1064 x = bfd_get_16 (input_bfd, contents);
1065 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1066 bfd_put_16 (input_bfd, x, contents);
1069 case R_AVR_LO8_LDI_NEG:
1070 contents += rel->r_offset;
1071 srel = (bfd_signed_vma) relocation + rel->r_addend;
1073 x = bfd_get_16 (input_bfd, contents);
1074 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1075 bfd_put_16 (input_bfd, x, contents);
1078 case R_AVR_HI8_LDI_NEG:
1079 contents += rel->r_offset;
1080 srel = (bfd_signed_vma) relocation + rel->r_addend;
1082 srel = (srel >> 8) & 0xff;
1083 x = bfd_get_16 (input_bfd, contents);
1084 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1085 bfd_put_16 (input_bfd, x, contents);
1088 case R_AVR_HH8_LDI_NEG:
1089 contents += rel->r_offset;
1090 srel = (bfd_signed_vma) relocation + rel->r_addend;
1092 srel = (srel >> 16) & 0xff;
1093 x = bfd_get_16 (input_bfd, contents);
1094 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1095 bfd_put_16 (input_bfd, x, contents);
1098 case R_AVR_MS8_LDI_NEG:
1099 contents += rel->r_offset;
1100 srel = (bfd_signed_vma) relocation + rel->r_addend;
1102 srel = (srel >> 24) & 0xff;
1103 x = bfd_get_16 (input_bfd, contents);
1104 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1105 bfd_put_16 (input_bfd, x, contents);
1108 case R_AVR_LO8_LDI_GS:
1109 use_stubs = (!htab->no_stubs);
1111 case R_AVR_LO8_LDI_PM:
1112 contents += rel->r_offset;
1113 srel = (bfd_signed_vma) relocation + rel->r_addend;
1116 && avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1118 bfd_vma old_srel = srel;
1120 /* We need to use the address of the stub instead. */
1121 srel = avr_get_stub_addr (srel, htab);
1123 printf ("LD: Using jump stub (at 0x%x) with destination 0x%x for "
1124 "reloc at address 0x%x.\n",
1125 (unsigned int) srel,
1126 (unsigned int) old_srel,
1127 (unsigned int) reloc_addr);
1129 if (avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1130 return bfd_reloc_outofrange;
1134 return bfd_reloc_outofrange;
1136 x = bfd_get_16 (input_bfd, contents);
1137 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1138 bfd_put_16 (input_bfd, x, contents);
1141 case R_AVR_HI8_LDI_GS:
1142 use_stubs = (!htab->no_stubs);
1144 case R_AVR_HI8_LDI_PM:
1145 contents += rel->r_offset;
1146 srel = (bfd_signed_vma) relocation + rel->r_addend;
1149 && avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1151 bfd_vma old_srel = srel;
1153 /* We need to use the address of the stub instead. */
1154 srel = avr_get_stub_addr (srel, htab);
1156 printf ("LD: Using jump stub (at 0x%x) with destination 0x%x for "
1157 "reloc at address 0x%x.\n",
1158 (unsigned int) srel,
1159 (unsigned int) old_srel,
1160 (unsigned int) reloc_addr);
1162 if (avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1163 return bfd_reloc_outofrange;
1167 return bfd_reloc_outofrange;
1169 srel = (srel >> 8) & 0xff;
1170 x = bfd_get_16 (input_bfd, contents);
1171 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1172 bfd_put_16 (input_bfd, x, contents);
1175 case R_AVR_HH8_LDI_PM:
1176 contents += rel->r_offset;
1177 srel = (bfd_signed_vma) relocation + rel->r_addend;
1179 return bfd_reloc_outofrange;
1181 srel = (srel >> 16) & 0xff;
1182 x = bfd_get_16 (input_bfd, contents);
1183 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1184 bfd_put_16 (input_bfd, x, contents);
1187 case R_AVR_LO8_LDI_PM_NEG:
1188 contents += rel->r_offset;
1189 srel = (bfd_signed_vma) relocation + rel->r_addend;
1192 return bfd_reloc_outofrange;
1194 x = bfd_get_16 (input_bfd, contents);
1195 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1196 bfd_put_16 (input_bfd, x, contents);
1199 case R_AVR_HI8_LDI_PM_NEG:
1200 contents += rel->r_offset;
1201 srel = (bfd_signed_vma) relocation + rel->r_addend;
1204 return bfd_reloc_outofrange;
1206 srel = (srel >> 8) & 0xff;
1207 x = bfd_get_16 (input_bfd, contents);
1208 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1209 bfd_put_16 (input_bfd, x, contents);
1212 case R_AVR_HH8_LDI_PM_NEG:
1213 contents += rel->r_offset;
1214 srel = (bfd_signed_vma) relocation + rel->r_addend;
1217 return bfd_reloc_outofrange;
1219 srel = (srel >> 16) & 0xff;
1220 x = bfd_get_16 (input_bfd, contents);
1221 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1222 bfd_put_16 (input_bfd, x, contents);
1226 contents += rel->r_offset;
1227 srel = (bfd_signed_vma) relocation + rel->r_addend;
1229 return bfd_reloc_outofrange;
1231 x = bfd_get_16 (input_bfd, contents);
1232 x |= ((srel & 0x10000) | ((srel << 3) & 0x1f00000)) >> 16;
1233 bfd_put_16 (input_bfd, x, contents);
1234 bfd_put_16 (input_bfd, (bfd_vma) srel & 0xffff, contents+2);
1238 use_stubs = (!htab->no_stubs);
1239 contents += rel->r_offset;
1240 srel = (bfd_signed_vma) relocation + rel->r_addend;
1243 && avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1245 bfd_vma old_srel = srel;
1247 /* We need to use the address of the stub instead. */
1248 srel = avr_get_stub_addr (srel,htab);
1250 printf ("LD: Using jump stub (at 0x%x) with destination 0x%x for "
1251 "reloc at address 0x%x.\n",
1252 (unsigned int) srel,
1253 (unsigned int) old_srel,
1254 (unsigned int) reloc_addr);
1256 if (avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1257 return bfd_reloc_outofrange;
1261 return bfd_reloc_outofrange;
1263 bfd_put_16 (input_bfd, (bfd_vma) srel &0x00ffff, contents);
1269 /* Nothing to do here, as contents already contains the diff value. */
1273 case R_AVR_LDS_STS_16:
1274 contents += rel->r_offset;
1275 srel = (bfd_signed_vma) relocation + rel->r_addend;
1276 if ((srel & 0xFFFF) < 0x40 || (srel & 0xFFFF) > 0xbf)
1277 return bfd_reloc_outofrange;
1279 x = bfd_get_16 (input_bfd, contents);
1280 x |= (srel & 0x0f) | ((srel & 0x30) << 5) | ((srel & 0x40) << 2);
1281 bfd_put_16 (input_bfd, x, contents);
1285 contents += rel->r_offset;
1286 srel = (bfd_signed_vma) relocation + rel->r_addend;
1287 if ((srel & 0xffff) > 0x3f)
1288 return bfd_reloc_outofrange;
1289 x = bfd_get_16 (input_bfd, contents);
1290 x = (x & 0xf9f0) | ((srel & 0x30) << 5) | (srel & 0x0f);
1291 bfd_put_16 (input_bfd, x, contents);
1295 contents += rel->r_offset;
1296 srel = (bfd_signed_vma) relocation + rel->r_addend;
1297 if ((srel & 0xffff) > 0x1f)
1298 return bfd_reloc_outofrange;
1299 x = bfd_get_16 (input_bfd, contents);
1300 x = (x & 0xff07) | ((srel & 0x1f) << 3);
1301 bfd_put_16 (input_bfd, x, contents);
1305 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1306 contents, rel->r_offset,
1307 relocation, rel->r_addend);
1313 /* Relocate an AVR ELF section. */
1316 elf32_avr_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED,
1317 struct bfd_link_info *info,
1319 asection *input_section,
1321 Elf_Internal_Rela *relocs,
1322 Elf_Internal_Sym *local_syms,
1323 asection **local_sections)
1325 Elf_Internal_Shdr * symtab_hdr;
1326 struct elf_link_hash_entry ** sym_hashes;
1327 Elf_Internal_Rela * rel;
1328 Elf_Internal_Rela * relend;
1329 struct elf32_avr_link_hash_table * htab = avr_link_hash_table (info);
1334 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
1335 sym_hashes = elf_sym_hashes (input_bfd);
1336 relend = relocs + input_section->reloc_count;
1338 for (rel = relocs; rel < relend; rel ++)
1340 reloc_howto_type * howto;
1341 unsigned long r_symndx;
1342 Elf_Internal_Sym * sym;
1344 struct elf_link_hash_entry * h;
1346 bfd_reloc_status_type r;
1350 r_type = ELF32_R_TYPE (rel->r_info);
1351 r_symndx = ELF32_R_SYM (rel->r_info);
1352 howto = elf_avr_howto_table + r_type;
1357 if (r_symndx < symtab_hdr->sh_info)
1359 sym = local_syms + r_symndx;
1360 sec = local_sections [r_symndx];
1361 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1363 name = bfd_elf_string_from_elf_section
1364 (input_bfd, symtab_hdr->sh_link, sym->st_name);
1365 name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
1369 bfd_boolean unresolved_reloc, warned, ignored;
1371 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1372 r_symndx, symtab_hdr, sym_hashes,
1374 unresolved_reloc, warned, ignored);
1376 name = h->root.root.string;
1379 if (sec != NULL && discarded_section (sec))
1380 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
1381 rel, 1, relend, howto, 0, contents);
1383 if (info->relocatable)
1386 r = avr_final_link_relocate (howto, input_bfd, input_section,
1387 contents, rel, relocation, htab);
1389 if (r != bfd_reloc_ok)
1391 const char * msg = (const char *) NULL;
1395 case bfd_reloc_overflow:
1396 r = info->callbacks->reloc_overflow
1397 (info, (h ? &h->root : NULL),
1398 name, howto->name, (bfd_vma) 0,
1399 input_bfd, input_section, rel->r_offset);
1402 case bfd_reloc_undefined:
1403 r = info->callbacks->undefined_symbol
1404 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
1407 case bfd_reloc_outofrange:
1408 msg = _("internal error: out of range error");
1411 case bfd_reloc_notsupported:
1412 msg = _("internal error: unsupported relocation error");
1415 case bfd_reloc_dangerous:
1416 msg = _("internal error: dangerous relocation");
1420 msg = _("internal error: unknown error");
1425 r = info->callbacks->warning
1426 (info, msg, name, input_bfd, input_section, rel->r_offset);
1436 /* The final processing done just before writing out a AVR ELF object
1437 file. This gets the AVR architecture right based on the machine
1441 bfd_elf_avr_final_write_processing (bfd *abfd,
1442 bfd_boolean linker ATTRIBUTE_UNUSED)
1446 switch (bfd_get_mach (abfd))
1450 val = E_AVR_MACH_AVR2;
1454 val = E_AVR_MACH_AVR1;
1457 case bfd_mach_avr25:
1458 val = E_AVR_MACH_AVR25;
1462 val = E_AVR_MACH_AVR3;
1465 case bfd_mach_avr31:
1466 val = E_AVR_MACH_AVR31;
1469 case bfd_mach_avr35:
1470 val = E_AVR_MACH_AVR35;
1474 val = E_AVR_MACH_AVR4;
1478 val = E_AVR_MACH_AVR5;
1481 case bfd_mach_avr51:
1482 val = E_AVR_MACH_AVR51;
1486 val = E_AVR_MACH_AVR6;
1489 case bfd_mach_avrxmega1:
1490 val = E_AVR_MACH_XMEGA1;
1493 case bfd_mach_avrxmega2:
1494 val = E_AVR_MACH_XMEGA2;
1497 case bfd_mach_avrxmega3:
1498 val = E_AVR_MACH_XMEGA3;
1501 case bfd_mach_avrxmega4:
1502 val = E_AVR_MACH_XMEGA4;
1505 case bfd_mach_avrxmega5:
1506 val = E_AVR_MACH_XMEGA5;
1509 case bfd_mach_avrxmega6:
1510 val = E_AVR_MACH_XMEGA6;
1513 case bfd_mach_avrxmega7:
1514 val = E_AVR_MACH_XMEGA7;
1517 case bfd_mach_avrtiny:
1518 val = E_AVR_MACH_AVRTINY;
1522 elf_elfheader (abfd)->e_machine = EM_AVR;
1523 elf_elfheader (abfd)->e_flags &= ~ EF_AVR_MACH;
1524 elf_elfheader (abfd)->e_flags |= val;
1525 elf_elfheader (abfd)->e_flags |= EF_AVR_LINKRELAX_PREPARED;
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 /* This function handles relaxing for the avr.
1940 Many important relaxing opportunities within functions are already
1941 realized by the compiler itself.
1942 Here we try to replace call (4 bytes) -> rcall (2 bytes)
1943 and jump -> rjmp (safes also 2 bytes).
1944 As well we now optimize seqences of
1945 - call/rcall function
1950 . In case that within a sequence
1953 the ret could no longer be reached it is optimized away. In order
1954 to check if the ret is no longer needed, it is checked that the ret's address
1955 is not the target of a branch or jump within the same section, it is checked
1956 that there is no skip instruction before the jmp/rjmp and that there
1957 is no local or global label place at the address of the ret.
1959 We refrain from relaxing within sections ".vectors" and
1960 ".jumptables" in order to maintain the position of the instructions.
1961 There, however, we substitute jmp/call by a sequence rjmp,nop/rcall,nop
1962 if possible. (In future one could possibly use the space of the nop
1963 for the first instruction of the irq service function.
1965 The .jumptables sections is meant to be used for a future tablejump variant
1966 for the devices with 3-byte program counter where the table itself
1967 contains 4-byte jump instructions whose relative offset must not
1971 elf32_avr_relax_section (bfd *abfd,
1973 struct bfd_link_info *link_info,
1976 Elf_Internal_Shdr *symtab_hdr;
1977 Elf_Internal_Rela *internal_relocs;
1978 Elf_Internal_Rela *irel, *irelend;
1979 bfd_byte *contents = NULL;
1980 Elf_Internal_Sym *isymbuf = NULL;
1981 struct elf32_avr_link_hash_table *htab;
1983 /* If 'shrinkable' is FALSE, do not shrink by deleting bytes while
1984 relaxing. Such shrinking can cause issues for the sections such
1985 as .vectors and .jumptables. Instead the unused bytes should be
1986 filled with nop instructions. */
1987 bfd_boolean shrinkable = TRUE;
1989 if (!strcmp (sec->name,".vectors")
1990 || !strcmp (sec->name,".jumptables"))
1993 if (link_info->relocatable)
1994 (*link_info->callbacks->einfo)
1995 (_("%P%F: --relax and -r may not be used together\n"));
1997 htab = avr_link_hash_table (link_info);
2001 /* Assume nothing changes. */
2004 if ((!htab->no_stubs) && (sec == htab->stub_sec))
2006 /* We are just relaxing the stub section.
2007 Let's calculate the size needed again. */
2008 bfd_size_type last_estimated_stub_section_size = htab->stub_sec->size;
2011 printf ("Relaxing the stub section. Size prior to this pass: %i\n",
2012 (int) last_estimated_stub_section_size);
2014 elf32_avr_size_stubs (htab->stub_sec->output_section->owner,
2017 /* Check if the number of trampolines changed. */
2018 if (last_estimated_stub_section_size != htab->stub_sec->size)
2022 printf ("Size of stub section after this pass: %i\n",
2023 (int) htab->stub_sec->size);
2028 /* We don't have to do anything for a relocatable link, if
2029 this section does not have relocs, or if this is not a
2031 if (link_info->relocatable
2032 || (sec->flags & SEC_RELOC) == 0
2033 || sec->reloc_count == 0
2034 || (sec->flags & SEC_CODE) == 0)
2037 /* Check if the object file to relax uses internal symbols so that we
2038 could fix up the relocations. */
2039 if (!(elf_elfheader (abfd)->e_flags & EF_AVR_LINKRELAX_PREPARED))
2042 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2044 /* Get a copy of the native relocations. */
2045 internal_relocs = (_bfd_elf_link_read_relocs
2046 (abfd, sec, NULL, NULL, link_info->keep_memory));
2047 if (internal_relocs == NULL)
2050 /* Walk through the relocs looking for relaxing opportunities. */
2051 irelend = internal_relocs + sec->reloc_count;
2052 for (irel = internal_relocs; irel < irelend; irel++)
2056 if ( ELF32_R_TYPE (irel->r_info) != R_AVR_13_PCREL
2057 && ELF32_R_TYPE (irel->r_info) != R_AVR_7_PCREL
2058 && ELF32_R_TYPE (irel->r_info) != R_AVR_CALL)
2061 /* Get the section contents if we haven't done so already. */
2062 if (contents == NULL)
2064 /* Get cached copy if it exists. */
2065 if (elf_section_data (sec)->this_hdr.contents != NULL)
2066 contents = elf_section_data (sec)->this_hdr.contents;
2069 /* Go get them off disk. */
2070 if (! bfd_malloc_and_get_section (abfd, sec, &contents))
2075 /* Read this BFD's local symbols if we haven't done so already. */
2076 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
2078 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2079 if (isymbuf == NULL)
2080 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
2081 symtab_hdr->sh_info, 0,
2083 if (isymbuf == NULL)
2088 /* Get the value of the symbol referred to by the reloc. */
2089 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
2091 /* A local symbol. */
2092 Elf_Internal_Sym *isym;
2095 isym = isymbuf + ELF32_R_SYM (irel->r_info);
2096 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
2097 symval = isym->st_value;
2098 /* If the reloc is absolute, it will not have
2099 a symbol or section associated with it. */
2101 symval += sym_sec->output_section->vma
2102 + sym_sec->output_offset;
2107 struct elf_link_hash_entry *h;
2109 /* An external symbol. */
2110 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
2111 h = elf_sym_hashes (abfd)[indx];
2112 BFD_ASSERT (h != NULL);
2113 if (h->root.type != bfd_link_hash_defined
2114 && h->root.type != bfd_link_hash_defweak)
2115 /* This appears to be a reference to an undefined
2116 symbol. Just ignore it--it will be caught by the
2117 regular reloc processing. */
2120 symval = (h->root.u.def.value
2121 + h->root.u.def.section->output_section->vma
2122 + h->root.u.def.section->output_offset);
2125 /* For simplicity of coding, we are going to modify the section
2126 contents, the section relocs, and the BFD symbol table. We
2127 must tell the rest of the code not to free up this
2128 information. It would be possible to instead create a table
2129 of changes which have to be made, as is done in coff-mips.c;
2130 that would be more work, but would require less memory when
2131 the linker is run. */
2132 switch (ELF32_R_TYPE (irel->r_info))
2134 /* Try to turn a 22-bit absolute call/jump into an 13-bit
2135 pc-relative rcall/rjmp. */
2138 bfd_vma value = symval + irel->r_addend;
2140 int distance_short_enough = 0;
2142 /* Get the address of this instruction. */
2143 dot = (sec->output_section->vma
2144 + sec->output_offset + irel->r_offset);
2146 /* Compute the distance from this insn to the branch target. */
2149 /* Check if the gap falls in the range that can be accommodated
2150 in 13bits signed (It is 12bits when encoded, as we deal with
2151 word addressing). */
2152 if (!shrinkable && ((int) gap >= -4096 && (int) gap <= 4095))
2153 distance_short_enough = 1;
2154 /* If shrinkable, then we can check for a range of distance which
2155 is two bytes farther on both the directions because the call
2156 or jump target will be closer by two bytes after the
2158 else if (shrinkable && ((int) gap >= -4094 && (int) gap <= 4097))
2159 distance_short_enough = 1;
2161 /* Here we handle the wrap-around case. E.g. for a 16k device
2162 we could use a rjmp to jump from address 0x100 to 0x3d00!
2163 In order to make this work properly, we need to fill the
2164 vaiable avr_pc_wrap_around with the appropriate value.
2165 I.e. 0x4000 for a 16k device. */
2167 /* Shrinking the code size makes the gaps larger in the
2168 case of wrap-arounds. So we use a heuristical safety
2169 margin to avoid that during relax the distance gets
2170 again too large for the short jumps. Let's assume
2171 a typical code-size reduction due to relax for a
2172 16k device of 600 bytes. So let's use twice the
2173 typical value as safety margin. */
2177 int assumed_shrink = 600;
2178 if (avr_pc_wrap_around > 0x4000)
2179 assumed_shrink = 900;
2181 safety_margin = 2 * assumed_shrink;
2183 rgap = avr_relative_distance_considering_wrap_around (gap);
2185 if (rgap >= (-4092 + safety_margin)
2186 && rgap <= (4094 - safety_margin))
2187 distance_short_enough = 1;
2190 if (distance_short_enough)
2192 unsigned char code_msb;
2193 unsigned char code_lsb;
2196 printf ("shrinking jump/call instruction at address 0x%x"
2197 " in section %s\n\n",
2198 (int) dot, sec->name);
2200 /* Note that we've changed the relocs, section contents,
2202 elf_section_data (sec)->relocs = internal_relocs;
2203 elf_section_data (sec)->this_hdr.contents = contents;
2204 symtab_hdr->contents = (unsigned char *) isymbuf;
2206 /* Get the instruction code for relaxing. */
2207 code_lsb = bfd_get_8 (abfd, contents + irel->r_offset);
2208 code_msb = bfd_get_8 (abfd, contents + irel->r_offset + 1);
2210 /* Mask out the relocation bits. */
2213 if (code_msb == 0x94 && code_lsb == 0x0E)
2215 /* we are changing call -> rcall . */
2216 bfd_put_8 (abfd, 0x00, contents + irel->r_offset);
2217 bfd_put_8 (abfd, 0xD0, contents + irel->r_offset + 1);
2219 else if (code_msb == 0x94 && code_lsb == 0x0C)
2221 /* we are changeing jump -> rjmp. */
2222 bfd_put_8 (abfd, 0x00, contents + irel->r_offset);
2223 bfd_put_8 (abfd, 0xC0, contents + irel->r_offset + 1);
2228 /* Fix the relocation's type. */
2229 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2232 /* We should not modify the ordering if 'shrinkable' is
2236 /* Let's insert a nop. */
2237 bfd_put_8 (abfd, 0x00, contents + irel->r_offset + 2);
2238 bfd_put_8 (abfd, 0x00, contents + irel->r_offset + 3);
2242 /* Delete two bytes of data. */
2243 if (!elf32_avr_relax_delete_bytes (abfd, sec,
2244 irel->r_offset + 2, 2))
2247 /* That will change things, so, we should relax again.
2248 Note that this is not required, and it may be slow. */
2256 unsigned char code_msb;
2257 unsigned char code_lsb;
2260 code_msb = bfd_get_8 (abfd, contents + irel->r_offset + 1);
2261 code_lsb = bfd_get_8 (abfd, contents + irel->r_offset + 0);
2263 /* Get the address of this instruction. */
2264 dot = (sec->output_section->vma
2265 + sec->output_offset + irel->r_offset);
2267 /* Here we look for rcall/ret or call/ret sequences that could be
2268 safely replaced by rjmp/ret or jmp/ret. */
2269 if (((code_msb & 0xf0) == 0xd0)
2270 && avr_replace_call_ret_sequences)
2272 /* This insn is a rcall. */
2273 unsigned char next_insn_msb = 0;
2274 unsigned char next_insn_lsb = 0;
2276 if (irel->r_offset + 3 < sec->size)
2279 bfd_get_8 (abfd, contents + irel->r_offset + 3);
2281 bfd_get_8 (abfd, contents + irel->r_offset + 2);
2284 if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb))
2286 /* The next insn is a ret. We now convert the rcall insn
2287 into a rjmp instruction. */
2289 bfd_put_8 (abfd, code_msb, contents + irel->r_offset + 1);
2291 printf ("converted rcall/ret sequence at address 0x%x"
2292 " into rjmp/ret sequence. Section is %s\n\n",
2293 (int) dot, sec->name);
2298 else if ((0x94 == (code_msb & 0xfe))
2299 && (0x0e == (code_lsb & 0x0e))
2300 && avr_replace_call_ret_sequences)
2302 /* This insn is a call. */
2303 unsigned char next_insn_msb = 0;
2304 unsigned char next_insn_lsb = 0;
2306 if (irel->r_offset + 5 < sec->size)
2309 bfd_get_8 (abfd, contents + irel->r_offset + 5);
2311 bfd_get_8 (abfd, contents + irel->r_offset + 4);
2314 if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb))
2316 /* The next insn is a ret. We now convert the call insn
2317 into a jmp instruction. */
2320 bfd_put_8 (abfd, code_lsb, contents + irel->r_offset);
2322 printf ("converted call/ret sequence at address 0x%x"
2323 " into jmp/ret sequence. Section is %s\n\n",
2324 (int) dot, sec->name);
2329 else if ((0xc0 == (code_msb & 0xf0))
2330 || ((0x94 == (code_msb & 0xfe))
2331 && (0x0c == (code_lsb & 0x0e))))
2333 /* This insn is a rjmp or a jmp. */
2334 unsigned char next_insn_msb = 0;
2335 unsigned char next_insn_lsb = 0;
2338 if (0xc0 == (code_msb & 0xf0))
2339 insn_size = 2; /* rjmp insn */
2341 insn_size = 4; /* jmp insn */
2343 if (irel->r_offset + insn_size + 1 < sec->size)
2346 bfd_get_8 (abfd, contents + irel->r_offset
2349 bfd_get_8 (abfd, contents + irel->r_offset
2353 if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb))
2355 /* The next insn is a ret. We possibly could delete
2356 this ret. First we need to check for preceding
2357 sbis/sbic/sbrs or cpse "skip" instructions. */
2359 int there_is_preceding_non_skip_insn = 1;
2360 bfd_vma address_of_ret;
2362 address_of_ret = dot + insn_size;
2364 if (debug_relax && (insn_size == 2))
2365 printf ("found rjmp / ret sequence at address 0x%x\n",
2367 if (debug_relax && (insn_size == 4))
2368 printf ("found jmp / ret sequence at address 0x%x\n",
2371 /* We have to make sure that there is a preceding insn. */
2372 if (irel->r_offset >= 2)
2374 unsigned char preceding_msb;
2375 unsigned char preceding_lsb;
2378 bfd_get_8 (abfd, contents + irel->r_offset - 1);
2380 bfd_get_8 (abfd, contents + irel->r_offset - 2);
2383 if (0x99 == preceding_msb)
2384 there_is_preceding_non_skip_insn = 0;
2387 if (0x9b == preceding_msb)
2388 there_is_preceding_non_skip_insn = 0;
2391 if ((0xfc == (preceding_msb & 0xfe)
2392 && (0x00 == (preceding_lsb & 0x08))))
2393 there_is_preceding_non_skip_insn = 0;
2396 if ((0xfe == (preceding_msb & 0xfe)
2397 && (0x00 == (preceding_lsb & 0x08))))
2398 there_is_preceding_non_skip_insn = 0;
2401 if (0x10 == (preceding_msb & 0xfc))
2402 there_is_preceding_non_skip_insn = 0;
2404 if (there_is_preceding_non_skip_insn == 0)
2406 printf ("preceding skip insn prevents deletion of"
2407 " ret insn at Addy 0x%x in section %s\n",
2408 (int) dot + 2, sec->name);
2412 /* There is no previous instruction. */
2413 there_is_preceding_non_skip_insn = 0;
2416 if (there_is_preceding_non_skip_insn)
2418 /* We now only have to make sure that there is no
2419 local label defined at the address of the ret
2420 instruction and that there is no local relocation
2421 in this section pointing to the ret. */
2423 int deleting_ret_is_safe = 1;
2424 unsigned int section_offset_of_ret_insn =
2425 irel->r_offset + insn_size;
2426 Elf_Internal_Sym *isym, *isymend;
2427 unsigned int sec_shndx;
2428 struct bfd_section *isec;
2431 _bfd_elf_section_from_bfd_section (abfd, sec);
2433 /* Check for local symbols. */
2434 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
2435 isymend = isym + symtab_hdr->sh_info;
2436 /* PR 6019: There may not be any local symbols. */
2437 for (; isym != NULL && isym < isymend; isym++)
2439 if (isym->st_value == section_offset_of_ret_insn
2440 && isym->st_shndx == sec_shndx)
2442 deleting_ret_is_safe = 0;
2444 printf ("local label prevents deletion of ret "
2445 "insn at address 0x%x\n",
2446 (int) dot + insn_size);
2450 /* Now check for global symbols. */
2453 struct elf_link_hash_entry **sym_hashes;
2454 struct elf_link_hash_entry **end_hashes;
2456 symcount = (symtab_hdr->sh_size
2457 / sizeof (Elf32_External_Sym)
2458 - symtab_hdr->sh_info);
2459 sym_hashes = elf_sym_hashes (abfd);
2460 end_hashes = sym_hashes + symcount;
2461 for (; sym_hashes < end_hashes; sym_hashes++)
2463 struct elf_link_hash_entry *sym_hash =
2465 if ((sym_hash->root.type == bfd_link_hash_defined
2466 || sym_hash->root.type ==
2467 bfd_link_hash_defweak)
2468 && sym_hash->root.u.def.section == sec
2469 && sym_hash->root.u.def.value == section_offset_of_ret_insn)
2471 deleting_ret_is_safe = 0;
2473 printf ("global label prevents deletion of "
2474 "ret insn at address 0x%x\n",
2475 (int) dot + insn_size);
2480 /* Now we check for relocations pointing to ret. */
2481 for (isec = abfd->sections; isec && deleting_ret_is_safe; isec = isec->next)
2483 Elf_Internal_Rela *rel;
2484 Elf_Internal_Rela *relend;
2486 rel = elf_section_data (isec)->relocs;
2488 rel = _bfd_elf_link_read_relocs (abfd, isec, NULL, NULL, TRUE);
2490 relend = rel + isec->reloc_count;
2492 for (; rel && rel < relend; rel++)
2494 bfd_vma reloc_target = 0;
2496 /* Read this BFD's local symbols if we haven't
2498 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
2500 isymbuf = (Elf_Internal_Sym *)
2501 symtab_hdr->contents;
2502 if (isymbuf == NULL)
2503 isymbuf = bfd_elf_get_elf_syms
2506 symtab_hdr->sh_info, 0,
2508 if (isymbuf == NULL)
2512 /* Get the value of the symbol referred to
2514 if (ELF32_R_SYM (rel->r_info)
2515 < symtab_hdr->sh_info)
2517 /* A local symbol. */
2521 + ELF32_R_SYM (rel->r_info);
2522 sym_sec = bfd_section_from_elf_index
2523 (abfd, isym->st_shndx);
2524 symval = isym->st_value;
2526 /* If the reloc is absolute, it will not
2527 have a symbol or section associated
2533 sym_sec->output_section->vma
2534 + sym_sec->output_offset;
2535 reloc_target = symval + rel->r_addend;
2539 reloc_target = symval + rel->r_addend;
2540 /* Reference symbol is absolute. */
2543 /* else ... reference symbol is extern. */
2545 if (address_of_ret == reloc_target)
2547 deleting_ret_is_safe = 0;
2550 "rjmp/jmp ret sequence at address"
2551 " 0x%x could not be deleted. ret"
2552 " is target of a relocation.\n",
2553 (int) address_of_ret);
2559 if (deleting_ret_is_safe)
2562 printf ("unreachable ret instruction "
2563 "at address 0x%x deleted.\n",
2564 (int) dot + insn_size);
2566 /* Delete two bytes of data. */
2567 if (!elf32_avr_relax_delete_bytes (abfd, sec,
2568 irel->r_offset + insn_size, 2))
2571 /* That will change things, so, we should relax
2572 again. Note that this is not required, and it
2585 if (contents != NULL
2586 && elf_section_data (sec)->this_hdr.contents != contents)
2588 if (! link_info->keep_memory)
2592 /* Cache the section contents for elf_link_input_bfd. */
2593 elf_section_data (sec)->this_hdr.contents = contents;
2597 if (internal_relocs != NULL
2598 && elf_section_data (sec)->relocs != internal_relocs)
2599 free (internal_relocs);
2605 && symtab_hdr->contents != (unsigned char *) isymbuf)
2607 if (contents != NULL
2608 && elf_section_data (sec)->this_hdr.contents != contents)
2610 if (internal_relocs != NULL
2611 && elf_section_data (sec)->relocs != internal_relocs)
2612 free (internal_relocs);
2617 /* This is a version of bfd_generic_get_relocated_section_contents
2618 which uses elf32_avr_relocate_section.
2620 For avr it's essentially a cut and paste taken from the H8300 port.
2621 The author of the relaxation support patch for avr had absolutely no
2622 clue what is happening here but found out that this part of the code
2623 seems to be important. */
2626 elf32_avr_get_relocated_section_contents (bfd *output_bfd,
2627 struct bfd_link_info *link_info,
2628 struct bfd_link_order *link_order,
2630 bfd_boolean relocatable,
2633 Elf_Internal_Shdr *symtab_hdr;
2634 asection *input_section = link_order->u.indirect.section;
2635 bfd *input_bfd = input_section->owner;
2636 asection **sections = NULL;
2637 Elf_Internal_Rela *internal_relocs = NULL;
2638 Elf_Internal_Sym *isymbuf = NULL;
2640 /* We only need to handle the case of relaxing, or of having a
2641 particular set of section contents, specially. */
2643 || elf_section_data (input_section)->this_hdr.contents == NULL)
2644 return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
2648 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2650 memcpy (data, elf_section_data (input_section)->this_hdr.contents,
2651 (size_t) input_section->size);
2653 if ((input_section->flags & SEC_RELOC) != 0
2654 && input_section->reloc_count > 0)
2657 Elf_Internal_Sym *isym, *isymend;
2660 internal_relocs = (_bfd_elf_link_read_relocs
2661 (input_bfd, input_section, NULL, NULL, FALSE));
2662 if (internal_relocs == NULL)
2665 if (symtab_hdr->sh_info != 0)
2667 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2668 if (isymbuf == NULL)
2669 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
2670 symtab_hdr->sh_info, 0,
2672 if (isymbuf == NULL)
2676 amt = symtab_hdr->sh_info;
2677 amt *= sizeof (asection *);
2678 sections = bfd_malloc (amt);
2679 if (sections == NULL && amt != 0)
2682 isymend = isymbuf + symtab_hdr->sh_info;
2683 for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
2687 if (isym->st_shndx == SHN_UNDEF)
2688 isec = bfd_und_section_ptr;
2689 else if (isym->st_shndx == SHN_ABS)
2690 isec = bfd_abs_section_ptr;
2691 else if (isym->st_shndx == SHN_COMMON)
2692 isec = bfd_com_section_ptr;
2694 isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
2699 if (! elf32_avr_relocate_section (output_bfd, link_info, input_bfd,
2700 input_section, data, internal_relocs,
2704 if (sections != NULL)
2707 && symtab_hdr->contents != (unsigned char *) isymbuf)
2709 if (elf_section_data (input_section)->relocs != internal_relocs)
2710 free (internal_relocs);
2716 if (sections != NULL)
2719 && symtab_hdr->contents != (unsigned char *) isymbuf)
2721 if (internal_relocs != NULL
2722 && elf_section_data (input_section)->relocs != internal_relocs)
2723 free (internal_relocs);
2728 /* Determines the hash entry name for a particular reloc. It consists of
2729 the identifier of the symbol section and the added reloc addend and
2730 symbol offset relative to the section the symbol is attached to. */
2733 avr_stub_name (const asection *symbol_section,
2734 const bfd_vma symbol_offset,
2735 const Elf_Internal_Rela *rela)
2740 len = 8 + 1 + 8 + 1 + 1;
2741 stub_name = bfd_malloc (len);
2743 sprintf (stub_name, "%08x+%08x",
2744 symbol_section->id & 0xffffffff,
2745 (unsigned int) ((rela->r_addend & 0xffffffff) + symbol_offset));
2751 /* Add a new stub entry to the stub hash. Not all fields of the new
2752 stub entry are initialised. */
2754 static struct elf32_avr_stub_hash_entry *
2755 avr_add_stub (const char *stub_name,
2756 struct elf32_avr_link_hash_table *htab)
2758 struct elf32_avr_stub_hash_entry *hsh;
2760 /* Enter this entry into the linker stub hash table. */
2761 hsh = avr_stub_hash_lookup (&htab->bstab, stub_name, TRUE, FALSE);
2765 (*_bfd_error_handler) (_("%B: cannot create stub entry %s"),
2770 hsh->stub_offset = 0;
2774 /* We assume that there is already space allocated for the stub section
2775 contents and that before building the stubs the section size is
2776 initialized to 0. We assume that within the stub hash table entry,
2777 the absolute position of the jmp target has been written in the
2778 target_value field. We write here the offset of the generated jmp insn
2779 relative to the trampoline section start to the stub_offset entry in
2780 the stub hash table entry. */
2783 avr_build_one_stub (struct bfd_hash_entry *bh, void *in_arg)
2785 struct elf32_avr_stub_hash_entry *hsh;
2786 struct bfd_link_info *info;
2787 struct elf32_avr_link_hash_table *htab;
2794 bfd_vma jmp_insn = 0x0000940c;
2796 /* Massage our args to the form they really have. */
2797 hsh = avr_stub_hash_entry (bh);
2799 if (!hsh->is_actually_needed)
2802 info = (struct bfd_link_info *) in_arg;
2804 htab = avr_link_hash_table (info);
2808 target = hsh->target_value;
2810 /* Make a note of the offset within the stubs for this entry. */
2811 hsh->stub_offset = htab->stub_sec->size;
2812 loc = htab->stub_sec->contents + hsh->stub_offset;
2814 stub_bfd = htab->stub_sec->owner;
2817 printf ("Building one Stub. Address: 0x%x, Offset: 0x%x\n",
2818 (unsigned int) target,
2819 (unsigned int) hsh->stub_offset);
2821 /* We now have to add the information on the jump target to the bare
2822 opcode bits already set in jmp_insn. */
2824 /* Check for the alignment of the address. */
2828 starget = target >> 1;
2829 jmp_insn |= ((starget & 0x10000) | ((starget << 3) & 0x1f00000)) >> 16;
2830 bfd_put_16 (stub_bfd, jmp_insn, loc);
2831 bfd_put_16 (stub_bfd, (bfd_vma) starget & 0xffff, loc + 2);
2833 htab->stub_sec->size += 4;
2835 /* Now add the entries in the address mapping table if there is still
2840 nr = htab->amt_entry_cnt + 1;
2841 if (nr <= htab->amt_max_entry_cnt)
2843 htab->amt_entry_cnt = nr;
2845 htab->amt_stub_offsets[nr - 1] = hsh->stub_offset;
2846 htab->amt_destination_addr[nr - 1] = target;
2854 avr_mark_stub_not_to_be_necessary (struct bfd_hash_entry *bh,
2855 void *in_arg ATTRIBUTE_UNUSED)
2857 struct elf32_avr_stub_hash_entry *hsh;
2859 hsh = avr_stub_hash_entry (bh);
2860 hsh->is_actually_needed = FALSE;
2866 avr_size_one_stub (struct bfd_hash_entry *bh, void *in_arg)
2868 struct elf32_avr_stub_hash_entry *hsh;
2869 struct elf32_avr_link_hash_table *htab;
2872 /* Massage our args to the form they really have. */
2873 hsh = avr_stub_hash_entry (bh);
2876 if (hsh->is_actually_needed)
2881 htab->stub_sec->size += size;
2886 elf32_avr_setup_params (struct bfd_link_info *info,
2888 asection *avr_stub_section,
2889 bfd_boolean no_stubs,
2890 bfd_boolean deb_stubs,
2891 bfd_boolean deb_relax,
2892 bfd_vma pc_wrap_around,
2893 bfd_boolean call_ret_replacement)
2895 struct elf32_avr_link_hash_table *htab = avr_link_hash_table (info);
2899 htab->stub_sec = avr_stub_section;
2900 htab->stub_bfd = avr_stub_bfd;
2901 htab->no_stubs = no_stubs;
2903 debug_relax = deb_relax;
2904 debug_stubs = deb_stubs;
2905 avr_pc_wrap_around = pc_wrap_around;
2906 avr_replace_call_ret_sequences = call_ret_replacement;
2910 /* Set up various things so that we can make a list of input sections
2911 for each output section included in the link. Returns -1 on error,
2912 0 when no stubs will be needed, and 1 on success. It also sets
2913 information on the stubs bfd and the stub section in the info
2917 elf32_avr_setup_section_lists (bfd *output_bfd,
2918 struct bfd_link_info *info)
2921 unsigned int bfd_count;
2922 int top_id, top_index;
2924 asection **input_list, **list;
2926 struct elf32_avr_link_hash_table *htab = avr_link_hash_table (info);
2928 if (htab == NULL || htab->no_stubs)
2931 /* Count the number of input BFDs and find the top input section id. */
2932 for (input_bfd = info->input_bfds, bfd_count = 0, top_id = 0;
2934 input_bfd = input_bfd->link.next)
2937 for (section = input_bfd->sections;
2939 section = section->next)
2940 if (top_id < section->id)
2941 top_id = section->id;
2944 htab->bfd_count = bfd_count;
2946 /* We can't use output_bfd->section_count here to find the top output
2947 section index as some sections may have been removed, and
2948 strip_excluded_output_sections doesn't renumber the indices. */
2949 for (section = output_bfd->sections, top_index = 0;
2951 section = section->next)
2952 if (top_index < section->index)
2953 top_index = section->index;
2955 htab->top_index = top_index;
2956 amt = sizeof (asection *) * (top_index + 1);
2957 input_list = bfd_malloc (amt);
2958 htab->input_list = input_list;
2959 if (input_list == NULL)
2962 /* For sections we aren't interested in, mark their entries with a
2963 value we can check later. */
2964 list = input_list + top_index;
2966 *list = bfd_abs_section_ptr;
2967 while (list-- != input_list);
2969 for (section = output_bfd->sections;
2971 section = section->next)
2972 if ((section->flags & SEC_CODE) != 0)
2973 input_list[section->index] = NULL;
2979 /* Read in all local syms for all input bfds, and create hash entries
2980 for export stubs if we are building a multi-subspace shared lib.
2981 Returns -1 on error, 0 otherwise. */
2984 get_local_syms (bfd *input_bfd, struct bfd_link_info *info)
2986 unsigned int bfd_indx;
2987 Elf_Internal_Sym *local_syms, **all_local_syms;
2988 struct elf32_avr_link_hash_table *htab = avr_link_hash_table (info);
2994 /* We want to read in symbol extension records only once. To do this
2995 we need to read in the local symbols in parallel and save them for
2996 later use; so hold pointers to the local symbols in an array. */
2997 amt = sizeof (Elf_Internal_Sym *) * htab->bfd_count;
2998 all_local_syms = bfd_zmalloc (amt);
2999 htab->all_local_syms = all_local_syms;
3000 if (all_local_syms == NULL)
3003 /* Walk over all the input BFDs, swapping in local symbols.
3004 If we are creating a shared library, create hash entries for the
3008 input_bfd = input_bfd->link.next, bfd_indx++)
3010 Elf_Internal_Shdr *symtab_hdr;
3012 /* We'll need the symbol table in a second. */
3013 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3014 if (symtab_hdr->sh_info == 0)
3017 /* We need an array of the local symbols attached to the input bfd. */
3018 local_syms = (Elf_Internal_Sym *) symtab_hdr->contents;
3019 if (local_syms == NULL)
3021 local_syms = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
3022 symtab_hdr->sh_info, 0,
3024 /* Cache them for elf_link_input_bfd. */
3025 symtab_hdr->contents = (unsigned char *) local_syms;
3027 if (local_syms == NULL)
3030 all_local_syms[bfd_indx] = local_syms;
3036 #define ADD_DUMMY_STUBS_FOR_DEBUGGING 0
3039 elf32_avr_size_stubs (bfd *output_bfd,
3040 struct bfd_link_info *info,
3041 bfd_boolean is_prealloc_run)
3043 struct elf32_avr_link_hash_table *htab;
3044 int stub_changed = 0;
3046 htab = avr_link_hash_table (info);
3050 /* At this point we initialize htab->vector_base
3051 To the start of the text output section. */
3052 htab->vector_base = htab->stub_sec->output_section->vma;
3054 if (get_local_syms (info->input_bfds, info))
3056 if (htab->all_local_syms)
3057 goto error_ret_free_local;
3061 if (ADD_DUMMY_STUBS_FOR_DEBUGGING)
3063 struct elf32_avr_stub_hash_entry *test;
3065 test = avr_add_stub ("Hugo",htab);
3066 test->target_value = 0x123456;
3067 test->stub_offset = 13;
3069 test = avr_add_stub ("Hugo2",htab);
3070 test->target_value = 0x84210;
3071 test->stub_offset = 14;
3077 unsigned int bfd_indx;
3079 /* We will have to re-generate the stub hash table each time anything
3080 in memory has changed. */
3082 bfd_hash_traverse (&htab->bstab, avr_mark_stub_not_to_be_necessary, htab);
3083 for (input_bfd = info->input_bfds, bfd_indx = 0;
3085 input_bfd = input_bfd->link.next, bfd_indx++)
3087 Elf_Internal_Shdr *symtab_hdr;
3089 Elf_Internal_Sym *local_syms;
3091 /* We'll need the symbol table in a second. */
3092 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3093 if (symtab_hdr->sh_info == 0)
3096 local_syms = htab->all_local_syms[bfd_indx];
3098 /* Walk over each section attached to the input bfd. */
3099 for (section = input_bfd->sections;
3101 section = section->next)
3103 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
3105 /* If there aren't any relocs, then there's nothing more
3107 if ((section->flags & SEC_RELOC) == 0
3108 || section->reloc_count == 0)
3111 /* If this section is a link-once section that will be
3112 discarded, then don't create any stubs. */
3113 if (section->output_section == NULL
3114 || section->output_section->owner != output_bfd)
3117 /* Get the relocs. */
3119 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
3121 if (internal_relocs == NULL)
3122 goto error_ret_free_local;
3124 /* Now examine each relocation. */
3125 irela = internal_relocs;
3126 irelaend = irela + section->reloc_count;
3127 for (; irela < irelaend; irela++)
3129 unsigned int r_type, r_indx;
3130 struct elf32_avr_stub_hash_entry *hsh;
3133 bfd_vma destination;
3134 struct elf_link_hash_entry *hh;
3137 r_type = ELF32_R_TYPE (irela->r_info);
3138 r_indx = ELF32_R_SYM (irela->r_info);
3140 /* Only look for 16 bit GS relocs. No other reloc will need a
3142 if (!((r_type == R_AVR_16_PM)
3143 || (r_type == R_AVR_LO8_LDI_GS)
3144 || (r_type == R_AVR_HI8_LDI_GS)))
3147 /* Now determine the call target, its name, value,
3153 if (r_indx < symtab_hdr->sh_info)
3155 /* It's a local symbol. */
3156 Elf_Internal_Sym *sym;
3157 Elf_Internal_Shdr *hdr;
3160 sym = local_syms + r_indx;
3161 if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
3162 sym_value = sym->st_value;
3163 shndx = sym->st_shndx;
3164 if (shndx < elf_numsections (input_bfd))
3166 hdr = elf_elfsections (input_bfd)[shndx];
3167 sym_sec = hdr->bfd_section;
3168 destination = (sym_value + irela->r_addend
3169 + sym_sec->output_offset
3170 + sym_sec->output_section->vma);
3175 /* It's an external symbol. */
3178 e_indx = r_indx - symtab_hdr->sh_info;
3179 hh = elf_sym_hashes (input_bfd)[e_indx];
3181 while (hh->root.type == bfd_link_hash_indirect
3182 || hh->root.type == bfd_link_hash_warning)
3183 hh = (struct elf_link_hash_entry *)
3184 (hh->root.u.i.link);
3186 if (hh->root.type == bfd_link_hash_defined
3187 || hh->root.type == bfd_link_hash_defweak)
3189 sym_sec = hh->root.u.def.section;
3190 sym_value = hh->root.u.def.value;
3191 if (sym_sec->output_section != NULL)
3192 destination = (sym_value + irela->r_addend
3193 + sym_sec->output_offset
3194 + sym_sec->output_section->vma);
3196 else if (hh->root.type == bfd_link_hash_undefweak)
3201 else if (hh->root.type == bfd_link_hash_undefined)
3203 if (! (info->unresolved_syms_in_objects == RM_IGNORE
3204 && (ELF_ST_VISIBILITY (hh->other)
3210 bfd_set_error (bfd_error_bad_value);
3212 error_ret_free_internal:
3213 if (elf_section_data (section)->relocs == NULL)
3214 free (internal_relocs);
3215 goto error_ret_free_local;
3219 if (! avr_stub_is_required_for_16_bit_reloc
3220 (destination - htab->vector_base))
3222 if (!is_prealloc_run)
3223 /* We are having a reloc that does't need a stub. */
3226 /* We don't right now know if a stub will be needed.
3227 Let's rather be on the safe side. */
3230 /* Get the name of this stub. */
3231 stub_name = avr_stub_name (sym_sec, sym_value, irela);
3234 goto error_ret_free_internal;
3237 hsh = avr_stub_hash_lookup (&htab->bstab,
3242 /* The proper stub has already been created. Mark it
3243 to be used and write the possibly changed destination
3245 hsh->is_actually_needed = TRUE;
3246 hsh->target_value = destination;
3251 hsh = avr_add_stub (stub_name, htab);
3255 goto error_ret_free_internal;
3258 hsh->is_actually_needed = TRUE;
3259 hsh->target_value = destination;
3262 printf ("Adding stub with destination 0x%x to the"
3263 " hash table.\n", (unsigned int) destination);
3265 printf ("(Pre-Alloc run: %i)\n", is_prealloc_run);
3267 stub_changed = TRUE;
3270 /* We're done with the internal relocs, free them. */
3271 if (elf_section_data (section)->relocs == NULL)
3272 free (internal_relocs);
3276 /* Re-Calculate the number of needed stubs. */
3277 htab->stub_sec->size = 0;
3278 bfd_hash_traverse (&htab->bstab, avr_size_one_stub, htab);
3283 stub_changed = FALSE;
3286 free (htab->all_local_syms);
3289 error_ret_free_local:
3290 free (htab->all_local_syms);
3295 /* Build all the stubs associated with the current output file. The
3296 stubs are kept in a hash table attached to the main linker hash
3297 table. We also set up the .plt entries for statically linked PIC
3298 functions here. This function is called via hppaelf_finish in the
3302 elf32_avr_build_stubs (struct bfd_link_info *info)
3305 struct bfd_hash_table *table;
3306 struct elf32_avr_link_hash_table *htab;
3307 bfd_size_type total_size = 0;
3309 htab = avr_link_hash_table (info);
3313 /* In case that there were several stub sections: */
3314 for (stub_sec = htab->stub_bfd->sections;
3316 stub_sec = stub_sec->next)
3320 /* Allocate memory to hold the linker stubs. */
3321 size = stub_sec->size;
3324 stub_sec->contents = bfd_zalloc (htab->stub_bfd, size);
3325 if (stub_sec->contents == NULL && size != 0)
3330 /* Allocate memory for the adress mapping table. */
3331 htab->amt_entry_cnt = 0;
3332 htab->amt_max_entry_cnt = total_size / 4;
3333 htab->amt_stub_offsets = bfd_malloc (sizeof (bfd_vma)
3334 * htab->amt_max_entry_cnt);
3335 htab->amt_destination_addr = bfd_malloc (sizeof (bfd_vma)
3336 * htab->amt_max_entry_cnt );
3339 printf ("Allocating %i entries in the AMT\n", htab->amt_max_entry_cnt);
3341 /* Build the stubs as directed by the stub hash table. */
3342 table = &htab->bstab;
3343 bfd_hash_traverse (table, avr_build_one_stub, info);
3346 printf ("Final Stub section Size: %i\n", (int) htab->stub_sec->size);
3351 #define ELF_ARCH bfd_arch_avr
3352 #define ELF_TARGET_ID AVR_ELF_DATA
3353 #define ELF_MACHINE_CODE EM_AVR
3354 #define ELF_MACHINE_ALT1 EM_AVR_OLD
3355 #define ELF_MAXPAGESIZE 1
3357 #define TARGET_LITTLE_SYM avr_elf32_vec
3358 #define TARGET_LITTLE_NAME "elf32-avr"
3360 #define bfd_elf32_bfd_link_hash_table_create elf32_avr_link_hash_table_create
3362 #define elf_info_to_howto avr_info_to_howto_rela
3363 #define elf_info_to_howto_rel NULL
3364 #define elf_backend_relocate_section elf32_avr_relocate_section
3365 #define elf_backend_can_gc_sections 1
3366 #define elf_backend_rela_normal 1
3367 #define elf_backend_final_write_processing \
3368 bfd_elf_avr_final_write_processing
3369 #define elf_backend_object_p elf32_avr_object_p
3371 #define bfd_elf32_bfd_relax_section elf32_avr_relax_section
3372 #define bfd_elf32_bfd_get_relocated_section_contents \
3373 elf32_avr_get_relocated_section_contents
3375 #include "elf32-target.h"