clang  14.0.0git
keylockerintrin.h
Go to the documentation of this file.
1 /*===----------------- keylockerintrin.h - KL Intrinsics -------------------===
2  *
3  * Permission is hereby granted, free of charge, to any person obtaining a copy
4  * of this software and associated documentation files (the "Software"), to deal
5  * in the Software without restriction, including without limitation the rights
6  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
7  * copies of the Software, and to permit persons to whom the Software is
8  * furnished to do so, subject to the following conditions:
9  *
10  * The above copyright notice and this permission notice shall be included in
11  * all copies or substantial portions of the Software.
12  *
13  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
14  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
15  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
16  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
17  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
18  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
19  * THE SOFTWARE.
20  *
21  *===-----------------------------------------------------------------------===
22  */
23 
24 #ifndef __IMMINTRIN_H
25 #error "Never use <keylockerintrin.h> directly; include <immintrin.h> instead."
26 #endif
27 
28 #ifndef _KEYLOCKERINTRIN_H
29 #define _KEYLOCKERINTRIN_H
30 
31 #if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
32  defined(__KL__)
33 
34 /* Define the default attributes for the functions in this file. */
35 #define __DEFAULT_FN_ATTRS \
36  __attribute__((__always_inline__, __nodebug__, __target__("kl"),\
37  __min_vector_width__(128)))
38 
39 /// Load internal wrapping key from __intkey, __enkey_lo and __enkey_hi. __ctl
40 /// will assigned to EAX, whch specifies the KeySource and whether backing up
41 /// the key is permitted. The 256-bit encryption key is loaded from the two
42 /// explicit operands (__enkey_lo and __enkey_hi). The 128-bit integrity key is
43 /// loaded from the implicit operand XMM0 which assigned by __intkey.
44 ///
45 /// \headerfile <x86intrin.h>
46 ///
47 /// This intrinsic corresponds to the <c> LOADIWKEY </c> instructions.
48 ///
49 /// \operation
50 /// IF CPL > 0 // LOADKWKEY only allowed at ring 0 (supervisor mode)
51 /// GP (0)
52 /// FI
53 /// IF “LOADIWKEY exiting” VM execution control set
54 /// VMexit
55 /// FI
56 /// IF __ctl[4:1] > 1 // Reserved KeySource encoding used
57 /// GP (0)
58 /// FI
59 /// IF __ctl[31:5] != 0 // Reserved bit in __ctl is set
60 /// GP (0)
61 /// FI
62 /// IF __ctl[0] AND (CPUID.19H.ECX[0] == 0) // NoBackup is not supported on this part
63 /// GP (0)
64 /// FI
65 /// IF (__ctl[4:1] == 1) AND (CPUID.19H.ECX[1] == 0) // KeySource of 1 is not supported on this part
66 /// GP (0)
67 /// FI
68 /// IF (__ctl[4:1] == 0) // KeySource of 0.
69 /// IWKey.Encryption Key[127:0] := __enkey_hi[127:0]:
70 /// IWKey.Encryption Key[255:128] := __enkey_lo[127:0]
71 /// IWKey.IntegrityKey[127:0] := __intkey[127:0]
72 /// IWKey.NoBackup := __ctl[0]
73 /// IWKey.KeySource := __ctl[4:1]
74 /// ZF := 0
75 /// ELSE // KeySource of 1. See RDSEED definition for details of randomness
76 /// IF HW_NRND_GEN.ready == 1 // Full-entropy random data from RDSEED was received
77 /// IWKey.Encryption Key[127:0] := __enkey_hi[127:0] XOR HW_NRND_GEN.data[127:0]
78 /// IWKey.Encryption Key[255:128] := __enkey_lo[127:0] XOR HW_NRND_GEN.data[255:128]
79 /// IWKey.Encryption Key[255:0] := __enkey_hi[127:0]:__enkey_lo[127:0] XOR HW_NRND_GEN.data[255:0]
80 /// IWKey.IntegrityKey[127:0] := __intkey[127:0] XOR HW_NRND_GEN.data[383:256]
81 /// IWKey.NoBackup := __ctl[0]
82 /// IWKey.KeySource := __ctl[4:1]
83 /// ZF := 0
84 /// ELSE // Random data was not returned from RDSEED. IWKey was not loaded
85 /// ZF := 1
86 /// FI
87 /// FI
88 /// dst := ZF
89 /// OF := 0
90 /// SF := 0
91 /// AF := 0
92 /// PF := 0
93 /// CF := 0
94 /// \endoperation
95 static __inline__ void __DEFAULT_FN_ATTRS
96 _mm_loadiwkey (unsigned int __ctl, __m128i __intkey,
97  __m128i __enkey_lo, __m128i __enkey_hi) {
98  __builtin_ia32_loadiwkey (__intkey, __enkey_lo, __enkey_hi, __ctl);
99 }
100 
101 /// Wrap a 128-bit AES key from __key into a key handle and output in
102 /// ((__m128i*)__h) to ((__m128i*)__h) + 2 and a 32-bit value as return.
103 /// The explicit source operand __htype specifies handle restrictions.
104 ///
105 /// \headerfile <x86intrin.h>
106 ///
107 /// This intrinsic corresponds to the <c> ENCODEKEY128 </c> instructions.
108 ///
109 /// \operation
110 /// InputKey[127:0] := __key[127:0]
111 /// KeyMetadata[2:0] := __htype[2:0]
112 /// KeyMetadata[23:3] := 0 // Reserved for future usage
113 /// KeyMetadata[27:24] := 0 // KeyType is AES-128 (value of 0)
114 /// KeyMetadata[127:28] := 0 // Reserved for future usage
115 /// Handle[383:0] := WrapKey128(InputKey[127:0], KeyMetadata[127:0],
116 /// IWKey.Integrity Key[127:0], IWKey.Encryption Key[255:0])
117 /// dst[0] := IWKey.NoBackup
118 /// dst[4:1] := IWKey.KeySource[3:0]
119 /// dst[31:5] := 0
120 /// MEM[__h+127:__h] := Handle[127:0] // AAD
121 /// MEM[__h+255:__h+128] := Handle[255:128] // Integrity Tag
122 /// MEM[__h+383:__h+256] := Handle[383:256] // CipherText
123 /// OF := 0
124 /// SF := 0
125 /// ZF := 0
126 /// AF := 0
127 /// PF := 0
128 /// CF := 0
129 /// \endoperation
130 static __inline__ unsigned int __DEFAULT_FN_ATTRS
131 _mm_encodekey128_u32(unsigned int __htype, __m128i __key, void *__h) {
132  return __builtin_ia32_encodekey128_u32(__htype, (__v2di)__key, __h);
133 }
134 
135 /// Wrap a 256-bit AES key from __key_hi:__key_lo into a key handle, then
136 /// output handle in ((__m128i*)__h) to ((__m128i*)__h) + 3 and
137 /// a 32-bit value as return.
138 /// The explicit source operand __htype specifies handle restrictions.
139 ///
140 /// \headerfile <x86intrin.h>
141 ///
142 /// This intrinsic corresponds to the <c> ENCODEKEY256 </c> instructions.
143 ///
144 /// \operation
145 /// InputKey[127:0] := __key_lo[127:0]
146 /// InputKey[255:128] := __key_hi[255:128]
147 /// KeyMetadata[2:0] := __htype[2:0]
148 /// KeyMetadata[23:3] := 0 // Reserved for future usage
149 /// KeyMetadata[27:24] := 1 // KeyType is AES-256 (value of 1)
150 /// KeyMetadata[127:28] := 0 // Reserved for future usage
151 /// Handle[511:0] := WrapKey256(InputKey[255:0], KeyMetadata[127:0],
152 /// IWKey.Integrity Key[127:0], IWKey.Encryption Key[255:0])
153 /// dst[0] := IWKey.NoBackup
154 /// dst[4:1] := IWKey.KeySource[3:0]
155 /// dst[31:5] := 0
156 /// MEM[__h+127:__h] := Handle[127:0] // AAD
157 /// MEM[__h+255:__h+128] := Handle[255:128] // Tag
158 /// MEM[__h+383:__h+256] := Handle[383:256] // CipherText[127:0]
159 /// MEM[__h+511:__h+384] := Handle[511:384] // CipherText[255:128]
160 /// OF := 0
161 /// SF := 0
162 /// ZF := 0
163 /// AF := 0
164 /// PF := 0
165 /// CF := 0
166 /// \endoperation
167 static __inline__ unsigned int __DEFAULT_FN_ATTRS
168 _mm_encodekey256_u32(unsigned int __htype, __m128i __key_lo, __m128i __key_hi,
169  void *__h) {
170  return __builtin_ia32_encodekey256_u32(__htype, (__v2di)__key_lo,
171  (__v2di)__key_hi, __h);
172 }
173 
174 /// The AESENC128KL performs 10 rounds of AES to encrypt the __idata using
175 /// the 128-bit key in the handle from the __h. It stores the result in the
176 /// __odata. And return the affected ZF flag status.
177 ///
178 /// \headerfile <x86intrin.h>
179 ///
180 /// This intrinsic corresponds to the <c> AESENC128KL </c> instructions.
181 ///
182 /// \operation
183 /// Handle[383:0] := MEM[__h+383:__h] // Load is not guaranteed to be atomic.
184 /// IllegalHandle := ( HandleReservedBitSet (Handle[383:0]) ||
185 /// (Handle[127:0] AND (CPL > 0)) ||
186 /// Handle[383:256] ||
187 /// HandleKeyType (Handle[383:0]) != HANDLE_KEY_TYPE_AES128 )
188 /// IF (IllegalHandle)
189 /// ZF := 1
190 /// ELSE
191 /// (UnwrappedKey, Authentic) := UnwrapKeyAndAuthenticate384 (Handle[383:0], IWKey)
192 /// IF (Authentic == 0)
193 /// ZF := 1
194 /// ELSE
195 /// MEM[__odata+127:__odata] := AES128Encrypt (__idata[127:0], UnwrappedKey)
196 /// ZF := 0
197 /// FI
198 /// FI
199 /// dst := ZF
200 /// OF := 0
201 /// SF := 0
202 /// AF := 0
203 /// PF := 0
204 /// CF := 0
205 /// \endoperation
206 static __inline__ unsigned char __DEFAULT_FN_ATTRS
207 _mm_aesenc128kl_u8(__m128i* __odata, __m128i __idata, const void *__h) {
208  return __builtin_ia32_aesenc128kl_u8((__v2di *)__odata, (__v2di)__idata, __h);
209 }
210 
211 /// The AESENC256KL performs 14 rounds of AES to encrypt the __idata using
212 /// the 256-bit key in the handle from the __h. It stores the result in the
213 /// __odata. And return the affected ZF flag status.
214 ///
215 /// \headerfile <x86intrin.h>
216 ///
217 /// This intrinsic corresponds to the <c> AESENC256KL </c> instructions.
218 ///
219 /// \operation
220 /// Handle[511:0] := MEM[__h+511:__h] // Load is not guaranteed to be atomic.
221 /// IllegalHandle := ( HandleReservedBitSet (Handle[511:0]) ||
222 /// (Handle[127:0] AND (CPL > 0)) ||
223 /// Handle[255:128] ||
224 /// HandleKeyType (Handle[511:0]) != HANDLE_KEY_TYPE_AES256 )
225 /// IF (IllegalHandle)
226 /// ZF := 1
227 /// MEM[__odata+127:__odata] := 0
228 /// ELSE
229 /// (UnwrappedKey, Authentic) := UnwrapKeyAndAuthenticate512 (Handle[511:0], IWKey)
230 /// IF (Authentic == 0)
231 /// ZF := 1
232 /// MEM[__odata+127:__odata] := 0
233 /// ELSE
234 /// MEM[__odata+127:__odata] := AES256Encrypt (__idata[127:0], UnwrappedKey)
235 /// ZF := 0
236 /// FI
237 /// FI
238 /// dst := ZF
239 /// OF := 0
240 /// SF := 0
241 /// AF := 0
242 /// PF := 0
243 /// CF := 0
244 /// \endoperation
245 static __inline__ unsigned char __DEFAULT_FN_ATTRS
246 _mm_aesenc256kl_u8(__m128i* __odata, __m128i __idata, const void *__h) {
247  return __builtin_ia32_aesenc256kl_u8((__v2di *)__odata, (__v2di)__idata, __h);
248 }
249 
250 /// The AESDEC128KL performs 10 rounds of AES to decrypt the __idata using
251 /// the 128-bit key in the handle from the __h. It stores the result in the
252 /// __odata. And return the affected ZF flag status.
253 ///
254 /// \headerfile <x86intrin.h>
255 ///
256 /// This intrinsic corresponds to the <c> AESDEC128KL </c> instructions.
257 ///
258 /// \operation
259 /// Handle[383:0] := MEM[__h+383:__h] // Load is not guaranteed to be atomic.
260 /// IllegalHandle := (HandleReservedBitSet (Handle[383:0]) ||
261 /// (Handle[127:0] AND (CPL > 0)) ||
262 /// Handle[383:256] ||
263 /// HandleKeyType (Handle[383:0]) != HANDLE_KEY_TYPE_AES128)
264 /// IF (IllegalHandle)
265 /// ZF := 1
266 /// MEM[__odata+127:__odata] := 0
267 /// ELSE
268 /// (UnwrappedKey, Authentic) := UnwrapKeyAndAuthenticate384 (Handle[383:0], IWKey)
269 /// IF (Authentic == 0)
270 /// ZF := 1
271 /// MEM[__odata+127:__odata] := 0
272 /// ELSE
273 /// MEM[__odata+127:__odata] := AES128Decrypt (__idata[127:0], UnwrappedKey)
274 /// ZF := 0
275 /// FI
276 /// FI
277 /// dst := ZF
278 /// OF := 0
279 /// SF := 0
280 /// AF := 0
281 /// PF := 0
282 /// CF := 0
283 /// \endoperation
284 static __inline__ unsigned char __DEFAULT_FN_ATTRS
285 _mm_aesdec128kl_u8(__m128i* __odata, __m128i __idata, const void *__h) {
286  return __builtin_ia32_aesdec128kl_u8((__v2di *)__odata, (__v2di)__idata, __h);
287 }
288 
289 /// The AESDEC256KL performs 10 rounds of AES to decrypt the __idata using
290 /// the 256-bit key in the handle from the __h. It stores the result in the
291 /// __odata. And return the affected ZF flag status.
292 ///
293 /// \headerfile <x86intrin.h>
294 ///
295 /// This intrinsic corresponds to the <c> AESDEC256KL </c> instructions.
296 ///
297 /// \operation
298 /// Handle[511:0] := MEM[__h+511:__h]
299 /// IllegalHandle := (HandleReservedBitSet (Handle[511:0]) ||
300 /// (Handle[127:0] AND (CPL > 0)) ||
301 /// Handle[383:256] ||
302 /// HandleKeyType (Handle[511:0]) != HANDLE_KEY_TYPE_AES256)
303 /// IF (IllegalHandle)
304 /// ZF := 1
305 /// MEM[__odata+127:__odata] := 0
306 /// ELSE
307 /// (UnwrappedKey, Authentic) := UnwrapKeyAndAuthenticate512 (Handle[511:0], IWKey)
308 /// IF (Authentic == 0)
309 /// ZF := 1
310 /// MEM[__odata+127:__odata] := 0
311 /// ELSE
312 /// MEM[__odata+127:__odata] := AES256Decrypt (__idata[127:0], UnwrappedKey)
313 /// ZF := 0
314 /// FI
315 /// FI
316 /// dst := ZF
317 /// OF := 0
318 /// SF := 0
319 /// AF := 0
320 /// PF := 0
321 /// CF := 0
322 /// \endoperation
323 static __inline__ unsigned char __DEFAULT_FN_ATTRS
324 _mm_aesdec256kl_u8(__m128i* __odata, __m128i __idata, const void *__h) {
325  return __builtin_ia32_aesdec256kl_u8((__v2di *)__odata, (__v2di)__idata, __h);
326 }
327 
328 #undef __DEFAULT_FN_ATTRS
329 
330 #endif /* !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) \
331  || defined(__KL__) */
332 
333 #if !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) || \
334  defined(__WIDEKL__)
335 
336 /* Define the default attributes for the functions in this file. */
337 #define __DEFAULT_FN_ATTRS \
338  __attribute__((__always_inline__, __nodebug__, __target__("kl,widekl"),\
339  __min_vector_width__(128)))
340 
341 /// Encrypt __idata[0] to __idata[7] using 128-bit AES key indicated by handle
342 /// at __h and store each resultant block back from __odata to __odata+7. And
343 /// return the affected ZF flag status.
344 ///
345 /// \headerfile <x86intrin.h>
346 ///
347 /// This intrinsic corresponds to the <c> AESENCWIDE128KL </c> instructions.
348 ///
349 /// \operation
350 /// Handle := MEM[__h+383:__h]
351 /// IllegalHandle := ( HandleReservedBitSet (Handle[383:0]) ||
352 /// (Handle[127:0] AND (CPL > 0)) ||
353 /// Handle[255:128] ||
354 /// HandleKeyType (Handle[383:0]) != HANDLE_KEY_TYPE_AES128 )
355 /// IF (IllegalHandle)
356 /// ZF := 1
357 /// FOR i := 0 to 7
358 /// __odata[i] := 0
359 /// ENDFOR
360 /// ELSE
361 /// (UnwrappedKey, Authentic) := UnwrapKeyAndAuthenticate384 (Handle[383:0], IWKey)
362 /// IF Authentic == 0
363 /// ZF := 1
364 /// FOR i := 0 to 7
365 /// __odata[i] := 0
366 /// ENDFOR
367 /// ELSE
368 /// FOR i := 0 to 7
369 /// __odata[i] := AES128Encrypt (__idata[i], UnwrappedKey)
370 /// ENDFOR
371 /// ZF := 0
372 /// FI
373 /// FI
374 /// dst := ZF
375 /// OF := 0
376 /// SF := 0
377 /// AF := 0
378 /// PF := 0
379 /// CF := 0
380 /// \endoperation
381 static __inline__ unsigned char __DEFAULT_FN_ATTRS
382 _mm_aesencwide128kl_u8(__m128i __odata[8], const __m128i __idata[8], const void* __h) {
383  return __builtin_ia32_aesencwide128kl_u8((__v2di *)__odata,
384  (const __v2di *)__idata, __h);
385 }
386 
387 /// Encrypt __idata[0] to __idata[7] using 256-bit AES key indicated by handle
388 /// at __h and store each resultant block back from __odata to __odata+7. And
389 /// return the affected ZF flag status.
390 ///
391 /// \headerfile <x86intrin.h>
392 ///
393 /// This intrinsic corresponds to the <c> AESENCWIDE256KL </c> instructions.
394 ///
395 /// \operation
396 /// Handle[511:0] := MEM[__h+511:__h]
397 /// IllegalHandle := ( HandleReservedBitSet (Handle[511:0]) ||
398 /// (Handle[127:0] AND (CPL > 0)) ||
399 /// Handle[255:128] ||
400 /// HandleKeyType (Handle[511:0]) != HANDLE_KEY_TYPE_AES512 )
401 /// IF (IllegalHandle)
402 /// ZF := 1
403 /// FOR i := 0 to 7
404 /// __odata[i] := 0
405 /// ENDFOR
406 /// ELSE
407 /// (UnwrappedKey, Authentic) := UnwrapKeyAndAuthenticate512 (Handle[511:0], IWKey)
408 /// IF Authentic == 0
409 /// ZF := 1
410 /// FOR i := 0 to 7
411 /// __odata[i] := 0
412 /// ENDFOR
413 /// ELSE
414 /// FOR i := 0 to 7
415 /// __odata[i] := AES256Encrypt (__idata[i], UnwrappedKey)
416 /// ENDFOR
417 /// ZF := 0
418 /// FI
419 /// FI
420 /// dst := ZF
421 /// OF := 0
422 /// SF := 0
423 /// AF := 0
424 /// PF := 0
425 /// CF := 0
426 /// \endoperation
427 static __inline__ unsigned char __DEFAULT_FN_ATTRS
428 _mm_aesencwide256kl_u8(__m128i __odata[8], const __m128i __idata[8], const void* __h) {
429  return __builtin_ia32_aesencwide256kl_u8((__v2di *)__odata,
430  (const __v2di *)__idata, __h);
431 }
432 
433 /// Decrypt __idata[0] to __idata[7] using 128-bit AES key indicated by handle
434 /// at __h and store each resultant block back from __odata to __odata+7. And
435 /// return the affected ZF flag status.
436 ///
437 /// \headerfile <x86intrin.h>
438 ///
439 /// This intrinsic corresponds to the <c> AESDECWIDE128KL </c> instructions.
440 ///
441 /// \operation
442 /// Handle[383:0] := MEM[__h+383:__h]
443 /// IllegalHandle := ( HandleReservedBitSet (Handle[383:0]) ||
444 /// (Handle[127:0] AND (CPL > 0)) ||
445 /// Handle[255:128] ||
446 /// HandleKeyType (Handle) != HANDLE_KEY_TYPE_AES128 )
447 /// IF (IllegalHandle)
448 /// ZF := 1
449 /// FOR i := 0 to 7
450 /// __odata[i] := 0
451 /// ENDFOR
452 /// ELSE
453 /// (UnwrappedKey, Authentic) := UnwrapKeyAndAuthenticate384 (Handle[383:0], IWKey)
454 /// IF Authentic == 0
455 /// ZF := 1
456 /// FOR i := 0 to 7
457 /// __odata[i] := 0
458 /// ENDFOR
459 /// ELSE
460 /// FOR i := 0 to 7
461 /// __odata[i] := AES128Decrypt (__idata[i], UnwrappedKey)
462 /// ENDFOR
463 /// ZF := 0
464 /// FI
465 /// FI
466 /// dst := ZF
467 /// OF := 0
468 /// SF := 0
469 /// AF := 0
470 /// PF := 0
471 /// CF := 0
472 /// \endoperation
473 static __inline__ unsigned char __DEFAULT_FN_ATTRS
474 _mm_aesdecwide128kl_u8(__m128i __odata[8], const __m128i __idata[8], const void* __h) {
475  return __builtin_ia32_aesdecwide128kl_u8((__v2di *)__odata,
476  (const __v2di *)__idata, __h);
477 }
478 
479 /// Decrypt __idata[0] to __idata[7] using 256-bit AES key indicated by handle
480 /// at __h and store each resultant block back from __odata to __odata+7. And
481 /// return the affected ZF flag status.
482 ///
483 /// \headerfile <x86intrin.h>
484 ///
485 /// This intrinsic corresponds to the <c> AESDECWIDE256KL </c> instructions.
486 ///
487 /// \operation
488 /// Handle[511:0] := MEM[__h+511:__h]
489 /// IllegalHandle = ( HandleReservedBitSet (Handle[511:0]) ||
490 /// (Handle[127:0] AND (CPL > 0)) ||
491 /// Handle[255:128] ||
492 /// HandleKeyType (Handle) != HANDLE_KEY_TYPE_AES512 )
493 /// If (IllegalHandle)
494 /// ZF := 1
495 /// FOR i := 0 to 7
496 /// __odata[i] := 0
497 /// ENDFOR
498 /// ELSE
499 /// (UnwrappedKey, Authentic) := UnwrapKeyAndAuthenticate512 (Handle[511:0], IWKey)
500 /// IF Authentic == 0
501 /// ZF := 1
502 /// FOR i := 0 to 7
503 /// __odata[i] := 0
504 /// ENDFOR
505 /// ELSE
506 /// FOR i := 0 to 7
507 /// __odata[i] := AES256Decrypt (__idata[i], UnwrappedKey)
508 /// ENDFOR
509 /// ZF := 0
510 /// FI
511 /// FI
512 /// dst := ZF
513 /// OF := 0
514 /// SF := 0
515 /// AF := 0
516 /// PF := 0
517 /// CF := 0
518 /// \endoperation
519 static __inline__ unsigned char __DEFAULT_FN_ATTRS
520 _mm_aesdecwide256kl_u8(__m128i __odata[8], const __m128i __idata[8], const void* __h) {
521  return __builtin_ia32_aesdecwide256kl_u8((__v2di *)__odata,
522  (const __v2di *)__idata, __h);
523 }
524 
525 #undef __DEFAULT_FN_ATTRS
526 
527 #endif /* !(defined(_MSC_VER) || defined(__SCE__)) || __has_feature(modules) \
528  || defined(__WIDEKL__) */
529 
530 #endif /* _KEYLOCKERINTRIN_H */
_mm_aesdec256kl_u8
static __inline__ unsigned char __DEFAULT_FN_ATTRS _mm_aesdec256kl_u8(__m128i *__odata, __m128i __idata, const void *__h)
The AESDEC256KL performs 10 rounds of AES to decrypt the __idata using the 256-bit key in the handle ...
Definition: keylockerintrin.h:324
_mm_aesdecwide256kl_u8
static __inline__ unsigned char __DEFAULT_FN_ATTRS _mm_aesdecwide256kl_u8(__m128i __odata[8], const __m128i __idata[8], const void *__h)
Decrypt __idata[0] to __idata[7] using 256-bit AES key indicated by handle at __h and store each resu...
Definition: keylockerintrin.h:520
_mm_encodekey128_u32
static __inline__ unsigned int __DEFAULT_FN_ATTRS _mm_encodekey128_u32(unsigned int __htype, __m128i __key, void *__h)
Wrap a 128-bit AES key from __key into a key handle and output in ((__m128i*)__h) to ((__m128i*)__h) ...
Definition: keylockerintrin.h:131
__DEFAULT_FN_ATTRS
#define __DEFAULT_FN_ATTRS
Definition: keylockerintrin.h:337
_mm_aesencwide128kl_u8
static __inline__ unsigned char __DEFAULT_FN_ATTRS _mm_aesencwide128kl_u8(__m128i __odata[8], const __m128i __idata[8], const void *__h)
Encrypt __idata[0] to __idata[7] using 128-bit AES key indicated by handle at __h and store each resu...
Definition: keylockerintrin.h:382
_mm_aesdecwide128kl_u8
static __inline__ unsigned char __DEFAULT_FN_ATTRS _mm_aesdecwide128kl_u8(__m128i __odata[8], const __m128i __idata[8], const void *__h)
Decrypt __idata[0] to __idata[7] using 128-bit AES key indicated by handle at __h and store each resu...
Definition: keylockerintrin.h:474
_mm_encodekey256_u32
static __inline__ unsigned int __DEFAULT_FN_ATTRS _mm_encodekey256_u32(unsigned int __htype, __m128i __key_lo, __m128i __key_hi, void *__h)
Wrap a 256-bit AES key from __key_hi:__key_lo into a key handle, then output handle in ((__m128i*)__h...
Definition: keylockerintrin.h:168
_mm_loadiwkey
static __inline__ void __DEFAULT_FN_ATTRS _mm_loadiwkey(unsigned int __ctl, __m128i __intkey, __m128i __enkey_lo, __m128i __enkey_hi)
Load internal wrapping key from __intkey, __enkey_lo and __enkey_hi.
Definition: keylockerintrin.h:96
_mm_aesenc256kl_u8
static __inline__ unsigned char __DEFAULT_FN_ATTRS _mm_aesenc256kl_u8(__m128i *__odata, __m128i __idata, const void *__h)
The AESENC256KL performs 14 rounds of AES to encrypt the __idata using the 256-bit key in the handle ...
Definition: keylockerintrin.h:246
_mm_aesenc128kl_u8
static __inline__ unsigned char __DEFAULT_FN_ATTRS _mm_aesenc128kl_u8(__m128i *__odata, __m128i __idata, const void *__h)
The AESENC128KL performs 10 rounds of AES to encrypt the __idata using the 128-bit key in the handle ...
Definition: keylockerintrin.h:207
_mm_aesencwide256kl_u8
static __inline__ unsigned char __DEFAULT_FN_ATTRS _mm_aesencwide256kl_u8(__m128i __odata[8], const __m128i __idata[8], const void *__h)
Encrypt __idata[0] to __idata[7] using 256-bit AES key indicated by handle at __h and store each resu...
Definition: keylockerintrin.h:428
_mm_aesdec128kl_u8
static __inline__ unsigned char __DEFAULT_FN_ATTRS _mm_aesdec128kl_u8(__m128i *__odata, __m128i __idata, const void *__h)
The AESDEC128KL performs 10 rounds of AES to decrypt the __idata using the 128-bit key in the handle ...
Definition: keylockerintrin.h:285