// license that can be found in the LICENSE file.

//go:build !math_big_pure_go && (mips64 || mips64le)

#include "textflag.h"

// This file provides fast assembly versions for the elementary
// arithmetic operations on vectors implemented in arith.go.

TEXT ·addVV(SB),NOSPLIT,$0
	JMP ·addVV_g(SB)

TEXT ·subVV(SB),NOSPLIT,$0
	JMP ·subVV_g(SB)

TEXT ·addVW(SB),NOSPLIT,$0
	JMP ·addVW_g(SB)

TEXT ·subVW(SB),NOSPLIT,$0

// license that can be found in the LICENSE file.

//go:build !math_big_pure_go && riscv64

#include "textflag.h"

// This file provides fast assembly versions for the elementary
// arithmetic operations on vectors implemented in arith.go.

TEXT ·addVV(SB),NOSPLIT,$0
	JMP ·addVV_g(SB)

TEXT ·subVV(SB),NOSPLIT,$0
	JMP ·subVV_g(SB)

TEXT ·addVW(SB),NOSPLIT,$0
	JMP ·addVW_g(SB)

TEXT ·subVW(SB),NOSPLIT,$0

	MOVD	$16, R10
	MOVD	$32, R14
	MOVD	$48, R15
	ANDCC	$63, R6, R9	// Check for tailing bytes for later
	PCALIGN $16
	// Case for >= 64 bytes
	// Process 64 bytes per iteration
	// Load 4 vectors of a and b
	// XOR the corresponding vectors
	// from a and b and store the result
loop64:
	LXVD2X	(R4)(R8), VS32
	LXVD2X	(R4)(R10), VS34
	LXVD2X	(R4)(R14), VS36
	LXVD2X	(R4)(R15), VS38
	LXVD2X	(R5)(R8), VS33
	LXVD2X	(R5)(R10), VS35

//go:build arm64 && !linux && !freebsd && !android && (!darwin || ios) && !openbsd

package cpu

func osInit() {
	// Other operating systems do not support reading HWCap from auxiliary vector,
	// reading privileged aarch64 system registers or sysctl in user space to detect
	// CPU features at runtime.

	/* Vector instructions */

	/* Vector load */
	{as: ALVEBX, a1: C_XOREG, a6: C_VREG, type_: 45, size: 4}, /* vector load, x-form */

	/* Vector store */
	{as: ASTVEBX, a1: C_VREG, a6: C_XOREG, type_: 44, size: 4}, /* vector store, x-form */

	/* Vector logical */
	{as: AVAND, a1: C_VREG, a2: C_VREG, a6: C_VREG, type_: 82, size: 4}, /* vector and, vx-form */

	_, errUint64 := ParseUint("INVALID", 10, 64)

	vectors := []struct {
		err  error  // Input error
		want string // Function name wanted
	}{
		{errInt, "Atoi"},
		{errBool, "ParseBool"},
		{errFloat, "ParseFloat"},
		{errInt64, "ParseInt"},
		{errUint64, "ParseUint"},
	}

	for _, v := range vectors {
		nerr, ok := v.err.(*NumError)
		if !ok {

	ROUND4(X0, X5, X15, X10, X1, X6, X12, X11, X2, X7, X13, X8,  X3, X4, X14, X9)

	ADD $-1, R1
	BNE loop

	// decrement length
	ADD $-256, R4

	// rearrange vectors
	SHUFFLE(X0, X1, X2, X3, M0, M1, M2, M3)
	ADDV(J0, X0, X1, X2, X3)
	SHUFFLE(X4, X5, X6, X7, M0, M1, M2, M3)
	ADDV(KEY0, X4, X5, X6, X7)
	SHUFFLE(X8, X9, X10, X11, M0, M1, M2, M3)
	ADDV(KEY1, X8, X9, X10, X11)

	return dk.EncapsulationKey(), dk
}

var millionFlag = flag.Bool("million", false, "run the million vector test")

// TestPQCrystalsAccumulated accumulates the 10k vectors generated by the
// reference implementation and checks the hash of the result, to avoid checking
// in 150MB of test vectors.
func TestPQCrystalsAccumulated(t *testing.T) {
	n := 10000

		arg = argVW{z, x, y, 0}
		testFunVWext(t, "addVW, vector of max uint", addVW, addVW_g, arg)

		// vector of '0', to force carry flag set in each 'sub'
		x = makeWordVec(0, n)
		arg = argVW{z, x, 1, 0}
		testFunVWext(t, "subVW, vector of zero", subVW, subVW_g, arg)
	}
}

type argVU struct {
	d  []Word // d is a Word slice, the input parameters x and z come from this array.

package chacha20

import "golang.org/x/sys/cpu"

var haveAsm = cpu.S390X.HasVX

const bufSize = 256

// xorKeyStreamVX is an assembly implementation of XORKeyStream. It must only
// be called when the vector facility is available. Implementation in asm_s390x.s.
//
//go:noescape
func xorKeyStreamVX(dst, src []byte, key *[8]uint32, nonce *[3]uint32, counter *uint32)

func (c *Cipher) xorKeyStreamBlocks(dst, src []byte) {