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