runtime/interpreter/mterp/arm/array.S - SHIFTPHONES/android_art - Gitiles

 %def op_aget(load="ldr", shift="2", data_offset="MIRROR_INT_ARRAY_DATA_OFFSET"):
     /*
      * Array get, 32 bits or less.  vAA <- vBB[vCC].
      *
      * Note: using the usual FETCH/and/shift stuff, this fits in exactly 17
      * instructions.  We use a pair of FETCH_Bs instead.
      *
      * 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 */
     FETCH_B r2, 1, 0                    @ r2<- BB
     mov     r9, rINST, lsr #8           @ r9<- AA
     FETCH_B r3, 1, 1                    @ r3<- CC
     GET_VREG r0, r2                     @ r0<- vBB (array object)
     GET_VREG r1, r3                     @ r1<- vCC (requested index)
     cmp     r0, #0                      @ null array object?
     beq     common_errNullObject        @ yes, bail
     ldr     r3, [r0, #MIRROR_ARRAY_LENGTH_OFFSET]    @ r3<- arrayObj->length
     add     r0, r0, r1, lsl #$shift     @ r0<- arrayObj + index*width
     cmp     r1, r3                      @ compare unsigned index, length
     bcs     common_errArrayIndex        @ index >= length, bail
     FETCH_ADVANCE_INST 2                @ advance rPC, load rINST
     $load   r2, [r0, #$data_offset]     @ r2<- vBB[vCC]
     GET_INST_OPCODE ip                  @ extract opcode from rINST
     SET_VREG r2, r9                     @ vAA<- r2
     GOTO_OPCODE ip                      @ jump to next instruction

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

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

 %def op_aget_char():
 %  op_aget(load="ldrh", 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 */
     FETCH_B r2, 1, 0                    @ r2<- BB
     mov     r9, rINST, lsr #8           @ r9<- AA
     FETCH_B r3, 1, 1                    @ r3<- CC
     EXPORT_PC
     GET_VREG r0, r2                     @ r0<- vBB (array object)
     GET_VREG r1, r3                     @ r1<- vCC (requested index)
     bl       artAGetObjectFromMterp     @ (array, index)
     ldr      r1, [rSELF, #THREAD_EXCEPTION_OFFSET]
     PREFETCH_INST 2
     cmp      r1, #0
     bne      MterpException
     SET_VREG_OBJECT r0, r9
     ADVANCE 2
     GET_INST_OPCODE ip
     GOTO_OPCODE ip                      @ jump to next instruction

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

 %def op_aget_wide():
     /*
      * Array get, 64 bits.  vAA <- vBB[vCC].
      *
      * Arrays of long/double are 64-bit aligned, so it's okay to use LDRD.
      */
     /* aget-wide vAA, vBB, vCC */
     FETCH r0, 1                         @ r0<- CCBB
     mov     r9, rINST, lsr #8           @ r9<- AA
     and     r2, r0, #255                @ r2<- BB
     mov     r3, r0, lsr #8              @ r3<- CC
     GET_VREG r0, r2                     @ r0<- vBB (array object)
     GET_VREG r1, r3                     @ r1<- vCC (requested index)
     cmp     r0, #0                      @ null array object?
     beq     common_errNullObject        @ yes, bail
     ldr     r3, [r0, #MIRROR_ARRAY_LENGTH_OFFSET]    @ r3<- arrayObj->length
     add     r0, r0, r1, lsl #3          @ r0<- arrayObj + index*width
     cmp     r1, r3                      @ compare unsigned index, length
     bcs     common_errArrayIndex        @ index >= length, bail
     FETCH_ADVANCE_INST 2                @ advance rPC, load rINST
     CLEAR_SHADOW_PAIR r9, lr, ip        @ Zero out the shadow regs
     ldrd    r2, [r0, #MIRROR_WIDE_ARRAY_DATA_OFFSET]  @ r2/r3<- vBB[vCC]
     VREG_INDEX_TO_ADDR r9, r9           @ r9<- &fp[AA]
     GET_INST_OPCODE ip                  @ extract opcode from rINST
     SET_VREG_WIDE_BY_ADDR r2, r3, r9    @ vAA/vAA+1<- r2/r3
     GOTO_OPCODE ip                      @ jump to next instruction

 %def op_aput(store="str", shift="2", data_offset="MIRROR_INT_ARRAY_DATA_OFFSET"):
     /*
      * Array put, 32 bits or less.  vBB[vCC] <- vAA.
      *
      * Note: using the usual FETCH/and/shift stuff, this fits in exactly 17
      * instructions.  We use a pair of FETCH_Bs instead.
      *
      * 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 */
     FETCH_B r2, 1, 0                    @ r2<- BB
     mov     r9, rINST, lsr #8           @ r9<- AA
     FETCH_B r3, 1, 1                    @ r3<- CC
     GET_VREG r0, r2                     @ r0<- vBB (array object)
     GET_VREG r1, r3                     @ r1<- vCC (requested index)
     cmp     r0, #0                      @ null array object?
     beq     common_errNullObject        @ yes, bail
     ldr     r3, [r0, #MIRROR_ARRAY_LENGTH_OFFSET]     @ r3<- arrayObj->length
     add     r0, r0, r1, lsl #$shift     @ r0<- arrayObj + index*width
     cmp     r1, r3                      @ compare unsigned index, length
     bcs     common_errArrayIndex        @ index >= length, bail
     FETCH_ADVANCE_INST 2                @ advance rPC, load rINST
     GET_VREG r2, r9                     @ r2<- vAA
     GET_INST_OPCODE ip                  @ extract opcode from rINST
     $store  r2, [r0, #$data_offset]     @ vBB[vCC]<- r2
     GOTO_OPCODE ip                      @ jump to next instruction

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

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

 %def op_aput_char():
 %  op_aput(store="strh", 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 */
     EXPORT_PC
     add     r0, rFP, #OFF_FP_SHADOWFRAME
     mov     r1, rPC
     mov     r2, rINST
     bl      MterpAputObject
     cmp     r0, #0
     beq     MterpPossibleException
     FETCH_ADVANCE_INST 2                @ advance rPC, load rINST
     GET_INST_OPCODE ip                  @ extract opcode from rINST
     GOTO_OPCODE ip                      @ jump to next instruction

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

 %def op_aput_wide():
     /*
      * Array put, 64 bits.  vBB[vCC] <- vAA.
      *
      * Arrays of long/double are 64-bit aligned, so it's okay to use STRD.
      */
     /* aput-wide vAA, vBB, vCC */
     FETCH r0, 1                         @ r0<- CCBB
     mov     r9, rINST, lsr #8           @ r9<- AA
     and     r2, r0, #255                @ r2<- BB
     mov     r3, r0, lsr #8              @ r3<- CC
     GET_VREG r0, r2                     @ r0<- vBB (array object)
     GET_VREG r1, r3                     @ r1<- vCC (requested index)
     cmp     r0, #0                      @ null array object?
     beq     common_errNullObject        @ yes, bail
     ldr     r3, [r0, #MIRROR_ARRAY_LENGTH_OFFSET]    @ r3<- arrayObj->length
     add     r0, r0, r1, lsl #3          @ r0<- arrayObj + index*width
     cmp     r1, r3                      @ compare unsigned index, length
     VREG_INDEX_TO_ADDR r9, r9           @ r9<- &fp[AA]
     bcs     common_errArrayIndex        @ index >= length, bail
     FETCH_ADVANCE_INST 2                @ advance rPC, load rINST
     GET_VREG_WIDE_BY_ADDR r2, r3, r9    @ r2/r3<- vAA/vAA+1
     GET_INST_OPCODE ip                  @ extract opcode from rINST
     strd    r2, [r0, #MIRROR_WIDE_ARRAY_DATA_OFFSET]  @ r2/r3<- vBB[vCC]
     GOTO_OPCODE ip                      @ jump to next instruction

 %def op_array_length():
     /*
      * Return the length of an array.
      */
     mov     r1, rINST, lsr #12          @ r1<- B
     ubfx    r2, rINST, #8, #4           @ r2<- A
     GET_VREG r0, r1                     @ r0<- vB (object ref)
     cmp     r0, #0                      @ is object null?
     beq     common_errNullObject        @ yup, fail
     FETCH_ADVANCE_INST 1                @ advance rPC, load rINST
     ldr     r3, [r0, #MIRROR_ARRAY_LENGTH_OFFSET]    @ r3<- array length
     GET_INST_OPCODE ip                  @ extract opcode from rINST
     SET_VREG r3, r2                     @ vB<- length
     GOTO_OPCODE ip                      @ jump to next instruction

 %def op_fill_array_data():
     /* fill-array-data vAA, +BBBBBBBB */
     EXPORT_PC
     FETCH r0, 1                         @ r0<- bbbb (lo)
     FETCH r1, 2                         @ r1<- BBBB (hi)
     mov     r3, rINST, lsr #8           @ r3<- AA
     orr     r1, r0, r1, lsl #16         @ r1<- BBBBbbbb
     GET_VREG r0, r3                     @ r0<- vAA (array object)
     add     r1, rPC, r1, lsl #1         @ r1<- PC + BBBBbbbb*2 (array data off.)
     bl      MterpFillArrayData          @ (obj, payload)
     cmp     r0, #0                      @ 0 means an exception is thrown
     beq     MterpPossibleException      @ exception?
     FETCH_ADVANCE_INST 3                @ advance rPC, load rINST
     GET_INST_OPCODE ip                  @ extract opcode from rINST
     GOTO_OPCODE ip                      @ 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
     add     r0, rFP, #OFF_FP_SHADOWFRAME
     mov     r1, rPC
     mov     r2, rSELF
     bl      $helper
     cmp     r0, #0
     beq     MterpPossibleException
     FETCH_ADVANCE_INST 3                @ advance rPC, load rINST
     GET_INST_OPCODE ip                  @ extract opcode from rINST
     GOTO_OPCODE ip                      @ 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 */
     EXPORT_PC
     add     r0, rFP, #OFF_FP_SHADOWFRAME
     mov     r1, rPC
     mov     r2, rINST
     mov     r3, rSELF
     bl      MterpNewArray
     cmp     r0, #0
     beq     MterpPossibleException
     FETCH_ADVANCE_INST 2                @ advance rPC, load rINST
     GET_INST_OPCODE ip                  @ extract opcode from rINST
     GOTO_OPCODE ip                      @ jump to next instruction
	%def op_aget(load="ldr", shift="2", data_offset="MIRROR_INT_ARRAY_DATA_OFFSET"):
	/*
	* Array get, 32 bits or less. vAA <- vBB[vCC].
	*
	* Note: using the usual FETCH/and/shift stuff, this fits in exactly 17
	* instructions. We use a pair of FETCH_Bs instead.
	*
	* 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 */
	FETCH_B r2, 1, 0 @ r2<- BB
	mov r9, rINST, lsr #8 @ r9<- AA
	FETCH_B r3, 1, 1 @ r3<- CC
	GET_VREG r0, r2 @ r0<- vBB (array object)
	GET_VREG r1, r3 @ r1<- vCC (requested index)
	cmp r0, #0 @ null array object?
	beq common_errNullObject @ yes, bail
	ldr r3, [r0, #MIRROR_ARRAY_LENGTH_OFFSET] @ r3<- arrayObj->length
	add r0, r0, r1, lsl #$shift @ r0<- arrayObj + index*width
	cmp r1, r3 @ compare unsigned index, length
	bcs common_errArrayIndex @ index >= length, bail
	FETCH_ADVANCE_INST 2 @ advance rPC, load rINST
	$load r2, [r0, #$data_offset] @ r2<- vBB[vCC]
	GET_INST_OPCODE ip @ extract opcode from rINST
	SET_VREG r2, r9 @ vAA<- r2
	GOTO_OPCODE ip @ jump to next instruction

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

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

	%def op_aget_char():
	% op_aget(load="ldrh", 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 */
	FETCH_B r2, 1, 0 @ r2<- BB
	mov r9, rINST, lsr #8 @ r9<- AA
	FETCH_B r3, 1, 1 @ r3<- CC
	EXPORT_PC
	GET_VREG r0, r2 @ r0<- vBB (array object)
	GET_VREG r1, r3 @ r1<- vCC (requested index)
	bl artAGetObjectFromMterp @ (array, index)
	ldr r1, [rSELF, #THREAD_EXCEPTION_OFFSET]
	PREFETCH_INST 2
	cmp r1, #0
	bne MterpException
	SET_VREG_OBJECT r0, r9
	ADVANCE 2
	GET_INST_OPCODE ip
	GOTO_OPCODE ip @ jump to next instruction

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

	%def op_aget_wide():
	/*
	* Array get, 64 bits. vAA <- vBB[vCC].
	*
	* Arrays of long/double are 64-bit aligned, so it's okay to use LDRD.
	*/
	/* aget-wide vAA, vBB, vCC */
	FETCH r0, 1 @ r0<- CCBB
	mov r9, rINST, lsr #8 @ r9<- AA
	and r2, r0, #255 @ r2<- BB
	mov r3, r0, lsr #8 @ r3<- CC
	GET_VREG r0, r2 @ r0<- vBB (array object)
	GET_VREG r1, r3 @ r1<- vCC (requested index)
	cmp r0, #0 @ null array object?
	beq common_errNullObject @ yes, bail
	ldr r3, [r0, #MIRROR_ARRAY_LENGTH_OFFSET] @ r3<- arrayObj->length
	add r0, r0, r1, lsl #3 @ r0<- arrayObj + index*width
	cmp r1, r3 @ compare unsigned index, length
	bcs common_errArrayIndex @ index >= length, bail
	FETCH_ADVANCE_INST 2 @ advance rPC, load rINST
	CLEAR_SHADOW_PAIR r9, lr, ip @ Zero out the shadow regs
	ldrd r2, [r0, #MIRROR_WIDE_ARRAY_DATA_OFFSET] @ r2/r3<- vBB[vCC]
	VREG_INDEX_TO_ADDR r9, r9 @ r9<- &fp[AA]
	GET_INST_OPCODE ip @ extract opcode from rINST
	SET_VREG_WIDE_BY_ADDR r2, r3, r9 @ vAA/vAA+1<- r2/r3
	GOTO_OPCODE ip @ jump to next instruction

	%def op_aput(store="str", shift="2", data_offset="MIRROR_INT_ARRAY_DATA_OFFSET"):
	/*
	* Array put, 32 bits or less. vBB[vCC] <- vAA.
	*
	* Note: using the usual FETCH/and/shift stuff, this fits in exactly 17
	* instructions. We use a pair of FETCH_Bs instead.
	*
	* 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 */
	FETCH_B r2, 1, 0 @ r2<- BB
	mov r9, rINST, lsr #8 @ r9<- AA
	FETCH_B r3, 1, 1 @ r3<- CC
	GET_VREG r0, r2 @ r0<- vBB (array object)
	GET_VREG r1, r3 @ r1<- vCC (requested index)
	cmp r0, #0 @ null array object?
	beq common_errNullObject @ yes, bail
	ldr r3, [r0, #MIRROR_ARRAY_LENGTH_OFFSET] @ r3<- arrayObj->length
	add r0, r0, r1, lsl #$shift @ r0<- arrayObj + index*width
	cmp r1, r3 @ compare unsigned index, length
	bcs common_errArrayIndex @ index >= length, bail
	FETCH_ADVANCE_INST 2 @ advance rPC, load rINST
	GET_VREG r2, r9 @ r2<- vAA
	GET_INST_OPCODE ip @ extract opcode from rINST
	$store r2, [r0, #$data_offset] @ vBB[vCC]<- r2
	GOTO_OPCODE ip @ jump to next instruction

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

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

	%def op_aput_char():
	% op_aput(store="strh", 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 */
	EXPORT_PC
	add r0, rFP, #OFF_FP_SHADOWFRAME
	mov r1, rPC
	mov r2, rINST
	bl MterpAputObject
	cmp r0, #0
	beq MterpPossibleException
	FETCH_ADVANCE_INST 2 @ advance rPC, load rINST
	GET_INST_OPCODE ip @ extract opcode from rINST
	GOTO_OPCODE ip @ jump to next instruction

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

	%def op_aput_wide():
	/*
	* Array put, 64 bits. vBB[vCC] <- vAA.
	*
	* Arrays of long/double are 64-bit aligned, so it's okay to use STRD.
	*/
	/* aput-wide vAA, vBB, vCC */
	FETCH r0, 1 @ r0<- CCBB
	mov r9, rINST, lsr #8 @ r9<- AA
	and r2, r0, #255 @ r2<- BB
	mov r3, r0, lsr #8 @ r3<- CC
	GET_VREG r0, r2 @ r0<- vBB (array object)
	GET_VREG r1, r3 @ r1<- vCC (requested index)
	cmp r0, #0 @ null array object?
	beq common_errNullObject @ yes, bail
	ldr r3, [r0, #MIRROR_ARRAY_LENGTH_OFFSET] @ r3<- arrayObj->length
	add r0, r0, r1, lsl #3 @ r0<- arrayObj + index*width
	cmp r1, r3 @ compare unsigned index, length
	VREG_INDEX_TO_ADDR r9, r9 @ r9<- &fp[AA]
	bcs common_errArrayIndex @ index >= length, bail
	FETCH_ADVANCE_INST 2 @ advance rPC, load rINST
	GET_VREG_WIDE_BY_ADDR r2, r3, r9 @ r2/r3<- vAA/vAA+1
	GET_INST_OPCODE ip @ extract opcode from rINST
	strd r2, [r0, #MIRROR_WIDE_ARRAY_DATA_OFFSET] @ r2/r3<- vBB[vCC]
	GOTO_OPCODE ip @ jump to next instruction

	%def op_array_length():
	/*
	* Return the length of an array.
	*/
	mov r1, rINST, lsr #12 @ r1<- B
	ubfx r2, rINST, #8, #4 @ r2<- A
	GET_VREG r0, r1 @ r0<- vB (object ref)
	cmp r0, #0 @ is object null?
	beq common_errNullObject @ yup, fail
	FETCH_ADVANCE_INST 1 @ advance rPC, load rINST
	ldr r3, [r0, #MIRROR_ARRAY_LENGTH_OFFSET] @ r3<- array length
	GET_INST_OPCODE ip @ extract opcode from rINST
	SET_VREG r3, r2 @ vB<- length
	GOTO_OPCODE ip @ jump to next instruction

	%def op_fill_array_data():
	/* fill-array-data vAA, +BBBBBBBB */
	EXPORT_PC
	FETCH r0, 1 @ r0<- bbbb (lo)
	FETCH r1, 2 @ r1<- BBBB (hi)
	mov r3, rINST, lsr #8 @ r3<- AA
	orr r1, r0, r1, lsl #16 @ r1<- BBBBbbbb
	GET_VREG r0, r3 @ r0<- vAA (array object)
	add r1, rPC, r1, lsl #1 @ r1<- PC + BBBBbbbb*2 (array data off.)
	bl MterpFillArrayData @ (obj, payload)
	cmp r0, #0 @ 0 means an exception is thrown
	beq MterpPossibleException @ exception?
	FETCH_ADVANCE_INST 3 @ advance rPC, load rINST
	GET_INST_OPCODE ip @ extract opcode from rINST
	GOTO_OPCODE ip @ 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
	add r0, rFP, #OFF_FP_SHADOWFRAME
	mov r1, rPC
	mov r2, rSELF
	bl $helper
	cmp r0, #0
	beq MterpPossibleException
	FETCH_ADVANCE_INST 3 @ advance rPC, load rINST
	GET_INST_OPCODE ip @ extract opcode from rINST
	GOTO_OPCODE ip @ 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 */
	EXPORT_PC
	add r0, rFP, #OFF_FP_SHADOWFRAME
	mov r1, rPC
	mov r2, rINST
	mov r3, rSELF
	bl MterpNewArray
	cmp r0, #0
	beq MterpPossibleException
	FETCH_ADVANCE_INST 2 @ advance rPC, load rINST
	GET_INST_OPCODE ip @ extract opcode from rINST
	GOTO_OPCODE ip @ jump to next instruction