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