nuttx/tools/Makefile.win
liuhaitao adc0c3e459 build: parallel clean and distclean subdir build
Use absolute path for APPDIR which could be used by apps clean
and distclean subdir build. Parallel clean and distclean subdir
could save more build time.

Signed-off-by: liuhaitao <liuhaitao@xiaomi.com>
2020-05-22 12:35:46 +01:00

570 lines
21 KiB
Makefile

############################################################################
# tools/Makefile.win
#
# Copyright (C) 2012, 2015, 2018 Gregory Nutt. All rights reserved.
# Author: Gregory Nutt <gnutt@nuttx.org>
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# 1. Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# 2. Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in
# the documentation and/or other materials provided with the
# distribution.
# 3. Neither the name NuttX nor the names of its contributors may be
# used to endorse or promote products derived from this software
# without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
# OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
#
############################################################################
export SHELL=cmd
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
ifeq ($(CONFIG_ARCH_BOARD_CUSTOM),y)
ifeq ($(CONFIG_ARCH_BOARD_CUSTOM_DIR_RELPATH),y)
BOARD_DIR = $(TOPDIR)$(DELIM)$(CONFIG_ARCH_BOARD_CUSTOM_DIR)
else
BOARD_DIR = $(CONFIG_ARCH_BOARD_CUSTOM_DIR)
endif
else
BOARD_DIR = $(TOPDIR)$(DELIM)boards$(DELIM)$(CONFIG_ARCH)$(DELIM)$(CONFIG_ARCH_CHIP)
endif
COMMON_DIR = $(if $(wildcard $(BOARD_DIR)$(DELIM)common$(DELIM)Makefile),y,)
# 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)})
# 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 = -w$(CONFIG_CYGWIN_WINTOOL) -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
$(Q) cp -pf 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
$(Q) cp -pf 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
$(Q) cp -pf 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
$(Q) cp -pf 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 TOPDIR="$(TOPDIR)" 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)
$(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 TOPDIR="$(TOPDIR)" mkconfig$(HOSTEXEEXT)
include\nuttx\config.h: $(TOPDIR)\.config tools\mkconfig$(HOSTEXEEXT)
$(Q) tools\mkconfig$(HOSTEXEEXT) $(TOPDIR) > include\nuttx\config.h
# Targets used to create dependencies
tools\mkdeps$(HOSTEXEEXT):
$(Q) $(MAKE) -C tools -f Makefile.host TOPDIR="$(TOPDIR)" 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: .config
@echo LN: include\arch to $(ARCH_DIR)\include
$(Q) $(DIRLINK) $(TOPDIR)\$(ARCH_DIR)\include include\arch
# 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)\$(CONFIG_ARCH_BOARD)\include
$(Q) $(DIRLINK) $(BOARD_DIR)\$(CONFIG_ARCH_BOARD)\include include\arch\board
ifeq ($(COMMON_DIR),y)
# 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: .config
@echo "LN: $(ARCH_SRC)\board to $(BOARD_DIR)\common"
$(Q) $(DIRLINK) $(BOARD_DIR)\common $(ARCH_SRC)\board
@echo "LN: $(ARCH_SRC)\board\board to $(BOARD_DIR)\$(CONFIG_ARCH_BOARD)\src"
$(Q) $(DIRLINK) $(BOARD_DIR)\$(CONFIG_ARCH_BOARD)\src $(ARCH_SRC)\board\board
else
# Link the boards\<arch>\<chip>\<board>\src dir to arch\<arch-name>\src\board
$(ARCH_SRC)\board: .config
@echo LN: $(ARCH_SRC)\board to $(BOARD_DIR)\$(CONFIG_ARCH_BOARD)\src
$(Q) $(DIRLINK) $(BOARD_DIR)\$(CONFIG_ARCH_BOARD)\src $(ARCH_SRC)\board
endif
# Link the boards\<arch>\<chip>\drivers dir to drivers\platform
drivers\platform: .config
@echo LN: $(TOPDIR)\drivers\platform to $(BOARD_DIR)\drivers
$(Q) $(DIRLINK) $(BOARD_DIR)\drivers $(TOPDIR)\drivers\platform
# Link arch\<arch-name>\src\<chip-name> to arch\<arch-name>\src\chip
$(ARCH_SRC)\chip: .config
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
# Link arch\<arch-name>\include\<chip-name> to arch\<arch-name>\include\chip
include\arch\chip: include\arch
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
dirlinks: include\arch include\arch\board include\arch\chip $(ARCH_SRC)\board $(ARCH_SRC)\chip drivers\platform
$(Q) $(MAKE) -C boards dirlinks TOPDIR="$(TOPDIR)"
$(Q) $(MAKE) -C openamp dirlinks TOPDIR="$(TOPDIR)"
$(Q) $(MAKE) -C $(CONFIG_APPS_DIR) dirlinks TOPDIR="$(TOPDIR)"
# 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 TOPDIR="$(TOPDIR)" 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 TOPDIR="$(TOPDIR)" 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)
# 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.
include tools/LibTargets.mk
# 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)
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) TOPDIR="$(TOPDIR)" LINKLIBS="$(LINKLIBS)" USERLIBS="$(USERLIBS)" "$(CONFIG_PASS1_TARGET)"
endif
pass2: $(NUTTXLIBS)
$(Q) $(MAKE) -C $(ARCH_SRC) TOPDIR="$(TOPDIR)" EXTRA_OBJS="$(EXTRA_OBJS)" LINKLIBS="$(LINKLIBS)" EXTRAFLAGS="$(KDEFINE) $(EXTRAFLAGS)" $(BIN)
ifeq ($(CONFIG_INTELHEX_BINARY),y)
@echo "CP: $(NUTTXNAME).hex"
$(Q) $(OBJCOPY) $(OBJCOPYARGS) -O ihex $(BIN) $(NUTTXNAME).hex
endif
ifeq ($(CONFIG_MOTOROLA_SREC),y)
@echo "CP: $(NUTTXNAME).srec"
$(Q) $(OBJCOPY) $(OBJCOPYARGS) -O srec $(BIN) $(NUTTXNAME).srec
endif
ifeq ($(CONFIG_RAW_BINARY),y)
@echo "CP: $(NUTTXNAME).bin"
$(Q) $(OBJCOPY) $(OBJCOPYARGS) -O binary $(BIN) $(NUTTXNAME).bin
endif
$(call POSTBUILD)
# $(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
# 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 TOPDIR="$(TOPDIR)" depend )
pass2dep: context tools\mkdeps$(HOSTEXEEXT)
$(Q) for %%G in ($(KERNDEPDIRS)) do ( $(MAKE) -C %%G TOPDIR="$(TOPDIR)" 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.
do_config: dirlinks apps_preconfig
$(Q) set APPSDIR=$(patsubst "%",%,${CONFIG_APPS_DIR})& kconfig-conf Kconfig
config: do_config clean_context
do_oldconfig: dirlinks apps_preconfig
$(Q) set APPSDIR=$(patsubst "%",%,${CONFIG_APPS_DIR})& kconfig-conf --oldconfig Kconfig
oldconfig: do_oldconfig clean_context
do_olddefconfig: dirlinks apps_preconfig
$(Q) set APPSDIR=$(patsubst "%",%,${CONFIG_APPS_DIR})& kconfig-conf --olddefconfig Kconfig
olddefconfig: do_olddefconfig clean_context
do_menuconfig: dirlinks configenv apps_preconfig
$(Q) set APPSDIR=$(patsubst "%",%,${CONFIG_APPS_DIR})& kconfig-mconf Kconfig
menuconfig: do_menuconfig clean_context
do_nconfig: dirlinks apps_preconfig
$(Q) set APPSDIR=$(patsubst "%",%,${CONFIG_APPS_DIR})& kconfig-nconf Kconfig
nconfig: do_nconfig clean_context
savedefconfig: dirlinks apps_preconfig
$(Q) set APPSDIR=$(patsubst "%",%,${CONFIG_APPS_DIR})& 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)
$(Q) $(MAKE) -C tools -f Makefile.host TOPDIR="$(TOPDIR)" clean
ifeq ($(CONFIG_BUILD_2PASS),y)
$(Q) $(MAKE) -C $(CONFIG_PASS1_BUILDIR) TOPDIR="$(TOPDIR)" 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) TOPDIR="$(TOPDIR)" 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 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)
# 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:
ifneq ($(APPDIR),)
$(Q) $(MAKE) -C "$(APPDIR)" TOPDIR="$(TOPDIR)" preconfig
endif
apps_clean:
ifneq ($(APPDIR),)
$(Q) $(MAKE) -C "$(APPDIR)" TOPDIR="$(TOPDIR)" clean
endif
apps_distclean:
ifneq ($(APPDIR),)
$(Q) $(MAKE) -C "$(APPDIR)" TOPDIR="$(TOPDIR)" distclean
endif