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