basis/compiler/cfg/intrinsics/simd/simd.factor

   1 ! Copyright (C) 2009 Slava Pestov, Joe Groff.
   2 ! See http://factorcode.org/license.txt for BSD license.
   3 USING: accessors alien alien.c-types byte-arrays fry
   4 classes.algebra cpu.architecture kernel math sequences
   5 math.vectors math.vectors.simd.intrinsics
   6 macros generalizations combinators combinators.short-circuit
   7 arrays locals compiler.tree.propagation.info
   8 compiler.cfg.builder.blocks
   9 compiler.cfg.comparisons
  10 compiler.cfg.stacks compiler.cfg.stacks.local compiler.cfg.hats
  11 compiler.cfg.instructions compiler.cfg.registers
  12 compiler.cfg.intrinsics
  13 compiler.cfg.intrinsics.alien
  14 compiler.cfg.intrinsics.simd.backend
  15 specialized-arrays ;
  16 FROM: alien.c-types => heap-size char short int longlong float double ;
  17 SPECIALIZED-ARRAYS: char uchar short ushort int uint longlong ulonglong float double ;
  18 IN: compiler.cfg.intrinsics.simd
  19
  20 ! compound vector ops
  21
  22 : sign-bit-mask ( rep -- byte-array )
  23     unsign-rep {
  24         { char-16-rep [ uchar-array{
  25             HEX: 80 HEX: 80 HEX: 80 HEX: 80
  26             HEX: 80 HEX: 80 HEX: 80 HEX: 80
  27             HEX: 80 HEX: 80 HEX: 80 HEX: 80
  28             HEX: 80 HEX: 80 HEX: 80 HEX: 80
  29         } underlying>> ] }
  30         { short-8-rep [ ushort-array{
  31             HEX: 8000 HEX: 8000 HEX: 8000 HEX: 8000
  32             HEX: 8000 HEX: 8000 HEX: 8000 HEX: 8000
  33         } underlying>> ] }
  34         { int-4-rep [ uint-array{
  35             HEX: 8000,0000 HEX: 8000,0000
  36             HEX: 8000,0000 HEX: 8000,0000
  37         } underlying>> ] }
  38         { longlong-2-rep [ ulonglong-array{
  39             HEX: 8000,0000,0000,0000
  40             HEX: 8000,0000,0000,0000
  41         } underlying>> ] }
  42     } case ;
  43
  44 : ^load-neg-zero-vector ( rep -- dst )
  45     {
  46         { float-4-rep [ float-array{ -0.0 -0.0 -0.0 -0.0 } underlying>> ^^load-constant ] }
  47         { double-2-rep [ double-array{ -0.0 -0.0 } underlying>> ^^load-constant ] }
  48     } case ;
  49
  50 : ^load-add-sub-vector ( rep -- dst )
  51     unsign-rep {
  52         { float-4-rep    [ float-array{ -0.0  0.0 -0.0  0.0 } underlying>> ^^load-constant ] }
  53         { double-2-rep   [ double-array{ -0.0  0.0 } underlying>> ^^load-constant ] }
  54         { char-16-rep    [ char-array{ -1 0 -1 0 -1 0 -1 0 -1 0 -1 0 -1 0 -1 0 } underlying>> ^^load-constant ] }
  55         { short-8-rep    [ short-array{ -1 0 -1 0 -1 0 -1 0 } underlying>> ^^load-constant ] }
  56         { int-4-rep      [ int-array{ -1 0 -1 0 } underlying>> ^^load-constant ] }
  57         { longlong-2-rep [ longlong-array{ -1 0 } underlying>> ^^load-constant ] }
  58     } case ;
  59
  60 : >variable-shuffle ( shuffle rep -- shuffle' )
  61     rep-component-type heap-size
  62     [ dup <repetition> >byte-array ]
  63     [ iota >byte-array ] bi
  64     '[ _ n*v _ v+ ] map concat ;
  65
  66 : ^load-immediate-shuffle ( shuffle rep -- dst )
  67     >variable-shuffle ^^load-constant ;
  68
  69 :: ^blend-vector ( mask true false rep -- dst )
  70     true mask rep ^^and-vector
  71     mask false rep ^^andn-vector
  72     rep ^^or-vector ;
  73
  74 : ^not-vector ( src rep -- dst )
  75     {
  76         [ ^^not-vector ]
  77         [ [ ^^fill-vector ] [ ^^xor-vector ] bi ]
  78     } v-vector-op ;
  79
  80 :: ^((compare-vector)) ( src1 src2 rep {cc,swap} -- dst )
  81     {cc,swap} first2 :> ( cc swap? )
  82     swap?
  83     [ src2 src1 rep cc ^^compare-vector ]
  84     [ src1 src2 rep cc ^^compare-vector ] if ;
  85
  86 :: ^(compare-vector) ( src1 src2 rep orig-cc -- dst )
  87     rep orig-cc %compare-vector-ccs :> ( ccs not? )
  88
  89     ccs empty?
  90     [ rep not? [ ^^fill-vector ] [ ^^zero-vector ] if ]
  91     [
  92         ccs unclip :> ( rest-ccs first-cc )
  93         src1 src2 rep first-cc ^((compare-vector)) :> first-dst
  94
  95         rest-ccs first-dst
  96         [ [ src1 src2 rep ] dip ^((compare-vector)) rep ^^or-vector ]
  97         reduce
  98
  99         not? [ rep ^not-vector ] when
 100     ] if ;
 101
 102 :: ^minmax-compare-vector ( src1 src2 rep cc -- dst )
 103     cc order-cc {
 104         { cc<  [ src1 src2 rep ^^max-vector src1 rep cc/= ^(compare-vector) ] }
 105         { cc<= [ src1 src2 rep ^^min-vector src1 rep cc=  ^(compare-vector) ] }
 106         { cc>  [ src1 src2 rep ^^min-vector src1 rep cc/= ^(compare-vector) ] }
 107         { cc>= [ src1 src2 rep ^^max-vector src1 rep cc=  ^(compare-vector) ] }
 108     } case ;
 109
 110 : ^compare-vector ( src1 src2 rep cc -- dst )
 111     {
 112         [ ^(compare-vector) ]
 113         [ ^minmax-compare-vector ]
 114         { unsigned-int-vector-rep [| src1 src2 rep cc |
 115             rep sign-bit-mask ^^load-constant :> sign-bits
 116             src1 sign-bits rep ^^xor-vector
 117             src2 sign-bits rep ^^xor-vector
 118             rep unsign-rep cc ^(compare-vector)
 119         ] }
 120     } vv-cc-vector-op ;
 121
 122 : ^unpack-vector-head ( src rep -- dst )
 123     {
 124         [ ^^unpack-vector-head ]
 125         { unsigned-int-vector-rep [ [ ^^zero-vector ] [ ^^merge-vector-head ] bi ] }
 126         { signed-int-vector-rep [| src rep |
 127             src src rep ^^merge-vector-head :> merged
 128             rep rep-component-type heap-size 8 * :> bits
 129             merged bits rep widen-vector-rep ^^shr-vector-imm
 130         ] }
 131         { signed-int-vector-rep [| src rep |
 132             rep ^^zero-vector :> zero
 133             zero src rep cc> ^compare-vector :> sign
 134             src sign rep ^^merge-vector-head
 135         ] }
 136     } v-vector-op ;
 137
 138 : ^unpack-vector-tail ( src rep -- dst )
 139     {
 140         [ ^^unpack-vector-tail ]
 141         [ [ ^^tail>head-vector ] [ ^^unpack-vector-head ] bi ]
 142         { unsigned-int-vector-rep [ [ ^^zero-vector ] [ ^^merge-vector-tail ] bi ] }
 143         { signed-int-vector-rep [| src rep |
 144             src src rep ^^merge-vector-tail :> merged
 145             rep rep-component-type heap-size 8 * :> bits
 146             merged bits rep widen-vector-rep ^^shr-vector-imm
 147         ] }
 148         { signed-int-vector-rep [| src rep |
 149             rep ^^zero-vector :> zero
 150             zero src rep cc> ^compare-vector :> sign
 151             src sign rep ^^merge-vector-tail
 152         ] }
 153     } v-vector-op ;
 154
 155 : ^(sum-vector-2) ( src rep -- dst )
 156     {
 157         [ dupd ^^horizontal-add-vector ]
 158         [| src rep |
 159             src src rep ^^merge-vector-head :> head
 160             src src rep ^^merge-vector-tail :> tail
 161             head tail rep ^^add-vector
 162         ]
 163     } v-vector-op ;
 164
 165 : ^(sum-vector-4) ( src rep -- dst )
 166     {
 167         [
 168             [ dupd ^^horizontal-add-vector ]
 169             [ dupd ^^horizontal-add-vector ] bi
 170         ]
 171         [| src rep |
 172             src src rep ^^merge-vector-head :> head
 173             src src rep ^^merge-vector-tail :> tail
 174             head tail rep ^^add-vector :> src'
 175
 176             rep widen-vector-rep :> rep'
 177             src' src' rep' ^^merge-vector-head :> head'
 178             src' src' rep' ^^merge-vector-tail :> tail'
 179             head' tail' rep ^^add-vector
 180         ]
 181     } v-vector-op ;
 182
 183 : ^(sum-vector-8) ( src rep -- dst )
 184     {
 185         [
 186             [ dupd ^^horizontal-add-vector ]
 187             [ dupd ^^horizontal-add-vector ]
 188             [ dupd ^^horizontal-add-vector ] tri
 189         ]
 190         [| src rep |
 191             src src rep ^^merge-vector-head :> head
 192             src src rep ^^merge-vector-tail :> tail
 193             head tail rep ^^add-vector :> src'
 194
 195             rep widen-vector-rep :> rep'
 196             src' src' rep' ^^merge-vector-head :> head'
 197             src' src' rep' ^^merge-vector-tail :> tail'
 198             head' tail' rep ^^add-vector :> src''
 199
 200             rep' widen-vector-rep :> rep''
 201             src'' src'' rep'' ^^merge-vector-head :> head''
 202             src'' src'' rep'' ^^merge-vector-tail :> tail''
 203             head'' tail'' rep ^^add-vector
 204         ]
 205     } v-vector-op ;
 206
 207 : ^(sum-vector-16) ( src rep -- dst )
 208     {
 209         [
 210             {
 211                 [ dupd ^^horizontal-add-vector ]
 212                 [ dupd ^^horizontal-add-vector ]
 213                 [ dupd ^^horizontal-add-vector ]
 214                 [ dupd ^^horizontal-add-vector ]
 215             } cleave
 216         ]
 217         [| src rep |
 218             src src rep ^^merge-vector-head :> head
 219             src src rep ^^merge-vector-tail :> tail
 220             head tail rep ^^add-vector :> src'
 221
 222             rep widen-vector-rep :> rep'
 223             src' src' rep' ^^merge-vector-head :> head'
 224             src' src' rep' ^^merge-vector-tail :> tail'
 225             head' tail' rep ^^add-vector :> src''
 226
 227             rep' widen-vector-rep :> rep''
 228             src'' src'' rep'' ^^merge-vector-head :> head''
 229             src'' src'' rep'' ^^merge-vector-tail :> tail''
 230             head'' tail'' rep ^^add-vector :> src'''
 231
 232             rep'' widen-vector-rep :> rep'''
 233             src''' src''' rep''' ^^merge-vector-head :> head'''
 234             src''' src''' rep''' ^^merge-vector-tail :> tail'''
 235             head''' tail''' rep ^^add-vector
 236         ]
 237     } v-vector-op ;
 238
 239 : ^(sum-vector) ( src rep -- dst )
 240     [
 241         dup rep-length {
 242             {  2 [ ^(sum-vector-2) ] }
 243             {  4 [ ^(sum-vector-4) ] }
 244             {  8 [ ^(sum-vector-8) ] }
 245             { 16 [ ^(sum-vector-16) ] }
 246         } case
 247     ] [ ^^vector>scalar ] bi ;
 248
 249 : ^sum-vector ( src rep -- dst )
 250     unsign-rep {
 251         { float-vector-rep [ ^(sum-vector) ] }
 252         { int-vector-rep [| src rep |
 253             src rep ^unpack-vector-head :> head
 254             src rep ^unpack-vector-tail :> tail
 255             rep widen-vector-rep :> wide-rep
 256             head tail wide-rep ^^add-vector wide-rep
 257             ^(sum-vector)
 258         ] }
 259     } v-vector-op ;
 260
 261 : shuffle? ( obj -- ? ) { [ array? ] [ [ integer? ] all? ] } 1&& ;
 262
 263 : ^shuffle-vector-imm ( src1 shuffle rep -- dst )
 264     [ rep-length 0 pad-tail ] keep {
 265         [ ^^shuffle-vector-imm ]
 266         [ [ ^load-immediate-shuffle ] [ ^^shuffle-vector ] bi ]
 267     } vl-vector-op ;
 268
 269 : ^broadcast-vector ( src n rep -- dst )
 270     [ rep-length swap <array> ] keep
 271     ^shuffle-vector-imm ;
 272
 273 : ^with-vector ( src rep -- dst )
 274     [ ^^scalar>vector ] keep [ 0 ] dip ^broadcast-vector ;
 275
 276 : ^select-vector ( src n rep -- dst )
 277     [ ^broadcast-vector ] keep ^^vector>scalar ;
 278
 279 ! intrinsic emitters
 280
 281 : emit-simd-v+ ( node -- )
 282     {
 283         [ ^^add-vector ]
 284     } emit-vv-vector-op ;
 285
 286 : emit-simd-v- ( node -- )
 287     {
 288         [ ^^sub-vector ]
 289     } emit-vv-vector-op ;
 290
 291 : emit-simd-vneg ( node -- )
 292     {
 293         { float-vector-rep [ [ ^load-neg-zero-vector ] [ ^^sub-vector ] bi ] }
 294         { int-vector-rep   [ [ ^^zero-vector         ] [ ^^sub-vector ] bi ] }
 295     } emit-v-vector-op ;
 296
 297 : emit-simd-v+- ( node -- )
 298     {
 299         [ ^^add-sub-vector ]
 300         { float-vector-rep [| src1 src2 rep |
 301             rep ^load-add-sub-vector :> signs
 302             src2 signs rep ^^xor-vector :> src2'
 303             src1 src2' rep ^^add-vector
 304         ] }
 305         { int-vector-rep   [| src1 src2 rep |
 306             rep ^load-add-sub-vector :> signs
 307             src2  signs rep ^^xor-vector :> src2'
 308             src2' signs rep ^^sub-vector :> src2''
 309             src1 src2'' rep ^^add-vector
 310         ] }
 311     } emit-vv-vector-op ;
 312
 313 : emit-simd-vs+ ( node -- )
 314     {
 315         { float-vector-rep [ ^^add-vector ] }
 316         { int-vector-rep [ ^^saturated-add-vector ] }
 317     } emit-vv-vector-op ;
 318
 319 : emit-simd-vs- ( node -- )
 320     {
 321         { float-vector-rep [ ^^sub-vector ] }
 322         { int-vector-rep [ ^^saturated-sub-vector ] }
 323     } emit-vv-vector-op ;
 324
 325 : emit-simd-vs* ( node -- )
 326     {
 327         { float-vector-rep [ ^^mul-vector ] }
 328         { int-vector-rep [ ^^saturated-mul-vector ] }
 329     } emit-vv-vector-op ;
 330
 331 : emit-simd-v* ( node -- )
 332     {
 333         [ ^^mul-vector ]
 334     } emit-vv-vector-op ;
 335
 336 : emit-simd-v/ ( node -- )
 337     {
 338         [ ^^div-vector ]
 339     } emit-vv-vector-op ;
 340
 341 : emit-simd-vmin ( node -- )
 342     {
 343         [ ^^min-vector ]
 344         [
 345             [ cc< ^compare-vector ]
 346             [ ^blend-vector ] 3bi
 347         ]
 348     } emit-vv-vector-op ;
 349
 350 : emit-simd-vmax ( node -- )
 351     {
 352         [ ^^max-vector ]
 353         [
 354             [ cc> ^compare-vector ]
 355             [ ^blend-vector ] 3bi
 356         ]
 357     } emit-vv-vector-op ;
 358
 359 : emit-simd-v. ( node -- )
 360     {
 361         [ ^^dot-vector ]
 362         { float-vector-rep [ [ ^^mul-vector ] [ ^sum-vector ] bi ] }
 363     } emit-vv-vector-op ;
 364
 365 : emit-simd-vsqrt ( node -- )
 366     {
 367         [ ^^sqrt-vector ]
 368     } emit-v-vector-op ;
 369
 370 : emit-simd-sum ( node -- )
 371     {
 372         [ ^sum-vector ]
 373     } emit-v-vector-op ;
 374
 375 : emit-simd-vabs ( node -- )
 376     {
 377         { unsigned-int-vector-rep [ drop ] }
 378         [ ^^abs-vector ]
 379         { float-vector-rep [ [ ^load-neg-zero-vector ] [ swapd ^^andn-vector ] bi ] }
 380         { int-vector-rep [| src rep |
 381             rep ^^zero-vector :> zero
 382             zero src rep ^^sub-vector :> -src
 383             zero src rep cc> ^compare-vector :> sign
 384             sign -src src rep ^blend-vector
 385         ] }
 386     } emit-v-vector-op ;
 387
 388 : emit-simd-vand ( node -- )
 389     {
 390         [ ^^and-vector ]
 391     } emit-vv-vector-op ;
 392
 393 : emit-simd-vandn ( node -- )
 394     {
 395         [ ^^andn-vector ]
 396     } emit-vv-vector-op ;
 397
 398 : emit-simd-vor ( node -- )
 399     {
 400         [ ^^or-vector ]
 401     } emit-vv-vector-op ;
 402
 403 : emit-simd-vxor ( node -- )
 404     {
 405         [ ^^xor-vector ]
 406     } emit-vv-vector-op ;
 407
 408 : emit-simd-vnot ( node -- )
 409     {
 410         [ ^not-vector ]
 411     } emit-v-vector-op ;
 412
 413 : emit-simd-vlshift ( node -- )
 414     {
 415         [ ^^shl-vector ]
 416     } {
 417         [ ^^shl-vector-imm ]
 418     } [ integer? ] emit-vv-or-vl-vector-op ;
 419
 420 : emit-simd-vrshift ( node -- )
 421     {
 422         [ ^^shr-vector ]
 423     } {
 424         [ ^^shr-vector-imm ]
 425     } [ integer? ] emit-vv-or-vl-vector-op ;
 426
 427 : emit-simd-hlshift ( node -- )
 428     {
 429         [ ^^horizontal-shl-vector-imm ]
 430     } [ integer? ] emit-vl-vector-op ;
 431
 432 : emit-simd-hrshift ( node -- )
 433     {
 434         [ ^^horizontal-shr-vector-imm ]
 435     } [ integer? ] emit-vl-vector-op ;
 436
 437 : emit-simd-vshuffle-elements ( node -- )
 438     {
 439         [ ^shuffle-vector-imm ]
 440     } [ shuffle? ] emit-vl-vector-op ;
 441
 442 : emit-simd-vshuffle-bytes ( node -- )
 443     {
 444         [ ^^shuffle-vector ]
 445     } emit-vv-vector-op ;
 446
 447 : emit-simd-vmerge-head ( node -- )
 448     {
 449         [ ^^merge-vector-head ]
 450     } emit-vv-vector-op ;
 451
 452 : emit-simd-vmerge-tail ( node -- )
 453     {
 454         [ ^^merge-vector-tail ]
 455     } emit-vv-vector-op ;
 456
 457 : emit-simd-v<= ( node -- )
 458     {
 459         [ cc<= ^compare-vector ]
 460     } emit-vv-vector-op ;
 461 : emit-simd-v< ( node -- )
 462     {
 463         [ cc< ^compare-vector ]
 464     } emit-vv-vector-op ;
 465 : emit-simd-v= ( node -- )
 466     {
 467         [ cc=  ^compare-vector ]
 468     } emit-vv-vector-op ;
 469 : emit-simd-v> ( node -- )
 470     {
 471         [ cc>  ^compare-vector ]
 472     } emit-vv-vector-op ;
 473 : emit-simd-v>= ( node -- )
 474     {
 475         [ cc>= ^compare-vector ]
 476     } emit-vv-vector-op ;
 477 : emit-simd-vunordered? ( node -- )
 478     {
 479         [ cc/<>= ^compare-vector ]
 480     } emit-vv-vector-op ;
 481
 482 : emit-simd-vany? ( node -- )
 483     {
 484         [ vcc-any ^^test-vector ]
 485     } emit-v-vector-op ;
 486 : emit-simd-vall? ( node -- )
 487     {
 488         [ vcc-all ^^test-vector ]
 489     } emit-v-vector-op ;
 490 : emit-simd-vnone? ( node -- )
 491     {
 492         [ vcc-none ^^test-vector ]
 493     } emit-v-vector-op ;
 494
 495 : emit-simd-v>float ( node -- )
 496     {
 497         { float-vector-rep [ drop ] }
 498         { int-vector-rep [ ^^integer>float-vector ] }
 499     } emit-v-vector-op ;
 500
 501 : emit-simd-v>integer ( node -- )
 502     {
 503         { float-vector-rep [ ^^float>integer-vector ] }
 504         { int-vector-rep [ drop ] }
 505     } emit-v-vector-op ;
 506
 507 : emit-simd-vpack-signed ( node -- )
 508     {
 509         [ ^^signed-pack-vector ]
 510     } emit-vv-vector-op ;
 511
 512 : emit-simd-vpack-unsigned ( node -- )
 513     {
 514         [ ^^unsigned-pack-vector ]
 515     } emit-vv-vector-op ;
 516
 517 : emit-simd-vunpack-head ( node -- )
 518     {
 519         [ ^unpack-vector-head ]
 520     } emit-v-vector-op ;
 521
 522 : emit-simd-vunpack-tail ( node -- )
 523     {
 524         [ ^unpack-vector-tail ]
 525     } emit-v-vector-op ;
 526
 527 : emit-simd-with ( node -- )
 528     {
 529         [ ^with-vector ]
 530     } emit-v-vector-op ;
 531
 532 : emit-simd-gather-2 ( node -- )
 533     {
 534         [ ^^gather-vector-2 ]
 535     } emit-vv-vector-op ;
 536
 537 : emit-simd-gather-4 ( node -- )
 538     {
 539         [ ^^gather-vector-4 ]
 540     } emit-vvvv-vector-op ;
 541
 542 : emit-simd-select ( node -- )
 543     {
 544         [ ^select-vector ]
 545     } [ integer? ] emit-vl-vector-op ;
 546
 547 : emit-alien-vector ( node -- )
 548     dup [
 549         '[
 550             ds-drop prepare-alien-getter
 551             _ ^^alien-vector ds-push
 552         ]
 553         [ inline-alien-getter? ] inline-alien
 554     ] with { [ %alien-vector-reps member? ] } if-literals-match ;
 555
 556 : emit-set-alien-vector ( node -- )
 557     dup [
 558         '[
 559             ds-drop prepare-alien-setter ds-pop
 560             _ ##set-alien-vector
 561         ]
 562         [ byte-array inline-alien-setter? ]
 563         inline-alien
 564     ] with { [ %alien-vector-reps member? ] } if-literals-match ;
 565
 566 : enable-simd ( -- )
 567     {
 568         { (simd-v+)                [ emit-simd-v+                  ] }
 569         { (simd-v-)                [ emit-simd-v-                  ] }
 570         { (simd-vneg)              [ emit-simd-vneg                ] }
 571         { (simd-v+-)               [ emit-simd-v+-                 ] }
 572         { (simd-vs+)               [ emit-simd-vs+                 ] }
 573         { (simd-vs-)               [ emit-simd-vs-                 ] }
 574         { (simd-vs*)               [ emit-simd-vs*                 ] }
 575         { (simd-v*)                [ emit-simd-v*                  ] }
 576         { (simd-v/)                [ emit-simd-v/                  ] }
 577         { (simd-vmin)              [ emit-simd-vmin                ] }
 578         { (simd-vmax)              [ emit-simd-vmax                ] }
 579         { (simd-v.)                [ emit-simd-v.                  ] }
 580         { (simd-vsqrt)             [ emit-simd-vsqrt               ] }
 581         { (simd-sum)               [ emit-simd-sum                 ] }
 582         { (simd-vabs)              [ emit-simd-vabs                ] }
 583         { (simd-vbitand)           [ emit-simd-vand                ] }
 584         { (simd-vbitandn)          [ emit-simd-vandn               ] }
 585         { (simd-vbitor)            [ emit-simd-vor                 ] }
 586         { (simd-vbitxor)           [ emit-simd-vxor                ] }
 587         { (simd-vbitnot)           [ emit-simd-vnot                ] }
 588         { (simd-vand)              [ emit-simd-vand                ] }
 589         { (simd-vandn)             [ emit-simd-vandn               ] }
 590         { (simd-vor)               [ emit-simd-vor                 ] }
 591         { (simd-vxor)              [ emit-simd-vxor                ] }
 592         { (simd-vnot)              [ emit-simd-vnot                ] }
 593         { (simd-vlshift)           [ emit-simd-vlshift             ] }
 594         { (simd-vrshift)           [ emit-simd-vrshift             ] }
 595         { (simd-hlshift)           [ emit-simd-hlshift             ] }
 596         { (simd-hrshift)           [ emit-simd-hrshift             ] }
 597         { (simd-vshuffle-elements) [ emit-simd-vshuffle-elements   ] }
 598         { (simd-vshuffle-bytes)    [ emit-simd-vshuffle-bytes      ] }
 599         { (simd-vmerge-head)       [ emit-simd-vmerge-head         ] }
 600         { (simd-vmerge-tail)       [ emit-simd-vmerge-tail         ] }
 601         { (simd-v<=)               [ emit-simd-v<=                 ] }
 602         { (simd-v<)                [ emit-simd-v<                  ] }
 603         { (simd-v=)                [ emit-simd-v=                  ] }
 604         { (simd-v>)                [ emit-simd-v>                  ] }
 605         { (simd-v>=)               [ emit-simd-v>=                 ] }
 606         { (simd-vunordered?)       [ emit-simd-vunordered?         ] }
 607         { (simd-vany?)             [ emit-simd-vany?               ] }
 608         { (simd-vall?)             [ emit-simd-vall?               ] }
 609         { (simd-vnone?)            [ emit-simd-vnone?              ] }
 610         { (simd-v>float)           [ emit-simd-v>float             ] }
 611         { (simd-v>integer)         [ emit-simd-v>integer           ] }
 612         { (simd-vpack-signed)      [ emit-simd-vpack-signed        ] }
 613         { (simd-vpack-unsigned)    [ emit-simd-vpack-unsigned      ] }
 614         { (simd-vunpack-head)      [ emit-simd-vunpack-head        ] }
 615         { (simd-vunpack-tail)      [ emit-simd-vunpack-tail        ] }
 616         { (simd-with)              [ emit-simd-with                ] }
 617         { (simd-gather-2)          [ emit-simd-gather-2            ] }
 618         { (simd-gather-4)          [ emit-simd-gather-4            ] }
 619         { (simd-select)            [ emit-simd-select              ] }
 620         { alien-vector             [ emit-alien-vector             ] }
 621         { set-alien-vector         [ emit-set-alien-vector         ] }
 622     } enable-intrinsics ;
 623
 624 enable-simd