bfd/cpu-arm.c

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