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