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