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