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