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