bfd/archures.c

   1 /* BFD library support routines for architectures.
   2    Copyright (C) 1990, 91, 92, 93, 94, 1995 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 /*
  22
  23 SECTION
  24         Architectures
  25
  26         BFD keeps one atom in a BFD describing the
  27         architecture of the data attached to the BFD: a pointer to a
  28         <<bfd_arch_info_type>>.
  29
  30         Pointers to structures can be requested independently of a BFD
  31         so that an architecture's information can be interrogated
  32         without access to an open BFD.
  33
  34         The architecture information is provided by each architecture package.
  35         The set of default architectures is selected by the macro
  36         <<SELECT_ARCHITECTURES>>.  This is normally set up in the
  37         @file{config/@var{target}.mt} file of your choice.  If the name is not
  38         defined, then all the architectures supported are included.
  39
  40         When BFD starts up, all the architectures are called with an
  41         initialize method.  It is up to the architecture back end to
  42         insert as many items into the list of architectures as it wants to;
  43         generally this would be one for each machine and one for the
  44         default case (an item with a machine field of 0).
  45
  46         BFD's idea of an architecture is implemented in @file{archures.c}.
  47 */
  48
  49 /*
  50
  51 SUBSECTION
  52         bfd_architecture
  53
  54 DESCRIPTION
  55         This enum gives the object file's CPU architecture, in a
  56         global sense---i.e., what processor family does it belong to?
  57         Another field indicates which processor within
  58         the family is in use.  The machine gives a number which
  59         distinguishes different versions of the architecture,
  60         containing, for example, 2 and 3 for Intel i960 KA and i960 KB,
  61         and 68020 and 68030 for Motorola 68020 and 68030.
  62
  63 .enum bfd_architecture
  64 .{
  65 .  bfd_arch_unknown,   {* File arch not known *}
  66 .  bfd_arch_obscure,   {* Arch known, not one of these *}
  67 .  bfd_arch_m68k,      {* Motorola 68xxx *}
  68 .  bfd_arch_vax,       {* DEC Vax *}
  69 .  bfd_arch_i960,      {* Intel 960 *}
  70 .    {* The order of the following is important.
  71 .       lower number indicates a machine type that
  72 .       only accepts a subset of the instructions
  73 .       available to machines with higher numbers.
  74 .       The exception is the "ca", which is
  75 .       incompatible with all other machines except
  76 .       "core". *}
  77 .
  78 .#define bfd_mach_i960_core      1
  79 .#define bfd_mach_i960_ka_sa     2
  80 .#define bfd_mach_i960_kb_sb     3
  81 .#define bfd_mach_i960_mc        4
  82 .#define bfd_mach_i960_xa        5
  83 .#define bfd_mach_i960_ca        6
  84 . {* start-sanitize-i960xl *}
  85 .#define bfd_mach_i960_xl        7
  86 . {* end-sanitize-i960xl *}
  87 .
  88 .  bfd_arch_a29k,      {* AMD 29000 *}
  89 .  bfd_arch_sparc,     {* SPARC *}
  90 .#define bfd_mach_sparc         1
  91 .#define bfd_mach_sparc64       2
  92 .  bfd_arch_mips,      {* MIPS Rxxxx *}
  93 .  bfd_arch_i386,      {* Intel 386 *}
  94 .  bfd_arch_we32k,     {* AT&T WE32xxx *}
  95 .  bfd_arch_tahoe,     {* CCI/Harris Tahoe *}
  96 .  bfd_arch_i860,      {* Intel 860 *}
  97 .  bfd_arch_romp,      {* IBM ROMP PC/RT *}
  98 .  bfd_arch_alliant,   {* Alliant *}
  99 .  bfd_arch_convex,    {* Convex *}
 100 .  bfd_arch_m88k,      {* Motorola 88xxx *}
 101 .  bfd_arch_pyramid,   {* Pyramid Technology *}
 102 .  bfd_arch_h8300,     {* Hitachi H8/300 *}
 103 .#define bfd_mach_h8300   1
 104 .#define bfd_mach_h8300h  2
 105 .  bfd_arch_powerpc,   {* PowerPC *}
 106 .  bfd_arch_rs6000,    {* IBM RS/6000 *}
 107 .  bfd_arch_hppa,      {* HP PA RISC *}
 108 .  bfd_arch_z8k,       {* Zilog Z8000 *}
 109 .#define bfd_mach_z8001         1
 110 .#define bfd_mach_z8002         2
 111 .  bfd_arch_h8500,     {* Hitachi H8/500 *}
 112 .  bfd_arch_sh,        {* Hitachi SH *}
 113 .  bfd_arch_alpha,     {* Dec Alpha *}
 114 .  bfd_arch_arm,       {* Advanced Risc Machines ARM *}
 115 .  bfd_arch_ns32k,     {* National Semiconductors ns32000 *}
 116 .  bfd_arch_w65,       {* WDC 65816 *}
 117 . {* start-sanitize-rce *}
 118 .  bfd_arch_rce,       {* Motorola RCE *}
 119 . {* end-sanitize-rce *}
 120 . {* start-sanitize-arc *}
 121 .  bfd_arch_arc,       {* Argonaut RISC Core *}
 122 .#define bfd_mach_arc_base 0
 123 .#define bfd_mach_arc_host 1
 124 .#define bfd_mach_arc_graphics 2
 125 .#define bfd_mach_arc_audio 3
 126 . {* end-sanitize-arc *}
 127 .  bfd_arch_last
 128 .  };
 129
 130
 131 */
 132
 133 #include "bfd.h"
 134 #include "sysdep.h"
 135 #include "libbfd.h"
 136 #include <ctype.h>
 137
 138 /*
 139
 140 SUBSECTION
 141         bfd_arch_info
 142
 143 DESCRIPTION
 144         This structure contains information on architectures for use
 145         within BFD.
 146
 147 .
 148 .typedef struct bfd_arch_info
 149 .{
 150 .  int bits_per_word;
 151 .  int bits_per_address;
 152 .  int bits_per_byte;
 153 .  enum bfd_architecture arch;
 154 .  unsigned long mach;
 155 .  char *arch_name;
 156 .  CONST  char *printable_name;
 157 .  unsigned int section_align_power;
 158 . {* true if this is the default machine for the architecture *}
 159 .  boolean the_default;
 160 .  CONST struct bfd_arch_info * (*compatible)
 161 .       PARAMS ((CONST struct bfd_arch_info *a,
 162 .                CONST struct bfd_arch_info *b));
 163 .
 164 .  boolean (*scan) PARAMS ((CONST struct bfd_arch_info *, CONST char *));
 165 .  {* How to disassemble an instruction, producing a printable
 166 .     representation on a specified stdio stream.  This isn't
 167 .     defined for most processors at present, because of the size
 168 .     of the additional tables it would drag in, and because gdb
 169 .     wants to use a different interface.  *}
 170 .  unsigned int (*disassemble) PARAMS ((bfd_vma addr, CONST char *data,
 171 .                                       PTR stream));
 172 .
 173 .  struct bfd_arch_info *next;
 174 .} bfd_arch_info_type;
 175 */
 176
 177 bfd_arch_info_type   *bfd_arch_info_list;
 178
 179
 180 /*
 181 FUNCTION
 182         bfd_printable_name
 183
 184 SYNOPSIS
 185         CONST char *bfd_printable_name(bfd *abfd);
 186
 187 DESCRIPTION
 188         Return a printable string representing the architecture and machine
 189         from the pointer to the architecture info structure.
 190
 191 */
 192
 193 CONST char *
 194 bfd_printable_name (abfd)
 195      bfd *abfd;
 196 {
 197   return abfd->arch_info->printable_name;
 198 }
 199
 200
 201
 202 /*
 203 FUNCTION
 204         bfd_scan_arch
 205
 206 SYNOPSIS
 207         bfd_arch_info_type *bfd_scan_arch(CONST char *string);
 208
 209 DESCRIPTION
 210         Figure out if BFD supports any cpu which could be described with
 211         the name @var{string}.  Return a pointer to an <<arch_info>>
 212         structure if a machine is found, otherwise NULL.
 213
 214 */
 215
 216 bfd_arch_info_type *
 217 bfd_scan_arch (string)
 218      CONST char *string;
 219 {
 220   struct bfd_arch_info *ap;
 221
 222   /* Look through all the installed architectures */
 223   for (ap = bfd_arch_info_list;
 224        ap != (bfd_arch_info_type *)NULL;
 225        ap = ap->next) {
 226
 227     if (ap->scan(ap, string))
 228       return ap;
 229   }
 230   return (bfd_arch_info_type *)NULL;
 231 }
 232
 233
 234
 235 /*
 236 FUNCTION
 237         bfd_arch_get_compatible
 238
 239 SYNOPSIS
 240         CONST bfd_arch_info_type *bfd_arch_get_compatible(
 241                 CONST bfd *abfd,
 242                 CONST bfd *bbfd);
 243
 244 DESCRIPTION
 245         Determine whether two BFDs'
 246         architectures and machine types are compatible.  Calculates
 247         the lowest common denominator between the two architectures
 248         and machine types implied by the BFDs and returns a pointer to
 249         an <<arch_info>> structure describing the compatible machine.
 250 */
 251
 252 CONST bfd_arch_info_type *
 253 bfd_arch_get_compatible (abfd, bbfd)
 254      CONST bfd *abfd;
 255      CONST bfd *bbfd;
 256 {
 257   /* If either architecture is unknown, then all we can do is assume
 258      the user knows what he's doing.  */
 259   if (abfd->arch_info->arch == bfd_arch_unknown)
 260         return bbfd->arch_info;
 261   if (bbfd->arch_info->arch == bfd_arch_unknown)
 262         return abfd->arch_info;
 263
 264   /* Otherwise architecture-specific code has to decide.  */
 265   return  abfd->arch_info->compatible(abfd->arch_info,bbfd->arch_info);
 266 }
 267
 268
 269 /*
 270 INTERNAL_DEFINITION
 271         bfd_default_arch_struct
 272
 273 DESCRIPTION
 274         The <<bfd_default_arch_struct>> is an item of
 275         <<bfd_arch_info_type>> which has been initialized to a fairly
 276         generic state.  A BFD starts life by pointing to this
 277         structure, until the correct back end has determined the real
 278         architecture of the file.
 279
 280 .extern bfd_arch_info_type bfd_default_arch_struct;
 281
 282 */
 283
 284 bfd_arch_info_type bfd_default_arch_struct =
 285 {
 286     32,32,8,bfd_arch_unknown,0,"unknown","unknown",2,true,
 287     bfd_default_compatible,
 288     bfd_default_scan,
 289     0,
 290 };
 291
 292 /*
 293 FUNCTION
 294         bfd_set_arch_info
 295
 296 SYNOPSIS
 297         void bfd_set_arch_info(bfd *abfd, bfd_arch_info_type *arg);
 298
 299 DESCRIPTION
 300         Set the architecture info of @var{abfd} to @var{arg}.
 301 */
 302
 303 void
 304 bfd_set_arch_info (abfd, arg)
 305      bfd *abfd;
 306      bfd_arch_info_type *arg;
 307 {
 308   abfd->arch_info = arg;
 309 }
 310
 311 /*
 312 INTERNAL_FUNCTION
 313         bfd_default_set_arch_mach
 314
 315 SYNOPSIS
 316         boolean bfd_default_set_arch_mach(bfd *abfd,
 317                 enum bfd_architecture arch,
 318                 unsigned long mach);
 319
 320 DESCRIPTION
 321         Set the architecture and machine type in BFD @var{abfd}
 322         to @var{arch} and @var{mach}.  Find the correct
 323         pointer to a structure and insert it into the <<arch_info>>
 324         pointer.
 325 */
 326
 327 boolean
 328 bfd_default_set_arch_mach (abfd, arch, mach)
 329      bfd *abfd;
 330      enum bfd_architecture arch;
 331      unsigned    long mach;
 332 {
 333   static struct bfd_arch_info *old_ptr = &bfd_default_arch_struct;
 334   boolean found = false;
 335   /* run through the table to find the one we want, we keep a little
 336      cache to speed things up */
 337   if (old_ptr == 0 || arch != old_ptr->arch || mach != old_ptr->mach) {
 338     bfd_arch_info_type *ptr;
 339     old_ptr = (bfd_arch_info_type *)NULL;
 340     for (ptr = bfd_arch_info_list;
 341          ptr != (bfd_arch_info_type *)NULL;
 342          ptr= ptr->next) {
 343       if (ptr->arch == arch &&
 344           ((ptr->mach == mach) || (ptr->the_default && mach == 0))) {
 345         old_ptr = ptr;
 346         found = true;
 347         break;
 348       }
 349     }
 350     if (found==false) {
 351       /*looked for it and it wasn't there, so put in the default */
 352       old_ptr = &bfd_default_arch_struct;
 353       bfd_set_error (bfd_error_bad_value);
 354     }
 355   }
 356   else {
 357     /* it was in the cache */
 358     found = true;
 359   }
 360
 361   abfd->arch_info = old_ptr;
 362
 363   return found;
 364 }
 365
 366
 367 /*
 368 FUNCTION
 369         bfd_get_arch
 370
 371 SYNOPSIS
 372         enum bfd_architecture bfd_get_arch(bfd *abfd);
 373
 374 DESCRIPTION
 375         Return the enumerated type which describes the BFD @var{abfd}'s
 376         architecture.
 377
 378 */
 379
 380 enum bfd_architecture
 381 bfd_get_arch (abfd)
 382      bfd *abfd;
 383 {
 384     return abfd->arch_info->arch;
 385 }
 386
 387 /*
 388 FUNCTION
 389         bfd_get_mach
 390
 391 SYNOPSIS
 392         unsigned long bfd_get_mach(bfd *abfd);
 393
 394 DESCRIPTION
 395         Return the long type which describes the BFD @var{abfd}'s
 396         machine.
 397 */
 398
 399 unsigned long
 400 bfd_get_mach (abfd)
 401      bfd *abfd;
 402 {
 403     return abfd->arch_info->mach;
 404 }
 405
 406 /*
 407 FUNCTION
 408         bfd_arch_bits_per_byte
 409
 410 SYNOPSIS
 411         unsigned int bfd_arch_bits_per_byte(bfd *abfd);
 412
 413 DESCRIPTION
 414         Return the number of bits in one of the BFD @var{abfd}'s
 415         architecture's bytes.
 416
 417 */
 418
 419 unsigned int
 420 bfd_arch_bits_per_byte (abfd)
 421      bfd *abfd;
 422 {
 423   return abfd->arch_info->bits_per_byte;
 424 }
 425
 426 /*
 427 FUNCTION
 428         bfd_arch_bits_per_address
 429
 430 SYNOPSIS
 431         unsigned int bfd_arch_bits_per_address(bfd *abfd);
 432
 433 DESCRIPTION
 434         Return the number of bits in one of the BFD @var{abfd}'s
 435         architecture's addresses.
 436 */
 437
 438 unsigned int
 439 bfd_arch_bits_per_address (abfd)
 440      bfd *abfd;
 441 {
 442   return abfd->arch_info->bits_per_address;
 443 }
 444
 445
 446 extern void bfd_a29k_arch PARAMS ((void));
 447 extern void bfd_alpha_arch PARAMS ((void));
 448 /* start-sanitize-arc */
 449 extern void bfd_arc_arch PARAMS ((void));
 450 /* end-sanitize-arc */
 451 extern void bfd_arm_arch PARAMS ((void));
 452 extern void bfd_h8300_arch PARAMS ((void));
 453 extern void bfd_h8500_arch PARAMS ((void));
 454 extern void bfd_hppa_arch PARAMS ((void));
 455 extern void bfd_i386_arch PARAMS ((void));
 456 extern void bfd_i960_arch PARAMS ((void));
 457 extern void bfd_m68k_arch PARAMS ((void));
 458 extern void bfd_m88k_arch PARAMS ((void));
 459 extern void bfd_mips_arch PARAMS ((void));
 460 extern void bfd_powerpc_arch PARAMS ((void));
 461 extern void bfd_rs6000_arch PARAMS ((void));
 462 extern void bfd_sh_arch PARAMS ((void));
 463 /* start-sanitize-rce */
 464 extern void bfd_rce_arch PARAMS ((void));
 465 /* end-sanitize-rce */
 466 extern void bfd_sparc_arch PARAMS ((void));
 467 extern void bfd_vax_arch PARAMS ((void));
 468 extern void bfd_we32k_arch PARAMS ((void));
 469 extern void bfd_z8k_arch PARAMS ((void));
 470 extern void bfd_ns32k_arch PARAMS ((void));
 471 extern void bfd_w65_arch PARAMS ((void));
 472
 473 static void (*const archures_init_table[]) PARAMS ((void)) =
 474 {
 475 #ifdef SELECT_ARCHITECTURES
 476   SELECT_ARCHITECTURES,
 477 #else
 478   bfd_a29k_arch,
 479   bfd_alpha_arch,
 480 /* start-sanitize-arc */
 481   bfd_arc_arch,
 482 /* end-sanitize-arc */
 483   bfd_arm_arch,
 484   bfd_h8300_arch,
 485   bfd_h8500_arch,
 486   bfd_hppa_arch,
 487   bfd_i386_arch,
 488   bfd_i960_arch,
 489   bfd_m68k_arch,
 490   bfd_m88k_arch,
 491   bfd_mips_arch,
 492   bfd_powerpc_arch,
 493   bfd_rs6000_arch,
 494   bfd_sh_arch,
 495 /* start-sanitize-rce */
 496   bfd_rce_arch,
 497 /* end-sanitize-rce */
 498   bfd_sparc_arch,
 499   bfd_vax_arch,
 500   bfd_we32k_arch,
 501   bfd_z8k_arch,
 502   bfd_ns32k_arch,
 503   bfd_w65_arch,
 504 #endif
 505   0
 506   };
 507
 508
 509
 510 /*
 511 INTERNAL_FUNCTION
 512         bfd_arch_init
 513
 514 SYNOPSIS
 515         void bfd_arch_init(void);
 516
 517 DESCRIPTION
 518         Initialize the architecture dispatch table by
 519         calling all installed architecture packages and getting them
 520         to poke around.
 521 */
 522
 523 void
 524 bfd_arch_init ()
 525 {
 526     void (*const *ptable) PARAMS ((void));
 527     for (ptable = archures_init_table; *ptable ; ptable++)
 528       (*ptable)();
 529 }
 530
 531
 532 /*
 533 INTERNAL_FUNCTION
 534         bfd_arch_linkin
 535
 536 SYNOPSIS
 537         void bfd_arch_linkin(bfd_arch_info_type *ptr);
 538
 539 DESCRIPTION
 540         Link the architecture info structure @var{ptr} into the list.
 541 */
 542
 543 void
 544 bfd_arch_linkin (ptr)
 545      bfd_arch_info_type *ptr;
 546 {
 547   ptr->next = bfd_arch_info_list;
 548   bfd_arch_info_list = ptr;
 549 }
 550
 551
 552 /*
 553 INTERNAL_FUNCTION
 554         bfd_default_compatible
 555
 556 SYNOPSIS
 557         CONST bfd_arch_info_type *bfd_default_compatible
 558         (CONST bfd_arch_info_type *a,
 559         CONST bfd_arch_info_type *b);
 560
 561 DESCRIPTION
 562         The default function for testing for compatibility.
 563 */
 564
 565 CONST bfd_arch_info_type *
 566 bfd_default_compatible (a,b)
 567      CONST bfd_arch_info_type *a;
 568      CONST bfd_arch_info_type *b;
 569 {
 570   if(a->arch != b->arch) return NULL;
 571
 572   if (a->mach > b->mach) {
 573     return a;
 574   }
 575   if (b->mach > a->mach) {
 576     return b;
 577   }
 578   return a;
 579 }
 580
 581
 582 /*
 583 INTERNAL_FUNCTION
 584         bfd_default_scan
 585
 586 SYNOPSIS
 587         boolean bfd_default_scan(CONST struct bfd_arch_info *info, CONST char *string);
 588
 589 DESCRIPTION
 590         The default function for working out whether this is an
 591         architecture hit and a machine hit.
 592 */
 593
 594 boolean
 595 bfd_default_scan (info, string)
 596      CONST struct bfd_arch_info *info;
 597      CONST char *string;
 598 {
 599   CONST  char *ptr_src;
 600   CONST   char *ptr_tst;
 601   unsigned long number;
 602   enum bfd_architecture arch;
 603   /* First test for an exact match */
 604   if (strcmp(string, info->printable_name) == 0) return true;
 605
 606   /* See how much of the supplied string matches with the
 607      architecture, eg the string m68k:68020 would match the 68k entry
 608      up to the :, then we get left with the machine number */
 609
 610   for (ptr_src = string,
 611        ptr_tst = info->arch_name;
 612        *ptr_src && *ptr_tst;
 613        ptr_src++,
 614        ptr_tst++)
 615     {
 616       if (*ptr_src != *ptr_tst) break;
 617     }
 618
 619   /* Chewed up as much of the architecture as will match, skip any
 620      colons */
 621   if (*ptr_src == ':') ptr_src++;
 622
 623   if (*ptr_src == 0) {
 624     /* nothing more, then only keep this one if it is the default
 625        machine for this architecture */
 626     return info->the_default;
 627   }
 628   number = 0;
 629   while (isdigit(*ptr_src)) {
 630     number = number * 10 + *ptr_src  - '0';
 631     ptr_src++;
 632   }
 633
 634   switch (number)
 635     {
 636     case 65:
 637       arch = bfd_arch_w65;
 638       break;
 639
 640     case 300:
 641       arch = bfd_arch_h8300;
 642       break;
 643
 644     case 500:
 645       arch = bfd_arch_h8500;
 646       break;
 647
 648     case 68010:
 649     case 68020:
 650     case 68030:
 651     case 68040:
 652     case 68332:
 653     case 68050:
 654     case 68000:
 655       arch = bfd_arch_m68k;
 656       break;
 657     case 386:
 658     case 80386:
 659     case 486:
 660     case 80486:
 661       arch = bfd_arch_i386;
 662       break;
 663     case 29000:
 664       arch = bfd_arch_a29k;
 665       break;
 666
 667     case 8000:
 668       arch = bfd_arch_z8k;
 669       break;
 670
 671     case 32000:
 672       arch = bfd_arch_we32k;
 673       break;
 674
 675     case 860:
 676     case 80860:
 677       arch = bfd_arch_i860;
 678       break;
 679     case 960:
 680     case 80960:
 681       arch = bfd_arch_i960;
 682       break;
 683
 684     case 2000:
 685     case 3000:
 686     case 4000:
 687     case 4400:
 688       arch = bfd_arch_mips;
 689       break;
 690
 691     case 6000:
 692       arch = bfd_arch_rs6000;
 693       break;
 694
 695     default:
 696       return false;
 697     }
 698   if (arch != info->arch)
 699     return false;
 700
 701   if (number != info->mach)
 702     return false;
 703
 704   return true;
 705 }
 706
 707
 708 /*
 709 FUNCTION
 710         bfd_get_arch_info
 711
 712 SYNOPSIS
 713         bfd_arch_info_type * bfd_get_arch_info(bfd *abfd);
 714
 715 DESCRIPTION
 716         Return the architecture info struct in @var{abfd}.
 717 */
 718
 719 bfd_arch_info_type *
 720 bfd_get_arch_info (abfd)
 721      bfd *abfd;
 722 {
 723   return  abfd->arch_info;
 724 }
 725
 726
 727 /*
 728 FUNCTION
 729         bfd_lookup_arch
 730
 731 SYNOPSIS
 732         bfd_arch_info_type *bfd_lookup_arch
 733                 (enum bfd_architecture
 734                 arch,
 735                 unsigned long machine);
 736
 737 DESCRIPTION
 738         Look for the architecure info structure which matches the
 739         arguments @var{arch} and @var{machine}. A machine of 0 matches the
 740         machine/architecture structure which marks itself as the
 741         default.
 742 */
 743
 744 bfd_arch_info_type *
 745 bfd_lookup_arch (arch, machine)
 746      enum bfd_architecture arch;
 747      unsigned long machine;
 748 {
 749     bfd_arch_info_type *ap;
 750     bfd_check_init();
 751     for (ap = bfd_arch_info_list;
 752          ap !=  (bfd_arch_info_type *)NULL;
 753          ap = ap->next) {
 754             if (ap->arch == arch &&
 755                 ((ap->mach == machine)
 756                  || (ap->the_default && machine == 0))) {
 757                     return ap;
 758                 }
 759         }
 760     return (bfd_arch_info_type *)NULL;
 761 }
 762
 763
 764 /*
 765 FUNCTION
 766         bfd_printable_arch_mach
 767
 768 SYNOPSIS
 769         CONST char *bfd_printable_arch_mach
 770                 (enum bfd_architecture arch, unsigned long machine);
 771
 772 DESCRIPTION
 773         Return a printable string representing the architecture and
 774         machine type.
 775
 776         This routine is depreciated.
 777 */
 778
 779 CONST char *
 780 bfd_printable_arch_mach (arch, machine)
 781      enum bfd_architecture arch;
 782      unsigned long machine;
 783 {
 784     bfd_arch_info_type *ap = bfd_lookup_arch(arch, machine);
 785     if(ap) return ap->printable_name;
 786     return "UNKNOWN!";
 787 }