*/
#include "asm_support.h"
+/*
+ * Handle mac compiler specific
+ */
+#if defined(__APPLE__)
+ #define MACRO_LITERAL(value) $(value)
+ #define FUNCTION_TYPE(name)
+ #define SIZE(start,end)
+ // Mac OS' symbols have an _ prefix.
+ #define SYMBOL(name) _ ## name
+#else
+ #define MACRO_LITERAL(value) $value
+ #define FUNCTION_TYPE(name) .type name, @function
+ #define SIZE(start,end) .size start, .-end
+ #define SYMBOL(name) name
+#endif
+
/* Frame size must be 16-byte aligned.
* Remember about 4 bytes for return address
*/
*/
.macro REFRESH_INST _opnum
movb rINSTbl, rINSTbh
- movb $\_opnum, rINSTbl
+ movb MACRO_LITERAL(\_opnum), rINSTbl
.endm
/*
.macro GOTO_NEXT
movzx rINSTbl,%eax
movzbl rINSTbh,rINST
- shll $7, %eax
+ shll MACRO_LITERAL(7), %eax
addl rIBASE, %eax
jmp *%eax
.endm
.macro SET_VREG _reg _vreg
movl \_reg, (rFP,\_vreg,4)
- movl $0, (rREFS,\_vreg,4)
+ movl MACRO_LITERAL(0), (rREFS,\_vreg,4)
.endm
/* Write wide value from xmm. xmm is clobbered. */
.macro SET_VREG_HIGH _reg _vreg
movl \_reg, 4(rFP,\_vreg,4)
- movl $0, 4(rREFS,\_vreg,4)
+ movl MACRO_LITERAL(0), 4(rREFS,\_vreg,4)
.endm
.macro CLEAR_REF _vreg
- movl $0, (rREFS,\_vreg,4)
+ movl MACRO_LITERAL(0), (rREFS,\_vreg,4)
.endm
.macro CLEAR_WIDE_REF _vreg
- movl $0, (rREFS,\_vreg,4)
- movl $0, 4(rREFS,\_vreg,4)
+ movl MACRO_LITERAL(0), (rREFS,\_vreg,4)
+ movl MACRO_LITERAL(0), 4(rREFS,\_vreg,4)
.endm
/* File: x86/entry.S */
*/
.text
- .global ExecuteMterpImpl
- .type ExecuteMterpImpl, %function
+ .global SYMBOL(ExecuteMterpImpl)
+ FUNCTION_TYPE(ExecuteMterpImpl)
/*
* On entry:
*
*/
-ExecuteMterpImpl:
+SYMBOL(ExecuteMterpImpl):
.cfi_startproc
/* Allocate frame */
subl $FRAME_SIZE, %esp
/* NOTE: no fallthrough */
- .global artMterpAsmInstructionStart
- .type artMterpAsmInstructionStart, %function
-artMterpAsmInstructionStart = .L_op_nop
+ .global SYMBOL(artMterpAsmInstructionStart)
+ FUNCTION_TYPE(SYMBOL(artMterpAsmInstructionStart))
+SYMBOL(artMterpAsmInstructionStart) = .L_op_nop
.text
/* ------------------------------ */
movzbl rINSTbl, %eax # eax <- BA
andb $0xf, %al # eax <- A
shrl $4, rINST # rINST <- B
- GET_VREG rINST rINST
+ GET_VREG rINST, rINST
.if 0
- SET_VREG_OBJECT rINST %eax # fp[A] <- fp[B]
+ SET_VREG_OBJECT rINST, %eax # fp[A] <- fp[B]
.else
- SET_VREG rINST %eax # fp[A] <- fp[B]
+ SET_VREG rINST, %eax # fp[A] <- fp[B]
.endif
ADVANCE_PC_FETCH_AND_GOTO_NEXT 1
/* op vAA, vBBBB */
movzx rINSTbl, %eax # eax <- AA
movw 2(rPC), rINSTw # rINSTw <- BBBB
- GET_VREG rINST rINST # rINST <- fp[BBBB]
+ GET_VREG rINST, rINST # rINST <- fp[BBBB]
.if 0
- SET_VREG_OBJECT rINST %eax # fp[A] <- fp[B]
+ SET_VREG_OBJECT rINST, %eax # fp[A] <- fp[B]
.else
- SET_VREG rINST %eax # fp[A] <- fp[B]
+ SET_VREG rINST, %eax # fp[A] <- fp[B]
.endif
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* op vAAAA, vBBBB */
movzwl 4(rPC), %ecx # ecx <- BBBB
movzwl 2(rPC), %eax # eax <- AAAA
- GET_VREG rINST %ecx
+ GET_VREG rINST, %ecx
.if 0
- SET_VREG_OBJECT rINST %eax # fp[A] <- fp[B]
+ SET_VREG_OBJECT rINST, %eax # fp[A] <- fp[B]
.else
- SET_VREG rINST %eax # fp[A] <- fp[B]
+ SET_VREG rINST, %eax # fp[A] <- fp[B]
.endif
ADVANCE_PC_FETCH_AND_GOTO_NEXT 3
movzbl rINSTbl, %ecx # ecx <- BA
sarl $4, rINST # rINST <- B
andb $0xf, %cl # ecx <- A
- GET_WIDE_FP_VREG %xmm0 rINST # xmm0 <- v[B]
- SET_WIDE_FP_VREG %xmm0 %ecx # v[A] <- xmm0
+ GET_WIDE_FP_VREG %xmm0, rINST # xmm0 <- v[B]
+ SET_WIDE_FP_VREG %xmm0, %ecx # v[A] <- xmm0
ADVANCE_PC_FETCH_AND_GOTO_NEXT 1
/* ------------------------------ */
/* NOTE: regs can overlap, e.g. "move v6,v7" or "move v7,v6" */
movzwl 2(rPC), %ecx # ecx <- BBBB
movzbl rINSTbl, %eax # eax <- AAAA
- GET_WIDE_FP_VREG %xmm0 %ecx # xmm0 <- v[B]
- SET_WIDE_FP_VREG %xmm0 %eax # v[A] <- xmm0
+ GET_WIDE_FP_VREG %xmm0, %ecx # xmm0 <- v[B]
+ SET_WIDE_FP_VREG %xmm0, %eax # v[A] <- xmm0
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* ------------------------------ */
/* NOTE: regs can overlap, e.g. "move v6,v7" or "move v7,v6" */
movzwl 4(rPC), %ecx # ecx<- BBBB
movzwl 2(rPC), %eax # eax<- AAAA
- GET_WIDE_FP_VREG %xmm0 %ecx # xmm0 <- v[B]
- SET_WIDE_FP_VREG %xmm0 %eax # v[A] <- xmm0
+ GET_WIDE_FP_VREG %xmm0, %ecx # xmm0 <- v[B]
+ SET_WIDE_FP_VREG %xmm0, %eax # v[A] <- xmm0
ADVANCE_PC_FETCH_AND_GOTO_NEXT 3
/* ------------------------------ */
movzbl rINSTbl, %eax # eax <- BA
andb $0xf, %al # eax <- A
shrl $4, rINST # rINST <- B
- GET_VREG rINST rINST
+ GET_VREG rINST, rINST
.if 1
- SET_VREG_OBJECT rINST %eax # fp[A] <- fp[B]
+ SET_VREG_OBJECT rINST, %eax # fp[A] <- fp[B]
.else
- SET_VREG rINST %eax # fp[A] <- fp[B]
+ SET_VREG rINST, %eax # fp[A] <- fp[B]
.endif
ADVANCE_PC_FETCH_AND_GOTO_NEXT 1
/* op vAA, vBBBB */
movzx rINSTbl, %eax # eax <- AA
movw 2(rPC), rINSTw # rINSTw <- BBBB
- GET_VREG rINST rINST # rINST <- fp[BBBB]
+ GET_VREG rINST, rINST # rINST <- fp[BBBB]
.if 1
- SET_VREG_OBJECT rINST %eax # fp[A] <- fp[B]
+ SET_VREG_OBJECT rINST, %eax # fp[A] <- fp[B]
.else
- SET_VREG rINST %eax # fp[A] <- fp[B]
+ SET_VREG rINST, %eax # fp[A] <- fp[B]
.endif
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* op vAAAA, vBBBB */
movzwl 4(rPC), %ecx # ecx <- BBBB
movzwl 2(rPC), %eax # eax <- AAAA
- GET_VREG rINST %ecx
+ GET_VREG rINST, %ecx
.if 1
- SET_VREG_OBJECT rINST %eax # fp[A] <- fp[B]
+ SET_VREG_OBJECT rINST, %eax # fp[A] <- fp[B]
.else
- SET_VREG rINST %eax # fp[A] <- fp[B]
+ SET_VREG rINST, %eax # fp[A] <- fp[B]
.endif
ADVANCE_PC_FETCH_AND_GOTO_NEXT 3
movl OFF_FP_RESULT_REGISTER(rFP), %eax # get pointer to result JType.
movl (%eax), %eax # r0 <- result.i.
.if 0
- SET_VREG_OBJECT %eax rINST # fp[A] <- fp[B]
+ SET_VREG_OBJECT %eax, rINST # fp[A] <- fp[B]
.else
- SET_VREG %eax rINST # fp[A] <- fp[B]
+ SET_VREG %eax, rINST # fp[A] <- fp[B]
.endif
ADVANCE_PC_FETCH_AND_GOTO_NEXT 1
movl OFF_FP_RESULT_REGISTER(rFP), %eax # get pointer to result JType.
movl 4(%eax), %ecx # Get high
movl (%eax), %eax # Get low
- SET_VREG %eax rINST # v[AA+0] <- eax
- SET_VREG_HIGH %ecx rINST # v[AA+1] <- ecx
+ SET_VREG %eax, rINST # v[AA+0] <- eax
+ SET_VREG_HIGH %ecx, rINST # v[AA+1] <- ecx
ADVANCE_PC_FETCH_AND_GOTO_NEXT 1
/* ------------------------------ */
movl OFF_FP_RESULT_REGISTER(rFP), %eax # get pointer to result JType.
movl (%eax), %eax # r0 <- result.i.
.if 1
- SET_VREG_OBJECT %eax rINST # fp[A] <- fp[B]
+ SET_VREG_OBJECT %eax, rINST # fp[A] <- fp[B]
.else
- SET_VREG %eax rINST # fp[A] <- fp[B]
+ SET_VREG %eax, rINST # fp[A] <- fp[B]
.endif
ADVANCE_PC_FETCH_AND_GOTO_NEXT 1
/* move-exception vAA */
movl rSELF, %ecx
movl THREAD_EXCEPTION_OFFSET(%ecx), %eax
- SET_VREG_OBJECT %eax rINST # fp[AA] <- exception object
+ SET_VREG_OBJECT %eax, rINST # fp[AA] <- exception object
movl $0, THREAD_EXCEPTION_OFFSET(%ecx)
ADVANCE_PC_FETCH_AND_GOTO_NEXT 1
.L_op_return_void: /* 0x0e */
/* File: x86/op_return_void.S */
.extern MterpThreadFenceForConstructor
- call MterpThreadFenceForConstructor
+ call SYMBOL(MterpThreadFenceForConstructor)
movl rSELF, %eax
testl $(THREAD_SUSPEND_REQUEST | THREAD_CHECKPOINT_REQUEST), THREAD_FLAGS_OFFSET(%eax)
jz 1f
movl %eax, OUT_ARG0(%esp)
- call MterpSuspendCheck
+ call SYMBOL(MterpSuspendCheck)
1:
xorl %eax, %eax
xorl %ecx, %ecx
*/
/* op vAA */
.extern MterpThreadFenceForConstructor
- call MterpThreadFenceForConstructor
+ call SYMBOL(MterpThreadFenceForConstructor)
movl rSELF, %eax
testl $(THREAD_SUSPEND_REQUEST | THREAD_CHECKPOINT_REQUEST), THREAD_FLAGS_OFFSET(%eax)
jz 1f
movl %eax, OUT_ARG0(%esp)
- call MterpSuspendCheck
+ call SYMBOL(MterpSuspendCheck)
1:
- GET_VREG %eax rINST # eax <- vAA
+ GET_VREG %eax, rINST # eax <- vAA
xorl %ecx, %ecx
jmp MterpReturn
*/
/* return-wide vAA */
.extern MterpThreadFenceForConstructor
- call MterpThreadFenceForConstructor
+ call SYMBOL(MterpThreadFenceForConstructor)
movl rSELF, %eax
testl $(THREAD_SUSPEND_REQUEST | THREAD_CHECKPOINT_REQUEST), THREAD_FLAGS_OFFSET(%eax)
jz 1f
movl %eax, OUT_ARG0(%esp)
- call MterpSuspendCheck
+ call SYMBOL(MterpSuspendCheck)
1:
- GET_VREG %eax rINST # eax <- v[AA+0]
- GET_VREG_HIGH %ecx rINST # ecx <- v[AA+1]
+ GET_VREG %eax, rINST # eax <- v[AA+0]
+ GET_VREG_HIGH %ecx, rINST # ecx <- v[AA+1]
jmp MterpReturn
/* ------------------------------ */
*/
/* op vAA */
.extern MterpThreadFenceForConstructor
- call MterpThreadFenceForConstructor
+ call SYMBOL(MterpThreadFenceForConstructor)
movl rSELF, %eax
testl $(THREAD_SUSPEND_REQUEST | THREAD_CHECKPOINT_REQUEST), THREAD_FLAGS_OFFSET(%eax)
jz 1f
movl %eax, OUT_ARG0(%esp)
- call MterpSuspendCheck
+ call SYMBOL(MterpSuspendCheck)
1:
- GET_VREG %eax rINST # eax <- vAA
+ GET_VREG %eax, rINST # eax <- vAA
xorl %ecx, %ecx
jmp MterpReturn
movl $0xf, rINST
andl %eax, rINST # rINST <- A
sarl $4, %eax
- SET_VREG %eax rINST
+ SET_VREG %eax, rINST
ADVANCE_PC_FETCH_AND_GOTO_NEXT 1
/* ------------------------------ */
/* File: x86/op_const_16.S */
/* const/16 vAA, #+BBBB */
movswl 2(rPC), %ecx # ecx <- ssssBBBB
- SET_VREG %ecx rINST # vAA <- ssssBBBB
+ SET_VREG %ecx, rINST # vAA <- ssssBBBB
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* ------------------------------ */
/* File: x86/op_const.S */
/* const vAA, #+BBBBbbbb */
movl 2(rPC), %eax # grab all 32 bits at once
- SET_VREG %eax rINST # vAA<- eax
+ SET_VREG %eax, rINST # vAA<- eax
ADVANCE_PC_FETCH_AND_GOTO_NEXT 3
/* ------------------------------ */
/* const/high16 vAA, #+BBBB0000 */
movzwl 2(rPC), %eax # eax <- 0000BBBB
sall $16, %eax # eax <- BBBB0000
- SET_VREG %eax rINST # vAA <- eax
+ SET_VREG %eax, rINST # vAA <- eax
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* ------------------------------ */
movswl 2(rPC), %eax # eax <- ssssBBBB
movl rIBASE, %ecx # preserve rIBASE (cltd trashes it)
cltd # rIBASE:eax <- ssssssssssssBBBB
- SET_VREG_HIGH rIBASE rINST # store msw
- SET_VREG %eax rINST # store lsw
+ SET_VREG_HIGH rIBASE, rINST # store msw
+ SET_VREG %eax, rINST # store lsw
movl %ecx, rIBASE # restore rIBASE
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
movl 2(rPC), %eax # eax <- BBBBbbbb
movl rIBASE, %ecx # preserve rIBASE (cltd trashes it)
cltd # rIBASE:eax <- ssssssssssssBBBB
- SET_VREG_HIGH rIBASE rINST # store msw
- SET_VREG %eax rINST # store lsw
+ SET_VREG_HIGH rIBASE, rINST # store msw
+ SET_VREG %eax, rINST # store lsw
movl %ecx, rIBASE # restore rIBASE
ADVANCE_PC_FETCH_AND_GOTO_NEXT 3
movl 2(rPC), %eax # eax <- lsw
movzbl rINSTbl, %ecx # ecx <- AA
movl 6(rPC), rINST # rINST <- msw
- SET_VREG %eax %ecx
- SET_VREG_HIGH rINST %ecx
+ SET_VREG %eax, %ecx
+ SET_VREG_HIGH rINST, %ecx
ADVANCE_PC_FETCH_AND_GOTO_NEXT 5
/* ------------------------------ */
/* const-wide/high16 vAA, #+BBBB000000000000 */
movzwl 2(rPC), %eax # eax <- 0000BBBB
sall $16, %eax # eax <- BBBB0000
- SET_VREG_HIGH %eax rINST # v[AA+1] <- eax
+ SET_VREG_HIGH %eax, rINST # v[AA+1] <- eax
xorl %eax, %eax
- SET_VREG %eax rINST # v[AA+0] <- eax
+ SET_VREG %eax, rINST # v[AA+0] <- eax
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* ------------------------------ */
movl %eax, OUT_ARG2(%esp)
movl rSELF, %eax
movl %eax, OUT_ARG3(%esp)
- call MterpConstString # (index, tgt_reg, shadow_frame, self)
+ call SYMBOL(MterpConstString) # (index, tgt_reg, shadow_frame, self)
REFRESH_IBASE
testl %eax, %eax
jnz MterpPossibleException
movl %eax, OUT_ARG2(%esp)
movl rSELF, %eax
movl %eax, OUT_ARG3(%esp)
- call MterpConstString # (index, tgt_reg, shadow_frame, self)
+ call SYMBOL(MterpConstString) # (index, tgt_reg, shadow_frame, self)
REFRESH_IBASE
testl %eax, %eax
jnz MterpPossibleException
movl %eax, OUT_ARG2(%esp)
movl rSELF, %eax
movl %eax, OUT_ARG3(%esp)
- call MterpConstClass # (index, tgt_reg, shadow_frame, self)
+ call SYMBOL(MterpConstClass) # (index, tgt_reg, shadow_frame, self)
REFRESH_IBASE
testl %eax, %eax
jnz MterpPossibleException
*/
/* monitor-enter vAA */
EXPORT_PC
- GET_VREG %ecx rINST
+ GET_VREG %ecx, rINST
movl %ecx, OUT_ARG0(%esp)
movl rSELF, %eax
movl %eax, OUT_ARG1(%esp)
- call artLockObjectFromCode # (object, self)
+ call SYMBOL(artLockObjectFromCode) # (object, self)
REFRESH_IBASE
testl %eax, %eax
jnz MterpException
*/
/* monitor-exit vAA */
EXPORT_PC
- GET_VREG %ecx rINST
+ GET_VREG %ecx, rINST
movl %ecx, OUT_ARG0(%esp)
movl rSELF, %eax
movl %eax, OUT_ARG1(%esp)
- call artUnlockObjectFromCode # (object, self)
+ call SYMBOL(artUnlockObjectFromCode) # (object, self)
REFRESH_IBASE
testl %eax, %eax
jnz MterpException
movl %eax, OUT_ARG2(%esp)
movl rSELF, %ecx
movl %ecx, OUT_ARG3(%esp)
- call MterpCheckCast # (index, &obj, method, self)
+ call SYMBOL(MterpCheckCast) # (index, &obj, method, self)
REFRESH_IBASE
testl %eax, %eax
jnz MterpPossibleException
movl %eax, OUT_ARG2(%esp)
movl rSELF, %ecx
movl %ecx, OUT_ARG3(%esp)
- call MterpInstanceOf # (index, &obj, method, self)
+ call SYMBOL(MterpInstanceOf) # (index, &obj, method, self)
movl rSELF, %ecx
REFRESH_IBASE_FROM_SELF %ecx
cmpl $0, THREAD_EXCEPTION_OFFSET(%ecx)
jnz MterpException
andb $0xf, rINSTbl # rINSTbl <- A
- SET_VREG %eax rINST
+ SET_VREG %eax, rINST
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* ------------------------------ */
*/
mov rINST, %eax # eax <- BA
sarl $4, rINST # rINST <- B
- GET_VREG %ecx rINST # ecx <- vB (object ref)
+ GET_VREG %ecx, rINST # ecx <- vB (object ref)
testl %ecx, %ecx # is null?
je common_errNullObject
andb $0xf, %al # eax <- A
movl MIRROR_ARRAY_LENGTH_OFFSET(%ecx), rINST
- SET_VREG rINST %eax
+ SET_VREG rINST, %eax
ADVANCE_PC_FETCH_AND_GOTO_NEXT 1
/* ------------------------------ */
movl %ecx, OUT_ARG1(%esp)
REFRESH_INST 34
movl rINST, OUT_ARG2(%esp)
- call MterpNewInstance
+ call SYMBOL(MterpNewInstance)
REFRESH_IBASE
testl %eax, %eax # 0 means an exception is thrown
jz MterpPossibleException
movl rINST, OUT_ARG2(%esp)
movl rSELF, %ecx
movl %ecx, OUT_ARG3(%esp)
- call MterpNewArray
+ call SYMBOL(MterpNewArray)
REFRESH_IBASE
testl %eax, %eax # 0 means an exception is thrown
jz MterpPossibleException
movl rPC, OUT_ARG1(%esp)
movl rSELF, %ecx
movl %ecx, OUT_ARG2(%esp)
- call MterpFilledNewArray
+ call SYMBOL(MterpFilledNewArray)
REFRESH_IBASE
testl %eax, %eax # 0 means an exception is thrown
jz MterpPossibleException
movl rPC, OUT_ARG1(%esp)
movl rSELF, %ecx
movl %ecx, OUT_ARG2(%esp)
- call MterpFilledNewArrayRange
+ call SYMBOL(MterpFilledNewArrayRange)
REFRESH_IBASE
testl %eax, %eax # 0 means an exception is thrown
jz MterpPossibleException
EXPORT_PC
movl 2(rPC), %ecx # ecx <- BBBBbbbb
leal (rPC,%ecx,2), %ecx # ecx <- PC + BBBBbbbb*2
- GET_VREG %eax rINST # eax <- vAA (array object)
+ GET_VREG %eax, rINST # eax <- vAA (array object)
movl %eax, OUT_ARG0(%esp)
movl %ecx, OUT_ARG1(%esp)
- call MterpFillArrayData # (obj, payload)
+ call SYMBOL(MterpFillArrayData) # (obj, payload)
REFRESH_IBASE
testl %eax, %eax # 0 means an exception is thrown
jz MterpPossibleException
*/
/* throw vAA */
EXPORT_PC
- GET_VREG %eax rINST # eax<- vAA (exception object)
+ GET_VREG %eax, rINST # eax<- vAA (exception object)
testl %eax, %eax
jz common_errNullObject
movl rSELF,%ecx
*/
/* op vAA, +BBBB */
movl 2(rPC), %ecx # ecx <- BBBBbbbb
- GET_VREG %eax rINST # eax <- vAA
+ GET_VREG %eax, rINST # eax <- vAA
leal (rPC,%ecx,2), %ecx # ecx <- PC + BBBBbbbb*2
movl %eax, OUT_ARG1(%esp) # ARG1 <- vAA
movl %ecx, OUT_ARG0(%esp) # ARG0 <- switchData
- call MterpDoPackedSwitch
+ call SYMBOL(MterpDoPackedSwitch)
addl %eax, %eax
leal (rPC, %eax), rPC
FETCH_INST
*/
/* op vAA, +BBBB */
movl 2(rPC), %ecx # ecx <- BBBBbbbb
- GET_VREG %eax rINST # eax <- vAA
+ GET_VREG %eax, rINST # eax <- vAA
leal (rPC,%ecx,2), %ecx # ecx <- PC + BBBBbbbb*2
movl %eax, OUT_ARG1(%esp) # ARG1 <- vAA
movl %ecx, OUT_ARG0(%esp) # ARG0 <- switchData
- call MterpDoSparseSwitch
+ call SYMBOL(MterpDoSparseSwitch)
addl %eax, %eax
leal (rPC, %eax), rPC
FETCH_INST
.Lop_cmpl_float_less:
decl %eax
.Lop_cmpl_float_finish:
- SET_VREG %eax rINST
+ SET_VREG %eax, rINST
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
.Lop_cmpg_float_less:
decl %eax
.Lop_cmpg_float_finish:
- SET_VREG %eax rINST
+ SET_VREG %eax, rINST
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
.Lop_cmpl_double_less:
decl %eax
.Lop_cmpl_double_finish:
- SET_VREG %eax rINST
+ SET_VREG %eax, rINST
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
.Lop_cmpg_double_less:
decl %eax
.Lop_cmpg_double_finish:
- SET_VREG %eax rINST
+ SET_VREG %eax, rINST
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* cmp-long vAA, vBB, vCC */
movzbl 2(rPC), %eax # eax <- BB
movzbl 3(rPC), %ecx # ecx <- CC
- GET_VREG_HIGH %eax %eax # eax <- v[BB+1], BB is clobbered
+ GET_VREG_HIGH %eax, %eax # eax <- v[BB+1], BB is clobbered
cmpl VREG_HIGH_ADDRESS(%ecx), %eax
jl .Lop_cmp_long_smaller
jg .Lop_cmp_long_bigger
movzbl 2(rPC), %eax # eax <- BB, restore BB
- GET_VREG %eax %eax # eax <- v[BB]
+ GET_VREG %eax, %eax # eax <- v[BB]
sub VREG_ADDRESS(%ecx), %eax
ja .Lop_cmp_long_bigger
jb .Lop_cmp_long_smaller
.Lop_cmp_long_finish:
- SET_VREG %eax rINST
+ SET_VREG %eax, rINST
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
.Lop_cmp_long_bigger:
/* if-cmp vA, vB, +CCCC */
movzx rINSTbl, %ecx # ecx <- A+
andb $0xf, %cl # ecx <- A
- GET_VREG %eax %ecx # eax <- vA
+ GET_VREG %eax, %ecx # eax <- vA
sarl $4, rINST # rINST <- B
cmpl VREG_ADDRESS(rINST), %eax # compare (vA, vB)
movl $2, %eax # assume not taken
/* if-cmp vA, vB, +CCCC */
movzx rINSTbl, %ecx # ecx <- A+
andb $0xf, %cl # ecx <- A
- GET_VREG %eax %ecx # eax <- vA
+ GET_VREG %eax, %ecx # eax <- vA
sarl $4, rINST # rINST <- B
cmpl VREG_ADDRESS(rINST), %eax # compare (vA, vB)
movl $2, %eax # assume not taken
/* if-cmp vA, vB, +CCCC */
movzx rINSTbl, %ecx # ecx <- A+
andb $0xf, %cl # ecx <- A
- GET_VREG %eax %ecx # eax <- vA
+ GET_VREG %eax, %ecx # eax <- vA
sarl $4, rINST # rINST <- B
cmpl VREG_ADDRESS(rINST), %eax # compare (vA, vB)
movl $2, %eax # assume not taken
/* if-cmp vA, vB, +CCCC */
movzx rINSTbl, %ecx # ecx <- A+
andb $0xf, %cl # ecx <- A
- GET_VREG %eax %ecx # eax <- vA
+ GET_VREG %eax, %ecx # eax <- vA
sarl $4, rINST # rINST <- B
cmpl VREG_ADDRESS(rINST), %eax # compare (vA, vB)
movl $2, %eax # assume not taken
/* if-cmp vA, vB, +CCCC */
movzx rINSTbl, %ecx # ecx <- A+
andb $0xf, %cl # ecx <- A
- GET_VREG %eax %ecx # eax <- vA
+ GET_VREG %eax, %ecx # eax <- vA
sarl $4, rINST # rINST <- B
cmpl VREG_ADDRESS(rINST), %eax # compare (vA, vB)
movl $2, %eax # assume not taken
/* if-cmp vA, vB, +CCCC */
movzx rINSTbl, %ecx # ecx <- A+
andb $0xf, %cl # ecx <- A
- GET_VREG %eax %ecx # eax <- vA
+ GET_VREG %eax, %ecx # eax <- vA
sarl $4, rINST # rINST <- B
cmpl VREG_ADDRESS(rINST), %eax # compare (vA, vB)
movl $2, %eax # assume not taken
/* op vAA, vBB, vCC */
movzbl 2(rPC), %eax # eax <- BB
movzbl 3(rPC), %ecx # ecx <- CC
- GET_VREG %eax %eax # eax <- vBB (array object)
- GET_VREG %ecx %ecx # ecx <- vCC (requested index)
+ GET_VREG %eax, %eax # eax <- vBB (array object)
+ GET_VREG %ecx, %ecx # ecx <- vCC (requested index)
testl %eax, %eax # null array object?
je common_errNullObject # bail if so
cmpl MIRROR_ARRAY_LENGTH_OFFSET(%eax), %ecx
jae common_errArrayIndex # index >= length, bail.
movl MIRROR_INT_ARRAY_DATA_OFFSET(%eax,%ecx,4), %eax
- SET_VREG %eax rINST
+ SET_VREG %eax, rINST
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* ------------------------------ */
/* aget-wide vAA, vBB, vCC */
movzbl 2(rPC), %eax # eax <- BB
movzbl 3(rPC), %ecx # ecx <- CC
- GET_VREG %eax %eax # eax <- vBB (array object)
- GET_VREG %ecx %ecx # ecx <- vCC (requested index)
+ GET_VREG %eax, %eax # eax <- vBB (array object)
+ GET_VREG %ecx, %ecx # ecx <- vCC (requested index)
testl %eax, %eax # null array object?
je common_errNullObject # bail if so
cmpl MIRROR_ARRAY_LENGTH_OFFSET(%eax), %ecx
jae common_errArrayIndex # index >= length, bail.
leal MIRROR_WIDE_ARRAY_DATA_OFFSET(%eax,%ecx,8), %eax
movq (%eax), %xmm0 # xmm0 <- vBB[vCC]
- SET_WIDE_FP_VREG %xmm0 rINST # vAA <- xmm0
+ SET_WIDE_FP_VREG %xmm0, rINST # vAA <- xmm0
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* ------------------------------ */
/* op vAA, vBB, vCC */
movzbl 2(rPC), %eax # eax <- BB
movzbl 3(rPC), %ecx # ecx <- CC
- GET_VREG %eax %eax # eax <- vBB (array object)
- GET_VREG %ecx %ecx # ecs <- vCC (requested index)
+ GET_VREG %eax, %eax # eax <- vBB (array object)
+ GET_VREG %ecx, %ecx # ecs <- vCC (requested index)
EXPORT_PC
movl %eax, OUT_ARG0(%esp)
movl %ecx, OUT_ARG1(%esp)
- call artAGetObjectFromMterp # (array, index)
+ call SYMBOL(artAGetObjectFromMterp) # (array, index)
movl rSELF, %ecx
REFRESH_IBASE_FROM_SELF %ecx
cmpl $0, THREAD_EXCEPTION_OFFSET(%ecx)
jnz MterpException
- SET_VREG_OBJECT %eax rINST
+ SET_VREG_OBJECT %eax, rINST
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* ------------------------------ */
/* op vAA, vBB, vCC */
movzbl 2(rPC), %eax # eax <- BB
movzbl 3(rPC), %ecx # ecx <- CC
- GET_VREG %eax %eax # eax <- vBB (array object)
- GET_VREG %ecx %ecx # ecx <- vCC (requested index)
+ GET_VREG %eax, %eax # eax <- vBB (array object)
+ GET_VREG %ecx, %ecx # ecx <- vCC (requested index)
testl %eax, %eax # null array object?
je common_errNullObject # bail if so
cmpl MIRROR_ARRAY_LENGTH_OFFSET(%eax), %ecx
jae common_errArrayIndex # index >= length, bail.
movzbl MIRROR_BOOLEAN_ARRAY_DATA_OFFSET(%eax,%ecx,1), %eax
- SET_VREG %eax rINST
+ SET_VREG %eax, rINST
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* op vAA, vBB, vCC */
movzbl 2(rPC), %eax # eax <- BB
movzbl 3(rPC), %ecx # ecx <- CC
- GET_VREG %eax %eax # eax <- vBB (array object)
- GET_VREG %ecx %ecx # ecx <- vCC (requested index)
+ GET_VREG %eax, %eax # eax <- vBB (array object)
+ GET_VREG %ecx, %ecx # ecx <- vCC (requested index)
testl %eax, %eax # null array object?
je common_errNullObject # bail if so
cmpl MIRROR_ARRAY_LENGTH_OFFSET(%eax), %ecx
jae common_errArrayIndex # index >= length, bail.
movsbl MIRROR_BYTE_ARRAY_DATA_OFFSET(%eax,%ecx,1), %eax
- SET_VREG %eax rINST
+ SET_VREG %eax, rINST
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* op vAA, vBB, vCC */
movzbl 2(rPC), %eax # eax <- BB
movzbl 3(rPC), %ecx # ecx <- CC
- GET_VREG %eax %eax # eax <- vBB (array object)
- GET_VREG %ecx %ecx # ecx <- vCC (requested index)
+ GET_VREG %eax, %eax # eax <- vBB (array object)
+ GET_VREG %ecx, %ecx # ecx <- vCC (requested index)
testl %eax, %eax # null array object?
je common_errNullObject # bail if so
cmpl MIRROR_ARRAY_LENGTH_OFFSET(%eax), %ecx
jae common_errArrayIndex # index >= length, bail.
movzwl MIRROR_CHAR_ARRAY_DATA_OFFSET(%eax,%ecx,2), %eax
- SET_VREG %eax rINST
+ SET_VREG %eax, rINST
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* op vAA, vBB, vCC */
movzbl 2(rPC), %eax # eax <- BB
movzbl 3(rPC), %ecx # ecx <- CC
- GET_VREG %eax %eax # eax <- vBB (array object)
- GET_VREG %ecx %ecx # ecx <- vCC (requested index)
+ GET_VREG %eax, %eax # eax <- vBB (array object)
+ GET_VREG %ecx, %ecx # ecx <- vCC (requested index)
testl %eax, %eax # null array object?
je common_errNullObject # bail if so
cmpl MIRROR_ARRAY_LENGTH_OFFSET(%eax), %ecx
jae common_errArrayIndex # index >= length, bail.
movswl MIRROR_SHORT_ARRAY_DATA_OFFSET(%eax,%ecx,2), %eax
- SET_VREG %eax rINST
+ SET_VREG %eax, rINST
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* op vAA, vBB, vCC */
movzbl 2(rPC), %eax # eax <- BB
movzbl 3(rPC), %ecx # ecx <- CC
- GET_VREG %eax %eax # eax <- vBB (array object)
- GET_VREG %ecx %ecx # ecx <- vCC (requested index)
+ GET_VREG %eax, %eax # eax <- vBB (array object)
+ GET_VREG %ecx, %ecx # ecx <- vCC (requested index)
testl %eax, %eax # null array object?
je common_errNullObject # bail if so
cmpl MIRROR_ARRAY_LENGTH_OFFSET(%eax), %ecx
jae common_errArrayIndex # index >= length, bail.
leal MIRROR_INT_ARRAY_DATA_OFFSET(%eax,%ecx,4), %eax
- GET_VREG rINST rINST
+ GET_VREG rINST, rINST
movl rINST, (%eax)
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* aput-wide vAA, vBB, vCC */
movzbl 2(rPC), %eax # eax <- BB
movzbl 3(rPC), %ecx # ecx <- CC
- GET_VREG %eax %eax # eax <- vBB (array object)
- GET_VREG %ecx %ecx # ecx <- vCC (requested index)
+ GET_VREG %eax, %eax # eax <- vBB (array object)
+ GET_VREG %ecx, %ecx # ecx <- vCC (requested index)
testl %eax, %eax # null array object?
je common_errNullObject # bail if so
cmpl MIRROR_ARRAY_LENGTH_OFFSET(%eax), %ecx
jae common_errArrayIndex # index >= length, bail.
leal MIRROR_WIDE_ARRAY_DATA_OFFSET(%eax,%ecx,8), %eax
- GET_WIDE_FP_VREG %xmm0 rINST # xmm0 <- vAA
+ GET_WIDE_FP_VREG %xmm0, rINST # xmm0 <- vAA
movq %xmm0, (%eax) # vBB[vCC] <- xmm0
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
movl rPC, OUT_ARG1(%esp)
REFRESH_INST 77
movl rINST, OUT_ARG2(%esp)
- call MterpAputObject # (array, index)
+ call SYMBOL(MterpAputObject) # (array, index)
REFRESH_IBASE
testl %eax, %eax
jz MterpPossibleException
/* op vAA, vBB, vCC */
movzbl 2(rPC), %eax # eax <- BB
movzbl 3(rPC), %ecx # ecx <- CC
- GET_VREG %eax %eax # eax <- vBB (array object)
- GET_VREG %ecx %ecx # ecx <- vCC (requested index)
+ GET_VREG %eax, %eax # eax <- vBB (array object)
+ GET_VREG %ecx, %ecx # ecx <- vCC (requested index)
testl %eax, %eax # null array object?
je common_errNullObject # bail if so
cmpl MIRROR_ARRAY_LENGTH_OFFSET(%eax), %ecx
jae common_errArrayIndex # index >= length, bail.
leal MIRROR_BOOLEAN_ARRAY_DATA_OFFSET(%eax,%ecx,1), %eax
- GET_VREG rINST rINST
+ GET_VREG rINST, rINST
movb rINSTbl, (%eax)
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* op vAA, vBB, vCC */
movzbl 2(rPC), %eax # eax <- BB
movzbl 3(rPC), %ecx # ecx <- CC
- GET_VREG %eax %eax # eax <- vBB (array object)
- GET_VREG %ecx %ecx # ecx <- vCC (requested index)
+ GET_VREG %eax, %eax # eax <- vBB (array object)
+ GET_VREG %ecx, %ecx # ecx <- vCC (requested index)
testl %eax, %eax # null array object?
je common_errNullObject # bail if so
cmpl MIRROR_ARRAY_LENGTH_OFFSET(%eax), %ecx
jae common_errArrayIndex # index >= length, bail.
leal MIRROR_BYTE_ARRAY_DATA_OFFSET(%eax,%ecx,1), %eax
- GET_VREG rINST rINST
+ GET_VREG rINST, rINST
movb rINSTbl, (%eax)
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* op vAA, vBB, vCC */
movzbl 2(rPC), %eax # eax <- BB
movzbl 3(rPC), %ecx # ecx <- CC
- GET_VREG %eax %eax # eax <- vBB (array object)
- GET_VREG %ecx %ecx # ecx <- vCC (requested index)
+ GET_VREG %eax, %eax # eax <- vBB (array object)
+ GET_VREG %ecx, %ecx # ecx <- vCC (requested index)
testl %eax, %eax # null array object?
je common_errNullObject # bail if so
cmpl MIRROR_ARRAY_LENGTH_OFFSET(%eax), %ecx
jae common_errArrayIndex # index >= length, bail.
leal MIRROR_CHAR_ARRAY_DATA_OFFSET(%eax,%ecx,2), %eax
- GET_VREG rINST rINST
+ GET_VREG rINST, rINST
movw rINSTw, (%eax)
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* op vAA, vBB, vCC */
movzbl 2(rPC), %eax # eax <- BB
movzbl 3(rPC), %ecx # ecx <- CC
- GET_VREG %eax %eax # eax <- vBB (array object)
- GET_VREG %ecx %ecx # ecx <- vCC (requested index)
+ GET_VREG %eax, %eax # eax <- vBB (array object)
+ GET_VREG %ecx, %ecx # ecx <- vCC (requested index)
testl %eax, %eax # null array object?
je common_errNullObject # bail if so
cmpl MIRROR_ARRAY_LENGTH_OFFSET(%eax), %ecx
jae common_errArrayIndex # index >= length, bail.
leal MIRROR_SHORT_ARRAY_DATA_OFFSET(%eax,%ecx,2), %eax
- GET_VREG rINST rINST
+ GET_VREG rINST, rINST
movw rINSTw, (%eax)
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
movl %eax, OUT_ARG2(%esp) # referrer
mov rSELF, %ecx
movl %ecx, OUT_ARG3(%esp) # self
- call artGet32InstanceFromCode
+ call SYMBOL(artGet32InstanceFromCode)
movl rSELF, %ecx
REFRESH_IBASE_FROM_SELF %ecx
cmpl $0, THREAD_EXCEPTION_OFFSET(%ecx)
jnz MterpException # bail out
andb $0xf, rINSTbl # rINST <- A
.if 0
- SET_VREG_OBJECT %eax rINST # fp[A] <-value
+ SET_VREG_OBJECT %eax, rINST # fp[A] <-value
.else
- SET_VREG %eax rINST # fp[A] <-value
+ SET_VREG %eax, rINST # fp[A] <-value
.endif
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
movl %eax, OUT_ARG2(%esp) # referrer
mov rSELF, %ecx
movl %ecx, OUT_ARG3(%esp) # self
- call artGet64InstanceFromCode
+ call SYMBOL(artGet64InstanceFromCode)
mov rSELF, %ecx
cmpl $0, THREAD_EXCEPTION_OFFSET(%ecx)
jnz MterpException # bail out
andb $0xf, rINSTbl # rINST <- A
- SET_VREG %eax rINST
- SET_VREG_HIGH %edx rINST
+ SET_VREG %eax, rINST
+ SET_VREG_HIGH %edx, rINST
REFRESH_IBASE_FROM_SELF %ecx
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
movl %eax, OUT_ARG2(%esp) # referrer
mov rSELF, %ecx
movl %ecx, OUT_ARG3(%esp) # self
- call artGetObjInstanceFromCode
+ call SYMBOL(artGetObjInstanceFromCode)
movl rSELF, %ecx
REFRESH_IBASE_FROM_SELF %ecx
cmpl $0, THREAD_EXCEPTION_OFFSET(%ecx)
jnz MterpException # bail out
andb $0xf, rINSTbl # rINST <- A
.if 1
- SET_VREG_OBJECT %eax rINST # fp[A] <-value
+ SET_VREG_OBJECT %eax, rINST # fp[A] <-value
.else
- SET_VREG %eax rINST # fp[A] <-value
+ SET_VREG %eax, rINST # fp[A] <-value
.endif
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
movl %eax, OUT_ARG2(%esp) # referrer
mov rSELF, %ecx
movl %ecx, OUT_ARG3(%esp) # self
- call artGetBooleanInstanceFromCode
+ call SYMBOL(artGetBooleanInstanceFromCode)
movl rSELF, %ecx
REFRESH_IBASE_FROM_SELF %ecx
cmpl $0, THREAD_EXCEPTION_OFFSET(%ecx)
jnz MterpException # bail out
andb $0xf, rINSTbl # rINST <- A
.if 0
- SET_VREG_OBJECT %eax rINST # fp[A] <-value
+ SET_VREG_OBJECT %eax, rINST # fp[A] <-value
.else
- SET_VREG %eax rINST # fp[A] <-value
+ SET_VREG %eax, rINST # fp[A] <-value
.endif
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
movl %eax, OUT_ARG2(%esp) # referrer
mov rSELF, %ecx
movl %ecx, OUT_ARG3(%esp) # self
- call artGetByteInstanceFromCode
+ call SYMBOL(artGetByteInstanceFromCode)
movl rSELF, %ecx
REFRESH_IBASE_FROM_SELF %ecx
cmpl $0, THREAD_EXCEPTION_OFFSET(%ecx)
jnz MterpException # bail out
andb $0xf, rINSTbl # rINST <- A
.if 0
- SET_VREG_OBJECT %eax rINST # fp[A] <-value
+ SET_VREG_OBJECT %eax, rINST # fp[A] <-value
.else
- SET_VREG %eax rINST # fp[A] <-value
+ SET_VREG %eax, rINST # fp[A] <-value
.endif
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
movl %eax, OUT_ARG2(%esp) # referrer
mov rSELF, %ecx
movl %ecx, OUT_ARG3(%esp) # self
- call artGetCharInstanceFromCode
+ call SYMBOL(artGetCharInstanceFromCode)
movl rSELF, %ecx
REFRESH_IBASE_FROM_SELF %ecx
cmpl $0, THREAD_EXCEPTION_OFFSET(%ecx)
jnz MterpException # bail out
andb $0xf, rINSTbl # rINST <- A
.if 0
- SET_VREG_OBJECT %eax rINST # fp[A] <-value
+ SET_VREG_OBJECT %eax, rINST # fp[A] <-value
.else
- SET_VREG %eax rINST # fp[A] <-value
+ SET_VREG %eax, rINST # fp[A] <-value
.endif
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
movl %eax, OUT_ARG2(%esp) # referrer
mov rSELF, %ecx
movl %ecx, OUT_ARG3(%esp) # self
- call artGetShortInstanceFromCode
+ call SYMBOL(artGetShortInstanceFromCode)
movl rSELF, %ecx
REFRESH_IBASE_FROM_SELF %ecx
cmpl $0, THREAD_EXCEPTION_OFFSET(%ecx)
jnz MterpException # bail out
andb $0xf, rINSTbl # rINST <- A
.if 0
- SET_VREG_OBJECT %eax rINST # fp[A] <-value
+ SET_VREG_OBJECT %eax, rINST # fp[A] <-value
.else
- SET_VREG %eax rINST # fp[A] <-value
+ SET_VREG %eax, rINST # fp[A] <-value
.endif
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
movl %eax, OUT_ARG2(%esp) # fp[A]
movl OFF_FP_METHOD(rFP), %eax
movl %eax, OUT_ARG3(%esp) # referrer
- call artSet32InstanceFromMterp
+ call SYMBOL(artSet32InstanceFromMterp)
testl %eax, %eax
jnz MterpPossibleException
REFRESH_IBASE
movl %eax, OUT_ARG2(%esp) # &fp[A]
movl OFF_FP_METHOD(rFP), %eax
movl %eax, OUT_ARG3(%esp) # referrer
- call artSet64InstanceFromMterp
+ call SYMBOL(artSet64InstanceFromMterp)
testl %eax, %eax
jnz MterpPossibleException
REFRESH_IBASE
movl rINST, OUT_ARG2(%esp)
movl rSELF, %eax
movl %eax, OUT_ARG3(%esp)
- call MterpIputObject
+ call SYMBOL(MterpIputObject)
testl %eax, %eax
jz MterpException
REFRESH_IBASE
movl %eax, OUT_ARG2(%esp) # fp[A]
movl OFF_FP_METHOD(rFP), %eax
movl %eax, OUT_ARG3(%esp) # referrer
- call artSet8InstanceFromMterp
+ call SYMBOL(artSet8InstanceFromMterp)
testl %eax, %eax
jnz MterpPossibleException
REFRESH_IBASE
movl %eax, OUT_ARG2(%esp) # fp[A]
movl OFF_FP_METHOD(rFP), %eax
movl %eax, OUT_ARG3(%esp) # referrer
- call artSet8InstanceFromMterp
+ call SYMBOL(artSet8InstanceFromMterp)
testl %eax, %eax
jnz MterpPossibleException
REFRESH_IBASE
movl %eax, OUT_ARG2(%esp) # fp[A]
movl OFF_FP_METHOD(rFP), %eax
movl %eax, OUT_ARG3(%esp) # referrer
- call artSet16InstanceFromMterp
+ call SYMBOL(artSet16InstanceFromMterp)
testl %eax, %eax
jnz MterpPossibleException
REFRESH_IBASE
movl %eax, OUT_ARG2(%esp) # fp[A]
movl OFF_FP_METHOD(rFP), %eax
movl %eax, OUT_ARG3(%esp) # referrer
- call artSet16InstanceFromMterp
+ call SYMBOL(artSet16InstanceFromMterp)
testl %eax, %eax
jnz MterpPossibleException
REFRESH_IBASE
movl %eax, OUT_ARG1(%esp) # referrer
movl rSELF, %ecx
movl %ecx, OUT_ARG2(%esp) # self
- call artGet32StaticFromCode
+ call SYMBOL(artGet32StaticFromCode)
movl rSELF, %ecx
REFRESH_IBASE_FROM_SELF %ecx
cmpl $0, THREAD_EXCEPTION_OFFSET(%ecx)
jnz MterpException
.if 0
- SET_VREG_OBJECT %eax rINST # fp[A] <- value
+ SET_VREG_OBJECT %eax, rINST # fp[A] <- value
.else
- SET_VREG %eax rINST # fp[A] <- value
+ SET_VREG %eax, rINST # fp[A] <- value
.endif
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
movl %eax, OUT_ARG1(%esp) # referrer
movl rSELF, %ecx
movl %ecx, OUT_ARG2(%esp) # self
- call artGet64StaticFromCode
+ call SYMBOL(artGet64StaticFromCode)
movl rSELF, %ecx
cmpl $0, THREAD_EXCEPTION_OFFSET(%ecx)
jnz MterpException
- SET_VREG %eax rINST # fp[A]<- low part
- SET_VREG_HIGH %edx rINST # fp[A+1]<- high part
+ SET_VREG %eax, rINST # fp[A]<- low part
+ SET_VREG_HIGH %edx, rINST # fp[A+1]<- high part
REFRESH_IBASE_FROM_SELF %ecx
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
movl %eax, OUT_ARG1(%esp) # referrer
movl rSELF, %ecx
movl %ecx, OUT_ARG2(%esp) # self
- call artGetObjStaticFromCode
+ call SYMBOL(artGetObjStaticFromCode)
movl rSELF, %ecx
REFRESH_IBASE_FROM_SELF %ecx
cmpl $0, THREAD_EXCEPTION_OFFSET(%ecx)
jnz MterpException
.if 1
- SET_VREG_OBJECT %eax rINST # fp[A] <- value
+ SET_VREG_OBJECT %eax, rINST # fp[A] <- value
.else
- SET_VREG %eax rINST # fp[A] <- value
+ SET_VREG %eax, rINST # fp[A] <- value
.endif
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
movl %eax, OUT_ARG1(%esp) # referrer
movl rSELF, %ecx
movl %ecx, OUT_ARG2(%esp) # self
- call artGetBooleanStaticFromCode
+ call SYMBOL(artGetBooleanStaticFromCode)
movl rSELF, %ecx
REFRESH_IBASE_FROM_SELF %ecx
cmpl $0, THREAD_EXCEPTION_OFFSET(%ecx)
jnz MterpException
.if 0
- SET_VREG_OBJECT %eax rINST # fp[A] <- value
+ SET_VREG_OBJECT %eax, rINST # fp[A] <- value
.else
- SET_VREG %eax rINST # fp[A] <- value
+ SET_VREG %eax, rINST # fp[A] <- value
.endif
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
movl %eax, OUT_ARG1(%esp) # referrer
movl rSELF, %ecx
movl %ecx, OUT_ARG2(%esp) # self
- call artGetByteStaticFromCode
+ call SYMBOL(artGetByteStaticFromCode)
movl rSELF, %ecx
REFRESH_IBASE_FROM_SELF %ecx
cmpl $0, THREAD_EXCEPTION_OFFSET(%ecx)
jnz MterpException
.if 0
- SET_VREG_OBJECT %eax rINST # fp[A] <- value
+ SET_VREG_OBJECT %eax, rINST # fp[A] <- value
.else
- SET_VREG %eax rINST # fp[A] <- value
+ SET_VREG %eax, rINST # fp[A] <- value
.endif
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
movl %eax, OUT_ARG1(%esp) # referrer
movl rSELF, %ecx
movl %ecx, OUT_ARG2(%esp) # self
- call artGetCharStaticFromCode
+ call SYMBOL(artGetCharStaticFromCode)
movl rSELF, %ecx
REFRESH_IBASE_FROM_SELF %ecx
cmpl $0, THREAD_EXCEPTION_OFFSET(%ecx)
jnz MterpException
.if 0
- SET_VREG_OBJECT %eax rINST # fp[A] <- value
+ SET_VREG_OBJECT %eax, rINST # fp[A] <- value
.else
- SET_VREG %eax rINST # fp[A] <- value
+ SET_VREG %eax, rINST # fp[A] <- value
.endif
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
movl %eax, OUT_ARG1(%esp) # referrer
movl rSELF, %ecx
movl %ecx, OUT_ARG2(%esp) # self
- call artGetShortStaticFromCode
+ call SYMBOL(artGetShortStaticFromCode)
movl rSELF, %ecx
REFRESH_IBASE_FROM_SELF %ecx
cmpl $0, THREAD_EXCEPTION_OFFSET(%ecx)
jnz MterpException
.if 0
- SET_VREG_OBJECT %eax rINST # fp[A] <- value
+ SET_VREG_OBJECT %eax, rINST # fp[A] <- value
.else
- SET_VREG %eax rINST # fp[A] <- value
+ SET_VREG %eax, rINST # fp[A] <- value
.endif
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
EXPORT_PC
movzwl 2(rPC), %eax
movl %eax, OUT_ARG0(%esp) # field ref BBBB
- GET_VREG rINST rINST
+ GET_VREG rINST, rINST
movl rINST, OUT_ARG1(%esp) # fp[AA]
movl OFF_FP_METHOD(rFP), %eax
movl %eax, OUT_ARG2(%esp) # referrer
movl rSELF, %ecx
movl %ecx, OUT_ARG3(%esp) # self
- call artSet32StaticFromCode
+ call SYMBOL(artSet32StaticFromCode)
testl %eax, %eax
jnz MterpException
REFRESH_IBASE
movl %eax, OUT_ARG2(%esp) # &fp[AA]
movl rSELF, %ecx
movl %ecx, OUT_ARG3(%esp) # self
- call artSet64IndirectStaticFromMterp
+ call SYMBOL(artSet64IndirectStaticFromMterp)
testl %eax, %eax
jnz MterpException
REFRESH_IBASE
movl rINST, OUT_ARG2(%esp)
movl rSELF, %ecx
movl %ecx, OUT_ARG3(%esp)
- call MterpSputObject
+ call SYMBOL(MterpSputObject)
testl %eax, %eax
jz MterpException
REFRESH_IBASE
EXPORT_PC
movzwl 2(rPC), %eax
movl %eax, OUT_ARG0(%esp) # field ref BBBB
- GET_VREG rINST rINST
+ GET_VREG rINST, rINST
movl rINST, OUT_ARG1(%esp) # fp[AA]
movl OFF_FP_METHOD(rFP), %eax
movl %eax, OUT_ARG2(%esp) # referrer
movl rSELF, %ecx
movl %ecx, OUT_ARG3(%esp) # self
- call artSet8StaticFromCode
+ call SYMBOL(artSet8StaticFromCode)
testl %eax, %eax
jnz MterpException
REFRESH_IBASE
EXPORT_PC
movzwl 2(rPC), %eax
movl %eax, OUT_ARG0(%esp) # field ref BBBB
- GET_VREG rINST rINST
+ GET_VREG rINST, rINST
movl rINST, OUT_ARG1(%esp) # fp[AA]
movl OFF_FP_METHOD(rFP), %eax
movl %eax, OUT_ARG2(%esp) # referrer
movl rSELF, %ecx
movl %ecx, OUT_ARG3(%esp) # self
- call artSet8StaticFromCode
+ call SYMBOL(artSet8StaticFromCode)
testl %eax, %eax
jnz MterpException
REFRESH_IBASE
EXPORT_PC
movzwl 2(rPC), %eax
movl %eax, OUT_ARG0(%esp) # field ref BBBB
- GET_VREG rINST rINST
+ GET_VREG rINST, rINST
movl rINST, OUT_ARG1(%esp) # fp[AA]
movl OFF_FP_METHOD(rFP), %eax
movl %eax, OUT_ARG2(%esp) # referrer
movl rSELF, %ecx
movl %ecx, OUT_ARG3(%esp) # self
- call artSet16StaticFromCode
+ call SYMBOL(artSet16StaticFromCode)
testl %eax, %eax
jnz MterpException
REFRESH_IBASE
EXPORT_PC
movzwl 2(rPC), %eax
movl %eax, OUT_ARG0(%esp) # field ref BBBB
- GET_VREG rINST rINST
+ GET_VREG rINST, rINST
movl rINST, OUT_ARG1(%esp) # fp[AA]
movl OFF_FP_METHOD(rFP), %eax
movl %eax, OUT_ARG2(%esp) # referrer
movl rSELF, %ecx
movl %ecx, OUT_ARG3(%esp) # self
- call artSet16StaticFromCode
+ call SYMBOL(artSet16StaticFromCode)
testl %eax, %eax
jnz MterpException
REFRESH_IBASE
movl rPC, OUT_ARG2(%esp)
REFRESH_INST 110
movl rINST, OUT_ARG3(%esp)
- call MterpInvokeVirtual
+ call SYMBOL(MterpInvokeVirtual)
testl %eax, %eax
jz MterpException
REFRESH_IBASE
movl rPC, OUT_ARG2(%esp)
REFRESH_INST 111
movl rINST, OUT_ARG3(%esp)
- call MterpInvokeSuper
+ call SYMBOL(MterpInvokeSuper)
testl %eax, %eax
jz MterpException
REFRESH_IBASE
movl rPC, OUT_ARG2(%esp)
REFRESH_INST 112
movl rINST, OUT_ARG3(%esp)
- call MterpInvokeDirect
+ call SYMBOL(MterpInvokeDirect)
testl %eax, %eax
jz MterpException
REFRESH_IBASE
movl rPC, OUT_ARG2(%esp)
REFRESH_INST 113
movl rINST, OUT_ARG3(%esp)
- call MterpInvokeStatic
+ call SYMBOL(MterpInvokeStatic)
testl %eax, %eax
jz MterpException
REFRESH_IBASE
movl rPC, OUT_ARG2(%esp)
REFRESH_INST 114
movl rINST, OUT_ARG3(%esp)
- call MterpInvokeInterface
+ call SYMBOL(MterpInvokeInterface)
testl %eax, %eax
jz MterpException
REFRESH_IBASE
testl $(THREAD_SUSPEND_REQUEST | THREAD_CHECKPOINT_REQUEST), THREAD_FLAGS_OFFSET(%eax)
jz 1f
movl %eax, OUT_ARG0(%esp)
- call MterpSuspendCheck
+ call SYMBOL(MterpSuspendCheck)
1:
xorl %eax, %eax
xorl %ecx, %ecx
movl rPC, OUT_ARG2(%esp)
REFRESH_INST 116
movl rINST, OUT_ARG3(%esp)
- call MterpInvokeVirtualRange
+ call SYMBOL(MterpInvokeVirtualRange)
testl %eax, %eax
jz MterpException
REFRESH_IBASE
movl rPC, OUT_ARG2(%esp)
REFRESH_INST 117
movl rINST, OUT_ARG3(%esp)
- call MterpInvokeSuperRange
+ call SYMBOL(MterpInvokeSuperRange)
testl %eax, %eax
jz MterpException
REFRESH_IBASE
movl rPC, OUT_ARG2(%esp)
REFRESH_INST 118
movl rINST, OUT_ARG3(%esp)
- call MterpInvokeDirectRange
+ call SYMBOL(MterpInvokeDirectRange)
testl %eax, %eax
jz MterpException
REFRESH_IBASE
movl rPC, OUT_ARG2(%esp)
REFRESH_INST 119
movl rINST, OUT_ARG3(%esp)
- call MterpInvokeStaticRange
+ call SYMBOL(MterpInvokeStaticRange)
testl %eax, %eax
jz MterpException
REFRESH_IBASE
movl rPC, OUT_ARG2(%esp)
REFRESH_INST 120
movl rINST, OUT_ARG3(%esp)
- call MterpInvokeInterfaceRange
+ call SYMBOL(MterpInvokeInterfaceRange)
testl %eax, %eax
jz MterpException
REFRESH_IBASE
/* unop vA, vB */
movzbl rINSTbl,%ecx # ecx <- A+
sarl $4,rINST # rINST <- B
- GET_VREG %eax rINST # eax <- vB
+ GET_VREG %eax, rINST # eax <- vB
andb $0xf,%cl # ecx <- A
negl %eax
- SET_VREG %eax %ecx
+ SET_VREG %eax, %ecx
ADVANCE_PC_FETCH_AND_GOTO_NEXT 1
/* unop vA, vB */
movzbl rINSTbl,%ecx # ecx <- A+
sarl $4,rINST # rINST <- B
- GET_VREG %eax rINST # eax <- vB
+ GET_VREG %eax, rINST # eax <- vB
andb $0xf,%cl # ecx <- A
notl %eax
- SET_VREG %eax %ecx
+ SET_VREG %eax, %ecx
ADVANCE_PC_FETCH_AND_GOTO_NEXT 1
movzbl rINSTbl, %ecx # ecx <- BA
sarl $4, %ecx # ecx <- B
andb $0xf, rINSTbl # rINST <- A
- GET_VREG %eax %ecx # eax <- v[B+0]
- GET_VREG_HIGH %ecx %ecx # ecx <- v[B+1]
+ GET_VREG %eax, %ecx # eax <- v[B+0]
+ GET_VREG_HIGH %ecx, %ecx # ecx <- v[B+1]
negl %eax
adcl $0, %ecx
negl %ecx
- SET_VREG %eax rINST # v[A+0] <- eax
- SET_VREG_HIGH %ecx rINST # v[A+1] <- ecx
+ SET_VREG %eax, rINST # v[A+0] <- eax
+ SET_VREG_HIGH %ecx, rINST # v[A+1] <- ecx
ADVANCE_PC_FETCH_AND_GOTO_NEXT 1
movzbl rINSTbl, %ecx # ecx <- BA
sarl $4, %ecx # ecx <- B
andb $0xf, rINSTbl # rINST <- A
- GET_VREG %eax %ecx # eax <- v[B+0]
- GET_VREG_HIGH %ecx %ecx # ecx <- v[B+1]
+ GET_VREG %eax, %ecx # eax <- v[B+0]
+ GET_VREG_HIGH %ecx, %ecx # ecx <- v[B+1]
notl %eax
notl %ecx
- SET_VREG %eax rINST # v[A+0] <- eax
- SET_VREG_HIGH %ecx rINST # v[A+1] <- ecx
+ SET_VREG %eax, rINST # v[A+0] <- eax
+ SET_VREG_HIGH %ecx, rINST # v[A+1] <- ecx
ADVANCE_PC_FETCH_AND_GOTO_NEXT 1
/* ------------------------------ */
/* int to long vA, vB */
movzbl rINSTbl, %eax # eax <- +A
sarl $4, %eax # eax <- B
- GET_VREG %eax %eax # eax <- vB
+ GET_VREG %eax, %eax # eax <- vB
andb $0xf, rINSTbl # rINST <- A
movl rIBASE, %ecx # cltd trashes rIBASE/edx
cltd # rINST:eax<- sssssssBBBBBBBB
- SET_VREG_HIGH rIBASE rINST # v[A+1] <- rIBASE
- SET_VREG %eax rINST # v[A+0] <- %eax
+ SET_VREG_HIGH rIBASE, rINST # v[A+1] <- rIBASE
+ SET_VREG %eax, rINST # v[A+0] <- %eax
movl %ecx, rIBASE
ADVANCE_PC_FETCH_AND_GOTO_NEXT 1
movzbl rINSTbl, %eax # eax <- BA
andb $0xf, %al # eax <- A
shrl $4, rINST # rINST <- B
- GET_VREG rINST rINST
+ GET_VREG rINST, rINST
.if 0
- SET_VREG_OBJECT rINST %eax # fp[A] <- fp[B]
+ SET_VREG_OBJECT rINST, %eax # fp[A] <- fp[B]
.else
- SET_VREG rINST %eax # fp[A] <- fp[B]
+ SET_VREG rINST, %eax # fp[A] <- fp[B]
.endif
ADVANCE_PC_FETCH_AND_GOTO_NEXT 1
/* unop vA, vB */
movzbl rINSTbl,%ecx # ecx <- A+
sarl $4,rINST # rINST <- B
- GET_VREG %eax rINST # eax <- vB
+ GET_VREG %eax, rINST # eax <- vB
andb $0xf,%cl # ecx <- A
movsbl %al, %eax
- SET_VREG %eax %ecx
+ SET_VREG %eax, %ecx
ADVANCE_PC_FETCH_AND_GOTO_NEXT 1
/* unop vA, vB */
movzbl rINSTbl,%ecx # ecx <- A+
sarl $4,rINST # rINST <- B
- GET_VREG %eax rINST # eax <- vB
+ GET_VREG %eax, rINST # eax <- vB
andb $0xf,%cl # ecx <- A
movzwl %ax,%eax
- SET_VREG %eax %ecx
+ SET_VREG %eax, %ecx
ADVANCE_PC_FETCH_AND_GOTO_NEXT 1
/* unop vA, vB */
movzbl rINSTbl,%ecx # ecx <- A+
sarl $4,rINST # rINST <- B
- GET_VREG %eax rINST # eax <- vB
+ GET_VREG %eax, rINST # eax <- vB
andb $0xf,%cl # ecx <- A
movswl %ax, %eax
- SET_VREG %eax %ecx
+ SET_VREG %eax, %ecx
ADVANCE_PC_FETCH_AND_GOTO_NEXT 1
/* binop vAA, vBB, vCC */
movzbl 2(rPC), %eax # eax <- BB
movzbl 3(rPC), %ecx # ecx <- CC
- GET_VREG %eax %eax # eax <- vBB
+ GET_VREG %eax, %eax # eax <- vBB
addl (rFP,%ecx,4), %eax # ex: addl (rFP,%ecx,4),%eax
- SET_VREG %eax rINST
+ SET_VREG %eax, rINST
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* binop vAA, vBB, vCC */
movzbl 2(rPC), %eax # eax <- BB
movzbl 3(rPC), %ecx # ecx <- CC
- GET_VREG %eax %eax # eax <- vBB
+ GET_VREG %eax, %eax # eax <- vBB
subl (rFP,%ecx,4), %eax # ex: addl (rFP,%ecx,4),%eax
- SET_VREG %eax rINST
+ SET_VREG %eax, rINST
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* mul vAA, vBB, vCC */
movzbl 2(rPC), %eax # eax <- BB
movzbl 3(rPC), %ecx # ecx <- CC
- GET_VREG %eax %eax # eax <- vBB
+ GET_VREG %eax, %eax # eax <- vBB
mov rIBASE, LOCAL0(%esp)
imull (rFP,%ecx,4), %eax # trashes rIBASE/edx
mov LOCAL0(%esp), rIBASE
- SET_VREG %eax rINST
+ SET_VREG %eax, rINST
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* ------------------------------ */
/* div/rem vAA, vBB, vCC */
movzbl 2(rPC), %eax # eax <- BB
movzbl 3(rPC), %ecx # ecx <- CC
- GET_VREG %eax %eax # eax <- vBB
- GET_VREG %ecx %ecx # ecx <- vCC
+ GET_VREG %eax, %eax # eax <- vBB
+ GET_VREG %ecx, %ecx # ecx <- vCC
mov rIBASE, LOCAL0(%esp)
testl %ecx, %ecx
je common_errDivideByZero
xorl %edx, %edx # Clear %edx before divide
div %cx
.Lop_div_int_finish:
- SET_VREG %eax rINST
+ SET_VREG %eax, rINST
mov LOCAL0(%esp), rIBASE
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* div/rem vAA, vBB, vCC */
movzbl 2(rPC), %eax # eax <- BB
movzbl 3(rPC), %ecx # ecx <- CC
- GET_VREG %eax %eax # eax <- vBB
- GET_VREG %ecx %ecx # ecx <- vCC
+ GET_VREG %eax, %eax # eax <- vBB
+ GET_VREG %ecx, %ecx # ecx <- vCC
mov rIBASE, LOCAL0(%esp)
testl %ecx, %ecx
je common_errDivideByZero
xorl %edx, %edx # Clear %edx before divide
div %cx
.Lop_rem_int_finish:
- SET_VREG rIBASE rINST
+ SET_VREG rIBASE, rINST
mov LOCAL0(%esp), rIBASE
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* binop vAA, vBB, vCC */
movzbl 2(rPC), %eax # eax <- BB
movzbl 3(rPC), %ecx # ecx <- CC
- GET_VREG %eax %eax # eax <- vBB
+ GET_VREG %eax, %eax # eax <- vBB
andl (rFP,%ecx,4), %eax # ex: addl (rFP,%ecx,4),%eax
- SET_VREG %eax rINST
+ SET_VREG %eax, rINST
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* binop vAA, vBB, vCC */
movzbl 2(rPC), %eax # eax <- BB
movzbl 3(rPC), %ecx # ecx <- CC
- GET_VREG %eax %eax # eax <- vBB
+ GET_VREG %eax, %eax # eax <- vBB
orl (rFP,%ecx,4), %eax # ex: addl (rFP,%ecx,4),%eax
- SET_VREG %eax rINST
+ SET_VREG %eax, rINST
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* binop vAA, vBB, vCC */
movzbl 2(rPC), %eax # eax <- BB
movzbl 3(rPC), %ecx # ecx <- CC
- GET_VREG %eax %eax # eax <- vBB
+ GET_VREG %eax, %eax # eax <- vBB
xorl (rFP,%ecx,4), %eax # ex: addl (rFP,%ecx,4),%eax
- SET_VREG %eax rINST
+ SET_VREG %eax, rINST
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* binop vAA, vBB, vCC */
movzbl 2(rPC),%eax # eax <- BB
movzbl 3(rPC),%ecx # ecx <- CC
- GET_VREG %eax %eax # eax <- vBB
- GET_VREG %ecx %ecx # eax <- vBB
+ GET_VREG %eax, %eax # eax <- vBB
+ GET_VREG %ecx, %ecx # eax <- vBB
sall %cl, %eax # ex: addl %ecx,%eax
- SET_VREG %eax rINST
+ SET_VREG %eax, rINST
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* binop vAA, vBB, vCC */
movzbl 2(rPC),%eax # eax <- BB
movzbl 3(rPC),%ecx # ecx <- CC
- GET_VREG %eax %eax # eax <- vBB
- GET_VREG %ecx %ecx # eax <- vBB
+ GET_VREG %eax, %eax # eax <- vBB
+ GET_VREG %ecx, %ecx # eax <- vBB
sarl %cl, %eax # ex: addl %ecx,%eax
- SET_VREG %eax rINST
+ SET_VREG %eax, rINST
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* binop vAA, vBB, vCC */
movzbl 2(rPC),%eax # eax <- BB
movzbl 3(rPC),%ecx # ecx <- CC
- GET_VREG %eax %eax # eax <- vBB
- GET_VREG %ecx %ecx # eax <- vBB
+ GET_VREG %eax, %eax # eax <- vBB
+ GET_VREG %ecx, %ecx # eax <- vBB
shrl %cl, %eax # ex: addl %ecx,%eax
- SET_VREG %eax rINST
+ SET_VREG %eax, rINST
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
* Generic 64-bit binary operation.
*/
/* binop vAA, vBB, vCC */
- movzbl 2(rPC),%eax # eax <- BB
- movzbl 3(rPC),%ecx # ecx <- CC
- movl rIBASE,LOCAL0(%esp) # save rIBASE
- GET_VREG rIBASE %eax # rIBASE <- v[BB+0]
- GET_VREG_HIGH %eax %eax # eax <- v[BB+1]
+ movzbl 2(rPC), %eax # eax <- BB
+ movzbl 3(rPC), %ecx # ecx <- CC
+ movl rIBASE, LOCAL0(%esp) # save rIBASE
+ GET_VREG rIBASE, %eax # rIBASE <- v[BB+0]
+ GET_VREG_HIGH %eax, %eax # eax <- v[BB+1]
addl (rFP,%ecx,4), rIBASE # ex: addl (rFP,%ecx,4),rIBASE
adcl 4(rFP,%ecx,4), %eax # ex: adcl 4(rFP,%ecx,4),%eax
- SET_VREG rIBASE rINST # v[AA+0] <- rIBASE
- movl LOCAL0(%esp),rIBASE # restore rIBASE
- SET_VREG_HIGH %eax rINST # v[AA+1] <- eax
+ SET_VREG rIBASE, rINST # v[AA+0] <- rIBASE
+ movl LOCAL0(%esp), rIBASE # restore rIBASE
+ SET_VREG_HIGH %eax, rINST # v[AA+1] <- eax
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
* Generic 64-bit binary operation.
*/
/* binop vAA, vBB, vCC */
- movzbl 2(rPC),%eax # eax <- BB
- movzbl 3(rPC),%ecx # ecx <- CC
- movl rIBASE,LOCAL0(%esp) # save rIBASE
- GET_VREG rIBASE %eax # rIBASE <- v[BB+0]
- GET_VREG_HIGH %eax %eax # eax <- v[BB+1]
+ movzbl 2(rPC), %eax # eax <- BB
+ movzbl 3(rPC), %ecx # ecx <- CC
+ movl rIBASE, LOCAL0(%esp) # save rIBASE
+ GET_VREG rIBASE, %eax # rIBASE <- v[BB+0]
+ GET_VREG_HIGH %eax, %eax # eax <- v[BB+1]
subl (rFP,%ecx,4), rIBASE # ex: addl (rFP,%ecx,4),rIBASE
sbbl 4(rFP,%ecx,4), %eax # ex: adcl 4(rFP,%ecx,4),%eax
- SET_VREG rIBASE rINST # v[AA+0] <- rIBASE
- movl LOCAL0(%esp),rIBASE # restore rIBASE
- SET_VREG_HIGH %eax rINST # v[AA+1] <- eax
+ SET_VREG rIBASE, rINST # v[AA+0] <- rIBASE
+ movl LOCAL0(%esp), rIBASE # restore rIBASE
+ SET_VREG_HIGH %eax, rINST # v[AA+1] <- eax
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
mov LOCAL0(%esp), rPC # restore Interpreter PC
mov LOCAL1(%esp), rFP # restore FP
leal (%ecx,rIBASE), rIBASE # full result now in rIBASE:%eax
- SET_VREG_HIGH rIBASE rINST # v[B+1] <- rIBASE
+ SET_VREG_HIGH rIBASE, rINST # v[B+1] <- rIBASE
mov LOCAL2(%esp), rIBASE # restore IBASE
- SET_VREG %eax rINST # v[B] <- eax
+ SET_VREG %eax, rINST # v[B] <- eax
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* ------------------------------ */
mov rIBASE, LOCAL0(%esp) # save rIBASE/%edx
mov rINST, LOCAL1(%esp) # save rINST/%ebx
movzbl 3(rPC), %eax # eax <- CC
- GET_VREG %ecx %eax
- GET_VREG_HIGH %ebx %eax
+ GET_VREG %ecx, %eax
+ GET_VREG_HIGH %ebx, %eax
movl %ecx, %edx
orl %ebx, %ecx
jz common_errDivideByZero
movzbl 2(rPC), %eax # eax <- BB
- GET_VREG_HIGH %ecx %eax
- GET_VREG %eax %eax
- call art_quick_ldiv
+ GET_VREG_HIGH %ecx, %eax
+ GET_VREG %eax, %eax
+ call SYMBOL(art_quick_ldiv)
mov LOCAL1(%esp), rINST # restore rINST/%ebx
- SET_VREG_HIGH rIBASE rINST
- SET_VREG %eax rINST
+ SET_VREG_HIGH rIBASE, rINST
+ SET_VREG %eax, rINST
mov LOCAL0(%esp), rIBASE # restore rIBASE/%edx
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
mov rIBASE, LOCAL0(%esp) # save rIBASE/%edx
mov rINST, LOCAL1(%esp) # save rINST/%ebx
movzbl 3(rPC), %eax # eax <- CC
- GET_VREG %ecx %eax
- GET_VREG_HIGH %ebx %eax
+ GET_VREG %ecx, %eax
+ GET_VREG_HIGH %ebx, %eax
movl %ecx, %edx
orl %ebx, %ecx
jz common_errDivideByZero
movzbl 2(rPC), %eax # eax <- BB
- GET_VREG_HIGH %ecx %eax
- GET_VREG %eax %eax
- call art_quick_lmod
+ GET_VREG_HIGH %ecx, %eax
+ GET_VREG %eax, %eax
+ call SYMBOL(art_quick_lmod)
mov LOCAL1(%esp), rINST # restore rINST/%ebx
- SET_VREG_HIGH rIBASE rINST
- SET_VREG %eax rINST
+ SET_VREG_HIGH rIBASE, rINST
+ SET_VREG %eax, rINST
mov LOCAL0(%esp), rIBASE # restore rIBASE/%edx
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
* Generic 64-bit binary operation.
*/
/* binop vAA, vBB, vCC */
- movzbl 2(rPC),%eax # eax <- BB
- movzbl 3(rPC),%ecx # ecx <- CC
- movl rIBASE,LOCAL0(%esp) # save rIBASE
- GET_VREG rIBASE %eax # rIBASE <- v[BB+0]
- GET_VREG_HIGH %eax %eax # eax <- v[BB+1]
+ movzbl 2(rPC), %eax # eax <- BB
+ movzbl 3(rPC), %ecx # ecx <- CC
+ movl rIBASE, LOCAL0(%esp) # save rIBASE
+ GET_VREG rIBASE, %eax # rIBASE <- v[BB+0]
+ GET_VREG_HIGH %eax, %eax # eax <- v[BB+1]
andl (rFP,%ecx,4), rIBASE # ex: addl (rFP,%ecx,4),rIBASE
andl 4(rFP,%ecx,4), %eax # ex: adcl 4(rFP,%ecx,4),%eax
- SET_VREG rIBASE rINST # v[AA+0] <- rIBASE
- movl LOCAL0(%esp),rIBASE # restore rIBASE
- SET_VREG_HIGH %eax rINST # v[AA+1] <- eax
+ SET_VREG rIBASE, rINST # v[AA+0] <- rIBASE
+ movl LOCAL0(%esp), rIBASE # restore rIBASE
+ SET_VREG_HIGH %eax, rINST # v[AA+1] <- eax
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
* Generic 64-bit binary operation.
*/
/* binop vAA, vBB, vCC */
- movzbl 2(rPC),%eax # eax <- BB
- movzbl 3(rPC),%ecx # ecx <- CC
- movl rIBASE,LOCAL0(%esp) # save rIBASE
- GET_VREG rIBASE %eax # rIBASE <- v[BB+0]
- GET_VREG_HIGH %eax %eax # eax <- v[BB+1]
+ movzbl 2(rPC), %eax # eax <- BB
+ movzbl 3(rPC), %ecx # ecx <- CC
+ movl rIBASE, LOCAL0(%esp) # save rIBASE
+ GET_VREG rIBASE, %eax # rIBASE <- v[BB+0]
+ GET_VREG_HIGH %eax, %eax # eax <- v[BB+1]
orl (rFP,%ecx,4), rIBASE # ex: addl (rFP,%ecx,4),rIBASE
orl 4(rFP,%ecx,4), %eax # ex: adcl 4(rFP,%ecx,4),%eax
- SET_VREG rIBASE rINST # v[AA+0] <- rIBASE
- movl LOCAL0(%esp),rIBASE # restore rIBASE
- SET_VREG_HIGH %eax rINST # v[AA+1] <- eax
+ SET_VREG rIBASE, rINST # v[AA+0] <- rIBASE
+ movl LOCAL0(%esp), rIBASE # restore rIBASE
+ SET_VREG_HIGH %eax, rINST # v[AA+1] <- eax
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
* Generic 64-bit binary operation.
*/
/* binop vAA, vBB, vCC */
- movzbl 2(rPC),%eax # eax <- BB
- movzbl 3(rPC),%ecx # ecx <- CC
- movl rIBASE,LOCAL0(%esp) # save rIBASE
- GET_VREG rIBASE %eax # rIBASE <- v[BB+0]
- GET_VREG_HIGH %eax %eax # eax <- v[BB+1]
+ movzbl 2(rPC), %eax # eax <- BB
+ movzbl 3(rPC), %ecx # ecx <- CC
+ movl rIBASE, LOCAL0(%esp) # save rIBASE
+ GET_VREG rIBASE, %eax # rIBASE <- v[BB+0]
+ GET_VREG_HIGH %eax, %eax # eax <- v[BB+1]
xorl (rFP,%ecx,4), rIBASE # ex: addl (rFP,%ecx,4),rIBASE
xorl 4(rFP,%ecx,4), %eax # ex: adcl 4(rFP,%ecx,4),%eax
- SET_VREG rIBASE rINST # v[AA+0] <- rIBASE
- movl LOCAL0(%esp),rIBASE # restore rIBASE
- SET_VREG_HIGH %eax rINST # v[AA+1] <- eax
+ SET_VREG rIBASE, rINST # v[AA+0] <- rIBASE
+ movl LOCAL0(%esp), rIBASE # restore rIBASE
+ SET_VREG_HIGH %eax, rINST # v[AA+1] <- eax
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
movzbl 2(rPC), %eax # eax <- BB
movzbl 3(rPC), %ecx # ecx <- CC
movl rIBASE, LOCAL0(%esp)
- GET_VREG_HIGH rIBASE %eax # ecx <- v[BB+1]
- GET_VREG %ecx %ecx # ecx <- vCC
- GET_VREG %eax %eax # eax <- v[BB+0]
+ GET_VREG_HIGH rIBASE, %eax # ecx <- v[BB+1]
+ GET_VREG %ecx, %ecx # ecx <- vCC
+ GET_VREG %eax, %eax # eax <- v[BB+0]
shldl %eax,rIBASE
sall %cl, %eax
testb $32, %cl
movl %eax, rIBASE
xorl %eax, %eax
2:
- SET_VREG_HIGH rIBASE rINST # v[AA+1] <- rIBASE
+ SET_VREG_HIGH rIBASE, rINST # v[AA+1] <- rIBASE
movl LOCAL0(%esp), rIBASE
- SET_VREG %eax rINST # v[AA+0] <- %eax
+ SET_VREG %eax, rINST # v[AA+0] <- %eax
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* ------------------------------ */
movzbl 2(rPC), %eax # eax <- BB
movzbl 3(rPC), %ecx # ecx <- CC
movl rIBASE, LOCAL0(%esp)
- GET_VREG_HIGH rIBASE %eax # rIBASE<- v[BB+1]
- GET_VREG %ecx %ecx # ecx <- vCC
- GET_VREG %eax %eax # eax <- v[BB+0]
+ GET_VREG_HIGH rIBASE, %eax # rIBASE<- v[BB+1]
+ GET_VREG %ecx, %ecx # ecx <- vCC
+ GET_VREG %eax, %eax # eax <- v[BB+0]
shrdl rIBASE, %eax
sarl %cl, rIBASE
testb $32, %cl
movl rIBASE, %eax
sarl $31, rIBASE
2:
- SET_VREG_HIGH rIBASE rINST # v[AA+1] <- rIBASE
+ SET_VREG_HIGH rIBASE, rINST # v[AA+1] <- rIBASE
movl LOCAL0(%esp), rIBASE
- SET_VREG %eax rINST # v[AA+0] <- eax
+ SET_VREG %eax, rINST # v[AA+0] <- eax
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* ------------------------------ */
movzbl 2(rPC), %eax # eax <- BB
movzbl 3(rPC), %ecx # ecx <- CC
movl rIBASE, LOCAL0(%esp)
- GET_VREG_HIGH rIBASE %eax # rIBASE <- v[BB+1]
- GET_VREG %ecx %ecx # ecx <- vCC
- GET_VREG %eax %eax # eax <- v[BB+0]
+ GET_VREG_HIGH rIBASE, %eax # rIBASE <- v[BB+1]
+ GET_VREG %ecx, %ecx # ecx <- vCC
+ GET_VREG %eax, %eax # eax <- v[BB+0]
shrdl rIBASE, %eax
shrl %cl, rIBASE
testb $32, %cl
movl rIBASE, %eax
xorl rIBASE, rIBASE
2:
- SET_VREG_HIGH rIBASE rINST # v[AA+1] <- rIBASE
+ SET_VREG_HIGH rIBASE, rINST # v[AA+1] <- rIBASE
movl LOCAL0(%esp), rIBASE
- SET_VREG %eax rINST # v[BB+0] <- eax
+ SET_VREG %eax, rINST # v[BB+0] <- eax
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* ------------------------------ */
/* binop/2addr vA, vB */
movzx rINSTbl, %ecx # ecx <- A+
sarl $4, rINST # rINST <- B
- GET_VREG %eax rINST # eax <- vB
+ GET_VREG %eax, rINST # eax <- vB
andb $0xf, %cl # ecx <- A
addl %eax, (rFP,%ecx,4) # for ex: addl %eax,(rFP,%ecx,4)
CLEAR_REF %ecx
/* binop/2addr vA, vB */
movzx rINSTbl, %ecx # ecx <- A+
sarl $4, rINST # rINST <- B
- GET_VREG %eax rINST # eax <- vB
+ GET_VREG %eax, rINST # eax <- vB
andb $0xf, %cl # ecx <- A
subl %eax, (rFP,%ecx,4) # for ex: addl %eax,(rFP,%ecx,4)
CLEAR_REF %ecx
/* mul vA, vB */
movzx rINSTbl, %ecx # ecx <- A+
sarl $4, rINST # rINST <- B
- GET_VREG %eax rINST # eax <- vB
+ GET_VREG %eax, rINST # eax <- vB
andb $0xf, %cl # ecx <- A
mov rIBASE, LOCAL0(%esp)
imull (rFP,%ecx,4), %eax # trashes rIBASE/edx
mov LOCAL0(%esp), rIBASE
- SET_VREG %eax %ecx
+ SET_VREG %eax, %ecx
ADVANCE_PC_FETCH_AND_GOTO_NEXT 1
/* ------------------------------ */
movzx rINSTbl, %ecx # eax <- BA
mov rIBASE, LOCAL0(%esp)
sarl $4, %ecx # ecx <- B
- GET_VREG %ecx %ecx # eax <- vBB
+ GET_VREG %ecx, %ecx # eax <- vBB
andb $0xf, rINSTbl # rINST <- A
- GET_VREG %eax rINST # eax <- vBB
+ GET_VREG %eax, rINST # eax <- vBB
testl %ecx, %ecx
je common_errDivideByZero
cmpl $-1, %ecx
cmpl $0x80000000, %eax
jne .Lop_div_int_2addr_continue_div2addr
movl $0x80000000, %eax
- SET_VREG %eax rINST
+ SET_VREG %eax, rINST
mov LOCAL0(%esp), rIBASE
ADVANCE_PC_FETCH_AND_GOTO_NEXT 1
.Lop_div_int_2addr_continue_div2addr:
cltd
idivl %ecx
- SET_VREG %eax rINST
+ SET_VREG %eax, rINST
mov LOCAL0(%esp), rIBASE
ADVANCE_PC_FETCH_AND_GOTO_NEXT 1
movzx rINSTbl, %ecx # eax <- BA
mov rIBASE, LOCAL0(%esp)
sarl $4, %ecx # ecx <- B
- GET_VREG %ecx %ecx # eax <- vBB
+ GET_VREG %ecx, %ecx # eax <- vBB
andb $0xf, rINSTbl # rINST <- A
- GET_VREG %eax rINST # eax <- vBB
+ GET_VREG %eax, rINST # eax <- vBB
testl %ecx, %ecx
je common_errDivideByZero
cmpl $-1, %ecx
cmpl $0x80000000, %eax
jne .Lop_rem_int_2addr_continue_div2addr
movl $0, rIBASE
- SET_VREG rIBASE rINST
+ SET_VREG rIBASE, rINST
mov LOCAL0(%esp), rIBASE
ADVANCE_PC_FETCH_AND_GOTO_NEXT 1
.Lop_rem_int_2addr_continue_div2addr:
cltd
idivl %ecx
- SET_VREG rIBASE rINST
+ SET_VREG rIBASE, rINST
mov LOCAL0(%esp), rIBASE
ADVANCE_PC_FETCH_AND_GOTO_NEXT 1
/* binop/2addr vA, vB */
movzx rINSTbl, %ecx # ecx <- A+
sarl $4, rINST # rINST <- B
- GET_VREG %eax rINST # eax <- vB
+ GET_VREG %eax, rINST # eax <- vB
andb $0xf, %cl # ecx <- A
andl %eax, (rFP,%ecx,4) # for ex: addl %eax,(rFP,%ecx,4)
CLEAR_REF %ecx
/* binop/2addr vA, vB */
movzx rINSTbl, %ecx # ecx <- A+
sarl $4, rINST # rINST <- B
- GET_VREG %eax rINST # eax <- vB
+ GET_VREG %eax, rINST # eax <- vB
andb $0xf, %cl # ecx <- A
orl %eax, (rFP,%ecx,4) # for ex: addl %eax,(rFP,%ecx,4)
CLEAR_REF %ecx
/* binop/2addr vA, vB */
movzx rINSTbl, %ecx # ecx <- A+
sarl $4, rINST # rINST <- B
- GET_VREG %eax rINST # eax <- vB
+ GET_VREG %eax, rINST # eax <- vB
andb $0xf, %cl # ecx <- A
xorl %eax, (rFP,%ecx,4) # for ex: addl %eax,(rFP,%ecx,4)
CLEAR_REF %ecx
/* shift/2addr vA, vB */
movzx rINSTbl, %ecx # eax <- BA
sarl $4, %ecx # ecx <- B
- GET_VREG %ecx %ecx # eax <- vBB
+ GET_VREG %ecx, %ecx # eax <- vBB
andb $0xf, rINSTbl # rINST <- A
- GET_VREG %eax rINST # eax <- vAA
+ GET_VREG %eax, rINST # eax <- vAA
sall %cl, %eax # ex: sarl %cl, %eax
- SET_VREG %eax rINST
+ SET_VREG %eax, rINST
ADVANCE_PC_FETCH_AND_GOTO_NEXT 1
/* shift/2addr vA, vB */
movzx rINSTbl, %ecx # eax <- BA
sarl $4, %ecx # ecx <- B
- GET_VREG %ecx %ecx # eax <- vBB
+ GET_VREG %ecx, %ecx # eax <- vBB
andb $0xf, rINSTbl # rINST <- A
- GET_VREG %eax rINST # eax <- vAA
+ GET_VREG %eax, rINST # eax <- vAA
sarl %cl, %eax # ex: sarl %cl, %eax
- SET_VREG %eax rINST
+ SET_VREG %eax, rINST
ADVANCE_PC_FETCH_AND_GOTO_NEXT 1
/* shift/2addr vA, vB */
movzx rINSTbl, %ecx # eax <- BA
sarl $4, %ecx # ecx <- B
- GET_VREG %ecx %ecx # eax <- vBB
+ GET_VREG %ecx, %ecx # eax <- vBB
andb $0xf, rINSTbl # rINST <- A
- GET_VREG %eax rINST # eax <- vAA
+ GET_VREG %eax, rINST # eax <- vAA
shrl %cl, %eax # ex: sarl %cl, %eax
- SET_VREG %eax rINST
+ SET_VREG %eax, rINST
ADVANCE_PC_FETCH_AND_GOTO_NEXT 1
* Generic 64-bit binary operation.
*/
/* binop/2addr vA, vB */
- movzbl rINSTbl,%ecx # ecx<- BA
- sarl $4,%ecx # ecx<- B
- GET_VREG %eax %ecx # eax<- v[B+0]
- GET_VREG_HIGH %ecx %ecx # eax<- v[B+1]
- andb $0xF,rINSTbl # rINST<- A
+ movzbl rINSTbl, %ecx # ecx<- BA
+ sarl $4, %ecx # ecx<- B
+ GET_VREG %eax, %ecx # eax<- v[B+0]
+ GET_VREG_HIGH %ecx, %ecx # eax<- v[B+1]
+ andb $0xF, rINSTbl # rINST<- A
addl %eax, (rFP,rINST,4) # ex: addl %eax,(rFP,rINST,4)
adcl %ecx, 4(rFP,rINST,4) # ex: adcl %ecx,4(rFP,rINST,4)
CLEAR_WIDE_REF rINST
* Generic 64-bit binary operation.
*/
/* binop/2addr vA, vB */
- movzbl rINSTbl,%ecx # ecx<- BA
- sarl $4,%ecx # ecx<- B
- GET_VREG %eax %ecx # eax<- v[B+0]
- GET_VREG_HIGH %ecx %ecx # eax<- v[B+1]
- andb $0xF,rINSTbl # rINST<- A
+ movzbl rINSTbl, %ecx # ecx<- BA
+ sarl $4, %ecx # ecx<- B
+ GET_VREG %eax, %ecx # eax<- v[B+0]
+ GET_VREG_HIGH %ecx, %ecx # eax<- v[B+1]
+ andb $0xF, rINSTbl # rINST<- A
subl %eax, (rFP,rINST,4) # ex: addl %eax,(rFP,rINST,4)
sbbl %ecx, 4(rFP,rINST,4) # ex: adcl %ecx,4(rFP,rINST,4)
CLEAR_WIDE_REF rINST
andb $0xf, rINSTbl # rINST <- A
mov rINST, LOCAL1(%esp) # save rINST/%ebx
movl %ebx, %ecx
- GET_VREG %edx %eax
- GET_VREG_HIGH %ebx %eax
+ GET_VREG %edx, %eax
+ GET_VREG_HIGH %ebx, %eax
movl %edx, %eax
orl %ebx, %eax
jz common_errDivideByZero
- GET_VREG %eax %ecx
- GET_VREG_HIGH %ecx %ecx
- call art_quick_ldiv
+ GET_VREG %eax, %ecx
+ GET_VREG_HIGH %ecx, %ecx
+ call SYMBOL(art_quick_ldiv)
mov LOCAL1(%esp), rINST # restore rINST/%ebx
- SET_VREG_HIGH rIBASE rINST
- SET_VREG %eax rINST
+ SET_VREG_HIGH rIBASE, rINST
+ SET_VREG %eax, rINST
mov LOCAL0(%esp), rIBASE # restore rIBASE/%edx
ADVANCE_PC_FETCH_AND_GOTO_NEXT 1
andb $0xf, rINSTbl # rINST <- A
mov rINST, LOCAL1(%esp) # save rINST/%ebx
movl %ebx, %ecx
- GET_VREG %edx %eax
- GET_VREG_HIGH %ebx %eax
+ GET_VREG %edx, %eax
+ GET_VREG_HIGH %ebx, %eax
movl %edx, %eax
orl %ebx, %eax
jz common_errDivideByZero
- GET_VREG %eax %ecx
- GET_VREG_HIGH %ecx %ecx
- call art_quick_lmod
+ GET_VREG %eax, %ecx
+ GET_VREG_HIGH %ecx, %ecx
+ call SYMBOL(art_quick_lmod)
mov LOCAL1(%esp), rINST # restore rINST/%ebx
- SET_VREG_HIGH rIBASE rINST
- SET_VREG %eax rINST
+ SET_VREG_HIGH rIBASE, rINST
+ SET_VREG %eax, rINST
mov LOCAL0(%esp), rIBASE # restore rIBASE/%edx
ADVANCE_PC_FETCH_AND_GOTO_NEXT 1
* Generic 64-bit binary operation.
*/
/* binop/2addr vA, vB */
- movzbl rINSTbl,%ecx # ecx<- BA
- sarl $4,%ecx # ecx<- B
- GET_VREG %eax %ecx # eax<- v[B+0]
- GET_VREG_HIGH %ecx %ecx # eax<- v[B+1]
- andb $0xF,rINSTbl # rINST<- A
+ movzbl rINSTbl, %ecx # ecx<- BA
+ sarl $4, %ecx # ecx<- B
+ GET_VREG %eax, %ecx # eax<- v[B+0]
+ GET_VREG_HIGH %ecx, %ecx # eax<- v[B+1]
+ andb $0xF, rINSTbl # rINST<- A
andl %eax, (rFP,rINST,4) # ex: addl %eax,(rFP,rINST,4)
andl %ecx, 4(rFP,rINST,4) # ex: adcl %ecx,4(rFP,rINST,4)
CLEAR_WIDE_REF rINST
* Generic 64-bit binary operation.
*/
/* binop/2addr vA, vB */
- movzbl rINSTbl,%ecx # ecx<- BA
- sarl $4,%ecx # ecx<- B
- GET_VREG %eax %ecx # eax<- v[B+0]
- GET_VREG_HIGH %ecx %ecx # eax<- v[B+1]
- andb $0xF,rINSTbl # rINST<- A
+ movzbl rINSTbl, %ecx # ecx<- BA
+ sarl $4, %ecx # ecx<- B
+ GET_VREG %eax, %ecx # eax<- v[B+0]
+ GET_VREG_HIGH %ecx, %ecx # eax<- v[B+1]
+ andb $0xF, rINSTbl # rINST<- A
orl %eax, (rFP,rINST,4) # ex: addl %eax,(rFP,rINST,4)
orl %ecx, 4(rFP,rINST,4) # ex: adcl %ecx,4(rFP,rINST,4)
CLEAR_WIDE_REF rINST
* Generic 64-bit binary operation.
*/
/* binop/2addr vA, vB */
- movzbl rINSTbl,%ecx # ecx<- BA
- sarl $4,%ecx # ecx<- B
- GET_VREG %eax %ecx # eax<- v[B+0]
- GET_VREG_HIGH %ecx %ecx # eax<- v[B+1]
- andb $0xF,rINSTbl # rINST<- A
+ movzbl rINSTbl, %ecx # ecx<- BA
+ sarl $4, %ecx # ecx<- B
+ GET_VREG %eax, %ecx # eax<- v[B+0]
+ GET_VREG_HIGH %ecx, %ecx # eax<- v[B+1]
+ andb $0xF, rINSTbl # rINST<- A
xorl %eax, (rFP,rINST,4) # ex: addl %eax,(rFP,rINST,4)
xorl %ecx, 4(rFP,rINST,4) # ex: adcl %ecx,4(rFP,rINST,4)
CLEAR_WIDE_REF rINST
/* rINSTw gets AA */
movzbl rINSTbl, %ecx # ecx <- BA
andb $0xf, rINSTbl # rINST <- A
- GET_VREG %eax rINST # eax <- v[AA+0]
+ GET_VREG %eax, rINST # eax <- v[AA+0]
sarl $4, %ecx # ecx <- B
movl rIBASE, LOCAL0(%esp)
- GET_VREG_HIGH rIBASE rINST # rIBASE <- v[AA+1]
- GET_VREG %ecx %ecx # ecx <- vBB
+ GET_VREG_HIGH rIBASE, rINST # rIBASE <- v[AA+1]
+ GET_VREG %ecx, %ecx # ecx <- vBB
shldl %eax, rIBASE
sall %cl, %eax
testb $32, %cl
movl %eax, rIBASE
xorl %eax, %eax
2:
- SET_VREG_HIGH rIBASE rINST # v[AA+1] <- rIBASE
+ SET_VREG_HIGH rIBASE, rINST # v[AA+1] <- rIBASE
movl LOCAL0(%esp), rIBASE
- SET_VREG %eax rINST # v[AA+0] <- eax
+ SET_VREG %eax, rINST # v[AA+0] <- eax
ADVANCE_PC_FETCH_AND_GOTO_NEXT 1
/* ------------------------------ */
/* rINSTw gets AA */
movzbl rINSTbl, %ecx # ecx <- BA
andb $0xf, rINSTbl # rINST <- A
- GET_VREG %eax rINST # eax <- v[AA+0]
+ GET_VREG %eax, rINST # eax <- v[AA+0]
sarl $4, %ecx # ecx <- B
movl rIBASE, LOCAL0(%esp)
- GET_VREG_HIGH rIBASE rINST # rIBASE <- v[AA+1]
- GET_VREG %ecx %ecx # ecx <- vBB
+ GET_VREG_HIGH rIBASE, rINST # rIBASE <- v[AA+1]
+ GET_VREG %ecx, %ecx # ecx <- vBB
shrdl rIBASE, %eax
sarl %cl, rIBASE
testb $32, %cl
movl rIBASE, %eax
sarl $31, rIBASE
2:
- SET_VREG_HIGH rIBASE rINST # v[AA+1] <- rIBASE
+ SET_VREG_HIGH rIBASE, rINST # v[AA+1] <- rIBASE
movl LOCAL0(%esp), rIBASE
- SET_VREG %eax rINST # v[AA+0] <- eax
+ SET_VREG %eax, rINST # v[AA+0] <- eax
ADVANCE_PC_FETCH_AND_GOTO_NEXT 1
/* ------------------------------ */
/* rINSTw gets AA */
movzbl rINSTbl, %ecx # ecx <- BA
andb $0xf, rINSTbl # rINST <- A
- GET_VREG %eax rINST # eax <- v[AA+0]
+ GET_VREG %eax, rINST # eax <- v[AA+0]
sarl $4, %ecx # ecx <- B
movl rIBASE, LOCAL0(%esp)
- GET_VREG_HIGH rIBASE rINST # rIBASE <- v[AA+1]
- GET_VREG %ecx %ecx # ecx <- vBB
+ GET_VREG_HIGH rIBASE, rINST # rIBASE <- v[AA+1]
+ GET_VREG %ecx, %ecx # ecx <- vBB
shrdl rIBASE, %eax
shrl %cl, rIBASE
testb $32, %cl
movl rIBASE, %eax
xorl rIBASE, rIBASE
2:
- SET_VREG_HIGH rIBASE rINST # v[AA+1] <- rIBASE
+ SET_VREG_HIGH rIBASE, rINST # v[AA+1] <- rIBASE
movl LOCAL0(%esp), rIBASE
- SET_VREG %eax rINST # v[AA+0] <- eax
+ SET_VREG %eax, rINST # v[AA+0] <- eax
ADVANCE_PC_FETCH_AND_GOTO_NEXT 1
/* ------------------------------ */
/* binop/lit16 vA, vB, #+CCCC */
movzbl rINSTbl, %eax # eax <- 000000BA
sarl $4, %eax # eax <- B
- GET_VREG %eax %eax # eax <- vB
+ GET_VREG %eax, %eax # eax <- vB
movswl 2(rPC), %ecx # ecx <- ssssCCCC
andb $0xf, rINSTbl # rINST <- A
addl %ecx, %eax # for example: addl %ecx, %eax
- SET_VREG %eax rINST
+ SET_VREG %eax, rINST
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* binop/lit16 vA, vB, #+CCCC */
movzbl rINSTbl, %eax # eax <- 000000BA
sarl $4, %eax # eax <- B
- GET_VREG %eax %eax # eax <- vB
+ GET_VREG %eax, %eax # eax <- vB
movswl 2(rPC), %ecx # ecx <- ssssCCCC
andb $0xf, rINSTbl # rINST <- A
subl %eax, %ecx # for example: addl %ecx, %eax
- SET_VREG %ecx rINST
+ SET_VREG %ecx, rINST
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* Need A in rINST, ssssCCCC in ecx, vB in eax */
movzbl rINSTbl, %eax # eax <- 000000BA
sarl $4, %eax # eax <- B
- GET_VREG %eax %eax # eax <- vB
+ GET_VREG %eax, %eax # eax <- vB
movswl 2(rPC), %ecx # ecx <- ssssCCCC
andb $0xf, rINSTbl # rINST <- A
mov rIBASE, LOCAL0(%esp)
imull %ecx, %eax # trashes rIBASE/edx
mov LOCAL0(%esp), rIBASE
- SET_VREG %eax rINST
+ SET_VREG %eax, rINST
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* ------------------------------ */
/* Need A in rINST, ssssCCCC in ecx, vB in eax */
movzbl rINSTbl, %eax # eax <- 000000BA
sarl $4, %eax # eax <- B
- GET_VREG %eax %eax # eax <- vB
+ GET_VREG %eax, %eax # eax <- vB
movswl 2(rPC), %ecx # ecx <- ssssCCCC
andb $0xf, rINSTbl # rINST <- A
testl %ecx, %ecx
cmpl $0x80000000, %eax
jne .Lop_div_int_lit16_continue_div
movl $0x80000000, %eax
- SET_VREG %eax rINST
+ SET_VREG %eax, rINST
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
.Lop_div_int_lit16_continue_div:
mov rIBASE, LOCAL0(%esp)
cltd
idivl %ecx
- SET_VREG %eax rINST
+ SET_VREG %eax, rINST
mov LOCAL0(%esp), rIBASE
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* Need A in rINST, ssssCCCC in ecx, vB in eax */
movzbl rINSTbl, %eax # eax <- 000000BA
sarl $4, %eax # eax <- B
- GET_VREG %eax %eax # eax <- vB
+ GET_VREG %eax, %eax # eax <- vB
movswl 2(rPC), %ecx # ecx <- ssssCCCC
andb $0xf, rINSTbl # rINST <- A
testl %ecx, %ecx
cmpl $0x80000000, %eax
jne .Lop_rem_int_lit16_continue_div
movl $0, %eax
- SET_VREG %eax rINST
+ SET_VREG %eax, rINST
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
.Lop_rem_int_lit16_continue_div:
mov rIBASE, LOCAL0(%esp)
cltd
idivl %ecx
- SET_VREG rIBASE rINST
+ SET_VREG rIBASE, rINST
mov LOCAL0(%esp), rIBASE
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* binop/lit16 vA, vB, #+CCCC */
movzbl rINSTbl, %eax # eax <- 000000BA
sarl $4, %eax # eax <- B
- GET_VREG %eax %eax # eax <- vB
+ GET_VREG %eax, %eax # eax <- vB
movswl 2(rPC), %ecx # ecx <- ssssCCCC
andb $0xf, rINSTbl # rINST <- A
andl %ecx, %eax # for example: addl %ecx, %eax
- SET_VREG %eax rINST
+ SET_VREG %eax, rINST
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* binop/lit16 vA, vB, #+CCCC */
movzbl rINSTbl, %eax # eax <- 000000BA
sarl $4, %eax # eax <- B
- GET_VREG %eax %eax # eax <- vB
+ GET_VREG %eax, %eax # eax <- vB
movswl 2(rPC), %ecx # ecx <- ssssCCCC
andb $0xf, rINSTbl # rINST <- A
orl %ecx, %eax # for example: addl %ecx, %eax
- SET_VREG %eax rINST
+ SET_VREG %eax, rINST
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* binop/lit16 vA, vB, #+CCCC */
movzbl rINSTbl, %eax # eax <- 000000BA
sarl $4, %eax # eax <- B
- GET_VREG %eax %eax # eax <- vB
+ GET_VREG %eax, %eax # eax <- vB
movswl 2(rPC), %ecx # ecx <- ssssCCCC
andb $0xf, rINSTbl # rINST <- A
xorl %ecx, %eax # for example: addl %ecx, %eax
- SET_VREG %eax rINST
+ SET_VREG %eax, rINST
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* binop/lit8 vAA, vBB, #+CC */
movzbl 2(rPC), %eax # eax <- BB
movsbl 3(rPC), %ecx # ecx <- ssssssCC
- GET_VREG %eax %eax # eax <- rBB
+ GET_VREG %eax, %eax # eax <- rBB
addl %ecx, %eax # ex: addl %ecx,%eax
- SET_VREG %eax rINST
+ SET_VREG %eax, rINST
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* binop/lit8 vAA, vBB, #+CC */
movzbl 2(rPC), %eax # eax <- BB
movsbl 3(rPC), %ecx # ecx <- ssssssCC
- GET_VREG %eax %eax # eax <- rBB
+ GET_VREG %eax, %eax # eax <- rBB
subl %eax, %ecx # ex: addl %ecx,%eax
- SET_VREG %ecx rINST
+ SET_VREG %ecx, rINST
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* mul/lit8 vAA, vBB, #+CC */
movzbl 2(rPC), %eax # eax <- BB
movsbl 3(rPC), %ecx # ecx <- ssssssCC
- GET_VREG %eax %eax # eax <- rBB
+ GET_VREG %eax, %eax # eax <- rBB
mov rIBASE, LOCAL0(%esp)
imull %ecx, %eax # trashes rIBASE/edx
mov LOCAL0(%esp), rIBASE
- SET_VREG %eax rINST
+ SET_VREG %eax, rINST
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* ------------------------------ */
/* div/rem/lit8 vAA, vBB, #+CC */
movzbl 2(rPC), %eax # eax <- BB
movsbl 3(rPC), %ecx # ecx <- ssssssCC
- GET_VREG %eax %eax # eax <- rBB
+ GET_VREG %eax, %eax # eax <- rBB
testl %ecx, %ecx
je common_errDivideByZero
cmpl $0x80000000, %eax
cmpl $-1, %ecx
jne .Lop_div_int_lit8_continue_div
movl $0x80000000, %eax
- SET_VREG %eax rINST
+ SET_VREG %eax, rINST
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
.Lop_div_int_lit8_continue_div:
mov rIBASE, LOCAL0(%esp)
cltd
idivl %ecx
- SET_VREG %eax rINST
+ SET_VREG %eax, rINST
mov LOCAL0(%esp), rIBASE
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* div/rem/lit8 vAA, vBB, #+CC */
movzbl 2(rPC), %eax # eax <- BB
movsbl 3(rPC), %ecx # ecx <- ssssssCC
- GET_VREG %eax %eax # eax <- rBB
+ GET_VREG %eax, %eax # eax <- rBB
testl %ecx, %ecx
je common_errDivideByZero
cmpl $0x80000000, %eax
cmpl $-1, %ecx
jne .Lop_rem_int_lit8_continue_div
movl $0, %eax
- SET_VREG %eax rINST
+ SET_VREG %eax, rINST
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
.Lop_rem_int_lit8_continue_div:
mov rIBASE, LOCAL0(%esp)
cltd
idivl %ecx
- SET_VREG rIBASE rINST
+ SET_VREG rIBASE, rINST
mov LOCAL0(%esp), rIBASE
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* binop/lit8 vAA, vBB, #+CC */
movzbl 2(rPC), %eax # eax <- BB
movsbl 3(rPC), %ecx # ecx <- ssssssCC
- GET_VREG %eax %eax # eax <- rBB
+ GET_VREG %eax, %eax # eax <- rBB
andl %ecx, %eax # ex: addl %ecx,%eax
- SET_VREG %eax rINST
+ SET_VREG %eax, rINST
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* binop/lit8 vAA, vBB, #+CC */
movzbl 2(rPC), %eax # eax <- BB
movsbl 3(rPC), %ecx # ecx <- ssssssCC
- GET_VREG %eax %eax # eax <- rBB
+ GET_VREG %eax, %eax # eax <- rBB
orl %ecx, %eax # ex: addl %ecx,%eax
- SET_VREG %eax rINST
+ SET_VREG %eax, rINST
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* binop/lit8 vAA, vBB, #+CC */
movzbl 2(rPC), %eax # eax <- BB
movsbl 3(rPC), %ecx # ecx <- ssssssCC
- GET_VREG %eax %eax # eax <- rBB
+ GET_VREG %eax, %eax # eax <- rBB
xorl %ecx, %eax # ex: addl %ecx,%eax
- SET_VREG %eax rINST
+ SET_VREG %eax, rINST
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* binop/lit8 vAA, vBB, #+CC */
movzbl 2(rPC), %eax # eax <- BB
movsbl 3(rPC), %ecx # ecx <- ssssssCC
- GET_VREG %eax %eax # eax <- rBB
+ GET_VREG %eax, %eax # eax <- rBB
sall %cl, %eax # ex: addl %ecx,%eax
- SET_VREG %eax rINST
+ SET_VREG %eax, rINST
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* binop/lit8 vAA, vBB, #+CC */
movzbl 2(rPC), %eax # eax <- BB
movsbl 3(rPC), %ecx # ecx <- ssssssCC
- GET_VREG %eax %eax # eax <- rBB
+ GET_VREG %eax, %eax # eax <- rBB
sarl %cl, %eax # ex: addl %ecx,%eax
- SET_VREG %eax rINST
+ SET_VREG %eax, rINST
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* binop/lit8 vAA, vBB, #+CC */
movzbl 2(rPC), %eax # eax <- BB
movsbl 3(rPC), %ecx # ecx <- ssssssCC
- GET_VREG %eax %eax # eax <- rBB
+ GET_VREG %eax, %eax # eax <- rBB
shrl %cl, %eax # ex: addl %ecx,%eax
- SET_VREG %eax rINST
+ SET_VREG %eax, rINST
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* op vA, vB, offset@CCCC */
movzbl rINSTbl, %ecx # ecx <- BA
sarl $4, %ecx # ecx <- B
- GET_VREG %ecx %ecx # vB (object we're operating on)
+ GET_VREG %ecx, %ecx # vB (object we're operating on)
movzwl 2(rPC), %eax # eax <- field byte offset
testl %ecx, %ecx # is object null?
je common_errNullObject
movl (%ecx,%eax,1), %eax
andb $0xf,rINSTbl # rINST <- A
- SET_VREG %eax rINST # fp[A] <- value
+ SET_VREG %eax, rINST # fp[A] <- value
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* ------------------------------ */
/* iget-wide-quick vA, vB, offset@CCCC */
movzbl rINSTbl, %ecx # ecx <- BA
sarl $4, %ecx # ecx <- B
- GET_VREG %ecx %ecx # vB (object we're operating on)
+ GET_VREG %ecx, %ecx # vB (object we're operating on)
movzwl 2(rPC), %eax # eax <- field byte offset
testl %ecx, %ecx # is object null?
je common_errNullObject
movq (%ecx,%eax,1), %xmm0
andb $0xf, rINSTbl # rINST <- A
- SET_WIDE_FP_VREG %xmm0 rINST
+ SET_WIDE_FP_VREG %xmm0, rINST
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* ------------------------------ */
/* op vA, vB, offset@CCCC */
movzbl rINSTbl, %ecx # ecx <- BA
sarl $4, %ecx # ecx <- B
- GET_VREG %ecx %ecx # vB (object we're operating on)
+ GET_VREG %ecx, %ecx # vB (object we're operating on)
movzwl 2(rPC), %eax # eax <- field byte offset
movl %ecx, OUT_ARG0(%esp)
movl %eax, OUT_ARG1(%esp)
EXPORT_PC
- call artIGetObjectFromMterp # (obj, offset)
+ call SYMBOL(artIGetObjectFromMterp) # (obj, offset)
movl rSELF, %ecx
REFRESH_IBASE_FROM_SELF %ecx
cmpl $0, THREAD_EXCEPTION_OFFSET(%ecx)
jnz MterpException # bail out
andb $0xf,rINSTbl # rINST <- A
- SET_VREG_OBJECT %eax rINST # fp[A] <- value
+ SET_VREG_OBJECT %eax, rINST # fp[A] <- value
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* ------------------------------ */
/* op vA, vB, offset@CCCC */
movzbl rINSTbl, %ecx # ecx <- BA
sarl $4, %ecx # ecx <- B
- GET_VREG %ecx %ecx # vB (object we're operating on)
+ GET_VREG %ecx, %ecx # vB (object we're operating on)
testl %ecx, %ecx # is object null?
je common_errNullObject
andb $0xf, rINSTbl # rINST <- A
- GET_VREG rINST rINST # rINST <- v[A]
+ GET_VREG rINST, rINST # rINST <- v[A]
movzwl 2(rPC), %eax # eax <- field byte offset
movl rINST, (%ecx,%eax,1)
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* iput-wide-quick vA, vB, offset@CCCC */
movzbl rINSTbl, %ecx # ecx<- BA
sarl $4, %ecx # ecx<- B
- GET_VREG %ecx %ecx # vB (object we're operating on)
+ GET_VREG %ecx, %ecx # vB (object we're operating on)
testl %ecx, %ecx # is object null?
je common_errNullObject
movzwl 2(rPC), %eax # eax<- field byte offset
leal (%ecx,%eax,1), %ecx # ecx<- Address of 64-bit target
andb $0xf, rINSTbl # rINST<- A
- GET_WIDE_FP_VREG %xmm0 rINST # xmm0<- fp[A]/fp[A+1]
+ GET_WIDE_FP_VREG %xmm0, rINST # xmm0<- fp[A]/fp[A+1]
movq %xmm0, (%ecx) # obj.field<- r0/r1
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
movl rPC, OUT_ARG1(%esp)
REFRESH_INST 232
movl rINST, OUT_ARG2(%esp)
- call MterpIputObjectQuick
+ call SYMBOL(MterpIputObjectQuick)
testl %eax, %eax
jz MterpException
REFRESH_IBASE
movl rPC, OUT_ARG2(%esp)
REFRESH_INST 233
movl rINST, OUT_ARG3(%esp)
- call MterpInvokeVirtualQuick
+ call SYMBOL(MterpInvokeVirtualQuick)
testl %eax, %eax
jz MterpException
REFRESH_IBASE
movl rPC, OUT_ARG2(%esp)
REFRESH_INST 234
movl rINST, OUT_ARG3(%esp)
- call MterpInvokeVirtualQuickRange
+ call SYMBOL(MterpInvokeVirtualQuickRange)
testl %eax, %eax
jz MterpException
REFRESH_IBASE
/* op vA, vB, offset@CCCC */
movzbl rINSTbl, %ecx # ecx <- BA
sarl $4, %ecx # ecx <- B
- GET_VREG %ecx %ecx # vB (object we're operating on)
+ GET_VREG %ecx, %ecx # vB (object we're operating on)
testl %ecx, %ecx # is object null?
je common_errNullObject
andb $0xf, rINSTbl # rINST <- A
- GET_VREG rINST rINST # rINST <- v[A]
+ GET_VREG rINST, rINST # rINST <- v[A]
movzwl 2(rPC), %eax # eax <- field byte offset
movb rINSTbl, (%ecx,%eax,1)
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* op vA, vB, offset@CCCC */
movzbl rINSTbl, %ecx # ecx <- BA
sarl $4, %ecx # ecx <- B
- GET_VREG %ecx %ecx # vB (object we're operating on)
+ GET_VREG %ecx, %ecx # vB (object we're operating on)
testl %ecx, %ecx # is object null?
je common_errNullObject
andb $0xf, rINSTbl # rINST <- A
- GET_VREG rINST rINST # rINST <- v[A]
+ GET_VREG rINST, rINST # rINST <- v[A]
movzwl 2(rPC), %eax # eax <- field byte offset
movb rINSTbl, (%ecx,%eax,1)
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* op vA, vB, offset@CCCC */
movzbl rINSTbl, %ecx # ecx <- BA
sarl $4, %ecx # ecx <- B
- GET_VREG %ecx %ecx # vB (object we're operating on)
+ GET_VREG %ecx, %ecx # vB (object we're operating on)
testl %ecx, %ecx # is object null?
je common_errNullObject
andb $0xf, rINSTbl # rINST <- A
- GET_VREG rINST rINST # rINST <- v[A]
+ GET_VREG rINST, rINST # rINST <- v[A]
movzwl 2(rPC), %eax # eax <- field byte offset
movw rINSTw, (%ecx,%eax,1)
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* op vA, vB, offset@CCCC */
movzbl rINSTbl, %ecx # ecx <- BA
sarl $4, %ecx # ecx <- B
- GET_VREG %ecx %ecx # vB (object we're operating on)
+ GET_VREG %ecx, %ecx # vB (object we're operating on)
testl %ecx, %ecx # is object null?
je common_errNullObject
andb $0xf, rINSTbl # rINST <- A
- GET_VREG rINST rINST # rINST <- v[A]
+ GET_VREG rINST, rINST # rINST <- v[A]
movzwl 2(rPC), %eax # eax <- field byte offset
movw rINSTw, (%ecx,%eax,1)
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* op vA, vB, offset@CCCC */
movzbl rINSTbl, %ecx # ecx <- BA
sarl $4, %ecx # ecx <- B
- GET_VREG %ecx %ecx # vB (object we're operating on)
+ GET_VREG %ecx, %ecx # vB (object we're operating on)
movzwl 2(rPC), %eax # eax <- field byte offset
testl %ecx, %ecx # is object null?
je common_errNullObject
movsbl (%ecx,%eax,1), %eax
andb $0xf,rINSTbl # rINST <- A
- SET_VREG %eax rINST # fp[A] <- value
+ SET_VREG %eax, rINST # fp[A] <- value
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* op vA, vB, offset@CCCC */
movzbl rINSTbl, %ecx # ecx <- BA
sarl $4, %ecx # ecx <- B
- GET_VREG %ecx %ecx # vB (object we're operating on)
+ GET_VREG %ecx, %ecx # vB (object we're operating on)
movzwl 2(rPC), %eax # eax <- field byte offset
testl %ecx, %ecx # is object null?
je common_errNullObject
movsbl (%ecx,%eax,1), %eax
andb $0xf,rINSTbl # rINST <- A
- SET_VREG %eax rINST # fp[A] <- value
+ SET_VREG %eax, rINST # fp[A] <- value
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* op vA, vB, offset@CCCC */
movzbl rINSTbl, %ecx # ecx <- BA
sarl $4, %ecx # ecx <- B
- GET_VREG %ecx %ecx # vB (object we're operating on)
+ GET_VREG %ecx, %ecx # vB (object we're operating on)
movzwl 2(rPC), %eax # eax <- field byte offset
testl %ecx, %ecx # is object null?
je common_errNullObject
movzwl (%ecx,%eax,1), %eax
andb $0xf,rINSTbl # rINST <- A
- SET_VREG %eax rINST # fp[A] <- value
+ SET_VREG %eax, rINST # fp[A] <- value
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
/* op vA, vB, offset@CCCC */
movzbl rINSTbl, %ecx # ecx <- BA
sarl $4, %ecx # ecx <- B
- GET_VREG %ecx %ecx # vB (object we're operating on)
+ GET_VREG %ecx, %ecx # vB (object we're operating on)
movzwl 2(rPC), %eax # eax <- field byte offset
testl %ecx, %ecx # is object null?
je common_errNullObject
movswl (%ecx,%eax,1), %eax
andb $0xf,rINSTbl # rINST <- A
- SET_VREG %eax rINST # fp[A] <- value
+ SET_VREG %eax, rINST # fp[A] <- value
ADVANCE_PC_FETCH_AND_GOTO_NEXT 2
.balign 128
- .size artMterpAsmInstructionStart, .-artMterpAsmInstructionStart
- .global artMterpAsmInstructionEnd
-artMterpAsmInstructionEnd:
+ SIZE(SYMBOL(artMterpAsmInstructionStart),SYMBOL(artMterpAsmInstructionStart))
+ .global SYMBOL(artMterpAsmInstructionEnd)
+SYMBOL(artMterpAsmInstructionEnd):
/*
* ===========================================================================
* Sister implementations
* ===========================================================================
*/
- .global artMterpAsmSisterStart
- .type artMterpAsmSisterStart, %function
+ .global SYMBOL(artMterpAsmSisterStart)
+ FUNCTION_TYPE(SYMBOL(artMterpAsmSisterStart))
.text
.balign 4
-artMterpAsmSisterStart:
+SYMBOL(artMterpAsmSisterStart):
- .size artMterpAsmSisterStart, .-artMterpAsmSisterStart
- .global artMterpAsmSisterEnd
-artMterpAsmSisterEnd:
+ SIZE(SYMBOL(artMterpAsmSisterStart),SYMBOL(artMterpAsmSisterStart))
+ .global SYMBOL(artMterpAsmSisterEnd)
+SYMBOL(artMterpAsmSisterEnd):
- .global artMterpAsmAltInstructionStart
- .type artMterpAsmAltInstructionStart, %function
+ .global SYMBOL(artMterpAsmAltInstructionStart)
+ FUNCTION_TYPE(SYMBOL(artMterpAsmAltInstructionStart))
.text
-artMterpAsmAltInstructionStart = .L_ALT_op_nop
+SYMBOL(artMterpAsmAltInstructionStart) = .L_ALT_op_nop
/* ------------------------------ */
.balign 128
.L_ALT_op_nop: /* 0x00 */
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(0*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(1*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(2*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(3*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(4*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(5*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(6*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(7*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(8*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(9*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(10*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(11*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(12*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(13*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(14*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(15*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(16*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(17*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(18*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(19*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(20*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(21*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(22*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(23*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(24*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(25*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(26*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(27*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(28*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(29*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(30*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(31*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(32*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(33*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(34*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(35*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(36*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(37*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(38*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(39*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(40*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(41*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(42*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(43*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(44*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(45*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(46*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(47*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(48*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(49*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(50*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(51*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(52*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(53*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(54*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(55*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(56*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(57*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(58*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(59*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(60*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(61*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(62*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(63*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(64*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(65*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(66*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(67*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(68*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(69*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(70*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(71*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(72*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(73*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(74*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(75*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(76*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(77*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(78*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(79*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(80*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(81*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(82*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(83*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(84*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(85*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(86*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(87*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(88*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(89*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(90*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(91*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(92*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(93*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(94*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(95*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(96*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(97*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(98*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(99*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(100*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(101*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(102*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(103*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(104*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(105*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(106*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(107*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(108*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(109*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(110*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(111*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(112*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(113*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(114*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(115*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(116*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(117*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(118*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(119*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(120*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(121*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(122*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(123*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(124*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(125*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(126*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(127*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(128*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(129*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(130*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(131*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(132*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(133*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(134*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(135*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(136*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(137*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(138*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(139*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(140*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(141*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(142*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(143*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(144*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(145*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(146*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(147*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(148*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(149*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(150*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(151*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(152*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(153*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(154*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(155*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(156*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(157*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(158*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(159*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(160*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(161*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(162*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(163*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(164*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(165*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(166*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(167*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(168*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(169*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(170*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(171*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(172*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(173*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(174*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(175*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(176*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(177*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(178*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(179*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(180*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(181*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(182*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(183*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(184*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(185*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(186*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(187*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(188*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(189*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(190*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(191*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(192*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(193*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(194*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(195*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(196*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(197*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(198*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(199*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(200*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(201*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(202*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(203*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(204*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(205*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(206*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(207*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(208*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(209*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(210*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(211*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(212*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(213*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(214*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(215*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(216*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(217*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(218*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(219*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(220*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(221*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(222*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(223*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(224*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(225*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(226*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(227*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(228*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(229*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(230*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(231*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(232*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(233*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(234*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(235*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(236*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(237*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(238*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(239*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(240*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(241*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(242*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(243*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(244*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(245*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(246*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(247*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(248*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(249*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(250*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(251*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(252*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(253*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(254*128)
movl %ecx, OUT_ARG0(%esp)
leal OFF_FP_SHADOWFRAME(rFP), %eax
movl %eax, OUT_ARG1(%esp)
- call MterpCheckBefore # (self, shadow_frame)
+ call SYMBOL(MterpCheckBefore) # (self, shadow_frame)
REFRESH_IBASE
jmp .L_op_nop+(255*128)
.balign 128
- .size artMterpAsmAltInstructionStart, .-artMterpAsmAltInstructionStart
- .global artMterpAsmAltInstructionEnd
-artMterpAsmAltInstructionEnd:
+ SIZE(SYMBOL(artMterpAsmAltInstructionStart),SYMBOL(artMterpAsmAltInstructionStart))
+ .global SYMBOL(artMterpAsmAltInstructionEnd)
+SYMBOL(artMterpAsmAltInstructionEnd):
/* File: x86/footer.S */
/*
* ===========================================================================
movl %eax, OUT_ARG0(%esp)
lea OFF_FP_SHADOWFRAME(rFP), %ecx
movl %ecx, OUT_ARG1(%esp)
- call MterpLogDivideByZeroException
+ call SYMBOL(MterpLogDivideByZeroException)
#endif
jmp MterpCommonFallback
movl %eax, OUT_ARG0(%esp)
lea OFF_FP_SHADOWFRAME(rFP), %ecx
movl %ecx, OUT_ARG1(%esp)
- call MterpLogArrayIndexException
+ call SYMBOL(MterpLogArrayIndexException)
#endif
jmp MterpCommonFallback
movl %eax, OUT_ARG0(%esp)
lea OFF_FP_SHADOWFRAME(rFP), %ecx
movl %ecx, OUT_ARG1(%esp)
- call MterpLogNegativeArraySizeException
+ call SYMBOL(MterpLogNegativeArraySizeException)
#endif
jmp MterpCommonFallback
movl %eax, OUT_ARG0(%esp)
lea OFF_FP_SHADOWFRAME(rFP), %ecx
movl %ecx, OUT_ARG1(%esp)
- call MterpLogNoSuchMethodException
+ call SYMBOL(MterpLogNoSuchMethodException)
#endif
jmp MterpCommonFallback
movl %eax, OUT_ARG0(%esp)
lea OFF_FP_SHADOWFRAME(rFP), %ecx
movl %ecx, OUT_ARG1(%esp)
- call MterpLogNullObjectException
+ call SYMBOL(MterpLogNullObjectException)
#endif
jmp MterpCommonFallback
movl %eax, OUT_ARG0(%esp)
lea OFF_FP_SHADOWFRAME(rFP), %ecx
movl %ecx, OUT_ARG0(%esp)
- call MterpLogExceptionThrownException
+ call SYMBOL(MterpLogExceptionThrownException)
#endif
jmp MterpCommonFallback
movl %ecx, OUT_ARG0(%esp)
movl THREAD_FLAGS_OFFSET(%eax), %eax
movl %eax, OUT_ARG2(%esp)
- call MterpLogSuspendFallback
+ call SYMBOL(MterpLogSuspendFallback)
#endif
jmp MterpCommonFallback
movl %eax, OUT_ARG0(%esp)
lea OFF_FP_SHADOWFRAME(rFP), %ecx
movl %ecx, OUT_ARG1(%esp)
- call MterpHandleException
+ call SYMBOL(MterpHandleException)
testl %eax, %eax
jz MterpExceptionReturn
REFRESH_IBASE
testl $(THREAD_SUSPEND_REQUEST | THREAD_CHECKPOINT_REQUEST), THREAD_FLAGS_OFFSET(%eax)
jz 1f
movl %eax, OUT_ARG0(%esp)
- call MterpSuspendCheck
+ call SYMBOL(MterpSuspendCheck)
REFRESH_IBASE
1:
GOTO_NEXT
movl %eax, OUT_ARG0(%esp)
lea OFF_FP_SHADOWFRAME(rFP), %ecx
movl %ecx, OUT_ARG1(%esp)
- call MterpLogFallback
+ call SYMBOL(MterpLogFallback)
#endif
MterpCommonFallback:
xor %eax, %eax
ret
.cfi_endproc
- .size ExecuteMterpImpl, .-ExecuteMterpImpl
+ SIZE(ExecuteMterpImpl,ExecuteMterpImpl)
OSDN Git Service
