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