bfd/archures.c

   1 /* BFD library support routines for architectures.
   2    Copyright (C) 1990, 91-98, 1999 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 .#define bfd_mach_m68000 1
  74 .#define bfd_mach_m68008 2
  75 .#define bfd_mach_m68010 3
  76 .#define bfd_mach_m68020 4
  77 .#define bfd_mach_m68030 5
  78 .#define bfd_mach_m68040 6
  79 .#define bfd_mach_m68060 7
  80 .#define bfd_mach_cpu32  8
  81 .  bfd_arch_vax,       {* DEC Vax *}
  82 .  bfd_arch_i960,      {* Intel 960 *}
  83 .    {* The order of the following is important.
  84 .       lower number indicates a machine type that
  85 .       only accepts a subset of the instructions
  86 .       available to machines with higher numbers.
  87 .       The exception is the "ca", which is
  88 .       incompatible with all other machines except
  89 .       "core". *}
  90 .
  91 .#define bfd_mach_i960_core      1
  92 .#define bfd_mach_i960_ka_sa     2
  93 .#define bfd_mach_i960_kb_sb     3
  94 .#define bfd_mach_i960_mc        4
  95 .#define bfd_mach_i960_xa        5
  96 .#define bfd_mach_i960_ca        6
  97 .#define bfd_mach_i960_jx        7
  98 .#define bfd_mach_i960_hx        8
  99 .
 100 .  bfd_arch_a29k,      {* AMD 29000 *}
 101 .  bfd_arch_sparc,     {* SPARC *}
 102 .#define bfd_mach_sparc                 1
 103 .{* The difference between v8plus and v9 is that v9 is a true 64 bit env.  *}
 104 .#define bfd_mach_sparc_sparclet        2
 105 .#define bfd_mach_sparc_sparclite       3
 106 .#define bfd_mach_sparc_v8plus          4
 107 .#define bfd_mach_sparc_v8plusa         5 {* with ultrasparc add'ns *}
 108 .#define bfd_mach_sparc_sparclite_le    6
 109 .#define bfd_mach_sparc_v9              7
 110 .#define bfd_mach_sparc_v9a             8 {* with ultrasparc add'ns *}
 111 .{* Nonzero if MACH has the v9 instruction set.  *}
 112 .#define bfd_mach_sparc_v9_p(mach) \
 113 .  ((mach) >= bfd_mach_sparc_v8plus && (mach) <= bfd_mach_sparc_v9a)
 114 .  bfd_arch_mips,      {* MIPS Rxxxx *}
 115 .#define bfd_mach_mips3000              3000
 116 .#define bfd_mach_mips3900              3900
 117 .#define bfd_mach_mips4000              4000
 118 .#define bfd_mach_mips4010              4010
 119 .#define bfd_mach_mips4100              4100
 120 .#define bfd_mach_mips4111              4111
 121 .#define bfd_mach_mips4300              4300
 122 .#define bfd_mach_mips4400              4400
 123 .#define bfd_mach_mips4600              4600
 124 .#define bfd_mach_mips4650              4650
 125 .#define bfd_mach_mips5000              5000
 126 .#define bfd_mach_mips6000              6000
 127 .#define bfd_mach_mips8000              8000
 128 .#define bfd_mach_mips10000             10000
 129 .#define bfd_mach_mips16                16
 130 .  bfd_arch_i386,      {* Intel 386 *}
 131 .#define bfd_mach_i386_i386 0
 132 .#define bfd_mach_i386_i8086 1
 133 .#define bfd_mach_i386_i386_intel_syntax 2
 134 .  bfd_arch_we32k,     {* AT&T WE32xxx *}
 135 .  bfd_arch_tahoe,     {* CCI/Harris Tahoe *}
 136 .  bfd_arch_i860,      {* Intel 860 *}
 137 .  bfd_arch_romp,      {* IBM ROMP PC/RT *}
 138 .  bfd_arch_alliant,   {* Alliant *}
 139 .  bfd_arch_convex,    {* Convex *}
 140 .  bfd_arch_m88k,      {* Motorola 88xxx *}
 141 .  bfd_arch_pyramid,   {* Pyramid Technology *}
 142 .  bfd_arch_h8300,     {* Hitachi H8/300 *}
 143 .#define bfd_mach_h8300   1
 144 .#define bfd_mach_h8300h  2
 145 .#define bfd_mach_h8300s  3
 146 .  bfd_arch_powerpc,   {* PowerPC *}
 147 .  bfd_arch_rs6000,    {* IBM RS/6000 *}
 148 .  bfd_arch_hppa,      {* HP PA RISC *}
 149 .  bfd_arch_d10v,      {* Mitsubishi D10V *}
 150 .  bfd_arch_d30v,      {* Mitsubishi D30V *}
 151 .  bfd_arch_z8k,       {* Zilog Z8000 *}
 152 .#define bfd_mach_z8001         1
 153 .#define bfd_mach_z8002         2
 154 .  bfd_arch_h8500,     {* Hitachi H8/500 *}
 155 .  bfd_arch_sh,        {* Hitachi SH *}
 156 .#define bfd_mach_sh            0
 157 .#define bfd_mach_sh3        0x30
 158 .#define bfd_mach_sh3e       0x3e
 159 .  bfd_arch_alpha,     {* Dec Alpha *}
 160 .#define bfd_mach_alpha_ev4  0x10
 161 .#define bfd_mach_alpha_ev5  0x20
 162 .#define bfd_mach_alpha_ev6  0x30
 163 .  bfd_arch_arm,       {* Advanced Risc Machines ARM *}
 164 .#define bfd_mach_arm_2         1
 165 .#define bfd_mach_arm_2a        2
 166 .#define bfd_mach_arm_3         3
 167 .#define bfd_mach_arm_3M        4
 168 .#define bfd_mach_arm_4         5
 169 .#define bfd_mach_arm_4T        6
 170 .#define bfd_mach_arm_5         7
 171 .#define bfd_mach_arm_5T        8
 172 .  bfd_arch_ns32k,     {* National Semiconductors ns32000 *}
 173 .  bfd_arch_w65,       {* WDC 65816 *}
 174 .  bfd_arch_tic30,     {* Texas Instruments TMS320C30 *}
 175 .  bfd_arch_tic80,     {* TI TMS320c80 (MVP) *}
 176 .  bfd_arch_v850,      {* NEC V850 *}
 177 .#define bfd_mach_v850          0
 178 .#define bfd_mach_v850e         'E'
 179 .#define bfd_mach_v850ea        'A'
 180 .  bfd_arch_arc,       {* Argonaut RISC Core *}
 181 .#define bfd_mach_arc_base 0
 182 .  bfd_arch_m32r,      {* Mitsubishi M32R/D *}
 183 .#define bfd_mach_m32r          0 {* backwards compatibility *}
 184 .  bfd_arch_mn10200,   {* Matsushita MN10200 *}
 185 .  bfd_arch_mn10300,   {* Matsushita MN10300 *}
 186 .#define bfd_mach_mn10300               300
 187 .  bfd_arch_fr30,
 188 .#define bfd_mach_fr30          0x46523330
 189 .  bfd_arch_mcore,
 190 .  bfd_arch_last
 191 .  };
 192
 193
 194 */
 195
 196 /*
 197
 198 SUBSECTION
 199         bfd_arch_info
 200
 201 DESCRIPTION
 202         This structure contains information on architectures for use
 203         within BFD.
 204
 205 .
 206 .typedef struct bfd_arch_info
 207 .{
 208 .  int bits_per_word;
 209 .  int bits_per_address;
 210 .  int bits_per_byte;
 211 .  enum bfd_architecture arch;
 212 .  unsigned long mach;
 213 .  const char *arch_name;
 214 .  const char *printable_name;
 215 .  unsigned int section_align_power;
 216 . {* true if this is the default machine for the architecture *}
 217 .  boolean the_default;
 218 .  const struct bfd_arch_info * (*compatible)
 219 .       PARAMS ((const struct bfd_arch_info *a,
 220 .                const struct bfd_arch_info *b));
 221 .
 222 .  boolean (*scan) PARAMS ((const struct bfd_arch_info *, const char *));
 223 .
 224 .  const struct bfd_arch_info *next;
 225 .} bfd_arch_info_type;
 226 */
 227
 228 extern const bfd_arch_info_type bfd_a29k_arch;
 229 extern const bfd_arch_info_type bfd_alpha_arch;
 230 extern const bfd_arch_info_type bfd_arc_arch;
 231 extern const bfd_arch_info_type bfd_arm_arch;
 232 extern const bfd_arch_info_type bfd_d10v_arch;
 233 extern const bfd_arch_info_type bfd_d30v_arch;
 234 extern const bfd_arch_info_type bfd_h8300_arch;
 235 extern const bfd_arch_info_type bfd_h8500_arch;
 236 extern const bfd_arch_info_type bfd_hppa_arch;
 237 extern const bfd_arch_info_type bfd_i386_arch;
 238 extern const bfd_arch_info_type bfd_i860_arch;
 239 extern const bfd_arch_info_type bfd_i960_arch;
 240 extern const bfd_arch_info_type bfd_m32r_arch;
 241 extern const bfd_arch_info_type bfd_m68k_arch;
 242 extern const bfd_arch_info_type bfd_m88k_arch;
 243 extern const bfd_arch_info_type bfd_mips_arch;
 244 extern const bfd_arch_info_type bfd_mn10200_arch;
 245 extern const bfd_arch_info_type bfd_mn10300_arch;
 246 extern const bfd_arch_info_type bfd_powerpc_arch;
 247 extern const bfd_arch_info_type bfd_rs6000_arch;
 248 extern const bfd_arch_info_type bfd_sh_arch;
 249 extern const bfd_arch_info_type bfd_sparc_arch;
 250 extern const bfd_arch_info_type bfd_tic30_arch;
 251 extern const bfd_arch_info_type bfd_tic80_arch;
 252 extern const bfd_arch_info_type bfd_vax_arch;
 253 extern const bfd_arch_info_type bfd_we32k_arch;
 254 extern const bfd_arch_info_type bfd_z8k_arch;
 255 extern const bfd_arch_info_type bfd_ns32k_arch;
 256 extern const bfd_arch_info_type bfd_w65_arch;
 257 extern const bfd_arch_info_type bfd_v850_arch;
 258 extern const bfd_arch_info_type bfd_fr30_arch;
 259 extern const bfd_arch_info_type bfd_mcore_arch;
 260
 261 static const bfd_arch_info_type * const bfd_archures_list[] =
 262 {
 263 #ifdef SELECT_ARCHITECTURES
 264   SELECT_ARCHITECTURES,
 265 #else
 266   &bfd_a29k_arch,
 267   &bfd_alpha_arch,
 268   &bfd_arc_arch,
 269   &bfd_arm_arch,
 270   &bfd_d10v_arch,
 271   &bfd_d30v_arch,
 272   &bfd_h8300_arch,
 273   &bfd_h8500_arch,
 274   &bfd_hppa_arch,
 275   &bfd_i386_arch,
 276   &bfd_i860_arch,
 277   &bfd_i960_arch,
 278   &bfd_m32r_arch,
 279   &bfd_m68k_arch,
 280   &bfd_m88k_arch,
 281   &bfd_mips_arch,
 282   &bfd_mn10200_arch,
 283   &bfd_mn10300_arch,
 284   &bfd_powerpc_arch,
 285   &bfd_rs6000_arch,
 286   &bfd_sh_arch,
 287   &bfd_sparc_arch,
 288   &bfd_tic30_arch,
 289   &bfd_tic80_arch,
 290   &bfd_vax_arch,
 291   &bfd_we32k_arch,
 292   &bfd_z8k_arch,
 293   &bfd_ns32k_arch,
 294   &bfd_w65_arch,
 295   &bfd_v850_arch,
 296   &bfd_fr30_arch,
 297   & bfd_mcore_arch,
 298 #endif
 299   0
 300 };
 301
 302 /*
 303 FUNCTION
 304         bfd_printable_name
 305
 306 SYNOPSIS
 307         const char *bfd_printable_name(bfd *abfd);
 308
 309 DESCRIPTION
 310         Return a printable string representing the architecture and machine
 311         from the pointer to the architecture info structure.
 312
 313 */
 314
 315 const char *
 316 bfd_printable_name (abfd)
 317      bfd *abfd;
 318 {
 319   return abfd->arch_info->printable_name;
 320 }
 321
 322
 323
 324 /*
 325 FUNCTION
 326         bfd_scan_arch
 327
 328 SYNOPSIS
 329         const bfd_arch_info_type *bfd_scan_arch(const char *string);
 330
 331 DESCRIPTION
 332         Figure out if BFD supports any cpu which could be described with
 333         the name @var{string}.  Return a pointer to an <<arch_info>>
 334         structure if a machine is found, otherwise NULL.
 335
 336 */
 337
 338 const bfd_arch_info_type *
 339 bfd_scan_arch (string)
 340      const char *string;
 341 {
 342   const bfd_arch_info_type * const *app, *ap;
 343
 344   /* Look through all the installed architectures */
 345   for (app = bfd_archures_list; *app != NULL; app++)
 346     {
 347       for (ap = *app; ap != NULL; ap = ap->next)
 348         {
 349           if (ap->scan (ap, string))
 350             return ap;
 351         }
 352     }
 353
 354   return NULL;
 355 }
 356
 357
 358
 359 /*
 360 FUNCTION
 361         bfd_arch_list
 362
 363 SYNOPSIS
 364         const char **bfd_arch_list(void);
 365
 366 DESCRIPTION
 367         Return a freshly malloced NULL-terminated vector of the names
 368         of all the valid BFD architectures.  Do not modify the names.
 369
 370 */
 371
 372 const char **
 373 bfd_arch_list ()
 374 {
 375   int vec_length = 0;
 376   const char **name_ptr;
 377   const char **name_list;
 378   const bfd_arch_info_type * const *app;
 379
 380   /* Determine the number of architectures */
 381   vec_length = 0;
 382   for (app = bfd_archures_list; *app != NULL; app++)
 383     {
 384       const bfd_arch_info_type *ap;
 385       for (ap = *app; ap != NULL; ap = ap->next)
 386         {
 387           vec_length++;
 388         }
 389     }
 390
 391   name_list = (CONST char **)
 392     bfd_malloc ((vec_length + 1) * sizeof (char **));
 393   if (name_list == NULL)
 394     return NULL;
 395
 396   /* Point the list at each of the names */
 397   name_ptr = name_list;
 398   for (app = bfd_archures_list; *app != NULL; app++)
 399     {
 400       const bfd_arch_info_type *ap;
 401       for (ap = *app; ap != NULL; ap = ap->next)
 402         {
 403           *name_ptr = ap->printable_name;
 404           name_ptr++;
 405         }
 406     }
 407   *name_ptr = NULL;
 408
 409   return name_list;
 410 }
 411
 412
 413
 414 /*
 415 FUNCTION
 416         bfd_arch_get_compatible
 417
 418 SYNOPSIS
 419         const bfd_arch_info_type *bfd_arch_get_compatible(
 420                 const bfd *abfd,
 421                 const bfd *bbfd);
 422
 423 DESCRIPTION
 424         Determine whether two BFDs'
 425         architectures and machine types are compatible.  Calculates
 426         the lowest common denominator between the two architectures
 427         and machine types implied by the BFDs and returns a pointer to
 428         an <<arch_info>> structure describing the compatible machine.
 429 */
 430
 431 const bfd_arch_info_type *
 432 bfd_arch_get_compatible (abfd, bbfd)
 433      const bfd *abfd;
 434      const bfd *bbfd;
 435 {
 436   /* If either architecture is unknown, then all we can do is assume
 437      the user knows what he's doing.  */
 438   if (abfd->arch_info->arch == bfd_arch_unknown)
 439         return bbfd->arch_info;
 440   if (bbfd->arch_info->arch == bfd_arch_unknown)
 441         return abfd->arch_info;
 442
 443   /* Otherwise architecture-specific code has to decide.  */
 444   return abfd->arch_info->compatible (abfd->arch_info, bbfd->arch_info);
 445 }
 446
 447
 448 /*
 449 INTERNAL_DEFINITION
 450         bfd_default_arch_struct
 451
 452 DESCRIPTION
 453         The <<bfd_default_arch_struct>> is an item of
 454         <<bfd_arch_info_type>> which has been initialized to a fairly
 455         generic state.  A BFD starts life by pointing to this
 456         structure, until the correct back end has determined the real
 457         architecture of the file.
 458
 459 .extern const bfd_arch_info_type bfd_default_arch_struct;
 460
 461 */
 462
 463 const bfd_arch_info_type bfd_default_arch_struct =
 464 {
 465     32,32,8,bfd_arch_unknown,0,"unknown","unknown",2,true,
 466     bfd_default_compatible,
 467     bfd_default_scan,
 468     0,
 469 };
 470
 471 /*
 472 FUNCTION
 473         bfd_set_arch_info
 474
 475 SYNOPSIS
 476         void bfd_set_arch_info(bfd *abfd, const bfd_arch_info_type *arg);
 477
 478 DESCRIPTION
 479         Set the architecture info of @var{abfd} to @var{arg}.
 480 */
 481
 482 void
 483 bfd_set_arch_info (abfd, arg)
 484      bfd *abfd;
 485      const bfd_arch_info_type *arg;
 486 {
 487   abfd->arch_info = arg;
 488 }
 489
 490 /*
 491 INTERNAL_FUNCTION
 492         bfd_default_set_arch_mach
 493
 494 SYNOPSIS
 495         boolean bfd_default_set_arch_mach(bfd *abfd,
 496                 enum bfd_architecture arch,
 497                 unsigned long mach);
 498
 499 DESCRIPTION
 500         Set the architecture and machine type in BFD @var{abfd}
 501         to @var{arch} and @var{mach}.  Find the correct
 502         pointer to a structure and insert it into the <<arch_info>>
 503         pointer.
 504 */
 505
 506 boolean
 507 bfd_default_set_arch_mach (abfd, arch, mach)
 508      bfd *abfd;
 509      enum bfd_architecture arch;
 510      unsigned long mach;
 511 {
 512   const bfd_arch_info_type * const *app, *ap;
 513
 514   for (app = bfd_archures_list; *app != NULL; app++)
 515     {
 516       for (ap = *app; ap != NULL; ap = ap->next)
 517         {
 518           if (ap->arch == arch
 519               && (ap->mach == mach
 520                   || (mach == 0 && ap->the_default)))
 521             {
 522               abfd->arch_info = ap;
 523               return true;
 524             }
 525         }
 526     }
 527
 528   abfd->arch_info = &bfd_default_arch_struct;
 529   bfd_set_error (bfd_error_bad_value);
 530   return false;
 531 }
 532
 533
 534 /*
 535 FUNCTION
 536         bfd_get_arch
 537
 538 SYNOPSIS
 539         enum bfd_architecture bfd_get_arch(bfd *abfd);
 540
 541 DESCRIPTION
 542         Return the enumerated type which describes the BFD @var{abfd}'s
 543         architecture.
 544
 545 */
 546
 547 enum bfd_architecture
 548 bfd_get_arch (abfd)
 549      bfd *abfd;
 550 {
 551     return abfd->arch_info->arch;
 552 }
 553
 554 /*
 555 FUNCTION
 556         bfd_get_mach
 557
 558 SYNOPSIS
 559         unsigned long bfd_get_mach(bfd *abfd);
 560
 561 DESCRIPTION
 562         Return the long type which describes the BFD @var{abfd}'s
 563         machine.
 564 */
 565
 566 unsigned long
 567 bfd_get_mach (abfd)
 568      bfd *abfd;
 569 {
 570     return abfd->arch_info->mach;
 571 }
 572
 573 /*
 574 FUNCTION
 575         bfd_arch_bits_per_byte
 576
 577 SYNOPSIS
 578         unsigned int bfd_arch_bits_per_byte(bfd *abfd);
 579
 580 DESCRIPTION
 581         Return the number of bits in one of the BFD @var{abfd}'s
 582         architecture's bytes.
 583
 584 */
 585
 586 unsigned int
 587 bfd_arch_bits_per_byte (abfd)
 588      bfd *abfd;
 589 {
 590   return abfd->arch_info->bits_per_byte;
 591 }
 592
 593 /*
 594 FUNCTION
 595         bfd_arch_bits_per_address
 596
 597 SYNOPSIS
 598         unsigned int bfd_arch_bits_per_address(bfd *abfd);
 599
 600 DESCRIPTION
 601         Return the number of bits in one of the BFD @var{abfd}'s
 602         architecture's addresses.
 603 */
 604
 605 unsigned int
 606 bfd_arch_bits_per_address (abfd)
 607      bfd *abfd;
 608 {
 609   return abfd->arch_info->bits_per_address;
 610 }
 611
 612
 613 /*
 614 INTERNAL_FUNCTION
 615         bfd_default_compatible
 616
 617 SYNOPSIS
 618         const bfd_arch_info_type *bfd_default_compatible
 619         (const bfd_arch_info_type *a,
 620         const bfd_arch_info_type *b);
 621
 622 DESCRIPTION
 623         The default function for testing for compatibility.
 624 */
 625
 626 const bfd_arch_info_type *
 627 bfd_default_compatible (a,b)
 628      const bfd_arch_info_type *a;
 629      const bfd_arch_info_type *b;
 630 {
 631   if (a->arch != b->arch)
 632     return NULL;
 633
 634   if (a->mach > b->mach)
 635     return a;
 636
 637   if (b->mach > a->mach)
 638     return b;
 639
 640   return a;
 641 }
 642
 643
 644 /*
 645 INTERNAL_FUNCTION
 646         bfd_default_scan
 647
 648 SYNOPSIS
 649         boolean bfd_default_scan(const struct bfd_arch_info *info, const char *string);
 650
 651 DESCRIPTION
 652         The default function for working out whether this is an
 653         architecture hit and a machine hit.
 654 */
 655
 656 boolean
 657 bfd_default_scan (info, string)
 658      const struct bfd_arch_info *info;
 659      const char *string;
 660 {
 661   const char *ptr_src;
 662   const char *ptr_tst;
 663   unsigned long number;
 664   enum bfd_architecture arch;
 665   const char *printable_name_colon;
 666
 667   /* Exact match of the architecture name (ARCH_NAME) and also the
 668      default architecture? */
 669   if (strcasecmp (string, info->arch_name) == 0
 670       && info->the_default)
 671     return true;
 672
 673   /* Exact match of the machine name (PRINTABLE_NAME)? */
 674   if (strcasecmp (string, info->printable_name) == 0)
 675     return true;
 676
 677   /* Given that printable_name contains no colon, attempt to match:
 678      ARCH_NAME [ ":" ] PRINTABLE_NAME? */
 679   printable_name_colon = strchr (info->printable_name, ':');
 680   if (printable_name_colon == NULL)
 681     {
 682       int strlen_arch_name = strlen (info->arch_name);
 683       if (strncasecmp (string, info->arch_name, strlen_arch_name) == 0)
 684         {
 685           if (string[strlen_arch_name] == ':')
 686             {
 687               if (strcasecmp (string + strlen_arch_name + 1,
 688                               info->printable_name) == 0)
 689                 return true;
 690             }
 691           else
 692             {
 693               if (strcasecmp (string + strlen_arch_name,
 694                               info->printable_name) == 0)
 695                 return true;
 696             }
 697         }
 698     }
 699
 700   /* Given that PRINTABLE_NAME has the form: <arch> ":" <mach>;
 701      Attempt to match: <arch> <mach>? */
 702   if (printable_name_colon != NULL)
 703     {
 704       int colon_index = printable_name_colon - info->printable_name;
 705       if (strncasecmp (string, info->printable_name, colon_index) == 0
 706           && strcasecmp (string + colon_index,
 707                          info->printable_name + colon_index + 1) == 0)
 708         return true;
 709     }
 710
 711   /* Given that PRINTABLE_NAME has the form: <arch> ":" <mach>; Do not
 712      attempt to match just <mach>, it could be ambigious.  This test
 713      is left until later. */
 714
 715   /* NOTE: The below is retained for compatibility only. Please do not
 716      add to this code */
 717
 718   /* See how much of the supplied string matches with the
 719      architecture, eg the string m68k:68020 would match the 68k entry
 720      up to the :, then we get left with the machine number */
 721
 722   for (ptr_src = string, ptr_tst = info->arch_name;
 723        *ptr_src && *ptr_tst;
 724        ptr_src++, ptr_tst++)
 725     {
 726       if (*ptr_src != *ptr_tst) break;
 727     }
 728
 729   /* Chewed up as much of the architecture as will match, skip any
 730      colons */
 731   if (*ptr_src == ':')
 732     ptr_src++;
 733
 734   if (*ptr_src == 0)
 735     {
 736       /* nothing more, then only keep this one if it is the default
 737          machine for this architecture */
 738       return info->the_default;
 739     }
 740
 741   number = 0;
 742   while (isdigit ((unsigned char) *ptr_src))
 743     {
 744       number = number * 10 + *ptr_src  - '0';
 745       ptr_src++;
 746     }
 747
 748   /* NOTE: The below is retained for compatibility only.
 749      PLEASE DO NOT ADD TO THIS CODE. */
 750
 751   switch (number)
 752     {
 753       /* FIXME: These are needed to parse IEEE objects.  */
 754     case 68000:
 755       arch = bfd_arch_m68k;
 756       number = bfd_mach_m68000;
 757       break;
 758     case 68010:
 759       arch = bfd_arch_m68k;
 760       number = bfd_mach_m68010;
 761       break;
 762     case 68020:
 763       arch = bfd_arch_m68k;
 764       number = bfd_mach_m68020;
 765       break;
 766     case 68030:
 767       arch = bfd_arch_m68k;
 768       number = bfd_mach_m68030;
 769       break;
 770     case 68040:
 771       arch = bfd_arch_m68k;
 772       number = bfd_mach_m68040;
 773       break;
 774     case 68060:
 775       arch = bfd_arch_m68k;
 776       number = bfd_mach_m68060;
 777       break;
 778     case 68332:
 779       arch = bfd_arch_m68k;
 780       number = bfd_mach_cpu32;
 781       break;
 782
 783     case 32000:
 784       arch = bfd_arch_we32k;
 785       break;
 786
 787     case 3000:
 788       arch = bfd_arch_mips;
 789       number = bfd_mach_mips3000;
 790       break;
 791
 792     case 4000:
 793       arch = bfd_arch_mips;
 794       number = bfd_mach_mips4000;
 795       break;
 796
 797     case 6000:
 798       arch = bfd_arch_rs6000;
 799       break;
 800
 801     default:
 802       return false;
 803     }
 804
 805   if (arch != info->arch)
 806     return false;
 807
 808   if (number != info->mach)
 809     return false;
 810
 811   return true;
 812 }
 813
 814
 815 /*
 816 FUNCTION
 817         bfd_get_arch_info
 818
 819 SYNOPSIS
 820         const bfd_arch_info_type * bfd_get_arch_info(bfd *abfd);
 821
 822 DESCRIPTION
 823         Return the architecture info struct in @var{abfd}.
 824 */
 825
 826 const bfd_arch_info_type *
 827 bfd_get_arch_info (abfd)
 828      bfd *abfd;
 829 {
 830   return abfd->arch_info;
 831 }
 832
 833
 834 /*
 835 FUNCTION
 836         bfd_lookup_arch
 837
 838 SYNOPSIS
 839         const bfd_arch_info_type *bfd_lookup_arch
 840                 (enum bfd_architecture
 841                 arch,
 842                 unsigned long machine);
 843
 844 DESCRIPTION
 845         Look for the architecure info structure which matches the
 846         arguments @var{arch} and @var{machine}. A machine of 0 matches the
 847         machine/architecture structure which marks itself as the
 848         default.
 849 */
 850
 851 const bfd_arch_info_type *
 852 bfd_lookup_arch (arch, machine)
 853      enum bfd_architecture arch;
 854      unsigned long machine;
 855 {
 856   const bfd_arch_info_type * const *app, *ap;
 857
 858   for (app = bfd_archures_list; *app != NULL; app++)
 859     {
 860       for (ap = *app; ap != NULL; ap = ap->next)
 861         {
 862           if (ap->arch == arch
 863               && (ap->mach == machine
 864                   || (machine == 0 && ap->the_default)))
 865             return ap;
 866         }
 867     }
 868
 869   return NULL;
 870 }
 871
 872
 873 /*
 874 FUNCTION
 875         bfd_printable_arch_mach
 876
 877 SYNOPSIS
 878         const char *bfd_printable_arch_mach
 879                 (enum bfd_architecture arch, unsigned long machine);
 880
 881 DESCRIPTION
 882         Return a printable string representing the architecture and
 883         machine type.
 884
 885         This routine is depreciated.
 886 */
 887
 888 const char *
 889 bfd_printable_arch_mach (arch, machine)
 890      enum bfd_architecture arch;
 891      unsigned long machine;
 892 {
 893     const bfd_arch_info_type *ap = bfd_lookup_arch (arch, machine);
 894
 895     if (ap)
 896       return ap->printable_name;
 897     return "UNKNOWN!";
 898 }