![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to arch.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / cctools / libstuff|
Return to arch.c CVS log | Up to [Apple XNU] / GNUtools / cctools / libstuff |
1.1 root 1: #include "string.h"
2: #include <mach/mach.h>
3: #include "stuff/arch.h"
4:
5: /*
6: * The array of all currently know architecture flags (terminated with an entry
7: * with all zeros). Pointer to this returned with get_arch_flags().
8: */
9: static const struct arch_flag arch_flags[] = {
10: { "any", CPU_TYPE_ANY, CPU_SUBTYPE_MULTIPLE },
11: { "little", CPU_TYPE_ANY, CPU_SUBTYPE_LITTLE_ENDIAN },
12: { "big", CPU_TYPE_ANY, CPU_SUBTYPE_BIG_ENDIAN },
13: /* architecture families */
14: { "m68k", CPU_TYPE_MC680x0, CPU_SUBTYPE_MC680x0_ALL },
15: { "m98k", CPU_TYPE_MC98000, CPU_SUBTYPE_MC98000_ALL },
16: { "m88k", CPU_TYPE_MC88000, CPU_SUBTYPE_MC88000_ALL },
17: { "i386", CPU_TYPE_I386, CPU_SUBTYPE_I386_ALL },
18: { "i860", CPU_TYPE_I860, CPU_SUBTYPE_I860_ALL },
19: { "hppa", CPU_TYPE_HPPA, CPU_SUBTYPE_HPPA_ALL },
20: { "sparc", CPU_TYPE_SPARC, CPU_SUBTYPE_SPARC_ALL },
21: /* specific architecture implementations */
22: { "m68030", CPU_TYPE_MC680x0, CPU_SUBTYPE_MC68030_ONLY },
23: { "m68040", CPU_TYPE_MC680x0, CPU_SUBTYPE_MC68040 },
24: { "i486", CPU_TYPE_I386, CPU_SUBTYPE_486 },
25: { "i486SX", CPU_TYPE_I386, CPU_SUBTYPE_486SX },
26: { "i586", CPU_TYPE_I386, CPU_SUBTYPE_586 },
27: { "i586SX", CPU_TYPE_I386, CPU_SUBTYPE_586SX },
28: { "hppa7100LC", CPU_TYPE_HPPA, CPU_SUBTYPE_HPPA_7100LC },
29: { NULL, 0, 0 }
30: };
31:
32: /*
33: * get_arch_from_flag() is passed a name of an architecture flag and returns
34: * zero if that flag is not known and non-zero if the flag is known.
35: * If the pointer to the arch_flag is not NULL it is filled in with the
36: * arch_flag struct that matches the name.
37: */
38: int
39: get_arch_from_flag(
40: char *name,
41: struct arch_flag *arch_flag)
42: {
43: unsigned long i;
44:
45: for(i = 0; arch_flags[i].name != NULL; i++){
46: if(strcmp(arch_flags[i].name, name) == 0){
47: if(arch_flag != NULL)
48: *arch_flag = arch_flags[i];
49: return(1);
50: }
51: }
52: if(arch_flag != NULL)
53: memset(arch_flag, '\0', sizeof(struct arch_flag));
54: return(0);
55: }
56:
57: /*
58: * get_arch_from_host() gets the architecture from the host this is running on
59: * and returns zero if the architecture is not known and zero if the
60: * architecture is known. If the parameters family_arch_flag and
61: * specific_arch_flag are not NULL they get fill in with the family
62: * architecture and specific architecure for the host. If the architecture
63: * is unknown and the parameters are not NULL then all fields are set to zero.
64: */
65: int
66: get_arch_from_host(
67: struct arch_flag *family_arch_flag,
68: struct arch_flag *specific_arch_flag)
69: {
70: struct host_basic_info host_basic_info;
71: unsigned int count;
72: kern_return_t r;
73:
74: if(family_arch_flag != NULL)
75: memset(family_arch_flag, '\0', sizeof(struct arch_flag));
76: if(specific_arch_flag != NULL)
77: memset(specific_arch_flag, '\0', sizeof(struct arch_flag));
78:
79: count = HOST_BASIC_INFO_COUNT;
80: if((r = host_info(host_self(), HOST_BASIC_INFO,
81: (host_info_t)(&host_basic_info),
82: &count)) != KERN_SUCCESS)
83: return(0);
84:
85: if(family_arch_flag != NULL){
86: family_arch_flag->cputype = host_basic_info.cpu_type;
87: }
88: if(specific_arch_flag != NULL){
89: specific_arch_flag->cputype = host_basic_info.cpu_type;
90: specific_arch_flag->cpusubtype = host_basic_info.cpu_subtype;
91: }
92: switch(host_basic_info.cpu_type){
93: case CPU_TYPE_MC680x0:
94: switch(host_basic_info.cpu_subtype){
95: case CPU_SUBTYPE_MC680x0_ALL:
96: case CPU_SUBTYPE_MC68030_ONLY:
97: if(family_arch_flag != NULL){
98: family_arch_flag->name = "m68k";
99: family_arch_flag->cpusubtype = CPU_SUBTYPE_MC680x0_ALL;
100: }
101: if(specific_arch_flag != NULL){
102: specific_arch_flag->name = "m68030";
103: /*
104: * There is a "bug" in the kernel for compatiblity that on
105: * an 030 machine host_info() returns cpusubtype
106: * CPU_SUBTYPE_MC680x0_ALL and not CPU_SUBTYPE_MC68030_ONLY.
107: */
108: specific_arch_flag->cpusubtype = CPU_SUBTYPE_MC68030_ONLY;
109: }
110: return(1);
111: case CPU_SUBTYPE_MC68040:
112: if(family_arch_flag != NULL){
113: family_arch_flag->name = "m68k";
114: family_arch_flag->cpusubtype = CPU_SUBTYPE_MC680x0_ALL;
115: }
116: if(specific_arch_flag != NULL)
117: specific_arch_flag->name = "m68040";
118: return(1);
119: }
120: break;
121: case CPU_TYPE_MC98000:
122: switch(host_basic_info.cpu_subtype){
123: case CPU_SUBTYPE_MC98000_ALL:
124: if(family_arch_flag != NULL){
125: family_arch_flag->name = "m98k";
126: family_arch_flag->cpusubtype = CPU_SUBTYPE_MC98000_ALL;
127: }
128: if(specific_arch_flag != NULL)
129: specific_arch_flag->name = "m98k";
130: return(1);
131: }
132: break;
133: case CPU_TYPE_MC88000:
134: switch(host_basic_info.cpu_subtype){
135: case CPU_SUBTYPE_MC88000_ALL:
136: case CPU_SUBTYPE_MC88110:
137: if(family_arch_flag != NULL){
138: family_arch_flag->name = "m88k";
139: family_arch_flag->cpusubtype = CPU_SUBTYPE_MC88000_ALL;
140: }
141: if(specific_arch_flag != NULL)
142: specific_arch_flag->name = "m88k";
143: return(1);
144: }
145: break;
146: case CPU_TYPE_I386:
147: switch(host_basic_info.cpu_subtype){
148: case CPU_SUBTYPE_I386_ALL:
149: /* case CPU_SUBTYPE_386: same value as above */
150: if(family_arch_flag != NULL){
151: family_arch_flag->name = "i386";
152: family_arch_flag->cpusubtype = CPU_SUBTYPE_I386_ALL;
153: }
154: if(specific_arch_flag != NULL)
155: specific_arch_flag->name = "i386";
156: return(1);
157: case CPU_SUBTYPE_486:
158: if(family_arch_flag != NULL){
159: family_arch_flag->name = "i386";
160: family_arch_flag->cpusubtype = CPU_SUBTYPE_I386_ALL;
161: }
162: if(specific_arch_flag != NULL)
163: specific_arch_flag->name = "i486";
164: return(1);
165: case CPU_SUBTYPE_486SX:
166: if(family_arch_flag != NULL){
167: family_arch_flag->name = "i386";
168: family_arch_flag->cpusubtype = CPU_SUBTYPE_I386_ALL;
169: }
170: if(specific_arch_flag != NULL)
171: specific_arch_flag->name = "i486SX";
172: return(1);
173: case CPU_SUBTYPE_586:
174: if(family_arch_flag != NULL){
175: family_arch_flag->name = "i386";
176: family_arch_flag->cpusubtype = CPU_SUBTYPE_I386_ALL;
177: }
178: if(specific_arch_flag != NULL)
179: specific_arch_flag->name = "i586";
180: return(1);
181: case CPU_SUBTYPE_586SX:
182: if(family_arch_flag != NULL){
183: family_arch_flag->name = "i386";
184: family_arch_flag->cpusubtype = CPU_SUBTYPE_I386_ALL;
185: }
186: if(specific_arch_flag != NULL)
187: specific_arch_flag->name = "i586SX";
188: return(1);
189: }
190: break;
191: case CPU_TYPE_I860:
192: switch(host_basic_info.cpu_subtype){
193: case CPU_SUBTYPE_I860_ALL:
194: case CPU_SUBTYPE_I860_860:
195: if(family_arch_flag != NULL){
196: family_arch_flag->name = "i860";
197: family_arch_flag->cpusubtype = CPU_SUBTYPE_I860_ALL;
198: }
199: if(specific_arch_flag != NULL)
200: specific_arch_flag->name = "i860";
201: return(1);
202: }
203: break;
204: case CPU_TYPE_HPPA:
205: switch(host_basic_info.cpu_subtype){
206: case CPU_SUBTYPE_HPPA_ALL:
207: if(family_arch_flag != NULL){
208: family_arch_flag->name = "hppa";
209: family_arch_flag->cpusubtype = CPU_SUBTYPE_HPPA_ALL;
210: }
211: if(specific_arch_flag != NULL)
212: specific_arch_flag->name = "hppa";
213: return(1);
214: case CPU_SUBTYPE_HPPA_7100LC:
215: if(family_arch_flag != NULL){
216: family_arch_flag->name = "hppa";
217: family_arch_flag->cpusubtype = CPU_SUBTYPE_HPPA_ALL;
218: }
219: if(specific_arch_flag != NULL)
220: specific_arch_flag->name = "hppa7100LC";
221: return(1);
222:
223: }
224: break;
225: case CPU_TYPE_SPARC:
226: switch(host_basic_info.cpu_subtype){
227: case /*CPU_SUBTYPE_SPARC_ALL*/0:
228: if(family_arch_flag != NULL){
229: family_arch_flag->name = "sparc";
230: family_arch_flag->cpusubtype = CPU_SUBTYPE_SPARC_ALL;
231: }
232: if(specific_arch_flag != NULL)
233: specific_arch_flag->name = "sparc";
234: return(1);
235: }
236: break;
237: }
238: return(0);
239: }
240:
241: /*
242: * get_arch_flags() returns a pointer to an array of all currently know
243: * architecture flags (terminated with an entry with all zeros).
244: */
245: const struct arch_flag *
246: get_arch_flags(
247: void)
248: {
249: return(arch_flags);
250: }
251:
252: /*
253: * get_arch_name_from_types() returns the name of the architecture for the
254: * specified cputype and cpusubtype if known. If unknown it returns a pointer
255: * to the string "unknown".
256: */
257: const char *
258: get_arch_name_from_types(
259: cpu_type_t cputype,
260: cpu_subtype_t cpusubtype)
261: {
262: unsigned long i;
263:
264: for(i = 0; arch_flags[i].name != NULL; i++){
265: if(arch_flags[i].cputype == cputype &&
266: arch_flags[i].cpusubtype == cpusubtype)
267: return(arch_flags[i].name);
268: }
269: return("unknown");
270: }
271:
272: /*
273: * get_arch_family_from_cputype() returns the family architecture for the
274: * specified cputype if known. If unknown it returns NULL.
275: */
276: const struct arch_flag *
277: get_arch_family_from_cputype(
278: cpu_type_t cputype)
279: {
280: unsigned long i;
281:
282: for(i = 0; arch_flags[i].name != NULL; i++){
283: if(arch_flags[i].cputype == cputype)
284: return(arch_flags + i);
285: }
286: return(NULL);
287: }
288:
289: /*
290: * get_byte_sex_from_flag() returns the byte sex of the architecture for the
291: * specified cputype and cpusubtype if known. If unknown it returns
292: * UNKNOWN_BYTE_SEX. If the bytesex can be determined directly as in the case
293: * of reading a magic number from a file that should be done and this routine
294: * should not be used as it could be out of date.
295: */
296: enum byte_sex
297: get_byte_sex_from_flag(
298: const struct arch_flag *flag)
299: {
300: if(flag->cputype == CPU_TYPE_MC680x0 ||
301: flag->cputype == CPU_TYPE_MC88000 ||
302: flag->cputype == CPU_TYPE_MC98000 ||
303: flag->cputype == CPU_TYPE_HPPA ||
304: flag->cputype == CPU_TYPE_SPARC ||
305: flag->cputype == CPU_TYPE_I860)
306: return BIG_ENDIAN_BYTE_SEX;
307: else if(flag->cputype == CPU_TYPE_I386)
308: return LITTLE_ENDIAN_BYTE_SEX;
309: else
310: return UNKNOWN_BYTE_SEX;
311: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.