Automatic date update in version.in
[external/binutils.git] / bfd / cpu-arm.c
1 /* BFD support for the ARM processor
2    Copyright (C) 1994-2019 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,       "arm620"          },
76   { bfd_mach_arm_3,       "arm7"            },
77   { bfd_mach_arm_3,       "arm70"           },
78   { bfd_mach_arm_3,       "arm700"          },
79   { bfd_mach_arm_3,       "arm700i"         },
80   { bfd_mach_arm_3,       "arm710"          },
81   { bfd_mach_arm_3,       "arm7100"         },
82   { bfd_mach_arm_3,       "arm710c"         },
83   { bfd_mach_arm_4T,      "arm710t"         },
84   { bfd_mach_arm_3,       "arm720"          },
85   { bfd_mach_arm_4T,      "arm720t"         },
86   { bfd_mach_arm_4T,      "arm740t"         },
87   { bfd_mach_arm_3,       "arm7500"         },
88   { bfd_mach_arm_3,       "arm7500fe"       },
89   { bfd_mach_arm_3,       "arm7d"           },
90   { bfd_mach_arm_3,       "arm7di"          },
91   { bfd_mach_arm_3M,      "arm7dm"          },
92   { bfd_mach_arm_3M,      "arm7dmi"         },
93   { bfd_mach_arm_4T,      "arm7t"           },
94   { bfd_mach_arm_4T,      "arm7tdmi"        },
95   { bfd_mach_arm_4T,      "arm7tdmi-s"      },
96   { bfd_mach_arm_3M,      "arm7m"           },
97   { bfd_mach_arm_4,       "arm8"            },
98   { bfd_mach_arm_4,       "arm810"          },
99   { bfd_mach_arm_4,       "arm9"            },
100   { bfd_mach_arm_4T,      "arm920"          },
101   { bfd_mach_arm_4T,      "arm920t"         },
102   { bfd_mach_arm_4T,      "arm922t"         },
103   { bfd_mach_arm_5TEJ,    "arm926ej"        },
104   { bfd_mach_arm_5TEJ,    "arm926ejs"       },
105   { bfd_mach_arm_5TEJ,    "arm926ej-s"      },
106   { bfd_mach_arm_4T,      "arm940t"         },
107   { bfd_mach_arm_5TE,     "arm946e"         },
108   { bfd_mach_arm_5TE,     "arm946e-r0"      },
109   { bfd_mach_arm_5TE,     "arm946e-s"       },
110   { bfd_mach_arm_5TE,     "arm966e"         },
111   { bfd_mach_arm_5TE,     "arm966e-r0"      },
112   { bfd_mach_arm_5TE,     "arm966e-s"       },
113   { bfd_mach_arm_5TE,     "arm968e-s"       },
114   { bfd_mach_arm_5TE,     "arm9e"           },
115   { bfd_mach_arm_5TE,     "arm9e-r0"        },
116   { bfd_mach_arm_4T,      "arm9tdmi"        },
117   { bfd_mach_arm_5TE,     "arm1020"         },
118   { bfd_mach_arm_5T,      "arm1020t"        },
119   { bfd_mach_arm_5TE,     "arm1020e"        },
120   { bfd_mach_arm_5TE,     "arm1022e"        },
121   { bfd_mach_arm_5TEJ,    "arm1026ejs"      },
122   { bfd_mach_arm_5TEJ,    "arm1026ej-s"     },
123   { bfd_mach_arm_5TE,     "arm10e"          },
124   { bfd_mach_arm_5T,      "arm10t"          },
125   { bfd_mach_arm_5T,      "arm10tdmi"       },
126   { bfd_mach_arm_6,       "arm1136j-s"      },
127   { bfd_mach_arm_6,       "arm1136js"       },
128   { bfd_mach_arm_6,       "arm1136jf-s"     },
129   { bfd_mach_arm_6,       "arm1136jfs"      },
130   { bfd_mach_arm_6KZ,     "arm1176jz-s"     },
131   { bfd_mach_arm_6KZ,     "arm1176jzf-s"    },
132   { bfd_mach_arm_6T2,     "arm1156t2-s"     },
133   { bfd_mach_arm_6T2,     "arm1156t2f-s"    },
134   { bfd_mach_arm_7,       "cortex-a5"       },
135   { bfd_mach_arm_7,       "cortex-a7"       },
136   { bfd_mach_arm_7,       "cortex-a8"       },
137   { bfd_mach_arm_7,       "cortex-a9"       },
138   { bfd_mach_arm_7,       "cortex-a12"      },
139   { bfd_mach_arm_7,       "cortex-a15"      },
140   { bfd_mach_arm_7,       "cortex-a17"      },
141   { bfd_mach_arm_8,       "cortex-a32"      },
142   { bfd_mach_arm_8,       "cortex-a35"      },
143   { bfd_mach_arm_8,       "cortex-a53"      },
144   { bfd_mach_arm_8,       "cortex-a55"      },
145   { bfd_mach_arm_8,       "cortex-a57"      },
146   { bfd_mach_arm_8,       "cortex-a72"      },
147   { bfd_mach_arm_8,       "cortex-a73"      },
148   { bfd_mach_arm_8,       "cortex-a75"      },
149   { bfd_mach_arm_8,       "cortex-a76"      },
150   { bfd_mach_arm_6SM,     "cortex-m0"       },
151   { bfd_mach_arm_6SM,     "cortex-m0plus"   },
152   { bfd_mach_arm_6SM,     "cortex-m1"       },
153   { bfd_mach_arm_8M_BASE, "cortex-m23"      },
154   { bfd_mach_arm_7,       "cortex-m3"       },
155   { bfd_mach_arm_8M_MAIN, "cortex-m33"      },
156   { bfd_mach_arm_7EM,     "cortex-m4"       },
157   { bfd_mach_arm_7EM,     "cortex-m7"       },
158   { bfd_mach_arm_7,       "cortex-r4"       },
159   { bfd_mach_arm_7,       "cortex-r4f"      },
160   { bfd_mach_arm_7,       "cortex-r5"       },
161   { bfd_mach_arm_8R,      "cortex-r52"      },
162   { bfd_mach_arm_7,       "cortex-r7"       },
163   { bfd_mach_arm_7,       "cortex-r8"       },
164   { bfd_mach_arm_4T,      "ep9312"          },
165   { bfd_mach_arm_8,       "exynos-m1"       },
166   { bfd_mach_arm_4,       "fa526"           },
167   { bfd_mach_arm_5TE,     "fa606te"         },
168   { bfd_mach_arm_5TE,     "fa616te"         },
169   { bfd_mach_arm_4,       "fa626"           },
170   { bfd_mach_arm_5TE,     "fa626te"         },
171   { bfd_mach_arm_5TE,     "fa726te"         },
172   { bfd_mach_arm_5TE,     "fmp626"          },
173   { bfd_mach_arm_XScale,  "i80200"          },
174   { bfd_mach_arm_7,       "marvell-pj4"     },
175   { bfd_mach_arm_7,       "marvell-whitney" },
176   { bfd_mach_arm_6K,      "mpcore"          },
177   { bfd_mach_arm_6K,      "mpcorenovfp"     },
178   { bfd_mach_arm_4,       "sa1"             },
179   { bfd_mach_arm_4,       "strongarm"       },
180   { bfd_mach_arm_4,       "strongarm1"      },
181   { bfd_mach_arm_4,       "strongarm110"    },
182   { bfd_mach_arm_4,       "strongarm1100"   },
183   { bfd_mach_arm_4,       "strongarm1110"   },
184   { bfd_mach_arm_XScale,  "xscale"          },
185   { bfd_mach_arm_8,       "xgene1"          },
186   { bfd_mach_arm_8,       "xgene2"          },
187   { bfd_mach_arm_ep9312,  "ep9312"          },
188   { bfd_mach_arm_iWMMXt,  "iwmmxt"          },
189   { bfd_mach_arm_iWMMXt2, "iwmmxt2"         },
190   { bfd_mach_arm_unknown, "arm_any"         }
191 };
192
193 static bfd_boolean
194 scan (const struct bfd_arch_info *info, const char *string)
195 {
196   int  i;
197
198   /* First test for an exact match.  */
199   if (strcasecmp (string, info->printable_name) == 0)
200     return TRUE;
201
202   /* Next check for a processor name instead of an Architecture name.  */
203   for (i = sizeof (processors) / sizeof (processors[0]); i--;)
204     {
205       if (strcasecmp (string, processors [i].name) == 0)
206         break;
207     }
208
209   if (i != -1 && info->mach == processors [i].mach)
210     return TRUE;
211
212   /* Finally check for the default architecture.  */
213   if (strcasecmp (string, "arm") == 0)
214     return info->the_default;
215
216   return FALSE;
217 }
218
219 #define N(number, print, default, next)  \
220 {  32, 32, 8, bfd_arch_arm, number, "arm", print, 4, default, compatible, \
221    scan, bfd_arch_default_fill, next }
222
223 static const bfd_arch_info_type arch_info_struct[] =
224 {
225   N (bfd_mach_arm_2,         "armv2",          FALSE, & arch_info_struct[1]),
226   N (bfd_mach_arm_2a,        "armv2a",         FALSE, & arch_info_struct[2]),
227   N (bfd_mach_arm_3,         "armv3",          FALSE, & arch_info_struct[3]),
228   N (bfd_mach_arm_3M,        "armv3m",         FALSE, & arch_info_struct[4]),
229   N (bfd_mach_arm_4,         "armv4",          FALSE, & arch_info_struct[5]),
230   N (bfd_mach_arm_4T,        "armv4t",         FALSE, & arch_info_struct[6]),
231   N (bfd_mach_arm_5,         "armv5",          FALSE, & arch_info_struct[7]),
232   N (bfd_mach_arm_5T,        "armv5t",         FALSE, & arch_info_struct[8]),
233   N (bfd_mach_arm_5TE,       "armv5te",        FALSE, & arch_info_struct[9]),
234   N (bfd_mach_arm_XScale,    "xscale",         FALSE, & arch_info_struct[10]),
235   N (bfd_mach_arm_ep9312,    "ep9312",         FALSE, & arch_info_struct[11]),
236   N (bfd_mach_arm_iWMMXt,    "iwmmxt",         FALSE, & arch_info_struct[12]),
237   N (bfd_mach_arm_iWMMXt2,   "iwmmxt2",        FALSE, & arch_info_struct[13]),
238   N (bfd_mach_arm_5TEJ,      "armv5tej",       FALSE, & arch_info_struct[14]),
239   N (bfd_mach_arm_6,         "armv6",          FALSE, & arch_info_struct[15]),
240   N (bfd_mach_arm_6KZ,       "armv6kz",        FALSE, & arch_info_struct[16]),
241   N (bfd_mach_arm_6T2,       "armv6t2",        FALSE, & arch_info_struct[17]),
242   N (bfd_mach_arm_6K,        "armv6k",         FALSE, & arch_info_struct[18]),
243   N (bfd_mach_arm_7,         "armv7",          FALSE, & arch_info_struct[19]),
244   N (bfd_mach_arm_6M,        "armv6-m",        FALSE, & arch_info_struct[20]),
245   N (bfd_mach_arm_6SM,       "armv6s-m",       FALSE, & arch_info_struct[21]),
246   N (bfd_mach_arm_7EM,       "armv7e-m",       FALSE, & arch_info_struct[22]),
247   N (bfd_mach_arm_8,         "armv8-a",        FALSE, & arch_info_struct[23]),
248   N (bfd_mach_arm_8R,        "armv8-r",        FALSE, & arch_info_struct[24]),
249   N (bfd_mach_arm_8M_BASE,   "armv8-m.base",   FALSE, & arch_info_struct[25]),
250   N (bfd_mach_arm_8M_MAIN,   "armv8-m.main",   FALSE, & arch_info_struct[26]),
251   N (bfd_mach_arm_unknown,   "arm_any",        FALSE, NULL)
252 };
253
254 const bfd_arch_info_type bfd_arm_arch =
255   N (0, "arm", TRUE, & arch_info_struct[0]);
256
257 /* Support functions used by both the COFF and ELF versions of the ARM port.  */
258
259 /* Handle the merging of the 'machine' settings of input file IBFD
260    and an output file OBFD.  These values actually represent the
261    different possible ARM architecture variants.
262    Returns TRUE if they were merged successfully or FALSE otherwise.  */
263
264 bfd_boolean
265 bfd_arm_merge_machines (bfd *ibfd, bfd *obfd)
266 {
267   unsigned int in  = bfd_get_mach (ibfd);
268   unsigned int out = bfd_get_mach (obfd);
269
270   /* If the output architecture is unknown, we now have a value to set.  */
271   if (out == bfd_mach_arm_unknown)
272     bfd_set_arch_mach (obfd, bfd_arch_arm, in);
273
274   /* If the input architecture is unknown,
275      then so must be the output architecture.  */
276   else if (in == bfd_mach_arm_unknown)
277     /* FIXME: We ought to have some way to
278        override this on the command line.  */
279     bfd_set_arch_mach (obfd, bfd_arch_arm, bfd_mach_arm_unknown);
280
281   /* If they are the same then nothing needs to be done.  */
282   else if (out == in)
283     ;
284
285   /* Otherwise the general principle that a earlier architecture can be
286      linked with a later architecture to produce a binary that will execute
287      on the later architecture.
288
289      We fail however if we attempt to link a Cirrus EP9312 binary with an
290      Intel XScale binary, since these architecture have co-processors which
291      will not both be present on the same physical hardware.  */
292   else if (in == bfd_mach_arm_ep9312
293            && (out == bfd_mach_arm_XScale
294                || out == bfd_mach_arm_iWMMXt
295                || out == bfd_mach_arm_iWMMXt2))
296     {
297       /* xgettext: c-format */
298       _bfd_error_handler (_("\
299 error: %pB is compiled for the EP9312, whereas %pB is compiled for XScale"),
300                           ibfd, obfd);
301       bfd_set_error (bfd_error_wrong_format);
302       return FALSE;
303     }
304   else if (out == bfd_mach_arm_ep9312
305            && (in == bfd_mach_arm_XScale
306                || in == bfd_mach_arm_iWMMXt
307                || in == bfd_mach_arm_iWMMXt2))
308     {
309       /* xgettext: c-format */
310       _bfd_error_handler (_("\
311 error: %pB is compiled for the EP9312, whereas %pB is compiled for XScale"),
312                           obfd, ibfd);
313       bfd_set_error (bfd_error_wrong_format);
314       return FALSE;
315     }
316   else if (in > out)
317     bfd_set_arch_mach (obfd, bfd_arch_arm, in);
318   /* else
319      Nothing to do.  */
320
321   return TRUE;
322 }
323
324 typedef struct
325 {
326   unsigned char namesz[4];      /* Size of entry's owner string.  */
327   unsigned char descsz[4];      /* Size of the note descriptor.  */
328   unsigned char type[4];        /* Interpretation of the descriptor.  */
329   char          name[1];        /* Start of the name+desc data.  */
330 } arm_Note;
331
332 static bfd_boolean
333 arm_check_note (bfd *abfd,
334                 bfd_byte *buffer,
335                 bfd_size_type buffer_size,
336                 const char *expected_name,
337                 char **description_return)
338 {
339   unsigned long namesz;
340   unsigned long descsz;
341   unsigned long type;
342   char *        descr;
343
344   if (buffer_size < offsetof (arm_Note, name))
345     return FALSE;
346
347   /* We have to extract the values this way to allow for a
348      host whose endian-ness is different from the target.  */
349   namesz = bfd_get_32 (abfd, buffer);
350   descsz = bfd_get_32 (abfd, buffer + offsetof (arm_Note, descsz));
351   type   = bfd_get_32 (abfd, buffer + offsetof (arm_Note, type));
352   descr  = (char *) buffer + offsetof (arm_Note, name);
353
354   /* Check for buffer overflow.  */
355   if (namesz + descsz + offsetof (arm_Note, name) > buffer_size)
356     return FALSE;
357
358   if (expected_name == NULL)
359     {
360       if (namesz != 0)
361         return FALSE;
362     }
363   else
364     {
365       if (namesz != ((strlen (expected_name) + 1 + 3) & ~3))
366         return FALSE;
367
368       if (strcmp (descr, expected_name) != 0)
369         return FALSE;
370
371       descr += (namesz + 3) & ~3;
372     }
373
374   /* FIXME: We should probably check the type as well.  */
375   (void) type;
376
377   if (description_return != NULL)
378     * description_return = descr;
379
380   return TRUE;
381 }
382
383 #define NOTE_ARCH_STRING        "arch: "
384
385 bfd_boolean
386 bfd_arm_update_notes (bfd *abfd, const char *note_section)
387 {
388   asection *     arm_arch_section;
389   bfd_size_type  buffer_size;
390   bfd_byte *     buffer;
391   char *         arch_string;
392   char *         expected;
393
394   /* Look for a note section.  If one is present check the architecture
395      string encoded in it, and set it to the current architecture if it is
396      different.  */
397   arm_arch_section = bfd_get_section_by_name (abfd, note_section);
398
399   if (arm_arch_section == NULL)
400     return TRUE;
401
402   buffer_size = arm_arch_section->size;
403   if (buffer_size == 0)
404     return FALSE;
405
406   if (!bfd_malloc_and_get_section (abfd, arm_arch_section, &buffer))
407     goto FAIL;
408
409   /* Parse the note.  */
410   if (! arm_check_note (abfd, buffer, buffer_size, NOTE_ARCH_STRING, & arch_string))
411     goto FAIL;
412
413   /* Check the architecture in the note against the architecture of the bfd.
414      Newer architectures versions should not be added here as build attribute
415      are a better mechanism to convey ISA used.  */
416   switch (bfd_get_mach (abfd))
417     {
418     default:
419     case bfd_mach_arm_unknown: expected = "unknown"; break;
420     case bfd_mach_arm_2:       expected = "armv2"; break;
421     case bfd_mach_arm_2a:      expected = "armv2a"; break;
422     case bfd_mach_arm_3:       expected = "armv3"; break;
423     case bfd_mach_arm_3M:      expected = "armv3M"; break;
424     case bfd_mach_arm_4:       expected = "armv4"; break;
425     case bfd_mach_arm_4T:      expected = "armv4t"; break;
426     case bfd_mach_arm_5:       expected = "armv5"; break;
427     case bfd_mach_arm_5T:      expected = "armv5t"; break;
428     case bfd_mach_arm_5TE:     expected = "armv5te"; break;
429     case bfd_mach_arm_XScale:  expected = "XScale"; break;
430     case bfd_mach_arm_ep9312:  expected = "ep9312"; break;
431     case bfd_mach_arm_iWMMXt:  expected = "iWMMXt"; break;
432     case bfd_mach_arm_iWMMXt2: expected = "iWMMXt2"; break;
433     }
434
435   if (strcmp (arch_string, expected) != 0)
436     {
437       strcpy ((char *) buffer + (offsetof (arm_Note, name)
438                                  + ((strlen (NOTE_ARCH_STRING) + 3) & ~3)),
439               expected);
440
441       if (! bfd_set_section_contents (abfd, arm_arch_section, buffer,
442                                       (file_ptr) 0, buffer_size))
443         {
444           _bfd_error_handler
445             /* xgettext: c-format */
446             (_("warning: unable to update contents of %s section in %pB"),
447              note_section, abfd);
448           goto FAIL;
449         }
450     }
451
452   free (buffer);
453   return TRUE;
454
455  FAIL:
456   if (buffer != NULL)
457     free (buffer);
458   return FALSE;
459 }
460
461
462 static struct
463 {
464   const char * string;
465   unsigned int mach;
466 }
467
468 /* Newer architectures versions should not be added here as build attribute are
469    a better mechanism to convey ISA used.  */
470 architectures[] =
471 {
472   { "armv2",   bfd_mach_arm_2 },
473   { "armv2a",  bfd_mach_arm_2a },
474   { "armv3",   bfd_mach_arm_3 },
475   { "armv3M",  bfd_mach_arm_3M },
476   { "armv4",   bfd_mach_arm_4 },
477   { "armv4t",  bfd_mach_arm_4T },
478   { "armv5",   bfd_mach_arm_5 },
479   { "armv5t",  bfd_mach_arm_5T },
480   { "armv5te", bfd_mach_arm_5TE },
481   { "XScale",  bfd_mach_arm_XScale },
482   { "ep9312",  bfd_mach_arm_ep9312 },
483   { "iWMMXt",  bfd_mach_arm_iWMMXt },
484   { "iWMMXt2", bfd_mach_arm_iWMMXt2 },
485   { "arm_any", bfd_mach_arm_unknown }
486 };
487
488 /* Extract the machine number stored in a note section.  */
489 unsigned int
490 bfd_arm_get_mach_from_notes (bfd *abfd, const char *note_section)
491 {
492   asection *     arm_arch_section;
493   bfd_size_type  buffer_size;
494   bfd_byte *     buffer;
495   char *         arch_string;
496   int            i;
497
498   /* Look for a note section.  If one is present check the architecture
499      string encoded in it, and set it to the current architecture if it is
500      different.  */
501   arm_arch_section = bfd_get_section_by_name (abfd, note_section);
502
503   if (arm_arch_section == NULL)
504     return bfd_mach_arm_unknown;
505
506   buffer_size = arm_arch_section->size;
507   if (buffer_size == 0)
508     return bfd_mach_arm_unknown;
509
510   if (!bfd_malloc_and_get_section (abfd, arm_arch_section, &buffer))
511     goto FAIL;
512
513   /* Parse the note.  */
514   if (! arm_check_note (abfd, buffer, buffer_size, NOTE_ARCH_STRING, & arch_string))
515     goto FAIL;
516
517   /* Interpret the architecture string.  */
518   for (i = ARRAY_SIZE (architectures); i--;)
519     if (strcmp (arch_string, architectures[i].string) == 0)
520       {
521         free (buffer);
522         return architectures[i].mach;
523       }
524
525  FAIL:
526   if (buffer != NULL)
527     free (buffer);
528   return bfd_mach_arm_unknown;
529 }
530
531 bfd_boolean
532 bfd_is_arm_special_symbol_name (const char * name, int type)
533 {
534   /* The ARM compiler outputs several obsolete forms.  Recognize them
535      in addition to the standard $a, $t and $d.  We are somewhat loose
536      in what we accept here, since the full set is not documented.  */
537   if (!name || name[0] != '$')
538     return FALSE;
539   if (name[1] == 'a' || name[1] == 't' || name[1] == 'd')
540     type &= BFD_ARM_SPECIAL_SYM_TYPE_MAP;
541   else if (name[1] == 'm' || name[1] == 'f' || name[1] == 'p')
542     type &= BFD_ARM_SPECIAL_SYM_TYPE_TAG;
543   else if (name[1] >= 'a' && name[1] <= 'z')
544     type &= BFD_ARM_SPECIAL_SYM_TYPE_OTHER;
545   else
546     return FALSE;
547
548   return (type != 0 && (name[2] == 0 || name[2] == '.'));
549 }
550