bfd/archures.c

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