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