Remove the curve448/decaf sub-directory
[openssl.git] / crypto / ec / curve448 / word.h
1 /* Copyright (c) 2014 Cryptography Research, Inc.
2  * Released under the MIT License.  See LICENSE.txt for license information.
3  */
4
5 #ifndef __WORD_H__
6 #define __WORD_H__
7
8 /* for posix_memalign */
9 #define _XOPEN_SOURCE 600
10 #define __STDC_WANT_LIB_EXT1__ 1 /* for memset_s */
11 #include <string.h>
12 #if defined(__sun) && defined(__SVR4)
13 extern int posix_memalign(void **, size_t, size_t);
14 #endif
15
16 #include <assert.h>
17 #include <stdint.h>
18 #include "arch_intrinsics.h"
19
20 #include "curve448utils.h"
21
22 #ifndef _BSD_SOURCE
23 #define _BSD_SOURCE 1
24 #endif
25
26 #ifndef _DEFAULT_SOURCE
27 #define _DEFAULT_SOURCE 1
28 #endif
29
30 #include "portable_endian.h"
31
32 #include <stdlib.h>
33 #include <sys/types.h>
34 #include <inttypes.h>
35
36 #if defined(__ARM_NEON__)
37 #include <arm_neon.h>
38 #elif defined(__SSE2__)
39     #if !defined(__GNUC__) || __clang__ || __GNUC__ >= 5 || (__GNUC__==4 && __GNUC_MINOR__ >= 4)
40         #include <immintrin.h>
41     #else
42         #include <emmintrin.h>
43     #endif
44 #endif
45
46 #if (ARCH_WORD_BITS == 64)
47     typedef uint64_t word_t, mask_t;
48     typedef __uint128_t dword_t;
49     typedef int32_t hsword_t;
50     typedef int64_t sword_t;
51     typedef __int128_t dsword_t;
52 #elif (ARCH_WORD_BITS == 32)
53     typedef uint32_t word_t, mask_t;
54     typedef uint64_t dword_t;
55     typedef int16_t hsword_t;
56     typedef int32_t sword_t;
57     typedef int64_t dsword_t;
58 #else
59     #error "For now, libdecaf only supports 32- and 64-bit architectures."
60 #endif
61     
62 /* Scalar limbs are keyed off of the API word size instead of the arch word size. */
63 #if DECAF_WORD_BITS == 64
64     #define SC_LIMB(x) (x##ull)
65 #elif DECAF_WORD_BITS == 32
66     #define SC_LIMB(x) ((uint32_t)x##ull),(x##ull>>32)
67 #else
68     #error "For now, libdecaf only supports 32- and 64-bit architectures."
69 #endif
70
71 #ifdef __ARM_NEON__
72     typedef uint32x4_t vecmask_t;
73 #elif __clang__
74     typedef uint64_t uint64x2_t __attribute__((ext_vector_type(2)));
75     typedef int64_t  int64x2_t __attribute__((ext_vector_type(2)));
76     typedef uint64_t uint64x4_t __attribute__((ext_vector_type(4)));
77     typedef int64_t  int64x4_t __attribute__((ext_vector_type(4)));
78     typedef uint32_t uint32x4_t __attribute__((ext_vector_type(4)));
79     typedef int32_t  int32x4_t __attribute__((ext_vector_type(4)));
80     typedef uint32_t uint32x2_t __attribute__((ext_vector_type(2)));
81     typedef int32_t  int32x2_t __attribute__((ext_vector_type(2)));
82     typedef uint32_t uint32x8_t __attribute__((ext_vector_type(8)));
83     typedef int32_t  int32x8_t __attribute__((ext_vector_type(8)));
84     typedef word_t vecmask_t __attribute__((ext_vector_type(4)));
85 #else /* GCC, hopefully? */
86     typedef uint64_t uint64x2_t __attribute__((vector_size(16)));
87     typedef int64_t  int64x2_t __attribute__((vector_size(16)));
88     typedef uint64_t uint64x4_t __attribute__((vector_size(32)));
89     typedef int64_t  int64x4_t __attribute__((vector_size(32)));
90     typedef uint32_t uint32x4_t __attribute__((vector_size(16)));
91     typedef int32_t  int32x4_t __attribute__((vector_size(16)));
92     typedef uint32_t uint32x2_t __attribute__((vector_size(8)));
93     typedef int32_t  int32x2_t __attribute__((vector_size(8)));
94     typedef uint32_t uint32x8_t __attribute__((vector_size(32)));
95     typedef int32_t  int32x8_t __attribute__((vector_size(32)));
96     typedef word_t vecmask_t __attribute__((vector_size(32)));
97 #endif
98
99 #if __AVX2__
100     #define VECTOR_ALIGNED __attribute__((aligned(32)))
101     typedef uint32x8_t big_register_t;
102     typedef uint64x4_t uint64xn_t;
103     typedef uint32x8_t uint32xn_t;
104
105     static DECAF_INLINE big_register_t
106     br_set_to_mask(mask_t x) {
107         uint32_t y = (uint32_t)x;
108         big_register_t ret = {y,y,y,y,y,y,y,y};
109         return ret;
110     }
111 #elif __SSE2__
112     #define VECTOR_ALIGNED __attribute__((aligned(16)))
113     typedef uint32x4_t big_register_t;
114     typedef uint64x2_t uint64xn_t;
115     typedef uint32x4_t uint32xn_t;
116
117     static DECAF_INLINE big_register_t
118     br_set_to_mask(mask_t x) {
119         uint32_t y = x;
120         big_register_t ret = {y,y,y,y};
121         return ret;
122     }
123 #elif __ARM_NEON__
124     #define VECTOR_ALIGNED __attribute__((aligned(16)))
125     typedef uint32x4_t big_register_t;
126     typedef uint64x2_t uint64xn_t;
127     typedef uint32x4_t uint32xn_t;
128     
129     static DECAF_INLINE big_register_t
130     br_set_to_mask(mask_t x) {
131         return vdupq_n_u32(x);
132     }
133 #elif _WIN64 || __amd64__ || __X86_64__ || __aarch64__
134     #define VECTOR_ALIGNED __attribute__((aligned(8)))
135     typedef uint64_t big_register_t, uint64xn_t;
136
137     typedef uint32_t uint32xn_t;
138     static DECAF_INLINE big_register_t
139     br_set_to_mask(mask_t x) {
140         return (big_register_t)x;
141     }
142 #else
143     #define VECTOR_ALIGNED __attribute__((aligned(4)))
144     typedef uint64_t uint64xn_t;
145     typedef uint32_t uint32xn_t;
146     typedef uint32_t big_register_t;
147
148     static DECAF_INLINE big_register_t
149     br_set_to_mask(mask_t x) {
150         return (big_register_t)x;
151     }
152 #endif
153
154 typedef struct {
155     uint64xn_t unaligned;
156 } __attribute__((packed)) unaligned_uint64xn_t;
157
158 typedef struct {
159     uint32xn_t unaligned;
160 } __attribute__((packed)) unaligned_uint32xn_t;
161
162 #if __AVX2__
163     static DECAF_INLINE big_register_t
164     br_is_zero(big_register_t x) {
165         return (big_register_t)(x == br_set_to_mask(0));
166     }
167 #elif __SSE2__
168     static DECAF_INLINE big_register_t
169     br_is_zero(big_register_t x) {
170         return (big_register_t)_mm_cmpeq_epi32((__m128i)x, _mm_setzero_si128());
171         //return (big_register_t)(x == br_set_to_mask(0));
172     }
173 #elif __ARM_NEON__
174     static DECAF_INLINE big_register_t
175     br_is_zero(big_register_t x) {
176         return vceqq_u32(x,x^x);
177     }
178 #else
179     #define br_is_zero word_is_zero
180 #endif
181
182 /**
183  * Really call memset, in a way that prevents the compiler from optimizing it out.
184  * @param p The object to zeroize.
185  * @param c The char to set it to (probably zero).
186  * @param s The size of the object.
187  */
188 #if defined(__DARWIN_C_LEVEL) || defined(__STDC_LIB_EXT1__)
189 #define HAS_MEMSET_S
190 #endif
191
192 #if !defined(__STDC_WANT_LIB_EXT1__) || __STDC_WANT_LIB_EXT1__ != 1
193 #define NEED_MEMSET_S_EXTERN
194 #endif
195
196 #ifdef HAS_MEMSET_S
197     #ifdef NEED_MEMSET_S_EXTERN
198         extern int memset_s(void *, size_t, int, size_t);
199     #endif
200     static DECAF_INLINE void
201     really_memset(void *p, char c, size_t s) {
202         memset_s(p, s, c, s);
203     }
204 #else
205     /* PERF: use words? */
206     static DECAF_INLINE void
207     really_memset(void *p, char c, size_t s) {
208         volatile char *pv = (volatile char *)p;
209         size_t i;
210         for (i=0; i<s; i++) pv[i] = c;
211     }
212 #endif
213
214 /**
215  * Allocate memory which is sufficiently aligned to be used for the
216  * largest vector on the system (for now that's a big_register_t).
217  *
218  * Man malloc says that it does this, but at least for AVX2 on MacOS X,
219  * it's lying.
220  *
221  * @param size The size of the region to allocate.
222  * @return A suitable pointer, which can be free'd with free(),
223  * or NULL if no memory can be allocated.
224  */
225 static DECAF_INLINE void *
226 malloc_vector(size_t size) {
227     void *out = NULL;
228     
229     int ret = posix_memalign(&out, sizeof(big_register_t), size);
230     
231     if (ret) {
232         return NULL;
233     } else {
234         return out;
235     }
236 }
237
238 /* PERF: vectorize vs unroll */
239 #ifdef __clang__
240 #if 100*__clang_major__ + __clang_minor__ > 305
241 #define UNROLL _Pragma("clang loop unroll(full)")
242 #endif
243 #endif
244
245 #ifndef UNROLL
246 #define UNROLL
247 #endif
248
249 /* The plan on booleans:
250  *
251  * The external interface uses decaf_bool_t, but this might be a different
252  * size than our particular arch's word_t (and thus mask_t).  Also, the caller
253  * isn't guaranteed to pass it as nonzero.  So bool_to_mask converts word sizes
254  * and checks nonzero.
255  *
256  * On the flip side, mask_t is always -1 or 0, but it might be a different size
257  * than decaf_bool_t.
258  *
259  * On the third hand, we have success vs boolean types, but that's handled in
260  * common.h: it converts between decaf_bool_t and decaf_error_t.
261  */
262 static DECAF_INLINE decaf_bool_t mask_to_bool (mask_t m) {
263     return (decaf_sword_t)(sword_t)m;
264 }
265
266 static DECAF_INLINE mask_t bool_to_mask (decaf_bool_t m) {
267     /* On most arches this will be optimized to a simple cast. */
268     mask_t ret = 0;
269     unsigned int limit = sizeof(decaf_bool_t)/sizeof(mask_t);
270     if (limit < 1) limit = 1;
271     for (unsigned int i=0; i<limit; i++) {
272         ret |= ~ word_is_zero(m >> (i*8*sizeof(word_t)));
273     }
274     return ret;
275 }
276
277 static DECAF_INLINE void ignore_result ( decaf_bool_t boo ) {
278     (void)boo;
279 }
280
281 #endif /* __WORD_H__ */