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 layouts 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     signed-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     signed-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 signed-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 PREDICATE: fixnum-vector-rep < int-vector-rep
 156     rep-component-type heap-size cell < ;
 157
 158 : ^(sum-vector-2) ( src rep -- dst )
 159     {
 160         [ dupd ^^horizontal-add-vector ]
 161         [| src rep |
 162             src src rep ^^merge-vector-head :> head
 163             src src rep ^^merge-vector-tail :> tail
 164             head tail rep ^^add-vector
 165         ]
 166     } v-vector-op ;
 167
 168 : ^(sum-vector-4) ( src rep -- dst )
 169     {
 170         [
 171             [ dupd ^^horizontal-add-vector ]
 172             [ dupd ^^horizontal-add-vector ] bi
 173         ]
 174         [| src rep |
 175             src src rep ^^merge-vector-head :> head
 176             src src rep ^^merge-vector-tail :> tail
 177             head tail rep ^^add-vector :> src'
 178
 179             rep widen-vector-rep :> rep'
 180             src' src' rep' ^^merge-vector-head :> head'
 181             src' src' rep' ^^merge-vector-tail :> tail'
 182             head' tail' rep ^^add-vector
 183         ]
 184     } v-vector-op ;
 185
 186 : ^(sum-vector-8) ( src rep -- dst )
 187     {
 188         [
 189             [ dupd ^^horizontal-add-vector ]
 190             [ dupd ^^horizontal-add-vector ]
 191             [ dupd ^^horizontal-add-vector ] tri
 192         ]
 193         [| src rep |
 194             src src rep ^^merge-vector-head :> head
 195             src src rep ^^merge-vector-tail :> tail
 196             head tail rep ^^add-vector :> src'
 197
 198             rep widen-vector-rep :> rep'
 199             src' src' rep' ^^merge-vector-head :> head'
 200             src' src' rep' ^^merge-vector-tail :> tail'
 201             head' tail' rep ^^add-vector :> src''
 202
 203             rep' widen-vector-rep :> rep''
 204             src'' src'' rep'' ^^merge-vector-head :> head''
 205             src'' src'' rep'' ^^merge-vector-tail :> tail''
 206             head'' tail'' rep ^^add-vector
 207         ]
 208     } v-vector-op ;
 209
 210 : ^(sum-vector-16) ( src rep -- dst )
 211     {
 212         [
 213             {
 214                 [ dupd ^^horizontal-add-vector ]
 215                 [ dupd ^^horizontal-add-vector ]
 216                 [ dupd ^^horizontal-add-vector ]
 217                 [ dupd ^^horizontal-add-vector ]
 218             } cleave
 219         ]
 220         [| src rep |
 221             src src rep ^^merge-vector-head :> head
 222             src src rep ^^merge-vector-tail :> tail
 223             head tail rep ^^add-vector :> src'
 224
 225             rep widen-vector-rep :> rep'
 226             src' src' rep' ^^merge-vector-head :> head'
 227             src' src' rep' ^^merge-vector-tail :> tail'
 228             head' tail' rep ^^add-vector :> src''
 229
 230             rep' widen-vector-rep :> rep''
 231             src'' src'' rep'' ^^merge-vector-head :> head''
 232             src'' src'' rep'' ^^merge-vector-tail :> tail''
 233             head'' tail'' rep ^^add-vector :> src'''
 234
 235             rep'' widen-vector-rep :> rep'''
 236             src''' src''' rep''' ^^merge-vector-head :> head'''
 237             src''' src''' rep''' ^^merge-vector-tail :> tail'''
 238             head''' tail''' rep ^^add-vector
 239         ]
 240     } v-vector-op ;
 241
 242 : ^(sum-vector) ( src rep -- dst )
 243     [
 244         dup rep-length {
 245             {  2 [ ^(sum-vector-2) ] }
 246             {  4 [ ^(sum-vector-4) ] }
 247             {  8 [ ^(sum-vector-8) ] }
 248             { 16 [ ^(sum-vector-16) ] }
 249         } case
 250     ] [ ^^vector>scalar ] bi ;
 251
 252 : ^sum-vector ( src rep -- dst )
 253     {
 254         { float-vector-rep [ ^(sum-vector) ] }
 255         { fixnum-vector-rep [| src rep |
 256             src rep ^unpack-vector-head :> head
 257             src rep ^unpack-vector-tail :> tail
 258             rep widen-vector-rep :> wide-rep
 259             head tail wide-rep ^^add-vector wide-rep
 260             ^(sum-vector)
 261         ] }
 262     } v-vector-op ;
 263
 264 : shuffle? ( obj -- ? ) { [ array? ] [ [ integer? ] all? ] } 1&& ;
 265
 266 : ^shuffle-vector-imm ( src1 shuffle rep -- dst )
 267     [ rep-length 0 pad-tail ] keep {
 268         [ ^^shuffle-vector-imm ]
 269         [ [ ^load-immediate-shuffle ] [ ^^shuffle-vector ] bi ]
 270     } vl-vector-op ;
 271
 272 : ^broadcast-vector ( src n rep -- dst )
 273     [ rep-length swap <array> ] keep
 274     ^shuffle-vector-imm ;
 275
 276 : ^with-vector ( src rep -- dst )
 277     [ ^^scalar>vector ] keep [ 0 ] dip ^broadcast-vector ;
 278
 279 : ^select-vector ( src n rep -- dst )
 280     [ ^broadcast-vector ] keep ^^vector>scalar ;
 281
 282 ! intrinsic emitters
 283
 284 : emit-simd-v+ ( node -- )
 285     {
 286         [ ^^add-vector ]
 287     } emit-vv-vector-op ;
 288
 289 : emit-simd-v- ( node -- )
 290     {
 291         [ ^^sub-vector ]
 292     } emit-vv-vector-op ;
 293
 294 : emit-simd-vneg ( node -- )
 295     {
 296         { float-vector-rep [ [ ^load-neg-zero-vector swap ] [ ^^sub-vector ] bi ] }
 297         { int-vector-rep   [ [ ^^zero-vector         swap ] [ ^^sub-vector ] bi ] }
 298     } emit-v-vector-op ;
 299
 300 : emit-simd-v+- ( node -- )
 301     {
 302         [ ^^add-sub-vector ]
 303         { float-vector-rep [| src1 src2 rep |
 304             rep ^load-add-sub-vector :> signs
 305             src2 signs rep ^^xor-vector :> src2'
 306             src1 src2' rep ^^add-vector
 307         ] }
 308         { int-vector-rep   [| src1 src2 rep |
 309             rep ^load-add-sub-vector :> signs
 310             src2  signs rep ^^xor-vector :> src2'
 311             src2' signs rep ^^sub-vector :> src2''
 312             src1 src2'' rep ^^add-vector
 313         ] }
 314     } emit-vv-vector-op ;
 315
 316 : emit-simd-vs+ ( node -- )
 317     {
 318         { float-vector-rep [ ^^add-vector ] }
 319         { int-vector-rep [ ^^saturated-add-vector ] }
 320     } emit-vv-vector-op ;
 321
 322 : emit-simd-vs- ( node -- )
 323     {
 324         { float-vector-rep [ ^^sub-vector ] }
 325         { int-vector-rep [ ^^saturated-sub-vector ] }
 326     } emit-vv-vector-op ;
 327
 328 : emit-simd-vs* ( node -- )
 329     {
 330         { float-vector-rep [ ^^mul-vector ] }
 331         { int-vector-rep [ ^^saturated-mul-vector ] }
 332     } emit-vv-vector-op ;
 333
 334 : emit-simd-v* ( node -- )
 335     {
 336         [ ^^mul-vector ]
 337     } emit-vv-vector-op ;
 338
 339 : emit-simd-v/ ( node -- )
 340     {
 341         [ ^^div-vector ]
 342     } emit-vv-vector-op ;
 343
 344 : emit-simd-vmin ( node -- )
 345     {
 346         [ ^^min-vector ]
 347         [
 348             [ cc< ^compare-vector ]
 349             [ ^blend-vector ] 3bi
 350         ]
 351     } emit-vv-vector-op ;
 352
 353 : emit-simd-vmax ( node -- )
 354     {
 355         [ ^^max-vector ]
 356         [
 357             [ cc> ^compare-vector ]
 358             [ ^blend-vector ] 3bi
 359         ]
 360     } emit-vv-vector-op ;
 361
 362 : emit-simd-v. ( node -- )
 363     {
 364         [ ^^dot-vector ]
 365         { float-vector-rep [ [ ^^mul-vector ] [ ^sum-vector ] bi ] }
 366     } emit-vv-vector-op ;
 367
 368 : emit-simd-vsqrt ( node -- )
 369     {
 370         [ ^^sqrt-vector ]
 371     } emit-v-vector-op ;
 372
 373 : emit-simd-sum ( node -- )
 374     {
 375         [ ^sum-vector ]
 376     } emit-v-vector-op ;
 377
 378 : emit-simd-vabs ( node -- )
 379     {
 380         { unsigned-int-vector-rep [ drop ] }
 381         [ ^^abs-vector ]
 382         { float-vector-rep [ [ ^load-neg-zero-vector ] [ swapd ^^andn-vector ] bi ] }
 383         { int-vector-rep [| src rep |
 384             rep ^^zero-vector :> zero
 385             zero src rep ^^sub-vector :> -src
 386             zero src rep cc> ^compare-vector :> sign
 387             sign -src src rep ^blend-vector
 388         ] }
 389     } emit-v-vector-op ;
 390
 391 : emit-simd-vand ( node -- )
 392     {
 393         [ ^^and-vector ]
 394     } emit-vv-vector-op ;
 395
 396 : emit-simd-vandn ( node -- )
 397     {
 398         [ ^^andn-vector ]
 399     } emit-vv-vector-op ;
 400
 401 : emit-simd-vor ( node -- )
 402     {
 403         [ ^^or-vector ]
 404     } emit-vv-vector-op ;
 405
 406 : emit-simd-vxor ( node -- )
 407     {
 408         [ ^^xor-vector ]
 409     } emit-vv-vector-op ;
 410
 411 : emit-simd-vnot ( node -- )
 412     {
 413         [ ^not-vector ]
 414     } emit-v-vector-op ;
 415
 416 : emit-simd-vlshift ( node -- )
 417     {
 418         [ ^^shl-vector ]
 419     } {
 420         [ ^^shl-vector-imm ]
 421     } [ integer? ] emit-vv-or-vl-vector-op ;
 422
 423 : emit-simd-vrshift ( node -- )
 424     {
 425         [ ^^shr-vector ]
 426     } {
 427         [ ^^shr-vector-imm ]
 428     } [ integer? ] emit-vv-or-vl-vector-op ;
 429
 430 : emit-simd-hlshift ( node -- )
 431     {
 432         [ ^^horizontal-shl-vector-imm ]
 433     } [ integer? ] emit-vl-vector-op ;
 434
 435 : emit-simd-hrshift ( node -- )
 436     {
 437         [ ^^horizontal-shr-vector-imm ]
 438     } [ integer? ] emit-vl-vector-op ;
 439
 440 : emit-simd-vshuffle-elements ( node -- )
 441     {
 442         [ ^shuffle-vector-imm ]
 443     } [ shuffle? ] emit-vl-vector-op ;
 444
 445 : emit-simd-vshuffle-bytes ( node -- )
 446     {
 447         [ ^^shuffle-vector ]
 448     } emit-vv-vector-op ;
 449
 450 : emit-simd-vmerge-head ( node -- )
 451     {
 452         [ ^^merge-vector-head ]
 453     } emit-vv-vector-op ;
 454
 455 : emit-simd-vmerge-tail ( node -- )
 456     {
 457         [ ^^merge-vector-tail ]
 458     } emit-vv-vector-op ;
 459
 460 : emit-simd-v<= ( node -- )
 461     {
 462         [ cc<= ^compare-vector ]
 463     } emit-vv-vector-op ;
 464 : emit-simd-v< ( node -- )
 465     {
 466         [ cc< ^compare-vector ]
 467     } emit-vv-vector-op ;
 468 : emit-simd-v= ( node -- )
 469     {
 470         [ cc=  ^compare-vector ]
 471     } emit-vv-vector-op ;
 472 : emit-simd-v> ( node -- )
 473     {
 474         [ cc>  ^compare-vector ]
 475     } emit-vv-vector-op ;
 476 : emit-simd-v>= ( node -- )
 477     {
 478         [ cc>= ^compare-vector ]
 479     } emit-vv-vector-op ;
 480 : emit-simd-vunordered? ( node -- )
 481     {
 482         [ cc/<>= ^compare-vector ]
 483     } emit-vv-vector-op ;
 484
 485 : emit-simd-vany? ( node -- )
 486     {
 487         [ vcc-any ^^test-vector ]
 488     } emit-v-vector-op ;
 489 : emit-simd-vall? ( node -- )
 490     {
 491         [ vcc-all ^^test-vector ]
 492     } emit-v-vector-op ;
 493 : emit-simd-vnone? ( node -- )
 494     {
 495         [ vcc-none ^^test-vector ]
 496     } emit-v-vector-op ;
 497
 498 : emit-simd-v>float ( node -- )
 499     {
 500         { float-vector-rep [ drop ] }
 501         { int-vector-rep [ ^^integer>float-vector ] }
 502     } emit-v-vector-op ;
 503
 504 : emit-simd-v>integer ( node -- )
 505     {
 506         { float-vector-rep [ ^^float>integer-vector ] }
 507         { int-vector-rep [ drop ] }
 508     } emit-v-vector-op ;
 509
 510 : emit-simd-vpack-signed ( node -- )
 511     {
 512         [ ^^signed-pack-vector ]
 513     } emit-vv-vector-op ;
 514
 515 : emit-simd-vpack-unsigned ( node -- )
 516     {
 517         [ ^^unsigned-pack-vector ]
 518     } emit-vv-vector-op ;
 519
 520 : emit-simd-vunpack-head ( node -- )
 521     {
 522         [ ^unpack-vector-head ]
 523     } emit-v-vector-op ;
 524
 525 : emit-simd-vunpack-tail ( node -- )
 526     {
 527         [ ^unpack-vector-tail ]
 528     } emit-v-vector-op ;
 529
 530 : emit-simd-with ( node -- )
 531     {
 532         { fixnum-vector-rep [ ^with-vector ] }
 533         { float-vector-rep  [ ^with-vector ] }
 534     } emit-v-vector-op ;
 535
 536 : emit-simd-gather-2 ( node -- )
 537     {
 538         { fixnum-vector-rep [ ^^gather-vector-2 ] }
 539         { float-vector-rep  [ ^^gather-vector-2 ] }
 540     } emit-vv-vector-op ;
 541
 542 : emit-simd-gather-4 ( node -- )
 543     {
 544         { fixnum-vector-rep [ ^^gather-vector-4 ] }
 545         { float-vector-rep  [ ^^gather-vector-4 ] }
 546     } emit-vvvv-vector-op ;
 547
 548 : emit-simd-select ( node -- )
 549     {
 550         { fixnum-vector-rep [ ^select-vector ] }
 551         { float-vector-rep  [ ^select-vector ] }
 552     } [ integer? ] emit-vl-vector-op ;
 553
 554 : emit-alien-vector ( node -- )
 555     dup [
 556         '[
 557             ds-drop prepare-alien-getter
 558             _ ^^alien-vector ds-push
 559         ]
 560         [ inline-alien-getter? ] inline-alien
 561     ] with { [ %alien-vector-reps member? ] } if-literals-match ;
 562
 563 : emit-set-alien-vector ( node -- )
 564     dup [
 565         '[
 566             ds-drop prepare-alien-setter ds-pop
 567             _ ##set-alien-vector
 568         ]
 569         [ byte-array inline-alien-setter? ]
 570         inline-alien
 571     ] with { [ %alien-vector-reps member? ] } if-literals-match ;
 572
 573 : enable-simd ( -- )
 574     {
 575         { (simd-v+)                [ emit-simd-v+                  ] }
 576         { (simd-v-)                [ emit-simd-v-                  ] }
 577         { (simd-vneg)              [ emit-simd-vneg                ] }
 578         { (simd-v+-)               [ emit-simd-v+-                 ] }
 579         { (simd-vs+)               [ emit-simd-vs+                 ] }
 580         { (simd-vs-)               [ emit-simd-vs-                 ] }
 581         { (simd-vs*)               [ emit-simd-vs*                 ] }
 582         { (simd-v*)                [ emit-simd-v*                  ] }
 583         { (simd-v/)                [ emit-simd-v/                  ] }
 584         { (simd-vmin)              [ emit-simd-vmin                ] }
 585         { (simd-vmax)              [ emit-simd-vmax                ] }
 586         { (simd-v.)                [ emit-simd-v.                  ] }
 587         { (simd-vsqrt)             [ emit-simd-vsqrt               ] }
 588         { (simd-sum)               [ emit-simd-sum                 ] }
 589         { (simd-vabs)              [ emit-simd-vabs                ] }
 590         { (simd-vbitand)           [ emit-simd-vand                ] }
 591         { (simd-vbitandn)          [ emit-simd-vandn               ] }
 592         { (simd-vbitor)            [ emit-simd-vor                 ] }
 593         { (simd-vbitxor)           [ emit-simd-vxor                ] }
 594         { (simd-vbitnot)           [ emit-simd-vnot                ] }
 595         { (simd-vand)              [ emit-simd-vand                ] }
 596         { (simd-vandn)             [ emit-simd-vandn               ] }
 597         { (simd-vor)               [ emit-simd-vor                 ] }
 598         { (simd-vxor)              [ emit-simd-vxor                ] }
 599         { (simd-vnot)              [ emit-simd-vnot                ] }
 600         { (simd-vlshift)           [ emit-simd-vlshift             ] }
 601         { (simd-vrshift)           [ emit-simd-vrshift             ] }
 602         { (simd-hlshift)           [ emit-simd-hlshift             ] }
 603         { (simd-hrshift)           [ emit-simd-hrshift             ] }
 604         { (simd-vshuffle-elements) [ emit-simd-vshuffle-elements   ] }
 605         { (simd-vshuffle-bytes)    [ emit-simd-vshuffle-bytes      ] }
 606         { (simd-vmerge-head)       [ emit-simd-vmerge-head         ] }
 607         { (simd-vmerge-tail)       [ emit-simd-vmerge-tail         ] }
 608         { (simd-v<=)               [ emit-simd-v<=                 ] }
 609         { (simd-v<)                [ emit-simd-v<                  ] }
 610         { (simd-v=)                [ emit-simd-v=                  ] }
 611         { (simd-v>)                [ emit-simd-v>                  ] }
 612         { (simd-v>=)               [ emit-simd-v>=                 ] }
 613         { (simd-vunordered?)       [ emit-simd-vunordered?         ] }
 614         { (simd-vany?)             [ emit-simd-vany?               ] }
 615         { (simd-vall?)             [ emit-simd-vall?               ] }
 616         { (simd-vnone?)            [ emit-simd-vnone?              ] }
 617         { (simd-v>float)           [ emit-simd-v>float             ] }
 618         { (simd-v>integer)         [ emit-simd-v>integer           ] }
 619         { (simd-vpack-signed)      [ emit-simd-vpack-signed        ] }
 620         { (simd-vpack-unsigned)    [ emit-simd-vpack-unsigned      ] }
 621         { (simd-vunpack-head)      [ emit-simd-vunpack-head        ] }
 622         { (simd-vunpack-tail)      [ emit-simd-vunpack-tail        ] }
 623         { (simd-with)              [ emit-simd-with                ] }
 624         { (simd-gather-2)          [ emit-simd-gather-2            ] }
 625         { (simd-gather-4)          [ emit-simd-gather-4            ] }
 626         { (simd-select)            [ emit-simd-select              ] }
 627         { alien-vector             [ emit-alien-vector             ] }
 628         { set-alien-vector         [ emit-set-alien-vector         ] }
 629     } enable-intrinsics ;
 630
 631 enable-simd