1 /* AVR-specific support for 32-bit ELF
2 Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2006, 2007, 2008
3 Free Software Foundation, Inc.
4 Contributed by Denis Chertykov <denisc@overta.ru>
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor,
21 Boston, MA 02110-1301, USA. */
28 #include "elf32-avr.h"
30 /* Enable debugging printout at stdout with this variable. */
31 static bfd_boolean debug_relax = FALSE;
33 /* Enable debugging printout at stdout with this variable. */
34 static bfd_boolean debug_stubs = FALSE;
36 /* Hash table initialization and handling. Code is taken from the hppa port
37 and adapted to the needs of AVR. */
39 /* We use two hash tables to hold information for linking avr objects.
41 The first is the elf32_avr_link_hash_tablse which is derived from the
42 stanard ELF linker hash table. We use this as a place to attach the other
43 hash table and some static information.
45 The second is the stub hash table which is derived from the base BFD
46 hash table. The stub hash table holds the information on the linker
49 struct elf32_avr_stub_hash_entry
51 /* Base hash table entry structure. */
52 struct bfd_hash_entry bh_root;
54 /* Offset within stub_sec of the beginning of this stub. */
57 /* Given the symbol's value and its section we can determine its final
58 value when building the stubs (so the stub knows where to jump). */
61 /* This way we could mark stubs to be no longer necessary. */
62 bfd_boolean is_actually_needed;
65 struct elf32_avr_link_hash_table
67 /* The main hash table. */
68 struct elf_link_hash_table etab;
70 /* The stub hash table. */
71 struct bfd_hash_table bstab;
75 /* Linker stub bfd. */
78 /* The stub section. */
81 /* Usually 0, unless we are generating code for a bootloader. Will
82 be initialized by elf32_avr_size_stubs to the vma offset of the
83 output section associated with the stub section. */
86 /* Assorted information used by elf32_avr_size_stubs. */
87 unsigned int bfd_count;
89 asection ** input_list;
90 Elf_Internal_Sym ** all_local_syms;
92 /* Tables for mapping vma beyond the 128k boundary to the address of the
93 corresponding stub. (AMT)
94 "amt_max_entry_cnt" reflects the number of entries that memory is allocated
95 for in the "amt_stub_offsets" and "amt_destination_addr" arrays.
96 "amt_entry_cnt" informs how many of these entries actually contain
98 unsigned int amt_entry_cnt;
99 unsigned int amt_max_entry_cnt;
100 bfd_vma * amt_stub_offsets;
101 bfd_vma * amt_destination_addr;
104 /* Various hash macros and functions. */
105 #define avr_link_hash_table(p) \
106 /* PR 3874: Check that we have an AVR style hash table before using it. */\
107 ((p)->hash->table.newfunc != elf32_avr_link_hash_newfunc ? NULL : \
108 ((struct elf32_avr_link_hash_table *) ((p)->hash)))
110 #define avr_stub_hash_entry(ent) \
111 ((struct elf32_avr_stub_hash_entry *)(ent))
113 #define avr_stub_hash_lookup(table, string, create, copy) \
114 ((struct elf32_avr_stub_hash_entry *) \
115 bfd_hash_lookup ((table), (string), (create), (copy)))
117 static reloc_howto_type elf_avr_howto_table[] =
119 HOWTO (R_AVR_NONE, /* type */
121 2, /* size (0 = byte, 1 = short, 2 = long) */
123 FALSE, /* pc_relative */
125 complain_overflow_bitfield, /* complain_on_overflow */
126 bfd_elf_generic_reloc, /* special_function */
127 "R_AVR_NONE", /* name */
128 FALSE, /* partial_inplace */
131 FALSE), /* pcrel_offset */
133 HOWTO (R_AVR_32, /* type */
135 2, /* size (0 = byte, 1 = short, 2 = long) */
137 FALSE, /* pc_relative */
139 complain_overflow_bitfield, /* complain_on_overflow */
140 bfd_elf_generic_reloc, /* special_function */
141 "R_AVR_32", /* name */
142 FALSE, /* partial_inplace */
143 0xffffffff, /* src_mask */
144 0xffffffff, /* dst_mask */
145 FALSE), /* pcrel_offset */
147 /* A 7 bit PC relative relocation. */
148 HOWTO (R_AVR_7_PCREL, /* type */
150 1, /* size (0 = byte, 1 = short, 2 = long) */
152 TRUE, /* pc_relative */
154 complain_overflow_bitfield, /* complain_on_overflow */
155 bfd_elf_generic_reloc, /* special_function */
156 "R_AVR_7_PCREL", /* name */
157 FALSE, /* partial_inplace */
158 0xffff, /* src_mask */
159 0xffff, /* dst_mask */
160 TRUE), /* pcrel_offset */
162 /* A 13 bit PC relative relocation. */
163 HOWTO (R_AVR_13_PCREL, /* type */
165 1, /* size (0 = byte, 1 = short, 2 = long) */
167 TRUE, /* pc_relative */
169 complain_overflow_bitfield, /* complain_on_overflow */
170 bfd_elf_generic_reloc, /* special_function */
171 "R_AVR_13_PCREL", /* name */
172 FALSE, /* partial_inplace */
173 0xfff, /* src_mask */
174 0xfff, /* dst_mask */
175 TRUE), /* pcrel_offset */
177 /* A 16 bit absolute relocation. */
178 HOWTO (R_AVR_16, /* type */
180 1, /* size (0 = byte, 1 = short, 2 = long) */
182 FALSE, /* pc_relative */
184 complain_overflow_dont, /* complain_on_overflow */
185 bfd_elf_generic_reloc, /* special_function */
186 "R_AVR_16", /* name */
187 FALSE, /* partial_inplace */
188 0xffff, /* src_mask */
189 0xffff, /* dst_mask */
190 FALSE), /* pcrel_offset */
192 /* A 16 bit absolute relocation for command address
193 Will be changed when linker stubs are needed. */
194 HOWTO (R_AVR_16_PM, /* type */
196 1, /* size (0 = byte, 1 = short, 2 = long) */
198 FALSE, /* pc_relative */
200 complain_overflow_bitfield, /* complain_on_overflow */
201 bfd_elf_generic_reloc, /* special_function */
202 "R_AVR_16_PM", /* name */
203 FALSE, /* partial_inplace */
204 0xffff, /* src_mask */
205 0xffff, /* dst_mask */
206 FALSE), /* pcrel_offset */
207 /* A low 8 bit absolute relocation of 16 bit address.
209 HOWTO (R_AVR_LO8_LDI, /* type */
211 1, /* size (0 = byte, 1 = short, 2 = long) */
213 FALSE, /* pc_relative */
215 complain_overflow_dont, /* complain_on_overflow */
216 bfd_elf_generic_reloc, /* special_function */
217 "R_AVR_LO8_LDI", /* name */
218 FALSE, /* partial_inplace */
219 0xffff, /* src_mask */
220 0xffff, /* dst_mask */
221 FALSE), /* pcrel_offset */
222 /* A high 8 bit absolute relocation of 16 bit address.
224 HOWTO (R_AVR_HI8_LDI, /* type */
226 1, /* size (0 = byte, 1 = short, 2 = long) */
228 FALSE, /* pc_relative */
230 complain_overflow_dont, /* complain_on_overflow */
231 bfd_elf_generic_reloc, /* special_function */
232 "R_AVR_HI8_LDI", /* name */
233 FALSE, /* partial_inplace */
234 0xffff, /* src_mask */
235 0xffff, /* dst_mask */
236 FALSE), /* pcrel_offset */
237 /* A high 6 bit absolute relocation of 22 bit address.
238 For LDI command. As well second most significant 8 bit value of
239 a 32 bit link-time constant. */
240 HOWTO (R_AVR_HH8_LDI, /* type */
242 1, /* size (0 = byte, 1 = short, 2 = long) */
244 FALSE, /* pc_relative */
246 complain_overflow_dont, /* complain_on_overflow */
247 bfd_elf_generic_reloc, /* special_function */
248 "R_AVR_HH8_LDI", /* name */
249 FALSE, /* partial_inplace */
250 0xffff, /* src_mask */
251 0xffff, /* dst_mask */
252 FALSE), /* pcrel_offset */
253 /* A negative low 8 bit absolute relocation of 16 bit address.
255 HOWTO (R_AVR_LO8_LDI_NEG, /* type */
257 1, /* size (0 = byte, 1 = short, 2 = long) */
259 FALSE, /* pc_relative */
261 complain_overflow_dont, /* complain_on_overflow */
262 bfd_elf_generic_reloc, /* special_function */
263 "R_AVR_LO8_LDI_NEG", /* name */
264 FALSE, /* partial_inplace */
265 0xffff, /* src_mask */
266 0xffff, /* dst_mask */
267 FALSE), /* pcrel_offset */
268 /* A negative high 8 bit absolute relocation of 16 bit address.
270 HOWTO (R_AVR_HI8_LDI_NEG, /* type */
272 1, /* size (0 = byte, 1 = short, 2 = long) */
274 FALSE, /* pc_relative */
276 complain_overflow_dont, /* complain_on_overflow */
277 bfd_elf_generic_reloc, /* special_function */
278 "R_AVR_HI8_LDI_NEG", /* name */
279 FALSE, /* partial_inplace */
280 0xffff, /* src_mask */
281 0xffff, /* dst_mask */
282 FALSE), /* pcrel_offset */
283 /* A negative high 6 bit absolute relocation of 22 bit address.
285 HOWTO (R_AVR_HH8_LDI_NEG, /* type */
287 1, /* size (0 = byte, 1 = short, 2 = long) */
289 FALSE, /* pc_relative */
291 complain_overflow_dont, /* complain_on_overflow */
292 bfd_elf_generic_reloc, /* special_function */
293 "R_AVR_HH8_LDI_NEG", /* name */
294 FALSE, /* partial_inplace */
295 0xffff, /* src_mask */
296 0xffff, /* dst_mask */
297 FALSE), /* pcrel_offset */
298 /* A low 8 bit absolute relocation of 24 bit program memory address.
299 For LDI command. Will not be changed when linker stubs are needed. */
300 HOWTO (R_AVR_LO8_LDI_PM, /* type */
302 1, /* size (0 = byte, 1 = short, 2 = long) */
304 FALSE, /* pc_relative */
306 complain_overflow_dont, /* complain_on_overflow */
307 bfd_elf_generic_reloc, /* special_function */
308 "R_AVR_LO8_LDI_PM", /* name */
309 FALSE, /* partial_inplace */
310 0xffff, /* src_mask */
311 0xffff, /* dst_mask */
312 FALSE), /* pcrel_offset */
313 /* A low 8 bit absolute relocation of 24 bit program memory address.
314 For LDI command. Will not be changed when linker stubs are needed. */
315 HOWTO (R_AVR_HI8_LDI_PM, /* type */
317 1, /* size (0 = byte, 1 = short, 2 = long) */
319 FALSE, /* pc_relative */
321 complain_overflow_dont, /* complain_on_overflow */
322 bfd_elf_generic_reloc, /* special_function */
323 "R_AVR_HI8_LDI_PM", /* name */
324 FALSE, /* partial_inplace */
325 0xffff, /* src_mask */
326 0xffff, /* dst_mask */
327 FALSE), /* pcrel_offset */
328 /* A low 8 bit absolute relocation of 24 bit program memory address.
329 For LDI command. Will not be changed when linker stubs are needed. */
330 HOWTO (R_AVR_HH8_LDI_PM, /* type */
332 1, /* size (0 = byte, 1 = short, 2 = long) */
334 FALSE, /* pc_relative */
336 complain_overflow_dont, /* complain_on_overflow */
337 bfd_elf_generic_reloc, /* special_function */
338 "R_AVR_HH8_LDI_PM", /* name */
339 FALSE, /* partial_inplace */
340 0xffff, /* src_mask */
341 0xffff, /* dst_mask */
342 FALSE), /* pcrel_offset */
343 /* A low 8 bit absolute relocation of 24 bit program memory address.
344 For LDI command. Will not be changed when linker stubs are needed. */
345 HOWTO (R_AVR_LO8_LDI_PM_NEG, /* type */
347 1, /* size (0 = byte, 1 = short, 2 = long) */
349 FALSE, /* pc_relative */
351 complain_overflow_dont, /* complain_on_overflow */
352 bfd_elf_generic_reloc, /* special_function */
353 "R_AVR_LO8_LDI_PM_NEG", /* name */
354 FALSE, /* partial_inplace */
355 0xffff, /* src_mask */
356 0xffff, /* dst_mask */
357 FALSE), /* pcrel_offset */
358 /* A low 8 bit absolute relocation of 24 bit program memory address.
359 For LDI command. Will not be changed when linker stubs are needed. */
360 HOWTO (R_AVR_HI8_LDI_PM_NEG, /* type */
362 1, /* size (0 = byte, 1 = short, 2 = long) */
364 FALSE, /* pc_relative */
366 complain_overflow_dont, /* complain_on_overflow */
367 bfd_elf_generic_reloc, /* special_function */
368 "R_AVR_HI8_LDI_PM_NEG", /* name */
369 FALSE, /* partial_inplace */
370 0xffff, /* src_mask */
371 0xffff, /* dst_mask */
372 FALSE), /* pcrel_offset */
373 /* A low 8 bit absolute relocation of 24 bit program memory address.
374 For LDI command. Will not be changed when linker stubs are needed. */
375 HOWTO (R_AVR_HH8_LDI_PM_NEG, /* type */
377 1, /* size (0 = byte, 1 = short, 2 = long) */
379 FALSE, /* pc_relative */
381 complain_overflow_dont, /* complain_on_overflow */
382 bfd_elf_generic_reloc, /* special_function */
383 "R_AVR_HH8_LDI_PM_NEG", /* name */
384 FALSE, /* partial_inplace */
385 0xffff, /* src_mask */
386 0xffff, /* dst_mask */
387 FALSE), /* pcrel_offset */
388 /* Relocation for CALL command in ATmega. */
389 HOWTO (R_AVR_CALL, /* type */
391 2, /* size (0 = byte, 1 = short, 2 = long) */
393 FALSE, /* pc_relative */
395 complain_overflow_dont,/* complain_on_overflow */
396 bfd_elf_generic_reloc, /* special_function */
397 "R_AVR_CALL", /* name */
398 FALSE, /* partial_inplace */
399 0xffffffff, /* src_mask */
400 0xffffffff, /* dst_mask */
401 FALSE), /* pcrel_offset */
402 /* A 16 bit absolute relocation of 16 bit address.
404 HOWTO (R_AVR_LDI, /* type */
406 1, /* size (0 = byte, 1 = short, 2 = long) */
408 FALSE, /* pc_relative */
410 complain_overflow_dont,/* complain_on_overflow */
411 bfd_elf_generic_reloc, /* special_function */
412 "R_AVR_LDI", /* name */
413 FALSE, /* partial_inplace */
414 0xffff, /* src_mask */
415 0xffff, /* dst_mask */
416 FALSE), /* pcrel_offset */
417 /* A 6 bit absolute relocation of 6 bit offset.
418 For ldd/sdd command. */
419 HOWTO (R_AVR_6, /* type */
421 0, /* size (0 = byte, 1 = short, 2 = long) */
423 FALSE, /* pc_relative */
425 complain_overflow_dont,/* complain_on_overflow */
426 bfd_elf_generic_reloc, /* special_function */
427 "R_AVR_6", /* name */
428 FALSE, /* partial_inplace */
429 0xffff, /* src_mask */
430 0xffff, /* dst_mask */
431 FALSE), /* pcrel_offset */
432 /* A 6 bit absolute relocation of 6 bit offset.
433 For sbiw/adiw command. */
434 HOWTO (R_AVR_6_ADIW, /* type */
436 0, /* size (0 = byte, 1 = short, 2 = long) */
438 FALSE, /* pc_relative */
440 complain_overflow_dont,/* complain_on_overflow */
441 bfd_elf_generic_reloc, /* special_function */
442 "R_AVR_6_ADIW", /* name */
443 FALSE, /* partial_inplace */
444 0xffff, /* src_mask */
445 0xffff, /* dst_mask */
446 FALSE), /* pcrel_offset */
447 /* Most significant 8 bit value of a 32 bit link-time constant. */
448 HOWTO (R_AVR_MS8_LDI, /* type */
450 1, /* size (0 = byte, 1 = short, 2 = long) */
452 FALSE, /* pc_relative */
454 complain_overflow_dont, /* complain_on_overflow */
455 bfd_elf_generic_reloc, /* special_function */
456 "R_AVR_MS8_LDI", /* name */
457 FALSE, /* partial_inplace */
458 0xffff, /* src_mask */
459 0xffff, /* dst_mask */
460 FALSE), /* pcrel_offset */
461 /* Negative most significant 8 bit value of a 32 bit link-time constant. */
462 HOWTO (R_AVR_MS8_LDI_NEG, /* type */
464 1, /* size (0 = byte, 1 = short, 2 = long) */
466 FALSE, /* pc_relative */
468 complain_overflow_dont, /* complain_on_overflow */
469 bfd_elf_generic_reloc, /* special_function */
470 "R_AVR_MS8_LDI_NEG", /* name */
471 FALSE, /* partial_inplace */
472 0xffff, /* src_mask */
473 0xffff, /* dst_mask */
474 FALSE), /* pcrel_offset */
475 /* A low 8 bit absolute relocation of 24 bit program memory address.
476 For LDI command. Will be changed when linker stubs are needed. */
477 HOWTO (R_AVR_LO8_LDI_GS, /* type */
479 1, /* size (0 = byte, 1 = short, 2 = long) */
481 FALSE, /* pc_relative */
483 complain_overflow_dont, /* complain_on_overflow */
484 bfd_elf_generic_reloc, /* special_function */
485 "R_AVR_LO8_LDI_GS", /* name */
486 FALSE, /* partial_inplace */
487 0xffff, /* src_mask */
488 0xffff, /* dst_mask */
489 FALSE), /* pcrel_offset */
490 /* A low 8 bit absolute relocation of 24 bit program memory address.
491 For LDI command. Will be changed when linker stubs are needed. */
492 HOWTO (R_AVR_HI8_LDI_GS, /* type */
494 1, /* size (0 = byte, 1 = short, 2 = long) */
496 FALSE, /* pc_relative */
498 complain_overflow_dont, /* complain_on_overflow */
499 bfd_elf_generic_reloc, /* special_function */
500 "R_AVR_HI8_LDI_GS", /* name */
501 FALSE, /* partial_inplace */
502 0xffff, /* src_mask */
503 0xffff, /* dst_mask */
504 FALSE) /* pcrel_offset */
507 /* Map BFD reloc types to AVR ELF reloc types. */
511 bfd_reloc_code_real_type bfd_reloc_val;
512 unsigned int elf_reloc_val;
515 static const struct avr_reloc_map avr_reloc_map[] =
517 { BFD_RELOC_NONE, R_AVR_NONE },
518 { BFD_RELOC_32, R_AVR_32 },
519 { BFD_RELOC_AVR_7_PCREL, R_AVR_7_PCREL },
520 { BFD_RELOC_AVR_13_PCREL, R_AVR_13_PCREL },
521 { BFD_RELOC_16, R_AVR_16 },
522 { BFD_RELOC_AVR_16_PM, R_AVR_16_PM },
523 { BFD_RELOC_AVR_LO8_LDI, R_AVR_LO8_LDI},
524 { BFD_RELOC_AVR_HI8_LDI, R_AVR_HI8_LDI },
525 { BFD_RELOC_AVR_HH8_LDI, R_AVR_HH8_LDI },
526 { BFD_RELOC_AVR_MS8_LDI, R_AVR_MS8_LDI },
527 { BFD_RELOC_AVR_LO8_LDI_NEG, R_AVR_LO8_LDI_NEG },
528 { BFD_RELOC_AVR_HI8_LDI_NEG, R_AVR_HI8_LDI_NEG },
529 { BFD_RELOC_AVR_HH8_LDI_NEG, R_AVR_HH8_LDI_NEG },
530 { BFD_RELOC_AVR_MS8_LDI_NEG, R_AVR_MS8_LDI_NEG },
531 { BFD_RELOC_AVR_LO8_LDI_PM, R_AVR_LO8_LDI_PM },
532 { BFD_RELOC_AVR_LO8_LDI_GS, R_AVR_LO8_LDI_GS },
533 { BFD_RELOC_AVR_HI8_LDI_PM, R_AVR_HI8_LDI_PM },
534 { BFD_RELOC_AVR_HI8_LDI_GS, R_AVR_HI8_LDI_GS },
535 { BFD_RELOC_AVR_HH8_LDI_PM, R_AVR_HH8_LDI_PM },
536 { BFD_RELOC_AVR_LO8_LDI_PM_NEG, R_AVR_LO8_LDI_PM_NEG },
537 { BFD_RELOC_AVR_HI8_LDI_PM_NEG, R_AVR_HI8_LDI_PM_NEG },
538 { BFD_RELOC_AVR_HH8_LDI_PM_NEG, R_AVR_HH8_LDI_PM_NEG },
539 { BFD_RELOC_AVR_CALL, R_AVR_CALL },
540 { BFD_RELOC_AVR_LDI, R_AVR_LDI },
541 { BFD_RELOC_AVR_6, R_AVR_6 },
542 { BFD_RELOC_AVR_6_ADIW, R_AVR_6_ADIW }
545 /* Meant to be filled one day with the wrap around address for the
546 specific device. I.e. should get the value 0x4000 for 16k devices,
547 0x8000 for 32k devices and so on.
549 We initialize it here with a value of 0x1000000 resulting in
550 that we will never suggest a wrap-around jump during relaxation.
551 The logic of the source code later on assumes that in
552 avr_pc_wrap_around one single bit is set. */
553 static bfd_vma avr_pc_wrap_around = 0x10000000;
555 /* If this variable holds a value different from zero, the linker relaxation
556 machine will try to optimize call/ret sequences by a single jump
557 instruction. This option could be switched off by a linker switch. */
558 static int avr_replace_call_ret_sequences = 1;
560 /* Initialize an entry in the stub hash table. */
562 static struct bfd_hash_entry *
563 stub_hash_newfunc (struct bfd_hash_entry *entry,
564 struct bfd_hash_table *table,
567 /* Allocate the structure if it has not already been allocated by a
571 entry = bfd_hash_allocate (table,
572 sizeof (struct elf32_avr_stub_hash_entry));
577 /* Call the allocation method of the superclass. */
578 entry = bfd_hash_newfunc (entry, table, string);
581 struct elf32_avr_stub_hash_entry *hsh;
583 /* Initialize the local fields. */
584 hsh = avr_stub_hash_entry (entry);
585 hsh->stub_offset = 0;
586 hsh->target_value = 0;
592 /* This function is just a straight passthrough to the real
593 function in linker.c. Its prupose is so that its address
594 can be compared inside the avr_link_hash_table macro. */
596 static struct bfd_hash_entry *
597 elf32_avr_link_hash_newfunc (struct bfd_hash_entry * entry,
598 struct bfd_hash_table * table,
601 return _bfd_elf_link_hash_newfunc (entry, table, string);
604 /* Create the derived linker hash table. The AVR ELF port uses the derived
605 hash table to keep information specific to the AVR ELF linker (without
606 using static variables). */
608 static struct bfd_link_hash_table *
609 elf32_avr_link_hash_table_create (bfd *abfd)
611 struct elf32_avr_link_hash_table *htab;
612 bfd_size_type amt = sizeof (*htab);
614 htab = bfd_malloc (amt);
618 if (!_bfd_elf_link_hash_table_init (&htab->etab, abfd,
619 elf32_avr_link_hash_newfunc,
620 sizeof (struct elf_link_hash_entry)))
626 /* Init the stub hash table too. */
627 if (!bfd_hash_table_init (&htab->bstab, stub_hash_newfunc,
628 sizeof (struct elf32_avr_stub_hash_entry)))
631 htab->stub_bfd = NULL;
632 htab->stub_sec = NULL;
634 /* Initialize the address mapping table. */
635 htab->amt_stub_offsets = NULL;
636 htab->amt_destination_addr = NULL;
637 htab->amt_entry_cnt = 0;
638 htab->amt_max_entry_cnt = 0;
640 return &htab->etab.root;
643 /* Free the derived linker hash table. */
646 elf32_avr_link_hash_table_free (struct bfd_link_hash_table *btab)
648 struct elf32_avr_link_hash_table *htab
649 = (struct elf32_avr_link_hash_table *) btab;
651 /* Free the address mapping table. */
652 if (htab->amt_stub_offsets != NULL)
653 free (htab->amt_stub_offsets);
654 if (htab->amt_destination_addr != NULL)
655 free (htab->amt_destination_addr);
657 bfd_hash_table_free (&htab->bstab);
658 _bfd_generic_link_hash_table_free (btab);
661 /* Calculates the effective distance of a pc relative jump/call. */
664 avr_relative_distance_considering_wrap_around (unsigned int distance)
666 unsigned int wrap_around_mask = avr_pc_wrap_around - 1;
667 int dist_with_wrap_around = distance & wrap_around_mask;
669 if (dist_with_wrap_around > ((int) (avr_pc_wrap_around >> 1)))
670 dist_with_wrap_around -= avr_pc_wrap_around;
672 return dist_with_wrap_around;
676 static reloc_howto_type *
677 bfd_elf32_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
678 bfd_reloc_code_real_type code)
683 i < sizeof (avr_reloc_map) / sizeof (struct avr_reloc_map);
685 if (avr_reloc_map[i].bfd_reloc_val == code)
686 return &elf_avr_howto_table[avr_reloc_map[i].elf_reloc_val];
691 static reloc_howto_type *
692 bfd_elf32_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
698 i < sizeof (elf_avr_howto_table) / sizeof (elf_avr_howto_table[0]);
700 if (elf_avr_howto_table[i].name != NULL
701 && strcasecmp (elf_avr_howto_table[i].name, r_name) == 0)
702 return &elf_avr_howto_table[i];
707 /* Set the howto pointer for an AVR ELF reloc. */
710 avr_info_to_howto_rela (bfd *abfd ATTRIBUTE_UNUSED,
712 Elf_Internal_Rela *dst)
716 r_type = ELF32_R_TYPE (dst->r_info);
717 BFD_ASSERT (r_type < (unsigned int) R_AVR_max);
718 cache_ptr->howto = &elf_avr_howto_table[r_type];
721 /* Look through the relocs for a section during the first phase.
722 Since we don't do .gots or .plts, we just need to consider the
723 virtual table relocs for gc. */
726 elf32_avr_check_relocs (bfd *abfd,
727 struct bfd_link_info *info,
729 const Elf_Internal_Rela *relocs)
731 Elf_Internal_Shdr *symtab_hdr;
732 struct elf_link_hash_entry **sym_hashes;
733 const Elf_Internal_Rela *rel;
734 const Elf_Internal_Rela *rel_end;
736 if (info->relocatable)
739 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
740 sym_hashes = elf_sym_hashes (abfd);
742 rel_end = relocs + sec->reloc_count;
743 for (rel = relocs; rel < rel_end; rel++)
745 struct elf_link_hash_entry *h;
746 unsigned long r_symndx;
748 r_symndx = ELF32_R_SYM (rel->r_info);
749 if (r_symndx < symtab_hdr->sh_info)
753 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
754 while (h->root.type == bfd_link_hash_indirect
755 || h->root.type == bfd_link_hash_warning)
756 h = (struct elf_link_hash_entry *) h->root.u.i.link;
764 avr_stub_is_required_for_16_bit_reloc (bfd_vma relocation)
766 return (relocation >= 0x020000);
769 /* Returns the address of the corresponding stub if there is one.
770 Returns otherwise an address above 0x020000. This function
771 could also be used, if there is no knowledge on the section where
772 the destination is found. */
775 avr_get_stub_addr (bfd_vma srel,
776 struct elf32_avr_link_hash_table *htab)
779 bfd_vma stub_sec_addr =
780 (htab->stub_sec->output_section->vma +
781 htab->stub_sec->output_offset);
783 for (index = 0; index < htab->amt_max_entry_cnt; index ++)
784 if (htab->amt_destination_addr[index] == srel)
785 return htab->amt_stub_offsets[index] + stub_sec_addr;
787 /* Return an address that could not be reached by 16 bit relocs. */
791 /* Perform a single relocation. By default we use the standard BFD
792 routines, but a few relocs, we have to do them ourselves. */
794 static bfd_reloc_status_type
795 avr_final_link_relocate (reloc_howto_type * howto,
797 asection * input_section,
799 Elf_Internal_Rela * rel,
801 struct elf32_avr_link_hash_table * htab)
803 bfd_reloc_status_type r = bfd_reloc_ok;
806 bfd_signed_vma reloc_addr;
807 bfd_boolean use_stubs = FALSE;
808 /* Usually is 0, unless we are generating code for a bootloader. */
809 bfd_signed_vma base_addr = htab->vector_base;
811 /* Absolute addr of the reloc in the final excecutable. */
812 reloc_addr = rel->r_offset + input_section->output_section->vma
813 + input_section->output_offset;
818 contents += rel->r_offset;
819 srel = (bfd_signed_vma) relocation;
820 srel += rel->r_addend;
821 srel -= rel->r_offset;
822 srel -= 2; /* Branch instructions add 2 to the PC... */
823 srel -= (input_section->output_section->vma +
824 input_section->output_offset);
827 return bfd_reloc_outofrange;
828 if (srel > ((1 << 7) - 1) || (srel < - (1 << 7)))
829 return bfd_reloc_overflow;
830 x = bfd_get_16 (input_bfd, contents);
831 x = (x & 0xfc07) | (((srel >> 1) << 3) & 0x3f8);
832 bfd_put_16 (input_bfd, x, contents);
836 contents += rel->r_offset;
837 srel = (bfd_signed_vma) relocation;
838 srel += rel->r_addend;
839 srel -= rel->r_offset;
840 srel -= 2; /* Branch instructions add 2 to the PC... */
841 srel -= (input_section->output_section->vma +
842 input_section->output_offset);
845 return bfd_reloc_outofrange;
847 srel = avr_relative_distance_considering_wrap_around (srel);
849 /* AVR addresses commands as words. */
852 /* Check for overflow. */
853 if (srel < -2048 || srel > 2047)
855 /* Relative distance is too large. */
857 /* Always apply WRAPAROUND for avr2 and avr4. */
858 switch (bfd_get_mach (input_bfd))
865 return bfd_reloc_overflow;
869 x = bfd_get_16 (input_bfd, contents);
870 x = (x & 0xf000) | (srel & 0xfff);
871 bfd_put_16 (input_bfd, x, contents);
875 contents += rel->r_offset;
876 srel = (bfd_signed_vma) relocation + rel->r_addend;
877 x = bfd_get_16 (input_bfd, contents);
878 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
879 bfd_put_16 (input_bfd, x, contents);
883 contents += rel->r_offset;
884 srel = (bfd_signed_vma) relocation + rel->r_addend;
885 if (((srel > 0) && (srel & 0xffff) > 255)
886 || ((srel < 0) && ((-srel) & 0xffff) > 128))
887 /* Remove offset for data/eeprom section. */
888 return bfd_reloc_overflow;
890 x = bfd_get_16 (input_bfd, contents);
891 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
892 bfd_put_16 (input_bfd, x, contents);
896 contents += rel->r_offset;
897 srel = (bfd_signed_vma) relocation + rel->r_addend;
898 if (((srel & 0xffff) > 63) || (srel < 0))
899 /* Remove offset for data/eeprom section. */
900 return bfd_reloc_overflow;
901 x = bfd_get_16 (input_bfd, contents);
902 x = (x & 0xd3f8) | ((srel & 7) | ((srel & (3 << 3)) << 7)
903 | ((srel & (1 << 5)) << 8));
904 bfd_put_16 (input_bfd, x, contents);
908 contents += rel->r_offset;
909 srel = (bfd_signed_vma) relocation + rel->r_addend;
910 if (((srel & 0xffff) > 63) || (srel < 0))
911 /* Remove offset for data/eeprom section. */
912 return bfd_reloc_overflow;
913 x = bfd_get_16 (input_bfd, contents);
914 x = (x & 0xff30) | (srel & 0xf) | ((srel & 0x30) << 2);
915 bfd_put_16 (input_bfd, x, contents);
919 contents += rel->r_offset;
920 srel = (bfd_signed_vma) relocation + rel->r_addend;
921 srel = (srel >> 8) & 0xff;
922 x = bfd_get_16 (input_bfd, contents);
923 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
924 bfd_put_16 (input_bfd, x, contents);
928 contents += rel->r_offset;
929 srel = (bfd_signed_vma) relocation + rel->r_addend;
930 srel = (srel >> 16) & 0xff;
931 x = bfd_get_16 (input_bfd, contents);
932 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
933 bfd_put_16 (input_bfd, x, contents);
937 contents += rel->r_offset;
938 srel = (bfd_signed_vma) relocation + rel->r_addend;
939 srel = (srel >> 24) & 0xff;
940 x = bfd_get_16 (input_bfd, contents);
941 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
942 bfd_put_16 (input_bfd, x, contents);
945 case R_AVR_LO8_LDI_NEG:
946 contents += rel->r_offset;
947 srel = (bfd_signed_vma) relocation + rel->r_addend;
949 x = bfd_get_16 (input_bfd, contents);
950 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
951 bfd_put_16 (input_bfd, x, contents);
954 case R_AVR_HI8_LDI_NEG:
955 contents += rel->r_offset;
956 srel = (bfd_signed_vma) relocation + rel->r_addend;
958 srel = (srel >> 8) & 0xff;
959 x = bfd_get_16 (input_bfd, contents);
960 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
961 bfd_put_16 (input_bfd, x, contents);
964 case R_AVR_HH8_LDI_NEG:
965 contents += rel->r_offset;
966 srel = (bfd_signed_vma) relocation + rel->r_addend;
968 srel = (srel >> 16) & 0xff;
969 x = bfd_get_16 (input_bfd, contents);
970 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
971 bfd_put_16 (input_bfd, x, contents);
974 case R_AVR_MS8_LDI_NEG:
975 contents += rel->r_offset;
976 srel = (bfd_signed_vma) relocation + rel->r_addend;
978 srel = (srel >> 24) & 0xff;
979 x = bfd_get_16 (input_bfd, contents);
980 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
981 bfd_put_16 (input_bfd, x, contents);
984 case R_AVR_LO8_LDI_GS:
985 use_stubs = (!htab->no_stubs);
987 case R_AVR_LO8_LDI_PM:
988 contents += rel->r_offset;
989 srel = (bfd_signed_vma) relocation + rel->r_addend;
992 && avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
994 bfd_vma old_srel = srel;
996 /* We need to use the address of the stub instead. */
997 srel = avr_get_stub_addr (srel, htab);
999 printf ("LD: Using jump stub (at 0x%x) with destination 0x%x for "
1000 "reloc at address 0x%x.\n",
1001 (unsigned int) srel,
1002 (unsigned int) old_srel,
1003 (unsigned int) reloc_addr);
1005 if (avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1006 return bfd_reloc_outofrange;
1010 return bfd_reloc_outofrange;
1012 x = bfd_get_16 (input_bfd, contents);
1013 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1014 bfd_put_16 (input_bfd, x, contents);
1017 case R_AVR_HI8_LDI_GS:
1018 use_stubs = (!htab->no_stubs);
1020 case R_AVR_HI8_LDI_PM:
1021 contents += rel->r_offset;
1022 srel = (bfd_signed_vma) relocation + rel->r_addend;
1025 && avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1027 bfd_vma old_srel = srel;
1029 /* We need to use the address of the stub instead. */
1030 srel = avr_get_stub_addr (srel, htab);
1032 printf ("LD: Using jump stub (at 0x%x) with destination 0x%x for "
1033 "reloc at address 0x%x.\n",
1034 (unsigned int) srel,
1035 (unsigned int) old_srel,
1036 (unsigned int) reloc_addr);
1038 if (avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1039 return bfd_reloc_outofrange;
1043 return bfd_reloc_outofrange;
1045 srel = (srel >> 8) & 0xff;
1046 x = bfd_get_16 (input_bfd, contents);
1047 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1048 bfd_put_16 (input_bfd, x, contents);
1051 case R_AVR_HH8_LDI_PM:
1052 contents += rel->r_offset;
1053 srel = (bfd_signed_vma) relocation + rel->r_addend;
1055 return bfd_reloc_outofrange;
1057 srel = (srel >> 16) & 0xff;
1058 x = bfd_get_16 (input_bfd, contents);
1059 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1060 bfd_put_16 (input_bfd, x, contents);
1063 case R_AVR_LO8_LDI_PM_NEG:
1064 contents += rel->r_offset;
1065 srel = (bfd_signed_vma) relocation + rel->r_addend;
1068 return bfd_reloc_outofrange;
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_HI8_LDI_PM_NEG:
1076 contents += rel->r_offset;
1077 srel = (bfd_signed_vma) relocation + rel->r_addend;
1080 return bfd_reloc_outofrange;
1082 srel = (srel >> 8) & 0xff;
1083 x = bfd_get_16 (input_bfd, contents);
1084 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1085 bfd_put_16 (input_bfd, x, contents);
1088 case R_AVR_HH8_LDI_PM_NEG:
1089 contents += rel->r_offset;
1090 srel = (bfd_signed_vma) relocation + rel->r_addend;
1093 return bfd_reloc_outofrange;
1095 srel = (srel >> 16) & 0xff;
1096 x = bfd_get_16 (input_bfd, contents);
1097 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1098 bfd_put_16 (input_bfd, x, contents);
1102 contents += rel->r_offset;
1103 srel = (bfd_signed_vma) relocation + rel->r_addend;
1105 return bfd_reloc_outofrange;
1107 x = bfd_get_16 (input_bfd, contents);
1108 x |= ((srel & 0x10000) | ((srel << 3) & 0x1f00000)) >> 16;
1109 bfd_put_16 (input_bfd, x, contents);
1110 bfd_put_16 (input_bfd, (bfd_vma) srel & 0xffff, contents+2);
1114 use_stubs = (!htab->no_stubs);
1115 contents += rel->r_offset;
1116 srel = (bfd_signed_vma) relocation + rel->r_addend;
1119 && avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1121 bfd_vma old_srel = srel;
1123 /* We need to use the address of the stub instead. */
1124 srel = avr_get_stub_addr (srel,htab);
1126 printf ("LD: Using jump stub (at 0x%x) with destination 0x%x for "
1127 "reloc at address 0x%x.\n",
1128 (unsigned int) srel,
1129 (unsigned int) old_srel,
1130 (unsigned int) reloc_addr);
1132 if (avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1133 return bfd_reloc_outofrange;
1137 return bfd_reloc_outofrange;
1139 bfd_put_16 (input_bfd, (bfd_vma) srel &0x00ffff, contents);
1143 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1144 contents, rel->r_offset,
1145 relocation, rel->r_addend);
1151 /* Relocate an AVR ELF section. */
1154 elf32_avr_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED,
1155 struct bfd_link_info *info,
1157 asection *input_section,
1159 Elf_Internal_Rela *relocs,
1160 Elf_Internal_Sym *local_syms,
1161 asection **local_sections)
1163 Elf_Internal_Shdr * symtab_hdr;
1164 struct elf_link_hash_entry ** sym_hashes;
1165 Elf_Internal_Rela * rel;
1166 Elf_Internal_Rela * relend;
1167 struct elf32_avr_link_hash_table * htab = avr_link_hash_table (info);
1169 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
1170 sym_hashes = elf_sym_hashes (input_bfd);
1171 relend = relocs + input_section->reloc_count;
1173 for (rel = relocs; rel < relend; rel ++)
1175 reloc_howto_type * howto;
1176 unsigned long r_symndx;
1177 Elf_Internal_Sym * sym;
1179 struct elf_link_hash_entry * h;
1181 bfd_reloc_status_type r;
1185 r_type = ELF32_R_TYPE (rel->r_info);
1186 r_symndx = ELF32_R_SYM (rel->r_info);
1187 howto = elf_avr_howto_table + ELF32_R_TYPE (rel->r_info);
1192 if (r_symndx < symtab_hdr->sh_info)
1194 sym = local_syms + r_symndx;
1195 sec = local_sections [r_symndx];
1196 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1198 name = bfd_elf_string_from_elf_section
1199 (input_bfd, symtab_hdr->sh_link, sym->st_name);
1200 name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
1204 bfd_boolean unresolved_reloc, warned;
1206 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1207 r_symndx, symtab_hdr, sym_hashes,
1209 unresolved_reloc, warned);
1211 name = h->root.root.string;
1214 if (sec != NULL && elf_discarded_section (sec))
1216 /* For relocs against symbols from removed linkonce sections,
1217 or sections discarded by a linker script, we just want the
1218 section contents zeroed. Avoid any special processing. */
1219 _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
1225 if (info->relocatable)
1228 r = avr_final_link_relocate (howto, input_bfd, input_section,
1229 contents, rel, relocation, htab);
1231 if (r != bfd_reloc_ok)
1233 const char * msg = (const char *) NULL;
1237 case bfd_reloc_overflow:
1238 r = info->callbacks->reloc_overflow
1239 (info, (h ? &h->root : NULL),
1240 name, howto->name, (bfd_vma) 0,
1241 input_bfd, input_section, rel->r_offset);
1244 case bfd_reloc_undefined:
1245 r = info->callbacks->undefined_symbol
1246 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
1249 case bfd_reloc_outofrange:
1250 msg = _("internal error: out of range error");
1253 case bfd_reloc_notsupported:
1254 msg = _("internal error: unsupported relocation error");
1257 case bfd_reloc_dangerous:
1258 msg = _("internal error: dangerous relocation");
1262 msg = _("internal error: unknown error");
1267 r = info->callbacks->warning
1268 (info, msg, name, input_bfd, input_section, rel->r_offset);
1278 /* The final processing done just before writing out a AVR ELF object
1279 file. This gets the AVR architecture right based on the machine
1283 bfd_elf_avr_final_write_processing (bfd *abfd,
1284 bfd_boolean linker ATTRIBUTE_UNUSED)
1288 switch (bfd_get_mach (abfd))
1292 val = E_AVR_MACH_AVR2;
1296 val = E_AVR_MACH_AVR1;
1299 case bfd_mach_avr25:
1300 val = E_AVR_MACH_AVR25;
1303 val = E_AVR_MACH_AVR3;
1306 case bfd_mach_avr31:
1307 val = E_AVR_MACH_AVR31;
1309 case bfd_mach_avr35:
1310 val = E_AVR_MACH_AVR35;
1313 val = E_AVR_MACH_AVR4;
1317 val = E_AVR_MACH_AVR5;
1320 case bfd_mach_avr51:
1321 val = E_AVR_MACH_AVR51;
1325 val = E_AVR_MACH_AVR6;
1329 elf_elfheader (abfd)->e_machine = EM_AVR;
1330 elf_elfheader (abfd)->e_flags &= ~ EF_AVR_MACH;
1331 elf_elfheader (abfd)->e_flags |= val;
1332 elf_elfheader (abfd)->e_flags |= EF_AVR_LINKRELAX_PREPARED;
1335 /* Set the right machine number. */
1338 elf32_avr_object_p (bfd *abfd)
1340 unsigned int e_set = bfd_mach_avr2;
1342 if (elf_elfheader (abfd)->e_machine == EM_AVR
1343 || elf_elfheader (abfd)->e_machine == EM_AVR_OLD)
1345 int e_mach = elf_elfheader (abfd)->e_flags & EF_AVR_MACH;
1350 case E_AVR_MACH_AVR2:
1351 e_set = bfd_mach_avr2;
1354 case E_AVR_MACH_AVR1:
1355 e_set = bfd_mach_avr1;
1358 case E_AVR_MACH_AVR25:
1359 e_set = bfd_mach_avr25;
1362 case E_AVR_MACH_AVR3:
1363 e_set = bfd_mach_avr3;
1366 case E_AVR_MACH_AVR31:
1367 e_set = bfd_mach_avr31;
1370 case E_AVR_MACH_AVR35:
1371 e_set = bfd_mach_avr35;
1374 case E_AVR_MACH_AVR4:
1375 e_set = bfd_mach_avr4;
1378 case E_AVR_MACH_AVR5:
1379 e_set = bfd_mach_avr5;
1382 case E_AVR_MACH_AVR51:
1383 e_set = bfd_mach_avr51;
1386 case E_AVR_MACH_AVR6:
1387 e_set = bfd_mach_avr6;
1391 return bfd_default_set_arch_mach (abfd, bfd_arch_avr,
1396 /* Delete some bytes from a section while changing the size of an instruction.
1397 The parameter "addr" denotes the section-relative offset pointing just
1398 behind the shrinked instruction. "addr+count" point at the first
1399 byte just behind the original unshrinked instruction. */
1402 elf32_avr_relax_delete_bytes (bfd *abfd,
1407 Elf_Internal_Shdr *symtab_hdr;
1408 unsigned int sec_shndx;
1410 Elf_Internal_Rela *irel, *irelend;
1411 Elf_Internal_Rela *irelalign;
1412 Elf_Internal_Sym *isym;
1413 Elf_Internal_Sym *isymbuf = NULL;
1414 Elf_Internal_Sym *isymend;
1416 struct elf_link_hash_entry **sym_hashes;
1417 struct elf_link_hash_entry **end_hashes;
1418 unsigned int symcount;
1420 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1421 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1422 contents = elf_section_data (sec)->this_hdr.contents;
1424 /* The deletion must stop at the next ALIGN reloc for an aligment
1425 power larger than the number of bytes we are deleting. */
1430 irel = elf_section_data (sec)->relocs;
1431 irelend = irel + sec->reloc_count;
1433 /* Actually delete the bytes. */
1434 if (toaddr - addr - count > 0)
1435 memmove (contents + addr, contents + addr + count,
1436 (size_t) (toaddr - addr - count));
1439 /* Adjust all the reloc addresses. */
1440 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1442 bfd_vma old_reloc_address;
1443 bfd_vma shrinked_insn_address;
1445 old_reloc_address = (sec->output_section->vma
1446 + sec->output_offset + irel->r_offset);
1447 shrinked_insn_address = (sec->output_section->vma
1448 + sec->output_offset + addr - count);
1450 /* Get the new reloc address. */
1451 if ((irel->r_offset > addr
1452 && irel->r_offset < toaddr))
1455 printf ("Relocation at address 0x%x needs to be moved.\n"
1456 "Old section offset: 0x%x, New section offset: 0x%x \n",
1457 (unsigned int) old_reloc_address,
1458 (unsigned int) irel->r_offset,
1459 (unsigned int) ((irel->r_offset) - count));
1461 irel->r_offset -= count;
1466 /* The reloc's own addresses are now ok. However, we need to readjust
1467 the reloc's addend, i.e. the reloc's value if two conditions are met:
1468 1.) the reloc is relative to a symbol in this section that
1469 is located in front of the shrinked instruction
1470 2.) symbol plus addend end up behind the shrinked instruction.
1472 The most common case where this happens are relocs relative to
1473 the section-start symbol.
1475 This step needs to be done for all of the sections of the bfd. */
1478 struct bfd_section *isec;
1480 for (isec = abfd->sections; isec; isec = isec->next)
1483 bfd_vma shrinked_insn_address;
1485 shrinked_insn_address = (sec->output_section->vma
1486 + sec->output_offset + addr - count);
1488 irelend = elf_section_data (isec)->relocs + isec->reloc_count;
1489 for (irel = elf_section_data (isec)->relocs;
1493 /* Read this BFD's local symbols if we haven't done
1495 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
1497 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1498 if (isymbuf == NULL)
1499 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
1500 symtab_hdr->sh_info, 0,
1502 if (isymbuf == NULL)
1506 /* Get the value of the symbol referred to by the reloc. */
1507 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1509 /* A local symbol. */
1510 Elf_Internal_Sym *isym;
1513 isym = isymbuf + ELF32_R_SYM (irel->r_info);
1514 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
1515 symval = isym->st_value;
1516 /* If the reloc is absolute, it will not have
1517 a symbol or section associated with it. */
1520 symval += sym_sec->output_section->vma
1521 + sym_sec->output_offset;
1524 printf ("Checking if the relocation's "
1525 "addend needs corrections.\n"
1526 "Address of anchor symbol: 0x%x \n"
1527 "Address of relocation target: 0x%x \n"
1528 "Address of relaxed insn: 0x%x \n",
1529 (unsigned int) symval,
1530 (unsigned int) (symval + irel->r_addend),
1531 (unsigned int) shrinked_insn_address);
1533 if (symval <= shrinked_insn_address
1534 && (symval + irel->r_addend) > shrinked_insn_address)
1536 irel->r_addend -= count;
1539 printf ("Relocation's addend needed to be fixed \n");
1542 /* else...Reference symbol is absolute. No adjustment needed. */
1544 /* else...Reference symbol is extern. No need for adjusting
1550 /* Adjust the local symbols defined in this section. */
1551 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1552 isymend = isym + symtab_hdr->sh_info;
1553 for (; isym < isymend; isym++)
1555 if (isym->st_shndx == sec_shndx
1556 && isym->st_value > addr
1557 && isym->st_value < toaddr)
1558 isym->st_value -= count;
1561 /* Now adjust the global symbols defined in this section. */
1562 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1563 - symtab_hdr->sh_info);
1564 sym_hashes = elf_sym_hashes (abfd);
1565 end_hashes = sym_hashes + symcount;
1566 for (; sym_hashes < end_hashes; sym_hashes++)
1568 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1569 if ((sym_hash->root.type == bfd_link_hash_defined
1570 || sym_hash->root.type == bfd_link_hash_defweak)
1571 && sym_hash->root.u.def.section == sec
1572 && sym_hash->root.u.def.value > addr
1573 && sym_hash->root.u.def.value < toaddr)
1575 sym_hash->root.u.def.value -= count;
1582 /* This function handles relaxing for the avr.
1583 Many important relaxing opportunities within functions are already
1584 realized by the compiler itself.
1585 Here we try to replace call (4 bytes) -> rcall (2 bytes)
1586 and jump -> rjmp (safes also 2 bytes).
1587 As well we now optimize seqences of
1588 - call/rcall function
1593 . In case that within a sequence
1596 the ret could no longer be reached it is optimized away. In order
1597 to check if the ret is no longer needed, it is checked that the ret's address
1598 is not the target of a branch or jump within the same section, it is checked
1599 that there is no skip instruction before the jmp/rjmp and that there
1600 is no local or global label place at the address of the ret.
1602 We refrain from relaxing within sections ".vectors" and
1603 ".jumptables" in order to maintain the position of the instructions.
1604 There, however, we substitute jmp/call by a sequence rjmp,nop/rcall,nop
1605 if possible. (In future one could possibly use the space of the nop
1606 for the first instruction of the irq service function.
1608 The .jumptables sections is meant to be used for a future tablejump variant
1609 for the devices with 3-byte program counter where the table itself
1610 contains 4-byte jump instructions whose relative offset must not
1614 elf32_avr_relax_section (bfd *abfd,
1616 struct bfd_link_info *link_info,
1619 Elf_Internal_Shdr *symtab_hdr;
1620 Elf_Internal_Rela *internal_relocs;
1621 Elf_Internal_Rela *irel, *irelend;
1622 bfd_byte *contents = NULL;
1623 Elf_Internal_Sym *isymbuf = NULL;
1624 static asection *last_input_section = NULL;
1625 static Elf_Internal_Rela *last_reloc = NULL;
1626 struct elf32_avr_link_hash_table *htab;
1628 htab = avr_link_hash_table (link_info);
1632 /* Assume nothing changes. */
1635 if ((!htab->no_stubs) && (sec == htab->stub_sec))
1637 /* We are just relaxing the stub section.
1638 Let's calculate the size needed again. */
1639 bfd_size_type last_estimated_stub_section_size = htab->stub_sec->size;
1642 printf ("Relaxing the stub section. Size prior to this pass: %i\n",
1643 (int) last_estimated_stub_section_size);
1645 elf32_avr_size_stubs (htab->stub_sec->output_section->owner,
1648 /* Check if the number of trampolines changed. */
1649 if (last_estimated_stub_section_size != htab->stub_sec->size)
1653 printf ("Size of stub section after this pass: %i\n",
1654 (int) htab->stub_sec->size);
1659 /* We don't have to do anything for a relocatable link, if
1660 this section does not have relocs, or if this is not a
1662 if (link_info->relocatable
1663 || (sec->flags & SEC_RELOC) == 0
1664 || sec->reloc_count == 0
1665 || (sec->flags & SEC_CODE) == 0)
1668 /* Check if the object file to relax uses internal symbols so that we
1669 could fix up the relocations. */
1670 if (!(elf_elfheader (abfd)->e_flags & EF_AVR_LINKRELAX_PREPARED))
1673 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1675 /* Get a copy of the native relocations. */
1676 internal_relocs = (_bfd_elf_link_read_relocs
1677 (abfd, sec, NULL, NULL, link_info->keep_memory));
1678 if (internal_relocs == NULL)
1681 if (sec != last_input_section)
1684 last_input_section = sec;
1686 /* Walk through the relocs looking for relaxing opportunities. */
1687 irelend = internal_relocs + sec->reloc_count;
1688 for (irel = internal_relocs; irel < irelend; irel++)
1692 if ( ELF32_R_TYPE (irel->r_info) != R_AVR_13_PCREL
1693 && ELF32_R_TYPE (irel->r_info) != R_AVR_7_PCREL
1694 && ELF32_R_TYPE (irel->r_info) != R_AVR_CALL)
1697 /* Get the section contents if we haven't done so already. */
1698 if (contents == NULL)
1700 /* Get cached copy if it exists. */
1701 if (elf_section_data (sec)->this_hdr.contents != NULL)
1702 contents = elf_section_data (sec)->this_hdr.contents;
1705 /* Go get them off disk. */
1706 if (! bfd_malloc_and_get_section (abfd, sec, &contents))
1711 /* Read this BFD's local symbols if we haven't done so already. */
1712 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
1714 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1715 if (isymbuf == NULL)
1716 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
1717 symtab_hdr->sh_info, 0,
1719 if (isymbuf == NULL)
1724 /* Get the value of the symbol referred to by the reloc. */
1725 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1727 /* A local symbol. */
1728 Elf_Internal_Sym *isym;
1731 isym = isymbuf + ELF32_R_SYM (irel->r_info);
1732 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
1733 symval = isym->st_value;
1734 /* If the reloc is absolute, it will not have
1735 a symbol or section associated with it. */
1737 symval += sym_sec->output_section->vma
1738 + sym_sec->output_offset;
1743 struct elf_link_hash_entry *h;
1745 /* An external symbol. */
1746 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
1747 h = elf_sym_hashes (abfd)[indx];
1748 BFD_ASSERT (h != NULL);
1749 if (h->root.type != bfd_link_hash_defined
1750 && h->root.type != bfd_link_hash_defweak)
1751 /* This appears to be a reference to an undefined
1752 symbol. Just ignore it--it will be caught by the
1753 regular reloc processing. */
1756 symval = (h->root.u.def.value
1757 + h->root.u.def.section->output_section->vma
1758 + h->root.u.def.section->output_offset);
1761 /* For simplicity of coding, we are going to modify the section
1762 contents, the section relocs, and the BFD symbol table. We
1763 must tell the rest of the code not to free up this
1764 information. It would be possible to instead create a table
1765 of changes which have to be made, as is done in coff-mips.c;
1766 that would be more work, but would require less memory when
1767 the linker is run. */
1768 switch (ELF32_R_TYPE (irel->r_info))
1770 /* Try to turn a 22-bit absolute call/jump into an 13-bit
1771 pc-relative rcall/rjmp. */
1774 bfd_vma value = symval + irel->r_addend;
1776 int distance_short_enough = 0;
1778 /* Get the address of this instruction. */
1779 dot = (sec->output_section->vma
1780 + sec->output_offset + irel->r_offset);
1782 /* Compute the distance from this insn to the branch target. */
1785 /* If the distance is within -4094..+4098 inclusive, then we can
1786 relax this jump/call. +4098 because the call/jump target
1787 will be closer after the relaxation. */
1788 if ((int) gap >= -4094 && (int) gap <= 4098)
1789 distance_short_enough = 1;
1791 /* Here we handle the wrap-around case. E.g. for a 16k device
1792 we could use a rjmp to jump from address 0x100 to 0x3d00!
1793 In order to make this work properly, we need to fill the
1794 vaiable avr_pc_wrap_around with the appropriate value.
1795 I.e. 0x4000 for a 16k device. */
1797 /* Shrinking the code size makes the gaps larger in the
1798 case of wrap-arounds. So we use a heuristical safety
1799 margin to avoid that during relax the distance gets
1800 again too large for the short jumps. Let's assume
1801 a typical code-size reduction due to relax for a
1802 16k device of 600 bytes. So let's use twice the
1803 typical value as safety margin. */
1807 int assumed_shrink = 600;
1808 if (avr_pc_wrap_around > 0x4000)
1809 assumed_shrink = 900;
1811 safety_margin = 2 * assumed_shrink;
1813 rgap = avr_relative_distance_considering_wrap_around (gap);
1815 if (rgap >= (-4092 + safety_margin)
1816 && rgap <= (4094 - safety_margin))
1817 distance_short_enough = 1;
1820 if (distance_short_enough)
1822 unsigned char code_msb;
1823 unsigned char code_lsb;
1826 printf ("shrinking jump/call instruction at address 0x%x"
1827 " in section %s\n\n",
1828 (int) dot, sec->name);
1830 /* Note that we've changed the relocs, section contents,
1832 elf_section_data (sec)->relocs = internal_relocs;
1833 elf_section_data (sec)->this_hdr.contents = contents;
1834 symtab_hdr->contents = (unsigned char *) isymbuf;
1836 /* Get the instruction code for relaxing. */
1837 code_lsb = bfd_get_8 (abfd, contents + irel->r_offset);
1838 code_msb = bfd_get_8 (abfd, contents + irel->r_offset + 1);
1840 /* Mask out the relocation bits. */
1843 if (code_msb == 0x94 && code_lsb == 0x0E)
1845 /* we are changing call -> rcall . */
1846 bfd_put_8 (abfd, 0x00, contents + irel->r_offset);
1847 bfd_put_8 (abfd, 0xD0, contents + irel->r_offset + 1);
1849 else if (code_msb == 0x94 && code_lsb == 0x0C)
1851 /* we are changeing jump -> rjmp. */
1852 bfd_put_8 (abfd, 0x00, contents + irel->r_offset);
1853 bfd_put_8 (abfd, 0xC0, contents + irel->r_offset + 1);
1858 /* Fix the relocation's type. */
1859 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1862 /* Check for the vector section. There we don't want to
1863 modify the ordering! */
1865 if (!strcmp (sec->name,".vectors")
1866 || !strcmp (sec->name,".jumptables"))
1868 /* Let's insert a nop. */
1869 bfd_put_8 (abfd, 0x00, contents + irel->r_offset + 2);
1870 bfd_put_8 (abfd, 0x00, contents + irel->r_offset + 3);
1874 /* Delete two bytes of data. */
1875 if (!elf32_avr_relax_delete_bytes (abfd, sec,
1876 irel->r_offset + 2, 2))
1879 /* That will change things, so, we should relax again.
1880 Note that this is not required, and it may be slow. */
1888 unsigned char code_msb;
1889 unsigned char code_lsb;
1892 code_msb = bfd_get_8 (abfd, contents + irel->r_offset + 1);
1893 code_lsb = bfd_get_8 (abfd, contents + irel->r_offset + 0);
1895 /* Get the address of this instruction. */
1896 dot = (sec->output_section->vma
1897 + sec->output_offset + irel->r_offset);
1899 /* Here we look for rcall/ret or call/ret sequences that could be
1900 safely replaced by rjmp/ret or jmp/ret. */
1901 if (((code_msb & 0xf0) == 0xd0)
1902 && avr_replace_call_ret_sequences)
1904 /* This insn is a rcall. */
1905 unsigned char next_insn_msb = 0;
1906 unsigned char next_insn_lsb = 0;
1908 if (irel->r_offset + 3 < sec->size)
1911 bfd_get_8 (abfd, contents + irel->r_offset + 3);
1913 bfd_get_8 (abfd, contents + irel->r_offset + 2);
1916 if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb))
1918 /* The next insn is a ret. We now convert the rcall insn
1919 into a rjmp instruction. */
1921 bfd_put_8 (abfd, code_msb, contents + irel->r_offset + 1);
1923 printf ("converted rcall/ret sequence at address 0x%x"
1924 " into rjmp/ret sequence. Section is %s\n\n",
1925 (int) dot, sec->name);
1930 else if ((0x94 == (code_msb & 0xfe))
1931 && (0x0e == (code_lsb & 0x0e))
1932 && avr_replace_call_ret_sequences)
1934 /* This insn is a call. */
1935 unsigned char next_insn_msb = 0;
1936 unsigned char next_insn_lsb = 0;
1938 if (irel->r_offset + 5 < sec->size)
1941 bfd_get_8 (abfd, contents + irel->r_offset + 5);
1943 bfd_get_8 (abfd, contents + irel->r_offset + 4);
1946 if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb))
1948 /* The next insn is a ret. We now convert the call insn
1949 into a jmp instruction. */
1952 bfd_put_8 (abfd, code_lsb, contents + irel->r_offset);
1954 printf ("converted call/ret sequence at address 0x%x"
1955 " into jmp/ret sequence. Section is %s\n\n",
1956 (int) dot, sec->name);
1961 else if ((0xc0 == (code_msb & 0xf0))
1962 || ((0x94 == (code_msb & 0xfe))
1963 && (0x0c == (code_lsb & 0x0e))))
1965 /* This insn is a rjmp or a jmp. */
1966 unsigned char next_insn_msb = 0;
1967 unsigned char next_insn_lsb = 0;
1970 if (0xc0 == (code_msb & 0xf0))
1971 insn_size = 2; /* rjmp insn */
1973 insn_size = 4; /* jmp insn */
1975 if (irel->r_offset + insn_size + 1 < sec->size)
1978 bfd_get_8 (abfd, contents + irel->r_offset
1981 bfd_get_8 (abfd, contents + irel->r_offset
1985 if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb))
1987 /* The next insn is a ret. We possibly could delete
1988 this ret. First we need to check for preceeding
1989 sbis/sbic/sbrs or cpse "skip" instructions. */
1991 int there_is_preceeding_non_skip_insn = 1;
1992 bfd_vma address_of_ret;
1994 address_of_ret = dot + insn_size;
1996 if (debug_relax && (insn_size == 2))
1997 printf ("found rjmp / ret sequence at address 0x%x\n",
1999 if (debug_relax && (insn_size == 4))
2000 printf ("found jmp / ret sequence at address 0x%x\n",
2003 /* We have to make sure that there is a preceeding insn. */
2004 if (irel->r_offset >= 2)
2006 unsigned char preceeding_msb;
2007 unsigned char preceeding_lsb;
2009 bfd_get_8 (abfd, contents + irel->r_offset - 1);
2011 bfd_get_8 (abfd, contents + irel->r_offset - 2);
2014 if (0x99 == preceeding_msb)
2015 there_is_preceeding_non_skip_insn = 0;
2018 if (0x9b == preceeding_msb)
2019 there_is_preceeding_non_skip_insn = 0;
2022 if ((0xfc == (preceeding_msb & 0xfe)
2023 && (0x00 == (preceeding_lsb & 0x08))))
2024 there_is_preceeding_non_skip_insn = 0;
2027 if ((0xfe == (preceeding_msb & 0xfe)
2028 && (0x00 == (preceeding_lsb & 0x08))))
2029 there_is_preceeding_non_skip_insn = 0;
2032 if (0x10 == (preceeding_msb & 0xfc))
2033 there_is_preceeding_non_skip_insn = 0;
2035 if (there_is_preceeding_non_skip_insn == 0)
2037 printf ("preceeding skip insn prevents deletion of"
2038 " ret insn at addr 0x%x in section %s\n",
2039 (int) dot + 2, sec->name);
2043 /* There is no previous instruction. */
2044 there_is_preceeding_non_skip_insn = 0;
2047 if (there_is_preceeding_non_skip_insn)
2049 /* We now only have to make sure that there is no
2050 local label defined at the address of the ret
2051 instruction and that there is no local relocation
2052 in this section pointing to the ret. */
2054 int deleting_ret_is_safe = 1;
2055 unsigned int section_offset_of_ret_insn =
2056 irel->r_offset + insn_size;
2057 Elf_Internal_Sym *isym, *isymend;
2058 unsigned int sec_shndx;
2061 _bfd_elf_section_from_bfd_section (abfd, sec);
2063 /* Check for local symbols. */
2064 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
2065 isymend = isym + symtab_hdr->sh_info;
2066 /* PR 6019: There may not be any local symbols. */
2067 for (; isym != NULL && isym < isymend; isym++)
2069 if (isym->st_value == section_offset_of_ret_insn
2070 && isym->st_shndx == sec_shndx)
2072 deleting_ret_is_safe = 0;
2074 printf ("local label prevents deletion of ret "
2075 "insn at address 0x%x\n",
2076 (int) dot + insn_size);
2080 /* Now check for global symbols. */
2083 struct elf_link_hash_entry **sym_hashes;
2084 struct elf_link_hash_entry **end_hashes;
2086 symcount = (symtab_hdr->sh_size
2087 / sizeof (Elf32_External_Sym)
2088 - symtab_hdr->sh_info);
2089 sym_hashes = elf_sym_hashes (abfd);
2090 end_hashes = sym_hashes + symcount;
2091 for (; sym_hashes < end_hashes; sym_hashes++)
2093 struct elf_link_hash_entry *sym_hash =
2095 if ((sym_hash->root.type == bfd_link_hash_defined
2096 || sym_hash->root.type ==
2097 bfd_link_hash_defweak)
2098 && sym_hash->root.u.def.section == sec
2099 && sym_hash->root.u.def.value == section_offset_of_ret_insn)
2101 deleting_ret_is_safe = 0;
2103 printf ("global label prevents deletion of "
2104 "ret insn at address 0x%x\n",
2105 (int) dot + insn_size);
2109 /* Now we check for relocations pointing to ret. */
2111 Elf_Internal_Rela *irel;
2112 Elf_Internal_Rela *relend;
2113 Elf_Internal_Shdr *symtab_hdr;
2115 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2116 relend = elf_section_data (sec)->relocs
2119 for (irel = elf_section_data (sec)->relocs;
2120 irel < relend; irel++)
2122 bfd_vma reloc_target = 0;
2124 Elf_Internal_Sym *isymbuf = NULL;
2126 /* Read this BFD's local symbols if we haven't
2128 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
2130 isymbuf = (Elf_Internal_Sym *)
2131 symtab_hdr->contents;
2132 if (isymbuf == NULL)
2133 isymbuf = bfd_elf_get_elf_syms
2136 symtab_hdr->sh_info, 0,
2138 if (isymbuf == NULL)
2142 /* Get the value of the symbol referred to
2144 if (ELF32_R_SYM (irel->r_info)
2145 < symtab_hdr->sh_info)
2147 /* A local symbol. */
2148 Elf_Internal_Sym *isym;
2152 + ELF32_R_SYM (irel->r_info);
2153 sym_sec = bfd_section_from_elf_index
2154 (abfd, isym->st_shndx);
2155 symval = isym->st_value;
2157 /* If the reloc is absolute, it will not
2158 have a symbol or section associated
2164 sym_sec->output_section->vma
2165 + sym_sec->output_offset;
2166 reloc_target = symval + irel->r_addend;
2170 reloc_target = symval + irel->r_addend;
2171 /* Reference symbol is absolute. */
2174 /* else ... reference symbol is extern. */
2176 if (address_of_ret == reloc_target)
2178 deleting_ret_is_safe = 0;
2181 "rjmp/jmp ret sequence at address"
2182 " 0x%x could not be deleted. ret"
2183 " is target of a relocation.\n",
2184 (int) address_of_ret);
2189 if (deleting_ret_is_safe)
2192 printf ("unreachable ret instruction "
2193 "at address 0x%x deleted.\n",
2194 (int) dot + insn_size);
2196 /* Delete two bytes of data. */
2197 if (!elf32_avr_relax_delete_bytes (abfd, sec,
2198 irel->r_offset + insn_size, 2))
2201 /* That will change things, so, we should relax
2202 again. Note that this is not required, and it
2216 if (contents != NULL
2217 && elf_section_data (sec)->this_hdr.contents != contents)
2219 if (! link_info->keep_memory)
2223 /* Cache the section contents for elf_link_input_bfd. */
2224 elf_section_data (sec)->this_hdr.contents = contents;
2228 if (internal_relocs != NULL
2229 && elf_section_data (sec)->relocs != internal_relocs)
2230 free (internal_relocs);
2236 && symtab_hdr->contents != (unsigned char *) isymbuf)
2238 if (contents != NULL
2239 && elf_section_data (sec)->this_hdr.contents != contents)
2241 if (internal_relocs != NULL
2242 && elf_section_data (sec)->relocs != internal_relocs)
2243 free (internal_relocs);
2248 /* This is a version of bfd_generic_get_relocated_section_contents
2249 which uses elf32_avr_relocate_section.
2251 For avr it's essentially a cut and paste taken from the H8300 port.
2252 The author of the relaxation support patch for avr had absolutely no
2253 clue what is happening here but found out that this part of the code
2254 seems to be important. */
2257 elf32_avr_get_relocated_section_contents (bfd *output_bfd,
2258 struct bfd_link_info *link_info,
2259 struct bfd_link_order *link_order,
2261 bfd_boolean relocatable,
2264 Elf_Internal_Shdr *symtab_hdr;
2265 asection *input_section = link_order->u.indirect.section;
2266 bfd *input_bfd = input_section->owner;
2267 asection **sections = NULL;
2268 Elf_Internal_Rela *internal_relocs = NULL;
2269 Elf_Internal_Sym *isymbuf = NULL;
2271 /* We only need to handle the case of relaxing, or of having a
2272 particular set of section contents, specially. */
2274 || elf_section_data (input_section)->this_hdr.contents == NULL)
2275 return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
2279 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2281 memcpy (data, elf_section_data (input_section)->this_hdr.contents,
2282 (size_t) input_section->size);
2284 if ((input_section->flags & SEC_RELOC) != 0
2285 && input_section->reloc_count > 0)
2288 Elf_Internal_Sym *isym, *isymend;
2291 internal_relocs = (_bfd_elf_link_read_relocs
2292 (input_bfd, input_section, NULL, NULL, FALSE));
2293 if (internal_relocs == NULL)
2296 if (symtab_hdr->sh_info != 0)
2298 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2299 if (isymbuf == NULL)
2300 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
2301 symtab_hdr->sh_info, 0,
2303 if (isymbuf == NULL)
2307 amt = symtab_hdr->sh_info;
2308 amt *= sizeof (asection *);
2309 sections = bfd_malloc (amt);
2310 if (sections == NULL && amt != 0)
2313 isymend = isymbuf + symtab_hdr->sh_info;
2314 for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
2318 if (isym->st_shndx == SHN_UNDEF)
2319 isec = bfd_und_section_ptr;
2320 else if (isym->st_shndx == SHN_ABS)
2321 isec = bfd_abs_section_ptr;
2322 else if (isym->st_shndx == SHN_COMMON)
2323 isec = bfd_com_section_ptr;
2325 isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
2330 if (! elf32_avr_relocate_section (output_bfd, link_info, input_bfd,
2331 input_section, data, internal_relocs,
2335 if (sections != NULL)
2338 && symtab_hdr->contents != (unsigned char *) isymbuf)
2340 if (elf_section_data (input_section)->relocs != internal_relocs)
2341 free (internal_relocs);
2347 if (sections != NULL)
2350 && symtab_hdr->contents != (unsigned char *) isymbuf)
2352 if (internal_relocs != NULL
2353 && elf_section_data (input_section)->relocs != internal_relocs)
2354 free (internal_relocs);
2359 /* Determines the hash entry name for a particular reloc. It consists of
2360 the identifier of the symbol section and the added reloc addend and
2361 symbol offset relative to the section the symbol is attached to. */
2364 avr_stub_name (const asection *symbol_section,
2365 const bfd_vma symbol_offset,
2366 const Elf_Internal_Rela *rela)
2371 len = 8 + 1 + 8 + 1 + 1;
2372 stub_name = bfd_malloc (len);
2374 sprintf (stub_name, "%08x+%08x",
2375 symbol_section->id & 0xffffffff,
2376 (unsigned int) ((rela->r_addend & 0xffffffff) + symbol_offset));
2382 /* Add a new stub entry to the stub hash. Not all fields of the new
2383 stub entry are initialised. */
2385 static struct elf32_avr_stub_hash_entry *
2386 avr_add_stub (const char *stub_name,
2387 struct elf32_avr_link_hash_table *htab)
2389 struct elf32_avr_stub_hash_entry *hsh;
2391 /* Enter this entry into the linker stub hash table. */
2392 hsh = avr_stub_hash_lookup (&htab->bstab, stub_name, TRUE, FALSE);
2396 (*_bfd_error_handler) (_("%B: cannot create stub entry %s"),
2401 hsh->stub_offset = 0;
2405 /* We assume that there is already space allocated for the stub section
2406 contents and that before building the stubs the section size is
2407 initialized to 0. We assume that within the stub hash table entry,
2408 the absolute position of the jmp target has been written in the
2409 target_value field. We write here the offset of the generated jmp insn
2410 relative to the trampoline section start to the stub_offset entry in
2411 the stub hash table entry. */
2414 avr_build_one_stub (struct bfd_hash_entry *bh, void *in_arg)
2416 struct elf32_avr_stub_hash_entry *hsh;
2417 struct bfd_link_info *info;
2418 struct elf32_avr_link_hash_table *htab;
2425 bfd_vma jmp_insn = 0x0000940c;
2427 /* Massage our args to the form they really have. */
2428 hsh = avr_stub_hash_entry (bh);
2430 if (!hsh->is_actually_needed)
2433 info = (struct bfd_link_info *) in_arg;
2435 htab = avr_link_hash_table (info);
2439 target = hsh->target_value;
2441 /* Make a note of the offset within the stubs for this entry. */
2442 hsh->stub_offset = htab->stub_sec->size;
2443 loc = htab->stub_sec->contents + hsh->stub_offset;
2445 stub_bfd = htab->stub_sec->owner;
2448 printf ("Building one Stub. Address: 0x%x, Offset: 0x%x\n",
2449 (unsigned int) target,
2450 (unsigned int) hsh->stub_offset);
2452 /* We now have to add the information on the jump target to the bare
2453 opcode bits already set in jmp_insn. */
2455 /* Check for the alignment of the address. */
2459 starget = target >> 1;
2460 jmp_insn |= ((starget & 0x10000) | ((starget << 3) & 0x1f00000)) >> 16;
2461 bfd_put_16 (stub_bfd, jmp_insn, loc);
2462 bfd_put_16 (stub_bfd, (bfd_vma) starget & 0xffff, loc + 2);
2464 htab->stub_sec->size += 4;
2466 /* Now add the entries in the address mapping table if there is still
2471 nr = htab->amt_entry_cnt + 1;
2472 if (nr <= htab->amt_max_entry_cnt)
2474 htab->amt_entry_cnt = nr;
2476 htab->amt_stub_offsets[nr - 1] = hsh->stub_offset;
2477 htab->amt_destination_addr[nr - 1] = target;
2485 avr_mark_stub_not_to_be_necessary (struct bfd_hash_entry *bh,
2488 struct elf32_avr_stub_hash_entry *hsh;
2489 struct elf32_avr_link_hash_table *htab;
2492 hsh = avr_stub_hash_entry (bh);
2493 hsh->is_actually_needed = FALSE;
2499 avr_size_one_stub (struct bfd_hash_entry *bh, void *in_arg)
2501 struct elf32_avr_stub_hash_entry *hsh;
2502 struct elf32_avr_link_hash_table *htab;
2505 /* Massage our args to the form they really have. */
2506 hsh = avr_stub_hash_entry (bh);
2509 if (hsh->is_actually_needed)
2514 htab->stub_sec->size += size;
2519 elf32_avr_setup_params (struct bfd_link_info *info,
2521 asection *avr_stub_section,
2522 bfd_boolean no_stubs,
2523 bfd_boolean deb_stubs,
2524 bfd_boolean deb_relax,
2525 bfd_vma pc_wrap_around,
2526 bfd_boolean call_ret_replacement)
2528 struct elf32_avr_link_hash_table *htab = avr_link_hash_table (info);
2532 htab->stub_sec = avr_stub_section;
2533 htab->stub_bfd = avr_stub_bfd;
2534 htab->no_stubs = no_stubs;
2536 debug_relax = deb_relax;
2537 debug_stubs = deb_stubs;
2538 avr_pc_wrap_around = pc_wrap_around;
2539 avr_replace_call_ret_sequences = call_ret_replacement;
2543 /* Set up various things so that we can make a list of input sections
2544 for each output section included in the link. Returns -1 on error,
2545 0 when no stubs will be needed, and 1 on success. It also sets
2546 information on the stubs bfd and the stub section in the info
2550 elf32_avr_setup_section_lists (bfd *output_bfd,
2551 struct bfd_link_info *info)
2554 unsigned int bfd_count;
2555 int top_id, top_index;
2557 asection **input_list, **list;
2559 struct elf32_avr_link_hash_table *htab = avr_link_hash_table(info);
2561 if (htab == NULL || htab->no_stubs)
2564 /* Count the number of input BFDs and find the top input section id. */
2565 for (input_bfd = info->input_bfds, bfd_count = 0, top_id = 0;
2567 input_bfd = input_bfd->link_next)
2570 for (section = input_bfd->sections;
2572 section = section->next)
2573 if (top_id < section->id)
2574 top_id = section->id;
2577 htab->bfd_count = bfd_count;
2579 /* We can't use output_bfd->section_count here to find the top output
2580 section index as some sections may have been removed, and
2581 strip_excluded_output_sections doesn't renumber the indices. */
2582 for (section = output_bfd->sections, top_index = 0;
2584 section = section->next)
2585 if (top_index < section->index)
2586 top_index = section->index;
2588 htab->top_index = top_index;
2589 amt = sizeof (asection *) * (top_index + 1);
2590 input_list = bfd_malloc (amt);
2591 htab->input_list = input_list;
2592 if (input_list == NULL)
2595 /* For sections we aren't interested in, mark their entries with a
2596 value we can check later. */
2597 list = input_list + top_index;
2599 *list = bfd_abs_section_ptr;
2600 while (list-- != input_list);
2602 for (section = output_bfd->sections;
2604 section = section->next)
2605 if ((section->flags & SEC_CODE) != 0)
2606 input_list[section->index] = NULL;
2612 /* Read in all local syms for all input bfds, and create hash entries
2613 for export stubs if we are building a multi-subspace shared lib.
2614 Returns -1 on error, 0 otherwise. */
2617 get_local_syms (bfd *input_bfd, struct bfd_link_info *info)
2619 unsigned int bfd_indx;
2620 Elf_Internal_Sym *local_syms, **all_local_syms;
2621 struct elf32_avr_link_hash_table *htab = avr_link_hash_table (info);
2627 /* We want to read in symbol extension records only once. To do this
2628 we need to read in the local symbols in parallel and save them for
2629 later use; so hold pointers to the local symbols in an array. */
2630 amt = sizeof (Elf_Internal_Sym *) * htab->bfd_count;
2631 all_local_syms = bfd_zmalloc (amt);
2632 htab->all_local_syms = all_local_syms;
2633 if (all_local_syms == NULL)
2636 /* Walk over all the input BFDs, swapping in local symbols.
2637 If we are creating a shared library, create hash entries for the
2641 input_bfd = input_bfd->link_next, bfd_indx++)
2643 Elf_Internal_Shdr *symtab_hdr;
2645 /* We'll need the symbol table in a second. */
2646 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2647 if (symtab_hdr->sh_info == 0)
2650 /* We need an array of the local symbols attached to the input bfd. */
2651 local_syms = (Elf_Internal_Sym *) symtab_hdr->contents;
2652 if (local_syms == NULL)
2654 local_syms = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
2655 symtab_hdr->sh_info, 0,
2657 /* Cache them for elf_link_input_bfd. */
2658 symtab_hdr->contents = (unsigned char *) local_syms;
2660 if (local_syms == NULL)
2663 all_local_syms[bfd_indx] = local_syms;
2669 #define ADD_DUMMY_STUBS_FOR_DEBUGGING 0
2672 elf32_avr_size_stubs (bfd *output_bfd,
2673 struct bfd_link_info *info,
2674 bfd_boolean is_prealloc_run)
2676 struct elf32_avr_link_hash_table *htab;
2677 int stub_changed = 0;
2679 htab = avr_link_hash_table (info);
2683 /* At this point we initialize htab->vector_base
2684 To the start of the text output section. */
2685 htab->vector_base = htab->stub_sec->output_section->vma;
2687 if (get_local_syms (info->input_bfds, info))
2689 if (htab->all_local_syms)
2690 goto error_ret_free_local;
2694 if (ADD_DUMMY_STUBS_FOR_DEBUGGING)
2696 struct elf32_avr_stub_hash_entry *test;
2698 test = avr_add_stub ("Hugo",htab);
2699 test->target_value = 0x123456;
2700 test->stub_offset = 13;
2702 test = avr_add_stub ("Hugo2",htab);
2703 test->target_value = 0x84210;
2704 test->stub_offset = 14;
2710 unsigned int bfd_indx;
2712 /* We will have to re-generate the stub hash table each time anything
2713 in memory has changed. */
2715 bfd_hash_traverse (&htab->bstab, avr_mark_stub_not_to_be_necessary, htab);
2716 for (input_bfd = info->input_bfds, bfd_indx = 0;
2718 input_bfd = input_bfd->link_next, bfd_indx++)
2720 Elf_Internal_Shdr *symtab_hdr;
2722 Elf_Internal_Sym *local_syms;
2724 /* We'll need the symbol table in a second. */
2725 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2726 if (symtab_hdr->sh_info == 0)
2729 local_syms = htab->all_local_syms[bfd_indx];
2731 /* Walk over each section attached to the input bfd. */
2732 for (section = input_bfd->sections;
2734 section = section->next)
2736 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
2738 /* If there aren't any relocs, then there's nothing more
2740 if ((section->flags & SEC_RELOC) == 0
2741 || section->reloc_count == 0)
2744 /* If this section is a link-once section that will be
2745 discarded, then don't create any stubs. */
2746 if (section->output_section == NULL
2747 || section->output_section->owner != output_bfd)
2750 /* Get the relocs. */
2752 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
2754 if (internal_relocs == NULL)
2755 goto error_ret_free_local;
2757 /* Now examine each relocation. */
2758 irela = internal_relocs;
2759 irelaend = irela + section->reloc_count;
2760 for (; irela < irelaend; irela++)
2762 unsigned int r_type, r_indx;
2763 struct elf32_avr_stub_hash_entry *hsh;
2766 bfd_vma destination;
2767 struct elf_link_hash_entry *hh;
2770 r_type = ELF32_R_TYPE (irela->r_info);
2771 r_indx = ELF32_R_SYM (irela->r_info);
2773 /* Only look for 16 bit GS relocs. No other reloc will need a
2775 if (!((r_type == R_AVR_16_PM)
2776 || (r_type == R_AVR_LO8_LDI_GS)
2777 || (r_type == R_AVR_HI8_LDI_GS)))
2780 /* Now determine the call target, its name, value,
2786 if (r_indx < symtab_hdr->sh_info)
2788 /* It's a local symbol. */
2789 Elf_Internal_Sym *sym;
2790 Elf_Internal_Shdr *hdr;
2793 sym = local_syms + r_indx;
2794 if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
2795 sym_value = sym->st_value;
2796 shndx = sym->st_shndx;
2797 if (shndx < elf_numsections (input_bfd))
2799 hdr = elf_elfsections (input_bfd)[shndx];
2800 sym_sec = hdr->bfd_section;
2801 destination = (sym_value + irela->r_addend
2802 + sym_sec->output_offset
2803 + sym_sec->output_section->vma);
2808 /* It's an external symbol. */
2811 e_indx = r_indx - symtab_hdr->sh_info;
2812 hh = elf_sym_hashes (input_bfd)[e_indx];
2814 while (hh->root.type == bfd_link_hash_indirect
2815 || hh->root.type == bfd_link_hash_warning)
2816 hh = (struct elf_link_hash_entry *)
2817 (hh->root.u.i.link);
2819 if (hh->root.type == bfd_link_hash_defined
2820 || hh->root.type == bfd_link_hash_defweak)
2822 sym_sec = hh->root.u.def.section;
2823 sym_value = hh->root.u.def.value;
2824 if (sym_sec->output_section != NULL)
2825 destination = (sym_value + irela->r_addend
2826 + sym_sec->output_offset
2827 + sym_sec->output_section->vma);
2829 else if (hh->root.type == bfd_link_hash_undefweak)
2834 else if (hh->root.type == bfd_link_hash_undefined)
2836 if (! (info->unresolved_syms_in_objects == RM_IGNORE
2837 && (ELF_ST_VISIBILITY (hh->other)
2843 bfd_set_error (bfd_error_bad_value);
2845 error_ret_free_internal:
2846 if (elf_section_data (section)->relocs == NULL)
2847 free (internal_relocs);
2848 goto error_ret_free_local;
2852 if (! avr_stub_is_required_for_16_bit_reloc
2853 (destination - htab->vector_base))
2855 if (!is_prealloc_run)
2856 /* We are having a reloc that does't need a stub. */
2859 /* We don't right now know if a stub will be needed.
2860 Let's rather be on the safe side. */
2863 /* Get the name of this stub. */
2864 stub_name = avr_stub_name (sym_sec, sym_value, irela);
2867 goto error_ret_free_internal;
2870 hsh = avr_stub_hash_lookup (&htab->bstab,
2875 /* The proper stub has already been created. Mark it
2876 to be used and write the possibly changed destination
2878 hsh->is_actually_needed = TRUE;
2879 hsh->target_value = destination;
2884 hsh = avr_add_stub (stub_name, htab);
2888 goto error_ret_free_internal;
2891 hsh->is_actually_needed = TRUE;
2892 hsh->target_value = destination;
2895 printf ("Adding stub with destination 0x%x to the"
2896 " hash table.\n", (unsigned int) destination);
2898 printf ("(Pre-Alloc run: %i)\n", is_prealloc_run);
2900 stub_changed = TRUE;
2903 /* We're done with the internal relocs, free them. */
2904 if (elf_section_data (section)->relocs == NULL)
2905 free (internal_relocs);
2909 /* Re-Calculate the number of needed stubs. */
2910 htab->stub_sec->size = 0;
2911 bfd_hash_traverse (&htab->bstab, avr_size_one_stub, htab);
2916 stub_changed = FALSE;
2919 free (htab->all_local_syms);
2922 error_ret_free_local:
2923 free (htab->all_local_syms);
2928 /* Build all the stubs associated with the current output file. The
2929 stubs are kept in a hash table attached to the main linker hash
2930 table. We also set up the .plt entries for statically linked PIC
2931 functions here. This function is called via hppaelf_finish in the
2935 elf32_avr_build_stubs (struct bfd_link_info *info)
2938 struct bfd_hash_table *table;
2939 struct elf32_avr_link_hash_table *htab;
2940 bfd_size_type total_size = 0;
2942 htab = avr_link_hash_table (info);
2946 /* In case that there were several stub sections: */
2947 for (stub_sec = htab->stub_bfd->sections;
2949 stub_sec = stub_sec->next)
2953 /* Allocate memory to hold the linker stubs. */
2954 size = stub_sec->size;
2957 stub_sec->contents = bfd_zalloc (htab->stub_bfd, size);
2958 if (stub_sec->contents == NULL && size != 0)
2963 /* Allocate memory for the adress mapping table. */
2964 htab->amt_entry_cnt = 0;
2965 htab->amt_max_entry_cnt = total_size / 4;
2966 htab->amt_stub_offsets = bfd_malloc (sizeof (bfd_vma)
2967 * htab->amt_max_entry_cnt);
2968 htab->amt_destination_addr = bfd_malloc (sizeof (bfd_vma)
2969 * htab->amt_max_entry_cnt );
2972 printf ("Allocating %i entries in the AMT\n", htab->amt_max_entry_cnt);
2974 /* Build the stubs as directed by the stub hash table. */
2975 table = &htab->bstab;
2976 bfd_hash_traverse (table, avr_build_one_stub, info);
2979 printf ("Final Stub section Size: %i\n", (int) htab->stub_sec->size);
2984 #define ELF_ARCH bfd_arch_avr
2985 #define ELF_MACHINE_CODE EM_AVR
2986 #define ELF_MACHINE_ALT1 EM_AVR_OLD
2987 #define ELF_MAXPAGESIZE 1
2989 #define TARGET_LITTLE_SYM bfd_elf32_avr_vec
2990 #define TARGET_LITTLE_NAME "elf32-avr"
2992 #define bfd_elf32_bfd_link_hash_table_create elf32_avr_link_hash_table_create
2993 #define bfd_elf32_bfd_link_hash_table_free elf32_avr_link_hash_table_free
2995 #define elf_info_to_howto avr_info_to_howto_rela
2996 #define elf_info_to_howto_rel NULL
2997 #define elf_backend_relocate_section elf32_avr_relocate_section
2998 #define elf_backend_check_relocs elf32_avr_check_relocs
2999 #define elf_backend_can_gc_sections 1
3000 #define elf_backend_rela_normal 1
3001 #define elf_backend_final_write_processing \
3002 bfd_elf_avr_final_write_processing
3003 #define elf_backend_object_p elf32_avr_object_p
3005 #define bfd_elf32_bfd_relax_section elf32_avr_relax_section
3006 #define bfd_elf32_bfd_get_relocated_section_contents \
3007 elf32_avr_get_relocated_section_contents
3009 #include "elf32-target.h"