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