Manual formatting tweaks to Curve448 code
[openssl.git] / crypto / ec / curve448 / arch_x86_64 / arch_intrinsics.h
1 /*
2  * Copyright 2017 The OpenSSL Project Authors. All Rights Reserved.
3  * Copyright 2014-2016 Cryptography Research, Inc.
4  *
5  * Licensed under the OpenSSL license (the "License").  You may not use
6  * this file except in compliance with the License.  You can obtain a copy
7  * in the file LICENSE in the source distribution or at
8  * https://www.openssl.org/source/license.html
9  *
10  * Originally written by Mike Hamburg
11  */
12 #ifndef __ARCH_X86_64_ARCH_INTRINSICS_H__
13 #define __ARCH_X86_64_ARCH_INTRINSICS_H__
14
15 #define ARCH_WORD_BITS 64
16
17 #include <openssl/e_os2.h>
18
19 /* FUTURE: autogenerate */
20 static __inline__ __uint128_t widemul(const uint64_t *a, const uint64_t *b)
21 {
22   uint64_t c, d;
23
24   #ifndef __BMI2__
25       __asm__ volatile
26           ("movq %[a], %%rax;"
27            "mulq %[b];"
28            : [c]"=&a"(c), [d]"=d"(d)
29            : [b]"m"(*b), [a]"m"(*a)
30            : "cc");
31   #else
32       __asm__ volatile
33           ("movq %[a], %%rdx;"
34            "mulx %[b], %[c], %[d];"
35            : [c]"=r"(c), [d]"=r"(d)
36            : [b]"m"(*b), [a]"m"(*a)
37            : "rdx");
38   #endif
39   return (((__uint128_t)(d)) << 64) | c;
40 }
41
42 static __inline__ __uint128_t widemul_rm(uint64_t a, const uint64_t *b)
43 {
44   uint64_t c, d;
45
46   #ifndef __BMI2__
47       __asm__ volatile
48           ("movq %[a], %%rax;"
49            "mulq %[b];"
50            : [c]"=&a"(c), [d]"=d"(d)
51            : [b]"m"(*b), [a]"r"(a)
52            : "cc");
53   #else
54       __asm__ volatile
55           ("mulx %[b], %[c], %[d];"
56            : [c]"=r"(c), [d]"=r"(d)
57            : [b]"m"(*b), [a]"d"(a));
58   #endif
59   return (((__uint128_t)(d)) << 64) | c;
60 }
61
62 static __inline__ __uint128_t widemul_rr(uint64_t a, uint64_t b)
63 {
64   uint64_t c, d;
65
66   #ifndef __BMI2__
67       __asm__ volatile
68           ("mulq %[b];"
69            : [c]"=a"(c), [d]"=d"(d)
70            : [b]"r"(b), "a"(a)
71            : "cc");
72   #else
73       __asm__ volatile
74           ("mulx %[b], %[c], %[d];"
75            : [c]"=r"(c), [d]"=r"(d)
76            : [b]"r"(b), [a]"d"(a));
77   #endif
78   return (((__uint128_t)(d)) << 64) | c;
79 }
80
81 static __inline__ __uint128_t widemul2(const uint64_t *a, const uint64_t *b)
82 {
83   uint64_t c, d;
84
85   #ifndef __BMI2__
86       __asm__ volatile
87           ("movq %[a], %%rax; "
88            "addq %%rax, %%rax; "
89            "mulq %[b];"
90            : [c]"=&a"(c), [d]"=d"(d)
91            : [b]"m"(*b), [a]"m"(*a)
92            : "cc");
93   #else
94       __asm__ volatile
95           ("movq %[a], %%rdx;"
96            "leaq (,%%rdx,2), %%rdx;"
97            "mulx %[b], %[c], %[d];"
98            : [c]"=r"(c), [d]"=r"(d)
99            : [b]"m"(*b), [a]"m"(*a)
100            : "rdx");
101   #endif
102   return (((__uint128_t)(d)) << 64) | c;
103 }
104
105 static __inline__ void mac(__uint128_t *acc, const uint64_t *a,
106                            const uint64_t *b)
107 {
108   uint64_t lo = *acc, hi = *acc >> 64;
109   
110   #ifdef __BMI2__
111       uint64_t c,d;
112       __asm__ volatile
113           ("movq %[a], %%rdx; "
114            "mulx %[b], %[c], %[d]; "
115            "addq %[c], %[lo]; "
116            "adcq %[d], %[hi]; "
117            : [c]"=&r"(c), [d]"=&r"(d), [lo]"+r"(lo), [hi]"+r"(hi)
118            : [b]"m"(*b), [a]"m"(*a)
119            : "rdx", "cc");
120   #else
121       __asm__ volatile
122           ("movq %[a], %%rax; "
123            "mulq %[b]; "
124            "addq %%rax, %[lo]; "
125            "adcq %%rdx, %[hi]; "
126            : [lo]"+r"(lo), [hi]"+r"(hi)
127            : [b]"m"(*b), [a]"m"(*a)
128            : "rax", "rdx", "cc");
129   #endif
130   
131   *acc = (((__uint128_t)(hi)) << 64) | lo;
132 }
133
134 static __inline__ void macac(__uint128_t *acc, __uint128_t *acc2,
135                              const uint64_t *a, const uint64_t *b)
136 {
137   uint64_t lo = *acc, hi = *acc >> 64;
138   uint64_t lo2 = *acc2, hi2 = *acc2 >> 64;
139   
140   #ifdef __BMI2__
141       uint64_t c,d;
142       __asm__ volatile
143           ("movq %[a], %%rdx; "
144            "mulx %[b], %[c], %[d]; "
145            "addq %[c], %[lo]; "
146            "adcq %[d], %[hi]; "
147            "addq %[c], %[lo2]; "
148            "adcq %[d], %[hi2]; "
149            : [c]"=r"(c), [d]"=r"(d), [lo]"+r"(lo), [hi]"+r"(hi), [lo2]"+r"(lo2), [hi2]"+r"(hi2)
150            : [b]"m"(*b), [a]"m"(*a)
151            : "rdx", "cc");
152   #else
153       __asm__ volatile
154           ("movq %[a], %%rax; "
155            "mulq %[b]; "
156            "addq %%rax, %[lo]; "
157            "adcq %%rdx, %[hi]; "
158            "addq %%rax, %[lo2]; "
159            "adcq %%rdx, %[hi2]; "
160            : [lo]"+r"(lo), [hi]"+r"(hi), [lo2]"+r"(lo2), [hi2]"+r"(hi2)
161            : [b]"m"(*b), [a]"m"(*a)
162            : "rax", "rdx", "cc");
163   #endif
164   
165   *acc = (((__uint128_t)(hi)) << 64) | lo;
166   *acc2 = (((__uint128_t)(hi2)) << 64) | lo2;
167 }
168
169 static __inline__ void mac_rm(__uint128_t *acc, uint64_t a, const uint64_t *b)
170 {
171   uint64_t lo = *acc, hi = *acc >> 64;
172   
173   #ifdef __BMI2__
174       uint64_t c,d;
175       __asm__ volatile
176           ("mulx %[b], %[c], %[d]; "
177            "addq %[c], %[lo]; "
178            "adcq %[d], %[hi]; "
179            : [c]"=r"(c), [d]"=r"(d), [lo]"+r"(lo), [hi]"+r"(hi)
180            : [b]"m"(*b), [a]"d"(a)
181            : "cc");
182   #else
183       __asm__ volatile
184           ("movq %[a], %%rax; "
185            "mulq %[b]; "
186            "addq %%rax, %[lo]; "
187            "adcq %%rdx, %[hi]; "
188            : [lo]"+r"(lo), [hi]"+r"(hi)
189            : [b]"m"(*b), [a]"r"(a)
190            : "rax", "rdx", "cc");
191   #endif
192   
193   *acc = (((__uint128_t)(hi)) << 64) | lo;
194 }
195
196 static __inline__ void mac_rr(__uint128_t *acc, uint64_t a, const uint64_t b)
197 {
198   uint64_t lo = *acc, hi = *acc >> 64;
199   
200   #ifdef __BMI2__
201       uint64_t c,d;
202       __asm__ volatile
203           ("mulx %[b], %[c], %[d]; "
204            "addq %[c], %[lo]; "
205            "adcq %[d], %[hi]; "
206            : [c]"=r"(c), [d]"=r"(d), [lo]"+r"(lo), [hi]"+r"(hi)
207            : [b]"r"(b), [a]"d"(a)
208            : "cc");
209   #else
210       __asm__ volatile
211           ("mulq %[b]; "
212            "addq %%rax, %[lo]; "
213            "adcq %%rdx, %[hi]; "
214            : [lo]"+r"(lo), [hi]"+r"(hi), "+a"(a)
215            : [b]"r"(b)
216            : "rdx", "cc");
217   #endif
218   
219   *acc = (((__uint128_t)(hi)) << 64) | lo;
220 }
221
222 static __inline__ void mac2(__uint128_t *acc, const uint64_t *a,
223                             const uint64_t *b)
224 {
225   uint64_t lo = *acc, hi = *acc >> 64;
226   
227   #ifdef __BMI2__
228       uint64_t c,d;
229       __asm__ volatile
230           ("movq %[a], %%rdx; "
231            "addq %%rdx, %%rdx; "
232            "mulx %[b], %[c], %[d]; "
233            "addq %[c], %[lo]; "
234            "adcq %[d], %[hi]; "
235            : [c]"=r"(c), [d]"=r"(d), [lo]"+r"(lo), [hi]"+r"(hi)
236            : [b]"m"(*b), [a]"m"(*a)
237            : "rdx", "cc");
238   #else
239       __asm__ volatile
240           ("movq %[a], %%rax; "
241            "addq %%rax, %%rax; "
242            "mulq %[b]; "
243            "addq %%rax, %[lo]; "
244            "adcq %%rdx, %[hi]; "
245            : [lo]"+r"(lo), [hi]"+r"(hi)
246            : [b]"m"(*b), [a]"m"(*a)
247            : "rax", "rdx", "cc");
248   #endif
249   
250   *acc = (((__uint128_t)(hi)) << 64) | lo;
251 }
252
253 static __inline__ void msb(__uint128_t *acc, const uint64_t *a,
254                            const uint64_t *b)
255 {
256   uint64_t lo = *acc, hi = *acc >> 64;
257
258   #ifdef __BMI2__
259       uint64_t c,d;
260       __asm__ volatile
261           ("movq %[a], %%rdx; "
262            "mulx %[b], %[c], %[d]; "
263            "subq %[c], %[lo]; "
264            "sbbq %[d], %[hi]; "
265            : [c]"=r"(c), [d]"=r"(d), [lo]"+r"(lo), [hi]"+r"(hi)
266            : [b]"m"(*b), [a]"m"(*a)
267            : "rdx", "cc");
268   #else
269       __asm__ volatile
270           ("movq %[a], %%rax; "
271            "mulq %[b]; "
272            "subq %%rax, %[lo]; "
273            "sbbq %%rdx, %[hi]; "
274            : [lo]"+r"(lo), [hi]"+r"(hi)
275            : [b]"m"(*b), [a]"m"(*a)
276            : "rax", "rdx", "cc");
277   #endif
278   *acc = (((__uint128_t)(hi)) << 64) | lo;
279 }
280
281 static __inline__ void msb2(__uint128_t *acc, const uint64_t *a,
282                             const uint64_t *b)
283 {
284   uint64_t lo = *acc, hi = *acc >> 64;
285
286   #ifdef __BMI2__
287       uint64_t c,d;
288       __asm__ volatile
289           ("movq %[a], %%rdx; "
290            "addq %%rdx, %%rdx; "
291            "mulx %[b], %[c], %[d]; "
292            "subq %[c], %[lo]; "
293            "sbbq %[d], %[hi]; "
294            : [c]"=r"(c), [d]"=r"(d), [lo]"+r"(lo), [hi]"+r"(hi)
295            : [b]"m"(*b), [a]"m"(*a)
296            : "rdx", "cc");
297   #else
298       __asm__ volatile
299           ("movq %[a], %%rax; "
300            "addq %%rax, %%rax; "
301            "mulq %[b]; "
302            "subq %%rax, %[lo]; "
303            "sbbq %%rdx, %[hi]; "
304            : [lo]"+r"(lo), [hi]"+r"(hi)
305            : [b]"m"(*b), [a]"m"(*a)
306            : "rax", "rdx", "cc");
307   #endif
308   *acc = (((__uint128_t)(hi))<<64) | lo;
309   
310 }
311
312 static __inline__ void mrs(__uint128_t *acc, const uint64_t *a,
313                            const uint64_t *b)
314 {
315   uint64_t c,d, lo = *acc, hi = *acc >> 64;
316   __asm__ volatile
317       ("movq %[a], %%rdx; "
318        "mulx %[b], %[c], %[d]; "
319        "subq %[lo], %[c]; "
320        "sbbq %[hi], %[d]; "
321        : [c]"=r"(c), [d]"=r"(d), [lo]"+r"(lo), [hi]"+r"(hi)
322        : [b]"m"(*b), [a]"m"(*a)
323        : "rdx", "cc");
324   *acc = (((__uint128_t)(d)) << 64) | c;
325 }
326
327 static __inline__ uint64_t word_is_zero(uint64_t x)
328 {
329   __asm__ volatile("neg %0; sbb %0, %0;" : "+r"(x));
330   return ~x;
331 }
332
333 static inline uint64_t shrld(__uint128_t x, int n)
334 {
335     return x >> n;
336 }
337
338 #endif /* __ARCH_X86_64_ARCH_INTRINSICS_H__ */