blob: 88e1f0ed4b37af3ab37754e945e0185cc27d2b48 [file] [log] [blame]
%def bincmp(condition=""):
/*
* Generic two-operand compare-and-branch operation. Provide a "condition"
* fragment that specifies the comparison to perform.
*
* For: if-eq, if-ne, if-lt, if-ge, if-gt, if-le
*/
/* if-cmp vA, vB, +CCCC */
GET_OPA4(a0) # a0 <- A+
GET_OPB(a1) # a1 <- B
GET_VREG(a3, a1) # a3 <- vB
GET_VREG(a0, a0) # a0 <- vA
FETCH_S(rINST, 1) # rINST<- branch offset, in code units
b${condition} a0, a3, MterpCommonTakenBranchNoFlags # compare (vA, vB)
li t0, JIT_CHECK_OSR
beq rPROFILE, t0, .L_check_not_taken_osr
FETCH_ADVANCE_INST(2) # advance rPC, load rINST
GET_INST_OPCODE(t0) # extract opcode from rINST
GOTO_OPCODE(t0) # jump to next instruction
%def zcmp(condition=""):
/*
* Generic one-operand compare-and-branch operation. Provide a "condition"
* fragment that specifies the comparison to perform.
*
* for: if-eqz, if-nez, if-ltz, if-gez, if-gtz, if-lez
*/
/* if-cmp vAA, +BBBB */
GET_OPA(a0) # a0 <- AA
GET_VREG(a0, a0) # a0 <- vAA
FETCH_S(rINST, 1) # rINST <- branch offset, in code units
b${condition} a0, zero, MterpCommonTakenBranchNoFlags
li t0, JIT_CHECK_OSR # possible OSR re-entry?
beq rPROFILE, t0, .L_check_not_taken_osr
FETCH_ADVANCE_INST(2) # advance rPC, load rINST
GET_INST_OPCODE(t0) # extract opcode from rINST
GOTO_OPCODE(t0) # jump to next instruction
%def op_goto():
/*
* Unconditional branch, 8-bit offset.
*
* The branch distance is a signed code-unit offset, which we need to
* double to get a byte offset.
*/
/* goto +AA */
sll a0, rINST, 16 # a0 <- AAxx0000
sra rINST, a0, 24 # rINST <- ssssssAA (sign-extended)
b MterpCommonTakenBranchNoFlags
%def op_goto_16():
/*
* Unconditional branch, 16-bit offset.
*
* The branch distance is a signed code-unit offset, which we need to
* double to get a byte offset.
*/
/* goto/16 +AAAA */
FETCH_S(rINST, 1) # rINST <- ssssAAAA (sign-extended)
b MterpCommonTakenBranchNoFlags
%def op_goto_32():
/*
* Unconditional branch, 32-bit offset.
*
* The branch distance is a signed code-unit offset, which we need to
* double to get a byte offset.
*
* Unlike most opcodes, this one is allowed to branch to itself, so
* our "backward branch" test must be "<=0" instead of "<0".
*/
/* goto/32 +AAAAAAAA */
FETCH(rINST, 1) # rINST <- aaaa (lo)
FETCH(a1, 2) # a1 <- AAAA (hi)
INSERT_HIGH_HALF(rINST, a1) # rINST <- AAAAaaaa
b MterpCommonTakenBranchNoFlags
%def op_if_eq():
% bincmp(condition="eq")
%def op_if_eqz():
% zcmp(condition="eq")
%def op_if_ge():
% bincmp(condition="ge")
%def op_if_gez():
% zcmp(condition="ge")
%def op_if_gt():
% bincmp(condition="gt")
%def op_if_gtz():
% zcmp(condition="gt")
%def op_if_le():
% bincmp(condition="le")
%def op_if_lez():
% zcmp(condition="le")
%def op_if_lt():
% bincmp(condition="lt")
%def op_if_ltz():
% zcmp(condition="lt")
%def op_if_ne():
% bincmp(condition="ne")
%def op_if_nez():
% zcmp(condition="ne")
%def op_packed_switch(func="MterpDoPackedSwitch"):
/*
* Handle a packed-switch or sparse-switch instruction. In both cases
* we decode it and hand it off to a helper function.
*
* We don't really expect backward branches in a switch statement, but
* they're perfectly legal, so we check for them here.
*
* for: packed-switch, sparse-switch
*/
/* op vAA, +BBBB */
FETCH(a0, 1) # a0 <- bbbb (lo)
FETCH(a1, 2) # a1 <- BBBB (hi)
GET_OPA(a3) # a3 <- AA
INSERT_HIGH_HALF(a0, a1) # a0 <- BBBBbbbb
GET_VREG(a1, a3) # a1 <- vAA
EAS1(a0, rPC, a0) # a0 <- PC + BBBBbbbb*2
JAL($func) # a0 <- code-unit branch offset
move rINST, v0
b MterpCommonTakenBranchNoFlags
%def op_return():
/*
* Return a 32-bit value.
*
* for: return, return-object
*/
/* op vAA */
.extern MterpThreadFenceForConstructor
JAL(MterpThreadFenceForConstructor)
lw ra, THREAD_FLAGS_OFFSET(rSELF)
move a0, rSELF
and ra, THREAD_SUSPEND_OR_CHECKPOINT_REQUEST
beqz ra, 1f
JAL(MterpSuspendCheck) # (self)
1:
GET_OPA(a2) # a2 <- AA
GET_VREG(v0, a2) # v0 <- vAA
move v1, zero
b MterpReturn
%def op_return_object():
% op_return()
%def op_return_void():
.extern MterpThreadFenceForConstructor
JAL(MterpThreadFenceForConstructor)
lw ra, THREAD_FLAGS_OFFSET(rSELF)
move a0, rSELF
and ra, THREAD_SUSPEND_OR_CHECKPOINT_REQUEST
beqz ra, 1f
JAL(MterpSuspendCheck) # (self)
1:
move v0, zero
move v1, zero
b MterpReturn
%def op_return_void_no_barrier():
lw ra, THREAD_FLAGS_OFFSET(rSELF)
move a0, rSELF
and ra, THREAD_SUSPEND_OR_CHECKPOINT_REQUEST
beqz ra, 1f
JAL(MterpSuspendCheck) # (self)
1:
move v0, zero
move v1, zero
b MterpReturn
%def op_return_wide():
/*
* Return a 64-bit value.
*/
/* return-wide vAA */
.extern MterpThreadFenceForConstructor
JAL(MterpThreadFenceForConstructor)
lw ra, THREAD_FLAGS_OFFSET(rSELF)
move a0, rSELF
and ra, THREAD_SUSPEND_OR_CHECKPOINT_REQUEST
beqz ra, 1f
JAL(MterpSuspendCheck) # (self)
1:
GET_OPA(a2) # a2 <- AA
EAS2(a2, rFP, a2) # a2 <- &fp[AA]
LOAD64(v0, v1, a2) # v0/v1 <- vAA/vAA+1
b MterpReturn
%def op_sparse_switch():
% op_packed_switch(func="MterpDoSparseSwitch")
%def op_throw():
/*
* Throw an exception object in the current thread.
*/
/* throw vAA */
EXPORT_PC() # exception handler can throw
GET_OPA(a2) # a2 <- AA
GET_VREG(a1, a2) # a1 <- vAA (exception object)
# null object?
beqz a1, common_errNullObject # yes, throw an NPE instead
sw a1, THREAD_EXCEPTION_OFFSET(rSELF) # thread->exception <- obj
b MterpException