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