Renesas: Add support for Renesas compilers

- CC-RX for RX architecture
- CC-RL for RL78 architecture
- CC-RH for RH850 architecture

Closes: #26880

Help/variable/CMAKE_LANG_COMPILER_ARCHITECTURE_ID.rst

@@ -253,6 +253,23 @@ These identifiers are used when :variable:`CMAKE_<LANG>_COMPILER_ID` is
 ``V850``
   Renesas Electronics V850 32-bit
 
+Renesas Compiler Platforms
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+.. versionadded:: 4.1
+
+These identifiers are used when :variable:`CMAKE_<LANG>_COMPILER_ID` is
+``Renesas``.
+
+``RH850``
+  Renesas Electronics RH850
+
+``RL78``
+  Renesas Electronics RL78
+
+``RX``
+  Renesas Electronics RX
+
 TASKING Platforms
 ^^^^^^^^^^^^^^^^^
 

Help/variable/CMAKE_LANG_COMPILER_ID.rst

@@ -42,6 +42,7 @@ Value                           Name
 ``PGI``                         The Portland Group
 ``PathScale``                   PathScale
 ``QCC``                         QNX C/C++ compiler
+``Renesas``                     `Renesas Compiler`_
 ``SCO``                         SCO OpenServer/UnixWare C/C++ Compiler
 ``SDCC``                        `Small Device C Compiler`_
 ``SunPro``                      Oracle Developer Studio
@@ -70,6 +71,7 @@ languages.
 .. _NVIDIA CUDA Compiler: https://developer.nvidia.com/cuda-llvm-compiler
 .. _Open Watcom: https://open-watcom.github.io
 .. _OrangeC Compiler: https://github.com/LADSoft/OrangeC
+.. _Renesas Compiler: https://www.renesas.com
 .. _Small Device C Compiler: https://sdcc.sourceforge.net
 .. _Tiny C Compiler: https://bellard.org/tcc
 .. _Tasking Compiler Toolsets: https://www.tasking.com

Modules/CMakeCCompilerId.c.in

@@ -48,7 +48,7 @@ char const *info_cray = "INFO" ":" "compiler_wrapper[CrayPrgEnv]";
 #  define C_STD __STDC_VERSION__
 #endif
 
-#if !defined(__STDC__) && !defined(__clang__)
+#if !defined(__STDC__) && !defined(__clang__) && !defined(__RENESAS__)
 # if defined(_MSC_VER) || defined(__ibmxl__) || defined(__IBMC__)
 #  define C_VERSION "90"
 # else
@@ -70,7 +70,7 @@ const char* info_language_standard_default =
 
 const char* info_language_extensions_default = "INFO" ":" "extensions_default["
 #if (defined(__clang__) || defined(__GNUC__) || defined(__xlC__) ||           \
-     defined(__TI_COMPILER_VERSION__)) &&                                     \
+     defined(__TI_COMPILER_VERSION__) || defined(__RENESAS__)) &&             \
   !defined(__STRICT_ANSI__)
   "ON"
 #else

Modules/CMakeCXXCompilerId.cpp.in

@@ -108,7 +108,7 @@ const char* info_language_standard_default = "INFO" ":" "standard_default["
 
 const char* info_language_extensions_default = "INFO" ":" "extensions_default["
 #if (defined(__clang__) || defined(__GNUC__) || defined(__xlC__) ||           \
-     defined(__TI_COMPILER_VERSION__)) &&                                     \
+     defined(__TI_COMPILER_VERSION__) || defined(__RENESAS__)) &&             \
   !defined(__STRICT_ANSI__)
   "ON"
 #else

Modules/CMakeCompilerIdDetection.cmake

@@ -68,6 +68,7 @@ function(compiler_id_detection outvar lang)
       GHS
       Tasking
       OrangeC
+      Renesas
     )
     if ("x${lang}" STREQUAL "xC")
       list(APPEND ordered_compilers

Modules/CMakeDetermineASMCompiler.cmake

@@ -161,6 +161,10 @@ if(NOT CMAKE_ASM${ASM_DIALECT}_COMPILER_ID)
   set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_Tasking "--version")
   set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_Tasking "TASKING")
 
+  list(APPEND CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDORS Renesas)
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_FLAGS_Renesas "-v")
+  set(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_VENDOR_REGEX_Renesas "(RX Family C/C\\+\\+ Compiler)|(RL78 Family Compiler)|(RH850 Family Compiler)")
+
   include(CMakeDetermineCompilerId)
   set(userflags)
   CMAKE_DETERMINE_COMPILER_ID_VENDOR(ASM${ASM_DIALECT} "${userflags}")
@@ -189,6 +193,10 @@ if(NOT CMAKE_ASM${ASM_DIALECT}_COMPILER_ID)
         set(CMAKE_ASM${ASM_DIALECT}_COMPILER_FRONTEND_VARIANT "GNU")
       endif()
       set(_variant " with ${CMAKE_ASM${ASM_DIALECT}_COMPILER_FRONTEND_VARIANT}-like command-line")
+  elseif("x${CMAKE_ASM${ASM_DIALECT}_COMPILER_ID}" STREQUAL "xRenesas")
+    string(REGEX MATCH "[A-Za-z0-9]+ Family (C/C\\+\\+ )*Compiler [V|E][0-9|.]+" _compiler_id "${CMAKE_ASM${ASM_DIALECT}_COMPILER_ID_OUTPUT}")
+    string(REGEX MATCH "R[A-Za-z0-9]+" CMAKE_ASM${ASM_DIALECT}_COMPILER_ARCHITECTURE_ID "${_compiler_id}")
+    string(REGEX MATCH "V[0-9|.]+" CMAKE_ASM${ASM_DIALECT}_COMPILER_VERSION "${_compiler_id}")
   endif()
 
   _cmake_find_compiler_sysroot(ASM${ASM_DIALECT})
@@ -208,6 +216,8 @@ if(CMAKE_ASM${ASM_DIALECT}_COMPILER_ID)
   endif()
   if(CMAKE_ASM${ASM_DIALECT}_COMPILER_ARCHITECTURE_ID AND "x${CMAKE_ASM${ASM_DIALECT}_COMPILER_ID}" STREQUAL "xIAR")
     set(_archid " ${CMAKE_ASM${ASM_DIALECT}_COMPILER_ARCHITECTURE_ID}")
+  elseif(CMAKE_ASM${ASM_DIALECT}_COMPILER_ARCHITECTURE_ID AND "x${CMAKE_ASM${ASM_DIALECT}_COMPILER_ID}" STREQUAL "xRenesas")
+    set(_archid " ${CMAKE_ASM${ASM_DIALECT}_COMPILER_ARCHITECTURE_ID} Family Assembler")
   else()
     set(_archid "")
   endif()

Modules/CMakeDetermineCompilerId.cmake

@@ -386,6 +386,25 @@ function(CMAKE_DETERMINE_COMPILER_ID lang flagvar src)
     endif()
     if(CMAKE_${lang}_COMPILER_ARCHITECTURE_ID AND "x${CMAKE_${lang}_COMPILER_ID}" STREQUAL "xIAR")
       set(_archid " ${CMAKE_${lang}_COMPILER_ARCHITECTURE_ID}")
+    elseif(CMAKE_${lang}_COMPILER_ARCHITECTURE_ID AND "x${CMAKE_${lang}_COMPILER_ID}" STREQUAL "xRenesas")
+      # Architecture is "RH850", "RL78" or "RX", compiler name to show is "CC-RH", "CC-RL" or "CC-RX"
+      string(SUBSTRING ${CMAKE_${lang}_COMPILER_ARCHITECTURE_ID} 0 2 _archid)
+      set(_archid " CC-${_archid}")
+      # Detected compiler version is in the form as "3.2.1", show it as "3.02.01" according to the compiler's document.
+      string(REPLACE "." ";" _version_list ${_version})
+      list(GET _version_list 0 _version)
+      foreach(_i RANGE 1 2)
+        list(GET _version_list ${_i} _minor)
+        string(LENGTH ${_minor} _minor_len)
+        if (${_minor_len} EQUAL 1)
+          set(_minor "0${_minor}")
+        endif()
+        string(APPEND _version ".${_minor}")
+        unset(_minor)
+        unset(_minor_len)
+      endforeach()
+      string(REPLACE " " " V" _version ${_version})
+      unset(_version_list)
     else()
       set(_archid "")
     endif()

Modules/CMakePlatformId.h.in

@@ -274,6 +274,20 @@
 #  define ARCHITECTURE_ID ""
 # endif
 
+#elif defined(__RENESAS__)
+# if defined(__CCRX__)
+#  define ARCHITECTURE_ID "RX"
+
+# elif defined(__CCRL__)
+#  define ARCHITECTURE_ID "RL78"
+
+# elif defined(__CCRH__)
+#  define ARCHITECTURE_ID "RH850"
+
+# else
+#  define ARCHITECTURE_ID ""
+# endif
+
 #else
 #  define ARCHITECTURE_ID
 #endif

Modules/Compiler/Renesas-ASM.cmake

@@ -0,0 +1,13 @@
+
+include(Compiler/Renesas)
+__compiler_renesas(ASM)
+
+if(CMAKE_ASM_COMPILER_ARCHITECTURE_ID STREQUAL "RX")
+  set(CMAKE_ASM_SOURCE_FILE_EXTENSIONS src;SRC;s;S)
+elseif(CMAKE_ASM_COMPILER_ARCHITECTURE_ID STREQUAL "RL78")
+  set(CMAKE_ASM_SOURCE_FILE_EXTENSIONS asm;ASM;s;S)
+elseif(CMAKE_ASM_COMPILER_ARCHITECTURE_ID STREQUAL "RH850")
+  set(CMAKE_ASM_SOURCE_FILE_EXTENSIONS asm;ASM;s;S)
+else()
+    message(FATAL_ERROR "Architecture for Renesas compiler: ${CMAKE_ASM_COMPILER_ARCHITECTURE_ID} is not supported.")
+endif()

Modules/Compiler/Renesas-C-FeatureTests.cmake

@@ -0,0 +1,14 @@
+
+set(_cmake_oldestSupported "((__RENESAS_VERSION__ >> 24 & 0xFF)) >= 1")
+
+
+set(Renesas_C11 "${_cmake_oldestSupported} && defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201112L")
+set(Renesas_C99 "${_cmake_oldestSupported} && defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L")
+
+set(_cmake_feature_test_c_std_99 "${Renesas_C99}")
+set(_cmake_feature_test_c_restrict "${Renesas_C99}")
+set(_cmake_feature_test_c_variadic_macros "${Renesas_C99}")
+
+set(Renesas_C90 "${_cmake_oldestSupported}")
+set(_cmake_feature_test_c_std_90 "${Renesas_C90}")
+set(_cmake_feature_test_c_function_prototypes "${Renesas_C90}")

Modules/Compiler/Renesas-C.cmake

@@ -0,0 +1,10 @@
+
+include(Compiler/Renesas)
+__compiler_renesas(C)
+
+set(CMAKE_C90_STANDARD_COMPILE_OPTION "-lang=c")
+set(CMAKE_C90_EXTENSION_COMPILE_OPTION "-lang=c")
+set(CMAKE_C99_STANDARD_COMPILE_OPTION "-lang=c99")
+set(CMAKE_C99_EXTENSION_COMPILE_OPTION "-lang=c99")
+
+__compiler_check_default_language_standard(C 1.0 90)

Modules/Compiler/Renesas-CXX.cmake

@@ -0,0 +1,3 @@
+
+include(Compiler/Renesas)
+__compiler_renesas(CXX)

Modules/Compiler/Renesas-DetermineCompiler.cmake

@@ -0,0 +1,7 @@
+set(_compiler_id_pp_test "defined(__RENESAS__)")
+
+set(_compiler_id_version_compute "
+/* __RENESAS_VERSION__ = 0xVVRRPP00 */
+# define @PREFIX@COMPILER_VERSION_MAJOR @MACRO_HEX@(__RENESAS_VERSION__ >> 24 & 0xFF)
+# define @PREFIX@COMPILER_VERSION_MINOR @MACRO_HEX@(__RENESAS_VERSION__ >> 16 & 0xFF)
+# define @PREFIX@COMPILER_VERSION_PATCH @MACRO_HEX@(__RENESAS_VERSION__ >> 8  & 0xFF)")

Modules/Compiler/Renesas.cmake

@@ -0,0 +1,140 @@
+
+include_guard()
+
+include(Compiler/CMakeCommonCompilerMacros)
+
+macro(__compiler_renesas lang)
+
+  if(CMAKE_${lang}_COMPILER_ARCHITECTURE_ID STREQUAL "RX")
+# CC-RX
+    # Pass directly include and define flag to the assembler.
+    if ("${lang}" STREQUAL "ASM")
+      set(_ASM_PREFIX "-asmopt=")
+    endif()
+    set(CMAKE_INCLUDE_FLAG_${lang} "${_ASM_PREFIX}-include=")
+    set(CMAKE_${lang}_DEFINE_FLAG "${_ASM_PREFIX}-define=")
+
+    set(CMAKE_LINK_LIBRARY_FLAG "-lnkopt=-library=")
+    set(CMAKE_${lang}_RESPONSE_FILE_FLAG "-subcommand=")
+    set(CMAKE_${lang}_LINKER_WRAPPER_FLAG "-lnkopt=" "")
+
+    set(_RENESAS_DEBUG_FLAG "-debug")
+    if (CMAKE_${lang}_COMPILER_VERSION VERSION_GREATER_EQUAL 3.02)
+      string(APPEND _RENESAS_DEBUG_FLAG " -g_line")
+    endif()
+
+    string(APPEND CMAKE_${lang}_FLAGS_INIT " ")
+    string(APPEND CMAKE_${lang}_FLAGS_DEBUG_INIT " -optimize=0 ${_RENESAS_DEBUG_FLAG}")
+    string(APPEND CMAKE_${lang}_FLAGS_RELEASE_INIT " ${CMAKE_${lang}_DEFINE_FLAG}NDEBUG=1")
+    string(APPEND CMAKE_${lang}_FLAGS_RELWITHDEBINFO_INIT " ${_RENESAS_DEBUG_FLAG} ${CMAKE_${lang}_DEFINE_FLAG}NDEBUG=1")
+    string(APPEND CMAKE_${lang}_FLAGS_MINSIZEREL_INIT " -size ${CMAKE_${lang}_DEFINE_FLAG}NDEBUG=1")
+
+    set(_PREP_OUT "-output=prep=<PREPROCESSED_SOURCE>")
+    set(_ASM_OUT "-output=src=<ASSEMBLY_SOURCE>")
+    set(_OBJ_OUT "-output=obj=<OBJECT>")
+    set(_EXE_OUT "-output=abs=<TARGET>")
+    if ("${lang}" STREQUAL "ASM")
+      # Assembler dependency.
+      set(_DEP_OUT "${_ASM_PREFIX}-MM ${_ASM_PREFIX}-MT=<OBJECT> ${_ASM_PREFIX}-MF=<DEP_FILE>")
+    else()
+      # Compiler dependency.
+      set(_DEP_OUT "-MM -MT=<OBJECT> -output=dep=<DEP_FILE>")
+    endif()
+
+  elseif(CMAKE_${lang}_COMPILER_ARCHITECTURE_ID STREQUAL "RL78")
+# CC-RL
+    # Pass directly include and define flag to the assembler.
+    if ("${lang}" STREQUAL "ASM")
+      set(_ASM_PREFIX "-asmopt=")
+      set(CMAKE_INCLUDE_FLAG_${lang} "${_ASM_PREFIX}-include=")
+      set(CMAKE_${lang}_DEFINE_FLAG "${_ASM_PREFIX}-define=")
+    endif()
+
+    set(CMAKE_LINK_LIBRARY_FLAG "-lnkopt=-library=")
+    set(CMAKE_${lang}_RESPONSE_FILE_FLAG "-subcommand=")
+    set(CMAKE_${lang}_LINKER_WRAPPER_FLAG "-lnkopt=" "")
+
+    set(_RENESAS_DEBUG_FLAG "-g")
+    if (CMAKE_${lang}_COMPILER_VERSION VERSION_GREATER_EQUAL 1.02)
+      string(APPEND _RENESAS_DEBUG_FLAG " -g_line")
+    endif()
+
+    string(APPEND CMAKE_${lang}_FLAGS_INIT " ")
+    string(APPEND CMAKE_${lang}_FLAGS_DEBUG_INIT " -Onothing ${_RENESAS_DEBUG_FLAG}")
+    string(APPEND CMAKE_${lang}_FLAGS_RELEASE_INIT " ${CMAKE_${lang}_DEFINE_FLAG}NDEBUG")
+    string(APPEND CMAKE_${lang}_FLAGS_RELWITHDEBINFO_INIT " ${_RENESAS_DEBUG_FLAG} ${CMAKE_${lang}_DEFINE_FLAG}NDEBUG")
+    string(APPEND CMAKE_${lang}_FLAGS_MINSIZEREL_INIT " -Osize ${CMAKE_${lang}_DEFINE_FLAG}NDEBUG")
+
+    set(_PREP_OUT "-P -o <PREPROCESSED_SOURCE>")
+    set(_ASM_OUT "-S -o <ASSEMBLY_SOURCE>")
+    set(_OBJ_OUT "-c -o <OBJECT>")
+    set(_EXE_OUT "-o <TARGET>")
+    set(_DEP_OUT "-M -MT=<OBJECT> -o <DEP_FILE>")
+    # Assembler dependency. -c is required to avoid to process to link
+    if ("${lang}" STREQUAL "ASM")
+      set(_DEP_OUT "-c ${_ASM_PREFIX}-MM ${_ASM_PREFIX}-MT=<OBJECT> ${_ASM_PREFIX}-MF=<DEP_FILE>")
+    endif()
+
+  elseif(CMAKE_${lang}_COMPILER_ARCHITECTURE_ID STREQUAL "RH850")
+# CC-RH
+    set(CMAKE_LINK_LIBRARY_FLAG "-Xlk_option=-library=")
+    set(CMAKE_${lang}_LINKER_WRAPPER_FLAG "-Xlk_option=" "")
+    # Pass directly include and define flag to the assembler.
+    if ("${lang}" STREQUAL "ASM")
+      set(_ASM_PREFIX "-Xasm_option=")
+      set(CMAKE_INCLUDE_FLAG_${lang} "${_ASM_PREFIX}-I")
+      set(CMAKE_${lang}_DEFINE_FLAG "${_ASM_PREFIX}-D")
+    endif()
+
+    set(_RENESAS_DEBUG_FLAG "-g")
+    if (CMAKE_${lang}_COMPILER_VERSION VERSION_GREATER_EQUAL 1.05)
+      string(APPEND _RENESAS_DEBUG_FLAG " -g_line")
+    endif()
+
+    string(APPEND CMAKE_${lang}_FLAGS_INIT " ")
+    string(APPEND CMAKE_${lang}_FLAGS_DEBUG_INIT " -Onothing ${_RENESAS_DEBUG_FLAG}")
+    string(APPEND CMAKE_${lang}_FLAGS_RELEASE_INIT " ${CMAKE_${lang}_DEFINE_FLAG}NDEBUG")
+    string(APPEND CMAKE_${lang}_FLAGS_RELWITHDEBINFO_INIT " ${_RENESAS_DEBUG_FLAG} ${CMAKE_${lang}_DEFINE_FLAG}NDEBUG")
+    string(APPEND CMAKE_${lang}_FLAGS_MINSIZEREL_INIT " -Osize ${CMAKE_${lang}_DEFINE_FLAG}NDEBUG")
+
+    set(_PREP_OUT "-P -o<PREPROCESSED_SOURCE>")
+    set(_ASM_OUT "-S -o<ASSEMBLY_SOURCE>")
+    set(_OBJ_OUT "-c -o<OBJECT>")
+    set(_EXE_OUT "-o<TARGET>")
+    set(_DEP_OUT "-M -o<DEP_FILE>")
+    # Assembler dependency. -c is required to avoid to process to link
+    if ("${lang}" STREQUAL "ASM")
+      set(_DEP_OUT "-c ${_ASM_PREFIX}-MM ${_ASM_PREFIX}-MT=<OBJECT> ${_ASM_PREFIX}-MF=<DEP_FILE>")
+    endif()
+
+# Otherwise, not supported architecture.
+  else()
+    message(FATAL_ERROR "Architecture for Renesas compiler: ${CMAKE_${lang}_COMPILER_ARCHITECTURE_ID} is not supported.")
+  endif()
+
+# Common
+  set(CMAKE_EXECUTABLE_SUFFIX ".abs")
+  set(CMAKE_EXECUTABLE_SUFFIX_${lang} ".abs")
+  set(CMAKE_STATIC_LIBRARY_PREFIX "")
+  set(CMAKE_STATIC_LIBRARY_SUFFIX ".lib")
+  set(CMAKE_${lang}_DEPENDS_USE_COMPILER TRUE)
+  set(CMAKE_${lang}_DEPFILE_FORMAT custom)
+  # This is supported only when link process is called from driver.
+  set(CMAKE_${lang}_RESPONSE_FILE_LINK_FLAG "${CMAKE_${lang}_RESPONSE_FILE_FLAG}")
+
+# Compile commands
+  set(CMAKE_${lang}_CREATE_PREPROCESSED_SOURCE "<CMAKE_${lang}_COMPILER> <SOURCE> <DEFINES> <INCLUDES> <FLAGS> ${_PREP_OUT}")
+  set(CMAKE_${lang}_CREATE_ASSEMBLY_SOURCE "<CMAKE_${lang}_COMPILER> <SOURCE> <DEFINES> <INCLUDES> <FLAGS> ${_ASM_OUT}")
+  set(CMAKE_${lang}_COMPILE_OBJECT "<CMAKE_${lang}_COMPILER> <SOURCE> <DEFINES> <INCLUDES> <FLAGS> ${_OBJ_OUT}")
+  set(CMAKE_${lang}_LINK_EXECUTABLE "<CMAKE_${lang}_COMPILER> <FLAGS> <CMAKE_${lang}_LINK_FLAGS> <LINK_FLAGS> <OBJECTS> <LINK_LIBRARIES> ${_EXE_OUT}")
+  set(CMAKE_${lang}_DEPENDS_EXTRA_COMMANDS "<CMAKE_${lang}_COMPILER> <SOURCE> <DEFINES> <INCLUDES> <FLAGS> ${_DEP_OUT}")
+
+# Link/Archive commands. Use rlink as the linker and archiver.
+  get_filename_component(_RENESAS_CC_PATH ${CMAKE_${lang}_COMPILER} DIRECTORY NO_CACHE)
+  set(_RLINK "\"${_RENESAS_CC_PATH}/rlink\"")
+  set(CMAKE_${lang}_CREATE_STATIC_LIBRARY "${_RLINK} -nologo -form=library -output=<TARGET> <LINK_FLAGS> <OBJECTS>")
+  set(CMAKE_${lang}_ARCHIVE_CREATE "${_RLINK} -nologo -form=library -output=<TARGET> <LINK_FLAGS> <OBJECTS>")
+  set(CMAKE_${lang}_ARCHIVE_APPEND "${_RLINK} -nologo -form=library -output=<TARGET> -library=<TARGET> <LINK_FLAGS> <OBJECTS>")
+  set(CMAKE_${lang}_ARCHIVE_FINISH "")
+
+endmacro()

Tests/RunCMake/CMakeLists.txt

@@ -1390,3 +1390,7 @@ if(CMake_TEST_Diab_TOOLCHAINS)
   add_RunCMake_test(Diab -DCMake_TEST_Diab_TOOLCHAINS=${CMake_TEST_Diab_TOOLCHAINS})
   set_property(TEST RunCMake.Diab APPEND PROPERTY LABELS "Diab")
 endif()
+if (CMake_TEST_Renesas_TOOLCHAINS)
+  add_RunCMake_test(Renesas -DCMake_TEST_Renesas_TOOLCHAINS=${CMake_TEST_Renesas_TOOLCHAINS})
+  set_property(TEST RunCMake.Renesas APPEND PROPERTY LABELS "Renesas")
+endif()

Tests/RunCMake/Renesas/CMakeLists.txt

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

Tests/RunCMake/Renesas/RunCMakeTest.cmake

@@ -0,0 +1,69 @@
+include(RunCMake)
+
+if(RunCMake_GENERATOR MATCHES "Makefile|Ninja")
+  file(GLOB _renesas_toolchains
+    "${CMake_TEST_Renesas_TOOLCHAINS}/*/*/bin/ccr*.exe" )
+  if(_renesas_toolchains STREQUAL "")
+    message(FATAL_ERROR "Could not find any Renesas toolchains at: ${CMake_TEST_Renesas_TOOLCHAINS}.")
+  endif()
+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(_renesas_toolchain IN LISTS _renesas_toolchains)
+  cmake_path(GET _renesas_toolchain PARENT_PATH BIN_DIR)
+  cmake_path(GET _renesas_toolchain FILENAME BIN_NAME)
+
+  if(BIN_NAME MATCHES "ccrx.exe")
+# CC-RX
+    set(ENV{BIN_RX} ${BIN_DIR})
+    run_toolchain(renesas-c
+      -DCMAKE_SYSTEM_NAME=Generic
+      -DCMAKE_C_COMPILER=${_renesas_toolchain}
+      -DCMAKE_C_FLAGS="-isa=rxv2"
+      -DCMAKE_EXE_LINKER_FLAGS="-lnkopt=-start=P,C,D/100,B/8000"
+    )
+    run_toolchain(renesas-asm-rx
+      -DCMAKE_SYSTEM_NAME=Generic
+      -DCMAKE_C_COMPILER=${_renesas_toolchain}
+      -DCMAKE_ASM_COMPILER=${_renesas_toolchain}
+      -DCMAKE_C_FLAGS="-isa=rxv2"
+      -DCMAKE_ASM_FLAGS="-isa=rxv2"
+    )
+  elseif(BIN_NAME MATCHES "ccrl.exe")
+# CC-RL
+    run_toolchain(renesas-c
+      -DCMAKE_SYSTEM_NAME=Generic
+      -DCMAKE_C_COMPILER=${_renesas_toolchain}
+      -DCMAKE_C_FLAGS="-cpu=S2"
+      -DCMAKE_EXE_LINKER_FLAGS="-lnkopt=-auto_section_layout"
+    )
+    run_toolchain(renesas-asm-rl
+      -DCMAKE_SYSTEM_NAME=Generic
+      -DCMAKE_C_COMPILER=${_renesas_toolchain}
+      -DCMAKE_ASM_COMPILER=${_renesas_toolchain}
+      -DCMAKE_C_FLAGS="-cpu=S2"
+      -DCMAKE_ASM_FLAGS="-cpu=S2"
+    )
+  elseif(BIN_NAME MATCHES "ccrh.exe")
+# CC-RH
+    run_toolchain(renesas-c
+      -DCMAKE_SYSTEM_NAME=Generic
+      -DCMAKE_C_COMPILER=${_renesas_toolchain}
+      -DCMAKE_C_FLAGS="-Xcommon=rh850"
+      -DCMAKE_EXE_LINKER_FLAGS="-lnkopt=-start=SU,SI,B_1,R_1,C_1"
+    )
+    run_toolchain(renesas-asm-rh
+      -DCMAKE_SYSTEM_NAME=Generic
+      -DCMAKE_C_COMPILER=${_renesas_toolchain}
+      -DCMAKE_ASM_COMPILER=${_renesas_toolchain}
+      -DCMAKE_C_FLAGS="-Xcommon=rh850"
+      -DCMAKE_ASM_FLAGS="-Xcommon=rh850"
+    )
+  endif()
+endforeach()

Tests/RunCMake/Renesas/libmod.c

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

Tests/RunCMake/Renesas/module-rh.asm

@@ -0,0 +1,7 @@
+.public _main
+
+.section .text, text
+_main:
+    .stack _main = 0
+    mov 0x00000000, r10
+    jmp [r31]

Tests/RunCMake/Renesas/module-rl.asm

@@ -0,0 +1,10 @@
+.PUBLIC _main
+
+.SECTION .textf,TEXTF
+.TYPE _main,function,.LFE1-_main
+
+_main:
+        .STACK _main = 4
+        clrw ax
+        ret
+.LFE1:

Tests/RunCMake/Renesas/module-rx.src

@@ -0,0 +1,7 @@
+.SECTION P,CODE
+
+_main:
+    MOV.L #0, R1
+    RTS
+
+.END

Tests/RunCMake/Renesas/module.c

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

Tests/RunCMake/Renesas/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/Renesas/renesas-asm-rh.cmake

@@ -0,0 +1,2 @@
+enable_language(ASM)
+add_executable(exec-asm module-rh.asm)

Tests/RunCMake/Renesas/renesas-asm-rl.cmake

@@ -0,0 +1,2 @@
+enable_language(ASM)
+add_executable(exec-asm module-rl.asm)

Tests/RunCMake/Renesas/renesas-asm-rx.cmake

@@ -0,0 +1,2 @@
+enable_language(ASM)
+add_executable(exec-asm module-rx.src)

Tests/RunCMake/Renesas/renesas-c.cmake

@@ -0,0 +1,2 @@
+enable_language(C)
+add_executable(exec-c module.c)

Tests/RunCMake/Renesas/renesas-lib.cmake

@@ -0,0 +1,7 @@
+enable_language(C)
+add_library(renesas-test-lib libmod.c)
+
+add_executable(exec-lib-c module.c)
+target_compile_options(exec-lib-c)
+target_compile_definitions(exec-lib-c PRIVATE __USE_LIBFUN)
+target_link_libraries(exec-lib-c PRIVATE renesas-test-lib)

Utilities/Sphinx/conf.py.in

@@ -109,6 +109,7 @@ linkcheck_allowed_redirects = {
     r'https://learn\.microsoft\.com/en-us/cpp/build/reference/openmp-enable-openmp-2-0-support': r'https://learn\.microsoft\.com/en-us/cpp/build/reference/openmp-enable-openmp-2-0-support\?.*',
     r'https://learn\.microsoft\.com/en-us/cpp/c-language/parsing-c-command-line-arguments': r'https://learn\.microsoft\.com/en-us/cpp/c-language/parsing-c-command-line-arguments\?.*',
     r'https://openjdk\.java\.net/jeps/313': r'https://openjdk\.org:443/jeps/313',
+    r'https://www\.renesas\.com': r'https://www\.renesas\.com/en',
     r'https://www\.sphinx-doc\.org': r'https://www\.sphinx-doc\.org/en/master/',
 }