| /* |
| * 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, Mikhail Y. Fursov |
| */ |
| |
| #include "Ia32Inst.h" |
| #include "Ia32IRManager.h" |
| |
| |
| //#define ENABLE_GC_RT_CHECKS |
| |
| namespace Jitrino { |
| namespace Ia32 { |
| |
| class APIMagicsHandlerSession: public SessionAction { |
| void runImpl(); |
| U_32 getNeedInfo()const{ return 0; } |
| U_32 getSideEffects()const{ return 0; } |
| bool isIRDumpEnabled(){ return true; } |
| }; |
| |
| static ActionFactory<APIMagicsHandlerSession> _api_magics("api_magic"); |
| |
| static Opnd* getCallDst(CallInst* callInst) { |
| Inst::Opnds defs(callInst, Inst::OpndRole_InstLevel | Inst::OpndRole_Def | Inst::OpndRole_Explicit); |
| U_32 idx = defs.begin(); |
| return callInst->getOpnd(idx); |
| } |
| static Opnd* getCallSrc(CallInst* callInst, U_32 n) { |
| Inst::Opnds uses(callInst, Inst::OpndRole_InstLevel | Inst::OpndRole_Use | Inst::OpndRole_Explicit); |
| U_32 idx = uses.begin(); //the first use is call addr |
| for (U_32 i=0; i<=n; i++) { |
| idx = uses.next(idx); |
| } |
| return callInst->getOpnd(idx); |
| } |
| |
| class APIMagicHandler { |
| public: |
| APIMagicHandler(IRManager* _irm, CallInst* _inst, MethodDesc* _md) |
| : irm(_irm), callInst(_inst), md(_md), typeManager(irm->getTypeManager()) { |
| cfg = irm->getFlowGraph(); |
| } |
| virtual ~APIMagicHandler(){}; |
| |
| virtual void run()=0; |
| protected: |
| |
| void convertIntToInt(Opnd* dst, Opnd* src, Node* node); |
| Opnd* addElemIndexWithLEA(Opnd* array, Opnd* index, RegName dstRegName, Node* node); |
| Opnd* getOpnd(Opnd* arg); |
| |
| IRManager* irm; |
| CallInst* callInst; |
| MethodDesc* md; |
| ControlFlowGraph* cfg; |
| TypeManager& typeManager; |
| }; |
| |
| #define DECLARE_HELPER_INLINER(name)\ |
| class name : public APIMagicHandler {\ |
| public:\ |
| name (IRManager* irm, CallInst* inst, MethodDesc* md)\ |
| : APIMagicHandler(irm, inst, md){}\ |
| \ |
| virtual void run();\ |
| };\ |
| |
| enum Math_function {SIN, COS, TAN, ASIN, ACOS, ATAN, ATAN2, LOG, LOG10, LOG1P, ABS, SQRT};\ |
| |
| #define DECLARE_HELPER_INLINER_MATH(name)\ |
| class name : public APIMagicHandler {\ |
| public:\ |
| enum Math_function func;\ |
| Mnemonic mnemonic;\ |
| name (IRManager* irm, CallInst* inst, MethodDesc* md, enum Math_function f, Mnemonic mn = Mnemonic_NULL)\ |
| : APIMagicHandler(irm, inst, md){name::func = f; name::mnemonic = mn;}\ |
| \ |
| 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(System_arraycopyDirect_Handler); |
| DECLARE_HELPER_INLINER(System_arraycopyReverse_Handler); |
| 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); |
| DECLARE_HELPER_INLINER(Float_floatToRawIntBits_x_F_x_I); |
| DECLARE_HELPER_INLINER(Float_intBitsToFloat_x_I_x_F); |
| |
| void APIMagicsHandlerSession::runImpl() { |
| CompilationContext* cc = getCompilationContext(); |
| MemoryManager tmpMM("Inline API methods"); |
| #ifndef _EM64T_ |
| bool mathAsMagic = getBoolArg("magic_math", true); |
| #endif |
| //finding all api magic calls |
| IRManager* irm = cc->getLIRManager(); |
| ControlFlowGraph* fg = irm->getFlowGraph(); |
| StlVector<APIMagicHandler*> handlers(tmpMM); |
| const Nodes& nodes = fg->getNodesPostOrder();//process checking only reachable nodes. |
| for (Nodes::const_iterator it = nodes.begin(), end = nodes.end(); it!=end; ++it) { |
| Node* node = *it; |
| if (node->isBlockNode()) { |
| for (Inst* inst = (Inst*)node->getFirstInst(); inst!=NULL; inst = inst->getNextInst()) { |
| if (!inst->hasKind(Inst::Kind_CallInst)) { |
| continue; |
| } |
| if ( ((CallInst*)inst)->isDirect() ) { |
| CallInst* callInst = (CallInst*)inst; |
| Opnd * targetOpnd=callInst->getOpnd(callInst->getTargetOpndIndex()); |
| assert(targetOpnd->isPlacedIn(OpndKind_Imm)); |
| Opnd::RuntimeInfo * ri=targetOpnd->getRuntimeInfo(); |
| if( !ri ) { |
| continue; |
| }; |
| if( ri->getKind() == Opnd::RuntimeInfo::Kind_MethodDirectAddr ){ |
| #ifndef _EM64T_ |
| MethodDesc * md = (MethodDesc*)ri->getValue(0); |
| const char* className = md->getParentType()->getName(); |
| const char* methodName = md->getName(); |
| const char* signature = md->getSignatureString(); |
| if (!strcmp(className, "java/lang/Integer")) { |
| if (!strcmp(methodName, "numberOfLeadingZeros") && !strcmp(signature, "(I)I")) { |
| handlers.push_back(new (tmpMM) Integer_numberOfLeadingZeros_Handler_x_I_x_I(irm, callInst, md)); |
| } else if (!strcmp(methodName, "numberOfTrailingZeros") && !strcmp(signature, "(I)I")) { |
| handlers.push_back(new (tmpMM) Integer_numberOfTrailingZeros_Handler_x_I_x_I(irm, callInst, md)); |
| } |
| } else if (!strcmp(className, "java/lang/Long")) { |
| if (!strcmp(methodName, "numberOfLeadingZeros") && !strcmp(signature, "(J)I")) { |
| handlers.push_back(new (tmpMM) Long_numberOfLeadingZeros_Handler_x_J_x_I(irm, callInst, md)); |
| } 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/Float")) { |
| if (!strcmp(methodName, "floatToRawIntBits") && !strcmp(signature, "(F)I")) { |
| handlers.push_back(new (tmpMM) Float_floatToRawIntBits_x_F_x_I(irm, callInst, md)); |
| } else if (!strcmp(methodName, "intBitsToFloat") && !strcmp(signature, "(I)F")) { |
| handlers.push_back(new (tmpMM) Float_intBitsToFloat_x_I_x_F(irm, callInst, md)); |
| } |
| } else if (mathAsMagic && !strcmp(className, "java/lang/Math")) { |
| if (!strcmp(signature, "(D)D")) { |
| if (!strcmp(methodName, "sqrt")) { |
| handlers.push_back(new (tmpMM) Math_Handler_x_D_x_D(irm, callInst, md, SQRT, Mnemonic_FSQRT)); |
| } |
| if (!strcmp(methodName, "sin")) { |
| handlers.push_back(new (tmpMM) Math_Handler_x_D_x_D(irm, callInst, md, SIN, Mnemonic_FSIN)); |
| } |
| if (!strcmp(methodName, "cos")) { |
| handlers.push_back(new (tmpMM) Math_Handler_x_D_x_D(irm, callInst, md, COS, Mnemonic_FCOS)); |
| } |
| if (!strcmp(methodName, "abs")) { |
| handlers.push_back(new (tmpMM) Math_Handler_x_D_x_D(irm, callInst, md, ABS, Mnemonic_FABS)); |
| } |
| if (!strcmp(methodName, "tan")) { |
| handlers.push_back(new (tmpMM) Math_Handler_x_D_x_D(irm, callInst, md, TAN, Mnemonic_FPTAN)); |
| } |
| if (!strcmp(methodName, "log")) { |
| handlers.push_back(new (tmpMM) Math_Handler_x_D_x_D(irm, callInst, md, LOG, Mnemonic_FLDLN2)); |
| } |
| if (!strcmp(methodName, "log10")) { |
| handlers.push_back(new (tmpMM) Math_Handler_x_D_x_D(irm, callInst, md, LOG10, Mnemonic_FLDLG2)); |
| } |
| if (!strcmp(methodName, "log1p")) { |
| handlers.push_back(new (tmpMM) Math_Handler_x_D_x_D(irm, callInst, md, LOG1P, Mnemonic_FLDLN2)); |
| } |
| if (!strcmp(methodName, "atan")) { |
| handlers.push_back(new (tmpMM) Math_Handler_x_D_x_D(irm, callInst, md, ATAN)); |
| } |
| if (!strcmp(methodName, "asin")) { |
| handlers.push_back(new (tmpMM) Math_Handler_x_D_x_D(irm, callInst, md, ASIN)); |
| } |
| if (!strcmp(methodName, "acos")) { |
| handlers.push_back(new (tmpMM) Math_Handler_x_D_x_D(irm, callInst, md, ACOS)); |
| } |
| } else if (!strcmp(signature, "(F)F") && !strcmp(methodName, "abs")) { |
| handlers.push_back(new (tmpMM) Math_Handler_x_D_x_D(irm, callInst, md, ABS, Mnemonic_FABS)); |
| } else if (!strcmp(signature, "(DD)D") && !strcmp(methodName, "atan2")) { |
| handlers.push_back(new (tmpMM) Math_Handler_x_D_x_D(irm, callInst, md, ATAN2)); |
| } |
| } |
| #endif |
| } else if( ri->getKind() == Opnd::RuntimeInfo::Kind_InternalHelperAddress ) { |
| if( strcmp((char*)ri->getValue(0),"memory_copy_direct")==0 ) { |
| if(getBoolArg("System_arraycopy_as_magic", true)) { |
| handlers.push_back(new (tmpMM) System_arraycopyDirect_Handler(irm, callInst, NULL)); |
| } else { assert(0); } |
| } else if( strcmp((char*)ri->getValue(0),"memory_copy_reverse")==0 ) { |
| if(getBoolArg("System_arraycopy_as_magic", true)) { |
| handlers.push_back(new (tmpMM) System_arraycopyReverse_Handler(irm, callInst, NULL)); |
| } else { assert(0); } |
| } else if( strcmp((char*)ri->getValue(0),"String_compareTo")==0 ) { |
| if(getBoolArg("String_compareTo_as_magic", true)) |
| handlers.push_back(new (tmpMM) String_compareTo_Handler_x_String_x_I(irm, callInst, NULL)); |
| } else if( strcmp((char*)ri->getValue(0),"String_regionMatches")==0 ) { |
| if(getBoolArg("String_regionMatches_as_magic", true)) |
| handlers.push_back(new (tmpMM) String_regionMatches_Handler_x_I_x_String_x_I_x_I_x_Z(irm, callInst, NULL)); |
| } else if( strcmp((char*)ri->getValue(0),"String_indexOf")==0 ) { |
| if(getBoolArg("String_indexOf_as_magic", true)) |
| handlers.push_back(new (tmpMM) String_indexOf_Handler_x_String_x_I_x_I(irm, callInst, NULL)); |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| //running all handlers |
| for (StlVector<APIMagicHandler*>::const_iterator it = handlers.begin(), end = handlers.end(); it!=end; ++it) { |
| APIMagicHandler* handler = *it; |
| handler->run(); |
| } |
| if (handlers.size() > 0) { |
| irm->invalidateLivenessInfo(); |
| } |
| } |
| |
| |
| void Integer_numberOfLeadingZeros_Handler_x_I_x_I::run() { |
| //mov r2,-1 |
| //bsr r1,arg |
| //cmovz r1,r2 |
| //return 31 - r1; |
| Type * i32Type =irm->getTypeFromTag(Type::Int32); |
| Opnd* r1 = irm->newOpnd(i32Type); |
| Opnd* r2 = irm->newOpnd(i32Type); |
| Opnd* arg = getCallSrc(callInst, 0); |
| Opnd* res = getCallDst(callInst); |
| |
| |
| irm->newCopyPseudoInst(Mnemonic_MOV, r2, irm->newImmOpnd(i32Type, -1))->insertBefore(callInst); |
| irm->newInstEx(Mnemonic_BSR, 1, r1, arg)->insertBefore(callInst); |
| irm->newInstEx(Mnemonic_CMOVZ, 1, r1, r1, r2)->insertBefore(callInst); |
| irm->newInstEx(Mnemonic_SUB, 1, res, irm->newImmOpnd(i32Type, 31), r1)->insertBefore(callInst); |
| |
| callInst->unlink(); |
| } |
| |
| void Float_floatToRawIntBits_x_F_x_I::run() { |
| |
| Opnd* arg = getCallSrc(callInst, 0); |
| Opnd* res = getCallDst(callInst); |
| |
| irm->newCopyPseudoInst(Mnemonic_MOV, res, arg)->insertBefore(callInst); |
| callInst->unlink(); |
| } |
| |
| void Float_intBitsToFloat_x_I_x_F::run() { |
| |
| Opnd* arg = getCallSrc(callInst, 0); |
| Opnd* res = getCallDst(callInst); |
| |
| irm->newCopyPseudoInst(Mnemonic_MOV, res, arg)->insertBefore(callInst); |
| 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(); |
| switch (func) { |
| case SQRT: case SIN: case COS: case ABS: case TAN: |
| node->appendInst(irm->newInst(Mnemonic_FLD, fp0, arg)); |
| node->appendInst(irm->newInst(mnemonic, fp0)); |
| if (func == TAN) { |
| node->appendInst(irm->newInst(Mnemonic_FSTP, res, fp0)); |
| } |
| break; |
| case LOG: case LOG10: case LOG1P: |
| node->appendInst(irm->newInst(mnemonic, fp0)); |
| node->appendInst(irm->newInst(Mnemonic_FLD, fp0, arg)); |
| if (func == LOG1P) { |
| node->appendInst(irm->newInst(Mnemonic_FLD1, fp0)); |
| node->appendInst(irm->newInst(Mnemonic_FADDP, fp0)); |
| } |
| node->appendInst(irm->newInst(Mnemonic_FYL2X, fp0)); |
| break; |
| case ATAN: |
| node->appendInst(irm->newInst(Mnemonic_FLD, fp0, arg)); |
| node->appendInst(irm->newInst(Mnemonic_FLD1, fp0)); |
| node->appendInst(irm->newInst(Mnemonic_FPATAN, fp0)); |
| break; |
| case ATAN2: |
| node->appendInst(irm->newInst(Mnemonic_FLD, fp0, arg)); |
| node->appendInst(irm->newInst(Mnemonic_FLD, fp0, getCallSrc(callInst, 1))); |
| node->appendInst(irm->newInst(Mnemonic_FPATAN, fp0)); |
| break; |
| case ASIN: case ACOS: |
| 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 (func == ACOS) { |
| node->appendInst(irm->newInst(Mnemonic_FXCH, fp0)); |
| } |
| node->appendInst(irm->newInst(Mnemonic_FPATAN, fp0)); |
| break; |
| default: assert(0); |
| } |
| 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; |
| |
| } |
| } |
| |
| void Integer_numberOfTrailingZeros_Handler_x_I_x_I::run() { |
| //mov r2,32 |
| //bsf r1,arg |
| //cmovz r1,r2 |
| //return r1 |
| Type * i32Type =irm->getTypeFromTag(Type::Int32); |
| Opnd* r1 = irm->newOpnd(i32Type); |
| Opnd* r2 = irm->newOpnd(i32Type); |
| Opnd* arg = getCallSrc(callInst, 0); |
| Opnd* res = getCallDst(callInst); |
| |
| irm->newCopyPseudoInst(Mnemonic_MOV, r2, irm->newImmOpnd(i32Type, 32))->insertBefore(callInst); |
| irm->newInstEx(Mnemonic_BSF, 1, r1, arg)->insertBefore(callInst); |
| irm->newInstEx(Mnemonic_CMOVZ, 1, r1, r1, r2)->insertBefore(callInst); |
| irm->newCopyPseudoInst(Mnemonic_MOV, res, r1)->insertBefore(callInst); |
| |
| callInst->unlink(); |
| } |
| |
| void Long_numberOfLeadingZeros_Handler_x_J_x_I::run() { |
| #ifdef _EM64T_ |
| return; |
| #else |
| // bsr r1,hi |
| // jz high_part_is_zero |
| //high_part_is_not_zero: |
| // return 31-r1 |
| //high_part_is_zero: |
| // mov r2,-1 |
| // bsr r1,lw |
| // cmovz r1, r2 |
| // return 63 - r1; |
| |
| |
| Type * i32Type =irm->getTypeFromTag(Type::Int32); |
| Opnd* r1 = irm->newOpnd(i32Type); |
| Opnd* r2 = irm->newOpnd(i32Type); |
| Opnd* lwOpnd = getCallSrc(callInst, 0); |
| Opnd* hiOpnd = getCallSrc(callInst, 1); |
| Opnd* res = getCallDst(callInst); |
| |
| if (callInst!=callInst->getNode()->getLastInst()) { |
| cfg->splitNodeAtInstruction(callInst, true, true, NULL); |
| } |
| Node* node = callInst->getNode(); |
| Node* nextNode = node->getUnconditionalEdgeTarget(); |
| assert(nextNode!=NULL); |
| cfg->removeEdge(node->getUnconditionalEdge()); |
| callInst->unlink(); |
| |
| Node* hiZeroNode = cfg->createBlockNode(); |
| Node* hiNotZeroNode = cfg->createBlockNode(); |
| |
| //node |
| node->appendInst(irm->newInstEx(Mnemonic_BSR, 1, r1, hiOpnd)); |
| node->appendInst(irm->newBranchInst(Mnemonic_JZ, hiZeroNode, hiNotZeroNode)); |
| |
| |
| //high_part_is_not_zero |
| hiNotZeroNode->appendInst(irm->newInstEx(Mnemonic_SUB, 1, res, irm->newImmOpnd(i32Type, 31), r1)); |
| |
| //high_part_is_zero |
| hiZeroNode->appendInst(irm->newCopyPseudoInst(Mnemonic_MOV, r2, irm->newImmOpnd(i32Type, -1))); |
| hiZeroNode->appendInst(irm->newInstEx(Mnemonic_BSR, 1, r1, lwOpnd)); |
| hiZeroNode->appendInst(irm->newInstEx(Mnemonic_CMOVZ, 1, r1, r1, r2)); |
| hiZeroNode->appendInst(irm->newInstEx(Mnemonic_SUB, 1, res, irm->newImmOpnd(i32Type, 63), r1)); |
| |
| |
| cfg->addEdge(node, hiZeroNode, 0.3); |
| cfg->addEdge(node, hiNotZeroNode, 0.7); |
| cfg->addEdge(hiZeroNode, nextNode); |
| cfg->addEdge(hiNotZeroNode, nextNode); |
| |
| #endif |
| } |
| |
| void Long_numberOfTrailingZeros_Handler_x_J_x_I::run() { |
| #ifdef _EM64T_ |
| return; |
| #else |
| |
| // bsf r1,lw |
| // jz low_part_is_zero |
| //low_part_is_not_zero: |
| // return r1; |
| //low_part_is_zero: |
| // bsf r1,hi |
| // jz zero |
| //not_zero; |
| // return 32 + r1; |
| //zero: |
| // return 64; |
| |
| Type * i32Type =irm->getTypeFromTag(Type::Int32); |
| Opnd* r1 = irm->newOpnd(i32Type); |
| Opnd* lwOpnd = getCallSrc(callInst, 0); |
| Opnd* hiOpnd = getCallSrc(callInst, 1); |
| Opnd* res = getCallDst(callInst); |
| |
| if (callInst!=callInst->getNode()->getLastInst()) { |
| cfg->splitNodeAtInstruction(callInst, true, true, NULL); |
| } |
| Node* node = callInst->getNode(); |
| Node* nextNode = node->getUnconditionalEdgeTarget(); |
| assert(nextNode!=NULL); |
| cfg->removeEdge(node->getUnconditionalEdge()); |
| callInst->unlink(); |
| |
| Node* lowZeroNode = cfg->createBlockNode(); |
| Node* lowNotZeroNode = cfg->createBlockNode(); |
| Node* notZeroNode = cfg->createBlockNode(); |
| Node* zeroNode = cfg->createBlockNode(); |
| |
| //node: |
| node->appendInst(irm->newInstEx(Mnemonic_BSF, 1, r1, lwOpnd)); |
| node->appendInst(irm->newBranchInst(Mnemonic_JZ, lowZeroNode, lowNotZeroNode)); |
| |
| //low_part_is_not_zero: |
| lowNotZeroNode->appendInst(irm->newCopyPseudoInst(Mnemonic_MOV, res, r1)); |
| |
| //low_part_is_zero: |
| lowZeroNode->appendInst(irm->newInstEx(Mnemonic_BSF, 1, r1, hiOpnd)); |
| lowZeroNode->appendInst(irm->newBranchInst(Mnemonic_JZ, zeroNode, notZeroNode)); |
| |
| //not zero: |
| notZeroNode->appendInst(irm->newInstEx(Mnemonic_ADD, 1, res, r1, irm->newImmOpnd(i32Type, 32))); |
| |
| //zero: |
| zeroNode->appendInst(irm->newCopyPseudoInst(Mnemonic_MOV, res, irm->newImmOpnd(i32Type, 64))); |
| |
| cfg->addEdge(node, lowNotZeroNode, 0.7); |
| cfg->addEdge(node, lowZeroNode, 0.3); |
| cfg->addEdge(lowNotZeroNode, nextNode); |
| cfg->addEdge(lowZeroNode, zeroNode, 0.1); |
| cfg->addEdge(lowZeroNode, notZeroNode, 0.9); |
| cfg->addEdge(notZeroNode, nextNode); |
| cfg->addEdge(zeroNode, nextNode); |
| |
| #endif |
| } |
| |
| void System_arraycopyDirect_Handler::run() |
| { |
| Node* currNode = callInst->getNode(); |
| if (callInst!=currNode->getLastInst()) { |
| cfg->splitNodeAtInstruction(callInst, true, true, NULL); |
| } |
| UNUSED Node* nextNode = currNode->getUnconditionalEdgeTarget(); |
| assert(nextNode!=NULL); |
| assert( currNode->getOutEdge(Edge::Kind_Dispatch) == NULL); |
| |
| callInst->unlink(); |
| |
| #ifdef _EM64T_ |
| RegName counterRegName = RegName_RCX; |
| RegName srcAddrRegName = RegName_RSI; |
| RegName dstAddrRegName = RegName_RDI; |
| #else |
| RegName counterRegName = RegName_ECX; |
| RegName srcAddrRegName = RegName_ESI; |
| RegName dstAddrRegName = RegName_EDI; |
| #endif |
| |
| Opnd* src = getCallSrc(callInst, 0); |
| Opnd* srcPos = getCallSrc(callInst, 1); |
| Opnd* dst = getCallSrc(callInst, 2); |
| Opnd* dstPos = getCallSrc(callInst, 3); |
| Opnd* counterVal = getCallSrc(callInst, 4); |
| |
| // prepare counter |
| Opnd* counter = irm->newRegOpnd(typeManager.getIntPtrType(),counterRegName); |
| convertIntToInt(counter, counterVal, currNode); |
| |
| // prepare src/dst positions |
| Opnd* srcAddr = addElemIndexWithLEA(src,srcPos,srcAddrRegName,currNode); |
| Opnd* dstAddr = addElemIndexWithLEA(dst,dstPos,dstAddrRegName,currNode); |
| |
| Opnd* one = irm->newImmOpnd(typeManager.getInt8Type(), 1); |
| |
| Mnemonic mn = Mnemonic_NULL; |
| Type* elemType = src->getType()->asArrayType()->getElementType(); |
| OpndSize typeSize = IRManager::getTypeSize(elemType->tag); |
| switch(typeSize) { |
| case OpndSize_8: mn = Mnemonic_MOVS8; break; |
| case OpndSize_16: mn = Mnemonic_MOVS16; break; |
| case OpndSize_32: mn = Mnemonic_MOVS32; break; |
| case OpndSize_64: |
| { |
| /** |
| * FIXME |
| * Currently JIT erroneously supposes that compressed mode is always on. |
| * So if type is object, it is actually compressed (32-bit sized). |
| * But IRManager::getTypeSize() "correctly" returns OpndSize_64. |
| */ |
| if (!elemType->isObject()) { |
| currNode->appendInst(irm->newInstEx(Mnemonic_SHL, 1, counter, counter, one)); |
| } |
| mn = Mnemonic_MOVS32; |
| } |
| break; |
| default: assert(0); mn = Mnemonic_MOVS32; break; |
| } |
| |
| Inst* copyInst = irm->newInst(mn,dstAddr,srcAddr,counter); |
| copyInst->setPrefix(InstPrefix_REP); |
| currNode->appendInst(copyInst); |
| } |
| |
| void System_arraycopyReverse_Handler::run() |
| { |
| Node* currNode = callInst->getNode(); |
| irm->newInst(Mnemonic_PUSHFD)->insertBefore(callInst); |
| irm->newInst(Mnemonic_STD)->insertBefore(callInst); |
| System_arraycopyDirect_Handler directHandler(irm, callInst, NULL); |
| directHandler.run(); |
| |
| currNode->appendInst(irm->newInst(Mnemonic_POPFD)); |
| } |
| |
| void String_compareTo_Handler_x_String_x_I::run() { |
| //mov ds:esi, this |
| //mov es:edi, src |
| //mov ecx, min(this.count, src.count) |
| //repne cmpw |
| //if ZF == 0 (one of strings is a prefix) |
| // return this.count - src.count |
| //else |
| // return [ds:esi-2] - [es:edi-2] |
| |
| Node* callInstNode = callInst->getNode(); |
| Node* nextNode = callInstNode->getUnconditionalEdgeTarget(); |
| assert(nextNode!=NULL); |
| cfg->removeEdge(callInstNode->getUnconditionalEdge()); |
| |
| // arguments of the call are already prepared by respective HLO pass |
| // they are not the strings but 'value' arrays |
| Opnd* thisArr = getCallSrc(callInst, 0); |
| Opnd* thisIdx = getCallSrc(callInst, 1); |
| Opnd* thisLen = getCallSrc(callInst, 2); |
| Opnd* trgtArr = getCallSrc(callInst, 3); |
| Opnd* trgtIdx = getCallSrc(callInst, 4); |
| Opnd* trgtLen = getCallSrc(callInst, 5); |
| Opnd* valForCounter = getCallSrc(callInst, 6); |
| Opnd* res = getCallDst(callInst); |
| |
| #ifdef _EM64T_ |
| RegName counterRegName = RegName_RCX; |
| RegName thisAddrRegName = RegName_RSI; |
| RegName trgtAddrRegName = RegName_RDI; |
| #else |
| RegName counterRegName = RegName_ECX; |
| RegName thisAddrRegName = RegName_ESI; |
| RegName trgtAddrRegName = RegName_EDI; |
| #endif |
| Type* counterType = typeManager.getIntPtrType(); |
| |
| Node* counterIsZeroNode = irm->getFlowGraph()->createBlockNode(); |
| // if counter is zero jump to counterIsZeroNode immediately |
| callInstNode->appendInst(irm->newInst(Mnemonic_TEST, valForCounter, valForCounter)); |
| BranchInst* br = irm->newBranchInst(Mnemonic_JZ, NULL, NULL); |
| callInstNode->appendInst(br); |
| Node* node = irm->getFlowGraph()->createBlockNode(); |
| br->setTrueTarget(counterIsZeroNode); |
| br->setFalseTarget(node); |
| irm->getFlowGraph()->addEdge(counterIsZeroNode, nextNode, 1); |
| irm->getFlowGraph()->addEdge(callInstNode, counterIsZeroNode, 0.05); |
| irm->getFlowGraph()->addEdge(callInstNode, node, 0.95); |
| |
| // prepare counter |
| Opnd* counter = irm->newRegOpnd(counterType,counterRegName); |
| convertIntToInt(counter, valForCounter, node); |
| |
| // prepare this/trgt positions |
| Opnd* thisAddrReg = addElemIndexWithLEA(thisArr,thisIdx,thisAddrRegName,node); |
| Opnd* trgtAddrReg = addElemIndexWithLEA(trgtArr,trgtIdx,trgtAddrRegName,node); |
| |
| Inst* compareInst = irm->newInst(Mnemonic_CMPSW,thisAddrReg,trgtAddrReg,counter); |
| compareInst->setPrefix(InstPrefix_REPZ); |
| node->appendInst(compareInst); |
| |
| // counter is 0 means the same as last comparison leaves zero at ZF |
| br = irm->newBranchInst(Mnemonic_JZ, NULL, NULL); |
| node->appendInst(br); |
| |
| Node* differentStringsNode = irm->getFlowGraph()->createBlockNode(); |
| br->setTrueTarget(counterIsZeroNode); |
| br->setFalseTarget(differentStringsNode); |
| irm->getFlowGraph()->addEdge(node, counterIsZeroNode, 0.5); |
| irm->getFlowGraph()->addEdge(node, differentStringsNode, 0.5); |
| irm->getFlowGraph()->addEdge(differentStringsNode, nextNode, 1); |
| |
| // counter is zero |
| counterIsZeroNode->appendInst(irm->newInstEx(Mnemonic_SUB, 1, res, thisLen, trgtLen)); |
| |
| // strings are different |
| Opnd* minustwo = irm->newImmOpnd(counterType,-2); |
| Type* charType = typeManager.getCharType(); |
| Opnd* thisChar = irm->newMemOpnd(charType, thisAddrReg, NULL, NULL, minustwo); |
| Opnd* trgtChar = irm->newMemOpnd(charType, trgtAddrReg, NULL, NULL, minustwo); |
| Type* intType = res->getType(); |
| Opnd* thisInt = irm->newOpnd(intType); |
| Opnd* trgtInt = irm->newOpnd(intType); |
| differentStringsNode->appendInst(irm->newInstEx(Mnemonic_MOVZX, 1, thisInt, thisChar)); |
| differentStringsNode->appendInst(irm->newInstEx(Mnemonic_MOVZX, 1, trgtInt, trgtChar)); |
| differentStringsNode->appendInst(irm->newInstEx(Mnemonic_SUB, 1, res, thisInt, trgtInt)); |
| |
| callInst->unlink(); |
| } |
| |
| void String_regionMatches_Handler_x_I_x_String_x_I_x_I_x_Z::run() { |
| //mov ds:esi, this |
| //mov es:edi, src |
| //mov ecx, counter |
| //repne cmpw |
| //if ZF == 0 (one of strings is a prefix) |
| // return this.count - src.count |
| //else |
| // return [ds:esi-2] - [es:edi-2] |
| |
| Node* node = callInst->getNode(); |
| Node* nextNode = NULL; |
| |
| if(callInst == node->getLastInst()) { |
| nextNode = node->getUnconditionalEdgeTarget(); |
| assert(nextNode!=NULL); |
| } else { |
| nextNode = irm->getFlowGraph()->splitNodeAtInstruction(callInst, true, true, NULL); |
| } |
| cfg->removeEdge(node->getUnconditionalEdge()); |
| |
| // arguments of the call are already prepared by respective HLO pass |
| // they are not the strings but 'value' arrays |
| Opnd* thisArr = getCallSrc(callInst, 0); |
| Opnd* thisIdx = getCallSrc(callInst, 1); |
| Opnd* trgtArr = getCallSrc(callInst, 2); |
| Opnd* trgtIdx = getCallSrc(callInst, 3); |
| Opnd* valForCounter = getCallSrc(callInst, 4); |
| Opnd* res = getCallDst(callInst); |
| |
| #ifdef _EM64T_ |
| RegName counterRegName = RegName_RCX; |
| RegName thisAddrRegName = RegName_RSI; |
| RegName trgtAddrRegName = RegName_RDI; |
| #else |
| RegName counterRegName = RegName_ECX; |
| RegName thisAddrRegName = RegName_ESI; |
| RegName trgtAddrRegName = RegName_EDI; |
| #endif |
| Type* counterType = typeManager.getIntPtrType(); |
| |
| // prepare counter |
| Opnd* counter = irm->newRegOpnd(counterType,counterRegName); |
| convertIntToInt(counter, valForCounter, node); |
| |
| // prepare this/trgt positions |
| Opnd* thisAddrReg = addElemIndexWithLEA(thisArr,thisIdx,thisAddrRegName,node); |
| Opnd* trgtAddrReg = addElemIndexWithLEA(trgtArr,trgtIdx,trgtAddrRegName,node); |
| |
| Inst* compareInst = irm->newInst(Mnemonic_CMPSW,thisAddrReg,trgtAddrReg,counter); |
| compareInst->setPrefix(InstPrefix_REPZ); |
| node->appendInst(compareInst); |
| |
| // counter is 0 means the same as last comparison leaves zero at ZF |
| BranchInst* br = irm->newBranchInst(Mnemonic_JZ, NULL, NULL); |
| node->appendInst(br); |
| |
| Node* sameRegionsNode = irm->getFlowGraph()->createBlockNode(); |
| Node* diffRegionsNode = irm->getFlowGraph()->createBlockNode(); |
| br->setTrueTarget(sameRegionsNode); |
| br->setFalseTarget(diffRegionsNode); |
| irm->getFlowGraph()->addEdge(node, sameRegionsNode, 0.5); |
| irm->getFlowGraph()->addEdge(sameRegionsNode, nextNode, 1); |
| irm->getFlowGraph()->addEdge(node, diffRegionsNode, 0.5); |
| irm->getFlowGraph()->addEdge(diffRegionsNode, nextNode, 1); |
| |
| // regions are equal |
| Opnd* one = irm->newImmOpnd(res->getType(),1); |
| sameRegionsNode->appendInst(irm->newInst(Mnemonic_MOV, res, one)); |
| |
| // regions are different |
| Opnd* zero = irm->newImmOpnd(res->getType(),0); |
| diffRegionsNode->appendInst(irm->newInst(Mnemonic_MOV, res, zero)); |
| |
| callInst->unlink(); |
| } |
| |
| void String_indexOf_Handler_x_String_x_I_x_I::run() { |
| |
| Node* callInstNode = callInst->getNode(); |
| Node* nextNode = NULL; |
| |
| if(callInst == callInstNode->getLastInst()) { |
| nextNode = callInstNode->getUnconditionalEdgeTarget(); |
| assert(nextNode!=NULL); |
| } else { |
| nextNode = irm->getFlowGraph()->splitNodeAtInstruction(callInst, true, true, NULL); |
| } |
| cfg->removeEdge(callInstNode->getUnconditionalEdge()); |
| |
| // arguments of the call are already prepared by respective HLO pass |
| // they are not the strings but 'value' arrays |
| Opnd* thisArr = getCallSrc(callInst, 0); |
| Opnd* thisOffset = getCallSrc(callInst, 1); |
| Opnd* thisLen = getCallSrc(callInst, 2); |
| Opnd* trgtArr = getCallSrc(callInst, 3); |
| Opnd* trgtOffset = getCallSrc(callInst, 4); |
| Opnd* trgtLen = getCallSrc(callInst, 5); |
| Opnd* start = getCallSrc(callInst, 6); |
| Opnd* res = getCallDst(callInst); |
| |
| #ifdef _EM64T_ |
| Type* counterType = irm->getTypeManager().getInt64Type(); |
| Constraint regConstr(OpndKind_GPReg, OpndSize_64); |
| #else |
| Type* counterType = irm->getTypeManager().getInt32Type(); |
| Constraint regConstr(OpndKind_GPReg, OpndSize_32); |
| #endif |
| Constraint reg16Constr(OpndKind_GPReg, OpndSize_16); |
| |
| Opnd* zero = irm->newImmOpnd(counterType, 0); |
| |
| Node* mainNode = irm->getFlowGraph()->createBlockNode(); |
| |
| Node* mainLoop = irm->getFlowGraph()->createBlockNode(); |
| Node* mainLoop2 = irm->getFlowGraph()->createBlockNode(); |
| Node* mainLoop3 = irm->getFlowGraph()->createBlockNode(); |
| Node* nestedLoop = irm->getFlowGraph()->createBlockNode(); |
| Node* nestedLoop2 = irm->getFlowGraph()->createBlockNode(); |
| Node* nestedLoop3 = irm->getFlowGraph()->createBlockNode(); |
| Node* mainLoopEnd = irm->getFlowGraph()->createBlockNode(); |
| |
| Node* returnStart = irm->getFlowGraph()->createBlockNode(); |
| Node* returnIndex = irm->getFlowGraph()->createBlockNode(); |
| Node* returnMinusOne = irm->getFlowGraph()->createBlockNode(); |
| |
| irm->getFlowGraph()->addEdge(mainNode, mainLoop); |
| |
| irm->getFlowGraph()->addEdge(mainLoop, mainLoop2, 0.9); |
| irm->getFlowGraph()->addEdge(mainLoop, returnMinusOne, 0.1); |
| irm->getFlowGraph()->addEdge(mainLoop2, mainLoop3, 0.1); |
| irm->getFlowGraph()->addEdge(mainLoop2, mainLoopEnd, 0.9); |
| irm->getFlowGraph()->addEdge(mainLoop3, nestedLoop); |
| irm->getFlowGraph()->addEdge(nestedLoop, returnIndex, 0.1); |
| irm->getFlowGraph()->addEdge(nestedLoop, nestedLoop2, 0.9); |
| irm->getFlowGraph()->addEdge(nestedLoop2, mainLoopEnd, 0.8); |
| irm->getFlowGraph()->addEdge(nestedLoop2, nestedLoop3, 0.2); |
| irm->getFlowGraph()->addEdge(nestedLoop3, nestedLoop); |
| irm->getFlowGraph()->addEdge(mainLoopEnd, mainLoop); |
| |
| irm->getFlowGraph()->addEdge(returnStart, nextNode); |
| irm->getFlowGraph()->addEdge(returnMinusOne, nextNode); |
| irm->getFlowGraph()->addEdge(returnIndex, nextNode); |
| |
| Opnd* subLen = irm->newOpnd(counterType, regConstr); |
| |
| bool startIsZero = true; |
| if ( !(start->isPlacedIn(OpndKind_Imm) && start->getImmValue() == 0) ) |
| startIsZero = false; |
| |
| if ( !start->isPlacedIn(OpndKind_Imm) ) |
| { |
| Node* startLessThanZero = irm->getFlowGraph()->createBlockNode(); |
| Node* subLenCheck = irm->getFlowGraph()->createBlockNode(); |
| Node* startCheck = irm->getFlowGraph()->createBlockNode(); |
| |
| irm->getFlowGraph()->addEdge(callInstNode, startLessThanZero, 0); |
| irm->getFlowGraph()->addEdge(callInstNode, subLenCheck, 1); |
| irm->getFlowGraph()->addEdge(startLessThanZero, subLenCheck); |
| irm->getFlowGraph()->addEdge(subLenCheck, startCheck, 0); |
| irm->getFlowGraph()->addEdge(subLenCheck, mainNode, 1); |
| irm->getFlowGraph()->addEdge(startCheck, returnMinusOne, 0); |
| irm->getFlowGraph()->addEdge(startCheck, returnStart, 1); |
| |
| callInstNode->appendInst(irm->newInst(Mnemonic_CMP, start, zero)); // cmp start, 0 |
| callInstNode->appendInst(irm->newBranchInst(Mnemonic_JL, startLessThanZero, subLenCheck)); // jl startLessThanZero |
| |
| startLessThanZero->appendInst(irm->newInst(Mnemonic_MOV, start, zero)); // mov start, 0 |
| |
| // saving subString.length on register |
| subLenCheck->appendInst(irm->newCopyPseudoInst(Mnemonic_MOV, subLen, trgtLen)); // mov subLen, subString.count |
| subLenCheck->appendInst(irm->newInst(Mnemonic_CMP, subLen, zero)); // cmp subLen, 0 |
| subLenCheck->appendInst(irm->newBranchInst(Mnemonic_JE, startCheck, mainNode)); // je startCheck |
| |
| startCheck->appendInst(irm->newInst(Mnemonic_CMP, start, thisLen)); // cmp start, this.count |
| startCheck->appendInst(irm->newBranchInst(Mnemonic_JG, returnMinusOne, returnStart)); // jg returnMinusOne |
| } |
| else // removing unnecessary checks |
| { |
| int64 val = start->getImmValue(); |
| if (val <0) |
| { |
| start = zero; |
| val = 0; |
| } |
| |
| // saving subString.length on register |
| callInstNode->appendInst(irm->newCopyPseudoInst(Mnemonic_MOV, subLen, trgtLen)); // mov subLen, subString.count |
| callInstNode->appendInst(irm->newInst(Mnemonic_CMP, subLen, zero)); // cmp subLen, 0 |
| |
| if (val != 0) |
| { |
| Node* startCheck = irm->getFlowGraph()->createBlockNode(); |
| |
| irm->getFlowGraph()->addEdge(callInstNode, mainNode, 1); |
| irm->getFlowGraph()->addEdge(callInstNode, startCheck, 0); |
| irm->getFlowGraph()->addEdge(startCheck, returnMinusOne, 0); |
| irm->getFlowGraph()->addEdge(startCheck, returnStart, 1); |
| |
| callInstNode->appendInst(irm->newBranchInst(Mnemonic_JE, startCheck, mainNode)); // je startCheck |
| |
| startCheck->appendInst(irm->newInst(Mnemonic_CMP, thisLen, start)); // cmp this.count, start |
| startCheck->appendInst(irm->newBranchInst(Mnemonic_JL, returnMinusOne, returnStart)); // jl returnMinusOne |
| } |
| else |
| { |
| irm->getFlowGraph()->addEdge(callInstNode, mainNode, 1); |
| irm->getFlowGraph()->addEdge(callInstNode, returnStart, 0); |
| callInstNode->appendInst(irm->newBranchInst(Mnemonic_JE, returnStart, mainNode)); // je returnStart |
| } |
| } |
| |
| // prepare this position |
| Opnd* offset = irm->newOpnd(counterType, regConstr); |
| mainNode->appendInst(irm->newCopyPseudoInst(Mnemonic_MOV, offset, thisOffset)); // mov offset, this.offset |
| if (!startIsZero) |
| mainNode->appendInst(irm->newInst(Mnemonic_ADD, offset, start)); // add offset, start |
| Opnd* thisAddrReg = addElemIndexWithLEA(thisArr, offset, RegName_Null, mainNode); // lea edi, [this.value + offset*sizeof(char) + 12] |
| |
| // prepare trgt position |
| Opnd* trgtAddrReg = addElemIndexWithLEA(trgtArr, trgtOffset, RegName_Null, mainNode); // lea esi, [subString.value + subString.offset*sizeof(char) + 12] |
| |
| // lastIndex = this.count - subString.count - start |
| Opnd* lastIndex = irm->newOpnd(counterType, regConstr); |
| mainNode->appendInst(irm->newCopyPseudoInst(Mnemonic_MOV, lastIndex, thisLen)); // mov lastIndex, this.count |
| mainNode->appendInst(irm->newInst(Mnemonic_SUB, lastIndex, subLen)); // sub lastIndex, subLen |
| if (!startIsZero) |
| mainNode->appendInst(irm->newInst(Mnemonic_SUB, lastIndex, start)); // sub lastIndex, start |
| |
| //save subString's first char |
| Opnd* firstChar = irm->newOpnd(irm->getTypeManager().getCharType(), reg16Constr); |
| mainNode->appendInst(irm->newInst(Mnemonic_MOV, firstChar, irm->newMemOpnd(irm->getTypeManager().getCharType(), trgtAddrReg, 0, 0, 0))); // mov firstChar, word ptr [esi] |
| |
| // preparing main loop iterator |
| Opnd* mainLoopIter = irm->newOpnd(counterType, regConstr); |
| mainNode->appendInst(irm->newInst(Mnemonic_MOV, mainLoopIter, zero)); // mov mainLoopIter, 0 |
| |
| //***************************************************************************************************** |
| |
| // main loop |
| mainLoop->appendInst(irm->newInst(Mnemonic_CMP, mainLoopIter, lastIndex)); // cmp mainLoopIter, lastIndex |
| mainLoop->appendInst(irm->newBranchInst(Mnemonic_JG, returnMinusOne, mainLoop2)); // jg returnMinusOne |
| |
| Opnd* currentChar = irm->newMemOpnd(irm->getTypeManager().getCharType(), thisAddrReg, 0, 0, 0); |
| mainLoop2->appendInst(irm->newInst(Mnemonic_CMP, currentChar, firstChar)); // cmp word ptr [edi], firstChar |
| mainLoop2->appendInst(irm->newBranchInst(Mnemonic_JNE, mainLoopEnd, mainLoop3)); // jne mainLoopEnd |
| |
| // preparing nested loop iterator |
| Opnd* nestedLoopIter = irm->newOpnd(counterType, regConstr); |
| mainLoop3->appendInst(irm->newInst(Mnemonic_MOV, nestedLoopIter, irm->newImmOpnd(counterType, 1))); // mov nestedLoopIter, 1 |
| |
| nestedLoop->appendInst(irm->newInst(Mnemonic_CMP, nestedLoopIter, subLen)); // cmp nestedLoopIter, subLen |
| nestedLoop->appendInst(irm->newBranchInst(Mnemonic_JGE, returnIndex, nestedLoop2)); // jge returnIndex |
| |
| Opnd* tmp = irm->newRegOpnd(irm->getTypeManager().getCharType(), RegName_DX); |
| nestedLoop2->appendInst(irm->newInst(Mnemonic_MOV, tmp, irm->newMemOpnd(irm->getTypeManager().getCharType(), thisAddrReg, nestedLoopIter, irm->newImmOpnd(counterType, 2), 0))); // mov tmp, [edi + 2*nestedLoopIter] |
| nestedLoop2->appendInst(irm->newInst(Mnemonic_CMP, tmp, irm->newMemOpnd(irm->getTypeManager().getCharType(), trgtAddrReg, nestedLoopIter, irm->newImmOpnd(counterType, 2), 0))); // cmp tmp, [esi + 2*nestedLoopIter] |
| nestedLoop2->appendInst(irm->newBranchInst(Mnemonic_JNE, mainLoopEnd, nestedLoop3)); // jne mainLoopEnd |
| |
| nestedLoop3->appendInst(irm->newInst(Mnemonic_ADD, nestedLoopIter, irm->newImmOpnd(counterType, 1))); // add nestedLoopIter, 1 |
| |
| mainLoopEnd->appendInst(irm->newInst(Mnemonic_ADD, mainLoopIter, irm->newImmOpnd(counterType, 1))); // add mainLoopIter, 1 |
| mainLoopEnd->appendInst(irm->newInst(Mnemonic_ADD, thisAddrReg, irm->newImmOpnd(counterType, 2))); // add edi, 2 |
| |
| returnMinusOne->appendInst(irm->newInst(Mnemonic_MOV, res, irm->newImmOpnd(res->getType(), -1))); |
| |
| returnStart->appendInst(irm->newInst(Mnemonic_MOV, res, start)); |
| |
| returnIndex->appendInst(irm->newInst(Mnemonic_MOV, res, mainLoopIter)); |
| |
| if (!startIsZero) |
| returnIndex->appendInst(irm->newInst(Mnemonic_ADD, res, start)); |
| |
| callInst->unlink(); |
| } |
| |
| void APIMagicHandler::convertIntToInt(Opnd* dst, Opnd* src, Node* node) |
| { |
| Type* dstType = dst->getType(); |
| Type* srcType = src->getType(); |
| |
| // this works only for equal types |
| // or Int32 into IntPtr conversion |
| assert(srcType == dstType || (srcType == irm->getTypeManager().getInt32Type() && |
| dstType == irm->getTypeManager().getIntPtrType())); |
| |
| if(srcType != dstType) { |
| #ifdef _EM64T_ |
| node->appendInst(irm->newInstEx(Mnemonic_MOVZX, 1, dst, src)); |
| #else |
| node->appendInst(irm->newCopyPseudoInst(Mnemonic_MOV, dst, src)); |
| #endif |
| } |
| } |
| |
| // Compute address of the array element given |
| // address of the first element and index |
| // using 'LEA' instruction |
| |
| Opnd* APIMagicHandler::addElemIndexWithLEA(Opnd* array, Opnd* index, RegName dstRegName, Node* node) |
| { |
| ArrayType * arrayType = array->getType()->asArrayType(); |
| Type * elemType = arrayType->getElementType(); |
| Type * dstType = irm->getManagedPtrType(elemType); |
| //Opnd * dst = irm->newRegOpnd(dstType,dstRegName); |
| Opnd* dst; |
| if (dstRegName != RegName_Null) |
| dst = irm->newRegOpnd(dstType,dstRegName); |
| else |
| { |
| Constraint reg32Constr(OpndKind_GPReg, OpndSize_32); |
| dst = irm->newOpnd(dstType,reg32Constr); |
| } |
| |
| // TypeManager& typeManager = typeManager; |
| #ifdef _EM64T_ |
| Type * offType = typeManager.getInt64Type(); |
| #else |
| Type * offType = typeManager.getInt32Type(); |
| #endif |
| Type * indexType = typeManager.getIntPtrType(); |
| |
| U_32 elemSize = 0; |
| if (elemType->isReference() |
| && Type::isCompressedReference(elemType->tag, irm->getCompilationInterface()) |
| && !elemType->isCompressedReference()) { |
| elemSize = 4; |
| } else { |
| elemSize = getByteSize(irm->getTypeSize(elemType)); |
| } |
| Opnd * elemSizeOpnd = irm->newImmOpnd(indexType, elemSize); |
| |
| Opnd * indexOpnd = NULL; |
| if ( index->isPlacedIn(OpndKind_Imm) && index->getImmValue() == 0 ) { |
| indexOpnd = NULL; |
| elemSizeOpnd = NULL; |
| } else { |
| indexOpnd = irm->newOpnd(indexType); |
| convertIntToInt(indexOpnd,index,node); |
| } |
| Opnd * arrOffset = irm->newImmOpnd(offType, arrayType->getArrayElemOffset()); |
| Opnd * addr = irm->newMemOpnd(dstType,(Opnd*)array, indexOpnd, elemSizeOpnd, arrOffset); |
| node->appendInst(irm->newInstEx(Mnemonic_LEA, 1, dst, addr)); |
| |
| return dst; |
| } |
| |
| |
| }} //namespace |
| |
| |
| |
| |
| |
| |
