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