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_8_1M_MAIN, "armv8.1-m.main", FALSE, & arch_info_struct[27]),
 252   N (bfd_mach_arm_unknown,   "arm_any",        FALSE, NULL)
 253 };
 254
 255 const bfd_arch_info_type bfd_arm_arch =
 256   N (0, "arm", TRUE, & arch_info_struct[0]);
 257
 258 /* Support functions used by both the COFF and ELF versions of the ARM port.  */
 259
 260 /* Handle the merging of the 'machine' settings of input file IBFD
 261    and an output file OBFD.  These values actually represent the
 262    different possible ARM architecture variants.
 263    Returns TRUE if they were merged successfully or FALSE otherwise.  */
 264
 265 bfd_boolean
 266 bfd_arm_merge_machines (bfd *ibfd, bfd *obfd)
 267 {
 268   unsigned int in  = bfd_get_mach (ibfd);
 269   unsigned int out = bfd_get_mach (obfd);
 270
 271   /* If the output architecture is unknown, we now have a value to set.  */
 272   if (out == bfd_mach_arm_unknown)
 273     bfd_set_arch_mach (obfd, bfd_arch_arm, in);
 274
 275   /* If the input architecture is unknown,
 276      then so must be the output architecture.  */
 277   else if (in == bfd_mach_arm_unknown)
 278     /* FIXME: We ought to have some way to
 279        override this on the command line.  */
 280     bfd_set_arch_mach (obfd, bfd_arch_arm, bfd_mach_arm_unknown);
 281
 282   /* If they are the same then nothing needs to be done.  */
 283   else if (out == in)
 284     ;
 285
 286   /* Otherwise the general principle that a earlier architecture can be
 287      linked with a later architecture to produce a binary that will execute
 288      on the later architecture.
 289
 290      We fail however if we attempt to link a Cirrus EP9312 binary with an
 291      Intel XScale binary, since these architecture have co-processors which
 292      will not both be present on the same physical hardware.  */
 293   else if (in == bfd_mach_arm_ep9312
 294            && (out == bfd_mach_arm_XScale
 295                || out == bfd_mach_arm_iWMMXt
 296                || out == bfd_mach_arm_iWMMXt2))
 297     {
 298       /* xgettext: c-format */
 299       _bfd_error_handler (_("\
 300 error: %pB is compiled for the EP9312, whereas %pB is compiled for XScale"),
 301                           ibfd, obfd);
 302       bfd_set_error (bfd_error_wrong_format);
 303       return FALSE;
 304     }
 305   else if (out == bfd_mach_arm_ep9312
 306            && (in == bfd_mach_arm_XScale
 307                || in == bfd_mach_arm_iWMMXt
 308                || in == bfd_mach_arm_iWMMXt2))
 309     {
 310       /* xgettext: c-format */
 311       _bfd_error_handler (_("\
 312 error: %pB is compiled for the EP9312, whereas %pB is compiled for XScale"),
 313                           obfd, ibfd);
 314       bfd_set_error (bfd_error_wrong_format);
 315       return FALSE;
 316     }
 317   else if (in > out)
 318     bfd_set_arch_mach (obfd, bfd_arch_arm, in);
 319   /* else
 320      Nothing to do.  */
 321
 322   return TRUE;
 323 }
 324
 325 typedef struct
 326 {
 327   unsigned char namesz[4];      /* Size of entry's owner string.  */
 328   unsigned char descsz[4];      /* Size of the note descriptor.  */
 329   unsigned char type[4];        /* Interpretation of the descriptor.  */
 330   char          name[1];        /* Start of the name+desc data.  */
 331 } arm_Note;
 332
 333 static bfd_boolean
 334 arm_check_note (bfd *abfd,
 335                 bfd_byte *buffer,
 336                 bfd_size_type buffer_size,
 337                 const char *expected_name,
 338                 char **description_return)
 339 {
 340   unsigned long namesz;
 341   unsigned long descsz;
 342   unsigned long type;
 343   char *        descr;
 344
 345   if (buffer_size < offsetof (arm_Note, name))
 346     return FALSE;
 347
 348   /* We have to extract the values this way to allow for a
 349      host whose endian-ness is different from the target.  */
 350   namesz = bfd_get_32 (abfd, buffer);
 351   descsz = bfd_get_32 (abfd, buffer + offsetof (arm_Note, descsz));
 352   type   = bfd_get_32 (abfd, buffer + offsetof (arm_Note, type));
 353   descr  = (char *) buffer + offsetof (arm_Note, name);
 354
 355   /* Check for buffer overflow.  */
 356   if (namesz + descsz + offsetof (arm_Note, name) > buffer_size)
 357     return FALSE;
 358
 359   if (expected_name == NULL)
 360     {
 361       if (namesz != 0)
 362         return FALSE;
 363     }
 364   else
 365     {
 366       if (namesz != ((strlen (expected_name) + 1 + 3) & ~3))
 367         return FALSE;
 368
 369       if (strcmp (descr, expected_name) != 0)
 370         return FALSE;
 371
 372       descr += (namesz + 3) & ~3;
 373     }
 374
 375   /* FIXME: We should probably check the type as well.  */
 376   (void) type;
 377
 378   if (description_return != NULL)
 379     * description_return = descr;
 380
 381   return TRUE;
 382 }
 383
 384 #define NOTE_ARCH_STRING        "arch: "
 385
 386 bfd_boolean
 387 bfd_arm_update_notes (bfd *abfd, const char *note_section)
 388 {
 389   asection *     arm_arch_section;
 390   bfd_size_type  buffer_size;
 391   bfd_byte *     buffer;
 392   char *         arch_string;
 393   char *         expected;
 394
 395   /* Look for a note section.  If one is present check the architecture
 396      string encoded in it, and set it to the current architecture if it is
 397      different.  */
 398   arm_arch_section = bfd_get_section_by_name (abfd, note_section);
 399
 400   if (arm_arch_section == NULL)
 401     return TRUE;
 402
 403   buffer_size = arm_arch_section->size;
 404   if (buffer_size == 0)
 405     return FALSE;
 406
 407   if (!bfd_malloc_and_get_section (abfd, arm_arch_section, &buffer))
 408     goto FAIL;
 409
 410   /* Parse the note.  */
 411   if (! arm_check_note (abfd, buffer, buffer_size, NOTE_ARCH_STRING, & arch_string))
 412     goto FAIL;
 413
 414   /* Check the architecture in the note against the architecture of the bfd.
 415      Newer architectures versions should not be added here as build attribute
 416      are a better mechanism to convey ISA used.  */
 417   switch (bfd_get_mach (abfd))
 418     {
 419     default:
 420     case bfd_mach_arm_unknown: expected = "unknown"; break;
 421     case bfd_mach_arm_2:       expected = "armv2"; break;
 422     case bfd_mach_arm_2a:      expected = "armv2a"; break;
 423     case bfd_mach_arm_3:       expected = "armv3"; break;
 424     case bfd_mach_arm_3M:      expected = "armv3M"; break;
 425     case bfd_mach_arm_4:       expected = "armv4"; break;
 426     case bfd_mach_arm_4T:      expected = "armv4t"; break;
 427     case bfd_mach_arm_5:       expected = "armv5"; break;
 428     case bfd_mach_arm_5T:      expected = "armv5t"; break;
 429     case bfd_mach_arm_5TE:     expected = "armv5te"; break;
 430     case bfd_mach_arm_XScale:  expected = "XScale"; break;
 431     case bfd_mach_arm_ep9312:  expected = "ep9312"; break;
 432     case bfd_mach_arm_iWMMXt:  expected = "iWMMXt"; break;
 433     case bfd_mach_arm_iWMMXt2: expected = "iWMMXt2"; break;
 434     }
 435
 436   if (strcmp (arch_string, expected) != 0)
 437     {
 438       strcpy ((char *) buffer + (offsetof (arm_Note, name)
 439                                  + ((strlen (NOTE_ARCH_STRING) + 3) & ~3)),
 440               expected);
 441
 442       if (! bfd_set_section_contents (abfd, arm_arch_section, buffer,
 443                                       (file_ptr) 0, buffer_size))
 444         {
 445           _bfd_error_handler
 446             /* xgettext: c-format */
 447             (_("warning: unable to update contents of %s section in %pB"),
 448              note_section, abfd);
 449           goto FAIL;
 450         }
 451     }
 452
 453   free (buffer);
 454   return TRUE;
 455
 456  FAIL:
 457   if (buffer != NULL)
 458     free (buffer);
 459   return FALSE;
 460 }
 461
 462
 463 static struct
 464 {
 465   const char * string;
 466   unsigned int mach;
 467 }
 468
 469 /* Newer architectures versions should not be added here as build attribute are
 470    a better mechanism to convey ISA used.  */
 471 architectures[] =
 472 {
 473   { "armv2",   bfd_mach_arm_2 },
 474   { "armv2a",  bfd_mach_arm_2a },
 475   { "armv3",   bfd_mach_arm_3 },
 476   { "armv3M",  bfd_mach_arm_3M },
 477   { "armv4",   bfd_mach_arm_4 },
 478   { "armv4t",  bfd_mach_arm_4T },
 479   { "armv5",   bfd_mach_arm_5 },
 480   { "armv5t",  bfd_mach_arm_5T },
 481   { "armv5te", bfd_mach_arm_5TE },
 482   { "XScale",  bfd_mach_arm_XScale },
 483   { "ep9312",  bfd_mach_arm_ep9312 },
 484   { "iWMMXt",  bfd_mach_arm_iWMMXt },
 485   { "iWMMXt2", bfd_mach_arm_iWMMXt2 },
 486   { "arm_any", bfd_mach_arm_unknown }
 487 };
 488
 489 /* Extract the machine number stored in a note section.  */
 490 unsigned int
 491 bfd_arm_get_mach_from_notes (bfd *abfd, const char *note_section)
 492 {
 493   asection *     arm_arch_section;
 494   bfd_size_type  buffer_size;
 495   bfd_byte *     buffer;
 496   char *         arch_string;
 497   int            i;
 498
 499   /* Look for a note section.  If one is present check the architecture
 500      string encoded in it, and set it to the current architecture if it is
 501      different.  */
 502   arm_arch_section = bfd_get_section_by_name (abfd, note_section);
 503
 504   if (arm_arch_section == NULL)
 505     return bfd_mach_arm_unknown;
 506
 507   buffer_size = arm_arch_section->size;
 508   if (buffer_size == 0)
 509     return bfd_mach_arm_unknown;
 510
 511   if (!bfd_malloc_and_get_section (abfd, arm_arch_section, &buffer))
 512     goto FAIL;
 513
 514   /* Parse the note.  */
 515   if (! arm_check_note (abfd, buffer, buffer_size, NOTE_ARCH_STRING, & arch_string))
 516     goto FAIL;
 517
 518   /* Interpret the architecture string.  */
 519   for (i = ARRAY_SIZE (architectures); i--;)
 520     if (strcmp (arch_string, architectures[i].string) == 0)
 521       {
 522         free (buffer);
 523         return architectures[i].mach;
 524       }
 525
 526  FAIL:
 527   if (buffer != NULL)
 528     free (buffer);
 529   return bfd_mach_arm_unknown;
 530 }
 531
 532 bfd_boolean
 533 bfd_is_arm_special_symbol_name (const char * name, int type)
 534 {
 535   /* The ARM compiler outputs several obsolete forms.  Recognize them
 536      in addition to the standard $a, $t and $d.  We are somewhat loose
 537      in what we accept here, since the full set is not documented.  */
 538   if (!name || name[0] != '$')
 539     return FALSE;
 540   if (name[1] == 'a' || name[1] == 't' || name[1] == 'd')
 541     type &= BFD_ARM_SPECIAL_SYM_TYPE_MAP;
 542   else if (name[1] == 'm' || name[1] == 'f' || name[1] == 'p')
 543     type &= BFD_ARM_SPECIAL_SYM_TYPE_TAG;
 544   else if (name[1] >= 'a' && name[1] <= 'z')
 545     type &= BFD_ARM_SPECIAL_SYM_TYPE_OTHER;
 546   else
 547     return FALSE;
 548
 549   return (type != 0 && (name[2] == 0 || name[2] == '.'));
 550 }
 551