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