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