Merge topic 'ticlang-compilers' into release-3.29

4c51136b8c ci: Enable TIClang test on Debian Clang jobs in nightly pipeline
9ba0a54554 TIClang: Add support for TI Clang-based compilers, including tiarmclang

Acked-by: Kitware Robot <[email protected]>
Merge-request: !9228

.gitlab/.gitignore

@@ -16,6 +16,7 @@
 /python*
 /qt*
 /sccache*
+/ticlang
 /unstable-jom*
 /watcom
 /wix*

.gitlab/ci/configure_debian12_makefiles_clang.cmake

@@ -1 +1,5 @@
+if (NOT "$ENV{CMAKE_CI_NIGHTLY}" STREQUAL "")
+  set(CMake_TEST_TICLANG_TOOLCHAINS "$ENV{CI_PROJECT_DIR}/.gitlab/ticlang" CACHE PATH "")
+endif()
+
 include("${CMAKE_CURRENT_LIST_DIR}/configure_external_test.cmake")

.gitlab/ci/configure_debian12_ninja_clang.cmake

@@ -1 +1,5 @@
+if (NOT "$ENV{CMAKE_CI_NIGHTLY}" STREQUAL "")
+  set(CMake_TEST_TICLANG_TOOLCHAINS "$ENV{CI_PROJECT_DIR}/.gitlab/ticlang" CACHE PATH "")
+endif()
+
 include("${CMAKE_CURRENT_LIST_DIR}/configure_external_test.cmake")

.gitlab/ci/env_debian12_makefiles_clang.sh

@@ -1,2 +1,6 @@
+if test "$CMAKE_CI_NIGHTLY" = "true"; then
+  source .gitlab/ci/ticlang-env.sh
+fi
+
 export CC=/usr/bin/clang-15
 export CXX=/usr/bin/clang++-15

.gitlab/ci/env_debian12_ninja_clang.sh

@@ -1,2 +1,6 @@
+if test "$CMAKE_CI_NIGHTLY" = "true"; then
+  source .gitlab/ci/ticlang-env.sh
+fi
+
 export CC=/usr/bin/clang-15
 export CXX=/usr/bin/clang++-15

.gitlab/ci/ticlang-env.sh

@@ -0,0 +1,2 @@
+.gitlab/ci/ticlang.sh
+.gitlab/ticlang/bin/tiarmclang --version

.gitlab/ci/ticlang.sh

@@ -0,0 +1,28 @@
+#!/bin/sh
+
+set -e
+
+case "$(uname -s)-$(uname -m)" in
+    Linux-x86_64)
+        shatool="sha256sum"
+        sha256sum="c69ac58e403b82eac1c407cc67b35fab5d95c5d8db75b019095f9412aacff27d"
+        filename="ti_cgt_armllvm_3.2.1.LTS_linux-x64_installer.bin"
+        dirname="ti-cgt-armllvm_3.2.1.LTS"
+        ;;
+    *)
+        echo "Unrecognized platform $(uname -s)-$(uname -m)"
+        exit 1
+        ;;
+esac
+readonly shatool
+readonly sha256sum
+
+cd .gitlab
+
+echo "$sha256sum  $filename" > ticlang.sha256sum
+curl -OL "https://cmake.org/files/dependencies/internal/$filename"
+$shatool --check ticlang.sha256sum
+chmod +x "$filename"
+"./$filename" --mode unattended --prefix .
+mv "$dirname" ticlang
+rm -f "$filename" ticlang.sha256sum

Help/manual/cmake-compile-features.7.rst

@@ -266,6 +266,7 @@ versions specified for each:
 * ``PGI``: PGI version 12.10+.
 * ``NVHPC``: NVIDIA HPC compilers version 11.0+.
 * ``TI``: Texas Instruments compiler.
+* ``TIClang``: Texas Instruments Clang-based compilers.
 * ``XL``: IBM XL version 10.1+.
 
 CMake is currently aware of the :prop_tgt:`C standards <C_STANDARD>` and

Help/release/3.29.rst

@@ -39,6 +39,9 @@ Compilers
 * The LLVM/Clang GNU-like frontend on Windows (``clang++``) may now be used
   to compile ``CUDA`` language sources.
 
+* TI Clang-based compilers are now supported with
+  :variable:`compiler id <CMAKE_<LANG>_COMPILER_ID>` ``TIClang``.
+
 Commands
 --------
 

Help/variable/CMAKE_LANG_COMPILER_ID.rst

@@ -43,6 +43,7 @@ Value                           Name
 ``SunPro``                      Oracle Solaris Studio
 ``Tasking``                     `Tasking Compiler Toolsets`_
 ``TI``                          Texas Instruments
+``TIClang``                     `Texas Instruments Clang-based Compilers`_
 ``TinyCC``                      `Tiny C Compiler`_
 ``XL``, ``VisualAge``, ``zOS``  IBM XL
 ``XLClang``                     IBM Clang-based XL
@@ -68,3 +69,4 @@ languages.
 .. _Small Device C Compiler: https://sdcc.sourceforge.net
 .. _Tiny C Compiler: https://bellard.org/tcc
 .. _Tasking Compiler Toolsets: https://www.tasking.com
+.. _Texas Instruments Clang-based Compilers: https://www.ti.com/tool/download/ARM-CGT-CLANG

Modules/CMakeCompilerIdDetection.cmake

@@ -80,6 +80,7 @@ function(compiler_id_detection outvar lang)
       ARMCC
       AppleClang
       ARMClang
+      TIClang
     )
     list(APPEND ordered_compilers
       Clang

Modules/CMakeDetermineASMCompiler.cmake

@@ -102,6 +102,10 @@ if(NOT CMAKE_ASM${ASM_DIALECT}_COMPILER_ID)
   set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_TI "-h")
   set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_TI "Texas Instruments")
 
+  list(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS TIClang )
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_TIClang "--version")
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_TIClang "(TI (.*) Clang Compiler)")
+
   list(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS IAR)
   set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_IAR )
   set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_IAR "IAR Assembler")

Modules/CMakeDetermineCCompiler.cmake

@@ -166,6 +166,11 @@ if (NOT _CMAKE_TOOLCHAIN_PREFIX)
       set(_CMAKE_TOOLCHAIN_PREFIX ${CMAKE_MATCH_1})
       set(_CMAKE_TOOLCHAIN_SUFFIX ${CMAKE_MATCH_4})
       set(_CMAKE_COMPILER_SUFFIX ${CMAKE_MATCH_6})
+    elseif(CMAKE_C_COMPILER_ID MATCHES "TIClang")
+       if (COMPILER_BASENAME MATCHES "^(.+)?clang(\\.exe)?$")
+         set(_CMAKE_TOOLCHAIN_PREFIX "${CMAKE_MATCH_1}")
+         set(_CMAKE_TOOLCHAIN_SUFFIX "${CMAKE_MATCH_2}")
+       endif()
     elseif(CMAKE_C_COMPILER_ID MATCHES "Clang")
       if(CMAKE_C_COMPILER_TARGET)
         set(_CMAKE_TOOLCHAIN_PREFIX ${CMAKE_C_COMPILER_TARGET}-)

Modules/CMakeDetermineCXXCompiler.cmake

@@ -171,6 +171,11 @@ if (NOT _CMAKE_TOOLCHAIN_PREFIX)
       set(_CMAKE_TOOLCHAIN_PREFIX ${CMAKE_MATCH_1})
       set(_CMAKE_TOOLCHAIN_SUFFIX ${CMAKE_MATCH_3})
       set(_CMAKE_COMPILER_SUFFIX ${CMAKE_MATCH_5})
+    elseif(CMAKE_CXX_COMPILER_ID MATCHES "TIClang")
+       if (COMPILER_BASENAME MATCHES "^(.+)?clang(\\.exe)?$")
+         set(_CMAKE_TOOLCHAIN_PREFIX "${CMAKE_MATCH_1}")
+         set(_CMAKE_TOOLCHAIN_SUFFIX "${CMAKE_MATCH_2}")
+       endif()
     elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
       if(CMAKE_CXX_COMPILER_TARGET)
         set(_CMAKE_TOOLCHAIN_PREFIX ${CMAKE_CXX_COMPILER_TARGET}-)

Modules/CMakeDetermineCompilerId.cmake

@@ -280,7 +280,8 @@ function(CMAKE_DETERMINE_COMPILER_ID lang flagvar src)
     endif()
   elseif("x${CMAKE_${lang}_COMPILER_ID}" STREQUAL "xGNU"
     OR "x${CMAKE_${lang}_COMPILER_ID}" STREQUAL "xAppleClang"
-    OR "x${CMAKE_${lang}_COMPILER_ID}" STREQUAL "xFujitsuClang")
+    OR "x${CMAKE_${lang}_COMPILER_ID}" STREQUAL "xFujitsuClang"
+    OR "x${CMAKE_${lang}_COMPILER_ID}" STREQUAL "xTIClang")
     set(CMAKE_${lang}_COMPILER_FRONTEND_VARIANT "GNU")
   elseif("x${CMAKE_${lang}_COMPILER_ID}" STREQUAL "xMSVC")
     set(CMAKE_${lang}_COMPILER_FRONTEND_VARIANT "MSVC")

Modules/CMakePlatformId.h.in

@@ -219,6 +219,14 @@
 #  define ARCHITECTURE_ID ""
 # endif
 
+#elif defined(__clang__) && defined(__ti__)
+# if defined(__ARM_ARCH)
+#  define ARCHITECTURE_ID "Arm"
+
+# else /* unknown architecture */
+#  define ARCHITECTURE_ID ""
+# endif
+
 #elif defined(__TI_COMPILER_VERSION__)
 # if defined(__TI_ARM__)
 #  define ARCHITECTURE_ID "ARM"

Modules/Compiler/TIClang-ASM.cmake

@@ -0,0 +1,9 @@
+include(Compiler/TIClang)
+
+set(CMAKE_ASM_OUTPUT_EXTENSION ".o")
+set(CMAKE_ASM_OUTPUT_EXTENSION_REPLACE 1)
+
+set(CMAKE_ASM_COMPILE_OBJECT       "<CMAKE_ASM_COMPILER> <DEFINES> <INCLUDES> <FLAGS> -c -o <OBJECT> <SOURCE>")
+set(CMAKE_ASM_SOURCE_FILE_EXTENSIONS S;s;asm;msa)
+
+__compiler_ticlang(ASM)

Modules/Compiler/TIClang-C-FeatureTests.cmake

@@ -0,0 +1 @@
+include(Compiler/Clang-C-FeatureTests)

Modules/Compiler/TIClang-C.cmake

@@ -0,0 +1,23 @@
+include(Compiler/Clang-C)
+include(Compiler/TIClang)
+__compiler_ticlang(C)
+
+if((NOT DEFINED CMAKE_DEPENDS_USE_COMPILER OR CMAKE_DEPENDS_USE_COMPILER)
+    AND CMAKE_GENERATOR MATCHES "Makefiles|WMake"
+    AND CMAKE_DEPFILE_FLAGS_C)
+  # dependencies are computed by the compiler itself
+  set(CMAKE_C_DEPFILE_FORMAT gcc)
+  set(CMAKE_C_DEPENDS_USE_COMPILER TRUE)
+endif()
+
+set(CMAKE_C90_STANDARD_COMPILE_OPTION "-std=c90")
+set(CMAKE_C90_EXTENSION_COMPILE_OPTION "-std=gnu90")
+set(CMAKE_C90_STANDARD__HAS_FULL_SUPPORT ON)
+
+set(CMAKE_C99_STANDARD_COMPILE_OPTION "-std=c99")
+set(CMAKE_C99_EXTENSION_COMPILE_OPTION "-std=gnu99")
+set(CMAKE_C99_STANDARD__HAS_FULL_SUPPORT ON)
+
+set(CMAKE_C11_STANDARD_COMPILE_OPTION "-std=c11")
+set(CMAKE_C11_EXTENSION_COMPILE_OPTION "-std=gnu11")
+set(CMAKE_C11_STANDARD__HAS_FULL_SUPPORT ON)

Modules/Compiler/TIClang-CXX-FeatureTests.cmake

@@ -0,0 +1 @@
+include(Compiler/Clang-CXX-FeatureTests)

Modules/Compiler/TIClang-CXX.cmake

@@ -0,0 +1,25 @@
+include(Compiler/Clang-CXX)
+include(Compiler/TIClang)
+__compiler_ticlang(CXX)
+
+if((NOT DEFINED CMAKE_DEPENDS_USE_COMPILER OR CMAKE_DEPENDS_USE_COMPILER)
+    AND CMAKE_GENERATOR MATCHES "Makefiles|WMake"
+    AND CMAKE_DEPFILE_FLAGS_CXX)
+  # dependencies are computed by the compiler itself
+  set(CMAKE_CXX_DEPFILE_FORMAT gcc)
+  set(CMAKE_CXX_DEPENDS_USE_COMPILER TRUE)
+endif()
+
+set(CMAKE_CXX98_STANDARD_COMPILE_OPTION "-std=c++98")
+set(CMAKE_CXX98_EXTENSION_COMPILE_OPTION "-std=gnu++98")
+set(CMAKE_CXX98_STANDARD__HAS_FULL_SUPPORT ON)
+
+set(CMAKE_CXX11_STANDARD_COMPILE_OPTION "-std=c++11")
+set(CMAKE_CXX11_EXTENSION_COMPILE_OPTION "-std=gnu++11")
+
+set(CMAKE_CXX14_STANDARD_COMPILE_OPTION "-std=c++14")
+set(CMAKE_CXX14_EXTENSION_COMPILE_OPTION "-std=gnu++14")
+set(CMAKE_CXX14_STANDARD__HAS_FULL_SUPPORT ON)
+
+set(CMAKE_CXX17_STANDARD_COMPILE_OPTION "-std=c++17")
+set(CMAKE_CXX17_EXTENSION_COMPILE_OPTION "-std=gnu++17")

Modules/Compiler/TIClang-DetermineCompiler.cmake

@@ -0,0 +1,10 @@
+# TI Clang-based Toolchains
+set(_compiler_id_pp_test "defined(__clang__) && defined(__ti__)")
+
+set(_compiler_id_version_compute "
+  # define @PREFIX@COMPILER_VERSION_MAJOR @MACRO_DEC@(__ti_major__)
+  # define @PREFIX@COMPILER_VERSION_MINOR @MACRO_DEC@(__ti_minor__)
+  # define @PREFIX@COMPILER_VERSION_PATCH @MACRO_DEC@(__ti_patchlevel__)")
+
+string(APPEND _compiler_id_version_compute "
+# define @PREFIX@COMPILER_VERSION_INTERNAL @MACRO_DEC@(__ti_version__)")

Modules/Compiler/TIClang.cmake

@@ -0,0 +1,30 @@
+if(__COMPILER_TICLANG)
+  return()
+endif()
+set(__COMPILER_TICLANG TRUE)
+
+include(Compiler/CMakeCommonCompilerMacros)
+
+# get linker supported cpu list
+macro(__compiler_ticlang lang)
+  set(CMAKE_${lang}_RESPONSE_FILE_LINK_FLAG "-Xlinker ")
+
+  set(CMAKE_${lang}_CREATE_PREPROCESSED_SOURCE "<CMAKE_${lang}_COMPILER> <DEFINES> <INCLUDES> <FLAGS> -E <SOURCE> > <PREPROCESSED_SOURCE>")
+
+  set(CMAKE_${lang}_CREATE_ASSEMBLY_SOURCE "<CMAKE_${lang}_COMPILER> <DEFINES> <INCLUDES> <FLAGS> -S <SOURCE> -o <ASSEMBLY_SOURCE>")
+
+  set(CMAKE_${lang}_COMPILE_OBJECT  "<CMAKE_${lang}_COMPILER> -c <SOURCE> <DEFINES> <INCLUDES> <FLAGS> -o <OBJECT>")
+
+  set(CMAKE_${lang}_LINK_EXECUTABLE "<CMAKE_${lang}_COMPILER> <FLAGS> -Xlinker --output_file=<TARGET> -Xlinker --map_file=<TARGET_NAME>.map -Xlinker --rom_model <CMAKE_${lang}_LINK_FLAGS> <LINK_FLAGS> <OBJECTS> <LINK_LIBRARIES>")
+
+  set(CMAKE_${lang}_ARCHIVE_CREATE  "<CMAKE_AR> cr <TARGET> <OBJECTS>")
+  set(CMAKE_${lang}_ARCHIVE_APPEND  "<CMAKE_AR> r <TARGET> <OBJECTS>")
+  set(CMAKE_${lang}_ARCHIVE_FINISH  "")
+
+  set(CMAKE_${lang}_LINKER_WRAPPER_FLAG "-Xlinker" " ")
+  set(CMAKE_${lang}_LINKER_WRAPPER_FLAG_SEP)
+endmacro()
+
+set(CMAKE_EXECUTABLE_SUFFIX ".out")
+set(CMAKE_LIBRARY_PATH_FLAG "-Wl,--search_path=")
+set(CMAKE_LINK_LIBRARY_FLAG "-Wl,--library=")

Tests/RunCMake/CMakeLists.txt

@@ -1177,3 +1177,9 @@ if(CMake_TEST_IAR_TOOLCHAINS)
   add_RunCMake_test(IAR -DCMake_TEST_IAR_TOOLCHAINS=${CMake_TEST_IAR_TOOLCHAINS})
   set_property(TEST RunCMake.IAR APPEND PROPERTY LABELS "IAR")
 endif()
+if(CMake_TEST_TICLANG_TOOLCHAINS)
+  # This is necessary to preserve the LIST variable contents given by user.
+  string(REPLACE ";" "$<SEMICOLON>" TOOLCHAINS "${CMake_TEST_TICLANG_TOOLCHAINS}")
+  add_RunCMake_test(TIClang "-DCMake_TEST_TICLANG_TOOLCHAINS=${TOOLCHAINS}")
+  set_property(TEST RunCMake.TIClang APPEND PROPERTY LABELS "TIClang")
+endif()

Tests/RunCMake/TIClang/CMakeLists.txt

@@ -0,0 +1,3 @@
+cmake_minimum_required(VERSION 3.29)
+project(${RunCMake_TEST} NONE)
+include(${RunCMake_TEST}.cmake)

Tests/RunCMake/TIClang/RunCMakeTest.cmake

@@ -0,0 +1,61 @@
+include(RunCMake)
+
+# Test expects to be given a LIST of toolchain directories where a TIClang
+# compiler binary is expected to be found relative to the "bin" directory:
+# "-DCMake_TEST_TICLANG_TOOLCHAINS=<path1>;<path2>;<path3>"
+if(RunCMake_GENERATOR MATCHES "Makefile|Ninja")
+  set(_ticlang_toolchains "${CMake_TEST_TICLANG_TOOLCHAINS}" )
+endif()
+
+function(run_toolchain case)
+  set(RunCMake_TEST_BINARY_DIR ${RunCMake_BINARY_DIR}/${case}-build)
+  run_cmake_with_options(${case} ${ARGN})
+  set(RunCMake_TEST_NO_CLEAN 1)
+  run_cmake_command(${case}-build ${CMAKE_COMMAND} --build .)
+endfunction()
+
+foreach(_ticlang_toolchain_path IN LISTS _ticlang_toolchains)
+  file(GLOB _ticlang_toolchain "${_ticlang_toolchain_path}/bin/*clang" )
+  if(_ticlang_toolchain STREQUAL "")
+    message(WARNING
+          "Could not find a TIClang toolchain at: ${_ticlang_toolchain_path}.")
+    continue()
+  endif()
+
+  message(STATUS "Found TIClang toolchain: ${_ticlang_toolchain}")
+
+  if(_ticlang_toolchain MATCHES "tiarmclang")
+    set(LINK_OPTS "--use_memcpy=fast,--use_memset=fast,-llnk.cmd")
+    set(CMAKE_FLAGS "-mcpu=cortex-r5 -Oz")
+  else()
+    set(CMAKE_FLAGS "")
+    set(LINK_OPTS "")
+  endif()
+
+  run_toolchain(ticlang-c
+    -DCMAKE_SYSTEM_NAME=Generic
+    -DCMAKE_C_COMPILER=${_ticlang_toolchain}
+    -DCMAKE_C_FLAGS=${CMAKE_FLAGS}
+    -DCMAKE_C_LINKER_FLAGS=${LINK_OPTS}
+  )
+
+  run_toolchain(ticlang-cxx
+    -DCMAKE_SYSTEM_NAME=Generic
+    -DCMAKE_CXX_COMPILER=${_ticlang_toolchain}
+    -DCMAKE_CXX_FLAGS=${CMAKE_FLAGS}
+    -DCMAKE_CXX_LINKER_FLAGS=${LINK_OPTS}
+  )
+
+  run_toolchain(ticlang-asm
+    -DCMAKE_SYSTEM_NAME=Generic
+    -DCMAKE_ASM_COMPILER=${_ticlang_toolchain}
+    -DCMAKE_ASM_FLAGS=${CMAKE_FLAGS}
+  )
+
+  run_toolchain(ticlang-lib
+    -DCMAKE_SYSTEM_NAME=Generic
+    -DCMAKE_C_COMPILER=${_ticlang_toolchain}
+    -DCMAKE_C_FLAGS=${CMAKE_FLAGS}
+    -DCMAKE_C_LINKER_FLAGS=${LINK_OPTS}
+  )
+endforeach()

Tests/RunCMake/TIClang/libmod.c

@@ -0,0 +1,4 @@
+int ticlang_libfun()
+{
+  return 42;
+}

Tests/RunCMake/TIClang/module.c

@@ -0,0 +1,14 @@
+#include "module.h"
+#if defined(__USE_LIBFUN)
+extern int ticlang_libfun();
+#endif
+int i;
+int main()
+{
+#if defined(__USE_LIBFUN)
+  i = ticlang_libfun();
+#else
+  i = INTERNAL;
+#endif
+  return i;
+}

Tests/RunCMake/TIClang/module.cxx

@@ -0,0 +1,7 @@
+#include "module.h"
+int i;
+int main()
+{
+  i = INTERNAL;
+  return i;
+}

Tests/RunCMake/TIClang/module.h

@@ -0,0 +1,12 @@
+#ifndef __MODULE_H__
+#define __MODULE_H__
+
+#if defined(__cplusplus)
+#  define INTERNAL 64
+#elif !defined(__cplusplus)
+#  define INTERNAL 32
+#else
+#  error "Unable to determine INTERNAL symbol."
+#endif
+
+#endif /* __MODULE_H__ */

Tests/RunCMake/TIClang/module.s

@@ -0,0 +1,9 @@
+	.text
+	.syntax unified
+	.section	.text.main,"ax",%progbits
+	.hidden	main
+	.globl	main
+	.p2align	4
+main:
+	nop
+	bx	lr

Tests/RunCMake/TIClang/ticlang-asm.cmake

@@ -0,0 +1,5 @@
+enable_language(ASM)
+
+add_executable(exec-asm)
+target_sources(exec-asm PRIVATE module.s)
+target_link_options(exec-asm PRIVATE ${LINKER_OPTS})

Tests/RunCMake/TIClang/ticlang-c.cmake

@@ -0,0 +1,5 @@
+enable_language(C)
+
+add_executable(exec-c)
+target_sources(exec-c PRIVATE module.c)
+target_link_options(exec-c PRIVATE ${LINKER_OPTS})

Tests/RunCMake/TIClang/ticlang-cxx.cmake

@@ -0,0 +1,5 @@
+enable_language(CXX)
+
+add_executable(exec-cxx)
+target_sources(exec-cxx PRIVATE module.cxx)
+target_link_options(exec-cxx PRIVATE ${LINKER_OPTS})

Tests/RunCMake/TIClang/ticlang-lib.cmake

@@ -0,0 +1,10 @@
+enable_language(C)
+
+add_library(ticlang-test-lib)
+target_sources(ticlang-test-lib PRIVATE libmod.c)
+
+add_executable(exec-lib-c)
+target_sources(exec-lib-c PRIVATE module.c)
+target_compile_definitions(exec-lib-c PRIVATE __USE_LIBFUN)
+target_link_libraries(exec-lib-c LINK_PUBLIC ticlang-test-lib)
+target_link_options(exec-lib-c PRIVATE ${LINKER_OPTS})