instrset.h File Reference

#include <stdint.h>
#include <stdlib.h>

Include dependency graph for instrset.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
class	Const_int_t< n >
class	Const_uint_t< n >
struct	EList< T, N >

Macros
#define	ALLOW_FP_PERMUTE   true
#define	INSTRSET   0
#define	const_int(n)
#define	const_uint(n)

Functions
int	instrset_detect (void)
bool	hasFMA3 (void)
bool	hasFMA4 (void)
bool	hasXOP (void)
bool	hasAVX512ER (void)
bool	hasAVX512VBMI (void)
bool	hasAVX512VBMI2 (void)
int	physicalProcessors (int *logical_processors=0)
constexpr int	bit_scan_reverse_const (uint64_t const n)
template<typename V>
constexpr auto	get_inttype ()
template<int N>
constexpr auto	zero_mask (int const (&a)[N])
template<typename V>
constexpr auto	zero_mask_broad (int const (&A)[V::size()])
template<int N, int B>
constexpr uint64_t	make_bit_mask (int const (&a)[N])
template<typename V>
constexpr auto	make_broad_mask (uint64_t const m)
template<typename V>
constexpr auto	perm_mask_broad (int const (&A)[V::size()])
template<typename V>
constexpr uint64_t	perm_flags (int const (&a)[V::size()])
template<int N>
constexpr uint64_t	compress_mask (int const (&a)[N])
template<int N>
constexpr uint64_t	expand_mask (int const (&a)[N])
template<typename V>
constexpr uint64_t	perm16_flags (int const (&a)[V::size()])
template<typename V, int oppos = 0>
constexpr auto	pshufb_mask (int const (&A)[V::size()])
template<int N>
constexpr EList< int, N/2 >	largeblock_perm (int const (&a)[N])
template<typename V>
constexpr uint64_t	blend_flags (int const (&a)[V::size()])
template<int N, int dozero>
constexpr EList< int, 2 *N >	blend_perm_indexes (int const (&a)[N])
template<int N>
constexpr EList< int, N/2 >	largeblock_indexes (int const (&a)[N])
template<typename dummy>
void	blend2 ()
template<typename dummy>
void	blend4 ()
template<typename dummy>
void	blend8 ()
template<typename dummy>
void	blend16 ()
template<typename dummy>
void	blend32 ()
template<int N, int dozero, int src1, int src2>
constexpr EList< int, N >	blend_half_indexes (int const (&a)[N])
template<typename W, int... i0>
auto	blend_half (W const &a, W const &b)

Variables
constexpr int	V_DC = -256
const int	perm_zeroing = 1
const int	perm_perm = 2
const int	perm_allzero = 4
const int	perm_largeblock = 8
const int	perm_addz = 0x10
const int	perm_addz2 = 0x20
const int	perm_cross_lane = 0x40
const int	perm_same_pattern = 0x80
const int	perm_punpckh = 0x100
const int	perm_punpckl = 0x200
const int	perm_rotate
const int	perm_shright
const int	perm_shleft
const int	perm_rotate_big
const int	perm_broadcast = 0x8000
const int	perm_zext = 0x10000
const int	perm_compress = 0x20000
const int	perm_expand = 0x40000
const int	perm_outofrange = 0x10000000
const int	perm_rot_count = 32
const int	perm_ipattern
const int	blend_zeroing = 1
const int	blend_allzero = 2
const int	blend_largeblock = 4
const int	blend_addz = 8
const int	blend_a = 0x10
const int	blend_b = 0x20
const int	blend_perma = 0x40
const int	blend_permb = 0x80
const int	blend_cross_lane = 0x100
const int	blend_same_pattern = 0x200
const int	blend_punpckhab = 0x1000
const int	blend_punpckhba = 0x2000
const int	blend_punpcklab = 0x4000
const int	blend_punpcklba = 0x8000
const int	blend_rotateab = 0x10000
const int	blend_rotateba = 0x20000
const int	blend_shufab = 0x40000
const int	blend_shufba = 0x80000
const int	blend_rotate_big = 0x100000
const int	blend_outofrange = 0x10000000
const int	blend_shufpattern = 32
const int	blend_rotpattern = 40

Macro Definition Documentation

ALLOW_FP_PERMUTE

#define ALLOW_FP_PERMUTE   true

Definition at line 28 of file instrset.h.

const_int

#define const_int

(

n

)

Value:

( Const_int_t<n>() )

Definition at line 406 of file instrset.h.

const_uint

#define const_uint

(

n

)

Value:

( Const_uint_t<n>() )

Definition at line 407 of file instrset.h.

INSTRSET

#define INSTRSET   0

Definition at line 76 of file instrset.h.

Function Documentation

bit_scan_reverse_const()

int bit_scan_reverse_const ( uint64_t const n )

constexpr

Definition at line 381 of file instrset.h.

                                                           {
    if ( n == 0 ) return -1;
    uint64_t a = n, b = 0, j = 64, k = 0;
    do {
      j >>= 1;
      k = (uint64_t)1 << j;
      if ( a >= k ) {
        a >>= j;
        b += j;
      }
    } while ( j > 0 );
    return int( b );
  }

blend16()

template<typename dummy>

void blend16

(

)

Definition at line 1298 of file instrset.h.

{}

blend2()

template<typename dummy>

void blend2

(

)

Definition at line 1292 of file instrset.h.

{}

blend32()

template<typename dummy>

void blend32

(

)

Definition at line 1300 of file instrset.h.

{}

blend4()

template<typename dummy>

void blend4

(

)

Definition at line 1294 of file instrset.h.

{}

blend8()

template<typename dummy>

void blend8

(

)

Definition at line 1296 of file instrset.h.

{}

blend_flags()

template<typename V>

uint64_t blend_flags ( int const (&) a[V::size()] )

constexpr

Definition at line 1037 of file instrset.h.

                                                              {
    // a is a reference to a constexpr array of permutation indexes
    // V is a vector class
    constexpr int  N                     = V::size();                                             // number of elements
    uint64_t       r                     = blend_largeblock | blend_same_pattern | blend_allzero; // return value
    uint32_t       iu                    = 0;                                                     // loop counter
    int32_t        ii                    = 0;                                                     // loop counter
    int            ix                    = 0;                                                     // index number i
    const uint32_t nlanes                = sizeof( V ) / 16; // number of 128-bit lanes
    const uint32_t lanesize              = N / nlanes;       // elements per lane
    uint32_t       lane                  = 0;                // current lane
    uint32_t       rot                   = 999;              // rotate left count
    int            lanepattern[lanesize] = { 0 };            // pattern in each lane
    if ( lanesize == 2 && N <= 8 ) {
      r |= blend_shufab | blend_shufba; // check if it fits shufpd
    }
 
    for ( ii = 0; ii < N; ii++ ) { // loop through indexes
      ix = a[ii];                  // index
      if ( ix < 0 ) {
        if ( ix == -1 )
          r |= blend_zeroing; // set to zero
        else if ( ix != V_DC ) {
          r = blend_outofrange;
          break; // illegal index
        }
      } else { // ix >= 0
        r &= ~blend_allzero;
        if ( ix < N ) {
          r |= blend_a;                     // data from a
          if ( ix != ii ) r |= blend_perma; // permutation of a
        } else if ( ix < 2 * N ) {
          r |= blend_b;                         // data from b
          if ( ix != ii + N ) r |= blend_permb; // permutation of b
        } else {
          r = blend_outofrange;
          break; // illegal index
        }
      }
      // check if pattern fits a larger block size:
      // even indexes must be even, odd indexes must fit the preceding even index + 1
      if ( ( ii & 1 ) == 0 ) {                                            // even index
        if ( ix >= 0 && ( ix & 1 ) ) r &= ~blend_largeblock;              // not even. does not fit larger block size
        int iy = a[ii + 1];                                               // next odd index
        if ( iy >= 0 && ( iy & 1 ) == 0 ) r &= ~blend_largeblock;         // not odd. does not fit larger block size
        if ( ix >= 0 && iy >= 0 && iy != ix + 1 ) r &= ~blend_largeblock; // does not fit preceding index + 1
        if ( ix == -1 && iy >= 0 ) r |= blend_addz; // needs additional zeroing at current block size
        if ( iy == -1 && ix >= 0 ) r |= blend_addz; // needs additional zeroing at current block size
      }
      lane = (uint32_t)ii / lanesize; // current lane
      if ( lane == 0 ) {              // first lane, or no pattern yet
        lanepattern[ii] = ix;         // save pattern
      }
      // check if crossing lanes
      if ( ix >= 0 ) {
        uint32_t lanei = uint32_t( ix & ~N ) / lanesize; // source lane
        if ( lanei != lane ) {
          r |= blend_cross_lane; // crossing lane
        }
        if ( lanesize == 2 ) { // check if it fits pshufd
          if ( lanei != lane ) r &= ~( blend_shufab | blend_shufba );
          if ( ( ( ( ix & N ) != 0 ) ^ ii ) & 1 )
            r &= ~blend_shufab;
          else
            r &= ~blend_shufba;
        }
      }
      // check if same pattern in all lanes
      if ( lane != 0 && ix >= 0 ) {                                             // not first lane
        int j  = ii - int( lane * lanesize );                                   // index into lanepattern
        int jx = ix - int( lane * lanesize );                                   // pattern within lane
        if ( jx < 0 || ( jx & ~N ) >= (int)lanesize ) r &= ~blend_same_pattern; // source is in another lane
        if ( lanepattern[j] < 0 ) {
          lanepattern[j] = jx; // pattern not known from previous lane
        } else {
          if ( lanepattern[j] != jx ) r &= ~blend_same_pattern; // not same pattern
        }
      }
    }
    if ( !( r & blend_largeblock ) ) r &= ~blend_addz;    // remove irrelevant flag
    if ( r & blend_cross_lane ) r &= ~blend_same_pattern; // remove irrelevant flag
    if ( !( r & ( blend_perma | blend_permb ) ) ) {
      return r; // no permutation. more checks are superfluous
    }
    if ( r & blend_same_pattern ) {
      // same pattern in all lanes. check if it fits unpack patterns
      r |= blend_punpckhab | blend_punpckhba | blend_punpcklab | blend_punpcklba;
      for ( iu = 0; iu < lanesize; iu++ ) { // loop through lanepattern
        ix = lanepattern[iu];
        if ( ix >= 0 ) {
          if ( (uint32_t)ix != iu / 2 + ( iu & 1 ) * N ) r &= ~blend_punpcklab;
          if ( (uint32_t)ix != iu / 2 + ( ( iu & 1 ) ^ 1 ) * N ) r &= ~blend_punpcklba;
          if ( (uint32_t)ix != ( iu + lanesize ) / 2 + ( iu & 1 ) * N ) r &= ~blend_punpckhab;
          if ( (uint32_t)ix != ( iu + lanesize ) / 2 + ( ( iu & 1 ) ^ 1 ) * N ) r &= ~blend_punpckhba;
        }
      }
#if INSTRSET >= 4 // SSSE3. check if it fits palignr
      for ( iu = 0; iu < lanesize; iu++ ) {
        ix = lanepattern[iu];
        if ( ix >= 0 ) {
          uint32_t t = ix & ~N;
          if ( ix & N ) t += lanesize;
          uint32_t tb = ( t + 2 * lanesize - iu ) % ( lanesize * 2 );
          if ( rot == 999 ) {
            rot = tb;
          } else { // check if fit
            if ( rot != tb ) rot = 1000;
          }
        }
      }
      if ( rot < 999 ) { // firs palignr
        if ( rot < lanesize ) {
          r |= blend_rotateba;
        } else {
          r |= blend_rotateab;
        }
        const uint32_t elementsize = sizeof( V ) / N;
        r |= uint64_t( ( rot & ( lanesize - 1 ) ) * elementsize ) << blend_rotpattern;
      }
#endif
      if ( lanesize == 4 ) {
        // check if it fits shufps
        r |= blend_shufab | blend_shufba;
        for ( ii = 0; ii < 2; ii++ ) {
          ix = lanepattern[ii];
          if ( ix >= 0 ) {
            if ( ix & N )
              r &= ~blend_shufab;
            else
              r &= ~blend_shufba;
          }
        }
        for ( ; ii < 4; ii++ ) {
          ix = lanepattern[ii];
          if ( ix >= 0 ) {
            if ( ix & N )
              r &= ~blend_shufba;
            else
              r &= ~blend_shufab;
          }
        }
        if ( r & ( blend_shufab | blend_shufba ) ) { // fits shufps/shufpd
          uint8_t shufpattern = 0;                   // get pattern
          for ( iu = 0; iu < lanesize; iu++ ) { shufpattern |= ( lanepattern[iu] & 3 ) << iu * 2; }
          r |= (uint64_t)shufpattern << blend_shufpattern; // return pattern
        }
      }
    } else if ( nlanes > 1 ) { // not same pattern in all lanes
      rot = 999;               // check if it fits big rotate
      for ( ii = 0; ii < N; ii++ ) {
        ix = a[ii];
        if ( ix >= 0 ) {
          uint32_t rot2 = ( ix + 2 * N - ii ) % ( 2 * N ); // rotate count
          if ( rot == 999 ) {
            rot = rot2; // save rotate count
          } else if ( rot != rot2 ) {
            rot = 1000;
            break; // does not fit big rotate
          }
        }
      }
      if ( rot < 2 * N ) { // fits big rotate
        r |= blend_rotate_big | (uint64_t)rot << blend_rotpattern;
      }
    }
    if ( lanesize == 2 && ( r & ( blend_shufab | blend_shufba ) ) ) { // fits shufpd. Get pattern
      for ( ii = 0; ii < N; ii++ ) { r |= uint64_t( a[ii] & 1 ) << ( blend_shufpattern + ii ); }
    }
    return r;
  }

blend_half()

template<typename W, int... i0>

auto blend_half	(	W const &	a,
		W const &	b )

Definition at line 1353 of file instrset.h.

                                            {
    typedef decltype( a.get_low() ) V;             // type for half-size vector
    constexpr int                   N = V::size(); // size of half-size vector
    static_assert( sizeof...( i0 ) == N, "wrong number of indexes in blend_half" );
    constexpr int ind[N] = { i0... }; // array of indexes
 
    // lambda to find which of the four possible sources are used
    // return: EList<int, 5> containing a list of up to 4 sources. The last element is the number of sources used
    auto listsources = []( int const n, int const( &ind )[N] ) constexpr {
      bool source_used[4] = { false, false, false, false }; // list of sources used
      int  i              = 0;
      for ( i = 0; i < n; i++ ) {
        int ix = ind[i]; // index
        if ( ix >= 0 ) {
          int src              = ix / n; // source used
          source_used[src & 3] = true;
        }
      }
      // return a list of sources used. The last element is the number of sources used
      EList<int, 5> sources = { { 0 } };
      int           nsrc    = 0; // number of sources
      for ( i = 0; i < 4; i++ ) {
        if ( source_used[i] ) { sources.a[nsrc++] = i; }
      }
      sources.a[4] = nsrc;
      return sources;
    };
    // list of sources used
    constexpr EList<int, 5> sources = listsources( N, ind );
    constexpr int           nsrc    = sources.a[4]; // number of sources used
 
    if constexpr ( nsrc == 0 ) { // no sources
      return V( 0 );
    }
    // get indexes for the first one or two sources
    constexpr int           uindex = ( nsrc > 2 ) ? 1 : 2; // unused elements set to zero if two blends are combined
    constexpr EList<int, N> L      = blend_half_indexes<N, uindex, sources.a[0], sources.a[1]>( ind );
    V                       x0;
    V                       src0 = selectblend<W, sources.a[0]>( a, b ); // first source
    V                       src1 = selectblend<W, sources.a[1]>( a, b ); // second source
    if constexpr ( N == 2 ) {
      x0 = blend2<L.a[0], L.a[1]>( src0, src1 );
    } else if constexpr ( N == 4 ) {
      x0 = blend4<L.a[0], L.a[1], L.a[2], L.a[3]>( src0, src1 );
    } else if constexpr ( N == 8 ) {
      x0 = blend8<L.a[0], L.a[1], L.a[2], L.a[3], L.a[4], L.a[5], L.a[6], L.a[7]>( src0, src1 );
    } else if constexpr ( N == 16 ) {
      x0 = blend16<L.a[0], L.a[1], L.a[2], L.a[3], L.a[4], L.a[5], L.a[6], L.a[7], L.a[8], L.a[9], L.a[10], L.a[11],
                   L.a[12], L.a[13], L.a[14], L.a[15]>( src0, src1 );
    } else if constexpr ( N == 32 ) {
      x0 = blend32<L.a[0], L.a[1], L.a[2], L.a[3], L.a[4], L.a[5], L.a[6], L.a[7], L.a[8], L.a[9], L.a[10], L.a[11],
                   L.a[12], L.a[13], L.a[14], L.a[15], L.a[16], L.a[17], L.a[18], L.a[19], L.a[20], L.a[21], L.a[22],
                   L.a[23], L.a[24], L.a[25], L.a[26], L.a[27], L.a[28], L.a[29], L.a[30], L.a[31]>( src0, src1 );
    }
    if constexpr ( nsrc > 2 ) { // get last one or two sources
      constexpr EList<int, N> M = blend_half_indexes<N, 1, sources.a[2], sources.a[3]>( ind );
      V                       x1;
      V                       src2 = selectblend<W, sources.a[2]>( a, b ); // third source
      V                       src3 = selectblend<W, sources.a[3]>( a, b ); // fourth source
      if constexpr ( N == 2 ) {
        x1 = blend2<M.a[0], M.a[1]>( src0, src1 );
      } else if constexpr ( N == 4 ) {
        x1 = blend4<M.a[0], M.a[1], M.a[2], M.a[3]>( src2, src3 );
      } else if constexpr ( N == 8 ) {
        x1 = blend8<M.a[0], M.a[1], M.a[2], M.a[3], M.a[4], M.a[5], M.a[6], M.a[7]>( src2, src3 );
      } else if constexpr ( N == 16 ) {
        x1 = blend16<M.a[0], M.a[1], M.a[2], M.a[3], M.a[4], M.a[5], M.a[6], M.a[7], M.a[8], M.a[9], M.a[10], M.a[11],
                     M.a[12], M.a[13], M.a[14], M.a[15]>( src2, src3 );
      } else if constexpr ( N == 32 ) {
        x1 = blend32<M.a[0], M.a[1], M.a[2], M.a[3], M.a[4], M.a[5], M.a[6], M.a[7], M.a[8], M.a[9], M.a[10], M.a[11],
                     M.a[12], M.a[13], M.a[14], M.a[15], M.a[16], M.a[17], M.a[18], M.a[19], M.a[20], M.a[21], M.a[22],
                     M.a[23], M.a[24], M.a[25], M.a[26], M.a[27], M.a[28], M.a[29], M.a[30], M.a[31]>( src2, src3 );
      }
      x0 |= x1; // combine result of two blends. Unused elements are zero
    }
    return x0;
  }

blend_half_indexes()

template<int N, int dozero, int src1, int src2>

EList< int, N > blend_half_indexes ( int const (&) a[N] )

constexpr

Definition at line 1309 of file instrset.h.

                                                                    {
    // a is a reference to a constexpr array of permutation indexes
    EList<int, N> list = { { 0 } };          // list to return
    int           u    = dozero ? -1 : V_DC; // value to use for unused entries
    int           j    = 0;                  // loop counter
 
    for ( j = 0; j < N; j++ ) { // loop through indexes
      int ix = a[j];            // current index
      if ( ix < 0 ) {           // zero or don't care
        list.a[j] = ( dozero == 2 ) ? ix : u;
      } else {
        int src = ix / N; // source
        if ( src == src1 ) {
          list.a[j] = ix & ( N - 1 );
        } else if ( src == src2 ) {
          list.a[j] = ( ix & ( N - 1 ) ) + N;
        } else
          list.a[j] = u;
      }
    }
    return list;
  }

blend_perm_indexes()

template<int N, int dozero>

EList< int, 2 *N > blend_perm_indexes ( int const (&) a[N] )

constexpr

Definition at line 1214 of file instrset.h.

                                                                        {
    // a is a reference to a constexpr array of permutation indexes
    EList<int, 2 * N> list = { { 0 } };          // list to return
    int               u    = dozero ? -1 : V_DC; // value to use for unused entries
    int               j    = 0;
 
    for ( j = 0; j < N; j++ ) { // loop through indexes
      int ix = a[j];            // current index
      if ( ix < 0 ) {           // zero or don't care
        if ( dozero == 2 ) {
          // list.a[j] = list.a[j + N] = ix;  // fails in gcc in complicated cases
          list.a[j]     = ix;
          list.a[j + N] = ix;
        } else {
          // list.a[j] = list.a[j + N] = u;
          list.a[j]     = u;
          list.a[j + N] = u;
        }
      } else if ( ix < N ) { // value from a
        list.a[j]     = ix;
        list.a[j + N] = u;
      } else {
        list.a[j]     = u; // value from b
        list.a[j + N] = ix - N;
      }
    }
    return list;
  }

compress_mask()

template<int N>

uint64_t compress_mask ( int const (&) a[N] )

constexpr

Definition at line 824 of file instrset.h.

                                                          {
    // a is a reference to a constexpr array of permutation indexes
    int      ix = 0, lasti = -1, lastp = -1;
    uint64_t m = 0;
    int      i = 0;
    int      j = 1; // loop counters
    for ( i = 0; i < N; i++ ) {
      ix = a[i]; // permutation index
      if ( ix >= 0 ) {
        m |= (uint64_t)1 << ix; // mask for compression source
        for ( j = 1; j < i - lastp; j++ ) {
          m |= (uint64_t)1 << ( lasti + j ); // dummy filling source
        }
        lastp = i;
        lasti = ix;
      }
    }
    return m;
  }

expand_mask()

template<int N>

uint64_t expand_mask ( int const (&) a[N] )

constexpr

Definition at line 848 of file instrset.h.

                                                        {
    // a is a reference to a constexpr array of permutation indexes
    int      ix = 0, lasti = -1, lastp = -1;
    uint64_t m = 0;
    int      i = 0;
    int      j = 1;
    for ( i = 0; i < N; i++ ) {
      ix = a[i]; // permutation index
      if ( ix >= 0 ) {
        m |= (uint64_t)1 << i; // mask for expansion destination
        for ( j = 1; j < ix - lasti; j++ ) {
          m |= (uint64_t)1 << ( lastp + j ); // dummy filling destination
        }
        lastp = i;
        lasti = ix;
      }
    }
    return m;
  }

get_inttype()

template<typename V>

auto get_inttype ( )

constexpr

Definition at line 469 of file instrset.h.

                               {
    constexpr int elementsize = sizeof( V ) / V::size(); // size of vector elements
 
    if constexpr ( elementsize >= 8 ) {
      return -int64_t( 1 );
    } else if constexpr ( elementsize >= 4 ) {
      return int32_t( -1 );
    } else if constexpr ( elementsize >= 2 ) {
      return int16_t( -1 );
    } else {
      return int8_t( -1 );
    }
  }

hasAVX512ER()

bool hasAVX512ER

(

void

)

Definition at line 142 of file instrset_detect.cpp.

                           {
    if ( instrset_detect() < 9 ) return false; // must have AVX512F
    int abcd[4];                               // cpuid results
    cpuid( abcd, 7 );                          // call cpuid function 7
    return ( ( abcd[1] & ( 1 << 27 ) ) != 0 ); // ebx bit 27 indicates AVX512ER
  }

hasAVX512VBMI()

bool hasAVX512VBMI

(

void

)

Definition at line 150 of file instrset_detect.cpp.

                             {
    if ( instrset_detect() < 10 ) return false; // must have AVX512BW
    int abcd[4];                                // cpuid results
    cpuid( abcd, 7 );                           // call cpuid function 7
    return ( ( abcd[2] & ( 1 << 1 ) ) != 0 );   // ecx bit 1 indicates AVX512VBMI
  }

hasAVX512VBMI2()

bool hasAVX512VBMI2

(

void

)

Definition at line 158 of file instrset_detect.cpp.

                              {
    if ( instrset_detect() < 10 ) return false; // must have AVX512BW
    int abcd[4];                                // cpuid results
    cpuid( abcd, 7 );                           // call cpuid function 7
    return ( ( abcd[2] & ( 1 << 6 ) ) != 0 );   // ecx bit 6 indicates AVX512VBMI2
  }

hasFMA3()

bool hasFMA3

(

void

)

Definition at line 110 of file instrset_detect.cpp.

                       {
    if ( instrset_detect() < 7 ) return false; // must have AVX
    int abcd[4];                               // cpuid results
    cpuid( abcd, 1 );                          // call cpuid function 1
    return ( ( abcd[2] & ( 1 << 12 ) ) != 0 ); // ecx bit 12 indicates FMA3
  }

hasFMA4()

bool hasFMA4

(

void

)

Definition at line 118 of file instrset_detect.cpp.

                       {
    if ( instrset_detect() < 7 ) return false; // must have AVX
    int abcd[4];                               // cpuid results
    cpuid( abcd, 0x80000001 );                 // call cpuid function 0x80000001
    return ( ( abcd[2] & ( 1 << 16 ) ) != 0 ); // ecx bit 16 indicates FMA4
  }

hasXOP()

bool hasXOP

(

void

)

Definition at line 126 of file instrset_detect.cpp.

                      {
    if ( instrset_detect() < 7 ) return false; // must have AVX
    int abcd[4];                               // cpuid results
    cpuid( abcd, 0x80000001 );                 // call cpuid function 0x80000001
    return ( ( abcd[2] & ( 1 << 11 ) ) != 0 ); // ecx bit 11 indicates XOP
  }

instrset_detect()

int instrset_detect

(

void

)

Definition at line 63 of file instrset_detect.cpp.

                              {
 
    static int iset = -1; // remember value for next call
    if ( iset >= 0 ) {
      return iset; // called before
    }
    iset        = 0;                                   // default value
    int abcd[4] = { 0, 0, 0, 0 };                      // cpuid results
    cpuid( abcd, 0 );                                  // call cpuid function 0
    if ( abcd[0] == 0 ) return iset;                   // no further cpuid function supported
    cpuid( abcd, 1 );                                  // call cpuid function 1 for feature flags
    if ( ( abcd[3] & ( 1 << 0 ) ) == 0 ) return iset;  // no floating point
    if ( ( abcd[3] & ( 1 << 23 ) ) == 0 ) return iset; // no MMX
    if ( ( abcd[3] & ( 1 << 15 ) ) == 0 ) return iset; // no conditional move
    if ( ( abcd[3] & ( 1 << 24 ) ) == 0 ) return iset; // no FXSAVE
    if ( ( abcd[3] & ( 1 << 25 ) ) == 0 ) return iset; // no SSE
    iset = 1;                                          // 1: SSE supported
    if ( ( abcd[3] & ( 1 << 26 ) ) == 0 ) return iset; // no SSE2
    iset = 2;                                          // 2: SSE2 supported
    if ( ( abcd[2] & ( 1 << 0 ) ) == 0 ) return iset;  // no SSE3
    iset = 3;                                          // 3: SSE3 supported
    if ( ( abcd[2] & ( 1 << 9 ) ) == 0 ) return iset;  // no SSSE3
    iset = 4;                                          // 4: SSSE3 supported
    if ( ( abcd[2] & ( 1 << 19 ) ) == 0 ) return iset; // no SSE4.1
    iset = 5;                                          // 5: SSE4.1 supported
    if ( ( abcd[2] & ( 1 << 23 ) ) == 0 ) return iset; // no POPCNT
    if ( ( abcd[2] & ( 1 << 20 ) ) == 0 ) return iset; // no SSE4.2
    iset = 6;                                          // 6: SSE4.2 supported
    if ( ( abcd[2] & ( 1 << 27 ) ) == 0 ) return iset; // no OSXSAVE
    if ( ( xgetbv( 0 ) & 6 ) != 6 ) return iset;       // AVX not enabled in O.S.
    if ( ( abcd[2] & ( 1 << 28 ) ) == 0 ) return iset; // no AVX
    iset = 7;                                          // 7: AVX supported
    cpuid( abcd, 7 );                                  // call cpuid leaf 7 for feature flags
    if ( ( abcd[1] & ( 1 << 5 ) ) == 0 ) return iset;  // no AVX2
    iset = 8;
    if ( ( abcd[1] & ( 1 << 16 ) ) == 0 ) return iset; // no AVX512
    cpuid( abcd, 0xD );                                // call cpuid leaf 0xD for feature flags
    if ( ( abcd[0] & 0x60 ) != 0x60 ) return iset;     // no AVX512
    iset = 9;
    cpuid( abcd, 7 );                                          // call cpuid leaf 7 for feature flags
    if ( ( abcd[1] & ( 1 << 31 ) ) == 0 ) return iset;         // no AVX512VL
    if ( ( abcd[1] & 0x40020000 ) != 0x40020000 ) return iset; // no AVX512BW, AVX512DQ
    iset = 10;
    return iset;
  }

largeblock_indexes()

template<int N>

EList< int, N/2 > largeblock_indexes ( int const (&) a[N] )

constexpr

Definition at line 1249 of file instrset.h.

                                                                        {
    // Parameter a is a reference to a constexpr array of N permutation indexes
    EList<int, N / 2> list = { { 0 } }; // list to return
 
    bool fit_addz = false; // additional zeroing needed at the lower block level
    int  ix       = 0;     // even index
    int  iy       = 0;     // odd index
    int  iz       = 0;     // combined index
    int  i        = 0;     // loop counter
 
    for ( i = 0; i < N; i += 2 ) {
      ix = a[i];     // even index
      iy = a[i + 1]; // odd index
      if ( ix >= 0 ) {
        iz = ix / 2; // half index
      } else if ( iy >= 0 ) {
        iz = iy / 2; // half index
      } else
        iz = ix | iy;     // -1 or V_DC. -1 takes precedence
      list.a[i / 2] = iz; // save to list
      // check if additional zeroing is needed at current block size
      if ( ( ix == -1 && iy >= 0 ) || ( iy == -1 && ix >= 0 ) ) { fit_addz = true; }
    }
    // replace -1 by V_DC if fit_addz
    if ( fit_addz ) {
      for ( i = 0; i < N / 2; i++ ) {
        if ( list.a[i] < 0 ) list.a[i] = V_DC;
      }
    }
    return list;
  }

largeblock_perm()

template<int N>

EList< int, N/2 > largeblock_perm ( int const (&) a[N] )

constexpr

Definition at line 978 of file instrset.h.

                                                                     {
    // Parameter a is a reference to a constexpr array of permutation indexes
    EList<int, N / 2> list     = { { 0 } }; // result indexes
    int               ix       = 0;         // even index
    int               iy       = 0;         // odd index
    int               iz       = 0;         // combined index
    bool              fit_addz = false;     // additional zeroing needed at the lower block level
    int               i        = 0;         // loop counter
 
    // check if additional zeroing is needed at current block size
    for ( i = 0; i < N; i += 2 ) {
      ix = a[i];     // even index
      iy = a[i + 1]; // odd index
      if ( ( ix == -1 && iy >= 0 ) || ( iy == -1 && ix >= 0 ) ) { fit_addz = true; }
    }
 
    // loop through indexes
    for ( i = 0; i < N; i += 2 ) {
      ix = a[i];     // even index
      iy = a[i + 1]; // odd index
      if ( ix >= 0 ) {
        iz = ix / 2; // half index
      } else if ( iy >= 0 ) {
        iz = iy / 2;
      } else {
        iz = ix | iy;              // -1 or V_DC. -1 takes precedence
        if ( fit_addz ) iz = V_DC; // V_DC, because result will be zeroed later
      }
      list.a[i / 2] = iz; // save to list
    }
    return list;
  }

make_bit_mask()

template<int N, int B>

uint64_t make_bit_mask ( int const (&) a[N] )

constexpr

Definition at line 525 of file instrset.h.

                                                          {
    uint64_t r = 0;                   // return value
    uint8_t  j = uint8_t( B & 0xFF ); // index to selected bit
    uint64_t s = 0;                   // bit number i in r
    uint64_t f = 0;                   // 1 if bit not flipped
    int      i = 0;
    for ( i = 0; i < N; i++ ) {
      int ix = a[i];
      if ( ix < 0 ) { // -1 or V_DC
        s = ( B >> 10 ) & 1;
      } else {
        s = ( (uint32_t)ix >> j ) & 1; // extract selected bit
        if ( i < N / 2 ) {
          f = ( B >> 8 ) & 1; // lower half
        } else {
          f = ( B >> 9 ) & 1; // upper half
        }
        s ^= f ^ 1; // flip bit if needed
      }
      r |= uint64_t( s ) << i; // set bit in return value
    }
    return r;
  }

make_broad_mask()

template<typename V>

auto make_broad_mask ( uint64_t const m )

constexpr

Definition at line 552 of file instrset.h.

                                                     {
    constexpr int                        N = V::size(); // number of vector elements
    typedef decltype( get_inttype<V>() ) Etype;         // element type
    EList<Etype, N>                      u = { { 0 } }; // list for returning
    int                                  i = 0;
    for ( i = 0; i < N; i++ ) { u.a[i] = ( ( m >> i ) & 1 ) != 0 ? get_inttype<V>() : 0; }
    return u; // return encapsulated array
  }

perm16_flags()

template<typename V>

uint64_t perm16_flags ( int const (&) a[V::size()] )

constexpr

Definition at line 876 of file instrset.h.

                                                               {
    // a is a reference to a constexpr array of permutation indexes
    // V is a vector class
    constexpr int N = V::size(); // number of elements
 
    uint64_t       retval                = 0;              // return value
    uint32_t       pat[4]                = { 0, 0, 0, 0 }; // permute patterns
    uint32_t       i                     = 0;              // loop counter
    int            ix                    = 0;              // index number i
    const uint32_t lanesize              = 8;              // elements per lane
    uint32_t       lane                  = 0;              // current lane
    int            lanepattern[lanesize] = { 0 };          // pattern in each lane
 
    for ( i = 0; i < N; i++ ) {
      ix   = a[i];
      lane = i / lanesize; // current lane
      if ( lane == 0 ) {
        lanepattern[i] = ix;                // save pattern
      } else if ( ix >= 0 ) {               // not first lane
        uint32_t j  = i - lane * lanesize;  // index into lanepattern
        int      jx = ix - lane * lanesize; // pattern within lane
        if ( lanepattern[j] < 0 ) {
          lanepattern[j] = jx; // pattern not known from previous lane
        }
      }
    }
    // four patterns: low2low, high2high, high2low, low2high
    for ( i = 0; i < 4; i++ ) {
      // loop through low pattern
      if ( lanepattern[i] >= 0 ) {
        if ( lanepattern[i] < 4 ) { // low2low
          retval |= 1;
          pat[0] |= uint32_t( lanepattern[i] & 3 ) << ( 2 * i );
        } else { // high2low
          retval |= 4;
          pat[2] |= uint32_t( lanepattern[i] & 3 ) << ( 2 * i );
        }
      }
      // loop through high pattern
      if ( lanepattern[i + 4] >= 0 ) {
        if ( lanepattern[i + 4] < 4 ) { // low2high
          retval |= 8;
          pat[3] |= uint32_t( lanepattern[i + 4] & 3 ) << ( 2 * i );
        } else { // high2high
          retval |= 2;
          pat[1] |= uint32_t( lanepattern[i + 4] & 3 ) << ( 2 * i );
        }
      }
    }
    // join return data
    for ( i = 0; i < 4; i++ ) { retval |= (uint64_t)pat[i] << ( 32 + i * 8 ); }
    return retval;
  }

perm_flags()

template<typename V>

uint64_t perm_flags ( int const (&) a[V::size()] )

constexpr

Definition at line 603 of file instrset.h.

                                                             {
    // a is a reference to a constexpr array of permutation indexes
    // V is a vector class
    constexpr int  N             = V::size();                                          // number of elements
    uint64_t       r             = perm_largeblock | perm_same_pattern | perm_allzero; // return value
    uint32_t       i             = 0;                                                  // loop counter
    int            j             = 0;                                                  // loop counter
    int            ix            = 0;                                                  // index number i
    const uint32_t nlanes        = sizeof( V ) / 16;                                   // number of 128-bit lanes
    const uint32_t lanesize      = N / nlanes;                                         // elements per lane
    const uint32_t elementsize   = sizeof( V ) / N;                                    // size of each vector element
    uint32_t       lane          = 0;                                                  // current lane
    uint32_t       rot           = 999;                                                // rotate left count
    int32_t        broadc        = 999;                                                // index to broadcasted element
    uint32_t       patfail       = 0;  // remember certain patterns that do not fit
    uint32_t       addz2         = 0;  // remember certain patterns need extra zeroing
    int32_t        compresslasti = -1; // last index in perm_compress fit
    int32_t        compresslastp = -1; // last position in perm_compress fit
    int32_t        expandlasti   = -1; // last index in perm_expand fit
    int32_t        expandlastp   = -1; // last position in perm_expand fit
 
    int lanepattern[lanesize] = { 0 }; // pattern in each lane
 
    for ( i = 0; i < N; i++ ) { // loop through indexes
      ix = a[i];                // current index
      // meaning of ix: -1 = set to zero, V_DC = don't care, non-negative value = permute.
      if ( ix == -1 ) {
        r |= perm_zeroing; // zeroing requested
      } else if ( ix != V_DC && uint32_t( ix ) >= N ) {
        r |= perm_outofrange; // index out of range
      }
      if ( ix >= 0 ) {
        r &= ~perm_allzero;                 // not all zero
        if ( ix != (int)i ) r |= perm_perm; // needs permutation
        if ( broadc == 999 )
          broadc = ix; // remember broadcast index
        else if ( broadc != ix )
          broadc = 1000; // does not fit broadcast
      }
      // check if pattern fits a larger block size:
      // even indexes must be even, odd indexes must fit the preceding even index + 1
      if ( ( i & 1 ) == 0 ) {                                            // even index
        if ( ix >= 0 && ( ix & 1 ) ) r &= ~perm_largeblock;              // not even. does not fit larger block size
        int iy = a[i + 1];                                               // next odd index
        if ( iy >= 0 && ( iy & 1 ) == 0 ) r &= ~perm_largeblock;         // not odd. does not fit larger block size
        if ( ix >= 0 && iy >= 0 && iy != ix + 1 ) r &= ~perm_largeblock; // does not fit preceding index + 1
        if ( ix == -1 && iy >= 0 ) r |= perm_addz; // needs additional zeroing at current block size
        if ( iy == -1 && ix >= 0 ) r |= perm_addz; // needs additional zeroing at current block size
      }
      lane = i / lanesize;   // current lane
      if ( lane == 0 ) {     // first lane, or no pattern yet
        lanepattern[i] = ix; // save pattern
      }
      // check if crossing lanes
      if ( ix >= 0 ) {
        uint32_t lanei = (uint32_t)ix / lanesize;  // source lane
        if ( lanei != lane ) r |= perm_cross_lane; // crossing lane
      }
      // check if same pattern in all lanes
      if ( lane != 0 && ix >= 0 ) {                                   // not first lane
        int j1 = i - int( lane * lanesize );                          // index into lanepattern
        int jx = ix - int( lane * lanesize );                         // pattern within lane
        if ( jx < 0 || jx >= (int)lanesize ) r &= ~perm_same_pattern; // source is in another lane
        if ( lanepattern[j1] < 0 ) {
          lanepattern[j1] = jx; // pattern not known from previous lane
        } else {
          if ( lanepattern[j1] != jx ) r &= ~perm_same_pattern; // not same pattern
        }
      }
      if ( ix >= 0 ) {
        // check if pattern fits zero extension (perm_zext)
        if ( uint32_t( ix * 2 ) != i ) {
          patfail |= 1; // does not fit zero extension
        }
        // check if pattern fits compress (perm_compress)
        if ( ix > compresslasti && ix - compresslasti >= (int)i - compresslastp ) {
          if ( (int)i - compresslastp > 1 ) addz2 |= 2; // perm_compress may need additional zeroing
          compresslasti = ix;
          compresslastp = i;
        } else {
          patfail |= 2; // does not fit perm_compress
        }
        // check if pattern fits expand (perm_expand)
        if ( ix > expandlasti && ix - expandlasti <= (int)i - expandlastp ) {
          if ( ix - expandlasti > 1 ) addz2 |= 4; // perm_expand may need additional zeroing
          expandlasti = ix;
          expandlastp = i;
        } else {
          patfail |= 4; // does not fit perm_compress
        }
      } else if ( ix == -1 ) {
        if ( ( i & 1 ) == 0 ) addz2 |= 1; // zero extension needs additional zeroing
      }
    }
    if ( !( r & perm_perm ) ) return r; // more checks are superfluous
 
    if ( !( r & perm_largeblock ) ) r &= ~perm_addz;    // remove irrelevant flag
    if ( r & perm_cross_lane ) r &= ~perm_same_pattern; // remove irrelevant flag
    if ( ( patfail & 1 ) == 0 ) {
      r |= perm_zext; // fits zero extension
      if ( ( addz2 & 1 ) != 0 ) r |= perm_addz2;
    } else if ( ( patfail & 2 ) == 0 ) {
      r |= perm_compress;         // fits compression
      if ( ( addz2 & 2 ) != 0 ) { // check if additional zeroing needed
        for ( j = 0; j < compresslastp; j++ ) {
          if ( a[j] == -1 ) r |= perm_addz2;
        }
      }
    } else if ( ( patfail & 4 ) == 0 ) {
      r |= perm_expand;           // fits expansion
      if ( ( addz2 & 4 ) != 0 ) { // check if additional zeroing needed
        for ( j = 0; j < expandlastp; j++ ) {
          if ( a[j] == -1 ) r |= perm_addz2;
        }
      }
    }
 
    if ( r & perm_same_pattern ) {
      // same pattern in all lanes. check if it fits specific patterns
      bool fit = true;
      // fit shift or rotate
      for ( i = 0; i < lanesize; i++ ) {
        if ( lanepattern[i] >= 0 ) {
          uint32_t rot1 = uint32_t( lanepattern[i] + lanesize - i ) % lanesize;
          if ( rot == 999 ) {
            rot = rot1;
          } else { // check if fit
            if ( rot != rot1 ) fit = false;
          }
        }
      }
      rot &= lanesize - 1;                           // prevent out of range values
      if ( fit ) {                                   // fits rotate, and possibly shift
        uint64_t rot2 = ( rot * elementsize ) & 0xF; // rotate right count in bytes
        r |= rot2 << perm_rot_count;                 // put shift/rotate count in output bit 16-19
#if INSTRSET >= 4                                    // SSSE3
        r |= perm_rotate;                            // allow palignr
#endif
        // fit shift left
        fit = true;
        for ( i = 0; i < lanesize - rot; i++ ) { // check if first rot elements are zero or don't care
          if ( lanepattern[i] >= 0 ) fit = false;
        }
        if ( fit ) {
          r |= perm_shleft;
          for ( ; i < lanesize; i++ )
            if ( lanepattern[i] == -1 ) r |= perm_addz; // additional zeroing needed
        }
        // fit shift right
        fit = true;
        for ( i = lanesize - (uint32_t)rot; i < lanesize;
              i++ ) { // check if last (lanesize-rot) elements are zero or don't care
          if ( lanepattern[i] >= 0 ) fit = false;
        }
        if ( fit ) {
          r |= perm_shright;
          for ( i = 0; i < lanesize - rot; i++ ) {
            if ( lanepattern[i] == -1 ) r |= perm_addz; // additional zeroing needed
          }
        }
      }
      // fit punpckhi
      fit         = true;
      uint32_t j2 = lanesize / 2;
      for ( i = 0; i < lanesize; i++ ) {
        if ( lanepattern[i] >= 0 && lanepattern[i] != (int)j2 ) fit = false;
        if ( ( i & 1 ) != 0 ) j2++;
      }
      if ( fit ) r |= perm_punpckh;
      // fit punpcklo
      fit = true;
      j2  = 0;
      for ( i = 0; i < lanesize; i++ ) {
        if ( lanepattern[i] >= 0 && lanepattern[i] != (int)j2 ) fit = false;
        if ( ( i & 1 ) != 0 ) j2++;
      }
      if ( fit ) r |= perm_punpckl;
      // fit pshufd
      if ( elementsize >= 4 ) {
        uint64_t p = 0;
        for ( i = 0; i < lanesize; i++ ) {
          if ( lanesize == 4 ) {
            p |= ( lanepattern[i] & 3 ) << 2 * i;
          } else { // lanesize = 2
            p |= ( ( lanepattern[i] & 1 ) * 10 + 4 ) << 4 * i;
          }
        }
        r |= p << perm_ipattern;
      }
    }
#if INSTRSET >= 7
    else {                          // not same pattern in all lanes
      if constexpr ( nlanes > 1 ) { // Try if it fits big rotate
        for ( i = 0; i < N; i++ ) {
          ix = a[i];
          if ( ix >= 0 ) {
            uint32_t rot2 = ( ix + N - i ) % N; // rotate count
            if ( rot == 999 ) {
              rot = rot2; // save rotate count
            } else if ( rot != rot2 ) {
              rot = 1000;
              break; // does not fit big rotate
            }
          }
        }
        if ( rot < N ) { // fits big rotate
          r |= perm_rotate_big | (uint64_t)rot << perm_rot_count;
        }
      }
    }
#endif
    if ( broadc < 999 && ( r & ( perm_rotate | perm_shright | perm_shleft | perm_rotate_big ) ) == 0 ) {
      r |= perm_broadcast | (uint64_t)broadc << perm_rot_count; // fits broadcast
    }
    return r;
  }

perm_mask_broad()

template<typename V>

auto perm_mask_broad ( int const (&) A[V::size()] )

constexpr

Definition at line 564 of file instrset.h.

                                                              {
    constexpr int                        N = V::size(); // number of vector elements
    typedef decltype( get_inttype<V>() ) Etype;         // vector element type
    EList<Etype, N>                      u = { { 0 } }; // list for returning
    int                                  i = 0;
    for ( i = 0; i < N; i++ ) { u.a[i] = Etype( A[i] ); }
    return u; // return encapsulated array
  }

physicalProcessors()

int physicalProcessors

(

int *

logical_processors = 0

)

pshufb_mask()

template<typename V, int oppos = 0>

auto pshufb_mask ( int const (&) A[V::size()] )

constexpr

Definition at line 935 of file instrset.h.

                                                          {
    // Parameter a is a reference to a constexpr array of permutation indexes
    // V is a vector class
    // oppos = 1 for data from the opposite 128-bit lane in 256-bit vectors
    constexpr uint32_t N                 = V::size();        // number of vector elements
    constexpr uint32_t elementsize       = sizeof( V ) / N;  // size of each vector element
    constexpr uint32_t nlanes            = sizeof( V ) / 16; // number of 128 bit lanes in vector
    constexpr uint32_t elements_per_lane = N / nlanes;       // number of vector elements per lane
 
    EList<int8_t, sizeof( V )> u = { { 0 } }; // list for returning
 
    uint32_t i    = 0; // loop counters
    uint32_t j    = 0;
    int      m    = 0;
    int      k    = 0;
    uint32_t lane = 0;
 
    for ( lane = 0; lane < nlanes; lane++ ) {     // loop through lanes
      for ( i = 0; i < elements_per_lane; i++ ) { // loop through elements in lane
        // permutation index for element within lane
        int8_t p  = -1;
        int    ix = A[m];
        if ( ix >= 0 ) {
          ix ^= oppos * elements_per_lane; // flip bit if opposite lane
        }
        ix -= int( lane * elements_per_lane );          // index relative to lane
        if ( ix >= 0 && ix < (int)elements_per_lane ) { // index points to desired lane
          p = ix * elementsize;
        }
        for ( j = 0; j < elementsize; j++ ) { // loop through bytes in element
          u.a[k++] = p < 0 ? -1 : p + j;      // store byte permutation index
        }
        m++;
      }
    }
    return u; // return encapsulated array
  }

zero_mask()

template<int N>

auto zero_mask ( int const (&) a[N] )

constexpr

Definition at line 486 of file instrset.h.

                                                  {
    uint64_t mask = 0;
    int      i    = 0;
 
    for ( i = 0; i < N; i++ ) {
      if ( a[i] >= 0 ) mask |= uint64_t( 1 ) << i;
    }
    if constexpr ( N <= 8 )
      return uint8_t( mask );
    else if constexpr ( N <= 16 )
      return uint16_t( mask );
    else if constexpr ( N <= 32 )
      return uint32_t( mask );
    else
      return mask;
  }

zero_mask_broad()

template<typename V>

auto zero_mask_broad ( int const (&) A[V::size()] )

constexpr

Definition at line 506 of file instrset.h.

                                                              {
    constexpr int                        N = V::size(); // number of vector elements
    typedef decltype( get_inttype<V>() ) Etype;         // element type
    EList<Etype, N>                      u = { { 0 } }; // list for return
    int                                  i = 0;
    for ( i = 0; i < N; i++ ) { u.a[i] = A[i] >= 0 ? get_inttype<V>() : 0; }
    return u; // return encapsulated array
  }

Variable Documentation

blend_a

const int blend_a = 0x10

Definition at line 1017 of file instrset.h.

blend_addz

const int blend_addz = 8

Definition at line 1016 of file instrset.h.

blend_allzero

const int blend_allzero = 2

Definition at line 1014 of file instrset.h.

blend_b

const int blend_b = 0x20

Definition at line 1018 of file instrset.h.

blend_cross_lane

const int blend_cross_lane = 0x100

Definition at line 1021 of file instrset.h.

blend_largeblock

const int blend_largeblock = 4

Definition at line 1015 of file instrset.h.

blend_outofrange

const int blend_outofrange = 0x10000000

Definition at line 1032 of file instrset.h.

blend_perma

const int blend_perma = 0x40

Definition at line 1019 of file instrset.h.

blend_permb

const int blend_permb = 0x80

Definition at line 1020 of file instrset.h.

blend_punpckhab

const int blend_punpckhab = 0x1000

Definition at line 1023 of file instrset.h.

blend_punpckhba

const int blend_punpckhba = 0x2000

Definition at line 1024 of file instrset.h.

blend_punpcklab

const int blend_punpcklab = 0x4000

Definition at line 1025 of file instrset.h.

blend_punpcklba

const int blend_punpcklba = 0x8000

Definition at line 1026 of file instrset.h.

blend_rotate_big

const int blend_rotate_big = 0x100000

Definition at line 1031 of file instrset.h.

blend_rotateab

const int blend_rotateab = 0x10000

Definition at line 1027 of file instrset.h.

blend_rotateba

const int blend_rotateba = 0x20000

Definition at line 1028 of file instrset.h.

blend_rotpattern

const int blend_rotpattern = 40

Definition at line 1034 of file instrset.h.

blend_same_pattern

const int blend_same_pattern = 0x200

Definition at line 1022 of file instrset.h.

blend_shufab

const int blend_shufab = 0x40000

Definition at line 1029 of file instrset.h.

blend_shufba

const int blend_shufba = 0x80000

Definition at line 1030 of file instrset.h.

blend_shufpattern

const int blend_shufpattern = 32

Definition at line 1033 of file instrset.h.

blend_zeroing

const int blend_zeroing = 1

Definition at line 1013 of file instrset.h.

perm_addz

const int perm_addz = 0x10

Definition at line 579 of file instrset.h.

perm_addz2

const int perm_addz2 = 0x20

Definition at line 580 of file instrset.h.

perm_allzero

const int perm_allzero = 4

Definition at line 577 of file instrset.h.

perm_broadcast

const int perm_broadcast = 0x8000

Definition at line 593 of file instrset.h.

perm_compress

const int perm_compress = 0x20000

Definition at line 595 of file instrset.h.

perm_cross_lane

const int perm_cross_lane = 0x40

Definition at line 581 of file instrset.h.

perm_expand

const int perm_expand = 0x40000

Definition at line 596 of file instrset.h.

perm_ipattern

const int perm_ipattern

Initial value:

=
      40

Definition at line 599 of file instrset.h.

perm_largeblock

const int perm_largeblock = 8

Definition at line 578 of file instrset.h.

perm_outofrange

const int perm_outofrange = 0x10000000

Definition at line 597 of file instrset.h.

perm_perm

const int perm_perm = 2

Definition at line 576 of file instrset.h.

perm_punpckh

const int perm_punpckh = 0x100

Definition at line 583 of file instrset.h.

perm_punpckl

const int perm_punpckl = 0x200

Definition at line 584 of file instrset.h.

perm_rot_count

const int perm_rot_count = 32

Definition at line 598 of file instrset.h.

perm_rotate

const int perm_rotate

Initial value:

=
      0x400

Definition at line 585 of file instrset.h.

perm_rotate_big

const int perm_rotate_big

Initial value:

=
      0x4000

Definition at line 591 of file instrset.h.

perm_same_pattern

const int perm_same_pattern = 0x80

Definition at line 582 of file instrset.h.

perm_shleft

const int perm_shleft

Initial value:

=
      0x2000

Definition at line 589 of file instrset.h.

perm_shright

const int perm_shright

Initial value:

=
      0x1000

Definition at line 587 of file instrset.h.

perm_zeroing

const int perm_zeroing = 1

Definition at line 575 of file instrset.h.

perm_zext

const int perm_zext = 0x10000

Definition at line 594 of file instrset.h.

V_DC

int V_DC = -256

constexpr

Definition at line 219 of file instrset.h.