Index: port/src/encoder/ia32_em64t/enc_base.cpp =================================================================== --- port/src/encoder/ia32_em64t/enc_base.cpp (revision 618602) +++ port/src/encoder/ia32_em64t/enc_base.cpp (working copy) @@ -272,7 +272,7 @@ } char * EncoderBase::encode(char * stream, Mnemonic mn, const Operands& opnds) -{ +{ #ifdef _DEBUG if (opnds.count() > 0) { if (opnds[0].is_mem()) { Index: port/src/encoder/ia32_em64t/encoder.h =================================================================== --- port/src/encoder/ia32_em64t/encoder.h (revision 618602) +++ port/src/encoder/ia32_em64t/encoder.h (working copy) @@ -678,7 +678,7 @@ ENCODER_DECLARE_EXPORT char * fprem(char * stream); ENCODER_DECLARE_EXPORT char * fprem1(char * stream); //!char *math_frndint(char * stream); -//!char *math_fsqrt(char * stream); +//ENCODER_DECLARE_EXPORT !char * fsqrt(char * stream); //!char *math_fptan(char * stream); // Index: port/src/encoder/ia32_em64t/enc_tabl.cpp =================================================================== --- port/src/encoder/ia32_em64t/enc_tabl.cpp (revision 618602) +++ port/src/encoder/ia32_em64t/enc_tabl.cpp (working copy) @@ -618,10 +618,10 @@ ***** FPU operations ***** ****************************************************************************/ -BEGIN_MNEMONIC(FADDP, MF_NONE, U ) +BEGIN_MNEMONIC(FADDP, MF_NONE, DU ) BEGIN_OPCODES() - {OpcodeInfo::all, {0xDE, 0xC1}, {FP0D, FP1D}, DU_U }, - {OpcodeInfo::all, {0xDE, 0xC1}, {FP0S, FP1S}, DU_U }, + {OpcodeInfo::all, {0xDE, 0xC1}, {FP0D}, DU }, + {OpcodeInfo::all, {0xDE, 0xC1}, {FP0S}, DU }, END_OPCODES() END_MNEMONIC() @@ -639,10 +639,10 @@ END_OPCODES() END_MNEMONIC() -BEGIN_MNEMONIC(FSUBP, MF_NONE, U ) +BEGIN_MNEMONIC(FSUBP, MF_NONE, DU ) BEGIN_OPCODES() - {OpcodeInfo::all, {0xDE, 0xE9}, {FP0D, FP1D}, DU_U }, - {OpcodeInfo::all, {0xDE, 0xE9}, {FP0S, FP1S}, DU_U }, + {OpcodeInfo::all, {0xDE, 0xE9}, {FP0D}, DU }, + {OpcodeInfo::all, {0xDE, 0xE9}, {FP0S}, DU }, END_OPCODES() END_MNEMONIC() @@ -652,6 +652,15 @@ {OpcodeInfo::all, {0xD8, _4}, {FP0S, m32}, DU_U }, END_OPCODES() END_MNEMONIC() + +BEGIN_MNEMONIC(FISUB, MF_NONE, U ) +BEGIN_OPCODES() + {OpcodeInfo::all, {0xDA, _4}, {FP0S, m32}, DU_U }, +// {OpcodeInfo::all, {0xDE, _4}, {FP0S, m16}, DU_U }, +END_OPCODES() +END_MNEMONIC() + + BEGIN_MNEMONIC(FMUL, MF_NONE, DU_U ) BEGIN_OPCODES() @@ -660,17 +669,17 @@ END_OPCODES() END_MNEMONIC() -BEGIN_MNEMONIC(FMULP, MF_NONE, U ) +BEGIN_MNEMONIC(FMULP, MF_NONE, DU ) BEGIN_OPCODES() - {OpcodeInfo::all, {0xDE, 0xC9}, {FP0D, FP1D}, DU_U }, - {OpcodeInfo::all, {0xDE, 0xC9}, {FP0S, FP1S}, DU_U }, + {OpcodeInfo::all, {0xDE, 0xC9}, {FP0D}, DU }, + {OpcodeInfo::all, {0xDE, 0xC9}, {FP0S}, DU }, END_OPCODES() END_MNEMONIC() -BEGIN_MNEMONIC(FDIVP, MF_NONE, U ) +BEGIN_MNEMONIC(FDIVP, MF_NONE, DU ) BEGIN_OPCODES() - {OpcodeInfo::all, {0xDE, 0xF9}, {FP0D, FP1D}, DU_U }, - {OpcodeInfo::all, {0xDE, 0xF9}, {FP0S, FP1S}, DU_U }, + {OpcodeInfo::all, {0xDE, 0xF9}, {FP0D}, DU }, + {OpcodeInfo::all, {0xDE, 0xF9}, {FP0S}, DU }, END_OPCODES() END_MNEMONIC() @@ -783,6 +792,28 @@ END_OPCODES() END_MNEMONIC() +BEGIN_MNEMONIC(FLDLG2, MF_NONE, DU ) +BEGIN_OPCODES() + {OpcodeInfo::all, {0xD9, 0xEC}, {FP0S}, DU }, + {OpcodeInfo::all, {0xD9, 0xEC}, {FP0D}, DU }, +END_OPCODES() +END_MNEMONIC() + +BEGIN_MNEMONIC(FLDLN2, MF_NONE, DU ) +BEGIN_OPCODES() + {OpcodeInfo::all, {0xD9, 0xED}, {FP0S}, DU }, + {OpcodeInfo::all, {0xD9, 0xED}, {FP0D}, DU }, +END_OPCODES() +END_MNEMONIC() + +BEGIN_MNEMONIC(FLD1, MF_NONE, DU ) +BEGIN_OPCODES() + {OpcodeInfo::all, {0xD9, 0xE8}, {FP0S}, DU }, + {OpcodeInfo::all, {0xD9, 0xE8}, {FP0D}, DU }, +END_OPCODES() +END_MNEMONIC() + + BEGIN_MNEMONIC(FPREM, MF_NONE, N) BEGIN_OPCODES() {OpcodeInfo::all, {0xD9, 0xF8}, {}, N }, @@ -819,6 +850,93 @@ END_OPCODES() END_MNEMONIC() +BEGIN_MNEMONIC(FSQRT, MF_NONE, DU) + BEGIN_OPCODES() + {OpcodeInfo::all, {0xD9, 0xFA}, {FP0S}, DU }, + {OpcodeInfo::all, {0xD9, 0xFA}, {FP0D}, DU }, + END_OPCODES() +END_MNEMONIC() + + +BEGIN_MNEMONIC(FYL2X, MF_NONE, DU) + BEGIN_OPCODES() + {OpcodeInfo::all, {0xD9, 0xF1}, {FP0S}, DU }, + {OpcodeInfo::all, {0xD9, 0xF1}, {FP0D}, DU }, + END_OPCODES() +END_MNEMONIC() + + +BEGIN_MNEMONIC(FYL2XP1, MF_NONE, DU) + BEGIN_OPCODES() + {OpcodeInfo::all, {0xD9, 0xF9}, {FP0S}, DU }, + {OpcodeInfo::all, {0xD9, 0xF9}, {FP0D}, DU }, + END_OPCODES() +END_MNEMONIC() + +BEGIN_MNEMONIC(F2XM1, MF_NONE, DU) + BEGIN_OPCODES() + {OpcodeInfo::all, {0xD9, 0xF0}, {FP0S}, DU }, + {OpcodeInfo::all, {0xD9, 0xF0}, {FP0D}, DU }, + END_OPCODES() +END_MNEMONIC() + +BEGIN_MNEMONIC(FPATAN, MF_NONE, DU) + BEGIN_OPCODES() + {OpcodeInfo::all, {0xD9, 0xF3}, {FP0S}, DU }, + {OpcodeInfo::all, {0xD9, 0xF3}, {FP0D}, DU }, + END_OPCODES() +END_MNEMONIC() + +BEGIN_MNEMONIC(FXCH, MF_NONE, DU) + BEGIN_OPCODES() + {OpcodeInfo::all, {0xD9, 0xC9}, {FP0S}, DU }, + {OpcodeInfo::all, {0xD9, 0xC9}, {FP0D}, DU }, + END_OPCODES() +END_MNEMONIC() + +BEGIN_MNEMONIC(FSCALE, MF_NONE, DU) + BEGIN_OPCODES() + {OpcodeInfo::all, {0xD9, 0xFD}, {FP0S}, DU }, + {OpcodeInfo::all, {0xD9, 0xFD}, {FP0D}, DU }, + END_OPCODES() +END_MNEMONIC() + + + + + + + + + +BEGIN_MNEMONIC(FABS, MF_NONE, DU) + BEGIN_OPCODES() + {OpcodeInfo::all, {0xD9, 0xE1}, {FP0S}, DU }, + {OpcodeInfo::all, {0xD9, 0xE1}, {FP0D}, DU }, + END_OPCODES() +END_MNEMONIC() + +BEGIN_MNEMONIC(FSIN, MF_NONE, DU) + BEGIN_OPCODES() + {OpcodeInfo::all, {0xD9, 0xFE}, {FP0S}, DU }, + {OpcodeInfo::all, {0xD9, 0xFE}, {FP0D}, DU }, + END_OPCODES() +END_MNEMONIC() + +BEGIN_MNEMONIC(FCOS, MF_NONE, DU) + BEGIN_OPCODES() + {OpcodeInfo::all, {0xD9, 0xFF}, {FP0S}, DU }, + {OpcodeInfo::all, {0xD9, 0xFF}, {FP0D}, DU }, + END_OPCODES() +END_MNEMONIC() + +BEGIN_MNEMONIC(FPTAN, MF_NONE, DU) + BEGIN_OPCODES() + {OpcodeInfo::all, {0xD9, 0xF2}, {FP0S}, DU }, + {OpcodeInfo::all, {0xD9, 0xF2}, {FP0D}, DU }, + END_OPCODES() +END_MNEMONIC() + // // ~ FPU // Index: port/src/encoder/ia32_em64t/enc_defs.h =================================================================== --- port/src/encoder/ia32_em64t/enc_defs.h (revision 618602) +++ port/src/encoder/ia32_em64t/enc_defs.h (working copy) @@ -478,6 +478,7 @@ Mnemonic_FADD, Mnemonic_FSUBP, Mnemonic_FSUB, +Mnemonic_FISUB, Mnemonic_FMUL, Mnemonic_FMULP, Mnemonic_FDIVP, @@ -490,6 +491,10 @@ //Mnemonic_FDECSTP, // Decrement Stack-Top Pointer Mnemonic_FILD, // Load Integer Mnemonic_FLD, // Load Floating Point Value +Mnemonic_FLDLG2, +Mnemonic_FLDLN2, +Mnemonic_FLD1, + Mnemonic_FCLEX, // Clear Exceptions Mnemonic_FCHS, // Change sign of ST0 Mnemonic_FNCLEX, // Clear Exceptions @@ -502,7 +507,20 @@ Mnemonic_FPREM1, // Partial Remainder Mnemonic_FST, // Store Floating Point Value Mnemonic_FSTP, // Store Floating Point Value and pop the FP stack +Mnemonic_FSQRT, //Computes the square root of the source value in the stack and pop the FP stack +Mnemonic_FABS, //Computes the absolute value of the source value in the stack and pop the FP stack +Mnemonic_FSIN, //Computes the sine of the source value in the stack and pop the FP stack +Mnemonic_FCOS, //Computes the cosine of the source value in the stack and pop the FP stack +Mnemonic_FPTAN, //Computes the tangent of the source value in the stack and pop the FP stack +Mnemonic_FYL2X, +Mnemonic_FYL2XP1, +Mnemonic_F2XM1, +Mnemonic_FPATAN, +Mnemonic_FXCH, +Mnemonic_FSCALE, + + Mnemonic_XCHG, Mnemonic_DIV, // Unsigned Divide Mnemonic_IDIV, // Signed Divide Index: jitrino/src/codegenerator/ia32/Ia32Inst.h =================================================================== --- jitrino/src/codegenerator/ia32/Ia32Inst.h (revision 618602) +++ jitrino/src/codegenerator/ia32/Ia32Inst.h (working copy) @@ -756,7 +756,15 @@ m==Mnemonic_POPFD || m==Mnemonic_PUSHFD || m==Mnemonic_POP || - m==Mnemonic_PUSH ) + m==Mnemonic_PUSH || + m==Mnemonic_FSTP || + m==Mnemonic_FST || + m==Mnemonic_FIST || + m==Mnemonic_FLD || + m==Mnemonic_FILD || + m==Mnemonic_FLDLN2 || + m==Mnemonic_FLDLG2 || + m==Mnemonic_FLD1 ) { return true; } Index: jitrino/src/codegenerator/ia32/Ia32APIMagics.cpp =================================================================== --- jitrino/src/codegenerator/ia32/Ia32APIMagics.cpp (revision 618602) +++ jitrino/src/codegenerator/ia32/Ia32APIMagics.cpp (working copy) @@ -62,6 +62,8 @@ void convertIntToInt(Opnd* dst, Opnd* src, Node* node); Opnd* addElemIndexWithLEA(Opnd* array, Opnd* index, Node* node); + Opnd* getOpnd(Opnd* arg); + Opnd* getDoubleTypeOpnd(); IRManager* irm; CallInst* callInst; @@ -78,14 +80,55 @@ virtual void run();\ };\ +#define DECLARE_HELPER_INLINER_MATH(name)\ +class name : public APIMagicHandler {\ +public:\ + Mnemonic mnemonic;\ + name (IRManager* irm, CallInst* inst, MethodDesc* md, Mnemonic mn)\ + : APIMagicHandler(irm, inst, md){name::mnemonic=mn;}\ + \ + virtual void run();\ +};\ + +#define DECLARE_HELPER_INLINER_MATH_EXT(name)\ +class name : public APIMagicHandler {\ +public:\ + boolean flag;\ + name (IRManager* irm, CallInst* inst, MethodDesc* md, boolean isSet)\ + : APIMagicHandler(irm, inst, md){name::flag = isSet;}\ + \ + virtual void run();\ +};\ + + +#define DECLARE_HELPER_INLINER_MATH_LOG(name)\ +class name : public APIMagicHandler {\ +public:\ + boolean flag;\ + Mnemonic mnemonic;\ + name (IRManager* irm, CallInst* inst, MethodDesc* md, Mnemonic mn, boolean isSet)\ + : APIMagicHandler(irm, inst, md){name::mnemonic=mn; name::flag = isSet;}\ + \ + virtual void run();\ +};\ + + + DECLARE_HELPER_INLINER(Integer_numberOfLeadingZeros_Handler_x_I_x_I); DECLARE_HELPER_INLINER(Integer_numberOfTrailingZeros_Handler_x_I_x_I); DECLARE_HELPER_INLINER(Long_numberOfLeadingZeros_Handler_x_J_x_I); DECLARE_HELPER_INLINER(Long_numberOfTrailingZeros_Handler_x_J_x_I); +DECLARE_HELPER_INLINER_MATH(Math_Handler_x_D_x_D); +DECLARE_HELPER_INLINER(Math_tan_Handler_x_D_x_D); +DECLARE_HELPER_INLINER_MATH_EXT(Math_asincos_Handler_x_D_x_D); +DECLARE_HELPER_INLINER_MATH_EXT(Math_atan_Handler_x_D_x_D); +DECLARE_HELPER_INLINER_MATH_LOG(Math_log_Handler_x_D_x_D); + DECLARE_HELPER_INLINER(String_compareTo_Handler_x_String_x_I); DECLARE_HELPER_INLINER(String_regionMatches_Handler_x_I_x_String_x_I_x_I_x_Z); DECLARE_HELPER_INLINER(String_indexOf_Handler_x_String_x_I_x_I); + void APIMagicsHandlerSession::runImpl() { CompilationContext* cc = getCompilationContext(); MemoryManager tmpMM("Inline API methods"); @@ -127,6 +170,53 @@ } else if (!strcmp(methodName, "numberOfTrailingZeros") && !strcmp(signature, "(J)I")) { handlers.push_back(new (tmpMM) Long_numberOfTrailingZeros_Handler_x_J_x_I(irm, callInst, md)); } + } else if (!strcmp(className, "java/lang/Math") && getBoolArg("Math_as_magic", true)) { + if (!strcmp(signature, "(D)D")) { + if (!strcmp(methodName, "sqrt")) { + handlers.push_back(new (tmpMM) Math_Handler_x_D_x_D(irm, callInst, md, Mnemonic_FSQRT)); + } + if (!strcmp(methodName, "sin")) { + handlers.push_back(new (tmpMM) Math_Handler_x_D_x_D(irm, callInst, md, Mnemonic_FSIN)); + } + if (!strcmp(methodName, "cos")) { + handlers.push_back(new (tmpMM) Math_Handler_x_D_x_D(irm, callInst, md, Mnemonic_FCOS)); + } + if (!strcmp(methodName, "abs")) { + handlers.push_back(new (tmpMM) Math_Handler_x_D_x_D(irm, callInst, md, Mnemonic_FABS)); + } + if (!strcmp(methodName, "tan")) { + handlers.push_back(new (tmpMM) Math_tan_Handler_x_D_x_D(irm, callInst, md)); + } + if (!strcmp(methodName, "log")) { + handlers.push_back(new (tmpMM) Math_log_Handler_x_D_x_D(irm, callInst, md, Mnemonic_FLDLN2, false)); + } + if (!strcmp(methodName, "log10")) { + handlers.push_back(new (tmpMM) Math_log_Handler_x_D_x_D(irm, callInst, md, Mnemonic_FLDLG2, false)); + } + if (!strcmp(methodName, "log1p")) { + handlers.push_back(new (tmpMM) Math_log_Handler_x_D_x_D(irm, callInst, md, Mnemonic_FLDLN2, true)); + } + + if (!strcmp(methodName, "atan")) { + handlers.push_back(new (tmpMM) Math_atan_Handler_x_D_x_D(irm, callInst, md, false)); + } + + if (!strcmp(methodName, "atan2")) { + handlers.push_back(new (tmpMM) Math_atan_Handler_x_D_x_D(irm, callInst, md, true)); + } + + if (!strcmp(methodName, "asin")) { + handlers.push_back(new (tmpMM) Math_asincos_Handler_x_D_x_D(irm, callInst, md, true)); + } + if (!strcmp(methodName, "acos")) { + handlers.push_back(new (tmpMM) Math_asincos_Handler_x_D_x_D(irm, callInst, md, false)); + } + } else { + if (!strcmp(methodName, "abs")) { + handlers.push_back(new (tmpMM) Math_Handler_x_D_x_D(irm, callInst, md, Mnemonic_FABS)); + } + } + } #endif } else if( ri->getKind() == Opnd::RuntimeInfo::Kind_InternalHelperAddress ) { @@ -177,6 +267,108 @@ callInst->unlink(); } +void Math_Handler_x_D_x_D::run() { + Opnd* arg = getCallSrc(callInst, 0); + Opnd* res = getCallDst(callInst); + + Opnd* fp0 = getOpnd(arg); + Node* node = callInst->getNode(); + node->appendInst(irm->newInst(Mnemonic_FLD, fp0, arg)); + node->appendInst(irm->newInst(mnemonic, fp0)); + node->appendInst(irm->newInst(Mnemonic_FSTP, res, fp0)); + callInst->unlink(); +} + +void Math_log_Handler_x_D_x_D::run() { + Opnd* arg = getCallSrc(callInst, 0); + Opnd* res = getCallDst(callInst); + Opnd* fp0 = getDoubleTypeOpnd(); + Node* node = callInst->getNode(); + node->appendInst(irm->newInst(mnemonic, fp0)); + node->appendInst(irm->newInst(Mnemonic_FLD, fp0, arg)); + if (flag) { + node->appendInst(irm->newInst(Mnemonic_FLD1, fp0)); + node->appendInst(irm->newInst(Mnemonic_FADDP, fp0)); + } + node->appendInst(irm->newInst(Mnemonic_FYL2X, fp0)); + node->appendInst(irm->newInst(Mnemonic_FSTP, res, fp0)); + callInst->unlink(); +} + +void Math_atan_Handler_x_D_x_D::run() { + Opnd* arg = getCallSrc(callInst, 0); + Opnd* res = getCallDst(callInst); + + Opnd* fp0 = getDoubleTypeOpnd(); + Node* node = callInst->getNode(); + node->appendInst(irm->newInst(Mnemonic_FLD, fp0, arg)); + if (flag) { + node->appendInst(irm->newInst(Mnemonic_FLD, fp0, getCallSrc(callInst, 1))); + node->appendInst(irm->newInst(Mnemonic_FDIVP, fp0)); + } + node->appendInst(irm->newInst(Mnemonic_FLD1, fp0)); + node->appendInst(irm->newInst(Mnemonic_FPATAN, fp0)); + node->appendInst(irm->newInst(Mnemonic_FSTP, res, fp0)); + callInst->unlink(); +} + + + + +void Math_asincos_Handler_x_D_x_D::run() { + Opnd* arg = getCallSrc(callInst, 0); + Opnd* res = getCallDst(callInst); + + Opnd* fp0 = getDoubleTypeOpnd(); + Node* node = callInst->getNode(); + node->appendInst(irm->newInst(Mnemonic_FLD, fp0, arg)); + node->appendInst(irm->newInst(Mnemonic_FLD1, fp0)); + node->appendInst(irm->newInst(Mnemonic_FLD, fp0, arg)); + node->appendInst(irm->newInst(Mnemonic_FLD, fp0, arg)); + node->appendInst(irm->newInst(Mnemonic_FMULP, fp0)); + node->appendInst(irm->newInst(Mnemonic_FSUBP, fp0)); + node->appendInst(irm->newInst(Mnemonic_FSQRT, fp0)); + if (!flag) { + node->appendInst(irm->newInst(Mnemonic_FXCH, fp0)); + } + node->appendInst(irm->newInst(Mnemonic_FPATAN, fp0)); + node->appendInst(irm->newInst(Mnemonic_FSTP, res, fp0)); + callInst->unlink(); +} + +void Math_tan_Handler_x_D_x_D::run() { + Opnd* arg = getCallSrc(callInst, 0); + Opnd* res = getCallDst(callInst); + Opnd* fp0 = getDoubleTypeOpnd(); + Node* node = callInst->getNode(); + node->appendInst(irm->newInst(Mnemonic_FLD, fp0, arg)); + node->appendInst(irm->newInst(Mnemonic_FPTAN, fp0)); + node->appendInst(irm->newInst(Mnemonic_FSTP, res, fp0)); + node->appendInst(irm->newInst(Mnemonic_FSTP, res, fp0)); + callInst->unlink(); +} + +Opnd* APIMagicHandler::getOpnd(Opnd* arg) { + if (arg->getSize() == OpndSize_64) { + Opnd * fp0Op64 = irm->newOpnd(irm->getTypeManager().getDoubleType(), RegName_FP0D); + fp0Op64->assignRegName(RegName_FP0D); + return fp0Op64; + } else { + Opnd * fp0Op32 = irm->newOpnd(irm->getTypeManager().getSingleType(), RegName_FP0S); + fp0Op32->assignRegName(RegName_FP0S); + return fp0Op32; + + } +} + +Opnd* APIMagicHandler::getDoubleTypeOpnd() { + Opnd * fp0Op64 = irm->newOpnd(irm->getTypeManager().getDoubleType(), RegName_FP0D); + fp0Op64->assignRegName(RegName_FP0D); + return fp0Op64; +} + + + void Integer_numberOfTrailingZeros_Handler_x_I_x_I::run() { //mov r2,32 //bsf r1,arg Index: jitrino/src/optimizer/inliner.cpp =================================================================== --- jitrino/src/optimizer/inliner.cpp (revision 618602) +++ jitrino/src/optimizer/inliner.cpp (working copy) @@ -134,7 +134,26 @@ _inlineSkipMethodTable->add_method_record("java/lang/Integer", "numberOfTrailingZeros", "(I)I", des, false); _inlineSkipMethodTable->add_method_record("java/lang/Long", "numberOfLeadingZeros", "(J)I", des, false); _inlineSkipMethodTable->add_method_record("java/lang/Long", "numberOfTrailingZeros", "(J)I", des, false); + _inlineSkipMethodTable->add_method_record("java/lang/Math", "sqrt", "(D)D", des, false); + _inlineSkipMethodTable->add_method_record("java/lang/Math", "sin", "(D)D", des, false); + _inlineSkipMethodTable->add_method_record("java/lang/Math", "cos", "(D)D", des, false); + _inlineSkipMethodTable->add_method_record("java/lang/Math", "abs", "(J)J", des, false); + _inlineSkipMethodTable->add_method_record("java/lang/Math", "abs", "(I)I", des, false); + _inlineSkipMethodTable->add_method_record("java/lang/Math", "abs", "(J)J", des, false); + _inlineSkipMethodTable->add_method_record("java/lang/Math", "abs", "(F)F", des, false); + _inlineSkipMethodTable->add_method_record("java/lang/Math", "abs", "(D)D", des, false); + _inlineSkipMethodTable->add_method_record("java/lang/Math", "tan", "(D)D", des, false); + _inlineSkipMethodTable->add_method_record("java/lang/Math", "atan", "(D)D", des, false); + _inlineSkipMethodTable->add_method_record("java/lang/Math", "atan2", "(D)D", des, false); + _inlineSkipMethodTable->add_method_record("java/lang/Math", "asin", "(D)D", des, false); + _inlineSkipMethodTable->add_method_record("java/lang/Math", "acos", "(D)D", des, false); + _inlineSkipMethodTable->add_method_record("java/lang/Math", "log", "(D)D", des, false); + _inlineSkipMethodTable->add_method_record("java/lang/Math", "log10", "(D)D", des, false); + _inlineSkipMethodTable->add_method_record("java/lang/Math", "log1p", "(D)D", des, false); + + + #endif if(argSource->getBoolArg("String_compareTo_as_magic",true)) { _inlineSkipMethodTable->add_method_record("java/lang/String", "compareTo", "(Ljava/lang/String;)I", des, false);