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 BFD_ASSERT (r_type
< (unsigned int) R_AVR_max
);
863 cache_ptr
->howto
= &elf_avr_howto_table
[r_type
];
867 avr_stub_is_required_for_16_bit_reloc (bfd_vma relocation
)
869 return (relocation
>= 0x020000);
872 /* Returns the address of the corresponding stub if there is one.
873 Returns otherwise an address above 0x020000. This function
874 could also be used, if there is no knowledge on the section where
875 the destination is found. */
878 avr_get_stub_addr (bfd_vma srel
,
879 struct elf32_avr_link_hash_table
*htab
)
882 bfd_vma stub_sec_addr
=
883 (htab
->stub_sec
->output_section
->vma
+
884 htab
->stub_sec
->output_offset
);
886 for (sindex
= 0; sindex
< htab
->amt_max_entry_cnt
; sindex
++)
887 if (htab
->amt_destination_addr
[sindex
] == srel
)
888 return htab
->amt_stub_offsets
[sindex
] + stub_sec_addr
;
890 /* Return an address that could not be reached by 16 bit relocs. */
894 /* Perform a diff relocation. Nothing to do, as the difference value is already
895 written into the section's contents. */
897 static bfd_reloc_status_type
898 bfd_elf_avr_diff_reloc (bfd
*abfd ATTRIBUTE_UNUSED
,
899 arelent
*reloc_entry ATTRIBUTE_UNUSED
,
900 asymbol
*symbol ATTRIBUTE_UNUSED
,
901 void *data ATTRIBUTE_UNUSED
,
902 asection
*input_section ATTRIBUTE_UNUSED
,
903 bfd
*output_bfd ATTRIBUTE_UNUSED
,
904 char **error_message ATTRIBUTE_UNUSED
)
910 /* Perform a single relocation. By default we use the standard BFD
911 routines, but a few relocs, we have to do them ourselves. */
913 static bfd_reloc_status_type
914 avr_final_link_relocate (reloc_howto_type
* howto
,
916 asection
* input_section
,
918 Elf_Internal_Rela
* rel
,
920 struct elf32_avr_link_hash_table
* htab
)
922 bfd_reloc_status_type r
= bfd_reloc_ok
;
925 bfd_signed_vma reloc_addr
;
926 bfd_boolean use_stubs
= FALSE
;
927 /* Usually is 0, unless we are generating code for a bootloader. */
928 bfd_signed_vma base_addr
= htab
->vector_base
;
930 /* Absolute addr of the reloc in the final excecutable. */
931 reloc_addr
= rel
->r_offset
+ input_section
->output_section
->vma
932 + input_section
->output_offset
;
937 contents
+= rel
->r_offset
;
938 srel
= (bfd_signed_vma
) relocation
;
939 srel
+= rel
->r_addend
;
940 srel
-= rel
->r_offset
;
941 srel
-= 2; /* Branch instructions add 2 to the PC... */
942 srel
-= (input_section
->output_section
->vma
+
943 input_section
->output_offset
);
946 return bfd_reloc_outofrange
;
947 if (srel
> ((1 << 7) - 1) || (srel
< - (1 << 7)))
948 return bfd_reloc_overflow
;
949 x
= bfd_get_16 (input_bfd
, contents
);
950 x
= (x
& 0xfc07) | (((srel
>> 1) << 3) & 0x3f8);
951 bfd_put_16 (input_bfd
, x
, contents
);
955 contents
+= rel
->r_offset
;
956 srel
= (bfd_signed_vma
) relocation
;
957 srel
+= rel
->r_addend
;
958 srel
-= rel
->r_offset
;
959 srel
-= 2; /* Branch instructions add 2 to the PC... */
960 srel
-= (input_section
->output_section
->vma
+
961 input_section
->output_offset
);
964 return bfd_reloc_outofrange
;
966 srel
= avr_relative_distance_considering_wrap_around (srel
);
968 /* AVR addresses commands as words. */
971 /* Check for overflow. */
972 if (srel
< -2048 || srel
> 2047)
974 /* Relative distance is too large. */
976 /* Always apply WRAPAROUND for avr2, avr25, and avr4. */
977 switch (bfd_get_mach (input_bfd
))
985 return bfd_reloc_overflow
;
989 x
= bfd_get_16 (input_bfd
, contents
);
990 x
= (x
& 0xf000) | (srel
& 0xfff);
991 bfd_put_16 (input_bfd
, x
, contents
);
995 contents
+= rel
->r_offset
;
996 srel
= (bfd_signed_vma
) relocation
+ rel
->r_addend
;
997 x
= bfd_get_16 (input_bfd
, contents
);
998 x
= (x
& 0xf0f0) | (srel
& 0xf) | ((srel
<< 4) & 0xf00);
999 bfd_put_16 (input_bfd
, x
, contents
);
1003 contents
+= rel
->r_offset
;
1004 srel
= (bfd_signed_vma
) relocation
+ rel
->r_addend
;
1005 if (((srel
> 0) && (srel
& 0xffff) > 255)
1006 || ((srel
< 0) && ((-srel
) & 0xffff) > 128))
1007 /* Remove offset for data/eeprom section. */
1008 return bfd_reloc_overflow
;
1010 x
= bfd_get_16 (input_bfd
, contents
);
1011 x
= (x
& 0xf0f0) | (srel
& 0xf) | ((srel
<< 4) & 0xf00);
1012 bfd_put_16 (input_bfd
, x
, contents
);
1016 contents
+= rel
->r_offset
;
1017 srel
= (bfd_signed_vma
) relocation
+ rel
->r_addend
;
1018 if (((srel
& 0xffff) > 63) || (srel
< 0))
1019 /* Remove offset for data/eeprom section. */
1020 return bfd_reloc_overflow
;
1021 x
= bfd_get_16 (input_bfd
, contents
);
1022 x
= (x
& 0xd3f8) | ((srel
& 7) | ((srel
& (3 << 3)) << 7)
1023 | ((srel
& (1 << 5)) << 8));
1024 bfd_put_16 (input_bfd
, x
, contents
);
1028 contents
+= rel
->r_offset
;
1029 srel
= (bfd_signed_vma
) relocation
+ rel
->r_addend
;
1030 if (((srel
& 0xffff) > 63) || (srel
< 0))
1031 /* Remove offset for data/eeprom section. */
1032 return bfd_reloc_overflow
;
1033 x
= bfd_get_16 (input_bfd
, contents
);
1034 x
= (x
& 0xff30) | (srel
& 0xf) | ((srel
& 0x30) << 2);
1035 bfd_put_16 (input_bfd
, x
, contents
);
1039 contents
+= rel
->r_offset
;
1040 srel
= (bfd_signed_vma
) relocation
+ rel
->r_addend
;
1041 srel
= (srel
>> 8) & 0xff;
1042 x
= bfd_get_16 (input_bfd
, contents
);
1043 x
= (x
& 0xf0f0) | (srel
& 0xf) | ((srel
<< 4) & 0xf00);
1044 bfd_put_16 (input_bfd
, x
, contents
);
1048 contents
+= rel
->r_offset
;
1049 srel
= (bfd_signed_vma
) relocation
+ rel
->r_addend
;
1050 srel
= (srel
>> 16) & 0xff;
1051 x
= bfd_get_16 (input_bfd
, contents
);
1052 x
= (x
& 0xf0f0) | (srel
& 0xf) | ((srel
<< 4) & 0xf00);
1053 bfd_put_16 (input_bfd
, x
, contents
);
1057 contents
+= rel
->r_offset
;
1058 srel
= (bfd_signed_vma
) relocation
+ rel
->r_addend
;
1059 srel
= (srel
>> 24) & 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_LO8_LDI_NEG
:
1066 contents
+= rel
->r_offset
;
1067 srel
= (bfd_signed_vma
) relocation
+ rel
->r_addend
;
1069 x
= bfd_get_16 (input_bfd
, contents
);
1070 x
= (x
& 0xf0f0) | (srel
& 0xf) | ((srel
<< 4) & 0xf00);
1071 bfd_put_16 (input_bfd
, x
, contents
);
1074 case R_AVR_HI8_LDI_NEG
:
1075 contents
+= rel
->r_offset
;
1076 srel
= (bfd_signed_vma
) relocation
+ rel
->r_addend
;
1078 srel
= (srel
>> 8) & 0xff;
1079 x
= bfd_get_16 (input_bfd
, contents
);
1080 x
= (x
& 0xf0f0) | (srel
& 0xf) | ((srel
<< 4) & 0xf00);
1081 bfd_put_16 (input_bfd
, x
, contents
);
1084 case R_AVR_HH8_LDI_NEG
:
1085 contents
+= rel
->r_offset
;
1086 srel
= (bfd_signed_vma
) relocation
+ rel
->r_addend
;
1088 srel
= (srel
>> 16) & 0xff;
1089 x
= bfd_get_16 (input_bfd
, contents
);
1090 x
= (x
& 0xf0f0) | (srel
& 0xf) | ((srel
<< 4) & 0xf00);
1091 bfd_put_16 (input_bfd
, x
, contents
);
1094 case R_AVR_MS8_LDI_NEG
:
1095 contents
+= rel
->r_offset
;
1096 srel
= (bfd_signed_vma
) relocation
+ rel
->r_addend
;
1098 srel
= (srel
>> 24) & 0xff;
1099 x
= bfd_get_16 (input_bfd
, contents
);
1100 x
= (x
& 0xf0f0) | (srel
& 0xf) | ((srel
<< 4) & 0xf00);
1101 bfd_put_16 (input_bfd
, x
, contents
);
1104 case R_AVR_LO8_LDI_GS
:
1105 use_stubs
= (!htab
->no_stubs
);
1107 case R_AVR_LO8_LDI_PM
:
1108 contents
+= rel
->r_offset
;
1109 srel
= (bfd_signed_vma
) relocation
+ rel
->r_addend
;
1112 && avr_stub_is_required_for_16_bit_reloc (srel
- base_addr
))
1114 bfd_vma old_srel
= srel
;
1116 /* We need to use the address of the stub instead. */
1117 srel
= avr_get_stub_addr (srel
, htab
);
1119 printf ("LD: Using jump stub (at 0x%x) with destination 0x%x for "
1120 "reloc at address 0x%x.\n",
1121 (unsigned int) srel
,
1122 (unsigned int) old_srel
,
1123 (unsigned int) reloc_addr
);
1125 if (avr_stub_is_required_for_16_bit_reloc (srel
- base_addr
))
1126 return bfd_reloc_outofrange
;
1130 return bfd_reloc_outofrange
;
1132 x
= bfd_get_16 (input_bfd
, contents
);
1133 x
= (x
& 0xf0f0) | (srel
& 0xf) | ((srel
<< 4) & 0xf00);
1134 bfd_put_16 (input_bfd
, x
, contents
);
1137 case R_AVR_HI8_LDI_GS
:
1138 use_stubs
= (!htab
->no_stubs
);
1140 case R_AVR_HI8_LDI_PM
:
1141 contents
+= rel
->r_offset
;
1142 srel
= (bfd_signed_vma
) relocation
+ rel
->r_addend
;
1145 && avr_stub_is_required_for_16_bit_reloc (srel
- base_addr
))
1147 bfd_vma old_srel
= srel
;
1149 /* We need to use the address of the stub instead. */
1150 srel
= avr_get_stub_addr (srel
, htab
);
1152 printf ("LD: Using jump stub (at 0x%x) with destination 0x%x for "
1153 "reloc at address 0x%x.\n",
1154 (unsigned int) srel
,
1155 (unsigned int) old_srel
,
1156 (unsigned int) reloc_addr
);
1158 if (avr_stub_is_required_for_16_bit_reloc (srel
- base_addr
))
1159 return bfd_reloc_outofrange
;
1163 return bfd_reloc_outofrange
;
1165 srel
= (srel
>> 8) & 0xff;
1166 x
= bfd_get_16 (input_bfd
, contents
);
1167 x
= (x
& 0xf0f0) | (srel
& 0xf) | ((srel
<< 4) & 0xf00);
1168 bfd_put_16 (input_bfd
, x
, contents
);
1171 case R_AVR_HH8_LDI_PM
:
1172 contents
+= rel
->r_offset
;
1173 srel
= (bfd_signed_vma
) relocation
+ rel
->r_addend
;
1175 return bfd_reloc_outofrange
;
1177 srel
= (srel
>> 16) & 0xff;
1178 x
= bfd_get_16 (input_bfd
, contents
);
1179 x
= (x
& 0xf0f0) | (srel
& 0xf) | ((srel
<< 4) & 0xf00);
1180 bfd_put_16 (input_bfd
, x
, contents
);
1183 case R_AVR_LO8_LDI_PM_NEG
:
1184 contents
+= rel
->r_offset
;
1185 srel
= (bfd_signed_vma
) relocation
+ rel
->r_addend
;
1188 return bfd_reloc_outofrange
;
1190 x
= bfd_get_16 (input_bfd
, contents
);
1191 x
= (x
& 0xf0f0) | (srel
& 0xf) | ((srel
<< 4) & 0xf00);
1192 bfd_put_16 (input_bfd
, x
, contents
);
1195 case R_AVR_HI8_LDI_PM_NEG
:
1196 contents
+= rel
->r_offset
;
1197 srel
= (bfd_signed_vma
) relocation
+ rel
->r_addend
;
1200 return bfd_reloc_outofrange
;
1202 srel
= (srel
>> 8) & 0xff;
1203 x
= bfd_get_16 (input_bfd
, contents
);
1204 x
= (x
& 0xf0f0) | (srel
& 0xf) | ((srel
<< 4) & 0xf00);
1205 bfd_put_16 (input_bfd
, x
, contents
);
1208 case R_AVR_HH8_LDI_PM_NEG
:
1209 contents
+= rel
->r_offset
;
1210 srel
= (bfd_signed_vma
) relocation
+ rel
->r_addend
;
1213 return bfd_reloc_outofrange
;
1215 srel
= (srel
>> 16) & 0xff;
1216 x
= bfd_get_16 (input_bfd
, contents
);
1217 x
= (x
& 0xf0f0) | (srel
& 0xf) | ((srel
<< 4) & 0xf00);
1218 bfd_put_16 (input_bfd
, x
, contents
);
1222 contents
+= rel
->r_offset
;
1223 srel
= (bfd_signed_vma
) relocation
+ rel
->r_addend
;
1225 return bfd_reloc_outofrange
;
1227 x
= bfd_get_16 (input_bfd
, contents
);
1228 x
|= ((srel
& 0x10000) | ((srel
<< 3) & 0x1f00000)) >> 16;
1229 bfd_put_16 (input_bfd
, x
, contents
);
1230 bfd_put_16 (input_bfd
, (bfd_vma
) srel
& 0xffff, contents
+2);
1234 use_stubs
= (!htab
->no_stubs
);
1235 contents
+= rel
->r_offset
;
1236 srel
= (bfd_signed_vma
) relocation
+ rel
->r_addend
;
1239 && avr_stub_is_required_for_16_bit_reloc (srel
- base_addr
))
1241 bfd_vma old_srel
= srel
;
1243 /* We need to use the address of the stub instead. */
1244 srel
= avr_get_stub_addr (srel
,htab
);
1246 printf ("LD: Using jump stub (at 0x%x) with destination 0x%x for "
1247 "reloc at address 0x%x.\n",
1248 (unsigned int) srel
,
1249 (unsigned int) old_srel
,
1250 (unsigned int) reloc_addr
);
1252 if (avr_stub_is_required_for_16_bit_reloc (srel
- base_addr
))
1253 return bfd_reloc_outofrange
;
1257 return bfd_reloc_outofrange
;
1259 bfd_put_16 (input_bfd
, (bfd_vma
) srel
&0x00ffff, contents
);
1265 /* Nothing to do here, as contents already contains the diff value. */
1269 case R_AVR_LDS_STS_16
:
1270 contents
+= rel
->r_offset
;
1271 srel
= (bfd_signed_vma
) relocation
+ rel
->r_addend
;
1272 if ((srel
& 0xFFFF) < 0x40 || (srel
& 0xFFFF) > 0xbf)
1273 return bfd_reloc_outofrange
;
1275 x
= bfd_get_16 (input_bfd
, contents
);
1276 x
|= (srel
& 0x0f) | ((srel
& 0x30) << 5) | ((srel
& 0x40) << 2);
1277 bfd_put_16 (input_bfd
, x
, contents
);
1281 contents
+= rel
->r_offset
;
1282 srel
= (bfd_signed_vma
) relocation
+ rel
->r_addend
;
1283 if ((srel
& 0xffff) > 0x3f)
1284 return bfd_reloc_outofrange
;
1285 x
= bfd_get_16 (input_bfd
, contents
);
1286 x
= (x
& 0xf9f0) | ((srel
& 0x30) << 5) | (srel
& 0x0f);
1287 bfd_put_16 (input_bfd
, x
, contents
);
1291 contents
+= rel
->r_offset
;
1292 srel
= (bfd_signed_vma
) relocation
+ rel
->r_addend
;
1293 if ((srel
& 0xffff) > 0x1f)
1294 return bfd_reloc_outofrange
;
1295 x
= bfd_get_16 (input_bfd
, contents
);
1296 x
= (x
& 0xff07) | ((srel
& 0x1f) << 3);
1297 bfd_put_16 (input_bfd
, x
, contents
);
1301 r
= _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
1302 contents
, rel
->r_offset
,
1303 relocation
, rel
->r_addend
);
1309 /* Relocate an AVR ELF section. */
1312 elf32_avr_relocate_section (bfd
*output_bfd ATTRIBUTE_UNUSED
,
1313 struct bfd_link_info
*info
,
1315 asection
*input_section
,
1317 Elf_Internal_Rela
*relocs
,
1318 Elf_Internal_Sym
*local_syms
,
1319 asection
**local_sections
)
1321 Elf_Internal_Shdr
* symtab_hdr
;
1322 struct elf_link_hash_entry
** sym_hashes
;
1323 Elf_Internal_Rela
* rel
;
1324 Elf_Internal_Rela
* relend
;
1325 struct elf32_avr_link_hash_table
* htab
= avr_link_hash_table (info
);
1330 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
1331 sym_hashes
= elf_sym_hashes (input_bfd
);
1332 relend
= relocs
+ input_section
->reloc_count
;
1334 for (rel
= relocs
; rel
< relend
; rel
++)
1336 reloc_howto_type
* howto
;
1337 unsigned long r_symndx
;
1338 Elf_Internal_Sym
* sym
;
1340 struct elf_link_hash_entry
* h
;
1342 bfd_reloc_status_type r
;
1346 r_type
= ELF32_R_TYPE (rel
->r_info
);
1347 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1348 howto
= elf_avr_howto_table
+ r_type
;
1353 if (r_symndx
< symtab_hdr
->sh_info
)
1355 sym
= local_syms
+ r_symndx
;
1356 sec
= local_sections
[r_symndx
];
1357 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
1359 name
= bfd_elf_string_from_elf_section
1360 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
);
1361 name
= (name
== NULL
) ? bfd_section_name (input_bfd
, sec
) : name
;
1365 bfd_boolean unresolved_reloc
, warned
, ignored
;
1367 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
1368 r_symndx
, symtab_hdr
, sym_hashes
,
1370 unresolved_reloc
, warned
, ignored
);
1372 name
= h
->root
.root
.string
;
1375 if (sec
!= NULL
&& discarded_section (sec
))
1376 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
1377 rel
, 1, relend
, howto
, 0, contents
);
1379 if (info
->relocatable
)
1382 r
= avr_final_link_relocate (howto
, input_bfd
, input_section
,
1383 contents
, rel
, relocation
, htab
);
1385 if (r
!= bfd_reloc_ok
)
1387 const char * msg
= (const char *) NULL
;
1391 case bfd_reloc_overflow
:
1392 r
= info
->callbacks
->reloc_overflow
1393 (info
, (h
? &h
->root
: NULL
),
1394 name
, howto
->name
, (bfd_vma
) 0,
1395 input_bfd
, input_section
, rel
->r_offset
);
1398 case bfd_reloc_undefined
:
1399 r
= info
->callbacks
->undefined_symbol
1400 (info
, name
, input_bfd
, input_section
, rel
->r_offset
, TRUE
);
1403 case bfd_reloc_outofrange
:
1404 msg
= _("internal error: out of range error");
1407 case bfd_reloc_notsupported
:
1408 msg
= _("internal error: unsupported relocation error");
1411 case bfd_reloc_dangerous
:
1412 msg
= _("internal error: dangerous relocation");
1416 msg
= _("internal error: unknown error");
1421 r
= info
->callbacks
->warning
1422 (info
, msg
, name
, input_bfd
, input_section
, rel
->r_offset
);
1432 /* The final processing done just before writing out a AVR ELF object
1433 file. This gets the AVR architecture right based on the machine
1437 bfd_elf_avr_final_write_processing (bfd
*abfd
,
1438 bfd_boolean linker ATTRIBUTE_UNUSED
)
1442 switch (bfd_get_mach (abfd
))
1446 val
= E_AVR_MACH_AVR2
;
1450 val
= E_AVR_MACH_AVR1
;
1453 case bfd_mach_avr25
:
1454 val
= E_AVR_MACH_AVR25
;
1458 val
= E_AVR_MACH_AVR3
;
1461 case bfd_mach_avr31
:
1462 val
= E_AVR_MACH_AVR31
;
1465 case bfd_mach_avr35
:
1466 val
= E_AVR_MACH_AVR35
;
1470 val
= E_AVR_MACH_AVR4
;
1474 val
= E_AVR_MACH_AVR5
;
1477 case bfd_mach_avr51
:
1478 val
= E_AVR_MACH_AVR51
;
1482 val
= E_AVR_MACH_AVR6
;
1485 case bfd_mach_avrxmega1
:
1486 val
= E_AVR_MACH_XMEGA1
;
1489 case bfd_mach_avrxmega2
:
1490 val
= E_AVR_MACH_XMEGA2
;
1493 case bfd_mach_avrxmega3
:
1494 val
= E_AVR_MACH_XMEGA3
;
1497 case bfd_mach_avrxmega4
:
1498 val
= E_AVR_MACH_XMEGA4
;
1501 case bfd_mach_avrxmega5
:
1502 val
= E_AVR_MACH_XMEGA5
;
1505 case bfd_mach_avrxmega6
:
1506 val
= E_AVR_MACH_XMEGA6
;
1509 case bfd_mach_avrxmega7
:
1510 val
= E_AVR_MACH_XMEGA7
;
1513 case bfd_mach_avrtiny
:
1514 val
= E_AVR_MACH_AVRTINY
;
1518 elf_elfheader (abfd
)->e_machine
= EM_AVR
;
1519 elf_elfheader (abfd
)->e_flags
&= ~ EF_AVR_MACH
;
1520 elf_elfheader (abfd
)->e_flags
|= val
;
1521 elf_elfheader (abfd
)->e_flags
|= EF_AVR_LINKRELAX_PREPARED
;
1524 /* Set the right machine number. */
1527 elf32_avr_object_p (bfd
*abfd
)
1529 unsigned int e_set
= bfd_mach_avr2
;
1531 if (elf_elfheader (abfd
)->e_machine
== EM_AVR
1532 || elf_elfheader (abfd
)->e_machine
== EM_AVR_OLD
)
1534 int e_mach
= elf_elfheader (abfd
)->e_flags
& EF_AVR_MACH
;
1539 case E_AVR_MACH_AVR2
:
1540 e_set
= bfd_mach_avr2
;
1543 case E_AVR_MACH_AVR1
:
1544 e_set
= bfd_mach_avr1
;
1547 case E_AVR_MACH_AVR25
:
1548 e_set
= bfd_mach_avr25
;
1551 case E_AVR_MACH_AVR3
:
1552 e_set
= bfd_mach_avr3
;
1555 case E_AVR_MACH_AVR31
:
1556 e_set
= bfd_mach_avr31
;
1559 case E_AVR_MACH_AVR35
:
1560 e_set
= bfd_mach_avr35
;
1563 case E_AVR_MACH_AVR4
:
1564 e_set
= bfd_mach_avr4
;
1567 case E_AVR_MACH_AVR5
:
1568 e_set
= bfd_mach_avr5
;
1571 case E_AVR_MACH_AVR51
:
1572 e_set
= bfd_mach_avr51
;
1575 case E_AVR_MACH_AVR6
:
1576 e_set
= bfd_mach_avr6
;
1579 case E_AVR_MACH_XMEGA1
:
1580 e_set
= bfd_mach_avrxmega1
;
1583 case E_AVR_MACH_XMEGA2
:
1584 e_set
= bfd_mach_avrxmega2
;
1587 case E_AVR_MACH_XMEGA3
:
1588 e_set
= bfd_mach_avrxmega3
;
1591 case E_AVR_MACH_XMEGA4
:
1592 e_set
= bfd_mach_avrxmega4
;
1595 case E_AVR_MACH_XMEGA5
:
1596 e_set
= bfd_mach_avrxmega5
;
1599 case E_AVR_MACH_XMEGA6
:
1600 e_set
= bfd_mach_avrxmega6
;
1603 case E_AVR_MACH_XMEGA7
:
1604 e_set
= bfd_mach_avrxmega7
;
1607 case E_AVR_MACH_AVRTINY
:
1608 e_set
= bfd_mach_avrtiny
;
1612 return bfd_default_set_arch_mach (abfd
, bfd_arch_avr
,
1616 /* Returns whether the relocation type passed is a diff reloc. */
1619 elf32_avr_is_diff_reloc (Elf_Internal_Rela
*irel
)
1621 return (ELF32_R_TYPE (irel
->r_info
) == R_AVR_DIFF8
1622 ||ELF32_R_TYPE (irel
->r_info
) == R_AVR_DIFF16
1623 || ELF32_R_TYPE (irel
->r_info
) == R_AVR_DIFF32
);
1626 /* Reduce the diff value written in the section by count if the shrinked
1627 insn address happens to fall between the two symbols for which this
1628 diff reloc was emitted. */
1631 elf32_avr_adjust_diff_reloc_value (bfd
*abfd
,
1632 struct bfd_section
*isec
,
1633 Elf_Internal_Rela
*irel
,
1635 bfd_vma shrinked_insn_address
,
1638 unsigned char *reloc_contents
= NULL
;
1639 unsigned char *isec_contents
= elf_section_data (isec
)->this_hdr
.contents
;
1640 if (isec_contents
== NULL
)
1642 if (! bfd_malloc_and_get_section (abfd
, isec
, &isec_contents
))
1645 elf_section_data (isec
)->this_hdr
.contents
= isec_contents
;
1648 reloc_contents
= isec_contents
+ irel
->r_offset
;
1650 /* Read value written in object file. */
1652 switch (ELF32_R_TYPE (irel
->r_info
))
1656 x
= *reloc_contents
;
1661 x
= bfd_get_16 (abfd
, reloc_contents
);
1666 x
= bfd_get_32 (abfd
, reloc_contents
);
1675 /* For a diff reloc sym1 - sym2 the diff at assembly time (x) is written
1676 into the object file at the reloc offset. sym2's logical value is
1677 symval (<start_of_section>) + reloc addend. Compute the start and end
1678 addresses and check if the shrinked insn falls between sym1 and sym2. */
1680 bfd_vma end_address
= symval
+ irel
->r_addend
;
1681 bfd_vma start_address
= end_address
- x
;
1683 /* Reduce the diff value by count bytes and write it back into section
1686 if (shrinked_insn_address
>= start_address
1687 && shrinked_insn_address
<= end_address
)
1689 switch (ELF32_R_TYPE (irel
->r_info
))
1693 *reloc_contents
= (x
- count
);
1698 bfd_put_16 (abfd
, (x
- count
) & 0xFFFF, reloc_contents
);
1703 bfd_put_32 (abfd
, (x
- count
) & 0xFFFFFFFF, reloc_contents
);
1715 /* Delete some bytes from a section while changing the size of an instruction.
1716 The parameter "addr" denotes the section-relative offset pointing just
1717 behind the shrinked instruction. "addr+count" point at the first
1718 byte just behind the original unshrinked instruction. */
1721 elf32_avr_relax_delete_bytes (bfd
*abfd
,
1726 Elf_Internal_Shdr
*symtab_hdr
;
1727 unsigned int sec_shndx
;
1729 Elf_Internal_Rela
*irel
, *irelend
;
1730 Elf_Internal_Sym
*isym
;
1731 Elf_Internal_Sym
*isymbuf
= NULL
;
1733 struct elf_link_hash_entry
**sym_hashes
;
1734 struct elf_link_hash_entry
**end_hashes
;
1735 unsigned int symcount
;
1737 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1738 sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
1739 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1743 irel
= elf_section_data (sec
)->relocs
;
1744 irelend
= irel
+ sec
->reloc_count
;
1746 /* Actually delete the bytes. */
1747 if (toaddr
- addr
- count
> 0)
1748 memmove (contents
+ addr
, contents
+ addr
+ count
,
1749 (size_t) (toaddr
- addr
- count
));
1752 /* Adjust all the reloc addresses. */
1753 for (irel
= elf_section_data (sec
)->relocs
; irel
< irelend
; irel
++)
1755 bfd_vma old_reloc_address
;
1757 old_reloc_address
= (sec
->output_section
->vma
1758 + sec
->output_offset
+ irel
->r_offset
);
1760 /* Get the new reloc address. */
1761 if ((irel
->r_offset
> addr
1762 && irel
->r_offset
< toaddr
))
1765 printf ("Relocation at address 0x%x needs to be moved.\n"
1766 "Old section offset: 0x%x, New section offset: 0x%x \n",
1767 (unsigned int) old_reloc_address
,
1768 (unsigned int) irel
->r_offset
,
1769 (unsigned int) ((irel
->r_offset
) - count
));
1771 irel
->r_offset
-= count
;
1776 /* The reloc's own addresses are now ok. However, we need to readjust
1777 the reloc's addend, i.e. the reloc's value if two conditions are met:
1778 1.) the reloc is relative to a symbol in this section that
1779 is located in front of the shrinked instruction
1780 2.) symbol plus addend end up behind the shrinked instruction.
1782 The most common case where this happens are relocs relative to
1783 the section-start symbol.
1785 This step needs to be done for all of the sections of the bfd. */
1788 struct bfd_section
*isec
;
1790 for (isec
= abfd
->sections
; isec
; isec
= isec
->next
)
1793 bfd_vma shrinked_insn_address
;
1795 if (isec
->reloc_count
== 0)
1798 shrinked_insn_address
= (sec
->output_section
->vma
1799 + sec
->output_offset
+ addr
- count
);
1801 irel
= elf_section_data (isec
)->relocs
;
1802 /* PR 12161: Read in the relocs for this section if necessary. */
1804 irel
= _bfd_elf_link_read_relocs (abfd
, isec
, NULL
, NULL
, TRUE
);
1806 for (irelend
= irel
+ isec
->reloc_count
;
1810 /* Read this BFD's local symbols if we haven't done
1812 if (isymbuf
== NULL
&& symtab_hdr
->sh_info
!= 0)
1814 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
1815 if (isymbuf
== NULL
)
1816 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
1817 symtab_hdr
->sh_info
, 0,
1819 if (isymbuf
== NULL
)
1823 /* Get the value of the symbol referred to by the reloc. */
1824 if (ELF32_R_SYM (irel
->r_info
) < symtab_hdr
->sh_info
)
1826 /* A local symbol. */
1829 isym
= isymbuf
+ ELF32_R_SYM (irel
->r_info
);
1830 sym_sec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
1831 symval
= isym
->st_value
;
1832 /* If the reloc is absolute, it will not have
1833 a symbol or section associated with it. */
1836 symval
+= sym_sec
->output_section
->vma
1837 + sym_sec
->output_offset
;
1840 printf ("Checking if the relocation's "
1841 "addend needs corrections.\n"
1842 "Address of anchor symbol: 0x%x \n"
1843 "Address of relocation target: 0x%x \n"
1844 "Address of relaxed insn: 0x%x \n",
1845 (unsigned int) symval
,
1846 (unsigned int) (symval
+ irel
->r_addend
),
1847 (unsigned int) shrinked_insn_address
);
1849 if (symval
<= shrinked_insn_address
1850 && (symval
+ irel
->r_addend
) > shrinked_insn_address
)
1852 if (elf32_avr_is_diff_reloc (irel
))
1854 elf32_avr_adjust_diff_reloc_value (abfd
, isec
, irel
,
1856 shrinked_insn_address
,
1860 irel
->r_addend
-= count
;
1863 printf ("Relocation's addend needed to be fixed \n");
1866 /* else...Reference symbol is absolute. No adjustment needed. */
1868 /* else...Reference symbol is extern. No need for adjusting
1874 /* Adjust the local symbols defined in this section. */
1875 isym
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
1876 /* Fix PR 9841, there may be no local symbols. */
1879 Elf_Internal_Sym
*isymend
;
1881 isymend
= isym
+ symtab_hdr
->sh_info
;
1882 for (; isym
< isymend
; isym
++)
1884 if (isym
->st_shndx
== sec_shndx
)
1886 if (isym
->st_value
> addr
1887 && isym
->st_value
<= toaddr
)
1888 isym
->st_value
-= count
;
1890 if (isym
->st_value
<= addr
1891 && isym
->st_value
+ isym
->st_size
> addr
)
1893 /* If this assert fires then we have a symbol that ends
1894 part way through an instruction. Does that make
1896 BFD_ASSERT (isym
->st_value
+ isym
->st_size
>= addr
+ count
);
1897 isym
->st_size
-= count
;
1903 /* Now adjust the global symbols defined in this section. */
1904 symcount
= (symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
)
1905 - symtab_hdr
->sh_info
);
1906 sym_hashes
= elf_sym_hashes (abfd
);
1907 end_hashes
= sym_hashes
+ symcount
;
1908 for (; sym_hashes
< end_hashes
; sym_hashes
++)
1910 struct elf_link_hash_entry
*sym_hash
= *sym_hashes
;
1911 if ((sym_hash
->root
.type
== bfd_link_hash_defined
1912 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
1913 && sym_hash
->root
.u
.def
.section
== sec
)
1915 if (sym_hash
->root
.u
.def
.value
> addr
1916 && sym_hash
->root
.u
.def
.value
<= toaddr
)
1917 sym_hash
->root
.u
.def
.value
-= count
;
1919 if (sym_hash
->root
.u
.def
.value
<= addr
1920 && (sym_hash
->root
.u
.def
.value
+ sym_hash
->size
> addr
))
1922 /* If this assert fires then we have a symbol that ends
1923 part way through an instruction. Does that make
1925 BFD_ASSERT (sym_hash
->root
.u
.def
.value
+ sym_hash
->size
1927 sym_hash
->size
-= count
;
1935 /* This function handles relaxing for the avr.
1936 Many important relaxing opportunities within functions are already
1937 realized by the compiler itself.
1938 Here we try to replace call (4 bytes) -> rcall (2 bytes)
1939 and jump -> rjmp (safes also 2 bytes).
1940 As well we now optimize seqences of
1941 - call/rcall function
1946 . In case that within a sequence
1949 the ret could no longer be reached it is optimized away. In order
1950 to check if the ret is no longer needed, it is checked that the ret's address
1951 is not the target of a branch or jump within the same section, it is checked
1952 that there is no skip instruction before the jmp/rjmp and that there
1953 is no local or global label place at the address of the ret.
1955 We refrain from relaxing within sections ".vectors" and
1956 ".jumptables" in order to maintain the position of the instructions.
1957 There, however, we substitute jmp/call by a sequence rjmp,nop/rcall,nop
1958 if possible. (In future one could possibly use the space of the nop
1959 for the first instruction of the irq service function.
1961 The .jumptables sections is meant to be used for a future tablejump variant
1962 for the devices with 3-byte program counter where the table itself
1963 contains 4-byte jump instructions whose relative offset must not
1967 elf32_avr_relax_section (bfd
*abfd
,
1969 struct bfd_link_info
*link_info
,
1972 Elf_Internal_Shdr
*symtab_hdr
;
1973 Elf_Internal_Rela
*internal_relocs
;
1974 Elf_Internal_Rela
*irel
, *irelend
;
1975 bfd_byte
*contents
= NULL
;
1976 Elf_Internal_Sym
*isymbuf
= NULL
;
1977 struct elf32_avr_link_hash_table
*htab
;
1979 /* If 'shrinkable' is FALSE, do not shrink by deleting bytes while
1980 relaxing. Such shrinking can cause issues for the sections such
1981 as .vectors and .jumptables. Instead the unused bytes should be
1982 filled with nop instructions. */
1983 bfd_boolean shrinkable
= TRUE
;
1985 if (!strcmp (sec
->name
,".vectors")
1986 || !strcmp (sec
->name
,".jumptables"))
1989 if (link_info
->relocatable
)
1990 (*link_info
->callbacks
->einfo
)
1991 (_("%P%F: --relax and -r may not be used together\n"));
1993 htab
= avr_link_hash_table (link_info
);
1997 /* Assume nothing changes. */
2000 if ((!htab
->no_stubs
) && (sec
== htab
->stub_sec
))
2002 /* We are just relaxing the stub section.
2003 Let's calculate the size needed again. */
2004 bfd_size_type last_estimated_stub_section_size
= htab
->stub_sec
->size
;
2007 printf ("Relaxing the stub section. Size prior to this pass: %i\n",
2008 (int) last_estimated_stub_section_size
);
2010 elf32_avr_size_stubs (htab
->stub_sec
->output_section
->owner
,
2013 /* Check if the number of trampolines changed. */
2014 if (last_estimated_stub_section_size
!= htab
->stub_sec
->size
)
2018 printf ("Size of stub section after this pass: %i\n",
2019 (int) htab
->stub_sec
->size
);
2024 /* We don't have to do anything for a relocatable link, if
2025 this section does not have relocs, or if this is not a
2027 if (link_info
->relocatable
2028 || (sec
->flags
& SEC_RELOC
) == 0
2029 || sec
->reloc_count
== 0
2030 || (sec
->flags
& SEC_CODE
) == 0)
2033 /* Check if the object file to relax uses internal symbols so that we
2034 could fix up the relocations. */
2035 if (!(elf_elfheader (abfd
)->e_flags
& EF_AVR_LINKRELAX_PREPARED
))
2038 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2040 /* Get a copy of the native relocations. */
2041 internal_relocs
= (_bfd_elf_link_read_relocs
2042 (abfd
, sec
, NULL
, NULL
, link_info
->keep_memory
));
2043 if (internal_relocs
== NULL
)
2046 /* Walk through the relocs looking for relaxing opportunities. */
2047 irelend
= internal_relocs
+ sec
->reloc_count
;
2048 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
2052 if ( ELF32_R_TYPE (irel
->r_info
) != R_AVR_13_PCREL
2053 && ELF32_R_TYPE (irel
->r_info
) != R_AVR_7_PCREL
2054 && ELF32_R_TYPE (irel
->r_info
) != R_AVR_CALL
)
2057 /* Get the section contents if we haven't done so already. */
2058 if (contents
== NULL
)
2060 /* Get cached copy if it exists. */
2061 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
2062 contents
= elf_section_data (sec
)->this_hdr
.contents
;
2065 /* Go get them off disk. */
2066 if (! bfd_malloc_and_get_section (abfd
, sec
, &contents
))
2071 /* Read this BFD's local symbols if we haven't done so already. */
2072 if (isymbuf
== NULL
&& symtab_hdr
->sh_info
!= 0)
2074 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
2075 if (isymbuf
== NULL
)
2076 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
2077 symtab_hdr
->sh_info
, 0,
2079 if (isymbuf
== NULL
)
2084 /* Get the value of the symbol referred to by the reloc. */
2085 if (ELF32_R_SYM (irel
->r_info
) < symtab_hdr
->sh_info
)
2087 /* A local symbol. */
2088 Elf_Internal_Sym
*isym
;
2091 isym
= isymbuf
+ ELF32_R_SYM (irel
->r_info
);
2092 sym_sec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
2093 symval
= isym
->st_value
;
2094 /* If the reloc is absolute, it will not have
2095 a symbol or section associated with it. */
2097 symval
+= sym_sec
->output_section
->vma
2098 + sym_sec
->output_offset
;
2103 struct elf_link_hash_entry
*h
;
2105 /* An external symbol. */
2106 indx
= ELF32_R_SYM (irel
->r_info
) - symtab_hdr
->sh_info
;
2107 h
= elf_sym_hashes (abfd
)[indx
];
2108 BFD_ASSERT (h
!= NULL
);
2109 if (h
->root
.type
!= bfd_link_hash_defined
2110 && h
->root
.type
!= bfd_link_hash_defweak
)
2111 /* This appears to be a reference to an undefined
2112 symbol. Just ignore it--it will be caught by the
2113 regular reloc processing. */
2116 symval
= (h
->root
.u
.def
.value
2117 + h
->root
.u
.def
.section
->output_section
->vma
2118 + h
->root
.u
.def
.section
->output_offset
);
2121 /* For simplicity of coding, we are going to modify the section
2122 contents, the section relocs, and the BFD symbol table. We
2123 must tell the rest of the code not to free up this
2124 information. It would be possible to instead create a table
2125 of changes which have to be made, as is done in coff-mips.c;
2126 that would be more work, but would require less memory when
2127 the linker is run. */
2128 switch (ELF32_R_TYPE (irel
->r_info
))
2130 /* Try to turn a 22-bit absolute call/jump into an 13-bit
2131 pc-relative rcall/rjmp. */
2134 bfd_vma value
= symval
+ irel
->r_addend
;
2136 int distance_short_enough
= 0;
2138 /* Get the address of this instruction. */
2139 dot
= (sec
->output_section
->vma
2140 + sec
->output_offset
+ irel
->r_offset
);
2142 /* Compute the distance from this insn to the branch target. */
2145 /* Check if the gap falls in the range that can be accommodated
2146 in 13bits signed (It is 12bits when encoded, as we deal with
2147 word addressing). */
2148 if (!shrinkable
&& ((int) gap
>= -4096 && (int) gap
<= 4095))
2149 distance_short_enough
= 1;
2150 /* If shrinkable, then we can check for a range of distance which
2151 is two bytes farther on both the directions because the call
2152 or jump target will be closer by two bytes after the
2154 else if (shrinkable
&& ((int) gap
>= -4094 && (int) gap
<= 4097))
2155 distance_short_enough
= 1;
2157 /* Here we handle the wrap-around case. E.g. for a 16k device
2158 we could use a rjmp to jump from address 0x100 to 0x3d00!
2159 In order to make this work properly, we need to fill the
2160 vaiable avr_pc_wrap_around with the appropriate value.
2161 I.e. 0x4000 for a 16k device. */
2163 /* Shrinking the code size makes the gaps larger in the
2164 case of wrap-arounds. So we use a heuristical safety
2165 margin to avoid that during relax the distance gets
2166 again too large for the short jumps. Let's assume
2167 a typical code-size reduction due to relax for a
2168 16k device of 600 bytes. So let's use twice the
2169 typical value as safety margin. */
2173 int assumed_shrink
= 600;
2174 if (avr_pc_wrap_around
> 0x4000)
2175 assumed_shrink
= 900;
2177 safety_margin
= 2 * assumed_shrink
;
2179 rgap
= avr_relative_distance_considering_wrap_around (gap
);
2181 if (rgap
>= (-4092 + safety_margin
)
2182 && rgap
<= (4094 - safety_margin
))
2183 distance_short_enough
= 1;
2186 if (distance_short_enough
)
2188 unsigned char code_msb
;
2189 unsigned char code_lsb
;
2192 printf ("shrinking jump/call instruction at address 0x%x"
2193 " in section %s\n\n",
2194 (int) dot
, sec
->name
);
2196 /* Note that we've changed the relocs, section contents,
2198 elf_section_data (sec
)->relocs
= internal_relocs
;
2199 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2200 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
2202 /* Get the instruction code for relaxing. */
2203 code_lsb
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
);
2204 code_msb
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
+ 1);
2206 /* Mask out the relocation bits. */
2209 if (code_msb
== 0x94 && code_lsb
== 0x0E)
2211 /* we are changing call -> rcall . */
2212 bfd_put_8 (abfd
, 0x00, contents
+ irel
->r_offset
);
2213 bfd_put_8 (abfd
, 0xD0, contents
+ irel
->r_offset
+ 1);
2215 else if (code_msb
== 0x94 && code_lsb
== 0x0C)
2217 /* we are changeing jump -> rjmp. */
2218 bfd_put_8 (abfd
, 0x00, contents
+ irel
->r_offset
);
2219 bfd_put_8 (abfd
, 0xC0, contents
+ irel
->r_offset
+ 1);
2224 /* Fix the relocation's type. */
2225 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
2228 /* We should not modify the ordering if 'shrinkable' is
2232 /* Let's insert a nop. */
2233 bfd_put_8 (abfd
, 0x00, contents
+ irel
->r_offset
+ 2);
2234 bfd_put_8 (abfd
, 0x00, contents
+ irel
->r_offset
+ 3);
2238 /* Delete two bytes of data. */
2239 if (!elf32_avr_relax_delete_bytes (abfd
, sec
,
2240 irel
->r_offset
+ 2, 2))
2243 /* That will change things, so, we should relax again.
2244 Note that this is not required, and it may be slow. */
2252 unsigned char code_msb
;
2253 unsigned char code_lsb
;
2256 code_msb
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
+ 1);
2257 code_lsb
= bfd_get_8 (abfd
, contents
+ irel
->r_offset
+ 0);
2259 /* Get the address of this instruction. */
2260 dot
= (sec
->output_section
->vma
2261 + sec
->output_offset
+ irel
->r_offset
);
2263 /* Here we look for rcall/ret or call/ret sequences that could be
2264 safely replaced by rjmp/ret or jmp/ret. */
2265 if (((code_msb
& 0xf0) == 0xd0)
2266 && avr_replace_call_ret_sequences
)
2268 /* This insn is a rcall. */
2269 unsigned char next_insn_msb
= 0;
2270 unsigned char next_insn_lsb
= 0;
2272 if (irel
->r_offset
+ 3 < sec
->size
)
2275 bfd_get_8 (abfd
, contents
+ irel
->r_offset
+ 3);
2277 bfd_get_8 (abfd
, contents
+ irel
->r_offset
+ 2);
2280 if ((0x95 == next_insn_msb
) && (0x08 == next_insn_lsb
))
2282 /* The next insn is a ret. We now convert the rcall insn
2283 into a rjmp instruction. */
2285 bfd_put_8 (abfd
, code_msb
, contents
+ irel
->r_offset
+ 1);
2287 printf ("converted rcall/ret sequence at address 0x%x"
2288 " into rjmp/ret sequence. Section is %s\n\n",
2289 (int) dot
, sec
->name
);
2294 else if ((0x94 == (code_msb
& 0xfe))
2295 && (0x0e == (code_lsb
& 0x0e))
2296 && avr_replace_call_ret_sequences
)
2298 /* This insn is a call. */
2299 unsigned char next_insn_msb
= 0;
2300 unsigned char next_insn_lsb
= 0;
2302 if (irel
->r_offset
+ 5 < sec
->size
)
2305 bfd_get_8 (abfd
, contents
+ irel
->r_offset
+ 5);
2307 bfd_get_8 (abfd
, contents
+ irel
->r_offset
+ 4);
2310 if ((0x95 == next_insn_msb
) && (0x08 == next_insn_lsb
))
2312 /* The next insn is a ret. We now convert the call insn
2313 into a jmp instruction. */
2316 bfd_put_8 (abfd
, code_lsb
, contents
+ irel
->r_offset
);
2318 printf ("converted call/ret sequence at address 0x%x"
2319 " into jmp/ret sequence. Section is %s\n\n",
2320 (int) dot
, sec
->name
);
2325 else if ((0xc0 == (code_msb
& 0xf0))
2326 || ((0x94 == (code_msb
& 0xfe))
2327 && (0x0c == (code_lsb
& 0x0e))))
2329 /* This insn is a rjmp or a jmp. */
2330 unsigned char next_insn_msb
= 0;
2331 unsigned char next_insn_lsb
= 0;
2334 if (0xc0 == (code_msb
& 0xf0))
2335 insn_size
= 2; /* rjmp insn */
2337 insn_size
= 4; /* jmp insn */
2339 if (irel
->r_offset
+ insn_size
+ 1 < sec
->size
)
2342 bfd_get_8 (abfd
, contents
+ irel
->r_offset
2345 bfd_get_8 (abfd
, contents
+ irel
->r_offset
2349 if ((0x95 == next_insn_msb
) && (0x08 == next_insn_lsb
))
2351 /* The next insn is a ret. We possibly could delete
2352 this ret. First we need to check for preceding
2353 sbis/sbic/sbrs or cpse "skip" instructions. */
2355 int there_is_preceding_non_skip_insn
= 1;
2356 bfd_vma address_of_ret
;
2358 address_of_ret
= dot
+ insn_size
;
2360 if (debug_relax
&& (insn_size
== 2))
2361 printf ("found rjmp / ret sequence at address 0x%x\n",
2363 if (debug_relax
&& (insn_size
== 4))
2364 printf ("found jmp / ret sequence at address 0x%x\n",
2367 /* We have to make sure that there is a preceding insn. */
2368 if (irel
->r_offset
>= 2)
2370 unsigned char preceding_msb
;
2371 unsigned char preceding_lsb
;
2374 bfd_get_8 (abfd
, contents
+ irel
->r_offset
- 1);
2376 bfd_get_8 (abfd
, contents
+ irel
->r_offset
- 2);
2379 if (0x99 == preceding_msb
)
2380 there_is_preceding_non_skip_insn
= 0;
2383 if (0x9b == preceding_msb
)
2384 there_is_preceding_non_skip_insn
= 0;
2387 if ((0xfc == (preceding_msb
& 0xfe)
2388 && (0x00 == (preceding_lsb
& 0x08))))
2389 there_is_preceding_non_skip_insn
= 0;
2392 if ((0xfe == (preceding_msb
& 0xfe)
2393 && (0x00 == (preceding_lsb
& 0x08))))
2394 there_is_preceding_non_skip_insn
= 0;
2397 if (0x10 == (preceding_msb
& 0xfc))
2398 there_is_preceding_non_skip_insn
= 0;
2400 if (there_is_preceding_non_skip_insn
== 0)
2402 printf ("preceding skip insn prevents deletion of"
2403 " ret insn at Addy 0x%x in section %s\n",
2404 (int) dot
+ 2, sec
->name
);
2408 /* There is no previous instruction. */
2409 there_is_preceding_non_skip_insn
= 0;
2412 if (there_is_preceding_non_skip_insn
)
2414 /* We now only have to make sure that there is no
2415 local label defined at the address of the ret
2416 instruction and that there is no local relocation
2417 in this section pointing to the ret. */
2419 int deleting_ret_is_safe
= 1;
2420 unsigned int section_offset_of_ret_insn
=
2421 irel
->r_offset
+ insn_size
;
2422 Elf_Internal_Sym
*isym
, *isymend
;
2423 unsigned int sec_shndx
;
2424 struct bfd_section
*isec
;
2427 _bfd_elf_section_from_bfd_section (abfd
, sec
);
2429 /* Check for local symbols. */
2430 isym
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
2431 isymend
= isym
+ symtab_hdr
->sh_info
;
2432 /* PR 6019: There may not be any local symbols. */
2433 for (; isym
!= NULL
&& isym
< isymend
; isym
++)
2435 if (isym
->st_value
== section_offset_of_ret_insn
2436 && isym
->st_shndx
== sec_shndx
)
2438 deleting_ret_is_safe
= 0;
2440 printf ("local label prevents deletion of ret "
2441 "insn at address 0x%x\n",
2442 (int) dot
+ insn_size
);
2446 /* Now check for global symbols. */
2449 struct elf_link_hash_entry
**sym_hashes
;
2450 struct elf_link_hash_entry
**end_hashes
;
2452 symcount
= (symtab_hdr
->sh_size
2453 / sizeof (Elf32_External_Sym
)
2454 - symtab_hdr
->sh_info
);
2455 sym_hashes
= elf_sym_hashes (abfd
);
2456 end_hashes
= sym_hashes
+ symcount
;
2457 for (; sym_hashes
< end_hashes
; sym_hashes
++)
2459 struct elf_link_hash_entry
*sym_hash
=
2461 if ((sym_hash
->root
.type
== bfd_link_hash_defined
2462 || sym_hash
->root
.type
==
2463 bfd_link_hash_defweak
)
2464 && sym_hash
->root
.u
.def
.section
== sec
2465 && sym_hash
->root
.u
.def
.value
== section_offset_of_ret_insn
)
2467 deleting_ret_is_safe
= 0;
2469 printf ("global label prevents deletion of "
2470 "ret insn at address 0x%x\n",
2471 (int) dot
+ insn_size
);
2476 /* Now we check for relocations pointing to ret. */
2477 for (isec
= abfd
->sections
; isec
&& deleting_ret_is_safe
; isec
= isec
->next
)
2479 Elf_Internal_Rela
*rel
;
2480 Elf_Internal_Rela
*relend
;
2482 rel
= elf_section_data (isec
)->relocs
;
2484 rel
= _bfd_elf_link_read_relocs (abfd
, isec
, NULL
, NULL
, TRUE
);
2486 relend
= rel
+ isec
->reloc_count
;
2488 for (; rel
&& rel
< relend
; rel
++)
2490 bfd_vma reloc_target
= 0;
2492 /* Read this BFD's local symbols if we haven't
2494 if (isymbuf
== NULL
&& symtab_hdr
->sh_info
!= 0)
2496 isymbuf
= (Elf_Internal_Sym
*)
2497 symtab_hdr
->contents
;
2498 if (isymbuf
== NULL
)
2499 isymbuf
= bfd_elf_get_elf_syms
2502 symtab_hdr
->sh_info
, 0,
2504 if (isymbuf
== NULL
)
2508 /* Get the value of the symbol referred to
2510 if (ELF32_R_SYM (rel
->r_info
)
2511 < symtab_hdr
->sh_info
)
2513 /* A local symbol. */
2517 + ELF32_R_SYM (rel
->r_info
);
2518 sym_sec
= bfd_section_from_elf_index
2519 (abfd
, isym
->st_shndx
);
2520 symval
= isym
->st_value
;
2522 /* If the reloc is absolute, it will not
2523 have a symbol or section associated
2529 sym_sec
->output_section
->vma
2530 + sym_sec
->output_offset
;
2531 reloc_target
= symval
+ rel
->r_addend
;
2535 reloc_target
= symval
+ rel
->r_addend
;
2536 /* Reference symbol is absolute. */
2539 /* else ... reference symbol is extern. */
2541 if (address_of_ret
== reloc_target
)
2543 deleting_ret_is_safe
= 0;
2546 "rjmp/jmp ret sequence at address"
2547 " 0x%x could not be deleted. ret"
2548 " is target of a relocation.\n",
2549 (int) address_of_ret
);
2555 if (deleting_ret_is_safe
)
2558 printf ("unreachable ret instruction "
2559 "at address 0x%x deleted.\n",
2560 (int) dot
+ insn_size
);
2562 /* Delete two bytes of data. */
2563 if (!elf32_avr_relax_delete_bytes (abfd
, sec
,
2564 irel
->r_offset
+ insn_size
, 2))
2567 /* That will change things, so, we should relax
2568 again. Note that this is not required, and it
2581 if (contents
!= NULL
2582 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2584 if (! link_info
->keep_memory
)
2588 /* Cache the section contents for elf_link_input_bfd. */
2589 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2593 if (internal_relocs
!= NULL
2594 && elf_section_data (sec
)->relocs
!= internal_relocs
)
2595 free (internal_relocs
);
2601 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
2603 if (contents
!= NULL
2604 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2606 if (internal_relocs
!= NULL
2607 && elf_section_data (sec
)->relocs
!= internal_relocs
)
2608 free (internal_relocs
);
2613 /* This is a version of bfd_generic_get_relocated_section_contents
2614 which uses elf32_avr_relocate_section.
2616 For avr it's essentially a cut and paste taken from the H8300 port.
2617 The author of the relaxation support patch for avr had absolutely no
2618 clue what is happening here but found out that this part of the code
2619 seems to be important. */
2622 elf32_avr_get_relocated_section_contents (bfd
*output_bfd
,
2623 struct bfd_link_info
*link_info
,
2624 struct bfd_link_order
*link_order
,
2626 bfd_boolean relocatable
,
2629 Elf_Internal_Shdr
*symtab_hdr
;
2630 asection
*input_section
= link_order
->u
.indirect
.section
;
2631 bfd
*input_bfd
= input_section
->owner
;
2632 asection
**sections
= NULL
;
2633 Elf_Internal_Rela
*internal_relocs
= NULL
;
2634 Elf_Internal_Sym
*isymbuf
= NULL
;
2636 /* We only need to handle the case of relaxing, or of having a
2637 particular set of section contents, specially. */
2639 || elf_section_data (input_section
)->this_hdr
.contents
== NULL
)
2640 return bfd_generic_get_relocated_section_contents (output_bfd
, link_info
,
2644 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2646 memcpy (data
, elf_section_data (input_section
)->this_hdr
.contents
,
2647 (size_t) input_section
->size
);
2649 if ((input_section
->flags
& SEC_RELOC
) != 0
2650 && input_section
->reloc_count
> 0)
2653 Elf_Internal_Sym
*isym
, *isymend
;
2656 internal_relocs
= (_bfd_elf_link_read_relocs
2657 (input_bfd
, input_section
, NULL
, NULL
, FALSE
));
2658 if (internal_relocs
== NULL
)
2661 if (symtab_hdr
->sh_info
!= 0)
2663 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
2664 if (isymbuf
== NULL
)
2665 isymbuf
= bfd_elf_get_elf_syms (input_bfd
, symtab_hdr
,
2666 symtab_hdr
->sh_info
, 0,
2668 if (isymbuf
== NULL
)
2672 amt
= symtab_hdr
->sh_info
;
2673 amt
*= sizeof (asection
*);
2674 sections
= bfd_malloc (amt
);
2675 if (sections
== NULL
&& amt
!= 0)
2678 isymend
= isymbuf
+ symtab_hdr
->sh_info
;
2679 for (isym
= isymbuf
, secpp
= sections
; isym
< isymend
; ++isym
, ++secpp
)
2683 if (isym
->st_shndx
== SHN_UNDEF
)
2684 isec
= bfd_und_section_ptr
;
2685 else if (isym
->st_shndx
== SHN_ABS
)
2686 isec
= bfd_abs_section_ptr
;
2687 else if (isym
->st_shndx
== SHN_COMMON
)
2688 isec
= bfd_com_section_ptr
;
2690 isec
= bfd_section_from_elf_index (input_bfd
, isym
->st_shndx
);
2695 if (! elf32_avr_relocate_section (output_bfd
, link_info
, input_bfd
,
2696 input_section
, data
, internal_relocs
,
2700 if (sections
!= NULL
)
2703 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
2705 if (elf_section_data (input_section
)->relocs
!= internal_relocs
)
2706 free (internal_relocs
);
2712 if (sections
!= NULL
)
2715 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
2717 if (internal_relocs
!= NULL
2718 && elf_section_data (input_section
)->relocs
!= internal_relocs
)
2719 free (internal_relocs
);
2724 /* Determines the hash entry name for a particular reloc. It consists of
2725 the identifier of the symbol section and the added reloc addend and
2726 symbol offset relative to the section the symbol is attached to. */
2729 avr_stub_name (const asection
*symbol_section
,
2730 const bfd_vma symbol_offset
,
2731 const Elf_Internal_Rela
*rela
)
2736 len
= 8 + 1 + 8 + 1 + 1;
2737 stub_name
= bfd_malloc (len
);
2739 sprintf (stub_name
, "%08x+%08x",
2740 symbol_section
->id
& 0xffffffff,
2741 (unsigned int) ((rela
->r_addend
& 0xffffffff) + symbol_offset
));
2747 /* Add a new stub entry to the stub hash. Not all fields of the new
2748 stub entry are initialised. */
2750 static struct elf32_avr_stub_hash_entry
*
2751 avr_add_stub (const char *stub_name
,
2752 struct elf32_avr_link_hash_table
*htab
)
2754 struct elf32_avr_stub_hash_entry
*hsh
;
2756 /* Enter this entry into the linker stub hash table. */
2757 hsh
= avr_stub_hash_lookup (&htab
->bstab
, stub_name
, TRUE
, FALSE
);
2761 (*_bfd_error_handler
) (_("%B: cannot create stub entry %s"),
2766 hsh
->stub_offset
= 0;
2770 /* We assume that there is already space allocated for the stub section
2771 contents and that before building the stubs the section size is
2772 initialized to 0. We assume that within the stub hash table entry,
2773 the absolute position of the jmp target has been written in the
2774 target_value field. We write here the offset of the generated jmp insn
2775 relative to the trampoline section start to the stub_offset entry in
2776 the stub hash table entry. */
2779 avr_build_one_stub (struct bfd_hash_entry
*bh
, void *in_arg
)
2781 struct elf32_avr_stub_hash_entry
*hsh
;
2782 struct bfd_link_info
*info
;
2783 struct elf32_avr_link_hash_table
*htab
;
2790 bfd_vma jmp_insn
= 0x0000940c;
2792 /* Massage our args to the form they really have. */
2793 hsh
= avr_stub_hash_entry (bh
);
2795 if (!hsh
->is_actually_needed
)
2798 info
= (struct bfd_link_info
*) in_arg
;
2800 htab
= avr_link_hash_table (info
);
2804 target
= hsh
->target_value
;
2806 /* Make a note of the offset within the stubs for this entry. */
2807 hsh
->stub_offset
= htab
->stub_sec
->size
;
2808 loc
= htab
->stub_sec
->contents
+ hsh
->stub_offset
;
2810 stub_bfd
= htab
->stub_sec
->owner
;
2813 printf ("Building one Stub. Address: 0x%x, Offset: 0x%x\n",
2814 (unsigned int) target
,
2815 (unsigned int) hsh
->stub_offset
);
2817 /* We now have to add the information on the jump target to the bare
2818 opcode bits already set in jmp_insn. */
2820 /* Check for the alignment of the address. */
2824 starget
= target
>> 1;
2825 jmp_insn
|= ((starget
& 0x10000) | ((starget
<< 3) & 0x1f00000)) >> 16;
2826 bfd_put_16 (stub_bfd
, jmp_insn
, loc
);
2827 bfd_put_16 (stub_bfd
, (bfd_vma
) starget
& 0xffff, loc
+ 2);
2829 htab
->stub_sec
->size
+= 4;
2831 /* Now add the entries in the address mapping table if there is still
2836 nr
= htab
->amt_entry_cnt
+ 1;
2837 if (nr
<= htab
->amt_max_entry_cnt
)
2839 htab
->amt_entry_cnt
= nr
;
2841 htab
->amt_stub_offsets
[nr
- 1] = hsh
->stub_offset
;
2842 htab
->amt_destination_addr
[nr
- 1] = target
;
2850 avr_mark_stub_not_to_be_necessary (struct bfd_hash_entry
*bh
,
2851 void *in_arg ATTRIBUTE_UNUSED
)
2853 struct elf32_avr_stub_hash_entry
*hsh
;
2855 hsh
= avr_stub_hash_entry (bh
);
2856 hsh
->is_actually_needed
= FALSE
;
2862 avr_size_one_stub (struct bfd_hash_entry
*bh
, void *in_arg
)
2864 struct elf32_avr_stub_hash_entry
*hsh
;
2865 struct elf32_avr_link_hash_table
*htab
;
2868 /* Massage our args to the form they really have. */
2869 hsh
= avr_stub_hash_entry (bh
);
2872 if (hsh
->is_actually_needed
)
2877 htab
->stub_sec
->size
+= size
;
2882 elf32_avr_setup_params (struct bfd_link_info
*info
,
2884 asection
*avr_stub_section
,
2885 bfd_boolean no_stubs
,
2886 bfd_boolean deb_stubs
,
2887 bfd_boolean deb_relax
,
2888 bfd_vma pc_wrap_around
,
2889 bfd_boolean call_ret_replacement
)
2891 struct elf32_avr_link_hash_table
*htab
= avr_link_hash_table (info
);
2895 htab
->stub_sec
= avr_stub_section
;
2896 htab
->stub_bfd
= avr_stub_bfd
;
2897 htab
->no_stubs
= no_stubs
;
2899 debug_relax
= deb_relax
;
2900 debug_stubs
= deb_stubs
;
2901 avr_pc_wrap_around
= pc_wrap_around
;
2902 avr_replace_call_ret_sequences
= call_ret_replacement
;
2906 /* Set up various things so that we can make a list of input sections
2907 for each output section included in the link. Returns -1 on error,
2908 0 when no stubs will be needed, and 1 on success. It also sets
2909 information on the stubs bfd and the stub section in the info
2913 elf32_avr_setup_section_lists (bfd
*output_bfd
,
2914 struct bfd_link_info
*info
)
2917 unsigned int bfd_count
;
2918 int top_id
, top_index
;
2920 asection
**input_list
, **list
;
2922 struct elf32_avr_link_hash_table
*htab
= avr_link_hash_table (info
);
2924 if (htab
== NULL
|| htab
->no_stubs
)
2927 /* Count the number of input BFDs and find the top input section id. */
2928 for (input_bfd
= info
->input_bfds
, bfd_count
= 0, top_id
= 0;
2930 input_bfd
= input_bfd
->link
.next
)
2933 for (section
= input_bfd
->sections
;
2935 section
= section
->next
)
2936 if (top_id
< section
->id
)
2937 top_id
= section
->id
;
2940 htab
->bfd_count
= bfd_count
;
2942 /* We can't use output_bfd->section_count here to find the top output
2943 section index as some sections may have been removed, and
2944 strip_excluded_output_sections doesn't renumber the indices. */
2945 for (section
= output_bfd
->sections
, top_index
= 0;
2947 section
= section
->next
)
2948 if (top_index
< section
->index
)
2949 top_index
= section
->index
;
2951 htab
->top_index
= top_index
;
2952 amt
= sizeof (asection
*) * (top_index
+ 1);
2953 input_list
= bfd_malloc (amt
);
2954 htab
->input_list
= input_list
;
2955 if (input_list
== NULL
)
2958 /* For sections we aren't interested in, mark their entries with a
2959 value we can check later. */
2960 list
= input_list
+ top_index
;
2962 *list
= bfd_abs_section_ptr
;
2963 while (list
-- != input_list
);
2965 for (section
= output_bfd
->sections
;
2967 section
= section
->next
)
2968 if ((section
->flags
& SEC_CODE
) != 0)
2969 input_list
[section
->index
] = NULL
;
2975 /* Read in all local syms for all input bfds, and create hash entries
2976 for export stubs if we are building a multi-subspace shared lib.
2977 Returns -1 on error, 0 otherwise. */
2980 get_local_syms (bfd
*input_bfd
, struct bfd_link_info
*info
)
2982 unsigned int bfd_indx
;
2983 Elf_Internal_Sym
*local_syms
, **all_local_syms
;
2984 struct elf32_avr_link_hash_table
*htab
= avr_link_hash_table (info
);
2990 /* We want to read in symbol extension records only once. To do this
2991 we need to read in the local symbols in parallel and save them for
2992 later use; so hold pointers to the local symbols in an array. */
2993 amt
= sizeof (Elf_Internal_Sym
*) * htab
->bfd_count
;
2994 all_local_syms
= bfd_zmalloc (amt
);
2995 htab
->all_local_syms
= all_local_syms
;
2996 if (all_local_syms
== NULL
)
2999 /* Walk over all the input BFDs, swapping in local symbols.
3000 If we are creating a shared library, create hash entries for the
3004 input_bfd
= input_bfd
->link
.next
, bfd_indx
++)
3006 Elf_Internal_Shdr
*symtab_hdr
;
3008 /* We'll need the symbol table in a second. */
3009 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
3010 if (symtab_hdr
->sh_info
== 0)
3013 /* We need an array of the local symbols attached to the input bfd. */
3014 local_syms
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
3015 if (local_syms
== NULL
)
3017 local_syms
= bfd_elf_get_elf_syms (input_bfd
, symtab_hdr
,
3018 symtab_hdr
->sh_info
, 0,
3020 /* Cache them for elf_link_input_bfd. */
3021 symtab_hdr
->contents
= (unsigned char *) local_syms
;
3023 if (local_syms
== NULL
)
3026 all_local_syms
[bfd_indx
] = local_syms
;
3032 #define ADD_DUMMY_STUBS_FOR_DEBUGGING 0
3035 elf32_avr_size_stubs (bfd
*output_bfd
,
3036 struct bfd_link_info
*info
,
3037 bfd_boolean is_prealloc_run
)
3039 struct elf32_avr_link_hash_table
*htab
;
3040 int stub_changed
= 0;
3042 htab
= avr_link_hash_table (info
);
3046 /* At this point we initialize htab->vector_base
3047 To the start of the text output section. */
3048 htab
->vector_base
= htab
->stub_sec
->output_section
->vma
;
3050 if (get_local_syms (info
->input_bfds
, info
))
3052 if (htab
->all_local_syms
)
3053 goto error_ret_free_local
;
3057 if (ADD_DUMMY_STUBS_FOR_DEBUGGING
)
3059 struct elf32_avr_stub_hash_entry
*test
;
3061 test
= avr_add_stub ("Hugo",htab
);
3062 test
->target_value
= 0x123456;
3063 test
->stub_offset
= 13;
3065 test
= avr_add_stub ("Hugo2",htab
);
3066 test
->target_value
= 0x84210;
3067 test
->stub_offset
= 14;
3073 unsigned int bfd_indx
;
3075 /* We will have to re-generate the stub hash table each time anything
3076 in memory has changed. */
3078 bfd_hash_traverse (&htab
->bstab
, avr_mark_stub_not_to_be_necessary
, htab
);
3079 for (input_bfd
= info
->input_bfds
, bfd_indx
= 0;
3081 input_bfd
= input_bfd
->link
.next
, bfd_indx
++)
3083 Elf_Internal_Shdr
*symtab_hdr
;
3085 Elf_Internal_Sym
*local_syms
;
3087 /* We'll need the symbol table in a second. */
3088 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
3089 if (symtab_hdr
->sh_info
== 0)
3092 local_syms
= htab
->all_local_syms
[bfd_indx
];
3094 /* Walk over each section attached to the input bfd. */
3095 for (section
= input_bfd
->sections
;
3097 section
= section
->next
)
3099 Elf_Internal_Rela
*internal_relocs
, *irelaend
, *irela
;
3101 /* If there aren't any relocs, then there's nothing more
3103 if ((section
->flags
& SEC_RELOC
) == 0
3104 || section
->reloc_count
== 0)
3107 /* If this section is a link-once section that will be
3108 discarded, then don't create any stubs. */
3109 if (section
->output_section
== NULL
3110 || section
->output_section
->owner
!= output_bfd
)
3113 /* Get the relocs. */
3115 = _bfd_elf_link_read_relocs (input_bfd
, section
, NULL
, NULL
,
3117 if (internal_relocs
== NULL
)
3118 goto error_ret_free_local
;
3120 /* Now examine each relocation. */
3121 irela
= internal_relocs
;
3122 irelaend
= irela
+ section
->reloc_count
;
3123 for (; irela
< irelaend
; irela
++)
3125 unsigned int r_type
, r_indx
;
3126 struct elf32_avr_stub_hash_entry
*hsh
;
3129 bfd_vma destination
;
3130 struct elf_link_hash_entry
*hh
;
3133 r_type
= ELF32_R_TYPE (irela
->r_info
);
3134 r_indx
= ELF32_R_SYM (irela
->r_info
);
3136 /* Only look for 16 bit GS relocs. No other reloc will need a
3138 if (!((r_type
== R_AVR_16_PM
)
3139 || (r_type
== R_AVR_LO8_LDI_GS
)
3140 || (r_type
== R_AVR_HI8_LDI_GS
)))
3143 /* Now determine the call target, its name, value,
3149 if (r_indx
< symtab_hdr
->sh_info
)
3151 /* It's a local symbol. */
3152 Elf_Internal_Sym
*sym
;
3153 Elf_Internal_Shdr
*hdr
;
3156 sym
= local_syms
+ r_indx
;
3157 if (ELF_ST_TYPE (sym
->st_info
) != STT_SECTION
)
3158 sym_value
= sym
->st_value
;
3159 shndx
= sym
->st_shndx
;
3160 if (shndx
< elf_numsections (input_bfd
))
3162 hdr
= elf_elfsections (input_bfd
)[shndx
];
3163 sym_sec
= hdr
->bfd_section
;
3164 destination
= (sym_value
+ irela
->r_addend
3165 + sym_sec
->output_offset
3166 + sym_sec
->output_section
->vma
);
3171 /* It's an external symbol. */
3174 e_indx
= r_indx
- symtab_hdr
->sh_info
;
3175 hh
= elf_sym_hashes (input_bfd
)[e_indx
];
3177 while (hh
->root
.type
== bfd_link_hash_indirect
3178 || hh
->root
.type
== bfd_link_hash_warning
)
3179 hh
= (struct elf_link_hash_entry
*)
3180 (hh
->root
.u
.i
.link
);
3182 if (hh
->root
.type
== bfd_link_hash_defined
3183 || hh
->root
.type
== bfd_link_hash_defweak
)
3185 sym_sec
= hh
->root
.u
.def
.section
;
3186 sym_value
= hh
->root
.u
.def
.value
;
3187 if (sym_sec
->output_section
!= NULL
)
3188 destination
= (sym_value
+ irela
->r_addend
3189 + sym_sec
->output_offset
3190 + sym_sec
->output_section
->vma
);
3192 else if (hh
->root
.type
== bfd_link_hash_undefweak
)
3197 else if (hh
->root
.type
== bfd_link_hash_undefined
)
3199 if (! (info
->unresolved_syms_in_objects
== RM_IGNORE
3200 && (ELF_ST_VISIBILITY (hh
->other
)
3206 bfd_set_error (bfd_error_bad_value
);
3208 error_ret_free_internal
:
3209 if (elf_section_data (section
)->relocs
== NULL
)
3210 free (internal_relocs
);
3211 goto error_ret_free_local
;
3215 if (! avr_stub_is_required_for_16_bit_reloc
3216 (destination
- htab
->vector_base
))
3218 if (!is_prealloc_run
)
3219 /* We are having a reloc that does't need a stub. */
3222 /* We don't right now know if a stub will be needed.
3223 Let's rather be on the safe side. */
3226 /* Get the name of this stub. */
3227 stub_name
= avr_stub_name (sym_sec
, sym_value
, irela
);
3230 goto error_ret_free_internal
;
3233 hsh
= avr_stub_hash_lookup (&htab
->bstab
,
3238 /* The proper stub has already been created. Mark it
3239 to be used and write the possibly changed destination
3241 hsh
->is_actually_needed
= TRUE
;
3242 hsh
->target_value
= destination
;
3247 hsh
= avr_add_stub (stub_name
, htab
);
3251 goto error_ret_free_internal
;
3254 hsh
->is_actually_needed
= TRUE
;
3255 hsh
->target_value
= destination
;
3258 printf ("Adding stub with destination 0x%x to the"
3259 " hash table.\n", (unsigned int) destination
);
3261 printf ("(Pre-Alloc run: %i)\n", is_prealloc_run
);
3263 stub_changed
= TRUE
;
3266 /* We're done with the internal relocs, free them. */
3267 if (elf_section_data (section
)->relocs
== NULL
)
3268 free (internal_relocs
);
3272 /* Re-Calculate the number of needed stubs. */
3273 htab
->stub_sec
->size
= 0;
3274 bfd_hash_traverse (&htab
->bstab
, avr_size_one_stub
, htab
);
3279 stub_changed
= FALSE
;
3282 free (htab
->all_local_syms
);
3285 error_ret_free_local
:
3286 free (htab
->all_local_syms
);
3291 /* Build all the stubs associated with the current output file. The
3292 stubs are kept in a hash table attached to the main linker hash
3293 table. We also set up the .plt entries for statically linked PIC
3294 functions here. This function is called via hppaelf_finish in the
3298 elf32_avr_build_stubs (struct bfd_link_info
*info
)
3301 struct bfd_hash_table
*table
;
3302 struct elf32_avr_link_hash_table
*htab
;
3303 bfd_size_type total_size
= 0;
3305 htab
= avr_link_hash_table (info
);
3309 /* In case that there were several stub sections: */
3310 for (stub_sec
= htab
->stub_bfd
->sections
;
3312 stub_sec
= stub_sec
->next
)
3316 /* Allocate memory to hold the linker stubs. */
3317 size
= stub_sec
->size
;
3320 stub_sec
->contents
= bfd_zalloc (htab
->stub_bfd
, size
);
3321 if (stub_sec
->contents
== NULL
&& size
!= 0)
3326 /* Allocate memory for the adress mapping table. */
3327 htab
->amt_entry_cnt
= 0;
3328 htab
->amt_max_entry_cnt
= total_size
/ 4;
3329 htab
->amt_stub_offsets
= bfd_malloc (sizeof (bfd_vma
)
3330 * htab
->amt_max_entry_cnt
);
3331 htab
->amt_destination_addr
= bfd_malloc (sizeof (bfd_vma
)
3332 * htab
->amt_max_entry_cnt
);
3335 printf ("Allocating %i entries in the AMT\n", htab
->amt_max_entry_cnt
);
3337 /* Build the stubs as directed by the stub hash table. */
3338 table
= &htab
->bstab
;
3339 bfd_hash_traverse (table
, avr_build_one_stub
, info
);
3342 printf ("Final Stub section Size: %i\n", (int) htab
->stub_sec
->size
);
3347 #define ELF_ARCH bfd_arch_avr
3348 #define ELF_TARGET_ID AVR_ELF_DATA
3349 #define ELF_MACHINE_CODE EM_AVR
3350 #define ELF_MACHINE_ALT1 EM_AVR_OLD
3351 #define ELF_MAXPAGESIZE 1
3353 #define TARGET_LITTLE_SYM avr_elf32_vec
3354 #define TARGET_LITTLE_NAME "elf32-avr"
3356 #define bfd_elf32_bfd_link_hash_table_create elf32_avr_link_hash_table_create
3358 #define elf_info_to_howto avr_info_to_howto_rela
3359 #define elf_info_to_howto_rel NULL
3360 #define elf_backend_relocate_section elf32_avr_relocate_section
3361 #define elf_backend_can_gc_sections 1
3362 #define elf_backend_rela_normal 1
3363 #define elf_backend_final_write_processing \
3364 bfd_elf_avr_final_write_processing
3365 #define elf_backend_object_p elf32_avr_object_p
3367 #define bfd_elf32_bfd_relax_section elf32_avr_relax_section
3368 #define bfd_elf32_bfd_get_relocated_section_contents \
3369 elf32_avr_get_relocated_section_contents
3371 #include "elf32-target.h"