diff --git a/share/mk/gendirdeps.mk b/share/mk/gendirdeps.mk
index 1ff2036237ed..ec4e188cdf78 100644
--- a/share/mk/gendirdeps.mk
+++ b/share/mk/gendirdeps.mk
@@ -1,388 +1,421 @@
-# $Id: gendirdeps.mk,v 1.48 2022/09/09 17:44:29 sjg Exp $
+# $Id: gendirdeps.mk,v 1.49 2023/04/20 17:45:03 sjg Exp $
 
+# SPDX-License-Identifier: BSD-2-Clause
+#
 # Copyright (c) 2011-2020, Simon J. Gerraty
 # Copyright (c) 2010-2018, Juniper Networks, Inc.
 # All rights reserved.
 #
 # 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 COPYRIGHT HOLDERS AND CONTRIBUTORS
 # "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 COPYRIGHT
 # OWNER OR CONTRIBUTORS 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.
 
 #
 # This makefile [re]generates ${.MAKE.DEPENDFILE}
 #
 
 .include <install-new.mk>
 
 # Assumptions:
 #	RELDIR is the relative path from ${SRCTOP} to ${_CURDIR}
 #		(SRCTOP is ${SB}/src)
 #	_CURDIR is the absolute version of ${.CURDIR}
 #	_OBJDIR is the absolute version of ${.OBJDIR}
 #	_objroot is realpath of ${_OBJTOP} without ${MACHINE}
 #		this may be different from _OBJROOT if $SB/obj is a
 #		symlink to another filesystem.
 #		_objroot must be a prefix match for _objtop
 
+# If any of GENDIRDEPS_FILTER, GENDIRDEPS_FILTER_DIR_VARS
+# or GENDIRDEPS_FILTER_VARS are set, we use them to filter the
+# output from filemon(4).
+# Any references to variables that dirdeps.mk will set
+# such as DEP_MACHINE, DEP_RELDIR etc, should use that form.
+# Thus we want ${DEP_MACHINE} not ${MACHINE} used in DIRDEPS.
+#
+# If any manually maintained Makefile.depend files will use any
+# DEP_* variables in conditionals, precautions are needed to avoid
+# errors when Makefile.depend is read at level 1+ (ie not via
+# dirdeps.mk)
+# Using MACHINE as an example; such makefiles can do:
+#
+# 	DEP_MACHINE ?= ${MACHINE}
+# 	.if ${DEP_MACHINE} == "xyz"
+#
+# or:
+# 
+# 	.if ${DEP_MACHINE:U${MACHINE}} == "xyz"
+#
+# but it might be safer to set GENDIRDEPS_FILTER_DIR_VARS and
+# GENDIRDEPS_FILTER_VARS via local.meta.sys.mk rather than
+# local.gendirdeps.mk and then:
+#
+# 	.if ${.MAKE.LEVEL} > 0
+# 	.for V in ${GENDIRDEPS_FILTER_DIR_VARS:MDEP_*} \
+# 		${GENDIRDEPS_FILTER_VARS:MDEP_*}
+# 	$V ?= ${${V:S,DEP_,,}}
+# 	.endfor
+# 	.endif
+# 
 .MAIN: all
 
 # keep this simple
 .MAKE.MODE = compat
 
 all:
 
 _CURDIR ?= ${.CURDIR}
 _OBJDIR ?= ${.OBJDIR}
 _OBJTOP ?= ${OBJTOP}
 _OBJROOT ?= ${OBJROOT:U${_OBJTOP:H}}
 .if ${_OBJROOT:M*/}
 _slash=/
 .else
 _slash=
 .endif
 _objroot ?= ${_OBJROOT:tA}${_slash}
 
 _this = ${.PARSEDIR}/${.PARSEFILE}
 
 # remember what to make
 _DEPENDFILE := ${_CURDIR}/${.MAKE.DEPENDFILE:T}
 
 # We do _not_ want to read our own output!
 .MAKE.DEPENDFILE = /dev/null
 
 # caller should have set this
 META_FILES ?= ${.MAKE.META.FILES}
 
 .if !empty(META_FILES)
 
 .if ${.MAKE.LEVEL} > 0 && !empty(GENDIRDEPS_FILTER)
 # so we can compare below
 .-include <${_DEPENDFILE}>
 # yes, I mean :U with no value
 _DIRDEPS := ${DIRDEPS:U:O:u}
 .endif
 
 META_FILES := ${META_FILES:T:O:u}
 
 # pickup customizations
 .-include <local.gendirdeps.mk>
 
 # these are actually prefixes that we'll skip
 # they should all be absolute paths
 SKIP_GENDIRDEPS ?=
 .if !empty(SKIP_GENDIRDEPS)
 _skip_gendirdeps = ${EGREP:Uegrep} -v '^(${SKIP_GENDIRDEPS:O:u:ts|})' |
 .else
 _skip_gendirdeps =
 .endif
 
 # Below we will turn _{VAR} into ${VAR} which keeps this simple
 # GENDIRDEPS_FILTER_DIR_VARS is a list of dirs to be substiuted for.
 # GENDIRDEPS_FILTER_VARS is more general.
 # In each case order matters.
 .if !empty(GENDIRDEPS_FILTER_DIR_VARS)
 GENDIRDEPS_FILTER += ${GENDIRDEPS_FILTER_DIR_VARS:@v@S,${$v},_{${v}},@}
 .endif
 .if !empty(GENDIRDEPS_FILTER_VARS)
 GENDIRDEPS_FILTER += ${GENDIRDEPS_FILTER_VARS:@v@S,/${$v}/,/_{${v}}/,@:NS,//,*:u}
 .endif
 
 # this (*should* be set in meta.sys.mk)
 # is the script that extracts what we want.
 META2DEPS ?= ${.PARSEDIR}/meta2deps.sh
 META2DEPS := ${META2DEPS}
 
 .if ${DEBUG_GENDIRDEPS:Uno:@x@${RELDIR:M$x}@} != "" && ${DEBUG_GENDIRDEPS:Uno:Mmeta2d*} != ""
 _time = time
 _sh_x = sh -x
 _py_d = -ddd
 .else
 _time =
 _sh_x =
 _py_d =
 .endif
 
 .if ${META2DEPS:E} == "py"
 # we can afford to do this all the time.
 DPDEPS ?= no
 META2DEPS_CMD = ${_time} ${PYTHON} ${META2DEPS} ${_py_d}
 .if ${DPDEPS:tl} != "no"
 META2DEPS_CMD += -D ${DPDEPS}
 .endif
 META2DEPS_FILTER = sed 's,^src:,${SRCTOP}/,;s,^\([^/]\),${OBJTOP}/\1,' |
 .elif ${META2DEPS:E} == "sh"
 META2DEPS_CMD = ${_time} ${_sh_x} ${META2DEPS} OBJTOP=${_OBJTOP}
 .else
 META2DEPS_CMD ?= ${META2DEPS}
 .endif
 
 .if ${TARGET_OBJ_SPEC:U${MACHINE}} != ${MACHINE}
 META2DEPS_CMD += -T ${TARGET_OBJ_SPEC}
 .endif
 META2DEPS_CMD += \
 	-R ${RELDIR} -H ${HOST_TARGET} \
 	${M2D_OBJROOTS:O:u:@o@-O $o@} \
 	${M2D_EXCLUDES:O:u:@o@-X $o@} \
 
 
 M2D_OBJROOTS += ${OBJTOP} ${_OBJROOT} ${_objroot}
 .if defined(SB_OBJROOT)
 M2D_OBJROOTS += ${SB_OBJROOT}
 .endif
 .if defined(STAGE_ROOT)
 M2D_OBJROOTS += ${STAGE_ROOT}
 .endif
 .if ${.MAKE.DEPENDFILE_PREFERENCE:U${.MAKE.DEPENDFILE}:M*.${MACHINE}} == ""
 # meta2deps.py only groks objroot
 # so we need to give it what it expects
 # and tell it not to add machine qualifiers
 META2DEPS_ARGS += MACHINE=none
 .endif
 .if defined(SB_BACKING_SB)
 META2DEPS_CMD += -S ${SB_BACKING_SB}/src
 M2D_OBJROOTS += ${SB_BACKING_SB}/${SB_OBJPREFIX}
 .endif
 
 GENDIRDEPS_SEDCMDS += \
 	-e 's,//*$$,,;s,\.${HOST_TARGET:Uhost}$$,.host,' \
 	-e 's,\.${HOST_TARGET32:Uhost32}$$,.host32,' \
 	-e 's,\.${MACHINE}$$,,' \
 	-e 's:\.${TARGET_SPEC:U${MACHINE}}$$::'
 
 # we are only interested in the dirs
 # specifically those we read something from.
 # we canonicalize them to keep things simple
 # if we are using a split-fs sandbox, it gets a little messier.
 _objtop := ${_OBJTOP:tA}
 
 # some people put *.meta in META_XTRAS to make sure we get here
 _meta_files := ${META_FILES:N\*.meta:O:u}
 # assume a big list
 _meta_files_arg= @meta.list
 .if empty(_meta_files) && ${META_FILES:M\*.meta} != ""
 # XXX this should be considered a bad idea,
 # since we cannot ignore stale .meta
 x != cd ${_OBJDIR} && find . -name '*.meta' -print -o \( -type d ! -name . -prune \) | sed 's,^./,,' > meta.list; echo
 .elif ${_meta_files:[#]} > 500
 .export _meta_files
 x != echo; for m in $$_meta_files; do echo $$m; done > meta.list
 # _meta_files is consuming a lot of env space
 # that can impact command line length,
 # and we do not need it any more
 .undef _meta_files
 .unexport _meta_files
 .else
 _meta_files_arg:= ${_meta_files}
 .endif
 
 dir_list != cd ${_OBJDIR} && \
 	${META2DEPS_CMD} MACHINE=${MACHINE} \
 	SRCTOP=${SRCTOP} RELDIR=${RELDIR} CURDIR=${_CURDIR} \
 	${META2DEPS_ARGS} \
 	${_meta_files_arg} | ${META2DEPS_FILTER} ${_skip_gendirdeps} \
 	sed ${GENDIRDEPS_SEDCMDS}
 
 .if ${dir_list:M*ERROR\:*} != ""
 .warning ${dir_list:tW:C,.*(ERROR),\1,}
 .warning Skipping ${_DEPENDFILE:S,${SRCTOP}/,,}
 # we are not going to update anything
 .else
 dpadd_dir_list=
 .if !empty(DPADD)
 _nonlibs := ${DPADD:T:Nlib*:N*include}
 .if !empty(_nonlibs)
 ddep_list =
 .for f in ${_nonlibs:@x@${DPADD:M*/$x}@}
 .if exists($f.dirdep)
 ddep_list += $f.dirdep
 .elif exists(${f:H}.dirdep)
 ddep_list += ${f:H}.dirdep
 .else
 dir_list += ${f:H:tA}
 dpadd_dir_list += ${f:H:tA}
 .endif
 .endfor
 .if !empty(ddep_list)
 ddeps != cat ${ddep_list:O:u} | ${META2DEPS_FILTER} ${_skip_gendirdeps} \
 	sed ${GENDIRDEPS_SEDCMDS}
 
 .if ${DEBUG_GENDIRDEPS:Uno:@x@${RELDIR:M$x}@} != ""
 .info ${RELDIR}: raw_dir_list='${dir_list}'
 .info ${RELDIR}: ddeps='${ddeps}'
 .endif
 dir_list += ${ddeps}
 .endif
 .endif
 .endif
 
 # DIRDEPS represent things that had to have been built first
 # so they should all be undir OBJTOP.
 # Note that ${_OBJTOP}/bsd/include/machine will get reported
 # to us as $SRCTOP/bsd/sys/$MACHINE_ARCH/include meaning we
 # will want to visit bsd/include
 # so we add
 # ${"${dir_list:M*bsd/sys/${MACHINE_ARCH}/include}":?bsd/include:}
 # to GENDIRDEPS_DIR_LIST_XTRAS
 _objtops = ${OBJTOP} ${_OBJTOP} ${_objtop}
 _objtops := ${_objtops:O:u}
 dirdep_list = \
 	${_objtops:@o@${dir_list:M$o*/*:C,$o[^/]*/,,}@} \
 	${GENDIRDEPS_DIR_LIST_XTRAS}
 
 # sort longest first
 M2D_OBJROOTS := ${M2D_OBJROOTS:O:u:[-1..1]}
 
 # anything we use from an object dir other than ours
 # needs to be qualified with its .<machine> suffix
 # (we used the pseudo machine "host" for the HOST_TARGET).
 skip_ql= ${SRCTOP}* ${_objtops:@o@$o*@}
 .for o in ${M2D_OBJROOTS:${skip_ql:${M_ListToSkip}}}
 # we need := so only skip_ql to this point applies
 ql.$o := ${dir_list:${skip_ql:${M_ListToSkip}}:M$o*/*/*:C,$o([^/]+)/(.*),\2.\1,:S,.${HOST_TARGET},.host,}
 qualdir_list += ${ql.$o}
 .if ${DEBUG_GENDIRDEPS:Uno:@x@${RELDIR:M$x}@} != ""
 .info ${RELDIR}: o=$o ${ql.$o qualdir_list:L:@v@$v=${$v}@}
 .endif
 skip_ql+= $o*
 .endfor
 
 dirdep_list := ${dirdep_list:O:u}
 qualdir_list := ${qualdir_list:N*.${MACHINE}:O:u}
 
 DIRDEPS = \
 	${dirdep_list:N${RELDIR}:N${RELDIR}/*} \
 	${qualdir_list:N${RELDIR}.*:N${RELDIR}/*}
 
 # We only consider things below $RELDIR/ if they have a makefile.
 # This is the same test that _DIRDEP_USE applies.
 # We have do a double test with dirdep_list as it _may_ contain
 # qualified dirs - if we got anything from a stage dir.
 # qualdir_list we know are all qualified.
 # It would be nice do peform this check for all of DIRDEPS,
 # but we cannot assume that all of the tree is present,
 # in fact we can only assume that RELDIR is.
 DIRDEPS += \
 	${dirdep_list:M${RELDIR}/*:@d@${.MAKE.MAKEFILE_PREFERENCE:@m@${exists(${SRCTOP}/$d/$m):?$d:${exists(${SRCTOP}/${d:R}/$m):?$d:}}@}@} \
 	${qualdir_list:M${RELDIR}/*:@d@${.MAKE.MAKEFILE_PREFERENCE:@m@${exists(${SRCTOP}/${d:R}/$m):?$d:}@}@}
 
 # what modifiers do we allow in GENDIRDEPS_FILTER
 GENDIRDEPS_FILTER_MASK += @CMNS
 DIRDEPS := ${DIRDEPS:${GENDIRDEPS_FILTER:UNno:M[${GENDIRDEPS_FILTER_MASK:O:u:ts}]*:ts:}:C,//+,/,g:O:u}
 
 .if ${DEBUG_GENDIRDEPS:Uno:@x@${RELDIR:M$x}@} != ""
 .info ${RELDIR}: M2D_OBJROOTS=${M2D_OBJROOTS}
 .info ${RELDIR}: M2D_EXCLUDES=${M2D_EXCLUDES}
 .info ${RELDIR}: dir_list='${dir_list}'
 .info ${RELDIR}: dpadd_dir_list='${dpadd_dir_list}'
 .info ${RELDIR}: dirdep_list='${dirdep_list}'
 .info ${RELDIR}: qualdir_list='${qualdir_list}'
 .info ${RELDIR}: SKIP_GENDIRDEPS='${SKIP_GENDIRDEPS}'
 .info ${RELDIR}: GENDIRDEPS_FILTER='${GENDIRDEPS_FILTER}'
 .info ${RELDIR}: FORCE_DPADD='${DPADD}'
 .info ${RELDIR}: DIRDEPS='${DIRDEPS}'
 .endif
 
 # SRC_DIRDEPS is for checkout logic
 src_dirdep_list = \
 	${dir_list:M${SRCTOP}/*:S,${SRCTOP}/,,}
 
 SRC_DIRDEPS = \
 	${src_dirdep_list:N${RELDIR}:N${RELDIR}/*:C,(/h)/.*,,}
 
 SRC_DIRDEPS := ${SRC_DIRDEPS:${GENDIRDEPS_SRC_FILTER:UN/*:ts:}:C,//+,/,g:O:u}
 
 # if you want to capture SRC_DIRDEPS in .MAKE.DEPENDFILE put
 # SRC_DIRDEPS_FILE = ${_DEPENDFILE}
 # in local.gendirdeps.mk
 .if ${SRC_DIRDEPS_FILE:Uno:tl} != "no"
 ECHO_SRC_DIRDEPS = echo 'SRC_DIRDEPS = \'; echo '${SRC_DIRDEPS:@d@	$d \\${.newline}@}'; echo;
 
 .if ${SRC_DIRDEPS_FILE:T} == ${_DEPENDFILE:T}
 _include_src_dirdeps = ${ECHO_SRC_DIRDEPS}
 .else
 all: ${SRC_DIRDEPS_FILE}
 .if !target(${SRC_DIRDEPS_FILE})
 ${SRC_DIRDEPS_FILE}: ${META_FILES} ${_this} ${META2DEPS}
 	@(${ECHO_SRC_DIRDEPS}) > $@
 .endif
 .endif
 .endif
 _include_src_dirdeps ?=
 
 all:	${_DEPENDFILE}
 
 # if this is going to exist it would be there by now
 .if !exists(.depend)
 CAT_DEPEND = /dev/null
 .endif
 CAT_DEPEND ?= .depend
 
 .if !empty(_DIRDEPS) && ${DIRDEPS} != ${_DIRDEPS}
 # we may have changed a filter
 .PHONY: ${_DEPENDFILE}
 .endif
 
 # set this to 'no' and we will not capture any
 # local depends
 LOCAL_DEPENDS_GUARD ?= _{.MAKE.LEVEL} > 0
 
 # 'cat .depend' should suffice, but if we are mixing build modes
 # .depend may contain things we don't want.
 # The sed command at the end of the stream, allows for the filters
 # to output _{VAR} tokens which we will turn into proper ${VAR} references.
 ${_DEPENDFILE}: .NOMETA ${CAT_DEPEND:M.depend} ${META_FILES:O:u:@m@${exists($m):?$m:}@} ${_this} ${META2DEPS}
 	@(${GENDIRDEPS_HEADER} echo '# Autogenerated - do NOT edit!'; echo; \
 	echo 'DIRDEPS = \'; \
 	echo '${DIRDEPS:@d@	$d \\${.newline}@}'; echo; \
 	${_include_src_dirdeps} \
 	echo '.include <dirdeps.mk>'; \
 	[ "${LOCAL_DEPENDS_GUARD:[1]:tl}" != no ] || exit 0; \
 	echo; \
 	echo '.if ${LOCAL_DEPENDS_GUARD}'; \
 	echo '# local dependencies - needed for -jN in clean tree'; \
 	[ -s ${CAT_DEPEND} ] && { grep : ${CAT_DEPEND} | grep -v '[/\\]'; }; \
 	echo '.endif' ) | sed 's,_\([{(]\),$$\1,g' > $@.new${.MAKE.PID}
 	@${InstallNew}; InstallNew -s $@.new${.MAKE.PID}
 
 .endif				# meta2deps failed
 .elif !empty(SUBDIR)
 
 DIRDEPS := ${SUBDIR:S,^,${RELDIR}/,:O:u}
 
 all:	${_DEPENDFILE}
 
 ${_DEPENDFILE}: .NOMETA ${MAKEFILE} ${_this}
 	@(${GENDIRDEPS_HEADER} echo '# Autogenerated - do NOT edit!'; echo; \
 	echo 'DIRDEPS = \'; \
 	echo '${DIRDEPS:@d@	$d \\${.newline}@}'; echo; \
 	echo '.include <dirdeps.mk>'; \
 	echo ) | sed 's,_\([{(]\),$$\1,g' > $@.new
 	@${InstallNew}; InstallNew $@.new
 
 .else
 
 # nothing to do
 all ${_DEPENDFILE}:
 
 .endif
 ${_DEPENDFILE}: .PRECIOUS
 
 # don't waste time looking for ways to make .meta files
 .SUFFIXES:
diff --git a/share/mk/local.dirdeps.mk b/share/mk/local.dirdeps.mk
index d7e5396c81ed..246c9cdef114 100644
--- a/share/mk/local.dirdeps.mk
+++ b/share/mk/local.dirdeps.mk
@@ -1,221 +1,222 @@
 # $FreeBSD$
 .if !target(_DIRDEP_USE)
 # we are the 1st makefile
 
 .if !defined(MK_CLANG)
 .include "${SRCTOP}/share/mk/src.opts.mk"
 .endif
 
 # making universe is special
 .if defined(UNIVERSE_GUARD)
 # these should be done by now
 DIRDEPS_FILTER+= N*.host
 .endif
 
 # pseudo machines get no qualification
 .for m in host common
 M_dep_qual_fixes += C;($m),[^/.,]*$$;\1;
 .endfor
 #.info M_dep_qual_fixes=${M_dep_qual_fixes}
 
 # Cheat for including src.libnames.mk
 __<bsd.init.mk>__:
 # Pull in _INTERNALLIBS
 .include <src.libnames.mk>
 
 # Host libraries should mostly be excluded from the build so the
 # host version in /usr/lib is used.  Internal libraries need to be
 # allowed to be built though since they are never installed.
 _need_host_libs=
 .for lib in ${_INTERNALLIBS}
 _need_host_libs+= ${LIB${lib:tu}DIR:S,^${OBJTOP}/,,}
 .endfor
 
 N_host_libs:= ${cd ${SRCTOP} && echo lib/lib*:L:sh:${_need_host_libs:${M_ListToSkip}}:${M_ListToSkip}}
 DIRDEPS_FILTER.host = \
 	${N_host_libs} \
 	Ninclude* \
 	Nlib/csu* \
 	Nlib/libc \
 	Nlib/[mn]* \
 	Ngnu/lib/lib[a-r]* \
 	Nsecure/lib* \
 	Nusr.bin/xinstall* \
 
 
 DIRDEPS_FILTER+= \
 	Nbin/cat.host \
 	${DIRDEPS_FILTER.xtras:U}
 
 # Cleanup a buildworld's WORLDTMP so that any files generated from it
 # or using it will rebuild with the DIRDEPS SYSROOT.  Otherwise existing
 # object .meta files may still reference those directories and not be
 # rebuilt and lead to incorrect Makefile.depend files due to lack of
 # .dirdep files.
 .if !defined(NO_CLEANUP_WORLDTMP) && exists(${OBJTOP}/tmp/_worldtmp)
 cleanup_worldtmp: .PHONY .NOMETA
 	@echo "Cleaning leftover WORLDTMP from buildworld."
 	-rm -rf ${OBJTOP}/tmp/*
 	-chflags -R 0 ${OBJTOP}/tmp/*
 	rm -rf ${OBJTOP}/tmp
 beforedirdeps: cleanup_worldtmp
 .endif
 .endif
 
 # reset this each time
 DIRDEPS_FILTER.xtras=
 .if ${DEP_MACHINE:Npkgs*} != ""
 DIRDEPS_FILTER.xtras+= Nusr.bin/clang/clang.host
 .endif
 
 .if ${DEP_MACHINE} != "host"
 
 # this is how we can handle optional dependencies
 .if ${DEP_RELDIR} == "lib/libc"
 DIRDEPS += lib/libc_nonshared
 .if ${MK_SSP:Uno} != "no" 
 DIRDEPS += lib/libssp_nonshared
 .endif
 .else
 DIRDEPS_FILTER.xtras+= Nlib/libc_nonshared
 .endif
 
 # some optional things
 .if ${MK_CTF} == "yes" && ${DEP_RELDIR:Mcddl/usr.bin/ctf*} == ""
 DIRDEPS += \
 	cddl/usr.bin/ctfconvert.host \
 	cddl/usr.bin/ctfmerge.host
 .endif
 
 # Add in proper libgcc (gnu or LLVM) if not building libcc and libc is needed.
 # Add both gcc_s and gcc_eh as dependencies as the decision to build
 # -static or not is not known here.
 .if ${DEP_RELDIR:M*libgcc*} == "" && ${DIRDEPS:U:Mlib/libc} != ""
 DIRDEPS+= \
 	lib/libgcc_eh \
 	lib/libgcc_s
 .endif
 
 # Bootstrap support.  Give hints to DIRDEPS if there is no Makefile.depend*
 # generated yet.  This can be based on things such as SRC files and LIBADD.
 # These hints will not factor into the final Makefile.depend as only what is
 # used will be added in and handled via [local.]gendirdeps.mk.  This is not
 # done for MACHINE=host builds.
 # XXX: Include this in local.autodep.mk as well for gendirdeps without filemon.
 # Only do this for main build target
 .if ${RELDIR} == ${DEP_RELDIR} && !defined(_RECURSING_PROGS)
 .for _depfile in ${.MAKE.DEPENDFILE_PREFERENCE:T}
 .if !defined(_have_depfile) && exists(${.CURDIR}/${_depfile})
 _have_depfile=
 .endif
 .endfor
 .if !defined(_have_depfile)
 # KMOD does not use any stdlibs.
 .if !defined(KMOD)
 # Gather PROGS dependencies first
 .if !empty(PROGS)
 _PROGS_LIBADD=
 _PROGS_DPADD=
 _PROGS_SRCS=
 .for _prog in ${PROGS}
 .for s in . _
 .if !empty(LIBADD${s}${_prog})
 _PROGS_LIBADD+=	${LIBADD${s}${_prog}}
 .endif
 .if !empty(DPADD${s}${_prog})
 _PROGS_DPADD+=	${DPADD${s}${_prog}}
 .endif
 .if !empty(SRCS${s}${_prog})
 _PROGS_SRCS+=	${SRCS${s}${_prog}}
 .endif
 .endfor	# .for s in . _
 # Add in assumed source (bsd.prog.mk)
 .if !target(${_prog})
 .if defined(PROG_CXX)
 _PROGS_SRCS+=	${_prog}.cc
 .else
 _PROGS_SRCS+=	${_prog}.c
 .endif
 .endif	# !target(${_prog})
 .endfor	# .for _prog in ${PROGS}
 .endif	# !empty(PROGS)
 _SRCS= ${SRCS} ${_PROGS_SRCS}
 
 # Has C files. The C_DIRDEPS are shared with C++ files as well.
 C_DIRDEPS= \
 	include \
 	include/arpa \
 	include/protocols \
 	include/rpc  \
 	include/rpcsvc \
 	include/xlocale \
 	lib/${CSU_DIR} \
 	lib/libc \
 	lib/libcompiler_rt \
 
 # libgcc is needed as well but is added later.
 
 .if ${MK_GSSAPI} != "no"
 C_DIRDEPS+=  include/gssapi
 .endif
 
 .if !empty(_SRCS:M*.c)
 DIRDEPS+= ${C_DIRDEPS}
 .endif
 # Has C++ files
 .if !empty(_SRCS:M*.cc) || !empty(_SRCS:M*.C) || !empty(_SRCS:M*.cpp) || \
     !empty(_SRCS:M*.cxx)
 DIRDEPS+= ${C_DIRDEPS}
 .if ${MK_CLANG} == "yes"
 DIRDEPS+= lib/libc++ lib/libcxxrt
 .endif
 # XXX: Clang and GCC always adds -lm currently, even when not needed.
 DIRDEPS+= lib/msun
 .endif	# CXX
 .endif	# !defined(KMOD)
 # Has yacc files.
 .if !empty(_SRCS:M*.y)
 DIRDEPS+=	usr.bin/yacc.host
 .endif
 _DPADD= ${DPADD} ${_PROGS_DPADD}
 .if !empty(_DPADD)
 # This only works for DPADD with full OBJ/SRC paths, which is mostly just
 # _INTERNALLIBS.
 _DP_DIRDEPS= \
 	${_DPADD:O:u:M${OBJTOP}*:H:N.:tA:C,${OBJTOP}[^/]*/,,:N.:O:u} \
 	${_DPADD:O:u:M${OBJROOT}*:N${OBJTOP}*:N${STAGE_ROOT}/*:H:S,${OBJROOT},,:C,^([^/]+)/(.*),\2.\1,:S,${HOST_TARGET}$,host,:N.*:O:u}
 # Resolve the paths to RELDIRs
 .if !empty(_DP_DIRDEPS)
 DIRDEPS+= ${_DP_DIRDEPS:C,^,${SRCTOP}/,:tA:C,^${SRCTOP}/,,}
 .endif
 .endif	# !empty(DPADD)
 _ALL_LIBADD= ${LIBADD} ${_PROGS_LIBADD}
 .if !empty(_ALL_LIBADD)
 # Also handle LIBADD for non-internal libraries.
 .for _lib in ${_ALL_LIBADD:O:u}
 _lib${_lib}reldir= ${LIB${_lib:tu}DIR:C,${OBJTOP}/,,}
 .if defined(LIB${_lib:tu}DIR) && ${DIRDEPS:M${_lib${_lib}reldir}} == "" && \
     exists(${SRCTOP}/${_lib${_lib}reldir})
 DIRDEPS+= ${_lib${_lib}reldir}
 .endif
 .endfor
 .endif	# !empty(LIBADD)
 .endif	# no Makefile.depend*
 .endif	# ${RELDIR} == ${DEP_RELDIR}
 
 .endif	# ${DEP_MACHINE} != "host"
 
 .if ${MK_STAGING} == "yes"
 # we need targets/pseudo/stage to prep the stage tree
-.if ${DEP_RELDIR} != "targets/pseudo/stage"
+.if ${DEP_RELDIR:N.:N${SRCTOP}:N*pseudo/stage} != ""
 DIRDEPS += targets/pseudo/stage
 .endif
 .endif
 
 DEP_MACHINE_ARCH = ${MACHINE_ARCH.${DEP_MACHINE}}
+DEP_MACHINE_CPUARCH = ${DEP_MACHINE_ARCH:${__TO_CPUARCH}}
 CSU_DIR.${DEP_MACHINE_ARCH} ?= csu/${DEP_MACHINE_ARCH}
 CSU_DIR := ${CSU_DIR.${DEP_MACHINE_ARCH}}
 BOOT_MACHINE_DIR:= ${BOOT_MACHINE_DIR.${DEP_MACHINE}}
 KERNEL_NAME:= ${KERNEL_NAME.${DEP_MACHINE}}
 
 .-include <site.dirdeps.mk>
diff --git a/share/mk/local.gendirdeps.mk b/share/mk/local.gendirdeps.mk
index c8aa3ce05910..c224c7c64bd2 100644
--- a/share/mk/local.gendirdeps.mk
+++ b/share/mk/local.gendirdeps.mk
@@ -1,74 +1,62 @@
 # $FreeBSD$
 
 # we need a keyword, this noise is to prevent it being expanded
 GENDIRDEPS_HEADER= echo '\# ${FreeBSD:L:@v@$$$v$$ @:M*F*}';
 
 # suppress optional/auto dependencies
 # local.dirdeps.mk will put them in if necessary
 GENDIRDEPS_FILTER+= \
 	Nbin/cat.host \
 	Nlib/libssp_nonshared \
 	Ncddl/usr.bin/ctf* \
 	Nlib/libc_nonshared \
 	Nlib/libgcc_eh \
 	Nlib/libgcc_s \
 	Nstand/libsa/* \
 	Nstand/libsa32/* \
 	Ntargets/pseudo/stage* \
 	Ntools/*
 
 # Clang has nested directories in its OBJDIR.
 GENDIRDEPS_FILTER+= C,(lib/clang/lib[^/]*)/.*,\1,
 
 # Exclude toolchain which is handled special.
 .if ${RELDIR:Mtargets*} == ""
 .if ${RELDIR:Nusr.bin/clang/*:Ngnu/usr.bin/cc/*:Nlib/clang*} != ""
 GENDIRDEPS_FILTER.host+= \
 	Nusr.bin/clang/* \
 	Ngnu/usr.bin/cc/* \
 
 .endif
 GENDIRDEPS_FILTER_HOST_TOOLS+= \
 	Nlib/clang/headers \
 	Nusr.bin/addr2line \
 	Nusr.bin/ar \
 	Nusr.bin/clang/clang \
 	Nusr.bin/elfcopy \
 	Nusr.bin/elfdump \
 	Nusr.bin/nm \
 	Nusr.bin/readelf \
 	Nusr.bin/size \
 	Nusr.bin/strings \
 	Nusr.bin/strip \
 	Ngnu/usr.bin/cc* \
 	Ngnu/usr.bin/binutils* \
 
 .if ${MACHINE} != "host"
 GENDIRDEPS_FILTER+=	${GENDIRDEPS_FILTER_HOST_TOOLS:C,$,.host,}
 .else
 GENDIRDEPS_FILTER+=	${GENDIRDEPS_FILTER_HOST_TOOLS}
 .endif
 .endif
 
 GENDIRDEPS_FILTER+= ${GENDIRDEPS_FILTER.${MACHINE}:U}
 
 # gendirdeps.mk will turn _{VAR} into ${VAR} which keeps this simple
-# order of this list matters!
-GENDIRDEPS_FILTER_DIR_VARS+= \
-       CSU_DIR \
-       BOOT_MACHINE_DIR
-
-# order of this list matters!
-GENDIRDEPS_FILTER_VARS+= \
-       KERNEL_NAME \
-       MACHINE_CPUARCH \
-       MACHINE_ARCH \
-       MACHINE
-
-GENDIRDEPS_FILTER+= ${GENDIRDEPS_FILTER_DIR_VARS:@v@S,${$v},_{${v}},@}
-GENDIRDEPS_FILTER+= ${GENDIRDEPS_FILTER_VARS:@v@S,/${$v}/,/_{${v}}/,@:NS,//,*:u}
+# see local.meta.sys.mk for GENDIRDEPS_FILTER_DIR_VARS and
+# GENDIRDEPS_FILTER_VARS
 
 # avoid churn for now
 LOCAL_DEPENDS_GUARD= _{DEP_RELDIR} == _{_DEP_RELDIR}
 
 .-include <site.gendirdeps.mk>
diff --git a/share/mk/local.meta.sys.mk b/share/mk/local.meta.sys.mk
index 6d54d9c5881c..6e03a99d7dfe 100644
--- a/share/mk/local.meta.sys.mk
+++ b/share/mk/local.meta.sys.mk
@@ -1,269 +1,265 @@
 # $FreeBSD$
 
 # local configuration specific to meta mode
-# XXX some of this should be in meta.sys.mk
 # we assume that MK_DIRDEPS_BUILD=yes
 
 # we need this until there is an alternative
 MK_INSTALL_AS_USER= yes
 
 .if !defined(HOST_TARGET) || !defined(HOST_MACHINE)
 # we need HOST_TARGET etc below.
 .include <host-target.mk>
 .export HOST_TARGET
 .endif
 
 # from src/Makefile (for universe)
 TARGET_ARCHES_arm?=     arm armv6 armv7
 TARGET_ARCHES_arm64?=   aarch64
 TARGET_ARCHES_powerpc?= powerpc powerpc64 powerpc64le powerpcspe
 TARGET_ARCHES_riscv?=   riscv64
 
 # some corner cases
 BOOT_MACHINE_DIR.amd64 = boot/i386
 MACHINE_ARCH.host = ${_HOST_ARCH}
 
 # the list of machines we support
 ALL_MACHINE_LIST?= amd64 arm arm64 i386 powerpc riscv
 
 .-include <site.meta.sys.mk>
 
 .for m in ${ALL_MACHINE_LIST:O:u}
 MACHINE_ARCH_LIST.$m?= ${TARGET_ARCHES_${m}:U$m}
 MACHINE_ARCH.$m?= ${MACHINE_ARCH_LIST.$m:[1]}
 BOOT_MACHINE_DIR.$m ?= boot/$m
 .endfor
 
-.ifndef _TARGET_SPEC
 .if empty(MACHINE_ARCH)
 .if !empty(TARGET_ARCH)
 MACHINE_ARCH= ${TARGET_ARCH}
 .else
 MACHINE_ARCH= ${MACHINE_ARCH.${MACHINE}}
 .endif
 .endif
 MACHINE_ARCH?= ${MACHINE_ARCH.${MACHINE}}
 MACHINE_ARCH:= ${MACHINE_ARCH}
-.else
-# we got here via dirdeps
-MACHINE_ARCH:= ${MACHINE_ARCH.${MACHINE}}
-.endif
-
-# now because for universe we want to potentially
-# build for multiple MACHINE_ARCH per MACHINE
-# we need more than MACHINE in TARGET_SPEC
-TARGET_SPEC_VARS?= MACHINE MACHINE_ARCH
-# see dirdeps.mk
-.if ${TARGET_SPEC:Uno:M*,*} != ""
-_tspec := ${TARGET_SPEC:S/,/ /g}
-MACHINE := ${_tspec:[1]}
-MACHINE_ARCH := ${_tspec:[2]}
-# etc.
-# We need to stop that TARGET_SPEC affecting any submakes
-# and deal with MACHINE=${TARGET_SPEC} in the environment.
-TARGET_SPEC=
-# export but do not track
-.export-env TARGET_SPEC 
-.export ${TARGET_SPEC_VARS}
-.for v in ${TARGET_SPEC_VARS:O:u}
-.if empty($v)
-.undef $v
-.endif
-.endfor
-.endif
-# make sure we know what TARGET_SPEC is
-# as we may need it to find Makefile.depend*
-TARGET_SPEC = ${TARGET_SPEC_VARS:@v@${$v:U}@:ts,}
 
 # to be consistent with src/Makefile just concatenate with '.'s
 TARGET_OBJ_SPEC:= ${TARGET_SPEC:S;,;.;g}
 OBJTOP:= ${OBJROOT}${TARGET_OBJ_SPEC}
 
 .if defined(MAKEOBJDIR)
 .if ${MAKEOBJDIR:M/*} == ""
 .error Cannot use MAKEOBJDIR=${MAKEOBJDIR}${.newline}Unset MAKEOBJDIR to get default:  MAKEOBJDIR='${_default_makeobjdir}'
 .endif
 .endif
 
 HOST_OBJTOP ?= ${OBJROOT}${HOST_TARGET}
 
 .if ${OBJTOP} == ${HOST_OBJTOP} || ${REQUESTED_MACHINE:U${MACHINE}} == "host"
 MACHINE= host
 .if ${TARGET_MACHINE:Uno} == ${HOST_TARGET}
 # not what we want
 TARGET_MACHINE= host
 .endif
 .endif
 .if ${MACHINE} == "host"
 OBJTOP := ${HOST_OBJTOP}
+MACHINE_ARCH= ${MACHINE_ARCH.${MACHINE}}
 .endif
 
 .if ${.MAKE.LEVEL} == 0 || empty(PYTHON)
 PYTHON ?= /usr/local/bin/python
 .export PYTHON
 # _SKIP_BUILD is not 100% as it requires wrapping all 'all:' targets to avoid
 # building in MAKELEVEL0.  Just prohibit 'all' entirely in this case to avoid
 # problems.
 .if ${MK_DIRDEPS_BUILD} == "yes" && ${.MAKE.LEVEL} == 0
 .MAIN: dirdeps
 .if make(all)
 .error DIRDEPS_BUILD: Please run '${MAKE}' instead of '${MAKE} all'.
 .endif
 .endif
 .endif
 
 # we want to end up with a singe stage tree for all machines
 .if ${MK_STAGING} == "yes"
 .if empty(STAGE_ROOT)
 STAGE_ROOT?= ${OBJROOT}stage
 .export STAGE_ROOT
 .endif
 .endif
 
 .if ${MK_STAGING} == "yes"
 .if ${MACHINE} == "host"
 STAGE_MACHINE= ${HOST_TARGET}
 .else
 STAGE_MACHINE:= ${TARGET_OBJ_SPEC}
 .endif
 STAGE_OBJTOP:= ${STAGE_ROOT}/${STAGE_MACHINE}
 STAGE_COMMON_OBJTOP:= ${STAGE_ROOT}/common
 STAGE_TARGET_OBJTOP:= ${STAGE_ROOT}/${TARGET_OBJ_SPEC}
 STAGE_HOST_OBJTOP:= ${STAGE_ROOT}/${HOST_TARGET}
 # These are exported for hooking in out-of-tree builds.  They will always
 # be overridden in sub-makes above when building in-tree.
 .if ${.MAKE.LEVEL} > 0
 .export STAGE_OBJTOP STAGE_TARGET_OBJTOP STAGE_HOST_OBJTOP
 .endif
 
 # Use tools/install.sh which can avoid the need for xinstall for simple cases.
 INSTALL?=	sh ${SRCTOP}/tools/install.sh
 # This is for stage-install to pickup from the environment.
 REAL_INSTALL:=	${INSTALL}
 .export REAL_INSTALL
 STAGE_INSTALL=	sh ${.PARSEDIR:tA}/stage-install.sh OBJDIR=${.OBJDIR:tA}
 
 STAGE_LIBDIR= ${STAGE_OBJTOP}${_LIBDIR:U${LIBDIR:U/lib}}
 STAGE_INCLUDEDIR= ${STAGE_OBJTOP}${INCLUDEDIR:U/usr/include}
 # this is not the same as INCLUDEDIR
 STAGE_INCSDIR= ${STAGE_OBJTOP}${INCSDIR:U/include}
 # the target is usually an absolute path
 STAGE_SYMLINKS_DIR= ${STAGE_OBJTOP}
 
 #LDFLAGS_LAST+= -Wl,-rpath-link,${STAGE_LIBDIR}
 .if ${MK_SYSROOT} == "yes"
 SYSROOT?= ${STAGE_OBJTOP}
 .else
 LDFLAGS_LAST+= -L${STAGE_LIBDIR}
 .endif
 
 .endif				# MK_STAGING
 
 .-include "local.toolchain.mk"
 
 # this is sufficient for most of the tree.
 .MAKE.DEPENDFILE_DEFAULT = ${.MAKE.DEPENDFILE_PREFIX}
 
 # but if we have a machine qualified file it should be used in preference
 .MAKE.DEPENDFILE_PREFERENCE = \
 	${.MAKE.DEPENDFILE_PREFIX}.${MACHINE} \
 	${.MAKE.DEPENDFILE_PREFIX}
 
 .undef .MAKE.DEPENDFILE
 
 .include "sys.dependfile.mk"
 
 .if ${.MAKE.LEVEL} > 0 && ${MACHINE} == "host" && ${.MAKE.DEPENDFILE:E} != "host"
 # we can use this but should not update it.
 UPDATE_DEPENDFILE= NO
 .endif
 # Don't require filemon for makeman.
 .if make(showconfig)
 UPDATE_DEPENDFILE= NO
 .endif
 
 # define the list of places that contain files we are responsible for
 .MAKE.META.BAILIWICK = ${SB} ${OBJROOT} ${STAGE_ROOT}
 
 CSU_DIR.${MACHINE_ARCH} ?= csu/${MACHINE_ARCH}
 CSU_DIR := ${CSU_DIR.${MACHINE_ARCH}}
 
 .if !empty(TIME_STAMP)
 TRACER= ${TIME_STAMP} ${:U}
 .endif
 .if !defined(_RECURSING_PROGS) && !defined(_RECURSING_CRUNCH) && \
     !make(print-dir)
 WITH_META_STATS= t
 .endif
 
 # toolchains can be a pain - especially bootstrappping them
 .if ${MACHINE} == "host"
 MK_SHARED_TOOLCHAIN= no
 .endif
 TOOLCHAIN_VARS=	AS AR CC CLANG_TBLGEN CXX CPP LD NM OBJCOPY RANLIB \
 		STRINGS SIZE LLVM_TBLGEN
 _toolchain_bin_CLANG_TBLGEN=	/usr/bin/clang-tblgen
 _toolchain_bin_LLVM_TBLGEN=	/usr/bin/llvm-tblgen
 _toolchain_bin_CXX=		/usr/bin/c++
 .ifdef WITH_TOOLSDIR
 TOOLSDIR?= ${HOST_OBJTOP}/tools
 .elif defined(STAGE_HOST_OBJTOP)
 TOOLSDIR?= ${STAGE_HOST_OBJTOP}
 .endif
 .if ${MK_DIRDEPS_BUILD} == "yes" && ${MACHINE} != "host"
 # ideally tools needed by makefiles like sh,csh,tinfo
 # would be built in their own directories but for now
 # this works well enough.
 BTOOLSPATH= ${HOST_OBJTOP}/${RELDIR}
 .else
 # Only define if it exists in case user didn't run bootstrap-tools.  Otherwise
 # the tool will be built during the build.  Building it assumes it is
 # TARGET==MACHINE.
 .if exists(${HOST_OBJTOP}/tools${.CURDIR})
 BTOOLSPATH= ${HOST_OBJTOP}/tools${.CURDIR}
 .endif
 .endif
 
 # Don't use the bootstrap tools logic on itself.
 .if ${.TARGETS:Mbootstrap-tools} == "" && \
     !make(test-system-*) && !make(showconfig) && !make(print-dir) && \
     !defined(BOOTSTRAPPING_TOOLS) && !empty(TOOLSDIR) && ${.MAKE.LEVEL} == 0
 .for dir in /sbin /bin /usr/sbin /usr/bin
 PATH:= ${TOOLSDIR}${dir}:${PATH}
 .endfor
 .export PATH
 # Prefer the TOOLSDIR version of the toolchain if present vs the host version.
 .for var in ${TOOLCHAIN_VARS}
 _toolchain_bin.${var}=	${TOOLSDIR}${_toolchain_bin_${var}:U/usr/bin/${var:tl}}
 .if exists(${_toolchain_bin.${var}})
 HOST_${var}?=	${_toolchain_bin.${var}}
 .export		HOST_${var}
 .endif
 .endfor
 .endif
 
 .for var in ${TOOLCHAIN_VARS}
 HOST_${var}?=	${_toolchain_bin_${var}:U/usr/bin/${var:tl}}
 .endfor
 
 .if ${MACHINE} == "host"
 .for var in ${TOOLCHAIN_VARS}
 ${var}=		${HOST_${var}}
 .endfor
 .endif
 
 .if ${MACHINE:Nhost:Ncommon} != "" && ${MACHINE} != ${HOST_MACHINE}
 # cross-building
 .if !defined(FREEBSD_REVISION)
 FREEBSD_REVISION!= sed -n '/^REVISION=/{s,.*=,,;s,",,g;p; }' ${SRCTOP}/sys/conf/newvers.sh
 .export FREEBSD_REVISION
 .endif
 CROSS_TARGET_FLAGS= -target ${MACHINE_ARCH}-unknown-freebsd${FREEBSD_REVISION}
 CFLAGS+= ${CROSS_TARGET_FLAGS}
 ACFLAGS+= ${CROSS_TARGET_FLAGS}
 .endif
 
 META_MODE+=	missing-meta=yes
 .if empty(META_MODE:Mnofilemon)
 META_MODE+=	missing-filemon=yes
 .endif
+
+.if ${MK_DIRDEPS_BUILD} == "yes"
+# we set these here, rather than local.gendirdeps.mk
+# so we can ensure any DEP_* values that might be used in
+# conditionals do not cause syntax errors when Makefile.depend
+# is included at level 1+
+
+# order of this list matters!
+GENDIRDEPS_FILTER_DIR_VARS+= \
+       CSU_DIR \
+       BOOT_MACHINE_DIR
+
+# order of this list matters!
+GENDIRDEPS_FILTER_VARS+= \
+       KERNEL_NAME \
+       DEP_MACHINE_CPUARCH \
+       DEP_MACHINE_ARCH \
+       DEP_MACHINE
+
+.if ${.MAKE.LEVEL} > 0
+.for V in ${GENDIRDEPS_FILTER_DIR_VARS:MDEP_*:O:u} \
+	${GENDIRDEPS_FILTER_VARS:MDEP_*:O:u}
+$V?= ${${V:S,DEP_,,}}
+.endfor
+.endif
+
+.endif
diff --git a/share/mk/local.sys.env.mk b/share/mk/local.sys.env.mk
index e3348537db41..626aafe61270 100644
--- a/share/mk/local.sys.env.mk
+++ b/share/mk/local.sys.env.mk
@@ -1,52 +1,57 @@
 # $FreeBSD$
 
 # This makefile is for customizations that should be done early
 
 .if !defined(_TARGETS)
 # some things we do only once
 _TARGETS:= ${.TARGETS}
 .export _TARGETS
 .endif
 
 # some handy macros
 _this = ${.PARSEDIR:tA}/${.PARSEFILE}
 # some useful modifiers
 
 # A useful trick for testing multiple :M's against something
 # :L says to use the variable's name as its value - ie. literal
 # got = ${clean* destroy:${M_ListToMatch:S,V,.TARGETS,}}
 M_ListToMatch = L:@m@$${V:M$$m}@
 # match against our initial targets (see above)
 M_L_TARGETS = ${M_ListToMatch:S,V,_TARGETS,}
 
 # turn a list into a set of :N modifiers
 # NskipFoo = ${Foo:${M_ListToSkip}}
 M_ListToSkip= O:u:ts::S,:,:N,g:S,^,N,
 
 # type should be a builtin in any sh since about 1980,
 # AUTOCONF := ${autoconf:L:${M_whence}}
 M_type = @x@(type $$x 2> /dev/null); echo;@:sh:[0]:N* found*:[@]:C,[()],,g
 M_whence = ${M_type}:M/*:[1]
 
 # convert a path to a valid shell variable
 M_P2V = tu:C,[./-],_,g
 
 # these are handy
 # we can use this for a cheap timestamp at the start of a target's script,
 # but not at the end - since make will expand both at the same time.
 TIME_STAMP_FMT = @ %s [%Y-%m-%d %T]
 TIME_STAMP = ${TIME_STAMP_FMT:localtime}
 # this will produce the same output but as of when date(1) is run.
 TIME_STAMP_DATE = `date '+${TIME_STAMP_FMT}'`
 TIME_STAMP_END?= ${TIME_STAMP_DATE}
 
 # Simplify auto.obj.mk mkdir -p handling and avoid unneeded/redundant
 # error spam and show a proper error.
 Mkdirs= Mkdirs() { mkdir -p $$* || :; }
 
 .if !empty(.MAKEFLAGS:M-s)
 ECHO_TRACE?=	true
 .endif
 
 .include "src.sys.env.mk"
 .-include <site.sys.env.mk>
+
+# For universe we want to potentially
+# build for multiple MACHINE_ARCH per MACHINE
+# so we need more than MACHINE in TARGET_SPEC
+TARGET_SPEC_VARS?= MACHINE MACHINE_ARCH
diff --git a/share/mk/meta.sys.mk b/share/mk/meta.sys.mk
index cccab7ca952d..1fc58a226cb1 100644
--- a/share/mk/meta.sys.mk
+++ b/share/mk/meta.sys.mk
@@ -1,180 +1,218 @@
-# $FreeBSD$
-# $Id: meta.sys.mk,v 1.42 2021/12/13 05:50:55 sjg Exp $
+# $Id: meta.sys.mk,v 1.46 2023/04/18 18:43:00 sjg Exp $
 
 #
 #	@(#) Copyright (c) 2010-2021, Simon J. Gerraty
 #
 #	This file is provided in the hope that it will
 #	be of use.  There is absolutely NO WARRANTY.
 #	Permission to copy, redistribute or otherwise
 #	use this file is hereby granted provided that
 #	the above copyright notice and this notice are
 #	left intact.
 #
 #	Please send copies of changes and bug-fixes to:
 #	sjg@crufty.net
 #
 
 # include this if you want to enable meta mode
 # for maximum benefit, requires filemon(4) driver.
 
 .if ${MAKE_VERSION:U0} > 20100901
 .if !target(.ERROR)
 
-.-include <local.meta.sys.mk>
+.-include <local.meta.sys.env.mk>
+
+# If TARGET_SPEC_VARS is other than just MACHINE
+# it should be set by now.
+# TARGET_SPEC must not contain any '.'s.
+TARGET_SPEC_VARS ?= MACHINE
+
+.if !target(_meta_tspec_env_done_)
+_meta_tspec_env_done_: .NOTMAIN
+# Allow for local.meta.sys.env.mk to have done this
+
+.if ${TARGET_SPEC:Uno:M*,*} != ""
+# deal with TARGET_SPEC from env
+_tspec := ${TARGET_SPEC:S/,/ /g}
+.for i in ${TARGET_SPEC_VARS:${M_RANGE:Urange}}
+${TARGET_SPEC_VARS:[$i]} := ${_tspec:[$i]}
+.endfor
+# We need to stop that TARGET_SPEC affecting any submakes
+TARGET_SPEC=
+# so export but do not track
+.export-env TARGET_SPEC
+.export ${TARGET_SPEC_VARS}
+.for v in ${TARGET_SPEC_VARS:O:u}
+.if empty($v)
+.undef $v
+.endif
+.endfor
+.endif
+.endif
+
+# Now make sure we know what TARGET_SPEC is
+# as we may need it to find Makefile.depend*
+.if ${MACHINE:Mhost*} != ""
+# host is special
+TARGET_SPEC = ${MACHINE}
+.else
+TARGET_SPEC = ${TARGET_SPEC_VARS:@v@${$v:U}@:ts,}
+.endif
 
 # absolute path to what we are reading.
 _PARSEDIR = ${.PARSEDIR:tA}
 
 .if !defined(SYS_MK_DIR)
 SYS_MK_DIR := ${_PARSEDIR}
 .endif
 
 META_MODE += meta verbose
 .if ${MAKE_VERSION:U0} > 20130323 && empty(.MAKE.PATH_FILEMON)
 # we do not support filemon
 META_MODE += nofilemon
 MKDEP_MK ?= auto.dep.mk
 .endif
 
 .MAKE.MODE ?= ${META_MODE}
 
 _filemon := ${.MAKE.PATH_FILEMON:U/dev/filemon}
 
 .if empty(UPDATE_DEPENDFILE)
 _make_mode := ${.MAKE.MODE} ${META_MODE}
 .if ${_make_mode:M*read*} != "" || ${_make_mode:M*nofilemon*} != ""
 # tell everyone we are not updating Makefile.depend*
 UPDATE_DEPENDFILE = NO
 .export UPDATE_DEPENDFILE
 .endif
 .if ${_filemon:T:Mfilemon} == "filemon"
 .if ${UPDATE_DEPENDFILE:Uyes:tl} == "no" && !exists(${_filemon})
 # we should not get upset
 META_MODE += nofilemon
 .export META_MODE
 .endif
 .endif
 .endif
 
 .if !defined(NO_SILENT)
 .if ${MAKE_VERSION} > 20110818
 # only be silent when we have a .meta file
 META_MODE += silent=yes
 .else
 .SILENT:
 .endif
 .endif
 
 # we use the pseudo machine "host" for the build host.
 # this should be taken care of before we get here
 .if ${OBJTOP:Ua} == ${HOST_OBJTOP:Ub}
 MACHINE = host
 .endif
 
 .if !defined(MACHINE0)
 # it can be handy to know which MACHINE kicked off the build
 # for example, if using Makefild.depend for multiple machines,
 # allowing only MACHINE0 to update can keep things simple.
 MACHINE0 := ${MACHINE}
 .export MACHINE0
 .endif
 
 .if !defined(META2DEPS)
 .if defined(PYTHON) && exists(${PYTHON})
 # we prefer the python version of this - it is much faster
 META2DEPS ?= ${.PARSEDIR}/meta2deps.py
 .else
 META2DEPS ?= ${.PARSEDIR}/meta2deps.sh
 .endif
 META2DEPS := ${META2DEPS}
 .export META2DEPS
 .endif
 
 MAKE_PRINT_VAR_ON_ERROR += \
 	.ERROR_TARGET \
 	.ERROR_META_FILE \
 	.MAKE.LEVEL \
 	MAKEFILE \
 	.MAKE.MODE
 
 .if !defined(SB) && defined(SRCTOP)
 SB = ${SRCTOP:H}
 .endif
 ERROR_LOGDIR ?= ${SB}/error
 meta_error_log = ${ERROR_LOGDIR}/meta-${.MAKE.PID}.log
 
 # we are not interested in make telling us a failure happened elsewhere
 .ERROR: _metaError
 _metaError: .NOMETA .NOTMAIN
 	-@[ "${.ERROR_META_FILE}" ] && { \
 	grep -q 'failure has been detected in another branch' ${.ERROR_META_FILE} && exit 0; \
 	mkdir -p ${meta_error_log:H}; \
 	cp ${.ERROR_META_FILE} ${meta_error_log}; \
 	echo "ERROR: log ${meta_error_log}" >&2; }; :
 
 .endif
 
 # Are we, after all, in meta mode?
 .if ${.MAKE.MODE:Uno:Mmeta*} != ""
 MKDEP_MK ?= meta.autodep.mk
 
 .if ${.MAKE.MAKEFILES:M*sys.dependfile.mk} == ""
 # this does all the smarts of setting .MAKE.DEPENDFILE
 .-include <sys.dependfile.mk>
 # check if we got anything sane
 .if ${.MAKE.DEPENDFILE} == ".depend"
 .undef .MAKE.DEPENDFILE
 .endif
 .MAKE.DEPENDFILE ?= Makefile.depend
 .endif
 
 # we can afford to use cookies to prevent some targets
 # re-running needlessly
 META_COOKIE_TOUCH?= touch ${COOKIE.${.TARGET}:U${.OBJDIR}/${.TARGET:T}}
 META_NOPHONY=
 META_NOECHO= :
 
 # some targets involve old pre-built targets
 # ignore mtime of shell
 # and mtime of makefiles does not matter in meta mode
 .MAKE.META.IGNORE_PATHS += \
 	${MAKEFILE} \
 	${MAKE_SHELL} \
 	${SHELL} \
 	${SYS_MK_DIR} \
 
 
 .if ${UPDATE_DEPENDFILE:Uyes:tl} != "no"
 .if ${.MAKEFLAGS:Uno:M-k} != ""
 # make this more obvious
 .warning Setting UPDATE_DEPENDFILE=NO due to -k
 UPDATE_DEPENDFILE= NO
 .export UPDATE_DEPENDFILE
 .elif ${_filemon:T} == "filemon" && !exists(${_filemon})
 .error ${.newline}ERROR: The filemon module (${_filemon}) is not loaded.
 .endif
 .endif
 
 .if ${.MAKE.LEVEL} == 0
 .if ${MK_DIRDEPS_BUILD:Uyes} == "yes"
 # make sure dirdeps target exists and do it first
 all: dirdeps .WAIT
 dirdeps:
 .NOPATH: dirdeps
 
 .if defined(ALL_MACHINES)
 # the first .MAIN: is what counts
 # by default dirdeps is all we want at level0
 .MAIN: dirdeps
 .endif
 .endif
 
 .endif
 .else
 META_COOKIE_TOUCH=
 # some targets need to be .PHONY in non-meta mode
 META_NOPHONY= .PHONY
 META_NOECHO= echo
 .endif
 .endif
+
+.-include <local.meta.sys.mk>