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