CoCalc -- tomcrypt

GitHub Repository: wine-mirror/wine
Path: blob/master/libs/tomcrypt/src/headers/tomcrypt_macros.h
⁵⁹⁷¹ views
1
/* LibTomCrypt, modular cryptographic library -- Tom St Denis
2
 *
3
 * LibTomCrypt is a library that provides various cryptographic
4
 * algorithms in a highly modular and flexible manner.
5
 *
6
 * The library is free for all purposes without any express
7
 * guarantee it works.
8
 */
9

10
/* ---- HELPER MACROS ---- */
11
#ifdef ENDIAN_NEUTRAL
12

13
#define STORE32L(x, y)                                                                     \
14
  do { (y)[3] = (unsigned char)(((x)>>24)&255); (y)[2] = (unsigned char)(((x)>>16)&255);   \
15
       (y)[1] = (unsigned char)(((x)>>8)&255); (y)[0] = (unsigned char)((x)&255); } while(0)
16

17
#define LOAD32L(x, y)                            \
18
  do { x = ((ulong32)((y)[3] & 255)<<24) | \
19
           ((ulong32)((y)[2] & 255)<<16) | \
20
           ((ulong32)((y)[1] & 255)<<8)  | \
21
           ((ulong32)((y)[0] & 255)); } while(0)
22

23
#define STORE64L(x, y)                                                                     \
24
  do { (y)[7] = (unsigned char)(((x)>>56)&255); (y)[6] = (unsigned char)(((x)>>48)&255);   \
25
       (y)[5] = (unsigned char)(((x)>>40)&255); (y)[4] = (unsigned char)(((x)>>32)&255);   \
26
       (y)[3] = (unsigned char)(((x)>>24)&255); (y)[2] = (unsigned char)(((x)>>16)&255);   \
27
       (y)[1] = (unsigned char)(((x)>>8)&255); (y)[0] = (unsigned char)((x)&255); } while(0)
28

29
#define LOAD64L(x, y)                                                       \
30
  do { x = (((ulong64)((y)[7] & 255))<<56)|(((ulong64)((y)[6] & 255))<<48)| \
31
           (((ulong64)((y)[5] & 255))<<40)|(((ulong64)((y)[4] & 255))<<32)| \
32
           (((ulong64)((y)[3] & 255))<<24)|(((ulong64)((y)[2] & 255))<<16)| \
33
           (((ulong64)((y)[1] & 255))<<8)|(((ulong64)((y)[0] & 255))); } while(0)
34

35
#define STORE32H(x, y)                                                                     \
36
  do { (y)[0] = (unsigned char)(((x)>>24)&255); (y)[1] = (unsigned char)(((x)>>16)&255);   \
37
       (y)[2] = (unsigned char)(((x)>>8)&255); (y)[3] = (unsigned char)((x)&255); } while(0)
38

39
#define LOAD32H(x, y)                            \
40
  do { x = ((ulong32)((y)[0] & 255)<<24) | \
41
           ((ulong32)((y)[1] & 255)<<16) | \
42
           ((ulong32)((y)[2] & 255)<<8)  | \
43
           ((ulong32)((y)[3] & 255)); } while(0)
44

45
#define STORE64H(x, y)                                                                     \
46
do { (y)[0] = (unsigned char)(((x)>>56)&255); (y)[1] = (unsigned char)(((x)>>48)&255);     \
47
     (y)[2] = (unsigned char)(((x)>>40)&255); (y)[3] = (unsigned char)(((x)>>32)&255);     \
48
     (y)[4] = (unsigned char)(((x)>>24)&255); (y)[5] = (unsigned char)(((x)>>16)&255);     \
49
     (y)[6] = (unsigned char)(((x)>>8)&255); (y)[7] = (unsigned char)((x)&255); } while(0)
50

51
#define LOAD64H(x, y)                                                      \
52
do { x = (((ulong64)((y)[0] & 255))<<56)|(((ulong64)((y)[1] & 255))<<48) | \
53
         (((ulong64)((y)[2] & 255))<<40)|(((ulong64)((y)[3] & 255))<<32) | \
54
         (((ulong64)((y)[4] & 255))<<24)|(((ulong64)((y)[5] & 255))<<16) | \
55
         (((ulong64)((y)[6] & 255))<<8)|(((ulong64)((y)[7] & 255))); } while(0)
56

57

58
#elif defined(ENDIAN_LITTLE)
59

60
#ifdef LTC_HAVE_BSWAP_BUILTIN
61

62
#define STORE32H(x, y)                          \
63
do { ulong32 __t = __builtin_bswap32 ((x));     \
64
      XMEMCPY ((y), &__t, 4); } while(0)
65

66
#define LOAD32H(x, y)                           \
67
do { XMEMCPY (&(x), (y), 4);                    \
68
      (x) = __builtin_bswap32 ((x)); } while(0)
69

70
#elif !defined(LTC_NO_BSWAP) && (defined(INTEL_CC) || (defined(__GNUC__) && (defined(__DJGPP__) || defined(__CYGWIN__) || defined(__MINGW32__) || defined(__i386__) || defined(__x86_64__))))
71

72
#define STORE32H(x, y)           \
73
asm __volatile__ (               \
74
   "bswapl %0     \n\t"          \
75
   "movl   %0,(%1)\n\t"          \
76
   "bswapl %0     \n\t"          \
77
      ::"r"(x), "r"(y));
78

79
#define LOAD32H(x, y)          \
80
asm __volatile__ (             \
81
   "movl (%1),%0\n\t"          \
82
   "bswapl %0\n\t"             \
83
   :"=r"(x): "r"(y));
84

85
#else
86

87
#define STORE32H(x, y)                                                                     \
88
  do { (y)[0] = (unsigned char)(((x)>>24)&255); (y)[1] = (unsigned char)(((x)>>16)&255);   \
89
       (y)[2] = (unsigned char)(((x)>>8)&255); (y)[3] = (unsigned char)((x)&255); } while(0)
90

91
#define LOAD32H(x, y)                            \
92
  do { x = ((ulong32)((y)[0] & 255)<<24) | \
93
           ((ulong32)((y)[1] & 255)<<16) | \
94
           ((ulong32)((y)[2] & 255)<<8)  | \
95
           ((ulong32)((y)[3] & 255)); } while(0)
96

97
#endif
98

99
#ifdef LTC_HAVE_BSWAP_BUILTIN
100

101
#define STORE64H(x, y)                          \
102
do { ulong64 __t = __builtin_bswap64 ((x));     \
103
      XMEMCPY ((y), &__t, 8); } while(0)
104

105
#define LOAD64H(x, y)                           \
106
do { XMEMCPY (&(x), (y), 8);                    \
107
      (x) = __builtin_bswap64 ((x)); } while(0)
108

109
/* x86_64 processor */
110
#elif !defined(LTC_NO_BSWAP) && (defined(__GNUC__) && defined(__x86_64__))
111

112
#define STORE64H(x, y)           \
113
asm __volatile__ (               \
114
   "bswapq %0     \n\t"          \
115
   "movq   %0,(%1)\n\t"          \
116
   "bswapq %0     \n\t"          \
117
   ::"r"(x), "r"(y): "memory");
118

119
#define LOAD64H(x, y)          \
120
asm __volatile__ (             \
121
   "movq (%1),%0\n\t"          \
122
   "bswapq %0\n\t"             \
123
   :"=r"(x): "r"(y): "memory");
124

125
#else
126

127
#define STORE64H(x, y)                                                                     \
128
do { (y)[0] = (unsigned char)(((x)>>56)&255); (y)[1] = (unsigned char)(((x)>>48)&255);     \
129
     (y)[2] = (unsigned char)(((x)>>40)&255); (y)[3] = (unsigned char)(((x)>>32)&255);     \
130
     (y)[4] = (unsigned char)(((x)>>24)&255); (y)[5] = (unsigned char)(((x)>>16)&255);     \
131
     (y)[6] = (unsigned char)(((x)>>8)&255); (y)[7] = (unsigned char)((x)&255); } while(0)
132

133
#define LOAD64H(x, y)                                                      \
134
do { x = (((ulong64)((y)[0] & 255))<<56)|(((ulong64)((y)[1] & 255))<<48) | \
135
         (((ulong64)((y)[2] & 255))<<40)|(((ulong64)((y)[3] & 255))<<32) | \
136
         (((ulong64)((y)[4] & 255))<<24)|(((ulong64)((y)[5] & 255))<<16) | \
137
         (((ulong64)((y)[6] & 255))<<8)|(((ulong64)((y)[7] & 255))); } while(0)
138

139
#endif
140

141
#ifdef ENDIAN_32BITWORD
142

143
#define STORE32L(x, y)        \
144
  do { ulong32  __t = (x); XMEMCPY(y, &__t, 4); } while(0)
145

146
#define LOAD32L(x, y)         \
147
  do { XMEMCPY(&(x), y, 4); } while(0)
148

149
#define STORE64L(x, y)                                                                     \
150
  do { (y)[7] = (unsigned char)(((x)>>56)&255); (y)[6] = (unsigned char)(((x)>>48)&255);   \
151
       (y)[5] = (unsigned char)(((x)>>40)&255); (y)[4] = (unsigned char)(((x)>>32)&255);   \
152
       (y)[3] = (unsigned char)(((x)>>24)&255); (y)[2] = (unsigned char)(((x)>>16)&255);   \
153
       (y)[1] = (unsigned char)(((x)>>8)&255); (y)[0] = (unsigned char)((x)&255); } while(0)
154

155
#define LOAD64L(x, y)                                                       \
156
  do { x = (((ulong64)((y)[7] & 255))<<56)|(((ulong64)((y)[6] & 255))<<48)| \
157
           (((ulong64)((y)[5] & 255))<<40)|(((ulong64)((y)[4] & 255))<<32)| \
158
           (((ulong64)((y)[3] & 255))<<24)|(((ulong64)((y)[2] & 255))<<16)| \
159
           (((ulong64)((y)[1] & 255))<<8)|(((ulong64)((y)[0] & 255))); } while(0)
160

161
#else /* 64-bit words then  */
162

163
#define STORE32L(x, y)        \
164
  do { ulong32 __t = (x); XMEMCPY(y, &__t, 4); } while(0)
165

166
#define LOAD32L(x, y)         \
167
  do { XMEMCPY(&(x), y, 4); x &= 0xFFFFFFFF; } while(0)
168

169
#define STORE64L(x, y)        \
170
  do { ulong64 __t = (x); XMEMCPY(y, &__t, 8); } while(0)
171

172
#define LOAD64L(x, y)         \
173
  do { XMEMCPY(&(x), y, 8); } while(0)
174

175
#endif /* ENDIAN_64BITWORD */
176

177
#elif defined(ENDIAN_BIG)
178

179
#define STORE32L(x, y)                                                                     \
180
  do { (y)[3] = (unsigned char)(((x)>>24)&255); (y)[2] = (unsigned char)(((x)>>16)&255);   \
181
       (y)[1] = (unsigned char)(((x)>>8)&255); (y)[0] = (unsigned char)((x)&255); } while(0)
182

183
#define LOAD32L(x, y)                            \
184
  do { x = ((ulong32)((y)[3] & 255)<<24) | \
185
           ((ulong32)((y)[2] & 255)<<16) | \
186
           ((ulong32)((y)[1] & 255)<<8)  | \
187
           ((ulong32)((y)[0] & 255)); } while(0)
188

189
#define STORE64L(x, y)                                                                     \
190
do { (y)[7] = (unsigned char)(((x)>>56)&255); (y)[6] = (unsigned char)(((x)>>48)&255);     \
191
     (y)[5] = (unsigned char)(((x)>>40)&255); (y)[4] = (unsigned char)(((x)>>32)&255);     \
192
     (y)[3] = (unsigned char)(((x)>>24)&255); (y)[2] = (unsigned char)(((x)>>16)&255);     \
193
     (y)[1] = (unsigned char)(((x)>>8)&255); (y)[0] = (unsigned char)((x)&255); } while(0)
194

195
#define LOAD64L(x, y)                                                      \
196
do { x = (((ulong64)((y)[7] & 255))<<56)|(((ulong64)((y)[6] & 255))<<48) | \
197
         (((ulong64)((y)[5] & 255))<<40)|(((ulong64)((y)[4] & 255))<<32) | \
198
         (((ulong64)((y)[3] & 255))<<24)|(((ulong64)((y)[2] & 255))<<16) | \
199
         (((ulong64)((y)[1] & 255))<<8)|(((ulong64)((y)[0] & 255))); } while(0)
200

201
#ifdef ENDIAN_32BITWORD
202

203
#define STORE32H(x, y)        \
204
  do { ulong32 __t = (x); XMEMCPY(y, &__t, 4); } while(0)
205

206
#define LOAD32H(x, y)         \
207
  do { XMEMCPY(&(x), y, 4); } while(0)
208

209
#define STORE64H(x, y)                                                                     \
210
  do { (y)[0] = (unsigned char)(((x)>>56)&255); (y)[1] = (unsigned char)(((x)>>48)&255);   \
211
       (y)[2] = (unsigned char)(((x)>>40)&255); (y)[3] = (unsigned char)(((x)>>32)&255);   \
212
       (y)[4] = (unsigned char)(((x)>>24)&255); (y)[5] = (unsigned char)(((x)>>16)&255);   \
213
       (y)[6] = (unsigned char)(((x)>>8)&255);  (y)[7] = (unsigned char)((x)&255); } while(0)
214

215
#define LOAD64H(x, y)                                                       \
216
  do { x = (((ulong64)((y)[0] & 255))<<56)|(((ulong64)((y)[1] & 255))<<48)| \
217
           (((ulong64)((y)[2] & 255))<<40)|(((ulong64)((y)[3] & 255))<<32)| \
218
           (((ulong64)((y)[4] & 255))<<24)|(((ulong64)((y)[5] & 255))<<16)| \
219
           (((ulong64)((y)[6] & 255))<<8)| (((ulong64)((y)[7] & 255))); } while(0)
220

221
#else /* 64-bit words then  */
222

223
#define STORE32H(x, y)        \
224
  do { ulong32 __t = (x); XMEMCPY(y, &__t, 4); } while(0)
225

226
#define LOAD32H(x, y)         \
227
  do { XMEMCPY(&(x), y, 4); x &= 0xFFFFFFFF; } while(0)
228

229
#define STORE64H(x, y)        \
230
  do { ulong64 __t = (x); XMEMCPY(y, &__t, 8); } while(0)
231

232
#define LOAD64H(x, y)         \
233
  do { XMEMCPY(&(x), y, 8); } while(0)
234

235
#endif /* ENDIAN_64BITWORD */
236
#endif /* ENDIAN_BIG */
237

238
#define BSWAP(x)  ( ((x>>24)&0x000000FFUL) | ((x<<24)&0xFF000000UL)  | \
239
                    ((x>>8)&0x0000FF00UL)  | ((x<<8)&0x00FF0000UL) )
240

241

242
/* 32-bit Rotates */
243
#if defined(_MSC_VER)
244
#define LTC_ROx_ASM
245

246
/* instrinsic rotate */
247
#include <stdlib.h>
248
#pragma intrinsic(_lrotr,_lrotl)
249
#define ROR(x,n) _lrotr(x,n)
250
#define ROL(x,n) _lrotl(x,n)
251
#define RORc(x,n) _lrotr(x,n)
252
#define ROLc(x,n) _lrotl(x,n)
253

254
#elif !defined(__STRICT_ANSI__) && defined(__GNUC__) && (defined(__i386__) || defined(__x86_64__)) && !defined(INTEL_CC) && !defined(LTC_NO_ASM)
255
#define LTC_ROx_ASM
256

257
static inline ulong32 ROL(ulong32 word, int i)
258
{
259
   asm ("roll %%cl,%0"
260
      :"=r" (word)
261
      :"0" (word),"c" (i));
262
   return word;
263
}
264

265
static inline ulong32 ROR(ulong32 word, int i)
266
{
267
   asm ("rorl %%cl,%0"
268
      :"=r" (word)
269
      :"0" (word),"c" (i));
270
   return word;
271
}
272

273
#ifndef LTC_NO_ROLC
274

275
#define ROLc(word,i) ({ \
276
   ulong32 __ROLc_tmp = (word); \
277
   __asm__ ("roll %2, %0" : \
278
            "=r" (__ROLc_tmp) : \
279
            "0" (__ROLc_tmp), \
280
            "I" (i)); \
281
            __ROLc_tmp; \
282
   })
283
#define RORc(word,i) ({ \
284
   ulong32 __RORc_tmp = (word); \
285
   __asm__ ("rorl %2, %0" : \
286
            "=r" (__RORc_tmp) : \
287
            "0" (__RORc_tmp), \
288
            "I" (i)); \
289
            __RORc_tmp; \
290
   })
291

292
#else
293

294
#define ROLc ROL
295
#define RORc ROR
296

297
#endif
298

299
#elif !defined(__STRICT_ANSI__) && defined(LTC_PPC32)
300
#define LTC_ROx_ASM
301

302
static inline ulong32 ROL(ulong32 word, int i)
303
{
304
   asm ("rotlw %0,%0,%2"
305
      :"=r" (word)
306
      :"0" (word),"r" (i));
307
   return word;
308
}
309

310
static inline ulong32 ROR(ulong32 word, int i)
311
{
312
   asm ("rotlw %0,%0,%2"
313
      :"=r" (word)
314
      :"0" (word),"r" (32-i));
315
   return word;
316
}
317

318
#ifndef LTC_NO_ROLC
319

320
static inline ulong32 ROLc(ulong32 word, const int i)
321
{
322
   asm ("rotlwi %0,%0,%2"
323
      :"=r" (word)
324
      :"0" (word),"I" (i));
325
   return word;
326
}
327

328
static inline ulong32 RORc(ulong32 word, const int i)
329
{
330
   asm ("rotrwi %0,%0,%2"
331
      :"=r" (word)
332
      :"0" (word),"I" (i));
333
   return word;
334
}
335

336
#else
337

338
#define ROLc ROL
339
#define RORc ROR
340

341
#endif
342

343

344
#else
345

346
/* rotates the hard way */
347
#define ROL(x, y) ( (((ulong32)(x)<<(ulong32)((y)&31)) | (((ulong32)(x)&0xFFFFFFFFUL)>>(ulong32)((32-((y)&31))&31))) & 0xFFFFFFFFUL)
348
#define ROR(x, y) ( ((((ulong32)(x)&0xFFFFFFFFUL)>>(ulong32)((y)&31)) | ((ulong32)(x)<<(ulong32)((32-((y)&31))&31))) & 0xFFFFFFFFUL)
349
#define ROLc(x, y) ( (((ulong32)(x)<<(ulong32)((y)&31)) | (((ulong32)(x)&0xFFFFFFFFUL)>>(ulong32)((32-((y)&31))&31))) & 0xFFFFFFFFUL)
350
#define RORc(x, y) ( ((((ulong32)(x)&0xFFFFFFFFUL)>>(ulong32)((y)&31)) | ((ulong32)(x)<<(ulong32)((32-((y)&31))&31))) & 0xFFFFFFFFUL)
351

352
#endif
353

354

355
/* 64-bit Rotates */
356
#if !defined(__STRICT_ANSI__) && defined(__GNUC__) && defined(__x86_64__) && !defined(_WIN64) && !defined(LTC_NO_ASM)
357

358
static inline ulong64 ROL64(ulong64 word, int i)
359
{
360
   asm("rolq %%cl,%0"
361
      :"=r" (word)
362
      :"0" (word),"c" (i));
363
   return word;
364
}
365

366
static inline ulong64 ROR64(ulong64 word, int i)
367
{
368
   asm("rorq %%cl,%0"
369
      :"=r" (word)
370
      :"0" (word),"c" (i));
371
   return word;
372
}
373

374
#ifndef LTC_NO_ROLC
375

376
#define ROL64c(word,i) ({ \
377
   ulong64 __ROL64c_tmp = word; \
378
   __asm__ ("rolq %2, %0" : \
379
            "=r" (__ROL64c_tmp) : \
380
            "0" (__ROL64c_tmp), \
381
            "J" (i)); \
382
            __ROL64c_tmp; \
383
   })
384
#define ROR64c(word,i) ({ \
385
   ulong64 __ROR64c_tmp = word; \
386
   __asm__ ("rorq %2, %0" : \
387
            "=r" (__ROR64c_tmp) : \
388
            "0" (__ROR64c_tmp), \
389
            "J" (i)); \
390
            __ROR64c_tmp; \
391
   })
392

393
#else /* LTC_NO_ROLC */
394

395
#define ROL64c ROL64
396
#define ROR64c ROR64
397

398
#endif
399

400
#else /* Not x86_64  */
401

402
#define ROL64(x, y) \
403
    ( (((x)<<((ulong64)(y)&63)) | \
404
      (((x)&CONST64(0xFFFFFFFFFFFFFFFF))>>(((ulong64)64-((y)&63))&63))) & CONST64(0xFFFFFFFFFFFFFFFF))
405

406
#define ROR64(x, y) \
407
    ( ((((x)&CONST64(0xFFFFFFFFFFFFFFFF))>>((ulong64)(y)&CONST64(63))) | \
408
      ((x)<<(((ulong64)64-((y)&63))&63))) & CONST64(0xFFFFFFFFFFFFFFFF))
409

410
#define ROL64c(x, y) \
411
    ( (((x)<<((ulong64)(y)&63)) | \
412
      (((x)&CONST64(0xFFFFFFFFFFFFFFFF))>>(((ulong64)64-((y)&63))&63))) & CONST64(0xFFFFFFFFFFFFFFFF))
413

414
#define ROR64c(x, y) \
415
    ( ((((x)&CONST64(0xFFFFFFFFFFFFFFFF))>>((ulong64)(y)&CONST64(63))) | \
416
      ((x)<<(((ulong64)64-((y)&63))&63))) & CONST64(0xFFFFFFFFFFFFFFFF))
417

418
#endif
419

420
#ifndef MAX
421
   #define MAX(x, y) ( ((x)>(y))?(x):(y) )
422
#endif
423

424
#ifndef MIN
425
   #define MIN(x, y) ( ((x)<(y))?(x):(y) )
426
#endif
427

428
#ifndef LTC_UNUSED_PARAM
429
   #define LTC_UNUSED_PARAM(x) (void)(x)
430
#endif
431

432
/* extract a byte portably */
433
#ifdef _MSC_VER
434
   #define byte(x, n) ((unsigned char)((x) >> (8 * (n))))
435
#else
436
   #define byte(x, n) (((x) >> (8 * (n))) & 255)
437
#endif
438

439
/* there is no snprintf before Visual C++ 2015 */
440
#if defined(_MSC_VER) && _MSC_VER < 1900
441
#define snprintf _snprintf
442
#endif
443

444
Product

Resources

Company
