Index: head/share/mk/bsd.incs.mk
===================================================================
--- head/share/mk/bsd.incs.mk	(revision 288963)
+++ head/share/mk/bsd.incs.mk	(revision 288964)
@@ -1,102 +1,102 @@
 # $FreeBSD$
 
 .if !target(__<bsd.init.mk>__)
 .error bsd.incs.mk cannot be included directly.
 .endif
 
 .if ${MK_INCLUDES} != "no"
 
 INCSGROUPS?=	INCS
 
 .if !target(buildincludes)
 .for group in ${INCSGROUPS}
 buildincludes: ${${group}}
 .endfor
 .endif
 
 all: buildincludes
 
 .if !target(installincludes)
 .for group in ${INCSGROUPS}
 .if defined(${group}) && !empty(${group})
 
 ${group}OWN?=	${BINOWN}
 ${group}GRP?=	${BINGRP}
 ${group}MODE?=	${NOBINMODE}
 ${group}DIR?=	${INCLUDEDIR}${PRIVATELIB:D/private/${LIB}}
 STAGE_SETS+=	${group}
 STAGE_DIR.${group}= ${STAGE_OBJTOP}${${group}DIR}
 STAGE_SYMLINKS_DIR.${group}= ${STAGE_OBJTOP}
 
 _${group}INCS=
 .for header in ${${group}}
 .if defined(${group}OWN_${header:T}) || defined(${group}GRP_${header:T}) || \
     defined(${group}MODE_${header:T}) || defined(${group}DIR_${header:T}) || \
     defined(${group}NAME_${header:T}) || defined(${group}NAME)
 ${group}OWN_${header:T}?=	${${group}OWN}
 ${group}GRP_${header:T}?=	${${group}GRP}
 ${group}MODE_${header:T}?=	${${group}MODE}
 ${group}DIR_${header:T}?=	${${group}DIR}
 .if defined(${group}NAME)
 ${group}NAME_${header:T}?=	${${group}NAME}
 .else
 ${group}NAME_${header:T}?=	${header:T}
 .endif
 STAGE_AS_SETS+= ${header:T}
 STAGE_AS_${header:T}= ${${group}NAME_${header:T}}
 # XXX {group}OWN,GRP,MODE
 STAGE_DIR.${header:T}= ${STAGE_OBJTOP}${${group}DIR_${header:T}}
 stage_as.${header:T}: ${header}
 stage_includes: stage_as.${header:T}
 
 installincludes: _${group}INS_${header:T}
 _${group}INS_${header:T}: ${header}
 	${INSTALL} -C -o ${${group}OWN_${.ALLSRC:T}} \
 	    -g ${${group}GRP_${.ALLSRC:T}} -m ${${group}MODE_${.ALLSRC:T}} \
 	    ${.ALLSRC} \
 	    ${DESTDIR}${${group}DIR_${.ALLSRC:T}}/${${group}NAME_${.ALLSRC:T}}
 .else
 _${group}INCS+= ${header}
 .endif
 .endfor
 .if !empty(_${group}INCS)
 stage_files.${group}: ${_${group}INCS}
 stage_includes: stage_files.${group}
 
 installincludes: _${group}INS
 _${group}INS: ${_${group}INCS}
 .if defined(${group}NAME)
 	${INSTALL} -C -o ${${group}OWN} -g ${${group}GRP} -m ${${group}MODE} \
 	    ${.ALLSRC} ${DESTDIR}${${group}DIR}/${${group}NAME}
 .else
 	${INSTALL} -C -o ${${group}OWN} -g ${${group}GRP} -m ${${group}MODE} \
 	    ${.ALLSRC} ${DESTDIR}${${group}DIR}
 .endif
 .endif
 
 .endif # defined(${group}) && !empty(${group})
 .endfor
 
 .if defined(INCSLINKS) && !empty(INCSLINKS)
 installincludes:
 .for s t in ${INCSLINKS}
 	@${ECHO} "$t -> $s" ; \
 	${INSTALL_SYMLINK} $s ${DESTDIR}$t
 .endfor
 .endif
 .endif # !target(installincludes)
 
 realinstall: installincludes
 .ORDER: beforeinstall installincludes
 
 .if ${MK_STAGING} != "no" && !defined(_SKIP_BUILD)
 .if !defined(NO_STAGE_INCLUDES)
-staging: stage_includes
+STAGE_TARGETS+= stage_includes
 .if !empty(INCSLINKS)
-staging: stage_symlinks
+STAGE_TARGETS+= stage_symlinks
 STAGE_SYMLINKS.INCS= ${INCSLINKS}
 .endif
 .endif
 .endif
 
 .endif # ${MK_TOOLCHAIN} != "no"
Index: head/share/mk/bsd.man.mk
===================================================================
--- head/share/mk/bsd.man.mk	(revision 288963)
+++ head/share/mk/bsd.man.mk	(revision 288964)
@@ -1,243 +1,243 @@
 # $FreeBSD$
 #
 # The include file <bsd.man.mk> handles installing manual pages and
 # their links.
 #
 #
 # +++ variables +++
 #
 # DESTDIR	Change the tree where the man pages gets installed. [not set]
 #
 # MANDIR	Base path for manual installation. [${SHAREDIR}/man/man]
 #
 # MANOWN	Manual owner. [${SHAREOWN}]
 #
 # MANGRP	Manual group. [${SHAREGRP}]
 #
 # MANMODE	Manual mode. [${NOBINMODE}]
 #
 # MANSUBDIR	Subdirectory under the manual page section, i.e. "/i386"
 #		or "/tahoe" for machine specific manual pages.
 #
 # MAN		The manual pages to be installed. For sections see
 #		variable ${SECTIONS}
 #
 # MCOMPRESS_CMD	Program to compress man pages. Output is to
 #		stdout. [${COMPRESS_CMD}]
 #
 # MLINKS	List of manual page links (using a suffix). The
 #		linked-to file must come first, the linked file
 #		second, and there may be multiple pairs. The files
 #		are hard-linked.
 #
 # NO_MLINKS	If you do not want install manual page links. [not set]
 #
 # MANFILTER	command to pipe the raw man page through before compressing
 #		or installing.  Can be used to do sed substitution.
 #
 # MANBUILDCAT	create preformatted manual pages in addition to normal
 #		pages. [not set]
 #
 # MANDOC_CMD	command and flags to create preformatted pages
 #
 # +++ targets +++
 #
 #	maninstall:
 #		Install the manual pages and their links.
 #
 
 .if !target(__<bsd.init.mk>__)
 .error bsd.man.mk cannot be included directly.
 .endif
 
 MINSTALL?=	${INSTALL} -o ${MANOWN} -g ${MANGRP} -m ${MANMODE}
 
 CATDIR=		${MANDIR:H:S/$/\/cat/}
 CATEXT=		.cat
 MANDOC_CMD?=	mandoc -Tascii
 
 MCOMPRESS_CMD?=	${COMPRESS_CMD}
 MCOMPRESS_EXT?=	${COMPRESS_EXT}
 
 SECTIONS=	1 2 3 4 5 6 7 8 9
 .SUFFIXES:	${SECTIONS:S/^/./g}
 
 # Backwards compatibility.
 .if !defined(MAN)
 .for __sect in ${SECTIONS}
 .if defined(MAN${__sect}) && !empty(MAN${__sect})
 MAN+=	${MAN${__sect}}
 .endif
 .endfor
 .endif
 
 _manpages:
 all-man: _manpages
 
 .if ${MK_MANCOMPRESS} == "no"
 
 # Make special arrangements to filter to a temporary file at build time
 # for MK_MANCOMPRESS == no.
 .if defined(MANFILTER)
 FILTEXTENSION=		.filt
 .else
 FILTEXTENSION=
 .endif
 
 ZEXT=
 
 .if defined(MANFILTER)
 .if defined(MAN) && !empty(MAN)
 CLEANFILES+=	${MAN:T:S/$/${FILTEXTENSION}/g}
 CLEANFILES+=	${MAN:T:S/$/${CATEXT}${FILTEXTENSION}/g}
 .for __page in ${MAN}
 .for __target in ${__page:T:S/$/${FILTEXTENSION}/g}
 _manpages: ${__target}
 ${__target}: ${__page}
 	${MANFILTER} < ${.ALLSRC} > ${.TARGET}
 .endfor
 .if defined(MANBUILDCAT) && !empty(MANBUILDCAT)
 .for __target in ${__page:T:S/$/${CATEXT}${FILTEXTENSION}/g}
 _manpages: ${__target}
 ${__target}: ${__page}
 	${MANFILTER} < ${.ALLSRC} | ${MANDOC_CMD} > ${.TARGET}
 .endfor
 .endif
 .endfor
 .endif
 .else
 .if defined(MAN) && !empty(MAN)
 CLEANFILES+=	${MAN:T:S/$/${CATEXT}/g}
 .if defined(MANBUILDCAT) && !empty(MANBUILDCAT)
 .for __page in ${MAN}
 .for __target in ${__page:T:S/$/${CATEXT}/g}
 _manpages: ${__target}
 ${__target}: ${__page}
 	${MANDOC_CMD} ${.ALLSRC} > ${.TARGET}
 .endfor
 .endfor
 .else
 _manpages: ${MAN}
 .endif
 .endif
 .endif
 
 .else
 
 ZEXT=		${MCOMPRESS_EXT}
 
 .if defined(MAN) && !empty(MAN)
 .if ${MK_STAGING_MAN} == "yes"
-staging: stage_files
+STAGE_TARGETS+= stage_files
 _mansets:= ${MAN:E:O:u:M*[1-9]:@s@man$s@}
 STAGE_SETS+= ${_mansets}
 .for _page in ${MAN}
 stage_files.man${_page:T:E}: ${_page}
 STAGE_DIR.man${_page:T:E}?= ${STAGE_OBJTOP}${MANDIR}${_page:T:E}${MANSUBDIR}
 .endfor
 .if !empty(MLINKS)
 STAGE_SETS+= mlinks
-staging: stage_links
+STAGE_TARGETS+= stage_links
 STAGE_LINKS.mlinks:= ${MLINKS:@f@${f:S,^,${MANDIR}${f:E}${MANSUBDIR}/,}@}
 stage_links.mlinks: ${_mansets:@s@stage_files.$s@}
 .endif
 .endif
 
 CLEANFILES+=	${MAN:T:S/$/${MCOMPRESS_EXT}/g}
 CLEANFILES+=	${MAN:T:S/$/${CATEXT}${MCOMPRESS_EXT}/g}
 .for __page in ${MAN}
 .for __target in ${__page:T:S/$/${MCOMPRESS_EXT}/}
 _manpages: ${__target}
 ${__target}: ${__page}
 .if defined(MANFILTER)
 	${MANFILTER} < ${.ALLSRC} | ${MCOMPRESS_CMD} > ${.TARGET}
 .else
 	${MCOMPRESS_CMD} ${.ALLSRC} > ${.TARGET}
 .endif
 .endfor
 .if defined(MANBUILDCAT) && !empty(MANBUILDCAT)
 .for __target in ${__page:T:S/$/${CATEXT}${MCOMPRESS_EXT}/}
 _manpages: ${__target}
 ${__target}: ${__page}
 .if defined(MANFILTER)
 	${MANFILTER} < ${.ALLSRC} | ${MANDOC_CMD} | ${MCOMPRESS_CMD} > ${.TARGET}
 .else
 	${MANDOC_CMD} ${.ALLSRC} | ${MCOMPRESS_CMD} > ${.TARGET}
 .endif
 .endfor
 .endif
 .endfor
 .endif
 
 .endif
 
 maninstall: _maninstall
 _maninstall:
 .if defined(MAN) && !empty(MAN)
 _maninstall: ${MAN}
 .if ${MK_MANCOMPRESS} == "no"
 .if defined(MANFILTER)
 .for __page in ${MAN}
 	${MINSTALL} ${__page:T:S/$/${FILTEXTENSION}/g} \
 		${DESTDIR}${MANDIR}${__page:E}${MANSUBDIR}/${__page}
 .if defined(MANBUILDCAT) && !empty(MANBUILDCAT)
 	${MINSTALL} ${__page:T:S/$/${CATEXT}${FILTEXTENSION}/g} \
 		${DESTDIR}${CATDIR}${__page:E}${MANSUBDIR}/${__page}
 .endif
 .endfor
 .else
 .for _page _sect in ${.ALLSRC:C/\.([^.]*)$/.\1 \1/}
 	@d=${DESTDIR}${MANDIR}${_sect}${MANSUBDIR}; \
 	${ECHO} ${MINSTALL} ${_page} $${d}; \
 	${MINSTALL} $${page} $${d};
 .endfor
 .if defined(MANBUILDCAT) && !empty(MANBUILDCAT)
 .for __page in ${MAN}
 	${MINSTALL} ${__page:T:S/$/${CATEXT}/} \
 		${DESTDIR}${CATDIR}${__page:E}${MANSUBDIR}/${__page:T}
 .endfor
 .endif
 .endif
 .else
 .for __page in ${MAN}
 	${MINSTALL} ${__page:T:S/$/${MCOMPRESS_EXT}/g} \
 		${DESTDIR}${MANDIR}${__page:E}${MANSUBDIR}
 .if defined(MANBUILDCAT) && !empty(MANBUILDCAT)
 	${MINSTALL} ${__page:T:S/$/${CATEXT}${MCOMPRESS_EXT}/g} \
 		${DESTDIR}${CATDIR}${__page:E}${MANSUBDIR}/${__page:T:S/$/${MCOMPRESS_EXT}/}
 .endif
 .endfor
 .endif
 .endif
 
 .if !defined(NO_MLINKS) && defined(MLINKS) && !empty(MLINKS)
 .for _oname _osect _dname _dsect in ${MLINKS:C/\.([^.]*)$/.\1 \1/}
 	@l=${DESTDIR}${MANDIR}${_osect}${MANSUBDIR}/${_oname}; \
 	t=${DESTDIR}${MANDIR}${_dsect}${MANSUBDIR}/${_dname}; \
 	${ECHO} $${t}${ZEXT} -\> $${l}${ZEXT}; \
 	rm -f $${t} $${t}${MCOMPRESS_EXT}; \
 	${INSTALL_LINK} $${l}${ZEXT} $${t}${ZEXT}
 .endfor
 .if defined(MANBUILDCAT) && !empty(MANBUILDCAT)
 .for _oname _osect _dname _dsect in ${MLINKS:C/\.([^.]*)$/.\1 \1/}
 	@l=${DESTDIR}${MANDIR}${_osect}${MANSUBDIR}/${_oname}; \
 	t=${DESTDIR}${MANDIR}${_dsect}${MANSUBDIR}/${_dname}; \
 	${ECHO} $${t}${ZEXT} -\> $${l}${ZEXT}; \
 	rm -f $${t} $${t}${MCOMPRESS_EXT}; \
 	${INSTALL_LINK} $${l}${ZEXT} $${t}${ZEXT}
 .endfor
 .endif
 .endif
 
 manlint:
 .if defined(MAN) && !empty(MAN)
 .for __page in ${MAN}
 manlint: ${__page}lint
 ${__page}lint: ${__page}
 .if defined(MANFILTER)
 	${MANFILTER} < ${.ALLSRC} | ${MANDOC_CMD} -Tlint
 .else
 	${MANDOC_CMD} -Tlint ${.ALLSRC}
 .endif
 .endfor
 .endif
Index: head/share/mk/bsd.nls.mk
===================================================================
--- head/share/mk/bsd.nls.mk	(revision 288963)
+++ head/share/mk/bsd.nls.mk	(revision 288964)
@@ -1,83 +1,83 @@
 # $FreeBSD$
 #
 # This include file <bsd.nls.mk> handles building and installing Native
 # Language Support (NLS) catalogs
 #
 # +++ variables +++
 #
 # GENCAT	A program for converting .msg files into compiled NLS
 #		.cat files. [gencat]
 #
 # NLS		Source or intermediate .msg files. [set in Makefile]
 #
 # NLSDIR	Base path for National Language Support files
 #		installation. [${SHAREDIR}/nls]
 #
 # NLSGRP	National Language Support files group. [${SHAREGRP}]
 #
 # NLSMODE	National Language Support files mode. [${NOBINMODE}]
 #
 # NLSOWN	National Language Support files owner. [${SHAREOWN}]
 
 .if !target(__<bsd.init.mk>__)
 .error bsd.nls.mk cannot be included directly.
 .endif
 
 GENCAT?=	gencat
 
 .SUFFIXES: .cat .msg
 
 .msg.cat:
 	${GENCAT} ${.TARGET} ${.IMPSRC}
 
 .if defined(NLS) && !empty(NLS) && ${MK_NLS} != "no"
 
 #
 # .msg file pre-build rules
 #
 NLSSRCDIR?=	${.CURDIR}
 .for file in ${NLS}
 .if defined(NLSSRCFILES)
 NLSSRCFILES_${file}?= ${NLSSRCFILES}
 .endif
 .if defined(NLSSRCFILES_${file})
 NLSSRCDIR_${file}?= ${NLSSRCDIR}
 ${file}.msg: ${NLSSRCFILES_${file}:S/^/${NLSSRCDIR_${file}}\//}
 	@rm -f ${.TARGET}
 	cat ${.ALLSRC} > ${.TARGET}
 CLEANFILES+= ${file}.msg
 .endif
 .endfor
 
 #
 # .cat file build rules
 #
 NLS:=		${NLS:=.cat}
 CLEANFILES+=	${NLS}
 FILESGROUPS?=	FILES
 FILESGROUPS+=	NLS
 NLSDIR?=	${SHAREDIR}/nls
 
 #
 # installation rules
 #
 .if ${MK_STAGING_PROG} == "yes"
 .if !defined(_SKIP_BUILD)
-staging:   stage_symlinks
+STAGE_TARGETS+= stage_symlinks
 .endif
 STAGE_SYMLINKS.NLS= ${NLSSYMLINKS}
 STAGE_SYMLINKS_DIR.NLS= ${STAGE_OBJTOP}
 .else
 SYMLINKS+= ${NLSSYMLINKS}
 .endif
 .for file in ${NLS}
 NLSNAME_${file:T}= ${file:T:R}/${NLSNAME}.cat
 .if defined(NLSLINKS_${file:R}) && !empty(NLSLINKS_${file:R})
 NLSLINKS+=	${file:R}
 .endif
 .for dst in ${NLSLINKS_${file:R}}
 NLSSYMLINKS+= ../${file:R}/${NLSNAME}.cat ${NLSDIR}/${dst}/${NLSNAME}.cat
 .endfor
 .endfor
 
 .endif # defined(NLS) && !empty(NLS) && ${MK_NLS} != "no"
Index: head/share/mk/bsd.sys.mk
===================================================================
--- head/share/mk/bsd.sys.mk	(revision 288963)
+++ head/share/mk/bsd.sys.mk	(revision 288964)
@@ -1,284 +1,284 @@
 # $FreeBSD$
 #
 # This file contains common settings used for building FreeBSD
 # sources.
 
 # Enable various levels of compiler warning checks.  These may be
 # overridden (e.g. if using a non-gcc compiler) by defining MK_WARNS=no.
 
 # for GCC:   http://gcc.gnu.org/onlinedocs/gcc-4.2.1/gcc/Warning-Options.html
 
 .include <bsd.compiler.mk>
 
 # the default is gnu99 for now
 CSTD?=		gnu99
 
 .if ${CSTD} == "k&r"
 CFLAGS+=	-traditional
 .elif ${CSTD} == "c89" || ${CSTD} == "c90"
 CFLAGS+=	-std=iso9899:1990
 .elif ${CSTD} == "c94" || ${CSTD} == "c95"
 CFLAGS+=	-std=iso9899:199409
 .elif ${CSTD} == "c99"
 CFLAGS+=	-std=iso9899:1999
 .else # CSTD
 CFLAGS+=	-std=${CSTD}
 .endif # CSTD
 # -pedantic is problematic because it also imposes namespace restrictions
 #CFLAGS+=	-pedantic
 .if defined(WARNS)
 .if ${WARNS} >= 1
 CWARNFLAGS+=	-Wsystem-headers
 .if !defined(NO_WERROR) && !defined(NO_WERROR.${COMPILER_TYPE})
 CWARNFLAGS+=	-Werror
 .endif # !NO_WERROR && !NO_WERROR.${COMPILER_TYPE}
 .endif # WARNS >= 1
 .if ${WARNS} >= 2
 CWARNFLAGS+=	-Wall -Wno-format-y2k
 .endif # WARNS >= 2
 .if ${WARNS} >= 3
 CWARNFLAGS+=	-W -Wno-unused-parameter -Wstrict-prototypes\
 		-Wmissing-prototypes -Wpointer-arith
 .endif # WARNS >= 3
 .if ${WARNS} >= 4
 CWARNFLAGS+=	-Wreturn-type -Wcast-qual -Wwrite-strings -Wswitch -Wshadow\
 		-Wunused-parameter
 .if !defined(NO_WCAST_ALIGN) && !defined(NO_WCAST_ALIGN.${COMPILER_TYPE})
 CWARNFLAGS+=	-Wcast-align
 .endif # !NO_WCAST_ALIGN !NO_WCAST_ALIGN.${COMPILER_TYPE}
 .endif # WARNS >= 4
 # BDECFLAGS
 .if ${WARNS} >= 6
 CWARNFLAGS+=	-Wchar-subscripts -Winline -Wnested-externs -Wredundant-decls\
 		-Wold-style-definition
 .if !defined(NO_WMISSING_VARIABLE_DECLARATIONS)
 CWARNFLAGS.clang+=	-Wmissing-variable-declarations
 .endif
 .if !defined(NO_WTHREAD_SAFETY)
 CWARNFLAGS.clang+=	-Wthread-safety
 .endif
 .endif # WARNS >= 6
 .if ${WARNS} >= 2 && ${WARNS} <= 4
 # XXX Delete -Wuninitialized by default for now -- the compiler doesn't
 # XXX always get it right.
 CWARNFLAGS+=	-Wno-uninitialized
 .endif # WARNS >=2 && WARNS <= 4
 CWARNFLAGS+=	-Wno-pointer-sign
 # Clang has more warnings enabled by default, and when using -Wall, so if WARNS
 # is set to low values, these have to be disabled explicitly.
 .if ${WARNS} <= 6
 CWARNFLAGS.clang+=	-Wno-empty-body -Wno-string-plus-int
 .if ${COMPILER_TYPE} == "clang" && ${COMPILER_VERSION} >= 30400
 CWARNFLAGS.clang+= -Wno-unused-const-variable
 .endif
 .endif # WARNS <= 6
 .if ${WARNS} <= 3
 CWARNFLAGS.clang+=	-Wno-tautological-compare -Wno-unused-value\
 		-Wno-parentheses-equality -Wno-unused-function -Wno-enum-conversion
 .if ${COMPILER_TYPE} == "clang" && ${COMPILER_VERSION} >= 30600
 CWARNFLAGS.clang+=	-Wno-unused-local-typedef
 .endif
 .endif # WARNS <= 3
 .if ${WARNS} <= 2
 CWARNFLAGS.clang+=	-Wno-switch -Wno-switch-enum -Wno-knr-promoted-parameter
 .endif # WARNS <= 2
 .if ${WARNS} <= 1
 CWARNFLAGS.clang+=	-Wno-parentheses
 .endif # WARNS <= 1
 .if defined(NO_WARRAY_BOUNDS)
 CWARNFLAGS.clang+=	-Wno-array-bounds
 .endif # NO_WARRAY_BOUNDS
 .endif # WARNS
 
 .if defined(FORMAT_AUDIT)
 WFORMAT=	1
 .endif # FORMAT_AUDIT
 .if defined(WFORMAT)
 .if ${WFORMAT} > 0
 #CWARNFLAGS+=	-Wformat-nonliteral -Wformat-security -Wno-format-extra-args
 CWARNFLAGS+=	-Wformat=2 -Wno-format-extra-args
 .if ${WARNS} <= 3
 CWARNFLAGS.clang+=	-Wno-format-nonliteral
 .endif # WARNS <= 3
 .if !defined(NO_WERROR) && !defined(NO_WERROR.${COMPILER_TYPE})
 CWARNFLAGS+=	-Werror
 .endif # !NO_WERROR && !NO_WERROR.${COMPILER_TYPE}
 .endif # WFORMAT > 0
 .endif # WFORMAT
 .if defined(NO_WFORMAT) || defined(NO_WFORMAT.${COMPILER_TYPE})
 CWARNFLAGS+=	-Wno-format
 .endif # NO_WFORMAT || NO_WFORMAT.${COMPILER_TYPE}
 
 # How to handle FreeBSD custom printf format specifiers.
 .if ${COMPILER_TYPE} == "clang" && ${COMPILER_VERSION} >= 30600
 FORMAT_EXTENSIONS=	-D__printf__=__freebsd_kprintf__
 .else
 FORMAT_EXTENSIONS=	-fformat-extensions
 .endif
 
 .if defined(IGNORE_PRAGMA)
 CWARNFLAGS+=	-Wno-unknown-pragmas
 .endif # IGNORE_PRAGMA
 
 # We need this conditional because many places that use it
 # only enable it for some files with CLFAGS.$FILE+=${CLANG_NO_IAS}.
 # unconditionally, and can't easily use the CFLAGS.clang=
 # mechanism.
 .if ${COMPILER_TYPE} == "clang"
 CLANG_NO_IAS=	 -no-integrated-as
 .endif
 CLANG_OPT_SMALL= -mstack-alignment=8 -mllvm -inline-threshold=3\
 		 -mllvm -simplifycfg-dup-ret
 .if ${COMPILER_VERSION} >= 30500 && ${COMPILER_VERSION} < 30700
 CLANG_OPT_SMALL+= -mllvm -enable-gvn=false
 .else
 CLANG_OPT_SMALL+= -mllvm -enable-load-pre=false
 .endif
 CFLAGS.clang+=	 -Qunused-arguments
 .if ${MACHINE_CPUARCH} == "sparc64"
 # Don't emit .cfi directives, since we must use GNU as on sparc64, for now.
 CFLAGS.clang+=	 -fno-dwarf2-cfi-asm
 .endif # SPARC64
 # The libc++ headers use c++11 extensions.  These are normally silenced because
 # they are treated as system headers, but we explicitly disable that warning
 # suppression when building the base system to catch bugs in our headers.
 # Eventually we'll want to start building the base system C++ code as C++11,
 # but not yet.
 CXXFLAGS.clang+=	 -Wno-c++11-extensions
 
 .if ${MK_SSP} != "no" && \
     ${MACHINE_CPUARCH} != "arm" && ${MACHINE_CPUARCH} != "mips"
 # Don't use -Wstack-protector as it breaks world with -Werror.
 SSP_CFLAGS?=	-fstack-protector-strong
 CFLAGS+=	${SSP_CFLAGS}
 .endif # SSP && !ARM && !MIPS
 
 # Allow user-specified additional warning flags, plus compiler specific flag overrides.
 # Unless we've overriden this...
 .if ${MK_WARNS} != "no"
 CFLAGS+=	${CWARNFLAGS} ${CWARNFLAGS.${COMPILER_TYPE}}
 .endif
 
 CFLAGS+=	 ${CFLAGS.${COMPILER_TYPE}}
 CXXFLAGS+=	 ${CXXFLAGS.${COMPILER_TYPE}}
 
 # Tell bmake not to mistake standard targets for things to be searched for
 # or expect to ever be up-to-date.
 PHONY_NOTMAIN = afterdepend afterinstall all beforedepend beforeinstall \
 		beforelinking build build-tools buildfiles buildincludes \
 		checkdpadd clean cleandepend cleandir cleanobj configure \
 		depend dependall distclean distribute exe \
 		html includes install installfiles installincludes lint \
 		obj objlink objs objwarn realall realdepend \
 		realinstall regress subdir-all subdir-depend subdir-install \
 		tags whereobj
 
 # we don't want ${PROG} to be PHONY
 .PHONY: ${PHONY_NOTMAIN:N${PROG:U}}
 .NOTMAIN: ${PHONY_NOTMAIN:Nall}
 
 .if ${MK_STAGING} != "no"
 .if defined(_SKIP_BUILD) || (!make(all) && !make(clean*))
 _SKIP_STAGING?= yes
 .endif
 .if ${_SKIP_STAGING:Uno} == "yes"
 staging stage_libs stage_files stage_as stage_links stage_symlinks:
 .else
 # allow targets like beforeinstall to be leveraged
 DESTDIR= ${STAGE_OBJTOP}
 
 .if commands(beforeinstall)
 .if !empty(_LIBS) || ${MK_STAGING_PROG} != "no"
 staging: beforeinstall
 .endif
 .endif
 
 # normally only libs and includes are staged
 .if ${MK_STAGING_PROG} != "no"
 STAGE_DIR.prog= ${STAGE_OBJTOP}${BINDIR}
 
 .if !empty(PROG) || !empty(PROGS)
 .if defined(PROGNAME)
 STAGE_AS_SETS+= prog
 STAGE_AS_${PROG}= ${PROGNAME}
 stage_as.prog: ${PROG}
 .else
 STAGE_SETS+= prog
 stage_files.prog: ${PROG}
-staging: stage_files
+STAGE_TARGETS+= stage_files
 .endif
 .endif
 .endif
 
 .if !empty(_LIBS) && !defined(INTERNALLIB)
 .if defined(SHLIBDIR) && ${SHLIBDIR} != ${LIBDIR} && ${_LIBS:Uno:M*.so.*} != ""
 STAGE_SETS+= shlib
 STAGE_DIR.shlib= ${STAGE_OBJTOP}${SHLIBDIR}
 STAGE_FILES.shlib+= ${_LIBS:M*.so.*}
 stage_files.shlib: ${_LIBS:M*.so.*}
 .endif
 
 .if defined(SHLIB_LINK) && commands(${SHLIB_LINK:R}.ld)
 _LDSCRIPTROOT?= ${STAGE_OBJTOP}
 STAGE_AS_SETS+= ldscript
 STAGE_AS.ldscript+= ${SHLIB_LINK:R}.ld
 stage_as.ldscript: ${SHLIB_LINK:R}.ld
 STAGE_DIR.ldscript = ${STAGE_LIBDIR}
 STAGE_AS_${SHLIB_LINK:R}.ld:= ${SHLIB_LINK}
 NO_SHLIB_LINKS=
 .endif
 
 .if target(stage_files.shlib)
 stage_libs: ${_LIBS}
 .if defined(DEBUG_FLAGS) && target(${SHLIB_NAME}.symbols)
 stage_files.shlib: ${SHLIB_NAME}.symbols
 .endif
 .else
 stage_libs: ${_LIBS}
 .endif
 .if defined(SHLIB_NAME) && defined(DEBUG_FLAGS) && target(${SHLIB_NAME}.symbols)
 stage_libs: ${SHLIB_NAME}.symbols
 .endif
 
 .endif
 
 .if !empty(INCS) || !empty(INCSGROUPS) && target(buildincludes)
 .if !defined(NO_BEFOREBUILD_INCLUDES)
 stage_includes: buildincludes
 beforebuild: stage_includes
 .endif
 .endif
 
 .for t in stage_libs stage_files stage_as
 .if target($t)
-staging: $t
+STAGE_TARGETS+= $t
 .endif
 .endfor
 
 .if !empty(STAGE_AS_SETS)
-staging: stage_as
+STAGE_TARGETS+= stage_as
 .endif
 
 .if !empty(_LIBS) || ${MK_STAGING_PROG} != "no"
 
 .if !empty(LINKS)
-staging: stage_links
+STAGE_TARGETS+= stage_links
 .if ${MAKE_VERSION} < 20131001
 stage_links.links: ${_LIBS} ${PROG}
 .endif
 STAGE_SETS+= links
 STAGE_LINKS.links= ${LINKS}
 .endif
 
 .if !empty(SYMLINKS)
-staging: stage_symlinks
+STAGE_TARGETS+= stage_symlinks
 STAGE_SETS+= links
 STAGE_SYMLINKS.links= ${SYMLINKS}
 .endif
 
 .endif
 
 .include <meta.stage.mk>
 .endif
 .endif
 
Index: head/share/mk/meta.stage.mk
===================================================================
--- head/share/mk/meta.stage.mk	(revision 288963)
+++ head/share/mk/meta.stage.mk	(revision 288964)
@@ -1,290 +1,293 @@
 # $FreeBSD$
 # $Id: meta.stage.mk,v 1.35 2015/05/20 06:40:33 sjg Exp $
 #
 #	@(#) Copyright (c) 2011, 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
 #
 
 .if !target(__${.PARSEFILE}__)
 __${.PARSEFILE}__:
 
 .if ${.MAKE.DEPENDFILE_PREFERENCE:U${.MAKE.DEPENDFILE}:M*.${MACHINE}} != ""
 # this is generally safer anyway
 _dirdep = ${RELDIR}.${MACHINE}
 .else
 _dirdep = ${RELDIR}
 .endif
 
+CLEANFILES+= .dirdep
+
 # this allows us to trace dependencies back to their src dir
 .dirdep:
 	@echo '${_dirdep}' > $@
 
 .if defined(NO_POSIX_SHELL) || ${type printf:L:sh:Mbuiltin} == ""
 _stage_file_basename = `basename $$f`
 _stage_target_dirname = `dirname $$t`
 .else
 _stage_file_basename = $${f\#\#*/}
 _stage_target_dirname = $${t%/*}
 .endif
 
 _OBJROOT ?= ${OBJROOT:U${OBJTOP:H}}
 .if ${_OBJROOT:M*/} != ""
 _objroot ?= ${_OBJROOT:tA}/
 .else
 _objroot ?= ${_OBJROOT:tA}
 .endif
 
 # make sure this is global
 _STAGED_DIRS ?=
 .export _STAGED_DIRS
 # add each dir we stage to to _STAGED_DIRS
 # and make sure we have absolute paths so that bmake
 # will match against .MAKE.META.BAILIWICK
 STAGE_DIR_FILTER = tA:@d@$${_STAGED_DIRS::+=$$d}$$d@
 # convert _STAGED_DIRS into suitable filters
 GENDIRDEPS_FILTER += Nnot-empty-is-important \
 	${_STAGED_DIRS:O:u:M${OBJTOP}*:S,${OBJTOP}/,N,} \
 	${_STAGED_DIRS:O:u:M${_objroot}*:N${OBJTOP}*:S,${_objroot},,:C,^([^/]+)/(.*),N\2.\1,:S,${HOST_TARGET},.host,}
 
 LN_CP_SCRIPT = LnCp() { \
   rm -f $$2 2> /dev/null; \
   ln $$1 $$2 2> /dev/null || \
   cp -p $$1 $$2; }
 
 # a staging conflict should cause an error
 # a warning is handy when bootstapping different options.
 STAGE_CONFLICT?= ERROR
 .if ${STAGE_CONFLICT:tl} == "error"
 STAGE_CONFLICT_ACTION= exit 1;
 .else
 STAGE_CONFLICT_ACTION=
 .endif
 
 # it is an error for more than one src dir to try and stage
 # the same file
 STAGE_DIRDEP_SCRIPT = ${LN_CP_SCRIPT}; StageDirdep() { \
   t=$$1; \
   if [ -s $$t.dirdep ]; then \
 	cmp -s .dirdep $$t.dirdep && return; \
 	echo "${STAGE_CONFLICT}: $$t installed by `cat $$t.dirdep` not ${_dirdep}" >&2; \
 	${STAGE_CONFLICT_ACTION} \
   fi; \
   LnCp .dirdep $$t.dirdep || exit 1; }
 
 # common logic for staging files
 # this all relies on RELDIR being set to a subdir of SRCTOP
 # we use ln(1) if we can, else cp(1)
 STAGE_FILE_SCRIPT = ${STAGE_DIRDEP_SCRIPT}; StageFiles() { \
   case "$$1" in "") return;; -m) mode=$$2; shift 2;; *) mode=;; esac; \
   dest=$$1; shift; \
   mkdir -p $$dest; \
   [ -s .dirdep ] || echo '${_dirdep}' > .dirdep; \
   for f in "$$@"; do \
 	case "$$f" in */*) t=$$dest/${_stage_file_basename};; *) t=$$dest/$$f;; esac; \
 	StageDirdep $$t; \
 	LnCp $$f $$t || exit 1; \
 	[ -z "$$mode" ] || chmod $$mode $$t; \
   done; :; }
 
 STAGE_LINKS_SCRIPT = ${STAGE_DIRDEP_SCRIPT}; StageLinks() { \
   case "$$1" in "") return;; --) shift;; -*) ldest= lnf=$$1; shift;; /*) ldest=$$1/;; esac; \
   dest=$$1; shift; \
   mkdir -p $$dest; \
   [ -s .dirdep ] || echo '${_dirdep}' > .dirdep; \
   while test $$\# -ge 2; do \
 	l=$$ldest$$1; shift; \
 	t=$$dest/$$1; \
 	case "$$1" in */*) mkdir -p ${_stage_target_dirname};; esac; \
 	shift; \
 	StageDirdep $$t; \
 	rm -f $$t 2>/dev/null; \
 	ln $$lnf $$l $$t || exit 1; \
   done; :; }
 
 STAGE_AS_SCRIPT = ${STAGE_DIRDEP_SCRIPT}; StageAs() { \
   case "$$1" in "") return;; -m) mode=$$2; shift 2;; *) mode=;; esac; \
   dest=$$1; shift; \
   mkdir -p $$dest; \
   [ -s .dirdep ] || echo '${_dirdep}' > .dirdep; \
   while test $$\# -ge 2; do \
 	s=$$1; shift; \
 	t=$$dest/$$1; \
 	case "$$1" in */*) mkdir -p ${_stage_target_dirname};; esac; \
 	shift; \
 	StageDirdep $$t; \
 	LnCp $$s $$t || exit 1; \
 	[ -z "$$mode" ] || chmod $$mode $$t; \
   done; :; }
 
 # this is simple, a list of the "staged" files depends on this,
 _STAGE_BASENAME_USE:	.USE ${.TARGET:T}
 	@${STAGE_FILE_SCRIPT}; StageFiles ${.TARGET:H:${STAGE_DIR_FILTER}} ${.TARGET:T}
 
 _STAGE_AS_BASENAME_USE:        .USE ${.TARGET:T}
 	@${STAGE_AS_SCRIPT}; StageAs ${.TARGET:H:${STAGE_DIR_FILTER}} ${.TARGET:T} ${STAGE_AS_${.TARGET:T}:U${.TARGET:T}}
 
 .if !empty(STAGE_INCSDIR)
 STAGE_TARGETS += stage_incs
-STAGE_INCS ?= ${.ALLSRC:N.dirdep}
+STAGE_INCS ?= ${.ALLSRC:N.dirdep:Nstage_*}
 
 stage_includes: stage_incs
 stage_incs:	.dirdep
 	@${STAGE_FILE_SCRIPT}; StageFiles ${STAGE_INCSDIR:${STAGE_DIR_FILTER}} ${STAGE_INCS}
 	@touch $@
 .endif
 
 .if !empty(STAGE_LIBDIR)
 STAGE_TARGETS += stage_libs
 
-STAGE_LIBS ?= ${.ALLSRC:N.dirdep}
+STAGE_LIBS ?= ${.ALLSRC:N.dirdep:Nstage_*}
 
 stage_libs:	.dirdep
 	@${STAGE_FILE_SCRIPT}; StageFiles ${STAGE_LIBDIR:${STAGE_DIR_FILTER}} ${STAGE_LIBS}
 .if !defined(NO_SHLIB_LINKS)
 .if !empty(SHLIB_LINKS)
 	@${STAGE_LINKS_SCRIPT}; StageLinks -s ${STAGE_LIBDIR:${STAGE_DIR_FILTER}} \
 	${SHLIB_LINKS:@t@${STAGE_LIBS:T:M$t.*} $t@}
 .elif !empty(SHLIB_LINK) && !empty(SHLIB_NAME)
 	@${STAGE_LINKS_SCRIPT}; StageLinks -s ${STAGE_LIBDIR:${STAGE_DIR_FILTER}} ${SHLIB_NAME} ${SHLIB_LINK} ${SYMLINKS:T}
 .endif
 .endif
 	@touch $@
 .endif
 
 .if !empty(STAGE_DIR)
 STAGE_SETS += _default
 STAGE_DIR._default = ${STAGE_DIR}
 STAGE_LINKS_DIR._default = ${STAGE_LINKS_DIR:U${STAGE_OBJTOP}}
 STAGE_SYMLINKS_DIR._default = ${STAGE_SYMLINKS_DIR:U${STAGE_OBJTOP}}
 STAGE_FILES._default = ${STAGE_FILES}
 STAGE_LINKS._default = ${STAGE_LINKS}
 STAGE_SYMLINKS._default = ${STAGE_SYMLINKS}
 STAGE_FILES ?= ${.ALLSRC:N.dirdep:Nstage_*}
 STAGE_SYMLINKS ?= ${.ALLSRC:T:N.dirdep:Nstage_*}
 .endif
 
 .if !empty(STAGE_SETS)
 CLEANFILES += ${STAGE_SETS:@s@stage*$s@}
 
 # some makefiles need to populate multiple directories
 .for s in ${STAGE_SETS:O:u}
-STAGE_FILES.$s ?= ${.ALLSRC:N.dirdep}
-STAGE_SYMLINKS.$s ?= ${.ALLSRC:N.dirdep}
+STAGE_FILES.$s ?= ${.ALLSRC:N.dirdep:Nstage_*}
+STAGE_SYMLINKS.$s ?= ${.ALLSRC:N.dirdep:Nstage_*}
 STAGE_LINKS_DIR.$s ?= ${STAGE_OBJTOP}
 STAGE_SYMLINKS_DIR.$s ?= ${STAGE_OBJTOP}
 
 STAGE_TARGETS += stage_files
 .if $s != "_default"
 stage_files:	stage_files.$s
 stage_files.$s:	.dirdep
 .else
 stage_files:	.dirdep
 .endif
 	@${STAGE_FILE_SCRIPT}; StageFiles ${FLAGS.$@} ${STAGE_FILES_DIR.$s:U${STAGE_DIR.$s}:${STAGE_DIR_FILTER}} ${STAGE_FILES.$s}
 	@touch $@
 
 STAGE_TARGETS += stage_links
 .if $s != "_default"
 stage_links:	stage_links.$s
 stage_links.$s:	.dirdep
 .else
 stage_links:	.dirdep
 .endif
 	@${STAGE_LINKS_SCRIPT}; StageLinks ${STAGE_LINKS_DIR.$s:U${STAGE_DIR.$s}:${STAGE_DIR_FILTER}} ${STAGE_LINKS.$s}
 	@touch $@
 
 STAGE_TARGETS += stage_symlinks
 .if $s != "_default"
 stage_symlinks:	stage_symlinks.$s
 stage_symlinks.$s:	.dirdep
 .else
 stage_symlinks:	.dirdep
 .endif
 	@${STAGE_LINKS_SCRIPT}; StageLinks -s ${STAGE_SYMLINKS_DIR.$s:U${STAGE_DIR.$s}:${STAGE_DIR_FILTER}} ${STAGE_SYMLINKS.$s}
 	@touch $@
 
 .endfor
 .endif
 
 .if !empty(STAGE_AS_SETS)
 CLEANFILES += ${STAGE_AS_SETS:@s@stage*$s@}
 
 STAGE_TARGETS += stage_as
 
 # sometimes things need to be renamed as they are staged
 # each ${file} will be staged as ${STAGE_AS_${file:T}}
 # one could achieve the same with SYMLINKS
 .for s in ${STAGE_AS_SETS:O:u}
-STAGE_AS.$s ?= ${.ALLSRC:N.dirdep}
+STAGE_AS.$s ?= ${.ALLSRC:N.dirdep:Nstage_*}
 
 stage_as:	stage_as.$s
 stage_as.$s:	.dirdep
 	@${STAGE_AS_SCRIPT}; StageAs ${FLAGS.$@} ${STAGE_FILES_DIR.$s:U${STAGE_DIR.$s}:${STAGE_DIR_FILTER}} ${STAGE_AS.$s:@f@$f ${STAGE_AS_${f:tA}:U${STAGE_AS_${f:T}:U${f:T}}}@}
 	@touch $@
 
 .endfor
 .endif
 
 CLEANFILES += ${STAGE_TARGETS} stage_incs stage_includes
 
 # stage_*links usually needs to follow any others.
-.if !empty(STAGE_SETS) && !empty(STAGE_TARGETS:Nstage_links)
-.for s in ${STAGE_SETS:O:u}
-stage_links.$s: ${STAGE_TARGETS:Nstage_links:O:u}
+# for non-jobs mode the order here matters
+staging: ${STAGE_TARGETS:N*_links} ${STAGE_TARGETS:M*_links}
+
+.if ${.MAKE.JOBS:U0} > 0 && ${STAGE_TARGETS:M*_links} != ""
+# the above isn't sufficient
+.for t in ${STAGE_TARGETS:N*links:O:u}
+.ORDER: $t stage_links
 .endfor
 .endif
-
-# make sure this exists
-staging:
 
 # generally we want staging to wait until everything else is done
 STAGING_WAIT ?= .WAIT
 
 .if ${.MAKE.LEVEL} > 0
 all: ${STAGING_WAIT} staging
 .endif
 
 .if exists(${.PARSEDIR}/stage-install.sh) && !defined(STAGE_INSTALL)
 # this will run install(1) and then followup with .dirdep files.
 STAGE_INSTALL := sh ${.PARSEDIR:tA}/stage-install.sh INSTALL="${INSTALL}" OBJDIR=${.OBJDIR:tA}
 .endif
 
 # if ${INSTALL} gets run during 'all' assume it is for staging?
 .if ${.TARGETS:Nall} == "" && defined(STAGE_INSTALL)
 INSTALL := ${STAGE_INSTALL}
 .if target(beforeinstall)
 beforeinstall: .dirdep
 .endif
 .endif
 .NOPATH: ${STAGE_FILES}
 
 .if !empty(STAGE_TARGETS)
 MK_STALE_STAGED?= no
 .if ${MK_STALE_STAGED} == "yes"
 all: stale_staged
 # get a list of paths that we have just staged
 # get a list of paths that we have previously staged to those same dirs
 # anything in the 2nd list but not the first is stale - remove it.
 stale_staged: staging .NOMETA
 	@egrep '^[WL] .*${STAGE_OBJTOP}' /dev/null ${.MAKE.META.FILES:M*stage_*} | \
 	sed "/\.dirdep/d;s,.* '*\(${STAGE_OBJTOP}/[^ '][^ ']*\).*,\1," | \
 	sort > ${.TARGET}.staged1
 	@grep -l '${_dirdep}' /dev/null ${_STAGED_DIRS:M${STAGE_OBJTOP}*:O:u:@d@$d/*.dirdep@} | \
 	sed 's,\.dirdep,,' | sort > ${.TARGET}.staged2
 	@comm -13 ${.TARGET}.staged1 ${.TARGET}.staged2 > ${.TARGET}.stale
 	@test ! -s ${.TARGET}.stale || { \
 		echo "Removing stale staged files..."; \
 		sed 's,.*,& &.dirdep,' ${.TARGET}.stale | xargs rm -f; }
 
 .endif
 .endif
 .endif