1 // Code generated by 'simdgen -o godefs -goroot $GOROOT -arch amd64 -xedPath $XED_PATH go_amd64.yaml types.yaml categories.yaml'; DO NOT EDIT. 2 3 //go:build goexperiment.simd 4 5 package archsimd 6 7 // v128 is a tag type that tells the compiler that this is really 128-bit SIMD 8 type v128 struct { 9 _128 [0]func() // uncomparable 10 } 11 12 // Float32x4 is a 128-bit SIMD vector of 4 float32s. 13 type Float32x4 struct { 14 float32x4 v128 15 vals [4]float32 16 } 17 18 // Len returns the number of elements in a Float32x4. 19 func (x Float32x4) Len() int { return 4 } 20 21 // LoadFloat32x4Array loads a Float32x4 from an array. 22 // 23 //go:noescape 24 func LoadFloat32x4Array(y *[4]float32) Float32x4 25 26 // StoreArray stores a Float32x4 to an array. 27 // 28 //go:noescape 29 func (x Float32x4) StoreArray(y *[4]float32) 30 31 // StoreArrayMasked stores a Float32x4 to an array, 32 // at those elements enabled by mask. 33 // 34 // Asm: VMASKMOVD, CPU Feature: AVX2 35 // 36 //go:noescape 37 func (x Float32x4) StoreArrayMasked(y *[4]float32, mask Mask32x4) 38 39 // Float64x2 is a 128-bit SIMD vector of 2 float64s. 40 type Float64x2 struct { 41 float64x2 v128 42 vals [2]float64 43 } 44 45 // Len returns the number of elements in a Float64x2. 46 func (x Float64x2) Len() int { return 2 } 47 48 // LoadFloat64x2Array loads a Float64x2 from an array. 49 // 50 //go:noescape 51 func LoadFloat64x2Array(y *[2]float64) Float64x2 52 53 // StoreArray stores a Float64x2 to an array. 54 // 55 //go:noescape 56 func (x Float64x2) StoreArray(y *[2]float64) 57 58 // StoreArrayMasked stores a Float64x2 to an array, 59 // at those elements enabled by mask. 60 // 61 // Asm: VMASKMOVQ, CPU Feature: AVX2 62 // 63 //go:noescape 64 func (x Float64x2) StoreArrayMasked(y *[2]float64, mask Mask64x2) 65 66 // Int8x16 is a 128-bit SIMD vector of 16 int8s. 67 type Int8x16 struct { 68 int8x16 v128 69 vals [16]int8 70 } 71 72 // Len returns the number of elements in an Int8x16. 73 func (x Int8x16) Len() int { return 16 } 74 75 // LoadInt8x16Array loads an Int8x16 from an array. 76 // 77 //go:noescape 78 func LoadInt8x16Array(y *[16]int8) Int8x16 79 80 // StoreArray stores an Int8x16 to an array. 81 // 82 //go:noescape 83 func (x Int8x16) StoreArray(y *[16]int8) 84 85 // Int16x8 is a 128-bit SIMD vector of 8 int16s. 86 type Int16x8 struct { 87 int16x8 v128 88 vals [8]int16 89 } 90 91 // Len returns the number of elements in an Int16x8. 92 func (x Int16x8) Len() int { return 8 } 93 94 // LoadInt16x8Array loads an Int16x8 from an array. 95 // 96 //go:noescape 97 func LoadInt16x8Array(y *[8]int16) Int16x8 98 99 // StoreArray stores an Int16x8 to an array. 100 // 101 //go:noescape 102 func (x Int16x8) StoreArray(y *[8]int16) 103 104 // Int32x4 is a 128-bit SIMD vector of 4 int32s. 105 type Int32x4 struct { 106 int32x4 v128 107 vals [4]int32 108 } 109 110 // Len returns the number of elements in an Int32x4. 111 func (x Int32x4) Len() int { return 4 } 112 113 // LoadInt32x4Array loads an Int32x4 from an array. 114 // 115 //go:noescape 116 func LoadInt32x4Array(y *[4]int32) Int32x4 117 118 // StoreArray stores an Int32x4 to an array. 119 // 120 //go:noescape 121 func (x Int32x4) StoreArray(y *[4]int32) 122 123 // StoreArrayMasked stores an Int32x4 to an array, 124 // at those elements enabled by mask. 125 // 126 // Asm: VMASKMOVD, CPU Feature: AVX2 127 // 128 //go:noescape 129 func (x Int32x4) StoreArrayMasked(y *[4]int32, mask Mask32x4) 130 131 // Int64x2 is a 128-bit SIMD vector of 2 int64s. 132 type Int64x2 struct { 133 int64x2 v128 134 vals [2]int64 135 } 136 137 // Len returns the number of elements in an Int64x2. 138 func (x Int64x2) Len() int { return 2 } 139 140 // LoadInt64x2Array loads an Int64x2 from an array. 141 // 142 //go:noescape 143 func LoadInt64x2Array(y *[2]int64) Int64x2 144 145 // StoreArray stores an Int64x2 to an array. 146 // 147 //go:noescape 148 func (x Int64x2) StoreArray(y *[2]int64) 149 150 // StoreArrayMasked stores an Int64x2 to an array, 151 // at those elements enabled by mask. 152 // 153 // Asm: VMASKMOVQ, CPU Feature: AVX2 154 // 155 //go:noescape 156 func (x Int64x2) StoreArrayMasked(y *[2]int64, mask Mask64x2) 157 158 // Uint8x16 is a 128-bit SIMD vector of 16 uint8s. 159 type Uint8x16 struct { 160 uint8x16 v128 161 vals [16]uint8 162 } 163 164 // Len returns the number of elements in a Uint8x16. 165 func (x Uint8x16) Len() int { return 16 } 166 167 // LoadUint8x16Array loads a Uint8x16 from an array. 168 // 169 //go:noescape 170 func LoadUint8x16Array(y *[16]uint8) Uint8x16 171 172 // StoreArray stores a Uint8x16 to an array. 173 // 174 //go:noescape 175 func (x Uint8x16) StoreArray(y *[16]uint8) 176 177 // Uint16x8 is a 128-bit SIMD vector of 8 uint16s. 178 type Uint16x8 struct { 179 uint16x8 v128 180 vals [8]uint16 181 } 182 183 // Len returns the number of elements in a Uint16x8. 184 func (x Uint16x8) Len() int { return 8 } 185 186 // LoadUint16x8Array loads a Uint16x8 from an array. 187 // 188 //go:noescape 189 func LoadUint16x8Array(y *[8]uint16) Uint16x8 190 191 // StoreArray stores a Uint16x8 to an array. 192 // 193 //go:noescape 194 func (x Uint16x8) StoreArray(y *[8]uint16) 195 196 // Uint32x4 is a 128-bit SIMD vector of 4 uint32s. 197 type Uint32x4 struct { 198 uint32x4 v128 199 vals [4]uint32 200 } 201 202 // Len returns the number of elements in a Uint32x4. 203 func (x Uint32x4) Len() int { return 4 } 204 205 // LoadUint32x4Array loads a Uint32x4 from an array. 206 // 207 //go:noescape 208 func LoadUint32x4Array(y *[4]uint32) Uint32x4 209 210 // StoreArray stores a Uint32x4 to an array. 211 // 212 //go:noescape 213 func (x Uint32x4) StoreArray(y *[4]uint32) 214 215 // StoreArrayMasked stores a Uint32x4 to an array, 216 // at those elements enabled by mask. 217 // 218 // Asm: VMASKMOVD, CPU Feature: AVX2 219 // 220 //go:noescape 221 func (x Uint32x4) StoreArrayMasked(y *[4]uint32, mask Mask32x4) 222 223 // Uint64x2 is a 128-bit SIMD vector of 2 uint64s. 224 type Uint64x2 struct { 225 uint64x2 v128 226 vals [2]uint64 227 } 228 229 // Len returns the number of elements in a Uint64x2. 230 func (x Uint64x2) Len() int { return 2 } 231 232 // LoadUint64x2Array loads a Uint64x2 from an array. 233 // 234 //go:noescape 235 func LoadUint64x2Array(y *[2]uint64) Uint64x2 236 237 // StoreArray stores a Uint64x2 to an array. 238 // 239 //go:noescape 240 func (x Uint64x2) StoreArray(y *[2]uint64) 241 242 // StoreArrayMasked stores a Uint64x2 to an array, 243 // at those elements enabled by mask. 244 // 245 // Asm: VMASKMOVQ, CPU Feature: AVX2 246 // 247 //go:noescape 248 func (x Uint64x2) StoreArrayMasked(y *[2]uint64, mask Mask64x2) 249 250 // Mask8x16 is a mask for a SIMD vector of 16 8-bit elements. 251 type Mask8x16 struct { 252 int8x16 v128 253 vals [16]int8 254 } 255 256 // Mask8x16FromBits constructs a Mask8x16 from a bitmap value, where 1 means set for the indexed element, 0 means unset. 257 // 258 // Asm: KMOVB, CPU Feature: AVX512 259 func Mask8x16FromBits(y uint16) Mask8x16 260 261 // ToBits constructs a bitmap from a Mask8x16, where 1 means set for the indexed element, 0 means unset. 262 // 263 // Asm: VPMOVMSKB, CPU Features: AVX 264 func (x Mask8x16) ToBits() uint16 265 266 // Mask16x8 is a mask for a SIMD vector of 8 16-bit elements. 267 type Mask16x8 struct { 268 int16x8 v128 269 vals [8]int16 270 } 271 272 // Mask16x8FromBits constructs a Mask16x8 from a bitmap value, where 1 means set for the indexed element, 0 means unset. 273 // 274 // Asm: KMOVW, CPU Feature: AVX512 275 func Mask16x8FromBits(y uint8) Mask16x8 276 277 // ToBits constructs a bitmap from a Mask16x8, where 1 means set for the indexed element, 0 means unset. 278 // 279 // Asm: KMOVW, CPU Features: AVX512 280 func (x Mask16x8) ToBits() uint8 281 282 // Mask32x4 is a mask for a SIMD vector of 4 32-bit elements. 283 type Mask32x4 struct { 284 int32x4 v128 285 vals [4]int32 286 } 287 288 // Mask32x4FromBits constructs a Mask32x4 from a bitmap value, where 1 means set for the indexed element, 0 means unset. 289 // Only the lower 4 bits of y are used. 290 // 291 // Asm: KMOVD, CPU Feature: AVX512 292 func Mask32x4FromBits(y uint8) Mask32x4 293 294 // ToBits constructs a bitmap from a Mask32x4, where 1 means set for the indexed element, 0 means unset. 295 // Only the lower 4 bits of y are used. 296 // 297 // Asm: VMOVMSKPS, CPU Features: AVX 298 func (x Mask32x4) ToBits() uint8 299 300 // Mask64x2 is a mask for a SIMD vector of 2 64-bit elements. 301 type Mask64x2 struct { 302 int64x2 v128 303 vals [2]int64 304 } 305 306 // Mask64x2FromBits constructs a Mask64x2 from a bitmap value, where 1 means set for the indexed element, 0 means unset. 307 // Only the lower 2 bits of y are used. 308 // 309 // Asm: KMOVQ, CPU Feature: AVX512 310 func Mask64x2FromBits(y uint8) Mask64x2 311 312 // ToBits constructs a bitmap from a Mask64x2, where 1 means set for the indexed element, 0 means unset. 313 // Only the lower 2 bits of y are used. 314 // 315 // Asm: VMOVMSKPD, CPU Features: AVX 316 func (x Mask64x2) ToBits() uint8 317 318 // v256 is a tag type that tells the compiler that this is really 256-bit SIMD 319 type v256 struct { 320 _256 [0]func() // uncomparable 321 } 322 323 // Float32x8 is a 256-bit SIMD vector of 8 float32s. 324 type Float32x8 struct { 325 float32x8 v256 326 vals [8]float32 327 } 328 329 // Len returns the number of elements in a Float32x8. 330 func (x Float32x8) Len() int { return 8 } 331 332 // LoadFloat32x8Array loads a Float32x8 from an array. 333 // 334 //go:noescape 335 func LoadFloat32x8Array(y *[8]float32) Float32x8 336 337 // StoreArray stores a Float32x8 to an array. 338 // 339 //go:noescape 340 func (x Float32x8) StoreArray(y *[8]float32) 341 342 // StoreArrayMasked stores a Float32x8 to an array, 343 // at those elements enabled by mask. 344 // 345 // Asm: VMASKMOVD, CPU Feature: AVX2 346 // 347 //go:noescape 348 func (x Float32x8) StoreArrayMasked(y *[8]float32, mask Mask32x8) 349 350 // Float64x4 is a 256-bit SIMD vector of 4 float64s. 351 type Float64x4 struct { 352 float64x4 v256 353 vals [4]float64 354 } 355 356 // Len returns the number of elements in a Float64x4. 357 func (x Float64x4) Len() int { return 4 } 358 359 // LoadFloat64x4Array loads a Float64x4 from an array. 360 // 361 //go:noescape 362 func LoadFloat64x4Array(y *[4]float64) Float64x4 363 364 // StoreArray stores a Float64x4 to an array. 365 // 366 //go:noescape 367 func (x Float64x4) StoreArray(y *[4]float64) 368 369 // StoreArrayMasked stores a Float64x4 to an array, 370 // at those elements enabled by mask. 371 // 372 // Asm: VMASKMOVQ, CPU Feature: AVX2 373 // 374 //go:noescape 375 func (x Float64x4) StoreArrayMasked(y *[4]float64, mask Mask64x4) 376 377 // Int8x32 is a 256-bit SIMD vector of 32 int8s. 378 type Int8x32 struct { 379 int8x32 v256 380 vals [32]int8 381 } 382 383 // Len returns the number of elements in an Int8x32. 384 func (x Int8x32) Len() int { return 32 } 385 386 // LoadInt8x32Array loads an Int8x32 from an array. 387 // 388 //go:noescape 389 func LoadInt8x32Array(y *[32]int8) Int8x32 390 391 // StoreArray stores an Int8x32 to an array. 392 // 393 //go:noescape 394 func (x Int8x32) StoreArray(y *[32]int8) 395 396 // Int16x16 is a 256-bit SIMD vector of 16 int16s. 397 type Int16x16 struct { 398 int16x16 v256 399 vals [16]int16 400 } 401 402 // Len returns the number of elements in an Int16x16. 403 func (x Int16x16) Len() int { return 16 } 404 405 // LoadInt16x16Array loads an Int16x16 from an array. 406 // 407 //go:noescape 408 func LoadInt16x16Array(y *[16]int16) Int16x16 409 410 // StoreArray stores an Int16x16 to an array. 411 // 412 //go:noescape 413 func (x Int16x16) StoreArray(y *[16]int16) 414 415 // Int32x8 is a 256-bit SIMD vector of 8 int32s. 416 type Int32x8 struct { 417 int32x8 v256 418 vals [8]int32 419 } 420 421 // Len returns the number of elements in an Int32x8. 422 func (x Int32x8) Len() int { return 8 } 423 424 // LoadInt32x8Array loads an Int32x8 from an array. 425 // 426 //go:noescape 427 func LoadInt32x8Array(y *[8]int32) Int32x8 428 429 // StoreArray stores an Int32x8 to an array. 430 // 431 //go:noescape 432 func (x Int32x8) StoreArray(y *[8]int32) 433 434 // StoreArrayMasked stores an Int32x8 to an array, 435 // at those elements enabled by mask. 436 // 437 // Asm: VMASKMOVD, CPU Feature: AVX2 438 // 439 //go:noescape 440 func (x Int32x8) StoreArrayMasked(y *[8]int32, mask Mask32x8) 441 442 // Int64x4 is a 256-bit SIMD vector of 4 int64s. 443 type Int64x4 struct { 444 int64x4 v256 445 vals [4]int64 446 } 447 448 // Len returns the number of elements in an Int64x4. 449 func (x Int64x4) Len() int { return 4 } 450 451 // LoadInt64x4Array loads an Int64x4 from an array. 452 // 453 //go:noescape 454 func LoadInt64x4Array(y *[4]int64) Int64x4 455 456 // StoreArray stores an Int64x4 to an array. 457 // 458 //go:noescape 459 func (x Int64x4) StoreArray(y *[4]int64) 460 461 // StoreArrayMasked stores an Int64x4 to an array, 462 // at those elements enabled by mask. 463 // 464 // Asm: VMASKMOVQ, CPU Feature: AVX2 465 // 466 //go:noescape 467 func (x Int64x4) StoreArrayMasked(y *[4]int64, mask Mask64x4) 468 469 // Uint8x32 is a 256-bit SIMD vector of 32 uint8s. 470 type Uint8x32 struct { 471 uint8x32 v256 472 vals [32]uint8 473 } 474 475 // Len returns the number of elements in a Uint8x32. 476 func (x Uint8x32) Len() int { return 32 } 477 478 // LoadUint8x32Array loads a Uint8x32 from an array. 479 // 480 //go:noescape 481 func LoadUint8x32Array(y *[32]uint8) Uint8x32 482 483 // StoreArray stores a Uint8x32 to an array. 484 // 485 //go:noescape 486 func (x Uint8x32) StoreArray(y *[32]uint8) 487 488 // Uint16x16 is a 256-bit SIMD vector of 16 uint16s. 489 type Uint16x16 struct { 490 uint16x16 v256 491 vals [16]uint16 492 } 493 494 // Len returns the number of elements in a Uint16x16. 495 func (x Uint16x16) Len() int { return 16 } 496 497 // LoadUint16x16Array loads a Uint16x16 from an array. 498 // 499 //go:noescape 500 func LoadUint16x16Array(y *[16]uint16) Uint16x16 501 502 // StoreArray stores a Uint16x16 to an array. 503 // 504 //go:noescape 505 func (x Uint16x16) StoreArray(y *[16]uint16) 506 507 // Uint32x8 is a 256-bit SIMD vector of 8 uint32s. 508 type Uint32x8 struct { 509 uint32x8 v256 510 vals [8]uint32 511 } 512 513 // Len returns the number of elements in a Uint32x8. 514 func (x Uint32x8) Len() int { return 8 } 515 516 // LoadUint32x8Array loads a Uint32x8 from an array. 517 // 518 //go:noescape 519 func LoadUint32x8Array(y *[8]uint32) Uint32x8 520 521 // StoreArray stores a Uint32x8 to an array. 522 // 523 //go:noescape 524 func (x Uint32x8) StoreArray(y *[8]uint32) 525 526 // StoreArrayMasked stores a Uint32x8 to an array, 527 // at those elements enabled by mask. 528 // 529 // Asm: VMASKMOVD, CPU Feature: AVX2 530 // 531 //go:noescape 532 func (x Uint32x8) StoreArrayMasked(y *[8]uint32, mask Mask32x8) 533 534 // Uint64x4 is a 256-bit SIMD vector of 4 uint64s. 535 type Uint64x4 struct { 536 uint64x4 v256 537 vals [4]uint64 538 } 539 540 // Len returns the number of elements in a Uint64x4. 541 func (x Uint64x4) Len() int { return 4 } 542 543 // LoadUint64x4Array loads a Uint64x4 from an array. 544 // 545 //go:noescape 546 func LoadUint64x4Array(y *[4]uint64) Uint64x4 547 548 // StoreArray stores a Uint64x4 to an array. 549 // 550 //go:noescape 551 func (x Uint64x4) StoreArray(y *[4]uint64) 552 553 // StoreArrayMasked stores a Uint64x4 to an array, 554 // at those elements enabled by mask. 555 // 556 // Asm: VMASKMOVQ, CPU Feature: AVX2 557 // 558 //go:noescape 559 func (x Uint64x4) StoreArrayMasked(y *[4]uint64, mask Mask64x4) 560 561 // Mask8x32 is a mask for a SIMD vector of 32 8-bit elements. 562 type Mask8x32 struct { 563 int8x32 v256 564 vals [32]int8 565 } 566 567 // Mask8x32FromBits constructs a Mask8x32 from a bitmap value, where 1 means set for the indexed element, 0 means unset. 568 // 569 // Asm: KMOVB, CPU Feature: AVX512 570 func Mask8x32FromBits(y uint32) Mask8x32 571 572 // ToBits constructs a bitmap from a Mask8x32, where 1 means set for the indexed element, 0 means unset. 573 // 574 // Asm: VPMOVMSKB, CPU Features: AVX2 575 func (x Mask8x32) ToBits() uint32 576 577 // Mask16x16 is a mask for a SIMD vector of 16 16-bit elements. 578 type Mask16x16 struct { 579 int16x16 v256 580 vals [16]int16 581 } 582 583 // Mask16x16FromBits constructs a Mask16x16 from a bitmap value, where 1 means set for the indexed element, 0 means unset. 584 // 585 // Asm: KMOVW, CPU Feature: AVX512 586 func Mask16x16FromBits(y uint16) Mask16x16 587 588 // ToBits constructs a bitmap from a Mask16x16, where 1 means set for the indexed element, 0 means unset. 589 // 590 // Asm: KMOVW, CPU Features: AVX512 591 func (x Mask16x16) ToBits() uint16 592 593 // Mask32x8 is a mask for a SIMD vector of 8 32-bit elements. 594 type Mask32x8 struct { 595 int32x8 v256 596 vals [8]int32 597 } 598 599 // Mask32x8FromBits constructs a Mask32x8 from a bitmap value, where 1 means set for the indexed element, 0 means unset. 600 // 601 // Asm: KMOVD, CPU Feature: AVX512 602 func Mask32x8FromBits(y uint8) Mask32x8 603 604 // ToBits constructs a bitmap from a Mask32x8, where 1 means set for the indexed element, 0 means unset. 605 // 606 // Asm: VMOVMSKPS, CPU Features: AVX 607 func (x Mask32x8) ToBits() uint8 608 609 // Mask64x4 is a mask for a SIMD vector of 4 64-bit elements. 610 type Mask64x4 struct { 611 int64x4 v256 612 vals [4]int64 613 } 614 615 // Mask64x4FromBits constructs a Mask64x4 from a bitmap value, where 1 means set for the indexed element, 0 means unset. 616 // Only the lower 4 bits of y are used. 617 // 618 // Asm: KMOVQ, CPU Feature: AVX512 619 func Mask64x4FromBits(y uint8) Mask64x4 620 621 // ToBits constructs a bitmap from a Mask64x4, where 1 means set for the indexed element, 0 means unset. 622 // Only the lower 4 bits of y are used. 623 // 624 // Asm: VMOVMSKPD, CPU Features: AVX 625 func (x Mask64x4) ToBits() uint8 626 627 // v512 is a tag type that tells the compiler that this is really 512-bit SIMD 628 type v512 struct { 629 _512 [0]func() // uncomparable 630 } 631 632 // Float32x16 is a 512-bit SIMD vector of 16 float32s. 633 type Float32x16 struct { 634 float32x16 v512 635 vals [16]float32 636 } 637 638 // Len returns the number of elements in a Float32x16. 639 func (x Float32x16) Len() int { return 16 } 640 641 // LoadFloat32x16Array loads a Float32x16 from an array. 642 // 643 //go:noescape 644 func LoadFloat32x16Array(y *[16]float32) Float32x16 645 646 // StoreArray stores a Float32x16 to an array. 647 // 648 //go:noescape 649 func (x Float32x16) StoreArray(y *[16]float32) 650 651 // StoreArrayMasked stores a Float32x16 to an array, 652 // at those elements enabled by mask. 653 // 654 // Asm: VMOVDQU32, CPU Feature: AVX512 655 // 656 //go:noescape 657 func (x Float32x16) StoreArrayMasked(y *[16]float32, mask Mask32x16) 658 659 // Float64x8 is a 512-bit SIMD vector of 8 float64s. 660 type Float64x8 struct { 661 float64x8 v512 662 vals [8]float64 663 } 664 665 // Len returns the number of elements in a Float64x8. 666 func (x Float64x8) Len() int { return 8 } 667 668 // LoadFloat64x8Array loads a Float64x8 from an array. 669 // 670 //go:noescape 671 func LoadFloat64x8Array(y *[8]float64) Float64x8 672 673 // StoreArray stores a Float64x8 to an array. 674 // 675 //go:noescape 676 func (x Float64x8) StoreArray(y *[8]float64) 677 678 // StoreArrayMasked stores a Float64x8 to an array, 679 // at those elements enabled by mask. 680 // 681 // Asm: VMOVDQU64, CPU Feature: AVX512 682 // 683 //go:noescape 684 func (x Float64x8) StoreArrayMasked(y *[8]float64, mask Mask64x8) 685 686 // Int8x64 is a 512-bit SIMD vector of 64 int8s. 687 type Int8x64 struct { 688 int8x64 v512 689 vals [64]int8 690 } 691 692 // Len returns the number of elements in an Int8x64. 693 func (x Int8x64) Len() int { return 64 } 694 695 // LoadInt8x64Array loads an Int8x64 from an array. 696 // 697 //go:noescape 698 func LoadInt8x64Array(y *[64]int8) Int8x64 699 700 // StoreArray stores an Int8x64 to an array. 701 // 702 //go:noescape 703 func (x Int8x64) StoreArray(y *[64]int8) 704 705 // StoreArrayMasked stores an Int8x64 to an array, 706 // at those elements enabled by mask. 707 // 708 // Asm: VMOVDQU8, CPU Feature: AVX512 709 // 710 //go:noescape 711 func (x Int8x64) StoreArrayMasked(y *[64]int8, mask Mask8x64) 712 713 // Int16x32 is a 512-bit SIMD vector of 32 int16s. 714 type Int16x32 struct { 715 int16x32 v512 716 vals [32]int16 717 } 718 719 // Len returns the number of elements in an Int16x32. 720 func (x Int16x32) Len() int { return 32 } 721 722 // LoadInt16x32Array loads an Int16x32 from an array. 723 // 724 //go:noescape 725 func LoadInt16x32Array(y *[32]int16) Int16x32 726 727 // StoreArray stores an Int16x32 to an array. 728 // 729 //go:noescape 730 func (x Int16x32) StoreArray(y *[32]int16) 731 732 // StoreArrayMasked stores an Int16x32 to an array, 733 // at those elements enabled by mask. 734 // 735 // Asm: VMOVDQU16, CPU Feature: AVX512 736 // 737 //go:noescape 738 func (x Int16x32) StoreArrayMasked(y *[32]int16, mask Mask16x32) 739 740 // Int32x16 is a 512-bit SIMD vector of 16 int32s. 741 type Int32x16 struct { 742 int32x16 v512 743 vals [16]int32 744 } 745 746 // Len returns the number of elements in an Int32x16. 747 func (x Int32x16) Len() int { return 16 } 748 749 // LoadInt32x16Array loads an Int32x16 from an array. 750 // 751 //go:noescape 752 func LoadInt32x16Array(y *[16]int32) Int32x16 753 754 // StoreArray stores an Int32x16 to an array. 755 // 756 //go:noescape 757 func (x Int32x16) StoreArray(y *[16]int32) 758 759 // StoreArrayMasked stores an Int32x16 to an array, 760 // at those elements enabled by mask. 761 // 762 // Asm: VMOVDQU32, CPU Feature: AVX512 763 // 764 //go:noescape 765 func (x Int32x16) StoreArrayMasked(y *[16]int32, mask Mask32x16) 766 767 // Int64x8 is a 512-bit SIMD vector of 8 int64s. 768 type Int64x8 struct { 769 int64x8 v512 770 vals [8]int64 771 } 772 773 // Len returns the number of elements in an Int64x8. 774 func (x Int64x8) Len() int { return 8 } 775 776 // LoadInt64x8Array loads an Int64x8 from an array. 777 // 778 //go:noescape 779 func LoadInt64x8Array(y *[8]int64) Int64x8 780 781 // StoreArray stores an Int64x8 to an array. 782 // 783 //go:noescape 784 func (x Int64x8) StoreArray(y *[8]int64) 785 786 // StoreArrayMasked stores an Int64x8 to an array, 787 // at those elements enabled by mask. 788 // 789 // Asm: VMOVDQU64, CPU Feature: AVX512 790 // 791 //go:noescape 792 func (x Int64x8) StoreArrayMasked(y *[8]int64, mask Mask64x8) 793 794 // Uint8x64 is a 512-bit SIMD vector of 64 uint8s. 795 type Uint8x64 struct { 796 uint8x64 v512 797 vals [64]uint8 798 } 799 800 // Len returns the number of elements in a Uint8x64. 801 func (x Uint8x64) Len() int { return 64 } 802 803 // LoadUint8x64Array loads a Uint8x64 from an array. 804 // 805 //go:noescape 806 func LoadUint8x64Array(y *[64]uint8) Uint8x64 807 808 // StoreArray stores a Uint8x64 to an array. 809 // 810 //go:noescape 811 func (x Uint8x64) StoreArray(y *[64]uint8) 812 813 // StoreArrayMasked stores a Uint8x64 to an array, 814 // at those elements enabled by mask. 815 // 816 // Asm: VMOVDQU8, CPU Feature: AVX512 817 // 818 //go:noescape 819 func (x Uint8x64) StoreArrayMasked(y *[64]uint8, mask Mask8x64) 820 821 // Uint16x32 is a 512-bit SIMD vector of 32 uint16s. 822 type Uint16x32 struct { 823 uint16x32 v512 824 vals [32]uint16 825 } 826 827 // Len returns the number of elements in a Uint16x32. 828 func (x Uint16x32) Len() int { return 32 } 829 830 // LoadUint16x32Array loads a Uint16x32 from an array. 831 // 832 //go:noescape 833 func LoadUint16x32Array(y *[32]uint16) Uint16x32 834 835 // StoreArray stores a Uint16x32 to an array. 836 // 837 //go:noescape 838 func (x Uint16x32) StoreArray(y *[32]uint16) 839 840 // StoreArrayMasked stores a Uint16x32 to an array, 841 // at those elements enabled by mask. 842 // 843 // Asm: VMOVDQU16, CPU Feature: AVX512 844 // 845 //go:noescape 846 func (x Uint16x32) StoreArrayMasked(y *[32]uint16, mask Mask16x32) 847 848 // Uint32x16 is a 512-bit SIMD vector of 16 uint32s. 849 type Uint32x16 struct { 850 uint32x16 v512 851 vals [16]uint32 852 } 853 854 // Len returns the number of elements in a Uint32x16. 855 func (x Uint32x16) Len() int { return 16 } 856 857 // LoadUint32x16Array loads a Uint32x16 from an array. 858 // 859 //go:noescape 860 func LoadUint32x16Array(y *[16]uint32) Uint32x16 861 862 // StoreArray stores a Uint32x16 to an array. 863 // 864 //go:noescape 865 func (x Uint32x16) StoreArray(y *[16]uint32) 866 867 // StoreArrayMasked stores a Uint32x16 to an array, 868 // at those elements enabled by mask. 869 // 870 // Asm: VMOVDQU32, CPU Feature: AVX512 871 // 872 //go:noescape 873 func (x Uint32x16) StoreArrayMasked(y *[16]uint32, mask Mask32x16) 874 875 // Uint64x8 is a 512-bit SIMD vector of 8 uint64s. 876 type Uint64x8 struct { 877 uint64x8 v512 878 vals [8]uint64 879 } 880 881 // Len returns the number of elements in a Uint64x8. 882 func (x Uint64x8) Len() int { return 8 } 883 884 // LoadUint64x8Array loads a Uint64x8 from an array. 885 // 886 //go:noescape 887 func LoadUint64x8Array(y *[8]uint64) Uint64x8 888 889 // StoreArray stores a Uint64x8 to an array. 890 // 891 //go:noescape 892 func (x Uint64x8) StoreArray(y *[8]uint64) 893 894 // StoreArrayMasked stores a Uint64x8 to an array, 895 // at those elements enabled by mask. 896 // 897 // Asm: VMOVDQU64, CPU Feature: AVX512 898 // 899 //go:noescape 900 func (x Uint64x8) StoreArrayMasked(y *[8]uint64, mask Mask64x8) 901 902 // Mask8x64 is a mask for a SIMD vector of 64 8-bit elements. 903 type Mask8x64 struct { 904 int8x64 v512 905 vals [64]int8 906 } 907 908 // Mask8x64FromBits constructs a Mask8x64 from a bitmap value, where 1 means set for the indexed element, 0 means unset. 909 // 910 // Asm: KMOVB, CPU Feature: AVX512 911 func Mask8x64FromBits(y uint64) Mask8x64 912 913 // ToBits constructs a bitmap from a Mask8x64, where 1 means set for the indexed element, 0 means unset. 914 // 915 // Asm: KMOVB, CPU Features: AVX512 916 func (x Mask8x64) ToBits() uint64 917 918 // Mask16x32 is a mask for a SIMD vector of 32 16-bit elements. 919 type Mask16x32 struct { 920 int16x32 v512 921 vals [32]int16 922 } 923 924 // Mask16x32FromBits constructs a Mask16x32 from a bitmap value, where 1 means set for the indexed element, 0 means unset. 925 // 926 // Asm: KMOVW, CPU Feature: AVX512 927 func Mask16x32FromBits(y uint32) Mask16x32 928 929 // ToBits constructs a bitmap from a Mask16x32, where 1 means set for the indexed element, 0 means unset. 930 // 931 // Asm: KMOVW, CPU Features: AVX512 932 func (x Mask16x32) ToBits() uint32 933 934 // Mask32x16 is a mask for a SIMD vector of 16 32-bit elements. 935 type Mask32x16 struct { 936 int32x16 v512 937 vals [16]int32 938 } 939 940 // Mask32x16FromBits constructs a Mask32x16 from a bitmap value, where 1 means set for the indexed element, 0 means unset. 941 // 942 // Asm: KMOVD, CPU Feature: AVX512 943 func Mask32x16FromBits(y uint16) Mask32x16 944 945 // ToBits constructs a bitmap from a Mask32x16, where 1 means set for the indexed element, 0 means unset. 946 // 947 // Asm: KMOVD, CPU Features: AVX512 948 func (x Mask32x16) ToBits() uint16 949 950 // Mask64x8 is a mask for a SIMD vector of 8 64-bit elements. 951 type Mask64x8 struct { 952 int64x8 v512 953 vals [8]int64 954 } 955 956 // Mask64x8FromBits constructs a Mask64x8 from a bitmap value, where 1 means set for the indexed element, 0 means unset. 957 // 958 // Asm: KMOVQ, CPU Feature: AVX512 959 func Mask64x8FromBits(y uint8) Mask64x8 960 961 // ToBits constructs a bitmap from a Mask64x8, where 1 means set for the indexed element, 0 means unset. 962 // 963 // Asm: KMOVQ, CPU Features: AVX512 964 func (x Mask64x8) ToBits() uint8 965