contrib/llvm/tools/clang/lib/Headers/bmiintrin.h

   1 /*===---- bmiintrin.h - BMI 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 #if !defined __X86INTRIN_H && !defined __IMMINTRIN_H
  25 #error "Never use <bmiintrin.h> directly; include <x86intrin.h> instead."
  26 #endif
  27
  28 #ifndef __BMIINTRIN_H
  29 #define __BMIINTRIN_H
  30
  31 /// \brief Counts the number of trailing zero bits in the operand.
  32 ///
  33 /// \headerfile <x86intrin.h>
  34 ///
  35 /// \code
  36 /// unsigned short _tzcnt_u16(unsigned short a);
  37 /// \endcode
  38 ///
  39 /// This intrinsic corresponds to the \c TZCNT instruction.
  40 ///
  41 /// \param a
  42 ///    An unsigned 16-bit integer whose trailing zeros are to be counted.
  43 /// \returns An unsigned 16-bit integer containing the number of trailing zero
  44 ///    bits in the operand.
  45 #define _tzcnt_u16(a)     (__tzcnt_u16((a)))
  46
  47 /// \brief Performs a bitwise AND of the second operand with the one's
  48 ///    complement of the first operand.
  49 ///
  50 /// \headerfile <x86intrin.h>
  51 ///
  52 /// \code
  53 /// unsigned int _andn_u32(unsigned int a, unsigned int b);
  54 /// \endcode
  55 ///
  56 /// This intrinsic corresponds to the \c ANDN instruction.
  57 ///
  58 /// \param a
  59 ///    An unsigned integer containing one of the operands.
  60 /// \param b
  61 ///    An unsigned integer containing one of the operands.
  62 /// \returns An unsigned integer containing the bitwise AND of the second
  63 ///    operand with the one's complement of the first operand.
  64 #define _andn_u32(a, b)   (__andn_u32((a), (b)))
  65
  66 /* _bextr_u32 != __bextr_u32 */
  67 /// \brief Clears all bits in the source except for the least significant bit
  68 ///    containing a value of 1 and returns the result.
  69 ///
  70 /// \headerfile <x86intrin.h>
  71 ///
  72 /// \code
  73 /// unsigned int _blsi_u32(unsigned int a);
  74 /// \endcode
  75 ///
  76 /// This intrinsic corresponds to the \c BLSI instruction.
  77 ///
  78 /// \param a
  79 ///    An unsigned integer whose bits are to be cleared.
  80 /// \returns An unsigned integer containing the result of clearing the bits from
  81 ///    the source operand.
  82 #define _blsi_u32(a)      (__blsi_u32((a)))
  83
  84 /// \brief Creates a mask whose bits are set to 1, using bit 0 up to and
  85 ///    including the least siginificant bit that is set to 1 in the source
  86 ///    operand and returns the result.
  87 ///
  88 /// \headerfile <x86intrin.h>
  89 ///
  90 /// \code
  91 /// unsigned int _blsmsk_u32(unsigned int a);
  92 /// \endcode
  93 ///
  94 /// This intrinsic corresponds to the \c BLSMSK instruction.
  95 ///
  96 /// \param a
  97 ///    An unsigned integer used to create the mask.
  98 /// \returns An unsigned integer containing the newly created mask.
  99 #define _blsmsk_u32(a)    (__blsmsk_u32((a)))
 100
 101 /// \brief Clears the least siginificant bit that is set to 1 in the source
 102 ///    operand and returns the result.
 103 ///
 104 /// \headerfile <x86intrin.h>
 105 ///
 106 /// \code
 107 /// unsigned int _blsr_u32(unsigned int a);
 108 /// \endcode
 109 ///
 110 /// This intrinsic corresponds to the \c BLSR instruction.
 111 ///
 112 /// \param a
 113 ///    An unsigned integer containing the operand to be cleared.
 114 /// \returns An unsigned integer containing the result of clearing the source
 115 ///    operand.
 116 #define _blsr_u32(a)      (__blsr_u32((a)))
 117
 118 /// \brief Counts the number of trailing zero bits in the operand.
 119 ///
 120 /// \headerfile <x86intrin.h>
 121 ///
 122 /// \code
 123 /// unsigned int _tzcnt_u32(unsigned int a);
 124 /// \endcode
 125 ///
 126 /// This intrinsic corresponds to the \c TZCNT instruction.
 127 ///
 128 /// \param a
 129 ///    An unsigned 32-bit integer whose trailing zeros are to be counted.
 130 /// \returns An unsigned 32-bit integer containing the number of trailing zero
 131 ///    bits in the operand.
 132 #define _tzcnt_u32(a)     (__tzcnt_u32((a)))
 133
 134 /* Define the default attributes for the functions in this file. */
 135 #define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("bmi")))
 136
 137 /* Allow using the tzcnt intrinsics even for non-BMI targets. Since the TZCNT
 138    instruction behaves as BSF on non-BMI targets, there is code that expects
 139    to use it as a potentially faster version of BSF. */
 140 #define __RELAXED_FN_ATTRS __attribute__((__always_inline__, __nodebug__))
 141
 142 /// \brief Counts the number of trailing zero bits in the operand.
 143 ///
 144 /// \headerfile <x86intrin.h>
 145 ///
 146 /// This intrinsic corresponds to the \c TZCNT instruction.
 147 ///
 148 /// \param __X
 149 ///    An unsigned 16-bit integer whose trailing zeros are to be counted.
 150 /// \returns An unsigned 16-bit integer containing the number of trailing zero
 151 ///    bits in the operand.
 152 static __inline__ unsigned short __RELAXED_FN_ATTRS
 153 __tzcnt_u16(unsigned short __X)
 154 {
 155   return __X ? __builtin_ctzs(__X) : 16;
 156 }
 157
 158 /// \brief Performs a bitwise AND of the second operand with the one's
 159 ///    complement of the first operand.
 160 ///
 161 /// \headerfile <x86intrin.h>
 162 ///
 163 /// This intrinsic corresponds to the \c ANDN instruction.
 164 ///
 165 /// \param __X
 166 ///    An unsigned integer containing one of the operands.
 167 /// \param __Y
 168 ///    An unsigned integer containing one of the operands.
 169 /// \returns An unsigned integer containing the bitwise AND of the second
 170 ///    operand with the one's complement of the first operand.
 171 static __inline__ unsigned int __DEFAULT_FN_ATTRS
 172 __andn_u32(unsigned int __X, unsigned int __Y)
 173 {
 174   return ~__X & __Y;
 175 }
 176
 177 /* AMD-specified, double-leading-underscore version of BEXTR */
 178 /// \brief Extracts the specified bits from the first operand and returns them
 179 ///    in the least significant bits of the result.
 180 ///
 181 /// \headerfile <x86intrin.h>
 182 ///
 183 /// This intrinsic corresponds to the \c BEXTR instruction.
 184 ///
 185 /// \param __X
 186 ///    An unsigned integer whose bits are to be extracted.
 187 /// \param __Y
 188 ///    An unsigned integer used to specify which bits are extracted. Bits [7:0]
 189 ///    specify the index of the least significant bit. Bits [15:8] specify the
 190 ///    number of bits to be extracted.
 191 /// \returns An unsigned integer whose least significant bits contain the
 192 ///    extracted bits.
 193 static __inline__ unsigned int __DEFAULT_FN_ATTRS
 194 __bextr_u32(unsigned int __X, unsigned int __Y)
 195 {
 196   return __builtin_ia32_bextr_u32(__X, __Y);
 197 }
 198
 199 /* Intel-specified, single-leading-underscore version of BEXTR */
 200 /// \brief Extracts the specified bits from the first operand and returns them
 201 ///    in the least significant bits of the result.
 202 ///
 203 /// \headerfile <x86intrin.h>
 204 ///
 205 /// This intrinsic corresponds to the \c BEXTR instruction.
 206 ///
 207 /// \param __X
 208 ///    An unsigned integer whose bits are to be extracted.
 209 /// \param __Y
 210 ///    An unsigned integer used to specify the index of the least significant
 211 ///    bit for the bits to be extracted. Bits [7:0] specify the index.
 212 /// \param __Z
 213 ///    An unsigned integer used to specify the number of bits to be extracted.
 214 ///    Bits [7:0] specify the number of bits.
 215 /// \returns An unsigned integer whose least significant bits contain the
 216 ///    extracted bits.
 217 static __inline__ unsigned int __DEFAULT_FN_ATTRS
 218 _bextr_u32(unsigned int __X, unsigned int __Y, unsigned int __Z)
 219 {
 220   return __builtin_ia32_bextr_u32 (__X, ((__Y & 0xff) | ((__Z & 0xff) << 8)));
 221 }
 222
 223 /// \brief Clears all bits in the source except for the least significant bit
 224 ///    containing a value of 1 and returns the result.
 225 ///
 226 /// \headerfile <x86intrin.h>
 227 ///
 228 /// This intrinsic corresponds to the \c BLSI instruction.
 229 ///
 230 /// \param __X
 231 ///    An unsigned integer whose bits are to be cleared.
 232 /// \returns An unsigned integer containing the result of clearing the bits from
 233 ///    the source operand.
 234 static __inline__ unsigned int __DEFAULT_FN_ATTRS
 235 __blsi_u32(unsigned int __X)
 236 {
 237   return __X & -__X;
 238 }
 239
 240 /// \brief Creates a mask whose bits are set to 1, using bit 0 up to and
 241 ///    including the least siginificant bit that is set to 1 in the source
 242 ///    operand and returns the result.
 243 ///
 244 /// \headerfile <x86intrin.h>
 245 ///
 246 /// This intrinsic corresponds to the \c BLSMSK instruction.
 247 ///
 248 /// \param __X
 249 ///    An unsigned integer used to create the mask.
 250 /// \returns An unsigned integer containing the newly created mask.
 251 static __inline__ unsigned int __DEFAULT_FN_ATTRS
 252 __blsmsk_u32(unsigned int __X)
 253 {
 254   return __X ^ (__X - 1);
 255 }
 256
 257 /// \brief Clears the least siginificant bit that is set to 1 in the source
 258 ///    operand and returns the result.
 259 ///
 260 /// \headerfile <x86intrin.h>
 261 ///
 262 /// This intrinsic corresponds to the \c BLSR instruction.
 263 ///
 264 /// \param __X
 265 ///    An unsigned integer containing the operand to be cleared.
 266 /// \returns An unsigned integer containing the result of clearing the source
 267 ///    operand.
 268 static __inline__ unsigned int __DEFAULT_FN_ATTRS
 269 __blsr_u32(unsigned int __X)
 270 {
 271   return __X & (__X - 1);
 272 }
 273
 274 /// \brief Counts the number of trailing zero bits in the operand.
 275 ///
 276 /// \headerfile <x86intrin.h>
 277 ///
 278 /// This intrinsic corresponds to the \c TZCNT instruction.
 279 ///
 280 /// \param __X
 281 ///    An unsigned 32-bit integer whose trailing zeros are to be counted.
 282 /// \returns An unsigned 32-bit integer containing the number of trailing zero
 283 ///    bits in the operand.
 284 static __inline__ unsigned int __RELAXED_FN_ATTRS
 285 __tzcnt_u32(unsigned int __X)
 286 {
 287   return __X ? __builtin_ctz(__X) : 32;
 288 }
 289
 290 /// \brief Counts the number of trailing zero bits in the operand.
 291 ///
 292 /// \headerfile <x86intrin.h>
 293 ///
 294 /// This intrinsic corresponds to the \c TZCNT instruction.
 295 ///
 296 /// \param __X
 297 ///    An unsigned 32-bit integer whose trailing zeros are to be counted.
 298 /// \returns An 32-bit integer containing the number of trailing zero
 299 ///    bits in the operand.
 300 static __inline__ int __RELAXED_FN_ATTRS
 301 _mm_tzcnt_32(unsigned int __X)
 302 {
 303   return __X ? __builtin_ctz(__X) : 32;
 304 }
 305
 306 #ifdef __x86_64__
 307
 308 /// \brief Performs a bitwise AND of the second operand with the one's
 309 ///    complement of the first operand.
 310 ///
 311 /// \headerfile <x86intrin.h>
 312 ///
 313 /// \code
 314 /// unsigned long long _andn_u64 (unsigned long long a, unsigned long long b);
 315 /// \endcode
 316 ///
 317 /// This intrinsic corresponds to the \c ANDN instruction.
 318 ///
 319 /// \param a
 320 ///    An unsigned 64-bit integer containing one of the operands.
 321 /// \param b
 322 ///    An unsigned 64-bit integer containing one of the operands.
 323 /// \returns An unsigned 64-bit integer containing the bitwise AND of the second
 324 ///    operand with the one's complement of the first operand.
 325 #define _andn_u64(a, b)   (__andn_u64((a), (b)))
 326
 327 /* _bextr_u64 != __bextr_u64 */
 328 /// \brief Clears all bits in the source except for the least significant bit
 329 ///    containing a value of 1 and returns the result.
 330 ///
 331 /// \headerfile <x86intrin.h>
 332 ///
 333 /// \code
 334 /// unsigned long long _blsi_u64(unsigned long long a);
 335 /// \endcode
 336 ///
 337 /// This intrinsic corresponds to the \c BLSI instruction.
 338 ///
 339 /// \param a
 340 ///    An unsigned 64-bit integer whose bits are to be cleared.
 341 /// \returns An unsigned 64-bit integer containing the result of clearing the
 342 ///    bits from the source operand.
 343 #define _blsi_u64(a)      (__blsi_u64((a)))
 344
 345 /// \brief Creates a mask whose bits are set to 1, using bit 0 up to and
 346 ///    including the least siginificant bit that is set to 1 in the source
 347 ///    operand and returns the result.
 348 ///
 349 /// \headerfile <x86intrin.h>
 350 ///
 351 /// \code
 352 /// unsigned long long _blsmsk_u64(unsigned long long a);
 353 /// \endcode
 354 ///
 355 /// This intrinsic corresponds to the \c BLSMSK instruction.
 356 ///
 357 /// \param a
 358 ///    An unsigned 64-bit integer used to create the mask.
 359 /// \returns A unsigned 64-bit integer containing the newly created mask.
 360 #define _blsmsk_u64(a)    (__blsmsk_u64((a)))
 361
 362 /// \brief Clears the least siginificant bit that is set to 1 in the source
 363 ///    operand and returns the result.
 364 ///
 365 /// \headerfile <x86intrin.h>
 366 ///
 367 /// \code
 368 /// unsigned long long _blsr_u64(unsigned long long a);
 369 /// \endcode
 370 ///
 371 /// This intrinsic corresponds to the \c BLSR instruction.
 372 ///
 373 /// \param a
 374 ///    An unsigned 64-bit integer containing the operand to be cleared.
 375 /// \returns An unsigned 64-bit integer containing the result of clearing the
 376 ///    source operand.
 377 #define _blsr_u64(a)      (__blsr_u64((a)))
 378
 379 /// \brief Counts the number of trailing zero bits in the operand.
 380 ///
 381 /// \headerfile <x86intrin.h>
 382 ///
 383 /// \code
 384 /// unsigned long long _tzcnt_u64(unsigned long long a);
 385 /// \endcode
 386 ///
 387 /// This intrinsic corresponds to the \c TZCNT instruction.
 388 ///
 389 /// \param a
 390 ///    An unsigned 64-bit integer whose trailing zeros are to be counted.
 391 /// \returns An unsigned 64-bit integer containing the number of trailing zero
 392 ///    bits in the operand.
 393 #define _tzcnt_u64(a)     (__tzcnt_u64((a)))
 394
 395 /// \brief Performs a bitwise AND of the second operand with the one's
 396 ///    complement of the first operand.
 397 ///
 398 /// \headerfile <x86intrin.h>
 399 ///
 400 /// This intrinsic corresponds to the \c ANDN instruction.
 401 ///
 402 /// \param __X
 403 ///    An unsigned 64-bit integer containing one of the operands.
 404 /// \param __Y
 405 ///    An unsigned 64-bit integer containing one of the operands.
 406 /// \returns An unsigned 64-bit integer containing the bitwise AND of the second
 407 ///    operand with the one's complement of the first operand.
 408 static __inline__ unsigned long long __DEFAULT_FN_ATTRS
 409 __andn_u64 (unsigned long long __X, unsigned long long __Y)
 410 {
 411   return ~__X & __Y;
 412 }
 413
 414 /* AMD-specified, double-leading-underscore version of BEXTR */
 415 /// \brief Extracts the specified bits from the first operand and returns them
 416 ///    in the least significant bits of the result.
 417 ///
 418 /// \headerfile <x86intrin.h>
 419 ///
 420 /// This intrinsic corresponds to the \c BEXTR instruction.
 421 ///
 422 /// \param __X
 423 ///    An unsigned 64-bit integer whose bits are to be extracted.
 424 /// \param __Y
 425 ///    An unsigned 64-bit integer used to specify which bits are extracted. Bits
 426 ///    [7:0] specify the index of the least significant bit. Bits [15:8] specify
 427 ///    the number of bits to be extracted.
 428 /// \returns An unsigned 64-bit integer whose least significant bits contain the
 429 ///    extracted bits.
 430 static __inline__ unsigned long long __DEFAULT_FN_ATTRS
 431 __bextr_u64(unsigned long long __X, unsigned long long __Y)
 432 {
 433   return __builtin_ia32_bextr_u64(__X, __Y);
 434 }
 435
 436 /* Intel-specified, single-leading-underscore version of BEXTR */
 437 /// \brief Extracts the specified bits from the first operand and returns them
 438 ///     in the least significant bits of the result.
 439 ///
 440 /// \headerfile <x86intrin.h>
 441 ///
 442 /// This intrinsic corresponds to the \c BEXTR instruction.
 443 ///
 444 /// \param __X
 445 ///    An unsigned 64-bit integer whose bits are to be extracted.
 446 /// \param __Y
 447 ///    An unsigned integer used to specify the index of the least significant
 448 ///    bit for the bits to be extracted. Bits [7:0] specify the index.
 449 /// \param __Z
 450 ///    An unsigned integer used to specify the number of bits to be extracted.
 451 ///    Bits [7:0] specify the number of bits.
 452 /// \returns An unsigned 64-bit integer whose least significant bits contain the
 453 ///    extracted bits.
 454 static __inline__ unsigned long long __DEFAULT_FN_ATTRS
 455 _bextr_u64(unsigned long long __X, unsigned int __Y, unsigned int __Z)
 456 {
 457   return __builtin_ia32_bextr_u64 (__X, ((__Y & 0xff) | ((__Z & 0xff) << 8)));
 458 }
 459
 460 /// \brief Clears all bits in the source except for the least significant bit
 461 ///    containing a value of 1 and returns the result.
 462 ///
 463 /// \headerfile <x86intrin.h>
 464 ///
 465 /// This intrinsic corresponds to the \c BLSI instruction.
 466 ///
 467 /// \param __X
 468 ///    An unsigned 64-bit integer whose bits are to be cleared.
 469 /// \returns An unsigned 64-bit integer containing the result of clearing the
 470 ///    bits from the source operand.
 471 static __inline__ unsigned long long __DEFAULT_FN_ATTRS
 472 __blsi_u64(unsigned long long __X)
 473 {
 474   return __X & -__X;
 475 }
 476
 477 /// \brief Creates a mask whose bits are set to 1, using bit 0 up to and
 478 ///    including the least siginificant bit that is set to 1 in the source
 479 ///    operand and returns the result.
 480 ///
 481 /// \headerfile <x86intrin.h>
 482 ///
 483 /// This intrinsic corresponds to the \c BLSMSK instruction.
 484 ///
 485 /// \param __X
 486 ///    An unsigned 64-bit integer used to create the mask.
 487 /// \returns A unsigned 64-bit integer containing the newly created mask.
 488 static __inline__ unsigned long long __DEFAULT_FN_ATTRS
 489 __blsmsk_u64(unsigned long long __X)
 490 {
 491   return __X ^ (__X - 1);
 492 }
 493
 494 /// \brief Clears the least siginificant bit that is set to 1 in the source
 495 ///    operand and returns the result.
 496 ///
 497 /// \headerfile <x86intrin.h>
 498 ///
 499 /// This intrinsic corresponds to the \c BLSR instruction.
 500 ///
 501 /// \param __X
 502 ///    An unsigned 64-bit integer containing the operand to be cleared.
 503 /// \returns An unsigned 64-bit integer containing the result of clearing the
 504 ///    source operand.
 505 static __inline__ unsigned long long __DEFAULT_FN_ATTRS
 506 __blsr_u64(unsigned long long __X)
 507 {
 508   return __X & (__X - 1);
 509 }
 510
 511 /// \brief Counts the number of trailing zero bits in the operand.
 512 ///
 513 /// \headerfile <x86intrin.h>
 514 ///
 515 /// This intrinsic corresponds to the \c TZCNT instruction.
 516 ///
 517 /// \param __X
 518 ///    An unsigned 64-bit integer whose trailing zeros are to be counted.
 519 /// \returns An unsigned 64-bit integer containing the number of trailing zero
 520 ///    bits in the operand.
 521 static __inline__ unsigned long long __RELAXED_FN_ATTRS
 522 __tzcnt_u64(unsigned long long __X)
 523 {
 524   return __X ? __builtin_ctzll(__X) : 64;
 525 }
 526
 527 /// \brief Counts the number of trailing zero bits in the operand.
 528 ///
 529 /// \headerfile <x86intrin.h>
 530 ///
 531 /// This intrinsic corresponds to the \c TZCNT instruction.
 532 ///
 533 /// \param __X
 534 ///    An unsigned 64-bit integer whose trailing zeros are to be counted.
 535 /// \returns An 64-bit integer containing the number of trailing zero
 536 ///    bits in the operand.
 537 static __inline__ long long __RELAXED_FN_ATTRS
 538 _mm_tzcnt_64(unsigned long long __X)
 539 {
 540   return __X ? __builtin_ctzll(__X) : 64;
 541 }
 542
 543 #endif /* __x86_64__ */
 544
 545 #undef __DEFAULT_FN_ATTRS
 546 #undef __RELAXED_FN_ATTRS
 547
 548 #endif /* __BMIINTRIN_H */