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