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