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