diff --git a/lib/clang/llvm.build.mk b/lib/clang/llvm.build.mk
index 2520637e2d06..c731deba8976 100644
--- a/lib/clang/llvm.build.mk
+++ b/lib/clang/llvm.build.mk
@@ -1,133 +1,132 @@
 
 .include <src.opts.mk>
 
 .ifndef LLVM_BASE
 .error Please define LLVM_BASE before including this file
 .endif
 
 .ifndef LLVM_SRCS
 .error Please define LLVM_SRCS before including this file
 .endif
 
 .ifndef SRCDIR
 .error Please define SRCDIR before including this file
 .endif
 
 .ifndef OS_REVISION
 .error Please define OS_REVISION before including this file
 .endif
 
 .PATH:		${LLVM_BASE}/${SRCDIR}
 
 CFLAGS+=	-I${SRCTOP}/lib/clang/include
 CFLAGS+=	-I${LLVM_SRCS}/include
 CFLAGS+=	-D__STDC_CONSTANT_MACROS
 CFLAGS+=	-D__STDC_FORMAT_MACROS
 CFLAGS+=	-D__STDC_LIMIT_MACROS
 CFLAGS+=	-DHAVE_VCS_VERSION_INC
 .if ${MK_LLVM_ASSERTIONS} == "no"
 CFLAGS+=	-DNDEBUG
 .endif
 
 # Note that using TARGET_ARCH here is essential for a functional native-xtools
 # build!  For native-xtools, we're building binaries that will work on the
 # *host* machine (MACHINE_ARCH), but they should default to producing binaries
 # for the *target* machine (TARGET_ARCH).
 TARGET_ARCH?=	${MACHINE_ARCH}
 BUILD_ARCH?=	${MACHINE_ARCH}
 
 # Armv6 and armv7 uses hard float abi, unless the CPUTYPE has soft in it.
 # For all other targets, we stick with 'unknown'.
 .if ${TARGET_ARCH:Marm*}
 .if !defined(CPUTYPE) || ${CPUTYPE:M*soft*} == ""
 TARGET_TRIPLE_ABI=-gnueabihf
 .else
 TARGET_TRIPLE_ABI=-gnueabi
 .endif
 .else
 TARGET_TRIPLE_ABI=
 .endif
 VENDOR=		unknown
 
 LLVM_TARGET_TRIPLE?=	${TARGET_ARCH:C/amd64/x86_64/}-${VENDOR}-freebsd${OS_REVISION}${TARGET_TRIPLE_ABI}
 LLVM_BUILD_TRIPLE?=	${BUILD_ARCH:C/amd64/x86_64/}-${VENDOR}-freebsd${OS_REVISION}
 
 CFLAGS+=	-DLLVM_DEFAULT_TARGET_TRIPLE=\"${LLVM_TARGET_TRIPLE}\"
 CFLAGS+=	-DLLVM_HOST_TRIPLE=\"${LLVM_BUILD_TRIPLE}\"
 CFLAGS+=	-DDEFAULT_SYSROOT=\"${TOOLS_PREFIX}\"
 
 .if ${MK_LLVM_TARGET_AARCH64} != "no"
 CFLAGS+=	-DLLVM_TARGET_ENABLE_AARCH64
 . if ${MACHINE_CPUARCH} == "aarch64"
 LLVM_NATIVE_ARCH=	AArch64
 . endif
 .endif
 .if ${MK_LLVM_TARGET_ARM} != "no"
 CFLAGS+=	-DLLVM_TARGET_ENABLE_ARM
 . if ${MACHINE_CPUARCH} == "arm"
 LLVM_NATIVE_ARCH=	ARM
 . endif
 .endif
 .if ${MK_LLVM_TARGET_BPF} != "no"
 CFLAGS+=	-DLLVM_TARGET_ENABLE_BPF
 .endif
 .if ${MK_LLVM_TARGET_MIPS} != "no"
 CFLAGS+=	-DLLVM_TARGET_ENABLE_MIPS
 .endif
 .if ${MK_LLVM_TARGET_POWERPC} != "no"
 CFLAGS+=	-DLLVM_TARGET_ENABLE_POWERPC
 . if ${MACHINE_CPUARCH} == "powerpc"
 LLVM_NATIVE_ARCH=	PowerPC
 . endif
 .endif
 .if ${MK_LLVM_TARGET_RISCV} != "no"
 CFLAGS+=	-DLLVM_TARGET_ENABLE_RISCV
 . if ${MACHINE_CPUARCH} == "riscv"
 LLVM_NATIVE_ARCH=	RISCV
 . endif
 .endif
 .if ${MK_LLVM_TARGET_X86} != "no"
 CFLAGS+=	-DLLVM_TARGET_ENABLE_X86
 . if ${MACHINE_CPUARCH} == "i386" || ${MACHINE_CPUARCH} == "amd64"
 LLVM_NATIVE_ARCH=	X86
 . endif
 .endif
 
 .ifdef LLVM_NATIVE_ARCH
 CFLAGS+=	-DLLVM_NATIVE_ASMPARSER=LLVMInitialize${LLVM_NATIVE_ARCH}AsmParser
 CFLAGS+=	-DLLVM_NATIVE_ASMPRINTER=LLVMInitialize${LLVM_NATIVE_ARCH}AsmPrinter
 CFLAGS+=	-DLLVM_NATIVE_DISASSEMBLER=LLVMInitialize${LLVM_NATIVE_ARCH}Disassembler
 CFLAGS+=	-DLLVM_NATIVE_TARGET=LLVMInitialize${LLVM_NATIVE_ARCH}Target
 CFLAGS+=	-DLLVM_NATIVE_TARGETINFO=LLVMInitialize${LLVM_NATIVE_ARCH}TargetInfo
 CFLAGS+=	-DLLVM_NATIVE_TARGETMC=LLVMInitialize${LLVM_NATIVE_ARCH}TargetMC
 .endif
 
 CFLAGS+=	-ffunction-sections
 CFLAGS+=	-fdata-sections
 .include "bsd.linker.mk"
 .if ${LINKER_TYPE} == "mac"
 LDFLAGS+=	-Wl,-dead_strip
 .else
 LDFLAGS+=	-Wl,--gc-sections
 # XXX: --gc-sections strips the ELF brand note and on RISC-V the OS/ABI ends up
 # as NONE, so for statically-linked binaries, i.e. lacking an interpreter,
 # get_brandinfo finds nothing and (f)execve fails with ENOEXEC. Work around
 # this by manually setting the OS/ABI field via the emulation.
 .if ${MACHINE_ARCH:Mriscv64*} != "" && ${NO_SHARED:Uno:tl} != "no" && \
     (${.MAKE.OS} == "FreeBSD" || !defined(BOOTSTRAPPING))
 LDFLAGS+=	-Wl,-m,elf64lriscv_fbsd
 .endif
 .endif
 
-CXXSTD?=	c++17
 CXXFLAGS+=	-fno-exceptions
 CXXFLAGS+=	-fno-rtti
 .if ${.MAKE.OS} == "FreeBSD" || !defined(BOOTSTRAPPING)
 CXXFLAGS.clang+= -stdlib=libc++
 .else
 # Building on macOS/Linux needs the real sysctl() not the bootstrap tools stub.
 CFLAGS+=	-DBOOTSTRAPPING_WANT_NATIVE_SYSCTL
 .endif
 .if defined(BOOTSTRAPPING) && ${.MAKE.OS} == "Linux"
 LIBADD+=	dl
 .endif
diff --git a/lib/libc/tests/stdlib/Makefile b/lib/libc/tests/stdlib/Makefile
index 54ac8a5f3b42..15b8d3844d08 100644
--- a/lib/libc/tests/stdlib/Makefile
+++ b/lib/libc/tests/stdlib/Makefile
@@ -1,85 +1,83 @@
 .include <src.opts.mk>
 
 ATF_TESTS_C+=		clearenv_test
 ATF_TESTS_C+=		cxa_atexit_test
 ATF_TESTS_C+=		dynthr_test
 ATF_TESTS_C+=		heapsort_test
 ATF_TESTS_C+=		libc_exit_test
 ATF_TESTS_C+=		mergesort_test
 ATF_TESTS_C+=		qsort_test
 .if ${COMPILER_TYPE} == "clang"
 ATF_TESTS_C+=		qsort_b_test
 .endif
 ATF_TESTS_C+=		qsort_r_compat_test
 ATF_TESTS_C+=		qsort_r_test
 ATF_TESTS_C+=		qsort_s_test
 ATF_TESTS_C+=		set_constraint_handler_s_test
 ATF_TESTS_C+=		strfmon_test
 ATF_TESTS_C+=		tsearch_test
 ATF_TESTS_CXX+=		cxa_thread_atexit_test
 ATF_TESTS_CXX+=		cxa_thread_atexit_nothr_test
 
 # All architectures on FreeBSD have fenv.h
 CFLAGS+=	-D__HAVE_FENV
 
 # Define __HAVE_LONG_DOUBLE for architectures whose long double has greater
 # precision than their double.
 .if ${MACHINE_CPUARCH} == "aarch64" || \
     ${MACHINE_CPUARCH} == "amd64" || \
     ${MACHINE_CPUARCH} == "i386" || \
     ${MACHINE_CPUARCH} == "riscv"
 CFLAGS+=	-D__HAVE_LONG_DOUBLE
 .endif
 
 # TODO: t_getenv_thread, t_mi_vector_hash, t_strtoi
 NETBSD_ATF_TESTS_C+=	abs_test
 NETBSD_ATF_TESTS_C+=	atoi_test
 NETBSD_ATF_TESTS_C+=	div_test
 NETBSD_ATF_TESTS_C+=	getenv_test
 NETBSD_ATF_TESTS_C+=	exit_test
 NETBSD_ATF_TESTS_C+=	hsearch_test
 NETBSD_ATF_TESTS_C+=	posix_memalign_test
 NETBSD_ATF_TESTS_C+=	random_test
 NETBSD_ATF_TESTS_C+=	strtod_test
 NETBSD_ATF_TESTS_C+=	strtol_test
 NETBSD_ATF_TESTS_C+=	system_test
 
 # TODO: need to come up with a correct explanation of what the patch pho does
 # with h_atexit
 #ATF_TESTS_SH=	atexit_test
 NETBSD_ATF_TESTS_SH=	getopt_test
 
 .include "../Makefile.netbsd-tests"
 
 BINDIR=		${TESTSDIR}
 
 # TODO: see comment above
 #PROGS+=		h_atexit
 PROGS+=		h_getopt h_getopt_long
 
 CFLAGS+=	-I${.CURDIR}
 
-CXXSTD.cxa_thread_atexit_test=	c++11
-CXXSTD.cxa_thread_atexit_nothr_test=	c++11
 LIBADD.cxa_thread_atexit_test+=		pthread
 
 # Tests that requires Blocks feature
 .for t in qsort_b_test
 CFLAGS.${t}.c+=		-fblocks
 LIBADD.${t}+=		BlocksRuntime
 .endfor
 
 .for t in h_getopt h_getopt_long
 CFLAGS.$t+=	-I${LIBNETBSD_SRCDIR} -I${SRCTOP}/contrib/netbsd-tests
 LDFLAGS.$t+=	-L${LIBNETBSD_OBJDIR}
 
 LIBADD.${t}+=	netbsd util
 .endfor
 
 LIBADD.libc_exit_test+=		pthread
 LIBADD.strtod_test+=		m
 
 SUBDIR+=	dynthr_mod
 SUBDIR+=	libatexit
 
 .include <bsd.test.mk>
diff --git a/lib/libclang_rt/Makefile.inc b/lib/libclang_rt/Makefile.inc
index c472e8b741be..e7db5a469661 100644
--- a/lib/libclang_rt/Makefile.inc
+++ b/lib/libclang_rt/Makefile.inc
@@ -1,36 +1,35 @@
 .include <bsd.compiler.mk>
 
 PACKAGE=	clang
 CRTSRC=		${SRCTOP}/contrib/llvm-project/compiler-rt
 .include "compiler-rt-vars.mk"
 
 .PATH:		${CRTSRC}/lib
 
 LIBDIR=		${SANITIZER_LIBDIR}
 SHLIBDIR=	${LIBDIR}
 
 NO_PIC=
 MK_ASAN:=	no
 MK_SSP=		no
 MK_UBSAN:=	no
 
 WARNS?=		0
 
 CFLAGS+=	-DNDEBUG
 CFLAGS+=	-DHAVE_RPC_XDR_H=0
 CFLAGS+=	-DSANITIZER_SUPPORTS_WEAK_HOOKS=0
 CFLAGS+=	-DUBSAN_CAN_USE_CXXABI
 CFLAGS+=	${PICFLAG}
 CFLAGS+=	-fno-builtin
 CFLAGS+=	-fno-exceptions
 CXXFLAGS+=	-fno-rtti
 .if ${COMPILER_TYPE} == clang
 CFLAGS+=	-fno-sanitize=safe-stack
 .endif
 CFLAGS+=	-fno-stack-protector
 CFLAGS+=	-funwind-tables
 CXXFLAGS+=	-fvisibility-inlines-hidden
 CXXFLAGS+=	-fvisibility=hidden
 CFLAGS+=	-I${CRTSRC}/include
 CFLAGS+=	-I${CRTSRC}/lib
-CXXSTD=		c++17
diff --git a/lib/libcxxrt/Makefile b/lib/libcxxrt/Makefile
index 7a683ba779f6..0f203b3a7cb1 100644
--- a/lib/libcxxrt/Makefile
+++ b/lib/libcxxrt/Makefile
@@ -1,54 +1,53 @@
 PACKAGE=	clibs
 SHLIBDIR?=	/lib
 
 .include <src.opts.mk>
 
 SRCDIR=		${SRCTOP}/contrib/libcxxrt
 
 SHLIB_MAJOR=	1
 
 .PATH: ${SRCDIR}
 
 LIB=		cxxrt
 
 SRCS+=		auxhelper.cc
 SRCS+=		dynamic_cast.cc
 SRCS+=		exception.cc
 SRCS+=		guard.cc
 SRCS+=		libelftc_dem_gnu3.c
 SRCS+=		memory.cc
 SRCS+=		stdexcept.cc
 SRCS+=		terminate.cc
 SRCS+=		typeinfo.cc
 
 WARNS?=		0
 CFLAGS+=	-isystem ${SRCDIR} -nostdinc++
-CXXSTD?=	c++14
 
 .if exists(Version.map.${MACHINE})
 VERSION_MAP=	${.CURDIR}/Version.map.${MACHINE}
 .else
 .if ${MACHINE_ABI:Mlong32}
 VERSION_MAP=	Version-32.map
 .else
 VERSION_MAP=	Version-64.map
 .endif
 
 Version-32.map: Version.map
 	sed 's/%%NEW_DELETE_TYPE%%/int/' ${.ALLSRC} > ${.TARGET}
 
 Version-64.map: Version.map
 	sed 's/%%NEW_DELETE_TYPE%%/long/' ${.ALLSRC} > ${.TARGET}
 .endif
 
 .include <bsd.lib.mk>
 
 # gcc13 doesn't support _Float16 on riscv, powerpc64, and x86 or __int128
 # on i386.  Disable checks for missing symbols to allow this to link.
 #
 # XXX: This is a hack that hides an ABI divergence between clang and gcc.
 .if ${COMPILER_TYPE} == "gcc" && \
     (${MACHINE_ARCH} == "amd64" || ${MACHINE_ARCH} == "i386" || \
      ${MACHINE_ARCH:Mpowerpc64*} || ${MACHINE_ARCH} == "riscv64")
 LDFLAGS+=	-Wl,--undefined-version
 .endif
diff --git a/lib/libgcc_eh/Makefile.inc b/lib/libgcc_eh/Makefile.inc
index af59ee7aaa65..529ef7170485 100644
--- a/lib/libgcc_eh/Makefile.inc
+++ b/lib/libgcc_eh/Makefile.inc
@@ -1,53 +1,52 @@
 COMPILERRTDIR=	${SRCTOP}/contrib/llvm-project/compiler-rt
 UNWINDINCDIR=	${SRCTOP}/contrib/llvm-project/libunwind/include
 UNWINDSRCDIR=	${SRCTOP}/contrib/llvm-project/libunwind/src
 
 STATIC_CFLAGS+=${PICFLAG} -fvisibility=hidden -DVISIBILITY_HIDDEN
 
 .PATH: ${COMPILERRTDIR}/lib/builtins
 .PATH: ${UNWINDSRCDIR}
 SRCS_EXC+=	gcc_personality_v0.c
 SRCS_EXC+=	Unwind-EHABI.cpp
 SRCS_EXC+=	Unwind-sjlj.c
 SRCS_EXC+=	UnwindLevel1-gcc-ext.c
 SRCS_EXC+=	UnwindLevel1.c
 SRCS_EXC+=	UnwindRegistersRestore.S
 SRCS_EXC+=	UnwindRegistersSave.S
 SRCS_EXC+=	libunwind.cpp
 
 SRCS+=		${SRCS_EXC}
 .if ${MACHINE} == "amd64" || ${MACHINE} == "i386" || ${MACHINE} == "powerpc"
 CFLAGS.UnwindLevel1-gcc-ext.c+=	-D_LIBUNWIND_SUPPORT_FRAME_APIS
 .endif
 .for file in ${SRCS_EXC:M*.c}
 CFLAGS.${file}+=	-fno-exceptions -funwind-tables
 .if ${MK_ASAN} != "no"
 # False-positives during stack unwinding
 CFLAGS.${file}+=	-fno-sanitize=address
 .endif
 .endfor
 .for file in ${SRCS_EXC:M*.cpp}
 CXXFLAGS.${file}+=	-fno-exceptions -funwind-tables
 .if ${MK_ASAN} != "no"
 # False-positives during stack unwinding
 CXXFLAGS.${file}+=	-fno-sanitize=address
 .endif
 .endfor
 
 CFLAGS+=	-I${UNWINDINCDIR}
 CFLAGS+=	-D_LIBUNWIND_IS_NATIVE_ONLY
 CFLAGS+=	-D_LIBUNWIND_USE_FRAME_HEADER_CACHE
 CXXFLAGS+=	-fno-rtti
-CXXSTD?=	c++11
 STATIC_CXXFLAGS+= -fvisibility=hidden -fPIC
 # Probably need to just move this earlier or use CXXFLAGS
 .if ${MK_DIRDEPS_BUILD} == "yes"
 # Avoid dependency on lib/libc++
 CFLAGS+=	-isystem ${SRCTOP}/contrib/llvm-project/libcxx/include -nostdinc++
 
 # we need this for __config_site
 CFLAGS+=	-I${SRCTOP}/lib/libc++
 .if ${.MAKE.LEVEL} > 0
 GENDIRDEPS_FILTER+= Nlib/libc++
 .endif
 .endif
diff --git a/lib/libomp/Makefile b/lib/libomp/Makefile
index 6c14c7d21077..f1513e70f3f6 100644
--- a/lib/libomp/Makefile
+++ b/lib/libomp/Makefile
@@ -1,97 +1,96 @@
 # z_Linux_asm.S is missing BTI support
 MK_BRANCH_PROTECTION=no
 
 .include <bsd.compiler.mk>
 
 SHLIB_NAME=	libomp.so
 
 OMPSRC=		${SRCTOP}/contrib/llvm-project/openmp/runtime/src
 ITTSRC=		${OMPSRC}/thirdparty/ittnotify
 .PATH:		${OMPSRC}
 .PATH:		${ITTSRC}
 
 SRCS+=		ittnotify_static.cpp
 SRCS+=		kmp_affinity.cpp
 SRCS+=		kmp_alloc.cpp
 SRCS+=		kmp_atomic.cpp
 SRCS+=		kmp_barrier.cpp
 SRCS+=		kmp_cancel.cpp
 SRCS+=		kmp_csupport.cpp
 SRCS+=		kmp_debug.cpp
 SRCS+=		kmp_dispatch.cpp
 SRCS+=		kmp_environment.cpp
 SRCS+=		kmp_error.cpp
 SRCS+=		kmp_ftn_cdecl.cpp
 SRCS+=		kmp_ftn_extra.cpp
 SRCS+=		kmp_global.cpp
 SRCS+=		kmp_gsupport.cpp
 SRCS+=		kmp_i18n.cpp
 SRCS+=		kmp_io.cpp
 SRCS+=		kmp_itt.cpp
 SRCS+=		kmp_lock.cpp
 SRCS+=		kmp_runtime.cpp
 SRCS+=		kmp_sched.cpp
 SRCS+=		kmp_settings.cpp
 SRCS+=		kmp_str.cpp
 SRCS+=		kmp_taskdeps.cpp
 SRCS+=		kmp_tasking.cpp
 SRCS+=		kmp_threadprivate.cpp
 SRCS+=		kmp_utility.cpp
 SRCS+=		kmp_version.cpp
 SRCS+=		kmp_wait_release.cpp
 SRCS+=		ompt-general.cpp
 SRCS+=		z_Linux_asm.S
 SRCS+=		z_Linux_util.cpp
 INCS+=		omp.h
 
 WARNS?=		1
 
 CFLAGS+=	-D__STDC_CONSTANT_MACROS
 CFLAGS+=	-D__STDC_FORMAT_MACROS
 CFLAGS+=	-D__STDC_LIMIT_MACROS
 CFLAGS+=	-I${.CURDIR}
 CFLAGS+=	-I${OMPSRC}
 CFLAGS+=	-I${ITTSRC}
 CFLAGS+=	-ffunction-sections
 CFLAGS+=	-fdata-sections
 CXXFLAGS+=	-fvisibility-inlines-hidden
 CXXFLAGS+=	-fno-exceptions
 CXXFLAGS+=	-fno-rtti
-CXXSTD=		c++17
 
 .if ${COMPILER_TYPE} == "clang"
 .if ${MACHINE_CPUARCH} == "i386"
 .if ${COMPILER_VERSION} >= 90000
 # When targeting i386, clang 9.0.0 produces a new warning about large atomic
 # operations "possibly incurring significant performance penalties", but there
 # is not much we can do about it.
 CWARNFLAGS+=	-Wno-atomic-alignment
 .endif
 .if ${COMPILER_VERSION} >= 170000
 # When targeting i386, clang 17.0.0 produces a new warning that __sync
 # builtin operations must have natural alignment, but there is not much we
 # can do about it.
 CWARNFLAGS+=	-Wno-sync-alignment
 .endif # COMPILER_VERSION >= 170000
 .endif # MACHINE_CPUARCH == i386
 .if ${COMPILER_VERSION} >= 180000
 # clang 18.0.0 introduces a new warning about variable length arrays in C++,
 # which OpenMP makes use of in several sources.
 CXXWARNFLAGS+=	-Wno-vla-cxx-extension
 .endif # COMPILER_VERSION >= 180000
 .endif # COMPILER_TYPE == clang
 
 LDFLAGS+=	-Wl,--warn-shared-textrel
 LDFLAGS+=	-Wl,--gc-sections
 LDFLAGS+=	-Wl,-z,noexecstack
 LDFLAGS+=	-Wl,-fini=__kmp_internal_end_fini
 LDFLAGS+=	-Wl,-soname,libomp.so
 
 VERSION_MAP=	${OMPSRC}/exports_so.txt
 
 LIBADD+=	pthread
 LIBADD+=	m
 
 SYMLINKS+=	${SHLIB_NAME} ${LIBDIR}/libgomp.so
 
 .include <bsd.lib.mk>
diff --git a/lib/ofed/libibnetdisc/Makefile b/lib/ofed/libibnetdisc/Makefile
index d3e0dd92509a..aac0bf0f5971 100644
--- a/lib/ofed/libibnetdisc/Makefile
+++ b/lib/ofed/libibnetdisc/Makefile
@@ -1,35 +1,34 @@
 .include <src.opts.mk>
 
 _spath=	${SRCTOP}/contrib/ofed/libibnetdisc
 .PATH: ${_spath} ${_spath}/man
 
 SHLIBDIR?=	/usr/lib
 LIB_CXX=	ibnetdisc
 SHLIB_MAJOR=	5
 
 SRCS= \
 chassis.c \
 g_hash_table.cpp \
 ibnetdisc.c \
 ibnetdisc_cache.c \
 query_smp.c
 
 MAN= \
 ibnd_discover_fabric.3 \
 ibnd_find_node_guid.3 \
 ibnd_iter_nodes.3
 
 MLINKS+=ibnd_discover_fabric.3 ibnd_debug.3
 MLINKS+=ibnd_discover_fabric.3 ibnd_destroy_fabric.3
 MLINKS+=ibnd_discover_fabric.3 ibnd_show_progress.3
 MLINKS+=ibnd_find_node_guid.3 ibnd_find_node_dr.3
 MLINKS+=ibnd_iter_nodes.3 ibnd_iter_nodes_type.3
 
 LIBADD=		osmcomp ibmad ibumad
 CFLAGS+=	-DHAVE_CONFIG_H=1
 CFLAGS+=	-I${_spath}
 CFLAGS+=	-I${SYSROOT:U${DESTDIR}}/${INCLUDEDIR}/infiniband
-CXXSTD=		c++11
 VERSION_MAP=	${_spath}/libibnetdisc.map
 
 .include <bsd.lib.mk>
diff --git a/libexec/atf/atf-pytest-wrapper/Makefile b/libexec/atf/atf-pytest-wrapper/Makefile
index e4dc0f8a5fd1..80b5e411ec4e 100644
--- a/libexec/atf/atf-pytest-wrapper/Makefile
+++ b/libexec/atf/atf-pytest-wrapper/Makefile
@@ -1,10 +1,9 @@
 .include <src.opts.mk>
 .include <bsd.init.mk>
 
 PACKAGE=	tests
 PROG_CXX=	atf_pytest_wrapper
 SRCS=		atf_pytest_wrapper.cpp
-CXXSTD=		c++17
 MAN=
 
 .include <bsd.prog.mk>
diff --git a/share/mk/bsd.sys.mk b/share/mk/bsd.sys.mk
index 63496e9b8ccd..b8535809e5aa 100644
--- a/share/mk/bsd.sys.mk
+++ b/share/mk/bsd.sys.mk
@@ -1,530 +1,532 @@
 #
 # 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:   https://gcc.gnu.org/onlinedocs/gcc/Warning-Options.html
 # for clang: https://clang.llvm.org/docs/DiagnosticsReference.html
 
 .include <bsd.compiler.mk>
 
 CSTD?=		gnu17
 
 .if ${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
 
+CXXSTD?=	gnu++17
+
 .if !empty(CXXSTD)
 CXXFLAGS+=	-std=${CXXSTD}
 .endif
 
 # This gives the Makefile we're evaluating at the top-level a chance to set
 # WARNS.  If it doesn't do so, we may freely pull a DEFAULTWARNS if it's set
 # and use that.  This allows us to default WARNS to 6 for src builds without
 # needing to set the default in various Makefile.inc.
 .if !defined(WARNS) && defined(DEFAULTWARNS)
 WARNS=	${DEFAULTWARNS}
 .endif
 
 # -pedantic is problematic because it also imposes namespace restrictions
 #CFLAGS+=	-pedantic
 .if defined(WARNS)
 .if ${WARNS} >= 1
 CWARNFLAGS+=	-Wsystem-headers
 .if ${MK_WERROR} != "no" && ${MK_WERROR.${COMPILER_TYPE}:Uyes} != "no"
 CWARNFLAGS+=	-Werror
 .endif # ${MK_WERROR} != "no" && ${MK_WERROR.${COMPILER_TYPE}:Uyes} != "no"
 .endif # WARNS >= 1
 .if ${WARNS} >= 2
 CWARNFLAGS+=	-Wall -Wno-format-y2k
 .endif # WARNS >= 2
 .if ${WARNS} >= 3
 CWARNFLAGS+=	-W -Wno-unused-parameter
 .if ${COMPILER_TYPE} == "clang"
 CWARNFLAGS+=	-Wstrict-prototypes
 .endif
 CWARNFLAGS+=	-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
 .if ${WARNS} >= 6
 CWARNFLAGS+=	-Wchar-subscripts -Wnested-externs \
 		-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
 .if !defined(NO_WDATE_TIME)
 CWARNFLAGS+=	-Wdate-time
 .endif # NO_WDATE_TIME
 # 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
 CWARNFLAGS.clang+=	-Wno-unused-const-variable
 .if ${COMPILER_TYPE} == "clang" && ${COMPILER_VERSION} >= 150000
 CWARNFLAGS.clang+=	-Wno-error=unused-but-set-parameter
 .endif
 .if ${COMPILER_TYPE} == "clang" && ${COMPILER_VERSION} >= 190000
 # Similar to gcc >= 8.1 -Wno-error=cast-function-type below
 CWARNFLAGS.clang+=	-Wno-error=cast-function-type-mismatch
 .endif
 .endif # WARNS <= 6
 .if ${WARNS} <= 3
 CWARNFLAGS.clang+=	-Wno-tautological-compare -Wno-unused-value\
 		-Wno-parentheses-equality -Wno-unused-function -Wno-enum-conversion
 CWARNFLAGS.clang+=	-Wno-unused-local-typedef
 CWARNFLAGS.clang+=	-Wno-address-of-packed-member
 .if ${COMPILER_TYPE} == "gcc" && ${COMPILER_VERSION} >= 90100
 CWARNFLAGS.gcc+=	-Wno-address-of-packed-member
 .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
 .if defined(NO_WMISLEADING_INDENTATION) && \
     ((${COMPILER_TYPE} == "clang" && ${COMPILER_VERSION} >= 100000) || \
       ${COMPILER_TYPE} == "gcc")
 CWARNFLAGS+=		-Wno-misleading-indentation
 .endif # NO_WMISLEADING_INDENTATION
 .if ${COMPILER_VERSION} >= 130000
 NO_WUNUSED_BUT_SET_VARIABLE=	-Wno-unused-but-set-variable
 .endif
 .if ${COMPILER_TYPE} == "clang" && ${COMPILER_VERSION} >= 140000
 NO_WBITWISE_INSTEAD_OF_LOGICAL=	-Wno-bitwise-instead-of-logical
 .endif
 .if ${COMPILER_TYPE} == "clang" && ${COMPILER_VERSION} >= 150000
 NO_WARRAY_PARAMETER=	-Wno-array-parameter
 NO_WSTRICT_PROTOTYPES=	-Wno-strict-prototypes
 NO_WDEPRECATED_NON_PROTOTYPE=-Wno-deprecated-non-prototype
 .endif
 .if ${COMPILER_TYPE} == "gcc" && ${COMPILER_VERSION} >= 50200
 NO_WUNUSED_BUT_SET_VARIABLE=-Wno-unused-but-set-variable
 .endif
 .if ${COMPILER_TYPE} == "gcc" && ${COMPILER_VERSION} >= 100100
 NO_WZERO_LENGTH_BOUNDS=	-Wno-zero-length-bounds
 .endif
 .if ${COMPILER_TYPE} == "gcc" && ${COMPILER_VERSION} >= 110100
 NO_WARRAY_PARAMETER=	-Wno-array-parameter
 .endif
 .if ${COMPILER_TYPE} == "gcc" && ${COMPILER_VERSION} >= 120100
 NO_WUSE_AFTER_FREE=	-Wno-use-after-free
 NO_WDANGLING_POINTER=	-Wno-dangling-pointer
 .endif
 .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:U0} <= 3
 CWARNFLAGS.clang+=	-Wno-format-nonliteral
 .endif # WARNS <= 3
 .if ${MK_WERROR} != "no" && ${MK_WERROR.${COMPILER_TYPE}:Uyes} != "no"
 CWARNFLAGS+=	-Werror
 .endif # ${MK_WERROR} != "no" && ${MK_WERROR.${COMPILER_TYPE}:Uyes} != "no"
 .endif # WFORMAT > 0
 .endif # WFORMAT
 .if defined(NO_WFORMAT) || defined(NO_WFORMAT.${COMPILER_TYPE})
 CWARNFLAGS+=	-Wno-format
 .endif # NO_WFORMAT || NO_WFORMAT.${COMPILER_TYPE}
 
 # GCC
 # We should clean up warnings produced with these flags.
 # They were originally added as a quick hack to enable gcc5/6.
 # The base system requires at least GCC 6.4, but some ports
 # use this file with older compilers.  Request an exprun
 # before changing these.
 .if ${COMPILER_TYPE} == "gcc"
 # GCC 5.2.0
 .if ${COMPILER_VERSION} >= 50200
 CWARNFLAGS+=	-Wno-error=address			\
 		-Wno-error=array-bounds			\
 		-Wno-error=attributes			\
 		-Wno-error=bool-compare			\
 		-Wno-error=cast-align			\
 		-Wno-error=clobbered			\
 		-Wno-error=deprecated-declarations	\
 		-Wno-error=enum-compare			\
 		-Wno-error=extra			\
 		-Wno-error=logical-not-parentheses	\
 		-Wno-error=strict-aliasing		\
 		-Wno-error=uninitialized		\
 		-Wno-error=unused-function		\
 		-Wno-error=unused-value
 .endif
 
 # GCC 6.1.0
 .if ${COMPILER_VERSION} >= 60100
 CWARNFLAGS+=	-Wno-error=empty-body			\
 		-Wno-error=maybe-uninitialized		\
 		-Wno-error=nonnull-compare		\
 		-Wno-error=shift-negative-value		\
 		-Wno-error=tautological-compare		\
 		-Wno-error=unused-const-variable
 .endif
 
 # GCC 7.1.0
 .if ${COMPILER_VERSION} >= 70100
 CWARNFLAGS+=	-Wno-error=bool-operation		\
 		-Wno-error=deprecated			\
 		-Wno-error=expansion-to-defined		\
 		-Wno-error=format-overflow		\
 		-Wno-error=format-truncation		\
 		-Wno-error=implicit-fallthrough		\
 		-Wno-error=int-in-bool-context		\
 		-Wno-error=memset-elt-size		\
 		-Wno-error=noexcept-type		\
 		-Wno-error=nonnull			\
 		-Wno-error=pointer-compare		\
 		-Wno-error=stringop-overflow
 .endif
 
 # GCC 8.1.0
 .if ${COMPILER_VERSION} >= 80100
 CWARNFLAGS+=	-Wno-error=aggressive-loop-optimizations	\
 		-Wno-error=cast-function-type			\
 		-Wno-error=catch-value				\
 		-Wno-error=multistatement-macros		\
 		-Wno-error=restrict				\
 		-Wno-error=sizeof-pointer-memaccess		\
 		-Wno-error=stringop-truncation
 CXXWARNFLAGS+=	-Wno-error=class-memaccess
 .endif
 
 # GCC 9.2.0
 .if ${COMPILER_VERSION} >= 90200
 .if ${MACHINE_ARCH} == "i386"
 CWARNFLAGS+=	-Wno-error=overflow
 .endif
 .endif
 
 # GCC 12.1.0
 .if ${COMPILER_VERSION} >= 120100
 # These warnings are raised by headers in libc++ so are disabled
 # globally for all C++
 CXXWARNFLAGS+=	-Wno-literal-suffix 			\
 		-Wno-error=unknown-pragmas
 .endif
 
 # GCC 13.1.0
 .if ${COMPILER_VERSION} >= 130100
 # These warnings are raised by headers in libc++ so are disabled
 # globally for all C++
 CXXWARNFLAGS+=	-Wno-dangling-reference
 .endif
 
 # GCC produces false positives for functions that switch on an
 # enum (GCC bug 87950)
 CWARNFLAGS+=	-Wno-return-type
 
 # GCC's own arm_neon.h triggers various warnings
 .if ${MACHINE_CPUARCH} == "aarch64"
 CWARNFLAGS+=	-Wno-system-headers
 .endif
 .endif	# gcc
 
 # How to handle FreeBSD custom printf format specifiers.
 .if ${COMPILER_TYPE} == "clang" || \
     (${COMPILER_TYPE} == "gcc" && ${COMPILER_VERSION} >= 120100)
 FORMAT_EXTENSIONS=	-D__printf__=__freebsd_kprintf__
 .else
 FORMAT_EXTENSIONS=	-fformat-extensions
 .endif
 
 .if defined(IGNORE_PRAGMA)
 CWARNFLAGS+=	-Wno-unknown-pragmas
 .endif # IGNORE_PRAGMA
 
 # This warning is utter nonsense
 CFLAGS+=	-Wno-format-zero-length
 
 .if ${COMPILER_TYPE} == "clang"
 # The headers provided by clang are incompatible with the FreeBSD headers.
 # If the version of clang is not one that has been patched to omit the
 # incompatible headers, we need to compile with -nobuiltininc and add the
 # resource dir to the end of the search paths. This ensures that headers such as
 # immintrin.h are still found but stddef.h, etc. are picked up from FreeBSD.
 #
 # XXX: This is a hack to support complete external installs of clang while
 # we work to synchronize our decleration guards with those in the clang tree.
 .if ${MK_CLANG_BOOTSTRAP:Uno} == "no" && \
     ${COMPILER_RESOURCE_DIR} != "unknown" && !defined(BOOTSTRAPPING)
 CFLAGS+=-nobuiltininc -idirafter ${COMPILER_RESOURCE_DIR}/include
 .endif
 .endif
 
 CLANG_OPT_SMALL= -mstack-alignment=8 -mllvm -inline-threshold=3
 .if ${COMPILER_VERSION} < 130000
 CLANG_OPT_SMALL+= -mllvm -simplifycfg-dup-ret
 .endif
 CLANG_OPT_SMALL+= -mllvm -enable-load-pre=false
 CFLAGS.clang+=	 -Qunused-arguments
 # 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
 
 # XXX This should be defaulted to 2 when WITH_SSP is in use after further
 # testing and soak time.
 FORTIFY_SOURCE?=	0
 .if ${MK_SSP} != "no"
 # Don't use -Wstack-protector as it breaks world with -Werror.
 .if ${COMPILER_FEATURES:Mstackclash}
 SSP_CFLAGS?=	-fstack-protector-strong -fstack-clash-protection
 .else
 SSP_CFLAGS?=	-fstack-protector-strong
 .endif
 CFLAGS+=	${SSP_CFLAGS}
 .endif # SSP
 .if ${FORTIFY_SOURCE} > 0
 CFLAGS+=	-D_FORTIFY_SOURCE=${FORTIFY_SOURCE}
 CXXFLAGS+=	-D_FORTIFY_SOURCE=${FORTIFY_SOURCE}
 .endif
 
 # Additional flags passed in CFLAGS and CXXFLAGS when MK_DEBUG_FILES is
 # enabled.
 DEBUG_FILES_CFLAGS?= -g -gz=zlib
 
 # Allow user-specified additional warning flags, plus compiler and file
 # specific flag overrides, unless we've overridden this...
 .if ${MK_WARNS} != "no"
 CFLAGS+=	${CWARNFLAGS:M*} ${CWARNFLAGS.${COMPILER_TYPE}}
 CFLAGS+=	${CWARNFLAGS.${.IMPSRC:T}}
 CXXFLAGS+=	${CXXWARNFLAGS:M*} ${CXXWARNFLAGS.${COMPILER_TYPE}}
 CXXFLAGS+=	${CXXWARNFLAGS.${.IMPSRC:T}}
 .endif
 
 CFLAGS+=	 ${CFLAGS.${COMPILER_TYPE}}
 CXXFLAGS+=	 ${CXXFLAGS.${COMPILER_TYPE}}
 
 AFLAGS+=	${AFLAGS.${.IMPSRC:T}}
 AFLAGS+=	${AFLAGS.${.TARGET:T}}
 ACFLAGS+=	${ACFLAGS.${.IMPSRC:T}}
 ACFLAGS+=	${ACFLAGS.${.TARGET:T}}
 CFLAGS+=	${CFLAGS.${.IMPSRC:T}}
 CXXFLAGS+=	${CXXFLAGS.${.IMPSRC:T}}
 
 LDFLAGS+=	${LDFLAGS.${LINKER_TYPE}}
 
 # Only allow .TARGET when not using PROGS as it has the same syntax
 # per PROG which is ambiguous with this syntax. This is only needed
 # for PROG_VARS vars.
 #
 # Some directories (currently just clang) also need to disable this since
 # CFLAGS.${COMPILER_TYPE}, CFLAGS.${.IMPSRC:T} and CFLAGS.${.TARGET:T} all live
 # in the same namespace, meaning that, for example, GCC builds of clang pick up
 # CFLAGS.clang via CFLAGS.${.TARGET:T} and thus try to pass Clang-specific
 # flags. Ideally the different sources of CFLAGS would be namespaced to avoid
 # collisions.
 .if !defined(_RECURSING_PROGS) && !defined(NO_TARGET_FLAGS)
 .if ${MK_WARNS} != "no"
 CFLAGS+=	${CWARNFLAGS.${.TARGET:T}}
 .endif
 CFLAGS+=	${CFLAGS.${.TARGET:T}}
 CXXFLAGS+=	${CXXFLAGS.${.TARGET:T}}
 LDFLAGS+=	${LDFLAGS.${.TARGET:T}}
 LDADD+=		${LDADD.${.TARGET:T}}
 LIBADD+=	${LIBADD.${.TARGET:T}}
 .endif
 
 .if defined(SRCTOP)
 # Prevent rebuilding during install to support read-only objdirs.
 .if ${.TARGETS:M*install*} == ${.TARGETS} && empty(.MAKE.MODE:Mmeta)
 CFLAGS+=	ERROR-tried-to-rebuild-during-make-install
 .endif
 .endif
 
 # Please keep this if in sync with kern.mk
 .if ${LD} != "ld" && (${CC:[1]:H} != ${LD:[1]:H} || ${LD:[1]:T} != "ld")
 # Add -fuse-ld=${LD} if $LD is in a different directory or not called "ld".
 .if ${COMPILER_TYPE} == "clang"
 # Note: Clang does not like relative paths for ld so we map ld.lld -> lld.
 .if ${COMPILER_VERSION} >= 120000
 LDFLAGS+=	--ld-path=${LD:[1]:S/^ld.//1W}
 .else
 LDFLAGS+=	-fuse-ld=${LD:[1]:S/^ld.//1W}
 .endif
 .elif ${COMPILER_TYPE} == "gcc"
 # GCC does not support an absolute path for -fuse-ld so we just print this
 # warning instead and let the user add the required symlinks.
 # However, we can avoid this warning if -B is set appropriately (e.g. for
 # CROSS_TOOLCHAIN=...-gcc).
 .if !(${LD:[1]:T} == "ld" && ${CC:tw:M-B${LD:[1]:H}/})
 .warning LD (${LD}) is not the default linker for ${CC} but -fuse-ld= is not supported
 .endif
 .endif
 .endif
 
 # Tell bmake not to mistake standard targets for things to be searched for
 # or expect to ever be up-to-date.
 PHONY_NOTMAIN = analyze afterdepend afterinstall all beforedepend beforeinstall \
 		beforelinking build build-tools buildconfig buildfiles \
 		buildincludes check checkdpadd clean cleandepend cleandir \
 		cleanobj configure depend distclean distribute exe \
 		files html includes install installconfig installdirs \
 		installfiles installincludes lint obj objlink objs objwarn \
 		realinstall 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*) && !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}
 .export DESTDIR
 
 .if target(beforeinstall)
 .if !empty(_LIBS) || (${MK_STAGING_PROG} != "no" && !defined(INTERNALPROG))
 staging: beforeinstall
 .endif
 .endif
 
 # normally only libs and includes are staged
 .if ${MK_STAGING_PROG} != "no" && !defined(INTERNALPROG)
 STAGE_DIR.prog= ${STAGE_OBJTOP}${BINDIR}
 
 .if !empty(PROG)
 .if defined(PROGNAME)
 STAGE_AS_SETS+= prog
 STAGE_AS_${PROG}= ${PROGNAME}
 stage_as.prog: ${PROG}
 .else
 STAGE_SETS+= prog
 stage_files.prog: ${PROG}
 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)
 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 defined(STATIC_LDSCRIPT) && target(lib${LIB}.ald)
 STAGE_AS_SETS+= ald
 STAGE_DIR.ald = ${STAGE_LIBDIR}
 STAGE_AS.ald+= lib${LIB}.ald
 STAGE_AS_lib${LIB}.ald = lib${LIB}.a
 stage_as.ald: lib${LIB}.ald
 .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)
 STAGE_TARGETS+= $t
 .endif
 .endfor
 
 .if !empty(STAGE_AS_SETS)
 STAGE_TARGETS+= stage_as
 .endif
 
 .if !empty(STAGE_TARGETS) || (${MK_STAGING_PROG} != "no" && !defined(INTERNALPROG))
 
 .if !empty(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)
 STAGE_TARGETS+= stage_symlinks
 STAGE_SETS+= links
 STAGE_SYMLINKS.links= ${SYMLINKS}
 .endif
 
 .endif
 
 .include <meta.stage.mk>
 .endif
 .endif
 
 .if defined(META_TARGETS)
 .for _tgt in ${META_TARGETS}
 .if target(${_tgt})
 ${_tgt}: ${META_DEPS}
 .endif
 .endfor
 .endif
 
 # we are generally the last makefile read
 CFLAGS+= ${CFLAGS_LAST}
 CXXFLAGS+= ${CXXFLAGS_LAST}
 LDFLAGS+= ${LDFLAGS_LAST}
diff --git a/share/mk/googletest.test.inc.mk b/share/mk/googletest.test.inc.mk
index 05415775448b..9ef5a3ceac00 100644
--- a/share/mk/googletest.test.inc.mk
+++ b/share/mk/googletest.test.inc.mk
@@ -1,14 +1,12 @@
 GTESTS_CXXFLAGS+= -DGTEST_HAS_POSIX_RE=1
 GTESTS_CXXFLAGS+= -DGTEST_HAS_PTHREAD=1
 GTESTS_CXXFLAGS+= -DGTEST_HAS_STREAM_REDIRECTION=1
 GTESTS_CXXFLAGS+= -frtti
 
 .include <bsd.compiler.mk>
 
 # XXX: src.libnames.mk should handle adding this directory for libgtest's,
 # libgmock's, etc, headers.
 CXXFLAGS+=	-I${DESTDIR}${INCLUDEDIR}/private
 
-CXXSTD?=	c++14
-
 NO_WTHREAD_SAFETY=
diff --git a/tests/sys/fs/fusefs/Makefile b/tests/sys/fs/fusefs/Makefile
index d91199fd519e..06b82071fe31 100644
--- a/tests/sys/fs/fusefs/Makefile
+++ b/tests/sys/fs/fusefs/Makefile
@@ -1,98 +1,97 @@
 .include <bsd.compiler.mk>
 
 PACKAGE=	tests
 
 TESTSDIR=	${TESTSBASE}/sys/fs/fusefs
 
 # We could simply link all of these files into a single executable.  But since
 # Kyua treats googletest programs as plain tests, it's better to separate them
 # out, so we get more granular reporting.
 GTESTS+=	access
 GTESTS+=	allow_other
 GTESTS+=	bad_server
 GTESTS+=	bmap
 GTESTS+=	cache
 GTESTS+=	copy_file_range
 GTESTS+=	create
 GTESTS+=	default_permissions
 GTESTS+=	default_permissions_privileged
 GTESTS+=	destroy
 GTESTS+=	dev_fuse_poll
 GTESTS+=	fallocate
 GTESTS+=	fifo
 GTESTS+=	flush
 GTESTS+=	forget
 GTESTS+=	fsync
 GTESTS+=	fsyncdir
 GTESTS+=	getattr
 GTESTS+=	interrupt
 GTESTS+=	io
 GTESTS+=	last_local_modify
 GTESTS+=	link
 GTESTS+=	locks
 GTESTS+=	lookup
 GTESTS+=	lseek
 GTESTS+=	mkdir
 GTESTS+=	mknod
 GTESTS+=	mount
 GTESTS+=	nfs
 GTESTS+=	notify
 GTESTS+=	open
 GTESTS+=	opendir
 GTESTS+=	read
 GTESTS+=	readdir
 GTESTS+=	readlink
 GTESTS+=	release
 GTESTS+=	releasedir
 GTESTS+=	rename
 GTESTS+=	rmdir
 GTESTS+=	setattr
 GTESTS+=	statfs
 GTESTS+=	symlink
 GTESTS+=	unlink
 GTESTS+=	write
 GTESTS+=	xattr
 
 .for p in ${GTESTS}
 SRCS.$p+=	${p}.cc
 SRCS.$p+=	getmntopts.c
 SRCS.$p+=	mockfs.cc
 SRCS.$p+=	utils.cc
 .endfor
 
 TEST_METADATA.default_permissions+=	required_user="unprivileged"
 TEST_METADATA.default_permissions_privileged+=	required_user="root"
 TEST_METADATA.mknod+=	required_user="root"
 TEST_METADATA.nfs+=	required_user="root"
 
 TEST_METADATA+= timeout=10
 
 FUSEFS=		${SRCTOP}/sys/fs/fuse
 MOUNT=		${SRCTOP}/sbin/mount
 # Suppress warnings that GCC generates for the libc++ and gtest headers.
 CXXWARNFLAGS.gcc+=	-Wno-placement-new -Wno-attributes
 # Suppress Wcast-align for readdir.cc, because it is unavoidable when using
 # getdirentries.
 CXXWARNFLAGS.readdir.cc+=	-Wno-cast-align
 .if ${COMPILER_TYPE} == "gcc" && ${COMPILER_VERSION} >= 80000
 CXXWARNFLAGS+=	-Wno-class-memaccess
 .endif
 # Suppress false warning about set but unused DNAME in inval_entry_below_root
 CXXWARNFLAGS.gcc+= -Wno-unused-but-set-variable
 # Suppress warnings about deprecated implicit copy constructors in gtest.
 CXXWARNFLAGS+=  -Wno-deprecated-copy
 .if ${COMPILER_TYPE} == "clang" && ${COMPILER_VERSION} >= 180000
 # clang 18.0.0 introduces a new warning about variable length arrays in C++.
 CXXWARNFLAGS+=	-Wno-vla-cxx-extension
 .endif
 CXXFLAGS+=	-I${SRCTOP}/tests
 CXXFLAGS+=	-I${FUSEFS}
 CXXFLAGS+=	-I${MOUNT}
 .PATH:		${MOUNT}
-CXXSTD=		c++14
 
 LIBADD+=	pthread
 LIBADD+=	gmock gtest
 LIBADD+=	util
 
 .include <bsd.test.mk>
diff --git a/usr.bin/dtc/Makefile b/usr.bin/dtc/Makefile
index 9b1aff13511f..d7661ae164c3 100644
--- a/usr.bin/dtc/Makefile
+++ b/usr.bin/dtc/Makefile
@@ -1,13 +1,11 @@
 PROG_CXX=dtc
 SRCS=	dtc.cc input_buffer.cc string.cc dtb.cc fdt.cc checking.cc
 MAN=	dtc.1
 
 WARNS?=	3
 
 CXXFLAGS+=	-fno-rtti -fno-exceptions
 
-CXXSTD=	c++17
-
 NO_SHARED?=NO
 
 .include <bsd.prog.mk>
diff --git a/usr.sbin/pmc/Makefile b/usr.sbin/pmc/Makefile
index 3f73dd398958..02292917ab57 100644
--- a/usr.sbin/pmc/Makefile
+++ b/usr.sbin/pmc/Makefile
@@ -1,15 +1,14 @@
 .include <src.opts.mk>
 
 PROG_CXX=	pmc
 MAN=	
-CXXSTD= c++14
 CWARNFLAGS.gcc+= -Wno-redundant-decls
 CFLAGS+= -I${SRCTOP}/lib/libpmcstat
 
 LIBADD=	pmc m pmcstat elf
 
 SRCS=	pmc.c pmc_util.c cmd_pmc_stat.c \
 	cmd_pmc_list.c cmd_pmc_filter.cc \
 	cmd_pmc_summary.cc
 
 .include <bsd.prog.mk>