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