clang/lib/Headers/keylockerintrin.h

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