Index: head/lib/clang/llvm.build.mk =================================================================== --- head/lib/clang/llvm.build.mk (revision 345703) +++ head/lib/clang/llvm.build.mk (revision 345704) @@ -1,106 +1,106 @@ # $FreeBSD$ .include .ifndef LLVM_SRCS .error Please define LLVM_SRCS before including this file .endif .ifndef SRCDIR .error Please define SRCDIR before including this file .endif .PATH: ${LLVM_SRCS}/${SRCDIR} CFLAGS+= -I${SRCTOP}/lib/clang/include CFLAGS+= -I${LLVM_SRCS}/include CFLAGS+= -DLLVM_BUILD_GLOBAL_ISEL CFLAGS+= -D__STDC_LIMIT_MACROS CFLAGS+= -D__STDC_CONSTANT_MACROS #CFLAGS+= -DNDEBUG TARGET_ARCH?= ${MACHINE_ARCH} BUILD_ARCH?= ${MACHINE_ARCH} # Armv6 and armv7 uses hard float abi, unless the CPUTYPE has soft in it. # arm (for armv4 and armv5 CPUs) always uses the soft float ABI. # For all other targets, we stick with 'unknown'. .if ${TARGET_ARCH:Marmv[67]*} && (!defined(CPUTYPE) || ${CPUTYPE:M*soft*} == "") TARGET_ABI= -gnueabihf .elif ${TARGET_ARCH:Marm*} TARGET_ABI= -gnueabi .else TARGET_ABI= .endif VENDOR= unknown OS_VERSION= freebsd13.0 LLVM_TARGET_TRIPLE?= ${TARGET_ARCH:C/amd64/x86_64/:C/arm64/aarch64/}-${VENDOR}-${OS_VERSION}${TARGET_ABI} LLVM_BUILD_TRIPLE?= ${BUILD_ARCH:C/amd64/x86_64/:C/arm64/aarch64/}-${VENDOR}-${OS_VERSION} 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 . if ${MACHINE_CPUARCH} == "mips" LLVM_NATIVE_ARCH= Mips . endif .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_SPARC} != "no" CFLAGS+= -DLLVM_TARGET_ENABLE_SPARC . if ${MACHINE_CPUARCH} == "sparc64" LLVM_NATIVE_ARCH= Sparc . 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 LDFLAGS+= -Wl,--gc-sections -CXXFLAGS+= -std=c++11 +CXXSTD?= c++11 CXXFLAGS+= -fno-exceptions CXXFLAGS+= -fno-rtti CXXFLAGS.clang+= -stdlib=libc++ .if ${MACHINE_CPUARCH} == "arm" STATIC_CFLAGS+= -mlong-calls STATIC_CXXFLAGS+= -mlong-calls .endif Index: head/lib/libc/tests/stdlib/Makefile =================================================================== --- head/lib/libc/tests/stdlib/Makefile (revision 345703) +++ head/lib/libc/tests/stdlib/Makefile (revision 345704) @@ -1,68 +1,68 @@ # $FreeBSD$ .include ATF_TESTS_C+= dynthr_test ATF_TESTS_C+= heapsort_test ATF_TESTS_C+= mergesort_test ATF_TESTS_C+= qsort_test ATF_TESTS_C+= set_constraint_handler_s_test ATF_TESTS_C+= strfmon_test ATF_TESTS_C+= tsearch_test .if ${COMPILER_FEATURES:Mc++11} ATF_TESTS_CXX+= cxa_thread_atexit_test ATF_TESTS_CXX+= cxa_thread_atexit_nothr_test .endif # Not sure why this isn't defined for all architectures, since most # have long double. .if ${MACHINE_CPUARCH} == "aarch64" || \ ${MACHINE_CPUARCH} == "amd64" || \ ${MACHINE_CPUARCH} == "i386" 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} -CXXFLAGS.cxa_thread_atexit_test+= -std=c++11 -CXXFLAGS.cxa_thread_atexit_nothr_test+= -std=c++11 +CXXSTD.cxa_thread_atexit_test= c++11 +CXXSTD.cxa_thread_atexit_nothr_test= c++11 LIBADD.cxa_thread_atexit_test+= pthread .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.strtod_test+= m SUBDIR+= dynthr_mod .include Index: head/lib/libc++/Makefile =================================================================== --- head/lib/libc++/Makefile (revision 345703) +++ head/lib/libc++/Makefile (revision 345704) @@ -1,275 +1,273 @@ # $FreeBSD$ .include PACKAGE= clibs _LIBCXXRTDIR= ${SRCTOP}/contrib/libcxxrt HDRDIR= ${SRCTOP}/contrib/libc++/include SRCDIR= ${SRCTOP}/contrib/libc++/src CXXINCLUDEDIR= ${INCLUDEDIR}/c++/v${SHLIB_MAJOR} .if ${MACHINE_CPUARCH} == "arm" STATIC_CXXFLAGS+= -mlong-calls .endif .PATH: ${SRCDIR} LIB= c++ SHLIB_MAJOR= 1 SHLIB_LDSCRIPT= libc++.ldscript SRCS+= algorithm.cpp SRCS+= any.cpp SRCS+= bind.cpp SRCS+= charconv.cpp SRCS+= chrono.cpp SRCS+= condition_variable.cpp SRCS+= debug.cpp SRCS+= exception.cpp SRCS+= functional.cpp SRCS+= future.cpp SRCS+= hash.cpp SRCS+= ios.cpp SRCS+= iostream.cpp SRCS+= locale.cpp SRCS+= memory.cpp SRCS+= mutex.cpp SRCS+= new.cpp SRCS+= optional.cpp SRCS+= random.cpp SRCS+= regex.cpp SRCS+= shared_mutex.cpp SRCS+= stdexcept.cpp SRCS+= string.cpp SRCS+= strstream.cpp SRCS+= system_error.cpp SRCS+= thread.cpp SRCS+= typeinfo.cpp SRCS+= utility.cpp SRCS+= valarray.cpp SRCS+= variant.cpp SRCS+= vector.cpp SRCS+= filesystem/directory_iterator.cpp SRCS+= filesystem/int128_builtins.cpp SRCS+= filesystem/operations.cpp CXXRT_SRCS+= auxhelper.cc CXXRT_SRCS+= dynamic_cast.cc CXXRT_SRCS+= exception.cc CXXRT_SRCS+= guard.cc CXXRT_SRCS+= libelftc_dem_gnu3.c CXXRT_SRCS+= memory.cc CXXRT_SRCS+= stdexcept.cc CXXRT_SRCS+= terminate.cc CXXRT_SRCS+= typeinfo.cc .for _S in ${CXXRT_SRCS} CLEANFILES+= cxxrt_${_S} STATICOBJS+= cxxrt_${_S:R}.o cxxrt_${_S}: ${_LIBCXXRTDIR}/${_S} .NOMETA ln -sf ${.ALLSRC} ${.TARGET} .endfor WARNS= 0 CFLAGS+= -isystem ${HDRDIR} CFLAGS+= -isystem ${_LIBCXXRTDIR} CFLAGS+= -nostdinc++ CFLAGS+= -nostdlib CFLAGS+= -D_LIBCPP_BUILDING_LIBRARY CFLAGS+= -DLIBCXXRT -.if empty(CXXFLAGS:M-std=*) -CXXFLAGS+= -std=c++11 -.endif +CXXSTD= c++11 LIBADD+= cxxrt INCSGROUPS= STD EXP EXT STD_HEADERS+= __bit_reference STD_HEADERS+= __bsd_locale_defaults.h STD_HEADERS+= __bsd_locale_fallbacks.h STD_HEADERS+= __config STD_HEADERS+= __debug STD_HEADERS+= __errc STD_HEADERS+= __functional_03 STD_HEADERS+= __functional_base STD_HEADERS+= __functional_base_03 STD_HEADERS+= __hash_table STD_HEADERS+= __libcpp_version STD_HEADERS+= __locale STD_HEADERS+= __mutex_base STD_HEADERS+= __node_handle STD_HEADERS+= __nullptr STD_HEADERS+= __split_buffer STD_HEADERS+= __sso_allocator STD_HEADERS+= __std_stream STD_HEADERS+= __string STD_HEADERS+= __threading_support STD_HEADERS+= __tree STD_HEADERS+= __tuple STD_HEADERS+= __undef_macros STD_HEADERS+= algorithm STD_HEADERS+= any STD_HEADERS+= array STD_HEADERS+= atomic STD_HEADERS+= bit STD_HEADERS+= bitset STD_HEADERS+= cassert STD_HEADERS+= ccomplex STD_HEADERS+= cctype STD_HEADERS+= cerrno STD_HEADERS+= cfenv STD_HEADERS+= cfloat STD_HEADERS+= charconv STD_HEADERS+= chrono STD_HEADERS+= cinttypes STD_HEADERS+= ciso646 STD_HEADERS+= climits STD_HEADERS+= clocale STD_HEADERS+= cmath STD_HEADERS+= codecvt STD_HEADERS+= compare STD_HEADERS+= complex STD_HEADERS+= complex.h STD_HEADERS+= condition_variable STD_HEADERS+= csetjmp STD_HEADERS+= csignal STD_HEADERS+= cstdarg STD_HEADERS+= cstdbool STD_HEADERS+= cstddef STD_HEADERS+= cstdint STD_HEADERS+= cstdio STD_HEADERS+= cstdlib STD_HEADERS+= cstring STD_HEADERS+= ctgmath STD_HEADERS+= ctime STD_HEADERS+= ctype.h STD_HEADERS+= cwchar STD_HEADERS+= cwctype STD_HEADERS+= deque STD_HEADERS+= errno.h STD_HEADERS+= exception STD_HEADERS+= filesystem STD_HEADERS+= float.h STD_HEADERS+= forward_list STD_HEADERS+= fstream STD_HEADERS+= functional STD_HEADERS+= future STD_HEADERS+= initializer_list STD_HEADERS+= inttypes.h STD_HEADERS+= iomanip STD_HEADERS+= ios STD_HEADERS+= iosfwd STD_HEADERS+= iostream STD_HEADERS+= istream STD_HEADERS+= iterator STD_HEADERS+= limits STD_HEADERS+= limits.h STD_HEADERS+= list STD_HEADERS+= locale STD_HEADERS+= locale.h STD_HEADERS+= map STD_HEADERS+= math.h STD_HEADERS+= memory STD_HEADERS+= mutex STD_HEADERS+= new STD_HEADERS+= numeric STD_HEADERS+= optional STD_HEADERS+= ostream STD_HEADERS+= queue STD_HEADERS+= random STD_HEADERS+= ratio STD_HEADERS+= regex STD_HEADERS+= scoped_allocator STD_HEADERS+= set STD_HEADERS+= setjmp.h STD_HEADERS+= shared_mutex STD_HEADERS+= span STD_HEADERS+= sstream STD_HEADERS+= stack STD_HEADERS+= stdbool.h STD_HEADERS+= stddef.h STD_HEADERS+= stdexcept STD_HEADERS+= stdint.h STD_HEADERS+= stdio.h STD_HEADERS+= stdlib.h STD_HEADERS+= streambuf STD_HEADERS+= string STD_HEADERS+= string.h STD_HEADERS+= string_view STD_HEADERS+= strstream STD_HEADERS+= system_error STD_HEADERS+= tgmath.h STD_HEADERS+= thread STD_HEADERS+= tuple STD_HEADERS+= type_traits STD_HEADERS+= typeindex STD_HEADERS+= typeinfo STD_HEADERS+= unordered_map STD_HEADERS+= unordered_set STD_HEADERS+= utility STD_HEADERS+= valarray STD_HEADERS+= variant STD_HEADERS+= vector STD_HEADERS+= version STD_HEADERS+= wchar.h STD_HEADERS+= wctype.h RT_HEADERS+= cxxabi.h RT_HEADERS+= unwind-arm.h RT_HEADERS+= unwind-itanium.h RT_HEADERS+= unwind.h .for hdr in ${STD_HEADERS} STD+= ${HDRDIR}/${hdr} INCSLINKS+= ../${hdr} ${CXXINCLUDEDIR}/tr1/${hdr} .endfor .for hdr in ${RT_HEADERS} STD+= ${_LIBCXXRTDIR}/${hdr} .endfor STDDIR= ${CXXINCLUDEDIR} EXP_HEADERS+= __config EXP_HEADERS+= __memory EXP_HEADERS+= algorithm EXP_HEADERS+= any EXP_HEADERS+= chrono EXP_HEADERS+= coroutine EXP_HEADERS+= deque EXP_HEADERS+= filesystem EXP_HEADERS+= forward_list EXP_HEADERS+= functional EXP_HEADERS+= iterator EXP_HEADERS+= list EXP_HEADERS+= map EXP_HEADERS+= memory_resource EXP_HEADERS+= numeric EXP_HEADERS+= optional EXP_HEADERS+= propagate_const EXP_HEADERS+= ratio EXP_HEADERS+= regex EXP_HEADERS+= set EXP_HEADERS+= simd EXP_HEADERS+= string EXP_HEADERS+= string_view EXP_HEADERS+= system_error EXP_HEADERS+= tuple EXP_HEADERS+= type_traits EXP_HEADERS+= unordered_map EXP_HEADERS+= unordered_set EXP_HEADERS+= utility EXP_HEADERS+= vector .for hdr in ${EXP_HEADERS} EXP+= ${HDRDIR}/experimental/${hdr} .endfor EXPDIR= ${CXXINCLUDEDIR}/experimental EXT_HEADERS+= __hash EXT_HEADERS+= hash_map EXT_HEADERS+= hash_set .for hdr in ${EXT_HEADERS} EXT+= ${HDRDIR}/ext/${hdr} .endfor EXTDIR= ${CXXINCLUDEDIR}/ext .include Index: head/lib/libc++experimental/Makefile =================================================================== --- head/lib/libc++experimental/Makefile (revision 345703) +++ head/lib/libc++experimental/Makefile (revision 345704) @@ -1,27 +1,25 @@ # $FreeBSD$ .include PACKAGE= clibs SRCDIR= ${SRCTOP}/contrib/libc++ LIB= c++experimental NO_PIC= MK_PROFILE= no .PATH: ${SRCDIR}/src/experimental SRCS+= memory_resource.cpp WARNS?= 0 CXXFLAGS+= ${PICFLAG} CXXFLAGS+= -isystem ${SRCDIR}/include CXXFLAGS+= -nostdinc++ CXXFLAGS+= -nostdlib CXXFLAGS+= -D_LIBCPP_BUILDING_LIBRARY CXXFLAGS+= -DLIBCXXRT -.if empty(CXXFLAGS:M-std=*) -CXXFLAGS+= -std=c++14 -.endif +CXXSTD= c++14 .include Index: head/lib/libc++fs/Makefile =================================================================== --- head/lib/libc++fs/Makefile (revision 345703) +++ head/lib/libc++fs/Makefile (revision 345704) @@ -1,29 +1,27 @@ # $FreeBSD$ .include PACKAGE= clibs SRCDIR= ${SRCTOP}/contrib/libc++ LIB= c++fs NO_PIC= MK_PROFILE= no .PATH: ${SRCDIR}/src/filesystem SRCS+= directory_iterator.cpp SRCS+= int128_builtins.cpp SRCS+= operations.cpp WARNS?= 0 CXXFLAGS+= ${PICFLAG} CXXFLAGS+= -isystem ${SRCDIR}/include CXXFLAGS+= -nostdinc++ CXXFLAGS+= -nostdlib CXXFLAGS+= -D_LIBCPP_BUILDING_LIBRARY CXXFLAGS+= -DLIBCXXRT -.if empty(CXXFLAGS:M-std=*) -CXXFLAGS+= -std=c++14 -.endif +CXXSTD= c++14 .include Index: head/lib/libclang_rt/Makefile.inc =================================================================== --- head/lib/libclang_rt/Makefile.inc (revision 345703) +++ head/lib/libclang_rt/Makefile.inc (revision 345704) @@ -1,44 +1,44 @@ # $FreeBSD$ .include # armv[67] is a bit special since we allow a soft-floating version via # CPUTYPE matching *soft*. This variant may not actually work though. .if ${MACHINE_ARCH:Marmv[67]*} != "" && \ (!defined(CPUTYPE) || ${CPUTYPE:M*soft*} == "") CRTARCH?= armhf .else CRTARCH?= ${MACHINE_CPUARCH:C/amd64/x86_64/} .endif CRTSRC= ${SRCTOP}/contrib/compiler-rt .PATH: ${CRTSRC}/lib CLANGDIR= /usr/lib/clang/8.0.0 LIBDIR= ${CLANGDIR}/lib/freebsd SHLIBDIR= ${LIBDIR} NO_PIC= MK_PROFILE= no WARNS?= 0 SSP_CFLAGS= CFLAGS+= -DNDEBUG CFLAGS+= -DHAVE_RPC_XDR_H=0 CFLAGS+= -DHAVE_TIRPC_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 && ${COMPILER_VERSION} >= 30700 CFLAGS+= -fno-sanitize=safe-stack .endif CFLAGS+= -fno-stack-protector CFLAGS+= -funwind-tables CXXFLAGS+= -fvisibility-inlines-hidden CXXFLAGS+= -fvisibility=hidden CFLAGS+= -I${CRTSRC}/lib -CXXFLAGS+= -std=c++11 +CXXSTD= c++11 Index: head/lib/libcxxrt/Makefile =================================================================== --- head/lib/libcxxrt/Makefile (revision 345703) +++ head/lib/libcxxrt/Makefile (revision 345704) @@ -1,30 +1,28 @@ # $FreeBSD$ PACKAGE= clibs SRCDIR= ${SRCTOP}/contrib/libcxxrt SHLIB_MAJOR= 1 SHLIBDIR?= /lib .PATH: ${SRCDIR} LIB= cxxrt SRCS+= libelftc_dem_gnu3.c\ terminate.cc\ dynamic_cast.cc\ memory.cc\ auxhelper.cc\ exception.cc\ stdexcept.cc\ typeinfo.cc\ guard.cc WARNS= 0 CFLAGS+= -isystem ${SRCDIR} -nostdinc++ -.if empty(CXXFLAGS:M-std=*) -CXXFLAGS+= -std=c++11 -.endif +CXXSTD= c++11 VERSION_MAP= ${.CURDIR}/Version.map .include Index: head/lib/libgcc_eh/Makefile.inc =================================================================== --- head/lib/libgcc_eh/Makefile.inc (revision 345703) +++ head/lib/libgcc_eh/Makefile.inc (revision 345704) @@ -1,39 +1,37 @@ # $FreeBSD$ COMPILERRTDIR= ${SRCTOP}/contrib/compiler-rt UNWINDINCDIR= ${SRCTOP}/contrib/libunwind/include UNWINDSRCDIR= ${SRCTOP}/contrib/libunwind/src STATIC_CFLAGS+=${PICFLAG} -fvisibility=hidden -DVISIBILITY_HIDDEN .PATH: ${COMPILERRTDIR}/lib/builtins .PATH: ${UNWINDSRCDIR} SRCS_EXC+= gcc_personality_v0.c SRCS_EXC+= int_util.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} .for file in ${SRCS_EXC:M*.c} CFLAGS.${file}+= -fno-exceptions -funwind-tables .endfor .for file in ${SRCS_EXC:M*.cpp} CXXFLAGS.${file}+= -fno-exceptions -funwind-tables .endfor CFLAGS+= -I${UNWINDINCDIR} -I${.CURDIR} -D_LIBUNWIND_IS_NATIVE_ONLY -.if empty(CXXFLAGS:M-std=*) -CXXFLAGS+= -std=c++11 -.endif 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/libc++/include -nostdinc++ .endif Index: head/lib/libomp/Makefile =================================================================== --- head/lib/libomp/Makefile (revision 345703) +++ head/lib/libomp/Makefile (revision 345704) @@ -1,71 +1,71 @@ # $FreeBSD$ SHLIB_NAME= libomp.so OMPSRC= ${SRCTOP}/contrib/openmp/runtime/src ITTSRC= ${OMPSRC}/thirdparty/ittnotify .PATH: ${OMPSRC} .PATH: ${ITTSRC} SRCS+= ittnotify_static.c 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_taskq.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+= -std=c++11 CXXFLAGS+= -fno-exceptions CXXFLAGS+= -fno-rtti +CXXSTD= c++11 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 .include Index: head/lib/ofed/libibnetdisc/Makefile =================================================================== --- head/lib/ofed/libibnetdisc/Makefile (revision 345703) +++ head/lib/ofed/libibnetdisc/Makefile (revision 345704) @@ -1,39 +1,36 @@ # $FreeBSD$ .include _spath= ${SRCTOP}/contrib/ofed/libibnetdisc .PATH: ${_spath} ${_spath}/man SHLIBDIR?= /usr/lib LIB_CXX= ibnetdisc SHLIB_MAJOR= 5 MK_PROFILE= no SRCS= \ chassis.c \ g_hash_table.cpp \ ibnetdisc.c \ ibnetdisc_cache.c \ query_smp.c MAN= \ ibnd_debug.3 \ ibnd_destroy_fabric.3 \ ibnd_discover_fabric.3 \ ibnd_find_node_dr.3 \ ibnd_find_node_guid.3 \ ibnd_iter_nodes.3 \ ibnd_iter_nodes_type.3 \ ibnd_show_progress.3 LIBADD= osmcomp ibmad ibumad CFLAGS+= -DHAVE_CONFIG_H=1 CFLAGS+= -I${_spath} CFLAGS+= -I${SYSROOT:U${DESTDIR}}/${INCLUDEDIR}/infiniband -.if ${COMPILER_FEATURES:Mc++11} -CXXFLAGS+= -std=c++11 -.endif VERSION_MAP= ${_spath}/libibnetdisc.map .include Index: head/share/mk/bsd.progs.mk =================================================================== --- head/share/mk/bsd.progs.mk (revision 345703) +++ head/share/mk/bsd.progs.mk (revision 345704) @@ -1,164 +1,164 @@ # $FreeBSD$ # $Id: progs.mk,v 1.11 2012/11/06 17:18:54 sjg Exp $ # # @(#) Copyright (c) 2006, 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 # .MAIN: all .if defined(PROGS) || defined(PROGS_CXX) # we really only use PROGS below... PROGS += ${PROGS_CXX} .if defined(PROG) # just one of many -PROG_OVERRIDE_VARS += BINDIR BINGRP BINOWN BINMODE DPSRCS MAN NO_WERROR \ - PROGNAME SRCS STRIP WARNS +PROG_OVERRIDE_VARS += BINDIR BINGRP BINOWN BINMODE CSTD CXXSTD DPSRCS MAN \ + NO_WERROR PROGNAME SRCS STRIP WARNS PROG_VARS += CFLAGS CXXFLAGS DEBUG_FLAGS DPADD INTERNALPROG LDADD LIBADD \ LINKS LDFLAGS MLINKS ${PROG_OVERRIDE_VARS} .for v in ${PROG_VARS:O:u} .if empty(${PROG_OVERRIDE_VARS:M$v}) .if defined(${v}.${PROG}) $v += ${${v}.${PROG}} .elif defined(${v}_${PROG}) $v += ${${v}_${PROG}} .endif .else $v ?= .endif .endfor .if ${MK_DIRDEPS_BUILD} == "yes" # Leave updating the Makefile.depend to the parent. UPDATE_DEPENDFILE = NO # Record our meta files for the parent to use. CLEANFILES+= ${PROG}.meta_files ${PROG}.meta_files: .NOMETA $${.MAKE.META.CREATED} ${_this} @echo "Updating ${.TARGET}: ${.OODATE:T:[1..8]}" @echo ${.MAKE.META.FILES} > ${.TARGET} .if !defined(_SKIP_BUILD) .END: ${PROG}.meta_files .endif .endif # ${MK_DIRDEPS_BUILD} == "yes" # prog.mk will do the rest .else # !defined(PROG) .if !defined(_SKIP_BUILD) all: ${PROGS} .endif META_XTRAS+= ${cat ${PROGS:S/$/*.meta_files/} 2>/dev/null || true:L:sh} .if ${MK_STAGING} != "no" && !empty(PROGS) # Stage from parent while respecting PROGNAME and BINDIR overrides. .for _prog in ${PROGS} STAGE_DIR.prog.${_prog}= ${STAGE_OBJTOP}${BINDIR.${_prog}:UBINDIR_${_prog}:U${BINDIR}} STAGE_AS_SETS+= prog.${_prog} STAGE_AS_prog.${_prog}= ${PROGNAME.${_prog}:UPROGNAME_${_prog}:U${_prog}} stage_as.prog.${_prog}: ${_prog} .endfor .endif # ${MK_STAGING} != "no" && !empty(PROGS) .endif .endif # PROGS || PROGS_CXX # These are handled by the main make process. .ifdef _RECURSING_PROGS MK_STAGING= no _PROGS_GLOBAL_VARS= CLEANFILES CLEANDIRS CONFGROUPS DIRS FILESGROUPS INCSGROUPS \ SCRIPTS .for v in ${_PROGS_GLOBAL_VARS} $v = .endfor .endif # handle being called [bsd.]progs.mk .include # Find common sources among the PROGS to depend on them before building # anything. This allows parallelization without them each fighting over # the same objects. _PROGS_COMMON_SRCS= _PROGS_ALL_SRCS= .for p in ${PROGS} .for s in ${SRCS.${p}} .if ${_PROGS_ALL_SRCS:M${s}} && !${_PROGS_COMMON_SRCS:M${s}} _PROGS_COMMON_SRCS+= ${s} .else _PROGS_ALL_SRCS+= ${s} .endif .endfor .endfor .if !empty(_PROGS_COMMON_SRCS) _PROGS_COMMON_OBJS= ${_PROGS_COMMON_SRCS:M*.[dhly]} .if !empty(_PROGS_COMMON_SRCS:N*.[dhly]) _PROGS_COMMON_OBJS+= ${_PROGS_COMMON_SRCS:N*.[dhly]:${OBJS_SRCS_FILTER:ts:}:S/$/.o/g} .endif .endif # When recursing, ensure common sources are not rebuilt in META_MODE. .if defined(_RECURSING_PROGS) && !empty(_PROGS_COMMON_OBJS) && \ !empty(.MAKE.MODE:Mmeta) ${_PROGS_COMMON_OBJS}: .NOMETA .endif .if !empty(PROGS) && !defined(_RECURSING_PROGS) && !defined(PROG) # tell progs.mk we might want to install things PROGS_TARGETS+= checkdpadd clean depend install # Only handle removing depend files from the main process. _PROG_MK.cleandir= CLEANDEPENDFILES= CLEANDEPENDDIRS= _PROG_MK.cleanobj= CLEANDEPENDFILES= CLEANDEPENDDIRS= # Only recurse on these if there is no objdir, meaning a normal # 'clean' gets ran via the target defined in bsd.obj.mk. # Same check from cleanobj: in bsd.obj.mk .if ${CANONICALOBJDIR} == ${.CURDIR} || !exists(${CANONICALOBJDIR}/) PROGS_TARGETS+= cleandir cleanobj .endif # Ensure common objects are built before recursing. .if !empty(_PROGS_COMMON_OBJS) ${PROGS}: ${_PROGS_COMMON_OBJS} .endif .for p in ${PROGS} .if defined(PROGS_CXX) && !empty(PROGS_CXX:M$p) # bsd.prog.mk may need to know this x.$p= PROG_CXX=$p .endif # Main PROG target $p ${p}_p: .PHONY .MAKE (cd ${.CURDIR} && \ DEPENDFILE=.depend.$p \ NO_SUBDIR=1 ${MAKE} -f ${MAKEFILE} _RECURSING_PROGS=t \ PROG=$p ${x.$p}) # Pseudo targets for PROG, such as 'install'. .for t in ${PROGS_TARGETS:O:u} $p.$t: .PHONY .MAKE (cd ${.CURDIR} && \ DEPENDFILE=.depend.$p \ NO_SUBDIR=1 ${MAKE} -f ${MAKEFILE} _RECURSING_PROGS=t \ ${_PROG_MK.${t}} PROG=$p ${x.$p} ${@:E}) .endfor .endfor # Depend main pseudo targets on all PROG.pseudo targets too. .for t in ${PROGS_TARGETS:O:u} .if make(${t}) $t: ${PROGS:%=%.$t} .endif .endfor .endif # !empty(PROGS) && !defined(_RECURSING_PROGS) && !defined(PROG) Index: head/share/mk/bsd.sys.mk =================================================================== --- head/share/mk/bsd.sys.mk (revision 345703) +++ head/share/mk/bsd.sys.mk (revision 345704) @@ -1,376 +1,389 @@ # $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 4.2.1 GCC: http://gcc.gnu.org/onlinedocs/gcc-4.2.1/gcc/Warning-Options.html # for current GCC: https://gcc.gnu.org/onlinedocs/gcc/Warning-Options.html # for clang: https://clang.llvm.org/docs/DiagnosticsReference.html .include # the default is gnu99 for now CSTD?= gnu99 .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 + +.if ${COMPILER_FEATURES:Mc++11} +CXXSTD?= c++11 +.elif ${COMPILER_TYPE} == "gcc" +# Prior versions of g++ support C++98 with GNU extensions by default. +CXXSTD?= gnu++98 +.else +# Assume that the compiler supports at least C++98. +CXXSTD?= c++98 +.endif +CXXFLAGS+= -std=${CXXSTD} +# CXXSTD + # -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 .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 .if ${COMPILER_TYPE} == "clang" && ${COMPILER_VERSION} >= 40000 CWARNFLAGS.clang+= -Wno-address-of-packed-member .endif .if ${COMPILER_TYPE} == "clang" && ${COMPILER_VERSION} >= 70000 && \ ${MACHINE_CPUARCH} == "arm" && !${MACHINE_ARCH:Marmv[67]*} CWARNFLAGS.clang+= -Wno-atomic-alignment .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} # GCC 5.2.0 .if ${COMPILER_TYPE} == "gcc" && ${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=enum-compare \ -Wno-error=extra \ -Wno-error=inline \ -Wno-error=logical-not-parentheses \ -Wno-error=strict-aliasing \ -Wno-error=uninitialized \ -Wno-error=unused-but-set-variable \ -Wno-error=unused-function \ -Wno-error=unused-value .endif # GCC 6.1.0 .if ${COMPILER_TYPE} == "gcc" && ${COMPILER_VERSION} >= 60100 CWARNFLAGS+= -Wno-error=misleading-indentation \ -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_TYPE} == "gcc" && ${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_TYPE} == "gcc" && ${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 .endif # 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" .if (${COMPILER_TYPE} == "clang" && ${COMPILER_VERSION} >= 30500) || \ (${COMPILER_TYPE} == "gcc" && \ (${COMPILER_VERSION} == 40201 || ${COMPILER_VERSION} >= 40900)) # Don't use -Wstack-protector as it breaks world with -Werror. SSP_CFLAGS?= -fstack-protector-strong .else SSP_CFLAGS?= -fstack-protector .endif CFLAGS+= ${SSP_CFLAGS} .endif # SSP && !ARM && !MIPS # Additional flags passed in CFLAGS and CXXFLAGS when MK_DEBUG_FILES is # enabled. DEBUG_FILES_CFLAGS?= -g # 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}} .endif CFLAGS+= ${CFLAGS.${COMPILER_TYPE}} CXXFLAGS+= ${CXXFLAGS.${COMPILER_TYPE}} AFLAGS+= ${AFLAGS.${.IMPSRC:T}} ACFLAGS+= ${ACFLAGS.${.IMPSRC:T}} CFLAGS+= ${CFLAGS.${.IMPSRC:T}} CXXFLAGS+= ${CXXFLAGS.${.IMPSRC:T}} LDFLAGS+= ${LDFLAGS.${LINKER_TYPE}} .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 # 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*)) _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 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 .endif .endif .if defined(META_TARGETS) .for _tgt in ${META_TARGETS} .if target(${_tgt}) ${_tgt}: ${META_DEPS} .endif .endfor .endif Index: head/share/mk/googletest.test.inc.mk =================================================================== --- head/share/mk/googletest.test.inc.mk (revision 345703) +++ head/share/mk/googletest.test.inc.mk (revision 345704) @@ -1,16 +1,12 @@ # $FreeBSD$ -# XXX: this should be defined in bsd.sys.mk -CXXSTD?= c++11 - GTESTS_CXXFLAGS+= -DGTEST_HAS_POSIX_RE=1 GTESTS_CXXFLAGS+= -DGTEST_HAS_PTHREAD=1 GTESTS_CXXFLAGS+= -DGTEST_HAS_STREAM_REDIRECTION=1 GTESTS_CXXFLAGS+= -frtti -GTESTS_CXXFLAGS+= -std=${CXXSTD} # XXX: src.libnames.mk should handle adding this directory for libgtest's, # libgmock's, etc, headers. CXXFLAGS+= -I${DESTDIR}${INCLUDEDIR}/private NO_WTHREAD_SAFETY= Index: head/usr.bin/dtc/Makefile =================================================================== --- head/usr.bin/dtc/Makefile (revision 345703) +++ head/usr.bin/dtc/Makefile (revision 345704) @@ -1,13 +1,13 @@ # $FreeBSD$ PROG_CXX=dtc SRCS= dtc.cc input_buffer.cc string.cc dtb.cc fdt.cc checking.cc MAN= dtc.1 WARNS?= 3 -CXXFLAGS+= -std=c++11 -fno-rtti -fno-exceptions +CXXFLAGS+= -fno-rtti -fno-exceptions NO_SHARED?=NO .include Index: head/usr.sbin/pmc/Makefile =================================================================== --- head/usr.sbin/pmc/Makefile (revision 345703) +++ head/usr.sbin/pmc/Makefile (revision 345704) @@ -1,18 +1,19 @@ # # $FreeBSD$ # .include PROG_CXX= pmc MAN= WARNS?= 3 -CXXFLAGS+= -O0 -std=c++14 +CXXFLAGS+= -O0 +CXXSTD= c++14 CWARNFLAGS.gcc+= -Wno-redundant-decls LIBADD= kvm pmc m ncursesw 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