projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
bfd:
[deliverable/binutils-gdb.git] / bfd / archures.c
CommitLineData
252b5132 1/* BFD library support routines for architectures.
d4845d57
JR		 2 Copyright (C) 1990, 91, 92, 93, 94, 95, 96, 97, 98, 1999, 2000
3 Free Software Foundation, Inc.
252b5132
RH		 4 Hacked by John Gilmore and Steve Chamberlain of Cygnus Support.
5
6This file is part of BFD, the Binary File Descriptor library.
7
8This program is free software; you can redistribute it and/or modify
9it under the terms of the GNU General Public License as published by
10the Free Software Foundation; either version 2 of the License, or
11(at your option) any later version.
12
13This program is distributed in the hope that it will be useful,
14but WITHOUT ANY WARRANTY; without even the implied warranty of
15MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16GNU General Public License for more details.
17
18You should have received a copy of the GNU General Public License
19along with this program; if not, write to the Free Software
20Foundation, 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
29SECTION
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
57SUBSECTION
58 bfd_architecture
59
60DESCRIPTION
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.{* Nonzero if MACH has the v9 instruction set. *}
113.#define bfd_mach_sparc_v9_p(mach) \
114. ((mach) >= bfd_mach_sparc_v8plus && (mach) <= bfd_mach_sparc_v9a)
115. bfd_arch_mips, {* MIPS Rxxxx *}
116.#define bfd_mach_mips3000 3000
117.#define bfd_mach_mips3900 3900
118.#define bfd_mach_mips4000 4000
119.#define bfd_mach_mips4010 4010
120.#define bfd_mach_mips4100 4100
121.#define bfd_mach_mips4111 4111
122.#define bfd_mach_mips4300 4300
123.#define bfd_mach_mips4400 4400
124.#define bfd_mach_mips4600 4600
125.#define bfd_mach_mips4650 4650
126.#define bfd_mach_mips5000 5000
127.#define bfd_mach_mips6000 6000
128.#define bfd_mach_mips8000 8000
129.#define bfd_mach_mips10000 10000
130.#define bfd_mach_mips16 16
131. bfd_arch_i386, {* Intel 386 *}
132.#define bfd_mach_i386_i386 0
133.#define bfd_mach_i386_i8086 1
134.#define bfd_mach_i386_i386_intel_syntax 2
135. bfd_arch_we32k, {* AT&T WE32xxx *}
136. bfd_arch_tahoe, {* CCI/Harris Tahoe *}
137. bfd_arch_i860, {* Intel 860 *}
138. bfd_arch_romp, {* IBM ROMP PC/RT *}
139. bfd_arch_alliant, {* Alliant *}
140. bfd_arch_convex, {* Convex *}
141. bfd_arch_m88k, {* Motorola 88xxx *}
142. bfd_arch_pyramid, {* Pyramid Technology *}
143. bfd_arch_h8300, {* Hitachi H8/300 *}
144.#define bfd_mach_h8300 1
145.#define bfd_mach_h8300h 2
146.#define bfd_mach_h8300s 3
147. bfd_arch_powerpc, {* PowerPC *}
148. bfd_arch_rs6000, {* IBM RS/6000 *}
149. bfd_arch_hppa, {* HP PA RISC *}
150. bfd_arch_d10v, {* Mitsubishi D10V *}
7af8cca9
MM		 151.#define bfd_mach_d10v 0
152.#define bfd_mach_d10v_ts2 2
153.#define bfd_mach_d10v_ts3 3
252b5132
RH		 154. bfd_arch_d30v, {* Mitsubishi D30V *}
155. bfd_arch_z8k, {* Zilog Z8000 *}
156.#define bfd_mach_z8001 1
157.#define bfd_mach_z8002 2
158. bfd_arch_h8500, {* Hitachi H8/500 *}
159. bfd_arch_sh, {* Hitachi SH *}
160.#define bfd_mach_sh 0
d4845d57
JR		 161.#define bfd_mach_sh2 0x20
162.#define bfd_mach_sh_dsp 0x2d
252b5132 163.#define bfd_mach_sh3 0x30
d4845d57 164.#define bfd_mach_sh3_dsp 0x3d
252b5132 165.#define bfd_mach_sh3e 0x3e
d4845d57 166.#define bfd_mach_sh4 0x40
252b5132
RH		 167. bfd_arch_alpha, {* Dec Alpha *}
168.#define bfd_mach_alpha_ev4 0x10
169.#define bfd_mach_alpha_ev5 0x20
170.#define bfd_mach_alpha_ev6 0x30
171. bfd_arch_arm, {* Advanced Risc Machines ARM *}
172.#define bfd_mach_arm_2 1
478d07d6 173.#define bfd_mach_arm_2a 2
252b5132
RH		 174.#define bfd_mach_arm_3 3
175.#define bfd_mach_arm_3M 4
478d07d6 176.#define bfd_mach_arm_4 5
252b5132 177.#define bfd_mach_arm_4T 6
478d07d6
NC		 178.#define bfd_mach_arm_5 7
179.#define bfd_mach_arm_5T 8
252b5132
RH		 180. bfd_arch_ns32k, {* National Semiconductors ns32000 *}
181. bfd_arch_w65, {* WDC 65816 *}
182. bfd_arch_tic30, {* Texas Instruments TMS320C30 *}
183. bfd_arch_tic80, {* TI TMS320c80 (MVP) *}
184. bfd_arch_v850, {* NEC V850 *}
185.#define bfd_mach_v850 0
186.#define bfd_mach_v850e 'E'
187.#define bfd_mach_v850ea 'A'
188. bfd_arch_arc, {* Argonaut RISC Core *}
189.#define bfd_mach_arc_base 0
190. bfd_arch_m32r, {* Mitsubishi M32R/D *}
191.#define bfd_mach_m32r 0 {* backwards compatibility *}
a23ef39f 192.#define bfd_mach_m32rx 'x'
252b5132
RH		 193. bfd_arch_mn10200, {* Matsushita MN10200 *}
194. bfd_arch_mn10300, {* Matsushita MN10300 *}
195.#define bfd_mach_mn10300 300
31f8dc8f 196.#define bfd_mach_am33 330
252b5132
RH		 197. bfd_arch_fr30,
198.#define bfd_mach_fr30 0x46523330
199. bfd_arch_mcore,
0bcb993b 200. bfd_arch_pj,
252b5132
RH		 201. bfd_arch_last
202. };
203
204
205*/
206
207/*
208
209SUBSECTION
210 bfd_arch_info
211
212DESCRIPTION
213 This structure contains information on architectures for use
214 within BFD.
215
216.
217.typedef struct bfd_arch_info
218.{
219. int bits_per_word;
220. int bits_per_address;
221. int bits_per_byte;
222. enum bfd_architecture arch;
223. unsigned long mach;
224. const char *arch_name;
225. const char *printable_name;
226. unsigned int section_align_power;
227. {* true if this is the default machine for the architecture *}
228. boolean the_default;
229. const struct bfd_arch_info * (*compatible)
230. PARAMS ((const struct bfd_arch_info *a,
231. const struct bfd_arch_info *b));
232.
233. boolean (*scan) PARAMS ((const struct bfd_arch_info *, const char *));
234.
235. const struct bfd_arch_info *next;
236.} bfd_arch_info_type;
237*/
238
239extern const bfd_arch_info_type bfd_a29k_arch;
240extern const bfd_arch_info_type bfd_alpha_arch;
241extern const bfd_arch_info_type bfd_arc_arch;
242extern const bfd_arch_info_type bfd_arm_arch;
243extern const bfd_arch_info_type bfd_d10v_arch;
244extern const bfd_arch_info_type bfd_d30v_arch;
245extern const bfd_arch_info_type bfd_h8300_arch;
246extern const bfd_arch_info_type bfd_h8500_arch;
247extern const bfd_arch_info_type bfd_hppa_arch;
248extern const bfd_arch_info_type bfd_i386_arch;
249extern const bfd_arch_info_type bfd_i860_arch;
250extern const bfd_arch_info_type bfd_i960_arch;
251extern const bfd_arch_info_type bfd_m32r_arch;
252extern const bfd_arch_info_type bfd_m68k_arch;
253extern const bfd_arch_info_type bfd_m88k_arch;
254extern const bfd_arch_info_type bfd_mips_arch;
255extern const bfd_arch_info_type bfd_mn10200_arch;
256extern const bfd_arch_info_type bfd_mn10300_arch;
257extern const bfd_arch_info_type bfd_powerpc_arch;
258extern const bfd_arch_info_type bfd_rs6000_arch;
0bcb993b 259extern const bfd_arch_info_type bfd_pj_arch;
252b5132
RH		 260extern const bfd_arch_info_type bfd_sh_arch;
261extern const bfd_arch_info_type bfd_sparc_arch;
262extern const bfd_arch_info_type bfd_tic30_arch;
263extern const bfd_arch_info_type bfd_tic80_arch;
264extern const bfd_arch_info_type bfd_vax_arch;
265extern const bfd_arch_info_type bfd_we32k_arch;
266extern const bfd_arch_info_type bfd_z8k_arch;
267extern const bfd_arch_info_type bfd_ns32k_arch;
268extern const bfd_arch_info_type bfd_w65_arch;
269extern const bfd_arch_info_type bfd_v850_arch;
270extern const bfd_arch_info_type bfd_fr30_arch;
271extern const bfd_arch_info_type bfd_mcore_arch;
272
273static const bfd_arch_info_type * const bfd_archures_list[] =
274{
275#ifdef SELECT_ARCHITECTURES
276 SELECT_ARCHITECTURES,
277#else
278 &bfd_a29k_arch,
279 &bfd_alpha_arch,
280 &bfd_arc_arch,
281 &bfd_arm_arch,
282 &bfd_d10v_arch,
283 &bfd_d30v_arch,
284 &bfd_h8300_arch,
285 &bfd_h8500_arch,
286 &bfd_hppa_arch,
287 &bfd_i386_arch,
288 &bfd_i860_arch,
289 &bfd_i960_arch,
290 &bfd_m32r_arch,
291 &bfd_m68k_arch,
292 &bfd_m88k_arch,
293 &bfd_mips_arch,
294 &bfd_mn10200_arch,
295 &bfd_mn10300_arch,
296 &bfd_powerpc_arch,
297 &bfd_rs6000_arch,
298 &bfd_sh_arch,
299 &bfd_sparc_arch,
300 &bfd_tic30_arch,
301 &bfd_tic80_arch,
302 &bfd_vax_arch,
303 &bfd_we32k_arch,
304 &bfd_z8k_arch,
305 &bfd_ns32k_arch,
306 &bfd_w65_arch,
307 &bfd_v850_arch,
308 &bfd_fr30_arch,
309 & bfd_mcore_arch,
310#endif
311 0
312};
313
314/*
315FUNCTION
316 bfd_printable_name
317
318SYNOPSIS
319 const char *bfd_printable_name(bfd *abfd);
320
321DESCRIPTION
322 Return a printable string representing the architecture and machine
323 from the pointer to the architecture info structure.
324
325*/
326
327const char *
328bfd_printable_name (abfd)
329 bfd *abfd;
330{
331 return abfd->arch_info->printable_name;
332}
333
334
335
336/*
337FUNCTION
338 bfd_scan_arch
339
340SYNOPSIS
341 const bfd_arch_info_type *bfd_scan_arch(const char *string);
342
343DESCRIPTION
344 Figure out if BFD supports any cpu which could be described with
345 the name @var{string}. Return a pointer to an <<arch_info>>
346 structure if a machine is found, otherwise NULL.
347
348*/
349
350const bfd_arch_info_type *
351bfd_scan_arch (string)
352 const char *string;
353{
354 const bfd_arch_info_type * const *app, *ap;
355
356 /* Look through all the installed architectures */
357 for (app = bfd_archures_list; *app != NULL; app++)
358 {
359 for (ap = *app; ap != NULL; ap = ap->next)
360 {
361 if (ap->scan (ap, string))
362 return ap;
363 }
364 }
365
366 return NULL;
367}
368
369
370
371/*
372FUNCTION
373 bfd_arch_list
374
375SYNOPSIS
376 const char **bfd_arch_list(void);
377
378DESCRIPTION
379 Return a freshly malloced NULL-terminated vector of the names
380 of all the valid BFD architectures. Do not modify the names.
381
382*/
383
384const char **
385bfd_arch_list ()
386{
387 int vec_length = 0;
388 const char **name_ptr;
389 const char **name_list;
390 const bfd_arch_info_type * const *app;
391
392 /* Determine the number of architectures */
393 vec_length = 0;
394 for (app = bfd_archures_list; *app != NULL; app++)
395 {
396 const bfd_arch_info_type *ap;
397 for (ap = *app; ap != NULL; ap = ap->next)
398 {
399 vec_length++;
400 }
401 }
402
403 name_list = (CONST char **)
404 bfd_malloc ((vec_length + 1) * sizeof (char **));
405 if (name_list == NULL)
406 return NULL;
407
408 /* Point the list at each of the names */
409 name_ptr = name_list;
410 for (app = bfd_archures_list; *app != NULL; app++)
411 {
412 const bfd_arch_info_type *ap;
413 for (ap = *app; ap != NULL; ap = ap->next)
414 {
415 *name_ptr = ap->printable_name;
416 name_ptr++;
417 }
418 }
419 *name_ptr = NULL;
420
421 return name_list;
422}
423
424
425
426/*
427FUNCTION
428 bfd_arch_get_compatible
429
430SYNOPSIS
431 const bfd_arch_info_type *bfd_arch_get_compatible(
432 const bfd *abfd,
433 const bfd *bbfd);
434
435DESCRIPTION
436 Determine whether two BFDs'
437 architectures and machine types are compatible. Calculates
438 the lowest common denominator between the two architectures
439 and machine types implied by the BFDs and returns a pointer to
440 an <<arch_info>> structure describing the compatible machine.
441*/
442
443const bfd_arch_info_type *
444bfd_arch_get_compatible (abfd, bbfd)
445 const bfd *abfd;
446 const bfd *bbfd;
447{
448 /* If either architecture is unknown, then all we can do is assume
449 the user knows what he's doing. */
450 if (abfd->arch_info->arch == bfd_arch_unknown)
451 return bbfd->arch_info;
452 if (bbfd->arch_info->arch == bfd_arch_unknown)
453 return abfd->arch_info;
454
455 /* Otherwise architecture-specific code has to decide. */
456 return abfd->arch_info->compatible (abfd->arch_info, bbfd->arch_info);
457}
458
459
460/*
461INTERNAL_DEFINITION
462 bfd_default_arch_struct
463
464DESCRIPTION
465 The <<bfd_default_arch_struct>> is an item of
466 <<bfd_arch_info_type>> which has been initialized to a fairly
467 generic state. A BFD starts life by pointing to this
468 structure, until the correct back end has determined the real
469 architecture of the file.
470
471.extern const bfd_arch_info_type bfd_default_arch_struct;
472
473*/
474
475const bfd_arch_info_type bfd_default_arch_struct =
476{
477 32,32,8,bfd_arch_unknown,0,"unknown","unknown",2,true,
478 bfd_default_compatible,
479 bfd_default_scan,
480 0,
481};
482
483/*
484FUNCTION
485 bfd_set_arch_info
486
487SYNOPSIS
488 void bfd_set_arch_info(bfd *abfd, const bfd_arch_info_type *arg);
489
490DESCRIPTION
491 Set the architecture info of @var{abfd} to @var{arg}.
492*/
493
494void
495bfd_set_arch_info (abfd, arg)
496 bfd *abfd;
497 const bfd_arch_info_type *arg;
498{
499 abfd->arch_info = arg;
500}
501
502/*
503INTERNAL_FUNCTION
504 bfd_default_set_arch_mach
505
506SYNOPSIS
507 boolean bfd_default_set_arch_mach(bfd *abfd,
508 enum bfd_architecture arch,
509 unsigned long mach);
510
511DESCRIPTION
512 Set the architecture and machine type in BFD @var{abfd}
513 to @var{arch} and @var{mach}. Find the correct
514 pointer to a structure and insert it into the <<arch_info>>
515 pointer.
516*/
517
518boolean
519bfd_default_set_arch_mach (abfd, arch, mach)
520 bfd *abfd;
521 enum bfd_architecture arch;
522 unsigned long mach;
523{
524 const bfd_arch_info_type * const *app, *ap;
525
526 for (app = bfd_archures_list; *app != NULL; app++)
527 {
528 for (ap = *app; ap != NULL; ap = ap->next)
529 {
530 if (ap->arch == arch
531 && (ap->mach == mach
532 || (mach == 0 && ap->the_default)))
533 {
534 abfd->arch_info = ap;
535 return true;
536 }
537 }
538 }
539
540 abfd->arch_info = &bfd_default_arch_struct;
541 bfd_set_error (bfd_error_bad_value);
542 return false;
543}
544
545
546/*
547FUNCTION
548 bfd_get_arch
549
550SYNOPSIS
551 enum bfd_architecture bfd_get_arch(bfd *abfd);
552
553DESCRIPTION
554 Return the enumerated type which describes the BFD @var{abfd}'s
555 architecture.
556
557*/
558
559enum bfd_architecture
560bfd_get_arch (abfd)
561 bfd *abfd;
562{
563 return abfd->arch_info->arch;
564}
565
566/*
567FUNCTION
568 bfd_get_mach
569
570SYNOPSIS
571 unsigned long bfd_get_mach(bfd *abfd);
572
573DESCRIPTION
574 Return the long type which describes the BFD @var{abfd}'s
575 machine.
576*/
577
578unsigned long
579bfd_get_mach (abfd)
580 bfd *abfd;
581{
582 return abfd->arch_info->mach;
583}
584
585/*
586FUNCTION
587 bfd_arch_bits_per_byte
588
589SYNOPSIS
590 unsigned int bfd_arch_bits_per_byte(bfd *abfd);
591
592DESCRIPTION
593 Return the number of bits in one of the BFD @var{abfd}'s
594 architecture's bytes.
595
596*/
597
598unsigned int
599bfd_arch_bits_per_byte (abfd)
600 bfd *abfd;
601{
602 return abfd->arch_info->bits_per_byte;
603}
604
605/*
606FUNCTION
607 bfd_arch_bits_per_address
608
609SYNOPSIS
610 unsigned int bfd_arch_bits_per_address(bfd *abfd);
611
612DESCRIPTION
613 Return the number of bits in one of the BFD @var{abfd}'s
614 architecture's addresses.
615*/
616
617unsigned int
618bfd_arch_bits_per_address (abfd)
619 bfd *abfd;
620{
621 return abfd->arch_info->bits_per_address;
622}
623
624
625/*
626INTERNAL_FUNCTION
627 bfd_default_compatible
628
629SYNOPSIS
630 const bfd_arch_info_type *bfd_default_compatible
631 (const bfd_arch_info_type *a,
632 const bfd_arch_info_type *b);
633
634DESCRIPTION
635 The default function for testing for compatibility.
636*/
637
638const bfd_arch_info_type *
639bfd_default_compatible (a,b)
640 const bfd_arch_info_type *a;
641 const bfd_arch_info_type *b;
642{
643 if (a->arch != b->arch)
644 return NULL;
645
646 if (a->mach > b->mach)
647 return a;
648
649 if (b->mach > a->mach)
650 return b;
651
652 return a;
653}
654
655
656/*
657INTERNAL_FUNCTION
658 bfd_default_scan
659
660SYNOPSIS
661 boolean bfd_default_scan(const struct bfd_arch_info *info, const char *string);
662
663DESCRIPTION
664 The default function for working out whether this is an
665 architecture hit and a machine hit.
666*/
667
668boolean
669bfd_default_scan (info, string)
670 const struct bfd_arch_info *info;
671 const char *string;
672{
673 const char *ptr_src;
674 const char *ptr_tst;
675 unsigned long number;
676 enum bfd_architecture arch;
677 const char *printable_name_colon;
678
679 /* Exact match of the architecture name (ARCH_NAME) and also the
680 default architecture? */
681 if (strcasecmp (string, info->arch_name) == 0
682 && info->the_default)
683 return true;
684
685 /* Exact match of the machine name (PRINTABLE_NAME)? */
686 if (strcasecmp (string, info->printable_name) == 0)
687 return true;
688
689 /* Given that printable_name contains no colon, attempt to match:
690 ARCH_NAME [ ":" ] PRINTABLE_NAME? */
691 printable_name_colon = strchr (info->printable_name, ':');
692 if (printable_name_colon == NULL)
693 {
694 int strlen_arch_name = strlen (info->arch_name);
695 if (strncasecmp (string, info->arch_name, strlen_arch_name) == 0)
696 {
697 if (string[strlen_arch_name] == ':')
698 {
699 if (strcasecmp (string + strlen_arch_name + 1,
700 info->printable_name) == 0)
701 return true;
702 }
703 else
704 {
705 if (strcasecmp (string + strlen_arch_name,
706 info->printable_name) == 0)
707 return true;
708 }
709 }
710 }
711
712 /* Given that PRINTABLE_NAME has the form: <arch> ":" <mach>;
713 Attempt to match: <arch> <mach>? */
714 if (printable_name_colon != NULL)
715 {
716 int colon_index = printable_name_colon - info->printable_name;
717 if (strncasecmp (string, info->printable_name, colon_index) == 0
718 && strcasecmp (string + colon_index,
719 info->printable_name + colon_index + 1) == 0)
720 return true;
721 }
722
723 /* Given that PRINTABLE_NAME has the form: <arch> ":" <mach>; Do not
724 attempt to match just <mach>, it could be ambigious. This test
725 is left until later. */
726
727 /* NOTE: The below is retained for compatibility only. Please do not
728 add to this code */
729
730 /* See how much of the supplied string matches with the
731 architecture, eg the string m68k:68020 would match the 68k entry
732 up to the :, then we get left with the machine number */
733
734 for (ptr_src = string, ptr_tst = info->arch_name;
735 *ptr_src && *ptr_tst;
736 ptr_src++, ptr_tst++)
737 {
738 if (*ptr_src != *ptr_tst) break;
739 }
740
741 /* Chewed up as much of the architecture as will match, skip any
742 colons */
743 if (*ptr_src == ':')
744 ptr_src++;
745
746 if (*ptr_src == 0)
747 {
748 /* nothing more, then only keep this one if it is the default
749 machine for this architecture */
750 return info->the_default;
751 }
752
753 number = 0;
754 while (isdigit ((unsigned char) *ptr_src))
755 {
756 number = number * 10 + *ptr_src - '0';
757 ptr_src++;
758 }
759
760 /* NOTE: The below is retained for compatibility only.
761 PLEASE DO NOT ADD TO THIS CODE. */
762
763 switch (number)
764 {
765 /* FIXME: These are needed to parse IEEE objects. */
766 case 68000:
767 arch = bfd_arch_m68k;
768 number = bfd_mach_m68000;
769 break;
770 case 68010:
771 arch = bfd_arch_m68k;
772 number = bfd_mach_m68010;
773 break;
774 case 68020:
775 arch = bfd_arch_m68k;
776 number = bfd_mach_m68020;
777 break;
778 case 68030:
779 arch = bfd_arch_m68k;
780 number = bfd_mach_m68030;
781 break;
782 case 68040:
783 arch = bfd_arch_m68k;
784 number = bfd_mach_m68040;
785 break;
786 case 68060:
787 arch = bfd_arch_m68k;
788 number = bfd_mach_m68060;
789 break;
790 case 68332:
791 arch = bfd_arch_m68k;
792 number = bfd_mach_cpu32;
793 break;
794
795 case 32000:
796 arch = bfd_arch_we32k;
797 break;
798
799 case 3000:
800 arch = bfd_arch_mips;
801 number = bfd_mach_mips3000;
802 break;
803
804 case 4000:
805 arch = bfd_arch_mips;
806 number = bfd_mach_mips4000;
807 break;
808
809 case 6000:
810 arch = bfd_arch_rs6000;
811 break;
812
d4845d57
JR		 813 case 7410:
814 arch = bfd_arch_sh;
815 number = bfd_mach_sh_dsp;
816 break;
817
818 case 7708:
819 arch = bfd_arch_sh;
820 number = bfd_mach_sh3;
821 break;
822
823 case 7729:
824 arch = bfd_arch_sh;
825 number = bfd_mach_sh3_dsp;
826 break;
827
828 case 7750:
829 arch = bfd_arch_sh;
830 number = bfd_mach_sh4;
831 break;
832
252b5132
RH		 833 default:
834 return false;
835 }
836
837 if (arch != info->arch)
838 return false;
839
840 if (number != info->mach)
841 return false;
842
843 return true;
844}
845
846
847/*
848FUNCTION
849 bfd_get_arch_info
850
851SYNOPSIS
852 const bfd_arch_info_type * bfd_get_arch_info(bfd *abfd);
853
854DESCRIPTION
855 Return the architecture info struct in @var{abfd}.
856*/
857
858const bfd_arch_info_type *
859bfd_get_arch_info (abfd)
860 bfd *abfd;
861{
862 return abfd->arch_info;
863}
864
865
866/*
867FUNCTION
868 bfd_lookup_arch
869
870SYNOPSIS
871 const bfd_arch_info_type *bfd_lookup_arch
872 (enum bfd_architecture
873 arch,
874 unsigned long machine);
875
876DESCRIPTION
877 Look for the architecure info structure which matches the
878 arguments @var{arch} and @var{machine}. A machine of 0 matches the
879 machine/architecture structure which marks itself as the
880 default.
881*/
882
883const bfd_arch_info_type *
884bfd_lookup_arch (arch, machine)
885 enum bfd_architecture arch;
886 unsigned long machine;
887{
888 const bfd_arch_info_type * const *app, *ap;
889
890 for (app = bfd_archures_list; *app != NULL; app++)
891 {
892 for (ap = *app; ap != NULL; ap = ap->next)
893 {
894 if (ap->arch == arch
895 && (ap->mach == machine
896 || (machine == 0 && ap->the_default)))
897 return ap;
898 }
899 }
900
901 return NULL;
902}
903
904
905/*
906FUNCTION
907 bfd_printable_arch_mach
908
909SYNOPSIS
910 const char *bfd_printable_arch_mach
911 (enum bfd_architecture arch, unsigned long machine);
912
913DESCRIPTION
914 Return a printable string representing the architecture and
915 machine type.
916
917 This routine is depreciated.
918*/
919
920const char *
921bfd_printable_arch_mach (arch, machine)
922 enum bfd_architecture arch;
923 unsigned long machine;
924{
9a968f43 925 const bfd_arch_info_type * ap = bfd_lookup_arch (arch, machine);
252b5132
RH		 926
927 if (ap)
928 return ap->printable_name;
929 return "UNKNOWN!";
930}
9a968f43
NC		 931
932/*
933FUNCTION
934 bfd_octets_per_byte
935
936SYNOPSIS
937 int bfd_octets_per_byte(bfd *abfd);
938
939DESCRIPTION
940 Return the number of octets (8-bit quantities) per target byte
941 (minimum addressable unit). In most cases, this will be one, but some
942 DSP targets have 16, 32, or even 48 bits per byte.
943
944*/
945
946int
947bfd_octets_per_byte (abfd)
948 bfd * abfd;
949{
950 return bfd_arch_mach_octets_per_byte (bfd_get_arch (abfd),
951 bfd_get_mach (abfd));
952}
953
954/*
955FUNCTION
956 bfd_arch_mach_octets_per_byte
957
958SYNOPSIS
959 int bfd_arch_mach_octets_per_byte(enum bfd_architecture arch,
960 unsigned long machine);
961
962DESCRIPTION
963 See bfd_octets_per_byte.
964
965 This routine is provided for those cases where a bfd * is not
966 available
967*/
968
969int
970bfd_arch_mach_octets_per_byte (arch, mach)
971 enum bfd_architecture arch;
972 unsigned long mach;
973{
974 const bfd_arch_info_type * ap = bfd_lookup_arch (arch, mach);
975
976 if (ap)
977 return ap->bits_per_byte / 8;
978 return 1;
979}
980
GDB Binutils - Deliverables
This page took 0.074703 seconds and 4 git commands to generate.