Index: head/Makefile
===================================================================
--- head/Makefile	(revision 359493)
+++ head/Makefile	(revision 359494)
@@ -1,770 +1,777 @@
 #
 # $FreeBSD$
 #
 # The user-driven targets are:
 #
 # universe            - *Really* build *everything* (buildworld and
 #                       all kernels on all architectures).  Define
-#                       MAKE_JUST_KERNELS to only build kernels,
-#                       MAKE_JUST_WORLDS to only build userland.
+#                       MAKE_JUST_KERNELS or WITHOUT_WORLDS to only build kernels,
+#                       MAKE_JUST_WORLDS or WITHOUT_KERNELS to only build userland.
 # tinderbox           - Same as universe, but presents a list of failed build
 #                       targets and exits with an error if there were any.
+# worlds	      - Same as universe, except just makes the worlds.
+# kernels	      - Same as universe, except just makes the kernels.
 # buildworld          - Rebuild *everything*, including glue to help do
 #                       upgrades.
 # installworld        - Install everything built by "buildworld".
 # world               - buildworld + installworld, no kernel.
 # buildkernel         - Rebuild the kernel and the kernel-modules.
 # installkernel       - Install the kernel and the kernel-modules.
 # installkernel.debug
 # reinstallkernel     - Reinstall the kernel and the kernel-modules.
 # reinstallkernel.debug
 # kernel              - buildkernel + installkernel.
 # kernel-toolchain    - Builds the subset of world necessary to build a kernel
 # kernel-toolchains   - Build kernel-toolchain for all universe targets.
 # doxygen             - Build API documentation of the kernel, needs doxygen.
 # update              - Convenient way to update your source tree(s).
 # checkworld          - Run test suite on installed world.
 # check-old           - List obsolete directories/files/libraries.
 # check-old-dirs      - List obsolete directories.
 # check-old-files     - List obsolete files.
 # check-old-libs      - List obsolete libraries.
 # delete-old          - Delete obsolete directories/files.
 # delete-old-dirs     - Delete obsolete directories.
 # delete-old-files    - Delete obsolete files.
 # delete-old-libs     - Delete obsolete libraries.
 # targets             - Print a list of supported TARGET/TARGET_ARCH pairs
 #                       for world and kernel targets.
 # toolchains          - Build a toolchain for all world and kernel targets.
 # makeman             - Regenerate src.conf(5)
 # sysent              - (Re)build syscall entries from syscalls.master.
 # xdev                - xdev-build + xdev-install for the architecture
 #                       specified with TARGET and TARGET_ARCH.
 # xdev-build          - Build cross-development tools.
 # xdev-install        - Install cross-development tools.
 # xdev-links          - Create traditional links in /usr/bin for cc, etc
 # native-xtools       - Create host binaries that produce target objects
 #                       for use in qemu user-mode jails.  TARGET and
 #                       TARGET_ARCH should be defined.
 # native-xtools-install
 #                     - Install the files to the given DESTDIR/NXTP where
 #                       NXTP defaults to /nxb-bin.
 #
 # This makefile is simple by design. The FreeBSD make automatically reads
 # the /usr/share/mk/sys.mk unless the -m argument is specified on the
 # command line. By keeping this makefile simple, it doesn't matter too
 # much how different the installed mk files are from those in the source
 # tree. This makefile executes a child make process, forcing it to use
 # the mk files from the source tree which are supposed to DTRT.
 #
 # Most of the user-driven targets (as listed above) are implemented in
 # Makefile.inc1.  The exceptions are universe, tinderbox and targets.
 #
 # If you want to build your system from source, be sure that /usr/obj has
 # at least 6 GB of disk space available.  A complete 'universe' build of
 # r340283 (2018-11) required 167 GB of space.  ZFS lz4 compression
 # achieved a 2.18x ratio, reducing actual space to 81 GB.
 #
 # For individuals wanting to build from the sources currently on their
 # system, the simple instructions are:
 #
 # 1.  `cd /usr/src'  (or to the directory containing your source tree).
 # 2.  Define `HISTORICAL_MAKE_WORLD' variable (see README).
 # 3.  `make world'
 #
 # For individuals wanting to upgrade their sources (even if only a
 # delta of a few days):
 #
 #  1.  `cd /usr/src'       (or to the directory containing your source tree).
 #  2.  `make buildworld'
 #  3.  `make buildkernel KERNCONF=YOUR_KERNEL_HERE'     (default is GENERIC).
 #  4.  `make installkernel KERNCONF=YOUR_KERNEL_HERE'   (default is GENERIC).
 #       [steps 3. & 4. can be combined by using the "kernel" target]
 #  5.  `reboot'        (in single user mode: boot -s from the loader prompt).
 #  6.  `mergemaster -p'
 #  7.  `make installworld'
 #  8.  `mergemaster'            (you may wish to use -i, along with -U or -F).
 #  9.  `make delete-old'
 # 10.  `reboot'
 # 11.  `make delete-old-libs' (in case no 3rd party program uses them anymore)
 #
 # See src/UPDATING `COMMON ITEMS' for more complete information.
 #
 # If TARGET=machine (e.g. powerpc, arm64, ...) is specified you can
 # cross build world for other machine types using the buildworld target,
 # and once the world is built you can cross build a kernel using the
 # buildkernel target.
 #
 # Define the user-driven targets. These are listed here in alphabetical
 # order, but that's not important.
 #
 # Targets that begin with underscore are internal targets intended for
 # developer convenience only.  They are intentionally not documented and
 # completely subject to change without notice.
 #
 # For more information, see the build(7) manual page.
 #
 
+.if defined(UNIVERSE_TARGET) || defined(MAKE_JUST_WORLDS) || defined(WITHOUT_KERNELS)
+__DO_KERNELS=no
+.endif
+.if defined(MAKE_JUST_KERNELS) || defined(WITHOUT_WORLDS)
+__DO_WORLDS=no
+.endif
+__DO_WORLDS?=yes
+__DO_KERNELS?=yes
+
 # This is included so CC is set to ccache for -V, and COMPILER_TYPE/VERSION
 # can be cached for sub-makes. We can't do this while still running on the
 # old fmake from FreeBSD 9.x or older, so avoid including it then to avoid
 # heartburn upgrading from older systems. The need for CC is done with new
 # make later in the build, and caching COMPILER_TYPE/VERSION is only an
 # optimization. Also sinclude it to be friendlier to foreign OS hosted builds.
 .if ${MAKE_VERSION} >= 20140620 && defined(.PARSEDIR)
 .sinclude <bsd.compiler.mk>
 .endif
 
 # Note: we use this awkward construct to be compatible with FreeBSD's
 # old make used in 10.0 and 9.2 and earlier.
 .if defined(MK_DIRDEPS_BUILD) && ${MK_DIRDEPS_BUILD} == "yes" && \
     !make(showconfig) && !make(print-dir)
 # targets/Makefile plays the role of top-level
 .include "targets/Makefile"
 .else
 
 TGTS=	all all-man buildenv buildenvvars buildkernel buildworld \
 	check check-old check-old-dirs check-old-files check-old-libs \
 	checkdpadd checkworld clean cleandepend cleandir cleanworld \
 	cleanuniverse \
 	delete-old delete-old-dirs delete-old-files delete-old-libs \
 	depend distribute distributekernel distributekernel.debug \
 	distributeworld distrib-dirs distribution doxygen \
 	everything hier hierarchy install installcheck installkernel \
 	installkernel.debug packagekernel packageworld \
 	reinstallkernel reinstallkernel.debug \
 	installworld kernel-toolchain libraries maninstall \
 	obj objlink showconfig tags toolchain update \
 	makeman sysent \
 	_worldtmp _legacy _bootstrap-tools _cleanobj _obj \
 	_build-tools _build-metadata _cross-tools _includes _libraries \
 	build32 distribute32 install32 buildsoft distributesoft installsoft \
 	builddtb xdev xdev-build xdev-install \
 	xdev-links native-xtools native-xtools-install stageworld stagekernel \
 	stage-packages stage-packages-kernel stage-packages-world \
 	create-packages-world create-packages-kernel create-packages \
 	packages installconfig real-packages sign-packages package-pkg \
 	print-dir test-system-compiler test-system-linker
 
 # These targets require a TARGET and TARGET_ARCH be defined.
 XTGTS=	native-xtools native-xtools-install xdev xdev-build xdev-install \
 	xdev-links
 
 # XXX: r156740: This can't work since bsd.subdir.mk is not included ever.
 # It will only work for SUBDIR_TARGETS in make.conf.
 TGTS+=	${SUBDIR_TARGETS}
 
 BITGTS=	files includes
 BITGTS:=${BITGTS} ${BITGTS:S/^/build/} ${BITGTS:S/^/install/}
 TGTS+=	${BITGTS}
 
 # Only some targets are allowed to use meta mode.  Others get it
 # disabled.  In some cases, such as 'install', meta mode can be dangerous
 # as a cookie may be used to prevent redundant installations (such as
 # for WORLDTMP staging).  For DESTDIR=/ we always want to install though.
 # For other cases, such as delete-old-libs, meta mode may break
 # the interactive tty prompt.  The safest route is to just whitelist
 # the ones that benefit from it.
 META_TGT_WHITELIST+= \
 	_* build32 buildfiles buildincludes buildkernel buildsoft \
 	buildworld everything kernel-toolchain kernel-toolchains kernel \
 	kernels libraries native-xtools showconfig test-system-compiler \
 	test-system-linker tinderbox toolchain \
 	toolchains universe universe-toolchain world worlds xdev xdev-build
 
 .ORDER: buildworld installworld
 .ORDER: buildworld distrib-dirs
 .ORDER: buildworld distribution
 .ORDER: buildworld distribute
 .ORDER: buildworld distributeworld
 .ORDER: buildworld buildkernel
 .ORDER: distrib-dirs distribute
 .ORDER: distrib-dirs distributeworld
 .ORDER: distrib-dirs installworld
 .ORDER: distribution distribute
 .ORDER: distributeworld distribute
 .ORDER: distributeworld distribution
 .ORDER: installworld distribute
 .ORDER: installworld distribution
 .ORDER: installworld installkernel
 .ORDER: buildkernel installkernel
 .ORDER: buildkernel installkernel.debug
 .ORDER: buildkernel reinstallkernel
 .ORDER: buildkernel reinstallkernel.debug
 
 PATH=	/sbin:/bin:/usr/sbin:/usr/bin
 MAKEOBJDIRPREFIX?=	/usr/obj
 _MAKEOBJDIRPREFIX!= /usr/bin/env -i PATH=${PATH} ${MAKE} MK_AUTO_OBJ=no \
     ${.MAKEFLAGS:MMAKEOBJDIRPREFIX=*} __MAKE_CONF=${__MAKE_CONF} \
     SRCCONF=${SRCCONF} SRC_ENV_CONF= \
     -f /dev/null -V MAKEOBJDIRPREFIX dummy
 .if !empty(_MAKEOBJDIRPREFIX)
 .error MAKEOBJDIRPREFIX can only be set in environment or src-env.conf(5),\
     not as a global (in make.conf(5) or src.conf(5)) or command-line variable.
 .endif
 
 # We often need to use the tree's version of make to build it.
 # Choices add to complexity though.
 # We cannot blindly use a make which may not be the one we want
 # so be explicit - until all choice is removed.
 WANT_MAKE=	bmake
 .if !empty(.MAKE.MODE:Mmeta)
 # 20160604 - support missing-meta,missing-filemon and performance improvements
 WANT_MAKE_VERSION= 20160604
 .else
 # 20160220 - support .dinclude for FAST_DEPEND.
 WANT_MAKE_VERSION= 20160220
 .endif
 MYMAKE=		${OBJROOT}make.${MACHINE}/${WANT_MAKE}
 .if defined(.PARSEDIR)
 HAVE_MAKE=	bmake
 .else
 HAVE_MAKE=	fmake
 .endif
 .if defined(ALWAYS_BOOTSTRAP_MAKE) || \
     ${HAVE_MAKE} != ${WANT_MAKE} || \
     (defined(WANT_MAKE_VERSION) && ${MAKE_VERSION} < ${WANT_MAKE_VERSION})
 NEED_MAKE_UPGRADE= t
 .endif
 .if exists(${MYMAKE})
 SUB_MAKE:= ${MYMAKE} -m ${.CURDIR}/share/mk
 .elif defined(NEED_MAKE_UPGRADE)
 # It may not exist yet but we may cause it to.
 # In the case of fmake, upgrade_checks may cause a newer version to be built.
 SUB_MAKE= `test -x ${MYMAKE} && echo ${MYMAKE} || echo ${MAKE}` \
 	-m ${.CURDIR}/share/mk
 .else
 SUB_MAKE= ${MAKE} -m ${.CURDIR}/share/mk
 .endif
 
 _MAKE=	PATH=${PATH} MAKE_CMD="${MAKE}" ${SUB_MAKE} -f Makefile.inc1 \
 	TARGET=${_TARGET} TARGET_ARCH=${_TARGET_ARCH} ${_MAKEARGS}
 
 .if defined(MK_META_MODE) && ${MK_META_MODE} == "yes"
 # Only allow meta mode for the whitelisted targets.  See META_TGT_WHITELIST
 # above.  If overridden as a make argument then don't bother trying to
 # disable it.
 .if empty(.MAKEOVERRIDES:MMK_META_MODE)
 .for _tgt in ${META_TGT_WHITELIST}
 .if make(${_tgt})
 _CAN_USE_META_MODE?= yes
 .endif
 .endfor
 .if !defined(_CAN_USE_META_MODE)
 _MAKE+=	MK_META_MODE=no
 MK_META_MODE= no
 .if defined(.PARSEDIR)
 .unexport META_MODE
 .endif
 .endif	# !defined(_CAN_USE_META_MODE)
 .endif	# empty(.MAKEOVERRIDES:MMK_META_MODE)
 
 .if ${MK_META_MODE} == "yes"
 .if !exists(/dev/filemon) && !defined(NO_FILEMON) && !make(showconfig)
 # Require filemon be loaded to provide a working incremental build
 .error ${.newline}ERROR: The filemon module (/dev/filemon) is not loaded. \
     ${.newline}ERROR: WITH_META_MODE is enabled but requires filemon for an incremental build. \
     ${.newline}ERROR: 'kldload filemon' or pass -DNO_FILEMON to suppress this error.
 .endif	# !exists(/dev/filemon) && !defined(NO_FILEMON)
 .endif	# ${MK_META_MODE} == yes
 .endif	# defined(MK_META_MODE) && ${MK_META_MODE} == yes
 
 # Guess target architecture from target type, and vice versa, based on
 # historic FreeBSD practice of tending to have TARGET == TARGET_ARCH
 # expanding to TARGET == TARGET_CPUARCH in recent times, with known
 # exceptions.
 .if !defined(TARGET_ARCH) && defined(TARGET)
 # T->TA mapping is usually TARGET with arm64 the odd man out
 _TARGET_ARCH=	${TARGET:S/arm64/aarch64/:S/riscv/riscv64/:S/arm/armv7/}
 .elif !defined(TARGET) && defined(TARGET_ARCH) && \
     ${TARGET_ARCH} != ${MACHINE_ARCH}
 # TA->T mapping is accidentally CPUARCH with aarch64 the odd man out
 _TARGET=	${TARGET_ARCH:${__TO_CPUARCH}:C/aarch64/arm64/}
 .endif
 .if defined(TARGET) && !defined(_TARGET)
 _TARGET=${TARGET}
 .endif
 .if defined(TARGET_ARCH) && !defined(_TARGET_ARCH)
 _TARGET_ARCH=${TARGET_ARCH}
 .endif
 # for historical compatibility for xdev targets
 .if defined(XDEV)
 _TARGET=	${XDEV}
 .endif
 .if defined(XDEV_ARCH)
 _TARGET_ARCH=	${XDEV_ARCH}
 .endif
 # Some targets require a set TARGET/TARGET_ARCH, check before the default
 # MACHINE and after the compatibility handling.
 .if !defined(_TARGET) || !defined(_TARGET_ARCH)
 ${XTGTS}: _assert_target
 .endif
 # Otherwise, default to current machine type and architecture.
 _TARGET?=	${MACHINE}
 _TARGET_ARCH?=	${MACHINE_ARCH}
 
 .if make(native-xtools*)
 NXB_TARGET:=		${_TARGET}
 NXB_TARGET_ARCH:=	${_TARGET_ARCH}
 _TARGET=		${MACHINE}
 _TARGET_ARCH=		${MACHINE_ARCH}
 _MAKE+=			NXB_TARGET=${NXB_TARGET} \
 			NXB_TARGET_ARCH=${NXB_TARGET_ARCH}
 .endif
 
 .if make(print-dir)
 .SILENT:
 .endif
 
 _assert_target: .PHONY .MAKE
 .for _tgt in ${XTGTS}
 .if make(${_tgt})
 	@echo "*** Error: Both TARGET and TARGET_ARCH must be defined for \"${_tgt}\" target"
 	@false
 .endif
 .endfor
 
 #
 # Make sure we have an up-to-date make(1). Only world and buildworld
 # should do this as those are the initial targets used for upgrades.
 # The user can define ALWAYS_CHECK_MAKE to have this check performed
 # for all targets.
 #
 .if defined(ALWAYS_CHECK_MAKE) || !defined(.PARSEDIR)
 ${TGTS}: upgrade_checks
 .else
 buildworld: upgrade_checks
 .endif
 
 #
 # Handle the user-driven targets, using the source relative mk files.
 #
 
 tinderbox toolchains kernel-toolchains: .MAKE
 ${TGTS}: .PHONY .MAKE
 	${_+_}@cd ${.CURDIR}; ${_MAKE} ${.TARGET}
 
 # The historic default "all" target creates files which may cause stale
 # or (in the cross build case) unlinkable results. Fail with an error
 # when no target is given. The users can explicitly specify "all"
 # if they want the historic behavior.
 .MAIN:	_guard
 
 _guard: .PHONY
 	@echo
 	@echo "Explicit target required.  Likely \"${SUBDIR_OVERRIDE:Dall:Ubuildworld}\" is wanted.  See build(7)."
 	@echo
 	@false
 
 STARTTIME!= LC_ALL=C date
 CHECK_TIME!= cmp=`mktemp`; find ${.CURDIR}/sys/sys/param.h -newer "$$cmp" && rm "$$cmp"; echo
 .if !empty(CHECK_TIME)
 .error check your date/time: ${STARTTIME}
 .endif
 
 .if defined(HISTORICAL_MAKE_WORLD) || defined(DESTDIR)
 #
 # world
 #
 # Attempt to rebuild and reinstall everything. This target is not to be
 # used for upgrading an existing FreeBSD system, because the kernel is
 # not included. One can argue that this target doesn't build everything
 # then.
 #
 world: upgrade_checks .PHONY
 	@echo "--------------------------------------------------------------"
 	@echo ">>> make world started on ${STARTTIME}"
 	@echo "--------------------------------------------------------------"
 .if target(pre-world)
 	@echo
 	@echo "--------------------------------------------------------------"
 	@echo ">>> Making 'pre-world' target"
 	@echo "--------------------------------------------------------------"
 	${_+_}@cd ${.CURDIR}; ${_MAKE} pre-world
 .endif
 	${_+_}@cd ${.CURDIR}; ${_MAKE} buildworld
 	${_+_}@cd ${.CURDIR}; ${_MAKE} installworld MK_META_MODE=no
 .if target(post-world)
 	@echo
 	@echo "--------------------------------------------------------------"
 	@echo ">>> Making 'post-world' target"
 	@echo "--------------------------------------------------------------"
 	${_+_}@cd ${.CURDIR}; ${_MAKE} post-world
 .endif
 	@echo
 	@echo "--------------------------------------------------------------"
 	@echo ">>> make world completed on `LC_ALL=C date`"
 	@echo "                   (started ${STARTTIME})"
 	@echo "--------------------------------------------------------------"
 .else
 world: .PHONY
 	@echo "WARNING: make world will overwrite your existing FreeBSD"
 	@echo "installation without also building and installing a new"
 	@echo "kernel.  This can be dangerous.  Please read the handbook,"
 	@echo "'Rebuilding world', for how to upgrade your system."
 	@echo "Define DESTDIR to where you want to install FreeBSD,"
 	@echo "including /, to override this warning and proceed as usual."
 	@echo ""
 	@echo "Bailing out now..."
 	@false
 .endif
 
 #
 # kernel
 #
 # Short hand for `make buildkernel installkernel'
 #
 kernel: buildkernel installkernel .PHONY
 
 #
 # Perform a few tests to determine if the installed tools are adequate
 # for building the world.
 #
 upgrade_checks: .PHONY
 .if defined(NEED_MAKE_UPGRADE)
 	@${_+_}(cd ${.CURDIR} && ${MAKE} ${WANT_MAKE:S,^f,,})
 .endif
 
 #
 # Upgrade make(1) to the current version using the installed
 # headers, libraries and tools.  Also, allow the location of
 # the system bsdmake-like utility to be overridden.
 #
 MMAKEENV=	\
 		DESTDIR= \
 		INSTALL="sh ${.CURDIR}/tools/install.sh"
 MMAKE=		${MMAKEENV} ${MAKE} \
 		OBJTOP=${MYMAKE:H}/obj \
 		OBJROOT='$${OBJTOP}/' \
 		MAKEOBJDIRPREFIX= \
 		MAN= -DNO_SHARED \
 		-DNO_CPU_CFLAGS -DNO_WERROR \
 		-DNO_SUBDIR \
 		DESTDIR= PROGNAME=${MYMAKE:T}
 
 bmake: .PHONY
 	@echo
 	@echo "--------------------------------------------------------------"
 	@echo ">>> Building an up-to-date ${.TARGET}(1)"
 	@echo "--------------------------------------------------------------"
 	${_+_}@cd ${.CURDIR}/usr.bin/${.TARGET}; \
 		${MMAKE} obj; \
 		${MMAKE} depend; \
 		${MMAKE} all; \
 		${MMAKE} install DESTDIR=${MYMAKE:H} BINDIR=
 
 regress: .PHONY
 	@echo "'make regress' has been renamed 'make check'" | /usr/bin/fmt
 	@false
 
 tinderbox toolchains kernel-toolchains kernels worlds: upgrade_checks
 
 tinderbox: .PHONY
 	@cd ${.CURDIR}; ${SUB_MAKE} DOING_TINDERBOX=YES universe
 
 toolchains: .PHONY
 	@cd ${.CURDIR}; ${SUB_MAKE} UNIVERSE_TARGET=toolchain universe
 
 kernel-toolchains: .PHONY
 	@cd ${.CURDIR}; ${SUB_MAKE} UNIVERSE_TARGET=kernel-toolchain universe
 
 kernels: .PHONY
 	@cd ${.CURDIR}; ${SUB_MAKE} UNIVERSE_TARGET=buildkernel universe
 
 worlds: .PHONY
 	@cd ${.CURDIR}; ${SUB_MAKE} UNIVERSE_TARGET=buildworld universe
 
 #
 # universe
 #
 # Attempt to rebuild *everything* for all supported architectures,
 # with a reasonable chance of success, regardless of how old your
 # existing system is.
 #
 .if make(universe) || make(universe_kernels) || make(tinderbox) || \
     make(targets) || make(universe-toolchain)
 #
 # Don't build rarely used architectures unless requested.
 #
 .if defined(EXTRA_TARGETS)
 EXTRA_ARCHES_mips=	mipsel mipshf mipselhf mips64el mips64hf mips64elhf
 EXTRA_ARCHES_mips+=	mipsn32
 .endif
 TARGETS?=amd64 arm arm64 i386 mips powerpc riscv
 _UNIVERSE_TARGETS=	${TARGETS}
 TARGET_ARCHES_arm?=	armv6 armv7
 TARGET_ARCHES_arm64?=	aarch64
 TARGET_ARCHES_mips?=	mips mips64 ${EXTRA_ARCHES_mips}
 # powerpcspe excluded until clang fixed
 TARGET_ARCHES_powerpc?=	powerpc powerpc64
 TARGET_ARCHES_riscv?=	riscv64 riscv64sf
 .for target in ${TARGETS}
 TARGET_ARCHES_${target}?= ${target}
 .endfor
 
 # Remove architectures only supported by external toolchain from
 # universe if required toolchain packages are missing.
 # Note: We no longer have targets that require an external toolchain, but for
 # now keep this block in case a new non-LLVM architecture is added and to reuse
 # it for a future extenal GCC make universe variant.
 _external_toolchain_targets=
 .for target in ${_external_toolchain_targets}
 .if ${_UNIVERSE_TARGETS:M${target}}
 .for toolchain in ${TOOLCHAINS_${target}}
 .if !exists(/usr/local/share/toolchains/${toolchain}.mk)
 _UNIVERSE_TARGETS:= ${_UNIVERSE_TARGETS:N${target}}
 universe: universe_${toolchain}_skip .PHONY
 universe_epilogue: universe_${toolchain}_skip .PHONY
 universe_${toolchain}_skip: universe_prologue .PHONY
 	@echo ">> ${target} skipped - install ${toolchain} port or package to build"
 .endif
 .endfor
 .endif
 .endfor
 
-.if defined(UNIVERSE_TARGET)
-MAKE_JUST_WORLDS=	YES
-.else
 UNIVERSE_TARGET?=	buildworld
-.endif
 KERNSRCDIR?=		${.CURDIR}/sys
 
 targets:	.PHONY
 	@echo "Supported TARGET/TARGET_ARCH pairs for world and kernel targets"
 .for target in ${TARGETS}
 .for target_arch in ${TARGET_ARCHES_${target}}
 	@echo "    ${target}/${target_arch}"
 .endfor
 .endfor
 
 .if defined(DOING_TINDERBOX)
 FAILFILE=${.CURDIR}/_.tinderbox.failed
 MAKEFAIL=tee -a ${FAILFILE}
 .else
 MAKEFAIL=cat
 .endif
 
 universe_prologue:  upgrade_checks
 universe: universe_prologue
 universe_prologue: .PHONY
 	@echo "--------------------------------------------------------------"
 	@echo ">>> make universe started on ${STARTTIME}"
 	@echo "--------------------------------------------------------------"
 .if defined(DOING_TINDERBOX)
 	@rm -f ${FAILFILE}
 .endif
 
 universe-toolchain: .PHONY universe_prologue
 	@echo "--------------------------------------------------------------"
 	@echo "> Toolchain bootstrap started on `LC_ALL=C date`"
 	@echo "--------------------------------------------------------------"
 	${_+_}@cd ${.CURDIR}; \
 	    env PATH=${PATH} ${SUB_MAKE} ${JFLAG} kernel-toolchain \
 	    TARGET=${MACHINE} TARGET_ARCH=${MACHINE_ARCH} \
 	    OBJTOP="${HOST_OBJTOP}" \
 	    WITHOUT_SYSTEM_COMPILER=yes \
 	    WITHOUT_SYSTEM_LINKER=yes \
 	    TOOLS_PREFIX_UNDEF= \
 	    kernel-toolchain \
 	    MK_LLVM_TARGET_ALL=yes \
 	    > _.${.TARGET} 2>&1 || \
 	    (echo "${.TARGET} failed," \
 	    "check _.${.TARGET} for details" | \
 	    ${MAKEFAIL}; false)
 	@if [ ! -e "${HOST_OBJTOP}/tmp/usr/bin/cc" ]; then \
 	    echo "Missing host compiler at ${HOST_OBJTOP}/tmp/usr/bin/cc?" >&2; \
 	    false; \
 	fi
 	@if [ ! -e "${HOST_OBJTOP}/tmp/usr/bin/ld" ]; then \
 	    echo "Missing host linker at ${HOST_OBJTOP}/tmp/usr/bin/ld?" >&2; \
 	    false; \
 	fi
 	@echo "--------------------------------------------------------------"
 	@echo "> Toolchain bootstrap completed on `LC_ALL=C date`"
 	@echo "--------------------------------------------------------------"
 
 .for target in ${_UNIVERSE_TARGETS}
 universe: universe_${target}
 universe_epilogue: universe_${target}
 universe_${target}: universe_${target}_prologue .PHONY
 universe_${target}_prologue: universe_prologue .PHONY
 	@echo ">> ${target} started on `LC_ALL=C date`"
 universe_${target}_worlds: .PHONY
 
 .if !make(targets) && !make(universe-toolchain)
 .for target_arch in ${TARGET_ARCHES_${target}}
 .if !defined(_need_clang_${target}_${target_arch})
 _need_clang_${target}_${target_arch} != \
 	env TARGET=${target} TARGET_ARCH=${target_arch} \
 	${SUB_MAKE} -C ${.CURDIR} -f Makefile.inc1 test-system-compiler \
 	    ${MAKE_PARAMS_${target}} -V MK_CLANG_BOOTSTRAP 2>/dev/null || \
 	    echo unknown
 .export _need_clang_${target}_${target_arch}
 .endif
 .if !defined(_need_lld_${target}_${target_arch})
 _need_lld_${target}_${target_arch} != \
 	env TARGET=${target} TARGET_ARCH=${target_arch} \
 	${SUB_MAKE} -C ${.CURDIR} -f Makefile.inc1 test-system-linker \
 	    ${MAKE_PARAMS_${target}} -V MK_LLD_BOOTSTRAP 2>/dev/null || \
 	    echo unknown
 .export _need_lld_${target}_${target_arch}
 .endif
 # Setup env for each arch to use the one clang.
 .if defined(_need_clang_${target}_${target_arch}) && \
     ${_need_clang_${target}_${target_arch}} == "yes"
 # No check on existing XCC or CROSS_BINUTILS_PREFIX, etc, is needed since
 # we use the test-system-compiler logic to determine if clang needs to be
 # built.  It will be no from that logic if already using an external
 # toolchain or /usr/bin/cc.
 # XXX: Passing HOST_OBJTOP into the PATH would allow skipping legacy,
 #      bootstrap-tools, and cross-tools.  Need to ensure each tool actually
 #      supports all TARGETS though.
 # For now we only pass UNIVERSE_TOOLCHAIN_PATH which will be added at the end
 # of STRICTTMPPATH to ensure that the target-specific binaries come first.
 MAKE_PARAMS_${target}+= \
 	XCC="${HOST_OBJTOP}/tmp/usr/bin/cc" \
 	XCXX="${HOST_OBJTOP}/tmp/usr/bin/c++" \
 	XCPP="${HOST_OBJTOP}/tmp/usr/bin/cpp" \
 	UNIVERSE_TOOLCHAIN_PATH=${HOST_OBJTOP}/tmp/usr/bin
 .endif
 .if defined(_need_lld_${target}_${target_arch}) && \
     ${_need_lld_${target}_${target_arch}} == "yes"
 MAKE_PARAMS_${target}+= \
 	XLD="${HOST_OBJTOP}/tmp/usr/bin/ld"
 .endif
 .endfor
 .endif	# !make(targets)
 
-.if !defined(MAKE_JUST_KERNELS)
+.if ${__DO_WORLDS} == "yes"
 universe_${target}_done: universe_${target}_worlds .PHONY
 .for target_arch in ${TARGET_ARCHES_${target}}
 universe_${target}_worlds: universe_${target}_${target_arch} .PHONY
 .if (defined(_need_clang_${target}_${target_arch}) && \
     ${_need_clang_${target}_${target_arch}} == "yes") || \
     (defined(_need_lld_${target}_${target_arch}) && \
     ${_need_lld_${target}_${target_arch}} == "yes")
 universe_${target}_${target_arch}: universe-toolchain
 universe_${target}_prologue: universe-toolchain
 .endif
 universe_${target}_${target_arch}: universe_${target}_prologue .MAKE .PHONY
 	@echo ">> ${target}.${target_arch} ${UNIVERSE_TARGET} started on `LC_ALL=C date`"
 	@(cd ${.CURDIR} && env __MAKE_CONF=/dev/null \
 	    ${SUB_MAKE} ${JFLAG} ${UNIVERSE_TARGET} \
 	    TARGET=${target} \
 	    TARGET_ARCH=${target_arch} \
 	    ${MAKE_PARAMS_${target}} \
 	    > _.${target}.${target_arch}.${UNIVERSE_TARGET} 2>&1 || \
 	    (echo "${target}.${target_arch} ${UNIVERSE_TARGET} failed," \
 	    "check _.${target}.${target_arch}.${UNIVERSE_TARGET} for details" | \
 	    ${MAKEFAIL}))
 	@echo ">> ${target}.${target_arch} ${UNIVERSE_TARGET} completed on `LC_ALL=C date`"
 .endfor
-.endif # !MAKE_JUST_KERNELS
+.endif # ${__DO_WORLDS} == "yes"
 
-.if !defined(MAKE_JUST_WORLDS)
+.if ${__DO_KERNELS} == "yes"
 universe_${target}_done: universe_${target}_kernels .PHONY
 universe_${target}_kernels: universe_${target}_worlds .PHONY
 universe_${target}_kernels: universe_${target}_prologue .MAKE .PHONY
 	@if [ -e "${KERNSRCDIR}/${target}/conf/NOTES" ]; then \
 	  (cd ${KERNSRCDIR}/${target}/conf && env __MAKE_CONF=/dev/null \
 	    ${SUB_MAKE} LINT \
 	    > ${.CURDIR}/_.${target}.makeLINT 2>&1 || \
 	    (echo "${target} 'make LINT' failed," \
 	    "check _.${target}.makeLINT for details"| ${MAKEFAIL})); \
 	fi
 	@cd ${.CURDIR}; ${SUB_MAKE} ${.MAKEFLAGS} TARGET=${target} \
 	    universe_kernels
-.endif # !MAKE_JUST_WORLDS
+.endif # ${__DO_KERNELS} == "yes"
 
 # Tell the user the worlds and kernels have completed
 universe_${target}: universe_${target}_done
 universe_${target}_done:
 	@echo ">> ${target} completed on `LC_ALL=C date`"
 .endfor
 .if make(universe_kernconfs) || make(universe_kernels)
 .if !defined(TARGET)
 TARGET!=	uname -m
 .endif
 universe_kernels_prologue: .PHONY
 	@echo ">> ${TARGET} kernels started on `LC_ALL=C date`"
 universe_kernels: universe_kernconfs .PHONY
 	@echo ">> ${TARGET} kernels completed on `LC_ALL=C date`"
 .if defined(MAKE_ALL_KERNELS)
 _THINNER=cat
 .elif defined(MAKE_LINT_KERNELS)
 _THINNER=grep 'LINT' || true
 .else
 _THINNER=xargs grep -L "^.NO_UNIVERSE" || true
 .endif
 KERNCONFS!=	cd ${KERNSRCDIR}/${TARGET}/conf && \
 		find [[:upper:][:digit:]]*[[:upper:][:digit:]] \
 		-type f -maxdepth 0 \
 		! -name DEFAULTS ! -name NOTES | \
 		${_THINNER}
 universe_kernconfs: universe_kernels_prologue .PHONY
 .for kernel in ${KERNCONFS}
 TARGET_ARCH_${kernel}!=	cd ${KERNSRCDIR}/${TARGET}/conf && \
 	config -m ${KERNSRCDIR}/${TARGET}/conf/${kernel} 2> /dev/null | \
 	grep -v WARNING: | cut -f 2
 .if empty(TARGET_ARCH_${kernel})
 .error "Target architecture for ${TARGET}/conf/${kernel} unknown.  config(8) likely too old."
 .endif
 universe_kernconfs_${TARGET_ARCH_${kernel}}: universe_kernconf_${TARGET}_${kernel}
 universe_kernconf_${TARGET}_${kernel}: .MAKE
 	@echo ">> ${TARGET}.${TARGET_ARCH_${kernel}} ${kernel} kernel started on `LC_ALL=C date`"
 	@(cd ${.CURDIR} && env __MAKE_CONF=/dev/null \
 	    ${SUB_MAKE} ${JFLAG} buildkernel \
 	    TARGET=${TARGET} \
 	    TARGET_ARCH=${TARGET_ARCH_${kernel}} \
 	    ${MAKE_PARAMS_${TARGET}} \
 	    KERNCONF=${kernel} \
 	    > _.${TARGET}.${kernel} 2>&1 || \
 	    (echo "${TARGET} ${kernel} kernel failed," \
 	    "check _.${TARGET}.${kernel} for details"| ${MAKEFAIL}))
 	@echo ">> ${TARGET}.${TARGET_ARCH_${kernel}} ${kernel} kernel completed on `LC_ALL=C date`"
 .endfor
 .for target_arch in ${TARGET_ARCHES_${TARGET}}
 universe_kernconfs: universe_kernconfs_${target_arch} .PHONY
 universe_kernconfs_${target_arch}:
 .endfor
 .endif	# make(universe_kernels)
 universe: universe_epilogue
 universe_epilogue: .PHONY
 	@echo "--------------------------------------------------------------"
 	@echo ">>> make universe completed on `LC_ALL=C date`"
 	@echo "                      (started ${STARTTIME})"
 	@echo "--------------------------------------------------------------"
 .if defined(DOING_TINDERBOX)
 	@if [ -e ${FAILFILE} ] ; then \
 		echo "Tinderbox failed:" ;\
 		cat ${FAILFILE} ;\
 		exit 1 ;\
 	fi
 .endif
 .endif
 
 buildLINT: .PHONY
 	${MAKE} -C ${.CURDIR}/sys/${_TARGET}/conf LINT
 
 .if defined(.PARSEDIR)
 # This makefile does not run in meta mode
 .MAKE.MODE= normal
 # Normally the things we run from here don't either.
 # Using -DWITH_META_MODE
 # we can buildworld with meta files created which are useful 
 # for debugging, but without any of the rest of a meta mode build.
 MK_DIRDEPS_BUILD= no
 MK_STAGING= no
 # tell meta.autodep.mk to not even think about updating anything.
 UPDATE_DEPENDFILE= NO
 .if !make(showconfig)
 .export MK_DIRDEPS_BUILD MK_STAGING UPDATE_DEPENDFILE
 .endif
 
 .if make(universe)
 # we do not want a failure of one branch abort all.
 MAKE_JOB_ERROR_TOKEN= no
 .export MAKE_JOB_ERROR_TOKEN
 .endif
 .endif # bmake
 
 .endif				# DIRDEPS_BUILD
Index: head/share/man/man7/build.7
===================================================================
--- head/share/man/man7/build.7	(revision 359493)
+++ head/share/man/man7/build.7	(revision 359494)
@@ -1,827 +1,833 @@
 .\" Copyright (c) 2000
 .\"	Mike W. Meyer
 .\"
 .\" Redistribution and use in source and binary forms, with or without
 .\" modification, are permitted provided that the following conditions
 .\" are met:
 .\" 1. Redistributions of source code must retain the above copyright
 .\"    notice, this list of conditions and the following disclaimer.
 .\" 2. Redistributions in binary form must reproduce the above copyright
 .\"    notice, this list of conditions and the following disclaimer in the
 .\"    documentation and/or other materials provided with the distribution.
 .\"
 .\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND
 .\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 .\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 .\" ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE
 .\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 .\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 .\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 .\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 .\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 .\" SUCH DAMAGE.
 .\"
 .\" $FreeBSD$
 .\"
-.Dd December 3, 2018
+.Dd March 29, 2020
 .Dt BUILD 7
 .Os
 .Sh NAME
 .Nm build
 .Nd information on how to build the system
 .Sh DESCRIPTION
 The sources for the
 .Fx
 system and its applications are contained in three different directories,
 normally
 .Pa /usr/src ,
 .Pa /usr/doc ,
 and
 .Pa /usr/ports .
 These directories may be initially empty or non-existent until updated with
 .Xr svn 1
 or
 .Xr svnlite 1
 or
 .Xr portsnap 8 .
 Directory
 .Pa /usr/src
 contains the
 .Dq "base system"
 sources, which is loosely defined as the things required to rebuild
 the system to a useful state.
 Directory
 .Pa /usr/doc
 contains the source for the system documentation, excluding the manual
 pages.
 Directory
 .Pa /usr/ports
 contains a tree that provides a consistent interface for building and
 installing third party applications.
 For more information about the ports build process, see
 .Xr ports 7 .
 .Pp
 The
 .Xr make 1
 command is used in each of these directories to build and install the
 things in that directory.
 Issuing the
 .Xr make 1
 command in any directory or
 subdirectory of those directories has the same effect as issuing the
 same command in all subdirectories of that directory.
 With no target specified, the things in that directory are just built.
 .Pp
 A source tree is allowed to be read-only.
 As described in
 .Xr make 1 ,
 objects are usually built in a separate object directory hierarchy
 specified by the environment variable
 .Va MAKEOBJDIRPREFIX ,
 or under
 .Pa /usr/obj
 if variable
 .Va MAKEOBJDIRPREFIX
 is not set.
 The canonical object directory is described in the documentation for the
 .Cm buildworld
 target below.
 .Pp
 The build may be controlled by defining
 .Xr make 1
 variables described in the
 .Sx ENVIRONMENT
 section below, and by the variables documented in
 .Xr make.conf 5 .
 .Pp
 The following list provides the names and actions for the targets
 supported by the build system:
 .Bl -tag -width ".Cm cleandepend"
 .It Cm analyze
 Run Clang static analyzer against all objects and present output on stdout.
 .It Cm check
 Run tests for a given subdirectory.
 The default directory used is
 .Pa ${.OBJDIR} ,
 but the check directory can be changed with
 .Pa ${CHECKDIR} .
 .It Cm checkworld
 Run the
 .Fx
 test suite on installed world.
 .It Cm clean
 Remove any files created during the build process.
 .It Cm cleandepend
 Remove the
 .Pa ${.OBJDIR}/${DEPENDFILE}*
 files generated by prior
 .Dq Li "make"
 and
 .Dq Li "make depend"
 steps.
 .It Cm cleandir
 Remove the canonical object directory if it exists, or perform
 actions equivalent to
 .Dq Li "make clean cleandepend"
 if it does not.
 This target will also remove an
 .Pa obj
 link in
 .Pa ${.CURDIR}
 if that exists.
 .Pp
 It is advisable to run
 .Dq Li "make cleandir"
 twice: the first invocation will remove the canonical object directory
 and the second one will clean up
 .Pa ${.CURDIR} .
 .It Cm depend
 Generate a list of build dependencies in file
 .Pa ${.OBJDIR}/${DEPENDFILE} .
 Per-object dependencies are generated at build time and stored in
 .Pa ${.OBJDIR}/${DEPENDFILE}.${OBJ} .
 .It Cm install
 Install the results of the build to the appropriate location in the
 installation directory hierarchy specified in variable
 .Va DESTDIR .
 .It Cm obj
 Create the canonical object directory associated with the current
 directory.
 .It Cm objlink
 Create a symbolic link to the canonical object directory in
 .Pa ${.CURDIR} .
 .It Cm tags
 Generate a tags file using the program specified in the
 .Xr make 1
 variable
 .Va CTAGS .
 The build system supports
 .Xr ctags 1
 and
 .Nm "GNU Global" .
 .El
 .Pp
 The other supported targets under directory
 .Pa /usr/src
 are:
 .Bl -tag -width ".Cm distributeworld"
 .It Cm buildenv
 Spawn an interactive shell with environment variables set up for
 building the system or individual components.
 For cross-building the target architecture needs to be specified with
 .Xr make 1
 variables
 .Va TARGET_ARCH
 and
 .Va TARGET .
 .Pp
 This target is only useful after a complete toolchain (including
 the compiler, linker, assembler, headers and libraries) has been
 built; see the
 .Cm toolchain
 target below.
 .It Cm buildworld
 Build everything but the kernel, configure files in
 .Pa etc ,
 and
 .Pa release .
 The object directory can be changed from the default
 .Pa /usr/obj
 by setting the
 .Pa MAKEOBJDIRPREFIX
 .Xr make 1
 variable.
 The actual build location prefix used
 depends on the
 .Va WITH_UNIFIED_OBJDIR
 option from
 .Xr src.conf 5 .
 If enabled it is
 .Pa ${MAKEOBJDIRPREFIX}${.CURDIR}/${TARGET}.${TARGET_ARCH}
 for all builds.
 If disabled it is
 .Pa ${MAKEOBJDIRPREFIX}${.CURDIR}
 for native builds, and
 .Pa ${MAKEOBJDIRPREFIX}/${TARGET}.${TARGET_ARCH}${.CURDIR}
 for cross builds and native builds with variable
 .Va CROSS_BUILD_TESTING
 set.
 .It Cm cleanworld
 Attempt to clean up targets built by a preceding
 .Cm buildworld ,
 or similar step built from this source directory.
 .It Cm cleanuniverse
 When
 .Va WITH_UNIFIED_OBJDIR
 is enabled, attempt to clean up targets built by a preceding
 .Cm buildworld ,
 .Cm universe ,
 or similar step, for any architecture built from this source directory.
 .It Cm distributeworld
 Distribute everything compiled by a preceding
 .Cm buildworld
 step.
 Files are placed in the directory hierarchy specified by
 .Xr make 1
 variable
 .Va DISTDIR .
 This target is used while building a release; see
 .Xr release 7 .
 .It Cm native-xtools
 This target builds a cross-toolchain for the given
 .Sy TARGET
 and
 .Sy TARGET_ARCH ,
 as well as a select list of static userland tools for the host system.
 This is intended to be used in a jail where QEMU is used to improve
 performance by avoiding emulating binaries that do not need to be emulated.
 .Sy TARGET
 and
 .Sy TARGET_ARCH
 should be defined.
 .It Cm native-xtools-install
 Installs the results to
 .Pa ${DESTDIR}/${NXTP}
 where
 .Va NXTP
 defaults to
 .Pa nxb-bin .
 .Sy TARGET
 and
 .Sy TARGET_ARCH
 must be defined.
 .It Cm packageworld
 Archive the results of
 .Cm distributeworld ,
 placing the results in
 .Va DISTDIR .
 This target is used while building a release; see
 .Xr release 7 .
 .It Cm installworld
 Install everything built by a preceding
 .Cm buildworld
 step into the directory hierarchy pointed to by
 .Xr make 1
 variable
 .Va DESTDIR .
 .Pp
 If installing onto an NFS file system and running
 .Xr make 1
 with the
 .Fl j
 option, make sure that
 .Xr rpc.lockd 8
 is running on both client and server.
 See
 .Xr rc.conf 5
 on how to make it start at boot time.
 .It Cm toolchain
 Create the build toolchain needed to build the rest of the system.
 For cross-architecture builds, this step creates a cross-toolchain.
 .It Cm universe
 For each architecture,
 execute a
 .Cm buildworld
 followed by a
 .Cm buildkernel
 for all kernels for that architecture,
 including
 .Pa LINT .
 This command takes a long time.
 .It Cm update
 Get updated sources as configured in
 .Xr make.conf 5 .
 .It Cm targets
 Print a list of supported
 .Va TARGET
 /
 .Va TARGET_ARCH
 pairs for world and kernel targets.
 .It Cm tinderbox
 Execute the same targets as
 .Cm universe .
 In addition print a summary of all failed targets at the end and
 exit with an error if there were any.
 .It Cm toolchains
 Create a build toolchain for each architecture supported by the build system.
 .It Cm xdev
 Builds and installs a cross-toolchain and sysroot for the given
 .Sy TARGET
 and
 .Sy TARGET_ARCH .
 The sysroot contains target library and headers.
 The target is an alias for
 .Cm xdev-build
 and
 .Cm xdev-install .
 The location of the files installed can be controlled with
 .Va DESTDIR .
 The target location in
 .Va DESTDIR
 is
 .Pa ${DESTDIR}/${XDTP}
 where
 .Va XDTP
 defaults to
 .Pa /usr/${XDDIR}
 and
 .Va XDDIR
 defaults to
 .Pa ${TARGET_ARCH}-freebsd .
 .It Cm xdev-build
 Builds for the
 .Cm xdev
 target.
 .It Cm xdev-install
 Installs the files for the
 .Cm xdev
 target.
 .It Cm xdev-links
 Installs autoconf-style symlinks to
 .Pa ${DESTDIR}/usr/bin
 pointing into the xdev toolchain in
 .Pa ${DESTDIR}/${XDTP} .
 .El
 .Pp
 Kernel specific build targets in
 .Pa /usr/src
 are:
 .Bl -tag -width ".Cm distributekernel"
 .It Cm buildkernel
 Rebuild the kernel and the kernel modules.
 The object directory can be changed from the default
 .Pa /usr/obj
 by setting the
 .Pa MAKEOBJDIRPREFIX
 .Xr make 1
 variable.
 .It Cm installkernel
 Install the kernel and the kernel modules to directory
 .Pa ${DESTDIR}/boot/kernel ,
 renaming any pre-existing directory with this name to
 .Pa kernel.old
 if it contained the currently running kernel.
 The target directory under
 .Pa ${DESTDIR}
 may be modified using the
 .Va INSTKERNNAME
 and
 .Va KODIR
 .Xr make 1
 variables.
 .It Cm distributekernel
 Install the kernel to the directory
 .Pa ${DISTDIR}/kernel/boot/kernel .
 This target is used while building a release; see
 .Xr release 7 .
 .It Cm packagekernel
 Archive the results of
 .Cm distributekernel ,
 placing the results in
 .Va DISTDIR .
 This target is used while building a release; see
 .Xr release 7 .
 .It Cm kernel
 Equivalent to
 .Cm buildkernel
 followed by
 .Cm installkernel
 .It Cm kernel-toolchain
 Rebuild the tools needed for kernel compilation.
 Use this if you did not do a
 .Cm buildworld
 first.
 .It Cm reinstallkernel
 Reinstall the kernel and the kernel modules, overwriting the contents
 of the target directory.
 As with the
 .Cm installkernel
 target, the target directory can be specified using the
 .Xr make 1
 variable
 .Va INSTKERNNAME .
 .El
 .Pp
 Convenience targets for cleaning up the install destination directory
 denoted by variable
 .Va DESTDIR
 include:
 .Bl -tag -width ".Cm delete-old-libs"
 .It Cm check-old
 Print a list of old files and directories in the system.
 .It Cm delete-old
 Delete obsolete base system files and directories interactively.
 When
 .Li -DBATCH_DELETE_OLD_FILES
 is specified at the command line, the delete operation will be
 non-interactive.
 The variables
 .Va DESTDIR ,
 .Va TARGET_ARCH
 and
 .Va TARGET
 should be set as with
 .Dq Li "make installworld" .
 .It Cm delete-old-libs
 Delete obsolete base system libraries interactively.
 This target should only be used if no third party software uses these
 libraries.
 When
 .Li -DBATCH_DELETE_OLD_FILES
 is specified at the command line, the delete operation will be
 non-interactive.
 The variables
 .Va DESTDIR ,
 .Va TARGET_ARCH
 and
 .Va TARGET
 should be set as with
 .Dq Li "make installworld" .
 .El
 .Sh ENVIRONMENT
 Variables that influence all builds include:
 .Bl -tag -width ".Va MAKEOBJDIRPREFIX"
 .It Va DEBUG_FLAGS
 Defines a set of debugging flags that will be used to build all userland
 binaries under
 .Pa /usr/src .
 When
 .Va DEBUG_FLAGS
 is defined, the
 .Cm install
 and
 .Cm installworld
 targets install binaries from the current
 .Va MAKEOBJDIRPREFIX
 without stripping,
 so that debugging information is retained in the installed binaries.
 .It Va DESTDIR
 The directory hierarchy prefix where built objects will be installed.
 If not set,
 .Va DESTDIR
 defaults to the empty string.
 .It Va MAKEOBJDIRPREFIX
 Defines the prefix for directory names in the tree of built objects.
 Defaults to
 .Pa /usr/obj
 if not defined.
 This variable should only be set in the environment or
 .Pa /etc/src-env.conf
 and not via
 .Pa /etc/make.conf
 or
 .Pa /etc/src.conf
 or the command line.
 .It Va NO_WERROR
 If defined, compiler warnings will not cause the build to halt,
 even if the makefile says otherwise.
 .It Va WITH_CTF
 If defined, the build process will run the DTrace CTF conversion
 tools on built objects.
 .El
 .Pp
 Additionally, builds in
 .Pa /usr/src
 are influenced by the following
 .Xr make 1
 variables:
 .Bl -tag -width ".Va SUBDIR_OVERRIDE"
 .It Va KERNCONF
 Overrides which kernel to build and install for the various kernel
 make targets.
 It defaults to
 .Cm GENERIC .
 .It Va KERNCONFDIR
 Overrides the directory in which
 .Va KERNCONF
 and any files included by
 .Va KERNCONF
 should be found.
 Defaults to
 .Pa sys/${ARCH}/conf .
 .It Va KERNFAST
 If set, the build target
 .Cm buildkernel
 defaults to setting
 .Va NO_KERNELCLEAN ,
 .Va NO_KERNELCONFIG ,
 and
 .Va NO_KERNELOBJ .
 When set to a value other than
 .Cm 1
 then
 .Va KERNCONF
 is set to the value of
 .Va KERNFAST .
 .It Va LOCAL_DIRS
 If set, this variable supplies a list of additional directories relative to
 the root of the source tree to build as part of the
 .Cm everything
 target.
 The directories are built in parallel with each other,
 and with the base system directories.
 Insert a
 .Va .WAIT
 directive at the beginning of the
 .Va LOCAL_DIRS
 list to ensure all base system directories are built first.
 .Va .WAIT
 may also be used as needed elsewhere within the list.
 .It Va LOCAL_ITOOLS
 If set, this variable supplies a list of additional tools that are used by the
 .Cm installworld
 and
 .Cm distributeworld
 targets.
 .It Va LOCAL_LIB_DIRS
 If set, this variable supplies a list of additional directories relative to
 the root of the source tree to build as part of the
 .Cm libraries
 target.
 The directories are built in parallel with each other,
 and with the base system libraries.
 Insert a
 .Va .WAIT
 directive at the beginning of the
 .Va LOCAL_DIRS
 list to ensure all base system libraries are built first.
 .Va .WAIT
 may also be used as needed elsewhere within the list.
 .It Va LOCAL_MTREE
 If set, this variable supplies a list of additional mtrees relative to the
 root of the source tree to use as part of the
 .Cm hierarchy
 target.
 .It Va LOCAL_TOOL_DIRS
 If set, this variable supplies a list of additional directories relative to
 the root of the source tree to build as part of the
 .Cm build-tools
 target.
 .It Va LOCAL_XTOOL_DIRS
 If set, this variable supplies a list of additional directories relative to
 the root of the source tree to build as part of the
 .Cm cross-tools
 target.
 .It Va PORTS_MODULES
 A list of ports with kernel modules that should be built and installed
 as part of the
 .Cm buildkernel
 and
 .Cm installkernel
 process.
 .Bd -literal -offset indent
 make PORTS_MODULES=emulators/kqemu-kmod kernel
 .Ed
 .It Va STRIPBIN
 Command to use at install time when stripping binaries.
 Be sure to add any additional tools required to run
 .Va STRIPBIN
 to the
 .Va LOCAL_ITOOLS
 .Xr make 1
 variable before running the
 .Cm distributeworld
 or
 .Cm installworld
 targets.
 See
 .Xr install 1
 for more details.
 .It Va SUBDIR_OVERRIDE
 Override the default list of sub-directories and only build the
 sub-directory named in this variable.
 If combined with
 .Cm buildworld
 then all libraries and includes, and some of the build tools will still build
 as well.
 Specifying
 .Cm -DNO_LIBS ,
 and
 .Cm -DWORLDFAST
 will only build the specified directory as was done historically.
 When combined with
 .Cm buildworld
 it is necesarry to override
 .Va LOCAL_LIB_DIRS
 with any custom directories containing libraries.
 This allows building a subset of the system in the same way as
 .Cm buildworld
 does using its sysroot handling.
 This variable can also be useful when debugging failed builds.
 .Bd -literal -offset indent
 make some-target SUBDIR_OVERRIDE=foo/bar
 .Ed
 .It Va TARGET
 The target hardware platform.
 This is analogous to the
 .Dq Nm uname Fl m
 output.
 This is necessary to cross-build some target architectures.
 For example, cross-building for ARM64 machines requires
 .Va TARGET_ARCH Ns = Ns Li aarch64
 and
 .Va TARGET Ns = Ns Li arm64 .
 If not set,
 .Va TARGET
 defaults to the current hardware platform, unless
 .Va TARGET_ARCH
 is also set, in which case it defaults to the appropriate
 value for that architecture.
 .It Va TARGET_ARCH
 The target machine processor architecture.
 This is analogous to the
 .Dq Nm uname Fl p
 output.
 Set this to cross-build for a different architecture.
 If not set,
 .Va TARGET_ARCH
 defaults to the current machine architecture, unless
 .Va TARGET
 is also set, in which case it defaults to the appropriate
 value for that platform.
 Typically, one only needs to set
 .Va TARGET .
 .El
 .Pp
 Builds under directory
 .Pa /usr/src
 are also influenced by defining one or more of the following symbols,
 using the
 .Fl D
 option of
 .Xr make 1 :
 .Bl -tag -width ".Va -DNO_KERNELCONFIG"
 .It Va LOADER_DEFAULT_INTERP
 Defines what interpreter the default loader program will have.
 Valid values include
 .Dq 4th ,
 .Dq lua ,
 and
 .Dq simp .
 This creates the default link for
 .Pa /boot/loader
 to the loader with that interpreter.
 It also determines what interpreter is compiled into
 .Pa userboot .
 .It Va NO_CLEANDIR
 If set, the build targets that clean parts of the object tree use the
 equivalent of
 .Dq make clean
 instead of
 .Dq make cleandir .
 .It Va NO_CLEAN
 If set, no object tree files are cleaned at all.
 This is the default when
 .Va WITH_META_MODE
 is used with
 .Xr filemon 4
 loaded.
 See
 .Xr src.conf 5
 for more details.
 Setting
 .Va NO_CLEAN
 implies
 .Va NO_KERNELCLEAN ,
 so when
 .Va NO_CLEAN
 is set no kernel objects are cleaned either.
 .It Va NO_CTF
 If set, the build process does not run the DTrace CTF conversion tools
 on built objects.
 .It Va NO_SHARE
 If set, the build does not descend into the
 .Pa /usr/src/share
 subdirectory (i.e., manual pages, locale data files, timezone data files and
 other
 .Pa /usr/src/share
 files will not be rebuild from their sources).
 .It Va NO_KERNELCLEAN
 If set, the build process does not run
 .Dq make clean
 as part of the
 .Cm buildkernel
 target.
 .It Va NO_KERNELCONFIG
 If set, the build process does not run
 .Xr config 8
 as part of the
 .Cm buildkernel
 target.
 .It Va NO_KERNELOBJ
 If set, the build process does not run
 .Dq make obj
 as part of the
 .Cm buildkernel
 target.
 .It Va NO_DOCUPDATE
 If set, the update process does not update the source of the
 .Fx
 documentation as part of the
 .Dq make update
 target.
 .It Va NO_LIBS
 If set, the libraries phase will be skipped.
 .It Va NO_OBJWALK
 If set, no object directories will be created.
 This should only be used if object directories were created in a
 previous build and no new directories are connected.
 .It Va NO_PORTSUPDATE
 If set, the update process does not update the Ports tree as part of the
 .Dq make update
 target.
 .It Va NO_WWWUPDATE
 If set, the update process does not update the www tree as part of the
 .Dq make update
 target.
 .It Va WORLDFAST
 If set, the build target
 .Cm buildworld
 defaults to setting
 .Va NO_CLEAN ,
 .Va NO_OBJWALK ,
 and will skip most bootstrap phases.
 It will only bootstrap libraries and build all of userland.
 This option should be used only when it is known that none of the bootstrap
 needs changed and that no new directories have been connected to the build.
 .El
 .Pp
 Builds under directory
 .Pa /usr/doc
 are influenced by the following
 .Xr make 1
 variables:
 .Bl -tag -width ".Va DOC_LANG"
 .It Va DOC_LANG
 If set, restricts the documentation build to the language subdirectories
 specified as its content.
 The default action is to build documentation for all languages.
 .El
 .Pp
 Builds using the
 .Cm universe
 target are influenced by the following
 .Xr make 1
 variables:
 .Bl -tag -width ".Va MAKE_JUST_KERNELS"
 .It Va JFLAG
 Pass the value of this variable to each
 .Xr make 1
 invocation used to build worlds and kernels.
 This can be used to enable multiple jobs within a single architecture's build
 while still building each architecture serially.
 .It Va MAKE_JUST_KERNELS
 Only build kernels for each supported architecture.
 .It Va MAKE_JUST_WORLDS
 Only build worlds for each supported architecture.
+.It Va WITHOUT_WORLDS
+Only build kernels for each supported architecture.
+.It Va WITHOUT_KERNELS
+Only build worlds for each supported architecture.
 .It Va UNIVERSE_TARGET
 Execute the specified
 .Xr make 1
 target for each supported architecture instead of the default action of
 building a world and one or more kernels.
+This variable implies
+.Va WITHOUT_KERNELS .
 .El
 .Sh FILES
 .Bl -tag -width ".Pa /usr/share/examples/etc/make.conf" -compact
 .It Pa /usr/doc/Makefile
 .It Pa /usr/doc/share/mk/doc.project.mk
 .It Pa /usr/ports/Mk/bsd.port.mk
 .It Pa /usr/ports/Mk/bsd.sites.mk
 .It Pa /usr/share/examples/etc/make.conf
 .It Pa /usr/src/Makefile
 .It Pa /usr/src/Makefile.inc1
 .El
 .Sh EXAMPLES
 For an
 .Dq approved
 method of updating your system from the latest sources, please see the
 .Sx COMMON ITEMS
 section in
 .Pa src/UPDATING .
 .Pp
 The following sequence of commands can be used to cross-build the
 system for the armv6 architecture on an amd64 host:
 .Bd -literal -offset indent
 cd /usr/src
 make TARGET_ARCH=armv6 buildworld buildkernel
 make TARGET_ARCH=armv6 DESTDIR=/clients/arm installworld installkernel
 .Ed
 .Sh SEE ALSO
 .Xr cc 1 ,
 .Xr install 1 ,
 .Xr make 1 ,
 .Xr svn 1 ,
 .Xr svnlite 1 ,
 .Xr make.conf 5 ,
 .Xr src.conf 5 ,
 .Xr arch 7 ,
 .Xr ports 7 ,
 .Xr release 7 ,
 .Xr tests 7 ,
 .Xr config 8 ,
 .Xr mergemaster 8 ,
 .Xr portsnap 8 ,
 .Xr reboot 8 ,
 .Xr shutdown 8
 .Sh AUTHORS
 .An Mike W. Meyer Aq Mt mwm@mired.org