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