bfd/cpu-arm.c

   1 /* BFD support for the ARM processor
   2    Copyright (C) 1994-2016 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_unknown, "arm_any", FALSE, NULL)
 146 };
 147
 148 const bfd_arch_info_type bfd_arm_arch =
 149   N (0, "arm", TRUE, & arch_info_struct[0]);
 150
 151 /* Support functions used by both the COFF and ELF versions of the ARM port.  */
 152
 153 /* Handle the merging of the 'machine' settings of input file IBFD
 154    and an output file OBFD.  These values actually represent the
 155    different possible ARM architecture variants.
 156    Returns TRUE if they were merged successfully or FALSE otherwise.  */
 157
 158 bfd_boolean
 159 bfd_arm_merge_machines (bfd *ibfd, bfd *obfd)
 160 {
 161   unsigned int in  = bfd_get_mach (ibfd);
 162   unsigned int out = bfd_get_mach (obfd);
 163
 164   /* If the output architecture is unknown, we now have a value to set.  */
 165   if (out == bfd_mach_arm_unknown)
 166     bfd_set_arch_mach (obfd, bfd_arch_arm, in);
 167
 168   /* If the input architecture is unknown,
 169      then so must be the output architecture.  */
 170   else if (in == bfd_mach_arm_unknown)
 171     /* FIXME: We ought to have some way to
 172        override this on the command line.  */
 173     bfd_set_arch_mach (obfd, bfd_arch_arm, bfd_mach_arm_unknown);
 174
 175   /* If they are the same then nothing needs to be done.  */
 176   else if (out == in)
 177     ;
 178
 179   /* Otherwise the general principle that a earlier architecture can be
 180      linked with a later architecture to produce a binary that will execute
 181      on the later architecture.
 182
 183      We fail however if we attempt to link a Cirrus EP9312 binary with an
 184      Intel XScale binary, since these architecture have co-processors which
 185      will not both be present on the same physical hardware.  */
 186   else if (in == bfd_mach_arm_ep9312
 187            && (out == bfd_mach_arm_XScale
 188                || out == bfd_mach_arm_iWMMXt
 189                || out == bfd_mach_arm_iWMMXt2))
 190     {
 191       _bfd_error_handler (_("\
 192 error: %B is compiled for the EP9312, whereas %B is compiled for XScale"),
 193                           ibfd, obfd);
 194       bfd_set_error (bfd_error_wrong_format);
 195       return FALSE;
 196     }
 197   else if (out == bfd_mach_arm_ep9312
 198            && (in == bfd_mach_arm_XScale
 199                || in == bfd_mach_arm_iWMMXt
 200                || in == bfd_mach_arm_iWMMXt2))
 201     {
 202       _bfd_error_handler (_("\
 203 error: %B is compiled for the EP9312, whereas %B is compiled for XScale"),
 204                           obfd, ibfd);
 205       bfd_set_error (bfd_error_wrong_format);
 206       return FALSE;
 207     }
 208   else if (in > out)
 209     bfd_set_arch_mach (obfd, bfd_arch_arm, in);
 210   /* else
 211      Nothing to do.  */
 212
 213   return TRUE;
 214 }
 215
 216 typedef struct
 217 {
 218   unsigned char namesz[4];      /* Size of entry's owner string.  */
 219   unsigned char descsz[4];      /* Size of the note descriptor.  */
 220   unsigned char type[4];        /* Interpretation of the descriptor.  */
 221   char          name[1];        /* Start of the name+desc data.  */
 222 } arm_Note;
 223
 224 static bfd_boolean
 225 arm_check_note (bfd *abfd,
 226                 bfd_byte *buffer,
 227                 bfd_size_type buffer_size,
 228                 const char *expected_name,
 229                 char **description_return)
 230 {
 231   unsigned long namesz;
 232   unsigned long descsz;
 233   unsigned long type;
 234   char *        descr;
 235
 236   if (buffer_size < offsetof (arm_Note, name))
 237     return FALSE;
 238
 239   /* We have to extract the values this way to allow for a
 240      host whose endian-ness is different from the target.  */
 241   namesz = bfd_get_32 (abfd, buffer);
 242   descsz = bfd_get_32 (abfd, buffer + offsetof (arm_Note, descsz));
 243   type   = bfd_get_32 (abfd, buffer + offsetof (arm_Note, type));
 244   descr  = (char *) buffer + offsetof (arm_Note, name);
 245
 246   /* Check for buffer overflow.  */
 247   if (namesz + descsz + offsetof (arm_Note, name) > buffer_size)
 248     return FALSE;
 249
 250   if (expected_name == NULL)
 251     {
 252       if (namesz != 0)
 253         return FALSE;
 254     }
 255   else
 256     {
 257       if (namesz != ((strlen (expected_name) + 1 + 3) & ~3))
 258         return FALSE;
 259
 260       if (strcmp (descr, expected_name) != 0)
 261         return FALSE;
 262
 263       descr += (namesz + 3) & ~3;
 264     }
 265
 266   /* FIXME: We should probably check the type as well.  */
 267   (void) type;
 268
 269   if (description_return != NULL)
 270     * description_return = descr;
 271
 272   return TRUE;
 273 }
 274
 275 #define NOTE_ARCH_STRING        "arch: "
 276
 277 bfd_boolean
 278 bfd_arm_update_notes (bfd *abfd, const char *note_section)
 279 {
 280   asection *     arm_arch_section;
 281   bfd_size_type  buffer_size;
 282   bfd_byte *     buffer;
 283   char *         arch_string;
 284   char *         expected;
 285
 286   /* Look for a note section.  If one is present check the architecture
 287      string encoded in it, and set it to the current architecture if it is
 288      different.  */
 289   arm_arch_section = bfd_get_section_by_name (abfd, note_section);
 290
 291   if (arm_arch_section == NULL)
 292     return TRUE;
 293
 294   buffer_size = arm_arch_section->size;
 295   if (buffer_size == 0)
 296     return FALSE;
 297
 298   if (!bfd_malloc_and_get_section (abfd, arm_arch_section, &buffer))
 299     goto FAIL;
 300
 301   /* Parse the note.  */
 302   if (! arm_check_note (abfd, buffer, buffer_size, NOTE_ARCH_STRING, & arch_string))
 303     goto FAIL;
 304
 305   /* Check the architecture in the note against the architecture of the bfd.  */
 306   switch (bfd_get_mach (abfd))
 307     {
 308     default:
 309     case bfd_mach_arm_unknown: expected = "unknown"; break;
 310     case bfd_mach_arm_2:       expected = "armv2"; break;
 311     case bfd_mach_arm_2a:      expected = "armv2a"; break;
 312     case bfd_mach_arm_3:       expected = "armv3"; break;
 313     case bfd_mach_arm_3M:      expected = "armv3M"; break;
 314     case bfd_mach_arm_4:       expected = "armv4"; break;
 315     case bfd_mach_arm_4T:      expected = "armv4t"; break;
 316     case bfd_mach_arm_5:       expected = "armv5"; break;
 317     case bfd_mach_arm_5T:      expected = "armv5t"; break;
 318     case bfd_mach_arm_5TE:     expected = "armv5te"; break;
 319     case bfd_mach_arm_XScale:  expected = "XScale"; break;
 320     case bfd_mach_arm_ep9312:  expected = "ep9312"; break;
 321     case bfd_mach_arm_iWMMXt:  expected = "iWMMXt"; break;
 322     case bfd_mach_arm_iWMMXt2: expected = "iWMMXt2"; break;
 323     }
 324
 325   if (strcmp (arch_string, expected) != 0)
 326     {
 327       strcpy ((char *) buffer + (offsetof (arm_Note, name)
 328                                  + ((strlen (NOTE_ARCH_STRING) + 3) & ~3)),
 329               expected);
 330
 331       if (! bfd_set_section_contents (abfd, arm_arch_section, buffer,
 332                                       (file_ptr) 0, buffer_size))
 333         {
 334           _bfd_error_handler
 335             (_("warning: unable to update contents of %s section in %s"),
 336              note_section, bfd_get_filename (abfd));
 337           goto FAIL;
 338         }
 339     }
 340
 341   free (buffer);
 342   return TRUE;
 343
 344  FAIL:
 345   if (buffer != NULL)
 346     free (buffer);
 347   return FALSE;
 348 }
 349
 350
 351 static struct
 352 {
 353   const char * string;
 354   unsigned int mach;
 355 }
 356 architectures[] =
 357 {
 358   { "armv2",   bfd_mach_arm_2 },
 359   { "armv2a",  bfd_mach_arm_2a },
 360   { "armv3",   bfd_mach_arm_3 },
 361   { "armv3M",  bfd_mach_arm_3M },
 362   { "armv4",   bfd_mach_arm_4 },
 363   { "armv4t",  bfd_mach_arm_4T },
 364   { "armv5",   bfd_mach_arm_5 },
 365   { "armv5t",  bfd_mach_arm_5T },
 366   { "armv5te", bfd_mach_arm_5TE },
 367   { "XScale",  bfd_mach_arm_XScale },
 368   { "ep9312",  bfd_mach_arm_ep9312 },
 369   { "iWMMXt",  bfd_mach_arm_iWMMXt },
 370   { "iWMMXt2", bfd_mach_arm_iWMMXt2 },
 371   { "arm_any", bfd_mach_arm_unknown }
 372 };
 373
 374 /* Extract the machine number stored in a note section.  */
 375 unsigned int
 376 bfd_arm_get_mach_from_notes (bfd *abfd, const char *note_section)
 377 {
 378   asection *     arm_arch_section;
 379   bfd_size_type  buffer_size;
 380   bfd_byte *     buffer;
 381   char *         arch_string;
 382   int            i;
 383
 384   /* Look for a note section.  If one is present check the architecture
 385      string encoded in it, and set it to the current architecture if it is
 386      different.  */
 387   arm_arch_section = bfd_get_section_by_name (abfd, note_section);
 388
 389   if (arm_arch_section == NULL)
 390     return bfd_mach_arm_unknown;
 391
 392   buffer_size = arm_arch_section->size;
 393   if (buffer_size == 0)
 394     return bfd_mach_arm_unknown;
 395
 396   if (!bfd_malloc_and_get_section (abfd, arm_arch_section, &buffer))
 397     goto FAIL;
 398
 399   /* Parse the note.  */
 400   if (! arm_check_note (abfd, buffer, buffer_size, NOTE_ARCH_STRING, & arch_string))
 401     goto FAIL;
 402
 403   /* Interpret the architecture string.  */
 404   for (i = ARRAY_SIZE (architectures); i--;)
 405     if (strcmp (arch_string, architectures[i].string) == 0)
 406       {
 407         free (buffer);
 408         return architectures[i].mach;
 409       }
 410
 411  FAIL:
 412   if (buffer != NULL)
 413     free (buffer);
 414   return bfd_mach_arm_unknown;
 415 }
 416
 417 bfd_boolean
 418 bfd_is_arm_special_symbol_name (const char * name, int type)
 419 {
 420   /* The ARM compiler outputs several obsolete forms.  Recognize them
 421      in addition to the standard $a, $t and $d.  We are somewhat loose
 422      in what we accept here, since the full set is not documented.  */
 423   if (!name || name[0] != '$')
 424     return FALSE;
 425   if (name[1] == 'a' || name[1] == 't' || name[1] == 'd')
 426     type &= BFD_ARM_SPECIAL_SYM_TYPE_MAP;
 427   else if (name[1] == 'm' || name[1] == 'f' || name[1] == 'p')
 428     type &= BFD_ARM_SPECIAL_SYM_TYPE_TAG;
 429   else if (name[1] >= 'a' && name[1] <= 'z')
 430     type &= BFD_ARM_SPECIAL_SYM_TYPE_OTHER;
 431   else
 432     return FALSE;
 433
 434   return (type != 0 && (name[2] == 0 || name[2] == '.'));
 435 }
 436