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