src/Makefile.inc1

#
# $FreeBSD$
#
# Make command line options:
#	-DNO_CLEANDIR run ${MAKE} clean, instead of ${MAKE} cleandir
#	-DNO_CLEAN do not clean at all
#	-DDB_FROM_SRC use the user/group databases in src/etc instead of
#	    the system database when installing.
#	-DNO_SHARE do not go into share subdir
#	-DKERNFAST define NO_KERNEL{CONFIG,CLEAN,OBJ}
#	-DNO_KERNELCONFIG do not run config in ${MAKE} buildkernel
#	-DNO_KERNELCLEAN do not run ${MAKE} clean in ${MAKE} buildkernel
#	-DNO_KERNELOBJ do not run ${MAKE} obj in ${MAKE} buildkernel
#	-DNO_ROOT install without using root privilege
#	-DWITHOUT_CTF do not run the DTrace CTF conversion tools on built objects
#	LOCAL_DIRS="list of dirs" to add additional dirs to the SUBDIR list
#	LOCAL_ITOOLS="list of tools" to add additional tools to the ITOOLS list
#	LOCAL_LIB_DIRS="list of dirs" to add additional dirs to libraries target
#	LOCAL_MTREE="list of mtree files" to process to allow local directories
#	    to be created before files are installed
#	LOCAL_LEGACY_DIRS="list of dirs" to add additional dirs to the legacy
#	    target
#	LOCAL_BSTOOL_DIRS="list of dirs" to add additional dirs to the
#	    bootstrap-tools target
#	LOCAL_TOOL_DIRS="list of dirs" to add additional dirs to the build-tools
#	    target
#	LOCAL_XTOOL_DIRS="list of dirs" to add additional dirs to the
#	    cross-tools target
#	METALOG="path to metadata log" to write permission and ownership
#	    when NO_ROOT is set.  (default: ${DESTDIR}/${DISTDIR}/METALOG,
#           check /etc/make.conf for DISTDIR)
#	TARGET="machine" to crossbuild world for a different machine type
#	TARGET_ARCH= may be required when a TARGET supports multiple endians
#	BUILDENV_SHELL= shell to launch for the buildenv target (def:${SHELL})
#	WORLD_FLAGS= additional flags to pass to make(1) during buildworld
#	KERNEL_FLAGS= additional flags to pass to make(1) during buildkernel
#	SUBDIR_OVERRIDE="list of dirs" to build rather than everything.
#	    All libraries and includes, and some build tools will still build.

#
# The intended user-driven targets are:
# buildworld  - rebuild *everything*, including glue to help do upgrades
# installworld- install everything built by "buildworld"
# checkworld  - run test suite on installed world
# doxygen     - build API documentation of the kernel
#
# Standard targets (not defined here) are documented in the makefiles in
# /usr/share/mk.  These include:
#		obj depend all install clean cleandepend cleanobj

.if !defined(TARGET) || !defined(TARGET_ARCH)
.error Both TARGET and TARGET_ARCH must be defined.
.endif

.if make(showconfig) || make(test-system-*)
_MKSHOWCONFIG=	t
.endif

SRCDIR?=	${.CURDIR}
LOCALBASE?=	/usr/local
TIME_ENV ?= time env

.include "share/mk/src.tools.mk"

# Cross toolchain changes must be in effect before bsd.compiler.mk
# so that gets the right CC, and pass CROSS_TOOLCHAIN to submakes.
.if defined(CROSS_TOOLCHAIN)
.if exists(${LOCALBASE}/share/toolchains/${CROSS_TOOLCHAIN}.mk)
.include "${LOCALBASE}/share/toolchains/${CROSS_TOOLCHAIN}.mk"
.elif exists(${CROSS_TOOLCHAIN})
.include "${CROSS_TOOLCHAIN}"
.else
.error CROSS_TOOLCHAIN ${CROSS_TOOLCHAIN} not found
.endif
CROSSENV+=CROSS_TOOLCHAIN="${CROSS_TOOLCHAIN}"
.endif
.if defined(CROSS_TOOLCHAIN_PREFIX)
CROSS_COMPILER_PREFIX?=${CROSS_TOOLCHAIN_PREFIX}
.endif

XCOMPILERS=	CC CXX CPP
.for COMPILER in ${XCOMPILERS}
.if defined(CROSS_COMPILER_PREFIX)
X${COMPILER}?=	${CROSS_COMPILER_PREFIX}${${COMPILER}}
.else
X${COMPILER}?=	${${COMPILER}}
.endif
.endfor
# If a full path to an external cross compiler is given, don't build
# a cross compiler.
.if ${XCC:N${CCACHE_BIN}:M/*}
MK_CLANG_BOOTSTRAP=	no
# Make sure sub-makes see the option as disabled so the hack in bsd.sys.mk to
# work around incompatible headers in Clang's resource directory is enabled.
.MAKEOVERRIDES+=	MK_CLANG_BOOTSTRAP
.endif

# Pull in compiler metadata from buildworld/toolchain if possible to avoid
# running CC from bsd.compiler.mk.
.if make(installworld) || make(install) || make(distributeworld) || \
    make(stageworld)
.-include "${OBJTOP}/toolchain-metadata.mk"
.if !defined(_LOADED_TOOLCHAIN_METADATA)
.error A build is required first.  You may have the wrong MAKEOBJDIRPREFIX set.
.endif
.endif

# Pull in COMPILER_TYPE and COMPILER_FREEBSD_VERSION early. Pull it from the
# tree to be friendlier to foreign OS builds. It's safe to do so unconditionally
# here since we will always have the right make, unlike in src/Makefile
# Don't include bsd.linker.mk yet until XBINUTILS is handled (after src.opts.mk)
_NO_INCLUDE_LINKERMK=	t
# We also want the X_COMPILER* variables if we are using an external toolchain.
_WANT_TOOLCHAIN_CROSS_VARS=	t
.include "share/mk/bsd.compiler.mk"
.undef _NO_INCLUDE_LINKERMK
.undef _WANT_TOOLCHAIN_CROSS_VARS
# src.opts.mk depends on COMPILER_FEATURES
.include "share/mk/src.opts.mk"

.if ${TARGET} == ${MACHINE}
TARGET_CPUTYPE?=${CPUTYPE}
.else
TARGET_CPUTYPE?=
.endif
.if !empty(TARGET_CPUTYPE)
_TARGET_CPUTYPE=${TARGET_CPUTYPE}
.else
_TARGET_CPUTYPE=dummy
.endif
.if ${TARGET} == "arm"
.if ${TARGET_ARCH:Marmv[67]*} != "" && ${TARGET_CPUTYPE:M*soft*} == ""
TARGET_TRIPLE_ABI=	gnueabihf
.else
TARGET_TRIPLE_ABI=	gnueabi
.endif
.endif
MACHINE_TRIPLE_ABI?=	unknown
MACHINE_TRIPLE?=${MACHINE_ARCH:S/amd64/x86_64/:C/sf$//}-${MACHINE_TRIPLE_ABI}-freebsd${OS_REVISION}
TARGET_TRIPLE_ABI?=	unknown
TARGET_TRIPLE?=	${TARGET_ARCH:S/amd64/x86_64/:C/sf$//}-${TARGET_TRIPLE_ABI}-freebsd${OS_REVISION}
KNOWN_ARCHES?=	aarch64/arm64 \
		amd64 \
		armv6/arm \
		armv7/arm \
		i386 \
		powerpc \
		powerpc64/powerpc \
		powerpc64le/powerpc \
		powerpcspe/powerpc \
		riscv64/riscv \
		riscv64sf/riscv

.if ${TARGET} == ${TARGET_ARCH}
_t=		${TARGET}
.else
_t=		${TARGET_ARCH}/${TARGET}
.endif
.for _t in ${_t}
.if empty(KNOWN_ARCHES:M${_t})
.error Unknown target ${TARGET_ARCH}:${TARGET}.
.endif
.endfor

.if ${.MAKE.OS} != "FreeBSD"
CROSSBUILD_HOST=${.MAKE.OS}
.if ${.MAKE.OS} != "Linux" && ${.MAKE.OS} != "Darwin"
.warning Unsupported crossbuild system: ${.MAKE.OS}. Build will probably fail!
.endif
# We need to force NO_ROOT/DB_FROM_SRC builds when building on other operating
# systems since the BSD.foo.dist specs contain users and groups that do not
# exist by default on a Linux/MacOS system.
NO_ROOT:=	1
DB_FROM_SRC:=	1
.export NO_ROOT
.endif

# If all targets are disabled for system llvm then don't expect it to work
# for cross-builds.
.if !defined(TOOLS_PREFIX) && ${MK_LLVM_TARGET_ALL} == "no" && \
    ${MACHINE} != ${TARGET} && ${MACHINE_ARCH} != ${TARGET_ARCH} && \
    !make(showconfig)
MK_SYSTEM_COMPILER=	no
MK_SYSTEM_LINKER=	no
.endif

# Handle external binutils.
.if defined(CROSS_TOOLCHAIN_PREFIX)
CROSS_BINUTILS_PREFIX?=${CROSS_TOOLCHAIN_PREFIX}
.endif
XBINUTILS=	AS AR ELFCTL LD NM OBJCOPY RANLIB SIZE STRINGS STRIPBIN
.for BINUTIL in ${XBINUTILS}
.if defined(CROSS_BINUTILS_PREFIX) && \
    exists(${CROSS_BINUTILS_PREFIX}/${${BINUTIL}})
X${BINUTIL}?=	${CROSS_BINUTILS_PREFIX:C,/*$,,}/${${BINUTIL}}
.else
X${BINUTIL}?=	${${BINUTIL}}
.endif
.endfor

# If a full path to an external linker is given, don't build lld.
.if ${XLD:M/*}
MK_LLD_BOOTSTRAP=	no
.endif

# We also want the X_LINKER* variables if we are using an external toolchain.
_WANT_TOOLCHAIN_CROSS_VARS=	t
.include "share/mk/bsd.linker.mk"
.undef _WANT_TOOLCHAIN_CROSS_VARS

# Begin WITH_SYSTEM_COMPILER / WITH_SYSTEM_LD

# WITH_SYSTEM_COMPILER - Pull in needed values and make a decision.

# Check if there is a local compiler that can satisfy as an external compiler.
# Which compiler is expected to be used?
.if ${MK_CLANG_BOOTSTRAP} == "yes"
WANT_COMPILER_TYPE=	clang
.else
WANT_COMPILER_TYPE=
.endif

.if !defined(WANT_COMPILER_FREEBSD_VERSION) && !make(showconfig) && \
    !make(test-system-linker)
.if ${WANT_COMPILER_TYPE} == "clang"
WANT_COMPILER_FREEBSD_VERSION_FILE= lib/clang/freebsd_cc_version.h
WANT_COMPILER_FREEBSD_VERSION!= \
	awk '$$2 == "FREEBSD_CC_VERSION" {printf("%d\n", $$3)}' \
	${SRCDIR}/${WANT_COMPILER_FREEBSD_VERSION_FILE} || echo unknown
WANT_COMPILER_VERSION_FILE= lib/clang/include/clang/Basic/Version.inc
WANT_COMPILER_VERSION!= \
	awk '$$2 == "CLANG_VERSION" {split($$3, a, "."); print a[1] * 10000 + a[2] * 100 + a[3]}' \
	${SRCDIR}/${WANT_COMPILER_VERSION_FILE} || echo unknown
.endif
.export WANT_COMPILER_FREEBSD_VERSION WANT_COMPILER_VERSION
.endif	# !defined(WANT_COMPILER_FREEBSD_VERSION)

# It needs to be the same revision as we would build for the bootstrap.
# If the expected vs CC is different then we can't skip.
# GCC cannot be used for cross-arch yet.  For clang we pass -target later if
# TARGET_ARCH!=MACHINE_ARCH.
.if ${MK_SYSTEM_COMPILER} == "yes" && \
    defined(WANT_COMPILER_FREEBSD_VERSION) && \
    ${MK_CLANG_BOOTSTRAP} == "yes" && \
    !make(xdev*) && \
    ${X_COMPILER_TYPE} == ${WANT_COMPILER_TYPE} && \
    (${X_COMPILER_TYPE} == "clang" || ${TARGET_ARCH} == ${MACHINE_ARCH}) && \
    ${X_COMPILER_VERSION} == ${WANT_COMPILER_VERSION} && \
    ${X_COMPILER_FREEBSD_VERSION} == ${WANT_COMPILER_FREEBSD_VERSION}
# Everything matches, disable the bootstrap compiler.
MK_CLANG_BOOTSTRAP=	no
USING_SYSTEM_COMPILER=	yes
.endif	# ${WANT_COMPILER_TYPE} == ${COMPILER_TYPE}

# WITH_SYSTEM_LD - Pull in needed values and make a decision.

# Check if there is a local linker that can satisfy as an external linker.
# Which linker is expected to be used?
.if ${MK_LLD_BOOTSTRAP} == "yes"
WANT_LINKER_TYPE=		lld
.else
WANT_LINKER_TYPE=
.endif

.if !defined(WANT_LINKER_FREEBSD_VERSION) && !make(showconfig) && \
    !make(test-system-compiler)
.if ${WANT_LINKER_TYPE} == "lld"
WANT_LINKER_FREEBSD_VERSION_FILE= lib/clang/include/lld/Common/Version.inc
WANT_LINKER_FREEBSD_VERSION!= \
	awk '$$2 == "LLD_FREEBSD_VERSION" {print $$3}' \
	${SRCDIR}/${WANT_LINKER_FREEBSD_VERSION_FILE} || echo unknown
WANT_LINKER_VERSION_FILE= lib/clang/include/lld/Common/Version.inc
WANT_LINKER_VERSION!= \
	awk '$$2 == "LLD_VERSION_STRING" {gsub("\"", "", $$3); split($$3, a, "."); print a[1] * 10000 + a[2] * 100 + a[3]}' \
	${SRCDIR}/${WANT_LINKER_VERSION_FILE} || echo unknown
.else
WANT_LINKER_FREEBSD_VERSION_FILE=
WANT_LINKER_FREEBSD_VERSION=
.endif
.export WANT_LINKER_FREEBSD_VERSION WANT_LINKER_VERSION
.endif	# !defined(WANT_LINKER_FREEBSD_VERSION)

.if ${MK_SYSTEM_LINKER} == "yes" && \
    defined(WANT_LINKER_FREEBSD_VERSION) && \
    (${MK_LLD_BOOTSTRAP} == "yes") && \
    !make(xdev*) && \
    ${X_LINKER_TYPE} == ${WANT_LINKER_TYPE} && \
    ${X_LINKER_VERSION} == ${WANT_LINKER_VERSION} && \
    ${X_LINKER_FREEBSD_VERSION} == ${WANT_LINKER_FREEBSD_VERSION}
# Everything matches, disable the bootstrap linker.
MK_LLD_BOOTSTRAP=	no
USING_SYSTEM_LINKER=	yes
.endif	# ${WANT_LINKER_TYPE} == ${LINKER_TYPE}

# WITH_SYSTEM_COMPILER / WITH_SYSTEM_LINKER - Handle defaults and debug.
USING_SYSTEM_COMPILER?=	no
USING_SYSTEM_LINKER?=	no

TEST_SYSTEM_COMPILER_VARS= \
	USING_SYSTEM_COMPILER MK_SYSTEM_COMPILER \
	MK_CROSS_COMPILER MK_CLANG_BOOTSTRAP \
	WANT_COMPILER_TYPE WANT_COMPILER_VERSION WANT_COMPILER_VERSION_FILE \
	WANT_COMPILER_FREEBSD_VERSION WANT_COMPILER_FREEBSD_VERSION_FILE \
	CC COMPILER_TYPE COMPILER_FEATURES COMPILER_VERSION \
	COMPILER_FREEBSD_VERSION \
	XCC X_COMPILER_TYPE X_COMPILER_FEATURES X_COMPILER_VERSION \
	X_COMPILER_FREEBSD_VERSION
TEST_SYSTEM_LINKER_VARS= \
	USING_SYSTEM_LINKER MK_SYSTEM_LINKER \
	MK_LLD_BOOTSTRAP \
	WANT_LINKER_TYPE WANT_LINKER_VERSION WANT_LINKER_VERSION_FILE \
	WANT_LINKER_FREEBSD_VERSION WANT_LINKER_FREEBSD_VERSION_FILE \
	LD LINKER_TYPE LINKER_FEATURES LINKER_VERSION \
	LINKER_FREEBSD_VERSION \
	XLD X_LINKER_TYPE X_LINKER_FEATURES X_LINKER_VERSION \
	X_LINKER_FREEBSD_VERSION

.for _t in compiler linker
test-system-${_t}: .PHONY
.for v in ${TEST_SYSTEM_${_t:tu}_VARS}
	${_+_}@printf "%-35s= %s\n" "${v}" "${${v}}"
.endfor
.endfor
.if (make(buildworld) || make(buildkernel) || make(kernel-toolchain) || \
    make(toolchain) || make(_cross-tools))
.if ${USING_SYSTEM_COMPILER} == "yes"
.info SYSTEM_COMPILER: Determined that CC=${CC} matches the source tree.  Not bootstrapping a cross-compiler.
.elif ${MK_CLANG_BOOTSTRAP} == "yes"
.info SYSTEM_COMPILER: libclang will be built for bootstrapping a cross-compiler.
.endif
.if ${USING_SYSTEM_LINKER} == "yes"
.info SYSTEM_LINKER: Determined that LD=${LD} matches the source tree.  Not bootstrapping a cross-linker.
.elif ${MK_LLD_BOOTSTRAP} == "yes"
.info SYSTEM_LINKER: libclang will be built for bootstrapping a cross-linker.
.endif
.endif

# End WITH_SYSTEM_COMPILER / WITH_SYSTEM_LD

# Store some compiler metadata for use in installworld where we don't
# want to invoke CC at all.
_TOOLCHAIN_METADATA_VARS=	COMPILER_VERSION \
				COMPILER_TYPE \
				COMPILER_FEATURES \
				COMPILER_FREEBSD_VERSION \
				COMPILER_RESOURCE_DIR \
				LINKER_VERSION \
				LINKER_FEATURES \
				LINKER_TYPE \
				LINKER_FREEBSD_VERSION
toolchain-metadata.mk: .PHONY .META
	@: > ${.TARGET}
	@echo ".info Using cached toolchain metadata from build at $$(hostname) on $$(date)" \
	    > ${.TARGET}
	@echo "_LOADED_TOOLCHAIN_METADATA=t" >> ${.TARGET}
.for v in ${_TOOLCHAIN_METADATA_VARS}
	@echo "${v}=${${v}}" >> ${.TARGET}
	@echo "X_${v}=${X_${v}}" >> ${.TARGET}
.endfor
	@echo ".export ${_TOOLCHAIN_METADATA_VARS}" >> ${.TARGET}
	@echo ".export ${_TOOLCHAIN_METADATA_VARS:C,^,X_,}" >> ${.TARGET}


# We must do lib/ and libexec/ before bin/ in case of a mid-install error to
# keep the users system reasonably usable.  For static->dynamic root upgrades,
# we don't want to install a dynamic binary without rtld and the needed
# libraries.  More commonly, for dynamic root, we don't want to install a
# binary that requires a newer library version that hasn't been installed yet.
# This ordering is not a guarantee though.  The only guarantee of a working
# system here would require fine-grained ordering of all components based
# on their dependencies.
.if !empty(SUBDIR_OVERRIDE)
SUBDIR=	${SUBDIR_OVERRIDE}
.else
SUBDIR=	lib libexec
# Add LOCAL_LIB_DIRS, but only if they will not be picked up as a SUBDIR
# of a LOCAL_DIRS directory.  This allows LOCAL_DIRS=foo and
# LOCAL_LIB_DIRS=foo/lib to behave as expected.
.for _DIR in ${LOCAL_DIRS:M*/} ${LOCAL_DIRS:N*/:S|$|/|}
_REDUNDANT_LIB_DIRS+=    ${LOCAL_LIB_DIRS:M${_DIR}*}
.endfor
.for _DIR in ${LOCAL_LIB_DIRS}
.if ${_DIR} == ".WAIT" || (empty(_REDUNDANT_LIB_DIRS:M${_DIR}) && exists(${.CURDIR}/${_DIR}/Makefile))
SUBDIR+=	${_DIR}
.endif
.endfor
.if !defined(NO_ROOT) && (make(installworld) || make(install))
# Ensure libraries are installed before progressing.
SUBDIR+=.WAIT
.endif
SUBDIR+=bin
.if ${MK_CDDL} != "no"
SUBDIR+=cddl
.endif
SUBDIR+=gnu include
.if ${MK_KERBEROS} != "no"
SUBDIR+=kerberos5
.endif
.if ${MK_RESCUE} != "no"
SUBDIR+=rescue
.endif
SUBDIR+=sbin
.if ${MK_CRYPT} != "no"
SUBDIR+=secure
.endif
.if !defined(NO_SHARE)
SUBDIR+=share
.endif
.if ${MK_BOOT} != "no"
SUBDIR+=stand
.endif
SUBDIR+=sys usr.bin usr.sbin
.if ${MK_TESTS} != "no"
SUBDIR+=	tests
.endif

# Local directories are built in parallel with the base system directories.
# Users may insert a .WAIT directive at the beginning or elsewhere within
# the LOCAL_DIRS and LOCAL_LIB_DIRS lists as needed.
.for _DIR in ${LOCAL_DIRS}
.if ${_DIR} == ".WAIT" || exists(${.CURDIR}/${_DIR}/Makefile)
SUBDIR+=	${_DIR}
.endif
.endfor

# We must do etc/ last as it hooks into building the man whatis file
# by calling 'makedb' in share/man.  This is only relevant for
# install/distribute so they build the whatis file after every manpage is
# installed.
.if make(installworld) || make(install)
SUBDIR+=.WAIT
.endif
SUBDIR+=etc

.endif	# !empty(SUBDIR_OVERRIDE)

.if defined(NOCLEAN)
.warning The src.conf WITHOUT_CLEAN option can now be used instead of NOCLEAN.
MK_CLEAN:=	no
.endif
.if defined(NO_CLEAN)
.info The src.conf WITHOUT_CLEAN option can now be used instead of NO_CLEAN.
MK_CLEAN:=	no
.endif
.if defined(NO_CLEANDIR)
CLEANDIR=	clean cleandepend
.else
CLEANDIR=	cleandir
.endif

.if defined(WORLDFAST)
MK_CLEAN:=	no
NO_OBJWALK=	t
.endif

.if ${MK_META_MODE} == "yes"
# If filemon is used then we can rely on the build being incremental-safe.
# The .meta files will also track the build command and rebuild should
# it change.
.if empty(.MAKE.MODE:Mnofilemon)
MK_CLEAN:=	no
.endif
.endif
.if defined(NO_OBJWALK) || ${MK_AUTO_OBJ} == "yes"
NO_OBJWALK=	t
NO_KERNELOBJ=	t
.endif
.if !defined(NO_OBJWALK)
_obj=		obj
.endif

LOCAL_TOOL_DIRS?=
PACKAGEDIR?=	${DESTDIR}/${DISTDIR}

.if empty(SHELL:M*csh*)
BUILDENV_SHELL?=${SHELL}
.else
BUILDENV_SHELL?=/bin/sh
.endif

.if !defined(_MKSHOWCONFIG)
.if !defined(VCS_REVISION) || empty(VCS_REVISION)
.if !defined(SVNVERSION_CMD) || empty(SVNVERSION_CMD)
. for _D in ${PATH:S,:, ,g}
.  if exists(${_D}/svnversion)
SVNVERSION_CMD?=${_D}/svnversion
.  endif
.  if exists(${_D}/svnliteversion)
SVNVERSION_CMD?=${_D}/svnliteversion
.  endif
. endfor
.endif
.if defined(SVNVERSION_CMD) && !empty(SVNVERSION_CMD)
_VCS_REVISION?=	$$(eval ${SVNVERSION_CMD} ${SRCDIR})
. if !empty(_VCS_REVISION)
VCS_REVISION=	$$(echo r${_VCS_REVISION})
.export VCS_REVISION
. endif
.endif
.endif

.if !defined(GIT_CMD) || empty(GIT_CMD)
. for _P in /usr/bin /usr/local/bin
.  if exists(${_P}/git)
GIT_CMD=   ${_P}/git
.  endif
. endfor
.export GIT_CMD
.endif

.if !defined(OSRELDATE)
.if exists(/usr/include/osreldate.h)
OSRELDATE!=	awk '/^\#define[[:space:]]*__FreeBSD_version/ { print $$3 }' \
		/usr/include/osreldate.h
.else
OSRELDATE=	0
.endif
.export OSRELDATE
.endif

# Set VERSION for CTFMERGE to use via the default CTFFLAGS=-L VERSION.
.for _V in BRANCH REVISION TYPE
.if !defined(_${_V})
_${_V}!=	eval $$(awk '/^${_V}=/{print}' ${SRCTOP}/sys/conf/newvers.sh); echo $$${_V}
.export _${_V}
.endif
.endfor
.if !defined(SRCRELDATE)
SRCRELDATE!=	awk '/^\#define[[:space:]]*__FreeBSD_version/ { print $$3 }' \
		${SRCDIR}/sys/sys/param.h
.export SRCRELDATE
.endif
.if !defined(VERSION)
VERSION=	FreeBSD ${_REVISION}-${_BRANCH:C/-p[0-9]+$//} ${TARGET_ARCH} ${SRCRELDATE}
.export VERSION
.endif
MAJOR_REVISION=	${_REVISION:R}

.if !defined(PKG_VERSION)
_STRTIMENOW=	%Y%m%d%H%M%S
_TIMENOW=	${_STRTIMENOW:gmtime}
.if ${_BRANCH:MCURRENT*} || ${_BRANCH:MSTABLE*} || ${_BRANCH:MPRERELEASE*}
EXTRA_REVISION=	.snap${_TIMENOW}
.elif ${_BRANCH:MALPHA*}
EXTRA_REVISION=	.a${_BRANCH:C/ALPHA([0-9]+).*/\1/}.${_TIMENOW}
.elif ${_BRANCH:MBETA*}
EXTRA_REVISION=	.b${_BRANCH:C/BETA([0-9]+).*/\1/}.${_TIMENOW}
.elif ${_BRANCH:MRC*}
EXTRA_REVISION=	.rc${_BRANCH:C/RC([0-9]+).*/\1/}.${_TIMENOW}
.elif ${_BRANCH:M*-p*}
EXTRA_REVISION=	p${_BRANCH:C/.*-p([0-9]+$)/\1/}
.endif
PKG_VERSION:=	${MAJOR_REVISION}${EXTRA_REVISION:C/[[:space:]]//g}
.endif
.endif	# !defined(PKG_VERSION)

.if !defined(PKG_TIMESTAMP)
TIMEEPOCHNOW=		%s
SOURCE_DATE_EPOCH=	${TIMEEPOCHNOW:gmtime}
.else
SOURCE_DATE_EPOCH=	${PKG_TIMESTAMP}
.endif

PKG_NAME_PREFIX?=	FreeBSD
PKG_MAINTAINER?=	re@FreeBSD.org
PKG_WWW?=		https://www.FreeBSD.org
.export PKG_NAME_PREFIX
.export PKG_MAINTAINER
.export PKG_WWW

.if !defined(_MKSHOWCONFIG)
_CPUTYPE!=	MAKEFLAGS= CPUTYPE=${_TARGET_CPUTYPE} ${MAKE} -f /dev/null \
		-m ${.CURDIR}/share/mk MK_AUTO_OBJ=no -V CPUTYPE
.if ${_CPUTYPE} != ${_TARGET_CPUTYPE}
.error CPUTYPE global should be set with ?=.
.endif
.endif
.if make(buildworld)
BUILD_ARCH!=	uname -p
# On some Linux systems uname -p returns "unknown" so skip this check there.
# This check only exists to tell people to use TARGET_ARCH instead of
# MACHINE_ARCH so skipping it when crossbuilding on non-FreeBSD should be fine.
.if ${MACHINE_ARCH} != ${BUILD_ARCH} && ${.MAKE.OS} == "FreeBSD"
.error To cross-build, set TARGET_ARCH.
.endif
.endif
WORLDTMP?=	${OBJTOP}/tmp
BPATH=		${CCACHE_WRAPPER_PATH_PFX}${WORLDTMP}/legacy/usr/sbin:${WORLDTMP}/legacy/usr/bin:${WORLDTMP}/legacy/bin:${WORLDTMP}/legacy/usr/libexec
XPATH=		${WORLDTMP}/bin:${WORLDTMP}/usr/sbin:${WORLDTMP}/usr/bin

# When building we want to find the cross tools before the host tools in ${BPATH}.
# We also need to add UNIVERSE_TOOLCHAIN_PATH so that we can find the shared
# toolchain files (clang, lld, etc.) during make universe/tinderbox
STRICTTMPPATH=	${XPATH}:${BPATH}:${UNIVERSE_TOOLCHAIN_PATH}
# We should not be using tools from /usr/bin accidentally since this could cause
# the build to break on other systems that don't have that tool. For now we
# still allow using the old behaviour (inheriting $PATH) if
# BUILD_WITH_STRICT_TMPPATH is set to 0 but this will eventually be removed.

# Currently strict $PATH can cause build failures and does not work yet with
# USING_SYSTEM_LINKER/USING_SYSTEM_COMPILER. Once these issues have been
# resolved it will be turned on by default.
BUILD_WITH_STRICT_TMPPATH?=0
.if defined(CROSSBUILD_HOST)
# When building on non-FreeBSD we can't rely on the tools in /usr/bin being compatible
# with what FreeBSD expects. Therefore we only use tools from STRICTTMPPATH
# during the world build stage. We build most tools during the bootstrap-tools
# phase but symlink host tools that are known to work instead of building them
BUILD_WITH_STRICT_TMPPATH:=1
.endif
.if ${BUILD_WITH_STRICT_TMPPATH} != 0
TMPPATH=	${STRICTTMPPATH}
.else
TMPPATH=	${STRICTTMPPATH}:${PATH}
.endif

#
# Avoid running mktemp(1) unless actually needed.
# It may not be functional, e.g., due to new ABI
# when in the middle of installing over this system.
#
.if make(distributeworld) || make(installworld) || make(stageworld)
.if ${BUILD_WITH_STRICT_TMPPATH} != 0
MKTEMP=${WORLDTMP}/legacy/usr/bin/mktemp
.if !exists(${MKTEMP})
.error mktemp binary doesn't exist in expected location: ${MKTEMP}
.endif
.else
MKTEMP=mktemp
.endif
INSTALLTMP!=	${MKTEMP} -d -u -t install

.if ${.MAKE.OS} == "FreeBSD"
# When building on FreeBSD we always copy the host tools instead of linking
# into INSTALLTMP to avoid issues with incompatible libraries (see r364030).
# Note: we could create links if we don't intend to update the current machine.
INSTALLTMP_COPY_HOST_TOOL=cp
.else
# However, this is not necessary on Linux/macOS. Additionally, copying the host
# tools to another directory with cp results in AMFI Launch Constraint
# Violations on macOS Ventura as part of its System Integrity Protection.
INSTALLTMP_COPY_HOST_TOOL=ln -s
.endif
.endif

.if make(stagekernel) || make(distributekernel)
TAGS+=		kernel
PACKAGE=	kernel
.endif

#
# Building a world goes through the following stages
#
# 1. legacy stage [BMAKE]
#	This stage is responsible for creating compatibility
#	shims that are needed by the bootstrap-tools,
#	build-tools and cross-tools stages. These are generally
#	APIs that tools from one of those three stages need to
#	build that aren't present on the host.
# 1. bootstrap-tools stage [BMAKE]
#	This stage is responsible for creating programs that
#	are needed for backward compatibility reasons. They
#	are not built as cross-tools.
# 2. build-tools stage [TMAKE]
#	This stage is responsible for creating the object
#	tree and building any tools that are needed during
#	the build process. Some programs are listed during
#	this phase because they build binaries to generate
#	files needed to build these programs. This stage also
#	builds the 'build-tools' target rather than 'all'.
# 3. cross-tools stage [XMAKE]
#	This stage is responsible for creating any tools that
#	are needed for building the system. A cross-compiler is one
#	of them. This differs from build tools in two ways:
#	1. the 'all' target is built rather than 'build-tools'
#	2. these tools are installed into TMPPATH for stage 4.
# 4. world stage [WMAKE]
#	This stage actually builds the world.
# 5. install stage (optional) [IMAKE]
#	This stage installs a previously built world.
#

BOOTSTRAPPING?=	0
# Keep these in sync
MINIMUM_SUPPORTED_OSREL?= 1104001
MINIMUM_SUPPORTED_REL?= 11.4

# Common environment for world related stages
CROSSENV+=	\
		MACHINE_ARCH=${TARGET_ARCH} \
		MACHINE=${TARGET} \
		CPUTYPE=${TARGET_CPUTYPE}
.if ${MK_META_MODE} != "no"
# Don't rebuild build-tools targets during normal build.
CROSSENV+=	BUILD_TOOLS_META=.NOMETA
.endif
.if defined(TARGET_CFLAGS)
CROSSENV+=	${TARGET_CFLAGS}
.endif
.if (${TARGET} != ${MACHINE} && !defined(WITH_LOCAL_MODULES)) || \
    defined(WITHOUT_LOCAL_MODULES)
CROSSENV+=	LOCAL_MODULES=
.endif

BOOTSTRAPPING_OSRELDATE?=${OSRELDATE}

# bootstrap-tools stage
BMAKEENV=	INSTALL="sh ${.CURDIR}/tools/install.sh" \
		TOOLS_PREFIX=${TOOLS_PREFIX_UNDEF:U${WORLDTMP}} \
		PATH=${BPATH:Q}:${PATH:Q} \
		WORLDTMP=${WORLDTMP} \
		MAKEFLAGS="-m ${.CURDIR}/tools/build/mk ${.MAKEFLAGS}"
# need to keep this in sync with targets/pseudo/bootstrap-tools/Makefile
BSARGS= 	DESTDIR= \
		OBJTOP='${WORLDTMP}/obj-tools' \
		OBJROOT='$${OBJTOP}/' \
		MAKEOBJDIRPREFIX= \
		BOOTSTRAPPING=${BOOTSTRAPPING_OSRELDATE} \
		BWPHASE=${.TARGET:C,^_,,} \
		-DNO_CPU_CFLAGS \
		-DNO_LINT \
		-DNO_PIC \
		-DNO_SHARED \
		MK_ASAN=no \
		MK_CTF=no \
		MK_CLANG_EXTRAS=no \
		MK_CLANG_FORMAT=no \
		MK_CLANG_FULL=no \
		MK_HTML=no \
		MK_MAN=no \
		MK_PROFILE=no \
		MK_RETPOLINE=no \
		MK_SSP=no \
		MK_TESTS=no \
		MK_UBSAN=no \
		MK_WERROR=no \
		MK_INCLUDES=yes \
		MK_MAN_UTILS=yes

BMAKE=		\
		${TIME_ENV} ${BMAKEENV} ${MAKE} ${WORLD_FLAGS} -f Makefile.inc1 \
		${BSARGS}
.if empty(.MAKEOVERRIDES:MMK_LLVM_TARGET_ALL)
BMAKE+=		MK_LLVM_TARGET_ALL=no
.endif

# build-tools stage
TMAKE=		\
		${TIME_ENV} ${BMAKEENV} ${MAKE} ${WORLD_FLAGS} -f Makefile.inc1 \
		TARGET=${TARGET} TARGET_ARCH=${TARGET_ARCH} \
		DESTDIR= \
		BOOTSTRAPPING=${BOOTSTRAPPING_OSRELDATE} \
		BWPHASE=${.TARGET:C,^_,,} \
		-DNO_CPU_CFLAGS \
		-DNO_LINT \
		MK_ASAN=no \
		MK_CTF=no \
		MK_CLANG_EXTRAS=no \
		MK_CLANG_FORMAT=no \
		MK_CLANG_FULL=no \
		MK_LLDB=no \
		MK_RETPOLINE=no \
		MK_SSP=no \
		MK_TESTS=no \
		MK_UBSAN=no \
		MK_WERROR=no

# cross-tools stage
# TOOLS_PREFIX set in BMAKE
XMAKE=		${BMAKE} \
		TARGET=${TARGET} TARGET_ARCH=${TARGET_ARCH} \
		MK_LLDB=no \
		MK_LLVM_BINUTILS=no \
		MK_TESTS=no

# kernel-tools stage
KTMAKEENV=	INSTALL="sh ${.CURDIR}/tools/install.sh" \
		PATH=${BPATH:Q}:${PATH:Q} \
		WORLDTMP=${WORLDTMP} \
		MAKEFLAGS="-m ${.CURDIR}/tools/build/mk ${.MAKEFLAGS}"

KTMAKE=		${TIME_ENV} \
		TOOLS_PREFIX=${TOOLS_PREFIX_UNDEF:U${WORLDTMP}} \
		${KTMAKEENV} ${MAKE} ${WORLD_FLAGS} -f Makefile.inc1 \
		DESTDIR= \
		OBJTOP='${WORLDTMP}/obj-kernel-tools' \
		OBJROOT='$${OBJTOP}/' \
		MAKEOBJDIRPREFIX= \
		BOOTSTRAPPING=${BOOTSTRAPPING_OSRELDATE} \
		-DNO_CPU_CFLAGS \
		-DNO_LINT \
		-DNO_PIC \
		-DNO_SHARED \
		MK_CTF=no \
		MK_HTML=no \
		MK_MAN=no \
		MK_PROFILE=no \
		MK_SSP=no \
		MK_RETPOLINE=no \
		MK_WERROR=no

# world stage
WMAKEENV=	${CROSSENV} \
		INSTALL="${INSTALL_CMD} -U" \
		PATH=${TMPPATH:Q} \
		SYSROOT=${WORLDTMP}

# make hierarchy
HMAKE=		PATH=${TMPPATH:Q} ${MAKE} LOCAL_MTREE=${LOCAL_MTREE:Q}
.if defined(NO_ROOT)
HMAKE+=		PATH=${TMPPATH:Q} METALOG=${METALOG} -DNO_ROOT
.endif

CROSSENV+=	CC="${XCC} ${XCFLAGS}" CXX="${XCXX} ${XCXXFLAGS} ${XCFLAGS}" \
		CPP="${XCPP} ${XCFLAGS}" \
		AS="${XAS}" AR="${XAR}" ELFCTL="${XELFCTL}" LD="${XLD}" \
		LLVM_LINK="${XLLVM_LINK}" NM=${XNM} OBJCOPY="${XOBJCOPY}" \
		RANLIB=${XRANLIB} STRINGS=${XSTRINGS} \
		SIZE="${XSIZE}" STRIPBIN="${XSTRIPBIN}"

.if defined(CROSS_BINUTILS_PREFIX) && exists(${CROSS_BINUTILS_PREFIX})
# In the case of xdev-build tools, CROSS_BINUTILS_PREFIX won't be a
# directory, but the compiler will look in the right place for its
# tools so we don't need to tell it where to look.
BFLAGS+=	-B${CROSS_BINUTILS_PREFIX}
.endif


# The internal bootstrap compiler has a default sysroot set by TOOLS_PREFIX
# and target set by TARGET/TARGET_ARCH.  However, there are several needs to
# always pass an explicit --sysroot and -target.
# - External compiler needs sysroot and target flags.
# - External ld needs sysroot.
# - To be clear about the use of a sysroot when using the internal compiler.
# - Easier debugging.
# - Allowing WITH_SYSTEM_COMPILER+WITH_META_MODE to work together due to
#   the flip-flopping build command when sometimes using external and
#   sometimes using internal.
# - Allow using lld which has no support for default paths.
.if !defined(CROSS_BINUTILS_PREFIX) || !exists(${CROSS_BINUTILS_PREFIX})
BFLAGS+=	-B${WORLDTMP}/usr/bin
.endif
.if ${WANT_COMPILER_TYPE} == gcc || \
    (defined(X_COMPILER_TYPE) && ${X_COMPILER_TYPE} == gcc)
.elif ${WANT_COMPILER_TYPE} == clang || \
    (defined(X_COMPILER_TYPE) && ${X_COMPILER_TYPE} == clang)
XCFLAGS+=	-target ${TARGET_TRIPLE}
.endif
XCFLAGS+=	--sysroot=${WORLDTMP}

.if !empty(BFLAGS)
XCFLAGS+=	${BFLAGS}
.endif

.if ${MK_LIB32} == "yes"
_LIBCOMPAT= 32
.include "Makefile.libcompat"
.endif

# META_MODE normally ignores host file changes since every build updates
# timestamps (see NO_META_IGNORE_HOST in sys.mk).  There are known times
# when the ABI breaks though that we want to force rebuilding WORLDTMP
# to get updated host tools.
.if ${MK_META_MODE} == "yes" && ${MK_CLEAN} == "no" && \
    !defined(NO_META_IGNORE_HOST) && !defined(NO_META_IGNORE_HOST_HEADERS) && \
    !defined(_MKSHOWCONFIG)
# r318736 - ino64 major ABI breakage
META_MODE_BAD_ABI_VERS+=	1200031

.if !defined(OBJDIR_HOST_OSRELDATE)
.if exists(${OBJTOP}/host-osreldate.h)
OBJDIR_HOST_OSRELDATE!=	\
    awk '/^\#define[[:space:]]*__FreeBSD_version/ { print $$3 }' \
    ${OBJTOP}/host-osreldate.h
.elif exists(${WORLDTMP}/usr/include/osreldate.h)
OBJDIR_HOST_OSRELDATE=	0
.endif
.export OBJDIR_HOST_OSRELDATE
.endif

# Note that this logic is the opposite of normal BOOTSTRAP handling.  We want
# to compare the WORLDTMP's OSRELDATE to the host's OSRELDATE.  If the WORLDTMP
# is older than the ABI-breakage OSRELDATE of the HOST then we rebuild.
.if defined(OBJDIR_HOST_OSRELDATE)
.for _ver in ${META_MODE_BAD_ABI_VERS}
.if ${OSRELDATE} >= ${_ver} && ${OBJDIR_HOST_OSRELDATE} < ${_ver}
_meta_mode_need_rebuild=	${_ver}
.endif
.endfor
.if defined(_meta_mode_need_rebuild)
.info META_MODE: Rebuilding host tools due to ABI breakage in __FreeBSD_version ${_meta_mode_need_rebuild}.
NO_META_IGNORE_HOST_HEADERS=	1
.export NO_META_IGNORE_HOST_HEADERS
.endif	# defined(_meta_mode_need_rebuild)
.endif	# defined(OBJDIR_HOST_OSRELDATE)
.endif	# ${MK_META_MODE} == "yes" && ${MK_CLEAN} == "no" ...
# This is only used for META_MODE+filemon to track what the oldest
# __FreeBSD_version is in WORLDTMP.  This purposely does NOT have
# a make dependency on /usr/include/osreldate.h as the file should
# only be copied when it is missing or meta mode determines it has changed.
# Since host files are normally ignored without NO_META_IGNORE_HOST
# the file will never be updated unless that flag is specified.  This
# allows tracking the oldest osreldate to force rebuilds via
# META_MODE_BADABI_REVS above.
host-osreldate.h: # DO NOT ADD /usr/include/osreldate.h here
.if !defined(CROSSBUILD_HOST)
	@cp -f /usr/include/osreldate.h ${.TARGET}
.else
	@echo "#ifndef __FreeBSD_version" > ${.TARGET}
	@echo "#define __FreeBSD_version ${OSRELDATE}" >> ${.TARGET}
	@echo "#endif" >> ${.TARGET}
.endif

WMAKE=		${TIME_ENV} ${WMAKEENV} ${MAKE} ${WORLD_FLAGS} -f Makefile.inc1 \
		BWPHASE=${.TARGET:C,^_,,} \
		DESTDIR=${WORLDTMP}

IMAKEENV=	${CROSSENV}
IMAKE=		${TIME_ENV} ${IMAKEENV} ${MAKE} -f Makefile.inc1 \
		${IMAKE_INSTALL} ${IMAKE_MTREE}
.if empty(.MAKEFLAGS:M-n)
IMAKEENV+=	PATH=${STRICTTMPPATH:Q}:${INSTALLTMP:Q} \
		LD_LIBRARY_PATH=${INSTALLTMP:Q} \
		PATH_LOCALE=${INSTALLTMP}/locale
IMAKE+=		__MAKE_SHELL=${INSTALLTMP}/sh
.else
IMAKEENV+=	PATH=${TMPPATH:Q}:${INSTALLTMP:Q}
.endif

# When generating install media, do not allow user and group information from
# the build host to affect the contents of the distribution.
.if make(distributeworld) || make(distrib-dirs) || make(distribution) || \
    make(stageworld)
DB_FROM_SRC=	yes
.endif

.if defined(DB_FROM_SRC)
INSTALLFLAGS+=	-N ${.CURDIR}/etc
MTREEFLAGS+=	-N ${.CURDIR}/etc
.endif
_INSTALL_DDIR=	${DESTDIR}/${DISTDIR}
INSTALL_DDIR=	${_INSTALL_DDIR:S://:/:g:C:/$::}
.if defined(NO_ROOT)
METALOG?=	${DESTDIR}/${DISTDIR}/METALOG
METALOG:=	${METALOG:C,//+,/,g}
IMAKE+=		-DNO_ROOT METALOG=${METALOG}
METALOG_INSTALLFLAGS=	-U -M ${METALOG} -D ${INSTALL_DDIR}
INSTALLFLAGS+=	${METALOG_INSTALLFLAGS}
CERTCTLFLAGS=	${METALOG_INSTALLFLAGS}
MTREEFLAGS+=	-W
.endif
.if defined(BUILD_PKGS)
INSTALLFLAGS+=	-h sha256
.endif
.if defined(DB_FROM_SRC) || defined(NO_ROOT)
IMAKE_INSTALL=	INSTALL="${INSTALL_CMD} ${INSTALLFLAGS}"
IMAKE_MTREE=	MTREE_CMD="${MTREE_CMD} ${MTREEFLAGS}"
.endif
.if make(distributeworld)
CERTCTLDESTDIR=	${DESTDIR}/${DISTDIR}
CERTCTLFLAGS+=	-d /base
.else
CERTCTLDESTDIR=	${DESTDIR}
.endif
CERTCTLFLAGS+=	-D "${CERTCTLDESTDIR}"

DESTDIR_MTREEFLAGS=	-deU
# When creating worldtmp we don't need to set the directories as owned by root
# so we also pass -W
WORLDTMP_MTREEFLAGS=	-deUW
.if defined(NO_ROOT)
# When building with -DNO_ROOT we shouldn't be changing the directories
# that are created by mtree to be owned by root/wheel.
DESTDIR_MTREEFLAGS+=	-W
.endif
.if defined(DB_FROM_SRC)
DISTR_MTREEFLAGS=	-N ${.CURDIR}/etc
.endif
DISTR_MTREECMD=	${MTREE_CMD}
.if ${BUILD_WITH_STRICT_TMPPATH} != 0
DISTR_MTREECMD=	${WORLDTMP}/legacy/usr/sbin/mtree
.endif
DISTR_MTREE=	${DISTR_MTREECMD} ${DISTR_MTREEFLAGS}
WORLDTMP_MTREE=	${DISTR_MTREECMD} ${WORLDTMP_MTREEFLAGS}
DESTDIR_MTREE=	${DISTR_MTREECMD} ${DESTDIR_MTREEFLAGS}

METALOG_SORT_CMD=	env -i LC_COLLATE=C sort

# kernel stage
KMAKEENV=	${WMAKEENV:NSYSROOT=*}
KMAKE=		${TIME_ENV} ${KMAKEENV} ${MAKE} ${.MAKEFLAGS} ${KERNEL_FLAGS} KERNEL=${INSTKERNNAME}

#
# buildworld
#
# Attempt to rebuild the entire system, with reasonable chance of
# success, regardless of how old your existing system is.
#
_sanity_check: .PHONY .MAKE
.if ${.CURDIR:C/[^,]//g} != ""
#	The m4 build of sendmail files doesn't like it if ',' is used
#	anywhere in the path of it's files.
	@echo
	@echo "*** Error: path to source tree contains a comma ','"
	@echo
	@false
.elif ${.CURDIR:M*\:*} != ""
#	Using ':' leaks into PATH and breaks finding cross-tools.
	@echo
	@echo "*** Error: path to source tree contains a colon ':'"
	@echo
	@false
.endif

# Our current approach to dependency tracking cannot cope with certain source
# tree changes, particularly with respect to removing source files and
# replacing generated files.  Handle these cases here in an ad-hoc fashion.
_cleanobj_fast_depend_hack: .PHONY
	@echo ">>> Deleting stale dependencies...";
	sh ${.CURDIR}/tools/build/depend-cleanup.sh ${OBJTOP}

_worldtmp: .PHONY
	@echo
	@echo "--------------------------------------------------------------"
	@echo ">>> Rebuilding the temporary build tree"
	@echo "--------------------------------------------------------------"
.if ${MK_CLEAN} == "yes"
	rm -rf ${WORLDTMP}
.else
# Note: for delete-old we need to set $PATH to also include the host $PATH
# since otherwise a partial build with missing symlinks in ${WORLDTMP}/legacy/
# will fail to run due to missing binaries. $WMAKE sets PATH to only ${TMPPATH}
# so we remove that assingnment from $WMAKE and prepend the new $PATH
	${_+_}@if [ -e "${WORLDTMP}" ]; then \
		echo ">>> Deleting stale files in build tree..."; \
		cd ${.CURDIR}; env PATH=${TMPPATH:Q}:${PATH:Q} ${WMAKE:NPATH=*} \
		    _NO_INCLUDE_COMPILERMK=t -DBATCH_DELETE_OLD_FILES delete-old \
		    delete-old-libs >/dev/null; \
	fi
	rm -rf ${WORLDTMP}/legacy/usr/include
.if ${USING_SYSTEM_COMPILER} == "yes"
.for cc in cc c++
	if [ -x ${WORLDTMP}/usr/bin/${cc} ]; then \
		inum=$$(stat -f %i ${WORLDTMP}/usr/bin/${cc}); \
		find ${WORLDTMP}/usr/bin -inum $${inum} -delete; \
	fi
.endfor
.endif	# ${USING_SYSTEM_COMPILER} == "yes"
.if ${USING_SYSTEM_LINKER} == "yes"
	@rm -f ${WORLDTMP}/usr/bin/ld ${WORLDTMP}/usr/bin/ld.lld
.endif	# ${USING_SYSTEM_LINKER} == "yes"
.endif	# ${MK_CLEAN} == "yes"
	@mkdir -p ${WORLDTMP}
	@touch ${WORLDTMP}/${.TARGET}
# We can't use mtree to create the worldtmp directories since it may not be
# available on the target system (this happens e.g. when building on non-FreeBSD)
	${_+_}cd ${.CURDIR}/tools/build; \
	    ${MAKE} DIRPRFX=tools/build/ DESTDIR=${WORLDTMP}/legacy installdirs
# In order to build without inheriting $PATH we need to add symlinks to the host
# tools in $WORLDTMP for the tools that we don't build during bootstrap-tools
	${_+_}cd ${.CURDIR}/tools/build; \
	    ${MAKE} DIRPRFX=tools/build/ DESTDIR=${WORLDTMP}/legacy host-symlinks

_legacy:
	@echo
	@echo "--------------------------------------------------------------"
	@echo ">>> stage 1.1: legacy release compatibility shims"
	@echo "--------------------------------------------------------------"
	${_+_}cd ${.CURDIR}; ${BMAKE} legacy
_bootstrap-tools:
	@echo
	@echo "--------------------------------------------------------------"
	@echo ">>> stage 1.2: bootstrap tools"
	@echo "--------------------------------------------------------------"
.if ${MK_CLEAN} != "yes"
	${_+_}cd ${.CURDIR}; ${BMAKE} _NO_INCLUDE_COMPILERMK=t _cleanobj_fast_depend_hack
.endif
	${_+_}cd ${.CURDIR}; ${BMAKE} bootstrap-tools
	mkdir -p ${WORLDTMP}/usr ${WORLDTMP}/lib/casper ${WORLDTMP}/lib/geom \
	    ${WORLDTMP}/bin
	${WORLDTMP_MTREE} -f ${.CURDIR}/etc/mtree/BSD.usr.dist \
	    -p ${WORLDTMP}/usr >/dev/null
	${WORLDTMP_MTREE} -f ${.CURDIR}/etc/mtree/BSD.include.dist \
	    -p ${WORLDTMP}/usr/include >/dev/null
.if ${TARGET_ARCH} == "amd64"
	mkdir -p ${WORLDTMP}/usr/include/i386
.endif
	ln -sf ${.CURDIR}/sys ${WORLDTMP}
.if ${MK_DEBUG_FILES} != "no"
	${WORLDTMP_MTREE} -f ${.CURDIR}/etc/mtree/BSD.debug.dist \
	    -p ${WORLDTMP}/usr/lib >/dev/null
.endif
.for _mtree in ${LOCAL_MTREE}
	${WORLDTMP_MTREE} -f ${.CURDIR}/${_mtree} -p ${WORLDTMP} > /dev/null
.endfor
_cleanobj:
.if ${MK_CLEAN} == "yes"
	@echo
	@echo "--------------------------------------------------------------"
	@echo ">>> stage 2.1: cleaning up the object tree"
	@echo "--------------------------------------------------------------"
	# Avoid including bsd.compiler.mk in clean and obj with _NO_INCLUDE_COMPILERMK
	# since the restricted $PATH might not contain a valid cc binary
	${_+_}cd ${.CURDIR}; ${WMAKE} _NO_INCLUDE_COMPILERMK=t ${CLEANDIR}
.if defined(_LIBCOMPAT)
	${_+_}cd ${.CURDIR}; ${LIBCOMPATWMAKE} _NO_INCLUDE_COMPILERMK=t -f Makefile.inc1 ${CLEANDIR}
.endif
.else
	${_+_}cd ${.CURDIR}; ${WMAKE} _NO_INCLUDE_COMPILERMK=t _cleanobj_fast_depend_hack
.endif	# ${MK_CLEAN} == "yes"
_obj:
	@echo
	@echo "--------------------------------------------------------------"
	@echo ">>> stage 2.2: rebuilding the object tree"
	@echo "--------------------------------------------------------------"
	${_+_}cd ${.CURDIR}; ${WMAKE} _NO_INCLUDE_COMPILERMK=t obj
_build-tools:
	@echo
	@echo "--------------------------------------------------------------"
	@echo ">>> stage 2.3: build tools"
	@echo "--------------------------------------------------------------"
	${_+_}cd ${.CURDIR}; ${TMAKE} build-tools
_cross-tools:
	@echo
	@echo "--------------------------------------------------------------"
	@echo ">>> stage 3: cross tools"
	@echo "--------------------------------------------------------------"
	@rm -f ${OBJTOP}/toolchain-metadata.mk
	${_+_}cd ${.CURDIR}; ${XMAKE} cross-tools
	${_+_}cd ${.CURDIR}; ${XMAKE} kernel-tools
_build-metadata:
	@echo
	@echo "--------------------------------------------------------------"
	@echo ">>> stage 3.1: recording build metadata"
	@echo "--------------------------------------------------------------"
	${_+_}cd ${.CURDIR}; ${WMAKE} toolchain-metadata.mk
	${_+_}cd ${.CURDIR}; ${WMAKE} host-osreldate.h
_includes:
	@echo
	@echo "--------------------------------------------------------------"
	@echo ">>> stage 4.1: building includes"
	@echo "--------------------------------------------------------------"
# Special handling for SUBDIR_OVERRIDE in buildworld as they most likely need
# headers from default SUBDIR.  Do SUBDIR_OVERRIDE includes last.
	${_+_}cd ${.CURDIR}; ${WMAKE} SUBDIR_OVERRIDE= SHARED=symlinks \
	    MK_INCLUDES=yes includes
.if !empty(SUBDIR_OVERRIDE) && make(buildworld)
	${_+_}cd ${.CURDIR}; ${WMAKE} MK_INCLUDES=yes SHARED=symlinks includes
.endif
	${_+_}cd ${.CURDIR};  ${WMAKE} test-includes
_libraries:
	@echo
	@echo "--------------------------------------------------------------"
	@echo ">>> stage 4.2: building libraries"
	@echo "--------------------------------------------------------------"
	${_+_}cd ${.CURDIR}; \
	    ${WMAKE} -DNO_FSCHG MK_HTML=no -DNO_LINT MK_MAN=no \
	    MK_PROFILE=no MK_TESTS=no MK_TESTS_SUPPORT=${MK_TESTS_SUPPORT} \
	    libraries
everything: .PHONY
	@echo
	@echo "--------------------------------------------------------------"
	@echo ">>> stage 4.4: building everything"
	@echo "--------------------------------------------------------------"
	${_+_}cd ${.CURDIR}; _PARALLEL_SUBDIR_OK=1 ${WMAKE} all

WMAKE_TGTS=
.if !defined(WORLDFAST)
WMAKE_TGTS+=	_sanity_check _worldtmp _legacy
.if empty(SUBDIR_OVERRIDE)
WMAKE_TGTS+=	_bootstrap-tools
.endif
WMAKE_TGTS+=	_cleanobj
.if !defined(NO_OBJWALK)
WMAKE_TGTS+=	_obj
.endif
WMAKE_TGTS+=	_build-tools _cross-tools
WMAKE_TGTS+=	_build-metadata
WMAKE_TGTS+=	_includes
.endif
.if !defined(NO_LIBS)
WMAKE_TGTS+=	_libraries
.endif
.if defined(_LIBCOMPAT) && empty(SUBDIR_OVERRIDE)
WMAKE_TGTS+=	build${libcompat}
.endif
WMAKE_TGTS+=	everything

# record buildworld time in seconds
.if make(buildworld)
_BUILDWORLD_START!= date '+%s'
.export _BUILDWORLD_START
.endif

buildworld: buildworld_prologue ${WMAKE_TGTS} buildworld_epilogue .PHONY
.ORDER: buildworld_prologue ${WMAKE_TGTS} buildworld_epilogue

_ncpu_cmd=sysctl -n hw.ncpu 2>/dev/null || nproc 2>/dev/null || echo unknown

buildworld_prologue: .PHONY
	@echo "--------------------------------------------------------------"
	@echo ">>> World build started on `LC_ALL=C date`"
	@echo "--------------------------------------------------------------"

buildworld_epilogue: .PHONY
	@echo
	@echo "--------------------------------------------------------------"
	@echo ">>> World build completed on `LC_ALL=C date`"
	@seconds=$$(($$(date '+%s') - ${_BUILDWORLD_START})); \
	  echo -n ">>> World built in $$seconds seconds, "; \
	  echo "ncpu: $$(${_ncpu_cmd})${.MAKE.JOBS:S/^/, make -j/}"
	@echo "--------------------------------------------------------------"

#
# We need to have this as a target because the indirection between Makefile
# and Makefile.inc1 causes the correct PATH to be used, rather than a
# modification of the current environment's PATH.  In addition, we need
# to quote multiword values.
#
buildenvvars: .PHONY
	@echo ${WMAKEENV:Q} ${.MAKE.EXPORTED:@v@$v=\"${$v}\"@}

.if ${.TARGETS:Mbuildenv}
.if ${.MAKEFLAGS:M-j}
.error The buildenv target is incompatible with -j
.endif
.endif
BUILDENV_DIR?=	${.CURDIR}
#
# Note: make will report any errors the shell reports. This can
# be odd if the last command in an interactive shell generates an
# error or is terminated by SIGINT. These reported errors look bad,
# but are harmless. Allowing them also allows BUILDENV_SHELL to
# be a complex command whose status will be returned to the caller.
# Some scripts in tools rely on this behavior to report build errors.
#
buildenv: .PHONY
	@echo Entering world for ${TARGET_ARCH}:${TARGET}
.if ${BUILDENV_SHELL:M*zsh*}
	@echo For ZSH you must run: export CPUTYPE=${TARGET_CPUTYPE}
.endif
	@cd ${BUILDENV_DIR} && env ${WMAKEENV} \
	INSTALL="${INSTALL_CMD} ${INSTALLFLAGS}" \
	MTREE_CMD="${MTREE_CMD} ${MTREEFLAGS}" BUILDENV=1 ${BUILDENV_SHELL}

TOOLCHAIN_TGTS=	${WMAKE_TGTS:Neverything:Nbuild${libcompat}}
toolchain: ${TOOLCHAIN_TGTS} .PHONY
KERNEL_TOOLCHAIN_TGTS=	${TOOLCHAIN_TGTS:N_obj:N_cleanobj:N_includes:N_libraries}
.if make(kernel-toolchain)
.ORDER: ${KERNEL_TOOLCHAIN_TGTS}
.endif
kernel-toolchain: ${KERNEL_TOOLCHAIN_TGTS} .PHONY

#
# installcheck
#
# Checks to be sure system is ready for installworld/installkernel.
#
installcheck: _installcheck_world _installcheck_kernel .PHONY
_installcheck_world: .PHONY
	@echo "--------------------------------------------------------------"
	@echo ">>> Install check world"
	@echo "--------------------------------------------------------------"
_installcheck_kernel: .PHONY
	@echo "--------------------------------------------------------------"
	@echo ">>> Install check kernel"
	@echo "--------------------------------------------------------------"

#
# Require DESTDIR to be set if installing for a different architecture or
# using the user/group database in the source tree.
#
.if ${TARGET_ARCH} != ${MACHINE_ARCH} || ${TARGET} != ${MACHINE} || \
    defined(DB_FROM_SRC)
.if !make(distributeworld)
_installcheck_world: __installcheck_DESTDIR
_installcheck_kernel: __installcheck_DESTDIR
__installcheck_DESTDIR: .PHONY
.if !defined(DESTDIR) || empty(DESTDIR)
	@echo "ERROR: Please set DESTDIR!"; \
	false
.endif
.endif
.endif

.if !defined(DB_FROM_SRC)
#
# Check for missing UIDs/GIDs.
#
CHECK_UIDS=	auditdistd
CHECK_GIDS=	audit
CHECK_UIDS+=	ntpd
CHECK_GIDS+=	ntpd
CHECK_UIDS+=	proxy
CHECK_GIDS+=	proxy authpf
CHECK_UIDS+=	smmsp
CHECK_GIDS+=	smmsp
CHECK_UIDS+=	unbound
CHECK_GIDS+=	unbound
_installcheck_world: __installcheck_UGID
__installcheck_UGID: .PHONY
.for uid in ${CHECK_UIDS}
	@if ! `id -u ${uid} >/dev/null 2>&1`; then \
		echo "ERROR: Required ${uid} user is missing, see /usr/src/UPDATING."; \
		false; \
	fi
.endfor
.for gid in ${CHECK_GIDS}
	@if ! `find / -prune -group ${gid} >/dev/null 2>&1`; then \
		echo "ERROR: Required ${gid} group is missing, see /usr/src/UPDATING."; \
		false; \
	fi
.endfor
.endif
#
# If installing over the running system (DESTDIR is / or unset) and the install
# includes rescue, try running rescue from the objdir as a sanity check.  If
# rescue is not functional (e.g., because it depends on a system call not
# supported by the currently running kernel), abort the installation.
#
.if !make(distributeworld) && ${MK_RESCUE} != "no" && \
    (empty(DESTDIR) || ${DESTDIR} == "/") && empty(BYPASS_INSTALLCHECK_SH)
_installcheck_world: __installcheck_sh_check
__installcheck_sh_check: .PHONY
	@if [ "`${OBJTOP}/rescue/rescue/rescue sh -c 'echo OK'`" != \
	    OK ]; then \
		echo "rescue/sh check failed, installation aborted" >&2; \
		false; \
	fi
.endif

#
# Required install tools to be saved in a scratch dir for safety.
#
.if !defined(CROSSBUILD_HOST)
_sysctl=sysctl
.endif

ITOOLS=	[ awk cap_mkdb cat chflags chmod chown cmp cp \
	date echo egrep find grep id install ${_install-info} \
	ln make mkdir mtree mv pwd_mkdb \
	rm sed services_mkdb sh sort strip ${_sysctl} test time true uname wc

.if ${MK_ZONEINFO} != "no"
ITOOLS+=tzsetup
.endif

# Needed for share/man
.if ${MK_MAN_UTILS} != "no"
ITOOLS+=makewhatis
.endif

ITOOLS+=${LOCAL_ITOOLS}

#
# distributeworld
#
# Distributes everything compiled by a `buildworld'.
#
# installworld
#
# Installs everything compiled by a 'buildworld'.
#

# Non-base distributions produced by the base system
EXTRA_DISTRIBUTIONS=
.if defined(_LIBCOMPAT)
EXTRA_DISTRIBUTIONS+=	lib${libcompat}
.endif
.if ${MK_TESTS} != "no"
EXTRA_DISTRIBUTIONS+=	tests
.endif

DEBUG_DISTRIBUTIONS=
.if ${MK_DEBUG_FILES} != "no"
DEBUG_DISTRIBUTIONS+=	base ${EXTRA_DISTRIBUTIONS:S,tests,,}
.endif

MTREE_MAGIC?=	mtree 2.0

distributeworld installworld stageworld: _installcheck_world .PHONY
	mkdir -p ${INSTALLTMP}
	progs=$$(for prog in ${ITOOLS}; do \
		if progpath=`env PATH=${TMPPATH:Q} which $$prog`; then \
			echo $$progpath; \
		else \
			echo "Required tool $$prog not found in PATH ("${TMPPATH:Q}")." >&2; \
			exit 1; \
		fi; \
	    done); \
	if [ -z "${CROSSBUILD_HOST}" ] ; then \
		libs=$$(ldd -f "%o %p\n" -f "%o %p\n" $$progs 2>/dev/null | sort -u | grep -Ev '\[.*]' | \
		    while read line; do \
			set -- $$line; \
			if [ "$$2 $$3" != "not found" ]; then \
				echo $$2; \
			else \
				echo "Required library $$1 not found." >&2; \
				exit 1; \
			fi; \
		    done); \
	fi; \
	${INSTALLTMP_COPY_HOST_TOOL} $$libs $$progs ${INSTALLTMP}
	cp -R $${PATH_LOCALE:-"/usr/share/locale"} ${INSTALLTMP}/locale
.