xref: /freebsd/Makefile.inc1 (revision 3332f1b444d4a73238e9f59cca27bfc95fe936bd)
1#
2# $FreeBSD$
3#
4# Make command line options:
5#	-DNO_CLEANDIR run ${MAKE} clean, instead of ${MAKE} cleandir
6#	-DNO_CLEAN do not clean at all
7#	-DDB_FROM_SRC use the user/group databases in src/etc instead of
8#	    the system database when installing.
9#	-DNO_SHARE do not go into share subdir
10#	-DKERNFAST define NO_KERNEL{CONFIG,CLEAN,OBJ}
11#	-DNO_KERNELCONFIG do not run config in ${MAKE} buildkernel
12#	-DNO_KERNELCLEAN do not run ${MAKE} clean in ${MAKE} buildkernel
13#	-DNO_KERNELOBJ do not run ${MAKE} obj in ${MAKE} buildkernel
14#	-DNO_ROOT install without using root privilege
15#	-DWITHOUT_CTF do not run the DTrace CTF conversion tools on built objects
16#	LOCAL_DIRS="list of dirs" to add additional dirs to the SUBDIR list
17#	LOCAL_ITOOLS="list of tools" to add additional tools to the ITOOLS list
18#	LOCAL_LIB_DIRS="list of dirs" to add additional dirs to libraries target
19#	LOCAL_MTREE="list of mtree files" to process to allow local directories
20#	    to be created before files are installed
21#	LOCAL_LEGACY_DIRS="list of dirs" to add additional dirs to the legacy
22#	    target
23#	LOCAL_BSTOOL_DIRS="list of dirs" to add additional dirs to the
24#	    bootstrap-tools target
25#	LOCAL_TOOL_DIRS="list of dirs" to add additional dirs to the build-tools
26#	    target
27#	LOCAL_XTOOL_DIRS="list of dirs" to add additional dirs to the
28#	    cross-tools target
29#	METALOG="path to metadata log" to write permission and ownership
30#	    when NO_ROOT is set.  (default: ${DESTDIR}/${DISTDIR}/METALOG,
31#           check /etc/make.conf for DISTDIR)
32#	TARGET="machine" to crossbuild world for a different machine type
33#	TARGET_ARCH= may be required when a TARGET supports multiple endians
34#	BUILDENV_SHELL= shell to launch for the buildenv target (def:${SHELL})
35#	WORLD_FLAGS= additional flags to pass to make(1) during buildworld
36#	KERNEL_FLAGS= additional flags to pass to make(1) during buildkernel
37#	SUBDIR_OVERRIDE="list of dirs" to build rather than everything.
38#	    All libraries and includes, and some build tools will still build.
39
40#
41# The intended user-driven targets are:
42# buildworld  - rebuild *everything*, including glue to help do upgrades
43# installworld- install everything built by "buildworld"
44# checkworld  - run test suite on installed world
45# doxygen     - build API documentation of the kernel
46#
47# Standard targets (not defined here) are documented in the makefiles in
48# /usr/share/mk.  These include:
49#		obj depend all install clean cleandepend cleanobj
50
51.if !defined(TARGET) || !defined(TARGET_ARCH)
52.error "Both TARGET and TARGET_ARCH must be defined."
53.endif
54
55.if make(showconfig) || make(test-system-*)
56_MKSHOWCONFIG=	t
57.endif
58
59SRCDIR?=	${.CURDIR}
60LOCALBASE?=	/usr/local
61TIME_ENV ?= time env
62
63.include "share/mk/src.tools.mk"
64
65# Cross toolchain changes must be in effect before bsd.compiler.mk
66# so that gets the right CC, and pass CROSS_TOOLCHAIN to submakes.
67.if defined(CROSS_TOOLCHAIN)
68.if exists(${LOCALBASE}/share/toolchains/${CROSS_TOOLCHAIN}.mk)
69.include "${LOCALBASE}/share/toolchains/${CROSS_TOOLCHAIN}.mk"
70.elif exists(/usr/share/toolchains/${CROSS_TOOLCHAIN}.mk)
71.include "/usr/share/toolchains/${CROSS_TOOLCHAIN}.mk"
72.elif exists(${CROSS_TOOLCHAIN})
73.include "${CROSS_TOOLCHAIN}"
74.else
75.error CROSS_TOOLCHAIN ${CROSS_TOOLCHAIN} not found
76.endif
77CROSSENV+=CROSS_TOOLCHAIN="${CROSS_TOOLCHAIN}"
78.endif
79.if defined(CROSS_TOOLCHAIN_PREFIX)
80CROSS_COMPILER_PREFIX?=${CROSS_TOOLCHAIN_PREFIX}
81.endif
82
83XCOMPILERS=	CC CXX CPP
84.for COMPILER in ${XCOMPILERS}
85.if defined(CROSS_COMPILER_PREFIX)
86X${COMPILER}?=	${CROSS_COMPILER_PREFIX}${${COMPILER}}
87.else
88X${COMPILER}?=	${${COMPILER}}
89.endif
90.endfor
91# If a full path to an external cross compiler is given, don't build
92# a cross compiler.
93.if ${XCC:N${CCACHE_BIN}:M/*}
94MK_CLANG_BOOTSTRAP=	no
95# Make sure sub-makes see the option as disabled so the hack in bsd.sys.mk to
96# work around incompatible headers in Clang's resource directory is enabled.
97.MAKEOVERRIDES+=	MK_CLANG_BOOTSTRAP
98.endif
99
100# Pull in compiler metadata from buildworld/toolchain if possible to avoid
101# running CC from bsd.compiler.mk.
102.if make(installworld) || make(install) || make(distributeworld) || \
103    make(stageworld)
104.-include "${OBJTOP}/toolchain-metadata.mk"
105.if !defined(_LOADED_TOOLCHAIN_METADATA)
106.error A build is required first.  You may have the wrong MAKEOBJDIRPREFIX set.
107.endif
108.endif
109
110# Pull in COMPILER_TYPE and COMPILER_FREEBSD_VERSION early. Pull it from the
111# tree to be friendlier to foreign OS builds. It's safe to do so unconditionally
112# here since we will always have the right make, unlike in src/Makefile
113# Don't include bsd.linker.mk yet until XBINUTILS is handled (after src.opts.mk)
114_NO_INCLUDE_LINKERMK=	t
115# We also want the X_COMPILER* variables if we are using an external toolchain.
116_WANT_TOOLCHAIN_CROSS_VARS=	t
117.include "share/mk/bsd.compiler.mk"
118.undef _NO_INCLUDE_LINKERMK
119.undef _WANT_TOOLCHAIN_CROSS_VARS
120# src.opts.mk depends on COMPILER_FEATURES
121.include "share/mk/src.opts.mk"
122
123.if ${TARGET} == ${MACHINE}
124TARGET_CPUTYPE?=${CPUTYPE}
125.else
126TARGET_CPUTYPE?=
127.endif
128.if !empty(TARGET_CPUTYPE)
129_TARGET_CPUTYPE=${TARGET_CPUTYPE}
130.else
131_TARGET_CPUTYPE=dummy
132.endif
133.if ${TARGET} == "arm"
134.if ${TARGET_ARCH:Marmv[67]*} != "" && ${TARGET_CPUTYPE:M*soft*} == ""
135TARGET_ABI=	gnueabihf
136.else
137TARGET_ABI=	gnueabi
138.endif
139.endif
140MACHINE_ABI?=	unknown
141MACHINE_TRIPLE?=${MACHINE_ARCH:S/amd64/x86_64/:C/[hs]f$//:S/mipsn32/mips64/}-${MACHINE_ABI}-freebsd14.0
142TARGET_ABI?=	unknown
143TARGET_TRIPLE?=	${TARGET_ARCH:S/amd64/x86_64/:C/[hs]f$//:S/mipsn32/mips64/}-${TARGET_ABI}-freebsd14.0
144KNOWN_ARCHES?=	aarch64/arm64 \
145		amd64 \
146		armv6/arm \
147		armv7/arm \
148		i386 \
149		mips \
150		mipsel/mips \
151		mips64el/mips \
152		mipsn32el/mips \
153		mips64/mips \
154		mipsn32/mips \
155		mipshf/mips \
156		mipselhf/mips \
157		mips64elhf/mips \
158		mips64hf/mips \
159		powerpc \
160		powerpc64/powerpc \
161		powerpc64le/powerpc \
162		powerpcspe/powerpc \
163		riscv64/riscv \
164		riscv64sf/riscv
165
166.if ${TARGET} == ${TARGET_ARCH}
167_t=		${TARGET}
168.else
169_t=		${TARGET_ARCH}/${TARGET}
170.endif
171.for _t in ${_t}
172.if empty(KNOWN_ARCHES:M${_t})
173.error Unknown target ${TARGET_ARCH}:${TARGET}.
174.endif
175.endfor
176
177.if ${.MAKE.OS} != "FreeBSD"
178CROSSBUILD_HOST=${.MAKE.OS}
179.if ${.MAKE.OS} != "Linux" && ${.MAKE.OS} != "Darwin"
180.warning "Unsupported crossbuild system: ${.MAKE.OS}. Build will probably fail!"
181.endif
182# We need to force NO_ROOT/DB_FROM_SRC builds when building on other operating
183# systems since the BSD.foo.dist specs contain users and groups that do not
184# exist by default on a Linux/MacOS system.
185NO_ROOT:=	1
186DB_FROM_SRC:=	1
187.export NO_ROOT
188.endif
189
190# If all targets are disabled for system llvm then don't expect it to work
191# for cross-builds.
192.if !defined(TOOLS_PREFIX) && ${MK_LLVM_TARGET_ALL} == "no" && \
193    ${MACHINE} != ${TARGET} && ${MACHINE_ARCH} != ${TARGET_ARCH} && \
194    !make(showconfig)
195MK_SYSTEM_COMPILER=	no
196MK_SYSTEM_LINKER=	no
197.endif
198
199# Handle external binutils.
200.if defined(CROSS_TOOLCHAIN_PREFIX)
201CROSS_BINUTILS_PREFIX?=${CROSS_TOOLCHAIN_PREFIX}
202.endif
203XBINUTILS=	AS AR ELFCTL LD NM OBJCOPY RANLIB SIZE STRINGS STRIPBIN
204.for BINUTIL in ${XBINUTILS}
205.if defined(CROSS_BINUTILS_PREFIX) && \
206    exists(${CROSS_BINUTILS_PREFIX}/${${BINUTIL}})
207X${BINUTIL}?=	${CROSS_BINUTILS_PREFIX:C,/*$,,}/${${BINUTIL}}
208.else
209X${BINUTIL}?=	${${BINUTIL}}
210.endif
211.endfor
212
213# If a full path to an external linker is given, don't build lld.
214.if ${XLD:M/*}
215MK_LLD_BOOTSTRAP=	no
216.endif
217
218# We also want the X_LINKER* variables if we are using an external toolchain.
219_WANT_TOOLCHAIN_CROSS_VARS=	t
220.include "share/mk/bsd.linker.mk"
221.undef _WANT_TOOLCHAIN_CROSS_VARS
222
223# Begin WITH_SYSTEM_COMPILER / WITH_SYSTEM_LD
224
225# WITH_SYSTEM_COMPILER - Pull in needed values and make a decision.
226
227# Check if there is a local compiler that can satisfy as an external compiler.
228# Which compiler is expected to be used?
229.if ${MK_CLANG_BOOTSTRAP} == "yes"
230WANT_COMPILER_TYPE=	clang
231.else
232WANT_COMPILER_TYPE=
233.endif
234
235.if !defined(WANT_COMPILER_FREEBSD_VERSION) && !make(showconfig) && \
236    !make(test-system-linker)
237.if ${WANT_COMPILER_TYPE} == "clang"
238WANT_COMPILER_FREEBSD_VERSION_FILE= lib/clang/freebsd_cc_version.h
239WANT_COMPILER_FREEBSD_VERSION!= \
240	awk '$$2 == "FREEBSD_CC_VERSION" {printf("%d\n", $$3)}' \
241	${SRCDIR}/${WANT_COMPILER_FREEBSD_VERSION_FILE} || echo unknown
242WANT_COMPILER_VERSION_FILE= lib/clang/include/clang/Basic/Version.inc
243WANT_COMPILER_VERSION!= \
244	awk '$$2 == "CLANG_VERSION" {split($$3, a, "."); print a[1] * 10000 + a[2] * 100 + a[3]}' \
245	${SRCDIR}/${WANT_COMPILER_VERSION_FILE} || echo unknown
246.endif
247.export WANT_COMPILER_FREEBSD_VERSION WANT_COMPILER_VERSION
248.endif	# !defined(WANT_COMPILER_FREEBSD_VERSION)
249
250# It needs to be the same revision as we would build for the bootstrap.
251# If the expected vs CC is different then we can't skip.
252# GCC cannot be used for cross-arch yet.  For clang we pass -target later if
253# TARGET_ARCH!=MACHINE_ARCH.
254.if ${MK_SYSTEM_COMPILER} == "yes" && \
255    defined(WANT_COMPILER_FREEBSD_VERSION) && \
256    ${MK_CLANG_BOOTSTRAP} == "yes" && \
257    !make(xdev*) && \
258    ${X_COMPILER_TYPE} == ${WANT_COMPILER_TYPE} && \
259    (${X_COMPILER_TYPE} == "clang" || ${TARGET_ARCH} == ${MACHINE_ARCH}) && \
260    ${X_COMPILER_VERSION} == ${WANT_COMPILER_VERSION} && \
261    ${X_COMPILER_FREEBSD_VERSION} == ${WANT_COMPILER_FREEBSD_VERSION}
262# Everything matches, disable the bootstrap compiler.
263MK_CLANG_BOOTSTRAP=	no
264USING_SYSTEM_COMPILER=	yes
265.endif	# ${WANT_COMPILER_TYPE} == ${COMPILER_TYPE}
266
267# WITH_SYSTEM_LD - Pull in needed values and make a decision.
268
269# Check if there is a local linker that can satisfy as an external linker.
270# Which linker is expected to be used?
271.if ${MK_LLD_BOOTSTRAP} == "yes"
272WANT_LINKER_TYPE=		lld
273.else
274WANT_LINKER_TYPE=
275.endif
276
277.if !defined(WANT_LINKER_FREEBSD_VERSION) && !make(showconfig) && \
278    !make(test-system-compiler)
279.if ${WANT_LINKER_TYPE} == "lld"
280WANT_LINKER_FREEBSD_VERSION_FILE= lib/clang/include/VCSVersion.inc
281_WANT_LINKER_FREEBSD_VERSION!= \
282	awk '$$2 == "LLD_REVISION" {gsub(/"/, "", $$3); print $$3}' \
283	${SRCDIR}/${WANT_LINKER_FREEBSD_VERSION_FILE} || echo unknown
284WANT_LINKER_FREEBSD_VERSION=${_WANT_LINKER_FREEBSD_VERSION:C/.*-(.*)/\1/}
285WANT_LINKER_VERSION_FILE= lib/clang/include/lld/Common/Version.inc
286WANT_LINKER_VERSION!= \
287	awk '$$2 == "LLD_VERSION_STRING" { gsub("\"", "", $$3); split($$3, a, "."); print a[1] * 10000 + a[2] * 100 + a[3]}' \
288	${SRCDIR}/${WANT_LINKER_VERSION_FILE} || echo unknown
289.else
290WANT_LINKER_FREEBSD_VERSION_FILE=
291WANT_LINKER_FREEBSD_VERSION=
292.endif
293.export WANT_LINKER_FREEBSD_VERSION WANT_LINKER_VERSION
294.endif	# !defined(WANT_LINKER_FREEBSD_VERSION)
295
296.if ${MK_SYSTEM_LINKER} == "yes" && \
297    defined(WANT_LINKER_FREEBSD_VERSION) && \
298    (${MK_LLD_BOOTSTRAP} == "yes") && \
299    !make(xdev*) && \
300    ${X_LINKER_TYPE} == ${WANT_LINKER_TYPE} && \
301    ${X_LINKER_VERSION} == ${WANT_LINKER_VERSION} && \
302    ${X_LINKER_FREEBSD_VERSION} == ${WANT_LINKER_FREEBSD_VERSION}
303# Everything matches, disable the bootstrap linker.
304MK_LLD_BOOTSTRAP=	no
305USING_SYSTEM_LINKER=	yes
306.endif	# ${WANT_LINKER_TYPE} == ${LINKER_TYPE}
307
308# WITH_SYSTEM_COMPILER / WITH_SYSTEM_LINKER - Handle defaults and debug.
309USING_SYSTEM_COMPILER?=	no
310USING_SYSTEM_LINKER?=	no
311
312TEST_SYSTEM_COMPILER_VARS= \
313	USING_SYSTEM_COMPILER MK_SYSTEM_COMPILER \
314	MK_CROSS_COMPILER MK_CLANG_BOOTSTRAP \
315	WANT_COMPILER_TYPE WANT_COMPILER_VERSION WANT_COMPILER_VERSION_FILE \
316	WANT_COMPILER_FREEBSD_VERSION WANT_COMPILER_FREEBSD_VERSION_FILE \
317	CC COMPILER_TYPE COMPILER_FEATURES COMPILER_VERSION \
318	COMPILER_FREEBSD_VERSION \
319	XCC X_COMPILER_TYPE X_COMPILER_FEATURES X_COMPILER_VERSION \
320	X_COMPILER_FREEBSD_VERSION
321TEST_SYSTEM_LINKER_VARS= \
322	USING_SYSTEM_LINKER MK_SYSTEM_LINKER \
323	MK_LLD_BOOTSTRAP \
324	WANT_LINKER_TYPE WANT_LINKER_VERSION WANT_LINKER_VERSION_FILE \
325	WANT_LINKER_FREEBSD_VERSION WANT_LINKER_FREEBSD_VERSION_FILE \
326	LD LINKER_TYPE LINKER_FEATURES LINKER_VERSION \
327	LINKER_FREEBSD_VERSION \
328	XLD X_LINKER_TYPE X_LINKER_FEATURES X_LINKER_VERSION \
329	X_LINKER_FREEBSD_VERSION
330
331.for _t in compiler linker
332test-system-${_t}: .PHONY
333.for v in ${TEST_SYSTEM_${_t:tu}_VARS}
334	${_+_}@printf "%-35s= %s\n" "${v}" "${${v}}"
335.endfor
336.endfor
337.if (make(buildworld) || make(buildkernel) || make(kernel-toolchain) || \
338    make(toolchain) || make(_cross-tools))
339.if ${USING_SYSTEM_COMPILER} == "yes"
340.info SYSTEM_COMPILER: Determined that CC=${CC} matches the source tree.  Not bootstrapping a cross-compiler.
341.elif ${MK_CLANG_BOOTSTRAP} == "yes"
342.info SYSTEM_COMPILER: libclang will be built for bootstrapping a cross-compiler.
343.endif
344.if ${USING_SYSTEM_LINKER} == "yes"
345.info SYSTEM_LINKER: Determined that LD=${LD} matches the source tree.  Not bootstrapping a cross-linker.
346.elif ${MK_LLD_BOOTSTRAP} == "yes"
347.info SYSTEM_LINKER: libclang will be built for bootstrapping a cross-linker.
348.endif
349.endif
350
351# End WITH_SYSTEM_COMPILER / WITH_SYSTEM_LD
352
353# Store some compiler metadata for use in installworld where we don't
354# want to invoke CC at all.
355_TOOLCHAIN_METADATA_VARS=	COMPILER_VERSION \
356				COMPILER_TYPE \
357				COMPILER_FEATURES \
358				COMPILER_FREEBSD_VERSION \
359				COMPILER_RESOURCE_DIR \
360				LINKER_VERSION \
361				LINKER_FEATURES \
362				LINKER_TYPE \
363				LINKER_FREEBSD_VERSION
364toolchain-metadata.mk: .PHONY .META
365	@: > ${.TARGET}
366	@echo ".info Using cached toolchain metadata from build at $$(hostname) on $$(date)" \
367	    > ${.TARGET}
368	@echo "_LOADED_TOOLCHAIN_METADATA=t" >> ${.TARGET}
369.for v in ${_TOOLCHAIN_METADATA_VARS}
370	@echo "${v}=${${v}}" >> ${.TARGET}
371	@echo "X_${v}=${X_${v}}" >> ${.TARGET}
372.endfor
373	@echo ".export ${_TOOLCHAIN_METADATA_VARS}" >> ${.TARGET}
374	@echo ".export ${_TOOLCHAIN_METADATA_VARS:C,^,X_,}" >> ${.TARGET}
375
376
377# We must do lib/ and libexec/ before bin/ in case of a mid-install error to
378# keep the users system reasonably usable.  For static->dynamic root upgrades,
379# we don't want to install a dynamic binary without rtld and the needed
380# libraries.  More commonly, for dynamic root, we don't want to install a
381# binary that requires a newer library version that hasn't been installed yet.
382# This ordering is not a guarantee though.  The only guarantee of a working
383# system here would require fine-grained ordering of all components based
384# on their dependencies.
385.if !empty(SUBDIR_OVERRIDE)
386SUBDIR=	${SUBDIR_OVERRIDE}
387.else
388SUBDIR=	lib libexec
389# Add LOCAL_LIB_DIRS, but only if they will not be picked up as a SUBDIR
390# of a LOCAL_DIRS directory.  This allows LOCAL_DIRS=foo and
391# LOCAL_LIB_DIRS=foo/lib to behave as expected.
392.for _DIR in ${LOCAL_DIRS:M*/} ${LOCAL_DIRS:N*/:S|$|/|}
393_REDUNDANT_LIB_DIRS+=    ${LOCAL_LIB_DIRS:M${_DIR}*}
394.endfor
395.for _DIR in ${LOCAL_LIB_DIRS}
396.if ${_DIR} == ".WAIT" || (empty(_REDUNDANT_LIB_DIRS:M${_DIR}) && exists(${.CURDIR}/${_DIR}/Makefile))
397SUBDIR+=	${_DIR}
398.endif
399.endfor
400.if !defined(NO_ROOT) && (make(installworld) || make(install))
401# Ensure libraries are installed before progressing.
402SUBDIR+=.WAIT
403.endif
404SUBDIR+=bin
405.if ${MK_CDDL} != "no"
406SUBDIR+=cddl
407.endif
408SUBDIR+=gnu include
409.if ${MK_KERBEROS} != "no"
410SUBDIR+=kerberos5
411.endif
412.if ${MK_RESCUE} != "no"
413SUBDIR+=rescue
414.endif
415SUBDIR+=sbin
416.if ${MK_CRYPT} != "no"
417SUBDIR+=secure
418.endif
419.if !defined(NO_SHARE)
420SUBDIR+=share
421.endif
422.if ${MK_BOOT} != "no"
423SUBDIR+=stand
424.endif
425SUBDIR+=sys usr.bin usr.sbin
426.if ${MK_TESTS} != "no"
427SUBDIR+=	tests
428.endif
429
430# Local directories are built in parallel with the base system directories.
431# Users may insert a .WAIT directive at the beginning or elsewhere within
432# the LOCAL_DIRS and LOCAL_LIB_DIRS lists as needed.
433.for _DIR in ${LOCAL_DIRS}
434.if ${_DIR} == ".WAIT" || exists(${.CURDIR}/${_DIR}/Makefile)
435SUBDIR+=	${_DIR}
436.endif
437.endfor
438
439# We must do etc/ last as it hooks into building the man whatis file
440# by calling 'makedb' in share/man.  This is only relevant for
441# install/distribute so they build the whatis file after every manpage is
442# installed.
443.if make(installworld) || make(install)
444SUBDIR+=.WAIT
445.endif
446SUBDIR+=etc
447
448.endif	# !empty(SUBDIR_OVERRIDE)
449
450.if defined(NOCLEAN)
451.warning The src.conf WITHOUT_CLEAN option can now be used instead of NOCLEAN.
452MK_CLEAN:=	no
453.endif
454.if defined(NO_CLEAN)
455.info The src.conf WITHOUT_CLEAN option can now be used instead of NO_CLEAN.
456MK_CLEAN:=	no
457.endif
458.if defined(NO_CLEANDIR)
459CLEANDIR=	clean cleandepend
460.else
461CLEANDIR=	cleandir
462.endif
463
464.if defined(WORLDFAST)
465MK_CLEAN:=	no
466NO_OBJWALK=	t
467.endif
468
469.if ${MK_META_MODE} == "yes"
470# If filemon is used then we can rely on the build being incremental-safe.
471# The .meta files will also track the build command and rebuild should
472# it change.
473.if empty(.MAKE.MODE:Mnofilemon)
474MK_CLEAN:=	no
475.endif
476.endif
477.if defined(NO_OBJWALK) || ${MK_AUTO_OBJ} == "yes"
478NO_OBJWALK=	t
479NO_KERNELOBJ=	t
480.endif
481.if !defined(NO_OBJWALK)
482_obj=		obj
483.endif
484
485LOCAL_TOOL_DIRS?=
486PACKAGEDIR?=	${DESTDIR}/${DISTDIR}
487
488.if empty(SHELL:M*csh*)
489BUILDENV_SHELL?=${SHELL}
490.else
491BUILDENV_SHELL?=/bin/sh
492.endif
493
494.if !defined(_MKSHOWCONFIG)
495.if !defined(VCS_REVISION) || empty(VCS_REVISION)
496.if !defined(SVNVERSION_CMD) || empty(SVNVERSION_CMD)
497. for _D in ${PATH:S,:, ,g}
498.  if exists(${_D}/svnversion)
499SVNVERSION_CMD?=${_D}/svnversion
500.  endif
501.  if exists(${_D}/svnliteversion)
502SVNVERSION_CMD?=${_D}/svnliteversion
503.  endif
504. endfor
505.endif
506_VCS_REVISION?=	$$(eval ${SVNVERSION_CMD} ${SRCDIR})
507. if !empty(_VCS_REVISION)
508VCS_REVISION=	$$(echo r${_VCS_REVISION})
509. endif
510.export VCS_REVISION
511.endif
512
513.if !defined(GIT_CMD) || empty(GIT_CMD)
514. for _P in /usr/bin /usr/local/bin
515.  if exists(${_P}/git)
516GIT_CMD=   ${_P}/git
517.  endif
518. endfor
519.export GIT_CMD
520.endif
521
522.if !defined(OSRELDATE)
523.if exists(/usr/include/osreldate.h)
524OSRELDATE!=	awk '/^\#define[[:space:]]*__FreeBSD_version/ { print $$3 }' \
525		/usr/include/osreldate.h
526.else
527OSRELDATE=	0
528.endif
529.export OSRELDATE
530.endif
531
532# Set VERSION for CTFMERGE to use via the default CTFFLAGS=-L VERSION.
533.for _V in BRANCH REVISION
534.if !defined(_${_V})
535_${_V}!=	eval $$(awk '/^${_V}=/{print}' ${SRCTOP}/sys/conf/newvers.sh); echo $$${_V}
536.export _${_V}
537.endif
538.endfor
539.if !defined(SRCRELDATE)
540SRCRELDATE!=	awk '/^\#define[[:space:]]*__FreeBSD_version/ { print $$3 }' \
541		${SRCDIR}/sys/sys/param.h
542.export SRCRELDATE
543.endif
544.if !defined(VERSION)
545VERSION=	FreeBSD ${_REVISION}-${_BRANCH:C/-p[0-9]+$//} ${TARGET_ARCH} ${SRCRELDATE}
546.export VERSION
547.endif
548
549.if !defined(PKG_VERSION)
550_STRTIMENOW=	%Y%m%d%H%M%S
551_TIMENOW=	${_STRTIMENOW:gmtime}
552.if ${_BRANCH:MCURRENT*} || ${_BRANCH:MSTABLE*} || ${_BRANCH:MPRERELEASE*}
553_REVISION:=	${_REVISION:R}
554EXTRA_REVISION=	.snap${_TIMENOW}
555.elif ${_BRANCH:MALPHA*}
556EXTRA_REVISION=	.a${_BRANCH:C/ALPHA([0-9]+).*/\1/}.${_TIMENOW}
557.elif ${_BRANCH:MBETA*}
558EXTRA_REVISION=	.b${_BRANCH:C/BETA([0-9]+).*/\1/}.${_TIMENOW}
559.elif ${_BRANCH:MRC*}
560EXTRA_REVISION=	.rc${_BRANCH:C/RC([0-9]+).*/\1/}.${_TIMENOW}
561.elif ${_BRANCH:M*-p*}
562EXTRA_REVISION=	p${_BRANCH:C/.*-p([0-9]+$)/\1/}
563.endif
564PKG_VERSION:=	${_REVISION}${EXTRA_REVISION:C/[[:space:]]//g}
565.endif
566.endif	# !defined(PKG_VERSION)
567
568.if !defined(PKG_TIMESTAMP)
569TIMEEPOCHNOW=		%s
570SOURCE_DATE_EPOCH=	${TIMEEPOCHNOW:gmtime}
571.else
572SOURCE_DATE_EPOCH=	${PKG_TIMESTAMP}
573.endif
574
575PKG_NAME_PREFIX?=	FreeBSD
576PKG_MAINTAINER?=	re@FreeBSD.org
577PKG_WWW?=		https://www.FreeBSD.org
578.export PKG_NAME_PREFIX
579.export PKG_MAINTAINER
580.export PKG_WWW
581
582.if !defined(_MKSHOWCONFIG)
583_CPUTYPE!=	MAKEFLAGS= CPUTYPE=${_TARGET_CPUTYPE} ${MAKE} -f /dev/null \
584		-m ${.CURDIR}/share/mk MK_AUTO_OBJ=no -V CPUTYPE
585.if ${_CPUTYPE} != ${_TARGET_CPUTYPE}
586.error CPUTYPE global should be set with ?=.
587.endif
588.endif
589.if make(buildworld)
590BUILD_ARCH!=	uname -p
591# On some Linux systems uname -p returns "unknown" so skip this check there.
592# This check only exists to tell people to use TARGET_ARCH instead of
593# MACHINE_ARCH so skipping it when crossbuilding on non-FreeBSD should be fine.
594.if ${MACHINE_ARCH} != ${BUILD_ARCH} && ${.MAKE.OS} == "FreeBSD"
595.error To cross-build, set TARGET_ARCH.
596.endif
597.endif
598WORLDTMP?=	${OBJTOP}/tmp
599BPATH=		${CCACHE_WRAPPER_PATH_PFX}${WORLDTMP}/legacy/usr/sbin:${WORLDTMP}/legacy/usr/bin:${WORLDTMP}/legacy/bin:${WORLDTMP}/legacy/usr/libexec
600XPATH=		${WORLDTMP}/bin:${WORLDTMP}/usr/sbin:${WORLDTMP}/usr/bin
601
602# When building we want to find the cross tools before the host tools in ${BPATH}.
603# We also need to add UNIVERSE_TOOLCHAIN_PATH so that we can find the shared
604# toolchain files (clang, lld, etc.) during make universe/tinderbox
605STRICTTMPPATH=	${XPATH}:${BPATH}:${UNIVERSE_TOOLCHAIN_PATH}
606# We should not be using tools from /usr/bin accidentally since this could cause
607# the build to break on other systems that don't have that tool. For now we
608# still allow using the old behaviour (inheriting $PATH) if
609# BUILD_WITH_STRICT_TMPPATH is set to 0 but this will eventually be removed.
610
611# Currently strict $PATH can cause build failures and does not work yet with
612# USING_SYSTEM_LINKER/USING_SYSTEM_COMPILER. Once these issues have been
613# resolved it will be turned on by default.
614BUILD_WITH_STRICT_TMPPATH?=0
615.if defined(CROSSBUILD_HOST)
616# When building on non-FreeBSD we can't rely on the tools in /usr/bin being compatible
617# with what FreeBSD expects. Therefore we only use tools from STRICTTMPPATH
618# during the world build stage. We build most tools during the bootstrap-tools
619# phase but symlink host tools that are known to work instead of building them
620BUILD_WITH_STRICT_TMPPATH:=1
621.endif
622.if ${BUILD_WITH_STRICT_TMPPATH} != 0
623TMPPATH=	${STRICTTMPPATH}
624.else
625TMPPATH=	${STRICTTMPPATH}:${PATH}
626.endif
627
628#
629# Avoid running mktemp(1) unless actually needed.
630# It may not be functional, e.g., due to new ABI
631# when in the middle of installing over this system.
632#
633.if make(distributeworld) || make(installworld) || make(stageworld)
634.if ${BUILD_WITH_STRICT_TMPPATH} != 0
635MKTEMP=${WORLDTMP}/legacy/usr/bin/mktemp
636.if !exists(${MKTEMP})
637.error "mktemp binary doesn't exist in expected location: ${MKTEMP}"
638.endif
639.else
640MKTEMP=mktemp
641.endif
642INSTALLTMP!=	${MKTEMP} -d -u -t install
643.endif
644
645.if make(stagekernel) || make(distributekernel)
646TAGS+=		kernel
647PACKAGE=	kernel
648.endif
649
650#
651# Building a world goes through the following stages
652#
653# 1. legacy stage [BMAKE]
654#	This stage is responsible for creating compatibility
655#	shims that are needed by the bootstrap-tools,
656#	build-tools and cross-tools stages. These are generally
657#	APIs that tools from one of those three stages need to
658#	build that aren't present on the host.
659# 1. bootstrap-tools stage [BMAKE]
660#	This stage is responsible for creating programs that
661#	are needed for backward compatibility reasons. They
662#	are not built as cross-tools.
663# 2. build-tools stage [TMAKE]
664#	This stage is responsible for creating the object
665#	tree and building any tools that are needed during
666#	the build process. Some programs are listed during
667#	this phase because they build binaries to generate
668#	files needed to build these programs. This stage also
669#	builds the 'build-tools' target rather than 'all'.
670# 3. cross-tools stage [XMAKE]
671#	This stage is responsible for creating any tools that
672#	are needed for building the system. A cross-compiler is one
673#	of them. This differs from build tools in two ways:
674#	1. the 'all' target is built rather than 'build-tools'
675#	2. these tools are installed into TMPPATH for stage 4.
676# 4. world stage [WMAKE]
677#	This stage actually builds the world.
678# 5. install stage (optional) [IMAKE]
679#	This stage installs a previously built world.
680#
681
682BOOTSTRAPPING?=	0
683# Keep these in sync
684MINIMUM_SUPPORTED_OSREL?= 1002501
685MINIMUM_SUPPORTED_REL?= 10.3
686
687# Common environment for world related stages
688CROSSENV+=	\
689		MACHINE_ARCH=${TARGET_ARCH} \
690		MACHINE=${TARGET} \
691		CPUTYPE=${TARGET_CPUTYPE}
692.if ${MK_META_MODE} != "no"
693# Don't rebuild build-tools targets during normal build.
694CROSSENV+=	BUILD_TOOLS_META=.NOMETA
695.endif
696.if defined(TARGET_CFLAGS)
697CROSSENV+=	${TARGET_CFLAGS}
698.endif
699.if (${TARGET} != ${MACHINE} && !defined(WITH_LOCAL_MODULES)) || \
700    defined(WITHOUT_LOCAL_MODULES)
701CROSSENV+=	LOCAL_MODULES=
702.endif
703
704BOOTSTRAPPING_OSRELDATE?=${OSRELDATE}
705
706# bootstrap-tools stage
707BMAKEENV=	INSTALL="sh ${.CURDIR}/tools/install.sh" \
708		TOOLS_PREFIX=${TOOLS_PREFIX_UNDEF:U${WORLDTMP}} \
709		PATH=${BPATH}:${PATH} \
710		WORLDTMP=${WORLDTMP} \
711		MAKEFLAGS="-m ${.CURDIR}/tools/build/mk ${.MAKEFLAGS}"
712# need to keep this in sync with targets/pseudo/bootstrap-tools/Makefile
713BSARGS= 	DESTDIR= \
714		OBJTOP='${WORLDTMP}/obj-tools' \
715		OBJROOT='$${OBJTOP}/' \
716		MAKEOBJDIRPREFIX= \
717		BOOTSTRAPPING=${BOOTSTRAPPING_OSRELDATE} \
718		BWPHASE=${.TARGET:C,^_,,} \
719		-DNO_CPU_CFLAGS \
720		-DNO_LINT \
721		-DNO_PIC \
722		-DNO_SHARED \
723		MK_ASAN=no \
724		MK_CTF=no \
725		MK_CLANG_EXTRAS=no \
726		MK_CLANG_FORMAT=no \
727		MK_CLANG_FULL=no \
728		MK_HTML=no \
729		MK_MAN=no \
730		MK_PROFILE=no \
731		MK_RETPOLINE=no \
732		MK_SSP=no \
733		MK_TESTS=no \
734		MK_UBSAN=no \
735		MK_WERROR=no \
736		MK_INCLUDES=yes \
737		MK_MAN_UTILS=yes
738
739BMAKE=		\
740		${TIME_ENV} ${BMAKEENV} ${MAKE} ${WORLD_FLAGS} -f Makefile.inc1 \
741		${BSARGS}
742.if empty(.MAKEOVERRIDES:MMK_LLVM_TARGET_ALL)
743BMAKE+=		MK_LLVM_TARGET_ALL=no
744.endif
745
746# build-tools stage
747TMAKE=		\
748		${TIME_ENV} ${BMAKEENV} ${MAKE} ${WORLD_FLAGS} -f Makefile.inc1 \
749		TARGET=${TARGET} TARGET_ARCH=${TARGET_ARCH} \
750		DESTDIR= \
751		BOOTSTRAPPING=${BOOTSTRAPPING_OSRELDATE} \
752		BWPHASE=${.TARGET:C,^_,,} \
753		-DNO_CPU_CFLAGS \
754		-DNO_LINT \
755		MK_ASAN=no \
756		MK_CTF=no \
757		MK_CLANG_EXTRAS=no \
758		MK_CLANG_FORMAT=no \
759		MK_CLANG_FULL=no \
760		MK_LLDB=no \
761		MK_RETPOLINE=no \
762		MK_SSP=no \
763		MK_TESTS=no \
764		MK_UBSAN=no \
765		MK_WERROR=no
766
767# cross-tools stage
768# TOOLS_PREFIX set in BMAKE
769XMAKE=		${BMAKE} \
770		TARGET=${TARGET} TARGET_ARCH=${TARGET_ARCH} \
771		MK_CLANG_IS_CC=${MK_CLANG_BOOTSTRAP} \
772		MK_LLDB=no \
773		MK_LLVM_BINUTILS=no \
774		MK_TESTS=no
775
776# kernel-tools stage
777KTMAKEENV=	INSTALL="sh ${.CURDIR}/tools/install.sh" \
778		PATH=${BPATH}:${PATH} \
779		WORLDTMP=${WORLDTMP} \
780		MAKEFLAGS="-m ${.CURDIR}/tools/build/mk ${.MAKEFLAGS}"
781
782KTMAKE=		${TIME_ENV} \
783		TOOLS_PREFIX=${TOOLS_PREFIX_UNDEF:U${WORLDTMP}} \
784		${KTMAKEENV} ${MAKE} ${WORLD_FLAGS} -f Makefile.inc1 \
785		DESTDIR= \
786		OBJTOP='${WORLDTMP}/obj-kernel-tools' \
787		OBJROOT='$${OBJTOP}/' \
788		MAKEOBJDIRPREFIX= \
789		BOOTSTRAPPING=${BOOTSTRAPPING_OSRELDATE} \
790		-DNO_CPU_CFLAGS \
791		-DNO_LINT \
792		-DNO_PIC \
793		-DNO_SHARED \
794		MK_CTF=no \
795		MK_HTML=no \
796		MK_MAN=no \
797		MK_PROFILE=no \
798		MK_SSP=no \
799		MK_RETPOLINE=no \
800		MK_WERROR=no
801
802# world stage
803WMAKEENV=	${CROSSENV} \
804		INSTALL="${INSTALL_CMD} -U" \
805		PATH=${TMPPATH} \
806		SYSROOT=${WORLDTMP}
807
808# make hierarchy
809HMAKE=		PATH=${TMPPATH} ${MAKE} LOCAL_MTREE=${LOCAL_MTREE:Q}
810.if defined(NO_ROOT)
811HMAKE+=		PATH=${TMPPATH} METALOG=${METALOG} -DNO_ROOT
812.endif
813
814CROSSENV+=	CC="${XCC} ${XCFLAGS}" CXX="${XCXX} ${XCXXFLAGS} ${XCFLAGS}" \
815		CPP="${XCPP} ${XCFLAGS}" \
816		AS="${XAS}" AR="${XAR}" ELFCTL="${XELFCTL}" LD="${XLD}" \
817		LLVM_LINK="${XLLVM_LINK}" NM=${XNM} OBJCOPY="${XOBJCOPY}" \
818		RANLIB=${XRANLIB} STRINGS=${XSTRINGS} \
819		SIZE="${XSIZE}" STRIPBIN="${XSTRIPBIN}"
820
821.if defined(CROSS_BINUTILS_PREFIX) && exists(${CROSS_BINUTILS_PREFIX})
822# In the case of xdev-build tools, CROSS_BINUTILS_PREFIX won't be a
823# directory, but the compiler will look in the right place for its
824# tools so we don't need to tell it where to look.
825BFLAGS+=	-B${CROSS_BINUTILS_PREFIX}
826.endif
827
828
829# The internal bootstrap compiler has a default sysroot set by TOOLS_PREFIX
830# and target set by TARGET/TARGET_ARCH.  However, there are several needs to
831# always pass an explicit --sysroot and -target.
832# - External compiler needs sysroot and target flags.
833# - External ld needs sysroot.
834# - To be clear about the use of a sysroot when using the internal compiler.
835# - Easier debugging.
836# - Allowing WITH_SYSTEM_COMPILER+WITH_META_MODE to work together due to
837#   the flip-flopping build command when sometimes using external and
838#   sometimes using internal.
839# - Allow using lld which has no support for default paths.
840.if !defined(CROSS_BINUTILS_PREFIX) || !exists(${CROSS_BINUTILS_PREFIX})
841BFLAGS+=	-B${WORLDTMP}/usr/bin
842.endif
843.if ${WANT_COMPILER_TYPE} == gcc || \
844    (defined(X_COMPILER_TYPE) && ${X_COMPILER_TYPE} == gcc)
845.elif ${WANT_COMPILER_TYPE} == clang || \
846    (defined(X_COMPILER_TYPE) && ${X_COMPILER_TYPE} == clang)
847XCFLAGS+=	-target ${TARGET_TRIPLE}
848.endif
849XCFLAGS+=	--sysroot=${WORLDTMP}
850
851.if !empty(BFLAGS)
852XCFLAGS+=	${BFLAGS}
853.endif
854
855.if ${MK_LIB32} == "yes"
856_LIBCOMPAT= 32
857.include "Makefile.libcompat"
858.elif ${MK_LIBSOFT} == "yes"
859_LIBCOMPAT= SOFT
860.include "Makefile.libcompat"
861.endif
862
863# META_MODE normally ignores host file changes since every build updates
864# timestamps (see NO_META_IGNORE_HOST in sys.mk).  There are known times
865# when the ABI breaks though that we want to force rebuilding WORLDTMP
866# to get updated host tools.
867.if ${MK_META_MODE} == "yes" && ${MK_CLEAN} == "no" && \
868    !defined(NO_META_IGNORE_HOST) && !defined(NO_META_IGNORE_HOST_HEADERS) && \
869    !defined(_MKSHOWCONFIG)
870# r318736 - ino64 major ABI breakage
871META_MODE_BAD_ABI_VERS+=	1200031
872
873.if !defined(OBJDIR_HOST_OSRELDATE)
874.if exists(${OBJTOP}/host-osreldate.h)
875OBJDIR_HOST_OSRELDATE!=	\
876    awk '/^\#define[[:space:]]*__FreeBSD_version/ { print $$3 }' \
877    ${OBJTOP}/host-osreldate.h
878.elif exists(${WORLDTMP}/usr/include/osreldate.h)
879OBJDIR_HOST_OSRELDATE=	0
880.endif
881.export OBJDIR_HOST_OSRELDATE
882.endif
883
884# Note that this logic is the opposite of normal BOOTSTRAP handling.  We want
885# to compare the WORLDTMP's OSRELDATE to the host's OSRELDATE.  If the WORLDTMP
886# is older than the ABI-breakage OSRELDATE of the HOST then we rebuild.
887.if defined(OBJDIR_HOST_OSRELDATE)
888.for _ver in ${META_MODE_BAD_ABI_VERS}
889.if ${OSRELDATE} >= ${_ver} && ${OBJDIR_HOST_OSRELDATE} < ${_ver}
890_meta_mode_need_rebuild=	${_ver}
891.endif
892.endfor
893.if defined(_meta_mode_need_rebuild)
894.info META_MODE: Rebuilding host tools due to ABI breakage in __FreeBSD_version ${_meta_mode_need_rebuild}.
895NO_META_IGNORE_HOST_HEADERS=	1
896.export NO_META_IGNORE_HOST_HEADERS
897.endif	# defined(_meta_mode_need_rebuild)
898.endif	# defined(OBJDIR_HOST_OSRELDATE)
899.endif	# ${MK_META_MODE} == "yes" && ${MK_CLEAN} == "no" ...
900# This is only used for META_MODE+filemon to track what the oldest
901# __FreeBSD_version is in WORLDTMP.  This purposely does NOT have
902# a make dependency on /usr/include/osreldate.h as the file should
903# only be copied when it is missing or meta mode determines it has changed.
904# Since host files are normally ignored without NO_META_IGNORE_HOST
905# the file will never be updated unless that flag is specified.  This
906# allows tracking the oldest osreldate to force rebuilds via
907# META_MODE_BADABI_REVS above.
908host-osreldate.h: # DO NOT ADD /usr/include/osreldate.h here
909.if !defined(CROSSBUILD_HOST)
910	@cp -f /usr/include/osreldate.h ${.TARGET}
911.else
912	@echo "#ifndef __FreeBSD_version" > ${.TARGET}
913	@echo "#define __FreeBSD_version ${OSRELDATE}" >> ${.TARGET}
914	@echo "#endif" >> ${.TARGET}
915.endif
916
917WMAKE=		${TIME_ENV} ${WMAKEENV} ${MAKE} ${WORLD_FLAGS} -f Makefile.inc1 \
918		BWPHASE=${.TARGET:C,^_,,} \
919		DESTDIR=${WORLDTMP}
920
921IMAKEENV=	${CROSSENV}
922IMAKE=		${TIME_ENV} ${IMAKEENV} ${MAKE} -f Makefile.inc1 \
923		${IMAKE_INSTALL} ${IMAKE_MTREE}
924.if empty(.MAKEFLAGS:M-n)
925IMAKEENV+=	PATH=${STRICTTMPPATH}:${INSTALLTMP} \
926		LD_LIBRARY_PATH=${INSTALLTMP} \
927		PATH_LOCALE=${INSTALLTMP}/locale
928IMAKE+=		__MAKE_SHELL=${INSTALLTMP}/sh
929.else
930IMAKEENV+=	PATH=${TMPPATH}:${INSTALLTMP}
931.endif
932
933# When generating install media, do not allow user and group information from
934# the build host to affect the contents of the distribution.
935.if make(distributeworld) || make(distrib-dirs) || make(distribution) || \
936    make(stageworld)
937DB_FROM_SRC=	yes
938.endif
939
940.if defined(DB_FROM_SRC)
941INSTALLFLAGS+=	-N ${.CURDIR}/etc
942MTREEFLAGS+=	-N ${.CURDIR}/etc
943.endif
944_INSTALL_DDIR=	${DESTDIR}/${DISTDIR}
945INSTALL_DDIR=	${_INSTALL_DDIR:S://:/:g:C:/$::}
946.if defined(NO_ROOT)
947METALOG?=	${DESTDIR}/${DISTDIR}/METALOG
948METALOG:=	${METALOG:C,//+,/,g}
949IMAKE+=		-DNO_ROOT METALOG=${METALOG}
950METALOG_INSTALLFLAGS=	-U -M ${METALOG} -D ${INSTALL_DDIR}
951INSTALLFLAGS+=	${METALOG_INSTALLFLAGS}
952CERTCTLFLAGS=	${METALOG_INSTALLFLAGS}
953MTREEFLAGS+=	-W
954.endif
955.if defined(BUILD_PKGS)
956INSTALLFLAGS+=	-h sha256
957.endif
958.if defined(DB_FROM_SRC) || defined(NO_ROOT)
959IMAKE_INSTALL=	INSTALL="${INSTALL_CMD} ${INSTALLFLAGS}"
960IMAKE_MTREE=	MTREE_CMD="${MTREE_CMD} ${MTREEFLAGS}"
961.endif
962.if make(distributeworld)
963CERTCTLDESTDIR=	${DESTDIR}/${DISTDIR}/base
964.else
965CERTCTLDESTDIR=	${DESTDIR}
966.endif
967
968DESTDIR_MTREEFLAGS=	-deU
969# When creating worldtmp we don't need to set the directories as owned by root
970# so we also pass -W
971WORLDTMP_MTREEFLAGS=	-deUW
972.if defined(NO_ROOT)
973# When building with -DNO_ROOT we shouldn't be changing the directories
974# that are created by mtree to be owned by root/wheel.
975DESTDIR_MTREEFLAGS+=	-W
976.endif
977DISTR_MTREE=	${MTREE_CMD}
978.if ${BUILD_WITH_STRICT_TMPPATH} != 0
979DISTR_MTREE=	${WORLDTMP}/legacy/usr/sbin/mtree
980.endif
981WORLDTMP_MTREE=	${DISTR_MTREE} ${WORLDTMP_MTREEFLAGS}
982DESTDIR_MTREE=	${DISTR_MTREE} ${DESTDIR_MTREEFLAGS}
983
984# kernel stage
985KMAKEENV=	${WMAKEENV:NSYSROOT=*}
986KMAKE=		${TIME_ENV} ${KMAKEENV} ${MAKE} ${.MAKEFLAGS} ${KERNEL_FLAGS} KERNEL=${INSTKERNNAME}
987
988#
989# buildworld
990#
991# Attempt to rebuild the entire system, with reasonable chance of
992# success, regardless of how old your existing system is.
993#
994_sanity_check: .PHONY .MAKE
995.if ${.CURDIR:C/[^,]//g} != ""
996#	The m4 build of sendmail files doesn't like it if ',' is used
997#	anywhere in the path of it's files.
998	@echo
999	@echo "*** Error: path to source tree contains a comma ','"
1000	@echo
1001	@false
1002.elif ${.CURDIR:M*\:*} != ""
1003#	Using ':' leaks into PATH and breaks finding cross-tools.
1004	@echo
1005	@echo "*** Error: path to source tree contains a colon ':'"
1006	@echo
1007	@false
1008.endif
1009
1010# Our current approach to dependency tracking cannot cope with certain source
1011# tree changes, particularly with respect to removing source files and
1012# replacing generated files.  Handle these cases here in an ad-hoc fashion.
1013_cleanobj_fast_depend_hack: .PHONY
1014	@echo ">>> Deleting stale dependencies...";
1015	sh ${.CURDIR}/tools/build/depend-cleanup.sh ${OBJTOP}
1016
1017_worldtmp: .PHONY
1018	@echo
1019	@echo "--------------------------------------------------------------"
1020	@echo ">>> Rebuilding the temporary build tree"
1021	@echo "--------------------------------------------------------------"
1022.if ${MK_CLEAN} == "yes"
1023	rm -rf ${WORLDTMP}
1024.else
1025# Note: for delete-old we need to set $PATH to also include the host $PATH
1026# since otherwise a partial build with missing symlinks in ${WORLDTMP}/legacy/
1027# will fail to run due to missing binaries. $WMAKE sets PATH to only ${TMPPATH}
1028# so we remove that assingnment from $WMAKE and prepend the new $PATH
1029	${_+_}@if [ -e "${WORLDTMP}" ]; then \
1030		echo ">>> Deleting stale files in build tree..."; \
1031		cd ${.CURDIR}; env PATH=${TMPPATH}:${PATH} ${WMAKE:NPATH=*} \
1032		    _NO_INCLUDE_COMPILERMK=t -DBATCH_DELETE_OLD_FILES delete-old \
1033		    delete-old-libs >/dev/null; \
1034	fi
1035	rm -rf ${WORLDTMP}/legacy/usr/include
1036.if ${USING_SYSTEM_COMPILER} == "yes"
1037.for cc in cc c++
1038	if [ -x ${WORLDTMP}/usr/bin/${cc} ]; then \
1039		inum=$$(stat -f %i ${WORLDTMP}/usr/bin/${cc}); \
1040		find ${WORLDTMP}/usr/bin -inum $${inum} -delete; \
1041	fi
1042.endfor
1043.endif	# ${USING_SYSTEM_COMPILER} == "yes"
1044.if ${USING_SYSTEM_LINKER} == "yes"
1045	@rm -f ${WORLDTMP}/usr/bin/ld ${WORLDTMP}/usr/bin/ld.lld
1046.endif	# ${USING_SYSTEM_LINKER} == "yes"
1047.endif	# ${MK_CLEAN} == "yes"
1048	@mkdir -p ${WORLDTMP}
1049	@touch ${WORLDTMP}/${.TARGET}
1050# We can't use mtree to create the worldtmp directories since it may not be
1051# available on the target system (this happens e.g. when building on non-FreeBSD)
1052	${_+_}cd ${.CURDIR}/tools/build; \
1053	    ${MAKE} DIRPRFX=tools/build/ DESTDIR=${WORLDTMP}/legacy installdirs
1054# In order to build without inheriting $PATH we need to add symlinks to the host
1055# tools in $WORLDTMP for the tools that we don't build during bootstrap-tools
1056	${_+_}cd ${.CURDIR}/tools/build; \
1057	    ${MAKE} DIRPRFX=tools/build/ DESTDIR=${WORLDTMP}/legacy host-symlinks
1058
1059_legacy:
1060	@echo
1061	@echo "--------------------------------------------------------------"
1062	@echo ">>> stage 1.1: legacy release compatibility shims"
1063	@echo "--------------------------------------------------------------"
1064	${_+_}cd ${.CURDIR}; ${BMAKE} legacy
1065_bootstrap-tools:
1066	@echo
1067	@echo "--------------------------------------------------------------"
1068	@echo ">>> stage 1.2: bootstrap tools"
1069	@echo "--------------------------------------------------------------"
1070	${_+_}cd ${.CURDIR}; ${BMAKE} bootstrap-tools
1071	mkdir -p ${WORLDTMP}/usr ${WORLDTMP}/lib/casper ${WORLDTMP}/lib/geom \
1072	    ${WORLDTMP}/bin
1073	${WORLDTMP_MTREE} -f ${.CURDIR}/etc/mtree/BSD.usr.dist \
1074	    -p ${WORLDTMP}/usr >/dev/null
1075	${WORLDTMP_MTREE} -f ${.CURDIR}/etc/mtree/BSD.include.dist \
1076	    -p ${WORLDTMP}/usr/include >/dev/null
1077	ln -sf ${.CURDIR}/sys ${WORLDTMP}
1078.if ${MK_DEBUG_FILES} != "no"
1079	${WORLDTMP_MTREE} -f ${.CURDIR}/etc/mtree/BSD.debug.dist \
1080	    -p ${WORLDTMP}/usr/lib >/dev/null
1081.endif
1082.for _mtree in ${LOCAL_MTREE}
1083	${WORLDTMP_MTREE} -f ${.CURDIR}/${_mtree} -p ${WORLDTMP} > /dev/null
1084.endfor
1085_cleanobj:
1086.if ${MK_CLEAN} == "yes"
1087	@echo
1088	@echo "--------------------------------------------------------------"
1089	@echo ">>> stage 2.1: cleaning up the object tree"
1090	@echo "--------------------------------------------------------------"
1091	# Avoid including bsd.compiler.mk in clean and obj with _NO_INCLUDE_COMPILERMK
1092	# since the restricted $PATH might not contain a valid cc binary
1093	${_+_}cd ${.CURDIR}; ${WMAKE} _NO_INCLUDE_COMPILERMK=t ${CLEANDIR}
1094.if defined(_LIBCOMPAT)
1095	${_+_}cd ${.CURDIR}; ${LIBCOMPATWMAKE} _NO_INCLUDE_COMPILERMK=t -f Makefile.inc1 ${CLEANDIR}
1096.endif
1097.else
1098	${_+_}cd ${.CURDIR}; ${WMAKE} _NO_INCLUDE_COMPILERMK=t _cleanobj_fast_depend_hack
1099.endif	# ${MK_CLEAN} == "yes"
1100_obj:
1101	@echo
1102	@echo "--------------------------------------------------------------"
1103	@echo ">>> stage 2.2: rebuilding the object tree"
1104	@echo "--------------------------------------------------------------"
1105	${_+_}cd ${.CURDIR}; ${WMAKE} _NO_INCLUDE_COMPILERMK=t obj
1106_build-tools:
1107	@echo
1108	@echo "--------------------------------------------------------------"
1109	@echo ">>> stage 2.3: build tools"
1110	@echo "--------------------------------------------------------------"
1111	${_+_}cd ${.CURDIR}; ${TMAKE} build-tools
1112_cross-tools:
1113	@echo
1114	@echo "--------------------------------------------------------------"
1115	@echo ">>> stage 3: cross tools"
1116	@echo "--------------------------------------------------------------"
1117	@rm -f ${OBJTOP}/toolchain-metadata.mk
1118	${_+_}cd ${.CURDIR}; ${XMAKE} cross-tools
1119	${_+_}cd ${.CURDIR}; ${XMAKE} kernel-tools
1120_build-metadata:
1121	@echo
1122	@echo "--------------------------------------------------------------"
1123	@echo ">>> stage 3.1: recording build metadata"
1124	@echo "--------------------------------------------------------------"
1125	${_+_}cd ${.CURDIR}; ${WMAKE} toolchain-metadata.mk
1126	${_+_}cd ${.CURDIR}; ${WMAKE} host-osreldate.h
1127_includes:
1128	@echo
1129	@echo "--------------------------------------------------------------"
1130	@echo ">>> stage 4.1: building includes"
1131	@echo "--------------------------------------------------------------"
1132# Special handling for SUBDIR_OVERRIDE in buildworld as they most likely need
1133# headers from default SUBDIR.  Do SUBDIR_OVERRIDE includes last.
1134	${_+_}cd ${.CURDIR}; ${WMAKE} SUBDIR_OVERRIDE= SHARED=symlinks \
1135	    MK_INCLUDES=yes includes
1136.if !empty(SUBDIR_OVERRIDE) && make(buildworld)
1137	${_+_}cd ${.CURDIR}; ${WMAKE} MK_INCLUDES=yes SHARED=symlinks includes
1138.endif
1139_libraries:
1140	@echo
1141	@echo "--------------------------------------------------------------"
1142	@echo ">>> stage 4.2: building libraries"
1143	@echo "--------------------------------------------------------------"
1144	${_+_}cd ${.CURDIR}; \
1145	    ${WMAKE} -DNO_FSCHG MK_HTML=no -DNO_LINT MK_MAN=no \
1146	    MK_PROFILE=no MK_TESTS=no MK_TESTS_SUPPORT=${MK_TESTS_SUPPORT} \
1147	    libraries
1148everything: .PHONY
1149	@echo
1150	@echo "--------------------------------------------------------------"
1151	@echo ">>> stage 4.4: building everything"
1152	@echo "--------------------------------------------------------------"
1153	${_+_}cd ${.CURDIR}; _PARALLEL_SUBDIR_OK=1 ${WMAKE} all
1154
1155WMAKE_TGTS=
1156.if !defined(WORLDFAST)
1157WMAKE_TGTS+=	_sanity_check _worldtmp _legacy
1158.if empty(SUBDIR_OVERRIDE)
1159WMAKE_TGTS+=	_bootstrap-tools
1160.endif
1161WMAKE_TGTS+=	_cleanobj
1162.if !defined(NO_OBJWALK)
1163WMAKE_TGTS+=	_obj
1164.endif
1165WMAKE_TGTS+=	_build-tools _cross-tools
1166WMAKE_TGTS+=	_build-metadata
1167WMAKE_TGTS+=	_includes
1168.endif
1169.if !defined(NO_LIBS)
1170WMAKE_TGTS+=	_libraries
1171.endif
1172.if defined(_LIBCOMPAT) && empty(SUBDIR_OVERRIDE)
1173WMAKE_TGTS+=	build${libcompat}
1174.endif
1175WMAKE_TGTS+=	everything
1176
1177# record buildworld time in seconds
1178.if make(buildworld)
1179_BUILDWORLD_START!= date '+%s'
1180.export _BUILDWORLD_START
1181.endif
1182
1183buildworld: buildworld_prologue ${WMAKE_TGTS} buildworld_epilogue .PHONY
1184.ORDER: buildworld_prologue ${WMAKE_TGTS} buildworld_epilogue
1185
1186_ncpu_cmd=sysctl -n hw.ncpu 2>/dev/null || nproc 2>/dev/null || echo unknown
1187
1188buildworld_prologue: .PHONY
1189	@echo "--------------------------------------------------------------"
1190	@echo ">>> World build started on `LC_ALL=C date`"
1191	@echo "--------------------------------------------------------------"
1192
1193buildworld_epilogue: .PHONY
1194	@echo
1195	@echo "--------------------------------------------------------------"
1196	@echo ">>> World build completed on `LC_ALL=C date`"
1197	@seconds=$$(($$(date '+%s') - ${_BUILDWORLD_START})); \
1198	  echo -n ">>> World built in $$seconds seconds, "; \
1199	  echo "ncpu: $$(${_ncpu_cmd})${.MAKE.JOBS:S/^/, make -j/}"
1200	@echo "--------------------------------------------------------------"
1201
1202#
1203# We need to have this as a target because the indirection between Makefile
1204# and Makefile.inc1 causes the correct PATH to be used, rather than a
1205# modification of the current environment's PATH.  In addition, we need
1206# to quote multiword values.
1207#
1208buildenvvars: .PHONY
1209	@echo ${WMAKEENV:Q} ${.MAKE.EXPORTED:@v@$v=\"${$v}\"@}
1210
1211.if ${.TARGETS:Mbuildenv}
1212.if ${.MAKEFLAGS:M-j}
1213.error The buildenv target is incompatible with -j
1214.endif
1215.endif
1216BUILDENV_DIR?=	${.CURDIR}
1217#
1218# Note: make will report any errors the shell reports. This can
1219# be odd if the last command in an interactive shell generates an
1220# error or is terminated by SIGINT. These reported errors look bad,
1221# but are harmless. Allowing them also allows BUILDENV_SHELL to
1222# be a complex command whose status will be returned to the caller.
1223# Some scripts in tools rely on this behavior to report build errors.
1224#
1225buildenv: .PHONY
1226	@echo Entering world for ${TARGET_ARCH}:${TARGET}
1227.if ${BUILDENV_SHELL:M*zsh*}
1228	@echo For ZSH you must run: export CPUTYPE=${TARGET_CPUTYPE}
1229.endif
1230	@cd ${BUILDENV_DIR} && env ${WMAKEENV} \
1231	INSTALL="${INSTALL_CMD} ${INSTALLFLAGS}" \
1232	MTREE_CMD="${MTREE_CMD} ${MTREEFLAGS}" BUILDENV=1 ${BUILDENV_SHELL}
1233
1234TOOLCHAIN_TGTS=	${WMAKE_TGTS:Neverything:Nbuild${libcompat}}
1235toolchain: ${TOOLCHAIN_TGTS} .PHONY
1236KERNEL_TOOLCHAIN_TGTS=	${TOOLCHAIN_TGTS:N_obj:N_cleanobj:N_includes:N_libraries}
1237.if make(kernel-toolchain)
1238.ORDER: ${KERNEL_TOOLCHAIN_TGTS}
1239.endif
1240kernel-toolchain: ${KERNEL_TOOLCHAIN_TGTS} .PHONY
1241
1242#
1243# installcheck
1244#
1245# Checks to be sure system is ready for installworld/installkernel.
1246#
1247installcheck: _installcheck_world _installcheck_kernel .PHONY
1248_installcheck_world: .PHONY
1249	@echo "--------------------------------------------------------------"
1250	@echo ">>> Install check world"
1251	@echo "--------------------------------------------------------------"
1252_installcheck_kernel: .PHONY
1253	@echo "--------------------------------------------------------------"
1254	@echo ">>> Install check kernel"
1255	@echo "--------------------------------------------------------------"
1256
1257#
1258# Require DESTDIR to be set if installing for a different architecture or
1259# using the user/group database in the source tree.
1260#
1261.if ${TARGET_ARCH} != ${MACHINE_ARCH} || ${TARGET} != ${MACHINE} || \
1262    defined(DB_FROM_SRC)
1263.if !make(distributeworld)
1264_installcheck_world: __installcheck_DESTDIR
1265_installcheck_kernel: __installcheck_DESTDIR
1266__installcheck_DESTDIR: .PHONY
1267.if !defined(DESTDIR) || empty(DESTDIR)
1268	@echo "ERROR: Please set DESTDIR!"; \
1269	false
1270.endif
1271.endif
1272.endif
1273
1274.if !defined(DB_FROM_SRC)
1275#
1276# Check for missing UIDs/GIDs.
1277#
1278CHECK_UIDS=	auditdistd
1279CHECK_GIDS=	audit
1280CHECK_UIDS+=	ntpd
1281CHECK_GIDS+=	ntpd
1282CHECK_UIDS+=	proxy
1283CHECK_GIDS+=	proxy authpf
1284CHECK_UIDS+=	smmsp
1285CHECK_GIDS+=	smmsp
1286CHECK_UIDS+=	unbound
1287CHECK_GIDS+=	unbound
1288_installcheck_world: __installcheck_UGID
1289__installcheck_UGID: .PHONY
1290.for uid in ${CHECK_UIDS}
1291	@if ! `id -u ${uid} >/dev/null 2>&1`; then \
1292		echo "ERROR: Required ${uid} user is missing, see /usr/src/UPDATING."; \
1293		false; \
1294	fi
1295.endfor
1296.for gid in ${CHECK_GIDS}
1297	@if ! `find / -prune -group ${gid} >/dev/null 2>&1`; then \
1298		echo "ERROR: Required ${gid} group is missing, see /usr/src/UPDATING."; \
1299		false; \
1300	fi
1301.endfor
1302.endif
1303#
1304# If installing over the running system (DESTDIR is / or unset) and the install
1305# includes rescue, try running rescue from the objdir as a sanity check.  If
1306# rescue is not functional (e.g., because it depends on a system call not
1307# supported by the currently running kernel), abort the installation.
1308#
1309.if !make(distributeworld) && ${MK_RESCUE} != "no" && \
1310    (empty(DESTDIR) || ${DESTDIR} == "/") && empty(BYPASS_INSTALLCHECK_SH)
1311_installcheck_world: __installcheck_sh_check
1312__installcheck_sh_check: .PHONY
1313	@if [ "`${OBJTOP}/rescue/rescue/rescue sh -c 'echo OK'`" != \
1314	    OK ]; then \
1315		echo "rescue/sh check failed, installation aborted" >&2; \
1316		false; \
1317	fi
1318.endif
1319
1320#
1321# Required install tools to be saved in a scratch dir for safety.
1322#
1323.if ${MK_ZONEINFO} != "no"
1324_zoneinfo=	zic tzsetup
1325.endif
1326
1327.if !defined(CROSSBUILD_HOST)
1328_sysctl=sysctl
1329.endif
1330
1331ITOOLS=	[ awk cap_mkdb cat chflags chmod chown cmp cp \
1332	date echo egrep find grep id install ${_install-info} \
1333	ln make mkdir mtree mv pwd_mkdb \
1334	rm sed services_mkdb sh sort strip ${_sysctl} test time true uname wc \
1335	${_zoneinfo} ${LOCAL_ITOOLS}
1336
1337# Needed for share/man
1338.if ${MK_MAN_UTILS} != "no"
1339ITOOLS+=makewhatis
1340.endif
1341
1342#
1343# distributeworld
1344#
1345# Distributes everything compiled by a `buildworld'.
1346#
1347# installworld
1348#
1349# Installs everything compiled by a 'buildworld'.
1350#
1351
1352# Non-base distributions produced by the base system
1353EXTRA_DISTRIBUTIONS=
1354.if defined(_LIBCOMPAT)
1355EXTRA_DISTRIBUTIONS+=	lib${libcompat}
1356.endif
1357.if ${MK_TESTS} != "no"
1358EXTRA_DISTRIBUTIONS+=	tests
1359.endif
1360
1361DEBUG_DISTRIBUTIONS=
1362.if ${MK_DEBUG_FILES} != "no"
1363DEBUG_DISTRIBUTIONS+=	base ${EXTRA_DISTRIBUTIONS:S,tests,,}
1364.endif
1365
1366MTREE_MAGIC?=	mtree 2.0
1367
1368distributeworld installworld stageworld: _installcheck_world .PHONY
1369	mkdir -p ${INSTALLTMP}
1370	progs=$$(for prog in ${ITOOLS}; do \
1371		if progpath=`env PATH=${TMPPATH} which $$prog`; then \
1372			echo $$progpath; \
1373		else \
1374			echo "Required tool $$prog not found in PATH ($$PATH)." >&2; \
1375			exit 1; \
1376		fi; \
1377	    done); \
1378	if [ -z "${CROSSBUILD_HOST}" ] ; then \
1379		libs=$$(ldd -f "%o %p\n" -f "%o %p\n" $$progs 2>/dev/null | sort -u | \
1380		    while read line; do \
1381			set -- $$line; \
1382			if [ "$$2 $$3" != "not found" ]; then \
1383				echo $$2; \
1384			else \
1385				echo "Required library $$1 not found." >&2; \
1386				exit 1; \
1387			fi; \
1388		    done); \
1389	fi; \
1390	cp $$libs $$progs ${INSTALLTMP}
1391	cp -R $${PATH_LOCALE:-"/usr/share/locale"} ${INSTALLTMP}/locale
1392.if defined(NO_ROOT)
1393	-mkdir -p ${METALOG:H}
1394	echo "#${MTREE_MAGIC}" > ${METALOG}
1395.endif
1396.if make(distributeworld)
1397.for dist in ${EXTRA_DISTRIBUTIONS}
1398	-mkdir ${DESTDIR}/${DISTDIR}/${dist}
1399	${DESTDIR_MTREE} -f ${.CURDIR}/etc/mtree/BSD.root.dist \
1400	    -p ${DESTDIR}/${DISTDIR}/${dist} >/dev/null
1401	${DESTDIR_MTREE} -f ${.CURDIR}/etc/mtree/BSD.usr.dist \
1402	    -p ${DESTDIR}/${DISTDIR}/${dist}/usr >/dev/null
1403	${DESTDIR_MTREE} -f ${.CURDIR}/etc/mtree/BSD.include.dist \
1404	    -p ${DESTDIR}/${DISTDIR}/${dist}/usr/include >/dev/null
1405.if ${MK_DEBUG_FILES} != "no"
1406	${DESTDIR_MTREE} -f ${.CURDIR}/etc/mtree/BSD.debug.dist \
1407	    -p ${DESTDIR}/${DISTDIR}/${dist}/usr/lib >/dev/null
1408.endif
1409.if defined(_LIBCOMPAT)
1410	${DESTDIR_MTREE} -f ${.CURDIR}/etc/mtree/BSD.lib${libcompat}.dist \
1411	    -p ${DESTDIR}/${DISTDIR}/${dist}/usr >/dev/null
1412.if ${MK_DEBUG_FILES} != "no"
1413	${DESTDIR_MTREE} -f ${.CURDIR}/etc/mtree/BSD.lib${libcompat}.dist \
1414	    -p ${DESTDIR}/${DISTDIR}/${dist}/usr/lib/debug/usr >/dev/null
1415.endif
1416.endif
1417.if ${MK_TESTS} != "no" && ${dist} == "tests"
1418	-mkdir -p ${DESTDIR}/${DISTDIR}/${dist}${TESTSBASE}
1419	${DESTDIR_MTREE} -f ${.CURDIR}/etc/mtree/BSD.tests.dist \
1420	    -p ${DESTDIR}/${DISTDIR}/${dist}${TESTSBASE} >/dev/null
1421.if ${MK_DEBUG_FILES} != "no"
1422	${DESTDIR_MTREE} -f ${.CURDIR}/etc/mtree/BSD.tests.dist \
1423	    -p ${DESTDIR}/${DISTDIR}/${dist}/usr/lib/debug/${TESTSBASE} >/dev/null
1424.endif
1425.endif
1426.if defined(NO_ROOT)
1427	${IMAKEENV} ${DISTR_MTREE} -C -f ${.CURDIR}/etc/mtree/BSD.root.dist | \
1428	    sed -e 's#^\./#./${dist}/#' >> ${METALOG}
1429	${IMAKEENV} ${DISTR_MTREE} -C -f ${.CURDIR}/etc/mtree/BSD.usr.dist | \
1430	    sed -e 's#^\./#./${dist}/usr/#' >> ${METALOG}
1431	${IMAKEENV} ${DISTR_MTREE} -C -f ${.CURDIR}/etc/mtree/BSD.include.dist | \
1432	    sed -e 's#^\./#./${dist}/usr/include/#' >> ${METALOG}
1433.if defined(_LIBCOMPAT)
1434	${IMAKEENV} ${DISTR_MTREE} -C -f ${.CURDIR}/etc/mtree/BSD.lib${libcompat}.dist | \
1435	    sed -e 's#^\./#./${dist}/usr/#' >> ${METALOG}
1436.endif
1437.endif
1438.endfor
1439	-mkdir ${DESTDIR}/${DISTDIR}/base
1440	${_+_}cd ${.CURDIR}/etc; ${CROSSENV} PATH=${TMPPATH} ${MAKE} \
1441	    METALOG=${METALOG} ${IMAKE_INSTALL} ${IMAKE_MTREE} \
1442	    DISTBASE=/base DESTDIR=${DESTDIR}/${DISTDIR}/base \
1443	    LOCAL_MTREE=${LOCAL_MTREE:Q} distrib-dirs
1444	${INSTALL_SYMLINK} ${INSTALLFLAGS} usr/src/sys ${INSTALL_DDIR}/base/sys
1445.endif # make(distributeworld)
1446	${_+_}cd ${.CURDIR}; ${IMAKE} re${.TARGET:S/world$//}; \
1447	    ${IMAKEENV} rm -rf ${INSTALLTMP}
1448.if make(distributeworld)
1449.for dist in ${EXTRA_DISTRIBUTIONS}
1450	find ${DESTDIR}/${DISTDIR}/${dist} -mindepth 1 -type d -empty -delete
1451.endfor
1452.if defined(NO_ROOT)
1453.for dist in base ${EXTRA_DISTRIBUTIONS}
1454	@# For each file that exists in this dist, print the corresponding
1455	@# line from the METALOG.  This relies on the fact that
1456	@# a line containing only the filename will sort immediately before
1457	@# the relevant mtree line.
1458	cd ${DESTDIR}/${DISTDIR}; \
1459	find ./${dist} | sort -u ${METALOG} - | \
1460	awk 'BEGIN { print "#${MTREE_MAGIC}" } !/ type=/ { file = $$1 } / type=/ { if ($$1 == file) { sub(/^\.\/${dist}\//, "./"); print } }' > \
1461	${DESTDIR}/${DISTDIR}/${dist}.meta
1462.endfor
1463.for dist in ${DEBUG_DISTRIBUTIONS}
1464	@# For each file that exists in this dist, print the corresponding
1465	@# line from the METALOG.  This relies on the fact that
1466	@# a line containing only the filename will sort immediately before
1467	@# the relevant mtree line.
1468	cd ${DESTDIR}/${DISTDIR}; \
1469	find ./${dist}/usr/lib/debug | sort -u ${METALOG} - | \
1470	awk 'BEGIN { print "#${MTREE_MAGIC}" } !/ type=/ { file = $$1 } / type=/ { if ($$1 == file) { sub(/^\.\/${dist}\//, "./"); print } }' > \
1471	${DESTDIR}/${DISTDIR}/${dist}.debug.meta
1472.endfor
1473.endif
1474.endif # make(distributeworld)
1475.if !make(packageworld) && ${MK_CAROOT} != "no"
1476	@if which openssl>/dev/null; then \
1477		DESTDIR=${CERTCTLDESTDIR} PATH=${TMPPATH}:${PATH} \
1478		    sh ${SRCTOP}/usr.sbin/certctl/certctl.sh ${CERTCTLFLAGS} rehash \
1479	else \
1480		echo "No openssl on the host, not rehashing certificates target -- /etc/ssl may not be populated."; \
1481	fi
1482.endif
1483
1484packageworld: .PHONY
1485.for dist in base ${EXTRA_DISTRIBUTIONS}
1486.if defined(NO_ROOT)
1487	${_+_}cd ${DESTDIR}/${DISTDIR}/${dist}; \
1488	    tar cvf - --exclude usr/lib/debug \
1489	    @${DESTDIR}/${DISTDIR}/${dist}.meta | \
1490	    ${XZ_CMD} > ${PACKAGEDIR}/${dist}.txz
1491.else
1492	${_+_}cd ${DESTDIR}/${DISTDIR}/${dist}; \
1493	    tar cvf - --exclude usr/lib/debug . | \
1494	    ${XZ_CMD} > ${PACKAGEDIR}/${dist}.txz
1495.endif
1496.endfor
1497
1498.for dist in ${DEBUG_DISTRIBUTIONS}
1499. if defined(NO_ROOT)
1500	${_+_}cd ${DESTDIR}/${DISTDIR}/${dist}; \
1501	    tar cvf - @${DESTDIR}/${DISTDIR}/${dist}.debug.meta | \
1502	    ${XZ_CMD} > ${PACKAGEDIR}/${dist}-dbg.txz
1503. else
1504	${_+_}cd ${DESTDIR}/${DISTDIR}/${dist}; \
1505	    tar cvLf - usr/lib/debug | \
1506	    ${XZ_CMD} > ${PACKAGEDIR}/${dist}-dbg.txz
1507. endif
1508.endfor
1509
1510makeman: .PHONY
1511	${_+_}cd ${.CURDIR}/tools/build/options; sh makeman > \
1512	    ${.CURDIR}/share/man/man5/src.conf.5
1513
1514# We can't assume here that ${TMPPATH} will include ${PATH} or /usr/libexec
1515# because we may be building with a STRICTTMPPATH, so we explicitly include
1516# /usr/libexec here for flua.  ${TMPPATH} still usefully includes anything else
1517# we may need to function.
1518_sysent_PATH=	${TMPPATH}:/usr/libexec
1519_sysent_dirs=	sys/kern
1520_sysent_dirs+=	sys/compat/freebsd32
1521_sysent_dirs+=	sys/amd64/linux		\
1522		sys/amd64/linux32	\
1523		sys/arm64/linux		\
1524		sys/i386/linux
1525
1526sysent: .PHONY
1527.for _dir in ${_sysent_dirs}
1528sysent-${_dir}: .PHONY
1529	@echo "${MAKE} -C ${.CURDIR}/${_dir} sysent"
1530	${_+_}@env PATH=${_sysent_PATH} ${MAKE} -C ${.CURDIR}/${_dir} sysent
1531
1532sysent: sysent-${_dir}
1533.endfor
1534
1535#
1536# reinstall
1537#
1538# If you have a build server, you can NFS mount the source and obj directories
1539# and do a 'make reinstall' on the *client* to install new binaries from the
1540# most recent server build.
1541#
1542restage reinstall: .MAKE .PHONY
1543	@echo "--------------------------------------------------------------"
1544	@echo ">>> Making hierarchy"
1545	@echo "--------------------------------------------------------------"
1546	${_+_}cd ${.CURDIR}; ${MAKE} -f Makefile.inc1 \
1547	    LOCAL_MTREE=${LOCAL_MTREE:Q} hierarchy
1548.if make(restage)
1549	@echo "--------------------------------------------------------------"
1550	@echo ">>> Making distribution"
1551	@echo "--------------------------------------------------------------"
1552	${_+_}cd ${.CURDIR}; ${MAKE} -f Makefile.inc1 \
1553	    LOCAL_MTREE=${LOCAL_MTREE:Q} distribution
1554.endif
1555	@echo
1556	@echo "--------------------------------------------------------------"
1557	@echo ">>> Installing everything started on `LC_ALL=C date`"
1558	@echo "--------------------------------------------------------------"
1559	${_+_}cd ${.CURDIR}; ${MAKE} -f Makefile.inc1 install
1560.if defined(_LIBCOMPAT)
1561	${_+_}cd ${.CURDIR}; ${MAKE} -f Makefile.inc1 install${libcompat}
1562.endif
1563	@echo "--------------------------------------------------------------"
1564	@echo ">>> Installing everything completed on `LC_ALL=C date`"
1565	@echo "--------------------------------------------------------------"
1566
1567redistribute: .MAKE .PHONY
1568	@echo "--------------------------------------------------------------"
1569	@echo ">>> Distributing everything"
1570	@echo "--------------------------------------------------------------"
1571	${_+_}cd ${.CURDIR}; ${MAKE} -f Makefile.inc1 distribute
1572.if defined(_LIBCOMPAT)
1573	${_+_}cd ${.CURDIR}; ${MAKE} -f Makefile.inc1 distribute${libcompat} \
1574	    DISTRIBUTION=lib${libcompat}
1575.endif
1576
1577distrib-dirs distribution: .MAKE .PHONY
1578	${_+_}cd ${.CURDIR}/etc; ${CROSSENV} PATH=${TMPPATH} ${MAKE} \
1579	    ${IMAKE_INSTALL} ${IMAKE_MTREE} METALOG=${METALOG} ${.TARGET}
1580.if make(distribution)
1581	${_+_}cd ${.CURDIR}; ${CROSSENV} PATH=${TMPPATH} \
1582		${MAKE} -f Makefile.inc1 ${IMAKE_INSTALL} \
1583		METALOG=${METALOG} MK_TESTS=no \
1584		MK_TESTS_SUPPORT=${MK_TESTS_SUPPORT} installconfig
1585.endif
1586
1587#
1588# buildkernel and installkernel
1589#
1590# Which kernels to build and/or install is specified by setting
1591# KERNCONF. If not defined a GENERIC kernel is built/installed.
1592# Only the existing (depending TARGET) config files are used
1593# for building kernels and only the first of these is designated
1594# as the one being installed.
1595#
1596# Note that we have to use TARGET instead of TARGET_ARCH when
1597# we're in kernel-land. Since only TARGET_ARCH is (expected) to
1598# be set to cross-build, we have to make sure TARGET is set
1599# properly.
1600
1601.if defined(KERNFAST)
1602NO_KERNELCLEAN=	t
1603NO_KERNELCONFIG=	t
1604NO_KERNELOBJ=		t
1605# Shortcut for KERNCONF=Blah -DKERNFAST is now KERNFAST=Blah
1606.if !defined(KERNCONF) && ${KERNFAST} != "1"
1607KERNCONF=${KERNFAST}
1608.endif
1609.endif
1610.if ${TARGET_ARCH} == "powerpc64"
1611KERNCONF?=	GENERIC64
1612.elif ${TARGET_ARCH} == "powerpc64le"
1613KERNCONF?=	GENERIC64LE
1614.elif ${TARGET_ARCH} == "powerpcspe"
1615KERNCONF?=	MPC85XXSPE
1616.else
1617KERNCONF?=	GENERIC
1618.endif
1619INSTKERNNAME?=	kernel
1620
1621KERNSRCDIR?=	${.CURDIR}/sys
1622KRNLCONFDIR=	${KERNSRCDIR}/${TARGET}/conf
1623KRNLOBJDIR=	${OBJTOP}${KERNSRCDIR:C,^${.CURDIR},,}
1624KERNCONFDIR?=	${KRNLCONFDIR}
1625
1626BUILDKERNELS=
1627INSTALLKERNEL=
1628.if defined(NO_INSTALLKERNEL)
1629# All of the BUILDKERNELS loops start at index 1.
1630BUILDKERNELS+= dummy
1631.endif
1632.for _kernel in ${KERNCONF}
1633.if !defined(_MKSHOWCONFIG) && exists(${KERNCONFDIR}/${_kernel})
1634BUILDKERNELS+=	${_kernel}
1635.if empty(INSTALLKERNEL) && !defined(NO_INSTALLKERNEL)
1636INSTALLKERNEL= ${_kernel}
1637.endif
1638.else
1639.if make(buildkernel)
1640.error Missing KERNCONF ${KERNCONFDIR}/${_kernel}
1641.endif
1642.endif
1643.endfor
1644
1645_cleankernobj_fast_depend_hack: .PHONY
1646# 20191009  r353340  removal of opensolaris_atomic.S (also r353381)
1647.if ${MACHINE} != i386
1648.for f in opensolaris_atomic
1649.for m in opensolaris zfs
1650	@if [ -e "${KRNLOBJDIR}/${KERNCONF}/modules${SRCTOP}/sys/modules/${m}/.depend.${f}.o" ] && \
1651	    grep -q ${f}.S "${KRNLOBJDIR}/${KERNCONF}/modules${SRCTOP}/sys/modules/${m}/.depend.${f}.o"; then \
1652		echo "Removing stale dependencies for opensolaris_atomic"; \
1653		rm -f ${KRNLOBJDIR}/${KERNCONF}/modules${SRCTOP}/sys/modules/${m}/.depend.${f}.*; \
1654	fi
1655.endfor
1656.endfor
1657.endif
1658
1659${WMAKE_TGTS:N_worldtmp:Nbuild${libcompat}} ${.ALLTARGETS:M_*:N_worldtmp}: .MAKE .PHONY
1660
1661# record kernel(s) build time in seconds
1662.if make(buildkernel)
1663_BUILDKERNEL_START!= date '+%s'
1664.endif
1665
1666#
1667# buildkernel
1668#
1669# Builds all kernels defined by BUILDKERNELS.
1670#
1671buildkernel: .MAKE .PHONY
1672.if empty(BUILDKERNELS:Ndummy)
1673	@echo "ERROR: Missing kernel configuration file(s) (${KERNCONF})."; \
1674	false
1675.endif
1676	@echo
1677.for _kernel in ${BUILDKERNELS:Ndummy}
1678	@echo "--------------------------------------------------------------"
1679	@echo ">>> Kernel build for ${_kernel} started on `LC_ALL=C date`"
1680	@echo "--------------------------------------------------------------"
1681	@echo "===> ${_kernel}"
1682	mkdir -p ${KRNLOBJDIR}
1683.if !defined(NO_KERNELCONFIG)
1684	@echo
1685	@echo "--------------------------------------------------------------"
1686	@echo ">>> stage 1: configuring the kernel"
1687	@echo "--------------------------------------------------------------"
1688	cd ${KRNLCONFDIR}; \
1689		PATH=${TMPPATH} \
1690		    config ${CONFIGARGS} -d ${KRNLOBJDIR}/${_kernel} \
1691			-I '${KERNCONFDIR}' -I '${KRNLCONFDIR}' \
1692			'${KERNCONFDIR}/${_kernel}'
1693.endif
1694.if ${MK_CLEAN} == "yes" && !defined(NO_KERNELCLEAN)
1695	@echo
1696	@echo "--------------------------------------------------------------"
1697	@echo ">>> stage 2.1: cleaning up the object tree"
1698	@echo "--------------------------------------------------------------"
1699	${_+_}cd ${KRNLOBJDIR}/${_kernel}; ${KMAKE} ${CLEANDIR}
1700.else
1701	${_+_}cd ${.CURDIR}; ${WMAKE} _cleankernobj_fast_depend_hack
1702.endif
1703.if !defined(NO_KERNELOBJ)
1704	@echo
1705	@echo "--------------------------------------------------------------"
1706	@echo ">>> stage 2.2: rebuilding the object tree"
1707	@echo "--------------------------------------------------------------"
1708	${_+_}cd ${KRNLOBJDIR}/${_kernel}; ${KMAKE} obj
1709.endif
1710	@echo
1711	@echo "--------------------------------------------------------------"
1712	@echo ">>> stage 2.3: build tools"
1713	@echo "--------------------------------------------------------------"
1714	${_+_}cd ${.CURDIR}; ${KTMAKE} kernel-tools
1715	@echo
1716	@echo "--------------------------------------------------------------"
1717	@echo ">>> stage 3.1: building everything"
1718	@echo "--------------------------------------------------------------"
1719	${_+_}cd ${KRNLOBJDIR}/${_kernel}; ${KMAKE} all -DNO_MODULES_OBJ
1720	@echo "--------------------------------------------------------------"
1721	@echo ">>> Kernel build for ${_kernel} completed on `LC_ALL=C date`"
1722	@echo "--------------------------------------------------------------"
1723
1724.endfor
1725	@seconds=$$(($$(date '+%s') - ${_BUILDKERNEL_START})); \
1726	  echo -n ">>> Kernel(s) ${BUILDKERNELS} built in $$seconds seconds, "; \
1727	  echo "ncpu: $$(${_ncpu_cmd})${.MAKE.JOBS:S/^/, make -j/}"
1728	@echo "--------------------------------------------------------------"
1729
1730.if !make(packages) && !make(update-packages)
1731NO_INSTALLEXTRAKERNELS?=	yes
1732.else
1733# packages/update-packages installs kernels to a staging directory then builds
1734# packages from the result to be installed, typically to other systems.  It is
1735# less surprising for these targets to honor KERNCONF if multiple kernels are
1736# specified.
1737NO_INSTALLEXTRAKERNELS?=	no
1738.endif
1739
1740#
1741# installkernel, etc.
1742#
1743# Install the kernel defined by INSTALLKERNEL
1744#
1745installkernel installkernel.debug \
1746reinstallkernel reinstallkernel.debug: _installcheck_kernel .PHONY
1747.if !defined(NO_INSTALLKERNEL)
1748.if empty(INSTALLKERNEL)
1749	@echo "ERROR: No kernel \"${KERNCONF}\" to install."; \
1750	false
1751.endif
1752	@echo "--------------------------------------------------------------"
1753	@echo ">>> Installing kernel ${INSTALLKERNEL} on $$(LC_ALL=C date)"
1754	@echo "--------------------------------------------------------------"
1755	${_+_}cd ${KRNLOBJDIR}/${INSTALLKERNEL}; \
1756	    ${CROSSENV} PATH=${TMPPATH} \
1757	    ${MAKE} ${IMAKE_INSTALL} KERNEL=${INSTKERNNAME} ${.TARGET:S/kernel//}
1758	@echo "--------------------------------------------------------------"
1759	@echo ">>> Installing kernel ${INSTALLKERNEL} completed on $$(LC_ALL=C date)"
1760	@echo "--------------------------------------------------------------"
1761.endif
1762.if ${BUILDKERNELS:[#]} > 1 && ${NO_INSTALLEXTRAKERNELS} != "yes"
1763.for _kernel in ${BUILDKERNELS:[2..-1]}
1764	@echo "--------------------------------------------------------------"
1765	@echo ">>> Installing kernel ${_kernel} $$(LC_ALL=C date)"
1766	@echo "--------------------------------------------------------------"
1767	${_+_}cd ${KRNLOBJDIR}/${_kernel}; \
1768	    ${CROSSENV} PATH=${TMPPATH} \
1769	    ${MAKE} ${IMAKE_INSTALL} KERNEL=${INSTKERNNAME}.${_kernel} ${.TARGET:S/kernel//}
1770	@echo "--------------------------------------------------------------"
1771	@echo ">>> Installing kernel ${_kernel} completed on $$(LC_ALL=C date)"
1772	@echo "--------------------------------------------------------------"
1773.endfor
1774.endif
1775
1776distributekernel distributekernel.debug: .PHONY
1777.if !defined(NO_INSTALLKERNEL)
1778.if empty(INSTALLKERNEL)
1779	@echo "ERROR: No kernel \"${KERNCONF}\" to install."; \
1780	false
1781.endif
1782	mkdir -p ${DESTDIR}/${DISTDIR}
1783.if defined(NO_ROOT)
1784	@echo "#${MTREE_MAGIC}" > ${DESTDIR}/${DISTDIR}/kernel.premeta
1785.endif
1786	${_+_}cd ${KRNLOBJDIR}/${INSTALLKERNEL}; \
1787	    ${IMAKEENV} ${IMAKE_INSTALL:S/METALOG/kernel.premeta/} \
1788	    ${IMAKE_MTREE} PATH=${TMPPATH} ${MAKE} KERNEL=${INSTKERNNAME} \
1789	    DESTDIR=${INSTALL_DDIR}/kernel \
1790	    ${.TARGET:S/distributekernel/install/}
1791.if defined(NO_ROOT)
1792	@sed -e 's|^./kernel|.|' ${DESTDIR}/${DISTDIR}/kernel.premeta > \
1793	    ${DESTDIR}/${DISTDIR}/kernel.meta
1794.endif
1795.endif
1796.if ${BUILDKERNELS:[#]} > 1 && ${NO_INSTALLEXTRAKERNELS} != "yes"
1797.for _kernel in ${BUILDKERNELS:[2..-1]}
1798.if defined(NO_ROOT)
1799	@echo "#${MTREE_MAGIC}" > ${DESTDIR}/${DISTDIR}/kernel.${_kernel}.premeta
1800.endif
1801	${_+_}cd ${KRNLOBJDIR}/${_kernel}; \
1802	    ${IMAKEENV} ${IMAKE_INSTALL:S/METALOG/kernel.${_kernel}.premeta/} \
1803	    ${IMAKE_MTREE} PATH=${TMPPATH} ${MAKE} \
1804	    KERNEL=${INSTKERNNAME}.${_kernel} \
1805	    DESTDIR=${INSTALL_DDIR}/kernel.${_kernel} \
1806	    ${.TARGET:S/distributekernel/install/}
1807.if defined(NO_ROOT)
1808	@sed -e "s|^./kernel.${_kernel}|.|" \
1809	    ${DESTDIR}/${DISTDIR}/kernel.${_kernel}.premeta > \
1810	    ${DESTDIR}/${DISTDIR}/kernel.${_kernel}.meta
1811.endif
1812.endfor
1813.endif
1814
1815packagekernel: .PHONY
1816.if defined(NO_ROOT)
1817.if !defined(NO_INSTALLKERNEL)
1818	cd ${DESTDIR}/${DISTDIR}/kernel; \
1819	    tar cvf - --exclude '*.debug' \
1820	    @${DESTDIR}/${DISTDIR}/kernel.meta | \
1821	    ${XZ_CMD} > ${PACKAGEDIR}/kernel.txz
1822.endif
1823.if ${MK_DEBUG_FILES} != "no"
1824	cd ${DESTDIR}/${DISTDIR}/kernel; \
1825	    tar cvf - --include '*/*/*.debug' \
1826	    @${DESTDIR}/${DISTDIR}/kernel.meta | \
1827	    ${XZ_CMD} > ${DESTDIR}/${DISTDIR}/kernel-dbg.txz
1828.endif
1829.if ${BUILDKERNELS:[#]} > 1 && ${NO_INSTALLEXTRAKERNELS} != "yes"
1830.for _kernel in ${BUILDKERNELS:[2..-1]}
1831	cd ${DESTDIR}/${DISTDIR}/kernel.${_kernel}; \
1832	    tar cvf - --exclude '*.debug' \
1833	    @${DESTDIR}/${DISTDIR}/kernel.${_kernel}.meta | \
1834	    ${XZ_CMD} > ${PACKAGEDIR}/kernel.${_kernel}.txz
1835.if ${MK_DEBUG_FILES} != "no"
1836	cd ${DESTDIR}/${DISTDIR}/kernel.${_kernel}; \
1837	    tar cvf - --include '*/*/*.debug' \
1838	    @${DESTDIR}/${DISTDIR}/kernel.${_kernel}.meta | \
1839	    ${XZ_CMD} > ${DESTDIR}/${DISTDIR}/kernel.${_kernel}-dbg.txz
1840.endif
1841.endfor
1842.endif
1843.else
1844.if !defined(NO_INSTALLKERNEL)
1845	cd ${DESTDIR}/${DISTDIR}/kernel; \
1846	    tar cvf - --exclude '*.debug' . | \
1847	    ${XZ_CMD} > ${PACKAGEDIR}/kernel.txz
1848.endif
1849.if ${MK_DEBUG_FILES} != "no"
1850	cd ${DESTDIR}/${DISTDIR}/kernel; \
1851	    tar cvf - --include '*/*/*.debug' $$(eval find .) | \
1852	    ${XZ_CMD} > ${DESTDIR}/${DISTDIR}/kernel-dbg.txz
1853.endif
1854.if ${BUILDKERNELS:[#]} > 1 && ${NO_INSTALLEXTRAKERNELS} != "yes"
1855.for _kernel in ${BUILDKERNELS:[2..-1]}
1856	cd ${DESTDIR}/${DISTDIR}/kernel.${_kernel}; \
1857	    tar cvf - --exclude '*.debug' . | \
1858	    ${XZ_CMD} > ${PACKAGEDIR}/kernel.${_kernel}.txz
1859.if ${MK_DEBUG_FILES} != "no"
1860	cd ${DESTDIR}/${DISTDIR}/kernel.${_kernel}; \
1861	    tar cvf - --include '*/*/*.debug' $$(eval find .) | \
1862	    ${XZ_CMD} > ${DESTDIR}/${DISTDIR}/kernel.${_kernel}-dbg.txz
1863.endif
1864.endfor
1865.endif
1866.endif
1867
1868stagekernel: .PHONY
1869	${_+_}${MAKE} -C ${.CURDIR} ${.MAKEFLAGS} distributekernel
1870
1871PORTSDIR?=	/usr/ports
1872WSTAGEDIR?=	${OBJTOP}/worldstage
1873KSTAGEDIR?=	${OBJTOP}/kernelstage
1874REPODIR?=	${OBJROOT}repo
1875PKG_FORMAT?=	txz
1876PKG_REPO_SIGNING_KEY?=	# empty
1877PKG_OUTPUT_DIR?=	${PKG_VERSION}
1878
1879.ORDER:		stage-packages create-packages
1880.ORDER:		create-packages create-world-packages
1881.ORDER:		create-packages create-kernel-packages
1882.ORDER:		create-packages sign-packages
1883
1884_pkgbootstrap: .PHONY
1885.if make(*package*) && !exists(${LOCALBASE}/sbin/pkg)
1886	@env ASSUME_ALWAYS_YES=YES pkg bootstrap
1887.endif
1888
1889.if make(create-world-packages-jobs) || make(create-kernel-packages*) || make(real-update-packages) || make(sign-packages)
1890PKG_ABI!=${PKG_CMD} -o ABI_FILE=${WSTAGEDIR}/usr/bin/uname config ABI
1891.endif
1892PKG_BIN_VERSION!=${PKG_CMD} --version </dev/null 2>/dev/null |\
1893    awk -F. '/^[0-9.]+$$/ {print $$1 * 10000 + $$2 * 100 + $$3}'
1894.if ${PKG_BIN_VERSION} < 11700
1895PKG_EXT=	${PKG_FORMAT}
1896.else
1897PKG_EXT=	pkg
1898.endif
1899
1900.if !defined(PKG_VERSION_FROM) && make(real-update-packages)
1901.if defined(PKG_ABI)
1902.if exists(${REPODIR}/${PKG_ABI})
1903PKG_VERSION_FROM!=/usr/bin/readlink ${REPODIR}/${PKG_ABI}/latest
1904PKG_VERSION_FROM_DIR=	${REPODIR}/${PKG_ABI}/${PKG_VERSION_FROM}
1905.else
1906PKG_VERSION_FROM=
1907PKG_VERSION_FROM_DIR=
1908.endif
1909.endif
1910.endif
1911
1912PKGMAKEARGS+=	PKG_VERSION=${PKG_VERSION} \
1913		NO_INSTALLEXTRAKERNELS=${NO_INSTALLEXTRAKERNELS}
1914
1915packages: .PHONY
1916	${_+_}${MAKE} -C ${.CURDIR} ${PKGMAKEARGS} real-packages
1917
1918update-packages: .PHONY
1919	${_+_}${MAKE} -C ${.CURDIR} ${PKGMAKEARGS} real-update-packages
1920
1921package-pkg: .PHONY
1922	rm -rf /tmp/ports.${TARGET} || :
1923	env ${WMAKEENV:Q} SRCDIR=${.CURDIR} PORTSDIR=${PORTSDIR} REVISION=${_REVISION} \
1924		PKG_CMD=${PKG_CMD} PKG_VERSION=${PKG_VERSION} REPODIR=${REPODIR} \
1925		WSTAGEDIR=${WSTAGEDIR} \
1926		sh ${.CURDIR}/release/scripts/make-pkg-package.sh
1927
1928real-packages:	stage-packages create-packages sign-packages .PHONY
1929
1930real-update-packages: stage-packages .PHONY
1931	${_+_}${MAKE} -C ${.CURDIR} PKG_VERSION=${PKG_VERSION} create-packages
1932.if empty(PKG_VERSION_FROM_DIR)
1933	@echo "==> Bootstrapping repository, not checking for new packages"
1934.else
1935	@echo "==> Checking for new packages (comparing ${PKG_VERSION} to ${PKG_VERSION_FROM})"
1936	@for pkg in ${PKG_VERSION_FROM_DIR}/${PKG_NAME_PREFIX}-*; do \
1937	  pkgname=$$(pkg query -F $${pkg} '%n' | sed 's/${PKG_NAME_PREFIX}-\(.*\)/\1/') ; \
1938	  newpkgname=${PKG_NAME_PREFIX}-$${pkgname}-${PKG_VERSION}.${PKG_EXT} ; \
1939	  oldsum=$$(pkg query -F $${pkg} '%X') ; \
1940	  if [ ! -f ${REPODIR}/${PKG_ABI}/${PKG_VERSION}/$${newpkgname} ]; then \
1941	    continue; \
1942	  fi ; \
1943	  newsum=$$(pkg query -F ${REPODIR}/${PKG_ABI}/${PKG_VERSION}/$${newpkgname} '%X') ; \
1944	  if [ "$${oldsum}" == "$${newsum}" ]; then \
1945	   echo "==> Keeping old ${PKG_NAME_PREFIX}-$${pkgname}-${PKG_VERSION_FROM}.${PKG_EXT}" ; \
1946	   rm ${REPODIR}/${PKG_ABI}/${PKG_VERSION}/$${newpkgname} ; \
1947	   cp $${pkg} ${REPODIR}/${PKG_ABI}/${PKG_VERSION} ; \
1948	  else \
1949	    echo "==> New package $${newpkgname}" ; \
1950	  fi ; \
1951	done
1952.endif
1953	${_+_}@cd ${.CURDIR}; \
1954		${MAKE} -f Makefile.inc1 PKG_VERSION=${PKG_VERSION} sign-packages
1955
1956stage-packages-world: .PHONY
1957	@mkdir -p ${WSTAGEDIR}
1958	${_+_}@cd ${.CURDIR}; \
1959		${MAKE} DESTDIR=${WSTAGEDIR} -DNO_ROOT stageworld
1960
1961stage-packages-kernel: .PHONY
1962	@mkdir -p ${KSTAGEDIR}
1963	${_+_}@cd ${.CURDIR}; \
1964		${MAKE} DESTDIR=${KSTAGEDIR} -DNO_ROOT stagekernel
1965
1966stage-packages: .PHONY stage-packages-world stage-packages-kernel
1967
1968_repodir: .PHONY
1969	@mkdir -p ${REPODIR}
1970
1971create-packages-world:	_pkgbootstrap _repodir .PHONY
1972	${_+_}@cd ${.CURDIR}; \
1973		${MAKE} -f Makefile.inc1 \
1974			DESTDIR=${WSTAGEDIR} \
1975			PKG_VERSION=${PKG_VERSION} create-world-packages
1976
1977create-packages-kernel:	_pkgbootstrap _repodir .PHONY
1978	${_+_}@cd ${.CURDIR}; \
1979		${MAKE} -f Makefile.inc1 \
1980			DESTDIR=${KSTAGEDIR} \
1981			PKG_VERSION=${PKG_VERSION} DISTDIR=kernel \
1982			SOURCE_DATE_EPOCH=${SOURCE_DATE_EPOCH} \
1983			create-kernel-packages
1984
1985create-packages: .PHONY create-packages-world create-packages-kernel
1986
1987create-world-packages:	_pkgbootstrap .PHONY
1988	@rm -f ${WSTAGEDIR}/*.plist 2>/dev/null || :
1989	@cd ${WSTAGEDIR} ; \
1990		env -i LC_COLLATE=C sort ${WSTAGEDIR}/${DISTDIR}/METALOG | \
1991		awk -f ${SRCDIR}/release/scripts/mtree-to-plist.awk
1992	@for plist in ${WSTAGEDIR}/*.plist; do \
1993	  plist=$${plist##*/} ; \
1994	  pkgname=$${plist%.plist} ; \
1995	  echo "_PKGS+= $${pkgname}" ; \
1996	done > ${WSTAGEDIR}/packages.mk
1997	${_+_}@cd ${.CURDIR}; \
1998		${MAKE} -f Makefile.inc1 create-world-packages-jobs \
1999		SOURCE_DATE_EPOCH=${SOURCE_DATE_EPOCH} \
2000		.MAKE.JOB.PREFIX=
2001
2002.if make(create-world-packages-jobs)
2003.include "${WSTAGEDIR}/packages.mk"
2004.endif
2005
2006create-world-packages-jobs: .PHONY
2007.for pkgname in ${_PKGS}
2008create-world-packages-jobs: create-world-package-${pkgname}
2009create-world-package-${pkgname}: .PHONY
2010	@sh ${SRCDIR}/release/packages/generate-ucl.sh -o ${pkgname} \
2011		-s ${SRCDIR} -u ${WSTAGEDIR}/${pkgname}.ucl
2012	@awk -F\" ' \
2013		/^name/ { printf("===> Creating %s-", $$2); next } \
2014		/^version/ { print $$2; next } \
2015		' ${WSTAGEDIR}/${pkgname}.ucl
2016	@if [ "${pkgname}" == "runtime" ]; then \
2017		sed -i '' -e "s/%VCS_REVISION%/${VCS_REVISION}/" ${WSTAGEDIR}/${pkgname}.ucl ; \
2018	fi
2019	${PKG_CMD} -o ABI_FILE=${WSTAGEDIR}/usr/bin/uname -o ALLOW_BASE_SHLIBS=yes \
2020		create -f ${PKG_FORMAT} -M ${WSTAGEDIR}/${pkgname}.ucl \
2021		-p ${WSTAGEDIR}/${pkgname}.plist \
2022		-r ${WSTAGEDIR} \
2023		-o ${REPODIR}/${PKG_ABI}/${PKG_OUTPUT_DIR}
2024.endfor
2025
2026_default_flavor=	-default
2027.if make(*package*) && exists(${KSTAGEDIR}/kernel.meta)
2028. if ${MK_DEBUG_FILES} != "no"
2029_debug=-dbg
2030. endif
2031create-kernel-packages:	.PHONY
2032. for flavor in "" ${_debug}
2033create-kernel-packages: create-kernel-packages-flavor${flavor:C,^""$,${_default_flavor},}
2034create-kernel-packages-flavor${flavor:C,^""$,${_default_flavor},}: _pkgbootstrap .PHONY
2035	@cd ${KSTAGEDIR}/${DISTDIR} ; \
2036	env -i LC_COLLATE=C sort ${KSTAGEDIR}/kernel.meta | \
2037	awk -f ${SRCDIR}/release/scripts/mtree-to-plist.awk \
2038		-v kernel=yes -v _kernconf=${INSTALLKERNEL} ; \
2039	sed -e "s/%VERSION%/${PKG_VERSION}/" \
2040		-e "s/%PKGNAME%/kernel-${INSTALLKERNEL:tl}${flavor}/" \
2041		-e "s/%KERNELDIR%/kernel/" \
2042		-e "s/%COMMENT%/FreeBSD ${INSTALLKERNEL} kernel ${flavor}/" \
2043		-e "s/%DESC%/FreeBSD ${INSTALLKERNEL} kernel ${flavor}/" \
2044		-e "s/ %VCS_REVISION%/${VCS_REVISION}/" \
2045		-e "s/%PKG_NAME_PREFIX%/${PKG_NAME_PREFIX}/" \
2046		-e "s/%PKG_MAINTAINER%/${PKG_MAINTAINER}/" \
2047		-e "s|%PKG_WWW%|${PKG_WWW}|" \
2048		${SRCDIR}/release/packages/kernel.ucl \
2049		> ${KSTAGEDIR}/${DISTDIR}/kernel.${INSTALLKERNEL}${flavor}.ucl ; \
2050	awk -F\" ' \
2051		/name/ { printf("===> Creating %s-", $$2); next } \
2052		/version/ {print $$2; next } ' \
2053		${KSTAGEDIR}/${DISTDIR}/kernel.${INSTALLKERNEL}${flavor}.ucl ; \
2054	${PKG_CMD} -o ABI_FILE=${WSTAGEDIR}/usr/bin/uname -o ALLOW_BASE_SHLIBS=yes \
2055		create -f ${PKG_FORMAT} \
2056		-M ${KSTAGEDIR}/${DISTDIR}/kernel.${INSTALLKERNEL}${flavor}.ucl \
2057		-p ${KSTAGEDIR}/${DISTDIR}/kernel.${INSTALLKERNEL}${flavor}.plist \
2058		-r ${KSTAGEDIR}/${DISTDIR} \
2059		-o ${REPODIR}/${PKG_ABI}/${PKG_OUTPUT_DIR}
2060. endfor
2061.endif
2062.if ${BUILDKERNELS:[#]} > 1 && ${NO_INSTALLEXTRAKERNELS} != "yes"
2063. for _kernel in ${BUILDKERNELS:[2..-1]}
2064.  if exists(${KSTAGEDIR}/kernel.${_kernel}.meta)
2065.   if ${MK_DEBUG_FILES} != "no"
2066_debug=-dbg
2067.   endif
2068.   for flavor in "" ${_debug}
2069create-kernel-packages: create-kernel-packages-extra-flavor${flavor:C,^""$,${_default_flavor},}-${_kernel}
2070create-kernel-packages-extra-flavor${flavor:C,^""$,${_default_flavor},}-${_kernel}: _pkgbootstrap .PHONY
2071	@cd ${KSTAGEDIR}/kernel.${_kernel} ; \
2072	env -i LC_COLLATE=C sort ${KSTAGEDIR}/kernel.${_kernel}.meta | \
2073	awk -f ${SRCDIR}/release/scripts/mtree-to-plist.awk \
2074		-v kernel=yes -v _kernconf=${_kernel} ; \
2075	sed -e "s/%VERSION%/${PKG_VERSION}/" \
2076		-e "s/%PKGNAME%/kernel-${_kernel:tl}${flavor}/" \
2077		-e "s/%KERNELDIR%/kernel.${_kernel}/" \
2078		-e "s/%COMMENT%/FreeBSD ${_kernel} kernel ${flavor}/" \
2079		-e "s/%DESC%/FreeBSD ${_kernel} kernel ${flavor}/" \
2080		-e "s/ %VCS_REVISION%/${VCS_REVISION}/" \
2081		-e "s/%PKG_NAME_PREFIX%/${PKG_NAME_PREFIX}/" \
2082		-e "s/%PKG_MAINTAINER%/${PKG_MAINTAINER}/" \
2083		-e "s|%PKG_WWW%|${PKG_WWW}|" \
2084		${SRCDIR}/release/packages/kernel.ucl \
2085		> ${KSTAGEDIR}/kernel.${_kernel}/kernel.${_kernel}${flavor}.ucl ; \
2086	awk -F\" ' \
2087		/name/ { printf("===> Creating %s-", $$2); next } \
2088		/version/ {print $$2; next } ' \
2089		${KSTAGEDIR}/kernel.${_kernel}/kernel.${_kernel}${flavor}.ucl ; \
2090	${PKG_CMD} -o ABI_FILE=${WSTAGEDIR}/usr/bin/uname -o ALLOW_BASE_SHLIBS=yes \
2091		create -f ${PKG_FORMAT} \
2092		-M ${KSTAGEDIR}/kernel.${_kernel}/kernel.${_kernel}${flavor}.ucl \
2093		-p ${KSTAGEDIR}/kernel.${_kernel}/kernel.${_kernel}${flavor}.plist \
2094		-r ${KSTAGEDIR}/kernel.${_kernel} \
2095		-o ${REPODIR}/${PKG_ABI}/${PKG_OUTPUT_DIR}
2096.   endfor
2097.  endif
2098. endfor
2099.endif
2100
2101sign-packages:	_pkgbootstrap .PHONY
2102	printf "version = 2;\n" > ${WSTAGEDIR}/meta
2103.if ${PKG_BIN_VERSION} < 11700
2104	printf "packing_format = \"${PKG_FORMAT}\";\n" >> ${WSTAGEDIR}/meta
2105.endif
2106	@[ -L "${REPODIR}/$$(${PKG_CMD} -o ABI_FILE=${WSTAGEDIR}/usr/bin/uname config ABI)/latest" ] && \
2107		unlink ${REPODIR}/$$(${PKG_CMD} -o ABI_FILE=${WSTAGEDIR}/usr/bin/uname config ABI)/latest ; \
2108	${PKG_CMD} -o ABI_FILE=${WSTAGEDIR}/usr/bin/uname repo \
2109		-m ${WSTAGEDIR}/meta \
2110		-o ${REPODIR}/$$(${PKG_CMD} -o ABI_FILE=${WSTAGEDIR}/usr/bin/uname config ABI)/${PKG_VERSION} \
2111		${REPODIR}/$$(${PKG_CMD} -o ABI_FILE=${WSTAGEDIR}/usr/bin/uname config ABI)/${PKG_VERSION} \
2112		${PKG_REPO_SIGNING_KEY} ; \
2113	cd ${REPODIR}/$$(${PKG_CMD} -o ABI_FILE=${WSTAGEDIR}/usr/bin/uname config ABI); \
2114	ln -s ${PKG_OUTPUT_DIR} latest
2115
2116#
2117#
2118# checkworld
2119#
2120# Run test suite on installed world.
2121#
2122checkworld: .PHONY
2123	@if [ ! -x "${LOCALBASE}/bin/kyua" ] && [ ! -x "/usr/bin/kyua" ]; then \
2124		echo "You need kyua (devel/kyua) to run the test suite." | /usr/bin/fmt; \
2125		exit 1; \
2126	fi
2127	${_+_}PATH="$$PATH:${LOCALBASE}/bin" kyua test -k ${TESTSBASE}/Kyuafile
2128
2129#
2130#
2131# doxygen
2132#
2133# Build the API documentation with doxygen
2134#
2135doxygen: .PHONY
2136	@if [ ! -x "${LOCALBASE}/bin/doxygen" ]; then \
2137		echo "You need doxygen (devel/doxygen) to generate the API documentation of the kernel." | /usr/bin/fmt; \
2138		exit 1; \
2139	fi
2140	${_+_}cd ${.CURDIR}/tools/kerneldoc/subsys; ${MAKE} obj all
2141
2142#
2143# ------------------------------------------------------------------------
2144#
2145# From here onwards are utility targets used by the 'make world' and
2146# related targets.  If your 'world' breaks, you may like to try to fix
2147# the problem and manually run the following targets to attempt to
2148# complete the build.  Beware, this is *not* guaranteed to work, you
2149# need to have a pretty good grip on the current state of the system
2150# to attempt to manually finish it.  If in doubt, 'make world' again.
2151#
2152
2153#
2154# legacy: Build compatibility shims for the next three targets. This is a
2155# minimal set of tools and shims necessary to compensate for older systems
2156# which don't have the APIs required by the targets built in bootstrap-tools,
2157# build-tools or cross-tools.
2158#
2159legacy: .PHONY
2160.if ${BOOTSTRAPPING} < ${MINIMUM_SUPPORTED_OSREL} && ${BOOTSTRAPPING} != 0
2161	@echo "ERROR: Source upgrades from versions prior to ${MINIMUM_SUPPORTED_REL} are not supported."; \
2162	false
2163.endif
2164
2165.for _tool in \
2166  tools/build \
2167  ${LOCAL_LEGACY_DIRS}
2168	${_+_}@${ECHODIR} "===> ${_tool} (obj,includes,all,install)"; \
2169	    cd ${.CURDIR}/${_tool}; \
2170	    if [ -z "${NO_OBJWALK}" ]; then ${MAKE} DIRPRFX=${_tool}/ obj; fi; \
2171	    ${MAKE} DIRPRFX=${_tool}/ DESTDIR=${WORLDTMP}/legacy includes; \
2172	    ${MAKE} DIRPRFX=${_tool}/ MK_INCLUDES=no all; \
2173	    ${MAKE} DIRPRFX=${_tool}/ MK_INCLUDES=no \
2174	        DESTDIR=${WORLDTMP}/legacy install
2175.endfor
2176
2177#
2178# bootstrap-tools: Build tools needed for compatibility. These are binaries that
2179# are built to build other binaries in the system. However, the focus of these
2180# binaries is usually quite narrow. Bootstrap tools use the host's compiler and
2181# libraries, augmented by -legacy, in addition to the libraries built during
2182# bootstrap-tools.
2183#
2184_bt=		_bootstrap-tools
2185
2186# We want to run the build with only ${WORLDTMP} in $PATH to ensure we don't
2187# accidentally run tools that are incompatible but happen to be in $PATH.
2188# This is especially important when building on Linux/MacOS where many of the
2189# programs used during the build accept different flags or generate different
2190# output. On those platforms we only symlink the tools known to be compatible
2191# (e.g. basic utilities such as mkdir) into ${WORLDTMP} and build all others
2192# from the FreeBSD sources during the bootstrap-tools stage.
2193# We want to build without the user's $PATH starting in the bootstrap-tools
2194# phase so the tools used in that phase (ln, cp, etc) must have already been
2195# linked to $WORLDTMP. The tools are listed in the _host_tools_to_symlink
2196# variable in tools/build/Makefile and are linked during the legacy phase.
2197# Since they could be Linux or MacOS binaries, too we must only use flags that
2198# are portable across operating systems.
2199
2200# If BOOTSTRAP_ALL_TOOLS is set we will build all the required tools from the
2201# current source tree. Otherwise we create a symlink to the version found in
2202# $PATH during the bootstrap-tools stage.
2203# When building on non-FreeBSD systems we can't assume that the host binaries
2204# accept compatible flags or produce compatible output. Therefore we force
2205# BOOTSTRAP_ALL_TOOLS and just build the FreeBSD version of the binary.
2206.if defined(CROSSBUILD_HOST)
2207BOOTSTRAP_ALL_TOOLS:=	1
2208.endif
2209.if defined(BOOTSTRAP_ALL_TOOLS)
2210# BOOTSTRAPPING will be set on the command line so we can't override it here.
2211# Instead set BOOTSTRAPPING_OSRELDATE so that the value 0 is set ${BSARGS}
2212BOOTSTRAPPING_OSRELDATE:=	0
2213.endif
2214
2215# libnv and libsbuf are requirements for config(8), which is an unconditional
2216# bootstrap-tool.
2217_config=usr.sbin/config lib/libnv lib/libsbuf
2218${_bt}-usr.sbin/config: ${_bt}-lib/libnv ${_bt}-lib/libsbuf
2219
2220.if ${MK_GAMES} != "no"
2221_strfile=	usr.bin/fortune/strfile
2222.endif
2223
2224# vtfontcvt is used to build font files for loader and to generate
2225# C source for loader built in font (8x16.c).
2226_vtfontcvt=	usr.bin/vtfontcvt
2227
2228# If we are not building the bootstrap because BOOTSTRAPPING is sufficient
2229# we symlink the host version to $WORLDTMP instead. By doing this we can also
2230# detect when a bootstrap tool is being used without the required MK_FOO.
2231# If you add a new bootstrap tool where we could also use the host version,
2232# please ensure that you also add a .else case where you add the tool to the
2233# _bootstrap_tools_links variable.
2234.if ${BOOTSTRAPPING} < 1000033
2235# Note: lex needs m4 to build but m4 also depends on lex (which needs m4 to
2236# generate any files). To fix this cyclic dependency we can build a bootstrap
2237# version of m4 (with pre-generated files) then use that to build the real m4.
2238# We can't simply use the host m4 since e.g. the macOS version does not accept
2239# the flags that are passed by lex.
2240# For lex we also use the pre-gerated files since we would otherwise need to
2241# build awk and sed first (which need lex to build)
2242# TODO: add a _bootstrap_lex and then build the real lex afterwards
2243_lex=		usr.bin/lex
2244_m4=		tools/build/bootstrap-m4 usr.bin/m4
2245${_bt}-tools/build/bootstrap-m4: ${_bt}-usr.bin/lex ${_bt}-lib/libopenbsd ${_bt}-usr.bin/yacc
2246${_bt}-usr.bin/m4: ${_bt}-lib/libopenbsd ${_bt}-usr.bin/yacc ${_bt}-usr.bin/lex ${_bt}-tools/build/bootstrap-m4
2247_bt_m4_depend=${_bt}-usr.bin/m4
2248_bt_lex_depend=${_bt}-usr.bin/lex ${_bt_m4_depend}
2249.else
2250_bootstrap_tools_links+=m4 lex
2251.endif
2252
2253# ELF Tool Chain libraries are needed for ELF tools and dtrace tools.
2254# r296685 fix cross-endian objcopy
2255# r310724 fixed PR 215350, a crash in libdwarf with objects built by GCC 6.2.
2256# r334881 added libdwarf constants used by ctfconvert.
2257# r338478 fixed a crash in objcopy for mips64el objects
2258# r339083 libelf: correct mips64el test to use ELF header
2259# r348347 Add missing powerpc64 relocation support to libdwarf
2260.if ${BOOTSTRAPPING} < 1300030
2261_elftoolchain_libs= lib/libelf lib/libdwarf lib/libzstd
2262${_bt}-lib/libelf: ${_bt_m4_depend}
2263${_bt}-lib/libdwarf: ${_bt_m4_depend}
2264.endif
2265
2266# flua is required to regenerate syscall files.  It first appeared during the
2267# 13.0-CURRENT cycle, thus needs to be built on -older releases and stable
2268# branches.
2269.if ${BOOTSTRAPPING} < 1300059
2270${_bt}-libexec/flua: ${_bt}-lib/liblua ${_bt}-lib/libucl
2271_flua= lib/liblua lib/libucl libexec/flua
2272.endif
2273
2274# r245440 mtree -N support added
2275# r313404 requires sha384.h for libnetbsd, added to libmd in r292782
2276.if ${BOOTSTRAPPING} < 1100093
2277_nmtree=	lib/libmd \
2278		lib/libnetbsd \
2279		usr.sbin/nmtree
2280
2281${_bt}-lib/libnetbsd: ${_bt}-lib/libmd
2282${_bt}-usr.sbin/nmtree: ${_bt}-lib/libnetbsd
2283.else
2284_bootstrap_tools_links+=mtree
2285.endif
2286
2287# r246097: log addition login.conf.db, passwd, pwd.db, and spwd.db with cat -l
2288.if ${BOOTSTRAPPING} < 1000027
2289_cat=		bin/cat
2290.else
2291_bootstrap_tools_links+=cat
2292.endif
2293
2294# r277259 crunchide: Correct 64-bit section header offset
2295# r281674 crunchide: always include both 32- and 64-bit ELF support
2296.if ${BOOTSTRAPPING} < 1100078
2297_crunchide=	usr.sbin/crunch/crunchide
2298.else
2299_bootstrap_tools_links+=crunchide
2300.endif
2301
2302# 1300115: Higher WARNS fixes
2303.if ${BOOTSTRAPPING} < 1202502 || \
2304	(${BOOTSTRAPPING} > 1300000 && ${BOOTSTRAPPING} < 1300131)
2305_crunchgen=	usr.sbin/crunch/crunchgen
2306.else
2307_bootstrap_tools_links+=crunchgen
2308.endif
2309
2310# r296926 -P keymap search path, MFC to stable/10 in r298297
2311# Note: kbdcontrol can not be bootstrapped on non-FreeBSD systems
2312.if !defined(CROSSBUILD_HOST)
2313.if (${BOOTSTRAPPING} < 1003501 || \
2314	(${BOOTSTRAPPING} >= 1100000 && ${BOOTSTRAPPING} < 1100103) || \
2315	(!exists(/usr/sbin/kbdcontrol)))
2316_kbdcontrol=	usr.sbin/kbdcontrol
2317.else
2318_bootstrap_tools_links+=kbdcontrol
2319.endif
2320.endif
2321
2322# 1300102: VHDX support
2323.if ${BOOTSTRAPPING} < 1201520 || \
2324	(${BOOTSTRAPPING} > 1300000 && ${BOOTSTRAPPING} < 1300102)
2325_mkimg=	usr.bin/mkimg
2326.else
2327_bootstrap_tools_links+=mkimg
2328.endif
2329
2330_yacc=		usr.bin/yacc
2331
2332.if ${MK_BSNMP} != "no"
2333_gensnmptree=	usr.sbin/bsnmpd/gensnmptree
2334.endif
2335
2336
2337# We need to build tblgen when we're building clang or lld, either as
2338# bootstrap tools, or as the part of the normal build.
2339# llvm-tblgen is also needed for various llvm binutils (e.g. objcopy).
2340.if ${MK_CLANG_BOOTSTRAP} != "no" || ${MK_CLANG} != "no" || \
2341    ${MK_LLD_BOOTSTRAP} != "no" || ${MK_LLD} != "no" || \
2342    ${MK_LLDB} != "no" || ${MK_LLVM_BINUTILS} != "no"
2343_clang_tblgen= \
2344	lib/clang/libllvmminimal \
2345	usr.bin/clang/llvm-tblgen
2346.if ${MK_CLANG_BOOTSTRAP} != "no" || ${MK_CLANG} != "no"
2347_clang_tblgen+=	usr.bin/clang/clang-tblgen
2348.endif
2349.if ${MK_LLDB} != "no"
2350_clang_tblgen+=	usr.bin/clang/lldb-tblgen
2351.endif
2352${_bt}-usr.bin/clang/clang-tblgen: ${_bt}-lib/clang/libllvmminimal
2353${_bt}-usr.bin/clang/llvm-tblgen: ${_bt}-lib/clang/libllvmminimal
2354${_bt}-usr.bin/clang/lldb-tblgen: ${_bt}-lib/clang/libllvmminimal
2355.endif
2356
2357# C.UTF-8 is always built in share/ctypes and we need localedef for that.
2358_localedef=	usr.bin/localedef
2359${_bt}-usr.bin/localedef: ${_bt}-usr.bin/yacc ${_bt_lex_depend}
2360
2361.if ${MK_ICONV} != "no"
2362_mkesdb=	usr.bin/mkesdb
2363_mkcsmapper=	usr.bin/mkcsmapper
2364${_bt}-usr.bin/mkesdb: ${_bt}-usr.bin/yacc ${_bt_lex_depend}
2365${_bt}-usr.bin/mkcsmapper: ${_bt}-usr.bin/yacc ${_bt_lex_depend}
2366.endif
2367
2368.if ${MK_KERBEROS} != "no"
2369_kerberos5_bootstrap_tools= \
2370	kerberos5/tools/make-roken \
2371	kerberos5/lib/libroken \
2372	kerberos5/lib/libvers \
2373	kerberos5/tools/asn1_compile \
2374	kerberos5/tools/slc \
2375	usr.bin/compile_et
2376
2377.ORDER: ${_kerberos5_bootstrap_tools:C/^/${_bt}-/g}
2378.for _tool in ${_kerberos5_bootstrap_tools}
2379${_bt}-${_tool}: ${_bt}-usr.bin/yacc ${_bt_lex_depend}
2380.endfor
2381.endif
2382
2383${_bt}-usr.bin/mandoc: ${_bt}-lib/libopenbsd
2384
2385# The tools listed in _basic_bootstrap_tools will generally not be
2386# bootstrapped unless BOOTSTRAP_ALL_TOOL is set. However, when building on a
2387# Linux or MacOS host the host versions are incompatible so we need to build
2388# them from the source tree. Usually the link name will be the same as the subdir,
2389# but some directories such as grep or test install multiple binaries. In that
2390# case we use the _basic_bootstrap_tools_multilink variable which is a list of
2391# subdirectory and comma-separated list of files.
2392_basic_bootstrap_tools_multilink=usr.bin/grep grep,egrep,fgrep
2393_basic_bootstrap_tools_multilink+=bin/test test,[
2394# bootstrap tools needed by buildworld:
2395_basic_bootstrap_tools+=usr.bin/cut bin/expr usr.bin/gencat usr.bin/join \
2396    usr.bin/mktemp bin/realpath bin/rmdir usr.bin/sed usr.bin/sort \
2397    usr.bin/truncate usr.bin/tsort
2398# Some build scripts use nawk instead of awk (this happens at least in
2399# cddl/contrib/opensolaris/lib/libdtrace/common/mknames.sh) so we need both awk
2400# and nawk in ${WORLDTMP}/legacy/bin.
2401_basic_bootstrap_tools_multilink+=usr.bin/awk awk,nawk
2402# file2c is required for building usr.sbin/config:
2403_basic_bootstrap_tools+=usr.bin/file2c
2404# uuencode/uudecode required for share/tabset
2405_basic_bootstrap_tools+=usr.bin/uuencode usr.bin/uudecode
2406# xargs is required by mkioctls
2407_basic_bootstrap_tools+=usr.bin/xargs
2408# cap_mkdb is required for share/termcap:
2409_basic_bootstrap_tools+=usr.bin/cap_mkdb
2410# services_mkdb/pwd_mkdb are required for installworld:
2411_basic_bootstrap_tools+=usr.sbin/services_mkdb usr.sbin/pwd_mkdb
2412# ldd is required for installcheck (TODO: just always use /usr/bin/ldd instead?)
2413.if !defined(CROSSBUILD_HOST)
2414# ldd is only needed for updating the running system so we don't need to
2415# bootstrap ldd on non-FreeBSD systems
2416_basic_bootstrap_tools+=usr.bin/ldd
2417.endif
2418# sysctl/chflags are required for installkernel:
2419.if !defined(CROSSBUILD_HOST)
2420_basic_bootstrap_tools+=bin/chflags
2421# Note: sysctl does not bootstrap on FreeBSD < 13 anymore, but that doesn't
2422# matter since we don't need any of the new features for the build.
2423_bootstrap_tools_links+=sysctl
2424.else
2425# When building on non-FreeBSD, install a fake chflags instead since the
2426# version from the source tree cannot work. We also don't need sysctl since we
2427# are install with -DNO_ROOT.
2428_other_bootstrap_tools+=tools/build/cross-build/fake_chflags
2429.endif
2430# mkfifo is used by sys/conf/newvers.sh
2431_basic_bootstrap_tools+=usr.bin/mkfifo
2432# jot is needed for the mkimg tests
2433_basic_bootstrap_tools+=usr.bin/jot
2434
2435.if ${MK_BOOT} != "no"
2436# md5 is used by boot/beri (and possibly others)
2437_basic_bootstrap_tools+=sbin/md5
2438.endif
2439
2440.if ${MK_ZONEINFO} != "no"
2441_basic_bootstrap_tools+=usr.sbin/zic usr.sbin/tzsetup
2442.endif
2443
2444.if defined(BOOTSTRAP_ALL_TOOLS)
2445_other_bootstrap_tools+=${_basic_bootstrap_tools}
2446.for _subdir _links in ${_basic_bootstrap_tools_multilink}
2447_other_bootstrap_tools+=${_subdir}
2448.endfor
2449${_bt}-usr.bin/awk: ${_bt_lex_depend} ${_bt}-usr.bin/yacc
2450${_bt}-bin/expr: ${_bt_lex_depend} ${_bt}-usr.bin/yacc
2451# If we are bootstrapping file2c, we have to build it before config:
2452${_bt}-usr.sbin/config: ${_bt}-usr.bin/file2c ${_bt_lex_depend}
2453# Note: no symlink to make/bmake in the !BOOTSTRAP_ALL_TOOLS case here since
2454# the links to make/bmake make links will have already have been created in the
2455# `make legacy` step. Not adding a link to make is important on non-FreeBSD
2456# since "make" will usually point to GNU make there.
2457_other_bootstrap_tools+=usr.bin/bmake
2458
2459# Avoid dependency on host bz2 headers:
2460_other_bootstrap_tools+=lib/libbz2
2461${_bt}-usr.bin/grep: ${_bt}-lib/libbz2
2462.else
2463# All tools in _basic_bootstrap_tools have the same name as the subdirectory
2464# so we can use :T to get the name of the symlinks that we need to create.
2465_bootstrap_tools_links+=${_basic_bootstrap_tools:T}
2466.for _subdir _links in ${_basic_bootstrap_tools_multilink}
2467_bootstrap_tools_links+=${_links:S/,/ /g}
2468.endfor
2469.endif	# defined(BOOTSTRAP_ALL_TOOLS)
2470
2471# Link the tools that we need for building but don't need to bootstrap because
2472# the host version is known to be compatible into ${WORLDTMP}/legacy
2473# We do this before building any of the bootstrap tools in case they depend on
2474# the presence of any of the links (e.g. as m4/lex/awk)
2475${_bt}-links: .PHONY
2476
2477.for _tool in ${_bootstrap_tools_links}
2478${_bt}-link-${_tool}: .PHONY
2479	@rm -f "${WORLDTMP}/legacy/bin/${_tool}"; \
2480	source_path=`which ${_tool}`; \
2481	if [ ! -e "$${source_path}" ] ; then \
2482		echo "Cannot find host tool '${_tool}'"; false; \
2483	fi; \
2484	cp -pf "$${source_path}" "${WORLDTMP}/legacy/bin/${_tool}"
2485${_bt}-links: ${_bt}-link-${_tool}
2486.endfor
2487
2488bootstrap-tools: ${_bt}-links .PHONY
2489
2490#	Please document (add comment) why something is in 'bootstrap-tools'.
2491#	Try to bound the building of the bootstrap-tool to just the
2492#	FreeBSD versions that need the tool built at this stage of the build.
2493.for _tool in \
2494    ${_clang_tblgen} \
2495    ${_kerberos5_bootstrap_tools} \
2496    ${_strfile} \
2497    usr.bin/dtc \
2498    ${_cat} \
2499    ${_kbdcontrol} \
2500    ${_elftoolchain_libs} \
2501    lib/libopenbsd \
2502    usr.bin/mandoc \
2503    usr.bin/rpcgen \
2504    ${_yacc} \
2505    ${_m4} \
2506    ${_lex} \
2507    ${_other_bootstrap_tools} \
2508    usr.bin/xinstall \
2509    ${_gensnmptree} \
2510    ${_config} \
2511    ${_flua} \
2512    ${_crunchide} \
2513    ${_crunchgen} \
2514    ${_mkimg} \
2515    ${_nmtree} \
2516    ${_vtfontcvt} \
2517    ${_localedef} \
2518    ${_mkcsmapper} \
2519    ${_mkesdb} \
2520    ${LOCAL_BSTOOL_DIRS}
2521${_bt}-${_tool}: ${_bt}-links .PHONY .MAKE
2522	${_+_}@${ECHODIR} "===> ${_tool} (obj,all,install)"; \
2523		cd ${.CURDIR}/${_tool}; \
2524		if [ -z "${NO_OBJWALK}" ]; then ${MAKE} DIRPRFX=${_tool}/ obj; fi; \
2525		if [ "${_tool}" = "usr.bin/lex" ]; then \
2526			${MAKE} DIRPRFX=${_tool}/ bootstrap; \
2527		fi; \
2528		${MAKE} DIRPRFX=${_tool}/ all; \
2529		${MAKE} DIRPRFX=${_tool}/ DESTDIR=${WORLDTMP}/legacy install
2530
2531bootstrap-tools: ${_bt}-${_tool}
2532.endfor
2533.if target(${_bt}-lib/libmd)
2534# If we are bootstrapping libmd (e.g. when building on macOS/Linux) add the
2535# necessary dependencies:
2536${_bt}-usr.bin/sort: ${_bt}-lib/libmd
2537${_bt}-usr.bin/xinstall: ${_bt}-lib/libmd
2538${_bt}-sbin/md5: ${_bt}-lib/libmd
2539.endif
2540
2541
2542#
2543# build-tools: Build special purpose build tools
2544#
2545.if !defined(NO_SHARE) && ${MK_SYSCONS} != "no"
2546_share=	share/syscons/scrnmaps
2547.endif
2548
2549.if ${MK_RESCUE} != "no"
2550# rescue includes programs that have build-tools targets
2551_rescue=rescue/rescue
2552.endif
2553
2554.if ${MK_TCSH} != "no"
2555_tcsh=bin/csh
2556.endif
2557.if ${MK_FILE} != "no"
2558_libmagic=lib/libmagic
2559.endif
2560
2561.if ${MK_PMC} != "no"
2562_jevents=lib/libpmc/pmu-events
2563.endif
2564
2565# kernel-toolchain skips _cleanobj, so handle cleaning up previous
2566# build-tools directories if needed.
2567.if ${MK_CLEAN} == "yes" && make(kernel-toolchain)
2568_bt_clean=	${CLEANDIR}
2569.endif
2570
2571.for _tool in \
2572    ${_tcsh} \
2573    bin/sh \
2574    ${LOCAL_TOOL_DIRS} \
2575    ${_jevents} \
2576    lib/ncurses/tinfo \
2577    ${_rescue} \
2578    ${_share} \
2579    usr.bin/awk \
2580    ${_libmagic} \
2581    usr.bin/vi/catalog
2582build-tools_${_tool}: .PHONY
2583	${_+_}@${ECHODIR} "===> ${_tool} (${_bt_clean:D${_bt_clean},}obj,build-tools)"; \
2584		cd ${.CURDIR}/${_tool}; \
2585		if [ -n "${_bt_clean}" ]; then ${MAKE} DIRPRFX=${_tool}/ ${_bt_clean}; fi; \
2586		if [ -z "${NO_OBJWALK}" ]; then ${MAKE} DIRPRFX=${_tool}/ obj; fi; \
2587		${MAKE} DIRPRFX=${_tool}/ build-tools
2588build-tools: build-tools_${_tool}
2589.endfor
2590
2591#
2592# kernel-tools: Build kernel-building tools
2593#
2594kernel-tools: .PHONY
2595	mkdir -p ${WORLDTMP}/usr
2596	${WORLDTMP_MTREE} -f ${.CURDIR}/etc/mtree/BSD.usr.dist \
2597	    -p ${WORLDTMP}/usr >/dev/null
2598
2599#
2600# cross-tools: All the tools needed to build the rest of the system after
2601# we get done with the earlier stages. It is the last set of tools needed
2602# to begin building the target binaries.
2603#
2604.if ${TARGET_ARCH} != ${MACHINE_ARCH} || ${BUILD_WITH_STRICT_TMPPATH} != 0
2605.if ${TARGET_ARCH} == "amd64" || ${TARGET_ARCH} == "i386"
2606_btxld=		usr.sbin/btxld
2607.endif
2608.endif
2609
2610# Rebuild ctfconvert and ctfmerge to avoid difficult-to-diagnose failures
2611# resulting from missing bug fixes or ELF Toolchain updates.
2612.if ${MK_CDDL} != "no"
2613_dtrace_tools= cddl/lib/libctf cddl/lib/libspl cddl/usr.bin/ctfconvert \
2614    cddl/usr.bin/ctfmerge
2615.endif
2616
2617# If we're given an XAS, don't build binutils.
2618.if ${XAS:M/*} == ""
2619.if ${MK_ELFTOOLCHAIN_BOOTSTRAP} != "no"
2620_elftctools=	lib/libelftc \
2621		lib/libpe \
2622		usr.bin/elfctl \
2623		usr.bin/objcopy \
2624		usr.bin/nm \
2625		usr.bin/size \
2626		usr.bin/strings
2627# These are not required by the build, but can be useful for developers who
2628# cross-build on a FreeBSD 10 host:
2629_elftctools+=	usr.bin/addr2line
2630.endif
2631.elif ${TARGET_ARCH} != ${MACHINE_ARCH} && ${MK_ELFTOOLCHAIN_BOOTSTRAP} != "no"
2632# If cross-building with an external binutils we still need to build strip for
2633# the target (for at least crunchide).
2634_elftctools=	lib/libelftc \
2635		lib/libpe \
2636		usr.bin/elfctl \
2637		usr.bin/objcopy
2638.endif
2639
2640.if ${MK_CLANG_BOOTSTRAP} != "no"
2641_clang=		usr.bin/clang
2642.endif
2643.if ${MK_LLD_BOOTSTRAP} != "no"
2644_lld=		usr.bin/clang/lld
2645.endif
2646.if ${MK_CLANG_BOOTSTRAP} != "no" || ${MK_LLD_BOOTSTRAP} != "no"
2647_clang_libs=	lib/clang
2648.endif
2649.if ${MK_USB} != "no"
2650_usb_tools=	stand/usb/tools
2651.endif
2652
2653.if ${BUILD_WITH_STRICT_TMPPATH} != 0 || defined(BOOTSTRAP_ALL_TOOLS)
2654_ar=usr.bin/ar
2655.endif
2656
2657cross-tools: .MAKE .PHONY
2658.for _tool in \
2659    ${LOCAL_XTOOL_DIRS} \
2660    ${_ar} \
2661    ${_clang_libs} \
2662    ${_clang} \
2663    ${_lld} \
2664    ${_elftctools} \
2665    ${_dtrace_tools} \
2666    ${_btxld} \
2667    ${_usb_tools}
2668	${_+_}@${ECHODIR} "===> ${_tool} (obj,all,install)"; \
2669		cd ${.CURDIR}/${_tool}; \
2670		if [ -z "${NO_OBJWALK}" ]; then ${MAKE} DIRPRFX=${_tool}/ obj; fi; \
2671		${MAKE} DIRPRFX=${_tool}/ all; \
2672		${MAKE} DIRPRFX=${_tool}/ DESTDIR=${WORLDTMP} install
2673.endfor
2674
2675#
2676# native-xtools is the current target for qemu-user cross builds of ports
2677# via poudriere and the imgact_binmisc kernel module.
2678# This target merely builds a toolchan/sysroot, then builds the tools it wants
2679# with the options it wants in a special MAKEOBJDIRPREFIX, using the toolchain
2680# already built.  It then installs the static tools to NXBDESTDIR for Poudriere
2681# to pickup.
2682#
2683NXBOBJROOT=	${OBJROOT}${MACHINE}.${MACHINE_ARCH}/nxb/
2684NXBOBJTOP=	${NXBOBJROOT}${NXB_TARGET}.${NXB_TARGET_ARCH}
2685NXTP?=		/nxb-bin
2686.if ${NXTP:N/*}
2687.error NXTP variable should be an absolute path
2688.endif
2689NXBDESTDIR?=	${DESTDIR}${NXTP}
2690
2691# This is the list of tools to be built/installed as static and where
2692# appropriate to build for the given TARGET.TARGET_ARCH.
2693NXBDIRS+= \
2694    bin/cat \
2695    bin/chmod \
2696    bin/cp \
2697    ${_tcsh} \
2698    bin/echo \
2699    bin/expr \
2700    bin/hostname \
2701    bin/ln \
2702    bin/ls \
2703    bin/mkdir \
2704    bin/mv \
2705    bin/ps \
2706    bin/realpath \
2707    bin/rm \
2708    bin/rmdir \
2709    bin/sh \
2710    bin/sleep \
2711    sbin/md5 \
2712    sbin/sysctl \
2713    usr.bin/addr2line \
2714    usr.bin/ar \
2715    usr.bin/awk \
2716    usr.bin/basename \
2717    usr.bin/bmake \
2718    usr.bin/bzip2 \
2719    usr.bin/cmp \
2720    usr.bin/diff \
2721    usr.bin/dirname \
2722    usr.bin/objcopy \
2723    usr.bin/env \
2724    usr.bin/fetch \
2725    usr.bin/find \
2726    usr.bin/grep \
2727    usr.bin/gzip \
2728    usr.bin/head \
2729    usr.bin/id \
2730    usr.bin/lex \
2731    usr.bin/limits \
2732    usr.bin/mandoc \
2733    usr.bin/mktemp \
2734    usr.bin/mt \
2735    usr.bin/nm \
2736    usr.bin/patch \
2737    usr.bin/readelf \
2738    usr.bin/sed \
2739    usr.bin/size \
2740    usr.bin/sort \
2741    usr.bin/strings \
2742    usr.bin/tar \
2743    usr.bin/touch \
2744    usr.bin/tr \
2745    usr.bin/true \
2746    usr.bin/uniq \
2747    usr.bin/unzip \
2748    usr.bin/wc \
2749    usr.bin/xargs \
2750    usr.bin/xinstall \
2751    usr.bin/xz \
2752    usr.bin/yacc \
2753    usr.sbin/chown
2754
2755SUBDIR_DEPEND_usr.bin/clang=	lib/clang
2756.if ${MK_CLANG} != "no"
2757NXBDIRS+=	lib/clang
2758NXBDIRS+=	usr.bin/clang
2759.endif
2760# XXX: native-xtools passes along ${NXBDIRS} in SUBDIR_OVERRIDE that needs
2761# to be evaluated after NXBDIRS is set.
2762.if make(install) && !empty(SUBDIR_OVERRIDE)
2763SUBDIR=	${SUBDIR_OVERRIDE}
2764.endif
2765
2766NXBMAKEARGS+= \
2767	OBJTOP=${NXBOBJTOP:Q} \
2768	OBJROOT=${NXBOBJROOT:Q} \
2769	-DNO_SHARED \
2770	-DNO_CPU_CFLAGS \
2771	-DNO_PIC \
2772	MK_CASPER=no \
2773	MK_CLANG_EXTRAS=no \
2774	MK_CLANG_FORMAT=no \
2775	MK_CLANG_FULL=no \
2776	MK_CTF=no \
2777	MK_DEBUG_FILES=no \
2778	MK_HTML=no \
2779	MK_LLDB=no \
2780	MK_MAN=no \
2781	MK_MAN_UTILS=yes \
2782	MK_OFED=no \
2783	MK_OPENSSH=no \
2784	MK_PROFILE=no \
2785	MK_RETPOLINE=no \
2786	MK_SENDMAIL=no \
2787	MK_SSP=no \
2788	MK_TESTS=no \
2789	MK_WERROR=no \
2790	MK_ZFS=no
2791
2792NXBMAKEENV+= \
2793	MAKEOBJDIRPREFIX=
2794
2795# This should match all of the knobs in lib/Makefile that it takes to avoid
2796# descending into lib/clang!
2797NXBTNOTOOLS=	MK_CLANG=no MK_LLD=no MK_LLDB=no MK_LLVM_BINUTILS=no
2798
2799.if make(native-xtools*) && \
2800    (!defined(NXB_TARGET) || !defined(NXB_TARGET_ARCH))
2801.error Missing NXB_TARGET / NXB_TARGET_ARCH
2802.endif
2803# For 'toolchain' we want to produce native binaries that themselves generate
2804# native binaries.
2805NXBTMAKE=	${NXBMAKEENV} ${MAKE} ${NXBMAKEARGS:N-DNO_PIC:N-DNO_SHARED} \
2806		TARGET=${MACHINE} TARGET_ARCH=${MACHINE_ARCH}
2807# For 'everything' we want to produce native binaries (hence -target to
2808# be MACHINE) that themselves generate TARGET.TARGET_ARCH binaries.
2809# TARGET/TARGET_ARCH are still passed along from user.
2810#
2811# Use the toolchain we create as an external toolchain.
2812.if ${USING_SYSTEM_COMPILER} == "yes" || ${XCC:N${CCACHE_BIN}:M/*}
2813NXBMAKE+=	XCC="${XCC}" \
2814		XCXX="${XCXX}" \
2815		XCPP="${XCPP}"
2816.else
2817NXBMAKE+=	XCC="${NXBOBJTOP}/tmp/usr/bin/cc" \
2818		XCXX="${NXBOBJTOP}/tmp/usr/bin/c++" \
2819		XCPP="${NXBOBJTOP}/tmp/usr/bin/cpp"
2820.endif
2821NXBMAKE+=	${NXBMAKEENV} ${MAKE} -f Makefile.inc1 ${NXBMAKEARGS} \
2822		MACHINE=${MACHINE} MACHINE_ARCH=${MACHINE_ARCH} \
2823		TARGET=${NXB_TARGET} TARGET_ARCH=${NXB_TARGET_ARCH} \
2824		TARGET_TRIPLE=${MACHINE_TRIPLE:Q}
2825# NXBDIRS is improperly based on MACHINE rather than NXB_TARGET.  Need to
2826# invoke a sub-make to reevaluate MK_CLANG, etc, for NXBDIRS.
2827NXBMAKE+=	SUBDIR_OVERRIDE='$${NXBDIRS:M*}'
2828# Need to avoid the -isystem logic when using clang as an external toolchain
2829# even if the TARGET being built for wants GCC.
2830NXBMAKE+=	WANT_COMPILER_TYPE='$${X_COMPILER_TYPE}'
2831native-xtools: .PHONY
2832	${_+_}cd ${.CURDIR}; ${NXBTMAKE} _cleanobj
2833	# Build the bootstrap/host/cross tools that produce native binaries
2834	${_+_}cd ${.CURDIR}; ${NXBTMAKE} kernel-toolchain
2835	# Populate includes/libraries sysroot that produce native binaries.
2836	# This is split out from 'toolchain' above mostly so that target LLVM
2837	# libraries have a proper LLVM_DEFAULT_TARGET_TRIPLE without
2838	# polluting the cross-compiler build.  The LLVM libs are skipped
2839	# here to avoid the problem but are kept in 'toolchain' so that
2840	# needed build tools are built.
2841	${_+_}cd ${.CURDIR}; ${NXBTMAKE} _includes ${NXBTNOTOOLS}
2842	${_+_}cd ${.CURDIR}; ${NXBTMAKE} _libraries ${NXBTNOTOOLS}
2843.if !defined(NO_OBJWALK)
2844	${_+_}cd ${.CURDIR}; ${NXBMAKE} _obj
2845.endif
2846	${_+_}cd ${.CURDIR}; ${NXBMAKE} everything
2847	@echo ">> native-xtools done.  Use 'make native-xtools-install' to install to a given DESTDIR"
2848
2849native-xtools-install: .PHONY
2850	mkdir -p ${NXBDESTDIR}/bin ${NXBDESTDIR}/sbin ${NXBDESTDIR}/usr
2851	${DESTDIR_MTREE} -f ${.CURDIR}/etc/mtree/BSD.usr.dist \
2852	    -p ${NXBDESTDIR}/usr >/dev/null
2853	${DESTDIR_MTREE} -f ${.CURDIR}/etc/mtree/BSD.include.dist \
2854	    -p ${NXBDESTDIR}/usr/include >/dev/null
2855	${_+_}cd ${.CURDIR}; ${NXBMAKE} \
2856	    DESTDIR=${NXBDESTDIR} \
2857	    -DNO_ROOT \
2858	    install
2859
2860#
2861# hierarchy - ensure that all the needed directories are present
2862#
2863hierarchy hier: .MAKE .PHONY
2864	${_+_}cd ${.CURDIR}/etc; ${HMAKE} distrib-dirs
2865
2866#
2867# libraries - build all libraries, and install them under ${DESTDIR}.
2868#
2869# The list of libraries with dependents (${_prebuild_libs}) and their
2870# interdependencies (__L) are built automatically by the
2871# ${.CURDIR}/tools/make_libdeps.sh script.
2872#
2873libraries: .MAKE .PHONY
2874	${_+_}cd ${.CURDIR}; \
2875	    ${MAKE} -f Makefile.inc1 _prereq_libs; \
2876	    ${MAKE} -f Makefile.inc1 _startup_libs; \
2877	    ${MAKE} -f Makefile.inc1 _prebuild_libs; \
2878	    ${MAKE} -f Makefile.inc1 _generic_libs
2879
2880#
2881# static libgcc.a prerequisite for shared libc
2882#
2883_prereq_libs= lib/libcompiler_rt
2884.if ${MK_SSP} != "no"
2885_prereq_libs+= lib/libssp_nonshared
2886.endif
2887.if ${MK_ASAN} != "no"
2888_prereq_libs+=	lib/libclang_rt/asan
2889_prereq_libs+=	lib/libclang_rt/asan-preinit
2890_prereq_libs+=	lib/libclang_rt/asan_cxx
2891.endif
2892.if ${MK_UBSAN} != "no"
2893_prereq_libs+=	lib/libclang_rt/ubsan_minimal
2894_prereq_libs+=	lib/libclang_rt/ubsan_standalone
2895_prereq_libs+=	lib/libclang_rt/ubsan_standalone_cxx
2896.endif
2897
2898# These dependencies are not automatically generated:
2899#
2900# lib/csu and lib/libc must be built before
2901# all shared libraries for ELF.
2902#
2903_startup_libs=	lib/csu
2904_startup_libs+=	lib/libc
2905_startup_libs+=	lib/libc_nonshared
2906.if ${MK_CXX} != "no"
2907_startup_libs+=	lib/libcxxrt
2908.endif
2909
2910_prereq_libs+=	lib/libgcc_eh lib/libgcc_s
2911_startup_libs+=	lib/libgcc_eh lib/libgcc_s
2912
2913lib/libgcc_s__L: lib/libc__L
2914lib/libgcc_s__L: lib/libc_nonshared__L
2915.if ${MK_CXX} != "no"
2916lib/libcxxrt__L: lib/libgcc_s__L
2917.endif
2918
2919_prebuild_libs=	${_kerberos5_lib_libasn1} \
2920		${_kerberos5_lib_libhdb} \
2921		${_kerberos5_lib_libheimbase} \
2922		${_kerberos5_lib_libheimntlm} \
2923		${_libsqlite3} \
2924		${_kerberos5_lib_libheimipcc} \
2925		${_kerberos5_lib_libhx509} ${_kerberos5_lib_libkrb5} \
2926		${_kerberos5_lib_libroken} \
2927		${_kerberos5_lib_libwind} \
2928		lib/libbz2 ${_libcom_err} lib/libcrypt \
2929		lib/libelf lib/libexpat \
2930		lib/libfigpar \
2931		${_lib_libgssapi} \
2932		lib/libjail \
2933		lib/libkiconv lib/libkvm lib/liblzma lib/libmd lib/libnv \
2934		lib/libzstd \
2935		${_lib_casper} \
2936		lib/ncurses/tinfo \
2937		lib/ncurses/ncurses \
2938		lib/libopie lib/libpam/libpam lib/libthr \
2939		${_lib_libradius} lib/libsbuf lib/libtacplus \
2940		lib/libgeom \
2941		${_cddl_lib_libumem} ${_cddl_lib_libnvpair} \
2942		${_cddl_lib_libuutil} \
2943		${_cddl_lib_libavl} \
2944		${_cddl_lib_libicp} \
2945		${_cddl_lib_libicp_rescue} \
2946		${_cddl_lib_libspl} \
2947		${_cddl_lib_libtpool} \
2948		${_cddl_lib_libzfs_core} ${_cddl_lib_libzfs} \
2949		${_cddl_lib_libzutil} \
2950		${_cddl_lib_libctf} ${_cddl_lib_libzfsbootenv} \
2951		lib/libufs \
2952		lib/libutil lib/libpjdlog ${_lib_libypclnt} lib/libz lib/msun \
2953		${_secure_lib_libcrypto} ${_secure_lib_libssl} \
2954		${_lib_libldns} ${_secure_lib_libssh}
2955
2956.if ${MK_DIALOG} != "no"
2957_prebuild_libs+= gnu/lib/libdialog
2958gnu/lib/libdialog__L: lib/msun__L lib/ncurses/tinfo__L lib/ncurses/ncurses__L
2959.endif
2960
2961.if ${MK_GOOGLETEST} != "no"
2962_prebuild_libs+= lib/libregex
2963.endif
2964
2965.if ${MK_CXX} != "no"
2966_prebuild_libs+= lib/libc++
2967.endif
2968
2969lib/libgeom__L: lib/libexpat__L lib/libsbuf__L
2970lib/libkvm__L: lib/libelf__L
2971
2972.if ${MK_RADIUS_SUPPORT} != "no"
2973_lib_libradius=	lib/libradius
2974.endif
2975
2976lib/ncurses/ncurses__L:	lib/ncurses/tinfo__L
2977
2978.if ${MK_OFED} != "no"
2979_prebuild_libs+= \
2980	lib/ofed/libibverbs \
2981	lib/ofed/libibmad \
2982	lib/ofed/libibumad \
2983	lib/ofed/complib \
2984	lib/ofed/libmlx5
2985
2986lib/ofed/libibmad__L:	lib/ofed/libibumad__L
2987lib/ofed/complib__L:	lib/libthr__L
2988lib/ofed/libmlx5__L:	lib/ofed/libibverbs__L lib/libthr__L
2989.endif
2990
2991.if ${MK_CASPER} != "no"
2992_lib_casper=	lib/libcasper
2993.endif
2994
2995lib/libpjdlog__L: lib/libutil__L
2996lib/libcasper__L: lib/libnv__L
2997lib/liblzma__L: lib/libmd__L lib/libthr__L
2998lib/libzstd__L: lib/libthr__L
2999
3000_generic_libs=	${_cddl_lib} gnu/lib ${_kerberos5_lib} lib ${_secure_lib}
3001.if ${MK_IPFILTER} != "no"
3002_generic_libs+=	sbin/ipf/libipf
3003.endif
3004.for _DIR in ${LOCAL_LIB_DIRS}
3005.if ${_DIR} == ".WAIT"  || (empty(_generic_libs:M${_DIR}) && exists(${.CURDIR}/${_DIR}/Makefile))
3006_generic_libs+= ${_DIR}
3007.endif
3008.endfor
3009
3010lib/libopie__L lib/libtacplus__L: lib/libmd__L
3011
3012.if ${MK_CDDL} != "no"
3013_cddl_lib_libumem= cddl/lib/libumem
3014_cddl_lib_libnvpair= cddl/lib/libnvpair
3015_cddl_lib_libavl= cddl/lib/libavl
3016_cddl_lib_libuutil= cddl/lib/libuutil
3017_cddl_lib_libspl= cddl/lib/libspl
3018
3019cddl/lib/libuutil__L: cddl/lib/libavl__L cddl/lib/libspl__L
3020
3021.if ${MK_ZFS} != "no"
3022_cddl_lib_libicp= cddl/lib/libicp
3023_cddl_lib_libicp_rescue= cddl/lib/libicp_rescue
3024_cddl_lib_libtpool= cddl/lib/libtpool
3025_cddl_lib_libzutil= cddl/lib/libzutil
3026_cddl_lib_libzfs_core= cddl/lib/libzfs_core
3027_cddl_lib_libzfs= cddl/lib/libzfs
3028_cddl_lib_libzfsbootenv= cddl/lib/libzfsbootenv
3029
3030cddl/lib/libtpool__L: cddl/lib/libspl__L
3031
3032cddl/lib/libzutil__L: cddl/lib/libavl__L cddl/lib/libtpool__L
3033
3034cddl/lib/libzfs_core__L: cddl/lib/libnvpair__L
3035
3036cddl/lib/libzfs__L: cddl/lib/libzfs_core__L lib/msun__L lib/libutil__L
3037cddl/lib/libzfs__L: lib/libthr__L lib/libmd__L lib/libz__L cddl/lib/libumem__L
3038cddl/lib/libzfs__L: cddl/lib/libuutil__L cddl/lib/libavl__L lib/libgeom__L
3039cddl/lib/libzfs__L: cddl/lib/libnvpair__L cddl/lib/libzutil__L
3040cddl/lib/libzfs__L: secure/lib/libcrypto__L
3041
3042cddl/lib/libzfsbootenv__L: cddl/lib/libzfs__L
3043lib/libbe__L: cddl/lib/libzfs__L cddl/lib/libzfsbootenv__L
3044.endif
3045_cddl_lib_libctf= cddl/lib/libctf
3046_cddl_lib= cddl/lib
3047cddl/lib/libctf__L: lib/libz__L cddl/lib/libspl__L
3048.endif
3049# cddl/lib/libdtrace requires lib/libproc and lib/librtld_db
3050_prebuild_libs+=	lib/libprocstat lib/libproc lib/librtld_db
3051lib/libprocstat__L: lib/libelf__L lib/libkvm__L lib/libutil__L
3052lib/libproc__L: lib/libprocstat__L
3053lib/librtld_db__L: lib/libprocstat__L
3054
3055.if ${MK_CRYPT} != "no"
3056.if ${MK_OPENSSL} != "no"
3057_secure_lib_libcrypto= secure/lib/libcrypto
3058_secure_lib_libssl= secure/lib/libssl
3059lib/libradius__L secure/lib/libssl__L: secure/lib/libcrypto__L
3060secure/lib/libcrypto__L: lib/libthr__L
3061.if ${MK_LDNS} != "no"
3062_lib_libldns= lib/libldns
3063lib/libldns__L: secure/lib/libssl__L
3064.endif
3065.if ${MK_OPENSSH} != "no"
3066_secure_lib_libssh= secure/lib/libssh
3067secure/lib/libssh__L: lib/libz__L secure/lib/libcrypto__L lib/libcrypt__L
3068.if ${MK_LDNS} != "no"
3069secure/lib/libssh__L: lib/libldns__L
3070.endif
3071.if ${MK_GSSAPI} != "no" && ${MK_KERBEROS_SUPPORT} != "no"
3072secure/lib/libssh__L: lib/libgssapi__L kerberos5/lib/libkrb5__L \
3073    kerberos5/lib/libhx509__L kerberos5/lib/libasn1__L lib/libcom_err__L \
3074    lib/libmd__L kerberos5/lib/libroken__L
3075.endif
3076.endif
3077.endif
3078_secure_lib=	secure/lib
3079.endif
3080
3081.if ${MK_KERBEROS} != "no"
3082kerberos5/lib/libasn1__L: lib/libcom_err__L kerberos5/lib/libroken__L
3083kerberos5/lib/libhdb__L: kerberos5/lib/libasn1__L lib/libcom_err__L \
3084    kerberos5/lib/libkrb5__L kerberos5/lib/libroken__L \
3085    kerberos5/lib/libwind__L lib/libsqlite3__L
3086kerberos5/lib/libheimntlm__L: secure/lib/libcrypto__L kerberos5/lib/libkrb5__L \
3087    kerberos5/lib/libroken__L lib/libcom_err__L
3088kerberos5/lib/libhx509__L: kerberos5/lib/libasn1__L lib/libcom_err__L \
3089    secure/lib/libcrypto__L kerberos5/lib/libroken__L kerberos5/lib/libwind__L
3090kerberos5/lib/libkrb5__L: kerberos5/lib/libasn1__L lib/libcom_err__L \
3091    lib/libcrypt__L secure/lib/libcrypto__L kerberos5/lib/libhx509__L \
3092    kerberos5/lib/libroken__L kerberos5/lib/libwind__L \
3093    kerberos5/lib/libheimbase__L kerberos5/lib/libheimipcc__L
3094kerberos5/lib/libroken__L: lib/libcrypt__L
3095kerberos5/lib/libwind__L: kerberos5/lib/libroken__L lib/libcom_err__L
3096kerberos5/lib/libheimbase__L: lib/libthr__L
3097kerberos5/lib/libheimipcc__L: kerberos5/lib/libroken__L kerberos5/lib/libheimbase__L lib/libthr__L
3098.endif
3099
3100lib/libsqlite3__L: lib/libthr__L
3101
3102.if ${MK_GSSAPI} != "no"
3103_lib_libgssapi=	lib/libgssapi
3104.endif
3105
3106.if ${MK_KERBEROS} != "no"
3107_kerberos5_lib=	kerberos5/lib
3108_kerberos5_lib_libasn1= kerberos5/lib/libasn1
3109_kerberos5_lib_libhdb= kerberos5/lib/libhdb
3110_kerberos5_lib_libheimbase= kerberos5/lib/libheimbase
3111_kerberos5_lib_libkrb5= kerberos5/lib/libkrb5
3112_kerberos5_lib_libhx509= kerberos5/lib/libhx509
3113_kerberos5_lib_libroken= kerberos5/lib/libroken
3114_kerberos5_lib_libheimntlm= kerberos5/lib/libheimntlm
3115_libsqlite3= lib/libsqlite3
3116_kerberos5_lib_libheimipcc= kerberos5/lib/libheimipcc
3117_kerberos5_lib_libwind= kerberos5/lib/libwind
3118_libcom_err= lib/libcom_err
3119.endif
3120
3121.if ${MK_NIS} != "no"
3122_lib_libypclnt=	lib/libypclnt
3123.endif
3124
3125.if ${MK_OPENSSL} == "no"
3126lib/libradius__L: lib/libmd__L
3127.endif
3128
3129lib/libproc__L: \
3130    ${_cddl_lib_libctf:D${_cddl_lib_libctf}__L} lib/libelf__L lib/librtld_db__L lib/libutil__L
3131.if ${MK_CXX} != "no"
3132lib/libproc__L: lib/libcxxrt__L
3133.endif
3134
3135.for _lib in ${_prereq_libs}
3136${_lib}__PL: .PHONY .MAKE
3137.if !defined(_MKSHOWCONFIG) && exists(${.CURDIR}/${_lib})
3138	${_+_}@${ECHODIR} "===> ${_lib} (obj,all,install)"; \
3139		cd ${.CURDIR}/${_lib}; \
3140		if [ -z "${NO_OBJWALK}" ]; then ${MAKE} MK_TESTS=no DIRPRFX=${_lib}/ obj; fi; \
3141		${MAKE} MK_TESTS=no MK_PROFILE=no -DNO_PIC \
3142		    DIRPRFX=${_lib}/ all; \
3143		${MAKE} MK_TESTS=no MK_PROFILE=no -DNO_PIC \
3144		    DIRPRFX=${_lib}/ install
3145.endif
3146.endfor
3147
3148.for _lib in ${_startup_libs} ${_prebuild_libs} ${_generic_libs}
3149${_lib}__L: .PHONY .MAKE
3150.if !defined(_MKSHOWCONFIG) && exists(${.CURDIR}/${_lib})
3151	${_+_}@${ECHODIR} "===> ${_lib} (obj,all,install)"; \
3152		cd ${.CURDIR}/${_lib}; \
3153		if [ -z "${NO_OBJWALK}" ]; then ${MAKE} MK_TESTS=no DIRPRFX=${_lib}/ obj; fi; \
3154		${MAKE} MK_TESTS=no DIRPRFX=${_lib}/ all; \
3155		${MAKE} MK_TESTS=no DIRPRFX=${_lib}/ install
3156.endif
3157.endfor
3158
3159_prereq_libs: ${_prereq_libs:S/$/__PL/}
3160_startup_libs: ${_startup_libs:S/$/__L/}
3161_prebuild_libs: ${_prebuild_libs:S/$/__L/}
3162_generic_libs: ${_generic_libs:S/$/__L/}
3163
3164# Enable SUBDIR_PARALLEL when not calling 'make all', unless called from
3165# 'everything' with _PARALLEL_SUBDIR_OK set.  This is because it is unlikely
3166# that running 'make all' from the top-level, especially with a SUBDIR_OVERRIDE
3167# or LOCAL_DIRS set, will have a reliable build if SUBDIRs are built in
3168# parallel.  This is safe for the world stage of buildworld though since it has
3169# already built libraries in a proper order and installed includes into
3170# WORLDTMP. Special handling is done for SUBDIR ordering for 'install*' to
3171# avoid trashing a system if it crashes mid-install.
3172.if !make(all) || defined(_PARALLEL_SUBDIR_OK)
3173SUBDIR_PARALLEL=
3174.endif
3175
3176.include <bsd.subdir.mk>
3177
3178.if make(check-old) || make(check-old-dirs) || \
3179    make(check-old-files) || make(check-old-libs) || \
3180    make(delete-old) || make(delete-old-dirs) || \
3181    make(delete-old-files) || make(delete-old-libs)
3182
3183#
3184# check for / delete old files section
3185#
3186
3187.include "ObsoleteFiles.inc"
3188
3189OLD_LIBS_MESSAGE="Please be sure no application still uses those libraries, \
3190else you can not start such an application. Consult UPDATING for more \
3191information regarding how to cope with the removal/revision bump of a \
3192specific library."
3193
3194.if !defined(BATCH_DELETE_OLD_FILES)
3195RM_I=-i
3196.else
3197RM_I=-v
3198.endif
3199
3200delete-old-files: .PHONY
3201	@echo ">>> Removing old files (only deletes safe to delete libs)"
3202# Ask for every old file if the user really wants to remove it.
3203# It's annoying, but better safe than sorry.
3204# NB: We cannot pass the list of OLD_FILES as a parameter because the
3205# argument list will get too long. Using .for/.endfor make "loops" will make
3206# the Makefile parser segfault.
3207	@exec 3<&0; \
3208	cd ${.CURDIR}; \
3209	${MAKE} -f ${.CURDIR}/Makefile.inc1 ${.MAKEFLAGS} ${.TARGET} \
3210	    -V OLD_FILES -V "OLD_FILES:Musr/share/*.gz:R" | xargs -n1 | sort | \
3211	while read file; do \
3212		if [ -f "${DESTDIR}/$${file}" -o -L "${DESTDIR}/$${file}" ]; then \
3213			chflags noschg "${DESTDIR}/$${file}" 2>/dev/null || true; \
3214			rm ${RM_I} "${DESTDIR}/$${file}" <&3; \
3215		fi; \
3216		for ext in debug symbols; do \
3217		  if ! [ -e "${DESTDIR}/$${file}" ] && [ -f \
3218		      "${DESTDIR}${DEBUGDIR}/$${file}.$${ext}" ]; then \
3219			  rm ${RM_I} "${DESTDIR}${DEBUGDIR}/$${file}.$${ext}" \
3220			      <&3; \
3221		  fi; \
3222		done; \
3223	done
3224# Remove catpages without corresponding manpages.
3225	@exec 3<&0; \
3226	find ${DESTDIR}/usr/share/man/cat* ! -type d 2>/dev/null | sort | \
3227	sed -ep -e's:${DESTDIR}/usr/share/man/cat:${DESTDIR}/usr/share/man/man:' | \
3228	while read catpage; do \
3229		read manpage; \
3230		if [ ! -e "$${manpage}" ]; then \
3231			rm ${RM_I} $${catpage} <&3; \
3232	        fi; \
3233	done
3234	@echo ">>> Old files removed"
3235
3236check-old-files: .PHONY
3237	@echo ">>> Checking for old files"
3238	@cd ${.CURDIR}; \
3239	${MAKE} -f ${.CURDIR}/Makefile.inc1 ${.MAKEFLAGS} ${.TARGET} \
3240	    -V OLD_FILES -V "OLD_FILES:Musr/share/*.gz:R" | xargs -n1 | \
3241	while read file; do \
3242		if [ -f "${DESTDIR}/$${file}" -o -L "${DESTDIR}/$${file}" ]; then \
3243		 	echo "${DESTDIR}/$${file}"; \
3244		fi; \
3245		for ext in debug symbols; do \
3246		  if [ -f "${DESTDIR}${DEBUGDIR}/$${file}.$${ext}" ]; then \
3247			  echo "${DESTDIR}${DEBUGDIR}/$${file}.$${ext}"; \
3248		  fi; \
3249		done; \
3250	done | sort
3251# Check for catpages without corresponding manpages.
3252	@find ${DESTDIR}/usr/share/man/cat* ! -type d 2>/dev/null | \
3253	sed -ep -e's:${DESTDIR}/usr/share/man/cat:${DESTDIR}/usr/share/man/man:' | \
3254	while read catpage; do \
3255		read manpage; \
3256		if [ ! -e "$${manpage}" ]; then \
3257			echo $${catpage}; \
3258	        fi; \
3259	done | sort
3260
3261delete-old-libs: .PHONY
3262	@echo ">>> Removing old libraries"
3263	@echo "${OLD_LIBS_MESSAGE}" | fmt
3264	@exec 3<&0; \
3265	cd ${.CURDIR}; \
3266	${MAKE} -f ${.CURDIR}/Makefile.inc1 ${.MAKEFLAGS} ${.TARGET} \
3267	    -V OLD_LIBS | xargs -n1 | sort | \
3268	while read file; do \
3269		if [ -f "${DESTDIR}/$${file}" -o -L "${DESTDIR}/$${file}" ]; then \
3270			chflags noschg "${DESTDIR}/$${file}" 2>/dev/null || true; \
3271			rm ${RM_I} "${DESTDIR}/$${file}" <&3; \
3272		fi; \
3273		for ext in debug symbols; do \
3274		  if ! [ -e "${DESTDIR}/$${file}" ] && [ -f \
3275		      "${DESTDIR}${DEBUGDIR}/$${file}.$${ext}" ]; then \
3276			  rm ${RM_I} "${DESTDIR}${DEBUGDIR}/$${file}.$${ext}" \
3277			      <&3; \
3278		  fi; \
3279		done; \
3280	done
3281	@echo ">>> Old libraries removed"
3282
3283check-old-libs: .PHONY
3284	@echo ">>> Checking for old libraries"
3285	@cd ${.CURDIR}; \
3286	${MAKE} -f ${.CURDIR}/Makefile.inc1 ${.MAKEFLAGS} ${.TARGET} \
3287	    -V OLD_LIBS | xargs -n1 | \
3288	while read file; do \
3289		if [ -f "${DESTDIR}/$${file}" -o -L "${DESTDIR}/$${file}" ]; then \
3290			echo "${DESTDIR}/$${file}"; \
3291		fi; \
3292		for ext in debug symbols; do \
3293		  if [ -f "${DESTDIR}${DEBUGDIR}/$${file}.$${ext}" ]; then \
3294			  echo "${DESTDIR}${DEBUGDIR}/$${file}.$${ext}"; \
3295		  fi; \
3296		done; \
3297	done | sort
3298
3299delete-old-dirs: .PHONY
3300	@echo ">>> Removing old directories"
3301	@cd ${.CURDIR}; \
3302	${MAKE} -f ${.CURDIR}/Makefile.inc1 ${.MAKEFLAGS} ${.TARGET} \
3303	    -V OLD_DIRS | xargs -n1 | sort -r | \
3304	while read dir; do \
3305		if [ -d "${DESTDIR}/$${dir}" ]; then \
3306			rmdir -v "${DESTDIR}/$${dir}" || true; \
3307		elif [ -L "${DESTDIR}/$${dir}" ]; then \
3308			echo "${DESTDIR}/$${dir} is a link, please remove everything manually."; \
3309		fi; \
3310		if [ -d "${DESTDIR}${DEBUGDIR}/$${dir}" ]; then \
3311			rmdir -v "${DESTDIR}${DEBUGDIR}/$${dir}" || true; \
3312		elif [ -L "${DESTDIR}${DEBUGDIR}/$${dir}" ]; then \
3313			echo "${DESTDIR}${DEBUGDIR}/$${dir} is a link, please remove everything manually."; \
3314		fi; \
3315	done
3316	@echo ">>> Old directories removed"
3317
3318check-old-dirs: .PHONY
3319	@echo ">>> Checking for old directories"
3320	@cd ${.CURDIR}; \
3321	${MAKE} -f ${.CURDIR}/Makefile.inc1 ${.MAKEFLAGS} ${.TARGET} \
3322	    -V OLD_DIRS | xargs -n1 | sort -r | \
3323	while read dir; do \
3324		if [ -d "${DESTDIR}/$${dir}" ]; then \
3325			echo "${DESTDIR}/$${dir}"; \
3326		elif [ -L "${DESTDIR}/$${dir}" ]; then \
3327			echo "${DESTDIR}/$${dir} is a link, please remove everything manually."; \
3328		fi; \
3329		if [ -d "${DESTDIR}${DEBUGDIR}/$${dir}" ]; then \
3330			echo "${DESTDIR}${DEBUGDIR}/$${dir}"; \
3331		elif [ -L "${DESTDIR}${DEBUGDIR}/$${dir}" ]; then \
3332			echo "${DESTDIR}${DEBUGDIR}/$${dir} is a link, please remove everything manually."; \
3333		fi; \
3334	done
3335
3336delete-old: delete-old-files delete-old-dirs .PHONY
3337	@echo "To remove old libraries run '${MAKE_CMD} delete-old-libs'."
3338
3339check-old: check-old-files check-old-libs check-old-dirs .PHONY
3340	@echo "To remove old files and directories run '${MAKE_CMD} delete-old'."
3341	@echo "To remove old libraries run '${MAKE_CMD} delete-old-libs'."
3342
3343.endif
3344
3345#
3346# showconfig - show build configuration.
3347#
3348showconfig: .PHONY
3349	@(${MAKE} -n -f ${.CURDIR}/sys/conf/kern.opts.mk -V dummy -dg1 UPDATE_DEPENDFILE=no NO_OBJ=yes; \
3350	  ${MAKE} -n -f ${.CURDIR}/share/mk/src.opts.mk -V dummy -dg1 UPDATE_DEPENDFILE=no NO_OBJ=yes) 2>&1 | grep ^MK_ | sort -u
3351
3352.if !empty(KRNLOBJDIR) && !empty(KERNCONF)
3353DTBOUTPUTPATH= ${KRNLOBJDIR}/${KERNCONF}/
3354
3355.if !defined(FDT_DTS_FILE) || empty(FDT_DTS_FILE)
3356.if !defined(_MKSHOWCONFIG) && exists(${KERNCONFDIR}/${KERNCONF})
3357FDT_DTS_FILE!= awk 'BEGIN {FS="="} /^makeoptions[[:space:]]+FDT_DTS_FILE/ {print $$2}' \
3358	'${KERNCONFDIR}/${KERNCONF}' ; echo
3359.endif
3360.endif
3361
3362.endif
3363
3364.if !defined(DTBOUTPUTPATH) || !exists(${DTBOUTPUTPATH})
3365DTBOUTPUTPATH= ${.CURDIR}
3366.endif
3367
3368#
3369# Build 'standalone' Device Tree Blob
3370#
3371builddtb: .PHONY
3372	@PATH=${TMPPATH} MACHINE=${TARGET} \
3373	sh ${.CURDIR}/sys/tools/fdt/make_dtb.sh ${.CURDIR}/sys \
3374	    "${FDT_DTS_FILE}" ${DTBOUTPUTPATH}
3375
3376###############
3377
3378# cleanworld
3379# In the following, the first 'rm' in a series will usually remove all
3380# files and directories.  If it does not, then there are probably some
3381# files with file flags set, so this unsets them and tries the 'rm' a
3382# second time.  There are situations where this target will be cleaning
3383# some directories via more than one method, but that duplication is
3384# needed to correctly handle all the possible situations.  Removing all
3385# files without file flags set in the first 'rm' instance saves time,
3386# because 'chflags' will need to operate on fewer files afterwards.
3387#
3388# It is expected that BW_CANONICALOBJDIR == the CANONICALOBJDIR as would be
3389# created by bsd.obj.mk, except that we don't want to .include that file
3390# in this makefile.  We don't do a cleandir walk if MK_AUTO_OBJ is yes
3391# since it is not possible for files to land in the wrong place.
3392#
3393.if make(cleanworld)
3394BW_CANONICALOBJDIR:=${OBJTOP}/
3395.elif make(cleanuniverse)
3396BW_CANONICALOBJDIR:=${OBJROOT}
3397.if ${MK_UNIFIED_OBJDIR} == "no"
3398.error ${.TARGETS} only supported with WITH_UNIFIED_OBJDIR enabled.
3399.endif
3400.endif
3401cleanworld cleanuniverse: .PHONY
3402.if !empty(BW_CANONICALOBJDIR) && exists(${BW_CANONICALOBJDIR}) && \
3403    ${.CURDIR:tA} != ${BW_CANONICALOBJDIR:tA}
3404	-rm -rf ${BW_CANONICALOBJDIR}*
3405	-chflags -R 0 ${BW_CANONICALOBJDIR}
3406	rm -rf ${BW_CANONICALOBJDIR}*
3407.endif
3408.if make(cleanworld) && ${MK_AUTO_OBJ} == "no" && \
3409    (empty(BW_CANONICALOBJDIR) || ${.CURDIR:tA} == ${BW_CANONICALOBJDIR:tA})
3410.if ${.CURDIR} == ${.OBJDIR} || ${.CURDIR}/obj == ${.OBJDIR}
3411	#   To be safe in this case, fall back to a 'make cleandir'
3412	${_+_}@cd ${.CURDIR}; ${MAKE} cleandir
3413.endif
3414.endif
3415
3416.if ${TARGET} == ${MACHINE} && ${TARGET_ARCH} == ${MACHINE_ARCH}
3417XDEV_CPUTYPE?=${CPUTYPE}
3418.else
3419XDEV_CPUTYPE?=${TARGET_CPUTYPE}
3420.endif
3421
3422NOFUN=-DNO_FSCHG MK_HTML=no -DNO_LINT \
3423	MK_MAN=no MK_NLS=no MK_PROFILE=no \
3424	MK_KERBEROS=no MK_RESCUE=no MK_TESTS=no MK_WERROR=no \
3425	TARGET=${TARGET} TARGET_ARCH=${TARGET_ARCH} \
3426	CPUTYPE=${XDEV_CPUTYPE}
3427
3428XDDIR=${TARGET_ARCH}-freebsd
3429XDTP?=/usr/${XDDIR}
3430.if ${XDTP:N/*}
3431.error XDTP variable should be an absolute path
3432.endif
3433
3434CDBOBJROOT=	${OBJROOT}${MACHINE}.${MACHINE_ARCH}/xdev/
3435CDBOBJTOP=	${CDBOBJROOT}${XDDIR}
3436CDBENV= \
3437	INSTALL="sh ${.CURDIR}/tools/install.sh"
3438CDENV= ${CDBENV} \
3439	TOOLS_PREFIX=${XDTP}
3440CDMAKEARGS= \
3441	OBJTOP=${CDBOBJTOP:Q} \
3442	OBJROOT=${CDBOBJROOT:Q}
3443CD2MAKEARGS= ${CDMAKEARGS}
3444
3445.if ${WANT_COMPILER_TYPE} == gcc || \
3446    (defined(X_COMPILER_TYPE) && ${X_COMPILER_TYPE} == gcc)
3447# GCC requires -isystem and -L when using a cross-compiler.  --sysroot
3448# won't set header path and -L is used to ensure the base library path
3449# is added before the port PREFIX library path.
3450CD2CFLAGS+=	-isystem ${XDDESTDIR}/usr/include -L${XDDESTDIR}/usr/lib
3451# GCC requires -B to find /usr/lib/crti.o when using a cross-compiler
3452# combined with --sysroot.
3453CD2CFLAGS+=	-B${XDDESTDIR}/usr/lib
3454# Force using libc++ for external GCC.
3455.if defined(X_COMPILER_TYPE) && \
3456    ${X_COMPILER_TYPE} == gcc && ${X_COMPILER_VERSION} >= 40800
3457CD2CXXFLAGS+=	-isystem ${XDDESTDIR}/usr/include/c++/v1 -std=c++11 \
3458		-nostdinc++
3459.endif
3460.endif
3461CD2CFLAGS+=	--sysroot=${XDDESTDIR}/
3462CD2ENV=${CDENV} CC="${CC} ${CD2CFLAGS}" CXX="${CXX} ${CD2CXXFLAGS} ${CD2CFLAGS}" \
3463	CPP="${CPP} ${CD2CFLAGS}" \
3464	MACHINE=${TARGET} MACHINE_ARCH=${TARGET_ARCH}
3465
3466CDTMP=	${OBJTOP}/${XDDIR}/tmp
3467CDMAKE=${CDENV} PATH=${CDTMP}/usr/bin:${PATH} ${MAKE} ${CDMAKEARGS} ${NOFUN}
3468CD2MAKE=${CD2ENV} PATH=${CDTMP}/usr/bin:${XDDESTDIR}/usr/bin:${PATH} \
3469	${MAKE} ${CD2MAKEARGS} ${NOFUN}
3470.if ${MK_META_MODE} != "no"
3471# Don't rebuild build-tools targets during normal build.
3472CD2MAKE+=	BUILD_TOOLS_META=.NOMETA
3473.endif
3474XDDESTDIR=${DESTDIR}${XDTP}
3475
3476.ORDER: xdev-build xdev-install xdev-links
3477xdev: xdev-build xdev-install .PHONY
3478
3479.ORDER: _xb-worldtmp _xb-bootstrap-tools _xb-build-tools _xb-cross-tools
3480xdev-build: _xb-worldtmp _xb-bootstrap-tools _xb-build-tools _xb-cross-tools .PHONY
3481
3482_xb-worldtmp: .PHONY
3483	mkdir -p ${CDTMP}/usr
3484	${WORLDTMP_MTREE} -f ${.CURDIR}/etc/mtree/BSD.usr.dist \
3485	    -p ${CDTMP}/usr >/dev/null
3486
3487_xb-bootstrap-tools: .PHONY
3488.for _tool in \
3489    ${_clang_tblgen} \
3490    ${_yacc}
3491	${_+_}@${ECHODIR} "===> ${_tool} (obj,all,install)"; \
3492	cd ${.CURDIR}/${_tool}; \
3493	if [ -z "${NO_OBJWALK}" ]; then ${CDMAKE} DIRPRFX=${_tool}/ obj; fi; \
3494	${CDMAKE} DIRPRFX=${_tool}/ all; \
3495	${CDMAKE} DIRPRFX=${_tool}/ DESTDIR=${CDTMP} install
3496.endfor
3497
3498_xb-build-tools: .PHONY
3499	${_+_}@cd ${.CURDIR}; \
3500	${CDBENV} ${MAKE} ${CDMAKEARGS} -f Makefile.inc1 ${NOFUN} build-tools
3501
3502XDEVDIRS= \
3503    ${_clang_libs} \
3504    ${_lld} \
3505    ${_elftctools} \
3506    usr.bin/ar \
3507    ${_clang}
3508
3509_xb-cross-tools: .PHONY
3510.for _tool in ${XDEVDIRS}
3511	${_+_}@${ECHODIR} "===> xdev ${_tool} (obj,all)"; \
3512	cd ${.CURDIR}/${_tool}; \
3513	if [ -z "${NO_OBJWALK}" ]; then ${CDMAKE} DIRPRFX=${_tool}/ obj; fi; \
3514	${CDMAKE} DIRPRFX=${_tool}/ all
3515.endfor
3516
3517_xi-mtree: .PHONY
3518	${_+_}@${ECHODIR} "mtree populating ${XDDESTDIR}"
3519	mkdir -p ${XDDESTDIR}
3520	${DESTDIR_MTREE} -f ${.CURDIR}/etc/mtree/BSD.root.dist \
3521	    -p ${XDDESTDIR} >/dev/null
3522	${DESTDIR_MTREE} -f ${.CURDIR}/etc/mtree/BSD.usr.dist \
3523	    -p ${XDDESTDIR}/usr >/dev/null
3524	${DESTDIR_MTREE} -f ${.CURDIR}/etc/mtree/BSD.include.dist \
3525	    -p ${XDDESTDIR}/usr/include >/dev/null
3526.if defined(_LIBCOMPAT)
3527	${DESTDIR_MTREE} -f ${.CURDIR}/etc/mtree/BSD.lib${libcompat}.dist \
3528	    -p ${XDDESTDIR}/usr >/dev/null
3529.endif
3530.if ${MK_TESTS} != "no"
3531	mkdir -p ${XDDESTDIR}${TESTSBASE}
3532	${DESTDIR_MTREE} -f ${.CURDIR}/etc/mtree/BSD.tests.dist \
3533	    -p ${XDDESTDIR}${TESTSBASE} >/dev/null
3534.endif
3535
3536.ORDER: xdev-build _xi-mtree _xi-cross-tools _xi-includes _xi-libraries
3537xdev-install: xdev-build _xi-mtree _xi-cross-tools _xi-includes _xi-libraries .PHONY
3538
3539_xi-cross-tools: .PHONY
3540	@echo "_xi-cross-tools"
3541.for _tool in ${XDEVDIRS}
3542	${_+_}@${ECHODIR} "===> xdev ${_tool} (install)"; \
3543	cd ${.CURDIR}/${_tool}; \
3544	${CDMAKE} DIRPRFX=${_tool}/ install DESTDIR=${XDDESTDIR}
3545.endfor
3546
3547_xi-includes: .PHONY
3548.if !defined(NO_OBJWALK)
3549	${_+_}cd ${.CURDIR}; ${CD2MAKE} -f Makefile.inc1 _obj \
3550		DESTDIR=${XDDESTDIR}
3551.endif
3552	${_+_}cd ${.CURDIR}; ${CD2MAKE} -f Makefile.inc1 includes \
3553		DESTDIR=${XDDESTDIR}
3554
3555_xi-libraries: .PHONY
3556	${_+_}cd ${.CURDIR}; ${CD2MAKE} -f Makefile.inc1 libraries \
3557		DESTDIR=${XDDESTDIR}
3558
3559xdev-links: .PHONY
3560	${_+_}cd ${XDDESTDIR}/usr/bin; \
3561	mkdir -p ../../../../usr/bin; \
3562		for i in *; do \
3563			ln -sf ../../${XDTP}/usr/bin/$$i \
3564			    ../../../../usr/bin/${XDDIR}-$$i; \
3565			ln -sf ../../${XDTP}/usr/bin/$$i \
3566			    ../../../../usr/bin/${XDDIR}${_REVISION}-$$i; \
3567		done
3568