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 */
619 /* Map BFD reloc types to AVR ELF reloc types. */
623 bfd_reloc_code_real_type bfd_reloc_val;
624 unsigned int elf_reloc_val;
627 static const struct avr_reloc_map avr_reloc_map[] =
629 { BFD_RELOC_NONE, R_AVR_NONE },
630 { BFD_RELOC_32, R_AVR_32 },
631 { BFD_RELOC_AVR_7_PCREL, R_AVR_7_PCREL },
632 { BFD_RELOC_AVR_13_PCREL, R_AVR_13_PCREL },
633 { BFD_RELOC_16, R_AVR_16 },
634 { BFD_RELOC_AVR_16_PM, R_AVR_16_PM },
635 { BFD_RELOC_AVR_LO8_LDI, R_AVR_LO8_LDI},
636 { BFD_RELOC_AVR_HI8_LDI, R_AVR_HI8_LDI },
637 { BFD_RELOC_AVR_HH8_LDI, R_AVR_HH8_LDI },
638 { BFD_RELOC_AVR_MS8_LDI, R_AVR_MS8_LDI },
639 { BFD_RELOC_AVR_LO8_LDI_NEG, R_AVR_LO8_LDI_NEG },
640 { BFD_RELOC_AVR_HI8_LDI_NEG, R_AVR_HI8_LDI_NEG },
641 { BFD_RELOC_AVR_HH8_LDI_NEG, R_AVR_HH8_LDI_NEG },
642 { BFD_RELOC_AVR_MS8_LDI_NEG, R_AVR_MS8_LDI_NEG },
643 { BFD_RELOC_AVR_LO8_LDI_PM, R_AVR_LO8_LDI_PM },
644 { BFD_RELOC_AVR_LO8_LDI_GS, R_AVR_LO8_LDI_GS },
645 { BFD_RELOC_AVR_HI8_LDI_PM, R_AVR_HI8_LDI_PM },
646 { BFD_RELOC_AVR_HI8_LDI_GS, R_AVR_HI8_LDI_GS },
647 { BFD_RELOC_AVR_HH8_LDI_PM, R_AVR_HH8_LDI_PM },
648 { BFD_RELOC_AVR_LO8_LDI_PM_NEG, R_AVR_LO8_LDI_PM_NEG },
649 { BFD_RELOC_AVR_HI8_LDI_PM_NEG, R_AVR_HI8_LDI_PM_NEG },
650 { BFD_RELOC_AVR_HH8_LDI_PM_NEG, R_AVR_HH8_LDI_PM_NEG },
651 { BFD_RELOC_AVR_CALL, R_AVR_CALL },
652 { BFD_RELOC_AVR_LDI, R_AVR_LDI },
653 { BFD_RELOC_AVR_6, R_AVR_6 },
654 { BFD_RELOC_AVR_6_ADIW, R_AVR_6_ADIW },
655 { BFD_RELOC_8, R_AVR_8 },
656 { BFD_RELOC_AVR_8_LO, R_AVR_8_LO8 },
657 { BFD_RELOC_AVR_8_HI, R_AVR_8_HI8 },
658 { BFD_RELOC_AVR_8_HLO, R_AVR_8_HLO8 },
659 { BFD_RELOC_AVR_DIFF8, R_AVR_DIFF8 },
660 { BFD_RELOC_AVR_DIFF16, R_AVR_DIFF16 },
661 { BFD_RELOC_AVR_DIFF32, R_AVR_DIFF32 },
662 { BFD_RELOC_AVR_LDS_STS_16, R_AVR_LDS_STS_16}
665 /* Meant to be filled one day with the wrap around address for the
666 specific device. I.e. should get the value 0x4000 for 16k devices,
667 0x8000 for 32k devices and so on.
669 We initialize it here with a value of 0x1000000 resulting in
670 that we will never suggest a wrap-around jump during relaxation.
671 The logic of the source code later on assumes that in
672 avr_pc_wrap_around one single bit is set. */
673 static bfd_vma avr_pc_wrap_around = 0x10000000;
675 /* If this variable holds a value different from zero, the linker relaxation
676 machine will try to optimize call/ret sequences by a single jump
677 instruction. This option could be switched off by a linker switch. */
678 static int avr_replace_call_ret_sequences = 1;
680 /* Initialize an entry in the stub hash table. */
682 static struct bfd_hash_entry *
683 stub_hash_newfunc (struct bfd_hash_entry *entry,
684 struct bfd_hash_table *table,
687 /* Allocate the structure if it has not already been allocated by a
691 entry = bfd_hash_allocate (table,
692 sizeof (struct elf32_avr_stub_hash_entry));
697 /* Call the allocation method of the superclass. */
698 entry = bfd_hash_newfunc (entry, table, string);
701 struct elf32_avr_stub_hash_entry *hsh;
703 /* Initialize the local fields. */
704 hsh = avr_stub_hash_entry (entry);
705 hsh->stub_offset = 0;
706 hsh->target_value = 0;
712 /* This function is just a straight passthrough to the real
713 function in linker.c. Its prupose is so that its address
714 can be compared inside the avr_link_hash_table macro. */
716 static struct bfd_hash_entry *
717 elf32_avr_link_hash_newfunc (struct bfd_hash_entry * entry,
718 struct bfd_hash_table * table,
721 return _bfd_elf_link_hash_newfunc (entry, table, string);
724 /* Free the derived linker hash table. */
727 elf32_avr_link_hash_table_free (bfd *obfd)
729 struct elf32_avr_link_hash_table *htab
730 = (struct elf32_avr_link_hash_table *) obfd->link.hash;
732 /* Free the address mapping table. */
733 if (htab->amt_stub_offsets != NULL)
734 free (htab->amt_stub_offsets);
735 if (htab->amt_destination_addr != NULL)
736 free (htab->amt_destination_addr);
738 bfd_hash_table_free (&htab->bstab);
739 _bfd_elf_link_hash_table_free (obfd);
742 /* Create the derived linker hash table. The AVR ELF port uses the derived
743 hash table to keep information specific to the AVR ELF linker (without
744 using static variables). */
746 static struct bfd_link_hash_table *
747 elf32_avr_link_hash_table_create (bfd *abfd)
749 struct elf32_avr_link_hash_table *htab;
750 bfd_size_type amt = sizeof (*htab);
752 htab = bfd_zmalloc (amt);
756 if (!_bfd_elf_link_hash_table_init (&htab->etab, abfd,
757 elf32_avr_link_hash_newfunc,
758 sizeof (struct elf_link_hash_entry),
765 /* Init the stub hash table too. */
766 if (!bfd_hash_table_init (&htab->bstab, stub_hash_newfunc,
767 sizeof (struct elf32_avr_stub_hash_entry)))
769 _bfd_elf_link_hash_table_free (abfd);
772 htab->etab.root.hash_table_free = elf32_avr_link_hash_table_free;
774 return &htab->etab.root;
777 /* Calculates the effective distance of a pc relative jump/call. */
780 avr_relative_distance_considering_wrap_around (unsigned int distance)
782 unsigned int wrap_around_mask = avr_pc_wrap_around - 1;
783 int dist_with_wrap_around = distance & wrap_around_mask;
785 if (dist_with_wrap_around > ((int) (avr_pc_wrap_around >> 1)))
786 dist_with_wrap_around -= avr_pc_wrap_around;
788 return dist_with_wrap_around;
792 static reloc_howto_type *
793 bfd_elf32_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
794 bfd_reloc_code_real_type code)
799 i < sizeof (avr_reloc_map) / sizeof (struct avr_reloc_map);
801 if (avr_reloc_map[i].bfd_reloc_val == code)
802 return &elf_avr_howto_table[avr_reloc_map[i].elf_reloc_val];
807 static reloc_howto_type *
808 bfd_elf32_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
814 i < sizeof (elf_avr_howto_table) / sizeof (elf_avr_howto_table[0]);
816 if (elf_avr_howto_table[i].name != NULL
817 && strcasecmp (elf_avr_howto_table[i].name, r_name) == 0)
818 return &elf_avr_howto_table[i];
823 /* Set the howto pointer for an AVR ELF reloc. */
826 avr_info_to_howto_rela (bfd *abfd ATTRIBUTE_UNUSED,
828 Elf_Internal_Rela *dst)
832 r_type = ELF32_R_TYPE (dst->r_info);
833 BFD_ASSERT (r_type < (unsigned int) R_AVR_max);
834 cache_ptr->howto = &elf_avr_howto_table[r_type];
838 avr_stub_is_required_for_16_bit_reloc (bfd_vma relocation)
840 return (relocation >= 0x020000);
843 /* Returns the address of the corresponding stub if there is one.
844 Returns otherwise an address above 0x020000. This function
845 could also be used, if there is no knowledge on the section where
846 the destination is found. */
849 avr_get_stub_addr (bfd_vma srel,
850 struct elf32_avr_link_hash_table *htab)
853 bfd_vma stub_sec_addr =
854 (htab->stub_sec->output_section->vma +
855 htab->stub_sec->output_offset);
857 for (sindex = 0; sindex < htab->amt_max_entry_cnt; sindex ++)
858 if (htab->amt_destination_addr[sindex] == srel)
859 return htab->amt_stub_offsets[sindex] + stub_sec_addr;
861 /* Return an address that could not be reached by 16 bit relocs. */
865 /* Perform a diff relocation. Nothing to do, as the difference value is already
866 written into the section's contents. */
868 static bfd_reloc_status_type
869 bfd_elf_avr_diff_reloc (bfd *abfd ATTRIBUTE_UNUSED,
870 arelent *reloc_entry ATTRIBUTE_UNUSED,
871 asymbol *symbol ATTRIBUTE_UNUSED,
872 void *data ATTRIBUTE_UNUSED,
873 asection *input_section ATTRIBUTE_UNUSED,
874 bfd *output_bfd ATTRIBUTE_UNUSED,
875 char **error_message ATTRIBUTE_UNUSED)
881 /* Perform a single relocation. By default we use the standard BFD
882 routines, but a few relocs, we have to do them ourselves. */
884 static bfd_reloc_status_type
885 avr_final_link_relocate (reloc_howto_type * howto,
887 asection * input_section,
889 Elf_Internal_Rela * rel,
891 struct elf32_avr_link_hash_table * htab)
893 bfd_reloc_status_type r = bfd_reloc_ok;
896 bfd_signed_vma reloc_addr;
897 bfd_boolean use_stubs = FALSE;
898 /* Usually is 0, unless we are generating code for a bootloader. */
899 bfd_signed_vma base_addr = htab->vector_base;
901 /* Absolute addr of the reloc in the final excecutable. */
902 reloc_addr = rel->r_offset + input_section->output_section->vma
903 + input_section->output_offset;
908 contents += rel->r_offset;
909 srel = (bfd_signed_vma) relocation;
910 srel += rel->r_addend;
911 srel -= rel->r_offset;
912 srel -= 2; /* Branch instructions add 2 to the PC... */
913 srel -= (input_section->output_section->vma +
914 input_section->output_offset);
917 return bfd_reloc_outofrange;
918 if (srel > ((1 << 7) - 1) || (srel < - (1 << 7)))
919 return bfd_reloc_overflow;
920 x = bfd_get_16 (input_bfd, contents);
921 x = (x & 0xfc07) | (((srel >> 1) << 3) & 0x3f8);
922 bfd_put_16 (input_bfd, x, contents);
926 contents += rel->r_offset;
927 srel = (bfd_signed_vma) relocation;
928 srel += rel->r_addend;
929 srel -= rel->r_offset;
930 srel -= 2; /* Branch instructions add 2 to the PC... */
931 srel -= (input_section->output_section->vma +
932 input_section->output_offset);
935 return bfd_reloc_outofrange;
937 srel = avr_relative_distance_considering_wrap_around (srel);
939 /* AVR addresses commands as words. */
942 /* Check for overflow. */
943 if (srel < -2048 || srel > 2047)
945 /* Relative distance is too large. */
947 /* Always apply WRAPAROUND for avr2, avr25, and avr4. */
948 switch (bfd_get_mach (input_bfd))
956 return bfd_reloc_overflow;
960 x = bfd_get_16 (input_bfd, contents);
961 x = (x & 0xf000) | (srel & 0xfff);
962 bfd_put_16 (input_bfd, x, contents);
966 contents += rel->r_offset;
967 srel = (bfd_signed_vma) relocation + rel->r_addend;
968 x = bfd_get_16 (input_bfd, contents);
969 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
970 bfd_put_16 (input_bfd, x, contents);
974 contents += rel->r_offset;
975 srel = (bfd_signed_vma) relocation + rel->r_addend;
976 if (((srel > 0) && (srel & 0xffff) > 255)
977 || ((srel < 0) && ((-srel) & 0xffff) > 128))
978 /* Remove offset for data/eeprom section. */
979 return bfd_reloc_overflow;
981 x = bfd_get_16 (input_bfd, contents);
982 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
983 bfd_put_16 (input_bfd, x, contents);
987 contents += rel->r_offset;
988 srel = (bfd_signed_vma) relocation + rel->r_addend;
989 if (((srel & 0xffff) > 63) || (srel < 0))
990 /* Remove offset for data/eeprom section. */
991 return bfd_reloc_overflow;
992 x = bfd_get_16 (input_bfd, contents);
993 x = (x & 0xd3f8) | ((srel & 7) | ((srel & (3 << 3)) << 7)
994 | ((srel & (1 << 5)) << 8));
995 bfd_put_16 (input_bfd, x, contents);
999 contents += rel->r_offset;
1000 srel = (bfd_signed_vma) relocation + rel->r_addend;
1001 if (((srel & 0xffff) > 63) || (srel < 0))
1002 /* Remove offset for data/eeprom section. */
1003 return bfd_reloc_overflow;
1004 x = bfd_get_16 (input_bfd, contents);
1005 x = (x & 0xff30) | (srel & 0xf) | ((srel & 0x30) << 2);
1006 bfd_put_16 (input_bfd, x, contents);
1010 contents += rel->r_offset;
1011 srel = (bfd_signed_vma) relocation + rel->r_addend;
1012 srel = (srel >> 8) & 0xff;
1013 x = bfd_get_16 (input_bfd, contents);
1014 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1015 bfd_put_16 (input_bfd, x, contents);
1019 contents += rel->r_offset;
1020 srel = (bfd_signed_vma) relocation + rel->r_addend;
1021 srel = (srel >> 16) & 0xff;
1022 x = bfd_get_16 (input_bfd, contents);
1023 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1024 bfd_put_16 (input_bfd, x, contents);
1028 contents += rel->r_offset;
1029 srel = (bfd_signed_vma) relocation + rel->r_addend;
1030 srel = (srel >> 24) & 0xff;
1031 x = bfd_get_16 (input_bfd, contents);
1032 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1033 bfd_put_16 (input_bfd, x, contents);
1036 case R_AVR_LO8_LDI_NEG:
1037 contents += rel->r_offset;
1038 srel = (bfd_signed_vma) relocation + rel->r_addend;
1040 x = bfd_get_16 (input_bfd, contents);
1041 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1042 bfd_put_16 (input_bfd, x, contents);
1045 case R_AVR_HI8_LDI_NEG:
1046 contents += rel->r_offset;
1047 srel = (bfd_signed_vma) relocation + rel->r_addend;
1049 srel = (srel >> 8) & 0xff;
1050 x = bfd_get_16 (input_bfd, contents);
1051 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1052 bfd_put_16 (input_bfd, x, contents);
1055 case R_AVR_HH8_LDI_NEG:
1056 contents += rel->r_offset;
1057 srel = (bfd_signed_vma) relocation + rel->r_addend;
1059 srel = (srel >> 16) & 0xff;
1060 x = bfd_get_16 (input_bfd, contents);
1061 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1062 bfd_put_16 (input_bfd, x, contents);
1065 case R_AVR_MS8_LDI_NEG:
1066 contents += rel->r_offset;
1067 srel = (bfd_signed_vma) relocation + rel->r_addend;
1069 srel = (srel >> 24) & 0xff;
1070 x = bfd_get_16 (input_bfd, contents);
1071 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1072 bfd_put_16 (input_bfd, x, contents);
1075 case R_AVR_LO8_LDI_GS:
1076 use_stubs = (!htab->no_stubs);
1078 case R_AVR_LO8_LDI_PM:
1079 contents += rel->r_offset;
1080 srel = (bfd_signed_vma) relocation + rel->r_addend;
1083 && avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1085 bfd_vma old_srel = srel;
1087 /* We need to use the address of the stub instead. */
1088 srel = avr_get_stub_addr (srel, htab);
1090 printf ("LD: Using jump stub (at 0x%x) with destination 0x%x for "
1091 "reloc at address 0x%x.\n",
1092 (unsigned int) srel,
1093 (unsigned int) old_srel,
1094 (unsigned int) reloc_addr);
1096 if (avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1097 return bfd_reloc_outofrange;
1101 return bfd_reloc_outofrange;
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_HI8_LDI_GS:
1109 use_stubs = (!htab->no_stubs);
1111 case R_AVR_HI8_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 srel = (srel >> 8) & 0xff;
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_HH8_LDI_PM:
1143 contents += rel->r_offset;
1144 srel = (bfd_signed_vma) relocation + rel->r_addend;
1146 return bfd_reloc_outofrange;
1148 srel = (srel >> 16) & 0xff;
1149 x = bfd_get_16 (input_bfd, contents);
1150 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1151 bfd_put_16 (input_bfd, x, contents);
1154 case R_AVR_LO8_LDI_PM_NEG:
1155 contents += rel->r_offset;
1156 srel = (bfd_signed_vma) relocation + rel->r_addend;
1159 return bfd_reloc_outofrange;
1161 x = bfd_get_16 (input_bfd, contents);
1162 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1163 bfd_put_16 (input_bfd, x, contents);
1166 case R_AVR_HI8_LDI_PM_NEG:
1167 contents += rel->r_offset;
1168 srel = (bfd_signed_vma) relocation + rel->r_addend;
1171 return bfd_reloc_outofrange;
1173 srel = (srel >> 8) & 0xff;
1174 x = bfd_get_16 (input_bfd, contents);
1175 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1176 bfd_put_16 (input_bfd, x, contents);
1179 case R_AVR_HH8_LDI_PM_NEG:
1180 contents += rel->r_offset;
1181 srel = (bfd_signed_vma) relocation + rel->r_addend;
1184 return bfd_reloc_outofrange;
1186 srel = (srel >> 16) & 0xff;
1187 x = bfd_get_16 (input_bfd, contents);
1188 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1189 bfd_put_16 (input_bfd, x, contents);
1193 contents += rel->r_offset;
1194 srel = (bfd_signed_vma) relocation + rel->r_addend;
1196 return bfd_reloc_outofrange;
1198 x = bfd_get_16 (input_bfd, contents);
1199 x |= ((srel & 0x10000) | ((srel << 3) & 0x1f00000)) >> 16;
1200 bfd_put_16 (input_bfd, x, contents);
1201 bfd_put_16 (input_bfd, (bfd_vma) srel & 0xffff, contents+2);
1205 use_stubs = (!htab->no_stubs);
1206 contents += rel->r_offset;
1207 srel = (bfd_signed_vma) relocation + rel->r_addend;
1210 && avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1212 bfd_vma old_srel = srel;
1214 /* We need to use the address of the stub instead. */
1215 srel = avr_get_stub_addr (srel,htab);
1217 printf ("LD: Using jump stub (at 0x%x) with destination 0x%x for "
1218 "reloc at address 0x%x.\n",
1219 (unsigned int) srel,
1220 (unsigned int) old_srel,
1221 (unsigned int) reloc_addr);
1223 if (avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1224 return bfd_reloc_outofrange;
1228 return bfd_reloc_outofrange;
1230 bfd_put_16 (input_bfd, (bfd_vma) srel &0x00ffff, contents);
1236 /* Nothing to do here, as contents already contains the diff value. */
1240 case R_AVR_LDS_STS_16:
1241 contents += rel->r_offset;
1242 srel = (bfd_signed_vma) relocation + rel->r_addend;
1243 if ((srel & 0xFFFF) < 0x40 || (srel & 0xFFFF) > 0xbf)
1244 return bfd_reloc_outofrange;
1246 x = bfd_get_16 (input_bfd, contents);
1247 x |= (srel & 0x0f) | ((srel & 0x30) << 5) | ((srel & 0x40) << 2);
1248 bfd_put_16 (input_bfd, x, contents);
1252 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1253 contents, rel->r_offset,
1254 relocation, rel->r_addend);
1260 /* Relocate an AVR ELF section. */
1263 elf32_avr_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED,
1264 struct bfd_link_info *info,
1266 asection *input_section,
1268 Elf_Internal_Rela *relocs,
1269 Elf_Internal_Sym *local_syms,
1270 asection **local_sections)
1272 Elf_Internal_Shdr * symtab_hdr;
1273 struct elf_link_hash_entry ** sym_hashes;
1274 Elf_Internal_Rela * rel;
1275 Elf_Internal_Rela * relend;
1276 struct elf32_avr_link_hash_table * htab = avr_link_hash_table (info);
1281 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
1282 sym_hashes = elf_sym_hashes (input_bfd);
1283 relend = relocs + input_section->reloc_count;
1285 for (rel = relocs; rel < relend; rel ++)
1287 reloc_howto_type * howto;
1288 unsigned long r_symndx;
1289 Elf_Internal_Sym * sym;
1291 struct elf_link_hash_entry * h;
1293 bfd_reloc_status_type r;
1297 r_type = ELF32_R_TYPE (rel->r_info);
1298 r_symndx = ELF32_R_SYM (rel->r_info);
1299 howto = elf_avr_howto_table + r_type;
1304 if (r_symndx < symtab_hdr->sh_info)
1306 sym = local_syms + r_symndx;
1307 sec = local_sections [r_symndx];
1308 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1310 name = bfd_elf_string_from_elf_section
1311 (input_bfd, symtab_hdr->sh_link, sym->st_name);
1312 name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
1316 bfd_boolean unresolved_reloc, warned, ignored;
1318 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1319 r_symndx, symtab_hdr, sym_hashes,
1321 unresolved_reloc, warned, ignored);
1323 name = h->root.root.string;
1326 if (sec != NULL && discarded_section (sec))
1327 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
1328 rel, 1, relend, howto, 0, contents);
1330 if (info->relocatable)
1333 r = avr_final_link_relocate (howto, input_bfd, input_section,
1334 contents, rel, relocation, htab);
1336 if (r != bfd_reloc_ok)
1338 const char * msg = (const char *) NULL;
1342 case bfd_reloc_overflow:
1343 r = info->callbacks->reloc_overflow
1344 (info, (h ? &h->root : NULL),
1345 name, howto->name, (bfd_vma) 0,
1346 input_bfd, input_section, rel->r_offset);
1349 case bfd_reloc_undefined:
1350 r = info->callbacks->undefined_symbol
1351 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
1354 case bfd_reloc_outofrange:
1355 msg = _("internal error: out of range error");
1358 case bfd_reloc_notsupported:
1359 msg = _("internal error: unsupported relocation error");
1362 case bfd_reloc_dangerous:
1363 msg = _("internal error: dangerous relocation");
1367 msg = _("internal error: unknown error");
1372 r = info->callbacks->warning
1373 (info, msg, name, input_bfd, input_section, rel->r_offset);
1383 /* The final processing done just before writing out a AVR ELF object
1384 file. This gets the AVR architecture right based on the machine
1388 bfd_elf_avr_final_write_processing (bfd *abfd,
1389 bfd_boolean linker ATTRIBUTE_UNUSED)
1393 switch (bfd_get_mach (abfd))
1397 val = E_AVR_MACH_AVR2;
1401 val = E_AVR_MACH_AVR1;
1404 case bfd_mach_avr25:
1405 val = E_AVR_MACH_AVR25;
1409 val = E_AVR_MACH_AVR3;
1412 case bfd_mach_avr31:
1413 val = E_AVR_MACH_AVR31;
1416 case bfd_mach_avr35:
1417 val = E_AVR_MACH_AVR35;
1421 val = E_AVR_MACH_AVR4;
1425 val = E_AVR_MACH_AVR5;
1428 case bfd_mach_avr51:
1429 val = E_AVR_MACH_AVR51;
1433 val = E_AVR_MACH_AVR6;
1436 case bfd_mach_avrxmega1:
1437 val = E_AVR_MACH_XMEGA1;
1440 case bfd_mach_avrxmega2:
1441 val = E_AVR_MACH_XMEGA2;
1444 case bfd_mach_avrxmega3:
1445 val = E_AVR_MACH_XMEGA3;
1448 case bfd_mach_avrxmega4:
1449 val = E_AVR_MACH_XMEGA4;
1452 case bfd_mach_avrxmega5:
1453 val = E_AVR_MACH_XMEGA5;
1456 case bfd_mach_avrxmega6:
1457 val = E_AVR_MACH_XMEGA6;
1460 case bfd_mach_avrxmega7:
1461 val = E_AVR_MACH_XMEGA7;
1464 case bfd_mach_avrtiny:
1465 val = E_AVR_MACH_AVRTINY;
1469 elf_elfheader (abfd)->e_machine = EM_AVR;
1470 elf_elfheader (abfd)->e_flags &= ~ EF_AVR_MACH;
1471 elf_elfheader (abfd)->e_flags |= val;
1472 elf_elfheader (abfd)->e_flags |= EF_AVR_LINKRELAX_PREPARED;
1475 /* Set the right machine number. */
1478 elf32_avr_object_p (bfd *abfd)
1480 unsigned int e_set = bfd_mach_avr2;
1482 if (elf_elfheader (abfd)->e_machine == EM_AVR
1483 || elf_elfheader (abfd)->e_machine == EM_AVR_OLD)
1485 int e_mach = elf_elfheader (abfd)->e_flags & EF_AVR_MACH;
1490 case E_AVR_MACH_AVR2:
1491 e_set = bfd_mach_avr2;
1494 case E_AVR_MACH_AVR1:
1495 e_set = bfd_mach_avr1;
1498 case E_AVR_MACH_AVR25:
1499 e_set = bfd_mach_avr25;
1502 case E_AVR_MACH_AVR3:
1503 e_set = bfd_mach_avr3;
1506 case E_AVR_MACH_AVR31:
1507 e_set = bfd_mach_avr31;
1510 case E_AVR_MACH_AVR35:
1511 e_set = bfd_mach_avr35;
1514 case E_AVR_MACH_AVR4:
1515 e_set = bfd_mach_avr4;
1518 case E_AVR_MACH_AVR5:
1519 e_set = bfd_mach_avr5;
1522 case E_AVR_MACH_AVR51:
1523 e_set = bfd_mach_avr51;
1526 case E_AVR_MACH_AVR6:
1527 e_set = bfd_mach_avr6;
1530 case E_AVR_MACH_XMEGA1:
1531 e_set = bfd_mach_avrxmega1;
1534 case E_AVR_MACH_XMEGA2:
1535 e_set = bfd_mach_avrxmega2;
1538 case E_AVR_MACH_XMEGA3:
1539 e_set = bfd_mach_avrxmega3;
1542 case E_AVR_MACH_XMEGA4:
1543 e_set = bfd_mach_avrxmega4;
1546 case E_AVR_MACH_XMEGA5:
1547 e_set = bfd_mach_avrxmega5;
1550 case E_AVR_MACH_XMEGA6:
1551 e_set = bfd_mach_avrxmega6;
1554 case E_AVR_MACH_XMEGA7:
1555 e_set = bfd_mach_avrxmega7;
1558 case E_AVR_MACH_AVRTINY:
1559 e_set = bfd_mach_avrtiny;
1563 return bfd_default_set_arch_mach (abfd, bfd_arch_avr,
1567 /* Returns whether the relocation type passed is a diff reloc. */
1570 elf32_avr_is_diff_reloc (Elf_Internal_Rela *irel)
1572 return (ELF32_R_TYPE (irel->r_info) == R_AVR_DIFF8
1573 ||ELF32_R_TYPE (irel->r_info) == R_AVR_DIFF16
1574 || ELF32_R_TYPE (irel->r_info) == R_AVR_DIFF32);
1577 /* Reduce the diff value written in the section by count if the shrinked
1578 insn address happens to fall between the two symbols for which this
1579 diff reloc was emitted. */
1582 elf32_avr_adjust_diff_reloc_value (bfd *abfd,
1583 struct bfd_section *isec,
1584 Elf_Internal_Rela *irel,
1586 bfd_vma shrinked_insn_address,
1589 unsigned char *reloc_contents = NULL;
1590 unsigned char *isec_contents = elf_section_data (isec)->this_hdr.contents;
1591 if (isec_contents == NULL)
1593 if (! bfd_malloc_and_get_section (abfd, isec, &isec_contents))
1596 elf_section_data (isec)->this_hdr.contents = isec_contents;
1599 reloc_contents = isec_contents + irel->r_offset;
1601 /* Read value written in object file. */
1603 switch (ELF32_R_TYPE (irel->r_info))
1607 x = *reloc_contents;
1612 x = bfd_get_16 (abfd, reloc_contents);
1617 x = bfd_get_32 (abfd, reloc_contents);
1626 /* For a diff reloc sym1 - sym2 the diff at assembly time (x) is written
1627 into the object file at the reloc offset. sym2's logical value is
1628 symval (<start_of_section>) + reloc addend. Compute the start and end
1629 addresses and check if the shrinked insn falls between sym1 and sym2. */
1631 bfd_vma end_address = symval + irel->r_addend;
1632 bfd_vma start_address = end_address - x;
1634 /* Reduce the diff value by count bytes and write it back into section
1637 if (shrinked_insn_address >= start_address
1638 && shrinked_insn_address <= end_address)
1640 switch (ELF32_R_TYPE (irel->r_info))
1644 *reloc_contents = (x - count);
1649 bfd_put_16 (abfd, (x - count) & 0xFFFF, reloc_contents);
1654 bfd_put_32 (abfd, (x - count) & 0xFFFFFFFF, reloc_contents);
1666 /* Delete some bytes from a section while changing the size of an instruction.
1667 The parameter "addr" denotes the section-relative offset pointing just
1668 behind the shrinked instruction. "addr+count" point at the first
1669 byte just behind the original unshrinked instruction. */
1672 elf32_avr_relax_delete_bytes (bfd *abfd,
1677 Elf_Internal_Shdr *symtab_hdr;
1678 unsigned int sec_shndx;
1680 Elf_Internal_Rela *irel, *irelend;
1681 Elf_Internal_Sym *isym;
1682 Elf_Internal_Sym *isymbuf = NULL;
1684 struct elf_link_hash_entry **sym_hashes;
1685 struct elf_link_hash_entry **end_hashes;
1686 unsigned int symcount;
1688 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1689 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1690 contents = elf_section_data (sec)->this_hdr.contents;
1694 irel = elf_section_data (sec)->relocs;
1695 irelend = irel + sec->reloc_count;
1697 /* Actually delete the bytes. */
1698 if (toaddr - addr - count > 0)
1699 memmove (contents + addr, contents + addr + count,
1700 (size_t) (toaddr - addr - count));
1703 /* Adjust all the reloc addresses. */
1704 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1706 bfd_vma old_reloc_address;
1708 old_reloc_address = (sec->output_section->vma
1709 + sec->output_offset + irel->r_offset);
1711 /* Get the new reloc address. */
1712 if ((irel->r_offset > addr
1713 && irel->r_offset < toaddr))
1716 printf ("Relocation at address 0x%x needs to be moved.\n"
1717 "Old section offset: 0x%x, New section offset: 0x%x \n",
1718 (unsigned int) old_reloc_address,
1719 (unsigned int) irel->r_offset,
1720 (unsigned int) ((irel->r_offset) - count));
1722 irel->r_offset -= count;
1727 /* The reloc's own addresses are now ok. However, we need to readjust
1728 the reloc's addend, i.e. the reloc's value if two conditions are met:
1729 1.) the reloc is relative to a symbol in this section that
1730 is located in front of the shrinked instruction
1731 2.) symbol plus addend end up behind the shrinked instruction.
1733 The most common case where this happens are relocs relative to
1734 the section-start symbol.
1736 This step needs to be done for all of the sections of the bfd. */
1739 struct bfd_section *isec;
1741 for (isec = abfd->sections; isec; isec = isec->next)
1744 bfd_vma shrinked_insn_address;
1746 if (isec->reloc_count == 0)
1749 shrinked_insn_address = (sec->output_section->vma
1750 + sec->output_offset + addr - count);
1752 irel = elf_section_data (isec)->relocs;
1753 /* PR 12161: Read in the relocs for this section if necessary. */
1755 irel = _bfd_elf_link_read_relocs (abfd, isec, NULL, NULL, TRUE);
1757 for (irelend = irel + isec->reloc_count;
1761 /* Read this BFD's local symbols if we haven't done
1763 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
1765 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1766 if (isymbuf == NULL)
1767 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
1768 symtab_hdr->sh_info, 0,
1770 if (isymbuf == NULL)
1774 /* Get the value of the symbol referred to by the reloc. */
1775 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1777 /* A local symbol. */
1780 isym = isymbuf + ELF32_R_SYM (irel->r_info);
1781 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
1782 symval = isym->st_value;
1783 /* If the reloc is absolute, it will not have
1784 a symbol or section associated with it. */
1787 symval += sym_sec->output_section->vma
1788 + sym_sec->output_offset;
1791 printf ("Checking if the relocation's "
1792 "addend needs corrections.\n"
1793 "Address of anchor symbol: 0x%x \n"
1794 "Address of relocation target: 0x%x \n"
1795 "Address of relaxed insn: 0x%x \n",
1796 (unsigned int) symval,
1797 (unsigned int) (symval + irel->r_addend),
1798 (unsigned int) shrinked_insn_address);
1800 if (symval <= shrinked_insn_address
1801 && (symval + irel->r_addend) > shrinked_insn_address)
1803 if (elf32_avr_is_diff_reloc (irel))
1805 elf32_avr_adjust_diff_reloc_value (abfd, isec, irel,
1807 shrinked_insn_address,
1811 irel->r_addend -= count;
1814 printf ("Relocation's addend needed to be fixed \n");
1817 /* else...Reference symbol is absolute. No adjustment needed. */
1819 /* else...Reference symbol is extern. No need for adjusting
1825 /* Adjust the local symbols defined in this section. */
1826 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1827 /* Fix PR 9841, there may be no local symbols. */
1830 Elf_Internal_Sym *isymend;
1832 isymend = isym + symtab_hdr->sh_info;
1833 for (; isym < isymend; isym++)
1835 if (isym->st_shndx == sec_shndx
1836 && isym->st_value > addr
1837 && isym->st_value < toaddr)
1838 isym->st_value -= count;
1842 /* Now adjust the global symbols defined in this section. */
1843 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1844 - symtab_hdr->sh_info);
1845 sym_hashes = elf_sym_hashes (abfd);
1846 end_hashes = sym_hashes + symcount;
1847 for (; sym_hashes < end_hashes; sym_hashes++)
1849 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1850 if ((sym_hash->root.type == bfd_link_hash_defined
1851 || sym_hash->root.type == bfd_link_hash_defweak)
1852 && sym_hash->root.u.def.section == sec
1853 && sym_hash->root.u.def.value > addr
1854 && sym_hash->root.u.def.value < toaddr)
1856 sym_hash->root.u.def.value -= count;
1863 /* This function handles relaxing for the avr.
1864 Many important relaxing opportunities within functions are already
1865 realized by the compiler itself.
1866 Here we try to replace call (4 bytes) -> rcall (2 bytes)
1867 and jump -> rjmp (safes also 2 bytes).
1868 As well we now optimize seqences of
1869 - call/rcall function
1874 . In case that within a sequence
1877 the ret could no longer be reached it is optimized away. In order
1878 to check if the ret is no longer needed, it is checked that the ret's address
1879 is not the target of a branch or jump within the same section, it is checked
1880 that there is no skip instruction before the jmp/rjmp and that there
1881 is no local or global label place at the address of the ret.
1883 We refrain from relaxing within sections ".vectors" and
1884 ".jumptables" in order to maintain the position of the instructions.
1885 There, however, we substitute jmp/call by a sequence rjmp,nop/rcall,nop
1886 if possible. (In future one could possibly use the space of the nop
1887 for the first instruction of the irq service function.
1889 The .jumptables sections is meant to be used for a future tablejump variant
1890 for the devices with 3-byte program counter where the table itself
1891 contains 4-byte jump instructions whose relative offset must not
1895 elf32_avr_relax_section (bfd *abfd,
1897 struct bfd_link_info *link_info,
1900 Elf_Internal_Shdr *symtab_hdr;
1901 Elf_Internal_Rela *internal_relocs;
1902 Elf_Internal_Rela *irel, *irelend;
1903 bfd_byte *contents = NULL;
1904 Elf_Internal_Sym *isymbuf = NULL;
1905 struct elf32_avr_link_hash_table *htab;
1907 /* If 'shrinkable' is FALSE, do not shrink by deleting bytes while
1908 relaxing. Such shrinking can cause issues for the sections such
1909 as .vectors and .jumptables. Instead the unused bytes should be
1910 filled with nop instructions. */
1911 bfd_boolean shrinkable = TRUE;
1913 if (!strcmp (sec->name,".vectors")
1914 || !strcmp (sec->name,".jumptables"))
1917 if (link_info->relocatable)
1918 (*link_info->callbacks->einfo)
1919 (_("%P%F: --relax and -r may not be used together\n"));
1921 htab = avr_link_hash_table (link_info);
1925 /* Assume nothing changes. */
1928 if ((!htab->no_stubs) && (sec == htab->stub_sec))
1930 /* We are just relaxing the stub section.
1931 Let's calculate the size needed again. */
1932 bfd_size_type last_estimated_stub_section_size = htab->stub_sec->size;
1935 printf ("Relaxing the stub section. Size prior to this pass: %i\n",
1936 (int) last_estimated_stub_section_size);
1938 elf32_avr_size_stubs (htab->stub_sec->output_section->owner,
1941 /* Check if the number of trampolines changed. */
1942 if (last_estimated_stub_section_size != htab->stub_sec->size)
1946 printf ("Size of stub section after this pass: %i\n",
1947 (int) htab->stub_sec->size);
1952 /* We don't have to do anything for a relocatable link, if
1953 this section does not have relocs, or if this is not a
1955 if (link_info->relocatable
1956 || (sec->flags & SEC_RELOC) == 0
1957 || sec->reloc_count == 0
1958 || (sec->flags & SEC_CODE) == 0)
1961 /* Check if the object file to relax uses internal symbols so that we
1962 could fix up the relocations. */
1963 if (!(elf_elfheader (abfd)->e_flags & EF_AVR_LINKRELAX_PREPARED))
1966 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1968 /* Get a copy of the native relocations. */
1969 internal_relocs = (_bfd_elf_link_read_relocs
1970 (abfd, sec, NULL, NULL, link_info->keep_memory));
1971 if (internal_relocs == NULL)
1974 /* Walk through the relocs looking for relaxing opportunities. */
1975 irelend = internal_relocs + sec->reloc_count;
1976 for (irel = internal_relocs; irel < irelend; irel++)
1980 if ( ELF32_R_TYPE (irel->r_info) != R_AVR_13_PCREL
1981 && ELF32_R_TYPE (irel->r_info) != R_AVR_7_PCREL
1982 && ELF32_R_TYPE (irel->r_info) != R_AVR_CALL)
1985 /* Get the section contents if we haven't done so already. */
1986 if (contents == NULL)
1988 /* Get cached copy if it exists. */
1989 if (elf_section_data (sec)->this_hdr.contents != NULL)
1990 contents = elf_section_data (sec)->this_hdr.contents;
1993 /* Go get them off disk. */
1994 if (! bfd_malloc_and_get_section (abfd, sec, &contents))
1999 /* Read this BFD's local symbols if we haven't done so already. */
2000 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
2002 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2003 if (isymbuf == NULL)
2004 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
2005 symtab_hdr->sh_info, 0,
2007 if (isymbuf == NULL)
2012 /* Get the value of the symbol referred to by the reloc. */
2013 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
2015 /* A local symbol. */
2016 Elf_Internal_Sym *isym;
2019 isym = isymbuf + ELF32_R_SYM (irel->r_info);
2020 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
2021 symval = isym->st_value;
2022 /* If the reloc is absolute, it will not have
2023 a symbol or section associated with it. */
2025 symval += sym_sec->output_section->vma
2026 + sym_sec->output_offset;
2031 struct elf_link_hash_entry *h;
2033 /* An external symbol. */
2034 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
2035 h = elf_sym_hashes (abfd)[indx];
2036 BFD_ASSERT (h != NULL);
2037 if (h->root.type != bfd_link_hash_defined
2038 && h->root.type != bfd_link_hash_defweak)
2039 /* This appears to be a reference to an undefined
2040 symbol. Just ignore it--it will be caught by the
2041 regular reloc processing. */
2044 symval = (h->root.u.def.value
2045 + h->root.u.def.section->output_section->vma
2046 + h->root.u.def.section->output_offset);
2049 /* For simplicity of coding, we are going to modify the section
2050 contents, the section relocs, and the BFD symbol table. We
2051 must tell the rest of the code not to free up this
2052 information. It would be possible to instead create a table
2053 of changes which have to be made, as is done in coff-mips.c;
2054 that would be more work, but would require less memory when
2055 the linker is run. */
2056 switch (ELF32_R_TYPE (irel->r_info))
2058 /* Try to turn a 22-bit absolute call/jump into an 13-bit
2059 pc-relative rcall/rjmp. */
2062 bfd_vma value = symval + irel->r_addend;
2064 int distance_short_enough = 0;
2066 /* Get the address of this instruction. */
2067 dot = (sec->output_section->vma
2068 + sec->output_offset + irel->r_offset);
2070 /* Compute the distance from this insn to the branch target. */
2073 /* Check if the gap falls in the range that can be accommodated
2074 in 13bits signed (It is 12bits when encoded, as we deal with
2075 word addressing). */
2076 if (!shrinkable && ((int) gap >= -4096 && (int) gap <= 4095))
2077 distance_short_enough = 1;
2078 /* If shrinkable, then we can check for a range of distance which
2079 is two bytes farther on both the directions because the call
2080 or jump target will be closer by two bytes after the
2082 else if (shrinkable && ((int) gap >= -4094 && (int) gap <= 4097))
2083 distance_short_enough = 1;
2085 /* Here we handle the wrap-around case. E.g. for a 16k device
2086 we could use a rjmp to jump from address 0x100 to 0x3d00!
2087 In order to make this work properly, we need to fill the
2088 vaiable avr_pc_wrap_around with the appropriate value.
2089 I.e. 0x4000 for a 16k device. */
2091 /* Shrinking the code size makes the gaps larger in the
2092 case of wrap-arounds. So we use a heuristical safety
2093 margin to avoid that during relax the distance gets
2094 again too large for the short jumps. Let's assume
2095 a typical code-size reduction due to relax for a
2096 16k device of 600 bytes. So let's use twice the
2097 typical value as safety margin. */
2101 int assumed_shrink = 600;
2102 if (avr_pc_wrap_around > 0x4000)
2103 assumed_shrink = 900;
2105 safety_margin = 2 * assumed_shrink;
2107 rgap = avr_relative_distance_considering_wrap_around (gap);
2109 if (rgap >= (-4092 + safety_margin)
2110 && rgap <= (4094 - safety_margin))
2111 distance_short_enough = 1;
2114 if (distance_short_enough)
2116 unsigned char code_msb;
2117 unsigned char code_lsb;
2120 printf ("shrinking jump/call instruction at address 0x%x"
2121 " in section %s\n\n",
2122 (int) dot, sec->name);
2124 /* Note that we've changed the relocs, section contents,
2126 elf_section_data (sec)->relocs = internal_relocs;
2127 elf_section_data (sec)->this_hdr.contents = contents;
2128 symtab_hdr->contents = (unsigned char *) isymbuf;
2130 /* Get the instruction code for relaxing. */
2131 code_lsb = bfd_get_8 (abfd, contents + irel->r_offset);
2132 code_msb = bfd_get_8 (abfd, contents + irel->r_offset + 1);
2134 /* Mask out the relocation bits. */
2137 if (code_msb == 0x94 && code_lsb == 0x0E)
2139 /* we are changing call -> rcall . */
2140 bfd_put_8 (abfd, 0x00, contents + irel->r_offset);
2141 bfd_put_8 (abfd, 0xD0, contents + irel->r_offset + 1);
2143 else if (code_msb == 0x94 && code_lsb == 0x0C)
2145 /* we are changeing jump -> rjmp. */
2146 bfd_put_8 (abfd, 0x00, contents + irel->r_offset);
2147 bfd_put_8 (abfd, 0xC0, contents + irel->r_offset + 1);
2152 /* Fix the relocation's type. */
2153 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2156 /* We should not modify the ordering if 'shrinkable' is
2160 /* Let's insert a nop. */
2161 bfd_put_8 (abfd, 0x00, contents + irel->r_offset + 2);
2162 bfd_put_8 (abfd, 0x00, contents + irel->r_offset + 3);
2166 /* Delete two bytes of data. */
2167 if (!elf32_avr_relax_delete_bytes (abfd, sec,
2168 irel->r_offset + 2, 2))
2171 /* That will change things, so, we should relax again.
2172 Note that this is not required, and it may be slow. */
2180 unsigned char code_msb;
2181 unsigned char code_lsb;
2184 code_msb = bfd_get_8 (abfd, contents + irel->r_offset + 1);
2185 code_lsb = bfd_get_8 (abfd, contents + irel->r_offset + 0);
2187 /* Get the address of this instruction. */
2188 dot = (sec->output_section->vma
2189 + sec->output_offset + irel->r_offset);
2191 /* Here we look for rcall/ret or call/ret sequences that could be
2192 safely replaced by rjmp/ret or jmp/ret. */
2193 if (((code_msb & 0xf0) == 0xd0)
2194 && avr_replace_call_ret_sequences)
2196 /* This insn is a rcall. */
2197 unsigned char next_insn_msb = 0;
2198 unsigned char next_insn_lsb = 0;
2200 if (irel->r_offset + 3 < sec->size)
2203 bfd_get_8 (abfd, contents + irel->r_offset + 3);
2205 bfd_get_8 (abfd, contents + irel->r_offset + 2);
2208 if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb))
2210 /* The next insn is a ret. We now convert the rcall insn
2211 into a rjmp instruction. */
2213 bfd_put_8 (abfd, code_msb, contents + irel->r_offset + 1);
2215 printf ("converted rcall/ret sequence at address 0x%x"
2216 " into rjmp/ret sequence. Section is %s\n\n",
2217 (int) dot, sec->name);
2222 else if ((0x94 == (code_msb & 0xfe))
2223 && (0x0e == (code_lsb & 0x0e))
2224 && avr_replace_call_ret_sequences)
2226 /* This insn is a call. */
2227 unsigned char next_insn_msb = 0;
2228 unsigned char next_insn_lsb = 0;
2230 if (irel->r_offset + 5 < sec->size)
2233 bfd_get_8 (abfd, contents + irel->r_offset + 5);
2235 bfd_get_8 (abfd, contents + irel->r_offset + 4);
2238 if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb))
2240 /* The next insn is a ret. We now convert the call insn
2241 into a jmp instruction. */
2244 bfd_put_8 (abfd, code_lsb, contents + irel->r_offset);
2246 printf ("converted call/ret sequence at address 0x%x"
2247 " into jmp/ret sequence. Section is %s\n\n",
2248 (int) dot, sec->name);
2253 else if ((0xc0 == (code_msb & 0xf0))
2254 || ((0x94 == (code_msb & 0xfe))
2255 && (0x0c == (code_lsb & 0x0e))))
2257 /* This insn is a rjmp or a jmp. */
2258 unsigned char next_insn_msb = 0;
2259 unsigned char next_insn_lsb = 0;
2262 if (0xc0 == (code_msb & 0xf0))
2263 insn_size = 2; /* rjmp insn */
2265 insn_size = 4; /* jmp insn */
2267 if (irel->r_offset + insn_size + 1 < sec->size)
2270 bfd_get_8 (abfd, contents + irel->r_offset
2273 bfd_get_8 (abfd, contents + irel->r_offset
2277 if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb))
2279 /* The next insn is a ret. We possibly could delete
2280 this ret. First we need to check for preceding
2281 sbis/sbic/sbrs or cpse "skip" instructions. */
2283 int there_is_preceding_non_skip_insn = 1;
2284 bfd_vma address_of_ret;
2286 address_of_ret = dot + insn_size;
2288 if (debug_relax && (insn_size == 2))
2289 printf ("found rjmp / ret sequence at address 0x%x\n",
2291 if (debug_relax && (insn_size == 4))
2292 printf ("found jmp / ret sequence at address 0x%x\n",
2295 /* We have to make sure that there is a preceding insn. */
2296 if (irel->r_offset >= 2)
2298 unsigned char preceding_msb;
2299 unsigned char preceding_lsb;
2302 bfd_get_8 (abfd, contents + irel->r_offset - 1);
2304 bfd_get_8 (abfd, contents + irel->r_offset - 2);
2307 if (0x99 == preceding_msb)
2308 there_is_preceding_non_skip_insn = 0;
2311 if (0x9b == preceding_msb)
2312 there_is_preceding_non_skip_insn = 0;
2315 if ((0xfc == (preceding_msb & 0xfe)
2316 && (0x00 == (preceding_lsb & 0x08))))
2317 there_is_preceding_non_skip_insn = 0;
2320 if ((0xfe == (preceding_msb & 0xfe)
2321 && (0x00 == (preceding_lsb & 0x08))))
2322 there_is_preceding_non_skip_insn = 0;
2325 if (0x10 == (preceding_msb & 0xfc))
2326 there_is_preceding_non_skip_insn = 0;
2328 if (there_is_preceding_non_skip_insn == 0)
2330 printf ("preceding skip insn prevents deletion of"
2331 " ret insn at Addy 0x%x in section %s\n",
2332 (int) dot + 2, sec->name);
2336 /* There is no previous instruction. */
2337 there_is_preceding_non_skip_insn = 0;
2340 if (there_is_preceding_non_skip_insn)
2342 /* We now only have to make sure that there is no
2343 local label defined at the address of the ret
2344 instruction and that there is no local relocation
2345 in this section pointing to the ret. */
2347 int deleting_ret_is_safe = 1;
2348 unsigned int section_offset_of_ret_insn =
2349 irel->r_offset + insn_size;
2350 Elf_Internal_Sym *isym, *isymend;
2351 unsigned int sec_shndx;
2352 struct bfd_section *isec;
2355 _bfd_elf_section_from_bfd_section (abfd, sec);
2357 /* Check for local symbols. */
2358 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
2359 isymend = isym + symtab_hdr->sh_info;
2360 /* PR 6019: There may not be any local symbols. */
2361 for (; isym != NULL && isym < isymend; isym++)
2363 if (isym->st_value == section_offset_of_ret_insn
2364 && isym->st_shndx == sec_shndx)
2366 deleting_ret_is_safe = 0;
2368 printf ("local label prevents deletion of ret "
2369 "insn at address 0x%x\n",
2370 (int) dot + insn_size);
2374 /* Now check for global symbols. */
2377 struct elf_link_hash_entry **sym_hashes;
2378 struct elf_link_hash_entry **end_hashes;
2380 symcount = (symtab_hdr->sh_size
2381 / sizeof (Elf32_External_Sym)
2382 - symtab_hdr->sh_info);
2383 sym_hashes = elf_sym_hashes (abfd);
2384 end_hashes = sym_hashes + symcount;
2385 for (; sym_hashes < end_hashes; sym_hashes++)
2387 struct elf_link_hash_entry *sym_hash =
2389 if ((sym_hash->root.type == bfd_link_hash_defined
2390 || sym_hash->root.type ==
2391 bfd_link_hash_defweak)
2392 && sym_hash->root.u.def.section == sec
2393 && sym_hash->root.u.def.value == section_offset_of_ret_insn)
2395 deleting_ret_is_safe = 0;
2397 printf ("global label prevents deletion of "
2398 "ret insn at address 0x%x\n",
2399 (int) dot + insn_size);
2404 /* Now we check for relocations pointing to ret. */
2405 for (isec = abfd->sections; isec && deleting_ret_is_safe; isec = isec->next)
2407 Elf_Internal_Rela *rel;
2408 Elf_Internal_Rela *relend;
2410 rel = elf_section_data (isec)->relocs;
2412 rel = _bfd_elf_link_read_relocs (abfd, isec, NULL, NULL, TRUE);
2414 relend = rel + isec->reloc_count;
2416 for (; rel && rel < relend; rel++)
2418 bfd_vma reloc_target = 0;
2420 /* Read this BFD's local symbols if we haven't
2422 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
2424 isymbuf = (Elf_Internal_Sym *)
2425 symtab_hdr->contents;
2426 if (isymbuf == NULL)
2427 isymbuf = bfd_elf_get_elf_syms
2430 symtab_hdr->sh_info, 0,
2432 if (isymbuf == NULL)
2436 /* Get the value of the symbol referred to
2438 if (ELF32_R_SYM (rel->r_info)
2439 < symtab_hdr->sh_info)
2441 /* A local symbol. */
2445 + ELF32_R_SYM (rel->r_info);
2446 sym_sec = bfd_section_from_elf_index
2447 (abfd, isym->st_shndx);
2448 symval = isym->st_value;
2450 /* If the reloc is absolute, it will not
2451 have a symbol or section associated
2457 sym_sec->output_section->vma
2458 + sym_sec->output_offset;
2459 reloc_target = symval + rel->r_addend;
2463 reloc_target = symval + rel->r_addend;
2464 /* Reference symbol is absolute. */
2467 /* else ... reference symbol is extern. */
2469 if (address_of_ret == reloc_target)
2471 deleting_ret_is_safe = 0;
2474 "rjmp/jmp ret sequence at address"
2475 " 0x%x could not be deleted. ret"
2476 " is target of a relocation.\n",
2477 (int) address_of_ret);
2483 if (deleting_ret_is_safe)
2486 printf ("unreachable ret instruction "
2487 "at address 0x%x deleted.\n",
2488 (int) dot + insn_size);
2490 /* Delete two bytes of data. */
2491 if (!elf32_avr_relax_delete_bytes (abfd, sec,
2492 irel->r_offset + insn_size, 2))
2495 /* That will change things, so, we should relax
2496 again. Note that this is not required, and it
2509 if (contents != NULL
2510 && elf_section_data (sec)->this_hdr.contents != contents)
2512 if (! link_info->keep_memory)
2516 /* Cache the section contents for elf_link_input_bfd. */
2517 elf_section_data (sec)->this_hdr.contents = contents;
2521 if (internal_relocs != NULL
2522 && elf_section_data (sec)->relocs != internal_relocs)
2523 free (internal_relocs);
2529 && symtab_hdr->contents != (unsigned char *) isymbuf)
2531 if (contents != NULL
2532 && elf_section_data (sec)->this_hdr.contents != contents)
2534 if (internal_relocs != NULL
2535 && elf_section_data (sec)->relocs != internal_relocs)
2536 free (internal_relocs);
2541 /* This is a version of bfd_generic_get_relocated_section_contents
2542 which uses elf32_avr_relocate_section.
2544 For avr it's essentially a cut and paste taken from the H8300 port.
2545 The author of the relaxation support patch for avr had absolutely no
2546 clue what is happening here but found out that this part of the code
2547 seems to be important. */
2550 elf32_avr_get_relocated_section_contents (bfd *output_bfd,
2551 struct bfd_link_info *link_info,
2552 struct bfd_link_order *link_order,
2554 bfd_boolean relocatable,
2557 Elf_Internal_Shdr *symtab_hdr;
2558 asection *input_section = link_order->u.indirect.section;
2559 bfd *input_bfd = input_section->owner;
2560 asection **sections = NULL;
2561 Elf_Internal_Rela *internal_relocs = NULL;
2562 Elf_Internal_Sym *isymbuf = NULL;
2564 /* We only need to handle the case of relaxing, or of having a
2565 particular set of section contents, specially. */
2567 || elf_section_data (input_section)->this_hdr.contents == NULL)
2568 return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
2572 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2574 memcpy (data, elf_section_data (input_section)->this_hdr.contents,
2575 (size_t) input_section->size);
2577 if ((input_section->flags & SEC_RELOC) != 0
2578 && input_section->reloc_count > 0)
2581 Elf_Internal_Sym *isym, *isymend;
2584 internal_relocs = (_bfd_elf_link_read_relocs
2585 (input_bfd, input_section, NULL, NULL, FALSE));
2586 if (internal_relocs == NULL)
2589 if (symtab_hdr->sh_info != 0)
2591 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2592 if (isymbuf == NULL)
2593 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
2594 symtab_hdr->sh_info, 0,
2596 if (isymbuf == NULL)
2600 amt = symtab_hdr->sh_info;
2601 amt *= sizeof (asection *);
2602 sections = bfd_malloc (amt);
2603 if (sections == NULL && amt != 0)
2606 isymend = isymbuf + symtab_hdr->sh_info;
2607 for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
2611 if (isym->st_shndx == SHN_UNDEF)
2612 isec = bfd_und_section_ptr;
2613 else if (isym->st_shndx == SHN_ABS)
2614 isec = bfd_abs_section_ptr;
2615 else if (isym->st_shndx == SHN_COMMON)
2616 isec = bfd_com_section_ptr;
2618 isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
2623 if (! elf32_avr_relocate_section (output_bfd, link_info, input_bfd,
2624 input_section, data, internal_relocs,
2628 if (sections != NULL)
2631 && symtab_hdr->contents != (unsigned char *) isymbuf)
2633 if (elf_section_data (input_section)->relocs != internal_relocs)
2634 free (internal_relocs);
2640 if (sections != NULL)
2643 && symtab_hdr->contents != (unsigned char *) isymbuf)
2645 if (internal_relocs != NULL
2646 && elf_section_data (input_section)->relocs != internal_relocs)
2647 free (internal_relocs);
2652 /* Determines the hash entry name for a particular reloc. It consists of
2653 the identifier of the symbol section and the added reloc addend and
2654 symbol offset relative to the section the symbol is attached to. */
2657 avr_stub_name (const asection *symbol_section,
2658 const bfd_vma symbol_offset,
2659 const Elf_Internal_Rela *rela)
2664 len = 8 + 1 + 8 + 1 + 1;
2665 stub_name = bfd_malloc (len);
2667 sprintf (stub_name, "%08x+%08x",
2668 symbol_section->id & 0xffffffff,
2669 (unsigned int) ((rela->r_addend & 0xffffffff) + symbol_offset));
2675 /* Add a new stub entry to the stub hash. Not all fields of the new
2676 stub entry are initialised. */
2678 static struct elf32_avr_stub_hash_entry *
2679 avr_add_stub (const char *stub_name,
2680 struct elf32_avr_link_hash_table *htab)
2682 struct elf32_avr_stub_hash_entry *hsh;
2684 /* Enter this entry into the linker stub hash table. */
2685 hsh = avr_stub_hash_lookup (&htab->bstab, stub_name, TRUE, FALSE);
2689 (*_bfd_error_handler) (_("%B: cannot create stub entry %s"),
2694 hsh->stub_offset = 0;
2698 /* We assume that there is already space allocated for the stub section
2699 contents and that before building the stubs the section size is
2700 initialized to 0. We assume that within the stub hash table entry,
2701 the absolute position of the jmp target has been written in the
2702 target_value field. We write here the offset of the generated jmp insn
2703 relative to the trampoline section start to the stub_offset entry in
2704 the stub hash table entry. */
2707 avr_build_one_stub (struct bfd_hash_entry *bh, void *in_arg)
2709 struct elf32_avr_stub_hash_entry *hsh;
2710 struct bfd_link_info *info;
2711 struct elf32_avr_link_hash_table *htab;
2718 bfd_vma jmp_insn = 0x0000940c;
2720 /* Massage our args to the form they really have. */
2721 hsh = avr_stub_hash_entry (bh);
2723 if (!hsh->is_actually_needed)
2726 info = (struct bfd_link_info *) in_arg;
2728 htab = avr_link_hash_table (info);
2732 target = hsh->target_value;
2734 /* Make a note of the offset within the stubs for this entry. */
2735 hsh->stub_offset = htab->stub_sec->size;
2736 loc = htab->stub_sec->contents + hsh->stub_offset;
2738 stub_bfd = htab->stub_sec->owner;
2741 printf ("Building one Stub. Address: 0x%x, Offset: 0x%x\n",
2742 (unsigned int) target,
2743 (unsigned int) hsh->stub_offset);
2745 /* We now have to add the information on the jump target to the bare
2746 opcode bits already set in jmp_insn. */
2748 /* Check for the alignment of the address. */
2752 starget = target >> 1;
2753 jmp_insn |= ((starget & 0x10000) | ((starget << 3) & 0x1f00000)) >> 16;
2754 bfd_put_16 (stub_bfd, jmp_insn, loc);
2755 bfd_put_16 (stub_bfd, (bfd_vma) starget & 0xffff, loc + 2);
2757 htab->stub_sec->size += 4;
2759 /* Now add the entries in the address mapping table if there is still
2764 nr = htab->amt_entry_cnt + 1;
2765 if (nr <= htab->amt_max_entry_cnt)
2767 htab->amt_entry_cnt = nr;
2769 htab->amt_stub_offsets[nr - 1] = hsh->stub_offset;
2770 htab->amt_destination_addr[nr - 1] = target;
2778 avr_mark_stub_not_to_be_necessary (struct bfd_hash_entry *bh,
2779 void *in_arg ATTRIBUTE_UNUSED)
2781 struct elf32_avr_stub_hash_entry *hsh;
2783 hsh = avr_stub_hash_entry (bh);
2784 hsh->is_actually_needed = FALSE;
2790 avr_size_one_stub (struct bfd_hash_entry *bh, void *in_arg)
2792 struct elf32_avr_stub_hash_entry *hsh;
2793 struct elf32_avr_link_hash_table *htab;
2796 /* Massage our args to the form they really have. */
2797 hsh = avr_stub_hash_entry (bh);
2800 if (hsh->is_actually_needed)
2805 htab->stub_sec->size += size;
2810 elf32_avr_setup_params (struct bfd_link_info *info,
2812 asection *avr_stub_section,
2813 bfd_boolean no_stubs,
2814 bfd_boolean deb_stubs,
2815 bfd_boolean deb_relax,
2816 bfd_vma pc_wrap_around,
2817 bfd_boolean call_ret_replacement)
2819 struct elf32_avr_link_hash_table *htab = avr_link_hash_table (info);
2823 htab->stub_sec = avr_stub_section;
2824 htab->stub_bfd = avr_stub_bfd;
2825 htab->no_stubs = no_stubs;
2827 debug_relax = deb_relax;
2828 debug_stubs = deb_stubs;
2829 avr_pc_wrap_around = pc_wrap_around;
2830 avr_replace_call_ret_sequences = call_ret_replacement;
2834 /* Set up various things so that we can make a list of input sections
2835 for each output section included in the link. Returns -1 on error,
2836 0 when no stubs will be needed, and 1 on success. It also sets
2837 information on the stubs bfd and the stub section in the info
2841 elf32_avr_setup_section_lists (bfd *output_bfd,
2842 struct bfd_link_info *info)
2845 unsigned int bfd_count;
2846 int top_id, top_index;
2848 asection **input_list, **list;
2850 struct elf32_avr_link_hash_table *htab = avr_link_hash_table (info);
2852 if (htab == NULL || htab->no_stubs)
2855 /* Count the number of input BFDs and find the top input section id. */
2856 for (input_bfd = info->input_bfds, bfd_count = 0, top_id = 0;
2858 input_bfd = input_bfd->link.next)
2861 for (section = input_bfd->sections;
2863 section = section->next)
2864 if (top_id < section->id)
2865 top_id = section->id;
2868 htab->bfd_count = bfd_count;
2870 /* We can't use output_bfd->section_count here to find the top output
2871 section index as some sections may have been removed, and
2872 strip_excluded_output_sections doesn't renumber the indices. */
2873 for (section = output_bfd->sections, top_index = 0;
2875 section = section->next)
2876 if (top_index < section->index)
2877 top_index = section->index;
2879 htab->top_index = top_index;
2880 amt = sizeof (asection *) * (top_index + 1);
2881 input_list = bfd_malloc (amt);
2882 htab->input_list = input_list;
2883 if (input_list == NULL)
2886 /* For sections we aren't interested in, mark their entries with a
2887 value we can check later. */
2888 list = input_list + top_index;
2890 *list = bfd_abs_section_ptr;
2891 while (list-- != input_list);
2893 for (section = output_bfd->sections;
2895 section = section->next)
2896 if ((section->flags & SEC_CODE) != 0)
2897 input_list[section->index] = NULL;
2903 /* Read in all local syms for all input bfds, and create hash entries
2904 for export stubs if we are building a multi-subspace shared lib.
2905 Returns -1 on error, 0 otherwise. */
2908 get_local_syms (bfd *input_bfd, struct bfd_link_info *info)
2910 unsigned int bfd_indx;
2911 Elf_Internal_Sym *local_syms, **all_local_syms;
2912 struct elf32_avr_link_hash_table *htab = avr_link_hash_table (info);
2918 /* We want to read in symbol extension records only once. To do this
2919 we need to read in the local symbols in parallel and save them for
2920 later use; so hold pointers to the local symbols in an array. */
2921 amt = sizeof (Elf_Internal_Sym *) * htab->bfd_count;
2922 all_local_syms = bfd_zmalloc (amt);
2923 htab->all_local_syms = all_local_syms;
2924 if (all_local_syms == NULL)
2927 /* Walk over all the input BFDs, swapping in local symbols.
2928 If we are creating a shared library, create hash entries for the
2932 input_bfd = input_bfd->link.next, bfd_indx++)
2934 Elf_Internal_Shdr *symtab_hdr;
2936 /* We'll need the symbol table in a second. */
2937 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2938 if (symtab_hdr->sh_info == 0)
2941 /* We need an array of the local symbols attached to the input bfd. */
2942 local_syms = (Elf_Internal_Sym *) symtab_hdr->contents;
2943 if (local_syms == NULL)
2945 local_syms = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
2946 symtab_hdr->sh_info, 0,
2948 /* Cache them for elf_link_input_bfd. */
2949 symtab_hdr->contents = (unsigned char *) local_syms;
2951 if (local_syms == NULL)
2954 all_local_syms[bfd_indx] = local_syms;
2960 #define ADD_DUMMY_STUBS_FOR_DEBUGGING 0
2963 elf32_avr_size_stubs (bfd *output_bfd,
2964 struct bfd_link_info *info,
2965 bfd_boolean is_prealloc_run)
2967 struct elf32_avr_link_hash_table *htab;
2968 int stub_changed = 0;
2970 htab = avr_link_hash_table (info);
2974 /* At this point we initialize htab->vector_base
2975 To the start of the text output section. */
2976 htab->vector_base = htab->stub_sec->output_section->vma;
2978 if (get_local_syms (info->input_bfds, info))
2980 if (htab->all_local_syms)
2981 goto error_ret_free_local;
2985 if (ADD_DUMMY_STUBS_FOR_DEBUGGING)
2987 struct elf32_avr_stub_hash_entry *test;
2989 test = avr_add_stub ("Hugo",htab);
2990 test->target_value = 0x123456;
2991 test->stub_offset = 13;
2993 test = avr_add_stub ("Hugo2",htab);
2994 test->target_value = 0x84210;
2995 test->stub_offset = 14;
3001 unsigned int bfd_indx;
3003 /* We will have to re-generate the stub hash table each time anything
3004 in memory has changed. */
3006 bfd_hash_traverse (&htab->bstab, avr_mark_stub_not_to_be_necessary, htab);
3007 for (input_bfd = info->input_bfds, bfd_indx = 0;
3009 input_bfd = input_bfd->link.next, bfd_indx++)
3011 Elf_Internal_Shdr *symtab_hdr;
3013 Elf_Internal_Sym *local_syms;
3015 /* We'll need the symbol table in a second. */
3016 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3017 if (symtab_hdr->sh_info == 0)
3020 local_syms = htab->all_local_syms[bfd_indx];
3022 /* Walk over each section attached to the input bfd. */
3023 for (section = input_bfd->sections;
3025 section = section->next)
3027 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
3029 /* If there aren't any relocs, then there's nothing more
3031 if ((section->flags & SEC_RELOC) == 0
3032 || section->reloc_count == 0)
3035 /* If this section is a link-once section that will be
3036 discarded, then don't create any stubs. */
3037 if (section->output_section == NULL
3038 || section->output_section->owner != output_bfd)
3041 /* Get the relocs. */
3043 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
3045 if (internal_relocs == NULL)
3046 goto error_ret_free_local;
3048 /* Now examine each relocation. */
3049 irela = internal_relocs;
3050 irelaend = irela + section->reloc_count;
3051 for (; irela < irelaend; irela++)
3053 unsigned int r_type, r_indx;
3054 struct elf32_avr_stub_hash_entry *hsh;
3057 bfd_vma destination;
3058 struct elf_link_hash_entry *hh;
3061 r_type = ELF32_R_TYPE (irela->r_info);
3062 r_indx = ELF32_R_SYM (irela->r_info);
3064 /* Only look for 16 bit GS relocs. No other reloc will need a
3066 if (!((r_type == R_AVR_16_PM)
3067 || (r_type == R_AVR_LO8_LDI_GS)
3068 || (r_type == R_AVR_HI8_LDI_GS)))
3071 /* Now determine the call target, its name, value,
3077 if (r_indx < symtab_hdr->sh_info)
3079 /* It's a local symbol. */
3080 Elf_Internal_Sym *sym;
3081 Elf_Internal_Shdr *hdr;
3084 sym = local_syms + r_indx;
3085 if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
3086 sym_value = sym->st_value;
3087 shndx = sym->st_shndx;
3088 if (shndx < elf_numsections (input_bfd))
3090 hdr = elf_elfsections (input_bfd)[shndx];
3091 sym_sec = hdr->bfd_section;
3092 destination = (sym_value + irela->r_addend
3093 + sym_sec->output_offset
3094 + sym_sec->output_section->vma);
3099 /* It's an external symbol. */
3102 e_indx = r_indx - symtab_hdr->sh_info;
3103 hh = elf_sym_hashes (input_bfd)[e_indx];
3105 while (hh->root.type == bfd_link_hash_indirect
3106 || hh->root.type == bfd_link_hash_warning)
3107 hh = (struct elf_link_hash_entry *)
3108 (hh->root.u.i.link);
3110 if (hh->root.type == bfd_link_hash_defined
3111 || hh->root.type == bfd_link_hash_defweak)
3113 sym_sec = hh->root.u.def.section;
3114 sym_value = hh->root.u.def.value;
3115 if (sym_sec->output_section != NULL)
3116 destination = (sym_value + irela->r_addend
3117 + sym_sec->output_offset
3118 + sym_sec->output_section->vma);
3120 else if (hh->root.type == bfd_link_hash_undefweak)
3125 else if (hh->root.type == bfd_link_hash_undefined)
3127 if (! (info->unresolved_syms_in_objects == RM_IGNORE
3128 && (ELF_ST_VISIBILITY (hh->other)
3134 bfd_set_error (bfd_error_bad_value);
3136 error_ret_free_internal:
3137 if (elf_section_data (section)->relocs == NULL)
3138 free (internal_relocs);
3139 goto error_ret_free_local;
3143 if (! avr_stub_is_required_for_16_bit_reloc
3144 (destination - htab->vector_base))
3146 if (!is_prealloc_run)
3147 /* We are having a reloc that does't need a stub. */
3150 /* We don't right now know if a stub will be needed.
3151 Let's rather be on the safe side. */
3154 /* Get the name of this stub. */
3155 stub_name = avr_stub_name (sym_sec, sym_value, irela);
3158 goto error_ret_free_internal;
3161 hsh = avr_stub_hash_lookup (&htab->bstab,
3166 /* The proper stub has already been created. Mark it
3167 to be used and write the possibly changed destination
3169 hsh->is_actually_needed = TRUE;
3170 hsh->target_value = destination;
3175 hsh = avr_add_stub (stub_name, htab);
3179 goto error_ret_free_internal;
3182 hsh->is_actually_needed = TRUE;
3183 hsh->target_value = destination;
3186 printf ("Adding stub with destination 0x%x to the"
3187 " hash table.\n", (unsigned int) destination);
3189 printf ("(Pre-Alloc run: %i)\n", is_prealloc_run);
3191 stub_changed = TRUE;
3194 /* We're done with the internal relocs, free them. */
3195 if (elf_section_data (section)->relocs == NULL)
3196 free (internal_relocs);
3200 /* Re-Calculate the number of needed stubs. */
3201 htab->stub_sec->size = 0;
3202 bfd_hash_traverse (&htab->bstab, avr_size_one_stub, htab);
3207 stub_changed = FALSE;
3210 free (htab->all_local_syms);
3213 error_ret_free_local:
3214 free (htab->all_local_syms);
3219 /* Build all the stubs associated with the current output file. The
3220 stubs are kept in a hash table attached to the main linker hash
3221 table. We also set up the .plt entries for statically linked PIC
3222 functions here. This function is called via hppaelf_finish in the
3226 elf32_avr_build_stubs (struct bfd_link_info *info)
3229 struct bfd_hash_table *table;
3230 struct elf32_avr_link_hash_table *htab;
3231 bfd_size_type total_size = 0;
3233 htab = avr_link_hash_table (info);
3237 /* In case that there were several stub sections: */
3238 for (stub_sec = htab->stub_bfd->sections;
3240 stub_sec = stub_sec->next)
3244 /* Allocate memory to hold the linker stubs. */
3245 size = stub_sec->size;
3248 stub_sec->contents = bfd_zalloc (htab->stub_bfd, size);
3249 if (stub_sec->contents == NULL && size != 0)
3254 /* Allocate memory for the adress mapping table. */
3255 htab->amt_entry_cnt = 0;
3256 htab->amt_max_entry_cnt = total_size / 4;
3257 htab->amt_stub_offsets = bfd_malloc (sizeof (bfd_vma)
3258 * htab->amt_max_entry_cnt);
3259 htab->amt_destination_addr = bfd_malloc (sizeof (bfd_vma)
3260 * htab->amt_max_entry_cnt );
3263 printf ("Allocating %i entries in the AMT\n", htab->amt_max_entry_cnt);
3265 /* Build the stubs as directed by the stub hash table. */
3266 table = &htab->bstab;
3267 bfd_hash_traverse (table, avr_build_one_stub, info);
3270 printf ("Final Stub section Size: %i\n", (int) htab->stub_sec->size);
3275 #define ELF_ARCH bfd_arch_avr
3276 #define ELF_TARGET_ID AVR_ELF_DATA
3277 #define ELF_MACHINE_CODE EM_AVR
3278 #define ELF_MACHINE_ALT1 EM_AVR_OLD
3279 #define ELF_MAXPAGESIZE 1
3281 #define TARGET_LITTLE_SYM avr_elf32_vec
3282 #define TARGET_LITTLE_NAME "elf32-avr"
3284 #define bfd_elf32_bfd_link_hash_table_create elf32_avr_link_hash_table_create
3286 #define elf_info_to_howto avr_info_to_howto_rela
3287 #define elf_info_to_howto_rel NULL
3288 #define elf_backend_relocate_section elf32_avr_relocate_section
3289 #define elf_backend_can_gc_sections 1
3290 #define elf_backend_rela_normal 1
3291 #define elf_backend_final_write_processing \
3292 bfd_elf_avr_final_write_processing
3293 #define elf_backend_object_p elf32_avr_object_p
3295 #define bfd_elf32_bfd_relax_section elf32_avr_relax_section
3296 #define bfd_elf32_bfd_get_relocated_section_contents \
3297 elf32_avr_get_relocated_section_contents
3299 #include "elf32-target.h"