162da1169e
Add new option -A is added to tools/testbuild.sh that will take the created build executable and store it in a folder for the config that generated it under $ARTIFACTDIR which can be set via an environment variable or defaulted to $(TOPDIR)/buildartifacts This is also helpful for local testing because you can now run tools/testbuild.sh -A sim.dat and have all of the simulation targets generated without having to rebuild along the way. In the GitHub Actions workflow the artifacs are uploaded two two bundles one for macOS and one for Linux Signed-off-by: Brennan Ashton <bashton@brennanashton.com>
564 lines
21 KiB
Makefile
564 lines
21 KiB
Makefile
############################################################################
|
|
# tools/Makefile.win
|
|
#
|
|
# Licensed to the Apache Software Foundation (ASF) under one or more
|
|
# contributor license agreements. See the NOTICE file distributed with
|
|
# this work for additional information regarding copyright ownership. The
|
|
# ASF licenses this file to you under the Apache License, Version 2.0 (the
|
|
# "License"); you may not use this file except in compliance with the
|
|
# License. You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
# License for the specific language governing permissions and limitations
|
|
# under the License.
|
|
#
|
|
############################################################################
|
|
|
|
export SHELL=cmd
|
|
|
|
export TOPDIR := ${shell echo %CD%}
|
|
include $(TOPDIR)\Make.defs
|
|
-include $(TOPDIR)\.version
|
|
|
|
# In case .version file does not exist
|
|
|
|
CONFIG_VERSION_STRING ?= "0.0.0"
|
|
CONFIG_VERSION_MAJOR ?= 0
|
|
CONFIG_VERSION_MINOR ?= 0
|
|
CONFIG_VERSION_PATCH ?= 0
|
|
CONFIG_VERSION_BUILD ?= "0"
|
|
|
|
# Process architecture and board-specific directories
|
|
|
|
ARCH_DIR = arch\$(CONFIG_ARCH)
|
|
ARCH_SRC = $(ARCH_DIR)\src
|
|
ARCH_INC = $(ARCH_DIR)\include
|
|
|
|
# CONFIG_APPS_DIR can be over-ridden from the command line or in the .config file.
|
|
# The default value of CONFIG_APPS_DIR is ..\apps. Ultimately, the application
|
|
# will be built if APPDIR is defined. APPDIR will be defined if a directory containing
|
|
# a Makefile is found at the path provided by CONFIG_APPS_DIR
|
|
|
|
ifeq ($(CONFIG_APPS_DIR),)
|
|
CONFIG_APPS_DIR = ..\apps
|
|
endif
|
|
APPDIR := $(realpath ${shell if exist "$(CONFIG_APPS_DIR)\Makefile" echo $(CONFIG_APPS_DIR)})
|
|
|
|
# External code support
|
|
# If external/ contains a Kconfig, we define the EXTERNALDIR variable to 'external'
|
|
# so that main Kconfig can find it. Otherwise, we redirect it to a dummy Kconfig
|
|
# This is due to kconfig inability to do conditional inclusion.
|
|
|
|
EXTERNALDIR := $(shell if [ -r $(TOPDIR)\external\Kconfig ]; then echo 'external'; else echo 'dummy'; fi)
|
|
|
|
# CONTEXTDIRS include directories that have special, one-time pre-build
|
|
# requirements. Normally this includes things like auto-generation of
|
|
# configuration specific files or creation of configurable symbolic links
|
|
# CLEANDIRS are the directories that the clean target will executed in.
|
|
# These are all directories that we know about.
|
|
# CCLEANDIRS are directories that the clean_context target will execute in.
|
|
# The clean_context target "undoes" the actions of the context target.
|
|
# Only directories known to require cleaning are included.
|
|
# KERNDEPDIRS are the directories in which we will build target dependencies.
|
|
# If NuttX and applications are built separately (CONFIG_BUILD_PROTECTED or
|
|
# CONFIG_BUILD_KERNEL), then this holds only the directories containing
|
|
# kernel files.
|
|
# USERDEPDIRS. If NuttX and applications are built separately (CONFIG_BUILD_PROTECTED),
|
|
# then this holds only the directories containing user files. If
|
|
# CONFIG_BUILD_KERNEL is selected, then applications are not build at all.
|
|
|
|
include tools\Directories.mk
|
|
|
|
#
|
|
# Extra objects used in the final link.
|
|
#
|
|
# Pass 1 Incremental (relative) link objects should be put into the
|
|
# processor-specific source directory (where other link objects will
|
|
# be created). If the pass1 object is an archive, it could go anywhere.
|
|
|
|
ifeq ($(CONFIG_BUILD_2PASS),y)
|
|
EXTRA_OBJS += $(CONFIG_PASS1_OBJECT)
|
|
endif
|
|
|
|
# Library build selections
|
|
#
|
|
# NUTTXLIBS is the list of NuttX libraries that is passed to the
|
|
# processor-specific Makefile to build the final NuttX target.
|
|
# USERLIBS is the list of libraries used to build the final user-space
|
|
# application
|
|
# EXPORTLIBS is the list of libraries that should be exported by
|
|
# 'make export' is
|
|
|
|
ifeq ($(CONFIG_BUILD_PROTECTED),y)
|
|
include tools\ProtectedLibs.mk
|
|
else ifeq ($(CONFIG_BUILD_KERNEL),y)
|
|
include tools\KernelLibs.mk
|
|
else
|
|
include tools\FlatLibs.mk
|
|
endif
|
|
|
|
# LINKLIBS derives from NUTTXLIBS and is simply the same list with the
|
|
# subdirectory removed
|
|
|
|
LINKLIBS = $(patsubst staging\\%,%,$(NUTTXLIBS))
|
|
|
|
# Export tool definitions
|
|
|
|
MKEXPORT = tools\mkexport.bat
|
|
MKEXPORT_ARGS = -t "$(TOPDIR)"
|
|
|
|
ifneq ($(CONFIG_BUILD_FLAT),y)
|
|
MKEXPORT_ARGS += -u
|
|
endif
|
|
|
|
ifneq ($(APPDIR),)
|
|
ifneq ($(shell [ -e $(APPDIR)/Makefile ] && echo yes),)
|
|
MKEXPORT_ARGS += -a "$(APPDIR)"
|
|
MKEXPORT_ARGS += -m "$(MAKE)"
|
|
endif
|
|
endif
|
|
|
|
ifeq ($(V),2)
|
|
MKEXPORT_ARGS += -d
|
|
endif
|
|
|
|
# This is the name of the final target (relative to the top level directory)
|
|
|
|
NUTTXNAME = nuttx
|
|
BIN = $(NUTTXNAME)$(EXEEXT)
|
|
|
|
all: $(BIN)
|
|
.PHONY: dirlinks context clean_context configenv config oldconfig menuconfig nconfig export subdir_clean clean subdir_distclean distclean apps_clean apps_distclean
|
|
.PHONY: pass1 pass1dep
|
|
.PHONY: pass2 pass2dep
|
|
|
|
# Target used to copy include\nuttx\math.h. If CONFIG_ARCH_MATH_H is
|
|
# defined, then there is an architecture specific math.h header file
|
|
# that will be included indirectly from include\math.h. But first, we
|
|
# have to copy math.h from include\nuttx\. to include\. Logic within
|
|
# include\nuttx\math.h will hand the redirection to the architecture-
|
|
# specific math.h header file.
|
|
#
|
|
# If the CONFIG_LIBM is defined, the Rhombus libm will be built at libc\math.
|
|
# Definitions and prototypes for the Rhombus libm are also contained in
|
|
# include\nuttx\math.h and so the file must also be copied in that case.
|
|
#
|
|
# If neither CONFIG_ARCH_MATH_H nor CONFIG_LIBM is defined, then no math.h
|
|
# header file will be provided. You would want that behavior if (1) you
|
|
# don't use libm, or (2) you want to use the math.h and libm provided
|
|
# within your toolchain.
|
|
|
|
ifeq ($(CONFIG_ARCH_MATH_H),y)
|
|
NEED_MATH_H = y
|
|
else ifeq ($(CONFIG_LIBM),y)
|
|
NEED_MATH_H = y
|
|
endif
|
|
|
|
ifeq ($(NEED_MATH_H),y)
|
|
include\math.h: include\nuttx\math.h .clean_context
|
|
$(Q) cp -f include\nuttx\math.h include\math.h
|
|
else
|
|
include\math.h:
|
|
endif
|
|
|
|
# The float.h header file defines the properties of your floating point
|
|
# implementation. It would always be best to use your toolchain's float.h
|
|
# header file but if none is available, a default float.h header file will
|
|
# provided if this option is selected. However there is no assurance that
|
|
# the settings in this float.h are actually correct for your platform!
|
|
|
|
ifeq ($(CONFIG_ARCH_FLOAT_H),y)
|
|
include\float.h: include\nuttx\float.h .clean_context
|
|
$(Q) cp -f include\nuttx\float.h include\float.h
|
|
else
|
|
include\float.h:
|
|
endif
|
|
|
|
# Target used to copy include\nuttx\stdarg.h. If CONFIG_ARCH_STDARG_H is
|
|
# defined, then there is an architecture specific stdarg.h header file
|
|
# that will be included indirectly from include\stdarg.h. But first, we
|
|
# have to copy stdarg.h from include\nuttx\. to include\.
|
|
|
|
ifeq ($(CONFIG_ARCH_STDARG_H),y)
|
|
include\stdarg.h: include\nuttx\stdarg.h .clean_context
|
|
$(Q) cp -f include\nuttx\stdarg.h include\stdarg.h
|
|
else
|
|
include\stdarg.h:
|
|
endif
|
|
|
|
# Target used to copy include\nuttx\setjmp.h. If CONFIG_ARCH_SETJMP_H is
|
|
# defined, then there is an architecture specific setjmp.h header file
|
|
# that will be included indirectly from include\setjmp.h. But first, we
|
|
# have to copy setjmp.h from include\nuttx\. to include\.
|
|
|
|
ifeq ($(CONFIG_ARCH_SETJMP_H),y)
|
|
include\setjmp.h: include\nuttx\setjmp.h .clean_context
|
|
$(Q) cp -f include\nuttx\setjmp.h include\setjmp.h
|
|
else
|
|
include\setjmp.h:
|
|
endif
|
|
|
|
# Targets used to build include\nuttx\version.h. Creation of version.h is
|
|
# part of the overall NuttX configuration sequence. Notice that the
|
|
# tools\mkversion tool is built and used to create include\nuttx\version.h
|
|
|
|
tools\mkversion$(HOSTEXEEXT):
|
|
$(Q) $(MAKE) -C tools -f Makefile.host mkversion$(HOSTEXEEXT)
|
|
|
|
$(TOPDIR)\.version:
|
|
$(Q) echo CONFIG_VERSION_STRING="0" > .version
|
|
$(Q) echo CONFIG_VERSION_MAJOR=0 >> .version
|
|
$(Q) echo CONFIG_VERSION_MINOR=0 >> .version
|
|
$(Q) echo CONFIG_VERSION_PATCH=0 >> .version
|
|
$(Q) echo CONFIG_VERSION_BUILD="0" >> .version
|
|
|
|
include\nuttx\version.h: $(TOPDIR)\.version tools\mkversion$(HOSTEXEEXT) .clean_context
|
|
$(Q) tools\mkversion$(HOSTEXEEXT) $(TOPDIR) > include\nuttx\version.h
|
|
|
|
# Targets used to build include\nuttx\config.h. Creation of config.h is
|
|
# part of the overall NuttX configuration sequence. Notice that the
|
|
# tools\mkconfig tool is built and used to create include\nuttx\config.h
|
|
|
|
tools\mkconfig$(HOSTEXEEXT):
|
|
$(Q) $(MAKE) -C tools -f Makefile.host mkconfig$(HOSTEXEEXT)
|
|
|
|
include\nuttx\config.h: $(TOPDIR)\.config tools\mkconfig$(HOSTEXEEXT) .clean_context
|
|
$(Q) tools\mkconfig$(HOSTEXEEXT) $(TOPDIR) > include\nuttx\config.h
|
|
|
|
# Targets used to create dependencies
|
|
|
|
tools\mkdeps$(HOSTEXEEXT):
|
|
$(Q) $(MAKE) -C tools -f Makefile.host mkdeps$(HOSTEXEEXT)
|
|
|
|
# dirlinks, and helpers
|
|
#
|
|
# Directories links. Most of establishing the NuttX configuration involves
|
|
# setting up symbolic links with 'generic' directory names to specific,
|
|
# configured directories.
|
|
|
|
# Link the arch\<arch-name>\include directory to include\arch
|
|
|
|
include\arch: .clean_context
|
|
@echo LN: include\arch to $(ARCH_DIR)\include
|
|
$(Q) $(DIRLINK) $(TOPDIR)\$(ARCH_DIR)\include include\arch
|
|
$(Q) touch $@
|
|
|
|
# Link the boards\<arch>\<chip>\<board>\include directory to include\arch\board
|
|
|
|
include\arch\board: include\arch
|
|
@echo LN: include\arch\board to $(BOARD_DIR)\include
|
|
$(Q) $(DIRLINK) $(BOARD_DIR)\include include\arch\board
|
|
$(Q) touch $@
|
|
|
|
ifneq ($(BOARD_COMMON_DIR),)
|
|
# Link the boards\<arch>\<chip>\common dir to arch\<arch-name>\src\board
|
|
# Link the boards\<arch>\<chip>\<board>\src dir to arch\<arch-name>\src\board\board
|
|
|
|
$(ARCH_SRC)\board: .clean_context
|
|
@echo "LN: $(ARCH_SRC)\board to $(BOARD_COMMON_DIR)"
|
|
$(Q) $(DIRLINK) $(BOARD_COMMON_DIR) $(ARCH_SRC)\board
|
|
@echo "LN: $(ARCH_SRC)\board\board to $(BOARD_DIR)\src"
|
|
$(Q) $(DIRLINK) $(BOARD_DIR)\src $(ARCH_SRC)\board\board
|
|
$(Q) touch $@
|
|
else
|
|
# Link the boards\<arch>\<chip>\<board>\src dir to arch\<arch-name>\src\board
|
|
|
|
$(ARCH_SRC)\board: .clean_context
|
|
@echo LN: $(ARCH_SRC)\board to $(BOARD_DIR)\src
|
|
$(Q) $(DIRLINK) $(BOARD_DIR)\src $(ARCH_SRC)\board
|
|
$(Q) touch $@
|
|
endif
|
|
|
|
# Link the boards\<arch>\<chip>\drivers dir to drivers\platform
|
|
|
|
drivers\platform: .clean_context
|
|
@echo LN: $(TOPDIR)\drivers\platform to $(BOARD_DRIVERS_DIR)
|
|
$(Q) $(DIRLINK) $(BOARD_DRIVERS_DIR) $(TOPDIR)\drivers\platform
|
|
$(Q) touch $@
|
|
|
|
# Link arch\<arch-name>\src\<chip-name> to arch\<arch-name>\src\chip
|
|
|
|
$(ARCH_SRC)\chip: .clean_context
|
|
ifeq ($(CONFIG_ARCH_CHIP_CUSTOM),y)
|
|
@echo LN: $(ARCH_SRC)\chip to $(CHIP_DIR)
|
|
$(Q) $(DIRLINK) $(CHIP_DIR) $(ARCH_SRC)\chip
|
|
else ifneq ($(CONFIG_ARCH_CHIP),)
|
|
@echo LN: $(ARCH_SRC)\chip to $(ARCH_SRC)\$(CONFIG_ARCH_CHIP)
|
|
$(Q) $(DIRLINK) $(TOPDIR)\$(ARCH_SRC)\$(CONFIG_ARCH_CHIP) $(ARCH_SRC)\chip
|
|
endif
|
|
$(Q) cp -f $(CHIP_KCONFIG) $(TOPDIR)\arch\dummy\Kconfig
|
|
$(Q) touch $@
|
|
|
|
# Link arch\<arch-name>\include\<chip-name> to arch\<arch-name>\include\chip
|
|
|
|
include\arch\chip: include\arch
|
|
ifeq ($(CONFIG_ARCH_CHIP_CUSTOM),y)
|
|
@echo LN: include\arch\chip to $(CHIP_DIR)\include
|
|
$(Q) $(DIRLINK) $(CHIP_DIR)\include include\arch\chip
|
|
else ifneq ($(CONFIG_ARCH_CHIP),)
|
|
@echo LN: include\arch\chip to $(ARCH_INC)\$(CONFIG_ARCH_CHIP)
|
|
$(Q) $(DIRLINK) $(TOPDIR)\$(ARCH_INC)\$(CONFIG_ARCH_CHIP) include\arch\chip
|
|
endif
|
|
$(Q) touch $@
|
|
|
|
dirlinks: include\arch include\arch\board include\arch\chip $(ARCH_SRC)\board $(ARCH_SRC)\chip drivers\platform
|
|
$(Q) $(MAKE) -C libs/libxx dirlinks
|
|
$(Q) $(MAKE) -C boards dirlinks
|
|
$(Q) $(MAKE) -C openamp dirlinks
|
|
$(Q) $(MAKE) -C $(CONFIG_APPS_DIR) dirlinks
|
|
|
|
# context
|
|
#
|
|
# The context target is invoked on each target build to assure that NuttX is
|
|
# properly configured. The basic configuration steps include creation of the
|
|
# the config.h and version.h header files in the include\nuttx directory and
|
|
# the establishment of symbolic links to configured directories.
|
|
|
|
context: include\nuttx\config.h include\nuttx\version.h include\math.h include\float.h include\stdarg.h include\setjmp.h dirlinks
|
|
$(Q) mkdir -p staging
|
|
$(Q) for %%G in ($(CONTEXTDIRS)) do ( $(MAKE) -C %%G context )
|
|
|
|
# clean_context
|
|
#
|
|
# This is part of the distclean target. It removes all of the header files
|
|
# and symbolic links created by the context target.
|
|
|
|
clean_context:
|
|
$(Q) for %%G in ($(CCLEANDIRS)) do ( if exist %%G\Makefile $(MAKE) -C %%G clean_context )
|
|
$(call DELFILE, include\nuttx\config.h)
|
|
$(call DELFILE, include\nuttx\version.h)
|
|
$(call DELFILE, include\float.h)
|
|
$(call DELFILE, include\math.h)
|
|
$(call DELFILE, include\stdarg.h)
|
|
$(call DELFILE, include\setjmp.h)
|
|
$(call DELFILE, arch\dummy\Kconfig)
|
|
$(call DIRUNLINK, include\arch\board)
|
|
$(call DIRUNLINK, include\arch\chip)
|
|
$(call DIRUNLINK, include\arch)
|
|
$(call DIRUNLINK, $(ARCH_SRC)\board\board)
|
|
$(call DIRUNLINK, $(ARCH_SRC)\board)
|
|
$(call DIRUNLINK, $(ARCH_SRC)\chip)
|
|
$(call DIRUNLINK, $(TOPDIR)\drivers\platform)
|
|
|
|
.clean_context: .config
|
|
+$(Q) $(MAKE) clean_context
|
|
$(Q) touch $@
|
|
|
|
# Archive targets. The target build sequence will first create a series of
|
|
# libraries, one per configured source file directory. The final NuttX
|
|
# execution will then be built from those libraries. The following targets
|
|
# build those libraries.
|
|
|
|
# pass1 and pass2
|
|
#
|
|
# If the 2 pass build option is selected, then this pass1 target is
|
|
# configured to built before the pass2 target. This pass1 target may, as an
|
|
# example, build an extra link object (CONFIG_PASS1_OBJECT) which may be an
|
|
# incremental (relative) link object, but could be a static library (archive);
|
|
# some modification to this Makefile would be required if CONFIG_PASS1_OBJECT
|
|
# is an archive. Exactly what is performed during pass1 or what it generates
|
|
# is unknown to this makefile unless CONFIG_PASS1_OBJECT is defined.
|
|
|
|
pass1: $(USERLIBS)
|
|
|
|
pass2: $(NUTTXLIBS)
|
|
|
|
# $(BIN)
|
|
#
|
|
# Create the final NuttX executable in a two pass build process. In the
|
|
# normal case, all pass1 and pass2 dependencies are created then pass1
|
|
# and pass2 targets are built. However, in some cases, you may need to build
|
|
# pass1 dependencies and pass1 first, then build pass2 dependencies and pass2.
|
|
# in that case, execute 'make pass1 pass2' from the command line.
|
|
|
|
$(BIN): pass1 pass2
|
|
ifeq ($(CONFIG_BUILD_2PASS),y)
|
|
$(Q) if [ -z "$(CONFIG_PASS1_BUILDIR)" ]; then \
|
|
echo "ERROR: CONFIG_PASS1_BUILDIR not defined"; \
|
|
exit 1; \
|
|
fi
|
|
$(Q) if [ ! -d "$(CONFIG_PASS1_BUILDIR)" ]; then \
|
|
echo "ERROR: CONFIG_PASS1_BUILDIR does not exist"; \
|
|
exit 1; \
|
|
fi
|
|
$(Q) if [ ! -f "$(CONFIG_PASS1_BUILDIR)\Makefile" ]; then \
|
|
echo "ERROR: No Makefile in CONFIG_PASS1_BUILDIR"; \
|
|
exit 1; \
|
|
fi
|
|
$(Q) $(MAKE) -C $(CONFIG_PASS1_BUILDIR) LINKLIBS="$(LINKLIBS)" USERLIBS="$(USERLIBS)" "$(CONFIG_PASS1_TARGET)"
|
|
endif
|
|
$(Q) $(MAKE) -C $(ARCH_SRC) EXTRA_OBJS="$(EXTRA_OBJS)" LINKLIBS="$(LINKLIBS)" EXTRAFLAGS="$(KDEFINE) $(EXTRAFLAGS)" $(BIN)
|
|
echo $(BIN) > $(NUTTXNAME).manifest
|
|
printf '%s\n' *.map >> $(NUTTXNAME).manifest
|
|
ifeq ($(CONFIG_INTELHEX_BINARY),y)
|
|
@echo "CP: $(NUTTXNAME).hex"
|
|
$(Q) $(OBJCOPY) $(OBJCOPYARGS) -O ihex $(BIN) $(NUTTXNAME).hex
|
|
echo $(NUTTXNAME).hex >> $(NUTTXNAME).manifest
|
|
endif
|
|
ifeq ($(CONFIG_MOTOROLA_SREC),y)
|
|
@echo "CP: $(NUTTXNAME).srec"
|
|
$(Q) $(OBJCOPY) $(OBJCOPYARGS) -O srec $(BIN) $(NUTTXNAME).srec
|
|
echo $(NUTTXNAME).srec >> $(NUTTXNAME).manifest
|
|
endif
|
|
ifeq ($(CONFIG_RAW_BINARY),y)
|
|
@echo "CP: $(NUTTXNAME).bin"
|
|
$(Q) $(OBJCOPY) $(OBJCOPYARGS) -O binary $(BIN) $(NUTTXNAME).bin
|
|
echo $(NUTTXNAME).bin >> $(NUTTXNAME).manifest
|
|
endif
|
|
$(call POSTBUILD, $(TOPDIR))
|
|
|
|
# download
|
|
#
|
|
# This is a helper target that will rebuild NuttX and download it to the target
|
|
# system in one step. The operation of this target depends completely upon
|
|
# implementation of the DOWNLOAD command in the user Make.defs file. It will
|
|
# generate an error an error if the DOWNLOAD command is not defined.
|
|
|
|
download: $(BIN)
|
|
$(call DOWNLOAD, $<)
|
|
|
|
# pass1dep: Create pass1 build dependencies
|
|
# pass2dep: Create pass2 build dependencies
|
|
|
|
pass1dep: context tools\mkdeps$(HOSTEXEEXT)
|
|
$(Q) for %%G in ($(USERDEPDIRS)) do ( $(MAKE) -C %%G depend )
|
|
|
|
pass2dep: context tools\mkdeps$(HOSTEXEEXT)
|
|
$(Q) for %%G in ($(KERNDEPDIRS)) do ( $(MAKE) -C %%G EXTRAFLAGS="$(KDEFINE) $(EXTRAFLAGS)" depend )
|
|
|
|
# Configuration targets
|
|
#
|
|
# These targets depend on the kconfig-frontends packages. To use these, you
|
|
# must first download and install the kconfig-frontends package from this
|
|
# location: https://bitbucket.org/nuttx/tools/downloads/. See
|
|
# misc\tools\README.txt for additional information.
|
|
|
|
config: apps_preconfig
|
|
$(Q) set APPSDIR=$(patsubst "%",%,${CONFIG_APPS_DIR})& set EXTERNALDIR=$(EXTERNALDIR)& kconfig-conf Kconfig
|
|
|
|
oldconfig: apps_preconfig
|
|
$(Q) set APPSDIR=$(patsubst "%",%,${CONFIG_APPS_DIR})& set EXTERNALDIR=$(EXTERNALDIR)& kconfig-conf --oldconfig Kconfig
|
|
|
|
olddefconfig: apps_preconfig
|
|
$(Q) set APPSDIR=$(patsubst "%",%,${CONFIG_APPS_DIR})& set EXTERNALDIR=$(EXTERNALDIR)& kconfig-conf --olddefconfig Kconfig
|
|
|
|
menuconfig: configenv apps_preconfig
|
|
$(Q) set APPSDIR=$(patsubst "%",%,${CONFIG_APPS_DIR})& set EXTERNALDIR=$(EXTERNALDIR)& kconfig-mconf Kconfig
|
|
|
|
nconfig: apps_preconfig
|
|
$(Q) set APPSDIR=$(patsubst "%",%,${CONFIG_APPS_DIR})& set EXTERNALDIR=$(EXTERNALDIR)& kconfig-nconf Kconfig
|
|
|
|
savedefconfig: apps_preconfig
|
|
$(Q) set APPSDIR=$(patsubst "%",%,${CONFIG_APPS_DIR})& set EXTERNALDIR=$(EXTERNALDIR)& kconfig-conf --savedefconfig defconfig.tmp Kconfig
|
|
$(Q) sed -i -e "/CONFIG_APPS_DIR=/d" defconfig.tmp
|
|
$(Q) grep "CONFIG_ARCH=" .config >> defconfig.tmp
|
|
-$(Q) grep "^CONFIG_ARCH_CHIP_" .config >> defconfig.tmp
|
|
-$(Q) grep "CONFIG_ARCH_CHIP=" .config >> defconfig.tmp
|
|
-$(Q) grep "CONFIG_ARCH_BOARD=" .config >> defconfig.tmp
|
|
-$(Q) grep "^CONFIG_ARCH_CUSTOM" .config >> defconfig.tmp
|
|
-$(Q) grep "^CONFIG_ARCH_BOARD_CUSTOM" .config >> defconfig.tmp
|
|
$(Q) export LC_ALL=C; cat defconfig.tmp | sort | uniq > sortedconfig.tmp
|
|
$(Q) echo "#" > warning.tmp
|
|
$(Q) echo "# This file is autogenerated: PLEASE DO NOT EDIT IT." >> warning.tmp
|
|
$(Q) echo "#" >> warning.tmp
|
|
$(Q) echo "# You can use \"make menuconfig\" to make any modifications to the installed .config file." >> warning.tmp
|
|
$(Q) echo "# You can then do \"make savedefconfig\" to generate a new defconfig file that includes your" >> warning.tmp
|
|
$(Q) echo "# modifications." >> warning.tmp
|
|
$(Q) echo "#" >> warning.tmp
|
|
$(Q) cat warning.tmp sortedconfig.tmp > defconfig
|
|
$(Q) rm -f warning.tmp
|
|
$(Q) rm -f defconfig.tmp
|
|
$(Q) rm -f sortedconfig.tmp
|
|
|
|
# export
|
|
#
|
|
# The export target will package the NuttX libraries and header files into
|
|
# an exportable package. Caveats: (1) These needs some extension for the KERNEL
|
|
# build; it needs to receive USERLIBS and create a libuser.a). (2) The logic
|
|
# in tools\mkexport.sh only supports GCC and, for example, explicitly assumes
|
|
# that the archiver is 'ar'
|
|
|
|
export: ${NUTTXLIBS}
|
|
$(Q) $(MKEXPORT) $(MKEXPORT_ARGS) -l "$(EXPORTLIBS)"
|
|
|
|
# General housekeeping targets: dependencies, cleaning, etc.
|
|
#
|
|
# depend: Create both PASS1 and PASS2 dependencies
|
|
# clean: Removes derived object files, archives, executables, and
|
|
# temporary files, but retains the configuration and context
|
|
# files and directories.
|
|
# distclean: Does 'clean' then also removes all configuration and context
|
|
# files. This essentially restores the directory structure
|
|
# to its original, unconfigured stated.
|
|
|
|
depend: pass1dep pass2dep
|
|
|
|
$(foreach SDIR, $(CLEANDIRS), $(eval $(call SDIR_template,$(SDIR),clean)))
|
|
|
|
subdir_clean: $(foreach SDIR, $(CLEANDIRS), $(SDIR)_clean)
|
|
ifeq ($(CONFIG_BUILD_2PASS),y)
|
|
$(Q) $(MAKE) -C $(CONFIG_PASS1_BUILDIR) clean
|
|
endif
|
|
|
|
clean: subdir_clean
|
|
$(call DELFILE, $(BIN))
|
|
$(call DELFILE, nuttx.*)
|
|
$(call DELFILE, *.map)
|
|
$(call DELFILE, _SAVED_APPS_config)
|
|
$(call DELFILE, nuttx-export*)
|
|
$(call DELFILE, nuttx_user*)
|
|
$(call DELFILE, .gdbinit)
|
|
$(call DELDIR, staging)
|
|
$(call DELFILE, uImage)
|
|
$(call CLEAN)
|
|
|
|
$(foreach SDIR, $(CLEANDIRS), $(eval $(call SDIR_template,$(SDIR),distclean)))
|
|
|
|
subdir_distclean: $(foreach SDIR, $(CLEANDIRS), $(SDIR)_distclean)
|
|
|
|
distclean: clean subdir_distclean clean_context
|
|
ifeq ($(CONFIG_BUILD_2PASS),y)
|
|
$(Q) $(MAKE) -C $(CONFIG_PASS1_BUILDIR) distclean
|
|
endif
|
|
$(call DELFILE, Make.defs)
|
|
$(call DELFILE, defconfig)
|
|
$(call DELFILE, defconfig.tmp-e)
|
|
$(call DELFILE, .config)
|
|
$(call DELFILE, .config.old)
|
|
$(call DELFILE, .config-e)
|
|
$(call DELFILE, .clean_context)
|
|
$(Q) $(MAKE) -C tools -f Makefile.host clean
|
|
|
|
# Application housekeeping targets. The APPDIR variable refers to the user
|
|
# application directory. A sample apps\ directory is included with NuttX,
|
|
# however, this is not treated as part of NuttX and may be replaced with a
|
|
# different application directory. For the most part, the application
|
|
# directory is treated like any other build directory in this script. However,
|
|
# as a convenience, the following targets are included to support housekeeping
|
|
# functions in the user application directory from the NuttX build directory.
|
|
#
|
|
# apps_preconfig: Prepare applications to be configured
|
|
# apps_clean: Perform the clean operation only in the user application
|
|
# directory
|
|
# apps_distclean: Perform the distclean operation only in the user application
|
|
# directory.
|
|
|
|
apps_preconfig: dirlinks
|
|
ifneq ($(APPDIR),)
|
|
$(Q) $(MAKE) -C "$(APPDIR)" preconfig
|
|
endif
|
|
|
|
apps_clean:
|
|
ifneq ($(APPDIR),)
|
|
$(Q) $(MAKE) -C "$(APPDIR)" clean
|
|
endif
|
|
|
|
apps_distclean:
|
|
ifneq ($(APPDIR),)
|
|
$(Q) $(MAKE) -C "$(APPDIR)" distclean
|
|
endif
|