bfd/archures.c

   1 /* BFD library support routines for architectures.
   2    Copyright (C) 1990, 91-98, 1999 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 .#define bfd_mach_m68000 1
  74 .#define bfd_mach_m68008 2
  75 .#define bfd_mach_m68010 3
  76 .#define bfd_mach_m68020 4
  77 .#define bfd_mach_m68030 5
  78 .#define bfd_mach_m68040 6
  79 .#define bfd_mach_m68060 7
  80 .#define bfd_mach_cpu32  8
  81 .  bfd_arch_vax,       {* DEC Vax *}
  82 .  bfd_arch_i960,      {* Intel 960 *}
  83 .    {* The order of the following is important.
  84 .       lower number indicates a machine type that
  85 .       only accepts a subset of the instructions
  86 .       available to machines with higher numbers.
  87 .       The exception is the "ca", which is
  88 .       incompatible with all other machines except
  89 .       "core". *}
  90 .
  91 .#define bfd_mach_i960_core      1
  92 .#define bfd_mach_i960_ka_sa     2
  93 .#define bfd_mach_i960_kb_sb     3
  94 .#define bfd_mach_i960_mc        4
  95 .#define bfd_mach_i960_xa        5
  96 .#define bfd_mach_i960_ca        6
  97 .#define bfd_mach_i960_jx        7
  98 .#define bfd_mach_i960_hx        8
  99 .
 100 .  bfd_arch_a29k,      {* AMD 29000 *}
 101 .  bfd_arch_sparc,     {* SPARC *}
 102 .#define bfd_mach_sparc                 1
 103 .{* The difference between v8plus and v9 is that v9 is a true 64 bit env.  *}
 104 .#define bfd_mach_sparc_sparclet        2
 105 .#define bfd_mach_sparc_sparclite       3
 106 .#define bfd_mach_sparc_v8plus          4
 107 .#define bfd_mach_sparc_v8plusa         5 {* with ultrasparc add'ns *}
 108 .#define bfd_mach_sparc_sparclite_le    6
 109 .#define bfd_mach_sparc_v9              7
 110 .#define bfd_mach_sparc_v9a             8 {* with ultrasparc add'ns *}
 111 .{* Nonzero if MACH has the v9 instruction set.  *}
 112 .#define bfd_mach_sparc_v9_p(mach) \
 113 .  ((mach) >= bfd_mach_sparc_v8plus && (mach) <= bfd_mach_sparc_v9a)
 114 .  bfd_arch_mips,      {* MIPS Rxxxx *}
 115 .#define bfd_mach_mips3000              3000
 116 .#define bfd_mach_mips3900              3900
 117 .#define bfd_mach_mips4000              4000
 118 .#define bfd_mach_mips4010              4010
 119 .#define bfd_mach_mips4100              4100
 120 .#define bfd_mach_mips4111              4111
 121 .#define bfd_mach_mips4300              4300
 122 .#define bfd_mach_mips4400              4400
 123 .#define bfd_mach_mips4600              4600
 124 .#define bfd_mach_mips4650              4650
 125 .#define bfd_mach_mips5000              5000
 126 .#define bfd_mach_mips6000              6000
 127 .#define bfd_mach_mips8000              8000
 128 .#define bfd_mach_mips10000             10000
 129 .#define bfd_mach_mips16                16
 130 .  bfd_arch_i386,      {* Intel 386 *}
 131 .#define bfd_mach_i386_i386 0
 132 .#define bfd_mach_i386_i8086 1
 133 .#define bfd_mach_i386_i386_intel_syntax 2
 134 .  bfd_arch_we32k,     {* AT&T WE32xxx *}
 135 .  bfd_arch_tahoe,     {* CCI/Harris Tahoe *}
 136 .  bfd_arch_i860,      {* Intel 860 *}
 137 .  bfd_arch_romp,      {* IBM ROMP PC/RT *}
 138 .  bfd_arch_alliant,   {* Alliant *}
 139 .  bfd_arch_convex,    {* Convex *}
 140 .  bfd_arch_m88k,      {* Motorola 88xxx *}
 141 .  bfd_arch_pyramid,   {* Pyramid Technology *}
 142 .  bfd_arch_h8300,     {* Hitachi H8/300 *}
 143 .#define bfd_mach_h8300   1
 144 .#define bfd_mach_h8300h  2
 145 .#define bfd_mach_h8300s  3
 146 .  bfd_arch_powerpc,   {* PowerPC *}
 147 .  bfd_arch_rs6000,    {* IBM RS/6000 *}
 148 .  bfd_arch_hppa,      {* HP PA RISC *}
 149 .  bfd_arch_d10v,      {* Mitsubishi D10V *}
 150 .  bfd_arch_d30v,      {* Mitsubishi D30V *}
 151 .  bfd_arch_z8k,       {* Zilog Z8000 *}
 152 .#define bfd_mach_z8001         1
 153 .#define bfd_mach_z8002         2
 154 .  bfd_arch_h8500,     {* Hitachi H8/500 *}
 155 .  bfd_arch_sh,        {* Hitachi SH *}
 156 .#define bfd_mach_sh            0
 157 .#define bfd_mach_sh3        0x30
 158 .#define bfd_mach_sh3e       0x3e
 159 .  bfd_arch_alpha,     {* Dec Alpha *}
 160 .#define bfd_mach_alpha_ev4  0x10
 161 .#define bfd_mach_alpha_ev5  0x20
 162 .#define bfd_mach_alpha_ev6  0x30
 163 .  bfd_arch_arm,       {* Advanced Risc Machines ARM *}
 164 .#define bfd_mach_arm_2         1
 165 .#define bfd_mach_arm_2a                2
 166 .#define bfd_mach_arm_3         3
 167 .#define bfd_mach_arm_3M        4
 168 .#define bfd_mach_arm_4                 5
 169 .#define bfd_mach_arm_4T        6
 170 .  bfd_arch_ns32k,     {* National Semiconductors ns32000 *}
 171 .  bfd_arch_w65,       {* WDC 65816 *}
 172 .  bfd_arch_tic30,     {* Texas Instruments TMS320C30 *}
 173 .  bfd_arch_tic80,     {* TI TMS320c80 (MVP) *}
 174 .  bfd_arch_v850,      {* NEC V850 *}
 175 .#define bfd_mach_v850          0
 176 .#define bfd_mach_v850e         'E'
 177 .#define bfd_mach_v850ea        'A'
 178 .  bfd_arch_arc,       {* Argonaut RISC Core *}
 179 .#define bfd_mach_arc_base 0
 180 .  bfd_arch_m32r,      {* Mitsubishi M32R/D *}
 181 .#define bfd_mach_m32r          0 {* backwards compatibility *}
 182 .  bfd_arch_mn10200,   {* Matsushita MN10200 *}
 183 .  bfd_arch_mn10300,   {* Matsushita MN10300 *}
 184 .#define bfd_mach_mn10300               300
 185 .  bfd_arch_fr30,
 186 .#define bfd_mach_fr30          0x46523330
 187 .  bfd_arch_mcore,
 188 .  bfd_arch_last
 189 .  };
 190
 191
 192 */
 193
 194 /*
 195
 196 SUBSECTION
 197         bfd_arch_info
 198
 199 DESCRIPTION
 200         This structure contains information on architectures for use
 201         within BFD.
 202
 203 .
 204 .typedef struct bfd_arch_info
 205 .{
 206 .  int bits_per_word;
 207 .  int bits_per_address;
 208 .  int bits_per_byte;
 209 .  enum bfd_architecture arch;
 210 .  unsigned long mach;
 211 .  const char *arch_name;
 212 .  const char *printable_name;
 213 .  unsigned int section_align_power;
 214 . {* true if this is the default machine for the architecture *}
 215 .  boolean the_default;
 216 .  const struct bfd_arch_info * (*compatible)
 217 .       PARAMS ((const struct bfd_arch_info *a,
 218 .                const struct bfd_arch_info *b));
 219 .
 220 .  boolean (*scan) PARAMS ((const struct bfd_arch_info *, const char *));
 221 .
 222 .  const struct bfd_arch_info *next;
 223 .} bfd_arch_info_type;
 224 */
 225
 226 extern const bfd_arch_info_type bfd_a29k_arch;
 227 extern const bfd_arch_info_type bfd_alpha_arch;
 228 extern const bfd_arch_info_type bfd_arc_arch;
 229 extern const bfd_arch_info_type bfd_arm_arch;
 230 extern const bfd_arch_info_type bfd_d10v_arch;
 231 extern const bfd_arch_info_type bfd_d30v_arch;
 232 extern const bfd_arch_info_type bfd_h8300_arch;
 233 extern const bfd_arch_info_type bfd_h8500_arch;
 234 extern const bfd_arch_info_type bfd_hppa_arch;
 235 extern const bfd_arch_info_type bfd_i386_arch;
 236 extern const bfd_arch_info_type bfd_i860_arch;
 237 extern const bfd_arch_info_type bfd_i960_arch;
 238 extern const bfd_arch_info_type bfd_m32r_arch;
 239 extern const bfd_arch_info_type bfd_m68k_arch;
 240 extern const bfd_arch_info_type bfd_m88k_arch;
 241 extern const bfd_arch_info_type bfd_mips_arch;
 242 extern const bfd_arch_info_type bfd_mn10200_arch;
 243 extern const bfd_arch_info_type bfd_mn10300_arch;
 244 extern const bfd_arch_info_type bfd_powerpc_arch;
 245 extern const bfd_arch_info_type bfd_rs6000_arch;
 246 extern const bfd_arch_info_type bfd_sh_arch;
 247 extern const bfd_arch_info_type bfd_sparc_arch;
 248 extern const bfd_arch_info_type bfd_tic30_arch;
 249 extern const bfd_arch_info_type bfd_tic80_arch;
 250 extern const bfd_arch_info_type bfd_vax_arch;
 251 extern const bfd_arch_info_type bfd_we32k_arch;
 252 extern const bfd_arch_info_type bfd_z8k_arch;
 253 extern const bfd_arch_info_type bfd_ns32k_arch;
 254 extern const bfd_arch_info_type bfd_w65_arch;
 255 extern const bfd_arch_info_type bfd_v850_arch;
 256 extern const bfd_arch_info_type bfd_fr30_arch;
 257 extern const bfd_arch_info_type bfd_mcore_arch;
 258
 259 static const bfd_arch_info_type * const bfd_archures_list[] =
 260 {
 261 #ifdef SELECT_ARCHITECTURES
 262   SELECT_ARCHITECTURES,
 263 #else
 264   &bfd_a29k_arch,
 265   &bfd_alpha_arch,
 266   &bfd_arc_arch,
 267   &bfd_arm_arch,
 268   &bfd_d10v_arch,
 269   &bfd_d30v_arch,
 270   &bfd_h8300_arch,
 271   &bfd_h8500_arch,
 272   &bfd_hppa_arch,
 273   &bfd_i386_arch,
 274   &bfd_i860_arch,
 275   &bfd_i960_arch,
 276   &bfd_m32r_arch,
 277   &bfd_m68k_arch,
 278   &bfd_m88k_arch,
 279   &bfd_mips_arch,
 280   &bfd_mn10200_arch,
 281   &bfd_mn10300_arch,
 282   &bfd_powerpc_arch,
 283   &bfd_rs6000_arch,
 284   &bfd_sh_arch,
 285   &bfd_sparc_arch,
 286   &bfd_tic30_arch,
 287   &bfd_tic80_arch,
 288   &bfd_vax_arch,
 289   &bfd_we32k_arch,
 290   &bfd_z8k_arch,
 291   &bfd_ns32k_arch,
 292   &bfd_w65_arch,
 293   &bfd_v850_arch,
 294   &bfd_fr30_arch,
 295   & bfd_mcore_arch,
 296 #endif
 297   0
 298 };
 299
 300 /*
 301 FUNCTION
 302         bfd_printable_name
 303
 304 SYNOPSIS
 305         const char *bfd_printable_name(bfd *abfd);
 306
 307 DESCRIPTION
 308         Return a printable string representing the architecture and machine
 309         from the pointer to the architecture info structure.
 310
 311 */
 312
 313 const char *
 314 bfd_printable_name (abfd)
 315      bfd *abfd;
 316 {
 317   return abfd->arch_info->printable_name;
 318 }
 319
 320
 321
 322 /*
 323 FUNCTION
 324         bfd_scan_arch
 325
 326 SYNOPSIS
 327         const bfd_arch_info_type *bfd_scan_arch(const char *string);
 328
 329 DESCRIPTION
 330         Figure out if BFD supports any cpu which could be described with
 331         the name @var{string}.  Return a pointer to an <<arch_info>>
 332         structure if a machine is found, otherwise NULL.
 333
 334 */
 335
 336 const bfd_arch_info_type *
 337 bfd_scan_arch (string)
 338      const char *string;
 339 {
 340   const bfd_arch_info_type * const *app, *ap;
 341
 342   /* Look through all the installed architectures */
 343   for (app = bfd_archures_list; *app != NULL; app++)
 344     {
 345       for (ap = *app; ap != NULL; ap = ap->next)
 346         {
 347           if (ap->scan (ap, string))
 348             return ap;
 349         }
 350     }
 351
 352   return NULL;
 353 }
 354
 355
 356
 357 /*
 358 FUNCTION
 359         bfd_arch_list
 360
 361 SYNOPSIS
 362         const char **bfd_arch_list(void);
 363
 364 DESCRIPTION
 365         Return a freshly malloced NULL-terminated vector of the names
 366         of all the valid BFD architectures.  Do not modify the names.
 367
 368 */
 369
 370 const char **
 371 bfd_arch_list ()
 372 {
 373   int vec_length = 0;
 374   const char **name_ptr;
 375   const char **name_list;
 376   const bfd_arch_info_type * const *app;
 377
 378   /* Determine the number of architectures */
 379   vec_length = 0;
 380   for (app = bfd_archures_list; *app != NULL; app++)
 381     {
 382       const bfd_arch_info_type *ap;
 383       for (ap = *app; ap != NULL; ap = ap->next)
 384         {
 385           vec_length++;
 386         }
 387     }
 388
 389   name_list = (CONST char **)
 390     bfd_malloc ((vec_length + 1) * sizeof (char **));
 391   if (name_list == NULL)
 392     return NULL;
 393
 394   /* Point the list at each of the names */
 395   name_ptr = name_list;
 396   for (app = bfd_archures_list; *app != NULL; app++)
 397     {
 398       const bfd_arch_info_type *ap;
 399       for (ap = *app; ap != NULL; ap = ap->next)
 400         {
 401           *name_ptr = ap->printable_name;
 402           name_ptr++;
 403         }
 404     }
 405   *name_ptr = NULL;
 406
 407   return name_list;
 408 }
 409
 410
 411
 412 /*
 413 FUNCTION
 414         bfd_arch_get_compatible
 415
 416 SYNOPSIS
 417         const bfd_arch_info_type *bfd_arch_get_compatible(
 418                 const bfd *abfd,
 419                 const bfd *bbfd);
 420
 421 DESCRIPTION
 422         Determine whether two BFDs'
 423         architectures and machine types are compatible.  Calculates
 424         the lowest common denominator between the two architectures
 425         and machine types implied by the BFDs and returns a pointer to
 426         an <<arch_info>> structure describing the compatible machine.
 427 */
 428
 429 const bfd_arch_info_type *
 430 bfd_arch_get_compatible (abfd, bbfd)
 431      const bfd *abfd;
 432      const bfd *bbfd;
 433 {
 434   /* If either architecture is unknown, then all we can do is assume
 435      the user knows what he's doing.  */
 436   if (abfd->arch_info->arch == bfd_arch_unknown)
 437         return bbfd->arch_info;
 438   if (bbfd->arch_info->arch == bfd_arch_unknown)
 439         return abfd->arch_info;
 440
 441   /* Otherwise architecture-specific code has to decide.  */
 442   return abfd->arch_info->compatible (abfd->arch_info, bbfd->arch_info);
 443 }
 444
 445
 446 /*
 447 INTERNAL_DEFINITION
 448         bfd_default_arch_struct
 449
 450 DESCRIPTION
 451         The <<bfd_default_arch_struct>> is an item of
 452         <<bfd_arch_info_type>> which has been initialized to a fairly
 453         generic state.  A BFD starts life by pointing to this
 454         structure, until the correct back end has determined the real
 455         architecture of the file.
 456
 457 .extern const bfd_arch_info_type bfd_default_arch_struct;
 458
 459 */
 460
 461 const bfd_arch_info_type bfd_default_arch_struct =
 462 {
 463     32,32,8,bfd_arch_unknown,0,"unknown","unknown",2,true,
 464     bfd_default_compatible,
 465     bfd_default_scan,
 466     0,
 467 };
 468
 469 /*
 470 FUNCTION
 471         bfd_set_arch_info
 472
 473 SYNOPSIS
 474         void bfd_set_arch_info(bfd *abfd, const bfd_arch_info_type *arg);
 475
 476 DESCRIPTION
 477         Set the architecture info of @var{abfd} to @var{arg}.
 478 */
 479
 480 void
 481 bfd_set_arch_info (abfd, arg)
 482      bfd *abfd;
 483      const bfd_arch_info_type *arg;
 484 {
 485   abfd->arch_info = arg;
 486 }
 487
 488 /*
 489 INTERNAL_FUNCTION
 490         bfd_default_set_arch_mach
 491
 492 SYNOPSIS
 493         boolean bfd_default_set_arch_mach(bfd *abfd,
 494                 enum bfd_architecture arch,
 495                 unsigned long mach);
 496
 497 DESCRIPTION
 498         Set the architecture and machine type in BFD @var{abfd}
 499         to @var{arch} and @var{mach}.  Find the correct
 500         pointer to a structure and insert it into the <<arch_info>>
 501         pointer.
 502 */
 503
 504 boolean
 505 bfd_default_set_arch_mach (abfd, arch, mach)
 506      bfd *abfd;
 507      enum bfd_architecture arch;
 508      unsigned long mach;
 509 {
 510   const bfd_arch_info_type * const *app, *ap;
 511
 512   for (app = bfd_archures_list; *app != NULL; app++)
 513     {
 514       for (ap = *app; ap != NULL; ap = ap->next)
 515         {
 516           if (ap->arch == arch
 517               && (ap->mach == mach
 518                   || (mach == 0 && ap->the_default)))
 519             {
 520               abfd->arch_info = ap;
 521               return true;
 522             }
 523         }
 524     }
 525
 526   abfd->arch_info = &bfd_default_arch_struct;
 527   bfd_set_error (bfd_error_bad_value);
 528   return false;
 529 }
 530
 531
 532 /*
 533 FUNCTION
 534         bfd_get_arch
 535
 536 SYNOPSIS
 537         enum bfd_architecture bfd_get_arch(bfd *abfd);
 538
 539 DESCRIPTION
 540         Return the enumerated type which describes the BFD @var{abfd}'s
 541         architecture.
 542
 543 */
 544
 545 enum bfd_architecture
 546 bfd_get_arch (abfd)
 547      bfd *abfd;
 548 {
 549     return abfd->arch_info->arch;
 550 }
 551
 552 /*
 553 FUNCTION
 554         bfd_get_mach
 555
 556 SYNOPSIS
 557         unsigned long bfd_get_mach(bfd *abfd);
 558
 559 DESCRIPTION
 560         Return the long type which describes the BFD @var{abfd}'s
 561         machine.
 562 */
 563
 564 unsigned long
 565 bfd_get_mach (abfd)
 566      bfd *abfd;
 567 {
 568     return abfd->arch_info->mach;
 569 }
 570
 571 /*
 572 FUNCTION
 573         bfd_arch_bits_per_byte
 574
 575 SYNOPSIS
 576         unsigned int bfd_arch_bits_per_byte(bfd *abfd);
 577
 578 DESCRIPTION
 579         Return the number of bits in one of the BFD @var{abfd}'s
 580         architecture's bytes.
 581
 582 */
 583
 584 unsigned int
 585 bfd_arch_bits_per_byte (abfd)
 586      bfd *abfd;
 587 {
 588   return abfd->arch_info->bits_per_byte;
 589 }
 590
 591 /*
 592 FUNCTION
 593         bfd_arch_bits_per_address
 594
 595 SYNOPSIS
 596         unsigned int bfd_arch_bits_per_address(bfd *abfd);
 597
 598 DESCRIPTION
 599         Return the number of bits in one of the BFD @var{abfd}'s
 600         architecture's addresses.
 601 */
 602
 603 unsigned int
 604 bfd_arch_bits_per_address (abfd)
 605      bfd *abfd;
 606 {
 607   return abfd->arch_info->bits_per_address;
 608 }
 609
 610
 611 /*
 612 INTERNAL_FUNCTION
 613         bfd_default_compatible
 614
 615 SYNOPSIS
 616         const bfd_arch_info_type *bfd_default_compatible
 617         (const bfd_arch_info_type *a,
 618         const bfd_arch_info_type *b);
 619
 620 DESCRIPTION
 621         The default function for testing for compatibility.
 622 */
 623
 624 const bfd_arch_info_type *
 625 bfd_default_compatible (a,b)
 626      const bfd_arch_info_type *a;
 627      const bfd_arch_info_type *b;
 628 {
 629   if (a->arch != b->arch)
 630     return NULL;
 631
 632   if (a->mach > b->mach)
 633     return a;
 634
 635   if (b->mach > a->mach)
 636     return b;
 637
 638   return a;
 639 }
 640
 641
 642 /*
 643 INTERNAL_FUNCTION
 644         bfd_default_scan
 645
 646 SYNOPSIS
 647         boolean bfd_default_scan(const struct bfd_arch_info *info, const char *string);
 648
 649 DESCRIPTION
 650         The default function for working out whether this is an
 651         architecture hit and a machine hit.
 652 */
 653
 654 boolean
 655 bfd_default_scan (info, string)
 656      const struct bfd_arch_info *info;
 657      const char *string;
 658 {
 659   const char *ptr_src;
 660   const char *ptr_tst;
 661   unsigned long number;
 662   enum bfd_architecture arch;
 663   const char *printable_name_colon;
 664
 665   /* Exact match of the architecture name (ARCH_NAME) and also the
 666      default architecture? */
 667   if (strcasecmp (string, info->arch_name) == 0
 668       && info->the_default)
 669     return true;
 670
 671   /* Exact match of the machine name (PRINTABLE_NAME)? */
 672   if (strcasecmp (string, info->printable_name) == 0)
 673     return true;
 674
 675   /* Given that printable_name contains no colon, attempt to match:
 676      ARCH_NAME [ ":" ] PRINTABLE_NAME? */
 677   printable_name_colon = strchr (info->printable_name, ':');
 678   if (printable_name_colon == NULL)
 679     {
 680       int strlen_arch_name = strlen (info->arch_name);
 681       if (strncasecmp (string, info->arch_name, strlen_arch_name) == 0)
 682         {
 683           if (string[strlen_arch_name] == ':')
 684             {
 685               if (strcasecmp (string + strlen_arch_name + 1,
 686                               info->printable_name) == 0)
 687                 return true;
 688             }
 689           else
 690             {
 691               if (strcasecmp (string + strlen_arch_name,
 692                               info->printable_name) == 0)
 693                 return true;
 694             }
 695         }
 696     }
 697
 698   /* Given that PRINTABLE_NAME has the form: <arch> ":" <mach>;
 699      Attempt to match: <arch> <mach>? */
 700   if (printable_name_colon != NULL)
 701     {
 702       int colon_index = printable_name_colon - info->printable_name;
 703       if (strncasecmp (string, info->printable_name, colon_index) == 0
 704           && strcasecmp (string + colon_index,
 705                          info->printable_name + colon_index + 1) == 0)
 706         return true;
 707     }
 708
 709   /* Given that PRINTABLE_NAME has the form: <arch> ":" <mach>; Do not
 710      attempt to match just <mach>, it could be ambigious.  This test
 711      is left until later. */
 712
 713   /* NOTE: The below is retained for compatibility only. Please do not
 714      add to this code */
 715
 716   /* See how much of the supplied string matches with the
 717      architecture, eg the string m68k:68020 would match the 68k entry
 718      up to the :, then we get left with the machine number */
 719
 720   for (ptr_src = string, ptr_tst = info->arch_name;
 721        *ptr_src && *ptr_tst;
 722        ptr_src++, ptr_tst++)
 723     {
 724       if (*ptr_src != *ptr_tst) break;
 725     }
 726
 727   /* Chewed up as much of the architecture as will match, skip any
 728      colons */
 729   if (*ptr_src == ':')
 730     ptr_src++;
 731
 732   if (*ptr_src == 0)
 733     {
 734       /* nothing more, then only keep this one if it is the default
 735          machine for this architecture */
 736       return info->the_default;
 737     }
 738
 739   number = 0;
 740   while (isdigit ((unsigned char) *ptr_src))
 741     {
 742       number = number * 10 + *ptr_src  - '0';
 743       ptr_src++;
 744     }
 745
 746   /* NOTE: The below is retained for compatibility only.
 747      PLEASE DO NOT ADD TO THIS CODE. */
 748
 749   switch (number)
 750     {
 751       /* FIXME: These are needed to parse IEEE objects.  */
 752     case 68000:
 753       arch = bfd_arch_m68k;
 754       number = bfd_mach_m68000;
 755       break;
 756     case 68010:
 757       arch = bfd_arch_m68k;
 758       number = bfd_mach_m68010;
 759       break;
 760     case 68020:
 761       arch = bfd_arch_m68k;
 762       number = bfd_mach_m68020;
 763       break;
 764     case 68030:
 765       arch = bfd_arch_m68k;
 766       number = bfd_mach_m68030;
 767       break;
 768     case 68040:
 769       arch = bfd_arch_m68k;
 770       number = bfd_mach_m68040;
 771       break;
 772     case 68060:
 773       arch = bfd_arch_m68k;
 774       number = bfd_mach_m68060;
 775       break;
 776     case 68332:
 777       arch = bfd_arch_m68k;
 778       number = bfd_mach_cpu32;
 779       break;
 780
 781     case 32000:
 782       arch = bfd_arch_we32k;
 783       break;
 784
 785     case 3000:
 786       arch = bfd_arch_mips;
 787       number = bfd_mach_mips3000;
 788       break;
 789
 790     case 4000:
 791       arch = bfd_arch_mips;
 792       number = bfd_mach_mips4000;
 793       break;
 794
 795     case 6000:
 796       arch = bfd_arch_rs6000;
 797       break;
 798
 799     default:
 800       return false;
 801     }
 802
 803   if (arch != info->arch)
 804     return false;
 805
 806   if (number != info->mach)
 807     return false;
 808
 809   return true;
 810 }
 811
 812
 813 /*
 814 FUNCTION
 815         bfd_get_arch_info
 816
 817 SYNOPSIS
 818         const bfd_arch_info_type * bfd_get_arch_info(bfd *abfd);
 819
 820 DESCRIPTION
 821         Return the architecture info struct in @var{abfd}.
 822 */
 823
 824 const bfd_arch_info_type *
 825 bfd_get_arch_info (abfd)
 826      bfd *abfd;
 827 {
 828   return abfd->arch_info;
 829 }
 830
 831
 832 /*
 833 FUNCTION
 834         bfd_lookup_arch
 835
 836 SYNOPSIS
 837         const bfd_arch_info_type *bfd_lookup_arch
 838                 (enum bfd_architecture
 839                 arch,
 840                 unsigned long machine);
 841
 842 DESCRIPTION
 843         Look for the architecure info structure which matches the
 844         arguments @var{arch} and @var{machine}. A machine of 0 matches the
 845         machine/architecture structure which marks itself as the
 846         default.
 847 */
 848
 849 const bfd_arch_info_type *
 850 bfd_lookup_arch (arch, machine)
 851      enum bfd_architecture arch;
 852      unsigned long machine;
 853 {
 854   const bfd_arch_info_type * const *app, *ap;
 855
 856   for (app = bfd_archures_list; *app != NULL; app++)
 857     {
 858       for (ap = *app; ap != NULL; ap = ap->next)
 859         {
 860           if (ap->arch == arch
 861               && (ap->mach == machine
 862                   || (machine == 0 && ap->the_default)))
 863             return ap;
 864         }
 865     }
 866
 867   return NULL;
 868 }
 869
 870
 871 /*
 872 FUNCTION
 873         bfd_printable_arch_mach
 874
 875 SYNOPSIS
 876         const char *bfd_printable_arch_mach
 877                 (enum bfd_architecture arch, unsigned long machine);
 878
 879 DESCRIPTION
 880         Return a printable string representing the architecture and
 881         machine type.
 882
 883         This routine is depreciated.
 884 */
 885
 886 const char *
 887 bfd_printable_arch_mach (arch, machine)
 888      enum bfd_architecture arch;
 889      unsigned long machine;
 890 {
 891     const bfd_arch_info_type *ap = bfd_lookup_arch (arch, machine);
 892
 893     if (ap)
 894       return ap->printable_name;
 895     return "UNKNOWN!";
 896 }