projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Add missing end-of-comment marker to previous delta. (Doh!)
[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 r = info->callbacks->reloc_overflow
1491 (info, (h ? &h->root : NULL),
1492 name, howto->name, (bfd_vma) 0,
1493 input_bfd, input_section, rel->r_offset);
1494 break;
1495
1496 case bfd_reloc_undefined:
1497 r = info->callbacks->undefined_symbol
1498 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
1499 break;
1500
1501 case bfd_reloc_outofrange:
1502 msg = _("internal error: out of range error");
1503 break;
1504
1505 case bfd_reloc_notsupported:
1506 msg = _("internal error: unsupported relocation error");
1507 break;
1508
1509 case bfd_reloc_dangerous:
1510 msg = _("internal error: dangerous relocation");
1511 break;
1512
1513 default:
1514 msg = _("internal error: unknown error");
1515 break;
1516 }
1517
1518 if (msg)
1519 r = info->callbacks->warning
1520 (info, msg, name, input_bfd, input_section, rel->r_offset);
1521
1522 if (! r)
1523 return FALSE;
1524 }
1525 }
1526
1527 return TRUE;
1528 }
1529
1530 /* The final processing done just before writing out a AVR ELF object
1531 file. This gets the AVR architecture right based on the machine
1532 number. */
1533
1534 static void
1535 bfd_elf_avr_final_write_processing (bfd *abfd,
1536 bfd_boolean linker ATTRIBUTE_UNUSED)
1537 {
1538 unsigned long val;
1539
1540 switch (bfd_get_mach (abfd))
1541 {
1542 default:
1543 case bfd_mach_avr2:
1544 val = E_AVR_MACH_AVR2;
1545 break;
1546
1547 case bfd_mach_avr1:
1548 val = E_AVR_MACH_AVR1;
1549 break;
1550
1551 case bfd_mach_avr25:
1552 val = E_AVR_MACH_AVR25;
1553 break;
1554
1555 case bfd_mach_avr3:
1556 val = E_AVR_MACH_AVR3;
1557 break;
1558
1559 case bfd_mach_avr31:
1560 val = E_AVR_MACH_AVR31;
1561 break;
1562
1563 case bfd_mach_avr35:
1564 val = E_AVR_MACH_AVR35;
1565 break;
1566
1567 case bfd_mach_avr4:
1568 val = E_AVR_MACH_AVR4;
1569 break;
1570
1571 case bfd_mach_avr5:
1572 val = E_AVR_MACH_AVR5;
1573 break;
1574
1575 case bfd_mach_avr51:
1576 val = E_AVR_MACH_AVR51;
1577 break;
1578
1579 case bfd_mach_avr6:
1580 val = E_AVR_MACH_AVR6;
1581 break;
1582
1583 case bfd_mach_avrxmega1:
1584 val = E_AVR_MACH_XMEGA1;
1585 break;
1586
1587 case bfd_mach_avrxmega2:
1588 val = E_AVR_MACH_XMEGA2;
1589 break;
1590
1591 case bfd_mach_avrxmega3:
1592 val = E_AVR_MACH_XMEGA3;
1593 break;
1594
1595 case bfd_mach_avrxmega4:
1596 val = E_AVR_MACH_XMEGA4;
1597 break;
1598
1599 case bfd_mach_avrxmega5:
1600 val = E_AVR_MACH_XMEGA5;
1601 break;
1602
1603 case bfd_mach_avrxmega6:
1604 val = E_AVR_MACH_XMEGA6;
1605 break;
1606
1607 case bfd_mach_avrxmega7:
1608 val = E_AVR_MACH_XMEGA7;
1609 break;
1610
1611 case bfd_mach_avrtiny:
1612 val = E_AVR_MACH_AVRTINY;
1613 break;
1614 }
1615
1616 elf_elfheader (abfd)->e_machine = EM_AVR;
1617 elf_elfheader (abfd)->e_flags &= ~ EF_AVR_MACH;
1618 elf_elfheader (abfd)->e_flags |= val;
1619 }
1620
1621 /* Set the right machine number. */
1622
1623 static bfd_boolean
1624 elf32_avr_object_p (bfd *abfd)
1625 {
1626 unsigned int e_set = bfd_mach_avr2;
1627
1628 if (elf_elfheader (abfd)->e_machine == EM_AVR
1629 || elf_elfheader (abfd)->e_machine == EM_AVR_OLD)
1630 {
1631 int e_mach = elf_elfheader (abfd)->e_flags & EF_AVR_MACH;
1632
1633 switch (e_mach)
1634 {
1635 default:
1636 case E_AVR_MACH_AVR2:
1637 e_set = bfd_mach_avr2;
1638 break;
1639
1640 case E_AVR_MACH_AVR1:
1641 e_set = bfd_mach_avr1;
1642 break;
1643
1644 case E_AVR_MACH_AVR25:
1645 e_set = bfd_mach_avr25;
1646 break;
1647
1648 case E_AVR_MACH_AVR3:
1649 e_set = bfd_mach_avr3;
1650 break;
1651
1652 case E_AVR_MACH_AVR31:
1653 e_set = bfd_mach_avr31;
1654 break;
1655
1656 case E_AVR_MACH_AVR35:
1657 e_set = bfd_mach_avr35;
1658 break;
1659
1660 case E_AVR_MACH_AVR4:
1661 e_set = bfd_mach_avr4;
1662 break;
1663
1664 case E_AVR_MACH_AVR5:
1665 e_set = bfd_mach_avr5;
1666 break;
1667
1668 case E_AVR_MACH_AVR51:
1669 e_set = bfd_mach_avr51;
1670 break;
1671
1672 case E_AVR_MACH_AVR6:
1673 e_set = bfd_mach_avr6;
1674 break;
1675
1676 case E_AVR_MACH_XMEGA1:
1677 e_set = bfd_mach_avrxmega1;
1678 break;
1679
1680 case E_AVR_MACH_XMEGA2:
1681 e_set = bfd_mach_avrxmega2;
1682 break;
1683
1684 case E_AVR_MACH_XMEGA3:
1685 e_set = bfd_mach_avrxmega3;
1686 break;
1687
1688 case E_AVR_MACH_XMEGA4:
1689 e_set = bfd_mach_avrxmega4;
1690 break;
1691
1692 case E_AVR_MACH_XMEGA5:
1693 e_set = bfd_mach_avrxmega5;
1694 break;
1695
1696 case E_AVR_MACH_XMEGA6:
1697 e_set = bfd_mach_avrxmega6;
1698 break;
1699
1700 case E_AVR_MACH_XMEGA7:
1701 e_set = bfd_mach_avrxmega7;
1702 break;
1703
1704 case E_AVR_MACH_AVRTINY:
1705 e_set = bfd_mach_avrtiny;
1706 break;
1707 }
1708 }
1709 return bfd_default_set_arch_mach (abfd, bfd_arch_avr,
1710 e_set);
1711 }
1712
1713 /* Returns whether the relocation type passed is a diff reloc. */
1714
1715 static bfd_boolean
1716 elf32_avr_is_diff_reloc (Elf_Internal_Rela *irel)
1717 {
1718 return (ELF32_R_TYPE (irel->r_info) == R_AVR_DIFF8
1719 ||ELF32_R_TYPE (irel->r_info) == R_AVR_DIFF16
1720 || ELF32_R_TYPE (irel->r_info) == R_AVR_DIFF32);
1721 }
1722
1723 /* Reduce the diff value written in the section by count if the shrinked
1724 insn address happens to fall between the two symbols for which this
1725 diff reloc was emitted. */
1726
1727 static void
1728 elf32_avr_adjust_diff_reloc_value (bfd *abfd,
1729 struct bfd_section *isec,
1730 Elf_Internal_Rela *irel,
1731 bfd_vma symval,
1732 bfd_vma shrinked_insn_address,
1733 int count)
1734 {
1735 unsigned char *reloc_contents = NULL;
1736 unsigned char *isec_contents = elf_section_data (isec)->this_hdr.contents;
1737 if (isec_contents == NULL)
1738 {
1739 if (! bfd_malloc_and_get_section (abfd, isec, &isec_contents))
1740 return;
1741
1742 elf_section_data (isec)->this_hdr.contents = isec_contents;
1743 }
1744
1745 reloc_contents = isec_contents + irel->r_offset;
1746
1747 /* Read value written in object file. */
1748 bfd_vma x = 0;
1749 switch (ELF32_R_TYPE (irel->r_info))
1750 {
1751 case R_AVR_DIFF8:
1752 {
1753 x = *reloc_contents;
1754 break;
1755 }
1756 case R_AVR_DIFF16:
1757 {
1758 x = bfd_get_16 (abfd, reloc_contents);
1759 break;
1760 }
1761 case R_AVR_DIFF32:
1762 {
1763 x = bfd_get_32 (abfd, reloc_contents);
1764 break;
1765 }
1766 default:
1767 {
1768 BFD_FAIL();
1769 }
1770 }
1771
1772 /* For a diff reloc sym1 - sym2 the diff at assembly time (x) is written
1773 into the object file at the reloc offset. sym2's logical value is
1774 symval (<start_of_section>) + reloc addend. Compute the start and end
1775 addresses and check if the shrinked insn falls between sym1 and sym2. */
1776
1777 bfd_vma end_address = symval + irel->r_addend;
1778 bfd_vma start_address = end_address - x;
1779
1780 /* Reduce the diff value by count bytes and write it back into section
1781 contents. */
1782
1783 if (shrinked_insn_address >= start_address
1784 && shrinked_insn_address <= end_address)
1785 {
1786 switch (ELF32_R_TYPE (irel->r_info))
1787 {
1788 case R_AVR_DIFF8:
1789 {
1790 *reloc_contents = (x - count);
1791 break;
1792 }
1793 case R_AVR_DIFF16:
1794 {
1795 bfd_put_16 (abfd, (x - count) & 0xFFFF, reloc_contents);
1796 break;
1797 }
1798 case R_AVR_DIFF32:
1799 {
1800 bfd_put_32 (abfd, (x - count) & 0xFFFFFFFF, reloc_contents);
1801 break;
1802 }
1803 default:
1804 {
1805 BFD_FAIL();
1806 }
1807 }
1808
1809 }
1810 }
1811
1812 /* Delete some bytes from a section while changing the size of an instruction.
1813 The parameter "addr" denotes the section-relative offset pointing just
1814 behind the shrinked instruction. "addr+count" point at the first
1815 byte just behind the original unshrinked instruction. */
1816
1817 static bfd_boolean
1818 elf32_avr_relax_delete_bytes (bfd *abfd,
1819 asection *sec,
1820 bfd_vma addr,
1821 int count)
1822 {
1823 Elf_Internal_Shdr *symtab_hdr;
1824 unsigned int sec_shndx;
1825 bfd_byte *contents;
1826 Elf_Internal_Rela *irel, *irelend;
1827 Elf_Internal_Sym *isym;
1828 Elf_Internal_Sym *isymbuf = NULL;
1829 bfd_vma toaddr;
1830 struct elf_link_hash_entry **sym_hashes;
1831 struct elf_link_hash_entry **end_hashes;
1832 unsigned int symcount;
1833 struct avr_relax_info *relax_info;
1834 struct avr_property_record *prop_record = NULL;
1835
1836 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1837 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1838 contents = elf_section_data (sec)->this_hdr.contents;
1839 relax_info = get_avr_relax_info (sec);
1840
1841 toaddr = sec->size;
1842
1843 if (relax_info->records.count > 0)
1844 {
1845 /* There should be no property record within the range of deleted
1846 bytes, however, there might be a property record for ADDR, this is
1847 how we handle alignment directives.
1848 Find the next (if any) property record after the deleted bytes. */
1849 unsigned int i;
1850
1851 for (i = 0; i < relax_info->records.count; ++i)
1852 {
1853 bfd_vma offset = relax_info->records.items [i].offset;
1854
1855 BFD_ASSERT (offset <= addr || offset >= (addr + count));
1856 if (offset >= (addr + count))
1857 {
1858 prop_record = &relax_info->records.items [i];
1859 toaddr = offset;
1860 break;
1861 }
1862 }
1863 }
1864
1865 irel = elf_section_data (sec)->relocs;
1866 irelend = irel + sec->reloc_count;
1867
1868 /* Actually delete the bytes. */
1869 if (toaddr - addr - count > 0)
1870 memmove (contents + addr, contents + addr + count,
1871 (size_t) (toaddr - addr - count));
1872 if (prop_record == NULL)
1873 sec->size -= count;
1874 else
1875 {
1876 /* Use the property record to fill in the bytes we've opened up. */
1877 int fill = 0;
1878 switch (prop_record->type)
1879 {
1880 case RECORD_ORG_AND_FILL:
1881 fill = prop_record->data.org.fill;
1882 /* Fall through. */
1883 case RECORD_ORG:
1884 break;
1885 case RECORD_ALIGN_AND_FILL:
1886 fill = prop_record->data.align.fill;
1887 /* Fall through. */
1888 case RECORD_ALIGN:
1889 prop_record->data.align.preceding_deleted += count;
1890 break;
1891 };
1892 memset (contents + toaddr - count, fill, count);
1893
1894 /* Adjust the TOADDR to avoid moving symbols located at the address
1895 of the property record, which has not moved. */
1896 toaddr -= count;
1897 }
1898
1899 /* Adjust all the reloc addresses. */
1900 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1901 {
1902 bfd_vma old_reloc_address;
1903
1904 old_reloc_address = (sec->output_section->vma
1905 + sec->output_offset + irel->r_offset);
1906
1907 /* Get the new reloc address. */
1908 if ((irel->r_offset > addr
1909 && irel->r_offset < toaddr))
1910 {
1911 if (debug_relax)
1912 printf ("Relocation at address 0x%x needs to be moved.\n"
1913 "Old section offset: 0x%x, New section offset: 0x%x \n",
1914 (unsigned int) old_reloc_address,
1915 (unsigned int) irel->r_offset,
1916 (unsigned int) ((irel->r_offset) - count));
1917
1918 irel->r_offset -= count;
1919 }
1920
1921 }
1922
1923 /* The reloc's own addresses are now ok. However, we need to readjust
1924 the reloc's addend, i.e. the reloc's value if two conditions are met:
1925 1.) the reloc is relative to a symbol in this section that
1926 is located in front of the shrinked instruction
1927 2.) symbol plus addend end up behind the shrinked instruction.
1928
1929 The most common case where this happens are relocs relative to
1930 the section-start symbol.
1931
1932 This step needs to be done for all of the sections of the bfd. */
1933
1934 {
1935 struct bfd_section *isec;
1936
1937 for (isec = abfd->sections; isec; isec = isec->next)
1938 {
1939 bfd_vma symval;
1940 bfd_vma shrinked_insn_address;
1941
1942 if (isec->reloc_count == 0)
1943 continue;
1944
1945 shrinked_insn_address = (sec->output_section->vma
1946 + sec->output_offset + addr - count);
1947
1948 irel = elf_section_data (isec)->relocs;
1949 /* PR 12161: Read in the relocs for this section if necessary. */
1950 if (irel == NULL)
1951 irel = _bfd_elf_link_read_relocs (abfd, isec, NULL, NULL, TRUE);
1952
1953 for (irelend = irel + isec->reloc_count;
1954 irel < irelend;
1955 irel++)
1956 {
1957 /* Read this BFD's local symbols if we haven't done
1958 so already. */
1959 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
1960 {
1961 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1962 if (isymbuf == NULL)
1963 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
1964 symtab_hdr->sh_info, 0,
1965 NULL, NULL, NULL);
1966 if (isymbuf == NULL)
1967 return FALSE;
1968 }
1969
1970 /* Get the value of the symbol referred to by the reloc. */
1971 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1972 {
1973 /* A local symbol. */
1974 asection *sym_sec;
1975
1976 isym = isymbuf + ELF32_R_SYM (irel->r_info);
1977 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
1978 symval = isym->st_value;
1979 /* If the reloc is absolute, it will not have
1980 a symbol or section associated with it. */
1981 if (sym_sec == sec)
1982 {
1983 symval += sym_sec->output_section->vma
1984 + sym_sec->output_offset;
1985
1986 if (debug_relax)
1987 printf ("Checking if the relocation's "
1988 "addend needs corrections.\n"
1989 "Address of anchor symbol: 0x%x \n"
1990 "Address of relocation target: 0x%x \n"
1991 "Address of relaxed insn: 0x%x \n",
1992 (unsigned int) symval,
1993 (unsigned int) (symval + irel->r_addend),
1994 (unsigned int) shrinked_insn_address);
1995
1996 if (symval <= shrinked_insn_address
1997 && (symval + irel->r_addend) > shrinked_insn_address)
1998 {
1999 if (elf32_avr_is_diff_reloc (irel))
2000 {
2001 elf32_avr_adjust_diff_reloc_value (abfd, isec, irel,
2002 symval,
2003 shrinked_insn_address,
2004 count);
2005 }
2006
2007 irel->r_addend -= count;
2008
2009 if (debug_relax)
2010 printf ("Relocation's addend needed to be fixed \n");
2011 }
2012 }
2013 /* else...Reference symbol is absolute. No adjustment needed. */
2014 }
2015 /* else...Reference symbol is extern. No need for adjusting
2016 the addend. */
2017 }
2018 }
2019 }
2020
2021 /* Adjust the local symbols defined in this section. */
2022 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
2023 /* Fix PR 9841, there may be no local symbols. */
2024 if (isym != NULL)
2025 {
2026 Elf_Internal_Sym *isymend;
2027
2028 isymend = isym + symtab_hdr->sh_info;
2029 for (; isym < isymend; isym++)
2030 {
2031 if (isym->st_shndx == sec_shndx)
2032 {
2033 if (isym->st_value > addr
2034 && isym->st_value <= toaddr)
2035 isym->st_value -= count;
2036
2037 if (isym->st_value <= addr
2038 && isym->st_value + isym->st_size > addr)
2039 {
2040 /* If this assert fires then we have a symbol that ends
2041 part way through an instruction. Does that make
2042 sense? */
2043 BFD_ASSERT (isym->st_value + isym->st_size >= addr + count);
2044 isym->st_size -= count;
2045 }
2046 }
2047 }
2048 }
2049
2050 /* Now adjust the global symbols defined in this section. */
2051 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
2052 - symtab_hdr->sh_info);
2053 sym_hashes = elf_sym_hashes (abfd);
2054 end_hashes = sym_hashes + symcount;
2055 for (; sym_hashes < end_hashes; sym_hashes++)
2056 {
2057 struct elf_link_hash_entry *sym_hash = *sym_hashes;
2058 if ((sym_hash->root.type == bfd_link_hash_defined
2059 || sym_hash->root.type == bfd_link_hash_defweak)
2060 && sym_hash->root.u.def.section == sec)
2061 {
2062 if (sym_hash->root.u.def.value > addr
2063 && sym_hash->root.u.def.value <= toaddr)
2064 sym_hash->root.u.def.value -= count;
2065
2066 if (sym_hash->root.u.def.value <= addr
2067 && (sym_hash->root.u.def.value + sym_hash->size > addr))
2068 {
2069 /* If this assert fires then we have a symbol that ends
2070 part way through an instruction. Does that make
2071 sense? */
2072 BFD_ASSERT (sym_hash->root.u.def.value + sym_hash->size
2073 >= addr + count);
2074 sym_hash->size -= count;
2075 }
2076 }
2077 }
2078
2079 return TRUE;
2080 }
2081
2082 static Elf_Internal_Sym *
2083 retrieve_local_syms (bfd *input_bfd)
2084 {
2085 Elf_Internal_Shdr *symtab_hdr;
2086 Elf_Internal_Sym *isymbuf;
2087 size_t locsymcount;
2088
2089 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2090 locsymcount = symtab_hdr->sh_info;
2091
2092 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2093 if (isymbuf == NULL && locsymcount != 0)
2094 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr, locsymcount, 0,
2095 NULL, NULL, NULL);
2096
2097 /* Save the symbols for this input file so they won't be read again. */
2098 if (isymbuf && isymbuf != (Elf_Internal_Sym *) symtab_hdr->contents)
2099 symtab_hdr->contents = (unsigned char *) isymbuf;
2100
2101 return isymbuf;
2102 }
2103
2104 /* Get the input section for a given symbol index.
2105 If the symbol is:
2106 . a section symbol, return the section;
2107 . a common symbol, return the common section;
2108 . an undefined symbol, return the undefined section;
2109 . an indirect symbol, follow the links;
2110 . an absolute value, return the absolute section. */
2111
2112 static asection *
2113 get_elf_r_symndx_section (bfd *abfd, unsigned long r_symndx)
2114 {
2115 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2116 asection *target_sec = NULL;
2117 if (r_symndx < symtab_hdr->sh_info)
2118 {
2119 Elf_Internal_Sym *isymbuf;
2120 unsigned int section_index;
2121
2122 isymbuf = retrieve_local_syms (abfd);
2123 section_index = isymbuf[r_symndx].st_shndx;
2124
2125 if (section_index == SHN_UNDEF)
2126 target_sec = bfd_und_section_ptr;
2127 else if (section_index == SHN_ABS)
2128 target_sec = bfd_abs_section_ptr;
2129 else if (section_index == SHN_COMMON)
2130 target_sec = bfd_com_section_ptr;
2131 else
2132 target_sec = bfd_section_from_elf_index (abfd, section_index);
2133 }
2134 else
2135 {
2136 unsigned long indx = r_symndx - symtab_hdr->sh_info;
2137 struct elf_link_hash_entry *h = elf_sym_hashes (abfd)[indx];
2138
2139 while (h->root.type == bfd_link_hash_indirect
2140 || h->root.type == bfd_link_hash_warning)
2141 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2142
2143 switch (h->root.type)
2144 {
2145 case bfd_link_hash_defined:
2146 case bfd_link_hash_defweak:
2147 target_sec = h->root.u.def.section;
2148 break;
2149 case bfd_link_hash_common:
2150 target_sec = bfd_com_section_ptr;
2151 break;
2152 case bfd_link_hash_undefined:
2153 case bfd_link_hash_undefweak:
2154 target_sec = bfd_und_section_ptr;
2155 break;
2156 default: /* New indirect warning. */
2157 target_sec = bfd_und_section_ptr;
2158 break;
2159 }
2160 }
2161 return target_sec;
2162 }
2163
2164 /* Get the section-relative offset for a symbol number. */
2165
2166 static bfd_vma
2167 get_elf_r_symndx_offset (bfd *abfd, unsigned long r_symndx)
2168 {
2169 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2170 bfd_vma offset = 0;
2171
2172 if (r_symndx < symtab_hdr->sh_info)
2173 {
2174 Elf_Internal_Sym *isymbuf;
2175 isymbuf = retrieve_local_syms (abfd);
2176 offset = isymbuf[r_symndx].st_value;
2177 }
2178 else
2179 {
2180 unsigned long indx = r_symndx - symtab_hdr->sh_info;
2181 struct elf_link_hash_entry *h =
2182 elf_sym_hashes (abfd)[indx];
2183
2184 while (h->root.type == bfd_link_hash_indirect
2185 || h->root.type == bfd_link_hash_warning)
2186 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2187 if (h->root.type == bfd_link_hash_defined
2188 || h->root.type == bfd_link_hash_defweak)
2189 offset = h->root.u.def.value;
2190 }
2191 return offset;
2192 }
2193
2194 /* Iterate over the property records in R_LIST, and copy each record into
2195 the list of records within the relaxation information for the section to
2196 which the record applies. */
2197
2198 static void
2199 avr_elf32_assign_records_to_sections (struct avr_property_record_list *r_list)
2200 {
2201 unsigned int i;
2202
2203 for (i = 0; i < r_list->record_count; ++i)
2204 {
2205 struct avr_relax_info *relax_info;
2206
2207 relax_info = get_avr_relax_info (r_list->records [i].section);
2208 BFD_ASSERT (relax_info != NULL);
2209
2210 if (relax_info->records.count
2211 == relax_info->records.allocated)
2212 {
2213 /* Allocate more space. */
2214 bfd_size_type size;
2215
2216 relax_info->records.allocated += 10;
2217 size = (sizeof (struct avr_property_record)
2218 * relax_info->records.allocated);
2219 relax_info->records.items
2220 = bfd_realloc (relax_info->records.items, size);
2221 }
2222
2223 memcpy (&relax_info->records.items [relax_info->records.count],
2224 &r_list->records [i],
2225 sizeof (struct avr_property_record));
2226 relax_info->records.count++;
2227 }
2228 }
2229
2230 /* Compare two STRUCT AVR_PROPERTY_RECORD in AP and BP, used as the
2231 ordering callback from QSORT. */
2232
2233 static int
2234 avr_property_record_compare (const void *ap, const void *bp)
2235 {
2236 const struct avr_property_record *a
2237 = (struct avr_property_record *) ap;
2238 const struct avr_property_record *b
2239 = (struct avr_property_record *) bp;
2240
2241 if (a->offset != b->offset)
2242 return (a->offset - b->offset);
2243
2244 if (a->section != b->section)
2245 return (bfd_get_section_vma (a->section->owner, a->section)
2246 - bfd_get_section_vma (b->section->owner, b->section));
2247
2248 return (a->type - b->type);
2249 }
2250
2251 /* Load all of the avr property sections from all of the bfd objects
2252 referenced from LINK_INFO. All of the records within each property
2253 section are assigned to the STRUCT AVR_RELAX_INFO within the section
2254 specific data of the appropriate section. */
2255
2256 static void
2257 avr_load_all_property_sections (struct bfd_link_info *link_info)
2258 {
2259 bfd *abfd;
2260 asection *sec;
2261
2262 /* Initialize the per-section relaxation info. */
2263 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link.next)
2264 for (sec = abfd->sections; sec != NULL; sec = sec->next)
2265 {
2266 init_avr_relax_info (sec);
2267 }
2268
2269 /* Load the descriptor tables from .avr.prop sections. */
2270 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link.next)
2271 {
2272 struct avr_property_record_list *r_list;
2273
2274 r_list = avr_elf32_load_property_records (abfd);
2275 if (r_list != NULL)
2276 avr_elf32_assign_records_to_sections (r_list);
2277
2278 free (r_list);
2279 }
2280
2281 /* Now, for every section, ensure that the descriptor list in the
2282 relaxation data is sorted by ascending offset within the section. */
2283 for (abfd = link_info->input_bfds; abfd != NULL; abfd = abfd->link.next)
2284 for (sec = abfd->sections; sec != NULL; sec = sec->next)
2285 {
2286 struct avr_relax_info *relax_info = get_avr_relax_info (sec);
2287 if (relax_info && relax_info->records.count > 0)
2288 {
2289 unsigned int i;
2290
2291 qsort (relax_info->records.items,
2292 relax_info->records.count,
2293 sizeof (struct avr_property_record),
2294 avr_property_record_compare);
2295
2296 /* For debug purposes, list all the descriptors. */
2297 for (i = 0; i < relax_info->records.count; ++i)
2298 {
2299 switch (relax_info->records.items [i].type)
2300 {
2301 case RECORD_ORG:
2302 break;
2303 case RECORD_ORG_AND_FILL:
2304 break;
2305 case RECORD_ALIGN:
2306 break;
2307 case RECORD_ALIGN_AND_FILL:
2308 break;
2309 };
2310 }
2311 }
2312 }
2313 }
2314
2315 /* This function handles relaxing for the avr.
2316 Many important relaxing opportunities within functions are already
2317 realized by the compiler itself.
2318 Here we try to replace call (4 bytes) -> rcall (2 bytes)
2319 and jump -> rjmp (safes also 2 bytes).
2320 As well we now optimize seqences of
2321 - call/rcall function
2322 - ret
2323 to yield
2324 - jmp/rjmp function
2325 - ret
2326 . In case that within a sequence
2327 - jmp/rjmp label
2328 - ret
2329 the ret could no longer be reached it is optimized away. In order
2330 to check if the ret is no longer needed, it is checked that the ret's address
2331 is not the target of a branch or jump within the same section, it is checked
2332 that there is no skip instruction before the jmp/rjmp and that there
2333 is no local or global label place at the address of the ret.
2334
2335 We refrain from relaxing within sections ".vectors" and
2336 ".jumptables" in order to maintain the position of the instructions.
2337 There, however, we substitute jmp/call by a sequence rjmp,nop/rcall,nop
2338 if possible. (In future one could possibly use the space of the nop
2339 for the first instruction of the irq service function.
2340
2341 The .jumptables sections is meant to be used for a future tablejump variant
2342 for the devices with 3-byte program counter where the table itself
2343 contains 4-byte jump instructions whose relative offset must not
2344 be changed. */
2345
2346 static bfd_boolean
2347 elf32_avr_relax_section (bfd *abfd,
2348 asection *sec,
2349 struct bfd_link_info *link_info,
2350 bfd_boolean *again)
2351 {
2352 Elf_Internal_Shdr *symtab_hdr;
2353 Elf_Internal_Rela *internal_relocs;
2354 Elf_Internal_Rela *irel, *irelend;
2355 bfd_byte *contents = NULL;
2356 Elf_Internal_Sym *isymbuf = NULL;
2357 struct elf32_avr_link_hash_table *htab;
2358 static bfd_boolean relaxation_initialised = FALSE;
2359
2360 if (!relaxation_initialised)
2361 {
2362 relaxation_initialised = TRUE;
2363
2364 /* Load entries from the .avr.prop sections. */
2365 avr_load_all_property_sections (link_info);
2366 }
2367
2368 /* If 'shrinkable' is FALSE, do not shrink by deleting bytes while
2369 relaxing. Such shrinking can cause issues for the sections such
2370 as .vectors and .jumptables. Instead the unused bytes should be
2371 filled with nop instructions. */
2372 bfd_boolean shrinkable = TRUE;
2373
2374 if (!strcmp (sec->name,".vectors")
2375 || !strcmp (sec->name,".jumptables"))
2376 shrinkable = FALSE;
2377
2378 if (bfd_link_relocatable (link_info))
2379 (*link_info->callbacks->einfo)
2380 (_("%P%F: --relax and -r may not be used together\n"));
2381
2382 htab = avr_link_hash_table (link_info);
2383 if (htab == NULL)
2384 return FALSE;
2385
2386 /* Assume nothing changes. */
2387 *again = FALSE;
2388
2389 if ((!htab->no_stubs) && (sec == htab->stub_sec))
2390 {
2391 /* We are just relaxing the stub section.
2392 Let's calculate the size needed again. */
2393 bfd_size_type last_estimated_stub_section_size = htab->stub_sec->size;
2394
2395 if (debug_relax)
2396 printf ("Relaxing the stub section. Size prior to this pass: %i\n",
2397 (int) last_estimated_stub_section_size);
2398
2399 elf32_avr_size_stubs (htab->stub_sec->output_section->owner,
2400 link_info, FALSE);
2401
2402 /* Check if the number of trampolines changed. */
2403 if (last_estimated_stub_section_size != htab->stub_sec->size)
2404 *again = TRUE;
2405
2406 if (debug_relax)
2407 printf ("Size of stub section after this pass: %i\n",
2408 (int) htab->stub_sec->size);
2409
2410 return TRUE;
2411 }
2412
2413 /* We don't have to do anything for a relocatable link, if
2414 this section does not have relocs, or if this is not a
2415 code section. */
2416 if (bfd_link_relocatable (link_info)
2417 || (sec->flags & SEC_RELOC) == 0
2418 || sec->reloc_count == 0
2419 || (sec->flags & SEC_CODE) == 0)
2420 return TRUE;
2421
2422 /* Check if the object file to relax uses internal symbols so that we
2423 could fix up the relocations. */
2424 if (!(elf_elfheader (abfd)->e_flags & EF_AVR_LINKRELAX_PREPARED))
2425 return TRUE;
2426
2427 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2428
2429 /* Get a copy of the native relocations. */
2430 internal_relocs = (_bfd_elf_link_read_relocs
2431 (abfd, sec, NULL, NULL, link_info->keep_memory));
2432 if (internal_relocs == NULL)
2433 goto error_return;
2434
2435 /* Walk through the relocs looking for relaxing opportunities. */
2436 irelend = internal_relocs + sec->reloc_count;
2437 for (irel = internal_relocs; irel < irelend; irel++)
2438 {
2439 bfd_vma symval;
2440
2441 if ( ELF32_R_TYPE (irel->r_info) != R_AVR_13_PCREL
2442 && ELF32_R_TYPE (irel->r_info) != R_AVR_7_PCREL
2443 && ELF32_R_TYPE (irel->r_info) != R_AVR_CALL)
2444 continue;
2445
2446 /* Get the section contents if we haven't done so already. */
2447 if (contents == NULL)
2448 {
2449 /* Get cached copy if it exists. */
2450 if (elf_section_data (sec)->this_hdr.contents != NULL)
2451 contents = elf_section_data (sec)->this_hdr.contents;
2452 else
2453 {
2454 /* Go get them off disk. */
2455 if (! bfd_malloc_and_get_section (abfd, sec, &contents))
2456 goto error_return;
2457 }
2458 }
2459
2460 /* Read this BFD's local symbols if we haven't done so already. */
2461 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
2462 {
2463 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2464 if (isymbuf == NULL)
2465 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
2466 symtab_hdr->sh_info, 0,
2467 NULL, NULL, NULL);
2468 if (isymbuf == NULL)
2469 goto error_return;
2470 }
2471
2472
2473 /* Get the value of the symbol referred to by the reloc. */
2474 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
2475 {
2476 /* A local symbol. */
2477 Elf_Internal_Sym *isym;
2478 asection *sym_sec;
2479
2480 isym = isymbuf + ELF32_R_SYM (irel->r_info);
2481 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
2482 symval = isym->st_value;
2483 /* If the reloc is absolute, it will not have
2484 a symbol or section associated with it. */
2485 if (sym_sec)
2486 symval += sym_sec->output_section->vma
2487 + sym_sec->output_offset;
2488 }
2489 else
2490 {
2491 unsigned long indx;
2492 struct elf_link_hash_entry *h;
2493
2494 /* An external symbol. */
2495 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
2496 h = elf_sym_hashes (abfd)[indx];
2497 BFD_ASSERT (h != NULL);
2498 if (h->root.type != bfd_link_hash_defined
2499 && h->root.type != bfd_link_hash_defweak)
2500 /* This appears to be a reference to an undefined
2501 symbol. Just ignore it--it will be caught by the
2502 regular reloc processing. */
2503 continue;
2504
2505 symval = (h->root.u.def.value
2506 + h->root.u.def.section->output_section->vma
2507 + h->root.u.def.section->output_offset);
2508 }
2509
2510 /* For simplicity of coding, we are going to modify the section
2511 contents, the section relocs, and the BFD symbol table. We
2512 must tell the rest of the code not to free up this
2513 information. It would be possible to instead create a table
2514 of changes which have to be made, as is done in coff-mips.c;
2515 that would be more work, but would require less memory when
2516 the linker is run. */
2517 switch (ELF32_R_TYPE (irel->r_info))
2518 {
2519 /* Try to turn a 22-bit absolute call/jump into an 13-bit
2520 pc-relative rcall/rjmp. */
2521 case R_AVR_CALL:
2522 {
2523 bfd_vma value = symval + irel->r_addend;
2524 bfd_vma dot, gap;
2525 int distance_short_enough = 0;
2526
2527 /* Get the address of this instruction. */
2528 dot = (sec->output_section->vma
2529 + sec->output_offset + irel->r_offset);
2530
2531 /* Compute the distance from this insn to the branch target. */
2532 gap = value - dot;
2533
2534 /* Check if the gap falls in the range that can be accommodated
2535 in 13bits signed (It is 12bits when encoded, as we deal with
2536 word addressing). */
2537 if (!shrinkable && ((int) gap >= -4096 && (int) gap <= 4095))
2538 distance_short_enough = 1;
2539 /* If shrinkable, then we can check for a range of distance which
2540 is two bytes farther on both the directions because the call
2541 or jump target will be closer by two bytes after the
2542 relaxation. */
2543 else if (shrinkable && ((int) gap >= -4094 && (int) gap <= 4097))
2544 distance_short_enough = 1;
2545
2546 /* Here we handle the wrap-around case. E.g. for a 16k device
2547 we could use a rjmp to jump from address 0x100 to 0x3d00!
2548 In order to make this work properly, we need to fill the
2549 vaiable avr_pc_wrap_around with the appropriate value.
2550 I.e. 0x4000 for a 16k device. */
2551 {
2552 /* Shrinking the code size makes the gaps larger in the
2553 case of wrap-arounds. So we use a heuristical safety
2554 margin to avoid that during relax the distance gets
2555 again too large for the short jumps. Let's assume
2556 a typical code-size reduction due to relax for a
2557 16k device of 600 bytes. So let's use twice the
2558 typical value as safety margin. */
2559 int rgap;
2560 int safety_margin;
2561
2562 int assumed_shrink = 600;
2563 if (avr_pc_wrap_around > 0x4000)
2564 assumed_shrink = 900;
2565
2566 safety_margin = 2 * assumed_shrink;
2567
2568 rgap = avr_relative_distance_considering_wrap_around (gap);
2569
2570 if (rgap >= (-4092 + safety_margin)
2571 && rgap <= (4094 - safety_margin))
2572 distance_short_enough = 1;
2573 }
2574
2575 if (distance_short_enough)
2576 {
2577 unsigned char code_msb;
2578 unsigned char code_lsb;
2579
2580 if (debug_relax)
2581 printf ("shrinking jump/call instruction at address 0x%x"
2582 " in section %s\n\n",
2583 (int) dot, sec->name);
2584
2585 /* Note that we've changed the relocs, section contents,
2586 etc. */
2587 elf_section_data (sec)->relocs = internal_relocs;
2588 elf_section_data (sec)->this_hdr.contents = contents;
2589 symtab_hdr->contents = (unsigned char *) isymbuf;
2590
2591 /* Get the instruction code for relaxing. */
2592 code_lsb = bfd_get_8 (abfd, contents + irel->r_offset);
2593 code_msb = bfd_get_8 (abfd, contents + irel->r_offset + 1);
2594
2595 /* Mask out the relocation bits. */
2596 code_msb &= 0x94;
2597 code_lsb &= 0x0E;
2598 if (code_msb == 0x94 && code_lsb == 0x0E)
2599 {
2600 /* we are changing call -> rcall . */
2601 bfd_put_8 (abfd, 0x00, contents + irel->r_offset);
2602 bfd_put_8 (abfd, 0xD0, contents + irel->r_offset + 1);
2603 }
2604 else if (code_msb == 0x94 && code_lsb == 0x0C)
2605 {
2606 /* we are changeing jump -> rjmp. */
2607 bfd_put_8 (abfd, 0x00, contents + irel->r_offset);
2608 bfd_put_8 (abfd, 0xC0, contents + irel->r_offset + 1);
2609 }
2610 else
2611 abort ();
2612
2613 /* Fix the relocation's type. */
2614 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2615 R_AVR_13_PCREL);
2616
2617 /* We should not modify the ordering if 'shrinkable' is
2618 FALSE. */
2619 if (!shrinkable)
2620 {
2621 /* Let's insert a nop. */
2622 bfd_put_8 (abfd, 0x00, contents + irel->r_offset + 2);
2623 bfd_put_8 (abfd, 0x00, contents + irel->r_offset + 3);
2624 }
2625 else
2626 {
2627 /* Delete two bytes of data. */
2628 if (!elf32_avr_relax_delete_bytes (abfd, sec,
2629 irel->r_offset + 2, 2))
2630 goto error_return;
2631
2632 /* That will change things, so, we should relax again.
2633 Note that this is not required, and it may be slow. */
2634 *again = TRUE;
2635 }
2636 }
2637 }
2638
2639 default:
2640 {
2641 unsigned char code_msb;
2642 unsigned char code_lsb;
2643 bfd_vma dot;
2644
2645 code_msb = bfd_get_8 (abfd, contents + irel->r_offset + 1);
2646 code_lsb = bfd_get_8 (abfd, contents + irel->r_offset + 0);
2647
2648 /* Get the address of this instruction. */
2649 dot = (sec->output_section->vma
2650 + sec->output_offset + irel->r_offset);
2651
2652 /* Here we look for rcall/ret or call/ret sequences that could be
2653 safely replaced by rjmp/ret or jmp/ret. */
2654 if (((code_msb & 0xf0) == 0xd0)
2655 && avr_replace_call_ret_sequences)
2656 {
2657 /* This insn is a rcall. */
2658 unsigned char next_insn_msb = 0;
2659 unsigned char next_insn_lsb = 0;
2660
2661 if (irel->r_offset + 3 < sec->size)
2662 {
2663 next_insn_msb =
2664 bfd_get_8 (abfd, contents + irel->r_offset + 3);
2665 next_insn_lsb =
2666 bfd_get_8 (abfd, contents + irel->r_offset + 2);
2667 }
2668
2669 if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb))
2670 {
2671 /* The next insn is a ret. We now convert the rcall insn
2672 into a rjmp instruction. */
2673 code_msb &= 0xef;
2674 bfd_put_8 (abfd, code_msb, contents + irel->r_offset + 1);
2675 if (debug_relax)
2676 printf ("converted rcall/ret sequence at address 0x%x"
2677 " into rjmp/ret sequence. Section is %s\n\n",
2678 (int) dot, sec->name);
2679 *again = TRUE;
2680 break;
2681 }
2682 }
2683 else if ((0x94 == (code_msb & 0xfe))
2684 && (0x0e == (code_lsb & 0x0e))
2685 && avr_replace_call_ret_sequences)
2686 {
2687 /* This insn is a call. */
2688 unsigned char next_insn_msb = 0;
2689 unsigned char next_insn_lsb = 0;
2690
2691 if (irel->r_offset + 5 < sec->size)
2692 {
2693 next_insn_msb =
2694 bfd_get_8 (abfd, contents + irel->r_offset + 5);
2695 next_insn_lsb =
2696 bfd_get_8 (abfd, contents + irel->r_offset + 4);
2697 }
2698
2699 if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb))
2700 {
2701 /* The next insn is a ret. We now convert the call insn
2702 into a jmp instruction. */
2703
2704 code_lsb &= 0xfd;
2705 bfd_put_8 (abfd, code_lsb, contents + irel->r_offset);
2706 if (debug_relax)
2707 printf ("converted call/ret sequence at address 0x%x"
2708 " into jmp/ret sequence. Section is %s\n\n",
2709 (int) dot, sec->name);
2710 *again = TRUE;
2711 break;
2712 }
2713 }
2714 else if ((0xc0 == (code_msb & 0xf0))
2715 || ((0x94 == (code_msb & 0xfe))
2716 && (0x0c == (code_lsb & 0x0e))))
2717 {
2718 /* This insn is a rjmp or a jmp. */
2719 unsigned char next_insn_msb = 0;
2720 unsigned char next_insn_lsb = 0;
2721 int insn_size;
2722
2723 if (0xc0 == (code_msb & 0xf0))
2724 insn_size = 2; /* rjmp insn */
2725 else
2726 insn_size = 4; /* jmp insn */
2727
2728 if (irel->r_offset + insn_size + 1 < sec->size)
2729 {
2730 next_insn_msb =
2731 bfd_get_8 (abfd, contents + irel->r_offset
2732 + insn_size + 1);
2733 next_insn_lsb =
2734 bfd_get_8 (abfd, contents + irel->r_offset
2735 + insn_size);
2736 }
2737
2738 if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb))
2739 {
2740 /* The next insn is a ret. We possibly could delete
2741 this ret. First we need to check for preceding
2742 sbis/sbic/sbrs or cpse "skip" instructions. */
2743
2744 int there_is_preceding_non_skip_insn = 1;
2745 bfd_vma address_of_ret;
2746
2747 address_of_ret = dot + insn_size;
2748
2749 if (debug_relax && (insn_size == 2))
2750 printf ("found rjmp / ret sequence at address 0x%x\n",
2751 (int) dot);
2752 if (debug_relax && (insn_size == 4))
2753 printf ("found jmp / ret sequence at address 0x%x\n",
2754 (int) dot);
2755
2756 /* We have to make sure that there is a preceding insn. */
2757 if (irel->r_offset >= 2)
2758 {
2759 unsigned char preceding_msb;
2760 unsigned char preceding_lsb;
2761
2762 preceding_msb =
2763 bfd_get_8 (abfd, contents + irel->r_offset - 1);
2764 preceding_lsb =
2765 bfd_get_8 (abfd, contents + irel->r_offset - 2);
2766
2767 /* sbic. */
2768 if (0x99 == preceding_msb)
2769 there_is_preceding_non_skip_insn = 0;
2770
2771 /* sbis. */
2772 if (0x9b == preceding_msb)
2773 there_is_preceding_non_skip_insn = 0;
2774
2775 /* sbrc */
2776 if ((0xfc == (preceding_msb & 0xfe)
2777 && (0x00 == (preceding_lsb & 0x08))))
2778 there_is_preceding_non_skip_insn = 0;
2779
2780 /* sbrs */
2781 if ((0xfe == (preceding_msb & 0xfe)
2782 && (0x00 == (preceding_lsb & 0x08))))
2783 there_is_preceding_non_skip_insn = 0;
2784
2785 /* cpse */
2786 if (0x10 == (preceding_msb & 0xfc))
2787 there_is_preceding_non_skip_insn = 0;
2788
2789 if (there_is_preceding_non_skip_insn == 0)
2790 if (debug_relax)
2791 printf ("preceding skip insn prevents deletion of"
2792 " ret insn at Addy 0x%x in section %s\n",
2793 (int) dot + 2, sec->name);
2794 }
2795 else
2796 {
2797 /* There is no previous instruction. */
2798 there_is_preceding_non_skip_insn = 0;
2799 }
2800
2801 if (there_is_preceding_non_skip_insn)
2802 {
2803 /* We now only have to make sure that there is no
2804 local label defined at the address of the ret
2805 instruction and that there is no local relocation
2806 in this section pointing to the ret. */
2807
2808 int deleting_ret_is_safe = 1;
2809 unsigned int section_offset_of_ret_insn =
2810 irel->r_offset + insn_size;
2811 Elf_Internal_Sym *isym, *isymend;
2812 unsigned int sec_shndx;
2813 struct bfd_section *isec;
2814
2815 sec_shndx =
2816 _bfd_elf_section_from_bfd_section (abfd, sec);
2817
2818 /* Check for local symbols. */
2819 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
2820 isymend = isym + symtab_hdr->sh_info;
2821 /* PR 6019: There may not be any local symbols. */
2822 for (; isym != NULL && isym < isymend; isym++)
2823 {
2824 if (isym->st_value == section_offset_of_ret_insn
2825 && isym->st_shndx == sec_shndx)
2826 {
2827 deleting_ret_is_safe = 0;
2828 if (debug_relax)
2829 printf ("local label prevents deletion of ret "
2830 "insn at address 0x%x\n",
2831 (int) dot + insn_size);
2832 }
2833 }
2834
2835 /* Now check for global symbols. */
2836 {
2837 int symcount;
2838 struct elf_link_hash_entry **sym_hashes;
2839 struct elf_link_hash_entry **end_hashes;
2840
2841 symcount = (symtab_hdr->sh_size
2842 / sizeof (Elf32_External_Sym)
2843 - symtab_hdr->sh_info);
2844 sym_hashes = elf_sym_hashes (abfd);
2845 end_hashes = sym_hashes + symcount;
2846 for (; sym_hashes < end_hashes; sym_hashes++)
2847 {
2848 struct elf_link_hash_entry *sym_hash =
2849 *sym_hashes;
2850 if ((sym_hash->root.type == bfd_link_hash_defined
2851 || sym_hash->root.type ==
2852 bfd_link_hash_defweak)
2853 && sym_hash->root.u.def.section == sec
2854 && sym_hash->root.u.def.value == section_offset_of_ret_insn)
2855 {
2856 deleting_ret_is_safe = 0;
2857 if (debug_relax)
2858 printf ("global label prevents deletion of "
2859 "ret insn at address 0x%x\n",
2860 (int) dot + insn_size);
2861 }
2862 }
2863 }
2864
2865 /* Now we check for relocations pointing to ret. */
2866 for (isec = abfd->sections; isec && deleting_ret_is_safe; isec = isec->next)
2867 {
2868 Elf_Internal_Rela *rel;
2869 Elf_Internal_Rela *relend;
2870
2871 rel = elf_section_data (isec)->relocs;
2872 if (rel == NULL)
2873 rel = _bfd_elf_link_read_relocs (abfd, isec, NULL, NULL, TRUE);
2874
2875 relend = rel + isec->reloc_count;
2876
2877 for (; rel && rel < relend; rel++)
2878 {
2879 bfd_vma reloc_target = 0;
2880
2881 /* Read this BFD's local symbols if we haven't
2882 done so already. */
2883 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
2884 {
2885 isymbuf = (Elf_Internal_Sym *)
2886 symtab_hdr->contents;
2887 if (isymbuf == NULL)
2888 isymbuf = bfd_elf_get_elf_syms
2889 (abfd,
2890 symtab_hdr,
2891 symtab_hdr->sh_info, 0,
2892 NULL, NULL, NULL);
2893 if (isymbuf == NULL)
2894 break;
2895 }
2896
2897 /* Get the value of the symbol referred to
2898 by the reloc. */
2899 if (ELF32_R_SYM (rel->r_info)
2900 < symtab_hdr->sh_info)
2901 {
2902 /* A local symbol. */
2903 asection *sym_sec;
2904
2905 isym = isymbuf
2906 + ELF32_R_SYM (rel->r_info);
2907 sym_sec = bfd_section_from_elf_index
2908 (abfd, isym->st_shndx);
2909 symval = isym->st_value;
2910
2911 /* If the reloc is absolute, it will not
2912 have a symbol or section associated
2913 with it. */
2914
2915 if (sym_sec)
2916 {
2917 symval +=
2918 sym_sec->output_section->vma
2919 + sym_sec->output_offset;
2920 reloc_target = symval + rel->r_addend;
2921 }
2922 else
2923 {
2924 reloc_target = symval + rel->r_addend;
2925 /* Reference symbol is absolute. */
2926 }
2927 }
2928 /* else ... reference symbol is extern. */
2929
2930 if (address_of_ret == reloc_target)
2931 {
2932 deleting_ret_is_safe = 0;
2933 if (debug_relax)
2934 printf ("ret from "
2935 "rjmp/jmp ret sequence at address"
2936 " 0x%x could not be deleted. ret"
2937 " is target of a relocation.\n",
2938 (int) address_of_ret);
2939 break;
2940 }
2941 }
2942 }
2943
2944 if (deleting_ret_is_safe)
2945 {
2946 if (debug_relax)
2947 printf ("unreachable ret instruction "
2948 "at address 0x%x deleted.\n",
2949 (int) dot + insn_size);
2950
2951 /* Delete two bytes of data. */
2952 if (!elf32_avr_relax_delete_bytes (abfd, sec,
2953 irel->r_offset + insn_size, 2))
2954 goto error_return;
2955
2956 /* That will change things, so, we should relax
2957 again. Note that this is not required, and it
2958 may be slow. */
2959 *again = TRUE;
2960 break;
2961 }
2962 }
2963 }
2964 }
2965 break;
2966 }
2967 }
2968 }
2969
2970 if (!*again)
2971 {
2972 /* Look through all the property records in this section to see if
2973 there's any alignment records that can be moved. */
2974 struct avr_relax_info *relax_info;
2975
2976 relax_info = get_avr_relax_info (sec);
2977 if (relax_info->records.count > 0)
2978 {
2979 unsigned int i;
2980
2981 for (i = 0; i < relax_info->records.count; ++i)
2982 {
2983 switch (relax_info->records.items [i].type)
2984 {
2985 case RECORD_ORG:
2986 case RECORD_ORG_AND_FILL:
2987 break;
2988 case RECORD_ALIGN:
2989 case RECORD_ALIGN_AND_FILL:
2990 {
2991 struct avr_property_record *record;
2992 unsigned long bytes_to_align;
2993 int count = 0;
2994
2995 /* Look for alignment directives that have had enough
2996 bytes deleted before them, such that the directive
2997 can be moved backwards and still maintain the
2998 required alignment. */
2999 record = &relax_info->records.items [i];
3000 bytes_to_align
3001 = (unsigned long) (1 << record->data.align.bytes);
3002 while (record->data.align.preceding_deleted >=
3003 bytes_to_align)
3004 {
3005 record->data.align.preceding_deleted
3006 -= bytes_to_align;
3007 count += bytes_to_align;
3008 }
3009
3010 if (count > 0)
3011 {
3012 bfd_vma addr = record->offset;
3013
3014 /* We can delete COUNT bytes and this alignment
3015 directive will still be correctly aligned.
3016 First move the alignment directive, then delete
3017 the bytes. */
3018 record->offset -= count;
3019 elf32_avr_relax_delete_bytes (abfd, sec,
3020 addr - count,
3021 count);
3022 *again = TRUE;
3023 }
3024 }
3025 break;
3026 }
3027 }
3028 }
3029 }
3030
3031 if (contents != NULL
3032 && elf_section_data (sec)->this_hdr.contents != contents)
3033 {
3034 if (! link_info->keep_memory)
3035 free (contents);
3036 else
3037 {
3038 /* Cache the section contents for elf_link_input_bfd. */
3039 elf_section_data (sec)->this_hdr.contents = contents;
3040 }
3041 }
3042
3043 if (internal_relocs != NULL
3044 && elf_section_data (sec)->relocs != internal_relocs)
3045 free (internal_relocs);
3046
3047 return TRUE;
3048
3049 error_return:
3050 if (isymbuf != NULL
3051 && symtab_hdr->contents != (unsigned char *) isymbuf)
3052 free (isymbuf);
3053 if (contents != NULL
3054 && elf_section_data (sec)->this_hdr.contents != contents)
3055 free (contents);
3056 if (internal_relocs != NULL
3057 && elf_section_data (sec)->relocs != internal_relocs)
3058 free (internal_relocs);
3059
3060 return FALSE;
3061 }
3062
3063 /* This is a version of bfd_generic_get_relocated_section_contents
3064 which uses elf32_avr_relocate_section.
3065
3066 For avr it's essentially a cut and paste taken from the H8300 port.
3067 The author of the relaxation support patch for avr had absolutely no
3068 clue what is happening here but found out that this part of the code
3069 seems to be important. */
3070
3071 static bfd_byte *
3072 elf32_avr_get_relocated_section_contents (bfd *output_bfd,
3073 struct bfd_link_info *link_info,
3074 struct bfd_link_order *link_order,
3075 bfd_byte *data,
3076 bfd_boolean relocatable,
3077 asymbol **symbols)
3078 {
3079 Elf_Internal_Shdr *symtab_hdr;
3080 asection *input_section = link_order->u.indirect.section;
3081 bfd *input_bfd = input_section->owner;
3082 asection **sections = NULL;
3083 Elf_Internal_Rela *internal_relocs = NULL;
3084 Elf_Internal_Sym *isymbuf = NULL;
3085
3086 /* We only need to handle the case of relaxing, or of having a
3087 particular set of section contents, specially. */
3088 if (relocatable
3089 || elf_section_data (input_section)->this_hdr.contents == NULL)
3090 return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
3091 link_order, data,
3092 relocatable,
3093 symbols);
3094 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3095
3096 memcpy (data, elf_section_data (input_section)->this_hdr.contents,
3097 (size_t) input_section->size);
3098
3099 if ((input_section->flags & SEC_RELOC) != 0
3100 && input_section->reloc_count > 0)
3101 {
3102 asection **secpp;
3103 Elf_Internal_Sym *isym, *isymend;
3104 bfd_size_type amt;
3105
3106 internal_relocs = (_bfd_elf_link_read_relocs
3107 (input_bfd, input_section, NULL, NULL, FALSE));
3108 if (internal_relocs == NULL)
3109 goto error_return;
3110
3111 if (symtab_hdr->sh_info != 0)
3112 {
3113 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
3114 if (isymbuf == NULL)
3115 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
3116 symtab_hdr->sh_info, 0,
3117 NULL, NULL, NULL);
3118 if (isymbuf == NULL)
3119 goto error_return;
3120 }
3121
3122 amt = symtab_hdr->sh_info;
3123 amt *= sizeof (asection *);
3124 sections = bfd_malloc (amt);
3125 if (sections == NULL && amt != 0)
3126 goto error_return;
3127
3128 isymend = isymbuf + symtab_hdr->sh_info;
3129 for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
3130 {
3131 asection *isec;
3132
3133 if (isym->st_shndx == SHN_UNDEF)
3134 isec = bfd_und_section_ptr;
3135 else if (isym->st_shndx == SHN_ABS)
3136 isec = bfd_abs_section_ptr;
3137 else if (isym->st_shndx == SHN_COMMON)
3138 isec = bfd_com_section_ptr;
3139 else
3140 isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
3141
3142 *secpp = isec;
3143 }
3144
3145 if (! elf32_avr_relocate_section (output_bfd, link_info, input_bfd,
3146 input_section, data, internal_relocs,
3147 isymbuf, sections))
3148 goto error_return;
3149
3150 if (sections != NULL)
3151 free (sections);
3152 if (isymbuf != NULL
3153 && symtab_hdr->contents != (unsigned char *) isymbuf)
3154 free (isymbuf);
3155 if (elf_section_data (input_section)->relocs != internal_relocs)
3156 free (internal_relocs);
3157 }
3158
3159 return data;
3160
3161 error_return:
3162 if (sections != NULL)
3163 free (sections);
3164 if (isymbuf != NULL
3165 && symtab_hdr->contents != (unsigned char *) isymbuf)
3166 free (isymbuf);
3167 if (internal_relocs != NULL
3168 && elf_section_data (input_section)->relocs != internal_relocs)
3169 free (internal_relocs);
3170 return NULL;
3171 }
3172
3173
3174 /* Determines the hash entry name for a particular reloc. It consists of
3175 the identifier of the symbol section and the added reloc addend and
3176 symbol offset relative to the section the symbol is attached to. */
3177
3178 static char *
3179 avr_stub_name (const asection *symbol_section,
3180 const bfd_vma symbol_offset,
3181 const Elf_Internal_Rela *rela)
3182 {
3183 char *stub_name;
3184 bfd_size_type len;
3185
3186 len = 8 + 1 + 8 + 1 + 1;
3187 stub_name = bfd_malloc (len);
3188
3189 sprintf (stub_name, "%08x+%08x",
3190 symbol_section->id & 0xffffffff,
3191 (unsigned int) ((rela->r_addend & 0xffffffff) + symbol_offset));
3192
3193 return stub_name;
3194 }
3195
3196
3197 /* Add a new stub entry to the stub hash. Not all fields of the new
3198 stub entry are initialised. */
3199
3200 static struct elf32_avr_stub_hash_entry *
3201 avr_add_stub (const char *stub_name,
3202 struct elf32_avr_link_hash_table *htab)
3203 {
3204 struct elf32_avr_stub_hash_entry *hsh;
3205
3206 /* Enter this entry into the linker stub hash table. */
3207 hsh = avr_stub_hash_lookup (&htab->bstab, stub_name, TRUE, FALSE);
3208
3209 if (hsh == NULL)
3210 {
3211 (*_bfd_error_handler) (_("%B: cannot create stub entry %s"),
3212 NULL, stub_name);
3213 return NULL;
3214 }
3215
3216 hsh->stub_offset = 0;
3217 return hsh;
3218 }
3219
3220 /* We assume that there is already space allocated for the stub section
3221 contents and that before building the stubs the section size is
3222 initialized to 0. We assume that within the stub hash table entry,
3223 the absolute position of the jmp target has been written in the
3224 target_value field. We write here the offset of the generated jmp insn
3225 relative to the trampoline section start to the stub_offset entry in
3226 the stub hash table entry. */
3227
3228 static bfd_boolean
3229 avr_build_one_stub (struct bfd_hash_entry *bh, void *in_arg)
3230 {
3231 struct elf32_avr_stub_hash_entry *hsh;
3232 struct bfd_link_info *info;
3233 struct elf32_avr_link_hash_table *htab;
3234 bfd *stub_bfd;
3235 bfd_byte *loc;
3236 bfd_vma target;
3237 bfd_vma starget;
3238
3239 /* Basic opcode */
3240 bfd_vma jmp_insn = 0x0000940c;
3241
3242 /* Massage our args to the form they really have. */
3243 hsh = avr_stub_hash_entry (bh);
3244
3245 if (!hsh->is_actually_needed)
3246 return TRUE;
3247
3248 info = (struct bfd_link_info *) in_arg;
3249
3250 htab = avr_link_hash_table (info);
3251 if (htab == NULL)
3252 return FALSE;
3253
3254 target = hsh->target_value;
3255
3256 /* Make a note of the offset within the stubs for this entry. */
3257 hsh->stub_offset = htab->stub_sec->size;
3258 loc = htab->stub_sec->contents + hsh->stub_offset;
3259
3260 stub_bfd = htab->stub_sec->owner;
3261
3262 if (debug_stubs)
3263 printf ("Building one Stub. Address: 0x%x, Offset: 0x%x\n",
3264 (unsigned int) target,
3265 (unsigned int) hsh->stub_offset);
3266
3267 /* We now have to add the information on the jump target to the bare
3268 opcode bits already set in jmp_insn. */
3269
3270 /* Check for the alignment of the address. */
3271 if (target & 1)
3272 return FALSE;
3273
3274 starget = target >> 1;
3275 jmp_insn |= ((starget & 0x10000) | ((starget << 3) & 0x1f00000)) >> 16;
3276 bfd_put_16 (stub_bfd, jmp_insn, loc);
3277 bfd_put_16 (stub_bfd, (bfd_vma) starget & 0xffff, loc + 2);
3278
3279 htab->stub_sec->size += 4;
3280
3281 /* Now add the entries in the address mapping table if there is still
3282 space left. */
3283 {
3284 unsigned int nr;
3285
3286 nr = htab->amt_entry_cnt + 1;
3287 if (nr <= htab->amt_max_entry_cnt)
3288 {
3289 htab->amt_entry_cnt = nr;
3290
3291 htab->amt_stub_offsets[nr - 1] = hsh->stub_offset;
3292 htab->amt_destination_addr[nr - 1] = target;
3293 }
3294 }
3295
3296 return TRUE;
3297 }
3298
3299 static bfd_boolean
3300 avr_mark_stub_not_to_be_necessary (struct bfd_hash_entry *bh,
3301 void *in_arg ATTRIBUTE_UNUSED)
3302 {
3303 struct elf32_avr_stub_hash_entry *hsh;
3304
3305 hsh = avr_stub_hash_entry (bh);
3306 hsh->is_actually_needed = FALSE;
3307
3308 return TRUE;
3309 }
3310
3311 static bfd_boolean
3312 avr_size_one_stub (struct bfd_hash_entry *bh, void *in_arg)
3313 {
3314 struct elf32_avr_stub_hash_entry *hsh;
3315 struct elf32_avr_link_hash_table *htab;
3316 int size;
3317
3318 /* Massage our args to the form they really have. */
3319 hsh = avr_stub_hash_entry (bh);
3320 htab = in_arg;
3321
3322 if (hsh->is_actually_needed)
3323 size = 4;
3324 else
3325 size = 0;
3326
3327 htab->stub_sec->size += size;
3328 return TRUE;
3329 }
3330
3331 void
3332 elf32_avr_setup_params (struct bfd_link_info *info,
3333 bfd *avr_stub_bfd,
3334 asection *avr_stub_section,
3335 bfd_boolean no_stubs,
3336 bfd_boolean deb_stubs,
3337 bfd_boolean deb_relax,
3338 bfd_vma pc_wrap_around,
3339 bfd_boolean call_ret_replacement)
3340 {
3341 struct elf32_avr_link_hash_table *htab = avr_link_hash_table (info);
3342
3343 if (htab == NULL)
3344 return;
3345 htab->stub_sec = avr_stub_section;
3346 htab->stub_bfd = avr_stub_bfd;
3347 htab->no_stubs = no_stubs;
3348
3349 debug_relax = deb_relax;
3350 debug_stubs = deb_stubs;
3351 avr_pc_wrap_around = pc_wrap_around;
3352 avr_replace_call_ret_sequences = call_ret_replacement;
3353 }
3354
3355
3356 /* Set up various things so that we can make a list of input sections
3357 for each output section included in the link. Returns -1 on error,
3358 0 when no stubs will be needed, and 1 on success. It also sets
3359 information on the stubs bfd and the stub section in the info
3360 struct. */
3361
3362 int
3363 elf32_avr_setup_section_lists (bfd *output_bfd,
3364 struct bfd_link_info *info)
3365 {
3366 bfd *input_bfd;
3367 unsigned int bfd_count;
3368 unsigned int top_id, top_index;
3369 asection *section;
3370 asection **input_list, **list;
3371 bfd_size_type amt;
3372 struct elf32_avr_link_hash_table *htab = avr_link_hash_table (info);
3373
3374 if (htab == NULL || htab->no_stubs)
3375 return 0;
3376
3377 /* Count the number of input BFDs and find the top input section id. */
3378 for (input_bfd = info->input_bfds, bfd_count = 0, top_id = 0;
3379 input_bfd != NULL;
3380 input_bfd = input_bfd->link.next)
3381 {
3382 bfd_count += 1;
3383 for (section = input_bfd->sections;
3384 section != NULL;
3385 section = section->next)
3386 if (top_id < section->id)
3387 top_id = section->id;
3388 }
3389
3390 htab->bfd_count = bfd_count;
3391
3392 /* We can't use output_bfd->section_count here to find the top output
3393 section index as some sections may have been removed, and
3394 strip_excluded_output_sections doesn't renumber the indices. */
3395 for (section = output_bfd->sections, top_index = 0;
3396 section != NULL;
3397 section = section->next)
3398 if (top_index < section->index)
3399 top_index = section->index;
3400
3401 htab->top_index = top_index;
3402 amt = sizeof (asection *) * (top_index + 1);
3403 input_list = bfd_malloc (amt);
3404 htab->input_list = input_list;
3405 if (input_list == NULL)
3406 return -1;
3407
3408 /* For sections we aren't interested in, mark their entries with a
3409 value we can check later. */
3410 list = input_list + top_index;
3411 do
3412 *list = bfd_abs_section_ptr;
3413 while (list-- != input_list);
3414
3415 for (section = output_bfd->sections;
3416 section != NULL;
3417 section = section->next)
3418 if ((section->flags & SEC_CODE) != 0)
3419 input_list[section->index] = NULL;
3420
3421 return 1;
3422 }
3423
3424
3425 /* Read in all local syms for all input bfds, and create hash entries
3426 for export stubs if we are building a multi-subspace shared lib.
3427 Returns -1 on error, 0 otherwise. */
3428
3429 static int
3430 get_local_syms (bfd *input_bfd, struct bfd_link_info *info)
3431 {
3432 unsigned int bfd_indx;
3433 Elf_Internal_Sym *local_syms, **all_local_syms;
3434 struct elf32_avr_link_hash_table *htab = avr_link_hash_table (info);
3435 bfd_size_type amt;
3436
3437 if (htab == NULL)
3438 return -1;
3439
3440 /* We want to read in symbol extension records only once. To do this
3441 we need to read in the local symbols in parallel and save them for
3442 later use; so hold pointers to the local symbols in an array. */
3443 amt = sizeof (Elf_Internal_Sym *) * htab->bfd_count;
3444 all_local_syms = bfd_zmalloc (amt);
3445 htab->all_local_syms = all_local_syms;
3446 if (all_local_syms == NULL)
3447 return -1;
3448
3449 /* Walk over all the input BFDs, swapping in local symbols.
3450 If we are creating a shared library, create hash entries for the
3451 export stubs. */
3452 for (bfd_indx = 0;
3453 input_bfd != NULL;
3454 input_bfd = input_bfd->link.next, bfd_indx++)
3455 {
3456 Elf_Internal_Shdr *symtab_hdr;
3457
3458 /* We'll need the symbol table in a second. */
3459 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3460 if (symtab_hdr->sh_info == 0)
3461 continue;
3462
3463 /* We need an array of the local symbols attached to the input bfd. */
3464 local_syms = (Elf_Internal_Sym *) symtab_hdr->contents;
3465 if (local_syms == NULL)
3466 {
3467 local_syms = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
3468 symtab_hdr->sh_info, 0,
3469 NULL, NULL, NULL);
3470 /* Cache them for elf_link_input_bfd. */
3471 symtab_hdr->contents = (unsigned char *) local_syms;
3472 }
3473 if (local_syms == NULL)
3474 return -1;
3475
3476 all_local_syms[bfd_indx] = local_syms;
3477 }
3478
3479 return 0;
3480 }
3481
3482 #define ADD_DUMMY_STUBS_FOR_DEBUGGING 0
3483
3484 bfd_boolean
3485 elf32_avr_size_stubs (bfd *output_bfd,
3486 struct bfd_link_info *info,
3487 bfd_boolean is_prealloc_run)
3488 {
3489 struct elf32_avr_link_hash_table *htab;
3490 int stub_changed = 0;
3491
3492 htab = avr_link_hash_table (info);
3493 if (htab == NULL)
3494 return FALSE;
3495
3496 /* At this point we initialize htab->vector_base
3497 To the start of the text output section. */
3498 htab->vector_base = htab->stub_sec->output_section->vma;
3499
3500 if (get_local_syms (info->input_bfds, info))
3501 {
3502 if (htab->all_local_syms)
3503 goto error_ret_free_local;
3504 return FALSE;
3505 }
3506
3507 if (ADD_DUMMY_STUBS_FOR_DEBUGGING)
3508 {
3509 struct elf32_avr_stub_hash_entry *test;
3510
3511 test = avr_add_stub ("Hugo",htab);
3512 test->target_value = 0x123456;
3513 test->stub_offset = 13;
3514
3515 test = avr_add_stub ("Hugo2",htab);
3516 test->target_value = 0x84210;
3517 test->stub_offset = 14;
3518 }
3519
3520 while (1)
3521 {
3522 bfd *input_bfd;
3523 unsigned int bfd_indx;
3524
3525 /* We will have to re-generate the stub hash table each time anything
3526 in memory has changed. */
3527
3528 bfd_hash_traverse (&htab->bstab, avr_mark_stub_not_to_be_necessary, htab);
3529 for (input_bfd = info->input_bfds, bfd_indx = 0;
3530 input_bfd != NULL;
3531 input_bfd = input_bfd->link.next, bfd_indx++)
3532 {
3533 Elf_Internal_Shdr *symtab_hdr;
3534 asection *section;
3535 Elf_Internal_Sym *local_syms;
3536
3537 /* We'll need the symbol table in a second. */
3538 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3539 if (symtab_hdr->sh_info == 0)
3540 continue;
3541
3542 local_syms = htab->all_local_syms[bfd_indx];
3543
3544 /* Walk over each section attached to the input bfd. */
3545 for (section = input_bfd->sections;
3546 section != NULL;
3547 section = section->next)
3548 {
3549 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
3550
3551 /* If there aren't any relocs, then there's nothing more
3552 to do. */
3553 if ((section->flags & SEC_RELOC) == 0
3554 || section->reloc_count == 0)
3555 continue;
3556
3557 /* If this section is a link-once section that will be
3558 discarded, then don't create any stubs. */
3559 if (section->output_section == NULL
3560 || section->output_section->owner != output_bfd)
3561 continue;
3562
3563 /* Get the relocs. */
3564 internal_relocs
3565 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
3566 info->keep_memory);
3567 if (internal_relocs == NULL)
3568 goto error_ret_free_local;
3569
3570 /* Now examine each relocation. */
3571 irela = internal_relocs;
3572 irelaend = irela + section->reloc_count;
3573 for (; irela < irelaend; irela++)
3574 {
3575 unsigned int r_type, r_indx;
3576 struct elf32_avr_stub_hash_entry *hsh;
3577 asection *sym_sec;
3578 bfd_vma sym_value;
3579 bfd_vma destination;
3580 struct elf_link_hash_entry *hh;
3581 char *stub_name;
3582
3583 r_type = ELF32_R_TYPE (irela->r_info);
3584 r_indx = ELF32_R_SYM (irela->r_info);
3585
3586 /* Only look for 16 bit GS relocs. No other reloc will need a
3587 stub. */
3588 if (!((r_type == R_AVR_16_PM)
3589 || (r_type == R_AVR_LO8_LDI_GS)
3590 || (r_type == R_AVR_HI8_LDI_GS)))
3591 continue;
3592
3593 /* Now determine the call target, its name, value,
3594 section. */
3595 sym_sec = NULL;
3596 sym_value = 0;
3597 destination = 0;
3598 hh = NULL;
3599 if (r_indx < symtab_hdr->sh_info)
3600 {
3601 /* It's a local symbol. */
3602 Elf_Internal_Sym *sym;
3603 Elf_Internal_Shdr *hdr;
3604 unsigned int shndx;
3605
3606 sym = local_syms + r_indx;
3607 if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
3608 sym_value = sym->st_value;
3609 shndx = sym->st_shndx;
3610 if (shndx < elf_numsections (input_bfd))
3611 {
3612 hdr = elf_elfsections (input_bfd)[shndx];
3613 sym_sec = hdr->bfd_section;
3614 destination = (sym_value + irela->r_addend
3615 + sym_sec->output_offset
3616 + sym_sec->output_section->vma);
3617 }
3618 }
3619 else
3620 {
3621 /* It's an external symbol. */
3622 int e_indx;
3623
3624 e_indx = r_indx - symtab_hdr->sh_info;
3625 hh = elf_sym_hashes (input_bfd)[e_indx];
3626
3627 while (hh->root.type == bfd_link_hash_indirect
3628 || hh->root.type == bfd_link_hash_warning)
3629 hh = (struct elf_link_hash_entry *)
3630 (hh->root.u.i.link);
3631
3632 if (hh->root.type == bfd_link_hash_defined
3633 || hh->root.type == bfd_link_hash_defweak)
3634 {
3635 sym_sec = hh->root.u.def.section;
3636 sym_value = hh->root.u.def.value;
3637 if (sym_sec->output_section != NULL)
3638 destination = (sym_value + irela->r_addend
3639 + sym_sec->output_offset
3640 + sym_sec->output_section->vma);
3641 }
3642 else if (hh->root.type == bfd_link_hash_undefweak)
3643 {
3644 if (! bfd_link_pic (info))
3645 continue;
3646 }
3647 else if (hh->root.type == bfd_link_hash_undefined)
3648 {
3649 if (! (info->unresolved_syms_in_objects == RM_IGNORE
3650 && (ELF_ST_VISIBILITY (hh->other)
3651 == STV_DEFAULT)))
3652 continue;
3653 }
3654 else
3655 {
3656 bfd_set_error (bfd_error_bad_value);
3657
3658 error_ret_free_internal:
3659 if (elf_section_data (section)->relocs == NULL)
3660 free (internal_relocs);
3661 goto error_ret_free_local;
3662 }
3663 }
3664
3665 if (! avr_stub_is_required_for_16_bit_reloc
3666 (destination - htab->vector_base))
3667 {
3668 if (!is_prealloc_run)
3669 /* We are having a reloc that does't need a stub. */
3670 continue;
3671
3672 /* We don't right now know if a stub will be needed.
3673 Let's rather be on the safe side. */
3674 }
3675
3676 /* Get the name of this stub. */
3677 stub_name = avr_stub_name (sym_sec, sym_value, irela);
3678
3679 if (!stub_name)
3680 goto error_ret_free_internal;
3681
3682
3683 hsh = avr_stub_hash_lookup (&htab->bstab,
3684 stub_name,
3685 FALSE, FALSE);
3686 if (hsh != NULL)
3687 {
3688 /* The proper stub has already been created. Mark it
3689 to be used and write the possibly changed destination
3690 value. */
3691 hsh->is_actually_needed = TRUE;
3692 hsh->target_value = destination;
3693 free (stub_name);
3694 continue;
3695 }
3696
3697 hsh = avr_add_stub (stub_name, htab);
3698 if (hsh == NULL)
3699 {
3700 free (stub_name);
3701 goto error_ret_free_internal;
3702 }
3703
3704 hsh->is_actually_needed = TRUE;
3705 hsh->target_value = destination;
3706
3707 if (debug_stubs)
3708 printf ("Adding stub with destination 0x%x to the"
3709 " hash table.\n", (unsigned int) destination);
3710 if (debug_stubs)
3711 printf ("(Pre-Alloc run: %i)\n", is_prealloc_run);
3712
3713 stub_changed = TRUE;
3714 }
3715
3716 /* We're done with the internal relocs, free them. */
3717 if (elf_section_data (section)->relocs == NULL)
3718 free (internal_relocs);
3719 }
3720 }
3721
3722 /* Re-Calculate the number of needed stubs. */
3723 htab->stub_sec->size = 0;
3724 bfd_hash_traverse (&htab->bstab, avr_size_one_stub, htab);
3725
3726 if (!stub_changed)
3727 break;
3728
3729 stub_changed = FALSE;
3730 }
3731
3732 free (htab->all_local_syms);
3733 return TRUE;
3734
3735 error_ret_free_local:
3736 free (htab->all_local_syms);
3737 return FALSE;
3738 }
3739
3740
3741 /* Build all the stubs associated with the current output file. The
3742 stubs are kept in a hash table attached to the main linker hash
3743 table. We also set up the .plt entries for statically linked PIC
3744 functions here. This function is called via hppaelf_finish in the
3745 linker. */
3746
3747 bfd_boolean
3748 elf32_avr_build_stubs (struct bfd_link_info *info)
3749 {
3750 asection *stub_sec;
3751 struct bfd_hash_table *table;
3752 struct elf32_avr_link_hash_table *htab;
3753 bfd_size_type total_size = 0;
3754
3755 htab = avr_link_hash_table (info);
3756 if (htab == NULL)
3757 return FALSE;
3758
3759 /* In case that there were several stub sections: */
3760 for (stub_sec = htab->stub_bfd->sections;
3761 stub_sec != NULL;
3762 stub_sec = stub_sec->next)
3763 {
3764 bfd_size_type size;
3765
3766 /* Allocate memory to hold the linker stubs. */
3767 size = stub_sec->size;
3768 total_size += size;
3769
3770 stub_sec->contents = bfd_zalloc (htab->stub_bfd, size);
3771 if (stub_sec->contents == NULL && size != 0)
3772 return FALSE;
3773 stub_sec->size = 0;
3774 }
3775
3776 /* Allocate memory for the adress mapping table. */
3777 htab->amt_entry_cnt = 0;
3778 htab->amt_max_entry_cnt = total_size / 4;
3779 htab->amt_stub_offsets = bfd_malloc (sizeof (bfd_vma)
3780 * htab->amt_max_entry_cnt);
3781 htab->amt_destination_addr = bfd_malloc (sizeof (bfd_vma)
3782 * htab->amt_max_entry_cnt );
3783
3784 if (debug_stubs)
3785 printf ("Allocating %i entries in the AMT\n", htab->amt_max_entry_cnt);
3786
3787 /* Build the stubs as directed by the stub hash table. */
3788 table = &htab->bstab;
3789 bfd_hash_traverse (table, avr_build_one_stub, info);
3790
3791 if (debug_stubs)
3792 printf ("Final Stub section Size: %i\n", (int) htab->stub_sec->size);
3793
3794 return TRUE;
3795 }
3796
3797 /* Callback used by QSORT to order relocations AP and BP. */
3798
3799 static int
3800 internal_reloc_compare (const void *ap, const void *bp)
3801 {
3802 const Elf_Internal_Rela *a = (const Elf_Internal_Rela *) ap;
3803 const Elf_Internal_Rela *b = (const Elf_Internal_Rela *) bp;
3804
3805 if (a->r_offset != b->r_offset)
3806 return (a->r_offset - b->r_offset);
3807
3808 /* We don't need to sort on these criteria for correctness,
3809 but enforcing a more strict ordering prevents unstable qsort
3810 from behaving differently with different implementations.
3811 Without the code below we get correct but different results
3812 on Solaris 2.7 and 2.8. We would like to always produce the
3813 same results no matter the host. */
3814
3815 if (a->r_info != b->r_info)
3816 return (a->r_info - b->r_info);
3817
3818 return (a->r_addend - b->r_addend);
3819 }
3820
3821 /* Return true if ADDRESS is within the vma range of SECTION from ABFD. */
3822
3823 static bfd_boolean
3824 avr_is_section_for_address (bfd *abfd, asection *section, bfd_vma address)
3825 {
3826 bfd_vma vma;
3827 bfd_size_type size;
3828
3829 vma = bfd_get_section_vma (abfd, section);
3830 if (address < vma)
3831 return FALSE;
3832
3833 size = section->size;
3834 if (address >= vma + size)
3835 return FALSE;
3836
3837 return TRUE;
3838 }
3839
3840 /* Data structure used by AVR_FIND_SECTION_FOR_ADDRESS. */
3841
3842 struct avr_find_section_data
3843 {
3844 /* The address we're looking for. */
3845 bfd_vma address;
3846
3847 /* The section we've found. */
3848 asection *section;
3849 };
3850
3851 /* Helper function to locate the section holding a certain virtual memory
3852 address. This is called via bfd_map_over_sections. The DATA is an
3853 instance of STRUCT AVR_FIND_SECTION_DATA, the address field of which
3854 has been set to the address to search for, and the section field has
3855 been set to NULL. If SECTION from ABFD contains ADDRESS then the
3856 section field in DATA will be set to SECTION. As an optimisation, if
3857 the section field is already non-null then this function does not
3858 perform any checks, and just returns. */
3859
3860 static void
3861 avr_find_section_for_address (bfd *abfd,
3862 asection *section, void *data)
3863 {
3864 struct avr_find_section_data *fs_data
3865 = (struct avr_find_section_data *) data;
3866
3867 /* Return if already found. */
3868 if (fs_data->section != NULL)
3869 return;
3870
3871 /* If this section isn't part of the addressable code content, skip it. */
3872 if ((bfd_get_section_flags (abfd, section) & SEC_ALLOC) == 0
3873 && (bfd_get_section_flags (abfd, section) & SEC_CODE) == 0)
3874 return;
3875
3876 if (avr_is_section_for_address (abfd, section, fs_data->address))
3877 fs_data->section = section;
3878 }
3879
3880 /* Load all of the property records from SEC, a section from ABFD. Return
3881 a STRUCT AVR_PROPERTY_RECORD_LIST containing all the records. The
3882 memory for the returned structure, and all of the records pointed too by
3883 the structure are allocated with a single call to malloc, so, only the
3884 pointer returned needs to be free'd. */
3885
3886 static struct avr_property_record_list *
3887 avr_elf32_load_records_from_section (bfd *abfd, asection *sec)
3888 {
3889 char *contents = NULL, *ptr;
3890 bfd_size_type size, mem_size;
3891 bfd_byte version, flags;
3892 uint16_t record_count, i;
3893 struct avr_property_record_list *r_list = NULL;
3894 Elf_Internal_Rela *internal_relocs = NULL, *rel, *rel_end;
3895 struct avr_find_section_data fs_data;
3896
3897 fs_data.section = NULL;
3898
3899 size = bfd_get_section_size (sec);
3900 contents = bfd_malloc (size);
3901 bfd_get_section_contents (abfd, sec, contents, 0, size);
3902 ptr = contents;
3903
3904 /* Load the relocations for the '.avr.prop' section if there are any, and
3905 sort them. */
3906 internal_relocs = (_bfd_elf_link_read_relocs
3907 (abfd, sec, NULL, NULL, FALSE));
3908 if (internal_relocs)
3909 qsort (internal_relocs, sec->reloc_count,
3910 sizeof (Elf_Internal_Rela), internal_reloc_compare);
3911
3912 /* There is a header at the start of the property record section SEC, the
3913 format of this header is:
3914 uint8_t : version number
3915 uint8_t : flags
3916 uint16_t : record counter
3917 */
3918
3919 /* Check we have at least got a headers worth of bytes. */
3920 if (size < AVR_PROPERTY_SECTION_HEADER_SIZE)
3921 goto load_failed;
3922
3923 version = *((bfd_byte *) ptr);
3924 ptr++;
3925 flags = *((bfd_byte *) ptr);
3926 ptr++;
3927 record_count = *((uint16_t *) ptr);
3928 ptr+=2;
3929 BFD_ASSERT (ptr - contents == AVR_PROPERTY_SECTION_HEADER_SIZE);
3930
3931 /* Now allocate space for the list structure, and all of the list
3932 elements in a single block. */
3933 mem_size = sizeof (struct avr_property_record_list)
3934 + sizeof (struct avr_property_record) * record_count;
3935 r_list = bfd_malloc (mem_size);
3936 if (r_list == NULL)
3937 goto load_failed;
3938
3939 r_list->version = version;
3940 r_list->flags = flags;
3941 r_list->section = sec;
3942 r_list->record_count = record_count;
3943 r_list->records = (struct avr_property_record *) (&r_list [1]);
3944 size -= AVR_PROPERTY_SECTION_HEADER_SIZE;
3945
3946 /* Check that we understand the version number. There is only one
3947 version number right now, anything else is an error. */
3948 if (r_list->version != AVR_PROPERTY_RECORDS_VERSION)
3949 goto load_failed;
3950
3951 rel = internal_relocs;
3952 rel_end = rel + sec->reloc_count;
3953 for (i = 0; i < record_count; ++i)
3954 {
3955 bfd_vma address;
3956
3957 /* Each entry is a 32-bit address, followed by a single byte type.
3958 After that is the type specific data. We must take care to
3959 ensure that we don't read beyond the end of the section data. */
3960 if (size < 5)
3961 goto load_failed;
3962
3963 r_list->records [i].section = NULL;
3964 r_list->records [i].offset = 0;
3965
3966 if (rel)
3967 {
3968 /* The offset of the address within the .avr.prop section. */
3969 size_t offset = ptr - contents;
3970
3971 while (rel < rel_end && rel->r_offset < offset)
3972 ++rel;
3973
3974 if (rel == rel_end)
3975 rel = NULL;
3976 else if (rel->r_offset == offset)
3977 {
3978 /* Find section and section offset. */
3979 unsigned long r_symndx;
3980
3981 asection * rel_sec;
3982 bfd_vma sec_offset;
3983
3984 r_symndx = ELF32_R_SYM (rel->r_info);
3985 rel_sec = get_elf_r_symndx_section (abfd, r_symndx);
3986 sec_offset = get_elf_r_symndx_offset (abfd, r_symndx)
3987 + rel->r_addend;
3988
3989 r_list->records [i].section = rel_sec;
3990 r_list->records [i].offset = sec_offset;
3991 }
3992 }
3993
3994 address = *((uint32_t *) ptr);
3995 ptr += 4;
3996 size -= 4;
3997
3998 if (r_list->records [i].section == NULL)
3999 {
4000 /* Try to find section and offset from address. */
4001 if (fs_data.section != NULL
4002 && !avr_is_section_for_address (abfd, fs_data.section,
4003 address))
4004 fs_data.section = NULL;
4005
4006 if (fs_data.section == NULL)
4007 {
4008 fs_data.address = address;
4009 bfd_map_over_sections (abfd, avr_find_section_for_address,
4010 &fs_data);
4011 }
4012
4013 if (fs_data.section == NULL)
4014 {
4015 fprintf (stderr, "Failed to find matching section.\n");
4016 goto load_failed;
4017 }
4018
4019 r_list->records [i].section = fs_data.section;
4020 r_list->records [i].offset
4021 = address - bfd_get_section_vma (abfd, fs_data.section);
4022 }
4023
4024 r_list->records [i].type = *((bfd_byte *) ptr);
4025 ptr += 1;
4026 size -= 1;
4027
4028 switch (r_list->records [i].type)
4029 {
4030 case RECORD_ORG:
4031 /* Nothing else to load. */
4032 break;
4033 case RECORD_ORG_AND_FILL:
4034 /* Just a 4-byte fill to load. */
4035 if (size < 4)
4036 goto load_failed;
4037 r_list->records [i].data.org.fill = *((uint32_t *) ptr);
4038 ptr += 4;
4039 size -= 4;
4040 break;
4041 case RECORD_ALIGN:
4042 /* Just a 4-byte alignment to load. */
4043 if (size < 4)
4044 goto load_failed;
4045 r_list->records [i].data.align.bytes = *((uint32_t *) ptr);
4046 ptr += 4;
4047 size -= 4;
4048 /* Just initialise PRECEDING_DELETED field, this field is
4049 used during linker relaxation. */
4050 r_list->records [i].data.align.preceding_deleted = 0;
4051 break;
4052 case RECORD_ALIGN_AND_FILL:
4053 /* A 4-byte alignment, and a 4-byte fill to load. */
4054 if (size < 8)
4055 goto load_failed;
4056 r_list->records [i].data.align.bytes = *((uint32_t *) ptr);
4057 ptr += 4;
4058 r_list->records [i].data.align.fill = *((uint32_t *) ptr);
4059 ptr += 4;
4060 size -= 8;
4061 /* Just initialise PRECEDING_DELETED field, this field is
4062 used during linker relaxation. */
4063 r_list->records [i].data.align.preceding_deleted = 0;
4064 break;
4065 default:
4066 goto load_failed;
4067 }
4068 }
4069
4070 free (contents);
4071 free (internal_relocs);
4072 return r_list;
4073
4074 load_failed:
4075 free (internal_relocs);
4076 free (contents);
4077 free (r_list);
4078 return NULL;
4079 }
4080
4081 /* Load all of the property records from ABFD. See
4082 AVR_ELF32_LOAD_RECORDS_FROM_SECTION for details of the return value. */
4083
4084 struct avr_property_record_list *
4085 avr_elf32_load_property_records (bfd *abfd)
4086 {
4087 asection *sec;
4088
4089 /* Find the '.avr.prop' section and load the contents into memory. */
4090 sec = bfd_get_section_by_name (abfd, AVR_PROPERTY_RECORD_SECTION_NAME);
4091 if (sec == NULL)
4092 return NULL;
4093 return avr_elf32_load_records_from_section (abfd, sec);
4094 }
4095
4096 const char *
4097 avr_elf32_property_record_name (struct avr_property_record *rec)
4098 {
4099 const char *str;
4100
4101 switch (rec->type)
4102 {
4103 case RECORD_ORG:
4104 str = "ORG";
4105 break;
4106 case RECORD_ORG_AND_FILL:
4107 str = "ORG+FILL";
4108 break;
4109 case RECORD_ALIGN:
4110 str = "ALIGN";
4111 break;
4112 case RECORD_ALIGN_AND_FILL:
4113 str = "ALIGN+FILL";
4114 break;
4115 default:
4116 str = "unknown";
4117 }
4118
4119 return str;
4120 }
4121
4122
4123 #define ELF_ARCH bfd_arch_avr
4124 #define ELF_TARGET_ID AVR_ELF_DATA
4125 #define ELF_MACHINE_CODE EM_AVR
4126 #define ELF_MACHINE_ALT1 EM_AVR_OLD
4127 #define ELF_MAXPAGESIZE 1
4128
4129 #define TARGET_LITTLE_SYM avr_elf32_vec
4130 #define TARGET_LITTLE_NAME "elf32-avr"
4131
4132 #define bfd_elf32_bfd_link_hash_table_create elf32_avr_link_hash_table_create
4133
4134 #define elf_info_to_howto avr_info_to_howto_rela
4135 #define elf_info_to_howto_rel NULL
4136 #define elf_backend_relocate_section elf32_avr_relocate_section
4137 #define elf_backend_can_gc_sections 1
4138 #define elf_backend_rela_normal 1
4139 #define elf_backend_final_write_processing \
4140 bfd_elf_avr_final_write_processing
4141 #define elf_backend_object_p elf32_avr_object_p
4142
4143 #define bfd_elf32_bfd_relax_section elf32_avr_relax_section
4144 #define bfd_elf32_bfd_get_relocated_section_contents \
4145 elf32_avr_get_relocated_section_contents
4146 #define bfd_elf32_new_section_hook elf_avr_new_section_hook
4147
4148 #include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.115471 seconds and 4 git commands to generate.