CoCalc -- scrypt-jane-portable.h

GitHub Repository: tpruvot/cpuminer-multi
Path: blob/linux/scryptjane/scrypt-jane-portable.h
¹²⁰¹ views
1
/* determine os */
2
#if defined(_WIN32)	|| defined(_WIN64) || defined(__TOS_WIN__) || defined(__WINDOWS__)
3
	#include <windows.h>
4
	#include <wincrypt.h>
5
	#define OS_WINDOWS
6
#elif defined(sun) || defined(__sun) || defined(__SVR4) || defined(__svr4__)
7
	#include <sys/mman.h>
8
	#include <sys/time.h>
9
	#include <fcntl.h>
10

11
	#define OS_SOLARIS
12
#else
13
	#include <sys/mman.h>
14
	#include <sys/time.h>
15
	#include <sys/param.h> /* need this to define BSD */
16
	#include <unistd.h>
17
	#include <fcntl.h>
18

19
	#define OS_NIX
20
	#if defined(__linux__)
21
		#include <endian.h>
22
		#define OS_LINUX
23
	#elif defined(BSD)
24
		#define OS_BSD
25

26
		#if defined(MACOS_X) || (defined(__APPLE__) & defined(__MACH__))
27
			#define OS_OSX
28
		#elif defined(macintosh) || defined(Macintosh)
29
			#define OS_MAC
30
		#elif defined(__OpenBSD__)
31
			#define OS_OPENBSD
32
		#endif
33
	#endif
34
#endif
35

36

37
/* determine compiler */
38
#if defined(_MSC_VER)
39
	#define COMPILER_MSVC _MSC_VER
40
	#if ((COMPILER_MSVC > 1200) || defined(_mm_free))
41
		#define COMPILER_MSVC6PP_AND_LATER
42
	#endif
43
	#if (COMPILER_MSVC >= 1500)
44
		#define COMPILER_HAS_TMMINTRIN
45
	#endif
46
	
47
	#pragma warning(disable : 4127) /* conditional expression is constant */
48
	#pragma warning(disable : 4100) /* unreferenced formal parameter */
49
	
50
	#include <float.h>
51
	#include <stdlib.h> /* _rotl */
52
	#include <intrin.h>
53

54
	typedef unsigned char uint8_t;
55
	typedef unsigned short uint16_t;
56
	typedef unsigned int uint32_t;
57
	typedef signed int int32_t;	
58
	typedef unsigned __int64 uint64_t;
59
	typedef signed __int64 int64_t;
60

61
	#define ROTL32(a,b) _rotl(a,b)
62
	#define ROTR32(a,b) _rotr(a,b)
63
	#define ROTL64(a,b) _rotl64(a,b)
64
	#define ROTR64(a,b) _rotr64(a,b)
65
	#undef NOINLINE
66
	#define NOINLINE __declspec(noinline)
67
	#undef INLINE
68
	#define INLINE __forceinline
69
	#undef FASTCALL
70
	#define FASTCALL __fastcall
71
	#undef CDECL
72
	#define CDECL __cdecl
73
	#undef STDCALL
74
	#define STDCALL __stdcall
75
	#undef NAKED
76
	#define NAKED __declspec(naked)
77
	#define MM16 __declspec(align(16))
78
#endif
79
#if defined(__ICC)
80
	#define COMPILER_INTEL
81
#endif
82
#if defined(__GNUC__)
83
	#if (__GNUC__ >= 3)
84
		#define COMPILER_GCC_PATCHLEVEL __GNUC_PATCHLEVEL__
85
	#else
86
		#define COMPILER_GCC_PATCHLEVEL 0
87
	#endif
88
	#define COMPILER_GCC (__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + COMPILER_GCC_PATCHLEVEL)
89
	#define ROTL32(a,b) (((a) << (b)) | ((a) >> (32 - b)))
90
	#define ROTR32(a,b) (((a) >> (b)) | ((a) << (32 - b)))
91
	#define ROTL64(a,b) (((a) << (b)) | ((a) >> (64 - b)))
92
	#define ROTR64(a,b) (((a) >> (b)) | ((a) << (64 - b)))
93
	#undef NOINLINE
94
	#if (COMPILER_GCC >= 30000)
95
		#define NOINLINE __attribute__((noinline))
96
	#else
97
		#define NOINLINE
98
	#endif
99
	#undef INLINE
100
	#if (COMPILER_GCC >= 30000)
101
		#define INLINE __attribute__((always_inline))
102
	#else
103
		#define INLINE inline
104
	#endif
105
	#undef FASTCALL
106
	#if (COMPILER_GCC >= 30400)
107
		#define FASTCALL __attribute__((fastcall))
108
	#else
109
		#define FASTCALL
110
	#endif
111
	#undef CDECL
112
	#define CDECL __attribute__((cdecl))
113
	#undef STDCALL
114
	#define STDCALL __attribute__((stdcall))
115
	#define MM16 __attribute__((aligned(16)))
116
	#include <stdint.h>
117
#endif
118
#if defined(__MINGW32__) || defined(__MINGW64__)
119
	#define COMPILER_MINGW
120
#endif
121
#if defined(__PATHCC__)
122
	#define COMPILER_PATHCC
123
#endif
124

125
#define OPTIONAL_INLINE
126
#if defined(OPTIONAL_INLINE)
127
	#undef OPTIONAL_INLINE
128
	#define OPTIONAL_INLINE INLINE
129
#else
130
	#define OPTIONAL_INLINE
131
#endif
132

133
#define CRYPTO_FN NOINLINE STDCALL
134

135
/* determine cpu */
136
#if defined(__amd64__) || defined(__amd64) || defined(__x86_64__ ) || defined(_M_X64)
137
	#define CPU_X86_64
138
#elif defined(__i586__) || defined(__i686__) || (defined(_M_IX86) && (_M_IX86 >= 500))
139
	#define CPU_X86 500
140
#elif defined(__i486__) || (defined(_M_IX86) && (_M_IX86 >= 400))
141
	#define CPU_X86 400
142
#elif defined(__i386__) || (defined(_M_IX86) && (_M_IX86 >= 300)) || defined(__X86__) || defined(_X86_) || defined(__I86__)
143
	#define CPU_X86 300
144
#elif defined(__ia64__) || defined(_IA64) || defined(__IA64__) || defined(_M_IA64) || defined(__ia64)
145
	#define CPU_IA64
146
#endif
147

148
#if defined(__sparc__) || defined(__sparc) || defined(__sparcv9)
149
	#define CPU_SPARC
150
	#if defined(__sparcv9)
151
		#define CPU_SPARC64
152
	#endif
153
#endif
154

155
#if defined(CPU_X86_64) || defined(CPU_IA64) || defined(CPU_SPARC64) || defined(__64BIT__) || defined(__LP64__) || defined(_LP64) || (defined(_MIPS_SZLONG) && (_MIPS_SZLONG == 64))
156
	#define CPU_64BITS
157
	#undef FASTCALL
158
	#define FASTCALL
159
	#undef CDECL
160
	#define CDECL
161
	#undef STDCALL
162
	#define STDCALL
163
#endif
164

165
#if defined(powerpc) || defined(__PPC__) || defined(__ppc__) || defined(_ARCH_PPC) || defined(__powerpc__) || defined(__powerpc) || defined(POWERPC) || defined(_M_PPC)
166
	#define CPU_PPC
167
	#if defined(_ARCH_PWR7)
168
		#define CPU_POWER7
169
	#elif defined(__64BIT__)
170
		#define CPU_PPC64
171
	#else
172
		#define CPU_PPC32
173
	#endif
174
#endif
175

176
#if defined(__hppa__) || defined(__hppa)
177
	#define CPU_HPPA
178
#endif
179

180
#if defined(__alpha__) || defined(__alpha) || defined(_M_ALPHA)
181
	#define CPU_ALPHA
182
#endif
183

184
/* endian */
185

186
#if ((defined(__BYTE_ORDER) && defined(__LITTLE_ENDIAN) && (__BYTE_ORDER == __LITTLE_ENDIAN)) || \
187
	 (defined(BYTE_ORDER) && defined(LITTLE_ENDIAN) && (BYTE_ORDER == LITTLE_ENDIAN)) || \
188
	 (defined(CPU_X86) || defined(CPU_X86_64)) || \
189
	 (defined(vax) || defined(MIPSEL) || defined(_MIPSEL)))
190
#define CPU_LE
191
#elif ((defined(__BYTE_ORDER) && defined(__BIG_ENDIAN) && (__BYTE_ORDER == __BIG_ENDIAN)) || \
192
	   (defined(BYTE_ORDER) && defined(BIG_ENDIAN) && (BYTE_ORDER == BIG_ENDIAN)) || \
193
	   (defined(CPU_SPARC) || defined(CPU_PPC) || defined(mc68000) || defined(sel)) || defined(_MIPSEB))
194
#define CPU_BE
195
#else
196
	/* unknown endian! */
197
#endif
198

199

200
#define U8TO32_BE(p)                                            \
201
	(((uint32_t)((p)[0]) << 24) | ((uint32_t)((p)[1]) << 16) |  \
202
	 ((uint32_t)((p)[2]) <<  8) | ((uint32_t)((p)[3])      ))
203

204
#define U8TO32_LE(p)                                            \
205
	(((uint32_t)((p)[0])      ) | ((uint32_t)((p)[1]) <<  8) |  \
206
	 ((uint32_t)((p)[2]) << 16) | ((uint32_t)((p)[3]) << 24))
207

208
#define U32TO8_BE(p, v)                                           \
209
	(p)[0] = (uint8_t)((v) >> 24); (p)[1] = (uint8_t)((v) >> 16); \
210
	(p)[2] = (uint8_t)((v) >>  8); (p)[3] = (uint8_t)((v)      );
211

212
#define U32TO8_LE(p, v)                                           \
213
	(p)[0] = (uint8_t)((v)      ); (p)[1] = (uint8_t)((v) >>  8); \
214
	(p)[2] = (uint8_t)((v) >> 16); (p)[3] = (uint8_t)((v) >> 24);
215

216
#define U8TO64_BE(p)                                                  \
217
	(((uint64_t)U8TO32_BE(p) << 32) | (uint64_t)U8TO32_BE((p) + 4))
218

219
#define U8TO64_LE(p)                                                  \
220
	(((uint64_t)U8TO32_LE(p)) | ((uint64_t)U8TO32_LE((p) + 4) << 32))
221

222
#define U64TO8_BE(p, v)                        \
223
	U32TO8_BE((p),     (uint32_t)((v) >> 32)); \
224
	U32TO8_BE((p) + 4, (uint32_t)((v)      ));
225

226
#define U64TO8_LE(p, v)                        \
227
	U32TO8_LE((p),     (uint32_t)((v)      )); \
228
	U32TO8_LE((p) + 4, (uint32_t)((v) >> 32));
229

230
#define U32_SWAP(v) {                                             \
231
	(v) = (((v) << 8) & 0xFF00FF00 ) | (((v) >> 8) & 0xFF00FF );  \
232
    (v) = ((v) << 16) | ((v) >> 16);                              \
233
}
234

235
#define U64_SWAP(v) {                                                                       \
236
	(v) = (((v) <<  8) & 0xFF00FF00FF00FF00ull ) | (((v) >>  8) & 0x00FF00FF00FF00FFull );  \
237
	(v) = (((v) << 16) & 0xFFFF0000FFFF0000ull ) | (((v) >> 16) & 0x0000FFFF0000FFFFull );  \
238
    (v) = ((v) << 32) | ((v) >> 32);                                                        \
239
}
240

241
static int
242
scrypt_verify(const uint8_t *x, const uint8_t *y, size_t len) {
243
	uint32_t differentbits = 0;
244
	while (len--)
245
		differentbits |= (*x++ ^ *y++);
246
	return (1 & ((differentbits - 1) >> 8));
247
}
248

249
void
250
scrypt_ensure_zero(void *p, size_t len) {
251
#if ((defined(CPU_X86) || defined(CPU_X86_64)) && defined(COMPILER_MSVC))
252
		__stosb((unsigned char *)p, 0, len);
253
#elif (defined(CPU_X86) && defined(COMPILER_GCC))
254
	__asm__ __volatile__(
255
		"pushl %%edi;\n"
256
		"pushl %%ecx;\n"
257
		"rep stosb;\n"
258
		"popl %%ecx;\n"
259
		"popl %%edi;\n"
260
		:: "a"(0), "D"(p), "c"(len) : "cc", "memory"
261
	);
262
#elif (defined(CPU_X86_64) && defined(COMPILER_GCC))
263
	__asm__ __volatile__(
264
		"pushq %%rdi;\n"
265
		"pushq %%rcx;\n"
266
		"rep stosb;\n"
267
		"popq %%rcx;\n"
268
		"popq %%rdi;\n"
269
		:: "a"(0), "D"(p), "c"(len) : "cc", "memory"
270
	);
271
#else
272
	volatile uint8_t *b = (volatile uint8_t *)p;
273
	size_t i;
274
	for (i = 0; i < len; i++)
275
		b[i] = 0;
276
#endif
277
}
278

279
#ifdef __arm__
280

281
static size_t detect_cpu(void) {
282
	return 0;
283
}
284

285
#endif
286

287
#include "scrypt-jane-portable-x86.h"
288

289

290
Product

Resources

Company
