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(_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 /// \code{.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 /// \endcode
  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 /// \code{.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 /// \endcode
 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 /// \code{.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 /// \endcode
 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 /// \code{.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 /// \endcode
 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 /// \code{.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 /// \endcode
 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 /// \code{.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 /// \endcode
 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 /// \code{.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 /// \endcode
 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 /// \code{.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 /// \endcode
 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 /// \code{.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 /// \endcode
 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 /// \code{.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 /// \endcode
 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 /// \code{.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 /// \endcode
 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 */