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_list
 339
 340 SYNOPSIS
 341         const char **bfd_arch_list(void);
 342
 343 DESCRIPTION
 344         Return a freshly malloced NULL-terminated vector of the names
 345         of all the valid BFD architectures.  Do not modify the names.
 346
 347 */
 348
 349 const char **
 350 bfd_arch_list ()
 351 {
 352   int vec_length = 0;
 353   const char **name_ptr;
 354   const char **name_list;
 355   const bfd_arch_info_type * const *app;
 356
 357   /* Determine the number of architectures */
 358   vec_length = 0;
 359   for (app = bfd_archures_list; *app != NULL; app++)
 360     {
 361       const bfd_arch_info_type *ap;
 362       for (ap = *app; ap != NULL; ap = ap->next)
 363         {
 364           vec_length++;
 365         }
 366     }
 367
 368   name_list = (CONST char **)
 369     bfd_malloc ((vec_length + 1) * sizeof (char **));
 370   if (name_list == NULL)
 371     return NULL;
 372
 373   /* Point the list at each of the names */
 374   name_ptr = name_list;
 375   for (app = bfd_archures_list; *app != NULL; app++)
 376     {
 377       const bfd_arch_info_type *ap;
 378       for (ap = *app; ap != NULL; ap = ap->next)
 379         {
 380           *name_ptr = ap->printable_name;
 381           name_ptr++;
 382         }
 383     }
 384   *name_ptr = NULL;
 385
 386   return name_list;
 387 }
 388
 389
 390
 391 /*
 392 FUNCTION
 393         bfd_arch_get_compatible
 394
 395 SYNOPSIS
 396         const bfd_arch_info_type *bfd_arch_get_compatible(
 397                 const bfd *abfd,
 398                 const bfd *bbfd);
 399
 400 DESCRIPTION
 401         Determine whether two BFDs'
 402         architectures and machine types are compatible.  Calculates
 403         the lowest common denominator between the two architectures
 404         and machine types implied by the BFDs and returns a pointer to
 405         an <<arch_info>> structure describing the compatible machine.
 406 */
 407
 408 const bfd_arch_info_type *
 409 bfd_arch_get_compatible (abfd, bbfd)
 410      const bfd *abfd;
 411      const bfd *bbfd;
 412 {
 413   /* If either architecture is unknown, then all we can do is assume
 414      the user knows what he's doing.  */
 415   if (abfd->arch_info->arch == bfd_arch_unknown)
 416         return bbfd->arch_info;
 417   if (bbfd->arch_info->arch == bfd_arch_unknown)
 418         return abfd->arch_info;
 419
 420   /* Otherwise architecture-specific code has to decide.  */
 421   return abfd->arch_info->compatible (abfd->arch_info, bbfd->arch_info);
 422 }
 423
 424
 425 /*
 426 INTERNAL_DEFINITION
 427         bfd_default_arch_struct
 428
 429 DESCRIPTION
 430         The <<bfd_default_arch_struct>> is an item of
 431         <<bfd_arch_info_type>> which has been initialized to a fairly
 432         generic state.  A BFD starts life by pointing to this
 433         structure, until the correct back end has determined the real
 434         architecture of the file.
 435
 436 .extern const bfd_arch_info_type bfd_default_arch_struct;
 437
 438 */
 439
 440 const bfd_arch_info_type bfd_default_arch_struct =
 441 {
 442     32,32,8,bfd_arch_unknown,0,"unknown","unknown",2,true,
 443     bfd_default_compatible,
 444     bfd_default_scan,
 445     0,
 446 };
 447
 448 /*
 449 FUNCTION
 450         bfd_set_arch_info
 451
 452 SYNOPSIS
 453         void bfd_set_arch_info(bfd *abfd, const bfd_arch_info_type *arg);
 454
 455 DESCRIPTION
 456         Set the architecture info of @var{abfd} to @var{arg}.
 457 */
 458
 459 void
 460 bfd_set_arch_info (abfd, arg)
 461      bfd *abfd;
 462      const bfd_arch_info_type *arg;
 463 {
 464   abfd->arch_info = arg;
 465 }
 466
 467 /*
 468 INTERNAL_FUNCTION
 469         bfd_default_set_arch_mach
 470
 471 SYNOPSIS
 472         boolean bfd_default_set_arch_mach(bfd *abfd,
 473                 enum bfd_architecture arch,
 474                 unsigned long mach);
 475
 476 DESCRIPTION
 477         Set the architecture and machine type in BFD @var{abfd}
 478         to @var{arch} and @var{mach}.  Find the correct
 479         pointer to a structure and insert it into the <<arch_info>>
 480         pointer.
 481 */
 482
 483 boolean
 484 bfd_default_set_arch_mach (abfd, arch, mach)
 485      bfd *abfd;
 486      enum bfd_architecture arch;
 487      unsigned long mach;
 488 {
 489   const bfd_arch_info_type * const *app, *ap;
 490
 491   for (app = bfd_archures_list; *app != NULL; app++)
 492     {
 493       for (ap = *app; ap != NULL; ap = ap->next)
 494         {
 495           if (ap->arch == arch
 496               && (ap->mach == mach
 497                   || (mach == 0 && ap->the_default)))
 498             {
 499               abfd->arch_info = ap;
 500               return true;
 501             }
 502         }
 503     }
 504
 505   abfd->arch_info = &bfd_default_arch_struct;
 506   bfd_set_error (bfd_error_bad_value);
 507   return false;
 508 }
 509
 510
 511 /*
 512 FUNCTION
 513         bfd_get_arch
 514
 515 SYNOPSIS
 516         enum bfd_architecture bfd_get_arch(bfd *abfd);
 517
 518 DESCRIPTION
 519         Return the enumerated type which describes the BFD @var{abfd}'s
 520         architecture.
 521
 522 */
 523
 524 enum bfd_architecture
 525 bfd_get_arch (abfd)
 526      bfd *abfd;
 527 {
 528     return abfd->arch_info->arch;
 529 }
 530
 531 /*
 532 FUNCTION
 533         bfd_get_mach
 534
 535 SYNOPSIS
 536         unsigned long bfd_get_mach(bfd *abfd);
 537
 538 DESCRIPTION
 539         Return the long type which describes the BFD @var{abfd}'s
 540         machine.
 541 */
 542
 543 unsigned long
 544 bfd_get_mach (abfd)
 545      bfd *abfd;
 546 {
 547     return abfd->arch_info->mach;
 548 }
 549
 550 /*
 551 FUNCTION
 552         bfd_arch_bits_per_byte
 553
 554 SYNOPSIS
 555         unsigned int bfd_arch_bits_per_byte(bfd *abfd);
 556
 557 DESCRIPTION
 558         Return the number of bits in one of the BFD @var{abfd}'s
 559         architecture's bytes.
 560
 561 */
 562
 563 unsigned int
 564 bfd_arch_bits_per_byte (abfd)
 565      bfd *abfd;
 566 {
 567   return abfd->arch_info->bits_per_byte;
 568 }
 569
 570 /*
 571 FUNCTION
 572         bfd_arch_bits_per_address
 573
 574 SYNOPSIS
 575         unsigned int bfd_arch_bits_per_address(bfd *abfd);
 576
 577 DESCRIPTION
 578         Return the number of bits in one of the BFD @var{abfd}'s
 579         architecture's addresses.
 580 */
 581
 582 unsigned int
 583 bfd_arch_bits_per_address (abfd)
 584      bfd *abfd;
 585 {
 586   return abfd->arch_info->bits_per_address;
 587 }
 588
 589
 590 /*
 591 INTERNAL_FUNCTION
 592         bfd_default_compatible
 593
 594 SYNOPSIS
 595         const bfd_arch_info_type *bfd_default_compatible
 596         (const bfd_arch_info_type *a,
 597         const bfd_arch_info_type *b);
 598
 599 DESCRIPTION
 600         The default function for testing for compatibility.
 601 */
 602
 603 const bfd_arch_info_type *
 604 bfd_default_compatible (a,b)
 605      const bfd_arch_info_type *a;
 606      const bfd_arch_info_type *b;
 607 {
 608   if (a->arch != b->arch)
 609     return NULL;
 610
 611   if (a->mach > b->mach)
 612     return a;
 613
 614   if (b->mach > a->mach)
 615     return b;
 616
 617   return a;
 618 }
 619
 620
 621 /*
 622 INTERNAL_FUNCTION
 623         bfd_default_scan
 624
 625 SYNOPSIS
 626         boolean bfd_default_scan(const struct bfd_arch_info *info, const char *string);
 627
 628 DESCRIPTION
 629         The default function for working out whether this is an
 630         architecture hit and a machine hit.
 631 */
 632
 633 boolean
 634 bfd_default_scan (info, string)
 635      const struct bfd_arch_info *info;
 636      const char *string;
 637 {
 638   const char *ptr_src;
 639   const char *ptr_tst;
 640   unsigned long number;
 641   enum bfd_architecture arch;
 642   const char *printable_name_colon;
 643
 644   /* Exact match of the architecture name (ARCH_NAME) and also the
 645      default architecture? */
 646   if (strcasecmp (string, info->arch_name) == 0
 647       && info->the_default)
 648     return true;
 649
 650   /* Exact match of the machine name (PRINTABLE_NAME)? */
 651   if (strcasecmp (string, info->printable_name) == 0)
 652     return true;
 653
 654   /* Given that printable_name contains no colon, attempt to match:
 655      ARCH_NAME [ ":" ] PRINTABLE_NAME? */
 656   printable_name_colon = strchr (info->printable_name, ':');
 657   if (printable_name_colon == NULL)
 658     {
 659       int strlen_arch_name = strlen (info->arch_name);
 660       if (strncasecmp (string, info->arch_name, strlen_arch_name) == 0)
 661         if (string[strlen_arch_name] == ':')
 662           {
 663             if (strcasecmp (string + strlen_arch_name + 1,
 664                             info->printable_name) == 0)
 665               return true;
 666           }
 667         else
 668           {
 669             if (strcasecmp (string + strlen_arch_name,
 670                             info->printable_name) == 0)
 671               return true;
 672           }
 673     }
 674
 675   /* Given that PRINTABLE_NAME has the form: <arch> ":" <mach>;
 676      Attempt to match: <arch> <mach>? */
 677   if (printable_name_colon != NULL)
 678     {
 679       int colon_index = printable_name_colon - info->printable_name;
 680       if (strncasecmp (string, info->printable_name, colon_index) == 0
 681           && strcasecmp (string + colon_index,
 682                          info->printable_name + colon_index + 1) == 0)
 683         return true;
 684     }
 685
 686   /* Given that PRINTABLE_NAME has the form: <arch> ":" <mach>; Do not
 687      attempt to match just <mach>, it could be ambigious.  This test
 688      is left until later. */
 689
 690   /* NOTE: The below is retained for compatibility only. Please do not
 691      add to this code */
 692
 693   /* See how much of the supplied string matches with the
 694      architecture, eg the string m68k:68020 would match the 68k entry
 695      up to the :, then we get left with the machine number */
 696
 697   for (ptr_src = string, ptr_tst = info->arch_name;
 698        *ptr_src && *ptr_tst;
 699        ptr_src++, ptr_tst++)
 700     {
 701       if (*ptr_src != *ptr_tst) break;
 702     }
 703
 704   /* Chewed up as much of the architecture as will match, skip any
 705      colons */
 706   if (*ptr_src == ':')
 707     ptr_src++;
 708
 709   if (*ptr_src == 0)
 710     {
 711       /* nothing more, then only keep this one if it is the default
 712          machine for this architecture */
 713       return info->the_default;
 714     }
 715
 716   number = 0;
 717   while (isdigit(*ptr_src))
 718     {
 719       number = number * 10 + *ptr_src  - '0';
 720       ptr_src++;
 721     }
 722
 723   /* NOTE: The below is retained for compatibility only.  Please do
 724      not add to this code. */
 725
 726   switch (number)
 727     {
 728     case 68010:
 729     case 68020:
 730     case 68030:
 731     case 68040:
 732     case 68332:
 733     case 68050:
 734     case 68000:
 735       arch = bfd_arch_m68k;
 736       break;
 737
 738     case 32000:
 739       arch = bfd_arch_we32k;
 740       break;
 741
 742     case 3000:
 743     case 4000:
 744       arch = bfd_arch_mips;
 745       break;
 746
 747     case 6000:
 748       arch = bfd_arch_rs6000;
 749       break;
 750
 751     default:
 752       return false;
 753     }
 754
 755   if (arch != info->arch)
 756     return false;
 757
 758   if (number != info->mach)
 759     return false;
 760
 761   return true;
 762 }
 763
 764
 765 /*
 766 FUNCTION
 767         bfd_get_arch_info
 768
 769 SYNOPSIS
 770         const bfd_arch_info_type * bfd_get_arch_info(bfd *abfd);
 771
 772 DESCRIPTION
 773         Return the architecture info struct in @var{abfd}.
 774 */
 775
 776 const bfd_arch_info_type *
 777 bfd_get_arch_info (abfd)
 778      bfd *abfd;
 779 {
 780   return abfd->arch_info;
 781 }
 782
 783
 784 /*
 785 FUNCTION
 786         bfd_lookup_arch
 787
 788 SYNOPSIS
 789         const bfd_arch_info_type *bfd_lookup_arch
 790                 (enum bfd_architecture
 791                 arch,
 792                 unsigned long machine);
 793
 794 DESCRIPTION
 795         Look for the architecure info structure which matches the
 796         arguments @var{arch} and @var{machine}. A machine of 0 matches the
 797         machine/architecture structure which marks itself as the
 798         default.
 799 */
 800
 801 const bfd_arch_info_type *
 802 bfd_lookup_arch (arch, machine)
 803      enum bfd_architecture arch;
 804      unsigned long machine;
 805 {
 806   const bfd_arch_info_type * const *app, *ap;
 807
 808   for (app = bfd_archures_list; *app != NULL; app++)
 809     {
 810       for (ap = *app; ap != NULL; ap = ap->next)
 811         {
 812           if (ap->arch == arch
 813               && (ap->mach == machine
 814                   || (machine == 0 && ap->the_default)))
 815             return ap;
 816         }
 817     }
 818
 819   return NULL;
 820 }
 821
 822
 823 /*
 824 FUNCTION
 825         bfd_printable_arch_mach
 826
 827 SYNOPSIS
 828         const char *bfd_printable_arch_mach
 829                 (enum bfd_architecture arch, unsigned long machine);
 830
 831 DESCRIPTION
 832         Return a printable string representing the architecture and
 833         machine type.
 834
 835         This routine is depreciated.
 836 */
 837
 838 const char *
 839 bfd_printable_arch_mach (arch, machine)
 840      enum bfd_architecture arch;
 841      unsigned long machine;
 842 {
 843     const bfd_arch_info_type *ap = bfd_lookup_arch (arch, machine);
 844
 845     if (ap)
 846       return ap->printable_name;
 847     return "UNKNOWN!";
 848 }