bfd/archures.c

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