v2.14.4

Repair compilation with Clang 9.0.0

CHANGELOG.md

@@ -1,3 +1,10 @@
+# v2.14.4
+- [#992](https://github.com/xmrig/xmrig/pull/992)  Fixed compilation with Clang 3.5.
+- [#1012](https://github.com/xmrig/xmrig/pull/1012) Fixed compilation with Clang 9.0.
+- In HTTP API for unknown hashrate now used `null` instead of `0.0`.
+- Fixed MSVC 2019 version detection.
+- Removed obsolete automatic variants.
+
 # v2.14.1
 * [#975](https://github.com/xmrig/xmrig/issues/975) Fixed crash on Linux if double thread mode used.
 

README.md

@@ -13,7 +13,7 @@ Originally based on cpuminer-multi with heavy optimizations/rewrites and removin
 * This is the **CPU-mining** version, there is also a [NVIDIA GPU version](https://github.com/xmrig/xmrig-nvidia) and [AMD GPU version]( https://github.com/xmrig/xmrig-amd).
 * [Roadmap](https://github.com/xmrig/xmrig/issues/106) for next releases.
 
-<img src="http://i.imgur.com/OKZRVDh.png" width="619" >
+<img src="http://i.imgur.com/Ymumes5.png" width="670" >
 
 #### Table of contents
 * [Features](#features)

cmake/flags.cmake

@@ -10,6 +10,8 @@ if (CMAKE_BUILD_TYPE STREQUAL "Release")
     add_definitions(/DNDEBUG)
 endif()
 
+include(CheckSymbolExists)
+
 if (CMAKE_CXX_COMPILER_ID MATCHES GNU)
 
     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -Wno-strict-aliasing")
@@ -27,6 +29,8 @@ if (CMAKE_CXX_COMPILER_ID MATCHES GNU)
     else()
         set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -maes")
         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -maes")
+
+        add_definitions(/DHAVE_ROTR)
     endif()
 
     if (WIN32)
@@ -50,6 +54,7 @@ elseif (CMAKE_CXX_COMPILER_ID MATCHES MSVC)
     add_definitions(/D_CRT_SECURE_NO_WARNINGS)
     add_definitions(/D_CRT_NONSTDC_NO_WARNINGS)
     add_definitions(/DNOMINMAX)
+    add_definitions(/DHAVE_ROTR)
 
 elseif (CMAKE_CXX_COMPILER_ID MATCHES Clang)
 
@@ -68,6 +73,11 @@ elseif (CMAKE_CXX_COMPILER_ID MATCHES Clang)
     else()
         set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -maes")
         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -maes")
+
+        check_symbol_exists("_rotr" "x86intrin.h" HAVE_ROTR)
+        if (HAVE_ROTR)
+            add_definitions(/DHAVE_ROTR)
+        endif()
     endif()
 
 endif()

src/Mem.cpp

@@ -53,7 +53,7 @@ MemInfo Mem::create(cryptonight_ctx **ctx, xmrig::Algo algorithm, size_t count)
 
         uint8_t* p = reinterpret_cast<uint8_t*>(allocateExecutableMemory(0x4000));
         c->generated_code  = reinterpret_cast<cn_mainloop_fun_ms_abi>(p);
-        c->generated_code_double = reinterpret_cast<cn_mainloop_double_fun_ms_abi>(p + 0x2000);
+        c->generated_code_double = reinterpret_cast<cn_mainloop_fun_ms_abi>(p + 0x2000);
 
         c->generated_code_data.variant = xmrig::VARIANT_MAX;
         c->generated_code_data.height = (uint64_t)(-1);

src/api/ApiRouter.cpp

@@ -51,13 +51,15 @@
 #include "workers/Workers.h"
 
 
-static inline double normalize(double d)
+static inline rapidjson::Value normalize(double d)
 {
+    using namespace rapidjson;
+
     if (!isnormal(d)) {
-        return 0.0;
+        return Value(kNullType);
     }
 
-    return floor(d * 100.0) / 100.0;
+    return Value(floor(d * 100.0) / 100.0);
 }
 
 

src/common/net/Job.cpp

@@ -127,24 +127,6 @@ bool xmrig::Job::setBlob(const char *blob)
         m_algorithm.setVariant(variant());
     }
 
-    if (!m_algorithm.isForced()) {
-        if (m_algorithm.variant() == VARIANT_XTL && m_blob[0] >= 9) {
-            m_algorithm.setVariant(VARIANT_HALF);
-        }
-        else if (m_algorithm.variant() == VARIANT_MSR && m_blob[0] >= 8) {
-            m_algorithm.setVariant(VARIANT_HALF);
-        }
-        else if (m_algorithm.variant() == VARIANT_WOW && m_blob[0] < 11) {
-            m_algorithm.setVariant(VARIANT_2);
-        }
-        else if (m_algorithm.variant() == VARIANT_RWZ && m_blob[0] < 12) {
-            m_algorithm.setVariant(VARIANT_2);
-        }
-        else if (m_algorithm.variant() == VARIANT_ZLS && m_blob[0] < 8) {
-            m_algorithm.setVariant(VARIANT_2);
-        }
-    }
-
 #   ifdef XMRIG_PROXY_PROJECT
     memset(m_rawBlob, 0, sizeof(m_rawBlob));
     memcpy(m_rawBlob, blob, m_size * 2);

src/core/Config.cpp

@@ -22,6 +22,7 @@
  *   along with this program. If not, see <http://www.gnu.org/licenses/>.
  */
 
+#include <algorithm>
 #include <string.h>
 #include <uv.h>
 #include <inttypes.h>

src/crypto/CryptoNight.h

@@ -36,8 +36,7 @@
 #endif
 
 struct cryptonight_ctx;
-typedef void(*cn_mainloop_fun_ms_abi)(cryptonight_ctx*) ABI_ATTRIBUTE;
-typedef void(*cn_mainloop_double_fun_ms_abi)(cryptonight_ctx*, cryptonight_ctx*) ABI_ATTRIBUTE;
+typedef void(*cn_mainloop_fun_ms_abi)(cryptonight_ctx**) ABI_ATTRIBUTE;
 
 struct cryptonight_r_data {
     int variant;
@@ -54,7 +53,7 @@ struct cryptonight_ctx {
     const uint32_t* saes_table;
 
     cn_mainloop_fun_ms_abi generated_code;
-    cn_mainloop_double_fun_ms_abi generated_code_double;
+    cn_mainloop_fun_ms_abi generated_code_double;
     cryptonight_r_data generated_code_data;
     cryptonight_r_data generated_code_double_data;
 };

src/crypto/CryptoNight_x86.h

@@ -590,7 +590,7 @@ inline void cryptonight_single_hash(const uint8_t *__restrict__ input, size_t si
         }
 
         ctx[0]->saes_table = (const uint32_t*)saes_table;
-        ctx[0]->generated_code(ctx[0]);
+        ctx[0]->generated_code(ctx);
     } else {
 #endif
 
@@ -750,32 +750,32 @@ inline void cryptonight_single_hash_gpu(const uint8_t *__restrict__ input, size_
 
 
 #ifndef XMRIG_NO_ASM
-extern "C" void cnv2_mainloop_ivybridge_asm(cryptonight_ctx *ctx);
-extern "C" void cnv2_mainloop_ryzen_asm(cryptonight_ctx *ctx);
-extern "C" void cnv2_mainloop_bulldozer_asm(cryptonight_ctx *ctx);
-extern "C" void cnv2_double_mainloop_sandybridge_asm(cryptonight_ctx* ctx0, cryptonight_ctx* ctx1);
-extern "C" void cnv2_rwz_mainloop_asm(cryptonight_ctx *ctx);
-extern "C" void cnv2_rwz_double_mainloop_asm(cryptonight_ctx* ctx0, cryptonight_ctx* ctx1);
+extern "C" void cnv2_mainloop_ivybridge_asm(cryptonight_ctx **ctx);
+extern "C" void cnv2_mainloop_ryzen_asm(cryptonight_ctx **ctx);
+extern "C" void cnv2_mainloop_bulldozer_asm(cryptonight_ctx **ctx);
+extern "C" void cnv2_double_mainloop_sandybridge_asm(cryptonight_ctx **ctx);
+extern "C" void cnv2_rwz_mainloop_asm(cryptonight_ctx **ctx);
+extern "C" void cnv2_rwz_double_mainloop_asm(cryptonight_ctx **ctx);
 
 extern xmrig::CpuThread::cn_mainloop_fun        cn_half_mainloop_ivybridge_asm;
 extern xmrig::CpuThread::cn_mainloop_fun        cn_half_mainloop_ryzen_asm;
 extern xmrig::CpuThread::cn_mainloop_fun        cn_half_mainloop_bulldozer_asm;
-extern xmrig::CpuThread::cn_mainloop_double_fun cn_half_double_mainloop_sandybridge_asm;
+extern xmrig::CpuThread::cn_mainloop_fun        cn_half_double_mainloop_sandybridge_asm;
 
 extern xmrig::CpuThread::cn_mainloop_fun        cn_trtl_mainloop_ivybridge_asm;
 extern xmrig::CpuThread::cn_mainloop_fun        cn_trtl_mainloop_ryzen_asm;
 extern xmrig::CpuThread::cn_mainloop_fun        cn_trtl_mainloop_bulldozer_asm;
-extern xmrig::CpuThread::cn_mainloop_double_fun cn_trtl_double_mainloop_sandybridge_asm;
+extern xmrig::CpuThread::cn_mainloop_fun        cn_trtl_double_mainloop_sandybridge_asm;
 
 extern xmrig::CpuThread::cn_mainloop_fun        cn_zls_mainloop_ivybridge_asm;
 extern xmrig::CpuThread::cn_mainloop_fun        cn_zls_mainloop_ryzen_asm;
 extern xmrig::CpuThread::cn_mainloop_fun        cn_zls_mainloop_bulldozer_asm;
-extern xmrig::CpuThread::cn_mainloop_double_fun cn_zls_double_mainloop_sandybridge_asm;
+extern xmrig::CpuThread::cn_mainloop_fun        cn_zls_double_mainloop_sandybridge_asm;
 
 extern xmrig::CpuThread::cn_mainloop_fun        cn_double_mainloop_ivybridge_asm;
 extern xmrig::CpuThread::cn_mainloop_fun        cn_double_mainloop_ryzen_asm;
 extern xmrig::CpuThread::cn_mainloop_fun        cn_double_mainloop_bulldozer_asm;
-extern xmrig::CpuThread::cn_mainloop_double_fun cn_double_double_mainloop_sandybridge_asm;
+extern xmrig::CpuThread::cn_mainloop_fun        cn_double_double_mainloop_sandybridge_asm;
 
 void wow_compile_code(const V4_Instruction* code, int code_size, void* machine_code, xmrig::Assembly ASM);
 void v4_compile_code(const V4_Instruction* code, int code_size, void* machine_code, xmrig::Assembly ASM);
@@ -824,64 +824,64 @@ inline void cryptonight_single_hash_asm(const uint8_t *__restrict__ input, size_
 
     if (VARIANT == xmrig::VARIANT_2) {
         if (ASM == xmrig::ASM_INTEL) {
-            cnv2_mainloop_ivybridge_asm(ctx[0]);
+            cnv2_mainloop_ivybridge_asm(ctx);
         }
         else if (ASM == xmrig::ASM_RYZEN) {
-            cnv2_mainloop_ryzen_asm(ctx[0]);
+            cnv2_mainloop_ryzen_asm(ctx);
         }
         else {
-            cnv2_mainloop_bulldozer_asm(ctx[0]);
+            cnv2_mainloop_bulldozer_asm(ctx);
         }
     }
     else if (VARIANT == xmrig::VARIANT_HALF) {
         if (ASM == xmrig::ASM_INTEL) {
-            cn_half_mainloop_ivybridge_asm(ctx[0]);
+            cn_half_mainloop_ivybridge_asm(ctx);
         }
         else if (ASM == xmrig::ASM_RYZEN) {
-            cn_half_mainloop_ryzen_asm(ctx[0]);
+            cn_half_mainloop_ryzen_asm(ctx);
         }
         else {
-            cn_half_mainloop_bulldozer_asm(ctx[0]);
+            cn_half_mainloop_bulldozer_asm(ctx);
         }
     }
     else if (VARIANT == xmrig::VARIANT_TRTL) {
         if (ASM == xmrig::ASM_INTEL) {
-            cn_trtl_mainloop_ivybridge_asm(ctx[0]);
+            cn_trtl_mainloop_ivybridge_asm(ctx);
         }
         else if (ASM == xmrig::ASM_RYZEN) {
-            cn_trtl_mainloop_ryzen_asm(ctx[0]);
+            cn_trtl_mainloop_ryzen_asm(ctx);
         }
         else {
-            cn_trtl_mainloop_bulldozer_asm(ctx[0]);
+            cn_trtl_mainloop_bulldozer_asm(ctx);
         }
     }
     else if (VARIANT == xmrig::VARIANT_RWZ) {
-        cnv2_rwz_mainloop_asm(ctx[0]);
+        cnv2_rwz_mainloop_asm(ctx);
     }
     else if (VARIANT == xmrig::VARIANT_ZLS) {
         if (ASM == xmrig::ASM_INTEL) {
-            cn_zls_mainloop_ivybridge_asm(ctx[0]);
+            cn_zls_mainloop_ivybridge_asm(ctx);
         }
         else if (ASM == xmrig::ASM_RYZEN) {
-            cn_zls_mainloop_ryzen_asm(ctx[0]);
+            cn_zls_mainloop_ryzen_asm(ctx);
         }
         else {
-            cn_zls_mainloop_bulldozer_asm(ctx[0]);
+            cn_zls_mainloop_bulldozer_asm(ctx);
         }
     }
     else if (VARIANT == xmrig::VARIANT_DOUBLE) {
         if (ASM == xmrig::ASM_INTEL) {
-            cn_double_mainloop_ivybridge_asm(ctx[0]);
+            cn_double_mainloop_ivybridge_asm(ctx);
         }
         else if (ASM == xmrig::ASM_RYZEN) {
-            cn_double_mainloop_ryzen_asm(ctx[0]);
+            cn_double_mainloop_ryzen_asm(ctx);
         }
         else {
-            cn_double_mainloop_bulldozer_asm(ctx[0]);
+            cn_double_mainloop_bulldozer_asm(ctx);
         }
     }
     else if (xmrig::cn_is_cryptonight_r<VARIANT>()) {
-        ctx[0]->generated_code(ctx[0]);
+        ctx[0]->generated_code(ctx);
     }
 
     cn_implode_scratchpad<ALGO, MEM, false>(reinterpret_cast<__m128i*>(ctx[0]->memory), reinterpret_cast<__m128i*>(ctx[0]->state));
@@ -910,25 +910,25 @@ inline void cryptonight_double_hash_asm(const uint8_t *__restrict__ input, size_
     cn_explode_scratchpad<ALGO, MEM, false>(reinterpret_cast<__m128i*>(ctx[1]->state), reinterpret_cast<__m128i*>(ctx[1]->memory));
 
     if (VARIANT == xmrig::VARIANT_2) {
-        cnv2_double_mainloop_sandybridge_asm(ctx[0], ctx[1]);
+        cnv2_double_mainloop_sandybridge_asm(ctx);
     }
     else if (VARIANT == xmrig::VARIANT_HALF) {
-        cn_half_double_mainloop_sandybridge_asm(ctx[0], ctx[1]);
+        cn_half_double_mainloop_sandybridge_asm(ctx);
     }
     else if (VARIANT == xmrig::VARIANT_TRTL) {
-        cn_trtl_double_mainloop_sandybridge_asm(ctx[0], ctx[1]);
+        cn_trtl_double_mainloop_sandybridge_asm(ctx);
     }
     else if (VARIANT == xmrig::VARIANT_RWZ) {
-        cnv2_rwz_double_mainloop_asm(ctx[0], ctx[1]);
+        cnv2_rwz_double_mainloop_asm(ctx);
     }
     else if (VARIANT == xmrig::VARIANT_ZLS) {
-        cn_zls_double_mainloop_sandybridge_asm(ctx[0], ctx[1]);
+        cn_zls_double_mainloop_sandybridge_asm(ctx);
     }
     else if (VARIANT == xmrig::VARIANT_DOUBLE) {
-        cn_double_double_mainloop_sandybridge_asm(ctx[0], ctx[1]);
+        cn_double_double_mainloop_sandybridge_asm(ctx);
     }
     else if (xmrig::cn_is_cryptonight_r<VARIANT>()) {
-        ctx[0]->generated_code_double(ctx[0], ctx[1]);
+        ctx[0]->generated_code_double(ctx);
     }
 
     cn_implode_scratchpad<ALGO, MEM, false>(reinterpret_cast<__m128i*>(ctx[0]->memory), reinterpret_cast<__m128i*>(ctx[0]->state));

src/crypto/asm/CryptonightR_soft_aes_template.inc

@@ -6,6 +6,8 @@ PUBLIC FN_PREFIX(CryptonightR_soft_aes_template_end)
 
 ALIGN(64)
 FN_PREFIX(CryptonightR_soft_aes_template_part1):
+	mov	rcx, [rcx]
+
 	mov	QWORD PTR [rsp+8], rcx
 	push	rbx
 	push	rbp

src/crypto/asm/CryptonightR_soft_aes_template_win.inc

@@ -6,6 +6,8 @@ PUBLIC CryptonightR_soft_aes_template_end
 
 ALIGN(64)
 CryptonightR_soft_aes_template_part1:
+	mov	rcx, [rcx]
+
 	mov	QWORD PTR [rsp+8], rcx
 	push	rbx
 	push	rbp

src/crypto/asm/CryptonightR_template.inc

@@ -12,6 +12,8 @@ PUBLIC FN_PREFIX(CryptonightR_template_double_end)
 
 ALIGN(64)
 FN_PREFIX(CryptonightR_template_part1):
+	mov	rcx, [rcx]
+
 	mov	QWORD PTR [rsp+16], rbx
 	mov	QWORD PTR [rsp+24], rbp
 	mov	QWORD PTR [rsp+32], rsi
@@ -183,6 +185,9 @@ FN_PREFIX(CryptonightR_template_end):
 
 ALIGN(64)
 FN_PREFIX(CryptonightR_template_double_part1):
+	mov	rdx, [rcx+8]
+	mov	rcx, [rcx]
+
 	mov	QWORD PTR [rsp+24], rbx
 	push	rbp
 	push	rsi

src/crypto/asm/CryptonightR_template_win.inc

@@ -12,6 +12,8 @@ PUBLIC CryptonightR_template_double_end
 
 ALIGN(64)
 CryptonightR_template_part1:
+	mov	rcx, [rcx]
+
 	mov	QWORD PTR [rsp+16], rbx
 	mov	QWORD PTR [rsp+24], rbp
 	mov	QWORD PTR [rsp+32], rsi
@@ -183,6 +185,9 @@ CryptonightR_template_end:
 
 ALIGN(64)
 CryptonightR_template_double_part1:
+	mov	rdx, [rcx+8]
+	mov	rcx, [rcx]
+
 	mov	QWORD PTR [rsp+24], rbx
 	push	rbp
 	push	rsi

src/crypto/asm/CryptonightWOW_soft_aes_template.inc

@@ -6,6 +6,8 @@ PUBLIC FN_PREFIX(CryptonightWOW_soft_aes_template_end)
 
 ALIGN(64)
 FN_PREFIX(CryptonightWOW_soft_aes_template_part1):
+	mov	rcx, [rcx]
+
 	mov	QWORD PTR [rsp+8], rcx
 	push	rbx
 	push	rbp

src/crypto/asm/CryptonightWOW_soft_aes_template_win.inc

@@ -6,6 +6,8 @@ PUBLIC CryptonightWOW_soft_aes_template_end
 
 ALIGN(64)
 CryptonightWOW_soft_aes_template_part1:
+	mov	rcx, [rcx]
+
 	mov	QWORD PTR [rsp+8], rcx
 	push	rbx
 	push	rbp

src/crypto/asm/CryptonightWOW_template.inc

@@ -12,6 +12,8 @@ PUBLIC FN_PREFIX(CryptonightWOW_template_double_end)
 
 ALIGN(64)
 FN_PREFIX(CryptonightWOW_template_part1):
+	mov	rcx, [rcx]
+
 	mov	QWORD PTR [rsp+16], rbx
 	mov	QWORD PTR [rsp+24], rbp
 	mov	QWORD PTR [rsp+32], rsi
@@ -165,6 +167,9 @@ FN_PREFIX(CryptonightWOW_template_end):
 
 ALIGN(64)
 FN_PREFIX(CryptonightWOW_template_double_part1):
+	mov	rdx, [rcx+8]
+	mov	rcx, [rcx]
+
 	mov	QWORD PTR [rsp+24], rbx
 	push	rbp
 	push	rsi

src/crypto/asm/CryptonightWOW_template_win.inc

@@ -12,6 +12,8 @@ PUBLIC CryptonightWOW_template_double_end
 
 ALIGN(64)
 CryptonightWOW_template_part1:
+	mov	rcx, [rcx]
+
 	mov	QWORD PTR [rsp+16], rbx
 	mov	QWORD PTR [rsp+24], rbp
 	mov	QWORD PTR [rsp+32], rsi
@@ -165,6 +167,9 @@ CryptonightWOW_template_end:
 
 ALIGN(64)
 CryptonightWOW_template_double_part1:
+	mov	rdx, [rcx+8]
+	mov	rcx, [rcx]
+
 	mov	QWORD PTR [rsp+24], rbx
 	push	rbp
 	push	rsi

src/crypto/asm/cn2/cnv2_double_main_loop_sandybridge.inc

@@ -1,3 +1,6 @@
+	mov	rdx, [rcx+8]
+	mov	rcx, [rcx]
+
 	mov	rax, rsp
 	push	rbx
 	push	rbp

src/crypto/asm/cn2/cnv2_main_loop_bulldozer.inc

@@ -1,3 +1,5 @@
+	mov	rcx, [rcx]
+
 	mov	QWORD PTR [rsp+16], rbx
 	mov	QWORD PTR [rsp+24], rbp
 	mov	QWORD PTR [rsp+32], rsi

src/crypto/asm/cn2/cnv2_main_loop_ivybridge.inc

@@ -1,3 +1,5 @@
+	mov	rcx, [rcx]
+
 	mov	 QWORD PTR [rsp+24], rbx
 	push	 rbp
 	push	 rsi

src/crypto/asm/cn2/cnv2_main_loop_ryzen.inc

@@ -1,3 +1,5 @@
+	mov	rcx, [rcx]
+
 	mov	QWORD PTR [rsp+16], rbx
 	mov	QWORD PTR [rsp+24], rbp
 	mov	QWORD PTR [rsp+32], rsi

src/crypto/asm/cn2/cnv2_rwz_double_main_loop.inc

@@ -1,3 +1,6 @@
+	mov	rdx, [rcx+8]
+	mov	rcx, [rcx]
+
 	mov	rax, rsp
 	push	rbx
 	push	rbp

src/crypto/asm/cn2/cnv2_rwz_main_loop.inc

@@ -1,3 +1,5 @@
+	mov	rcx, [rcx]
+
 	mov	 QWORD PTR [rsp+24], rbx
 	push	 rbp
 	push	 rsi

src/crypto/asm/cn_main_loop.S

@@ -49,7 +49,6 @@ ALIGN(64)
 FN_PREFIX(cnv2_double_mainloop_sandybridge_asm):
 	sub rsp, 48
 	mov rcx, rdi
-	mov rdx, rsi
 	#include "cn2/cnv2_double_main_loop_sandybridge.inc"
 	add rsp, 48
 	ret 0
@@ -68,7 +67,6 @@ ALIGN(64)
 FN_PREFIX(cnv2_rwz_double_mainloop_asm):
 	sub rsp, 48
 	mov rcx, rdi
-	mov rdx, rsi
 	#include "cn2/cnv2_rwz_double_main_loop.inc"
 	add rsp, 48
 	ret 0

src/crypto/asm/win64/CryptonightR_soft_aes_template_win.inc

@@ -6,6 +6,8 @@ PUBLIC CryptonightR_soft_aes_template_end
 
 ALIGN(64)
 CryptonightR_soft_aes_template_part1:
+	mov	rcx, [rcx]
+
 	mov	QWORD PTR [rsp+8], rcx
 	push	rbx
 	push	rbp

src/crypto/asm/win64/CryptonightR_template_win.inc

@@ -12,6 +12,8 @@ PUBLIC CryptonightR_template_double_end
 
 ALIGN(64)
 CryptonightR_template_part1:
+	mov	rcx, [rcx]
+
 	mov	QWORD PTR [rsp+16], rbx
 	mov	QWORD PTR [rsp+24], rbp
 	mov	QWORD PTR [rsp+32], rsi
@@ -183,6 +185,9 @@ CryptonightR_template_end:
 
 ALIGN(64)
 CryptonightR_template_double_part1:
+	mov	rdx, [rcx+8]
+	mov	rcx, [rcx]
+
 	mov	QWORD PTR [rsp+24], rbx
 	push	rbp
 	push	rsi

src/crypto/asm/win64/CryptonightWOW_soft_aes_template_win.inc

@@ -6,6 +6,8 @@ PUBLIC CryptonightWOW_soft_aes_template_end
 
 ALIGN(64)
 CryptonightWOW_soft_aes_template_part1:
+	mov	rcx, [rcx]
+
 	mov	QWORD PTR [rsp+8], rcx
 	push	rbx
 	push	rbp

src/crypto/asm/win64/CryptonightWOW_template_win.inc

@@ -12,6 +12,8 @@ PUBLIC CryptonightWOW_template_double_end
 
 ALIGN(64)
 CryptonightWOW_template_part1:
+	mov	rcx, [rcx]
+
 	mov	QWORD PTR [rsp+16], rbx
 	mov	QWORD PTR [rsp+24], rbp
 	mov	QWORD PTR [rsp+32], rsi
@@ -165,6 +167,9 @@ CryptonightWOW_template_end:
 
 ALIGN(64)
 CryptonightWOW_template_double_part1:
+	mov	rdx, [rcx+8]
+	mov	rcx, [rcx]
+
 	mov	QWORD PTR [rsp+24], rbx
 	push	rbp
 	push	rsi

src/crypto/asm/win64/cn2/cnv2_double_main_loop_sandybridge.inc

@@ -1,3 +1,6 @@
+	mov	rdx, [rcx+8]
+	mov	rcx, [rcx]
+
 	mov	rax, rsp
 	push	rbx
 	push	rbp

src/crypto/asm/win64/cn2/cnv2_main_loop_bulldozer.inc

@@ -1,3 +1,5 @@
+	mov	rcx, [rcx]
+
 	mov	QWORD PTR [rsp+16], rbx
 	mov	QWORD PTR [rsp+24], rbp
 	mov	QWORD PTR [rsp+32], rsi

src/crypto/asm/win64/cn2/cnv2_main_loop_ivybridge.inc

@@ -1,3 +1,5 @@
+	mov	rcx, [rcx]
+
 	mov	 QWORD PTR [rsp+24], rbx
 	push	 rbp
 	push	 rsi

src/crypto/asm/win64/cn2/cnv2_main_loop_ryzen.inc

@@ -1,3 +1,5 @@
+	mov	rcx, [rcx]
+
 	mov	QWORD PTR [rsp+16], rbx
 	mov	QWORD PTR [rsp+24], rbp
 	mov	QWORD PTR [rsp+32], rsi

src/crypto/asm/win64/cn2/cnv2_rwz_double_main_loop.inc

@@ -1,3 +1,6 @@
+	mov	rdx, [rcx+8]
+	mov	rcx, [rcx]
+
 	mov	rax, rsp
 	push	rbx
 	push	rbp

src/crypto/asm/win64/cn2/cnv2_rwz_main_loop.inc

@@ -1,3 +1,5 @@
+	mov	rcx, [rcx]
+
 	mov	 QWORD PTR [rsp+24], rbx
 	push	 rbp
 	push	 rsi

src/crypto/cn_gpu_avx.cpp

@@ -30,6 +30,12 @@
 #   include <intrin.h>
 #   define __restrict__ __restrict
 #endif
+#ifndef _mm256_bslli_epi128
+	#define _mm256_bslli_epi128(a, count) _mm256_slli_si256((a), (count))
+#endif
+#ifndef _mm256_bsrli_epi128
+	#define _mm256_bsrli_epi128(a, count) _mm256_srli_si256((a), (count))
+#endif
 
 inline void prep_dv_avx(__m256i* idx, __m256i& v, __m256& n01)
 {

src/crypto/soft_aes.h

@@ -130,7 +130,7 @@ static inline uint32_t sub_word(uint32_t key)
          saes_sbox[key & 0xff];
 }
 
-#if defined(__clang__) || defined(XMRIG_ARM)
+#ifndef HAVE_ROTR
 static inline uint32_t _rotr(uint32_t value, uint32_t amount)
 {
     return (value >> amount) | (value << ((32 - amount) & 31));

src/version.h

@@ -28,7 +28,7 @@
 #define APP_ID        "xmrig"
 #define APP_NAME      "XMRig"
 #define APP_DESC      "XMRig CPU miner"
-#define APP_VERSION   "2.14.1"
+#define APP_VERSION   "2.14.4"
 #define APP_DOMAIN    "xmrig.com"
 #define APP_SITE      "www.xmrig.com"
 #define APP_COPYRIGHT "Copyright (C) 2016-2019 xmrig.com"
@@ -36,10 +36,12 @@
 
 #define APP_VER_MAJOR  2
 #define APP_VER_MINOR  14
-#define APP_VER_PATCH  1
+#define APP_VER_PATCH  4
 
 #ifdef _MSC_VER
-#   if (_MSC_VER >= 1910)
+#   if (_MSC_VER >= 1920)
+#       define MSVC_VERSION 2019
+#   elif (_MSC_VER >= 1910 && _MSC_VER < 1920)
 #       define MSVC_VERSION 2017
 #   elif _MSC_VER == 1900
 #       define MSVC_VERSION 2015

src/workers/CpuThread.cpp

@@ -90,31 +90,31 @@ static void patchCode(T dst, U src, const uint32_t iterations, const uint32_t ma
 }
 
 
-extern "C" void cnv2_mainloop_ivybridge_asm(cryptonight_ctx *ctx);
-extern "C" void cnv2_mainloop_ryzen_asm(cryptonight_ctx *ctx);
-extern "C" void cnv2_mainloop_bulldozer_asm(cryptonight_ctx *ctx);
-extern "C" void cnv2_double_mainloop_sandybridge_asm(cryptonight_ctx *ctx0, cryptonight_ctx *ctx1);
+extern "C" void cnv2_mainloop_ivybridge_asm(cryptonight_ctx **ctx);
+extern "C" void cnv2_mainloop_ryzen_asm(cryptonight_ctx **ctx);
+extern "C" void cnv2_mainloop_bulldozer_asm(cryptonight_ctx **ctx);
+extern "C" void cnv2_double_mainloop_sandybridge_asm(cryptonight_ctx **ctx);
 
 
 xmrig::CpuThread::cn_mainloop_fun        cn_half_mainloop_ivybridge_asm             = nullptr;
 xmrig::CpuThread::cn_mainloop_fun        cn_half_mainloop_ryzen_asm                 = nullptr;
 xmrig::CpuThread::cn_mainloop_fun        cn_half_mainloop_bulldozer_asm             = nullptr;
-xmrig::CpuThread::cn_mainloop_double_fun cn_half_double_mainloop_sandybridge_asm    = nullptr;
+xmrig::CpuThread::cn_mainloop_fun        cn_half_double_mainloop_sandybridge_asm    = nullptr;
 
 xmrig::CpuThread::cn_mainloop_fun        cn_trtl_mainloop_ivybridge_asm             = nullptr;
 xmrig::CpuThread::cn_mainloop_fun        cn_trtl_mainloop_ryzen_asm                 = nullptr;
 xmrig::CpuThread::cn_mainloop_fun        cn_trtl_mainloop_bulldozer_asm             = nullptr;
-xmrig::CpuThread::cn_mainloop_double_fun cn_trtl_double_mainloop_sandybridge_asm    = nullptr;
+xmrig::CpuThread::cn_mainloop_fun        cn_trtl_double_mainloop_sandybridge_asm    = nullptr;
 
 xmrig::CpuThread::cn_mainloop_fun        cn_zls_mainloop_ivybridge_asm              = nullptr;
 xmrig::CpuThread::cn_mainloop_fun        cn_zls_mainloop_ryzen_asm                  = nullptr;
 xmrig::CpuThread::cn_mainloop_fun        cn_zls_mainloop_bulldozer_asm              = nullptr;
-xmrig::CpuThread::cn_mainloop_double_fun cn_zls_double_mainloop_sandybridge_asm     = nullptr;
+xmrig::CpuThread::cn_mainloop_fun        cn_zls_double_mainloop_sandybridge_asm     = nullptr;
 
 xmrig::CpuThread::cn_mainloop_fun        cn_double_mainloop_ivybridge_asm           = nullptr;
 xmrig::CpuThread::cn_mainloop_fun        cn_double_mainloop_ryzen_asm               = nullptr;
 xmrig::CpuThread::cn_mainloop_fun        cn_double_mainloop_bulldozer_asm           = nullptr;
-xmrig::CpuThread::cn_mainloop_double_fun cn_double_double_mainloop_sandybridge_asm  = nullptr;
+xmrig::CpuThread::cn_mainloop_fun        cn_double_double_mainloop_sandybridge_asm  = nullptr;
 
 
 void xmrig::CpuThread::patchAsmVariants()
@@ -125,22 +125,22 @@ void xmrig::CpuThread::patchAsmVariants()
     cn_half_mainloop_ivybridge_asm              = reinterpret_cast<cn_mainloop_fun>         (base + 0x0000);
     cn_half_mainloop_ryzen_asm                  = reinterpret_cast<cn_mainloop_fun>         (base + 0x1000);
     cn_half_mainloop_bulldozer_asm              = reinterpret_cast<cn_mainloop_fun>         (base + 0x2000);
-    cn_half_double_mainloop_sandybridge_asm     = reinterpret_cast<cn_mainloop_double_fun>  (base + 0x3000);
+    cn_half_double_mainloop_sandybridge_asm     = reinterpret_cast<cn_mainloop_fun>         (base + 0x3000);
 
     cn_trtl_mainloop_ivybridge_asm              = reinterpret_cast<cn_mainloop_fun>         (base + 0x4000);
     cn_trtl_mainloop_ryzen_asm                  = reinterpret_cast<cn_mainloop_fun>         (base + 0x5000);
     cn_trtl_mainloop_bulldozer_asm              = reinterpret_cast<cn_mainloop_fun>         (base + 0x6000);
-    cn_trtl_double_mainloop_sandybridge_asm     = reinterpret_cast<cn_mainloop_double_fun>  (base + 0x7000);
+    cn_trtl_double_mainloop_sandybridge_asm     = reinterpret_cast<cn_mainloop_fun>         (base + 0x7000);
 
     cn_zls_mainloop_ivybridge_asm               = reinterpret_cast<cn_mainloop_fun>         (base + 0x8000);
     cn_zls_mainloop_ryzen_asm                   = reinterpret_cast<cn_mainloop_fun>         (base + 0x9000);
     cn_zls_mainloop_bulldozer_asm               = reinterpret_cast<cn_mainloop_fun>         (base + 0xA000);
-    cn_zls_double_mainloop_sandybridge_asm      = reinterpret_cast<cn_mainloop_double_fun>  (base + 0xB000);
+    cn_zls_double_mainloop_sandybridge_asm      = reinterpret_cast<cn_mainloop_fun>         (base + 0xB000);
 
     cn_double_mainloop_ivybridge_asm            = reinterpret_cast<cn_mainloop_fun>         (base + 0xC000);
     cn_double_mainloop_ryzen_asm                = reinterpret_cast<cn_mainloop_fun>         (base + 0xD000);
     cn_double_mainloop_bulldozer_asm            = reinterpret_cast<cn_mainloop_fun>         (base + 0xE000);
-    cn_double_double_mainloop_sandybridge_asm   = reinterpret_cast<cn_mainloop_double_fun>  (base + 0xF000);
+    cn_double_double_mainloop_sandybridge_asm   = reinterpret_cast<cn_mainloop_fun>         (base + 0xF000);
 
     patchCode(cn_half_mainloop_ivybridge_asm,            cnv2_mainloop_ivybridge_asm,           xmrig::CRYPTONIGHT_HALF_ITER,   xmrig::CRYPTONIGHT_MASK);
     patchCode(cn_half_mainloop_ryzen_asm,                cnv2_mainloop_ryzen_asm,               xmrig::CRYPTONIGHT_HALF_ITER,   xmrig::CRYPTONIGHT_MASK);

src/workers/CpuThread.h

@@ -61,8 +61,7 @@ public:
     CpuThread(size_t index, Algo algorithm, AlgoVariant av, Multiway multiway, int64_t affinity, int priority, bool softAES, bool prefetch, Assembly assembly);
 
     typedef void (*cn_hash_fun)(const uint8_t *input, size_t size, uint8_t *output, cryptonight_ctx **ctx, uint64_t height);
-    typedef void (*cn_mainloop_fun)(cryptonight_ctx *ctx);
-    typedef void (*cn_mainloop_double_fun)(cryptonight_ctx *ctx1, cryptonight_ctx *ctx2);
+    typedef void (*cn_mainloop_fun)(cryptonight_ctx **ctx);
 
 #   ifndef XMRIG_NO_ASM
     static void patchAsmVariants();