#------------------------------------------------------------------------------- # Copyright (c) 2020, Arm Limited. All rights reserved. # # SPDX-License-Identifier: BSD-3-Clause # #------------------------------------------------------------------------------- cmake_minimum_required(VERSION 3.15) # Don't load this file if it is specified as a cmake toolchain file if(NOT TFM_TOOLCHAIN_FILE) message(DEPRECATION "SETTING CMAKE_TOOLCHAIN_FILE is deprecated. It has been replaced with TFM_TOOLCHAIN_FILE.") return() endif() SET(CMAKE_SYSTEM_NAME Generic) set(CMAKE_C_COMPILER armclang) set(CMAKE_ASM_COMPILER armasm) set(LINKER_VENEER_OUTPUT_FLAG --import_cmse_lib_out=) set(COMPILER_CMSE_FLAG $<$:-mcmse>) # This variable name is a bit of a misnomer. The file it is set to is included # at a particular step in the compiler initialisation. It is used here to # configure the extensions for object files. Despite the name, it also works # with the Ninja generator. set(CMAKE_USER_MAKE_RULES_OVERRIDE ${CMAKE_CURRENT_LIST_DIR}/cmake/set_extensions.cmake) macro(tfm_toolchain_reset_compiler_flags) set_property(DIRECTORY PROPERTY COMPILE_OPTIONS "") string(REGEX REPLACE "\\+nodsp" ".no_dsp" CMAKE_ASM_CPU_FLAG "${CMAKE_SYSTEM_PROCESSOR}") add_compile_options( $<$:-Wno-ignored-optimization-argument> $<$:-Wno-unused-command-line-argument> $<$:-Wall> # Don't error when the MBEDTLS_NULL_ENTROPY warning is shown $<$:-Wno-error=cpp> $<$:-c> $<$:-fdata-sections> $<$:-ffunction-sections> $<$:-fno-builtin> $<$:-fshort-enums> $<$:-fshort-wchar> $<$:-funsigned-char> $<$:-masm=auto> $<$:-nostdlib> $<$:-std=c99> $<$,$>>:-mfpu=none> $<$,$>>:--fpu=none> $<$:--cpu=${CMAKE_ASM_CPU_FLAG}> ) endmacro() macro(tfm_toolchain_reset_linker_flags) set_property(DIRECTORY PROPERTY LINK_OPTIONS "") add_link_options( --info=summarysizes,sizes,totals,unused,veneers --strict --symbols --xref # Suppress link warnings that are consistant (and therefore hopefully # harmless) # https://developer.arm.com/documentation/100074/0608/linker-errors-and-warnings/list-of-the-armlink-error-and-warning-messages # Empty region description --diag_suppress=6312 # Ns section matches pattern --diag_suppress=6314 # Duplicate input files --diag_suppress=6304 $<$>:--fpu=softvfp> ) endmacro() macro(tfm_toolchain_set_processor_arch) set(CMAKE_SYSTEM_PROCESSOR ${TFM_SYSTEM_PROCESSOR}) set(CMAKE_SYSTEM_ARCHITECTURE ${TFM_SYSTEM_ARCHITECTURE}) set(CMAKE_C_COMPILER_TARGET arm-${CROSS_COMPILE}) set(CMAKE_ASM_COMPILER_TARGET arm-${CROSS_COMPILE}) if (DEFINED TFM_SYSTEM_MVE) if(NOT TFM_SYSTEM_MVE) string(APPEND CMAKE_SYSTEM_PROCESSOR "+nomve") endif() endif() if (DEFINED TFM_SYSTEM_FP) if(NOT TFM_SYSTEM_FP) string(APPEND CMAKE_SYSTEM_PROCESSOR "+nofp") endif() endif() if (DEFINED TFM_SYSTEM_DSP) if(NOT TFM_SYSTEM_DSP) string(APPEND CMAKE_SYSTEM_PROCESSOR "+nodsp") endif() endif() # Cmake's ARMClang support has several issues with compiler validation. To # avoid these, we set the list of supported -mcpu and -march variables to # the ones we intend to use so that the validation will never fail. include(Compiler/ARMClang) set(CMAKE_C_COMPILER_PROCESSOR_LIST ${CMAKE_SYSTEM_PROCESSOR}) set(CMAKE_C_COMPILER_ARCH_LIST ${CMAKE_SYSTEM_PROCESSOR}) set(CMAKE_ASM_COMPILER_PROCESSOR_LIST ${CMAKE_SYSTEM_PROCESSOR}) set(CMAKE_ASM_COMPILER_ARCH_LIST ${CMAKE_SYSTEM_PROCESSOR}) endmacro() macro(tfm_toolchain_reload_compiler) tfm_toolchain_set_processor_arch() tfm_toolchain_reset_compiler_flags() tfm_toolchain_reset_linker_flags() unset(CMAKE_C_FLAGS_INIT) unset(CMAKE_C_LINK_FLAGS) unset(CMAKE_ASM_FLAGS_INIT) unset(CMAKE_ASM_LINK_FLAGS) unset(__mcpu_flag_set) unset(__march_flag_set) include(Compiler/ARMClang) __compiler_armclang(C) include(Compiler/ARMCC) __compiler_armcc(ASM) # Cmake's armclang support will set either mcpu or march, but march gives # better code size so we manually set it. set(CMAKE_C_FLAGS "-march=${CMAKE_SYSTEM_ARCHITECTURE}") set(CMAKE_ASM_FLAGS ${CMAKE_ASM_FLAGS_INIT}) set(CMAKE_C_LINK_FLAGS "--cpu=${CMAKE_SYSTEM_PROCESSOR}") set(CMAKE_ASM_LINK_FLAGS "--cpu=${CMAKE_SYSTEM_PROCESSOR}") # But armlink doesn't support this +dsp syntax string(REGEX REPLACE "\\+nodsp" "" CMAKE_C_LINK_FLAGS "${CMAKE_C_LINK_FLAGS}") string(REGEX REPLACE "\\+nodsp" "" CMAKE_ASM_LINK_FLAGS "${CMAKE_ASM_LINK_FLAGS}") # And uses different syntax for +nofp string(REGEX REPLACE "\\+nofp" ".no_fp" CMAKE_C_LINK_FLAGS "${CMAKE_C_LINK_FLAGS}") string(REGEX REPLACE "\\+nofp" ".no_fp" CMAKE_ASM_LINK_FLAGS "${CMAKE_ASM_LINK_FLAGS}") string(REGEX REPLACE "\\+nomve" ".no_mve" CMAKE_C_LINK_FLAGS "${CMAKE_C_LINK_FLAGS}") string(REGEX REPLACE "\\+nomve" ".no_mve" CMAKE_ASM_LINK_FLAGS "${CMAKE_ASM_LINK_FLAGS}") # Workaround for issues with --depend-single-line with armasm and Ninja if (CMAKE_GENERATOR STREQUAL "Ninja") set( CMAKE_DEPFILE_FLAGS_ASM "--depend=.d") endif() set(CMAKE_C_FLAGS_MINSIZEREL "-Oz -DNDEBUG") endmacro() # Configure environment for the compiler setup run by cmake at the first # `project` call in /CMakeLists.txt. After this mandatory setup is # done, all further compiler setup is done via tfm_toolchain_reload_compiler() tfm_toolchain_set_processor_arch() tfm_toolchain_reset_compiler_flags() tfm_toolchain_reset_linker_flags() # Behaviour for handling scatter files is so wildly divergent between compilers # that this macro is required. macro(target_add_scatter_file target) target_link_options(${target} PRIVATE --scatter=$ ) add_dependencies(${target} ${target}_scatter ) add_library(${target}_scatter OBJECT) foreach(scatter_file ${ARGN}) target_sources(${target}_scatter PRIVATE ${scatter_file} ) # Cmake cannot use generator expressions in the # set_source_file_properties command, so instead we just parse the regex # for the filename and set the property on all files, regardless of if # the generator expression would evaluate to true or not. string(REGEX REPLACE ".*>:(.*)>$" "\\1" SCATTER_FILE_PATH "${scatter_file}") set_source_files_properties(${SCATTER_FILE_PATH} PROPERTIES LANGUAGE C ) endforeach() target_link_libraries(${target}_scatter platform_region_defs psa_interface tfm_partition_defs ) target_compile_options(${target}_scatter PRIVATE -E -xc ) endmacro() macro(add_convert_to_bin_target target) get_target_property(bin_dir ${target} RUNTIME_OUTPUT_DIRECTORY) add_custom_target(${target}_bin SOURCES ${bin_dir}/${target}.bin ) add_custom_command(OUTPUT ${bin_dir}/${target}.bin DEPENDS ${target} COMMAND fromelf --bincombined $ --output=${bin_dir}/${target}.bin ) add_custom_target(${target}_elf SOURCES ${bin_dir}/${target}.elf ) add_custom_command(OUTPUT ${bin_dir}/${target}.elf DEPENDS ${target} COMMAND fromelf --elf $ --output=${bin_dir}/${target}.elf ) add_custom_target(${target}_hex SOURCES ${bin_dir}/${target}.hex ) add_custom_command(OUTPUT ${bin_dir}/${target}.hex DEPENDS ${target} COMMAND fromelf --i32combined $ --output=${bin_dir}/${target}.hex ) add_custom_target(${target}_binaries ALL DEPENDS ${target}_bin DEPENDS ${target}_elf DEPENDS ${target}_hex ) endmacro() # Macro for sharing code among independent binaries. This function extracts # some parts of the code based on a symbol template file and creates a text # file, which contains the symbols with their absolute addresses, which can be # picked up by the linker when linking the other target. # INPUTS: # TARGET - - Target to extract the symbols/objects from # SHARED_SYMBOL_TEMPLATE - Template with names of symbols to share macro(compiler_create_shared_code TARGET SHARED_SYMBOL_TEMPLATE) # Create a temporary file, which contains all extracted symbols from 'TARGET' set(ALL_SYMBOLS ${CMAKE_CURRENT_BINARY_DIR}/all_symbols.txt) set_property(TARGET ${TARGET} APPEND_STRING PROPERTY LINK_FLAGS " --symdefs=${ALL_SYMBOLS}") # Find the CMake script doing the symbol filtering. find_file(FILTER_SYMBOLS_SCRIPT "FilterSharedSymbols.cmake" PATHS ${CMAKE_MODULE_PATH} PATH_SUFFIXES Common NO_DEFAULT_PATH) # Single step, just filter the unwanted symbols from symdefs file add_custom_command(TARGET ${TARGET} POST_BUILD COMMAND ${CMAKE_COMMAND} -DSHARED_SYMBOL_TEMPLATE=${SHARED_SYMBOL_TEMPLATE} -DALL_SYMBOLS=${ALL_SYMBOLS} -P ${FILTER_SYMBOLS_SCRIPT} BYPRODUCTS ${CMAKE_CURRENT_BINARY_DIR}/shared_symbols_name.txt ${CMAKE_CURRENT_BINARY_DIR}/shared_symbols_addr.txt COMMENT "Filtering shared symbols" ) endmacro() macro(compiler_weaken_symbols TARGET SHARED_CODE_PATH ORIG_TARGET LIB_LIST) # Find the CMake scripts find_file(WEAKEN_SYMBOLS_SCRIPT "WeakenSymbols.cmake" PATHS ${CMAKE_MODULE_PATH} PATH_SUFFIXES Common NO_DEFAULT_PATH) add_custom_command(TARGET ${TARGET} PRE_LINK COMMAND ${CMAKE_COMMAND} -DLIB_LIST='${LIB_LIST}' -DSHARED_CODE_PATH=${SHARED_CODE_PATH} -P ${WEAKEN_SYMBOLS_SCRIPT} COMMENT "Set conflicting symbols to be weak in the original libraries to avoid collision") # If sharing target is defined by TF-M build then setup dependency if(NOT ${ORIG_TARGET} STREQUAL "EXTERNAL_TARGET") add_dependencies(${TARGET} ${ORIG_TARGET}) endif() endmacro() # Macro for linking shared code to given target. Location of shared code could # be outside of the TF-M project. Its location can be defined with the CMake # command line argument "SHARED_CODE_PATH". The file containing the shared objects # must be named "shared_symbols_addr.txt". # INPUTS: # TARGET Target to link the shared code to # SHARED_CODE_PATH Shared code located in this folder # ORIG_TARGET Target that shared code was extraced from # LIB_LIST List of libraries which are linked to top level target macro(compiler_link_shared_code TARGET SHARED_CODE_PATH ORIG_TARGET LIB_LIST) # ARMCLANG requires adding a symbol definition file to the source file list. # This is the output of the -symdefs compiler switch. set_source_files_properties(${SHARED_CODE_PATH}/shared_symbols_addr.txt PROPERTIES EXTERNAL_OBJECT true GENERATED true) target_sources(${TARGET} PRIVATE ${SHARED_CODE_PATH}/shared_symbols_addr.txt) compiler_weaken_symbols(${TARGET} ${SHARED_CODE_PATH} ${ORIG_TARGET} "${LIB_LIST}" ) endmacro()