| #------------------------------------------------------------------------------- |
| # SPDX-FileCopyrightText: Copyright The TrustedFirmware-M Contributors |
| # Copyright (c) 2022 Cypress Semiconductor Corporation (an Infineon company) |
| # or an affiliate of Cypress Semiconductor Corporation. All rights reserved. |
| # |
| # SPDX-License-Identifier: BSD-3-Clause |
| # |
| #------------------------------------------------------------------------------- |
| cmake_minimum_required(VERSION 3.21) |
| |
| SET(CMAKE_SYSTEM_NAME Generic) |
| |
| set(CMAKE_C_COMPILER armclang) |
| set(CMAKE_CXX_COMPILER armclang) |
| set(CMAKE_ASM_COMPILER armclang) |
| |
| set(LINKER_VENEER_OUTPUT_FLAG --import_cmse_lib_out=) |
| set(COMPILER_CMSE_FLAG $<$<COMPILE_LANGUAGE:C>:-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) |
| |
| # CMAKE_C_COMPILER_VERSION is not guaranteed to be defined. |
| EXECUTE_PROCESS( COMMAND ${CMAKE_C_COMPILER} --version OUTPUT_VARIABLE ARMCLANG_VERSION ) |
| string(REGEX MATCH "([0-9]+\.[0-9]+)" ARMCLANG_VERSION "${ARMCLANG_VERSION}") |
| set(ARMCLANG_VERSION ${CMAKE_MATCH_1}) |
| |
| if(NOT DEFINED CMAKE_OBJCOPY) |
| set(CMAKE_OBJCOPY ${CROSS_COMPILE}-objcopy CACHE FILEPATH "Path to objcopy") |
| endif() |
| |
| if (DEFINED TFM_SYSTEM_PROCESSOR) |
| set(CMAKE_SYSTEM_PROCESSOR ${TFM_SYSTEM_PROCESSOR}) |
| |
| if (TFM_SYSTEM_ARCHITECTURE STREQUAL "armv8.1-m.main") |
| if(NOT CONFIG_TFM_ENABLE_MVE) |
| string(APPEND CMAKE_SYSTEM_PROCESSOR "+nomve") |
| endif() |
| if((NOT TFM_SYSTEM_PROCESSOR STREQUAL "cortex-m85") |
| AND (NOT CONFIG_TFM_ENABLE_MVE_FP) |
| AND CONFIG_TFM_ENABLE_MVE |
| AND CONFIG_TFM_ENABLE_FP) |
| string(APPEND CMAKE_SYSTEM_PROCESSOR "+nomve.fp") |
| endif() |
| endif() |
| |
| if (DEFINED TFM_SYSTEM_DSP) |
| if(NOT TFM_SYSTEM_DSP) |
| string(APPEND CMAKE_SYSTEM_PROCESSOR "+nodsp") |
| endif() |
| endif() |
| |
| # ARMCLANG specifies that '+nofp' is available on following M-profile cpus: |
| # 'cortex-m4', 'cortex-m7', 'cortex-m33', 'cortex-m35p', 'cortex-m55' and 'cortex-m85'. |
| # Build fails if other M-profile cpu, such as 'cortex-m23', is added with '+nofp'. |
| # Explicitly list those cpu to align with ARMCLANG description. |
| if (NOT CONFIG_TFM_ENABLE_FP AND |
| (TFM_SYSTEM_PROCESSOR STREQUAL "cortex-m4" |
| OR TFM_SYSTEM_PROCESSOR STREQUAL "cortex-m7" |
| OR TFM_SYSTEM_PROCESSOR STREQUAL "cortex-m33" |
| OR TFM_SYSTEM_PROCESSOR STREQUAL "cortex-m35p" |
| OR TFM_SYSTEM_PROCESSOR STREQUAL "cortex-m55" |
| OR TFM_SYSTEM_PROCESSOR STREQUAL "cortex-m85")) |
| string(APPEND CMAKE_SYSTEM_PROCESSOR "+nofp") |
| endif() |
| endif() |
| |
| # CMAKE_SYSTEM_ARCH is an ARMCLANG CMAKE internal variable, used to set |
| # compile and linker flags up until CMake 3.21 where CMP0123 was introduced: |
| # https://cmake.org/cmake/help/latest/policy/CMP0123.html |
| # Another use of this variable is to statisfy a requirement for ARMCLANG to |
| # set either the target CPU or the Architecture. This variable needs to be |
| # set to allow targeting architectures without a specific CPU. |
| set(CMAKE_SYSTEM_ARCH ${TFM_SYSTEM_ARCHITECTURE}) |
| |
| set(CMAKE_C_COMPILER_TARGET arm-${CROSS_COMPILE}) |
| set(CMAKE_CXX_COMPILER_TARGET arm-${CROSS_COMPILE}) |
| set(CMAKE_ASM_COMPILER_TARGET arm-${CROSS_COMPILE}) |
| |
| if (TFM_SYSTEM_ARCHITECTURE STREQUAL "armv8.1-m.main") |
| # These three feature options are the only ones armlink accepts |
| if(CONFIG_TFM_ENABLE_MVE_FP) |
| string(APPEND CMAKE_SYSTEM_ARCH "+mve.fp") |
| elseif(CONFIG_TFM_ENABLE_MVE) |
| string(APPEND CMAKE_SYSTEM_ARCH "+mve") |
| elseif(TFM_SYSTEM_DSP) |
| string(APPEND CMAKE_SYSTEM_ARCH "+dsp") |
| endif() |
| |
| # Generic fp extension names to be used instead of -mfpu |
| # +fp/fpv5-sp-d16 is not handled as it is the default |
| if(CONFIG_TFM_ENABLE_FP) |
| if (CONFIG_TFM_FP_ARCH STREQUAL "fpv5-d16") |
| string(APPEND CMAKE_SYSTEM_ARCH "+fp.dp") |
| endif() |
| else() |
| string(APPEND CMAKE_SYSTEM_ARCH "+nofp") |
| endif() |
| endif() |
| |
| if(TFM_SYSTEM_DSP AND (NOT TFM_SYSTEM_ARCHITECTURE STREQUAL "armv8.1-m.main")) |
| string(APPEND CMAKE_SYSTEM_ARCH "+dsp") |
| 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_ARCH}) |
| set(CMAKE_CXX_COMPILER_PROCESSOR_LIST ${CMAKE_SYSTEM_PROCESSOR}) |
| set(CMAKE_CXX_COMPILER_ARCH_LIST ${CMAKE_SYSTEM_ARCH}) |
| set(CMAKE_ASM_COMPILER_PROCESSOR_LIST ${CMAKE_SYSTEM_PROCESSOR}) |
| set(CMAKE_ASM_COMPILER_ARCH_LIST ${CMAKE_SYSTEM_ARCH}) |
| |
| add_compile_options( |
| $<$<OR:$<COMPILE_LANGUAGE:C>,$<COMPILE_LANGUAGE:CXX>>:-Wno-ignored-optimization-argument> |
| $<$<OR:$<COMPILE_LANGUAGE:C>,$<COMPILE_LANGUAGE:CXX>>:-Wno-unused-command-line-argument> |
| $<$<OR:$<COMPILE_LANGUAGE:C>,$<COMPILE_LANGUAGE:CXX>>:-Wall> |
| # Don't error when the MBEDTLS_NULL_ENTROPY warning is shown |
| $<$<OR:$<COMPILE_LANGUAGE:C>,$<COMPILE_LANGUAGE:CXX>>:-Wno-error=cpp> |
| $<$<OR:$<COMPILE_LANGUAGE:C>,$<COMPILE_LANGUAGE:CXX>>:-c> |
| $<$<OR:$<COMPILE_LANGUAGE:C>,$<COMPILE_LANGUAGE:CXX>>:-fdata-sections> |
| $<$<OR:$<COMPILE_LANGUAGE:C>,$<COMPILE_LANGUAGE:CXX>>:-ffunction-sections> |
| $<$<OR:$<COMPILE_LANGUAGE:C>,$<COMPILE_LANGUAGE:CXX>>:-fno-builtin> |
| $<$<OR:$<COMPILE_LANGUAGE:C>,$<COMPILE_LANGUAGE:CXX>>:-fshort-enums> |
| $<$<OR:$<COMPILE_LANGUAGE:C>,$<COMPILE_LANGUAGE:CXX>>:-fshort-wchar> |
| $<$<OR:$<COMPILE_LANGUAGE:C>,$<COMPILE_LANGUAGE:CXX>>:-funsigned-char> |
| $<$<OR:$<COMPILE_LANGUAGE:C>,$<COMPILE_LANGUAGE:CXX>>:-masm=auto> |
| $<$<OR:$<COMPILE_LANGUAGE:C>,$<COMPILE_LANGUAGE:CXX>>:-nostdlib> |
| $<$<COMPILE_LANGUAGE:C>:-std=c99> |
| $<$<COMPILE_LANGUAGE:CXX>:-std=c++11> |
| $<$<COMPILE_LANGUAGE:ASM>:-masm=armasm> |
| $<$<AND:$<COMPILE_LANGUAGE:C>,$<BOOL:${TFM_DEBUG_SYMBOLS}>>:-g> |
| $<$<AND:$<COMPILE_LANGUAGE:CXX>,$<BOOL:${TFM_DEBUG_SYMBOLS}>>:-g> |
| $<$<AND:$<COMPILE_LANGUAGE:C,CXX>,$<BOOL:${CONFIG_TFM_WARNINGS_ARE_ERRORS}>>:-Werror> |
| ) |
| |
| add_link_options( |
| ${MEMORY_USAGE_FLAG} |
| --strict |
| --symbols |
| --xref |
| $<$<AND:$<VERSION_GREATER:${TFM_ISOLATION_LEVEL},1>,$<STREQUAL:"${TEST_PSA_API}","IPC">>:--no-merge> |
| # 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 |
| # Pattern only matches removed unused sections. |
| --diag_suppress=6329 |
| ) |
| |
| if(CONFIG_TFM_MEMORY_USAGE_QUIET) |
| set(MEMORY_USAGE_FLAG "") |
| else() |
| set(MEMORY_USAGE_FLAG --info=summarysizes,sizes,totals,unused,veneers) |
| endif() |
| |
| if (ARMCLANG_VERSION VERSION_LESS 6.13) |
| message(FATAL_ERROR "Please select newer Arm compiler version starting from 6.13.") |
| endif() |
| |
| if (ARMCLANG_VERSION VERSION_GREATER_EQUAL 6.15 AND |
| ARMCLANG_VERSION VERSION_LESS 6.18) |
| message(FATAL_ERROR "Armclang 6.15~6.17 may cause MemManage fault." |
| " This defect has been fixed since Armclang 6.18." |
| " See [SDCOMP-59788] in Armclang 6.18 release note for details." |
| " Please use other Armclang versions instead.") |
| endif() |
| |
| if (CMAKE_SYSTEM_PROCESSOR) |
| set(CMAKE_C_FLAGS "-mcpu=${CMAKE_SYSTEM_PROCESSOR}") |
| set(CMAKE_CXX_FLAGS "-mcpu=${CMAKE_SYSTEM_PROCESSOR}") |
| set(CMAKE_ASM_FLAGS "--target=${CMAKE_ASM_COMPILER_TARGET} -mcpu=${CMAKE_SYSTEM_PROCESSOR}") |
| |
| set(ARMLINK_MAPPED_OPTION "--cpu=${CMAKE_SYSTEM_PROCESSOR}") |
| # But armlink doesn't support this +dsp syntax |
| string(REGEX REPLACE "\\+nodsp" "" ARMLINK_MAPPED_OPTION "${ARMLINK_MAPPED_OPTION}") |
| # And uses different syntax for +nofp, +nomve.fp, nomve |
| string(REGEX REPLACE "\\+nofp" ".no_fp" ARMLINK_MAPPED_OPTION "${ARMLINK_MAPPED_OPTION}") |
| string(REGEX REPLACE "\\+nomve\\.fp" ".no_mvefp" ARMLINK_MAPPED_OPTION "${ARMLINK_MAPPED_OPTION}") |
| string(REGEX REPLACE "\\+nomve" ".no_mve" ARMLINK_MAPPED_OPTION "${ARMLINK_MAPPED_OPTION}") |
| |
| set(CMAKE_C_LINK_FLAGS ${ARMLINK_MAPPED_OPTION}) |
| set(CMAKE_CXX_LINK_FLAGS ${ARMLINK_MAPPED_OPTION}) |
| set(CMAKE_ASM_LINK_FLAGS ${ARMLINK_MAPPED_OPTION}) |
| else() |
| set(CMAKE_C_FLAGS "-march=${CMAKE_SYSTEM_ARCH}") |
| set(CMAKE_CXX_FLAGS "-march=${CMAKE_SYSTEM_ARCH}") |
| set(CMAKE_ASM_FLAGS "--target=${CMAKE_ASM_COMPILER_TARGET} -march=${CMAKE_SYSTEM_ARCH}") |
| |
| set(ARMLINK_MAPPED_OPTION "--cpu=${CMAKE_SYSTEM_ARCH}") |
| # Mapping the architecture name |
| string(REGEX REPLACE "armv" "" ARMLINK_MAPPED_OPTION "${ARMLINK_MAPPED_OPTION}") |
| # Armlink uses --fpu option instead of the generic extension names |
| string(REGEX REPLACE "\\+fp\\.dp" "" ARMLINK_MAPPED_OPTION "${ARMLINK_MAPPED_OPTION}") |
| string(REGEX REPLACE "\\+nofp" "" ARMLINK_MAPPED_OPTION "${ARMLINK_MAPPED_OPTION}") |
| # And different syntax for these features |
| string(REGEX REPLACE "\\+mve\\.fp" ".mve.fp" ARMLINK_MAPPED_OPTION "${ARMLINK_MAPPED_OPTION}") |
| string(REGEX REPLACE "\\+mve" ".mve" ARMLINK_MAPPED_OPTION "${ARMLINK_MAPPED_OPTION}") |
| string(REGEX REPLACE "\\+dsp" ".dsp" ARMLINK_MAPPED_OPTION "${ARMLINK_MAPPED_OPTION}") |
| |
| set(CMAKE_C_LINK_FLAGS ${ARMLINK_MAPPED_OPTION}) |
| set(CMAKE_CXX_LINK_FLAGS ${ARMLINK_MAPPED_OPTION}) |
| set(CMAKE_ASM_LINK_FLAGS ${ARMLINK_MAPPED_OPTION}) |
| endif() |
| |
| set(BL2_COMPILER_CP_FLAG |
| -mfpu=softvfp |
| ) |
| # As BL2 does not use hardware FPU, specify '--fpu=SoftVFP' explicitly to use software |
| # library functions for BL2 to override any implicit FPU option, such as '--cpu' option. |
| # Because the implicit hardware FPU option enforces BL2 to initialize FPU but hardware FPU |
| # is not actually enabled in BL2, it will cause BL2 runtime fault. |
| set(BL2_LINKER_CP_OPTION --fpu=SoftVFP) |
| |
| set(BL1_COMPILER_CP_FLAG |
| -mfpu=softvfp |
| ) |
| set(BL1_LINKER_CP_OPTION --fpu=SoftVFP) |
| |
| if (CONFIG_TFM_FLOAT_ABI STREQUAL "hard") |
| set(COMPILER_CP_FLAG |
| $<$<COMPILE_LANGUAGE:C>:-mfloat-abi=hard> |
| ) |
| if (CONFIG_TFM_ENABLE_FP) |
| if (TFM_SYSTEM_ARCHITECTURE STREQUAL "armv8.1-m.main") |
| # setting the -mfpu option disables the floating point mve, generic +fp.dp is used instead |
| set(COMPILER_CP_FLAG -mfloat-abi=hard) |
| else() |
| set(COMPILER_CP_FLAG -mfpu=${CONFIG_TFM_FP_ARCH};-mfloat-abi=hard) |
| endif() |
| # armasm and armlink have the same option "--fpu" and are both used to |
| # specify the target FPU architecture. So the supported FPU architecture |
| # names can be shared by armasm and armlink. |
| set(LINKER_CP_OPTION --fpu=${CONFIG_TFM_FP_ARCH_ASM}) |
| endif() |
| else() |
| set(COMPILER_CP_FLAG |
| -mfpu=softvfp |
| ) |
| set(LINKER_CP_OPTION --fpu=SoftVFP) |
| endif() |
| |
| set(CMAKE_C_FLAGS_MINSIZEREL "-Oz -DNDEBUG") |
| |
| # |
| # Pointer Authentication Code and Branch Target Identification (PACBTI) Options |
| # |
| if (${CONFIG_TFM_BRANCH_PROTECTION_FEAT} STREQUAL BRANCH_PROTECTION_NONE) |
| set(BRANCH_PROTECTION_OPTIONS "none") |
| elseif(${CONFIG_TFM_BRANCH_PROTECTION_FEAT} STREQUAL BRANCH_PROTECTION_STANDARD) |
| set(BRANCH_PROTECTION_OPTIONS "standard") |
| elseif(${CONFIG_TFM_BRANCH_PROTECTION_FEAT} STREQUAL BRANCH_PROTECTION_PACRET) |
| set(BRANCH_PROTECTION_OPTIONS "pac-ret") |
| elseif(${CONFIG_TFM_BRANCH_PROTECTION_FEAT} STREQUAL BRANCH_PROTECTION_PACRET_LEAF) |
| set(BRANCH_PROTECTION_OPTIONS "pac-ret+leaf") |
| elseif(${CONFIG_TFM_BRANCH_PROTECTION_FEAT} STREQUAL BRANCH_PROTECTION_BTI) |
| set(BRANCH_PROTECTION_OPTIONS "bti") |
| endif() |
| |
| if(NOT ${CONFIG_TFM_BRANCH_PROTECTION_FEAT} STREQUAL BRANCH_PROTECTION_DISABLED) |
| if(ARMCLANG_VERSION VERSION_LESS 6.18) |
| message(FATAL_ERROR "Your compiler does not support BRANCH_PROTECTION") |
| else() |
| if((TFM_SYSTEM_PROCESSOR MATCHES "cortex-m85") AND |
| (TFM_SYSTEM_ARCHITECTURE STREQUAL "armv8.1-m.main")) |
| message(NOTICE "BRANCH_PROTECTION enabled with: ${BRANCH_PROTECTION_OPTIONS}") |
| |
| string(APPEND CMAKE_C_FLAGS " -mbranch-protection=${BRANCH_PROTECTION_OPTIONS}") |
| string(APPEND CMAKE_CXX_FLAGS " -mbranch-protection=${BRANCH_PROTECTION_OPTIONS}") |
| |
| add_link_options(--library_security=pacbti-m) |
| else() |
| message(FATAL_ERROR "Your architecture does not support BRANCH_PROTECTION") |
| endif() |
| endif() |
| endif() |
| |
| # 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=$<TARGET_OBJECTS:${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 |
| KEEP_EXTENSION True # Don't use .o extension for the preprocessed file |
| ) |
| endforeach() |
| |
| add_dependencies(${target} |
| ${target}_scatter |
| ) |
| |
| set_property(TARGET ${target} APPEND PROPERTY LINK_DEPENDS $<TARGET_OBJECTS:${target}_scatter>) |
| |
| target_link_libraries(${target}_scatter |
| platform_region_defs |
| psa_interface |
| tfm_config |
| ) |
| |
| 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 $<TARGET_FILE:${target}> |
| --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 $<TARGET_FILE:${target}> |
| --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 $<TARGET_FILE:${target}> |
| --output=${bin_dir}/${target}.hex |
| ) |
| |
| add_custom_target(${target}_binaries |
| ALL |
| DEPENDS ${target}_bin |
| DEPENDS ${target}_elf |
| DEPENDS ${target}_hex |
| ) |
| endmacro() |
| |
| macro(target_share_symbols target) |
| get_target_property(TARGET_TYPE ${target} TYPE) |
| if (NOT TARGET_TYPE STREQUAL "EXECUTABLE") |
| message(FATAL_ERROR "${target} is not an executable. Symbols cannot be shared from libraries.") |
| endif() |
| |
| foreach(symbol_file ${ARGN}) |
| FILE(STRINGS ${symbol_file} SYMBOLS |
| LENGTH_MINIMUM 1 |
| ) |
| list(APPEND KEEP_SYMBOL_LIST ${SYMBOLS}) |
| endforeach() |
| |
| find_package(Python3) |
| |
| # strip all the symbols except those provided as arguments |
| add_custom_target(${target}_shared_symbols |
| VERBATIM |
| COMMAND fromelf --text -s $<TARGET_FILE:${target}> --output $<TARGET_FILE_DIR:${target}>/${target}${CODE_SHARING_OUTPUT_FILE_SUFFIX} |
| COMMAND ${Python3_EXECUTABLE} ${CMAKE_SOURCE_DIR}/tools/tfm_gen_armclang_shared_symbols.py |
| $<TARGET_FILE_DIR:${target}>/${target}${CODE_SHARING_OUTPUT_FILE_SUFFIX} |
| $<TARGET_FILE_DIR:${target}>/${target}${CODE_SHARING_OUTPUT_FILE_SUFFIX} |
| ${KEEP_SYMBOL_LIST} |
| ) |
| |
| # Ensure ${target} is build before $<TARGET_FILE:${target}> is used to generate ${target}_shared_symbols |
| add_dependencies(${target}_shared_symbols ${target}) |
| # Allow the global clean target to rm the ${target}_shared_symbols created |
| set_target_properties(${target}_shared_symbols PROPERTIES |
| ADDITIONAL_CLEAN_FILES $<TARGET_FILE_DIR:${target}>/${target}${CODE_SHARING_OUTPUT_FILE_SUFFIX} |
| ) |
| |
| # Force the target to not remove the symbols if they're unused. |
| list(TRANSFORM KEEP_SYMBOL_LIST PREPEND --undefined=) |
| target_link_options(${target} |
| PRIVATE |
| ${KEEP_SYMBOL_LIST} |
| # This is needed because the symbol file can contain functions |
| # that are not defined in every build configuration. |
| # The L6474E is: |
| # "Symbol referenced by --undefined or --undefined_and_export |
| # switch could not be resolved by a static library." |
| --diag_warning 6474 |
| ) |
| endmacro() |
| |
| macro(target_link_shared_code target) |
| get_target_property(TARGET_SOURCE_DIR ${target} SOURCE_DIR) |
| |
| foreach(symbol_provider ${ARGN}) |
| if (TARGET ${symbol_provider}) |
| get_target_property(SYMBOL_PROVIDER_TYPE ${symbol_provider} TYPE) |
| if (NOT SYMBOL_PROVIDER_TYPE STREQUAL "EXECUTABLE") |
| message(FATAL_ERROR "${symbol_provider} is not an executable. Symbols cannot be shared from libraries.") |
| endif() |
| endif() |
| |
| # Ensure ${symbol_provider}_shared_symbols is built before ${target} |
| add_dependencies(${target} ${symbol_provider}_shared_symbols) |
| # ${symbol_provider}_shared_symbols - a custom target is always considered out-of-date |
| # To only link when necessary, depend on ${symbol_provider} instead |
| set_property(TARGET ${target} APPEND PROPERTY LINK_DEPENDS $<TARGET_OBJECTS:${symbol_provider}>) |
| target_link_options(${target} PRIVATE LINKER:$<TARGET_FILE_DIR:${symbol_provider}>/${symbol_provider}${CODE_SHARING_INPUT_FILE_SUFFIX}) |
| endforeach() |
| endmacro() |
| |
| macro(target_strip_symbols target) |
| set(SYMBOL_LIST "${ARGN}") |
| list(TRANSFORM SYMBOL_LIST PREPEND --strip-symbol=) |
| |
| # TODO we assume that arm-none-eabi-objcopy is available - since we're using |
| # armclang this isn't necessarily true. |
| add_custom_command( |
| TARGET ${target} |
| POST_BUILD |
| COMMAND ${CMAKE_OBJCOPY} |
| ARGS $<TARGET_FILE:${target}> --wildcard ${SYMBOL_LIST} $<TARGET_FILE:${target}> |
| ) |
| endmacro() |
| |
| macro(target_strip_symbols_from_dependency target dependency) |
| set(SYMBOL_LIST "${ARGN}") |
| list(TRANSFORM SYMBOL_LIST PREPEND --strip-symbol=) |
| |
| # TODO we assume that arm-none-eabi-objcopy is available - since we're using |
| # armclang this isn't necessarily true. |
| add_custom_command( |
| TARGET ${target} |
| PRE_LINK |
| COMMAND ${CMAKE_OBJCOPY} |
| ARGS $<TARGET_FILE:${dependency}> --wildcard ${SYMBOL_LIST} $<TARGET_FILE:${dependency}> |
| ) |
| endmacro() |
| |
| macro(target_weaken_symbols target) |
| set(SYMBOL_LIST "${ARGN}") |
| list(TRANSFORM SYMBOL_LIST PREPEND --weaken-symbol=) |
| |
| # TODO we assume that arm-none-eabi-objcopy is available - since we're using |
| # armclang this isn't necessarily true. |
| add_custom_command( |
| TARGET ${target} |
| POST_BUILD |
| COMMAND ${CMAKE_OBJCOPY} |
| ARGS $<TARGET_FILE:${target}> --wildcard ${SYMBOL_LIST} $<TARGET_FILE:${target}> |
| ) |
| endmacro() |
| |
| macro(target_weaken_symbols_from_dependency target dependency) |
| set(SYMBOL_LIST "${ARGN}") |
| list(TRANSFORM SYMBOL_LIST PREPEND --weaken-symbol=) |
| |
| # TODO we assume that arm-none-eabi-objcopy is available - since we're using |
| # armclang this isn't necessarily true. |
| add_custom_command( |
| TARGET ${target} |
| PRE_LINK |
| COMMAND ${CMAKE_OBJCOPY} |
| ARGS $<TARGET_FILE:${dependency}> --wildcard ${SYMBOL_LIST} $<TARGET_FILE:${dependency}> |
| ) |
| endmacro() |