?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
oops - update date on newly created entry
[binutils.git] / bfd / elf32-avr.c
blob61f28e6d4e2270a9e1424eaf7e9909bc2503bdc9
1 /* AVR-specific support for 32-bit ELF
2 Copyright 1999, 2000, 2001 Free Software Foundation, Inc.
3 Contributed by Denis Chertykov <denisc@overta.ru>
4
5 This file is part of BFD, the Binary File Descriptor library.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
20
21 #include "bfd.h"
22 #include "sysdep.h"
23 #include "libbfd.h"
24 #include "elf-bfd.h"
25 #include "elf/avr.h"
26
27 static reloc_howto_type *bfd_elf32_bfd_reloc_type_lookup
28 PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
29 static void avr_info_to_howto_rela
30 PARAMS ((bfd *, arelent *, Elf32_Internal_Rela *));
31 static asection *elf32_avr_gc_mark_hook
32 PARAMS ((bfd *, struct bfd_link_info *, Elf_Internal_Rela *,
33 struct elf_link_hash_entry *, Elf_Internal_Sym *));
34 static boolean elf32_avr_gc_sweep_hook
35 PARAMS ((bfd *, struct bfd_link_info *, asection *,
36 const Elf_Internal_Rela *));
37 static boolean elf32_avr_check_relocs
38 PARAMS ((bfd *, struct bfd_link_info *, asection *,
39 const Elf_Internal_Rela *));
40 static bfd_reloc_status_type avr_final_link_relocate
41 PARAMS ((reloc_howto_type *, bfd *, asection *, bfd_byte *,
42 Elf_Internal_Rela *, bfd_vma));
43 static boolean elf32_avr_relocate_section
44 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
45 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
46 static void bfd_elf_avr_final_write_processing PARAMS ((bfd *, boolean));
47 static boolean elf32_avr_object_p PARAMS ((bfd *));
48
49 /* Use RELA instead of REL */
50 #undef USE_REL
51
52 static reloc_howto_type elf_avr_howto_table[] =
53 {
54 HOWTO (R_AVR_NONE, /* type */
55 0, /* rightshift */
56 2, /* size (0 = byte, 1 = short, 2 = long) */
57 32, /* bitsize */
58 false, /* pc_relative */
59 0, /* bitpos */
60 complain_overflow_bitfield, /* complain_on_overflow */
61 bfd_elf_generic_reloc, /* special_function */
62 "R_AVR_NONE", /* name */
63 false, /* partial_inplace */
64 0, /* src_mask */
65 0, /* dst_mask */
66 false), /* pcrel_offset */
67
68 HOWTO (R_AVR_32, /* type */
69 0, /* rightshift */
70 2, /* size (0 = byte, 1 = short, 2 = long) */
71 32, /* bitsize */
72 false, /* pc_relative */
73 0, /* bitpos */
74 complain_overflow_bitfield, /* complain_on_overflow */
75 bfd_elf_generic_reloc, /* special_function */
76 "R_AVR_32", /* name */
77 false, /* partial_inplace */
78 0xffffffff, /* src_mask */
79 0xffffffff, /* dst_mask */
80 false), /* pcrel_offset */
81
82 /* A 7 bit PC relative relocation. */
83 HOWTO (R_AVR_7_PCREL, /* type */
84 1, /* rightshift */
85 1, /* size (0 = byte, 1 = short, 2 = long) */
86 7, /* bitsize */
87 true, /* pc_relative */
88 3, /* bitpos */
89 complain_overflow_bitfield, /* complain_on_overflow */
90 bfd_elf_generic_reloc, /* special_function */
91 "R_AVR_7_PCREL", /* name */
92 false, /* partial_inplace */
93 0xffff, /* src_mask */
94 0xffff, /* dst_mask */
95 true), /* pcrel_offset */
96
97 /* A 13 bit PC relative relocation. */
98 HOWTO (R_AVR_13_PCREL, /* type */
99 1, /* rightshift */
100 1, /* size (0 = byte, 1 = short, 2 = long) */
101 13, /* bitsize */
102 true, /* pc_relative */
103 0, /* bitpos */
104 complain_overflow_bitfield, /* complain_on_overflow */
105 bfd_elf_generic_reloc, /* special_function */
106 "R_AVR_13_PCREL", /* name */
107 false, /* partial_inplace */
108 0xfff, /* src_mask */
109 0xfff, /* dst_mask */
110 true), /* pcrel_offset */
111
112 /* A 16 bit absolute relocation. */
113 HOWTO (R_AVR_16, /* type */
114 0, /* rightshift */
115 1, /* size (0 = byte, 1 = short, 2 = long) */
116 16, /* bitsize */
117 false, /* pc_relative */
118 0, /* bitpos */
119 complain_overflow_dont, /* complain_on_overflow */
120 bfd_elf_generic_reloc, /* special_function */
121 "R_AVR_16", /* name */
122 false, /* partial_inplace */
123 0xffff, /* src_mask */
124 0xffff, /* dst_mask */
125 false), /* pcrel_offset */
126
127 /* A 16 bit absolute relocation for command address. */
128 HOWTO (R_AVR_16_PM, /* type */
129 1, /* rightshift */
130 1, /* size (0 = byte, 1 = short, 2 = long) */
131 16, /* bitsize */
132 false, /* pc_relative */
133 0, /* bitpos */
134 complain_overflow_bitfield, /* complain_on_overflow */
135 bfd_elf_generic_reloc, /* special_function */
136 "R_AVR_16_PM", /* name */
137 false, /* partial_inplace */
138 0xffff, /* src_mask */
139 0xffff, /* dst_mask */
140 false), /* pcrel_offset */
141 /* A low 8 bit absolute relocation of 16 bit address.
142 For LDI command. */
143 HOWTO (R_AVR_LO8_LDI, /* type */
144 0, /* rightshift */
145 1, /* size (0 = byte, 1 = short, 2 = long) */
146 8, /* bitsize */
147 false, /* pc_relative */
148 0, /* bitpos */
149 complain_overflow_dont, /* complain_on_overflow */
150 bfd_elf_generic_reloc, /* special_function */
151 "R_AVR_LO8_LDI", /* name */
152 false, /* partial_inplace */
153 0xffff, /* src_mask */
154 0xffff, /* dst_mask */
155 false), /* pcrel_offset */
156 /* A high 8 bit absolute relocation of 16 bit address.
157 For LDI command. */
158 HOWTO (R_AVR_HI8_LDI, /* type */
159 8, /* rightshift */
160 1, /* size (0 = byte, 1 = short, 2 = long) */
161 8, /* bitsize */
162 false, /* pc_relative */
163 0, /* bitpos */
164 complain_overflow_dont, /* complain_on_overflow */
165 bfd_elf_generic_reloc, /* special_function */
166 "R_AVR_HI8_LDI", /* name */
167 false, /* partial_inplace */
168 0xffff, /* src_mask */
169 0xffff, /* dst_mask */
170 false), /* pcrel_offset */
171 /* A high 6 bit absolute relocation of 22 bit address.
172 For LDI command. */
173 HOWTO (R_AVR_HH8_LDI, /* type */
174 16, /* rightshift */
175 1, /* size (0 = byte, 1 = short, 2 = long) */
176 8, /* bitsize */
177 false, /* pc_relative */
178 0, /* bitpos */
179 complain_overflow_dont, /* complain_on_overflow */
180 bfd_elf_generic_reloc, /* special_function */
181 "R_AVR_HH8_LDI", /* name */
182 false, /* partial_inplace */
183 0xffff, /* src_mask */
184 0xffff, /* dst_mask */
185 false), /* pcrel_offset */
186 /* A negative low 8 bit absolute relocation of 16 bit address.
187 For LDI command. */
188 HOWTO (R_AVR_LO8_LDI_NEG, /* type */
189 0, /* rightshift */
190 1, /* size (0 = byte, 1 = short, 2 = long) */
191 8, /* bitsize */
192 false, /* pc_relative */
193 0, /* bitpos */
194 complain_overflow_dont, /* complain_on_overflow */
195 bfd_elf_generic_reloc, /* special_function */
196 "R_AVR_LO8_LDI_NEG", /* name */
197 false, /* partial_inplace */
198 0xffff, /* src_mask */
199 0xffff, /* dst_mask */
200 false), /* pcrel_offset */
201 /* A hegative high 8 bit absolute relocation of 16 bit address.
202 For LDI command. */
203 HOWTO (R_AVR_HI8_LDI_NEG, /* type */
204 8, /* rightshift */
205 1, /* size (0 = byte, 1 = short, 2 = long) */
206 8, /* bitsize */
207 false, /* pc_relative */
208 0, /* bitpos */
209 complain_overflow_dont, /* complain_on_overflow */
210 bfd_elf_generic_reloc, /* special_function */
211 "R_AVR_HI8_LDI_NEG", /* name */
212 false, /* partial_inplace */
213 0xffff, /* src_mask */
214 0xffff, /* dst_mask */
215 false), /* pcrel_offset */
216 /* A hegative high 6 bit absolute relocation of 22 bit address.
217 For LDI command. */
218 HOWTO (R_AVR_HH8_LDI_NEG, /* type */
219 16, /* rightshift */
220 1, /* size (0 = byte, 1 = short, 2 = long) */
221 8, /* bitsize */
222 false, /* pc_relative */
223 0, /* bitpos */
224 complain_overflow_dont, /* complain_on_overflow */
225 bfd_elf_generic_reloc, /* special_function */
226 "R_AVR_HH8_LDI_NEG", /* name */
227 false, /* partial_inplace */
228 0xffff, /* src_mask */
229 0xffff, /* dst_mask */
230 false), /* pcrel_offset */
231 /* A low 8 bit absolute relocation of 24 bit program memory address.
232 For LDI command. */
233 HOWTO (R_AVR_LO8_LDI_PM, /* type */
234 1, /* rightshift */
235 1, /* size (0 = byte, 1 = short, 2 = long) */
236 8, /* bitsize */
237 false, /* pc_relative */
238 0, /* bitpos */
239 complain_overflow_dont, /* complain_on_overflow */
240 bfd_elf_generic_reloc, /* special_function */
241 "R_AVR_LO8_LDI_PM", /* name */
242 false, /* partial_inplace */
243 0xffff, /* src_mask */
244 0xffff, /* dst_mask */
245 false), /* pcrel_offset */
246 /* A high 8 bit absolute relocation of 16 bit program memory address.
247 For LDI command. */
248 HOWTO (R_AVR_HI8_LDI_PM, /* type */
249 9, /* rightshift */
250 1, /* size (0 = byte, 1 = short, 2 = long) */
251 8, /* bitsize */
252 false, /* pc_relative */
253 0, /* bitpos */
254 complain_overflow_dont, /* complain_on_overflow */
255 bfd_elf_generic_reloc, /* special_function */
256 "R_AVR_HI8_LDI_PM", /* name */
257 false, /* partial_inplace */
258 0xffff, /* src_mask */
259 0xffff, /* dst_mask */
260 false), /* pcrel_offset */
261 /* A high 8 bit absolute relocation of 24 bit program memory address.
262 For LDI command. */
263 HOWTO (R_AVR_HH8_LDI_PM, /* type */
264 17, /* rightshift */
265 1, /* size (0 = byte, 1 = short, 2 = long) */
266 8, /* bitsize */
267 false, /* pc_relative */
268 0, /* bitpos */
269 complain_overflow_dont, /* complain_on_overflow */
270 bfd_elf_generic_reloc, /* special_function */
271 "R_AVR_HH8_LDI_PM", /* name */
272 false, /* partial_inplace */
273 0xffff, /* src_mask */
274 0xffff, /* dst_mask */
275 false), /* pcrel_offset */
276 /* A low 8 bit absolute relocation of a negative 24 bit
277 program memory address. For LDI command. */
278 HOWTO (R_AVR_LO8_LDI_PM_NEG, /* type */
279 1, /* rightshift */
280 1, /* size (0 = byte, 1 = short, 2 = long) */
281 8, /* bitsize */
282 false, /* pc_relative */
283 0, /* bitpos */
284 complain_overflow_dont, /* complain_on_overflow */
285 bfd_elf_generic_reloc, /* special_function */
286 "R_AVR_LO8_LDI_PM_NEG", /* name */
287 false, /* partial_inplace */
288 0xffff, /* src_mask */
289 0xffff, /* dst_mask */
290 false), /* pcrel_offset */
291 /* A high 8 bit absolute relocation of a negative 16 bit
292 program memory address. For LDI command. */
293 HOWTO (R_AVR_HI8_LDI_PM_NEG, /* type */
294 9, /* rightshift */
295 1, /* size (0 = byte, 1 = short, 2 = long) */
296 8, /* bitsize */
297 false, /* pc_relative */
298 0, /* bitpos */
299 complain_overflow_dont, /* complain_on_overflow */
300 bfd_elf_generic_reloc, /* special_function */
301 "R_AVR_HI8_LDI_PM_NEG", /* name */
302 false, /* partial_inplace */
303 0xffff, /* src_mask */
304 0xffff, /* dst_mask */
305 false), /* pcrel_offset */
306 /* A high 8 bit absolute relocation of a negative 24 bit
307 program memory address. For LDI command. */
308 HOWTO (R_AVR_HH8_LDI_PM_NEG, /* type */
309 17, /* rightshift */
310 1, /* size (0 = byte, 1 = short, 2 = long) */
311 8, /* bitsize */
312 false, /* pc_relative */
313 0, /* bitpos */
314 complain_overflow_dont, /* complain_on_overflow */
315 bfd_elf_generic_reloc, /* special_function */
316 "R_AVR_HH8_LDI_PM_NEG", /* name */
317 false, /* partial_inplace */
318 0xffff, /* src_mask */
319 0xffff, /* dst_mask */
320 false), /* pcrel_offset */
321 /* Relocation for CALL command in ATmega. */
322 HOWTO (R_AVR_CALL, /* type */
323 1, /* rightshift */
324 2, /* size (0 = byte, 1 = short, 2 = long) */
325 23, /* bitsize */
326 false, /* pc_relative */
327 0, /* bitpos */
328 complain_overflow_dont, /* complain_on_overflow */
329 bfd_elf_generic_reloc, /* special_function */
330 "R_AVR_CALL", /* name */
331 false, /* partial_inplace */
332 0xffffffff, /* src_mask */
333 0xffffffff, /* dst_mask */
334 false) /* pcrel_offset */
335 };
336
337 /* Map BFD reloc types to AVR ELF reloc types. */
338
339 struct avr_reloc_map
340 {
341 bfd_reloc_code_real_type bfd_reloc_val;
342 unsigned int elf_reloc_val;
343 };
344
345 static const struct avr_reloc_map avr_reloc_map[] =
346 {
347 { BFD_RELOC_NONE, R_AVR_NONE },
348 { BFD_RELOC_32, R_AVR_32 },
349 { BFD_RELOC_AVR_7_PCREL, R_AVR_7_PCREL },
350 { BFD_RELOC_AVR_13_PCREL, R_AVR_13_PCREL },
351 { BFD_RELOC_16, R_AVR_16 },
352 { BFD_RELOC_AVR_16_PM, R_AVR_16_PM },
353 { BFD_RELOC_AVR_LO8_LDI, R_AVR_LO8_LDI},
354 { BFD_RELOC_AVR_HI8_LDI, R_AVR_HI8_LDI },
355 { BFD_RELOC_AVR_HH8_LDI, R_AVR_HH8_LDI },
356 { BFD_RELOC_AVR_LO8_LDI_NEG, R_AVR_LO8_LDI_NEG },
357 { BFD_RELOC_AVR_HI8_LDI_NEG, R_AVR_HI8_LDI_NEG },
358 { BFD_RELOC_AVR_HH8_LDI_NEG, R_AVR_HH8_LDI_NEG },
359 { BFD_RELOC_AVR_LO8_LDI_PM, R_AVR_LO8_LDI_PM },
360 { BFD_RELOC_AVR_HI8_LDI_PM, R_AVR_HI8_LDI_PM },
361 { BFD_RELOC_AVR_HH8_LDI_PM, R_AVR_HH8_LDI_PM },
362 { BFD_RELOC_AVR_LO8_LDI_PM_NEG, R_AVR_LO8_LDI_PM_NEG },
363 { BFD_RELOC_AVR_HI8_LDI_PM_NEG, R_AVR_HI8_LDI_PM_NEG },
364 { BFD_RELOC_AVR_HH8_LDI_PM_NEG, R_AVR_HH8_LDI_PM_NEG },
365 { BFD_RELOC_AVR_CALL, R_AVR_CALL }
366 };
367
368 static reloc_howto_type *
369 bfd_elf32_bfd_reloc_type_lookup (abfd, code)
370 bfd *abfd ATTRIBUTE_UNUSED;
371 bfd_reloc_code_real_type code;
372 {
373 unsigned int i;
374
375 for (i = 0;
376 i < sizeof (avr_reloc_map) / sizeof (struct avr_reloc_map);
377 i++)
378 {
379 if (avr_reloc_map[i].bfd_reloc_val == code)
380 return &elf_avr_howto_table[avr_reloc_map[i].elf_reloc_val];
381 }
382
383 return NULL;
384 }
385
386 /* Set the howto pointer for an AVR ELF reloc. */
387
388 static void
389 avr_info_to_howto_rela (abfd, cache_ptr, dst)
390 bfd *abfd ATTRIBUTE_UNUSED;
391 arelent *cache_ptr;
392 Elf32_Internal_Rela *dst;
393 {
394 unsigned int r_type;
395
396 r_type = ELF32_R_TYPE (dst->r_info);
397 BFD_ASSERT (r_type < (unsigned int) R_AVR_max);
398 cache_ptr->howto = &elf_avr_howto_table[r_type];
399 }
400
401 static asection *
402 elf32_avr_gc_mark_hook (abfd, info, rel, h, sym)
403 bfd *abfd;
404 struct bfd_link_info *info ATTRIBUTE_UNUSED;
405 Elf_Internal_Rela *rel;
406 struct elf_link_hash_entry *h;
407 Elf_Internal_Sym *sym;
408 {
409 if (h != NULL)
410 {
411 switch (ELF32_R_TYPE (rel->r_info))
412 {
413 default:
414 switch (h->root.type)
415 {
416 case bfd_link_hash_defined:
417 case bfd_link_hash_defweak:
418 return h->root.u.def.section;
419
420 case bfd_link_hash_common:
421 return h->root.u.c.p->section;
422
423 default:
424 break;
425 }
426 }
427 }
428 else
429 {
430 return bfd_section_from_elf_index (abfd, sym->st_shndx);
431 }
432
433 return NULL;
434 }
435
436 static boolean
437 elf32_avr_gc_sweep_hook (abfd, info, sec, relocs)
438 bfd *abfd ATTRIBUTE_UNUSED;
439 struct bfd_link_info *info ATTRIBUTE_UNUSED;
440 asection *sec ATTRIBUTE_UNUSED;
441 const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
442 {
443 /* We don't use got and plt entries for avr. */
444 return true;
445 }
446
447 /* Look through the relocs for a section during the first phase.
448 Since we don't do .gots or .plts, we just need to consider the
449 virtual table relocs for gc. */
450
451 static boolean
452 elf32_avr_check_relocs (abfd, info, sec, relocs)
453 bfd *abfd;
454 struct bfd_link_info *info;
455 asection *sec;
456 const Elf_Internal_Rela *relocs;
457 {
458 Elf_Internal_Shdr *symtab_hdr;
459 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
460 const Elf_Internal_Rela *rel;
461 const Elf_Internal_Rela *rel_end;
462
463 if (info->relocateable)
464 return true;
465
466 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
467 sym_hashes = elf_sym_hashes (abfd);
468 sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof (Elf32_External_Sym);
469 if (!elf_bad_symtab (abfd))
470 sym_hashes_end -= symtab_hdr->sh_info;
471
472 rel_end = relocs + sec->reloc_count;
473 for (rel = relocs; rel < rel_end; rel++)
474 {
475 struct elf_link_hash_entry *h;
476 unsigned long r_symndx;
477
478 r_symndx = ELF32_R_SYM (rel->r_info);
479 if (r_symndx < symtab_hdr->sh_info)
480 h = NULL;
481 else
482 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
483 }
484
485 return true;
486 }
487
488 /* Perform a single relocation. By default we use the standard BFD
489 routines, but a few relocs, we have to do them ourselves. */
490
491 static bfd_reloc_status_type
492 avr_final_link_relocate (howto, input_bfd, input_section,
493 contents, rel, relocation)
494 reloc_howto_type * howto;
495 bfd * input_bfd;
496 asection * input_section;
497 bfd_byte * contents;
498 Elf_Internal_Rela * rel;
499 bfd_vma relocation;
500 {
501 bfd_reloc_status_type r = bfd_reloc_ok;
502 bfd_vma x;
503 bfd_signed_vma srel;
504
505 switch (howto->type)
506 {
507 case R_AVR_7_PCREL:
508 contents += rel->r_offset;
509 srel = (bfd_signed_vma) relocation;
510 srel += rel->r_addend;
511 srel -= rel->r_offset;
512 srel -= 2; /* Branch instructions add 2 to the PC... */
513 srel -= (input_section->output_section->vma +
514 input_section->output_offset);
515
516 if (srel & 1)
517 return bfd_reloc_outofrange;
518 if (srel > ((1 << 7) - 1) || (srel < - (1 << 7)))
519 return bfd_reloc_overflow;
520 x = bfd_get_16 (input_bfd, contents);
521 x = (x & 0xfc07) | (((srel >> 1) << 3) & 0x3f8);
522 bfd_put_16 (input_bfd, x, contents);
523 break;
524
525 case R_AVR_13_PCREL:
526 contents += rel->r_offset;
527 srel = (bfd_signed_vma) relocation;
528 srel += rel->r_addend;
529 srel -= rel->r_offset;
530 srel -= 2; /* Branch instructions add 2 to the PC... */
531 srel -= (input_section->output_section->vma +
532 input_section->output_offset);
533
534 if (srel & 1)
535 return bfd_reloc_outofrange;
536
537 /* AVR addresses commands as words. */
538 srel >>= 1;
539
540 /* Check for overflow. */
541 if (srel < -2048 || srel > 2047)
542 {
543 /* Apply WRAPAROUND if possible. */
544 switch (bfd_get_mach (input_bfd))
545 {
546 case bfd_mach_avr2:
547 case bfd_mach_avr4:
548 break;
549
550 default:
551 return bfd_reloc_overflow;
552 }
553 }
554
555 x = bfd_get_16 (input_bfd, contents);
556 x = (x & 0xf000) | (srel & 0xfff);
557 bfd_put_16 (input_bfd, x, contents);
558 break;
559
560 case R_AVR_LO8_LDI:
561 contents += rel->r_offset;
562 srel = (bfd_signed_vma) relocation + rel->r_addend;
563 x = bfd_get_16 (input_bfd, contents);
564 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
565 bfd_put_16 (input_bfd, x, contents);
566 break;
567
568 case R_AVR_HI8_LDI:
569 contents += rel->r_offset;
570 srel = (bfd_signed_vma) relocation + rel->r_addend;
571 srel = (srel >> 8) & 0xff;
572 x = bfd_get_16 (input_bfd, contents);
573 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
574 bfd_put_16 (input_bfd, x, contents);
575 break;
576
577 case R_AVR_HH8_LDI:
578 contents += rel->r_offset;
579 srel = (bfd_signed_vma) relocation + rel->r_addend;
580 srel = (srel >> 16) & 0xff;
581 x = bfd_get_16 (input_bfd, contents);
582 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
583 bfd_put_16 (input_bfd, x, contents);
584 break;
585
586 case R_AVR_LO8_LDI_NEG:
587 contents += rel->r_offset;
588 srel = (bfd_signed_vma) relocation + rel->r_addend;
589 srel = -srel;
590 x = bfd_get_16 (input_bfd, contents);
591 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
592 bfd_put_16 (input_bfd, x, contents);
593 break;
594
595 case R_AVR_HI8_LDI_NEG:
596 contents += rel->r_offset;
597 srel = (bfd_signed_vma) relocation + rel->r_addend;
598 srel = -srel;
599 srel = (srel >> 8) & 0xff;
600 x = bfd_get_16 (input_bfd, contents);
601 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
602 bfd_put_16 (input_bfd, x, contents);
603 break;
604
605 case R_AVR_HH8_LDI_NEG:
606 contents += rel->r_offset;
607 srel = (bfd_signed_vma) relocation + rel->r_addend;
608 srel = -srel;
609 srel = (srel >> 16) & 0xff;
610 x = bfd_get_16 (input_bfd, contents);
611 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
612 bfd_put_16 (input_bfd, x, contents);
613 break;
614
615 case R_AVR_LO8_LDI_PM:
616 contents += rel->r_offset;
617 srel = (bfd_signed_vma) relocation + rel->r_addend;
618 if (srel & 1)
619 return bfd_reloc_outofrange;
620 srel = srel >> 1;
621 x = bfd_get_16 (input_bfd, contents);
622 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
623 bfd_put_16 (input_bfd, x, contents);
624 break;
625
626 case R_AVR_HI8_LDI_PM:
627 contents += rel->r_offset;
628 srel = (bfd_signed_vma) relocation + rel->r_addend;
629 if (srel & 1)
630 return bfd_reloc_outofrange;
631 srel = srel >> 1;
632 srel = (srel >> 8) & 0xff;
633 x = bfd_get_16 (input_bfd, contents);
634 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
635 bfd_put_16 (input_bfd, x, contents);
636 break;
637
638 case R_AVR_HH8_LDI_PM:
639 contents += rel->r_offset;
640 srel = (bfd_signed_vma) relocation + rel->r_addend;
641 if (srel & 1)
642 return bfd_reloc_outofrange;
643 srel = srel >> 1;
644 srel = (srel >> 16) & 0xff;
645 x = bfd_get_16 (input_bfd, contents);
646 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
647 bfd_put_16 (input_bfd, x, contents);
648 break;
649
650 case R_AVR_LO8_LDI_PM_NEG:
651 contents += rel->r_offset;
652 srel = (bfd_signed_vma) relocation + rel->r_addend;
653 srel = -srel;
654 if (srel & 1)
655 return bfd_reloc_outofrange;
656 srel = srel >> 1;
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_HI8_LDI_PM_NEG:
663 contents += rel->r_offset;
664 srel = (bfd_signed_vma) relocation + rel->r_addend;
665 srel = -srel;
666 if (srel & 1)
667 return bfd_reloc_outofrange;
668 srel = srel >> 1;
669 srel = (srel >> 8) & 0xff;
670 x = bfd_get_16 (input_bfd, contents);
671 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
672 bfd_put_16 (input_bfd, x, contents);
673 break;
674
675 case R_AVR_HH8_LDI_PM_NEG:
676 contents += rel->r_offset;
677 srel = (bfd_signed_vma) relocation + rel->r_addend;
678 srel = -srel;
679 if (srel & 1)
680 return bfd_reloc_outofrange;
681 srel = srel >> 1;
682 srel = (srel >> 16) & 0xff;
683 x = bfd_get_16 (input_bfd, contents);
684 x = (x & 0xf0f0) | (srel & 0xf) | ((srel << 4) & 0xf00);
685 bfd_put_16 (input_bfd, x, contents);
686 break;
687
688 case R_AVR_CALL:
689 contents += rel->r_offset;
690 srel = (bfd_signed_vma) relocation + rel->r_addend;
691 if (srel & 1)
692 return bfd_reloc_outofrange;
693 srel = srel >> 1;
694 x = bfd_get_16 (input_bfd, contents);
695 x |= ((srel & 0x10000) | ((srel << 3) & 0x1f00000)) >> 16;
696 bfd_put_16 (input_bfd, x, contents);
697 bfd_put_16 (input_bfd, (bfd_vma) srel & 0xffff, contents+2);
698 break;
699
700 default:
701 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
702 contents, rel->r_offset,
703 relocation, rel->r_addend);
704 }
705
706 return r;
707 }
708
709 /* Relocate an AVR ELF section. */
710 static boolean
711 elf32_avr_relocate_section (output_bfd, info, input_bfd, input_section,
712 contents, relocs, local_syms, local_sections)
713 bfd *output_bfd ATTRIBUTE_UNUSED;
714 struct bfd_link_info *info;
715 bfd *input_bfd;
716 asection *input_section;
717 bfd_byte *contents;
718 Elf_Internal_Rela *relocs;
719 Elf_Internal_Sym *local_syms;
720 asection **local_sections;
721 {
722 Elf_Internal_Shdr * symtab_hdr;
723 struct elf_link_hash_entry ** sym_hashes;
724 Elf_Internal_Rela * rel;
725 Elf_Internal_Rela * relend;
726
727 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
728 sym_hashes = elf_sym_hashes (input_bfd);
729 relend = relocs + input_section->reloc_count;
730
731 for (rel = relocs; rel < relend; rel ++)
732 {
733 reloc_howto_type * howto;
734 unsigned long r_symndx;
735 Elf_Internal_Sym * sym;
736 asection * sec;
737 struct elf_link_hash_entry * h;
738 bfd_vma relocation;
739 bfd_reloc_status_type r;
740 const char * name = NULL;
741 int r_type;
742
743 r_type = ELF32_R_TYPE (rel->r_info);
744 r_symndx = ELF32_R_SYM (rel->r_info);
745
746 if (info->relocateable)
747 {
748 /* This is a relocateable link. We don't have to change
749 anything, unless the reloc is against a section symbol,
750 in which case we have to adjust according to where the
751 section symbol winds up in the output section. */
752 if (r_symndx < symtab_hdr->sh_info)
753 {
754 sym = local_syms + r_symndx;
755
756 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
757 {
758 sec = local_sections [r_symndx];
759 rel->r_addend += sec->output_offset + sym->st_value;
760 }
761 }
762
763 continue;
764 }
765
766 /* This is a final link. */
767 howto = elf_avr_howto_table + ELF32_R_TYPE (rel->r_info);
768 h = NULL;
769 sym = NULL;
770 sec = NULL;
771
772 if (r_symndx < symtab_hdr->sh_info)
773 {
774 sym = local_syms + r_symndx;
775 sec = local_sections [r_symndx];
776 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, sec, rel);
777
778 name = bfd_elf_string_from_elf_section
779 (input_bfd, symtab_hdr->sh_link, sym->st_name);
780 name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
781 }
782 else
783 {
784 h = sym_hashes [r_symndx - symtab_hdr->sh_info];
785
786 while (h->root.type == bfd_link_hash_indirect
787 || h->root.type == bfd_link_hash_warning)
788 h = (struct elf_link_hash_entry *) h->root.u.i.link;
789
790 name = h->root.root.string;
791
792 if (h->root.type == bfd_link_hash_defined
793 || h->root.type == bfd_link_hash_defweak)
794 {
795 sec = h->root.u.def.section;
796 relocation = (h->root.u.def.value
797 + sec->output_section->vma
798 + sec->output_offset);
799 }
800 else if (h->root.type == bfd_link_hash_undefweak)
801 {
802 relocation = 0;
803 }
804 else
805 {
806 if (! ((*info->callbacks->undefined_symbol)
807 (info, h->root.root.string, input_bfd,
808 input_section, rel->r_offset, true)))
809 return false;
810 relocation = 0;
811 }
812 }
813
814 r = avr_final_link_relocate (howto, input_bfd, input_section,
815 contents, rel, relocation);
816
817 if (r != bfd_reloc_ok)
818 {
819 const char * msg = (const char *) NULL;
820
821 switch (r)
822 {
823 case bfd_reloc_overflow:
824 r = info->callbacks->reloc_overflow
825 (info, name, howto->name, (bfd_vma) 0,
826 input_bfd, input_section, rel->r_offset);
827 break;
828
829 case bfd_reloc_undefined:
830 r = info->callbacks->undefined_symbol
831 (info, name, input_bfd, input_section, rel->r_offset, true);
832 break;
833
834 case bfd_reloc_outofrange:
835 msg = _("internal error: out of range error");
836 break;
837
838 case bfd_reloc_notsupported:
839 msg = _("internal error: unsupported relocation error");
840 break;
841
842 case bfd_reloc_dangerous:
843 msg = _("internal error: dangerous relocation");
844 break;
845
846 default:
847 msg = _("internal error: unknown error");
848 break;
849 }
850
851 if (msg)
852 r = info->callbacks->warning
853 (info, msg, name, input_bfd, input_section, rel->r_offset);
854
855 if (! r)
856 return false;
857 }
858 }
859
860 return true;
861 }
862
863 /* The final processing done just before writing out a AVR ELF object
864 file. This gets the AVR architecture right based on the machine
865 number. */
866
867 static void
868 bfd_elf_avr_final_write_processing (abfd, linker)
869 bfd *abfd;
870 boolean linker ATTRIBUTE_UNUSED;
871 {
872 unsigned long val;
873
874 switch (bfd_get_mach (abfd))
875 {
876 default:
877 case bfd_mach_avr2:
878 val = E_AVR_MACH_AVR2;
879 break;
880
881 case bfd_mach_avr1:
882 val = E_AVR_MACH_AVR1;
883 break;
884
885 case bfd_mach_avr3:
886 val = E_AVR_MACH_AVR3;
887 break;
888
889 case bfd_mach_avr4:
890 val = E_AVR_MACH_AVR4;
891 break;
892
893 case bfd_mach_avr5:
894 val = E_AVR_MACH_AVR5;
895 break;
896 }
897
898 elf_elfheader (abfd)->e_machine = EM_AVR;
899 elf_elfheader (abfd)->e_flags &= ~ EF_AVR_MACH;
900 elf_elfheader (abfd)->e_flags |= val;
901 }
902
903 /* Set the right machine number. */
904
905 static boolean
906 elf32_avr_object_p (abfd)
907 bfd *abfd;
908 {
909 unsigned int e_set = bfd_mach_avr2;
910 if (elf_elfheader (abfd)->e_machine == EM_AVR
911 || elf_elfheader (abfd)->e_machine == EM_AVR_OLD)
912 {
913 int e_mach = elf_elfheader (abfd)->e_flags & EF_AVR_MACH;
914 switch (e_mach)
915 {
916 default:
917 case E_AVR_MACH_AVR2:
918 e_set = bfd_mach_avr2;
919 break;
920
921 case E_AVR_MACH_AVR1:
922 e_set = bfd_mach_avr1;
923 break;
924
925 case E_AVR_MACH_AVR3:
926 e_set = bfd_mach_avr3;
927 break;
928
929 case E_AVR_MACH_AVR4:
930 e_set = bfd_mach_avr4;
931 break;
932
933 case E_AVR_MACH_AVR5:
934 e_set = bfd_mach_avr5;
935 break;
936 }
937 }
938 return bfd_default_set_arch_mach (abfd, bfd_arch_avr,
939 e_set);
940 }
941
942 #define ELF_ARCH bfd_arch_avr
943 #define ELF_MACHINE_CODE EM_AVR
944 #define ELF_MACHINE_ALT1 EM_AVR_OLD
945 #define ELF_MAXPAGESIZE 1
946
947 #define TARGET_LITTLE_SYM bfd_elf32_avr_vec
948 #define TARGET_LITTLE_NAME "elf32-avr"
949
950 #define elf_info_to_howto avr_info_to_howto_rela
951 #define elf_info_to_howto_rel NULL
952 #define elf_backend_relocate_section elf32_avr_relocate_section
953 #define elf_backend_gc_mark_hook elf32_avr_gc_mark_hook
954 #define elf_backend_gc_sweep_hook elf32_avr_gc_sweep_hook
955 #define elf_backend_check_relocs elf32_avr_check_relocs
956 #define elf_backend_can_gc_sections 1
957 #define elf_backend_final_write_processing \
958 bfd_elf_avr_final_write_processing
959 #define elf_backend_object_p elf32_avr_object_p
960
961 #include "elf32-target.h"
git-cvsimport of binutils cvsroot