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