1 /* BFD library support routines for architectures.
2 Copyright (C) 1990, 91, 92, 93, 94 Free Software Foundation, Inc.
3 Hacked by John Gilmore and Steve Chamberlain of Cygnus Support.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
26 BFD keeps one atom in a BFD describing the
27 architecture of the data attached to the BFD: a pointer to a
28 <<bfd_arch_info_type>>.
30 Pointers to structures can be requested independently of a BFD
31 so that an architecture's information can be interrogated
32 without access to an open BFD.
34 The architecture information is provided by each architecture package.
35 The set of default architectures is selected by the macro
36 <<SELECT_ARCHITECTURES>>. This is normally set up in the
37 @file{config/@var{target}.mt} file of your choice. If the name is not
38 defined, then all the architectures supported are included.
40 When BFD starts up, all the architectures are called with an
41 initialize method. It is up to the architecture back end to
42 insert as many items into the list of architectures as it wants to;
43 generally this would be one for each machine and one for the
44 default case (an item with a machine field of 0).
46 BFD's idea of an architecture is implemented in @file{archures.c}.
55 This enum gives the object file's CPU architecture, in a
56 global sense---i.e., what processor family does it belong to?
57 Another field indicates which processor within
58 the family is in use. The machine gives a number which
59 distinguishes different versions of the architecture,
60 containing, for example, 2 and 3 for Intel i960 KA and i960 KB,
61 and 68020 and 68030 for Motorola 68020 and 68030.
63 .enum bfd_architecture
65 . bfd_arch_unknown, {* File arch not known *}
66 . bfd_arch_obscure, {* Arch known, not one of these *}
67 . bfd_arch_m68k, {* Motorola 68xxx *}
68 . bfd_arch_vax, {* DEC Vax *}
69 . bfd_arch_i960, {* Intel 960 *}
70 . {* The order of the following is important.
71 . lower number indicates a machine type that
72 . only accepts a subset of the instructions
73 . available to machines with higher numbers.
74 . The exception is the "ca", which is
75 . incompatible with all other machines except
78 .#define bfd_mach_i960_core 1
79 .#define bfd_mach_i960_ka_sa 2
80 .#define bfd_mach_i960_kb_sb 3
81 .#define bfd_mach_i960_mc 4
82 .#define bfd_mach_i960_xa 5
83 .#define bfd_mach_i960_ca 6
84 . {* start-sanitize-i960xl *}
85 .#define bfd_mach_i960_xl 7
86 . {* end-sanitize-i960xl *}
88 . bfd_arch_a29k, {* AMD 29000 *}
89 . bfd_arch_sparc, {* SPARC *}
90 . bfd_arch_mips, {* MIPS Rxxxx *}
91 . bfd_arch_i386, {* Intel 386 *}
92 . bfd_arch_we32k, {* AT&T WE32xxx *}
93 . bfd_arch_tahoe, {* CCI/Harris Tahoe *}
94 . bfd_arch_i860, {* Intel 860 *}
95 . bfd_arch_romp, {* IBM ROMP PC/RT *}
96 . bfd_arch_alliant, {* Alliant *}
97 . bfd_arch_convex, {* Convex *}
98 . bfd_arch_m88k, {* Motorola 88xxx *}
99 . bfd_arch_pyramid, {* Pyramid Technology *}
100 . bfd_arch_h8300, {* Hitachi H8/300 *}
101 .#define bfd_mach_h8300 1
102 .#define bfd_mach_h8300h 2
103 . bfd_arch_powerpc, {* PowerPC *}
104 . bfd_arch_rs6000, {* IBM RS/6000 *}
105 . bfd_arch_hppa, {* HP PA RISC *}
106 . bfd_arch_z8k, {* Zilog Z8000 *}
107 .#define bfd_mach_z8001 1
108 .#define bfd_mach_z8002 2
109 . bfd_arch_h8500, {* Hitachi H8/500 *}
110 . bfd_arch_sh, {* Hitachi SH *}
111 . bfd_arch_alpha, {* Dec Alpha *}
112 . bfd_arch_arm, {* Advanced Risc Machines ARM *}
113 . bfd_arch_ns32k, {* National Semiconductors ns32000 *}
114 . {* start-sanitize-rce *}
115 . bfd_arch_rce, {* Motorola RCE *}
116 . {* end-sanitize-rce *}
117 . {* start-sanitize-arc *}
118 . bfd_arch_arc, {* Argonaut RISC Core *}
119 . {* end-sanitize-arc *}
136 This structure contains information on architectures for use
140 .typedef struct bfd_arch_info
143 . int bits_per_address;
145 . enum bfd_architecture arch;
148 . CONST char *printable_name;
149 . unsigned int section_align_power;
150 . {* true if this is the default machine for the architecture *}
151 . boolean the_default;
152 . CONST struct bfd_arch_info * (*compatible)
153 . PARAMS ((CONST struct bfd_arch_info *a,
154 . CONST struct bfd_arch_info *b));
156 . boolean (*scan) PARAMS ((CONST struct bfd_arch_info *, CONST char *));
157 . {* How to disassemble an instruction, producing a printable
158 . representation on a specified stdio stream. This isn't
159 . defined for most processors at present, because of the size
160 . of the additional tables it would drag in, and because gdb
161 . wants to use a different interface. *}
162 . unsigned int (*disassemble) PARAMS ((bfd_vma addr, CONST char *data,
165 . struct bfd_arch_info *next;
166 .} bfd_arch_info_type;
169 bfd_arch_info_type
*bfd_arch_info_list
;
177 CONST char *bfd_printable_name(bfd *abfd);
180 Return a printable string representing the architecture and machine
181 from the pointer to the architecture info structure.
186 bfd_printable_name (abfd
)
189 return abfd
->arch_info
->printable_name
;
199 bfd_arch_info_type *bfd_scan_arch(CONST char *string);
202 Figure out if BFD supports any cpu which could be described with
203 the name @var{string}. Return a pointer to an <<arch_info>>
204 structure if a machine is found, otherwise NULL.
209 bfd_scan_arch (string
)
212 struct bfd_arch_info
*ap
;
214 /* Look through all the installed architectures */
215 for (ap
= bfd_arch_info_list
;
216 ap
!= (bfd_arch_info_type
*)NULL
;
219 if (ap
->scan(ap
, string
))
222 return (bfd_arch_info_type
*)NULL
;
229 bfd_arch_get_compatible
232 CONST bfd_arch_info_type *bfd_arch_get_compatible(
237 Determine whether two BFDs'
238 architectures and machine types are compatible. Calculates
239 the lowest common denominator between the two architectures
240 and machine types implied by the BFDs and returns a pointer to
241 an <<arch_info>> structure describing the compatible machine.
244 CONST bfd_arch_info_type
*
245 bfd_arch_get_compatible (abfd
, bbfd
)
249 return abfd
->arch_info
->compatible(abfd
->arch_info
,bbfd
->arch_info
);
255 bfd_default_arch_struct
258 The <<bfd_default_arch_struct>> is an item of
259 <<bfd_arch_info_type>> which has been initialized to a fairly
260 generic state. A BFD starts life by pointing to this
261 structure, until the correct back end has determined the real
262 architecture of the file.
264 .extern bfd_arch_info_type bfd_default_arch_struct;
268 bfd_arch_info_type bfd_default_arch_struct
=
270 32,32,8,bfd_arch_unknown
,0,"unknown","unknown",2,true,
271 bfd_default_compatible
,
281 void bfd_set_arch_info(bfd *abfd, bfd_arch_info_type *arg);
284 Set the architecture info of @var{abfd} to @var{arg}.
288 bfd_set_arch_info (abfd
, arg
)
290 bfd_arch_info_type
*arg
;
292 abfd
->arch_info
= arg
;
297 bfd_default_set_arch_mach
300 boolean bfd_default_set_arch_mach(bfd *abfd,
301 enum bfd_architecture arch,
305 Set the architecture and machine type in BFD @var{abfd}
306 to @var{arch} and @var{mach}. Find the correct
307 pointer to a structure and insert it into the <<arch_info>>
312 bfd_default_set_arch_mach (abfd
, arch
, mach
)
314 enum bfd_architecture arch
;
317 static struct bfd_arch_info
*old_ptr
= &bfd_default_arch_struct
;
318 boolean found
= false;
319 /* run through the table to find the one we want, we keep a little
320 cache to speed things up */
321 if (old_ptr
== 0 || arch
!= old_ptr
->arch
|| mach
!= old_ptr
->mach
) {
322 bfd_arch_info_type
*ptr
;
323 old_ptr
= (bfd_arch_info_type
*)NULL
;
324 for (ptr
= bfd_arch_info_list
;
325 ptr
!= (bfd_arch_info_type
*)NULL
;
327 if (ptr
->arch
== arch
&&
328 ((ptr
->mach
== mach
) || (ptr
->the_default
&& mach
== 0))) {
335 /*looked for it and it wasn't there, so put in the default */
336 old_ptr
= &bfd_default_arch_struct
;
337 bfd_set_error (bfd_error_bad_value
);
341 /* it was in the cache */
345 abfd
->arch_info
= old_ptr
;
356 enum bfd_architecture bfd_get_arch(bfd *abfd);
359 Return the enumerated type which describes the BFD @var{abfd}'s
364 enum bfd_architecture
368 return abfd
->arch_info
->arch
;
376 unsigned long bfd_get_mach(bfd *abfd);
379 Return the long type which describes the BFD @var{abfd}'s
387 return abfd
->arch_info
->mach
;
392 bfd_arch_bits_per_byte
395 unsigned int bfd_arch_bits_per_byte(bfd *abfd);
398 Return the number of bits in one of the BFD @var{abfd}'s
399 architecture's bytes.
404 bfd_arch_bits_per_byte (abfd
)
407 return abfd
->arch_info
->bits_per_byte
;
412 bfd_arch_bits_per_address
415 unsigned int bfd_arch_bits_per_address(bfd *abfd);
418 Return the number of bits in one of the BFD @var{abfd}'s
419 architecture's addresses.
423 bfd_arch_bits_per_address (abfd
)
426 return abfd
->arch_info
->bits_per_address
;
430 extern void bfd_a29k_arch
PARAMS ((void));
431 extern void bfd_alpha_arch
PARAMS ((void));
432 /* start-sanitize-arc */
433 extern void bfd_arc_arch
PARAMS ((void));
434 /* end-sanitize-arc */
435 extern void bfd_arm_arch
PARAMS ((void));
436 extern void bfd_h8300_arch
PARAMS ((void));
437 extern void bfd_h8500_arch
PARAMS ((void));
438 extern void bfd_hppa_arch
PARAMS ((void));
439 extern void bfd_i386_arch
PARAMS ((void));
440 extern void bfd_i960_arch
PARAMS ((void));
441 extern void bfd_m68k_arch
PARAMS ((void));
442 extern void bfd_m88k_arch
PARAMS ((void));
443 extern void bfd_mips_arch
PARAMS ((void));
444 extern void bfd_powerpc_arch
PARAMS ((void));
445 extern void bfd_rs6000_arch
PARAMS ((void));
446 extern void bfd_sh_arch
PARAMS ((void));
447 /* start-sanitize-rce */
448 extern void bfd_rce_arch
PARAMS ((void));
449 /* end-sanitize-rce */
450 extern void bfd_sparc_arch
PARAMS ((void));
451 extern void bfd_vax_arch
PARAMS ((void));
452 extern void bfd_we32k_arch
PARAMS ((void));
453 extern void bfd_z8k_arch
PARAMS ((void));
454 extern void bfd_ns32k_arch
PARAMS ((void));
456 static void (*const archures_init_table
[]) PARAMS ((void)) =
458 #ifdef SELECT_ARCHITECTURES
459 SELECT_ARCHITECTURES
,
463 /* start-sanitize-arc */
465 /* end-sanitize-arc */
478 /* start-sanitize-rce */
480 /* end-sanitize-rce */
497 void bfd_arch_init(void);
500 Initialize the architecture dispatch table by
501 calling all installed architecture packages and getting them
508 void (*const *ptable
) PARAMS ((void));
509 for (ptable
= archures_init_table
; *ptable
; ptable
++)
519 void bfd_arch_linkin(bfd_arch_info_type *ptr);
522 Link the architecture info structure @var{ptr} into the list.
526 bfd_arch_linkin (ptr
)
527 bfd_arch_info_type
*ptr
;
529 ptr
->next
= bfd_arch_info_list
;
530 bfd_arch_info_list
= ptr
;
536 bfd_default_compatible
539 CONST bfd_arch_info_type *bfd_default_compatible
540 (CONST bfd_arch_info_type *a,
541 CONST bfd_arch_info_type *b);
544 The default function for testing for compatibility.
547 CONST bfd_arch_info_type
*
548 bfd_default_compatible (a
,b
)
549 CONST bfd_arch_info_type
*a
;
550 CONST bfd_arch_info_type
*b
;
552 if(a
->arch
!= b
->arch
) return NULL
;
554 if (a
->mach
> b
->mach
) {
557 if (b
->mach
> a
->mach
) {
569 boolean bfd_default_scan(CONST struct bfd_arch_info *info, CONST char *string);
572 The default function for working out whether this is an
573 architecture hit and a machine hit.
577 bfd_default_scan (info
, string
)
578 CONST
struct bfd_arch_info
*info
;
583 unsigned long number
;
584 enum bfd_architecture arch
;
585 /* First test for an exact match */
586 if (strcmp(string
, info
->printable_name
) == 0) return true;
588 /* See how much of the supplied string matches with the
589 architecture, eg the string m68k:68020 would match the 68k entry
590 up to the :, then we get left with the machine number */
592 for (ptr_src
= string
,
593 ptr_tst
= info
->arch_name
;
594 *ptr_src
&& *ptr_tst
;
598 if (*ptr_src
!= *ptr_tst
) break;
601 /* Chewed up as much of the architecture as will match, skip any
603 if (*ptr_src
== ':') ptr_src
++;
606 /* nothing more, then only keep this one if it is the default
607 machine for this architecture */
608 return info
->the_default
;
611 while (isdigit(*ptr_src
)) {
612 number
= number
* 10 + *ptr_src
- '0';
619 arch
= bfd_arch_h8300
;
623 arch
= bfd_arch_h8500
;
633 arch
= bfd_arch_m68k
;
639 arch
= bfd_arch_i386
;
642 arch
= bfd_arch_a29k
;
650 arch
= bfd_arch_we32k
;
655 arch
= bfd_arch_i860
;
659 arch
= bfd_arch_i960
;
666 arch
= bfd_arch_mips
;
670 arch
= bfd_arch_rs6000
;
676 if (arch
!= info
->arch
)
679 if (number
!= info
->mach
)
691 bfd_arch_info_type * bfd_get_arch_info(bfd *abfd);
694 Return the architecture info struct in @var{abfd}.
698 bfd_get_arch_info (abfd
)
701 return abfd
->arch_info
;
710 bfd_arch_info_type *bfd_lookup_arch
711 (enum bfd_architecture
716 Look for the architecure info structure which matches the
717 arguments @var{arch} and @var{machine}. A machine of 0 matches the
718 machine/architecture structure which marks itself as the
723 bfd_lookup_arch (arch
, machine
)
724 enum bfd_architecture arch
;
727 bfd_arch_info_type
*ap
;
729 for (ap
= bfd_arch_info_list
;
730 ap
!= (bfd_arch_info_type
*)NULL
;
732 if (ap
->arch
== arch
&&
733 ((ap
->mach
== machine
)
734 || (ap
->the_default
&& machine
== 0))) {
738 return (bfd_arch_info_type
*)NULL
;
744 bfd_printable_arch_mach
747 CONST char *bfd_printable_arch_mach
748 (enum bfd_architecture arch, unsigned long machine);
751 Return a printable string representing the architecture and
754 This routine is depreciated.
758 bfd_printable_arch_mach (arch
, machine
)
759 enum bfd_architecture arch
;
760 unsigned long machine
;
762 bfd_arch_info_type
*ap
= bfd_lookup_arch(arch
, machine
);
763 if(ap
) return ap
->printable_name
;