TIClang: Add support for TI Clang-based compilers, including tiarmclang

Add TIClang compiler ID and support in compiler modules.  Update
documentation.  Add rudimentary RunCMake test for TIClang to test
basic functionality.

Fixes: #24619

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})