bfd/archures.c

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