projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Update formatting to ISO-C90
[deliverable/binutils-gdb.git] / bfd / elf32-avr.c
1 /* AVR-specific support for 32-bit ELF
2 Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2006
3 Free Software Foundation, Inc.
4 Contributed by Denis Chertykov <denisc@overta.ru>
5
6 This file is part of BFD, the Binary File Descriptor library.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor,
21 Boston, MA 02110-1301, USA. */
22
23 #include "bfd.h"
24 #include "sysdep.h"
25 #include "libbfd.h"
26 #include "elf-bfd.h"
27 #include "elf/avr.h"
28
29 static reloc_howto_type elf_avr_howto_table[] =
30 {
31 HOWTO (R_AVR_NONE, /* type */
32 0, /* rightshift */
33 2, /* size (0 = byte, 1 = short, 2 = long) */
34 32, /* bitsize */
35 FALSE, /* pc_relative */
36 0, /* bitpos */
37 complain_overflow_bitfield, /* complain_on_overflow */
38 bfd_elf_generic_reloc, /* special_function */
39 "R_AVR_NONE", /* name */
40 FALSE, /* partial_inplace */
41 0, /* src_mask */
42 0, /* dst_mask */
43 FALSE), /* pcrel_offset */
44
45 HOWTO (R_AVR_32, /* type */
46 0, /* rightshift */
47 2, /* size (0 = byte, 1 = short, 2 = long) */
48 32, /* bitsize */
49 FALSE, /* pc_relative */
50 0, /* bitpos */
51 complain_overflow_bitfield, /* complain_on_overflow */
52 bfd_elf_generic_reloc, /* special_function */
53 "R_AVR_32", /* name */
54 FALSE, /* partial_inplace */
55 0xffffffff, /* src_mask */
56 0xffffffff, /* dst_mask */
57 FALSE), /* pcrel_offset */
58
59 /* A 7 bit PC relative relocation. */
60 HOWTO (R_AVR_7_PCREL, /* type */
61 1, /* rightshift */
62 1, /* size (0 = byte, 1 = short, 2 = long) */
63 7, /* bitsize */
64 TRUE, /* pc_relative */
65 3, /* bitpos */
66 complain_overflow_bitfield, /* complain_on_overflow */
67 bfd_elf_generic_reloc, /* special_function */
68 "R_AVR_7_PCREL", /* name */
69 FALSE, /* partial_inplace */
70 0xffff, /* src_mask */
71 0xffff, /* dst_mask */
72 TRUE), /* pcrel_offset */
73
74 /* A 13 bit PC relative relocation. */
75 HOWTO (R_AVR_13_PCREL, /* type */
76 1, /* rightshift */
77 1, /* size (0 = byte, 1 = short, 2 = long) */
78 13, /* bitsize */
79 TRUE, /* pc_relative */
80 0, /* bitpos */
81 complain_overflow_bitfield, /* complain_on_overflow */
82 bfd_elf_generic_reloc, /* special_function */
83 "R_AVR_13_PCREL", /* name */
84 FALSE, /* partial_inplace */
85 0xfff, /* src_mask */
86 0xfff, /* dst_mask */
87 TRUE), /* pcrel_offset */
88
89 /* A 16 bit absolute relocation. */
90 HOWTO (R_AVR_16, /* type */
91 0, /* rightshift */
92 1, /* size (0 = byte, 1 = short, 2 = long) */
93 16, /* bitsize */
94 FALSE, /* pc_relative */
95 0, /* bitpos */
96 complain_overflow_dont, /* complain_on_overflow */
97 bfd_elf_generic_reloc, /* special_function */
98 "R_AVR_16", /* name */
99 FALSE, /* partial_inplace */
100 0xffff, /* src_mask */
101 0xffff, /* dst_mask */
102 FALSE), /* pcrel_offset */
103
104 /* A 16 bit absolute relocation for command address. */
105 HOWTO (R_AVR_16_PM, /* type */
106 1, /* rightshift */
107 1, /* size (0 = byte, 1 = short, 2 = long) */
108 16, /* bitsize */
109 FALSE, /* pc_relative */
110 0, /* bitpos */
111 complain_overflow_bitfield, /* complain_on_overflow */
112 bfd_elf_generic_reloc, /* special_function */
113 "R_AVR_16_PM", /* name */
114 FALSE, /* partial_inplace */
115 0xffff, /* src_mask */
116 0xffff, /* dst_mask */
117 FALSE), /* pcrel_offset */
118 /* A low 8 bit absolute relocation of 16 bit address.
119 For LDI command. */
120 HOWTO (R_AVR_LO8_LDI, /* type */
121 0, /* rightshift */
122 1, /* size (0 = byte, 1 = short, 2 = long) */
123 8, /* bitsize */
124 FALSE, /* pc_relative */
125 0, /* bitpos */
126 complain_overflow_dont, /* complain_on_overflow */
127 bfd_elf_generic_reloc, /* special_function */
128 "R_AVR_LO8_LDI", /* name */
129 FALSE, /* partial_inplace */
130 0xffff, /* src_mask */
131 0xffff, /* dst_mask */
132 FALSE), /* pcrel_offset */
133 /* A high 8 bit absolute relocation of 16 bit address.
134 For LDI command. */
135 HOWTO (R_AVR_HI8_LDI, /* type */
136 8, /* rightshift */
137 1, /* size (0 = byte, 1 = short, 2 = long) */
138 8, /* bitsize */
139 FALSE, /* pc_relative */
140 0, /* bitpos */
141 complain_overflow_dont, /* complain_on_overflow */
142 bfd_elf_generic_reloc, /* special_function */
143 "R_AVR_HI8_LDI", /* name */
144 FALSE, /* partial_inplace */
145 0xffff, /* src_mask */
146 0xffff, /* dst_mask */
147 FALSE), /* pcrel_offset */
148 /* A high 6 bit absolute relocation of 22 bit address.
149 For LDI command. As well second most significant 8 bit value of
150 a 32 bit link-time constant. */
151 HOWTO (R_AVR_HH8_LDI, /* type */
152 16, /* rightshift */
153 1, /* size (0 = byte, 1 = short, 2 = long) */
154 8, /* bitsize */
155 FALSE, /* pc_relative */
156 0, /* bitpos */
157 complain_overflow_dont, /* complain_on_overflow */
158 bfd_elf_generic_reloc, /* special_function */
159 "R_AVR_HH8_LDI", /* name */
160 FALSE, /* partial_inplace */
161 0xffff, /* src_mask */
162 0xffff, /* dst_mask */
163 FALSE), /* pcrel_offset */
164 /* A negative low 8 bit absolute relocation of 16 bit address.
165 For LDI command. */
166 HOWTO (R_AVR_LO8_LDI_NEG, /* type */
167 0, /* rightshift */
168 1, /* size (0 = byte, 1 = short, 2 = long) */
169 8, /* bitsize */
170 FALSE, /* pc_relative */
171 0, /* bitpos */
172 complain_overflow_dont, /* complain_on_overflow */
173 bfd_elf_generic_reloc, /* special_function */
174 "R_AVR_LO8_LDI_NEG", /* name */
175 FALSE, /* partial_inplace */
176 0xffff, /* src_mask */
177 0xffff, /* dst_mask */
178 FALSE), /* pcrel_offset */
179 /* A negative high 8 bit absolute relocation of 16 bit address.
180 For LDI command. */
181 HOWTO (R_AVR_HI8_LDI_NEG, /* type */
182 8, /* rightshift */
183 1, /* size (0 = byte, 1 = short, 2 = long) */
184 8, /* bitsize */
185 FALSE, /* pc_relative */
186 0, /* bitpos */
187 complain_overflow_dont, /* complain_on_overflow */
188 bfd_elf_generic_reloc, /* special_function */
189 "R_AVR_HI8_LDI_NEG", /* name */
190 FALSE, /* partial_inplace */
191 0xffff, /* src_mask */
192 0xffff, /* dst_mask */
193 FALSE), /* pcrel_offset */
194 /* A negative high 6 bit absolute relocation of 22 bit address.
195 For LDI command. */
196 HOWTO (R_AVR_HH8_LDI_NEG, /* type */
197 16, /* rightshift */
198 1, /* size (0 = byte, 1 = short, 2 = long) */
199 8, /* bitsize */
200 FALSE, /* pc_relative */
201 0, /* bitpos */
202 complain_overflow_dont, /* complain_on_overflow */
203 bfd_elf_generic_reloc, /* special_function */
204 "R_AVR_HH8_LDI_NEG", /* name */
205 FALSE, /* partial_inplace */
206 0xffff, /* src_mask */
207 0xffff, /* dst_mask */
208 FALSE), /* pcrel_offset */
209 /* A low 8 bit absolute relocation of 24 bit program memory address.
210 For LDI command. */
211 HOWTO (R_AVR_LO8_LDI_PM, /* type */
212 1, /* rightshift */
213 1, /* size (0 = byte, 1 = short, 2 = long) */
214 8, /* bitsize */
215 FALSE, /* pc_relative */
216 0, /* bitpos */
217 complain_overflow_dont, /* complain_on_overflow */
218 bfd_elf_generic_reloc, /* special_function */
219 "R_AVR_LO8_LDI_PM", /* name */
220 FALSE, /* partial_inplace */
221 0xffff, /* src_mask */
222 0xffff, /* dst_mask */
223 FALSE), /* pcrel_offset */
224 /* A high 8 bit absolute relocation of 16 bit program memory address.
225 For LDI command. */
226 HOWTO (R_AVR_HI8_LDI_PM, /* type */
227 9, /* rightshift */
228 1, /* size (0 = byte, 1 = short, 2 = long) */
229 8, /* bitsize */
230 FALSE, /* pc_relative */
231 0, /* bitpos */
232 complain_overflow_dont, /* complain_on_overflow */
233 bfd_elf_generic_reloc, /* special_function */
234 "R_AVR_HI8_LDI_PM", /* name */
235 FALSE, /* partial_inplace */
236 0xffff, /* src_mask */
237 0xffff, /* dst_mask */
238 FALSE), /* pcrel_offset */
239 /* A high 8 bit absolute relocation of 24 bit program memory address.
240 For LDI command. */
241 HOWTO (R_AVR_HH8_LDI_PM, /* type */
242 17, /* rightshift */
243 1, /* size (0 = byte, 1 = short, 2 = long) */
244 8, /* bitsize */
245 FALSE, /* pc_relative */
246 0, /* bitpos */
247 complain_overflow_dont, /* complain_on_overflow */
248 bfd_elf_generic_reloc, /* special_function */
249 "R_AVR_HH8_LDI_PM", /* name */
250 FALSE, /* partial_inplace */
251 0xffff, /* src_mask */
252 0xffff, /* dst_mask */
253 FALSE), /* pcrel_offset */
254 /* A low 8 bit absolute relocation of a negative 24 bit
255 program memory address. For LDI command. */
256 HOWTO (R_AVR_LO8_LDI_PM_NEG, /* type */
257 1, /* rightshift */
258 1, /* size (0 = byte, 1 = short, 2 = long) */
259 8, /* bitsize */
260 FALSE, /* pc_relative */
261 0, /* bitpos */
262 complain_overflow_dont, /* complain_on_overflow */
263 bfd_elf_generic_reloc, /* special_function */
264 "R_AVR_LO8_LDI_PM_NEG", /* name */
265 FALSE, /* partial_inplace */
266 0xffff, /* src_mask */
267 0xffff, /* dst_mask */
268 FALSE), /* pcrel_offset */
269 /* A high 8 bit absolute relocation of a negative 16 bit
270 program memory address. For LDI command. */
271 HOWTO (R_AVR_HI8_LDI_PM_NEG, /* type */
272 9, /* rightshift */
273 1, /* size (0 = byte, 1 = short, 2 = long) */
274 8, /* bitsize */
275 FALSE, /* pc_relative */
276 0, /* bitpos */
277 complain_overflow_dont, /* complain_on_overflow */
278 bfd_elf_generic_reloc, /* special_function */
279 "R_AVR_HI8_LDI_PM_NEG", /* name */
280 FALSE, /* partial_inplace */
281 0xffff, /* src_mask */
282 0xffff, /* dst_mask */
283 FALSE), /* pcrel_offset */
284 /* A high 8 bit absolute relocation of a negative 24 bit
285 program memory address. For LDI command. */
286 HOWTO (R_AVR_HH8_LDI_PM_NEG, /* type */
287 17, /* rightshift */
288 1, /* size (0 = byte, 1 = short, 2 = long) */
289 8, /* bitsize */
290 FALSE, /* pc_relative */
291 0, /* bitpos */
292 complain_overflow_dont, /* complain_on_overflow */
293 bfd_elf_generic_reloc, /* special_function */
294 "R_AVR_HH8_LDI_PM_NEG", /* name */
295 FALSE, /* partial_inplace */
296 0xffff, /* src_mask */
297 0xffff, /* dst_mask */
298 FALSE), /* pcrel_offset */
299 /* Relocation for CALL command in ATmega. */
300 HOWTO (R_AVR_CALL, /* type */
301 1, /* rightshift */
302 2, /* size (0 = byte, 1 = short, 2 = long) */
303 23, /* 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_CALL", /* name */
309 FALSE, /* partial_inplace */
310 0xffffffff, /* src_mask */
311 0xffffffff, /* dst_mask */
312 FALSE), /* pcrel_offset */
313 /* A 16 bit absolute relocation of 16 bit address.
314 For LDI command. */
315 HOWTO (R_AVR_LDI, /* type */
316 0, /* rightshift */
317 1, /* size (0 = byte, 1 = short, 2 = long) */
318 16, /* 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_LDI", /* name */
324 FALSE, /* partial_inplace */
325 0xffff, /* src_mask */
326 0xffff, /* dst_mask */
327 FALSE), /* pcrel_offset */
328 /* A 6 bit absolute relocation of 6 bit offset.
329 For ldd/sdd command. */
330 HOWTO (R_AVR_6, /* type */
331 0, /* rightshift */
332 0, /* size (0 = byte, 1 = short, 2 = long) */
333 6, /* 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_6", /* name */
339 FALSE, /* partial_inplace */
340 0xffff, /* src_mask */
341 0xffff, /* dst_mask */
342 FALSE), /* pcrel_offset */
343 /* A 6 bit absolute relocation of 6 bit offset.
344 For sbiw/adiw command. */
345 HOWTO (R_AVR_6_ADIW, /* type */
346 0, /* rightshift */
347 0, /* size (0 = byte, 1 = short, 2 = long) */
348 6, /* 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_6_ADIW", /* name */
354 FALSE, /* partial_inplace */
355 0xffff, /* src_mask */
356 0xffff, /* dst_mask */
357 FALSE), /* pcrel_offset */
358 /* Most significant 8 bit value of a 32 bit link-time constant. */
359 HOWTO (R_AVR_MS8_LDI, /* type */
360 24, /* rightshift */
361 1, /* size (0 = byte, 1 = short, 2 = long) */
362 8, /* bitsize */
363 FALSE, /* pc_relative */
364 0, /* bitpos */
365 complain_overflow_dont, /* complain_on_overflow */
366 bfd_elf_generic_reloc, /* special_function */
367 "R_AVR_MS8_LDI", /* name */
368 FALSE, /* partial_inplace */
369 0xffff, /* src_mask */
370 0xffff, /* dst_mask */
371 FALSE), /* pcrel_offset */
372 /* Negative most significant 8 bit value of a 32 bit link-time constant. */
373 HOWTO (R_AVR_MS8_LDI_NEG, /* type */
374 24, /* rightshift */
375 1, /* size (0 = byte, 1 = short, 2 = long) */
376 8, /* bitsize */
377 FALSE, /* pc_relative */
378 0, /* bitpos */
379 complain_overflow_dont, /* complain_on_overflow */
380 bfd_elf_generic_reloc, /* special_function */
381 "R_AVR_MS8_LDI_NEG", /* name */
382 FALSE, /* partial_inplace */
383 0xffff, /* src_mask */
384 0xffff, /* dst_mask */
385 FALSE) /* pcrel_offset */
386 };
387
388 /* Map BFD reloc types to AVR ELF reloc types. */
389
390 struct avr_reloc_map
391 {
392 bfd_reloc_code_real_type bfd_reloc_val;
393 unsigned int elf_reloc_val;
394 };
395
396 static const struct avr_reloc_map avr_reloc_map[] =
397 {
398 { BFD_RELOC_NONE, R_AVR_NONE },
399 { BFD_RELOC_32, R_AVR_32 },
400 { BFD_RELOC_AVR_7_PCREL, R_AVR_7_PCREL },
401 { BFD_RELOC_AVR_13_PCREL, R_AVR_13_PCREL },
402 { BFD_RELOC_16, R_AVR_16 },
403 { BFD_RELOC_AVR_16_PM, R_AVR_16_PM },
404 { BFD_RELOC_AVR_LO8_LDI, R_AVR_LO8_LDI},
405 { BFD_RELOC_AVR_HI8_LDI, R_AVR_HI8_LDI },
406 { BFD_RELOC_AVR_HH8_LDI, R_AVR_HH8_LDI },
407 { BFD_RELOC_AVR_MS8_LDI, R_AVR_MS8_LDI },
408 { BFD_RELOC_AVR_LO8_LDI_NEG, R_AVR_LO8_LDI_NEG },
409 { BFD_RELOC_AVR_HI8_LDI_NEG, R_AVR_HI8_LDI_NEG },
410 { BFD_RELOC_AVR_HH8_LDI_NEG, R_AVR_HH8_LDI_NEG },
411 { BFD_RELOC_AVR_MS8_LDI_NEG, R_AVR_MS8_LDI_NEG },
412 { BFD_RELOC_AVR_LO8_LDI_PM, R_AVR_LO8_LDI_PM },
413 { BFD_RELOC_AVR_HI8_LDI_PM, R_AVR_HI8_LDI_PM },
414 { BFD_RELOC_AVR_HH8_LDI_PM, R_AVR_HH8_LDI_PM },
415 { BFD_RELOC_AVR_LO8_LDI_PM_NEG, R_AVR_LO8_LDI_PM_NEG },
416 { BFD_RELOC_AVR_HI8_LDI_PM_NEG, R_AVR_HI8_LDI_PM_NEG },
417 { BFD_RELOC_AVR_HH8_LDI_PM_NEG, R_AVR_HH8_LDI_PM_NEG },
418 { BFD_RELOC_AVR_CALL, R_AVR_CALL },
419 { BFD_RELOC_AVR_LDI, R_AVR_LDI },
420 { BFD_RELOC_AVR_6, R_AVR_6 },
421 { BFD_RELOC_AVR_6_ADIW, R_AVR_6_ADIW }
422 };
423
424 /* Meant to be filled one day with the wrap around address for the
425 specific device. I.e. should get the value 0x4000 for 16k devices,
426 0x8000 for 32k devices and so on.
427
428 We initialize it here with a value of 0x1000000 resulting in
429 that we will never suggest a wrap-around jump during relaxation.
430 The logic of the source code later on assumes that in
431 avr_pc_wrap_around one single bit is set. */
432
433 unsigned int avr_pc_wrap_around = 0x10000000;
434
435 /* Calculates the effective distance of a pc relative jump/call. */
436 static int
437 avr_relative_distance_considering_wrap_around (unsigned int distance)
438 {
439 unsigned int wrap_around_mask = avr_pc_wrap_around - 1;
440 int dist_with_wrap_around = distance & wrap_around_mask;
441
442 if (dist_with_wrap_around > ((int) (avr_pc_wrap_around >> 1)))
443 dist_with_wrap_around -= avr_pc_wrap_around;
444
445 return dist_with_wrap_around;
446 }
447
448
449 static reloc_howto_type *
450 bfd_elf32_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
451 bfd_reloc_code_real_type code)
452 {
453 unsigned int i;
454
455 for (i = 0;
456 i < sizeof (avr_reloc_map) / sizeof (struct avr_reloc_map);
457 i++)
458 {
459 if (avr_reloc_map[i].bfd_reloc_val == code)
460 return &elf_avr_howto_table[avr_reloc_map[i].elf_reloc_val];
461 }
462
463 return NULL;
464 }
465
466 /* Set the howto pointer for an AVR ELF reloc. */
467
468 static void
469 avr_info_to_howto_rela (bfd *abfd ATTRIBUTE_UNUSED,
470 arelent *cache_ptr,
471 Elf_Internal_Rela *dst)
472 {
473 unsigned int r_type;
474
475 r_type = ELF32_R_TYPE (dst->r_info);
476 BFD_ASSERT (r_type < (unsigned int) R_AVR_max);
477 cache_ptr->howto = &elf_avr_howto_table[r_type];
478 }
479
480 static asection *
481 elf32_avr_gc_mark_hook (asection *sec,
482 struct bfd_link_info *info ATTRIBUTE_UNUSED,
483 Elf_Internal_Rela *rel,
484 struct elf_link_hash_entry *h,
485 Elf_Internal_Sym *sym)
486 {
487 if (h != NULL)
488 {
489 switch (ELF32_R_TYPE (rel->r_info))
490 {
491 default:
492 switch (h->root.type)
493 {
494 case bfd_link_hash_defined:
495 case bfd_link_hash_defweak:
496 return h->root.u.def.section;
497
498 case bfd_link_hash_common:
499 return h->root.u.c.p->section;
500
501 default:
502 break;
503 }
504 }
505 }
506 else
507 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
508
509 return NULL;
510 }
511
512 static bfd_boolean
513 elf32_avr_gc_sweep_hook (bfd *abfd ATTRIBUTE_UNUSED,
514 struct bfd_link_info *info ATTRIBUTE_UNUSED,
515 asection *sec ATTRIBUTE_UNUSED,
516 const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED)
517 {
518 /* We don't use got and plt entries for avr. */
519 return TRUE;
520 }
521
522 /* Look through the relocs for a section during the first phase.
523 Since we don't do .gots or .plts, we just need to consider the
524 virtual table relocs for gc. */
525
526 static bfd_boolean
527 elf32_avr_check_relocs (bfd *abfd,
528 struct bfd_link_info *info,
529 asection *sec,
530 const Elf_Internal_Rela *relocs)
531 {
532 Elf_Internal_Shdr *symtab_hdr;
533 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
534 const Elf_Internal_Rela *rel;
535 const Elf_Internal_Rela *rel_end;
536
537 if (info->relocatable)
538 return TRUE;
539
540 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
541 sym_hashes = elf_sym_hashes (abfd);
542 sym_hashes_end = sym_hashes + symtab_hdr->sh_size / sizeof (Elf32_External_Sym);
543 if (!elf_bad_symtab (abfd))
544 sym_hashes_end -= symtab_hdr->sh_info;
545
546 rel_end = relocs + sec->reloc_count;
547 for (rel = relocs; rel < rel_end; rel++)
548 {
549 struct elf_link_hash_entry *h;
550 unsigned long r_symndx;
551
552 r_symndx = ELF32_R_SYM (rel->r_info);
553 if (r_symndx < symtab_hdr->sh_info)
554 h = NULL;
555 else
556 {
557 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
558 while (h->root.type == bfd_link_hash_indirect
559 || h->root.type == bfd_link_hash_warning)
560 h = (struct elf_link_hash_entry *) h->root.u.i.link;
561 }
562 }
563
564 return TRUE;
565 }
566
567 /* Perform a single relocation. By default we use the standard BFD
568 routines, but a few relocs, we have to do them ourselves. */
569
570 static bfd_reloc_status_type
571 avr_final_link_relocate (reloc_howto_type * howto,
572 bfd * input_bfd,
573 asection * input_section,
574 bfd_byte * contents,
575 Elf_Internal_Rela * rel,
576 bfd_vma relocation)
577 {
578 bfd_reloc_status_type r = bfd_reloc_ok;
579 bfd_vma x;
580 bfd_signed_vma srel;
581
582 switch (howto->type)
583 {
584 case R_AVR_7_PCREL:
585 contents += rel->r_offset;
586 srel = (bfd_signed_vma) relocation;
587 srel += rel->r_addend;
588 srel -= rel->r_offset;
589 srel -= 2; /* Branch instructions add 2 to the PC... */
590 srel -= (input_section->output_section->vma +
591 input_section->output_offset);
592
593 if (srel & 1)
594 return bfd_reloc_outofrange;
595 if (srel > ((1 << 7) - 1) || (srel < - (1 << 7)))
596 return bfd_reloc_overflow;
597 x = bfd_get_16 (input_bfd, contents);
598 x = (x & 0xfc07) | (((srel >> 1) << 3) & 0x3f8);
599 bfd_put_16 (input_bfd, x, contents);
600 break;
601
602 case R_AVR_13_PCREL:
603 contents += rel->r_offset;
604 srel = (bfd_signed_vma) relocation;
605 srel += rel->r_addend;
606 srel -= rel->r_offset;
607 srel -= 2; /* Branch instructions add 2 to the PC... */
608 srel -= (input_section->output_section->vma +
609 input_section->output_offset);
610
611 if (srel & 1)
612 return bfd_reloc_outofrange;
613
614 srel = avr_relative_distance_considering_wrap_around (srel);
615
616 /* AVR addresses commands as words. */
617 srel >>= 1;
618
619 /* Check for overflow. */
620 if (srel < -2048 || srel > 2047)
621 {
622 /* Relative distance is too large. */
623
624 /* Always apply WRAPAROUND for avr2 and avr4. */
625 switch (bfd_get_mach (input_bfd))
626 {
627 case bfd_mach_avr2:
628 case bfd_mach_avr4:
629 break;
630
631 default:
632 return bfd_reloc_overflow;
633 }
634 }
635
636 x = bfd_get_16 (input_bfd, contents);
637 x = (x & 0xf000) | (srel & 0xfff);
638 bfd_put_16 (input_bfd, x, contents);
639 break;
640
641 case R_AVR_LO8_LDI:
642 contents += rel->r_offset;
643 srel = (bfd_signed_vma) relocation + rel->r_addend;
644 x = bfd_get_16 (input_bfd, contents);
645 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
646 bfd_put_16 (input_bfd, x, contents);
647 break;
648
649 case R_AVR_LDI:
650 contents += rel->r_offset;
651 srel = (bfd_signed_vma) relocation + rel->r_addend;
652 if (((srel > 0) && (srel & 0xffff) > 255)
653 || ((srel < 0) && ((-srel) & 0xffff) > 128))
654 /* Remove offset for data/eeprom section. */
655 return bfd_reloc_overflow;
656
657 x = bfd_get_16 (input_bfd, contents);
658 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
659 bfd_put_16 (input_bfd, x, contents);
660 break;
661
662 case R_AVR_6:
663 contents += rel->r_offset;
664 srel = (bfd_signed_vma) relocation + rel->r_addend;
665 if (((srel & 0xffff) > 63) || (srel < 0))
666 /* Remove offset for data/eeprom section. */
667 return bfd_reloc_overflow;
668 x = bfd_get_16 (input_bfd, contents);
669 x = (x & 0xd3f8) | ((srel & 7) | ((srel & (3 << 3)) << 7)
670 | ((srel & (1 << 5)) << 8));
671 bfd_put_16 (input_bfd, x, contents);
672 break;
673
674 case R_AVR_6_ADIW:
675 contents += rel->r_offset;
676 srel = (bfd_signed_vma) relocation + rel->r_addend;
677 if (((srel & 0xffff) > 63) || (srel < 0))
678 /* Remove offset for data/eeprom section. */
679 return bfd_reloc_overflow;
680 x = bfd_get_16 (input_bfd, contents);
681 x = (x & 0xff30) | (srel & 0xf) | ((srel & 0x30) << 2);
682 bfd_put_16 (input_bfd, x, contents);
683 break;
684
685 case R_AVR_HI8_LDI:
686 contents += rel->r_offset;
687 srel = (bfd_signed_vma) relocation + rel->r_addend;
688 srel = (srel >> 8) & 0xff;
689 x = bfd_get_16 (input_bfd, contents);
690 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
691 bfd_put_16 (input_bfd, x, contents);
692 break;
693
694 case R_AVR_HH8_LDI:
695 contents += rel->r_offset;
696 srel = (bfd_signed_vma) relocation + rel->r_addend;
697 srel = (srel >> 16) & 0xff;
698 x = bfd_get_16 (input_bfd, contents);
699 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
700 bfd_put_16 (input_bfd, x, contents);
701 break;
702
703 case R_AVR_MS8_LDI:
704 contents += rel->r_offset;
705 srel = (bfd_signed_vma) relocation + rel->r_addend;
706 srel = (srel >> 24) & 0xff;
707 x = bfd_get_16 (input_bfd, contents);
708 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
709 bfd_put_16 (input_bfd, x, contents);
710 break;
711
712 case R_AVR_LO8_LDI_NEG:
713 contents += rel->r_offset;
714 srel = (bfd_signed_vma) relocation + rel->r_addend;
715 srel = -srel;
716 x = bfd_get_16 (input_bfd, contents);
717 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
718 bfd_put_16 (input_bfd, x, contents);
719 break;
720
721 case R_AVR_HI8_LDI_NEG:
722 contents += rel->r_offset;
723 srel = (bfd_signed_vma) relocation + rel->r_addend;
724 srel = -srel;
725 srel = (srel >> 8) & 0xff;
726 x = bfd_get_16 (input_bfd, contents);
727 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
728 bfd_put_16 (input_bfd, x, contents);
729 break;
730
731 case R_AVR_HH8_LDI_NEG:
732 contents += rel->r_offset;
733 srel = (bfd_signed_vma) relocation + rel->r_addend;
734 srel = -srel;
735 srel = (srel >> 16) & 0xff;
736 x = bfd_get_16 (input_bfd, contents);
737 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
738 bfd_put_16 (input_bfd, x, contents);
739 break;
740
741 case R_AVR_MS8_LDI_NEG:
742 contents += rel->r_offset;
743 srel = (bfd_signed_vma) relocation + rel->r_addend;
744 srel = -srel;
745 srel = (srel >> 24) & 0xff;
746 x = bfd_get_16 (input_bfd, contents);
747 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
748 bfd_put_16 (input_bfd, x, contents);
749 break;
750
751 case R_AVR_LO8_LDI_PM:
752 contents += rel->r_offset;
753 srel = (bfd_signed_vma) relocation + rel->r_addend;
754 if (srel & 1)
755 return bfd_reloc_outofrange;
756 srel = srel >> 1;
757 x = bfd_get_16 (input_bfd, contents);
758 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
759 bfd_put_16 (input_bfd, x, contents);
760 break;
761
762 case R_AVR_HI8_LDI_PM:
763 contents += rel->r_offset;
764 srel = (bfd_signed_vma) relocation + rel->r_addend;
765 if (srel & 1)
766 return bfd_reloc_outofrange;
767 srel = srel >> 1;
768 srel = (srel >> 8) & 0xff;
769 x = bfd_get_16 (input_bfd, contents);
770 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
771 bfd_put_16 (input_bfd, x, contents);
772 break;
773
774 case R_AVR_HH8_LDI_PM:
775 contents += rel->r_offset;
776 srel = (bfd_signed_vma) relocation + rel->r_addend;
777 if (srel & 1)
778 return bfd_reloc_outofrange;
779 srel = srel >> 1;
780 srel = (srel >> 16) & 0xff;
781 x = bfd_get_16 (input_bfd, contents);
782 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
783 bfd_put_16 (input_bfd, x, contents);
784 break;
785
786 case R_AVR_LO8_LDI_PM_NEG:
787 contents += rel->r_offset;
788 srel = (bfd_signed_vma) relocation + rel->r_addend;
789 srel = -srel;
790 if (srel & 1)
791 return bfd_reloc_outofrange;
792 srel = srel >> 1;
793 x = bfd_get_16 (input_bfd, contents);
794 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
795 bfd_put_16 (input_bfd, x, contents);
796 break;
797
798 case R_AVR_HI8_LDI_PM_NEG:
799 contents += rel->r_offset;
800 srel = (bfd_signed_vma) relocation + rel->r_addend;
801 srel = -srel;
802 if (srel & 1)
803 return bfd_reloc_outofrange;
804 srel = srel >> 1;
805 srel = (srel >> 8) & 0xff;
806 x = bfd_get_16 (input_bfd, contents);
807 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
808 bfd_put_16 (input_bfd, x, contents);
809 break;
810
811 case R_AVR_HH8_LDI_PM_NEG:
812 contents += rel->r_offset;
813 srel = (bfd_signed_vma) relocation + rel->r_addend;
814 srel = -srel;
815 if (srel & 1)
816 return bfd_reloc_outofrange;
817 srel = srel >> 1;
818 srel = (srel >> 16) & 0xff;
819 x = bfd_get_16 (input_bfd, contents);
820 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
821 bfd_put_16 (input_bfd, x, contents);
822 break;
823
824 case R_AVR_CALL:
825 contents += rel->r_offset;
826 srel = (bfd_signed_vma) relocation + rel->r_addend;
827 if (srel & 1)
828 return bfd_reloc_outofrange;
829 srel = srel >> 1;
830 x = bfd_get_16 (input_bfd, contents);
831 x |= ((srel & 0x10000) | ((srel << 3) & 0x1f00000)) >> 16;
832 bfd_put_16 (input_bfd, x, contents);
833 bfd_put_16 (input_bfd, (bfd_vma) srel & 0xffff, contents+2);
834 break;
835
836 default:
837 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
838 contents, rel->r_offset,
839 relocation, rel->r_addend);
840 }
841
842 return r;
843 }
844
845 /* Relocate an AVR ELF section. */
846
847 static bfd_boolean
848 elf32_avr_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED,
849 struct bfd_link_info *info,
850 bfd *input_bfd,
851 asection *input_section,
852 bfd_byte *contents,
853 Elf_Internal_Rela *relocs,
854 Elf_Internal_Sym *local_syms,
855 asection **local_sections)
856 {
857 Elf_Internal_Shdr * symtab_hdr;
858 struct elf_link_hash_entry ** sym_hashes;
859 Elf_Internal_Rela * rel;
860 Elf_Internal_Rela * relend;
861
862 if (info->relocatable)
863 return TRUE;
864
865 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
866 sym_hashes = elf_sym_hashes (input_bfd);
867 relend = relocs + input_section->reloc_count;
868
869 for (rel = relocs; rel < relend; rel ++)
870 {
871 reloc_howto_type * howto;
872 unsigned long r_symndx;
873 Elf_Internal_Sym * sym;
874 asection * sec;
875 struct elf_link_hash_entry * h;
876 bfd_vma relocation;
877 bfd_reloc_status_type r;
878 const char * name;
879 int r_type;
880
881 /* This is a final link. */
882 r_type = ELF32_R_TYPE (rel->r_info);
883 r_symndx = ELF32_R_SYM (rel->r_info);
884 howto = elf_avr_howto_table + ELF32_R_TYPE (rel->r_info);
885 h = NULL;
886 sym = NULL;
887 sec = NULL;
888
889 if (r_symndx < symtab_hdr->sh_info)
890 {
891 sym = local_syms + r_symndx;
892 sec = local_sections [r_symndx];
893 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
894
895 name = bfd_elf_string_from_elf_section
896 (input_bfd, symtab_hdr->sh_link, sym->st_name);
897 name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
898 }
899 else
900 {
901 bfd_boolean unresolved_reloc, warned;
902
903 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
904 r_symndx, symtab_hdr, sym_hashes,
905 h, sec, relocation,
906 unresolved_reloc, warned);
907
908 name = h->root.root.string;
909 }
910
911 r = avr_final_link_relocate (howto, input_bfd, input_section,
912 contents, rel, relocation);
913
914 if (r != bfd_reloc_ok)
915 {
916 const char * msg = (const char *) NULL;
917
918 switch (r)
919 {
920 case bfd_reloc_overflow:
921 r = info->callbacks->reloc_overflow
922 (info, (h ? &h->root : NULL),
923 name, howto->name, (bfd_vma) 0,
924 input_bfd, input_section, rel->r_offset);
925 break;
926
927 case bfd_reloc_undefined:
928 r = info->callbacks->undefined_symbol
929 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
930 break;
931
932 case bfd_reloc_outofrange:
933 msg = _("internal error: out of range error");
934 break;
935
936 case bfd_reloc_notsupported:
937 msg = _("internal error: unsupported relocation error");
938 break;
939
940 case bfd_reloc_dangerous:
941 msg = _("internal error: dangerous relocation");
942 break;
943
944 default:
945 msg = _("internal error: unknown error");
946 break;
947 }
948
949 if (msg)
950 r = info->callbacks->warning
951 (info, msg, name, input_bfd, input_section, rel->r_offset);
952
953 if (! r)
954 return FALSE;
955 }
956 }
957
958 return TRUE;
959 }
960
961 /* The final processing done just before writing out a AVR ELF object
962 file. This gets the AVR architecture right based on the machine
963 number. */
964
965 static void
966 bfd_elf_avr_final_write_processing (bfd *abfd,
967 bfd_boolean linker ATTRIBUTE_UNUSED)
968 {
969 unsigned long val;
970
971 switch (bfd_get_mach (abfd))
972 {
973 default:
974 case bfd_mach_avr2:
975 val = E_AVR_MACH_AVR2;
976 break;
977
978 case bfd_mach_avr1:
979 val = E_AVR_MACH_AVR1;
980 break;
981
982 case bfd_mach_avr3:
983 val = E_AVR_MACH_AVR3;
984 break;
985
986 case bfd_mach_avr4:
987 val = E_AVR_MACH_AVR4;
988 break;
989
990 case bfd_mach_avr5:
991 val = E_AVR_MACH_AVR5;
992 break;
993 }
994
995 elf_elfheader (abfd)->e_machine = EM_AVR;
996 elf_elfheader (abfd)->e_flags &= ~ EF_AVR_MACH;
997 elf_elfheader (abfd)->e_flags |= val;
998 elf_elfheader (abfd)->e_flags |= EF_AVR_LINKRELAX_PREPARED;
999 }
1000
1001 /* Set the right machine number. */
1002
1003 static bfd_boolean
1004 elf32_avr_object_p (bfd *abfd)
1005 {
1006 unsigned int e_set = bfd_mach_avr2;
1007
1008 if (elf_elfheader (abfd)->e_machine == EM_AVR
1009 || elf_elfheader (abfd)->e_machine == EM_AVR_OLD)
1010 {
1011 int e_mach = elf_elfheader (abfd)->e_flags & EF_AVR_MACH;
1012
1013 switch (e_mach)
1014 {
1015 default:
1016 case E_AVR_MACH_AVR2:
1017 e_set = bfd_mach_avr2;
1018 break;
1019
1020 case E_AVR_MACH_AVR1:
1021 e_set = bfd_mach_avr1;
1022 break;
1023
1024 case E_AVR_MACH_AVR3:
1025 e_set = bfd_mach_avr3;
1026 break;
1027
1028 case E_AVR_MACH_AVR4:
1029 e_set = bfd_mach_avr4;
1030 break;
1031
1032 case E_AVR_MACH_AVR5:
1033 e_set = bfd_mach_avr5;
1034 break;
1035 }
1036 }
1037 return bfd_default_set_arch_mach (abfd, bfd_arch_avr,
1038 e_set);
1039 }
1040
1041
1042 /* Enable debugging printout at stdout with a value of 1. */
1043 #define DEBUG_RELAX 0
1044
1045 /* Delete some bytes from a section while changing the size of an instruction.
1046 The parameter "addr" denotes the section-relative offset pointing just
1047 behind the shrinked instruction. "addr+count" point at the first
1048 byte just behind the original unshrinked instruction. */
1049
1050 static bfd_boolean
1051 elf32_avr_relax_delete_bytes (bfd *abfd,
1052 asection *sec,
1053 bfd_vma addr,
1054 int count)
1055 {
1056 Elf_Internal_Shdr *symtab_hdr;
1057 unsigned int sec_shndx;
1058 bfd_byte *contents;
1059 Elf_Internal_Rela *irel, *irelend;
1060 Elf_Internal_Rela *irelalign;
1061 Elf_Internal_Sym *isym;
1062 Elf_Internal_Sym *isymbuf = NULL;
1063 Elf_Internal_Sym *isymend;
1064 bfd_vma toaddr;
1065 struct elf_link_hash_entry **sym_hashes;
1066 struct elf_link_hash_entry **end_hashes;
1067 unsigned int symcount;
1068
1069 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1070 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1071 contents = elf_section_data (sec)->this_hdr.contents;
1072
1073 /* The deletion must stop at the next ALIGN reloc for an aligment
1074 power larger than the number of bytes we are deleting. */
1075
1076 irelalign = NULL;
1077 toaddr = sec->size;
1078
1079 irel = elf_section_data (sec)->relocs;
1080 irelend = irel + sec->reloc_count;
1081
1082 /* Actually delete the bytes. */
1083 if (toaddr - addr - count > 0)
1084 memmove (contents + addr, contents + addr + count,
1085 (size_t) (toaddr - addr - count));
1086 sec->size -= count;
1087
1088 /* Adjust all the relocs. */
1089 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1090 {
1091 bfd_vma symval;
1092 bfd_vma old_reloc_address;
1093 bfd_vma shrinked_insn_address;
1094
1095 old_reloc_address = (sec->output_section->vma
1096 + sec->output_offset + irel->r_offset);
1097 shrinked_insn_address = (sec->output_section->vma
1098 + sec->output_offset + addr - count);
1099
1100 /* Get the new reloc address. */
1101 if ((irel->r_offset > addr
1102 && irel->r_offset < toaddr))
1103 {
1104 if (DEBUG_RELAX)
1105 printf ("Relocation at address 0x%x needs to be moved.\n"
1106 "Old section offset: 0x%x, New section offset: 0x%x \n",
1107 (unsigned int) old_reloc_address,
1108 (unsigned int) irel->r_offset,
1109 (unsigned int) ((irel->r_offset) - count));
1110
1111 irel->r_offset -= count;
1112 }
1113
1114 /* The reloc's own addresses are now ok. However, we need to readjust
1115 the reloc's addend if two conditions are met:
1116 1.) the reloc is relative to a symbol in this section that
1117 is located in front of the shrinked instruction
1118 2.) symbol plus addend end up behind the shrinked instruction.
1119
1120 This should happen only for local symbols that are progmem related. */
1121
1122 /* Read this BFD's local symbols if we haven't done so already. */
1123 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
1124 {
1125 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1126 if (isymbuf == NULL)
1127 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
1128 symtab_hdr->sh_info, 0,
1129 NULL, NULL, NULL);
1130 if (isymbuf == NULL)
1131 return FALSE;
1132 }
1133
1134 /* Get the value of the symbol referred to by the reloc. */
1135 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1136 {
1137 /* A local symbol. */
1138 Elf_Internal_Sym *isym;
1139 asection *sym_sec;
1140
1141 isym = isymbuf + ELF32_R_SYM (irel->r_info);
1142 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
1143 symval = isym->st_value;
1144 /* If the reloc is absolute, it will not have
1145 a symbol or section associated with it. */
1146 if (sym_sec)
1147 {
1148 symval += sym_sec->output_section->vma
1149 + sym_sec->output_offset;
1150
1151 if (DEBUG_RELAX)
1152 printf ("Checking if the relocation's "
1153 "addend needs corrections.\n"
1154 "Address of anchor symbol: 0x%x \n"
1155 "Address of relocation target: 0x%x \n"
1156 "Address of relaxed insn: 0x%x \n",
1157 (unsigned int) symval,
1158 (unsigned int) (symval + irel->r_addend),
1159 (unsigned int) shrinked_insn_address);
1160
1161 if (symval <= shrinked_insn_address
1162 && (symval + irel->r_addend) > shrinked_insn_address)
1163 {
1164 irel->r_addend -= count;
1165
1166 if (DEBUG_RELAX)
1167 printf ("Anchor symbol and relocation target bracket "
1168 "shrinked insn address.\n"
1169 "Need for new addend : 0x%x\n",
1170 (unsigned int) irel->r_addend);
1171 }
1172 }
1173 /* else ... Reference symbol is absolute. No adjustment needed. */
1174 }
1175 /* else ... Reference symbol is extern. No need for adjusting the addend. */
1176 }
1177
1178 /* Adjust the local symbols defined in this section. */
1179 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1180 isymend = isym + symtab_hdr->sh_info;
1181 for (; isym < isymend; isym++)
1182 {
1183 if (isym->st_shndx == sec_shndx
1184 && isym->st_value > addr
1185 && isym->st_value < toaddr)
1186 isym->st_value -= count;
1187 }
1188
1189 /* Now adjust the global symbols defined in this section. */
1190 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1191 - symtab_hdr->sh_info);
1192 sym_hashes = elf_sym_hashes (abfd);
1193 end_hashes = sym_hashes + symcount;
1194 for (; sym_hashes < end_hashes; sym_hashes++)
1195 {
1196 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1197 if ((sym_hash->root.type == bfd_link_hash_defined
1198 || sym_hash->root.type == bfd_link_hash_defweak)
1199 && sym_hash->root.u.def.section == sec
1200 && sym_hash->root.u.def.value > addr
1201 && sym_hash->root.u.def.value < toaddr)
1202 {
1203 sym_hash->root.u.def.value -= count;
1204 }
1205 }
1206
1207 return TRUE;
1208 }
1209
1210 /* This function handles relaxing for the avr.
1211 Many important relaxing opportunities within functions are already
1212 realized by the compiler itself.
1213 Here we try to replace call (4 bytes) -> rcall (2 bytes)
1214 and jump -> rjmp (safes also 2 bytes).
1215 As well we now optimize seqences of
1216 - call/rcall function
1217 - ret
1218 to yield
1219 - jmp/rjmp function
1220 - ret
1221 . In case that within a sequence
1222 - jmp/rjmp label
1223 - ret
1224 the ret could no longer be reached it is optimized away. In order
1225 to check if the ret is no longer needed, it is checked that the ret's address
1226 is not the target of a branch or jump within the same section, it is checked
1227 that there is no skip instruction before the jmp/rjmp and that there
1228 is no local or global label place at the address of the ret.
1229
1230 We refrain from relaxing within sections ".vectors" and
1231 ".jumptables" in order to maintain the position of the instructions.
1232 There, however, we substitute jmp/call by a sequence rjmp,nop/rcall,nop
1233 if possible. (In future one could possibly use the space of the nop
1234 for the first instruction of the irq service function.
1235
1236 The .jumptables sections is meant to be used for a future tablejump variant
1237 for the devices with 3-byte program counter where the table itself
1238 contains 4-byte jump instructions whose relative offset must not
1239 be changed. */
1240
1241 static bfd_boolean
1242 elf32_avr_relax_section (bfd *abfd,
1243 asection *sec,
1244 struct bfd_link_info *link_info,
1245 bfd_boolean *again)
1246 {
1247 Elf_Internal_Shdr *symtab_hdr;
1248 Elf_Internal_Rela *internal_relocs;
1249 Elf_Internal_Rela *irel, *irelend;
1250 bfd_byte *contents = NULL;
1251 Elf_Internal_Sym *isymbuf = NULL;
1252 static asection *last_input_section = NULL;
1253 static Elf_Internal_Rela *last_reloc = NULL;
1254
1255 /* Assume nothing changes. */
1256 *again = FALSE;
1257
1258 /* We don't have to do anything for a relocatable link, if
1259 this section does not have relocs, or if this is not a
1260 code section. */
1261 if (link_info->relocatable
1262 || (sec->flags & SEC_RELOC) == 0
1263 || sec->reloc_count == 0
1264 || (sec->flags & SEC_CODE) == 0)
1265 return TRUE;
1266
1267 /* Check if the object file to relax uses internal symbols so that we
1268 could fix up the relocations. */
1269 if (!(elf_elfheader (abfd)->e_flags & EF_AVR_LINKRELAX_PREPARED))
1270 return TRUE;
1271
1272 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1273
1274 /* Get a copy of the native relocations. */
1275 internal_relocs = (_bfd_elf_link_read_relocs
1276 (abfd, sec, NULL, NULL, link_info->keep_memory));
1277 if (internal_relocs == NULL)
1278 goto error_return;
1279
1280 if (sec != last_input_section)
1281 last_reloc = NULL;
1282
1283 last_input_section = sec;
1284
1285 /* Walk through the relocs looking for relaxing opportunities. */
1286 irelend = internal_relocs + sec->reloc_count;
1287 for (irel = internal_relocs; irel < irelend; irel++)
1288 {
1289 bfd_vma symval;
1290
1291 if ( ELF32_R_TYPE (irel->r_info) != R_AVR_13_PCREL
1292 && ELF32_R_TYPE (irel->r_info) != R_AVR_7_PCREL
1293 && ELF32_R_TYPE (irel->r_info) != R_AVR_CALL)
1294 continue;
1295
1296 /* Get the section contents if we haven't done so already. */
1297 if (contents == NULL)
1298 {
1299 /* Get cached copy if it exists. */
1300 if (elf_section_data (sec)->this_hdr.contents != NULL)
1301 contents = elf_section_data (sec)->this_hdr.contents;
1302 else
1303 {
1304 /* Go get them off disk. */
1305 if (! bfd_malloc_and_get_section (abfd, sec, &contents))
1306 goto error_return;
1307 }
1308 }
1309
1310 /* Read this BFD's local symbols if we haven't done so already. */
1311 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
1312 {
1313 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1314 if (isymbuf == NULL)
1315 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
1316 symtab_hdr->sh_info, 0,
1317 NULL, NULL, NULL);
1318 if (isymbuf == NULL)
1319 goto error_return;
1320 }
1321
1322
1323 /* Get the value of the symbol referred to by the reloc. */
1324 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
1325 {
1326 /* A local symbol. */
1327 Elf_Internal_Sym *isym;
1328 asection *sym_sec;
1329
1330 isym = isymbuf + ELF32_R_SYM (irel->r_info);
1331 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
1332 symval = isym->st_value;
1333 /* If the reloc is absolute, it will not have
1334 a symbol or section associated with it. */
1335 if (sym_sec)
1336 symval += sym_sec->output_section->vma
1337 + sym_sec->output_offset;
1338 }
1339 else
1340 {
1341 unsigned long indx;
1342 struct elf_link_hash_entry *h;
1343
1344 /* An external symbol. */
1345 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
1346 h = elf_sym_hashes (abfd)[indx];
1347 BFD_ASSERT (h != NULL);
1348 if (h->root.type != bfd_link_hash_defined
1349 && h->root.type != bfd_link_hash_defweak)
1350 /* This appears to be a reference to an undefined
1351 symbol. Just ignore it--it will be caught by the
1352 regular reloc processing. */
1353 continue;
1354
1355 symval = (h->root.u.def.value
1356 + h->root.u.def.section->output_section->vma
1357 + h->root.u.def.section->output_offset);
1358 }
1359
1360 /* For simplicity of coding, we are going to modify the section
1361 contents, the section relocs, and the BFD symbol table. We
1362 must tell the rest of the code not to free up this
1363 information. It would be possible to instead create a table
1364 of changes which have to be made, as is done in coff-mips.c;
1365 that would be more work, but would require less memory when
1366 the linker is run. */
1367 switch (ELF32_R_TYPE (irel->r_info))
1368 {
1369 /* Try to turn a 22-bit absolute call/jump into an 13-bit
1370 pc-relative rcall/rjmp. */
1371 case R_AVR_CALL:
1372 {
1373 bfd_vma value = symval + irel->r_addend;
1374 bfd_vma dot, gap;
1375 int distance_short_enough = 0;
1376
1377 /* Get the address of this instruction. */
1378 dot = (sec->output_section->vma
1379 + sec->output_offset + irel->r_offset);
1380
1381 /* Compute the distance from this insn to the branch target. */
1382 gap = value - dot;
1383
1384 /* If the distance is within -4094..+4098 inclusive, then we can
1385 relax this jump/call. +4098 because the call/jump target
1386 will be closer after the relaxation. */
1387 if ((int) gap >= -4094 && (int) gap <= 4098)
1388 distance_short_enough = 1;
1389
1390 /* Here we handle the wrap-around case. E.g. for a 16k device
1391 we could use a rjmp to jump from address 0x100 to 0x3d00!
1392 In order to make this work properly, we need to fill the
1393 vaiable avr_pc_wrap_around with the appropriate value.
1394 I.e. 0x4000 for a 16k device. */
1395 {
1396 /* Shrinking the code size makes the gaps larger in the
1397 case of wrap-arounds. So we use a heuristical safety
1398 margin to avoid that during relax the distance gets
1399 again too large for the short jumps. Let's assume
1400 a typical code-size reduction due to relax for a
1401 16k device of 600 bytes. So let's use twice the
1402 typical value as safety margin. */
1403 int rgap;
1404 int safety_margin;
1405
1406 int assumed_shrink = 600;
1407 if (avr_pc_wrap_around > 0x4000)
1408 assumed_shrink = 900;
1409
1410 safety_margin = 2 * assumed_shrink;
1411
1412 rgap = avr_relative_distance_considering_wrap_around (gap);
1413
1414 if (rgap >= (-4092 + safety_margin)
1415 && rgap <= (4094 - safety_margin))
1416 distance_short_enough = 1;
1417 }
1418
1419 if (distance_short_enough)
1420 {
1421 unsigned char code_msb;
1422 unsigned char code_lsb;
1423
1424 if (DEBUG_RELAX)
1425 printf ("shrinking jump/call instruction at address 0x%x"
1426 " in section %s\n\n",
1427 (int) dot, sec->name);
1428
1429 /* Note that we've changed the relocs, section contents,
1430 etc. */
1431 elf_section_data (sec)->relocs = internal_relocs;
1432 elf_section_data (sec)->this_hdr.contents = contents;
1433 symtab_hdr->contents = (unsigned char *) isymbuf;
1434
1435 /* Get the instruction code for relaxing. */
1436 code_lsb = bfd_get_8 (abfd, contents + irel->r_offset);
1437 code_msb = bfd_get_8 (abfd, contents + irel->r_offset + 1);
1438
1439 /* Mask out the relocation bits. */
1440 code_msb &= 0x94;
1441 code_lsb &= 0x0E;
1442 if (code_msb == 0x94 && code_lsb == 0x0E)
1443 {
1444 /* we are changing call -> rcall . */
1445 bfd_put_8 (abfd, 0x00, contents + irel->r_offset);
1446 bfd_put_8 (abfd, 0xD0, contents + irel->r_offset + 1);
1447 }
1448 else if (code_msb == 0x94 && code_lsb == 0x0C)
1449 {
1450 /* we are changeing jump -> rjmp. */
1451 bfd_put_8 (abfd, 0x00, contents + irel->r_offset);
1452 bfd_put_8 (abfd, 0xC0, contents + irel->r_offset + 1);
1453 }
1454 else
1455 abort ();
1456
1457 /* Fix the relocation's type. */
1458 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1459 R_AVR_13_PCREL);
1460
1461 /* Check for the vector section. There we don't want to
1462 modify the ordering! */
1463
1464 if (!strcmp (sec->name,".vectors")
1465 || !strcmp (sec->name,".jumptables"))
1466 {
1467 /* Let's insert a nop. */
1468 bfd_put_8 (abfd, 0x00, contents + irel->r_offset + 2);
1469 bfd_put_8 (abfd, 0x00, contents + irel->r_offset + 3);
1470 }
1471 else
1472 {
1473 /* Delete two bytes of data. */
1474 if (!elf32_avr_relax_delete_bytes (abfd, sec,
1475 irel->r_offset + 2, 2))
1476 goto error_return;
1477
1478 /* That will change things, so, we should relax again.
1479 Note that this is not required, and it may be slow. */
1480 *again = TRUE;
1481 }
1482 }
1483 }
1484
1485 default:
1486 {
1487 unsigned char code_msb;
1488 unsigned char code_lsb;
1489 bfd_vma dot;
1490
1491 code_msb = bfd_get_8 (abfd, contents + irel->r_offset + 1);
1492 code_lsb = bfd_get_8 (abfd, contents + irel->r_offset + 0);
1493
1494 /* Get the address of this instruction. */
1495 dot = (sec->output_section->vma
1496 + sec->output_offset + irel->r_offset);
1497
1498 /* Here we look for rcall/ret or call/ret sequences that could be
1499 safely replaced by rjmp/ret or jmp/ret */
1500 if (0xd0 == (code_msb & 0xf0))
1501 {
1502 /* This insn is a rcall. */
1503 unsigned char next_insn_msb = 0;
1504 unsigned char next_insn_lsb = 0;
1505
1506 if (irel->r_offset + 3 < sec->size)
1507 {
1508 next_insn_msb =
1509 bfd_get_8 (abfd, contents + irel->r_offset + 3);
1510 next_insn_lsb =
1511 bfd_get_8 (abfd, contents + irel->r_offset + 2);
1512 }
1513
1514 if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb))
1515 {
1516 /* The next insn is a ret. We now convert the rcall insn
1517 into a rjmp instruction. */
1518 code_msb &= 0xef;
1519 bfd_put_8 (abfd, code_msb, contents + irel->r_offset + 1);
1520 if (DEBUG_RELAX)
1521 printf ("converted rcall/ret sequence at address 0x%x"
1522 " into rjmp/ret sequence. Section is %s\n\n",
1523 (int) dot, sec->name);
1524 *again = TRUE;
1525 break;
1526 }
1527 }
1528 else if ((0x94 == (code_msb & 0xfe))
1529 && (0x0e == (code_lsb & 0x0e)))
1530 {
1531 /* This insn is a call. */
1532 unsigned char next_insn_msb = 0;
1533 unsigned char next_insn_lsb = 0;
1534
1535 if (irel->r_offset + 5 < sec->size)
1536 {
1537 next_insn_msb =
1538 bfd_get_8 (abfd, contents + irel->r_offset + 5);
1539 next_insn_lsb =
1540 bfd_get_8 (abfd, contents + irel->r_offset + 4);
1541 }
1542
1543 if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb))
1544 {
1545 /* The next insn is a ret. We now convert the call insn
1546 into a jmp instruction. */
1547
1548 code_lsb &= 0xfd;
1549 bfd_put_8 (abfd, code_lsb, contents + irel->r_offset);
1550 if (DEBUG_RELAX)
1551 printf ("converted call/ret sequence at address 0x%x"
1552 " into jmp/ret sequence. Section is %s\n\n",
1553 (int) dot, sec->name);
1554 *again = TRUE;
1555 break;
1556 }
1557 }
1558 else if ((0xc0 == (code_msb & 0xf0))
1559 || ((0x94 == (code_msb & 0xfe))
1560 && (0x0c == (code_lsb & 0x0e))))
1561 {
1562 /* This insn is a rjmp or a jmp. */
1563 unsigned char next_insn_msb = 0;
1564 unsigned char next_insn_lsb = 0;
1565 int insn_size;
1566
1567 if (0xc0 == (code_msb & 0xf0))
1568 insn_size = 2; /* rjmp insn */
1569 else
1570 insn_size = 4; /* jmp insn */
1571
1572 if (irel->r_offset + insn_size + 1 < sec->size)
1573 {
1574 next_insn_msb =
1575 bfd_get_8 (abfd, contents + irel->r_offset
1576 + insn_size + 1);
1577 next_insn_lsb =
1578 bfd_get_8 (abfd, contents + irel->r_offset
1579 + insn_size);
1580 }
1581
1582 if ((0x95 == next_insn_msb) && (0x08 == next_insn_lsb))
1583 {
1584 /* The next insn is a ret. We possibly could delete
1585 this ret. First we need to check for preceeding
1586 sbis/sbic/sbrs or cpse "skip" instructions. */
1587
1588 int there_is_preceeding_non_skip_insn = 1;
1589 bfd_vma address_of_ret;
1590
1591 address_of_ret = dot + insn_size;
1592
1593 if (DEBUG_RELAX && (insn_size == 2))
1594 printf ("found rjmp / ret sequence at address 0x%x\n",
1595 (int) dot);
1596 if (DEBUG_RELAX && (insn_size == 4))
1597 printf ("found jmp / ret sequence at address 0x%x\n",
1598 (int) dot);
1599
1600 /* We have to make sure that there is a preceeding insn. */
1601 if (irel->r_offset >= 2)
1602 {
1603 unsigned char preceeding_msb;
1604 unsigned char preceeding_lsb;
1605 preceeding_msb =
1606 bfd_get_8 (abfd, contents + irel->r_offset - 1);
1607 preceeding_lsb =
1608 bfd_get_8 (abfd, contents + irel->r_offset - 2);
1609
1610 /* sbic. */
1611 if (0x99 == preceeding_msb)
1612 there_is_preceeding_non_skip_insn = 0;
1613
1614 /* sbis. */
1615 if (0x9b == preceeding_msb)
1616 there_is_preceeding_non_skip_insn = 0;
1617
1618 /* sbrc */
1619 if ((0xfc == (preceeding_msb & 0xfe)
1620 && (0x00 == (preceeding_lsb & 0x08))))
1621 there_is_preceeding_non_skip_insn = 0;
1622
1623 /* sbrs */
1624 if ((0xfe == (preceeding_msb & 0xfe)
1625 && (0x00 == (preceeding_lsb & 0x08))))
1626 there_is_preceeding_non_skip_insn = 0;
1627
1628 /* cpse */
1629 if (0x10 == (preceeding_msb & 0xfc))
1630 there_is_preceeding_non_skip_insn = 0;
1631
1632 if (there_is_preceeding_non_skip_insn == 0)
1633 if (DEBUG_RELAX)
1634 printf ("preceeding skip insn prevents deletion of"
1635 " ret insn at addr 0x%x in section %s\n",
1636 (int) dot + 2, sec->name);
1637 }
1638 else
1639 {
1640 /* There is no previous instruction. */
1641 there_is_preceeding_non_skip_insn = 0;
1642 }
1643
1644 if (there_is_preceeding_non_skip_insn)
1645 {
1646 /* We now only have to make sure that there is no
1647 local label defined at the address of the ret
1648 instruction and that there is no local relocation
1649 in this section pointing to the ret. */
1650
1651 int deleting_ret_is_safe = 1;
1652 unsigned int section_offset_of_ret_insn =
1653 irel->r_offset + insn_size;
1654 Elf_Internal_Sym *isym, *isymend;
1655 unsigned int sec_shndx;
1656
1657 sec_shndx =
1658 _bfd_elf_section_from_bfd_section (abfd, sec);
1659
1660 /* Check for local symbols. */
1661 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1662 isymend = isym + symtab_hdr->sh_info;
1663 for (; isym < isymend; isym++)
1664 {
1665 if (isym->st_value == section_offset_of_ret_insn
1666 && isym->st_shndx == sec_shndx)
1667 {
1668 deleting_ret_is_safe = 0;
1669 if (DEBUG_RELAX)
1670 printf ("local label prevents deletion of ret "
1671 "insn at address 0x%x\n",
1672 (int) dot + insn_size);
1673 }
1674 }
1675
1676 /* Now check for global symbols. */
1677 {
1678 int symcount;
1679 struct elf_link_hash_entry **sym_hashes;
1680 struct elf_link_hash_entry **end_hashes;
1681
1682 symcount = (symtab_hdr->sh_size
1683 / sizeof (Elf32_External_Sym)
1684 - symtab_hdr->sh_info);
1685 sym_hashes = elf_sym_hashes (abfd);
1686 end_hashes = sym_hashes + symcount;
1687 for (; sym_hashes < end_hashes; sym_hashes++)
1688 {
1689 struct elf_link_hash_entry *sym_hash =
1690 *sym_hashes;
1691 if ((sym_hash->root.type == bfd_link_hash_defined
1692 || sym_hash->root.type ==
1693 bfd_link_hash_defweak)
1694 && sym_hash->root.u.def.section == sec
1695 && sym_hash->root.u.def.value == section_offset_of_ret_insn)
1696 {
1697 deleting_ret_is_safe = 0;
1698 if (DEBUG_RELAX)
1699 printf ("global label prevents deletion of "
1700 "ret insn at address 0x%x\n",
1701 (int) dot + insn_size);
1702 }
1703 }
1704 }
1705 /* Now we check for relocations pointing to ret. */
1706 {
1707 Elf_Internal_Rela *irel;
1708 Elf_Internal_Rela *relend;
1709 Elf_Internal_Shdr *symtab_hdr;
1710
1711 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1712 relend = elf_section_data (sec)->relocs
1713 + sec->reloc_count;
1714
1715 for (irel = elf_section_data (sec)->relocs;
1716 irel < relend; irel++)
1717 {
1718 bfd_vma reloc_target = 0;
1719 bfd_vma symval;
1720 Elf_Internal_Sym *isymbuf = NULL;
1721
1722 /* Read this BFD's local symbols if we haven't
1723 done so already. */
1724 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
1725 {
1726 isymbuf = (Elf_Internal_Sym *)
1727 symtab_hdr->contents;
1728 if (isymbuf == NULL)
1729 isymbuf = bfd_elf_get_elf_syms
1730 (abfd,
1731 symtab_hdr,
1732 symtab_hdr->sh_info, 0,
1733 NULL, NULL, NULL);
1734 if (isymbuf == NULL)
1735 break;
1736 }
1737
1738 /* Get the value of the symbol referred to
1739 by the reloc. */
1740 if (ELF32_R_SYM (irel->r_info)
1741 < symtab_hdr->sh_info)
1742 {
1743 /* A local symbol. */
1744 Elf_Internal_Sym *isym;
1745 asection *sym_sec;
1746
1747 isym = isymbuf
1748 + ELF32_R_SYM (irel->r_info);
1749 sym_sec = bfd_section_from_elf_index
1750 (abfd, isym->st_shndx);
1751 symval = isym->st_value;
1752
1753 /* If the reloc is absolute, it will not
1754 have a symbol or section associated
1755 with it. */
1756
1757 if (sym_sec)
1758 {
1759 symval +=
1760 sym_sec->output_section->vma
1761 + sym_sec->output_offset;
1762 reloc_target = symval + irel->r_addend;
1763 }
1764 else
1765 {
1766 reloc_target = symval + irel->r_addend;
1767 /* Reference symbol is absolute. */
1768 }
1769 }
1770 /* else ... reference symbol is extern. */
1771
1772 if (address_of_ret == reloc_target)
1773 {
1774 deleting_ret_is_safe = 0;
1775 if (DEBUG_RELAX)
1776 printf ("ret from "
1777 "rjmp/jmp ret sequence at address"
1778 " 0x%x could not be deleted. ret"
1779 " is target of a relocation.\n",
1780 (int) address_of_ret);
1781 }
1782 }
1783 }
1784
1785 if (deleting_ret_is_safe)
1786 {
1787 if (DEBUG_RELAX)
1788 printf ("unreachable ret instruction "
1789 "at address 0x%x deleted.\n",
1790 (int) dot + insn_size);
1791
1792 /* Delete two bytes of data. */
1793 if (!elf32_avr_relax_delete_bytes (abfd, sec,
1794 irel->r_offset + insn_size, 2))
1795 goto error_return;
1796
1797 /* That will change things, so, we should relax
1798 again. Note that this is not required, and it
1799 may be slow. */
1800 *again = TRUE;
1801 break;
1802 }
1803 }
1804
1805 }
1806 }
1807 break;
1808 }
1809 }
1810 }
1811
1812 if (contents != NULL
1813 && elf_section_data (sec)->this_hdr.contents != contents)
1814 {
1815 if (! link_info->keep_memory)
1816 free (contents);
1817 else
1818 {
1819 /* Cache the section contents for elf_link_input_bfd. */
1820 elf_section_data (sec)->this_hdr.contents = contents;
1821 }
1822 }
1823
1824 if (internal_relocs != NULL
1825 && elf_section_data (sec)->relocs != internal_relocs)
1826 free (internal_relocs);
1827
1828 return TRUE;
1829
1830 error_return:
1831 if (isymbuf != NULL
1832 && symtab_hdr->contents != (unsigned char *) isymbuf)
1833 free (isymbuf);
1834 if (contents != NULL
1835 && elf_section_data (sec)->this_hdr.contents != contents)
1836 free (contents);
1837 if (internal_relocs != NULL
1838 && elf_section_data (sec)->relocs != internal_relocs)
1839 free (internal_relocs);
1840
1841 return FALSE;
1842 }
1843
1844 /* This is a version of bfd_generic_get_relocated_section_contents
1845 which uses elf32_avr_relocate_section.
1846
1847 For avr it's essentially a cut and paste taken from the H8300 port.
1848 The author of the relaxation support patch for avr had absolutely no
1849 clue what is happening here but found out that this part of the code
1850 seems to be important. */
1851
1852 static bfd_byte *
1853 elf32_avr_get_relocated_section_contents (bfd *output_bfd,
1854 struct bfd_link_info *link_info,
1855 struct bfd_link_order *link_order,
1856 bfd_byte *data,
1857 bfd_boolean relocatable,
1858 asymbol **symbols)
1859 {
1860 Elf_Internal_Shdr *symtab_hdr;
1861 asection *input_section = link_order->u.indirect.section;
1862 bfd *input_bfd = input_section->owner;
1863 asection **sections = NULL;
1864 Elf_Internal_Rela *internal_relocs = NULL;
1865 Elf_Internal_Sym *isymbuf = NULL;
1866
1867 /* We only need to handle the case of relaxing, or of having a
1868 particular set of section contents, specially. */
1869 if (relocatable
1870 || elf_section_data (input_section)->this_hdr.contents == NULL)
1871 return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
1872 link_order, data,
1873 relocatable,
1874 symbols);
1875 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1876
1877 memcpy (data, elf_section_data (input_section)->this_hdr.contents,
1878 (size_t) input_section->size);
1879
1880 if ((input_section->flags & SEC_RELOC) != 0
1881 && input_section->reloc_count > 0)
1882 {
1883 asection **secpp;
1884 Elf_Internal_Sym *isym, *isymend;
1885 bfd_size_type amt;
1886
1887 internal_relocs = (_bfd_elf_link_read_relocs
1888 (input_bfd, input_section, NULL, NULL, FALSE));
1889 if (internal_relocs == NULL)
1890 goto error_return;
1891
1892 if (symtab_hdr->sh_info != 0)
1893 {
1894 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1895 if (isymbuf == NULL)
1896 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
1897 symtab_hdr->sh_info, 0,
1898 NULL, NULL, NULL);
1899 if (isymbuf == NULL)
1900 goto error_return;
1901 }
1902
1903 amt = symtab_hdr->sh_info;
1904 amt *= sizeof (asection *);
1905 sections = bfd_malloc (amt);
1906 if (sections == NULL && amt != 0)
1907 goto error_return;
1908
1909 isymend = isymbuf + symtab_hdr->sh_info;
1910 for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
1911 {
1912 asection *isec;
1913
1914 if (isym->st_shndx == SHN_UNDEF)
1915 isec = bfd_und_section_ptr;
1916 else if (isym->st_shndx == SHN_ABS)
1917 isec = bfd_abs_section_ptr;
1918 else if (isym->st_shndx == SHN_COMMON)
1919 isec = bfd_com_section_ptr;
1920 else
1921 isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
1922
1923 *secpp = isec;
1924 }
1925
1926 if (! elf32_avr_relocate_section (output_bfd, link_info, input_bfd,
1927 input_section, data, internal_relocs,
1928 isymbuf, sections))
1929 goto error_return;
1930
1931 if (sections != NULL)
1932 free (sections);
1933 if (isymbuf != NULL
1934 && symtab_hdr->contents != (unsigned char *) isymbuf)
1935 free (isymbuf);
1936 if (elf_section_data (input_section)->relocs != internal_relocs)
1937 free (internal_relocs);
1938 }
1939
1940 return data;
1941
1942 error_return:
1943 if (sections != NULL)
1944 free (sections);
1945 if (isymbuf != NULL
1946 && symtab_hdr->contents != (unsigned char *) isymbuf)
1947 free (isymbuf);
1948 if (internal_relocs != NULL
1949 && elf_section_data (input_section)->relocs != internal_relocs)
1950 free (internal_relocs);
1951 return NULL;
1952 }
1953
1954
1955 #define ELF_ARCH bfd_arch_avr
1956 #define ELF_MACHINE_CODE EM_AVR
1957 #define ELF_MACHINE_ALT1 EM_AVR_OLD
1958 #define ELF_MAXPAGESIZE 1
1959
1960 #define TARGET_LITTLE_SYM bfd_elf32_avr_vec
1961 #define TARGET_LITTLE_NAME "elf32-avr"
1962
1963 #define elf_info_to_howto avr_info_to_howto_rela
1964 #define elf_info_to_howto_rel NULL
1965 #define elf_backend_relocate_section elf32_avr_relocate_section
1966 #define elf_backend_gc_mark_hook elf32_avr_gc_mark_hook
1967 #define elf_backend_gc_sweep_hook elf32_avr_gc_sweep_hook
1968 #define elf_backend_check_relocs elf32_avr_check_relocs
1969 #define elf_backend_can_gc_sections 1
1970 #define elf_backend_rela_normal 1
1971 #define elf_backend_final_write_processing \
1972 bfd_elf_avr_final_write_processing
1973 #define elf_backend_object_p elf32_avr_object_p
1974
1975 #define bfd_elf32_bfd_relax_section elf32_avr_relax_section
1976 #define bfd_elf32_bfd_get_relocated_section_contents \
1977 elf32_avr_get_relocated_section_contents
1978
1979 #include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.08798 seconds and 5 git commands to generate.