?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix RELOC_FOR_GLOBAL_SYMBOLS macro so that it can cope with user defined symbols...
[binutils-gdb.git] / bfd / elf32-avr.c
blob20e03bd75885c9be409369fee168ebfa2c7bd948
1 /* AVR-specific support for 32-bit ELF
2 Copyright (C) 1999-2024 Free Software Foundation, Inc.
3 Contributed by Denis Chertykov <denisc@overta.ru>
4
5 This file is part of BFD, the Binary File Descriptor library.
6
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.
11
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.
16
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. */
21
22 #include "sysdep.h"
23 #include "bfd.h"
24 #include "libbfd.h"
25 #include "elf-bfd.h"
26 #include "elf/avr.h"
27 #include "elf32-avr.h"
28
29 /* Enable debugging printout at stdout with this variable. */
30 static bool debug_relax = false;
31
32 /* Enable debugging printout at stdout with this variable. */
33 static bool debug_stubs = false;
34
35 static bfd_reloc_status_type
36 bfd_elf_avr_diff_reloc (bfd *, arelent *, asymbol *, void *,
37 asection *, bfd *, char **);
38
39 /* Hash table initialization and handling. Code is taken from the hppa port
40 and adapted to the needs of AVR. */
41
42 /* We use two hash tables to hold information for linking avr objects.
43
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.
47
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
50 stubs. */
51
52 struct elf32_avr_stub_hash_entry
53 {
54 /* Base hash table entry structure. */
55 struct bfd_hash_entry bh_root;
56
57 /* Offset within stub_sec of the beginning of this stub. */
58 bfd_vma stub_offset;
59
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). */
62 bfd_vma target_value;
63
64 /* This way we could mark stubs to be no longer necessary. */
65 bool is_actually_needed;
66 };
67
68 struct elf32_avr_link_hash_table
69 {
70 /* The main hash table. */
71 struct elf_link_hash_table etab;
72
73 /* The stub hash table. */
74 struct bfd_hash_table bstab;
75
76 bool no_stubs;
77
78 /* Linker stub bfd. */
79 bfd *stub_bfd;
80
81 /* The stub section. */
82 asection *stub_sec;
83
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. */
87 bfd_vma vector_base;
88
89 /* Assorted information used by elf32_avr_size_stubs. */
90 unsigned int bfd_count;
91 unsigned int top_index;
92 asection ** input_list;
93 Elf_Internal_Sym ** all_local_syms;
94
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
100 useful data. */
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;
105 };
106
107 /* Various hash macros and functions. */
108 #define avr_link_hash_table(p) \
109 ((is_elf_hash_table ((p)->hash) \
110 && elf_hash_table_id (elf_hash_table (p)) == AVR_ELF_DATA) \
111 ? (struct elf32_avr_link_hash_table *) (p)->hash : NULL)
112
113 #define avr_stub_hash_entry(ent) \
114 ((struct elf32_avr_stub_hash_entry *)(ent))
115
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)))
119
120 static reloc_howto_type elf_avr_howto_table[] =
121 {
122 HOWTO (R_AVR_NONE, /* type */
123 0, /* rightshift */
124 0, /* size */
125 0, /* bitsize */
126 false, /* pc_relative */
127 0, /* bitpos */
128 complain_overflow_dont, /* complain_on_overflow */
129 bfd_elf_generic_reloc, /* special_function */
130 "R_AVR_NONE", /* name */
131 false, /* partial_inplace */
132 0, /* src_mask */
133 0, /* dst_mask */
134 false), /* pcrel_offset */
135
136 HOWTO (R_AVR_32, /* type */
137 0, /* rightshift */
138 4, /* size */
139 32, /* bitsize */
140 false, /* pc_relative */
141 0, /* bitpos */
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 */
149
150 /* A 7 bit PC relative relocation. */
151 HOWTO (R_AVR_7_PCREL, /* type */
152 1, /* rightshift */
153 2, /* size */
154 7, /* bitsize */
155 true, /* pc_relative */
156 3, /* bitpos */
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 */
164
165 /* A 13 bit PC relative relocation. */
166 HOWTO (R_AVR_13_PCREL, /* type */
167 1, /* rightshift */
168 2, /* size */
169 13, /* bitsize */
170 true, /* pc_relative */
171 0, /* bitpos */
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 */
179
180 /* A 16 bit absolute relocation. */
181 HOWTO (R_AVR_16, /* type */
182 0, /* rightshift */
183 2, /* size */
184 16, /* bitsize */
185 false, /* pc_relative */
186 0, /* bitpos */
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 */
194
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 */
198 1, /* rightshift */
199 2, /* size */
200 16, /* bitsize */
201 false, /* pc_relative */
202 0, /* bitpos */
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.
211 For LDI command. */
212 HOWTO (R_AVR_LO8_LDI, /* type */
213 0, /* rightshift */
214 2, /* size */
215 8, /* bitsize */
216 false, /* pc_relative */
217 0, /* bitpos */
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.
226 For LDI command. */
227 HOWTO (R_AVR_HI8_LDI, /* type */
228 8, /* rightshift */
229 2, /* size */
230 8, /* bitsize */
231 false, /* pc_relative */
232 0, /* bitpos */
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 */
244 16, /* rightshift */
245 2, /* size */
246 8, /* bitsize */
247 false, /* pc_relative */
248 0, /* bitpos */
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.
257 For LDI command. */
258 HOWTO (R_AVR_LO8_LDI_NEG, /* type */
259 0, /* rightshift */
260 2, /* size */
261 8, /* bitsize */
262 false, /* pc_relative */
263 0, /* bitpos */
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.
272 For LDI command. */
273 HOWTO (R_AVR_HI8_LDI_NEG, /* type */
274 8, /* rightshift */
275 2, /* size */
276 8, /* bitsize */
277 false, /* pc_relative */
278 0, /* bitpos */
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.
287 For LDI command. */
288 HOWTO (R_AVR_HH8_LDI_NEG, /* type */
289 16, /* rightshift */
290 2, /* size */
291 8, /* bitsize */
292 false, /* pc_relative */
293 0, /* bitpos */
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 */
304 1, /* rightshift */
305 2, /* size */
306 8, /* bitsize */
307 false, /* pc_relative */
308 0, /* bitpos */
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 */
319 9, /* rightshift */
320 2, /* size */
321 8, /* bitsize */
322 false, /* pc_relative */
323 0, /* bitpos */
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 */
334 17, /* rightshift */
335 2, /* size */
336 8, /* bitsize */
337 false, /* pc_relative */
338 0, /* bitpos */
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 */
349 1, /* rightshift */
350 2, /* size */
351 8, /* bitsize */
352 false, /* pc_relative */
353 0, /* bitpos */
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 */
364 9, /* rightshift */
365 2, /* size */
366 8, /* bitsize */
367 false, /* pc_relative */
368 0, /* bitpos */
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 */
379 17, /* rightshift */
380 2, /* size */
381 8, /* bitsize */
382 false, /* pc_relative */
383 0, /* bitpos */
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 */
393 1, /* rightshift */
394 4, /* size */
395 23, /* bitsize */
396 false, /* pc_relative */
397 0, /* bitpos */
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.
406 For LDI command. */
407 HOWTO (R_AVR_LDI, /* type */
408 0, /* rightshift */
409 2, /* size */
410 16, /* bitsize */
411 false, /* pc_relative */
412 0, /* bitpos */
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 */
423 0, /* rightshift */
424 1, /* size */
425 6, /* bitsize */
426 false, /* pc_relative */
427 0, /* bitpos */
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 */
438 0, /* rightshift */
439 1, /* size */
440 6, /* bitsize */
441 false, /* pc_relative */
442 0, /* bitpos */
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 */
452 24, /* rightshift */
453 2, /* size */
454 8, /* bitsize */
455 false, /* pc_relative */
456 0, /* bitpos */
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 */
466 24, /* rightshift */
467 2, /* size */
468 8, /* bitsize */
469 false, /* pc_relative */
470 0, /* bitpos */
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 */
481 1, /* rightshift */
482 2, /* size */
483 8, /* bitsize */
484 false, /* pc_relative */
485 0, /* bitpos */
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 */
496 9, /* rightshift */
497 2, /* size */
498 8, /* bitsize */
499 false, /* pc_relative */
500 0, /* bitpos */
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 */
508 /* 8 bit offset. */
509 HOWTO (R_AVR_8, /* type */
510 0, /* rightshift */
511 1, /* size */
512 8, /* bitsize */
513 false, /* pc_relative */
514 0, /* bitpos */
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 */
524 0, /* rightshift */
525 1, /* size */
526 8, /* bitsize */
527 false, /* pc_relative */
528 0, /* bitpos */
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 */
538 8, /* rightshift */
539 1, /* size */
540 8, /* bitsize */
541 false, /* pc_relative */
542 0, /* bitpos */
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 */
552 16, /* rightshift */
553 1, /* size */
554 8, /* bitsize */
555 false, /* pc_relative */
556 0, /* bitpos */
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 */
565 0, /* rightshift */
566 1, /* size */
567 8, /* bitsize */
568 false, /* pc_relative */
569 0, /* bitpos */
570 complain_overflow_bitfield, /* complain_on_overflow */
571 bfd_elf_avr_diff_reloc, /* special_function */
572 "R_AVR_DIFF8", /* name */
573 false, /* partial_inplace */
574 0, /* src_mask */
575 0xff, /* dst_mask */
576 false), /* pcrel_offset */
577 HOWTO (R_AVR_DIFF16, /* type */
578 0, /* rightshift */
579 2, /* size */
580 16, /* bitsize */
581 false, /* pc_relative */
582 0, /* bitpos */
583 complain_overflow_bitfield, /* complain_on_overflow */
584 bfd_elf_avr_diff_reloc,/* special_function */
585 "R_AVR_DIFF16", /* name */
586 false, /* partial_inplace */
587 0, /* src_mask */
588 0xffff, /* dst_mask */
589 false), /* pcrel_offset */
590 HOWTO (R_AVR_DIFF32, /* type */
591 0, /* rightshift */
592 4, /* size */
593 32, /* bitsize */
594 false, /* pc_relative */
595 0, /* bitpos */
596 complain_overflow_bitfield, /* complain_on_overflow */
597 bfd_elf_avr_diff_reloc,/* special_function */
598 "R_AVR_DIFF32", /* name */
599 false, /* partial_inplace */
600 0, /* src_mask */
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 */
605 0, /* rightshift */
606 2, /* size */
607 7, /* bitsize */
608 false, /* pc_relative */
609 0, /* bitpos */
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 */
617
618 HOWTO (R_AVR_PORT6, /* type */
619 0, /* rightshift */
620 1, /* size */
621 6, /* bitsize */
622 false, /* pc_relative */
623 0, /* bitpos */
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 */
632 0, /* rightshift */
633 1, /* size */
634 5, /* bitsize */
635 false, /* pc_relative */
636 0, /* bitpos */
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 */
644
645 /* A 32 bit PC relative relocation. */
646 HOWTO (R_AVR_32_PCREL, /* type */
647 0, /* rightshift */
648 4, /* size */
649 32, /* bitsize */
650 true, /* pc_relative */
651 0, /* bitpos */
652 complain_overflow_bitfield, /* complain_on_overflow */
653 bfd_elf_generic_reloc, /* special_function */
654 "R_AVR_32_PCREL", /* name */
655 false, /* partial_inplace */
656 0xffffffff, /* src_mask */
657 0xffffffff, /* dst_mask */
658 true), /* pcrel_offset */
659 };
660
661 /* Map BFD reloc types to AVR ELF reloc types. */
662
663 struct avr_reloc_map
664 {
665 bfd_reloc_code_real_type bfd_reloc_val;
666 unsigned int elf_reloc_val;
667 };
668
669 static const struct avr_reloc_map avr_reloc_map[] =
670 {
671 { BFD_RELOC_NONE, R_AVR_NONE },
672 { BFD_RELOC_32, R_AVR_32 },
673 { BFD_RELOC_AVR_7_PCREL, R_AVR_7_PCREL },
674 { BFD_RELOC_AVR_13_PCREL, R_AVR_13_PCREL },
675 { BFD_RELOC_16, R_AVR_16 },
676 { BFD_RELOC_AVR_16_PM, R_AVR_16_PM },
677 { BFD_RELOC_AVR_LO8_LDI, R_AVR_LO8_LDI},
678 { BFD_RELOC_AVR_HI8_LDI, R_AVR_HI8_LDI },
679 { BFD_RELOC_AVR_HH8_LDI, R_AVR_HH8_LDI },
680 { BFD_RELOC_AVR_MS8_LDI, R_AVR_MS8_LDI },
681 { BFD_RELOC_AVR_LO8_LDI_NEG, R_AVR_LO8_LDI_NEG },
682 { BFD_RELOC_AVR_HI8_LDI_NEG, R_AVR_HI8_LDI_NEG },
683 { BFD_RELOC_AVR_HH8_LDI_NEG, R_AVR_HH8_LDI_NEG },
684 { BFD_RELOC_AVR_MS8_LDI_NEG, R_AVR_MS8_LDI_NEG },
685 { BFD_RELOC_AVR_LO8_LDI_PM, R_AVR_LO8_LDI_PM },
686 { BFD_RELOC_AVR_LO8_LDI_GS, R_AVR_LO8_LDI_GS },
687 { BFD_RELOC_AVR_HI8_LDI_PM, R_AVR_HI8_LDI_PM },
688 { BFD_RELOC_AVR_HI8_LDI_GS, R_AVR_HI8_LDI_GS },
689 { BFD_RELOC_AVR_HH8_LDI_PM, R_AVR_HH8_LDI_PM },
690 { BFD_RELOC_AVR_LO8_LDI_PM_NEG, R_AVR_LO8_LDI_PM_NEG },
691 { BFD_RELOC_AVR_HI8_LDI_PM_NEG, R_AVR_HI8_LDI_PM_NEG },
692 { BFD_RELOC_AVR_HH8_LDI_PM_NEG, R_AVR_HH8_LDI_PM_NEG },
693 { BFD_RELOC_AVR_CALL, R_AVR_CALL },
694 { BFD_RELOC_AVR_LDI, R_AVR_LDI },
695 { BFD_RELOC_AVR_6, R_AVR_6 },
696 { BFD_RELOC_AVR_6_ADIW, R_AVR_6_ADIW },
697 { BFD_RELOC_8, R_AVR_8 },
698 { BFD_RELOC_AVR_8_LO, R_AVR_8_LO8 },
699 { BFD_RELOC_AVR_8_HI, R_AVR_8_HI8 },
700 { BFD_RELOC_AVR_8_HLO, R_AVR_8_HLO8 },
701 { BFD_RELOC_AVR_DIFF8, R_AVR_DIFF8 },
702 { BFD_RELOC_AVR_DIFF16, R_AVR_DIFF16 },
703 { BFD_RELOC_AVR_DIFF32, R_AVR_DIFF32 },
704 { BFD_RELOC_AVR_LDS_STS_16, R_AVR_LDS_STS_16},
705 { BFD_RELOC_AVR_PORT6, R_AVR_PORT6},
706 { BFD_RELOC_AVR_PORT5, R_AVR_PORT5},
707 { BFD_RELOC_32_PCREL, R_AVR_32_PCREL}
708 };
709
710 static const struct bfd_elf_special_section elf_avr_special_sections[] =
711 {
712 { STRING_COMMA_LEN (".noinit"), 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
713 { NULL, 0, 0, 0, 0 }
714 };
715
716 /* Meant to be filled one day with the wrap around address for the
717 specific device. I.e. should get the value 0x4000 for 16k devices,
718 0x8000 for 32k devices and so on.
719
720 We initialize it here with a value of 0x1000000 resulting in
721 that we will never suggest a wrap-around jump during relaxation.
722 The logic of the source code later on assumes that in
723 avr_pc_wrap_around one single bit is set. */
724 static bfd_vma avr_pc_wrap_around = 0x10000000;
725
726 /* If this variable holds a value different from zero, the linker relaxation
727 machine will try to optimize call/ret sequences by a single jump
728 instruction. This option could be switched off by a linker switch. */
729 static int avr_replace_call_ret_sequences = 1;
730 \f
731
732 /* Per-section relaxation related information for avr. */
733
734 struct avr_relax_info
735 {
736 /* Track the avr property records that apply to this section. */
737
738 struct
739 {
740 /* Number of records in the list. */
741 unsigned count;
742
743 /* How many records worth of space have we allocated. */
744 unsigned allocated;
745
746 /* The records, only COUNT records are initialised. */
747 struct avr_property_record *items;
748 } records;
749 };
750
751 /* Per section data, specialised for avr. */
752
753 struct elf_avr_section_data
754 {
755 /* The standard data must appear first. */
756 struct bfd_elf_section_data elf;
757
758 /* Relaxation related information. */
759 struct avr_relax_info relax_info;
760 };
761
762 /* Possibly initialise avr specific data for new section SEC from ABFD. */
763
764 static bool
765 elf_avr_new_section_hook (bfd *abfd, asection *sec)
766 {
767 if (!sec->used_by_bfd)
768 {
769 struct elf_avr_section_data *sdata;
770 size_t amt = sizeof (*sdata);
771
772 sdata = bfd_zalloc (abfd, amt);
773 if (sdata == NULL)
774 return false;
775 sec->used_by_bfd = sdata;
776 }
777
778 return _bfd_elf_new_section_hook (abfd, sec);
779 }
780
781 /* Return a pointer to the relaxation information for SEC. */
782
783 static struct avr_relax_info *
784 get_avr_relax_info (asection *sec)
785 {
786 struct elf_avr_section_data *section_data;
787
788 /* No info available if no section or if it is an output section. */
789 if (!sec || sec == sec->output_section)
790 return NULL;
791
792 section_data = (struct elf_avr_section_data *) elf_section_data (sec);
793 return &section_data->relax_info;
794 }
795
796 /* Initialise the per section relaxation information for SEC. */
797
798 static void
799 init_avr_relax_info (asection *sec)
800 {
801 struct avr_relax_info *relax_info = get_avr_relax_info (sec);
802
803 relax_info->records.count = 0;
804 relax_info->records.allocated = 0;
805 relax_info->records.items = NULL;
806 }
807
808 /* Initialize an entry in the stub hash table. */
809
810 static struct bfd_hash_entry *
811 stub_hash_newfunc (struct bfd_hash_entry *entry,
812 struct bfd_hash_table *table,
813 const char *string)
814 {
815 /* Allocate the structure if it has not already been allocated by a
816 subclass. */
817 if (entry == NULL)
818 {
819 entry = bfd_hash_allocate (table,
820 sizeof (struct elf32_avr_stub_hash_entry));
821 if (entry == NULL)
822 return entry;
823 }
824
825 /* Call the allocation method of the superclass. */
826 entry = bfd_hash_newfunc (entry, table, string);
827 if (entry != NULL)
828 {
829 struct elf32_avr_stub_hash_entry *hsh;
830
831 /* Initialize the local fields. */
832 hsh = avr_stub_hash_entry (entry);
833 hsh->stub_offset = 0;
834 hsh->target_value = 0;
835 }
836
837 return entry;
838 }
839
840 /* This function is just a straight passthrough to the real
841 function in linker.c. Its prupose is so that its address
842 can be compared inside the avr_link_hash_table macro. */
843
844 static struct bfd_hash_entry *
845 elf32_avr_link_hash_newfunc (struct bfd_hash_entry * entry,
846 struct bfd_hash_table * table,
847 const char * string)
848 {
849 return _bfd_elf_link_hash_newfunc (entry, table, string);
850 }
851
852 /* Free the derived linker hash table. */
853
854 static void
855 elf32_avr_link_hash_table_free (bfd *obfd)
856 {
857 struct elf32_avr_link_hash_table *htab
858 = (struct elf32_avr_link_hash_table *) obfd->link.hash;
859
860 /* Free the address mapping table. */
861 free (htab->amt_stub_offsets);
862 free (htab->amt_destination_addr);
863
864 bfd_hash_table_free (&htab->bstab);
865 _bfd_elf_link_hash_table_free (obfd);
866 }
867
868 /* Create the derived linker hash table. The AVR ELF port uses the derived
869 hash table to keep information specific to the AVR ELF linker (without
870 using static variables). */
871
872 static struct bfd_link_hash_table *
873 elf32_avr_link_hash_table_create (bfd *abfd)
874 {
875 struct elf32_avr_link_hash_table *htab;
876 size_t amt = sizeof (*htab);
877
878 htab = bfd_zmalloc (amt);
879 if (htab == NULL)
880 return NULL;
881
882 if (!_bfd_elf_link_hash_table_init (&htab->etab, abfd,
883 elf32_avr_link_hash_newfunc,
884 sizeof (struct elf_link_hash_entry),
885 AVR_ELF_DATA))
886 {
887 free (htab);
888 return NULL;
889 }
890
891 /* Init the stub hash table too. */
892 if (!bfd_hash_table_init (&htab->bstab, stub_hash_newfunc,
893 sizeof (struct elf32_avr_stub_hash_entry)))
894 {
895 _bfd_elf_link_hash_table_free (abfd);
896 return NULL;
897 }
898 htab->etab.root.hash_table_free = elf32_avr_link_hash_table_free;
899
900 return &htab->etab.root;
901 }
902
903 /* Calculates the effective distance of a pc relative jump/call. */
904
905 static int
906 avr_relative_distance_considering_wrap_around (unsigned int distance)
907 {
908 unsigned int wrap_around_mask = avr_pc_wrap_around - 1;
909 int dist_with_wrap_around = distance & wrap_around_mask;
910
911 if (dist_with_wrap_around >= ((int) (avr_pc_wrap_around >> 1)))
912 dist_with_wrap_around -= avr_pc_wrap_around;
913
914 return dist_with_wrap_around;
915 }
916
917
918 static reloc_howto_type *
919 bfd_elf32_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
920 bfd_reloc_code_real_type code)
921 {
922 unsigned int i;
923
924 for (i = 0;
925 i < sizeof (avr_reloc_map) / sizeof (struct avr_reloc_map);
926 i++)
927 if (avr_reloc_map[i].bfd_reloc_val == code)
928 return &elf_avr_howto_table[avr_reloc_map[i].elf_reloc_val];
929
930 return NULL;
931 }
932
933 static reloc_howto_type *
934 bfd_elf32_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
935 const char *r_name)
936 {
937 unsigned int i;
938
939 for (i = 0;
940 i < sizeof (elf_avr_howto_table) / sizeof (elf_avr_howto_table[0]);
941 i++)
942 if (elf_avr_howto_table[i].name != NULL
943 && strcasecmp (elf_avr_howto_table[i].name, r_name) == 0)
944 return &elf_avr_howto_table[i];
945
946 return NULL;
947 }
948
949 /* Set the howto pointer for an AVR ELF reloc. */
950
951 static bool
952 avr_info_to_howto_rela (bfd *abfd,
953 arelent *cache_ptr,
954 Elf_Internal_Rela *dst)
955 {
956 unsigned int r_type;
957
958 r_type = ELF32_R_TYPE (dst->r_info);
959 if (r_type >= (unsigned int) R_AVR_max)
960 {
961 /* xgettext:c-format */
962 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
963 abfd, r_type);
964 bfd_set_error (bfd_error_bad_value);
965 return false;
966 }
967 cache_ptr->howto = &elf_avr_howto_table[r_type];
968 return true;
969 }
970
971 static bool
972 avr_stub_is_required_for_16_bit_reloc (bfd_vma relocation)
973 {
974 return (relocation >= 0x020000);
975 }
976
977 /* Returns the address of the corresponding stub if there is one.
978 Returns otherwise an address above 0x020000. This function
979 could also be used, if there is no knowledge on the section where
980 the destination is found. */
981
982 static bfd_vma
983 avr_get_stub_addr (bfd_vma srel,
984 struct elf32_avr_link_hash_table *htab)
985 {
986 unsigned int sindex;
987 bfd_vma stub_sec_addr =
988 (htab->stub_sec->output_section->vma +
989 htab->stub_sec->output_offset);
990
991 for (sindex = 0; sindex < htab->amt_max_entry_cnt; sindex ++)
992 if (htab->amt_destination_addr[sindex] == srel)
993 return htab->amt_stub_offsets[sindex] + stub_sec_addr;
994
995 /* Return an address that could not be reached by 16 bit relocs. */
996 return 0x020000;
997 }
998
999 /* Perform a diff relocation. Nothing to do, as the difference value is already
1000 written into the section's contents. */
1001
1002 static bfd_reloc_status_type
1003 bfd_elf_avr_diff_reloc (bfd *abfd ATTRIBUTE_UNUSED,
1004 arelent *reloc_entry ATTRIBUTE_UNUSED,
1005 asymbol *symbol ATTRIBUTE_UNUSED,
1006 void *data ATTRIBUTE_UNUSED,
1007 asection *input_section ATTRIBUTE_UNUSED,
1008 bfd *output_bfd ATTRIBUTE_UNUSED,
1009 char **error_message ATTRIBUTE_UNUSED)
1010 {
1011 return bfd_reloc_ok;
1012 }
1013
1014
1015 /* Perform a single relocation. By default we use the standard BFD
1016 routines, but a few relocs, we have to do them ourselves. */
1017
1018 static bfd_reloc_status_type
1019 avr_final_link_relocate (reloc_howto_type * howto,
1020 bfd * input_bfd,
1021 asection * input_section,
1022 bfd_byte * contents,
1023 Elf_Internal_Rela * rel,
1024 bfd_vma relocation,
1025 struct elf32_avr_link_hash_table * htab)
1026 {
1027 bfd_reloc_status_type r = bfd_reloc_ok;
1028 bfd_vma x;
1029 bfd_signed_vma srel;
1030 bfd_signed_vma reloc_addr;
1031 bool use_stubs = false;
1032 /* Usually is 0, unless we are generating code for a bootloader. */
1033 bfd_signed_vma base_addr = htab->vector_base;
1034
1035 /* Absolute addr of the reloc in the final excecutable. */
1036 reloc_addr = rel->r_offset + input_section->output_section->vma
1037 + input_section->output_offset;
1038
1039 switch (howto->type)
1040 {
1041 case R_AVR_7_PCREL:
1042 contents += rel->r_offset;
1043 srel = (bfd_signed_vma) relocation;
1044 srel += rel->r_addend;
1045 srel -= rel->r_offset;
1046 srel -= 2; /* Branch instructions add 2 to the PC... */
1047 srel -= (input_section->output_section->vma +
1048 input_section->output_offset);
1049
1050 if (srel & 1)
1051 return bfd_reloc_other;
1052 if (srel > ((1 << 7) - 1) || (srel < - (1 << 7)))
1053 return bfd_reloc_overflow;
1054 x = bfd_get_16 (input_bfd, contents);
1055 x = (x & 0xfc07) | (((srel >> 1) * 8) & 0x3f8);
1056 bfd_put_16 (input_bfd, x, contents);
1057 break;
1058
1059 case R_AVR_13_PCREL:
1060 contents += rel->r_offset;
1061 srel = (bfd_signed_vma) relocation;
1062 srel += rel->r_addend;
1063 srel -= rel->r_offset;
1064 srel -= 2; /* Branch instructions add 2 to the PC... */
1065 srel -= (input_section->output_section->vma +
1066 input_section->output_offset);
1067
1068 if (srel & 1)
1069 return bfd_reloc_other;
1070
1071 srel = avr_relative_distance_considering_wrap_around (srel);
1072
1073 /* AVR addresses commands as words. */
1074 srel >>= 1;
1075
1076 /* Check for overflow. */
1077 if (srel < -2048 || srel > 2047)
1078 {
1079 /* Relative distance is too large. */
1080
1081 /* Always apply WRAPAROUND for avr2, avr25, and avr4. */
1082 switch (bfd_get_mach (input_bfd))
1083 {
1084 case bfd_mach_avr2:
1085 case bfd_mach_avr25:
1086 case bfd_mach_avr4:
1087 break;
1088
1089 default:
1090 return bfd_reloc_overflow;
1091 }
1092 }
1093
1094 x = bfd_get_16 (input_bfd, contents);
1095 x = (x & 0xf000) | (srel & 0xfff);
1096 bfd_put_16 (input_bfd, x, contents);
1097 break;
1098
1099 case R_AVR_LO8_LDI:
1100 contents += rel->r_offset;
1101 srel = (bfd_signed_vma) relocation + rel->r_addend;
1102 x = bfd_get_16 (input_bfd, contents);
1103 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1104 bfd_put_16 (input_bfd, x, contents);
1105 break;
1106
1107 case R_AVR_LDI:
1108 contents += rel->r_offset;
1109 srel = (bfd_signed_vma) relocation + rel->r_addend;
1110 if (((srel > 0) && (srel & 0xffff) > 255)
1111 || ((srel < 0) && ((-srel) & 0xffff) > 128))
1112 /* Remove offset for data/eeprom section. */
1113 return bfd_reloc_overflow;
1114
1115 x = bfd_get_16 (input_bfd, contents);
1116 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1117 bfd_put_16 (input_bfd, x, contents);
1118 break;
1119
1120 case R_AVR_6:
1121 contents += rel->r_offset;
1122 srel = (bfd_signed_vma) relocation + rel->r_addend;
1123 if (((srel & 0xffff) > 63) || (srel < 0))
1124 /* Remove offset for data/eeprom section. */
1125 return bfd_reloc_overflow;
1126 x = bfd_get_16 (input_bfd, contents);
1127 x = (x & 0xd3f8) | ((srel & 7) | ((srel & (3 << 3)) << 7)
1128 | ((srel & (1 << 5)) << 8));
1129 bfd_put_16 (input_bfd, x, contents);
1130 break;
1131
1132 case R_AVR_6_ADIW:
1133 contents += rel->r_offset;
1134 srel = (bfd_signed_vma) relocation + rel->r_addend;
1135 if (((srel & 0xffff) > 63) || (srel < 0))
1136 /* Remove offset for data/eeprom section. */
1137 return bfd_reloc_overflow;
1138 x = bfd_get_16 (input_bfd, contents);
1139 x = (x & 0xff30) | (srel & 0xf) | ((srel & 0x30) << 2);
1140 bfd_put_16 (input_bfd, x, contents);
1141 break;
1142
1143 case R_AVR_HI8_LDI:
1144 contents += rel->r_offset;
1145 srel = (bfd_signed_vma) relocation + rel->r_addend;
1146 srel = (srel >> 8) & 0xff;
1147 x = bfd_get_16 (input_bfd, contents);
1148 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1149 bfd_put_16 (input_bfd, x, contents);
1150 break;
1151
1152 case R_AVR_HH8_LDI:
1153 contents += rel->r_offset;
1154 srel = (bfd_signed_vma) relocation + rel->r_addend;
1155 srel = (srel >> 16) & 0xff;
1156 x = bfd_get_16 (input_bfd, contents);
1157 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1158 bfd_put_16 (input_bfd, x, contents);
1159 break;
1160
1161 case R_AVR_MS8_LDI:
1162 contents += rel->r_offset;
1163 srel = (bfd_signed_vma) relocation + rel->r_addend;
1164 srel = (srel >> 24) & 0xff;
1165 x = bfd_get_16 (input_bfd, contents);
1166 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1167 bfd_put_16 (input_bfd, x, contents);
1168 break;
1169
1170 case R_AVR_LO8_LDI_NEG:
1171 contents += rel->r_offset;
1172 srel = (bfd_signed_vma) relocation + rel->r_addend;
1173 srel = -srel;
1174 x = bfd_get_16 (input_bfd, contents);
1175 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1176 bfd_put_16 (input_bfd, x, contents);
1177 break;
1178
1179 case R_AVR_HI8_LDI_NEG:
1180 contents += rel->r_offset;
1181 srel = (bfd_signed_vma) relocation + rel->r_addend;
1182 srel = -srel;
1183 srel = (srel >> 8) & 0xff;
1184 x = bfd_get_16 (input_bfd, contents);
1185 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1186 bfd_put_16 (input_bfd, x, contents);
1187 break;
1188
1189 case R_AVR_HH8_LDI_NEG:
1190 contents += rel->r_offset;
1191 srel = (bfd_signed_vma) relocation + rel->r_addend;
1192 srel = -srel;
1193 srel = (srel >> 16) & 0xff;
1194 x = bfd_get_16 (input_bfd, contents);
1195 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1196 bfd_put_16 (input_bfd, x, contents);
1197 break;
1198
1199 case R_AVR_MS8_LDI_NEG:
1200 contents += rel->r_offset;
1201 srel = (bfd_signed_vma) relocation + rel->r_addend;
1202 srel = -srel;
1203 srel = (srel >> 24) & 0xff;
1204 x = bfd_get_16 (input_bfd, contents);
1205 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1206 bfd_put_16 (input_bfd, x, contents);
1207 break;
1208
1209 case R_AVR_LO8_LDI_GS:
1210 use_stubs = (!htab->no_stubs);
1211 /* Fall through. */
1212 case R_AVR_LO8_LDI_PM:
1213 contents += rel->r_offset;
1214 srel = (bfd_signed_vma) relocation + rel->r_addend;
1215
1216 if (use_stubs
1217 && avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1218 {
1219 bfd_vma old_srel = srel;
1220
1221 /* We need to use the address of the stub instead. */
1222 srel = avr_get_stub_addr (srel, htab);
1223 if (debug_stubs)
1224 printf ("LD: Using jump stub (at 0x%x) with destination 0x%x for "
1225 "reloc at address 0x%x.\n",
1226 (unsigned int) srel,
1227 (unsigned int) old_srel,
1228 (unsigned int) reloc_addr);
1229
1230 if (avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1231 return bfd_reloc_overflow;
1232 }
1233
1234 if (srel & 1)
1235 return bfd_reloc_other;
1236 srel = srel >> 1;
1237 x = bfd_get_16 (input_bfd, contents);
1238 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1239 bfd_put_16 (input_bfd, x, contents);
1240 break;
1241
1242 case R_AVR_HI8_LDI_GS:
1243 use_stubs = (!htab->no_stubs);
1244 /* Fall through. */
1245 case R_AVR_HI8_LDI_PM:
1246 contents += rel->r_offset;
1247 srel = (bfd_signed_vma) relocation + rel->r_addend;
1248
1249 if (use_stubs
1250 && avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1251 {
1252 bfd_vma old_srel = srel;
1253
1254 /* We need to use the address of the stub instead. */
1255 srel = avr_get_stub_addr (srel, htab);
1256 if (debug_stubs)
1257 printf ("LD: Using jump stub (at 0x%x) with destination 0x%x for "
1258 "reloc at address 0x%x.\n",
1259 (unsigned int) srel,
1260 (unsigned int) old_srel,
1261 (unsigned int) reloc_addr);
1262
1263 if (avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1264 return bfd_reloc_overflow;
1265 }
1266
1267 if (srel & 1)
1268 return bfd_reloc_other;
1269 srel = srel >> 1;
1270 srel = (srel >> 8) & 0xff;
1271 x = bfd_get_16 (input_bfd, contents);
1272 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1273 bfd_put_16 (input_bfd, x, contents);
1274 break;
1275
1276 case R_AVR_HH8_LDI_PM:
1277 contents += rel->r_offset;
1278 srel = (bfd_signed_vma) relocation + rel->r_addend;
1279 if (srel & 1)
1280 return bfd_reloc_other;
1281 srel = srel >> 1;
1282 srel = (srel >> 16) & 0xff;
1283 x = bfd_get_16 (input_bfd, contents);
1284 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1285 bfd_put_16 (input_bfd, x, contents);
1286 break;
1287
1288 case R_AVR_LO8_LDI_PM_NEG:
1289 contents += rel->r_offset;
1290 srel = (bfd_signed_vma) relocation + rel->r_addend;
1291 srel = -srel;
1292 if (srel & 1)
1293 return bfd_reloc_other;
1294 srel = srel >> 1;
1295 x = bfd_get_16 (input_bfd, contents);
1296 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1297 bfd_put_16 (input_bfd, x, contents);
1298 break;
1299
1300 case R_AVR_HI8_LDI_PM_NEG:
1301 contents += rel->r_offset;
1302 srel = (bfd_signed_vma) relocation + rel->r_addend;
1303 srel = -srel;
1304 if (srel & 1)
1305 return bfd_reloc_other;
1306 srel = srel >> 1;
1307 srel = (srel >> 8) & 0xff;
1308 x = bfd_get_16 (input_bfd, contents);
1309 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1310 bfd_put_16 (input_bfd, x, contents);
1311 break;
1312
1313 case R_AVR_HH8_LDI_PM_NEG:
1314 contents += rel->r_offset;
1315 srel = (bfd_signed_vma) relocation + rel->r_addend;
1316 srel = -srel;
1317 if (srel & 1)
1318 return bfd_reloc_other;
1319 srel = srel >> 1;
1320 srel = (srel >> 16) & 0xff;
1321 x = bfd_get_16 (input_bfd, contents);
1322 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
1323 bfd_put_16 (input_bfd, x, contents);
1324 break;
1325
1326 case R_AVR_CALL:
1327 contents += rel->r_offset;
1328 srel = (bfd_signed_vma) relocation + rel->r_addend;
1329 if (srel & 1)
1330 return bfd_reloc_other;
1331 srel = srel >> 1;
1332 x = bfd_get_16 (input_bfd, contents);
1333 x |= ((srel & 0x10000) | ((srel << 3) & 0x1f00000)) >> 16;
1334 bfd_put_16 (input_bfd, x, contents);
1335 bfd_put_16 (input_bfd, (bfd_vma) srel & 0xffff, contents+2);
1336 break;
1337
1338 case R_AVR_16_PM:
1339 use_stubs = (!htab->no_stubs);
1340 contents += rel->r_offset;
1341 srel = (bfd_signed_vma) relocation + rel->r_addend;
1342
1343 if (use_stubs
1344 && avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1345 {
1346 bfd_vma old_srel = srel;
1347
1348 /* We need to use the address of the stub instead. */
1349 srel = avr_get_stub_addr (srel,htab);
1350 if (debug_stubs)
1351 printf ("LD: Using jump stub (at 0x%x) with destination 0x%x for "
1352 "reloc at address 0x%x.\n",
1353 (unsigned int) srel,
1354 (unsigned int) old_srel,
1355 (unsigned int) reloc_addr);
1356
1357 if (avr_stub_is_required_for_16_bit_reloc (srel - base_addr))
1358 return bfd_reloc_overflow;
1359 }
1360
1361 if (srel & 1)
1362 return bfd_reloc_other;
1363 srel = srel >> 1;
1364 bfd_put_16 (input_bfd, (bfd_vma) srel &0x00ffff, contents);
1365 break;
1366
1367 case R_AVR_DIFF8:
1368 case R_AVR_DIFF16:
1369 case R_AVR_DIFF32:
1370 /* Nothing to do here, as contents already contains the diff value. */
1371 r = bfd_reloc_ok;
1372 break;
1373
1374 case R_AVR_LDS_STS_16:
1375 contents += rel->r_offset;
1376 srel = (bfd_signed_vma) relocation + rel->r_addend;
1377 if ((srel & 0xFFFF) < 0x40 || (srel & 0xFFFF) > 0xbf)
1378 return bfd_reloc_overflow;
1379 srel = srel & 0x7f;
1380 x = bfd_get_16 (input_bfd, contents);
1381 x |= (srel & 0x0f) | ((srel & 0x30) << 5) | ((srel & 0x40) << 2);
1382 bfd_put_16 (input_bfd, x, contents);
1383 break;
1384
1385 case R_AVR_PORT6:
1386 contents += rel->r_offset;
1387 srel = (bfd_signed_vma) relocation + rel->r_addend;
1388 if ((srel & 0xffff) > 0x3f)
1389 return bfd_reloc_overflow;
1390 x = bfd_get_16 (input_bfd, contents);
1391 x = (x & 0xf9f0) | ((srel & 0x30) << 5) | (srel & 0x0f);
1392 bfd_put_16 (input_bfd, x, contents);
1393 break;
1394
1395 case R_AVR_PORT5:
1396 contents += rel->r_offset;
1397 srel = (bfd_signed_vma) relocation + rel->r_addend;
1398 if ((srel & 0xffff) > 0x1f)
1399 return bfd_reloc_overflow;
1400 x = bfd_get_16 (input_bfd, contents);
1401 x = (x & 0xff07) | ((srel & 0x1f) << 3);
1402 bfd_put_16 (input_bfd, x, contents);
1403 break;
1404
1405 default:
1406 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1407 contents, rel->r_offset,
1408 relocation, rel->r_addend);
1409 }
1410
1411 return r;
1412 }
1413
1414 /* Relocate an AVR ELF section. */
1415
1416 static int
1417 elf32_avr_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED,
1418 struct bfd_link_info *info,
1419 bfd *input_bfd,
1420 asection *input_section,
1421 bfd_byte *contents,
1422 Elf_Internal_Rela *relocs,
1423 Elf_Internal_Sym *local_syms,
1424 asection **local_sections)
1425 {
1426 Elf_Internal_Shdr * symtab_hdr;
1427 struct elf_link_hash_entry ** sym_hashes;
1428 Elf_Internal_Rela * rel;
1429 Elf_Internal_Rela * relend;
1430 struct elf32_avr_link_hash_table * htab = avr_link_hash_table (info);
1431
1432 if (htab == NULL)
1433 return false;
1434
1435 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
1436 sym_hashes = elf_sym_hashes (input_bfd);
1437 relend = relocs + input_section->reloc_count;
1438
1439 for (rel = relocs; rel < relend; rel ++)
1440 {
1441 reloc_howto_type * howto;
1442 unsigned long r_symndx;
1443 Elf_Internal_Sym * sym;
1444 asection * sec;
1445 struct elf_link_hash_entry * h;
1446 bfd_vma relocation;
1447 bfd_reloc_status_type r;
1448 const char * name;
1449 int r_type;
1450
1451 r_type = ELF32_R_TYPE (rel->r_info);
1452 r_symndx = ELF32_R_SYM (rel->r_info);
1453 howto = elf_avr_howto_table + r_type;
1454 h = NULL;
1455 sym = NULL;
1456 sec = NULL;
1457
1458 if (r_symndx < symtab_hdr->sh_info)
1459 {
1460 sym = local_syms + r_symndx;
1461 sec = local_sections [r_symndx];
1462 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1463
1464 name = bfd_elf_string_from_elf_section
1465 (input_bfd, symtab_hdr->sh_link, sym->st_name);
1466 name = name == NULL ? bfd_section_name (sec) : name;
1467 }
1468 else
1469 {
1470 bool unresolved_reloc, warned, ignored;
1471
1472 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1473 r_symndx, symtab_hdr, sym_hashes,
1474 h, sec, relocation,
1475 unresolved_reloc, warned, ignored);
1476
1477 name = h->root.root.string;
1478 }
1479
1480 if (sec != NULL && discarded_section (sec))
1481 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
1482 rel, 1, relend, howto, 0, contents);
1483
1484 if (bfd_link_relocatable (info))
1485 continue;
1486
1487 r = avr_final_link_relocate (howto, input_bfd, input_section,
1488 contents, rel, relocation, htab);
1489
1490 if (r != bfd_reloc_ok)
1491 {
1492 switch (r)
1493 {
1494 case bfd_reloc_overflow:
1495 (*info->callbacks->reloc_overflow)
1496 (info, (h ? &h->root : NULL), name, howto->name,
1497 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
1498 break;
1499
1500 case bfd_reloc_undefined:
1501 (*info->callbacks->undefined_symbol)
1502 (info, name, input_bfd, input_section, rel->r_offset, true);
1503 break;
1504
1505 case bfd_reloc_outofrange:
1506 /* xgettext:c-format */
1507 (*info->callbacks->einfo)
1508 (_("%X%H: %s against `%s':"
1509 " error: relocation applies outside section\n"),
1510 input_bfd, input_section, rel->r_offset, howto->name, name);
1511 break;
1512
1513 case bfd_reloc_other:
1514 /* xgettext:c-format */
1515 (*info->callbacks->einfo)
1516 (_("%X%H: %s against `%s':"
1517 " error: relocation target address is odd\n"),
1518 input_bfd, input_section, rel->r_offset, howto->name, name);
1519 break;
1520
1521 default:
1522 /* xgettext:c-format */
1523 (*info->callbacks->einfo)
1524 (_("%X%H: %s against `%s':"
1525 " internal error: unexpected relocation result %d\n"),
1526 input_bfd, input_section, rel->r_offset, howto->name, name, r);
1527 break;
1528 }
1529 }
1530 }
1531
1532 return true;
1533 }
1534
1535 /* The final processing done just before writing out a AVR ELF object
1536 file. This gets the AVR architecture right based on the machine
1537 number. */
1538
1539 static bool
1540 bfd_elf_avr_final_write_processing (bfd *abfd)
1541 {
1542 unsigned long val;
1543
1544 switch (bfd_get_mach (abfd))
1545 {
1546 default:
1547 case bfd_mach_avr2:
1548 val = E_AVR_MACH_AVR2;
1549 break;
1550
1551 case bfd_mach_avr1:
1552 val = E_AVR_MACH_AVR1;
1553 break;
1554
1555 case bfd_mach_avr25:
1556 val = E_AVR_MACH_AVR25;
1557 break;
1558
1559 case bfd_mach_avr3:
1560 val = E_AVR_MACH_AVR3;
1561 break;
1562
1563 case bfd_mach_avr31:
1564 val = E_AVR_MACH_AVR31;
1565 break;
1566
1567 case bfd_mach_avr35:
1568 val = E_AVR_MACH_AVR35;
1569 break;
1570
1571 case bfd_mach_avr4:
1572 val = E_AVR_MACH_AVR4;
1573 break;
1574
1575 case bfd_mach_avr5:
1576 val = E_AVR_MACH_AVR5;
1577 break;
1578
1579 case bfd_mach_avr51:
1580 val = E_AVR_MACH_AVR51;
1581 break;
1582
1583 case bfd_mach_avr6:
1584 val = E_AVR_MACH_AVR6;
1585 break;
1586
1587 case bfd_mach_avrxmega1:
1588 val = E_AVR_MACH_XMEGA1;
1589 break;
1590
1591 case bfd_mach_avrxmega2:
1592 val = E_AVR_MACH_XMEGA2;
1593 break;
1594
1595 case bfd_mach_avrxmega3:
1596 val = E_AVR_MACH_XMEGA3;
1597 break;
1598
1599 case bfd_mach_avrxmega4:
1600 val = E_AVR_MACH_XMEGA4;
1601 break;
1602
1603 case bfd_mach_avrxmega5:
1604 val = E_AVR_MACH_XMEGA5;
1605 break;
1606
1607 case bfd_mach_avrxmega6:
1608 val = E_AVR_MACH_XMEGA6;
1609 break;
1610
1611 case bfd_mach_avrxmega7:
1612 val = E_AVR_MACH_XMEGA7;
1613 break;
1614
1615 case bfd_mach_avrtiny:
1616 val = E_AVR_MACH_AVRTINY;
1617 break;
1618 }
1619
1620 elf_elfheader (abfd)->e_machine = EM_AVR;
1621 elf_elfheader (abfd)->e_flags &= ~ EF_AVR_MACH;
1622 elf_elfheader (abfd)->e_flags |= val;
1623 return _bfd_elf_final_write_processing (abfd);
1624 }
1625
1626 /* Set the right machine number. */
1627
1628 static bool
1629 elf32_avr_object_p (bfd *abfd)
1630 {
1631 unsigned int e_set = bfd_mach_avr2;
1632
1633 if (elf_elfheader (abfd)->e_machine == EM_AVR
1634 || elf_elfheader (abfd)->e_machine == EM_AVR_OLD)
1635 {
1636 int e_mach = elf_elfheader (abfd)->e_flags & EF_AVR_MACH;
1637
1638 switch (e_mach)
1639 {
1640 default:
1641 case E_AVR_MACH_AVR2:
1642 e_set = bfd_mach_avr2;
1643 break;
1644
1645 case E_AVR_MACH_AVR1:
1646 e_set = bfd_mach_avr1;
1647 break;
1648
1649 case E_AVR_MACH_AVR25:
1650 e_set = bfd_mach_avr25;
1651 break;
1652
1653 case E_AVR_MACH_AVR3:
1654 e_set = bfd_mach_avr3;
1655 break;
1656
1657 case E_AVR_MACH_AVR31:
1658 e_set = bfd_mach_avr31;
1659 break;
1660
1661 case E_AVR_MACH_AVR35:
1662 e_set = bfd_mach_avr35;
1663 break;
1664
1665 case E_AVR_MACH_AVR4:
1666 e_set = bfd_mach_avr4;
1667 break;
1668
1669 case E_AVR_MACH_AVR5:
1670 e_set = bfd_mach_avr5;
1671 break;
1672
1673 case E_AVR_MACH_AVR51:
1674 e_set = bfd_mach_avr51;
1675 break;
1676
1677 case E_AVR_MACH_AVR6:
1678 e_set = bfd_mach_avr6;
1679 break;
1680
1681 case E_AVR_MACH_XMEGA1:
1682 e_set = bfd_mach_avrxmega1;
1683 break;
1684
1685 case E_AVR_MACH_XMEGA2:
1686 e_set = bfd_mach_avrxmega2;
1687 break;
1688
1689 case E_AVR_MACH_XMEGA3:
1690 e_set = bfd_mach_avrxmega3;
1691 break;
1692
1693 case E_AVR_MACH_XMEGA4:
1694 e_set = bfd_mach_avrxmega4;
1695 break;
1696
1697 case E_AVR_MACH_XMEGA5:
1698 e_set = bfd_mach_avrxmega5;
1699 break;
1700
1701 case E_AVR_MACH_XMEGA6:
1702 e_set = bfd_mach_avrxmega6;
1703 break;
1704
1705 case E_AVR_MACH_XMEGA7:
1706 e_set = bfd_mach_avrxmega7;
1707 break;
1708
1709 case E_AVR_MACH_AVRTINY:
1710 e_set = bfd_mach_avrtiny;
1711 break;
1712 }
1713 }
1714 return bfd_default_set_arch_mach (abfd, bfd_arch_avr,
1715 e_set);
1716 }
1717
1718 /* Returns whether the relocation type passed is a diff reloc. */
1719
1720 static bool
1721 elf32_avr_is_diff_reloc (Elf_Internal_Rela *irel)
1722 {
1723 return (ELF32_R_TYPE (irel->r_info) == R_AVR_DIFF8
1724 ||ELF32_R_TYPE (irel->r_info) == R_AVR_DIFF16
1725 || ELF32_R_TYPE (irel->r_info) == R_AVR_DIFF32);
1726 }
1727
1728 /* Reduce the diff value written in the section by count if the shrinked
1729 insn address happens to fall between the two symbols for which this
1730 diff reloc was emitted. */
1731
1732 static void
1733 elf32_avr_adjust_diff_reloc_value (bfd *abfd,
1734 struct bfd_section *isec,
1735 Elf_Internal_Rela *irel,
1736 bfd_vma symval,
1737 bfd_vma shrinked_insn_address,
1738 int count)
1739 {
1740 unsigned char *reloc_contents = NULL;
1741 unsigned char *isec_contents = elf_section_data (isec)->this_hdr.contents;
1742 if (isec_contents == NULL)
1743 {
1744 if (! bfd_malloc_and_get_section (abfd, isec, &isec_contents))
1745 return;
1746
1747 elf_section_data (isec)->this_hdr.contents = isec_contents;
1748 }
1749
1750 reloc_contents = isec_contents + irel->r_offset;
1751
1752 /* Read value written in object file. */
1753 bfd_signed_vma x = 0;
1754 switch (ELF32_R_TYPE (irel->r_info))
1755 {
1756 case R_AVR_DIFF8:
1757 {
1758 x = bfd_get_signed_8 (abfd, reloc_contents);
1759 break;
1760 }
1761 case R_AVR_DIFF16:
1762 {
1763 x = bfd_get_signed_16 (abfd, reloc_contents);
1764 break;
1765 }
1766 case R_AVR_DIFF32:
1767 {
1768 x = bfd_get_signed_32 (abfd, reloc_contents);
1769 break;
1770 }
1771 default:
1772 {
1773 BFD_FAIL();
1774 }
1775 }
1776
1777 /* For a diff reloc sym1 - sym2 the diff at assembly time (x) is written
1778 into the object file at the reloc offset. sym2's logical value is
1779 symval (<start_of_section>) + reloc addend. Compute the start and end
1780 addresses and check if the shrinked insn falls between sym1 and sym2. */
1781
1782 bfd_vma sym2_address = symval + irel->r_addend;
1783 bfd_vma sym1_address = sym2_address - x;
1784
1785 /* Don't assume sym2 is bigger than sym1 - the difference
1786 could be negative. Compute start and end addresses, and
1787 use those to see if they span shrinked_insn_address. */
1788
1789 bfd_vma start_address = sym1_address < sym2_address
1790 ? sym1_address : sym2_address;
1791 bfd_vma end_address = sym1_address > sym2_address
1792 ? sym1_address : sym2_address;
1793
1794
1795 if (shrinked_insn_address >= start_address
1796 && shrinked_insn_address < end_address)
1797 {
1798 /* Reduce the diff value by count bytes and write it back into section
1799 contents. */
1800 bfd_signed_vma new_diff = x < 0 ? x + count : x - count;
1801
1802 if (sym2_address > shrinked_insn_address)
1803 irel->r_addend -= count;
1804
1805 switch (ELF32_R_TYPE (irel->r_info))
1806 {
1807 case R_AVR_DIFF8:
1808 {
1809 bfd_put_signed_8 (abfd, new_diff, reloc_contents);
1810 break;
1811 }
1812 case R_AVR_DIFF16:
1813 {
1814 bfd_put_signed_16 (abfd, new_diff & 0xFFFF, reloc_contents);
1815 break;
1816 }
1817 case R_AVR_DIFF32:
1818 {
1819 bfd_put_signed_32 (abfd, new_diff & 0xFFFFFFFF, reloc_contents);
1820 break;
1821 }
1822 default:
1823 {
1824 BFD_FAIL();
1825 }
1826 }
1827
1828 }
1829 }
1830
1831 static void
1832 elf32_avr_adjust_reloc_if_spans_insn (bfd *abfd,
1833 asection *isec,
1834 Elf_Internal_Rela *irel, bfd_vma symval,
1835 bfd_vma shrinked_insn_address,
1836 bfd_vma shrink_boundary,
1837 int count)
1838 {
1839
1840 if (elf32_avr_is_diff_reloc (irel))
1841 {
1842 elf32_avr_adjust_diff_reloc_value (abfd, isec, irel,
1843 symval,
1844 shrinked_insn_address,
1845 count);
1846 }
1847 else
1848 {
1849 bfd_vma reloc_value = symval + irel->r_addend;
1850 bool addend_within_shrink_boundary = reloc_value <= shrink_boundary;
1851
1852 bool reloc_spans_insn =
1853 (symval <= shrinked_insn_address
1854 && reloc_value > shrinked_insn_address
1855 && addend_within_shrink_boundary);
1856
1857 if (! reloc_spans_insn)
1858 return;
1859
1860 irel->r_addend -= count;
1861
1862 if (debug_relax)
1863 printf ("Relocation's addend needed to be fixed \n");
1864 }
1865 }
1866
1867 static bool
1868 avr_should_move_sym (symvalue symval,
1869 bfd_vma start,
1870 bfd_vma end,
1871 bool did_pad)
1872 {
1873 bool sym_within_boundary = did_pad ? symval < end : symval <= end;
1874 return (symval > start && sym_within_boundary);
1875 }
1876
1877 static bool
1878 avr_should_reduce_sym_size (symvalue symval,
1879 symvalue symend,
1880 bfd_vma start,
1881 bfd_vma end,
1882 bool did_pad)
1883 {
1884 bool sym_end_within_boundary = did_pad ? symend < end : symend <= end;
1885 return (symval <= start && symend > start && sym_end_within_boundary);
1886 }
1887
1888 static bool
1889 avr_should_increase_sym_size (symvalue symval,
1890 symvalue symend,
1891 bfd_vma start,
1892 bfd_vma end,
1893 bool did_pad)
1894 {
1895 return (avr_should_move_sym (symval, start, end, did_pad)
1896 && symend >= end && did_pad);
1897 }
1898
1899 /* Delete some bytes from a section while changing the size of an instruction.
1900 The parameter "addr" denotes the section-relative offset pointing just
1901 behind the shrinked instruction. "addr+count" point at the first
1902 byte just behind the original unshrinked instruction. If delete_shrinks_insn
1903 is FALSE, we are deleting redundant padding bytes from relax_info prop
1904 record handling. In that case, addr is section-relative offset of start
1905 of padding, and count is the number of padding bytes to delete. */
1906
1907 static bool
1908 elf32_avr_relax_delete_bytes (bfd *abfd,
1909 asection *sec,
1910 bfd_vma addr,
1911 int count,
1912 bool delete_shrinks_insn)
1913 {
1914 Elf_Internal_Shdr *symtab_hdr;
1915 unsigned int sec_shndx;
1916 bfd_byte *contents;
1917 Elf_Internal_Rela *irel, *irelend;
1918 Elf_Internal_Sym *isym;
1919 Elf_Internal_Sym *isymbuf = NULL;
1920 bfd_vma toaddr;
1921 struct elf_link_hash_entry **sym_hashes;
1922 struct elf_link_hash_entry **end_hashes;
1923 unsigned int symcount;
1924 struct avr_relax_info *relax_info;
1925 struct avr_property_record *prop_record = NULL;
1926 bool did_shrink = false;
1927 bool did_pad = false;
1928
1929 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1930 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1931 contents = elf_section_data (sec)->this_hdr.contents;
1932 relax_info = get_avr_relax_info (sec);
1933
1934 toaddr = sec->size;
1935
1936 if (relax_info->records.count > 0)
1937 {
1938 /* There should be no property record within the range of deleted
1939 bytes, however, there might be a property record for ADDR, this is
1940 how we handle alignment directives.
1941 Find the next (if any) property record after the deleted bytes. */
1942 unsigned int i;
1943
1944 for (i = 0; i < relax_info->records.count; ++i)
1945 {
1946 bfd_vma offset = relax_info->records.items [i].offset;
1947
1948 BFD_ASSERT (offset <= addr || offset >= (addr + count));
1949 if (offset >= (addr + count))
1950 {
1951 prop_record = &relax_info->records.items [i];
1952 toaddr = offset;
1953 break;
1954 }
1955 }
1956 }
1957
1958 irel = elf_section_data (sec)->relocs;
1959 irelend = irel + sec->reloc_count;
1960
1961 /* Actually delete the bytes. */
1962 if (toaddr - addr - count > 0)
1963 {
1964 memmove (contents + addr, contents + addr + count,
1965 (size_t) (toaddr - addr - count));
1966 did_shrink = true;
1967 }
1968 if (prop_record == NULL)
1969 {
1970 sec->size -= count;
1971 did_shrink = true;
1972 }
1973 else
1974 {
1975 /* Use the property record to fill in the bytes we've opened up. */
1976 int fill = 0;
1977 switch (prop_record->type)
1978 {
1979 case RECORD_ORG_AND_FILL:
1980 fill = prop_record->data.org.fill;
1981 /* Fall through. */
1982 case RECORD_ORG:
1983 break;
1984 case RECORD_ALIGN_AND_FILL:
1985 fill = prop_record->data.align.fill;
1986 /* Fall through. */
1987 case RECORD_ALIGN:
1988 prop_record->data.align.preceding_deleted += count;
1989 break;
1990 };
1991 /* If toaddr == (addr + count), then we didn't delete anything, yet
1992 we fill count bytes backwards from toaddr. This is still ok - we
1993 end up overwriting the bytes we would have deleted. We just need
1994 to remember we didn't delete anything i.e. don't set did_shrink,
1995 so that we don't corrupt reloc offsets or symbol values.*/
1996 memset (contents + toaddr - count, fill, count);
1997 did_pad = true;
1998 }
1999
2000 if (!did_shrink)
2001 return true;
2002
2003 /* Adjust all the reloc addresses. */
2004 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
2005 {
2006 bfd_vma old_reloc_address;
2007
2008 old_reloc_address = (sec->output_section->vma
2009 + sec->output_offset + irel->r_offset);
2010
2011 /* Get the new reloc address. */
2012 if ((irel->r_offset > addr
2013 && irel->r_offset < toaddr))
2014 {
2015 if (debug_relax)
2016 printf ("Relocation at address 0x%x needs to be moved.\n"
2017 "Old section offset: 0x%x, New section offset: 0x%x \n",
2018 (unsigned int) old_reloc_address,
2019 (unsigned int) irel->r_offset,
2020 (unsigned int) ((irel->r_offset) - count));
2021
2022 irel->r_offset -= count;
2023 }
2024
2025 }
2026
2027 /* The reloc's own addresses are now ok. However, we need to readjust
2028 the reloc's addend, i.e. the reloc's value if two conditions are met:
2029 1.) the reloc is relative to a symbol in this section that
2030 is located in front of the shrinked instruction
2031 2.) symbol plus addend end up behind the shrinked instruction.
2032
2033 The most common case where this happens are relocs relative to
2034 the section-start symbol.
2035
2036 This step needs to be done for all of the sections of the bfd. */
2037
2038 {
2039 struct bfd_section *isec;
2040
2041 for (isec = abfd->sections; isec; isec = isec->next)
2042 {
2043 bfd_vma symval;
2044 bfd_vma shrinked_insn_address;
2045
2046 if (isec->reloc_count == 0)
2047 continue;
2048
2049 shrinked_insn_address = (sec->output_section->vma
2050 + sec->output_offset + addr);
2051 if (delete_shrinks_insn)
2052 shrinked_insn_address -= count;
2053
2054 irel = elf_section_data (isec)->relocs;
2055 /* PR 12161: Read in the relocs for this section if necessary. */
2056 if (irel == NULL)
2057 irel = _bfd_elf_link_read_relocs (abfd, isec, NULL, NULL, true);
2058
2059 for (irelend = irel + isec->reloc_count;
2060 irel < irelend;
2061 irel++)
2062 {
2063 /* Read this BFD's local symbols if we haven't done
2064 so already. */
2065 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
2066 {
2067 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2068 if (isymbuf == NULL)
2069 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
2070 symtab_hdr->sh_info, 0,
2071 NULL, NULL, NULL);
2072 if (isymbuf == NULL)
2073 return false;
2074 }
2075
2076 /* Get the value of the symbol referred to by the reloc. */
2077 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
2078 {
2079 /* A local symbol. */
2080 asection *sym_sec;
2081
2082 isym = isymbuf + ELF32_R_SYM (irel->r_info);
2083 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
2084 symval = isym->st_value;
2085 /* If the reloc is absolute, it will not have
2086 a symbol or section associated with it. */
2087 if (sym_sec == sec)
2088 {
2089 /* If there is an alignment boundary, we only need to
2090 adjust addends that end up below the boundary. */
2091 bfd_vma shrink_boundary = (toaddr
2092 + sec->output_section->vma
2093 + sec->output_offset);
2094
2095 symval += sym_sec->output_section->vma
2096 + sym_sec->output_offset;
2097
2098 if (debug_relax)
2099 printf ("Checking if the relocation's "
2100 "addend needs corrections.\n"
2101 "Address of anchor symbol: 0x%x \n"
2102 "Address of relocation target: 0x%x \n"
2103 "Address of relaxed insn: 0x%x \n",
2104 (unsigned int) symval,
2105 (unsigned int) (symval + irel->r_addend),
2106 (unsigned int) shrinked_insn_address);
2107
2108 elf32_avr_adjust_reloc_if_spans_insn (abfd, isec, irel,
2109 symval,
2110 shrinked_insn_address,
2111 shrink_boundary,
2112 count);
2113 }
2114 /* else...Reference symbol is absolute. No adjustment needed. */
2115 }
2116 /* else...Reference symbol is extern. No need for adjusting
2117 the addend. */
2118 }
2119 }
2120 }
2121
2122 /* Adjust the local symbols defined in this section. */
2123 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
2124 /* Fix PR 9841, there may be no local symbols. */
2125 if (isym != NULL)
2126 {
2127 Elf_Internal_Sym *isymend;
2128
2129 isymend = isym + symtab_hdr->sh_info;
2130 for (; isym < isymend; isym++)
2131 {
2132 if (isym->st_shndx == sec_shndx)
2133 {
2134 symvalue symval = isym->st_value;
2135 symvalue symend = symval + isym->st_size;
2136 if (avr_should_reduce_sym_size (symval, symend,
2137 addr, toaddr, did_pad))
2138 {
2139 /* If this assert fires then we have a symbol that ends
2140 part way through an instruction. Does that make
2141 sense? */
2142 BFD_ASSERT (isym->st_value + isym->st_size >= addr + count);
2143 isym->st_size -= count;
2144 }
2145 else if (avr_should_increase_sym_size (symval, symend,
2146 addr, toaddr, did_pad))
2147 isym->st_size += count;
2148
2149 if (avr_should_move_sym (symval, addr, toaddr, did_pad))
2150 isym->st_value -= count;
2151 }
2152 }
2153 }
2154
2155 /* Now adjust the global symbols defined in this section. */
2156 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
2157 - symtab_hdr->sh_info);
2158 sym_hashes = elf_sym_hashes (abfd);
2159 end_hashes = sym_hashes + symcount;
2160 for (; sym_hashes < end_hashes; sym_hashes++)
2161 {
2162 struct elf_link_hash_entry *sym_hash = *sym_hashes;
2163 if ((sym_hash->root.type == bfd_link_hash_defined
2164 || sym_hash->root.type == bfd_link_hash_defweak)
2165 && sym_hash->root.u.def.section == sec)
2166 {
2167 symvalue symval = sym_hash->root.u.def.value;
2168 symvalue symend = symval + sym_hash->size;
2169
2170 if (avr_should_reduce_sym_size (symval, symend,
2171 addr, toaddr, did_pad))
2172 {
2173 /* If this assert fires then we have a symbol that ends
2174 part way through an instruction. Does that make
2175 sense? */
2176 BFD_ASSERT (symend >= addr + count);
2177 sym_hash->size -= count;
2178 }
2179 else if (avr_should_increase_sym_size (symval, symend,
2180 addr, toaddr, did_pad))
2181 sym_hash->size += count;
2182
2183 if (avr_should_move_sym (symval, addr, toaddr, did_pad))
2184 sym_hash->root.u.def.value -= count;
2185 }
2186 }
2187
2188 return true;
2189 }
2190
2191 static Elf_Internal_Sym *
2192 retrieve_local_syms (bfd *input_bfd)
2193 {
2194 Elf_Internal_Shdr *symtab_hdr;
2195 Elf_Internal_Sym *isymbuf;
2196 size_t locsymcount;
2197
2198 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2199 locsymcount = symtab_hdr->sh_info;
2200
2201 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2202 if (isymbuf == NULL && locsymcount != 0)
2203 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, locsymcount, 0,
2204 NULL, NULL, NULL);
2205
2206 /* Save the symbols for this input file so they won't be read again. */
2207 if (isymbuf && isymbuf != (Elf_Internal_Sym *) symtab_hdr->contents)
2208 symtab_hdr->contents = (unsigned char *) isymbuf;
2209
2210 return isymbuf;
2211 }
2212
2213 /* Get the input section for a given symbol index.
2214 If the symbol is:
2215 . a section symbol, return the section;
2216 . a common symbol, return the common section;
2217 . an undefined symbol, return the undefined section;
2218 . an indirect symbol, follow the links;
2219 . an absolute value, return the absolute section. */
2220
2221 static asection *
2222 get_elf_r_symndx_section (bfd *abfd, unsigned long r_symndx)
2223 {
2224 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2225 asection *target_sec = NULL;
2226 if (r_symndx < symtab_hdr->sh_info)
2227 {
2228 Elf_Internal_Sym *isymbuf;
2229 unsigned int section_index;
2230
2231 isymbuf = retrieve_local_syms (abfd);
2232 section_index = isymbuf[r_symndx].st_shndx;
2233
2234 if (section_index == SHN_UNDEF)
2235 target_sec = bfd_und_section_ptr;
2236 else if (section_index == SHN_ABS)
2237 target_sec = bfd_abs_section_ptr;
2238 else if (section_index == SHN_COMMON)
2239 target_sec = bfd_com_section_ptr;
2240 else
2241 target_sec = bfd_section_from_elf_index (abfd, section_index);
2242 }
2243 else
2244 {
2245 unsigned long indx = r_symndx - symtab_hdr->sh_info;
2246 struct elf_link_hash_entry *h = elf_sym_hashes (abfd)[indx];
2247
2248 while (h->root.type == bfd_link_hash_indirect
2249 || h->root.type == bfd_link_hash_warning)
2250 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2251
2252 switch (h->root.type)
2253 {
2254 case bfd_link_hash_defined:
2255 case bfd_link_hash_defweak:
2256 target_sec = h->root.u.def.section;
2257 break;
2258 case bfd_link_hash_common:
2259 target_sec = bfd_com_section_ptr;
2260 break;
2261 case bfd_link_hash_undefined:
2262 case bfd_link_hash_undefweak:
2263 target_sec = bfd_und_section_ptr;
2264 break;
2265 default: /* New indirect warning. */
2266 target_sec = bfd_und_section_ptr;
2267 break;
2268 }
2269 }
2270 return target_sec;
2271 }
2272
2273 /* Get the section-relative offset for a symbol number. */
2274
2275 static bfd_vma
2276 get_elf_r_symndx_offset (bfd *abfd, unsigned long r_symndx)
2277 {
2278 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2279 bfd_vma offset = 0;
2280
2281 if (r_symndx < symtab_hdr->sh_info)
2282 {
2283 Elf_Internal_Sym *isymbuf;
2284 isymbuf = retrieve_local_syms (abfd);
2285 offset = isymbuf[r_symndx].st_value;
2286 }
2287 else
2288 {
2289 unsigned long indx = r_symndx - symtab_hdr->sh_info;
2290 struct elf_link_hash_entry *h =
2291 elf_sym_hashes (abfd)[indx];
2292
2293 while (h->root.type == bfd_link_hash_indirect
2294 || h->root.type == bfd_link_hash_warning)
2295 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2296 if (h->root.type == bfd_link_hash_defined
2297 || h->root.type == bfd_link_hash_defweak)
2298 offset = h->root.u.def.value;
2299 }
2300 return offset;
2301 }
2302
2303 /* Iterate over the property records in R_LIST, and copy each record into
2304 the list of records within the relaxation information for the section to
2305 which the record applies. */
2306
2307 static void
2308 avr_elf32_assign_records_to_sections (struct avr_property_record_list *r_list)
2309 {
2310 unsigned int i;
2311
2312 for (i = 0; i < r_list->record_count; ++i)
2313 {
2314 struct avr_relax_info *relax_info;
2315
2316 relax_info = get_avr_relax_info (r_list->records [i].section);
2317 BFD_ASSERT (relax_info != NULL);
2318
2319 if (relax_info->records.count
2320 == relax_info->records.allocated)
2321 {
2322 /* Allocate more space. */
2323 bfd_size_type size;
2324
2325 relax_info->records.allocated += 10;
2326 size = (sizeof (struct avr_property_record)
2327 * relax_info->records.allocated);
2328 relax_info->records.items
2329 = bfd_realloc (relax_info->records.items, size);
2330 }
2331
2332 memcpy (&relax_info->records.items [relax_info->records.count],
2333 &r_list->records [i],
2334 sizeof (struct avr_property_record));
2335 relax_info->records.count++;
2336 }
2337 }
2338
2339 /* Compare two STRUCT AVR_PROPERTY_RECORD in AP and BP, used as the
2340 ordering callback from QSORT. */
2341
2342 static int
2343 avr_property_record_compare (const void *ap, const void *bp)
2344 {
2345 const struct avr_property_record *a
2346 = (struct avr_property_record *) ap;
2347 const struct avr_property_record *b
2348 = (struct avr_property_record *) bp;
2349
2350 if (a->offset != b->offset)
2351 return (a->offset - b->offset);
2352
2353 if (a->section != b->section)
2354 return bfd_section_vma (a->section) - bfd_section_vma (b->section);
2355
2356 return (a->type - b->type);
2357 }
2358
2359 /* Load all of the avr property sections from all of the bfd objects
2360 referenced from LINK_INFO. All of the records within each property
2361 section are assigned to the STRUCT AVR_RELAX_INFO within the section
2362 specific data of the appropriate section. */
2363
2364 static void
2365 avr_load_all_property_sections (struct bfd_link_info *link_info)
2366 {
2367 bfd *abfd;
2368 asection *sec;
2369
2370 /* Initialize the per-section relaxation info. */
2371 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link.next)
2372 for (sec = abfd->sections; sec != NULL; sec = sec->next)
2373 {
2374 init_avr_relax_info (sec);
2375 }
2376
2377 /* Load the descriptor tables from .avr.prop sections. */
2378 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link.next)
2379 {
2380 struct avr_property_record_list *r_list;
2381
2382 r_list = avr_elf32_load_property_records (abfd);
2383 if (r_list != NULL)
2384 avr_elf32_assign_records_to_sections (r_list);
2385
2386 free (r_list);
2387 }
2388
2389 /* Now, for every section, ensure that the descriptor list in the
2390 relaxation data is sorted by ascending offset within the section. */
2391 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link.next)
2392 for (sec = abfd->sections; sec != NULL; sec = sec->next)
2393 {
2394 struct avr_relax_info *relax_info = get_avr_relax_info (sec);
2395 if (relax_info && relax_info->records.count > 0)
2396 {
2397 unsigned int i;
2398
2399 qsort (relax_info->records.items,
2400 relax_info->records.count,
2401 sizeof (struct avr_property_record),
2402 avr_property_record_compare);
2403
2404 /* For debug purposes, list all the descriptors. */
2405 for (i = 0; i < relax_info->records.count; ++i)
2406 {
2407 switch (relax_info->records.items [i].type)
2408 {
2409 case RECORD_ORG:
2410 break;
2411 case RECORD_ORG_AND_FILL:
2412 break;
2413 case RECORD_ALIGN:
2414 break;
2415 case RECORD_ALIGN_AND_FILL:
2416 break;
2417 };
2418 }
2419 }
2420 }
2421 }
2422
2423 /* This function handles relaxing for the avr.
2424 Many important relaxing opportunities within functions are already
2425 realized by the compiler itself.
2426 Here we try to replace call (4 bytes) -> rcall (2 bytes)
2427 and jump -> rjmp (safes also 2 bytes).
2428 As well we now optimize seqences of
2429 - call/rcall function
2430 - ret
2431 to yield
2432 - jmp/rjmp function
2433 - ret
2434 . In case that within a sequence
2435 - jmp/rjmp label
2436 - ret
2437 the ret could no longer be reached it is optimized away. In order
2438 to check if the ret is no longer needed, it is checked that the ret's address
2439 is not the target of a branch or jump within the same section, it is checked
2440 that there is no skip instruction before the jmp/rjmp and that there
2441 is no local or global label place at the address of the ret.
2442
2443 We refrain from relaxing within sections ".vectors" and
2444 ".jumptables" in order to maintain the position of the instructions.
2445 There, however, we substitute jmp/call by a sequence rjmp,nop/rcall,nop
2446 if possible. (In future one could possibly use the space of the nop
2447 for the first instruction of the irq service function.
2448
2449 The .jumptables sections is meant to be used for a future tablejump variant
2450 for the devices with 3-byte program counter where the table itself
2451 contains 4-byte jump instructions whose relative offset must not
2452 be changed. */
2453
2454 static bool
2455 elf32_avr_relax_section (bfd *abfd,
2456 asection *sec,
2457 struct bfd_link_info *link_info,
2458 bool *again)
2459 {
2460 Elf_Internal_Shdr *symtab_hdr;
2461 Elf_Internal_Rela *internal_relocs;
2462 Elf_Internal_Rela *irel, *irelend;
2463 bfd_byte *contents = NULL;
2464 Elf_Internal_Sym *isymbuf = NULL;
2465 struct elf32_avr_link_hash_table *htab;
2466 static bool relaxation_initialised = false;
2467
2468 if (!relaxation_initialised)
2469 {
2470 relaxation_initialised = true;
2471
2472 /* Load entries from the .avr.prop sections. */
2473 avr_load_all_property_sections (link_info);
2474 }
2475
2476 /* If 'shrinkable' is FALSE, do not shrink by deleting bytes while
2477 relaxing. Such shrinking can cause issues for the sections such
2478 as .vectors and .jumptables. Instead the unused bytes should be
2479 filled with nop instructions. */
2480 bool shrinkable = true;
2481
2482 if (!strcmp (sec->name,".vectors")
2483 || !strcmp (sec->name,".jumptables"))
2484 shrinkable = false;
2485
2486 if (bfd_link_relocatable (link_info))
2487 (*link_info->callbacks->einfo)
2488 (_("%P%F: --relax and -r may not be used together\n"));
2489
2490 htab = avr_link_hash_table (link_info);
2491 if (htab == NULL)
2492 return false;
2493
2494 /* Assume nothing changes. */
2495 *again = false;
2496
2497 if ((!htab->no_stubs) && (sec == htab->stub_sec))
2498 {
2499 /* We are just relaxing the stub section.
2500 Let's calculate the size needed again. */
2501 bfd_size_type last_estimated_stub_section_size = htab->stub_sec->size;
2502
2503 if (debug_relax)
2504 printf ("Relaxing the stub section. Size prior to this pass: %i\n",
2505 (int) last_estimated_stub_section_size);
2506
2507 elf32_avr_size_stubs (htab->stub_sec->output_section->owner,
2508 link_info, false);
2509
2510 /* Check if the number of trampolines changed. */
2511 if (last_estimated_stub_section_size != htab->stub_sec->size)
2512 *again = true;
2513
2514 if (debug_relax)
2515 printf ("Size of stub section after this pass: %i\n",
2516 (int) htab->stub_sec->size);
2517
2518 return true;
2519 }
2520
2521 /* We don't have to do anything for a relocatable link, if
2522 this section does not have relocs, or if this is not a
2523 code section. */
2524 if (bfd_link_relocatable (link_info)
2525 || sec->reloc_count == 0
2526 || (sec->flags & SEC_RELOC) == 0
2527 || (sec->flags & SEC_HAS_CONTENTS) == 0
2528 || (sec->flags & SEC_CODE) == 0)
2529 return true;
2530
2531 /* Check if the object file to relax uses internal symbols so that we
2532 could fix up the relocations. */
2533 if (!(elf_elfheader (abfd)->e_flags & EF_AVR_LINKRELAX_PREPARED))
2534 return true;
2535
2536 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2537
2538 /* Get a copy of the native relocations. */
2539 internal_relocs = (_bfd_elf_link_read_relocs
2540 (abfd, sec, NULL, NULL, link_info->keep_memory));
2541 if (internal_relocs == NULL)
2542 goto error_return;
2543
2544 /* Walk through the relocs looking for relaxing opportunities. */
2545 irelend = internal_relocs + sec->reloc_count;
2546 for (irel = internal_relocs; irel < irelend; irel++)
2547 {
2548 bfd_vma symval;
2549
2550 if ( ELF32_R_TYPE (irel->r_info) != R_AVR_13_PCREL
2551 && ELF32_R_TYPE (irel->r_info) != R_AVR_7_PCREL
2552 && ELF32_R_TYPE (irel->r_info) != R_AVR_CALL)
2553 continue;
2554
2555 /* Get the section contents if we haven't done so already. */
2556 if (contents == NULL)
2557 {
2558 /* Get cached copy if it exists. */
2559 if (elf_section_data (sec)->this_hdr.contents != NULL)
2560 contents = elf_section_data (sec)->this_hdr.contents;
2561 else
2562 {
2563 /* Go get them off disk. */
2564 if (! bfd_malloc_and_get_section (abfd, sec, &contents))
2565 goto error_return;
2566 }
2567 }
2568
2569 /* Read this BFD's local symbols if we haven't done so already. */
2570 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
2571 {
2572 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2573 if (isymbuf == NULL)
2574 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
2575 symtab_hdr->sh_info, 0,
2576 NULL, NULL, NULL);
2577 if (isymbuf == NULL)
2578 goto error_return;
2579 }
2580
2581
2582 /* Get the value of the symbol referred to by the reloc. */
2583 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
2584 {
2585 /* A local symbol. */
2586 Elf_Internal_Sym *isym;
2587 asection *sym_sec;
2588
2589 isym = isymbuf + ELF32_R_SYM (irel->r_info);
2590 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
2591 symval = isym->st_value;
2592 /* If the reloc is absolute, it will not have
2593 a symbol or section associated with it. */
2594 if (sym_sec)
2595 symval += sym_sec->output_section->vma
2596 + sym_sec->output_offset;
2597 }
2598 else
2599 {
2600 unsigned long indx;
2601 struct elf_link_hash_entry *h;
2602
2603 /* An external symbol. */
2604 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
2605 h = elf_sym_hashes (abfd)[indx];
2606 BFD_ASSERT (h != NULL);
2607 if (h->root.type != bfd_link_hash_defined
2608 && h->root.type != bfd_link_hash_defweak)
2609 /* This appears to be a reference to an undefined
2610 symbol. Just ignore it--it will be caught by the
2611 regular reloc processing. */
2612 continue;
2613
2614 symval = (h->root.u.def.value
2615 + h->root.u.def.section->output_section->vma
2616 + h->root.u.def.section->output_offset);
2617 }
2618
2619 /* For simplicity of coding, we are going to modify the section
2620 contents, the section relocs, and the BFD symbol table. We
2621 must tell the rest of the code not to free up this
2622 information. It would be possible to instead create a table
2623 of changes which have to be made, as is done in coff-mips.c;
2624 that would be more work, but would require less memory when
2625 the linker is run. */
2626 switch (ELF32_R_TYPE (irel->r_info))
2627 {
2628 /* Try to turn a 22-bit absolute call/jump into an 13-bit
2629 pc-relative rcall/rjmp. */
2630 case R_AVR_CALL:
2631 {
2632 bfd_vma value = symval + irel->r_addend;
2633 bfd_vma dot, gap;
2634 int distance_short_enough = 0;
2635
2636 /* Get the address of this instruction. */
2637 dot = (sec->output_section->vma
2638 + sec->output_offset + irel->r_offset);
2639
2640 /* Compute the distance from this insn to the branch target. */
2641 gap = value - dot;
2642
2643 /* The ISA manual states that addressable range is PC - 2k + 1 to
2644 PC + 2k. In bytes, that would be -4094 <= PC <= 4096. The range
2645 is shifted one word to the right, because pc-relative instructions
2646 implicitly add one word i.e. rjmp 0 jumps to next insn, not the
2647 current one.
2648 Therefore, for the !shrinkable case, the range is as above.
2649 If shrinkable, then the current code only deletes bytes 3 and
2650 4 of the absolute call/jmp, so the forward jump range increases
2651 by 2 bytes, but the backward (negative) jump range remains
2652 the same. */
2653
2654
2655 /* Check if the gap falls in the range that can be accommodated
2656 in 13bits signed (It is 12bits when encoded, as we deal with
2657 word addressing). */
2658 if (!shrinkable && ((int) gap >= -4094 && (int) gap <= 4096))
2659 distance_short_enough = 1;
2660 /* If shrinkable, then we can check for a range of distance which
2661 is two bytes farther on the positive direction because the call
2662 or jump target will be closer by two bytes after the
2663 relaxation. */
2664 else if (shrinkable && ((int) gap >= -4094 && (int) gap <= 4098))
2665 distance_short_enough = 1;
2666
2667 /* Here we handle the wrap-around case. E.g. for a 16k device
2668 we could use a rjmp to jump from address 0x100 to 0x3d00!
2669 In order to make this work properly, we need to fill the
2670 vaiable avr_pc_wrap_around with the appropriate value.
2671 I.e. 0x4000 for a 16k device. */
2672 {
2673 /* Shrinking the code size makes the gaps larger in the
2674 case of wrap-arounds. So we use a heuristical safety
2675 margin to avoid that during relax the distance gets
2676 again too large for the short jumps. Let's assume
2677 a typical code-size reduction due to relax for a
2678 16k device of 600 bytes. So let's use twice the
2679 typical value as safety margin. */
2680 int rgap;
2681 int safety_margin;
2682
2683 int assumed_shrink = 600;
2684 if (avr_pc_wrap_around > 0x4000)
2685 assumed_shrink = 900;
2686
2687 safety_margin = 2 * assumed_shrink;
2688
2689 rgap = avr_relative_distance_considering_wrap_around (gap);
2690
2691 if (rgap >= (-4092 + safety_margin)
2692 && rgap <= (4094 - safety_margin))
2693 distance_short_enough = 1;
2694 }
2695
2696 if (distance_short_enough)
2697 {
2698 unsigned char code_msb;
2699 unsigned char code_lsb;
2700
2701 if (debug_relax)
2702 printf ("shrinking jump/call instruction at address 0x%x"
2703 " in section %s\n\n",
2704 (int) dot, sec->name);
2705
2706 /* Note that we've changed the relocs, section contents,
2707 etc. */
2708 elf_section_data (sec)->relocs = internal_relocs;
2709 elf_section_data (sec)->this_hdr.contents = contents;
2710 symtab_hdr->contents = (unsigned char *) isymbuf;
2711
2712 /* Get the instruction code for relaxing. */
2713 code_lsb = bfd_get_8 (abfd, contents + irel->r_offset);
2714 code_msb = bfd_get_8 (abfd, contents + irel->r_offset + 1);
2715
2716 /* Mask out the relocation bits. */
2717 code_msb &= 0x94;
2718 code_lsb &= 0x0E;
2719 if (code_msb == 0x94 && code_lsb == 0x0E)
2720 {
2721 /* we are changing call -> rcall . */
2722 bfd_put_8 (abfd, 0x00, contents + irel->r_offset);
2723 bfd_put_8 (abfd, 0xD0, contents + irel->r_offset + 1);
2724 }
2725 else if (code_msb == 0x94 && code_lsb == 0x0C)
2726 {
2727 /* we are changeing jump -> rjmp. */
2728 bfd_put_8 (abfd, 0x00, contents + irel->r_offset);
2729 bfd_put_8 (abfd, 0xC0, contents + irel->r_offset + 1);
2730 }
2731 else
2732 abort ();
2733
2734 /* Fix the relocation's type. */
2735 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2736 R_AVR_13_PCREL);
2737
2738 /* We should not modify the ordering if 'shrinkable' is
2739 FALSE. */
2740 if (!shrinkable)
2741 {
2742 /* Let's insert a nop. */
2743 bfd_put_8 (abfd, 0x00, contents + irel->r_offset + 2);
2744 bfd_put_8 (abfd, 0x00, contents + irel->r_offset + 3);
2745 }
2746 else
2747 {
2748 /* Delete two bytes of data. */
2749 if (!elf32_avr_relax_delete_bytes (abfd, sec,
2750 irel->r_offset + 2, 2,
2751 true))
2752 goto error_return;
2753
2754 /* That will change things, so, we should relax again.
2755 Note that this is not required, and it may be slow. */
2756 *again = true;
2757 }
2758 }
2759 }
2760 /* Fall through. */
2761
2762 default:
2763 {
2764 unsigned char code_msb;
2765 unsigned char code_lsb;
2766 bfd_vma dot;
2767
2768 code_msb = bfd_get_8 (abfd, contents + irel->r_offset + 1);
2769 code_lsb = bfd_get_8 (abfd, contents + irel->r_offset + 0);
2770
2771 /* Get the address of this instruction. */
2772 dot = (sec->output_section->vma
2773 + sec->output_offset + irel->r_offset);
2774
2775 /* Here we look for rcall/ret or call/ret sequences that could be
2776 safely replaced by rjmp/ret or jmp/ret. */
2777 if (((code_msb & 0xf0) == 0xd0)
2778 && avr_replace_call_ret_sequences)
2779 {
2780 /* This insn is a rcall. */
2781 unsigned char next_insn_msb = 0;
2782 unsigned char next_insn_lsb = 0;
2783
2784 if (irel->r_offset + 3 < sec->size)
2785 {
2786 next_insn_msb =
2787 bfd_get_8 (abfd, contents + irel->r_offset + 3);
2788 next_insn_lsb =
2789 bfd_get_8 (abfd, contents + irel->r_offset + 2);
2790 }
2791
2792 if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb))
2793 {
2794 /* The next insn is a ret. We now convert the rcall insn
2795 into a rjmp instruction. */
2796 code_msb &= 0xef;
2797 bfd_put_8 (abfd, code_msb, contents + irel->r_offset + 1);
2798 if (debug_relax)
2799 printf ("converted rcall/ret sequence at address 0x%x"
2800 " into rjmp/ret sequence. Section is %s\n\n",
2801 (int) dot, sec->name);
2802 *again = true;
2803 break;
2804 }
2805 }
2806 else if ((0x94 == (code_msb & 0xfe))
2807 && (0x0e == (code_lsb & 0x0e))
2808 && avr_replace_call_ret_sequences)
2809 {
2810 /* This insn is a call. */
2811 unsigned char next_insn_msb = 0;
2812 unsigned char next_insn_lsb = 0;
2813
2814 if (irel->r_offset + 5 < sec->size)
2815 {
2816 next_insn_msb =
2817 bfd_get_8 (abfd, contents + irel->r_offset + 5);
2818 next_insn_lsb =
2819 bfd_get_8 (abfd, contents + irel->r_offset + 4);
2820 }
2821
2822 if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb))
2823 {
2824 /* The next insn is a ret. We now convert the call insn
2825 into a jmp instruction. */
2826
2827 code_lsb &= 0xfd;
2828 bfd_put_8 (abfd, code_lsb, contents + irel->r_offset);
2829 if (debug_relax)
2830 printf ("converted call/ret sequence at address 0x%x"
2831 " into jmp/ret sequence. Section is %s\n\n",
2832 (int) dot, sec->name);
2833 *again = true;
2834 break;
2835 }
2836 }
2837 else if ((0xc0 == (code_msb & 0xf0))
2838 || ((0x94 == (code_msb & 0xfe))
2839 && (0x0c == (code_lsb & 0x0e))))
2840 {
2841 /* This insn is a rjmp or a jmp. */
2842 unsigned char next_insn_msb = 0;
2843 unsigned char next_insn_lsb = 0;
2844 int insn_size;
2845
2846 if (0xc0 == (code_msb & 0xf0))
2847 insn_size = 2; /* rjmp insn */
2848 else
2849 insn_size = 4; /* jmp insn */
2850
2851 if (irel->r_offset + insn_size + 1 < sec->size)
2852 {
2853 next_insn_msb =
2854 bfd_get_8 (abfd, contents + irel->r_offset
2855 + insn_size + 1);
2856 next_insn_lsb =
2857 bfd_get_8 (abfd, contents + irel->r_offset
2858 + insn_size);
2859 }
2860
2861 if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb))
2862 {
2863 /* The next insn is a ret. We possibly could delete
2864 this ret. First we need to check for preceding
2865 sbis/sbic/sbrs or cpse "skip" instructions. */
2866
2867 int there_is_preceding_non_skip_insn = 1;
2868 bfd_vma address_of_ret;
2869
2870 address_of_ret = dot + insn_size;
2871
2872 if (debug_relax && (insn_size == 2))
2873 printf ("found rjmp / ret sequence at address 0x%x\n",
2874 (int) dot);
2875 if (debug_relax && (insn_size == 4))
2876 printf ("found jmp / ret sequence at address 0x%x\n",
2877 (int) dot);
2878
2879 /* We have to make sure that there is a preceding insn. */
2880 if (irel->r_offset >= 2)
2881 {
2882 unsigned char preceding_msb;
2883 unsigned char preceding_lsb;
2884
2885 preceding_msb =
2886 bfd_get_8 (abfd, contents + irel->r_offset - 1);
2887 preceding_lsb =
2888 bfd_get_8 (abfd, contents + irel->r_offset - 2);
2889
2890 /* sbic. */
2891 if (0x99 == preceding_msb)
2892 there_is_preceding_non_skip_insn = 0;
2893
2894 /* sbis. */
2895 if (0x9b == preceding_msb)
2896 there_is_preceding_non_skip_insn = 0;
2897
2898 /* sbrc */
2899 if ((0xfc == (preceding_msb & 0xfe)
2900 && (0x00 == (preceding_lsb & 0x08))))
2901 there_is_preceding_non_skip_insn = 0;
2902
2903 /* sbrs */
2904 if ((0xfe == (preceding_msb & 0xfe)
2905 && (0x00 == (preceding_lsb & 0x08))))
2906 there_is_preceding_non_skip_insn = 0;
2907
2908 /* cpse */
2909 if (0x10 == (preceding_msb & 0xfc))
2910 there_is_preceding_non_skip_insn = 0;
2911
2912 if (there_is_preceding_non_skip_insn == 0)
2913 if (debug_relax)
2914 printf ("preceding skip insn prevents deletion of"
2915 " ret insn at Addy 0x%x in section %s\n",
2916 (int) dot + 2, sec->name);
2917 }
2918 else
2919 {
2920 /* There is no previous instruction. */
2921 there_is_preceding_non_skip_insn = 0;
2922 }
2923
2924 if (there_is_preceding_non_skip_insn)
2925 {
2926 /* We now only have to make sure that there is no
2927 local label defined at the address of the ret
2928 instruction and that there is no local relocation
2929 in this section pointing to the ret. */
2930
2931 int deleting_ret_is_safe = 1;
2932 unsigned int section_offset_of_ret_insn =
2933 irel->r_offset + insn_size;
2934 Elf_Internal_Sym *isym, *isymend;
2935 unsigned int sec_shndx;
2936 struct bfd_section *isec;
2937
2938 sec_shndx =
2939 _bfd_elf_section_from_bfd_section (abfd, sec);
2940
2941 /* Check for local symbols. */
2942 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
2943 isymend = isym + symtab_hdr->sh_info;
2944 /* PR 6019: There may not be any local symbols. */
2945 for (; isym != NULL && isym < isymend; isym++)
2946 {
2947 if (isym->st_value == section_offset_of_ret_insn
2948 && isym->st_shndx == sec_shndx)
2949 {
2950 deleting_ret_is_safe = 0;
2951 if (debug_relax)
2952 printf ("local label prevents deletion of ret "
2953 "insn at address 0x%x\n",
2954 (int) dot + insn_size);
2955 }
2956 }
2957
2958 /* Now check for global symbols. */
2959 {
2960 int symcount;
2961 struct elf_link_hash_entry **sym_hashes;
2962 struct elf_link_hash_entry **end_hashes;
2963
2964 symcount = (symtab_hdr->sh_size
2965 / sizeof (Elf32_External_Sym)
2966 - symtab_hdr->sh_info);
2967 sym_hashes = elf_sym_hashes (abfd);
2968 end_hashes = sym_hashes + symcount;
2969 for (; sym_hashes < end_hashes; sym_hashes++)
2970 {
2971 struct elf_link_hash_entry *sym_hash =
2972 *sym_hashes;
2973 if ((sym_hash->root.type == bfd_link_hash_defined
2974 || sym_hash->root.type ==
2975 bfd_link_hash_defweak)
2976 && sym_hash->root.u.def.section == sec
2977 && sym_hash->root.u.def.value == section_offset_of_ret_insn)
2978 {
2979 deleting_ret_is_safe = 0;
2980 if (debug_relax)
2981 printf ("global label prevents deletion of "
2982 "ret insn at address 0x%x\n",
2983 (int) dot + insn_size);
2984 }
2985 }
2986 }
2987
2988 /* Now we check for relocations pointing to ret. */
2989 for (isec = abfd->sections; isec && deleting_ret_is_safe; isec = isec->next)
2990 {
2991 Elf_Internal_Rela *rel;
2992 Elf_Internal_Rela *relend;
2993
2994 rel = elf_section_data (isec)->relocs;
2995 if (rel == NULL)
2996 rel = _bfd_elf_link_read_relocs (abfd, isec, NULL, NULL, true);
2997
2998 relend = rel + isec->reloc_count;
2999
3000 for (; rel && rel < relend; rel++)
3001 {
3002 bfd_vma reloc_target = 0;
3003
3004 /* Read this BFD's local symbols if we haven't
3005 done so already. */
3006 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
3007 {
3008 isymbuf = (Elf_Internal_Sym *)
3009 symtab_hdr->contents;
3010 if (isymbuf == NULL)
3011 isymbuf = bfd_elf_get_elf_syms
3012 (abfd,
3013 symtab_hdr,
3014 symtab_hdr->sh_info, 0,
3015 NULL, NULL, NULL);
3016 if (isymbuf == NULL)
3017 break;
3018 }
3019
3020 /* Get the value of the symbol referred to
3021 by the reloc. */
3022 if (ELF32_R_SYM (rel->r_info)
3023 < symtab_hdr->sh_info)
3024 {
3025 /* A local symbol. */
3026 asection *sym_sec;
3027
3028 isym = isymbuf
3029 + ELF32_R_SYM (rel->r_info);
3030 sym_sec = bfd_section_from_elf_index
3031 (abfd, isym->st_shndx);
3032 symval = isym->st_value;
3033
3034 /* If the reloc is absolute, it will not
3035 have a symbol or section associated
3036 with it. */
3037
3038 if (sym_sec)
3039 {
3040 symval +=
3041 sym_sec->output_section->vma
3042 + sym_sec->output_offset;
3043 reloc_target = symval + rel->r_addend;
3044 }
3045 else
3046 {
3047 reloc_target = symval + rel->r_addend;
3048 /* Reference symbol is absolute. */
3049 }
3050 }
3051 /* else ... reference symbol is extern. */
3052
3053 if (address_of_ret == reloc_target)
3054 {
3055 deleting_ret_is_safe = 0;
3056 if (debug_relax)
3057 printf ("ret from "
3058 "rjmp/jmp ret sequence at address"
3059 " 0x%x could not be deleted. ret"
3060 " is target of a relocation.\n",
3061 (int) address_of_ret);
3062 break;
3063 }
3064 }
3065 }
3066
3067 if (deleting_ret_is_safe)
3068 {
3069 if (debug_relax)
3070 printf ("unreachable ret instruction "
3071 "at address 0x%x deleted.\n",
3072 (int) dot + insn_size);
3073
3074 elf_section_data (sec)->relocs = internal_relocs;
3075 elf_section_data (sec)->this_hdr.contents = contents;
3076 symtab_hdr->contents = (unsigned char *) isymbuf;
3077
3078 /* Delete two bytes of data. */
3079 if (!elf32_avr_relax_delete_bytes (abfd, sec,
3080 irel->r_offset + insn_size, 2,
3081 true))
3082 goto error_return;
3083
3084 /* That will change things, so, we should relax
3085 again. Note that this is not required, and it
3086 may be slow. */
3087 *again = true;
3088 break;
3089 }
3090 }
3091 }
3092 }
3093 break;
3094 }
3095 }
3096 }
3097
3098 if (!*again)
3099 {
3100 /* Look through all the property records in this section to see if
3101 there's any alignment records that can be moved. */
3102 struct avr_relax_info *relax_info;
3103
3104 relax_info = get_avr_relax_info (sec);
3105 if (relax_info->records.count > 0)
3106 {
3107 unsigned int i;
3108
3109 for (i = 0; i < relax_info->records.count; ++i)
3110 {
3111 switch (relax_info->records.items [i].type)
3112 {
3113 case RECORD_ORG:
3114 case RECORD_ORG_AND_FILL:
3115 break;
3116 case RECORD_ALIGN:
3117 case RECORD_ALIGN_AND_FILL:
3118 {
3119 struct avr_property_record *record;
3120 unsigned long bytes_to_align;
3121 int count = 0;
3122
3123 /* Look for alignment directives that have had enough
3124 bytes deleted before them, such that the directive
3125 can be moved backwards and still maintain the
3126 required alignment. */
3127 record = &relax_info->records.items [i];
3128 bytes_to_align
3129 = (unsigned long) (1 << record->data.align.bytes);
3130 while (record->data.align.preceding_deleted >=
3131 bytes_to_align)
3132 {
3133 record->data.align.preceding_deleted
3134 -= bytes_to_align;
3135 count += bytes_to_align;
3136 }
3137
3138 if (count > 0)
3139 {
3140 bfd_vma addr = record->offset;
3141
3142 /* We can delete COUNT bytes and this alignment
3143 directive will still be correctly aligned.
3144 First move the alignment directive, then delete
3145 the bytes. */
3146 record->offset -= count;
3147 elf32_avr_relax_delete_bytes (abfd, sec,
3148 addr - count,
3149 count, false);
3150 *again = true;
3151 }
3152 }
3153 break;
3154 }
3155 }
3156 }
3157 }
3158
3159 if (contents != NULL
3160 && elf_section_data (sec)->this_hdr.contents != contents)
3161 {
3162 if (! link_info->keep_memory)
3163 free (contents);
3164 else
3165 {
3166 /* Cache the section contents for elf_link_input_bfd. */
3167 elf_section_data (sec)->this_hdr.contents = contents;
3168 }
3169 }
3170
3171 if (elf_section_data (sec)->relocs != internal_relocs)
3172 free (internal_relocs);
3173
3174 return true;
3175
3176 error_return:
3177 if (symtab_hdr->contents != (unsigned char *) isymbuf)
3178 free (isymbuf);
3179 if (elf_section_data (sec)->this_hdr.contents != contents)
3180 free (contents);
3181 if (elf_section_data (sec)->relocs != internal_relocs)
3182 free (internal_relocs);
3183
3184 return false;
3185 }
3186
3187 /* This is a version of bfd_generic_get_relocated_section_contents
3188 which uses elf32_avr_relocate_section.
3189
3190 For avr it's essentially a cut and paste taken from the H8300 port.
3191 The author of the relaxation support patch for avr had absolutely no
3192 clue what is happening here but found out that this part of the code
3193 seems to be important. */
3194
3195 static bfd_byte *
3196 elf32_avr_get_relocated_section_contents (bfd *output_bfd,
3197 struct bfd_link_info *link_info,
3198 struct bfd_link_order *link_order,
3199 bfd_byte *data,
3200 bool relocatable,
3201 asymbol **symbols)
3202 {
3203 Elf_Internal_Shdr *symtab_hdr;
3204 asection *input_section = link_order->u.indirect.section;
3205 bfd *input_bfd = input_section->owner;
3206 asection **sections = NULL;
3207 Elf_Internal_Rela *internal_relocs = NULL;
3208 Elf_Internal_Sym *isymbuf = NULL;
3209
3210 /* We only need to handle the case of relaxing, or of having a
3211 particular set of section contents, specially. */
3212 if (relocatable
3213 || elf_section_data (input_section)->this_hdr.contents == NULL)
3214 return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
3215 link_order, data,
3216 relocatable,
3217 symbols);
3218 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3219
3220 bfd_byte *orig_data = data;
3221 if (data == NULL)
3222 {
3223 data = bfd_malloc (input_section->size);
3224 if (data == NULL)
3225 return NULL;
3226 }
3227 memcpy (data, elf_section_data (input_section)->this_hdr.contents,
3228 (size_t) input_section->size);
3229
3230 if ((input_section->flags & SEC_RELOC) != 0
3231 && input_section->reloc_count > 0)
3232 {
3233 asection **secpp;
3234 Elf_Internal_Sym *isym, *isymend;
3235 bfd_size_type amt;
3236
3237 internal_relocs = (_bfd_elf_link_read_relocs
3238 (input_bfd, input_section, NULL, NULL, false));
3239 if (internal_relocs == NULL)
3240 goto error_return;
3241
3242 if (symtab_hdr->sh_info != 0)
3243 {
3244 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
3245 if (isymbuf == NULL)
3246 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
3247 symtab_hdr->sh_info, 0,
3248 NULL, NULL, NULL);
3249 if (isymbuf == NULL)
3250 goto error_return;
3251 }
3252
3253 amt = symtab_hdr->sh_info;
3254 amt *= sizeof (asection *);
3255 sections = bfd_malloc (amt);
3256 if (sections == NULL && amt != 0)
3257 goto error_return;
3258
3259 isymend = isymbuf + symtab_hdr->sh_info;
3260 for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
3261 {
3262 asection *isec;
3263
3264 if (isym->st_shndx == SHN_UNDEF)
3265 isec = bfd_und_section_ptr;
3266 else if (isym->st_shndx == SHN_ABS)
3267 isec = bfd_abs_section_ptr;
3268 else if (isym->st_shndx == SHN_COMMON)
3269 isec = bfd_com_section_ptr;
3270 else
3271 isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
3272
3273 *secpp = isec;
3274 }
3275
3276 if (! elf32_avr_relocate_section (output_bfd, link_info, input_bfd,
3277 input_section, data, internal_relocs,
3278 isymbuf, sections))
3279 goto error_return;
3280
3281 free (sections);
3282 if (symtab_hdr->contents != (unsigned char *) isymbuf)
3283 free (isymbuf);
3284 if (elf_section_data (input_section)->relocs != internal_relocs)
3285 free (internal_relocs);
3286 }
3287
3288 return data;
3289
3290 error_return:
3291 free (sections);
3292 if (symtab_hdr->contents != (unsigned char *) isymbuf)
3293 free (isymbuf);
3294 if (elf_section_data (input_section)->relocs != internal_relocs)
3295 free (internal_relocs);
3296 if (orig_data == NULL)
3297 free (data);
3298 return NULL;
3299 }
3300
3301
3302 /* Determines the hash entry name for a particular reloc. It consists of
3303 the identifier of the symbol section and the added reloc addend and
3304 symbol offset relative to the section the symbol is attached to. */
3305
3306 static char *
3307 avr_stub_name (const asection *symbol_section,
3308 const bfd_vma symbol_offset,
3309 const Elf_Internal_Rela *rela)
3310 {
3311 char *stub_name;
3312 bfd_size_type len;
3313
3314 len = 8 + 1 + 8 + 1 + 1;
3315 stub_name = bfd_malloc (len);
3316 if (stub_name != NULL)
3317 sprintf (stub_name, "%08x+%08x",
3318 symbol_section->id & 0xffffffff,
3319 (unsigned int) ((rela->r_addend & 0xffffffff) + symbol_offset));
3320
3321 return stub_name;
3322 }
3323
3324
3325 /* Add a new stub entry to the stub hash. Not all fields of the new
3326 stub entry are initialised. */
3327
3328 static struct elf32_avr_stub_hash_entry *
3329 avr_add_stub (const char *stub_name,
3330 struct elf32_avr_link_hash_table *htab)
3331 {
3332 struct elf32_avr_stub_hash_entry *hsh;
3333
3334 /* Enter this entry into the linker stub hash table. */
3335 hsh = avr_stub_hash_lookup (&htab->bstab, stub_name, true, false);
3336
3337 if (hsh == NULL)
3338 {
3339 /* xgettext:c-format */
3340 _bfd_error_handler (_("cannot create stub entry %s"), stub_name);
3341 return NULL;
3342 }
3343
3344 hsh->stub_offset = 0;
3345 return hsh;
3346 }
3347
3348 /* We assume that there is already space allocated for the stub section
3349 contents and that before building the stubs the section size is
3350 initialized to 0. We assume that within the stub hash table entry,
3351 the absolute position of the jmp target has been written in the
3352 target_value field. We write here the offset of the generated jmp insn
3353 relative to the trampoline section start to the stub_offset entry in
3354 the stub hash table entry. */
3355
3356 static bool
3357 avr_build_one_stub (struct bfd_hash_entry *bh, void *in_arg)
3358 {
3359 struct elf32_avr_stub_hash_entry *hsh;
3360 struct bfd_link_info *info;
3361 struct elf32_avr_link_hash_table *htab;
3362 bfd *stub_bfd;
3363 bfd_byte *loc;
3364 bfd_vma target;
3365 bfd_vma starget;
3366
3367 /* Basic opcode */
3368 bfd_vma jmp_insn = 0x0000940c;
3369
3370 /* Massage our args to the form they really have. */
3371 hsh = avr_stub_hash_entry (bh);
3372
3373 if (!hsh->is_actually_needed)
3374 return true;
3375
3376 info = (struct bfd_link_info *) in_arg;
3377
3378 htab = avr_link_hash_table (info);
3379 if (htab == NULL)
3380 return false;
3381
3382 target = hsh->target_value;
3383
3384 /* Make a note of the offset within the stubs for this entry. */
3385 hsh->stub_offset = htab->stub_sec->size;
3386 loc = htab->stub_sec->contents + hsh->stub_offset;
3387
3388 stub_bfd = htab->stub_sec->owner;
3389
3390 if (debug_stubs)
3391 printf ("Building one Stub. Address: 0x%x, Offset: 0x%x\n",
3392 (unsigned int) target,
3393 (unsigned int) hsh->stub_offset);
3394
3395 /* We now have to add the information on the jump target to the bare
3396 opcode bits already set in jmp_insn. */
3397
3398 /* Check for the alignment of the address. */
3399 if (target & 1)
3400 return false;
3401
3402 starget = target >> 1;
3403 jmp_insn |= ((starget & 0x10000) | ((starget << 3) & 0x1f00000)) >> 16;
3404 bfd_put_16 (stub_bfd, jmp_insn, loc);
3405 bfd_put_16 (stub_bfd, (bfd_vma) starget & 0xffff, loc + 2);
3406
3407 htab->stub_sec->size += 4;
3408
3409 /* Now add the entries in the address mapping table if there is still
3410 space left. */
3411 {
3412 unsigned int nr;
3413
3414 nr = htab->amt_entry_cnt + 1;
3415 if (nr <= htab->amt_max_entry_cnt)
3416 {
3417 htab->amt_entry_cnt = nr;
3418
3419 htab->amt_stub_offsets[nr - 1] = hsh->stub_offset;
3420 htab->amt_destination_addr[nr - 1] = target;
3421 }
3422 }
3423
3424 return true;
3425 }
3426
3427 static bool
3428 avr_mark_stub_not_to_be_necessary (struct bfd_hash_entry *bh,
3429 void *in_arg ATTRIBUTE_UNUSED)
3430 {
3431 struct elf32_avr_stub_hash_entry *hsh;
3432
3433 hsh = avr_stub_hash_entry (bh);
3434 hsh->is_actually_needed = false;
3435
3436 return true;
3437 }
3438
3439 static bool
3440 avr_size_one_stub (struct bfd_hash_entry *bh, void *in_arg)
3441 {
3442 struct elf32_avr_stub_hash_entry *hsh;
3443 struct elf32_avr_link_hash_table *htab;
3444 int size;
3445
3446 /* Massage our args to the form they really have. */
3447 hsh = avr_stub_hash_entry (bh);
3448 htab = in_arg;
3449
3450 if (hsh->is_actually_needed)
3451 size = 4;
3452 else
3453 size = 0;
3454
3455 htab->stub_sec->size += size;
3456 return true;
3457 }
3458
3459 void
3460 elf32_avr_setup_params (struct bfd_link_info *info,
3461 bfd *avr_stub_bfd,
3462 asection *avr_stub_section,
3463 bool no_stubs,
3464 bool deb_stubs,
3465 bool deb_relax,
3466 bfd_vma pc_wrap_around,
3467 bool call_ret_replacement)
3468 {
3469 struct elf32_avr_link_hash_table *htab = avr_link_hash_table (info);
3470
3471 if (htab == NULL)
3472 return;
3473 htab->stub_sec = avr_stub_section;
3474 htab->stub_bfd = avr_stub_bfd;
3475 htab->no_stubs = no_stubs;
3476
3477 debug_relax = deb_relax;
3478 debug_stubs = deb_stubs;
3479 avr_pc_wrap_around = pc_wrap_around;
3480 avr_replace_call_ret_sequences = call_ret_replacement;
3481 }
3482
3483
3484 /* Set up various things so that we can make a list of input sections
3485 for each output section included in the link. Returns -1 on error,
3486 0 when no stubs will be needed, and 1 on success. It also sets
3487 information on the stubs bfd and the stub section in the info
3488 struct. */
3489
3490 int
3491 elf32_avr_setup_section_lists (bfd *output_bfd,
3492 struct bfd_link_info *info)
3493 {
3494 bfd *input_bfd;
3495 unsigned int bfd_count;
3496 unsigned int top_id, top_index;
3497 asection *section;
3498 asection **input_list, **list;
3499 size_t amt;
3500 struct elf32_avr_link_hash_table *htab = avr_link_hash_table (info);
3501
3502 if (htab == NULL || htab->no_stubs)
3503 return 0;
3504
3505 /* Count the number of input BFDs and find the top input section id. */
3506 for (input_bfd = info->input_bfds, bfd_count = 0, top_id = 0;
3507 input_bfd != NULL;
3508 input_bfd = input_bfd->link.next)
3509 {
3510 bfd_count += 1;
3511 for (section = input_bfd->sections;
3512 section != NULL;
3513 section = section->next)
3514 if (top_id < section->id)
3515 top_id = section->id;
3516 }
3517
3518 htab->bfd_count = bfd_count;
3519
3520 /* We can't use output_bfd->section_count here to find the top output
3521 section index as some sections may have been removed, and
3522 strip_excluded_output_sections doesn't renumber the indices. */
3523 for (section = output_bfd->sections, top_index = 0;
3524 section != NULL;
3525 section = section->next)
3526 if (top_index < section->index)
3527 top_index = section->index;
3528
3529 htab->top_index = top_index;
3530 amt = sizeof (asection *) * (top_index + 1);
3531 input_list = bfd_malloc (amt);
3532 htab->input_list = input_list;
3533 if (input_list == NULL)
3534 return -1;
3535
3536 /* For sections we aren't interested in, mark their entries with a
3537 value we can check later. */
3538 list = input_list + top_index;
3539 do
3540 *list = bfd_abs_section_ptr;
3541 while (list-- != input_list);
3542
3543 for (section = output_bfd->sections;
3544 section != NULL;
3545 section = section->next)
3546 if ((section->flags & SEC_CODE) != 0)
3547 input_list[section->index] = NULL;
3548
3549 return 1;
3550 }
3551
3552
3553 /* Read in all local syms for all input bfds, and create hash entries
3554 for export stubs if we are building a multi-subspace shared lib.
3555 Returns -1 on error, 0 otherwise. */
3556
3557 static int
3558 get_local_syms (bfd *input_bfd, struct bfd_link_info *info)
3559 {
3560 unsigned int bfd_indx;
3561 Elf_Internal_Sym *local_syms, **all_local_syms;
3562 struct elf32_avr_link_hash_table *htab = avr_link_hash_table (info);
3563 size_t amt;
3564
3565 if (htab == NULL)
3566 return -1;
3567
3568 /* We want to read in symbol extension records only once. To do this
3569 we need to read in the local symbols in parallel and save them for
3570 later use; so hold pointers to the local symbols in an array. */
3571 amt = sizeof (Elf_Internal_Sym *) * htab->bfd_count;
3572 all_local_syms = bfd_zmalloc (amt);
3573 htab->all_local_syms = all_local_syms;
3574 if (all_local_syms == NULL)
3575 return -1;
3576
3577 /* Walk over all the input BFDs, swapping in local symbols.
3578 If we are creating a shared library, create hash entries for the
3579 export stubs. */
3580 for (bfd_indx = 0;
3581 input_bfd != NULL;
3582 input_bfd = input_bfd->link.next, bfd_indx++)
3583 {
3584 Elf_Internal_Shdr *symtab_hdr;
3585
3586 /* We'll need the symbol table in a second. */
3587 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3588 if (symtab_hdr->sh_info == 0)
3589 continue;
3590
3591 /* We need an array of the local symbols attached to the input bfd. */
3592 local_syms = (Elf_Internal_Sym *) symtab_hdr->contents;
3593 if (local_syms == NULL)
3594 {
3595 local_syms = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
3596 symtab_hdr->sh_info, 0,
3597 NULL, NULL, NULL);
3598 /* Cache them for elf_link_input_bfd. */
3599 symtab_hdr->contents = (unsigned char *) local_syms;
3600 }
3601 if (local_syms == NULL)
3602 return -1;
3603
3604 all_local_syms[bfd_indx] = local_syms;
3605 }
3606
3607 return 0;
3608 }
3609
3610 #define ADD_DUMMY_STUBS_FOR_DEBUGGING 0
3611
3612 bool
3613 elf32_avr_size_stubs (bfd *output_bfd,
3614 struct bfd_link_info *info,
3615 bool is_prealloc_run)
3616 {
3617 struct elf32_avr_link_hash_table *htab;
3618 int stub_changed = 0;
3619
3620 htab = avr_link_hash_table (info);
3621 if (htab == NULL)
3622 return false;
3623
3624 /* At this point we initialize htab->vector_base
3625 To the start of the text output section. */
3626 htab->vector_base = htab->stub_sec->output_section->vma;
3627
3628 if (get_local_syms (info->input_bfds, info))
3629 {
3630 if (htab->all_local_syms)
3631 goto error_ret_free_local;
3632 return false;
3633 }
3634
3635 if (ADD_DUMMY_STUBS_FOR_DEBUGGING)
3636 {
3637 struct elf32_avr_stub_hash_entry *test;
3638
3639 test = avr_add_stub ("Hugo",htab);
3640 test->target_value = 0x123456;
3641 test->stub_offset = 13;
3642
3643 test = avr_add_stub ("Hugo2",htab);
3644 test->target_value = 0x84210;
3645 test->stub_offset = 14;
3646 }
3647
3648 while (1)
3649 {
3650 bfd *input_bfd;
3651 unsigned int bfd_indx;
3652
3653 /* We will have to re-generate the stub hash table each time anything
3654 in memory has changed. */
3655
3656 bfd_hash_traverse (&htab->bstab, avr_mark_stub_not_to_be_necessary, htab);
3657 for (input_bfd = info->input_bfds, bfd_indx = 0;
3658 input_bfd != NULL;
3659 input_bfd = input_bfd->link.next, bfd_indx++)
3660 {
3661 Elf_Internal_Shdr *symtab_hdr;
3662 asection *section;
3663 Elf_Internal_Sym *local_syms;
3664
3665 /* We'll need the symbol table in a second. */
3666 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3667 if (symtab_hdr->sh_info == 0)
3668 continue;
3669
3670 local_syms = htab->all_local_syms[bfd_indx];
3671
3672 /* Walk over each section attached to the input bfd. */
3673 for (section = input_bfd->sections;
3674 section != NULL;
3675 section = section->next)
3676 {
3677 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
3678
3679 /* If there aren't any relocs, then there's nothing more
3680 to do. */
3681 if ((section->flags & SEC_RELOC) == 0
3682 || section->reloc_count == 0)
3683 continue;
3684
3685 /* If this section is a link-once section that will be
3686 discarded, then don't create any stubs. */
3687 if (section->output_section == NULL
3688 || section->output_section->owner != output_bfd)
3689 continue;
3690
3691 /* Get the relocs. */
3692 internal_relocs
3693 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
3694 info->keep_memory);
3695 if (internal_relocs == NULL)
3696 goto error_ret_free_local;
3697
3698 /* Now examine each relocation. */
3699 irela = internal_relocs;
3700 irelaend = irela + section->reloc_count;
3701 for (; irela < irelaend; irela++)
3702 {
3703 unsigned int r_type, r_indx;
3704 struct elf32_avr_stub_hash_entry *hsh;
3705 asection *sym_sec;
3706 bfd_vma sym_value;
3707 bfd_vma destination;
3708 struct elf_link_hash_entry *hh;
3709 char *stub_name;
3710
3711 r_type = ELF32_R_TYPE (irela->r_info);
3712 r_indx = ELF32_R_SYM (irela->r_info);
3713
3714 /* Only look for 16 bit GS relocs. No other reloc will need a
3715 stub. */
3716 if (!((r_type == R_AVR_16_PM)
3717 || (r_type == R_AVR_LO8_LDI_GS)
3718 || (r_type == R_AVR_HI8_LDI_GS)))
3719 continue;
3720
3721 /* Now determine the call target, its name, value,
3722 section. */
3723 sym_sec = NULL;
3724 sym_value = 0;
3725 destination = 0;
3726 hh = NULL;
3727 if (r_indx < symtab_hdr->sh_info)
3728 {
3729 /* It's a local symbol. */
3730 Elf_Internal_Sym *sym;
3731 Elf_Internal_Shdr *hdr;
3732 unsigned int shndx;
3733
3734 sym = local_syms + r_indx;
3735 if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
3736 sym_value = sym->st_value;
3737 shndx = sym->st_shndx;
3738 if (shndx < elf_numsections (input_bfd))
3739 {
3740 hdr = elf_elfsections (input_bfd)[shndx];
3741 sym_sec = hdr->bfd_section;
3742 destination = (sym_value + irela->r_addend
3743 + sym_sec->output_offset
3744 + sym_sec->output_section->vma);
3745 }
3746 }
3747 else
3748 {
3749 /* It's an external symbol. */
3750 int e_indx;
3751
3752 e_indx = r_indx - symtab_hdr->sh_info;
3753 hh = elf_sym_hashes (input_bfd)[e_indx];
3754
3755 while (hh->root.type == bfd_link_hash_indirect
3756 || hh->root.type == bfd_link_hash_warning)
3757 hh = (struct elf_link_hash_entry *)
3758 (hh->root.u.i.link);
3759
3760 if (hh->root.type == bfd_link_hash_defined
3761 || hh->root.type == bfd_link_hash_defweak)
3762 {
3763 sym_sec = hh->root.u.def.section;
3764 sym_value = hh->root.u.def.value;
3765 if (sym_sec->output_section != NULL)
3766 destination = (sym_value + irela->r_addend
3767 + sym_sec->output_offset
3768 + sym_sec->output_section->vma);
3769 }
3770 else if (hh->root.type == bfd_link_hash_undefweak)
3771 {
3772 if (! bfd_link_pic (info))
3773 continue;
3774 }
3775 else if (hh->root.type == bfd_link_hash_undefined)
3776 {
3777 if (! (info->unresolved_syms_in_objects == RM_IGNORE
3778 && (ELF_ST_VISIBILITY (hh->other)
3779 == STV_DEFAULT)))
3780 continue;
3781 }
3782 else
3783 {
3784 bfd_set_error (bfd_error_bad_value);
3785
3786 error_ret_free_internal:
3787 if (elf_section_data (section)->relocs == NULL)
3788 free (internal_relocs);
3789 goto error_ret_free_local;
3790 }
3791 }
3792
3793 if (! avr_stub_is_required_for_16_bit_reloc
3794 (destination - htab->vector_base))
3795 {
3796 if (!is_prealloc_run)
3797 /* We are having a reloc that does't need a stub. */
3798 continue;
3799
3800 /* We don't right now know if a stub will be needed.
3801 Let's rather be on the safe side. */
3802 }
3803
3804 /* Get the name of this stub. */
3805 stub_name = avr_stub_name (sym_sec, sym_value, irela);
3806
3807 if (!stub_name)
3808 goto error_ret_free_internal;
3809
3810
3811 hsh = avr_stub_hash_lookup (&htab->bstab,
3812 stub_name,
3813 false, false);
3814 if (hsh != NULL)
3815 {
3816 /* The proper stub has already been created. Mark it
3817 to be used and write the possibly changed destination
3818 value. */
3819 hsh->is_actually_needed = true;
3820 hsh->target_value = destination;
3821 free (stub_name);
3822 continue;
3823 }
3824
3825 hsh = avr_add_stub (stub_name, htab);
3826 if (hsh == NULL)
3827 {
3828 free (stub_name);
3829 goto error_ret_free_internal;
3830 }
3831
3832 hsh->is_actually_needed = true;
3833 hsh->target_value = destination;
3834
3835 if (debug_stubs)
3836 printf ("Adding stub with destination 0x%x to the"
3837 " hash table.\n", (unsigned int) destination);
3838 if (debug_stubs)
3839 printf ("(Pre-Alloc run: %i)\n", is_prealloc_run);
3840
3841 stub_changed = true;
3842 }
3843
3844 /* We're done with the internal relocs, free them. */
3845 if (elf_section_data (section)->relocs == NULL)
3846 free (internal_relocs);
3847 }
3848 }
3849
3850 /* Re-Calculate the number of needed stubs. */
3851 htab->stub_sec->size = 0;
3852 bfd_hash_traverse (&htab->bstab, avr_size_one_stub, htab);
3853
3854 if (!stub_changed)
3855 break;
3856
3857 stub_changed = false;
3858 }
3859
3860 free (htab->all_local_syms);
3861 return true;
3862
3863 error_ret_free_local:
3864 free (htab->all_local_syms);
3865 return false;
3866 }
3867
3868
3869 /* Build all the stubs associated with the current output file. The
3870 stubs are kept in a hash table attached to the main linker hash
3871 table. We also set up the .plt entries for statically linked PIC
3872 functions here. This function is called via hppaelf_finish in the
3873 linker. */
3874
3875 bool
3876 elf32_avr_build_stubs (struct bfd_link_info *info)
3877 {
3878 asection *stub_sec;
3879 struct bfd_hash_table *table;
3880 struct elf32_avr_link_hash_table *htab;
3881 bfd_size_type total_size = 0;
3882
3883 htab = avr_link_hash_table (info);
3884 if (htab == NULL)
3885 return false;
3886
3887 /* In case that there were several stub sections: */
3888 for (stub_sec = htab->stub_bfd->sections;
3889 stub_sec != NULL;
3890 stub_sec = stub_sec->next)
3891 {
3892 bfd_size_type size;
3893
3894 /* Allocate memory to hold the linker stubs. */
3895 size = stub_sec->size;
3896 total_size += size;
3897
3898 stub_sec->contents = bfd_zalloc (htab->stub_bfd, size);
3899 if (stub_sec->contents == NULL && size != 0)
3900 return false;
3901 stub_sec->size = 0;
3902 }
3903
3904 /* Allocate memory for the adress mapping table. */
3905 htab->amt_entry_cnt = 0;
3906 htab->amt_max_entry_cnt = total_size / 4;
3907 htab->amt_stub_offsets = bfd_malloc (sizeof (bfd_vma)
3908 * htab->amt_max_entry_cnt);
3909 htab->amt_destination_addr = bfd_malloc (sizeof (bfd_vma)
3910 * htab->amt_max_entry_cnt );
3911
3912 if (debug_stubs)
3913 printf ("Allocating %i entries in the AMT\n", htab->amt_max_entry_cnt);
3914
3915 /* Build the stubs as directed by the stub hash table. */
3916 table = &htab->bstab;
3917 bfd_hash_traverse (table, avr_build_one_stub, info);
3918
3919 if (debug_stubs)
3920 printf ("Final Stub section Size: %i\n", (int) htab->stub_sec->size);
3921
3922 return true;
3923 }
3924
3925 /* Callback used by QSORT to order relocations AP and BP. */
3926
3927 static int
3928 internal_reloc_compare (const void *ap, const void *bp)
3929 {
3930 const Elf_Internal_Rela *a = (const Elf_Internal_Rela *) ap;
3931 const Elf_Internal_Rela *b = (const Elf_Internal_Rela *) bp;
3932
3933 if (a->r_offset != b->r_offset)
3934 return (a->r_offset - b->r_offset);
3935
3936 /* We don't need to sort on these criteria for correctness,
3937 but enforcing a more strict ordering prevents unstable qsort
3938 from behaving differently with different implementations.
3939 Without the code below we get correct but different results
3940 on Solaris 2.7 and 2.8. We would like to always produce the
3941 same results no matter the host. */
3942
3943 if (a->r_info != b->r_info)
3944 return (a->r_info - b->r_info);
3945
3946 return (a->r_addend - b->r_addend);
3947 }
3948
3949 /* Return true if ADDRESS is within the vma range of SECTION from ABFD. */
3950
3951 static bool
3952 avr_is_section_for_address (asection *section, bfd_vma address)
3953 {
3954 bfd_vma vma;
3955 bfd_size_type size;
3956
3957 vma = bfd_section_vma (section);
3958 if (address < vma)
3959 return false;
3960
3961 size = section->size;
3962 if (address >= vma + size)
3963 return false;
3964
3965 return true;
3966 }
3967
3968 /* Data structure used by AVR_FIND_SECTION_FOR_ADDRESS. */
3969
3970 struct avr_find_section_data
3971 {
3972 /* The address we're looking for. */
3973 bfd_vma address;
3974
3975 /* The section we've found. */
3976 asection *section;
3977 };
3978
3979 /* Helper function to locate the section holding a certain virtual memory
3980 address. This is called via bfd_map_over_sections. The DATA is an
3981 instance of STRUCT AVR_FIND_SECTION_DATA, the address field of which
3982 has been set to the address to search for, and the section field has
3983 been set to NULL. If SECTION from ABFD contains ADDRESS then the
3984 section field in DATA will be set to SECTION. As an optimisation, if
3985 the section field is already non-null then this function does not
3986 perform any checks, and just returns. */
3987
3988 static void
3989 avr_find_section_for_address (bfd *abfd ATTRIBUTE_UNUSED,
3990 asection *section, void *data)
3991 {
3992 struct avr_find_section_data *fs_data
3993 = (struct avr_find_section_data *) data;
3994
3995 /* Return if already found. */
3996 if (fs_data->section != NULL)
3997 return;
3998
3999 /* If this section isn't part of the addressable code content, skip it. */
4000 if ((bfd_section_flags (section) & SEC_ALLOC) == 0
4001 && (bfd_section_flags (section) & SEC_CODE) == 0)
4002 return;
4003
4004 if (avr_is_section_for_address (section, fs_data->address))
4005 fs_data->section = section;
4006 }
4007
4008 /* Load all of the property records from SEC, a section from ABFD. Return
4009 a STRUCT AVR_PROPERTY_RECORD_LIST containing all the records. The
4010 memory for the returned structure, and all of the records pointed too by
4011 the structure are allocated with a single call to malloc, so, only the
4012 pointer returned needs to be free'd. */
4013
4014 static struct avr_property_record_list *
4015 avr_elf32_load_records_from_section (bfd *abfd, asection *sec)
4016 {
4017 bfd_byte *contents, *ptr;
4018 bfd_size_type size, mem_size;
4019 bfd_byte version, flags;
4020 uint16_t record_count, i;
4021 struct avr_property_record_list *r_list = NULL;
4022 Elf_Internal_Rela *internal_relocs = NULL, *rel, *rel_end;
4023 struct avr_find_section_data fs_data;
4024
4025 fs_data.section = NULL;
4026
4027 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
4028 goto load_failed;
4029 ptr = contents;
4030
4031 /* Load the relocations for the '.avr.prop' section if there are any, and
4032 sort them. */
4033 internal_relocs = (_bfd_elf_link_read_relocs
4034 (abfd, sec, NULL, NULL, false));
4035 if (internal_relocs)
4036 qsort (internal_relocs, sec->reloc_count,
4037 sizeof (Elf_Internal_Rela), internal_reloc_compare);
4038
4039 /* There is a header at the start of the property record section SEC, the
4040 format of this header is:
4041 uint8_t : version number
4042 uint8_t : flags
4043 uint16_t : record counter
4044 */
4045
4046 /* Check we have at least got a headers worth of bytes. */
4047 size = bfd_section_size (sec);
4048 if (size < AVR_PROPERTY_SECTION_HEADER_SIZE)
4049 goto load_failed;
4050
4051 version = *ptr;
4052 ptr++;
4053 flags = *ptr;
4054 ptr++;
4055 record_count = bfd_get_16 (abfd, ptr);
4056 ptr += 2;
4057 BFD_ASSERT (ptr - contents == AVR_PROPERTY_SECTION_HEADER_SIZE);
4058
4059 /* Now allocate space for the list structure, and all of the list
4060 elements in a single block. */
4061 mem_size = sizeof (struct avr_property_record_list)
4062 + sizeof (struct avr_property_record) * record_count;
4063 r_list = bfd_malloc (mem_size);
4064 if (r_list == NULL)
4065 goto load_failed;
4066
4067 r_list->version = version;
4068 r_list->flags = flags;
4069 r_list->section = sec;
4070 r_list->record_count = record_count;
4071 r_list->records = (struct avr_property_record *) (&r_list [1]);
4072 size -= AVR_PROPERTY_SECTION_HEADER_SIZE;
4073
4074 /* Check that we understand the version number. There is only one
4075 version number right now, anything else is an error. */
4076 if (r_list->version != AVR_PROPERTY_RECORDS_VERSION)
4077 goto load_failed;
4078
4079 rel = internal_relocs;
4080 rel_end = rel + sec->reloc_count;
4081 for (i = 0; i < record_count; ++i)
4082 {
4083 bfd_vma address;
4084
4085 /* Each entry is a 32-bit address, followed by a single byte type.
4086 After that is the type specific data. We must take care to
4087 ensure that we don't read beyond the end of the section data. */
4088 if (size < 5)
4089 goto load_failed;
4090
4091 r_list->records [i].section = NULL;
4092 r_list->records [i].offset = 0;
4093
4094 if (rel)
4095 {
4096 /* The offset of the address within the .avr.prop section. */
4097 size_t offset = ptr - contents;
4098
4099 while (rel < rel_end && rel->r_offset < offset)
4100 ++rel;
4101
4102 if (rel == rel_end)
4103 rel = NULL;
4104 else if (rel->r_offset == offset)
4105 {
4106 /* Find section and section offset. */
4107 unsigned long r_symndx;
4108
4109 asection * rel_sec;
4110 bfd_vma sec_offset;
4111
4112 r_symndx = ELF32_R_SYM (rel->r_info);
4113 rel_sec = get_elf_r_symndx_section (abfd, r_symndx);
4114 sec_offset = get_elf_r_symndx_offset (abfd, r_symndx)
4115 + rel->r_addend;
4116
4117 r_list->records [i].section = rel_sec;
4118 r_list->records [i].offset = sec_offset;
4119 }
4120 }
4121
4122 address = bfd_get_32 (abfd, ptr);
4123 ptr += 4;
4124 size -= 4;
4125
4126 if (r_list->records [i].section == NULL)
4127 {
4128 /* Try to find section and offset from address. */
4129 if (fs_data.section != NULL
4130 && !avr_is_section_for_address (fs_data.section, address))
4131 fs_data.section = NULL;
4132
4133 if (fs_data.section == NULL)
4134 {
4135 fs_data.address = address;
4136 bfd_map_over_sections (abfd, avr_find_section_for_address,
4137 &fs_data);
4138 }
4139
4140 if (fs_data.section == NULL)
4141 {
4142 fprintf (stderr, "Failed to find matching section.\n");
4143 goto load_failed;
4144 }
4145
4146 r_list->records [i].section = fs_data.section;
4147 r_list->records [i].offset
4148 = address - bfd_section_vma (fs_data.section);
4149 }
4150
4151 r_list->records [i].type = *ptr;
4152 ptr += 1;
4153 size -= 1;
4154
4155 switch (r_list->records [i].type)
4156 {
4157 case RECORD_ORG:
4158 /* Nothing else to load. */
4159 break;
4160 case RECORD_ORG_AND_FILL:
4161 /* Just a 4-byte fill to load. */
4162 if (size < 4)
4163 goto load_failed;
4164 r_list->records [i].data.org.fill = bfd_get_32 (abfd, ptr);
4165 ptr += 4;
4166 size -= 4;
4167 break;
4168 case RECORD_ALIGN:
4169 /* Just a 4-byte alignment to load. */
4170 if (size < 4)
4171 goto load_failed;
4172 r_list->records [i].data.align.bytes = bfd_get_32 (abfd, ptr);
4173 ptr += 4;
4174 size -= 4;
4175 /* Just initialise PRECEDING_DELETED field, this field is
4176 used during linker relaxation. */
4177 r_list->records [i].data.align.preceding_deleted = 0;
4178 break;
4179 case RECORD_ALIGN_AND_FILL:
4180 /* A 4-byte alignment, and a 4-byte fill to load. */
4181 if (size < 8)
4182 goto load_failed;
4183 r_list->records [i].data.align.bytes = bfd_get_32 (abfd, ptr);
4184 ptr += 4;
4185 r_list->records [i].data.align.fill = bfd_get_32 (abfd, ptr);
4186 ptr += 4;
4187 size -= 8;
4188 /* Just initialise PRECEDING_DELETED field, this field is
4189 used during linker relaxation. */
4190 r_list->records [i].data.align.preceding_deleted = 0;
4191 break;
4192 default:
4193 goto load_failed;
4194 }
4195 }
4196
4197 free (contents);
4198 if (elf_section_data (sec)->relocs != internal_relocs)
4199 free (internal_relocs);
4200 return r_list;
4201
4202 load_failed:
4203 if (elf_section_data (sec)->relocs != internal_relocs)
4204 free (internal_relocs);
4205 free (contents);
4206 free (r_list);
4207 return NULL;
4208 }
4209
4210 /* Load all of the property records from ABFD. See
4211 AVR_ELF32_LOAD_RECORDS_FROM_SECTION for details of the return value. */
4212
4213 struct avr_property_record_list *
4214 avr_elf32_load_property_records (bfd *abfd)
4215 {
4216 asection *sec;
4217
4218 /* Find the '.avr.prop' section and load the contents into memory. */
4219 sec = bfd_get_section_by_name (abfd, AVR_PROPERTY_RECORD_SECTION_NAME);
4220 if (sec == NULL || (sec->flags & SEC_HAS_CONTENTS) == 0)
4221 return NULL;
4222 return avr_elf32_load_records_from_section (abfd, sec);
4223 }
4224
4225 const char *
4226 avr_elf32_property_record_name (struct avr_property_record *rec)
4227 {
4228 const char *str;
4229
4230 switch (rec->type)
4231 {
4232 case RECORD_ORG:
4233 str = "ORG";
4234 break;
4235 case RECORD_ORG_AND_FILL:
4236 str = "ORG+FILL";
4237 break;
4238 case RECORD_ALIGN:
4239 str = "ALIGN";
4240 break;
4241 case RECORD_ALIGN_AND_FILL:
4242 str = "ALIGN+FILL";
4243 break;
4244 default:
4245 str = "unknown";
4246 }
4247
4248 return str;
4249 }
4250
4251
4252 #define ELF_ARCH bfd_arch_avr
4253 #define ELF_TARGET_ID AVR_ELF_DATA
4254 #define ELF_MACHINE_CODE EM_AVR
4255 #define ELF_MACHINE_ALT1 EM_AVR_OLD
4256 #define ELF_MAXPAGESIZE 1
4257
4258 #define TARGET_LITTLE_SYM avr_elf32_vec
4259 #define TARGET_LITTLE_NAME "elf32-avr"
4260
4261 #define bfd_elf32_bfd_link_hash_table_create elf32_avr_link_hash_table_create
4262
4263 #define elf_info_to_howto avr_info_to_howto_rela
4264 #define elf_info_to_howto_rel NULL
4265 #define elf_backend_relocate_section elf32_avr_relocate_section
4266 #define elf_backend_can_gc_sections 1
4267 #define elf_backend_rela_normal 1
4268 #define elf_backend_final_write_processing \
4269 bfd_elf_avr_final_write_processing
4270 #define elf_backend_object_p elf32_avr_object_p
4271
4272 #define bfd_elf32_bfd_relax_section elf32_avr_relax_section
4273 #define bfd_elf32_bfd_get_relocated_section_contents \
4274 elf32_avr_get_relocated_section_contents
4275 #define bfd_elf32_new_section_hook elf_avr_new_section_hook
4276 #define elf_backend_special_sections elf_avr_special_sections
4277
4278 #include "elf32-target.h"
The GNU Binutils are a collection of binary tools.