ARMmbed
/
mbed-os
mirror of https://github.com/ARMmbed/mbed-os.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
mbed-os/CMakeLists.txt

277 lines
11 KiB
CMake
Raw Normal View History

CMake: Refactor mapfile generation The refactoring was necessary to remove a function call (mbed_configure_app_target()) from application's CMakeLists.txt.
2021-02-17 17:28:47 +00:00
# Copyright (c) 2020-2021 ARM Limited. All rights reserved.
CMake: Add CMake scripts
2020-07-20 16:52:23 +00:00
# SPDX-License-Identifier: Apache-2.0
CMake: Use modern CMake techniques to set toolchain options Use target_compile_options(), target_compile_definitions(), and target_link_options() to set toolchain options.
2020-07-23 19:23:56 +00:00
# This is the boilerplate for Mbed OS
CMake: Add CMake scripts
2020-07-20 16:52:23 +00:00
Whoops, accidentally committed version change
2020-12-01 00:28:28 +00:00
cmake_minimum_required(VERSION 3.19.0 FATAL_ERROR)
CMake: Add CMake scripts
2020-07-20 16:52:23 +00:00
CMake: Set compile defintions for supported toolchain at top level input source file The compile defintions should always be added depending on the selected toolchain. mbed_set_toolchain_options() should only be called if a third-party toolchain file has not been used as it has compile options that can cause conflicts.
2020-10-28 16:50:23 +00:00
include(${MBED_CONFIG_PATH}/mbed_config.cmake)
CMake: add mbed_ prefix to our CMake files To avoid conflicts as we expose our CMake list files via CMAKE_MODULE_PATH. Some files already include it, this aligns the rest of files. I leave app.cmake as it is - it's user facing and it would be breaking change. We can clean this one for the next major version.
2021-04-12 12:21:28 +00:00
include(mbed_set_linker_script)
CMake: Do not hard code target in CPU core CMake module Provide a function in each CPU core module to set toolchain options. All the functions have the same interface therefore the CMake source file including the module always calls the same function regardless of which cpu core module is actually included. When the `mbed-os` target is broken up into multiple libraries, a library other than `mbed-os` might need to set the toolchain options. This will be possible by simply including the module and calling the function with the target and toolchain for which to set the options.
2020-08-04 18:23:25 +00:00
CMake: use project name for Mbed OS This enables multiple variables we can use. One of them is source dir for a project. It will replace MBED_PATH in the tree.
2021-04-08 11:59:53 +00:00
project(mbed-os)
CMake: set CMAKE_MODULE_PATH in the Mbed OS CMakelists.txt Update CMAKE_MODULE_PATH at once place. Note, we update also CMAKE_MODULE_PATH in app.cmake. This is temporary until we get a proper way to include Mbed Os (removing app.cmake need to be included by an application).
2021-04-14 11:22:53 +00:00
# Add all paths to the list files within Mbed OS
list(APPEND CMAKE_MODULE_PATH
"${mbed-os_SOURCE_DIR}/platform/FEATURE_EXPERIMENTAL_API/FEATURE_PSA/TARGET_TFM/TARGET_TFM_LATEST/scripts;${mbed-os_SOURCE_DIR}/targets/TARGET_Cypress/scripts;${mbed-os_SOURCE_DIR}/targets/TARGET_NXP/scripts"
)
CMake: add mbed-os and mbed-baremetal targets mbed-os consists of mbed-core and mbed-rtos mbed-baremetal consists of mbed-core The main change is for mbed-core. Changing from object library to be interface. This way it allows us to do the above to have 2 main targets for users to use. This should be backward compatible change as mbed-os target we used contains the same files/options as previously set.
2020-10-26 16:13:36 +00:00
add_library(mbed-core INTERFACE)
CMake: use CMAKE_TOOLCHAIN_FILE We should define CMAKE_TOOLCHAIN_FILE (as we are providing Mbed OS toolchain file). This fixes also the issue we had with Unix makefiles where application would be without response files. For more details, see https://gitlab.kitware.com/cmake/cmake/-/issues/21104 As the Mbed OS toolchain file is included by CMake, we need to have enabling language in the main CMake (can be executed only once).
2020-08-25 11:40:20 +00:00
CMake: add mbed-os and mbed-baremetal targets mbed-os consists of mbed-core and mbed-rtos mbed-baremetal consists of mbed-core The main change is for mbed-core. Changing from object library to be interface. This way it allows us to do the above to have 2 main targets for users to use. This should be backward compatible change as mbed-os target we used contains the same files/options as previously set.
2020-10-26 16:13:36 +00:00
add_library(mbed-os INTERFACE)
target_link_libraries(mbed-os
CMake: Fix third party toolchain file suppport Compile defintions are always included. However, functions that set compile options are only called if a third party toolchain file is not used
2020-10-28 16:53:46 +00:00
INTERFACE
mbed-rtos
mbed-core
CMake: add mbed-os and mbed-baremetal targets mbed-os consists of mbed-core and mbed-rtos mbed-baremetal consists of mbed-core The main change is for mbed-core. Changing from object library to be interface. This way it allows us to do the above to have 2 main targets for users to use. This should be backward compatible change as mbed-os target we used contains the same files/options as previously set.
2020-10-26 16:13:36 +00:00
)
add_library(mbed-baremetal INTERFACE)
target_link_libraries(mbed-baremetal
INTERFACE
mbed-core
)
CMake: Add support for C lib selection Configure the selected toolchain for the selected C library
2020-09-15 13:37:07 +00:00
# Validate selected C library type
# The C library type selected has to match the library that the target can support
if(${MBED_C_LIB} STREQUAL "small")
if(NOT "small" IN_LIST MBED_TARGET_SUPPORTED_C_LIBS)
if("std" IN_LIST MBED_TARGET_SUPPORTED_C_LIBS)
message(WARNING
"We noticed that target.c_lib is set to `${MBED_C_LIB}`."
" As the ${MBED_TARGET} target does not support a small C library for the ${MBED_TOOLCHAIN} toolchain,"
" we are using the standard C library instead."
)
set(MBED_C_LIB "std" CACHE STRING "")
cmake: Remove whitespace from mbed-os/CMakeLists.txt
2021-01-27 12:26:54 +00:00
endif()
CMake: Add support for C lib selection Configure the selected toolchain for the selected C library
2020-09-15 13:37:07 +00:00
endif()
elseif(NOT ${MBED_C_LIB} IN_LIST MBED_TARGET_SUPPORTED_C_LIBS)
message(FATAL_ERROR
"Invalid `target.c_lib` ('${MBED_C_LIB}') for '${MBED_TARGET}' target."
"\nPossible value(s): ${MBED_TARGET_SUPPORTED_C_LIBS}"
)
endif()
CMake: Add support for printf lib selection
2020-09-15 11:18:00 +00:00
# Validate selected printf library
set(MBED_PRINTF_LIB_TYPES std minimal-printf)
if(NOT ${MBED_PRINTF_LIB} IN_LIST MBED_PRINTF_LIB_TYPES)
message(FATAL_ERROR
"Invalid printf library type '${MBED_PRINTF_LIB}'. Possible values:\n ${MBED_PRINTF_LIB_TYPES}"
)
endif()
CMake: Fix third party toolchain file suppport Compile defintions are always included. However, functions that set compile options are only called if a third party toolchain file is not used
2020-10-28 16:53:46 +00:00
mbed_set_cpu_core_definitions(mbed-core)
if(${MBED_TOOLCHAIN_FILE_USED})
mbed_set_profile_options(mbed-core ${MBED_TOOLCHAIN})
mbed_set_c_lib(mbed-core ${MBED_C_LIB})
mbed_set_printf_lib(mbed-core ${MBED_PRINTF_LIB})
CMake: move language standard to mbed-core We set language standard via mbed-core and app inherits it if links to it. This is breaking change for application, please remove the function call from an application and it should build without errors.
2021-02-10 10:30:11 +00:00
target_compile_features(mbed-core
INTERFACE
c_std_11
cxx_std_14
)
CMake: Fix third party toolchain file suppport Compile defintions are always included. However, functions that set compile options are only called if a third party toolchain file is not used
2020-10-28 16:53:46 +00:00
endif()
CMake: Rename CMake targets * mbed-os renamed mbed-core * mbed-os-<COMPONENT> renamed mbed-<COMPONENT>
2020-10-22 16:00:21 +00:00
target_compile_definitions(mbed-core
CMake: add mbed-os and mbed-baremetal targets mbed-os consists of mbed-core and mbed-rtos mbed-baremetal consists of mbed-core The main change is for mbed-core. Changing from object library to be interface. This way it allows us to do the above to have 2 main targets for users to use. This should be backward compatible change as mbed-os target we used contains the same files/options as previously set.
2020-10-26 16:13:36 +00:00
INTERFACE
CMake: Minor formatting of top level CMakeLists.txt source file
2020-08-06 15:41:48 +00:00
${MBED_TARGET_DEFINITIONS}
${MBED_CONFIG_DEFINITIONS}
)
CMake: Remove app.cmake module This module was doing things that mbed-os and the application were supposed to do. Moved the statements form the module to `mbed-os/CMakeLists.txt` and to `<APPLICATION_ROOT>/CMakeLists.txt` . Mbed OS also ensures the executable produced uses whatever name the application has set.
2020-07-30 11:51:46 +00:00
CMake: Generate response file before adding mbed-targets We need to generate a "response file" to pass to the C preprocessor when we preprocess the linker script, because of path length limitations on Windows. We set the response file and bind the path to a global property. The MBED_TARGET being built queries this global property when it sets the linker script. We must set this global property before the targets subdirectory is added to the project. This is required because the MBED_TARGET depends on the response file. If the path to the response file is not defined when the target requests it the config definitions will not be passed to CPP.
2021-02-11 15:59:19 +00:00
# We need to generate a "response file" to pass to the C preprocessor when we preprocess the linker
# script, because of path length limitations on Windows. We set the response file and bind the path
# to a global property here. The MBED_TARGET being built queries this global property when it sets
# the linker script.
#
# We must set this global property before the targets subdirectory is added to the project. This is
# required because the MBED_TARGET depends on the response file. If the path to the response file
# is not defined when the target requests it the config definitions will not be passed to CPP.
#
# TODO: Remove this and find a more idiomatic way of passing compile definitions to CPP without
# using response files or global properties.
mbed_generate_options_for_linker(mbed-core RESPONSE_FILE_PATH)
set_property(GLOBAL PROPERTY COMPILE_DEFS_RESPONSE_FILE ${RESPONSE_FILE_PATH})
CMake: Set compile defintions for supported toolchain at top level input source file The compile defintions should always be added depending on the selected toolchain. mbed_set_toolchain_options() should only be called if a third-party toolchain file has not been used as it has compile options that can cause conflicts.
2020-10-28 16:50:23 +00:00
# Add compile definitions for backward compatibility with the toolchain
# supported. New source files should instead check for __GNUC__ and __clang__
cmake: Remove whitespace from mbed-os/CMakeLists.txt
2021-01-27 12:26:54 +00:00
# for the GCC_ARM and ARM toolchains respectively.
CMake: Set compile defintions for supported toolchain at top level input source file The compile defintions should always be added depending on the selected toolchain. mbed_set_toolchain_options() should only be called if a third-party toolchain file has not been used as it has compile options that can cause conflicts.
2020-10-28 16:50:23 +00:00
if(${MBED_TOOLCHAIN} STREQUAL "GCC_ARM")
target_compile_definitions(mbed-core
INTERFACE
TOOLCHAIN_GCC_ARM
TOOLCHAIN_GCC
)
elseif(${MBED_TOOLCHAIN} STREQUAL "ARM")
target_compile_definitions(mbed-core
INTERFACE
TOOLCHAIN_ARM
)
endif()
CMake: Add CMake scripts
2020-07-20 16:52:23 +00:00
# Include mbed.h and config from generate folder
CMake: Rename CMake targets * mbed-os renamed mbed-core * mbed-os-<COMPONENT> renamed mbed-<COMPONENT>
2020-10-22 16:00:21 +00:00
target_include_directories(mbed-core
CMake: add mbed-os and mbed-baremetal targets mbed-os consists of mbed-core and mbed-rtos mbed-baremetal consists of mbed-core The main change is for mbed-core. Changing from object library to be interface. This way it allows us to do the above to have 2 main targets for users to use. This should be backward compatible change as mbed-os target we used contains the same files/options as previously set.
2020-10-26 16:13:36 +00:00
INTERFACE
CMake: Minor formatting of top level CMakeLists.txt source file
2020-08-06 15:41:48 +00:00
${CMAKE_CURRENT_SOURCE_DIR}
)
CMake: Add CMake scripts
2020-07-20 16:52:23 +00:00
CMake: split rtos from core target Add or remove and directories containing source files, header files, and macro definitions that implement RTOS support. This includes: - cmsis/CMSIS_5/CMSIS/RTOS2/ - cmsis/device/rtos/ - rtos/source/ConditionVariable.cpp - rtos/source/Thread.cpp
2020-10-16 13:21:21 +00:00
# These targets are made visible here so their source files which
# are spread in different directories can be referenced and can be linked against
# by libraries that depend on them.
# TODO CMake: Should the source files be moved?
CMake: Rename CMake targets * mbed-os renamed mbed-core * mbed-os-<COMPONENT> renamed mbed-<COMPONENT>
2020-10-22 16:00:21 +00:00
add_library(mbed-device_key INTERFACE)
CMake: split rtos from core target Add or remove and directories containing source files, header files, and macro definitions that implement RTOS support. This includes: - cmsis/CMSIS_5/CMSIS/RTOS2/ - cmsis/device/rtos/ - rtos/source/ConditionVariable.cpp - rtos/source/Thread.cpp
2020-10-16 13:21:21 +00:00
add_library(mbed-rtos INTERFACE)
CMake: Componentize Mbed OS into multiple CMake targets (#13732) Aside from the core mbed-os CMake target, a number of targets have been created so they can optionally be included by application executables that require them using `target_link_libraries()`. Co-authored-by: Martin Kojtal <martin.kojtal@arm.com> Co-authored-by: Rajkumar Kanagaraj <rajkumar.kanagaraj@arm.com>
2020-10-12 11:35:19 +00:00
CMake: Add CMake scripts
2020-07-20 16:52:23 +00:00
add_subdirectory(cmsis)
add_subdirectory(drivers)
add_subdirectory(hal)
add_subdirectory(platform)
add_subdirectory(rtos)
add_subdirectory(targets)
CMake: Remove app.cmake module This module was doing things that mbed-os and the application were supposed to do. Moved the statements form the module to `mbed-os/CMakeLists.txt` and to `<APPLICATION_ROOT>/CMakeLists.txt` . Mbed OS also ensures the executable produced uses whatever name the application has set.
2020-07-30 11:51:46 +00:00
CMake: Componentize Mbed OS into multiple CMake targets (#13732) Aside from the core mbed-os CMake target, a number of targets have been created so they can optionally be included by application executables that require them using `target_link_libraries()`. Co-authored-by: Martin Kojtal <martin.kojtal@arm.com> Co-authored-by: Rajkumar Kanagaraj <rajkumar.kanagaraj@arm.com>
2020-10-12 11:35:19 +00:00
# The directories below contain optional target libraries
add_subdirectory(events EXCLUDE_FROM_ALL)
add_subdirectory(connectivity EXCLUDE_FROM_ALL)
add_subdirectory(storage EXCLUDE_FROM_ALL)
add_subdirectory(drivers/device_key EXCLUDE_FROM_ALL)
Fixed top-level CMakeLists.txt
2020-11-13 15:49:24 +00:00
add_subdirectory(drivers/usb EXCLUDE_FROM_ALL)
CMake: Componentize Mbed OS into multiple CMake targets (#13732) Aside from the core mbed-os CMake target, a number of targets have been created so they can optionally be included by application executables that require them using `target_link_libraries()`. Co-authored-by: Martin Kojtal <martin.kojtal@arm.com> Co-authored-by: Rajkumar Kanagaraj <rajkumar.kanagaraj@arm.com>
2020-10-12 11:35:19 +00:00
add_subdirectory(features EXCLUDE_FROM_ALL)
CMake: split rtos from core target Add or remove and directories containing source files, header files, and macro definitions that implement RTOS support. This includes: - cmsis/CMSIS_5/CMSIS/RTOS2/ - cmsis/device/rtos/ - rtos/source/ConditionVariable.cpp - rtos/source/Thread.cpp
2020-10-16 13:21:21 +00:00
add_subdirectory(cmsis/CMSIS_5/CMSIS/RTOS2 EXCLUDE_FROM_ALL)
add_subdirectory(cmsis/device/rtos EXCLUDE_FROM_ALL)
CMake: Remove app.cmake module This module was doing things that mbed-os and the application were supposed to do. Moved the statements form the module to `mbed-os/CMakeLists.txt` and to `<APPLICATION_ROOT>/CMakeLists.txt` . Mbed OS also ensures the executable produced uses whatever name the application has set.
2020-07-30 11:51:46 +00:00
CMake: fix wording in naming Co-authored-by: Hugues Kamba <41612201+hugueskamba@users.noreply.github.com>
2021-02-10 12:15:48 +00:00
# Ensure the words that make up the Mbed target name are separated with a hyphen, lowercase, and with the `mbed-` prefix.
CMake: add naming convention for mbed targets Using lowercase with dashes for targets with mbed- prefix
2021-02-09 15:17:31 +00:00
string(TOLOWER ${MBED_TARGET} MBED_TARGET_CONVERTED)
string(REPLACE "_" "-" MBED_TARGET_CONVERTED ${MBED_TARGET_CONVERTED})
string(PREPEND MBED_TARGET_CONVERTED "mbed-")
CMake: remove workaround for targets prior refactor As we refactored all targets, we can remove this workaround from the tree.
2021-02-15 14:11:09 +00:00
target_link_libraries(mbed-core INTERFACE ${MBED_TARGET_CONVERTED})
cmake: Refactor mbed_set_mbed_target_linker_script Move the mbed_set_mbed_target_linker_script function into its own file and make it set the linkerscript on the target passed in, rather than setting the linkerscript on the top level mbed-core target. We use CMake's automatic forwarding of usage requirements to forward the linker script to the top level target. This commit also adds a condition to check whether the MBED_TARGET is a CMake buildsystem target. If it is we will just link to it in the idiomatic CMake way, if it's not then we use the 'old' mechanism of setting the linkerscript for the mbed-core target. This check will be useful when we refactor MBED_TARGETS to be CMake buildsystem targets as it will allow us to do the refactoring incrementally.
2021-01-27 12:27:48 +00:00
CMake: Remove add_executable Instead provide functions to set the pre and post link commands.
2020-07-30 15:42:41 +00:00
#
# Converts output file of `target` to binary file and to Intel HEX file.
#
CMake: Use `mbed_` prefix for CMake functions
2020-08-12 12:11:16 +00:00
function(mbed_generate_bin_hex target)
CMake: Remove add_executable Instead provide functions to set the pre and post link commands.
2020-07-30 15:42:41 +00:00
get_property(elf_to_bin GLOBAL PROPERTY ELF2BIN)
CMake: Image format based on MBED_OUTPUT_EXT Requires: https://github.com/ARMmbed/mbed-tools/pull/242 The optional `OUTPUT_EXT` field in Mbed OS `targets.json` specifies the format of the output image. This is important because * some targets only support one image format * each post-binary hook outputs one image only This avoids confusion of having both .hex and .bin images generated while only one of them is usable.
2021-03-25 12:40:33 +00:00
if (MBED_TOOLCHAIN STREQUAL "GCC_ARM")
# The first condition is quoted in case MBED_OUTPUT_EXT is unset
if ("${MBED_OUTPUT_EXT}" STREQUAL "" OR MBED_OUTPUT_EXT STREQUAL "bin")
list(APPEND CMAKE_POST_BUILD_COMMAND
COMMAND ${elf_to_bin} -O binary $<TARGET_FILE:${target}> ${CMAKE_CURRENT_BINARY_DIR}/${target}.bin
COMMAND ${CMAKE_COMMAND} -E echo "-- built: ${CMAKE_CURRENT_BINARY_DIR}/${target}.bin"
)
endif()
if ("${MBED_OUTPUT_EXT}" STREQUAL "" OR MBED_OUTPUT_EXT STREQUAL "hex")
list(APPEND CMAKE_POST_BUILD_COMMAND
COMMAND ${elf_to_bin} -O ihex $<TARGET_FILE:${target}> ${CMAKE_CURRENT_BINARY_DIR}/${target}.hex
COMMAND ${CMAKE_COMMAND} -E echo "-- built: ${CMAKE_CURRENT_BINARY_DIR}/${target}.hex"
)
endif()
CMake: Remove add_executable Instead provide functions to set the pre and post link commands.
2020-07-30 15:42:41 +00:00
elseif(MBED_TOOLCHAIN STREQUAL "ARM")
get_property(mbed_studio_arm_compiler GLOBAL PROPERTY MBED_STUDIO_ARM_COMPILER)
CMake: Image format based on MBED_OUTPUT_EXT Requires: https://github.com/ARMmbed/mbed-tools/pull/242 The optional `OUTPUT_EXT` field in Mbed OS `targets.json` specifies the format of the output image. This is important because * some targets only support one image format * each post-binary hook outputs one image only This avoids confusion of having both .hex and .bin images generated while only one of them is usable.
2021-03-25 12:40:33 +00:00
if ("${MBED_OUTPUT_EXT}" STREQUAL "" OR MBED_OUTPUT_EXT STREQUAL "bin")
list(APPEND CMAKE_POST_BUILD_COMMAND
COMMAND ${elf_to_bin} ${mbed_studio_arm_compiler} --bin -o ${CMAKE_CURRENT_BINARY_DIR}/${target}.bin $<TARGET_FILE:${target}>
COMMAND ${CMAKE_COMMAND} -E echo "-- built: ${CMAKE_CURRENT_BINARY_DIR}/${target}.bin"
)
endif()
if ("${MBED_OUTPUT_EXT}" STREQUAL "" OR MBED_OUTPUT_EXT STREQUAL "hex")
list(APPEND CMAKE_POST_BUILD_COMMAND
Change CMAKE_BINARY_DIR to CMAKE_CURRENT_BINARY_DIR
2021-02-11 21:49:07 +00:00
COMMAND ${elf_to_bin} ${mbed_studio_arm_compiler} --i32combined -o ${CMAKE_CURRENT_BINARY_DIR}/${target}.hex $<TARGET_FILE:${target}>
COMMAND ${CMAKE_COMMAND} -E echo "-- built: ${CMAKE_CURRENT_BINARY_DIR}/${target}.hex"
CMake: Image format based on MBED_OUTPUT_EXT Requires: https://github.com/ARMmbed/mbed-tools/pull/242 The optional `OUTPUT_EXT` field in Mbed OS `targets.json` specifies the format of the output image. This is important because * some targets only support one image format * each post-binary hook outputs one image only This avoids confusion of having both .hex and .bin images generated while only one of them is usable.
2021-03-25 12:40:33 +00:00
)
endif()
CMake: Remove add_executable Instead provide functions to set the pre and post link commands.
2020-07-30 15:42:41 +00:00
endif()
add_custom_command(
TARGET
${target}
POST_BUILD
${CMAKE_POST_BUILD_COMMAND}
COMMENT
"executable:"
VERBATIM
)
CMake: Add post build operation support A CMake custom target, mbed-post-build, is added as a dependency of the application CMake target if a Mbed target adds a CMake custom target named mbed-post-build-bin. mbed-post-build-bin is added as a dependency of mbed-post-build. mbed-post-build-bin depends on the application binary. This is done so a CMake custom command that executes post-build can be added. The Python scripts that implement the operations have been modified to add CLI entry points so they can be called from CMake. Dependency on the old tool has been removed on those scripts by passing them exactly what they require instead of passing old tool Python objects. A consequence of that was to slightly amend how the old tool calls some of those Python modules. Support has only been added for Mbed targets that currently have a requirement for post build operations. This includes: LPC1114, LPC1768, ARCH_PRO, LPC54114, LPC546XX, FF_LPC546XX, CY8CKIT064B0S2_4343W, CYTFM_064B0S2_4343W, CYSBSYSKIT_01 The following targets are not supported as TFM support is not yet included: ARM_MUSCA_B1, ARM_MUSCA_B1_NS, ARM_MUSCA_S1, ARM_MUSCA_S1_NS.
2021-01-26 13:52:29 +00:00
Fix post build mechanism with unique CMake custom targets The CMake custom target must be unique to avoid more than one Mbed target adding the same. Only the CMake custom command added for the Mbed target being built is run as the custom CMake target now includes the Mbed target name.
2021-02-15 17:39:27 +00:00
if(TARGET mbed-post-build-bin-${MBED_TARGET})
Force regenerate application binaries on rebuild If a target has a post binary hook, we should force regenerate the application binaries every time so that the hook is run on a raw binary rather than a previous build that already went through the post-build process once.
2021-03-03 18:11:45 +00:00
# Remove the .elf file to force regenerate the application binaries
# (including .bin and .hex). This ensures that the post-build script runs
# on a raw application instead of a previous build that already went
# through the post-build process once.
file(REMOVE ${CMAKE_CURRENT_BINARY_DIR}/${target}.elf)
CMake: pass application name to post-build hook Pass the exact name to the post-build hook, when an application's or test's `CMakeLists.txt` calls `mbed_set_post_build()`. The interface is CMake's built-in mechanism: * `set_target_properties()` to set a property, e.g. application name * `$<TARGET_PROPERTY:target,property>` to query a property at run time
2021-03-03 18:26:11 +00:00
# Pass the application's name to the Mbed target's post build operation
set_target_properties(mbed-post-build-bin-${MBED_TARGET}
PROPERTIES
application ${target}
)
CMake: Refactor post-build hook to remove APP_TARGET references There should not be a reference to APP_TARGET in Mbed OS as end-users may decide to use a different name for the CMake variable to store their application name.
2021-02-19 11:52:57 +00:00
# The artefacts must be created before they can be further manipulated
add_dependencies(mbed-post-build-bin-${MBED_TARGET} ${target})
# Add a post-build hook to the top-level CMake target in the form of a
# CMake custom target. The hook depends on Mbed target specific
# post-build CMake target which has a custom command attached to it.
add_custom_target(mbed-post-build ALL DEPENDS mbed-post-build-bin-${MBED_TARGET})
CMake: Add post build operation support A CMake custom target, mbed-post-build, is added as a dependency of the application CMake target if a Mbed target adds a CMake custom target named mbed-post-build-bin. mbed-post-build-bin is added as a dependency of mbed-post-build. mbed-post-build-bin depends on the application binary. This is done so a CMake custom command that executes post-build can be added. The Python scripts that implement the operations have been modified to add CLI entry points so they can be called from CMake. Dependency on the old tool has been removed on those scripts by passing them exactly what they require instead of passing old tool Python objects. A consequence of that was to slightly amend how the old tool calls some of those Python modules. Support has only been added for Mbed targets that currently have a requirement for post build operations. This includes: LPC1114, LPC1768, ARCH_PRO, LPC54114, LPC546XX, FF_LPC546XX, CY8CKIT064B0S2_4343W, CYTFM_064B0S2_4343W, CYSBSYSKIT_01 The following targets are not supported as TFM support is not yet included: ARM_MUSCA_B1, ARM_MUSCA_B1_NS, ARM_MUSCA_S1, ARM_MUSCA_S1_NS.
2021-01-26 13:52:29 +00:00
endif()
CMake: Remove add_executable Instead provide functions to set the pre and post link commands.
2020-07-30 15:42:41 +00:00
endfunction()
CMake: Add a function to generate executable artifacts with memap (#13695) - Add linker option to generate map file for GCC_ARM and ARM toolchain - Add mbed_generate_map_file function to call memap.py (parse the map file). - Add mbed_generate_executable function to generate executable artifacts with a memory map table
2020-10-08 17:39:13 +00:00
#
# Parse toolchain generated map file of `target` and display a readable table format.
#
function(mbed_generate_map_file target)
add_custom_command(
TARGET
${target}
POST_BUILD
CMake tools: use CMAKE_CURRENT_LIST_DIR instead of MBED_PATH Excluding greentea tests, they will be fixed separately (more work needed).
2021-04-08 12:38:09 +00:00
COMMAND ${Python3_EXECUTABLE} ${mbed-os_SOURCE_DIR}/tools/memap.py -t ${MBED_TOOLCHAIN} ${CMAKE_CURRENT_BINARY_DIR}/${target}${CMAKE_EXECUTABLE_SUFFIX}.map
CMake: Add a function to generate executable artifacts with memap (#13695) - Add linker option to generate map file for GCC_ARM and ARM toolchain - Add mbed_generate_map_file function to call memap.py (parse the map file). - Add mbed_generate_executable function to generate executable artifacts with a memory map table
2020-10-08 17:39:13 +00:00
WORKING_DIRECTORY
Change CMAKE_BINARY_DIR to CMAKE_CURRENT_BINARY_DIR
2021-02-11 21:49:07 +00:00
${CMAKE_CURRENT_BINARY_DIR}
CMake: Add a function to generate executable artifacts with memap (#13695) - Add linker option to generate map file for GCC_ARM and ARM toolchain - Add mbed_generate_map_file function to call memap.py (parse the map file). - Add mbed_generate_executable function to generate executable artifacts with a memory map table
2020-10-08 17:39:13 +00:00
COMMENT
"Displaying memory map for ${target}"
)
endfunction()
#
CMake: Validate selected application profile (#13856) Check if the selected application profile is supported by the selected Mbed Target
2020-11-06 17:16:42 +00:00
# Validate selected application profile.
CMake: Add a function to generate executable artifacts with memap (#13695) - Add linker option to generate map file for GCC_ARM and ARM toolchain - Add mbed_generate_map_file function to call memap.py (parse the map file). - Add mbed_generate_executable function to generate executable artifacts with a memory map table
2020-10-08 17:39:13 +00:00
#
CMake: Validate selected application profile (#13856) Check if the selected application profile is supported by the selected Mbed Target
2020-11-06 17:16:42 +00:00
function(mbed_validate_application_profile target)
get_target_property(app_link_libraries ${target} LINK_LIBRARIES)
string(FIND "${app_link_libraries}" "mbed-baremetal" string_found_position)
if(${string_found_position} GREATER_EQUAL 0)
if(NOT "bare-metal" IN_LIST MBED_TARGET_SUPPORTED_APPLICATION_PROFILES)
message(FATAL_ERROR
"Use full profile as baremetal profile is not supported for this Mbed target")
endif()
elseif(NOT "full" IN_LIST MBED_TARGET_SUPPORTED_APPLICATION_PROFILES)
message(FATAL_ERROR
"The full profile is not supported for this Mbed target")
endif()
endfunction()
#
# Set post build operations
#
function(mbed_set_post_build target)
Configure memory map per target to allow multiple add_executable
2021-02-26 12:38:37 +00:00
# The mapfile name includes the top-level target name and the
CMake: Refactor mapfile generation The refactoring was necessary to remove a function call (mbed_configure_app_target()) from application's CMakeLists.txt.
2021-02-17 17:28:47 +00:00
# executable suffix for all toolchains as CMake hardcodes the name of the
# diagnostic output file for some toolchains.
Configure memory map per target to allow multiple add_executable
2021-02-26 12:38:37 +00:00
mbed_configure_memory_map(${target} "${CMAKE_CURRENT_BINARY_DIR}/${target}${CMAKE_EXECUTABLE_SUFFIX}.map")
CMake: Validate selected application profile (#13856) Check if the selected application profile is supported by the selected Mbed Target
2020-11-06 17:16:42 +00:00
mbed_validate_application_profile(${target})
CMake: Add a function to generate executable artifacts with memap (#13695) - Add linker option to generate map file for GCC_ARM and ARM toolchain - Add mbed_generate_map_file function to call memap.py (parse the map file). - Add mbed_generate_executable function to generate executable artifacts with a memory map table
2020-10-08 17:39:13 +00:00
mbed_generate_bin_hex(${target})
Add FindPythonPackage and use it to detect memap dependencies
2021-01-28 03:39:53 +00:00
if(HAVE_MEMAP_DEPS)
mbed_generate_map_file(${target})
endif()
CMake: Add a function to generate executable artifacts with memap (#13695) - Add linker option to generate map file for GCC_ARM and ARM toolchain - Add mbed_generate_map_file function to call memap.py (parse the map file). - Add mbed_generate_executable function to generate executable artifacts with a memory map table
2020-10-08 17:39:13 +00:00
endfunction()
CMake: ninja reponse files disabled for ARMClang on Windows Issue https://gitlab.kitware.com/cmake/cmake/-/issues/21093 Until this is fixed, we should disable response files for ARMClang + ninja on Windows. Other toolchains and host systems should benefit from response files thus not disabling them completely. This fixes the issue with not finding includes. It's not trivial to find the root cause, it took me a while to figure out why ARMClang can't find the paths. I moved the check to Mbed OS main cmake. It should not be in the toolchain file as it is not related to the toolchain but to generator. We need toolchain properly set up first. Note, I had to protect setting CMAKE_NINJA_FORCE_RESPONSE_FILE. If I set it to 0, ninja would still use rsp files so I rather protected it and define that variable only when required, not always. Co-authored-by: Hugues Kamba <41612201+hugueskamba@users.noreply.github.com>
2020-10-28 15:25:16 +00:00
# Ninja requires to be forced for response files
if ("${CMAKE_GENERATOR}" MATCHES "Ninja")
# known issue ARMClang and Ninja with response files for windows
# https://gitlab.kitware.com/cmake/cmake/-/issues/21093
if(NOT (CMAKE_HOST_SYSTEM_NAME MATCHES "Windows" AND CMAKE_CXX_COMPILER_ID MATCHES "ARMClang"))
set(CMAKE_NINJA_FORCE_RESPONSE_FILE 1 CACHE INTERNAL "")
endif()
endif()
CMake: Refactor mapfile generation The refactoring was necessary to remove a function call (mbed_configure_app_target()) from application's CMakeLists.txt.
2021-02-17 17:28:47 +00:00
# TODO: Remove once all example applications have removed it
function(mbed_configure_app_target target)
endfunction()