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