bfd/cpu-arm.c

   1 /* BFD support for the ARM processor
   2    Copyright (C) 1994-2018 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,  "arm7"     },
  76   { bfd_mach_arm_3,  "arm710"   },
  77   { bfd_mach_arm_3,  "arm7500"  },
  78   { bfd_mach_arm_3,  "arm7d"    },
  79   { bfd_mach_arm_3,  "arm7di"   },
  80   { bfd_mach_arm_3M, "arm7dm"   },
  81   { bfd_mach_arm_3M, "arm7dmi"  },
  82   { bfd_mach_arm_4T, "arm7tdmi" },
  83   { bfd_mach_arm_4,  "arm8"     },
  84   { bfd_mach_arm_4,  "arm810"   },
  85   { bfd_mach_arm_4,  "arm9"     },
  86   { bfd_mach_arm_4,  "arm920"   },
  87   { bfd_mach_arm_4T, "arm920t"  },
  88   { bfd_mach_arm_4T, "arm9tdmi" },
  89   { bfd_mach_arm_4,  "sa1"      },
  90   { bfd_mach_arm_4,  "strongarm"},
  91   { bfd_mach_arm_4,  "strongarm110" },
  92   { bfd_mach_arm_4,  "strongarm1100" },
  93   { bfd_mach_arm_XScale, "xscale" },
  94   { bfd_mach_arm_ep9312, "ep9312" },
  95   { bfd_mach_arm_iWMMXt, "iwmmxt" },
  96   { bfd_mach_arm_iWMMXt2, "iwmmxt2" },
  97   { bfd_mach_arm_unknown, "arm_any" }
  98 };
  99
 100 static bfd_boolean
 101 scan (const struct bfd_arch_info *info, const char *string)
 102 {
 103   int  i;
 104
 105   /* First test for an exact match.  */
 106   if (strcasecmp (string, info->printable_name) == 0)
 107     return TRUE;
 108
 109   /* Next check for a processor name instead of an Architecture name.  */
 110   for (i = sizeof (processors) / sizeof (processors[0]); i--;)
 111     {
 112       if (strcasecmp (string, processors [i].name) == 0)
 113         break;
 114     }
 115
 116   if (i != -1 && info->mach == processors [i].mach)
 117     return TRUE;
 118
 119   /* Finally check for the default architecture.  */
 120   if (strcasecmp (string, "arm") == 0)
 121     return info->the_default;
 122
 123   return FALSE;
 124 }
 125
 126 #define N(number, print, default, next)  \
 127 {  32, 32, 8, bfd_arch_arm, number, "arm", print, 4, default, compatible, \
 128    scan, bfd_arch_default_fill, next }
 129
 130 static const bfd_arch_info_type arch_info_struct[] =
 131 {
 132   N (bfd_mach_arm_2,         "armv2",          FALSE, & arch_info_struct[1]),
 133   N (bfd_mach_arm_2a,        "armv2a",         FALSE, & arch_info_struct[2]),
 134   N (bfd_mach_arm_3,         "armv3",          FALSE, & arch_info_struct[3]),
 135   N (bfd_mach_arm_3M,        "armv3m",         FALSE, & arch_info_struct[4]),
 136   N (bfd_mach_arm_4,         "armv4",          FALSE, & arch_info_struct[5]),
 137   N (bfd_mach_arm_4T,        "armv4t",         FALSE, & arch_info_struct[6]),
 138   N (bfd_mach_arm_5,         "armv5",          FALSE, & arch_info_struct[7]),
 139   N (bfd_mach_arm_5T,        "armv5t",         FALSE, & arch_info_struct[8]),
 140   N (bfd_mach_arm_5TE,       "armv5te",        FALSE, & arch_info_struct[9]),
 141   N (bfd_mach_arm_XScale,    "xscale",         FALSE, & arch_info_struct[10]),
 142   N (bfd_mach_arm_ep9312,    "ep9312",         FALSE, & arch_info_struct[11]),
 143   N (bfd_mach_arm_iWMMXt,    "iwmmxt",         FALSE, & arch_info_struct[12]),
 144   N (bfd_mach_arm_iWMMXt2,   "iwmmxt2",        FALSE, & arch_info_struct[13]),
 145   N (bfd_mach_arm_5TEJ,      "armv5tej",       FALSE, & arch_info_struct[14]),
 146   N (bfd_mach_arm_6,         "armv6",          FALSE, & arch_info_struct[15]),
 147   N (bfd_mach_arm_6KZ,       "armv6kz",        FALSE, & arch_info_struct[16]),
 148   N (bfd_mach_arm_6T2,       "armv6t2",        FALSE, & arch_info_struct[17]),
 149   N (bfd_mach_arm_6K,        "armv6k",         FALSE, & arch_info_struct[18]),
 150   N (bfd_mach_arm_7,         "armv7",          FALSE, & arch_info_struct[19]),
 151   N (bfd_mach_arm_6M,        "armv6-m",        FALSE, & arch_info_struct[20]),
 152   N (bfd_mach_arm_6SM,       "armv6s-m",       FALSE, & arch_info_struct[21]),
 153   N (bfd_mach_arm_7EM,       "armv7e-m",       FALSE, & arch_info_struct[22]),
 154   N (bfd_mach_arm_8,         "armv8-a",        FALSE, & arch_info_struct[23]),
 155   N (bfd_mach_arm_8R,        "armv8-r",        FALSE, & arch_info_struct[24]),
 156   N (bfd_mach_arm_8M_BASE,   "armv8-m.base",   FALSE, & arch_info_struct[25]),
 157   N (bfd_mach_arm_8M_MAIN,   "armv8-m.main",   FALSE, & arch_info_struct[26]),
 158   N (bfd_mach_arm_unknown,   "arm_any",        FALSE, NULL)
 159 };
 160
 161 const bfd_arch_info_type bfd_arm_arch =
 162   N (0, "arm", TRUE, & arch_info_struct[0]);
 163
 164 /* Support functions used by both the COFF and ELF versions of the ARM port.  */
 165
 166 /* Handle the merging of the 'machine' settings of input file IBFD
 167    and an output file OBFD.  These values actually represent the
 168    different possible ARM architecture variants.
 169    Returns TRUE if they were merged successfully or FALSE otherwise.  */
 170
 171 bfd_boolean
 172 bfd_arm_merge_machines (bfd *ibfd, bfd *obfd)
 173 {
 174   unsigned int in  = bfd_get_mach (ibfd);
 175   unsigned int out = bfd_get_mach (obfd);
 176
 177   /* If the output architecture is unknown, we now have a value to set.  */
 178   if (out == bfd_mach_arm_unknown)
 179     bfd_set_arch_mach (obfd, bfd_arch_arm, in);
 180
 181   /* If the input architecture is unknown,
 182      then so must be the output architecture.  */
 183   else if (in == bfd_mach_arm_unknown)
 184     /* FIXME: We ought to have some way to
 185        override this on the command line.  */
 186     bfd_set_arch_mach (obfd, bfd_arch_arm, bfd_mach_arm_unknown);
 187
 188   /* If they are the same then nothing needs to be done.  */
 189   else if (out == in)
 190     ;
 191
 192   /* Otherwise the general principle that a earlier architecture can be
 193      linked with a later architecture to produce a binary that will execute
 194      on the later architecture.
 195
 196      We fail however if we attempt to link a Cirrus EP9312 binary with an
 197      Intel XScale binary, since these architecture have co-processors which
 198      will not both be present on the same physical hardware.  */
 199   else if (in == bfd_mach_arm_ep9312
 200            && (out == bfd_mach_arm_XScale
 201                || out == bfd_mach_arm_iWMMXt
 202                || out == bfd_mach_arm_iWMMXt2))
 203     {
 204       /* xgettext: c-format */
 205       _bfd_error_handler (_("\
 206 error: %pB is compiled for the EP9312, whereas %pB is compiled for XScale"),
 207                           ibfd, obfd);
 208       bfd_set_error (bfd_error_wrong_format);
 209       return FALSE;
 210     }
 211   else if (out == bfd_mach_arm_ep9312
 212            && (in == bfd_mach_arm_XScale
 213                || in == bfd_mach_arm_iWMMXt
 214                || in == bfd_mach_arm_iWMMXt2))
 215     {
 216       /* xgettext: c-format */
 217       _bfd_error_handler (_("\
 218 error: %pB is compiled for the EP9312, whereas %pB is compiled for XScale"),
 219                           obfd, ibfd);
 220       bfd_set_error (bfd_error_wrong_format);
 221       return FALSE;
 222     }
 223   else if (in > out)
 224     bfd_set_arch_mach (obfd, bfd_arch_arm, in);
 225   /* else
 226      Nothing to do.  */
 227
 228   return TRUE;
 229 }
 230
 231 typedef struct
 232 {
 233   unsigned char namesz[4];      /* Size of entry's owner string.  */
 234   unsigned char descsz[4];      /* Size of the note descriptor.  */
 235   unsigned char type[4];        /* Interpretation of the descriptor.  */
 236   char          name[1];        /* Start of the name+desc data.  */
 237 } arm_Note;
 238
 239 static bfd_boolean
 240 arm_check_note (bfd *abfd,
 241                 bfd_byte *buffer,
 242                 bfd_size_type buffer_size,
 243                 const char *expected_name,
 244                 char **description_return)
 245 {
 246   unsigned long namesz;
 247   unsigned long descsz;
 248   unsigned long type;
 249   char *        descr;
 250
 251   if (buffer_size < offsetof (arm_Note, name))
 252     return FALSE;
 253
 254   /* We have to extract the values this way to allow for a
 255      host whose endian-ness is different from the target.  */
 256   namesz = bfd_get_32 (abfd, buffer);
 257   descsz = bfd_get_32 (abfd, buffer + offsetof (arm_Note, descsz));
 258   type   = bfd_get_32 (abfd, buffer + offsetof (arm_Note, type));
 259   descr  = (char *) buffer + offsetof (arm_Note, name);
 260
 261   /* Check for buffer overflow.  */
 262   if (namesz + descsz + offsetof (arm_Note, name) > buffer_size)
 263     return FALSE;
 264
 265   if (expected_name == NULL)
 266     {
 267       if (namesz != 0)
 268         return FALSE;
 269     }
 270   else
 271     {
 272       if (namesz != ((strlen (expected_name) + 1 + 3) & ~3))
 273         return FALSE;
 274
 275       if (strcmp (descr, expected_name) != 0)
 276         return FALSE;
 277
 278       descr += (namesz + 3) & ~3;
 279     }
 280
 281   /* FIXME: We should probably check the type as well.  */
 282   (void) type;
 283
 284   if (description_return != NULL)
 285     * description_return = descr;
 286
 287   return TRUE;
 288 }
 289
 290 #define NOTE_ARCH_STRING        "arch: "
 291
 292 bfd_boolean
 293 bfd_arm_update_notes (bfd *abfd, const char *note_section)
 294 {
 295   asection *     arm_arch_section;
 296   bfd_size_type  buffer_size;
 297   bfd_byte *     buffer;
 298   char *         arch_string;
 299   char *         expected;
 300
 301   /* Look for a note section.  If one is present check the architecture
 302      string encoded in it, and set it to the current architecture if it is
 303      different.  */
 304   arm_arch_section = bfd_get_section_by_name (abfd, note_section);
 305
 306   if (arm_arch_section == NULL)
 307     return TRUE;
 308
 309   buffer_size = arm_arch_section->size;
 310   if (buffer_size == 0)
 311     return FALSE;
 312
 313   if (!bfd_malloc_and_get_section (abfd, arm_arch_section, &buffer))
 314     goto FAIL;
 315
 316   /* Parse the note.  */
 317   if (! arm_check_note (abfd, buffer, buffer_size, NOTE_ARCH_STRING, & arch_string))
 318     goto FAIL;
 319
 320   /* Check the architecture in the note against the architecture of the bfd.  */
 321   switch (bfd_get_mach (abfd))
 322     {
 323     default:
 324     case bfd_mach_arm_unknown: expected = "unknown"; break;
 325     case bfd_mach_arm_2:       expected = "armv2"; break;
 326     case bfd_mach_arm_2a:      expected = "armv2a"; break;
 327     case bfd_mach_arm_3:       expected = "armv3"; break;
 328     case bfd_mach_arm_3M:      expected = "armv3M"; break;
 329     case bfd_mach_arm_4:       expected = "armv4"; break;
 330     case bfd_mach_arm_4T:      expected = "armv4t"; break;
 331     case bfd_mach_arm_5:       expected = "armv5"; break;
 332     case bfd_mach_arm_5T:      expected = "armv5t"; break;
 333     case bfd_mach_arm_5TE:     expected = "armv5te"; break;
 334     case bfd_mach_arm_XScale:  expected = "XScale"; break;
 335     case bfd_mach_arm_ep9312:  expected = "ep9312"; break;
 336     case bfd_mach_arm_iWMMXt:  expected = "iWMMXt"; break;
 337     case bfd_mach_arm_iWMMXt2: expected = "iWMMXt2"; break;
 338     }
 339
 340   if (strcmp (arch_string, expected) != 0)
 341     {
 342       strcpy ((char *) buffer + (offsetof (arm_Note, name)
 343                                  + ((strlen (NOTE_ARCH_STRING) + 3) & ~3)),
 344               expected);
 345
 346       if (! bfd_set_section_contents (abfd, arm_arch_section, buffer,
 347                                       (file_ptr) 0, buffer_size))
 348         {
 349           _bfd_error_handler
 350             /* xgettext: c-format */
 351             (_("warning: unable to update contents of %s section in %pB"),
 352              note_section, abfd);
 353           goto FAIL;
 354         }
 355     }
 356
 357   free (buffer);
 358   return TRUE;
 359
 360  FAIL:
 361   if (buffer != NULL)
 362     free (buffer);
 363   return FALSE;
 364 }
 365
 366
 367 static struct
 368 {
 369   const char * string;
 370   unsigned int mach;
 371 }
 372 architectures[] =
 373 {
 374   { "armv2",   bfd_mach_arm_2 },
 375   { "armv2a",  bfd_mach_arm_2a },
 376   { "armv3",   bfd_mach_arm_3 },
 377   { "armv3M",  bfd_mach_arm_3M },
 378   { "armv4",   bfd_mach_arm_4 },
 379   { "armv4t",  bfd_mach_arm_4T },
 380   { "armv5",   bfd_mach_arm_5 },
 381   { "armv5t",  bfd_mach_arm_5T },
 382   { "armv5te", bfd_mach_arm_5TE },
 383   { "XScale",  bfd_mach_arm_XScale },
 384   { "ep9312",  bfd_mach_arm_ep9312 },
 385   { "iWMMXt",  bfd_mach_arm_iWMMXt },
 386   { "iWMMXt2", bfd_mach_arm_iWMMXt2 },
 387   { "arm_any", bfd_mach_arm_unknown }
 388 };
 389
 390 /* Extract the machine number stored in a note section.  */
 391 unsigned int
 392 bfd_arm_get_mach_from_notes (bfd *abfd, const char *note_section)
 393 {
 394   asection *     arm_arch_section;
 395   bfd_size_type  buffer_size;
 396   bfd_byte *     buffer;
 397   char *         arch_string;
 398   int            i;
 399
 400   /* Look for a note section.  If one is present check the architecture
 401      string encoded in it, and set it to the current architecture if it is
 402      different.  */
 403   arm_arch_section = bfd_get_section_by_name (abfd, note_section);
 404
 405   if (arm_arch_section == NULL)
 406     return bfd_mach_arm_unknown;
 407
 408   buffer_size = arm_arch_section->size;
 409   if (buffer_size == 0)
 410     return bfd_mach_arm_unknown;
 411
 412   if (!bfd_malloc_and_get_section (abfd, arm_arch_section, &buffer))
 413     goto FAIL;
 414
 415   /* Parse the note.  */
 416   if (! arm_check_note (abfd, buffer, buffer_size, NOTE_ARCH_STRING, & arch_string))
 417     goto FAIL;
 418
 419   /* Interpret the architecture string.  */
 420   for (i = ARRAY_SIZE (architectures); i--;)
 421     if (strcmp (arch_string, architectures[i].string) == 0)
 422       {
 423         free (buffer);
 424         return architectures[i].mach;
 425       }
 426
 427  FAIL:
 428   if (buffer != NULL)
 429     free (buffer);
 430   return bfd_mach_arm_unknown;
 431 }
 432
 433 bfd_boolean
 434 bfd_is_arm_special_symbol_name (const char * name, int type)
 435 {
 436   /* The ARM compiler outputs several obsolete forms.  Recognize them
 437      in addition to the standard $a, $t and $d.  We are somewhat loose
 438      in what we accept here, since the full set is not documented.  */
 439   if (!name || name[0] != '$')
 440     return FALSE;
 441   if (name[1] == 'a' || name[1] == 't' || name[1] == 'd')
 442     type &= BFD_ARM_SPECIAL_SYM_TYPE_MAP;
 443   else if (name[1] == 'm' || name[1] == 'f' || name[1] == 'p')
 444     type &= BFD_ARM_SPECIAL_SYM_TYPE_TAG;
 445   else if (name[1] >= 'a' && name[1] <= 'z')
 446     type &= BFD_ARM_SPECIAL_SYM_TYPE_OTHER;
 447   else
 448     return FALSE;
 449
 450   return (type != 0 && (name[2] == 0 || name[2] == '.'));
 451 }
 452