Index: head/lib/clang/clang.build.mk
===================================================================
--- head/lib/clang/clang.build.mk	(revision 291560)
+++ head/lib/clang/clang.build.mk	(revision 291561)
@@ -1,263 +1,243 @@
 # $FreeBSD$
 
 .include <src.opts.mk>
 
 CLANG_SRCS=	${LLVM_SRCS}/tools/clang
 
 CFLAGS+=	-I${LLVM_SRCS}/include -I${CLANG_SRCS}/include \
 		-I${LLVM_SRCS}/${SRCDIR} ${INCDIR:C/^/-I${LLVM_SRCS}\//} -I. \
 		-I${LLVM_SRCS}/../../lib/clang/include \
 		-DLLVM_ON_UNIX -DLLVM_ON_FREEBSD \
 		-D__STDC_LIMIT_MACROS -D__STDC_CONSTANT_MACROS #-DNDEBUG
 
 .if ${MK_CLANG_FULL} != "no"
 CFLAGS+=	-DCLANG_ENABLE_ARCMT \
 		-DCLANG_ENABLE_STATIC_ANALYZER
 .endif # MK_CLANG_FULL
 
 # LLVM is not strict aliasing safe as of 12/31/2011
 CFLAGS+=	-fno-strict-aliasing
 
 TARGET_ARCH?=	${MACHINE_ARCH}
 BUILD_ARCH?=	${MACHINE_ARCH}
 
 .if ${TARGET_ARCH:Marm*hf*} != ""
 TARGET_ABI=	gnueabihf
 .elif ${TARGET_ARCH:Marm*} != ""
 TARGET_ABI=	gnueabi
 .else
 TARGET_ABI=	unknown
 .endif
 
 TARGET_TRIPLE?=	${TARGET_ARCH:C/amd64/x86_64/:C/armv6hf/armv6/:C/arm64/aarch64/}-${TARGET_ABI}-freebsd11.0
 BUILD_TRIPLE?=	${BUILD_ARCH:C/amd64/x86_64/:C/armv6hf/armv6/:C/arm64/aarch64/}-unknown-freebsd11.0
 CFLAGS+=	-DLLVM_DEFAULT_TARGET_TRIPLE=\"${TARGET_TRIPLE}\" \
 		-DLLVM_HOST_TRIPLE=\"${BUILD_TRIPLE}\" \
 		-DDEFAULT_SYSROOT=\"${TOOLS_PREFIX}\"
 CXXFLAGS+=	-std=c++11 -fno-exceptions -fno-rtti
 CXXFLAGS.clang+= -stdlib=libc++
 
 .PATH:	${LLVM_SRCS}/${SRCDIR}
 
-.if ${MK_DIRDEPS_BUILD} == "yes"
-.if empty(TOOLSDIR) || !exists(${TOOLSDIR}/usr/bin/clang-tblgen)
-.if ${MACHINE} == "host" && defined(BOOTSTRAPPING_TOOLS)
-.if !empty(LEGACY_TOOLS) && exists(${LEGACY_TOOLS}/usr/bin/tblgen)
-TOOLSDIR= ${LEGACY_TOOLS}
-.endif
-.endif
-.if ${MK_STAGING} == "yes" && exists(${STAGE_HOST_OBJTOP:Uno}/usr/bin/tblgen)
-TOOLSDIR= ${STAGE_HOST_OBJTOP}
-.endif
-.if exists(${LEGACY_TOOLS:Uno}/usr/bin/tblgen)
-TOOLSDIR= ${LEGACY_TOOLS}
-.endif
-.endif
-TOOLSDIR?=
-.if !empty(TOOLSDIR) && exists(${TOOLSDIR}/usr/bin/clang-tblgen)
-TBLGEN= ${TOOLSDIR}/usr/bin/tblgen
-CLANG_TBLGEN= ${TOOLSDIR}/usr/bin/clang-tblgen
-.endif
-.endif	# ${MK_DIRDEPS_BUILD} == "yes"
 TBLGEN?=	tblgen
 CLANG_TBLGEN?=	clang-tblgen
 
 Intrinsics.inc.h: ${LLVM_SRCS}/include/llvm/IR/Intrinsics.td
 	${TBLGEN} -gen-intrinsic \
 	    -I ${LLVM_SRCS}/include -d ${.TARGET:C/\.h$/.d/} -o ${.TARGET} \
 	    ${LLVM_SRCS}/include/llvm/IR/Intrinsics.td
 .for arch in \
 	AArch64/AArch64 ARM/ARM Mips/Mips PowerPC/PPC Sparc/Sparc X86/X86
 . for hdr in \
 	AsmMatcher/-gen-asm-matcher \
 	AsmWriter1/-gen-asm-writer,-asmwriternum=1 \
 	AsmWriter/-gen-asm-writer \
 	CallingConv/-gen-callingconv \
 	CodeEmitter/-gen-emitter \
 	DAGISel/-gen-dag-isel \
 	DisassemblerTables/-gen-disassembler \
 	FastISel/-gen-fast-isel \
 	InstrInfo/-gen-instr-info \
 	MCCodeEmitter/-gen-emitter \
 	MCPseudoLowering/-gen-pseudo-lowering \
 	RegisterInfo/-gen-register-info \
 	SubtargetInfo/-gen-subtarget
 ${arch:T}Gen${hdr:H:C/$/.inc.h/}: ${LLVM_SRCS}/lib/Target/${arch:H}/${arch:T}.td
 	${TBLGEN} ${hdr:T:C/,/ /g} \
 	    -I ${LLVM_SRCS}/include -I ${LLVM_SRCS}/lib/Target/${arch:H} \
 	    -d ${.TARGET:C/\.h$/.d/} -o ${.TARGET} \
 	    ${LLVM_SRCS}/lib/Target/${arch:H}/${arch:T}.td
 . endfor
 .endfor
 
 Attrs.inc.h: ${CLANG_SRCS}/include/clang/Basic/Attr.td
 	${CLANG_TBLGEN} -gen-clang-attr-classes \
 	    -I ${CLANG_SRCS}/include -d ${.TARGET:C/\.h$/.d/} -o ${.TARGET} \
 	    ${CLANG_SRCS}/include/clang/Basic/Attr.td
 
 AttrDump.inc.h: ${CLANG_SRCS}/include/clang/Basic/Attr.td
 	${CLANG_TBLGEN} -gen-clang-attr-dump \
 	    -I ${CLANG_SRCS}/include -d ${.TARGET:C/\.h$/.d/} -o ${.TARGET} \
 	    ${CLANG_SRCS}/include/clang/Basic/Attr.td
 
 AttrHasAttributeImpl.inc.h: ${CLANG_SRCS}/include/clang/Basic/Attr.td
 	${CLANG_TBLGEN} -gen-clang-attr-has-attribute-impl \
 	    -I ${CLANG_SRCS}/include -d ${.TARGET:C/\.h$/.d/} -o ${.TARGET} \
 	    ${CLANG_SRCS}/include/clang/Basic/Attr.td
 
 AttrImpl.inc.h: ${CLANG_SRCS}/include/clang/Basic/Attr.td
 	${CLANG_TBLGEN} -gen-clang-attr-impl \
 	    -I ${CLANG_SRCS}/include -d ${.TARGET:C/\.h$/.d/} -o ${.TARGET} \
 	    ${CLANG_SRCS}/include/clang/Basic/Attr.td
 
 AttrList.inc.h: ${CLANG_SRCS}/include/clang/Basic/Attr.td
 	${CLANG_TBLGEN} -gen-clang-attr-list \
 	    -I ${CLANG_SRCS}/include -d ${.TARGET:C/\.h$/.d/} -o ${.TARGET} \
 	    ${CLANG_SRCS}/include/clang/Basic/Attr.td
 
 AttrParsedAttrImpl.inc.h: ${CLANG_SRCS}/include/clang/Basic/Attr.td
 	${CLANG_TBLGEN} -gen-clang-attr-parsed-attr-impl \
 	    -I ${CLANG_SRCS}/include -d ${.TARGET:C/\.h$/.d/} -o ${.TARGET} \
 	    ${CLANG_SRCS}/include/clang/Basic/Attr.td
 
 AttrParsedAttrKinds.inc.h: ${CLANG_SRCS}/include/clang/Basic/Attr.td
 	${CLANG_TBLGEN} -gen-clang-attr-parsed-attr-kinds \
 	    -I ${CLANG_SRCS}/include -d ${.TARGET:C/\.h$/.d/} -o ${.TARGET} \
 	    ${CLANG_SRCS}/include/clang/Basic/Attr.td
 
 AttrParsedAttrList.inc.h: ${CLANG_SRCS}/include/clang/Basic/Attr.td
 	${CLANG_TBLGEN} -gen-clang-attr-parsed-attr-list \
 	    -I ${CLANG_SRCS}/include -d ${.TARGET:C/\.h$/.d/} -o ${.TARGET} \
 	    ${CLANG_SRCS}/include/clang/Basic/Attr.td
 
 AttrParserStringSwitches.inc.h: ${CLANG_SRCS}/include/clang/Basic/Attr.td
 	${CLANG_TBLGEN} -gen-clang-attr-parser-string-switches \
 	    -I ${CLANG_SRCS}/include -d ${.TARGET:C/\.h$/.d/} -o ${.TARGET} \
 	    ${CLANG_SRCS}/include/clang/Basic/Attr.td
 
 AttrPCHRead.inc.h: ${CLANG_SRCS}/include/clang/Basic/Attr.td
 	${CLANG_TBLGEN} -gen-clang-attr-pch-read \
 	    -I ${CLANG_SRCS}/include -d ${.TARGET:C/\.h$/.d/} -o ${.TARGET} \
 	    ${CLANG_SRCS}/include/clang/Basic/Attr.td
 
 AttrPCHWrite.inc.h: ${CLANG_SRCS}/include/clang/Basic/Attr.td
 	${CLANG_TBLGEN} -gen-clang-attr-pch-write \
 	    -I ${CLANG_SRCS}/include -d ${.TARGET:C/\.h$/.d/} -o ${.TARGET} \
 	    ${CLANG_SRCS}/include/clang/Basic/Attr.td
 
 AttrSpellingListIndex.inc.h: ${CLANG_SRCS}/include/clang/Basic/Attr.td
 	${CLANG_TBLGEN} -gen-clang-attr-spelling-index \
 	    -I ${CLANG_SRCS}/include -d ${.TARGET:C/\.h$/.d/} -o ${.TARGET} \
 	    ${CLANG_SRCS}/include/clang/Basic/Attr.td
 
 AttrTemplateInstantiate.inc.h: ${CLANG_SRCS}/include/clang/Basic/Attr.td
 	${CLANG_TBLGEN} -gen-clang-attr-template-instantiate \
 	    -I ${CLANG_SRCS}/include -d ${.TARGET:C/\.h$/.d/} -o ${.TARGET} \
 	    ${CLANG_SRCS}/include/clang/Basic/Attr.td
 
 AttrVisitor.inc.h: ${CLANG_SRCS}/include/clang/Basic/Attr.td
 	${CLANG_TBLGEN} -gen-clang-attr-ast-visitor \
 	    -I ${CLANG_SRCS}/include -d ${.TARGET:C/\.h$/.d/} -o ${.TARGET} \
 	    ${CLANG_SRCS}/include/clang/Basic/Attr.td
 
 CommentCommandInfo.inc.h: ${CLANG_SRCS}/include/clang/AST/CommentCommands.td
 	${CLANG_TBLGEN} -gen-clang-comment-command-info \
 	    -d ${.TARGET:C/\.h$/.d/} -o ${.TARGET} \
 	    ${CLANG_SRCS}/include/clang/AST/CommentCommands.td
 
 CommentCommandList.inc.h: ${CLANG_SRCS}/include/clang/AST/CommentCommands.td
 	${CLANG_TBLGEN} -gen-clang-comment-command-list \
 	    -d ${.TARGET:C/\.h$/.d/} -o ${.TARGET} \
 	    ${CLANG_SRCS}/include/clang/AST/CommentCommands.td
 
 CommentHTMLNamedCharacterReferences.inc.h: \
 	${CLANG_SRCS}/include/clang/AST/CommentHTMLNamedCharacterReferences.td
 	${CLANG_TBLGEN} -gen-clang-comment-html-named-character-references \
 	    -d ${.TARGET:C/\.h$/.d/} -o ${.TARGET} \
 	    ${CLANG_SRCS}/include/clang/AST/CommentHTMLNamedCharacterReferences.td
 
 CommentHTMLTags.inc.h: ${CLANG_SRCS}/include/clang/AST/CommentHTMLTags.td
 	${CLANG_TBLGEN} -gen-clang-comment-html-tags \
 	    -d ${.TARGET:C/\.h$/.d/} -o ${.TARGET} \
 	    ${CLANG_SRCS}/include/clang/AST/CommentHTMLTags.td
 
 CommentHTMLTagsProperties.inc.h: \
 	${CLANG_SRCS}/include/clang/AST/CommentHTMLTags.td
 	${CLANG_TBLGEN} -gen-clang-comment-html-tags-properties \
 	    -d ${.TARGET:C/\.h$/.d/} -o ${.TARGET} \
 	    ${CLANG_SRCS}/include/clang/AST/CommentHTMLTags.td
 
 CommentNodes.inc.h: ${CLANG_SRCS}/include/clang/Basic/CommentNodes.td
 	${CLANG_TBLGEN} -gen-clang-comment-nodes \
 	    -d ${.TARGET:C/\.h$/.d/} -o ${.TARGET} \
 	    ${CLANG_SRCS}/include/clang/Basic/CommentNodes.td
 
 DeclNodes.inc.h: ${CLANG_SRCS}/include/clang/Basic/DeclNodes.td
 	${CLANG_TBLGEN} -gen-clang-decl-nodes \
 	    -d ${.TARGET:C/\.h$/.d/} -o ${.TARGET} \
 	    ${CLANG_SRCS}/include/clang/Basic/DeclNodes.td
 
 StmtNodes.inc.h: ${CLANG_SRCS}/include/clang/Basic/StmtNodes.td
 	${CLANG_TBLGEN} -gen-clang-stmt-nodes \
 	    -d ${.TARGET:C/\.h$/.d/} -o ${.TARGET} \
 	    ${CLANG_SRCS}/include/clang/Basic/StmtNodes.td
 
 arm_neon.h: ${CLANG_SRCS}/include/clang/Basic/arm_neon.td
 	${CLANG_TBLGEN} -gen-arm-neon \
 	    -d ${.TARGET:C/\.h$/.d/} -o ${.TARGET} \
 	    ${CLANG_SRCS}/include/clang/Basic/arm_neon.td
 
 arm_neon.inc.h: ${CLANG_SRCS}/include/clang/Basic/arm_neon.td
 	${CLANG_TBLGEN} -gen-arm-neon-sema \
 	    -d ${.TARGET:C/\.h$/.d/} -o ${.TARGET} \
 	    ${CLANG_SRCS}/include/clang/Basic/arm_neon.td
 
 DiagnosticGroups.inc.h: ${CLANG_SRCS}/include/clang/Basic/Diagnostic.td
 	${CLANG_TBLGEN} -gen-clang-diag-groups \
 	    -I ${CLANG_SRCS}/include/clang/Basic -d ${.TARGET:C/\.h$/.d/} \
 	    -o ${.TARGET} ${CLANG_SRCS}/include/clang/Basic/Diagnostic.td
 
 DiagnosticIndexName.inc.h: ${CLANG_SRCS}/include/clang/Basic/Diagnostic.td
 	${CLANG_TBLGEN} -gen-clang-diags-index-name \
 	    -I ${CLANG_SRCS}/include/clang/Basic -d ${.TARGET:C/\.h$/.d/} \
 	    -o ${.TARGET} ${CLANG_SRCS}/include/clang/Basic/Diagnostic.td
 
 .for hdr in AST Analysis Comment Common Driver Frontend Lex Parse Sema Serialization
 Diagnostic${hdr}Kinds.inc.h: ${CLANG_SRCS}/include/clang/Basic/Diagnostic.td
 	${CLANG_TBLGEN} -gen-clang-diags-defs -clang-component=${hdr} \
 	    -I ${CLANG_SRCS}/include/clang/Basic -d ${.TARGET:C/\.h$/.d/} \
 	    -o ${.TARGET} ${CLANG_SRCS}/include/clang/Basic/Diagnostic.td
 .endfor
 
 # XXX: Atrocious hack, need to clean this up later
 .if defined(LIB) && ${LIB} == "llvmlibdriver"
 Options.inc.h: ${LLVM_SRCS}/lib/LibDriver/Options.td
 	${TBLGEN} -gen-opt-parser-defs \
 	    -I ${LLVM_SRCS}/include \
 	    -d ${.TARGET:C/\.h$/.d/} -o ${.TARGET} \
 	    ${LLVM_SRCS}/lib/LibDriver/Options.td
 .else
 Options.inc.h: ${CLANG_SRCS}/include/clang/Driver/Options.td
 	${TBLGEN} -gen-opt-parser-defs \
 	    -I ${LLVM_SRCS}/include -I ${CLANG_SRCS}/include/clang/Driver \
 	    -d ${.TARGET:C/\.h$/.d/} -o ${.TARGET} \
 	    ${CLANG_SRCS}/include/clang/Driver/Options.td
 .endif
 
 Checkers.inc.h: ${CLANG_SRCS}/lib/StaticAnalyzer/Checkers/Checkers.td
 	${CLANG_TBLGEN} -gen-clang-sa-checkers \
 	    -I ${CLANG_SRCS}/include -d ${.TARGET:C/\.h$/.d/} -o ${.TARGET} \
 	    ${CLANG_SRCS}/lib/StaticAnalyzer/Checkers/Checkers.td
 
 .if !make(depend)
 . for dep in ${TGHDRS:C/$/.inc.d/}
 .  sinclude "${dep}"
 . endfor
 .endif
 
 SRCS+=		${TGHDRS:C/$/.inc.h/}
 CLEANFILES+=	${TGHDRS:C/$/.inc.h/} ${TGHDRS:C/$/.inc.d/}
 
 # if we are not doing explicit 'make depend', there is 
 # nothing to cause these to be generated.
 beforebuild: ${SRCS:M*.inc.h}
Index: head/share/mk/local.meta.sys.mk
===================================================================
--- head/share/mk/local.meta.sys.mk	(revision 291560)
+++ head/share/mk/local.meta.sys.mk	(revision 291561)
@@ -1,248 +1,254 @@
 # $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
 
 _default_makeobjdir=$${.CURDIR:S,^$${SRCTOP},$${OBJTOP},}
 
 .if empty(OBJROOT) || ${.MAKE.LEVEL} == 0
 .if defined(MAKEOBJDIRPREFIX)
 # put things approximately where they want
 OBJROOT:=${MAKEOBJDIRPREFIX}${SRCTOP}/
 MAKEOBJDIRPREFIX=
 .export MAKEOBJDIRPREFIX
 .endif
 .if empty(MAKEOBJDIR)
 # OBJTOP set below
 MAKEOBJDIR=${_default_makeobjdir}
 # export but do not track
 .export-env MAKEOBJDIR
 # Expand for our own use
 MAKEOBJDIR:= ${MAKEOBJDIR}
 .endif
 .if !empty(SB)
 SB_OBJROOT ?= ${SB}/obj/
 # this is what we use below
 OBJROOT ?= ${SB_OBJROOT}
 .endif
 OBJROOT ?= /usr/obj${SRCTOP}/
 .if ${OBJROOT:M*/} != ""
 OBJROOT:= ${OBJROOT:H:tA}/
 .else
 OBJROOT:= ${OBJROOT:H:tA}/${OBJROOT:T}
 .endif
 .export OBJROOT SRCTOP
 
 # we need HOST_TARGET etc below.
 .include <host-target.mk>
 .export HOST_TARGET
 .endif
 
 # from src/Makefile (for universe)
 TARGET_ARCHES_arm?=     arm armeb armv6 armv6hf
 TARGET_ARCHES_arm64?=   aarch64
 TARGET_ARCHES_mips?=    mipsel mips mips64el mips64 mipsn32 mipsn32el
 TARGET_ARCHES_powerpc?= powerpc powerpc64
 TARGET_ARCHES_pc98?=    i386
 
 # 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 mips pc98 powerpc sparc64
 .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}
 .endif
 
 .if ${.MAKE.LEVEL} == 0
 PYTHON ?= /usr/local/bin/python
 .export PYTHON
 # this works best if share/mk is ready for it.
 BUILD_AT_LEVEL0= no
 
 # 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
 .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_HOST_OBJTOP:= ${STAGE_ROOT}/${HOST_TARGET}
 
 # 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 -Wl,${STAGE_LIBDIR}
 .if ${MK_SYSROOT} == "yes"
 SYSROOT?= ${STAGE_OBJTOP}
 .else
 LDFLAGS_LAST+= -L${STAGE_LIBDIR}
 .endif
 
 .endif				# MK_STAGING
 
 # 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
 
 # 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
 
 # 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 OBJDUMP OBJCOPY RANLIB \
+		STRINGS SIZE TBLGEN
+_toolchain_bin_CLANG_TBLGEN=	/usr/bin/clang-tblgen
+_toolchain_bin_CXX=		/usr/bin/c++
 .ifdef WITH_TOOLSDIR
 TOOLSDIR?= ${HOST_OBJTOP}/tools
-.elif defined(STAGE_HOST_OBJTOP) && exists(${STAGE_HOST_OBJTOP}/usr/bin)
+.elif defined(STAGE_HOST_OBJTOP)
 TOOLSDIR?= ${STAGE_HOST_OBJTOP}
 .endif
-.if !empty(TOOLSDIR)
-.if ${.MAKE.LEVEL} == 0 && exists(${TOOLSDIR}/usr/bin)
-PATH:= ${PATH:S,:, ,g:@d@${exists(${TOOLSDIR}$d):?${TOOLSDIR}$d:}@:ts:}:${PATH}
+# Don't use the bootstrap tools logic on itself.
+.if ${.TARGETS:Mbootstrap-tools} == "" && \
+    !defined(BOOTSTRAPPING_TOOLS) && !empty(TOOLSDIR) && ${.MAKE.LEVEL} == 0
+.for dir in /sbin /bin /usr/sbin /usr/bin
+PATH:= ${TOOLSDIR}${dir}:${PATH}
+.endfor
 .export PATH
-.if exists(${TOOLSDIR}/usr/bin/cc)
-HOST_CC?=	${TOOLSDIR}/usr/bin/cc
-CC?=		${HOST_CC}
-HOST_CXX?=	${TOOLSDIR}/usr/bin/c++
-CXX?=		${HOST_CXX}
-HOST_CPP?=	${TOOLSDIR}/usr/bin/cpp
-CPP?=		${HOST_CPP}
-.export HOST_CC CC HOST_CXX CXX HOST_CPP CPP
+# 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}}
+${var}?=	${HOST_${var}}
+.export		HOST_${var} ${var}
 .endif
+.endfor
 .endif
-.endif
 
-HOST_CC?=	/usr/bin/cc
-HOST_CXX?=	/usr/bin/c++
-HOST_CPP?=	/usr/bin/cpp
+.for var in ${TOOLCHAIN_VARS}
+HOST_${var}?=	${_toolchain_bin_${var}:U/usr/bin/${var:tl}}
+.endfor
 
 .if ${MACHINE} == "host"
-CC=		${HOST_CC}
-CXX=		${HOST_CXX}
-CPP=		${HOST_CPP}
+.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}
 LDFLAGS+= -Wl,-m -Wl,elf_${MACHINE_ARCH}_fbsd
 .endif
Index: head/targets/pseudo/bootstrap-tools/Makefile
===================================================================
--- head/targets/pseudo/bootstrap-tools/Makefile	(revision 291560)
+++ head/targets/pseudo/bootstrap-tools/Makefile	(revision 291561)
@@ -1,87 +1,88 @@
 # $FreeBSD$
 
 # building clang is particularly tedious - so avoid re-inventing wheels
 
 all: bootstrap-toolchain
 
 UPDATE_DEPENDFILE= no
 .export UPDATE_DEPENDFILE
 
 # we build for the pseudo machine "host"
 TARGET_MACHINE= host
 
 HOST_MACHINE!= uname -m
 HOST_MACHINE_ARCH!= uname -p
 BTOOLSDIR?= ${HOST_OBJTOP}/tools
 LEGACY_TOOLS?= ${BTOOLSDIR}/legacy
 
 BSENV= \
 	unset MAKEOBJDIR; MAKEOBJDIRPREFIX=${BTOOLSDIR} \
 	MAKESYSPATH=${SRCTOP}/tools/build/mk:${SRCTOP}/share/mk \
 	TARGET=${HOST_MACHINE} TARGET_ARCH=${HOST_MACHINE_ARCH} \
 	WITHOUT_STAGING=1 STAGE_ROOT= BOOTSTRAPPING_TOOLS=1 \
-	WORLDTMP=${BTOOLSDIR} LEGACY_TOOLS=${LEGACY_TOOLS} \
+	WORLDTMP=${BTOOLSDIR} \
 	INSTALL="sh ${SRCTOP}/tools/install.sh" \
 	PATH=${LEGACY_TOOLS}/usr/sbin:${LEGACY_TOOLS}/usr/bin:${LEGACY_TOOLS}/bin:${PATH}
 
 .if !defined(OSRELDATE)
 ord_h= /usr/include/osreldate.h
 .if exists(${ord_h})
 OSRELDATE!= sed -n '/define.*__FreeBSD_version/{s,^[^0-9]*,,p;q;}' ${ord_h}
 .endif
 OSRELDATE?= 0
 .endif
 
 # need to keep this in sync with src/Makefile.inc1 
 BSARGS= 	DESTDIR= \
 		BOOTSTRAPPING=${OSRELDATE} \
 		SSP_CFLAGS= \
 		MK_HTML=no NO_LINT=yes MK_MAN=no \
 		-DNO_PIC MK_PROFILE=no -DNO_SHARED \
 		-DNO_CPU_CFLAGS MK_WARNS=no MK_CTF=no \
 		MK_CLANG_EXTRAS=no MK_CLANG_FULL=no \
 		MK_LLDB=no MK_TESTS=no \
 		MK_INCLUDES=yes
 
 # Need to override these so OBJTOP uses are proper in the non-meta build.
 BSARGS+= OBJTOP=${BTOOLSDIR}${SRCTOP} OBJROOT='$${OBJTOP}/'
 # We will handle building the toolchain and cross-compiler.
 BSARGS+= MK_CROSS_COMPILER=no MK_CLANG=no MK_GCC=no
 
 DISTRIB_ENV=	INSTALL="sh ${SRCTOP}/tools/install.sh" NO_FSCHG=1 MK_TESTS=no
 legacy: .MAKE .META
 	mkdir -p ${LEGACY_TOOLS}
 	${DISTRIB_ENV} ${MAKE} -C ${SRCTOP}/etc distrib-dirs \
 	    DESTDIR=${BTOOLSDIR} > $@.distrib-dirs_btoolsdir
 	${DISTRIB_ENV} ${MAKE} -C ${SRCTOP}/etc distrib-dirs \
 	    DESTDIR=${LEGACY_TOOLS} > $@.distrib-dirs_legacy_tools
 	${BSENV} ${MAKE} -C ${SRCTOP} -f Makefile.inc1 ${BSARGS} $@
 	touch $@
 
 bootstrap-tools: legacy
 build-tools: bootstrap-tools
 cross-tools: build-tools
 
 cross-tools build-tools bootstrap-tools: .MAKE .META
 	${BSENV} ${MAKE} -C ${SRCTOP} -f Makefile.inc1 ${BSARGS} $@
 	touch $@
 
 # MAKELEVEL=0 so that dirdeps.mk does its thing
-# LEGACY_TOOLS lets us use the bootstrapped stuff above
+# BSENV:MPATH=* lets us use the bootstrapped stuff in LEGACY_TOOLS above.
 # TARGET* is so that MK_CLANG gets set correctly.
 BSTCENV= \
 	MAKELEVEL=0 \
 	MACHINE=host \
-	LEGACY_TOOLS=${LEGACY_TOOLS} \
+	BOOTSTRAPPING_TOOLS=1 \
 	TARGET=${HOST_MACHINE} \
-	TARGET_ARCH=${HOST_MACHINE_ARCH}
+	TARGET_ARCH=${HOST_MACHINE_ARCH} \
+	${BSENV:MPATH=*}
 
 BSTCARGS= \
 	${BSARGS:NDESTDIR=*:NOBJTOP=*:NOBJROOT=*:NMK_CROSS_COMPILER=*:NMK_CLANG=*:NMK_GCC=*} \
 	BUILD_DIRDEPS=yes \
 	-DWITH_STAGING \
 	-DWITH_TOOLSDIR
 
 # finally we build toolchain leveraging the above.
 bootstrap-toolchain:	.MAKE cross-tools
 	${BSTCENV} ${MAKE} -C ${.CURDIR:H:H} ${BSTCARGS} toolchain