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