this repo has no description
A few build fixes
+8
-909
+3
-2
platform-include/mach-o/fat.h
+3
-2
platform-include/mach-o/fat.h
···
42
42
* and contains the constants for the possible values of these types.
43
43
*/
44
44
#include <stdint.h>
45
-
#include <mach/machine.h>
46
-
#include <architecture/byte_order.h>
45
+
46
+
typedef int cpu_type_t;
47
+
typedef int cpu_subtype_t;
47
48
48
49
#define FAT_MAGIC 0xcafebabe
49
50
#define FAT_CIGAM 0xbebafeca /* NXSwapLong(FAT_MAGIC) */
+4
src/libmacho/swap.c
+4
src/libmacho/swap.c
+1
-1
src/libsystem/CMakeLists.txt
+1
-1
src/libsystem/CMakeLists.txt
-906
src/libsystem/libmacho/arch.c
-906
src/libsystem/libmacho/arch.c
···
1
-
// Modified for Darling by Lubos Dolezel
2
-
/*
3
-
* Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
4
-
*
5
-
* @APPLE_LICENSE_HEADER_START@
6
-
*
7
-
* This file contains Original Code and/or Modifications of Original Code
8
-
* as defined in and that are subject to the Apple Public Source License
9
-
* Version 2.0 (the 'License'). You may not use this file except in
10
-
* compliance with the License. Please obtain a copy of the License at
11
-
* http://www.opensource.apple.com/apsl/ and read it before using this
12
-
* file.
13
-
*
14
-
* The Original Code and all software distributed under the License are
15
-
* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16
-
* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17
-
* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18
-
* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
19
-
* Please see the License for the specific language governing rights and
20
-
* limitations under the License.
21
-
*
22
-
* @APPLE_LICENSE_HEADER_END@
23
-
*/
24
-
/*
25
-
* Copyright (c) 1993 NeXT Computer, Inc.
26
-
*
27
-
* Architecture computing functions.
28
-
*
29
-
* HISTORY
30
-
*
31
-
* 11 April 1997
32
-
* Update m98k to ppc and removed the never supported architectures (mips,
33
-
* and vax). Apple Computer, Inc.
34
-
*
35
-
* 4 February 1993 Lennart Lovstrand <lennart@next.com>
36
-
* Redesigned to use NXArchInfo based names and signatures.
37
-
*
38
-
* Originally written at NeXT, Inc.
39
-
*
40
-
*/
41
-
#ifndef RLD
42
-
#include <stdint.h>
43
-
#include <stdio.h>
44
-
#include <stdlib.h>
45
-
#include <string.h>
46
-
#include <limits.h>
47
-
48
-
#include "mach/machine.h"
49
-
#include "mach/mach.h"
50
-
#ifndef DARLING
51
-
#include "stuff/openstep_mach.h"
52
-
#endif
53
-
#include <mach-o/fat.h>
54
-
#include <mach-o/arch.h>
55
-
56
-
/* The array of all currently know architecture flags (terminated with an entry
57
-
* with all zeros). Pointer to this returned with NXGetAllArchInfos().
58
-
*/
59
-
static /* const */ NXArchInfo ArchInfoTable[] = {
60
-
/* architecture families */
61
-
{"hppa", CPU_TYPE_HPPA, CPU_SUBTYPE_HPPA_ALL, NX_BigEndian,
62
-
"HP-PA"},
63
-
{"i386", CPU_TYPE_I386, CPU_SUBTYPE_I386_ALL, NX_LittleEndian,
64
-
"Intel 80x86"},
65
-
{ "x86_64", CPU_TYPE_X86_64, CPU_SUBTYPE_X86_64_ALL, NX_LittleEndian,
66
-
"Intel x86-64" },
67
-
{ "x86_64h", CPU_TYPE_X86_64, CPU_SUBTYPE_X86_64_H, NX_LittleEndian,
68
-
"Intel x86-64h Haswell" },
69
-
{"i860", CPU_TYPE_I860, CPU_SUBTYPE_I860_ALL, NX_BigEndian,
70
-
"Intel 860"},
71
-
{"m68k", CPU_TYPE_MC680x0, CPU_SUBTYPE_MC680x0_ALL, NX_BigEndian,
72
-
"Motorola 68K"},
73
-
{"m88k", CPU_TYPE_MC88000, CPU_SUBTYPE_MC88000_ALL, NX_BigEndian,
74
-
"Motorola 88K"},
75
-
{"ppc", CPU_TYPE_POWERPC, CPU_SUBTYPE_POWERPC_ALL, NX_BigEndian,
76
-
"PowerPC"},
77
-
{"ppc64", CPU_TYPE_POWERPC64, CPU_SUBTYPE_POWERPC_ALL, NX_BigEndian,
78
-
"PowerPC 64-bit"},
79
-
{"sparc", CPU_TYPE_SPARC, CPU_SUBTYPE_SPARC_ALL, NX_BigEndian,
80
-
"SPARC"},
81
-
{"arm", CPU_TYPE_ARM, CPU_SUBTYPE_ARM_ALL, NX_LittleEndian,
82
-
"ARM"},
83
-
{"arm64", CPU_TYPE_ARM64, CPU_SUBTYPE_ARM64_ALL, NX_LittleEndian,
84
-
"ARM64"},
85
-
{"any", CPU_TYPE_ANY, CPU_SUBTYPE_MULTIPLE, NX_UnknownByteOrder,
86
-
"Architecture Independent"},
87
-
#ifndef DARLING
88
-
{"veo", CPU_TYPE_VEO, CPU_SUBTYPE_VEO_ALL, NX_BigEndian,
89
-
"veo"},
90
-
#endif
91
-
/* specific architecture implementations */
92
-
{"hppa7100LC", CPU_TYPE_HPPA, CPU_SUBTYPE_HPPA_7100LC, NX_BigEndian,
93
-
"HP-PA 7100LC"},
94
-
{"m68030", CPU_TYPE_MC680x0, CPU_SUBTYPE_MC68030_ONLY, NX_BigEndian,
95
-
"Motorola 68030"},
96
-
{"m68040", CPU_TYPE_MC680x0, CPU_SUBTYPE_MC68040, NX_BigEndian,
97
-
"Motorola 68040"},
98
-
{"i486", CPU_TYPE_I386, CPU_SUBTYPE_486, NX_LittleEndian,
99
-
"Intel 80486"},
100
-
{"i486SX", CPU_TYPE_I386, CPU_SUBTYPE_486SX, NX_LittleEndian,
101
-
"Intel 80486SX"},
102
-
{"pentium",CPU_TYPE_I386, CPU_SUBTYPE_PENT, NX_LittleEndian,
103
-
"Intel Pentium"}, /* same as 586 */
104
-
{"i586", CPU_TYPE_I386, CPU_SUBTYPE_586, NX_LittleEndian,
105
-
"Intel 80586"},
106
-
{"pentpro", CPU_TYPE_I386, CPU_SUBTYPE_PENTPRO, NX_LittleEndian,
107
-
"Intel Pentium Pro"}, /* same as 686 */
108
-
{"i686", CPU_TYPE_I386, CPU_SUBTYPE_PENTPRO, NX_LittleEndian,
109
-
"Intel Pentium Pro"},
110
-
{"pentIIm3", CPU_TYPE_I386, CPU_SUBTYPE_PENTII_M3, NX_LittleEndian,
111
-
"Intel Pentium II Model 3" },
112
-
{"pentIIm5", CPU_TYPE_I386, CPU_SUBTYPE_PENTII_M5, NX_LittleEndian,
113
-
"Intel Pentium II Model 5" },
114
-
{"pentium4", CPU_TYPE_I386, CPU_SUBTYPE_PENTIUM_4, NX_LittleEndian,
115
-
"Intel Pentium 4" },
116
-
{ "x86_64h", CPU_TYPE_I386, CPU_SUBTYPE_X86_64_H, NX_LittleEndian,
117
-
"Intel x86-64h Haswell" },
118
-
{"ppc601", CPU_TYPE_POWERPC, CPU_SUBTYPE_POWERPC_601, NX_BigEndian,
119
-
"PowerPC 601" },
120
-
{"ppc603", CPU_TYPE_POWERPC, CPU_SUBTYPE_POWERPC_603, NX_BigEndian,
121
-
"PowerPC 603" },
122
-
{"ppc603e",CPU_TYPE_POWERPC, CPU_SUBTYPE_POWERPC_603e, NX_BigEndian,
123
-
"PowerPC 603e" },
124
-
{"ppc603ev",CPU_TYPE_POWERPC,CPU_SUBTYPE_POWERPC_603ev,NX_BigEndian,
125
-
"PowerPC 603ev" },
126
-
{"ppc604", CPU_TYPE_POWERPC, CPU_SUBTYPE_POWERPC_604, NX_BigEndian,
127
-
"PowerPC 604" },
128
-
{"ppc604e",CPU_TYPE_POWERPC, CPU_SUBTYPE_POWERPC_604e, NX_BigEndian,
129
-
"PowerPC 604e" },
130
-
{"ppc750", CPU_TYPE_POWERPC, CPU_SUBTYPE_POWERPC_750, NX_BigEndian,
131
-
"PowerPC 750" },
132
-
{"ppc7400",CPU_TYPE_POWERPC, CPU_SUBTYPE_POWERPC_7400, NX_BigEndian,
133
-
"PowerPC 7400" },
134
-
{"ppc7450",CPU_TYPE_POWERPC, CPU_SUBTYPE_POWERPC_7450, NX_BigEndian,
135
-
"PowerPC 7450" },
136
-
{"ppc970", CPU_TYPE_POWERPC, CPU_SUBTYPE_POWERPC_970, NX_BigEndian,
137
-
"PowerPC 970" },
138
-
{"ppc970-64", CPU_TYPE_POWERPC64, CPU_SUBTYPE_POWERPC_970, NX_BigEndian,
139
-
"PowerPC 970 64-bit"},
140
-
{"armv4t", CPU_TYPE_ARM, CPU_SUBTYPE_ARM_V4T, NX_LittleEndian,
141
-
"arm v4t"},
142
-
{"armv5", CPU_TYPE_ARM, CPU_SUBTYPE_ARM_V5TEJ, NX_LittleEndian,
143
-
"arm v5"},
144
-
{"xscale", CPU_TYPE_ARM, CPU_SUBTYPE_ARM_XSCALE, NX_LittleEndian,
145
-
"arm xscale"},
146
-
{"armv6", CPU_TYPE_ARM, CPU_SUBTYPE_ARM_V6, NX_LittleEndian,
147
-
"arm v6"},
148
-
{"armv6m", CPU_TYPE_ARM, CPU_SUBTYPE_ARM_V6M, NX_LittleEndian,
149
-
"arm v6m"},
150
-
{"armv7", CPU_TYPE_ARM, CPU_SUBTYPE_ARM_V7, NX_LittleEndian,
151
-
"arm v7"},
152
-
{"armv7f", CPU_TYPE_ARM, CPU_SUBTYPE_ARM_V7F, NX_LittleEndian,
153
-
"arm v7f"},
154
-
{"armv7s", CPU_TYPE_ARM, CPU_SUBTYPE_ARM_V7S, NX_LittleEndian,
155
-
"arm v7s"},
156
-
{"armv7k", CPU_TYPE_ARM, CPU_SUBTYPE_ARM_V7K, NX_LittleEndian,
157
-
"arm v7k"},
158
-
{"armv7m", CPU_TYPE_ARM, CPU_SUBTYPE_ARM_V7M, NX_LittleEndian,
159
-
"arm v7m"},
160
-
{"armv7em",CPU_TYPE_ARM, CPU_SUBTYPE_ARM_V7EM, NX_LittleEndian,
161
-
"arm v7em"},
162
-
{"armv8", CPU_TYPE_ARM, CPU_SUBTYPE_ARM_V8, NX_LittleEndian,
163
-
"arm v8"},
164
-
{"arm64",CPU_TYPE_ARM64, CPU_SUBTYPE_ARM64_V8, NX_LittleEndian,
165
-
"arm64 v8"},
166
-
{"little", CPU_TYPE_ANY, CPU_SUBTYPE_LITTLE_ENDIAN, NX_LittleEndian,
167
-
"Little Endian"},
168
-
{"big", CPU_TYPE_ANY, CPU_SUBTYPE_BIG_ENDIAN, NX_BigEndian,
169
-
"Big Endian"},
170
-
#ifndef DARLING
171
-
{"veo1",CPU_TYPE_VEO, CPU_SUBTYPE_VEO_1, NX_BigEndian,
172
-
"veo 1" },
173
-
{"veo2",CPU_TYPE_VEO, CPU_SUBTYPE_VEO_2, NX_BigEndian,
174
-
"veo 2" },
175
-
#endif
176
-
{NULL, 0, 0, 0,
177
-
NULL}
178
-
};
179
-
180
-
/*
181
-
* NXGetAllArchInfos() returns a pointer to an array of all currently know
182
-
* architecture flags (terminated with an entry with all zeros).
183
-
*/
184
-
const
185
-
NXArchInfo *
186
-
NXGetAllArchInfos(void)
187
-
{
188
-
return(ArchInfoTable);
189
-
}
190
-
191
-
/*
192
-
* NXGetLocalArchInfo() returns the NXArchInfo matching the cputype and
193
-
* cpusubtype of the local host. NULL is returned if there is no matching
194
-
* entry in the ArchInfoTable.
195
-
*/
196
-
const
197
-
NXArchInfo *
198
-
NXGetLocalArchInfo(void)
199
-
{
200
-
struct host_basic_info hbi;
201
-
kern_return_t ret;
202
-
unsigned int count;
203
-
mach_port_t my_mach_host_self;
204
-
205
-
count = HOST_BASIC_INFO_COUNT;
206
-
my_mach_host_self = mach_host_self();
207
-
ret = host_info(my_mach_host_self, HOST_BASIC_INFO, (host_info_t)&hbi,
208
-
&count);
209
-
mach_port_deallocate(mach_task_self(), my_mach_host_self);
210
-
if(ret != KERN_SUCCESS)
211
-
return(NULL);
212
-
213
-
/*
214
-
* There is a "bug" in the kernel for compatiblity that on
215
-
* an 030 machine host_info() returns cpusubtype
216
-
* CPU_SUBTYPE_MC680x0_ALL and not CPU_SUBTYPE_MC68030_ONLY.
217
-
*/
218
-
if(hbi.cpu_type == CPU_TYPE_MC680x0 &&
219
-
hbi.cpu_subtype == CPU_SUBTYPE_MC680x0_ALL)
220
-
hbi.cpu_subtype = CPU_SUBTYPE_MC68030_ONLY;
221
-
222
-
return(NXGetArchInfoFromCpuType(hbi.cpu_type, hbi.cpu_subtype));
223
-
}
224
-
225
-
/*
226
-
* NXGetArchInfoFromName() is passed an architecture name (like "m68k")
227
-
* and returns the matching NXArchInfo struct, or NULL if none is found.
228
-
*/
229
-
const
230
-
NXArchInfo *
231
-
NXGetArchInfoFromName(
232
-
const char *name)
233
-
{
234
-
const NXArchInfo *ai;
235
-
236
-
for(ai = ArchInfoTable; ai->name != NULL; ai++)
237
-
if(strcmp(ai->name, name) == 0)
238
-
return(ai);
239
-
240
-
return(NULL);
241
-
}
242
-
243
-
/*
244
-
* NXGetArchInfoFromName() is passed a cputype and cpusubtype and returns
245
-
* the matching NXArchInfo struct, or NULL if none is found. If the
246
-
* cpusubtype is given as CPU_SUBTYPE_MULTIPLE, the first entry that
247
-
* matches the given cputype is returned. This is the NXArchInfo struct
248
-
* describing the CPU "family".
249
-
*/
250
-
const
251
-
NXArchInfo *
252
-
NXGetArchInfoFromCpuType(
253
-
cpu_type_t cputype,
254
-
cpu_subtype_t cpusubtype)
255
-
{
256
-
const NXArchInfo *ai;
257
-
NXArchInfo *q;
258
-
259
-
for(ai = ArchInfoTable; ai->name != NULL; ai++)
260
-
if(ai->cputype == cputype &&
261
-
(cpusubtype == CPU_SUBTYPE_MULTIPLE ||
262
-
((ai->cpusubtype & ~CPU_SUBTYPE_MASK) ==
263
-
(cpusubtype & ~CPU_SUBTYPE_MASK))))
264
-
return(ai);
265
-
266
-
if(cputype == CPU_TYPE_I386){
267
-
q = malloc(sizeof(NXArchInfo));
268
-
for(ai = ArchInfoTable; ai->name != NULL; ai++){
269
-
if(ai->cputype == cputype){
270
-
*q = *ai;
271
-
break;
272
-
}
273
-
}
274
-
q->cpusubtype = cpusubtype;
275
-
q->description = malloc(sizeof("Intel family model ") + 2 + 8);
276
-
if(q->description == NULL){
277
-
free(q);
278
-
return(NULL);
279
-
}
280
-
sprintf((char *)q->description, "Intel family %u model %u",
281
-
CPU_SUBTYPE_INTEL_FAMILY(cpusubtype & ~CPU_SUBTYPE_MASK),
282
-
CPU_SUBTYPE_INTEL_MODEL(cpusubtype & ~CPU_SUBTYPE_MASK));
283
-
return((const NXArchInfo *)q);
284
-
}
285
-
else if(cputype == CPU_TYPE_POWERPC){
286
-
q = malloc(sizeof(NXArchInfo));
287
-
for(ai = ArchInfoTable; ai->name != NULL; ai++){
288
-
if(ai->cputype == cputype){
289
-
*q = *ai;
290
-
break;
291
-
}
292
-
}
293
-
q->cpusubtype = cpusubtype;
294
-
q->description = malloc(sizeof("PowerPC cpusubtype ") + 10);
295
-
if(q->description == NULL){
296
-
free(q);
297
-
return(NULL);
298
-
}
299
-
sprintf((char *)q->description, "PowerPC cpusubtype %u", cpusubtype);
300
-
return((const NXArchInfo *)q);
301
-
}
302
-
303
-
return(NULL);
304
-
}
305
-
306
-
/*
307
-
* NXFindBestFatArch() is passed a cputype and cpusubtype and a set of
308
-
* fat_arch structs and selects the best one that matches (if any) and returns
309
-
* a pointer to that fat_arch struct (or NULL). The fat_arch structs must be
310
-
* in the host byte order and correct such that the fat_archs really points to
311
-
* enough memory for nfat_arch structs. It is possible that this routine could
312
-
* fail if new cputypes or cpusubtypes are added and an old version of this
313
-
* routine is used. But if there is an exact match between the cputype and
314
-
* cpusubtype and one of the fat_arch structs this routine will always succeed.
315
-
*/
316
-
struct fat_arch *
317
-
NXFindBestFatArch(
318
-
cpu_type_t cputype,
319
-
cpu_subtype_t cpusubtype,
320
-
struct fat_arch *fat_archs,
321
-
uint32_t nfat_archs)
322
-
{
323
-
uint32_t i;
324
-
int32_t lowest_family, lowest_model, lowest_index;
325
-
326
-
/*
327
-
* Look for the first exact match.
328
-
*/
329
-
for(i = 0; i < nfat_archs; i++){
330
-
if(fat_archs[i].cputype == cputype &&
331
-
(fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) ==
332
-
(cpusubtype & ~CPU_SUBTYPE_MASK))
333
-
return(fat_archs + i);
334
-
}
335
-
336
-
/*
337
-
* An exact match was not found so find the next best match which is
338
-
* cputype dependent.
339
-
*/
340
-
switch(cputype){
341
-
case CPU_TYPE_I386:
342
-
switch(cpusubtype & ~CPU_SUBTYPE_MASK){
343
-
default:
344
-
/*
345
-
* Intel cpusubtypes after the pentium (same as 586) are handled
346
-
* such that they require an exact match or they can use the
347
-
* pentium. If that is not found call into the loop for the
348
-
* earilier subtypes.
349
-
*/
350
-
for(i = 0; i < nfat_archs; i++){
351
-
if(fat_archs[i].cputype != cputype)
352
-
continue;
353
-
if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) ==
354
-
CPU_SUBTYPE_PENT)
355
-
return(fat_archs + i);
356
-
}
357
-
case CPU_SUBTYPE_PENT:
358
-
case CPU_SUBTYPE_486SX:
359
-
/*
360
-
* Since an exact match as not found look for the i486 else
361
-
* break into the loop to look for the i386_ALL.
362
-
*/
363
-
for(i = 0; i < nfat_archs; i++){
364
-
if(fat_archs[i].cputype != cputype)
365
-
continue;
366
-
if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) ==
367
-
CPU_SUBTYPE_486)
368
-
return(fat_archs + i);
369
-
}
370
-
break;
371
-
case CPU_SUBTYPE_I386_ALL:
372
-
/* case CPU_SUBTYPE_I386: same as above */
373
-
case CPU_SUBTYPE_486:
374
-
break;
375
-
}
376
-
for(i = 0; i < nfat_archs; i++){
377
-
if(fat_archs[i].cputype != cputype)
378
-
continue;
379
-
if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) ==
380
-
CPU_SUBTYPE_I386_ALL)
381
-
return(fat_archs + i);
382
-
}
383
-
384
-
/*
385
-
* A match failed, promote as little as possible.
386
-
*/
387
-
for(i = 0; i < nfat_archs; i++){
388
-
if(fat_archs[i].cputype != cputype)
389
-
continue;
390
-
if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) ==
391
-
CPU_SUBTYPE_486)
392
-
return(fat_archs + i);
393
-
}
394
-
for(i = 0; i < nfat_archs; i++){
395
-
if(fat_archs[i].cputype != cputype)
396
-
continue;
397
-
if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) ==
398
-
CPU_SUBTYPE_486SX)
399
-
return(fat_archs + i);
400
-
}
401
-
for(i = 0; i < nfat_archs; i++){
402
-
if(fat_archs[i].cputype != cputype)
403
-
continue;
404
-
if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) ==
405
-
CPU_SUBTYPE_586)
406
-
return(fat_archs + i);
407
-
}
408
-
/*
409
-
* Now look for the lowest family and in that the lowest model.
410
-
*/
411
-
lowest_family = CPU_SUBTYPE_INTEL_FAMILY_MAX + 1;
412
-
for(i = 0; i < nfat_archs; i++){
413
-
if(fat_archs[i].cputype != cputype)
414
-
continue;
415
-
if(CPU_SUBTYPE_INTEL_FAMILY(fat_archs[i].cpusubtype &
416
-
~CPU_SUBTYPE_MASK) < lowest_family)
417
-
lowest_family = CPU_SUBTYPE_INTEL_FAMILY(
418
-
fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK);
419
-
}
420
-
/* if no intel cputypes found return NULL */
421
-
if(lowest_family == CPU_SUBTYPE_INTEL_FAMILY_MAX + 1)
422
-
return(NULL);
423
-
lowest_model = INT_MAX;
424
-
lowest_index = -1;
425
-
for(i = 0; i < nfat_archs; i++){
426
-
if(fat_archs[i].cputype != cputype)
427
-
continue;
428
-
if(CPU_SUBTYPE_INTEL_FAMILY(fat_archs[i].cpusubtype &
429
-
~CPU_SUBTYPE_MASK) == lowest_family){
430
-
if(CPU_SUBTYPE_INTEL_MODEL(fat_archs[i].cpusubtype &
431
-
~CPU_SUBTYPE_MASK) < lowest_model){
432
-
lowest_model = CPU_SUBTYPE_INTEL_MODEL(
433
-
fat_archs[i].cpusubtype &
434
-
~CPU_SUBTYPE_MASK);
435
-
lowest_index = i;
436
-
}
437
-
}
438
-
}
439
-
return(fat_archs + lowest_index);
440
-
case CPU_TYPE_X86_64:
441
-
for(i = 0; i < nfat_archs; i++){
442
-
if(fat_archs[i].cputype != cputype)
443
-
continue;
444
-
if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) ==
445
-
CPU_SUBTYPE_X86_64_ALL)
446
-
return(fat_archs + i);
447
-
}
448
-
break;
449
-
case CPU_TYPE_MC680x0:
450
-
for(i = 0; i < nfat_archs; i++){
451
-
if(fat_archs[i].cputype != cputype)
452
-
continue;
453
-
if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) ==
454
-
CPU_SUBTYPE_MC680x0_ALL)
455
-
return(fat_archs + i);
456
-
}
457
-
/*
458
-
* Try to promote if starting from CPU_SUBTYPE_MC680x0_ALL and
459
-
* favor the CPU_SUBTYPE_MC68040 over the CPU_SUBTYPE_MC68030_ONLY.
460
-
*/
461
-
if((cpusubtype & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_MC680x0_ALL){
462
-
for(i = 0; i < nfat_archs; i++){
463
-
if(fat_archs[i].cputype != cputype)
464
-
continue;
465
-
if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) ==
466
-
CPU_SUBTYPE_MC68040)
467
-
return(fat_archs + i);
468
-
}
469
-
for(i = 0; i < nfat_archs; i++){
470
-
if(fat_archs[i].cputype != cputype)
471
-
continue;
472
-
if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) ==
473
-
CPU_SUBTYPE_MC68030_ONLY)
474
-
return(fat_archs + i);
475
-
}
476
-
}
477
-
break;
478
-
case CPU_TYPE_POWERPC:
479
-
/*
480
-
* An exact match as not found. So for all the PowerPC subtypes
481
-
* pick the subtype from the following order starting from a subtype
482
-
* that will work (contains 64-bit instructions or altivec if
483
-
* needed):
484
-
* 970, 7450, 7400, 750, 604e, 604, 603ev, 603e, 603, ALL
485
-
* Note the 601 is NOT in the list above. It is only picked via
486
-
* an exact match. For an unknown subtype pick only the ALL type if
487
-
* it exists.
488
-
*/
489
-
switch(cpusubtype & ~CPU_SUBTYPE_MASK){
490
-
case CPU_SUBTYPE_POWERPC_ALL:
491
-
/*
492
-
* The CPU_SUBTYPE_POWERPC_ALL is only used by the development
493
-
* environment tools when building a generic ALL type binary.
494
-
* In the case of a non-exact match we pick the most current
495
-
* processor.
496
-
*/
497
-
case CPU_SUBTYPE_POWERPC_970:
498
-
for(i = 0; i < nfat_archs; i++){
499
-
if(fat_archs[i].cputype != cputype)
500
-
continue;
501
-
if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) ==
502
-
CPU_SUBTYPE_POWERPC_970)
503
-
return(fat_archs + i);
504
-
}
505
-
case CPU_SUBTYPE_POWERPC_7450:
506
-
case CPU_SUBTYPE_POWERPC_7400:
507
-
for(i = 0; i < nfat_archs; i++){
508
-
if(fat_archs[i].cputype != cputype)
509
-
continue;
510
-
if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) ==
511
-
CPU_SUBTYPE_POWERPC_7450)
512
-
return(fat_archs + i);
513
-
}
514
-
for(i = 0; i < nfat_archs; i++){
515
-
if(fat_archs[i].cputype != cputype)
516
-
continue;
517
-
if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) ==
518
-
CPU_SUBTYPE_POWERPC_7400)
519
-
return(fat_archs + i);
520
-
}
521
-
case CPU_SUBTYPE_POWERPC_750:
522
-
case CPU_SUBTYPE_POWERPC_604e:
523
-
case CPU_SUBTYPE_POWERPC_604:
524
-
case CPU_SUBTYPE_POWERPC_603ev:
525
-
case CPU_SUBTYPE_POWERPC_603e:
526
-
case CPU_SUBTYPE_POWERPC_603:
527
-
for(i = 0; i < nfat_archs; i++){
528
-
if(fat_archs[i].cputype != cputype)
529
-
continue;
530
-
if((fat_archs[i].cpusubtype & CPU_SUBTYPE_MASK) ==
531
-
CPU_SUBTYPE_POWERPC_750)
532
-
return(fat_archs + i);
533
-
}
534
-
for(i = 0; i < nfat_archs; i++){
535
-
if(fat_archs[i].cputype != cputype)
536
-
continue;
537
-
if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) ==
538
-
CPU_SUBTYPE_POWERPC_604e)
539
-
return(fat_archs + i);
540
-
}
541
-
for(i = 0; i < nfat_archs; i++){
542
-
if(fat_archs[i].cputype != cputype)
543
-
continue;
544
-
if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) ==
545
-
CPU_SUBTYPE_POWERPC_604)
546
-
return(fat_archs + i);
547
-
}
548
-
for(i = 0; i < nfat_archs; i++){
549
-
if((fat_archs[i].cputype & ~CPU_SUBTYPE_MASK) != cputype)
550
-
continue;
551
-
if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) ==
552
-
CPU_SUBTYPE_POWERPC_603ev)
553
-
return(fat_archs + i);
554
-
}
555
-
for(i = 0; i < nfat_archs; i++){
556
-
if(fat_archs[i].cputype != cputype)
557
-
continue;
558
-
if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) ==
559
-
CPU_SUBTYPE_POWERPC_603e)
560
-
return(fat_archs + i);
561
-
}
562
-
for(i = 0; i < nfat_archs; i++){
563
-
if(fat_archs[i].cputype != cputype)
564
-
continue;
565
-
if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) ==
566
-
CPU_SUBTYPE_POWERPC_603)
567
-
return(fat_archs + i);
568
-
}
569
-
default:
570
-
for(i = 0; i < nfat_archs; i++){
571
-
if(fat_archs[i].cputype != cputype)
572
-
continue;
573
-
if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) ==
574
-
CPU_SUBTYPE_POWERPC_ALL)
575
-
return(fat_archs + i);
576
-
}
577
-
}
578
-
break;
579
-
case CPU_TYPE_POWERPC64:
580
-
/*
581
-
* An exact match as not found. So for all the PowerPC64 subtypes
582
-
* pick the subtype from the following order starting from a subtype
583
-
* that will work (contains 64-bit instructions or altivec if
584
-
* needed):
585
-
* 970 (currently only the one 64-bit subtype)
586
-
* For an unknown subtype pick only the ALL type if it exists.
587
-
*/
588
-
switch(cpusubtype & ~CPU_SUBTYPE_MASK){
589
-
case CPU_SUBTYPE_POWERPC_ALL:
590
-
/*
591
-
* The CPU_SUBTYPE_POWERPC_ALL is only used by the development
592
-
* environment tools when building a generic ALL type binary.
593
-
* In the case of a non-exact match we pick the most current
594
-
* processor.
595
-
*/
596
-
case CPU_SUBTYPE_POWERPC_970:
597
-
for(i = 0; i < nfat_archs; i++){
598
-
if(fat_archs[i].cputype != cputype)
599
-
continue;
600
-
if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) ==
601
-
CPU_SUBTYPE_POWERPC_970)
602
-
return(fat_archs + i);
603
-
}
604
-
default:
605
-
for(i = 0; i < nfat_archs; i++){
606
-
if(fat_archs[i].cputype != cputype)
607
-
continue;
608
-
if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) ==
609
-
CPU_SUBTYPE_POWERPC_ALL)
610
-
return(fat_archs + i);
611
-
}
612
-
}
613
-
break;
614
-
case CPU_TYPE_MC88000:
615
-
for(i = 0; i < nfat_archs; i++){
616
-
if(fat_archs[i].cputype != cputype)
617
-
continue;
618
-
if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) ==
619
-
CPU_SUBTYPE_MC88000_ALL)
620
-
return(fat_archs + i);
621
-
}
622
-
break;
623
-
case CPU_TYPE_I860:
624
-
for(i = 0; i < nfat_archs; i++){
625
-
if(fat_archs[i].cputype != cputype)
626
-
continue;
627
-
if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) ==
628
-
CPU_SUBTYPE_I860_ALL)
629
-
return(fat_archs + i);
630
-
}
631
-
break;
632
-
case CPU_TYPE_HPPA:
633
-
for(i = 0; i < nfat_archs; i++){
634
-
if(fat_archs[i].cputype != cputype)
635
-
continue;
636
-
if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) ==
637
-
CPU_SUBTYPE_HPPA_ALL)
638
-
return(fat_archs + i);
639
-
}
640
-
break;
641
-
case CPU_TYPE_SPARC:
642
-
for(i = 0; i < nfat_archs; i++){
643
-
if(fat_archs[i].cputype != cputype)
644
-
continue;
645
-
if((fat_archs[i].cpusubtype & ~CPU_SUBTYPE_MASK) ==
646
-
CPU_SUBTYPE_SPARC_ALL)
647
-
return(fat_archs + i);
648
-
}
649
-
break;
650
-
case CPU_TYPE_ARM:
651
-
case CPU_TYPE_ARM64:
652
-
{
653
-
/*
654
-
* ARM is straightforward, since each architecture is backward
655
-
* compatible with previous architectures. So, we just take the
656
-
* highest that is less than our target.
657
-
*/
658
-
int fat_match_found = 0;
659
-
uint32_t best_fat_arch = 0;
660
-
for(i = 0; i < nfat_archs; i++){
661
-
if(fat_archs[i].cputype != cputype)
662
-
continue;
663
-
if(fat_archs[i].cpusubtype > cpusubtype)
664
-
continue;
665
-
if(!fat_match_found){
666
-
fat_match_found = 1;
667
-
best_fat_arch = i;
668
-
continue;
669
-
}
670
-
if(fat_archs[i].cpusubtype >
671
-
fat_archs[best_fat_arch].cpusubtype)
672
-
best_fat_arch = i;
673
-
}
674
-
if(fat_match_found)
675
-
return fat_archs + best_fat_arch;
676
-
/*
677
-
* For CPU_TYPE_ARM64, we will fall back to a CPU_TYPE_ARM
678
-
* with the highest subtype.
679
-
*/
680
-
if(cputype == CPU_TYPE_ARM64){
681
-
int fat_match_found = 0;
682
-
uint32_t best_fat_arch = 0;
683
-
for(i = 0; i < nfat_archs; i++){
684
-
if(fat_archs[i].cputype != CPU_TYPE_ARM)
685
-
continue;
686
-
if(!fat_match_found){
687
-
fat_match_found = 1;
688
-
best_fat_arch = i;
689
-
continue;
690
-
}
691
-
if(fat_archs[i].cpusubtype >
692
-
fat_archs[best_fat_arch].cpusubtype)
693
-
best_fat_arch = i;
694
-
}
695
-
if(fat_match_found)
696
-
return fat_archs + best_fat_arch;
697
-
}
698
-
}
699
-
break;
700
-
default:
701
-
return(NULL);
702
-
}
703
-
return(NULL);
704
-
}
705
-
706
-
/*
707
-
* NXCombineCpuSubtypes() returns the resulting cpusubtype when combining two
708
-
* different cpusubtypes for the specified cputype. If the two cpusubtypes
709
-
* can't be combined (the specific subtypes are mutually exclusive) -1 is
710
-
* returned indicating it is an error to combine them. This can also fail and
711
-
* return -1 if new cputypes or cpusubtypes are added and an old version of
712
-
* this routine is used. But if the cpusubtypes are the same they can always
713
-
* be combined and this routine will return the cpusubtype pass in.
714
-
*/
715
-
cpu_subtype_t
716
-
NXCombineCpuSubtypes(
717
-
cpu_type_t cputype,
718
-
cpu_subtype_t cpusubtype1,
719
-
cpu_subtype_t cpusubtype2)
720
-
{
721
-
/*
722
-
* If this is an x86_64 cputype and either subtype is the
723
-
* "Haswell and compatible" it does not combine with anything else.
724
-
*/
725
-
if(cputype == CPU_TYPE_X86_64 &&
726
-
(cpusubtype1 == CPU_SUBTYPE_X86_64_H ||
727
-
cpusubtype2 == CPU_SUBTYPE_X86_64_H))
728
-
return((cpu_subtype_t)-1);
729
-
730
-
/*
731
-
* We now combine any i386 or x86-64 subtype to the ALL subtype.
732
-
*/
733
-
if(cputype == CPU_TYPE_I386)
734
-
return(CPU_SUBTYPE_I386_ALL);
735
-
736
-
if(cputype == CPU_TYPE_X86_64)
737
-
return(CPU_SUBTYPE_X86_64_ALL);
738
-
739
-
if((cpusubtype1 & ~CPU_SUBTYPE_MASK) ==
740
-
(cpusubtype2 & ~CPU_SUBTYPE_MASK))
741
-
return(cpusubtype1);
742
-
743
-
switch(cputype){
744
-
case CPU_TYPE_MC680x0:
745
-
if((cpusubtype1 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_MC680x0_ALL &&
746
-
(cpusubtype1 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_MC68030_ONLY &&
747
-
(cpusubtype1 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_MC68040)
748
-
return((cpu_subtype_t)-1);
749
-
if((cpusubtype2 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_MC680x0_ALL &&
750
-
(cpusubtype2 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_MC68030_ONLY &&
751
-
(cpusubtype2 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_MC68040)
752
-
return((cpu_subtype_t)-1);
753
-
754
-
if((cpusubtype1 & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_MC68030_ONLY &&
755
-
(cpusubtype2 & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_MC68040)
756
-
return((cpu_subtype_t)-1);
757
-
if((cpusubtype1 & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_MC68040 &&
758
-
(cpusubtype2 & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_MC68030_ONLY)
759
-
return((cpu_subtype_t)-1);
760
-
761
-
if((cpusubtype1 & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_MC68030_ONLY ||
762
-
(cpusubtype2 & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_MC68030_ONLY)
763
-
return(CPU_SUBTYPE_MC68030_ONLY);
764
-
765
-
if((cpusubtype1 & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_MC68040 ||
766
-
(cpusubtype2 & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_MC68040)
767
-
return(CPU_SUBTYPE_MC68040);
768
-
break; /* logically can't get here */
769
-
770
-
case CPU_TYPE_POWERPC:
771
-
/*
772
-
* Combining with the ALL type becomes the other type. Combining
773
-
* anything with the 601 becomes 601. All other non exact matches
774
-
* combine to the higher value subtype.
775
-
*/
776
-
if((cpusubtype1 & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_POWERPC_ALL)
777
-
return(cpusubtype2);
778
-
if((cpusubtype2 & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_POWERPC_ALL)
779
-
return(cpusubtype1);
780
-
781
-
if((cpusubtype1 & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_POWERPC_601 ||
782
-
(cpusubtype2 & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_POWERPC_601)
783
-
return(CPU_SUBTYPE_POWERPC_601);
784
-
785
-
if((cpusubtype1 & ~CPU_SUBTYPE_MASK) >
786
-
(cpusubtype2 & ~CPU_SUBTYPE_MASK))
787
-
return(cpusubtype1);
788
-
else
789
-
return(cpusubtype2);
790
-
break; /* logically can't get here */
791
-
792
-
case CPU_TYPE_MC88000:
793
-
if((cpusubtype1 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_MC88000_ALL &&
794
-
(cpusubtype1 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_MC88110)
795
-
return((cpu_subtype_t)-1);
796
-
if((cpusubtype2 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_MC88000_ALL &&
797
-
(cpusubtype2 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_MC88110)
798
-
return((cpu_subtype_t)-1);
799
-
800
-
if((cpusubtype1 & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_MC88110 ||
801
-
(cpusubtype2 & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_MC88110)
802
-
return(CPU_SUBTYPE_MC88110);
803
-
804
-
break; /* logically can't get here */
805
-
806
-
case CPU_TYPE_I860:
807
-
if((cpusubtype1 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_I860_ALL &&
808
-
(cpusubtype1 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_I860_860)
809
-
return((cpu_subtype_t)-1);
810
-
if((cpusubtype2 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_I860_ALL &&
811
-
(cpusubtype2 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_I860_860)
812
-
return((cpu_subtype_t)-1);
813
-
814
-
if((cpusubtype1 & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_I860_860 ||
815
-
(cpusubtype2 & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_I860_860)
816
-
return(CPU_SUBTYPE_I860_860);
817
-
break; /* logically can't get here */
818
-
819
-
case CPU_TYPE_HPPA:
820
-
if((cpusubtype1 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_HPPA_ALL &&
821
-
(cpusubtype1 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_HPPA_7100LC)
822
-
return((cpu_subtype_t)-1);
823
-
if((cpusubtype2 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_HPPA_ALL &&
824
-
(cpusubtype2 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_HPPA_7100LC)
825
-
return((cpu_subtype_t)-1);
826
-
827
-
return(CPU_SUBTYPE_HPPA_7100LC);
828
-
break; /* logically can't get here */
829
-
830
-
case CPU_TYPE_SPARC:
831
-
if((cpusubtype1 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_SPARC_ALL)
832
-
return((cpu_subtype_t)-1);
833
-
if((cpusubtype2 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_SPARC_ALL)
834
-
return((cpu_subtype_t)-1);
835
-
break; /* logically can't get here */
836
-
837
-
case CPU_TYPE_ARM:
838
-
/*
839
-
* Combinability matrix for ARM:
840
-
* V4T V5 XSCALE V6 V7 ALL
841
-
* ~~~ ~~ ~~~~~~ ~~ ~~ ~~~
842
-
* V4T V4T V5 XSCALE V6 V7 ALL
843
-
* V5 V5 V5 -- V6 V7 ALL
844
-
* XSCALE XSCALE -- XSCALE -- -- ALL
845
-
* V6 V6 V6 -- V6 V7 ALL
846
-
* V7 V7 V7 -- V7 V7 ALL
847
-
* ALL ALL ALL ALL ALL ALL ALL
848
-
*/
849
-
if((cpusubtype1 & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_ARM_ALL)
850
-
return(cpusubtype2);
851
-
if((cpusubtype2 & ~CPU_SUBTYPE_MASK) == CPU_SUBTYPE_ARM_ALL)
852
-
return(cpusubtype1);
853
-
switch((cpusubtype1 & ~CPU_SUBTYPE_MASK)){
854
-
case CPU_SUBTYPE_ARM_V7:
855
-
switch((cpusubtype2 & ~CPU_SUBTYPE_MASK)){
856
-
case CPU_SUBTYPE_ARM_XSCALE:
857
-
return((cpu_subtype_t)-1);
858
-
default:
859
-
return(CPU_SUBTYPE_ARM_V7);
860
-
}
861
-
case CPU_SUBTYPE_ARM_V6:
862
-
switch((cpusubtype2 & ~CPU_SUBTYPE_MASK)){
863
-
case CPU_SUBTYPE_ARM_XSCALE:
864
-
return((cpu_subtype_t)-1);
865
-
default:
866
-
return(CPU_SUBTYPE_ARM_V6);
867
-
}
868
-
case CPU_SUBTYPE_ARM_XSCALE:
869
-
switch((cpusubtype2 & ~CPU_SUBTYPE_MASK)){
870
-
case CPU_SUBTYPE_ARM_V7:
871
-
case CPU_SUBTYPE_ARM_V6:
872
-
case CPU_SUBTYPE_ARM_V5TEJ:
873
-
return((cpu_subtype_t)-1);
874
-
default:
875
-
return(CPU_SUBTYPE_ARM_XSCALE);
876
-
}
877
-
case CPU_SUBTYPE_ARM_V5TEJ:
878
-
switch((cpusubtype2 & ~CPU_SUBTYPE_MASK)){
879
-
case CPU_SUBTYPE_ARM_XSCALE:
880
-
return((cpu_subtype_t)-1);
881
-
case CPU_SUBTYPE_ARM_V7:
882
-
return(CPU_SUBTYPE_ARM_V7);
883
-
case CPU_SUBTYPE_ARM_V6:
884
-
return(CPU_SUBTYPE_ARM_V6);
885
-
default:
886
-
return(CPU_SUBTYPE_ARM_V5TEJ);
887
-
}
888
-
case CPU_SUBTYPE_ARM_V4T:
889
-
return((cpusubtype2 & ~CPU_SUBTYPE_MASK));
890
-
default:
891
-
return((cpu_subtype_t)-1);
892
-
}
893
-
894
-
case CPU_TYPE_ARM64:
895
-
if((cpusubtype1 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_ARM64_ALL)
896
-
return((cpu_subtype_t)-1);
897
-
if((cpusubtype2 & ~CPU_SUBTYPE_MASK) != CPU_SUBTYPE_ARM64_ALL)
898
-
return((cpu_subtype_t)-1);
899
-
break; /* logically can't get here */
900
-
901
-
default:
902
-
return((cpu_subtype_t)-1);
903
-
}
904
-
return((cpu_subtype_t)-1); /* logically can't get here */
905
-
}
906
-
#endif /* !defined(RLD) */