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