Index: head/share/mk/bsd.dep.mk
===================================================================
--- head/share/mk/bsd.dep.mk	(revision 308599)
+++ head/share/mk/bsd.dep.mk	(revision 308600)
@@ -1,321 +1,322 @@
 # $FreeBSD$
 #
 # The include file <bsd.dep.mk> handles Makefile dependencies.
 #
 #
 # +++ variables +++
 #
 # CLEANDEPENDDIRS	Additional directories to remove for the cleandepend
 # 			target.
 #
 # CLEANDEPENDFILES	Additional files to remove for the cleandepend target.
 #
 # CTAGS		A tags file generation program [gtags]
 #
 # CTAGSFLAGS	Options for ctags(1) [not set]
 #
 # DEPENDFILE	dependencies file [.depend]
 #
 # GTAGSFLAGS	Options for gtags(1) [-o]
 #
 # HTAGSFLAGS	Options for htags(1) [not set]
 #
 # SRCS          List of source files (c, c++, assembler)
 #
 # DPSRCS	List of source files which are needed for generating
 #		dependencies, ${SRCS} are always part of it.
 #
 # +++ targets +++
 #
 #	cleandepend:
 #		remove ${CLEANDEPENDFILES}; remove ${CLEANDEPENDDIRS} and all
 #		contents.
 #
 #	depend:
 #		Make the dependencies for the source files, and store
 #		them in the file ${DEPENDFILE}.
 #
 #	tags:
 #		In "ctags" mode, create a tags file for the source files.
 #		In "gtags" mode, create a (GLOBAL) gtags file for the
 #		source files.  If HTML is defined, htags(1) is also run
 #		after gtags(1).
 
 .if !target(__<bsd.init.mk>__)
 .error bsd.dep.mk cannot be included directly.
 .endif
 
 CTAGS?=		gtags
 CTAGSFLAGS?=
 GTAGSFLAGS?=	-o
 HTAGSFLAGS?=
 
 .if ${MK_DIRDEPS_BUILD} == "no"
 .MAKE.DEPENDFILE= ${DEPENDFILE}
 .endif
 CLEANDEPENDFILES+=	${DEPENDFILE} ${DEPENDFILE}.*
 .if ${MK_META_MODE} == "yes"
 CLEANDEPENDFILES+=	*.meta
 .endif
 
 # Keep `tags' here, before SRCS are mangled below for `depend'.
 .if !target(tags) && defined(SRCS) && !defined(NO_TAGS)
 tags: ${SRCS}
 .if ${CTAGS:T} == "gtags"
 	@cd ${.CURDIR} && ${CTAGS} ${GTAGSFLAGS} ${.OBJDIR}
 .if defined(HTML)
 	@cd ${.CURDIR} && htags ${HTAGSFLAGS} -d ${.OBJDIR} ${.OBJDIR}
 .endif
 .else
 	@${CTAGS} ${CTAGSFLAGS} -f /dev/stdout \
 	    ${.ALLSRC:N*.h} | sed "s;${.CURDIR}/;;" > ${.TARGET}
 .endif
 .endif
 
 .if !empty(.MAKE.MODE:Mmeta) && empty(.MAKE.MODE:Mnofilemon)
 _meta_filemon=	1
 .endif
 
 # Skip reading .depend when not needed to speed up tree-walks and simple
 # lookups.  See _SKIP_BUILD logic in bsd.init.mk for more details.
 # Also skip generating or including .depend.* files if in meta+filemon mode
 # since it will track dependencies itself.  OBJS_DEPEND_GUESS is still used.
 .if defined(_SKIP_BUILD) || defined(_meta_filemon)
 _SKIP_READ_DEPEND=	1
-.if ${MK_DIRDEPS_BUILD} == "no" || make(analyze) || make(print-dir)
+.if ${MK_DIRDEPS_BUILD} == "no" || make(analyze) || make(print-dir) || \
+    make(obj) || make(clean*) || make(destroy*)
 .MAKE.DEPENDFILE=	/dev/null
 .endif
 .endif
 
 .if defined(SRCS)
 CLEANFILES?=
 
 .for _S in ${SRCS:N*.[dhly]}
 OBJS_DEPEND_GUESS.${_S:R}.o+=	${_S}
 .endfor
 
 # Lexical analyzers
 .for _LSRC in ${SRCS:M*.l:N*/*}
 .for _LC in ${_LSRC:R}.c
 ${_LC}: ${_LSRC}
 	${LEX} ${LFLAGS} -o${.TARGET} ${.ALLSRC}
 OBJS_DEPEND_GUESS.${_LC:R}.o+=	${_LC}
 SRCS:=	${SRCS:S/${_LSRC}/${_LC}/}
 CLEANFILES+= ${_LC}
 .endfor
 .endfor
 
 # Yacc grammars
 .for _YSRC in ${SRCS:M*.y:N*/*}
 .for _YC in ${_YSRC:R}.c
 SRCS:=	${SRCS:S/${_YSRC}/${_YC}/}
 CLEANFILES+= ${_YC}
 .if !empty(YFLAGS:M-d) && !empty(SRCS:My.tab.h)
 .ORDER: ${_YC} y.tab.h
 y.tab.h: .NOMETA
 ${_YC} y.tab.h: ${_YSRC}
 	${YACC} ${YFLAGS} ${.ALLSRC}
 	cp y.tab.c ${_YC}
 CLEANFILES+= y.tab.c y.tab.h
 .elif !empty(YFLAGS:M-d)
 .for _YH in ${_YC:R}.h
 .ORDER: ${_YC} ${_YH}
 ${_YH}: .NOMETA
 ${_YC} ${_YH}: ${_YSRC}
 	${YACC} ${YFLAGS} -o ${_YC} ${.ALLSRC}
 SRCS+=	${_YH}
 CLEANFILES+= ${_YH}
 .endfor
 .else
 ${_YC}: ${_YSRC}
 	${YACC} ${YFLAGS} -o ${_YC} ${.ALLSRC}
 .endif
 OBJS_DEPEND_GUESS.${_YC:R}.o+=	${_YC}
 .endfor
 .endfor
 
 # DTrace probe definitions
 .if ${SRCS:M*.d}
 CFLAGS+=	-I${.OBJDIR}
 .endif
 .for _DSRC in ${SRCS:M*.d:N*/*}
 .for _D in ${_DSRC:R}
 SRCS+=	${_D}.h
 ${_D}.h: ${_DSRC}
 	${DTRACE} ${DTRACEFLAGS} -h -s ${.ALLSRC}
 SRCS:=	${SRCS:S/^${_DSRC}$//}
 OBJS+=	${_D}.o
 CLEANFILES+= ${_D}.h ${_D}.o
 ${_D}.o: ${_DSRC} ${OBJS:S/^${_D}.o$//}
 	@rm -f ${.TARGET}
 	${DTRACE} ${DTRACEFLAGS} -G -o ${.TARGET} -s ${.ALLSRC:N*.h}
 .if defined(LIB)
 CLEANFILES+= ${_D}.pico ${_D}.po
 ${_D}.pico: ${_DSRC} ${SOBJS:S/^${_D}.pico$//}
 	@rm -f ${.TARGET}
 	${DTRACE} ${DTRACEFLAGS} -G -o ${.TARGET} -s ${.ALLSRC:N*.h}
 ${_D}.po: ${_DSRC} ${POBJS:S/^${_D}.po$//}
 	@rm -f ${.TARGET}
 	${DTRACE} ${DTRACEFLAGS} -G -o ${.TARGET} -s ${.ALLSRC:N*.h}
 .endif
 .endfor
 .endfor
 
 
 .if ${MAKE_VERSION} < 20160220
 DEPEND_MP?=	-MP
 .endif
 # Handle OBJS=../somefile.o hacks.  Just replace '/' rather than use :T to
 # avoid collisions.
 DEPEND_FILTER=	C,/,_,g
 DEPENDSRCS=	${SRCS:M*.[cSC]} ${SRCS:M*.cxx} ${SRCS:M*.cpp} ${SRCS:M*.cc}
 .if !empty(DEPENDSRCS)
 DEPENDOBJS+=	${DEPENDSRCS:R:S,$,.o,}
 .endif
 DEPENDFILES_OBJS=	${DEPENDOBJS:O:u:${DEPEND_FILTER}:C/^/${DEPENDFILE}./}
 DEPEND_CFLAGS+=	-MD ${DEPEND_MP} -MF${DEPENDFILE}.${.TARGET:${DEPEND_FILTER}}
 DEPEND_CFLAGS+=	-MT${.TARGET}
 .if !defined(_meta_filemon)
 .if defined(.PARSEDIR)
 # Only add in DEPEND_CFLAGS for CFLAGS on files we expect from DEPENDOBJS
 # as those are the only ones we will include.
 DEPEND_CFLAGS_CONDITION= "${DEPENDOBJS:${DEPEND_FILTER}:M${.TARGET:${DEPEND_FILTER}}}" != ""
 CFLAGS+=	${${DEPEND_CFLAGS_CONDITION}:?${DEPEND_CFLAGS}:}
 .else
 CFLAGS+=	${DEPEND_CFLAGS}
 .endif
 .if !defined(_SKIP_READ_DEPEND)
 .for __depend_obj in ${DEPENDFILES_OBJS}
 .if ${MAKE_VERSION} < 20160220
 .sinclude "${.OBJDIR}/${__depend_obj}"
 .else
 .dinclude "${.OBJDIR}/${__depend_obj}"
 .endif
 .endfor
 .endif	# !defined(_SKIP_READ_DEPEND)
 .endif	# !defined(_meta_filemon)
 .endif	# defined(SRCS)
 
-.if ${MK_DIRDEPS_BUILD} == "yes" && !make(analyze) && !make(print-dir)
+.if ${MK_DIRDEPS_BUILD} == "yes" && ${.MAKE.DEPENDFILE} != "/dev/null"
 # Prevent meta.autodep.mk from tracking "local dependencies".
 .depend:
 .include <meta.autodep.mk>
 # If using filemon then _EXTRADEPEND is skipped since it is not needed.
 .if defined(_meta_filemon)
 # this depend: bypasses that below
 # the dependency helps when bootstrapping
 depend: beforedepend ${DPSRCS} ${SRCS} afterdepend
 beforedepend:
 afterdepend: beforedepend
 .endif
 .endif
 
 # Guess some dependencies for when no ${DEPENDFILE}.OBJ is generated yet.
 # For meta+filemon the .meta file is checked for since it is the dependency
 # file used.
 .for __obj in ${DEPENDOBJS:O:u}
 # If the obj has any '/', then replace with '_'.  For meta files, this is
 # mimicing what bmake's meta_name() does and adding in the full path
 # as well to ensure that the expected meta file is read.
 .if ${__obj:M*/*}
 _meta_obj=	${.OBJDIR:C,/,_,g}_${__obj:C,/,_,g}.meta
 .else
 _meta_obj=	${__obj}.meta
 .endif
 _dep_obj=	${DEPENDFILE}.${__obj:${DEPEND_FILTER}}
 .if (defined(_meta_filemon) && !exists(${.OBJDIR}/${_meta_obj})) || \
     (!defined(_meta_filemon) && !exists(${.OBJDIR}/${_dep_obj}))
 ${__obj}: ${OBJS_DEPEND_GUESS}
 ${__obj}: ${OBJS_DEPEND_GUESS.${__obj}}
 .elif defined(_meta_filemon)
 # For meta mode we still need to know which file to depend on to avoid
 # ambiguous suffix transformation rules from .PATH.  Meta mode does not
 # use .depend files.  We really only need source files, not headers since
 # they are typically in SRCS/beforebuild already.  For target-specific
 # guesses do include headers though since they may not be in SRCS.
 ${__obj}: ${OBJS_DEPEND_GUESS:N*.h}
 ${__obj}: ${OBJS_DEPEND_GUESS.${__obj}}
 .endif
 .endfor
 
 # Always run 'make depend' to generate dependencies early and to avoid the
 # need for manually running it.  The dirdeps build should only do this in
 # sub-makes though since MAKELEVEL0 is for dirdeps calculations.
 .if ${MK_DIRDEPS_BUILD} == "no" || ${.MAKE.LEVEL} > 0
 beforebuild: depend
 .endif
 
 .if !target(depend)
 .if defined(SRCS)
 depend: beforedepend ${DEPENDFILE} afterdepend
 
 # Tell bmake not to look for generated files via .PATH
 .NOPATH: ${DEPENDFILE} ${DEPENDFILES_OBJS}
 
 DPSRCS+= ${SRCS}
 # A .depend file will only be generated if there are commands in
 # beforedepend/_EXTRADEPEND/afterdepend  The _EXTRADEPEND target is
 # ignored if using meta+filemon since it handles all dependencies.  The other
 # targets are kept as they be used for generating something.  The target is
 # kept to allow 'make depend' to generate files.
 ${DEPENDFILE}: ${DPSRCS}
 .if exists(${.OBJDIR}/${DEPENDFILE}) || \
     ((commands(beforedepend) || \
     (!defined(_meta_filemon) && commands(_EXTRADEPEND)) || \
     commands(afterdepend)) && !empty(.MAKE.MODE:Mmeta))
 	rm -f ${DEPENDFILE}
 .endif
 .if !defined(_meta_filemon) && target(_EXTRADEPEND)
 _EXTRADEPEND: .USE
 ${DEPENDFILE}: _EXTRADEPEND
 .endif
 
 .ORDER: ${DEPENDFILE} afterdepend
 .else
 depend: beforedepend afterdepend
 .endif
 .if !target(beforedepend)
 beforedepend:
 .else
 .ORDER: beforedepend ${DEPENDFILE}
 .ORDER: beforedepend afterdepend
 .endif
 .if !target(afterdepend)
 afterdepend:
 .endif
 .endif
 
 .if defined(SRCS)
 .if ${CTAGS:T} == "gtags"
 CLEANDEPENDFILES+=	GPATH GRTAGS GSYMS GTAGS
 .if defined(HTML)
 CLEANDEPENDDIRS+=	HTML
 .endif
 .else
 CLEANDEPENDFILES+=	tags
 .endif
 .endif
 .if !target(cleandepend)
 cleandepend:
 .if !empty(CLEANDEPENDFILES)
 	rm -f ${CLEANDEPENDFILES}
 .endif
 .if !empty(CLEANDEPENDDIRS)
 	rm -rf ${CLEANDEPENDDIRS}
 .endif
 .endif
 .ORDER: cleandepend all
 .ORDER: cleandepend depend
 
 .if !target(checkdpadd) && (defined(DPADD) || defined(LDADD))
 _LDADD_FROM_DPADD=	${DPADD:R:T:C;^lib(.*)$;-l\1;g}
 # Ignore -Wl,--start-group/-Wl,--end-group as it might be required in the
 # LDADD list due to unresolved symbols
 _LDADD_CANONICALIZED=	${LDADD:N:R:T:C;^lib(.*)$;-l\1;g:N-Wl,--[es]*-group}
 checkdpadd:
 .if ${_LDADD_FROM_DPADD} != ${_LDADD_CANONICALIZED}
 	@echo ${.CURDIR}
 	@echo "DPADD -> ${_LDADD_FROM_DPADD}"
 	@echo "LDADD -> ${_LDADD_CANONICALIZED}"
 .endif
 .endif
Index: head/share/mk/bsd.subdir.mk
===================================================================
--- head/share/mk/bsd.subdir.mk	(revision 308599)
+++ head/share/mk/bsd.subdir.mk	(revision 308600)
@@ -1,194 +1,197 @@
 #	from: @(#)bsd.subdir.mk	5.9 (Berkeley) 2/1/91
 # $FreeBSD$
 #
 # The include file <bsd.subdir.mk> contains the default targets
 # for building subdirectories.
 #
 # For all of the directories listed in the variable SUBDIRS, the
 # specified directory will be visited and the target made. There is
 # also a default target which allows the command "make subdir" where
 # subdir is any directory listed in the variable SUBDIRS.
 #
 #
 # +++ variables +++
 #
 # DISTRIBUTION	Name of distribution. [base]
 #
 # SUBDIR	A list of subdirectories that should be built as well.
 #		Each of the targets will execute the same target in the
 #		subdirectories. SUBDIR.yes is automatically appended
 #		to this list.
 #
 # +++ targets +++
 #
 #	distribute:
 # 		This is a variant of install, which will
 # 		put the stuff into the right "distribution".
 #
 # 	See SUBDIR_TARGETS for list of targets that will recurse.
 #
 # 	Targets defined in STANDALONE_SUBDIR_TARGETS will always be ran
 # 	with SUBDIR_PARALLEL and will not respect .WAIT or SUBDIR_DEPEND_
 # 	values.
 #
 # 	SUBDIR_TARGETS and STANDALONE_SUBDIR_TARGETS can be appended to
 # 	via make.conf or src.conf.
 #
 
 .if !target(__<bsd.subdir.mk>__)
 __<bsd.subdir.mk>__:
 
 SUBDIR_TARGETS+= \
 		all all-man analyze buildconfig buildfiles buildincludes \
 		checkdpadd clean cleandepend cleandir cleanilinks \
 		cleanobj depend distribute files includes installconfig \
 		installfiles installincludes print-dir realinstall lint \
 		maninstall manlint obj objlink tags \
 
 # Described above.
 STANDALONE_SUBDIR_TARGETS+= \
 		all-man buildconfig buildfiles buildincludes check checkdpadd \
 		clean cleandepend cleandir cleanilinks cleanobj files includes \
 		installconfig installincludes installfiles print-dir \
 		maninstall manlint obj objlink
 
 # It is safe to install in parallel when staging.
 .if defined(NO_ROOT)
 STANDALONE_SUBDIR_TARGETS+= realinstall
 .endif
 
 .include <bsd.init.mk>
 
 .if make(print-dir)
 NEED_SUBDIR=	1
 ECHODIR=	:
 .SILENT:
 .if ${RELDIR:U.} != "."
 print-dir:	.PHONY
 	@echo ${RELDIR}
 .endif
 .endif
 
 .if !defined(NEED_SUBDIR)
-.if ${.MAKE.LEVEL} == 0 && ${MK_DIRDEPS_BUILD} == "yes" && !empty(SUBDIR) && !(make(clean*) || make(destroy*))
+# .MAKE.DEPENDFILE==/dev/null is set by bsd.dep.mk to avoid reading
+# Makefile.depend
+.if ${.MAKE.LEVEL} == 0 && ${MK_DIRDEPS_BUILD} == "yes" && !empty(SUBDIR) && \
+    ${.MAKE.DEPENDFILE} != "/dev/null"
 .include <meta.subdir.mk>
 # ignore this
 _SUBDIR:
 .endif
 .endif
 
 DISTRIBUTION?=	base
 .if !target(distribute)
 distribute: .MAKE
 .for dist in ${DISTRIBUTION}
 	${_+_}cd ${.CURDIR}; \
 	    ${MAKE} install installconfig -DNO_SUBDIR DESTDIR=${DISTDIR}/${dist} SHARED=copies
 .endfor
 .endif
 # Convenience targets to run 'build${target}' and 'install${target}' when
 # calling 'make ${target}'.
 .for __target in files includes
 .if !target(${__target})
 ${__target}:	build${__target} install${__target}
 .ORDER:		build${__target} install${__target}
 .endif
 .endfor
 
 # Make 'install' supports a before and after target.  Actual install
 # hooks are placed in 'realinstall'.
 .if !target(install)
 .for __stage in before real after
 .if !target(${__stage}install)
 ${__stage}install:
 .endif
 .endfor
 install:	beforeinstall realinstall afterinstall
 .ORDER:		beforeinstall realinstall afterinstall
 .endif
 .ORDER: all install
 
 # SUBDIR recursing may be disabled for MK_DIRDEPS_BUILD
 .if !target(_SUBDIR)
 
 .if defined(SUBDIR) || defined(SUBDIR.yes)
 SUBDIR:=${SUBDIR} ${SUBDIR.yes}
 SUBDIR:=${SUBDIR:u}
 .endif
 
 # Subdir code shared among 'make <subdir>', 'make <target>' and SUBDIR_PARALLEL.
 _SUBDIR_SH=	\
 		if test -d ${.CURDIR}/$${dir}.${MACHINE_ARCH}; then \
 			dir=$${dir}.${MACHINE_ARCH}; \
 		fi; \
 		${ECHODIR} "===> ${DIRPRFX}$${dir} ($${target})"; \
 		cd ${.CURDIR}/$${dir}; \
 		${MAKE} $${target} DIRPRFX=${DIRPRFX}$${dir}/
 
 # This is kept for compatibility only.  The normal handling of attaching to
 # SUBDIR_TARGETS will create a target for each directory.
 _SUBDIR: .USEBEFORE
 .if defined(SUBDIR) && !empty(SUBDIR) && !defined(NO_SUBDIR)
 	@${_+_}target=${.TARGET:realinstall=install}; \
 	    for dir in ${SUBDIR:N.WAIT}; do ( ${_SUBDIR_SH} ); done
 .endif
 
 # Create 'make subdir' targets to run the real 'all' target.
 .for __dir in ${SUBDIR:N.WAIT}
 ${__dir}: all_subdir_${DIRPRFX}${__dir} .PHONY
 .endfor
 
 .for __target in ${SUBDIR_TARGETS}
 # Can ordering be skipped for this and SUBDIR_PARALLEL forced?
 .if ${STANDALONE_SUBDIR_TARGETS:M${__target}}
 _is_standalone_target=	1
 _subdir_filter=	N.WAIT
 .else
 _is_standalone_target=	0
 _subdir_filter=
 .endif
 __subdir_targets=
 .for __dir in ${SUBDIR:${_subdir_filter}}
 .if ${__dir} == .WAIT
 __subdir_targets+= .WAIT
 .else
 __deps=
 .if ${_is_standalone_target} == 0
 .if defined(SUBDIR_PARALLEL)
 # Apply SUBDIR_DEPEND dependencies for SUBDIR_PARALLEL.
 .for __dep in ${SUBDIR_DEPEND_${__dir}}
 __deps+= ${__target}_subdir_${DIRPRFX}${__dep}
 .endfor
 .else
 # For non-parallel builds, directories depend on all targets before them.
 __deps:= ${__subdir_targets}
 .endif	# defined(SUBDIR_PARALLEL)
 .endif	# ${_is_standalone_target} == 0
 ${__target}_subdir_${DIRPRFX}${__dir}: .PHONY .MAKE .SILENT ${__deps}
 	@${_+_}target=${__target:realinstall=install}; \
 	    dir=${__dir}; \
 	    ${_SUBDIR_SH};
 __subdir_targets+= ${__target}_subdir_${DIRPRFX}${__dir}
 .endif	# ${__dir} == .WAIT
 .endfor	# __dir in ${SUBDIR}
 
 # Attach the subdir targets to the real target.
 # Only recurse on directly-called targets.  I.e., don't recurse on dependencies
 # such as 'install' becoming {before,real,after}install, just recurse
 # 'install'.  Despite that, 'realinstall' is special due to ordering issues
 # with 'afterinstall'.
 .if !defined(NO_SUBDIR) && (make(${__target}) || \
     (${__target} == realinstall && make(install)))
 ${__target}: ${__subdir_targets} .PHONY
 .endif	# make(${__target})
 .endfor	# __target in ${SUBDIR_TARGETS}
 
 .endif	# !target(_SUBDIR)
 
 # Ensure all targets exist
 .for __target in ${SUBDIR_TARGETS}
 .if !target(${__target})
 ${__target}:
 .endif
 .endfor
 
 .endif