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