bfd/archures.c

   1 /* BFD library support routines for architectures.
   2    Copyright (C) 1990, 91, 92, 93, 94, 95, 1996 Free Software Foundation, Inc.
   3    Hacked by John Gilmore and Steve Chamberlain of Cygnus Support.
   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 2 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 #include "bfd.h"
  22 #include "sysdep.h"
  23 #include "libbfd.h"
  24 #include <ctype.h>
  25
  26 /*
  27
  28 SECTION
  29         Architectures
  30
  31         BFD keeps one atom in a BFD describing the
  32         architecture of the data attached to the BFD: a pointer to a
  33         <<bfd_arch_info_type>>.
  34
  35         Pointers to structures can be requested independently of a BFD
  36         so that an architecture's information can be interrogated
  37         without access to an open BFD.
  38
  39         The architecture information is provided by each architecture package.
  40         The set of default architectures is selected by the macro
  41         <<SELECT_ARCHITECTURES>>.  This is normally set up in the
  42         @file{config/@var{target}.mt} file of your choice.  If the name is not
  43         defined, then all the architectures supported are included.
  44
  45         When BFD starts up, all the architectures are called with an
  46         initialize method.  It is up to the architecture back end to
  47         insert as many items into the list of architectures as it wants to;
  48         generally this would be one for each machine and one for the
  49         default case (an item with a machine field of 0).
  50
  51         BFD's idea of an architecture is implemented in @file{archures.c}.
  52 */
  53
  54 /*
  55
  56 SUBSECTION
  57         bfd_architecture
  58
  59 DESCRIPTION
  60         This enum gives the object file's CPU architecture, in a
  61         global sense---i.e., what processor family does it belong to?
  62         Another field indicates which processor within
  63         the family is in use.  The machine gives a number which
  64         distinguishes different versions of the architecture,
  65         containing, for example, 2 and 3 for Intel i960 KA and i960 KB,
  66         and 68020 and 68030 for Motorola 68020 and 68030.
  67
  68 .enum bfd_architecture
  69 .{
  70 .  bfd_arch_unknown,   {* File arch not known *}
  71 .  bfd_arch_obscure,   {* Arch known, not one of these *}
  72 .  bfd_arch_m68k,      {* Motorola 68xxx *}
  73 .  bfd_arch_vax,       {* DEC Vax *}
  74 .  bfd_arch_i960,      {* Intel 960 *}
  75 .    {* The order of the following is important.
  76 .       lower number indicates a machine type that
  77 .       only accepts a subset of the instructions
  78 .       available to machines with higher numbers.
  79 .       The exception is the "ca", which is
  80 .       incompatible with all other machines except
  81 .       "core". *}
  82 .
  83 .#define bfd_mach_i960_core      1
  84 .#define bfd_mach_i960_ka_sa     2
  85 .#define bfd_mach_i960_kb_sb     3
  86 .#define bfd_mach_i960_mc        4
  87 .#define bfd_mach_i960_xa        5
  88 .#define bfd_mach_i960_ca        6
  89 .#define bfd_mach_i960_jx        7
  90 .#define bfd_mach_i960_hx        8
  91 .
  92 .  bfd_arch_a29k,      {* AMD 29000 *}
  93 .  bfd_arch_sparc,     {* SPARC *}
  94 .#define bfd_mach_sparc                 1
  95 .{* The difference between v8plus and v9 is that v9 is a true 64 bit env.  *}
  96 .#define bfd_mach_sparc_sparclet        2
  97 .#define bfd_mach_sparc_sparclite       3
  98 .#define bfd_mach_sparc_v8plus          4
  99 .#define bfd_mach_sparc_v8plusa         5 {* with ultrasparc add'ns *}
 100 .#define bfd_mach_sparc_v9              6
 101 .#define bfd_mach_sparc_v9a             7 {* with ultrasparc add'ns *}
 102 .{* Nonzero if MACH has the v9 instruction set.  *}
 103 .#define bfd_mach_sparc_v9_p(mach) \
 104 .  ((mach) >= bfd_mach_sparc_v8plus && (mach) <= bfd_mach_sparc_v9a)
 105 .  bfd_arch_mips,      {* MIPS Rxxxx *}
 106 .  bfd_arch_i386,      {* Intel 386 *}
 107 .#define bfd_mach_i386_i386 0
 108 .#define bfd_mach_i386_i8086 1
 109 .  bfd_arch_we32k,     {* AT&T WE32xxx *}
 110 .  bfd_arch_tahoe,     {* CCI/Harris Tahoe *}
 111 .  bfd_arch_i860,      {* Intel 860 *}
 112 .  bfd_arch_romp,      {* IBM ROMP PC/RT *}
 113 .  bfd_arch_alliant,   {* Alliant *}
 114 .  bfd_arch_convex,    {* Convex *}
 115 .  bfd_arch_m88k,      {* Motorola 88xxx *}
 116 .  bfd_arch_pyramid,   {* Pyramid Technology *}
 117 .  bfd_arch_h8300,     {* Hitachi H8/300 *}
 118 .#define bfd_mach_h8300   1
 119 .#define bfd_mach_h8300h  2
 120 .#define bfd_mach_h8300s  3
 121 .  bfd_arch_powerpc,   {* PowerPC *}
 122 .  bfd_arch_rs6000,    {* IBM RS/6000 *}
 123 .  bfd_arch_hppa,      {* HP PA RISC *}
 124 .  bfd_arch_z8k,       {* Zilog Z8000 *}
 125 .#define bfd_mach_z8001         1
 126 .#define bfd_mach_z8002         2
 127 .  bfd_arch_h8500,     {* Hitachi H8/500 *}
 128 .  bfd_arch_sh,        {* Hitachi SH *}
 129 .  bfd_arch_alpha,     {* Dec Alpha *}
 130 .  bfd_arch_arm,       {* Advanced Risc Machines ARM *}
 131 .  bfd_arch_ns32k,     {* National Semiconductors ns32000 *}
 132 .  bfd_arch_w65,       {* WDC 65816 *}
 133 . {* start-sanitize-arc *}
 134 .  bfd_arch_arc,       {* Argonaut RISC Core *}
 135 .#define bfd_mach_arc_base 0
 136 .#define bfd_mach_arc_host 1
 137 .#define bfd_mach_arc_graphics 2
 138 .#define bfd_mach_arc_audio 3
 139 . {* end-sanitize-arc *}
 140 .  bfd_arch_last
 141 .  };
 142
 143
 144 */
 145
 146 /*
 147
 148 SUBSECTION
 149         bfd_arch_info
 150
 151 DESCRIPTION
 152         This structure contains information on architectures for use
 153         within BFD.
 154
 155 .
 156 .typedef struct bfd_arch_info
 157 .{
 158 .  int bits_per_word;
 159 .  int bits_per_address;
 160 .  int bits_per_byte;
 161 .  enum bfd_architecture arch;
 162 .  unsigned long mach;
 163 .  const char *arch_name;
 164 .  const char *printable_name;
 165 .  unsigned int section_align_power;
 166 . {* true if this is the default machine for the architecture *}
 167 .  boolean the_default;
 168 .  const struct bfd_arch_info * (*compatible)
 169 .       PARAMS ((const struct bfd_arch_info *a,
 170 .                const struct bfd_arch_info *b));
 171 .
 172 .  boolean (*scan) PARAMS ((const struct bfd_arch_info *, const char *));
 173 .
 174 .  const struct bfd_arch_info *next;
 175 .} bfd_arch_info_type;
 176 */
 177
 178 extern const bfd_arch_info_type bfd_a29k_arch;
 179 extern const bfd_arch_info_type bfd_alpha_arch;
 180 /* start-sanitize-arc */
 181 extern const bfd_arch_info_type bfd_arc_arch;
 182 /* end-sanitize-arc */
 183 extern const bfd_arch_info_type bfd_arm_arch;
 184 extern const bfd_arch_info_type bfd_h8300_arch;
 185 extern const bfd_arch_info_type bfd_h8500_arch;
 186 extern const bfd_arch_info_type bfd_hppa_arch;
 187 extern const bfd_arch_info_type bfd_i386_arch;
 188 extern const bfd_arch_info_type bfd_i860_arch;
 189 extern const bfd_arch_info_type bfd_i960_arch;
 190 extern const bfd_arch_info_type bfd_m68k_arch;
 191 extern const bfd_arch_info_type bfd_m88k_arch;
 192 extern const bfd_arch_info_type bfd_mips_arch;
 193 extern const bfd_arch_info_type bfd_powerpc_arch;
 194 extern const bfd_arch_info_type bfd_rs6000_arch;
 195 extern const bfd_arch_info_type bfd_sh_arch;
 196 extern const bfd_arch_info_type bfd_sparc_arch;
 197 extern const bfd_arch_info_type bfd_vax_arch;
 198 extern const bfd_arch_info_type bfd_we32k_arch;
 199 extern const bfd_arch_info_type bfd_z8k_arch;
 200 extern const bfd_arch_info_type bfd_ns32k_arch;
 201 extern const bfd_arch_info_type bfd_w65_arch;
 202
 203 static const bfd_arch_info_type * const bfd_archures_list[] =
 204 {
 205 #ifdef SELECT_ARCHITECTURES
 206   SELECT_ARCHITECTURES,
 207 #else
 208   &bfd_a29k_arch,
 209   &bfd_alpha_arch,
 210 /* start-sanitize-arc */
 211   &bfd_arc_arch,
 212 /* end-sanitize-arc */
 213   &bfd_arm_arch,
 214   &bfd_h8300_arch,
 215   &bfd_h8500_arch,
 216   &bfd_hppa_arch,
 217   &bfd_i386_arch,
 218   &bfd_i860_arch,
 219   &bfd_i960_arch,
 220   &bfd_m68k_arch,
 221   &bfd_m88k_arch,
 222   &bfd_mips_arch,
 223   &bfd_powerpc_arch,
 224   &bfd_rs6000_arch,
 225   &bfd_sh_arch,
 226   &bfd_sparc_arch,
 227   &bfd_vax_arch,
 228   &bfd_we32k_arch,
 229   &bfd_z8k_arch,
 230   &bfd_ns32k_arch,
 231   &bfd_w65_arch,
 232 #endif
 233   0
 234 };
 235
 236 /*
 237 FUNCTION
 238         bfd_printable_name
 239
 240 SYNOPSIS
 241         const char *bfd_printable_name(bfd *abfd);
 242
 243 DESCRIPTION
 244         Return a printable string representing the architecture and machine
 245         from the pointer to the architecture info structure.
 246
 247 */
 248
 249 const char *
 250 bfd_printable_name (abfd)
 251      bfd *abfd;
 252 {
 253   return abfd->arch_info->printable_name;
 254 }
 255
 256
 257
 258 /*
 259 FUNCTION
 260         bfd_scan_arch
 261
 262 SYNOPSIS
 263         const bfd_arch_info_type *bfd_scan_arch(const char *string);
 264
 265 DESCRIPTION
 266         Figure out if BFD supports any cpu which could be described with
 267         the name @var{string}.  Return a pointer to an <<arch_info>>
 268         structure if a machine is found, otherwise NULL.
 269
 270 */
 271
 272 const bfd_arch_info_type *
 273 bfd_scan_arch (string)
 274      const char *string;
 275 {
 276   const bfd_arch_info_type * const *app, *ap;
 277
 278   /* Look through all the installed architectures */
 279   for (app = bfd_archures_list; *app != NULL; app++)
 280     {
 281       for (ap = *app; ap != NULL; ap = ap->next)
 282         {
 283           if (ap->scan (ap, string))
 284             return ap;
 285         }
 286     }
 287
 288   return NULL;
 289 }
 290
 291
 292
 293 /*
 294 FUNCTION
 295         bfd_arch_get_compatible
 296
 297 SYNOPSIS
 298         const bfd_arch_info_type *bfd_arch_get_compatible(
 299                 const bfd *abfd,
 300                 const bfd *bbfd);
 301
 302 DESCRIPTION
 303         Determine whether two BFDs'
 304         architectures and machine types are compatible.  Calculates
 305         the lowest common denominator between the two architectures
 306         and machine types implied by the BFDs and returns a pointer to
 307         an <<arch_info>> structure describing the compatible machine.
 308 */
 309
 310 const bfd_arch_info_type *
 311 bfd_arch_get_compatible (abfd, bbfd)
 312      const bfd *abfd;
 313      const bfd *bbfd;
 314 {
 315   /* If either architecture is unknown, then all we can do is assume
 316      the user knows what he's doing.  */
 317   if (abfd->arch_info->arch == bfd_arch_unknown)
 318         return bbfd->arch_info;
 319   if (bbfd->arch_info->arch == bfd_arch_unknown)
 320         return abfd->arch_info;
 321
 322   /* Otherwise architecture-specific code has to decide.  */
 323   return abfd->arch_info->compatible (abfd->arch_info, bbfd->arch_info);
 324 }
 325
 326
 327 /*
 328 INTERNAL_DEFINITION
 329         bfd_default_arch_struct
 330
 331 DESCRIPTION
 332         The <<bfd_default_arch_struct>> is an item of
 333         <<bfd_arch_info_type>> which has been initialized to a fairly
 334         generic state.  A BFD starts life by pointing to this
 335         structure, until the correct back end has determined the real
 336         architecture of the file.
 337
 338 .extern const bfd_arch_info_type bfd_default_arch_struct;
 339
 340 */
 341
 342 const bfd_arch_info_type bfd_default_arch_struct =
 343 {
 344     32,32,8,bfd_arch_unknown,0,"unknown","unknown",2,true,
 345     bfd_default_compatible,
 346     bfd_default_scan,
 347     0,
 348 };
 349
 350 /*
 351 FUNCTION
 352         bfd_set_arch_info
 353
 354 SYNOPSIS
 355         void bfd_set_arch_info(bfd *abfd, const bfd_arch_info_type *arg);
 356
 357 DESCRIPTION
 358         Set the architecture info of @var{abfd} to @var{arg}.
 359 */
 360
 361 void
 362 bfd_set_arch_info (abfd, arg)
 363      bfd *abfd;
 364      const bfd_arch_info_type *arg;
 365 {
 366   abfd->arch_info = arg;
 367 }
 368
 369 /*
 370 INTERNAL_FUNCTION
 371         bfd_default_set_arch_mach
 372
 373 SYNOPSIS
 374         boolean bfd_default_set_arch_mach(bfd *abfd,
 375                 enum bfd_architecture arch,
 376                 unsigned long mach);
 377
 378 DESCRIPTION
 379         Set the architecture and machine type in BFD @var{abfd}
 380         to @var{arch} and @var{mach}.  Find the correct
 381         pointer to a structure and insert it into the <<arch_info>>
 382         pointer.
 383 */
 384
 385 boolean
 386 bfd_default_set_arch_mach (abfd, arch, mach)
 387      bfd *abfd;
 388      enum bfd_architecture arch;
 389      unsigned long mach;
 390 {
 391   const bfd_arch_info_type * const *app, *ap;
 392
 393   for (app = bfd_archures_list; *app != NULL; app++)
 394     {
 395       for (ap = *app; ap != NULL; ap = ap->next)
 396         {
 397           if (ap->arch == arch
 398               && (ap->mach == mach
 399                   || (mach == 0 && ap->the_default)))
 400             {
 401               abfd->arch_info = ap;
 402               return true;
 403             }
 404         }
 405     }
 406
 407   abfd->arch_info = &bfd_default_arch_struct;
 408   bfd_set_error (bfd_error_bad_value);
 409   return false;
 410 }
 411
 412
 413 /*
 414 FUNCTION
 415         bfd_get_arch
 416
 417 SYNOPSIS
 418         enum bfd_architecture bfd_get_arch(bfd *abfd);
 419
 420 DESCRIPTION
 421         Return the enumerated type which describes the BFD @var{abfd}'s
 422         architecture.
 423
 424 */
 425
 426 enum bfd_architecture
 427 bfd_get_arch (abfd)
 428      bfd *abfd;
 429 {
 430     return abfd->arch_info->arch;
 431 }
 432
 433 /*
 434 FUNCTION
 435         bfd_get_mach
 436
 437 SYNOPSIS
 438         unsigned long bfd_get_mach(bfd *abfd);
 439
 440 DESCRIPTION
 441         Return the long type which describes the BFD @var{abfd}'s
 442         machine.
 443 */
 444
 445 unsigned long
 446 bfd_get_mach (abfd)
 447      bfd *abfd;
 448 {
 449     return abfd->arch_info->mach;
 450 }
 451
 452 /*
 453 FUNCTION
 454         bfd_arch_bits_per_byte
 455
 456 SYNOPSIS
 457         unsigned int bfd_arch_bits_per_byte(bfd *abfd);
 458
 459 DESCRIPTION
 460         Return the number of bits in one of the BFD @var{abfd}'s
 461         architecture's bytes.
 462
 463 */
 464
 465 unsigned int
 466 bfd_arch_bits_per_byte (abfd)
 467      bfd *abfd;
 468 {
 469   return abfd->arch_info->bits_per_byte;
 470 }
 471
 472 /*
 473 FUNCTION
 474         bfd_arch_bits_per_address
 475
 476 SYNOPSIS
 477         unsigned int bfd_arch_bits_per_address(bfd *abfd);
 478
 479 DESCRIPTION
 480         Return the number of bits in one of the BFD @var{abfd}'s
 481         architecture's addresses.
 482 */
 483
 484 unsigned int
 485 bfd_arch_bits_per_address (abfd)
 486      bfd *abfd;
 487 {
 488   return abfd->arch_info->bits_per_address;
 489 }
 490
 491
 492 /*
 493 INTERNAL_FUNCTION
 494         bfd_default_compatible
 495
 496 SYNOPSIS
 497         const bfd_arch_info_type *bfd_default_compatible
 498         (const bfd_arch_info_type *a,
 499         const bfd_arch_info_type *b);
 500
 501 DESCRIPTION
 502         The default function for testing for compatibility.
 503 */
 504
 505 const bfd_arch_info_type *
 506 bfd_default_compatible (a,b)
 507      const bfd_arch_info_type *a;
 508      const bfd_arch_info_type *b;
 509 {
 510   if (a->arch != b->arch)
 511     return NULL;
 512
 513   if (a->mach > b->mach)
 514     return a;
 515
 516   if (b->mach > a->mach)
 517     return b;
 518
 519   return a;
 520 }
 521
 522
 523 /*
 524 INTERNAL_FUNCTION
 525         bfd_default_scan
 526
 527 SYNOPSIS
 528         boolean bfd_default_scan(const struct bfd_arch_info *info, const char *string);
 529
 530 DESCRIPTION
 531         The default function for working out whether this is an
 532         architecture hit and a machine hit.
 533 */
 534
 535 boolean
 536 bfd_default_scan (info, string)
 537      const struct bfd_arch_info *info;
 538      const char *string;
 539 {
 540   const char *ptr_src;
 541   const char *ptr_tst;
 542   unsigned long number;
 543   enum bfd_architecture arch;
 544
 545   /* First test for an exact match */
 546   if (strcmp (string, info->printable_name) == 0)
 547     return true;
 548
 549   /* See how much of the supplied string matches with the
 550      architecture, eg the string m68k:68020 would match the 68k entry
 551      up to the :, then we get left with the machine number */
 552
 553   for (ptr_src = string, ptr_tst = info->arch_name;
 554        *ptr_src && *ptr_tst;
 555        ptr_src++, ptr_tst++)
 556     {
 557       if (*ptr_src != *ptr_tst) break;
 558     }
 559
 560   /* Chewed up as much of the architecture as will match, skip any
 561      colons */
 562   if (*ptr_src == ':')
 563     ptr_src++;
 564
 565   if (*ptr_src == 0)
 566     {
 567       /* nothing more, then only keep this one if it is the default
 568          machine for this architecture */
 569       return info->the_default;
 570     }
 571
 572   number = 0;
 573   while (isdigit(*ptr_src))
 574     {
 575       number = number * 10 + *ptr_src  - '0';
 576       ptr_src++;
 577     }
 578
 579   switch (number)
 580     {
 581     case 65:
 582       arch = bfd_arch_w65;
 583       break;
 584
 585     case 300:
 586       arch = bfd_arch_h8300;
 587       break;
 588
 589     case 500:
 590       arch = bfd_arch_h8500;
 591       break;
 592
 593     case 68010:
 594     case 68020:
 595     case 68030:
 596     case 68040:
 597     case 68332:
 598     case 68050:
 599     case 68000:
 600       arch = bfd_arch_m68k;
 601       break;
 602
 603     case 386:
 604     case 80386:
 605     case 486:
 606     case 80486:
 607       arch = bfd_arch_i386;
 608       break;
 609
 610     case 29000:
 611       arch = bfd_arch_a29k;
 612       break;
 613
 614     case 8000:
 615       arch = bfd_arch_z8k;
 616       break;
 617
 618     case 32000:
 619       arch = bfd_arch_we32k;
 620       break;
 621
 622     case 860:
 623     case 80860:
 624       arch = bfd_arch_i860;
 625       break;
 626     case 960:
 627     case 80960:
 628       arch = bfd_arch_i960;
 629       break;
 630
 631     case 2000:
 632     case 3000:
 633     case 4000:
 634     case 4400:
 635       arch = bfd_arch_mips;
 636       break;
 637
 638     case 6000:
 639       arch = bfd_arch_rs6000;
 640       break;
 641
 642     default:
 643       return false;
 644     }
 645
 646   if (arch != info->arch)
 647     return false;
 648
 649   if (number != info->mach)
 650     return false;
 651
 652   return true;
 653 }
 654
 655
 656 /*
 657 FUNCTION
 658         bfd_get_arch_info
 659
 660 SYNOPSIS
 661         const bfd_arch_info_type * bfd_get_arch_info(bfd *abfd);
 662
 663 DESCRIPTION
 664         Return the architecture info struct in @var{abfd}.
 665 */
 666
 667 const bfd_arch_info_type *
 668 bfd_get_arch_info (abfd)
 669      bfd *abfd;
 670 {
 671   return abfd->arch_info;
 672 }
 673
 674
 675 /*
 676 FUNCTION
 677         bfd_lookup_arch
 678
 679 SYNOPSIS
 680         const bfd_arch_info_type *bfd_lookup_arch
 681                 (enum bfd_architecture
 682                 arch,
 683                 unsigned long machine);
 684
 685 DESCRIPTION
 686         Look for the architecure info structure which matches the
 687         arguments @var{arch} and @var{machine}. A machine of 0 matches the
 688         machine/architecture structure which marks itself as the
 689         default.
 690 */
 691
 692 const bfd_arch_info_type *
 693 bfd_lookup_arch (arch, machine)
 694      enum bfd_architecture arch;
 695      unsigned long machine;
 696 {
 697   const bfd_arch_info_type * const *app, *ap;
 698
 699   for (app = bfd_archures_list; *app != NULL; app++)
 700     {
 701       for (ap = *app; ap != NULL; ap = ap->next)
 702         {
 703           if (ap->arch == arch
 704               && (ap->mach == machine
 705                   || (machine == 0 && ap->the_default)))
 706             return ap;
 707         }
 708     }
 709
 710   return NULL;
 711 }
 712
 713
 714 /*
 715 FUNCTION
 716         bfd_printable_arch_mach
 717
 718 SYNOPSIS
 719         const char *bfd_printable_arch_mach
 720                 (enum bfd_architecture arch, unsigned long machine);
 721
 722 DESCRIPTION
 723         Return a printable string representing the architecture and
 724         machine type.
 725
 726         This routine is depreciated.
 727 */
 728
 729 const char *
 730 bfd_printable_arch_mach (arch, machine)
 731      enum bfd_architecture arch;
 732      unsigned long machine;
 733 {
 734     const bfd_arch_info_type *ap = bfd_lookup_arch (arch, machine);
 735
 736     if (ap)
 737       return ap->printable_name;
 738     return "UNKNOWN!";
 739 }