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 .#define bfd_mach_m32rx         'x'
 185 .  bfd_arch_mn10200,   {* Matsushita MN10200 *}
 186 .  bfd_arch_mn10300,   {* Matsushita MN10300 *}
 187 .#define bfd_mach_mn10300               300
 188 .  bfd_arch_fr30,
 189 .#define bfd_mach_fr30          0x46523330
 190 .  bfd_arch_mcore,
 191 .  bfd_arch_pj,
 192 .  bfd_arch_last
 193 .  };
 194
 195
 196 */
 197
 198 /*
 199
 200 SUBSECTION
 201         bfd_arch_info
 202
 203 DESCRIPTION
 204         This structure contains information on architectures for use
 205         within BFD.
 206
 207 .
 208 .typedef struct bfd_arch_info
 209 .{
 210 .  int bits_per_word;
 211 .  int bits_per_address;
 212 .  int bits_per_byte;
 213 .  enum bfd_architecture arch;
 214 .  unsigned long mach;
 215 .  const char *arch_name;
 216 .  const char *printable_name;
 217 .  unsigned int section_align_power;
 218 . {* true if this is the default machine for the architecture *}
 219 .  boolean the_default;
 220 .  const struct bfd_arch_info * (*compatible)
 221 .       PARAMS ((const struct bfd_arch_info *a,
 222 .                const struct bfd_arch_info *b));
 223 .
 224 .  boolean (*scan) PARAMS ((const struct bfd_arch_info *, const char *));
 225 .
 226 .  const struct bfd_arch_info *next;
 227 .} bfd_arch_info_type;
 228 */
 229
 230 extern const bfd_arch_info_type bfd_a29k_arch;
 231 extern const bfd_arch_info_type bfd_alpha_arch;
 232 extern const bfd_arch_info_type bfd_arc_arch;
 233 extern const bfd_arch_info_type bfd_arm_arch;
 234 extern const bfd_arch_info_type bfd_d10v_arch;
 235 extern const bfd_arch_info_type bfd_d30v_arch;
 236 extern const bfd_arch_info_type bfd_h8300_arch;
 237 extern const bfd_arch_info_type bfd_h8500_arch;
 238 extern const bfd_arch_info_type bfd_hppa_arch;
 239 extern const bfd_arch_info_type bfd_i386_arch;
 240 extern const bfd_arch_info_type bfd_i860_arch;
 241 extern const bfd_arch_info_type bfd_i960_arch;
 242 extern const bfd_arch_info_type bfd_m32r_arch;
 243 extern const bfd_arch_info_type bfd_m68k_arch;
 244 extern const bfd_arch_info_type bfd_m88k_arch;
 245 extern const bfd_arch_info_type bfd_mips_arch;
 246 extern const bfd_arch_info_type bfd_mn10200_arch;
 247 extern const bfd_arch_info_type bfd_mn10300_arch;
 248 extern const bfd_arch_info_type bfd_powerpc_arch;
 249 extern const bfd_arch_info_type bfd_rs6000_arch;
 250 extern const bfd_arch_info_type bfd_pj_arch;
 251 extern const bfd_arch_info_type bfd_sh_arch;
 252 extern const bfd_arch_info_type bfd_sparc_arch;
 253 extern const bfd_arch_info_type bfd_tic30_arch;
 254 extern const bfd_arch_info_type bfd_tic80_arch;
 255 extern const bfd_arch_info_type bfd_vax_arch;
 256 extern const bfd_arch_info_type bfd_we32k_arch;
 257 extern const bfd_arch_info_type bfd_z8k_arch;
 258 extern const bfd_arch_info_type bfd_ns32k_arch;
 259 extern const bfd_arch_info_type bfd_w65_arch;
 260 extern const bfd_arch_info_type bfd_v850_arch;
 261 extern const bfd_arch_info_type bfd_fr30_arch;
 262 extern const bfd_arch_info_type bfd_mcore_arch;
 263
 264 static const bfd_arch_info_type * const bfd_archures_list[] =
 265 {
 266 #ifdef SELECT_ARCHITECTURES
 267   SELECT_ARCHITECTURES,
 268 #else
 269   &bfd_a29k_arch,
 270   &bfd_alpha_arch,
 271   &bfd_arc_arch,
 272   &bfd_arm_arch,
 273   &bfd_d10v_arch,
 274   &bfd_d30v_arch,
 275   &bfd_h8300_arch,
 276   &bfd_h8500_arch,
 277   &bfd_hppa_arch,
 278   &bfd_i386_arch,
 279   &bfd_i860_arch,
 280   &bfd_i960_arch,
 281   &bfd_m32r_arch,
 282   &bfd_m68k_arch,
 283   &bfd_m88k_arch,
 284   &bfd_mips_arch,
 285   &bfd_mn10200_arch,
 286   &bfd_mn10300_arch,
 287   &bfd_powerpc_arch,
 288   &bfd_rs6000_arch,
 289   &bfd_sh_arch,
 290   &bfd_sparc_arch,
 291   &bfd_tic30_arch,
 292   &bfd_tic80_arch,
 293   &bfd_vax_arch,
 294   &bfd_we32k_arch,
 295   &bfd_z8k_arch,
 296   &bfd_ns32k_arch,
 297   &bfd_w65_arch,
 298   &bfd_v850_arch,
 299   &bfd_fr30_arch,
 300   & bfd_mcore_arch,
 301 #endif
 302   0
 303 };
 304
 305 /*
 306 FUNCTION
 307         bfd_printable_name
 308
 309 SYNOPSIS
 310         const char *bfd_printable_name(bfd *abfd);
 311
 312 DESCRIPTION
 313         Return a printable string representing the architecture and machine
 314         from the pointer to the architecture info structure.
 315
 316 */
 317
 318 const char *
 319 bfd_printable_name (abfd)
 320      bfd *abfd;
 321 {
 322   return abfd->arch_info->printable_name;
 323 }
 324
 325
 326
 327 /*
 328 FUNCTION
 329         bfd_scan_arch
 330
 331 SYNOPSIS
 332         const bfd_arch_info_type *bfd_scan_arch(const char *string);
 333
 334 DESCRIPTION
 335         Figure out if BFD supports any cpu which could be described with
 336         the name @var{string}.  Return a pointer to an <<arch_info>>
 337         structure if a machine is found, otherwise NULL.
 338
 339 */
 340
 341 const bfd_arch_info_type *
 342 bfd_scan_arch (string)
 343      const char *string;
 344 {
 345   const bfd_arch_info_type * const *app, *ap;
 346
 347   /* Look through all the installed architectures */
 348   for (app = bfd_archures_list; *app != NULL; app++)
 349     {
 350       for (ap = *app; ap != NULL; ap = ap->next)
 351         {
 352           if (ap->scan (ap, string))
 353             return ap;
 354         }
 355     }
 356
 357   return NULL;
 358 }
 359
 360
 361
 362 /*
 363 FUNCTION
 364         bfd_arch_list
 365
 366 SYNOPSIS
 367         const char **bfd_arch_list(void);
 368
 369 DESCRIPTION
 370         Return a freshly malloced NULL-terminated vector of the names
 371         of all the valid BFD architectures.  Do not modify the names.
 372
 373 */
 374
 375 const char **
 376 bfd_arch_list ()
 377 {
 378   int vec_length = 0;
 379   const char **name_ptr;
 380   const char **name_list;
 381   const bfd_arch_info_type * const *app;
 382
 383   /* Determine the number of architectures */
 384   vec_length = 0;
 385   for (app = bfd_archures_list; *app != NULL; app++)
 386     {
 387       const bfd_arch_info_type *ap;
 388       for (ap = *app; ap != NULL; ap = ap->next)
 389         {
 390           vec_length++;
 391         }
 392     }
 393
 394   name_list = (CONST char **)
 395     bfd_malloc ((vec_length + 1) * sizeof (char **));
 396   if (name_list == NULL)
 397     return NULL;
 398
 399   /* Point the list at each of the names */
 400   name_ptr = name_list;
 401   for (app = bfd_archures_list; *app != NULL; app++)
 402     {
 403       const bfd_arch_info_type *ap;
 404       for (ap = *app; ap != NULL; ap = ap->next)
 405         {
 406           *name_ptr = ap->printable_name;
 407           name_ptr++;
 408         }
 409     }
 410   *name_ptr = NULL;
 411
 412   return name_list;
 413 }
 414
 415
 416
 417 /*
 418 FUNCTION
 419         bfd_arch_get_compatible
 420
 421 SYNOPSIS
 422         const bfd_arch_info_type *bfd_arch_get_compatible(
 423                 const bfd *abfd,
 424                 const bfd *bbfd);
 425
 426 DESCRIPTION
 427         Determine whether two BFDs'
 428         architectures and machine types are compatible.  Calculates
 429         the lowest common denominator between the two architectures
 430         and machine types implied by the BFDs and returns a pointer to
 431         an <<arch_info>> structure describing the compatible machine.
 432 */
 433
 434 const bfd_arch_info_type *
 435 bfd_arch_get_compatible (abfd, bbfd)
 436      const bfd *abfd;
 437      const bfd *bbfd;
 438 {
 439   /* If either architecture is unknown, then all we can do is assume
 440      the user knows what he's doing.  */
 441   if (abfd->arch_info->arch == bfd_arch_unknown)
 442         return bbfd->arch_info;
 443   if (bbfd->arch_info->arch == bfd_arch_unknown)
 444         return abfd->arch_info;
 445
 446   /* Otherwise architecture-specific code has to decide.  */
 447   return abfd->arch_info->compatible (abfd->arch_info, bbfd->arch_info);
 448 }
 449
 450
 451 /*
 452 INTERNAL_DEFINITION
 453         bfd_default_arch_struct
 454
 455 DESCRIPTION
 456         The <<bfd_default_arch_struct>> is an item of
 457         <<bfd_arch_info_type>> which has been initialized to a fairly
 458         generic state.  A BFD starts life by pointing to this
 459         structure, until the correct back end has determined the real
 460         architecture of the file.
 461
 462 .extern const bfd_arch_info_type bfd_default_arch_struct;
 463
 464 */
 465
 466 const bfd_arch_info_type bfd_default_arch_struct =
 467 {
 468     32,32,8,bfd_arch_unknown,0,"unknown","unknown",2,true,
 469     bfd_default_compatible,
 470     bfd_default_scan,
 471     0,
 472 };
 473
 474 /*
 475 FUNCTION
 476         bfd_set_arch_info
 477
 478 SYNOPSIS
 479         void bfd_set_arch_info(bfd *abfd, const bfd_arch_info_type *arg);
 480
 481 DESCRIPTION
 482         Set the architecture info of @var{abfd} to @var{arg}.
 483 */
 484
 485 void
 486 bfd_set_arch_info (abfd, arg)
 487      bfd *abfd;
 488      const bfd_arch_info_type *arg;
 489 {
 490   abfd->arch_info = arg;
 491 }
 492
 493 /*
 494 INTERNAL_FUNCTION
 495         bfd_default_set_arch_mach
 496
 497 SYNOPSIS
 498         boolean bfd_default_set_arch_mach(bfd *abfd,
 499                 enum bfd_architecture arch,
 500                 unsigned long mach);
 501
 502 DESCRIPTION
 503         Set the architecture and machine type in BFD @var{abfd}
 504         to @var{arch} and @var{mach}.  Find the correct
 505         pointer to a structure and insert it into the <<arch_info>>
 506         pointer.
 507 */
 508
 509 boolean
 510 bfd_default_set_arch_mach (abfd, arch, mach)
 511      bfd *abfd;
 512      enum bfd_architecture arch;
 513      unsigned long mach;
 514 {
 515   const bfd_arch_info_type * const *app, *ap;
 516
 517   for (app = bfd_archures_list; *app != NULL; app++)
 518     {
 519       for (ap = *app; ap != NULL; ap = ap->next)
 520         {
 521           if (ap->arch == arch
 522               && (ap->mach == mach
 523                   || (mach == 0 && ap->the_default)))
 524             {
 525               abfd->arch_info = ap;
 526               return true;
 527             }
 528         }
 529     }
 530
 531   abfd->arch_info = &bfd_default_arch_struct;
 532   bfd_set_error (bfd_error_bad_value);
 533   return false;
 534 }
 535
 536
 537 /*
 538 FUNCTION
 539         bfd_get_arch
 540
 541 SYNOPSIS
 542         enum bfd_architecture bfd_get_arch(bfd *abfd);
 543
 544 DESCRIPTION
 545         Return the enumerated type which describes the BFD @var{abfd}'s
 546         architecture.
 547
 548 */
 549
 550 enum bfd_architecture
 551 bfd_get_arch (abfd)
 552      bfd *abfd;
 553 {
 554     return abfd->arch_info->arch;
 555 }
 556
 557 /*
 558 FUNCTION
 559         bfd_get_mach
 560
 561 SYNOPSIS
 562         unsigned long bfd_get_mach(bfd *abfd);
 563
 564 DESCRIPTION
 565         Return the long type which describes the BFD @var{abfd}'s
 566         machine.
 567 */
 568
 569 unsigned long
 570 bfd_get_mach (abfd)
 571      bfd *abfd;
 572 {
 573     return abfd->arch_info->mach;
 574 }
 575
 576 /*
 577 FUNCTION
 578         bfd_arch_bits_per_byte
 579
 580 SYNOPSIS
 581         unsigned int bfd_arch_bits_per_byte(bfd *abfd);
 582
 583 DESCRIPTION
 584         Return the number of bits in one of the BFD @var{abfd}'s
 585         architecture's bytes.
 586
 587 */
 588
 589 unsigned int
 590 bfd_arch_bits_per_byte (abfd)
 591      bfd *abfd;
 592 {
 593   return abfd->arch_info->bits_per_byte;
 594 }
 595
 596 /*
 597 FUNCTION
 598         bfd_arch_bits_per_address
 599
 600 SYNOPSIS
 601         unsigned int bfd_arch_bits_per_address(bfd *abfd);
 602
 603 DESCRIPTION
 604         Return the number of bits in one of the BFD @var{abfd}'s
 605         architecture's addresses.
 606 */
 607
 608 unsigned int
 609 bfd_arch_bits_per_address (abfd)
 610      bfd *abfd;
 611 {
 612   return abfd->arch_info->bits_per_address;
 613 }
 614
 615
 616 /*
 617 INTERNAL_FUNCTION
 618         bfd_default_compatible
 619
 620 SYNOPSIS
 621         const bfd_arch_info_type *bfd_default_compatible
 622         (const bfd_arch_info_type *a,
 623         const bfd_arch_info_type *b);
 624
 625 DESCRIPTION
 626         The default function for testing for compatibility.
 627 */
 628
 629 const bfd_arch_info_type *
 630 bfd_default_compatible (a,b)
 631      const bfd_arch_info_type *a;
 632      const bfd_arch_info_type *b;
 633 {
 634   if (a->arch != b->arch)
 635     return NULL;
 636
 637   if (a->mach > b->mach)
 638     return a;
 639
 640   if (b->mach > a->mach)
 641     return b;
 642
 643   return a;
 644 }
 645
 646
 647 /*
 648 INTERNAL_FUNCTION
 649         bfd_default_scan
 650
 651 SYNOPSIS
 652         boolean bfd_default_scan(const struct bfd_arch_info *info, const char *string);
 653
 654 DESCRIPTION
 655         The default function for working out whether this is an
 656         architecture hit and a machine hit.
 657 */
 658
 659 boolean
 660 bfd_default_scan (info, string)
 661      const struct bfd_arch_info *info;
 662      const char *string;
 663 {
 664   const char *ptr_src;
 665   const char *ptr_tst;
 666   unsigned long number;
 667   enum bfd_architecture arch;
 668   const char *printable_name_colon;
 669
 670   /* Exact match of the architecture name (ARCH_NAME) and also the
 671      default architecture? */
 672   if (strcasecmp (string, info->arch_name) == 0
 673       && info->the_default)
 674     return true;
 675
 676   /* Exact match of the machine name (PRINTABLE_NAME)? */
 677   if (strcasecmp (string, info->printable_name) == 0)
 678     return true;
 679
 680   /* Given that printable_name contains no colon, attempt to match:
 681      ARCH_NAME [ ":" ] PRINTABLE_NAME? */
 682   printable_name_colon = strchr (info->printable_name, ':');
 683   if (printable_name_colon == NULL)
 684     {
 685       int strlen_arch_name = strlen (info->arch_name);
 686       if (strncasecmp (string, info->arch_name, strlen_arch_name) == 0)
 687         {
 688           if (string[strlen_arch_name] == ':')
 689             {
 690               if (strcasecmp (string + strlen_arch_name + 1,
 691                               info->printable_name) == 0)
 692                 return true;
 693             }
 694           else
 695             {
 696               if (strcasecmp (string + strlen_arch_name,
 697                               info->printable_name) == 0)
 698                 return true;
 699             }
 700         }
 701     }
 702
 703   /* Given that PRINTABLE_NAME has the form: <arch> ":" <mach>;
 704      Attempt to match: <arch> <mach>? */
 705   if (printable_name_colon != NULL)
 706     {
 707       int colon_index = printable_name_colon - info->printable_name;
 708       if (strncasecmp (string, info->printable_name, colon_index) == 0
 709           && strcasecmp (string + colon_index,
 710                          info->printable_name + colon_index + 1) == 0)
 711         return true;
 712     }
 713
 714   /* Given that PRINTABLE_NAME has the form: <arch> ":" <mach>; Do not
 715      attempt to match just <mach>, it could be ambigious.  This test
 716      is left until later. */
 717
 718   /* NOTE: The below is retained for compatibility only. Please do not
 719      add to this code */
 720
 721   /* See how much of the supplied string matches with the
 722      architecture, eg the string m68k:68020 would match the 68k entry
 723      up to the :, then we get left with the machine number */
 724
 725   for (ptr_src = string, ptr_tst = info->arch_name;
 726        *ptr_src && *ptr_tst;
 727        ptr_src++, ptr_tst++)
 728     {
 729       if (*ptr_src != *ptr_tst) break;
 730     }
 731
 732   /* Chewed up as much of the architecture as will match, skip any
 733      colons */
 734   if (*ptr_src == ':')
 735     ptr_src++;
 736
 737   if (*ptr_src == 0)
 738     {
 739       /* nothing more, then only keep this one if it is the default
 740          machine for this architecture */
 741       return info->the_default;
 742     }
 743
 744   number = 0;
 745   while (isdigit ((unsigned char) *ptr_src))
 746     {
 747       number = number * 10 + *ptr_src  - '0';
 748       ptr_src++;
 749     }
 750
 751   /* NOTE: The below is retained for compatibility only.
 752      PLEASE DO NOT ADD TO THIS CODE. */
 753
 754   switch (number)
 755     {
 756       /* FIXME: These are needed to parse IEEE objects.  */
 757     case 68000:
 758       arch = bfd_arch_m68k;
 759       number = bfd_mach_m68000;
 760       break;
 761     case 68010:
 762       arch = bfd_arch_m68k;
 763       number = bfd_mach_m68010;
 764       break;
 765     case 68020:
 766       arch = bfd_arch_m68k;
 767       number = bfd_mach_m68020;
 768       break;
 769     case 68030:
 770       arch = bfd_arch_m68k;
 771       number = bfd_mach_m68030;
 772       break;
 773     case 68040:
 774       arch = bfd_arch_m68k;
 775       number = bfd_mach_m68040;
 776       break;
 777     case 68060:
 778       arch = bfd_arch_m68k;
 779       number = bfd_mach_m68060;
 780       break;
 781     case 68332:
 782       arch = bfd_arch_m68k;
 783       number = bfd_mach_cpu32;
 784       break;
 785
 786     case 32000:
 787       arch = bfd_arch_we32k;
 788       break;
 789
 790     case 3000:
 791       arch = bfd_arch_mips;
 792       number = bfd_mach_mips3000;
 793       break;
 794
 795     case 4000:
 796       arch = bfd_arch_mips;
 797       number = bfd_mach_mips4000;
 798       break;
 799
 800     case 6000:
 801       arch = bfd_arch_rs6000;
 802       break;
 803
 804     default:
 805       return false;
 806     }
 807
 808   if (arch != info->arch)
 809     return false;
 810
 811   if (number != info->mach)
 812     return false;
 813
 814   return true;
 815 }
 816
 817
 818 /*
 819 FUNCTION
 820         bfd_get_arch_info
 821
 822 SYNOPSIS
 823         const bfd_arch_info_type * bfd_get_arch_info(bfd *abfd);
 824
 825 DESCRIPTION
 826         Return the architecture info struct in @var{abfd}.
 827 */
 828
 829 const bfd_arch_info_type *
 830 bfd_get_arch_info (abfd)
 831      bfd *abfd;
 832 {
 833   return abfd->arch_info;
 834 }
 835
 836
 837 /*
 838 FUNCTION
 839         bfd_lookup_arch
 840
 841 SYNOPSIS
 842         const bfd_arch_info_type *bfd_lookup_arch
 843                 (enum bfd_architecture
 844                 arch,
 845                 unsigned long machine);
 846
 847 DESCRIPTION
 848         Look for the architecure info structure which matches the
 849         arguments @var{arch} and @var{machine}. A machine of 0 matches the
 850         machine/architecture structure which marks itself as the
 851         default.
 852 */
 853
 854 const bfd_arch_info_type *
 855 bfd_lookup_arch (arch, machine)
 856      enum bfd_architecture arch;
 857      unsigned long machine;
 858 {
 859   const bfd_arch_info_type * const *app, *ap;
 860
 861   for (app = bfd_archures_list; *app != NULL; app++)
 862     {
 863       for (ap = *app; ap != NULL; ap = ap->next)
 864         {
 865           if (ap->arch == arch
 866               && (ap->mach == machine
 867                   || (machine == 0 && ap->the_default)))
 868             return ap;
 869         }
 870     }
 871
 872   return NULL;
 873 }
 874
 875
 876 /*
 877 FUNCTION
 878         bfd_printable_arch_mach
 879
 880 SYNOPSIS
 881         const char *bfd_printable_arch_mach
 882                 (enum bfd_architecture arch, unsigned long machine);
 883
 884 DESCRIPTION
 885         Return a printable string representing the architecture and
 886         machine type.
 887
 888         This routine is depreciated.
 889 */
 890
 891 const char *
 892 bfd_printable_arch_mach (arch, machine)
 893      enum bfd_architecture arch;
 894      unsigned long machine;
 895 {
 896     const bfd_arch_info_type *ap = bfd_lookup_arch (arch, machine);
 897
 898     if (ap)
 899       return ap->printable_name;
 900     return "UNKNOWN!";
 901 }