| blob | 7edf362286f0602a3c8e7838eff56c90fecef59d |
1 /*
2 * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3 *
4 * @APPLE_LICENSE_HEADER_START@
5 *
6 * This file contains Original Code and/or Modifications of Original Code
7 * as defined in and that are subject to the Apple Public Source License
8 * Version 2.0 (the 'License'). You may not use this file except in
9 * compliance with the License. Please obtain a copy of the License at
10 * http://www.opensource.apple.com/apsl/ and read it before using this
11 * file.
12 *
13 * The Original Code and all software distributed under the License are
14 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
15 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
16 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
18 * Please see the License for the specific language governing rights and
19 * limitations under the License.
20 *
21 * @APPLE_LICENSE_HEADER_END@
22 */
23 /*
24 * Copyright (c) 1993 NeXT Computer, Inc.
25 *
26 * Architecture computing functions.
27 *
28 * HISTORY
29 *
30 * 11 April 1997
31 * Update m98k to ppc and removed the never supported architectures (mips,
32 * and vax). Apple Computer, Inc.
33 *
34 * 4 February 1993 Lennart Lovstrand <lennart@next.com>
35 * Redesigned to use NXArchInfo based names and signatures.
36 *
37 * Originally written at NeXT, Inc.
38 *
39 */
40 #ifndef RLD
41 #include <stdint.h>
42 #include <stdio.h>
43 #include <stdlib.h>
44 #include <string.h>
45 #include <limits.h>
50 #include <mach-o/fat.h>
51 #include <mach-o/arch.h>
53 /* The array of all currently know architecture flags (terminated with an entry
54 * with all zeros). Pointer to this returned with NXGetAllArchInfos().
55 */
57 /* architecture families */
86 /* specific architecture implementations */
170 NULL}
171 };
173 /*
174 * NXGetAllArchInfos() returns a pointer to an array of all currently know
175 * architecture flags (terminated with an entry with all zeros).
176 */
177 const
178 NXArchInfo *
180 {
182 }
184 /*
185 * NXGetLocalArchInfo() returns the NXArchInfo matching the cputype and
186 * cpusubtype of the local host. NULL is returned if there is no matching
187 * entry in the ArchInfoTable.
188 */
189 const
190 NXArchInfo *
192 {
194 kern_return_t ret;
196 mach_port_t my_mach_host_self;
206 /*
207 * There is a "bug" in the kernel for compatiblity that on
208 * an 030 machine host_info() returns cpusubtype
209 * CPU_SUBTYPE_MC680x0_ALL and not CPU_SUBTYPE_MC68030_ONLY.
210 */
216 }
218 /*
219 * NXGetArchInfoFromName() is passed an architecture name (like "m68k")
220 * and returns the matching NXArchInfo struct, or NULL if none is found.
221 */
222 const
223 NXArchInfo *
226 {
234 }
236 /*
237 * NXGetArchInfoFromName() is passed a cputype and cpusubtype and returns
238 * the matching NXArchInfo struct, or NULL if none is found. If the
239 * cpusubtype is given as CPU_SUBTYPE_MULTIPLE, the first entry that
240 * matches the given cputype is returned. This is the NXArchInfo struct
241 * describing the CPU "family".
242 */
243 const
244 NXArchInfo *
246 cpu_type_t cputype,
247 cpu_subtype_t cpusubtype)
248 {
265 }
266 }
272 }
277 }
284 }
285 }
291 }
294 }
297 }
299 /*
300 * internal_NXFindBestFatArch() is passed a cputype and cpusubtype and a
301 * either set of fat_arch structs or fat_arch_64 structs and selects the best
302 * one that matches (if any) and returns an index to the array of structs or
303 * -1 if none works for the cputype and cpusubtype. The fat_arch structs or
304 * fat_arch_64 structs must be in the host byte sex and correct such that the
305 * fat_archs really points to enough memory for nfat_arch structs. It is
306 * possible that this routine could fail if new cputypes or cpusubtypes are
307 * added and an old version of this routine is used. But if there is an exact
308 * match between the cputype and cpusubtype and one of the structs this routine
309 * will always succeed.
310 */
311 int32_t
313 cpu_type_t cputype,
314 cpu_subtype_t cpusubtype,
318 {
321 cpu_type_t fat_cputype;
322 cpu_subtype_t fat_cpusubtype;
324 /*
325 * Look for the first exact match.
326 */
331 }
335 }
340 }
342 /*
343 * An exact match was not found so find the next best match which is
344 * cputype dependent.
345 */
350 /*
351 * Intel cpusubtypes after the pentium (same as 586) are handled
352 * such that they require an exact match or they can use the
353 * pentium. If that is not found call into the loop for the
354 * earilier subtypes.
355 */
360 }
364 }
368 CPU_SUBTYPE_PENT)
370 }
373 /*
374 * Since an exact match as not found look for the i486 else
375 * break into the loop to look for the i386_ALL.
376 */
381 }
385 }
389 CPU_SUBTYPE_486)
391 }
394 /* case CPU_SUBTYPE_I386: same as above */
397 }
402 }
406 }
410 CPU_SUBTYPE_I386_ALL)
412 }
414 /*
415 * A match failed, promote as little as possible.
416 */
421 }
425 }
429 CPU_SUBTYPE_486)
431 }
436 }
440 }
444 CPU_SUBTYPE_486SX)
446 }
451 }
455 }
459 CPU_SUBTYPE_586)
461 }
462 /*
463 * Now look for the lowest family and in that the lowest model.
464 */
470 }
474 }
481 }
482 /* if no intel cputypes found return NULL */
491 }
495 }
503 fat_cpusubtype &
506 }
507 }
508 }
515 }
519 }
523 CPU_SUBTYPE_X86_64_ALL)
525 }
532 }
536 }
540 CPU_SUBTYPE_MC680x0_ALL)
542 }
543 /*
544 * Try to promote if starting from CPU_SUBTYPE_MC680x0_ALL and
545 * favor the CPU_SUBTYPE_MC68040 over the CPU_SUBTYPE_MC68030_ONLY.
546 */
552 }
556 }
560 CPU_SUBTYPE_MC68040)
562 }
567 }
571 }
575 CPU_SUBTYPE_MC68030_ONLY)
577 }
578 }
581 /*
582 * An exact match as not found. So for all the PowerPC subtypes
583 * pick the subtype from the following order starting from a subtype
584 * that will work (contains 64-bit instructions or altivec if
585 * needed):
586 * 970, 7450, 7400, 750, 604e, 604, 603ev, 603e, 603, ALL
587 * Note the 601 is NOT in the list above. It is only picked via
588 * an exact match. For an unknown subtype pick only the ALL type if
589 * it exists.
590 */
593 /*
594 * The CPU_SUBTYPE_POWERPC_ALL is only used by the development
595 * environment tools when building a generic ALL type binary.
596 * In the case of a non-exact match we pick the most current
597 * processor.
598 */
604 }
608 }
612 CPU_SUBTYPE_POWERPC_970)
614 }
621 }
625 }
629 CPU_SUBTYPE_POWERPC_7450)
631 }
636 }
640 }
644 CPU_SUBTYPE_POWERPC_7400)
646 }
657 }
661 }
665 CPU_SUBTYPE_POWERPC_750)
667 }
672 }
676 }
680 CPU_SUBTYPE_POWERPC_604e)
682 }
687 }
691 }
695 CPU_SUBTYPE_POWERPC_604)
697 }
702 }
706 }
710 CPU_SUBTYPE_POWERPC_603ev)
712 }
717 }
721 }
725 CPU_SUBTYPE_POWERPC_603e)
727 }
732 }
736 }
740 CPU_SUBTYPE_POWERPC_603)
742 }
748 }
752 }
756 CPU_SUBTYPE_POWERPC_ALL)
758 }
759 }
762 /*
763 * An exact match as not found. So for all the PowerPC64 subtypes
764 * pick the subtype from the following order starting from a subtype
765 * that will work (contains 64-bit instructions or altivec if
766 * needed):
767 * 970 (currently only the one 64-bit subtype)
768 * For an unknown subtype pick only the ALL type if it exists.
769 */
772 /*
773 * The CPU_SUBTYPE_POWERPC_ALL is only used by the development
774 * environment tools when building a generic ALL type binary.
775 * In the case of a non-exact match we pick the most current
776 * processor.
777 */
783 }
787 }
791 CPU_SUBTYPE_POWERPC_970)
793 }
799 }
803 }
807 CPU_SUBTYPE_POWERPC_ALL)
809 }
810 }
817 }
821 }
825 CPU_SUBTYPE_MC88000_ALL)
827 }
834 }
838 }
842 CPU_SUBTYPE_I860_ALL)
844 }
851 }
855 }
859 CPU_SUBTYPE_HPPA_ALL)
861 }
868 }
872 }
876 CPU_SUBTYPE_SPARC_ALL)
878 }
882 {
883 /*
884 * ARM is straightforward, since each architecture is backward
885 * compatible with previous architectures. So, we just take the
886 * highest that is less than our target.
887 */
894 }
898 }
907 }
912 }
917 }
918 }
921 /*
922 * For CPU_TYPE_ARM64, we will fall back to a CPU_TYPE_ARM
923 * with the highest subtype.
924 */
932 }
936 }
943 }
948 }
953 }
954 }
957 }
958 }
962 }
964 }
966 /*
967 * NXFindBestFatArch() is passed a cputype and cpusubtype and a set of
968 * fat_arch structs and selects the best one that matches (if any) and returns
969 * a pointer to that fat_arch struct (or NULL). The fat_arch structs must be
970 * in the host byte order and correct such that the fat_archs really points to
971 * enough memory for nfat_arch structs. It is possible that this routine could
972 * fail if new cputypes or cpusubtypes are added and an old version of this
973 * routine is used. But if there is an exact match between the cputype and
974 * cpusubtype and one of the fat_arch structs this routine will always succeed.
975 */
978 cpu_type_t cputype,
979 cpu_subtype_t cpusubtype,
982 {
986 nfat_archs);
990 }
992 /* NXFindBestFatArch_64() is passed a cputype and cpusubtype and a set of
993 * fat_arch_64 structs and selects the best one that matches (if any) and
994 * returns a pointer to that fat_arch_64 struct (or NULL). The fat_arch_64
995 * structs must be in the host byte order and correct such that the fat_archs64
996 * really points to enough memory for nfat_arch structs. It is possible that
997 * this routine could fail if new cputypes or cpusubtypes are added and an old
998 * version of this routine is used. But if there is an exact match between the
999 * cputype and cpusubtype and one of the fat_arch_64 structs this routine will
1000 * always succeed.
1001 */
1004 cpu_type_t cputype,
1005 cpu_subtype_t cpusubtype,
1008 {
1016 }
1018 /*
1019 * NXCombineCpuSubtypes() returns the resulting cpusubtype when combining two
1020 * different cpusubtypes for the specified cputype. If the two cpusubtypes
1021 * can't be combined (the specific subtypes are mutually exclusive) -1 is
1022 * returned indicating it is an error to combine them. This can also fail and
1023 * return -1 if new cputypes or cpusubtypes are added and an old version of
1024 * this routine is used. But if the cpusubtypes are the same they can always
1025 * be combined and this routine will return the cpusubtype pass in.
1026 */
1027 cpu_subtype_t
1029 cpu_type_t cputype,
1030 cpu_subtype_t cpusubtype1,
1031 cpu_subtype_t cpusubtype2)
1032 {
1033 /*
1034 * If this is an x86_64 cputype and either subtype is the
1035 * "Haswell and compatible" it does not combine with anything else.
1036 */
1042 /*
1043 * We now combine any i386 or x86-64 subtype to the ALL subtype.
1044 */
1083 /*
1084 * Combining with the ALL type becomes the other type. Combining
1085 * anything with the 601 becomes 601. All other non exact matches
1086 * combine to the higher value subtype.
1087 */
1100 else
1150 /*
1151 * Combinability matrix for ARM:
1152 * V4T V5 XSCALE V6 V7 ALL
1153 * ~~~ ~~ ~~~~~~ ~~ ~~ ~~~
1154 * V4T V4T V5 XSCALE V6 V7 ALL
1155 * V5 V5 V5 -- V6 V7 ALL
1156 * XSCALE XSCALE -- XSCALE -- -- ALL
1157 * V6 V6 V6 -- V6 V7 ALL
1158 * V7 V7 V7 -- V7 V7 ALL
1159 * ALL ALL ALL ALL ALL ALL ALL
1160 */
1172 }
1179 }
1188 }
1199 }
1204 }
1215 }
1217 }