📄 bytecodes.h
字号:
double lvalue = GET_DOUBLE(sp-3);
#endif
#if PROCESSOR_ARCHITECTURE_X86
/* On x86, we have to do some additional magic */
/* to get correct strictfp results. */
JFP_lib_ddiv_x86(lvalue, rvalue);
#else
#if UPTODOWNSTACK
SET_DOUBLE(sp + 2, lvalue / rvalue);
#else
SET_DOUBLE(sp - 3, lvalue / rvalue);
#endif
#endif
lessStack(2);
DONE(1)
#endif
/* --------------------------------------------------------------------- */
#if STANDARDBYTECODES
SELECT(IREM) /* Rem integer */
long rValue = popStack();
long lValue = topStack;
if (rValue == 0) {
goto handleArithmeticException;
} else if (lValue == 0x80000000 && rValue == -1) {
topStack = lValue % 1;
} else {
topStack = lValue % rValue;
}
DONE(1)
#endif
/* --------------------------------------------------------------------- */
#if STANDARDBYTECODES
SELECT(LREM) /* Rem long */
#if UPTODOWNSTACK
long64 rvalue = GET_LONG(sp);
long64 lvalue = GET_LONG(sp + 2);
#else
long64 rvalue = GET_LONG(sp - 1);
long64 lvalue = GET_LONG(sp - 3);
#endif
if (ll_zero_eq(rvalue)) {
goto handleArithmeticException;
} else {
#if UPTODOWNSTACK
SET_LONG(sp + 2, ll_rem(lvalue, rvalue));
#else
SET_LONG(sp - 3, ll_rem(lvalue, rvalue));
#endif
lessStack(2);
}
DONE(1)
#endif
/* --------------------------------------------------------------------- */
#if FLOATBYTECODES
SELECT(FREM) /* Rem float */
float result;
#if UPTODOWNSTACK
float rvalue = *(float*)sp++;
float lvalue = *(float*)sp;
#else
float rvalue = *(float*)sp--;
float lvalue = *(float*)sp;
#endif
#if PROCESSOR_ARCHITECTURE_X86
/* On x86, we have to do some additional magic */
/* to get correct strictfp results. */
JFP_lib_frem_x86(lvalue, rvalue);
#else
result = (float)DOUBLE_REMAINDER(lvalue, rvalue);
*(float *)sp = result;
#endif
DONE(1)
#endif
/* --------------------------------------------------------------------- */
#if FLOATBYTECODES
SELECT(DREM) /* Rem double */
double result;
#if UPTODOWNSTACK
double rvalue = GET_DOUBLE(sp);
double lvalue = GET_DOUBLE(sp+2);
#else
double rvalue = GET_DOUBLE(sp-1);
double lvalue = GET_DOUBLE(sp-3);
#endif
#if PROCESSOR_ARCHITECTURE_X86
/* On x86, we have to do some additional magic */
/* to get correct strictfp results. */
JFP_lib_drem_x86(lvalue, rvalue);
#else
result = DOUBLE_REMAINDER(lvalue, rvalue);
#if UPTODOWNSTACK
SET_DOUBLE(sp+2, result);
#else
SET_DOUBLE(sp-3, result);
#endif
#endif
lessStack(2);
DONE(1)
#endif
/* --------------------------------------------------------------------- */
#if STANDARDBYTECODES
SELECT(INEG) /* Negate integer */
*(long*)sp = 0 - *(long*)sp;
DONE(1)
#endif
/* --------------------------------------------------------------------- */
#if STANDARDBYTECODES
SELECT(LNEG) /* Negate long */
#if UPTODOWNSTACK
long64 lvalue = GET_LONG(sp);
ll_negate(lvalue);
SET_LONG(sp, lvalue);
#else
long64 lvalue = GET_LONG(sp - 1);
ll_negate(lvalue);
SET_LONG(sp - 1, lvalue);
#endif /* UPTODOWNSTACK */
DONE(1)
#endif
/* --------------------------------------------------------------------- */
#if FLOATBYTECODES
SELECT(FNEG) /* Negate float */
*(float*)sp = *(float*)sp * -1.0f;
DONE(1)
#endif
/* --------------------------------------------------------------------- */
#if FLOATBYTECODES
SELECT(DNEG) /* Negate double */
#if UPTODOWNSTACK
double value = - GET_DOUBLE(sp);
SET_DOUBLE(sp, value);
#else
double value = - GET_DOUBLE(sp-1);
SET_DOUBLE(sp-1, value);
#endif
DONE(1)
#endif
/* --------------------------------------------------------------------- */
#if STANDARDBYTECODES
SELECT(ISHL) /* Arithmetic shift left integer */
/* Note: shift range is limited to 31 (0x1F) */
long s = popStack() & 0x0000001F;
*(long*)sp <<= s;
DONE(1)
#endif
/* --------------------------------------------------------------------- */
#if STANDARDBYTECODES
SELECT(LSHL) /* Arithmetic shift left long */
/* Note: shift range is limited to 63 (0x3F) */
long s = popStack() & 0x0000003F;
#if UPTODOWNSTACK
long64 value = GET_LONG(sp);
SET_LONG(sp, ll_shl(value, s));
#else
long64 value = GET_LONG(sp - 1);
SET_LONG(sp - 1, ll_shl(value, s));
#endif /* UPTODOWNSTACK */
DONE(1)
#endif
/* --------------------------------------------------------------------- */
#if STANDARDBYTECODES
SELECT(ISHR) /* Arithmetic shift right integer */
/* Note: shift range is limited to 31 (0x1F) */
long s = popStack() & 0x0000001F;
/* Extends sign for negative numbers */
*(long*)sp >>= s;
DONE(1)
#endif
/* --------------------------------------------------------------------- */
#if STANDARDBYTECODES
SELECT(LSHR) /* Arithmetic shift right long */
/* Note: shift range is limited to 63 (0x3F) */
long s = popStack() & 0x0000003F;
#if UPTODOWNSTACK
long64 value = GET_LONG(sp);
SET_LONG(sp, ll_shr(value, s));
#else
long64 value = GET_LONG(sp - 1);
SET_LONG(sp - 1, ll_shr(value, s));
#endif /* UPTODOWNSTACK */
DONE(1)
#endif
/* --------------------------------------------------------------------- */
#if STANDARDBYTECODES
SELECT(IUSHR) /* Logical shift right integer */
long s = popStack() & 0x0000001F;
*(unsigned long*)sp >>= s; /* No sign extension */
DONE(1)
#endif
/* --------------------------------------------------------------------- */
#if STANDARDBYTECODES
SELECT(LUSHR) /* Logical shift right long */
long s = popStack() & 0x0000003F;
#if UPTODOWNSTACK
long64 value = GET_LONG(sp);
SET_LONG(sp, ll_ushr(value, s));
#else
long64 value = GET_LONG(sp - 1);
SET_LONG(sp - 1, ll_ushr(value, s));
#endif /* UPTODOWNSTACK */
DONE(1)
#endif
/* --------------------------------------------------------------------- */
#if STANDARDBYTECODES
SELECT(IAND) /* Boolean integer AND */
long temp = popStack();
topStack &= temp;
DONE(1)
#endif
/* --------------------------------------------------------------------- */
#if STANDARDBYTECODES
SELECT(LAND) /* Boolean long AND */
thirdStack &= topStack;
fourthStack &= secondStack;
lessStack(2);
DONE(1)
#endif
/* --------------------------------------------------------------------- */
#if STANDARDBYTECODES
SELECT(IOR) /* Boolean integer OR */
long temp = popStack();
topStack |= temp;
DONE(1)
#endif
/* --------------------------------------------------------------------- */
#if STANDARDBYTECODES
SELECT(LOR) /* Boolean long OR */
thirdStack |= topStack;
fourthStack |= secondStack;
lessStack(2);
DONE(1)
#endif
/* --------------------------------------------------------------------- */
#if STANDARDBYTECODES
SELECT(IXOR) /* Boolean integer XOR */
long temp = popStack();
topStack ^= temp;
DONE(1)
#endif
/* --------------------------------------------------------------------- */
#if STANDARDBYTECODES
SELECT(LXOR) /* Boolean long XOR */
thirdStack ^= topStack;
fourthStack ^= secondStack;
lessStack(2);
DONE(1)
#endif
/* --------------------------------------------------------------------- */
#if STANDARDBYTECODES
SELECT(IINC) /* Increment local variable */
unsigned int index = ip[1];
long value = ((signed char *)ip)[2];
lp[index] = ((long)(lp[index]) + value);
DONE(3)
#endif
/* --------------------------------------------------------------------- */
#if STANDARDBYTECODES
SELECT(I2L) /* Convert integer to long */
long value = *(long *)sp;
#if UPTODOWNSTACK
oneMore;
#if BIG_ENDIAN
((long *)sp)[0] = value >> 31;
#elif LITTLE_ENDIAN || !COMPILER_SUPPORTS_LONG
((long *)sp)[0] = value;
((long *)sp)[1] = value >> 31;
#else
SET_LONG(sp, value);
#endif
#else
#if BIG_ENDIAN
((long *)sp)[1] = value;
((long *)sp)[0] = value >> 31;
#elif LITTLE_ENDIAN || !COMPILER_SUPPORTS_LONG
((long *)sp)[1] = value >> 31;
#else
SET_LONG(sp, value);
#endif
oneMore;
#endif /* UPTODOWNSTACK */
DONE(1)
#endif
/* --------------------------------------------------------------------- */
#if FLOATBYTECODES
SELECT(I2F) /* Convert integer to float */
*(float*)sp = (float)*(long*)sp;
DONE(1)
#endif
/* --------------------------------------------------------------------- */
#if FLOATBYTECODES
SELECT(I2D) /* Convert integer to double */
#if UPTODOWNSTACK
long value = *(long *)sp;
oneMore;
SET_DOUBLE(sp, (double)value);
#else
SET_DOUBLE(sp, (double)*(long*)sp);
oneMore;
#endif /* UPTODOWNSTACK */
DONE(1)
#endif
/* --------------------------------------------------------------------- */
#if STANDARDBYTECODES
SELECT(L2I) /* Convert long to integer */
#if UPTODOWNSTACK
#if BIG_ENDIAN
#elif LITTLE_ENDIAN || !COMPILER_SUPPORTS_LONG
sp[1] = sp[0];
#else
sp[1] = (long)(GET_LONG(sp));
#endif
oneLess;
#else
oneLess;
#if BIG_ENDIAN
sp[0] = sp[1];
#elif LITTLE_ENDIAN || !COMPILER_SUPPORTS_LONG
/* do nothing */
#else
sp[0] = (long)(GET_LONG(sp));
#endif
#endif /* UPTODOWNSTACK */
DONE(1)
#endif
/* --------------------------------------------------------------------- */
#if FLOATBYTECODES
SELECT(L2F) /* Convert long to float */
#if UPTODOWNSTACK
long64 value = GET_LONG(sp);
oneLess;
*(float*)sp = ll2float(value);
#else
oneLess;
*(float*)sp = ll2float(GET_LONG(sp));
#endif
DONE(1)
#endif
/* --------------------------------------------------------------------- */
#if FLOATBYTECODES
SELECT(L2D) /* Convert long to double */
#if UPTODOWNSTACK
double value = ll2double(GET_LONG(sp));
SET_DOUBLE(sp, value);
#else
double value = ll2double(GET_LONG(sp - 1));
SET_DOUBLE(sp - 1, value);
#endif
DONE(1)
#endif
/* --------------------------------------------------------------------- */
#if FLOATBYTECODES
SELECT(F2I) /* Convert float to integer */
/*
* 0x4F000000 = ((float)0x80000000) magic number for Float any
* number >= this number will be a special case
*/
long value = *(long*)sp;
if ((value & 0x7FFFFFFF) >= 0x4F000000) {
if ((value >= F_L_POS_NAN && value <= F_H_POS_NAN) ||
(value >= F_L_NEG_NAN && value <= F_H_NEG_NAN)) {
*(long*)sp = 0; /* NaN */
} else if (value > 0) {
*(long*)sp = MAX_INT; /* +Infinity */
} else if (value < 0) {
*(long*)sp = MIN_INT; /* -Infinity */
}
} else {
*(long*)sp = (long)*(float*)sp;
}
DONE(1)
#endif
/* --------------------------------------------------------------------- */
#if FLOATBYTECODES
SELECT(F2L) /* Convert float to long */
/*
* 0x5F000000 = (0x4F000000 + 2E28) magic number for Float
* any number >= this number will be a special case
*/
long value = *(long*)sp;
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -