mirror of
https://github.com/RIOT-OS/RIOT.git
synced 2024-12-29 04:50:03 +01:00
267c8e1620
When mixing C and C++ code, $(CXX) has to be used for linking. Prior to this commit, the build system automatically uses $(CXX) if the application contains C++ source code. However, if C++ is used in an module only, $(CC) is still used. This has not let to problems, as internal modules must be written in C. For external modules this restriction does not apply. This commit checks if the cpp feature is used. In that case, $(CXX) is used for linking over $(CC). This way external modules may use C++ code.
965 lines
32 KiB
Makefile
965 lines
32 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
|
|
|
|
# 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
|
|
|
|
# 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 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 ($(origin EXTERNAL_BOARD_DIRS),command line)
|
|
# In Docker absolute paths are always given, so only fail when not in docker
|
|
ifeq ($(INSIDE_DOCKER),0)
|
|
$(error EXTERNAL_BOARD_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
|
|
|
|
ifneq (,$(BOARDSDIR))
|
|
# Only warn users, not the CI.
|
|
ifneq ($(RIOT_CI_BUILD),1)
|
|
# Do not warn when set from sub-make
|
|
ifeq ($(MAKELEVEL),0)
|
|
$(warning Using BOARDSDIR is deprecated use EXTERNAL_BOARD_DIRS instead)
|
|
$(info EXTERNAL_BOARD_DIRS can contain multiple folders separated by space)
|
|
endif
|
|
endif
|
|
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)))
|
|
|
|
# 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)/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
|
|
|
|
GLOBAL_GOALS += buildtest \
|
|
buildtest-indocker \
|
|
info-boards-features-blacklisted \
|
|
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
|
|
|
|
# Include Kconfig functionalities
|
|
include $(RIOTMAKE)/kconfig.mk
|
|
|
|
ifeq ($(OS),Darwin)
|
|
OPEN := open
|
|
else
|
|
OPEN := xdg-open
|
|
endif
|
|
|
|
QUIET ?= 1
|
|
|
|
ifeq ($(QUIET),1)
|
|
Q=@
|
|
MAKEFLAGS += --no-print-directory
|
|
else
|
|
Q=
|
|
endif
|
|
|
|
QQ=
|
|
|
|
# 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
|
|
|
|
# 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 2>&1 > /dev/null ; echo $$?))
|
|
WGET := $(shell which wget)
|
|
endif
|
|
endif
|
|
ifeq (,$(CURL))
|
|
ifeq (0,$(shell which curl 2>&1 > /dev/null ; echo $$?))
|
|
CURL := $(shell which curl)
|
|
endif
|
|
endif
|
|
ifeq (,$(WGET)$(CURL))
|
|
$(error 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 2>&1 > /dev/null ; echo $$?))
|
|
UNZIP_HERE := $(shell which unzip) -q
|
|
else
|
|
ifeq (0,$(shell which 7z 2>&1 > /dev/null ; echo $$?))
|
|
UNZIP_HERE := $(shell which 7z) x -bd
|
|
else
|
|
$(error 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
|
|
|
|
# Use TOOLCHAIN environment variable to select the toolchain to use.
|
|
# Default for macOS: llvm; for other OS: gnu
|
|
ifeq ($(BOARD),native)
|
|
ifeq ($(OS),Darwin)
|
|
TOOLCHAIN ?= llvm
|
|
endif
|
|
endif
|
|
TOOLCHAIN ?= gnu
|
|
|
|
# TOOLCHAIN = clang is an alias for TOOLCHAIN = llvm
|
|
ifeq (clang,$(TOOLCHAIN))
|
|
# use override so that we can redefine a variable set on the command line (as
|
|
# opposed to one set in the environment)
|
|
override TOOLCHAIN := llvm
|
|
endif
|
|
# TOOLCHAIN = gcc is an alias for TOOLCHAIN = gnu
|
|
ifeq (gcc,$(TOOLCHAIN))
|
|
# use override so that we can redefine a variable set on the command line (as
|
|
# opposed to one set in the environment)
|
|
override TOOLCHAIN := gnu
|
|
endif
|
|
|
|
ifeq (,$(TOOLCHAIN))
|
|
override TOOLCHAIN := gnu
|
|
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
|
|
|
|
# handle removal of default modules
|
|
USEMODULE += $(filter-out $(DISABLE_MODULE), $(DEFAULT_MODULE))
|
|
|
|
# process dependencies
|
|
include $(RIOTMAKE)/dependency_resolution.inc.mk
|
|
|
|
# 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
|
|
|
|
# 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
|
|
|
|
# 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
|
|
ifneq ($(filter $(BOARD_INSUFFICIENT_MEMORY), $(BOARD)),)
|
|
$(info CI-build: skipping link step)
|
|
RIOTNOLINK:=1
|
|
endif
|
|
# be more quiet when building for CI
|
|
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)
|
|
|
|
# OSX fails to create empty archives. Provide a wrapper to catch that error.
|
|
ifneq (0, $(shell mkdir -p $(BINDIR); $(AR) rc $(BINDIR)/empty-archive.a 2> /dev/null; \
|
|
echo $$?; rm -f $(BINDIR)/empty-archive.a 2>&1 > /dev/null))
|
|
AR := $(RIOTBASE)/dist/ar-wrapper $(AR)
|
|
endif
|
|
|
|
# Feature test default CFLAGS and LINKFLAGS for the set compiled.
|
|
include $(RIOTMAKE)/cflags.inc.mk
|
|
|
|
# Include VERSION for releases
|
|
-include $(RIOTBASE)/VERSION
|
|
|
|
include $(RIOTMAKE)/git_version.inc.mk
|
|
RIOT_VERSION ?= $(or $(GIT_VERSION),'UNKNOWN (builddir: $(RIOTBASE))')
|
|
|
|
# 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
|
|
|
|
# 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 += $(BINDIR)/$(APPLICATION_MODULE).a
|
|
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_DIRS:%=%/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
|
|
.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 serial and flasher
|
|
include $(RIOTBASE)/dist/testbed-support/makefile.iotlab.single.inc.mk
|
|
endif
|
|
|
|
ELFFILE ?= $(BINDIR)/$(APPLICATION).elf
|
|
HEXFILE ?= $(ELFFILE:.elf=.hex)
|
|
BINFILE ?= $(ELFFILE:.elf=.bin)
|
|
|
|
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,$(FEATURES_USED)))
|
|
CPPMIX ?= 1
|
|
endif
|
|
|
|
# We assume $(LINK) to be gcc-like. Use `LINKFLAGPREFIX :=` for ld-like linker options.
|
|
LINKFLAGPREFIX ?= -Wl,
|
|
|
|
DIRS += $(EXTERNAL_MODULE_DIRS)
|
|
|
|
# Define dependencies required for building (headers, downloading source files,)
|
|
BUILDDEPS += $(RIOTBUILD_CONFIG_HEADER_C)
|
|
BUILDDEPS += pkg-prepare
|
|
BUILDDEPS += $(APPDEPS)
|
|
|
|
# Save value to verify it is not modified later
|
|
_BASELIBS_VALUE_BEFORE_USAGE := $(BASELIBS)
|
|
|
|
# Linker rule
|
|
$(ELFFILE): FORCE
|
|
ifeq ($(BUILDOSXNATIVE),1)
|
|
_LINK = $(if $(CPPMIX),$(LINKXX),$(LINK)) $(UNDEF) $$(find $(BASELIBS) -size +8c) $(LINKFLAGS) $(LINKFLAGPREFIX)-no_pie
|
|
else
|
|
_LINK = $(if $(CPPMIX),$(LINKXX),$(LINK)) $(UNDEF) $(LINKFLAGPREFIX)--start-group $(BASELIBS) -lm $(LINKFLAGPREFIX)--end-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
|
|
else
|
|
link: ..compiler-check ..build-message $(BASELIBS)
|
|
endif # RIOTNOLINK
|
|
|
|
$(ELFFILE): $(BASELIBS)
|
|
$(Q)$(_LINK) -o $@
|
|
|
|
$(BINDIR)/$(APPLICATION_MODULE).a: pkg-build $(BUILDDEPS)
|
|
$(Q)DIRS="$(DIRS)" APPLICATION_BLOBS="$(BLOBS)" \
|
|
"$(MAKE)" -C $(APPDIR) -f $(RIOTMAKE)/application.inc.mk
|
|
$(BINDIR)/$(APPLICATION_MODULE).a: FORCE
|
|
|
|
# Other modules are built by application.inc.mk and packages building
|
|
_SUBMAKE_LIBS = $(filter-out $(BINDIR)/$(APPLICATION_MODULE).a $(APPDEPS), $(BASELIBS))
|
|
$(_SUBMAKE_LIBS): $(BINDIR)/$(APPLICATION_MODULE).a 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
|
|
|
|
# Rules to check the correctness of thin archives.
|
|
|
|
# OS independant relpath as 'realpath --relative-to' is not supported on OSx
|
|
relpath = $(shell python3 -c 'import pathlib; print(pathlib.Path("$1").relative_to("$(CURDIR)"))')
|
|
|
|
# Each ARCHECK file contains all the absolute paths found inside the archive.
|
|
BASELIB_ARCHECKS = $(patsubst %.a,%.a-check,$(filter %.a,$(BASELIBS)))
|
|
|
|
# For each a file, print the absolute paths found inside it
|
|
# If "ar t" is called with an absolute path it will print an abs path regardless
|
|
# of how the archive is internally
|
|
# In case of a malformed archive, ar prints to stderr (and sets an error code).
|
|
# Doing `2>&1` is hacky, the correct thing would be to get the exit code.
|
|
# The `| %.a` is necessary to be able to check file produced in docker.
|
|
%.a-check: %.a
|
|
$(Q)$(AR) t $(call relpath,$<) 2>&1 | grep '^/' | '$(LAZYSPONGE)' $(LAZYSPONGE_FLAGS) '$@'
|
|
|
|
# There's no point on keeping files whose content is later copied to another file
|
|
.INTERMEDIATE: $(BASELIB_ARCHECKS)
|
|
|
|
ARCHIVE_CHECK = $(BINDIR)/$(APPLICATION).archive-check
|
|
|
|
$(ARCHIVE_CHECK): $(BASELIB_ARCHECKS)
|
|
$(Q)cat $^ | '$(LAZYSPONGE)' $(LAZYSPONGE_FLAGS) '$@'
|
|
|
|
# Rule to check if thin archives are correctly produced, that is, with a correct
|
|
# relative path.
|
|
ifeq ($(BUILD_IN_DOCKER),1)
|
|
archive-check: ..in-docker-container
|
|
else
|
|
archive-check: $(ARCHIVE_CHECK) FORCE
|
|
@if [ -s '$<' ] ; then \
|
|
$(COLOR_ECHO) '$(COLOR_RED)Found the following absolute paths in archives' ;\
|
|
cat '$<';\
|
|
$(COLOR_ECHO) '$(COLOR_RESET)' ;\
|
|
exit 1;\
|
|
elif [ -f '$<' ] ; then \
|
|
$(COLOR_ECHO) '$(COLOR_GREEN)Archives correctly formed$(COLOR_RESET)' ;\
|
|
else \
|
|
$(COLOR_ECHO) '$(COLOR_RED)Unexpected error (file not found)$(COLOR_RESET)' ;\
|
|
exit 1;\
|
|
fi
|
|
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
|
|
ifneq (,$(filter debug, $(MAKECMDGOALS)))
|
|
ifneq (0,$(shell which setsid 2>&1 > /dev/null ; echo $$?))
|
|
SETSID = $(RIOTTOOLS)/setsid/setsid
|
|
$(call target-export-variables,debug,$(SETSID))
|
|
DEBUGDEPS += $(SETSID)
|
|
endif
|
|
endif
|
|
|
|
..compiler-check:
|
|
$(call check_cmd,$(CC),Compiler)
|
|
|
|
..build-message:
|
|
@$(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) $(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:
|
|
-@for i in $(USEPKG) ; do "$(MAKE)" -C $(RIOTPKG)/$$i clean ; done
|
|
-@rm -rf $(BINDIR)
|
|
-@rm -rf $(SCANBUILD_OUTPUTDIR)
|
|
|
|
# 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)
|
|
|
|
# Define flash-recipe with a default value
|
|
define default-flash-recipe
|
|
$(call check_cmd,$(FLASHER),Flash program)
|
|
$(FLASHER) $(FFLAGS)
|
|
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)
|
|
|
|
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)
|
|
|
|
# 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)
|
|
|
|
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)
|
|
|
|
emulate:
|
|
$(call check_cmd,$(EMULATOR),Emulation program)
|
|
$(EMULATOR) $(EMULATOR_FLAGS)
|
|
|
|
reset:
|
|
$(call check_cmd,$(RESET),Reset program)
|
|
$(RESET) $(RESET_FLAGS)
|
|
|
|
.PHONY: test test/available
|
|
TESTS ?= $(foreach file,$(wildcard $(APPDIR)/tests/*[^~]),\
|
|
$(shell test -f $(file) -a -x $(file) && echo $(file)))
|
|
|
|
# "make test" calls "make term" which would implicitly build it's dependencies,
|
|
# but that increases the time "make test" needs to get ready. That can cause
|
|
# problems ("make term" missing some lines) as terminal startup is not properly
|
|
# sychronized, but depends on a static timeout (TESTRUNNER_START_DELAY).
|
|
# Murdock builds the term dependencies before running "make test" to circumvent
|
|
# this. In order to make local builds behave similar, add the term deps here.
|
|
# See #11762.
|
|
TEST_DEPS += $(TERMDEPS)
|
|
|
|
# Export TESTRUNNER_RESET_AFTER_TERM only for the test target. This allows for
|
|
# it to be accessed through the environment from python test script.
|
|
# This is currently needed only by `examples/%/tests` and should be removed in
|
|
# the future since `make reset` after `term` is not a valid synch method across
|
|
# all platforms.
|
|
$(call target-export-variables,test,TESTRUNNER_RESET_AFTER_TERM)
|
|
test: $(TEST_DEPS)
|
|
$(Q) for t in $(TESTS); do \
|
|
$$t || exit 1; \
|
|
done
|
|
|
|
test/available:
|
|
$(Q)test -n "$(strip $(TESTS))"
|
|
|
|
# this target only makes sense if an ELFFILE is actually created, thus guard by
|
|
# RIOTNOLINK="".
|
|
ifeq (,$(RIOTNOLINK))
|
|
test-input-hash: $(TESTS) $(ELFFILE) $(TEST_EXTRA_FILES)
|
|
sha1sum $^ > $(BINDIR)/test-input-hash.sha1
|
|
else
|
|
test-input-hash:
|
|
true
|
|
endif
|
|
|
|
.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
|
|
|
|
# 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)\"
|
|
# 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)
|