?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add a note to the binutils/NEWS file about DCO signed contributions.
[binutils-gdb.git] / bfd / elf32-avr.c
blobf8b89930ef5f3b33bf86956c80e37aae37d73d15
1 /* AVR-specific support for 32-bit ELF
2 Copyright (C) 1999-2022 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->flags & SEC_RELOC) == 0
2526 || sec->reloc_count == 0
2527 || (sec->flags & SEC_CODE) == 0)
2528 return true;
2529
2530 /* Check if the object file to relax uses internal symbols so that we
2531 could fix up the relocations. */
2532 if (!(elf_elfheader (abfd)->e_flags & EF_AVR_LINKRELAX_PREPARED))
2533 return true;
2534
2535 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2536
2537 /* Get a copy of the native relocations. */
2538 internal_relocs = (_bfd_elf_link_read_relocs
2539 (abfd, sec, NULL, NULL, link_info->keep_memory));
2540 if (internal_relocs == NULL)
2541 goto error_return;
2542
2543 /* Walk through the relocs looking for relaxing opportunities. */
2544 irelend = internal_relocs + sec->reloc_count;
2545 for (irel = internal_relocs; irel < irelend; irel++)
2546 {
2547 bfd_vma symval;
2548
2549 if ( ELF32_R_TYPE (irel->r_info) != R_AVR_13_PCREL
2550 && ELF32_R_TYPE (irel->r_info) != R_AVR_7_PCREL
2551 && ELF32_R_TYPE (irel->r_info) != R_AVR_CALL)
2552 continue;
2553
2554 /* Get the section contents if we haven't done so already. */
2555 if (contents == NULL)
2556 {
2557 /* Get cached copy if it exists. */
2558 if (elf_section_data (sec)->this_hdr.contents != NULL)
2559 contents = elf_section_data (sec)->this_hdr.contents;
2560 else
2561 {
2562 /* Go get them off disk. */
2563 if (! bfd_malloc_and_get_section (abfd, sec, &contents))
2564 goto error_return;
2565 }
2566 }
2567
2568 /* Read this BFD's local symbols if we haven't done so already. */
2569 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
2570 {
2571 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2572 if (isymbuf == NULL)
2573 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
2574 symtab_hdr->sh_info, 0,
2575 NULL, NULL, NULL);
2576 if (isymbuf == NULL)
2577 goto error_return;
2578 }
2579
2580
2581 /* Get the value of the symbol referred to by the reloc. */
2582 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
2583 {
2584 /* A local symbol. */
2585 Elf_Internal_Sym *isym;
2586 asection *sym_sec;
2587
2588 isym = isymbuf + ELF32_R_SYM (irel->r_info);
2589 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
2590 symval = isym->st_value;
2591 /* If the reloc is absolute, it will not have
2592 a symbol or section associated with it. */
2593 if (sym_sec)
2594 symval += sym_sec->output_section->vma
2595 + sym_sec->output_offset;
2596 }
2597 else
2598 {
2599 unsigned long indx;
2600 struct elf_link_hash_entry *h;
2601
2602 /* An external symbol. */
2603 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
2604 h = elf_sym_hashes (abfd)[indx];
2605 BFD_ASSERT (h != NULL);
2606 if (h->root.type != bfd_link_hash_defined
2607 && h->root.type != bfd_link_hash_defweak)
2608 /* This appears to be a reference to an undefined
2609 symbol. Just ignore it--it will be caught by the
2610 regular reloc processing. */
2611 continue;
2612
2613 symval = (h->root.u.def.value
2614 + h->root.u.def.section->output_section->vma
2615 + h->root.u.def.section->output_offset);
2616 }
2617
2618 /* For simplicity of coding, we are going to modify the section
2619 contents, the section relocs, and the BFD symbol table. We
2620 must tell the rest of the code not to free up this
2621 information. It would be possible to instead create a table
2622 of changes which have to be made, as is done in coff-mips.c;
2623 that would be more work, but would require less memory when
2624 the linker is run. */
2625 switch (ELF32_R_TYPE (irel->r_info))
2626 {
2627 /* Try to turn a 22-bit absolute call/jump into an 13-bit
2628 pc-relative rcall/rjmp. */
2629 case R_AVR_CALL:
2630 {
2631 bfd_vma value = symval + irel->r_addend;
2632 bfd_vma dot, gap;
2633 int distance_short_enough = 0;
2634
2635 /* Get the address of this instruction. */
2636 dot = (sec->output_section->vma
2637 + sec->output_offset + irel->r_offset);
2638
2639 /* Compute the distance from this insn to the branch target. */
2640 gap = value - dot;
2641
2642 /* The ISA manual states that addressable range is PC - 2k + 1 to
2643 PC + 2k. In bytes, that would be -4094 <= PC <= 4096. The range
2644 is shifted one word to the right, because pc-relative instructions
2645 implicitly add one word i.e. rjmp 0 jumps to next insn, not the
2646 current one.
2647 Therefore, for the !shrinkable case, the range is as above.
2648 If shrinkable, then the current code only deletes bytes 3 and
2649 4 of the absolute call/jmp, so the forward jump range increases
2650 by 2 bytes, but the backward (negative) jump range remains
2651 the same. */
2652
2653
2654 /* Check if the gap falls in the range that can be accommodated
2655 in 13bits signed (It is 12bits when encoded, as we deal with
2656 word addressing). */
2657 if (!shrinkable && ((int) gap >= -4094 && (int) gap <= 4096))
2658 distance_short_enough = 1;
2659 /* If shrinkable, then we can check for a range of distance which
2660 is two bytes farther on the positive direction because the call
2661 or jump target will be closer by two bytes after the
2662 relaxation. */
2663 else if (shrinkable && ((int) gap >= -4094 && (int) gap <= 4098))
2664 distance_short_enough = 1;
2665
2666 /* Here we handle the wrap-around case. E.g. for a 16k device
2667 we could use a rjmp to jump from address 0x100 to 0x3d00!
2668 In order to make this work properly, we need to fill the
2669 vaiable avr_pc_wrap_around with the appropriate value.
2670 I.e. 0x4000 for a 16k device. */
2671 {
2672 /* Shrinking the code size makes the gaps larger in the
2673 case of wrap-arounds. So we use a heuristical safety
2674 margin to avoid that during relax the distance gets
2675 again too large for the short jumps. Let's assume
2676 a typical code-size reduction due to relax for a
2677 16k device of 600 bytes. So let's use twice the
2678 typical value as safety margin. */
2679 int rgap;
2680 int safety_margin;
2681
2682 int assumed_shrink = 600;
2683 if (avr_pc_wrap_around > 0x4000)
2684 assumed_shrink = 900;
2685
2686 safety_margin = 2 * assumed_shrink;
2687
2688 rgap = avr_relative_distance_considering_wrap_around (gap);
2689
2690 if (rgap >= (-4092 + safety_margin)
2691 && rgap <= (4094 - safety_margin))
2692 distance_short_enough = 1;
2693 }
2694
2695 if (distance_short_enough)
2696 {
2697 unsigned char code_msb;
2698 unsigned char code_lsb;
2699
2700 if (debug_relax)
2701 printf ("shrinking jump/call instruction at address 0x%x"
2702 " in section %s\n\n",
2703 (int) dot, sec->name);
2704
2705 /* Note that we've changed the relocs, section contents,
2706 etc. */
2707 elf_section_data (sec)->relocs = internal_relocs;
2708 elf_section_data (sec)->this_hdr.contents = contents;
2709 symtab_hdr->contents = (unsigned char *) isymbuf;
2710
2711 /* Get the instruction code for relaxing. */
2712 code_lsb = bfd_get_8 (abfd, contents + irel->r_offset);
2713 code_msb = bfd_get_8 (abfd, contents + irel->r_offset + 1);
2714
2715 /* Mask out the relocation bits. */
2716 code_msb &= 0x94;
2717 code_lsb &= 0x0E;
2718 if (code_msb == 0x94 && code_lsb == 0x0E)
2719 {
2720 /* we are changing call -> rcall . */
2721 bfd_put_8 (abfd, 0x00, contents + irel->r_offset);
2722 bfd_put_8 (abfd, 0xD0, contents + irel->r_offset + 1);
2723 }
2724 else if (code_msb == 0x94 && code_lsb == 0x0C)
2725 {
2726 /* we are changeing jump -> rjmp. */
2727 bfd_put_8 (abfd, 0x00, contents + irel->r_offset);
2728 bfd_put_8 (abfd, 0xC0, contents + irel->r_offset + 1);
2729 }
2730 else
2731 abort ();
2732
2733 /* Fix the relocation's type. */
2734 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2735 R_AVR_13_PCREL);
2736
2737 /* We should not modify the ordering if 'shrinkable' is
2738 FALSE. */
2739 if (!shrinkable)
2740 {
2741 /* Let's insert a nop. */
2742 bfd_put_8 (abfd, 0x00, contents + irel->r_offset + 2);
2743 bfd_put_8 (abfd, 0x00, contents + irel->r_offset + 3);
2744 }
2745 else
2746 {
2747 /* Delete two bytes of data. */
2748 if (!elf32_avr_relax_delete_bytes (abfd, sec,
2749 irel->r_offset + 2, 2,
2750 true))
2751 goto error_return;
2752
2753 /* That will change things, so, we should relax again.
2754 Note that this is not required, and it may be slow. */
2755 *again = true;
2756 }
2757 }
2758 }
2759 /* Fall through. */
2760
2761 default:
2762 {
2763 unsigned char code_msb;
2764 unsigned char code_lsb;
2765 bfd_vma dot;
2766
2767 code_msb = bfd_get_8 (abfd, contents + irel->r_offset + 1);
2768 code_lsb = bfd_get_8 (abfd, contents + irel->r_offset + 0);
2769
2770 /* Get the address of this instruction. */
2771 dot = (sec->output_section->vma
2772 + sec->output_offset + irel->r_offset);
2773
2774 /* Here we look for rcall/ret or call/ret sequences that could be
2775 safely replaced by rjmp/ret or jmp/ret. */
2776 if (((code_msb & 0xf0) == 0xd0)
2777 && avr_replace_call_ret_sequences)
2778 {
2779 /* This insn is a rcall. */
2780 unsigned char next_insn_msb = 0;
2781 unsigned char next_insn_lsb = 0;
2782
2783 if (irel->r_offset + 3 < sec->size)
2784 {
2785 next_insn_msb =
2786 bfd_get_8 (abfd, contents + irel->r_offset + 3);
2787 next_insn_lsb =
2788 bfd_get_8 (abfd, contents + irel->r_offset + 2);
2789 }
2790
2791 if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb))
2792 {
2793 /* The next insn is a ret. We now convert the rcall insn
2794 into a rjmp instruction. */
2795 code_msb &= 0xef;
2796 bfd_put_8 (abfd, code_msb, contents + irel->r_offset + 1);
2797 if (debug_relax)
2798 printf ("converted rcall/ret sequence at address 0x%x"
2799 " into rjmp/ret sequence. Section is %s\n\n",
2800 (int) dot, sec->name);
2801 *again = true;
2802 break;
2803 }
2804 }
2805 else if ((0x94 == (code_msb & 0xfe))
2806 && (0x0e == (code_lsb & 0x0e))
2807 && avr_replace_call_ret_sequences)
2808 {
2809 /* This insn is a call. */
2810 unsigned char next_insn_msb = 0;
2811 unsigned char next_insn_lsb = 0;
2812
2813 if (irel->r_offset + 5 < sec->size)
2814 {
2815 next_insn_msb =
2816 bfd_get_8 (abfd, contents + irel->r_offset + 5);
2817 next_insn_lsb =
2818 bfd_get_8 (abfd, contents + irel->r_offset + 4);
2819 }
2820
2821 if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb))
2822 {
2823 /* The next insn is a ret. We now convert the call insn
2824 into a jmp instruction. */
2825
2826 code_lsb &= 0xfd;
2827 bfd_put_8 (abfd, code_lsb, contents + irel->r_offset);
2828 if (debug_relax)
2829 printf ("converted call/ret sequence at address 0x%x"
2830 " into jmp/ret sequence. Section is %s\n\n",
2831 (int) dot, sec->name);
2832 *again = true;
2833 break;
2834 }
2835 }
2836 else if ((0xc0 == (code_msb & 0xf0))
2837 || ((0x94 == (code_msb & 0xfe))
2838 && (0x0c == (code_lsb & 0x0e))))
2839 {
2840 /* This insn is a rjmp or a jmp. */
2841 unsigned char next_insn_msb = 0;
2842 unsigned char next_insn_lsb = 0;
2843 int insn_size;
2844
2845 if (0xc0 == (code_msb & 0xf0))
2846 insn_size = 2; /* rjmp insn */
2847 else
2848 insn_size = 4; /* jmp insn */
2849
2850 if (irel->r_offset + insn_size + 1 < sec->size)
2851 {
2852 next_insn_msb =
2853 bfd_get_8 (abfd, contents + irel->r_offset
2854 + insn_size + 1);
2855 next_insn_lsb =
2856 bfd_get_8 (abfd, contents + irel->r_offset
2857 + insn_size);
2858 }
2859
2860 if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb))
2861 {
2862 /* The next insn is a ret. We possibly could delete
2863 this ret. First we need to check for preceding
2864 sbis/sbic/sbrs or cpse "skip" instructions. */
2865
2866 int there_is_preceding_non_skip_insn = 1;
2867 bfd_vma address_of_ret;
2868
2869 address_of_ret = dot + insn_size;
2870
2871 if (debug_relax && (insn_size == 2))
2872 printf ("found rjmp / ret sequence at address 0x%x\n",
2873 (int) dot);
2874 if (debug_relax && (insn_size == 4))
2875 printf ("found jmp / ret sequence at address 0x%x\n",
2876 (int) dot);
2877
2878 /* We have to make sure that there is a preceding insn. */
2879 if (irel->r_offset >= 2)
2880 {
2881 unsigned char preceding_msb;
2882 unsigned char preceding_lsb;
2883
2884 preceding_msb =
2885 bfd_get_8 (abfd, contents + irel->r_offset - 1);
2886 preceding_lsb =
2887 bfd_get_8 (abfd, contents + irel->r_offset - 2);
2888
2889 /* sbic. */
2890 if (0x99 == preceding_msb)
2891 there_is_preceding_non_skip_insn = 0;
2892
2893 /* sbis. */
2894 if (0x9b == preceding_msb)
2895 there_is_preceding_non_skip_insn = 0;
2896
2897 /* sbrc */
2898 if ((0xfc == (preceding_msb & 0xfe)
2899 && (0x00 == (preceding_lsb & 0x08))))
2900 there_is_preceding_non_skip_insn = 0;
2901
2902 /* sbrs */
2903 if ((0xfe == (preceding_msb & 0xfe)
2904 && (0x00 == (preceding_lsb & 0x08))))
2905 there_is_preceding_non_skip_insn = 0;
2906
2907 /* cpse */
2908 if (0x10 == (preceding_msb & 0xfc))
2909 there_is_preceding_non_skip_insn = 0;
2910
2911 if (there_is_preceding_non_skip_insn == 0)
2912 if (debug_relax)
2913 printf ("preceding skip insn prevents deletion of"
2914 " ret insn at Addy 0x%x in section %s\n",
2915 (int) dot + 2, sec->name);
2916 }
2917 else
2918 {
2919 /* There is no previous instruction. */
2920 there_is_preceding_non_skip_insn = 0;
2921 }
2922
2923 if (there_is_preceding_non_skip_insn)
2924 {
2925 /* We now only have to make sure that there is no
2926 local label defined at the address of the ret
2927 instruction and that there is no local relocation
2928 in this section pointing to the ret. */
2929
2930 int deleting_ret_is_safe = 1;
2931 unsigned int section_offset_of_ret_insn =
2932 irel->r_offset + insn_size;
2933 Elf_Internal_Sym *isym, *isymend;
2934 unsigned int sec_shndx;
2935 struct bfd_section *isec;
2936
2937 sec_shndx =
2938 _bfd_elf_section_from_bfd_section (abfd, sec);
2939
2940 /* Check for local symbols. */
2941 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
2942 isymend = isym + symtab_hdr->sh_info;
2943 /* PR 6019: There may not be any local symbols. */
2944 for (; isym != NULL && isym < isymend; isym++)
2945 {
2946 if (isym->st_value == section_offset_of_ret_insn
2947 && isym->st_shndx == sec_shndx)
2948 {
2949 deleting_ret_is_safe = 0;
2950 if (debug_relax)
2951 printf ("local label prevents deletion of ret "
2952 "insn at address 0x%x\n",
2953 (int) dot + insn_size);
2954 }
2955 }
2956
2957 /* Now check for global symbols. */
2958 {
2959 int symcount;
2960 struct elf_link_hash_entry **sym_hashes;
2961 struct elf_link_hash_entry **end_hashes;
2962
2963 symcount = (symtab_hdr->sh_size
2964 / sizeof (Elf32_External_Sym)
2965 - symtab_hdr->sh_info);
2966 sym_hashes = elf_sym_hashes (abfd);
2967 end_hashes = sym_hashes + symcount;
2968 for (; sym_hashes < end_hashes; sym_hashes++)
2969 {
2970 struct elf_link_hash_entry *sym_hash =
2971 *sym_hashes;
2972 if ((sym_hash->root.type == bfd_link_hash_defined
2973 || sym_hash->root.type ==
2974 bfd_link_hash_defweak)
2975 && sym_hash->root.u.def.section == sec
2976 && sym_hash->root.u.def.value == section_offset_of_ret_insn)
2977 {
2978 deleting_ret_is_safe = 0;
2979 if (debug_relax)
2980 printf ("global label prevents deletion of "
2981 "ret insn at address 0x%x\n",
2982 (int) dot + insn_size);
2983 }
2984 }
2985 }
2986
2987 /* Now we check for relocations pointing to ret. */
2988 for (isec = abfd->sections; isec && deleting_ret_is_safe; isec = isec->next)
2989 {
2990 Elf_Internal_Rela *rel;
2991 Elf_Internal_Rela *relend;
2992
2993 rel = elf_section_data (isec)->relocs;
2994 if (rel == NULL)
2995 rel = _bfd_elf_link_read_relocs (abfd, isec, NULL, NULL, true);
2996
2997 relend = rel + isec->reloc_count;
2998
2999 for (; rel && rel < relend; rel++)
3000 {
3001 bfd_vma reloc_target = 0;
3002
3003 /* Read this BFD's local symbols if we haven't
3004 done so already. */
3005 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
3006 {
3007 isymbuf = (Elf_Internal_Sym *)
3008 symtab_hdr->contents;
3009 if (isymbuf == NULL)
3010 isymbuf = bfd_elf_get_elf_syms
3011 (abfd,
3012 symtab_hdr,
3013 symtab_hdr->sh_info, 0,
3014 NULL, NULL, NULL);
3015 if (isymbuf == NULL)
3016 break;
3017 }
3018
3019 /* Get the value of the symbol referred to
3020 by the reloc. */
3021 if (ELF32_R_SYM (rel->r_info)
3022 < symtab_hdr->sh_info)
3023 {
3024 /* A local symbol. */
3025 asection *sym_sec;
3026
3027 isym = isymbuf
3028 + ELF32_R_SYM (rel->r_info);
3029 sym_sec = bfd_section_from_elf_index
3030 (abfd, isym->st_shndx);
3031 symval = isym->st_value;
3032
3033 /* If the reloc is absolute, it will not
3034 have a symbol or section associated
3035 with it. */
3036
3037 if (sym_sec)
3038 {
3039 symval +=
3040 sym_sec->output_section->vma
3041 + sym_sec->output_offset;
3042 reloc_target = symval + rel->r_addend;
3043 }
3044 else
3045 {
3046 reloc_target = symval + rel->r_addend;
3047 /* Reference symbol is absolute. */
3048 }
3049 }
3050 /* else ... reference symbol is extern. */
3051
3052 if (address_of_ret == reloc_target)
3053 {
3054 deleting_ret_is_safe = 0;
3055 if (debug_relax)
3056 printf ("ret from "
3057 "rjmp/jmp ret sequence at address"
3058 " 0x%x could not be deleted. ret"
3059 " is target of a relocation.\n",
3060 (int) address_of_ret);
3061 break;
3062 }
3063 }
3064 }
3065
3066 if (deleting_ret_is_safe)
3067 {
3068 if (debug_relax)
3069 printf ("unreachable ret instruction "
3070 "at address 0x%x deleted.\n",
3071 (int) dot + insn_size);
3072
3073 elf_section_data (sec)->relocs = internal_relocs;
3074 elf_section_data (sec)->this_hdr.contents = contents;
3075 symtab_hdr->contents = (unsigned char *) isymbuf;
3076
3077 /* Delete two bytes of data. */
3078 if (!elf32_avr_relax_delete_bytes (abfd, sec,
3079 irel->r_offset + insn_size, 2,
3080 true))
3081 goto error_return;
3082
3083 /* That will change things, so, we should relax
3084 again. Note that this is not required, and it
3085 may be slow. */
3086 *again = true;
3087 break;
3088 }
3089 }
3090 }
3091 }
3092 break;
3093 }
3094 }
3095 }
3096
3097 if (!*again)
3098 {
3099 /* Look through all the property records in this section to see if
3100 there's any alignment records that can be moved. */
3101 struct avr_relax_info *relax_info;
3102
3103 relax_info = get_avr_relax_info (sec);
3104 if (relax_info->records.count > 0)
3105 {
3106 unsigned int i;
3107
3108 for (i = 0; i < relax_info->records.count; ++i)
3109 {
3110 switch (relax_info->records.items [i].type)
3111 {
3112 case RECORD_ORG:
3113 case RECORD_ORG_AND_FILL:
3114 break;
3115 case RECORD_ALIGN:
3116 case RECORD_ALIGN_AND_FILL:
3117 {
3118 struct avr_property_record *record;
3119 unsigned long bytes_to_align;
3120 int count = 0;
3121
3122 /* Look for alignment directives that have had enough
3123 bytes deleted before them, such that the directive
3124 can be moved backwards and still maintain the
3125 required alignment. */
3126 record = &relax_info->records.items [i];
3127 bytes_to_align
3128 = (unsigned long) (1 << record->data.align.bytes);
3129 while (record->data.align.preceding_deleted >=
3130 bytes_to_align)
3131 {
3132 record->data.align.preceding_deleted
3133 -= bytes_to_align;
3134 count += bytes_to_align;
3135 }
3136
3137 if (count > 0)
3138 {
3139 bfd_vma addr = record->offset;
3140
3141 /* We can delete COUNT bytes and this alignment
3142 directive will still be correctly aligned.
3143 First move the alignment directive, then delete
3144 the bytes. */
3145 record->offset -= count;
3146 elf32_avr_relax_delete_bytes (abfd, sec,
3147 addr - count,
3148 count, false);
3149 *again = true;
3150 }
3151 }
3152 break;
3153 }
3154 }
3155 }
3156 }
3157
3158 if (contents != NULL
3159 && elf_section_data (sec)->this_hdr.contents != contents)
3160 {
3161 if (! link_info->keep_memory)
3162 free (contents);
3163 else
3164 {
3165 /* Cache the section contents for elf_link_input_bfd. */
3166 elf_section_data (sec)->this_hdr.contents = contents;
3167 }
3168 }
3169
3170 if (elf_section_data (sec)->relocs != internal_relocs)
3171 free (internal_relocs);
3172
3173 return true;
3174
3175 error_return:
3176 if (symtab_hdr->contents != (unsigned char *) isymbuf)
3177 free (isymbuf);
3178 if (elf_section_data (sec)->this_hdr.contents != contents)
3179 free (contents);
3180 if (elf_section_data (sec)->relocs != internal_relocs)
3181 free (internal_relocs);
3182
3183 return false;
3184 }
3185
3186 /* This is a version of bfd_generic_get_relocated_section_contents
3187 which uses elf32_avr_relocate_section.
3188
3189 For avr it's essentially a cut and paste taken from the H8300 port.
3190 The author of the relaxation support patch for avr had absolutely no
3191 clue what is happening here but found out that this part of the code
3192 seems to be important. */
3193
3194 static bfd_byte *
3195 elf32_avr_get_relocated_section_contents (bfd *output_bfd,
3196 struct bfd_link_info *link_info,
3197 struct bfd_link_order *link_order,
3198 bfd_byte *data,
3199 bool relocatable,
3200 asymbol **symbols)
3201 {
3202 Elf_Internal_Shdr *symtab_hdr;
3203 asection *input_section = link_order->u.indirect.section;
3204 bfd *input_bfd = input_section->owner;
3205 asection **sections = NULL;
3206 Elf_Internal_Rela *internal_relocs = NULL;
3207 Elf_Internal_Sym *isymbuf = NULL;
3208
3209 /* We only need to handle the case of relaxing, or of having a
3210 particular set of section contents, specially. */
3211 if (relocatable
3212 || elf_section_data (input_section)->this_hdr.contents == NULL)
3213 return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
3214 link_order, data,
3215 relocatable,
3216 symbols);
3217 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3218
3219 memcpy (data, elf_section_data (input_section)->this_hdr.contents,
3220 (size_t) input_section->size);
3221
3222 if ((input_section->flags & SEC_RELOC) != 0
3223 && input_section->reloc_count > 0)
3224 {
3225 asection **secpp;
3226 Elf_Internal_Sym *isym, *isymend;
3227 bfd_size_type amt;
3228
3229 internal_relocs = (_bfd_elf_link_read_relocs
3230 (input_bfd, input_section, NULL, NULL, false));
3231 if (internal_relocs == NULL)
3232 goto error_return;
3233
3234 if (symtab_hdr->sh_info != 0)
3235 {
3236 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
3237 if (isymbuf == NULL)
3238 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
3239 symtab_hdr->sh_info, 0,
3240 NULL, NULL, NULL);
3241 if (isymbuf == NULL)
3242 goto error_return;
3243 }
3244
3245 amt = symtab_hdr->sh_info;
3246 amt *= sizeof (asection *);
3247 sections = bfd_malloc (amt);
3248 if (sections == NULL && amt != 0)
3249 goto error_return;
3250
3251 isymend = isymbuf + symtab_hdr->sh_info;
3252 for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
3253 {
3254 asection *isec;
3255
3256 if (isym->st_shndx == SHN_UNDEF)
3257 isec = bfd_und_section_ptr;
3258 else if (isym->st_shndx == SHN_ABS)
3259 isec = bfd_abs_section_ptr;
3260 else if (isym->st_shndx == SHN_COMMON)
3261 isec = bfd_com_section_ptr;
3262 else
3263 isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
3264
3265 *secpp = isec;
3266 }
3267
3268 if (! elf32_avr_relocate_section (output_bfd, link_info, input_bfd,
3269 input_section, data, internal_relocs,
3270 isymbuf, sections))
3271 goto error_return;
3272
3273 free (sections);
3274 if (symtab_hdr->contents != (unsigned char *) isymbuf)
3275 free (isymbuf);
3276 if (elf_section_data (input_section)->relocs != internal_relocs)
3277 free (internal_relocs);
3278 }
3279
3280 return data;
3281
3282 error_return:
3283 free (sections);
3284 if (symtab_hdr->contents != (unsigned char *) isymbuf)
3285 free (isymbuf);
3286 if (elf_section_data (input_section)->relocs != internal_relocs)
3287 free (internal_relocs);
3288 return NULL;
3289 }
3290
3291
3292 /* Determines the hash entry name for a particular reloc. It consists of
3293 the identifier of the symbol section and the added reloc addend and
3294 symbol offset relative to the section the symbol is attached to. */
3295
3296 static char *
3297 avr_stub_name (const asection *symbol_section,
3298 const bfd_vma symbol_offset,
3299 const Elf_Internal_Rela *rela)
3300 {
3301 char *stub_name;
3302 bfd_size_type len;
3303
3304 len = 8 + 1 + 8 + 1 + 1;
3305 stub_name = bfd_malloc (len);
3306 if (stub_name != NULL)
3307 sprintf (stub_name, "%08x+%08x",
3308 symbol_section->id & 0xffffffff,
3309 (unsigned int) ((rela->r_addend & 0xffffffff) + symbol_offset));
3310
3311 return stub_name;
3312 }
3313
3314
3315 /* Add a new stub entry to the stub hash. Not all fields of the new
3316 stub entry are initialised. */
3317
3318 static struct elf32_avr_stub_hash_entry *
3319 avr_add_stub (const char *stub_name,
3320 struct elf32_avr_link_hash_table *htab)
3321 {
3322 struct elf32_avr_stub_hash_entry *hsh;
3323
3324 /* Enter this entry into the linker stub hash table. */
3325 hsh = avr_stub_hash_lookup (&htab->bstab, stub_name, true, false);
3326
3327 if (hsh == NULL)
3328 {
3329 /* xgettext:c-format */
3330 _bfd_error_handler (_("cannot create stub entry %s"), stub_name);
3331 return NULL;
3332 }
3333
3334 hsh->stub_offset = 0;
3335 return hsh;
3336 }
3337
3338 /* We assume that there is already space allocated for the stub section
3339 contents and that before building the stubs the section size is
3340 initialized to 0. We assume that within the stub hash table entry,
3341 the absolute position of the jmp target has been written in the
3342 target_value field. We write here the offset of the generated jmp insn
3343 relative to the trampoline section start to the stub_offset entry in
3344 the stub hash table entry. */
3345
3346 static bool
3347 avr_build_one_stub (struct bfd_hash_entry *bh, void *in_arg)
3348 {
3349 struct elf32_avr_stub_hash_entry *hsh;
3350 struct bfd_link_info *info;
3351 struct elf32_avr_link_hash_table *htab;
3352 bfd *stub_bfd;
3353 bfd_byte *loc;
3354 bfd_vma target;
3355 bfd_vma starget;
3356
3357 /* Basic opcode */
3358 bfd_vma jmp_insn = 0x0000940c;
3359
3360 /* Massage our args to the form they really have. */
3361 hsh = avr_stub_hash_entry (bh);
3362
3363 if (!hsh->is_actually_needed)
3364 return true;
3365
3366 info = (struct bfd_link_info *) in_arg;
3367
3368 htab = avr_link_hash_table (info);
3369 if (htab == NULL)
3370 return false;
3371
3372 target = hsh->target_value;
3373
3374 /* Make a note of the offset within the stubs for this entry. */
3375 hsh->stub_offset = htab->stub_sec->size;
3376 loc = htab->stub_sec->contents + hsh->stub_offset;
3377
3378 stub_bfd = htab->stub_sec->owner;
3379
3380 if (debug_stubs)
3381 printf ("Building one Stub. Address: 0x%x, Offset: 0x%x\n",
3382 (unsigned int) target,
3383 (unsigned int) hsh->stub_offset);
3384
3385 /* We now have to add the information on the jump target to the bare
3386 opcode bits already set in jmp_insn. */
3387
3388 /* Check for the alignment of the address. */
3389 if (target & 1)
3390 return false;
3391
3392 starget = target >> 1;
3393 jmp_insn |= ((starget & 0x10000) | ((starget << 3) & 0x1f00000)) >> 16;
3394 bfd_put_16 (stub_bfd, jmp_insn, loc);
3395 bfd_put_16 (stub_bfd, (bfd_vma) starget & 0xffff, loc + 2);
3396
3397 htab->stub_sec->size += 4;
3398
3399 /* Now add the entries in the address mapping table if there is still
3400 space left. */
3401 {
3402 unsigned int nr;
3403
3404 nr = htab->amt_entry_cnt + 1;
3405 if (nr <= htab->amt_max_entry_cnt)
3406 {
3407 htab->amt_entry_cnt = nr;
3408
3409 htab->amt_stub_offsets[nr - 1] = hsh->stub_offset;
3410 htab->amt_destination_addr[nr - 1] = target;
3411 }
3412 }
3413
3414 return true;
3415 }
3416
3417 static bool
3418 avr_mark_stub_not_to_be_necessary (struct bfd_hash_entry *bh,
3419 void *in_arg ATTRIBUTE_UNUSED)
3420 {
3421 struct elf32_avr_stub_hash_entry *hsh;
3422
3423 hsh = avr_stub_hash_entry (bh);
3424 hsh->is_actually_needed = false;
3425
3426 return true;
3427 }
3428
3429 static bool
3430 avr_size_one_stub (struct bfd_hash_entry *bh, void *in_arg)
3431 {
3432 struct elf32_avr_stub_hash_entry *hsh;
3433 struct elf32_avr_link_hash_table *htab;
3434 int size;
3435
3436 /* Massage our args to the form they really have. */
3437 hsh = avr_stub_hash_entry (bh);
3438 htab = in_arg;
3439
3440 if (hsh->is_actually_needed)
3441 size = 4;
3442 else
3443 size = 0;
3444
3445 htab->stub_sec->size += size;
3446 return true;
3447 }
3448
3449 void
3450 elf32_avr_setup_params (struct bfd_link_info *info,
3451 bfd *avr_stub_bfd,
3452 asection *avr_stub_section,
3453 bool no_stubs,
3454 bool deb_stubs,
3455 bool deb_relax,
3456 bfd_vma pc_wrap_around,
3457 bool call_ret_replacement)
3458 {
3459 struct elf32_avr_link_hash_table *htab = avr_link_hash_table (info);
3460
3461 if (htab == NULL)
3462 return;
3463 htab->stub_sec = avr_stub_section;
3464 htab->stub_bfd = avr_stub_bfd;
3465 htab->no_stubs = no_stubs;
3466
3467 debug_relax = deb_relax;
3468 debug_stubs = deb_stubs;
3469 avr_pc_wrap_around = pc_wrap_around;
3470 avr_replace_call_ret_sequences = call_ret_replacement;
3471 }
3472
3473
3474 /* Set up various things so that we can make a list of input sections
3475 for each output section included in the link. Returns -1 on error,
3476 0 when no stubs will be needed, and 1 on success. It also sets
3477 information on the stubs bfd and the stub section in the info
3478 struct. */
3479
3480 int
3481 elf32_avr_setup_section_lists (bfd *output_bfd,
3482 struct bfd_link_info *info)
3483 {
3484 bfd *input_bfd;
3485 unsigned int bfd_count;
3486 unsigned int top_id, top_index;
3487 asection *section;
3488 asection **input_list, **list;
3489 size_t amt;
3490 struct elf32_avr_link_hash_table *htab = avr_link_hash_table (info);
3491
3492 if (htab == NULL || htab->no_stubs)
3493 return 0;
3494
3495 /* Count the number of input BFDs and find the top input section id. */
3496 for (input_bfd = info->input_bfds, bfd_count = 0, top_id = 0;
3497 input_bfd != NULL;
3498 input_bfd = input_bfd->link.next)
3499 {
3500 bfd_count += 1;
3501 for (section = input_bfd->sections;
3502 section != NULL;
3503 section = section->next)
3504 if (top_id < section->id)
3505 top_id = section->id;
3506 }
3507
3508 htab->bfd_count = bfd_count;
3509
3510 /* We can't use output_bfd->section_count here to find the top output
3511 section index as some sections may have been removed, and
3512 strip_excluded_output_sections doesn't renumber the indices. */
3513 for (section = output_bfd->sections, top_index = 0;
3514 section != NULL;
3515 section = section->next)
3516 if (top_index < section->index)
3517 top_index = section->index;
3518
3519 htab->top_index = top_index;
3520 amt = sizeof (asection *) * (top_index + 1);
3521 input_list = bfd_malloc (amt);
3522 htab->input_list = input_list;
3523 if (input_list == NULL)
3524 return -1;
3525
3526 /* For sections we aren't interested in, mark their entries with a
3527 value we can check later. */
3528 list = input_list + top_index;
3529 do
3530 *list = bfd_abs_section_ptr;
3531 while (list-- != input_list);
3532
3533 for (section = output_bfd->sections;
3534 section != NULL;
3535 section = section->next)
3536 if ((section->flags & SEC_CODE) != 0)
3537 input_list[section->index] = NULL;
3538
3539 return 1;
3540 }
3541
3542
3543 /* Read in all local syms for all input bfds, and create hash entries
3544 for export stubs if we are building a multi-subspace shared lib.
3545 Returns -1 on error, 0 otherwise. */
3546
3547 static int
3548 get_local_syms (bfd *input_bfd, struct bfd_link_info *info)
3549 {
3550 unsigned int bfd_indx;
3551 Elf_Internal_Sym *local_syms, **all_local_syms;
3552 struct elf32_avr_link_hash_table *htab = avr_link_hash_table (info);
3553 size_t amt;
3554
3555 if (htab == NULL)
3556 return -1;
3557
3558 /* We want to read in symbol extension records only once. To do this
3559 we need to read in the local symbols in parallel and save them for
3560 later use; so hold pointers to the local symbols in an array. */
3561 amt = sizeof (Elf_Internal_Sym *) * htab->bfd_count;
3562 all_local_syms = bfd_zmalloc (amt);
3563 htab->all_local_syms = all_local_syms;
3564 if (all_local_syms == NULL)
3565 return -1;
3566
3567 /* Walk over all the input BFDs, swapping in local symbols.
3568 If we are creating a shared library, create hash entries for the
3569 export stubs. */
3570 for (bfd_indx = 0;
3571 input_bfd != NULL;
3572 input_bfd = input_bfd->link.next, bfd_indx++)
3573 {
3574 Elf_Internal_Shdr *symtab_hdr;
3575
3576 /* We'll need the symbol table in a second. */
3577 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3578 if (symtab_hdr->sh_info == 0)
3579 continue;
3580
3581 /* We need an array of the local symbols attached to the input bfd. */
3582 local_syms = (Elf_Internal_Sym *) symtab_hdr->contents;
3583 if (local_syms == NULL)
3584 {
3585 local_syms = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
3586 symtab_hdr->sh_info, 0,
3587 NULL, NULL, NULL);
3588 /* Cache them for elf_link_input_bfd. */
3589 symtab_hdr->contents = (unsigned char *) local_syms;
3590 }
3591 if (local_syms == NULL)
3592 return -1;
3593
3594 all_local_syms[bfd_indx] = local_syms;
3595 }
3596
3597 return 0;
3598 }
3599
3600 #define ADD_DUMMY_STUBS_FOR_DEBUGGING 0
3601
3602 bool
3603 elf32_avr_size_stubs (bfd *output_bfd,
3604 struct bfd_link_info *info,
3605 bool is_prealloc_run)
3606 {
3607 struct elf32_avr_link_hash_table *htab;
3608 int stub_changed = 0;
3609
3610 htab = avr_link_hash_table (info);
3611 if (htab == NULL)
3612 return false;
3613
3614 /* At this point we initialize htab->vector_base
3615 To the start of the text output section. */
3616 htab->vector_base = htab->stub_sec->output_section->vma;
3617
3618 if (get_local_syms (info->input_bfds, info))
3619 {
3620 if (htab->all_local_syms)
3621 goto error_ret_free_local;
3622 return false;
3623 }
3624
3625 if (ADD_DUMMY_STUBS_FOR_DEBUGGING)
3626 {
3627 struct elf32_avr_stub_hash_entry *test;
3628
3629 test = avr_add_stub ("Hugo",htab);
3630 test->target_value = 0x123456;
3631 test->stub_offset = 13;
3632
3633 test = avr_add_stub ("Hugo2",htab);
3634 test->target_value = 0x84210;
3635 test->stub_offset = 14;
3636 }
3637
3638 while (1)
3639 {
3640 bfd *input_bfd;
3641 unsigned int bfd_indx;
3642
3643 /* We will have to re-generate the stub hash table each time anything
3644 in memory has changed. */
3645
3646 bfd_hash_traverse (&htab->bstab, avr_mark_stub_not_to_be_necessary, htab);
3647 for (input_bfd = info->input_bfds, bfd_indx = 0;
3648 input_bfd != NULL;
3649 input_bfd = input_bfd->link.next, bfd_indx++)
3650 {
3651 Elf_Internal_Shdr *symtab_hdr;
3652 asection *section;
3653 Elf_Internal_Sym *local_syms;
3654
3655 /* We'll need the symbol table in a second. */
3656 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3657 if (symtab_hdr->sh_info == 0)
3658 continue;
3659
3660 local_syms = htab->all_local_syms[bfd_indx];
3661
3662 /* Walk over each section attached to the input bfd. */
3663 for (section = input_bfd->sections;
3664 section != NULL;
3665 section = section->next)
3666 {
3667 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
3668
3669 /* If there aren't any relocs, then there's nothing more
3670 to do. */
3671 if ((section->flags & SEC_RELOC) == 0
3672 || section->reloc_count == 0)
3673 continue;
3674
3675 /* If this section is a link-once section that will be
3676 discarded, then don't create any stubs. */
3677 if (section->output_section == NULL
3678 || section->output_section->owner != output_bfd)
3679 continue;
3680
3681 /* Get the relocs. */
3682 internal_relocs
3683 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
3684 info->keep_memory);
3685 if (internal_relocs == NULL)
3686 goto error_ret_free_local;
3687
3688 /* Now examine each relocation. */
3689 irela = internal_relocs;
3690 irelaend = irela + section->reloc_count;
3691 for (; irela < irelaend; irela++)
3692 {
3693 unsigned int r_type, r_indx;
3694 struct elf32_avr_stub_hash_entry *hsh;
3695 asection *sym_sec;
3696 bfd_vma sym_value;
3697 bfd_vma destination;
3698 struct elf_link_hash_entry *hh;
3699 char *stub_name;
3700
3701 r_type = ELF32_R_TYPE (irela->r_info);
3702 r_indx = ELF32_R_SYM (irela->r_info);
3703
3704 /* Only look for 16 bit GS relocs. No other reloc will need a
3705 stub. */
3706 if (!((r_type == R_AVR_16_PM)
3707 || (r_type == R_AVR_LO8_LDI_GS)
3708 || (r_type == R_AVR_HI8_LDI_GS)))
3709 continue;
3710
3711 /* Now determine the call target, its name, value,
3712 section. */
3713 sym_sec = NULL;
3714 sym_value = 0;
3715 destination = 0;
3716 hh = NULL;
3717 if (r_indx < symtab_hdr->sh_info)
3718 {
3719 /* It's a local symbol. */
3720 Elf_Internal_Sym *sym;
3721 Elf_Internal_Shdr *hdr;
3722 unsigned int shndx;
3723
3724 sym = local_syms + r_indx;
3725 if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
3726 sym_value = sym->st_value;
3727 shndx = sym->st_shndx;
3728 if (shndx < elf_numsections (input_bfd))
3729 {
3730 hdr = elf_elfsections (input_bfd)[shndx];
3731 sym_sec = hdr->bfd_section;
3732 destination = (sym_value + irela->r_addend
3733 + sym_sec->output_offset
3734 + sym_sec->output_section->vma);
3735 }
3736 }
3737 else
3738 {
3739 /* It's an external symbol. */
3740 int e_indx;
3741
3742 e_indx = r_indx - symtab_hdr->sh_info;
3743 hh = elf_sym_hashes (input_bfd)[e_indx];
3744
3745 while (hh->root.type == bfd_link_hash_indirect
3746 || hh->root.type == bfd_link_hash_warning)
3747 hh = (struct elf_link_hash_entry *)
3748 (hh->root.u.i.link);
3749
3750 if (hh->root.type == bfd_link_hash_defined
3751 || hh->root.type == bfd_link_hash_defweak)
3752 {
3753 sym_sec = hh->root.u.def.section;
3754 sym_value = hh->root.u.def.value;
3755 if (sym_sec->output_section != NULL)
3756 destination = (sym_value + irela->r_addend
3757 + sym_sec->output_offset
3758 + sym_sec->output_section->vma);
3759 }
3760 else if (hh->root.type == bfd_link_hash_undefweak)
3761 {
3762 if (! bfd_link_pic (info))
3763 continue;
3764 }
3765 else if (hh->root.type == bfd_link_hash_undefined)
3766 {
3767 if (! (info->unresolved_syms_in_objects == RM_IGNORE
3768 && (ELF_ST_VISIBILITY (hh->other)
3769 == STV_DEFAULT)))
3770 continue;
3771 }
3772 else
3773 {
3774 bfd_set_error (bfd_error_bad_value);
3775
3776 error_ret_free_internal:
3777 if (elf_section_data (section)->relocs == NULL)
3778 free (internal_relocs);
3779 goto error_ret_free_local;
3780 }
3781 }
3782
3783 if (! avr_stub_is_required_for_16_bit_reloc
3784 (destination - htab->vector_base))
3785 {
3786 if (!is_prealloc_run)
3787 /* We are having a reloc that does't need a stub. */
3788 continue;
3789
3790 /* We don't right now know if a stub will be needed.
3791 Let's rather be on the safe side. */
3792 }
3793
3794 /* Get the name of this stub. */
3795 stub_name = avr_stub_name (sym_sec, sym_value, irela);
3796
3797 if (!stub_name)
3798 goto error_ret_free_internal;
3799
3800
3801 hsh = avr_stub_hash_lookup (&htab->bstab,
3802 stub_name,
3803 false, false);
3804 if (hsh != NULL)
3805 {
3806 /* The proper stub has already been created. Mark it
3807 to be used and write the possibly changed destination
3808 value. */
3809 hsh->is_actually_needed = true;
3810 hsh->target_value = destination;
3811 free (stub_name);
3812 continue;
3813 }
3814
3815 hsh = avr_add_stub (stub_name, htab);
3816 if (hsh == NULL)
3817 {
3818 free (stub_name);
3819 goto error_ret_free_internal;
3820 }
3821
3822 hsh->is_actually_needed = true;
3823 hsh->target_value = destination;
3824
3825 if (debug_stubs)
3826 printf ("Adding stub with destination 0x%x to the"
3827 " hash table.\n", (unsigned int) destination);
3828 if (debug_stubs)
3829 printf ("(Pre-Alloc run: %i)\n", is_prealloc_run);
3830
3831 stub_changed = true;
3832 }
3833
3834 /* We're done with the internal relocs, free them. */
3835 if (elf_section_data (section)->relocs == NULL)
3836 free (internal_relocs);
3837 }
3838 }
3839
3840 /* Re-Calculate the number of needed stubs. */
3841 htab->stub_sec->size = 0;
3842 bfd_hash_traverse (&htab->bstab, avr_size_one_stub, htab);
3843
3844 if (!stub_changed)
3845 break;
3846
3847 stub_changed = false;
3848 }
3849
3850 free (htab->all_local_syms);
3851 return true;
3852
3853 error_ret_free_local:
3854 free (htab->all_local_syms);
3855 return false;
3856 }
3857
3858
3859 /* Build all the stubs associated with the current output file. The
3860 stubs are kept in a hash table attached to the main linker hash
3861 table. We also set up the .plt entries for statically linked PIC
3862 functions here. This function is called via hppaelf_finish in the
3863 linker. */
3864
3865 bool
3866 elf32_avr_build_stubs (struct bfd_link_info *info)
3867 {
3868 asection *stub_sec;
3869 struct bfd_hash_table *table;
3870 struct elf32_avr_link_hash_table *htab;
3871 bfd_size_type total_size = 0;
3872
3873 htab = avr_link_hash_table (info);
3874 if (htab == NULL)
3875 return false;
3876
3877 /* In case that there were several stub sections: */
3878 for (stub_sec = htab->stub_bfd->sections;
3879 stub_sec != NULL;
3880 stub_sec = stub_sec->next)
3881 {
3882 bfd_size_type size;
3883
3884 /* Allocate memory to hold the linker stubs. */
3885 size = stub_sec->size;
3886 total_size += size;
3887
3888 stub_sec->contents = bfd_zalloc (htab->stub_bfd, size);
3889 if (stub_sec->contents == NULL && size != 0)
3890 return false;
3891 stub_sec->size = 0;
3892 }
3893
3894 /* Allocate memory for the adress mapping table. */
3895 htab->amt_entry_cnt = 0;
3896 htab->amt_max_entry_cnt = total_size / 4;
3897 htab->amt_stub_offsets = bfd_malloc (sizeof (bfd_vma)
3898 * htab->amt_max_entry_cnt);
3899 htab->amt_destination_addr = bfd_malloc (sizeof (bfd_vma)
3900 * htab->amt_max_entry_cnt );
3901
3902 if (debug_stubs)
3903 printf ("Allocating %i entries in the AMT\n", htab->amt_max_entry_cnt);
3904
3905 /* Build the stubs as directed by the stub hash table. */
3906 table = &htab->bstab;
3907 bfd_hash_traverse (table, avr_build_one_stub, info);
3908
3909 if (debug_stubs)
3910 printf ("Final Stub section Size: %i\n", (int) htab->stub_sec->size);
3911
3912 return true;
3913 }
3914
3915 /* Callback used by QSORT to order relocations AP and BP. */
3916
3917 static int
3918 internal_reloc_compare (const void *ap, const void *bp)
3919 {
3920 const Elf_Internal_Rela *a = (const Elf_Internal_Rela *) ap;
3921 const Elf_Internal_Rela *b = (const Elf_Internal_Rela *) bp;
3922
3923 if (a->r_offset != b->r_offset)
3924 return (a->r_offset - b->r_offset);
3925
3926 /* We don't need to sort on these criteria for correctness,
3927 but enforcing a more strict ordering prevents unstable qsort
3928 from behaving differently with different implementations.
3929 Without the code below we get correct but different results
3930 on Solaris 2.7 and 2.8. We would like to always produce the
3931 same results no matter the host. */
3932
3933 if (a->r_info != b->r_info)
3934 return (a->r_info - b->r_info);
3935
3936 return (a->r_addend - b->r_addend);
3937 }
3938
3939 /* Return true if ADDRESS is within the vma range of SECTION from ABFD. */
3940
3941 static bool
3942 avr_is_section_for_address (asection *section, bfd_vma address)
3943 {
3944 bfd_vma vma;
3945 bfd_size_type size;
3946
3947 vma = bfd_section_vma (section);
3948 if (address < vma)
3949 return false;
3950
3951 size = section->size;
3952 if (address >= vma + size)
3953 return false;
3954
3955 return true;
3956 }
3957
3958 /* Data structure used by AVR_FIND_SECTION_FOR_ADDRESS. */
3959
3960 struct avr_find_section_data
3961 {
3962 /* The address we're looking for. */
3963 bfd_vma address;
3964
3965 /* The section we've found. */
3966 asection *section;
3967 };
3968
3969 /* Helper function to locate the section holding a certain virtual memory
3970 address. This is called via bfd_map_over_sections. The DATA is an
3971 instance of STRUCT AVR_FIND_SECTION_DATA, the address field of which
3972 has been set to the address to search for, and the section field has
3973 been set to NULL. If SECTION from ABFD contains ADDRESS then the
3974 section field in DATA will be set to SECTION. As an optimisation, if
3975 the section field is already non-null then this function does not
3976 perform any checks, and just returns. */
3977
3978 static void
3979 avr_find_section_for_address (bfd *abfd ATTRIBUTE_UNUSED,
3980 asection *section, void *data)
3981 {
3982 struct avr_find_section_data *fs_data
3983 = (struct avr_find_section_data *) data;
3984
3985 /* Return if already found. */
3986 if (fs_data->section != NULL)
3987 return;
3988
3989 /* If this section isn't part of the addressable code content, skip it. */
3990 if ((bfd_section_flags (section) & SEC_ALLOC) == 0
3991 && (bfd_section_flags (section) & SEC_CODE) == 0)
3992 return;
3993
3994 if (avr_is_section_for_address (section, fs_data->address))
3995 fs_data->section = section;
3996 }
3997
3998 /* Load all of the property records from SEC, a section from ABFD. Return
3999 a STRUCT AVR_PROPERTY_RECORD_LIST containing all the records. The
4000 memory for the returned structure, and all of the records pointed too by
4001 the structure are allocated with a single call to malloc, so, only the
4002 pointer returned needs to be free'd. */
4003
4004 static struct avr_property_record_list *
4005 avr_elf32_load_records_from_section (bfd *abfd, asection *sec)
4006 {
4007 bfd_byte *contents, *ptr;
4008 bfd_size_type size, mem_size;
4009 bfd_byte version, flags;
4010 uint16_t record_count, i;
4011 struct avr_property_record_list *r_list = NULL;
4012 Elf_Internal_Rela *internal_relocs = NULL, *rel, *rel_end;
4013 struct avr_find_section_data fs_data;
4014
4015 fs_data.section = NULL;
4016
4017 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
4018 goto load_failed;
4019 ptr = contents;
4020
4021 /* Load the relocations for the '.avr.prop' section if there are any, and
4022 sort them. */
4023 internal_relocs = (_bfd_elf_link_read_relocs
4024 (abfd, sec, NULL, NULL, false));
4025 if (internal_relocs)
4026 qsort (internal_relocs, sec->reloc_count,
4027 sizeof (Elf_Internal_Rela), internal_reloc_compare);
4028
4029 /* There is a header at the start of the property record section SEC, the
4030 format of this header is:
4031 uint8_t : version number
4032 uint8_t : flags
4033 uint16_t : record counter
4034 */
4035
4036 /* Check we have at least got a headers worth of bytes. */
4037 size = bfd_section_size (sec);
4038 if (size < AVR_PROPERTY_SECTION_HEADER_SIZE)
4039 goto load_failed;
4040
4041 version = *ptr;
4042 ptr++;
4043 flags = *ptr;
4044 ptr++;
4045 record_count = bfd_get_16 (abfd, ptr);
4046 ptr += 2;
4047 BFD_ASSERT (ptr - contents == AVR_PROPERTY_SECTION_HEADER_SIZE);
4048
4049 /* Now allocate space for the list structure, and all of the list
4050 elements in a single block. */
4051 mem_size = sizeof (struct avr_property_record_list)
4052 + sizeof (struct avr_property_record) * record_count;
4053 r_list = bfd_malloc (mem_size);
4054 if (r_list == NULL)
4055 goto load_failed;
4056
4057 r_list->version = version;
4058 r_list->flags = flags;
4059 r_list->section = sec;
4060 r_list->record_count = record_count;
4061 r_list->records = (struct avr_property_record *) (&r_list [1]);
4062 size -= AVR_PROPERTY_SECTION_HEADER_SIZE;
4063
4064 /* Check that we understand the version number. There is only one
4065 version number right now, anything else is an error. */
4066 if (r_list->version != AVR_PROPERTY_RECORDS_VERSION)
4067 goto load_failed;
4068
4069 rel = internal_relocs;
4070 rel_end = rel + sec->reloc_count;
4071 for (i = 0; i < record_count; ++i)
4072 {
4073 bfd_vma address;
4074
4075 /* Each entry is a 32-bit address, followed by a single byte type.
4076 After that is the type specific data. We must take care to
4077 ensure that we don't read beyond the end of the section data. */
4078 if (size < 5)
4079 goto load_failed;
4080
4081 r_list->records [i].section = NULL;
4082 r_list->records [i].offset = 0;
4083
4084 if (rel)
4085 {
4086 /* The offset of the address within the .avr.prop section. */
4087 size_t offset = ptr - contents;
4088
4089 while (rel < rel_end && rel->r_offset < offset)
4090 ++rel;
4091
4092 if (rel == rel_end)
4093 rel = NULL;
4094 else if (rel->r_offset == offset)
4095 {
4096 /* Find section and section offset. */
4097 unsigned long r_symndx;
4098
4099 asection * rel_sec;
4100 bfd_vma sec_offset;
4101
4102 r_symndx = ELF32_R_SYM (rel->r_info);
4103 rel_sec = get_elf_r_symndx_section (abfd, r_symndx);
4104 sec_offset = get_elf_r_symndx_offset (abfd, r_symndx)
4105 + rel->r_addend;
4106
4107 r_list->records [i].section = rel_sec;
4108 r_list->records [i].offset = sec_offset;
4109 }
4110 }
4111
4112 address = bfd_get_32 (abfd, ptr);
4113 ptr += 4;
4114 size -= 4;
4115
4116 if (r_list->records [i].section == NULL)
4117 {
4118 /* Try to find section and offset from address. */
4119 if (fs_data.section != NULL
4120 && !avr_is_section_for_address (fs_data.section, address))
4121 fs_data.section = NULL;
4122
4123 if (fs_data.section == NULL)
4124 {
4125 fs_data.address = address;
4126 bfd_map_over_sections (abfd, avr_find_section_for_address,
4127 &fs_data);
4128 }
4129
4130 if (fs_data.section == NULL)
4131 {
4132 fprintf (stderr, "Failed to find matching section.\n");
4133 goto load_failed;
4134 }
4135
4136 r_list->records [i].section = fs_data.section;
4137 r_list->records [i].offset
4138 = address - bfd_section_vma (fs_data.section);
4139 }
4140
4141 r_list->records [i].type = *ptr;
4142 ptr += 1;
4143 size -= 1;
4144
4145 switch (r_list->records [i].type)
4146 {
4147 case RECORD_ORG:
4148 /* Nothing else to load. */
4149 break;
4150 case RECORD_ORG_AND_FILL:
4151 /* Just a 4-byte fill to load. */
4152 if (size < 4)
4153 goto load_failed;
4154 r_list->records [i].data.org.fill = bfd_get_32 (abfd, ptr);
4155 ptr += 4;
4156 size -= 4;
4157 break;
4158 case RECORD_ALIGN:
4159 /* Just a 4-byte alignment to load. */
4160 if (size < 4)
4161 goto load_failed;
4162 r_list->records [i].data.align.bytes = bfd_get_32 (abfd, ptr);
4163 ptr += 4;
4164 size -= 4;
4165 /* Just initialise PRECEDING_DELETED field, this field is
4166 used during linker relaxation. */
4167 r_list->records [i].data.align.preceding_deleted = 0;
4168 break;
4169 case RECORD_ALIGN_AND_FILL:
4170 /* A 4-byte alignment, and a 4-byte fill to load. */
4171 if (size < 8)
4172 goto load_failed;
4173 r_list->records [i].data.align.bytes = bfd_get_32 (abfd, ptr);
4174 ptr += 4;
4175 r_list->records [i].data.align.fill = bfd_get_32 (abfd, ptr);
4176 ptr += 4;
4177 size -= 8;
4178 /* Just initialise PRECEDING_DELETED field, this field is
4179 used during linker relaxation. */
4180 r_list->records [i].data.align.preceding_deleted = 0;
4181 break;
4182 default:
4183 goto load_failed;
4184 }
4185 }
4186
4187 free (contents);
4188 if (elf_section_data (sec)->relocs != internal_relocs)
4189 free (internal_relocs);
4190 return r_list;
4191
4192 load_failed:
4193 if (elf_section_data (sec)->relocs != internal_relocs)
4194 free (internal_relocs);
4195 free (contents);
4196 free (r_list);
4197 return NULL;
4198 }
4199
4200 /* Load all of the property records from ABFD. See
4201 AVR_ELF32_LOAD_RECORDS_FROM_SECTION for details of the return value. */
4202
4203 struct avr_property_record_list *
4204 avr_elf32_load_property_records (bfd *abfd)
4205 {
4206 asection *sec;
4207
4208 /* Find the '.avr.prop' section and load the contents into memory. */
4209 sec = bfd_get_section_by_name (abfd, AVR_PROPERTY_RECORD_SECTION_NAME);
4210 if (sec == NULL)
4211 return NULL;
4212 return avr_elf32_load_records_from_section (abfd, sec);
4213 }
4214
4215 const char *
4216 avr_elf32_property_record_name (struct avr_property_record *rec)
4217 {
4218 const char *str;
4219
4220 switch (rec->type)
4221 {
4222 case RECORD_ORG:
4223 str = "ORG";
4224 break;
4225 case RECORD_ORG_AND_FILL:
4226 str = "ORG+FILL";
4227 break;
4228 case RECORD_ALIGN:
4229 str = "ALIGN";
4230 break;
4231 case RECORD_ALIGN_AND_FILL:
4232 str = "ALIGN+FILL";
4233 break;
4234 default:
4235 str = "unknown";
4236 }
4237
4238 return str;
4239 }
4240
4241
4242 #define ELF_ARCH bfd_arch_avr
4243 #define ELF_TARGET_ID AVR_ELF_DATA
4244 #define ELF_MACHINE_CODE EM_AVR
4245 #define ELF_MACHINE_ALT1 EM_AVR_OLD
4246 #define ELF_MAXPAGESIZE 1
4247
4248 #define TARGET_LITTLE_SYM avr_elf32_vec
4249 #define TARGET_LITTLE_NAME "elf32-avr"
4250
4251 #define bfd_elf32_bfd_link_hash_table_create elf32_avr_link_hash_table_create
4252
4253 #define elf_info_to_howto avr_info_to_howto_rela
4254 #define elf_info_to_howto_rel NULL
4255 #define elf_backend_relocate_section elf32_avr_relocate_section
4256 #define elf_backend_can_gc_sections 1
4257 #define elf_backend_rela_normal 1
4258 #define elf_backend_final_write_processing \
4259 bfd_elf_avr_final_write_processing
4260 #define elf_backend_object_p elf32_avr_object_p
4261
4262 #define bfd_elf32_bfd_relax_section elf32_avr_relax_section
4263 #define bfd_elf32_bfd_get_relocated_section_contents \
4264 elf32_avr_get_relocated_section_contents
4265 #define bfd_elf32_new_section_hook elf_avr_new_section_hook
4266 #define elf_backend_special_sections elf_avr_special_sections
4267
4268 #include "elf32-target.h"
The GNU Binutils are a collection of binary tools.