bfd/archures.c

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