bfd/cpu-arm.c

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