bfd/archures.c

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