?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* elf32-spu.c (build_stub): Fix malloc under-allocation.
[binutils.git] / bfd / elf32-avr.c
blob2a10162465e2c827ec136bd76d24c5a20c69ca8b
1 /* AVR-specific support for 32-bit ELF
2 Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
3 2010, 2011 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 case bfd_mach_avrxmega1:
1303 val = E_AVR_MACH_XMEGA1;
1304 break;
1305
1306 case bfd_mach_avrxmega2:
1307 val = E_AVR_MACH_XMEGA2;
1308 break;
1309
1310 case bfd_mach_avrxmega3:
1311 val = E_AVR_MACH_XMEGA3;
1312 break;
1313
1314 case bfd_mach_avrxmega4:
1315 val = E_AVR_MACH_XMEGA4;
1316 break;
1317
1318 case bfd_mach_avrxmega5:
1319 val = E_AVR_MACH_XMEGA5;
1320 break;
1321
1322 case bfd_mach_avrxmega6:
1323 val = E_AVR_MACH_XMEGA6;
1324 break;
1325
1326 case bfd_mach_avrxmega7:
1327 val = E_AVR_MACH_XMEGA7;
1328 break;
1329 }
1330
1331 elf_elfheader (abfd)->e_machine = EM_AVR;
1332 elf_elfheader (abfd)->e_flags &= ~ EF_AVR_MACH;
1333 elf_elfheader (abfd)->e_flags |= val;
1334 elf_elfheader (abfd)->e_flags |= EF_AVR_LINKRELAX_PREPARED;
1335 }
1336
1337 /* Set the right machine number. */
1338
1339 static bfd_boolean
1340 elf32_avr_object_p (bfd *abfd)
1341 {
1342 unsigned int e_set = bfd_mach_avr2;
1343
1344 if (elf_elfheader (abfd)->e_machine == EM_AVR
1345 || elf_elfheader (abfd)->e_machine == EM_AVR_OLD)
1346 {
1347 int e_mach = elf_elfheader (abfd)->e_flags & EF_AVR_MACH;
1348
1349 switch (e_mach)
1350 {
1351 default:
1352 case E_AVR_MACH_AVR2:
1353 e_set = bfd_mach_avr2;
1354 break;
1355
1356 case E_AVR_MACH_AVR1:
1357 e_set = bfd_mach_avr1;
1358 break;
1359
1360 case E_AVR_MACH_AVR25:
1361 e_set = bfd_mach_avr25;
1362 break;
1363
1364 case E_AVR_MACH_AVR3:
1365 e_set = bfd_mach_avr3;
1366 break;
1367
1368 case E_AVR_MACH_AVR31:
1369 e_set = bfd_mach_avr31;
1370 break;
1371
1372 case E_AVR_MACH_AVR35:
1373 e_set = bfd_mach_avr35;
1374 break;
1375
1376 case E_AVR_MACH_AVR4:
1377 e_set = bfd_mach_avr4;
1378 break;
1379
1380 case E_AVR_MACH_AVR5:
1381 e_set = bfd_mach_avr5;
1382 break;
1383
1384 case E_AVR_MACH_AVR51:
1385 e_set = bfd_mach_avr51;
1386 break;
1387
1388 case E_AVR_MACH_AVR6:
1389 e_set = bfd_mach_avr6;
1390 break;
1391
1392 case E_AVR_MACH_XMEGA1:
1393 e_set = bfd_mach_avrxmega1;
1394 break;
1395
1396 case E_AVR_MACH_XMEGA2:
1397 e_set = bfd_mach_avrxmega2;
1398 break;
1399
1400 case E_AVR_MACH_XMEGA3:
1401 e_set = bfd_mach_avrxmega3;
1402 break;
1403
1404 case E_AVR_MACH_XMEGA4:
1405 e_set = bfd_mach_avrxmega4;
1406 break;
1407
1408 case E_AVR_MACH_XMEGA5:
1409 e_set = bfd_mach_avrxmega5;
1410 break;
1411
1412 case E_AVR_MACH_XMEGA6:
1413 e_set = bfd_mach_avrxmega6;
1414 break;
1415
1416 case E_AVR_MACH_XMEGA7:
1417 e_set = bfd_mach_avrxmega7;
1418 break;
1419 }
1420 }
1421 return bfd_default_set_arch_mach (abfd, bfd_arch_avr,
1422 e_set);
1423 }
1424
1425
1426 /* Delete some bytes from a section while changing the size of an instruction.
1427 The parameter "addr" denotes the section-relative offset pointing just
1428 behind the shrinked instruction. "addr+count" point at the first
1429 byte just behind the original unshrinked instruction. */
1430
1431 static bfd_boolean
1432 elf32_avr_relax_delete_bytes (bfd *abfd,
1433 asection *sec,
1434 bfd_vma addr,
1435 int count)
1436 {
1437 Elf_Internal_Shdr *symtab_hdr;
1438 unsigned int sec_shndx;
1439 bfd_byte *contents;
1440 Elf_Internal_Rela *irel, *irelend;
1441 Elf_Internal_Sym *isym;
1442 Elf_Internal_Sym *isymbuf = NULL;
1443 bfd_vma toaddr;
1444 struct elf_link_hash_entry **sym_hashes;
1445 struct elf_link_hash_entry **end_hashes;
1446 unsigned int symcount;
1447
1448 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1449 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1450 contents = elf_section_data (sec)->this_hdr.contents;
1451
1452 toaddr = sec->size;
1453
1454 irel = elf_section_data (sec)->relocs;
1455 irelend = irel + sec->reloc_count;
1456
1457 /* Actually delete the bytes. */
1458 if (toaddr - addr - count > 0)
1459 memmove (contents + addr, contents + addr + count,
1460 (size_t) (toaddr - addr - count));
1461 sec->size -= count;
1462
1463 /* Adjust all the reloc addresses. */
1464 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1465 {
1466 bfd_vma old_reloc_address;
1467
1468 old_reloc_address = (sec->output_section->vma
1469 + sec->output_offset + irel->r_offset);
1470
1471 /* Get the new reloc address. */
1472 if ((irel->r_offset > addr
1473 && irel->r_offset < toaddr))
1474 {
1475 if (debug_relax)
1476 printf ("Relocation at address 0x%x needs to be moved.\n"
1477 "Old section offset: 0x%x, New section offset: 0x%x \n",
1478 (unsigned int) old_reloc_address,
1479 (unsigned int) irel->r_offset,
1480 (unsigned int) ((irel->r_offset) - count));
1481
1482 irel->r_offset -= count;
1483 }
1484
1485 }
1486
1487 /* The reloc's own addresses are now ok. However, we need to readjust
1488 the reloc's addend, i.e. the reloc's value if two conditions are met:
1489 1.) the reloc is relative to a symbol in this section that
1490 is located in front of the shrinked instruction
1491 2.) symbol plus addend end up behind the shrinked instruction.
1492
1493 The most common case where this happens are relocs relative to
1494 the section-start symbol.
1495
1496 This step needs to be done for all of the sections of the bfd. */
1497
1498 {
1499 struct bfd_section *isec;
1500
1501 for (isec = abfd->sections; isec; isec = isec->next)
1502 {
1503 bfd_vma symval;
1504 bfd_vma shrinked_insn_address;
1505
1506 if (isec->reloc_count == 0)
1507 continue;
1508
1509 shrinked_insn_address = (sec->output_section->vma
1510 + sec->output_offset + addr - count);
1511
1512 irel = elf_section_data (isec)->relocs;
1513 /* PR 12161: Read in the relocs for this section if necessary. */
1514 if (irel == NULL)
1515 irel = _bfd_elf_link_read_relocs (abfd, isec, NULL, NULL, FALSE);
1516
1517 for (irelend = irel + isec->reloc_count;
1518 irel < irelend;
1519 irel++)
1520 {
1521 /* Read this BFD's local symbols if we haven't done
1522 so already. */
1523 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
1524 {
1525 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1526 if (isymbuf == NULL)
1527 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
1528 symtab_hdr->sh_info, 0,
1529 NULL, NULL, NULL);
1530 if (isymbuf == NULL)
1531 return FALSE;
1532 }
1533
1534 /* Get the value of the symbol referred to by the reloc. */
1535 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1536 {
1537 /* A local symbol. */
1538 asection *sym_sec;
1539
1540 isym = isymbuf + ELF32_R_SYM (irel->r_info);
1541 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
1542 symval = isym->st_value;
1543 /* If the reloc is absolute, it will not have
1544 a symbol or section associated with it. */
1545 if (sym_sec == sec)
1546 {
1547 symval += sym_sec->output_section->vma
1548 + sym_sec->output_offset;
1549
1550 if (debug_relax)
1551 printf ("Checking if the relocation's "
1552 "addend needs corrections.\n"
1553 "Address of anchor symbol: 0x%x \n"
1554 "Address of relocation target: 0x%x \n"
1555 "Address of relaxed insn: 0x%x \n",
1556 (unsigned int) symval,
1557 (unsigned int) (symval + irel->r_addend),
1558 (unsigned int) shrinked_insn_address);
1559
1560 if (symval <= shrinked_insn_address
1561 && (symval + irel->r_addend) > shrinked_insn_address)
1562 {
1563 irel->r_addend -= count;
1564
1565 if (debug_relax)
1566 printf ("Relocation's addend needed to be fixed \n");
1567 }
1568 }
1569 /* else...Reference symbol is absolute. No adjustment needed. */
1570 }
1571 /* else...Reference symbol is extern. No need for adjusting
1572 the addend. */
1573 }
1574
1575 if (elf_section_data (isec)->relocs == NULL)
1576 free (irelend - isec->reloc_count);
1577 }
1578 }
1579
1580 /* Adjust the local symbols defined in this section. */
1581 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1582 /* Fix PR 9841, there may be no local symbols. */
1583 if (isym != NULL)
1584 {
1585 Elf_Internal_Sym *isymend;
1586
1587 isymend = isym + symtab_hdr->sh_info;
1588 for (; isym < isymend; isym++)
1589 {
1590 if (isym->st_shndx == sec_shndx
1591 && isym->st_value > addr
1592 && isym->st_value < toaddr)
1593 isym->st_value -= count;
1594 }
1595 }
1596
1597 /* Now adjust the global symbols defined in this section. */
1598 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1599 - symtab_hdr->sh_info);
1600 sym_hashes = elf_sym_hashes (abfd);
1601 end_hashes = sym_hashes + symcount;
1602 for (; sym_hashes < end_hashes; sym_hashes++)
1603 {
1604 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1605 if ((sym_hash->root.type == bfd_link_hash_defined
1606 || sym_hash->root.type == bfd_link_hash_defweak)
1607 && sym_hash->root.u.def.section == sec
1608 && sym_hash->root.u.def.value > addr
1609 && sym_hash->root.u.def.value < toaddr)
1610 {
1611 sym_hash->root.u.def.value -= count;
1612 }
1613 }
1614
1615 return TRUE;
1616 }
1617
1618 /* This function handles relaxing for the avr.
1619 Many important relaxing opportunities within functions are already
1620 realized by the compiler itself.
1621 Here we try to replace call (4 bytes) -> rcall (2 bytes)
1622 and jump -> rjmp (safes also 2 bytes).
1623 As well we now optimize seqences of
1624 - call/rcall function
1625 - ret
1626 to yield
1627 - jmp/rjmp function
1628 - ret
1629 . In case that within a sequence
1630 - jmp/rjmp label
1631 - ret
1632 the ret could no longer be reached it is optimized away. In order
1633 to check if the ret is no longer needed, it is checked that the ret's address
1634 is not the target of a branch or jump within the same section, it is checked
1635 that there is no skip instruction before the jmp/rjmp and that there
1636 is no local or global label place at the address of the ret.
1637
1638 We refrain from relaxing within sections ".vectors" and
1639 ".jumptables" in order to maintain the position of the instructions.
1640 There, however, we substitute jmp/call by a sequence rjmp,nop/rcall,nop
1641 if possible. (In future one could possibly use the space of the nop
1642 for the first instruction of the irq service function.
1643
1644 The .jumptables sections is meant to be used for a future tablejump variant
1645 for the devices with 3-byte program counter where the table itself
1646 contains 4-byte jump instructions whose relative offset must not
1647 be changed. */
1648
1649 static bfd_boolean
1650 elf32_avr_relax_section (bfd *abfd,
1651 asection *sec,
1652 struct bfd_link_info *link_info,
1653 bfd_boolean *again)
1654 {
1655 Elf_Internal_Shdr *symtab_hdr;
1656 Elf_Internal_Rela *internal_relocs;
1657 Elf_Internal_Rela *irel, *irelend;
1658 bfd_byte *contents = NULL;
1659 Elf_Internal_Sym *isymbuf = NULL;
1660 struct elf32_avr_link_hash_table *htab;
1661
1662 /* If 'shrinkable' is FALSE, do not shrink by deleting bytes while
1663 relaxing. Such shrinking can cause issues for the sections such
1664 as .vectors and .jumptables. Instead the unused bytes should be
1665 filled with nop instructions. */
1666 bfd_boolean shrinkable = TRUE;
1667
1668 if (!strcmp (sec->name,".vectors")
1669 || !strcmp (sec->name,".jumptables"))
1670 shrinkable = FALSE;
1671
1672 if (link_info->relocatable)
1673 (*link_info->callbacks->einfo)
1674 (_("%P%F: --relax and -r may not be used together\n"));
1675
1676 htab = avr_link_hash_table (link_info);
1677 if (htab == NULL)
1678 return FALSE;
1679
1680 /* Assume nothing changes. */
1681 *again = FALSE;
1682
1683 if ((!htab->no_stubs) && (sec == htab->stub_sec))
1684 {
1685 /* We are just relaxing the stub section.
1686 Let's calculate the size needed again. */
1687 bfd_size_type last_estimated_stub_section_size = htab->stub_sec->size;
1688
1689 if (debug_relax)
1690 printf ("Relaxing the stub section. Size prior to this pass: %i\n",
1691 (int) last_estimated_stub_section_size);
1692
1693 elf32_avr_size_stubs (htab->stub_sec->output_section->owner,
1694 link_info, FALSE);
1695
1696 /* Check if the number of trampolines changed. */
1697 if (last_estimated_stub_section_size != htab->stub_sec->size)
1698 *again = TRUE;
1699
1700 if (debug_relax)
1701 printf ("Size of stub section after this pass: %i\n",
1702 (int) htab->stub_sec->size);
1703
1704 return TRUE;
1705 }
1706
1707 /* We don't have to do anything for a relocatable link, if
1708 this section does not have relocs, or if this is not a
1709 code section. */
1710 if (link_info->relocatable
1711 || (sec->flags & SEC_RELOC) == 0
1712 || sec->reloc_count == 0
1713 || (sec->flags & SEC_CODE) == 0)
1714 return TRUE;
1715
1716 /* Check if the object file to relax uses internal symbols so that we
1717 could fix up the relocations. */
1718 if (!(elf_elfheader (abfd)->e_flags & EF_AVR_LINKRELAX_PREPARED))
1719 return TRUE;
1720
1721 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1722
1723 /* Get a copy of the native relocations. */
1724 internal_relocs = (_bfd_elf_link_read_relocs
1725 (abfd, sec, NULL, NULL, link_info->keep_memory));
1726 if (internal_relocs == NULL)
1727 goto error_return;
1728
1729 /* Walk through the relocs looking for relaxing opportunities. */
1730 irelend = internal_relocs + sec->reloc_count;
1731 for (irel = internal_relocs; irel < irelend; irel++)
1732 {
1733 bfd_vma symval;
1734
1735 if ( ELF32_R_TYPE (irel->r_info) != R_AVR_13_PCREL
1736 && ELF32_R_TYPE (irel->r_info) != R_AVR_7_PCREL
1737 && ELF32_R_TYPE (irel->r_info) != R_AVR_CALL)
1738 continue;
1739
1740 /* Get the section contents if we haven't done so already. */
1741 if (contents == NULL)
1742 {
1743 /* Get cached copy if it exists. */
1744 if (elf_section_data (sec)->this_hdr.contents != NULL)
1745 contents = elf_section_data (sec)->this_hdr.contents;
1746 else
1747 {
1748 /* Go get them off disk. */
1749 if (! bfd_malloc_and_get_section (abfd, sec, &contents))
1750 goto error_return;
1751 }
1752 }
1753
1754 /* Read this BFD's local symbols if we haven't done so already. */
1755 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
1756 {
1757 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1758 if (isymbuf == NULL)
1759 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
1760 symtab_hdr->sh_info, 0,
1761 NULL, NULL, NULL);
1762 if (isymbuf == NULL)
1763 goto error_return;
1764 }
1765
1766
1767 /* Get the value of the symbol referred to by the reloc. */
1768 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1769 {
1770 /* A local symbol. */
1771 Elf_Internal_Sym *isym;
1772 asection *sym_sec;
1773
1774 isym = isymbuf + ELF32_R_SYM (irel->r_info);
1775 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
1776 symval = isym->st_value;
1777 /* If the reloc is absolute, it will not have
1778 a symbol or section associated with it. */
1779 if (sym_sec)
1780 symval += sym_sec->output_section->vma
1781 + sym_sec->output_offset;
1782 }
1783 else
1784 {
1785 unsigned long indx;
1786 struct elf_link_hash_entry *h;
1787
1788 /* An external symbol. */
1789 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
1790 h = elf_sym_hashes (abfd)[indx];
1791 BFD_ASSERT (h != NULL);
1792 if (h->root.type != bfd_link_hash_defined
1793 && h->root.type != bfd_link_hash_defweak)
1794 /* This appears to be a reference to an undefined
1795 symbol. Just ignore it--it will be caught by the
1796 regular reloc processing. */
1797 continue;
1798
1799 symval = (h->root.u.def.value
1800 + h->root.u.def.section->output_section->vma
1801 + h->root.u.def.section->output_offset);
1802 }
1803
1804 /* For simplicity of coding, we are going to modify the section
1805 contents, the section relocs, and the BFD symbol table. We
1806 must tell the rest of the code not to free up this
1807 information. It would be possible to instead create a table
1808 of changes which have to be made, as is done in coff-mips.c;
1809 that would be more work, but would require less memory when
1810 the linker is run. */
1811 switch (ELF32_R_TYPE (irel->r_info))
1812 {
1813 /* Try to turn a 22-bit absolute call/jump into an 13-bit
1814 pc-relative rcall/rjmp. */
1815 case R_AVR_CALL:
1816 {
1817 bfd_vma value = symval + irel->r_addend;
1818 bfd_vma dot, gap;
1819 int distance_short_enough = 0;
1820
1821 /* Get the address of this instruction. */
1822 dot = (sec->output_section->vma
1823 + sec->output_offset + irel->r_offset);
1824
1825 /* Compute the distance from this insn to the branch target. */
1826 gap = value - dot;
1827
1828 /* Check if the gap falls in the range that can be accommodated
1829 in 13bits signed (It is 12bits when encoded, as we deal with
1830 word addressing). */
1831 if (!shrinkable && ((int) gap >= -4096 && (int) gap <= 4095))
1832 distance_short_enough = 1;
1833 /* If shrinkable, then we can check for a range of distance which
1834 is two bytes farther on both the directions because the call
1835 or jump target will be closer by two bytes after the
1836 relaxation. */
1837 else if (shrinkable && ((int) gap >= -4094 && (int) gap <= 4097))
1838 distance_short_enough = 1;
1839
1840 /* Here we handle the wrap-around case. E.g. for a 16k device
1841 we could use a rjmp to jump from address 0x100 to 0x3d00!
1842 In order to make this work properly, we need to fill the
1843 vaiable avr_pc_wrap_around with the appropriate value.
1844 I.e. 0x4000 for a 16k device. */
1845 {
1846 /* Shrinking the code size makes the gaps larger in the
1847 case of wrap-arounds. So we use a heuristical safety
1848 margin to avoid that during relax the distance gets
1849 again too large for the short jumps. Let's assume
1850 a typical code-size reduction due to relax for a
1851 16k device of 600 bytes. So let's use twice the
1852 typical value as safety margin. */
1853 int rgap;
1854 int safety_margin;
1855
1856 int assumed_shrink = 600;
1857 if (avr_pc_wrap_around > 0x4000)
1858 assumed_shrink = 900;
1859
1860 safety_margin = 2 * assumed_shrink;
1861
1862 rgap = avr_relative_distance_considering_wrap_around (gap);
1863
1864 if (rgap >= (-4092 + safety_margin)
1865 && rgap <= (4094 - safety_margin))
1866 distance_short_enough = 1;
1867 }
1868
1869 if (distance_short_enough)
1870 {
1871 unsigned char code_msb;
1872 unsigned char code_lsb;
1873
1874 if (debug_relax)
1875 printf ("shrinking jump/call instruction at address 0x%x"
1876 " in section %s\n\n",
1877 (int) dot, sec->name);
1878
1879 /* Note that we've changed the relocs, section contents,
1880 etc. */
1881 elf_section_data (sec)->relocs = internal_relocs;
1882 elf_section_data (sec)->this_hdr.contents = contents;
1883 symtab_hdr->contents = (unsigned char *) isymbuf;
1884
1885 /* Get the instruction code for relaxing. */
1886 code_lsb = bfd_get_8 (abfd, contents + irel->r_offset);
1887 code_msb = bfd_get_8 (abfd, contents + irel->r_offset + 1);
1888
1889 /* Mask out the relocation bits. */
1890 code_msb &= 0x94;
1891 code_lsb &= 0x0E;
1892 if (code_msb == 0x94 && code_lsb == 0x0E)
1893 {
1894 /* we are changing call -> rcall . */
1895 bfd_put_8 (abfd, 0x00, contents + irel->r_offset);
1896 bfd_put_8 (abfd, 0xD0, contents + irel->r_offset + 1);
1897 }
1898 else if (code_msb == 0x94 && code_lsb == 0x0C)
1899 {
1900 /* we are changeing jump -> rjmp. */
1901 bfd_put_8 (abfd, 0x00, contents + irel->r_offset);
1902 bfd_put_8 (abfd, 0xC0, contents + irel->r_offset + 1);
1903 }
1904 else
1905 abort ();
1906
1907 /* Fix the relocation's type. */
1908 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1909 R_AVR_13_PCREL);
1910
1911 /* We should not modify the ordering if 'shrinkable' is
1912 FALSE. */
1913 if (!shrinkable)
1914 {
1915 /* Let's insert a nop. */
1916 bfd_put_8 (abfd, 0x00, contents + irel->r_offset + 2);
1917 bfd_put_8 (abfd, 0x00, contents + irel->r_offset + 3);
1918 }
1919 else
1920 {
1921 /* Delete two bytes of data. */
1922 if (!elf32_avr_relax_delete_bytes (abfd, sec,
1923 irel->r_offset + 2, 2))
1924 goto error_return;
1925
1926 /* That will change things, so, we should relax again.
1927 Note that this is not required, and it may be slow. */
1928 *again = TRUE;
1929 }
1930 }
1931 }
1932
1933 default:
1934 {
1935 unsigned char code_msb;
1936 unsigned char code_lsb;
1937 bfd_vma dot;
1938
1939 code_msb = bfd_get_8 (abfd, contents + irel->r_offset + 1);
1940 code_lsb = bfd_get_8 (abfd, contents + irel->r_offset + 0);
1941
1942 /* Get the address of this instruction. */
1943 dot = (sec->output_section->vma
1944 + sec->output_offset + irel->r_offset);
1945
1946 /* Here we look for rcall/ret or call/ret sequences that could be
1947 safely replaced by rjmp/ret or jmp/ret. */
1948 if (((code_msb & 0xf0) == 0xd0)
1949 && avr_replace_call_ret_sequences)
1950 {
1951 /* This insn is a rcall. */
1952 unsigned char next_insn_msb = 0;
1953 unsigned char next_insn_lsb = 0;
1954
1955 if (irel->r_offset + 3 < sec->size)
1956 {
1957 next_insn_msb =
1958 bfd_get_8 (abfd, contents + irel->r_offset + 3);
1959 next_insn_lsb =
1960 bfd_get_8 (abfd, contents + irel->r_offset + 2);
1961 }
1962
1963 if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb))
1964 {
1965 /* The next insn is a ret. We now convert the rcall insn
1966 into a rjmp instruction. */
1967 code_msb &= 0xef;
1968 bfd_put_8 (abfd, code_msb, contents + irel->r_offset + 1);
1969 if (debug_relax)
1970 printf ("converted rcall/ret sequence at address 0x%x"
1971 " into rjmp/ret sequence. Section is %s\n\n",
1972 (int) dot, sec->name);
1973 *again = TRUE;
1974 break;
1975 }
1976 }
1977 else if ((0x94 == (code_msb & 0xfe))
1978 && (0x0e == (code_lsb & 0x0e))
1979 && avr_replace_call_ret_sequences)
1980 {
1981 /* This insn is a call. */
1982 unsigned char next_insn_msb = 0;
1983 unsigned char next_insn_lsb = 0;
1984
1985 if (irel->r_offset + 5 < sec->size)
1986 {
1987 next_insn_msb =
1988 bfd_get_8 (abfd, contents + irel->r_offset + 5);
1989 next_insn_lsb =
1990 bfd_get_8 (abfd, contents + irel->r_offset + 4);
1991 }
1992
1993 if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb))
1994 {
1995 /* The next insn is a ret. We now convert the call insn
1996 into a jmp instruction. */
1997
1998 code_lsb &= 0xfd;
1999 bfd_put_8 (abfd, code_lsb, contents + irel->r_offset);
2000 if (debug_relax)
2001 printf ("converted call/ret sequence at address 0x%x"
2002 " into jmp/ret sequence. Section is %s\n\n",
2003 (int) dot, sec->name);
2004 *again = TRUE;
2005 break;
2006 }
2007 }
2008 else if ((0xc0 == (code_msb & 0xf0))
2009 || ((0x94 == (code_msb & 0xfe))
2010 && (0x0c == (code_lsb & 0x0e))))
2011 {
2012 /* This insn is a rjmp or a jmp. */
2013 unsigned char next_insn_msb = 0;
2014 unsigned char next_insn_lsb = 0;
2015 int insn_size;
2016
2017 if (0xc0 == (code_msb & 0xf0))
2018 insn_size = 2; /* rjmp insn */
2019 else
2020 insn_size = 4; /* jmp insn */
2021
2022 if (irel->r_offset + insn_size + 1 < sec->size)
2023 {
2024 next_insn_msb =
2025 bfd_get_8 (abfd, contents + irel->r_offset
2026 + insn_size + 1);
2027 next_insn_lsb =
2028 bfd_get_8 (abfd, contents + irel->r_offset
2029 + insn_size);
2030 }
2031
2032 if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb))
2033 {
2034 /* The next insn is a ret. We possibly could delete
2035 this ret. First we need to check for preceding
2036 sbis/sbic/sbrs or cpse "skip" instructions. */
2037
2038 int there_is_preceding_non_skip_insn = 1;
2039 bfd_vma address_of_ret;
2040
2041 address_of_ret = dot + insn_size;
2042
2043 if (debug_relax && (insn_size == 2))
2044 printf ("found rjmp / ret sequence at address 0x%x\n",
2045 (int) dot);
2046 if (debug_relax && (insn_size == 4))
2047 printf ("found jmp / ret sequence at address 0x%x\n",
2048 (int) dot);
2049
2050 /* We have to make sure that there is a preceding insn. */
2051 if (irel->r_offset >= 2)
2052 {
2053 unsigned char preceding_msb;
2054 unsigned char preceding_lsb;
2055
2056 preceding_msb =
2057 bfd_get_8 (abfd, contents + irel->r_offset - 1);
2058 preceding_lsb =
2059 bfd_get_8 (abfd, contents + irel->r_offset - 2);
2060
2061 /* sbic. */
2062 if (0x99 == preceding_msb)
2063 there_is_preceding_non_skip_insn = 0;
2064
2065 /* sbis. */
2066 if (0x9b == preceding_msb)
2067 there_is_preceding_non_skip_insn = 0;
2068
2069 /* sbrc */
2070 if ((0xfc == (preceding_msb & 0xfe)
2071 && (0x00 == (preceding_lsb & 0x08))))
2072 there_is_preceding_non_skip_insn = 0;
2073
2074 /* sbrs */
2075 if ((0xfe == (preceding_msb & 0xfe)
2076 && (0x00 == (preceding_lsb & 0x08))))
2077 there_is_preceding_non_skip_insn = 0;
2078
2079 /* cpse */
2080 if (0x10 == (preceding_msb & 0xfc))
2081 there_is_preceding_non_skip_insn = 0;
2082
2083 if (there_is_preceding_non_skip_insn == 0)
2084 if (debug_relax)
2085 printf ("preceding skip insn prevents deletion of"
2086 " ret insn at Addy 0x%x in section %s\n",
2087 (int) dot + 2, sec->name);
2088 }
2089 else
2090 {
2091 /* There is no previous instruction. */
2092 there_is_preceding_non_skip_insn = 0;
2093 }
2094
2095 if (there_is_preceding_non_skip_insn)
2096 {
2097 /* We now only have to make sure that there is no
2098 local label defined at the address of the ret
2099 instruction and that there is no local relocation
2100 in this section pointing to the ret. */
2101
2102 int deleting_ret_is_safe = 1;
2103 unsigned int section_offset_of_ret_insn =
2104 irel->r_offset + insn_size;
2105 Elf_Internal_Sym *isym, *isymend;
2106 unsigned int sec_shndx;
2107
2108 sec_shndx =
2109 _bfd_elf_section_from_bfd_section (abfd, sec);
2110
2111 /* Check for local symbols. */
2112 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
2113 isymend = isym + symtab_hdr->sh_info;
2114 /* PR 6019: There may not be any local symbols. */
2115 for (; isym != NULL && isym < isymend; isym++)
2116 {
2117 if (isym->st_value == section_offset_of_ret_insn
2118 && isym->st_shndx == sec_shndx)
2119 {
2120 deleting_ret_is_safe = 0;
2121 if (debug_relax)
2122 printf ("local label prevents deletion of ret "
2123 "insn at address 0x%x\n",
2124 (int) dot + insn_size);
2125 }
2126 }
2127
2128 /* Now check for global symbols. */
2129 {
2130 int symcount;
2131 struct elf_link_hash_entry **sym_hashes;
2132 struct elf_link_hash_entry **end_hashes;
2133
2134 symcount = (symtab_hdr->sh_size
2135 / sizeof (Elf32_External_Sym)
2136 - symtab_hdr->sh_info);
2137 sym_hashes = elf_sym_hashes (abfd);
2138 end_hashes = sym_hashes + symcount;
2139 for (; sym_hashes < end_hashes; sym_hashes++)
2140 {
2141 struct elf_link_hash_entry *sym_hash =
2142 *sym_hashes;
2143 if ((sym_hash->root.type == bfd_link_hash_defined
2144 || sym_hash->root.type ==
2145 bfd_link_hash_defweak)
2146 && sym_hash->root.u.def.section == sec
2147 && sym_hash->root.u.def.value == section_offset_of_ret_insn)
2148 {
2149 deleting_ret_is_safe = 0;
2150 if (debug_relax)
2151 printf ("global label prevents deletion of "
2152 "ret insn at address 0x%x\n",
2153 (int) dot + insn_size);
2154 }
2155 }
2156 }
2157 /* Now we check for relocations pointing to ret. */
2158 {
2159 Elf_Internal_Rela *rel;
2160 Elf_Internal_Rela *relend;
2161
2162 relend = elf_section_data (sec)->relocs
2163 + sec->reloc_count;
2164
2165 for (rel = elf_section_data (sec)->relocs;
2166 rel < relend; rel++)
2167 {
2168 bfd_vma reloc_target = 0;
2169
2170 /* Read this BFD's local symbols if we haven't
2171 done so already. */
2172 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
2173 {
2174 isymbuf = (Elf_Internal_Sym *)
2175 symtab_hdr->contents;
2176 if (isymbuf == NULL)
2177 isymbuf = bfd_elf_get_elf_syms
2178 (abfd,
2179 symtab_hdr,
2180 symtab_hdr->sh_info, 0,
2181 NULL, NULL, NULL);
2182 if (isymbuf == NULL)
2183 break;
2184 }
2185
2186 /* Get the value of the symbol referred to
2187 by the reloc. */
2188 if (ELF32_R_SYM (rel->r_info)
2189 < symtab_hdr->sh_info)
2190 {
2191 /* A local symbol. */
2192 asection *sym_sec;
2193
2194 isym = isymbuf
2195 + ELF32_R_SYM (rel->r_info);
2196 sym_sec = bfd_section_from_elf_index
2197 (abfd, isym->st_shndx);
2198 symval = isym->st_value;
2199
2200 /* If the reloc is absolute, it will not
2201 have a symbol or section associated
2202 with it. */
2203
2204 if (sym_sec)
2205 {
2206 symval +=
2207 sym_sec->output_section->vma
2208 + sym_sec->output_offset;
2209 reloc_target = symval + rel->r_addend;
2210 }
2211 else
2212 {
2213 reloc_target = symval + rel->r_addend;
2214 /* Reference symbol is absolute. */
2215 }
2216 }
2217 /* else ... reference symbol is extern. */
2218
2219 if (address_of_ret == reloc_target)
2220 {
2221 deleting_ret_is_safe = 0;
2222 if (debug_relax)
2223 printf ("ret from "
2224 "rjmp/jmp ret sequence at address"
2225 " 0x%x could not be deleted. ret"
2226 " is target of a relocation.\n",
2227 (int) address_of_ret);
2228 }
2229 }
2230 }
2231
2232 if (deleting_ret_is_safe)
2233 {
2234 if (debug_relax)
2235 printf ("unreachable ret instruction "
2236 "at address 0x%x deleted.\n",
2237 (int) dot + insn_size);
2238
2239 /* Delete two bytes of data. */
2240 if (!elf32_avr_relax_delete_bytes (abfd, sec,
2241 irel->r_offset + insn_size, 2))
2242 goto error_return;
2243
2244 /* That will change things, so, we should relax
2245 again. Note that this is not required, and it
2246 may be slow. */
2247 *again = TRUE;
2248 break;
2249 }
2250 }
2251
2252 }
2253 }
2254 break;
2255 }
2256 }
2257 }
2258
2259 if (contents != NULL
2260 && elf_section_data (sec)->this_hdr.contents != contents)
2261 {
2262 if (! link_info->keep_memory)
2263 free (contents);
2264 else
2265 {
2266 /* Cache the section contents for elf_link_input_bfd. */
2267 elf_section_data (sec)->this_hdr.contents = contents;
2268 }
2269 }
2270
2271 if (internal_relocs != NULL
2272 && elf_section_data (sec)->relocs != internal_relocs)
2273 free (internal_relocs);
2274
2275 return TRUE;
2276
2277 error_return:
2278 if (isymbuf != NULL
2279 && symtab_hdr->contents != (unsigned char *) isymbuf)
2280 free (isymbuf);
2281 if (contents != NULL
2282 && elf_section_data (sec)->this_hdr.contents != contents)
2283 free (contents);
2284 if (internal_relocs != NULL
2285 && elf_section_data (sec)->relocs != internal_relocs)
2286 free (internal_relocs);
2287
2288 return FALSE;
2289 }
2290
2291 /* This is a version of bfd_generic_get_relocated_section_contents
2292 which uses elf32_avr_relocate_section.
2293
2294 For avr it's essentially a cut and paste taken from the H8300 port.
2295 The author of the relaxation support patch for avr had absolutely no
2296 clue what is happening here but found out that this part of the code
2297 seems to be important. */
2298
2299 static bfd_byte *
2300 elf32_avr_get_relocated_section_contents (bfd *output_bfd,
2301 struct bfd_link_info *link_info,
2302 struct bfd_link_order *link_order,
2303 bfd_byte *data,
2304 bfd_boolean relocatable,
2305 asymbol **symbols)
2306 {
2307 Elf_Internal_Shdr *symtab_hdr;
2308 asection *input_section = link_order->u.indirect.section;
2309 bfd *input_bfd = input_section->owner;
2310 asection **sections = NULL;
2311 Elf_Internal_Rela *internal_relocs = NULL;
2312 Elf_Internal_Sym *isymbuf = NULL;
2313
2314 /* We only need to handle the case of relaxing, or of having a
2315 particular set of section contents, specially. */
2316 if (relocatable
2317 || elf_section_data (input_section)->this_hdr.contents == NULL)
2318 return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
2319 link_order, data,
2320 relocatable,
2321 symbols);
2322 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2323
2324 memcpy (data, elf_section_data (input_section)->this_hdr.contents,
2325 (size_t) input_section->size);
2326
2327 if ((input_section->flags & SEC_RELOC) != 0
2328 && input_section->reloc_count > 0)
2329 {
2330 asection **secpp;
2331 Elf_Internal_Sym *isym, *isymend;
2332 bfd_size_type amt;
2333
2334 internal_relocs = (_bfd_elf_link_read_relocs
2335 (input_bfd, input_section, NULL, NULL, FALSE));
2336 if (internal_relocs == NULL)
2337 goto error_return;
2338
2339 if (symtab_hdr->sh_info != 0)
2340 {
2341 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2342 if (isymbuf == NULL)
2343 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
2344 symtab_hdr->sh_info, 0,
2345 NULL, NULL, NULL);
2346 if (isymbuf == NULL)
2347 goto error_return;
2348 }
2349
2350 amt = symtab_hdr->sh_info;
2351 amt *= sizeof (asection *);
2352 sections = bfd_malloc (amt);
2353 if (sections == NULL && amt != 0)
2354 goto error_return;
2355
2356 isymend = isymbuf + symtab_hdr->sh_info;
2357 for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
2358 {
2359 asection *isec;
2360
2361 if (isym->st_shndx == SHN_UNDEF)
2362 isec = bfd_und_section_ptr;
2363 else if (isym->st_shndx == SHN_ABS)
2364 isec = bfd_abs_section_ptr;
2365 else if (isym->st_shndx == SHN_COMMON)
2366 isec = bfd_com_section_ptr;
2367 else
2368 isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
2369
2370 *secpp = isec;
2371 }
2372
2373 if (! elf32_avr_relocate_section (output_bfd, link_info, input_bfd,
2374 input_section, data, internal_relocs,
2375 isymbuf, sections))
2376 goto error_return;
2377
2378 if (sections != NULL)
2379 free (sections);
2380 if (isymbuf != NULL
2381 && symtab_hdr->contents != (unsigned char *) isymbuf)
2382 free (isymbuf);
2383 if (elf_section_data (input_section)->relocs != internal_relocs)
2384 free (internal_relocs);
2385 }
2386
2387 return data;
2388
2389 error_return:
2390 if (sections != NULL)
2391 free (sections);
2392 if (isymbuf != NULL
2393 && symtab_hdr->contents != (unsigned char *) isymbuf)
2394 free (isymbuf);
2395 if (internal_relocs != NULL
2396 && elf_section_data (input_section)->relocs != internal_relocs)
2397 free (internal_relocs);
2398 return NULL;
2399 }
2400
2401
2402 /* Determines the hash entry name for a particular reloc. It consists of
2403 the identifier of the symbol section and the added reloc addend and
2404 symbol offset relative to the section the symbol is attached to. */
2405
2406 static char *
2407 avr_stub_name (const asection *symbol_section,
2408 const bfd_vma symbol_offset,
2409 const Elf_Internal_Rela *rela)
2410 {
2411 char *stub_name;
2412 bfd_size_type len;
2413
2414 len = 8 + 1 + 8 + 1 + 1;
2415 stub_name = bfd_malloc (len);
2416
2417 sprintf (stub_name, "%08x+%08x",
2418 symbol_section->id & 0xffffffff,
2419 (unsigned int) ((rela->r_addend & 0xffffffff) + symbol_offset));
2420
2421 return stub_name;
2422 }
2423
2424
2425 /* Add a new stub entry to the stub hash. Not all fields of the new
2426 stub entry are initialised. */
2427
2428 static struct elf32_avr_stub_hash_entry *
2429 avr_add_stub (const char *stub_name,
2430 struct elf32_avr_link_hash_table *htab)
2431 {
2432 struct elf32_avr_stub_hash_entry *hsh;
2433
2434 /* Enter this entry into the linker stub hash table. */
2435 hsh = avr_stub_hash_lookup (&htab->bstab, stub_name, TRUE, FALSE);
2436
2437 if (hsh == NULL)
2438 {
2439 (*_bfd_error_handler) (_("%B: cannot create stub entry %s"),
2440 NULL, stub_name);
2441 return NULL;
2442 }
2443
2444 hsh->stub_offset = 0;
2445 return hsh;
2446 }
2447
2448 /* We assume that there is already space allocated for the stub section
2449 contents and that before building the stubs the section size is
2450 initialized to 0. We assume that within the stub hash table entry,
2451 the absolute position of the jmp target has been written in the
2452 target_value field. We write here the offset of the generated jmp insn
2453 relative to the trampoline section start to the stub_offset entry in
2454 the stub hash table entry. */
2455
2456 static bfd_boolean
2457 avr_build_one_stub (struct bfd_hash_entry *bh, void *in_arg)
2458 {
2459 struct elf32_avr_stub_hash_entry *hsh;
2460 struct bfd_link_info *info;
2461 struct elf32_avr_link_hash_table *htab;
2462 bfd *stub_bfd;
2463 bfd_byte *loc;
2464 bfd_vma target;
2465 bfd_vma starget;
2466
2467 /* Basic opcode */
2468 bfd_vma jmp_insn = 0x0000940c;
2469
2470 /* Massage our args to the form they really have. */
2471 hsh = avr_stub_hash_entry (bh);
2472
2473 if (!hsh->is_actually_needed)
2474 return TRUE;
2475
2476 info = (struct bfd_link_info *) in_arg;
2477
2478 htab = avr_link_hash_table (info);
2479 if (htab == NULL)
2480 return FALSE;
2481
2482 target = hsh->target_value;
2483
2484 /* Make a note of the offset within the stubs for this entry. */
2485 hsh->stub_offset = htab->stub_sec->size;
2486 loc = htab->stub_sec->contents + hsh->stub_offset;
2487
2488 stub_bfd = htab->stub_sec->owner;
2489
2490 if (debug_stubs)
2491 printf ("Building one Stub. Address: 0x%x, Offset: 0x%x\n",
2492 (unsigned int) target,
2493 (unsigned int) hsh->stub_offset);
2494
2495 /* We now have to add the information on the jump target to the bare
2496 opcode bits already set in jmp_insn. */
2497
2498 /* Check for the alignment of the address. */
2499 if (target & 1)
2500 return FALSE;
2501
2502 starget = target >> 1;
2503 jmp_insn |= ((starget & 0x10000) | ((starget << 3) & 0x1f00000)) >> 16;
2504 bfd_put_16 (stub_bfd, jmp_insn, loc);
2505 bfd_put_16 (stub_bfd, (bfd_vma) starget & 0xffff, loc + 2);
2506
2507 htab->stub_sec->size += 4;
2508
2509 /* Now add the entries in the address mapping table if there is still
2510 space left. */
2511 {
2512 unsigned int nr;
2513
2514 nr = htab->amt_entry_cnt + 1;
2515 if (nr <= htab->amt_max_entry_cnt)
2516 {
2517 htab->amt_entry_cnt = nr;
2518
2519 htab->amt_stub_offsets[nr - 1] = hsh->stub_offset;
2520 htab->amt_destination_addr[nr - 1] = target;
2521 }
2522 }
2523
2524 return TRUE;
2525 }
2526
2527 static bfd_boolean
2528 avr_mark_stub_not_to_be_necessary (struct bfd_hash_entry *bh,
2529 void *in_arg ATTRIBUTE_UNUSED)
2530 {
2531 struct elf32_avr_stub_hash_entry *hsh;
2532
2533 hsh = avr_stub_hash_entry (bh);
2534 hsh->is_actually_needed = FALSE;
2535
2536 return TRUE;
2537 }
2538
2539 static bfd_boolean
2540 avr_size_one_stub (struct bfd_hash_entry *bh, void *in_arg)
2541 {
2542 struct elf32_avr_stub_hash_entry *hsh;
2543 struct elf32_avr_link_hash_table *htab;
2544 int size;
2545
2546 /* Massage our args to the form they really have. */
2547 hsh = avr_stub_hash_entry (bh);
2548 htab = in_arg;
2549
2550 if (hsh->is_actually_needed)
2551 size = 4;
2552 else
2553 size = 0;
2554
2555 htab->stub_sec->size += size;
2556 return TRUE;
2557 }
2558
2559 void
2560 elf32_avr_setup_params (struct bfd_link_info *info,
2561 bfd *avr_stub_bfd,
2562 asection *avr_stub_section,
2563 bfd_boolean no_stubs,
2564 bfd_boolean deb_stubs,
2565 bfd_boolean deb_relax,
2566 bfd_vma pc_wrap_around,
2567 bfd_boolean call_ret_replacement)
2568 {
2569 struct elf32_avr_link_hash_table *htab = avr_link_hash_table (info);
2570
2571 if (htab == NULL)
2572 return;
2573 htab->stub_sec = avr_stub_section;
2574 htab->stub_bfd = avr_stub_bfd;
2575 htab->no_stubs = no_stubs;
2576
2577 debug_relax = deb_relax;
2578 debug_stubs = deb_stubs;
2579 avr_pc_wrap_around = pc_wrap_around;
2580 avr_replace_call_ret_sequences = call_ret_replacement;
2581 }
2582
2583
2584 /* Set up various things so that we can make a list of input sections
2585 for each output section included in the link. Returns -1 on error,
2586 0 when no stubs will be needed, and 1 on success. It also sets
2587 information on the stubs bfd and the stub section in the info
2588 struct. */
2589
2590 int
2591 elf32_avr_setup_section_lists (bfd *output_bfd,
2592 struct bfd_link_info *info)
2593 {
2594 bfd *input_bfd;
2595 unsigned int bfd_count;
2596 int top_id, top_index;
2597 asection *section;
2598 asection **input_list, **list;
2599 bfd_size_type amt;
2600 struct elf32_avr_link_hash_table *htab = avr_link_hash_table (info);
2601
2602 if (htab == NULL || htab->no_stubs)
2603 return 0;
2604
2605 /* Count the number of input BFDs and find the top input section id. */
2606 for (input_bfd = info->input_bfds, bfd_count = 0, top_id = 0;
2607 input_bfd != NULL;
2608 input_bfd = input_bfd->link_next)
2609 {
2610 bfd_count += 1;
2611 for (section = input_bfd->sections;
2612 section != NULL;
2613 section = section->next)
2614 if (top_id < section->id)
2615 top_id = section->id;
2616 }
2617
2618 htab->bfd_count = bfd_count;
2619
2620 /* We can't use output_bfd->section_count here to find the top output
2621 section index as some sections may have been removed, and
2622 strip_excluded_output_sections doesn't renumber the indices. */
2623 for (section = output_bfd->sections, top_index = 0;
2624 section != NULL;
2625 section = section->next)
2626 if (top_index < section->index)
2627 top_index = section->index;
2628
2629 htab->top_index = top_index;
2630 amt = sizeof (asection *) * (top_index + 1);
2631 input_list = bfd_malloc (amt);
2632 htab->input_list = input_list;
2633 if (input_list == NULL)
2634 return -1;
2635
2636 /* For sections we aren't interested in, mark their entries with a
2637 value we can check later. */
2638 list = input_list + top_index;
2639 do
2640 *list = bfd_abs_section_ptr;
2641 while (list-- != input_list);
2642
2643 for (section = output_bfd->sections;
2644 section != NULL;
2645 section = section->next)
2646 if ((section->flags & SEC_CODE) != 0)
2647 input_list[section->index] = NULL;
2648
2649 return 1;
2650 }
2651
2652
2653 /* Read in all local syms for all input bfds, and create hash entries
2654 for export stubs if we are building a multi-subspace shared lib.
2655 Returns -1 on error, 0 otherwise. */
2656
2657 static int
2658 get_local_syms (bfd *input_bfd, struct bfd_link_info *info)
2659 {
2660 unsigned int bfd_indx;
2661 Elf_Internal_Sym *local_syms, **all_local_syms;
2662 struct elf32_avr_link_hash_table *htab = avr_link_hash_table (info);
2663 bfd_size_type amt;
2664
2665 if (htab == NULL)
2666 return -1;
2667
2668 /* We want to read in symbol extension records only once. To do this
2669 we need to read in the local symbols in parallel and save them for
2670 later use; so hold pointers to the local symbols in an array. */
2671 amt = sizeof (Elf_Internal_Sym *) * htab->bfd_count;
2672 all_local_syms = bfd_zmalloc (amt);
2673 htab->all_local_syms = all_local_syms;
2674 if (all_local_syms == NULL)
2675 return -1;
2676
2677 /* Walk over all the input BFDs, swapping in local symbols.
2678 If we are creating a shared library, create hash entries for the
2679 export stubs. */
2680 for (bfd_indx = 0;
2681 input_bfd != NULL;
2682 input_bfd = input_bfd->link_next, bfd_indx++)
2683 {
2684 Elf_Internal_Shdr *symtab_hdr;
2685
2686 /* We'll need the symbol table in a second. */
2687 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2688 if (symtab_hdr->sh_info == 0)
2689 continue;
2690
2691 /* We need an array of the local symbols attached to the input bfd. */
2692 local_syms = (Elf_Internal_Sym *) symtab_hdr->contents;
2693 if (local_syms == NULL)
2694 {
2695 local_syms = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
2696 symtab_hdr->sh_info, 0,
2697 NULL, NULL, NULL);
2698 /* Cache them for elf_link_input_bfd. */
2699 symtab_hdr->contents = (unsigned char *) local_syms;
2700 }
2701 if (local_syms == NULL)
2702 return -1;
2703
2704 all_local_syms[bfd_indx] = local_syms;
2705 }
2706
2707 return 0;
2708 }
2709
2710 #define ADD_DUMMY_STUBS_FOR_DEBUGGING 0
2711
2712 bfd_boolean
2713 elf32_avr_size_stubs (bfd *output_bfd,
2714 struct bfd_link_info *info,
2715 bfd_boolean is_prealloc_run)
2716 {
2717 struct elf32_avr_link_hash_table *htab;
2718 int stub_changed = 0;
2719
2720 htab = avr_link_hash_table (info);
2721 if (htab == NULL)
2722 return FALSE;
2723
2724 /* At this point we initialize htab->vector_base
2725 To the start of the text output section. */
2726 htab->vector_base = htab->stub_sec->output_section->vma;
2727
2728 if (get_local_syms (info->input_bfds, info))
2729 {
2730 if (htab->all_local_syms)
2731 goto error_ret_free_local;
2732 return FALSE;
2733 }
2734
2735 if (ADD_DUMMY_STUBS_FOR_DEBUGGING)
2736 {
2737 struct elf32_avr_stub_hash_entry *test;
2738
2739 test = avr_add_stub ("Hugo",htab);
2740 test->target_value = 0x123456;
2741 test->stub_offset = 13;
2742
2743 test = avr_add_stub ("Hugo2",htab);
2744 test->target_value = 0x84210;
2745 test->stub_offset = 14;
2746 }
2747
2748 while (1)
2749 {
2750 bfd *input_bfd;
2751 unsigned int bfd_indx;
2752
2753 /* We will have to re-generate the stub hash table each time anything
2754 in memory has changed. */
2755
2756 bfd_hash_traverse (&htab->bstab, avr_mark_stub_not_to_be_necessary, htab);
2757 for (input_bfd = info->input_bfds, bfd_indx = 0;
2758 input_bfd != NULL;
2759 input_bfd = input_bfd->link_next, bfd_indx++)
2760 {
2761 Elf_Internal_Shdr *symtab_hdr;
2762 asection *section;
2763 Elf_Internal_Sym *local_syms;
2764
2765 /* We'll need the symbol table in a second. */
2766 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2767 if (symtab_hdr->sh_info == 0)
2768 continue;
2769
2770 local_syms = htab->all_local_syms[bfd_indx];
2771
2772 /* Walk over each section attached to the input bfd. */
2773 for (section = input_bfd->sections;
2774 section != NULL;
2775 section = section->next)
2776 {
2777 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
2778
2779 /* If there aren't any relocs, then there's nothing more
2780 to do. */
2781 if ((section->flags & SEC_RELOC) == 0
2782 || section->reloc_count == 0)
2783 continue;
2784
2785 /* If this section is a link-once section that will be
2786 discarded, then don't create any stubs. */
2787 if (section->output_section == NULL
2788 || section->output_section->owner != output_bfd)
2789 continue;
2790
2791 /* Get the relocs. */
2792 internal_relocs
2793 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
2794 info->keep_memory);
2795 if (internal_relocs == NULL)
2796 goto error_ret_free_local;
2797
2798 /* Now examine each relocation. */
2799 irela = internal_relocs;
2800 irelaend = irela + section->reloc_count;
2801 for (; irela < irelaend; irela++)
2802 {
2803 unsigned int r_type, r_indx;
2804 struct elf32_avr_stub_hash_entry *hsh;
2805 asection *sym_sec;
2806 bfd_vma sym_value;
2807 bfd_vma destination;
2808 struct elf_link_hash_entry *hh;
2809 char *stub_name;
2810
2811 r_type = ELF32_R_TYPE (irela->r_info);
2812 r_indx = ELF32_R_SYM (irela->r_info);
2813
2814 /* Only look for 16 bit GS relocs. No other reloc will need a
2815 stub. */
2816 if (!((r_type == R_AVR_16_PM)
2817 || (r_type == R_AVR_LO8_LDI_GS)
2818 || (r_type == R_AVR_HI8_LDI_GS)))
2819 continue;
2820
2821 /* Now determine the call target, its name, value,
2822 section. */
2823 sym_sec = NULL;
2824 sym_value = 0;
2825 destination = 0;
2826 hh = NULL;
2827 if (r_indx < symtab_hdr->sh_info)
2828 {
2829 /* It's a local symbol. */
2830 Elf_Internal_Sym *sym;
2831 Elf_Internal_Shdr *hdr;
2832 unsigned int shndx;
2833
2834 sym = local_syms + r_indx;
2835 if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
2836 sym_value = sym->st_value;
2837 shndx = sym->st_shndx;
2838 if (shndx < elf_numsections (input_bfd))
2839 {
2840 hdr = elf_elfsections (input_bfd)[shndx];
2841 sym_sec = hdr->bfd_section;
2842 destination = (sym_value + irela->r_addend
2843 + sym_sec->output_offset
2844 + sym_sec->output_section->vma);
2845 }
2846 }
2847 else
2848 {
2849 /* It's an external symbol. */
2850 int e_indx;
2851
2852 e_indx = r_indx - symtab_hdr->sh_info;
2853 hh = elf_sym_hashes (input_bfd)[e_indx];
2854
2855 while (hh->root.type == bfd_link_hash_indirect
2856 || hh->root.type == bfd_link_hash_warning)
2857 hh = (struct elf_link_hash_entry *)
2858 (hh->root.u.i.link);
2859
2860 if (hh->root.type == bfd_link_hash_defined
2861 || hh->root.type == bfd_link_hash_defweak)
2862 {
2863 sym_sec = hh->root.u.def.section;
2864 sym_value = hh->root.u.def.value;
2865 if (sym_sec->output_section != NULL)
2866 destination = (sym_value + irela->r_addend
2867 + sym_sec->output_offset
2868 + sym_sec->output_section->vma);
2869 }
2870 else if (hh->root.type == bfd_link_hash_undefweak)
2871 {
2872 if (! info->shared)
2873 continue;
2874 }
2875 else if (hh->root.type == bfd_link_hash_undefined)
2876 {
2877 if (! (info->unresolved_syms_in_objects == RM_IGNORE
2878 && (ELF_ST_VISIBILITY (hh->other)
2879 == STV_DEFAULT)))
2880 continue;
2881 }
2882 else
2883 {
2884 bfd_set_error (bfd_error_bad_value);
2885
2886 error_ret_free_internal:
2887 if (elf_section_data (section)->relocs == NULL)
2888 free (internal_relocs);
2889 goto error_ret_free_local;
2890 }
2891 }
2892
2893 if (! avr_stub_is_required_for_16_bit_reloc
2894 (destination - htab->vector_base))
2895 {
2896 if (!is_prealloc_run)
2897 /* We are having a reloc that does't need a stub. */
2898 continue;
2899
2900 /* We don't right now know if a stub will be needed.
2901 Let's rather be on the safe side. */
2902 }
2903
2904 /* Get the name of this stub. */
2905 stub_name = avr_stub_name (sym_sec, sym_value, irela);
2906
2907 if (!stub_name)
2908 goto error_ret_free_internal;
2909
2910
2911 hsh = avr_stub_hash_lookup (&htab->bstab,
2912 stub_name,
2913 FALSE, FALSE);
2914 if (hsh != NULL)
2915 {
2916 /* The proper stub has already been created. Mark it
2917 to be used and write the possibly changed destination
2918 value. */
2919 hsh->is_actually_needed = TRUE;
2920 hsh->target_value = destination;
2921 free (stub_name);
2922 continue;
2923 }
2924
2925 hsh = avr_add_stub (stub_name, htab);
2926 if (hsh == NULL)
2927 {
2928 free (stub_name);
2929 goto error_ret_free_internal;
2930 }
2931
2932 hsh->is_actually_needed = TRUE;
2933 hsh->target_value = destination;
2934
2935 if (debug_stubs)
2936 printf ("Adding stub with destination 0x%x to the"
2937 " hash table.\n", (unsigned int) destination);
2938 if (debug_stubs)
2939 printf ("(Pre-Alloc run: %i)\n", is_prealloc_run);
2940
2941 stub_changed = TRUE;
2942 }
2943
2944 /* We're done with the internal relocs, free them. */
2945 if (elf_section_data (section)->relocs == NULL)
2946 free (internal_relocs);
2947 }
2948 }
2949
2950 /* Re-Calculate the number of needed stubs. */
2951 htab->stub_sec->size = 0;
2952 bfd_hash_traverse (&htab->bstab, avr_size_one_stub, htab);
2953
2954 if (!stub_changed)
2955 break;
2956
2957 stub_changed = FALSE;
2958 }
2959
2960 free (htab->all_local_syms);
2961 return TRUE;
2962
2963 error_ret_free_local:
2964 free (htab->all_local_syms);
2965 return FALSE;
2966 }
2967
2968
2969 /* Build all the stubs associated with the current output file. The
2970 stubs are kept in a hash table attached to the main linker hash
2971 table. We also set up the .plt entries for statically linked PIC
2972 functions here. This function is called via hppaelf_finish in the
2973 linker. */
2974
2975 bfd_boolean
2976 elf32_avr_build_stubs (struct bfd_link_info *info)
2977 {
2978 asection *stub_sec;
2979 struct bfd_hash_table *table;
2980 struct elf32_avr_link_hash_table *htab;
2981 bfd_size_type total_size = 0;
2982
2983 htab = avr_link_hash_table (info);
2984 if (htab == NULL)
2985 return FALSE;
2986
2987 /* In case that there were several stub sections: */
2988 for (stub_sec = htab->stub_bfd->sections;
2989 stub_sec != NULL;
2990 stub_sec = stub_sec->next)
2991 {
2992 bfd_size_type size;
2993
2994 /* Allocate memory to hold the linker stubs. */
2995 size = stub_sec->size;
2996 total_size += size;
2997
2998 stub_sec->contents = bfd_zalloc (htab->stub_bfd, size);
2999 if (stub_sec->contents == NULL && size != 0)
3000 return FALSE;
3001 stub_sec->size = 0;
3002 }
3003
3004 /* Allocate memory for the adress mapping table. */
3005 htab->amt_entry_cnt = 0;
3006 htab->amt_max_entry_cnt = total_size / 4;
3007 htab->amt_stub_offsets = bfd_malloc (sizeof (bfd_vma)
3008 * htab->amt_max_entry_cnt);
3009 htab->amt_destination_addr = bfd_malloc (sizeof (bfd_vma)
3010 * htab->amt_max_entry_cnt );
3011
3012 if (debug_stubs)
3013 printf ("Allocating %i entries in the AMT\n", htab->amt_max_entry_cnt);
3014
3015 /* Build the stubs as directed by the stub hash table. */
3016 table = &htab->bstab;
3017 bfd_hash_traverse (table, avr_build_one_stub, info);
3018
3019 if (debug_stubs)
3020 printf ("Final Stub section Size: %i\n", (int) htab->stub_sec->size);
3021
3022 return TRUE;
3023 }
3024
3025 #define ELF_ARCH bfd_arch_avr
3026 #define ELF_TARGET_ID AVR_ELF_DATA
3027 #define ELF_MACHINE_CODE EM_AVR
3028 #define ELF_MACHINE_ALT1 EM_AVR_OLD
3029 #define ELF_MAXPAGESIZE 1
3030
3031 #define TARGET_LITTLE_SYM bfd_elf32_avr_vec
3032 #define TARGET_LITTLE_NAME "elf32-avr"
3033
3034 #define bfd_elf32_bfd_link_hash_table_create elf32_avr_link_hash_table_create
3035 #define bfd_elf32_bfd_link_hash_table_free elf32_avr_link_hash_table_free
3036
3037 #define elf_info_to_howto avr_info_to_howto_rela
3038 #define elf_info_to_howto_rel NULL
3039 #define elf_backend_relocate_section elf32_avr_relocate_section
3040 #define elf_backend_can_gc_sections 1
3041 #define elf_backend_rela_normal 1
3042 #define elf_backend_final_write_processing \
3043 bfd_elf_avr_final_write_processing
3044 #define elf_backend_object_p elf32_avr_object_p
3045
3046 #define bfd_elf32_bfd_relax_section elf32_avr_relax_section
3047 #define bfd_elf32_bfd_get_relocated_section_contents \
3048 elf32_avr_get_relocated_section_contents
3049
3050 #include "elf32-target.h"
git-cvsimport of binutils cvsroot