this repo has no description
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

A few build fixes

+8 -909
+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
··· 26 26 #include <mach-o/swap.h> 27 27 #include <string.h> 28 28 29 + #ifndef FALSE 30 + #define FALSE 0 31 + #endif 32 + 29 33 void 30 34 swap_fat_header( 31 35 struct fat_header *fat_header,
+1 -1
src/libsystem/CMakeLists.txt
··· 27 27 set(libsystem_sources 28 28 init.c 29 29 dummy.c 30 - libmacho/arch.c 30 + CompatibilityHacks.c 31 31 ) 32 32 33 33 SET(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}/darling")
-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) */