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