Automatic date update in version.in
[external/binutils.git] / bfd / elf32-xc16x.c
1 /* Infineon XC16X-specific support for 16-bit ELF.
2    Copyright (C) 2006-2018 Free Software Foundation, Inc.
3    Contributed by KPIT Cummins Infosystems
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 3 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, 51 Franklin Street - Fifth Floor, Boston,
20    MA 02110-1301, USA.  */
21
22 #include "sysdep.h"
23 #include "bfd.h"
24 #include "libbfd.h"
25 #include "elf-bfd.h"
26 #include "elf/xc16x.h"
27 #include "dwarf2.h"
28 #include "libiberty.h"
29
30 static reloc_howto_type xc16x_elf_howto_table [] =
31 {
32   /* This reloc does nothing.  */
33   HOWTO (R_XC16X_NONE,          /* type */
34          0,                     /* rightshift */
35          3,                     /* size (0 = byte, 1 = short, 2 = long) */
36          0,                     /* bitsize */
37          FALSE,                 /* pc_relative */
38          0,                     /* bitpos */
39          complain_overflow_dont, /* complain_on_overflow */
40          bfd_elf_generic_reloc, /* special_function */
41          "R_XC16X_NONE",        /* name */
42          FALSE,                 /* partial_inplace */
43          0,                     /* src_mask */
44          0,                     /* dst_mask */
45          FALSE),                /* pcrel_offset */
46
47   /* An 8 bit absolute relocation.  */
48   HOWTO (R_XC16X_ABS_8,         /* type */
49          0,                     /* rightshift */
50          0,                     /* size (0 = byte, 1 = short, 2 = long) */
51          8,                     /* bitsize */
52          FALSE,                 /* pc_relative */
53          8,                     /* bitpos */
54          complain_overflow_bitfield, /* complain_on_overflow */
55          bfd_elf_generic_reloc, /* special_function */
56          "R_XC16X_ABS_8",       /* name */
57          TRUE,                  /* partial_inplace */
58          0x0000,                /* src_mask */
59          0x00ff,                /* dst_mask */
60          FALSE),                /* pcrel_offset */
61
62   /* A 16 bit absolute relocation.  */
63   HOWTO (R_XC16X_ABS_16,        /* type */
64          0,                     /* rightshift */
65          1,                     /* size (0 = byte, 1 = short, 2 = long) */
66          16,                    /* bitsize */
67          FALSE,                 /* pc_relative */
68          0,                     /* bitpos */
69          complain_overflow_dont, /* complain_on_overflow */
70          bfd_elf_generic_reloc, /* special_function */
71          "R_XC16X_ABS_16",      /* name */
72          TRUE,                  /* partial_inplace */
73          0x00000000,            /* src_mask */
74          0x0000ffff,            /* dst_mask */
75          FALSE),                /* pcrel_offset */
76
77   HOWTO (R_XC16X_ABS_32,        /* type */
78          0,                     /* rightshift */
79          2,                     /* size (0 = byte, 1 = short, 2 = long) */
80          32,                    /* bitsize */
81          FALSE,                 /* pc_relative */
82          0,                     /* bitpos */
83          complain_overflow_bitfield, /* complain_on_overflow */
84          bfd_elf_generic_reloc, /* special_function */
85          "R_XC16X_ABS_32",      /* name */
86          TRUE,                  /* partial_inplace */
87          0x00000000,            /* src_mask */
88          0xffffffff,            /* dst_mask */
89          FALSE),                /* pcrel_offset */
90
91
92   /* A PC relative 8 bit relocation.  */
93   HOWTO (R_XC16X_8_PCREL,       /* type */
94          0,                     /* rightshift */
95          0,                     /* size (0 = byte, 1 = short, 2 = long) */
96          8,                     /* bitsize */
97          TRUE,                  /* pc_relative */
98          8,                     /* bitpos */
99          complain_overflow_signed, /* complain_on_overflow */
100          bfd_elf_generic_reloc, /* special_function */
101          "R_XC16X_8_PCREL",     /* name */
102          FALSE,                 /* partial_inplace */
103          0x0000,                /* src_mask */
104          0x00ff,                /* dst_mask */
105          TRUE),         /* pcrel_offset */
106
107   /* Relocation regarding page number.  */
108     HOWTO (R_XC16X_PAG, /* type */
109          0,                     /* rightshift */
110          1,                     /* size (0 = byte, 1 = short, 2 = long) */
111          16,                    /* bitsize */
112          FALSE,                 /* pc_relative */
113          0,                     /* bitpos */
114          complain_overflow_signed, /* complain_on_overflow */
115          bfd_elf_generic_reloc, /* special_function */
116          "R_XC16X_PAG", /* name */
117          TRUE,                  /* partial_inplace */
118          0x00000000,            /* src_mask */
119          0x0000ffff,            /* dst_mask */
120          FALSE),                /* pcrel_offset */
121
122
123   /* Relocation regarding page number.  */
124       HOWTO (R_XC16X_POF,       /* type */
125          0,                     /* rightshift */
126          1,                     /* size (0 = byte, 1 = short, 2 = long) */
127          16,                    /* bitsize */
128          FALSE,                 /* pc_relative */
129          0,                     /* bitpos  */
130          complain_overflow_signed, /* complain_on_overflow  */
131          bfd_elf_generic_reloc, /* special_function  */
132          "R_XC16X_POF", /* name  */
133          TRUE,                  /* partial_inplace  */
134          0x00000000,            /* src_mask  */
135          0x0000ffff,            /* dst_mask  */
136          FALSE),                /* pcrel_offset  */
137
138
139   /* Relocation regarding segment number.   */
140       HOWTO (R_XC16X_SEG,       /* type  */
141          0,                     /* rightshift  */
142          1,                     /* size (0 = byte, 1 = short, 2 = long)  */
143          16,                    /* bitsize  */
144          FALSE,                 /* pc_relative  */
145          0,                     /* bitpos  */
146          complain_overflow_signed, /* complain_on_overflow  */
147          bfd_elf_generic_reloc, /* special_function  */
148          "R_XC16X_SEG", /* name  */
149          TRUE,                  /* partial_inplace  */
150          0x00000000,            /* src_mask  */
151          0x0000ffff,            /* dst_mask  */
152          FALSE),                /* pcrel_offset  */
153
154   /* Relocation regarding segment offset.  */
155       HOWTO (R_XC16X_SOF,       /* type  */
156          0,                     /* rightshift  */
157          1,                     /* size (0 = byte, 1 = short, 2 = long)  */
158          16,                    /* bitsize  */
159          FALSE,                 /* pc_relative  */
160          0,                     /* bitpos  */
161          complain_overflow_signed, /* complain_on_overflow  */
162          bfd_elf_generic_reloc, /* special_function  */
163          "R_XC16X_SOF", /* name */
164          TRUE,                  /* partial_inplace  */
165          0x00000000,            /* src_mask  */
166          0x0000ffff,            /* dst_mask  */
167          FALSE)                 /* pcrel_offset  */
168 };
169
170
171 /* Map BFD reloc types to XC16X ELF reloc types.  */
172
173 struct xc16x_reloc_map
174 {
175   bfd_reloc_code_real_type bfd_reloc_val;
176   unsigned int xc16x_reloc_val;
177 };
178
179 static const struct xc16x_reloc_map xc16x_reloc_map [] =
180 {
181   { BFD_RELOC_NONE,           R_XC16X_NONE },
182   { BFD_RELOC_8,              R_XC16X_ABS_8 },
183   { BFD_RELOC_16,             R_XC16X_ABS_16 },
184   { BFD_RELOC_32,             R_XC16X_ABS_32 },
185   { BFD_RELOC_8_PCREL,        R_XC16X_8_PCREL },
186   { BFD_RELOC_XC16X_PAG,      R_XC16X_PAG},
187   { BFD_RELOC_XC16X_POF,      R_XC16X_POF},
188   { BFD_RELOC_XC16X_SEG,      R_XC16X_SEG},
189   { BFD_RELOC_XC16X_SOF,      R_XC16X_SOF},
190 };
191
192
193 /* This function is used to search for correct relocation type from
194    howto structure.  */
195
196 static reloc_howto_type *
197 xc16x_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
198                          bfd_reloc_code_real_type code)
199 {
200   unsigned int i;
201
202   for (i = ARRAY_SIZE (xc16x_reloc_map); --i;)
203     if (xc16x_reloc_map [i].bfd_reloc_val == code)
204       return & xc16x_elf_howto_table [xc16x_reloc_map[i].xc16x_reloc_val];
205
206   return NULL;
207 }
208
209 static reloc_howto_type *
210 xc16x_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
211                          const char *r_name)
212 {
213   unsigned int i;
214
215   for (i = 0; i < ARRAY_SIZE (xc16x_elf_howto_table); i++)
216     if (xc16x_elf_howto_table[i].name != NULL
217         && strcasecmp (xc16x_elf_howto_table[i].name, r_name) == 0)
218       return &xc16x_elf_howto_table[i];
219
220   return NULL;
221 }
222
223 /* For a particular operand this function is
224    called to finalise the type of relocation.  */
225
226 static bfd_boolean
227 elf32_xc16x_info_to_howto (bfd *abfd, arelent *bfd_reloc,
228                            Elf_Internal_Rela *elf_reloc)
229 {
230   unsigned int r;
231   unsigned int i;
232
233   r = ELF32_R_TYPE (elf_reloc->r_info);
234   for (i = 0; i < ARRAY_SIZE (xc16x_elf_howto_table); i++)
235     if (xc16x_elf_howto_table[i].type == r)
236       {
237         bfd_reloc->howto = &xc16x_elf_howto_table[i];
238         return TRUE;
239       }
240   /* xgettext:c-format */
241   _bfd_error_handler (_("%pB: unsupported relocation type %#x"), abfd, r);
242   bfd_set_error (bfd_error_bad_value);
243   return FALSE;
244 }
245
246 static bfd_reloc_status_type
247 elf32_xc16x_final_link_relocate (unsigned long r_type,
248                                  bfd *input_bfd,
249                                  bfd *output_bfd ATTRIBUTE_UNUSED,
250                                  asection *input_section ATTRIBUTE_UNUSED,
251                                  bfd_byte *contents,
252                                  bfd_vma offset,
253                                  bfd_vma value,
254                                  bfd_vma addend,
255                                  struct bfd_link_info *info ATTRIBUTE_UNUSED,
256                                  asection *sym_sec ATTRIBUTE_UNUSED,
257                                  int is_local ATTRIBUTE_UNUSED)
258 {
259   bfd_byte *hit_data = contents + offset;
260   bfd_vma val1;
261
262   switch (r_type)
263     {
264     case R_XC16X_NONE:
265       return bfd_reloc_ok;
266
267     case R_XC16X_ABS_16:
268       value += addend;
269       bfd_put_16 (input_bfd, value, hit_data);
270       return bfd_reloc_ok;
271
272     case R_XC16X_8_PCREL:
273       bfd_put_8 (input_bfd, value, hit_data);
274       return bfd_reloc_ok;
275
276       /* Following case is to find page number from actual
277          address for this divide value by 16k i.e. page size.  */
278
279     case R_XC16X_PAG:
280       value += addend;
281       value /= 0x4000;
282       bfd_put_16 (input_bfd, value, hit_data);
283       return bfd_reloc_ok;
284
285       /* Following case is to find page offset from actual address
286          for this take modulo of value by 16k i.e. page size.  */
287
288     case R_XC16X_POF:
289       value += addend;
290       value %= 0x4000;
291       bfd_put_16 (input_bfd, value, hit_data);
292       return bfd_reloc_ok;
293
294       /* Following case is to find segment number from actual
295          address for this divide value by 64k i.e. segment size.  */
296
297     case R_XC16X_SEG:
298       value += addend;
299       value /= 0x10000;
300       bfd_put_16 (input_bfd, value, hit_data);
301       return bfd_reloc_ok;
302
303       /* Following case is to find segment offset from actual address
304          for this take modulo of value by 64k i.e. segment size.  */
305
306     case R_XC16X_SOF:
307       value += addend;
308       value %= 0x10000;
309       bfd_put_16 (input_bfd, value, hit_data);
310       return bfd_reloc_ok;
311
312     case R_XC16X_ABS_32:
313       if (!strstr (input_section->name,".debug"))
314         {
315           value += addend;
316           val1 = value;
317           value %= 0x4000;
318           val1 /= 0x4000;
319           val1 = val1 << 16;
320           value += val1;
321           bfd_put_32 (input_bfd, value, hit_data);
322         }
323       else
324         {
325           value += addend;
326           bfd_put_32 (input_bfd, value, hit_data);
327         }
328       return bfd_reloc_ok;
329
330     default:
331       return bfd_reloc_notsupported;
332     }
333 }
334
335 static bfd_boolean
336 elf32_xc16x_relocate_section (bfd *output_bfd,
337                               struct bfd_link_info *info,
338                               bfd *input_bfd,
339                               asection *input_section,
340                               bfd_byte *contents,
341                               Elf_Internal_Rela *relocs,
342                               Elf_Internal_Sym *local_syms,
343                               asection **local_sections)
344 {
345   Elf_Internal_Shdr *symtab_hdr;
346   struct elf_link_hash_entry **sym_hashes;
347   Elf_Internal_Rela *rel, *relend;
348
349   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
350   sym_hashes = elf_sym_hashes (input_bfd);
351
352   rel = relocs;
353   relend = relocs + input_section->reloc_count;
354   for (; rel < relend; rel++)
355     {
356       unsigned int r_type;
357       unsigned long r_symndx;
358       Elf_Internal_Sym *sym;
359       asection *sec;
360       struct elf_link_hash_entry *h;
361       bfd_vma relocation;
362
363       /* This is a final link.  */
364       r_symndx = ELF32_R_SYM (rel->r_info);
365       r_type = ELF32_R_TYPE (rel->r_info);
366       h = NULL;
367       sym = NULL;
368       sec = NULL;
369       if (r_symndx < symtab_hdr->sh_info)
370         {
371           sym = local_syms + r_symndx;
372           sec = local_sections[r_symndx];
373           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
374         }
375       else
376         {
377           bfd_boolean unresolved_reloc, warned, ignored;
378
379           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
380                                    r_symndx, symtab_hdr, sym_hashes,
381                                    h, sec, relocation,
382                                    unresolved_reloc, warned, ignored);
383         }
384
385       if (sec != NULL && discarded_section (sec))
386         {
387           /* For relocs against symbols from removed linkonce sections,
388              or sections discarded by a linker script, we just want the
389              section contents cleared.  Avoid any special processing.  */
390           reloc_howto_type *howto;
391           howto = xc16x_reloc_type_lookup (input_bfd, r_type);
392           RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
393                                            rel, 1, relend, howto, 0, contents);
394         }
395
396       if (bfd_link_relocatable (info))
397         continue;
398
399       elf32_xc16x_final_link_relocate (r_type, input_bfd, output_bfd,
400                                        input_section,
401                                        contents, rel->r_offset,
402                                        relocation, rel->r_addend,
403                                        info, sec, h == NULL);
404     }
405
406   return TRUE;
407 }
408
409
410 static void
411 elf32_xc16x_final_write_processing (bfd *abfd,
412                                     bfd_boolean linker ATTRIBUTE_UNUSED)
413 {
414   unsigned long val;
415
416   switch (bfd_get_mach (abfd))
417     {
418     default:
419     case bfd_mach_xc16x:
420       val = 0x1000;
421       break;
422
423     case bfd_mach_xc16xl:
424       val = 0x1001;
425       break;
426
427     case bfd_mach_xc16xs:
428       val = 0x1002;
429       break;
430     }
431
432   elf_elfheader (abfd)->e_flags |= val;
433 }
434
435 static unsigned long
436 elf32_xc16x_mach (flagword flags)
437 {
438   switch (flags)
439     {
440     case 0x1000:
441     default:
442       return bfd_mach_xc16x;
443
444     case 0x1001:
445       return bfd_mach_xc16xl;
446
447     case 0x1002:
448       return bfd_mach_xc16xs;
449     }
450 }
451
452
453 static bfd_boolean
454 elf32_xc16x_object_p (bfd *abfd)
455 {
456   bfd_default_set_arch_mach (abfd, bfd_arch_xc16x,
457                              elf32_xc16x_mach (elf_elfheader (abfd)->e_flags));
458   return TRUE;
459 }
460
461
462 #define ELF_ARCH                bfd_arch_xc16x
463 #define ELF_MACHINE_CODE        EM_XC16X
464 #define ELF_MAXPAGESIZE         0x100
465
466 #define TARGET_LITTLE_SYM       xc16x_elf32_vec
467 #define TARGET_LITTLE_NAME      "elf32-xc16x"
468 #define elf_backend_final_write_processing      elf32_xc16x_final_write_processing
469 #define elf_backend_object_p            elf32_xc16x_object_p
470 #define elf_backend_can_gc_sections     1
471 #define bfd_elf32_bfd_reloc_type_lookup xc16x_reloc_type_lookup
472 #define bfd_elf32_bfd_reloc_name_lookup xc16x_reloc_name_lookup
473 #define elf_info_to_howto               elf32_xc16x_info_to_howto
474 #define elf_info_to_howto_rel           elf32_xc16x_info_to_howto
475 #define elf_backend_relocate_section    elf32_xc16x_relocate_section
476 #define elf_backend_rela_normal         1
477
478 #include "elf32-target.h"