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