Update year range in copyright notice of all files.
[external/binutils.git] / bfd / cpu-arm.c
1 /* BFD support for the ARM processor
2    Copyright (C) 1994-2017 Free Software Foundation, Inc.
3    Contributed by Richard Earnshaw (rwe@pegasus.esprit.ec.org)
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, Inc., 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 "libiberty.h"
26
27 /* This routine is provided two arch_infos and works out which ARM
28    machine which would be compatible with both and returns a pointer
29    to its info structure.  */
30
31 static const bfd_arch_info_type *
32 compatible (const bfd_arch_info_type *a, const bfd_arch_info_type *b)
33 {
34   /* If a & b are for different architecture we can do nothing.  */
35   if (a->arch != b->arch)
36       return NULL;
37
38   /* If a & b are for the same machine then all is well.  */
39   if (a->mach == b->mach)
40     return a;
41
42   /* Otherwise if either a or b is the 'default' machine
43      then it can be polymorphed into the other.  */
44   if (a->the_default)
45     return b;
46
47   if (b->the_default)
48     return a;
49
50   /* So far all newer ARM architecture cores are
51      supersets of previous cores.  */
52   if (a->mach < b->mach)
53     return b;
54   else if (a->mach > b->mach)
55     return a;
56
57   /* Never reached!  */
58   return NULL;
59 }
60
61 static struct
62 {
63   unsigned int mach;
64   char *       name;
65 }
66 processors[] =
67 {
68   { bfd_mach_arm_2,  "arm2"     },
69   { bfd_mach_arm_2a, "arm250"   },
70   { bfd_mach_arm_2a, "arm3"     },
71   { bfd_mach_arm_3,  "arm6"     },
72   { bfd_mach_arm_3,  "arm60"    },
73   { bfd_mach_arm_3,  "arm600"   },
74   { bfd_mach_arm_3,  "arm610"   },
75   { bfd_mach_arm_3,  "arm7"     },
76   { bfd_mach_arm_3,  "arm710"   },
77   { bfd_mach_arm_3,  "arm7500"  },
78   { bfd_mach_arm_3,  "arm7d"    },
79   { bfd_mach_arm_3,  "arm7di"   },
80   { bfd_mach_arm_3M, "arm7dm"   },
81   { bfd_mach_arm_3M, "arm7dmi"  },
82   { bfd_mach_arm_4T, "arm7tdmi" },
83   { bfd_mach_arm_4,  "arm8"     },
84   { bfd_mach_arm_4,  "arm810"   },
85   { bfd_mach_arm_4,  "arm9"     },
86   { bfd_mach_arm_4,  "arm920"   },
87   { bfd_mach_arm_4T, "arm920t"  },
88   { bfd_mach_arm_4T, "arm9tdmi" },
89   { bfd_mach_arm_4,  "sa1"      },
90   { bfd_mach_arm_4,  "strongarm"},
91   { bfd_mach_arm_4,  "strongarm110" },
92   { bfd_mach_arm_4,  "strongarm1100" },
93   { bfd_mach_arm_XScale, "xscale" },
94   { bfd_mach_arm_ep9312, "ep9312" },
95   { bfd_mach_arm_iWMMXt, "iwmmxt" },
96   { bfd_mach_arm_iWMMXt2, "iwmmxt2" },
97   { bfd_mach_arm_unknown, "arm_any" }
98 };
99
100 static bfd_boolean
101 scan (const struct bfd_arch_info *info, const char *string)
102 {
103   int  i;
104
105   /* First test for an exact match.  */
106   if (strcasecmp (string, info->printable_name) == 0)
107     return TRUE;
108
109   /* Next check for a processor name instead of an Architecture name.  */
110   for (i = sizeof (processors) / sizeof (processors[0]); i--;)
111     {
112       if (strcasecmp (string, processors [i].name) == 0)
113         break;
114     }
115
116   if (i != -1 && info->mach == processors [i].mach)
117     return TRUE;
118
119   /* Finally check for the default architecture.  */
120   if (strcasecmp (string, "arm") == 0)
121     return info->the_default;
122
123   return FALSE;
124 }
125
126 #define N(number, print, default, next)  \
127 {  32, 32, 8, bfd_arch_arm, number, "arm", print, 4, default, compatible, \
128    scan, bfd_arch_default_fill, next }
129
130 static const bfd_arch_info_type arch_info_struct[] =
131 {
132   N (bfd_mach_arm_2,       "armv2",   FALSE, & arch_info_struct[1]),
133   N (bfd_mach_arm_2a,      "armv2a",  FALSE, & arch_info_struct[2]),
134   N (bfd_mach_arm_3,       "armv3",   FALSE, & arch_info_struct[3]),
135   N (bfd_mach_arm_3M,      "armv3m",  FALSE, & arch_info_struct[4]),
136   N (bfd_mach_arm_4,       "armv4",   FALSE, & arch_info_struct[5]),
137   N (bfd_mach_arm_4T,      "armv4t",  FALSE, & arch_info_struct[6]),
138   N (bfd_mach_arm_5,       "armv5",   FALSE, & arch_info_struct[7]),
139   N (bfd_mach_arm_5T,      "armv5t",  FALSE, & arch_info_struct[8]),
140   N (bfd_mach_arm_5TE,     "armv5te", FALSE, & arch_info_struct[9]),
141   N (bfd_mach_arm_XScale,  "xscale",  FALSE, & arch_info_struct[10]),
142   N (bfd_mach_arm_ep9312,  "ep9312",  FALSE, & arch_info_struct[11]),
143   N (bfd_mach_arm_iWMMXt,  "iwmmxt",  FALSE, & arch_info_struct[12]),
144   N (bfd_mach_arm_iWMMXt2, "iwmmxt2", FALSE, & arch_info_struct[13]),
145   N (bfd_mach_arm_unknown, "arm_any", FALSE, NULL)
146 };
147
148 const bfd_arch_info_type bfd_arm_arch =
149   N (0, "arm", TRUE, & arch_info_struct[0]);
150
151 /* Support functions used by both the COFF and ELF versions of the ARM port.  */
152
153 /* Handle the merging of the 'machine' settings of input file IBFD
154    and an output file OBFD.  These values actually represent the
155    different possible ARM architecture variants.
156    Returns TRUE if they were merged successfully or FALSE otherwise.  */
157
158 bfd_boolean
159 bfd_arm_merge_machines (bfd *ibfd, bfd *obfd)
160 {
161   unsigned int in  = bfd_get_mach (ibfd);
162   unsigned int out = bfd_get_mach (obfd);
163
164   /* If the output architecture is unknown, we now have a value to set.  */
165   if (out == bfd_mach_arm_unknown)
166     bfd_set_arch_mach (obfd, bfd_arch_arm, in);
167
168   /* If the input architecture is unknown,
169      then so must be the output architecture.  */
170   else if (in == bfd_mach_arm_unknown)
171     /* FIXME: We ought to have some way to
172        override this on the command line.  */
173     bfd_set_arch_mach (obfd, bfd_arch_arm, bfd_mach_arm_unknown);
174
175   /* If they are the same then nothing needs to be done.  */
176   else if (out == in)
177     ;
178
179   /* Otherwise the general principle that a earlier architecture can be
180      linked with a later architecture to produce a binary that will execute
181      on the later architecture.
182
183      We fail however if we attempt to link a Cirrus EP9312 binary with an
184      Intel XScale binary, since these architecture have co-processors which
185      will not both be present on the same physical hardware.  */
186   else if (in == bfd_mach_arm_ep9312
187            && (out == bfd_mach_arm_XScale
188                || out == bfd_mach_arm_iWMMXt
189                || out == bfd_mach_arm_iWMMXt2))
190     {
191       /* xgettext: c-format */
192       _bfd_error_handler (_("\
193 error: %B is compiled for the EP9312, whereas %B is compiled for XScale"),
194                           ibfd, obfd);
195       bfd_set_error (bfd_error_wrong_format);
196       return FALSE;
197     }
198   else if (out == bfd_mach_arm_ep9312
199            && (in == bfd_mach_arm_XScale
200                || in == bfd_mach_arm_iWMMXt
201                || in == bfd_mach_arm_iWMMXt2))
202     {
203       /* xgettext: c-format */
204       _bfd_error_handler (_("\
205 error: %B is compiled for the EP9312, whereas %B is compiled for XScale"),
206                           obfd, ibfd);
207       bfd_set_error (bfd_error_wrong_format);
208       return FALSE;
209     }
210   else if (in > out)
211     bfd_set_arch_mach (obfd, bfd_arch_arm, in);
212   /* else
213      Nothing to do.  */
214
215   return TRUE;
216 }
217
218 typedef struct
219 {
220   unsigned char namesz[4];      /* Size of entry's owner string.  */
221   unsigned char descsz[4];      /* Size of the note descriptor.  */
222   unsigned char type[4];        /* Interpretation of the descriptor.  */
223   char          name[1];        /* Start of the name+desc data.  */
224 } arm_Note;
225
226 static bfd_boolean
227 arm_check_note (bfd *abfd,
228                 bfd_byte *buffer,
229                 bfd_size_type buffer_size,
230                 const char *expected_name,
231                 char **description_return)
232 {
233   unsigned long namesz;
234   unsigned long descsz;
235   unsigned long type;
236   char *        descr;
237
238   if (buffer_size < offsetof (arm_Note, name))
239     return FALSE;
240
241   /* We have to extract the values this way to allow for a
242      host whose endian-ness is different from the target.  */
243   namesz = bfd_get_32 (abfd, buffer);
244   descsz = bfd_get_32 (abfd, buffer + offsetof (arm_Note, descsz));
245   type   = bfd_get_32 (abfd, buffer + offsetof (arm_Note, type));
246   descr  = (char *) buffer + offsetof (arm_Note, name);
247
248   /* Check for buffer overflow.  */
249   if (namesz + descsz + offsetof (arm_Note, name) > buffer_size)
250     return FALSE;
251
252   if (expected_name == NULL)
253     {
254       if (namesz != 0)
255         return FALSE;
256     }
257   else
258     {
259       if (namesz != ((strlen (expected_name) + 1 + 3) & ~3))
260         return FALSE;
261
262       if (strcmp (descr, expected_name) != 0)
263         return FALSE;
264
265       descr += (namesz + 3) & ~3;
266     }
267
268   /* FIXME: We should probably check the type as well.  */
269   (void) type;
270
271   if (description_return != NULL)
272     * description_return = descr;
273
274   return TRUE;
275 }
276
277 #define NOTE_ARCH_STRING        "arch: "
278
279 bfd_boolean
280 bfd_arm_update_notes (bfd *abfd, const char *note_section)
281 {
282   asection *     arm_arch_section;
283   bfd_size_type  buffer_size;
284   bfd_byte *     buffer;
285   char *         arch_string;
286   char *         expected;
287
288   /* Look for a note section.  If one is present check the architecture
289      string encoded in it, and set it to the current architecture if it is
290      different.  */
291   arm_arch_section = bfd_get_section_by_name (abfd, note_section);
292
293   if (arm_arch_section == NULL)
294     return TRUE;
295
296   buffer_size = arm_arch_section->size;
297   if (buffer_size == 0)
298     return FALSE;
299
300   if (!bfd_malloc_and_get_section (abfd, arm_arch_section, &buffer))
301     goto FAIL;
302
303   /* Parse the note.  */
304   if (! arm_check_note (abfd, buffer, buffer_size, NOTE_ARCH_STRING, & arch_string))
305     goto FAIL;
306
307   /* Check the architecture in the note against the architecture of the bfd.  */
308   switch (bfd_get_mach (abfd))
309     {
310     default:
311     case bfd_mach_arm_unknown: expected = "unknown"; break;
312     case bfd_mach_arm_2:       expected = "armv2"; break;
313     case bfd_mach_arm_2a:      expected = "armv2a"; break;
314     case bfd_mach_arm_3:       expected = "armv3"; break;
315     case bfd_mach_arm_3M:      expected = "armv3M"; break;
316     case bfd_mach_arm_4:       expected = "armv4"; break;
317     case bfd_mach_arm_4T:      expected = "armv4t"; break;
318     case bfd_mach_arm_5:       expected = "armv5"; break;
319     case bfd_mach_arm_5T:      expected = "armv5t"; break;
320     case bfd_mach_arm_5TE:     expected = "armv5te"; break;
321     case bfd_mach_arm_XScale:  expected = "XScale"; break;
322     case bfd_mach_arm_ep9312:  expected = "ep9312"; break;
323     case bfd_mach_arm_iWMMXt:  expected = "iWMMXt"; break;
324     case bfd_mach_arm_iWMMXt2: expected = "iWMMXt2"; break;
325     }
326
327   if (strcmp (arch_string, expected) != 0)
328     {
329       strcpy ((char *) buffer + (offsetof (arm_Note, name)
330                                  + ((strlen (NOTE_ARCH_STRING) + 3) & ~3)),
331               expected);
332
333       if (! bfd_set_section_contents (abfd, arm_arch_section, buffer,
334                                       (file_ptr) 0, buffer_size))
335         {
336           _bfd_error_handler
337             /* xgettext: c-format */
338             (_("warning: unable to update contents of %s section in %s"),
339              note_section, bfd_get_filename (abfd));
340           goto FAIL;
341         }
342     }
343
344   free (buffer);
345   return TRUE;
346
347  FAIL:
348   if (buffer != NULL)
349     free (buffer);
350   return FALSE;
351 }
352
353
354 static struct
355 {
356   const char * string;
357   unsigned int mach;
358 }
359 architectures[] =
360 {
361   { "armv2",   bfd_mach_arm_2 },
362   { "armv2a",  bfd_mach_arm_2a },
363   { "armv3",   bfd_mach_arm_3 },
364   { "armv3M",  bfd_mach_arm_3M },
365   { "armv4",   bfd_mach_arm_4 },
366   { "armv4t",  bfd_mach_arm_4T },
367   { "armv5",   bfd_mach_arm_5 },
368   { "armv5t",  bfd_mach_arm_5T },
369   { "armv5te", bfd_mach_arm_5TE },
370   { "XScale",  bfd_mach_arm_XScale },
371   { "ep9312",  bfd_mach_arm_ep9312 },
372   { "iWMMXt",  bfd_mach_arm_iWMMXt },
373   { "iWMMXt2", bfd_mach_arm_iWMMXt2 },
374   { "arm_any", bfd_mach_arm_unknown }
375 };
376
377 /* Extract the machine number stored in a note section.  */
378 unsigned int
379 bfd_arm_get_mach_from_notes (bfd *abfd, const char *note_section)
380 {
381   asection *     arm_arch_section;
382   bfd_size_type  buffer_size;
383   bfd_byte *     buffer;
384   char *         arch_string;
385   int            i;
386
387   /* Look for a note section.  If one is present check the architecture
388      string encoded in it, and set it to the current architecture if it is
389      different.  */
390   arm_arch_section = bfd_get_section_by_name (abfd, note_section);
391
392   if (arm_arch_section == NULL)
393     return bfd_mach_arm_unknown;
394
395   buffer_size = arm_arch_section->size;
396   if (buffer_size == 0)
397     return bfd_mach_arm_unknown;
398
399   if (!bfd_malloc_and_get_section (abfd, arm_arch_section, &buffer))
400     goto FAIL;
401
402   /* Parse the note.  */
403   if (! arm_check_note (abfd, buffer, buffer_size, NOTE_ARCH_STRING, & arch_string))
404     goto FAIL;
405
406   /* Interpret the architecture string.  */
407   for (i = ARRAY_SIZE (architectures); i--;)
408     if (strcmp (arch_string, architectures[i].string) == 0)
409       {
410         free (buffer);
411         return architectures[i].mach;
412       }
413
414  FAIL:
415   if (buffer != NULL)
416     free (buffer);
417   return bfd_mach_arm_unknown;
418 }
419
420 bfd_boolean
421 bfd_is_arm_special_symbol_name (const char * name, int type)
422 {
423   /* The ARM compiler outputs several obsolete forms.  Recognize them
424      in addition to the standard $a, $t and $d.  We are somewhat loose
425      in what we accept here, since the full set is not documented.  */
426   if (!name || name[0] != '$')
427     return FALSE;
428   if (name[1] == 'a' || name[1] == 't' || name[1] == 'd')
429     type &= BFD_ARM_SPECIAL_SYM_TYPE_MAP;
430   else if (name[1] == 'm' || name[1] == 'f' || name[1] == 'p')
431     type &= BFD_ARM_SPECIAL_SYM_TYPE_TAG;
432   else if (name[1] >= 'a' && name[1] <= 'z')
433     type &= BFD_ARM_SPECIAL_SYM_TYPE_OTHER;
434   else
435     return FALSE;
436
437   return (type != 0 && (name[2] == 0 || name[2] == '.'));
438 }
439