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