The branch main has been updated by dim: URL: https://cgit.FreeBSD.org/src/commit/?id=1838bd0f4839006b42d41a02a787b7f578655223
commit 1838bd0f4839006b42d41a02a787b7f578655223 Merge: 1fd87a682ad7 1e9a9d6d0565 Author: Dimitry Andric <[email protected]> AuthorDate: 2022-02-05 22:51:07 +0000 Commit: Dimitry Andric <[email protected]> CommitDate: 2022-05-14 11:45:25 +0000 Merge llvm-project release/14.x llvmorg-14-init-18315-g190be5457c90 This updates llvm, clang, compiler-rt, libc++, libunwind, lld, lldb and openmp to llvmorg-14-init-18315-g190be5457c90. PR: 261742 MFC after: 2 weeks Makefile.inc1 | 9 ++-- .../clang/lib/Driver/ToolChains/Linux.cpp | 2 +- .../sanitizer_platform_limits_posix.cpp | 2 +- .../libcxx/include/__algorithm/in_in_out_result.h | 12 ++++-- .../libcxx/include/__algorithm/in_in_result.h | 10 ++++- .../libcxx/include/__algorithm/in_out_result.h | 2 + .../libcxx/include/__chrono/duration.h | 2 +- .../__compare/compare_partial_order_fallback.h | 4 +- .../__compare/compare_strong_order_fallback.h | 4 +- .../libcxx/include/__compare/compare_three_way.h | 4 +- .../__compare/compare_weak_order_fallback.h | 4 +- .../libcxx/include/__compare/partial_order.h | 4 +- .../libcxx/include/__compare/strong_order.h | 4 +- .../libcxx/include/__compare/synth_three_way.h | 4 +- .../include/__compare/three_way_comparable.h | 4 +- .../libcxx/include/__compare/weak_order.h | 4 +- .../libcxx/include/__concepts/arithmetic.h | 4 +- .../libcxx/include/__concepts/assignable.h | 4 +- .../libcxx/include/__concepts/boolean_testable.h | 4 +- .../libcxx/include/__concepts/class_or_enum.h | 4 +- .../include/__concepts/common_reference_with.h | 4 +- .../libcxx/include/__concepts/common_with.h | 4 +- .../libcxx/include/__concepts/constructible.h | 4 +- .../libcxx/include/__concepts/convertible_to.h | 4 +- .../libcxx/include/__concepts/copyable.h | 4 +- .../libcxx/include/__concepts/derived_from.h | 4 +- .../libcxx/include/__concepts/destructible.h | 4 +- .../libcxx/include/__concepts/different_from.h | 4 +- .../include/__concepts/equality_comparable.h | 4 +- .../libcxx/include/__concepts/invocable.h | 4 +- .../libcxx/include/__concepts/movable.h | 4 +- .../libcxx/include/__concepts/predicate.h | 4 +- .../libcxx/include/__concepts/regular.h | 4 +- .../libcxx/include/__concepts/relation.h | 4 +- .../libcxx/include/__concepts/same_as.h | 4 +- .../libcxx/include/__concepts/semiregular.h | 4 +- .../libcxx/include/__concepts/swappable.h | 4 +- .../libcxx/include/__concepts/totally_ordered.h | 4 +- contrib/llvm-project/libcxx/include/__config | 2 +- .../libcxx/include/__iterator/distance.h | 4 +- .../include/__iterator/indirectly_comparable.h | 4 +- .../libcxx/include/__iterator/insert_iterator.h | 2 +- .../libcxx/include/__iterator/reverse_iterator.h | 2 +- .../__random/uniform_random_bit_generator.h | 4 +- .../llvm-project/libcxx/include/__ranges/access.h | 15 +++++-- .../include/__ranges/enable_borrowed_range.h | 4 +- .../include/__ranges/non_propagating_cache.h | 2 +- .../llvm-project/libcxx/include/__utility/cmp.h | 2 +- .../llvm-project/libcxx/include/__utility/pair.h | 6 +-- .../llvm-project/libcxx/include/module.modulemap | 3 +- contrib/llvm-project/libcxx/include/numbers | 4 +- contrib/llvm-project/libcxx/include/ranges | 4 +- contrib/llvm-project/libcxx/include/string | 15 ------- contrib/llvm-project/libcxx/include/string_view | 8 ++-- contrib/llvm-project/libcxx/include/tuple | 6 +-- contrib/llvm-project/libcxx/include/type_traits | 4 +- contrib/llvm-project/libcxx/src/string.cpp | 21 +++++++--- .../libunwind/src/DwarfInstructions.hpp | 2 - .../llvm/lib/Debuginfod/HTTPClient.cpp | 3 +- .../llvm-project/llvm/lib/ObjectYAML/ELFYAML.cpp | 3 ++ .../llvm/lib/Target/AVR/AVRFrameLowering.cpp | 4 +- .../llvm/lib/Target/PowerPC/PPCISelLowering.cpp | 2 + lib/clang/include/VCSVersion.inc | 10 ++--- lib/clang/include/lld/Common/Version.inc | 5 ++- lib/clang/include/llvm/Support/VCSRevision.h | 2 +- lib/clang/libclang/Makefile | 3 ++ lib/clang/liblldb/LLDBWrapLua.cpp | 11 +---- lib/clang/libllvm/Makefile | 2 +- lib/libgcc_eh/Makefile | 2 + lib/libomp/kmp_config.h | 49 +++++++++++++++++++++- lib/libomp/kmp_i18n_default.inc | 16 +++++-- lib/libomp/kmp_i18n_id.inc | 12 +++++- lib/libomp/omp-tools.h | 1 - lib/libomp/omp.h | 1 - 74 files changed, 240 insertions(+), 163 deletions(-) diff --cc Makefile.inc1 index e3081594ec77,000000000000..5aaa9a414473 mode 100644,000000..100644 --- a/Makefile.inc1 +++ b/Makefile.inc1 @@@ -1,3590 -1,0 +1,3589 @@@ +# +# $FreeBSD$ +# +# Make command line options: +# -DNO_CLEANDIR run ${MAKE} clean, instead of ${MAKE} cleandir +# -DNO_CLEAN do not clean at all +# -DDB_FROM_SRC use the user/group databases in src/etc instead of +# the system database when installing. +# -DNO_SHARE do not go into share subdir +# -DKERNFAST define NO_KERNEL{CONFIG,CLEAN,OBJ} +# -DNO_KERNELCONFIG do not run config in ${MAKE} buildkernel +# -DNO_KERNELCLEAN do not run ${MAKE} clean in ${MAKE} buildkernel +# -DNO_KERNELOBJ do not run ${MAKE} obj in ${MAKE} buildkernel +# -DNO_ROOT install without using root privilege +# -DWITHOUT_CTF do not run the DTrace CTF conversion tools on built objects +# LOCAL_DIRS="list of dirs" to add additional dirs to the SUBDIR list +# LOCAL_ITOOLS="list of tools" to add additional tools to the ITOOLS list +# LOCAL_LIB_DIRS="list of dirs" to add additional dirs to libraries target +# LOCAL_MTREE="list of mtree files" to process to allow local directories +# to be created before files are installed +# LOCAL_LEGACY_DIRS="list of dirs" to add additional dirs to the legacy +# target +# LOCAL_BSTOOL_DIRS="list of dirs" to add additional dirs to the +# bootstrap-tools target +# LOCAL_TOOL_DIRS="list of dirs" to add additional dirs to the build-tools +# target +# LOCAL_XTOOL_DIRS="list of dirs" to add additional dirs to the +# cross-tools target +# METALOG="path to metadata log" to write permission and ownership +# when NO_ROOT is set. (default: ${DESTDIR}/${DISTDIR}/METALOG, +# check /etc/make.conf for DISTDIR) +# TARGET="machine" to crossbuild world for a different machine type +# TARGET_ARCH= may be required when a TARGET supports multiple endians +# BUILDENV_SHELL= shell to launch for the buildenv target (def:${SHELL}) +# WORLD_FLAGS= additional flags to pass to make(1) during buildworld +# KERNEL_FLAGS= additional flags to pass to make(1) during buildkernel +# SUBDIR_OVERRIDE="list of dirs" to build rather than everything. +# All libraries and includes, and some build tools will still build. + +# +# The intended user-driven targets are: +# buildworld - rebuild *everything*, including glue to help do upgrades +# installworld- install everything built by "buildworld" +# checkworld - run test suite on installed world +# doxygen - build API documentation of the kernel +# +# Standard targets (not defined here) are documented in the makefiles in +# /usr/share/mk. These include: +# obj depend all install clean cleandepend cleanobj + +.if !defined(TARGET) || !defined(TARGET_ARCH) +.error Both TARGET and TARGET_ARCH must be defined. +.endif + +.if make(showconfig) || make(test-system-*) +_MKSHOWCONFIG= t +.endif + +SRCDIR?= ${.CURDIR} +LOCALBASE?= /usr/local +TIME_ENV ?= time env + +.include "share/mk/src.tools.mk" + +# Cross toolchain changes must be in effect before bsd.compiler.mk +# so that gets the right CC, and pass CROSS_TOOLCHAIN to submakes. +.if defined(CROSS_TOOLCHAIN) +.if exists(${LOCALBASE}/share/toolchains/${CROSS_TOOLCHAIN}.mk) +.include "${LOCALBASE}/share/toolchains/${CROSS_TOOLCHAIN}.mk" +.elif exists(/usr/share/toolchains/${CROSS_TOOLCHAIN}.mk) +.include "/usr/share/toolchains/${CROSS_TOOLCHAIN}.mk" +.elif exists(${CROSS_TOOLCHAIN}) +.include "${CROSS_TOOLCHAIN}" +.else +.error CROSS_TOOLCHAIN ${CROSS_TOOLCHAIN} not found +.endif +CROSSENV+=CROSS_TOOLCHAIN="${CROSS_TOOLCHAIN}" +.endif +.if defined(CROSS_TOOLCHAIN_PREFIX) +CROSS_COMPILER_PREFIX?=${CROSS_TOOLCHAIN_PREFIX} +.endif + +XCOMPILERS= CC CXX CPP +.for COMPILER in ${XCOMPILERS} +.if defined(CROSS_COMPILER_PREFIX) +X${COMPILER}?= ${CROSS_COMPILER_PREFIX}${${COMPILER}} +.else +X${COMPILER}?= ${${COMPILER}} +.endif +.endfor +# If a full path to an external cross compiler is given, don't build +# a cross compiler. +.if ${XCC:N${CCACHE_BIN}:M/*} +MK_CLANG_BOOTSTRAP= no +# Make sure sub-makes see the option as disabled so the hack in bsd.sys.mk to +# work around incompatible headers in Clang's resource directory is enabled. +.MAKEOVERRIDES+= MK_CLANG_BOOTSTRAP +.endif + +# Pull in compiler metadata from buildworld/toolchain if possible to avoid +# running CC from bsd.compiler.mk. +.if make(installworld) || make(install) || make(distributeworld) || \ + make(stageworld) +.-include "${OBJTOP}/toolchain-metadata.mk" +.if !defined(_LOADED_TOOLCHAIN_METADATA) +.error A build is required first. You may have the wrong MAKEOBJDIRPREFIX set. +.endif +.endif + +# Pull in COMPILER_TYPE and COMPILER_FREEBSD_VERSION early. Pull it from the +# tree to be friendlier to foreign OS builds. It's safe to do so unconditionally +# here since we will always have the right make, unlike in src/Makefile +# Don't include bsd.linker.mk yet until XBINUTILS is handled (after src.opts.mk) +_NO_INCLUDE_LINKERMK= t +# We also want the X_COMPILER* variables if we are using an external toolchain. +_WANT_TOOLCHAIN_CROSS_VARS= t +.include "share/mk/bsd.compiler.mk" +.undef _NO_INCLUDE_LINKERMK +.undef _WANT_TOOLCHAIN_CROSS_VARS +# src.opts.mk depends on COMPILER_FEATURES +.include "share/mk/src.opts.mk" + +.if ${TARGET} == ${MACHINE} +TARGET_CPUTYPE?=${CPUTYPE} +.else +TARGET_CPUTYPE?= +.endif +.if !empty(TARGET_CPUTYPE) +_TARGET_CPUTYPE=${TARGET_CPUTYPE} +.else +_TARGET_CPUTYPE=dummy +.endif +.if ${TARGET} == "arm" +.if ${TARGET_ARCH:Marmv[67]*} != "" && ${TARGET_CPUTYPE:M*soft*} == "" +TARGET_ABI= gnueabihf +.else +TARGET_ABI= gnueabi +.endif +.endif +MACHINE_ABI?= unknown +MACHINE_TRIPLE?=${MACHINE_ARCH:S/amd64/x86_64/:C/sf$//}-${MACHINE_ABI}-freebsd${OS_REVISION} +TARGET_ABI?= unknown +TARGET_TRIPLE?= ${TARGET_ARCH:S/amd64/x86_64/:C/sf$//}-${TARGET_ABI}-freebsd${OS_REVISION} +KNOWN_ARCHES?= aarch64/arm64 \ + amd64 \ + armv6/arm \ + armv7/arm \ + i386 \ + powerpc \ + powerpc64/powerpc \ + powerpc64le/powerpc \ + powerpcspe/powerpc \ + riscv64/riscv \ + riscv64sf/riscv + +.if ${TARGET} == ${TARGET_ARCH} +_t= ${TARGET} +.else +_t= ${TARGET_ARCH}/${TARGET} +.endif +.for _t in ${_t} +.if empty(KNOWN_ARCHES:M${_t}) +.error Unknown target ${TARGET_ARCH}:${TARGET}. +.endif +.endfor + +.if ${.MAKE.OS} != "FreeBSD" +CROSSBUILD_HOST=${.MAKE.OS} +.if ${.MAKE.OS} != "Linux" && ${.MAKE.OS} != "Darwin" +.warning Unsupported crossbuild system: ${.MAKE.OS}. Build will probably fail! +.endif +# We need to force NO_ROOT/DB_FROM_SRC builds when building on other operating +# systems since the BSD.foo.dist specs contain users and groups that do not +# exist by default on a Linux/MacOS system. +NO_ROOT:= 1 +DB_FROM_SRC:= 1 +.export NO_ROOT +.endif + +# If all targets are disabled for system llvm then don't expect it to work +# for cross-builds. +.if !defined(TOOLS_PREFIX) && ${MK_LLVM_TARGET_ALL} == "no" && \ + ${MACHINE} != ${TARGET} && ${MACHINE_ARCH} != ${TARGET_ARCH} && \ + !make(showconfig) +MK_SYSTEM_COMPILER= no +MK_SYSTEM_LINKER= no +.endif + +# Handle external binutils. +.if defined(CROSS_TOOLCHAIN_PREFIX) +CROSS_BINUTILS_PREFIX?=${CROSS_TOOLCHAIN_PREFIX} +.endif +XBINUTILS= AS AR ELFCTL LD NM OBJCOPY RANLIB SIZE STRINGS STRIPBIN +.for BINUTIL in ${XBINUTILS} +.if defined(CROSS_BINUTILS_PREFIX) && \ + exists(${CROSS_BINUTILS_PREFIX}/${${BINUTIL}}) +X${BINUTIL}?= ${CROSS_BINUTILS_PREFIX:C,/*$,,}/${${BINUTIL}} +.else +X${BINUTIL}?= ${${BINUTIL}} +.endif +.endfor + +# If a full path to an external linker is given, don't build lld. +.if ${XLD:M/*} +MK_LLD_BOOTSTRAP= no +.endif + +# We also want the X_LINKER* variables if we are using an external toolchain. +_WANT_TOOLCHAIN_CROSS_VARS= t +.include "share/mk/bsd.linker.mk" +.undef _WANT_TOOLCHAIN_CROSS_VARS + +# Begin WITH_SYSTEM_COMPILER / WITH_SYSTEM_LD + +# WITH_SYSTEM_COMPILER - Pull in needed values and make a decision. + +# Check if there is a local compiler that can satisfy as an external compiler. +# Which compiler is expected to be used? +.if ${MK_CLANG_BOOTSTRAP} == "yes" +WANT_COMPILER_TYPE= clang +.else +WANT_COMPILER_TYPE= +.endif + +.if !defined(WANT_COMPILER_FREEBSD_VERSION) && !make(showconfig) && \ + !make(test-system-linker) +.if ${WANT_COMPILER_TYPE} == "clang" +WANT_COMPILER_FREEBSD_VERSION_FILE= lib/clang/freebsd_cc_version.h +WANT_COMPILER_FREEBSD_VERSION!= \ + awk '$$2 == "FREEBSD_CC_VERSION" {printf("%d\n", $$3)}' \ + ${SRCDIR}/${WANT_COMPILER_FREEBSD_VERSION_FILE} || echo unknown +WANT_COMPILER_VERSION_FILE= lib/clang/include/clang/Basic/Version.inc +WANT_COMPILER_VERSION!= \ + awk '$$2 == "CLANG_VERSION" {split($$3, a, "."); print a[1] * 10000 + a[2] * 100 + a[3]}' \ + ${SRCDIR}/${WANT_COMPILER_VERSION_FILE} || echo unknown +.endif +.export WANT_COMPILER_FREEBSD_VERSION WANT_COMPILER_VERSION +.endif # !defined(WANT_COMPILER_FREEBSD_VERSION) + +# It needs to be the same revision as we would build for the bootstrap. +# If the expected vs CC is different then we can't skip. +# GCC cannot be used for cross-arch yet. For clang we pass -target later if +# TARGET_ARCH!=MACHINE_ARCH. +.if ${MK_SYSTEM_COMPILER} == "yes" && \ + defined(WANT_COMPILER_FREEBSD_VERSION) && \ + ${MK_CLANG_BOOTSTRAP} == "yes" && \ + !make(xdev*) && \ + ${X_COMPILER_TYPE} == ${WANT_COMPILER_TYPE} && \ + (${X_COMPILER_TYPE} == "clang" || ${TARGET_ARCH} == ${MACHINE_ARCH}) && \ + ${X_COMPILER_VERSION} == ${WANT_COMPILER_VERSION} && \ + ${X_COMPILER_FREEBSD_VERSION} == ${WANT_COMPILER_FREEBSD_VERSION} +# Everything matches, disable the bootstrap compiler. +MK_CLANG_BOOTSTRAP= no +USING_SYSTEM_COMPILER= yes +.endif # ${WANT_COMPILER_TYPE} == ${COMPILER_TYPE} + +# WITH_SYSTEM_LD - Pull in needed values and make a decision. + +# Check if there is a local linker that can satisfy as an external linker. +# Which linker is expected to be used? +.if ${MK_LLD_BOOTSTRAP} == "yes" +WANT_LINKER_TYPE= lld +.else +WANT_LINKER_TYPE= +.endif + +.if !defined(WANT_LINKER_FREEBSD_VERSION) && !make(showconfig) && \ + !make(test-system-compiler) +.if ${WANT_LINKER_TYPE} == "lld" - WANT_LINKER_FREEBSD_VERSION_FILE= lib/clang/include/VCSVersion.inc - _WANT_LINKER_FREEBSD_VERSION!= \ - awk '$$2 == "LLD_REVISION" {gsub(/"/, "", $$3); print $$3}' \ ++WANT_LINKER_FREEBSD_VERSION_FILE= lib/clang/include/lld/Common/Version.inc ++WANT_LINKER_FREEBSD_VERSION!= \ ++ awk '$$2 == "LLD_FREEBSD_VERSION" {print $$3}' \ + ${SRCDIR}/${WANT_LINKER_FREEBSD_VERSION_FILE} || echo unknown - WANT_LINKER_FREEBSD_VERSION=${_WANT_LINKER_FREEBSD_VERSION:C/.*-(.*)/\1/} +WANT_LINKER_VERSION_FILE= lib/clang/include/lld/Common/Version.inc +WANT_LINKER_VERSION!= \ - awk '$$2 == "LLD_VERSION_STRING" { gsub("\"", "", $$3); split($$3, a, "."); print a[1] * 10000 + a[2] * 100 + a[3]}' \ ++ awk '$$2 == "LLD_VERSION_STRING" {gsub("\"", "", $$3); split($$3, a, "."); print a[1] * 10000 + a[2] * 100 + a[3]}' \ + ${SRCDIR}/${WANT_LINKER_VERSION_FILE} || echo unknown +.else +WANT_LINKER_FREEBSD_VERSION_FILE= +WANT_LINKER_FREEBSD_VERSION= +.endif +.export WANT_LINKER_FREEBSD_VERSION WANT_LINKER_VERSION +.endif # !defined(WANT_LINKER_FREEBSD_VERSION) + +.if ${MK_SYSTEM_LINKER} == "yes" && \ + defined(WANT_LINKER_FREEBSD_VERSION) && \ + (${MK_LLD_BOOTSTRAP} == "yes") && \ + !make(xdev*) && \ + ${X_LINKER_TYPE} == ${WANT_LINKER_TYPE} && \ + ${X_LINKER_VERSION} == ${WANT_LINKER_VERSION} && \ + ${X_LINKER_FREEBSD_VERSION} == ${WANT_LINKER_FREEBSD_VERSION} +# Everything matches, disable the bootstrap linker. +MK_LLD_BOOTSTRAP= no +USING_SYSTEM_LINKER= yes +.endif # ${WANT_LINKER_TYPE} == ${LINKER_TYPE} + +# WITH_SYSTEM_COMPILER / WITH_SYSTEM_LINKER - Handle defaults and debug. +USING_SYSTEM_COMPILER?= no +USING_SYSTEM_LINKER?= no + +TEST_SYSTEM_COMPILER_VARS= \ + USING_SYSTEM_COMPILER MK_SYSTEM_COMPILER \ + MK_CROSS_COMPILER MK_CLANG_BOOTSTRAP \ + WANT_COMPILER_TYPE WANT_COMPILER_VERSION WANT_COMPILER_VERSION_FILE \ + WANT_COMPILER_FREEBSD_VERSION WANT_COMPILER_FREEBSD_VERSION_FILE \ + CC COMPILER_TYPE COMPILER_FEATURES COMPILER_VERSION \ + COMPILER_FREEBSD_VERSION \ + XCC X_COMPILER_TYPE X_COMPILER_FEATURES X_COMPILER_VERSION \ + X_COMPILER_FREEBSD_VERSION +TEST_SYSTEM_LINKER_VARS= \ + USING_SYSTEM_LINKER MK_SYSTEM_LINKER \ + MK_LLD_BOOTSTRAP \ + WANT_LINKER_TYPE WANT_LINKER_VERSION WANT_LINKER_VERSION_FILE \ + WANT_LINKER_FREEBSD_VERSION WANT_LINKER_FREEBSD_VERSION_FILE \ + LD LINKER_TYPE LINKER_FEATURES LINKER_VERSION \ + LINKER_FREEBSD_VERSION \ + XLD X_LINKER_TYPE X_LINKER_FEATURES X_LINKER_VERSION \ + X_LINKER_FREEBSD_VERSION + +.for _t in compiler linker +test-system-${_t}: .PHONY +.for v in ${TEST_SYSTEM_${_t:tu}_VARS} + ${_+_}@printf "%-35s= %s\n" "${v}" "${${v}}" +.endfor +.endfor +.if (make(buildworld) || make(buildkernel) || make(kernel-toolchain) || \ + make(toolchain) || make(_cross-tools)) +.if ${USING_SYSTEM_COMPILER} == "yes" +.info SYSTEM_COMPILER: Determined that CC=${CC} matches the source tree. Not bootstrapping a cross-compiler. +.elif ${MK_CLANG_BOOTSTRAP} == "yes" +.info SYSTEM_COMPILER: libclang will be built for bootstrapping a cross-compiler. +.endif +.if ${USING_SYSTEM_LINKER} == "yes" +.info SYSTEM_LINKER: Determined that LD=${LD} matches the source tree. Not bootstrapping a cross-linker. +.elif ${MK_LLD_BOOTSTRAP} == "yes" +.info SYSTEM_LINKER: libclang will be built for bootstrapping a cross-linker. +.endif +.endif + +# End WITH_SYSTEM_COMPILER / WITH_SYSTEM_LD + +# Store some compiler metadata for use in installworld where we don't +# want to invoke CC at all. +_TOOLCHAIN_METADATA_VARS= COMPILER_VERSION \ + COMPILER_TYPE \ + COMPILER_FEATURES \ + COMPILER_FREEBSD_VERSION \ + COMPILER_RESOURCE_DIR \ + LINKER_VERSION \ + LINKER_FEATURES \ + LINKER_TYPE \ + LINKER_FREEBSD_VERSION +toolchain-metadata.mk: .PHONY .META + @: > ${.TARGET} + @echo ".info Using cached toolchain metadata from build at $$(hostname) on $$(date)" \ + > ${.TARGET} + @echo "_LOADED_TOOLCHAIN_METADATA=t" >> ${.TARGET} +.for v in ${_TOOLCHAIN_METADATA_VARS} + @echo "${v}=${${v}}" >> ${.TARGET} + @echo "X_${v}=${X_${v}}" >> ${.TARGET} +.endfor + @echo ".export ${_TOOLCHAIN_METADATA_VARS}" >> ${.TARGET} + @echo ".export ${_TOOLCHAIN_METADATA_VARS:C,^,X_,}" >> ${.TARGET} + + +# We must do lib/ and libexec/ before bin/ in case of a mid-install error to +# keep the users system reasonably usable. For static->dynamic root upgrades, +# we don't want to install a dynamic binary without rtld and the needed +# libraries. More commonly, for dynamic root, we don't want to install a +# binary that requires a newer library version that hasn't been installed yet. +# This ordering is not a guarantee though. The only guarantee of a working +# system here would require fine-grained ordering of all components based +# on their dependencies. +.if !empty(SUBDIR_OVERRIDE) +SUBDIR= ${SUBDIR_OVERRIDE} +.else +SUBDIR= lib libexec +# Add LOCAL_LIB_DIRS, but only if they will not be picked up as a SUBDIR +# of a LOCAL_DIRS directory. This allows LOCAL_DIRS=foo and +# LOCAL_LIB_DIRS=foo/lib to behave as expected. +.for _DIR in ${LOCAL_DIRS:M*/} ${LOCAL_DIRS:N*/:S|$|/|} +_REDUNDANT_LIB_DIRS+= ${LOCAL_LIB_DIRS:M${_DIR}*} +.endfor +.for _DIR in ${LOCAL_LIB_DIRS} +.if ${_DIR} == ".WAIT" || (empty(_REDUNDANT_LIB_DIRS:M${_DIR}) && exists(${.CURDIR}/${_DIR}/Makefile)) +SUBDIR+= ${_DIR} +.endif +.endfor +.if !defined(NO_ROOT) && (make(installworld) || make(install)) +# Ensure libraries are installed before progressing. +SUBDIR+=.WAIT +.endif +SUBDIR+=bin +.if ${MK_CDDL} != "no" +SUBDIR+=cddl +.endif +SUBDIR+=gnu include +.if ${MK_KERBEROS} != "no" +SUBDIR+=kerberos5 +.endif +.if ${MK_RESCUE} != "no" +SUBDIR+=rescue +.endif +SUBDIR+=sbin +.if ${MK_CRYPT} != "no" +SUBDIR+=secure +.endif +.if !defined(NO_SHARE) +SUBDIR+=share +.endif +.if ${MK_BOOT} != "no" +SUBDIR+=stand +.endif +SUBDIR+=sys usr.bin usr.sbin +.if ${MK_TESTS} != "no" +SUBDIR+= tests +.endif + +# Local directories are built in parallel with the base system directories. +# Users may insert a .WAIT directive at the beginning or elsewhere within +# the LOCAL_DIRS and LOCAL_LIB_DIRS lists as needed. +.for _DIR in ${LOCAL_DIRS} +.if ${_DIR} == ".WAIT" || exists(${.CURDIR}/${_DIR}/Makefile) +SUBDIR+= ${_DIR} +.endif +.endfor + +# We must do etc/ last as it hooks into building the man whatis file +# by calling 'makedb' in share/man. This is only relevant for +# install/distribute so they build the whatis file after every manpage is +# installed. +.if make(installworld) || make(install) +SUBDIR+=.WAIT +.endif +SUBDIR+=etc + +.endif # !empty(SUBDIR_OVERRIDE) + +.if defined(NOCLEAN) +.warning The src.conf WITHOUT_CLEAN option can now be used instead of NOCLEAN. +MK_CLEAN:= no +.endif +.if defined(NO_CLEAN) +.info The src.conf WITHOUT_CLEAN option can now be used instead of NO_CLEAN. +MK_CLEAN:= no +.endif +.if defined(NO_CLEANDIR) +CLEANDIR= clean cleandepend +.else +CLEANDIR= cleandir +.endif + +.if defined(WORLDFAST) +MK_CLEAN:= no +NO_OBJWALK= t +.endif + +.if ${MK_META_MODE} == "yes" +# If filemon is used then we can rely on the build being incremental-safe. +# The .meta files will also track the build command and rebuild should +# it change. +.if empty(.MAKE.MODE:Mnofilemon) +MK_CLEAN:= no +.endif +.endif +.if defined(NO_OBJWALK) || ${MK_AUTO_OBJ} == "yes" +NO_OBJWALK= t +NO_KERNELOBJ= t +.endif +.if !defined(NO_OBJWALK) +_obj= obj +.endif + +LOCAL_TOOL_DIRS?= +PACKAGEDIR?= ${DESTDIR}/${DISTDIR} + +.if empty(SHELL:M*csh*) +BUILDENV_SHELL?=${SHELL} +.else +BUILDENV_SHELL?=/bin/sh +.endif + +.if !defined(_MKSHOWCONFIG) +.if !defined(VCS_REVISION) || empty(VCS_REVISION) +.if !defined(SVNVERSION_CMD) || empty(SVNVERSION_CMD) +. for _D in ${PATH:S,:, ,g} +. if exists(${_D}/svnversion) +SVNVERSION_CMD?=${_D}/svnversion +. endif +. if exists(${_D}/svnliteversion) +SVNVERSION_CMD?=${_D}/svnliteversion +. endif +. endfor +.endif +.if defined(SVNVERSION_CMD) && !empty(SVNVERSION_CMD) +_VCS_REVISION?= $$(eval ${SVNVERSION_CMD} ${SRCDIR}) +. if !empty(_VCS_REVISION) +VCS_REVISION= $$(echo r${_VCS_REVISION}) +.export VCS_REVISION +. endif +.endif +.endif + +.if !defined(GIT_CMD) || empty(GIT_CMD) +. for _P in /usr/bin /usr/local/bin +. if exists(${_P}/git) +GIT_CMD= ${_P}/git +. endif +. endfor +.export GIT_CMD +.endif + +.if !defined(OSRELDATE) +.if exists(/usr/include/osreldate.h) +OSRELDATE!= awk '/^\#define[[:space:]]*__FreeBSD_version/ { print $$3 }' \ + /usr/include/osreldate.h +.else +OSRELDATE= 0 +.endif +.export OSRELDATE +.endif + +# Set VERSION for CTFMERGE to use via the default CTFFLAGS=-L VERSION. +.for _V in BRANCH REVISION TYPE +.if !defined(_${_V}) +_${_V}!= eval $$(awk '/^${_V}=/{print}' ${SRCTOP}/sys/conf/newvers.sh); echo $$${_V} +.export _${_V} +.endif +.endfor +.if !defined(SRCRELDATE) +SRCRELDATE!= awk '/^\#define[[:space:]]*__FreeBSD_version/ { print $$3 }' \ + ${SRCDIR}/sys/sys/param.h +.export SRCRELDATE +.endif +.if !defined(VERSION) +VERSION= FreeBSD ${_REVISION}-${_BRANCH:C/-p[0-9]+$//} ${TARGET_ARCH} ${SRCRELDATE} +.export VERSION +.endif + +.if !defined(PKG_VERSION) +_STRTIMENOW= %Y%m%d%H%M%S +_TIMENOW= ${_STRTIMENOW:gmtime} +.if ${_BRANCH:MCURRENT*} || ${_BRANCH:MSTABLE*} || ${_BRANCH:MPRERELEASE*} +_REVISION:= ${_REVISION:R} +EXTRA_REVISION= .snap${_TIMENOW} +.elif ${_BRANCH:MALPHA*} +EXTRA_REVISION= .a${_BRANCH:C/ALPHA([0-9]+).*/\1/}.${_TIMENOW} +.elif ${_BRANCH:MBETA*} +EXTRA_REVISION= .b${_BRANCH:C/BETA([0-9]+).*/\1/}.${_TIMENOW} +.elif ${_BRANCH:MRC*} +EXTRA_REVISION= .rc${_BRANCH:C/RC([0-9]+).*/\1/}.${_TIMENOW} +.elif ${_BRANCH:M*-p*} +EXTRA_REVISION= p${_BRANCH:C/.*-p([0-9]+$)/\1/} +.endif +PKG_VERSION:= ${_REVISION}${EXTRA_REVISION:C/[[:space:]]//g} +.endif +.endif # !defined(PKG_VERSION) + +.if !defined(PKG_TIMESTAMP) +TIMEEPOCHNOW= %s +SOURCE_DATE_EPOCH= ${TIMEEPOCHNOW:gmtime} +.else +SOURCE_DATE_EPOCH= ${PKG_TIMESTAMP} +.endif + +PKG_NAME_PREFIX?= FreeBSD +PKG_MAINTAINER?= [email protected] +PKG_WWW?= https://www.FreeBSD.org +.export PKG_NAME_PREFIX +.export PKG_MAINTAINER +.export PKG_WWW + +.if !defined(_MKSHOWCONFIG) +_CPUTYPE!= MAKEFLAGS= CPUTYPE=${_TARGET_CPUTYPE} ${MAKE} -f /dev/null \ + -m ${.CURDIR}/share/mk MK_AUTO_OBJ=no -V CPUTYPE +.if ${_CPUTYPE} != ${_TARGET_CPUTYPE} +.error CPUTYPE global should be set with ?=. +.endif +.endif +.if make(buildworld) +BUILD_ARCH!= uname -p +# On some Linux systems uname -p returns "unknown" so skip this check there. +# This check only exists to tell people to use TARGET_ARCH instead of +# MACHINE_ARCH so skipping it when crossbuilding on non-FreeBSD should be fine. +.if ${MACHINE_ARCH} != ${BUILD_ARCH} && ${.MAKE.OS} == "FreeBSD" +.error To cross-build, set TARGET_ARCH. +.endif +.endif +WORLDTMP?= ${OBJTOP}/tmp +BPATH= ${CCACHE_WRAPPER_PATH_PFX}${WORLDTMP}/legacy/usr/sbin:${WORLDTMP}/legacy/usr/bin:${WORLDTMP}/legacy/bin:${WORLDTMP}/legacy/usr/libexec +XPATH= ${WORLDTMP}/bin:${WORLDTMP}/usr/sbin:${WORLDTMP}/usr/bin + +# When building we want to find the cross tools before the host tools in ${BPATH}. +# We also need to add UNIVERSE_TOOLCHAIN_PATH so that we can find the shared +# toolchain files (clang, lld, etc.) during make universe/tinderbox +STRICTTMPPATH= ${XPATH}:${BPATH}:${UNIVERSE_TOOLCHAIN_PATH} +# We should not be using tools from /usr/bin accidentally since this could cause +# the build to break on other systems that don't have that tool. For now we +# still allow using the old behaviour (inheriting $PATH) if +# BUILD_WITH_STRICT_TMPPATH is set to 0 but this will eventually be removed. + +# Currently strict $PATH can cause build failures and does not work yet with +# USING_SYSTEM_LINKER/USING_SYSTEM_COMPILER. Once these issues have been +# resolved it will be turned on by default. +BUILD_WITH_STRICT_TMPPATH?=0 +.if defined(CROSSBUILD_HOST) +# When building on non-FreeBSD we can't rely on the tools in /usr/bin being compatible +# with what FreeBSD expects. Therefore we only use tools from STRICTTMPPATH +# during the world build stage. We build most tools during the bootstrap-tools +# phase but symlink host tools that are known to work instead of building them +BUILD_WITH_STRICT_TMPPATH:=1 +.endif +.if ${BUILD_WITH_STRICT_TMPPATH} != 0 +TMPPATH= ${STRICTTMPPATH} +.else +TMPPATH= ${STRICTTMPPATH}:${PATH} +.endif + +# +# Avoid running mktemp(1) unless actually needed. +# It may not be functional, e.g., due to new ABI +# when in the middle of installing over this system. +# +.if make(distributeworld) || make(installworld) || make(stageworld) +.if ${BUILD_WITH_STRICT_TMPPATH} != 0 +MKTEMP=${WORLDTMP}/legacy/usr/bin/mktemp +.if !exists(${MKTEMP}) +.error mktemp binary doesn't exist in expected location: ${MKTEMP} +.endif +.else +MKTEMP=mktemp +.endif +INSTALLTMP!= ${MKTEMP} -d -u -t install +.endif + +.if make(stagekernel) || make(distributekernel) +TAGS+= kernel +PACKAGE= kernel +.endif + +# +# Building a world goes through the following stages +# +# 1. legacy stage [BMAKE] +# This stage is responsible for creating compatibility +# shims that are needed by the bootstrap-tools, +# build-tools and cross-tools stages. These are generally +# APIs that tools from one of those three stages need to +# build that aren't present on the host. +# 1. bootstrap-tools stage [BMAKE] +# This stage is responsible for creating programs that +# are needed for backward compatibility reasons. They +# are not built as cross-tools. +# 2. build-tools stage [TMAKE] +# This stage is responsible for creating the object +# tree and building any tools that are needed during +# the build process. Some programs are listed during +# this phase because they build binaries to generate +# files needed to build these programs. This stage also +# builds the 'build-tools' target rather than 'all'. +# 3. cross-tools stage [XMAKE] +# This stage is responsible for creating any tools that +# are needed for building the system. A cross-compiler is one +# of them. This differs from build tools in two ways: +# 1. the 'all' target is built rather than 'build-tools' +# 2. these tools are installed into TMPPATH for stage 4. +# 4. world stage [WMAKE] +# This stage actually builds the world. +# 5. install stage (optional) [IMAKE] +# This stage installs a previously built world. +# + +BOOTSTRAPPING?= 0 +# Keep these in sync +MINIMUM_SUPPORTED_OSREL?= 1104001 +MINIMUM_SUPPORTED_REL?= 11.4 + +# Common environment for world related stages +CROSSENV+= \ + MACHINE_ARCH=${TARGET_ARCH} \ + MACHINE=${TARGET} \ + CPUTYPE=${TARGET_CPUTYPE} +.if ${MK_META_MODE} != "no" +# Don't rebuild build-tools targets during normal build. +CROSSENV+= BUILD_TOOLS_META=.NOMETA +.endif +.if defined(TARGET_CFLAGS) +CROSSENV+= ${TARGET_CFLAGS} +.endif +.if (${TARGET} != ${MACHINE} && !defined(WITH_LOCAL_MODULES)) || \ + defined(WITHOUT_LOCAL_MODULES) +CROSSENV+= LOCAL_MODULES= +.endif + +BOOTSTRAPPING_OSRELDATE?=${OSRELDATE} + +# bootstrap-tools stage +BMAKEENV= INSTALL="sh ${.CURDIR}/tools/install.sh" \ + TOOLS_PREFIX=${TOOLS_PREFIX_UNDEF:U${WORLDTMP}} \ + PATH=${BPATH}:${PATH} \ + WORLDTMP=${WORLDTMP} \ + MAKEFLAGS="-m ${.CURDIR}/tools/build/mk ${.MAKEFLAGS}" +# need to keep this in sync with targets/pseudo/bootstrap-tools/Makefile +BSARGS= DESTDIR= \ + OBJTOP='${WORLDTMP}/obj-tools' \ + OBJROOT='$${OBJTOP}/' \ + MAKEOBJDIRPREFIX= \ + BOOTSTRAPPING=${BOOTSTRAPPING_OSRELDATE} \ + BWPHASE=${.TARGET:C,^_,,} \ + -DNO_CPU_CFLAGS \ + -DNO_LINT \ + -DNO_PIC \ + -DNO_SHARED \ + MK_ASAN=no \ + MK_CTF=no \ + MK_CLANG_EXTRAS=no \ + MK_CLANG_FORMAT=no \ + MK_CLANG_FULL=no \ + MK_HTML=no \ + MK_MAN=no \ + MK_PROFILE=no \ + MK_RETPOLINE=no \ + MK_SSP=no \ + MK_TESTS=no \ + MK_UBSAN=no \ + MK_WERROR=no \ + MK_INCLUDES=yes \ + MK_MAN_UTILS=yes + +BMAKE= \ + ${TIME_ENV} ${BMAKEENV} ${MAKE} ${WORLD_FLAGS} -f Makefile.inc1 \ + ${BSARGS} +.if empty(.MAKEOVERRIDES:MMK_LLVM_TARGET_ALL) +BMAKE+= MK_LLVM_TARGET_ALL=no +.endif + +# build-tools stage +TMAKE= \ + ${TIME_ENV} ${BMAKEENV} ${MAKE} ${WORLD_FLAGS} -f Makefile.inc1 \ + TARGET=${TARGET} TARGET_ARCH=${TARGET_ARCH} \ + DESTDIR= \ + BOOTSTRAPPING=${BOOTSTRAPPING_OSRELDATE} \ + BWPHASE=${.TARGET:C,^_,,} \ + -DNO_CPU_CFLAGS \ + -DNO_LINT \ + MK_ASAN=no \ + MK_CTF=no \ + MK_CLANG_EXTRAS=no \ + MK_CLANG_FORMAT=no \ + MK_CLANG_FULL=no \ + MK_LLDB=no \ + MK_RETPOLINE=no \ + MK_SSP=no \ + MK_TESTS=no \ + MK_UBSAN=no \ + MK_WERROR=no + +# cross-tools stage +# TOOLS_PREFIX set in BMAKE +XMAKE= ${BMAKE} \ + TARGET=${TARGET} TARGET_ARCH=${TARGET_ARCH} \ + MK_CLANG_IS_CC=${MK_CLANG_BOOTSTRAP} \ + MK_LLDB=no \ + MK_LLVM_BINUTILS=no \ + MK_TESTS=no + +# kernel-tools stage +KTMAKEENV= INSTALL="sh ${.CURDIR}/tools/install.sh" \ + PATH=${BPATH}:${PATH} \ + WORLDTMP=${WORLDTMP} \ + MAKEFLAGS="-m ${.CURDIR}/tools/build/mk ${.MAKEFLAGS}" + +KTMAKE= ${TIME_ENV} \ + TOOLS_PREFIX=${TOOLS_PREFIX_UNDEF:U${WORLDTMP}} \ + ${KTMAKEENV} ${MAKE} ${WORLD_FLAGS} -f Makefile.inc1 \ + DESTDIR= \ + OBJTOP='${WORLDTMP}/obj-kernel-tools' \ + OBJROOT='$${OBJTOP}/' \ + MAKEOBJDIRPREFIX= \ + BOOTSTRAPPING=${BOOTSTRAPPING_OSRELDATE} \ + -DNO_CPU_CFLAGS \ + -DNO_LINT \ + -DNO_PIC \ + -DNO_SHARED \ + MK_CTF=no \ + MK_HTML=no \ + MK_MAN=no \ + MK_PROFILE=no \ + MK_SSP=no \ + MK_RETPOLINE=no \ + MK_WERROR=no + +# world stage +WMAKEENV= ${CROSSENV} \ + INSTALL="${INSTALL_CMD} -U" \ + PATH=${TMPPATH} \ + SYSROOT=${WORLDTMP} + +# make hierarchy +HMAKE= PATH=${TMPPATH} ${MAKE} LOCAL_MTREE=${LOCAL_MTREE:Q} +.if defined(NO_ROOT) +HMAKE+= PATH=${TMPPATH} METALOG=${METALOG} -DNO_ROOT +.endif + +CROSSENV+= CC="${XCC} ${XCFLAGS}" CXX="${XCXX} ${XCXXFLAGS} ${XCFLAGS}" \ + CPP="${XCPP} ${XCFLAGS}" \ + AS="${XAS}" AR="${XAR}" ELFCTL="${XELFCTL}" LD="${XLD}" \ + LLVM_LINK="${XLLVM_LINK}" NM=${XNM} OBJCOPY="${XOBJCOPY}" \ + RANLIB=${XRANLIB} STRINGS=${XSTRINGS} \ + SIZE="${XSIZE}" STRIPBIN="${XSTRIPBIN}" + +.if defined(CROSS_BINUTILS_PREFIX) && exists(${CROSS_BINUTILS_PREFIX}) +# In the case of xdev-build tools, CROSS_BINUTILS_PREFIX won't be a +# directory, but the compiler will look in the right place for its +# tools so we don't need to tell it where to look. +BFLAGS+= -B${CROSS_BINUTILS_PREFIX} +.endif + + +# The internal bootstrap compiler has a default sysroot set by TOOLS_PREFIX +# and target set by TARGET/TARGET_ARCH. However, there are several needs to +# always pass an explicit --sysroot and -target. +# - External compiler needs sysroot and target flags. +# - External ld needs sysroot. +# - To be clear about the use of a sysroot when using the internal compiler. +# - Easier debugging. +# - Allowing WITH_SYSTEM_COMPILER+WITH_META_MODE to work together due to +# the flip-flopping build command when sometimes using external and +# sometimes using internal. +# - Allow using lld which has no support for default paths. +.if !defined(CROSS_BINUTILS_PREFIX) || !exists(${CROSS_BINUTILS_PREFIX}) +BFLAGS+= -B${WORLDTMP}/usr/bin +.endif +.if ${WANT_COMPILER_TYPE} == gcc || \ + (defined(X_COMPILER_TYPE) && ${X_COMPILER_TYPE} == gcc) +.elif ${WANT_COMPILER_TYPE} == clang || \ + (defined(X_COMPILER_TYPE) && ${X_COMPILER_TYPE} == clang) +XCFLAGS+= -target ${TARGET_TRIPLE} +.endif +XCFLAGS+= --sysroot=${WORLDTMP} + +.if !empty(BFLAGS) +XCFLAGS+= ${BFLAGS} +.endif + +.if ${MK_LIB32} == "yes" +_LIBCOMPAT= 32 +.include "Makefile.libcompat" +.endif + +# META_MODE normally ignores host file changes since every build updates +# timestamps (see NO_META_IGNORE_HOST in sys.mk). There are known times +# when the ABI breaks though that we want to force rebuilding WORLDTMP +# to get updated host tools. +.if ${MK_META_MODE} == "yes" && ${MK_CLEAN} == "no" && \ + !defined(NO_META_IGNORE_HOST) && !defined(NO_META_IGNORE_HOST_HEADERS) && \ + !defined(_MKSHOWCONFIG) +# r318736 - ino64 major ABI breakage +META_MODE_BAD_ABI_VERS+= 1200031 + +.if !defined(OBJDIR_HOST_OSRELDATE) +.if exists(${OBJTOP}/host-osreldate.h) +OBJDIR_HOST_OSRELDATE!= \ + awk '/^\#define[[:space:]]*__FreeBSD_version/ { print $$3 }' \ + ${OBJTOP}/host-osreldate.h +.elif exists(${WORLDTMP}/usr/include/osreldate.h) +OBJDIR_HOST_OSRELDATE= 0 +.endif +.export OBJDIR_HOST_OSRELDATE +.endif + +# Note that this logic is the opposite of normal BOOTSTRAP handling. We want +# to compare the WORLDTMP's OSRELDATE to the host's OSRELDATE. If the WORLDTMP +# is older than the ABI-breakage OSRELDATE of the HOST then we rebuild. +.if defined(OBJDIR_HOST_OSRELDATE) +.for _ver in ${META_MODE_BAD_ABI_VERS} +.if ${OSRELDATE} >= ${_ver} && ${OBJDIR_HOST_OSRELDATE} < ${_ver} +_meta_mode_need_rebuild= ${_ver} +.endif +.endfor +.if defined(_meta_mode_need_rebuild) *** 82571 LINES SKIPPED ***
