bfd/cpu-arm.c

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