Index: jitrino/src/codegenerator/CodeGenIntfc.h =================================================================== --- jitrino/src/codegenerator/CodeGenIntfc.h (revision 560245) +++ jitrino/src/codegenerator/CodeGenIntfc.h (working copy) @@ -152,18 +152,21 @@ }; }; -class IntrinsicCallOp { +/*class IntrinsicCallOp { public: enum Id { CharArrayCopy, ArrayCopyDirect, ArrayCopyReverse }; -}; +};*/ class JitHelperCallOp { public: enum Id { +// CharArrayCopy, + ArrayCopyDirect, + ArrayCopyReverse, InitializeArray, FillArrayWithConst, SaveThisState, @@ -258,7 +261,7 @@ NamedType* vtableType) = 0; virtual CG_OpndHandle* call(uint32 numArgs, CG_OpndHandle** args, Type* retType, MethodDesc *desc) = 0; - virtual CG_OpndHandle* arraycopyReverse(uint32 numArgs, CG_OpndHandle** args) = 0; +// virtual CG_OpndHandle* arraycopyReverse(uint32 numArgs, CG_OpndHandle** args) = 0; virtual CG_OpndHandle* arraycopy(uint32 numArgs, CG_OpndHandle** args) = 0; virtual CG_OpndHandle* tau_call(uint32 numArgs, CG_OpndHandle** args, Type* retType, MethodDesc *desc, @@ -272,10 +275,10 @@ CG_OpndHandle* methodPtr, CG_OpndHandle* tauNullChecked, CG_OpndHandle* tauTypesChecked) = 0; - virtual CG_OpndHandle* tau_callintr(uint32 numArgs, CG_OpndHandle** args, Type* retType, +/* virtual CG_OpndHandle* tau_callintr(uint32 numArgs, CG_OpndHandle** args, Type* retType, IntrinsicCallOp::Id callId, CG_OpndHandle* tauNullChecked, - CG_OpndHandle* tauTypesChecked) = 0; + CG_OpndHandle* tauTypesChecked) = 0;*/ virtual CG_OpndHandle* callhelper(uint32 numArgs, CG_OpndHandle** args, Type* retType, JitHelperCallOp::Id callId) = 0; virtual CG_OpndHandle* callvmhelper(uint32 numArgs, CG_OpndHandle** args, Type* retType, Index: jitrino/src/codegenerator/ia32/Ia32InstCodeSelector.cpp =================================================================== --- jitrino/src/codegenerator/ia32/Ia32InstCodeSelector.cpp (revision 560245) +++ jitrino/src/codegenerator/ia32/Ia32InstCodeSelector.cpp (working copy) @@ -2436,7 +2436,7 @@ { return tau_call(numArgs, args, retType, desc, getTauUnsafe(), getTauUnsafe()); } - +/* //_______________________________________________________________________________________________________________ // reverse copying with 'rep move' instruction // start indexes (args[1] and args[3] must be prepared respectively) @@ -2455,7 +2455,7 @@ return NULL; } - +*/ //_______________________________________________________________________________________________________________ // Transforming System::arraycopy call into 'rep move' @@ -2571,7 +2571,7 @@ return tau_calli(numArgs,args,retType,virtFunAddr,tauNullChecked, tauTypesChecked); } -//_______________________________________________________________________________________________________________ +/*//_______________________________________________________________________________________________________________ // Intrinsic call CG_OpndHandle* InstCodeSelector::callintr(uint32 numArgs, @@ -2596,6 +2596,7 @@ ICS_ASSERT(0); return 0; } +*/ //_______________________________________________________________________________________________________________ // JIT helper call @@ -2610,7 +2611,26 @@ case InitializeArray: assert(numArgs == 4); appendInsts(irManager.newInternalRuntimeHelperCallInst("initialize_array", numArgs, (Opnd**)args, dstOpnd)); - break; + break; + case ArrayCopyDirect: + { + arraycopy(numArgs, args); + + dstOpnd = NULL; + break; + } + case ArrayCopyReverse: + { + appendInsts(irManager.newInst(Mnemonic_PUSHFD)); + appendInsts(irManager.newInst(Mnemonic_STD)); + + arraycopy(numArgs,args); + + appendInsts(irManager.newInst(Mnemonic_POPFD)); + + dstOpnd = NULL; + break; + } case SaveThisState: { assert(numArgs == 1); Index: jitrino/src/codegenerator/ia32/Ia32InstCodeSelector.h =================================================================== --- jitrino/src/codegenerator/ia32/Ia32InstCodeSelector.h (revision 560245) +++ jitrino/src/codegenerator/ia32/Ia32InstCodeSelector.h (working copy) @@ -211,14 +211,14 @@ CG_OpndHandle* methodPtr, CG_OpndHandle* nonNullFirstArgTau, CG_OpndHandle* tauTypesChecked); CG_OpndHandle* call(uint32 numArgs, CG_OpndHandle** args, Type* retType, MethodDesc *desc); - CG_OpndHandle* arraycopyReverse(uint32 numArgs, CG_OpndHandle** args); +// CG_OpndHandle* arraycopyReverse(uint32 numArgs, CG_OpndHandle** args); CG_OpndHandle* arraycopy(uint32 numArgs, CG_OpndHandle** args); CG_OpndHandle* tau_call(uint32 numArgs, CG_OpndHandle** args, Type* retType, MethodDesc *desc, CG_OpndHandle *nonNullFirstArgTau, CG_OpndHandle *tauTypesChecked); CG_OpndHandle* tau_callvirt(uint32 numArgs,CG_OpndHandle** args, Type* retType, MethodDesc *desc, CG_OpndHandle* tauNullChecked, CG_OpndHandle* tauTypesChecked); - CG_OpndHandle* callintr(uint32 numArgs, CG_OpndHandle** args, Type* retType,IntrinsicCallOp::Id callId); - CG_OpndHandle* tau_callintr(uint32 numArgs, CG_OpndHandle** args, Type* retType,IntrinsicCallOp::Id callId, CG_OpndHandle *tauNullsChecked, CG_OpndHandle *tauTypesChecked); +// CG_OpndHandle* callintr(uint32 numArgs, CG_OpndHandle** args, Type* retType,IntrinsicCallOp::Id callId); +// CG_OpndHandle* tau_callintr(uint32 numArgs, CG_OpndHandle** args, Type* retType,IntrinsicCallOp::Id callId, CG_OpndHandle *tauNullsChecked, CG_OpndHandle *tauTypesChecked); CG_OpndHandle* callhelper(uint32 numArgs, CG_OpndHandle** args, Type* retType,JitHelperCallOp::Id callId); CG_OpndHandle* callvmhelper(uint32 numArgs, CG_OpndHandle** args, Type* retType, CompilationInterface::RuntimeHelperId callId); Index: jitrino/src/codegenerator/ipf/include/IpfCodeSelector.h =================================================================== --- jitrino/src/codegenerator/ipf/include/IpfCodeSelector.h (revision 560245) +++ jitrino/src/codegenerator/ipf/include/IpfCodeSelector.h (working copy) @@ -175,7 +175,7 @@ CG_OpndHandle *call(uint32, CG_OpndHandle**, Type*, MethodDesc*); CG_OpndHandle *tau_call(uint32, CG_OpndHandle**, Type*, MethodDesc*, CG_OpndHandle*, CG_OpndHandle*); CG_OpndHandle *tau_calli(uint32,CG_OpndHandle**, Type*, CG_OpndHandle*, CG_OpndHandle*, CG_OpndHandle*); - CG_OpndHandle *tau_callintr(uint32, CG_OpndHandle**, Type*, IntrinsicCallOp::Id, CG_OpndHandle*, CG_OpndHandle*); +// CG_OpndHandle *tau_callintr(uint32, CG_OpndHandle**, Type*, IntrinsicCallOp::Id, CG_OpndHandle*, CG_OpndHandle*); void ret(); void ret(CG_OpndHandle*); @@ -307,7 +307,7 @@ CG_OpndHandle* convToUPtr(PtrType*, CG_OpndHandle*) { NOT_IMPLEMENTED_C("convToUPtr") } CG_OpndHandle *tau_ldIntfTableAddr(Type*, CG_OpndHandle*, NamedType*, CG_OpndHandle*) { NOT_IMPLEMENTED_C("tau_ldIntfTableAddr"); } CG_OpndHandle* tau_ldIntfTableAddr(Type*, CG_OpndHandle*, NamedType*); - CG_OpndHandle* arraycopyReverse(unsigned int, CG_OpndHandle**); +// CG_OpndHandle* arraycopyReverse(unsigned int, CG_OpndHandle**); CG_OpndHandle* arraycopy(unsigned int, CG_OpndHandle**); CG_OpndHandle* addElemIndexWithLEA(Type*, CG_OpndHandle*, CG_OpndHandle*) { NOT_IMPLEMENTED_C("addElemIndexWithLEA") } CG_OpndHandle* ldRef(Type*, MethodDesc*, unsigned int, bool); Index: jitrino/src/codegenerator/ipf/IpfInstCodeSelector.cpp =================================================================== --- jitrino/src/codegenerator/ipf/IpfInstCodeSelector.cpp (revision 560245) +++ jitrino/src/codegenerator/ipf/IpfInstCodeSelector.cpp (working copy) @@ -1303,7 +1303,7 @@ indirectCall(numArgs, (Opnd **)args, retOpnd, (RegOpnd *)methodPtr, p0); return retOpnd; } - +/* //----------------------------------------------------------------------------// // Intrinsic call @@ -1328,7 +1328,7 @@ return retOpnd; } - +*/ //----------------------------------------------------------------------------// void IpfInstCodeSelector::ret() { @@ -1829,10 +1829,10 @@ //----------------------------------------------------------------------------// -CG_OpndHandle* IpfInstCodeSelector::arraycopyReverse(unsigned int numArgs, +/*CG_OpndHandle* IpfInstCodeSelector::arraycopyReverse(unsigned int numArgs, CG_OpndHandle** args) { NOT_IMPLEMENTED_C("arraycopyReverse") -} +} */ //----------------------------------------------------------------------------// // Load address of the field at "base + offset" Index: jitrino/src/dynopt/EdgeProfiler.cpp =================================================================== --- jitrino/src/dynopt/EdgeProfiler.cpp (revision 560245) +++ jitrino/src/dynopt/EdgeProfiler.cpp (working copy) @@ -666,7 +666,7 @@ } Inst* last = (Inst*)node->getLastInst(); // This method is not a leaf method. - if( last->getOpcode() >= Op_DirectCall && last->getOpcode() <= Op_IntrinsicCall ){ + if( last->getOpcode() >= Op_DirectCall && last->getOpcode() <= Op_JitHelperCall/*Op_IntrinsicCall*/ ){ return false; } Edges::const_iterator eiter; Index: jitrino/src/dynopt/StaticProfiler.cpp =================================================================== --- jitrino/src/dynopt/StaticProfiler.cpp (revision 560245) +++ jitrino/src/dynopt/StaticProfiler.cpp (working copy) @@ -415,8 +415,8 @@ static double callHeuristic(const StaticProfilerContext* c) { Node* node1 = c->edge1->getTargetNode(); Node* node2 = c->edge2->getTargetNode(); - bool node1HasCall = findInst(node1, Op_DirectCall, Op_IntrinsicCall)!=NULL; - bool node2HasCall = findInst(node2, Op_DirectCall, Op_IntrinsicCall)!=NULL; + bool node1HasCall = findInst(node1, Op_DirectCall, Op_JitHelperCall/*Op_IntrinsicCall*/)!=NULL; + bool node2HasCall = findInst(node2, Op_DirectCall, Op_JitHelperCall/*Op_IntrinsicCall*/)!=NULL; if (!node1HasCall && !node2HasCall) { return PROB_HEURISTIC_FAIL; Index: jitrino/src/optimizer/codelowerer.h =================================================================== --- jitrino/src/optimizer/codelowerer.h (revision 560245) +++ jitrino/src/optimizer/codelowerer.h (working copy) @@ -136,7 +136,7 @@ Inst* caseIndirectMemoryCall(CallInst* inst) {return caseDefault(inst);} - Inst* caseIntrinsicCall(IntrinsicCallInst* inst) {return caseDefault(inst);} +// Inst* caseIntrinsicCall(IntrinsicCallInst* inst) {return caseDefault(inst);} Inst* caseJitHelperCall(JitHelperCallInst* inst) {return caseDefault(inst);} Index: jitrino/src/optimizer/CodeSelectors.cpp =================================================================== --- jitrino/src/optimizer/CodeSelectors.cpp (revision 560245) +++ jitrino/src/optimizer/CodeSelectors.cpp (working copy) @@ -391,7 +391,7 @@ // // Maps intrinsic id // -IntrinsicCallOp::Id _BlockCodeSelector::convertIntrinsicId(IntrinsicCallId callId) { +/*IntrinsicCallOp::Id _BlockCodeSelector::convertIntrinsicId(IntrinsicCallId callId) { switch(callId) { case CharArrayCopy: return IntrinsicCallOp::CharArrayCopy; case ArrayCopyDirect: return IntrinsicCallOp::ArrayCopyDirect; @@ -399,7 +399,7 @@ } assert(0); return IntrinsicCallOp::CharArrayCopy; // to keep compiler quiet -} +} */ JitHelperCallOp::Id _BlockCodeSelector::convertJitHelperId(JitHelperCallId callId) { switch(callId) { @@ -409,6 +409,9 @@ case LockedCompareAndExchange: return JitHelperCallOp::LockedCompareAndExchange; case AddValueProfileValue: return JitHelperCallOp::AddValueProfileValue; case FillArrayWithConst: return JitHelperCallOp::FillArrayWithConst; +// case CharArrayCopy: return JitHelperCallOp::CharArrayCopy; + case ArrayCopyDirect: return JitHelperCallOp::ArrayCopyDirect; + case ArrayCopyReverse: return JitHelperCallOp::ArrayCopyReverse; } assert(0); return JitHelperCallOp::InitializeArray; // to keep compiler quiet @@ -852,7 +855,7 @@ getCGInst(tauTypesChecked)); } break; - case Op_IntrinsicCall: +/* case Op_IntrinsicCall: { assert(inst->getNumSrcOperands() >= 2); Opnd *tauNullChecked = inst->getSrc(0); @@ -888,7 +891,7 @@ } break; - case Op_JitHelperCall: +*/ case Op_JitHelperCall: { JitHelperCallInst* call = inst->asJitHelperCallInst(); JitHelperCallId callId = call->getJitHelperId(); Index: jitrino/src/optimizer/CodeSelectors.h =================================================================== --- jitrino/src/optimizer/CodeSelectors.h (revision 560245) +++ jitrino/src/optimizer/CodeSelectors.h (working copy) @@ -105,7 +105,7 @@ ConvertToIntOp::OverflowMod mapToIntConvertOvfMod(Inst *inst); // Maps intrinsic id - IntrinsicCallOp::Id convertIntrinsicId(IntrinsicCallId callId); + //IntrinsicCallOp::Id convertIntrinsicId(IntrinsicCallId callId); JitHelperCallOp::Id convertJitHelperId(JitHelperCallId callId); Index: jitrino/src/optimizer/escanalyzer.cpp =================================================================== --- jitrino/src/optimizer/escanalyzer.cpp (revision 560245) +++ jitrino/src/optimizer/escanalyzer.cpp (working copy) @@ -572,6 +572,26 @@ case LockedCompareAndExchange: case AddValueProfileValue: break; + case ArrayCopyDirect: + case ArrayCopyReverse: + { + if (!inst->getDst()->isNull()) { + assert(0); + } + n=inst->getNumSrcOperands(); + addinst=false; + for (uint32 i = 0; i < n; i++) { + Type* tt = inst->getSrc(i)->getType(); + if (!tt->isReference()) { + continue; + } + addinst=true; + break; + } + if (addinst) { + exam2Insts->push_back(inst); + } + } default: assert(0); } @@ -695,7 +715,7 @@ } #endif break; - +/* case Op_IntrinsicCall: // callintr #ifdef _DEBUG if (_instrInfo) { @@ -731,6 +751,7 @@ } #endif break; +*/ case Op_Catch: // catch #ifdef _DEBUG @@ -1073,7 +1094,7 @@ } break; - case Op_IntrinsicCall: // callintr +/* case Op_IntrinsicCall: // callintr n=inst->getNumSrcOperands(); switch(inst->asIntrinsicCallInst()->getIntrinsicId()) { case ArrayCopyDirect: @@ -1090,7 +1111,25 @@ assert(0); } break; +*/ + case Op_JitHelperCall: // calljithelper + n=inst->getNumSrcOperands(); + switch(inst->asJitHelperCallInst()->getJitHelperId()) { + case ArrayCopyDirect: + case ArrayCopyReverse: + cgnode = findCnGNode_op(inst->getSrc(2)->getId()); + assert(cgnode!=NULL); + cgn_src = findCnGNode_op(inst->getSrc(0)->getId()); + assert(cgn_src!=NULL); + addEdge(cgnode,cgn_src,ET_DEFER,inst); + Log::out() << "need to add edge from "<< cgnode->cngNodeId << " - " << cgnode->opndId << " to " + << cgn_src->cngNodeId << " - " << cgn_src->opndId << std::endl; + break; + default: + assert(0); + } + break; case Op_StVar: // stvar if (inst->getDst()->getType()->isObject()) { cgnode = findCnGNode_op(inst->getDst()->getId()); @@ -1438,7 +1477,7 @@ #endif return; } - if (inst->getOpcode() == Op_IntrinsicCall) { //callintr +/* if (inst->getOpcode() == Op_IntrinsicCall) { //callintr uint32 iid = inst->asIntrinsicCallInst()->getIntrinsicId(); switch(iid) { case ArrayCopyDirect: @@ -1453,7 +1492,24 @@ assert(0); } } - if (inst->getOpcode() == Op_LdFieldAddr) { +*/ + if (inst->getOpcode() == Op_JitHelperCall) { //calljithelper + uint32 iid = inst->asJitHelperCallInst()->getJitHelperId(); + switch(iid) { + case ArrayCopyDirect: + case ArrayCopyReverse: +#ifdef _DEBUG + if (_cngedges) { + Log::out() << "++++ addEdge: calljithelper" << std::endl; + } +#endif + return; + default: + assert(0); + } + } + + if (inst->getOpcode() == Op_LdFieldAddr) { FieldDesc* fd=inst->asFieldAccessInst()->getFieldDesc(); if (fd->getParentType()->isSystemString()&&strcmp(fd->getName(),"value")==0) { #ifdef _DEBUG @@ -3045,8 +3101,10 @@ fd->printFullName(os); os << std::endl; } - if (inst->asIntrinsicCallInst()) - os << " IntrinsicCallInst" << std::endl; +/* if (inst->asIntrinsicCallInst()) + os << " IntrinsicCallInst" << std::endl;*/ + if (inst->asJitHelperCallInst()) + os << " JitHelperCallInst" << std::endl; if (inst->asMethodCallInst()) os << " MethodCallInst" << std::endl; if (inst->asMultiSrcInst()) Index: jitrino/src/optimizer/escapeanalyzer.cpp =================================================================== --- jitrino/src/optimizer/escapeanalyzer.cpp (revision 560245) +++ jitrino/src/optimizer/escapeanalyzer.cpp (working copy) @@ -71,7 +71,9 @@ switch (inst->getOpcode()) { case Op_DirectCall: case Op_TauVirtualCall: case Op_IndirectCall: case Op_IndirectMemoryCall: - case Op_IntrinsicCall: +// case Op_IntrinsicCall: + case Op_JitHelperCall: + case Op_Return: case Op_Throw: case Op_TauStInd: case Op_TauStRef: case Op_TauStField: case Op_TauStElem: case Op_TauStStatic: @@ -107,7 +109,7 @@ if (srcIndex == 0) return false; break; - case Op_DirectCall: case Op_TauVirtualCall: case Op_IntrinsicCall: + case Op_DirectCall: case Op_TauVirtualCall: case Op_JitHelperCall://case Op_IntrinsicCall: break; // // return & throw @@ -182,7 +184,7 @@ // // calls should already be marked as escaping // - case Op_DirectCall: case Op_TauVirtualCall: case Op_IntrinsicCall: + case Op_DirectCall: case Op_TauVirtualCall: case Op_JitHelperCall://case Op_IntrinsicCall: case Op_IndirectCall: case Op_IndirectMemoryCall: break; // @@ -339,7 +341,8 @@ break; case Op_DirectCall: case Op_TauVirtualCall: - case Op_IntrinsicCall: + case Op_JitHelperCall: +// case Op_IntrinsicCall: { if (isRefOrPtrType(inst->getDst())) { // this instruction creates a free ptr/ref Index: jitrino/src/optimizer/hashvaluenumberer.cpp =================================================================== --- jitrino/src/optimizer/hashvaluenumberer.cpp (revision 560245) +++ jitrino/src/optimizer/hashvaluenumberer.cpp (working copy) @@ -198,7 +198,7 @@ Inst* caseIndirectMemoryCall(CallInst* inst) { return caseDefault(inst); } - Inst* caseIntrinsicCall(IntrinsicCallInst* inst) { return caseDefault(inst); } +// Inst* caseIntrinsicCall(IntrinsicCallInst* inst) { return caseDefault(inst); } Inst* caseJitHelperCall(JitHelperCallInst* inst) {return caseDefault(inst);} @@ -2311,7 +2311,7 @@ case Op_TauCheckDivOpnds: break; case Op_DirectCall: case Op_TauVirtualCall: case Op_IndirectCall: - case Op_IndirectMemoryCall: case Op_IntrinsicCall: case Op_InitType: + case Op_IndirectMemoryCall: case Op_JitHelperCall:/*case Op_IntrinsicCall:*/ case Op_InitType: break; case Op_TauMonitorExit: break; Index: jitrino/src/optimizer/Inst.cpp =================================================================== --- jitrino/src/optimizer/Inst.cpp (revision 560245) +++ jitrino/src/optimizer/Inst.cpp (working copy) @@ -440,7 +440,7 @@ } } -void IntrinsicCallInst::handlePrintEscape(::std::ostream& os, char code) const { +/*void IntrinsicCallInst::handlePrintEscape(::std::ostream& os, char code) const { switch(code) { case 'd': switch(intrinsicId) { @@ -458,7 +458,7 @@ Inst::handlePrintEscape(os, code); break; } -} +}*/ void JitHelperCallInst::handlePrintEscape(::std::ostream& os, char code) const { switch(code) { @@ -476,6 +476,12 @@ os << "AddValueProfileValue"; break; case FillArrayWithConst: os << "FillArrayWithConst"; break; +/* case CharArrayCopy: + os << "charArrayCopy"; break;*/ + case ArrayCopyDirect: + os << "ArrayCopyDirect"; break; + case ArrayCopyReverse: + os << "ArrayCopyReverse"; break; default: assert(0); break; } @@ -618,9 +624,9 @@ void accept(CatchLabelInst* inst) { clone = instFactory.makeClone(inst, opndManager, renameTable); } - void accept(IntrinsicCallInst* inst) { +/* void accept(IntrinsicCallInst* inst) { clone = instFactory.makeClone(inst, opndManager, renameTable); - } + }*/ void accept(JitHelperCallInst* inst) { clone = instFactory.makeClone(inst, opndManager, renameTable); } @@ -1038,7 +1044,7 @@ return newInst; } -IntrinsicCallInst* +/*IntrinsicCallInst* InstFactory::makeClone(IntrinsicCallInst* inst, OpndManager& opndManager, OpndRenameTable& table) { @@ -1055,7 +1061,7 @@ inst->getIntrinsicId()); newInst->setPersistentInstructionId(inst->getPersistentInstructionId()); return newInst; -} +}*/ JitHelperCallInst* InstFactory::makeClone(JitHelperCallInst* inst, @@ -1572,7 +1578,7 @@ return inst; } -IntrinsicCallInst* +/*IntrinsicCallInst* InstFactory::makeIntrinsicCallInst(Opcode op, Modifier mod, Type::Tag type, Opnd* dst, @@ -1584,7 +1590,7 @@ inst->id = numInsts++; return inst; } - +*/ JitHelperCallInst* InstFactory::makeJitHelperCallInst(Opcode op, Modifier mod, @@ -2019,12 +2025,12 @@ return inst; } -Inst* +/*Inst* InstFactory::makeIntrinsicCall(Opnd* dst, IntrinsicCallId id, Opnd* tauNullChecked, Opnd* tauTypesChecked, - uint32 numArgs, + uint32 numArgs, Opnd** args) { assert(tauNullChecked->getType()->tag == Type::Tau); assert(tauTypesChecked->getType()->tag == Type::Tau); @@ -2032,7 +2038,7 @@ args = copyOpnds(tauNullChecked, tauTypesChecked, args, numArgs); return makeIntrinsicCallInst(Op_IntrinsicCall, Modifier(Exception_Sometimes), returnType, dst, numArgs+2, args, id); -} +}*/ Inst* InstFactory::makeJitHelperCall(Opnd* dst, JitHelperCallId id, uint32 numArgs, Opnd** args) { @@ -2696,7 +2702,7 @@ case Op_TauVirtualCall: return caseTauVirtualCall(inst->asMethodCallInst()); case Op_IndirectCall: return caseIndirectCall(inst->asCallInst()); case Op_IndirectMemoryCall: return caseIndirectMemoryCall(inst->asCallInst()); - case Op_IntrinsicCall: return caseIntrinsicCall(inst->asIntrinsicCallInst()); +// case Op_IntrinsicCall: return caseIntrinsicCall(inst->asIntrinsicCallInst()); case Op_JitHelperCall: return caseJitHelperCall(inst->asJitHelperCallInst()); case Op_VMHelperCall: return caseVMHelperCall(inst->asVMHelperCallInst()); case Op_Return: return caseReturn(inst); Index: jitrino/src/optimizer/Inst.h =================================================================== --- jitrino/src/optimizer/Inst.h (revision 560245) +++ jitrino/src/optimizer/Inst.h (working copy) @@ -69,7 +69,7 @@ class TokenInst; class LinkingExcInst; class CallInst; -class IntrinsicCallInst; +//class IntrinsicCallInst; class JitHelperCallInst; class VMHelperCallInst; class PhiInst; @@ -89,7 +89,7 @@ virtual void accept(CatchLabelInst*) = 0; virtual void accept(ConstInst*) = 0; virtual void accept(DispatchLabelInst*) = 0; - virtual void accept(IntrinsicCallInst*) = 0; +// virtual void accept(IntrinsicCallInst*) = 0; virtual void accept(JitHelperCallInst*) = 0; virtual void accept(VMHelperCallInst*) = 0; virtual void accept(FieldAccessInst*) = 0; @@ -199,9 +199,9 @@ FieldAccessInst* asFieldAccessInst() const { if (isFieldAccess()) return (FieldAccessInst*)this; else return NULL; } - IntrinsicCallInst* asIntrinsicCallInst() const { +/* IntrinsicCallInst* asIntrinsicCallInst() const { if (isIntrinsicCallInst()) return (IntrinsicCallInst*) this; else return NULL; - } + }*/ JitHelperCallInst* asJitHelperCallInst() const { if (isJitHelperCallInst()) return (JitHelperCallInst*) this; else return NULL; } @@ -256,7 +256,7 @@ virtual bool isConst() const { return false; }; virtual bool isDispatchLabel() const { return false; }; virtual bool isFieldAccess() const { return false; }; - virtual bool isIntrinsicCallInst() const { return false; }; +// virtual bool isIntrinsicCallInst() const { return false; }; virtual bool isJitHelperCallInst() const { return false; }; virtual bool isVMHelperCallInst() const { return false; }; virtual bool isMethodCall() const { return false; }; @@ -937,7 +937,7 @@ Opnd** args; }; -// intrinsic calls +/*// intrinsic calls class IntrinsicCallInst : public Inst { public: void visit(InstFormatVisitor& visitor) {visitor.accept(this);} @@ -969,7 +969,7 @@ } Opnd** args; IntrinsicCallId intrinsicId; -}; +};*/ // JIT helper calls class JitHelperCallInst : public Inst { @@ -1131,9 +1131,9 @@ Opnd *tauNullCheckedFirstArg, Opnd *tauTypesChecked, uint32 numArgs, Opnd** args); - Inst* makeIntrinsicCall(Opnd* dst, IntrinsicCallId id, +/* Inst* makeIntrinsicCall(Opnd* dst, IntrinsicCallId id, Opnd* tauNullChecked, Opnd* tauTypesChecked, - uint32 numArgs, Opnd** args); + uint32 numArgs, Opnd** args);*/ Inst* makeJitHelperCall(Opnd* dst, JitHelperCallId id, uint32 numArgs, Opnd** args); Inst* makeVMHelperCall(Opnd* dst, CompilationInterface::RuntimeHelperId id, uint32 numArgs, Opnd** args); @@ -1345,7 +1345,7 @@ MethodInst* makeClone(MethodInst*, OpndManager&, OpndRenameTable&); MethodCallInst* makeClone(MethodCallInst*, OpndManager&, OpndRenameTable&); CallInst* makeClone(CallInst*, OpndManager&, OpndRenameTable&); - IntrinsicCallInst* makeClone(IntrinsicCallInst*, OpndManager&, OpndRenameTable&); +// IntrinsicCallInst* makeClone(IntrinsicCallInst*, OpndManager&, OpndRenameTable&); JitHelperCallInst* makeClone(JitHelperCallInst*, OpndManager&, OpndRenameTable&); VMHelperCallInst* makeClone(VMHelperCallInst*, OpndManager&, OpndRenameTable&); PhiInst* makeClone(PhiInst*, OpndManager&, OpndRenameTable&); @@ -1497,13 +1497,13 @@ Opnd* ptr, uint32 nArgs, Opnd** args); - IntrinsicCallInst* makeIntrinsicCallInst(Opcode op, +/* IntrinsicCallInst* makeIntrinsicCallInst(Opcode op, Modifier mod, Type::Tag, Opnd* dst, uint32 nArgs, Opnd** args_, - IntrinsicCallId id); + IntrinsicCallId id);*/ JitHelperCallInst* makeJitHelperCallInst(Opcode op, Modifier mod, Type::Tag, @@ -1651,8 +1651,8 @@ virtual Inst* caseIndirectMemoryCall(CallInst* inst)=0;//{return caseDefault(inst);} - virtual Inst* - caseIntrinsicCall(IntrinsicCallInst* inst)=0;//{return caseDefault(inst);} +/* virtual Inst* + caseIntrinsicCall(IntrinsicCallInst* inst)=0;//{return caseDefault(inst);}*/ virtual Inst* caseJitHelperCall(JitHelperCallInst* inst)=0;//{return caseDefault(inst);} Index: jitrino/src/optimizer/IRBuilder.cpp =================================================================== --- jitrino/src/optimizer/IRBuilder.cpp (revision 560245) +++ jitrino/src/optimizer/IRBuilder.cpp (working copy) @@ -1395,7 +1395,7 @@ tauTypesChecked, numArgs, args, methodDesc)); return dst; } - +/* Opnd* IRBuilder::genIntrinsicCall(IntrinsicCallId intrinsicId, Type* returnType, @@ -1424,7 +1424,7 @@ numArgs, args)); return dst; } - +*/ Opnd* IRBuilder::genJitHelperCall(JitHelperCallId helperId, Type* returnType, Index: jitrino/src/optimizer/IRBuilder.h =================================================================== --- jitrino/src/optimizer/IRBuilder.h (revision 560245) +++ jitrino/src/optimizer/IRBuilder.h (working copy) @@ -155,14 +155,14 @@ uint32 numArgs, Opnd* args[]); - Opnd* genIntrinsicCall( +/* Opnd* genIntrinsicCall( IntrinsicCallId intrinsicId, //TR Type* returnType, Opnd* tauNullCheckedRefArgs, // 0 for unsafe Opnd* tauTypesChecked, // 0 to let IRBuilder find it uint32 numArgs, Opnd* args[]); - +*/ Opnd* genJitHelperCall(JitHelperCallId helperId, Type* returnType, uint32 numArgs, Index: jitrino/src/optimizer/lazyexceptionopt.cpp =================================================================== --- jitrino/src/optimizer/lazyexceptionopt.cpp (revision 560245) +++ jitrino/src/optimizer/lazyexceptionopt.cpp (working copy) @@ -890,7 +890,7 @@ } #endif return methodCallHasSideEffect(inst); - case Op_IntrinsicCall: +// case Op_IntrinsicCall: case Op_JitHelperCall: case Op_VMHelperCall: return true; Index: jitrino/src/optimizer/memoryopt.cpp =================================================================== --- jitrino/src/optimizer/memoryopt.cpp (revision 560245) +++ jitrino/src/optimizer/memoryopt.cpp (working copy) @@ -618,7 +618,7 @@ thePass->effectAnyGlobal(n, i); } break; - case Op_IntrinsicCall: +/* case Op_IntrinsicCall: { IntrinsicCallInst *calli = i->asIntrinsicCallInst(); IntrinsicCallId callId = calli->getIntrinsicId(); @@ -654,6 +654,7 @@ } } break; +*/ case Op_VMHelperCall: break; case Op_JitHelperCall: @@ -667,6 +668,24 @@ case LockedCompareAndExchange: case AddValueProfileValue: break; + case ArrayCopyDirect: + case ArrayCopyReverse: + { + assert(jitcalli->getNumSrcOperands() == 5); + Opnd *srcarray = jitcalli->getSrc(0); + Opnd *srcoffset = jitcalli->getSrc(1); + Opnd *dstarray = jitcalli->getSrc(2); + Opnd *dstoffset = jitcalli->getSrc(3); + Opnd *length = jitcalli->getSrc(4); + + // effectXXXArrayElements actually does not depends on offset parameter + // so we do not need any special managing for the case of reverse copying + thePass->effectReadArrayLength(n, i, srcarray); + thePass->effectReadArrayElements(n, i, srcarray, srcoffset, length); + thePass->effectReadArrayLength(n, i, dstarray); + thePass->effectWriteArrayElements(n, i, dstarray, dstoffset, length); + break; + } default: assert(0); break; Index: jitrino/src/optimizer/Opcode.cpp =================================================================== --- jitrino/src/optimizer/Opcode.cpp (revision 560245) +++ jitrino/src/optimizer/Opcode.cpp (working copy) @@ -106,7 +106,7 @@ { Op_TauVirtualCall, true, MB::Call, MK::Exception, "callvirt", "callvrt [%2.%d](%a) ((%0,%1)) -) %l %b", }, { Op_IndirectCall, true, MB::Call, MK::Exception, "calli", "calli [%0](%a) ((%1,%2)) -) %l", }, { Op_IndirectMemoryCall, true, MB::Call, MK::Exception, "callimem", "callimem [%0](%a) ((%1,%2)) -) %l", }, - { Op_IntrinsicCall, true, MB::Call, MK::Exception, "callintr", "callintr %d(%p) ((%0,%1)) -) %l", }, +// { Op_IntrinsicCall, true, MB::Call, MK::Exception, "callintr", "callintr %d(%p) ((%0,%1)) -) %l", }, { Op_JitHelperCall, true, MB::Call, MK::Exception, "callhelper", "callhelper %d(%s) -) %l", }, { Op_VMHelperCall, true, MB::Call, MK::Exception, "callvmhelper", "callvmhelper %d(%s) -) %l %b", }, { Op_Return, true, MB::ControlFlow, MK::None, "return", "return %s", }, Index: jitrino/src/optimizer/Opcode.h =================================================================== --- jitrino/src/optimizer/Opcode.h (revision 560245) +++ jitrino/src/optimizer/Opcode.h (working copy) @@ -263,14 +263,16 @@ NewModifier2_BitsConsumed = 2 }; -enum IntrinsicCallId { +/*enum IntrinsicCallId { CharArrayCopy, ArrayCopyDirect, ArrayCopyReverse -}; +};*/ enum JitHelperCallId { InitializeArray, + ArrayCopyDirect, + ArrayCopyReverse, FillArrayWithConst, SaveThisState, //todo: replace with GetTLS + offset sequence ReadThisState, //todo: replace with GetTLS + offset sequence @@ -311,7 +313,7 @@ Op_TauVirtualCall, Op_IndirectCall, Op_IndirectMemoryCall, - Op_IntrinsicCall, +// Op_IntrinsicCall, Op_JitHelperCall, // call to a jit helper routine Op_VMHelperCall, // call to a vm (runtime) helper routine Op_Return, Index: jitrino/src/optimizer/simplifier.h =================================================================== --- jitrino/src/optimizer/simplifier.h (revision 560245) +++ jitrino/src/optimizer/simplifier.h (working copy) @@ -488,7 +488,7 @@ Inst* caseIndirectMemoryCall(CallInst* inst); - Inst* caseIntrinsicCall(IntrinsicCallInst* inst) {return caseDefault(inst);} +// Inst* caseIntrinsicCall(IntrinsicCallInst* inst) {return caseDefault(inst);} Inst* caseJitHelperCall(JitHelperCallInst* inst) {return caseDefault(inst);} Index: jitrino/src/optimizer/simplifytaus.cpp =================================================================== --- jitrino/src/optimizer/simplifytaus.cpp (revision 560245) +++ jitrino/src/optimizer/simplifytaus.cpp (working copy) @@ -477,7 +477,7 @@ case Op_TauVirtualCall: case Op_IndirectCall: case Op_IndirectMemoryCall: - case Op_IntrinsicCall: +// case Op_IntrinsicCall: if (handleCalls) { return genTauSafe(); } else { Index: jitrino/src/translator/java/JavaByteCodeTranslator.cpp =================================================================== --- jitrino/src/translator/java/JavaByteCodeTranslator.cpp (revision 560245) +++ jitrino/src/translator/java/JavaByteCodeTranslator.cpp (working copy) @@ -1612,15 +1612,16 @@ // // Try some optimizations for System::arraycopy(...), Min, Max, Abs... // +// printf("!!!!\n"); if (translationFlags.genArrayCopyRepMove == true && genArrayCopyRepMove(methodDesc,numArgs,srcOpnds)) { return; } else if (translationFlags.genArrayCopy == true && genArrayCopy(methodDesc,numArgs,srcOpnds)) { return; - } else if (translationFlags.genCharArrayCopy == true && +/* } else if (translationFlags.genCharArrayCopy == true && genCharArrayCopy(methodDesc,numArgs,srcOpnds,returnType)) { - return; + return;*/ } else if (translationFlags.genMinMaxAbs == true && genMinMax(methodDesc,numArgs,srcOpnds,returnType)) { return; @@ -2372,7 +2373,188 @@ else return true; } +/* +bool +JavaByteCodeTranslator::genArrayCopyRepMove(MethodDesc * methodDesc, + uint32 numArgs, + Opnd ** srcOpnds) { + if( !methodIsArraycopy(methodDesc) || + !arraycopyOptimizable(methodDesc,numArgs,srcOpnds) ) + { + // reject the inlining of System::arraycopy call + return false; + } + + if (Log::isEnabled()) { + Log::out() << "XXX array copy into 'rep move': "; + methodDesc->printFullName(Log::out()); + Log::out() << ::std::endl; + } + + assert(numArgs == 5); + Opnd * src = srcOpnds[0]; + Opnd * srcPos = srcOpnds[1]; + Type * srcPosType = srcPos->getType(); + Opnd * dst = srcOpnds[2]; + Opnd * dstPos = srcOpnds[3]; + Type * dstPosType = dstPos->getType(); + Opnd * len = srcOpnds[4]; + + // + // Generate exception condition checks: + // chknull src + // chknull dst + // cmpbr srcPos < 0, boundsException + // cmpbr dstPos < 0, boundsException + // cmpbr len < 0, boundsException + // srcEnd = add srcPos, len + // srcLen = src.length + // cmpbr srcEnd > srcLen, boundsException + // dstEnd = add dstPos, len + // dstLen = dst.length + // cmpbr dstEnd > dstLen, boundsException + // Skip trivial: + // cmpbr (src == dst) && (dstPos == srcPos), Exit + // + // Choose method: + // cmpbr (src != dst), Optimizable + // Choose a direction: + // cmpbr (dstPos > srcPos), Reverse + // + // Intrinsic calls will be codeselected into rep move instruction. + // Direct: + // IntrinsicCall id=ArrayCopyDirect + // goto Exit + // Reverse: + // srcPos = srcPos + len - 1 + // dstPos = dstPos + len - 1 + // IntrinsicCall id=ArrayCopyReverse + // goto Exit + // + // Optimizable: + // IntrinsicCall id=ArrayCopyDirect + // goto Exit + // boundsException: + // chkbounds -1, src + // Exit: + // + Opnd *tauSrcNullChecked = irBuilder.genTauCheckNull(src); + Opnd *tauDstNullChecked = irBuilder.genTauCheckNull(dst); + //Opnd *tauNullCheckedRefArgs = irBuilder.genTauAnd(tauSrcNullChecked,tauDstNullChecked); + + LabelInst * reverseCopying = irBuilder.createLabel(); + LabelInst * boundsException = irBuilder.createLabel(); + LabelInst * optimizable = irBuilder.createLabel(); + LabelInst * Exit = irBuilder.createLabel(); + + Type * intType = typeManager.getInt32Type(); + Type::Tag intTag = intType->tag; + Type * voidType = typeManager.getVoidType(); + + newFallthroughBlock(); + Opnd * zero = irBuilder.genLdConstant((int32)0); + Opnd * minusone = irBuilder.genLdConstant((int32)-1); + + irBuilder.genBranch(intTag,Cmp_GT,boundsException,zero,srcPos); + + newFallthroughBlock(); + irBuilder.genBranch(intTag,Cmp_GT,boundsException,zero,dstPos); + + newFallthroughBlock(); + irBuilder.genBranch(intTag,Cmp_GT,boundsException,zero,len); + + Modifier mod = Modifier(Overflow_None)|Modifier(Exception_Never)|Modifier(Strict_No); + + newFallthroughBlock(); + Opnd * srcLen = irBuilder.genArrayLen(intType,intTag,src); + Opnd * srcEnd = irBuilder.genAdd(intType,mod,srcPos,len); + irBuilder.genBranch(intTag,Cmp_GT,boundsException,srcEnd,srcLen); + + newFallthroughBlock(); + Opnd * dstEnd = irBuilder.genAdd(intType,mod,dstPos,len); + Opnd * dstLen = irBuilder.genArrayLen(intType,intTag,dst); + irBuilder.genBranch(intTag,Cmp_GT,boundsException,dstEnd,dstLen); + + newFallthroughBlock(); + + // The case of same arrays and same positions + Opnd * diff = irBuilder.genCmp3(intType,intTag,Cmp_GT,dstPos,srcPos); + Opnd * sameArrays = irBuilder.genCmp(intType,Type::IntPtr,Cmp_EQ,src,dst); + Opnd * zeroDiff = irBuilder.genCmp(intType,intTag,Cmp_EQ,diff,zero); + Opnd * nothingToCopy = irBuilder.genAnd(intType,sameArrays,zeroDiff); + irBuilder.genBranch(intTag,Cmp_GT,Exit,nothingToCopy,zero); + + newFallthroughBlock(); + + //Opnd* tauTypesChecked = irBuilder.genTauSafe(); + + // Checking for opportunity to use optimized method + irBuilder.genBranch(intTag,Cmp_NE_Un,optimizable,src,dst); + + newFallthroughBlock(); + + // Choose direction + irBuilder.genBranch(intTag,Cmp_GT,reverseCopying,dstPos,srcPos); + + newFallthroughBlock(); + + { // Direct Copying +// irBuilder.genIntrinsicCall(ArrayCopyDirect,voidType, +// tauNullCheckedRefArgs, +// tauTypesChecked, +// numArgs,srcOpnds); + irBuilder.genJitHelperCall(ArrayCopyDirect,voidType,numArgs,srcOpnds); + irBuilder.genJump(Exit); + } // End of Direct Copying + + irBuilder.genLabel(reverseCopying); + cfgBuilder.genBlockAfterCurrent(reverseCopying); + { // Reverse Copying + + Opnd* lastSrcIdx = irBuilder.genAdd(srcPosType,mod,srcEnd,minusone); + Opnd* lastDstIdx = irBuilder.genAdd(dstPosType,mod,dstEnd,minusone); + + Opnd** reverseArgs = new (memManager) Opnd*[numArgs]; + reverseArgs[0] = srcOpnds[0]; // src + reverseArgs[1] = lastSrcIdx; // srcPos+len-1 + reverseArgs[2] = srcOpnds[2]; // dst + reverseArgs[3] = lastDstIdx; // dstPos+len-1 + reverseArgs[4] = srcOpnds[4]; // len + // copy +// irBuilder.genIntrinsicCall(ArrayCopyReverse,voidType, +// tauNullCheckedRefArgs, +// tauTypesChecked, +// numArgs,reverseArgs); + irBuilder.genJitHelperCall(ArrayCopyReverse,voidType,numArgs,reverseArgs); + irBuilder.genJump(Exit); + } // End of Reverse Copying + + + irBuilder.genLabel(optimizable); + cfgBuilder.genBlockAfterCurrent(optimizable); + + { // Optimized method (now Direct Copying) +// irBuilder.genIntrinsicCall(ArrayCopyDirect,voidType, +// tauNullCheckedRefArgs, +// tauTypesChecked, +// numArgs,srcOpnds); + irBuilder.genJitHelperCall(ArrayCopyDirect,voidType,numArgs,srcOpnds); + irBuilder.genJump(Exit); + } // End of Optimized method + + + + irBuilder.genLabel(boundsException); + cfgBuilder.genBlockAfterCurrent(boundsException); + irBuilder.genTauCheckBounds(src,minusone,tauSrcNullChecked); + + irBuilder.genLabel(Exit); + cfgBuilder.genBlockAfterCurrent(Exit); + + return true; +}*/ + bool JavaByteCodeTranslator::genArrayCopyRepMove(MethodDesc * methodDesc, uint32 numArgs, @@ -2434,7 +2616,7 @@ // Opnd *tauSrcNullChecked = irBuilder.genTauCheckNull(src); Opnd *tauDstNullChecked = irBuilder.genTauCheckNull(dst); - Opnd *tauNullCheckedRefArgs = irBuilder.genTauAnd(tauSrcNullChecked,tauDstNullChecked); + //Opnd *tauNullCheckedRefArgs = irBuilder.genTauAnd(tauSrcNullChecked,tauDstNullChecked); LabelInst * reverseCopying = irBuilder.createLabel(); LabelInst * boundsException = irBuilder.createLabel(); @@ -2479,7 +2661,7 @@ newFallthroughBlock(); - Opnd* tauTypesChecked = irBuilder.genTauSafe(); + //Opnd* tauTypesChecked = irBuilder.genTauSafe(); // Choosing direction Opnd * dstIsGreater = irBuilder.genCmp(intType,intTag,Cmp_GT,diff,zero); @@ -2489,10 +2671,7 @@ newFallthroughBlock(); { // Direct Copying - irBuilder.genIntrinsicCall(ArrayCopyDirect,voidType, - tauNullCheckedRefArgs, - tauTypesChecked, - numArgs,srcOpnds); + irBuilder.genJitHelperCall(ArrayCopyDirect,voidType,numArgs,srcOpnds); irBuilder.genJump(Exit); } // End of Direct Copying @@ -2510,10 +2689,7 @@ reverseArgs[3] = lastDstIdx; // dstPos+len-1 reverseArgs[4] = srcOpnds[4]; // len // copy - irBuilder.genIntrinsicCall(ArrayCopyReverse,voidType, - tauNullCheckedRefArgs, - tauTypesChecked, - numArgs,reverseArgs); + irBuilder.genJitHelperCall(ArrayCopyReverse,voidType,numArgs,reverseArgs); irBuilder.genJump(Exit); } // End of Reverse Copying @@ -2782,7 +2958,7 @@ return true; } -bool +/*bool JavaByteCodeTranslator::genCharArrayCopy(MethodDesc * methodDesc, uint32 numArgs, Opnd ** srcOpnds, @@ -2882,7 +3058,7 @@ irBuilder.genLabel(L1); cfgBuilder.genBlockAfterCurrent(L1); return true; -} +}*/ bool JavaByteCodeTranslator::genMinMax(MethodDesc * methodDesc, Index: jitrino/src/translator/java/JavaByteCodeTranslator.h =================================================================== --- jitrino/src/translator/java/JavaByteCodeTranslator.h (revision 560245) +++ jitrino/src/translator/java/JavaByteCodeTranslator.h (working copy) @@ -274,7 +274,7 @@ bool methodIsArraycopy(MethodDesc * methodDesc); bool arraycopyOptimizable(MethodDesc * methodDesc, uint32 numArgs, Opnd ** srcOpnds); - bool genCharArrayCopy(MethodDesc * methodDesc,uint32 numArgs,Opnd ** srcOpnds, Type * returnType); +// bool genCharArrayCopy(MethodDesc * methodDesc,uint32 numArgs,Opnd ** srcOpnds, Type * returnType); bool genArrayCopyRepMove(MethodDesc * methodDesc,uint32 numArgs,Opnd ** srcOpnds); bool genArrayCopy(MethodDesc * methodDesc,uint32 numArgs,Opnd ** srcOpnds); bool genMinMax(MethodDesc * methodDesc,uint32 numArgs,Opnd ** srcOpnds, Type * returnType); Index: jitrino/src/translator/TranslatorIntfc.cpp =================================================================== --- jitrino/src/translator/TranslatorIntfc.cpp (revision 560245) +++ jitrino/src/translator/TranslatorIntfc.cpp (working copy) @@ -87,7 +87,6 @@ static const char* help = \ " propValues[={ON|off}] - propagate values during translation\n"\ - " genCharArrayCopy[={on|off}] - generate intrinsic calls to char array copy\n"\ " genArrayCopy[={ON|off}] - inline java/lang/System::arraycopy call as a copying loop\n"\ " genArrayCopyRepMove[={ON|off}] - inline java/lang/System::arraycopy call as 'rep move' instruction\n"\ " balancedSync[={on|OFF}] - treat all synchronization as balanced\n"\ @@ -96,6 +95,7 @@ " genMinMaxAbs[={on|OFF}] - use special opcodes for Min/Max/Abs\n"\ " genFMinMaxAbs[={on|OFF}] - also use opcodes for float Min/Max/Abs\n"; +/* " genCharArrayCopy[={on|off}] - generate intrinsic calls to char array copy\n"\*/ @@ -111,10 +111,10 @@ void TranslatorAction::readFlags() { flags.propValues = getBoolArg("propValues", true); #if defined(_IPF_) - flags.genCharArrayCopy = getBoolArg("genCharArrayCopy", true); +// flags.genCharArrayCopy = getBoolArg("genCharArrayCopy", true); flags.optArrayInit = getBoolArg("optArrayInit", false); #else - flags.genCharArrayCopy = getBoolArg("genCharArrayCopy", false); +// flags.genCharArrayCopy = getBoolArg("genCharArrayCopy", false); flags.optArrayInit = getBoolArg("optArrayInit", true); #endif flags.genArrayCopy = getBoolArg("genArrayCopy", false); Index: jitrino/src/translator/TranslatorIntfc.h =================================================================== --- jitrino/src/translator/TranslatorIntfc.h (revision 560245) +++ jitrino/src/translator/TranslatorIntfc.h (working copy) @@ -50,7 +50,7 @@ // to select which byte code translator optimizations are done struct TranslatorFlags { bool propValues : 1; // do value propagation - bool genCharArrayCopy : 1; // generate intrinsic calls to CharArrayCopy +// bool genCharArrayCopy : 1; // generate intrinsic calls to CharArrayCopy bool genArrayCopy : 1; // inline java/lang/System::arraycopy call as a copying loop bool genArrayCopyRepMove: 1; // inline java/lang/System::arraycopy call as 'rep move' instruction bool onlyBalancedSync : 1; // treat all method synchronization as balanced