makedefs/MakeInc.def

   1 # -*- mode: makefile;-*-
   2 #
   3 # Copyright (C) 1999-2019 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 #
  12 SUPPORTED_ARCH_CONFIGS := X86_64 X86_64H ARM ARM64
  13
  14 #
  15 # Kernel Configuration options
  16 #
  17 SUPPORTED_KERNEL_CONFIGS = RELEASE DEVELOPMENT DEBUG PROFILE KASAN
  18
  19
  20 #
  21 # Machine Configuration options
  22 #
  23
  24 SUPPORTED_X86_64_MACHINE_CONFIGS = NONE
  25 SUPPORTED_X86_64H_MACHINE_CONFIGS = NONE
  26
  27 SUPPORTED_ARM_MACHINE_CONFIGS = S7002 T8002 T8004
  28 SUPPORTED_ARM64_MACHINE_CONFIGS = T7000 T7001 S8000 S8001 T8010 T8011 BCM2837
  29
  30
  31 #
  32 # Setup up *_LC variables during recursive invocations
  33 #
  34
  35 ifndef CURRENT_ARCH_CONFIG_LC
  36         export CURRENT_ARCH_CONFIG_LC   := $(shell printf "%s" "$(CURRENT_ARCH_CONFIG)" | $(TR) A-Z a-z)
  37 endif
  38
  39 ifndef CURRENT_KERNEL_CONFIG_LC
  40         export CURRENT_KERNEL_CONFIG_LC := $(shell printf "%s" "$(CURRENT_KERNEL_CONFIG)" | $(TR) A-Z a-z)
  41 endif
  42
  43 ifndef CURRENT_MACHINE_CONFIG_LC
  44         export CURRENT_MACHINE_CONFIG_LC := $(shell printf "%s" "$(CURRENT_MACHINE_CONFIG)" | $(TR) A-Z a-z)
  45 endif
  46
  47 #
  48 # Component List
  49 #
  50 COMPONENT_LIST  = osfmk bsd libkern iokit pexpert libsa security san
  51 COMPONENT       = $(if $(word 2,$(subst /, ,$(RELATIVE_SOURCE_PATH))),$(word 2,$(subst /, ,$(RELATIVE_SOURCE_PATH))),$(firstword $(subst /, ,$(RELATIVE_SOURCE_PATH))))
  52 COMPONENT_IMPORT_LIST = $(filter-out $(COMPONENT),$(COMPONENT_LIST))
  53
  54 MACHINE_FLAGS_ARM64_T7000 = -DARM64_BOARD_CONFIG_T7000
  55 MACHINE_FLAGS_ARM64_T7001 = -DARM64_BOARD_CONFIG_T7001
  56 MACHINE_FLAGS_ARM_S7002 = -DARM_BOARD_CONFIG_S7002
  57 MACHINE_FLAGS_ARM64_S8000 = -DARM64_BOARD_CONFIG_S8000
  58 MACHINE_FLAGS_ARM64_S8001 = -DARM64_BOARD_CONFIG_S8001
  59 MACHINE_FLAGS_ARM_T8002 = -DARM_BOARD_CONFIG_T8002
  60 MACHINE_FLAGS_ARM_T8004 = -DARM_BOARD_CONFIG_T8004
  61 MACHINE_FLAGS_ARM64_T8010 = -DARM64_BOARD_CONFIG_T8010 -mcpu=hurricane
  62 MACHINE_FLAGS_ARM64_T8011 = -DARM64_BOARD_CONFIG_T8011 -mcpu=hurricane
  63 MACHINE_FLAGS_ARM64_BCM2837 = -DARM64_BOARD_CONFIG_BCM2837
  64
  65
  66 #
  67 # Deployment target flag
  68 #
  69 ifeq ($(PLATFORM),MacOSX)
  70     DEPLOYMENT_TARGET_FLAGS = -mmacosx-version-min=$(SDKVERSION) -DXNU_TARGET_OS_OSX
  71     DEPLOYMENT_LINKER_FLAGS = -Wl,-macosx_version_min,$(SDKVERSION)
  72 else ifeq ($(PLATFORM),DriverKit)
  73     DEPLOYMENT_TARGET_FLAGS = -target x86_64-apple-driverkit$(SDKVERSION) -DXNU_TARGET_OS_OSX
  74     DEPLOYMENT_LINKER_FLAGS = -Wl,-target,x86_64-apple-driverkit$(SDKVERSION)
  75 else ifeq ($(PLATFORM),WatchOS)
  76     DEPLOYMENT_TARGET_FLAGS = -mwatchos-version-min=$(SDKVERSION) -DXNU_TARGET_OS_WATCH
  77     DEPLOYMENT_LINKER_FLAGS =
  78 else ifeq ($(PLATFORM),tvOS)
  79     DEPLOYMENT_TARGET_FLAGS = -mtvos-version-min=$(SDKVERSION) -DXNU_TARGET_OS_TV
  80     DEPLOYMENT_LINKER_FLAGS =
  81 else ifeq ($(PLATFORM),AppleTVOS)
  82     DEPLOYMENT_TARGET_FLAGS = -mtvos-version-min=$(SDKVERSION) -DXNU_TARGET_OS_TV
  83 else ifeq ($(PLATFORM),BridgeOS)
  84     DEPLOYMENT_TARGET_FLAGS = -mbridgeos-version-min=$(SDKVERSION) -DXNU_TARGET_OS_BRIDGE
  85     DEPLOYMENT_LINKER_FLAGS =
  86 else ifneq ($(filter $(SUPPORTED_EMBEDDED_PLATFORMS),$(PLATFORM)),)
  87     DEPLOYMENT_TARGET_FLAGS = -miphoneos-version-min=$(SDKVERSION) -DXNU_TARGET_OS_IOS
  88     DEPLOYMENT_LINKER_FLAGS = -Wl,-ios_version_min,$(SDKVERSION)
  89 else ifneq ($(filter $(SUPPORTED_SIMULATOR_PLATFORMS),$(PLATFORM)),)
  90     DEPLOYMENT_TARGET_FLAGS =
  91     DEPLOYMENT_LINKER_FLAGS =
  92 else
  93     DEPLOYMENT_TARGET_FLAGS =
  94     DEPLOYMENT_LINKER_FLAGS =
  95 endif
  96
  97 DEPLOYMENT_TARGET_DEFINES = -DPLATFORM_$(PLATFORM)
  98
  99
 100 #
 101 # Standard defines list
 102 #
 103 DEFINES = -DAPPLE -DKERNEL -DKERNEL_PRIVATE -DXNU_KERNEL_PRIVATE \
 104         -DPRIVATE -D__MACHO__=1 -Dvolatile=__volatile $(CONFIG_DEFINES) \
 105         $(SEED_DEFINES)
 106
 107 #
 108 # Compiler command
 109 #
 110 KCC  = $(CC)
 111 KC++ = $(CXX)
 112
 113 GENASSYM_KCC = $(CC)
 114
 115 #
 116 # Compiler warning flags
 117 #
 118
 119 USE_WERROR := 1
 120 ifneq ($(BUILD_WERROR),)
 121 USE_WERROR := $(BUILD_WERROR)
 122 endif
 123
 124 ifeq ($(USE_WERROR),1)
 125 WERROR := -Werror
 126 endif
 127
 128 # Shared C/C++ warning flags
 129 # NOTE: order matters here.  -Wno-xxx goes before opt-in of ones we want
 130 WARNFLAGS_STD := \
 131         -Weverything \
 132         -Wno-pedantic \
 133         $(WERROR) \
 134         -Wno-implicit-int-conversion \
 135         -Wno-sign-conversion \
 136         -Wno-shorten-64-to-32 \
 137         -Wno-bad-function-cast \
 138         -Wno-c++-compat \
 139         -Wno-c++98-compat \
 140         -Wno-conditional-uninitialized \
 141         -Wno-covered-switch-default \
 142         -Wno-disabled-macro-expansion \
 143         -Wno-documentation-unknown-command \
 144         -Wno-extra-semi-stmt \
 145         -Wno-format-non-iso \
 146         -Wno-format-nonliteral \
 147         -Wno-language-extension-token \
 148         -Wno-missing-variable-declarations \
 149         -Wno-packed \
 150         -Wno-padded \
 151         -Wno-partial-availability \
 152         -Wno-reserved-id-macro \
 153         -Wno-shift-sign-overflow \
 154         -Wno-switch-enum \
 155         -Wno-undef \
 156         -Wno-unused-macros \
 157         -Wno-used-but-marked-unused \
 158         -Wno-variadic-macros \
 159         -Wno-vla \
 160         -Wno-zero-length-array
 161
 162 WARNFLAGS_STD := $(WARNFLAGS_STD) \
 163         -Wno-unknown-warning-option \
 164         -Wno-error=atomic-implicit-seq-cst
 165
 166 CWARNFLAGS_STD = \
 167         $(WARNFLAGS_STD)
 168
 169
 170
 171 # Can be overridden in Makefile.template or Makefile.$arch
 172 export CWARNFLAGS ?= $(CWARNFLAGS_STD)
 173
 174 define add_perfile_cflags
 175 $(1)_CWARNFLAGS_ADD += $2
 176 endef
 177
 178 define rm_perfile_cflags
 179 $(1)_CFLAGS_RM += $2
 180 endef
 181
 182 CXXWARNFLAGS_STD = \
 183         $(WARNFLAGS_STD) \
 184         -Wno-c++98-compat-pedantic \
 185         -Wno-exit-time-destructors \
 186         -Wno-global-constructors \
 187         -Wno-old-style-cast
 188
 189 # Can be overridden in Makefile.template or Makefile.$arch
 190 export CXXWARNFLAGS ?= $(CXXWARNFLAGS_STD)
 191
 192 define add_perfile_cxxflags
 193 $(1)_CXXWARNFLAGS_ADD += $2
 194 endef
 195
 196 #
 197 # Default ARCH_FLAGS, for use with compiler/linker/assembler/mig drivers
 198
 199 ARCH_FLAGS_X86_64         = -arch x86_64
 200 ARCH_FLAGS_X86_64H        = -arch x86_64h
 201
 202 ifneq ($(filter ARM ARM64,$(CURRENT_ARCH_CONFIG)),)
 203
 204 ifndef ARCH_STRING_FOR_CURRENT_MACHINE_CONFIG
 205 export ARCH_STRING_FOR_CURRENT_MACHINE_CONFIG := $(shell $(EMBEDDED_DEVICE_MAP) -db $(EDM_DBPATH) -query SELECT DISTINCT KernelMachOArchitecture FROM Targets WHERE KernelPlatform IS \"$(CURRENT_MACHINE_CONFIG_LC)\" LIMIT 1 || echo UNKNOWN )
 206 endif
 207
 208 #
 209 # This can have false negatives, and is used to avoid calling CTF when we'll build a static KC
 210 #
 211 ifndef WILL_BUILD_STATIC_KC
 212 export WILL_BUILD_STATIC_KC := $(shell $(EMBEDDED_DEVICE_MAP) -db $(EDM_DBPATH) \
 213                                 -query 'SELECT COUNT(*) != 0 FROM Targets WHERE KernelPlatform IS "$(CURRENT_MACHINE_CONFIG_LC)" \
 214                                         AND (KernelMachOArchitecture LIKE "arm64e" OR ProductType LIKE "iphone10,%")')
 215 endif
 216
 217 BUILD_STATIC_LINK := 1
 218
 219 endif
 220
 221 ARCH_FLAGS_ARM            = -arch $(ARCH_STRING_FOR_CURRENT_MACHINE_CONFIG)
 222 ARCH_FLAGS_ARM64          = -arch $(ARCH_STRING_FOR_CURRENT_MACHINE_CONFIG)
 223
 224 #
 225 # Clang static analyzer flags
 226 #
 227 ANALYZER                        = $(CC)
 228 ANALYZERPP                      = $(CXX)
 229 ANALYZERFLAGS           = --analyze -D__clang_analyzer__
 230 ifneq ($(ANALYZE_FORMAT),text)
 231 ANALYZERFLAGS           += -Xanalyzer -analyzer-output=html
 232 ANALYZERFLAGS           += -o $(OBJROOT)/analyzer-html
 233 else
 234 ANALYZERFLAGS           += -Xanalyzer -analyzer-output=text
 235 endif
 236 ifneq ($(ANALYZE_VERBOSE),YES)
 237 ANALYZERFLAGS           += -Xclang -analyzer-disable-checker -Xclang deadcode.DeadStores
 238 endif
 239
 240 #
 241 # Default CFLAGS
 242 #
 243 ifdef RC_NONARCH_CFLAGS
 244 OTHER_CFLAGS = $(RC_NONARCH_CLFAGS)
 245 endif
 246
 247 #
 248 # Debug info
 249 #
 250 DSYMINFODIR     = Contents
 251 DSYMKGMACROSDIR = Contents/Resources
 252 DSYMLLDBMACROSDIR = Contents/Resources/Python
 253 DSYMDWARFDIR    = Contents/Resources/DWARF
 254
 255 DEBUG_CFLAGS := -g
 256 BUILD_DSYM := 1
 257
 258 #
 259 # We must not use -fno-keep-inline-functions, or it will remove the dtrace
 260 # probes from the kernel.
 261 #
 262 CFLAGS_GEN = $(DEBUG_CFLAGS) -nostdinc \
 263         -ferror-limit=10000 \
 264         -fno-builtin \
 265         -fno-common \
 266         -ftrivial-auto-var-init=zero \
 267         -enable-trivial-auto-var-init-zero-knowing-it-will-be-removed-from-clang \
 268         -fsigned-bitfields \
 269         -fmerge-all-constants \
 270         -fno-c++-static-destructors \
 271         $(OTHER_CFLAGS)
 272
 273 CFLAGS_RELEASE  =
 274 CFLAGS_DEVELOPMENT      =
 275 CFLAGS_DEBUG    =
 276 CFLAGS_KASAN = $(CFLAGS_DEVELOPMENT)
 277 CFLAGS_PROFILE  =  -pg
 278
 279 CFLAGS_X86_64   = -Dx86_64 -DX86_64 -D__X86_64__ -DLP64 \
 280                                 -DPAGE_SIZE_FIXED -mkernel -msoft-float
 281
 282 CFLAGS_X86_64H = $(CFLAGS_X86_64)
 283
 284 CFLAGS_ARM      = -Darm -DARM -D__ARM__ -DPAGE_SIZE_FIXED \
 285                         -momit-leaf-frame-pointer -fno-strict-aliasing -D__API__=v4
 286
 287 CFLAGS_ARM64    = -Darm64 -DARM64 -D__ARM64__ -DLP64 -DPAGE_SIZE_FIXED \
 288                         -momit-leaf-frame-pointer -fno-strict-aliasing -D__API__=v4 -mkernel
 289
 290 CFLAGS_RELEASEX86_64 = -O2
 291 CFLAGS_DEVELOPMENTX86_64 = -O2
 292 CFLAGS_KASANX86_64 = $(CFLAGS_DEVELOPMENTX86_64)
 293 # No space optimization for the DEBUG kernel for the benefit of gdb:
 294 CFLAGS_DEBUGX86_64 = -O0
 295 CFLAGS_PROFILEX86_64 = -O2
 296
 297 CFLAGS_RELEASEX86_64H = -O2
 298 CFLAGS_DEVELOPMENTX86_64H = -O2
 299 CFLAGS_KASANX86_64H = $(CFLAGS_DEVELOPMENTX86_64H)
 300 # No space optimization for the DEBUG kernel for the benefit of gdb:
 301 CFLAGS_DEBUGX86_64H = -O0
 302 CFLAGS_PROFILEX86_64H = -O2
 303
 304 CFLAGS_RELEASEARM = -O2
 305 CFLAGS_DEVELOPMENTARM = -O2
 306 CFLAGS_DEBUGARM = -O0
 307 CFLAGS_PROFILEARM = -O2
 308
 309 CFLAGS_RELEASEARM64 = -O2
 310 CFLAGS_DEVELOPMENTARM64 = -O2
 311 CFLAGS_KASANARM64 = $(CFLAGS_DEVELOPMENTARM64)
 312 CFLAGS_DEBUGARM64 = -O0
 313 CFLAGS_PROFILEARM64 = -O2
 314
 315 #
 316 # Sanitizers Support (KASan, UBSan)
 317 #
 318
 319
 320 SAN=0
 321
 322 ifeq ($(CURRENT_KERNEL_CONFIG),KASAN)
 323 # KASan kernel config implicitly enables the KASan instrumentation.
 324 # Instrumentation for other sanitizers is enabled explicitly at build time.
 325 KASAN = 1
 326 endif
 327
 328 ifeq ($(KASAN),1)
 329 SAN=1
 330 BUILD_LTO = 0
 331 KASAN_SHIFT_ARM64=0xe000000000000000
 332 #
 333 # To calculate the kasan shift, subtract the lowest KVA to sanitize, shifted right by 3 bits,
 334 # from the base address of the kasan shadow area, (e.g. solve the following equation:
 335 # SHIFT = {VA mapped by the first KASAN PML4 [Currently #494]} - (LOWEST_KVA >> 3)
 336 # SHIFT = (0ULL - (512GiB * (512 - 494))) - (LOWEST_SAN_KVA >> 3)
 337 # SHIFT = FFFFF70000000000 - ((0ULL - (512GiB * (512 - 496))) >> 3) [PML4 #496 is the first possible KVA]
 338 # SHIFT = FFFFF70000000000 - (FFFFF80000000000 >> 3)
 339 # SHIFT = DFFFF80000000000
 340 # ).
 341 KASAN_SHIFT_X86_64=0xdffff80000000000
 342 KASAN_SHIFT_X86_64H=$(KASAN_SHIFT_X86_64)
 343 KASAN_SHIFT=$($(addsuffix $(CURRENT_ARCH_CONFIG),KASAN_SHIFT_))
 344 CFLAGS_GEN += -DKASAN=1 -DKASAN_SHIFT=$(KASAN_SHIFT) -fsanitize=address \
 345                 -mllvm -asan-globals-live-support \
 346                 -mllvm -asan-mapping-offset=$(KASAN_SHIFT)
 347
 348 endif
 349
 350 ifeq ($(UBSAN),1)
 351 SAN=1
 352 UBSAN_CHECKS = signed-integer-overflow shift pointer-overflow bounds object-size # non-fatal (calls runtime, can return)
 353 # UBSAN_CHECKS = undefined nullability unsigned-integer-overflow # everything
 354 UBSAN_CHECKS_FATAL =                                           # fatal (calls runtime, must not return)
 355 UBSAN_CHECKS_TRAP = vla-bound builtin                          # emit a trap instruction (no runtime support)
 356 UBSAN_DISABLED =
 357
 358 UBSAN_DISABLED += vptr function     # requires unsupported C++ runtime
 359 ifeq ($(KASAN),1)
 360 # UBSan alignment + KASan code size is too large
 361 # UBSan unreachable doesn't play nice with ASan (40723397)
 362 UBSAN_DISABLED += alignment unreachable
 363 endif
 364
 365 CFLAGS_GEN += -DUBSAN=1
 366 CFLAGS_GEN += $(foreach x,$(UBSAN_CHECKS) $(UBSAN_CHECKS_FATAL) $(UBSAN_CHECKS_TRAP),-fsanitize=$(x))
 367 CFLAGS_GEN += $(foreach x,$(UBSAN_CHECKS_FATAL),-fno-sanitize-recover=$(x))
 368 CFLAGS_GEN += $(foreach x,$(UBSAN_CHECKS_TRAP),-fsanitize-trap=$(x))
 369 CFLAGS_GEN += $(foreach x,$(UBSAN_DISABLED),-fno-sanitize=$(x))
 370 endif
 371
 372 ifeq ($(KSANCOV),1)
 373 # Enable SanitizerCoverage instrumentation in xnu
 374 SAN = 1
 375 KSANCOV_CFLAGS := -fsanitize-coverage=trace-pc-guard
 376 CFLAGS_GEN += $(KSANCOV_CFLAGS) -DKSANCOV=1
 377 endif
 378
 379 ifeq ($(SAN),1)
 380 CFLAGS_GEN += -fsanitize-blacklist=$(OBJROOT)/san/kasan-blacklist-$(CURRENT_ARCH_CONFIG_LC)
 381 endif
 382
 383
 384 CFLAGS  = $(CFLAGS_GEN) \
 385                   $($(addsuffix $(CURRENT_MACHINE_CONFIG),MACHINE_FLAGS_$(CURRENT_ARCH_CONFIG)_)) \
 386                   $($(addsuffix $(CURRENT_ARCH_CONFIG),ARCH_FLAGS_)) \
 387                   $($(addsuffix $(CURRENT_ARCH_CONFIG),CFLAGS_)) \
 388                   $($(addsuffix $(CURRENT_KERNEL_CONFIG),CFLAGS_)) \
 389                   $($(addsuffix $(CURRENT_ARCH_CONFIG), $(addsuffix $(CURRENT_KERNEL_CONFIG),CFLAGS_))) \
 390                   $(DEPLOYMENT_TARGET_FLAGS) \
 391                   $(DEPLOYMENT_TARGET_DEFINES) \
 392                   $(DEFINES)
 393
 394 #
 395 # Default C++ flags
 396 #
 397
 398 OTHER_CXXFLAGS  =
 399
 400 CXXFLAGS_GEN  = -std=gnu++1z -fsized-deallocation -fapple-kext $(OTHER_CXXFLAGS)
 401
 402 CXXFLAGS      = $(CXXFLAGS_GEN) \
 403                   $($(addsuffix $(CURRENT_ARCH_CONFIG),CXXFLAGS_)) \
 404                   $($(addsuffix $(CURRENT_KERNEL_CONFIG),CXXFLAGS_))
 405
 406 #
 407 # Assembler command
 408 #
 409 AS      = $(CC)
 410 S_KCC   = $(CC)
 411
 412 #
 413 # Default SFLAGS
 414 #
 415 SFLAGS_GEN = -D__ASSEMBLER__ -DASSEMBLER $(OTHER_CFLAGS)
 416
 417 SFLAGS_RELEASE  =
 418 SFLAGS_DEVELOPMENT      =
 419 SFLAGS_KASAN = $(SFLAGS_DEVELOPMENT) -DKASAN=1
 420 SFLAGS_DEBUG    =
 421 SFLAGS_PROFILE  =
 422
 423 SFLAGS_X86_64   = $(CFLAGS_X86_64)
 424 SFLAGS_X86_64H  = $(CFLAGS_X86_64H)
 425 SFLAGS_ARM      = $(CFLAGS_ARM)
 426 SFLAGS_ARM64    = $(CFLAGS_ARM64)
 427
 428 SFLAGS  = $(SFLAGS_GEN) \
 429                   $($(addsuffix $(CURRENT_MACHINE_CONFIG),MACHINE_FLAGS_$(CURRENT_ARCH_CONFIG)_)) \
 430                   $($(addsuffix $(CURRENT_ARCH_CONFIG),ARCH_FLAGS_)) \
 431                   $($(addsuffix $(CURRENT_ARCH_CONFIG),SFLAGS_)) \
 432                   $($(addsuffix $(CURRENT_KERNEL_CONFIG),SFLAGS_)) \
 433                   $(DEPLOYMENT_TARGET_FLAGS) \
 434                   $(DEPLOYMENT_TARGET_DEFINES) \
 435                   $(DEFINES)
 436
 437 #
 438 # Linker command
 439 #
 440 LD      = $(KC++) -nostdlib
 441
 442 #
 443 # Default LDFLAGS
 444 #
 445 # Availability of DWARF allows DTrace CTF (compressed type format) to be constructed.
 446 # ctf_insert creates the CTF section.  It needs reserved padding in the
 447 # headers for the load command segment and the CTF section structures.
 448 #
 449 LDFLAGS_KERNEL_GEN = \
 450         -nostdlib \
 451         -fapple-kext \
 452         -Wl,-e,__start \
 453         -Wl,-sectalign,__TEXT,__text,0x1000 \
 454         -Wl,-sectalign,__DATA,__common,0x1000 \
 455         -Wl,-sectalign,__DATA,__bss,0x1000 \
 456         -Wl,-sectcreate,__PRELINK_TEXT,__text,/dev/null \
 457         -Wl,-sectcreate,__PRELINK_INFO,__info,/dev/null \
 458         -Wl,-new_linker \
 459         -Wl,-pagezero_size,0x0 \
 460         -Wl,-version_load_command \
 461         -Wl,-function_starts \
 462         -Wl,-headerpad,152
 463
 464 # LDFLAGS_KERNEL_SDK    = -L$(SDKROOT)/usr/local/lib/kernel -lfirehose_kernel
 465 LDFLAGS_KERNEL_SDK      = -L$(SDKROOT)/usr/local/lib/kernel
 466
 467 LDFLAGS_KERNEL_RELEASE  =
 468 LDFLAGS_KERNEL_DEVELOPMENT     =
 469 LDFLAGS_KERNEL_KASAN = $(LDFLAGS_KERNEL_DEVELOPMENT)
 470 LDFLAGS_KERNEL_DEBUG    =
 471 LDFLAGS_KERNEL_PROFILE  =
 472
 473 # KASLR static slide config:
 474 ifndef SLIDE
 475 SLIDE=0x00
 476 endif
 477 KERNEL_MIN_ADDRESS      = 0xffffff8000000000
 478 KERNEL_BASE_OFFSET      = 0x100000
 479 KERNEL_STATIC_SLIDE     = $(shell printf "0x%016x" \
 480                           $$[ $(SLIDE) << 21 ])
 481 KERNEL_STATIC_BASE      = $(shell printf "0x%016x" \
 482                           $$[ $(KERNEL_MIN_ADDRESS) + $(KERNEL_BASE_OFFSET) ])
 483 KERNEL_HIB_SECTION_BASE = $(shell printf "0x%016x" \
 484                           $$[ $(KERNEL_STATIC_BASE) + $(KERNEL_STATIC_SLIDE) ])
 485 KERNEL_TEXT_BASE        = $(shell printf "0x%016x" \
 486                           $$[ $(KERNEL_HIB_SECTION_BASE) + 0x100000 ])
 487
 488 LDFLAGS_KERNEL_RELEASEX86_64 = \
 489         -Wl,-pie \
 490         -Wl,-segaddr,__HIB,$(KERNEL_HIB_SECTION_BASE) \
 491         -Wl,-image_base,$(KERNEL_TEXT_BASE) \
 492         -Wl,-seg_page_size,__TEXT,0x200000 \
 493         -Wl,-sectalign,__HIB,__bootPT,0x1000 \
 494         -Wl,-sectalign,__HIB,__desc,0x1000 \
 495         -Wl,-sectalign,__HIB,__data,0x1000 \
 496         -Wl,-sectalign,__HIB,__text,0x1000 \
 497         -Wl,-sectalign,__HIB,__const,0x1000 \
 498         -Wl,-sectalign,__HIB,__bss,0x1000 \
 499         -Wl,-sectalign,__HIB,__common,0x1000 \
 500         -Wl,-sectalign,__HIB,__llvm_prf_cnts,0x1000 \
 501         -Wl,-sectalign,__HIB,__llvm_prf_names,0x1000 \
 502         -Wl,-sectalign,__HIB,__llvm_prf_data,0x1000 \
 503         -Wl,-sectalign,__HIB,__textcoal_nt,0x1000 \
 504         -Wl,-rename_section,__DATA,__const,__DATA_CONST,__const \
 505         -Wl,-no_zero_fill_sections \
 506         $(LDFLAGS_NOSTRIP_FLAG)
 507
 508 ifeq ($(SAN),1)
 509 LDFLAGS_KERNEL_RELEASEX86_64 += \
 510         -Wl,-sectalign,__HIB,__cstring,0x1000
 511 endif
 512
 513 ifeq ($(KSANCOV),1)
 514 LDFLAGS_KERNEL_RELEASEX86_64 += \
 515         -Wl,-sectalign,__HIB,__sancov_guards,0x1000 \
 516         -Wl,-sectalign,__HIB,__sancov_pcs,0x1000
 517 endif
 518
 519 # Define KERNEL_BASE_OFFSET so known at compile time:
 520 CFLAGS_X86_64 += -DKERNEL_BASE_OFFSET=$(KERNEL_BASE_OFFSET)
 521 CFLAGS_X86_64H += -DKERNEL_BASE_OFFSET=$(KERNEL_BASE_OFFSET)
 522
 523 LDFLAGS_KERNEL_DEBUGX86_64 = $(LDFLAGS_KERNEL_RELEASEX86_64)
 524 LDFLAGS_KERNEL_DEVELOPMENTX86_64 = $(LDFLAGS_KERNEL_RELEASEX86_64)
 525 LDFLAGS_KERNEL_KASANX86_64 = $(LDFLAGS_KERNEL_DEVELOPMENTX86_64) \
 526         -Wl,-sectalign,__HIB,__asan_globals,0x1000 \
 527         -Wl,-sectalign,__HIB,__asan_liveness,0x1000 \
 528         -Wl,-sectalign,__HIB,__mod_term_func,0x1000 \
 529         -Wl,-rename_section,__HIB,__mod_init_func,__NULL,__mod_init_func \
 530         -Wl,-rename_section,__HIB,__eh_frame,__NULL,__eh_frame
 531 LDFLAGS_KERNEL_PROFILEX86_64 = $(LDFLAGS_KERNEL_RELEASEX86_64)
 532
 533 LDFLAGS_KERNEL_RELEASEX86_64H = $(LDFLAGS_KERNEL_RELEASEX86_64)
 534 LDFLAGS_KERNEL_DEBUGX86_64H = $(LDFLAGS_KERNEL_RELEASEX86_64H)
 535 LDFLAGS_KERNEL_DEVELOPMENTX86_64H = $(LDFLAGS_KERNEL_RELEASEX86_64H)
 536 LDFLAGS_KERNEL_KASANX86_64H = $(LDFLAGS_KERNEL_KASANX86_64)
 537 LDFLAGS_KERNEL_PROFILEX86_64H = $(LDFLAGS_KERNEL_RELEASEX86_64H)
 538
 539 # We preload ___udivmoddi4 in order to work around an issue with building
 540 # LTO on armv7.
 541 LDFLAGS_KERNEL_GENARM = \
 542         -Wl,-pie \
 543         -Wl,-static \
 544         -Wl,-image_base,0x80001000 \
 545         -Wl,-sectalign,__DATA,__const,0x1000 \
 546         -Wl,-u,___udivmoddi4
 547
 548 LDFLAGS_KERNEL_RELEASEARM     = \
 549         $(LDFLAGS_KERNEL_GENARM) \
 550         $(LDFLAGS_KERNEL_STRIP_LTO)
 551
 552 LDFLAGS_KERNEL_EXPORTS_RELEASEARM     = \
 553         -Wl,-exported_symbols_list,$(TARGET)/all-kpi.exp
 554
 555 LDFLAGS_KERNEL_DEVELOPMENTARM     = \
 556         $(LDFLAGS_KERNEL_GENARM) \
 557         $(LDFLAGS_NOSTRIP_FLAG)
 558
 559 LDFLAGS_KERNEL_EXPORTS_DEVELOPMENTARM =
 560
 561 LDFLAGS_KERNEL_DEBUGARM = $(LDFLAGS_KERNEL_DEVELOPMENTARM)
 562 LDFLAGS_KERNEL_EXPORTS_DEBUGARM = $(LDFLAGS_KERNEL_EXPORTS_DEVELOPMENTARM)
 563
 564 # Offset image base by page to have iBoot load kernel TEXT correctly.
 565 # First page is used for various purposes : sleep token, reset vector.
 566 # We also need a 32MB offset, as this is the minimum block mapping size
 567 # for a 16KB page runtime, and we wish to use the first virtual block
 568 # to map the low globals page.  We also need another 4MB to account for
 569 # the address space reserved by L4 (because the reservation is not a
 570 # multiple of the block size in alignment/length, we will implictly map
 571 # it with our block mapping, and we therefore must reflect that the
 572 # first 4MB of the block mapping for xnu do not belong to xnu).
 573 # For the moment, kaliber has a unique memory layout (monitor at the top
 574 # of memory).  Support this by breaking 16KB on other platforms and
 575 # mandating 32MB alignment. Image base (i.e. __TEXT) must be 16KB
 576 # aligned since ld64 will link with 16KB alignment for ARM64.
 577 #
 578 # We currently offset by an additional 32MB in order to reclaim memory.
 579 # We need a dedicated virtual page for the low globals.  Our bootloader
 580 # may have a significant chunk of memory (up to an L2 entry in size)
 581 # that lies before the kernel.  The addition 32MB of virtual padding
 582 # ensures that we have enough virtual address space to map all of that
 583 # memory as part of the V-to-P mapping.
 584 # 23355738 - put __PRELINK_TEXT first. We reserve enough room
 585 # for 0x0000000003000000 = 48MB of kexts
 586 #
 587 # 0xfffffff000000000 (32MB range for low globals)
 588 # 0xfffffff002000000 (32MB range to allow for large page physical slide)
 589 # 0xfffffff004000000 (16KB range to reserve the first available page)
 590 # 0xfffffff004004000 (48MB range for kexts)
 591 # 0xfffffff007004000 (Start of xnu proper).
 592 LDFLAGS_KERNEL_GENARM64 = \
 593         -Wl,-pie \
 594         -Wl,-static \
 595         -Wl,-segaddr,__PRELINK_TEXT,0xfffffff004004000 \
 596         -Wl,-image_base,0xfffffff007004000 \
 597         -Wl,-sectalign,__DATA,__const,0x4000 \
 598         -Wl,-rename_section,__DATA,__mod_init_func,__DATA_CONST,__mod_init_func \
 599         -Wl,-rename_section,__DATA,__mod_term_func,__DATA_CONST,__mod_term_func \
 600         -Wl,-rename_section,__DATA,__auth_ptr,__DATA_CONST,__auth_ptr \
 601         -Wl,-rename_section,__DATA,__auth_got,__DATA_CONST,__auth_got \
 602         -Wl,-rename_section,__DATA,__const,__DATA_CONST,__const \
 603         -Wl,-rename_section,__TEXT,__text,__TEXT_EXEC,__text \
 604         -Wl,-rename_section,__TEXT,__stubs,__TEXT_EXEC,__stubs \
 605         -Wl,-rename_section,__TEXT,initcode,__TEXT_EXEC,initcode \
 606         -Wl,-sectcreate,"__PLK_TEXT_EXEC",__text,/dev/null \
 607         -Wl,-sectcreate,__PRELINK_DATA,__data,/dev/null \
 608         -Wl,-sectcreate,"__PLK_DATA_CONST",__data,/dev/null \
 609         -Wl,-sectcreate,"__PLK_LLVM_COV",__llvm_covmap,/dev/null \
 610         -Wl,-sectcreate,"__PLK_LINKEDIT",__data,/dev/null
 611
 612
 613 LDFLAGS_KERNEL_SEGARM64 ?= \
 614         -Wl,-segment_order,__TEXT:__DATA_CONST:__LINKEDIT:__TEXT_EXEC:__LAST:__KLD:__DATA:__BOOTDATA
 615
 616 LDFLAGS_KERNEL_RELEASEARM64     = \
 617         $(LDFLAGS_KERNEL_GENARM64) \
 618         $(LDFLAGS_KERNEL_SEGARM64) \
 619         $(LDFLAGS_KERNEL_STRIP_LTO)
 620
 621 LDFLAGS_KERNEL_EXPORTS_RELEASEARM64     = \
 622         -Wl,-exported_symbols_list,$(TARGET)/all-kpi.exp
 623
 624 LDFLAGS_KERNEL_DEVELOPMENTARM64     = \
 625         $(LDFLAGS_KERNEL_GENARM64) \
 626         $(LDFLAGS_KERNEL_SEGARM64) \
 627         $(LDFLAGS_NOSTRIP_FLAG)
 628
 629 LDFLAGS_KERNEL_EXPORTS_DEVELOPMENTARM64 =
 630
 631 LDFLAGS_KERNEL_KASANARM64 = $(LDFLAGS_KERNEL_DEVELOPMENTARM64)
 632 LDFLAGS_KERNEL_DEBUGARM64 = $(LDFLAGS_KERNEL_DEVELOPMENTARM64)
 633
 634 LDFLAGS_KERNEL_EXPORTS_KASANARM64 = $(LDFLAGS_KERNEL_EXPORTS_DEVELOPMENTARM64)
 635 LDFLAGS_KERNEL_EXPORTS_DEBUGARM64 = $(LDFLAGS_KERNEL_EXPORTS_DEVELOPMENTARM64)
 636
 637 LDFLAGS_KERNEL  = $(LDFLAGS_KERNEL_GEN) \
 638                   $(LDFLAGS_KERNEL_SDK) \
 639                   $($(addsuffix $(CURRENT_ARCH_CONFIG),ARCH_FLAGS_)) \
 640                   $($(addsuffix $(CURRENT_ARCH_CONFIG),LDFLAGS_KERNEL_)) \
 641                   $($(addsuffix $(CURRENT_KERNEL_CONFIG),LDFLAGS_KERNEL_)) \
 642                   $($(addsuffix $(CURRENT_ARCH_CONFIG), $(addsuffix $(CURRENT_KERNEL_CONFIG),LDFLAGS_KERNEL_))) \
 643                   $(DEPLOYMENT_TARGET_FLAGS)
 644
 645
 646 LDFLAGS_KERNEL_EXPORTS   =   \
 647                   $($(addsuffix $(CURRENT_ARCH_CONFIG), $(addsuffix $(CURRENT_KERNEL_CONFIG),LDFLAGS_KERNEL_EXPORTS_))) \
 648                   -Wl,-alias_list,$(TARGET)/all-alias.exp
 649
 650
 651 #
 652 # Default runtime libraries to be linked with the kernel
 653 #
 654 LD_KERNEL_LIBS     = -lcc_kext
 655 LD_KERNEL_ARCHIVES = $(LDFLAGS_KERNEL_SDK) -lfirehose_kernel
 656
 657 #
 658 # DTrace support
 659 #
 660 ifndef DO_CTFMERGE
 661 DO_CTFMERGE := 1
 662 ifeq ($(CURRENT_KERNEL_CONFIG),RELEASE)
 663 ifneq ($(filter ARM%,$(CURRENT_ARCH_CONFIG)),)
 664 DO_CTFMERGE := 0
 665 endif
 666 endif
 667 ifneq ($(CURRENT_KERNEL_CONFIG),KASAN)
 668 ifeq ($(WILL_BUILD_STATIC_KC),1)
 669 DO_CTFMERGE := 0
 670 endif
 671 endif
 672 endif # DO_CTFMERGE
 673
 674
 675 #
 676 # Default INCFLAGS
 677 #
 678 INCFLAGS_IMPORT = $(patsubst %, -I$(OBJROOT)/EXPORT_HDRS/%, $(COMPONENT_IMPORT_LIST))
 679 INCFLAGS_EXTERN = -I$(SRCROOT)/EXTERNAL_HEADERS
 680 INCFLAGS_GEN    = -I$(SRCROOT)/$(COMPONENT) -I$(OBJROOT)/EXPORT_HDRS/$(COMPONENT)
 681 INCFLAGS_LOCAL  = -I.
 682 INCFLAGS_SDK    = -I$(SDKROOT)/usr/local/include/kernel
 683
 684 INCFLAGS        = $(INCFLAGS_LOCAL) $(INCFLAGS_GEN) $(INCFLAGS_IMPORT) $(INCFLAGS_EXTERN) $(INCFLAGS_MAKEFILE) $(INCFLAGS_SDK)
 685
 686 #
 687 # Default MIGFLAGS
 688 #
 689 MIGFLAGS        = $(DEFINES) $(INCFLAGS) -novouchers $($(addsuffix $(CURRENT_ARCH_CONFIG),CFLAGS_)) $($(addsuffix $(CURRENT_ARCH_CONFIG),ARCH_FLAGS_)) \
 690                 $(DEPLOYMENT_TARGET_FLAGS)
 691
 692 # Support for LLVM Profile Guided Optimization (PGO)
 693
 694 ifeq ($(BUILD_PROFILE),1)
 695 CFLAGS_GEN += -fprofile-instr-generate -DPROFILE
 696 CXXFLAGS_GEN += -fprofile-instr-generate -DPROFILE
 697 endif
 698
 699 ifdef USE_PROFILE
 700 CFLAGS_GEN += -fprofile-instr-use=$(USE_PROFILE)
 701 CXXFLAGS_GEN += -fprofile-instr-use=$(USE_PROFILE)
 702 LDFLAGS_KERNEL_GEN += -fprofile-instr-use=$(USE_PROFILE)
 703
 704 CFLAGS_GEN += -Wno-error=profile-instr-out-of-date
 705 endif
 706
 707 #
 708 # Support for LLVM Link Time Optimization (LTO)
 709 #
 710 # LTO can be explicitly enabled or disabled with BUILD_LTO=1|0
 711 # and defaults to enabled except for DEBUG kernels
 712 #
 713 # CFLAGS_NOLTO_FLAG is needed on a per-file basis (for files
 714 # that deal poorly with LTO, or files that must be machine
 715 # code *.o files for xnu to build (i.e, setsegname runs on
 716 # them).
 717 #
 718 # LDFLAGS_NOSTRIP_FLAG is used to support configurations that
 719 # do not utilize an export list.  For these configs to build,
 720 # we need to prevent the LTO logic from dead stripping them.
 721
 722 LTO_ENABLED_RELEASE = 1
 723 LTO_ENABLED_DEVELOPMENT = 1
 724 LTO_ENABLED_DEBUG = 0
 725 LTO_ENABLED_KASAN = 0
 726
 727 ifneq ($(BUILD_LTO),)
 728 USE_LTO = $(BUILD_LTO)
 729 else
 730 USE_LTO = $(LTO_ENABLED_$(CURRENT_KERNEL_CONFIG))
 731 endif
 732
 733 ifeq ($(USE_LTO),1)
 734 CFLAGS_GEN      += -flto
 735 CXXFLAGS_GEN    += -flto
 736 LDFLAGS_KERNEL_LTO      = -Wl,-mllvm,-inline-threshold=100
 737 LDFLAGS_KERNEL_GEN      += $(LDFLAGS_KERNEL_LTO) -Wl,-object_path_lto,$(TARGET)/lto.o
 738 LDFLAGS_NOSTRIP_FLAG = -rdynamic
 739 LDFLAGS_KERNEL_STRIP_LTO = -Wl,-dead_strip,-no_dead_strip_inits_and_terms
 740
 741 CFLAGS_NOLTO_FLAG = -fno-lto
 742 else
 743 LDFLAGS_KERNEL_LTO =
 744 LDFLAGS_NOSTRIP_FLAG =
 745 LDFLAGS_KERNEL_STRIP_LTO =
 746 CFLAGS_NOLTO_FLAG =
 747 endif
 748
 749 ifeq ($(BUILD_JSON_COMPILATION_DATABASE),1)
 750 BUILD_DSYM      := 0
 751 DO_CTFMERGE     := 0
 752 KCC             = $(JSONCOMPILATIONDB) $(OBJPATH)/compile_commands.json $(PWD) $< $(CC)
 753 KC++            = $(JSONCOMPILATIONDB) $(OBJPATH)/compile_commands.json $(PWD) $< $(CXX)
 754 S_KCC           = $(JSONCOMPILATIONDB) $(OBJPATH)/compile_commands.json $(PWD) $< $(CC)
 755 STRIP           = true
 756 endif
 757
 758 #
 759 # Default VPATH
 760 #
 761 export VPATH = .:$(SOURCE)
 762
 763
 764
 765 #
 766 # Macros that control installation of kernel and its header files
 767 #
 768 # install flags for header files
 769 #
 770 INSTALL_FLAGS = -c -S -m 0444
 771 DATA_INSTALL_FLAGS = -c -S -m 0644
 772 EXEC_INSTALL_FLAGS = -c -S -m 0755
 773
 774 #
 775 # Header file destinations
 776 #
 777
 778 ifeq ($(DRIVERKIT),1)
 779     SDKHEADERSROOT=$(DRIVERKITRUNTIMEROOT)
 780     # only whitelisted headers install outside of the DriverKit Runtime hierarchy
 781     DRIVERKITSDKHEADERSROOT=$(DRIVERKITROOT)
 782     DRIVERKITFRAMEDIR = $(DRIVERKITROOT)/System/Library/Frameworks
 783 endif
 784
 785 FRAMEDIR = $(SDKHEADERSROOT)/System/Library/Frameworks
 786
 787 SINCVERS = B
 788 SINCFRAME = $(FRAMEDIR)/System.framework
 789 SINCDIR = $(SINCFRAME)/Versions/$(SINCVERS)/Headers
 790 SPINCDIR = $(SINCFRAME)/Versions/$(SINCVERS)/PrivateHeaders
 791 SRESDIR = $(SINCFRAME)/Versions/$(SINCVERS)/Resources
 792
 793 ifndef INCDIR
 794     INCDIR = $(SDKHEADERSROOT)/usr/include
 795 endif
 796 ifndef DRIVERKITINCDIR
 797     DRIVERKITINCDIR = $(DRIVERKITSDKHEADERSROOT)/usr/include
 798 endif
 799 ifndef LCLDIR
 800     LCLDIR = $(SPINCDIR)
 801 endif
 802 ifndef DRIVERKITLCLDIR
 803     DRIVERKITLCLDIR = $(DRIVERKITSDKHEADERSROOT)/usr/local/include
 804 endif
 805
 806 KINCVERS = A
 807 KINCFRAME = $(FRAMEDIR)/Kernel.framework
 808 KINCDIR = $(KINCFRAME)/Versions/$(KINCVERS)/Headers
 809 KPINCDIR = $(KINCFRAME)/Versions/$(KINCVERS)/PrivateHeaders
 810 KRESDIR = $(KINCFRAME)/Versions/$(KINCVERS)/Resources
 811
 812 DKIT_INCVERS = A
 813 DKIT_INCFRAME = DriverKit.framework
 814 DKIT_INCDIR = $(DKIT_INCFRAME)/Versions/$(DKIT_INCVERS)/Headers
 815 DKIT_PINCDIR = $(DKIT_INCFRAME)/Versions/$(DKIT_INCVERS)/PrivateHeaders
 816 # DriverKit SDK frameworks use shallow bundle structure
 817 DRIVERKIT_DKIT_INCDIR = $(DKIT_INCFRAME)/Headers
 818 DRIVERKIT_DKIT_PINCDIR = $(DKIT_INCFRAME)/PrivateHeaders
 819
 820 XNU_PRIVATE_UNIFDEF = -UMACH_KERNEL_PRIVATE -UBSD_KERNEL_PRIVATE -UIOKIT_KERNEL_PRIVATE -ULIBKERN_KERNEL_PRIVATE -ULIBSA_KERNEL_PRIVATE -UPEXPERT_KERNEL_PRIVATE -UXNU_KERNEL_PRIVATE
 821
 822
 823 PLATFORM_UNIFDEF = $(foreach x,$(SUPPORTED_PLATFORMS),$(if $(filter $(PLATFORM),$(x)),-DPLATFORM_$(x) $(foreach token,$(PLATFORM_UNIFDEF_BLACKLIST_TOKENS_$(x)),-U$(token)),-UPLATFORM_$(x)))
 824
 825
 826 SPINCFRAME_UNIFDEF  = $(PLATFORM_UNIFDEF) $(XNU_PRIVATE_UNIFDEF) $(SEED_DEFINES) -UKERNEL_PRIVATE -UKERNEL -DPRIVATE -UDRIVERKIT -U_OPEN_SOURCE_ -U__OPEN_SOURCE__
 827 SINCFRAME_UNIFDEF   = $(PLATFORM_UNIFDEF) $(XNU_PRIVATE_UNIFDEF) $(SEED_DEFINES) -UKERNEL_PRIVATE -UKERNEL -UPRIVATE -UDRIVERKIT -D_OPEN_SOURCE_ -D__OPEN_SOURCE__
 828 DKPINCFRAME_UNIFDEF = $(PLATFORM_UNIFDEF) $(XNU_PRIVATE_UNIFDEF) $(SEED_DEFINES) -UKERNEL_PRIVATE -UKERNEL -DPRIVATE -DDRIVERKIT -U_OPEN_SOURCE_ -U__OPEN_SOURCE__
 829 DKINCFRAME_UNIFDEF  = $(PLATFORM_UNIFDEF) $(XNU_PRIVATE_UNIFDEF) $(SEED_DEFINES) -UKERNEL_PRIVATE -UKERNEL -UPRIVATE -DDRIVERKIT -D_OPEN_SOURCE_ -D__OPEN_SOURCE__
 830 KPINCFRAME_UNIFDEF  = $(PLATFORM_UNIFDEF) $(XNU_PRIVATE_UNIFDEF) $(SEED_DEFINES) -DKERNEL_PRIVATE -DKERNEL -DPRIVATE -UDRIVERKIT -U_OPEN_SOURCE_ -U__OPEN_SOURCE__
 831 KINCFRAME_UNIFDEF   = $(PLATFORM_UNIFDEF) $(XNU_PRIVATE_UNIFDEF) $(SEED_DEFINES) -UKERNEL_PRIVATE -DKERNEL -UPRIVATE -UDRIVERKIT -D_OPEN_SOURCE_ -D__OPEN_SOURCE__
 832 DATA_UNIFDEF        = $(PLATFORM_UNIFDEF) $(XNU_PRIVATE_UNIFDEF) $(SEED_DEFINES) -D_OPEN_SOURCE_ -D__OPEN_SOURCE__
 833
 834 #
 835 # Compononent Header file destinations
 836 #
 837 EXPDIR = EXPORT_HDRS/$(COMPONENT)
 838
 839 #
 840 # Strip Flags
 841 #
 842 STRIP_FLAGS_RELEASE     = -S -x
 843 STRIP_FLAGS_DEVELOPMENT = -S
 844 STRIP_FLAGS_KASAN = $(STRIP_FLAGS_DEVELOPMENT)
 845 STRIP_FLAGS_DEBUG       = -S
 846 STRIP_FLAGS_PROFILE     = -S -x
 847
 848 STRIP_FLAGS     = $($(addsuffix $(CURRENT_KERNEL_CONFIG),STRIP_FLAGS_))
 849
 850 #
 851 # dsymutil flags
 852 #
 853 DSYMUTIL_FLAGS_GEN      = --minimize
 854
 855 DSYMUTIL_FLAGS_X86_64   = --arch=x86_64
 856 DSYMUTIL_FLAGS_X86_64H  = --arch=x86_64h
 857 DSYMUTIL_FLAGS_ARM      = --arch=arm
 858 DSYMUTIL_FLAGS_ARM64    =
 859
 860 DSYMUTIL_FLAGS = $(DSYMUTIL_FLAGS_GEN) \
 861         $($(addsuffix $(CURRENT_ARCH_CONFIG),DSYMUTIL_FLAGS_))
 862
 863 #
 864 # Man Page destination
 865 #
 866 MANDIR = /usr/share/man
 867
 868 #
 869 # DEBUG alias location
 870 #
 871 DEVELOPER_EXTRAS_DIR = /AppleInternal/CoreOS/xnu_$(CURRENT_KERNEL_CONFIG_LC)
 872
 873 #
 874 # mach_kernel install location
 875 #
 876 INSTALL_KERNEL_DIR = /
 877
 878 #
 879 # new OS X install location
 880 #
 881 SYSTEM_LIBRARY_KERNELS_DIR = /System/Library/Kernels
 882
 883 #
 884 # File names in DSTROOT
 885 #
 886
 887 ifeq ($(PLATFORM),MacOSX)
 888 KERNEL_FILE_NAME_PREFIX = kernel
 889 else
 890 KERNEL_FILE_NAME_PREFIX = mach
 891 endif
 892
 893 ifeq ($(CURRENT_MACHINE_CONFIG),NONE)
 894 ifeq ($(CURRENT_KERNEL_CONFIG),RELEASE)
 895 KERNEL_FILE_NAME = $(KERNEL_FILE_NAME_PREFIX)
 896 KERNEL_LLDBBOOTSTRAP_NAME = $(KERNEL_FILE_NAME_PREFIX).py
 897 else
 898 KERNEL_FILE_NAME = $(KERNEL_FILE_NAME_PREFIX).$(CURRENT_KERNEL_CONFIG_LC)
 899 KERNEL_LLDBBOOTSTRAP_NAME = $(KERNEL_FILE_NAME_PREFIX).py
 900 endif
 901 else
 902 KERNEL_FILE_NAME = $(KERNEL_FILE_NAME_PREFIX).$(CURRENT_KERNEL_CONFIG_LC).$(CURRENT_MACHINE_CONFIG_LC)
 903 KERNEL_LLDBBOOTSTRAP_NAME = $(KERNEL_FILE_NAME_PREFIX)_$(CURRENT_KERNEL_CONFIG_LC).py
 904 endif
 905
 906 CURRENT_ALIAS_MACHINE_CONFIG = $(word 4,$(subst ^, ,$(CURRENT_BUILD_CONFIG)))
 907 CURRENT_ALIAS_MACHINE_CONFIG_LC = $(shell printf "%s" "$(CURRENT_ALIAS_MACHINE_CONFIG)" | $(TR) A-Z a-z)
 908 ifneq ($(CURRENT_ALIAS_MACHINE_CONFIG),)
 909 ALIAS_FILE_NAME = $(KERNEL_FILE_NAME_PREFIX).$(CURRENT_KERNEL_CONFIG_LC).$(CURRENT_ALIAS_MACHINE_CONFIG_LC)
 910 endif
 911
 912 #
 913 # System.kext pseudo-kext install location
 914 #
 915 INSTALL_EXTENSIONS_DIR = /System/Library/Extensions
 916
 917 #
 918 # KDK location
 919 #
 920 INSTALL_KERNEL_SYM_DIR = /System/Library/Extensions/KDK
 921
 922 #
 923 # Misc. Etc.
 924 #
 925 INSTALL_SHARE_MISC_DIR = /usr/share/misc
 926 INSTALL_DTRACE_SCRIPTS_DIR = /usr/lib/dtrace
 927 INSTALL_DTRACE_LIBEXEC_DIR = /usr/libexec/dtrace
 928
 929 #
 930 # Overrides for XBS build aliases
 931 #
 932 ifeq ($(RC_ProjectName),xnu_debug)
 933 INSTALL_KERNEL_DIR := $(DEVELOPER_EXTRAS_DIR)
 934 INSTALL_KERNEL_SYM_DIR := $(DEVELOPER_EXTRAS_DIR)
 935 INSTALL_KERNEL_SYM_TO_KDK = 1
 936 INSTALL_XNU_DEBUG_FILES = 1
 937 else ifneq ($(filter $(SUPPORTED_EMBEDDED_PLATFORMS),$(PLATFORM)),)
 938 INSTALL_KERNEL_SYM_TO_KDK = 1
 939 USE_BINARY_PLIST = 1
 940 else ifneq ($(filter $(SUPPORTED_SIMULATOR_PLATFORMS),$(PLATFORM)),)
 941 USE_BINARY_PLIST = 1
 942 else ifeq ($(PLATFORM),MacOSX)
 943 INSTALL_KERNEL_DIR := $(SYSTEM_LIBRARY_KERNELS_DIR)
 944 INSTALL_KERNEL_SYM_DIR := $(SYSTEM_LIBRARY_KERNELS_DIR)
 945 INSTALL_KERNEL_SYM_TO_KDK = $(if $(filter YES,$(DWARF_DSYM_FILE_SHOULD_ACCOMPANY_PRODUCT)),1,0)
 946 endif
 947
 948 ifeq ($(RC_ProjectName),xnu_kasan)
 949 INSTALL_KASAN_ONLY = 1
 950 endif
 951
 952 # vim: set ft=make: