| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| /** |
| * @author Intel, George A. Timoshenko |
| */ |
| |
| #include "HLOAPIMagics.h" |
| #include "Opcode.h" |
| #include "PMF.h" |
| #include "VMInterface.h" |
| |
| namespace Jitrino { |
| |
| bool arraycopyOptimizable(Inst* arraycopyCall, bool needWriteBarriers) { |
| // |
| // an ArrayStoreException is thrown and the destination is not modified: |
| // |
| // - The src argument refers to an object that is not an array. |
| // - The dest argument refers to an object that is not an array. |
| // - The src argument and dest argument refer to arrays whose component types are different primitive types. |
| // - The src argument refers to an array with a primitive component type and the dest argument |
| // refers to an array with a reference component type. |
| // - The src argument refers to an array with a reference component type and the dest argument |
| // refers to an array with a primitive component type. |
| // |
| Opnd * src = arraycopyCall->getSrc(2); |
| Type * srcType = src->getType(); |
| Opnd * dst = arraycopyCall->getSrc(4); |
| Type * dstType = dst->getType(); |
| assert(srcType->isObject() && |
| arraycopyCall->getSrc(3)->getType()->isInt4() && // 1 - srcPos |
| dstType->isObject() && |
| arraycopyCall->getSrc(5)->getType()->isInt4() && // 3 - dstPos |
| arraycopyCall->getSrc(6)->getType()->isInt4()); // 4 - length |
| |
| bool srcIsArray = srcType->isArray() && !srcType->isUnresolvedType(); |
| bool dstIsArray = dstType->isArray() && !dstType->isUnresolvedType(); |
| |
| bool isOptimizable = true; |
| |
| if ( srcIsArray && dstIsArray ) { |
| // these are arrays |
| |
| ArrayType* srcAsArrayType = srcType->asArrayType(); |
| ArrayType* dstAsArrayType = dstType->asArrayType(); |
| bool srcIsArrOfPrimitive = srcIsArray && VMInterface::isArrayOfPrimitiveElements(srcAsArrayType->getVMTypeHandle()); |
| bool dstIsArrOfPrimitive = dstIsArray && VMInterface::isArrayOfPrimitiveElements(dstAsArrayType->getVMTypeHandle()); |
| |
| // are these primitive or reference arrays? |
| if ( srcIsArrOfPrimitive && dstIsArrOfPrimitive ) { |
| // both arrays are primitive |
| |
| // if we are dealing with different primitive type arrays, reject optimization |
| // TODO: is that really necessary? |
| isOptimizable = (srcType == dstType); |
| |
| } else if ( srcIsArrOfPrimitive ^ dstIsArrOfPrimitive ) { |
| // arrays are mixed primitive and reference types |
| // reject optimization |
| isOptimizable = false; |
| |
| } else { |
| // both arrays are reference |
| |
| // if write barriers are enabled, reject optimization |
| // if not, check the types |
| if ( needWriteBarriers ) { |
| isOptimizable = false; |
| } else { |
| // Here is some inaccuracy. If src is a subclass of dst there is no ASE for sure. |
| // If it is not, we should check the assignability of each element being copied. |
| // To avoid this we just reject the inlining of System::arraycopy call in this case. |
| NamedType* srcElemType = srcAsArrayType->getElementType(); |
| NamedType* dstElemType = dstAsArrayType->getElementType(); |
| isOptimizable = (srcElemType->getVMTypeHandle() == dstElemType->getVMTypeHandle()); |
| } |
| |
| } |
| |
| } else { |
| // source or destination are not arrays |
| isOptimizable = false; |
| } |
| |
| return isOptimizable; |
| } |
| |
| |
| void |
| System_arraycopy_HLO_Handler::run() |
| { |
| InstFactory& instFactory = builder->getInstFactory(); |
| ControlFlowGraph& cfg = builder->getControlFlowGraph(); |
| |
| Node* firstNode = callInst->getNode(); |
| Edge* outEdge = firstNode->getOutEdge(Edge::Kind_Unconditional); |
| Node* exitNode = outEdge->getTargetNode(); |
| Node* dispatch = firstNode->getExceptionEdgeTarget(); |
| assert(dispatch); |
| callInst->unlink(); |
| cfg.removeEdge(outEdge); |
| |
| builder->setCurrentBCOffset(callInst->getBCOffset()); |
| builder->setCurrentNode(firstNode); |
| |
| // the fist two are tau operands |
| Opnd * src = callInst->getSrc(2); |
| Opnd * srcPos = callInst->getSrc(3); |
| Type * srcPosType = srcPos->getType(); |
| Opnd * dst = callInst->getSrc(4); |
| Opnd * dstPos = callInst->getSrc(5); |
| Type * dstPosType = dstPos->getType(); |
| Opnd * len = callInst->getSrc(6); |
| |
| // |
| // 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 a direction: |
| // cmpbr (dstPos > srcPos), Reverse |
| // |
| // Direct: |
| // JitHelperCall id=ArrayCopyDirect |
| // goto Exit |
| // Reverse: |
| // srcPos = srcPos + len - 1 |
| // dstPos = dstPos + len - 1 |
| // JitHelperCall id=ArrayCopyReverse |
| // goto Exit |
| // |
| // boundsException: |
| // chkbounds -1, src |
| // Exit: |
| // |
| |
| // Referenced nodes creation |
| LabelInst * reverseCopying = (LabelInst*)instFactory.makeLabel(); |
| LabelInst * boundsException = (LabelInst*)instFactory.makeLabel(); |
| LabelInst * Exit = (LabelInst*)exitNode->getLabelInst(); |
| |
| Node* BExcNode = cfg.createBlockNode(boundsException); |
| Node* RevCopyNode = cfg.createBlockNode(reverseCopying); |
| |
| //Other nodes creation and filling |
| Opnd* tauSrcNullChecked = builder->genTauCheckNull(src); |
| |
| // node |
| builder->genFallthroughNode(dispatch); |
| Opnd* tauDstNullChecked = builder->genTauCheckNull(dst); |
| |
| // node |
| builder->genFallthroughNode(); |
| builder->genEdgeFromCurrent(BExcNode, 0); |
| |
| Opnd* tauNullCheckedRefArgs = builder->genTauAnd(tauSrcNullChecked, tauDstNullChecked); |
| |
| Type * intType = builder->getTypeManager().getInt32Type(); |
| Type::Tag intTag = intType->tag; |
| |
| Opnd * zero = builder->genLdConstant(0); |
| builder->appendInst(instFactory.makeBranch(Cmp_GT,intTag,zero,srcPos,boundsException)); |
| |
| // node |
| builder->genFallthroughNode(); |
| builder->genEdgeFromCurrent(BExcNode, 0); |
| builder->appendInst(instFactory.makeBranch(Cmp_GT,intTag,zero,dstPos,boundsException)); |
| |
| // node |
| builder->genFallthroughNode(); |
| builder->genEdgeFromCurrent(BExcNode, 0); |
| builder->appendInst(instFactory.makeBranch(Cmp_GT,intTag,zero,len,boundsException)); |
| |
| Modifier mod = Modifier(Overflow_None)|Modifier(Exception_Never)|Modifier(Strict_No); |
| |
| // node |
| builder->genFallthroughNode(); |
| builder->genEdgeFromCurrent(BExcNode, 0); |
| |
| Opnd * srcLen = builder->genArrayLen(intType, intTag, src, tauSrcNullChecked); |
| Opnd * srcEnd = builder->genAdd(intType,mod,srcPos,len); |
| builder->appendInst(instFactory.makeBranch(Cmp_GT,intTag,srcEnd,srcLen,boundsException)); |
| |
| // node |
| builder->genFallthroughNode(); |
| builder->genEdgeFromCurrent(BExcNode, 0); |
| |
| Opnd * dstEnd = builder->genAdd(intType,mod,dstPos,len); |
| Opnd * dstLen = builder->genArrayLen(intType, intTag, dst, tauDstNullChecked); |
| builder->appendInst(instFactory.makeBranch(Cmp_GT,intTag,dstEnd,dstLen,boundsException)); |
| |
| // node |
| builder->genFallthroughNode(); |
| builder->genEdgeFromCurrent(exitNode, 0); |
| |
| // The case of same arrays and same positions |
| Opnd * diff = builder->genCmp3(intType,intTag,Cmp_GT,dstPos,srcPos); |
| Opnd * sameArrays = builder->genCmp(intType,Type::IntPtr,Cmp_EQ,src,dst); |
| Opnd * zeroDiff = builder->genCmp(intType,intTag,Cmp_EQ,diff,zero); |
| Opnd * nothingToCopy = builder->genAnd(intType,sameArrays,zeroDiff); |
| builder->appendInst(instFactory.makeBranch(Cmp_NonZero,intTag,nothingToCopy,Exit)); |
| |
| // node |
| builder->genFallthroughNode(); |
| builder->genEdgeFromCurrent(RevCopyNode,0); |
| |
| Opnd* tauTypesChecked = builder->genTauSafe(); |
| |
| // Choosing direction |
| Opnd * dstIsGreater = builder->genCmp(intType,intTag,Cmp_GT,diff,zero); |
| Opnd * reverseCopy = builder->genAnd(intType,sameArrays,dstIsGreater); |
| builder->appendInst(instFactory.makeBranch(Cmp_GT,intTag,reverseCopy,zero,reverseCopying)); |
| |
| // Direct Copying |
| builder->genFallthroughNode(); |
| builder->genEdgeFromCurrent(exitNode,0); |
| |
| Opnd* directArgs [5]; |
| directArgs[0] = src; |
| directArgs[1] = srcPos; |
| directArgs[2] = dst; |
| directArgs[3] = dstPos; |
| directArgs[4] = len; |
| builder->appendInst(instFactory.makeJitHelperCall(OpndManager::getNullOpnd(), ArrayCopyDirect, |
| tauNullCheckedRefArgs, tauTypesChecked, |
| 5, directArgs)); |
| |
| // Reverse Copying |
| builder->setCurrentNode(RevCopyNode); |
| builder->genEdgeFromCurrent(exitNode); |
| |
| Opnd* one = builder->genLdConstant(1); |
| Opnd* lastSrcIdx = builder->genSub(srcPosType,mod,srcEnd,one); |
| Opnd* lastDstIdx = builder->genSub(dstPosType,mod,dstEnd,one); |
| |
| Opnd* reverseArgs [5]; |
| reverseArgs[0] = src; |
| reverseArgs[1] = lastSrcIdx; // srcPos+len-1 |
| reverseArgs[2] = dst; |
| reverseArgs[3] = lastDstIdx; // dstPos+len-1 |
| reverseArgs[4] = len; |
| builder->appendInst(instFactory.makeJitHelperCall(OpndManager::getNullOpnd(), ArrayCopyReverse, |
| tauNullCheckedRefArgs, tauTypesChecked, |
| 5, reverseArgs)); |
| |
| // Bounds Exception |
| builder->setCurrentNode(BExcNode); |
| builder->genEdgeFromCurrent(exitNode); |
| builder->genEdgeFromCurrent(dispatch, 0); |
| Opnd* minusone = builder->genLdConstant(-1); |
| builder->genTauCheckBounds(src,minusone,tauSrcNullChecked); |
| } |
| |
| void |
| String_compareTo_HLO_Handler::run() |
| { |
| IRManager* irm = builder->getIRManager(); |
| InstFactory& instFactory = builder->getInstFactory(); |
| ControlFlowGraph& cfg = builder->getControlFlowGraph(); |
| |
| Node* firstNode = callInst->getNode(); |
| Node* lastNode = cfg.splitNodeAtInstruction(callInst, true, true, instFactory.makeLabel()); |
| Node* dispatch = firstNode->getExceptionEdgeTarget(); |
| assert(dispatch); |
| callInst->unlink(); |
| cfg.removeEdge(firstNode->findEdge(true, lastNode)); |
| |
| builder->setCurrentBCOffset(callInst->getBCOffset()); |
| |
| // the fist two are tau operands |
| Opnd* dst = callInst->getDst(); |
| Opnd* thisStr = callInst->getSrc(2); |
| Opnd* trgtStr = callInst->getSrc(3); |
| |
| Class_Handle string = (Class_Handle)VMInterface::getSystemStringVMTypeHandle(); |
| FieldDesc* fieldCountDesc = irm->getCompilationInterface().getFieldByName(string,"count"); |
| assert(fieldCountDesc); |
| FieldDesc* fieldValueDesc = irm->getCompilationInterface().getFieldByName(string,"value"); |
| assert(fieldValueDesc); |
| // this field is optional |
| FieldDesc* offsetDesc = irm->getCompilationInterface().getFieldByName(string,"offset"); |
| Type* fieldType = fieldCountDesc->getFieldType(); |
| Type::Tag fieldTag = fieldType->tag; |
| |
| // gen at the end of first node |
| builder->setCurrentNode(firstNode); |
| Opnd *tauThisNullChecked = builder->genTauCheckNull(thisStr); |
| |
| // node |
| builder->genFallthroughNode(dispatch); |
| Opnd *tauThisInRange = builder->genTauHasType(thisStr, fieldCountDesc->getParentType()); |
| Opnd* thisLength = builder->genLdField(fieldCountDesc, thisStr, tauThisNullChecked, tauThisInRange); |
| Opnd *tauTrgtNullChecked = builder->genTauCheckNull(trgtStr); |
| |
| // node |
| Node* branch = builder->genFallthroughNode(); |
| Opnd *tauTrgtInRange = builder->genTauHasType(trgtStr, fieldCountDesc->getParentType()); |
| Opnd* trgtLength = builder->genLdField(fieldCountDesc, trgtStr, tauTrgtNullChecked, tauTrgtInRange); |
| |
| LabelInst * ThisIsLonger = (LabelInst*)instFactory.makeLabel(); |
| builder->appendInst(instFactory.makeBranch(Cmp_GT,fieldTag,thisLength,trgtLength,ThisIsLonger)); |
| |
| VarOpnd* counterVar = builder->createVarOpnd(fieldType,false); |
| |
| // node (trgt is longer here) |
| builder->genFallthroughNode(); |
| SsaVarOpnd* thisLengthVar = builder->createSsaVarOpnd(counterVar); |
| builder->genStVar(thisLengthVar,thisLength); |
| builder->genEdgeFromCurrent(lastNode); // jump to merge |
| |
| // node (this is longer here) |
| builder->genNodeAfter(branch,ThisIsLonger); |
| SsaVarOpnd* trgtLengthVar = builder->createSsaVarOpnd(counterVar); |
| builder->genStVar(trgtLengthVar,trgtLength); |
| builder->genEdgeFromCurrent(lastNode); // jump to merge |
| |
| // last node (merge after counter definition) |
| builder->setCurrentNode(lastNode); |
| // gather counter value |
| Opnd* phiArgs[] = {thisLengthVar,trgtLengthVar}; |
| SsaVarOpnd* var = builder->createSsaVarOpnd(counterVar); |
| lastNode->appendInst(instFactory.makePhi(var,2,phiArgs)); |
| Opnd* counter = builder->createOpnd(fieldType); |
| lastNode->appendInst(instFactory.makeLdVar(counter,var)); |
| Opnd* thisStart = builder->genLdConstant(0); |
| Opnd* trgtStart = builder->genLdConstant(0); |
| if(offsetDesc) { |
| Modifier mod = Modifier(Overflow_None)|Modifier(Exception_Never)|Modifier(Strict_No); |
| Opnd* thisOffset = builder->genLdField(offsetDesc, thisStr, tauThisNullChecked, tauThisInRange); |
| Opnd* trgtOffset = builder->genLdField(offsetDesc, trgtStr, tauTrgtNullChecked, tauTrgtInRange); |
| thisStart = builder->genAdd(fieldType, mod, thisOffset, thisStart); |
| trgtStart = builder->genAdd(fieldType, mod, trgtOffset, trgtStart); |
| } |
| Opnd* thisValue = builder->genLdField(fieldValueDesc, thisStr, tauThisNullChecked, tauThisInRange); |
| Opnd* trgtValue = builder->genLdField(fieldValueDesc, trgtStr, tauTrgtNullChecked, tauTrgtInRange); |
| Opnd* opnds[] = {thisValue,thisStart,thisLength,trgtValue,trgtStart,trgtLength,counter}; |
| |
| // This helper call will be processed in Ia32ApiMagics pass |
| builder->appendInst(instFactory.makeJitHelperCall(dst, StringCompareTo, NULL, NULL, 7, opnds)); |
| |
| cfg.orderNodes(true); |
| } |
| |
| void |
| String_regionMatches_HLO_Handler::run() |
| { |
| IRManager* irm = builder->getIRManager(); |
| InstFactory& instFactory = builder->getInstFactory(); |
| ControlFlowGraph& cfg = builder->getControlFlowGraph(); |
| |
| Node* firstNode = callInst->getNode(); |
| Node* lastNode = cfg.splitNodeAtInstruction(callInst, true, true, instFactory.makeLabel()); |
| Node* dispatch = firstNode->getExceptionEdgeTarget(); |
| assert(dispatch); |
| callInst->unlink(); |
| cfg.removeEdge(firstNode->findEdge(true, lastNode)); |
| |
| builder->setCurrentBCOffset(callInst->getBCOffset()); |
| |
| // the fist two are tau operands |
| Opnd* dst = callInst->getDst(); |
| Opnd* thisStr = callInst->getSrc(2); |
| Opnd* thisStart = callInst->getSrc(3); |
| Opnd* trgtStr = callInst->getSrc(4); |
| Opnd* trgtStart = callInst->getSrc(5); |
| Opnd* counter = callInst->getSrc(6); |
| |
| Class_Handle string = (Class_Handle)VMInterface::getSystemStringVMTypeHandle(); |
| FieldDesc* fieldCountDesc = irm->getCompilationInterface().getFieldByName(string,"count"); |
| assert(fieldCountDesc); |
| FieldDesc* fieldValueDesc = irm->getCompilationInterface().getFieldByName(string,"value"); |
| assert(fieldValueDesc); |
| // this field is optional |
| FieldDesc* offsetDesc = irm->getCompilationInterface().getFieldByName(string,"offset"); |
| |
| Type* fieldType = fieldCountDesc->getFieldType(); |
| Type::Tag fieldTag = fieldType->tag; |
| |
| // gen at the end of first node |
| builder->setCurrentNode(firstNode); |
| Opnd *tauThisNullChecked = builder->genTauCheckNull(thisStr); |
| |
| // node |
| builder->genFallthroughNode(dispatch); |
| Opnd *tauThisInRange = builder->genTauHasType(thisStr, fieldCountDesc->getParentType()); |
| Opnd *tauTrgtNullChecked = builder->genTauCheckNull(trgtStr); |
| |
| LabelInst * FalseResult = (LabelInst*)instFactory.makeLabel(); |
| Node* returnFalse = cfg.createBlockNode(FalseResult); |
| |
| // node |
| builder->genFallthroughNode(); |
| Opnd* zero = builder->genLdConstant(0); |
| Opnd *tauTrgtInRange = builder->genTauHasType(trgtStr, fieldCountDesc->getParentType()); |
| builder->appendInst(instFactory.makeBranch(Cmp_GT,fieldTag,zero,trgtStart,FalseResult)); |
| builder->genEdgeFromCurrent(returnFalse); |
| |
| // node |
| builder->genFallthroughNode(); |
| builder->appendInst(instFactory.makeBranch(Cmp_GT,fieldTag,zero,thisStart,FalseResult)); |
| builder->genEdgeFromCurrent(returnFalse); |
| |
| Modifier mod = Modifier(Overflow_None)|Modifier(Exception_Never)|Modifier(Strict_No); |
| |
| // node |
| builder->genFallthroughNode(); |
| Opnd* trgtLength = builder->genLdField(fieldCountDesc, trgtStr, tauTrgtNullChecked, tauTrgtInRange); |
| Opnd* trgtDiff = builder->genSub(fieldType, mod,trgtLength,trgtStart); |
| builder->appendInst(instFactory.makeBranch(Cmp_GT,fieldTag,counter,trgtDiff,FalseResult)); |
| builder->genEdgeFromCurrent(returnFalse); |
| |
| // node |
| builder->genFallthroughNode(); |
| Opnd* thisLength = builder->genLdField(fieldCountDesc, thisStr, tauThisNullChecked, tauThisInRange); |
| Opnd* thisDiff = builder->genSub(fieldType, mod,thisLength,thisStart); |
| builder->appendInst(instFactory.makeBranch(Cmp_GT,fieldTag,counter,thisDiff,FalseResult)); |
| builder->genEdgeFromCurrent(returnFalse); |
| |
| LabelInst * TrueResult = (LabelInst*)instFactory.makeLabel(); |
| Node* returnTrue = cfg.createBlockNode(TrueResult); |
| |
| // node |
| builder->genFallthroughNode(); |
| builder->appendInst(instFactory.makeBranch(Cmp_GTE,fieldTag,zero,counter,TrueResult)); |
| builder->genEdgeFromCurrent(returnTrue); |
| |
| // node |
| builder->genFallthroughNode(); |
| if(offsetDesc) { |
| Opnd* thisOffset = builder->genLdField(offsetDesc, thisStr, tauThisNullChecked, tauThisInRange); |
| Opnd* trgtOffset = builder->genLdField(offsetDesc, trgtStr, tauTrgtNullChecked, tauTrgtInRange); |
| thisStart = builder->genAdd(fieldType, mod, thisOffset, thisStart); |
| trgtStart = builder->genAdd(fieldType, mod, trgtOffset, trgtStart); |
| } |
| Opnd* thisValue = builder->genLdField(fieldValueDesc, thisStr, tauThisNullChecked, tauThisInRange); |
| Opnd* trgtValue = builder->genLdField(fieldValueDesc, trgtStr, tauTrgtNullChecked, tauTrgtInRange); |
| Opnd* opnds[] = {thisValue,thisStart,trgtValue,trgtStart,counter}; |
| |
| // This helper call will be processed in Ia32ApiMagics pass |
| VarOpnd* resultVar = builder->createVarOpnd(dst->getType(),false); |
| SsaVarOpnd* resVar = builder->createSsaVarOpnd(resultVar); |
| Opnd* res = builder->createOpnd(dst->getType()); |
| builder->appendInst(instFactory.makeJitHelperCall(res, StringRegionMatches, NULL, NULL, 5, opnds)); |
| builder->genStVar(resVar,res); |
| builder->genEdgeFromCurrent(lastNode); |
| |
| // returnFalse |
| builder->setCurrentNode(returnFalse); |
| Opnd* resFalse = builder->genLdConstant(0); |
| SsaVarOpnd* resFalseVar = builder->createSsaVarOpnd(resultVar); |
| builder->genStVar(resFalseVar,resFalse); |
| builder->genEdgeFromCurrent(lastNode); |
| |
| // returnTrue |
| builder->setCurrentNode(returnTrue); |
| Opnd* resTrue = builder->genLdConstant(1); |
| SsaVarOpnd* resTrueVar = builder->createSsaVarOpnd(resultVar); |
| builder->genStVar(resTrueVar,resTrue); |
| builder->genEdgeFromCurrent(lastNode); |
| |
| // lastNode |
| Opnd* phiArgs[] = {resVar,resFalseVar,resTrueVar}; |
| SsaVarOpnd* var = builder->createSsaVarOpnd(resultVar); |
| lastNode->appendInst(instFactory.makePhi(var,3,phiArgs)); |
| lastNode->appendInst(instFactory.makeLdVar(dst,var)); |
| |
| cfg.orderNodes(true); |
| } |
| |
| void |
| String_indexOf_HLO_Handler::run() |
| { |
| IRManager* irm = builder->getIRManager(); |
| InstFactory& instFactory = builder->getInstFactory(); |
| ControlFlowGraph& cfg = builder->getControlFlowGraph(); |
| |
| Node* firstNode = callInst->getNode(); |
| Node* lastNode = cfg.splitNodeAtInstruction(callInst, true, true, instFactory.makeLabel()); |
| Node* dispatch = firstNode->getExceptionEdgeTarget(); |
| assert(dispatch); |
| callInst->unlink(); |
| cfg.removeEdge(firstNode->findEdge(true, lastNode)); |
| |
| builder->setCurrentBCOffset(callInst->getBCOffset()); |
| |
| // the fist two are tau operands |
| Opnd* dst = callInst->getDst(); |
| Opnd* thisStr = callInst->getSrc(2); |
| Opnd* trgtStr = callInst->getSrc(3); |
| Opnd* start = callInst->getSrc(4); |
| |
| Class_Handle string = (Class_Handle)VMInterface::getSystemStringVMTypeHandle(); |
| FieldDesc* fieldCountDesc = irm->getCompilationInterface().getFieldByName(string,"count"); |
| assert(fieldCountDesc); |
| FieldDesc* fieldValueDesc = irm->getCompilationInterface().getFieldByName(string,"value"); |
| assert(fieldValueDesc); |
| FieldDesc* offsetDesc = irm->getCompilationInterface().getFieldByName(string,"offset"); |
| assert(offsetDesc); |
| |
| // gen at the end of first node |
| builder->setCurrentNode(firstNode); |
| Opnd *tauThisNullChecked = builder->genTauCheckNull(thisStr); |
| |
| // node |
| builder->genFallthroughNode(dispatch); |
| Opnd *tauThisInRange = builder->genTauHasType(thisStr, fieldCountDesc->getParentType()); |
| |
| Opnd *tauTrgtNullChecked = builder->genTauCheckNull(trgtStr); |
| |
| // node |
| builder->genFallthroughNode(); |
| Opnd* imm128 = builder->genLdConstant(128); |
| Opnd* imm64 = builder->genLdConstant(64); |
| Opnd *tauTrgtInRange = builder->genTauHasType(trgtStr, fieldCountDesc->getParentType()); |
| |
| // node |
| builder->genFallthroughNode(dispatch); |
| |
| // prefetch String objects |
| Opnd * voidDst = builder->createOpnd(irm->getTypeManager().getVoidType()); |
| Opnd* prefetchThis[] = {thisStr, imm128, imm64}; |
| builder->appendInst(instFactory.makeJitHelperCall(voidDst, Prefetch, NULL, NULL, 3, prefetchThis)); |
| |
| // node |
| builder->genFallthroughNode(dispatch); |
| |
| Opnd* prefetchTrgt[] = {trgtStr, imm128, imm64}; |
| builder->appendInst(instFactory.makeJitHelperCall(voidDst, Prefetch, NULL, NULL, 3, prefetchTrgt)); |
| |
| Opnd* thisLength = builder->genLdField(fieldCountDesc, thisStr, tauThisNullChecked, tauThisInRange); |
| Opnd* trgtLength = builder->genLdField(fieldCountDesc, trgtStr, tauTrgtNullChecked, tauTrgtInRange); |
| |
| Opnd* thisOffset = builder->genLdField(offsetDesc, thisStr, tauThisNullChecked, tauThisInRange); |
| Opnd* trgtOffset = builder->genLdField(offsetDesc, trgtStr, tauTrgtNullChecked, tauTrgtInRange); |
| |
| Opnd* thisValue = builder->genLdField(fieldValueDesc, thisStr, tauThisNullChecked, tauThisInRange); |
| Opnd* trgtValue = builder->genLdField(fieldValueDesc, trgtStr, tauTrgtNullChecked, tauTrgtInRange); |
| |
| // node |
| builder->genFallthroughNode(dispatch); |
| |
| // prefetch character arrays |
| Opnd* prefetchThisValue[] = {thisValue, imm128, imm64}; |
| builder->appendInst(instFactory.makeJitHelperCall(voidDst, Prefetch, NULL, NULL, 3, prefetchThisValue)); |
| |
| // node |
| builder->genFallthroughNode(dispatch); |
| |
| Opnd* prefetchTrgtValue[] = {trgtValue, imm128, imm64}; |
| builder->appendInst(instFactory.makeJitHelperCall(voidDst, Prefetch, NULL, NULL, 3, prefetchTrgtValue)); |
| |
| // node |
| builder->genFallthroughNode(dispatch); |
| |
| Opnd* opnds[] = {thisValue, thisOffset, thisLength, trgtValue, trgtOffset, trgtLength, start}; |
| // This helper call will be processed in Ia32ApiMagics pass |
| builder->appendInst(instFactory.makeJitHelperCall(dst, StringIndexOf, NULL, NULL, 7, opnds)); |
| |
| builder->genEdgeFromCurrent(lastNode); |
| |
| cfg.orderNodes(true); |
| } |
| |
| void |
| System_identityHashCode_Handler::run() { |
| InstFactory& instFactory = builder->getInstFactory(); |
| |
| // the fist two are tau operands |
| Opnd* dst = callInst->getDst(); |
| Opnd* obj = callInst->getSrc(2); |
| // Opnd * opnds[] = { obj }; |
| |
| Node* firstNode = callInst->getNode(); |
| builder->setCurrentBCOffset(callInst->getBCOffset()); |
| builder->setCurrentNode(firstNode); |
| |
| // builder->appendInst(instFactory.makeVMHelperCall(dst, VM_RT_GET_IDENTITY_HASHCODE, 1, opnds)); |
| builder->appendInst(instFactory.makeIdentHC(dst, obj)); |
| callInst->unlink(); |
| } |
| |
| Node* |
| HLOAPIMagicIRBuilder::genNodeAfter(Node* srcNode, LabelInst* label, Node* dispatch) { |
| currentNode = cfg.createBlockNode(label); |
| cfg.addEdge(srcNode, currentNode); |
| if (dispatch != NULL) { |
| cfg.addEdge(currentNode, dispatch, 0.001); |
| } |
| return currentNode; |
| } |
| |
| Node* |
| HLOAPIMagicIRBuilder::genNodeAfterCurrent(LabelInst* label, Node* dispatch) { |
| return genNodeAfter(currentNode,label,dispatch); |
| } |
| |
| Node* |
| HLOAPIMagicIRBuilder::genFallthroughNode(Node* dispatch) { |
| return genNodeAfter(currentNode,instFactory.makeLabel(),dispatch); |
| } |
| |
| void |
| HLOAPIMagicIRBuilder::appendInst(Inst* inst) { |
| inst->setBCOffset(currentBCOffset); |
| assert(currentNode); |
| currentNode->appendInst(inst); |
| } |
| |
| void |
| HLOAPIMagicIRBuilder::genCopy(Opnd* trgt, Opnd* src) { |
| appendInst(instFactory.makeCopy(trgt,src)); |
| } |
| |
| Opnd* |
| HLOAPIMagicIRBuilder::genLdField(FieldDesc* fieldDesc, Opnd* base, |
| Opnd* tauBaseNonNull, Opnd* tauAddressInRange) { |
| Type* fieldType = fieldDesc->getFieldType(); |
| assert(fieldType); |
| |
| Opnd* fieldAddr; |
| Modifier mod; |
| |
| if (compRefs) { |
| // until VM type system is upgraded, |
| // fieldDesc type will have uncompressed ref type; |
| // compress it |
| Type *compressedType = typeManager.compressType(fieldType); |
| fieldAddr = createOpnd(typeManager.getManagedPtrType(compressedType)); |
| mod = AutoCompress_Yes; |
| } else { |
| fieldAddr = createOpnd(typeManager.getManagedPtrType(fieldType)); |
| mod = AutoCompress_No; |
| } |
| appendInst(instFactory.makeLdFieldAddr(fieldAddr, base, fieldDesc)); |
| |
| Opnd* fieldVal = createOpnd(fieldType); |
| appendInst(instFactory.makeTauLdInd(mod, fieldType->tag, fieldVal, fieldAddr, |
| tauBaseNonNull, tauAddressInRange)); |
| return fieldVal; |
| } |
| |
| Opnd* |
| HLOAPIMagicIRBuilder::createOpnd(Type* type) { |
| if (type->tag == Type::Void) |
| return OpndManager::getNullOpnd(); |
| return opndManager.createSsaTmpOpnd(type); |
| } |
| |
| VarOpnd* |
| HLOAPIMagicIRBuilder::createVarOpnd(Type* type, bool isPinned) { |
| assert(type->tag != Type::Void); |
| return opndManager.createVarOpnd(type,isPinned); |
| } |
| |
| SsaVarOpnd* |
| HLOAPIMagicIRBuilder::createSsaVarOpnd(VarOpnd* var) { |
| return opndManager.createSsaVarOpnd(var); |
| } |
| |
| void |
| HLOAPIMagicIRBuilder::genStVar(SsaVarOpnd* var, Opnd* src) { |
| appendInst(instFactory.makeStVar(var, src)); |
| } |
| |
| Opnd* |
| HLOAPIMagicIRBuilder::genTauCheckNull(Opnd* base) |
| { |
| Opnd* dst = createOpnd(typeManager.getTauType()); |
| Inst* inst = instFactory.makeTauCheckNull(dst, base); |
| appendInst(inst); |
| return dst; |
| } |
| |
| Opnd* |
| HLOAPIMagicIRBuilder::genAnd(Type* dstType, Opnd* src1, Opnd* src2) { |
| Opnd* dst = createOpnd(dstType); |
| appendInst(instFactory.makeAnd(dst, src1, src2)); |
| return dst; |
| } |
| |
| Opnd* |
| HLOAPIMagicIRBuilder::genTauAnd(Opnd *src1, Opnd *src2) { |
| if (src1->getId() > src2->getId()) { |
| Opnd *tmp = src1; |
| src1 = src2; |
| src2 = tmp; |
| } |
| Opnd* dst = createOpnd(typeManager.getTauType()); |
| Opnd* srcs[2] = { src1, src2 }; |
| appendInst(instFactory.makeTauAnd(dst, 2, srcs)); |
| |
| return dst; |
| } |
| |
| Opnd* |
| HLOAPIMagicIRBuilder::genAdd(Type* dstType, Modifier mod, Opnd* src1, Opnd* src2) { |
| Opnd* dst = createOpnd(dstType); |
| Inst *newi = instFactory.makeAdd(mod, dst, src1, src2); |
| appendInst(newi); |
| return dst; |
| } |
| |
| Opnd* |
| HLOAPIMagicIRBuilder::genSub(Type* dstType, Modifier mod, Opnd* src1, Opnd* src2) { |
| Opnd* dst = createOpnd(dstType); |
| Inst *newi = instFactory.makeSub(mod, dst, src1, src2); |
| appendInst(newi); |
| return dst; |
| } |
| |
| Opnd* |
| HLOAPIMagicIRBuilder::genLdConstant(I_32 val) { |
| Opnd* dst = createOpnd(typeManager.getInt32Type()); |
| appendInst(instFactory.makeLdConst(dst, val)); |
| return dst; |
| } |
| |
| Opnd* |
| HLOAPIMagicIRBuilder::genArrayLen(Type* dstType, Type::Tag type, Opnd* array, Opnd* tauNonNull) { |
| Opnd *tauIsArray = genTauHasType(array, array->getType()); |
| |
| return genTauArrayLen(dstType, type, array, tauNonNull, tauIsArray); |
| } |
| |
| Opnd* |
| HLOAPIMagicIRBuilder::genTauArrayLen(Type* dstType, Type::Tag type, Opnd* array, |
| Opnd* tauNullChecked, Opnd *tauTypeChecked) { |
| Opnd* dst = createOpnd(dstType); |
| appendInst(instFactory.makeTauArrayLen(dst, type, array, tauNullChecked, |
| tauTypeChecked)); |
| return dst; |
| } |
| |
| Opnd* |
| HLOAPIMagicIRBuilder::genCmp3(Type* dstType, |
| Type::Tag instType, // source type for inst |
| ComparisonModifier mod, |
| Opnd* src1, |
| Opnd* src2) { |
| // result of comparison is always a 32-bit int |
| Opnd* dst = createOpnd(dstType); |
| Inst* i = instFactory.makeCmp3(mod, instType, dst, src1, src2); |
| appendInst(i); |
| return dst; |
| } |
| |
| Opnd* |
| HLOAPIMagicIRBuilder::genCmp(Type* dstType, |
| Type::Tag instType, // source type for inst |
| ComparisonModifier mod, |
| Opnd* src1, |
| Opnd* src2) { |
| // result of comparison is always a 32-bit int |
| Opnd* dst = createOpnd(dstType); |
| Inst *i = instFactory.makeCmp(mod, instType, dst, src1, src2); |
| appendInst(i); |
| return dst; |
| } |
| |
| Opnd* |
| HLOAPIMagicIRBuilder::genTauSafe() { |
| Opnd* dst = createOpnd(typeManager.getTauType()); |
| appendInst(instFactory.makeTauSafe(dst)); |
| return dst; |
| } |
| |
| Opnd* |
| HLOAPIMagicIRBuilder::genTauCheckBounds(Opnd* array, Opnd* index, Opnd *tauNullChecked) { |
| Opnd* tauArrayTypeChecked = genTauHasType(array, array->getType()); |
| Opnd* arrayLen = genTauArrayLen(typeManager.getInt32Type(), Type::Int32, array, |
| tauNullChecked, tauArrayTypeChecked); |
| |
| Opnd* dst = genTauCheckBounds(arrayLen, index); |
| return dst; |
| } |
| |
| Opnd* |
| HLOAPIMagicIRBuilder::genTauCheckBounds(Opnd* ub, Opnd *index) { |
| Opnd* dst = createOpnd(typeManager.getTauType()); |
| appendInst(instFactory.makeTauCheckBounds(dst, ub, index)); |
| return dst; |
| } |
| |
| Opnd* |
| HLOAPIMagicIRBuilder::genTauHasType(Opnd *src, Type *castType) { |
| Opnd* dst = createOpnd(typeManager.getTauType()); |
| appendInst(instFactory.makeTauHasType(dst, src, castType)); |
| return dst; |
| } |
| |
| } //namespace Jitrino |
