#

#

# 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"

# tests-install- install tests 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

.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}"

.elif defined(UNIVERSE_TOOLCHAIN)

UNIVERSE_TOOLCHAIN_PATH?=${HOST_OBJTOP}/tmp/usr/bin

XCC?="${UNIVERSE_TOOLCHAIN_PATH}/cc"

XCXX?="${UNIVERSE_TOOLCHAIN_PATH}/c++"

XCPP?="${UNIVERSE_TOOLCHAIN_PATH}/cpp"

XLD?="${UNIVERSE_TOOLCHAIN_PATH}/ld"

.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) || make(tests-install)

.-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_MIDNIGHTBSD_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/[hs]f$//}-${MACHINE_ABI}-freebsd13.4

TARGET_ABI?= unknown

TARGET_TRIPLE?= ${TARGET_ARCH:S/amd64/x86_64/:C/[hs]f$//}-${TARGET_ABI}-freebsd13.4

KNOWN_ARCHES?= aarch64/arm64 \

amd64 \

armv6/arm \

armv7/arm \

i386 \

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} != "MidnightBSD" && ${.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_MIDNIGHTBSD_VERSION) && !make(showconfig) && \

!make(test-system-linker)

.if ${WANT_COMPILER_TYPE} == "clang"

WANT_COMPILER_MIDNIGHTBSD_VERSION_FILE= lib/clang/midnightbsd_cc_version.h

WANT_COMPILER_MIDNIGHTBSD_VERSION!= \

awk '$$2 == "MIDNIGHTBSD_CC_VERSION" {printf("%d\n", $$3)}' \

${SRCDIR}/${WANT_COMPILER_MIDNIGHTBSD_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_MIDNIGHTBSD_VERSION WANT_COMPILER_VERSION

.endif # !defined(WANT_COMPILER_MIDNIGHTBSD_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_MIDNIGHTBSD_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_MIDNIGHTBSD_VERSION} == ${WANT_COMPILER_MIDNIGHTBSD_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_MIDNIGHTBSD_VERSION) && !make(showconfig) && \

!make(test-system-compiler)

.if ${WANT_LINKER_TYPE} == "lld"

WANT_LINKER_MIDNIGHTBSD_VERSION_FILE= lib/clang/include/lld/Common/Version.inc

WANT_LINKER_MIDNIGHTBSD_VERSION!= \

awk '$$2 == "LLD_MIDNIGHTBSD_VERSION" {print $$3}' \

${SRCDIR}/${WANT_LINKER_MIDNIGHTBSD_VERSION_FILE} || echo unknown

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]}' \

${SRCDIR}/${WANT_LINKER_VERSION_FILE} || echo unknown

.else

WANT_LINKER_MIDNIGHTBSD_VERSION_FILE=

WANT_LINKER_MIDNIGHTBSD_VERSION=

.endif

.export WANT_LINKER_MIDNIGHTBSD_VERSION WANT_LINKER_VERSION

.endif # !defined(WANT_LINKER_MIDNIGHTBSD_VERSION)

.if ${MK_SYSTEM_LINKER} == "yes" && \

defined(WANT_LINKER_MIDNIGHTBSD_VERSION) && \

(${MK_LLD_BOOTSTRAP} == "yes") && \

!make(xdev*) && \

${X_LINKER_TYPE} == ${WANT_LINKER_TYPE} && \

${X_LINKER_VERSION} == ${WANT_LINKER_VERSION} && \

${X_LINKER_MIDNIGHTBSD_VERSION} == ${WANT_LINKER_MIDNIGHTBSD_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_MIDNIGHTBSD_VERSION WANT_COMPILER_MIDNIGHTBSD_VERSION_FILE \

CC COMPILER_TYPE COMPILER_FEATURES COMPILER_VERSION \

COMPILER_MIDNIGHTBSD_VERSION \

XCC X_COMPILER_TYPE X_COMPILER_FEATURES X_COMPILER_VERSION \

X_COMPILER_MIDNIGHTBSD_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_MIDNIGHTBSD_VERSION WANT_LINKER_MIDNIGHTBSD_VERSION_FILE \

LD LINKER_TYPE LINKER_FEATURES LINKER_VERSION \

LINKER_MIDNIGHTBSD_VERSION \

XLD X_LINKER_TYPE X_LINKER_FEATURES X_LINKER_VERSION \

X_LINKER_MIDNIGHTBSD_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_MIDNIGHTBSD_VERSION \

COMPILER_RESOURCE_DIR \

LINKER_VERSION \

LINKER_FEATURES \

LINKER_TYPE \

LINKER_MIDNIGHTBSD_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:]]*__MidnightBSD_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

.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:]]*__MidnightBSD_version/ { print $$3 }' \

${SRCDIR}/sys/sys/param.h

.export SRCRELDATE

.endif

.if !defined(VERSION)

VERSION= MidnightBSD ${_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?= MidnightBSD

PKG_MAINTAINER?= [email protected]

PKG_WWW?= https://www.MidnightBSD.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-MidnightBSD should be fine.

.if ${MACHINE_ARCH} != ${BUILD_ARCH} && (${.MAKE.OS} == "MidnightBSD" || ${.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}

.if defined(UNIVERSE_TOOLCHAIN_PATH)

STRICTTMPPATH:=${STRICTTMPPATH}:${UNIVERSE_TOOLCHAIN_PATH}

.endif

# 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-MidnightBSD we can't rely on the tools in /usr/bin being compatible

# with what MidnightBSD 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) || \

make(tests-install)

.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

.if ${.MAKE.OS} == "MidnightBSD"

# When building on MidnightBSD we always copy the host tools instead of linking

# into INSTALLTMP to avoid issues with incompatible libraries (see r364030).

# Note: we could create links if we don't intend to update the current machine.

INSTALLTMP_COPY_HOST_TOOL=cp

.else

# However, this is not necessary on Linux/macOS. Additionally, copying the host

# tools to another directory with cp results in AMFI Launch Constraint

# Violations on macOS Ventura as part of its System Integrity Protection.

INSTALLTMP_COPY_HOST_TOOL=ln -s

.endif

.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?= 301000

MINIMUM_SUPPORTED_REL?= 3.1

# 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}/' \

UNIVERSE_TOOLCHAIN_PATH=${UNIVERSE_TOOLCHAIN_PATH} \

MAKEOBJDIRPREFIX= \

BOOTSTRAPPING=${BOOTSTRAPPING_OSRELDATE} \

BWPHASE=${.TARGET:C,^_,,} \

-DNO_CPU_CFLAGS \

-DNO_LINT \

-DNO_PIC \

-DNO_SHARED \

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_WERROR=no \

MK_INCLUDES=yes \

MK_MAN_UTILS=yes

BMAKE= \

${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= \

${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_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_WERROR=no

# cross-tools stage

# TOOLS_PREFIX set in BMAKE

XMAKE= ${BMAKE} \

TARGET=${TARGET} TARGET_ARCH=${TARGET_ARCH} \

MK_CLANG=${MK_CLANG_BOOTSTRAP} \

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= \

TOOLS_PREFIX=${TOOLS_PREFIX_UNDEF:U${WORLDTMP}} \

${KTMAKEENV} ${MAKE} ${WORLD_FLAGS} -f Makefile.inc1 \

DESTDIR= \

OBJTOP='${WORLDTMP}/obj-kernel-tools' \

OBJROOT='$${OBJTOP}/' \

UNIVERSE_TOOLCHAIN_PATH=${UNIVERSE_TOOLCHAIN_PATH} \

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

# An external compiler (e.g. upstream clang on Linux/macOS) only knows the

# freebsd triple, so it predefines __FreeBSD__ but not __MidnightBSD__. The

# tree keys on __MidnightBSD__ everywhere, so supply it ourselves with the same

# value our own clang derives from the triple's OS major version.

.if defined(X_COMPILER_MIDNIGHTBSD_VERSION) && \

${X_COMPILER_MIDNIGHTBSD_VERSION} == "unknown"

XCFLAGS+= -D__MidnightBSD__=${TARGET_TRIPLE:C/.*freebsd([0-9]+).*/\1/}

.endif

XCFLAGS+= --sysroot=${WORLDTMP}

.if !empty(BFLAGS)

XCFLAGS+= ${BFLAGS}

.endif

.if ${MK_LIB32} == "yes"

_LIBCOMPAT= 32

.include "Makefile.libcompat"

.elif ${MK_LIBSOFT} == "yes"

_LIBCOMPAT= SOFT

.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:]]*__MidnightBSD_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)

.info META_MODE: Rebuilding host tools due to ABI breakage in __MidnightBSD_version ${_meta_mode_need_rebuild}.

NO_META_IGNORE_HOST_HEADERS= 1

.export NO_META_IGNORE_HOST_HEADERS

.endif # defined(_meta_mode_need_rebuild)

.endif # defined(OBJDIR_HOST_OSRELDATE)

.endif # ${MK_META_MODE} == "yes" && ${MK_CLEAN} == "no" ...

# This is only used for META_MODE+filemon to track what the oldest

# __MidnightBSD_version is in WORLDTMP. This purposely does NOT have

# a make dependency on /usr/include/osreldate.h as the file should

# only be copied when it is missing or meta mode determines it has changed.

# Since host files are normally ignored without NO_META_IGNORE_HOST

# the file will never be updated unless that flag is specified. This

# allows tracking the oldest osreldate to force rebuilds via

# META_MODE_BADABI_REVS above.

host-osreldate.h: # DO NOT ADD /usr/include/osreldate.h here

.if !defined(CROSSBUILD_HOST)

@cp -f /usr/include/osreldate.h ${.TARGET}

.else

@echo "#ifndef __MidnightBSD_version" > ${.TARGET}

@echo "#define __MidnightBSD_version ${OSRELDATE}" >> ${.TARGET}

@echo "#endif" >> ${.TARGET}

.endif

WMAKE= ${WMAKEENV} ${MAKE} ${WORLD_FLAGS} -f Makefile.inc1 \

BWPHASE=${.TARGET:C,^_,,} \

DESTDIR=${WORLDTMP}

IMAKEENV= ${CROSSENV}

IMAKE= ${IMAKEENV} ${MAKE} -f Makefile.inc1 \

${IMAKE_INSTALL} ${IMAKE_MTREE}

.if empty(.MAKEFLAGS:M-n)

IMAKEENV+= PATH=${STRICTTMPPATH}:${INSTALLTMP} \

LD_LIBRARY_PATH=${INSTALLTMP} \

PATH_LOCALE=${INSTALLTMP}/locale

IMAKE+= __MAKE_SHELL=${INSTALLTMP}/sh

.else

IMAKEENV+= PATH=${TMPPATH}:${INSTALLTMP}

.endif

# When generating install media, do not allow user and group information from

# the build host to affect the contents of the distribution.

.if make(distributeworld) || make(distrib-dirs) || make(distribution) || \

make(stageworld)

DB_FROM_SRC= yes

.endif

.if defined(DB_FROM_SRC)

INSTALLFLAGS+= -N ${.CURDIR}/etc

MTREEFLAGS+= -N ${.CURDIR}/etc

.endif

_INSTALL_DDIR= ${DESTDIR}/${DISTDIR}

INSTALL_DDIR= ${_INSTALL_DDIR:S://:/:g:C:/$::}

.if defined(NO_ROOT)

METALOG?= ${DESTDIR}/${DISTDIR}/METALOG

METALOG:= ${METALOG:C,//+,/,g}

IMAKE+= -DNO_ROOT METALOG=${METALOG}

METALOG_INSTALLFLAGS= -U -M ${METALOG} -D ${INSTALL_DDIR}

INSTALLFLAGS+= ${METALOG_INSTALLFLAGS}

CERTCTLFLAGS= ${METALOG_INSTALLFLAGS}

MTREEFLAGS+= -W

.endif

.if defined(BUILD_PKGS)

INSTALLFLAGS+= -h sha256

.endif

.if defined(DB_FROM_SRC) || defined(NO_ROOT)

IMAKE_INSTALL= INSTALL="${INSTALL_CMD} ${INSTALLFLAGS}"

IMAKE_MTREE= MTREE_CMD="${MTREE_CMD} ${MTREEFLAGS}"

.endif

.if make(distributeworld)

CERTCTLDESTDIR= ${DESTDIR}/${DISTDIR}

CERTCTLFLAGS+= -d /base

.else

CERTCTLDESTDIR= ${DESTDIR}

.endif

CERTCTLFLAGS+= -D "${CERTCTLDESTDIR}"

DESTDIR_MTREEFLAGS= -deU

# When creating worldtmp we don't need to set the directories as owned by root

# so we also pass -W

WORLDTMP_MTREEFLAGS= -deUW

.if defined(NO_ROOT)

# When building with -DNO_ROOT we shouldn't be changing the directories

# that are created by mtree to be owned by root/wheel.

DESTDIR_MTREEFLAGS+= -W

.endif

DISTR_MTREE= ${MTREE_CMD}

.if ${BUILD_WITH_STRICT_TMPPATH} != 0

DISTR_MTREE= ${WORLDTMP}/legacy/usr/sbin/mtree

.endif

WORLDTMP_MTREE= ${DISTR_MTREE} ${WORLDTMP_MTREEFLAGS}

DESTDIR_MTREE= ${DISTR_MTREE} ${DESTDIR_MTREEFLAGS}