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