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