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