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