What changed, and why it matters
This commit adds support for RISC-V processors to the XMRig cryptocurrency miner. It is a large feature/porting patch that introduces new CPU detection, build-system logic, and SSE-to-RISC-V vector compatibility headers. There is no direct evidence in the commit that this is a security fix or that it introduces a deliberate vulnerability; it reads as an architecture-enablement change. However, the patch contains a number of low-quality or risky implementation choices—such as placeholder AES stubs, inline assembly that may not compile on all toolchains, hardcoded -march flags, and a performance guide that recommends -ffast-math and aggressive kernel tuning—that could lead to incorrect hashing results, build failures, or local system misconfiguration. These are reliability and correctness concerns rather than proven security flaws.
Treat this as a feature commit, not a security patch. If deploying, verify builds on the exact target RISC-V board/toolchain because the ISA flags and inline assembly may not assemble cleanly. Ensure RandomX and CryptoNight are tested against known test vectors, since the soft-AES fallback and stubbed AES intrinsics could produce incorrect hashes if the wrong code path is reached. Review the performance-guide recommendations (especially -ffast-math and huge-page sysctl changes) before applying them in production. No CVE or advisory action is indicated by the supplied materials.
Security signals we found
Architecture port with large new inline-assembly and intrinsic-compatibility surface
Placeholder/stub AES intrinsics (_mm_aesenc_si128, _mm_aeskeygenassist_si128) that do not perform real AES
Forced soft AES path in RxVm.cpp for RISC-V to avoid runtime abort
Extension-gated RISC-V inline assembly (Zbb, Zba, Zihintpause, A extension, RVV) without runtime dispatch in some helpers
Build system sets -march=rv64gc baseline while documentation recommends a different, wider ISA string
Documentation recommends -ffast-math and aggressive kernel huge-page changes
No vendor security disclosure or CVE references present in commit
Evidence from the diff
The diff adds RISC-V as a supported architecture. Key changes: cmake/cpu.cmake and cmake/flags.cmake detect riscv* processors, set XMRIG_RISCV, and add -march=rv64gc plus -DHAVE_ROTR. RandomX x86 assembly and MSR paths are disabled for RISC-V. New files provide RISC-V CPU info (BasicCpuInfo_riscv.cpp, lscpu_riscv.cpp), SSE/NEON-to-RISC-V vector compatibility layers (sse2rvv.h, sse2rvv_optimized.h, sse2rvv_scalar_backup.h), and RISC-V-specific crypto/memory/RVV helpers (riscv_crypto.h, riscv_memory.h, riscv_rvv.h, RxDataset_riscv.h). RxVm.cpp forces soft AES on RISC-V. The new doc/RISCV_PERF_TUNING.md recommends aggressive compiler flags (-ffast-math, -flto, -funroll-loops) and huge-page tuning. Security-relevant signals: AES intrinsics are stubbed out (e.g., _mm_aesenc_si128 returns a simple XOR, _mm_aeskeygenassist_si128 returns its input), which could produce wrong hashes if ever invoked on the non-soft-AES path; inline RISC-V assembly uses instructions (prefetch.r/w, pause, ror, cpop, ctz, add.uw, amoadd.d.aq, amoswap.d.aq) that are extension-gated and may fail to assemble if the compiler is not configured for the exact target; the build forces -march=rv64gc at baseline but the doc suggests rv64gcv_zba_zbb_zbc_zbs, creating a mismatch. There is no mention of a CVE, security advisory, or independent researcher attribution in the commit materials.
Changed components
CMake build system (CMakeLists.txt, cmake/cpu.cmake, cmake/flags.cmake, cmake/asm.cmake, cmake/randomx.cmake)CPU backend platform detection (src/backend/cpu/platform/BasicCpuInfo_riscv.cpp, lscpu_riscv.cpp, BasicCpuInfo.h, HwlocCpuInfo.cpp, ICpuInfo.h)CryptoNight hashing path (src/crypto/cn/CnHash.cpp, CryptoNight.h, CryptoNight_arm.h, CryptoNight_monero.h, soft_aes.h, sse2rvv*.h)RandomX dataset/VM path (src/crypto/rx/RxDataset_riscv.h, RxVm.cpp)GhostRider path (src/crypto/ghostrider/ghostrider.cpp)RISC-V helper headers (src/crypto/riscv/riscv_crypto.h, riscv_memory.h, riscv_rvv.h)Memory allocation portability header (src/crypto/common/portable/mm_malloc.h)Documentation (doc/RISCV_PERF_TUNING.md)Inspect captured patch +3620 / −20
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 3139232..ff76048 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -97,6 +97,8 @@ set(HEADERS_CRYPTO
if (XMRIG_ARM)
set(HEADERS_CRYPTO "${HEADERS_CRYPTO}" src/crypto/cn/CryptoNight_arm.h)
+elseif (XMRIG_RISCV)
+ set(HEADERS_CRYPTO "${HEADERS_CRYPTO}" src/crypto/cn/CryptoNight_arm.h)
else()
set(HEADERS_CRYPTO "${HEADERS_CRYPTO}" src/crypto/cn/CryptoNight_x86.h)
endif()
diff --git a/README.md b/README.md
index b4d4075..a6f4c35 100644
--- a/README.md
+++ b/README.md
@@ -10,7 +10,7 @@
XMRig is a high performance, open source, cross platform RandomX, KawPow, CryptoNight and [GhostRider](https://github.com/xmrig/xmrig/tree/master/src/crypto/ghostrider#readme) unified CPU/GPU miner and [RandomX benchmark](https://xmrig.com/benchmark). Official binaries are available for Windows, Linux, macOS and FreeBSD.
## Mining backends
-- **CPU** (x86/x64/ARMv7/ARMv8)
+- **CPU** (x86/x64/ARMv7/ARMv8,RISC-V)
- **OpenCL** for AMD GPUs.
- **CUDA** for NVIDIA GPUs via external [CUDA plugin](https://github.com/xmrig/xmrig-cuda).
diff --git a/cmake/asm.cmake b/cmake/asm.cmake
index e445def..30a119c 100644
--- a/cmake/asm.cmake
+++ b/cmake/asm.cmake
@@ -1,4 +1,4 @@
-if (WITH_ASM AND NOT XMRIG_ARM AND CMAKE_SIZEOF_VOID_P EQUAL 8)
+if (WITH_ASM AND NOT XMRIG_ARM AND NOT XMRIG_RISCV AND CMAKE_SIZEOF_VOID_P EQUAL 8)
set(XMRIG_ASM_LIBRARY "xmrig-asm")
if (CMAKE_C_COMPILER_ID MATCHES MSVC)
diff --git a/cmake/cpu.cmake b/cmake/cpu.cmake
index fe322a3..84ef245 100644
--- a/cmake/cpu.cmake
+++ b/cmake/cpu.cmake
@@ -21,6 +21,19 @@ if (NOT VAES_SUPPORTED)
set(WITH_VAES OFF)
endif()
+# Detect RISC-V architecture early (before it's used below)
+if (CMAKE_SYSTEM_PROCESSOR MATCHES "^(riscv64|riscv|rv64)$")
+ set(RISCV_TARGET 64)
+ set(XMRIG_RISCV ON)
+ add_definitions(-DXMRIG_RISCV)
+ message(STATUS "Detected RISC-V 64-bit architecture (${CMAKE_SYSTEM_PROCESSOR})")
+elseif (CMAKE_SYSTEM_PROCESSOR MATCHES "^(riscv32|rv32)$")
+ set(RISCV_TARGET 32)
+ set(XMRIG_RISCV ON)
+ add_definitions(-DXMRIG_RISCV)
+ message(STATUS "Detected RISC-V 32-bit architecture (${CMAKE_SYSTEM_PROCESSOR})")
+endif()
+
if (XMRIG_64_BIT AND CMAKE_SYSTEM_PROCESSOR MATCHES "^(x86_64|AMD64)$")
add_definitions(-DRAPIDJSON_SSE2)
else()
@@ -29,6 +42,13 @@ else()
set(WITH_VAES OFF)
endif()
+# Disable x86-specific features for RISC-V
+if (XMRIG_RISCV)
+ set(WITH_SSE4_1 OFF)
+ set(WITH_AVX2 OFF)
+ set(WITH_VAES OFF)
+endif()
+
add_definitions(-DRAPIDJSON_WRITE_DEFAULT_FLAGS=6) # rapidjson::kWriteNanAndInfFlag | rapidjson::kWriteNanAndInfNullFlag
if (ARM_V8)
diff --git a/cmake/flags.cmake b/cmake/flags.cmake
index 9abf212..2046e85 100644
--- a/cmake/flags.cmake
+++ b/cmake/flags.cmake
@@ -25,9 +25,18 @@ if (CMAKE_CXX_COMPILER_ID MATCHES GNU)
if (ARM_TARGET EQUAL 8)
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${ARM8_CXX_FLAGS}")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${ARM8_CXX_FLAGS} -flax-vector-conversions")
+ add_definitions(-DHAVE_ROTR)
elseif (ARM_TARGET EQUAL 7)
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -march=armv7-a -mfpu=neon -flax-vector-conversions")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=armv7-a -mfpu=neon -flax-vector-conversions")
+ add_definitions(-DHAVE_ROTR)
+ elseif (XMRIG_RISCV)
+ # RISC-V baseline: rv64gc (RV64IMAFD + Zicsr + Zifencei)
+ # Use rv64gc for broad compatibility, extensions will be detected at runtime
+ set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -march=rv64gc")
+ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=rv64gc")
+
+ add_definitions(-DHAVE_ROTR)
else()
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -maes")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -maes")
@@ -71,9 +80,18 @@ elseif (CMAKE_CXX_COMPILER_ID MATCHES Clang)
if (ARM_TARGET EQUAL 8)
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${ARM8_CXX_FLAGS}")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${ARM8_CXX_FLAGS}")
+ add_definitions(-DHAVE_ROTR)
elseif (ARM_TARGET EQUAL 7)
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -mfpu=neon -march=${CMAKE_SYSTEM_PROCESSOR}")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mfpu=neon -march=${CMAKE_SYSTEM_PROCESSOR}")
+ add_definitions(-DHAVE_ROTR)
+ elseif (XMRIG_RISCV)
+ # RISC-V baseline: rv64gc (RV64IMAFD + Zicsr + Zifencei)
+ # Use rv64gc for broad compatibility, extensions will be detected at runtime
+ set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -march=rv64gc")
+ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -march=rv64gc")
+
+ add_definitions(-DHAVE_ROTR)
else()
set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -maes")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -maes")
diff --git a/cmake/randomx.cmake b/cmake/randomx.cmake
index a50e078..278fe44 100644
--- a/cmake/randomx.cmake
+++ b/cmake/randomx.cmake
@@ -62,7 +62,7 @@ if (WITH_RANDOMX)
src/crypto/randomx/jit_compiler_x86_static.asm
src/crypto/randomx/jit_compiler_x86.cpp
)
- elseif (WITH_ASM AND NOT XMRIG_ARM AND CMAKE_SIZEOF_VOID_P EQUAL 8)
+ elseif (WITH_ASM AND NOT XMRIG_ARM AND NOT XMRIG_RISCV AND CMAKE_SIZEOF_VOID_P EQUAL 8)
list(APPEND SOURCES_CRYPTO
src/crypto/randomx/jit_compiler_x86_static.S
src/crypto/randomx/jit_compiler_x86.cpp
@@ -116,7 +116,7 @@ if (WITH_RANDOMX)
)
endif()
- if (WITH_MSR AND NOT XMRIG_ARM AND CMAKE_SIZEOF_VOID_P EQUAL 8 AND (XMRIG_OS_WIN OR XMRIG_OS_LINUX))
+ if (WITH_MSR AND NOT XMRIG_ARM AND NOT XMRIG_RISCV AND CMAKE_SIZEOF_VOID_P EQUAL 8 AND (XMRIG_OS_WIN OR XMRIG_OS_LINUX))
add_definitions(/DXMRIG_FEATURE_MSR)
add_definitions(/DXMRIG_FIX_RYZEN)
message("-- WITH_MSR=ON")
diff --git a/doc/RISCV_PERF_TUNING.md b/doc/RISCV_PERF_TUNING.md
new file mode 100644
index 0000000..b37a530
--- /dev/null
+++ b/doc/RISCV_PERF_TUNING.md
@@ -0,0 +1,365 @@
+# RISC-V Performance Optimization Guide
+
+This guide provides comprehensive instructions for optimizing XMRig on RISC-V architectures.
+
+## Build Optimizations
+
+### Compiler Flags Applied Automatically
+
+The CMake build now applies aggressive RISC-V-specific optimizations:
+
+```cmake
+# RISC-V ISA with extensions
+-march=rv64gcv_zba_zbb_zbc_zbs
+
+# Aggressive compiler optimizations
+-funroll-loops # Unroll loops for ILP (instruction-level parallelism)
+-fomit-frame-pointer # Free up frame pointer register (RISC-V has limited registers)
+-fno-common # Better code generation for global variables
+-finline-functions # Inline more functions for better cache locality
+-ffast-math # Relaxed FP semantics (safe for mining)
+-flto # Link-time optimization for cross-module inlining
+
+# Release build additions
+-minline-atomics # Inline atomic operations for faster synchronization
+```
+
+### Optimal Build Command
+
+```bash
+mkdir build && cd build
+cmake -DCMAKE_BUILD_TYPE=Release ..
+make -j$(nproc)
+```
+
+**Expected build time**: 5-15 minutes depending on CPU
+
+## Runtime Optimizations
+
+### 1. Memory Configuration (Most Important)
+
+Enable huge pages to reduce TLB misses and fragmentation:
+
+#### Enable 2MB Huge Pages
+```bash
+# Calculate required huge pages (1 page = 2MB)
+# For 2 GB dataset: 1024 pages
+# For cache + dataset: 1536 pages minimum
+sudo sysctl -w vm.nr_hugepages=2048
+```
+
+Verify:
+```bash
+grep HugePages /proc/meminfo
+# Expected: HugePages_Free should be close to nr_hugepages
+```
+
+#### Enable 1GB Huge Pages (Optional but Recommended)
+
+```bash
+# Run provided helper script
+sudo ./scripts/enable_1gb_pages.sh
+
+# Verify 1GB pages are available
+cat /sys/kernel/mm/hugepages/hugepages-1048576kB/nr_hugepages
+# Should be: >= 1 (one 1GB page)
+```
+
+Update config.json:
+```json
+{
+ "cpu": {
+ "huge-pages": true
+ },
+ "randomx": {
+ "1gb-pages": true
+ }
+}
+```
+
+### 2. RandomX Mode Selection
+
+| Mode | Memory | Init Time | Throughput | Recommendation |
+|------|--------|-----------|-----------|-----------------|
+| **light** | 256 MB | 10 sec | Low | Testing, resource-constrained |
+| **fast** | 2 GB | 2-5 min* | High | Production (with huge pages) |
+| **auto** | 2 GB | Varies | High | Default (uses fast if possible) |
+
+*With optimizations; can be 30+ minutes without huge pages
+
+**For RISC-V, use fast mode with huge pages enabled.**
+
+### 3. Dataset Initialization Threads
+
+Optimal thread count = 60-75% of CPU cores (leaves headroom for OS/other tasks)
+
+```json
+{
+ "randomx": {
+ "init": 4
+ }
+}
+```
+
+Or auto-detect (rewritten for RISC-V):
+```json
+{
+ "randomx": {
+ "init": -1
+ }
+}
+```
+
+### 4. CPU Affinity (Optional)
+
+Pin threads to specific cores for better cache locality:
+
+```json
+{
+ "cpu": {
+ "rx/0": [
+ { "threads": 1, "affinity": 0 },
+ { "threads": 1, "affinity": 1 },
+ { "threads": 1, "affinity": 2 },
+ { "threads": 1, "affinity": 3 }
+ ]
+ }
+}
+```
+
+### 5. CPU Governor (Linux)
+
+Set to performance mode for maximum throughput:
+
+```bash
+# Check current governor
+cat /sys/devices/system/cpu/cpu0/cpufreq/scaling_governor
+
+# Set to performance (requires root)
+echo performance | sudo tee /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor
+
+# Verify
+cat /sys/devices/system/cpu/cpu0/cpufreq/scaling_governor
+# Should output: performance
+```
+
+## Configuration Examples
+
+### Minimum (Testing)
+```json
+{
+ "randomx": {
+ "mode": "light"
+ },
+ "cpu": {
+ "huge-pages": false
+ }
+}
+```
+
+### Recommended (Balanced)
+```json
+{
+ "randomx": {
+ "mode": "auto",
+ "init": 4,
+ "1gb-pages": true
+ },
+ "cpu": {
+ "huge-pages": true,
+ "priority": 2
+ }
+}
+```
+
+### Maximum Performance (Production)
+```json
+{
+ "randomx": {
+ "mode": "fast",
+ "init": -1,
+ "1gb-pages": true,
+ "scratchpad_prefetch_mode": 1
+ },
+ "cpu": {
+ "huge-pages": true,
+ "priority": 3,
+ "yield": false
+ }
+}
+```
+
+## CLI Equivalents
+
+```bash
+# Light mode
+./xmrig --randomx-mode=light
+
+# Fast mode with 4 init threads
+./xmrig --randomx-mode=fast --randomx-init=4
+
+# Benchmark
+./xmrig --bench=1M --algo=rx/0
+
+# Benchmark Wownero variant (1 MB scratchpad)
+./xmrig --bench=1M --algo=rx/wow
+
+# Mine to pool
+./xmrig -o pool.example.com:3333 -u YOUR_WALLET -p x
+```
+
+## Performance Diagnostics
+
+### Check if Vector Extensions are Detected
+
+Look for `FEATURES:` line in output:
+```
+ * CPU: ky,x60 (uarch ky,x1)
+ * FEATURES: rv64imafdcv zba zbb zbc zbs
+```
+
+- `v`: Vector extension (RVV) ✓
+- `zba`, `zbb`, `zbc`, `zbs`: Bit manipulation ✓
+- If missing, make sure build used `-march=rv64gcv_zba_zbb_zbc_zbs`
+
+### Verify Huge Pages at Runtime
+
+```bash
+# Run xmrig with --bench=1M and check output
+./xmrig --bench=1M
+
+# Look for line like:
+# HUGE PAGES 100% 1 / 1 (1024 MB)
+```
+
+- Should show 100% for dataset AND threads
+- If less, increase `vm.nr_hugepages` and reboot
+
+### Monitor Performance
+
+```bash
+# Run benchmark multiple times to find stable hashrate
+./xmrig --bench=1M --algo=rx/0
+./xmrig --bench=10M --algo=rx/0
+./xmrig --bench=100M --algo=rx/0
+
+# Check system load and memory during mining
+while true; do free -h; grep HugePages /proc/meminfo; sleep 2; done
+```
+
+## Expected Performance
+
+### Hardware: Orange Pi RV2 (Ky X1, 8 cores @ ~1.5 GHz)
+
+| Config | Mode | Hashrate | Init Time |
+|--------|------|----------|-----------|
+| Scalar (baseline) | fast | 30 H/s | 10 min |
+| Scalar + huge pages | fast | 33 H/s | 2 min |
+| RVV (if enabled) | fast | 70-100 H/s | 3 min |
+
+*Actual results depend on CPU frequency, memory speed, and load*
+
+## Troubleshooting
+
+### Long Initialization Times (30+ minutes)
+
+**Cause**: Huge pages not enabled, system using swap
+**Solution**:
+1. Enable huge pages: `sudo sysctl -w vm.nr_hugepages=2048`
+2. Reboot: `sudo reboot`
+3. Reduce mining threads to free memory
+4. Check available memory: `free -h`
+
+### Low Hashrate (50% of expected)
+
+**Cause**: CPU governor set to power-save, no huge pages, high contention
+**Solution**:
+1. Set governor to performance: `echo performance | sudo tee /sys/devices/system/cpu/cpu*/cpufreq/scaling_governor`
+2. Enable huge pages
+3. Reduce number of mining threads
+4. Check system load: `top` or `htop`
+
+### Dataset Init Crashes or Hangs
+
+**Cause**: Insufficient memory, corrupted huge pages
+**Solution**:
+1. Disable huge pages temporarily: set `huge-pages: false` in config
+2. Reduce mining threads
+3. Reboot and re-enable huge pages
+4. Try light mode: `--randomx-mode=light`
+
+### Out of Memory During Benchmark
+
+**Cause**: Not enough RAM for dataset + cache + threads
+**Solution**:
+1. Use light mode: `--randomx-mode=light`
+2. Reduce mining threads: `--threads=1`
+3. Increase available memory (kill other processes)
+4. Check: `free -h` before mining
+
+## Advanced Tuning
+
+### Vector Length (VLEN) Detection
+
+RISC-V vector extension variable length (VLEN) affects performance:
+
+```bash
+# Check VLEN on your CPU
+cat /proc/cpuinfo | grep vlen
+
+# Expected values:
+# - 128 bits (16 bytes) = minimum
+# - 256 bits (32 bytes) = common
+# - 512 bits (64 bytes) = high performance
+```
+
+Larger VLEN generally means better performance for vectorized operations.
+
+### Prefetch Optimization
+
+The code automatically optimizes memory prefetching for RISC-V:
+
+```
+scratchpad_prefetch_mode: 0 = disabled (slowest)
+scratchpad_prefetch_mode: 1 = prefetch.r (default, recommended)
+scratchpad_prefetch_mode: 2 = prefetch.w (experimental)
+```
+
+### Memory Bandwidth Saturation
+
+If experiencing memory bandwidth saturation (high latency):
+
+1. Reduce mining threads
+2. Increase L2/L3 cache by mining fewer threads per core
+3. Enable cache QoS (AMD Ryzen): `cache_qos: true`
+
+## Building with Custom Flags
+
+To build with custom RISC-V flags:
+
+```bash
+mkdir build && cd build
+cmake -DCMAKE_BUILD_TYPE=Release \
+ -DCMAKE_C_FLAGS="-march=rv64gcv_zba_zbb_zbc_zbs -O3 -funroll-loops -fomit-frame-pointer" \
+ ..
+make -j$(nproc)
+```
+
+## Future Optimizations
+
+- [ ] Zbk* (crypto) support detection and usage
+- [ ] Optimal VLEN-aware algorithm selection
+- [ ] Per-core memory affinity (NUMA support)
+- [ ] Dynamic thread count adjustment based on thermals
+- [ ] Cross-compile optimizations for various RISC-V cores
+
+## References
+
+- [RISC-V Vector Extension Spec](https://github.com/riscv/riscv-v-spec)
+- [RISC-V Bit Manipulation Spec](https://github.com/riscv/riscv-bitmanip)
+- [RISC-V Crypto Spec](https://github.com/riscv/riscv-crypto)
+- [XMRig Documentation](https://xmrig.com/docs)
+
+---
+
+For further optimization, enable RVV intrinsics by replacing `sse2rvv.h` with `sse2rvv_optimized.h` in the build.
diff --git a/src/3rdparty/argon2/CMakeLists.txt b/src/3rdparty/argon2/CMakeLists.txt
index a9751fd..7d09e51 100644
--- a/src/3rdparty/argon2/CMakeLists.txt
+++ b/src/3rdparty/argon2/CMakeLists.txt
@@ -35,7 +35,7 @@ if (CMAKE_C_COMPILER_ID MATCHES MSVC)
add_feature_impl(xop "" HAVE_XOP)
add_feature_impl(avx2 "/arch:AVX2" HAVE_AVX2)
add_feature_impl(avx512f "/arch:AVX512F" HAVE_AVX512F)
-elseif (NOT XMRIG_ARM AND CMAKE_SIZEOF_VOID_P EQUAL 8)
+elseif (NOT XMRIG_ARM AND NOT XMRIG_RISCV AND CMAKE_SIZEOF_VOID_P EQUAL 8)
function(add_feature_impl FEATURE GCC_FLAG DEF)
add_library(argon2-${FEATURE} STATIC arch/x86_64/lib/argon2-${FEATURE}.c)
target_include_directories(argon2-${FEATURE} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/../../)
diff --git a/src/backend/cpu/cpu.cmake b/src/backend/cpu/cpu.cmake
index f9a02ab..3c9d779 100644
--- a/src/backend/cpu/cpu.cmake
+++ b/src/backend/cpu/cpu.cmake
@@ -46,7 +46,12 @@ else()
set(CPUID_LIB "")
endif()
-if (XMRIG_ARM)
+if (XMRIG_RISCV)
+ list(APPEND SOURCES_BACKEND_CPU
+ src/backend/cpu/platform/lscpu_riscv.cpp
+ src/backend/cpu/platform/BasicCpuInfo_riscv.cpp
+ )
+elseif (XMRIG_ARM)
list(APPEND SOURCES_BACKEND_CPU src/backend/cpu/platform/BasicCpuInfo_arm.cpp)
if (XMRIG_OS_WIN)
diff --git a/src/backend/cpu/interfaces/ICpuInfo.h b/src/backend/cpu/interfaces/ICpuInfo.h
index 8d10d4d..e28a147 100644
--- a/src/backend/cpu/interfaces/ICpuInfo.h
+++ b/src/backend/cpu/interfaces/ICpuInfo.h
@@ -91,7 +91,7 @@ public:
ICpuInfo() = default;
virtual ~ICpuInfo() = default;
-# if defined(__x86_64__) || defined(_M_AMD64) || defined (__arm64__) || defined (__aarch64__)
+# if defined(__x86_64__) || defined(_M_AMD64) || defined (__arm64__) || defined (__aarch64__) || defined(__riscv) && (__riscv_xlen == 64)
inline constexpr static bool is64bit() { return true; }
# else
inline constexpr static bool is64bit() { return false; }
diff --git a/src/backend/cpu/platform/BasicCpuInfo.h b/src/backend/cpu/platform/BasicCpuInfo.h
index 5ea5661..97fe20e 100644
--- a/src/backend/cpu/platform/BasicCpuInfo.h
+++ b/src/backend/cpu/platform/BasicCpuInfo.h
@@ -65,7 +65,7 @@ protected:
inline Vendor vendor() const override { return m_vendor; }
inline uint32_t model() const override
{
-# ifndef XMRIG_ARM
+# if !defined(XMRIG_ARM) && !defined(XMRIG_RISCV)
return m_model;
# else
return 0;
@@ -80,7 +80,7 @@ protected:
Vendor m_vendor = VENDOR_UNKNOWN;
private:
-# ifndef XMRIG_ARM
+# if !defined(XMRIG_ARM) && !defined(XMRIG_RISCV)
uint32_t m_procInfo = 0;
uint32_t m_family = 0;
uint32_t m_model = 0;
diff --git a/src/backend/cpu/platform/BasicCpuInfo_riscv.cpp b/src/backend/cpu/platform/BasicCpuInfo_riscv.cpp
new file mode 100644
index 0000000..fd9c9ce
--- /dev/null
+++ b/src/backend/cpu/platform/BasicCpuInfo_riscv.cpp
@@ -0,0 +1,116 @@
+/* XMRig
+ * Copyright (c) 2025 Slayingripper <https://github.com/Slayingripper>
+ * Copyright (c) 2018-2025 SChernykh <https://github.com/SChernykh>
+ * Copyright (c) 2017-2019 XMR-Stak <https://github.com/fireice-uk>, <https://github.com/psychocrypt>
+ * Copyright (c) 2016-2025 XMRig <support@xmrig.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <array>
+#include <cstring>
+#include <fstream>
+#include <thread>
+
+
+#include "backend/cpu/platform/BasicCpuInfo.h"
+#include "base/tools/String.h"
+#include "3rdparty/rapidjson/document.h"
+
+
+namespace xmrig {
+
+
+extern String cpu_name_riscv();
+extern bool has_riscv_vector();
+extern bool has_riscv_crypto();
+
+
+} // namespace xmrig
+
+
+xmrig::BasicCpuInfo::BasicCpuInfo() :
+ m_threads(std::thread::hardware_concurrency())
+{
+ m_units.resize(m_threads);
+ for (int32_t i = 0; i < static_cast<int32_t>(m_threads); ++i) {
+ m_units[i] = i;
+ }
+
+ memcpy(m_brand, "RISC-V", 6);
+
+ auto name = cpu_name_riscv();
+ if (!name.isNull()) {
+ strncpy(m_brand, name.data(), sizeof(m_brand) - 1);
+ }
+
+ // Check for crypto extensions (Zknd/Zkne/Zknh - AES and SHA)
+ m_flags.set(FLAG_AES, has_riscv_crypto());
+
+ // RISC-V typically supports 1GB huge pages
+ m_flags.set(FLAG_PDPE1GB, std::ifstream("/sys/kernel/mm/hugepages/hugepages-1048576kB/nr_hugepages").good());
+}
+
+
+const char *xmrig::BasicCpuInfo::backend() const
+{
+ return "basic/1";
+}
+
+
+xmrig::CpuThreads xmrig::BasicCpuInfo::threads(const Algorithm &algorithm, uint32_t) const
+{
+# ifdef XMRIG_ALGO_GHOSTRIDER
+ if (algorithm.family() == Algorithm::GHOSTRIDER) {
+ return CpuThreads(threads(), 8);
+ }
+# endif
+
+ return CpuThreads(threads());
+}
+
+
+rapidjson::Value xmrig::BasicCpuInfo::toJSON(rapidjson::Document &doc) const
+{
+ using namespace rapidjson;
+ auto &allocator = doc.GetAllocator();
+
+ Value out(kObjectType);
+
+ out.AddMember("brand", StringRef(brand()), allocator);
+ out.AddMember("aes", hasAES(), allocator);
+ out.AddMember("avx2", false, allocator);
+ out.AddMember("x64", is64bit(), allocator); // DEPRECATED will be removed in the next major release.
+ out.AddMember("64_bit", is64bit(), allocator);
+ out.AddMember("l2", static_cast<uint64_t>(L2()), allocator);
+ out.AddMember("l3", static_cast<uint64_t>(L3()), allocator);
+ out.AddMember("cores", static_cast<uint64_t>(cores()), allocator);
+ out.AddMember("threads", static_cast<uint64_t>(threads()), allocator);
+ out.AddMember("packages", static_cast<uint64_t>(packages()), allocator);
+ out.AddMember("nodes", static_cast<uint64_t>(nodes()), allocator);
+ out.AddMember("backend", StringRef(backend()), allocator);
+ out.AddMember("msr", "none", allocator);
+ out.AddMember("assembly", "none", allocator);
+ out.AddMember("arch", "riscv64", allocator);
+
+ Value flags(kArrayType);
+
+ if (hasAES()) {
+ flags.PushBack("aes", allocator);
+ }
+
+ out.AddMember("flags", flags, allocator);
+
+ return out;
+}
diff --git a/src/backend/cpu/platform/HwlocCpuInfo.cpp b/src/backend/cpu/platform/HwlocCpuInfo.cpp
index f796416..1cb071b 100644
--- a/src/backend/cpu/platform/HwlocCpuInfo.cpp
+++ b/src/backend/cpu/platform/HwlocCpuInfo.cpp
@@ -87,7 +87,7 @@ static inline size_t countByType(hwloc_topology_t topology, hwloc_obj_type_t typ
}
-#ifndef XMRIG_ARM
+#if !defined(XMRIG_ARM) && !defined(XMRIG_RISCV)
static inline std::vector<hwloc_obj_t> findByType(hwloc_obj_t obj, hwloc_obj_type_t type)
{
std::vector<hwloc_obj_t> out;
@@ -207,7 +207,7 @@ bool xmrig::HwlocCpuInfo::membind(hwloc_const_bitmap_t nodeset)
xmrig::CpuThreads xmrig::HwlocCpuInfo::threads(const Algorithm &algorithm, uint32_t limit) const
{
-# ifndef XMRIG_ARM
+# if !defined(XMRIG_ARM) && !defined(XMRIG_RISCV)
if (L2() == 0 && L3() == 0) {
return BasicCpuInfo::threads(algorithm, limit);
}
@@ -277,7 +277,7 @@ xmrig::CpuThreads xmrig::HwlocCpuInfo::allThreads(const Algorithm &algorithm, ui
void xmrig::HwlocCpuInfo::processTopLevelCache(hwloc_obj_t cache, const Algorithm &algorithm, CpuThreads &threads, size_t limit) const
{
-# ifndef XMRIG_ARM
+# if !defined(XMRIG_ARM) && !defined(XMRIG_RISCV)
constexpr size_t oneMiB = 1024U * 1024U;
size_t PUs = countByType(cache, HWLOC_OBJ_PU);
diff --git a/src/backend/cpu/platform/lscpu_riscv.cpp b/src/backend/cpu/platform/lscpu_riscv.cpp
new file mode 100644
index 0000000..d19d26a
--- /dev/null
+++ b/src/backend/cpu/platform/lscpu_riscv.cpp
@@ -0,0 +1,140 @@
+/* XMRig
+ * Copyright (c) 2025 Slayingripper <https://github.com/Slayingripper>
+ * Copyright (c) 2018-2025 SChernykh <https://github.com/SChernykh>
+ * Copyright (c) 2016-2025 XMRig <support@xmrig.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "base/tools/String.h"
+#include "3rdparty/fmt/core.h"
+
+#include <cstdio>
+#include <cstring>
+#include <string>
+
+namespace xmrig {
+
+struct riscv_cpu_desc
+{
+ String model;
+ String isa;
+ String uarch;
+ bool has_vector = false;
+ bool has_crypto = false;
+
+ inline bool isReady() const { return !model.isNull(); }
+};
+
+static bool lookup_riscv(char *line, const char *pattern, String &value)
+{
+ char *p = strstr(line, pattern);
+ if (!p) {
+ return false;
+ }
+
+ p += strlen(pattern);
+ while (isspace(*p)) {
+ ++p;
+ }
+
+ if (*p == ':') {
+ ++p;
+ }
+
+ while (isspace(*p)) {
+ ++p;
+ }
+
+ // Remove trailing newline
+ size_t len = strlen(p);
+ if (len > 0 && p[len - 1] == '\n') {
+ p[len - 1] = '\0';
+ }
+
+ // Ensure we call the const char* assignment (which performs a copy)
+ // instead of the char* overload (which would take ownership of the pointer)
+ value = (const char*)p;
+ return true;
+}
+
+static bool read_riscv_cpuinfo(riscv_cpu_desc *desc)
+{
+ auto fp = fopen("/proc/cpuinfo", "r");
+ if (!fp) {
+ return false;
+ }
+
+ char buf[2048]; // Larger buffer for long ISA strings
+ while (fgets(buf, sizeof(buf), fp) != nullptr) {
+ lookup_riscv(buf, "model name", desc->model);
+
+ if (lookup_riscv(buf, "isa", desc->isa)) {
+ // Check for vector extensions
+ if (strstr(buf, "zve") || strstr(buf, "v_")) {
+ desc->has_vector = true;
+ }
+ // Check for crypto extensions (AES, SHA, etc.)
+ // zkn* = NIST crypto suite, zks* = SM crypto suite
+ // Note: zba/zbb/zbc/zbs are bit-manipulation, NOT crypto
+ if (strstr(buf, "zknd") || strstr(buf, "zkne") || strstr(buf, "zknh") ||
+ strstr(buf, "zksed") || strstr(buf, "zksh")) {
+ desc->has_crypto = true;
+ }
+ }
+
+ lookup_riscv(buf, "uarch", desc->uarch);
+
+ if (desc->isReady() && !desc->isa.isNull()) {
+ break;
+ }
+ }
+
+ fclose(fp);
+
+ return desc->isReady();
+}
+
+String cpu_name_riscv()
+{
+ riscv_cpu_desc desc;
+ if (read_riscv_cpuinfo(&desc)) {
+ if (!desc.uarch.isNull()) {
+ return fmt::format("{} ({})", desc.model, desc.uarch).c_str();
+ }
+ return desc.model;
+ }
+
+ return "RISC-V";
+}
+
+bool has_riscv_vector()
+{
+ riscv_cpu_desc desc;
+ if (read_riscv_cpuinfo(&desc)) {
+ return desc.has_vector;
+ }
+ return false;
+}
+
+bool has_riscv_crypto()
+{
+ riscv_cpu_desc desc;
+ if (read_riscv_cpuinfo(&desc)) {
+ return desc.has_crypto;
+ }
+ return false;
+}
+
+} // namespace xmrig
diff --git a/src/crypto/cn/CnHash.cpp b/src/crypto/cn/CnHash.cpp
index 4b4b006..b1f228b 100644
--- a/src/crypto/cn/CnHash.cpp
+++ b/src/crypto/cn/CnHash.cpp
@@ -23,7 +23,7 @@
#include "crypto/common/VirtualMemory.h"
-#if defined(XMRIG_ARM)
+#if defined(XMRIG_ARM) || defined(XMRIG_RISCV)
# include "crypto/cn/CryptoNight_arm.h"
#else
# include "crypto/cn/CryptoNight_x86.h"
diff --git a/src/crypto/cn/CryptoNight.h b/src/crypto/cn/CryptoNight.h
index 897890d..d37c3ea 100644
--- a/src/crypto/cn/CryptoNight.h
+++ b/src/crypto/cn/CryptoNight.h
@@ -30,7 +30,7 @@
#include <stddef.h>
#include <stdint.h>
-#if defined _MSC_VER || defined XMRIG_ARM
+#if defined _MSC_VER || defined XMRIG_ARM || defined XMRIG_RISCV
# define ABI_ATTRIBUTE
#else
# define ABI_ATTRIBUTE __attribute__((ms_abi))
diff --git a/src/crypto/cn/CryptoNight_arm.h b/src/crypto/cn/CryptoNight_arm.h
index 7b47e97..eeb5bd0 100644
--- a/src/crypto/cn/CryptoNight_arm.h
+++ b/src/crypto/cn/CryptoNight_arm.h
@@ -27,6 +27,9 @@
#ifndef XMRIG_CRYPTONIGHT_ARM_H
#define XMRIG_CRYPTONIGHT_ARM_H
+#ifdef XMRIG_RISCV
+# include "crypto/cn/sse2rvv.h"
+#endif
#include "base/crypto/keccak.h"
#include "crypto/cn/CnAlgo.h"
diff --git a/src/crypto/cn/CryptoNight_monero.h b/src/crypto/cn/CryptoNight_monero.h
index a9975e7..6c3d115 100644
--- a/src/crypto/cn/CryptoNight_monero.h
+++ b/src/crypto/cn/CryptoNight_monero.h
@@ -30,7 +30,7 @@
#include <math.h>
// VARIANT ALTERATIONS
-#ifndef XMRIG_ARM
+#if !defined(XMRIG_ARM) && !defined(XMRIG_RISCV)
# define VARIANT1_INIT(part) \
uint64_t tweak1_2_##part = 0; \
if (BASE == Algorithm::CN_1) { \
@@ -60,7 +60,7 @@
}
-#ifndef XMRIG_ARM
+#if !defined(XMRIG_ARM) && !defined(XMRIG_RISCV)
# define VARIANT2_INIT(part) \
__m128i division_result_xmm_##part = _mm_cvtsi64_si128(static_cast<int64_t>(h##part[12])); \
__m128i sqrt_result_xmm_##part = _mm_cvtsi64_si128(static_cast<int64_t>(h##part[13]));
diff --git a/src/crypto/cn/soft_aes.h b/src/crypto/cn/soft_aes.h
index fc37122..6de0089 100644
--- a/src/crypto/cn/soft_aes.h
+++ b/src/crypto/cn/soft_aes.h
@@ -29,6 +29,8 @@
#if defined(XMRIG_ARM)
# include "crypto/cn/sse2neon.h"
+#elif defined(XMRIG_RISCV)
+# include "crypto/cn/sse2rvv.h"
#elif defined(__GNUC__)
# include <x86intrin.h>
#else
diff --git a/src/crypto/cn/sse2rvv.h b/src/crypto/cn/sse2rvv.h
new file mode 100644
index 0000000..d5b525b
--- /dev/null
+++ b/src/crypto/cn/sse2rvv.h
@@ -0,0 +1,748 @@
+/* XMRig
+ * Copyright (c) 2025 Slayingripper <https://github.com/Slayingripper>
+ * Copyright (c) 2018-2025 SChernykh <https://github.com/SChernykh>
+ * Copyright (c) 2016-2025 XMRig <support@xmrig.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*
+ * SSE to RISC-V Vector (RVV) optimized compatibility header
+ * Provides both scalar fallback and vectorized implementations using RVV intrinsics
+ *
+ * Based on sse2neon.h concepts, adapted for RISC-V architecture with RVV extensions
+ * Original sse2neon.h: https://github.com/DLTcollab/sse2neon
+ */
+
+#ifndef XMRIG_SSE2RVV_OPTIMIZED_H
+#define XMRIG_SSE2RVV_OPTIMIZED_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+#include <string.h>
+
+/* Check if RVV is available */
+#if defined(__riscv_vector)
+#include <riscv_vector.h>
+#define USE_RVV_INTRINSICS 1
+#else
+#define USE_RVV_INTRINSICS 0
+#endif
+
+/* 128-bit vector type */
+typedef union {
+ uint8_t u8[16];
+ uint16_t u16[8];
+ uint32_t u32[4];
+ uint64_t u64[2];
+ int8_t i8[16];
+ int16_t i16[8];
+ int32_t i32[4];
+ int64_t i64[2];
+} __m128i_union;
+
+typedef __m128i_union __m128i;
+
+/* Set operations */
+static inline __m128i _mm_set_epi32(int e3, int e2, int e1, int e0)
+{
+ __m128i result;
+ result.i32[0] = e0;
+ result.i32[1] = e1;
+ result.i32[2] = e2;
+ result.i32[3] = e3;
+ return result;
+}
+
+static inline __m128i _mm_set_epi64x(int64_t e1, int64_t e0)
+{
+ __m128i result;
+ result.i64[0] = e0;
+ result.i64[1] = e1;
+ return result;
+}
+
+static inline __m128i _mm_setzero_si128(void)
+{
+ __m128i result;
+ memset(&result, 0, sizeof(result));
+ return result;
+}
+
+/* Extract/insert operations */
+static inline int _mm_cvtsi128_si32(__m128i a)
+{
+ return a.i32[0];
+}
+
+static inline int64_t _mm_cvtsi128_si64(__m128i a)
+{
+ return a.i64[0];
+}
+
+static inline __m128i _mm_cvtsi32_si128(int a)
+{
+ __m128i result = _mm_setzero_si128();
+ result.i32[0] = a;
+ return result;
+}
+
+static inline __m128i _mm_cvtsi64_si128(int64_t a)
+{
+ __m128i result = _mm_setzero_si128();
+ result.i64[0] = a;
+ return result;
+}
+
+/* Shuffle operations */
+static inline __m128i _mm_shuffle_epi32(__m128i a, int imm8)
+{
+ __m128i result;
+ result.u32[0] = a.u32[(imm8 >> 0) & 0x3];
+ result.u32[1] = a.u32[(imm8 >> 2) & 0x3];
+ result.u32[2] = a.u32[(imm8 >> 4) & 0x3];
+ result.u32[3] = a.u32[(imm8 >> 6) & 0x3];
+ return result;
+}
+
+/* Logical operations - optimized with RVV when available */
+static inline __m128i _mm_xor_si128(__m128i a, __m128i b)
+{
+#if USE_RVV_INTRINSICS
+ __m128i result;
+ size_t vl = __riscv_vsetvl_e64m1(2);
+ vuint64m1_t va = __riscv_vle64_v_u64m1(a.u64, vl);
+ vuint64m1_t vb = __riscv_vle64_v_u64m1(b.u64, vl);
+ vuint64m1_t vr = __riscv_vxor_vv_u64m1(va, vb, vl);
+ __riscv_vse64_v_u64m1(result.u64, vr, vl);
+ return result;
+#else
+ __m128i result;
+ result.u64[0] = a.u64[0] ^ b.u64[0];
+ result.u64[1] = a.u64[1] ^ b.u64[1];
+ return result;
+#endif
+}
+
+static inline __m128i _mm_or_si128(__m128i a, __m128i b)
+{
+#if USE_RVV_INTRINSICS
+ __m128i result;
+ size_t vl = __riscv_vsetvl_e64m1(2);
+ vuint64m1_t va = __riscv_vle64_v_u64m1(a.u64, vl);
+ vuint64m1_t vb = __riscv_vle64_v_u64m1(b.u64, vl);
+ vuint64m1_t vr = __riscv_vor_vv_u64m1(va, vb, vl);
+ __riscv_vse64_v_u64m1(result.u64, vr, vl);
+ return result;
+#else
+ __m128i result;
+ result.u64[0] = a.u64[0] | b.u64[0];
+ result.u64[1] = a.u64[1] | b.u64[1];
+ return result;
+#endif
+}
+
+static inline __m128i _mm_and_si128(__m128i a, __m128i b)
+{
+#if USE_RVV_INTRINSICS
+ __m128i result;
+ size_t vl = __riscv_vsetvl_e64m1(2);
+ vuint64m1_t va = __riscv_vle64_v_u64m1(a.u64, vl);
+ vuint64m1_t vb = __riscv_vle64_v_u64m1(b.u64, vl);
+ vuint64m1_t vr = __riscv_vand_vv_u64m1(va, vb, vl);
+ __riscv_vse64_v_u64m1(result.u64, vr, vl);
+ return result;
+#else
+ __m128i result;
+ result.u64[0] = a.u64[0] & b.u64[0];
+ result.u64[1] = a.u64[1] & b.u64[1];
+ return result;
+#endif
+}
+
+static inline __m128i _mm_andnot_si128(__m128i a, __m128i b)
+{
+#if USE_RVV_INTRINSICS
+ __m128i result;
+ size_t vl = __riscv_vsetvl_e64m1(2);
+ vuint64m1_t va = __riscv_vle64_v_u64m1(a.u64, vl);
+ vuint64m1_t vb = __riscv_vle64_v_u64m1(b.u64, vl);
+ vuint64m1_t vnot_a = __riscv_vnot_v_u64m1(va, vl);
+ vuint64m1_t vr = __riscv_vand_vv_u64m1(vnot_a, vb, vl);
+ __riscv_vse64_v_u64m1(result.u64, vr, vl);
+ return result;
+#else
+ __m128i result;
+ result.u64[0] = (~a.u64[0]) & b.u64[0];
+ result.u64[1] = (~a.u64[1]) & b.u64[1];
+ return result;
+#endif
+}
+
+/* Shift operations */
+static inline __m128i _mm_slli_si128(__m128i a, int imm8)
+{
+#if USE_RVV_INTRINSICS
+ __m128i result = _mm_setzero_si128();
+ int count = imm8 & 0xFF;
+ if (count > 15) return result;
+
+ size_t vl = __riscv_vsetvl_e8m1(16);
+ vuint8m1_t va = __riscv_vle8_v_u8m1(a.u8, vl);
+ vuint8m1_t vr = __riscv_vslideup_vx_u8m1(__riscv_vmv_v_x_u8m1(0, vl), va, count, vl);
+ __riscv_vse8_v_u8m1(result.u8, vr, vl);
+ return result;
+#else
+ __m128i result = _mm_setzero_si128();
+ int count = imm8 & 0xFF;
+ if (count > 15) return result;
+
+ for (int i = 0; i < 16 - count; i++) {
+ result.u8[i + count] = a.u8[i];
+ }
+ return result;
+#endif
+}
+
+static inline __m128i _mm_srli_si128(__m128i a, int imm8)
+{
+#if USE_RVV_INTRINSICS
+ __m128i result = _mm_setzero_si128();
+ int count = imm8 & 0xFF;
+ if (count > 15) return result;
+
+ size_t vl = __riscv_vsetvl_e8m1(16);
+ vuint8m1_t va = __riscv_vle8_v_u8m1(a.u8, vl);
+ vuint8m1_t vr = __riscv_vslidedown_vx_u8m1(va, count, vl);
+ __riscv_vse8_v_u8m1(result.u8, vr, vl);
+ return result;
+#else
+ __m128i result = _mm_setzero_si128();
+ int count = imm8 & 0xFF;
+ if (count > 15) return result;
+
+ for (int i = count; i < 16; i++) {
+ result.u8[i - count] = a.u8[i];
+ }
+ return result;
+#endif
+}
+
+static inline __m128i _mm_slli_epi64(__m128i a, int imm8)
+{
+#if USE_RVV_INTRINSICS
+ __m128i result;
+ if (imm8 > 63) {
+ result.u64[0] = 0;
+ result.u64[1] = 0;
+ } else {
+ size_t vl = __riscv_vsetvl_e64m1(2);
+ vuint64m1_t va = __riscv_vle64_v_u64m1(a.u64, vl);
+ vuint64m1_t vr = __riscv_vsll_vx_u64m1(va, imm8, vl);
+ __riscv_vse64_v_u64m1(result.u64, vr, vl);
+ }
+ return result;
+#else
+ __m128i result;
+ if (imm8 > 63) {
+ result.u64[0] = 0;
+ result.u64[1] = 0;
+ } else {
+ result.u64[0] = a.u64[0] << imm8;
+ result.u64[1] = a.u64[1] << imm8;
+ }
+ return result;
+#endif
+}
+
+static inline __m128i _mm_srli_epi64(__m128i a, int imm8)
+{
+#if USE_RVV_INTRINSICS
+ __m128i result;
+ if (imm8 > 63) {
+ result.u64[0] = 0;
+ result.u64[1] = 0;
+ } else {
+ size_t vl = __riscv_vsetvl_e64m1(2);
+ vuint64m1_t va = __riscv_vle64_v_u64m1(a.u64, vl);
+ vuint64m1_t vr = __riscv_vsrl_vx_u64m1(va, imm8, vl);
+ __riscv_vse64_v_u64m1(result.u64, vr, vl);
+ }
+ return result;
+#else
+ __m128i result;
+ if (imm8 > 63) {
+ result.u64[0] = 0;
+ result.u64[1] = 0;
+ } else {
+ result.u64[0] = a.u64[0] >> imm8;
+ result.u64[1] = a.u64[1] >> imm8;
+ }
+ return result;
+#endif
+}
+
+/* Load/store operations - optimized with RVV */
+static inline __m128i _mm_load_si128(const __m128i* p)
+{
+#if USE_RVV_INTRINSICS
+ __m128i result;
+ size_t vl = __riscv_vsetvl_e64m1(2);
+ vuint64m1_t v = __riscv_vle64_v_u64m1((const uint64_t*)p, vl);
+ __riscv_vse64_v_u64m1(result.u64, v, vl);
+ return result;
+#else
+ __m128i result;
+ memcpy(&result, p, sizeof(__m128i));
+ return result;
+#endif
+}
+
+static inline __m128i _mm_loadu_si128(const __m128i* p)
+{
+ __m128i result;
+ memcpy(&result, p, sizeof(__m128i));
+ return result;
+}
+
+static inline void _mm_store_si128(__m128i* p, __m128i a)
+{
+#if USE_RVV_INTRINSICS
+ size_t vl = __riscv_vsetvl_e64m1(2);
+ vuint64m1_t v = __riscv_vle64_v_u64m1(a.u64, vl);
+ __riscv_vse64_v_u64m1((uint64_t*)p, v, vl);
+#else
+ memcpy(p, &a, sizeof(__m128i));
+#endif
+}
+
+static inline void _mm_storeu_si128(__m128i* p, __m128i a)
+{
+ memcpy(p, &a, sizeof(__m128i));
+}
+
+/* Arithmetic operations - optimized with RVV */
+static inline __m128i _mm_add_epi64(__m128i a, __m128i b)
+{
+#if USE_RVV_INTRINSICS
+ __m128i result;
+ size_t vl = __riscv_vsetvl_e64m1(2);
+ vuint64m1_t va = __riscv_vle64_v_u64m1(a.u64, vl);
+ vuint64m1_t vb = __riscv_vle64_v_u64m1(b.u64, vl);
+ vuint64m1_t vr = __riscv_vadd_vv_u64m1(va, vb, vl);
+ __riscv_vse64_v_u64m1(result.u64, vr, vl);
+ return result;
+#else
+ __m128i result;
+ result.u64[0] = a.u64[0] + b.u64[0];
+ result.u64[1] = a.u64[1] + b.u64[1];
+ return result;
+#endif
+}
+
+static inline __m128i _mm_add_epi32(__m128i a, __m128i b)
+{
+#if USE_RVV_INTRINSICS
+ __m128i result;
+ size_t vl = __riscv_vsetvl_e32m1(4);
+ vuint32m1_t va = __riscv_vle32_v_u32m1(a.u32, vl);
+ vuint32m1_t vb = __riscv_vle32_v_u32m1(b.u32, vl);
+ vuint32m1_t vr = __riscv_vadd_vv_u32m1(va, vb, vl);
+ __riscv_vse32_v_u32m1(result.u32, vr, vl);
+ return result;
+#else
+ __m128i result;
+ for (int i = 0; i < 4; i++) {
+ result.i32[i] = a.i32[i] + b.i32[i];
+ }
+ return result;
+#endif
+}
+
+static inline __m128i _mm_sub_epi64(__m128i a, __m128i b)
+{
+#if USE_RVV_INTRINSICS
+ __m128i result;
+ size_t vl = __riscv_vsetvl_e64m1(2);
+ vuint64m1_t va = __riscv_vle64_v_u64m1(a.u64, vl);
+ vuint64m1_t vb = __riscv_vle64_v_u64m1(b.u64, vl);
+ vuint64m1_t vr = __riscv_vsub_vv_u64m1(va, vb, vl);
+ __riscv_vse64_v_u64m1(result.u64, vr, vl);
+ return result;
+#else
+ __m128i result;
+ result.u64[0] = a.u64[0] - b.u64[0];
+ result.u64[1] = a.u64[1] - b.u64[1];
+ return result;
+#endif
+}
+
+static inline __m128i _mm_mul_epu32(__m128i a, __m128i b)
+{
+#if USE_RVV_INTRINSICS
+ __m128i result;
+ size_t vl = __riscv_vsetvl_e64m1(2);
+ vuint64m1_t va_lo = __riscv_vzext_vf2_u64m1(__riscv_vle32_v_u32mf2(&a.u32[0], 2), vl);
+ vuint64m1_t vb_lo = __riscv_vzext_vf2_u64m1(__riscv_vle32_v_u32mf2(&b.u32[0], 2), vl);
+ vuint64m1_t vr = __riscv_vmul_vv_u64m1(va_lo, vb_lo, vl);
+ __riscv_vse64_v_u64m1(result.u64, vr, vl);
+ return result;
+#else
+ __m128i result;
+ result.u64[0] = (uint64_t)a.u32[0] * (uint64_t)b.u32[0];
+ result.u64[1] = (uint64_t)a.u32[2] * (uint64_t)b.u32[2];
+ return result;
+#endif
+}
+
+/* Unpack operations */
+static inline __m128i _mm_unpacklo_epi64(__m128i a, __m128i b)
+{
+ __m128i result;
+ result.u64[0] = a.u64[0];
+ result.u64[1] = b.u64[0];
+ return result;
+}
+
+static inline __m128i _mm_unpackhi_epi64(__m128i a, __m128i b)
+{
+ __m128i result;
+ result.u64[0] = a.u64[1];
+ result.u64[1] = b.u64[1];
+ return result;
+}
+
+/* Pause instruction for spin-wait loops */
+static inline void _mm_pause(void)
+{
+ /* RISC-V pause hint if available (requires Zihintpause extension) */
+#if defined(__riscv_zihintpause)
+ __asm__ __volatile__("pause");
+#else
+ __asm__ __volatile__("nop");
+#endif
+}
+
+/* Memory fence - optimized for RISC-V */
+static inline void _mm_mfence(void)
+{
+ __asm__ __volatile__("fence rw,rw" ::: "memory");
+}
+
+static inline void _mm_lfence(void)
+{
+ __asm__ __volatile__("fence r,r" ::: "memory");
+}
+
+static inline void _mm_sfence(void)
+{
+ __asm__ __volatile__("fence w,w" ::: "memory");
+}
+
+/* Comparison operations */
+static inline __m128i _mm_cmpeq_epi32(__m128i a, __m128i b)
+{
+ __m128i result;
+ for (int i = 0; i < 4; i++) {
+ result.u32[i] = (a.u32[i] == b.u32[i]) ? 0xFFFFFFFF : 0;
+ }
+ return result;
+}
+
+static inline __m128i _mm_cmpeq_epi64(__m128i a, __m128i b)
+{
+ __m128i result;
+ for (int i = 0; i < 2; i++) {
+ result.u64[i] = (a.u64[i] == b.u64[i]) ? 0xFFFFFFFFFFFFFFFFULL : 0;
+ }
+ return result;
+}
+
+/* Additional shift operations */
+static inline __m128i _mm_slli_epi32(__m128i a, int imm8)
+{
+#if USE_RVV_INTRINSICS
+ __m128i result;
+ if (imm8 > 31) {
+ memset(&result, 0, sizeof(result));
+ } else {
+ size_t vl = __riscv_vsetvl_e32m1(4);
+ vuint32m1_t va = __riscv_vle32_v_u32m1(a.u32, vl);
+ vuint32m1_t vr = __riscv_vsll_vx_u32m1(va, imm8, vl);
+ __riscv_vse32_v_u32m1(result.u32, vr, vl);
+ }
+ return result;
+#else
+ __m128i result;
+ if (imm8 > 31) {
+ for (int i = 0; i < 4; i++) result.u32[i] = 0;
+ } else {
+ for (int i = 0; i < 4; i++) {
+ result.u32[i] = a.u32[i] << imm8;
+ }
+ }
+ return result;
+#endif
+}
+
+static inline __m128i _mm_srli_epi32(__m128i a, int imm8)
+{
+#if USE_RVV_INTRINSICS
+ __m128i result;
+ if (imm8 > 31) {
+ memset(&result, 0, sizeof(result));
+ } else {
+ size_t vl = __riscv_vsetvl_e32m1(4);
+ vuint32m1_t va = __riscv_vle32_v_u32m1(a.u32, vl);
+ vuint32m1_t vr = __riscv_vsrl_vx_u32m1(va, imm8, vl);
+ __riscv_vse32_v_u32m1(result.u32, vr, vl);
+ }
+ return result;
+#else
+ __m128i result;
+ if (imm8 > 31) {
+ for (int i = 0; i < 4; i++) result.u32[i] = 0;
+ } else {
+ for (int i = 0; i < 4; i++) {
+ result.u32[i] = a.u32[i] >> imm8;
+ }
+ }
+ return result;
+#endif
+}
+
+/* 64-bit integer operations */
+static inline __m128i _mm_set1_epi64x(int64_t a)
+{
+ __m128i result;
+ result.i64[0] = a;
+ result.i64[1] = a;
+ return result;
+}
+
+/* Float type for compatibility */
+typedef __m128i __m128;
+
+/* Float operations - simplified scalar implementations */
+static inline __m128 _mm_set1_ps(float a)
+{
+ __m128 result;
+ uint32_t val;
+ memcpy(&val, &a, sizeof(float));
+ for (int i = 0; i < 4; i++) {
+ result.u32[i] = val;
+ }
+ return result;
+}
+
+static inline __m128 _mm_setzero_ps(void)
+{
+ __m128 result;
+ memset(&result, 0, sizeof(result));
+ return result;
+}
+
+static inline __m128 _mm_add_ps(__m128 a, __m128 b)
+{
+ __m128 result;
+ float fa[4], fb[4], fr[4];
+ memcpy(fa, &a, sizeof(__m128));
+ memcpy(fb, &b, sizeof(__m128));
+ for (int i = 0; i < 4; i++) {
+ fr[i] = fa[i] + fb[i];
+ }
+ memcpy(&result, fr, sizeof(__m128));
+ return result;
+}
+
+static inline __m128 _mm_mul_ps(__m128 a, __m128 b)
+{
+ __m128 result;
+ float fa[4], fb[4], fr[4];
+ memcpy(fa, &a, sizeof(__m128));
+ memcpy(fb, &b, sizeof(__m128));
+ for (int i = 0; i < 4; i++) {
+ fr[i] = fa[i] * fb[i];
+ }
+ memcpy(&result, fr, sizeof(__m128));
+ return result;
+}
+
+static inline __m128 _mm_and_ps(__m128 a, __m128 b)
+{
+ __m128 result;
+ result.u64[0] = a.u64[0] & b.u64[0];
+ result.u64[1] = a.u64[1] & b.u64[1];
+ return result;
+}
+
+static inline __m128 _mm_or_ps(__m128 a, __m128 b)
+{
+ __m128 result;
+ result.u64[0] = a.u64[0] | b.u64[0];
+ result.u64[1] = a.u64[1] | b.u64[1];
+ return result;
+}
+
+static inline __m128 _mm_cvtepi32_ps(__m128i a)
+{
+ __m128 result;
+ float fr[4];
+ for (int i = 0; i < 4; i++) {
+ fr[i] = (float)a.i32[i];
+ }
+ memcpy(&result, fr, sizeof(__m128));
+ return result;
+}
+
+static inline __m128i _mm_cvttps_epi32(__m128 a)
+{
+ __m128i result;
+ float fa[4];
+ memcpy(fa, &a, sizeof(__m128));
+ for (int i = 0; i < 4; i++) {
+ result.i32[i] = (int32_t)fa[i];
+ }
+ return result;
+}
+
+/* Casting operations */
+static inline __m128 _mm_castsi128_ps(__m128i a)
+{
+ __m128 result;
+ memcpy(&result, &a, sizeof(__m128));
+ return result;
+}
+
+static inline __m128i _mm_castps_si128(__m128 a)
+{
+ __m128i result;
+ memcpy(&result, &a, sizeof(__m128));
+ return result;
+}
+
+/* Additional set operations */
+static inline __m128i _mm_set1_epi32(int a)
+{
+ __m128i result;
+ for (int i = 0; i < 4; i++) {
+ result.i32[i] = a;
+ }
+ return result;
+}
+
+/* AES instructions - placeholders for soft_aes compatibility */
+static inline __m128i _mm_aesenc_si128(__m128i a, __m128i roundkey)
+{
+ return _mm_xor_si128(a, roundkey);
+}
+
+static inline __m128i _mm_aeskeygenassist_si128(__m128i a, const int rcon)
+{
+ return a;
+}
+
+/* Rotate right operation for soft_aes.h */
+static inline uint32_t _rotr(uint32_t value, unsigned int count)
+{
+ const unsigned int mask = 31;
+ count &= mask;
+ return (value >> count) | (value << ((-count) & mask));
+}
+
+/* ARM NEON compatibility types and intrinsics for RISC-V */
+typedef __m128i_union uint64x2_t;
+typedef __m128i_union uint8x16_t;
+typedef __m128i_union int64x2_t;
+typedef __m128i_union int32x4_t;
+
+static inline uint64x2_t vld1q_u64(const uint64_t *ptr)
+{
+ uint64x2_t result;
+ result.u64[0] = ptr[0];
+ result.u64[1] = ptr[1];
+ return result;
+}
+
+static inline int64x2_t vld1q_s64(const int64_t *ptr)
+{
+ int64x2_t result;
+ result.i64[0] = ptr[0];
+ result.i64[1] = ptr[1];
+ return result;
+}
+
+static inline void vst1q_u64(uint64_t *ptr, uint64x2_t val)
+{
+ ptr[0] = val.u64[0];
+ ptr[1] = val.u64[1];
+}
+
+static inline uint64x2_t veorq_u64(uint64x2_t a, uint64x2_t b)
+{
+ return _mm_xor_si128(a, b);
+}
+
+static inline uint64x2_t vaddq_u64(uint64x2_t a, uint64x2_t b)
+{
+ return _mm_add_epi64(a, b);
+}
+
+static inline uint64x2_t vreinterpretq_u64_u8(uint8x16_t a)
+{
+ uint64x2_t result;
+ memcpy(&result, &a, sizeof(uint64x2_t));
+ return result;
+}
+
+static inline uint64_t vgetq_lane_u64(uint64x2_t v, int lane)
+{
+ return v.u64[lane];
+}
+
+static inline int64_t vgetq_lane_s64(int64x2_t v, int lane)
+{
+ return v.i64[lane];
+}
+
+static inline int32_t vgetq_lane_s32(int32x4_t v, int lane)
+{
+ return v.i32[lane];
+}
+
+typedef struct { uint64_t val[1]; } uint64x1_t;
+
+static inline uint64x1_t vcreate_u64(uint64_t a)
+{
+ uint64x1_t result;
+ result.val[0] = a;
+ return result;
+}
+
+static inline uint64x2_t vcombine_u64(uint64x1_t low, uint64x1_t high)
+{
+ uint64x2_t result;
+ result.u64[0] = low.val[0];
+ result.u64[1] = high.val[0];
+ return result;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* XMRIG_SSE2RVV_OPTIMIZED_H */
diff --git a/src/crypto/cn/sse2rvv_optimized.h b/src/crypto/cn/sse2rvv_optimized.h
new file mode 100644
index 0000000..f83f110
--- /dev/null
+++ b/src/crypto/cn/sse2rvv_optimized.h
@@ -0,0 +1,748 @@
+/* XMRig
+ * Copyright (c) 2025 XMRig <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*
+ * SSE to RISC-V Vector (RVV) optimized compatibility header
+ * Provides both scalar fallback and vectorized implementations using RVV intrinsics
+ */
+
+#ifndef XMRIG_SSE2RVV_OPTIMIZED_H
+#define XMRIG_SSE2RVV_OPTIMIZED_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+#include <string.h>
+
+/* Check if RVV is available */
+#if defined(__riscv_vector)
+#include <riscv_vector.h>
+#define USE_RVV_INTRINSICS 1
+#else
+#define USE_RVV_INTRINSICS 0
+#endif
+
+/* 128-bit vector type */
+typedef union {
+ uint8_t u8[16];
+ uint16_t u16[8];
+ uint32_t u32[4];
+ uint64_t u64[2];
+ int8_t i8[16];
+ int16_t i16[8];
+ int32_t i32[4];
+ int64_t i64[2];
+#if USE_RVV_INTRINSICS
+ vuint64m1_t rvv_u64;
+ vuint32m1_t rvv_u32;
+ vuint8m1_t rvv_u8;
+#endif
+} __m128i_union;
+
+typedef __m128i_union __m128i;
+
+/* Set operations */
+static inline __m128i _mm_set_epi32(int e3, int e2, int e1, int e0)
+{
+ __m128i result;
+ result.i32[0] = e0;
+ result.i32[1] = e1;
+ result.i32[2] = e2;
+ result.i32[3] = e3;
+ return result;
+}
+
+static inline __m128i _mm_set_epi64x(int64_t e1, int64_t e0)
+{
+ __m128i result;
+ result.i64[0] = e0;
+ result.i64[1] = e1;
+ return result;
+}
+
+static inline __m128i _mm_setzero_si128(void)
+{
+ __m128i result;
+ memset(&result, 0, sizeof(result));
+ return result;
+}
+
+/* Extract/insert operations */
+static inline int _mm_cvtsi128_si32(__m128i a)
+{
+ return a.i32[0];
+}
+
+static inline int64_t _mm_cvtsi128_si64(__m128i a)
+{
+ return a.i64[0];
+}
+
+static inline __m128i _mm_cvtsi32_si128(int a)
+{
+ __m128i result = _mm_setzero_si128();
+ result.i32[0] = a;
+ return result;
+}
+
+static inline __m128i _mm_cvtsi64_si128(int64_t a)
+{
+ __m128i result = _mm_setzero_si128();
+ result.i64[0] = a;
+ return result;
+}
+
+/* Shuffle operations */
+static inline __m128i _mm_shuffle_epi32(__m128i a, int imm8)
+{
+ __m128i result;
+ result.u32[0] = a.u32[(imm8 >> 0) & 0x3];
+ result.u32[1] = a.u32[(imm8 >> 2) & 0x3];
+ result.u32[2] = a.u32[(imm8 >> 4) & 0x3];
+ result.u32[3] = a.u32[(imm8 >> 6) & 0x3];
+ return result;
+}
+
+/* Logical operations - optimized with RVV when available */
+static inline __m128i _mm_xor_si128(__m128i a, __m128i b)
+{
+#if USE_RVV_INTRINSICS
+ __m128i result;
+ size_t vl = __riscv_vsetvl_e64m1(2);
+ vuint64m1_t va = __riscv_vle64_v_u64m1(a.u64, vl);
+ vuint64m1_t vb = __riscv_vle64_v_u64m1(b.u64, vl);
+ vuint64m1_t vr = __riscv_vxor_vv_u64m1(va, vb, vl);
+ __riscv_vse64_v_u64m1(result.u64, vr, vl);
+ return result;
+#else
+ __m128i result;
+ result.u64[0] = a.u64[0] ^ b.u64[0];
+ result.u64[1] = a.u64[1] ^ b.u64[1];
+ return result;
+#endif
+}
+
+static inline __m128i _mm_or_si128(__m128i a, __m128i b)
+{
+#if USE_RVV_INTRINSICS
+ __m128i result;
+ size_t vl = __riscv_vsetvl_e64m1(2);
+ vuint64m1_t va = __riscv_vle64_v_u64m1(a.u64, vl);
+ vuint64m1_t vb = __riscv_vle64_v_u64m1(b.u64, vl);
+ vuint64m1_t vr = __riscv_vor_vv_u64m1(va, vb, vl);
+ __riscv_vse64_v_u64m1(result.u64, vr, vl);
+ return result;
+#else
+ __m128i result;
+ result.u64[0] = a.u64[0] | b.u64[0];
+ result.u64[1] = a.u64[1] | b.u64[1];
+ return result;
+#endif
+}
+
+static inline __m128i _mm_and_si128(__m128i a, __m128i b)
+{
+#if USE_RVV_INTRINSICS
+ __m128i result;
+ size_t vl = __riscv_vsetvl_e64m1(2);
+ vuint64m1_t va = __riscv_vle64_v_u64m1(a.u64, vl);
+ vuint64m1_t vb = __riscv_vle64_v_u64m1(b.u64, vl);
+ vuint64m1_t vr = __riscv_vand_vv_u64m1(va, vb, vl);
+ __riscv_vse64_v_u64m1(result.u64, vr, vl);
+ return result;
+#else
+ __m128i result;
+ result.u64[0] = a.u64[0] & b.u64[0];
+ result.u64[1] = a.u64[1] & b.u64[1];
+ return result;
+#endif
+}
+
+static inline __m128i _mm_andnot_si128(__m128i a, __m128i b)
+{
+#if USE_RVV_INTRINSICS
+ __m128i result;
+ size_t vl = __riscv_vsetvl_e64m1(2);
+ vuint64m1_t va = __riscv_vle64_v_u64m1(a.u64, vl);
+ vuint64m1_t vb = __riscv_vle64_v_u64m1(b.u64, vl);
+ vuint64m1_t vnot_a = __riscv_vnot_v_u64m1(va, vl);
+ vuint64m1_t vr = __riscv_vand_vv_u64m1(vnot_a, vb, vl);
+ __riscv_vse64_v_u64m1(result.u64, vr, vl);
+ return result;
+#else
+ __m128i result;
+ result.u64[0] = (~a.u64[0]) & b.u64[0];
+ result.u64[1] = (~a.u64[1]) & b.u64[1];
+ return result;
+#endif
+}
+
+/* Shift operations */
+static inline __m128i _mm_slli_si128(__m128i a, int imm8)
+{
+#if USE_RVV_INTRINSICS
+ __m128i result = _mm_setzero_si128();
+ int count = imm8 & 0xFF;
+ if (count > 15) return result;
+
+ size_t vl = __riscv_vsetvl_e8m1(16);
+ vuint8m1_t va = __riscv_vle8_v_u8m1(a.u8, vl);
+ vuint8m1_t vr = __riscv_vslideup_vx_u8m1(__riscv_vmv_v_x_u8m1(0, vl), va, count, vl);
+ __riscv_vse8_v_u8m1(result.u8, vr, vl);
+ return result;
+#else
+ __m128i result = _mm_setzero_si128();
+ int count = imm8 & 0xFF;
+ if (count > 15) return result;
+
+ for (int i = 0; i < 16 - count; i++) {
+ result.u8[i + count] = a.u8[i];
+ }
+ return result;
+#endif
+}
+
+static inline __m128i _mm_srli_si128(__m128i a, int imm8)
+{
+#if USE_RVV_INTRINSICS
+ __m128i result = _mm_setzero_si128();
+ int count = imm8 & 0xFF;
+ if (count > 15) return result;
+
+ size_t vl = __riscv_vsetvl_e8m1(16);
+ vuint8m1_t va = __riscv_vle8_v_u8m1(a.u8, vl);
+ vuint8m1_t vr = __riscv_vslidedown_vx_u8m1(va, count, vl);
+ __riscv_vse8_v_u8m1(result.u8, vr, vl);
+ return result;
+#else
+ __m128i result = _mm_setzero_si128();
+ int count = imm8 & 0xFF;
+ if (count > 15) return result;
+
+ for (int i = count; i < 16; i++) {
+ result.u8[i - count] = a.u8[i];
+ }
+ return result;
+#endif
+}
+
+static inline __m128i _mm_slli_epi64(__m128i a, int imm8)
+{
+#if USE_RVV_INTRINSICS
+ __m128i result;
+ if (imm8 > 63) {
+ result.u64[0] = 0;
+ result.u64[1] = 0;
+ } else {
+ size_t vl = __riscv_vsetvl_e64m1(2);
+ vuint64m1_t va = __riscv_vle64_v_u64m1(a.u64, vl);
+ vuint64m1_t vr = __riscv_vsll_vx_u64m1(va, imm8, vl);
+ __riscv_vse64_v_u64m1(result.u64, vr, vl);
+ }
+ return result;
+#else
+ __m128i result;
+ if (imm8 > 63) {
+ result.u64[0] = 0;
+ result.u64[1] = 0;
+ } else {
+ result.u64[0] = a.u64[0] << imm8;
+ result.u64[1] = a.u64[1] << imm8;
+ }
+ return result;
+#endif
+}
+
+static inline __m128i _mm_srli_epi64(__m128i a, int imm8)
+{
+#if USE_RVV_INTRINSICS
+ __m128i result;
+ if (imm8 > 63) {
+ result.u64[0] = 0;
+ result.u64[1] = 0;
+ } else {
+ size_t vl = __riscv_vsetvl_e64m1(2);
+ vuint64m1_t va = __riscv_vle64_v_u64m1(a.u64, vl);
+ vuint64m1_t vr = __riscv_vsrl_vx_u64m1(va, imm8, vl);
+ __riscv_vse64_v_u64m1(result.u64, vr, vl);
+ }
+ return result;
+#else
+ __m128i result;
+ if (imm8 > 63) {
+ result.u64[0] = 0;
+ result.u64[1] = 0;
+ } else {
+ result.u64[0] = a.u64[0] >> imm8;
+ result.u64[1] = a.u64[1] >> imm8;
+ }
+ return result;
+#endif
+}
+
+/* Load/store operations - optimized with RVV */
+static inline __m128i _mm_load_si128(const __m128i* p)
+{
+#if USE_RVV_INTRINSICS
+ __m128i result;
+ size_t vl = __riscv_vsetvl_e64m1(2);
+ vuint64m1_t v = __riscv_vle64_v_u64m1((const uint64_t*)p, vl);
+ __riscv_vse64_v_u64m1(result.u64, v, vl);
+ return result;
+#else
+ __m128i result;
+ memcpy(&result, p, sizeof(__m128i));
+ return result;
+#endif
+}
+
+static inline __m128i _mm_loadu_si128(const __m128i* p)
+{
+ __m128i result;
+ memcpy(&result, p, sizeof(__m128i));
+ return result;
+}
+
+static inline void _mm_store_si128(__m128i* p, __m128i a)
+{
+#if USE_RVV_INTRINSICS
+ size_t vl = __riscv_vsetvl_e64m1(2);
+ vuint64m1_t v = __riscv_vle64_v_u64m1(a.u64, vl);
+ __riscv_vse64_v_u64m1((uint64_t*)p, v, vl);
+#else
+ memcpy(p, &a, sizeof(__m128i));
+#endif
+}
+
+static inline void _mm_storeu_si128(__m128i* p, __m128i a)
+{
+ memcpy(p, &a, sizeof(__m128i));
+}
+
+/* Arithmetic operations - optimized with RVV */
+static inline __m128i _mm_add_epi64(__m128i a, __m128i b)
+{
+#if USE_RVV_INTRINSICS
+ __m128i result;
+ size_t vl = __riscv_vsetvl_e64m1(2);
+ vuint64m1_t va = __riscv_vle64_v_u64m1(a.u64, vl);
+ vuint64m1_t vb = __riscv_vle64_v_u64m1(b.u64, vl);
+ vuint64m1_t vr = __riscv_vadd_vv_u64m1(va, vb, vl);
+ __riscv_vse64_v_u64m1(result.u64, vr, vl);
+ return result;
+#else
+ __m128i result;
+ result.u64[0] = a.u64[0] + b.u64[0];
+ result.u64[1] = a.u64[1] + b.u64[1];
+ return result;
+#endif
+}
+
+static inline __m128i _mm_add_epi32(__m128i a, __m128i b)
+{
+#if USE_RVV_INTRINSICS
+ __m128i result;
+ size_t vl = __riscv_vsetvl_e32m1(4);
+ vuint32m1_t va = __riscv_vle32_v_u32m1(a.u32, vl);
+ vuint32m1_t vb = __riscv_vle32_v_u32m1(b.u32, vl);
+ vuint32m1_t vr = __riscv_vadd_vv_u32m1(va, vb, vl);
+ __riscv_vse32_v_u32m1(result.u32, vr, vl);
+ return result;
+#else
+ __m128i result;
+ for (int i = 0; i < 4; i++) {
+ result.i32[i] = a.i32[i] + b.i32[i];
+ }
+ return result;
+#endif
+}
+
+static inline __m128i _mm_sub_epi64(__m128i a, __m128i b)
+{
+#if USE_RVV_INTRINSICS
+ __m128i result;
+ size_t vl = __riscv_vsetvl_e64m1(2);
+ vuint64m1_t va = __riscv_vle64_v_u64m1(a.u64, vl);
+ vuint64m1_t vb = __riscv_vle64_v_u64m1(b.u64, vl);
+ vuint64m1_t vr = __riscv_vsub_vv_u64m1(va, vb, vl);
+ __riscv_vse64_v_u64m1(result.u64, vr, vl);
+ return result;
+#else
+ __m128i result;
+ result.u64[0] = a.u64[0] - b.u64[0];
+ result.u64[1] = a.u64[1] - b.u64[1];
+ return result;
+#endif
+}
+
+static inline __m128i _mm_mul_epu32(__m128i a, __m128i b)
+{
+#if USE_RVV_INTRINSICS
+ __m128i result;
+ size_t vl = __riscv_vsetvl_e64m1(2);
+ vuint64m1_t va_lo = __riscv_vzext_vf2_u64m1(__riscv_vle32_v_u32mf2(&a.u32[0], 2), vl);
+ vuint64m1_t vb_lo = __riscv_vzext_vf2_u64m1(__riscv_vle32_v_u32mf2(&b.u32[0], 2), vl);
+ vuint64m1_t vr = __riscv_vmul_vv_u64m1(va_lo, vb_lo, vl);
+ __riscv_vse64_v_u64m1(result.u64, vr, vl);
+ return result;
+#else
+ __m128i result;
+ result.u64[0] = (uint64_t)a.u32[0] * (uint64_t)b.u32[0];
+ result.u64[1] = (uint64_t)a.u32[2] * (uint64_t)b.u32[2];
+ return result;
+#endif
+}
+
+/* Unpack operations */
+static inline __m128i _mm_unpacklo_epi64(__m128i a, __m128i b)
+{
+ __m128i result;
+ result.u64[0] = a.u64[0];
+ result.u64[1] = b.u64[0];
+ return result;
+}
+
+static inline __m128i _mm_unpackhi_epi64(__m128i a, __m128i b)
+{
+ __m128i result;
+ result.u64[0] = a.u64[1];
+ result.u64[1] = b.u64[1];
+ return result;
+}
+
+/* Pause instruction for spin-wait loops */
+static inline void _mm_pause(void)
+{
+ /* RISC-V pause hint if available (requires Zihintpause extension) */
+#if defined(__riscv_zihintpause)
+ __asm__ __volatile__("pause");
+#else
+ __asm__ __volatile__("nop");
+#endif
+}
+
+/* Memory fence - optimized for RISC-V */
+static inline void _mm_mfence(void)
+{
+ __asm__ __volatile__("fence rw,rw" ::: "memory");
+}
+
+static inline void _mm_lfence(void)
+{
+ __asm__ __volatile__("fence r,r" ::: "memory");
+}
+
+static inline void _mm_sfence(void)
+{
+ __asm__ __volatile__("fence w,w" ::: "memory");
+}
+
+/* Comparison operations */
+static inline __m128i _mm_cmpeq_epi32(__m128i a, __m128i b)
+{
+ __m128i result;
+ for (int i = 0; i < 4; i++) {
+ result.u32[i] = (a.u32[i] == b.u32[i]) ? 0xFFFFFFFF : 0;
+ }
+ return result;
+}
+
+static inline __m128i _mm_cmpeq_epi64(__m128i a, __m128i b)
+{
+ __m128i result;
+ for (int i = 0; i < 2; i++) {
+ result.u64[i] = (a.u64[i] == b.u64[i]) ? 0xFFFFFFFFFFFFFFFFULL : 0;
+ }
+ return result;
+}
+
+/* Additional shift operations */
+static inline __m128i _mm_slli_epi32(__m128i a, int imm8)
+{
+#if USE_RVV_INTRINSICS
+ __m128i result;
+ if (imm8 > 31) {
+ memset(&result, 0, sizeof(result));
+ } else {
+ size_t vl = __riscv_vsetvl_e32m1(4);
+ vuint32m1_t va = __riscv_vle32_v_u32m1(a.u32, vl);
+ vuint32m1_t vr = __riscv_vsll_vx_u32m1(va, imm8, vl);
+ __riscv_vse32_v_u32m1(result.u32, vr, vl);
+ }
+ return result;
+#else
+ __m128i result;
+ if (imm8 > 31) {
+ for (int i = 0; i < 4; i++) result.u32[i] = 0;
+ } else {
+ for (int i = 0; i < 4; i++) {
+ result.u32[i] = a.u32[i] << imm8;
+ }
+ }
+ return result;
+#endif
+}
+
+static inline __m128i _mm_srli_epi32(__m128i a, int imm8)
+{
+#if USE_RVV_INTRINSICS
+ __m128i result;
+ if (imm8 > 31) {
+ memset(&result, 0, sizeof(result));
+ } else {
+ size_t vl = __riscv_vsetvl_e32m1(4);
+ vuint32m1_t va = __riscv_vle32_v_u32m1(a.u32, vl);
+ vuint32m1_t vr = __riscv_vsrl_vx_u32m1(va, imm8, vl);
+ __riscv_vse32_v_u32m1(result.u32, vr, vl);
+ }
+ return result;
+#else
+ __m128i result;
+ if (imm8 > 31) {
+ for (int i = 0; i < 4; i++) result.u32[i] = 0;
+ } else {
+ for (int i = 0; i < 4; i++) {
+ result.u32[i] = a.u32[i] >> imm8;
+ }
+ }
+ return result;
+#endif
+}
+
+/* 64-bit integer operations */
+static inline __m128i _mm_set1_epi64x(int64_t a)
+{
+ __m128i result;
+ result.i64[0] = a;
+ result.i64[1] = a;
+ return result;
+}
+
+/* Float type for compatibility */
+typedef __m128i __m128;
+
+/* Float operations - simplified scalar implementations */
+static inline __m128 _mm_set1_ps(float a)
+{
+ __m128 result;
+ uint32_t val;
+ memcpy(&val, &a, sizeof(float));
+ for (int i = 0; i < 4; i++) {
+ result.u32[i] = val;
+ }
+ return result;
+}
+
+static inline __m128 _mm_setzero_ps(void)
+{
+ __m128 result;
+ memset(&result, 0, sizeof(result));
+ return result;
+}
+
+static inline __m128 _mm_add_ps(__m128 a, __m128 b)
+{
+ __m128 result;
+ float fa[4], fb[4], fr[4];
+ memcpy(fa, &a, sizeof(__m128));
+ memcpy(fb, &b, sizeof(__m128));
+ for (int i = 0; i < 4; i++) {
+ fr[i] = fa[i] + fb[i];
+ }
+ memcpy(&result, fr, sizeof(__m128));
+ return result;
+}
+
+static inline __m128 _mm_mul_ps(__m128 a, __m128 b)
+{
+ __m128 result;
+ float fa[4], fb[4], fr[4];
+ memcpy(fa, &a, sizeof(__m128));
+ memcpy(fb, &b, sizeof(__m128));
+ for (int i = 0; i < 4; i++) {
+ fr[i] = fa[i] * fb[i];
+ }
+ memcpy(&result, fr, sizeof(__m128));
+ return result;
+}
+
+static inline __m128 _mm_and_ps(__m128 a, __m128 b)
+{
+ __m128 result;
+ result.u64[0] = a.u64[0] & b.u64[0];
+ result.u64[1] = a.u64[1] & b.u64[1];
+ return result;
+}
+
+static inline __m128 _mm_or_ps(__m128 a, __m128 b)
+{
+ __m128 result;
+ result.u64[0] = a.u64[0] | b.u64[0];
+ result.u64[1] = a.u64[1] | b.u64[1];
+ return result;
+}
+
+static inline __m128 _mm_cvtepi32_ps(__m128i a)
+{
+ __m128 result;
+ float fr[4];
+ for (int i = 0; i < 4; i++) {
+ fr[i] = (float)a.i32[i];
+ }
+ memcpy(&result, fr, sizeof(__m128));
+ return result;
+}
+
+static inline __m128i _mm_cvttps_epi32(__m128 a)
+{
+ __m128i result;
+ float fa[4];
+ memcpy(fa, &a, sizeof(__m128));
+ for (int i = 0; i < 4; i++) {
+ result.i32[i] = (int32_t)fa[i];
+ }
+ return result;
+}
+
+/* Casting operations */
+static inline __m128 _mm_castsi128_ps(__m128i a)
+{
+ __m128 result;
+ memcpy(&result, &a, sizeof(__m128));
+ return result;
+}
+
+static inline __m128i _mm_castps_si128(__m128 a)
+{
+ __m128i result;
+ memcpy(&result, &a, sizeof(__m128));
+ return result;
+}
+
+/* Additional set operations */
+static inline __m128i _mm_set1_epi32(int a)
+{
+ __m128i result;
+ for (int i = 0; i < 4; i++) {
+ result.i32[i] = a;
+ }
+ return result;
+}
+
+/* AES instructions - placeholders for soft_aes compatibility */
+static inline __m128i _mm_aesenc_si128(__m128i a, __m128i roundkey)
+{
+ return _mm_xor_si128(a, roundkey);
+}
+
+static inline __m128i _mm_aeskeygenassist_si128(__m128i a, const int rcon)
+{
+ return a;
+}
+
+/* Rotate right operation for soft_aes.h */
+static inline uint32_t _rotr(uint32_t value, unsigned int count)
+{
+ const unsigned int mask = 31;
+ count &= mask;
+ return (value >> count) | (value << ((-count) & mask));
+}
+
+/* ARM NEON compatibility types and intrinsics for RISC-V */
+typedef __m128i_union uint64x2_t;
+typedef __m128i_union uint8x16_t;
+typedef __m128i_union int64x2_t;
+typedef __m128i_union int32x4_t;
+
+static inline uint64x2_t vld1q_u64(const uint64_t *ptr)
+{
+ uint64x2_t result;
+ result.u64[0] = ptr[0];
+ result.u64[1] = ptr[1];
+ return result;
+}
+
+static inline int64x2_t vld1q_s64(const int64_t *ptr)
+{
+ int64x2_t result;
+ result.i64[0] = ptr[0];
+ result.i64[1] = ptr[1];
+ return result;
+}
+
+static inline void vst1q_u64(uint64_t *ptr, uint64x2_t val)
+{
+ ptr[0] = val.u64[0];
+ ptr[1] = val.u64[1];
+}
+
+static inline uint64x2_t veorq_u64(uint64x2_t a, uint64x2_t b)
+{
+ return _mm_xor_si128(a, b);
+}
+
+static inline uint64x2_t vaddq_u64(uint64x2_t a, uint64x2_t b)
+{
+ return _mm_add_epi64(a, b);
+}
+
+static inline uint64x2_t vreinterpretq_u64_u8(uint8x16_t a)
+{
+ uint64x2_t result;
+ memcpy(&result, &a, sizeof(uint64x2_t));
+ return result;
+}
+
+static inline uint64_t vgetq_lane_u64(uint64x2_t v, int lane)
+{
+ return v.u64[lane];
+}
+
+static inline int64_t vgetq_lane_s64(int64x2_t v, int lane)
+{
+ return v.i64[lane];
+}
+
+static inline int32_t vgetq_lane_s32(int32x4_t v, int lane)
+{
+ return v.i32[lane];
+}
+
+typedef struct { uint64_t val[1]; } uint64x1_t;
+
+static inline uint64x1_t vcreate_u64(uint64_t a)
+{
+ uint64x1_t result;
+ result.val[0] = a;
+ return result;
+}
+
+static inline uint64x2_t vcombine_u64(uint64x1_t low, uint64x1_t high)
+{
+ uint64x2_t result;
+ result.u64[0] = low.val[0];
+ result.u64[1] = high.val[0];
+ return result;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* XMRIG_SSE2RVV_OPTIMIZED_H */
diff --git a/src/crypto/cn/sse2rvv_scalar_backup.h b/src/crypto/cn/sse2rvv_scalar_backup.h
new file mode 100644
index 0000000..853adbb
--- /dev/null
+++ b/src/crypto/cn/sse2rvv_scalar_backup.h
@@ -0,0 +1,571 @@
+/* XMRig
+ * Copyright (c) 2025 XMRig <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*
+ * SSE to RISC-V compatibility header
+ * Provides scalar implementations of SSE intrinsics for RISC-V architecture
+ */
+
+#ifndef XMRIG_SSE2RVV_H
+#define XMRIG_SSE2RVV_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+#include <string.h>
+
+/* 128-bit vector type */
+typedef union {
+ uint8_t u8[16];
+ uint16_t u16[8];
+ uint32_t u32[4];
+ uint64_t u64[2];
+ int8_t i8[16];
+ int16_t i16[8];
+ int32_t i32[4];
+ int64_t i64[2];
+} __m128i_union;
+
+typedef __m128i_union __m128i;
+
+/* Set operations */
+static inline __m128i _mm_set_epi32(int e3, int e2, int e1, int e0)
+{
+ __m128i result;
+ result.i32[0] = e0;
+ result.i32[1] = e1;
+ result.i32[2] = e2;
+ result.i32[3] = e3;
+ return result;
+}
+
+static inline __m128i _mm_set_epi64x(int64_t e1, int64_t e0)
+{
+ __m128i result;
+ result.i64[0] = e0;
+ result.i64[1] = e1;
+ return result;
+}
+
+static inline __m128i _mm_setzero_si128(void)
+{
+ __m128i result;
+ memset(&result, 0, sizeof(result));
+ return result;
+}
+
+/* Extract/insert operations */
+static inline int _mm_cvtsi128_si32(__m128i a)
+{
+ return a.i32[0];
+}
+
+static inline int64_t _mm_cvtsi128_si64(__m128i a)
+{
+ return a.i64[0];
+}
+
+static inline __m128i _mm_cvtsi32_si128(int a)
+{
+ __m128i result = _mm_setzero_si128();
+ result.i32[0] = a;
+ return result;
+}
+
+static inline __m128i _mm_cvtsi64_si128(int64_t a)
+{
+ __m128i result = _mm_setzero_si128();
+ result.i64[0] = a;
+ return result;
+}
+
+/* Shuffle operations */
+static inline __m128i _mm_shuffle_epi32(__m128i a, int imm8)
+{
+ __m128i result;
+ result.u32[0] = a.u32[(imm8 >> 0) & 0x3];
+ result.u32[1] = a.u32[(imm8 >> 2) & 0x3];
+ result.u32[2] = a.u32[(imm8 >> 4) & 0x3];
+ result.u32[3] = a.u32[(imm8 >> 6) & 0x3];
+ return result;
+}
+
+/* Logical operations */
+static inline __m128i _mm_xor_si128(__m128i a, __m128i b)
+{
+ __m128i result;
+ result.u64[0] = a.u64[0] ^ b.u64[0];
+ result.u64[1] = a.u64[1] ^ b.u64[1];
+ return result;
+}
+
+static inline __m128i _mm_or_si128(__m128i a, __m128i b)
+{
+ __m128i result;
+ result.u64[0] = a.u64[0] | b.u64[0];
+ result.u64[1] = a.u64[1] | b.u64[1];
+ return result;
+}
+
+static inline __m128i _mm_and_si128(__m128i a, __m128i b)
+{
+ __m128i result;
+ result.u64[0] = a.u64[0] & b.u64[0];
+ result.u64[1] = a.u64[1] & b.u64[1];
+ return result;
+}
+
+static inline __m128i _mm_andnot_si128(__m128i a, __m128i b)
+{
+ __m128i result;
+ result.u64[0] = (~a.u64[0]) & b.u64[0];
+ result.u64[1] = (~a.u64[1]) & b.u64[1];
+ return result;
+}
+
+/* Shift operations */
+static inline __m128i _mm_slli_si128(__m128i a, int imm8)
+{
+ __m128i result = _mm_setzero_si128();
+ int count = imm8 & 0xFF;
+ if (count > 15) return result;
+
+ for (int i = 0; i < 16 - count; i++) {
+ result.u8[i + count] = a.u8[i];
+ }
+ return result;
+}
+
+static inline __m128i _mm_srli_si128(__m128i a, int imm8)
+{
+ __m128i result = _mm_setzero_si128();
+ int count = imm8 & 0xFF;
+ if (count > 15) return result;
+
+ for (int i = count; i < 16; i++) {
+ result.u8[i - count] = a.u8[i];
+ }
+ return result;
+}
+
+static inline __m128i _mm_slli_epi64(__m128i a, int imm8)
+{
+ __m128i result;
+ if (imm8 > 63) {
+ result.u64[0] = 0;
+ result.u64[1] = 0;
+ } else {
+ result.u64[0] = a.u64[0] << imm8;
+ result.u64[1] = a.u64[1] << imm8;
+ }
+ return result;
+}
+
+static inline __m128i _mm_srli_epi64(__m128i a, int imm8)
+{
+ __m128i result;
+ if (imm8 > 63) {
+ result.u64[0] = 0;
+ result.u64[1] = 0;
+ } else {
+ result.u64[0] = a.u64[0] >> imm8;
+ result.u64[1] = a.u64[1] >> imm8;
+ }
+ return result;
+}
+
+/* Load/store operations */
+static inline __m128i _mm_load_si128(const __m128i* p)
+{
+ __m128i result;
+ memcpy(&result, p, sizeof(__m128i));
+ return result;
+}
+
+static inline __m128i _mm_loadu_si128(const __m128i* p)
+{
+ __m128i result;
+ memcpy(&result, p, sizeof(__m128i));
+ return result;
+}
+
+static inline void _mm_store_si128(__m128i* p, __m128i a)
+{
+ memcpy(p, &a, sizeof(__m128i));
+}
+
+static inline void _mm_storeu_si128(__m128i* p, __m128i a)
+{
+ memcpy(p, &a, sizeof(__m128i));
+}
+
+/* Arithmetic operations */
+static inline __m128i _mm_add_epi64(__m128i a, __m128i b)
+{
+ __m128i result;
+ result.u64[0] = a.u64[0] + b.u64[0];
+ result.u64[1] = a.u64[1] + b.u64[1];
+ return result;
+}
+
+static inline __m128i _mm_add_epi32(__m128i a, __m128i b)
+{
+ __m128i result;
+ for (int i = 0; i < 4; i++) {
+ result.i32[i] = a.i32[i] + b.i32[i];
+ }
+ return result;
+}
+
+static inline __m128i _mm_sub_epi64(__m128i a, __m128i b)
+{
+ __m128i result;
+ result.u64[0] = a.u64[0] - b.u64[0];
+ result.u64[1] = a.u64[1] - b.u64[1];
+ return result;
+}
+
+static inline __m128i _mm_mul_epu32(__m128i a, __m128i b)
+{
+ __m128i result;
+ result.u64[0] = (uint64_t)a.u32[0] * (uint64_t)b.u32[0];
+ result.u64[1] = (uint64_t)a.u32[2] * (uint64_t)b.u32[2];
+ return result;
+}
+
+/* Unpack operations */
+static inline __m128i _mm_unpacklo_epi64(__m128i a, __m128i b)
+{
+ __m128i result;
+ result.u64[0] = a.u64[0];
+ result.u64[1] = b.u64[0];
+ return result;
+}
+
+static inline __m128i _mm_unpackhi_epi64(__m128i a, __m128i b)
+{
+ __m128i result;
+ result.u64[0] = a.u64[1];
+ result.u64[1] = b.u64[1];
+ return result;
+}
+
+/* Pause instruction for spin-wait loops */
+static inline void _mm_pause(void)
+{
+ /* RISC-V doesn't have a direct equivalent to x86 PAUSE
+ * Use a simple NOP or yield hint */
+ __asm__ __volatile__("nop");
+}
+
+/* Memory fence */
+static inline void _mm_mfence(void)
+{
+ __asm__ __volatile__("fence" ::: "memory");
+}
+
+static inline void _mm_lfence(void)
+{
+ __asm__ __volatile__("fence r,r" ::: "memory");
+}
+
+static inline void _mm_sfence(void)
+{
+ __asm__ __volatile__("fence w,w" ::: "memory");
+}
+
+/* Comparison operations */
+static inline __m128i _mm_cmpeq_epi32(__m128i a, __m128i b)
+{
+ __m128i result;
+ for (int i = 0; i < 4; i++) {
+ result.u32[i] = (a.u32[i] == b.u32[i]) ? 0xFFFFFFFF : 0;
+ }
+ return result;
+}
+
+static inline __m128i _mm_cmpeq_epi64(__m128i a, __m128i b)
+{
+ __m128i result;
+ for (int i = 0; i < 2; i++) {
+ result.u64[i] = (a.u64[i] == b.u64[i]) ? 0xFFFFFFFFFFFFFFFFULL : 0;
+ }
+ return result;
+}
+
+/* Additional shift operations */
+static inline __m128i _mm_slli_epi32(__m128i a, int imm8)
+{
+ __m128i result;
+ if (imm8 > 31) {
+ for (int i = 0; i < 4; i++) result.u32[i] = 0;
+ } else {
+ for (int i = 0; i < 4; i++) {
+ result.u32[i] = a.u32[i] << imm8;
+ }
+ }
+ return result;
+}
+
+static inline __m128i _mm_srli_epi32(__m128i a, int imm8)
+{
+ __m128i result;
+ if (imm8 > 31) {
+ for (int i = 0; i < 4; i++) result.u32[i] = 0;
+ } else {
+ for (int i = 0; i < 4; i++) {
+ result.u32[i] = a.u32[i] >> imm8;
+ }
+ }
+ return result;
+}
+
+/* 64-bit integer operations */
+static inline __m128i _mm_set1_epi64x(int64_t a)
+{
+ __m128i result;
+ result.i64[0] = a;
+ result.i64[1] = a;
+ return result;
+}
+
+/* Float type for compatibility - we'll treat it as int for simplicity */
+typedef __m128i __m128;
+
+/* Float operations - simplified scalar implementations */
+static inline __m128 _mm_set1_ps(float a)
+{
+ __m128 result;
+ uint32_t val;
+ memcpy(&val, &a, sizeof(float));
+ for (int i = 0; i < 4; i++) {
+ result.u32[i] = val;
+ }
+ return result;
+}
+
+static inline __m128 _mm_setzero_ps(void)
+{
+ __m128 result;
+ memset(&result, 0, sizeof(result));
+ return result;
+}
+
+static inline __m128 _mm_add_ps(__m128 a, __m128 b)
+{
+ __m128 result;
+ float fa[4], fb[4], fr[4];
+ memcpy(fa, &a, sizeof(__m128));
+ memcpy(fb, &b, sizeof(__m128));
+ for (int i = 0; i < 4; i++) {
+ fr[i] = fa[i] + fb[i];
+ }
+ memcpy(&result, fr, sizeof(__m128));
+ return result;
+}
+
+static inline __m128 _mm_mul_ps(__m128 a, __m128 b)
+{
+ __m128 result;
+ float fa[4], fb[4], fr[4];
+ memcpy(fa, &a, sizeof(__m128));
+ memcpy(fb, &b, sizeof(__m128));
+ for (int i = 0; i < 4; i++) {
+ fr[i] = fa[i] * fb[i];
+ }
+ memcpy(&result, fr, sizeof(__m128));
+ return result;
+}
+
+static inline __m128 _mm_and_ps(__m128 a, __m128 b)
+{
+ __m128 result;
+ result.u64[0] = a.u64[0] & b.u64[0];
+ result.u64[1] = a.u64[1] & b.u64[1];
+ return result;
+}
+
+static inline __m128 _mm_or_ps(__m128 a, __m128 b)
+{
+ __m128 result;
+ result.u64[0] = a.u64[0] | b.u64[0];
+ result.u64[1] = a.u64[1] | b.u64[1];
+ return result;
+}
+
+static inline __m128 _mm_cvtepi32_ps(__m128i a)
+{
+ __m128 result;
+ float fr[4];
+ for (int i = 0; i < 4; i++) {
+ fr[i] = (float)a.i32[i];
+ }
+ memcpy(&result, fr, sizeof(__m128));
+ return result;
+}
+
+static inline __m128i _mm_cvttps_epi32(__m128 a)
+{
+ __m128i result;
+ float fa[4];
+ memcpy(fa, &a, sizeof(__m128));
+ for (int i = 0; i < 4; i++) {
+ result.i32[i] = (int32_t)fa[i];
+ }
+ return result;
+}
+
+/* Casting operations */
+static inline __m128 _mm_castsi128_ps(__m128i a)
+{
+ __m128 result;
+ memcpy(&result, &a, sizeof(__m128));
+ return result;
+}
+
+static inline __m128i _mm_castps_si128(__m128 a)
+{
+ __m128i result;
+ memcpy(&result, &a, sizeof(__m128));
+ return result;
+}
+
+/* Additional set operations */
+static inline __m128i _mm_set1_epi32(int a)
+{
+ __m128i result;
+ for (int i = 0; i < 4; i++) {
+ result.i32[i] = a;
+ }
+ return result;
+}
+
+/* AES instructions - these are placeholders, actual AES is done via soft_aes.h */
+/* On RISC-V without crypto extensions, these should never be called directly */
+/* They are only here for compilation compatibility */
+static inline __m128i _mm_aesenc_si128(__m128i a, __m128i roundkey)
+{
+ /* This is a placeholder - actual implementation should use soft_aes */
+ /* If this function is called, it means SOFT_AES template parameter wasn't used */
+ /* We return a XOR as a minimal fallback, but proper code should use soft_aesenc */
+ return _mm_xor_si128(a, roundkey);
+}
+
+static inline __m128i _mm_aeskeygenassist_si128(__m128i a, const int rcon)
+{
+ /* Placeholder for AES key generation - should use soft_aeskeygenassist */
+ return a;
+}
+
+/* Rotate right operation for soft_aes.h */
+static inline uint32_t _rotr(uint32_t value, unsigned int count)
+{
+ const unsigned int mask = 31;
+ count &= mask;
+ return (value >> count) | (value << ((-count) & mask));
+}
+
+/* ARM NEON compatibility types and intrinsics for RISC-V */
+typedef __m128i_union uint64x2_t;
+typedef __m128i_union uint8x16_t;
+typedef __m128i_union int64x2_t;
+typedef __m128i_union int32x4_t;
+
+static inline uint64x2_t vld1q_u64(const uint64_t *ptr)
+{
+ uint64x2_t result;
+ result.u64[0] = ptr[0];
+ result.u64[1] = ptr[1];
+ return result;
+}
+
+static inline int64x2_t vld1q_s64(const int64_t *ptr)
+{
+ int64x2_t result;
+ result.i64[0] = ptr[0];
+ result.i64[1] = ptr[1];
+ return result;
+}
+
+static inline void vst1q_u64(uint64_t *ptr, uint64x2_t val)
+{
+ ptr[0] = val.u64[0];
+ ptr[1] = val.u64[1];
+}
+
+static inline uint64x2_t veorq_u64(uint64x2_t a, uint64x2_t b)
+{
+ uint64x2_t result;
+ result.u64[0] = a.u64[0] ^ b.u64[0];
+ result.u64[1] = a.u64[1] ^ b.u64[1];
+ return result;
+}
+
+static inline uint64x2_t vaddq_u64(uint64x2_t a, uint64x2_t b)
+{
+ uint64x2_t result;
+ result.u64[0] = a.u64[0] + b.u64[0];
+ result.u64[1] = a.u64[1] + b.u64[1];
+ return result;
+}
+
+static inline uint64x2_t vreinterpretq_u64_u8(uint8x16_t a)
+{
+ uint64x2_t result;
+ memcpy(&result, &a, sizeof(uint64x2_t));
+ return result;
+}
+
+static inline uint64_t vgetq_lane_u64(uint64x2_t v, int lane)
+{
+ return v.u64[lane];
+}
+
+static inline int64_t vgetq_lane_s64(int64x2_t v, int lane)
+{
+ return v.i64[lane];
+}
+
+static inline int32_t vgetq_lane_s32(int32x4_t v, int lane)
+{
+ return v.i32[lane];
+}
+
+typedef struct { uint64_t val[1]; } uint64x1_t;
+
+static inline uint64x1_t vcreate_u64(uint64_t a)
+{
+ uint64x1_t result;
+ result.val[0] = a;
+ return result;
+}
+
+static inline uint64x2_t vcombine_u64(uint64x1_t low, uint64x1_t high)
+{
+ uint64x2_t result;
+ result.u64[0] = low.val[0];
+ result.u64[1] = high.val[0];
+ return result;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* XMRIG_SSE2RVV_H */
diff --git a/src/crypto/common/portable/mm_malloc.h b/src/crypto/common/portable/mm_malloc.h
index 34ca7d4..388da64 100644
--- a/src/crypto/common/portable/mm_malloc.h
+++ b/src/crypto/common/portable/mm_malloc.h
@@ -26,7 +26,7 @@
#define XMRIG_MM_MALLOC_PORTABLE_H
-#if defined(XMRIG_ARM) && !defined(__clang__)
+#if (defined(XMRIG_ARM) || defined(XMRIG_RISCV)) && !defined(__clang__)
#include <stdlib.h>
diff --git a/src/crypto/ghostrider/ghostrider.cpp b/src/crypto/ghostrider/ghostrider.cpp
index 25bb44e..4a21ae0 100644
--- a/src/crypto/ghostrider/ghostrider.cpp
+++ b/src/crypto/ghostrider/ghostrider.cpp
@@ -57,6 +57,9 @@
#if defined(XMRIG_ARM)
# include "crypto/cn/sse2neon.h"
+#elif defined(XMRIG_RISCV)
+ // RISC-V doesn't have SSE/NEON, provide minimal compatibility
+# define _mm_pause() __asm__ __volatile__("nop")
#elif defined(__GNUC__)
# include <x86intrin.h>
#else
@@ -286,7 +289,7 @@ struct HelperThread
void benchmark()
{
-#ifndef XMRIG_ARM
+#if !defined(XMRIG_ARM) && !defined(XMRIG_RISCV)
static std::atomic<int> done{ 0 };
if (done.exchange(1)) {
return;
@@ -478,7 +481,7 @@ static inline bool findByType(hwloc_obj_t obj, hwloc_obj_type_t type, func lambd
HelperThread* create_helper_thread(int64_t cpu_index, int priority, const std::vector<int64_t>& affinities)
{
-#ifndef XMRIG_ARM
+#if !defined(XMRIG_ARM) && !defined(XMRIG_RISCV)
hwloc_bitmap_t helper_cpu_set = hwloc_bitmap_alloc();
hwloc_bitmap_t main_threads_set = hwloc_bitmap_alloc();
@@ -807,7 +810,7 @@ void hash_octa(const uint8_t* data, size_t size, uint8_t* output, cryptonight_ct
uint32_t cn_indices[6];
select_indices(cn_indices, seed);
-#ifdef XMRIG_ARM
+#if defined(XMRIG_ARM) || defined(XMRIG_RISCV)
uint32_t step[6] = { 1, 1, 1, 1, 1, 1 };
#else
uint32_t step[6] = { 4, 4, 1, 2, 4, 4 };
diff --git a/src/crypto/riscv/riscv_crypto.h b/src/crypto/riscv/riscv_crypto.h
new file mode 100644
index 0000000..4e04892
--- /dev/null
+++ b/src/crypto/riscv/riscv_crypto.h
@@ -0,0 +1,186 @@
+/* XMRig
+ * Copyright (c) 2025 XMRig <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*
+ * RISC-V Crypto Extensions (Zbk*) Support
+ *
+ * Supports detection and usage of RISC-V crypto extensions:
+ * - Zkn: NIST approved cryptographic extensions (AES, SHA2, SHA3)
+ * - Zknd/Zkne: AES decryption/encryption
+ * - Zknh: SHA2/SHA3 hash extensions
+ * - Zkb: Bit manipulation extensions (Zba, Zbb, Zbc, Zbs)
+ *
+ * Falls back gracefully to software implementations on systems without support.
+ */
+
+#ifndef XMRIG_RISCV_CRYPTO_H
+#define XMRIG_RISCV_CRYPTO_H
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if defined(XMRIG_RISCV)
+
+/* Check if RISC-V crypto extensions are available at compile time */
+#if defined(__riscv_zkne) || defined(__riscv_zknd)
+#define HAVE_RISCV_AES 1
+#else
+#define HAVE_RISCV_AES 0
+#endif
+
+#if defined(__riscv_zknh)
+#define HAVE_RISCV_SHA 1
+#else
+#define HAVE_RISCV_SHA 0
+#endif
+
+#if defined(__riscv_zba) && defined(__riscv_zbb) && defined(__riscv_zbc)
+#define HAVE_RISCV_BIT_MANIP 1
+#else
+#define HAVE_RISCV_BIT_MANIP 0
+#endif
+
+/* Detect CPU support at runtime via /proc/cpuinfo */
+extern bool riscv_cpu_has_aes_support(void);
+extern bool riscv_cpu_has_sha_support(void);
+extern bool riscv_cpu_has_bitmanip_support(void);
+
+/* Software fallback AES utilities optimized for RISC-V */
+
+/* AES S-box lookup - cache-friendly implementation */
+typedef struct {
+ uint32_t sbox_enc[256];
+ uint32_t sbox_dec[256];
+} riscv_aes_sbox_t;
+
+extern const riscv_aes_sbox_t riscv_aes_tables;
+
+/* Software AES encryption round optimized for RISC-V */
+static inline uint32_t riscv_aes_enc_round(uint32_t input, const uint32_t *round_key)
+{
+ uint32_t result = 0;
+
+ /* Unroll byte-by-byte lookups for better instruction-level parallelism */
+ uint32_t b0 = (input >> 0) & 0xFF;
+ uint32_t b1 = (input >> 8) & 0xFF;
+ uint32_t b2 = (input >> 16) & 0xFF;
+ uint32_t b3 = (input >> 24) & 0xFF;
+
+ result = riscv_aes_tables.sbox_enc[b0] ^
+ riscv_aes_tables.sbox_enc[b1] ^
+ riscv_aes_tables.sbox_enc[b2] ^
+ riscv_aes_tables.sbox_enc[b3];
+
+ return result ^ (*round_key);
+}
+
+/* Bit rotation optimized for RISC-V */
+static inline uint32_t riscv_rotr32(uint32_t x, int r)
+{
+#if defined(__riscv_zbb)
+ /* Use RISC-V bit rotation if available */
+ uint32_t result;
+ asm volatile ("ror %0, %1, %2" : "=r"(result) : "r"(x), "r"(r) : );
+ return result;
+#else
+ /* Scalar fallback */
+ return (x >> r) | (x << (32 - r));
+#endif
+}
+
+static inline uint64_t riscv_rotr64(uint64_t x, int r)
+{
+#if defined(__riscv_zbb)
+ /* Use RISC-V bit rotation if available */
+ uint64_t result;
+ asm volatile ("ror %0, %1, %2" : "=r"(result) : "r"(x), "r"(r) : );
+ return result;
+#else
+ /* Scalar fallback */
+ return (x >> r) | (x << (64 - r));
+#endif
+}
+
+/* Bit count operations optimized for RISC-V */
+static inline int riscv_popcount(uint64_t x)
+{
+#if defined(__riscv_zbb)
+ /* Use hardware popcount if available */
+ int result;
+ asm volatile ("cpop %0, %1" : "=r"(result) : "r"(x) : );
+ return result;
+#else
+ /* Scalar fallback */
+ return __builtin_popcountll(x);
+#endif
+}
+
+static inline int riscv_ctz(uint64_t x)
+{
+#if defined(__riscv_zbb)
+ /* Use hardware count trailing zeros if available */
+ int result;
+ asm volatile ("ctz %0, %1" : "=r"(result) : "r"(x) : );
+ return result;
+#else
+ /* Scalar fallback */
+ return __builtin_ctzll(x);
+#endif
+}
+
+/* Bit manipulation operations from Zba */
+static inline uint64_t riscv_add_uw(uint64_t a, uint64_t b)
+{
+#if defined(__riscv_zba)
+ /* Add unsigned word (add.uw) - zero extends 32-bit addition */
+ uint64_t result;
+ asm volatile ("add.uw %0, %1, %2" : "=r"(result) : "r"(a), "r"(b) : );
+ return result;
+#else
+ return ((a & 0xFFFFFFFF) + (b & 0xFFFFFFFF)) & 0xFFFFFFFF;
+#endif
+}
+
+#else /* !XMRIG_RISCV */
+
+/* Non-RISC-V fallbacks */
+#define HAVE_RISCV_AES 0
+#define HAVE_RISCV_SHA 0
+#define HAVE_RISCV_BIT_MANIP 0
+
+static inline bool riscv_cpu_has_aes_support(void) { return false; }
+static inline bool riscv_cpu_has_sha_support(void) { return false; }
+static inline bool riscv_cpu_has_bitmanip_support(void) { return false; }
+
+static inline uint32_t riscv_rotr32(uint32_t x, int r) { return (x >> r) | (x << (32 - r)); }
+static inline uint64_t riscv_rotr64(uint64_t x, int r) { return (x >> r) | (x << (64 - r)); }
+static inline int riscv_popcount(uint64_t x) { return __builtin_popcountll(x); }
+static inline int riscv_ctz(uint64_t x) { return __builtin_ctzll(x); }
+static inline uint64_t riscv_add_uw(uint64_t a, uint64_t b) { return (a & 0xFFFFFFFF) + (b & 0xFFFFFFFF); }
+
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // XMRIG_RISCV_CRYPTO_H
diff --git a/src/crypto/riscv/riscv_memory.h b/src/crypto/riscv/riscv_memory.h
new file mode 100644
index 0000000..f2dc9b1
--- /dev/null
+++ b/src/crypto/riscv/riscv_memory.h
@@ -0,0 +1,283 @@
+/* XMRig
+ * Copyright (c) 2025 XMRig <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*
+ * RISC-V optimized memory operations
+ *
+ * Provides efficient:
+ * - Memory barriers
+ * - Cache line operations
+ * - Prefetching hints
+ * - Aligned memory access
+ * - Memory pooling utilities
+ */
+
+#ifndef XMRIG_RISCV_MEMORY_H
+#define XMRIG_RISCV_MEMORY_H
+
+#include <stdint.h>
+#include <stddef.h>
+#include <string.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if defined(XMRIG_RISCV)
+
+#define CACHELINE_SIZE 64
+#define CACHELINE_MASK (~(CACHELINE_SIZE - 1))
+
+/* Memory barriers - optimized for RISC-V */
+
+/* Full memory barrier: all reads and writes before must complete before any after */
+static inline void riscv_mfence(void)
+{
+ asm volatile ("fence rw,rw" : : : "memory");
+}
+
+/* Load barrier: all loads before must complete before any after */
+static inline void riscv_lfence(void)
+{
+ asm volatile ("fence r,r" : : : "memory");
+}
+
+/* Store barrier: all stores before must complete before any after */
+static inline void riscv_sfence(void)
+{
+ asm volatile ("fence w,w" : : : "memory");
+}
+
+/* TSO (total store order) - ensures store-release semantics */
+static inline void riscv_fence_tso(void)
+{
+ asm volatile ("fence rw,w" : : : "memory");
+}
+
+/* Acquire barrier - for lock acquisition */
+static inline void riscv_acquire_fence(void)
+{
+ asm volatile ("fence r,rw" : : : "memory");
+}
+
+/* Release barrier - for lock release */
+static inline void riscv_release_fence(void)
+{
+ asm volatile ("fence rw,w" : : : "memory");
+}
+
+/* CPU pause hint (Zihintpause extension, falls back to NOP) */
+static inline void riscv_pause(void)
+{
+ asm volatile ("pause");
+}
+
+/* Prefetch operations - hints to load into L1 cache */
+
+/* Prefetch for read (temporal locality) */
+static inline void riscv_prefetch_read(const void *addr)
+{
+ /* Temporary workaround: use inline asm */
+ asm volatile ("# prefetch %0 \n" : : "m"(*(const char *)addr));
+}
+
+/* Prefetch for write (prepare for store) */
+static inline void riscv_prefetch_write(const void *addr)
+{
+ asm volatile ("# prefetch.w %0 \n" : : "m"(*(const char *)addr));
+}
+
+/* Prefetch with 0 temporal locality (load into L1 but not higher levels) */
+static inline void riscv_prefetch_nta(const void *addr)
+{
+ asm volatile ("# prefetch.nta %0 \n" : : "m"(*(const char *)addr));
+}
+
+/* Cache line flush (if supported) */
+static inline void riscv_clflush(const void *addr)
+{
+ /* RISC-V may not have cache flush in userspace */
+ /* This is a no-op unless running in privileged mode */
+ (void)addr;
+}
+
+/* Optimized memory copy with cache prefetching */
+static inline void riscv_memcpy_prefetch(void *dest, const void *src, size_t size)
+{
+ uint8_t *d = (uint8_t *)dest;
+ const uint8_t *s = (const uint8_t *)src;
+
+ /* Process in cache line sized chunks with prefetching */
+ size_t cache_lines = size / CACHELINE_SIZE;
+ for (size_t i = 0; i < cache_lines; ++i) {
+ /* Prefetch next cache lines ahead */
+ if (i + 4 < cache_lines) {
+ riscv_prefetch_read(s + (i + 4) * CACHELINE_SIZE);
+ }
+
+ /* Copy current cache line - use 64-bit accesses for efficiency */
+ const uint64_t *src64 = (const uint64_t *)(s + i * CACHELINE_SIZE);
+ uint64_t *dest64 = (uint64_t *)(d + i * CACHELINE_SIZE);
+
+ for (int j = 0; j < 8; ++j) { /* 8 * 8 bytes = 64 bytes */
+ dest64[j] = src64[j];
+ }
+ }
+
+ /* Handle remainder */
+ size_t remainder = size % CACHELINE_SIZE;
+ if (remainder > 0) {
+ memcpy(d + cache_lines * CACHELINE_SIZE,
+ s + cache_lines * CACHELINE_SIZE,
+ remainder);
+ }
+}
+
+/* Optimized memory fill with pattern */
+static inline void riscv_memfill64(void *dest, uint64_t value, size_t count)
+{
+ uint64_t *d = (uint64_t *)dest;
+
+ /* Unroll loop for better ILP */
+ size_t i = 0;
+ while (i + 8 <= count) {
+ d[i + 0] = value;
+ d[i + 1] = value;
+ d[i + 2] = value;
+ d[i + 3] = value;
+ d[i + 4] = value;
+ d[i + 5] = value;
+ d[i + 6] = value;
+ d[i + 7] = value;
+ i += 8;
+ }
+
+ /* Handle remainder */
+ while (i < count) {
+ d[i] = value;
+ i++;
+ }
+}
+
+/* Compare memory with early exit optimization */
+static inline int riscv_memcmp_fast(const void *s1, const void *s2, size_t n)
+{
+ const uint64_t *a = (const uint64_t *)s1;
+ const uint64_t *b = (const uint64_t *)s2;
+
+ size_t qwords = n / 8;
+ for (size_t i = 0; i < qwords; ++i) {
+ if (a[i] != b[i]) {
+ /* Use byte comparison to find first difference */
+ const uint8_t *ba = (const uint8_t *)a;
+ const uint8_t *bb = (const uint8_t *)b;
+ for (size_t j = i * 8; j < (i + 1) * 8 && j < n; ++j) {
+ if (ba[j] != bb[j]) {
+ return ba[j] - bb[j];
+ }
+ }
+ }
+ }
+
+ /* Check remainder */
+ size_t remainder = n % 8;
+ if (remainder > 0) {
+ const uint8_t *ba = (const uint8_t *)s1 + qwords * 8;
+ const uint8_t *bb = (const uint8_t *)s2 + qwords * 8;
+ for (size_t i = 0; i < remainder; ++i) {
+ if (ba[i] != bb[i]) {
+ return ba[i] - bb[i];
+ }
+ }
+ }
+
+ return 0;
+}
+
+/* Atomic operations - optimized for RISC-V A extension */
+
+typedef volatile uint64_t riscv_atomic64_t;
+
+static inline uint64_t riscv_atomic64_load(const riscv_atomic64_t *p)
+{
+ riscv_lfence(); /* Ensure load-acquire semantics */
+ return *p;
+}
+
+static inline void riscv_atomic64_store(riscv_atomic64_t *p, uint64_t v)
+{
+ riscv_sfence(); /* Ensure store-release semantics */
+ *p = v;
+}
+
+static inline uint64_t riscv_atomic64_exchange(riscv_atomic64_t *p, uint64_t v)
+{
+ uint64_t old;
+ asm volatile ("amoswap.d.aq %0, %2, (%1)" : "=r"(old) : "r"(p), "r"(v) : "memory");
+ return old;
+}
+
+static inline uint64_t riscv_atomic64_add(riscv_atomic64_t *p, uint64_t v)
+{
+ uint64_t old;
+ asm volatile ("amoadd.d.aq %0, %2, (%1)" : "=r"(old) : "r"(p), "r"(v) : "memory");
+ return old;
+}
+
+#else /* !XMRIG_RISCV */
+
+/* Fallback implementations for non-RISC-V */
+
+#define CACHELINE_SIZE 64
+
+static inline void riscv_mfence(void) { __sync_synchronize(); }
+static inline void riscv_lfence(void) { __sync_synchronize(); }
+static inline void riscv_sfence(void) { __sync_synchronize(); }
+static inline void riscv_fence_tso(void) { __sync_synchronize(); }
+static inline void riscv_acquire_fence(void) { __sync_synchronize(); }
+static inline void riscv_release_fence(void) { __sync_synchronize(); }
+static inline void riscv_pause(void) { }
+
+static inline void riscv_prefetch_read(const void *addr) { __builtin_prefetch(addr, 0, 3); }
+static inline void riscv_prefetch_write(const void *addr) { __builtin_prefetch(addr, 1, 3); }
+static inline void riscv_prefetch_nta(const void *addr) { __builtin_prefetch(addr, 0, 0); }
+static inline void riscv_clflush(const void *addr) { (void)addr; }
+
+static inline void riscv_memcpy_prefetch(void *dest, const void *src, size_t size)
+{
+ memcpy(dest, src, size);
+}
+
+static inline void riscv_memfill64(void *dest, uint64_t value, size_t count)
+{
+ for (size_t i = 0; i < count; ++i) {
+ ((uint64_t *)dest)[i] = value;
+ }
+}
+
+static inline int riscv_memcmp_fast(const void *s1, const void *s2, size_t n)
+{
+ return memcmp(s1, s2, n);
+}
+
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // XMRIG_RISCV_MEMORY_H
diff --git a/src/crypto/riscv/riscv_rvv.h b/src/crypto/riscv/riscv_rvv.h
new file mode 100644
index 0000000..da69d12
--- /dev/null
+++ b/src/crypto/riscv/riscv_rvv.h
@@ -0,0 +1,256 @@
+/* XMRig
+ * Copyright (c) 2025 Slayingripper <https://github.com/Slayingripper>
+ * Copyright (c) 2018-2025 SChernykh <https://github.com/SChernykh>
+ * Copyright (c) 2016-2025 XMRig <support@xmrig.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*
+ * RISC-V Vector Extension (RVV) Optimizations for XMRig
+ *
+ * Leverages RVV for parallel cryptographic operations
+ * Automatically falls back to scalar if RVV unavailable
+ */
+
+#ifndef XMRIG_RISCV_RVV_H
+#define XMRIG_RISCV_RVV_H
+
+#include <riscv_vector.h>
+#include <stdint.h>
+#include <string.h>
+
+#ifdef __riscv_v_elen
+ #define XMRIG_RVV_ENABLED 1
+ #define XMRIG_RVV_ELEN __riscv_v_elen
+#else
+ #define XMRIG_RVV_ENABLED 0
+ #define XMRIG_RVV_ELEN 64
+#endif
+
+/* Vector length in bits */
+#define RVV_VLEN __riscv_v_max_vlen
+
+/* Detect VLEN at runtime if available */
+static inline uint32_t riscv_rvv_vlen(void) {
+#ifdef __riscv_v_max_vlen
+ return __riscv_v_max_vlen;
+#else
+ /* Fallback: typical VLEN is 128, 256, or 512 bits */
+ return 128;
+#endif
+}
+
+/* Detect if RVV is available at runtime */
+static inline int riscv_has_rvv(void) {
+#ifdef __riscv_v
+ return 1;
+#else
+ return 0;
+#endif
+}
+
+#if XMRIG_RVV_ENABLED
+
+/* Vectorized 64-bit memory copy using RVV
+ * Copies 'size' bytes from src to dst using vector operations
+ * Assumes size is multiple of vector element width
+ */
+static inline void riscv_memcpy_rvv(void *dst, const void *src, size_t size) {
+ const uint8_t *s = (const uint8_t *)src;
+ uint8_t *d = (uint8_t *)dst;
+
+ /* Process in 64-byte chunks with RVV */
+ size_t vl;
+ uint64_t *d64 = (uint64_t *)dst;
+ const uint64_t *s64 = (const uint64_t *)src;
+ size_t count = size / 8;
+
+ size_t i = 0;
+ while (i < count) {
+ vl = __riscv_vsetvl_e64m1(count - i);
+ vfloat64m1_t vs = __riscv_vle64_v_f64m1((double *)(s64 + i), vl);
+ __riscv_vse64_v_f64m1((double *)(d64 + i), vs, vl);
+ i += vl;
+ }
+
+ /* Handle remainder */
+ size_t remainder = size % 8;
+ if (remainder) {
+ memcpy((uint8_t *)dst + size - remainder,
+ (uint8_t *)src + size - remainder,
+ remainder);
+ }
+}
+
+/* Vectorized memset using RVV - fill memory with pattern */
+static inline void riscv_memset_rvv(void *dst, uint32_t pattern, size_t size) {
+ uint32_t *d32 = (uint32_t *)dst;
+ size_t count = size / 4;
+ size_t vl, i = 0;
+
+ while (i < count) {
+ vl = __riscv_vsetvl_e32m1(count - i);
+ vuint32m1_t vp = __riscv_vmv_v_x_u32m1(pattern, vl);
+ __riscv_vse32_v_u32m1(d32 + i, vp, vl);
+ i += vl;
+ }
+
+ /* Handle remainder */
+ size_t remainder = size % 4;
+ if (remainder) {
+ memset((uint8_t *)dst + size - remainder,
+ pattern & 0xFF,
+ remainder);
+ }
+}
+
+/* Vectorized XOR operation - a ^= b for size bytes */
+static inline void riscv_xor_rvv(void *a, const void *b, size_t size) {
+ uint64_t *a64 = (uint64_t *)a;
+ const uint64_t *b64 = (const uint64_t *)b;
+ size_t count = size / 8;
+ size_t vl, i = 0;
+
+ while (i < count) {
+ vl = __riscv_vsetvl_e64m1(count - i);
+ vuint64m1_t va = __riscv_vle64_v_u64m1(a64 + i, vl);
+ vuint64m1_t vb = __riscv_vle64_v_u64m1(b64 + i, vl);
+ vuint64m1_t vc = __riscv_vxor_vv_u64m1(va, vb, vl);
+ __riscv_vse64_v_u64m1(a64 + i, vc, vl);
+ i += vl;
+ }
+
+ /* Handle remainder */
+ size_t remainder = size % 8;
+ if (remainder) {
+ uint8_t *a8 = (uint8_t *)a;
+ const uint8_t *b8 = (const uint8_t *)b;
+ for (size_t j = 0; j < remainder; j++) {
+ a8[size - remainder + j] ^= b8[size - remainder + j];
+ }
+ }
+}
+
+/* Vectorized memory comparison - returns 0 if equal, first differing byte difference otherwise */
+static inline int riscv_memcmp_rvv(const void *a, const void *b, size_t size) {
+ const uint64_t *a64 = (const uint64_t *)a;
+ const uint64_t *b64 = (const uint64_t *)b;
+ size_t count = size / 8;
+ size_t vl, i = 0;
+
+ while (i < count) {
+ vl = __riscv_vsetvl_e64m1(count - i);
+ vuint64m1_t va = __riscv_vle64_v_u64m1(a64 + i, vl);
+ vuint64m1_t vb = __riscv_vle64_v_u64m1(b64 + i, vl);
+ vbool64_t cmp = __riscv_vmsne_vv_u64m1_b64(va, vb, vl);
+
+ if (__riscv_vcpop_m_b64(cmp, vl) > 0) {
+ /* Found difference, fall back to scalar for exact position */
+ goto scalar_fallback;
+ }
+ i += vl;
+ }
+
+ /* Check remainder */
+ size_t remainder = size % 8;
+ if (remainder) {
+ const uint8_t *a8 = (const uint8_t *)a;
+ const uint8_t *b8 = (const uint8_t *)b;
+ for (size_t j = 0; j < remainder; j++) {
+ if (a8[size - remainder + j] != b8[size - remainder + j]) {
+ return a8[size - remainder + j] - b8[size - remainder + j];
+ }
+ }
+ }
+ return 0;
+
+scalar_fallback:
+ return memcmp(a, b, size);
+}
+
+/* Vectorized 256-bit rotation for RandomX AES operations */
+static inline void riscv_aes_rotate_rvv(uint32_t *data, size_t count) {
+ /* Rotate 32-bit elements by 8 bits within 256-bit vectors */
+ size_t vl, i = 0;
+
+ while (i < count) {
+ vl = __riscv_vsetvl_e32m1(count - i);
+ vuint32m1_t v = __riscv_vle32_v_u32m1(data + i, vl);
+
+ /* Rotate left by 8: (x << 8) | (x >> 24) */
+ vuint32m1_t shifted_left = __riscv_vsll_vx_u32m1(v, 8, vl);
+ vuint32m1_t shifted_right = __riscv_vsrl_vx_u32m1(v, 24, vl);
+ vuint32m1_t result = __riscv_vor_vv_u32m1(shifted_left, shifted_right, vl);
+
+ __riscv_vse32_v_u32m1(data + i, result, vl);
+ i += vl;
+ }
+}
+
+/* Parallel AES SubBytes operation using RVV */
+static inline void riscv_aes_subbytes_rvv(uint8_t *state, size_t size) {
+ /* This is a simplified version - real AES SubBytes uses lookup tables */
+ size_t vl, i = 0;
+
+ while (i < size) {
+ vl = __riscv_vsetvl_e8m1(size - i);
+ vuint8m1_t v = __riscv_vle8_v_u8m1(state + i, vl);
+
+ /* Placeholder: in real implementation, use AES SBOX lookup */
+ /* For now, just apply a simple transformation */
+ vuint8m1_t result = __riscv_vxor_vx_u8m1(v, 0x63, vl);
+
+ __riscv_vse8_v_u8m1(state + i, result, vl);
+ i += vl;
+ }
+}
+
+#else /* Scalar fallback when RVV unavailable */
+
+static inline void riscv_memcpy_rvv(void *dst, const void *src, size_t size) {
+ memcpy(dst, src, size);
+}
+
+static inline void riscv_memset_rvv(void *dst, uint32_t pattern, size_t size) {
+ memset(dst, pattern & 0xFF, size);
+}
+
+static inline void riscv_xor_rvv(void *a, const void *b, size_t size) {
+ uint8_t *a8 = (uint8_t *)a;
+ const uint8_t *b8 = (const uint8_t *)b;
+ for (size_t i = 0; i < size; i++) {
+ a8[i] ^= b8[i];
+ }
+}
+
+static inline int riscv_memcmp_rvv(const void *a, const void *b, size_t size) {
+ return memcmp(a, b, size);
+}
+
+static inline void riscv_aes_rotate_rvv(uint32_t *data, size_t count) {
+ for (size_t i = 0; i < count; i++) {
+ data[i] = (data[i] << 8) | (data[i] >> 24);
+ }
+}
+
+static inline void riscv_aes_subbytes_rvv(uint8_t *state, size_t size) {
+ for (size_t i = 0; i < size; i++) {
+ state[i] ^= 0x63;
+ }
+}
+
+#endif /* XMRIG_RVV_ENABLED */
+
+#endif /* XMRIG_RISCV_RVV_H */
diff --git a/src/crypto/rx/RxDataset_riscv.h b/src/crypto/rx/RxDataset_riscv.h
new file mode 100644
index 0000000..b3761ca
--- /dev/null
+++ b/src/crypto/rx/RxDataset_riscv.h
@@ -0,0 +1,124 @@
+/* XMRig
+ * Copyright (c) 2025 XMRig <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*
+ * RISC-V optimized RandomX dataset initialization
+ * Optimizations:
+ * - Adaptive thread allocation based on CPU cores
+ * - Prefetch hints for better cache utilization
+ * - Memory alignment optimizations for RISC-V
+ * - Efficient barrier operations
+ */
+
+#ifndef XMRIG_RXDATASET_RISCV_H
+#define XMRIG_RXDATASET_RISCV_H
+
+#include <stdint.h>
+#include <unistd.h>
+#include <sched.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#if defined(XMRIG_RISCV)
+
+/* RISC-V memory prefetch macros */
+#define PREFETCH_READ(addr) asm volatile ("prefetch.r %0" : : "r"(addr) : "memory")
+#define PREFETCH_WRITE(addr) asm volatile ("prefetch.w %0" : : "r"(addr) : "memory")
+#define MEMORY_BARRIER() asm volatile ("fence rw,rw" : : : "memory")
+#define READ_BARRIER() asm volatile ("fence r,r" : : : "memory")
+#define WRITE_BARRIER() asm volatile ("fence w,w" : : : "memory")
+
+/* RISC-V hint pause - tries Zihintpause, falls back to NOP */
+static inline void cpu_pause(void)
+{
+ asm volatile ("pause");
+}
+
+/* Adaptive thread count calculation for dataset init */
+static inline uint32_t riscv_optimal_init_threads(uint32_t available_threads)
+{
+ /* On RISC-V, use 60-75% of available threads for init */
+ /* This leaves some threads available for OS/other tasks */
+ uint32_t recommended = (available_threads * 3) / 4;
+ return recommended > 0 ? recommended : 1;
+}
+
+/* Prefetch next dataset item for better cache utilization */
+static inline void prefetch_dataset_item(const void *item, size_t size)
+{
+ const uint8_t *ptr = (const uint8_t *)item;
+ /* Prefetch cache line aligned chunks */
+ for (size_t i = 0; i < size; i += 64) {
+ PREFETCH_READ(ptr + i);
+ }
+}
+
+/* Cache-aware aligned memory copy optimized for RISC-V */
+static inline void aligned_memcpy_opt(void *dst, const void *src, size_t size)
+{
+ uint64_t *d = (uint64_t *)dst;
+ const uint64_t *s = (const uint64_t *)src;
+
+ /* Process in 64-byte chunks with prefetching */
+ size_t chunks = size / 8;
+ for (size_t i = 0; i < chunks; i += 8) {
+ if (i + 8 < chunks) {
+ prefetch_dataset_item(s + i + 8, 64);
+ }
+ d[i] = s[i];
+ d[i+1] = s[i+1];
+ d[i+2] = s[i+2];
+ d[i+3] = s[i+3];
+ d[i+4] = s[i+4];
+ d[i+5] = s[i+5];
+ d[i+6] = s[i+6];
+ d[i+7] = s[i+7];
+ }
+}
+
+/* Get optimal CPU core for thread pinning */
+static inline int get_optimal_cpu_core(int thread_id)
+{
+ long nprocs = sysconf(_SC_NPROCESSORS_ONLN);
+ if (nprocs <= 0) nprocs = 1;
+ return thread_id % nprocs;
+}
+
+#else /* !XMRIG_RISCV */
+
+/* Fallback for non-RISC-V architectures */
+#define PREFETCH_READ(addr)
+#define PREFETCH_WRITE(addr)
+#define MEMORY_BARRIER() __sync_synchronize()
+#define READ_BARRIER() __sync_synchronize()
+#define WRITE_BARRIER() __sync_synchronize()
+
+static inline void cpu_pause(void) { }
+static inline uint32_t riscv_optimal_init_threads(uint32_t available) { return available; }
+static inline void prefetch_dataset_item(const void *item, size_t size) { (void)item; (void)size; }
+static inline void aligned_memcpy_opt(void *dst, const void *src, size_t size) { memcpy(dst, src, size); }
+static inline int get_optimal_cpu_core(int thread_id) { return thread_id; }
+
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // XMRIG_RXDATASET_RISCV_H
diff --git a/src/crypto/rx/RxVm.cpp b/src/crypto/rx/RxVm.cpp
index acaa25e..6ffe210 100644
--- a/src/crypto/rx/RxVm.cpp
+++ b/src/crypto/rx/RxVm.cpp
@@ -29,9 +29,17 @@ randomx_vm *xmrig::RxVm::create(RxDataset *dataset, uint8_t *scratchpad, bool so
{
int flags = 0;
+ // On RISC-V, force software AES path even if CPU reports AES capability.
+ // The RandomX portable intrinsics will throw at runtime when HAVE_AES is not defined
+ // for this architecture. Until native AES intrinsics are wired for RISC-V, avoid
+ // setting HARD_AES to prevent "Platform doesn't support hardware AES" aborts.
+# ifndef XMRIG_RISCV
if (!softAes) {
flags |= RANDOMX_FLAG_HARD_AES;
}
+# else
+ (void)softAes; // unused on RISC-V to force soft AES
+# endif
if (dataset->get()) {
flags |= RANDOMX_FLAG_FULL_MEM;
diff --git a/src/version.h b/src/version.h
index a6773b1..ce36b0a 100644
--- a/src/version.h
+++ b/src/version.h
@@ -75,6 +75,8 @@
#ifdef XMRIG_ARM
# define APP_ARCH "ARMv" STR2(XMRIG_ARM)
+#elif defined(XMRIG_RISCV)
+# define APP_ARCH "RISC-V"
#else
# if defined(__x86_64__) || defined(__amd64__) || defined(_M_X64) || defined(_M_AMD64)
# define APP_ARCH "x86-64"
Why this scored 19/100
Community notes
Notes can correct, qualify, or add evidence to the AI analysis. Every note shown here has been validated by a human moderator.
The AI analysis stands alone for now. Submit a note if you can add evidence or important context.