// Copyright 2026 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

//go:build loong64 && gc && !purego

#include "textflag.h"

DATA ·iv0<>+0(SB)/8, $0x6a09e667f3bcc908
DATA ·iv0<>+8(SB)/8, $0xbb67ae8584caa73b
GLOBL ·iv0<>(SB), RODATA|NOPTR, $16

DATA ·iv1<>+0(SB)/8, $0x3c6ef372fe94f82b
DATA ·iv1<>+8(SB)/8, $0xa54ff53a5f1d36f1
GLOBL ·iv1<>(SB), RODATA|NOPTR, $16

DATA ·iv2<>+0(SB)/8, $0x510e527fade682d1
DATA ·iv2<>+8(SB)/8, $0x9b05688c2b3e6c1f
GLOBL ·iv2<>(SB), RODATA|NOPTR, $16

DATA ·iv3<>+0(SB)/8, $0x1f83d9abfb41bd6b
DATA ·iv3<>+8(SB)/8, $0x5be0cd19137e2179
GLOBL ·iv3<>(SB), RODATA|NOPTR, $16

#define SHUFFLE_1 \
	VADDV		V2, V13, V12; \	// V12 = V2
	VADDV		V6, V13, V16; \	// V16 = V6
	VADDV		V4, V13, V14; \	// V14 = V4
	VADDV		V5, V13, V4; \	// V4 = V5
	VADDV		V14, V13, V5; \	// V5 = V4
	VSHUF4IV	$9, V3, V2; \
	VSHUF4IV	$9, V12, V3; \
	VSHUF4IV	$3, V7, V6; \
	VSHUF4IV	$3, V16, V7; \

#define SHUFFLE_2 \
	VADDV		V2, V13, V12; \	// V12 = V2
	VADDV		V6, V13, V16; \	// V16 = V6
	VADDV		V4, V13, V14; \	// V14 = V4
	VADDV		V5, V13, V4; \	// V4 = V5
	VADDV		V14, V13, V5; \	// V5 = V4
	VSHUF4IV	$3, V3, V2; \
	VSHUF4IV	$3, V12, V3; \
	VSHUF4IV	$9, V7, V6; \
	VSHUF4IV	$9, V16, V7; \

#define LOAD_M(a, b, c, d, e, f, g, h) \
	VMOVQ	a, V8.V[0]; \
	VMOVQ	b, V8.V[1]; \
	VMOVQ	c, V9.V[0]; \
	VMOVQ	d, V9.V[1]; \
	VMOVQ	e, V10.V[0]; \
	VMOVQ	f, V10.V[1]; \
	VMOVQ	g, V11.V[0]; \
	VMOVQ	h, V11.V[1]; \

#define ROUND_0 \
	VADDV	V0, V8, V0; \
	VADDV	V1, V9, V1; \
	VADDV	V0, V2, V0; \
	VADDV	V1, V3, V1; \
	VXORV	V6, V0, V6; \
	VXORV	V7, V1, V7; \
	VROTRV	$32, V6, V6; \
	VROTRV	$32, V7, V7; \
	VADDV	V4, V6, V4; \
	VADDV	V5, V7, V5; \
	VXORV	V2, V4, V2; \
	VXORV	V3, V5, V3; \
	VROTRV	$24, V2, V2; \
	VROTRV	$24, V3, V3; \
	VADDV	V0, V10, V0; \
	VADDV	V1, V11, V1; \
	VADDV	V0, V2, V0; \
	VADDV	V1, V3, V1; \
	VXORV	V6, V0, V6; \
	VXORV	V7, V1, V7; \
	VROTRV	$16, V6, V6; \
	VROTRV	$16, V7, V7; \
	VADDV	V4, V6, V4; \
	VADDV	V5, V7, V5; \
	VXORV	V2, V4, V2; \
	VXORV	V3, V5, V3; \
	VROTRV	$63, V2, V2; \
	VROTRV	$63, V3, V3; \

#define ROUND_8	ROUND_0

// func hashBlocksVX(h *[8]uint64, c *[2]uint64, flag uint64, blocks []byte)
TEXT ·hashBlocksVX(SB), NOSPLIT, $0-48
	MOVV	h+0(FP), R4
	MOVV	c+8(FP), R5
	MOVV	flag+16(FP), R6
	MOVV	blocks_base+24(FP), R7
	MOVV	blocks_len+32(FP), R8
	MOVV	(R5), R9	// c0
	MOVV	8(R5), R10	// c1

loop:
	ADDV	$0x80, R9
	SGTU	$0x80, R9, R11
	ADDV	R10, R11, R10
	VMOVQ	R9, V8.V[0]
	VMOVQ	R10, V8.V[1]

	MOVV	$·iv0<>(SB), R11
	MOVV	$·iv1<>(SB), R12
	MOVV	$·iv2<>(SB), R13
	MOVV	$·iv3<>(SB), R14
	VMOVQ	(R13), V6
	VMOVQ	(R11), V4
	VMOVQ	(R12), V5
	MOVV	(R14), R15	// v14
	MOVV	8(R14), R16
	VXORV	V6, V8, V6
	XOR	R15, R6, R15
	VMOVQ	R16, V7.V[1]
	VMOVQ	R15, V7.V[0]

	VMOVQ	(R4), V0
	VMOVQ	16(R4), V1
	VMOVQ	32(R4), V2
	VMOVQ	48(R4), V3

	MOVV	0(R7), R11
	MOVV	8(R7), R12
	MOVV	16(R7), R13
	MOVV	24(R7), R14
	MOVV	32(R7), R15
	MOVV	40(R7), R16
	MOVV	48(R7), R17
	MOVV	56(R7), R18
	MOVV	64(R7), R19
	MOVV	72(R7), R24
	MOVV	80(R7), R25
	MOVV	88(R7), R26
	MOVV	96(R7), R27
	MOVV	104(R7), R28
	MOVV	112(R7), R29
	MOVV	120(R7), R30

	VXORV	V13, V13, V13	// V13=0

	LOAD_M(R11, R13, R15, R17, R12, R14, R16, R18)
	ROUND_0
	SHUFFLE_1
	LOAD_M(R19, R25, R27, R29, R24, R26, R28, R30)
	ROUND_8
	SHUFFLE_2

	LOAD_M(R29, R15, R24, R28, R25, R19, R30, R17)
	ROUND_0
	SHUFFLE_1
	LOAD_M(R12, R11, R26, R16, R27, R13, R18, R14)
	ROUND_8
	SHUFFLE_2

	LOAD_M(R26, R27, R16, R30, R19, R11, R13, R28)
	ROUND_0
	SHUFFLE_1
	LOAD_M(R25, R14, R18, R24, R29, R17, R12, R15)
	ROUND_8
	SHUFFLE_2

	LOAD_M(R18, R14, R28, R26, R24, R12, R27, R29)
	ROUND_0
	SHUFFLE_1
	LOAD_M(R13, R16, R15, R30, R17, R25, R11, R19)
	ROUND_8
	SHUFFLE_2

	LOAD_M(R24, R16, R13, R25, R11, R18, R15, R30)
	ROUND_0
	SHUFFLE_1
	LOAD_M(R29, R26, R17, R14, R12, R27, R19, R28)
	ROUND_8
	SHUFFLE_2

	LOAD_M(R13, R17, R11, R19, R27, R25, R26, R14)
	ROUND_0
	SHUFFLE_1
	LOAD_M(R15, R18, R30, R12, R28, R16, R29, R24)
	ROUND_8
	SHUFFLE_2

	LOAD_M(R27, R12, R29, R15, R16, R30, R28, R25)
	ROUND_0
	SHUFFLE_1
	LOAD_M(R11, R17, R24, R19, R18, R14, R13, R26)
	ROUND_8
	SHUFFLE_2

	LOAD_M(R28, R18, R27, R14, R26, R29, R12, R24)
	ROUND_0
	SHUFFLE_1
	LOAD_M(R16, R30, R19, R13, R11, R15, R17, R25)
	ROUND_8
	SHUFFLE_2

	LOAD_M(R17, R29, R26, R11, R30, R24, R14, R19)
	ROUND_0
	SHUFFLE_1
	LOAD_M(R27, R28, R12, R25, R13, R18, R15, R16)
	ROUND_8
	SHUFFLE_2

	LOAD_M(R25, R19, R18, R12, R13, R15, R17, R16)
	ROUND_0
	SHUFFLE_1
	LOAD_M(R30, R24, R14, R28, R26, R29, R27, R11)
	ROUND_8
	SHUFFLE_2

	LOAD_M(R11, R13, R15, R17, R12, R14, R16, R18)
	ROUND_0
	SHUFFLE_1
	LOAD_M(R19, R25, R27, R29, R24, R26, R28, R30)
	ROUND_8
	SHUFFLE_2

	LOAD_M(R29, R15, R24, R28, R25, R19, R30, R17)
	ROUND_0
	SHUFFLE_1
	LOAD_M(R12, R11, R26, R16, R27, R13, R18, R14)
	ROUND_8
	SHUFFLE_2

	VMOVQ	(R4), V8
	VMOVQ	16(R4), V9
	VMOVQ	32(R4), V10
	VMOVQ	48(R4), V11
	VXORV	V0, V4, V0
	VXORV	V1, V5, V1
	VXORV	V2, V6, V2
	VXORV	V3, V7, V3
	VXORV	V0, V8, V0
	VXORV	V1, V9, V1
	VXORV	V2, V10, V2
	VXORV	V3, V11, V3
	VMOVQ	V0, (R4)
	VMOVQ	V1, 16(R4)
	VMOVQ	V2, 32(R4)
	VMOVQ	V3, 48(R4)

	SUBV	$128, R8
	ADDV	$128, R7
	BNE	R8, R0, loop

	MOVV	R9, (R5)
	MOVV	R10, 8(R5)

	RET