├── .gitignore
├── LICENSE
├── README.md
├── examples
    ├── simple.nim
    └── simplex_noise.nim
├── nimsimd.nimble
└── src
    ├── nimsimd.nim
    └── nimsimd
        ├── avx.nim
        ├── avx2.nim
        ├── mmx.nim
        ├── sse.nim
        └── sse2.nim


/.gitignore:
--------------------------------------------------------------------------------
1 | *.exe
2 | nimcache/
3 | bin/


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2017 Jack Mott
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # nim_simd
 2 | 
 3 | This is an experiment / proof of concept to use Nim's metaprogramming to provide an easy to use SIMD abstraction layer. 
 4 | The goal is for users of the library to be able to write blocks of code containing SIMD intrinsics *one time* and end up with optimum
 5 | or near optimum SIMD instructions being used at runtime according to the users hardware. If you are interested in this, you may be interested in my other Rust library, which is a more complete version of the same idea: [SIMDeez](https://github.com/jackmott/simdeez)
 6 | 
 7 | How this will work:
 8 | 
 9 | * The user will write a block of code containing SIMD intrinsics using the `simd:` macro
10 | * At *compile time* the macro will produce all desired simd versions of the block.  sse, sse2, avx, and so on
11 | * At *run time* the simd instructions available on the computer will be detected, and the appropriate version of the code block will be executed
12 | 
13 | # Progress So Far:
14 | 
15 | See simd.nim for the proof of concept so far.  Already you can write code like this successfully:
16 | 
17 | ```nim
18 | var
19 |     a = newSeq[float32](12)
20 |     b = newSeq[float32](12)
21 |     r = newSeq[float32](12)
22 | 
23 | for i,v in a:
24 |     a[i] = float32(i)
25 |     b[i] = 2.0'f32
26 | 
27 | 
28 | SIMD:     
29 |     for i in countup(0,<a.len,simd.width div 4):
30 |         let av = simd.loadu_ps(addr a[i])
31 |         let bv = simd.loadu_ps(addr b[i])
32 |         let rv = simd.add_ps(av,bv)
33 |         simd.storeu_ps(addr r[i],rv)
34 | 
35 | echo a
36 | echo b
37 | echo r
38 | 
39 | ```
40 | 
41 | # Goals / Todo
42 | 
43 | * Newer SIMD instruction sets include functions with no counterpart in older instruction sets.  Optimally performing fallbacks will need to be crafted for each case. For instance
44 | a call to a blend instruction on SSE2 would need to be converted to  Or(AndNot(z,x), And(z,y)).  In some cases fallbacks may be degenerate or impossible. Compiler warnings? Errors?
45 | * The ability to loop over arrays of a given type should be made as simple as possible. We should provide some abstraction via the macro such that you can do something like `for i,v in myArray` and
46 | it will convert to iterate over the array at the appropriate stride length. Perhaps doing the loads automatically.  But I would like to give the user as much control as possible for performance.
47 | * Runtime cost needs to be kept very near 0. The whole point of SIMD is to extract as much performance as possible from the hardware
48 | 
49 | # Help Needed
50 | 
51 | I would love help with this, I am slowly learning Nim meta programming, so anyone who can help with that aspect, or who can help with SIMD issues would be appreciated. Feel free to jump in.
52 | 


--------------------------------------------------------------------------------
/examples/simple.nim:
--------------------------------------------------------------------------------
 1 | import ../src/nimsimd
 2 | import ../src/nimsimd/sse2
 3 | import ../src/nimsimd/avx2
 4 | 
 5 | var
 6 |     a = newSeq[float32](16)            
 7 |     b = newSeq[float32](16)
 8 |     r = newSeq[float32](16)
 9 | 
10 | for i,v in a:
11 |     a[i] = float32(i)            
12 |     b[i] = float32(i*2)
13 | 
14 | SIMD:
15 |     echo "SIMD lane width in bytes:" & $simd.width    
16 |     for i in countup(0,pred(a.len),simd.width div 4):    
17 |         var av = simd.loadu_ps(addr a[i])    
18 |         var bv = simd.loadu_ps(addr b[i])
19 |         var rv = simd.add_ps(av,bv)   
20 |         simd.storeu_ps(addr r[i],rv)
21 | 
22 | echo "A + B = R"
23 | echo a        
24 | echo b
25 | echo r
26 | 


--------------------------------------------------------------------------------
/examples/simplex_noise.nim:
--------------------------------------------------------------------------------
  1 | import ../src/nimsimd
  2 | import ../src/nimsimd/sse2
  3 | import ../src/nimsimd/avx2
  4 | 
  5 | # !!! Not working yet !!!
  6 | 
  7 | var gradX = [
  8 |     1'f32,-1'f32, 1'f32,-1'f32,
  9 |     1'f32,-1'f32, 1'f32,-1'f32,
 10 |     0'f32, 0'f32, 0'f32, 0'f32]    
 11 | 
 12 | var gradY = [    
 13 |     1'f32, 1'f32,-1'f32,-1'f32,
 14 |     0'f32, 0'f32, 0'f32, 0'f32,
 15 |     1'f32,-1'f32, 1'f32,-1'f32]
 16 | 
 17 | 
 18 | var gradZ = [    
 19 |     0'f32, 0'f32, 0'f32, 0'f32,
 20 |     1'f32, 1'f32,-1'f32,-1'f32,
 21 |     1'f32, 1'f32,-1'f32,-1'f32]
 22 | 
 23 | var perm = [        
 24 |     151'i32,160'i32,137'i32,91'i32,90'i32,15'i32,
 25 |     131'i32,13'i32,201'i32,95'i32,96'i32,53'i32,194'i32,233'i32,7'i32,225'i32,140'i32,36'i32,103'i32,30'i32,69'i32,142'i32,8'i32,99'i32,37'i32,240'i32,21'i32,10'i32,23'i32,
 26 |     190'i32, 6'i32,148'i32,247'i32,120'i32,234'i32,75'i32,0'i32,26'i32,197'i32,62'i32,94'i32,252'i32,219'i32,203'i32,117'i32,35'i32,11'i32,32'i32,57'i32,177'i32,33'i32,
 27 |     88'i32,237'i32,149'i32,56'i32,87'i32,174'i32,20'i32,125'i32,136'i32,171'i32,168'i32, 68'i32,175'i32,74'i32,165'i32,71'i32,134'i32,139'i32,48'i32,27'i32,166'i32,
 28 |     77'i32,146'i32,158'i32,231'i32,83'i32,111'i32,229'i32,122'i32,60'i32,211'i32,133'i32,230'i32,220'i32,105'i32,92'i32,41'i32,55'i32,46'i32,245'i32,40'i32,244'i32,
 29 |     102'i32,143'i32,54'i32, 65'i32,25'i32,63'i32,161'i32, 1'i32,216'i32,80'i32,73'i32,209'i32,76'i32,132'i32,187'i32,208'i32, 89'i32,18'i32,169'i32,200'i32,196'i32,
 30 |     135'i32,130'i32,116'i32,188'i32,159'i32,86'i32,164'i32,100'i32,109'i32,198'i32,173'i32,186'i32, 3'i32,64'i32,52'i32,217'i32,226'i32,250'i32,124'i32,123'i32,
 31 |     5'i32,202'i32,38'i32,147'i32,118'i32,126'i32,255'i32,82'i32,85'i32,212'i32,207'i32,206'i32,59'i32,227'i32,47'i32,16'i32,58'i32,17'i32,182'i32,189'i32,28'i32,42'i32,
 32 |     223'i32,183'i32,170'i32,213'i32,119'i32,248'i32,152'i32, 2'i32,44'i32,154'i32,163'i32, 70'i32,221'i32,153'i32,101'i32,155'i32,167'i32, 43'i32,172'i32,9'i32,
 33 |     129'i32,22'i32,39'i32,253'i32, 19'i32,98'i32,108'i32,110'i32,79'i32,113'i32,224'i32,232'i32,178'i32,185'i32, 112'i32,104'i32,218'i32,246'i32,97'i32,228'i32,
 34 |     251'i32,34'i32,242'i32,193'i32,238'i32,210'i32,144'i32,12'i32,191'i32,179'i32,162'i32,241'i32, 81'i32,51'i32,145'i32,235'i32,249'i32,14'i32,239'i32,107'i32,
 35 |     49'i32,192'i32,214'i32, 31'i32,181'i32,199'i32,106'i32,157'i32,184'i32, 84'i32,204'i32,176'i32,115'i32,121'i32,50'i32,45'i32,127'i32, 4'i32,150'i32,254'i32,
 36 |     138'i32,236'i32,205'i32,93'i32,222'i32,114'i32,67'i32,29'i32,24'i32,72'i32,243'i32,141'i32,128'i32,195'i32,78'i32,66'i32,215'i32,61'i32,156'i32,180'i32,
 37 |     151'i32,160'i32,137'i32,91'i32,90'i32,15'i32,
 38 |     131'i32,13'i32,201'i32,95'i32,96'i32,53'i32,194'i32,233'i32,7'i32,225'i32,140'i32,36'i32,103'i32,30'i32,69'i32,142'i32,8'i32,99'i32,37'i32,240'i32,21'i32,10'i32,23'i32,
 39 |     190'i32, 6'i32,148'i32,247'i32,120'i32,234'i32,75'i32,0'i32,26'i32,197'i32,62'i32,94'i32,252'i32,219'i32,203'i32,117'i32,35'i32,11'i32,32'i32,57'i32,177'i32,33'i32,
 40 |     88'i32,237'i32,149'i32,56'i32,87'i32,174'i32,20'i32,125'i32,136'i32,171'i32,168'i32, 68'i32,175'i32,74'i32,165'i32,71'i32,134'i32,139'i32,48'i32,27'i32,166'i32,
 41 |     77'i32,146'i32,158'i32,231'i32,83'i32,111'i32,229'i32,122'i32,60'i32,211'i32,133'i32,230'i32,220'i32,105'i32,92'i32,41'i32,55'i32,46'i32,245'i32,40'i32,244'i32,
 42 |     102'i32,143'i32,54'i32, 65'i32,25'i32,63'i32,161'i32, 1'i32,216'i32,80'i32,73'i32,209'i32,76'i32,132'i32,187'i32,208'i32, 89'i32,18'i32,169'i32,200'i32,196'i32,
 43 |     135'i32,130'i32,116'i32,188'i32,159'i32,86'i32,164'i32,100'i32,109'i32,198'i32,173'i32,186'i32, 3'i32,64'i32,52'i32,217'i32,226'i32,250'i32,124'i32,123'i32,
 44 |     5'i32,202'i32,38'i32,147'i32,118'i32,126'i32,255'i32,82'i32,85'i32,212'i32,207'i32,206'i32,59'i32,227'i32,47'i32,16'i32,58'i32,17'i32,182'i32,189'i32,28'i32,42'i32,
 45 |     223'i32,183'i32,170'i32,213'i32,119'i32,248'i32,152'i32, 2'i32,44'i32,154'i32,163'i32, 70'i32,221'i32,153'i32,101'i32,155'i32,167'i32, 43'i32,172'i32,9'i32,
 46 |     129'i32,22'i32,39'i32,253'i32, 19'i32,98'i32,108'i32,110'i32,79'i32,113'i32,224'i32,232'i32,178'i32,185'i32, 112'i32,104'i32,218'i32,246'i32,97'i32,228'i32,
 47 |     251'i32,34'i32,242'i32,193'i32,238'i32,210'i32,144'i32,12'i32,191'i32,179'i32,162'i32,241'i32, 81'i32,51'i32,145'i32,235'i32,249'i32,14'i32,239'i32,107'i32,
 48 |     49'i32,192'i32,214'i32, 31'i32,181'i32,199'i32,106'i32,157'i32,184'i32, 84'i32,204'i32,176'i32,115'i32,121'i32,50'i32,45'i32,127'i32, 4'i32,150'i32,254'i32,
 49 |     138'i32,236'i32,205'i32,93'i32,222'i32,114'i32,67'i32,29'i32,24'i32,72'i32,243'i32,141'i32,128'i32,195'i32,78'i32,66'i32,215'i32,61'i32,156'i32,180'i32]
 50 | 
 51 | var permMOD12 = [        
 52 |     7'i32, 4'i32, 5'i32, 7'i32, 6'i32, 3'i32, 11'i32, 1'i32, 9'i32, 11'i32, 0'i32, 5'i32, 2'i32, 5'i32, 7'i32, 9'i32, 8'i32, 0'i32, 7'i32, 6'i32, 9'i32, 10'i32, 8'i32, 3'i32,
 53 |     1'i32, 0'i32, 9'i32, 10'i32, 11'i32, 10'i32, 6'i32, 4'i32, 7'i32, 0'i32, 6'i32, 3'i32, 0'i32, 2'i32, 5'i32, 2'i32, 10'i32, 0'i32, 3'i32, 11'i32, 9'i32, 11'i32, 11'i32,
 54 |     8'i32, 9'i32, 9'i32, 9'i32, 4'i32, 9'i32, 5'i32, 8'i32, 3'i32, 6'i32, 8'i32, 5'i32, 4'i32, 3'i32, 0'i32, 8'i32, 7'i32, 2'i32, 9'i32, 11'i32, 2'i32, 7'i32, 0'i32, 3'i32, 10'i32,
 55 |     5'i32, 2'i32, 2'i32, 3'i32, 11'i32, 3'i32, 1'i32, 2'i32, 0'i32, 7'i32, 1'i32, 2'i32, 4'i32, 9'i32, 8'i32, 5'i32, 7'i32, 10'i32, 5'i32, 4'i32, 4'i32, 6'i32, 11'i32, 6'i32,
 56 |     5'i32, 1'i32, 3'i32, 5'i32, 1'i32, 0'i32, 8'i32, 1'i32, 5'i32, 4'i32, 0'i32, 7'i32, 4'i32, 5'i32, 6'i32, 1'i32, 8'i32, 4'i32, 3'i32, 10'i32, 8'i32, 8'i32, 3'i32, 2'i32, 8'i32,
 57 |     4'i32, 1'i32, 6'i32, 5'i32, 6'i32, 3'i32, 4'i32, 4'i32, 1'i32, 10'i32, 10'i32, 4'i32, 3'i32, 5'i32, 10'i32, 2'i32, 3'i32, 10'i32, 6'i32, 3'i32, 10'i32, 1'i32, 8'i32, 3'i32,
 58 |     2'i32, 11'i32, 11'i32, 11'i32, 4'i32, 10'i32, 5'i32, 2'i32, 9'i32, 4'i32, 6'i32, 7'i32, 3'i32, 2'i32, 9'i32, 11'i32, 8'i32, 8'i32, 2'i32, 8'i32, 10'i32, 7'i32, 10'i32, 5'i32,
 59 |     9'i32, 5'i32, 11'i32, 11'i32, 7'i32, 4'i32, 9'i32, 9'i32, 10'i32, 3'i32, 1'i32, 7'i32, 2'i32, 0'i32, 2'i32, 7'i32, 5'i32, 8'i32, 4'i32, 10'i32, 5'i32, 4'i32, 8'i32, 2'i32, 6'i32,
 60 |     1'i32, 0'i32, 11'i32, 10'i32, 2'i32, 1'i32, 10'i32, 6'i32, 0'i32, 0'i32, 11'i32, 11'i32, 6'i32, 1'i32, 9'i32, 3'i32, 1'i32, 7'i32, 9'i32, 2'i32, 11'i32, 11'i32, 1'i32, 0'i32,
 61 |     10'i32, 7'i32, 1'i32, 7'i32, 10'i32, 1'i32, 4'i32, 0'i32, 0'i32, 8'i32, 7'i32, 1'i32, 2'i32, 9'i32, 7'i32, 4'i32, 6'i32, 2'i32, 6'i32, 8'i32, 1'i32, 9'i32, 6'i32, 6'i32, 7'i32, 5'i32,
 62 |     0'i32, 0'i32, 3'i32, 9'i32, 8'i32, 3'i32, 6'i32, 6'i32, 11'i32, 1'i32, 0'i32, 0'i32,
 63 |     7'i32, 4'i32, 5'i32, 7'i32, 6'i32, 3'i32, 11'i32, 1'i32, 9'i32, 11'i32, 0'i32, 5'i32, 2'i32, 5'i32, 7'i32, 9'i32, 8'i32, 0'i32, 7'i32, 6'i32, 9'i32, 10'i32, 8'i32, 3'i32,
 64 |     1'i32, 0'i32, 9'i32, 10'i32, 11'i32, 10'i32, 6'i32, 4'i32, 7'i32, 0'i32, 6'i32, 3'i32, 0'i32, 2'i32, 5'i32, 2'i32, 10'i32, 0'i32, 3'i32, 11'i32, 9'i32, 11'i32, 11'i32,
 65 |     8'i32, 9'i32, 9'i32, 9'i32, 4'i32, 9'i32, 5'i32, 8'i32, 3'i32, 6'i32, 8'i32, 5'i32, 4'i32, 3'i32, 0'i32, 8'i32, 7'i32, 2'i32, 9'i32, 11'i32, 2'i32, 7'i32, 0'i32, 3'i32, 10'i32,
 66 |     5'i32, 2'i32, 2'i32, 3'i32, 11'i32, 3'i32, 1'i32, 2'i32, 0'i32, 7'i32, 1'i32, 2'i32, 4'i32, 9'i32, 8'i32, 5'i32, 7'i32, 10'i32, 5'i32, 4'i32, 4'i32, 6'i32, 11'i32, 6'i32,
 67 |     5'i32, 1'i32, 3'i32, 5'i32, 1'i32, 0'i32, 8'i32, 1'i32, 5'i32, 4'i32, 0'i32, 7'i32, 4'i32, 5'i32, 6'i32, 1'i32, 8'i32, 4'i32, 3'i32, 10'i32, 8'i32, 8'i32, 3'i32, 2'i32, 8'i32,
 68 |     4'i32, 1'i32, 6'i32, 5'i32, 6'i32, 3'i32, 4'i32, 4'i32, 1'i32, 10'i32, 10'i32, 4'i32, 3'i32, 5'i32, 10'i32, 2'i32, 3'i32, 10'i32, 6'i32, 3'i32, 10'i32, 1'i32, 8'i32, 3'i32,
 69 |     2'i32, 11'i32, 11'i32, 11'i32, 4'i32, 10'i32, 5'i32, 2'i32, 9'i32, 4'i32, 6'i32, 7'i32, 3'i32, 2'i32, 9'i32, 11'i32, 8'i32, 8'i32, 2'i32, 8'i32, 10'i32, 7'i32, 10'i32, 5'i32,
 70 |     9'i32, 5'i32, 11'i32, 11'i32, 7'i32, 4'i32, 9'i32, 9'i32, 10'i32, 3'i32, 1'i32, 7'i32, 2'i32, 0'i32, 2'i32, 7'i32, 5'i32, 8'i32, 4'i32, 10'i32, 5'i32, 4'i32, 8'i32, 2'i32, 6'i32,
 71 |     1'i32, 0'i32, 11'i32, 10'i32, 2'i32, 1'i32, 10'i32, 6'i32, 0'i32, 0'i32, 11'i32, 11'i32, 6'i32, 1'i32, 9'i32, 3'i32, 1'i32, 7'i32, 9'i32, 2'i32, 11'i32, 11'i32, 1'i32, 0'i32,
 72 |     10'i32, 7'i32, 1'i32, 7'i32, 10'i32, 1'i32, 4'i32, 0'i32, 0'i32, 8'i32, 7'i32, 1'i32, 2'i32, 9'i32, 7'i32, 4'i32, 6'i32, 2'i32, 6'i32, 8'i32, 1'i32, 9'i32, 6'i32, 6'i32, 7'i32, 5'i32,
 73 |     0'i32, 0'i32, 3'i32, 9'i32, 8'i32, 3'i32, 6'i32, 6'i32, 11'i32, 1'i32, 0'i32, 0'i32
 74 | ]
 75 | 
 76 | SIMD:
 77 |     let F3 = simd.set1_ps(1.0'f32/3.0'f32)    
 78 |     let G3 = simd.set1_ps(1.0'f32 / 6.0'f32)
 79 |     let G32 = simd.set1_ps((1.0'f32 / 6.0'f32) * 2.0'f32)
 80 |     let G33 = simd.set1_ps((1.0'f32 / 6.0'f32) * 3.0'f32)
 81 |     let ONE = simd.set1_epi32(1)
 82 |     let FF = simd.set1_epi32(0xff)
 83 |     let ONEF = simd.set1_ps(1.0'f32)
 84 |     let PSIX = simd.set1_ps(0.6'f32)
 85 |     let ZERO = simd.set1_ps(0'f32)
 86 |     let THIRTY_TWO = simd.set1_ps(32.0'f32)
 87 | 
 88 |     proc dotSIMD(x1,y1,z1,x2,y2,z2: var simd.mf32) : simd.mf32 =         
 89 |         let xx = simd.mul_ps(x1, x2)
 90 |         let yy = simd.mul_ps(y1, y2)
 91 |         let zz = simd.mul_ps(z1, z2)           
 92 |         return simd.add_ps(xx,simd.add_ps(yy,zz))
 93 |         
 94 |                                                                 
 95 |     proc simplexNoise(x,y,z: var simd.mf32) : simd.mf32 = 
 96 |         echo "a"
 97 |         let s = simd.mul_ps(F3,simd.add_ps(x,simd.add_ps(y,z)))
 98 |         let i = simd.floor_ps_epi32(simd.add_ps(x,s))
 99 |         let j = simd.floor_ps_epi32(simd.add_ps(y,s))
100 |         let k = simd.floor_ps_epi32(simd.add_ps(z,s))
101 |      
102 |         echo "b"
103 |         let t = simd.mul_ps(simd.cvtepi32_ps(simd.add_epi32(i,simd.add_epi32(j,k))),G3)
104 |         let X0 = simd.sub_ps(simd.cvtepi32_ps(i),t)
105 |         let Y0 = simd.sub_ps(simd.cvtepi32_ps(j),t)
106 |         let Z0 = simd.sub_ps(simd.cvtepi32_ps(k),t)
107 |         var x0 = simd.sub_ps(x,X0)
108 |         var y0 = simd.sub_ps(y,Y0)
109 |         var z0 = simd.sub_ps(z,Z0) 
110 | 
111 |         echo "b"
112 |         let i1 = simd.and_si(ONE,simd.and_si(simd.castps_si(simd.cmpge_ps(x0,y0)),simd.castps_si(simd.cmpge_ps(x0,z0))))
113 |         let j1 = simd.and_si(ONE,simd.and_si(simd.castps_si(simd.cmpgt_ps(y0,x0)),simd.castps_si(simd.cmpgt_ps(y0,z0))))
114 |         let k1 = simd.and_si(ONE,simd.and_si(simd.castps_si(simd.cmpgt_ps(z0,x0)),simd.castps_si(simd.cmpgt_ps(z0,y0))))
115 | 
116 |         echo "c"
117 |         let yx_xz = simd.and_si(simd.castps_si(simd.cmpge_ps(x0,y0)),simd.castps_si(simd.cmplt_ps(x0,z0)))
118 |         let zx_xy = simd.and_si(simd.castps_si(simd.cmpge_ps(x0,z0)),simd.castps_si(simd.cmplt_ps(x0,y0)))
119 | 
120 |         let xy_yz = simd.and_si(simd.castps_si(simd.cmplt_ps(x0,y0)),simd.castps_si(simd.cmplt_ps(y0,z0)))
121 |         let zy_yx = simd.and_si(simd.castps_si(simd.cmpge_ps(y0,z0)),simd.castps_si(simd.cmpge_ps(x0,y0)))
122 | 
123 |         let yz_zx = simd.and_si(simd.castps_si(simd.cmplt_ps(y0,z0)),simd.castps_si(simd.cmpge_ps(x0,z0)))
124 |         let xz_zy = simd.and_si(simd.castps_si(simd.cmplt_ps(x0,z0)),simd.castps_si(simd.cmpge_ps(y0,z0)))
125 | 
126 |         let i2 = simd.and_si(ONE,simd.or_si(i1,simd.or_si(yx_xz,zx_xy)))
127 |         let j2 = simd.and_si(ONE,simd.or_si(j1,simd.or_si(xy_yz,zy_yx)))
128 |         let k2 = simd.and_si(ONE,simd.or_si(k1,simd.or_si(yz_zx,xz_zy)))
129 | 
130 |         var x1 = simd.add_ps(simd.sub_ps(x0,simd.cvtepi32_ps(i1)),G3)
131 |         var y1 = simd.add_ps(simd.sub_ps(y0,simd.cvtepi32_ps(j1)),G3)
132 |         var z1 = simd.add_ps(simd.sub_ps(z0,simd.cvtepi32_ps(k1)),G3)
133 |         var x2 = simd.add_ps(simd.sub_ps(x0,simd.cvtepi32_ps(i2)),G32)
134 |         var y2 = simd.add_ps(simd.sub_ps(y0,simd.cvtepi32_ps(j2)),G32)
135 |         var z2 = simd.add_ps(simd.sub_ps(z0,simd.cvtepi32_ps(k2)),G32)
136 |         var x3 = simd.add_ps(simd.sub_ps(x0,ONEF),G33)
137 |         var y3 = simd.add_ps(simd.sub_ps(y0,ONEF),G33)
138 |         var z3 = simd.add_ps(simd.sub_ps(z0,ONEF),G33)
139 | 
140 |         let ii = simd.and_si(i,FF)
141 |         let jj = simd.and_si(j,FF)
142 |         let kk = simd.and_si(k,FF) 
143 |          
144 |         let pkk = simd.i32gather_epi32(perm[0].unsafeAddr,kk,4)
145 |         let pkkk1 = simd.i32gather_epi32(perm[0].unsafeAddr,simd.add_epi32(kk,k1),4)
146 |         let pkkk2 = simd.i32gather_Epi32(perm[0].unsafeAddr,simd.add_epi32(kk,k2),4)
147 |         let pkk1 = simd.i32gather_epi32(perm[0].unsafeAddr,simd.add_epi32(kk,ONE),4)
148 | 
149 |         let pjj = simd.i32gather_epi32(perm[0].unsafeAddr,simd.add_epi32(jj,pkk),4)
150 |         let pjjj1 = simd.i32gather_epi32(perm[0].unsafeAddr,simd.add_epi32(jj,simd.add_epi32(j1,pkkk1)),4)
151 |         let pjjj2 = simd.i32gather_epi32(perm[0].unsafeAddr,simd.add_epi32(jj,simd.add_epi32(j2,pkkk2)),4)
152 |         let pjj1 = simd.i32gather_epi32(perm[0].unsafeAddr,simd.add_epi32(jj,simd.add_epi32(ONE,pkk1)),4)
153 | 
154 |         let gi0 = simd.i32gather_epi32(permMOD12[0].unsafeAddr,simd.add_epi32(ii,pjj),4)
155 |         let gi1 = simd.i32gather_epi32(permMOD12[0].unsafeAddr,simd.add_epi32(i1,simd.add_epi32(ii,pjjj1)),4)
156 |         let gi2 = simd.i32gather_epi32(permMOD12[0].unsafeAddr,simd.add_epi32(i2,simd.add_epi32(ii,pjjj2)),4)
157 |         let gi3 = simd.i32gather_epi32(permMOD12[0].unsafeAddr,simd.add_epi32(ONE,simd.add_epi32(ii,pjj1)),4)
158 | 
159 |         var gi0x = simd.i32gather_ps(gradX[0].unsafeAddr,gi0,4)
160 |         var gi0y = simd.i32gather_ps(gradY[0].unsafeAddr,gi0,4)
161 |         var gi0z = simd.i32gather_ps(gradZ[0].unsafeAddr,gi0,4)
162 | 
163 |         var gi1x = simd.i32gather_ps(gradX[0].unsafeAddr,gi1,4)
164 |         var gi1y = simd.i32gather_ps(gradY[0].unsafeAddr,gi1,4)
165 |         var gi1z = simd.i32gather_ps(gradZ[0].unsafeAddr,gi1,4)
166 | 
167 |         var gi2x = simd.i32gather_ps(gradX[0].unsafeAddr,gi2,4)
168 |         var gi2y = simd.i32gather_ps(gradY[0].unsafeAddr,gi2,4)
169 |         var gi2z = simd.i32gather_ps(gradZ[0].unsafeAddr,gi2,4)
170 | 
171 |         var gi3x = simd.i32gather_ps(gradX[0].unsafeAddr,gi3,4)
172 |         var gi3y = simd.i32gather_ps(gradY[0].unsafeAddr,gi3,4)
173 |         var gi3z = simd.i32gather_ps(gradZ[0].unsafeAddr,gi3,4)
174 | 
175 |         let t0 = simd.sub_ps(simd.sub_ps(simd.sub_ps(PSIX,simd.mul_ps(x0,x0)),simd.mul_ps(y0,y0)),simd.mul_ps(z0,z0))
176 |         let t1 = simd.sub_ps(simd.sub_ps(simd.sub_ps(PSIX,simd.mul_ps(x1,x1)),simd.mul_ps(y1,y1)),simd.mul_ps(z1,z1))
177 |         let t2 = simd.sub_ps(simd.sub_ps(simd.sub_ps(PSIX,simd.mul_ps(x2,x2)),simd.mul_ps(y2,y2)),simd.mul_ps(z2,z2))
178 |         let t3 = simd.sub_ps(simd.sub_ps(simd.sub_ps(PSIX,simd.mul_ps(x3,x3)),simd.mul_ps(y3,y3)),simd.mul_ps(z3,z3))
179 | 
180 |         var t0q = simd.mul_ps(t0,t0)
181 |         t0q = simd.mul_ps(t0q,t0q)
182 |         var t1q = simd.mul_ps(t1,t1)
183 |         t1q = simd.mul_ps(t1q,t1q) 
184 |         var t2q = simd.mul_ps(t2,t2)
185 |         t2q = simd.mul_ps(t2q,t2q)
186 |         var t3q = simd.mul_ps(t3,t3)
187 |         t3q = simd.mul_ps(t3q,t3q)
188 | 
189 |         echo "test"
190 |         var xxx = dotSIMD(gi0x,gi0y,gi0z,x0,y0,z0)
191 |         echo "end test"
192 |         var n0 = simd.mul_ps(t0q,dotSIMD(gi0x,gi0y,gi0z,x0,y0,z0))
193 |         var n1 = simd.mul_ps(t1q,dotSIMD(gi1x,gi1y,gi1z,x1,y1,z1))
194 |         var n2 = simd.mul_ps(t2q,dotSIMD(gi2x,gi2y,gi2z,x2,y2,z2))
195 |         var n3 = simd.mul_ps(t3q,dotSIMD(gi3x,gi3y,gi3z,x3,y3,z3))
196 | 
197 |         var cond = simd.cmplt_ps(t0,ZERO)
198 |         n0 = simd.blendv_ps(n0,ZERO,cond)  
199 |         cond = simd.cmplt_ps(t1,ZERO)
200 |         n1 = simd.blendv_ps(n1,ZERO,cond)
201 |         cond = simd.cmplt_ps(t2,ZERO)
202 |         n2 = simd.blendv_ps(n2,ZERO,cond)
203 |         cond = simd.cmplt_ps(t3,ZERO)
204 |         n3 = simd.blendv_ps(n3,ZERO,cond)
205 |         echo "z"
206 |         return simd.mul_ps(THIRTY_TWO,simd.add_ps(n0,simd.add_ps(n1,simd.add_ps(n2,n3))))
207 | 
208 |     
209 |               
210 | 


--------------------------------------------------------------------------------
/nimsimd.nimble:
--------------------------------------------------------------------------------
 1 | # Package
 2 | 
 3 | version       = "0.1.0"
 4 | author        = "Jack Mott"
 5 | description   = "simd library"
 6 | license       = "MIT"
 7 | srcDir        = "src"
 8 | 
 9 | 
10 | # Dependencies
11 | 
12 | 


--------------------------------------------------------------------------------
/src/nimsimd.nim:
--------------------------------------------------------------------------------
  1 | import nimsimd/mmx
  2 | import nimsimd/avx
  3 | import nimsimd/sse
  4 | import nimsimd/avx2
  5 | import nimsimd/sse2
  6 | import macros 
  7 | import rdstdin
  8 | 
  9 | proc cpuidex(cpuInfo:ptr int,function_id:cint,subfunction_id:cint)
 10 |     {.importc:"__cpuidex", header:"intrin.h"}
 11 | 
 12 | proc c_xgetbv(xcr:cuint) : uint64
 13 |     {.importc:"_xgetbv", header:"immintrin.h"}
 14 | 
 15 | 
 16 | when defined(vcc) or defined(icc) :
 17 |     proc cpuid(outarray:openarray[int32],functionNumber:int32) =
 18 |         cpuidex(cast[ptr int32](outarray[0].unsafeAddr),functionNumber.cint,0)
 19 |     
 20 | elif defined(gcc) or defined(clang):        
 21 |     proc cpuid(outarray:openarray[int32],functionNumber:int32) =
 22 |         {.emit:"""
 23 |             int a, b, c, d;
 24 |             __asm("cpuid" : "=a"(a), "=b"(b), "=c"(c), "=d"(d) : "a"(functionNumber), "c"(0) : );
 25 |             outarray[0] = a;
 26 |             outarray[1] = b;
 27 |             outarray[2] = c;
 28 |             outarray[3] = d;
 29 |         """.}    
 30 | 
 31 | else:     
 32 |     proc cpuid(outarray:openarray[int32],functionNumber:int32) =
 33 |         {.emit"""
 34 |             __asm
 35 |             {
 36 |                 mov eax, functionNumber
 37 |                 xor ecx, ecx
 38 |                 cpuid;
 39 |                 mov esi, outarray
 40 |                     mov[esi], eax
 41 |                     mov[esi + 4], ebx
 42 |                     mov[esi + 8], ecx
 43 |                     mov[esi + 12], edx
 44 |              }
 45 |         ."""}
 46 | 
 47 | 
 48 | when defined(vcc) or defined(icc):
 49 |     proc xgetbv(x:int) :int64 =
 50 |         return c_xgetbv(x)
 51 | elif defined(gcc) or defined(clang):
 52 |     proc xgetbv(x:int) :int64 =
 53 |         var a,d: uint32
 54 |         {.emit"""            
 55 |             __asm( "xgetbv" : "=a"(a), "=d"(d) : "c"(x) : );           
 56 |         """.}
 57 |         return (a.uint64() or (d.uint64() shl 32)).int64()
 58 | else:
 59 |     proc xgetbv(x:int) :int64 =
 60 |         var a,d: uint32
 61 |         {.emit"""            
 62 |             __asm {
 63 |                 mov ecx, ctr
 64 |                 _emit 0x0f
 65 |                 _emit 0x01
 66 |                 _emit 0xd0; // xgetbv
 67 |                 mov a, eax
 68 |                     mov d, edx
 69 |             }            
 70 |         """.}
 71 |         return (a.uint64() or (d.uint64() shl 32)).int64()
 72 | 
 73 | 
 74 | 
 75 | type CPU_TYPE = enum
 76 |         UNINITIALIZED,NO_SIMD,SSE2,SSE41,AVX2
 77 | 
 78 | var cpuType = UNINITIALIZED
 79 | 
 80 | proc getCPUType() : CPU_TYPE =
 81 |     
 82 |     var cpuInfo = newSeq[int32](4)
 83 |     cpuid(cpuInfo,0)
 84 |     let nIds = cpuInfo[0]
 85 | 
 86 |     if nIds == 0:
 87 |         return NO_SIMD
 88 |     
 89 |     cpuid(cpuInfo,1)
 90 | 
 91 |     if (cpuInfo[3] and (1 shl 0)) == 0:
 92 |         return NO_SIMD
 93 |     if (cpuInfo[3] and (1 shl 23)) == 0:
 94 |         return NO_SIMD
 95 |     if (cpuInfo[3] and (1 shl 15)) == 0:
 96 |         return NO_SIMD
 97 |     if (cpuInfo[3] and (1 shl 24)) == 0:
 98 |         return NO_SIMD
 99 |     if (cpuInfo[3] and (1 shl 25)) == 0:
100 |         return NO_SIMD
101 |     if (cpuInfo[3] and (1 shl 26)) == 0:
102 |         return NO_SIMD  #actually has SSE be we only support SSE2 and up for now
103 | 
104 |     
105 | 
106 |     if (cpuInfo[2] and (1 shl 0)) == 0:
107 |         return SSE2
108 | 
109 |     if (cpuInfo[2] and (1 shl 9)) == 0:
110 |         return SSE2  #actually ahs SSE3 but we are not that granular for now
111 |     if (cpuInfo[2] and (1 shl 19)) == 0:
112 |         return SSE2  #actually ahs SSSE3 but we are not that granular for now
113 | 
114 |     if (cpuInfo[2] and (1 shl 23)) == 0:
115 |         return SSE41  #no popcount
116 |     if (cpuInfo[2] and (1 shl 20)) == 0:
117 |         return SSE41 #no sse4.2
118 |     
119 |     if (cpuInfo[2] and (1 shl 26)) == 0:
120 |         return SSE41  #actually ahs SSE42 but we are not that granular for now
121 |     if (cpuInfo[2] and (1 shl 27)) == 0:
122 |         return SSE41  #actually ahs SSE42 but we are not that granular for now
123 |     if (cpuInfo[2] and (1 shl 28)) == 0:
124 |         return SSE41  #actually ahs SSE42 but we are not that granular for now
125 |         
126 |     if (xgetbv(0) and 6) != 6:
127 |         return SSE41 #AVX not enabled in OS
128 | 
129 | 
130 |     cpuid(cpuInfo,7)
131 |     if (cpuInfo[1] and (1 shl 5)) == 0:
132 |         return SSE41 #actually avx but we are not that granual yet
133 |     
134 |     return AVX2
135 | 
136 |     
137 |    
138 | 
139 | 
140 | proc replaceSIMD(rootNode:NimNode, simdType:string, vectorSize:string) =           
141 |     var simdIdent = toNimIdent("simd")
142 |     var simdTypeIdent = toNimIdent(simdType)
143 |     for node in rootNode.children:
144 |         #echo $node.kind
145 |         if node.kind == nnkIdent:
146 |            #echo $node.ident
147 |            if node.ident == simdIdent:
148 |                 node.ident = simdTypeIdent
149 |                 break  #only want to check for ident simd on first ident
150 |         replaceSIMD(node,simdType,vectorsize)
151 | 
152 | macro SIMD_AVX2(body:untyped): untyped =            
153 |     replaceSIMD(body,"avx2","256")
154 |     body
155 | 
156 | macro SIMD_SSE2(body:untyped): untyped =            
157 |     replaceSIMD(body,"sse2","128")
158 |     body
159 | 
160 | 
161 | # width will be replaced with the width of the SIMD vector in bytes
162 | template SIMD*(body:untyped) =
163 |                     
164 |     if cpuType == UNINITIALIZED:
165 |         cpuType = getCPUType()
166 |         echo "Detected cpu type:" & $cpuType        
167 |              
168 |     # instead of calling different macros, is there a way to pass the string?
169 |     # I tried this and got odd compile errors
170 |     if cpuType == SSE2:    
171 |         SIMD_SSE2(body)
172 |     elif cpuType == AVX2:        
173 |         SIMD_AVX2(body)
174 | 
175 | 


--------------------------------------------------------------------------------
/src/nimsimd/avx.nim:
--------------------------------------------------------------------------------
  1 | #
  2 | #
  3 | #          Nimrod's x86 avx intrinsics
  4 | #        (c) Copyright 2014 Ben Segovia
  5 | #
  6 | #    See the file copying.txt, included in this
  7 | #    distribution, for details about the copyright.
  8 | #
  9 | #
 10 | import sse
 11 | when someGcc:
 12 |   {.passC: "-msse3 -mssse3 -msse4 -mavx".}
 13 |   {.passL: "-msse3 -mssse3 -msse4 -mavx".}
 14 | 
 15 | # width in bytes
 16 | const width* = 32
 17 | 
 18 | type m128* {.importc: "__m128", header: "xmmintrin.h".} = object
 19 | type m128d* {.importc: "__m128d", header: "emmintrin.h".} = object
 20 | type m128i* {.importc: "__m128i", header: "emmintrin.h".} = object
 21 | type m256* {.importc: "__m256", header: "immintrin.h".} = object
 22 | type m256d* {.importc: "__m256d", header: "immintrin.h".} = object
 23 | type m256i* {.importc: "__m256i", header: "immintrin.h".} = object
 24 | 
 25 | type mf32* = m256 
 26 | 
 27 | proc add_pd*(a: m256d, b: m256d): m256d
 28 |   {.importc: "_mm256_add_pd", header: "immintrin.h".}
 29 |   ## Exposes _mm256_add_pd intrinsics
 30 | 
 31 | proc add_ps*(a: m256, b: m256): m256
 32 |   {.importc: "_mm256_add_ps", header: "immintrin.h".}
 33 |   ## Exposes _mm256_add_ps intrinsics
 34 | 
 35 | proc sub_pd*(a: m256d, b: m256d): m256d
 36 |   {.importc: "_mm256_sub_pd", header: "immintrin.h".}
 37 |   ## Exposes _mm256_sub_pd intrinsics
 38 | 
 39 | proc sub_ps*(a: m256, b: m256): m256
 40 |   {.importc: "_mm256_sub_ps", header: "immintrin.h".}
 41 |   ## Exposes _mm256_sub_ps intrinsics
 42 | 
 43 | proc addsub_pd*(a: m256d, b: m256d): m256d
 44 |   {.importc: "_mm256_addsub_pd", header: "immintrin.h".}
 45 |   ## Exposes _mm256_addsub_pd intrinsics
 46 | 
 47 | proc addsub_ps*(a: m256, b: m256): m256
 48 |   {.importc: "_mm256_addsub_ps", header: "immintrin.h".}
 49 |   ## Exposes _mm256_addsub_ps intrinsics
 50 | 
 51 | proc div_pd*(a: m256d, b: m256d): m256d
 52 |   {.importc: "_mm256_div_pd", header: "immintrin.h".}
 53 |   ## Exposes _mm256_div_pd intrinsics
 54 | 
 55 | proc div_ps*(a: m256, b: m256): m256
 56 |   {.importc: "_mm256_div_ps", header: "immintrin.h".}
 57 |   ## Exposes _mm256_div_ps intrinsics
 58 | 
 59 | proc max_pd*(a: m256d, b: m256d): m256d
 60 |   {.importc: "_mm256_max_pd", header: "immintrin.h".}
 61 |   ## Exposes _mm256_max_pd intrinsics
 62 | 
 63 | proc max_ps*(a: m256, b: m256): m256
 64 |   {.importc: "_mm256_max_ps", header: "immintrin.h".}
 65 |   ## Exposes _mm256_max_ps intrinsics
 66 | 
 67 | proc min_pd*(a: m256d, b: m256d): m256d
 68 |   {.importc: "_mm256_min_pd", header: "immintrin.h".}
 69 |   ## Exposes _mm256_min_pd intrinsics
 70 | 
 71 | proc min_ps*(a: m256, b: m256): m256
 72 |   {.importc: "_mm256_min_ps", header: "immintrin.h".}
 73 |   ## Exposes _mm256_min_ps intrinsics
 74 | 
 75 | proc mul_pd*(a: m256d, b: m256d): m256d
 76 |   {.importc: "_mm256_mul_pd", header: "immintrin.h".}
 77 |   ## Exposes _mm256_mul_pd intrinsics
 78 | 
 79 | proc mul_ps*(a: m256, b: m256): m256
 80 |   {.importc: "_mm256_mul_ps", header: "immintrin.h".}
 81 |   ## Exposes _mm256_mul_ps intrinsics
 82 | 
 83 | proc sqrt_pd*(a: m256d): m256d
 84 |   {.importc: "_mm256_sqrt_pd", header: "immintrin.h".}
 85 |   ## Exposes _mm256_sqrt_pd intrinsics
 86 | 
 87 | proc sqrt_ps*(a: m256): m256
 88 |   {.importc: "_mm256_sqrt_ps", header: "immintrin.h".}
 89 |   ## Exposes _mm256_sqrt_ps intrinsics
 90 | 
 91 | proc rsqrt_ps*(a: m256): m256
 92 |   {.importc: "_mm256_rsqrt_ps", header: "immintrin.h".}
 93 |   ## Exposes _mm256_rsqrt_ps intrinsics
 94 | 
 95 | proc rcp_ps*(a: m256): m256
 96 |   {.importc: "_mm256_rcp_ps", header: "immintrin.h".}
 97 |   ## Exposes _mm256_rcp_ps intrinsics
 98 | 
 99 | proc and_pd*(a: m256d, b: m256d): m256d
100 |   {.importc: "_mm256_and_pd", header: "immintrin.h".}
101 |   ## Exposes _mm256_and_pd intrinsics
102 | 
103 | proc and_ps*(a: m256, b: m256): m256
104 |   {.importc: "_mm256_and_ps", header: "immintrin.h".}
105 |   ## Exposes _mm256_and_ps intrinsics
106 | 
107 | proc andnot_pd*(a: m256d, b: m256d): m256d
108 |   {.importc: "_mm256_andnot_pd", header: "immintrin.h".}
109 |   ## Exposes _mm256_andnot_pd intrinsics
110 | 
111 | proc andnot_ps*(a: m256, b: m256): m256
112 |   {.importc: "_mm256_andnot_ps", header: "immintrin.h".}
113 |   ## Exposes _mm256_andnot_ps intrinsics
114 | 
115 | proc or_pd*(a: m256d, b: m256d): m256d
116 |   {.importc: "_mm256_or_pd", header: "immintrin.h".}
117 |   ## Exposes _mm256_or_pd intrinsics
118 | 
119 | proc or_ps*(a: m256, b: m256): m256
120 |   {.importc: "_mm256_or_ps", header: "immintrin.h".}
121 |   ## Exposes _mm256_or_ps intrinsics
122 | 
123 | proc xor_pd*(a: m256d, b: m256d): m256d
124 |   {.importc: "_mm256_xor_pd", header: "immintrin.h".}
125 |   ## Exposes _mm256_xor_pd intrinsics
126 | 
127 | proc xor_ps*(a: m256, b: m256): m256
128 |   {.importc: "_mm256_xor_ps", header: "immintrin.h".}
129 |   ## Exposes _mm256_xor_ps intrinsics
130 | 
131 | proc hadd_pd*(a: m256d, b: m256d): m256d
132 |   {.importc: "_mm256_hadd_pd", header: "immintrin.h".}
133 |   ## Exposes _mm256_hadd_pd intrinsics
134 | 
135 | proc hadd_ps*(a: m256, b: m256): m256
136 |   {.importc: "_mm256_hadd_ps", header: "immintrin.h".}
137 |   ## Exposes _mm256_hadd_ps intrinsics
138 | 
139 | proc hsub_pd*(a: m256d, b: m256d): m256d
140 |   {.importc: "_mm256_hsub_pd", header: "immintrin.h".}
141 |   ## Exposes _mm256_hsub_pd intrinsics
142 | 
143 | proc hsub_ps*(a: m256, b: m256): m256
144 |   {.importc: "_mm256_hsub_ps", header: "immintrin.h".}
145 |   ## Exposes _mm256_hsub_ps intrinsics
146 | 
147 | proc permutevar_pd*(a: m128d, c: m128i): m128d
148 |   {.importc: "_mm_permutevar_pd", header: "immintrin.h".}
149 |   ## Exposes _mm_permutevar_pd intrinsics
150 | 
151 | proc permutevar_pd*(a: m256d, c: m256i): m256d
152 |   {.importc: "_mm256_permutevar_pd", header: "immintrin.h".}
153 |   ## Exposes _mm256_permutevar_pd intrinsics
154 | 
155 | proc permutevar_ps*(a: m128, c: m128i): m128
156 |   {.importc: "_mm_permutevar_ps", header: "immintrin.h".}
157 |   ## Exposes _mm_permutevar_ps intrinsics
158 | 
159 | proc permutevar_ps*(a: m256, c: m256i): m256
160 |   {.importc: "_mm256_permutevar_ps", header: "immintrin.h".}
161 |   ## Exposes _mm256_permutevar_ps intrinsics
162 | 
163 | proc blendv_pd*(a: m256d, b: m256d, c: m256d): m256d
164 |   {.importc: "_mm256_blendv_pd", header: "immintrin.h".}
165 |   ## Exposes _mm256_blendv_pd intrinsics
166 | 
167 | proc blendv_ps*(a: m256, b: m256, c: m256): m256
168 |   {.importc: "_mm256_blendv_ps", header: "immintrin.h".}
169 |   ## Exposes _mm256_blendv_ps intrinsics
170 | 
171 | when not defined(vcc):
172 |   proc extract_epi32*(a: m256i, imm: int32): int32
173 |     {.importc: "_mm256_extract_epi32", header: "immintrin.h".}
174 |     ## Exposes _mm256_extract_epi32 intrinsics
175 | 
176 |   proc extract_epi16*(a: m256i, imm: int32): int32
177 |     {.importc: "_mm256_extract_epi16", header: "immintrin.h".}
178 |     ## Exposes _mm256_extract_epi16 intrinsics
179 | 
180 |   proc extract_epi8*(a: m256i, imm: int32): int32
181 |     {.importc: "_mm256_extract_epi8", header: "immintrin.h".}
182 |     ## Exposes _mm256_extract_epi8 intrinsics
183 | 
184 |   proc insert_epi32*(a: m256i, b: int32, imm: int32): m256i
185 |     {.importc: "_mm256_insert_epi32", header: "immintrin.h".}
186 |     ## Exposes _mm256_insert_epi32 intrinsics
187 | 
188 |   proc insert_epi16*(a: m256i, b: int32, imm: int32): m256i
189 |     {.importc: "_mm256_insert_epi16", header: "immintrin.h".}
190 |     ## Exposes _mm256_insert_epi16 intrinsics
191 | 
192 |   proc insert_epi8*(a: m256i, b: int32, imm: int32): m256i
193 |     {.importc: "_mm256_insert_epi8", header: "immintrin.h".}
194 |     ## Exposes _mm256_insert_epi8 intrinsic
195 | 
196 | when defined(x86_64) and defined(vcc):
197 |   proc insert_epi64*(a: m256i, b: int32, imm: int32): m256i
198 |     {.importc: "_mm256_insert_epi64", header: "immintrin.h".}
199 |     ## Exposes _mm256_insert_epi64 intrinsics
200 | 
201 | proc cvtepi32_pd*(a: m128i): m256d
202 |   {.importc: "_mm256_cvtepi32_pd", header: "immintrin.h".}
203 |   ## Exposes _mm256_cvtepi32_pd intrinsics
204 | 
205 | proc cvtepi32_ps*(a: m256i): m256
206 |   {.importc: "_mm256_cvtepi32_ps", header: "immintrin.h".}
207 |   ## Exposes _mm256_cvtepi32_ps intrinsics
208 | 
209 | proc cvtpd_ps*(a: m256d): m128
210 |   {.importc: "_mm256_cvtpd_ps", header: "immintrin.h".}
211 |   ## Exposes _mm256_cvtpd_ps intrinsics
212 | 
213 | proc cvtps_epi32*(a: m256): m256i
214 |   {.importc: "_mm256_cvtps_epi32", header: "immintrin.h".}
215 |   ## Exposes _mm256_cvtps_epi32 intrinsics
216 | 
217 | proc cvtps_pd*(a: m128): m256d
218 |   {.importc: "_mm256_cvtps_pd", header: "immintrin.h".}
219 |   ## Exposes _mm256_cvtps_pd intrinsics
220 | 
221 | proc cvttpd_epi32*(a: m256d): m128i
222 |   {.importc: "_mm256_cvttpd_epi32", header: "immintrin.h".}
223 |   ## Exposes _mm256_cvttpd_epi32 intrinsics
224 | 
225 | proc cvtpd_epi32*(a: m256d): m128i
226 |   {.importc: "_mm256_cvtpd_epi32", header: "immintrin.h".}
227 |   ## Exposes _mm256_cvtpd_epi32 intrinsics
228 | 
229 | proc cvttps_epi32*(a: m256): m256i
230 |   {.importc: "_mm256_cvttps_epi32", header: "immintrin.h".}
231 |   ## Exposes _mm256_cvttps_epi32 intrinsics
232 | 
233 | proc movehdup_ps*(a: m256): m256
234 |   {.importc: "_mm256_movehdup_ps", header: "immintrin.h".}
235 |   ## Exposes _mm256_movehdup_ps intrinsics
236 | 
237 | proc moveldup_ps*(a: m256): m256
238 |   {.importc: "_mm256_moveldup_ps", header: "immintrin.h".}
239 |   ## Exposes _mm256_moveldup_ps intrinsics
240 | 
241 | proc movedup_pd*(a: m256d): m256d
242 |   {.importc: "_mm256_movedup_pd", header: "immintrin.h".}
243 |   ## Exposes _mm256_movedup_pd intrinsics
244 | 
245 | proc unpackhi_pd*(a: m256d, b: m256d): m256d
246 |   {.importc: "_mm256_unpackhi_pd", header: "immintrin.h".}
247 |   ## Exposes _mm256_unpackhi_pd intrinsics
248 | 
249 | proc unpacklo_pd*(a: m256d, b: m256d): m256d
250 |   {.importc: "_mm256_unpacklo_pd", header: "immintrin.h".}
251 |   ## Exposes _mm256_unpacklo_pd intrinsics
252 | 
253 | proc unpackhi_ps*(a: m256, b: m256): m256
254 |   {.importc: "_mm256_unpackhi_ps", header: "immintrin.h".}
255 |   ## Exposes _mm256_unpackhi_ps intrinsics
256 | 
257 | proc unpacklo_ps*(a: m256, b: m256): m256
258 |   {.importc: "_mm256_unpacklo_ps", header: "immintrin.h".}
259 |   ## Exposes _mm256_unpacklo_ps intrinsics
260 | 
261 | proc testz_pd*(a: m128d, b: m128d): int32
262 |   {.importc: "_mm_testz_pd", header: "immintrin.h".}
263 |   ## Exposes _mm_testz_pd intrinsics
264 | 
265 | proc testc_pd*(a: m128d, b: m128d): int32
266 |   {.importc: "_mm_testc_pd", header: "immintrin.h".}
267 |   ## Exposes _mm_testc_pd intrinsics
268 | 
269 | proc testnzc_pd*(a: m128d, b: m128d): int32
270 |   {.importc: "_mm_testnzc_pd", header: "immintrin.h".}
271 |   ## Exposes _mm_testnzc_pd intrinsics
272 | 
273 | proc testz_ps*(a: m128, b: m128): int32
274 |   {.importc: "_mm_testz_ps", header: "immintrin.h".}
275 |   ## Exposes _mm_testz_ps intrinsics
276 | 
277 | proc testc_ps*(a: m128, b: m128): int32
278 |   {.importc: "_mm_testc_ps", header: "immintrin.h".}
279 |   ## Exposes _mm_testc_ps intrinsics
280 | 
281 | proc testnzc_ps*(a: m128, b: m128): int32
282 |   {.importc: "_mm_testnzc_ps", header: "immintrin.h".}
283 |   ## Exposes _mm_testnzc_ps intrinsics
284 | 
285 | proc testz_pd*(a: m256d, b: m256d): int32
286 |   {.importc: "_mm256_testz_pd", header: "immintrin.h".}
287 |   ## Exposes _mm256_testz_pd intrinsics
288 | 
289 | proc testc_pd*(a: m256d, b: m256d): int32
290 |   {.importc: "_mm256_testc_pd", header: "immintrin.h".}
291 |   ## Exposes _mm256_testc_pd intrinsics
292 | 
293 | proc testnzc_pd*(a: m256d, b: m256d): int32
294 |   {.importc: "_mm256_testnzc_pd", header: "immintrin.h".}
295 |   ## Exposes _mm256_testnzc_pd intrinsics
296 | 
297 | proc testz_ps*(a: m256, b: m256): int32
298 |   {.importc: "_mm256_testz_ps", header: "immintrin.h".}
299 |   ## Exposes _mm256_testz_ps intrinsics
300 | 
301 | proc testc_ps*(a: m256, b: m256): int32
302 |   {.importc: "_mm256_testc_ps", header: "immintrin.h".}
303 |   ## Exposes _mm256_testc_ps intrinsics
304 | 
305 | proc testnzc_ps*(a: m256, b: m256): int32
306 |   {.importc: "_mm256_testnzc_ps", header: "immintrin.h".}
307 |   ## Exposes _mm256_testnzc_ps intrinsics
308 | 
309 | proc testz_si256*(a: m256i, b: m256i): int32
310 |   {.importc: "_mm256_testz_si256", header: "immintrin.h".}
311 |   ## Exposes _mm256_testz_si256 intrinsics
312 | 
313 | proc testc_si256*(a: m256i, b: m256i): int32
314 |   {.importc: "_mm256_testc_si256", header: "immintrin.h".}
315 |   ## Exposes _mm256_testc_si256 intrinsics
316 | 
317 | proc testnzc_si256*(a: m256i, b: m256i): int32
318 |   {.importc: "_mm256_testnzc_si256", header: "immintrin.h".}
319 |   ## Exposes _mm256_testnzc_si256 intrinsics
320 | 
321 | proc movemask_pd*(a: m256d): int32
322 |   {.importc: "_mm256_movemask_pd", header: "immintrin.h".}
323 |   ## Exposes _mm256_movemask_pd intrinsics
324 | 
325 | proc movemask_ps*(a: m256): int32
326 |   {.importc: "_mm256_movemask_ps", header: "immintrin.h".}
327 |   ## Exposes _mm256_movemask_ps intrinsics
328 | 
329 | proc zeroall*(): void
330 |   {.importc: "_mm256_zeroall", header: "immintrin.h".}
331 |   ## Exposes _mm256_zeroall intrinsics
332 | 
333 | proc zeroupper*(): void
334 |   {.importc: "_mm256_zeroupper", header: "immintrin.h".}
335 |   ## Exposes _mm256_zeroupper intrinsics
336 | 
337 | proc broadcast_ss*(a: ptr float32): m128
338 |   {.importc: "_mm_broadcast_ss", header: "immintrin.h".}
339 |   ## Exposes _mm_broadcast_ss intrinsics
340 | 
341 | proc broadcast_sd_256*(a: ptr float64): m256d
342 |   {.importc: "_mm256_broadcast_sd", header: "immintrin.h".}
343 |   ## Exposes _mm256_broadcast_sd intrinsics
344 | 
345 | proc broadcast_ss_256*(a: ptr float32): m256
346 |   {.importc: "_mm256_broadcast_ss", header: "immintrin.h".}
347 |   ## Exposes _mm256_broadcast_ss intrinsics
348 | 
349 | proc broadcast_pd*(a: ptr m128d): m256d
350 |   {.importc: "_mm256_broadcast_pd", header: "immintrin.h".}
351 |   ## Exposes _mm256_broadcast_pd intrinsics
352 | 
353 | proc broadcast_ps*(a: ptr m128): m256
354 |   {.importc: "_mm256_broadcast_ps", header: "immintrin.h".}
355 |   ## Exposes _mm256_broadcast_ps intrinsics
356 | 
357 | proc load_pd_256*(p: ptr float64): m256d
358 |   {.importc: "_mm256_load_pd", header: "immintrin.h".}
359 |   ## Exposes _mm256_load_pd intrinsics
360 | 
361 | proc load_ps*(p: ptr float32): m256
362 |   {.importc: "_mm256_load_ps", header: "immintrin.h".}
363 |   ## Exposes _mm256_load_ps intrinsics
364 | 
365 | proc loadu_pd_256*(p: ptr float64): m256d
366 |   {.importc: "_mm256_loadu_pd", header: "immintrin.h".}
367 |   ## Exposes _mm256_loadu_pd intrinsics
368 | 
369 | proc loadu_ps*(p: ptr float32): m256
370 |   {.importc: "_mm256_loadu_ps", header: "immintrin.h".}
371 |   ## Exposes _mm256_loadu_ps intrinsics
372 | 
373 | proc load_si256*(p: ptr m256i): m256i
374 |   {.importc: "_mm256_load_si256", header: "immintrin.h".}
375 |   ## Exposes _mm256_load_si256 intrinsics
376 | 
377 | proc loadu_si256*(p: ptr m256i): m256i
378 |   {.importc: "_mm256_loadu_si256", header: "immintrin.h".}
379 |   ## Exposes _mm256_loadu_si256 intrinsics
380 | 
381 | proc lddqu_si256*(p: ptr m256i): m256i
382 |   {.importc: "_mm256_lddqu_si256", header: "immintrin.h".}
383 |   ## Exposes _mm256_lddqu_si256 intrinsics
384 | 
385 | proc store_pd*(p: ptr float64, a: m256d): void
386 |   {.importc: "_mm256_store_pd", header: "immintrin.h".}
387 |   ## Exposes _mm256_store_pd intrinsics
388 | 
389 | proc store_ps*(p: ptr float32, a: m256): void
390 |   {.importc: "_mm256_store_ps", header: "immintrin.h".}
391 |   ## Exposes _mm256_store_ps intrinsics
392 | 
393 | proc storeu_pd*(p: ptr float64, a: m256d): void
394 |   {.importc: "_mm256_storeu_pd", header: "immintrin.h".}
395 |   ## Exposes _mm256_storeu_pd intrinsics
396 | 
397 | proc storeu_ps*(p: ptr float32, a: m256): void
398 |   {.importc: "_mm256_storeu_ps", header: "immintrin.h".}
399 |   ## Exposes _mm256_storeu_ps intrinsics
400 | 
401 | proc store_si256*(p: ptr m256i, a: m256i): void
402 |   {.importc: "_mm256_store_si256", header: "immintrin.h".}
403 |   ## Exposes _mm256_store_si256 intrinsics
404 | 
405 | proc storeu_si256*(p: ptr m256i, a: m256i): void
406 |   {.importc: "_mm256_storeu_si256", header: "immintrin.h".}
407 |   ## Exposes _mm256_storeu_si256 intrinsics
408 | 
409 | proc maskload_pd*(p: ptr float64, m: m128i): m128d
410 |   {.importc: "_mm_maskload_pd", header: "immintrin.h".}
411 |   ## Exposes _mm_maskload_pd intrinsics
412 | 
413 | proc maskload_pd*(p: ptr float64, m: m256i): m256d
414 |   {.importc: "_mm256_maskload_pd", header: "immintrin.h".}
415 |   ## Exposes _mm256_maskload_pd intrinsics
416 | 
417 | proc maskload_ps*(p: ptr float32, m: m128i): m128
418 |   {.importc: "_mm_maskload_ps", header: "immintrin.h".}
419 |   ## Exposes _mm_maskload_ps intrinsics
420 | 
421 | proc maskload_ps*(p: ptr float32, m: m256i): m256
422 |   {.importc: "_mm256_maskload_ps", header: "immintrin.h".}
423 |   ## Exposes _mm256_maskload_ps intrinsics
424 | 
425 | proc maskstore_ps*(p: ptr float32, m: m256i, a: m256): void
426 |   {.importc: "_mm256_maskstore_ps", header: "immintrin.h".}
427 |   ## Exposes _mm256_maskstore_ps intrinsics
428 | 
429 | proc maskstore_pd*(p: ptr float64, m: m128i, a: m128d): void
430 |   {.importc: "_mm_maskstore_pd", header: "immintrin.h".}
431 |   ## Exposes _mm_maskstore_pd intrinsics
432 | 
433 | proc maskstore_pd*(p: ptr float64, m: m256i, a: m256d): void
434 |   {.importc: "_mm256_maskstore_pd", header: "immintrin.h".}
435 |   ## Exposes _mm256_maskstore_pd intrinsics
436 | 
437 | proc maskstore_ps*(p: ptr float32, m: m128i, a: m128): void
438 |   {.importc: "_mm_maskstore_ps", header: "immintrin.h".}
439 |   ## Exposes _mm_maskstore_ps intrinsics
440 | 
441 | proc stream_si256*(a: ptr m256i, b: m256i): void
442 |   {.importc: "_mm256_stream_si256", header: "immintrin.h".}
443 |   ## Exposes _mm256_stream_si256 intrinsics
444 | 
445 | proc stream_pd*(a: ptr float64, b: m256d): void
446 |   {.importc: "_mm256_stream_pd", header: "immintrin.h".}
447 |   ## Exposes _mm256_stream_pd intrinsics
448 | 
449 | proc stream_ps*(p: ptr float32, a: m256): void
450 |   {.importc: "_mm256_stream_ps", header: "immintrin.h".}
451 |   ## Exposes _mm256_stream_ps intrinsics
452 | 
453 | proc set_pd*(a: float64, b: float64, c: float64, d: float64): m256d
454 |   {.importc: "_mm256_set_pd", header: "immintrin.h".}
455 |   ## Exposes _mm256_set_pd intrinsics
456 | 
457 | proc set_ps*(a: float32, b: float32, c: float32, d: float32, e: float32, f: float32, g: float32, h: float32): m256
458 |   {.importc: "_mm256_set_ps", header: "immintrin.h".}
459 |   ## Exposes _mm256_set_ps intrinsics
460 | 
461 | proc set_epi32*(i0: int32, i1: int32, i2: int32, i3: int32, i4: int32, i5: int32, i6: int32, i7: int32): m256i
462 |   {.importc: "_mm256_set_epi32", header: "immintrin.h".}
463 |   ## Exposes _mm256_set_epi32 intrinsics
464 | 
465 | proc set_epi16*(w15: int16, w14: int16, w13: int16, w12: int16, w11: int16, w10: int16, w09: int16, w08: int16, w07: int16, w06: int16, w05: int16, w04: int16, w03: int16, w02: int16, w01: int16, w00: int16): m256i
466 |   {.importc: "_mm256_set_epi16", header: "immintrin.h".}
467 |   ## Exposes _mm256_set_epi16 intrinsics
468 | 
469 | proc set_epi8*(b31: int8, b30: int8, b29: int8, b28: int8, b27: int8, b26: int8, b25: int8, b24: int8, b23: int8, b22: int8, b21: int8, b20: int8, b19: int8, b18: int8, b17: int8, b16: int8, b15: int8, b14: int8, b13: int8, b12: int8, b11: int8, b10: int8, b09: int8, b08: int8, b07: int8, b06: int8, b05: int8, b04: int8, b03: int8, b02: int8, b01: int8, b00: int8): m256i
470 |   {.importc: "_mm256_set_epi8", header: "immintrin.h".}
471 |   ## Exposes _mm256_set_epi8 intrinsics
472 | 
473 | when defined(x86_64):
474 |   proc set_epi64x*(a: int64, b: int64, c: int64, d: int64): m256i
475 |     {.importc: "_mm256_set_epi64x", header: "immintrin.h".}
476 |     ## Exposes _mm256_set_epi64x intrinsics
477 | 
478 |   proc setr_epi64x*(a: int64, b: int64, c: int64, d: int64): m256i
479 |     {.importc: "_mm256_setr_epi64x", header: "immintrin.h".}
480 |     ## Exposes _mm256_setr_epi64x intrinsics
481 | 
482 |   proc set1_epi64x*(q: int64): m256i
483 |     {.importc: "_mm256_set1_epi64x", header: "immintrin.h".}
484 |     ## Exposes _mm256_set1_epi64x intrinsics
485 | 
486 | proc setr_pd*(a: float64, b: float64, c: float64, d: float64): m256d
487 |   {.importc: "_mm256_setr_pd", header: "immintrin.h".}
488 |   ## Exposes _mm256_setr_pd intrinsics
489 | 
490 | proc setr_ps*(a: float32, b: float32, c: float32, d: float32, e: float32, f: float32, g: float32, h: float32): m256
491 |   {.importc: "_mm256_setr_ps", header: "immintrin.h".}
492 |   ## Exposes _mm256_setr_ps intrinsics
493 | 
494 | proc setr_epi32*(i0: int32, i1: int32, i2: int32, i3: int32, i4: int32, i5: int32, i6: int32, i7: int32): m256i
495 |   {.importc: "_mm256_setr_epi32", header: "immintrin.h".}
496 |   ## Exposes _mm256_setr_epi32 intrinsics
497 | 
498 | proc setr_epi16*(w15: int16, w14: int16, w13: int16, w12: int16, w11: int16, w10: int16, w09: int16, w08: int16, w07: int16, w06: int16, w05: int16, w04: int16, w03: int16, w02: int16, w01: int16, w00: int16): m256i
499 |   {.importc: "_mm256_setr_epi16", header: "immintrin.h".}
500 |   ## Exposes _mm256_setr_epi16 intrinsics
501 | 
502 | proc setr_epi8*(b31: int8, b30: int8, b29: int8, b28: int8, b27: int8, b26: int8, b25: int8, b24: int8, b23: int8, b22: int8, b21: int8, b20: int8, b19: int8, b18: int8, b17: int8, b16: int8, b15: int8, b14: int8, b13: int8, b12: int8, b11: int8, b10: int8, b09: int8, b08: int8, b07: int8, b06: int8, b05: int8, b04: int8, b03: int8, b02: int8, b01: int8, b00: int8): m256i
503 |   {.importc: "_mm256_setr_epi8", header: "immintrin.h".}
504 |   ## Exposes _mm256_setr_epi8 intrinsics
505 | 
506 | proc set1_pd_256*(w: float64): m256d
507 |   {.importc: "_mm256_set1_pd", header: "immintrin.h".}
508 |   ## Exposes _mm256_set1_pd intrinsics
509 | 
510 | proc set1_ps*(w: float32): m256
511 |   {.importc: "_mm256_set1_ps", header: "immintrin.h".}
512 |   ## Exposes _mm256_set1_ps intrinsics
513 | 
514 | proc set1_epi32*(i: int32): m256i
515 |   {.importc: "_mm256_set1_epi32", header: "immintrin.h".}
516 |   ## Exposes _mm256_set1_epi32 intrinsics
517 | 
518 | proc set1_epi16*(w: int16): m256i
519 |   {.importc: "_mm256_set1_epi16", header: "immintrin.h".}
520 |   ## Exposes _mm256_set1_epi16 intrinsics
521 | 
522 | proc set1_epi8*(b: int8): m256i
523 |   {.importc: "_mm256_set1_epi8", header: "immintrin.h".}
524 |   ## Exposes _mm256_set1_epi8 intrinsics
525 | 
526 | proc setzero_pd*(): m256d
527 |   {.importc: "_mm256_setzero_pd", header: "immintrin.h".}
528 |   ## Exposes _mm256_setzero_pd intrinsics
529 | 
530 | proc setzero_ps*(): m256
531 |   {.importc: "_mm256_setzero_ps", header: "immintrin.h".}
532 |   ## Exposes _mm256_setzero_ps intrinsics
533 | 
534 | proc setzero_si256*(): m256i
535 |   {.importc: "_mm256_setzero_si256", header: "immintrin.h".}
536 |   ## Exposes _mm256_setzero_si256 intrinsics
537 | 
538 | proc castpd_ps*(a: m256d): m256
539 |   {.importc: "_mm256_castpd_ps", header: "immintrin.h".}
540 |   ## Exposes _mm256_castpd_ps intrinsics
541 | 
542 | proc castpd_si*(a: m256d): m256i
543 |   {.importc: "_mm256_castpd_si256", header: "immintrin.h".}
544 |   ## Exposes _mm256_castpd_si256 intrinsics
545 | 
546 | proc castps_pd*(a: m256): m256d
547 |   {.importc: "_mm256_castps_pd", header: "immintrin.h".}
548 |   ## Exposes _mm256_castps_pd intrinsics
549 | 
550 | proc castps_si*(a: m256): m256i
551 |   {.importc: "_mm256_castps_si256", header: "immintrin.h".}
552 |   ## Exposes _mm256_castps_si256 intrinsics
553 | 
554 | proc castsi256_ps*(a: m256i): m256
555 |   {.importc: "_mm256_castsi256_ps", header: "immintrin.h".}
556 |   ## Exposes _mm256_castsi256_ps intrinsics
557 | 
558 | proc castsi256_pd*(a: m256i): m256d
559 |   {.importc: "_mm256_castsi256_pd", header: "immintrin.h".}
560 |   ## Exposes _mm256_castsi256_pd intrinsics
561 | 
562 | proc castpd256_pd128*(a: m256d): m128d
563 |   {.importc: "_mm256_castpd256_pd128", header: "immintrin.h".}
564 |   ## Exposes _mm256_castpd256_pd128 intrinsics
565 | 
566 | proc castps256_ps128*(a: m256): m128
567 |   {.importc: "_mm256_castps256_ps128", header: "immintrin.h".}
568 |   ## Exposes _mm256_castps256_ps128 intrinsics
569 | 
570 | proc castsi256_si128*(a: m256i): m128i
571 |   {.importc: "_mm256_castsi256_si128", header: "immintrin.h".}
572 |   ## Exposes _mm256_castsi256_si128 intrinsics
573 | 
574 | proc castpd128_pd256*(a: m128d): m256d
575 |   {.importc: "_mm256_castpd128_pd256", header: "immintrin.h".}
576 |   ## Exposes _mm256_castpd128_pd256 intrinsics
577 | 
578 | proc castps128_ps256*(a: m128): m256
579 |   {.importc: "_mm256_castps128_ps256", header: "immintrin.h".}
580 |   ## Exposes _mm256_castps128_ps256 intrinsics
581 | 
582 | proc castsi128_si256*(a: m128i): m256i
583 |   {.importc: "_mm256_castsi128_si256", header: "immintrin.h".}
584 |   ## Exposes _mm256_castsi128_si256 intrinsics
585 | 
586 | # Export all avx immintrin.h constants
587 | proc ceil_ps*(a: m256): m256
588 |   {.importc: "_mm256_ceil_ps", header: "immintrin.h".}
589 |   ## Exposes _mm256_ceil_ps intrinsics
590 | 
591 | proc ceil_pd*(a: m256d): m256d
592 |   {.importc: "_mm256_ceil_pd", header: "immintrin.h".}
593 |   ## Exposes _mm256_ceil_pd intrinsics
594 | 
595 | proc floor_ps*(a: m256): m256
596 |   {.importc: "_mm256_floor_ps", header: "immintrin.h".}
597 |   ## Exposes _mm256_floor_ps intrinsics
598 | 
599 | proc floor_pd*(a: m256d): m256d
600 |   {.importc: "_mm256_floor_pd", header: "immintrin.h".}
601 |   ## Exposes _mm256_floor_pd intrinsics
602 | 
603 | proc round_ps*(a: m256, b: int32): m256
604 |   {.importc: "_mm256_round_ps", header: "immintrin.h".}
605 |   ## Exposes _mm256_round_ps intrinsics
606 | 
607 | proc round_pd*(a: m256d, b: int32): m256d
608 |   {.importc: "_mm256_round_pd", header: "immintrin.h".}
609 |   ## Exposes _mm256_round_pd intrinsics
610 | 
611 | proc blend_ps*(a: m256, b: m256, c: int32): m256
612 |   {.importc: "_mm256_blend_ps", header: "immintrin.h".}
613 |   ## Exposes _mm256_blend_ps intrinsics
614 | 
615 | proc blend_pd*(a: m256d, b: m256d, c: int32): m256d
616 |   {.importc: "_mm256_blend_pd", header: "immintrin.h".}
617 |   ## Exposes _mm256_blend_pd intrinsics
618 | 
619 | proc permute_pd*(a: m256d, b: int32): m256d
620 |   {.importc: "_mm256_permute_pd", header: "immintrin.h".}
621 |   ## Exposes _mm256_permute_pd intrinsics
622 | 
623 | proc permute_pd*(a: m128d, b: int32): m128d
624 |   {.importc: "_mm_permute_pd", header: "immintrin.h".}
625 |   ## Exposes _mm_permute_pd intrinsics
626 | 
627 | proc permute_ps*(a: m256, b: int32): m256
628 |   {.importc: "_mm256_permute_ps", header: "immintrin.h".}
629 |   ## Exposes _mm256_permute_ps intrinsics
630 | 
631 | proc permute_ps*(a: m128, b: int32): m128
632 |   {.importc: "_mm_permute_ps", header: "immintrin.h".}
633 |   ## Exposes _mm_permute_ps intrinsics
634 | 
635 | proc permute2f128_pd*(a: m256d, b: m256d, c: int32): m256d
636 |   {.importc: "_mm256_permute2f128_pd", header: "immintrin.h".}
637 |   ## Exposes _mm256_permute2f128_pd intrinsics
638 | 
639 | proc permute2f128_ps*(a: m256, b: m256, c: int32): m256
640 |   {.importc: "_mm256_permute2f128_ps", header: "immintrin.h".}
641 |   ## Exposes _mm256_permute2f128_ps intrinsics
642 | 
643 | proc permute2f128_si256*(a: m256i, b: m256i, c: int32): m256i
644 |   {.importc: "_mm256_permute2f128_si256", header: "immintrin.h".}
645 |   ## Exposes _mm256_permute2f128_si256 intrinsics
646 | 
647 | proc dp_ps*(a: m256, b: m256, c: int32): m256
648 |   {.importc: "_mm256_dp_ps", header: "immintrin.h".}
649 |   ## Exposes _mm256_dp_ps intrinsics
650 | 
651 | proc shuffle_pd*(a: m256d, b: m256d, c: int32): m256d
652 |   {.importc: "_mm256_shuffle_pd", header: "immintrin.h".}
653 |   ## Exposes _mm256_shuffle_pd intrinsics
654 | 
655 | proc shuffle_ps*(a: m256, b: m256, c: int32): m256
656 |   {.importc: "_mm256_shuffle_ps", header: "immintrin.h".}
657 |   ## Exposes _mm256_shuffle_ps intrinsics
658 | 
659 | proc insertf128_pd*(a: m256d, b: m128d, c: int32): m256d
660 |   {.importc: "_mm256_insertf128_pd", header: "immintrin.h".}
661 |   ## Exposes _mm256_insertf128_pd intrinsics
662 | 
663 | proc insertf128_ps*(a: m256, b: m128, c: int32): m256
664 |   {.importc: "_mm256_insertf128_ps", header: "immintrin.h".}
665 |   ## Exposes _mm256_insertf128_ps intrinsics
666 | 
667 | proc insertf128_si256*(a: m256i, b: m128i, c: int32): m256i
668 |   {.importc: "_mm256_insertf128_si256", header: "immintrin.h".}
669 |   ## Exposes _mm256_insertf128_si256 intrinsics
670 | 
671 | proc cmp_pd*(a: m128d, b: m128d, c: int32): m128d
672 |   {.importc: "_mm_cmp_pd", header: "immintrin.h".}
673 |   ## Exposes _mm_cmp_pd intrinsics
674 | 
675 | proc cmp_ps*(a: m128, b: m128, c: int32): m128
676 |   {.importc: "_mm_cmp_ps", header: "immintrin.h".}
677 |   ## Exposes _mm_cmp_ps intrinsics
678 | 
679 | proc cmp_ss*(a: m128, b: m128, c: int32): m128
680 |   {.importc: "_mm_cmp_ss", header: "immintrin.h".}
681 |   ## Exposes _mm_cmp_ss intrinsics
682 | 
683 | proc cmp_pd*(a: m256d, b: m256d, c: int32): m256d
684 |   {.importc: "_mm256_cmp_pd", header: "immintrin.h".}
685 |   ## Exposes _mm256_cmp_pd intrinsics
686 | 
687 | proc cmp_ps*(a: m256, b: m256, c: int32): m256
688 |   {.importc: "_mm256_cmp_ps", header: "immintrin.h".}
689 |   ## Exposes _mm256_cmp_ps intrinsics
690 | 
691 | # Compare constants
692 | const CMP_EQ_OQ* = 0x00 # Equal (ordered, non-signaling)
693 | const CMP_LT_OS* = 0x01 # Less-than (ordered, signaling)
694 | const CMP_LE_OS* = 0x02 # Less-than-or-equal (ordered, signaling)
695 | const CMP_UNORD_Q* = 0x03 # Unordered (non-signaling)
696 | const CMP_NEQ_UQ* = 0x04 # Not-equal (unordered, non-signaling)
697 | const CMP_NLT_US* = 0x05 # Not-less-than (unordered, signaling)
698 | const CMP_NLE_US* = 0x06 # Not-less-than-or-equal (unordered, signaling)
699 | const CMP_ORD_Q* = 0x07 # Ordered (nonsignaling)
700 | const CMP_EQ_UQ* = 0x08 # Equal (unordered, non-signaling)
701 | const CMP_NGE_US* = 0x09 # Not-greater-than-or-equal (unord, signaling)
702 | const CMP_NGT_US* = 0x0a # Not-greater-than (unordered, signaling)
703 | const CMP_FALSE_OQ* = 0x0b # False (ordered, non-signaling)
704 | const CMP_NEQ_OQ* = 0x0c # Not-equal (ordered, non-signaling)
705 | const CMP_GE_OS* = 0x0d # Greater-than-or-equal (ordered, signaling)
706 | const CMP_GT_OS* = 0x0e # Greater-than (ordered, signaling)
707 | const CMP_TRUE_UQ* = 0x0f # True (unordered, non-signaling)
708 | const CMP_EQ_OS* = 0x10 # Equal (ordered, signaling)
709 | const CMP_LT_OQ* = 0x11 # Less-than (ordered, non-signaling)
710 | const CMP_LE_OQ* = 0x12 # Less-than-or-equal (ordered, non-signaling)
711 | const CMP_UNORD_S* = 0x13 # Unordered (signaling)
712 | const CMP_NEQ_US* = 0x14 # Not-equal (unordered, signaling)
713 | const CMP_NLT_UQ* = 0x15 # Not-less-than (unordered, non-signaling)
714 | const CMP_NLE_UQ* = 0x16 # Not-less-than-or-equal (unord, non-signaling)
715 | const CMP_ORD_S* = 0x17 # Ordered (signaling)
716 | const CMP_EQ_US* = 0x18 # Equal (unordered, signaling)
717 | const CMP_NGE_UQ* = 0x19 # Not-greater-than-or-equal (unord, non-sign)
718 | const CMP_NGT_UQ* = 0x1a # Not-greater-than (unordered, non-signaling)
719 | const CMP_FALSE_OS* = 0x1b # False (ordered, signaling)
720 | const CMP_NEQ_OS* = 0x1c # Not-equal (ordered, signaling)
721 | const CMP_GE_OQ* = 0x1d # Greater-than-or-equal (ordered, non-signaling)
722 | const CMP_GT_OQ* = 0x1e # Greater-than (ordered, non-signaling)
723 | const CMP_TRUE_US* = 0x1f # True (unordered, signaling)
724 | 
725 | ## Falbacks
726 | 
727 | # Floor and convert to int in one go
728 | template floor_ps_epi32*(a: m256) : m256i = 
729 |   cvtps_epi32(floor_ps(a))
730 | 
731 | # Greater than or equal with same conventions as SSE
732 | template cmpge_ps*(a,b:m256) : m256 =
733 |   cmp_ps(a,b,CMP_GE_OQ)
734 | 
735 | # Greater than with same conventions as SSE
736 | template cmpgt_ps*(a,b:m256) : m256 = 
737 |   cmp_ps(a,b,CMP_GT_OQ)
738 | 
739 | # Less than with same conventions as SSE
740 | template cmplt_ps*(a,b:m256) : m256 =
741 |   cmp_ps(a,b,CMP_LT_OQ)
742 | 


--------------------------------------------------------------------------------
/src/nimsimd/avx2.nim:
--------------------------------------------------------------------------------
  1 | #
  2 | #
  3 | #          Nimrod's x86 avx2 intrinsics
  4 | #        (c) Copyright 2014 Ben Segovia
  5 | #
  6 | #    See the file copying.txt, included in this
  7 | #    distribution, for details about the copyright.
  8 | #
  9 | include avx
 10 | 
 11 | when someGcc:
 12 |   {.passC: "-mavx2".}
 13 |   {.passL: "-mavx2".}
 14 | 
 15 | 
 16 | proc abs_epi8*(a: m256i): m256i
 17 |   {.importc: "_mm256_abs_epi8", header: "immintrin.h".}
 18 |   ## Exposes _mm256_abs_epi8 intrinsics
 19 | 
 20 | proc abs_epi16*(a: m256i): m256i
 21 |   {.importc: "_mm256_abs_epi16", header: "immintrin.h".}
 22 |   ## Exposes _mm256_abs_epi16 intrinsics
 23 | 
 24 | proc abs_epi32*(a: m256i): m256i
 25 |   {.importc: "_mm256_abs_epi32", header: "immintrin.h".}
 26 |   ## Exposes _mm256_abs_epi32 intrinsics
 27 | 
 28 | proc packs_epi16*(a: m256i, b: m256i): m256i
 29 |   {.importc: "_mm256_packs_epi16", header: "immintrin.h".}
 30 |   ## Exposes _mm256_packs_epi16 intrinsics
 31 | 
 32 | proc packs_epi32*(a: m256i, b: m256i): m256i
 33 |   {.importc: "_mm256_packs_epi32", header: "immintrin.h".}
 34 |   ## Exposes _mm256_packs_epi32 intrinsics
 35 | 
 36 | proc packus_epi16*(a: m256i, b: m256i): m256i
 37 |   {.importc: "_mm256_packus_epi16", header: "immintrin.h".}
 38 |   ## Exposes _mm256_packus_epi16 intrinsics
 39 | 
 40 | proc packus_epi32*(V1: m256i, V2: m256i): m256i
 41 |   {.importc: "_mm256_packus_epi32", header: "immintrin.h".}
 42 |   ## Exposes _mm256_packus_epi32 intrinsics
 43 | 
 44 | proc add_epi8*(a: m256i, b: m256i): m256i
 45 |   {.importc: "_mm256_add_epi8", header: "immintrin.h".}
 46 |   ## Exposes _mm256_add_epi8 intrinsics
 47 | 
 48 | proc add_epi16*(a: m256i, b: m256i): m256i
 49 |   {.importc: "_mm256_add_epi16", header: "immintrin.h".}
 50 |   ## Exposes _mm256_add_epi16 intrinsics
 51 | 
 52 | proc add_epi32*(a: m256i, b: m256i): m256i
 53 |   {.importc: "_mm256_add_epi32", header: "immintrin.h".}
 54 |   ## Exposes _mm256_add_epi32 intrinsics
 55 | 
 56 | proc add_epi64*(a: m256i, b: m256i): m256i
 57 |   {.importc: "_mm256_add_epi64", header: "immintrin.h".}
 58 |   ## Exposes _mm256_add_epi64 intrinsics
 59 | 
 60 | proc adds_epi8*(a: m256i, b: m256i): m256i
 61 |   {.importc: "_mm256_adds_epi8", header: "immintrin.h".}
 62 |   ## Exposes _mm256_adds_epi8 intrinsics
 63 | 
 64 | proc adds_epi16*(a: m256i, b: m256i): m256i
 65 |   {.importc: "_mm256_adds_epi16", header: "immintrin.h".}
 66 |   ## Exposes _mm256_adds_epi16 intrinsics
 67 | 
 68 | proc adds_epu8*(a: m256i, b: m256i): m256i
 69 |   {.importc: "_mm256_adds_epu8", header: "immintrin.h".}
 70 |   ## Exposes _mm256_adds_epu8 intrinsics
 71 | 
 72 | proc adds_epu16*(a: m256i, b: m256i): m256i
 73 |   {.importc: "_mm256_adds_epu16", header: "immintrin.h".}
 74 |   ## Exposes _mm256_adds_epu16 intrinsics
 75 | 
 76 | proc and_si*(a: m256i, b: m256i): m256i
 77 |   {.importc: "_mm256_and_si256", header: "immintrin.h".}
 78 |   ## Exposes _mm256_and_si256 intrinsics
 79 | 
 80 | proc andnot_si*(a: m256i, b: m256i): m256i
 81 |   {.importc: "_mm256_andnot_si256", header: "immintrin.h".}
 82 |   ## Exposes _mm256_andnot_si256 intrinsics
 83 | 
 84 | proc avg_epu8*(a: m256i, b: m256i): m256i
 85 |   {.importc: "_mm256_avg_epu8", header: "immintrin.h".}
 86 |   ## Exposes _mm256_avg_epu8 intrinsics
 87 | 
 88 | proc avg_epu16*(a: m256i, b: m256i): m256i
 89 |   {.importc: "_mm256_avg_epu16", header: "immintrin.h".}
 90 |   ## Exposes _mm256_avg_epu16 intrinsics
 91 | 
 92 | proc blendv_epi8*(V1: m256i, V2: m256i, M: m256i): m256i
 93 |   {.importc: "_mm256_blendv_epi8", header: "immintrin.h".}
 94 |   ## Exposes _mm256_blendv_epi8 intrinsics
 95 | 
 96 | proc cmpeq_epi8*(a: m256i, b: m256i): m256i
 97 |   {.importc: "_mm256_cmpeq_epi8", header: "immintrin.h".}
 98 |   ## Exposes _mm256_cmpeq_epi8 intrinsics
 99 | 
100 | proc cmpeq_epi16*(a: m256i, b: m256i): m256i
101 |   {.importc: "_mm256_cmpeq_epi16", header: "immintrin.h".}
102 |   ## Exposes _mm256_cmpeq_epi16 intrinsics
103 | 
104 | proc cmpeq_epi32*(a: m256i, b: m256i): m256i
105 |   {.importc: "_mm256_cmpeq_epi32", header: "immintrin.h".}
106 |   ## Exposes _mm256_cmpeq_epi32 intrinsics
107 | 
108 | proc cmpeq_epi64*(a: m256i, b: m256i): m256i
109 |   {.importc: "_mm256_cmpeq_epi64", header: "immintrin.h".}
110 |   ## Exposes _mm256_cmpeq_epi64 intrinsics
111 | 
112 | proc cmpgt_epi8*(a: m256i, b: m256i): m256i
113 |   {.importc: "_mm256_cmpgt_epi8", header: "immintrin.h".}
114 |   ## Exposes _mm256_cmpgt_epi8 intrinsics
115 | 
116 | proc cmpgt_epi16*(a: m256i, b: m256i): m256i
117 |   {.importc: "_mm256_cmpgt_epi16", header: "immintrin.h".}
118 |   ## Exposes _mm256_cmpgt_epi16 intrinsics
119 | 
120 | proc cmpgt_epi32*(a: m256i, b: m256i): m256i
121 |   {.importc: "_mm256_cmpgt_epi32", header: "immintrin.h".}
122 |   ## Exposes _mm256_cmpgt_epi32 intrinsics
123 | 
124 | proc cmpgt_epi64*(a: m256i, b: m256i): m256i
125 |   {.importc: "_mm256_cmpgt_epi64", header: "immintrin.h".}
126 |   ## Exposes _mm256_cmpgt_epi64 intrinsics
127 | 
128 | proc hadd_epi16*(a: m256i, b: m256i): m256i
129 |   {.importc: "_mm256_hadd_epi16", header: "immintrin.h".}
130 |   ## Exposes _mm256_hadd_epi16 intrinsics
131 | 
132 | proc hadd_epi32*(a: m256i, b: m256i): m256i
133 |   {.importc: "_mm256_hadd_epi32", header: "immintrin.h".}
134 |   ## Exposes _mm256_hadd_epi32 intrinsics
135 | 
136 | proc hadds_epi16*(a: m256i, b: m256i): m256i
137 |   {.importc: "_mm256_hadds_epi16", header: "immintrin.h".}
138 |   ## Exposes _mm256_hadds_epi16 intrinsics
139 | 
140 | proc hsub_epi16*(a: m256i, b: m256i): m256i
141 |   {.importc: "_mm256_hsub_epi16", header: "immintrin.h".}
142 |   ## Exposes _mm256_hsub_epi16 intrinsics
143 | 
144 | proc hsub_epi32*(a: m256i, b: m256i): m256i
145 |   {.importc: "_mm256_hsub_epi32", header: "immintrin.h".}
146 |   ## Exposes _mm256_hsub_epi32 intrinsics
147 | 
148 | proc hsubs_epi16*(a: m256i, b: m256i): m256i
149 |   {.importc: "_mm256_hsubs_epi16", header: "immintrin.h".}
150 |   ## Exposes _mm256_hsubs_epi16 intrinsics
151 | 
152 | proc maddubs_epi16*(a: m256i, b: m256i): m256i
153 |   {.importc: "_mm256_maddubs_epi16", header: "immintrin.h".}
154 |   ## Exposes _mm256_maddubs_epi16 intrinsics
155 | 
156 | proc madd_epi16*(a: m256i, b: m256i): m256i
157 |   {.importc: "_mm256_madd_epi16", header: "immintrin.h".}
158 |   ## Exposes _mm256_madd_epi16 intrinsics
159 | 
160 | proc max_epi8*(a: m256i, b: m256i): m256i
161 |   {.importc: "_mm256_max_epi8", header: "immintrin.h".}
162 |   ## Exposes _mm256_max_epi8 intrinsics
163 | 
164 | proc max_epi16*(a: m256i, b: m256i): m256i
165 |   {.importc: "_mm256_max_epi16", header: "immintrin.h".}
166 |   ## Exposes _mm256_max_epi16 intrinsics
167 | 
168 | proc max_epi32*(a: m256i, b: m256i): m256i
169 |   {.importc: "_mm256_max_epi32", header: "immintrin.h".}
170 |   ## Exposes _mm256_max_epi32 intrinsics
171 | 
172 | proc max_epu8*(a: m256i, b: m256i): m256i
173 |   {.importc: "_mm256_max_epu8", header: "immintrin.h".}
174 |   ## Exposes _mm256_max_epu8 intrinsics
175 | 
176 | proc max_epu16*(a: m256i, b: m256i): m256i
177 |   {.importc: "_mm256_max_epu16", header: "immintrin.h".}
178 |   ## Exposes _mm256_max_epu16 intrinsics
179 | 
180 | proc max_epu32*(a: m256i, b: m256i): m256i
181 |   {.importc: "_mm256_max_epu32", header: "immintrin.h".}
182 |   ## Exposes _mm256_max_epu32 intrinsics
183 | 
184 | proc min_epi8*(a: m256i, b: m256i): m256i
185 |   {.importc: "_mm256_min_epi8", header: "immintrin.h".}
186 |   ## Exposes _mm256_min_epi8 intrinsics
187 | 
188 | proc min_epi16*(a: m256i, b: m256i): m256i
189 |   {.importc: "_mm256_min_epi16", header: "immintrin.h".}
190 |   ## Exposes _mm256_min_epi16 intrinsics
191 | 
192 | proc min_epi32*(a: m256i, b: m256i): m256i
193 |   {.importc: "_mm256_min_epi32", header: "immintrin.h".}
194 |   ## Exposes _mm256_min_epi32 intrinsics
195 | 
196 | proc min_epu8*(a: m256i, b: m256i): m256i
197 |   {.importc: "_mm256_min_epu8", header: "immintrin.h".}
198 |   ## Exposes _mm256_min_epu8 intrinsics
199 | 
200 | proc min_epu16*(a: m256i, b: m256i): m256i
201 |   {.importc: "_mm256_min_epu16", header: "immintrin.h".}
202 |   ## Exposes _mm256_min_epu16 intrinsics
203 | 
204 | proc min_epu32*(a: m256i, b: m256i): m256i
205 |   {.importc: "_mm256_min_epu32", header: "immintrin.h".}
206 |   ## Exposes _mm256_min_epu32 intrinsics
207 | 
208 | proc movemask_epi8*(a: m256i): int32
209 |   {.importc: "_mm256_movemask_epi8", header: "immintrin.h".}
210 |   ## Exposes _mm256_movemask_epi8 intrinsics
211 | 
212 | proc cvtepi8_epi16*(V: m128i): m256i
213 |   {.importc: "_mm256_cvtepi8_epi16", header: "immintrin.h".}
214 |   ## Exposes _mm256_cvtepi8_epi16 intrinsics
215 | 
216 | proc cvtepi8_epi32*(V: m128i): m256i
217 |   {.importc: "_mm256_cvtepi8_epi32", header: "immintrin.h".}
218 |   ## Exposes _mm256_cvtepi8_epi32 intrinsics
219 | 
220 | proc cvtepi8_epi64*(V: m128i): m256i
221 |   {.importc: "_mm256_cvtepi8_epi64", header: "immintrin.h".}
222 |   ## Exposes _mm256_cvtepi8_epi64 intrinsics
223 | 
224 | proc cvtepi16_epi32*(V: m128i): m256i
225 |   {.importc: "_mm256_cvtepi16_epi32", header: "immintrin.h".}
226 |   ## Exposes _mm256_cvtepi16_epi32 intrinsics
227 | 
228 | proc cvtepi16_epi64*(V: m128i): m256i
229 |   {.importc: "_mm256_cvtepi16_epi64", header: "immintrin.h".}
230 |   ## Exposes _mm256_cvtepi16_epi64 intrinsics
231 | 
232 | proc cvtepi32_epi64*(V: m128i): m256i
233 |   {.importc: "_mm256_cvtepi32_epi64", header: "immintrin.h".}
234 |   ## Exposes _mm256_cvtepi32_epi64 intrinsics
235 | 
236 | proc cvtepu8_epi16*(V: m128i): m256i
237 |   {.importc: "_mm256_cvtepu8_epi16", header: "immintrin.h".}
238 |   ## Exposes _mm256_cvtepu8_epi16 intrinsics
239 | 
240 | proc cvtepu8_epi32*(V: m128i): m256i
241 |   {.importc: "_mm256_cvtepu8_epi32", header: "immintrin.h".}
242 |   ## Exposes _mm256_cvtepu8_epi32 intrinsics
243 | 
244 | proc cvtepu8_epi64*(V: m128i): m256i
245 |   {.importc: "_mm256_cvtepu8_epi64", header: "immintrin.h".}
246 |   ## Exposes _mm256_cvtepu8_epi64 intrinsics
247 | 
248 | proc cvtepu16_epi32*(V: m128i): m256i
249 |   {.importc: "_mm256_cvtepu16_epi32", header: "immintrin.h".}
250 |   ## Exposes _mm256_cvtepu16_epi32 intrinsics
251 | 
252 | proc cvtepu16_epi64*(V: m128i): m256i
253 |   {.importc: "_mm256_cvtepu16_epi64", header: "immintrin.h".}
254 |   ## Exposes _mm256_cvtepu16_epi64 intrinsics
255 | 
256 | proc cvtepu32_epi64*(V: m128i): m256i
257 |   {.importc: "_mm256_cvtepu32_epi64", header: "immintrin.h".}
258 |   ## Exposes _mm256_cvtepu32_epi64 intrinsics
259 | 
260 | proc mul_epi32*(a: m256i, b: m256i): m256i
261 |   {.importc: "_mm256_mul_epi32", header: "immintrin.h".}
262 |   ## Exposes _mm256_mul_epi32 intrinsics
263 | 
264 | proc mulhrs_epi16*(a: m256i, b: m256i): m256i
265 |   {.importc: "_mm256_mulhrs_epi16", header: "immintrin.h".}
266 |   ## Exposes _mm256_mulhrs_epi16 intrinsics
267 | 
268 | proc mulhi_epu16*(a: m256i, b: m256i): m256i
269 |   {.importc: "_mm256_mulhi_epu16", header: "immintrin.h".}
270 |   ## Exposes _mm256_mulhi_epu16 intrinsics
271 | 
272 | proc mulhi_epi16*(a: m256i, b: m256i): m256i
273 |   {.importc: "_mm256_mulhi_epi16", header: "immintrin.h".}
274 |   ## Exposes _mm256_mulhi_epi16 intrinsics
275 | 
276 | proc mullo_epi16*(a: m256i, b: m256i): m256i
277 |   {.importc: "_mm256_mullo_epi16", header: "immintrin.h".}
278 |   ## Exposes _mm256_mullo_epi16 intrinsics
279 | 
280 | proc mullo_epi32*(a: m256i, b: m256i): m256i
281 |   {.importc: "_mm256_mullo_epi32", header: "immintrin.h".}
282 |   ## Exposes _mm256_mullo_epi32 intrinsics
283 | 
284 | proc mul_epu32*(a: m256i, b: m256i): m256i
285 |   {.importc: "_mm256_mul_epu32", header: "immintrin.h".}
286 |   ## Exposes _mm256_mul_epu32 intrinsics
287 | 
288 | proc or_si*(a: m256i, b: m256i): m256i
289 |   {.importc: "_mm256_or_si256", header: "immintrin.h".}
290 |   ## Exposes _mm256_or_si256 intrinsics
291 | 
292 | proc sad_epu8*(a: m256i, b: m256i): m256i
293 |   {.importc: "_mm256_sad_epu8", header: "immintrin.h".}
294 |   ## Exposes _mm256_sad_epu8 intrinsics
295 | 
296 | proc shuffle_epi8*(a: m256i, b: m256i): m256i
297 |   {.importc: "_mm256_shuffle_epi8", header: "immintrin.h".}
298 |   ## Exposes _mm256_shuffle_epi8 intrinsics
299 | 
300 | proc sign_epi8*(a: m256i, b: m256i): m256i
301 |   {.importc: "_mm256_sign_epi8", header: "immintrin.h".}
302 |   ## Exposes _mm256_sign_epi8 intrinsics
303 | 
304 | proc sign_epi16*(a: m256i, b: m256i): m256i
305 |   {.importc: "_mm256_sign_epi16", header: "immintrin.h".}
306 |   ## Exposes _mm256_sign_epi16 intrinsics
307 | 
308 | proc sign_epi32*(a: m256i, b: m256i): m256i
309 |   {.importc: "_mm256_sign_epi32", header: "immintrin.h".}
310 |   ## Exposes _mm256_sign_epi32 intrinsics
311 | 
312 | proc slli_epi16*(a: m256i, count: int32): m256i
313 |   {.importc: "_mm256_slli_epi16", header: "immintrin.h".}
314 |   ## Exposes _mm256_slli_epi16 intrinsics
315 | 
316 | proc sll_epi16*(a: m256i, count: m128i): m256i
317 |   {.importc: "_mm256_sll_epi16", header: "immintrin.h".}
318 |   ## Exposes _mm256_sll_epi16 intrinsics
319 | 
320 | proc slli_epi32*(a: m256i, count: int32): m256i
321 |   {.importc: "_mm256_slli_epi32", header: "immintrin.h".}
322 |   ## Exposes _mm256_slli_epi32 intrinsics
323 | 
324 | proc sll_epi32*(a: m256i, count: m128i): m256i
325 |   {.importc: "_mm256_sll_epi32", header: "immintrin.h".}
326 |   ## Exposes _mm256_sll_epi32 intrinsics
327 | 
328 | proc slli_epi64*(a: m256i, count: int32): m256i
329 |   {.importc: "_mm256_slli_epi64", header: "immintrin.h".}
330 |   ## Exposes _mm256_slli_epi64 intrinsics
331 | 
332 | proc sll_epi64*(a: m256i, count: m128i): m256i
333 |   {.importc: "_mm256_sll_epi64", header: "immintrin.h".}
334 |   ## Exposes _mm256_sll_epi64 intrinsics
335 | 
336 | proc srai_epi16*(a: m256i, count: int32): m256i
337 |   {.importc: "_mm256_srai_epi16", header: "immintrin.h".}
338 |   ## Exposes _mm256_srai_epi16 intrinsics
339 | 
340 | proc sra_epi16*(a: m256i, count: m128i): m256i
341 |   {.importc: "_mm256_sra_epi16", header: "immintrin.h".}
342 |   ## Exposes _mm256_sra_epi16 intrinsics
343 | 
344 | proc srai_epi32*(a: m256i, count: int32): m256i
345 |   {.importc: "_mm256_srai_epi32", header: "immintrin.h".}
346 |   ## Exposes _mm256_srai_epi32 intrinsics
347 | 
348 | proc sra_epi32*(a: m256i, count: m128i): m256i
349 |   {.importc: "_mm256_sra_epi32", header: "immintrin.h".}
350 |   ## Exposes _mm256_sra_epi32 intrinsics
351 | 
352 | proc srli_epi16*(a: m256i, count: int32): m256i
353 |   {.importc: "_mm256_srli_epi16", header: "immintrin.h".}
354 |   ## Exposes _mm256_srli_epi16 intrinsics
355 | 
356 | proc srl_epi16*(a: m256i, count: m128i): m256i
357 |   {.importc: "_mm256_srl_epi16", header: "immintrin.h".}
358 |   ## Exposes _mm256_srl_epi16 intrinsics
359 | 
360 | proc srli_epi32*(a: m256i, count: int32): m256i
361 |   {.importc: "_mm256_srli_epi32", header: "immintrin.h".}
362 |   ## Exposes _mm256_srli_epi32 intrinsics
363 | 
364 | proc srl_epi32*(a: m256i, count: m128i): m256i
365 |   {.importc: "_mm256_srl_epi32", header: "immintrin.h".}
366 |   ## Exposes _mm256_srl_epi32 intrinsics
367 | 
368 | proc srli_epi64*(a: m256i, count: int32): m256i
369 |   {.importc: "_mm256_srli_epi64", header: "immintrin.h".}
370 |   ## Exposes _mm256_srli_epi64 intrinsics
371 | 
372 | proc srl_epi64*(a: m256i, count: m128i): m256i
373 |   {.importc: "_mm256_srl_epi64", header: "immintrin.h".}
374 |   ## Exposes _mm256_srl_epi64 intrinsics
375 | 
376 | proc sub_epi8*(a: m256i, b: m256i): m256i
377 |   {.importc: "_mm256_sub_epi8", header: "immintrin.h".}
378 |   ## Exposes _mm256_sub_epi8 intrinsics
379 | 
380 | proc sub_epi16*(a: m256i, b: m256i): m256i
381 |   {.importc: "_mm256_sub_epi16", header: "immintrin.h".}
382 |   ## Exposes _mm256_sub_epi16 intrinsics
383 | 
384 | proc sub_epi32*(a: m256i, b: m256i): m256i
385 |   {.importc: "_mm256_sub_epi32", header: "immintrin.h".}
386 |   ## Exposes _mm256_sub_epi32 intrinsics
387 | 
388 | proc sub_epi64*(a: m256i, b: m256i): m256i
389 |   {.importc: "_mm256_sub_epi64", header: "immintrin.h".}
390 |   ## Exposes _mm256_sub_epi64 intrinsics
391 | 
392 | proc subs_epi8*(a: m256i, b: m256i): m256i
393 |   {.importc: "_mm256_subs_epi8", header: "immintrin.h".}
394 |   ## Exposes _mm256_subs_epi8 intrinsics
395 | 
396 | proc subs_epi16*(a: m256i, b: m256i): m256i
397 |   {.importc: "_mm256_subs_epi16", header: "immintrin.h".}
398 |   ## Exposes _mm256_subs_epi16 intrinsics
399 | 
400 | proc subs_epu8*(a: m256i, b: m256i): m256i
401 |   {.importc: "_mm256_subs_epu8", header: "immintrin.h".}
402 |   ## Exposes _mm256_subs_epu8 intrinsics
403 | 
404 | proc subs_epu16*(a: m256i, b: m256i): m256i
405 |   {.importc: "_mm256_subs_epu16", header: "immintrin.h".}
406 |   ## Exposes _mm256_subs_epu16 intrinsics
407 | 
408 | proc unpackhi_epi8*(a: m256i, b: m256i): m256i
409 |   {.importc: "_mm256_unpackhi_epi8", header: "immintrin.h".}
410 |   ## Exposes _mm256_unpackhi_epi8 intrinsics
411 | 
412 | proc unpackhi_epi16*(a: m256i, b: m256i): m256i
413 |   {.importc: "_mm256_unpackhi_epi16", header: "immintrin.h".}
414 |   ## Exposes _mm256_unpackhi_epi16 intrinsics
415 | 
416 | proc unpackhi_epi32*(a: m256i, b: m256i): m256i
417 |   {.importc: "_mm256_unpackhi_epi32", header: "immintrin.h".}
418 |   ## Exposes _mm256_unpackhi_epi32 intrinsics
419 | 
420 | proc unpackhi_epi64*(a: m256i, b: m256i): m256i
421 |   {.importc: "_mm256_unpackhi_epi64", header: "immintrin.h".}
422 |   ## Exposes _mm256_unpackhi_epi64 intrinsics
423 | 
424 | proc unpacklo_epi8*(a: m256i, b: m256i): m256i
425 |   {.importc: "_mm256_unpacklo_epi8", header: "immintrin.h".}
426 |   ## Exposes _mm256_unpacklo_epi8 intrinsics
427 | 
428 | proc unpacklo_epi16*(a: m256i, b: m256i): m256i
429 |   {.importc: "_mm256_unpacklo_epi16", header: "immintrin.h".}
430 |   ## Exposes _mm256_unpacklo_epi16 intrinsics
431 | 
432 | proc unpacklo_epi32*(a: m256i, b: m256i): m256i
433 |   {.importc: "_mm256_unpacklo_epi32", header: "immintrin.h".}
434 |   ## Exposes _mm256_unpacklo_epi32 intrinsics
435 | 
436 | proc unpacklo_epi64*(a: m256i, b: m256i): m256i
437 |   {.importc: "_mm256_unpacklo_epi64", header: "immintrin.h".}
438 |   ## Exposes _mm256_unpacklo_epi64 intrinsics
439 | 
440 | proc xor_si256*(a: m256i, b: m256i): m256i
441 |   {.importc: "_mm256_xor_si256", header: "immintrin.h".}
442 |   ## Exposes _mm256_xor_si256 intrinsics
443 | 
444 | proc stream_load_si256*(V: ptr m256i): m256i
445 |   {.importc: "_mm256_stream_load_si256", header: "immintrin.h".}
446 |   ## Exposes _mm256_stream_load_si256 intrinsics
447 | 
448 | proc broadcastss_ps*(X: m128): m128
449 |   {.importc: "_mm_broadcastss_ps", header: "immintrin.h".}
450 |   ## Exposes _mm_broadcastss_ps intrinsics
451 | 
452 | proc broadcastss_ps_256*(X: m128): m256
453 |   {.importc: "_mm256_broadcastss_ps", header: "immintrin.h".}
454 |   ## Exposes _mm256_broadcastss_ps intrinsics
455 | 
456 | proc broadcastsd_pd*(X: m128d): m256d
457 |   {.importc: "_mm256_broadcastsd_pd", header: "immintrin.h".}
458 |   ## Exposes _mm256_broadcastsd_pd intrinsics
459 | 
460 | proc broadcastsi128_si256*(X: m128i): m256i
461 |   {.importc: "_mm256_broadcastsi128_si256", header: "immintrin.h".}
462 |   ## Exposes _mm256_broadcastsi128_si256 intrinsics
463 | 
464 | proc broadcastb_epi8_256*(X: m128i): m256i
465 |   {.importc: "_mm256_broadcastb_epi8", header: "immintrin.h".}
466 |   ## Exposes _mm256_broadcastb_epi8 intrinsics
467 | 
468 | proc broadcastw_epi16_256*(X: m128i): m256i
469 |   {.importc: "_mm256_broadcastw_epi16", header: "immintrin.h".}
470 |   ## Exposes _mm256_broadcastw_epi16 intrinsics
471 | 
472 | proc broadcastd_epi32_256*(X: m128i): m256i
473 |   {.importc: "_mm256_broadcastd_epi32", header: "immintrin.h".}
474 |   ## Exposes _mm256_broadcastd_epi32 intrinsics
475 | 
476 | proc broadcastq_epi64_256*(X: m128i): m256i
477 |   {.importc: "_mm256_broadcastq_epi64", header: "immintrin.h".}
478 |   ## Exposes _mm256_broadcastq_epi64 intrinsics
479 | 
480 | proc broadcastb_epi8*(X: m128i): m128i
481 |   {.importc: "_mm_broadcastb_epi8", header: "immintrin.h".}
482 |   ## Exposes _mm_broadcastb_epi8 intrinsics
483 | 
484 | proc broadcastw_epi16*(X: m128i): m128i
485 |   {.importc: "_mm_broadcastw_epi16", header: "immintrin.h".}
486 |   ## Exposes _mm_broadcastw_epi16 intrinsics
487 | 
488 | proc broadcastd_epi32*(X: m128i): m128i
489 |   {.importc: "_mm_broadcastd_epi32", header: "immintrin.h".}
490 |   ## Exposes _mm_broadcastd_epi32 intrinsics
491 | 
492 | proc broadcastq_epi64*(X: m128i): m128i
493 |   {.importc: "_mm_broadcastq_epi64", header: "immintrin.h".}
494 |   ## Exposes _mm_broadcastq_epi64 intrinsics
495 | 
496 | proc permutevar8x32_epi32*(a: m256i, b: m256i): m256i
497 |   {.importc: "_mm256_permutevar8x32_epi32", header: "immintrin.h".}
498 |   ## Exposes _mm256_permutevar8x32_epi32 intrinsics
499 | 
500 | proc permutevar8x32_ps*(a: m256, b: m256i): m256
501 |   {.importc: "_mm256_permutevar8x32_ps", header: "immintrin.h".}
502 |   ## Exposes _mm256_permutevar8x32_ps intrinsics
503 | 
504 | proc maskload_epi32*(X: ptr int32, M: m256i): m256i
505 |   {.importc: "_mm256_maskload_epi32", header: "immintrin.h".}
506 |   ## Exposes _mm256_maskload_epi32 intrinsics
507 | 
508 | proc maskload_epi64*(X: ptr int64, M: m256i): m256i
509 |   {.importc: "_mm256_maskload_epi64", header: "immintrin.h".}
510 |   ## Exposes _mm256_maskload_epi64 intrinsics
511 | 
512 | proc maskload_epi32*(X: ptr int32, M: m128i): m128i
513 |   {.importc: "_mm_maskload_epi32", header: "immintrin.h".}
514 |   ## Exposes _mm_maskload_epi32 intrinsics
515 | 
516 | proc maskload_epi64*(X: ptr int64, M: m128i): m128i
517 |   {.importc: "_mm_maskload_epi64", header: "immintrin.h".}
518 |   ## Exposes _mm_maskload_epi64 intrinsics
519 | 
520 | proc maskstore_epi32*(X: ptr int32, M: m256i, Y: m256i): void
521 |   {.importc: "_mm256_maskstore_epi32", header: "immintrin.h".}
522 |   ## Exposes _mm256_maskstore_epi32 intrinsics
523 | 
524 | proc maskstore_epi64*(X: ptr int64, M: m256i, Y: m256i): void
525 |   {.importc: "_mm256_maskstore_epi64", header: "immintrin.h".}
526 |   ## Exposes _mm256_maskstore_epi64 intrinsics
527 | 
528 | proc maskstore_epi32*(X: ptr int32, M: m128i, Y: m128i): void
529 |   {.importc: "_mm_maskstore_epi32", header: "immintrin.h".}
530 |   ## Exposes _mm_maskstore_epi32 intrinsics
531 | 
532 | proc maskstore_epi64*(X: ptr int64, M: m128i, Y: m128i): void
533 |   {.importc: "_mm_maskstore_epi64", header: "immintrin.h".}
534 |   ## Exposes _mm_maskstore_epi64 intrinsics
535 | 
536 | proc sllv_epi32*(X: m256i, Y: m256i): m256i
537 |   {.importc: "_mm256_sllv_epi32", header: "immintrin.h".}
538 |   ## Exposes _mm256_sllv_epi32 intrinsics
539 | 
540 | proc sllv_epi32*(X: m128i, Y: m128i): m128i
541 |   {.importc: "_mm_sllv_epi32", header: "immintrin.h".}
542 |   ## Exposes _mm_sllv_epi32 intrinsics
543 | 
544 | proc sllv_epi64*(X: m256i, Y: m256i): m256i
545 |   {.importc: "_mm256_sllv_epi64", header: "immintrin.h".}
546 |   ## Exposes _mm256_sllv_epi64 intrinsics
547 | 
548 | proc sllv_epi64*(X: m128i, Y: m128i): m128i
549 |   {.importc: "_mm_sllv_epi64", header: "immintrin.h".}
550 |   ## Exposes _mm_sllv_epi64 intrinsics
551 | 
552 | proc srav_epi32*(X: m256i, Y: m256i): m256i
553 |   {.importc: "_mm256_srav_epi32", header: "immintrin.h".}
554 |   ## Exposes _mm256_srav_epi32 intrinsics
555 | 
556 | proc srav_epi32*(X: m128i, Y: m128i): m128i
557 |   {.importc: "_mm_srav_epi32", header: "immintrin.h".}
558 |   ## Exposes _mm_srav_epi32 intrinsics
559 | 
560 | proc srlv_epi32*(X: m256i, Y: m256i): m256i
561 |   {.importc: "_mm256_srlv_epi32", header: "immintrin.h".}
562 |   ## Exposes _mm256_srlv_epi32 intrinsics
563 | 
564 | proc srlv_epi32*(X: m128i, Y: m128i): m128i
565 |   {.importc: "_mm_srlv_epi32", header: "immintrin.h".}
566 |   ## Exposes _mm_srlv_epi32 intrinsics
567 | 
568 | proc srlv_epi64*(X: m256i, Y: m256i): m256i
569 |   {.importc: "_mm256_srlv_epi64", header: "immintrin.h".}
570 |   ## Exposes _mm256_srlv_epi64 intrinsics
571 | 
572 | proc srlv_epi64*(X: m128i, Y: m128i): m128i
573 |   {.importc: "_mm_srlv_epi64", header: "immintrin.h".}
574 |   ## Exposes _mm_srlv_epi64 intrinsics
575 | 
576 | proc mask_i32gather_pd*(def_vals: m128d, base: ptr float64, vindex: m128i, vmask: m128d, scale: int32): m128d
577 |   {.importc: "_mm_mask_i32gather_pd", header: "immintrin.h".}
578 |   ## Exposes _mm_mask_i32gather_pd intrinsics
579 | 
580 | proc mask_i32gather_pd*(def_vals: m256d, base: ptr float64, vindex: m128i, vmask: m256d, scale: int32): m256d
581 |   {.importc: "_mm256_mask_i32gather_pd", header: "immintrin.h".}
582 |   ## Exposes _mm256_mask_i32gather_pd intrinsics
583 | 
584 | proc i32gather_ps*(base: ptr float32, vindex: m256i, scale: int32): m256
585 |   {.importc: "_mm256_i32gather_ps", header: "immintrin.h".}
586 |   ## Exposes _mm_i32gather_ps intrinsics
587 | 
588 | proc i32gather_pd_128*(base: ptr float64, vindex: m128i, scale: int32): m128d
589 |   {.importc: "_mm_i32gather_pd", header: "immintrin.h".}
590 |   ## Exposes _mm_i32gather_pd intrinsics
591 | 
592 | proc i32gather_pd*(base: ptr float64, vindex: m128i, scale: int32): m256d
593 |   {.importc: "_mm256_i32gather_pd", header: "immintrin.h".}
594 |   ## Exposes _mm256_i32gather_pd intrinsics
595 | 
596 | proc mask_i64gather_pd*(def_vals: m128d, base: ptr float64, vindex: m128i, vmask: m128d, scale: int32): m128d
597 |   {.importc: "_mm_mask_i64gather_pd", header: "immintrin.h".}
598 |   ## Exposes _mm_mask_i64gather_pd intrinsics
599 | 
600 | proc mask_i64gather_pd*(def_vals: m256d, base: ptr float64, vindex: m256i, vmask: m256d, scale: int32): m256d
601 |   {.importc: "_mm256_mask_i64gather_pd", header: "immintrin.h".}
602 |   ## Exposes _mm256_mask_i64gather_pd intrinsics
603 | 
604 | proc i64gather_pd*(base: ptr float64, vindex: m128i, scale: int32): m128d
605 |   {.importc: "_mm_i64gather_pd", header: "immintrin.h".}
606 |   ## Exposes _mm_i64gather_pd intrinsics
607 | 
608 | proc mask_i32gather_ps*(def_vals: m128, base: ptr float32, vindex: m128i, vmask: m128, scale: int32): m128
609 |   {.importc: "_mm_mask_i32gather_ps", header: "immintrin.h".}
610 |   ## Exposes _mm_mask_i32gather_ps intrinsics
611 | 
612 | proc mask_i32gather_ps*(def_vals: m256, base: ptr float32, vindex: m256i, vmask: m256, scale: int32): m256
613 |   {.importc: "_mm256_mask_i32gather_ps", header: "immintrin.h".}
614 |   ## Exposes _mm256_mask_i32gather_ps intrinsics
615 | 
616 | proc mask_i64gather_ps*(src: m128, base: ptr float32, vindex: m128i, mask: m128, scale: int32): m128
617 |   {.importc: "_mm_mask_i64gather_ps", header: "immintrin.h".}
618 |   ## Exposes _mm_mask_i64gather_ps intrinsics
619 | 
620 | proc mask_i32gather_epi32*(def_vals: m128i, base: ptr int32, vindex: m128i, vmask: m128i, scale: int32): m128i
621 |   {.importc: "_mm_mask_i32gather_epi32", header: "immintrin.h".}
622 |   ## Exposes _mm_mask_i32gather_epi32 intrinsics
623 | 
624 | proc mask_i32gather_epi32*(def_vals: m256i, base: ptr int32, vindex: m256i, vmask: m256i, scale: int32): m256i
625 |   {.importc: "_mm256_mask_i32gather_epi32", header: "immintrin.h".}
626 |   ## Exposes _mm256_mask_i32gather_epi32 intrinsics
627 | 
628 | proc i32gather_epi32_128*(base: ptr int32, vindex: m128i, scale: int32): m128i
629 |   {.importc: "_mm_i32gather_epi32", header: "immintrin.h".}
630 |   ## Exposes _mm_i32gather_epi32 intrinsics
631 | 
632 | proc i32gather_epi32*(base: ptr int32, vindex: m256i, scale: int32): m256i
633 |   {.importc: "_mm256_i32gather_epi32", header: "immintrin.h".}
634 |   ## Exposes _mm256_i32gather_epi32 intrinsics
635 | 
636 | proc mask_i32gather_epi64*(def_vals: m128i, base: ptr int64, vindex: m128i, vmask: m128i, scale: int32): m128i
637 |   {.importc: "_mm_mask_i32gather_epi64", header: "immintrin.h".}
638 |   ## Exposes _mm_mask_i32gather_epi64 intrinsics
639 | 
640 | proc mask_i32gather_epi64*(def_vals: m256i, base: ptr int64, vindex: m128i, vmask: m256i, scale: int32): m256i
641 |   {.importc: "_mm256_mask_i32gather_epi64", header: "immintrin.h".}
642 |   ## Exposes _mm256_mask_i32gather_epi64 intrinsics
643 | 
644 | proc i32gather_epi64*(base: ptr int64, vindex: m128i, scale: int32): m128i
645 |   {.importc: "_mm_i32gather_epi64", header: "immintrin.h".}
646 |   ## Exposes _mm_i32gather_epi64 intrinsics
647 | 
648 | proc i32gather_epi64_256*(base: ptr int64, vindex: m128i, scale: int32): m256i
649 |   {.importc: "_mm256_i32gather_epi64", header: "immintrin.h".}
650 |   ## Exposes _mm256_i32gather_epi64 intrinsics
651 | 
652 | proc mask_i64gather_epi32*(def_vals: m128i, base: ptr int32, vindex: m128i, vmask: m128i, scale: int32): m128i
653 |   {.importc: "_mm_mask_i64gather_epi32", header: "immintrin.h".}
654 |   ## Exposes _mm_mask_i64gather_epi32 intrinsics
655 | 
656 | proc mask_i64gather_epi32*(def_vals: m128i, base: ptr int32, vindex: m256i, vmask: m128i, scale: int32): m128i
657 |   {.importc: "_mm256_mask_i64gather_epi32", header: "immintrin.h".}
658 |   ## Exposes _mm256_mask_i64gather_epi32 intrinsics
659 | 
660 | proc i64gather_epi32*(base: ptr int32, vindex: m128i, scale: int32): m128i
661 |   {.importc: "_mm_i64gather_epi32", header: "immintrin.h".}
662 |   ## Exposes _mm_i64gather_epi32 intrinsics
663 | 
664 | proc i64gather_epi32*(base: ptr int32, vindex: m256i, scale: int32): m128i
665 |   {.importc: "_mm256_i64gather_epi32", header: "immintrin.h".}
666 |   ## Exposes _mm256_i64gather_epi32 intrinsics
667 | 
668 | proc mask_i64gather_epi64*(def_vals: m128i, base: ptr int64, vindex: m128i, vmask: m128i, scale: int32): m128i
669 |   {.importc: "_mm_mask_i64gather_epi64", header: "immintrin.h".}
670 |   ## Exposes _mm_mask_i64gather_epi64 intrinsics
671 | 
672 | proc mask_i64gather_epi64*(def_vals: m256i, base: ptr int64, vindex: m256i, vmask: m256i, scale: int32): m256i
673 |   {.importc: "_mm256_mask_i64gather_epi64", header: "immintrin.h".}
674 |   ## Exposes _mm256_mask_i64gather_epi64 intrinsics
675 | 
676 | proc i64gather_epi64*(base: ptr int64, vindex: m128i, scale: int32): m128i
677 |   {.importc: "_mm_i64gather_epi64", header: "immintrin.h".}
678 |   ## Exposes _mm_i64gather_epi64 intrinsics
679 | 
680 | proc i64gather_epi64*(base: ptr int64, vindex: m256i, scale: int32): m256i
681 |   {.importc: "_mm256_i64gather_epi64", header: "immintrin.h".}
682 |   ## Exposes _mm256_i64gather_epi64 intrinsics
683 | 
684 | proc alignr_epi8*(a: m256i, b: m256i, c: int32): m256i
685 |   {.importc: "_mm256_alignr_epi8", header: "immintrin.h".}
686 |   ## Exposes _mm256_alignr_epi8 intrinsics
687 | 
688 | proc blend_epi16*(a: m256i, b: m256i, c: int32): m256i
689 |   {.importc: "_mm256_blend_epi16", header: "immintrin.h".}
690 |   ## Exposes _mm256_blend_epi16 intrinsics
691 | 
692 | proc shuffle_epi32*(a: m256i, b: int32): m256i
693 |   {.importc: "_mm256_shuffle_epi32", header: "immintrin.h".}
694 |   ## Exposes _mm256_shuffle_epi32 intrinsics
695 | 
696 | proc shufflehi_epi16*(a: m256i, b: int32): m256i
697 |   {.importc: "_mm256_shufflehi_epi16", header: "immintrin.h".}
698 |   ## Exposes _mm256_shufflehi_epi16 intrinsics
699 | 
700 | proc shufflelo_epi16*(a: m256i, b: int32): m256i
701 |   {.importc: "_mm256_shufflelo_epi16", header: "immintrin.h".}
702 |   ## Exposes _mm256_shufflelo_epi16 intrinsics
703 | 
704 | proc slli_si256*(a: m256i, b: int32): m256i
705 |   {.importc: "_mm256_slli_si256", header: "immintrin.h".}
706 |   ## Exposes _mm256_slli_si256 intrinsics
707 | 
708 | proc srli_si256*(a: m256i, b: int32): m256i
709 |   {.importc: "_mm256_srli_si256", header: "immintrin.h".}
710 |   ## Exposes _mm256_srli_si256 intrinsics
711 | 
712 | proc blend_epi32*(a: m128i, b: m128i, c: int32): m128i
713 |   {.importc: "_mm_blend_epi32", header: "immintrin.h".}
714 |   ## Exposes _mm_blend_epi32 intrinsics
715 | 
716 | proc blend_epi32*(a: m256i, b: m256i, c: int32): m256i
717 |   {.importc: "_mm256_blend_epi32", header: "immintrin.h".}
718 |   ## Exposes _mm256_blend_epi32 intrinsics
719 | 
720 | proc permute4x64_pd*(a: m256d, b: int32): m256d
721 |   {.importc: "_mm256_permute4x64_pd", header: "immintrin.h".}
722 |   ## Exposes _mm256_permute4x64_pd intrinsics
723 | 
724 | proc permute4x64_epi64*(a: m256i, b: int32): m256i
725 |   {.importc: "_mm256_permute4x64_epi64", header: "immintrin.h".}
726 |   ## Exposes _mm256_permute4x64_epi64 intrinsics
727 | 
728 | proc permute2x128_si256*(a: m256i, b: m256i, c: int32): m256i
729 |   {.importc: "_mm256_permute2x128_si256", header: "immintrin.h".}
730 |   ## Exposes _mm256_permute2x128_si256 intrinsics
731 | 
732 | proc extracti128_si256*(a: m256i, b: int32): m128i
733 |   {.importc: "_mm256_extracti128_si256", header: "immintrin.h".}
734 |   ## Exposes _mm256_extracti128_si256 intrinsics
735 | 
736 | proc inserti128_si256*(a: m256i, b: m128i, c: int32): m256i
737 |   {.importc: "_mm256_inserti128_si256", header: "immintrin.h".}
738 |   ## Exposes _mm256_inserti128_si256 intrinsics
739 | 
740 | 


--------------------------------------------------------------------------------
/src/nimsimd/mmx.nim:
--------------------------------------------------------------------------------
  1 | #
  2 | #
  3 | #          Nimrod's x86 mmx intrinsics
  4 | #        (c) Copyright 2014 Ben Segovia
  5 | #
  6 | #    See the file copying.txt, included in this
  7 | #    distribution, for details about the copyright.
  8 | #
  9 | 
 10 | # MSVC does not support MMX on 64 bits target
 11 | const vcc64Bits* = defined(vcc) and defined(x86_64)
 12 | 
 13 | when not vcc64Bits:
 14 |   type m64* {.importc: "__m64", header: "mmintrin.h".} = object
 15 | 
 16 |   proc empty*(): void
 17 |     {.importc: "_mm_empty", header: "mmintrin.h".}
 18 |     ## Exposes _mm_empty intrinsics
 19 | 
 20 |   proc cvtsi32_si64*(i: int32): m64
 21 |     {.importc: "_mm_cvtsi32_si64", header: "mmintrin.h".}
 22 |     ## Exposes _mm_cvtsi32_si64 intrinsics
 23 | 
 24 |   proc cvtsi64_si32*(m: m64): int32
 25 |     {.importc: "_mm_cvtsi64_si32", header: "mmintrin.h".}
 26 |     ## Exposes _mm_cvtsi64_si32 intrinsics
 27 | 
 28 |   proc packs_pi16*(m1: m64, m2: m64): m64
 29 |     {.importc: "_mm_packs_pi16", header: "mmintrin.h".}
 30 |     ## Exposes _mm_packs_pi16 intrinsics
 31 | 
 32 |   proc packs_pi32*(m1: m64, m2: m64): m64
 33 |     {.importc: "_mm_packs_pi32", header: "mmintrin.h".}
 34 |     ## Exposes _mm_packs_pi32 intrinsics
 35 | 
 36 |   proc packs_pu16*(m1: m64, m2: m64): m64
 37 |     {.importc: "_mm_packs_pu16", header: "mmintrin.h".}
 38 |     ## Exposes _mm_packs_pu16 intrinsics
 39 | 
 40 |   proc unpackhi_pi8*(m1: m64, m2: m64): m64
 41 |     {.importc: "_mm_unpackhi_pi8", header: "mmintrin.h".}
 42 |     ## Exposes _mm_unpackhi_pi8 intrinsics
 43 | 
 44 |   proc unpackhi_pi16*(m1: m64, m2: m64): m64
 45 |     {.importc: "_mm_unpackhi_pi16", header: "mmintrin.h".}
 46 |     ## Exposes _mm_unpackhi_pi16 intrinsics
 47 | 
 48 |   proc unpackhi_pi32*(m1: m64, m2: m64): m64
 49 |     {.importc: "_mm_unpackhi_pi32", header: "mmintrin.h".}
 50 |     ## Exposes _mm_unpackhi_pi32 intrinsics
 51 | 
 52 |   proc unpacklo_pi8*(m1: m64, m2: m64): m64
 53 |     {.importc: "_mm_unpacklo_pi8", header: "mmintrin.h".}
 54 |     ## Exposes _mm_unpacklo_pi8 intrinsics
 55 | 
 56 |   proc unpacklo_pi16*(m1: m64, m2: m64): m64
 57 |     {.importc: "_mm_unpacklo_pi16", header: "mmintrin.h".}
 58 |     ## Exposes _mm_unpacklo_pi16 intrinsics
 59 | 
 60 |   proc unpacklo_pi32*(m1: m64, m2: m64): m64
 61 |     {.importc: "_mm_unpacklo_pi32", header: "mmintrin.h".}
 62 |     ## Exposes _mm_unpacklo_pi32 intrinsics
 63 | 
 64 |   proc add_pi8*(m1: m64, m2: m64): m64
 65 |     {.importc: "_mm_add_pi8", header: "mmintrin.h".}
 66 |     ## Exposes _mm_add_pi8 intrinsics
 67 | 
 68 |   proc add_pi16*(m1: m64, m2: m64): m64
 69 |     {.importc: "_mm_add_pi16", header: "mmintrin.h".}
 70 |     ## Exposes _mm_add_pi16 intrinsics
 71 | 
 72 |   proc add_pi32*(m1: m64, m2: m64): m64
 73 |     {.importc: "_mm_add_pi32", header: "mmintrin.h".}
 74 |     ## Exposes _mm_add_pi32 intrinsics
 75 | 
 76 |   proc adds_pi8*(m1: m64, m2: m64): m64
 77 |     {.importc: "_mm_adds_pi8", header: "mmintrin.h".}
 78 |     ## Exposes _mm_adds_pi8 intrinsics
 79 | 
 80 |   proc adds_pi16*(m1: m64, m2: m64): m64
 81 |     {.importc: "_mm_adds_pi16", header: "mmintrin.h".}
 82 |     ## Exposes _mm_adds_pi16 intrinsics
 83 | 
 84 |   proc adds_pu8*(m1: m64, m2: m64): m64
 85 |     {.importc: "_mm_adds_pu8", header: "mmintrin.h".}
 86 |     ## Exposes _mm_adds_pu8 intrinsics
 87 | 
 88 |   proc adds_pu16*(m1: m64, m2: m64): m64
 89 |     {.importc: "_mm_adds_pu16", header: "mmintrin.h".}
 90 |     ## Exposes _mm_adds_pu16 intrinsics
 91 | 
 92 |   proc sub_pi8*(m1: m64, m2: m64): m64
 93 |     {.importc: "_mm_sub_pi8", header: "mmintrin.h".}
 94 |     ## Exposes _mm_sub_pi8 intrinsics
 95 | 
 96 |   proc sub_pi16*(m1: m64, m2: m64): m64
 97 |     {.importc: "_mm_sub_pi16", header: "mmintrin.h".}
 98 |     ## Exposes _mm_sub_pi16 intrinsics
 99 | 
100 |   proc sub_pi32*(m1: m64, m2: m64): m64
101 |     {.importc: "_mm_sub_pi32", header: "mmintrin.h".}
102 |     ## Exposes _mm_sub_pi32 intrinsics
103 | 
104 |   proc subs_pi8*(m1: m64, m2: m64): m64
105 |     {.importc: "_mm_subs_pi8", header: "mmintrin.h".}
106 |     ## Exposes _mm_subs_pi8 intrinsics
107 | 
108 |   proc subs_pi16*(m1: m64, m2: m64): m64
109 |     {.importc: "_mm_subs_pi16", header: "mmintrin.h".}
110 |     ## Exposes _mm_subs_pi16 intrinsics
111 | 
112 |   proc subs_pu8*(m1: m64, m2: m64): m64
113 |     {.importc: "_mm_subs_pu8", header: "mmintrin.h".}
114 |     ## Exposes _mm_subs_pu8 intrinsics
115 | 
116 |   proc subs_pu16*(m1: m64, m2: m64): m64
117 |     {.importc: "_mm_subs_pu16", header: "mmintrin.h".}
118 |     ## Exposes _mm_subs_pu16 intrinsics
119 | 
120 |   proc madd_pi16*(m1: m64, m2: m64): m64
121 |     {.importc: "_mm_madd_pi16", header: "mmintrin.h".}
122 |     ## Exposes _mm_madd_pi16 intrinsics
123 | 
124 |   proc mulhi_pi16*(m1: m64, m2: m64): m64
125 |     {.importc: "_mm_mulhi_pi16", header: "mmintrin.h".}
126 |     ## Exposes _mm_mulhi_pi16 intrinsics
127 | 
128 |   proc mullo_pi16*(m1: m64, m2: m64): m64
129 |     {.importc: "_mm_mullo_pi16", header: "mmintrin.h".}
130 |     ## Exposes _mm_mullo_pi16 intrinsics
131 | 
132 |   proc sll_pi16*(m: m64, count: m64): m64
133 |     {.importc: "_mm_sll_pi16", header: "mmintrin.h".}
134 |     ## Exposes _mm_sll_pi16 intrinsics
135 | 
136 |   proc slli_pi16*(m: m64, count: int32): m64
137 |     {.importc: "_mm_slli_pi16", header: "mmintrin.h".}
138 |     ## Exposes _mm_slli_pi16 intrinsics
139 | 
140 |   proc sll_pi32*(m: m64, count: m64): m64
141 |     {.importc: "_mm_sll_pi32", header: "mmintrin.h".}
142 |     ## Exposes _mm_sll_pi32 intrinsics
143 | 
144 |   proc slli_pi32*(m: m64, count: int32): m64
145 |     {.importc: "_mm_slli_pi32", header: "mmintrin.h".}
146 |     ## Exposes _mm_slli_pi32 intrinsics
147 | 
148 |   proc sll_si64*(m: m64, count: m64): m64
149 |     {.importc: "_mm_sll_si64", header: "mmintrin.h".}
150 |     ## Exposes _mm_sll_si64 intrinsics
151 | 
152 |   proc slli_si64*(m: m64, count: int32): m64
153 |     {.importc: "_mm_slli_si64", header: "mmintrin.h".}
154 |     ## Exposes _mm_slli_si64 intrinsics
155 | 
156 |   proc sra_pi16*(m: m64, count: m64): m64
157 |     {.importc: "_mm_sra_pi16", header: "mmintrin.h".}
158 |     ## Exposes _mm_sra_pi16 intrinsics
159 | 
160 |   proc srai_pi16*(m: m64, count: int32): m64
161 |     {.importc: "_mm_srai_pi16", header: "mmintrin.h".}
162 |     ## Exposes _mm_srai_pi16 intrinsics
163 | 
164 |   proc sra_pi32*(m: m64, count: m64): m64
165 |     {.importc: "_mm_sra_pi32", header: "mmintrin.h".}
166 |     ## Exposes _mm_sra_pi32 intrinsics
167 | 
168 |   proc srai_pi32*(m: m64, count: int32): m64
169 |     {.importc: "_mm_srai_pi32", header: "mmintrin.h".}
170 |     ## Exposes _mm_srai_pi32 intrinsics
171 | 
172 |   proc srl_pi16*(m: m64, count: m64): m64
173 |     {.importc: "_mm_srl_pi16", header: "mmintrin.h".}
174 |     ## Exposes _mm_srl_pi16 intrinsics
175 | 
176 |   proc srli_pi16*(m: m64, count: int32): m64
177 |     {.importc: "_mm_srli_pi16", header: "mmintrin.h".}
178 |     ## Exposes _mm_srli_pi16 intrinsics
179 | 
180 |   proc srl_pi32*(m: m64, count: m64): m64
181 |     {.importc: "_mm_srl_pi32", header: "mmintrin.h".}
182 |     ## Exposes _mm_srl_pi32 intrinsics
183 | 
184 |   proc srli_pi32*(m: m64, count: int32): m64
185 |     {.importc: "_mm_srli_pi32", header: "mmintrin.h".}
186 |     ## Exposes _mm_srli_pi32 intrinsics
187 | 
188 |   proc srl_si64*(m: m64, count: m64): m64
189 |     {.importc: "_mm_srl_si64", header: "mmintrin.h".}
190 |     ## Exposes _mm_srl_si64 intrinsics
191 | 
192 |   proc srli_si64*(m: m64, count: int32): m64
193 |     {.importc: "_mm_srli_si64", header: "mmintrin.h".}
194 |     ## Exposes _mm_srli_si64 intrinsics
195 | 
196 |   proc and_si64*(m1: m64, m2: m64): m64
197 |     {.importc: "_mm_and_si64", header: "mmintrin.h".}
198 |     ## Exposes _mm_and_si64 intrinsics
199 | 
200 |   proc andnot_si64*(m1: m64, m2: m64): m64
201 |     {.importc: "_mm_andnot_si64", header: "mmintrin.h".}
202 |     ## Exposes _mm_andnot_si64 intrinsics
203 | 
204 |   proc or_si64*(m1: m64, m2: m64): m64
205 |     {.importc: "_mm_or_si64", header: "mmintrin.h".}
206 |     ## Exposes _mm_or_si64 intrinsics
207 | 
208 |   proc xor_si64*(m1: m64, m2: m64): m64
209 |     {.importc: "_mm_xor_si64", header: "mmintrin.h".}
210 |     ## Exposes _mm_xor_si64 intrinsics
211 | 
212 |   proc cmpeq_pi8*(m1: m64, m2: m64): m64
213 |     {.importc: "_mm_cmpeq_pi8", header: "mmintrin.h".}
214 |     ## Exposes _mm_cmpeq_pi8 intrinsics
215 | 
216 |   proc cmpeq_pi16*(m1: m64, m2: m64): m64
217 |     {.importc: "_mm_cmpeq_pi16", header: "mmintrin.h".}
218 |     ## Exposes _mm_cmpeq_pi16 intrinsics
219 | 
220 |   proc cmpeq_pi32*(m1: m64, m2: m64): m64
221 |     {.importc: "_mm_cmpeq_pi32", header: "mmintrin.h".}
222 |     ## Exposes _mm_cmpeq_pi32 intrinsics
223 | 
224 |   proc cmpgt_pi8*(m1: m64, m2: m64): m64
225 |     {.importc: "_mm_cmpgt_pi8", header: "mmintrin.h".}
226 |     ## Exposes _mm_cmpgt_pi8 intrinsics
227 | 
228 |   proc cmpgt_pi16*(m1: m64, m2: m64): m64
229 |     {.importc: "_mm_cmpgt_pi16", header: "mmintrin.h".}
230 |     ## Exposes _mm_cmpgt_pi16 intrinsics
231 | 
232 |   proc cmpgt_pi32*(m1: m64, m2: m64): m64
233 |     {.importc: "_mm_cmpgt_pi32", header: "mmintrin.h".}
234 |     ## Exposes _mm_cmpgt_pi32 intrinsics
235 | 
236 |   proc setzero_si64*(): m64
237 |     {.importc: "_mm_setzero_si64", header: "mmintrin.h".}
238 |     ## Exposes _mm_setzero_si64 intrinsics
239 | 
240 |   proc set_pi32*(i1: int32, i0: int32): m64
241 |     {.importc: "_mm_set_pi32", header: "mmintrin.h".}
242 |     ## Exposes _mm_set_pi32 intrinsics
243 | 
244 |   proc set_pi16*(s3: int16, s2: int16, s1: int16, s0: int16): m64
245 |     {.importc: "_mm_set_pi16", header: "mmintrin.h".}
246 |     ## Exposes _mm_set_pi16 intrinsics
247 | 
248 |   proc set_pi8*(b7: int8, b6: int8, b5: int8, b4: int8, b3: int8, b2: int8, b1: int8, b0: int8): m64
249 |     {.importc: "_mm_set_pi8", header: "mmintrin.h".}
250 |     ## Exposes _mm_set_pi8 intrinsics
251 | 
252 |   proc set1_pi32*(i: int32): m64
253 |     {.importc: "_mm_set1_pi32", header: "mmintrin.h".}
254 |     ## Exposes _mm_set1_pi32 intrinsics
255 | 
256 |   proc set1_pi16*(w: int16): m64
257 |     {.importc: "_mm_set1_pi16", header: "mmintrin.h".}
258 |     ## Exposes _mm_set1_pi16 intrinsics
259 | 
260 |   proc set1_pi8*(b: int8): m64
261 |     {.importc: "_mm_set1_pi8", header: "mmintrin.h".}
262 |     ## Exposes _mm_set1_pi8 intrinsics
263 | 
264 |   proc setr_pi32*(i0: int32, i1: int32): m64
265 |     {.importc: "_mm_setr_pi32", header: "mmintrin.h".}
266 |     ## Exposes _mm_setr_pi32 intrinsics
267 | 
268 |   proc setr_pi16*(w0: int16, w1: int16, w2: int16, w3: int16): m64
269 |     {.importc: "_mm_setr_pi16", header: "mmintrin.h".}
270 |     ## Exposes _mm_setr_pi16 intrinsics
271 | 
272 |   proc setr_pi8*(b0: int8, b1: int8, b2: int8, b3: int8, b4: int8, b5: int8, b6: int8, b7: int8): m64
273 |     {.importc: "_mm_setr_pi8", header: "mmintrin.h".}
274 |     ## Exposes _mm_setr_pi8 intrinsics
275 | 
276 |   # Assert we generate proper C code
277 |   when isMainModule:
278 |     var myint32 : int32 = 2;
279 |     var mym64 = set1_pi32(1)
280 |     var argint8 : int8 = 1;
281 |     var argint16 : int16 = 2;
282 |     var argm64 = set1_pi32(1)
283 | 
284 |     empty()
285 |     mym64 = cvtsi32_si64(1)
286 |     myint32 = cvtsi64_si32(argm64)
287 |     mym64 = packs_pi16(argm64, argm64)
288 |     mym64 = packs_pi32(argm64, argm64)
289 |     mym64 = packs_pu16(argm64, argm64)
290 |     mym64 = unpackhi_pi8(argm64, argm64)
291 |     mym64 = unpackhi_pi16(argm64, argm64)
292 |     mym64 = unpackhi_pi32(argm64, argm64)
293 |     mym64 = unpacklo_pi8(argm64, argm64)
294 |     mym64 = unpacklo_pi16(argm64, argm64)
295 |     mym64 = unpacklo_pi32(argm64, argm64)
296 |     mym64 = add_pi8(argm64, argm64)
297 |     mym64 = add_pi16(argm64, argm64)
298 |     mym64 = add_pi32(argm64, argm64)
299 |     mym64 = adds_pi8(argm64, argm64)
300 |     mym64 = adds_pi16(argm64, argm64)
301 |     mym64 = adds_pu8(argm64, argm64)
302 |     mym64 = adds_pu16(argm64, argm64)
303 |     mym64 = sub_pi8(argm64, argm64)
304 |     mym64 = sub_pi16(argm64, argm64)
305 |     mym64 = sub_pi32(argm64, argm64)
306 |     mym64 = subs_pi8(argm64, argm64)
307 |     mym64 = subs_pi16(argm64, argm64)
308 |     mym64 = subs_pu8(argm64, argm64)
309 |     mym64 = subs_pu16(argm64, argm64)
310 |     mym64 = madd_pi16(argm64, argm64)
311 |     mym64 = mulhi_pi16(argm64, argm64)
312 |     mym64 = mullo_pi16(argm64, argm64)
313 |     mym64 = sll_pi16(argm64, argm64)
314 |     mym64 = slli_pi16(argm64, 1)
315 |     mym64 = sll_pi32(argm64, argm64)
316 |     mym64 = slli_pi32(argm64, 1)
317 |     mym64 = sll_si64(argm64, argm64)
318 |     mym64 = slli_si64(argm64, 1)
319 |     mym64 = sra_pi16(argm64, argm64)
320 |     mym64 = srai_pi16(argm64, 1)
321 |     mym64 = sra_pi32(argm64, argm64)
322 |     mym64 = srai_pi32(argm64, 1)
323 |     mym64 = srl_pi16(argm64, argm64)
324 |     mym64 = srli_pi16(argm64, 1)
325 |     mym64 = srl_pi32(argm64, argm64)
326 |     mym64 = srli_pi32(argm64, 1)
327 |     mym64 = srl_si64(argm64, argm64)
328 |     mym64 = srli_si64(argm64, 1)
329 |     mym64 = and_si64(argm64, argm64)
330 |     mym64 = andnot_si64(argm64, argm64)
331 |     mym64 = or_si64(argm64, argm64)
332 |     mym64 = xor_si64(argm64, argm64)
333 |     mym64 = cmpeq_pi8(argm64, argm64)
334 |     mym64 = cmpeq_pi16(argm64, argm64)
335 |     mym64 = cmpeq_pi32(argm64, argm64)
336 |     mym64 = cmpgt_pi8(argm64, argm64)
337 |     mym64 = cmpgt_pi16(argm64, argm64)
338 |     mym64 = cmpgt_pi32(argm64, argm64)
339 |     mym64 = setzero_si64()
340 |     mym64 = set_pi32(1, 1)
341 |     mym64 = set_pi16(argint16, argint16, argint16, argint16)
342 |     mym64 = set_pi8(argint8, argint8, argint8, argint8, argint8, argint8, argint8, argint8)
343 |     mym64 = set1_pi32(1)
344 |     mym64 = set1_pi16(argint16)
345 |     mym64 = set1_pi8(argint8)
346 |     mym64 = setr_pi32(1, 1)
347 |     mym64 = setr_pi16(argint16, argint16, argint16, argint16)
348 |     mym64 = setr_pi8(argint8, argint8, argint8, argint8, argint8, argint8, argint8, argint8)
349 | 
350 | 


--------------------------------------------------------------------------------
/src/nimsimd/sse.nim:
--------------------------------------------------------------------------------
  1 | #
  2 | #
  3 | #          Nimrod's x86 sse intrinsics
  4 | #        (c) Copyright 2014 Ben Segovia
  5 | #
  6 | #    See the file copying.txt, included in this
  7 | #    distribution, for details about the copyright.
  8 | #
  9 | import mmx
 10 | 
 11 | const someGcc* = defined(gcc) or defined(llvm_gcc) or defined(clang)
 12 | when someGcc:
 13 |   {.passC: "-msse".}
 14 |   {.passL: "-msse".}
 15 | 
 16 | 
 17 | 
 18 | #Width in bytes
 19 | const width* = 16 
 20 | 
 21 | type m128* {.importc: "__m128", header: "xmmintrin.h".} = object
 22 | type m128i* {.importc: "__m128i", header: "emmintrin.h".} = object
 23 | type m128d* {.importc: "__m128d", header: "emmintrin.h".} = object
 24 | type mf32* = m128
 25 | 
 26 | proc add_ss*(a: m128, b: m128): m128
 27 |   {.importc: "_mm_add_ss", header: "xmmintrin.h".}
 28 |   ## Exposes _mm_add_ss intrinsics
 29 | 
 30 | proc add_ps*(a: m128, b: m128): m128
 31 |   {.importc: "_mm_add_ps", header: "xmmintrin.h".}
 32 |   ## Exposes _mm_add_ps intrinsics
 33 | 
 34 | proc sub_ss*(a: m128, b: m128): m128
 35 |   {.importc: "_mm_sub_ss", header: "xmmintrin.h".}
 36 |   ## Exposes _mm_sub_ss intrinsics
 37 | 
 38 | proc sub_ps*(a: m128, b: m128): m128
 39 |   {.importc: "_mm_sub_ps", header: "xmmintrin.h".}
 40 |   ## Exposes _mm_sub_ps intrinsics
 41 | 
 42 | proc mul_ss*(a: m128, b: m128): m128
 43 |   {.importc: "_mm_mul_ss", header: "xmmintrin.h".}
 44 |   ## Exposes _mm_mul_ss intrinsics
 45 | 
 46 | proc mul_ps*(a: m128, b: m128): m128
 47 |   {.importc: "_mm_mul_ps", header: "xmmintrin.h".}
 48 |   ## Exposes _mm_mul_ps intrinsics
 49 | 
 50 | proc div_ss*(a: m128, b: m128): m128
 51 |   {.importc: "_mm_div_ss", header: "xmmintrin.h".}
 52 |   ## Exposes _mm_div_ss intrinsics
 53 | 
 54 | proc div_ps*(a: m128, b: m128): m128
 55 |   {.importc: "_mm_div_ps", header: "xmmintrin.h".}
 56 |   ## Exposes _mm_div_ps intrinsics
 57 | 
 58 | proc sqrt_ss*(a: m128): m128
 59 |   {.importc: "_mm_sqrt_ss", header: "xmmintrin.h".}
 60 |   ## Exposes _mm_sqrt_ss intrinsics
 61 | 
 62 | proc sqrt_ps*(a: m128): m128
 63 |   {.importc: "_mm_sqrt_ps", header: "xmmintrin.h".}
 64 |   ## Exposes _mm_sqrt_ps intrinsics
 65 | 
 66 | proc rcp_ss*(a: m128): m128
 67 |   {.importc: "_mm_rcp_ss", header: "xmmintrin.h".}
 68 |   ## Exposes _mm_rcp_ss intrinsics
 69 | 
 70 | proc rcp_ps*(a: m128): m128
 71 |   {.importc: "_mm_rcp_ps", header: "xmmintrin.h".}
 72 |   ## Exposes _mm_rcp_ps intrinsics
 73 | 
 74 | proc rsqrt_ss*(a: m128): m128
 75 |   {.importc: "_mm_rsqrt_ss", header: "xmmintrin.h".}
 76 |   ## Exposes _mm_rsqrt_ss intrinsics
 77 | 
 78 | proc rsqrt_ps*(a: m128): m128
 79 |   {.importc: "_mm_rsqrt_ps", header: "xmmintrin.h".}
 80 |   ## Exposes _mm_rsqrt_ps intrinsics
 81 | 
 82 | proc min_ss*(a: m128, b: m128): m128
 83 |   {.importc: "_mm_min_ss", header: "xmmintrin.h".}
 84 |   ## Exposes _mm_min_ss intrinsics
 85 | 
 86 | proc min_ps*(a: m128, b: m128): m128
 87 |   {.importc: "_mm_min_ps", header: "xmmintrin.h".}
 88 |   ## Exposes _mm_min_ps intrinsics
 89 | 
 90 | proc max_ss*(a: m128, b: m128): m128
 91 |   {.importc: "_mm_max_ss", header: "xmmintrin.h".}
 92 |   ## Exposes _mm_max_ss intrinsics
 93 | 
 94 | proc max_ps*(a: m128, b: m128): m128
 95 |   {.importc: "_mm_max_ps", header: "xmmintrin.h".}
 96 |   ## Exposes _mm_max_ps intrinsics
 97 | 
 98 | proc and_ps*(a: m128, b: m128): m128
 99 |   {.importc: "_mm_and_ps", header: "xmmintrin.h".}
100 |   ## Exposes _mm_and_ps intrinsics
101 | 
102 | proc andnot_ps*(a: m128, b: m128): m128
103 |   {.importc: "_mm_andnot_ps", header: "xmmintrin.h".}
104 |   ## Exposes _mm_andnot_ps intrinsics
105 | 
106 | proc or_ps*(a: m128, b: m128): m128
107 |   {.importc: "_mm_or_ps", header: "xmmintrin.h".}
108 |   ## Exposes _mm_or_ps intrinsics
109 | 
110 | proc xor_ps*(a: m128, b: m128): m128
111 |   {.importc: "_mm_xor_ps", header: "xmmintrin.h".}
112 |   ## Exposes _mm_xor_ps intrinsics
113 | 
114 | proc cmpeq_ss*(a: m128, b: m128): m128
115 |   {.importc: "_mm_cmpeq_ss", header: "xmmintrin.h".}
116 |   ## Exposes _mm_cmpeq_ss intrinsics
117 | 
118 | proc cmpeq_ps*(a: m128, b: m128): m128
119 |   {.importc: "_mm_cmpeq_ps", header: "xmmintrin.h".}
120 |   ## Exposes _mm_cmpeq_ps intrinsics
121 | 
122 | proc cmplt_ss*(a: m128, b: m128): m128
123 |   {.importc: "_mm_cmplt_ss", header: "xmmintrin.h".}
124 |   ## Exposes _mm_cmplt_ss intrinsics
125 | 
126 | proc cmplt_ps*(a: m128, b: m128): m128
127 |   {.importc: "_mm_cmplt_ps", header: "xmmintrin.h".}
128 |   ## Exposes _mm_cmplt_ps intrinsics
129 | 
130 | proc cmple_ss*(a: m128, b: m128): m128
131 |   {.importc: "_mm_cmple_ss", header: "xmmintrin.h".}
132 |   ## Exposes _mm_cmple_ss intrinsics
133 | 
134 | proc cmple_ps*(a: m128, b: m128): m128
135 |   {.importc: "_mm_cmple_ps", header: "xmmintrin.h".}
136 |   ## Exposes _mm_cmple_ps intrinsics
137 | 
138 | proc cmpgt_ss*(a: m128, b: m128): m128
139 |   {.importc: "_mm_cmpgt_ss", header: "xmmintrin.h".}
140 |   ## Exposes _mm_cmpgt_ss intrinsics
141 | 
142 | proc cmpgt_ps*(a: m128, b: m128): m128
143 |   {.importc: "_mm_cmpgt_ps", header: "xmmintrin.h".}
144 |   ## Exposes _mm_cmpgt_ps intrinsics
145 | 
146 | proc cmpge_ss*(a: m128, b: m128): m128
147 |   {.importc: "_mm_cmpge_ss", header: "xmmintrin.h".}
148 |   ## Exposes _mm_cmpge_ss intrinsics
149 | 
150 | proc cmpge_ps*(a: m128, b: m128): m128
151 |   {.importc: "_mm_cmpge_ps", header: "xmmintrin.h".}
152 |   ## Exposes _mm_cmpge_ps intrinsics
153 | 
154 | proc cmpneq_ss*(a: m128, b: m128): m128
155 |   {.importc: "_mm_cmpneq_ss", header: "xmmintrin.h".}
156 |   ## Exposes _mm_cmpneq_ss intrinsics
157 | 
158 | proc cmpneq_ps*(a: m128, b: m128): m128
159 |   {.importc: "_mm_cmpneq_ps", header: "xmmintrin.h".}
160 |   ## Exposes _mm_cmpneq_ps intrinsics
161 | 
162 | proc cmpnlt_ss*(a: m128, b: m128): m128
163 |   {.importc: "_mm_cmpnlt_ss", header: "xmmintrin.h".}
164 |   ## Exposes _mm_cmpnlt_ss intrinsics
165 | 
166 | proc cmpnlt_ps*(a: m128, b: m128): m128
167 |   {.importc: "_mm_cmpnlt_ps", header: "xmmintrin.h".}
168 |   ## Exposes _mm_cmpnlt_ps intrinsics
169 | 
170 | proc cmpnle_ss*(a: m128, b: m128): m128
171 |   {.importc: "_mm_cmpnle_ss", header: "xmmintrin.h".}
172 |   ## Exposes _mm_cmpnle_ss intrinsics
173 | 
174 | proc cmpnle_ps*(a: m128, b: m128): m128
175 |   {.importc: "_mm_cmpnle_ps", header: "xmmintrin.h".}
176 |   ## Exposes _mm_cmpnle_ps intrinsics
177 | 
178 | proc cmpngt_ss*(a: m128, b: m128): m128
179 |   {.importc: "_mm_cmpngt_ss", header: "xmmintrin.h".}
180 |   ## Exposes _mm_cmpngt_ss intrinsics
181 | 
182 | proc cmpngt_ps*(a: m128, b: m128): m128
183 |   {.importc: "_mm_cmpngt_ps", header: "xmmintrin.h".}
184 |   ## Exposes _mm_cmpngt_ps intrinsics
185 | 
186 | proc cmpnge_ss*(a: m128, b: m128): m128
187 |   {.importc: "_mm_cmpnge_ss", header: "xmmintrin.h".}
188 |   ## Exposes _mm_cmpnge_ss intrinsics
189 | 
190 | proc cmpnge_ps*(a: m128, b: m128): m128
191 |   {.importc: "_mm_cmpnge_ps", header: "xmmintrin.h".}
192 |   ## Exposes _mm_cmpnge_ps intrinsics
193 | 
194 | proc cmpord_ss*(a: m128, b: m128): m128
195 |   {.importc: "_mm_cmpord_ss", header: "xmmintrin.h".}
196 |   ## Exposes _mm_cmpord_ss intrinsics
197 | 
198 | proc cmpord_ps*(a: m128, b: m128): m128
199 |   {.importc: "_mm_cmpord_ps", header: "xmmintrin.h".}
200 |   ## Exposes _mm_cmpord_ps intrinsics
201 | 
202 | proc cmpunord_ss*(a: m128, b: m128): m128
203 |   {.importc: "_mm_cmpunord_ss", header: "xmmintrin.h".}
204 |   ## Exposes _mm_cmpunord_ss intrinsics
205 | 
206 | proc cmpunord_ps*(a: m128, b: m128): m128
207 |   {.importc: "_mm_cmpunord_ps", header: "xmmintrin.h".}
208 |   ## Exposes _mm_cmpunord_ps intrinsics
209 | 
210 | proc comieq_ss*(a: m128, b: m128): int32
211 |   {.importc: "_mm_comieq_ss", header: "xmmintrin.h".}
212 |   ## Exposes _mm_comieq_ss intrinsics
213 | 
214 | proc comilt_ss*(a: m128, b: m128): int32
215 |   {.importc: "_mm_comilt_ss", header: "xmmintrin.h".}
216 |   ## Exposes _mm_comilt_ss intrinsics
217 | 
218 | proc comile_ss*(a: m128, b: m128): int32
219 |   {.importc: "_mm_comile_ss", header: "xmmintrin.h".}
220 |   ## Exposes _mm_comile_ss intrinsics
221 | 
222 | proc comigt_ss*(a: m128, b: m128): int32
223 |   {.importc: "_mm_comigt_ss", header: "xmmintrin.h".}
224 |   ## Exposes _mm_comigt_ss intrinsics
225 | 
226 | proc comige_ss*(a: m128, b: m128): int32
227 |   {.importc: "_mm_comige_ss", header: "xmmintrin.h".}
228 |   ## Exposes _mm_comige_ss intrinsics
229 | 
230 | proc comineq_ss*(a: m128, b: m128): int32
231 |   {.importc: "_mm_comineq_ss", header: "xmmintrin.h".}
232 |   ## Exposes _mm_comineq_ss intrinsics
233 | 
234 | proc ucomieq_ss*(a: m128, b: m128): int32
235 |   {.importc: "_mm_ucomieq_ss", header: "xmmintrin.h".}
236 |   ## Exposes _mm_ucomieq_ss intrinsics
237 | 
238 | proc ucomilt_ss*(a: m128, b: m128): int32
239 |   {.importc: "_mm_ucomilt_ss", header: "xmmintrin.h".}
240 |   ## Exposes _mm_ucomilt_ss intrinsics
241 | 
242 | proc ucomile_ss*(a: m128, b: m128): int32
243 |   {.importc: "_mm_ucomile_ss", header: "xmmintrin.h".}
244 |   ## Exposes _mm_ucomile_ss intrinsics
245 | 
246 | proc ucomigt_ss*(a: m128, b: m128): int32
247 |   {.importc: "_mm_ucomigt_ss", header: "xmmintrin.h".}
248 |   ## Exposes _mm_ucomigt_ss intrinsics
249 | 
250 | proc ucomige_ss*(a: m128, b: m128): int32
251 |   {.importc: "_mm_ucomige_ss", header: "xmmintrin.h".}
252 |   ## Exposes _mm_ucomige_ss intrinsics
253 | 
254 | proc ucomineq_ss*(a: m128, b: m128): int32
255 |   {.importc: "_mm_ucomineq_ss", header: "xmmintrin.h".}
256 |   ## Exposes _mm_ucomineq_ss intrinsics
257 | 
258 | proc cvtss_si32*(a: m128): int32
259 |   {.importc: "_mm_cvtss_si32", header: "xmmintrin.h".}
260 |   ## Exposes _mm_cvtss_si32 intrinsics
261 | 
262 | proc cvt_ss2si*(a: m128): int32
263 |   {.importc: "_mm_cvt_ss2si", header: "xmmintrin.h".}
264 |   ## Exposes _mm_cvt_ss2si intrinsics
265 | 
266 | proc cvttss_si32*(a: m128): int32
267 |   {.importc: "_mm_cvttss_si32", header: "xmmintrin.h".}
268 |   ## Exposes _mm_cvttss_si32 intrinsics
269 | 
270 | proc cvtt_ss2si*(a: m128): int32
271 |   {.importc: "_mm_cvtt_ss2si", header: "xmmintrin.h".}
272 |   ## Exposes _mm_cvtt_ss2si intrinsics
273 | 
274 | when not vcc64Bits:
275 |   proc cvtps_epi32*(a: m128): m64
276 |     {.importc: "_mm_cvtps_pi32", header: "xmmintrin.h".}
277 |     ## Exposes _mm_cvtps_pi32 intrinsics
278 | 
279 |   proc cvt_ps2pi*(a: m128): m64
280 |     {.importc: "_mm_cvt_ps2pi", header: "xmmintrin.h".}
281 |     ## Exposes _mm_cvt_ps2pi intrinsics
282 | 
283 |   proc cvttps_epi32*(a: m128): m64
284 |     {.importc: "_mm_cvttps_pi32", header: "xmmintrin.h".}
285 |     ## Exposes _mm_cvttps_pi32 intrinsics
286 | 
287 |   proc cvtt_ps2pi*(a: m128): m64
288 |     {.importc: "_mm_cvtt_ps2pi", header: "xmmintrin.h".}
289 |     ## Exposes _mm_cvtt_ps2pi intrinsics
290 | 
291 |   proc stream_pi*(p: ptr m64, a: m64): void
292 |     {.importc: "_mm_stream_pi", header: "xmmintrin.h".}
293 |     ## Exposes _mm_stream_pi intrinsics
294 | 
295 |   proc cvtpi16_ps*(a: m64): m128
296 |     {.importc: "_mm_cvtpi16_ps", header: "xmmintrin.h".}
297 |     ## Exposes _mm_cvtpi16_ps intrinsics
298 | 
299 |   proc cvtpu16_ps*(a: m64): m128
300 |     {.importc: "_mm_cvtpu16_ps", header: "xmmintrin.h".}
301 |     ## Exposes _mm_cvtpu16_ps intrinsics
302 | 
303 |   proc cvtpi8_ps*(a: m64): m128
304 |     {.importc: "_mm_cvtpi8_ps", header: "xmmintrin.h".}
305 |     ## Exposes _mm_cvtpi8_ps intrinsics
306 | 
307 |   proc cvtpu8_ps*(a: m64): m128
308 |     {.importc: "_mm_cvtpu8_ps", header: "xmmintrin.h".}
309 |     ## Exposes _mm_cvtpu8_ps intrinsics
310 | 
311 |   proc cvtpi32x2_ps*(a: m64, b: m64): m128
312 |     {.importc: "_mm_cvtpi32x2_ps", header: "xmmintrin.h".}
313 |     ## Exposes _mm_cvtpi32x2_ps intrinsics
314 | 
315 |   proc cvtps_pi16*(a: m128): m64
316 |     {.importc: "_mm_cvtps_pi16", header: "xmmintrin.h".}
317 |     ## Exposes _mm_cvtps_pi16 intrinsics
318 | 
319 |   proc cvtps_pi8*(a: m128): m64
320 |     {.importc: "_mm_cvtps_pi8", header: "xmmintrin.h".}
321 |     ## Exposes _mm_cvtps_pi8 intrinsics
322 | 
323 |   proc cvtepi32_ps*(a: m128, b: m64): m128
324 |     {.importc: "_mm_cvtpi32_ps", header: "xmmintrin.h".}
325 |     ## Exposes _mm_cvtpi32_ps intrinsics
326 | 
327 |   proc cvt_pi2ps*(a: m128, b: m64): m128
328 |     {.importc: "_mm_cvt_pi2ps", header: "xmmintrin.h".}
329 |     ## Exposes _mm_cvt_pi2ps intrinsics
330 | 
331 |   proc loadh_pi*(a: m128,  p: ptr m64): m128
332 |     {.importc: "_mm_loadh_pi", header: "xmmintrin.h".}
333 |     ## Exposes _mm_loadh_pi intrinsics
334 | 
335 |   proc loadl_pi*(a: m128,  p: ptr m64): m128
336 |     {.importc: "_mm_loadl_pi", header: "xmmintrin.h".}
337 |     ## Exposes _mm_loadl_pi intrinsics
338 | 
339 |   proc storeh_pi*(p: ptr m64, a: m128): void
340 |     {.importc: "_mm_storeh_pi", header: "xmmintrin.h".}
341 |     ## Exposes _mm_storeh_pi intrinsics
342 | 
343 |   proc storel_pi*(p: ptr m64, a: m128): void
344 |     {.importc: "_mm_storel_pi", header: "xmmintrin.h".}
345 |     ## Exposes _mm_storel_pi intrinsics
346 | 
347 |   proc extract_pi16*(a: m64, n: int32): int32
348 |     {.importc: "_mm_extract_pi16", header: "xmmintrin.h".}
349 |     ## Exposes _mm_extract_pi16 intrinsics
350 | 
351 |   proc insert_pi16*(a: m64, d: int32, n: int32): m64
352 |     {.importc: "_mm_insert_pi16", header: "xmmintrin.h".}
353 |     ## Exposes _mm_insert_pi16 intrinsics
354 | 
355 |   proc max_pi16*(a: m64, b: m64): m64
356 |     {.importc: "_mm_max_pi16", header: "xmmintrin.h".}
357 |     ## Exposes _mm_max_pi16 intrinsics
358 | 
359 |   proc max_pu8*(a: m64, b: m64): m64
360 |     {.importc: "_mm_max_pu8", header: "xmmintrin.h".}
361 |     ## Exposes _mm_max_pu8 intrinsics
362 | 
363 |   proc min_pi16*(a: m64, b: m64): m64
364 |     {.importc: "_mm_min_pi16", header: "xmmintrin.h".}
365 |     ## Exposes _mm_min_pi16 intrinsics
366 | 
367 |   proc min_pu8*(a: m64, b: m64): m64
368 |     {.importc: "_mm_min_pu8", header: "xmmintrin.h".}
369 |     ## Exposes _mm_min_pu8 intrinsics
370 | 
371 |   proc movemask_pi8*(a: m64): int32
372 |     {.importc: "_mm_movemask_pi8", header: "xmmintrin.h".}
373 |     ## Exposes _mm_movemask_pi8 intrinsics
374 | 
375 |   proc mulhi_pu16*(a: m64, b: m64): m64
376 |     {.importc: "_mm_mulhi_pu16", header: "xmmintrin.h".}
377 |     ## Exposes _mm_mulhi_pu16 intrinsics
378 | 
379 |   proc maskmove_si64*(d: m64, n: m64, p: ptr int8): void
380 |     {.importc: "_mm_maskmove_si64", header: "xmmintrin.h".}
381 |     ## Exposes _mm_maskmove_si64 intrinsics
382 | 
383 |   proc avg_pu8*(a: m64, b: m64): m64
384 |     {.importc: "_mm_avg_pu8", header: "xmmintrin.h".}
385 |     ## Exposes _mm_avg_pu8 intrinsics
386 | 
387 |   proc avg_pu16*(a: m64, b: m64): m64
388 |     {.importc: "_mm_avg_pu16", header: "xmmintrin.h".}
389 |     ## Exposes _mm_avg_pu16 intrinsics
390 | 
391 |   proc sad_pu8*(a: m64, b: m64): m64
392 |     {.importc: "_mm_sad_pu8", header: "xmmintrin.h".}
393 |     ## Exposes _mm_sad_pu8 intrinsics
394 | 
395 | proc cvtsi32_ss*(a: m128, b: int32): m128
396 |   {.importc: "_mm_cvtsi32_ss", header: "xmmintrin.h".}
397 |   ## Exposes _mm_cvtsi32_ss intrinsics
398 | 
399 | proc cvt_si2ss*(a: m128, b: int32): m128
400 |   {.importc: "_mm_cvt_si2ss", header: "xmmintrin.h".}
401 |   ## Exposes _mm_cvt_si2ss intrinsics
402 | 
403 | when defined(x86_64):
404 |   proc cvtsi64_ss*(a: m128, b: int64): m128
405 |     {.importc: "_mm_cvtsi64_ss", header: "xmmintrin.h".}
406 |     ## Exposes _mm_cvtsi64_ss intrinsics
407 | 
408 | proc cvtss_f32*(a: m128): float32
409 |   {.importc: "_mm_cvtss_f32", header: "xmmintrin.h".}
410 |   ## Exposes _mm_cvtss_f32 intrinsics
411 | 
412 | proc load_ss*( p: ptr float32): m128
413 |   {.importc: "_mm_load_ss", header: "xmmintrin.h".}
414 |   ## Exposes _mm_load_ss intrinsics
415 | 
416 | proc load1_ps*( p: ptr float32): m128
417 |   {.importc: "_mm_load1_ps", header: "xmmintrin.h".}
418 |   ## Exposes _mm_load1_ps intrinsics
419 | 
420 | proc load_ps*( p: ptr float32): m128
421 |   {.importc: "_mm_load_ps", header: "xmmintrin.h".}
422 |   ## Exposes _mm_load_ps intrinsics
423 | 
424 | proc loadu_ps*( p: ptr float32): m128
425 |   {.importc: "_mm_loadu_ps", header: "xmmintrin.h".}
426 |   ## Exposes _mm_loadu_ps intrinsics
427 | 
428 | proc loadr_ps*( p: ptr float32): m128
429 |   {.importc: "_mm_loadr_ps", header: "xmmintrin.h".}
430 |   ## Exposes _mm_loadr_ps intrinsics
431 | 
432 | proc set_ss*(w: float32): m128
433 |   {.importc: "_mm_set_ss", header: "xmmintrin.h".}
434 |   ## Exposes _mm_set_ss intrinsics
435 | 
436 | proc set1_ps*(w: float32): m128
437 |   {.importc: "_mm_set1_ps", header: "xmmintrin.h".}
438 |   ## Exposes _mm_set1_ps intrinsics
439 | 
440 | proc set_ps1*(w: float32): m128
441 |   {.importc: "_mm_set_ps1", header: "xmmintrin.h".}
442 |   ## Exposes _mm_set_ps1 intrinsics
443 | 
444 | proc set_ps*(z: float32, y: float32, x: float32, w: float32): m128
445 |   {.importc: "_mm_set_ps", header: "xmmintrin.h".}
446 |   ## Exposes _mm_set_ps intrinsics
447 | 
448 | proc setr_ps*(z: float32, y: float32, x: float32, w: float32): m128
449 |   {.importc: "_mm_setr_ps", header: "xmmintrin.h".}
450 |   ## Exposes _mm_setr_ps intrinsics
451 | 
452 | proc setzero_ps*(): m128
453 |   {.importc: "_mm_setzero_ps", header: "xmmintrin.h".}
454 |   ## Exposes _mm_setzero_ps intrinsics
455 | 
456 | proc store_ss*(p: ptr float32, a: m128): void
457 |   {.importc: "_mm_store_ss", header: "xmmintrin.h".}
458 |   ## Exposes _mm_store_ss intrinsics
459 | 
460 | proc storeu_ps*(p: ptr float32, a: m128): void
461 |   {.importc: "_mm_storeu_ps", header: "xmmintrin.h".}
462 |   ## Exposes _mm_storeu_ps intrinsics
463 | 
464 | proc store1_ps*(p: ptr float32, a: m128): void
465 |   {.importc: "_mm_store1_ps", header: "xmmintrin.h".}
466 |   ## Exposes _mm_store1_ps intrinsics
467 | 
468 | proc store_ps1*(p: ptr float32, a: m128): void
469 |   {.importc: "_mm_store_ps1", header: "xmmintrin.h".}
470 |   ## Exposes _mm_store_ps1 intrinsics
471 | 
472 | proc store_ps*(p: ptr float32, a: m128): void
473 |   {.importc: "_mm_store_ps", header: "xmmintrin.h".}
474 |   ## Exposes _mm_store_ps intrinsics
475 | 
476 | proc storer_ps*(p: ptr float32, a: m128): void
477 |   {.importc: "_mm_storer_ps", header: "xmmintrin.h".}
478 |   ## Exposes _mm_storer_ps intrinsics
479 | 
480 | proc stream_ps*(p: ptr float32, a: m128): void
481 |   {.importc: "_mm_stream_ps", header: "xmmintrin.h".}
482 |   ## Exposes _mm_stream_ps intrinsics
483 | 
484 | proc sfence*(): void
485 |   {.importc: "_mm_sfence", header: "xmmintrin.h".}
486 |   ## Exposes _mm_sfence intrinsics
487 | 
488 | proc getcsr*(): int32
489 |   {.importc: "_mm_getcsr", header: "xmmintrin.h".}
490 |   ## Exposes _mm_getcsr intrinsics
491 | 
492 | proc setcsr*(i: int32): void
493 |   {.importc: "_mm_setcsr", header: "xmmintrin.h".}
494 |   ## Exposes _mm_setcsr intrinsics
495 | 
496 | proc unpackhi_ps*(a: m128, b: m128): m128
497 |   {.importc: "_mm_unpackhi_ps", header: "xmmintrin.h".}
498 |   ## Exposes _mm_unpackhi_ps intrinsics
499 | 
500 | proc unpacklo_ps*(a: m128, b: m128): m128
501 |   {.importc: "_mm_unpacklo_ps", header: "xmmintrin.h".}
502 |   ## Exposes _mm_unpacklo_ps intrinsics
503 | 
504 | proc move_ss*(a: m128, b: m128): m128
505 |   {.importc: "_mm_move_ss", header: "xmmintrin.h".}
506 |   ## Exposes _mm_move_ss intrinsics
507 | 
508 | proc movehl_ps*(a: m128, b: m128): m128
509 |   {.importc: "_mm_movehl_ps", header: "xmmintrin.h".}
510 |   ## Exposes _mm_movehl_ps intrinsics
511 | 
512 | proc movelh_ps*(a: m128, b: m128): m128
513 |   {.importc: "_mm_movelh_ps", header: "xmmintrin.h".}
514 |   ## Exposes _mm_movelh_ps intrinsics
515 | 
516 | proc movemask_ps*(a: m128): int32
517 |   {.importc: "_mm_movemask_ps", header: "xmmintrin.h".}
518 |   ## Exposes _mm_movemask_ps intrinsics
519 | 
520 | # Export all xmmintrin.h constants
521 | const EXCEPT_INVALID* = 0x0001
522 | const EXCEPT_DENORM* = 0x0002
523 | const EXCEPT_DIV_ZERO* = 0x0004
524 | const EXCEPT_OVERFLOW* = 0x0008
525 | const EXCEPT_UNDERFLOW* = 0x0010
526 | const EXCEPT_INEXACT* = 0x0020
527 | const EXCEPT_MASK* = 0x003f
528 | const MASK_INVALID* = 0x0080
529 | const MASK_DENORM* = 0x0100
530 | const MASK_DIV_ZERO* = 0x0200
531 | const MASK_OVERFLOW* = 0x0400
532 | const MASK_UNDERFLOW* = 0x0800
533 | const MASK_INEXACT* = 0x1000
534 | const MASK_MASK* = 0x1f80
535 | const ROUND_NEAREST* = 0x0000
536 | const ROUND_DOWN* = 0x2000
537 | const ROUND_UP* = 0x4000
538 | const ROUND_TOWARD_ZERO* = 0x6000
539 | const ROUND_MASK* = 0x6000
540 | const FLUSH_ZERO_MASK* = 0x8000
541 | const FLUSH_ZERO_ON* = 0x8000
542 | const FLUSH_ZERO_OFF* = 0x0000
543 | 
544 | # Export all xmmintrin.h macros
545 | proc get_exception_mask*() : int32 {.inline.} =
546 |   getcsr() and MASK_MASK
547 | 
548 | proc get_exception_state*() : int32 {.inline.} =
549 |   getcsr() and EXCEPT_MASK
550 | 
551 | proc get_flush_zero_mode*() : int32 {.inline.} =
552 |   getcsr() and FLUSH_ZERO_MASK
553 | 
554 | proc get_rounding_mode*() : int32 {.inline.} =
555 |   getcsr() and ROUND_MASK
556 | 
557 | proc set_exception_mask*(x: int32) {.inline.} =
558 |   setcsr((getcsr() and not MASK_MASK) or x)
559 | 
560 | proc set_exception_state*(x: int32) {.inline.} =
561 |   setcsr((getcsr() and not EXCEPT_MASK) or x)
562 | 
563 | proc set_flush_zero_mode*(x: int32) {.inline.} =
564 |   setcsr((getcsr() and not FLUSH_ZERO_MASK) or x)
565 | 
566 | proc set_rounding_mode*(x: int32) {.inline.} =
567 |   setcsr((getcsr() and not ROUND_MASK) or x)
568 | 
569 | ## Fallbacks
570 | # Floor and convert to int in one go
571 | template floor_ps_epi32*(a: m128) : m128i = 
572 |   
573 |   let arr = cast[ptr array[0..0,float32]](a)
574 |   var result:m128i
575 |   let resultArr = cast[ptr array[0..0,int32]](result)
576 |   for i in 0 .. 4:
577 |     var xi = int32(arr[i])
578 |     resultArr[i] = 
579 |       if arr[i] < float(xi):
580 |           xi - 1'i32
581 |       else:
582 |           xi
583 |   result
584 | 
585 | # SSE has not father so we fallback to scalar
586 | proc i32gather_epi32*(base: ptr int32, vindex: m128i, scale: int32) : m128i =
587 |   let resultArr = cast[ptr array[0..0,int32]](result)
588 |   let vindexArr = cast[ptr array[0..0,int32]](vindex)
589 |   let baseArr = cast[ptr array[0..0,int32]](base)
590 | 
591 |   for i in 0 .. 4:        
592 |     resultArr[i] = baseArr[vindexArr[i]]
593 | 
594 |   return result
595 | 
596 | # SSE has not father so we fallback to scalar
597 | proc i32gather_ps*(base: ptr float32, vindex: m128i, scale: int32) : m128 =
598 |   let resultArr = cast[ptr array[0..0,float32]](result)
599 |   let vindexArr = cast[ptr array[0..0,int32]](vindex)
600 |   let baseArr = cast[ptr array[0..0,float32]](base)
601 | 
602 |   for i in 0 .. 4:        
603 |     resultArr[i] = baseArr[vindexArr[i]]
604 | 
605 |   return result
606 | 
607 | # SSE has not blendv but we can accomplish it with simd bitwise operators
608 | template blendv_ps*(a, b, c : m128) : m128 =
609 |   or_ps(andnot_ps(c,a),and_ps(c,b))
610 | 
611 | 
612 | # Assert we generate proper C code
613 | when isMainModule:
614 |   var myint32 : int32 = 1;
615 |   var mym128 = set1_ps(1.0)
616 |   var myfloat32 : float32 = 1.0
617 |   var argint8 : int8 = 1;
618 |   var argm128 = set1_ps(1.0)
619 |   when defined(x86_64):
620 |     var argint64 : int64 = 1
621 |   var argfloat32 : float32 = 1.0
622 |   var argptrint8 = addr(argint8)
623 |   var argptrfloat32 : ptr float32 = cast[ptr float32](addr(argm128))
624 |   when not vcc64Bits:
625 |     var mym64 = set1_pi32(1)
626 |     var argm64 = set1_pi32(1)
627 |     var argptrm64 = addr(argm64)
628 |     mym64 = cvtps_epi32(argm128)
629 |     mym64 = cvt_ps2pi(argm128)
630 |     mym64 = cvttps_epi32(argm128)
631 |     mym64 = cvtt_ps2pi(argm128)
632 |     mym128 = cvtepi32_ps(argm128, argm64)
633 |     mym128 = cvt_pi2ps(argm128, argm64)
634 |     mym128 = loadh_pi(argm128,  argptrm64)
635 |     mym128 = loadl_pi(argm128,  argptrm64)
636 |     storeh_pi(argptrm64, argm128)
637 |     storel_pi(argptrm64, argm128)
638 |     myint32 = extract_pi16(argm64, 1)
639 |     mym64 = insert_pi16(argm64, 1, 1)
640 |     mym64 = max_pi16(argm64, argm64)
641 |     mym64 = max_pu8(argm64, argm64)
642 |     mym64 = min_pi16(argm64, argm64)
643 |     mym64 = min_pu8(argm64, argm64)
644 |     myint32 = movemask_pi8(argm64)
645 |     mym64 = mulhi_pu16(argm64, argm64)
646 |     maskmove_si64(argm64, argm64, argptrint8)
647 |     mym64 = avg_pu8(argm64, argm64)
648 |     mym64 = avg_pu16(argm64, argm64)
649 |     mym64 = sad_pu8(argm64, argm64)
650 |     stream_pi(argptrm64, argm64)
651 |     mym128 = cvtpi16_ps(argm64)
652 |     mym128 = cvtpu16_ps(argm64)
653 |     mym128 = cvtpi8_ps(argm64)
654 |     mym128 = cvtpu8_ps(argm64)
655 |     mym128 = cvtpi32x2_ps(argm64, argm64)
656 |     mym64 = cvtps_pi16(argm128)
657 |     mym64 = cvtps_pi8(argm128)
658 |   mym128 = add_ss(argm128, argm128)
659 |   mym128 = add_ps(argm128, argm128)
660 |   mym128 = sub_ss(argm128, argm128)
661 |   mym128 = sub_ps(argm128, argm128)
662 |   mym128 = mul_ss(argm128, argm128)
663 |   mym128 = mul_ps(argm128, argm128)
664 |   mym128 = div_ss(argm128, argm128)
665 |   mym128 = div_ps(argm128, argm128)
666 |   mym128 = sqrt_ss(argm128)
667 |   mym128 = sqrt_ps(argm128)
668 |   mym128 = rcp_ss(argm128)
669 |   mym128 = rcp_ps(argm128)
670 |   mym128 = rsqrt_ss(argm128)
671 |   mym128 = rsqrt_ps(argm128)
672 |   mym128 = min_ss(argm128, argm128)
673 |   mym128 = min_ps(argm128, argm128)
674 |   mym128 = max_ss(argm128, argm128)
675 |   mym128 = max_ps(argm128, argm128)
676 |   mym128 = and_ps(argm128, argm128)
677 |   mym128 = andnot_ps(argm128, argm128)
678 |   mym128 = or_ps(argm128, argm128)
679 |   mym128 = xor_ps(argm128, argm128)
680 |   mym128 = cmpeq_ss(argm128, argm128)
681 |   mym128 = cmpeq_ps(argm128, argm128)
682 |   mym128 = cmplt_ss(argm128, argm128)
683 |   mym128 = cmplt_ps(argm128, argm128)
684 |   mym128 = cmple_ss(argm128, argm128)
685 |   mym128 = cmple_ps(argm128, argm128)
686 |   mym128 = cmpgt_ss(argm128, argm128)
687 |   mym128 = cmpgt_ps(argm128, argm128)
688 |   mym128 = cmpge_ss(argm128, argm128)
689 |   mym128 = cmpge_ps(argm128, argm128)
690 |   mym128 = cmpneq_ss(argm128, argm128)
691 |   mym128 = cmpneq_ps(argm128, argm128)
692 |   mym128 = cmpnlt_ss(argm128, argm128)
693 |   mym128 = cmpnlt_ps(argm128, argm128)
694 |   mym128 = cmpnle_ss(argm128, argm128)
695 |   mym128 = cmpnle_ps(argm128, argm128)
696 |   mym128 = cmpngt_ss(argm128, argm128)
697 |   mym128 = cmpngt_ps(argm128, argm128)
698 |   mym128 = cmpnge_ss(argm128, argm128)
699 |   mym128 = cmpnge_ps(argm128, argm128)
700 |   mym128 = cmpord_ss(argm128, argm128)
701 |   mym128 = cmpord_ps(argm128, argm128)
702 |   mym128 = cmpunord_ss(argm128, argm128)
703 |   mym128 = cmpunord_ps(argm128, argm128)
704 |   myint32 = comieq_ss(argm128, argm128)
705 |   myint32 = comilt_ss(argm128, argm128)
706 |   myint32 = comile_ss(argm128, argm128)
707 |   myint32 = comigt_ss(argm128, argm128)
708 |   myint32 = comige_ss(argm128, argm128)
709 |   myint32 = comineq_ss(argm128, argm128)
710 |   myint32 = ucomieq_ss(argm128, argm128)
711 |   myint32 = ucomilt_ss(argm128, argm128)
712 |   myint32 = ucomile_ss(argm128, argm128)
713 |   myint32 = ucomigt_ss(argm128, argm128)
714 |   myint32 = ucomige_ss(argm128, argm128)
715 |   myint32 = ucomineq_ss(argm128, argm128)
716 |   myint32 = cvtss_si32(argm128)
717 |   myint32 = cvt_ss2si(argm128)
718 |   myint32 = cvttss_si32(argm128)
719 |   myint32 = cvtt_ss2si(argm128)
720 |   mym128 = cvtsi32_ss(argm128, 1)
721 |   mym128 = cvt_si2ss(argm128, 1)
722 |   when defined(x86_64):
723 |     mym128 = cvtsi64_ss(argm128, argint64)
724 |   myfloat32 = cvtss_f32(argm128)
725 |   mym128 = load_ss( argptrfloat32)
726 |   mym128 = load1_ps( argptrfloat32)
727 |   mym128 = load_ps( argptrfloat32)
728 |   mym128 = loadu_ps( argptrfloat32)
729 |   mym128 = loadr_ps( argptrfloat32)
730 |   mym128 = set_ss(argfloat32)
731 |   mym128 = set1_ps(argfloat32)
732 |   mym128 = set_ps1(argfloat32)
733 |   mym128 = set_ps(argfloat32, argfloat32, argfloat32, argfloat32)
734 |   mym128 = setr_ps(argfloat32, argfloat32, argfloat32, argfloat32)
735 |   mym128 = setzero_ps()
736 |   store_ss(argptrfloat32, argm128)
737 |   storeu_ps(argptrfloat32, argm128)
738 |   store1_ps(argptrfloat32, argm128)
739 |   store_ps1(argptrfloat32, argm128)
740 |   store_ps(argptrfloat32, argm128)
741 |   storer_ps(argptrfloat32, argm128)
742 |   stream_ps(argptrfloat32, argm128)
743 |   sfence()
744 |   myint32 = getcsr()
745 |   setcsr(1)
746 |   mym128 = unpackhi_ps(argm128, argm128)
747 |   mym128 = unpacklo_ps(argm128, argm128)
748 |   mym128 = move_ss(argm128, argm128)
749 |   mym128 = movehl_ps(argm128, argm128)
750 |   mym128 = movelh_ps(argm128, argm128)
751 |   myint32 = movemask_ps(argm128)
752 | 
753 | 


--------------------------------------------------------------------------------
/src/nimsimd/sse2.nim:
--------------------------------------------------------------------------------
  1 | #
  2 | #
  3 | #          Nimrod's x86 sse2 intrinsics
  4 | #        (c) Copyright 2014 Ben Segovia
  5 | #
  6 | #    See the file copying.txt, included in this
  7 | #    distribution, for details about the copyright.
  8 | #
  9 | include sse
 10 | 
 11 | 
 12 | when someGcc:
 13 |   {.passC: "-msse2".}
 14 |   {.passL: "-msse2".}
 15 | 
 16 | 
 17 | proc add_sd*(a: m128d, b: m128d): m128d
 18 |   {.importc: "_mm_add_sd", header: "emmintrin.h".}
 19 |   ## Exposes _mm_add_sd intrinsics
 20 | 
 21 | proc add_pd*(a: m128d, b: m128d): m128d
 22 |   {.importc: "_mm_add_pd", header: "emmintrin.h".}
 23 |   ## Exposes _mm_add_pd intrinsics
 24 | 
 25 | proc sub_sd*(a: m128d, b: m128d): m128d
 26 |   {.importc: "_mm_sub_sd", header: "emmintrin.h".}
 27 |   ## Exposes _mm_sub_sd intrinsics
 28 | 
 29 | proc sub_pd*(a: m128d, b: m128d): m128d
 30 |   {.importc: "_mm_sub_pd", header: "emmintrin.h".}
 31 |   ## Exposes _mm_sub_pd intrinsics
 32 | 
 33 | proc mul_sd*(a: m128d, b: m128d): m128d
 34 |   {.importc: "_mm_mul_sd", header: "emmintrin.h".}
 35 |   ## Exposes _mm_mul_sd intrinsics
 36 | 
 37 | proc mul_pd*(a: m128d, b: m128d): m128d
 38 |   {.importc: "_mm_mul_pd", header: "emmintrin.h".}
 39 |   ## Exposes _mm_mul_pd intrinsics
 40 | 
 41 | proc div_sd*(a: m128d, b: m128d): m128d
 42 |   {.importc: "_mm_div_sd", header: "emmintrin.h".}
 43 |   ## Exposes _mm_div_sd intrinsics
 44 | 
 45 | proc div_pd*(a: m128d, b: m128d): m128d
 46 |   {.importc: "_mm_div_pd", header: "emmintrin.h".}
 47 |   ## Exposes _mm_div_pd intrinsics
 48 | 
 49 | proc sqrt_sd*(a: m128d, b: m128d): m128d
 50 |   {.importc: "_mm_sqrt_sd", header: "emmintrin.h".}
 51 |   ## Exposes _mm_sqrt_sd intrinsics
 52 | 
 53 | proc sqrt_pd*(a: m128d): m128d
 54 |   {.importc: "_mm_sqrt_pd", header: "emmintrin.h".}
 55 |   ## Exposes _mm_sqrt_pd intrinsics
 56 | 
 57 | proc min_sd*(a: m128d, b: m128d): m128d
 58 |   {.importc: "_mm_min_sd", header: "emmintrin.h".}
 59 |   ## Exposes _mm_min_sd intrinsics
 60 | 
 61 | proc min_pd*(a: m128d, b: m128d): m128d
 62 |   {.importc: "_mm_min_pd", header: "emmintrin.h".}
 63 |   ## Exposes _mm_min_pd intrinsics
 64 | 
 65 | proc max_sd*(a: m128d, b: m128d): m128d
 66 |   {.importc: "_mm_max_sd", header: "emmintrin.h".}
 67 |   ## Exposes _mm_max_sd intrinsics
 68 | 
 69 | proc max_pd*(a: m128d, b: m128d): m128d
 70 |   {.importc: "_mm_max_pd", header: "emmintrin.h".}
 71 |   ## Exposes _mm_max_pd intrinsics
 72 | 
 73 | proc and_pd*(a: m128d, b: m128d): m128d
 74 |   {.importc: "_mm_and_pd", header: "emmintrin.h".}
 75 |   ## Exposes _mm_and_pd intrinsics
 76 | 
 77 | proc andnot_pd*(a: m128d, b: m128d): m128d
 78 |   {.importc: "_mm_andnot_pd", header: "emmintrin.h".}
 79 |   ## Exposes _mm_andnot_pd intrinsics
 80 | 
 81 | proc or_pd*(a: m128d, b: m128d): m128d
 82 |   {.importc: "_mm_or_pd", header: "emmintrin.h".}
 83 |   ## Exposes _mm_or_pd intrinsics
 84 | 
 85 | proc xor_pd*(a: m128d, b: m128d): m128d
 86 |   {.importc: "_mm_xor_pd", header: "emmintrin.h".}
 87 |   ## Exposes _mm_xor_pd intrinsics
 88 | 
 89 | proc cmpeq_pd*(a: m128d, b: m128d): m128d
 90 |   {.importc: "_mm_cmpeq_pd", header: "emmintrin.h".}
 91 |   ## Exposes _mm_cmpeq_pd intrinsics
 92 | 
 93 | proc cmplt_pd*(a: m128d, b: m128d): m128d
 94 |   {.importc: "_mm_cmplt_pd", header: "emmintrin.h".}
 95 |   ## Exposes _mm_cmplt_pd intrinsics
 96 | 
 97 | proc cmple_pd*(a: m128d, b: m128d): m128d
 98 |   {.importc: "_mm_cmple_pd", header: "emmintrin.h".}
 99 |   ## Exposes _mm_cmple_pd intrinsics
100 | 
101 | proc cmpgt_pd*(a: m128d, b: m128d): m128d
102 |   {.importc: "_mm_cmpgt_pd", header: "emmintrin.h".}
103 |   ## Exposes _mm_cmpgt_pd intrinsics
104 | 
105 | proc cmpge_pd*(a: m128d, b: m128d): m128d
106 |   {.importc: "_mm_cmpge_pd", header: "emmintrin.h".}
107 |   ## Exposes _mm_cmpge_pd intrinsics
108 | 
109 | proc cmpord_pd*(a: m128d, b: m128d): m128d
110 |   {.importc: "_mm_cmpord_pd", header: "emmintrin.h".}
111 |   ## Exposes _mm_cmpord_pd intrinsics
112 | 
113 | proc cmpunord_pd*(a: m128d, b: m128d): m128d
114 |   {.importc: "_mm_cmpunord_pd", header: "emmintrin.h".}
115 |   ## Exposes _mm_cmpunord_pd intrinsics
116 | 
117 | proc cmpneq_pd*(a: m128d, b: m128d): m128d
118 |   {.importc: "_mm_cmpneq_pd", header: "emmintrin.h".}
119 |   ## Exposes _mm_cmpneq_pd intrinsics
120 | 
121 | proc cmpnlt_pd*(a: m128d, b: m128d): m128d
122 |   {.importc: "_mm_cmpnlt_pd", header: "emmintrin.h".}
123 |   ## Exposes _mm_cmpnlt_pd intrinsics
124 | 
125 | proc cmpnle_pd*(a: m128d, b: m128d): m128d
126 |   {.importc: "_mm_cmpnle_pd", header: "emmintrin.h".}
127 |   ## Exposes _mm_cmpnle_pd intrinsics
128 | 
129 | proc cmpngt_pd*(a: m128d, b: m128d): m128d
130 |   {.importc: "_mm_cmpngt_pd", header: "emmintrin.h".}
131 |   ## Exposes _mm_cmpngt_pd intrinsics
132 | 
133 | proc cmpnge_pd*(a: m128d, b: m128d): m128d
134 |   {.importc: "_mm_cmpnge_pd", header: "emmintrin.h".}
135 |   ## Exposes _mm_cmpnge_pd intrinsics
136 | 
137 | proc cmpeq_sd*(a: m128d, b: m128d): m128d
138 |   {.importc: "_mm_cmpeq_sd", header: "emmintrin.h".}
139 |   ## Exposes _mm_cmpeq_sd intrinsics
140 | 
141 | proc cmplt_sd*(a: m128d, b: m128d): m128d
142 |   {.importc: "_mm_cmplt_sd", header: "emmintrin.h".}
143 |   ## Exposes _mm_cmplt_sd intrinsics
144 | 
145 | proc cmple_sd*(a: m128d, b: m128d): m128d
146 |   {.importc: "_mm_cmple_sd", header: "emmintrin.h".}
147 |   ## Exposes _mm_cmple_sd intrinsics
148 | 
149 | proc cmpgt_sd*(a: m128d, b: m128d): m128d
150 |   {.importc: "_mm_cmpgt_sd", header: "emmintrin.h".}
151 |   ## Exposes _mm_cmpgt_sd intrinsics
152 | 
153 | proc cmpge_sd*(a: m128d, b: m128d): m128d
154 |   {.importc: "_mm_cmpge_sd", header: "emmintrin.h".}
155 |   ## Exposes _mm_cmpge_sd intrinsics
156 | 
157 | proc cmpord_sd*(a: m128d, b: m128d): m128d
158 |   {.importc: "_mm_cmpord_sd", header: "emmintrin.h".}
159 |   ## Exposes _mm_cmpord_sd intrinsics
160 | 
161 | proc cmpunord_sd*(a: m128d, b: m128d): m128d
162 |   {.importc: "_mm_cmpunord_sd", header: "emmintrin.h".}
163 |   ## Exposes _mm_cmpunord_sd intrinsics
164 | 
165 | proc cmpneq_sd*(a: m128d, b: m128d): m128d
166 |   {.importc: "_mm_cmpneq_sd", header: "emmintrin.h".}
167 |   ## Exposes _mm_cmpneq_sd intrinsics
168 | 
169 | proc cmpnlt_sd*(a: m128d, b: m128d): m128d
170 |   {.importc: "_mm_cmpnlt_sd", header: "emmintrin.h".}
171 |   ## Exposes _mm_cmpnlt_sd intrinsics
172 | 
173 | proc cmpnle_sd*(a: m128d, b: m128d): m128d
174 |   {.importc: "_mm_cmpnle_sd", header: "emmintrin.h".}
175 |   ## Exposes _mm_cmpnle_sd intrinsics
176 | 
177 | proc cmpngt_sd*(a: m128d, b: m128d): m128d
178 |   {.importc: "_mm_cmpngt_sd", header: "emmintrin.h".}
179 |   ## Exposes _mm_cmpngt_sd intrinsics
180 | 
181 | proc cmpnge_sd*(a: m128d, b: m128d): m128d
182 |   {.importc: "_mm_cmpnge_sd", header: "emmintrin.h".}
183 |   ## Exposes _mm_cmpnge_sd intrinsics
184 | 
185 | proc comieq_sd*(a: m128d, b: m128d): int32
186 |   {.importc: "_mm_comieq_sd", header: "emmintrin.h".}
187 |   ## Exposes _mm_comieq_sd intrinsics
188 | 
189 | proc comilt_sd*(a: m128d, b: m128d): int32
190 |   {.importc: "_mm_comilt_sd", header: "emmintrin.h".}
191 |   ## Exposes _mm_comilt_sd intrinsics
192 | 
193 | proc comile_sd*(a: m128d, b: m128d): int32
194 |   {.importc: "_mm_comile_sd", header: "emmintrin.h".}
195 |   ## Exposes _mm_comile_sd intrinsics
196 | 
197 | proc comigt_sd*(a: m128d, b: m128d): int32
198 |   {.importc: "_mm_comigt_sd", header: "emmintrin.h".}
199 |   ## Exposes _mm_comigt_sd intrinsics
200 | 
201 | proc comige_sd*(a: m128d, b: m128d): int32
202 |   {.importc: "_mm_comige_sd", header: "emmintrin.h".}
203 |   ## Exposes _mm_comige_sd intrinsics
204 | 
205 | proc comineq_sd*(a: m128d, b: m128d): int32
206 |   {.importc: "_mm_comineq_sd", header: "emmintrin.h".}
207 |   ## Exposes _mm_comineq_sd intrinsics
208 | 
209 | proc ucomieq_sd*(a: m128d, b: m128d): int32
210 |   {.importc: "_mm_ucomieq_sd", header: "emmintrin.h".}
211 |   ## Exposes _mm_ucomieq_sd intrinsics
212 | 
213 | proc ucomilt_sd*(a: m128d, b: m128d): int32
214 |   {.importc: "_mm_ucomilt_sd", header: "emmintrin.h".}
215 |   ## Exposes _mm_ucomilt_sd intrinsics
216 | 
217 | proc ucomile_sd*(a: m128d, b: m128d): int32
218 |   {.importc: "_mm_ucomile_sd", header: "emmintrin.h".}
219 |   ## Exposes _mm_ucomile_sd intrinsics
220 | 
221 | proc ucomigt_sd*(a: m128d, b: m128d): int32
222 |   {.importc: "_mm_ucomigt_sd", header: "emmintrin.h".}
223 |   ## Exposes _mm_ucomigt_sd intrinsics
224 | 
225 | proc ucomige_sd*(a: m128d, b: m128d): int32
226 |   {.importc: "_mm_ucomige_sd", header: "emmintrin.h".}
227 |   ## Exposes _mm_ucomige_sd intrinsics
228 | 
229 | proc ucomineq_sd*(a: m128d, b: m128d): int32
230 |   {.importc: "_mm_ucomineq_sd", header: "emmintrin.h".}
231 |   ## Exposes _mm_ucomineq_sd intrinsics
232 | 
233 | proc cvtpd_ps*(a: m128d): m128
234 |   {.importc: "_mm_cvtpd_ps", header: "emmintrin.h".}
235 |   ## Exposes _mm_cvtpd_ps intrinsics
236 | 
237 | proc cvtps_pd*(a: m128): m128d
238 |   {.importc: "_mm_cvtps_pd", header: "emmintrin.h".}
239 |   ## Exposes _mm_cvtps_pd intrinsics
240 | 
241 | proc cvtepi32_pd*(a: m128i): m128d
242 |   {.importc: "_mm_cvtepi32_pd", header: "emmintrin.h".}
243 |   ## Exposes _mm_cvtepi32_pd intrinsics
244 | 
245 | proc cvtpd_epi32*(a: m128d): m128i
246 |   {.importc: "_mm_cvtpd_epi32", header: "emmintrin.h".}
247 |   ## Exposes _mm_cvtpd_epi32 intrinsics
248 | 
249 | proc cvtsd_si32*(a: m128d): int32
250 |   {.importc: "_mm_cvtsd_si32", header: "emmintrin.h".}
251 |   ## Exposes _mm_cvtsd_si32 intrinsics
252 | 
253 | proc cvtsd_ss*(a: m128, b: m128d): m128
254 |   {.importc: "_mm_cvtsd_ss", header: "emmintrin.h".}
255 |   ## Exposes _mm_cvtsd_ss intrinsics
256 | 
257 | proc cvtsi32_sd*(a: m128d, b: int32): m128d
258 |   {.importc: "_mm_cvtsi32_sd", header: "emmintrin.h".}
259 |   ## Exposes _mm_cvtsi32_sd intrinsics
260 | 
261 | proc cvtss_sd*(a: m128d, b: m128): m128d
262 |   {.importc: "_mm_cvtss_sd", header: "emmintrin.h".}
263 |   ## Exposes _mm_cvtss_sd intrinsics
264 | 
265 | proc cvttpd_epi32*(a: m128d): m128i
266 |   {.importc: "_mm_cvttpd_epi32", header: "emmintrin.h".}
267 |   ## Exposes _mm_cvttpd_epi32 intrinsics
268 | 
269 | proc cvttsd_si32*(a: m128d): int32
270 |   {.importc: "_mm_cvttsd_si32", header: "emmintrin.h".}
271 |   ## Exposes _mm_cvttsd_si32 intrinsics
272 | 
273 | proc cvtsd_f64*(a: m128d): float64
274 |   {.importc: "_mm_cvtsd_f64", header: "emmintrin.h".}
275 |   ## Exposes _mm_cvtsd_f64 intrinsics
276 | 
277 | proc load_pd*(dp: ptr float64): m128d
278 |   {.importc: "_mm_load_pd", header: "emmintrin.h".}
279 |   ## Exposes _mm_load_pd intrinsics
280 | 
281 | proc load1_pd*(dp: ptr float64): m128d
282 |   {.importc: "_mm_load1_pd", header: "emmintrin.h".}
283 |   ## Exposes _mm_load1_pd intrinsics
284 | 
285 | proc loadr_pd*(dp: ptr float64): m128d
286 |   {.importc: "_mm_loadr_pd", header: "emmintrin.h".}
287 |   ## Exposes _mm_loadr_pd intrinsics
288 | 
289 | proc loadu_pd*(dp: ptr float64): m128d
290 |   {.importc: "_mm_loadu_pd", header: "emmintrin.h".}
291 |   ## Exposes _mm_loadu_pd intrinsics
292 | 
293 | proc load_sd*(dp: ptr float64): m128d
294 |   {.importc: "_mm_load_sd", header: "emmintrin.h".}
295 |   ## Exposes _mm_load_sd intrinsics
296 | 
297 | proc loadh_pd*(a: m128d, dp: ptr float64): m128d
298 |   {.importc: "_mm_loadh_pd", header: "emmintrin.h".}
299 |   ## Exposes _mm_loadh_pd intrinsics
300 | 
301 | proc loadl_pd*(a: m128d, dp: ptr float64): m128d
302 |   {.importc: "_mm_loadl_pd", header: "emmintrin.h".}
303 |   ## Exposes _mm_loadl_pd intrinsics
304 | 
305 | proc set_sd*(w: float64): m128d
306 |   {.importc: "_mm_set_sd", header: "emmintrin.h".}
307 |   ## Exposes _mm_set_sd intrinsics
308 | 
309 | proc set1_pd*(w: float64): m128d
310 |   {.importc: "_mm_set1_pd", header: "emmintrin.h".}
311 |   ## Exposes _mm_set1_pd intrinsics
312 | 
313 | proc set_pd*(w: float64, x: float64): m128d
314 |   {.importc: "_mm_set_pd", header: "emmintrin.h".}
315 |   ## Exposes _mm_set_pd intrinsics
316 | 
317 | proc setr_pd*(w: float64, x: float64): m128d
318 |   {.importc: "_mm_setr_pd", header: "emmintrin.h".}
319 |   ## Exposes _mm_setr_pd intrinsics
320 | 
321 | proc setzero_pd*(): m128d
322 |   {.importc: "_mm_setzero_pd", header: "emmintrin.h".}
323 |   ## Exposes _mm_setzero_pd intrinsics
324 | 
325 | proc move_sd*(a: m128d, b: m128d): m128d
326 |   {.importc: "_mm_move_sd", header: "emmintrin.h".}
327 |   ## Exposes _mm_move_sd intrinsics
328 | 
329 | proc store_sd*(dp: ptr float64, a: m128d): void
330 |   {.importc: "_mm_store_sd", header: "emmintrin.h".}
331 |   ## Exposes _mm_store_sd intrinsics
332 | 
333 | proc store1_pd*(dp: ptr float64, a: m128d): void
334 |   {.importc: "_mm_store1_pd", header: "emmintrin.h".}
335 |   ## Exposes _mm_store1_pd intrinsics
336 | 
337 | proc store_pd*(dp: ptr float64, a: m128d): void
338 |   {.importc: "_mm_store_pd", header: "emmintrin.h".}
339 |   ## Exposes _mm_store_pd intrinsics
340 | 
341 | proc storeu_pd*(dp: ptr float64, a: m128d): void
342 |   {.importc: "_mm_storeu_pd", header: "emmintrin.h".}
343 |   ## Exposes _mm_storeu_pd intrinsics
344 | 
345 | proc storer_pd*(dp: ptr float64, a: m128d): void
346 |   {.importc: "_mm_storer_pd", header: "emmintrin.h".}
347 |   ## Exposes _mm_storer_pd intrinsics
348 | 
349 | proc storeh_pd*(dp: ptr float64, a: m128d): void
350 |   {.importc: "_mm_storeh_pd", header: "emmintrin.h".}
351 |   ## Exposes _mm_storeh_pd intrinsics
352 | 
353 | proc storel_pd*(dp: ptr float64, a: m128d): void
354 |   {.importc: "_mm_storel_pd", header: "emmintrin.h".}
355 |   ## Exposes _mm_storel_pd intrinsics
356 | 
357 | proc add_epi8*(a: m128i, b: m128i): m128i
358 |   {.importc: "_mm_add_epi8", header: "emmintrin.h".}
359 |   ## Exposes _mm_add_epi8 intrinsics
360 | 
361 | proc add_epi16*(a: m128i, b: m128i): m128i
362 |   {.importc: "_mm_add_epi16", header: "emmintrin.h".}
363 |   ## Exposes _mm_add_epi16 intrinsics
364 | 
365 | proc add_epi32*(a: m128i, b: m128i): m128i
366 |   {.importc: "_mm_add_epi32", header: "emmintrin.h".}
367 |   ## Exposes _mm_add_epi32 intrinsics
368 | 
369 | proc add_epi64*(a: m128i, b: m128i): m128i
370 |   {.importc: "_mm_add_epi64", header: "emmintrin.h".}
371 |   ## Exposes _mm_add_epi64 intrinsics
372 | 
373 | proc adds_epi8*(a: m128i, b: m128i): m128i
374 |   {.importc: "_mm_adds_epi8", header: "emmintrin.h".}
375 |   ## Exposes _mm_adds_epi8 intrinsics
376 | 
377 | proc adds_epi16*(a: m128i, b: m128i): m128i
378 |   {.importc: "_mm_adds_epi16", header: "emmintrin.h".}
379 |   ## Exposes _mm_adds_epi16 intrinsics
380 | 
381 | proc adds_epu8*(a: m128i, b: m128i): m128i
382 |   {.importc: "_mm_adds_epu8", header: "emmintrin.h".}
383 |   ## Exposes _mm_adds_epu8 intrinsics
384 | 
385 | proc adds_epu16*(a: m128i, b: m128i): m128i
386 |   {.importc: "_mm_adds_epu16", header: "emmintrin.h".}
387 |   ## Exposes _mm_adds_epu16 intrinsics
388 | 
389 | proc avg_epu8*(a: m128i, b: m128i): m128i
390 |   {.importc: "_mm_avg_epu8", header: "emmintrin.h".}
391 |   ## Exposes _mm_avg_epu8 intrinsics
392 | 
393 | proc avg_epu16*(a: m128i, b: m128i): m128i
394 |   {.importc: "_mm_avg_epu16", header: "emmintrin.h".}
395 |   ## Exposes _mm_avg_epu16 intrinsics
396 | 
397 | proc madd_epi16*(a: m128i, b: m128i): m128i
398 |   {.importc: "_mm_madd_epi16", header: "emmintrin.h".}
399 |   ## Exposes _mm_madd_epi16 intrinsics
400 | 
401 | proc max_epi16*(a: m128i, b: m128i): m128i
402 |   {.importc: "_mm_max_epi16", header: "emmintrin.h".}
403 |   ## Exposes _mm_max_epi16 intrinsics
404 | 
405 | proc max_epu8*(a: m128i, b: m128i): m128i
406 |   {.importc: "_mm_max_epu8", header: "emmintrin.h".}
407 |   ## Exposes _mm_max_epu8 intrinsics
408 | 
409 | proc min_epi16*(a: m128i, b: m128i): m128i
410 |   {.importc: "_mm_min_epi16", header: "emmintrin.h".}
411 |   ## Exposes _mm_min_epi16 intrinsics
412 | 
413 | proc min_epu8*(a: m128i, b: m128i): m128i
414 |   {.importc: "_mm_min_epu8", header: "emmintrin.h".}
415 |   ## Exposes _mm_min_epu8 intrinsics
416 | 
417 | proc mulhi_epi16*(a: m128i, b: m128i): m128i
418 |   {.importc: "_mm_mulhi_epi16", header: "emmintrin.h".}
419 |   ## Exposes _mm_mulhi_epi16 intrinsics
420 | 
421 | proc mulhi_epu16*(a: m128i, b: m128i): m128i
422 |   {.importc: "_mm_mulhi_epu16", header: "emmintrin.h".}
423 |   ## Exposes _mm_mulhi_epu16 intrinsics
424 | 
425 | proc mullo_epi16*(a: m128i, b: m128i): m128i
426 |   {.importc: "_mm_mullo_epi16", header: "emmintrin.h".}
427 |   ## Exposes _mm_mullo_epi16 intrinsics
428 | 
429 | proc mul_epu32*(a: m128i, b: m128i): m128i
430 |   {.importc: "_mm_mul_epu32", header: "emmintrin.h".}
431 |   ## Exposes _mm_mul_epu32 intrinsics
432 | 
433 | proc sad_epu8*(a: m128i, b: m128i): m128i
434 |   {.importc: "_mm_sad_epu8", header: "emmintrin.h".}
435 |   ## Exposes _mm_sad_epu8 intrinsics
436 | 
437 | proc sub_epi8*(a: m128i, b: m128i): m128i
438 |   {.importc: "_mm_sub_epi8", header: "emmintrin.h".}
439 |   ## Exposes _mm_sub_epi8 intrinsics
440 | 
441 | proc sub_epi16*(a: m128i, b: m128i): m128i
442 |   {.importc: "_mm_sub_epi16", header: "emmintrin.h".}
443 |   ## Exposes _mm_sub_epi16 intrinsics
444 | 
445 | proc sub_epi32*(a: m128i, b: m128i): m128i
446 |   {.importc: "_mm_sub_epi32", header: "emmintrin.h".}
447 |   ## Exposes _mm_sub_epi32 intrinsics
448 | 
449 | proc sub_epi64*(a: m128i, b: m128i): m128i
450 |   {.importc: "_mm_sub_epi64", header: "emmintrin.h".}
451 |   ## Exposes _mm_sub_epi64 intrinsics
452 | 
453 | proc subs_epi8*(a: m128i, b: m128i): m128i
454 |   {.importc: "_mm_subs_epi8", header: "emmintrin.h".}
455 |   ## Exposes _mm_subs_epi8 intrinsics
456 | 
457 | proc subs_epi16*(a: m128i, b: m128i): m128i
458 |   {.importc: "_mm_subs_epi16", header: "emmintrin.h".}
459 |   ## Exposes _mm_subs_epi16 intrinsics
460 | 
461 | proc subs_epu8*(a: m128i, b: m128i): m128i
462 |   {.importc: "_mm_subs_epu8", header: "emmintrin.h".}
463 |   ## Exposes _mm_subs_epu8 intrinsics
464 | 
465 | proc subs_epu16*(a: m128i, b: m128i): m128i
466 |   {.importc: "_mm_subs_epu16", header: "emmintrin.h".}
467 |   ## Exposes _mm_subs_epu16 intrinsics
468 | 
469 | proc and_si*(a: m128i, b: m128i): m128i
470 |   {.importc: "_mm_and_si128", header: "emmintrin.h".}
471 |   ## Exposes _mm_and_si128 intrinsics
472 | 
473 | proc andnot_si*(a: m128i, b: m128i): m128i
474 |   {.importc: "_mm_andnot_si128", header: "emmintrin.h".}
475 |   ## Exposes _mm_andnot_si128 intrinsics
476 | 
477 | proc or_si*(a: m128i, b: m128i): m128i
478 |   {.importc: "_mm_or_si128", header: "emmintrin.h".}
479 |   ## Exposes _mm_or_si128 intrinsics
480 | 
481 | proc xor_si*(a: m128i, b: m128i): m128i
482 |   {.importc: "_mm_xor_si128", header: "emmintrin.h".}
483 |   ## Exposes _mm_xor_si128 intrinsics
484 | 
485 | proc slli_epi16*(a: m128i, count: int32): m128i
486 |   {.importc: "_mm_slli_epi16", header: "emmintrin.h".}
487 |   ## Exposes _mm_slli_epi16 intrinsics
488 | 
489 | proc sll_epi16*(a: m128i, count: m128i): m128i
490 |   {.importc: "_mm_sll_epi16", header: "emmintrin.h".}
491 |   ## Exposes _mm_sll_epi16 intrinsics
492 | 
493 | proc slli_epi32*(a: m128i, count: int32): m128i
494 |   {.importc: "_mm_slli_epi32", header: "emmintrin.h".}
495 |   ## Exposes _mm_slli_epi32 intrinsics
496 | 
497 | proc sll_epi32*(a: m128i, count: m128i): m128i
498 |   {.importc: "_mm_sll_epi32", header: "emmintrin.h".}
499 |   ## Exposes _mm_sll_epi32 intrinsics
500 | 
501 | proc slli_epi64*(a: m128i, count: int32): m128i
502 |   {.importc: "_mm_slli_epi64", header: "emmintrin.h".}
503 |   ## Exposes _mm_slli_epi64 intrinsics
504 | 
505 | proc sll_epi64*(a: m128i, count: m128i): m128i
506 |   {.importc: "_mm_sll_epi64", header: "emmintrin.h".}
507 |   ## Exposes _mm_sll_epi64 intrinsics
508 | 
509 | proc srai_epi16*(a: m128i, count: int32): m128i
510 |   {.importc: "_mm_srai_epi16", header: "emmintrin.h".}
511 |   ## Exposes _mm_srai_epi16 intrinsics
512 | 
513 | proc sra_epi16*(a: m128i, count: m128i): m128i
514 |   {.importc: "_mm_sra_epi16", header: "emmintrin.h".}
515 |   ## Exposes _mm_sra_epi16 intrinsics
516 | 
517 | proc srai_epi32*(a: m128i, count: int32): m128i
518 |   {.importc: "_mm_srai_epi32", header: "emmintrin.h".}
519 |   ## Exposes _mm_srai_epi32 intrinsics
520 | 
521 | proc sra_epi32*(a: m128i, count: m128i): m128i
522 |   {.importc: "_mm_sra_epi32", header: "emmintrin.h".}
523 |   ## Exposes _mm_sra_epi32 intrinsics
524 | 
525 | proc srli_epi16*(a: m128i, count: int32): m128i
526 |   {.importc: "_mm_srli_epi16", header: "emmintrin.h".}
527 |   ## Exposes _mm_srli_epi16 intrinsics
528 | 
529 | proc srl_epi16*(a: m128i, count: m128i): m128i
530 |   {.importc: "_mm_srl_epi16", header: "emmintrin.h".}
531 |   ## Exposes _mm_srl_epi16 intrinsics
532 | 
533 | proc srli_epi32*(a: m128i, count: int32): m128i
534 |   {.importc: "_mm_srli_epi32", header: "emmintrin.h".}
535 |   ## Exposes _mm_srli_epi32 intrinsics
536 | 
537 | proc srl_epi32*(a: m128i, count: m128i): m128i
538 |   {.importc: "_mm_srl_epi32", header: "emmintrin.h".}
539 |   ## Exposes _mm_srl_epi32 intrinsics
540 | 
541 | proc srli_epi64*(a: m128i, count: int32): m128i
542 |   {.importc: "_mm_srli_epi64", header: "emmintrin.h".}
543 |   ## Exposes _mm_srli_epi64 intrinsics
544 | 
545 | proc srl_epi64*(a: m128i, count: m128i): m128i
546 |   {.importc: "_mm_srl_epi64", header: "emmintrin.h".}
547 |   ## Exposes _mm_srl_epi64 intrinsics
548 | 
549 | proc cmpeq_epi8*(a: m128i, b: m128i): m128i
550 |   {.importc: "_mm_cmpeq_epi8", header: "emmintrin.h".}
551 |   ## Exposes _mm_cmpeq_epi8 intrinsics
552 | 
553 | proc cmpeq_epi16*(a: m128i, b: m128i): m128i
554 |   {.importc: "_mm_cmpeq_epi16", header: "emmintrin.h".}
555 |   ## Exposes _mm_cmpeq_epi16 intrinsics
556 | 
557 | proc cmpeq_epi32*(a: m128i, b: m128i): m128i
558 |   {.importc: "_mm_cmpeq_epi32", header: "emmintrin.h".}
559 |   ## Exposes _mm_cmpeq_epi32 intrinsics
560 | 
561 | proc cmpgt_epi8*(a: m128i, b: m128i): m128i
562 |   {.importc: "_mm_cmpgt_epi8", header: "emmintrin.h".}
563 |   ## Exposes _mm_cmpgt_epi8 intrinsics
564 | 
565 | proc cmpgt_epi16*(a: m128i, b: m128i): m128i
566 |   {.importc: "_mm_cmpgt_epi16", header: "emmintrin.h".}
567 |   ## Exposes _mm_cmpgt_epi16 intrinsics
568 | 
569 | proc cmpgt_epi32*(a: m128i, b: m128i): m128i
570 |   {.importc: "_mm_cmpgt_epi32", header: "emmintrin.h".}
571 |   ## Exposes _mm_cmpgt_epi32 intrinsics
572 | 
573 | proc cmplt_epi8*(a: m128i, b: m128i): m128i
574 |   {.importc: "_mm_cmplt_epi8", header: "emmintrin.h".}
575 |   ## Exposes _mm_cmplt_epi8 intrinsics
576 | 
577 | proc cmplt_epi16*(a: m128i, b: m128i): m128i
578 |   {.importc: "_mm_cmplt_epi16", header: "emmintrin.h".}
579 |   ## Exposes _mm_cmplt_epi16 intrinsics
580 | 
581 | proc cmplt_epi32*(a: m128i, b: m128i): m128i
582 |   {.importc: "_mm_cmplt_epi32", header: "emmintrin.h".}
583 |   ## Exposes _mm_cmplt_epi32 intrinsics
584 | 
585 | when defined(x86_64):
586 |   proc cvtsi64_sd*(a: m128d, b: int64): m128d
587 |     {.importc: "_mm_cvtsi64_sd", header: "emmintrin.h".}
588 |     ## Exposes _mm_cvtsi64_sd intrinsics
589 | 
590 |   proc cvtsi64_si128*(a: int64): m128i
591 |     {.importc: "_mm_cvtsi64_si128", header: "emmintrin.h".}
592 |     ## Exposes _mm_cvtsi64_si128 intrinsics
593 | 
594 |   proc stream_si64*(p: ptr int64, a: int64): void
595 |     {.importc: "_mm_stream_si64", header: "emmintrin.h".}
596 |     ## Exposes _mm_stream_si64 intrinsics
597 | 
598 | proc cvtepi32_ps*(a: m128i): m128
599 |   {.importc: "_mm_cvtepi32_ps", header: "emmintrin.h".}
600 |   ## Exposes _mm_cvtepi32_ps intrinsics
601 | 
602 | proc cvtps_epi32*(a: m128): m128i
603 |   {.importc: "_mm_cvtps_epi32", header: "emmintrin.h".}
604 |   ## Exposes _mm_cvtps_epi32 intrinsics
605 | 
606 | proc cvttps_epi32*(a: m128): m128i
607 |   {.importc: "_mm_cvttps_epi32", header: "emmintrin.h".}
608 |   ## Exposes _mm_cvttps_epi32 intrinsics
609 | 
610 | proc cvtsi32_si128*(a: int32): m128i
611 |   {.importc: "_mm_cvtsi32_si128", header: "emmintrin.h".}
612 |   ## Exposes _mm_cvtsi32_si128 intrinsics
613 | 
614 | proc cvtsi128_si32*(a: m128i): int32
615 |   {.importc: "_mm_cvtsi128_si32", header: "emmintrin.h".}
616 |   ## Exposes _mm_cvtsi128_si32 intrinsics
617 | 
618 | proc load_si128*(p: ptr m128i): m128i
619 |   {.importc: "_mm_load_si128", header: "emmintrin.h".}
620 |   ## Exposes _mm_load_si128 intrinsics
621 | 
622 | proc loadu_si128*(p: ptr m128i): m128i
623 |   {.importc: "_mm_loadu_si128", header: "emmintrin.h".}
624 |   ## Exposes _mm_loadu_si128 intrinsics
625 | 
626 | proc loadl_epi64*(p: ptr m128i): m128i
627 |   {.importc: "_mm_loadl_epi64", header: "emmintrin.h".}
628 |   ## Exposes _mm_loadl_epi64 intrinsics
629 | 
630 | proc set_epi32*(i3: int32, i2: int32, i1: int32, i0: int32): m128i
631 |   {.importc: "_mm_set_epi32", header: "emmintrin.h".}
632 |   ## Exposes _mm_set_epi32 intrinsics
633 | 
634 | proc set_epi16*(w7: int16, w6: int16, w5: int16, w4: int16, w3: int16, w2: int16, w1: int16, w0: int16): m128i
635 |   {.importc: "_mm_set_epi16", header: "emmintrin.h".}
636 |   ## Exposes _mm_set_epi16 intrinsics
637 | 
638 | proc set_epi8*(b15: int8, b14: int8, b13: int8, b12: int8, b11: int8, b10: int8, b9: int8, b8: int8, b7: int8, b6: int8, b5: int8, b4: int8, b3: int8, b2: int8, b1: int8, b0: int8): m128i
639 |   {.importc: "_mm_set_epi8", header: "emmintrin.h".}
640 |   ## Exposes _mm_set_epi8 intrinsics
641 | 
642 | proc set1_epi32*(i: int32): m128i
643 |   {.importc: "_mm_set1_epi32", header: "emmintrin.h".}
644 |   ## Exposes _mm_set1_epi32 intrinsics
645 | 
646 | proc set1_epi16*(w: int16): m128i
647 |   {.importc: "_mm_set1_epi16", header: "emmintrin.h".}
648 |   ## Exposes _mm_set1_epi16 intrinsics
649 | 
650 | proc set1_epi8*(b: int8): m128i
651 |   {.importc: "_mm_set1_epi8", header: "emmintrin.h".}
652 |   ## Exposes _mm_set1_epi8 intrinsics
653 | 
654 | proc setr_epi32*(i0: int32, i1: int32, i2: int32, i3: int32): m128i
655 |   {.importc: "_mm_setr_epi32", header: "emmintrin.h".}
656 |   ## Exposes _mm_setr_epi32 intrinsics
657 | 
658 | proc setr_epi16*(w0: int16, w1: int16, w2: int16, w3: int16, w4: int16, w5: int16, w6: int16, w7: int16): m128i
659 |   {.importc: "_mm_setr_epi16", header: "emmintrin.h".}
660 |   ## Exposes _mm_setr_epi16 intrinsics
661 | 
662 | proc setr_epi8*(b0: int8, b1: int8, b2: int8, b3: int8, b4: int8, b5: int8, b6: int8, b7: int8, b8: int8, b9: int8, b10: int8, b11: int8, b12: int8, b13: int8, b14: int8, b15: int8): m128i
663 |   {.importc: "_mm_setr_epi8", header: "emmintrin.h".}
664 |   ## Exposes _mm_setr_epi8 intrinsics
665 | 
666 | proc setzero_si128*(): m128i
667 |   {.importc: "_mm_setzero_si128", header: "emmintrin.h".}
668 |   ## Exposes _mm_setzero_si128 intrinsics
669 | 
670 | proc store_si128*(p: ptr m128i, b: m128i): void
671 |   {.importc: "_mm_store_si128", header: "emmintrin.h".}
672 |   ## Exposes _mm_store_si128 intrinsics
673 | 
674 | proc storeu_si128*(p: ptr m128i, b: m128i): void
675 |   {.importc: "_mm_storeu_si128", header: "emmintrin.h".}
676 |   ## Exposes _mm_storeu_si128 intrinsics
677 | 
678 | proc maskmoveu_si128*(d: m128i, n: m128i, p: ptr int8): void
679 |   {.importc: "_mm_maskmoveu_si128", header: "emmintrin.h".}
680 |   ## Exposes _mm_maskmoveu_si128 intrinsics
681 | 
682 | proc storel_epi64*(p: ptr m128i, a: m128i): void
683 |   {.importc: "_mm_storel_epi64", header: "emmintrin.h".}
684 |   ## Exposes _mm_storel_epi64 intrinsics
685 | 
686 | proc stream_pd*(p: ptr float64, a: m128d): void
687 |   {.importc: "_mm_stream_pd", header: "emmintrin.h".}
688 |   ## Exposes _mm_stream_pd intrinsics
689 | 
690 | proc stream_si128*(p: ptr m128i, a: m128i): void
691 |   {.importc: "_mm_stream_si128", header: "emmintrin.h".}
692 |   ## Exposes _mm_stream_si128 intrinsics
693 | 
694 | proc stream_si32*(p: ptr int32, a: int32): void
695 |   {.importc: "_mm_stream_si32", header: "emmintrin.h".}
696 |   ## Exposes _mm_stream_si32 intrinsics
697 | 
698 | proc clflush*(p: ptr int8): void
699 |   {.importc: "_mm_clflush", header: "emmintrin.h".}
700 |   ## Exposes _mm_clflush intrinsics
701 | 
702 | proc lfence*(): void
703 |   {.importc: "_mm_lfence", header: "emmintrin.h".}
704 |   ## Exposes _mm_lfence intrinsics
705 | 
706 | proc mfence*(): void
707 |   {.importc: "_mm_mfence", header: "emmintrin.h".}
708 |   ## Exposes _mm_mfence intrinsics
709 | 
710 | proc packs_epi16*(a: m128i, b: m128i): m128i
711 |   {.importc: "_mm_packs_epi16", header: "emmintrin.h".}
712 |   ## Exposes _mm_packs_epi16 intrinsics
713 | 
714 | proc packs_epi32*(a: m128i, b: m128i): m128i
715 |   {.importc: "_mm_packs_epi32", header: "emmintrin.h".}
716 |   ## Exposes _mm_packs_epi32 intrinsics
717 | 
718 | proc packus_epi16*(a: m128i, b: m128i): m128i
719 |   {.importc: "_mm_packus_epi16", header: "emmintrin.h".}
720 |   ## Exposes _mm_packus_epi16 intrinsics
721 | 
722 | proc extract_epi16*(a: m128i, imm: int32): int32
723 |   {.importc: "_mm_extract_epi16", header: "emmintrin.h".}
724 |   ## Exposes _mm_extract_epi16 intrinsics
725 | 
726 | proc insert_epi16*(a: m128i, b: int32, imm: int32): m128i
727 |   {.importc: "_mm_insert_epi16", header: "emmintrin.h".}
728 |   ## Exposes _mm_insert_epi16 intrinsics
729 | 
730 | proc movemask_epi8*(a: m128i): int32
731 |   {.importc: "_mm_movemask_epi8", header: "emmintrin.h".}
732 |   ## Exposes _mm_movemask_epi8 intrinsics
733 | 
734 | proc unpackhi_epi8*(a: m128i, b: m128i): m128i
735 |   {.importc: "_mm_unpackhi_epi8", header: "emmintrin.h".}
736 |   ## Exposes _mm_unpackhi_epi8 intrinsics
737 | 
738 | proc unpackhi_epi16*(a: m128i, b: m128i): m128i
739 |   {.importc: "_mm_unpackhi_epi16", header: "emmintrin.h".}
740 |   ## Exposes _mm_unpackhi_epi16 intrinsics
741 | 
742 | proc unpackhi_epi32*(a: m128i, b: m128i): m128i
743 |   {.importc: "_mm_unpackhi_epi32", header: "emmintrin.h".}
744 |   ## Exposes _mm_unpackhi_epi32 intrinsics
745 | 
746 | proc unpackhi_epi64*(a: m128i, b: m128i): m128i
747 |   {.importc: "_mm_unpackhi_epi64", header: "emmintrin.h".}
748 |   ## Exposes _mm_unpackhi_epi64 intrinsics
749 | 
750 | proc unpacklo_epi8*(a: m128i, b: m128i): m128i
751 |   {.importc: "_mm_unpacklo_epi8", header: "emmintrin.h".}
752 |   ## Exposes _mm_unpacklo_epi8 intrinsics
753 | 
754 | proc unpacklo_epi16*(a: m128i, b: m128i): m128i
755 |   {.importc: "_mm_unpacklo_epi16", header: "emmintrin.h".}
756 |   ## Exposes _mm_unpacklo_epi16 intrinsics
757 | 
758 | proc unpacklo_epi32*(a: m128i, b: m128i): m128i
759 |   {.importc: "_mm_unpacklo_epi32", header: "emmintrin.h".}
760 |   ## Exposes _mm_unpacklo_epi32 intrinsics
761 | 
762 | proc unpacklo_epi64*(a: m128i, b: m128i): m128i
763 |   {.importc: "_mm_unpacklo_epi64", header: "emmintrin.h".}
764 |   ## Exposes _mm_unpacklo_epi64 intrinsics
765 | 
766 | proc move_epi64*(a: m128i): m128i
767 |   {.importc: "_mm_move_epi64", header: "emmintrin.h".}
768 |   ## Exposes _mm_move_epi64 intrinsics
769 | 
770 | proc unpackhi_pd*(a: m128d, b: m128d): m128d
771 |   {.importc: "_mm_unpackhi_pd", header: "emmintrin.h".}
772 |   ## Exposes _mm_unpackhi_pd intrinsics
773 | 
774 | proc unpacklo_pd*(a: m128d, b: m128d): m128d
775 |   {.importc: "_mm_unpacklo_pd", header: "emmintrin.h".}
776 |   ## Exposes _mm_unpacklo_pd intrinsics
777 | 
778 | proc movemask_pd*(a: m128d): int32
779 |   {.importc: "_mm_movemask_pd", header: "emmintrin.h".}
780 |   ## Exposes _mm_movemask_pd intrinsics
781 | 
782 | proc castpd_ps*(a: m128d): m128
783 |   {.importc: "_mm_castpd_ps", header: "emmintrin.h".}
784 |   ## Exposes _mm_castpd_ps intrinsics
785 | 
786 | proc castpd_si*(a: m128d): m128i
787 |   {.importc: "_mm_castpd_si128", header: "emmintrin.h".}
788 |   ## Exposes _mm_castpd_si128 intrinsics
789 | 
790 | proc castps_pd*(a: m128): m128d
791 |   {.importc: "_mm_castps_pd", header: "emmintrin.h".}
792 |   ## Exposes _mm_castps_pd intrinsics
793 | 
794 | proc castps_si*(a: m128): m128i
795 |   {.importc: "_mm_castps_si128", header: "emmintrin.h".}
796 |   ## Exposes _mm_castps_si128 intrinsics
797 | 
798 | proc castsi128_ps*(a: m128i): m128
799 |   {.importc: "_mm_castsi128_ps", header: "emmintrin.h".}
800 |   ## Exposes _mm_castsi128_ps intrinsics
801 | 
802 | proc castsi128_pd*(a: m128i): m128d
803 |   {.importc: "_mm_castsi128_pd", header: "emmintrin.h".}
804 |   ## Exposes _mm_castsi128_pd intrinsics
805 | 
806 | proc pause*(): void
807 |   {.importc: "_mm_pause", header: "emmintrin.h".}
808 |   ## Exposes _mm_pause intrinsics
809 | 
810 | proc slli_si128*(a: m128i, b: int32): m128i
811 |   {.importc: "_mm_slli_si128", header: "emmintrin.h".}
812 |   ## Exposes _mm_slli_si128 intrinsics
813 | 
814 | proc srli_si128*(a: m128i, b: int32): m128i
815 |   {.importc: "_mm_srli_si128", header: "emmintrin.h".}
816 |   ## Exposes _mm_srli_si128 intrinsics
817 | 
818 | proc shuffle_epi32*(a: m128i, b: int32): m128i
819 |   {.importc: "_mm_shuffle_epi32", header: "emmintrin.h".}
820 |   ## Exposes _mm_shuffle_epi32 intrinsics
821 | 
822 | proc shufflelo_epi16*(a: m128i, b: int32): m128i
823 |   {.importc: "_mm_shufflelo_epi16", header: "emmintrin.h".}
824 |   ## Exposes _mm_shufflelo_epi16 intrinsics
825 | 
826 | proc shufflehi_epi16*(a: m128i, b: int32): m128i
827 |   {.importc: "_mm_shufflehi_epi16", header: "emmintrin.h".}
828 |   ## Exposes _mm_shufflehi_epi16 intrinsics
829 | 
830 | proc shuffle_pd*(a: m128d, b: m128d, c: int32): m128d
831 |   {.importc: "_mm_shuffle_pd", header: "emmintrin.h".}
832 |   ## Exposes _mm_shuffle_pd intrinsics
833 | 
834 | when not vcc64Bits:
835 |   proc cvtpd_pi32*(a: m128d): m64
836 |     {.importc: "_mm_cvtpd_pi32", header: "emmintrin.h".}
837 |     ## Exposes _mm_cvtpd_pi32 intrinsics
838 | 
839 |   proc cvttpd_pi32*(a: m128d): m64
840 |     {.importc: "_mm_cvttpd_pi32", header: "emmintrin.h".}
841 |     ## Exposes _mm_cvttpd_pi32 intrinsics
842 | 
843 |   proc cvtpi32_pd*(a: m64): m128d
844 |     {.importc: "_mm_cvtpi32_pd", header: "emmintrin.h".}
845 |     ## Exposes _mm_cvtpi32_pd intrinsics
846 | 
847 |   proc add_si64*(a: m64, b: m64): m64
848 |     {.importc: "_mm_add_si64", header: "emmintrin.h".}
849 |     ## Exposes _mm_add_si64 intrinsics
850 | 
851 |   proc set_epi64*(q1: m64, q0: m64): m128i
852 |     {.importc: "_mm_set_epi64", header: "emmintrin.h".}
853 |     ## Exposes _mm_set_epi64 intrinsics
854 | 
855 |   proc mul_su32*(a: m64, b: m64): m64
856 |     {.importc: "_mm_mul_su32", header: "emmintrin.h".}
857 |     ## Exposes _mm_mul_su32 intrinsics
858 | 
859 |   proc sub_si64*(a: m64, b: m64): m64
860 |     {.importc: "_mm_sub_si64", header: "emmintrin.h".}
861 |     ## Exposes _mm_sub_si64 intrinsics
862 | 
863 |   proc set1_epi64*(q: m64): m128i
864 |     {.importc: "_mm_set1_epi64", header: "emmintrin.h".}
865 |     ## Exposes _mm_set1_epi64 intrinsics
866 | 
867 |   proc setr_epi64*(q0: m64, q1: m64): m128i
868 |     {.importc: "_mm_setr_epi64", header: "emmintrin.h".}
869 |     ## Exposes _mm_setr_epi64 intrinsics
870 | 
871 |   proc movepi64_pi64*(a: m128i): m64
872 |     {.importc: "_mm_movepi64_pi64", header: "emmintrin.h".}
873 |     ## Exposes _mm_movepi64_pi64 intrinsics
874 | 
875 |   proc movpi64_epi64*(a: m64): m128i
876 |     {.importc: "_mm_movpi64_epi64", header: "emmintrin.h".}
877 |     ## Exposes _mm_movpi64_epi64 intrinsics
878 | 
879 | 


--------------------------------------------------------------------------------