1# -*- mode: makefile;-*- 2# 3# Copyright (C) 1999-2023 Apple Inc. All rights reserved. 4# 5# MakeInc.def contains global definitions for building, 6# linking, and installing files. 7# 8 9# 10# Architecture Configuration options 11# 12SUPPORTED_ARCH_CONFIGS := X86_64 X86_64H ARM64 13 14# 15# Kernel Configuration options 16# 17SUPPORTED_KERNEL_CONFIGS = RELEASE DEVELOPMENT DEBUG PROFILE KASAN SPTM 18 19 20# 21# Machine Configuration options 22# 23 24SUPPORTED_X86_64_MACHINE_CONFIGS = NONE 25SUPPORTED_X86_64H_MACHINE_CONFIGS = NONE 26 27ifneq ($(findstring _Sim,$(RC_ProjectName)),) 28SUPPORTED_ARM64_MACHINE_CONFIGS = NONE 29else ifneq ($(findstring _host,$(RC_ProjectName)),) 30SUPPORTED_ARM64_MACHINE_CONFIGS = NONE 31else 32SUPPORTED_ARM64_MACHINE_CONFIGS = T6000 T6020 T6030 T6031 T8101 T8103 T8112 T8122 T8132 VMAPPLE 33 34SPTM_ENABLED_SOCS_MacOSX = t8132 35endif 36 37# 38# Setup up *_LC variables during recursive invocations 39# 40 41ifndef CURRENT_ARCH_CONFIG_LC 42 export CURRENT_ARCH_CONFIG_LC := $(shell printf "%s" "$(CURRENT_ARCH_CONFIG)" | $(TR) A-Z a-z) 43endif 44 45ifndef CURRENT_KERNEL_CONFIG_LC 46 export CURRENT_KERNEL_CONFIG_LC := $(shell printf "%s" "$(CURRENT_KERNEL_CONFIG)" | $(TR) A-Z a-z) 47endif 48 49ifndef CURRENT_MACHINE_CONFIG_LC 50 export CURRENT_MACHINE_CONFIG_LC := $(shell printf "%s" "$(CURRENT_MACHINE_CONFIG)" | $(TR) A-Z a-z) 51endif 52 53# Enable BTI by default for all ARM64 targets 54BTI_BUILD = 1 55 56 57# -mkernel contains BTI by default 58ifeq ($(BTI_BUILD),1) 59 BTI_BUILD_FLAGS = -DXNU_BUILT_WITH_BTI 60else 61 BTI_BUILD_FLAGS = -fno-branch-target-identification -UXNU_BUILT_WITH_BTI 62endif 63 64# 65# Component List 66# 67COMPONENT_LIST = osfmk bsd libkern iokit pexpert libsa security san 68COMPONENT = $(if $(word 2,$(subst /, ,$(RELATIVE_SOURCE_PATH))),$(word 2,$(subst /, ,$(RELATIVE_SOURCE_PATH))),$(firstword $(subst /, ,$(RELATIVE_SOURCE_PATH)))) 69COMPONENT_IMPORT_LIST = $(filter-out $(COMPONENT),$(COMPONENT_LIST)) 70 71MACHINE_FLAGS_ARM64_T8101 = -DARM64_BOARD_CONFIG_T8101 -mcpu=apple-a14 72MACHINE_FLAGS_ARM64_T8103 = -DARM64_BOARD_CONFIG_T8103 -mcpu=apple-a14 73MACHINE_FLAGS_ARM64_T6000 = -DARM64_BOARD_CONFIG_T6000 -mcpu=apple-a14 74MACHINE_FLAGS_ARM64_T6020 = -DARM64_BOARD_CONFIG_T6020 -mcpu=apple-a15 75MACHINE_FLAGS_ARM64_T8112 = -DARM64_BOARD_CONFIG_T8112 -mcpu=apple-a15 76MACHINE_FLAGS_ARM64_T6030 = -DARM64_BOARD_CONFIG_T6030 -mcpu=apple-a16 77MACHINE_FLAGS_ARM64_T6031 = -DARM64_BOARD_CONFIG_T6031 -mcpu=apple-a16 78MACHINE_FLAGS_ARM64_T8122 = -DARM64_BOARD_CONFIG_T8122_T8130 -mcpu=apple-a16 79MACHINE_FLAGS_ARM64_T8132 = -DARM64_BOARD_CONFIG_T8132 -mcpu=apple-acc7 80MACHINE_FLAGS_ARM64_VMAPPLE = -DARM64_BOARD_CONFIG_VMAPPLE -march=armv8.5a+sme2 81 82 83# 84# Deployment target flag 85# 86ifeq ($(PLATFORM),MacOSX) 87 DEPLOYMENT_TARGET_FLAGS = -mmacosx-version-min=$(SDKVERSION) -DXNU_TARGET_OS_OSX 88 DEPLOYMENT_LINKER_FLAGS = -Wl,-macosx_version_min,$(SDKVERSION) 89else ifeq ($(PLATFORM),DriverKit) 90 DEPLOYMENT_TARGET_FLAGS = -target apple-driverkit$(SDKVERSION) -DXNU_TARGET_OS_OSX 91 DEPLOYMENT_LINKER_FLAGS = -Wl,-target,apple-driverkit$(SDKVERSION) 92else ifeq ($(PLATFORM),WatchOS) 93 DEPLOYMENT_TARGET_FLAGS = -mwatchos-version-min=$(SDKVERSION) -DXNU_TARGET_OS_WATCH 94 DEPLOYMENT_LINKER_FLAGS = 95else ifeq ($(PLATFORM),tvOS) 96 DEPLOYMENT_TARGET_FLAGS = -mtvos-version-min=$(SDKVERSION) -DXNU_TARGET_OS_TV 97 DEPLOYMENT_LINKER_FLAGS = 98else ifeq ($(PLATFORM),AppleTVOS) 99 DEPLOYMENT_TARGET_FLAGS = -mtvos-version-min=$(SDKVERSION) -DXNU_TARGET_OS_TV 100else ifeq ($(PLATFORM),BridgeOS) 101 DEPLOYMENT_TARGET_FLAGS = -mbridgeos-version-min=$(SDKVERSION) -DXNU_TARGET_OS_BRIDGE 102 DEPLOYMENT_LINKER_FLAGS = 103else ifneq ($(filter $(SUPPORTED_EMBEDDED_PLATFORMS),$(PLATFORM)),) 104 DEPLOYMENT_TARGET_FLAGS = -miphoneos-version-min=$(SDKVERSION) -DXNU_TARGET_OS_IOS 105 DEPLOYMENT_LINKER_FLAGS = -Wl,-ios_version_min,$(SDKVERSION) 106else ifneq ($(filter $(SUPPORTED_SIMULATOR_PLATFORMS),$(PLATFORM)),) 107 DEPLOYMENT_TARGET_FLAGS = 108 DEPLOYMENT_LINKER_FLAGS = 109else 110 DEPLOYMENT_TARGET_FLAGS = 111 DEPLOYMENT_LINKER_FLAGS = 112endif 113 114 115DEPLOYMENT_TARGET_DEFINES = -DXNU_PLATFORM_$(PLATFORM) 116 117 118# 119# Standard defines list 120# 121DEFINES = -DAPPLE -DKERNEL -DKERNEL_PRIVATE -DXNU_KERNEL_PRIVATE \ 122 -DPRIVATE -D__MACHO__=1 -Dvolatile=__volatile -DXNU_KERN_EVENT_DATA_IS_VLA \ 123 -DCURRENT_MACHINE_CONFIG_LC=$(CURRENT_MACHINE_CONFIG_LC) \ 124 $(CONFIG_DEFINES) $(SEED_DEFINES) 125 126# Enable caching with `make CCACHE=ccache` 127# This intentionally does not override $(CC) because that will confuse 128# utilities like mig. 129CCACHE ?= 130 131# 132# Compiler command 133# 134KCC = $(CCACHE) $(CC) 135KC++ = $(CCACHE) $(CXX) 136 137GENASSYM_KCC = $(CCACHE) $(CC) 138 139# 140# Compiler warning flags 141# 142 143USE_WERROR := 1 144ifneq ($(BUILD_WERROR),) 145USE_WERROR := $(BUILD_WERROR) 146endif 147 148ifeq ($(USE_WERROR),1) 149WERROR := -Werror 150endif 151 152# Shared C/C++ warning flags 153# NOTE: order matters here. -Wno-xxx goes before opt-in of ones we want 154WARNFLAGS_STD := \ 155 -Weverything \ 156 -Wundef-prefix=TARGET_OS_ \ 157 -Wundef-prefix=LCK_GRP_USE_ARG \ 158 -Wno-pedantic \ 159 $(WERROR) \ 160 -Wno-bad-function-cast \ 161 -Wno-bitwise-instead-of-logical \ 162 -Wno-c++-compat \ 163 -Wno-c++98-compat \ 164 -Wno-conditional-uninitialized \ 165 -Wno-covered-switch-default \ 166 -Wno-disabled-macro-expansion \ 167 -Wno-documentation-unknown-command \ 168 -Wno-extra-semi-stmt \ 169 -Wno-format-non-iso \ 170 -Wno-language-extension-token \ 171 -Wno-missing-variable-declarations \ 172 -Wno-packed \ 173 -Wno-padded \ 174 -Wno-partial-availability \ 175 -Wno-reserved-id-macro \ 176 -Wno-shift-sign-overflow \ 177 -Wno-switch-enum \ 178 -Wno-unaligned-access \ 179 -Wno-undef \ 180 -Wno-invalid-offsetof \ 181 -Wno-unused-macros \ 182 -Wno-used-but-marked-unused \ 183 -Wno-variadic-macros \ 184 -Wno-zero-length-array \ 185 -Wno-packed \ 186 -Wno-cast-function-type-strict \ 187 -Wno-incompatible-function-pointer-types-strict 188 189# When a new clang has new warnings disable them here until the kernel is fixed. 190WARNFLAGS_STD := $(WARNFLAGS_STD) \ 191 -Wno-unknown-warning-option \ 192 -Wno-anon-enum-enum-conversion \ 193 -Wno-error=enum-enum-conversion \ 194 -Wno-error=c99-designator \ 195 -Wno-error=reorder-init-list \ 196 -Wno-error=switch-default \ 197 -Wno-deprecated-volatile \ 198 -Wno-error=incompatible-function-pointer-types-strict \ 199 -Wno-cast-function-type-strict 200 201WARNFLAGS_STD := $(WARNFLAGS_STD) \ 202 -Wno-declaration-after-statement 203 204# Hand-written sign conversion diagnostics are resolved, but the 205# auto-generated ones need mig and iig to be updated to fix. Disable the 206# diagnostic here until we've completed that: 207WARNFLAGS_STD := $(WARNFLAGS_STD) \ 208 -Wno-sign-compare \ 209 -Wno-sign-conversion 210 211# Opt-ins: 212WARNFLAGS_STD := $(WARNFLAGS_STD) \ 213 -Wpointer-arith \ 214 -Wxnu-typed-allocators 215 216CWARNFLAGS_STD = \ 217 $(WARNFLAGS_STD) 218 219 220 221# Can be overridden in Makefile.template or Makefile.$arch 222export CWARNFLAGS ?= $(CWARNFLAGS_STD) 223 224define add_perfile_cflags 225$(1)_CWARNFLAGS_ADD += $2 226endef 227 228define rm_perfile_cflags 229$(1)_CFLAGS_RM += $2 230endef 231 232CXXWARNFLAGS_STD = \ 233 $(WARNFLAGS_STD) \ 234 -Wno-c++98-compat-pedantic \ 235 -Wno-exit-time-destructors \ 236 -Wno-global-constructors \ 237 -Wno-old-style-cast 238 239# Can be overridden in Makefile.template or Makefile.$arch 240export CXXWARNFLAGS ?= $(CXXWARNFLAGS_STD) 241 242define add_perfile_cxxflags 243$(1)_CXXWARNFLAGS_ADD += $2 244endef 245 246# 247# Default ARCH_FLAGS, for use with compiler/linker/assembler/mig drivers 248 249ARCH_FLAGS_X86_64 = -arch x86_64 250ARCH_FLAGS_X86_64H = -arch x86_64h 251 252ifeq ($(RC_ProjectName),xnu_libraries) 253BUILD_STATIC_LINK := 1 254BUILD_XNU_LIBRARY := 1 255RC_NONARCH_CFLAGS += -D__BUILDING_XNU_LIBRARY__=1 256endif 257 258ifneq ($(filter ARM ARM64,$(CURRENT_ARCH_CONFIG)),) 259 260ifneq ($(findstring _Sim,$(RC_ProjectName)),) 261ARCH_FLAGS_ARM64 = -arch arm64e 262else ifneq ($(findstring _host,$(RC_ProjectName)),) 263ARCH_FLAGS_ARM64 = -arch arm64e 264else 265 266ARCH_STRING_FOR_CURRENT_MACHINE_CONFIG ?= 267 268ifeq ($(ARCH_STRING_FOR_CURRENT_MACHINE_CONFIG),) 269 270ifneq ($(EMBEDDED_DEVICE_MAP),) 271export ARCH_STRING_FOR_CURRENT_MACHINE_CONFIG := $(shell $(EMBEDDED_DEVICE_MAP) -db $(EDM_DBPATH) -list -query SELECT DISTINCT KernelMachOArchitecture FROM Targets WHERE KernelPlatform IS \"$(CURRENT_MACHINE_CONFIG_LC)\" LIMIT 1 || echo UNKNOWN ) 272ifeq ($(ARCH_STRING_FOR_CURRENT_MACHINE_CONFIG),) 273ifeq ($(filter $(EXTRA_TARGET_CONFIGS_$(CURRENT_KERNEL_CONFIG)),$(CURRENT_MACHINE_CONFIG)),) 274$(error Machine config $(CURRENT_MACHINE_CONFIG_LC) not found in EmbeddedDeviceMap) 275endif 276endif 277endif 278 279endif 280 281ifeq ($(ARCH_STRING_FOR_CURRENT_MACHINE_CONFIG),) 282 283# Without embdedded device map, use a default arch string 284export ARCH_STRING_FOR_CURRENT_MACHINE_CONFIG := $(shell echo $(CURRENT_ARCH_CONFIG) | tr A-Z a-z) 285ifneq ($(filter arm64,$(ARCH_STRING_FOR_CURRENT_MACHINE_CONFIG)),) 286export ARCH_STRING_FOR_CURRENT_MACHINE_CONFIG := arm64e 287endif 288 289endif 290 291 292BUILD_STATIC_LINK := 1 293 294ARCH_FLAGS_ARM64 = -arch $(ARCH_STRING_FOR_CURRENT_MACHINE_CONFIG) 295 296endif 297 298else 299# non arm machine config string 300ifndef ARCH_STRING_FOR_CURRENT_MACHINE_CONFIG 301export ARCH_STRING_FOR_CURRENT_MACHINE_CONFIG := $(shell echo $(CURRENT_ARCH_CONFIG) | tr A-Z a-z) 302endif 303 304endif 305 306# 307# Default CFLAGS 308# 309ifdef RC_NONARCH_CFLAGS 310OTHER_CFLAGS = $(RC_NONARCH_CFLAGS) 311endif 312 313# 314# Debug info 315# 316DSYMINFODIR = Contents 317DSYMKGMACROSDIR = Contents/Resources 318DSYMLLDBMACROSDIR = Contents/Resources/Python 319DSYMDWARFDIR = Contents/Resources/DWARF 320 321DEBUG_CFLAGS := -g 322BUILD_DSYM := 1 323 324# 325# We must not use -fno-keep-inline-functions, or it will remove the dtrace 326# probes from the kernel. 327# 328CFLAGS_GEN = $(DEBUG_CFLAGS) -nostdlibinc \ 329 -ferror-limit=10000 \ 330 -fno-builtin \ 331 -fno-common \ 332 -ftrivial-auto-var-init=zero \ 333 -fsigned-bitfields \ 334 -fmerge-all-constants \ 335 -fno-c++-static-destructors \ 336 $(OTHER_CFLAGS) 337 338CFLAGS_RELEASE = 339CFLAGS_DEVELOPMENT = 340CFLAGS_DEBUG = 341CFLAGS_KASAN = $(CFLAGS_DEVELOPMENT) 342CFLAGS_PROFILE = -pg 343 344CFLAGS_X86_64 = -Dx86_64 -DX86_64 -D__X86_64__ -DLP64 \ 345 -DPAGE_SIZE_FIXED -mkernel -msoft-float 346 347CFLAGS_X86_64H = $(CFLAGS_X86_64) 348 349LARGE_MEMORY_DEFINE=-UARM_LARGE_MEMORY 350ARM64_PLKSEG_ADDR =0xfffffff004004000 351ARM64_LINK_ADDR =0xfffffff007004000 352 353# Use ARM_LARGE_MEMORY config for all MacOSX targets. 354ifneq ($(filter $(PLATFORM),MacOSX),) 355LARGE_MEMORY_DEFINE=-DARM_LARGE_MEMORY=1 356ARM64_PLKSEG_ADDR =0xfffffe0004004000 357ARM64_LINK_ADDR =0xfffffe0007004000 358endif 359 360 361CFLAGS_ARM64 = -Darm64 -DARM64 -D__ARM64__ -DLP64 -DPAGE_SIZE_FIXED -DVM_KERNEL_LINK_ADDRESS=$(ARM64_LINK_ADDR) \ 362 $(LARGE_MEMORY_DEFINE) -momit-leaf-frame-pointer -fno-strict-aliasing -D__API__=v4 -mkernel \ 363 $(BTI_BUILD_FLAGS) 364 365CXXFLAGS_ARM64 = $(BTI_BUILD_FLAGS) 366 367CFLAGS_RELEASEX86_64 = -O2 368CFLAGS_DEVELOPMENTX86_64 = -O2 369CFLAGS_KASANX86_64 = $(CFLAGS_DEVELOPMENTX86_64) 370# No space optimization for the DEBUG kernel for the benefit of gdb: 371CFLAGS_DEBUGX86_64 = -O0 372CFLAGS_PROFILEX86_64 = -O2 373 374CFLAGS_RELEASEX86_64H = -O2 375CFLAGS_DEVELOPMENTX86_64H = -O2 376CFLAGS_KASANX86_64H = $(CFLAGS_DEVELOPMENTX86_64H) 377# No space optimization for the DEBUG kernel for the benefit of gdb: 378CFLAGS_DEBUGX86_64H = -O0 379CFLAGS_PROFILEX86_64H = -O2 380 381CFLAGS_RELEASEARM = -O2 382CFLAGS_DEVELOPMENTARM = -O2 383CFLAGS_DEBUGARM = -O0 384CFLAGS_PROFILEARM = -O2 385 386CFLAGS_RELEASEARM64 = -O2 387CFLAGS_DEVELOPMENTARM64 = -O2 388CFLAGS_KASANARM64 = $(CFLAGS_DEVELOPMENTARM64) 389CFLAGS_DEBUGARM64 = -O0 390CFLAGS_SPTMARM64 = $(CFLAGS_DEVELOPMENTARM64) 391CFLAGS_PROFILEARM64 = -O2 392 393# 394# bound-checking support 395# 396# BOUND_CHECKS=0 disables, else support is dynamically detected. 397# Intel is currently disabled. 398# 399ifndef BOUND_CHECKS 400ifeq ($(shell $(CC) -E -fbounds-safety /dev/null 2>/dev/null && echo 1),1) 401 ifeq ($(CURRENT_ARCH_CONFIG_LC),x86_64) 402 export BOUND_CHECKS := 0 403 export CFLAGS_BOUND_CHECKS = -Wno-error=self-assign 404 else 405 export BOUND_CHECKS := 1 406 endif 407else 408 export BOUND_CHECKS := 0 409endif 410endif # ifndef BOUND_CHECKS 411ifeq ($(BOUND_CHECKS),1) 412CFLAGS_BOUND_CHECKS = -fbounds-safety 413else 414CFLAGS_BOUND_CHECKS ?= 415endif 416 417CFLAGS_BOUND_CHECKS_PENDING = -DBOUND_CHECKS_PENDING=1 -Wno-self-assign 418 419# Bounds-safety adoption mode 420# 421# * Tells Clang to run in bounds-safety adoption mode which is allowed to 422# produce better diagnostics but a slower build. 423# * Doesn't try to suppress any warnings in staging (see Bounds-safety warning 424# staging) 425# 426BOUNDS_SAFETY_ADOPTION_MODE ?= 0 427ifeq ($(BOUNDS_SAFETY_ADOPTION_MODE),1) 428 ifneq ($(BOUND_CHECKS),1) 429 $(error BOUNDS_SAFETY_ADOPTION_MODE cannot be enabled when BOUND_CHECKS=0) 430 endif 431 ifeq ($(RC_XBS),YES) 432 # This mode should **only** be used at engineers' desks and not in B&I 433 # builds because it may add compile-time overhead. 434 $(error BOUNDS_SAFETY_ADOPTION_MODE should not be enabled in B&I builds) 435 endif 436 CFLAGS_BOUND_CHECKS += -fbounds-safety-adoption-mode 437endif 438 439# Bounds-safety warning staging 440# 441# To prevent new bounds-safety warnings in a soon to be submitted Clang from 442# breaking the build they can be explicitly be prevented from being errors by 443# adding `-Wno-error=<new_warning_name>` to 444# `BOUNDS_SAFETY_DOWNGRADED_UPCOMING_WARNFLAGS`. 445# 446# A warning in `BOUNDS_SAFETY_DOWNGRADED_UPCOMING_WARNFLAGS` should be 447# removed once the new Clang with the warning is in the OS and the code builds 448# without it firing. 449# 450BOUNDS_SAFETY_DOWNGRADED_UPCOMING_WARNFLAGS = 451 452ifneq ($(words $(BOUNDS_SAFETY_DOWNGRADED_UPCOMING_WARNFLAGS)),0) 453 ifeq ($(BOUNDS_SAFETY_ADOPTION_MODE),0) 454 # Note this implicitly relies on `-Wno-unknown-warning-option` already being 455 # passed to the compiler. 456 CFLAGS_BOUND_CHECKS += $(BOUNDS_SAFETY_DOWNGRADED_UPCOMING_WARNFLAGS) 457 endif 458endif 459 460# Check whether soft trap is supported 461ifndef BOUND_CHECKS_SOFT 462ifeq ($(shell $(CC) -E -ftrap-function-returns /dev/null 2>/dev/null && echo 1),1) 463 export BOUND_CHECKS_SOFT := 1 464else 465 export BOUND_CHECKS_SOFT := 0 466endif 467endif # ifndef BOUND_CHECKS_SOFT 468ifeq ($(BOUND_CHECKS_SOFT),1) 469CFLAGS_BOUND_CHECKS_SOFT = -fbounds-safety -ftrap-function=ml_bound_chk_soft_trap -ftrap-function-returns 470CFLAGS_BOUND_CHECKS_DEBUG = $(CFLAGS_BOUND_CHECKS_SOFT) -DBOUND_CHECKS_DEBUG=1 471else 472CFLAGS_BOUND_CHECKS_SOFT = 473CFLAGS_BOUND_CHECKS_DEBUG = 474endif 475 476# 477# Sanitizers Support (KASan, UBSan) 478# 479 480# Which kernel configurations are built with KCOV enabled. 481KCOV_RUNTIME := KASAN 482 483ifneq ($(filter RELEASE, $(KCOV_RUNTIME)),) 484$(error "Sanitizer runtime should not be enabled for RELEASE kernel.") 485endif 486 487 488SAN=0 489 490# KASan support 491# 492 493ifeq ($(CURRENT_KERNEL_CONFIG),KASAN) 494# KASan kernel config implicitly enables the KASan instrumentation. 495# Instrumentation for other sanitizers is enabled explicitly at build time. 496KASAN = 1 497endif 498 499ifeq ($(KASAN),1) 500SAN=1 501BUILD_LTO=0 502 503# KASan Light support 504# 505# Light mode omits the HWASAN stack instrumentation. 506# Not supported by KASan Classic at this moment. 507 508KASAN_LIGHT_PLATFORM := WatchOS 509 510ifneq ($(filter $(PLATFORM), $(KASAN_LIGHT_PLATFORM)),) 511KASAN_LIGHT=1 512HWASAN_INSTRUMENT_STACK=0 513else 514KASAN_LIGHT=0 515HWASAN_INSTRUMENT_STACK=1 516endif 517 518KASAN_BLACKLIST=$(OBJROOT)/san/kasan-blacklist-$(CURRENT_ARCH_CONFIG_LC) 519 520# To calculate the kasan offset, subtract the lowest KVA to sanitize, shifted right by KASAN_SCALE_$INSTRUMENTATION bits, 521# from the base address of the kasan shadow area, (e.g. for x86_64 solve the following equation: 522# OFFSET = {VA mapped by the first KASAN PML4 [Currently #494]} - (LOWEST_KVA >> 3) 523# OFFSET = (0ULL - (512GiB * (512 - 494))) - (LOWEST_SAN_KVA >> 3) 524# OFFSET = FFFFF70000000000 - ((0ULL - (512GiB * (512 - 496))) >> 3) [PML4 #496 is the first possible KVA] 525# OFFSET = FFFFF70000000000 - (FFFFF80000000000 >> 3) 526# OFFSET = DFFFF80000000000 527# ). 528KASAN_OFFSET_X86_64=0xdffff80000000000 529KASAN_OFFSET_X86_64H=$(KASAN_OFFSET_X86_64) 530KASAN_OFFSET_ARM64=0xf000000000000000 531 532KASAN_OFFSET=$($(addsuffix $(CURRENT_ARCH_CONFIG),KASAN_OFFSET_)) 533 534# CLANG HWASAN/KHWASAN instrumentation powers KASAN_TBI. HWASAN traditional prefixing 535# is replaced by __asan_ to commonize exports across models. 536KASAN_SCALE_TBI=4 537CFLAGS_KASAN_INSTRUMENTATION_TBI = -DKASAN_TBI=1 -DKASAN_SCALE=$(KASAN_SCALE_TBI) \ 538 -fsanitize=kernel-hwaddress \ 539 -fsanitize-ignorelist=$(KASAN_BLACKLIST) \ 540 -mllvm -hwasan-recover=0 \ 541 -mllvm -hwasan-mapping-offset=$(KASAN_OFFSET) \ 542 -mllvm -hwasan-instrument-atomics=1 \ 543 -mllvm -hwasan-instrument-stack=$(HWASAN_INSTRUMENT_STACK) \ 544 -mllvm -hwasan-generate-tags-with-calls=1 \ 545 -mllvm -hwasan-instrument-with-calls=0 \ 546 -mllvm -hwasan-use-short-granules=0 \ 547 -mllvm -hwasan-memory-access-callback-prefix="__asan_" 548 549 550KASAN_SCALE_CLASSIC=3 551CFLAGS_KASAN_INSTRUMENTATION_CLASSIC = -DKASAN_CLASSIC=1 -DKASAN_SCALE=$(KASAN_SCALE_CLASSIC) \ 552 -fsanitize=address \ 553 -mllvm -asan-globals-live-support \ 554 -mllvm -asan-mapping-offset=$(KASAN_OFFSET) \ 555 -fsanitize-ignorelist=$(KASAN_BLACKLIST) 556 557CFLAGS_KASANARM64 += $(CFLAGS_KASAN_INSTRUMENTATION_TBI) 558CFLAGS_KASANX86_64 += $(CFLAGS_KASAN_INSTRUMENTATION_CLASSIC) 559CFLAGS_KASANX86_64H += $(CFLAGS_KASAN_INSTRUMENTATION_CLASSIC) 560CFLAGS_GEN += -DKASAN=1 -DKASAN_OFFSET=$(KASAN_OFFSET) -DKASAN_LIGHT=$(KASAN_LIGHT) 561 562SFLAGS_KASANARM64 += $(CFLAGS_KASAN_INSTRUMENTATION_TBI) 563SFLAGS_KASANX86_64 += $(CFLAGS_KASAN_INSTRUMENTATION_CLASSIC) 564SFLAGS_KASANX86_64H += $(CFLAGS_KASAN_INSTRUMENTATION_CLASSIC) 565SFLAGS_GEN += -DKASAN=1 -DKASAN_OFFSET=$(KASAN_OFFSET) -DKASAN_LIGHT=$(KASAN_LIGHT) 566 567endif 568 569# UBSan 570# 571# The Undefined Behavior sanitizer runtime is always built as part of, and only for, 572# KASAN variants. UBSan instrumentation is disabled by default and only enabled explicitly 573# when building with UBSAN=1. 574# 575# On iOS RELEASE and DEVELOPMENT kernels, a subset of UBSan checks is enabled along with a minimal 576# runtime that emulates trap mode (but makes it recoverable). 577 578ifeq ($(KASAN), 1) 579 580ifeq ($(UBSAN),1) 581SAN=1 582 583UBSAN_RUNTIME = 584UBSAN_CHECKS += signed-integer-overflow shift pointer-overflow bounds object-size # non-fatal (calls runtime, can return) 585# UBSAN_CHECKS = undefined nullability unsigned-integer-overflow # everything 586UBSAN_CHECKS_FATAL = # fatal (calls runtime, must not return) 587UBSAN_CHECKS_TRAP = vla-bound builtin # emit a trap instruction (no runtime support) 588UBSAN_DISABLED += vptr function # requires unsupported C++ runtime 589 590# UBSan alignment + KASan code size is too large 591# UBSan unreachable doesn't play nice with ASan (40723397) 592UBSAN_DISABLED += alignment unreachable 593 594endif 595 596else 597 598# DEVELOPMENT and RELEASE variants 599ifeq ($(PLATFORM),iPhoneOS) 600 601# Currently we have to keep alive two separated UBSAN runtimes (minimal for DEVELOPMENT, 602# full for KASAN). This implies that we cannot use CFLAGS_$(CURRENT_KERNEL_CONFIG), because 603# CFLAGS_DEVELOPMENT is folded into CFLAGS_KASAN. For the time being we leave this check here, 604# as we work (independently) to both break the CFLAGS direct dependency and commonize the 605# sanitizer runtimes. 606UBSAN_MINIMAL_RUNTIME := DEVELOPMENT DEBUG 607ifneq ($(filter $(CURRENT_KERNEL_CONFIG), $(UBSAN_MINIMAL_RUNTIME)),) 608 609# This is (unfortunately) intentional. Currently the "kasan" blacklist, which folds both 610# ubsan and kasan specific files, is generated for all builds during the 611# setup phase. The blacklist file itself is divided per-sanitizer, so won't 612# affect the UBSAN build outside of the entries that are legitimately 613# intended for it. 614UBSAN_BLACKLIST=$(OBJROOT)/san/kasan-blacklist-$(CURRENT_ARCH_CONFIG_LC) 615 616UBSAN_CHECKS = signed-integer-overflow 617UBSAN_RUNTIME = -fsanitize-minimal-runtime -fsanitize-ignorelist=$(UBSAN_BLACKLIST) 618UBSAN_CHECKS_TRAP = 619UBSAN_CHECKS_FATAL = 620UBSAN_DISABLED = 621endif 622endif 623 624endif 625 626CFLAGS_GEN += $(UBSAN_RUNTIME) 627CFLAGS_GEN += $(foreach x,$(UBSAN_CHECKS) $(UBSAN_CHECKS_FATAL) $(UBSAN_CHECKS_TRAP),-fsanitize=$(x)) 628CFLAGS_GEN += $(foreach x,$(UBSAN_CHECKS_FATAL),-fno-sanitize-recover=$(x)) 629CFLAGS_GEN += $(foreach x,$(UBSAN_CHECKS_TRAP),-fsanitize-trap=$(x)) 630CFLAGS_GEN += $(foreach x,$(UBSAN_DISABLED),-fno-sanitize=$(x)) 631 632ifeq ($(KSANCOV),1) 633# Enable SanitizerCoverage instrumentation in xnu 634SAN = 1 635KCOV_BLACKLIST := $(OBJROOT)/san/kcov-blacklist-$(CURRENT_ARCH_CONFIG_LC) 636KCOV_CFLAGS := -fsanitize-coverage=trace-pc-guard -fsanitize-coverage-ignorelist=$(KCOV_BLACKLIST) 637CFLAGS_GEN += $(KCOV_CFLAGS) -DKSANCOV=1 638endif 639 640ifeq ($(SAN),1) 641CFLAGS_GEN += -fsanitize-ignorelist=$(OBJROOT)/san/kasan-blacklist-$(CURRENT_ARCH_CONFIG_LC) 642endif 643 644# Any extra flags that get passed at the command line during build. 645ifeq ($(CFLAGS_EXTRA),) 646CFLAGS_EXTRA = 647endif 648 649CFLAGS = $(CFLAGS_GEN) \ 650 $($(addsuffix $(CURRENT_MACHINE_CONFIG),MACHINE_FLAGS_$(CURRENT_ARCH_CONFIG)_)) \ 651 $($(addsuffix $(CURRENT_ARCH_CONFIG),ARCH_FLAGS_)) \ 652 $($(addsuffix $(CURRENT_ARCH_CONFIG),CFLAGS_)) \ 653 $($(addsuffix $(CURRENT_KERNEL_CONFIG),CFLAGS_)) \ 654 $($(addsuffix $(CURRENT_ARCH_CONFIG), $(addsuffix $(CURRENT_KERNEL_CONFIG),CFLAGS_))) \ 655 $(DEPLOYMENT_TARGET_FLAGS) \ 656 $(DEPLOYMENT_TARGET_DEFINES) \ 657 $(DEFINES) \ 658 $(CFLAGS_EXTRA) 659 660# 661# Default C++ flags 662# 663 664OTHER_CXXFLAGS = 665 666CXXFLAGS_GEN = -std=gnu++2b -fsized-deallocation -fapple-kext $(OTHER_CXXFLAGS) 667 668CXXFLAGS = $(CXXFLAGS_GEN) \ 669 $($(addsuffix $(CURRENT_ARCH_CONFIG),CXXFLAGS_)) \ 670 $($(addsuffix $(CURRENT_KERNEL_CONFIG),CXXFLAGS_)) 671 672# 673# Assembler command 674# 675AS = $(CCACHE) $(CC) 676S_KCC = $(CC) 677 678# 679# Default SFLAGS 680# 681SFLAGS_GEN = -D__ASSEMBLER__ -DASSEMBLER $(OTHER_CFLAGS) 682 683SFLAGS_RELEASE = 684SFLAGS_DEVELOPMENT = 685 686# When making non-compatible changes to the XNU runtime, it can be useful to build 687# a KASAN kernel + runtime, but linked against a DEVELOPMENT kernel cache. 688# Uncomment the lines below to be able to build development, but passing KASAN=1. 689# #_ifeq ($(KASAN),1) 690# SFLAGS_DEVELOPMENT += -DKASAN=1 691# #_endif 692 693SFLAGS_KASAN = $(SFLAGS_DEVELOPMENT) -DKASAN=1 694SFLAGS_DEBUG = 695SFLAGS_PROFILE = 696 697SFLAGS_X86_64 = $(CFLAGS_X86_64) 698SFLAGS_X86_64H = $(CFLAGS_X86_64H) 699SFLAGS_ARM64 = $(CFLAGS_ARM64) 700 701SFLAGS = $(SFLAGS_GEN) \ 702 $($(addsuffix $(CURRENT_MACHINE_CONFIG),MACHINE_FLAGS_$(CURRENT_ARCH_CONFIG)_)) \ 703 $($(addsuffix $(CURRENT_ARCH_CONFIG),ARCH_FLAGS_)) \ 704 $($(addsuffix $(CURRENT_ARCH_CONFIG),SFLAGS_)) \ 705 $($(addsuffix $(CURRENT_KERNEL_CONFIG),SFLAGS_)) \ 706 $($(addsuffix $(CURRENT_ARCH_CONFIG), $(addsuffix $(CURRENT_KERNEL_CONFIG),SFLAGS_))) \ 707 $(DEPLOYMENT_TARGET_FLAGS) \ 708 $(DEPLOYMENT_TARGET_DEFINES) \ 709 $(DEFINES) 710 711# 712# Linker command 713# 714LD = $(KC++) -nostdlib 715 716# 717# Default LDFLAGS 718# 719# Availability of DWARF allows DTrace CTF (compressed type format) to be constructed. 720# ctf_insert creates the CTF section. It needs reserved padding in the 721# headers for the load command segment and the CTF section structures. 722# 723LDFLAGS_KERNEL_GEN = \ 724 -nostdlib \ 725 -fapple-kext \ 726 -Wl,-e,__start \ 727 -Wl,-sectalign,__TEXT,__text,0x1000 \ 728 -Wl,-sectalign,__DATA,__common,0x1000 \ 729 -Wl,-sectalign,__DATA,__bss,0x1000 \ 730 -Wl,-sectcreate,__PRELINK_TEXT,__text,/dev/null \ 731 -Wl,-segprot,__PRELINK_TEXT,r-x,r-x \ 732 -Wl,-sectcreate,__PRELINK_INFO,__info,/dev/null \ 733 -Wl,-new_linker \ 734 -Wl,-pagezero_size,0x0 \ 735 -Wl,-version_load_command \ 736 -Wl,-function_starts \ 737 -Wl,-headerpad,152 738 739# LDFLAGS_KERNEL_SDK = -L$(SDKROOT)/usr/local/lib/kernel -lfirehose_kernel 740LDFLAGS_KERNEL_SDK = -L$(SDKROOT)/usr/local/lib/kernel -L$(SDKROOT)/usr/local/lib/kernel/platform 741 742LDFLAGS_KERNEL_RELEASE = 743LDFLAGS_KERNEL_DEVELOPMENT = 744LDFLAGS_KERNEL_KASAN = $(LDFLAGS_KERNEL_DEVELOPMENT) 745LDFLAGS_KERNEL_DEBUG = 746LDFLAGS_KERNEL_PROFILE = 747 748# Tightbeam finds modules in the "tightbeam" subdirectory. 749TIGHTBEAM_MODULE_DIR = $(SDKROOT)/usr/local/lib/kernel/tightbeam 750 751# KASLR static slide config: 752ifndef SLIDE 753SLIDE=0x00 754endif 755KERNEL_MIN_ADDRESS = 0xffffff8000000000 756KERNEL_BASE_OFFSET = 0x100000 757# POSIX shells use signed long for their arithmetic expressions. However, 758# we're dealing with uintptr_t values here, so explicitly use bash which 759# is known to be able to handle such larger values. ksh also works; dash 760# and zsh both fail with different results (zsh even warns you). 761KERNEL_STATIC_SLIDE = $(shell $(BASH) -c 'printf "0x%016x" \ 762 $$(( $(SLIDE) << 21 ))') 763KERNEL_STATIC_BASE = $(shell $(BASH) -c 'printf "0x%016x" \ 764 $$(( $(KERNEL_MIN_ADDRESS) + $(KERNEL_BASE_OFFSET) ))') 765KERNEL_HIB_SECTION_BASE = $(shell $(BASH) -c 'printf "0x%016x" \ 766 $$(( $(KERNEL_STATIC_BASE) + $(KERNEL_STATIC_SLIDE) ))') 767KERNEL_TEXT_BASE = $(shell $(BASH) -c 'printf "0x%016x" \ 768 $$(( $(KERNEL_HIB_SECTION_BASE) + 0x100000 ))') 769 770LDFLAGS_KERNEL_RELEASEX86_64 = \ 771 -Wl,-pie \ 772 -Wl,-segaddr,__HIB,$(KERNEL_HIB_SECTION_BASE) \ 773 -Wl,-image_base,$(KERNEL_TEXT_BASE) \ 774 -Wl,-seg_page_size,__TEXT,0x200000 \ 775 -Wl,-sectalign,__HIB,__bootPT,0x1000 \ 776 -Wl,-sectalign,__HIB,__desc,0x1000 \ 777 -Wl,-sectalign,__HIB,__data,0x1000 \ 778 -Wl,-sectalign,__HIB,__text,0x1000 \ 779 -Wl,-sectalign,__HIB,__const,0x1000 \ 780 -Wl,-sectalign,__HIB,__bss,0x1000 \ 781 -Wl,-sectalign,__HIB,__common,0x1000 \ 782 -Wl,-sectalign,__HIB,__llvm_prf_cnts,0x1000 \ 783 -Wl,-sectalign,__HIB,__llvm_prf_names,0x1000 \ 784 -Wl,-sectalign,__HIB,__llvm_prf_data,0x1000 \ 785 -Wl,-sectalign,__HIB,__textcoal_nt,0x1000 \ 786 -Wl,-sectalign,__HIB,__cstring,0x1000 \ 787 -Wl,-sectalign,__DATA,__percpu,0x1000 \ 788 -Wl,-rename_section,__DATA,__const,__DATA_CONST,__const \ 789 -Wl,-segprot,__DATA_CONST,r--,r-- \ 790 -Wl,-rename_section,__KLD,__const,__KLDDATA,__const \ 791 -Wl,-rename_section,__KLD,__cstring,__KLDDATA,__cstring \ 792 -Wl,-segprot,__KLDDATA,rw-,rw- \ 793 -Wl,-segprot,__KLD,r-x,r-x \ 794 -Wl,-no_zero_fill_sections \ 795 $(LDFLAGS_NOSTRIP_FLAG) 796 797ifeq ($(SAN),1) 798LDFLAGS_KERNEL_RELEASEX86_64 += \ 799 -Wl,-sectalign,__HIB,__cstring,0x1000 800endif 801 802ifeq ($(KSANCOV),1) 803LDFLAGS_KERNEL_RELEASEX86_64 += \ 804 -Wl,-sectalign,__HIB,__sancov_guards,0x1000 \ 805 -Wl,-sectalign,__HIB,__sancov_pcs,0x1000 806endif 807 808# Define KERNEL_BASE_OFFSET so known at compile time: 809CFLAGS_X86_64 += -DKERNEL_BASE_OFFSET=$(KERNEL_BASE_OFFSET) 810CFLAGS_X86_64H += -DKERNEL_BASE_OFFSET=$(KERNEL_BASE_OFFSET) 811 812LDFLAGS_KERNEL_DEBUGX86_64 = $(LDFLAGS_KERNEL_RELEASEX86_64) 813LDFLAGS_KERNEL_DEVELOPMENTX86_64 = $(LDFLAGS_KERNEL_RELEASEX86_64) 814LDFLAGS_KERNEL_KASANX86_64 = $(LDFLAGS_KERNEL_DEVELOPMENTX86_64) \ 815 -Wl,-sectalign,__HIB,__asan_globals,0x1000 \ 816 -Wl,-sectalign,__HIB,__asan_liveness,0x1000 \ 817 -Wl,-sectalign,__HIB,__mod_term_func,0x1000 \ 818 -Wl,-rename_section,__HIB,__mod_init_func,__NULL,__mod_init_func \ 819 -Wl,-rename_section,__HIB,__eh_frame,__NULL,__eh_frame 820LDFLAGS_KERNEL_PROFILEX86_64 = $(LDFLAGS_KERNEL_RELEASEX86_64) 821 822LDFLAGS_KERNEL_RELEASEX86_64H = $(LDFLAGS_KERNEL_RELEASEX86_64) 823LDFLAGS_KERNEL_DEBUGX86_64H = $(LDFLAGS_KERNEL_RELEASEX86_64H) 824LDFLAGS_KERNEL_DEVELOPMENTX86_64H = $(LDFLAGS_KERNEL_RELEASEX86_64H) 825LDFLAGS_KERNEL_KASANX86_64H = $(LDFLAGS_KERNEL_KASANX86_64) 826LDFLAGS_KERNEL_PROFILEX86_64H = $(LDFLAGS_KERNEL_RELEASEX86_64H) 827 828# Offset image base by page to have iBoot load kernel TEXT correctly. 829# First page is used for various purposes : sleep token, reset vector. 830# We also need a 32MB offset, as this is the minimum block mapping size 831# for a 16KB page runtime, and we wish to use the first virtual block 832# to map the low globals page. We also need another 4MB to account for 833# the address space reserved by L4 (because the reservation is not a 834# multiple of the block size in alignment/length, we will implictly map 835# it with our block mapping, and we therefore must reflect that the 836# first 4MB of the block mapping for xnu do not belong to xnu). 837# For the moment, kaliber has a unique memory layout (monitor at the top 838# of memory). Support this by breaking 16KB on other platforms and 839# mandating 32MB alignment. Image base (i.e. __TEXT) must be 16KB 840# aligned since ld64 will link with 16KB alignment for ARM64. 841# 842# We currently offset by an additional 32MB in order to reclaim memory. 843# We need a dedicated virtual page for the low globals. Our bootloader 844# may have a significant chunk of memory (up to an L2 entry in size) 845# that lies before the kernel. The addition 32MB of virtual padding 846# ensures that we have enough virtual address space to map all of that 847# memory as part of the V-to-P mapping. 848# 23355738 - put __PRELINK_TEXT first. We reserve enough room 849# for 0x0000000003000000 = 48MB of kexts 850# 851# 0xfffffff000000000 (32MB range for low globals) 852# 0xfffffff002000000 (32MB range to allow for large page physical slide) 853# 0xfffffff004000000 (16KB range to reserve the first available page) 854# 0xfffffff004004000 (48MB range for kexts) 855# 0xfffffff007004000 (Start of xnu proper). 856LDFLAGS_KERNEL_GENARM64 = \ 857 -Wl,-pie \ 858 -Wl,-static \ 859 -Wl,-segaddr,__PRELINK_TEXT,$(ARM64_PLKSEG_ADDR) \ 860 -Wl,-image_base,$(ARM64_LINK_ADDR) \ 861 \ 862 -Wl,-rename_section,__HIB,__text,__TEXT_EXEC,__hib_text \ 863 \ 864 -Wl,-rename_section,__HIB,__const,__DATA_CONST,__hib_const \ 865 -Wl,-rename_section,__HIB,__cstring,__DATA_CONST,__hib_const \ 866 -Wl,-rename_section,__HIB,__literal8,__DATA_CONST,__hib_const \ 867 -Wl,-rename_section,__HIB,__literal16,__DATA_CONST,__hib_const \ 868 \ 869 -Wl,-rename_segment,__HIB,__HIBDATA \ 870 \ 871 -Wl,-sectalign,__DATA,__const,0x4000 \ 872 -Wl,-sectalign,__DATA,__percpu,0x4000 \ 873 -Wl,-sectalign,__DATA,__data,0x4000 \ 874 -Wl,-rename_section,__DATA,__mod_init_func,__DATA_CONST,__mod_init_func \ 875 -Wl,-rename_section,__DATA,__mod_term_func,__DATA_CONST,__mod_term_func \ 876 -Wl,-rename_section,__DATA,__auth_ptr,__DATA_CONST,__auth_ptr \ 877 -Wl,-rename_section,__DATA,__auth_got,__DATA_CONST,__auth_got \ 878 -Wl,-rename_section,__DATA,__const,__DATA_CONST,__const \ 879 -Wl,-segprot,__DATA_CONST,r--,r-- \ 880 -Wl,-rename_section,__KLD,__const,__KLDDATA,__const \ 881 -Wl,-rename_section,__KLD,__cstring,__KLDDATA,__cstring \ 882 -Wl,-segprot,__KLDDATA,rw-,rw- \ 883 -Wl,-segprot,__KLD,r-x,r-x \ 884 -Wl,-rename_section,__TEXT,__text,__TEXT_EXEC,__text \ 885 -Wl,-rename_section,__TEXT,__stubs,__TEXT_EXEC,__stubs \ 886 -Wl,-sectcreate,"__PLK_TEXT_EXEC",__text,/dev/null \ 887 -Wl,-sectcreate,__PRELINK_DATA,__data,/dev/null \ 888 -Wl,-sectcreate,"__PLK_DATA_CONST",__data,/dev/null \ 889 -Wl,-sectcreate,"__PLK_LLVM_COV",__llvm_covmap,/dev/null \ 890 -Wl,-sectcreate,"__PLK_LINKEDIT",__data,/dev/null 891 892# To support code coverage for kexts, the coverage mapping sections __llvm_covmap 893# and __llvm_covfun are put into the __PLK_LLVM_COV segment rather than the 894# standard __LLVM_COV segment. For later processing of the coverage data using 895# llvm-cov, we move the coverage mapping for the kernel itself into the same 896# segment (see also rdar://104951137) 897ifeq ($(BUILD_CODE_COVERAGE),1) 898LDFLAGS_KERNEL_GENARM64 += \ 899 -Wl,-rename_section,__LLVM_COV,__llvm_covmap,__PLK_LLVM_COV,__llvm_covmap \ 900 -Wl,-rename_section,__LLVM_COV,__llvm_covfun,__PLK_LLVM_COV,__llvm_covfun 901endif 902 903LDFLAGS_KERNEL_SEGARM64_SEG_ORDER = \ 904 __TEXT:__DATA_CONST:__DATA_SPTM:__LINKEDIT:__TEXT_EXEC:__TEXT_BOOT_EXEC:__KLD:__PPLTEXT:__PPLTRAMP:__PPLDATA_CONST:__LASTDATA_CONST:__LAST:__PPLDATA:__KLDDATA:__DATA:__HIBDATA:__BOOTDATA 905 906LDFLAGS_KERNEL_SEGARM64 = \ 907 -Wl,-rename_section,__PPLDATA,__const,__PPLDATA_CONST,__const \ 908 -Wl,-segment_order,$(LDFLAGS_KERNEL_SEGARM64_SEG_ORDER) \ 909 -Wl,-segprot,__TEXT,r--,r-- \ 910 -Wl,-segprot,__TEXT_EXEC,r-x,r-x \ 911 -Wl,-segprot,__TEXT_BOOT_EXEC,r-x,r-x \ 912 -Wl,-segprot,__PPLTEXT,r-x,r-x \ 913 -Wl,-segprot,__PPLTRAMP,r-x,r-x \ 914 -Wl,-segprot,__PPLDATA_CONST,r--,r-- \ 915 -Wl,-segprot,__LASTDATA_CONST,r--,r-- \ 916 -Wl,-segprot,__LAST,r-x,r-x \ 917 918LDFLAGS_KERNEL_RELEASEARM64 = \ 919 $(LDFLAGS_KERNEL_GENARM64) \ 920 $(LDFLAGS_KERNEL_SEGARM64) \ 921 $(LDFLAGS_KERNEL_STRIP_LTO) 922 923LDFLAGS_KERNEL_ONLY_CONFIG_RELEASEARM64 = \ 924 -Wl,-exported_symbols_list,$(TARGET)/all-kpi.exp 925 926LDFLAGS_KERNEL_DEVELOPMENTARM64 = \ 927 $(LDFLAGS_KERNEL_GENARM64) \ 928 $(LDFLAGS_KERNEL_SEGARM64) \ 929 $(LDFLAGS_NOSTRIP_FLAG) 930 931LDFLAGS_KERNEL_ONLY_CONFIG_DEVELOPMENTARM64 = 932 933LDFLAGS_KERNEL_KASANARM64 = $(LDFLAGS_KERNEL_DEVELOPMENTARM64) 934LDFLAGS_KERNEL_DEBUGARM64 = $(LDFLAGS_KERNEL_DEVELOPMENTARM64) 935LDFLAGS_KERNEL_SPTMARM64 = $(LDFLAGS_KERNEL_DEVELOPMENTARM64) 936 937LDFLAGS_KERNEL_ONLY_CONFIG_KASANARM64 = $(LDFLAGS_KERNEL_ONLY_CONFIG_DEVELOPMENTARM64) 938LDFLAGS_KERNEL_ONLY_CONFIG_DEBUGARM64 = $(LDFLAGS_KERNEL_ONLY_CONFIG_DEVELOPMENTARM64) 939 940# 941# arm64e specific linker flags that should be used only when linking the kernel 942# (and not the static kernel cache / kcgen) 943# 944LDFLAGS_KERNEL_ONLY_SUBARCH_arm64e = \ 945 -Wl,-add_split_seg_info \ 946 -Wl,-kernel 947 948LDFLAGS_KERNEL_ONLY_SUBARCH_x86_64 = \ 949 -Wl,-add_split_seg_info \ 950 -Wl,-kernel 951LDFLAGS_KERNEL_ONLY_SUBARCH_x86_64h = $(LDFLAGS_KERNEL_ONLY_SUBARCH_x86_64) 952 953LDFLAGS_KERNEL = $(LDFLAGS_KERNEL_GEN) \ 954 $(LDFLAGS_KERNEL_SDK) \ 955 $($(addsuffix $(CURRENT_ARCH_CONFIG),ARCH_FLAGS_)) \ 956 $($(addsuffix $(CURRENT_ARCH_CONFIG),LDFLAGS_KERNEL_)) \ 957 $($(addsuffix $(CURRENT_KERNEL_CONFIG),LDFLAGS_KERNEL_)) \ 958 $($(addsuffix $(CURRENT_ARCH_CONFIG), $(addsuffix $(CURRENT_KERNEL_CONFIG),LDFLAGS_KERNEL_))) \ 959 $(DEPLOYMENT_TARGET_FLAGS) 960 961LDFLAGS_KERNEL_ONLY += \ 962 $($(addsuffix $(CURRENT_ARCH_CONFIG), $(addsuffix $(CURRENT_KERNEL_CONFIG),LDFLAGS_KERNEL_ONLY_CONFIG_))) \ 963 $($(addsuffix $(ARCH_STRING_FOR_CURRENT_MACHINE_CONFIG),LDFLAGS_KERNEL_ONLY_SUBARCH_)) \ 964 -Wl,-alias_list,$(TARGET)/all-alias.exp \ 965 -Wl,-sectcreate,__LINKINFO,__symbolsets,$(TARGET)/symbolsets.plist -Wl,-segprot,__LINKINFO,r--,r-- 966 967LDFILES_KERNEL_ONLY = $(TARGET)/all-kpi.exp $(TARGET)/all-alias.exp $(TARGET)/symbolsets.plist 968 969# 970# Default runtime libraries to be linked with the kernel 971# 972LD_KERNEL_LIBS = -lcc_kext 973LD_KERNEL_ARCHIVES = $(LDFLAGS_KERNEL_SDK) -lfirehose_kernel 974 975# 976# SPTM TODO: This is a hack to always link the SPTM library when building the 977# SPTM variant. In the future, we should base whether to link the 978# library off of the HasSPTMTXM EDM per-target property. Note that 979# for standard kernels where the SPTM is enabled by default, 980# linkage is configured on a per-target and per-platform basis. 981# 982ifeq ($(CURRENT_KERNEL_CONFIG),SPTM) 983LD_KERNEL_ARCHIVES += -lTrustedExecutionMonitor_Kernel 984LD_KERNEL_ARCHIVES += -lsptm_xnu 985else 986 ifneq ($(CURRENT_KERNEL_CONFIG),KASAN) 987 ifneq ($(filter $(CURRENT_MACHINE_CONFIG_LC),$(SPTM_ENABLED_SOCS_$(PLATFORM))),) 988 LD_KERNEL_ARCHIVES += -lTrustedExecutionMonitor_Kernel 989 LD_KERNEL_ARCHIVES += -lsptm_xnu 990 endif 991 endif 992endif 993 994# 995# DTrace support 996# 997ifndef DO_CTFMERGE 998DO_CTFMERGE := 1 999ifeq ($(CURRENT_KERNEL_CONFIG),RELEASE) 1000ifneq ($(PLATFORM),MacOSX) 1001DO_CTFMERGE := 0 1002endif 1003endif 1004endif # DO_CTFMERGE 1005 1006 1007# 1008# Default INCFLAGS 1009# 1010INCFLAGS_IMPORT = $(patsubst %, -I$(OBJROOT)/EXPORT_HDRS/%, $(COMPONENT_IMPORT_LIST)) 1011INCFLAGS_EXTERN = -I$(SRCROOT)/EXTERNAL_HEADERS 1012INCFLAGS_GEN = -I$(SRCROOT)/$(COMPONENT) -I$(OBJROOT)/EXPORT_HDRS/$(COMPONENT) 1013INCFLAGS_LOCAL = -I. 1014INCFLAGS_SDK = -I$(SDKROOT)/usr/local/include/kernel 1015INCFLAGS_PLATFORM = -I$(SDKROOT)/$(KPINCDIR)/platform 1016 1017INCFLAGS = $(INCFLAGS_LOCAL) $(INCFLAGS_GEN) $(INCFLAGS_IMPORT) $(INCFLAGS_EXTERN) $(INCFLAGS_MAKEFILE) $(INCFLAGS_SDK) $(INCFLAGS_PLATFORM) 1018 1019# 1020# Default MIGFLAGS 1021# 1022MIGFLAGS = $(DEFINES) $(INCFLAGS) -novouchers $($(addsuffix $(CURRENT_ARCH_CONFIG),CFLAGS_)) $($(addsuffix $(CURRENT_ARCH_CONFIG),ARCH_FLAGS_)) \ 1023 $(DEPLOYMENT_TARGET_FLAGS) 1024 1025# 1026# Default MIG Kernel Server flags 1027# 1028MIGKSFLAGS = \ 1029 -DMACH_KERNEL_PRIVATE \ 1030 -DKERNEL_SERVER=1 \ 1031 -mach_msg2 1032 1033# 1034# Default MIG KernelUser flags 1035# 1036MIGKUFLAGS = \ 1037 -DMACH_KERNEL_PRIVATE \ 1038 -DKERNEL_USER=1 \ 1039 -maxonstack 1024 1040 1041# Support for LLVM Profile Guided Optimization (PGO) 1042 1043ifeq ($(BUILD_PROFILE),1) 1044CFLAGS_GEN += -fprofile-instr-generate -DPROFILE 1045CXXFLAGS_GEN += -fprofile-instr-generate -DPROFILE 1046endif 1047 1048ifdef USE_PROFILE 1049CFLAGS_GEN += -fprofile-instr-use=$(USE_PROFILE) 1050CXXFLAGS_GEN += -fprofile-instr-use=$(USE_PROFILE) 1051LDFLAGS_KERNEL_GEN += -fprofile-instr-use=$(USE_PROFILE) 1052 1053CFLAGS_GEN += -Wno-error=profile-instr-out-of-date 1054endif 1055 1056# Support for LLVM Source-based Code coverage. Since enabling code coverage 1057# increases the size of __LINKEDIT, it might be necessary to set the keepsyms=1 1058# boot-arg when building the kernel with code coverage enabled. 1059ifeq ($(BUILD_CODE_COVERAGE),1) 1060CFLAGS_GEN += -fprofile-instr-generate -fcoverage-mapping 1061CXXFLAGS_GEN += -fprofile-instr-generate -fcoverage-mapping 1062endif 1063 1064# 1065# Support for LLVM Link Time Optimization (LTO) 1066# 1067# LTO can be explicitly enabled or disabled with BUILD_LTO=1|0 1068# and defaults to enabled except for DEBUG kernels 1069# 1070# CFLAGS_NOLTO_FLAG is needed on a per-file basis (for files 1071# that deal poorly with LTO, or files that must be machine 1072# code *.o files for xnu to build (i.e, setsegname runs on 1073# them). 1074# 1075# LDFLAGS_NOSTRIP_FLAG is used to support configurations that 1076# do not utilize an export list. For these configs to build, 1077# we need to prevent the LTO logic from dead stripping them. 1078 1079LTO_ENABLED_RELEASE = 1 1080LTO_ENABLED_DEVELOPMENT = 1 1081LTO_ENABLED_DEBUG = 0 1082LTO_ENABLED_KASAN = 0 1083LTO_ENABLED_SPTM = $(LTO_ENABLED_DEVELOPMENT) 1084 1085ifneq ($(BUILD_LTO),) 1086USE_LTO = $(BUILD_LTO) 1087else 1088USE_LTO = $(LTO_ENABLED_$(CURRENT_KERNEL_CONFIG)) 1089endif 1090 1091ifeq ($(USE_LTO),1) 1092CFLAGS_GEN += -flto -DBUILT_LTO=1 1093CXXFLAGS_GEN += -flto -DBUILT_LTO=1 1094LDFLAGS_KERNEL_LTO = -Wl,-mllvm,-inline-threshold=100 1095LDFLAGS_KERNEL_GEN += $(LDFLAGS_KERNEL_LTO) -Wl,-object_path_lto,$(TARGET)/lto.o 1096LDFLAGS_NOSTRIP_FLAG = -rdynamic 1097LDFLAGS_KERNEL_STRIP_LTO = -Wl,-dead_strip,-no_dead_strip_inits_and_terms 1098 1099CFLAGS_NOLTO_FLAG = -fno-lto 1100else 1101LDFLAGS_KERNEL_LTO = 1102LDFLAGS_NOSTRIP_FLAG = 1103LDFLAGS_KERNEL_STRIP_LTO = 1104CFLAGS_NOLTO_FLAG = 1105endif 1106 1107# 1108# Default VPATH 1109# 1110export VPATH = .:$(SOURCE) 1111 1112 1113 1114# 1115# Macros that control installation of kernel and its header files 1116# 1117# install flags for header files 1118# 1119INSTALL_FLAGS = -c -S -m 0444 1120DATA_INSTALL_FLAGS = -c -S -m 0644 1121DATA_INSTALL_FLAGS_RO = -c -S -m 0444 1122EXEC_INSTALL_FLAGS = -c -S -m 0755 1123 1124# 1125# Header file destinations 1126# 1127 1128ifeq ($(DRIVERKIT),1) 1129 SDKHEADERSROOT=$(DRIVERKITRUNTIMEROOT) 1130 # only whitelisted headers install outside of the DriverKit Runtime hierarchy 1131 DRIVERKITSDKHEADERSROOT=$(DRIVERKITROOT) 1132 DRIVERKITFRAMEDIR = $(DRIVERKITROOT)/System/Library/Frameworks 1133endif 1134 1135ifeq ($(EXCLAVEKIT),1) 1136 EXCLAVEKITSDKHEADERSROOT=$(EXCLAVEKITROOT) 1137 EXCLAVEKITFRAMEDIR = $(EXCLAVEKITROOT)/System/Library/Frameworks 1138endif 1139 1140ifeq ($(EXCLAVECORE),1) 1141 EXCLAVECORESDKHEADERSROOT=$(EXCLAVECOREROOT) 1142 EXCLAVECOREFRAMEDIR = $(EXCLAVECOREROOT)/System/Library/Frameworks 1143endif 1144 1145FRAMEDIR = $(SDKHEADERSROOT)/System/Library/Frameworks 1146 1147IINCVERS = A 1148IINCFRAME = $(FRAMEDIR)/IOKit.framework 1149IINCDIR = $(IINCFRAME)/Versions/$(IINCVERS)/Headers 1150IPINCDIR = $(IINCFRAME)/Versions/$(IINCVERS)/PrivateHeaders 1151IRESDIR = $(IINCFRAME)/Versions/$(IINCVERS)/Resources 1152 1153SINCVERS = B 1154SINCFRAME = $(FRAMEDIR)/System.framework 1155SINCDIR = $(SINCFRAME)/Versions/$(SINCVERS)/Headers 1156SPINCDIR = $(SINCFRAME)/Versions/$(SINCVERS)/PrivateHeaders 1157SRESDIR = $(SINCFRAME)/Versions/$(SINCVERS)/Resources 1158 1159ifndef INCDIR 1160 INCDIR = $(SDKHEADERSROOT)/usr/include 1161endif 1162ifndef DRIVERKITINCDIR 1163 DRIVERKITINCDIR = $(DRIVERKITSDKHEADERSROOT)/usr/include 1164endif 1165ifndef EXCLAVEKITINCDIR 1166 EXCLAVEKITINCDIR = $(EXCLAVEKITSDKHEADERSROOT)/usr/include 1167endif 1168ifndef EXCLAVECOREINCDIR 1169 EXCLAVECOREINCDIR = $(EXCLAVECORESDKHEADERSROOT)/usr/include 1170endif 1171ifndef LCLDIR 1172 LCLDIR = $(SDKHEADERSROOT)/usr/local/include 1173endif 1174ifndef DRIVERKITLCLDIR 1175 DRIVERKITLCLDIR = $(DRIVERKITSDKHEADERSROOT)/usr/local/include 1176endif 1177 1178KINCVERS = A 1179KINCFRAME = $(FRAMEDIR)/Kernel.framework 1180KINCDIR = $(KINCFRAME)/Versions/$(KINCVERS)/Headers 1181KPINCDIR = $(KINCFRAME)/Versions/$(KINCVERS)/PrivateHeaders 1182KRESDIR = $(KINCFRAME)/Versions/$(KINCVERS)/Resources 1183 1184KLIBCXXDIR = $(KPINCDIR)/kernel_sdkroot 1185KLIBCXXINCDIR = $(KLIBCXXDIR)/usr/include 1186 1187DKIT_INCFRAME = DriverKit.framework 1188 1189ifeq ($(PLATFORM),MacOSX) 1190DKIT_INCVERS = A 1191DKIT_INCDIR = $(DKIT_INCFRAME)/Versions/$(DKIT_INCVERS)/Headers 1192DKIT_PINCDIR = $(DKIT_INCFRAME)/Versions/$(DKIT_INCVERS)/PrivateHeaders 1193else 1194# non-macOS SDK frameworks use shallow bundle structure 1195DKIT_INCDIR = $(DKIT_INCFRAME)/Headers 1196DKIT_PINCDIR = $(DKIT_INCFRAME)/PrivateHeaders 1197endif 1198 1199# DriverKit SDK frameworks use shallow bundle structure 1200DRIVERKIT_DKIT_INCDIR = $(DKIT_INCFRAME)/Headers 1201DRIVERKIT_DKIT_PINCDIR = $(DKIT_INCFRAME)/PrivateHeaders 1202 1203XNU_PRIVATE_UNIFDEF ?= 1204XNU_PRIVATE_UNIFDEF += -UMACH_KERNEL_PRIVATE 1205XNU_PRIVATE_UNIFDEF += -UBSD_KERNEL_PRIVATE 1206XNU_PRIVATE_UNIFDEF += -UIOKIT_KERNEL_PRIVATE 1207XNU_PRIVATE_UNIFDEF += -ULIBKERN_KERNEL_PRIVATE 1208XNU_PRIVATE_UNIFDEF += -ULIBSA_KERNEL_PRIVATE 1209XNU_PRIVATE_UNIFDEF += -UPEXPERT_KERNEL_PRIVATE 1210XNU_PRIVATE_UNIFDEF += -UXNU_KERNEL_PRIVATE 1211 1212 1213PLATFORM_UNIFDEF = $(foreach x,$(SUPPORTED_PLATFORMS),$(if $(filter $(PLATFORM),$(x)),-DXNU_PLATFORM_$(x) $(foreach token,$(PLATFORM_UNIFDEF_BLACKLIST_TOKENS_$(x)),-U$(token)),-UXNU_PLATFORM_$(x))) 1214 1215 1216# Some header guards need to be present and checked in kernel headers but removed from userspace headers 1217KERNEL_ONLY_GUARDS_UNIFDEF = 1218 1219SPINCFRAME_UNIFDEF = $(PLATFORM_UNIFDEF) $(XNU_PRIVATE_UNIFDEF) $(SEED_DEFINES) -UKERNEL_PRIVATE -UKERNEL -DPRIVATE -UDRIVERKIT -UEXCLAVEKIT -UEXCLAVECORE -U_OPEN_SOURCE_ -U__OPEN_SOURCE__ $(KERNEL_ONLY_GUARDS_UNIFDEF) 1220SINCFRAME_UNIFDEF = $(PLATFORM_UNIFDEF) $(XNU_PRIVATE_UNIFDEF) $(SEED_DEFINES) -UKERNEL_PRIVATE -UKERNEL -UPRIVATE -UDRIVERKIT -UEXCLAVEKIT -UEXCLAVECORE -D_OPEN_SOURCE_ -D__OPEN_SOURCE__ $(KERNEL_ONLY_GUARDS_UNIFDEF) 1221DKPINCFRAME_UNIFDEF = $(PLATFORM_UNIFDEF) $(XNU_PRIVATE_UNIFDEF) $(SEED_DEFINES) -UKERNEL_PRIVATE -UKERNEL -DPRIVATE -DDRIVERKIT -UEXCLAVEKIT -UEXCLAVECORE -U_OPEN_SOURCE_ -U__OPEN_SOURCE__ $(KERNEL_ONLY_GUARDS_UNIFDEF) 1222DKINCFRAME_UNIFDEF = $(PLATFORM_UNIFDEF) $(XNU_PRIVATE_UNIFDEF) $(SEED_DEFINES) -UKERNEL_PRIVATE -UKERNEL -UPRIVATE -DDRIVERKIT -UEXCLAVEKIT -UEXCLAVECORE -D_OPEN_SOURCE_ -D__OPEN_SOURCE__ $(KERNEL_ONLY_GUARDS_UNIFDEF) 1223EKPINCFRAME_UNIFDEF = $(PLATFORM_UNIFDEF) $(XNU_PRIVATE_UNIFDEF) $(SEED_DEFINES) -UKERNEL_PRIVATE -UKERNEL -DPRIVATE -UDRIVERKIT -DEXCLAVEKIT -UEXCLAVECORE -U_OPEN_SOURCE_ -U__OPEN_SOURCE__ $(KERNEL_ONLY_GUARDS_UNIFDEF) 1224EKINCFRAME_UNIFDEF = $(PLATFORM_UNIFDEF) $(XNU_PRIVATE_UNIFDEF) $(SEED_DEFINES) -UKERNEL_PRIVATE -UKERNEL -UPRIVATE -UDRIVERKIT -DEXCLAVEKIT -UEXCLAVECORE -D_OPEN_SOURCE_ -D__OPEN_SOURCE__ $(KERNEL_ONLY_GUARDS_UNIFDEF) 1225ECPINCFRAME_UNIFDEF = $(PLATFORM_UNIFDEF) $(XNU_PRIVATE_UNIFDEF) $(SEED_DEFINES) -UKERNEL_PRIVATE -UKERNEL -DPRIVATE -UDRIVERKIT -UEXCLAVEKIT -DEXCLAVECORE -U_OPEN_SOURCE_ -U__OPEN_SOURCE__ $(KERNEL_ONLY_GUARDS_UNIFDEF) 1226ECINCFRAME_UNIFDEF = $(PLATFORM_UNIFDEF) $(XNU_PRIVATE_UNIFDEF) $(SEED_DEFINES) -UKERNEL_PRIVATE -UKERNEL -UPRIVATE -UDRIVERKIT -UEXCLAVEKIT -DEXCLAVECORE -D_OPEN_SOURCE_ -D__OPEN_SOURCE__ $(KERNEL_ONLY_GUARDS_UNIFDEF) 1227KPINCFRAME_UNIFDEF = $(PLATFORM_UNIFDEF) $(XNU_PRIVATE_UNIFDEF) $(SEED_DEFINES) -DKERNEL_PRIVATE -DKERNEL -DPRIVATE -UDRIVERKIT -UXNU_LIBCXX_SDKROOT -UEXCLAVEKIT -UEXCLAVECORE -U_OPEN_SOURCE_ -U__OPEN_SOURCE__ 1228LIBCXXINCFRAME_UNIFDEF = $(PLATFORM_UNIFDEF) $(XNU_PRIVATE_UNIFDEF) $(SEED_DEFINES) -DKERNEL_PRIVATE -DKERNEL -DPRIVATE -UDRIVERKIT -DXNU_LIBCXX_SDKROOT -UEXCLAVEKIT -UEXCLAVECORE -U_OPEN_SOURCE_ -U__OPEN_SOURCE__ 1229KINCFRAME_UNIFDEF = $(PLATFORM_UNIFDEF) $(XNU_PRIVATE_UNIFDEF) $(SEED_DEFINES) -UKERNEL_PRIVATE -DKERNEL -UPRIVATE -UDRIVERKIT -UEXCLAVEKIT -UEXCLAVECORE -D_OPEN_SOURCE_ -D__OPEN_SOURCE__ 1230PDATA_UNIFDEF = $(PLATFORM_UNIFDEF) $(XNU_PRIVATE_UNIFDEF) $(SEED_DEFINES) -DPRIVATE -U_OPEN_SOURCE_ -U__OPEN_SOURCE__ 1231DATA_UNIFDEF = $(PLATFORM_UNIFDEF) $(XNU_PRIVATE_UNIFDEF) $(SEED_DEFINES) -UPRIVATE -D_OPEN_SOURCE_ -D__OPEN_SOURCE__ 1232 1233# 1234# Compononent Header file destinations 1235# 1236EXPDIR = EXPORT_HDRS/$(COMPONENT) 1237 1238# 1239# Strip Flags 1240# 1241STRIP_FLAGS_RELEASE = -S -x 1242STRIP_FLAGS_DEVELOPMENT = -S 1243STRIP_FLAGS_KASAN = $(STRIP_FLAGS_DEVELOPMENT) 1244STRIP_FLAGS_DEBUG = -S 1245STRIP_FLAGS_SPTM = $(STRIP_FLAGS_DEVELOPMENT) 1246STRIP_FLAGS_PROFILE = -S -x 1247 1248STRIP_FLAGS = $($(addsuffix $(CURRENT_KERNEL_CONFIG),STRIP_FLAGS_)) 1249 1250# 1251# dsymutil flags 1252# 1253DSYMUTIL_FLAGS_GEN = --minimize 1254 1255DSYMUTIL_FLAGS_X86_64 = --arch=x86_64 1256DSYMUTIL_FLAGS_X86_64H = --arch=x86_64h 1257DSYMUTIL_FLAGS_ARM64 = 1258 1259DSYMUTIL_FLAGS = $(DSYMUTIL_FLAGS_GEN) \ 1260 $($(addsuffix $(CURRENT_ARCH_CONFIG),DSYMUTIL_FLAGS_)) 1261 1262 1263 1264 1265# 1266# Man Page destination 1267# 1268MANDIR = /usr/share/man 1269 1270# 1271# DEBUG alias location 1272# 1273DEVELOPER_EXTRAS_DIR = /AppleInternal/CoreOS/xnu_$(CURRENT_KERNEL_CONFIG_LC) 1274 1275# 1276# mach_kernel install location 1277# 1278INSTALL_KERNEL_DIR = / 1279 1280# 1281# new OS X install location 1282# 1283SYSTEM_LIBRARY_KERNELS_DIR = /System/Library/Kernels 1284 1285# 1286# File names in DSTROOT 1287# 1288 1289ifeq ($(PLATFORM),MacOSX) 1290KERNEL_FILE_NAME_PREFIX = kernel 1291else 1292KERNEL_FILE_NAME_PREFIX = mach 1293endif 1294 1295ifeq ($(CURRENT_MACHINE_CONFIG),NONE) 1296ifeq ($(CURRENT_KERNEL_CONFIG),RELEASE) 1297KERNEL_FILE_NAME = $(KERNEL_FILE_NAME_PREFIX) 1298KERNEL_LLDBBOOTSTRAP_NAME = $(KERNEL_FILE_NAME_PREFIX).py 1299else 1300KERNEL_FILE_NAME = $(KERNEL_FILE_NAME_PREFIX).$(CURRENT_KERNEL_CONFIG_LC) 1301KERNEL_LLDBBOOTSTRAP_NAME = $(KERNEL_FILE_NAME_PREFIX).py 1302endif 1303else 1304KERNEL_FILE_NAME = $(KERNEL_FILE_NAME_PREFIX).$(CURRENT_KERNEL_CONFIG_LC).$(CURRENT_MACHINE_CONFIG_LC) 1305KERNEL_LLDBBOOTSTRAP_NAME = $(KERNEL_FILE_NAME_PREFIX)_$(CURRENT_KERNEL_CONFIG_LC).py 1306endif 1307 1308CURRENT_ALIAS_MACHINE_CONFIG = $(word 4,$(subst ^, ,$(CURRENT_BUILD_CONFIG))) 1309CURRENT_ALIAS_MACHINE_CONFIG_LC = $(shell printf "%s" "$(CURRENT_ALIAS_MACHINE_CONFIG)" | $(TR) A-Z a-z) 1310ifneq ($(CURRENT_ALIAS_MACHINE_CONFIG),) 1311ALIAS_FILE_NAME = $(KERNEL_FILE_NAME_PREFIX).$(CURRENT_KERNEL_CONFIG_LC).$(CURRENT_ALIAS_MACHINE_CONFIG_LC) 1312endif 1313 1314# 1315# System.kext pseudo-kext install location 1316# 1317INSTALL_EXTENSIONS_DIR = /System/Library/Extensions 1318SYSTEM_KEXT_INFO_PLIST = $(addprefix $(INSTALL_EXTENSIONS_DIR),/System.kext/Info.plist) 1319 1320# 1321# System.kext PlugIns install location 1322# 1323DSTROOT_SYSTEM_KEXT_PATH = $(addprefix $(DSTROOT)$(INSTALL_EXTENSIONS_DIR),/System.kext/PlugIns) 1324SYMROOT_SYSTEM_KEXT_PATH = $(addprefix $(SYMROOT),/System.kext/PlugIns) 1325 1326# 1327# KDK location 1328# 1329INSTALL_KERNEL_SYM_DIR = /System/Library/Extensions/KDK 1330 1331# 1332# Misc. Etc. 1333# 1334INSTALL_SHARE_MISC_DIR = /usr/share/misc 1335INSTALL_DTRACE_SCRIPTS_DIR = /usr/lib/dtrace 1336INSTALL_DTRACE_LIBEXEC_DIR = /usr/libexec/dtrace 1337INSTALL_ARIADNE_PLISTS_DIR = /AppleInternal/Library/Ariadne/Plists 1338# 1339# Generated xnu version file 1340# 1341XNU_VERSION = $(OBJROOT)/xnuVersion 1342 1343# 1344# Overrides for XBS build aliases 1345# 1346ifneq ($(filter $(RC_ProjectName),xnu_headers_driverkit),) 1347USE_BINARY_PLIST = 1 1348else ifneq ($(filter $(RC_ProjectName),xnu_debug),) 1349INSTALL_KERNEL_DIR := $(DEVELOPER_EXTRAS_DIR) 1350INSTALL_KERNEL_SYM_DIR := $(DEVELOPER_EXTRAS_DIR) 1351INSTALL_KERNEL_SYM_TO_KDK = 1 1352INSTALL_XNU_DEBUG_FILES = 1 1353else ifneq ($(filter $(SUPPORTED_EMBEDDED_PLATFORMS),$(PLATFORM)),) 1354INSTALL_KERNEL_SYM_TO_KDK = 1 1355USE_BINARY_PLIST = 1 1356else ifneq ($(filter $(SUPPORTED_SIMULATOR_PLATFORMS),$(PLATFORM)),) 1357USE_BINARY_PLIST = 1 1358else ifeq ($(PLATFORM),MacOSX) 1359INSTALL_KERNEL_DIR := $(SYSTEM_LIBRARY_KERNELS_DIR) 1360INSTALL_KERNEL_SYM_DIR := $(SYSTEM_LIBRARY_KERNELS_DIR) 1361INSTALL_KERNEL_SYM_TO_KDK = $(if $(filter YES,$(DWARF_DSYM_FILE_SHOULD_ACCOMPANY_PRODUCT)),1,0) 1362endif 1363 1364ifneq ($(filter $(RC_ProjectName),xnu_kasan),) 1365INSTALL_KASAN_ONLY = 1 1366endif 1367 1368# vim: set ft=make: 1369