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