bfd/cpu-arm.c

   1 /* BFD support for the ARM processor
   2    Copyright 1994, 1997, 1999, 2000, 2002, 2003, 2004, 2005, 2006, 2007,
   3    2009, 2010 Free Software Foundation, Inc.
   4    Contributed by Richard Earnshaw (rwe@pegasus.esprit.ec.org)
   5
   6    This file is part of BFD, the Binary File Descriptor library.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  21    MA 02110-1301, USA.  */
  22
  23 #include "sysdep.h"
  24 #include "bfd.h"
  25 #include "libbfd.h"
  26 #include "libiberty.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,  "arm7"     },
  77   { bfd_mach_arm_3,  "arm710"   },
  78   { bfd_mach_arm_3,  "arm7500"  },
  79   { bfd_mach_arm_3,  "arm7d"    },
  80   { bfd_mach_arm_3,  "arm7di"   },
  81   { bfd_mach_arm_3M, "arm7dm"   },
  82   { bfd_mach_arm_3M, "arm7dmi"  },
  83   { bfd_mach_arm_4T, "arm7tdmi" },
  84   { bfd_mach_arm_4,  "arm8"     },
  85   { bfd_mach_arm_4,  "arm810"   },
  86   { bfd_mach_arm_4,  "arm9"     },
  87   { bfd_mach_arm_4,  "arm920"   },
  88   { bfd_mach_arm_4T, "arm920t"  },
  89   { bfd_mach_arm_4T, "arm9tdmi" },
  90   { bfd_mach_arm_4,  "sa1"      },
  91   { bfd_mach_arm_4,  "strongarm"},
  92   { bfd_mach_arm_4,  "strongarm110" },
  93   { bfd_mach_arm_4,  "strongarm1100" },
  94   { bfd_mach_arm_XScale, "xscale" },
  95   { bfd_mach_arm_ep9312, "ep9312" },
  96   { bfd_mach_arm_iWMMXt, "iwmmxt" },
  97   { bfd_mach_arm_iWMMXt2, "iwmmxt2" }
  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, NULL)
 145 };
 146
 147 const bfd_arch_info_type bfd_arm_arch =
 148   N (0, "arm", TRUE, & arch_info_struct[0]);
 149
 150 /* Support functions used by both the COFF and ELF versions of the ARM port.  */
 151
 152 /* Handle the merging of the 'machine' settings of input file IBFD
 153    and an output file OBFD.  These values actually represent the
 154    different possible ARM architecture variants.
 155    Returns TRUE if they were merged successfully or FALSE otherwise.  */
 156
 157 bfd_boolean
 158 bfd_arm_merge_machines (bfd *ibfd, bfd *obfd)
 159 {
 160   unsigned int in  = bfd_get_mach (ibfd);
 161   unsigned int out = bfd_get_mach (obfd);
 162
 163   /* If the output architecture is unknown, we now have a value to set.  */
 164   if (out == bfd_mach_arm_unknown)
 165     bfd_set_arch_mach (obfd, bfd_arch_arm, in);
 166
 167   /* If the input architecture is unknown,
 168      then so must be the output architecture.  */
 169   else if (in == bfd_mach_arm_unknown)
 170     /* FIXME: We ought to have some way to
 171        override this on the command line.  */
 172     bfd_set_arch_mach (obfd, bfd_arch_arm, bfd_mach_arm_unknown);
 173
 174   /* If they are the same then nothing needs to be done.  */
 175   else if (out == in)
 176     ;
 177
 178   /* Otherwise the general principle that a earlier architecture can be
 179      linked with a later architecture to produce a binary that will execute
 180      on the later architecture.
 181
 182      We fail however if we attempt to link a Cirrus EP9312 binary with an
 183      Intel XScale binary, since these architecture have co-processors which
 184      will not both be present on the same physical hardware.  */
 185   else if (in == bfd_mach_arm_ep9312
 186            && (out == bfd_mach_arm_XScale
 187                || out == bfd_mach_arm_iWMMXt
 188                || out == bfd_mach_arm_iWMMXt2))
 189     {
 190       _bfd_error_handler (_("\
 191 error: %B is compiled for the EP9312, whereas %B is compiled for XScale"),
 192                           ibfd, obfd);
 193       bfd_set_error (bfd_error_wrong_format);
 194       return FALSE;
 195     }
 196   else if (out == bfd_mach_arm_ep9312
 197            && (in == bfd_mach_arm_XScale
 198                || in == bfd_mach_arm_iWMMXt
 199                || in == bfd_mach_arm_iWMMXt2))
 200     {
 201       _bfd_error_handler (_("\
 202 error: %B is compiled for the EP9312, whereas %B is compiled for XScale"),
 203                           obfd, ibfd);
 204       bfd_set_error (bfd_error_wrong_format);
 205       return FALSE;
 206     }
 207   else if (in > out)
 208     bfd_set_arch_mach (obfd, bfd_arch_arm, in);
 209   /* else
 210      Nothing to do.  */
 211
 212   return TRUE;
 213 }
 214
 215 typedef struct
 216 {
 217   unsigned char namesz[4];      /* Size of entry's owner string.  */
 218   unsigned char descsz[4];      /* Size of the note descriptor.  */
 219   unsigned char type[4];        /* Interpretation of the descriptor.  */
 220   char          name[1];        /* Start of the name+desc data.  */
 221 } arm_Note;
 222
 223 static bfd_boolean
 224 arm_check_note (bfd *abfd,
 225                 bfd_byte *buffer,
 226                 bfd_size_type buffer_size,
 227                 const char *expected_name,
 228                 char **description_return)
 229 {
 230   unsigned long namesz;
 231   unsigned long descsz;
 232   unsigned long type;
 233   char *        descr;
 234
 235   if (buffer_size < offsetof (arm_Note, name))
 236     return FALSE;
 237
 238   /* We have to extract the values this way to allow for a
 239      host whose endian-ness is different from the target.  */
 240   namesz = bfd_get_32 (abfd, buffer);
 241   descsz = bfd_get_32 (abfd, buffer + offsetof (arm_Note, descsz));
 242   type   = bfd_get_32 (abfd, buffer + offsetof (arm_Note, type));
 243   descr  = (char *) buffer + offsetof (arm_Note, name);
 244
 245   /* Check for buffer overflow.  */
 246   if (namesz + descsz + offsetof (arm_Note, name) > buffer_size)
 247     return FALSE;
 248
 249   if (expected_name == NULL)
 250     {
 251       if (namesz != 0)
 252         return FALSE;
 253     }
 254   else
 255     {
 256       if (namesz != ((strlen (expected_name) + 1 + 3) & ~3))
 257         return FALSE;
 258
 259       if (strcmp (descr, expected_name) != 0)
 260         return FALSE;
 261
 262       descr += (namesz + 3) & ~3;
 263     }
 264
 265   /* FIXME: We should probably check the type as well.  */
 266   (void) type;
 267
 268   if (description_return != NULL)
 269     * description_return = descr;
 270
 271   return TRUE;
 272 }
 273
 274 #define NOTE_ARCH_STRING        "arch: "
 275
 276 bfd_boolean
 277 bfd_arm_update_notes (bfd *abfd, const char *note_section)
 278 {
 279   asection *     arm_arch_section;
 280   bfd_size_type  buffer_size;
 281   bfd_byte *     buffer;
 282   char *         arch_string;
 283   char *         expected;
 284
 285   /* Look for a note section.  If one is present check the architecture
 286      string encoded in it, and set it to the current architecture if it is
 287      different.  */
 288   arm_arch_section = bfd_get_section_by_name (abfd, note_section);
 289
 290   if (arm_arch_section == NULL)
 291     return TRUE;
 292
 293   buffer_size = arm_arch_section->size;
 294   if (buffer_size == 0)
 295     return FALSE;
 296
 297   if (!bfd_malloc_and_get_section (abfd, arm_arch_section, &buffer))
 298     goto FAIL;
 299
 300   /* Parse the note.  */
 301   if (! arm_check_note (abfd, buffer, buffer_size, NOTE_ARCH_STRING, & arch_string))
 302     goto FAIL;
 303
 304   /* Check the architecture in the note against the architecture of the bfd.  */
 305   switch (bfd_get_mach (abfd))
 306     {
 307     default:
 308     case bfd_mach_arm_unknown: expected = "unknown"; break;
 309     case bfd_mach_arm_2:       expected = "armv2"; break;
 310     case bfd_mach_arm_2a:      expected = "armv2a"; break;
 311     case bfd_mach_arm_3:       expected = "armv3"; break;
 312     case bfd_mach_arm_3M:      expected = "armv3M"; break;
 313     case bfd_mach_arm_4:       expected = "armv4"; break;
 314     case bfd_mach_arm_4T:      expected = "armv4t"; break;
 315     case bfd_mach_arm_5:       expected = "armv5"; break;
 316     case bfd_mach_arm_5T:      expected = "armv5t"; break;
 317     case bfd_mach_arm_5TE:     expected = "armv5te"; break;
 318     case bfd_mach_arm_XScale:  expected = "XScale"; break;
 319     case bfd_mach_arm_ep9312:  expected = "ep9312"; break;
 320     case bfd_mach_arm_iWMMXt:  expected = "iWMMXt"; break;
 321     case bfd_mach_arm_iWMMXt2: expected = "iWMMXt2"; break;
 322     }
 323
 324   if (strcmp (arch_string, expected) != 0)
 325     {
 326       strcpy ((char *) buffer + (offsetof (arm_Note, name)
 327                                  + ((strlen (NOTE_ARCH_STRING) + 3) & ~3)),
 328               expected);
 329
 330       if (! bfd_set_section_contents (abfd, arm_arch_section, buffer,
 331                                       (file_ptr) 0, buffer_size))
 332         {
 333           (*_bfd_error_handler)
 334             (_("warning: unable to update contents of %s section in %s"),
 335              note_section, bfd_get_filename (abfd));
 336           goto FAIL;
 337         }
 338     }
 339
 340   free (buffer);
 341   return TRUE;
 342
 343  FAIL:
 344   if (buffer != NULL)
 345     free (buffer);
 346   return FALSE;
 347 }
 348
 349
 350 static struct
 351 {
 352   const char * string;
 353   unsigned int mach;
 354 }
 355 architectures[] =
 356 {
 357   { "armv2",   bfd_mach_arm_2 },
 358   { "armv2a",  bfd_mach_arm_2a },
 359   { "armv3",   bfd_mach_arm_3 },
 360   { "armv3M",  bfd_mach_arm_3M },
 361   { "armv4",   bfd_mach_arm_4 },
 362   { "armv4t",  bfd_mach_arm_4T },
 363   { "armv5",   bfd_mach_arm_5 },
 364   { "armv5t",  bfd_mach_arm_5T },
 365   { "armv5te", bfd_mach_arm_5TE },
 366   { "XScale",  bfd_mach_arm_XScale },
 367   { "ep9312",  bfd_mach_arm_ep9312 },
 368   { "iWMMXt",  bfd_mach_arm_iWMMXt },
 369   { "iWMMXt2", bfd_mach_arm_iWMMXt2 }
 370 };
 371
 372 /* Extract the machine number stored in a note section.  */
 373 unsigned int
 374 bfd_arm_get_mach_from_notes (bfd *abfd, const char *note_section)
 375 {
 376   asection *     arm_arch_section;
 377   bfd_size_type  buffer_size;
 378   bfd_byte *     buffer;
 379   char *         arch_string;
 380   int            i;
 381
 382   /* Look for a note section.  If one is present check the architecture
 383      string encoded in it, and set it to the current architecture if it is
 384      different.  */
 385   arm_arch_section = bfd_get_section_by_name (abfd, note_section);
 386
 387   if (arm_arch_section == NULL)
 388     return bfd_mach_arm_unknown;
 389
 390   buffer_size = arm_arch_section->size;
 391   if (buffer_size == 0)
 392     return bfd_mach_arm_unknown;
 393
 394   if (!bfd_malloc_and_get_section (abfd, arm_arch_section, &buffer))
 395     goto FAIL;
 396
 397   /* Parse the note.  */
 398   if (! arm_check_note (abfd, buffer, buffer_size, NOTE_ARCH_STRING, & arch_string))
 399     goto FAIL;
 400
 401   /* Interpret the architecture string.  */
 402   for (i = ARRAY_SIZE (architectures); i--;)
 403     if (strcmp (arch_string, architectures[i].string) == 0)
 404       {
 405         free (buffer);
 406         return architectures[i].mach;
 407       }
 408
 409  FAIL:
 410   if (buffer != NULL)
 411     free (buffer);
 412   return bfd_mach_arm_unknown;
 413 }
 414
 415 bfd_boolean
 416 bfd_is_arm_special_symbol_name (const char * name, int type)
 417 {
 418   /* The ARM compiler outputs several obsolete forms.  Recognize them
 419      in addition to the standard $a, $t and $d.  We are somewhat loose
 420      in what we accept here, since the full set is not documented.  */
 421   if (!name || name[0] != '$')
 422     return FALSE;
 423   if (name[1] == 'a' || name[1] == 't' || name[1] == 'd')
 424     type &= BFD_ARM_SPECIAL_SYM_TYPE_MAP;
 425   else if (name[1] == 'm' || name[1] == 'f' || name[1] == 'p')
 426     type &= BFD_ARM_SPECIAL_SYM_TYPE_TAG;
 427   else if (name[1] >= 'a' && name[1] <= 'z')
 428     type &= BFD_ARM_SPECIAL_SYM_TYPE_OTHER;
 429   else
 430     return FALSE;
 431
 432   return (type != 0 && (name[2] == 0 || name[2] == '.'));
 433 }
 434