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