// Copyright 2022 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.

#include "go_asm.h"
#include "textflag.h"

TEXT ·Compare<ABIInternal>(SB),NOSPLIT,$0-56
	// R4 = a_base
	// R5 = a_len
	// R6 = a_cap (unused)
	// R7 = b_base (want in R6)
	// R8 = b_len (want in R7)
	// R9 = b_cap (unused)
	MOVV	R7, R6
	MOVV	R8, R7
	JMP	cmpbody<>(SB)

TEXT runtime·cmpstring<ABIInternal>(SB),NOSPLIT,$0-40
	// R4 = a_base
	// R5 = a_len
	// R6 = b_base
	// R7 = b_len
	JMP	cmpbody<>(SB)

// On entry:
// R5 length of a
// R7 length of b
// R4 points to the start of a
// R6 points to the start of b
// for regabi the return value (-1/0/1) in R4
TEXT cmpbody<>(SB),NOSPLIT|NOFRAME,$0
	BEQ	R4, R6, cmp_len		// same start of a and b, then compare lengths

	SGTU	R5, R7, R9
	BNE	R9, b_lt_a
	MOVV	R5, R14
	JMP	entry
b_lt_a:
	MOVV	R7, R14			// R14 is min(R5, R7)
entry:
	ADDV	R4, R14, R12		// R4 start of a, R12 end of a
	BEQ	R4, R12, cmp_len	// minlength is 0

tail:
	MOVV	$2, R15
	BLT	R14, R15, cmp1		// min < 2
	SLLV	$1, R15
	BLT	R14, R15, cmp2		// min < 4
	SLLV	$1, R15
	BLT	R14, R15, cmp4		// min < 8
	SLLV	$1, R15
	BLT	R14, R15, cmp8		// min < 16
	SLLV	$1, R15
	BLT	R14, R15, cmp16		// min < 32

// When min >= 32 bytes, enter the cmp32_loop loop processing:
// take out 4 8-bytes from a and b in turn for comparison.
cmp32_loop:
	MOVV	(R4), R8
	MOVV	(R6), R9
	MOVV	8(R4), R10
	MOVV	8(R6), R11
	BNE	R8, R9, cmp8a
	BNE	R10, R11, cmp8b
	MOVV	16(R4), R8
	MOVV	16(R6), R9
	MOVV	24(R4), R10
	MOVV	24(R6), R11
	BNE	R8, R9, cmp8a
	BNE	R10, R11, cmp8b
	ADDV	$32, R4
	ADDV	$32, R6
	SUBV	$32, R14
	BGE	R14, R15, cmp32_loop
	BEQ	R14, cmp_len

check16:
	MOVV	$16, R15
	BLT	R14, R15, check8
cmp16:
	MOVV	(R4), R8
	MOVV	(R6), R9
	MOVV	8(R4), R10
	MOVV	8(R6), R11
	BNE	R8, R9, cmp8a
	BNE	R10, R11, cmp8b
	ADDV	$16, R4
	ADDV	$16, R6
	SUBV	$16, R14
	BEQ	R14, cmp_len

check8:
	MOVV	$8, R15
	BLT	R14, R15, check4
cmp8:
	MOVV	(R4), R8
	MOVV	(R6), R9
	BNE	R8, R9, cmp8a
	ADDV	$8, R4
	ADDV	$8, R6
	SUBV	$8, R14
	BEQ	R14, cmp_len

check4:
	MOVV	$4, R15
	BLT	R14, R15, check2
cmp4:
	MOVW	(R4), R8
	MOVW	(R6), R9
	BNE	R8, R9, cmp8a
	ADDV	$4, R4
	ADDV	$4, R6
	SUBV	$4, R14
	BEQ	R14, cmp_len

check2:
	MOVV	$2, R15
	BLT	R14, R15, cmp1
cmp2:
	MOVH	(R4), R8
	MOVH	(R6), R9
	BNE	R8, R9, cmp8a
	ADDV	$2, R4
	ADDV	$2, R6
	SUBV	$2, R14
	BEQ	R14, cmp_len

cmp1:
	BEQ	R14, cmp_len
	MOVBU	(R4), R8
	MOVBU	(R6), R9
	BNE	R8, R9, byte_cmp
	JMP	cmp_len

	// Compare 8/4/2 bytes taken from R8/R9 that are known to differ.
cmp8a:
	MOVV	R8, R10
	MOVV	R9, R11

	// Compare 8/4/2 bytes taken from R10/R11 that are known to differ.
cmp8b:
	MOVV	$0xff, R15

	// Take single bytes from R10/R11 in turn for cyclic comparison.
cmp8_loop:
	AND	R10, R15, R8
	AND	R11, R15, R9
	BNE	R8, R9, byte_cmp
	SLLV	$8, R15
	JMP	cmp8_loop

	// Compare 1 bytes taken from R8/R9 that are known to differ.
byte_cmp:
	SGTU	R8, R9, R4		// R4 = 1 if (R8 > R9)
	BNE	R0, R4, ret
	MOVV	$-1, R4
	JMP	ret

cmp_len:
	SGTU	R5, R7, R8
	SGTU	R7, R5, R9
	SUBV	R9, R8, R4

ret:
	RET