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