gas/
[binutils.git] / bfd / cpu-arm.c
blob3f56e8f9a62f64ba589048561c83185bc6078cd9
1 /* BFD support for the ARM processor
2 Copyright 1994, 1997, 1999, 2000, 2002, 2003, 2004, 2005
3 Free Software Foundation, Inc.
4 Contributed by Richard Earnshaw (rwe@pegasus.esprit.ec.org)
6 This file is part of BFD, the Binary File Descriptor library.
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 2 of the License, or
11 (at your option) any later version.
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.
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, MA 02110-1301, USA. */
22 #include "bfd.h"
23 #include "sysdep.h"
24 #include "libbfd.h"
25 #include "libiberty.h"
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. */
31 static const bfd_arch_info_type *
32 compatible (const bfd_arch_info_type *a, const bfd_arch_info_type *b)
34 /* If a & b are for different architecture we can do nothing. */
35 if (a->arch != b->arch)
36 return NULL;
38 /* If a & b are for the same machine then all is well. */
39 if (a->mach == b->mach)
40 return a;
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;
47 if (b->the_default)
48 return a;
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;
57 /* Never reached! */
58 return NULL;
61 static struct
63 unsigned int mach;
64 char * name;
66 processors[] =
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" }
98 static bfd_boolean
99 scan (const struct bfd_arch_info *info, const char *string)
101 int i;
103 /* First test for an exact match. */
104 if (strcasecmp (string, info->printable_name) == 0)
105 return TRUE;
107 /* Next check for a processor name instead of an Architecture name. */
108 for (i = sizeof (processors) / sizeof (processors[0]); i--;)
110 if (strcasecmp (string, processors [i].name) == 0)
111 break;
114 if (i != -1 && info->mach == processors [i].mach)
115 return TRUE;
117 /* Finally check for the default architecture. */
118 if (strcasecmp (string, "arm") == 0)
119 return info->the_default;
121 return FALSE;
124 #define N(number, print, default, next) \
125 { 32, 32, 8, bfd_arch_arm, number, "arm", print, 4, default, compatible, scan, next }
127 static const bfd_arch_info_type arch_info_struct[] =
129 N (bfd_mach_arm_2, "armv2", FALSE, & arch_info_struct[1]),
130 N (bfd_mach_arm_2a, "armv2a", FALSE, & arch_info_struct[2]),
131 N (bfd_mach_arm_3, "armv3", FALSE, & arch_info_struct[3]),
132 N (bfd_mach_arm_3M, "armv3m", FALSE, & arch_info_struct[4]),
133 N (bfd_mach_arm_4, "armv4", FALSE, & arch_info_struct[5]),
134 N (bfd_mach_arm_4T, "armv4t", FALSE, & arch_info_struct[6]),
135 N (bfd_mach_arm_5, "armv5", FALSE, & arch_info_struct[7]),
136 N (bfd_mach_arm_5T, "armv5t", FALSE, & arch_info_struct[8]),
137 N (bfd_mach_arm_5TE, "armv5te", FALSE, & arch_info_struct[9]),
138 N (bfd_mach_arm_XScale, "xscale", FALSE, & arch_info_struct[10]),
139 N (bfd_mach_arm_ep9312, "ep9312", FALSE, & arch_info_struct[11]),
140 N (bfd_mach_arm_iWMMXt,"iwmmxt", FALSE, NULL)
143 const bfd_arch_info_type bfd_arm_arch =
144 N (0, "arm", TRUE, & arch_info_struct[0]);
146 /* Support functions used by both the COFF and ELF versions of the ARM port. */
148 /* Handle the merging of the 'machine' settings of input file IBFD
149 and an output file OBFD. These values actually represent the
150 different possible ARM architecture variants.
151 Returns TRUE if they were merged successfully or FALSE otherwise. */
153 bfd_boolean
154 bfd_arm_merge_machines (bfd *ibfd, bfd *obfd)
156 unsigned int in = bfd_get_mach (ibfd);
157 unsigned int out = bfd_get_mach (obfd);
159 /* If the output architecture is unknown, we now have a value to set. */
160 if (out == bfd_mach_arm_unknown)
161 bfd_set_arch_mach (obfd, bfd_arch_arm, in);
163 /* If the input architecture is unknown,
164 then so must be the output architecture. */
165 else if (in == bfd_mach_arm_unknown)
166 /* FIXME: We ought to have some way to
167 override this on the command line. */
168 bfd_set_arch_mach (obfd, bfd_arch_arm, bfd_mach_arm_unknown);
170 /* If they are the same then nothing needs to be done. */
171 else if (out == in)
174 /* Otherwise the general principle that a earlier architecture can be
175 linked with a later architecture to produce a binary that will execute
176 on the later architecture.
178 We fail however if we attempt to link a Cirrus EP9312 binary with an
179 Intel XScale binary, since these architecture have co-processors which
180 will not both be present on the same physical hardware. */
181 else if (in == bfd_mach_arm_ep9312
182 && (out == bfd_mach_arm_XScale || out == bfd_mach_arm_iWMMXt))
184 _bfd_error_handler (_("\
185 ERROR: %B is compiled for the EP9312, whereas %B is compiled for XScale"),
186 ibfd, obfd);
187 bfd_set_error (bfd_error_wrong_format);
188 return FALSE;
190 else if (out == bfd_mach_arm_ep9312
191 && (in == bfd_mach_arm_XScale || in == bfd_mach_arm_iWMMXt))
193 _bfd_error_handler (_("\
194 ERROR: %B is compiled for the EP9312, whereas %B is compiled for XScale"),
195 obfd, ibfd);
196 bfd_set_error (bfd_error_wrong_format);
197 return FALSE;
199 else if (in > out)
200 bfd_set_arch_mach (obfd, bfd_arch_arm, in);
201 /* else
202 Nothing to do. */
204 return TRUE;
207 typedef struct
209 unsigned char namesz[4]; /* Size of entry's owner string. */
210 unsigned char descsz[4]; /* Size of the note descriptor. */
211 unsigned char type[4]; /* Interpretation of the descriptor. */
212 char name[1]; /* Start of the name+desc data. */
213 } arm_Note;
215 static bfd_boolean
216 arm_check_note (bfd *abfd,
217 bfd_byte *buffer,
218 bfd_size_type buffer_size,
219 const char *expected_name,
220 char **description_return)
222 unsigned long namesz;
223 unsigned long descsz;
224 unsigned long type;
225 char * descr;
227 if (buffer_size < offsetof (arm_Note, name))
228 return FALSE;
230 /* We have to extract the values this way to allow for a
231 host whose endian-ness is different from the target. */
232 namesz = bfd_get_32 (abfd, buffer);
233 descsz = bfd_get_32 (abfd, buffer + offsetof (arm_Note, descsz));
234 type = bfd_get_32 (abfd, buffer + offsetof (arm_Note, type));
235 descr = (char *) buffer + offsetof (arm_Note, name);
237 /* Check for buffer overflow. */
238 if (namesz + descsz + offsetof (arm_Note, name) > buffer_size)
239 return FALSE;
241 if (expected_name == NULL)
243 if (namesz != 0)
244 return FALSE;
246 else
248 if (namesz != ((strlen (expected_name) + 1 + 3) & ~3))
249 return FALSE;
251 if (strcmp (descr, expected_name) != 0)
252 return FALSE;
254 descr += (namesz + 3) & ~3;
257 /* FIXME: We should probably check the type as well. */
259 if (description_return != NULL)
260 * description_return = descr;
262 return TRUE;
265 #define NOTE_ARCH_STRING "arch: "
267 bfd_boolean
268 bfd_arm_update_notes (bfd *abfd, const char *note_section)
270 asection * arm_arch_section;
271 bfd_size_type buffer_size;
272 bfd_byte * buffer;
273 char * arch_string;
274 char * expected;
276 /* Look for a note section. If one is present check the architecture
277 string encoded in it, and set it to the current architecture if it is
278 different. */
279 arm_arch_section = bfd_get_section_by_name (abfd, note_section);
281 if (arm_arch_section == NULL)
282 return TRUE;
284 buffer_size = arm_arch_section->size;
285 if (buffer_size == 0)
286 return FALSE;
288 if (!bfd_malloc_and_get_section (abfd, arm_arch_section, &buffer))
289 goto FAIL;
291 /* Parse the note. */
292 if (! arm_check_note (abfd, buffer, buffer_size, NOTE_ARCH_STRING, & arch_string))
293 goto FAIL;
295 /* Check the architecture in the note against the architecture of the bfd. */
296 switch (bfd_get_mach (abfd))
298 default:
299 case bfd_mach_arm_unknown: expected = "unknown"; break;
300 case bfd_mach_arm_2: expected = "armv2"; break;
301 case bfd_mach_arm_2a: expected = "armv2a"; break;
302 case bfd_mach_arm_3: expected = "armv3"; break;
303 case bfd_mach_arm_3M: expected = "armv3M"; break;
304 case bfd_mach_arm_4: expected = "armv4"; break;
305 case bfd_mach_arm_4T: expected = "armv4t"; break;
306 case bfd_mach_arm_5: expected = "armv5"; break;
307 case bfd_mach_arm_5T: expected = "armv5t"; break;
308 case bfd_mach_arm_5TE: expected = "armv5te"; break;
309 case bfd_mach_arm_XScale: expected = "XScale"; break;
310 case bfd_mach_arm_ep9312: expected = "ep9312"; break;
311 case bfd_mach_arm_iWMMXt: expected = "iWMMXt"; break;
314 if (strcmp (arch_string, expected) != 0)
316 strcpy ((char *) buffer + (offsetof (arm_Note, name)
317 + ((strlen (NOTE_ARCH_STRING) + 3) & ~3)),
318 expected);
320 if (! bfd_set_section_contents (abfd, arm_arch_section, buffer,
321 (file_ptr) 0, buffer_size))
323 (*_bfd_error_handler)
324 (_("warning: unable to update contents of %s section in %s"),
325 note_section, bfd_get_filename (abfd));
326 goto FAIL;
330 free (buffer);
331 return TRUE;
333 FAIL:
334 if (buffer != NULL)
335 free (buffer);
336 return FALSE;
340 static struct
342 const char * string;
343 unsigned int mach;
345 architectures[] =
347 { "armv2", bfd_mach_arm_2 },
348 { "armv2a", bfd_mach_arm_2a },
349 { "armv3", bfd_mach_arm_3 },
350 { "armv3M", bfd_mach_arm_3M },
351 { "armv4", bfd_mach_arm_4 },
352 { "armv4t", bfd_mach_arm_4T },
353 { "armv5", bfd_mach_arm_5 },
354 { "armv5t", bfd_mach_arm_5T },
355 { "armv5te", bfd_mach_arm_5TE },
356 { "XScale", bfd_mach_arm_XScale },
357 { "ep9312", bfd_mach_arm_ep9312 },
358 { "iWMMXt", bfd_mach_arm_iWMMXt }
361 /* Extract the machine number stored in a note section. */
362 unsigned int
363 bfd_arm_get_mach_from_notes (bfd *abfd, const char *note_section)
365 asection * arm_arch_section;
366 bfd_size_type buffer_size;
367 bfd_byte * buffer;
368 char * arch_string;
369 int i;
371 /* Look for a note section. If one is present check the architecture
372 string encoded in it, and set it to the current architecture if it is
373 different. */
374 arm_arch_section = bfd_get_section_by_name (abfd, note_section);
376 if (arm_arch_section == NULL)
377 return bfd_mach_arm_unknown;
379 buffer_size = arm_arch_section->size;
380 if (buffer_size == 0)
381 return bfd_mach_arm_unknown;
383 if (!bfd_malloc_and_get_section (abfd, arm_arch_section, &buffer))
384 goto FAIL;
386 /* Parse the note. */
387 if (! arm_check_note (abfd, buffer, buffer_size, NOTE_ARCH_STRING, & arch_string))
388 goto FAIL;
390 /* Interpret the architecture string. */
391 for (i = ARRAY_SIZE (architectures); i--;)
392 if (strcmp (arch_string, architectures[i].string) == 0)
394 free (buffer);
395 return architectures[i].mach;
398 FAIL:
399 if (buffer != NULL)
400 free (buffer);
401 return bfd_mach_arm_unknown;
404 bfd_boolean
405 bfd_is_arm_mapping_symbol_name (const char * name)
407 return (name != NULL)
408 && (name[0] == '$')
409 && ((name[1] == 'a') || (name[1] == 't') || (name[1] == 'd'))
410 && (name[2] == 0);