chore: import upstream snapshot with attribution

platforms/linux/aarch64-gnu.toolchain.cmake

@@ -0,0 +1,4 @@
+set(CMAKE_SYSTEM_PROCESSOR aarch64)
+set(GCC_COMPILER_VERSION "" CACHE STRING "GCC Compiler version")
+set(GNU_MACHINE "aarch64-linux-gnu" CACHE STRING "GNU compiler triple")
+include("${CMAKE_CURRENT_LIST_DIR}/arm.toolchain.cmake")

platforms/linux/arm-gnueabi.toolchain.cmake

@@ -0,0 +1,3 @@
+set(GCC_COMPILER_VERSION "" CACHE STRING "GCC Compiler version")
+set(GNU_MACHINE "arm-linux-gnueabi" CACHE STRING "GNU compiler triple")
+include("${CMAKE_CURRENT_LIST_DIR}/arm.toolchain.cmake")

platforms/linux/arm.toolchain.cmake

@@ -0,0 +1,88 @@
+if(COMMAND toolchain_save_config)
+  return() # prevent recursive call
+endif()
+
+set(CMAKE_SYSTEM_NAME Linux)
+set(CMAKE_SYSTEM_VERSION 1)
+if(NOT DEFINED CMAKE_SYSTEM_PROCESSOR)
+  set(CMAKE_SYSTEM_PROCESSOR arm)
+else()
+  #message("CMAKE_SYSTEM_PROCESSOR=${CMAKE_SYSTEM_PROCESSOR}")
+endif()
+
+include("${CMAKE_CURRENT_LIST_DIR}/gnu.toolchain.cmake")
+
+if(CMAKE_SYSTEM_PROCESSOR STREQUAL arm AND NOT ARM_IGNORE_FP)
+  set(FLOAT_ABI_SUFFIX "")
+  if(NOT SOFTFP)
+    set(FLOAT_ABI_SUFFIX "hf")
+  endif()
+endif()
+
+if(NOT "x${GCC_COMPILER_VERSION}" STREQUAL "x")
+  set(__GCC_VER_SUFFIX "-${GCC_COMPILER_VERSION}")
+endif()
+
+if(NOT DEFINED CMAKE_C_COMPILER)
+  find_program(CMAKE_C_COMPILER NAMES ${GNU_MACHINE}${FLOAT_ABI_SUFFIX}-gcc${__GCC_VER_SUFFIX})
+else()
+  #message(WARNING "CMAKE_C_COMPILER=${CMAKE_C_COMPILER} is defined")
+endif()
+if(NOT DEFINED CMAKE_CXX_COMPILER)
+  find_program(CMAKE_CXX_COMPILER NAMES ${GNU_MACHINE}${FLOAT_ABI_SUFFIX}-g++${__GCC_VER_SUFFIX})
+else()
+  #message(WARNING "CMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER} is defined")
+endif()
+if(NOT DEFINED CMAKE_LINKER)
+  find_program(CMAKE_LINKER NAMES ${GNU_MACHINE}${FLOAT_ABI_SUFFIX}-ld${__GCC_VER_SUFFIX} ${GNU_MACHINE}${FLOAT_ABI_SUFFIX}-ld)
+else()
+  #message(WARNING "CMAKE_LINKER=${CMAKE_LINKER} is defined")
+endif()
+if(NOT DEFINED CMAKE_AR)
+  find_program(CMAKE_AR NAMES ${GNU_MACHINE}${FLOAT_ABI_SUFFIX}-ar${__GCC_VER_SUFFIX} ${GNU_MACHINE}${FLOAT_ABI_SUFFIX}-ar)
+else()
+  #message(WARNING "CMAKE_AR=${CMAKE_AR} is defined")
+endif()
+
+if(NOT DEFINED ARM_LINUX_SYSROOT AND DEFINED GNU_MACHINE)
+  set(ARM_LINUX_SYSROOT /usr/${GNU_MACHINE}${FLOAT_ABI_SUFFIX})
+endif()
+
+# == Compiler flags
+if(CMAKE_SYSTEM_PROCESSOR STREQUAL arm)
+  set(CMAKE_CXX_FLAGS_INIT "-mthumb")
+  set(CMAKE_C_FLAGS_INIT   "-mthumb")
+  set(common_ld_opt "-Wl,--fix-cortex-a8")
+  set(CMAKE_SHARED_LINKER_FLAGS_INIT "${common_ld_opt}")
+  set(CMAKE_MODULE_LINKER_FLAGS_INIT "${common_ld_opt}")
+  set(CMAKE_EXE_LINKER_FLAGS_INIT    "${common_ld_opt} -Wl,-z,nocopyreloc")
+elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL "aarch64")
+  include("${CMAKE_CURRENT_LIST_DIR}/flags-aarch64.cmake")
+  if(COMMAND ocv_set_platform_flags)
+    ocv_set_platform_flags(CMAKE_CXX_FLAGS_INIT)
+    ocv_set_platform_flags(CMAKE_C_FLAGS_INIT)
+  endif()
+endif()
+
+
+if(USE_NEON)
+  message(WARNING "You use obsolete variable USE_NEON to enable NEON instruction set. Use -DENABLE_NEON=ON instead." )
+  set(ENABLE_NEON TRUE)
+elseif(USE_VFPV3)
+  message(WARNING "You use obsolete variable USE_VFPV3 to enable VFPV3 instruction set. Use -DENABLE_VFPV3=ON instead." )
+  set(ENABLE_VFPV3 TRUE)
+endif()
+
+set(CMAKE_FIND_ROOT_PATH ${CMAKE_FIND_ROOT_PATH} ${ARM_LINUX_SYSROOT})
+
+if(EXISTS ${CUDA_TOOLKIT_ROOT_DIR})
+  set(CMAKE_FIND_ROOT_PATH ${CMAKE_FIND_ROOT_PATH} ${CUDA_TOOLKIT_ROOT_DIR})
+endif()
+
+set(TOOLCHAIN_CONFIG_VARS ${TOOLCHAIN_CONFIG_VARS}
+    ARM_LINUX_SYSROOT
+    ENABLE_NEON
+    ENABLE_VFPV3
+    CUDA_TOOLKIT_ROOT_DIR
+)
+toolchain_save_config()

platforms/linux/flags-aarch64.cmake

@@ -0,0 +1,22 @@
+# see https://gcc.gnu.org/onlinedocs/gcc/AArch64-Options.html#index-march
+function(ocv_set_platform_flags VAR)
+  unset(flags)
+  if(ENABLE_SVE)
+   set(flags "${flags}+sve")
+  endif()
+  if(ENABLE_BF16)
+    set(flags "${flags}+bf16")
+  endif()
+  if(ENABLE_DOTPROD)
+    set(flags "${flags}+dotprod")
+  endif()
+  if(ENABLE_FP16)
+    set(flags "${flags}+fp16")
+  endif()
+  if(DEFINED ENABLE_NEON AND NOT ENABLE_NEON)
+    set(flags "${flags}+nosimd")
+  endif()
+  if(flags)
+    set(${VAR} "-march=armv8.2-a${flags}" PARENT_SCOPE)
+  endif()
+endfunction()

platforms/linux/flags-riscv64.cmake

@@ -0,0 +1,9 @@
+# see https://gcc.gnu.org/onlinedocs/gcc/RISC-V-Options.html#index-march-14
+function(ocv_set_platform_flags VAR)
+  if(ENABLE_RVV OR RISCV_RVV_SCALABLE)
+    set(flags "-march=rv64gcv")
+  else()
+    set(flags "-march=rv64gc")
+  endif()
+  set(${VAR} "${flags}" PARENT_SCOPE)
+endfunction()

platforms/linux/gnu.toolchain.cmake

@@ -0,0 +1,134 @@
+cmake_minimum_required(VERSION 3.5)
+
+# load settings in case of "try compile"
+set(TOOLCHAIN_CONFIG_FILE "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/toolchain.config.cmake")
+get_property(__IN_TRY_COMPILE GLOBAL PROPERTY IN_TRY_COMPILE)
+if(__IN_TRY_COMPILE)
+  include("${CMAKE_CURRENT_SOURCE_DIR}/../toolchain.config.cmake" OPTIONAL) # CMAKE_BINARY_DIR is different
+  macro(toolchain_save_config)
+    # nothing
+  endmacro()
+else()
+  macro(toolchain_save_config)
+    set(__config "#message(\"Load TOOLCHAIN config...\")\n")
+    get_cmake_property(__variableNames VARIABLES)
+    set(__vars_list ${ARGN})
+    list(APPEND __vars_list
+        ${TOOLCHAIN_CONFIG_VARS}
+        CMAKE_SYSTEM_NAME
+        CMAKE_SYSTEM_VERSION
+        CMAKE_SYSTEM_PROCESSOR
+        CMAKE_C_COMPILER
+        CMAKE_CXX_COMPILER
+        CMAKE_C_FLAGS
+        CMAKE_CXX_FLAGS
+        CMAKE_SHARED_LINKER_FLAGS
+        CMAKE_MODULE_LINKER_FLAGS
+        CMAKE_EXE_LINKER_FLAGS
+        CMAKE_SKIP_RPATH
+        CMAKE_FIND_ROOT_PATH
+        GCC_COMPILER_VERSION
+    )
+    foreach(__var ${__variableNames})
+      foreach(_v ${__vars_list})
+        if("x${__var}" STREQUAL "x${_v}")
+          if(${__var} MATCHES " ")
+            set(__config "${__config}set(${__var} \"${${__var}}\")\n")
+          else()
+            set(__config "${__config}set(${__var} ${${__var}})\n")
+          endif()
+        endif()
+      endforeach()
+    endforeach()
+    if(EXISTS "${TOOLCHAIN_CONFIG_FILE}")
+      file(READ "${TOOLCHAIN_CONFIG_FILE}" __config_old)
+    endif()
+    if("${__config_old}" STREQUAL "${__config}")
+      # nothing
+    else()
+      #message("Update TOOLCHAIN config: ${__config}")
+      file(WRITE "${TOOLCHAIN_CONFIG_FILE}" "${__config}")
+    endif()
+    unset(__config)
+    unset(__config_old)
+    unset(__vars_list)
+    unset(__variableNames)
+  endmacro()
+endif() # IN_TRY_COMPILE
+
+if(NOT CMAKE_FIND_ROOT_PATH_MODE_LIBRARY)
+  set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
+endif()
+
+if(NOT CMAKE_FIND_ROOT_PATH_MODE_INCLUDE)
+  set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
+endif()
+
+if(NOT CMAKE_FIND_ROOT_PATH_MODE_PACKAGE)
+  set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY)
+endif()
+
+if(NOT CMAKE_FIND_ROOT_PATH_MODE_PROGRAM)
+  set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
+endif()
+
+macro(__cmake_find_root_save_and_reset)
+  foreach(v
+      CMAKE_FIND_ROOT_PATH_MODE_LIBRARY
+      CMAKE_FIND_ROOT_PATH_MODE_INCLUDE
+      CMAKE_FIND_ROOT_PATH_MODE_PACKAGE
+      CMAKE_FIND_ROOT_PATH_MODE_PROGRAM
+  )
+    set(__save_${v} ${${v}})
+    set(${v} NEVER)
+  endforeach()
+endmacro()
+
+macro(__cmake_find_root_restore)
+  foreach(v
+      CMAKE_FIND_ROOT_PATH_MODE_LIBRARY
+      CMAKE_FIND_ROOT_PATH_MODE_INCLUDE
+      CMAKE_FIND_ROOT_PATH_MODE_PACKAGE
+      CMAKE_FIND_ROOT_PATH_MODE_PROGRAM
+  )
+    set(${v} ${__save_${v}})
+    unset(__save_${v})
+  endforeach()
+endmacro()
+
+
+# macro to find programs on the host OS
+macro(find_host_program)
+ __cmake_find_root_save_and_reset()
+ if(CMAKE_HOST_WIN32)
+  SET(WIN32 1)
+  SET(UNIX)
+ elseif(CMAKE_HOST_APPLE)
+  SET(APPLE 1)
+  SET(UNIX)
+ endif()
+ find_program(${ARGN})
+ SET(WIN32)
+ SET(APPLE)
+ SET(UNIX 1)
+ __cmake_find_root_restore()
+endmacro()
+
+# macro to find packages on the host OS
+macro(find_host_package)
+ __cmake_find_root_save_and_reset()
+ if(CMAKE_HOST_WIN32)
+  SET(WIN32 1)
+  SET(UNIX)
+ elseif(CMAKE_HOST_APPLE)
+  SET(APPLE 1)
+  SET(UNIX)
+ endif()
+ find_package(${ARGN})
+ SET(WIN32)
+ SET(APPLE)
+ SET(UNIX 1)
+ __cmake_find_root_restore()
+endmacro()
+
+set(CMAKE_SKIP_RPATH TRUE CACHE BOOL "If set, runtime paths are not added when using shared libraries.")

platforms/linux/mips.toolchain.cmake

@@ -0,0 +1,80 @@
+# ----------------------------------------------------------------------------------------------
+#  MIPS ToolChanin can be downloaded from https://www.mips.com/develop/tools/codescape-mips-sdk/ .
+#  Toolchains with 'mti' in the name (and install directory) are for MIPS R2-R5 instruction sets.
+#  Toolchains with 'img' in the name are for MIPS R6 instruction sets.
+#  It is recommended to use cmake-gui application for build scripts configuration and generation:
+#  1. Run cmake-gui
+#  2. Specify toolchain file for cross-compiling, mips32r5el-gnu.toolchian.cmake or mips64r6el-gnu.toolchain.cmake
+#     can be selected.
+#  3. Configure and Generate makefiles.
+#  4. make -j4 & make install
+# ----------------------------------------------------------------------------------------------
+
+if(COMMAND toolchain_save_config)
+  return() # prevent recursive call
+endif()
+
+set(CMAKE_SYSTEM_NAME Linux)
+set(CMAKE_SYSTEM_VERSION 1)
+if(NOT DEFINED CMAKE_SYSTEM_PROCESSOR)
+  set(CMAKE_SYSTEM_PROCESSOR mips)
+endif()
+
+include("${CMAKE_CURRENT_LIST_DIR}/gnu.toolchain.cmake")
+
+if(CMAKE_SYSTEM_PROCESSOR STREQUAL mips AND NOT MIPS_IGNORE_FP)
+  set(FLOAT_ABI_SUFFIX "")
+endif()
+
+if(NOT "x${GCC_COMPILER_VERSION}" STREQUAL "x")
+  set(__GCC_VER_SUFFIX "-${GCC_COMPILER_VERSION}")
+endif()
+
+if(NOT DEFINED CMAKE_C_COMPILER)
+  find_program(CMAKE_C_COMPILER NAMES ${GNU_MACHINE}${FLOAT_ABI_SUFFIX}-gcc${__GCC_VER_SUFFIX})
+endif()
+if(NOT DEFINED CMAKE_CXX_COMPILER)
+  find_program(CMAKE_CXX_COMPILER NAMES ${GNU_MACHINE}${FLOAT_ABI_SUFFIX}-g++${__GCC_VER_SUFFIX})
+endif()
+if(NOT DEFINED CMAKE_LINKER)
+  find_program(CMAKE_LINKER NAMES ${GNU_MACHINE}${FLOAT_ABI_SUFFIX}-ld${__GCC_VER_SUFFIX} ${GNU_MACHINE}${FLOAT_ABI_SUFFIX}-ld)
+endif()
+if(NOT DEFINED CMAKE_AR)
+  find_program(CMAKE_AR NAMES ${GNU_MACHINE}${FLOAT_ABI_SUFFIX}-ar${__GCC_VER_SUFFIX} ${GNU_MACHINE}${FLOAT_ABI_SUFFIX}-ar)
+endif()
+
+if(NOT DEFINED MIPS_LINUX_SYSROOT AND DEFINED GNU_MACHINE)
+  set(MIPS_LINUX_SYSROOT /usr/bin)
+endif()
+
+if(NOT DEFINED CMAKE_CXX_FLAGS)
+  if(CMAKE_SYSTEM_PROCESSOR MATCHES "mips32r5el")
+    set(CMAKE_C_FLAGS             "-march=mips32r5 -EL -mmsa -mhard-float -mfp64 -mnan=2008 -mabs=2008 -O3 -ffp-contract=off -mtune=p5600" CACHE INTERNAL "")
+    set(CMAKE_SHARED_LINKER_FLAGS "" CACHE INTERNAL "")
+    set(CMAKE_CXX_FLAGS           "-march=mips32r5 -EL -mmsa -mhard-float -mfp64 -mnan=2008 -mabs=2008 -O3 -ffp-contract=off -mtune=p5600" CACHE INTERNAL "")
+    set(CMAKE_MODULE_LINKER_FLAGS "" CACHE INTERNAL "")
+    set(CMAKE_EXE_LINKER_FLAGS    "-lpthread -lrt -ldl -latomic" CACHE INTERNAL "Added for mips cross build error")
+
+    set(CMAKE_CXX_FLAGS           "${CMAKE_CXX_FLAGS} -fdata-sections  -Wa,--noexecstack -fsigned-char -Wno-psabi")
+    set(CMAKE_C_FLAGS             "${CMAKE_C_FLAGS} -fdata-sections  -Wa,--noexecstack -fsigned-char -Wno-psabi")
+  elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "mips64r6el")
+    set(CMAKE_C_FLAGS             "-O3 -march=i6500 -EL -mmsa -mabi=64 -mhard-float -mfp64 -mnan=2008" CACHE INTERNAL "")
+    set(CMAKE_SHARED_LINKER_FLAGS "" CACHE INTERNAL "")
+    set(CMAKE_CXX_FLAGS           "-O3 -march=i6500 -EL -mmsa -mabi=64 -mhard-float -mfp64 -mnan=2008" CACHE INTERNAL "")
+    set(CMAKE_MODULE_LINKER_FLAGS "" CACHE INTERNAL "")
+    set(CMAKE_EXE_LINKER_FLAGS    "-lpthread -lrt -ldl" CACHE INTERNAL "Added for mips cross build error")
+
+    set(CMAKE_CXX_FLAGS           "${CMAKE_CXX_FLAGS} -fdata-sections -Wa,--noexecstack -fsigned-char -Wno-psabi")
+    set(CMAKE_C_FLAGS             "${CMAKE_C_FLAGS} -fdata-sections -Wa,--noexecstack -fsigned-char -Wno-psabi")
+  endif()
+  set(CMAKE_SHARED_LINKER_FLAGS "${MIPS_LINKER_FLAGS} ${CMAKE_SHARED_LINKER_FLAGS}")
+  set(CMAKE_MODULE_LINKER_FLAGS "${MIPS_LINKER_FLAGS} ${CMAKE_MODULE_LINKER_FLAGS}")
+  set(CMAKE_EXE_LINKER_FLAGS    "${MIPS_LINKER_FLAGS} ${CMAKE_EXE_LINKER_FLAGS}")
+endif()
+
+set(CMAKE_FIND_ROOT_PATH ${CMAKE_FIND_ROOT_PATH} ${MIPS_LINUX_SYSROOT})
+
+set(TOOLCHAIN_CONFIG_VARS ${TOOLCHAIN_CONFIG_VARS}
+    MIPS_LINUX_SYSROOT
+)
+toolchain_save_config()

platforms/linux/mips32r5el-gnu.toolchain.cmake

@@ -0,0 +1,14 @@
+# ----------------------------------------------------------------------------------------------
+#  MIPS ToolChanin can be downloaded from https://www.mips.com/develop/tools/codescape-mips-sdk/ .
+#  Toolchains with 'mti' in the name (and install directory) are for MIPS R2-R5 instruction sets.
+#  Toolchains with 'img' in the name are for MIPS R6 instruction sets.
+#  It is recommended to use cmake-gui for build scripts configuration and generation:
+#  1. Run cmake-gui
+#  2. Specify toolchain file mips32r5el-gnu.toolchian.cmake for cross-compiling.
+#  3. Configure and Generate makefiles.
+#  4. make -j4 & make install
+# ----------------------------------------------------------------------------------------------
+set(CMAKE_SYSTEM_PROCESSOR mips32r5el)
+set(GCC_COMPILER_VERSION "" CACHE STRING "GCC Compiler version")
+set(GNU_MACHINE "mips-mti-linux-gnu" CACHE STRING "GNU compiler triple")
+include("${CMAKE_CURRENT_LIST_DIR}/mips.toolchain.cmake")

platforms/linux/mips64r6el-gnu.toolchain.cmake

@@ -0,0 +1,14 @@
+# ----------------------------------------------------------------------------------------------
+#  MIPS ToolChanin can be downloaded from https://www.mips.com/develop/tools/codescape-mips-sdk/ .
+#  Toolchains with 'mti' in the name (and install directory) are for MIPS R2-R5 instruction sets.
+#  Toolchains with 'img' in the name are for MIPS R6 instruction sets.
+#  It is recommended to use cmake-gui for build scripts configuration and generation:
+#  1. Run cmake-gui
+#  2. Specify toolchain file mips64r6el-gnu.toolchain.cmake for cross-compiling.
+#  3. Configure and Generate makefiles.
+#  4. make -j4 & make install
+# ----------------------------------------------------------------------------------------------
+set(CMAKE_SYSTEM_PROCESSOR mips64r6el)
+set(GCC_COMPILER_VERSION "" CACHE STRING "GCC Compiler version")
+set(GNU_MACHINE "mips-img-linux-gnu" CACHE STRING "GNU compiler triple")
+include("${CMAKE_CURRENT_LIST_DIR}/mips.toolchain.cmake")

platforms/linux/ppc64-gnu.toolchain.cmake

@@ -0,0 +1,3 @@
+set(CMAKE_SYSTEM_PROCESSOR ppc64)
+set(GNU_MACHINE "powerpc64-linux-gnu" CACHE STRING "GNU compiler triple")
+include("${CMAKE_CURRENT_LIST_DIR}/ppcat.toolchain.cmake")

platforms/linux/ppc64le-gnu.toolchain.cmake

@@ -0,0 +1,3 @@
+set(CMAKE_SYSTEM_PROCESSOR ppc64le)
+set(GNU_MACHINE "powerpc64le-linux-gnu" CACHE STRING "GNU compiler triple")
+include("${CMAKE_CURRENT_LIST_DIR}/ppcat.toolchain.cmake")

platforms/linux/ppcat.toolchain.cmake

@@ -0,0 +1,129 @@
+if(COMMAND toolchain_save_config)
+  return() # prevent recursive call
+endif()
+
+option(AT_PATH        "Advance Toolchain directory" "")
+option(AT_RPATH       "Add new directories to runtime search path" "")
+option(AT_HOST_LINK   "Enable/disable Link against host advance toolchain runtime" OFF)
+option(AT_NO_AUTOVEC  "Disable/enable Auto Vectorizer optimization" OFF)
+
+set(CMAKE_SYSTEM_NAME Linux)
+set(CMAKE_SYSTEM_VERSION 1)
+
+include("${CMAKE_CURRENT_LIST_DIR}/gnu.toolchain.cmake")
+
+if(NOT DEFINED CMAKE_C_COMPILER)
+  string(REGEX REPLACE "/+$" "" AT_PATH "${AT_PATH}")
+
+  if(NOT AT_PATH)
+    message(FATAL_ERROR "'AT_PATH' option is required. Please set it to Advance Toolchain path to get toolchain works")
+  endif()
+
+  if(NOT EXISTS ${AT_PATH})
+    message(FATAL_ERROR "'${AT_PATH}' Advance Toolchain path isn't exist")
+  endif()
+
+  set(CMAKE_C_COMPILER "${AT_PATH}/bin/${GNU_MACHINE}-gcc")
+
+  if(NOT EXISTS ${CMAKE_C_COMPILER})
+    message(FATAL_ERROR "GNU C compiler isn't exist on path '${CMAKE_C_COMPILER}'. Please install Advance Toolchain with ${CMAKE_SYSTEM_PROCESSOR} supports")
+  endif()
+endif()
+
+if(NOT DEFINED CMAKE_CXX_COMPILER)
+  set(CMAKE_CXX_COMPILER "${AT_PATH}/bin/${GNU_MACHINE}-g++")
+
+  if(NOT EXISTS ${CMAKE_CXX_COMPILER})
+    message(FATAL_ERROR "GNU C++ compiler isn't exist. Invalid install of Advance Toolchain")
+  endif()
+endif()
+
+if(NOT DEFINED AT_GCCROOT_PATH)
+  set(AT_GCCROOT_PATH "${AT_PATH}/${GNU_MACHINE}")
+
+  if(NOT EXISTS ${AT_GCCROOT_PATH})
+    message(FATAL_ERROR "GCC root path '${AT_GCCROOT_PATH}' isn't exist. Invalid install of Advance Toolchain")
+  endif()
+endif()
+
+if(NOT DEFINED AT_SYSROOT_PATH)
+  if(${CMAKE_SYSTEM_PROCESSOR} STREQUAL "ppc64")
+    set(AT_SYSROOT_PATH "${AT_PATH}/ppc")
+  else()
+    set(AT_SYSROOT_PATH "${AT_PATH}/${CMAKE_SYSTEM_PROCESSOR}")
+  endif()
+
+  if(NOT EXISTS ${AT_SYSROOT_PATH})
+    message(FATAL_ERROR "System root path '${AT_SYSROOT_PATH}' isn't exist. Invalid install of Advance Toolchain")
+  endif()
+endif()
+
+if(NOT DEFINED CMAKE_EXE_LINKER_FLAGS)
+  set(CMAKE_CXX_FLAGS           "" CACHE INTERNAL "")
+  set(CMAKE_C_FLAGS             "" CACHE INTERNAL "")
+  set(CMAKE_EXE_LINKER_FLAGS    "" CACHE INTERNAL "")
+  set(CMAKE_SHARED_LINKER_FLAGS "" CACHE INTERNAL "")
+  set(CMAKE_MODULE_LINKER_FLAGS "" CACHE INTERNAL "")
+
+  if(AT_RPATH)
+    string(REPLACE "," ";" RPATH_LIST ${AT_RPATH})
+  endif()
+
+  if(AT_HOST_LINK)
+    #get 64-bit dynamic linker path
+    file(STRINGS "${AT_SYSROOT_PATH}/usr/bin/ldd" RTLDLIST LIMIT_COUNT 1 REGEX "^RTLDLIST=[\"*\"]")
+    string(REGEX REPLACE "RTLDLIST=|\"" "" RTLDLIST "${RTLDLIST}")
+    string(REPLACE " " ";" RTLDLIST "${RTLDLIST}")
+
+    #RTLDLIST must contains 32 and 64 bit paths
+    list(LENGTH RTLDLIST RTLDLIST_LEN)
+    if(NOT RTLDLIST_LEN GREATER 1)
+      message(FATAL_ERROR "Could not fetch dynamic linker path. Invalid install of Advance Toolchain")
+    endif()
+
+    list (GET RTLDLIST 1 LINKER_PATH)
+    set(CMAKE_EXE_LINKER_FLAGS "-Wl,--dynamic-linker=${AT_SYSROOT_PATH}${LINKER_PATH}")
+
+    list(APPEND RPATH_LIST "${AT_GCCROOT_PATH}/lib64/")
+    list(APPEND RPATH_LIST "${AT_SYSROOT_PATH}/lib64/")
+    list(APPEND RPATH_LIST "${AT_SYSROOT_PATH}/usr/lib64/")
+    list(APPEND RPATH_LIST "${PROJECT_BINARY_DIR}/lib/")
+  endif()
+
+  list(LENGTH RPATH_LIST RPATH_LEN)
+  if(RPATH_LEN GREATER 0)
+    set(AT_LINKER_FLAGS "${AT_LINKER_FLAGS} -Wl")
+    foreach(RPATH ${RPATH_LIST})
+      set(AT_LINKER_FLAGS "${AT_LINKER_FLAGS},-rpath,${RPATH}")
+    endforeach()
+  endif()
+
+  set(CMAKE_SHARED_LINKER_FLAGS "${AT_LINKER_FLAGS} ${CMAKE_SHARED_LINKER_FLAGS}")
+  set(CMAKE_MODULE_LINKER_FLAGS "${AT_LINKER_FLAGS} ${CMAKE_MODULE_LINKER_FLAGS}")
+  set(CMAKE_EXE_LINKER_FLAGS    "${AT_LINKER_FLAGS} ${CMAKE_EXE_LINKER_FLAGS}")
+
+  if(AT_NO_AUTOVEC)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-tree-vectorize -fno-tree-slp-vectorize")
+    set(CMAKE_C_FLAGS   "${CMAKE_C_FLAGS} -fno-tree-vectorize -fno-tree-slp-vectorize")
+  endif()
+
+endif()
+
+set(CMAKE_FIND_ROOT_PATH ${CMAKE_FIND_ROOT_PATH} ${AT_SYSROOT_PATH} ${AT_GCCROOT_PATH})
+set(CMAKE_SYSROOT ${AT_SYSROOT_PATH})
+
+# what about ld.gold?
+if(NOT DEFINED CMAKE_LINKER)
+  find_program(CMAKE_LINKER NAMES ld)
+endif()
+
+if(NOT DEFINED CMAKE_AR)
+  find_program(CMAKE_AR NAMES ar)
+endif()
+
+set(TOOLCHAIN_CONFIG_VARS ${TOOLCHAIN_CONFIG_VARS}
+    CMAKE_SYSROOT
+    AT_SYSROOT_PATH
+    AT_GCCROOT_PATH
+)
+toolchain_save_config()

platforms/linux/riscv-gnu.toolchain.cmake

@@ -0,0 +1,54 @@
+if(COMMAND toolchain_save_config)
+  return() # prevent recursive call
+endif()
+
+set(CMAKE_SYSTEM_NAME Linux)
+set(CMAKE_SYSTEM_VERSION 1)
+if(NOT DEFINED CMAKE_SYSTEM_PROCESSOR)
+  set(CMAKE_SYSTEM_PROCESSOR riscv64)
+else()
+  #message("CMAKE_SYSTEM_PROCESSOR=${CMAKE_SYSTEM_PROCESSOR}")
+endif()
+
+include("${CMAKE_CURRENT_LIST_DIR}/gnu.toolchain.cmake")
+
+if(NOT "x${GCC_COMPILER_VERSION}" STREQUAL "x")
+  set(__GCC_VER_SUFFIX "-${GCC_COMPILER_VERSION}")
+endif()
+
+if(NOT DEFINED GNU_MACHINE)
+  set(GNU_MACHINE riscv64-unknown-linux-gnu CACHE STRING "GNU compiler triple")
+endif()
+
+if(NOT DEFINED TOOLCHAIN_COMPILER_LOCATION_HINT)
+  set(TOOLCHAIN_COMPILER_LOCATION_HINT PATHS /opt/riscv/bin ENV PATH)
+endif()
+
+find_program(CMAKE_C_COMPILER NAMES ${GNU_MACHINE}-gcc${__GCC_VER_SUFFIX} PATHS ${TOOLCHAIN_COMPILER_LOCATION_HINT})
+find_program(CMAKE_CXX_COMPILER NAMES ${GNU_MACHINE}-g++${__GCC_VER_SUFFIX} PATHS ${TOOLCHAIN_COMPILER_LOCATION_HINT})
+find_program(CMAKE_LINKER NAMES ${GNU_MACHINE}-ld${__GCC_VER_SUFFIX} ${GNU_MACHINE}-ld PATHS ${TOOLCHAIN_COMPILER_LOCATION_HINT})
+find_program(CMAKE_AR NAMES ${GNU_MACHINE}-ar${__GCC_VER_SUFFIX} ${GNU_MACHINE}-ar PATHS ${TOOLCHAIN_COMPILER_LOCATION_HINT})
+
+if(NOT CMAKE_C_COMPILER OR NOT CMAKE_CXX_COMPILER OR NOT CMAKE_LINKER OR NOT CMAKE_AR)
+  message(FATAL_ERROR "\
+    One of RISC-V toolchain components have not been found:
+      CMAKE_C_COMPILER=${CMAKE_C_COMPILER}
+      CMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}
+      CMAKE_LINKER=${CMAKE_LINKER}
+      CMAKE_AR=${CMAKE_AR}
+    Use PATH environment variable and/or GNU_MACHINE, TOOLCHAIN_COMPILER_LOCATION_HINT and others cmake variables to help CMake find them.")
+endif()
+
+if(NOT DEFINED RISCV_SYSROOT)
+  get_filename_component(_base_dir ${CMAKE_C_COMPILER} DIRECTORY)
+  get_filename_component(_base_dir ${_base_dir} DIRECTORY)
+  set(RISCV_SYSROOT ${_base_dir}/sysroot CACHE PATH "RISC-V sysroot")
+endif()
+
+set(CMAKE_SYSROOT "${RISCV_SYSROOT}")
+set(CMAKE_FIND_ROOT_PATH ${CMAKE_FIND_ROOT_PATH} ${RISCV_SYSROOT})
+
+set(TOOLCHAIN_CONFIG_VARS ${TOOLCHAIN_CONFIG_VARS}
+    RISCV_SYSROOT
+)
+toolchain_save_config()

platforms/linux/riscv64-071-gcc.toolchain.cmake

@@ -0,0 +1,57 @@
+set(CMAKE_SYSTEM_NAME Linux)
+set(CMAKE_SYSTEM_PROCESSOR riscv64)
+
+set(CMAKE_CXX_COMPILER riscv64-unknown-linux-gnu-g++)
+set(CMAKE_C_COMPILER  riscv64-unknown-linux-gnu-gcc)
+
+# MangoPi MQ Pro - C906FD, C906FDV
+# Lichee Pi 4A - C910, C910V (?)
+# CanMV K230 - C908, C908V
+
+# See https://github.com/T-head-Semi/gcc/blob/xuantie-gcc-10.4.0/gcc/config/riscv/riscv-cores.def
+
+set(_enable_vector OFF)
+if(CORE STREQUAL "C906FD")
+  set(CMAKE_C_FLAGS_INIT "-mcpu=c906fd -mabi=lp64d  -mtune=c906fd")
+  set(CMAKE_CXX_FLAGS_INIT "-mcpu=c906fd -mabi=lp64d  -mtune=c906fd")
+elseif(CORE STREQUAL "C906FDV")
+  set(CMAKE_C_FLAGS_INIT "-mcpu=c906fd -mabi=lp64d  -mtune=c906fd")
+  set(CMAKE_CXX_FLAGS_INIT "-mcpu=c906fd -mabi=lp64d  -mtune=c906fd")
+  # Disabled due to limited 64-bit SEW support
+  # set(_enable_vector ON)
+elseif(CORE STREQUAL "C908")
+  set(CMAKE_C_FLAGS_INIT "-mcpu=c908 -mabi=lp64d  -mtune=c908")
+  set(CMAKE_CXX_FLAGS_INIT "-mcpu=c908 -mabi=lp64d  -mtune=c908")
+elseif(CORE STREQUAL "C908V")
+  set(CMAKE_C_FLAGS_INIT "-mcpu=c908v -mabi=lp64d  -mtune=c908")
+  set(CMAKE_CXX_FLAGS_INIT "-mcpu=c908v -mabi=lp64d  -mtune=c908")
+  set(_enable_vector ON) # RVV 1.0
+elseif(CORE STREQUAL "C910")
+  set(CMAKE_C_FLAGS_INIT "-mcpu=c910 -mabi=lp64d -mtune=c910")
+  set(CMAKE_CXX_FLAGS_INIT "-mcpu=c910 -mabi=lp64d -mtune=c910")
+elseif(CORE STREQUAL "C910V")
+  set(CMAKE_C_FLAGS_INIT "-march=rv64imafdcv0p7xthead -mabi=lp64d")
+  set(CMAKE_CXX_FLAGS_INIT "-march=rv64imafdcv0p7xthead -mabi=lp64d")
+  set(_enable_vector ON) # RVV 0.7.1
+elseif(CORE STREQUAL "C920")
+  set(CMAKE_C_FLAGS_INIT "-mcpu=c920 -mabi=lp64d  -mtune=c920")
+  set(CMAKE_CXX_FLAGS_INIT "-mcpu=c920 -mabi=lp64d  -mtune=c920")
+  set(_enable_vector ON) # RVV 0.7.1
+elseif(CORE STREQUAL "C920V2")
+  set(CMAKE_C_FLAGS_INIT "-mcpu=c920v2 -mabi=lp64d  -mtune=c920v2")
+  set(CMAKE_CXX_FLAGS_INIT "-mcpu=c920v2 -mabi=lp64d  -mtune=c920v2")
+  set(_enable_vector ON) # RVV 1.0
+else()
+  set(CMAKE_C_FLAGS_INIT "-march=rv64imafdc_zihintpause_zfh_zba_zbb_zbc_zbs_xtheadc -mabi=lp64d")
+  set(CMAKE_CXX_FLAGS_INIT "-march=rv64imafdc_zihintpause_zfh_zba_zbb_zbc_zbs_xtheadc -mabi=lp64d")
+endif()
+
+if(_enable_vector)
+  set(CMAKE_C_FLAGS_INIT "${CMAKE_C_FLAGS_INIT} -D__riscv_vector_071 -mrvv-vector-bits=128")
+  set(CMAKE_CXX_FLAGS_INIT "${CMAKE_CXX_FLAGS_INIT} -D__riscv_vector_071 -mrvv-vector-bits=128")
+endif()
+
+if(ENABLE_GCOV)
+  set(CMAKE_CXX_FLAGS_INIT "${CMAKE_CXX_FLAGS_INIT} -fprofile-arcs -ftest-coverage")
+  set(CMAKE_C_FLAGS_INIT "${CMAKE_C_FLAGS_INIT} -fprofile-arcs -ftest-coverage")
+endif()

platforms/linux/riscv64-andes-gcc.toolchain.cmake

@@ -0,0 +1,21 @@
+set(CMAKE_SYSTEM_NAME Linux)
+set(CMAKE_SYSTEM_PROCESSOR riscv64)
+
+message(STATUS "RISCV: $ENV{RISCV}")
+message(STATUS "RISCV_GCC_INSTALL_ROOT: $ENV{RISCV_GCC_INSTALL_ROOT}")
+
+set(RISCV_GCC_INSTALL_ROOT $ENV{RISCV} CACHE PATH "Path to GCC for RISC-V cross compiler installation directory")
+
+set(CMAKE_C_COMPILER  ${RISCV_GCC_INSTALL_ROOT}/bin/riscv64-linux-gcc)
+set(CMAKE_CXX_COMPILER ${RISCV_GCC_INSTALL_ROOT}/bin/riscv64-linux-g++)
+
+# fix toolchain macro
+# enable rvp
+
+set(CMAKE_C_FLAGS_INIT "-march=rv64gc -mext-dsp -D__ANDES=1")
+set(CMAKE_CXX_FLAGS_INIT "-march=rv64gc -mext-dsp -D__ANDES=1")
+
+# fix segment address
+
+set(CMAKE_EXE_LINKER_FLAGS_INIT "-Wl,-Ttext-segment=0x50000")
+set(CMAKE_SHARED_LINKER_FLAGS_INIT "-Wl,-Ttext-segment=0x50000")

platforms/linux/riscv64-clang.toolchain.cmake

@@ -0,0 +1,32 @@
+set(CMAKE_SYSTEM_NAME Linux)
+set(CMAKE_SYSTEM_PROCESSOR riscv64)
+
+set(RISCV_CLANG_BUILD_ROOT /opt/rvv-llvm CACHE PATH "Path to CLANG for RISC-V cross compiler build directory")
+set(RISCV_GCC_INSTALL_ROOT /opt/riscv CACHE PATH "Path to GCC for RISC-V cross compiler installation directory")
+set(CMAKE_SYSROOT ${RISCV_GCC_INSTALL_ROOT}/sysroot CACHE PATH "RISC-V sysroot")
+
+set(CLANG_TARGET_TRIPLE riscv64-unknown-linux-gnu)
+
+set(CMAKE_C_COMPILER ${RISCV_CLANG_BUILD_ROOT}/bin/clang)
+set(CMAKE_C_COMPILER_TARGET ${CLANG_TARGET_TRIPLE})
+set(CMAKE_CXX_COMPILER ${RISCV_CLANG_BUILD_ROOT}/bin/clang++)
+set(CMAKE_CXX_COMPILER_TARGET ${CLANG_TARGET_TRIPLE})
+set(CMAKE_ASM_COMPILER ${RISCV_CLANG_BUILD_ROOT}/bin/clang)
+set(CMAKE_ASM_COMPILER_TARGET ${CLANG_TARGET_TRIPLE})
+
+# Don't run the linker on compiler check
+set(CMAKE_TRY_COMPILE_TARGET_TYPE STATIC_LIBRARY)
+
+include("${CMAKE_CURRENT_LIST_DIR}/flags-riscv64.cmake")
+if(COMMAND ocv_set_platform_flags)
+  ocv_set_platform_flags(CMAKE_CXX_FLAGS_INIT)
+  ocv_set_platform_flags(CMAKE_C_FLAGS_INIT)
+endif()
+set(CMAKE_CXX_FLAGS_INIT "${CMAKE_CXX_FLAGS_INIT} --gcc-toolchain=${RISCV_GCC_INSTALL_ROOT} -w")
+set(CMAKE_C_FLAGS_INIT "${CMAKE_C_FLAGS_INIT} --gcc-toolchain=${RISCV_GCC_INSTALL_ROOT} -w")
+
+set(CMAKE_FIND_ROOT_PATH ${CMAKE_SYSROOT})
+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)

platforms/linux/riscv64-gcc.toolchain.cmake

@@ -0,0 +1,11 @@
+set(CMAKE_SYSTEM_NAME Linux)
+set(CMAKE_SYSTEM_PROCESSOR riscv64)
+set(GNU_MACHINE riscv64-unknown-linux-gnu CACHE STRING "GNU compiler triple")
+
+include("${CMAKE_CURRENT_LIST_DIR}/flags-riscv64.cmake")
+if(COMMAND ocv_set_platform_flags)
+  ocv_set_platform_flags(CMAKE_CXX_FLAGS_INIT)
+  ocv_set_platform_flags(CMAKE_C_FLAGS_INIT)
+endif()
+
+include("${CMAKE_CURRENT_LIST_DIR}/riscv-gnu.toolchain.cmake")