runtime/interpreter/mterp/mips64/array.S - platform/art - Git at Google

 %def op_aget(load="lw", shift="2", data_offset="MIRROR_INT_ARRAY_DATA_OFFSET"):
     /*
      * Array get, 32 bits or less.  vAA <- vBB[vCC].
      *
      * for: aget, aget-boolean, aget-byte, aget-char, aget-short
      *
      * NOTE: assumes data offset for arrays is the same for all non-wide types.
      * If this changes, specialize.
      */
     /* op vAA, vBB, vCC */
     lbu     a2, 2(rPC)                  # a2 <- BB
     lbu     a3, 3(rPC)                  # a3 <- CC
     srl     a4, rINST, 8                # a4 <- AA
     GET_VREG_U a0, a2                   # a0 <- vBB (array object)
     GET_VREG a1, a3                     # a1 <- vCC (requested index)
     beqz    a0, common_errNullObject    # bail if null array object
     lw      a3, MIRROR_ARRAY_LENGTH_OFFSET(a0)  # a3 <- arrayObj->length
     .if $shift
     # [d]lsa does not support shift count of 0.
     dlsa    a0, a1, a0, $shift          # a0 <- arrayObj + index*width
     .else
     daddu   a0, a1, a0                  # a0 <- arrayObj + index*width
     .endif
     bgeu    a1, a3, common_errArrayIndex  # unsigned compare: index >= length, bail
     FETCH_ADVANCE_INST 2                # advance rPC, load rINST
     $load   a2, $data_offset(a0)        # a2 <- vBB[vCC]
     GET_INST_OPCODE v0                  # extract opcode from rINST
     SET_VREG a2, a4                     # vAA <- a2
     GOTO_OPCODE v0                      # jump to next instruction

 %def op_aget_boolean():
 %  op_aget(load="lbu", shift="0", data_offset="MIRROR_BOOLEAN_ARRAY_DATA_OFFSET")

 %def op_aget_byte():
 %  op_aget(load="lb", shift="0", data_offset="MIRROR_BYTE_ARRAY_DATA_OFFSET")

 %def op_aget_char():
 %  op_aget(load="lhu", shift="1", data_offset="MIRROR_CHAR_ARRAY_DATA_OFFSET")

 %def op_aget_object():
     /*
      * Array object get.  vAA <- vBB[vCC].
      *
      * for: aget-object
      */
     /* op vAA, vBB, vCC */
     .extern artAGetObjectFromMterp
     lbu     a2, 2(rPC)                  # a2 <- BB
     lbu     a3, 3(rPC)                  # a3 <- CC
     EXPORT_PC
     GET_VREG_U a0, a2                   # a0 <- vBB (array object)
     GET_VREG a1, a3                     # a1 <- vCC (requested index)
     jal     artAGetObjectFromMterp      # (array, index)
     ld      a1, THREAD_EXCEPTION_OFFSET(rSELF)
     srl     a4, rINST, 8                # a4 <- AA
     PREFETCH_INST 2
     bnez    a1, MterpException
     SET_VREG_OBJECT v0, a4              # vAA <- v0
     ADVANCE 2
     GET_INST_OPCODE v0                  # extract opcode from rINST
     GOTO_OPCODE v0                      # jump to next instruction

 %def op_aget_short():
 %  op_aget(load="lh", shift="1", data_offset="MIRROR_SHORT_ARRAY_DATA_OFFSET")

 %def op_aget_wide():
     /*
      * Array get, 64 bits.  vAA <- vBB[vCC].
      *
      */
     /* aget-wide vAA, vBB, vCC */
     lbu     a2, 2(rPC)                  # a2 <- BB
     lbu     a3, 3(rPC)                  # a3 <- CC
     srl     a4, rINST, 8                # a4 <- AA
     GET_VREG_U a0, a2                   # a0 <- vBB (array object)
     GET_VREG a1, a3                     # a1 <- vCC (requested index)
     beqz    a0, common_errNullObject    # bail if null array object
     lw      a3, MIRROR_ARRAY_LENGTH_OFFSET(a0)  # a3 <- arrayObj->length
     dlsa    a0, a1, a0, 3               # a0 <- arrayObj + index*width
     bgeu    a1, a3, common_errArrayIndex  # unsigned compare: index >= length, bail
     FETCH_ADVANCE_INST 2                # advance rPC, load rINST
     lw      a2, MIRROR_WIDE_ARRAY_DATA_OFFSET(a0)
     lw      a3, (MIRROR_WIDE_ARRAY_DATA_OFFSET+4)(a0)
     dinsu   a2, a3, 32, 32              # a2 <- vBB[vCC]
     GET_INST_OPCODE v0                  # extract opcode from rINST
     SET_VREG_WIDE a2, a4                # vAA <- a2
     GOTO_OPCODE v0                      # jump to next instruction

 %def op_aput(store="sw", shift="2", data_offset="MIRROR_INT_ARRAY_DATA_OFFSET"):
     /*
      * Array put, 32 bits or less.  vBB[vCC] <- vAA.
      *
      * for: aput, aput-boolean, aput-byte, aput-char, aput-short
      *
      * NOTE: this assumes data offset for arrays is the same for all non-wide types.
      * If this changes, specialize.
      */
     /* op vAA, vBB, vCC */
     lbu     a2, 2(rPC)                  # a2 <- BB
     lbu     a3, 3(rPC)                  # a3 <- CC
     srl     a4, rINST, 8                # a4 <- AA
     GET_VREG_U a0, a2                   # a0 <- vBB (array object)
     GET_VREG a1, a3                     # a1 <- vCC (requested index)
     beqz    a0, common_errNullObject    # bail if null array object
     lw      a3, MIRROR_ARRAY_LENGTH_OFFSET(a0)  # a3 <- arrayObj->length
     .if $shift
     # [d]lsa does not support shift count of 0.
     dlsa    a0, a1, a0, $shift          # a0 <- arrayObj + index*width
     .else
     daddu   a0, a1, a0                  # a0 <- arrayObj + index*width
     .endif
     bgeu    a1, a3, common_errArrayIndex  # unsigned compare: index >= length, bail
     FETCH_ADVANCE_INST 2                # advance rPC, load rINST
     GET_VREG a2, a4                     # a2 <- vAA
     GET_INST_OPCODE v0                  # extract opcode from rINST
     $store  a2, $data_offset(a0)        # vBB[vCC] <- a2
     GOTO_OPCODE v0                      # jump to next instruction

 %def op_aput_boolean():
 %  op_aput(store="sb", shift="0", data_offset="MIRROR_BOOLEAN_ARRAY_DATA_OFFSET")

 %def op_aput_byte():
 %  op_aput(store="sb", shift="0", data_offset="MIRROR_BYTE_ARRAY_DATA_OFFSET")

 %def op_aput_char():
 %  op_aput(store="sh", shift="1", data_offset="MIRROR_CHAR_ARRAY_DATA_OFFSET")

 %def op_aput_object():
     /*
      * Store an object into an array.  vBB[vCC] <- vAA.
      */
     /* op vAA, vBB, vCC */
     .extern MterpAputObject
     EXPORT_PC
     daddu   a0, rFP, OFF_FP_SHADOWFRAME
     move    a1, rPC
     move    a2, rINST
     jal     MterpAputObject
     beqzc   v0, MterpPossibleException
     FETCH_ADVANCE_INST 2                # advance rPC, load rINST
     GET_INST_OPCODE v0                  # extract opcode from rINST
     GOTO_OPCODE v0                      # jump to next instruction

 %def op_aput_short():
 %  op_aput(store="sh", shift="1", data_offset="MIRROR_SHORT_ARRAY_DATA_OFFSET")

 %def op_aput_wide():
     /*
      * Array put, 64 bits.  vBB[vCC] <- vAA.
      *
      */
     /* aput-wide vAA, vBB, vCC */
     lbu     a2, 2(rPC)                  # a2 <- BB
     lbu     a3, 3(rPC)                  # a3 <- CC
     srl     a4, rINST, 8                # a4 <- AA
     GET_VREG_U a0, a2                   # a0 <- vBB (array object)
     GET_VREG a1, a3                     # a1 <- vCC (requested index)
     beqz    a0, common_errNullObject    # bail if null array object
     lw      a3, MIRROR_ARRAY_LENGTH_OFFSET(a0)  # a3 <- arrayObj->length
     dlsa    a0, a1, a0, 3               # a0 <- arrayObj + index*width
     bgeu    a1, a3, common_errArrayIndex  # unsigned compare: index >= length, bail
     GET_VREG_WIDE a2, a4                # a2 <- vAA
     FETCH_ADVANCE_INST 2                # advance rPC, load rINST
     GET_INST_OPCODE v0                  # extract opcode from rINST
     sw      a2, MIRROR_WIDE_ARRAY_DATA_OFFSET(a0)
     dsrl32  a2, a2, 0
     sw      a2, (MIRROR_WIDE_ARRAY_DATA_OFFSET+4)(a0)  # vBB[vCC] <- a2
     GOTO_OPCODE v0                      # jump to next instruction

 %def op_array_length():
     /*
      * Return the length of an array.
      */
     srl     a1, rINST, 12               # a1 <- B
     GET_VREG_U a0, a1                   # a0 <- vB (object ref)
     ext     a2, rINST, 8, 4             # a2 <- A
     beqz    a0, common_errNullObject    # yup, fail
     FETCH_ADVANCE_INST 1                # advance rPC, load rINST
     lw      a3, MIRROR_ARRAY_LENGTH_OFFSET(a0)  # a3 <- array length
     GET_INST_OPCODE v0                  # extract opcode from rINST
     SET_VREG a3, a2                     # vB <- length
     GOTO_OPCODE v0                      # jump to next instruction

 %def op_fill_array_data():
     /* fill-array-data vAA, +BBBBBBBB */
     .extern MterpFillArrayData
     EXPORT_PC
     lh      a1, 2(rPC)                  # a1 <- bbbb (lo)
     lh      a0, 4(rPC)                  # a0 <- BBBB (hi)
     srl     a3, rINST, 8                # a3 <- AA
     ins     a1, a0, 16, 16              # a1 <- BBBBbbbb
     GET_VREG_U a0, a3                   # a0 <- vAA (array object)
     dlsa    a1, a1, rPC, 1              # a1 <- PC + BBBBbbbb*2 (array data off.)
     jal     MterpFillArrayData          # (obj, payload)
     beqzc   v0, MterpPossibleException  # exception?
     FETCH_ADVANCE_INST 3                # advance rPC, load rINST
     GET_INST_OPCODE v0                  # extract opcode from rINST
     GOTO_OPCODE v0                      # jump to next instruction

 %def op_filled_new_array(helper="MterpFilledNewArray"):
     /*
      * Create a new array with elements filled from registers.
      *
      * for: filled-new-array, filled-new-array/range
      */
     /* op vB, {vD, vE, vF, vG, vA}, class//CCCC */
     /* op {vCCCC..v(CCCC+AA-1)}, type//BBBB */
     .extern $helper
     EXPORT_PC
     daddu   a0, rFP, OFF_FP_SHADOWFRAME
     move    a1, rPC
     move    a2, rSELF
     jal     $helper
     beqzc   v0, MterpPossibleException
     FETCH_ADVANCE_INST 3                # advance rPC, load rINST
     GET_INST_OPCODE v0                  # extract opcode from rINST
     GOTO_OPCODE v0                      # jump to next instruction

 %def op_filled_new_array_range():
 %  op_filled_new_array(helper="MterpFilledNewArrayRange")

 %def op_new_array():
     /*
      * Allocate an array of objects, specified with the array class
      * and a count.
      *
      * The verifier guarantees that this is an array class, so we don't
      * check for it here.
      */
     /* new-array vA, vB, class//CCCC */
     .extern MterpNewArray
     EXPORT_PC
     daddu   a0, rFP, OFF_FP_SHADOWFRAME
     move    a1, rPC
     move    a2, rINST
     move    a3, rSELF
     jal     MterpNewArray
     beqzc   v0, MterpPossibleException
     FETCH_ADVANCE_INST 2                # advance rPC, load rINST
     GET_INST_OPCODE v0                  # extract opcode from rINST
     GOTO_OPCODE v0                      # jump to next instruction
	%def op_aget(load="lw", shift="2", data_offset="MIRROR_INT_ARRAY_DATA_OFFSET"):
	/*
	* Array get, 32 bits or less. vAA <- vBB[vCC].
	*
	* for: aget, aget-boolean, aget-byte, aget-char, aget-short
	*
	* NOTE: assumes data offset for arrays is the same for all non-wide types.
	* If this changes, specialize.
	*/
	/* op vAA, vBB, vCC */
	lbu a2, 2(rPC) # a2 <- BB
	lbu a3, 3(rPC) # a3 <- CC
	srl a4, rINST, 8 # a4 <- AA
	GET_VREG_U a0, a2 # a0 <- vBB (array object)
	GET_VREG a1, a3 # a1 <- vCC (requested index)
	beqz a0, common_errNullObject # bail if null array object
	lw a3, MIRROR_ARRAY_LENGTH_OFFSET(a0) # a3 <- arrayObj->length
	.if $shift
	# [d]lsa does not support shift count of 0.
	dlsa a0, a1, a0, $shift # a0 <- arrayObj + index*width
	.else
	daddu a0, a1, a0 # a0 <- arrayObj + index*width
	.endif
	bgeu a1, a3, common_errArrayIndex # unsigned compare: index >= length, bail
	FETCH_ADVANCE_INST 2 # advance rPC, load rINST
	$load a2, $data_offset(a0) # a2 <- vBB[vCC]
	GET_INST_OPCODE v0 # extract opcode from rINST
	SET_VREG a2, a4 # vAA <- a2
	GOTO_OPCODE v0 # jump to next instruction

	%def op_aget_boolean():
	% op_aget(load="lbu", shift="0", data_offset="MIRROR_BOOLEAN_ARRAY_DATA_OFFSET")

	%def op_aget_byte():
	% op_aget(load="lb", shift="0", data_offset="MIRROR_BYTE_ARRAY_DATA_OFFSET")

	%def op_aget_char():
	% op_aget(load="lhu", shift="1", data_offset="MIRROR_CHAR_ARRAY_DATA_OFFSET")

	%def op_aget_object():
	/*
	* Array object get. vAA <- vBB[vCC].
	*
	* for: aget-object
	*/
	/* op vAA, vBB, vCC */
	.extern artAGetObjectFromMterp
	lbu a2, 2(rPC) # a2 <- BB
	lbu a3, 3(rPC) # a3 <- CC
	EXPORT_PC
	GET_VREG_U a0, a2 # a0 <- vBB (array object)
	GET_VREG a1, a3 # a1 <- vCC (requested index)
	jal artAGetObjectFromMterp # (array, index)
	ld a1, THREAD_EXCEPTION_OFFSET(rSELF)
	srl a4, rINST, 8 # a4 <- AA
	PREFETCH_INST 2
	bnez a1, MterpException
	SET_VREG_OBJECT v0, a4 # vAA <- v0
	ADVANCE 2
	GET_INST_OPCODE v0 # extract opcode from rINST
	GOTO_OPCODE v0 # jump to next instruction

	%def op_aget_short():
	% op_aget(load="lh", shift="1", data_offset="MIRROR_SHORT_ARRAY_DATA_OFFSET")

	%def op_aget_wide():
	/*
	* Array get, 64 bits. vAA <- vBB[vCC].
	*
	*/
	/* aget-wide vAA, vBB, vCC */
	lbu a2, 2(rPC) # a2 <- BB
	lbu a3, 3(rPC) # a3 <- CC
	srl a4, rINST, 8 # a4 <- AA
	GET_VREG_U a0, a2 # a0 <- vBB (array object)
	GET_VREG a1, a3 # a1 <- vCC (requested index)
	beqz a0, common_errNullObject # bail if null array object
	lw a3, MIRROR_ARRAY_LENGTH_OFFSET(a0) # a3 <- arrayObj->length
	dlsa a0, a1, a0, 3 # a0 <- arrayObj + index*width
	bgeu a1, a3, common_errArrayIndex # unsigned compare: index >= length, bail
	FETCH_ADVANCE_INST 2 # advance rPC, load rINST
	lw a2, MIRROR_WIDE_ARRAY_DATA_OFFSET(a0)
	lw a3, (MIRROR_WIDE_ARRAY_DATA_OFFSET+4)(a0)
	dinsu a2, a3, 32, 32 # a2 <- vBB[vCC]
	GET_INST_OPCODE v0 # extract opcode from rINST
	SET_VREG_WIDE a2, a4 # vAA <- a2
	GOTO_OPCODE v0 # jump to next instruction

	%def op_aput(store="sw", shift="2", data_offset="MIRROR_INT_ARRAY_DATA_OFFSET"):
	/*
	* Array put, 32 bits or less. vBB[vCC] <- vAA.
	*
	* for: aput, aput-boolean, aput-byte, aput-char, aput-short
	*
	* NOTE: this assumes data offset for arrays is the same for all non-wide types.
	* If this changes, specialize.
	*/
	/* op vAA, vBB, vCC */
	lbu a2, 2(rPC) # a2 <- BB
	lbu a3, 3(rPC) # a3 <- CC
	srl a4, rINST, 8 # a4 <- AA
	GET_VREG_U a0, a2 # a0 <- vBB (array object)
	GET_VREG a1, a3 # a1 <- vCC (requested index)
	beqz a0, common_errNullObject # bail if null array object
	lw a3, MIRROR_ARRAY_LENGTH_OFFSET(a0) # a3 <- arrayObj->length
	.if $shift
	# [d]lsa does not support shift count of 0.
	dlsa a0, a1, a0, $shift # a0 <- arrayObj + index*width
	.else
	daddu a0, a1, a0 # a0 <- arrayObj + index*width
	.endif
	bgeu a1, a3, common_errArrayIndex # unsigned compare: index >= length, bail
	FETCH_ADVANCE_INST 2 # advance rPC, load rINST
	GET_VREG a2, a4 # a2 <- vAA
	GET_INST_OPCODE v0 # extract opcode from rINST
	$store a2, $data_offset(a0) # vBB[vCC] <- a2
	GOTO_OPCODE v0 # jump to next instruction

	%def op_aput_boolean():
	% op_aput(store="sb", shift="0", data_offset="MIRROR_BOOLEAN_ARRAY_DATA_OFFSET")

	%def op_aput_byte():
	% op_aput(store="sb", shift="0", data_offset="MIRROR_BYTE_ARRAY_DATA_OFFSET")

	%def op_aput_char():
	% op_aput(store="sh", shift="1", data_offset="MIRROR_CHAR_ARRAY_DATA_OFFSET")

	%def op_aput_object():
	/*
	* Store an object into an array. vBB[vCC] <- vAA.
	*/
	/* op vAA, vBB, vCC */
	.extern MterpAputObject
	EXPORT_PC
	daddu a0, rFP, OFF_FP_SHADOWFRAME
	move a1, rPC
	move a2, rINST
	jal MterpAputObject
	beqzc v0, MterpPossibleException
	FETCH_ADVANCE_INST 2 # advance rPC, load rINST
	GET_INST_OPCODE v0 # extract opcode from rINST
	GOTO_OPCODE v0 # jump to next instruction

	%def op_aput_short():
	% op_aput(store="sh", shift="1", data_offset="MIRROR_SHORT_ARRAY_DATA_OFFSET")

	%def op_aput_wide():
	/*
	* Array put, 64 bits. vBB[vCC] <- vAA.
	*
	*/
	/* aput-wide vAA, vBB, vCC */
	lbu a2, 2(rPC) # a2 <- BB
	lbu a3, 3(rPC) # a3 <- CC
	srl a4, rINST, 8 # a4 <- AA
	GET_VREG_U a0, a2 # a0 <- vBB (array object)
	GET_VREG a1, a3 # a1 <- vCC (requested index)
	beqz a0, common_errNullObject # bail if null array object
	lw a3, MIRROR_ARRAY_LENGTH_OFFSET(a0) # a3 <- arrayObj->length
	dlsa a0, a1, a0, 3 # a0 <- arrayObj + index*width
	bgeu a1, a3, common_errArrayIndex # unsigned compare: index >= length, bail
	GET_VREG_WIDE a2, a4 # a2 <- vAA
	FETCH_ADVANCE_INST 2 # advance rPC, load rINST
	GET_INST_OPCODE v0 # extract opcode from rINST
	sw a2, MIRROR_WIDE_ARRAY_DATA_OFFSET(a0)
	dsrl32 a2, a2, 0
	sw a2, (MIRROR_WIDE_ARRAY_DATA_OFFSET+4)(a0) # vBB[vCC] <- a2
	GOTO_OPCODE v0 # jump to next instruction

	%def op_array_length():
	/*
	* Return the length of an array.
	*/
	srl a1, rINST, 12 # a1 <- B
	GET_VREG_U a0, a1 # a0 <- vB (object ref)
	ext a2, rINST, 8, 4 # a2 <- A
	beqz a0, common_errNullObject # yup, fail
	FETCH_ADVANCE_INST 1 # advance rPC, load rINST
	lw a3, MIRROR_ARRAY_LENGTH_OFFSET(a0) # a3 <- array length
	GET_INST_OPCODE v0 # extract opcode from rINST
	SET_VREG a3, a2 # vB <- length
	GOTO_OPCODE v0 # jump to next instruction

	%def op_fill_array_data():
	/* fill-array-data vAA, +BBBBBBBB */
	.extern MterpFillArrayData
	EXPORT_PC
	lh a1, 2(rPC) # a1 <- bbbb (lo)
	lh a0, 4(rPC) # a0 <- BBBB (hi)
	srl a3, rINST, 8 # a3 <- AA
	ins a1, a0, 16, 16 # a1 <- BBBBbbbb
	GET_VREG_U a0, a3 # a0 <- vAA (array object)
	dlsa a1, a1, rPC, 1 # a1 <- PC + BBBBbbbb*2 (array data off.)
	jal MterpFillArrayData # (obj, payload)
	beqzc v0, MterpPossibleException # exception?
	FETCH_ADVANCE_INST 3 # advance rPC, load rINST
	GET_INST_OPCODE v0 # extract opcode from rINST
	GOTO_OPCODE v0 # jump to next instruction

	%def op_filled_new_array(helper="MterpFilledNewArray"):
	/*
	* Create a new array with elements filled from registers.
	*
	* for: filled-new-array, filled-new-array/range
	*/
	/* op vB, {vD, vE, vF, vG, vA}, class//CCCC */
	/* op {vCCCC..v(CCCC+AA-1)}, type//BBBB */
	.extern $helper
	EXPORT_PC
	daddu a0, rFP, OFF_FP_SHADOWFRAME
	move a1, rPC
	move a2, rSELF
	jal $helper
	beqzc v0, MterpPossibleException
	FETCH_ADVANCE_INST 3 # advance rPC, load rINST
	GET_INST_OPCODE v0 # extract opcode from rINST
	GOTO_OPCODE v0 # jump to next instruction

	%def op_filled_new_array_range():
	% op_filled_new_array(helper="MterpFilledNewArrayRange")

	%def op_new_array():
	/*
	* Allocate an array of objects, specified with the array class
	* and a count.
	*
	* The verifier guarantees that this is an array class, so we don't
	* check for it here.
	*/
	/* new-array vA, vB, class//CCCC */
	.extern MterpNewArray
	EXPORT_PC
	daddu a0, rFP, OFF_FP_SHADOWFRAME
	move a1, rPC
	move a2, rINST
	move a3, rSELF
	jal MterpNewArray
	beqzc v0, MterpPossibleException
	FETCH_ADVANCE_INST 2 # advance rPC, load rINST
	GET_INST_OPCODE v0 # extract opcode from rINST
	GOTO_OPCODE v0 # jump to next instruction