# SPDX-License-Identifier: Apache-2.0

# *DOCUMENTATION*

#

# Note that this is *NOT* the top-level CMakeLists.txt. That's in the

# application. See the Application Development Primer documentation

# for details.

#

# To see a list of typical targets execute "make usage"

# More info can be located in ./README.rst

# Comments in this file are targeted only to the developer, do not

# expect to learn how to build the kernel reading this file.

if(NOT DEFINED ZEPHYR_BINARY_DIR)

message(FATAL_ERROR "A user error has occurred.

cmake was invoked with '${CMAKE_CURRENT_LIST_DIR}' specified as the source directory,

but it must be invoked with an application source directory,

such as '${CMAKE_CURRENT_LIST_DIR}/samples/hello_world'.

Debug variables:

CMAKE_CACHEFILE_DIR: ${CMAKE_CACHEFILE_DIR}

")

endif()

# See https://gitlab.kitware.com/cmake/cmake/issues/16228

# and https://cmake.org/pipermail/cmake/2019-May/thread.html#69496

if(NOT ZEPHYR_BASE STREQUAL CMAKE_CURRENT_SOURCE_DIR)

message(WARNING "ZEPHYR_BASE doesn't match CMAKE_CURRENT_SOURCE_DIR

ZEPHYR_BASE = ${ZEPHYR_BASE}

PWD = $ENV{PWD}

CMAKE_CURRENT_SOURCE_DIR = ${CMAKE_CURRENT_SOURCE_DIR}

You may be using a mix of symbolic links and real paths which causes \

subtle and hard to debug CMake issues.")

endif()

# For Zephyr more specifically this breaks (at least)

# -fmacro-prefix-map=${ZEPHYR_BASE}=

# In some cases the "final" things are not used at all and "_prebuilt"

# is the last station. See "logical_target_for_zephyr_elf" below for

# details.

set(CMAKE_EXECUTABLE_SUFFIX .elf)

# Zephyr build system will use a dynamic number of linking stages based on build

# configuration.

#

# Currently up to three linking stages may be executed:

# zephyr_pre0: First linking stage

# zephyr_pre1: Second linking stage

# zephyr_final: Final linking stage

#

# There will at minimum be a single linking stage.

# When only a single linking stage is required, the `zephyr_pre0` will be mapped

# into the `zephyr_final` target.

#

# Multiple linking stages are required in the following cases:

# - device handles structs must be generated (CONFIG_HAS_DTS=y)

# - ISR tables must be generated (CONFIG_GEN_ISR_TABLES=y)

# - Kernel objects hash tables (CONFIG_USERSPACE=y)

# - Application memory partitions (CONFIG_USERSPACE=y)

#

# Some generators require that memory locations has been fixed, thus those are

# placed at the second linking stage.

#

# When all three linking stages are active, then the following properties applies:

# - zephyr_pre0: linker sections may resize / addresses may relocate

# - zephyr_pre1: All linker section sizes are fixed, addresses cannot change

# - zephyr_final: Final image.

#

set(ZEPHYR_CURRENT_LINKER_PASS 0)

set(ZEPHYR_CURRENT_LINKER_CMD linker_zephyr_pre${ZEPHYR_CURRENT_LINKER_PASS}.cmd)

set(ZEPHYR_LINK_STAGE_EXECUTABLE zephyr_pre${ZEPHYR_CURRENT_LINKER_PASS})

# ZEPHYR_PREBUILT_EXECUTABLE is used outside of this file, therefore keep the

# existing variable to allow slowly cleanup of linking stage handling.

# Three stage linking active: pre0 -> pre1 -> final, this will correspond to `pre1`

# Two stage linking active: pre0 -> final, this will correspond to `pre0`

if(CONFIG_USERSPACE OR CONFIG_HAS_DTS)

set(ZEPHYR_PREBUILT_EXECUTABLE zephyr_pre1)

else()

set(ZEPHYR_PREBUILT_EXECUTABLE zephyr_pre0)

endif()

set(ZEPHYR_FINAL_EXECUTABLE zephyr_final)

# Set some phony targets to collect dependencies

set(OFFSETS_H_TARGET offsets_h)

set(SYSCALL_LIST_H_TARGET syscall_list_h_target)

set(DRIVER_VALIDATION_H_TARGET driver_validation_h_target)

set(KOBJ_TYPES_H_TARGET kobj_types_h_target)

set(PARSE_SYSCALLS_TARGET parse_syscalls_target)

define_property(GLOBAL PROPERTY PROPERTY_OUTPUT_FORMAT BRIEF_DOCS " " FULL_DOCS " ")

set_property( GLOBAL PROPERTY PROPERTY_OUTPUT_FORMAT elf32-little${ARCH}) # BFD format

# "zephyr_interface" is a source-less library that encapsulates all the global

# compiler options needed by all source files. All zephyr libraries,

# including the library named "zephyr" link with this library to

# obtain these flags.

# https://cmake.org/cmake/help/latest/manual/cmake-buildsystem.7.html#interface-libraries

add_library(zephyr_interface INTERFACE)

# "zephyr" is a catch-all CMake library for source files that can be

# built purely with the include paths, defines, and other compiler

# flags that come with zephyr_interface.

zephyr_library_named(zephyr)

if(CONFIG_LEGACY_INCLUDE_PATH)

zephyr_include_directories(include/zephyr)

endif()

zephyr_include_directories(

include

${PROJECT_BINARY_DIR}/include/generated

${USERINCLUDE}

${STDINCLUDE}

)

include(${ZEPHYR_BASE}/cmake/linker_script/${ARCH}/linker.cmake OPTIONAL)

# Don't add non-existing include directories, it creates noise and

# warnings in some tooling

foreach(optional_include_dir

${SOC_DIR}/${ARCH}/${SOC_PATH}

${SOC_DIR}/${ARCH}/${SOC_PATH}/include

${SOC_DIR}/${ARCH}/${SOC_PATH}/include/${SOC_NAME}

${SOC_DIR}/${ARCH}/${SOC_FAMILY}/include

${SOC_DIR}/${ARCH}/${SOC_FAMILY}/common/include

)

if(EXISTS ${optional_include_dir})

zephyr_include_directories(${optional_include_dir})

endif()

endforeach()

# Don't inherit compiler flags from the environment

foreach(var AFLAGS CFLAGS CXXFLAGS CPPFLAGS LDFLAGS)

if(DEFINED ENV{${var}})

message(WARNING "The environment variable '${var}' was set to $ENV{${var}}, "

"but Zephyr ignores flags from the environment. Use 'cmake "

"-DEXTRA_${var}=$ENV{${var}}' instead."

)

unset(ENV{${var}})

endif()

endforeach()

zephyr_compile_definitions(

KERNEL

__ZEPHYR__=1

)

# Ensure that include/zephyr/toolchain.h includes toolchain/other.h for all off-tree toolchains

if(TOOLCHAIN_USE_CUSTOM)

zephyr_compile_definitions(__TOOLCHAIN_CUSTOM__)

endif()

# @Intent: Set compiler specific flag for disabling strict aliasing rule

zephyr_compile_options($<$<COMPILE_LANGUAGE:C>:$<TARGET_PROPERTY:compiler,no_strict_aliasing>>)

zephyr_compile_options($<$<COMPILE_LANGUAGE:CXX>:$<TARGET_PROPERTY:compiler-cpp,no_strict_aliasing>>)

# @Intent: Set compiler flags to enable buffer overflow checks in libc functions

# @details:

# Kconfig.zephyr "Detect buffer overflows in libc calls" is a kconfig choice,

# ensuring at most *one* of CONFIG_FORTIFY_SOURCE_{COMPILE_TIME,RUN_TIME} is

# set. Refer to Kconfig.zephyr for selection logic and description of these

# choices. Toolchains set both of the security_fortify_{compile_time,run_time}

# properties and the Kconfig settings are used here to select between those.

#

if(CONFIG_FORTIFY_SOURCE_RUN_TIME)

zephyr_compile_definitions($<TARGET_PROPERTY:compiler,security_fortify_run_time> )

elseif(CONFIG_FORTIFY_SOURCE_COMPILE_TIME)

zephyr_compile_definitions($<TARGET_PROPERTY:compiler,security_fortify_compile_time> )

endif()

# @Intent: Set compiler flags to detect general stack overflows across all functions

if(CONFIG_STACK_CANARIES)

zephyr_compile_options($<TARGET_PROPERTY:compiler,security_canaries>)

endif()

# @Intent: Obtain compiler optimizations flags and store in variables

# @details:

# Kconfig.zephyr "Optimization level" is a kconfig choice, ensuring

# only *one* of CONFIG_{NO,DEBUG,SPEED,SIZE}_OPTIMIZATIONS is set.

# Refer to Kconfig.zephyr for selection logic and description of these choices.

# toolchain_cc_optimize_*() macros must provide the mapping from these kconfigs

# to compiler flags. Each macro will store the flags in a CMake variable, whose

# name is passed as argument (somewhat like by reference).

#

# If the user wants to tweak the optimizations, there are two ways:

# 1) Using EXTRA_CFLAGS which is applied regardless of kconfig choice, or

# 2) Rely on override support being implemented by your toolchain_cc_optimize_*()

#

get_property(OPTIMIZE_FOR_NO_OPTIMIZATIONS_FLAG TARGET compiler PROPERTY no_optimization)

get_property(OPTIMIZE_FOR_DEBUG_FLAG TARGET compiler PROPERTY optimization_debug)

get_property(OPTIMIZE_FOR_SPEED_FLAG TARGET compiler PROPERTY optimization_speed)

get_property(OPTIMIZE_FOR_SIZE_FLAG TARGET compiler PROPERTY optimization_size)

# From kconfig choice, pick the actual OPTIMIZATION_FLAG to use.

# Kconfig choice ensures only one of these CONFIG_*_OPTIMIZATIONS is set.

if(CONFIG_NO_OPTIMIZATIONS)

set(OPTIMIZATION_FLAG ${OPTIMIZE_FOR_NO_OPTIMIZATIONS_FLAG})

elseif(CONFIG_DEBUG_OPTIMIZATIONS)

set(OPTIMIZATION_FLAG ${OPTIMIZE_FOR_DEBUG_FLAG})

elseif(CONFIG_SPEED_OPTIMIZATIONS)

set(OPTIMIZATION_FLAG ${OPTIMIZE_FOR_SPEED_FLAG})

elseif(CONFIG_SIZE_OPTIMIZATIONS)

set(OPTIMIZATION_FLAG ${OPTIMIZE_FOR_SIZE_FLAG}) # Default in kconfig

else()

assert(0 "Unreachable code. Expected optimization level to have been chosen. See Kconfig.zephyr")

endif()

if(NOT CONFIG_ARCH_IS_SET)

message(WARNING "\

None of the CONFIG_<arch> (e.g. CONFIG_X86) symbols are set. \

Select one of them from the SOC_SERIES_* symbol or, lacking that, from the \

SOC_* symbol.")

endif()

# Apply the final optimization flag(s)

zephyr_compile_options(${OPTIMIZATION_FLAG})

# @Intent: Obtain compiler specific flags related to C++ that are not influenced by kconfig

zephyr_compile_options($<$<COMPILE_LANGUAGE:CXX>:$<TARGET_PROPERTY:compiler-cpp,required>>)

# @Intent: Obtain compiler specific flags for compiling under different ISO standards of C++

if(CONFIG_CPLUSPLUS)

# From kconfig choice, pick a single dialect.

# Kconfig choice ensures only one of these CONFIG_STD_CPP* is set.

if(CONFIG_STD_CPP98)

set(STD_CPP_DIALECT_FLAGS $<TARGET_PROPERTY:compiler-cpp,dialect_cpp98>)

list(APPEND CMAKE_CXX_COMPILE_FEATURES ${compile_features_cpp98})

elseif(CONFIG_STD_CPP11)

set(STD_CPP_DIALECT_FLAGS $<TARGET_PROPERTY:compiler-cpp,dialect_cpp11>) # Default in kconfig

list(APPEND CMAKE_CXX_COMPILE_FEATURES ${compile_features_cpp11})

elseif(CONFIG_STD_CPP14)

set(STD_CPP_DIALECT_FLAGS $<TARGET_PROPERTY:compiler-cpp,dialect_cpp14>)

list(APPEND CMAKE_CXX_COMPILE_FEATURES ${compile_features_cpp14})

elseif(CONFIG_STD_CPP17)

set(STD_CPP_DIALECT_FLAGS $<TARGET_PROPERTY:compiler-cpp,dialect_cpp17>)

list(APPEND CMAKE_CXX_COMPILE_FEATURES ${compile_features_cpp17})

elseif(CONFIG_STD_CPP2A)

set(STD_CPP_DIALECT_FLAGS $<TARGET_PROPERTY:compiler-cpp,dialect_cpp2a>)

list(APPEND CMAKE_CXX_COMPILE_FEATURES ${compile_features_cpp20})

elseif(CONFIG_STD_CPP20)

set(STD_CPP_DIALECT_FLAGS $<TARGET_PROPERTY:compiler-cpp,dialect_cpp20>)

list(APPEND CMAKE_CXX_COMPILE_FEATURES ${compile_features_cpp20})

elseif(CONFIG_STD_CPP2B)

set(STD_CPP_DIALECT_FLAGS $<TARGET_PROPERTY:compiler-cpp,dialect_cpp2b>)

list(APPEND CMAKE_CXX_COMPILE_FEATURES ${compile_features_cpp20})

else()

assert(0 "Unreachable code. Expected C++ standard to have been chosen. See Kconfig.zephyr.")

endif()

set(CMAKE_CXX_COMPILE_FEATURES ${CMAKE_CXX_COMPILE_FEATURES} PARENT_SCOPE)

zephyr_compile_options($<$<COMPILE_LANGUAGE:CXX>:${STD_CPP_DIALECT_FLAGS}>)

endif()

if(NOT CONFIG_EXCEPTIONS)

# @Intent: Obtain compiler specific flags related to C++ Exceptions

zephyr_compile_options($<$<COMPILE_LANGUAGE:CXX>:$<TARGET_PROPERTY:compiler-cpp,no_exceptions>>)

endif()

if(NOT CONFIG_RTTI)

# @Intent: Obtain compiler specific flags related to C++ Run Time Type Information

zephyr_compile_options($<$<COMPILE_LANGUAGE:CXX>:$<TARGET_PROPERTY:compiler-cpp,no_rtti>>)

endif()

if(CONFIG_MISRA_SANE)

# @Intent: Obtain toolchain compiler flags relating to MISRA.

zephyr_compile_options($<$<COMPILE_LANGUAGE:C>:$<TARGET_PROPERTY:compiler,warning_error_misra_sane>>)

zephyr_compile_options($<$<COMPILE_LANGUAGE:CXX>:$<TARGET_PROPERTY:compiler-cpp,warning_error_misra_sane>>)

endif()

# This is intend to be temporary. Once we have fixed the violations that

# prevents build Zephyr, these flags shall be part of the default flags.

if(CONFIG_CODING_GUIDELINE_CHECK)

# @Intent: Obtain toolchain compiler flags relating to coding guideline

zephyr_compile_options($<$<COMPILE_LANGUAGE:C>:$<TARGET_PROPERTY:compiler,warning_error_coding_guideline>>)

endif()

# @Intent: Set compiler specific macro inclusion of AUTOCONF_H

zephyr_compile_options("SHELL: $<TARGET_PROPERTY:compiler,imacros> ${AUTOCONF_H}")

if(NOT CONFIG_PICOLIBC)

# @Intent: Set compiler specific flag for bare metal freestanding option

zephyr_compile_options($<$<COMPILE_LANGUAGE:C>:$<TARGET_PROPERTY:compiler,freestanding>>)

zephyr_compile_options($<$<COMPILE_LANGUAGE:ASM>:$<TARGET_PROPERTY:compiler,freestanding>>)

endif()

if (CONFIG_PICOLIBC AND NOT CONFIG_PICOLIBC_IO_FLOAT)

# @Intent: Set compiler specific flag to disable printf-related optimizations

zephyr_compile_options($<$<COMPILE_LANGUAGE:C>:$<TARGET_PROPERTY:compiler,no_printf_return_value>>)

endif()

# @Intent: Set compiler specific flag for tentative definitions, no-common

zephyr_compile_options($<TARGET_PROPERTY:compiler,no_common>)

# @Intent: Set compiler specific flag for production of debug information

zephyr_compile_options($<TARGET_PROPERTY:compiler,debug>)

if(CONFIG_COMPILER_COLOR_DIAGNOSTICS)

# @Intent: Set compiler specific flag for diagnostic messages

zephyr_compile_options($<TARGET_PROPERTY:compiler,diagnostic>)

endif()

if("${SPARSE}" STREQUAL "y")

list(APPEND TOOLCHAIN_C_FLAGS -D__CHECKER__)

# Avoid compiler "attribute directive ignored" warnings

list(APPEND TOOLCHAIN_C_FLAGS -Wno-attributes)

endif()

zephyr_compile_options(

${TOOLCHAIN_C_FLAGS}

)

# @Intent: Obtain compiler specific flags related to assembly

# ToDo: Remember to get feedback from Oticon on this, as they might use the `ASM_BASE_FLAG` since this is done this way.

zephyr_compile_options($<$<COMPILE_LANGUAGE:ASM>:$<TARGET_PROPERTY:asm,required>>)

# @Intent: Enforce standard integer type correspondence to match Zephyr usage.

# (must be after compiler specific flags)

if(CONFIG_ENFORCE_ZEPHYR_STDINT)

zephyr_compile_options("SHELL: $<TARGET_PROPERTY:compiler,imacros> ${ZEPHYR_BASE}/include/zephyr/toolchain/zephyr_stdint.h")

endif()

# Common toolchain-agnostic assembly flags

zephyr_compile_options(

$<$<COMPILE_LANGUAGE:ASM>:-D_ASMLANGUAGE>

)

# @Intent: Set fundamental linker specific flags

toolchain_ld_base()

toolchain_ld_force_undefined_symbols(

_OffsetAbsSyms

_ConfigAbsSyms

)

if(NOT CONFIG_NATIVE_APPLICATION)

# @Intent: Set linker specific flags for bare metal target

toolchain_ld_baremetal()

endif()

if(CONFIG_LIB_CPLUSPLUS)

# @Intent: Set linker specific flags for C++

toolchain_ld_cpp()

endif()

# @Intent: Add the basic toolchain warning flags

zephyr_compile_options($<$<COMPILE_LANGUAGE:C>:$<TARGET_PROPERTY:compiler,warning_base>>)

zephyr_compile_options($<$<COMPILE_LANGUAGE:CXX>:$<TARGET_PROPERTY:compiler-cpp,warning_base>>)

# ==========================================================================

#

# cmake -DW=... settings

#

# W=1 - warnings that may be relevant and does not occur too often

# W=2 - warnings that occur quite often but may still be relevant

# W=3 - the more obscure warnings, can most likely be ignored

# ==========================================================================

# @Intent: Add cmake -DW toolchain supported warnings, if any

if(W MATCHES "1")

zephyr_compile_options($<$<COMPILE_LANGUAGE:C>:$<TARGET_PROPERTY:compiler,warning_dw_1>>)

zephyr_compile_options($<$<COMPILE_LANGUAGE:CXX>:$<TARGET_PROPERTY:compiler-cpp,warning_dw_1>>)

endif()

if(W MATCHES "2")

zephyr_compile_options($<$<COMPILE_LANGUAGE:C>:$<TARGET_PROPERTY:compiler,warning_dw_2>>)

zephyr_compile_options($<$<COMPILE_LANGUAGE:CXX>:$<TARGET_PROPERTY:compiler-cpp,warning_dw_2>>)

endif()

if(W MATCHES "3")

zephyr_compile_options($<$<COMPILE_LANGUAGE:C>:$<TARGET_PROPERTY:compiler,warning_dw_3>>)

zephyr_compile_options($<$<COMPILE_LANGUAGE:CXX>:$<TARGET_PROPERTY:compiler-cpp,warning_dw_3>>)

endif()

# @Intent: Add extended, more specific, toolchain warning flags

zephyr_compile_options($<TARGET_PROPERTY:compiler,warning_extended>)

# @Intent: Trigger an error when a declaration does not specify a type

zephyr_compile_options($<$<COMPILE_LANGUAGE:C>:$<TARGET_PROPERTY:compiler,warning_error_implicit_int>>)

zephyr_compile_options($<$<COMPILE_LANGUAGE:CXX>:$<TARGET_PROPERTY:compiler-cpp,warning_error_implicit_int>>)

# @Intent: Do not make position independent code / executable

zephyr_compile_options($<$<COMPILE_LANGUAGE:C>:$<TARGET_PROPERTY:compiler,no_position_independent>>)

# Allow the user to inject options when calling cmake, e.g.

# 'cmake -DEXTRA_CFLAGS="-Werror -Wno-deprecated-declarations" ..'

include(cmake/extra_flags.cmake)

zephyr_cc_option(-fno-asynchronous-unwind-tables)

if(CONFIG_THREAD_LOCAL_STORAGE)

# Only support local exec TLS model at this point.

zephyr_cc_option(-ftls-model=local-exec)

endif()

if(CONFIG_OVERRIDE_FRAME_POINTER_DEFAULT)

if(CONFIG_OMIT_FRAME_POINTER)

zephyr_cc_option(-fomit-frame-pointer)

else()

zephyr_cc_option(-fno-omit-frame-pointer)

endif()

endif()

separate_arguments(COMPILER_OPT_AS_LIST UNIX_COMMAND ${CONFIG_COMPILER_OPT})

zephyr_compile_options(${COMPILER_OPT_AS_LIST})

# TODO: Include arch compiler options at this point.

if(NOT CMAKE_C_COMPILER_ID STREQUAL "Clang")

# GCC assumed

zephyr_cc_option(-fno-reorder-functions)

# GCC 11 and above may generate a warning when dereferencing a constant

# address pointer whose address is below the value specified by the

# `min-pagesize` parameter (defaults to 0x1000). The `min-pagesize` parameter

# is set to 0 such that GCC never generates any warnings for the constant

# address pointers. For more details, refer to the GCC PR99578.

zephyr_cc_option(--param=min-pagesize=0)

if(NOT ${ZEPHYR_TOOLCHAIN_VARIANT} STREQUAL "xcc")

zephyr_cc_option(-fno-defer-pop)

endif()

else()

# Clang produces false positive vla warnings

zephyr_cc_option(-Wno-vla)

endif()

zephyr_cc_option_ifdef(CONFIG_STACK_USAGE -fstack-usage)

# If the compiler supports it, strip the ${ZEPHYR_BASE} prefix from the

# __FILE__ macro used in __ASSERT*, in the

# .noinit."/home/joe/zephyr/fu/bar.c" section names and in any

# application code. This saves some memory, stops leaking user locations

# in binaries, makes failure logs more deterministic and most

# importantly makes builds more deterministic

# If several match then the last one wins. This matters for instances

# like tests/ and samples/: they're inside all of them! Then let's

# strip as little as possible.

zephyr_cc_option(-fmacro-prefix-map=${CMAKE_SOURCE_DIR}=CMAKE_SOURCE_DIR)

zephyr_cc_option(-fmacro-prefix-map=${ZEPHYR_BASE}=ZEPHYR_BASE)

if(WEST_TOPDIR)

zephyr_cc_option(-fmacro-prefix-map=${WEST_TOPDIR}=WEST_TOPDIR)

endif()

# TODO: Archiver arguments

# ar_option(D)

# Declare MPU userspace dependencies before the linker scripts to make

# sure the order of dependencies are met

if(CONFIG_USERSPACE)

add_custom_target(app_smem)

set(APP_SMEM_ALIGNED_DEP app_smem_aligned_linker)

set(APP_SMEM_UNALIGNED_DEP app_smem_unaligned_linker)

endif()

if(CONFIG_USERSPACE)

set(KOBJECT_LINKER_DEP kobject_linker)

endif()

get_property(TOPT GLOBAL PROPERTY TOPT)

set_ifndef( TOPT -Wl,-T) # clang doesn't pick -T for some reason and complains,

# while -Wl,-T works for both, gcc and clang

if(CONFIG_HAVE_CUSTOM_LINKER_SCRIPT)

set(LINKER_SCRIPT ${APPLICATION_SOURCE_DIR}/${CONFIG_CUSTOM_LINKER_SCRIPT})

if(NOT EXISTS ${LINKER_SCRIPT})

set(LINKER_SCRIPT ${CONFIG_CUSTOM_LINKER_SCRIPT})

assert_exists(CONFIG_CUSTOM_LINKER_SCRIPT)

endif()

else()

# Try a board specific linker file

set(LINKER_SCRIPT ${BOARD_DIR}/linker.ld)

if(NOT EXISTS ${LINKER_SCRIPT})

# If not available, try an SoC specific linker file

set(LINKER_SCRIPT ${SOC_DIR}/${ARCH}/${SOC_PATH}/linker.ld)

endif()

endif()

if(NOT EXISTS ${LINKER_SCRIPT})

message(FATAL_ERROR "Could not find linker script: '${LINKER_SCRIPT}'. Corrupted configuration?")

endif()

if(DEFINED BUILD_VERSION)

set(build_version_argument "-DBUILD_VERSION=${BUILD_VERSION}")

elseif(NOT ZEPHYR_GIT_INDEX)

set(ZEPHYR_GIT_INDEX ZEPHYR_GIT_INDEX-NOTFOUND CACHE PATH

"Path to Zephyr git repository index file")

if(EXISTS ${ZEPHYR_BASE}/.git/index)

set(ZEPHYR_GIT_DIR ${ZEPHYR_BASE}/.git/index CACHE PATH

"Path to Zephyr git repository index file" FORCE)

elseif(EXISTS ${ZEPHYR_BASE}/.git)

# Likely a git-submodule. Let's ask git where the real database is located.

find_package(Git QUIET)

if(GIT_FOUND)

execute_process(

COMMAND ${GIT_EXECUTABLE} rev-parse --absolute-git-dir

WORKING_DIRECTORY ${ZEPHYR_BASE}

OUTPUT_VARIABLE zephyr_git_dir

OUTPUT_STRIP_TRAILING_WHITESPACE

ERROR_STRIP_TRAILING_WHITESPACE

ERROR_VARIABLE stderr

RESULT_VARIABLE return_code)

if(return_code)

message(WARNING "BUILD_VERSION: git rev-parse failed: ${stderr}")

else()

if(NOT "${stderr}" STREQUAL "")

message(WARNING "BUILD_VERSION: git rev-parse warned: ${stderr}")

endif()

set(ZEPHYR_GIT_INDEX ${zephyr_git_dir}/index CACHE PATH

"Path to Zephyr git repository index file" FORCE)

endif()

else()

message(WARNING "Could not find git installation, "

"please specify '-DBUILD_VERSION=<version>'")

endif()

else()

message(WARNING "ZEPHYR_BASE=${ZEPHYR_BASE} doesn't appear to be a git "

"repository, please specify '-DBUILD_VERSION=<version>'")

endif()

endif()

if(ZEPHYR_GIT_INDEX)

set(git_dependency ${ZEPHYR_GIT_INDEX})

endif()

add_custom_command(

OUTPUT ${PROJECT_BINARY_DIR}/include/generated/version.h

COMMAND ${CMAKE_COMMAND} -DZEPHYR_BASE=${ZEPHYR_BASE}

-DOUT_FILE=${PROJECT_BINARY_DIR}/include/generated/version.h

${build_version_argument}

-P ${ZEPHYR_BASE}/cmake/gen_version_h.cmake

DEPENDS ${ZEPHYR_BASE}/VERSION ${git_dependency}

)

add_custom_target(version_h DEPENDS ${PROJECT_BINARY_DIR}/include/generated/version.h)

# Unfortunately, the order in which CMakeLists.txt code is processed

# matters so we need to be careful about how we order the processing

# of subdirectories. One example is "Compiler flags added late in the

# build are not exported to external build systems #5605"; when we

# integrate with an external build system we read out all compiler

# flags when the external project is created. So an external project

# defined in subsys or ext will not get global flags added by drivers/

# or tests/ as the subdirectories are ordered now.

#

# Another example of when the order matters is the reading and writing

# of global properties such as ZEPHYR_LIBS or

# GENERATED_KERNEL_OBJECT_FILES.

#

# Arch is placed early because it defines important compiler flags

# that must be exported to external build systems defined in

# e.g. subsys/.

add_subdirectory(arch)

add_subdirectory(lib)

# We use include instead of add_subdirectory to avoid creating a new directory scope.

# This is because source file properties are directory scoped, including the GENERATED

# property which is set implicitly for custom command outputs

include(misc/generated/CMakeLists.txt)

if(EXISTS ${SOC_DIR}/${ARCH}/CMakeLists.txt)

add_subdirectory(${SOC_DIR}/${ARCH} soc/${ARCH})

else()

add_subdirectory(${SOC_DIR}/${ARCH}/${SOC_PATH} soc/${ARCH}/${SOC_PATH})

endif()

add_subdirectory(boards)

add_subdirectory(subsys)

add_subdirectory(drivers)

# Include zephyr modules generated CMake file.

foreach(module_name ${ZEPHYR_MODULE_NAMES})

# Note the second, binary_dir parameter requires the added

# subdirectory to have its own, local cmake target(s). If not then

# this binary_dir is created but stays empty. Object files land in

# the main binary dir instead.

# https://cmake.org/pipermail/cmake/2019-June/069547.html

zephyr_string(SANITIZE TOUPPER MODULE_NAME_UPPER ${module_name})

if(NOT ${ZEPHYR_${MODULE_NAME_UPPER}_CMAKE_DIR} STREQUAL "")

set(ZEPHYR_CURRENT_MODULE_DIR ${ZEPHYR_${MODULE_NAME_UPPER}_MODULE_DIR})

set(ZEPHYR_CURRENT_CMAKE_DIR ${ZEPHYR_${MODULE_NAME_UPPER}_CMAKE_DIR})

add_subdirectory(${ZEPHYR_CURRENT_CMAKE_DIR} ${CMAKE_BINARY_DIR}/modules/${module_name})

endif()

endforeach()

# Done processing modules, clear ZEPHYR_CURRENT_MODULE_DIR and ZEPHYR_CURRENT_CMAKE_DIR.

set(ZEPHYR_CURRENT_MODULE_DIR)

set(ZEPHYR_CURRENT_CMAKE_DIR)

set(syscall_list_h ${CMAKE_CURRENT_BINARY_DIR}/include/generated/syscall_list.h)

set(syscalls_json ${CMAKE_CURRENT_BINARY_DIR}/misc/generated/syscalls.json)

set(struct_tags_json ${CMAKE_CURRENT_BINARY_DIR}/misc/generated/struct_tags.json)

# The syscalls subdirs txt file is constructed by python containing a list of folders to use for

# dependency handling, including empty folders.

# Windows: The list is used to specify DIRECTORY list with CMAKE_CONFIGURE_DEPENDS attribute.

# Other OS: The list will update whenever a file is added/removed/modified and ensure a re-build.

set(syscalls_subdirs_txt ${CMAKE_CURRENT_BINARY_DIR}/misc/generated/syscalls_subdirs.txt)

# As syscalls_subdirs_txt is updated whenever a file is modified, this file can not be used for

# monitoring of added / removed folders. A trigger file is thus used for correct dependency

# handling. The trigger file will update when a folder is added / removed.

set(syscalls_subdirs_trigger ${CMAKE_CURRENT_BINARY_DIR}/misc/generated/syscalls_subdirs.trigger)

if(NOT (${CMAKE_HOST_SYSTEM_NAME} STREQUAL Windows))

set(syscalls_links --create-links ${CMAKE_CURRENT_BINARY_DIR}/misc/generated/syscalls_links)

endif()

# When running CMake it must be ensured that all dependencies are correctly acquired.

execute_process(

COMMAND

${PYTHON_EXECUTABLE}

${ZEPHYR_BASE}/scripts/build/subfolder_list.py

--directory ${ZEPHYR_BASE}/include # Walk this directory

--out-file ${syscalls_subdirs_txt} # Write file with discovered folder

--trigger ${syscalls_subdirs_trigger} # Trigger file that is used for json generation

${syscalls_links} # If defined, create symlinks for dependencies

)

file(STRINGS ${syscalls_subdirs_txt} PARSE_SYSCALLS_PATHS_DEPENDS ENCODING UTF-8)

if(${CMAKE_HOST_SYSTEM_NAME} STREQUAL Windows)

# On windows only adding/removing files or folders will be reflected in depends.

# Hence adding a file requires CMake to re-run to add this file to the file list.

set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS ${PARSE_SYSCALLS_PATHS_DEPENDS})

# Also On Windows each header file must be monitored as file modifications are not reflected

# on directory level.

file(GLOB_RECURSE PARSE_SYSCALLS_HEADER_DEPENDS ${ZEPHYR_BASE}/include/*.h)

else()

# The syscall parsing depends on the folders in order to detect add/removed/modified files.

# When a folder is removed, CMake will try to find a target that creates that dependency.

# This command sets up the target for CMake to find.

# Without this code, CMake will fail with the following error:

# <folder> needed by '<target>', missing and no known rule to make it

# when a folder is removed.

add_custom_command(OUTPUT ${PARSE_SYSCALLS_PATHS_DEPENDS}

COMMAND ${CMAKE_COMMAND} -E echo ""

COMMENT "Preparing syscall dependency handling"

)

add_custom_command(

OUTPUT

${syscalls_subdirs_trigger}

COMMAND

${PYTHON_EXECUTABLE}

${ZEPHYR_BASE}/scripts/build/subfolder_list.py

--directory ${ZEPHYR_BASE}/include # Walk this directory

--out-file ${syscalls_subdirs_txt} # Write file with discovered folder

--trigger ${syscalls_subdirs_trigger} # Trigger file that is used for json generation

${syscalls_links} # If defined, create symlinks for dependencies

DEPENDS ${PARSE_SYSCALLS_PATHS_DEPENDS}

)

# Ensure subdir file always exists when specifying CMake dependency.

if(NOT EXISTS ${syscalls_subdirs_txt})

file(WRITE ${syscalls_subdirs_txt} "")

endif()

# On other OS'es, modifying a file is reflected on the folder timestamp and hence detected

# when using depend on directory level.

# Thus CMake only needs to re-run when sub-directories are added / removed, which is indicated

# using a trigger file.

set_property(DIRECTORY APPEND PROPERTY CMAKE_CONFIGURE_DEPENDS ${syscalls_subdirs_txt})

endif()

# syscall declarations are searched for in the SYSCALL_INCLUDE_DIRS

if(CONFIG_APPLICATION_DEFINED_SYSCALL)

list(APPEND SYSCALL_INCLUDE_DIRS ${APPLICATION_SOURCE_DIR})

endif()

if(CONFIG_ZTEST)

list(APPEND SYSCALL_INCLUDE_DIRS ${ZEPHYR_BASE}/subsys/testsuite/ztest/include)

endif()

foreach(d ${SYSCALL_INCLUDE_DIRS})

list(APPEND parse_syscalls_include_args

--include ${d}

)

endforeach()

add_custom_command(

OUTPUT

${syscalls_json}

${struct_tags_json}

COMMAND

${PYTHON_EXECUTABLE}

${ZEPHYR_BASE}/scripts/build/parse_syscalls.py

--include ${ZEPHYR_BASE}/include # Read files from this dir

--include ${ZEPHYR_BASE}/drivers # For net sockets

--include ${ZEPHYR_BASE}/subsys/net # More net sockets

${parse_syscalls_include_args} # Read files from these dirs also

--json-file ${syscalls_json} # Write this file

--tag-struct-file ${struct_tags_json} # Write subsystem list to this file

DEPENDS ${syscalls_subdirs_trigger} ${PARSE_SYSCALLS_HEADER_DEPENDS}

)

# Make sure Picolibc is built before the rest of the system; there's no explicit

# reference to any of the files as they're all picked up by various compiler

# settings

if(CONFIG_PICOLIBC_USE_MODULE)

set(picolibc_dependency PicolibcBuild)

endif()

add_custom_target(${SYSCALL_LIST_H_TARGET} DEPENDS ${syscall_list_h} ${picolibc_dependency})

set_property(TARGET ${SYSCALL_LIST_H_TARGET}

APPEND PROPERTY

ADDITIONAL_CLEAN_FILES

${CMAKE_CURRENT_BINARY_DIR}/include/generated/syscalls

)

add_custom_target(${PARSE_SYSCALLS_TARGET}

DEPENDS

${syscalls_json}

${struct_tags_json}

)

# 64-bit systems do not require special handling of 64-bit system call

# parameters or return values, indicate this to the system call boilerplate

# generation script.

if(CONFIG_64BIT)

set(SYSCALL_LONG_REGISTERS_ARG --long-registers)

endif()

if(CONFIG_TIMEOUT_64BIT)

set(SYSCALL_SPLIT_TIMEOUT_ARG --split-type k_timeout_t --split-type k_ticks_t)

endif()

add_custom_command(OUTPUT include/generated/syscall_dispatch.c ${syscall_list_h}

# Also, some files are written to include/generated/syscalls/

COMMAND

${PYTHON_EXECUTABLE}

${ZEPHYR_BASE}/scripts/build/gen_syscalls.py

--json-file ${syscalls_json} # Read this file

--base-output include/generated/syscalls # Write to this dir

--syscall-dispatch include/generated/syscall_dispatch.c # Write this file

--syscall-list ${syscall_list_h}

${SYSCALL_LONG_REGISTERS_ARG}

${SYSCALL_SPLIT_TIMEOUT_ARG}

WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}

DEPENDS ${PARSE_SYSCALLS_TARGET}

)

# This is passed into all calls to the gen_kobject_list.py script.

set(gen_kobject_list_include_args --include ${struct_tags_json})

set(DRV_VALIDATION ${PROJECT_BINARY_DIR}/include/generated/driver-validation.h)

add_custom_command(

OUTPUT ${DRV_VALIDATION}

COMMAND

${PYTHON_EXECUTABLE}

${ZEPHYR_BASE}/scripts/build/gen_kobject_list.py

--validation-output ${DRV_VALIDATION}

${gen_kobject_list_include_args}

$<$<BOOL:${CMAKE_VERBOSE_MAKEFILE}>:--verbose>

DEPENDS

${ZEPHYR_BASE}/scripts/build/gen_kobject_list.py

${PARSE_SYSCALLS_TARGET}

WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}

)

add_custom_target(${DRIVER_VALIDATION_H_TARGET} DEPENDS ${DRV_VALIDATION})

include(${ZEPHYR_BASE}/cmake/kobj.cmake)

gen_kobj(KOBJ_INCLUDE_PATH)

# Add a pseudo-target that is up-to-date when all generated headers

# are up-to-date.

add_custom_target(zephyr_generated_headers)

add_dependencies(zephyr_generated_headers

offsets_h version_h

)

# Generate offsets.c.obj from offsets.c

# Generate offsets.h from offsets.c.obj

set(OFFSETS_LIB offsets)

set(OFFSETS_C_PATH ${ARCH_DIR}/${ARCH}/core/offsets/offsets.c)

set(OFFSETS_H_PATH ${PROJECT_BINARY_DIR}/include/generated/offsets.h)

add_library( ${OFFSETS_LIB} OBJECT ${OFFSETS_C_PATH})

target_include_directories(${OFFSETS_LIB} PRIVATE

kernel/include

${ARCH_DIR}/${ARCH}/include

)

target_link_libraries(${OFFSETS_LIB} zephyr_interface)

add_dependencies(zephyr_interface

${SYSCALL_LIST_H_TARGET}

${DRIVER_VALIDATION_H_TARGET}

${KOBJ_TYPES_H_TARGET}

)

add_custom_command(

OUTPUT ${OFFSETS_H_PATH}

COMMAND ${PYTHON_EXECUTABLE} ${ZEPHYR_BASE}/scripts/build/gen_offset_header.py

-i $<TARGET_OBJECTS:${OFFSETS_LIB}>

-o ${OFFSETS_H_PATH}

DEPENDS

${OFFSETS_LIB}

$<TARGET_OBJECTS:${OFFSETS_LIB}>

)

add_custom_target(${OFFSETS_H_TARGET} DEPENDS ${OFFSETS_H_PATH})

zephyr_get_include_directories_for_lang(C ZEPHYR_INCLUDES)

add_subdirectory(kernel)

# Read list content

get_property(ZEPHYR_LIBS_PROPERTY GLOBAL PROPERTY ZEPHYR_LIBS)

foreach(zephyr_lib ${ZEPHYR_LIBS_PROPERTY})

get_property(lib_type TARGET ${zephyr_lib} PROPERTY TYPE)

# To prevent CMake failure when a driver is enabled, for example: REGULATOR=y

# we disable any Zephyr libraries without sources and adds the `empty_file.c`.

if(${lib_type} STREQUAL STATIC_LIBRARY

AND NOT ${zephyr_lib} STREQUAL app

)

get_property(source_list TARGET ${zephyr_lib} PROPERTY SOURCES)

get_property(lib_imported TARGET ${zephyr_lib} PROPERTY IMPORTED)

if(NOT source_list

AND NOT ${lib_imported}

)

get_property(allow_empty TARGET ${zephyr_lib} PROPERTY ALLOW_EMPTY)

if(NOT "${allow_empty}")

message(WARNING

"No SOURCES given to Zephyr library: ${zephyr_lib}\nExcluding target from build."

)

endif()

target_sources(${zephyr_lib} PRIVATE ${ZEPHYR_BASE}/misc/empty_file.c)

set_property(TARGET ${zephyr_lib} PROPERTY EXCLUDE_FROM_ALL TRUE)

list(REMOVE_ITEM ZEPHYR_LIBS_PROPERTY ${zephyr_lib})

continue()

endif()

endif()

# TODO: Could this become an INTERFACE property of zephyr_interface?

add_dependencies(${zephyr_lib} zephyr_generated_headers)

endforeach()

get_property(OUTPUT_FORMAT GLOBAL PROPERTY PROPERTY_OUTPUT_FORMAT)

if (CONFIG_CODE_DATA_RELOCATION)

set(CODE_RELOCATION_DEP code_relocation_source_lib)

endif() # CONFIG_CODE_DATA_RELOCATION

# Give the linker script targets all of the include directories so

# that cmake can successfully find the linker scripts' header

# dependencies.

zephyr_get_include_directories_for_lang(C

ZEPHYR_INCLUDE_DIRS

STRIP_PREFIX # Don't use a -I prefix

)

if(CONFIG_PM_DEVICE_POWER_DOMAIN_DYNAMIC)

set(number_of_dynamic_devices ${CONFIG_PM_DEVICE_POWER_DOMAIN_DYNAMIC_NUM})

else()

set(number_of_dynamic_devices 0)

endif()

if(CONFIG_HAS_DTS)

# dev_handles.c is generated from ${ZEPHYR_LINK_STAGE_EXECUTABLE} by

# gen_handles.py

add_custom_command(

OUTPUT dev_handles.c

COMMAND

${PYTHON_EXECUTABLE}

${ZEPHYR_BASE}/scripts/build/gen_handles.py

--output-source dev_handles.c

--output-graphviz dev_graph.dot

--num-dynamic-devices ${number_of_dynamic_devices}

--kernel $<TARGET_FILE:${ZEPHYR_LINK_STAGE_EXECUTABLE}>

--zephyr-base ${ZEPHYR_BASE}

--start-symbol "$<TARGET_PROPERTY:linker,devices_start_symbol>"

VERBATIM

DEPENDS ${ZEPHYR_LINK_STAGE_EXECUTABLE}

)

set_property(GLOBAL APPEND PROPERTY GENERATED_APP_SOURCE_FILES dev_handles.c)

# gen_handles runs on `__device_handles_pass1` so pass this info to the linker script generator

list(APPEND LINKER_PASS_${ZEPHYR_CURRENT_LINKER_PASS}_DEFINE "LINKER_DEVICE_HANDLES_PASS1")

endif()

if(CONFIG_CODE_DATA_RELOCATION)

# @Intent: Linker script to relocate .text, data and .bss sections

toolchain_ld_relocation()

endif()

if(CONFIG_USERSPACE)

zephyr_get_compile_options_for_lang_as_string(C compiler_flags_priv)

string(REPLACE "$<TARGET_PROPERTY:compiler,coverage>" ""

NO_COVERAGE_FLAGS "${compiler_flags_priv}"

)

set(GEN_KOBJ_LIST ${ZEPHYR_BASE}/scripts/build/gen_kobject_list.py)

set(PROCESS_GPERF ${ZEPHYR_BASE}/scripts/build/process_gperf.py)

endif()

get_property(CSTD GLOBAL PROPERTY CSTD)

set_ifndef(CSTD c99)

# @Intent: Obtain compiler specific flag for specifying the c standard

zephyr_compile_options(

$<$<COMPILE_LANGUAGE:C>:$<TARGET_PROPERTY:compiler,cstd>${CSTD}>

)

set(CMAKE_C_COMPILE_FEATURES ${compile_features_${CSTD}} PARENT_SCOPE)

# @Intent: Configure linker scripts, i.e. generate linker scripts with variables substituted

toolchain_ld_configure_files()

if(CONFIG_USERSPACE)

set(APP_SMEM_ALIGNED_LD "${PROJECT_BINARY_DIR}/include/generated/app_smem_aligned.ld")

set(APP_SMEM_UNALIGNED_LD "${PROJECT_BINARY_DIR}/include/generated/app_smem_unaligned.ld")

if(CONFIG_LINKER_USE_PINNED_SECTION)

set(APP_SMEM_PINNED_ALIGNED_LD

"${PROJECT_BINARY_DIR}/include/generated/app_smem_pinned_aligned.ld")

set(APP_SMEM_PINNED_UNALIGNED_LD

"${PROJECT_BINARY_DIR}/include/generated/app_smem_pinned_unaligned.ld")

if(NOT CONFIG_LINKER_GENERIC_SECTIONS_PRESENT_AT_BOOT)

# The libc partition may hold symbols that are required during boot process,

# for example, stack guard (if enabled). So the libc partition must be pinned

# if not sections are in physical memory at boot, as the paging mechanism is

# only initialized post-kernel.

set_property(TARGET app_smem APPEND PROPERTY pinned_partitions "z_libc_partition")

endif()

get_property(APP_SMEM_PINNED_PARTITION_LIST TARGET app_smem PROPERTY pinned_partitions)

if(APP_SMEM_PINNED_PARTITION_LIST)

list(JOIN APP_SMEM_PINNED_PARTITION_LIST "," APP_SMEM_PINNED_PARTITION_LIST_ARG_CSL)

set(APP_SMEM_PINNED_PARTITION_LIST_ARG "--pinpartitions=${APP_SMEM_PINNED_PARTITION_LIST_ARG_CSL}")

endif()

endif()

set(OBJ_FILE_DIR "${PROJECT_BINARY_DIR}/../")

if(CONFIG_NEWLIB_LIBC)

set(LIBC_PART -l libc.a z_libc_partition -l libm.a z_libc_partition)

endif()

if(CONFIG_NEWLIB_LIBC_NANO)

set(LIBC_PART -l libc_nano.a z_libc_partition -l libm_nano.a z_libc_partition)

endif()

if(CONFIG_PICOLIBC)

set(LIBC_PART -l libc.a z_libc_partition)

endif()

add_custom_command(

OUTPUT ${APP_SMEM_UNALIGNED_LD} ${APP_SMEM_PINNED_UNALIGNED_LD}

COMMAND ${PYTHON_EXECUTABLE}

${ZEPHYR_BASE}/scripts/build/gen_app_partitions.py

-f ${CMAKE_BINARY_DIR}/compile_commands.json

-o ${APP_SMEM_UNALIGNED_LD}

$<$<BOOL:${APP_SMEM_PINNED_UNALIGNED_LD}>:--pinoutput=${APP_SMEM_PINNED_UNALIGNED_LD}>

${APP_SMEM_PINNED_PARTITION_LIST_ARG}

${LIBC_PART}

$<TARGET_PROPERTY:zephyr_property_target,COMPILE_OPTIONS>

$<$<BOOL:${CMAKE_VERBOSE_MAKEFILE}>:--verbose>

DEPENDS

kernel

${CMAKE_BINARY_DIR}/compile_commands.json

${ZEPHYR_LIBS_PROPERTY}

WORKING_DIRECTORY ${PROJECT_BINARY_DIR}/

COMMAND_EXPAND_LISTS

COMMENT "Generating app_smem_unaligned linker section"

)

add_custom_target(

${APP_SMEM_ALIGNED_DEP}

DEPENDS

${APP_SMEM_ALIGNED_LD}

${APP_SMEM_PINNED_ALIGNED_LD}

)

add_custom_target(

${APP_SMEM_UNALIGNED_DEP}

DEPENDS

${APP_SMEM_UNALIGNED_LD}

${APP_SMEM_PINNED_UNALIGNED_LD}

)

set(APP_SMEM_UNALIGNED_LIB app_smem_unaligned_output_obj_renamed_lib)

list(APPEND LINKER_PASS_${ZEPHYR_CURRENT_LINKER_PASS}_DEFINE "LINKER_APP_SMEM_UNALIGNED")

endif()

if (CONFIG_USERSPACE)

add_custom_command(

OUTPUT ${APP_SMEM_ALIGNED_LD} ${APP_SMEM_PINNED_ALIGNED_LD}

COMMAND ${PYTHON_EXECUTABLE}

${ZEPHYR_BASE}/scripts/build/gen_app_partitions.py

-e $<TARGET_FILE:${ZEPHYR_LINK_STAGE_EXECUTABLE}>

-o ${APP_SMEM_ALIGNED_LD}

$<$<BOOL:${APP_SMEM_PINNED_ALIGNED_LD}>:--pinoutput=${APP_SMEM_PINNED_ALIGNED_LD}>

${APP_SMEM_PINNED_PARTITION_LIST_ARG}

${LIBC_PART}

$<TARGET_PROPERTY:zephyr_property_target,COMPILE_OPTIONS>

$<$<BOOL:${CMAKE_VERBOSE_MAKEFILE}>:--verbose>

DEPENDS

kernel

${ZEPHYR_LIBS_PROPERTY}

${ZEPHYR_LINK_STAGE_EXECUTABLE}

WORKING_DIRECTORY ${PROJECT_BINARY_DIR}/