MULHDU  R9, R20, R25      // R25 = z1[i]
	ADD     $-1, R11          // R11 = z_len - 1
	ADDC    R4, R24
	ADDZE   R25, R4
	MOVDU   R24, 8(R10)       // z[i]
	CMP     R11, $0
	BEQ     done              // If R11 = 0, we are done

	MOVDU   8(R8), R20
	MULLD   R9, R20, R24
	MULHDU  R9, R20, R25
	ADD     $-1, R11
	ADDC    R4, R24
	ADDZE   R25, R4
	MOVDU   R24, 8(R10)
	CMP     R11, $0

 * are callee-save, so they must be saved explicitly, along with $r1 (LR).
 */
.globl crosscall1
crosscall1:
	addi.d	$r3, $r3, -160
	st.d	$r1, $r3, 0
	st.d	$r23, $r3, 8
	st.d	$r24, $r3, 16
	st.d	$r25, $r3, 24
	st.d	$r26, $r3, 32
	st.d	$r27, $r3, 40
	st.d	$r28, $r3, 48
	st.d	$r29, $r3, 56
	st.d	$r30, $r3, 64
	st.d	$r2, $r3, 72
	st.d	$r22, $r3, 80
	fst.d	$f24, $r3, 88
	fst.d	$f25, $r3, 96

	print("r20  ", hex(c.r20()), "\t")
	print("r21  ", hex(c.r21()), "\n")
	print("r22  ", hex(c.r22()), "\t")
	print("r23  ", hex(c.r23()), "\n")
	print("r24  ", hex(c.r24()), "\t")
	print("r25  ", hex(c.r25()), "\n")
	print("r26  ", hex(c.r26()), "\t")
	print("r27  ", hex(c.r27()), "\n")
	print("r28  ", hex(c.r28()), "\t")
	print("r29  ", hex(c.r29()), "\n")
	print("r30  ", hex(c.r30()), "\t")

	XOR	R21,R24,R21	// xor done R24
	MOVWZ	(R10)(R8),R25	// tab[4][crc>>24]
	RLDICL	$48,R7,$56,R24	// crc>>16&0xFF
	XOR	R21,R25,R21	// xor done R25
	ADD	$1024,R10,R10	// &tab[5]
	SLD	$2,R24,R24	// crc>>16&0xFF*4
	MOVWZ	(R10)(R24),R26	// tab[5][crc>>16&0xFF]
	XOR	R21,R26,R21	// xor done R26
	RLDICL	$56,R7,$56,R25	// crc>>8
	ADD	$1024,R10,R10	// &tab[6]
	SLD	$2,R25,R25	// crc>>8&FF*2
	MOVBZ   R7,R26          // crc&0xFF

	MOVV R14, 88(R3)
	MOVV R15, 96(R3)
	MOVV R16, 104(R3)
	MOVV R17, 112(R3)
	MOVV R18, 120(R3)
	MOVV R19, 128(R3)
	MOVV R20, 136(R3)
	MOVV R21, 144(R3)
	MOVV R23, 152(R3)
	MOVV R24, 160(R3)
	MOVV R25, 168(R3)
	MOVV R26, 176(R3)
	MOVV R27, 184(R3)
	MOVV R28, 192(R3)
	MOVV R29, 200(R3)
	MOVV R31, 208(R3)
	MOVD F0, 216(R3)
	MOVD F1, 224(R3)
	MOVD F2, 232(R3)
	MOVD F3, 240(R3)
	MOVD F4, 248(R3)

	{"R15", "R15"},
	{"R16", "R16"},
	{"R17", "R17"},
	{"R18", "R18"},
	{"R19", "R19"},
	{"R2", "R2"},
	{"R20", "R20"},
	{"R21", "R21"},
	{"R22", "R22"},
	{"R23", "R23"},
	{"R24", "R24"},
	{"R25", "R25"},
	{"R26", "R26"},
	{"R27", "R27"},
	{"R28", "R28"},
	{"R29", "R29"},
	{"R3", "R3"},
	{"R31", "R31"},
	{"R4", "R4"},
	{"R5", "R5"},
	{"R6", "R6"},
	{"R7", "R7"},
	{"R8", "R8"},

	MOVD	R15, 56(R1)
	MOVD	R16, 64(R1)
	MOVD	R17, 72(R1)
	MOVD	R18, 80(R1)
	MOVD	R19, 88(R1)
	MOVD	R20, 96(R1)
	MOVD	R21,104(R1)
	MOVD	R22, 112(R1)
	MOVD	R23, 120(R1)
	MOVD	R24, 128(R1)
	MOVD	R25, 136(R1)
	MOVD	R26, 144(R1)
	MOVD	R27, 152(R1)
	MOVD	R28, 160(R1)
	MOVD	R29, 168(R1)
	MOVD	g, 176(R1) // R30
	MOVD	R31, 184(R1)
	FMOVD	F14, 192(R1)
	FMOVD	F15, 200(R1)
	FMOVD	F16, 208(R1)
	FMOVD	F17, 216(R1)

	STLXP (R17, R19), (R4), R5      <=>    stlxp w5, x17, x19, [x4]
	STXPW (R30, R25), (R22), R13    <=>    stxp w13, w30, w25, [x22]

2. Expressions for special arguments.

#<immediate> is written as $<immediate>.

Optionally-shifted immediate.

Examples:

	ADD $(3151<<12), R14, R20     <=>    add x20, x14, #0xc4f, lsl #12
	ADDW $1864, R25, R6           <=>    add w6, w25, #0x748

	LDP	19*8(RSP), (R23, R24)
	LDP	21*8(RSP), (R25, R26)
	JMP	retry

TEXT runtime·gcWriteBarrier1<ABIInternal>(SB),NOSPLIT,$0
	MOVD	$8, R25
	JMP	gcWriteBarrier<>(SB)
TEXT runtime·gcWriteBarrier2<ABIInternal>(SB),NOSPLIT,$0
	MOVD	$16, R25
	JMP	gcWriteBarrier<>(SB)
TEXT runtime·gcWriteBarrier3<ABIInternal>(SB),NOSPLIT,$0
	MOVD	$24, R25
	JMP	gcWriteBarrier<>(SB)

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.integtests.tooling.r25

import org.gradle.integtests.fixtures.executer.GradleVersions
import org.gradle.integtests.tooling.fixture.ContinuousBuildToolingApiSpecification
import org.gradle.integtests.tooling.fixture.TargetGradleVersion