1 /* BFD library support routines for architectures.
2 Copyright (C) 1990-1991 Free Software Foundation, Inc.
3 Hacked by John Gilmore and Steve Chamberlain of Cygnus Support.
6 This file is part of BFD, the Binary File Descriptor library.
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.
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.
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., 675 Mass Ave, Cambridge, MA 02139, USA. */
27 BFD's idea of an architecture is implimented in
28 <<archures.c>>. BFD keeps one atom in a BFD describing the
29 architecture of the data attached to the BFD; a pointer to a
30 <<bfd_arch_info_type>>.
32 Pointers to structures can be requested independently of a bfd
33 so that an architecture's information can be interrogated
34 without access to an open bfd.
36 The arch information is provided by each architecture package.
37 The set of default architectures is selected by the #define
38 <<SELECT_ARCHITECTURES>>. This is normally set up in the
39 <<config\/h\->> file of your choice. If the name is not
40 defined, then all the architectures supported are included.
42 When BFD starts up, all the architectures are called with an
43 initialize method. It is up to the architecture back end to
44 insert as many items into the list of arches as it wants to,
45 generally this would be one for each machine and one for the
46 default case (an item with a machine field of 0).
55 This enum gives the object file's CPU architecture, in a
56 global sense. E.g. what processor family does it belong to?
57 There is another field, which indicates what processor within
58 the family is in use. The machine gives a number which
59 distingushes 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
85 . bfd_arch_a29k, {* AMD 29000 *}
86 . bfd_arch_sparc, {* SPARC *}
87 . bfd_arch_mips, {* MIPS Rxxxx *}
88 . bfd_arch_i386, {* Intel 386 *}
89 . bfd_arch_ns32k, {* National Semiconductor 32xxx *}
90 . bfd_arch_tahoe, {* CCI/Harris Tahoe *}
91 . bfd_arch_i860, {* Intel 860 *}
92 . bfd_arch_romp, {* IBM ROMP PC/RT *}
93 . bfd_arch_alliant, {* Alliant *}
94 . bfd_arch_convex, {* Convex *}
95 . bfd_arch_m88k, {* Motorola 88xxx *}
96 . bfd_arch_pyramid, {* Pyramid Technology *}
97 . bfd_arch_h8300, {* Hitachi H8/300 *}
98 . bfd_arch_rs6000, {* IBM RS/6000 *}
99 . bfd_arch_hppa, {* HP PA RISC *}
120 This structure contains information on architectures for use
123 .typedef int bfd_reloc_code_type;
125 .typedef struct bfd_arch_info
128 . int bits_per_address;
130 . enum bfd_architecture arch;
133 . CONST char *printable_name;
134 . unsigned int section_align_power;
135 . {* true if this is the default machine for the architecture *}
136 . boolean the_default;
137 . CONST struct bfd_arch_info * EXFUN((*compatible),
138 . (CONST struct bfd_arch_info *a,
139 . CONST struct bfd_arch_info *b));
141 . boolean EXFUN((*scan),(CONST struct bfd_arch_info *,CONST char *));
142 . unsigned int EXFUN((*disassemble),(bfd_vma addr, CONST char *data,
145 . unsigned int segment_size;
146 . unsigned int page_size;
148 . struct bfd_arch_info *next;
149 .} bfd_arch_info_type;
152 bfd_arch_info_type
*bfd_arch_info_list
;
160 CONST char *bfd_printable_name(bfd *abfd);
163 Return a printable string representing the architecture and machine
164 from the pointer to the arch info structure
169 DEFUN(bfd_printable_name
, (abfd
),
172 return abfd
->arch_info
->printable_name
;
182 bfd_arch_info_type *bfd_scan_arch(CONST char *);
185 This routine is provided with a string and tries to work out
186 if bfd supports any cpu which could be described with the name
187 provided. The routine returns a pointer to an arch_info
188 structure if a machine is found, otherwise NULL.
193 DEFUN(bfd_scan_arch
,(string
),
196 struct bfd_arch_info
*ap
;
198 /* Look through all the installed architectures */
199 for (ap
= bfd_arch_info_list
;
200 ap
!= (bfd_arch_info_type
*)NULL
;
203 if (ap
->scan(ap
, string
))
206 return (bfd_arch_info_type
*)NULL
;
213 bfd_arch_get_compatible
216 CONST bfd_arch_info_type *bfd_arch_get_compatible(
221 This routine is used to determine whether two BFDs'
222 architectures and achine types are compatible. It calculates
223 the lowest common denominator between the two architectures
224 and machine types implied by the BFDs and returns a pointer to
225 an arch_info structure describing the compatible machine.
228 CONST bfd_arch_info_type
*
229 DEFUN(bfd_arch_get_compatible
,(abfd
, bbfd
),
234 return abfd
->arch_info
->compatible(abfd
->arch_info
,bbfd
->arch_info
);
240 bfd_default_arch_struct
243 The <<bfd_default_arch_struct>> is an item of
244 <<bfd_arch_info_type>> which has been initialized to a fairly
245 generic state. A BFD starts life by pointing to this
246 structure, until the correct back end has determined the real
247 architecture of the file.
249 .extern bfd_arch_info_type bfd_default_arch_struct;
253 bfd_arch_info_type bfd_default_arch_struct
=
255 32,32,8,bfd_arch_unknown
,0,"unknown","unknown",1,true,
256 bfd_default_compatible
,
266 void bfd_set_arch_info(bfd *, bfd_arch_info_type *);
270 void DEFUN(bfd_set_arch_info
,(abfd
, arg
),
272 bfd_arch_info_type
*arg
)
274 abfd
->arch_info
= arg
;
279 bfd_default_set_arch_mach
282 boolean bfd_default_set_arch_mach(bfd *abfd,
283 enum bfd_architecture arch,
287 Set the architecture and machine type in a bfd. This finds the
288 correct pointer to structure and inserts it into the arch_info
292 boolean
DEFUN(bfd_default_set_arch_mach
,(abfd
, arch
, mach
),
294 enum bfd_architecture arch AND
297 static struct bfd_arch_info
*old_ptr
= &bfd_default_arch_struct
;
298 boolean found
= false;
299 /* run through the table to find the one we want, we keep a little
300 cache to speed things up */
301 if (old_ptr
== 0 || arch
!= old_ptr
->arch
|| mach
!= old_ptr
->mach
) {
302 bfd_arch_info_type
*ptr
;
303 old_ptr
= (bfd_arch_info_type
*)NULL
;
304 for (ptr
= bfd_arch_info_list
;
305 ptr
!= (bfd_arch_info_type
*)NULL
;
307 if (ptr
->arch
== arch
&&
308 ((ptr
->mach
== mach
) || (ptr
->the_default
&& mach
== 0))) {
315 /*looked for it and it wasn't there, so put in the default */
316 old_ptr
= &bfd_default_arch_struct
;
321 /* it was in the cache */
325 abfd
->arch_info
= old_ptr
;
339 enum bfd_architecture bfd_get_arch(bfd *abfd);
342 Returns the enumerated type which describes the supplied bfd's
347 enum bfd_architecture
DEFUN(bfd_get_arch
, (abfd
), bfd
*abfd
)
349 return abfd
->arch_info
->arch
;
357 unsigned long bfd_get_mach(bfd *abfd);
360 Returns the long type which describes the supplied bfd's
365 DEFUN(bfd_get_mach
, (abfd
), bfd
*abfd
)
367 return abfd
->arch_info
->mach
;
372 bfd_arch_bits_per_byte
375 unsigned int bfd_arch_bits_per_byte(bfd *abfd);
378 Returns the number of bits in one of the architectures bytes
382 unsigned int DEFUN(bfd_arch_bits_per_byte
, (abfd
), bfd
*abfd
)
384 return abfd
->arch_info
->bits_per_byte
;
389 bfd_arch_bits_per_address
392 unsigned int bfd_arch_bits_per_address(bfd *abfd);
395 Returns the number of bits in one of the architectures addresses
398 unsigned int DEFUN(bfd_arch_bits_per_address
, (abfd
), bfd
*abfd
)
400 return abfd
->arch_info
->bits_per_address
;
405 extern void EXFUN(bfd_h8300_arch
,(void));
406 extern void EXFUN(bfd_i960_arch
,(void));
407 extern void EXFUN(bfd_empty_arch
,(void));
408 extern void EXFUN(bfd_sparc_arch
,(void));
409 extern void EXFUN(bfd_m88k_arch
,(void));
410 extern void EXFUN(bfd_m68k_arch
,(void));
411 extern void EXFUN(bfd_vax_arch
,(void));
412 extern void EXFUN(bfd_a29k_arch
,(void));
413 extern void EXFUN(bfd_mips_arch
,(void));
414 extern void EXFUN(bfd_i386_arch
,(void));
415 extern void EXFUN(bfd_rs6000_arch
,(void));
416 extern void EXFUN(bfd_hppa_arch
,(void));
420 static void EXFUN((*archures_init_table
[]),()) =
422 #ifdef SELECT_ARCHITECTURES
423 SELECT_ARCHITECTURES
,
447 void bfd_arch_init(void);
450 This routine initializes the architecture dispatch table by
451 calling all installed architecture packages and getting them
456 DEFUN_VOID(bfd_arch_init
)
458 void EXFUN((**ptable
),());
459 for (ptable
= archures_init_table
;
473 void bfd_arch_linkin(bfd_arch_info_type *);
476 Link the provided arch info structure into the list
479 void DEFUN(bfd_arch_linkin
,(ptr
),
480 bfd_arch_info_type
*ptr
)
482 ptr
->next
= bfd_arch_info_list
;
483 bfd_arch_info_list
= ptr
;
489 bfd_default_compatible
492 CONST bfd_arch_info_type *bfd_default_compatible
493 (CONST bfd_arch_info_type *a,
494 CONST bfd_arch_info_type *b);
497 The default function for testing for compatibility.
500 CONST bfd_arch_info_type
*
501 DEFUN(bfd_default_compatible
,(a
,b
),
502 CONST bfd_arch_info_type
*a AND
503 CONST bfd_arch_info_type
*b
)
505 if(a
->arch
!= b
->arch
) return NULL
;
507 if (a
->mach
> b
->mach
) {
510 if (b
->mach
> a
->mach
) {
522 boolean bfd_default_scan(CONST struct bfd_arch_info *, CONST char *);
525 The default function for working out whether this is an
526 architecture hit and a machine hit.
530 DEFUN(bfd_default_scan
,(info
, string
),
531 CONST
struct bfd_arch_info
*info AND
536 unsigned long number
;
537 enum bfd_architecture arch
;
538 /* First test for an exact match */
539 if (strcmp(string
, info
->printable_name
) == 0) return true;
541 /* See how much of the supplied string matches with the
542 architecture, eg the string m68k:68020 would match the 68k entry
543 up to the :, then we get left with the machine number */
545 for (ptr_src
= string
,
546 ptr_tst
= info
->arch_name
;
547 *ptr_src
&& *ptr_tst
;
551 if (*ptr_src
!= *ptr_tst
) break;
554 /* Chewed up as much of the architecture as will match, skip any
556 if (*ptr_src
== ':') ptr_src
++;
559 /* nothing more, then only keep this one if it is the default
560 machine for this architecture */
561 return info
->the_default
;
564 while (isdigit(*ptr_src
)) {
565 number
= number
* 10 + *ptr_src
- '0';
578 arch
= bfd_arch_m68k
;
583 arch
= bfd_arch_i386
;
586 arch
= bfd_arch_a29k
;
597 arch
= bfd_arch_ns32k
;
602 arch
= bfd_arch_i860
;
606 arch
= bfd_arch_rs6000
;
612 if (arch
!= info
->arch
)
615 if (number
!= info
->mach
)
630 bfd_arch_info_type * bfd_get_arch_info(bfd *);
635 DEFUN(bfd_get_arch_info
,(abfd
),
638 return abfd
->arch_info
;
647 bfd_arch_info_type *bfd_lookup_arch
648 (enum bfd_architecture
653 Look for the architecure info struct which matches the
654 arguments given. A machine of 0 will match the
655 machine/architecture structure which marks itself as the
660 DEFUN(bfd_lookup_arch
,(arch
, machine
),
661 enum bfd_architecture arch AND
664 bfd_arch_info_type
*ap
;
666 for (ap
= bfd_arch_info_list
;
667 ap
!= (bfd_arch_info_type
*)NULL
;
669 if (ap
->arch
== arch
&&
670 ((ap
->mach
== machine
)
671 || (ap
->the_default
&& machine
== 0))) {
675 return (bfd_arch_info_type
*)NULL
;
682 bfd_printable_arch_mach
685 CONST char * bfd_printable_arch_mach
686 (enum bfd_architecture arch, unsigned long machine);
689 Return a printable string representing the architecture and
692 NB. The use of this routine is depreciated.
696 DEFUN(bfd_printable_arch_mach
,(arch
, machine
),
697 enum bfd_architecture arch AND
698 unsigned long machine
)
700 bfd_arch_info_type
*ap
= bfd_lookup_arch(arch
, machine
);
701 if(ap
) return ap
->printable_name
;