xnu-3789.41.3.tar.gz

[apple/xnu.git] / makedefs / MakeInc.top

# -*- mode: makefile;-*-
#
# Copyright (C) 2010-2016 Apple Inc. All rights reserved.
#
# MakeInc.top is the top-level makefile for the xnu
# build system. All the main XBS targets
# (like "installhdrs") are defined here, as
# well as globals that can be overridden on
# the command-line by the user.
#
# This makefile's main purpose is to bootstrap
# the user's intent ("build these 3 kernels")
# into 3 single-architecture builds that each
# invoke the recursive make build system.
# As such, we have no knowledge of how to build
# a kernel or perform actions other than
# invoking a sub-make with a different
# current directory, makefile, and target. One
# side effect of this is that each
# single-architecture build is responsible for
# inserting its build products into the final
# multi-architecture output files. To avoid
# races, these aggregating stages for
# "primary" build configs are done in serial.
#

export MakeInc_cmd=${VERSDIR}/makedefs/MakeInc.cmd

include $(MakeInc_cmd)


#
# Architecture Configuration options
#

# Default to current kernel architecture

ifneq ($(filter $(SUPPORTED_EMBEDDED_PLATFORMS),$(PLATFORM)),)
     override DEFAULT_ARCH_CONFIG := ARM
else ifneq ($(filter $(SUPPORTED_SIMULATOR_PLATFORMS),$(PLATFORM)),)
     override DEFAULT_ARCH_CONFIG := X86_64
else
     override DEFAULT_ARCH_CONFIG := X86_64
endif

# Accept either explicit ARCH_CONFIGS or XBS-style RC_ARCHS
ifndef ARCH_CONFIGS
ifdef RC_ARCHS
ARCH_CONFIGS	:= $(shell printf "%s" "$(RC_ARCHS)" | $(TR) a-z A-Z | $(TR) " " "\n" | sort -u | $(TR) "\n" " ")
else
ARCH_CONFIGS	:= DEFAULT
endif
endif

#
# Kernel Configuration options
#

ifeq ($(RC_ProjectName),xnu_debug)
override DEFAULT_KERNEL_CONFIG := DEBUG
else ifneq ($(filter $(SUPPORTED_EMBEDDED_PLATFORMS),$(PLATFORM)),)
override DEFAULT_KERNEL_CONFIG := DEVELOPMENT
else ifeq ($(PLATFORM),MacOSX)
override DEFAULT_KERNEL_CONFIG := DEVELOPMENT
else
override DEFAULT_KERNEL_CONFIG := RELEASE
endif

# If KERNEL_CONFIGS is specified it should override default
ifndef KERNEL_CONFIGS
KERNEL_CONFIGS := DEFAULT
endif

#
# Machine Configuration options
#

override DEFAULT_I386_MACHINE_CONFIG := NONE
override DEFAULT_X86_64_MACHINE_CONFIG := NONE
override DEFAULT_X86_64H_MACHINE_CONFIG := NONE


# This is typically never specified (TARGET_CONFIGS is used)
ifndef MACHINE_CONFIGS
MACHINE_CONFIGS	:= DEFAULT
endif

#
# Target configuration options.  NOTE - target configurations will
# override ARCH_CONFIGS and KERNEL_CONFIGS and MACHINE_CONFIGS.
#
# Target configs come in groups of three parameters.  The first is the
# kernel configuration, the second is the architecture configuration,
# and the third is the machine configuration.  You may pass in as
# many groups of configurations as you wish.  Each item passed in is
# seperated by whitespace.
#
# Example:
#	TARGET_CONFIGS="release ppc default debug i386 default release arm MX31ADS"
# Parameters may be in upper or lower case (they are converted to upper).
#
# "default" parameter is a special case.  It means use the default value for
# that parameter.  Here are the default values for each configuration:
#
# default kernel configuration = DEFAULT_KERNEL_CONFIG
# default architecture configuration = system architecture where you are running make.


ifeq ($(PLATFORM),MacOSX)

# Defaults for "make all_desktop"
ifeq ($(KERNEL_CONFIGS),DEFAULT)
KERNEL_CONFIGS_DESKTOP := RELEASE DEVELOPMENT
else
KERNEL_CONFIGS_DESKTOP := $(KERNEL_CONFIGS)
endif

endif

ifndef TARGET_CONFIGS
ifneq ($(PRODUCT_CONFIGS),)
# generate TARGET_CONFIGS using KERNEL_CONFIGS and PRODUCT_CONFIGS
TARGET_CONFIGS := $(foreach my_devicemap_config,$(foreach my_product_config,$(shell printf "%s" "$(PRODUCT_CONFIGS)" | $(TR) A-Z a-z),$(call function_lookup_product,$(my_product_config))),$(foreach my_kernel_config,$(KERNEL_CONFIGS),$(my_kernel_config) $(subst ;, ,$(my_devicemap_config))))
TARGET_CONFIGS_ALIASES := $(foreach my_devicemap_config,$(foreach my_product_config,$(shell printf "%s" "$(PRODUCT_CONFIGS)" | $(TR) A-Z a-z),$(call function_lookup_product_alias,$(my_product_config))),$(foreach my_kernel_config,$(KERNEL_CONFIGS),$(my_kernel_config) $(subst ;, ,$(my_devicemap_config))))
else ifneq ($(filter %_release_embedded,$(MAKECMDGOALS)),)
# generate TARGET_CONFIGS for RELEASE kernel configs and products in the device map
TARGET_CONFIGS := $(foreach my_devicemap_config,$(foreach my_arch_config,$(ARCH_CONFIGS_EMBEDDED),$(foreach my_product_config,$(DEVICEMAP_PRODUCTS_$(my_arch_config)),$(call function_lookup_product,$(my_product_config)))),$(foreach my_kernel_config,RELEASE,$(my_kernel_config) $(subst ;, ,$(my_devicemap_config))))
TARGET_CONFIGS_ALIASES := $(foreach my_devicemap_config,$(foreach my_arch_config,$(ARCH_CONFIGS_EMBEDDED),$(foreach my_product_config,$(DEVICEMAP_PRODUCTS_$(my_arch_config)),$(call function_lookup_product_alias,$(my_product_config)))),$(foreach my_kernel_config,RELEASE,$(my_kernel_config) $(subst ;, ,$(my_devicemap_config))))
else ifneq ($(filter %_development_embedded,$(MAKECMDGOALS)),)
# generate TARGET_CONFIGS for DEVELOPMENT kernel configs and products in the device map
TARGET_CONFIGS := $(foreach my_devicemap_config,$(foreach my_arch_config,$(ARCH_CONFIGS_EMBEDDED),$(foreach my_product_config,$(DEVICEMAP_PRODUCTS_$(my_arch_config)),$(call function_lookup_product,$(my_product_config)))),$(foreach my_kernel_config,DEVELOPMENT,$(my_kernel_config) $(subst ;, ,$(my_devicemap_config))))
TARGET_CONFIGS_ALIASES := $(foreach my_devicemap_config,$(foreach my_arch_config,$(ARCH_CONFIGS_EMBEDDED),$(foreach my_product_config,$(DEVICEMAP_PRODUCTS_$(my_arch_config)),$(call function_lookup_product_alias,$(my_product_config)))),$(foreach my_kernel_config,DEVELOPMENT,$(my_kernel_config) $(subst ;, ,$(my_devicemap_config))))
else ifneq ($(filter %_embedded,$(MAKECMDGOALS)),)
# generate TARGET_CONFIGS for all kernel configs and products in the device map
TARGET_CONFIGS := $(foreach my_devicemap_config,$(foreach my_arch_config,$(ARCH_CONFIGS_EMBEDDED),$(foreach my_product_config,$(DEVICEMAP_PRODUCTS_$(my_arch_config)),$(call function_lookup_product,$(my_product_config)))),$(foreach my_kernel_config,$(KERNEL_CONFIGS_EMBEDDED),$(my_kernel_config) $(subst ;, ,$(my_devicemap_config))))
TARGET_CONFIGS_ALIASES := $(foreach my_devicemap_config,$(foreach my_arch_config,$(ARCH_CONFIGS_EMBEDDED),$(foreach my_product_config,$(DEVICEMAP_PRODUCTS_$(my_arch_config)),$(call function_lookup_product_alias,$(my_product_config)))),$(foreach my_kernel_config,$(KERNEL_CONFIGS_EMBEDDED),$(my_kernel_config) $(subst ;, ,$(my_devicemap_config))))
else ifneq ($(filter %_desktop,$(MAKECMDGOALS)),)
# generate TARGET_CONFIGS for all kernel configs for B&I
TARGET_CONFIGS := $(foreach my_kern_config, $(KERNEL_CONFIGS_DESKTOP), $(foreach my_arch_config, $(ARCH_CONFIGS), $(foreach my_machine_config, $(MACHINE_CONFIGS), $(my_kern_config) $(my_arch_config) $(my_machine_config))))
TARGET_CONFIGS_ALIASES :=
else
# generate TARGET_CONFIGS using KERNEL_CONFIGS and ARCH_CONFIGS and MACHINE_CONFIGS (which defaults to "DEFAULT")
TARGET_CONFIGS := $(foreach my_kern_config, $(KERNEL_CONFIGS), $(foreach my_arch_config, $(ARCH_CONFIGS), $(foreach my_machine_config, $(MACHINE_CONFIGS), $(my_kern_config) $(my_arch_config) $(my_machine_config))))
TARGET_CONFIGS_ALIASES :=
endif
endif

ifeq ($(TARGET_CONFIGS),)
$(error No TARGET_CONFIGS specified)
endif

TARGET_CONFIGS_UC := $(strip $(shell printf "%s" "$(TARGET_CONFIGS)" | $(TR) a-z A-Z))
TARGET_CONFIGS_ALIASES_UC := $(strip $(shell printf "%s" "$(TARGET_CONFIGS_ALIASES)" | $(TR) a-z A-Z))

#
# Build Configurations
#
# TARGET_CONFIGS is unwieldy for use in Makefiles. Convert them to
# "build configurations" which are tuples joined by "^". For
# example, "RELEASE I386 DEFAULT DEVELOPMENT ARM DEFAULT" becomes
# "RELEASE^I386^NONE DEVELOPMENT^ARM^S5L8920X", which can be looped
# over trivially. PRIMARY_BUILD_CONFIGS is the first config
# for each architecture, used primarily for machine-dependent recursion.

BUILD_CONFIGS = $(call function_create_build_configs, $(TARGET_CONFIGS_UC))

PRIMARY_ARCHS = $(strip $(sort $(foreach build_config, $(BUILD_CONFIGS), $(call function_extract_arch_config_from_build_config, $(build_config)))))
PRIMARY_BUILD_CONFIGS = $(strip $(foreach arch, $(PRIMARY_ARCHS), $(firstword $(foreach build_config, $(BUILD_CONFIGS), $(if $(filter $(arch),$(call function_extract_arch_config_from_build_config, $(build_config))), $(build_config), )))))
NON_PRIMARY_BUILD_CONFIGS = $(strip $(filter-out $(PRIMARY_BUILD_CONFIGS), $(BUILD_CONFIGS)))
FIRST_BUILD_CONFIG = $(firstword $(BUILD_CONFIGS))

ifneq ($(TARGET_CONFIGS_ALIASES_UC),)
ALIAS_CONFIGS = $(call function_create_alias_configs, $(TARGET_CONFIGS_ALIASES_UC))
else
ALIAS_CONFIGS =
endif

# $(warning PRIMARY_ARCHS is $(PRIMARY_ARCHS))
# $(warning TARGET_CONFIGS is $(TARGET_CONFIGS))
# $(warning BUILD_CONFIGS is $(BUILD_CONFIGS))
# $(warning PRIMARY_BUILD_CONFIGS is $(PRIMARY_BUILD_CONFIGS))
# $(warning NON_PRIMARY_BUILD_CONFIGS is $(NON_PRIMARY_BUILD_CONFIGS))
# $(warning TARGET_CONFIGS_ALIASES is $(TARGET_CONFIGS_ALIASES))
# $(warning ALIAS_CONFIGS is $(ALIAS_CONFIGS))

MEMORY_SIZE := $(shell /usr/sbin/sysctl -n hw.memsize)

# Assume LTO scaling by default, unless it is being explicitly passed on the command-line
LARGE_BUILD_FOOTPRINT := $(if $(BUILD_LTO),$(BUILD_LTO),1)

ifeq ($(LARGE_BUILD_FOOTPRINT),1)
RAM_PER_KERNEL_BUILD := 4294967296
else
RAM_PER_KERNEL_BUILD := 268435456
endif

KERNEL_BUILDS_IN_PARALLEL := $(shell if [ $(MEMORY_SIZE) -le $$((1 * $(RAM_PER_KERNEL_BUILD))) ]; then echo 1; elif [ $(MEMORY_SIZE) -gt $$(($(SYSCTL_HW_PHYSICALCPU) * $(RAM_PER_KERNEL_BUILD))) ]; then echo $(SYSCTL_HW_PHYSICALCPU); else expr $(MEMORY_SIZE) / $(RAM_PER_KERNEL_BUILD); fi )
# $(warning Building $(KERNEL_BUILDS_IN_PARALLEL) kernels in parallel)

#
# TOP_LEVEL_EACH_BUILD_CONFIG_BOOTSTRAP_template
#
# $(1) is the name of the makefile target to invoke for the each build config
#      after setting up the parallel hierarchy in the TARGET directory
# $(2) is an optional suffix on the TARGET directory, which might even be
#      "/.."
# $(3) are any dependencies for the bootstrap target
# $(4) are any dependencies that are expanded per-build config to another bootstrap target
# $(5) is how many build configurations to build in parallel
# $(6) is which build configs to build in parallel
#
# Since building many configurations in parallel may overwhelm the system,
# we try to throttle behavior into more managable S "stripes" of N/S
# configurations by generating sequential dependencies between configs
# in each stripe. That ensures that only S kernel builds are occurring
# at once at any point in time

define TOP_LEVEL_EACH_BUILD_CONFIG_BOOTSTRAP_template

# Create a list of synthesized targets for each build config
$(1)_bootstrap_target_list = $$(addprefix $(1)_bootstrap_,$(6))

.PHONY: $$($(1)_bootstrap_target_list)

$(1)_generated_stripe_dependencies = $$(call _function_generate_stripe_groupings,$(1),$(5),$(call reverse,$(6)))
ifeq ($$(VERBOSE_GENERATED_MAKE_FRAGMENTS),YES)
$$(warning Generate makefile fragment: $$($(1)_generated_stripe_dependencies))
endif
$$(eval $$($(1)_generated_stripe_dependencies))

$$($(1)_bootstrap_target_list): $(1)_bootstrap_% : $(1)_stripe_dep_for_% $$(addsuffix _bootstrap_%,$(4)) $(3)
	$$(_v)$$(MKDIR) $${OBJROOT}/$$(call function_convert_build_config_to_objdir,$$(patsubst $(1)_bootstrap_%,%,$$@))$(2)
	$$(_v)$${MAKE}													        \
		-C $${OBJROOT}/$$(call function_convert_build_config_to_objdir,$$(patsubst $(1)_bootstrap_%,%,$$@))$(2)		\
		-f $${SRCROOT}/Makefile												\
		CURRENT_KERNEL_CONFIG=$$(call function_extract_kernel_config_from_build_config,$$(patsubst $(1)_bootstrap_%,%,$$@)) \
		CURRENT_ARCH_CONFIG=$$(call function_extract_arch_config_from_build_config,$$(patsubst $(1)_bootstrap_%,%,$$@))	  \
		CURRENT_MACHINE_CONFIG=$$(call function_extract_machine_config_from_build_config,$$(patsubst $(1)_bootstrap_%,%,$$@))	\
		CURRENT_BUILD_CONFIG=$$(patsubst $(1)_bootstrap_%,%,$$@)							\
		PRIMARY_BUILD_CONFIGS="$(PRIMARY_BUILD_CONFIGS)"							\
		SOURCE=$${SRCROOT}/												\
		RELATIVE_SOURCE_PATH=.											\
		TARGET=$${OBJROOT}/$$(call function_convert_build_config_to_objdir,$$(patsubst $(1)_bootstrap_%,%,$$@))$(2)/	\
		OBJPATH=$${OBJROOT}/$$(call function_convert_build_config_to_objdir,$$(patsubst $(1)_bootstrap_%,%,$$@))	\
		$(1)

.PHONY: $(1)_bootstrap

$(1)_bootstrap: $$($(1)_bootstrap_target_list)
endef

#
# TOP_LEVEL_STRIPE_DEPENDENCY_template
#
# $(1) is the Makefile target we are building for
# $(2) is the build config that must build first
# $(3) is the build config that must build after $(2)

define TOP_LEVEL_STRIPE_DEPENDENCY_template

.PHONY: $(1)_stripe_dep_for_$(3)

 $(1)_stripe_dep_for_$(3): $(if $(2),$(1)_bootstrap_$(2))

endef

# $(1) is the Makefile target we are building for
# $(2) is the stripe size
# $(3) is the list of the build configs in the current group
# $(4) is the list of remaining build configs
_function_generate_stripe_groupings_recursive = $(foreach stripe_index,$(call sequence,$(2)),$(if $(word $(stripe_index),$(4)),$(call TOP_LEVEL_STRIPE_DEPENDENCY_template,$(1),$(word $(stripe_index),$(3)),$(word $(stripe_index),$(4))))) $(if $(word $(call increment,$(2)),$(4)),$(call _function_generate_stripe_groupings_recursive,$(1),$(2),$(wordlist 1,$(2),$(4)),$(wordlist $(call increment,$(2)),$(words $(4)),$(4))))

# $(1) is the Makefile target we are building for
# $(2) is the stripe size
# $(3) is the list of the build configs
_function_generate_stripe_groupings = $(call _function_generate_stripe_groupings_recursive,$(1),$(2),,$(3))

#
# Setup pass for build system tools
#

generated_top_level_build_setup = $(call TOP_LEVEL_EACH_BUILD_CONFIG_BOOTSTRAP_template,build_setup,/..,,,1,$(FIRST_BUILD_CONFIG))
ifeq ($(VERBOSE_GENERATED_MAKE_FRAGMENTS),YES)
$(warning Generate makefile fragment: $(generated_top_level_build_setup))
endif
$(eval $(generated_top_level_build_setup))

.PHONY: setup

# invalidate current kernel in $(SYMROOT). Timestamp must be +1 from a previous kernel build
setup: build_setup_bootstrap
	$(_v)$(TOUCH) $(OBJROOT)/.mach_kernel.timestamp.new
	$(_v)while [ \! $(OBJROOT)/.mach_kernel.timestamp.new -nt $(OBJROOT)/.mach_kernel.timestamp ]; do \
		$(SLEEP) 1;					\
		$(TOUCH) $(OBJROOT)/.mach_kernel.timestamp.new;	\
	done
	$(_v)$(MV) $(OBJROOT)/.mach_kernel.timestamp.new $(OBJROOT)/.mach_kernel.timestamp
	$(_v)$(TOUCH) $(OBJROOT)/.symbolset.timestamp.new
	$(_v)while [ \! $(OBJROOT)/.symbolset.timestamp.new -nt $(OBJROOT)/.symbolset.timestamp ]; do \
		$(SLEEP) 1;					\
		$(TOUCH) $(OBJROOT)/.symbolset.timestamp.new;	\
	done
	$(_v)$(MV) $(OBJROOT)/.symbolset.timestamp.new $(OBJROOT)/.symbolset.timestamp

#
# Install kernel header files
#
.PHONY: exporthdrs exporthdrs_mi exporthdrs_md

exporthdrs: exporthdrs_mi exporthdrs_md

#
# Install machine independent kernel header files
#

generated_top_level_build_exporthdrs_mi = $(call TOP_LEVEL_EACH_BUILD_CONFIG_BOOTSTRAP_template,build_exporthdrs_mi,,setup,,1,$(FIRST_BUILD_CONFIG))
ifeq ($(VERBOSE_GENERATED_MAKE_FRAGMENTS),YES)
$(warning Generate makefile fragment: $(generated_top_level_build_exporthdrs_mi))
endif
$(eval $(generated_top_level_build_exporthdrs_mi))

exporthdrs_mi: build_exporthdrs_mi_bootstrap

#
# Install machine dependent kernel header files
#

generated_top_level_build_exporthdrs_md = $(call TOP_LEVEL_EACH_BUILD_CONFIG_BOOTSTRAP_template,build_exporthdrs_md,,setup,,$(KERNEL_BUILDS_IN_PARALLEL),$(PRIMARY_BUILD_CONFIGS))
ifeq ($(VERBOSE_GENERATED_MAKE_FRAGMENTS),YES)
$(warning Generate makefile fragment: $(generated_top_level_build_exporthdrs_md))
endif
$(eval $(generated_top_level_build_exporthdrs_md))

exporthdrs_md: build_exporthdrs_md_bootstrap

#
# Install kernel header files
#

.PHONY: installhdrs installhdrs_mi installhdrs_md

ifeq ($(RC_ProjectName),xnu_debug)
installhdrs:
	@:
else

installhdrs: installhdrs_mi installhdrs_md
endif

.PHONY: installhdrs_embedded installhdrs_release_embedded installhdrs_development_embedded installhdrs_desktop

installhdrs_embedded installhdrs_release_embedded installhdrs_desktop: installhdrs

installhdrs_development_embedded:

#
# Install machine independent header files
#

generated_top_level_build_installhdrs_mi = $(call TOP_LEVEL_EACH_BUILD_CONFIG_BOOTSTRAP_template,build_installhdrs_mi,,setup,build_exporthdrs_mi,1,$(FIRST_BUILD_CONFIG))
ifeq ($(VERBOSE_GENERATED_MAKE_FRAGMENTS),YES)
$(warning Generate makefile fragment: $(generated_top_level_build_installhdrs_mi))
endif
$(eval $(generated_top_level_build_installhdrs_mi))

installhdrs_mi: build_installhdrs_mi_bootstrap

#
# Install machine dependent kernel header files
#

generated_top_level_build_installhdrs_md = $(call TOP_LEVEL_EACH_BUILD_CONFIG_BOOTSTRAP_template,build_installhdrs_md,,setup,build_exporthdrs_md,$(KERNEL_BUILDS_IN_PARALLEL),$(PRIMARY_BUILD_CONFIGS))
ifeq ($(VERBOSE_GENERATED_MAKE_FRAGMENTS),YES)
$(warning Generate makefile fragment: $(generated_top_level_build_installhdrs_md))
endif
$(eval $(generated_top_level_build_installhdrs_md))

installhdrs_md: build_installhdrs_md_bootstrap

#
#  Install text files (man pages, dtrace scripts, etc.)
#

generated_top_level_textfiles_install = $(call TOP_LEVEL_EACH_BUILD_CONFIG_BOOTSTRAP_template,textfiles_install,,setup,,1,$(FIRST_BUILD_CONFIG))
ifeq ($(VERBOSE_GENERATED_MAKE_FRAGMENTS),YES)
$(warning Generate makefile fragment: $(generated_top_level_textfiles_install))
endif
$(eval $(generated_top_level_textfiles_install))

.PHONY: install_textfiles

install_textfiles: textfiles_install_bootstrap

#
# Build all architectures for all Configuration/Architecture options
#

generated_top_level_build_all = $(call TOP_LEVEL_EACH_BUILD_CONFIG_BOOTSTRAP_template,build_all,,setup exporthdrs,,$(KERNEL_BUILDS_IN_PARALLEL),$(BUILD_CONFIGS))
ifeq ($(VERBOSE_GENERATED_MAKE_FRAGMENTS),YES)
$(warning Generate makefile fragment: $(generated_top_level_build_all))
endif
$(eval $(generated_top_level_build_all))

.PHONY: build

build: build_all_bootstrap

#
# Post-process build results
#

generated_top_level_config_all = $(call TOP_LEVEL_EACH_BUILD_CONFIG_BOOTSTRAP_template,config_all,,setup,build_all,$(KERNEL_BUILDS_IN_PARALLEL),$(BUILD_CONFIGS))
ifeq ($(VERBOSE_GENERATED_MAKE_FRAGMENTS),YES)
$(warning Generate makefile fragment: $(generated_top_level_config_all))
endif
$(eval $(generated_top_level_config_all))

.PHONY: all config

all config: config_all_bootstrap

.PHONY: all_embedded all_release_embedded all_development_embedded all_desktop

all_embedded all_release_embedded all_development_embedded all_desktop: all

#
# Install kernel files
#

generated_top_level_build_install_primary = $(call TOP_LEVEL_EACH_BUILD_CONFIG_BOOTSTRAP_template,build_install_primary,,setup,config_all,1,$(PRIMARY_BUILD_CONFIGS))
ifeq ($(VERBOSE_GENERATED_MAKE_FRAGMENTS),YES)
$(warning Generate makefile fragment: $(generated_top_level_build_install_primary))
endif
$(eval $(generated_top_level_build_install_primary))

.PHONY: install_primary

install_primary: build_install_primary_bootstrap

generated_top_level_build_install_non_primary = $(call TOP_LEVEL_EACH_BUILD_CONFIG_BOOTSTRAP_template,build_install_non_primary,,setup,config_all,$(KERNEL_BUILDS_IN_PARALLEL),$(NON_PRIMARY_BUILD_CONFIGS))
ifeq ($(VERBOSE_GENERATED_MAKE_FRAGMENTS),YES)
$(warning Generate makefile fragment: $(generated_top_level_build_install_non_primary))
endif
$(eval $(generated_top_level_build_install_non_primary))

.PHONY: install_non_primary

install_non_primary: build_install_non_primary_bootstrap

generated_top_level_config_install = $(call TOP_LEVEL_EACH_BUILD_CONFIG_BOOTSTRAP_template,config_install,,setup,config_all,1,$(PRIMARY_BUILD_CONFIGS))
ifeq ($(VERBOSE_GENERATED_MAKE_FRAGMENTS),YES)
$(warning Generate makefile fragment: $(generated_top_level_config_install))
endif
$(eval $(generated_top_level_config_install))

.PHONY: install_config final_touch_config_timestamps

install_config: config_install_bootstrap final_touch_config_timestamps

# Tell the next build the latest timestamp of any potential file in DSTROOT/SYMROOT
final_touch_config_timestamps: config_install_bootstrap
	$(_v)$(TOUCH) $(OBJROOT)/.symbolset.timestamp

#
# Aggregate install targets, which install everything appropriate for the current build alias/make target
#

.PHONY: install

ifeq ($(RC_ProjectName),xnu_debug)
install: install_kernels
else ifeq ($(RC_ProjectName),xnu_headers_Sim)
install: installhdrs
else

install: installhdrs install_textfiles install_config install_kernels install_aliases
endif

.PHONY: install_embedded install_release_embedded install_development_embedded install_desktop

# By default, all kernel files, headers, text files, and pseudo-kexts are installed
install_embedded install_release_embedded install_desktop: install

# These special configs only install the kernel files
install_development_embedded: install_kernels install_aliases

.PHONY: install_kernels final_touch_kernel_timestamps install_aliases

install_kernels: build_install_primary_bootstrap build_install_non_primary_bootstrap final_touch_kernel_timestamps

# Tell the next build the latest timestamp of any potential file in DSTROOT/SYMROOT
final_touch_kernel_timestamps: build_install_primary_bootstrap build_install_non_primary_bootstrap
	$(_v)$(TOUCH) $(OBJROOT)/.mach_kernel.timestamp

# Copy kernels that are aliases of another configuration
generated_top_level_install_alias = $(call TOP_LEVEL_EACH_BUILD_CONFIG_BOOTSTRAP_template,install_alias,,install_kernels,,$(KERNEL_BUILDS_IN_PARALLEL),$(ALIAS_CONFIGS))
ifeq ($(VERBOSE_GENERATED_MAKE_FRAGMENTS),YES)
$(warning Generate makefile fragment: $(generated_top_level_install_alias))
endif
$(eval $(generated_top_level_install_alias))

install_aliases: install_alias_bootstrap

#
# Install source tree
#
.PHONY: installsrc

installsrc:
	@echo INSTALLSRC $(SRCROOT)
	$(_v)$(MKDIR) $(SRCROOT)
	$(_v)$(FIND) -x . \! \( \( -name BUILD -o -name .svn -o -name .git -o -name cscope.\* -o -name \*~ \) -prune \) -print0 | $(PAX) -rw -p a -d0 $(SRCROOT)
	$(_v)$(CHMOD) -R go+rX $(SRCROOT)


#
# Clean up source tree
#
.PHONY: clean

clean:
	@:
	@rm -f cscope.* 2> /dev/null
	@rm -f $(OBJROOT)/cscope.genhdrs/* 2> /dev/null  || true
	@rm -f TAGS 2> /dev/null

#
# Build source file list for cscope database and tags
#
.PHONY: cscope.files

cscope.files:
	@echo "Building file list for cscope and tags"
	@find . -name '*.h' -type f | grep -v ^..BUILD > _cscope.files 2> /dev/null
	@find . -name '*.defs' -type f | grep -v ^..BUILD >> _cscope.files 2> /dev/null
	@find . -name '*.c' -type f | grep -v ^..BUILD >> _cscope.files 2> /dev/null
	@find . -name '*.cpp' -type f | grep -v ^..BUILD >> _cscope.files 2> /dev/null
	@find . -name '*.s' -type f | grep -v ^..BUILD >> _cscope.files 2> /dev/null
	@find . -name '*.h.template' -type f | grep -v ^..BUILD >> _cscope.files 2> /dev/null
	@cat $(OBJROOT)/cscope.genhdrs/* >> _cscope.files 2> /dev/null || true
	@echo -k -q -c > cscope.files 2> /dev/null
	@sort -u < _cscope.files >> cscope.files 2> /dev/null
	@rm -f _cscope.files _cscope.files2 2> /dev/null

#
# Build cscope database
#
cscope: cscope.files
	@echo "Building cscope database"
	@cscope -bvU 2> /dev/null

#
# Build tags
#
tags: cscope.files
	@echo "Building ctags"
	@-sed 1d cscope.files | xargs ctags -dtw 2> /dev/null || \
		echo "Phantom files detected!" 2>&1 > /dev/null
	@-[ -f TAGS ] || ${MAKE} -f $(firstword $(MAKEFILE_LIST)) TAGS

TAGS: cscope.files
	@echo "Building etags"
	@-cat cscope.files | etags -l auto -S - 2> /dev/null
	@rm -f cscope.files 2> /dev/null

#
# Re-indent source code using xnu clang-format style
#
.PHONY: reindent

reindent:
	$(_v)$(SRCROOT)/tools/reindent.sh

.PHONY: help

help:
	@cat README.md

.PHONY: print_exports

print_exports:
	$(_v)printenv | sort

generated_top_level_print_exports = $(call TOP_LEVEL_EACH_BUILD_CONFIG_BOOTSTRAP_template,print_exports,,,,1,$(FIRST_BUILD_CONFIG))
ifeq ($(VERBOSE_GENERATED_MAKE_FRAGMENTS),YES)
$(warning Generate makefile fragment: $(generated_top_level_print_exports))
endif
$(eval $(generated_top_level_print_exports))

.PHONY: print_exports_first_build_config

print_exports_first_build_config: print_exports_bootstrap