bfd/archures.c

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