mirror of
https://github.com/RIOT-OS/RIOT.git
synced 2024-12-29 04:50:03 +01:00
1022 lines
34 KiB
Makefile
1022 lines
34 KiB
Makefile
MATCH_MAKE_VERSION = 4.%
|
|
|
|
MAKEFLAGS += --no-builtin-rules
|
|
|
|
ifeq (,$(filter $(MATCH_MAKE_VERSION),$(MAKE_VERSION)))
|
|
$(error GNU Make $(MAKE_VERSION) is not supported by RIOT since release \
|
|
2020.01. Please upgrade your system to use GNU Make \
|
|
$(MATCH_MAKE_VERSION) or later.)
|
|
endif
|
|
|
|
#
|
|
# enable second expansion of prerequisites.
|
|
#
|
|
# Doing that here enables it globally for all applications.
|
|
#
|
|
# See https://www.gnu.org/software/make/manual/html_node/Secondary-Expansion.html
|
|
# for what it can be used for.
|
|
.SECONDEXPANSION:
|
|
|
|
# Will evaluate to the absolute path of the Makefile it's evaluated in.¹
|
|
#
|
|
# This variable MUST be immediately evaluated (tmp_var := $(LAST_MAKEFILEDIR))
|
|
# unless it is used directly.
|
|
#
|
|
# [1] Note that this will in fact return the path of the last Makefile that
|
|
# was included, so it must be evaluated before any subsequent includes.
|
|
LAST_MAKEFILEDIR = $(abspath $(dir $(lastword $(MAKEFILE_LIST))))
|
|
|
|
# 'Makefile.include' directory, must be evaluated before other 'include'
|
|
_riotbase := $(LAST_MAKEFILEDIR)
|
|
|
|
# include RIOT_MAKEFILES_GLOBAL_PRE configuration files
|
|
# allows setting user specific system wide configuration parsed before the body
|
|
# of $(RIOTBASE)/Makefile.include
|
|
include $(RIOT_MAKEFILES_GLOBAL_PRE)
|
|
|
|
# Globally set default goal to `all`
|
|
.DEFAULT_GOAL := all
|
|
|
|
# include Makefile.local if it exists
|
|
-include Makefile.local
|
|
|
|
# set undefined variables
|
|
RIOTBASE ?= $(_riotbase)
|
|
RIOTCPU ?= $(RIOTBASE)/cpu
|
|
# Deprecated to set RIOTBOARD, use EXTERNAL_BOARD_DIRS
|
|
RIOTBOARD ?= $(RIOTBASE)/boards
|
|
EXTERNAL_BOARD_DIRS ?=
|
|
RIOTMAKE ?= $(RIOTBASE)/makefiles
|
|
RIOTPKG ?= $(RIOTBASE)/pkg
|
|
RIOTTOOLS ?= $(RIOTBASE)/dist/tools
|
|
RIOTPROJECT ?= $(shell git rev-parse --show-toplevel 2>/dev/null || pwd)
|
|
BUILD_DIR ?= $(RIOTBASE)/build
|
|
APPDIR ?= $(CURDIR)
|
|
BINDIRBASE ?= $(APPDIR)/bin
|
|
BINDIR ?= $(BINDIRBASE)/$(BOARD)
|
|
PKGDIRBASE ?= $(RIOTBASE)/build/pkg
|
|
DLCACHE ?= $(RIOTTOOLS)/dlcache/dlcache.sh
|
|
DLCACHE_DIR ?= $(RIOTBASE)/.dlcache
|
|
WARNING_EXTERNAL_MODULE_DIRS ?= 1
|
|
|
|
# include CI info such as BOARD_INSUFFICIENT_MEMORY, if existing
|
|
-include Makefile.ci
|
|
|
|
__DIRECTORY_VARIABLES := \
|
|
RIOTBASE \
|
|
RIOTCPU \
|
|
RIOTMAKE \
|
|
RIOTPKG \
|
|
RIOTTOOLS \
|
|
RIOTPROJECT \
|
|
APPDIR \
|
|
BUILD_DIR \
|
|
BINDIRBASE \
|
|
BINDIR \
|
|
PKGDIRBASE \
|
|
DLCACHE_DIR \
|
|
#
|
|
|
|
# In GNU make command line is supposed to override the value set in makefile
|
|
# These variables can be overridden even when set from command line
|
|
__OVERRIDE_DIRECTORY_VARIABLES := $(__DIRECTORY_VARIABLES)
|
|
# Use absolute paths in recursive "make" even if overridden on command line.
|
|
MAKEOVERRIDES += $(foreach v,$(__OVERRIDE_DIRECTORY_VARIABLES),$(v)=$($(v)))
|
|
|
|
# Setting EXTERNAL_BOARD_DIRS and EXTERNAL_MODULE_DIRS as command line argument
|
|
# is too messy to handle: Even when every path in EXTERNAL_BOARD_DIRS is turned
|
|
# into an absolute path using override, sub-makes will still get the original
|
|
# value. Using MAKEOVERRIDES has issues with spaces in the values, which are
|
|
# used as separator in EXTERNAL_BOARD_DIRS. So we just enforce setting the value
|
|
# either in a Makefile, or as environment variable.
|
|
ifeq ($(INSIDE_DOCKER),0)
|
|
# In Docker absolute paths are always given, so only fail when not in docker
|
|
ifeq ($(origin EXTERNAL_BOARD_DIRS),command line)
|
|
$(error EXTERNAL_BOARD_DIRS must be passed as environment variable, and not as command line argument)
|
|
endif
|
|
ifeq ($(origin EXTERNAL_MODULE_DIRS),command line)
|
|
$(error EXTERNAL_MODULE_DIRS must be passed as environment variable, and not as command line argument)
|
|
endif
|
|
endif
|
|
|
|
# Deprecation of configuring 'RIOTBOARD'
|
|
ifneq ($(abspath $(RIOTBASE)/boards),$(abspath $(RIOTBOARD)))
|
|
$(warning overriding RIOTBOARD for external boards is deprecated, use EXTERNAL_BOARD_DIRS instead)
|
|
override RIOTBOARD := $(abspath $(RIOTBOARD))
|
|
__DIRECTORY_VARIABLES += RIOTBOARD
|
|
endif
|
|
|
|
# Only warn users, not the CI.
|
|
ifneq ($(RIOT_CI_BUILD),1)
|
|
# Do not warn when set from sub-make
|
|
ifeq ($(MAKELEVEL),0)
|
|
ifneq (,$(BOARDSDIR))
|
|
$(warning Using BOARDSDIR is deprecated use EXTERNAL_BOARD_DIRS instead)
|
|
$(info EXTERNAL_BOARD_DIRS can contain multiple folders separated by space)
|
|
endif
|
|
|
|
# API change warning for EXTERNAL_MODULE_DIRS, remove by 2021.10
|
|
ifneq (,$(EXTERNAL_MODULE_DIRS))
|
|
ifeq (1,$(WARNING_EXTERNAL_MODULE_DIRS))
|
|
$(info Warning! EXTERNAL_MODULE_DIRS is a search folder since 2021.07-branch, see \
|
|
https://doc.riot-os.org/creating-modules.html#modules-outside-of-riotbase)
|
|
endif
|
|
endif
|
|
endif
|
|
endif
|
|
|
|
# Needed for backward compatibility:
|
|
ifneq (,$(BOARDSDIR))
|
|
EXTERNAL_BOARD_DIRS += $(BOARDSDIR)
|
|
endif
|
|
|
|
# Make all paths absolute.
|
|
override RIOTBASE := $(abspath $(RIOTBASE))
|
|
override RIOTCPU := $(abspath $(RIOTCPU))
|
|
override RIOTMAKE := $(abspath $(RIOTMAKE))
|
|
override RIOTPKG := $(abspath $(RIOTPKG))
|
|
override RIOTTOOLS := $(abspath $(RIOTTOOLS))
|
|
override RIOTPROJECT := $(abspath $(RIOTPROJECT))
|
|
override APPDIR := $(abspath $(APPDIR))
|
|
override BUILD_DIR := $(abspath $(BUILD_DIR))
|
|
override BINDIRBASE := $(abspath $(BINDIRBASE))
|
|
override BINDIR := $(abspath $(BINDIR))
|
|
override PKGDIRBASE := $(abspath $(PKGDIRBASE))
|
|
override DLCACHE_DIR := $(abspath $(DLCACHE_DIR))
|
|
EXTERNAL_BOARD_DIRS := $(foreach dir,\
|
|
$(EXTERNAL_BOARD_DIRS),\
|
|
$(abspath $(dir)))
|
|
EXTERNAL_MODULE_DIRS := $(foreach dir,\
|
|
$(EXTERNAL_MODULE_DIRS),\
|
|
$(abspath $(dir)))
|
|
|
|
# Ensure that all directories are set and don't contain spaces.
|
|
ifneq (, $(filter-out 1, $(foreach v,$(__DIRECTORY_VARIABLES),$(words $($(v))))))
|
|
$(info Aborting compilation for your safety.)
|
|
$(info Related variables = $(__DIRECTORY_VARIABLES))
|
|
$(error Make sure no path override is empty or contains spaces!)
|
|
endif
|
|
|
|
# Path to the current directory relative to RIOTPROJECT
|
|
# trailing '/' is important when RIOTPROJECT == CURDIR
|
|
BUILDRELPATH ?= $(patsubst $(RIOTPROJECT)/%,%,$(CURDIR)/)
|
|
|
|
# Set CLEAN to "clean" if that target was requested.
|
|
# Allows recipes to be run after cleaning, without triggering it implicitly:
|
|
#
|
|
# all: | $(CLEAN)
|
|
#
|
|
CLEAN = $(filter clean, $(MAKECMDGOALS))
|
|
|
|
# include makefiles utils tools
|
|
include $(RIOTMAKE)/utils/variables.mk
|
|
include $(RIOTMAKE)/utils/strings.mk
|
|
|
|
|
|
# UNAME is always needed so use simple variable expansion so only evaluated once
|
|
UNAME := $(shell uname -m -s)
|
|
OS = $(word 1, $(UNAME))
|
|
OS_ARCH = $(word 2, $(UNAME))
|
|
|
|
# set python path, e.g. for tests
|
|
PYTHONPATH := $(RIOTBASE)/dist/pythonlibs/:$(PYTHONPATH)
|
|
|
|
# Basic utilities included before anything else
|
|
include $(RIOTMAKE)/utils/checks.mk
|
|
|
|
# Include Docker settings near the top because we need to build the environment
|
|
# command line before some of the variable origins are overwritten below when
|
|
# using abspath, strip etc.
|
|
include $(RIOTMAKE)/docker.inc.mk
|
|
|
|
# include color echo macros
|
|
include $(RIOTMAKE)/utils/ansi.mk
|
|
include $(RIOTMAKE)/color.inc.mk
|
|
|
|
# include concurrency helpers
|
|
include $(RIOTMAKE)/info-nproc.inc.mk
|
|
|
|
# List of boards variables
|
|
include $(RIOTMAKE)/boards.inc.mk
|
|
|
|
# Debug targets for build system migration
|
|
include $(RIOTMAKE)/dependencies_debug.inc.mk
|
|
|
|
# Use TOOLCHAIN environment variable to select the toolchain to use.
|
|
# If native, TOOLCHAIN for OSX is llvm
|
|
ifeq ($(BOARD),native)
|
|
ifeq ($(OS),Darwin)
|
|
TOOLCHAIN ?= llvm
|
|
endif
|
|
endif
|
|
# Use override so that we can redefine a variable set on the command line (as
|
|
# opposed to one set in the environment)
|
|
ifeq (clang,$(TOOLCHAIN))
|
|
# TOOLCHAIN = clang is an alias for TOOLCHAIN = llvm
|
|
override TOOLCHAIN := llvm
|
|
endif
|
|
ifeq (gcc,$(TOOLCHAIN))
|
|
# TOOLCHAIN = gcc is an alias for TOOLCHAIN = gnu
|
|
override TOOLCHAIN := gnu
|
|
endif
|
|
ifeq (,$(TOOLCHAIN))
|
|
override TOOLCHAIN := gnu
|
|
endif
|
|
|
|
GLOBAL_GOALS += buildtest \
|
|
buildtest-indocker \
|
|
info-boards-features-blacklisted \
|
|
info-boards-features-conflicting \
|
|
info-boards-features-missing \
|
|
info-boards-supported \
|
|
info-buildsizes info-buildsizes-diff \
|
|
#
|
|
|
|
ifneq (, $(filter $(GLOBAL_GOALS), $(MAKECMDGOALS)))
|
|
include $(RIOTMAKE)/info-global.inc.mk
|
|
include $(RIOTMAKE)/buildtests.inc.mk
|
|
else
|
|
|
|
all: link
|
|
|
|
# Folders to search: First the external boards, than the official
|
|
BOARDSDIRS := $(EXTERNAL_BOARD_DIRS) $(RIOTBOARD)
|
|
|
|
# Take the first folder in $(BOARDSDIRS) that contains a folder named $(BOARD)
|
|
BOARDDIR := $(word 1,$(foreach dir,$(BOARDSDIRS),$(wildcard $(dir)/$(BOARD)/.)))
|
|
# Sanitize folder
|
|
BOARDDIR := $(abspath $(BOARDDIR))
|
|
|
|
# Also provide BOARDSDIR for compatibility and for accessing common folders
|
|
# (e.g. include $(BOARDSDIR)/common/external_common/Makefile.dep)
|
|
BOARDSDIR := $(dir $(BOARDDIR))
|
|
|
|
ifeq (,$(BOARDDIR))
|
|
$(info Folders searched for the board: $(BOARDSDIRS))
|
|
$(error The specified board $(BOARD) does not exist.)
|
|
endif
|
|
|
|
include $(RIOTMAKE)/info.inc.mk
|
|
|
|
# Static code analysis tools provided by LLVM
|
|
include $(RIOTMAKE)/scan-build.inc.mk
|
|
|
|
export RIOTBUILD_CONFIG_HEADER_C = $(BINDIR)/riotbuild/riotbuild.h
|
|
|
|
# When testing Kconfig's module modelling we need to run Kconfig
|
|
ifeq (1,$(TEST_KCONFIG))
|
|
SHOULD_RUN_KCONFIG = 1
|
|
endif
|
|
|
|
ifeq ($(OS),Darwin)
|
|
OPEN := open
|
|
else
|
|
OPEN := xdg-open
|
|
endif
|
|
|
|
QUIET ?= 1
|
|
QUIETER ?= 0
|
|
|
|
ifeq ($(QUIET),1)
|
|
Q=@
|
|
MAKEFLAGS += --no-print-directory
|
|
else
|
|
Q=
|
|
endif
|
|
|
|
# Set this to 1 to enable code in RIOT that does safety checking
|
|
# which is not needed in a production environment but helps in the
|
|
# development process:
|
|
DEVELHELP ?= 0
|
|
ifeq ($(DEVELHELP),1)
|
|
CFLAGS += -DDEVELHELP
|
|
endif
|
|
|
|
# Set this to 1 to enable thread names
|
|
THREAD_NAMES ?= 0
|
|
ifeq ($(THREAD_NAMES),1)
|
|
CFLAGS += -DCONFIG_THREAD_NAMES
|
|
endif
|
|
|
|
# Override LOG_LEVEL if variable is set and if CFLAGS doesn't already contain
|
|
# a LOG_LEVEL config
|
|
ifdef LOG_LEVEL
|
|
ifeq (,$(filter -DLOG_LEVEL=%,$(CFLAGS)))
|
|
CFLAGS += -DLOG_LEVEL=$(LOG_LEVEL)
|
|
endif
|
|
endif
|
|
|
|
# Fail on warnings. Can be overridden by `make WERROR=0`.
|
|
WERROR ?= 1
|
|
ifeq ($(WERROR),1)
|
|
CFLAGS += -Werror
|
|
endif
|
|
|
|
WPEDANTIC ?= 0
|
|
ifeq ($(WPEDANTIC),1)
|
|
CFLAGS += -Wpedantic
|
|
endif
|
|
|
|
# Provide a shallow sanity check. You cannot call `make` in a module directory.
|
|
export __RIOTBUILD_FLAG := RIOT
|
|
|
|
BOARD := $(strip $(BOARD))
|
|
APPLICATION := $(strip $(APPLICATION))
|
|
|
|
# provide common external programs for `Makefile.include`s
|
|
|
|
ifeq (,$(and $(DOWNLOAD_TO_STDOUT),$(DOWNLOAD_TO_FILE)))
|
|
ifeq (,$(WGET))
|
|
ifeq (0,$(shell which wget > /dev/null 2>&1 ; echo $$?))
|
|
WGET = $(call memoized,WGET,$(shell which wget))
|
|
endif
|
|
endif
|
|
ifeq (,$(CURL))
|
|
ifeq (0,$(shell which curl > /dev/null 2>&1 ; echo $$?))
|
|
CURL = $(call memoized,CURL,$(shell which curl))
|
|
endif
|
|
endif
|
|
ifeq (,$(WGET)$(CURL))
|
|
$(warning Neither wget nor curl is installed!)
|
|
endif
|
|
|
|
ifeq (,$(DOWNLOAD_TO_STDOUT))
|
|
DOWNLOAD_TO_STDOUT ?= $(if $(CURL),$(CURL) -s,$(WGET) -q -O-)
|
|
endif
|
|
ifeq (,$(DOWNLOAD_TO_FILE))
|
|
DOWNLOAD_TO_FILE ?= $(if $(WGET),$(WGET) -nv -c -O,$(CURL) -s -o)
|
|
endif
|
|
endif
|
|
|
|
ifeq (,$(UNZIP_HERE))
|
|
ifeq (0,$(shell which unzip > /dev/null 2>&1 ; echo $$?))
|
|
UNZIP_HERE = $(call memoized,UNZIP_HERE,$(shell which unzip) -q)
|
|
else
|
|
ifeq (0,$(shell which 7z > /dev/null 2>&1 ; echo $$?))
|
|
UNZIP_HERE = $(call memoized,UNZIP_HERE,$(shell which 7z) x -bd)
|
|
else
|
|
$(warning Neither unzip nor 7z is installed.)
|
|
endif
|
|
endif
|
|
endif
|
|
|
|
# Tool saving stdin to a file only on content update.
|
|
# It keeps the file timestamp if it would end up the same.
|
|
LAZYSPONGE ?= $(RIOTTOOLS)/lazysponge/lazysponge.py
|
|
LAZYSPONGE_FLAGS ?= $(if $(filter 1,$(QUIET)),,--verbose)
|
|
|
|
ifeq (, $(APPLICATION))
|
|
$(error An application name must be specified as APPLICATION.)
|
|
endif
|
|
|
|
# default toolchain prefix, defaults to target triple followed by a dash, you
|
|
# will most likely not need to touch this.
|
|
export PREFIX ?= $(if $(TARGET_ARCH),$(TARGET_ARCH)-)
|
|
|
|
# set default PROGRAMMER value if flashing a board on IoT-LAB
|
|
# This must be done before parsing the Makefile.include of the board and cannot
|
|
# be done in makefile.iotlab.single.inc.mk which is included after.
|
|
ifneq (,$(IOTLAB_NODE))
|
|
PROGRAMMER ?= iotlab
|
|
# iotlab uses ELFFILE by default for flashing boards.
|
|
FLASHFILE ?= $(ELFFILE)
|
|
endif
|
|
|
|
# Add standard include directories
|
|
INCLUDES += -I$(RIOTBASE)/core/include -I$(RIOTBASE)/drivers/include -I$(RIOTBASE)/sys/include
|
|
|
|
# process provided features
|
|
include $(RIOTBASE)/Makefile.features
|
|
|
|
# mandatory includes!
|
|
include $(RIOTMAKE)/pseudomodules.inc.mk
|
|
include $(RIOTMAKE)/defaultmodules.inc.mk
|
|
|
|
# Include Kconfig functionalities
|
|
include $(RIOTMAKE)/kconfig.mk
|
|
|
|
# For testing, use TEST_KCONFIG as a switch between Makefile.dep and Kconfig
|
|
ifeq (1,$(TEST_KCONFIG))
|
|
$(info === [ATTENTION] Testing Kconfig dependency modelling ===)
|
|
KCONFIG_MODULES := $(call lowercase,$(patsubst CONFIG_MODULE_%,%,$(filter CONFIG_MODULE_%,$(.VARIABLES))))
|
|
USEMODULE := $(KCONFIG_MODULES)
|
|
KCONFIG_PACKAGES := $(call lowercase,$(patsubst CONFIG_PACKAGE_%,%,$(filter CONFIG_PACKAGE_%,$(.VARIABLES))))
|
|
USEPKG := $(KCONFIG_PACKAGES)
|
|
else
|
|
# check if required features are provided and update $(FEATURES_USED)
|
|
include $(RIOTMAKE)/features_check.inc.mk
|
|
|
|
# handle removal of default modules
|
|
USEMODULE += $(filter-out $(DISABLE_MODULE), $(DEFAULT_MODULE))
|
|
|
|
# avoid recursive expansion
|
|
USEMODULE := $(sort $(USEMODULE))
|
|
|
|
# process dependencies
|
|
include $(RIOTMAKE)/dependency_resolution.inc.mk
|
|
endif
|
|
|
|
# Include Board and CPU configuration
|
|
INCLUDES += $(addprefix -I,$(wildcard $(BOARDDIR)/include))
|
|
include $(BOARDDIR)/Makefile.include
|
|
INCLUDES += -I$(RIOTCPU)/$(CPU)/include
|
|
include $(RIOTCPU)/$(CPU)/Makefile.include
|
|
|
|
# Include common serial logic to define TERMPROG, TERMFLAGS variables based on
|
|
# the content of RIOT_TERMINAL
|
|
include $(RIOTMAKE)/tools/serial.inc.mk
|
|
|
|
# Include emulator code when required and if available
|
|
ifeq (1,$(EMULATE))
|
|
# Use renode as default emulator
|
|
RIOT_EMULATOR ?= renode
|
|
-include $(RIOTMAKE)/tools/$(RIOT_EMULATOR).inc.mk
|
|
TERMDEPS += $(EMULATORDEPS)
|
|
DEBUGDEPS += $(EMULATORDEPS)
|
|
endif
|
|
|
|
# Include common programmer logic if available
|
|
-include $(RIOTMAKE)/tools/$(PROGRAMMER).inc.mk
|
|
|
|
# Check if programmer is supported by the board, only if PROGRAMMERS_SUPPORTED
|
|
# is set and if programmer is not iotlab
|
|
ifneq (iotlab,$(PROGRAMMER))
|
|
ifneq (,$(PROGRAMMERS_SUPPORTED))
|
|
ifeq (,$(filter $(PROGRAMMER),$(PROGRAMMERS_SUPPORTED)))
|
|
$(info '$(PROGRAMMER)' programmer is not supported by this board. \
|
|
Supported programmers: '$(PROGRAMMERS_SUPPORTED)')
|
|
endif
|
|
endif
|
|
endif
|
|
|
|
# Assume GCC/GNU as supported toolchain if CPU's Makefile.include doesn't
|
|
# provide this macro
|
|
TOOLCHAINS_SUPPORTED ?= gnu
|
|
# Import all toolchain settings
|
|
include $(RIOTMAKE)/toolchain/$(TOOLCHAIN).inc.mk
|
|
|
|
# Append ldscript path after importing CPU and board makefiles to allow
|
|
# overriding the core ldscripts
|
|
LINKFLAGS += -L$(RIOTBASE)/core/ldscripts
|
|
|
|
# Tell ccache to pass the original file to the compiler, instead of passing the
|
|
# preprocessed code. Without this setting, the compilation will fail with
|
|
# -Wimplicit-fallthrough warnings even when the fall through case is properly
|
|
# commented because the preprocessor has stripped the comments from the code.
|
|
# This also fixes some other false warnings when compiling with LLVM/Clang.
|
|
# The environment variable only affects builds with ccache (e.g. on CI/Murdock).
|
|
# Non cached builds are not affected in any way.
|
|
# For more information, see http://petereisentraut.blogspot.com/2011/09/ccache-and-clang-part-2.html
|
|
export CCACHE_CPP2=yes
|
|
|
|
ifeq ($(strip $(MCU)),)
|
|
MCU = $(CPU)
|
|
endif
|
|
|
|
# set some settings useful for continuous integration builds
|
|
ifeq ($(RIOT_CI_BUILD),1)
|
|
RIOT_VERSION ?= buildtest
|
|
# set a dummy version number
|
|
RIOT_VERSION_CODE ?= RIOT_VERSION_NUM\(2042,5,23,0\)
|
|
ifneq ($(filter $(BOARD_INSUFFICIENT_MEMORY), $(BOARD)),)
|
|
$(info CI-build: skipping link step)
|
|
RIOTNOLINK:=1
|
|
endif
|
|
# be more quiet when building for CI
|
|
QUIETER=1
|
|
endif
|
|
|
|
ifeq ($(QUIETER),1)
|
|
QQ=@
|
|
else
|
|
QQ=
|
|
endif
|
|
|
|
# if you want to publish the board into the sources as an uppercase #define
|
|
BOARDDEF = $(call uppercase_and_underscore,$(BOARD))
|
|
CPUDEF = $(call uppercase_and_underscore,$(CPU))
|
|
MCUDEF = $(call uppercase_and_underscore,$(MCU))
|
|
CFLAGS += -DRIOT_APPLICATION=\"$(APPLICATION)\"
|
|
CFLAGS += -DBOARD_$(BOARDDEF)=\"$(BOARD)\" -DRIOT_BOARD=BOARD_$(BOARDDEF)
|
|
CFLAGS += -DCPU_$(CPUDEF)=\"$(CPU)\" -DRIOT_CPU=CPU_$(CPUDEF)
|
|
CFLAGS += -DMCU_$(MCUDEF)=\"$(MCU)\" -DRIOT_MCU=MCU_$(MCUDEF)
|
|
|
|
# Feature test default CFLAGS and LINKFLAGS for the set compiled.
|
|
include $(RIOTMAKE)/cflags.inc.mk
|
|
|
|
# Include VERSION for releases
|
|
-include $(RIOTBASE)/VERSION
|
|
-include $(RIOTBASE)/EXTRAVERSION
|
|
|
|
include $(RIOTMAKE)/git_version.inc.mk
|
|
RIOT_VERSION ?= $(or $(GIT_VERSION),'UNKNOWN (builddir: $(RIOTBASE))')
|
|
RIOT_EXTRAVERSION ?= 0
|
|
|
|
# Deprecate using RIOT_VERSION_OVERRIDE but currently keep the behavior
|
|
ifneq (,$(RIOT_VERSION_OVERRIDE))
|
|
$(warning 'RIOT_VERSION_OVERRIDE' is deprecated, it can now be set with 'RIOT_VERSION' directly.)
|
|
RIOT_VERSION = $(RIOT_VERSION_OVERRIDE)
|
|
endif
|
|
|
|
# Generate machine readable RIOT VERSION macro
|
|
RIOT_VERSION_CODE ?= $(shell echo ${RIOT_VERSION} | \
|
|
sed -E 's/([0-9]+).([0-9]+).?([0-9]+)?.*/RIOT_VERSION_NUM\\\(\1,\2,0\3,${RIOT_EXTRAVERSION}\\\)/')
|
|
|
|
# Set module by prepending APPLICATION name with 'application_'.
|
|
# It prevents conflict with application and modules with the same name.
|
|
APPLICATION_MODULE ?= application_$(APPLICATION)
|
|
|
|
# the binaries to link
|
|
BASELIBS += $(APPLICATION_MODULE).module
|
|
BASELIBS += $(APPDEPS)
|
|
|
|
|
|
# add extra include paths for packages in $(USEMODULE)
|
|
USEMODULE_INCLUDES =
|
|
|
|
include $(RIOTBASE)/sys/Makefile.include
|
|
|
|
# include Makefile.includes of each driver modules if they exist
|
|
-include $(USEMODULE:%=$(RIOTBASE)/drivers/%/Makefile.include)
|
|
|
|
# include Makefile.includes for packages in $(USEPKG)
|
|
-include $(USEPKG:%=$(RIOTPKG)/%/Makefile.include)
|
|
|
|
# include external modules configuration
|
|
-include $(EXTERNAL_MODULE_PATHS:%=%/Makefile.include)
|
|
|
|
# Deduplicate includes without sorting them
|
|
# see https://stackoverflow.com/questions/16144115/makefile-remove-duplicate-words-without-sorting
|
|
define uniq
|
|
$(eval seen :=)
|
|
$(foreach _,$1,$(if $(filter $_,$(seen)),,$(eval seen += $_)))
|
|
$(seen)
|
|
endef
|
|
|
|
USEMODULE_INCLUDES_ = $(strip $(call uniq,$(USEMODULE_INCLUDES)))
|
|
|
|
INCLUDES += $(USEMODULE_INCLUDES_:%=-I%)
|
|
|
|
|
|
# include bindist target
|
|
include $(RIOTMAKE)/bindist.inc.mk
|
|
|
|
# Add all USEMODULE modules to CFLAGS and populate BASELIBS
|
|
include $(RIOTMAKE)/modules.inc.mk
|
|
|
|
|
|
.PHONY: all link clean flash flash-only termdeps term doc debug debug-server reset objdump help info-modules
|
|
.PHONY: print-size elffile binfile hexfile flashfile cosy
|
|
.PHONY: ..in-docker-container
|
|
|
|
# Targets that depend on FORCE will always be rebuilt. Contrary to a .PHONY
|
|
# target, they are considered real files and the modification timestamp is taken
|
|
# into account.
|
|
#
|
|
# FORCE is useful for goals that may keep outputs unchanged (for example, if it
|
|
# depends on environment or configuration variables). If the goal were .PHONY, it
|
|
# would trigger a rebuild of all its dependents regardless of file modification.
|
|
#
|
|
# As general rule, use .PHONY only for non-file targets.
|
|
#
|
|
# For more information, see:
|
|
# https://www.gnu.org/software/make/manual/html_node/Phony-Targets.html
|
|
# https://www.gnu.org/software/make/manual/html_node/Force-Targets.html
|
|
.PHONY: FORCE
|
|
|
|
ifneq (,$(IOTLAB_NODE))
|
|
# iot-lab archi mapping
|
|
include $(RIOTBASE)/dist/testbed-support/makefile.iotlab.archi.inc.mk
|
|
ifneq (,$(IOTLAB_ARCHI))
|
|
# iot-lab serial and flasher
|
|
include $(RIOTBASE)/dist/testbed-support/makefile.iotlab.single.inc.mk
|
|
else
|
|
$(info $(COLOR_YELLOW)Board "$(BOARD)" incompatible with IOTLAB_NODE variable$(COLOR_RESET))
|
|
endif
|
|
endif
|
|
|
|
ELFFILE ?= $(BINDIR)/$(APPLICATION).elf
|
|
HEXFILE ?= $(ELFFILE:.elf=.hex)
|
|
BINFILE ?= $(ELFFILE:.elf=.bin)
|
|
MAPFILE ?= $(ELFFILE:.elf=.map)
|
|
|
|
ifneq (,$(filter suit, $(USEMODULE)))
|
|
include $(RIOTMAKE)/suit.base.inc.mk
|
|
endif
|
|
|
|
# include bootloaders support. It should be included early to allow using
|
|
# variables defined in `riotboot.mk` for `FLASHFILE` before it is evaluated.
|
|
# It should be included after defining 'BINFILE' for 'riotboot.bin' handling.
|
|
include $(RIOTMAKE)/boot/riotboot.mk
|
|
|
|
# Targets to get given file
|
|
elffile: $(ELFFILE)
|
|
hexfile: $(HEXFILE)
|
|
binfile: $(BINFILE)
|
|
# FLASHFILE is the file used by the flasher
|
|
# Usually set to $(ELFFILE), $(HEXFILE) or $(BINFILE) in the board/flasher
|
|
# or application specific files
|
|
flashfile: $(FLASHFILE)
|
|
|
|
ifeq (,$(FLASHFILE))
|
|
$(error FLASHFILE is not defined for this board: $(FLASHFILE))
|
|
endif
|
|
|
|
# By default always build ELFFILE, BINFILE and FLASHFILE
|
|
ifeq ($(RIOT_CI_BUILD),1)
|
|
# Don't build BINFILE on the CI to save some computation time
|
|
BUILD_FILES += $(ELFFILE) $(FLASHFILE)
|
|
else
|
|
BUILD_FILES += $(ELFFILE) $(BINFILE) $(FLASHFILE)
|
|
endif
|
|
|
|
# variables used to compile and link c++
|
|
ifneq (,$(filter cpp,$(USEMODULE)))
|
|
CPPMIX ?= 1
|
|
endif
|
|
|
|
# We assume $(LINK) to be gcc-like. Use `LINKFLAGPREFIX :=` for ld-like linker options.
|
|
LINKFLAGPREFIX ?= -Wl,
|
|
|
|
# Also build external modules
|
|
DIRS += $(EXTERNAL_MODULE_PATHS)
|
|
|
|
# Define dependencies required for building (headers, downloading source files,)
|
|
BUILDDEPS += $(RIOTBUILD_CONFIG_HEADER_C)
|
|
BUILDDEPS += pkg-prepare
|
|
BUILDDEPS += $(APPDEPS)
|
|
BUILDDEPS += $(MODULE_LIST_DIR)
|
|
|
|
# Save value to verify it is not modified later
|
|
_BASELIBS_VALUE_BEFORE_USAGE := $(BASELIBS)
|
|
|
|
# Linker rule
|
|
# Only use --start-group when archives are defined
|
|
ARCHIVES_GROUP = $(if $(ARCHIVES),$(LINKFLAGPREFIX)--start-group $(ARCHIVES) -lm $(LINKFLAGPREFIX)--end-group, -lm)
|
|
|
|
$(ELFFILE): FORCE
|
|
ifeq ($(BUILDOSXNATIVE),1)
|
|
_LINK = $(if $(CPPMIX),$(LINKXX),$(LINK)) $$(find $(BASELIBS:%.module=$(BINDIR)/%/) -name "*.o" 2> /dev/null | sort) $(ARCHIVES_GROUP) $(LINKFLAGS) $(LINKFLAGPREFIX)-no_pie
|
|
else
|
|
_LINK = $(if $(CPPMIX),$(LINKXX),$(LINK)) $$(find $(BASELIBS:%.module=$(BINDIR)/%/) -name "*.o" 2> /dev/null | sort) $(ARCHIVES_GROUP) $(LINKFLAGS) $(LINKFLAGPREFIX)-Map=$(BINDIR)/$(APPLICATION).map
|
|
endif # BUILDOSXNATIVE
|
|
|
|
ifeq ($(BUILD_IN_DOCKER),1)
|
|
link: ..in-docker-container
|
|
else
|
|
ifeq (,$(RIOTNOLINK))
|
|
link: ..compiler-check ..build-message $(BUILD_FILES) print-size ..module-check
|
|
else
|
|
link: ..compiler-check ..build-message $(BASELIBS) $(ARCHIVES) ..module-check
|
|
endif # RIOTNOLINK
|
|
|
|
$(ELFFILE): $(BASELIBS) $(ARCHIVES)
|
|
$(Q)$(_LINK) -o $@
|
|
|
|
.PHONY: $(APPLICATION_MODULE).module
|
|
|
|
..module-check: $(BASELIBS)
|
|
@[ -z "$(strip $(NON_GENERATED_MODULES))" ] || \
|
|
($(COLOR_ECHO) "$(COLOR_RED)Error - using unknown modules: $(COLOR_RESET)$(NON_GENERATED_MODULES)" && false)
|
|
|
|
$(APPLICATION_MODULE).module: pkg-build $(BUILDDEPS)
|
|
$(Q)DIRS="$(DIRS)" APPLICATION_BLOBS="$(BLOBS)" \
|
|
"$(MAKE)" -C $(APPDIR) -f $(RIOTMAKE)/application.inc.mk
|
|
$(APPLICATION_MODULE).module: FORCE
|
|
|
|
COMPILE_COMMANDS_PATH ?= $(RIOTBASE)/compile_commands.json
|
|
COMPILE_COMMANDS_FLAGS ?= --clangd
|
|
.PHONY: compile-commands
|
|
compile-commands: $(BUILDDEPS)
|
|
$(Q)DIRS="$(DIRS)" APPLICATION_BLOBS="$(BLOBS)" \
|
|
"$(MAKE)" -C $(APPDIR) -f $(RIOTMAKE)/application.inc.mk compile-commands
|
|
$(Q)$(RIOTTOOLS)/compile_commands/compile_commands.py $(COMPILE_COMMANDS_FLAGS) $(BINDIR) \
|
|
> $(COMPILE_COMMANDS_PATH)
|
|
|
|
# Other modules are built by application.inc.mk and packages building
|
|
_SUBMAKE_LIBS = $(filter-out $(APPLICATION_MODULE).module $(APPDEPS), $(BASELIBS) $(ARCHIVES))
|
|
$(_SUBMAKE_LIBS): $(APPLICATION_MODULE).module pkg-build
|
|
|
|
# 'print-size' triggers a rebuild. Use 'info-buildsize' if you do not need to rebuild.
|
|
print-size: $(ELFFILE)
|
|
$(Q)$(SIZE) $(SIZEFLAGS) $<
|
|
|
|
%.hex: %.elf
|
|
$(Q)$(OBJCOPY) $(OFLAGS) -Oihex $< $@
|
|
|
|
%.bin: %.elf
|
|
$(Q)$(OBJCOPY) $(OFLAGS) -Obinary $< $@
|
|
|
|
endif # BUILD_IN_DOCKER
|
|
|
|
# Check given command is available in the path
|
|
# check_cmd 'command' 'description'
|
|
define check_cmd
|
|
@command -v $1 >/dev/null 2>&1 || \
|
|
{ $(COLOR_ECHO) \
|
|
'$(COLOR_RED)$2 $1 is required but not found in PATH. Aborting.$(COLOR_RESET)'; \
|
|
exit 1;}
|
|
endef
|
|
|
|
# Check if setsid command is available on the system for debug target
|
|
# This is not the case on MacOSX, so it must be built on the fly
|
|
ifeq ($(OS),Darwin)
|
|
ifneq (,$(filter debug, $(MAKECMDGOALS)))
|
|
ifneq (0,$(shell command -v setsid > /dev/null 2>&1 ; echo $$?))
|
|
SETSID = $(RIOTTOOLS)/setsid/setsid
|
|
$(call target-export-variables,debug,$(SETSID))
|
|
DEBUGDEPS += $(SETSID)
|
|
endif
|
|
endif
|
|
endif
|
|
|
|
..compiler-check:
|
|
$(call check_cmd,$(CC),Compiler)
|
|
|
|
..build-message: $(if $(SHOULD_RUN_KCONFIG), check-kconfig-errors)
|
|
@$(COLOR_ECHO) '$(COLOR_GREEN)Building application "$(APPLICATION)" for "$(BOARD)" with MCU "$(MCU)".$(COLOR_RESET)'
|
|
@$(COLOR_ECHO)
|
|
|
|
# The `clean` needs to be serialized before everything else.
|
|
all $(BASELIBS) $(ARCHIVES) $(BUILDDEPS) ..in-docker-container: | $(CLEAN)
|
|
|
|
.PHONY: pkg-prepare pkg-build pkg-build-%
|
|
pkg-prepare:
|
|
-@for i in $(USEPKG) ; do "$(MAKE)" -C $(RIOTPKG)/$$i prepare ; done
|
|
|
|
pkg-build: $(USEPKG:%=pkg-build-%)
|
|
pkg-build-%: $(BUILDDEPS)
|
|
$(QQ)"$(MAKE)" -C $(RIOTPKG)/$*
|
|
|
|
clean:
|
|
ifndef MAKE_RESTARTS
|
|
-@for i in $(USEPKG) ; do "$(MAKE)" -C $(RIOTPKG)/$$i clean ; done
|
|
-@rm -rf $(BINDIR)
|
|
-@rm -rf $(SCANBUILD_OUTPUTDIR)
|
|
endif
|
|
|
|
# Remove intermediates, but keep the .elf, .hex and .map etc.
|
|
clean-intermediates:
|
|
-@for i in $(USEPKG) ; do "$(MAKE)" -C $(RIOTPKG)/$$i distclean ; done
|
|
-@rm -rf $(BINDIR)/*.a $(BINDIR)/*/
|
|
|
|
clean-pkg:
|
|
-@for i in $(USEPKG) ; do "$(MAKE)" -C $(RIOTPKG)/$$i distclean ; done
|
|
|
|
distclean:
|
|
-@for i in $(USEPKG) ; do "$(MAKE)" -C $(RIOTPKG)/$$i distclean ; done
|
|
-@rm -rf $(BINDIRBASE)
|
|
|
|
# Include PROGRAMMER_FLASH/PROGRAMMER_RESET variables
|
|
include $(RIOTMAKE)/tools/programmer.inc.mk
|
|
|
|
# Define flash-recipe with a default value
|
|
define default-flash-recipe
|
|
$(call check_cmd,$(FLASHER),Flash program)
|
|
$(PROGRAMMER_FLASH)
|
|
endef
|
|
flash-recipe ?= $(default-flash-recipe)
|
|
|
|
# Do not add dependencies to "flash" directly, use FLASHDEPS, as this is shared
|
|
# with flash-only too
|
|
|
|
flash: all $(FLASHDEPS)
|
|
$(flash-recipe)
|
|
|
|
flash-only: $(FLASHDEPS)
|
|
$(flash-recipe)
|
|
|
|
preflash: $(BUILD_BEFORE_FLASH)
|
|
$(PREFLASHER_PREFIX)$(PREFLASHER) $(PREFFLAGS)
|
|
|
|
# graphical memory usage analyzer
|
|
COSY_TOOL ?= $(PKGDIRBASE)/cosy/cosy.py
|
|
cosy: $(ELFFILE) $(COSY_TOOL)
|
|
$(COSY_TOOL) --riot-base $(RIOTBASE) $(APPDIR) $(BOARD) $(ELFFILE) $(MAPFILE)
|
|
|
|
ifneq (,$(TERMLOG)$(TERMTEE))
|
|
TERMTEE ?= | tee -a $(TERMLOG)
|
|
endif
|
|
TERMFLASHDEPS ?= $(filter flash flash-only,$(MAKECMDGOALS))
|
|
# Add TERMFLASHDEPS to TERMDEPS so it also applies to `test`
|
|
TERMDEPS += $(TERMFLASHDEPS)
|
|
termdeps: $(TERMDEPS)
|
|
|
|
term: $(TERMDEPS)
|
|
$(call check_cmd,$(TERMPROG),Terminal program)
|
|
$(TERMPROG) $(TERMFLAGS) $(TERMTEE)
|
|
|
|
# Term without the pyterm added logging
|
|
# PYTERMFLAGS must be exported for `jlink.sh term-rtt`.
|
|
cleanterm: export PYTERMFLAGS += --no-reconnect --noprefix --no-repeat-command-on-empty-line
|
|
cleanterm: $(TERMDEPS)
|
|
$(call check_cmd,$(TERMPROG),Terminal program)
|
|
$(TERMPROG) $(TERMFLAGS) $(TERMTEE)
|
|
|
|
list-ttys:
|
|
$(Q)$(RIOTTOOLS)/usb-serial/list-ttys.sh
|
|
|
|
doc:
|
|
$(MAKE) -BC $(RIOTBASE) doc
|
|
|
|
debug: $(DEBUGDEPS)
|
|
$(call check_cmd,$(DEBUGGER),Debug program)
|
|
$(DEBUGGER) $(DEBUGGER_FLAGS)
|
|
|
|
debug-server:
|
|
$(call check_cmd,$(DEBUGSERVER),Debug server program)
|
|
$(DEBUGSERVER) $(DEBUGSERVER_FLAGS)
|
|
|
|
ifeq (1,$(EMULATE))
|
|
emulate:
|
|
$(call check_cmd,$(EMULATOR),Emulation program)
|
|
$(EMULATOR) $(EMULATOR_FLAGS)
|
|
endif
|
|
|
|
reset:
|
|
$(call check_cmd,$(RESET),Reset program)
|
|
$(PROGRAMMER_RESET)
|
|
|
|
# tests related targets and variables
|
|
include $(RIOTMAKE)/tests/tests.inc.mk
|
|
|
|
.PHONY: fuzz
|
|
fuzz:
|
|
env FLASHFILE="$(FLASHFILE)" PORT="$(PORT)" TERMFLAGS="$(TERMFLAGS)" \
|
|
"$(RIOTBASE)"/dist/tools/fuzzing/afl.sh $(AFL_FLAGS)
|
|
|
|
# Default OBJDUMPFLAGS for platforms which do not specify it:
|
|
OBJDUMPFLAGS ?= -S -D -h
|
|
|
|
objdump:
|
|
$(call check_cmd,$(OBJDUMP),Objdump program)
|
|
$(OBJDUMP) $(OBJDUMPFLAGS) $(ELFFILE) | less
|
|
|
|
# inlcude clang-tidy
|
|
include $(RIOTMAKE)/clang_tidy.inc.mk
|
|
# Support Eclipse IDE.
|
|
include $(RIOTMAKE)/eclipse.inc.mk
|
|
|
|
# Export variables used throughout the whole make system:
|
|
include $(RIOTMAKE)/vars.inc.mk
|
|
|
|
# Include build targets for selected tools
|
|
include $(RIOTMAKE)/tools/targets.inc.mk
|
|
|
|
# Checks and defaults for USB Vendor and Product ID
|
|
include $(RIOTMAKE)/usb-codes.inc.mk
|
|
|
|
# Warn if the selected board and drivers don't provide all needed features:
|
|
ifneq (, $(filter all flash, $(if $(MAKECMDGOALS), $(MAKECMDGOALS), all)))
|
|
EXPECT_ERRORS :=
|
|
EXPECT_CONFLICT :=
|
|
|
|
# Test if there where dependencies against a module in DISABLE_MODULE.
|
|
ifneq (, $(filter $(DISABLE_MODULE), $(USEMODULE)))
|
|
$(shell $(COLOR_ECHO) "$(COLOR_RED)Required modules were disabled using DISABLE_MODULE:$(COLOR_RESET)"\
|
|
"$(sort $(filter $(DISABLE_MODULE), $(USEMODULE)))" 1>&2)
|
|
USEMODULE := $(filter-out $(DISABLE_MODULE), $(USEMODULE))
|
|
EXPECT_ERRORS := 1
|
|
endif
|
|
|
|
# Test if all feature requirements were met by the selected board.
|
|
ifneq (,$(FEATURES_MISSING))
|
|
$(shell $(COLOR_ECHO) "$(COLOR_RED)There are unsatisfied feature requirements:$(COLOR_RESET)"\
|
|
"$(FEATURES_MISSING)" 1>&2)
|
|
EXPECT_ERRORS := 1
|
|
endif
|
|
|
|
# Test if no feature in the requirements used is blacklisted for the selected board.
|
|
ifneq (,$(FEATURES_USED_BLACKLISTED))
|
|
$(shell $(COLOR_ECHO) "$(COLOR_RED)Some feature requirements are blacklisted:$(COLOR_RESET)"\
|
|
"$(FEATURES_USED_BLACKLISTED)" 1>&2)
|
|
EXPECT_ERRORS := 1
|
|
endif
|
|
|
|
# Test if any used feature conflict with another one.
|
|
ifneq (,$(FEATURES_CONFLICTING))
|
|
$(shell $(COLOR_ECHO) "$(COLOR_YELLOW)The following features may conflict:$(COLOR_RESET)"\
|
|
"$(FEATURES_CONFLICTING)" 1>&2)
|
|
ifneq (, $(FEATURES_CONFLICT_MSG))
|
|
$(shell $(COLOR_ECHO) "$(COLOR_YELLOW)Rationale: $(COLOR_RESET)$(FEATURES_CONFLICT_MSG)" 1>&2)
|
|
endif
|
|
EXPECT_CONFLICT := 1
|
|
endif
|
|
|
|
# If there is a whitelist, then test if the board is whitelisted.
|
|
ifneq (, $(BOARD_WHITELIST))
|
|
ifeq (, $(filter $(BOARD_WHITELIST), $(BOARD)))
|
|
$(shell $(COLOR_ECHO) "$(COLOR_RED)The selected BOARD=$(BOARD) is not whitelisted:$(COLOR_RESET) $(BOARD_WHITELIST)" 1>&2)
|
|
EXPECT_ERRORS := 1
|
|
endif
|
|
endif
|
|
|
|
# If there is a blacklist, then test if the board is blacklisted.
|
|
ifneq (, $(BOARD_BLACKLIST))
|
|
ifneq (, $(filter $(BOARD_BLACKLIST), $(BOARD)))
|
|
$(shell $(COLOR_ECHO) "$(COLOR_RED)The selected BOARD=$(BOARD) is blacklisted:$(COLOR_RESET) $(BOARD_BLACKLIST)" 1>&2)
|
|
EXPECT_ERRORS := 1
|
|
endif
|
|
endif
|
|
|
|
# test if toolchain is supported.
|
|
ifeq (,$(filter $(TOOLCHAIN),$(TOOLCHAINS_SUPPORTED)))
|
|
$(shell $(COLOR_ECHO) "$(COLOR_RED)The selected TOOLCHAIN=$(TOOLCHAIN) is not supported.$(COLOR_RESET)\nSupported toolchains: $(TOOLCHAINS_SUPPORTED)" 1>&2)
|
|
EXPECT_ERRORS := 1
|
|
endif
|
|
|
|
# If there is a blacklist, then test if the board is blacklisted.
|
|
ifneq (,$(TOOLCHAINS_BLACKLIST))
|
|
ifneq (,$(filter $(TOOLCHAIN),$(TOOLCHAINS_BLACKLIST)))
|
|
$(shell $(COLOR_ECHO) "$(COLOR_RED)The selected TOOLCHAIN=$(TOOLCHAIN) is blacklisted:$(COLOR_RESET) $(TOOLCHAINS_BLACKLIST)" 1>&2)
|
|
EXPECT_ERRORS := 1
|
|
endif
|
|
endif
|
|
|
|
ifneq (, $(EXPECT_CONFLICT))
|
|
$(shell $(COLOR_ECHO) "\n$(COLOR_YELLOW)EXPECT undesired behaviour!$(COLOR_RESET)" 1>&2)
|
|
endif
|
|
|
|
# Fail by default when errors are expected
|
|
CONTINUE_ON_EXPECTED_ERRORS ?= 0
|
|
ifneq (, $(EXPECT_ERRORS))
|
|
ifneq (1,$(CONTINUE_ON_EXPECTED_ERRORS))
|
|
$(error You can let the build continue on expected errors by setting CONTINUE_ON_EXPECTED_ERRORS=1 to the command line)
|
|
endif
|
|
$(shell $(COLOR_ECHO) "\n\n$(COLOR_RED)EXPECT ERRORS!$(COLOR_RESET)\n\n" 1>&2)
|
|
endif
|
|
|
|
endif
|
|
|
|
help:
|
|
@$(MAKE) -qp | sed -ne 's/\(^[a-z][a-z_-]*\):.*/\1/p' | sort | uniq
|
|
|
|
ifeq (iotlab-m3,$(BOARD))
|
|
ifneq (,$(filter iotlab-%,$(MAKECMDGOALS)))
|
|
include $(RIOTBASE)/dist/testbed-support/Makefile.iotlab
|
|
endif
|
|
endif
|
|
|
|
ifneq (,$(filter openv-%,$(MAKECMDGOALS)))
|
|
include $(RIOTBASE)/dist/tools/openvisualizer/makefile.openvisualizer.inc.mk
|
|
endif
|
|
|
|
# Include desvirt Makefile
|
|
include $(RIOTTOOLS)/desvirt/Makefile.desvirt
|
|
|
|
# Build a header file with all common macro definitions and undefinitions
|
|
# Everytime the header is updated, it will trigger a new compilation.
|
|
#
|
|
# The file is created first through a `.in` file that will be modified if
|
|
# any CFLAGS changed. It depends on FORCE to re-run of the script every time
|
|
# even if the file exists but the file will only be updated on modifications.
|
|
#
|
|
# The header is then created by keeping only the macros. Keeping the
|
|
# comments added absolute path in the file that screwed caching.
|
|
#
|
|
# The rebuild behavior could even only be done with an empty file, but currently
|
|
# some macros definitions are passed through this file.
|
|
$(RIOTBUILD_CONFIG_HEADER_C): $(RIOTBUILD_CONFIG_HEADER_C).in
|
|
$(Q)sed -n -e '1i\
|
|
/* Generated file do not edit */' -e '/^#.*/ p' $< > $@
|
|
|
|
.SECONDARY: $(RIOTBUILD_CONFIG_HEADER_C).in
|
|
$(RIOTBUILD_CONFIG_HEADER_C).in: FORCE | $(CLEAN)
|
|
@mkdir -p '$(dir $@)'
|
|
$(Q)'$(RIOTTOOLS)/genconfigheader/genconfigheader.sh' $(CFLAGS_WITH_MACROS) \
|
|
| '$(LAZYSPONGE)' $(LAZYSPONGE_FLAGS) '$@'
|
|
|
|
CFLAGS_WITH_MACROS += $(CFLAGS)
|
|
CFLAGS_WITH_MACROS += -DRIOT_VERSION=\"$(RIOT_VERSION)\"
|
|
CFLAGS_WITH_MACROS += -DRIOT_VERSION_CODE=$(RIOT_VERSION_CODE)
|
|
# MODULE_NAME defines. Declared in 'makefiles/modules.inc.mk'
|
|
CFLAGS_WITH_MACROS += $(EXTDEFINES)
|
|
|
|
CFLAGS += -include '$(RIOTBUILD_CONFIG_HEADER_C)'
|
|
|
|
# include mcuboot support
|
|
include $(RIOTMAKE)/mcuboot.mk
|
|
|
|
# include Murdock helpers
|
|
include $(RIOTMAKE)/murdock.inc.mk
|
|
|
|
# Sanity check, 'all' should be the default goal
|
|
ifneq (all, $(.DEFAULT_GOAL))
|
|
$(error .DEFAULT_GOAL := $(.DEFAULT_GOAL))
|
|
endif
|
|
|
|
|
|
# Detect if BASELIBS changed since its first use
|
|
ifneq ($(_BASELIBS_VALUE_BEFORE_USAGE),$(BASELIBS))
|
|
$(warning $(sort $(filter-out $(_BASELIBS_VALUE_BEFORE_USAGE), $(BASELIBS)) \
|
|
$(filter-out $(BASELIBS), $(_BASELIBS_VALUE_BEFORE_USAGE))))
|
|
$(error BASELIBS value changed)
|
|
endif
|
|
|
|
endif
|
|
|
|
# include RIOT_MAKEFILES_GLOBAL_POST configuration files
|
|
# allows setting user specific system wide configuration parsed after the body
|
|
# of $(RIOTBASE)/Makefile.include
|
|
include $(RIOT_MAKEFILES_GLOBAL_POST)
|