Merging changes for the v.6.5.1.202602 release

.github/workflows/regression_test.yml

@@ -41,6 +41,24 @@ jobs:
       cmake_path: ./test/smp/cmake
       result_affix: SMP
       skip_deploy: true
+  # riscv: disabled — re-enable when RISC-V CI is ready
+  # riscv:
+  #   permissions:
+  #     contents: read
+  #     issues: read
+  #     checks: write
+  #     pull-requests: write
+  #     pages: write
+  #     id-token: write
+  #   uses: ./.github/workflows/regression_template.yml
+  #   with:
+  #     install_script: ./scripts/install_riscv.sh
+  #     build_script: ./scripts/build_tx_riscv.sh
+  #     test_script: ./scripts/test_tx_riscv.sh
+  #     cmake_path: ./test/tx/cmake/riscv
+  #     result_affix: RISC-V
+  #     skip_deploy: true
+  #     skip_coverage: true
   deploy:
     permissions:
       contents: read

.gitignore

@@ -4,6 +4,7 @@
 .tmp/
 _deps/
 build/
+build_qemu/
 Debug/
 CMakeFiles/
 CMakeScripts/
@@ -22,3 +23,7 @@ CTestTestfile.cmake
 *.a
 *.htm
 
+
+# Local build artifacts
+build_m7/
+.codex

CMakeLists.txt

@@ -1,16 +1,41 @@
 cmake_minimum_required(VERSION 3.13 FATAL_ERROR)
 
-# Set up the project
-project(threadx
-    LANGUAGES C ASM
-)
+# Declare the project with C only first so that CMake loads the toolchain file,
+# which sets THREADX_ARCH and THREADX_TOOLCHAIN as normal variables.  Checking
+# those variables before project() would always fail because the toolchain is
+# not sourced until the first project() call.
+project(threadx LANGUAGES C)
 
 if(NOT DEFINED THREADX_ARCH)
     message(FATAL_ERROR "Error: THREADX_ARCH not defined")
 endif()
 if(NOT DEFINED THREADX_TOOLCHAIN)
     message(FATAL_ERROR "Error: THREADX_TOOLCHAIN not defined")
 endif()
+
+# The Windows simulation ports do not use assembly.  All other ports require
+# it.  enable_language() is called here rather than in project() above so that
+# the ASM toolchain is only activated when we know the target actually needs it.
+# Note: CMAKE_TRY_COMPILE_TARGET_TYPE is already set to STATIC_LIBRARY by
+# every toolchain file in cmake/, so it does not need to be repeated here.
+if(NOT ((THREADX_ARCH STREQUAL "win32") OR (THREADX_ARCH STREQUAL "win64")))
+    enable_language(ASM)
+endif()
+
+option(THREADX_SMP "Build ThreadX SMP version" OFF)
+
+if(THREADX_SMP)
+    set(TX_PORT_DIR "ports_smp")
+    set(TX_COMMON_DIR "common_smp")
+    set(TX_ARCH_DIR "${THREADX_ARCH}_smp")
+    message(STATUS "Building ThreadX SMP version")
+else()
+    set(TX_PORT_DIR "ports")
+    set(TX_COMMON_DIR "common")
+    set(TX_ARCH_DIR "${THREADX_ARCH}")
+    message(STATUS "Building standard ThreadX version")
+endif()
+
 message(STATUS "THREADX_ARCH: ${THREADX_ARCH}")
 message(STATUS "THREADX_TOOLCHAIN: ${THREADX_TOOLCHAIN}")
 
@@ -25,11 +50,11 @@ set(CUSTOM_INC_DIR ${CMAKE_CURRENT_BINARY_DIR}/custom_inc)
 if(DEFINED THREADX_CUSTOM_PORT)
     add_subdirectory(${THREADX_CUSTOM_PORT} threadx_port)
 else()
-    add_subdirectory(${CMAKE_CURRENT_LIST_DIR}/ports/${THREADX_ARCH}/${THREADX_TOOLCHAIN})
+    add_subdirectory(${CMAKE_CURRENT_LIST_DIR}/${TX_PORT_DIR}/${TX_ARCH_DIR}/${THREADX_TOOLCHAIN})
 endif()
 
 # Pick up the common stuff
-add_subdirectory(${CMAKE_CURRENT_LIST_DIR}/common)
+add_subdirectory(${CMAKE_CURRENT_LIST_DIR}/${TX_COMMON_DIR})
 
 # Define the FreeRTOS adaptation layer
 add_library(freertos-threadx EXCLUDE_FROM_ALL)
@@ -46,7 +71,7 @@ target_link_libraries(freertos-threadx PUBLIC threadx)
 # If the user provided an override, copy it to the custom directory
 if (NOT TX_USER_FILE)
     message(STATUS "Using default tx_user.h file")
-    set(TX_USER_FILE ${CMAKE_CURRENT_LIST_DIR}/common/inc/tx_user_sample.h)
+    set(TX_USER_FILE ${CMAKE_CURRENT_LIST_DIR}/${TX_COMMON_DIR}/inc/tx_user_sample.h)
 else()
     message(STATUS "Using custom tx_user.h file from ${TX_USER_FILE}")
 endif()
@@ -56,6 +81,17 @@ target_include_directories(${PROJECT_NAME}
     ${CUSTOM_INC_DIR}
 )
 target_compile_definitions(${PROJECT_NAME} PUBLIC "TX_INCLUDE_USER_DEFINE_FILE" )
+if(THREADX_SMP)
+    target_compile_definitions(${PROJECT_NAME} PUBLIC "TX_MPCORE" )
+endif()
+
+# Optional: build for S-mode (Supervisor mode) instead of M-mode (Machine mode).
+# Required when running after OpenSBI, e.g. booted from U-Boot.
+option(TX_RISCV_SMODE "Use S-mode CSRs instead of M-mode for RISC-V targets" OFF)
+if(TX_RISCV_SMODE)
+    message(STATUS "RISC-V S-mode enabled (TX_RISCV_SMODE)")
+    target_compile_definitions(${PROJECT_NAME} PUBLIC "TX_RISCV_SMODE")
+endif()
 
 # Enable a build target that produces a ZIP file of all sources
 set(CPACK_SOURCE_GENERATOR "ZIP")
@@ -69,4 +105,4 @@ set(CPACK_SOURCE_IGNORE_FILES
   ".*~$"
 )
 set(CPACK_VERBATIM_VARIABLES YES)
-include(CPack)
+include(CPack)

cmake/cortex_a9.cmake

@@ -0,0 +1,13 @@
+# Name of the target
+set(CMAKE_SYSTEM_NAME Generic)
+set(CMAKE_SYSTEM_PROCESSOR cortex-a9)
+
+set(THREADX_ARCH "cortex_a9")
+set(THREADX_TOOLCHAIN "gnu")
+
+set(MCPU_FLAGS "-marm -mcpu=cortex-a9")
+set(VFP_FLAGS "")
+set(SPEC_FLAGS "--specs=nosys.specs")
+# set(LD_FLAGS "-nostartfiles")
+
+include(${CMAKE_CURRENT_LIST_DIR}/arm-none-eabi.cmake)

cmake/riscv-none-elf-rv32imc.cmake

@@ -0,0 +1,71 @@
+# /***************************************************************************
+#  * Copyright (C) 2026 Eclipse ThreadX contributors
+#  *
+#  * This program and the accompanying materials are made available under the
+#  * terms of the MIT License which is available at
+#  * https://opensource.org/licenses/MIT.
+#  *
+#  * SPDX-License-Identifier: MIT
+#  ***************************************************************************/
+
+# CMake toolchain file for bare-metal RV32IMC targets (e.g. CORE-V MCU / CV32E40P)
+#
+# Uses the xPack riscv-none-elf-gcc toolchain:
+#   https://github.com/xpack-dev-tools/riscv-none-elf-gcc-xpack
+#
+# This is a cross-platform (Linux/macOS/Windows), multilib-capable toolchain
+# analogous to arm-none-eabi-gcc.  Its multilib includes rv32imc/ilp32
+# (soft-float), so -lgcc resolves correctly without any distro package.
+#
+# Install via:  bash ports/risc-v32/gnu/example_build/core_v_mcu/install_deps.sh
+# (downloads the latest xPack release to /opt/xpack-riscv-none-elf-gcc/)
+#
+# Do NOT use riscv32-unknown-elf-gcc (riscv-collab riscv32-elf release) for
+# this target: that toolchain is built --disable-multilib --with-abi=ilp32d,
+# so its libgcc only provides ilp32d (hardware FP) helpers and cannot link
+# rv32imc/ilp32 soft-float objects.
+#
+# Target ISA : rv32imc_zicsr  (integer, multiply, compressed, Zicsr)
+# ABI        : ilp32           (32-bit int/long/ptr, soft-float)
+# Code model : medlow          (addresses in [0, 2 GiB))
+
+set(CMAKE_SYSTEM_NAME Generic)
+set(CMAKE_SYSTEM_PROCESSOR riscv)
+
+set(THREADX_ARCH "risc-v32")
+set(THREADX_TOOLCHAIN "gnu")
+
+set(ARCH_FLAGS "-march=rv32imc_zicsr -mabi=ilp32 -mcmodel=medlow")
+set(CFLAGS   "${ARCH_FLAGS}")
+set(ASFLAGS  "${ARCH_FLAGS}")
+set(LDFLAGS  "${ARCH_FLAGS}")
+
+# xPack riscv-none-elf multilib toolchain.
+set(CMAKE_C_COMPILER    riscv-none-elf-gcc)
+set(CMAKE_CXX_COMPILER  riscv-none-elf-g++)
+set(AS                  riscv-none-elf-as)
+set(AR                  riscv-none-elf-ar)
+set(OBJCOPY             riscv-none-elf-objcopy)
+set(OBJDUMP             riscv-none-elf-objdump)
+set(SIZE                riscv-none-elf-size)
+
+set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)
+
+# Use static library for compiler feature probing (no linker script yet)
+set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)
+
+set(CMAKE_C_FLAGS   "${CFLAGS}"  CACHE INTERNAL "c compiler flags")
+set(CMAKE_CXX_FLAGS "${CFLAGS}"  CACHE INTERNAL "cxx compiler flags")
+set(CMAKE_ASM_FLAGS "${ASFLAGS} -D__ASSEMBLER__" CACHE INTERNAL "asm compiler flags")
+set(CMAKE_EXE_LINKER_FLAGS "${LDFLAGS}" CACHE INTERNAL "exe link flags")
+
+set(CMAKE_C_FLAGS_DEBUG   "-Og -g -ggdb3" CACHE INTERNAL "c debug flags")
+set(CMAKE_CXX_FLAGS_DEBUG "-Og -g -ggdb3" CACHE INTERNAL "cxx debug flags")
+set(CMAKE_ASM_FLAGS_DEBUG "-g -ggdb3"     CACHE INTERNAL "asm debug flags")
+
+set(CMAKE_C_FLAGS_RELEASE   "-Os" CACHE INTERNAL "c release flags")
+set(CMAKE_CXX_FLAGS_RELEASE "-Os" CACHE INTERNAL "cxx release flags")
+set(CMAKE_ASM_FLAGS_RELEASE ""    CACHE INTERNAL "asm release flags")

cmake/riscv32-unknown-elf-rv32imc.cmake

@@ -0,0 +1,93 @@
+# /***************************************************************************
+#  * Copyright (C) 2026 Eclipse ThreadX contributors
+#  *
+#  * This program and the accompanying materials are made available under the
+#  * terms of the MIT License which is available at
+#  * https://opensource.org/licenses/MIT.
+#  *
+#  * SPDX-License-Identifier: MIT
+#  ***************************************************************************/
+
+# CMake toolchain file for RV32GC targets (QEMU virt, etc.)
+#
+# Uses the dedicated riscv32-unknown-elf-gcc bare-metal toolchain from
+# riscv-collab (riscv32-elf-ubuntu-24.04-gcc.tar.xz, installs to /opt/riscv
+# via scripts/install_riscv.sh).
+#
+# IMPORTANT: the riscv-collab riscv32-elf toolchain is built
+# --disable-multilib --with-abi=ilp32d, so its libgcc only provides
+# ilp32d (hardware double-FP) helpers.  This cmake file therefore targets
+# rv32gc/ilp32d, which matches the toolchain's built-in ABI and works
+# correctly with QEMU virt (which emulates hardware FP).
+#
+# Do NOT use this file for bare-metal targets that lack hardware FP (e.g.
+# CV32E40P, rv32imc).  For those, use cmake/riscv64-ubuntu-rv32imc.cmake
+# which calls the Ubuntu gcc-riscv64-unknown-elf package — a multilib build
+# that includes the rv32im/ilp32 (soft-float) libgcc variant.
+#
+# Target ISA : rv32gc  (integer, multiply, atomics, FP, compressed, Zicsr)
+# ABI        : ilp32d  (32-bit int/long/ptr, hardware double-precision FP)
+# Code model : medlow  (addresses in [0, 2 GiB))
+
+set(CMAKE_SYSTEM_NAME Generic)
+set(CMAKE_SYSTEM_PROCESSOR riscv)
+
+set(THREADX_ARCH "risc-v32")
+set(THREADX_TOOLCHAIN "gnu")
+
+set(ARCH_FLAGS "-march=rv32gc -mabi=ilp32d -mcmodel=medlow")
+set(CFLAGS   "${ARCH_FLAGS}")
+set(ASFLAGS  "${ARCH_FLAGS}")
+set(LDFLAGS  "${ARCH_FLAGS}")
+
+# Dedicated riscv32 bare-metal toolchain (riscv-collab riscv32-elf release).
+set(CMAKE_C_COMPILER    riscv32-unknown-elf-gcc)
+set(CMAKE_CXX_COMPILER  riscv32-unknown-elf-g++)
+set(AS                  riscv32-unknown-elf-as)
+set(AR                  riscv32-unknown-elf-ar)
+set(OBJCOPY             riscv32-unknown-elf-objcopy)
+set(OBJDUMP             riscv32-unknown-elf-objdump)
+set(SIZE                riscv32-unknown-elf-size)
+
+set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)
+
+# Use static library for compiler feature probing (no linker script yet)
+set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)
+
+set(CMAKE_C_FLAGS   "${CFLAGS}"  CACHE INTERNAL "c compiler flags")
+set(CMAKE_CXX_FLAGS "${CFLAGS}"  CACHE INTERNAL "cxx compiler flags")
+set(CMAKE_ASM_FLAGS "${ASFLAGS} -D__ASSEMBLER__" CACHE INTERNAL "asm compiler flags")
+set(CMAKE_EXE_LINKER_FLAGS "${LDFLAGS}" CACHE INTERNAL "exe link flags")
+
+set(CMAKE_C_FLAGS_DEBUG   "-Og -g -ggdb3" CACHE INTERNAL "c debug flags")
+set(CMAKE_CXX_FLAGS_DEBUG "-Og -g -ggdb3" CACHE INTERNAL "cxx debug flags")
+set(CMAKE_ASM_FLAGS_DEBUG "-g -ggdb3"     CACHE INTERNAL "asm debug flags")
+
+set(CMAKE_C_FLAGS_RELEASE   "-Os" CACHE INTERNAL "c release flags")
+set(CMAKE_CXX_FLAGS_RELEASE "-Os" CACHE INTERNAL "cxx release flags")
+set(CMAKE_ASM_FLAGS_RELEASE ""    CACHE INTERNAL "asm release flags")
+
+
+set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)
+
+# Use static library for compiler feature probing (no linker script yet)
+set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)
+
+set(CMAKE_C_FLAGS   "${CFLAGS}"  CACHE INTERNAL "c compiler flags")
+set(CMAKE_CXX_FLAGS "${CFLAGS}"  CACHE INTERNAL "cxx compiler flags")
+set(CMAKE_ASM_FLAGS "${ASFLAGS} -D__ASSEMBLER__" CACHE INTERNAL "asm compiler flags")
+set(CMAKE_EXE_LINKER_FLAGS "${LDFLAGS}" CACHE INTERNAL "exe link flags")
+
+set(CMAKE_C_FLAGS_DEBUG   "-Og -g -ggdb3" CACHE INTERNAL "c debug flags")
+set(CMAKE_CXX_FLAGS_DEBUG "-Og -g -ggdb3" CACHE INTERNAL "cxx debug flags")
+set(CMAKE_ASM_FLAGS_DEBUG "-g -ggdb3"     CACHE INTERNAL "asm debug flags")
+
+set(CMAKE_C_FLAGS_RELEASE   "-Os" CACHE INTERNAL "c release flags")
+set(CMAKE_CXX_FLAGS_RELEASE "-Os" CACHE INTERNAL "cxx release flags")
+set(CMAKE_ASM_FLAGS_RELEASE ""    CACHE INTERNAL "asm release flags")

cmake/riscv32-unknown-elf.cmake

@@ -17,7 +17,12 @@ set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)
 
 set(CMAKE_C_FLAGS   "${CFLAGS}" CACHE INTERNAL "c compiler flags")
 set(CMAKE_CXX_FLAGS "${CXXFLAGS}" CACHE INTERNAL "cxx compiler flags")
-set(CMAKE_ASM_FLAGS "${ASFLAGS} -D__ASSEMBLER__ -D__riscv_float_abi_single" CACHE INTERNAL "asm compiler flags")
+if(DEFINED SOFT_FLOAT)
+    set(CMAKE_ASM_FLAGS "${ASFLAGS} -D__ASSEMBLER__" CACHE INTERNAL "asm compiler flags")
+else()
+    set(CMAKE_ASM_FLAGS "${ASFLAGS} -D__ASSEMBLER__ -D__riscv_float_abi_single" CACHE INTERNAL "asm compiler flags")
+endif()
+
 set(CMAKE_EXE_LINKER_FLAGS "${LDFLAGS}" CACHE INTERNAL "exe link flags")
 
 SET(CMAKE_C_FLAGS_DEBUG "-Og -g -ggdb3" CACHE INTERNAL "c debug compiler flags")

cmake/riscv32_gnu.cmake

@@ -1,10 +1,14 @@
 # Name of the target
 set(CMAKE_SYSTEM_NAME Generic)
 set(CMAKE_SYSTEM_PROCESSOR risc-v32)
-
 set(THREADX_ARCH "risc-v32")
 set(THREADX_TOOLCHAIN "gnu")
-set(ARCH_FLAGS "-g -march=rv32gc -mabi=ilp32d -mcmodel=medany")
+if(DEFINED SOFT_FLOAT)
+    set(ARCH_FLAGS "-g -march=rv32ima_zicsr -mabi=ilp32 -mcmodel=medany")
+    set(CACHE{SOFT_FLOAT} FORCE 1)
+else()
+    set(ARCH_FLAGS "-g -march=rv32gc -mabi=ilp32d -mcmodel=medany -mrelax")
+endif()
 set(CFLAGS "${ARCH_FLAGS}")
 set(ASFLAGS "${ARCH_FLAGS}")
 set(LDFLAGS "${ARCH_FLAGS}")

cmake/riscv64-gcc-rv32imc.cmake

@@ -0,0 +1,2 @@
+# This file is a compatibility alias.  Use riscv-none-elf-rv32imc.cmake.
+include(${CMAKE_CURRENT_LIST_DIR}/riscv-none-elf-rv32imc.cmake)

cmake/threadx_riscv_port.cmake

@@ -0,0 +1,50 @@
+# threadx_riscv_port.cmake
+#
+# Helper function shared by the three RISC-V port CMakeLists files
+# (risc-v32/gnu, risc-v32/clang, risc-v64/gnu).
+#
+# Usage:
+#   include(cmake/threadx_riscv_port.cmake)
+#   threadx_add_riscv_port(SRC_DIR <path-to-src>
+#                          INC_DIR <path-to-inc>
+#                          [EXAMPLE_DIR <path-to-example-build>])
+#
+# SRC_DIR   — directory containing the 8 ThreadX .S port files.
+# INC_DIR   — directory containing tx_port.h (added as PUBLIC include).
+# EXAMPLE_DIR — optional: if provided and contains a CMakeLists.txt,
+#               add_subdirectory() is called on it.
+
+function(threadx_add_riscv_port)
+    cmake_parse_arguments(RISCV "" "SRC_DIR;INC_DIR;EXAMPLE_DIR" "" ${ARGN})
+
+    if(NOT RISCV_SRC_DIR)
+        message(FATAL_ERROR "threadx_add_riscv_port: SRC_DIR is required")
+    endif()
+    if(NOT RISCV_INC_DIR)
+        message(FATAL_ERROR "threadx_add_riscv_port: INC_DIR is required")
+    endif()
+
+    target_sources(${PROJECT_NAME}
+        PRIVATE
+        # {{BEGIN_TARGET_SOURCES}}
+        ${RISCV_SRC_DIR}/tx_initialize_low_level.S
+        ${RISCV_SRC_DIR}/tx_thread_context_restore.S
+        ${RISCV_SRC_DIR}/tx_thread_context_save.S
+        ${RISCV_SRC_DIR}/tx_thread_interrupt_control.S
+        ${RISCV_SRC_DIR}/tx_thread_schedule.S
+        ${RISCV_SRC_DIR}/tx_thread_stack_build.S
+        ${RISCV_SRC_DIR}/tx_thread_system_return.S
+        ${RISCV_SRC_DIR}/tx_timer_interrupt.S
+        # {{END_TARGET_SOURCES}}
+    )
+
+    target_include_directories(${PROJECT_NAME}
+        PUBLIC
+        ${RISCV_INC_DIR}
+    )
+
+    if(RISCV_EXAMPLE_DIR AND
+       EXISTS ${RISCV_EXAMPLE_DIR}/CMakeLists.txt)
+        add_subdirectory(${RISCV_EXAMPLE_DIR})
+    endif()
+endfunction()