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 *}
115 . bfd_arch_rce, {* Motorola RCE *}
133 This structure contains information on architectures for use
137 .typedef struct bfd_arch_info
140 . int bits_per_address;
142 . enum bfd_architecture arch;
145 . CONST char *printable_name;
146 . unsigned int section_align_power;
147 . {* true if this is the default machine for the architecture *}
148 . boolean the_default;
149 . CONST struct bfd_arch_info * (*compatible)
150 . PARAMS ((CONST struct bfd_arch_info *a,
151 . CONST struct bfd_arch_info *b));
153 . boolean (*scan) PARAMS ((CONST struct bfd_arch_info *, CONST char *));
154 . {* How to disassemble an instruction, producing a printable
155 . representation on a specified stdio stream. This isn't
156 . defined for most processors at present, because of the size
157 . of the additional tables it would drag in, and because gdb
158 . wants to use a different interface. *}
159 . unsigned int (*disassemble) PARAMS ((bfd_vma addr, CONST char *data,
162 . struct bfd_arch_info *next;
163 .} bfd_arch_info_type;
166 bfd_arch_info_type
*bfd_arch_info_list
;
174 CONST char *bfd_printable_name(bfd *abfd);
177 Return a printable string representing the architecture and machine
178 from the pointer to the architecture info structure.
183 bfd_printable_name (abfd
)
186 return abfd
->arch_info
->printable_name
;
196 bfd_arch_info_type *bfd_scan_arch(CONST char *string);
199 Figure out if BFD supports any cpu which could be described with
200 the name @var{string}. Return a pointer to an <<arch_info>>
201 structure if a machine is found, otherwise NULL.
206 bfd_scan_arch (string
)
209 struct bfd_arch_info
*ap
;
211 /* Look through all the installed architectures */
212 for (ap
= bfd_arch_info_list
;
213 ap
!= (bfd_arch_info_type
*)NULL
;
216 if (ap
->scan(ap
, string
))
219 return (bfd_arch_info_type
*)NULL
;
226 bfd_arch_get_compatible
229 CONST bfd_arch_info_type *bfd_arch_get_compatible(
234 Determine whether two BFDs'
235 architectures and machine types are compatible. Calculates
236 the lowest common denominator between the two architectures
237 and machine types implied by the BFDs and returns a pointer to
238 an <<arch_info>> structure describing the compatible machine.
241 CONST bfd_arch_info_type
*
242 bfd_arch_get_compatible (abfd
, bbfd
)
246 return abfd
->arch_info
->compatible(abfd
->arch_info
,bbfd
->arch_info
);
252 bfd_default_arch_struct
255 The <<bfd_default_arch_struct>> is an item of
256 <<bfd_arch_info_type>> which has been initialized to a fairly
257 generic state. A BFD starts life by pointing to this
258 structure, until the correct back end has determined the real
259 architecture of the file.
261 .extern bfd_arch_info_type bfd_default_arch_struct;
265 bfd_arch_info_type bfd_default_arch_struct
=
267 32,32,8,bfd_arch_unknown
,0,"unknown","unknown",2,true,
268 bfd_default_compatible
,
278 void bfd_set_arch_info(bfd *abfd, bfd_arch_info_type *arg);
281 Set the architecture info of @var{abfd} to @var{arg}.
285 bfd_set_arch_info (abfd
, arg
)
287 bfd_arch_info_type
*arg
;
289 abfd
->arch_info
= arg
;
294 bfd_default_set_arch_mach
297 boolean bfd_default_set_arch_mach(bfd *abfd,
298 enum bfd_architecture arch,
302 Set the architecture and machine type in BFD @var{abfd}
303 to @var{arch} and @var{mach}. Find the correct
304 pointer to a structure and insert it into the <<arch_info>>
309 bfd_default_set_arch_mach (abfd
, arch
, mach
)
311 enum bfd_architecture arch
;
314 static struct bfd_arch_info
*old_ptr
= &bfd_default_arch_struct
;
315 boolean found
= false;
316 /* run through the table to find the one we want, we keep a little
317 cache to speed things up */
318 if (old_ptr
== 0 || arch
!= old_ptr
->arch
|| mach
!= old_ptr
->mach
) {
319 bfd_arch_info_type
*ptr
;
320 old_ptr
= (bfd_arch_info_type
*)NULL
;
321 for (ptr
= bfd_arch_info_list
;
322 ptr
!= (bfd_arch_info_type
*)NULL
;
324 if (ptr
->arch
== arch
&&
325 ((ptr
->mach
== mach
) || (ptr
->the_default
&& mach
== 0))) {
332 /*looked for it and it wasn't there, so put in the default */
333 old_ptr
= &bfd_default_arch_struct
;
334 bfd_set_error (bfd_error_bad_value
);
338 /* it was in the cache */
342 abfd
->arch_info
= old_ptr
;
353 enum bfd_architecture bfd_get_arch(bfd *abfd);
356 Return the enumerated type which describes the BFD @var{abfd}'s
361 enum bfd_architecture
365 return abfd
->arch_info
->arch
;
373 unsigned long bfd_get_mach(bfd *abfd);
376 Return the long type which describes the BFD @var{abfd}'s
384 return abfd
->arch_info
->mach
;
389 bfd_arch_bits_per_byte
392 unsigned int bfd_arch_bits_per_byte(bfd *abfd);
395 Return the number of bits in one of the BFD @var{abfd}'s
396 architecture's bytes.
401 bfd_arch_bits_per_byte (abfd
)
404 return abfd
->arch_info
->bits_per_byte
;
409 bfd_arch_bits_per_address
412 unsigned int bfd_arch_bits_per_address(bfd *abfd);
415 Return the number of bits in one of the BFD @var{abfd}'s
416 architecture's addresses.
420 bfd_arch_bits_per_address (abfd
)
423 return abfd
->arch_info
->bits_per_address
;
427 extern void bfd_a29k_arch
PARAMS ((void));
428 extern void bfd_alpha_arch
PARAMS ((void));
429 extern void bfd_arm_arch
PARAMS ((void));
430 extern void bfd_h8300_arch
PARAMS ((void));
431 extern void bfd_h8500_arch
PARAMS ((void));
432 extern void bfd_hppa_arch
PARAMS ((void));
433 extern void bfd_i386_arch
PARAMS ((void));
434 extern void bfd_i960_arch
PARAMS ((void));
435 extern void bfd_m68k_arch
PARAMS ((void));
436 extern void bfd_m88k_arch
PARAMS ((void));
437 extern void bfd_mips_arch
PARAMS ((void));
438 extern void bfd_powerpc_arch
PARAMS ((void));
439 extern void bfd_rs6000_arch
PARAMS ((void));
440 extern void bfd_sh_arch
PARAMS ((void));
441 /* start-sanitize-rce */
442 extern void bfd_rce_arch
PARAMS ((void));
443 /* end-sanitize-rce */
444 extern void bfd_sparc_arch
PARAMS ((void));
445 extern void bfd_vax_arch
PARAMS ((void));
446 extern void bfd_we32k_arch
PARAMS ((void));
447 extern void bfd_z8k_arch
PARAMS ((void));
448 extern void bfd_ns32k_arch
PARAMS ((void));
450 static void (*archures_init_table
[]) PARAMS ((void)) =
452 #ifdef SELECT_ARCHITECTURES
453 SELECT_ARCHITECTURES
,
469 /* start-sanitize-rce */
471 /* end-sanitize-rce */
488 void bfd_arch_init(void);
491 Initialize the architecture dispatch table by
492 calling all installed architecture packages and getting them
499 void (**ptable
) PARAMS ((void));
500 for (ptable
= archures_init_table
;
514 void bfd_arch_linkin(bfd_arch_info_type *ptr);
517 Link the architecture info structure @var{ptr} into the list.
521 bfd_arch_linkin (ptr
)
522 bfd_arch_info_type
*ptr
;
524 ptr
->next
= bfd_arch_info_list
;
525 bfd_arch_info_list
= ptr
;
531 bfd_default_compatible
534 CONST bfd_arch_info_type *bfd_default_compatible
535 (CONST bfd_arch_info_type *a,
536 CONST bfd_arch_info_type *b);
539 The default function for testing for compatibility.
542 CONST bfd_arch_info_type
*
543 bfd_default_compatible (a
,b
)
544 CONST bfd_arch_info_type
*a
;
545 CONST bfd_arch_info_type
*b
;
547 if(a
->arch
!= b
->arch
) return NULL
;
549 if (a
->mach
> b
->mach
) {
552 if (b
->mach
> a
->mach
) {
564 boolean bfd_default_scan(CONST struct bfd_arch_info *info, CONST char *string);
567 The default function for working out whether this is an
568 architecture hit and a machine hit.
572 bfd_default_scan (info
, string
)
573 CONST
struct bfd_arch_info
*info
;
578 unsigned long number
;
579 enum bfd_architecture arch
;
580 /* First test for an exact match */
581 if (strcmp(string
, info
->printable_name
) == 0) return true;
583 /* See how much of the supplied string matches with the
584 architecture, eg the string m68k:68020 would match the 68k entry
585 up to the :, then we get left with the machine number */
587 for (ptr_src
= string
,
588 ptr_tst
= info
->arch_name
;
589 *ptr_src
&& *ptr_tst
;
593 if (*ptr_src
!= *ptr_tst
) break;
596 /* Chewed up as much of the architecture as will match, skip any
598 if (*ptr_src
== ':') ptr_src
++;
601 /* nothing more, then only keep this one if it is the default
602 machine for this architecture */
603 return info
->the_default
;
606 while (isdigit(*ptr_src
)) {
607 number
= number
* 10 + *ptr_src
- '0';
614 arch
= bfd_arch_h8300
;
618 arch
= bfd_arch_h8500
;
628 arch
= bfd_arch_m68k
;
634 arch
= bfd_arch_i386
;
637 arch
= bfd_arch_a29k
;
645 arch
= bfd_arch_we32k
;
650 arch
= bfd_arch_i860
;
654 arch
= bfd_arch_i960
;
661 arch
= bfd_arch_mips
;
665 arch
= bfd_arch_rs6000
;
671 if (arch
!= info
->arch
)
674 if (number
!= info
->mach
)
686 bfd_arch_info_type * bfd_get_arch_info(bfd *abfd);
689 Return the architecture info struct in @var{abfd}.
693 bfd_get_arch_info (abfd
)
696 return abfd
->arch_info
;
705 bfd_arch_info_type *bfd_lookup_arch
706 (enum bfd_architecture
711 Look for the architecure info structure which matches the
712 arguments @var{arch} and @var{machine}. A machine of 0 matches the
713 machine/architecture structure which marks itself as the
718 bfd_lookup_arch (arch
, machine
)
719 enum bfd_architecture arch
;
722 bfd_arch_info_type
*ap
;
724 for (ap
= bfd_arch_info_list
;
725 ap
!= (bfd_arch_info_type
*)NULL
;
727 if (ap
->arch
== arch
&&
728 ((ap
->mach
== machine
)
729 || (ap
->the_default
&& machine
== 0))) {
733 return (bfd_arch_info_type
*)NULL
;
739 bfd_printable_arch_mach
742 CONST char *bfd_printable_arch_mach
743 (enum bfd_architecture arch, unsigned long machine);
746 Return a printable string representing the architecture and
749 This routine is depreciated.
753 bfd_printable_arch_mach (arch
, machine
)
754 enum bfd_architecture arch
;
755 unsigned long machine
;
757 bfd_arch_info_type
*ap
= bfd_lookup_arch(arch
, machine
);
758 if(ap
) return ap
->printable_name
;