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