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 #define _tzcnt_u16(a)     (__tzcnt_u16((a)))
  32
  33 #define _andn_u32(a, b)   (__andn_u32((a), (b)))
  34
  35 /* _bextr_u32 != __bextr_u32 */
  36 #define _blsi_u32(a)      (__blsi_u32((a)))
  37
  38 #define _blsmsk_u32(a)    (__blsmsk_u32((a)))
  39
  40 #define _blsr_u32(a)      (__blsr_u32((a)))
  41
  42 #define _tzcnt_u32(a)     (__tzcnt_u32((a)))
  43
  44 /* Define the default attributes for the functions in this file. */
  45 #define __DEFAULT_FN_ATTRS __attribute__((__always_inline__, __nodebug__, __target__("bmi")))
  46
  47 /* Allow using the tzcnt intrinsics even for non-BMI targets. Since the TZCNT
  48    instruction behaves as BSF on non-BMI targets, there is code that expects
  49    to use it as a potentially faster version of BSF. */
  50 #define __RELAXED_FN_ATTRS __attribute__((__always_inline__, __nodebug__))
  51
  52 /// Counts the number of trailing zero bits in the operand.
  53 ///
  54 /// \headerfile <x86intrin.h>
  55 ///
  56 /// This intrinsic corresponds to the <c> TZCNT </c> instruction.
  57 ///
  58 /// \param __X
  59 ///    An unsigned 16-bit integer whose trailing zeros are to be counted.
  60 /// \returns An unsigned 16-bit integer containing the number of trailing zero
  61 ///    bits in the operand.
  62 static __inline__ unsigned short __RELAXED_FN_ATTRS
  63 __tzcnt_u16(unsigned short __X)
  64 {
  65   return __X ? __builtin_ctzs(__X) : 16;
  66 }
  67
  68 /// Performs a bitwise AND of the second operand with the one's
  69 ///    complement of the first operand.
  70 ///
  71 /// \headerfile <x86intrin.h>
  72 ///
  73 /// This intrinsic corresponds to the <c> ANDN </c> instruction.
  74 ///
  75 /// \param __X
  76 ///    An unsigned integer containing one of the operands.
  77 /// \param __Y
  78 ///    An unsigned integer containing one of the operands.
  79 /// \returns An unsigned integer containing the bitwise AND of the second
  80 ///    operand with the one's complement of the first operand.
  81 static __inline__ unsigned int __DEFAULT_FN_ATTRS
  82 __andn_u32(unsigned int __X, unsigned int __Y)
  83 {
  84   return ~__X & __Y;
  85 }
  86
  87 /* AMD-specified, double-leading-underscore version of BEXTR */
  88 /// Extracts the specified bits from the first operand and returns them
  89 ///    in the least significant bits of the result.
  90 ///
  91 /// \headerfile <x86intrin.h>
  92 ///
  93 /// This intrinsic corresponds to the <c> BEXTR </c> instruction.
  94 ///
  95 /// \param __X
  96 ///    An unsigned integer whose bits are to be extracted.
  97 /// \param __Y
  98 ///    An unsigned integer used to specify which bits are extracted. Bits [7:0]
  99 ///    specify the index of the least significant bit. Bits [15:8] specify the
 100 ///    number of bits to be extracted.
 101 /// \returns An unsigned integer whose least significant bits contain the
 102 ///    extracted bits.
 103 /// \see _bextr_u32
 104 static __inline__ unsigned int __DEFAULT_FN_ATTRS
 105 __bextr_u32(unsigned int __X, unsigned int __Y)
 106 {
 107   return __builtin_ia32_bextr_u32(__X, __Y);
 108 }
 109
 110 /* Intel-specified, single-leading-underscore version of BEXTR */
 111 /// Extracts the specified bits from the first operand and returns them
 112 ///    in the least significant bits of the result.
 113 ///
 114 /// \headerfile <x86intrin.h>
 115 ///
 116 /// This intrinsic corresponds to the <c> BEXTR </c> instruction.
 117 ///
 118 /// \param __X
 119 ///    An unsigned integer whose bits are to be extracted.
 120 /// \param __Y
 121 ///    An unsigned integer used to specify the index of the least significant
 122 ///    bit for the bits to be extracted. Bits [7:0] specify the index.
 123 /// \param __Z
 124 ///    An unsigned integer used to specify the number of bits to be extracted.
 125 ///    Bits [7:0] specify the number of bits.
 126 /// \returns An unsigned integer whose least significant bits contain the
 127 ///    extracted bits.
 128 /// \see __bextr_u32
 129 static __inline__ unsigned int __DEFAULT_FN_ATTRS
 130 _bextr_u32(unsigned int __X, unsigned int __Y, unsigned int __Z)
 131 {
 132   return __builtin_ia32_bextr_u32 (__X, ((__Y & 0xff) | ((__Z & 0xff) << 8)));
 133 }
 134
 135 /// Clears all bits in the source except for the least significant bit
 136 ///    containing a value of 1 and returns the result.
 137 ///
 138 /// \headerfile <x86intrin.h>
 139 ///
 140 /// This intrinsic corresponds to the <c> BLSI </c> instruction.
 141 ///
 142 /// \param __X
 143 ///    An unsigned integer whose bits are to be cleared.
 144 /// \returns An unsigned integer containing the result of clearing the bits from
 145 ///    the source operand.
 146 static __inline__ unsigned int __DEFAULT_FN_ATTRS
 147 __blsi_u32(unsigned int __X)
 148 {
 149   return __X & -__X;
 150 }
 151
 152 /// Creates a mask whose bits are set to 1, using bit 0 up to and
 153 ///    including the least significant bit that is set to 1 in the source
 154 ///    operand and returns the result.
 155 ///
 156 /// \headerfile <x86intrin.h>
 157 ///
 158 /// This intrinsic corresponds to the <c> BLSMSK </c> instruction.
 159 ///
 160 /// \param __X
 161 ///    An unsigned integer used to create the mask.
 162 /// \returns An unsigned integer containing the newly created mask.
 163 static __inline__ unsigned int __DEFAULT_FN_ATTRS
 164 __blsmsk_u32(unsigned int __X)
 165 {
 166   return __X ^ (__X - 1);
 167 }
 168
 169 /// Clears the least significant bit that is set to 1 in the source
 170 ///    operand and returns the result.
 171 ///
 172 /// \headerfile <x86intrin.h>
 173 ///
 174 /// This intrinsic corresponds to the <c> BLSR </c> instruction.
 175 ///
 176 /// \param __X
 177 ///    An unsigned integer containing the operand to be cleared.
 178 /// \returns An unsigned integer containing the result of clearing the source
 179 ///    operand.
 180 static __inline__ unsigned int __DEFAULT_FN_ATTRS
 181 __blsr_u32(unsigned int __X)
 182 {
 183   return __X & (__X - 1);
 184 }
 185
 186 /// Counts the number of trailing zero bits in the operand.
 187 ///
 188 /// \headerfile <x86intrin.h>
 189 ///
 190 /// This intrinsic corresponds to the <c> TZCNT </c> instruction.
 191 ///
 192 /// \param __X
 193 ///    An unsigned 32-bit integer whose trailing zeros are to be counted.
 194 /// \returns An unsigned 32-bit integer containing the number of trailing zero
 195 ///    bits in the operand.
 196 static __inline__ unsigned int __RELAXED_FN_ATTRS
 197 __tzcnt_u32(unsigned int __X)
 198 {
 199   return __X ? __builtin_ctz(__X) : 32;
 200 }
 201
 202 /// Counts the number of trailing zero bits in the operand.
 203 ///
 204 /// \headerfile <x86intrin.h>
 205 ///
 206 /// This intrinsic corresponds to the <c> TZCNT </c> instruction.
 207 ///
 208 /// \param __X
 209 ///    An unsigned 32-bit integer whose trailing zeros are to be counted.
 210 /// \returns An 32-bit integer containing the number of trailing zero bits in
 211 ///    the operand.
 212 static __inline__ int __RELAXED_FN_ATTRS
 213 _mm_tzcnt_32(unsigned int __X)
 214 {
 215   return __X ? __builtin_ctz(__X) : 32;
 216 }
 217
 218 #ifdef __x86_64__
 219
 220 #define _andn_u64(a, b)   (__andn_u64((a), (b)))
 221
 222 /* _bextr_u64 != __bextr_u64 */
 223 #define _blsi_u64(a)      (__blsi_u64((a)))
 224
 225 #define _blsmsk_u64(a)    (__blsmsk_u64((a)))
 226
 227 #define _blsr_u64(a)      (__blsr_u64((a)))
 228
 229 #define _tzcnt_u64(a)     (__tzcnt_u64((a)))
 230
 231 /// Performs a bitwise AND of the second operand with the one's
 232 ///    complement of the first operand.
 233 ///
 234 /// \headerfile <x86intrin.h>
 235 ///
 236 /// This intrinsic corresponds to the <c> ANDN </c> instruction.
 237 ///
 238 /// \param __X
 239 ///    An unsigned 64-bit integer containing one of the operands.
 240 /// \param __Y
 241 ///    An unsigned 64-bit integer containing one of the operands.
 242 /// \returns An unsigned 64-bit integer containing the bitwise AND of the second
 243 ///    operand with the one's complement of the first operand.
 244 static __inline__ unsigned long long __DEFAULT_FN_ATTRS
 245 __andn_u64 (unsigned long long __X, unsigned long long __Y)
 246 {
 247   return ~__X & __Y;
 248 }
 249
 250 /* AMD-specified, double-leading-underscore version of BEXTR */
 251 /// Extracts the specified bits from the first operand and returns them
 252 ///    in the least significant bits of the result.
 253 ///
 254 /// \headerfile <x86intrin.h>
 255 ///
 256 /// This intrinsic corresponds to the <c> BEXTR </c> instruction.
 257 ///
 258 /// \param __X
 259 ///    An unsigned 64-bit integer whose bits are to be extracted.
 260 /// \param __Y
 261 ///    An unsigned 64-bit integer used to specify which bits are extracted. Bits
 262 ///    [7:0] specify the index of the least significant bit. Bits [15:8] specify
 263 ///    the number of bits to be extracted.
 264 /// \returns An unsigned 64-bit integer whose least significant bits contain the
 265 ///    extracted bits.
 266 /// \see _bextr_u64
 267 static __inline__ unsigned long long __DEFAULT_FN_ATTRS
 268 __bextr_u64(unsigned long long __X, unsigned long long __Y)
 269 {
 270   return __builtin_ia32_bextr_u64(__X, __Y);
 271 }
 272
 273 /* Intel-specified, single-leading-underscore version of BEXTR */
 274 /// Extracts the specified bits from the first operand and returns them
 275 ///     in the least significant bits of the result.
 276 ///
 277 /// \headerfile <x86intrin.h>
 278 ///
 279 /// This intrinsic corresponds to the <c> BEXTR </c> instruction.
 280 ///
 281 /// \param __X
 282 ///    An unsigned 64-bit integer whose bits are to be extracted.
 283 /// \param __Y
 284 ///    An unsigned integer used to specify the index of the least significant
 285 ///    bit for the bits to be extracted. Bits [7:0] specify the index.
 286 /// \param __Z
 287 ///    An unsigned integer used to specify the number of bits to be extracted.
 288 ///    Bits [7:0] specify the number of bits.
 289 /// \returns An unsigned 64-bit integer whose least significant bits contain the
 290 ///    extracted bits.
 291 /// \see __bextr_u64
 292 static __inline__ unsigned long long __DEFAULT_FN_ATTRS
 293 _bextr_u64(unsigned long long __X, unsigned int __Y, unsigned int __Z)
 294 {
 295   return __builtin_ia32_bextr_u64 (__X, ((__Y & 0xff) | ((__Z & 0xff) << 8)));
 296 }
 297
 298 /// Clears all bits in the source except for the least significant bit
 299 ///    containing a value of 1 and returns the result.
 300 ///
 301 /// \headerfile <x86intrin.h>
 302 ///
 303 /// This intrinsic corresponds to the <c> BLSI </c> instruction.
 304 ///
 305 /// \param __X
 306 ///    An unsigned 64-bit integer whose bits are to be cleared.
 307 /// \returns An unsigned 64-bit integer containing the result of clearing the
 308 ///    bits from the source operand.
 309 static __inline__ unsigned long long __DEFAULT_FN_ATTRS
 310 __blsi_u64(unsigned long long __X)
 311 {
 312   return __X & -__X;
 313 }
 314
 315 /// Creates a mask whose bits are set to 1, using bit 0 up to and
 316 ///    including the least significant bit that is set to 1 in the source
 317 ///    operand and returns the result.
 318 ///
 319 /// \headerfile <x86intrin.h>
 320 ///
 321 /// This intrinsic corresponds to the <c> BLSMSK </c> instruction.
 322 ///
 323 /// \param __X
 324 ///    An unsigned 64-bit integer used to create the mask.
 325 /// \returns An unsigned 64-bit integer containing the newly created mask.
 326 static __inline__ unsigned long long __DEFAULT_FN_ATTRS
 327 __blsmsk_u64(unsigned long long __X)
 328 {
 329   return __X ^ (__X - 1);
 330 }
 331
 332 /// Clears the least significant bit that is set to 1 in the source
 333 ///    operand and returns the result.
 334 ///
 335 /// \headerfile <x86intrin.h>
 336 ///
 337 /// This intrinsic corresponds to the <c> BLSR </c> instruction.
 338 ///
 339 /// \param __X
 340 ///    An unsigned 64-bit integer containing the operand to be cleared.
 341 /// \returns An unsigned 64-bit integer containing the result of clearing the
 342 ///    source operand.
 343 static __inline__ unsigned long long __DEFAULT_FN_ATTRS
 344 __blsr_u64(unsigned long long __X)
 345 {
 346   return __X & (__X - 1);
 347 }
 348
 349 /// Counts the number of trailing zero bits in the operand.
 350 ///
 351 /// \headerfile <x86intrin.h>
 352 ///
 353 /// This intrinsic corresponds to the <c> TZCNT </c> instruction.
 354 ///
 355 /// \param __X
 356 ///    An unsigned 64-bit integer whose trailing zeros are to be counted.
 357 /// \returns An unsigned 64-bit integer containing the number of trailing zero
 358 ///    bits in the operand.
 359 static __inline__ unsigned long long __RELAXED_FN_ATTRS
 360 __tzcnt_u64(unsigned long long __X)
 361 {
 362   return __X ? __builtin_ctzll(__X) : 64;
 363 }
 364
 365 /// Counts the number of trailing zero bits in the operand.
 366 ///
 367 /// \headerfile <x86intrin.h>
 368 ///
 369 /// This intrinsic corresponds to the <c> TZCNT </c> instruction.
 370 ///
 371 /// \param __X
 372 ///    An unsigned 64-bit integer whose trailing zeros are to be counted.
 373 /// \returns An 64-bit integer containing the number of trailing zero bits in
 374 ///    the operand.
 375 static __inline__ long long __RELAXED_FN_ATTRS
 376 _mm_tzcnt_64(unsigned long long __X)
 377 {
 378   return __X ? __builtin_ctzll(__X) : 64;
 379 }
 380
 381 #endif /* __x86_64__ */
 382
 383 #undef __DEFAULT_FN_ATTRS
 384 #undef __RELAXED_FN_ATTRS
 385
 386 #endif /* __BMIINTRIN_H */