/* * 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, Pavel A. Ozhdikhin */ #include "MemoryManager.h" #include "IRBuilder.h" #include "Inst.h" #include "CSEHash.h" #include "Log.h" #include "irmanager.h" #include "CompilationContext.h" namespace Jitrino { #if defined(_MSC_VER) && !defined (__ICL) && !defined (__GNUC__) #pragma warning(disable : 4355) #endif static const char* help = \ " expansion flags:\n"\ " expandMemAddrs[={ON|off}]\n"\ " expandElemAddrs[={ON|off}]\n"\ " expandCallAddrs[={on|OFF}]\n"\ " expandVirtualCallAddrs[={ON|off}]\n"\ " expandNullChecks[={ON|off}]\n"\ " expandElemTypeChecks[={ON|off}]\n"\ " translation-time optimizations:\n"\ " doCSE[={ON|off}]\n"\ " doSimplify[={ON|off}]\n"\ " suppressCheckBounds[={on|OFF}] - omit all bounds checks\n"\ " insertMethodLabels[={on|OFF}]\n"\ " compressedReferences[={on|OFF}] - force compressed references\n"; static ActionFactory _irbuilder(IRBUILDER_ACTION_NAME, help); class IRBuilderSimplifier : public Simplifier { public: IRBuilderSimplifier(IRBuilder& irb) : Simplifier(*irb.getIRManager(), false), irBuilder(irb) {} protected: // numeric virtual Inst* genAdd(Type* type, Modifier mod, Opnd* src1, Opnd* src2){ return irBuilder.genAdd(type, mod, src1, src2)->getInst(); } virtual Inst* genSub(Type* type, Modifier mod, Opnd* src1, Opnd* src2) { return irBuilder.genSub(type, mod, src1, src2)->getInst(); } virtual Inst* genNeg(Type* type, Opnd* src) { return irBuilder.genNeg(type, src)->getInst(); } virtual Inst* genMul(Type* type, Modifier mod, Opnd* src1, Opnd* src2){ return irBuilder.genMul(type, mod, src1, src2)->getInst(); } virtual Inst* genMulHi(Type* type, Modifier mod, Opnd* src1, Opnd* src2){ return irBuilder.genMulHi(type, mod, src1, src2)->getInst(); } virtual Inst* genMin(Type* type, Opnd* src1, Opnd* src2){ return irBuilder.genMin(type, src1, src2)->getInst(); } virtual Inst* genMax(Type* type, Opnd* src1, Opnd* src2){ return irBuilder.genMax(type, src1, src2)->getInst(); } virtual Inst* genAbs(Type* type, Opnd* src1){ return irBuilder.genAbs(type, src1)->getInst(); } // bitwise virtual Inst* genAnd(Type* type, Opnd* src1, Opnd* src2){ return irBuilder.genAnd(type, src1, src2)->getInst(); } virtual Inst* genOr(Type* type, Opnd* src1, Opnd* src2){ return irBuilder.genOr(type, src1, src2)->getInst(); } virtual Inst* genXor(Type* type, Opnd* src1, Opnd* src2){ return irBuilder.genXor(type, src1, src2)->getInst(); } virtual Inst* genNot(Type* type, Opnd* src1){ return irBuilder.genNot(type, src1)->getInst(); } virtual Inst* genSelect(Type* type, Opnd* src1, Opnd* src2, Opnd* src3){ return irBuilder.genSelect(type, src1, src2, src3)->getInst(); } // conversion virtual Inst* genConv(Type* dstType, Type::Tag toType, Modifier ovfMod, Opnd* src){ return irBuilder.genConv(dstType, toType, ovfMod, src)->getInst(); } virtual Inst* genConvZE(Type* dstType, Type::Tag toType, Modifier ovfMod, Opnd* src){ return irBuilder.genConvZE(dstType, toType, ovfMod, src)->getInst(); } virtual Inst* genConvUnmanaged(Type* dstType, Type::Tag toType, Modifier ovfMod, Opnd* src){ return irBuilder.genConvUnmanaged(dstType, toType, ovfMod, src)->getInst(); } // shifts virtual Inst* genShladd(Type* type, Opnd* src1, Opnd* src2, Opnd *src3){ return irBuilder.genShladd(type, src1, src2, src3)->getInst(); } virtual Inst* genShl(Type* type, Modifier smmod, Opnd* src1, Opnd* src2){ return irBuilder.genShl(type, smmod, src1, src2)->getInst(); } virtual Inst* genShr(Type* type, Modifier mods, Opnd* src1, Opnd* src2){ return irBuilder.genShr(type, mods, src1, src2)->getInst(); } // comparison virtual Inst* genCmp(Type* type, Type::Tag insttype, ComparisonModifier mod, Opnd* src1, Opnd* src2){ return irBuilder.genCmp(type, insttype, mod, src1, src2)->getInst(); } // control flow virtual void genJump(LabelInst* label) { irBuilder.genJump(label); } virtual void genBranch(Type::Tag instType, ComparisonModifier mod, LabelInst* label, Opnd* src1, Opnd* src2) { irBuilder.genBranch(instType, mod, label, src1, src2); } virtual void genBranch(Type::Tag instType, ComparisonModifier mod, LabelInst* label, Opnd* src1) { irBuilder.genBranch(instType, mod, label, src1); } virtual Inst* genDirectCall(MethodDesc* methodDesc,Type* returnType,Opnd* tauNullCheckedFirstArg, Opnd* tauTypesChecked,U_32 numArgs,Opnd* args[]) { irBuilder.genDirectCall(methodDesc, returnType, tauNullCheckedFirstArg, tauTypesChecked, numArgs, args); return (Inst*)irBuilder.getCurrentLabel()->getNode()->getLastInst(); } // load, store & mov virtual Inst* genLdConstant(I_32 val) { return irBuilder.genLdConstant(val)->getInst(); } virtual Inst* genLdConstant(int64 val) { return irBuilder.genLdConstant(val)->getInst(); } virtual Inst* genLdConstant(float val) { return irBuilder.genLdConstant(val)->getInst(); } virtual Inst* genLdConstant(double val) { return irBuilder.genLdConstant(val)->getInst(); } virtual Inst* genLdConstant(Type *type, ConstInst::ConstValue val) { return irBuilder.genLdConstant(type, val)->getInst(); } virtual Inst* genTauLdInd(Modifier mod, Type* dstType, Type::Tag ldType, Opnd* src, Opnd *tauNonNullBase, Opnd *tauAddressInRange) { return irBuilder.genTauLdInd(mod, dstType, ldType, src, tauNonNullBase, tauAddressInRange)->getInst(); } virtual Inst* genLdRef(Modifier mod, Type* dstType, U_32 token, MethodDesc *enclosingMethod) { return irBuilder.genLdRef(mod, dstType, token, enclosingMethod)->getInst(); } virtual Inst* genLdFunAddrSlot(MethodDesc* methodDesc) { return irBuilder.genLdFunAddrSlot(methodDesc)->getInst(); } virtual Inst* genGetVTableAddr(ObjectType* type) { return irBuilder.genGetVTable(type)->getInst(); } // compressed references virtual Inst* genCompressRef(Opnd *uncompref){ return irBuilder.genCompressRef(uncompref)->getInst(); } virtual Inst* genUncompressRef(Opnd *compref){ return irBuilder.genUncompressRef(compref)->getInst(); } virtual Inst *genLdFieldOffsetPlusHeapbase(FieldDesc* fd) { return irBuilder.genLdFieldOffsetPlusHeapbase(fd)->getInst(); } virtual Inst *genLdArrayBaseOffsetPlusHeapbase(Type *elemType) { return irBuilder.genLdArrayBaseOffsetPlusHeapbase(elemType)->getInst(); } virtual Inst *genLdArrayLenOffsetPlusHeapbase(Type *elemType) { return irBuilder.genLdArrayLenOffsetPlusHeapbase(elemType)->getInst(); } virtual Inst *genAddOffsetPlusHeapbase(Type *ptrType, Opnd *compRef, Opnd *offsetPlusHeapbase) { return irBuilder.genAddOffsetPlusHeapbase(ptrType, compRef, offsetPlusHeapbase)->getInst(); } virtual Inst *genTauSafe() { return irBuilder.genTauSafe()->getInst(); } virtual Inst *genTauMethodSafe() { return irBuilder.genTauMethodSafe()->getInst(); } virtual Inst *genTauUnsafe() { return irBuilder.genTauUnsafe()->getInst(); } virtual Inst* genTauStaticCast(Opnd *src, Opnd *tauCheckedCast, Type *castType) { return irBuilder.genTauStaticCast(src, tauCheckedCast, castType)->getInst(); } virtual Inst* genTauHasType(Opnd *src, Type *castType) { return irBuilder.genTauHasType(src, castType)->getInst(); } virtual Inst* genTauHasExactType(Opnd *src, Type *castType) { return irBuilder.genTauHasExactType(src, castType)->getInst(); } virtual Inst* genTauIsNonNull(Opnd *src) { return irBuilder.genTauIsNonNull(src)->getInst(); } // helper for store simplification, builds/finds simpler src, possibly // modifies typetag or store modifier. virtual Opnd* simplifyStoreSrc(Opnd *src, Type::Tag &typetag, Modifier &mod, bool compressRef) { return 0; } virtual void foldBranch(BranchInst* br, bool isTaken) { assert(0); } virtual void foldSwitch(SwitchInst* sw, U_32 index) { assert(0); } virtual void eliminateCheck(Inst* checkInst, bool alwaysThrows) { assert(0); } virtual void genThrowSystemException(CompilationInterface::SystemExceptionId id) { irBuilder.genThrowSystemException(id); } private: IRBuilder& irBuilder; }; void IRBuilderAction::init() { readFlags(); } void IRBuilderAction::readFlags() { // IRBuilder expansion flags // irBuilderFlags.expandMemAddrs = getBoolArg("expandMemAddrs", true); irBuilderFlags.expandElemAddrs = getBoolArg("expandElemAddrs", true); irBuilderFlags.expandCallAddrs = getBoolArg("expandCallAddrs", false); irBuilderFlags.expandVirtualCallAddrs = getBoolArg("expandVirtualCallAddrs", true); irBuilderFlags.expandNullChecks = getBoolArg("expandNullChecks", true); irBuilderFlags.expandElemTypeChecks = getBoolArg("expandElemTypeChecks", true); // // IRBuilder translation-time optimizations // irBuilderFlags.doCSE = getBoolArg("doCSE", true); irBuilderFlags.doSimplify = getBoolArg("doSimplify", true); irBuilderFlags.suppressCheckBounds = getBoolArg("suppressCheckBounds", false); irBuilderFlags.insertMethodLabels = getBoolArg("insertMethodLabels", true); irBuilderFlags.compressedReferences = getBoolArg("compressedReferences", false); irBuilderFlags.genMinMaxAbs = getBoolArg("genMinMaxAbs", false); irBuilderFlags.genFMinMaxAbs = getBoolArg("genFMinMaxAbs", false); irBuilderFlags.useNewTypeSystem = getBoolArg("useNewTypeSystem", false); } IRBuilder::IRBuilder() : irManager(NULL), opndManager(NULL), typeManager(NULL), instFactory(NULL), flowGraph(NULL), translatorFlags(NULL), currentLabel(NULL), cseHashTable(NULL), simplifier(NULL), tauMethodSafeOpnd(NULL), offset(0) { } void IRBuilder::init(IRManager* irm, TranslatorFlags* traFlags, MemoryManager& tmpMM) { IRBuilderAction* myAction = (IRBuilderAction*)getAction(); irBuilderFlags = myAction->getFlags(); //copy of flags irManager=irm; opndManager=&irm->getOpndManager(); typeManager = &irm->getTypeManager(); instFactory = &irm->getInstFactory(); flowGraph = &irm->getFlowGraph(); translatorFlags = traFlags; MemoryManager& mm = irm->getMemoryManager(); cseHashTable = new (tmpMM) CSEHashTable(mm); simplifier = new (mm) IRBuilderSimplifier(*this); CompilationInterface* ci = getCompilationContext()->getVMCompilationInterface(); irBuilderFlags.insertWriteBarriers = ci->needWriteBarriers(); irBuilderFlags.compressedReferences = irBuilderFlags.compressedReferences || VMInterface::areReferencesCompressed(); } void IRBuilder::invalid() { Log::out() << " !!!! ---- IRBuilder::invalid ---- !!!! " << ::std::endl; assert(0); } void IRBuilder::updateCurrentLabelBcOffset() { assert(currentLabel!=NULL); if (currentLabel->getBCOffset()==ILLEGAL_BC_MAPPING_VALUE) { assert(currentLabel->getNode() == NULL || currentLabel->getNode()->isEmpty()); currentLabel->setBCOffset((uint16)offset); } } Inst* IRBuilder::appendInst(Inst* inst) { updateCurrentLabelBcOffset(); assert(currentLabel->getBCOffset()!=ILLEGAL_BC_MAPPING_VALUE); inst->setBCOffset((uint16)offset); Node* node = currentLabel->getNode(); node->appendInst(inst); if(Log::isEnabled()) { inst->print(Log::out()); Log::out() << std::endl; Log::out().flush(); } return inst; } void IRBuilder::killCSE() { cseHashTable->kill(); } void IRBuilder::genLabel(LabelInst* labelInst) { cseHashTable->kill(); currentLabel = labelInst; updateCurrentLabelBcOffset(); if(Log::isEnabled()) { currentLabel->print(Log::out()); Log::out() << std::endl; Log::out().flush(); } } void IRBuilder::genFallThroughLabel(LabelInst* labelInst) { currentLabel = labelInst; updateCurrentLabelBcOffset(); if(Log::isEnabled()) { currentLabel->print(Log::out()); Log::out() << std::endl; Log::out().flush(); } } LabelInst* IRBuilder::createLabel() { currentLabel = (LabelInst*)instFactory->makeLabel(); updateCurrentLabelBcOffset(); return currentLabel; } void IRBuilder::createLabels(U_32 numLabels, LabelInst** labels) { for (U_32 i=0; imakeLabel(); } } LabelInst* IRBuilder::genMethodEntryLabel(MethodDesc* methodDesc) { currentLabel = instFactory->makeMethodEntryLabel(methodDesc); currentLabel->setBCOffset(0); if(Log::isEnabled()) { currentLabel->print(Log::out()); Log::out() << std::endl; Log::out().flush(); } return currentLabel; } // compute instructions Opnd* IRBuilder::genAdd(Type* dstType, Modifier mod, Opnd* src1, Opnd* src2) { src1 = propagateCopy(src1); src2 = propagateCopy(src2); Operation operation(Op_Add, dstType->tag, mod); U_32 hashcode = operation.encodeForHashing(); Opnd* dst = lookupHash(hashcode, src1, src2); if (dst) return dst; if (irBuilderFlags.doSimplify) { dst = simplifier->simplifyAdd(dstType, mod, src1, src2); } if (!dst) { dst = createOpnd(dstType); Inst *newi = instFactory->makeAdd(mod, dst, src1, src2); appendInst(newi); } insertHash(hashcode, src1, src2, dst->getInst()); return dst; } Opnd* IRBuilder::genMul(Type* dstType, Modifier mod, Opnd* src1, Opnd* src2) { src1 = propagateCopy(src1); src2 = propagateCopy(src2); Operation operation(Op_Mul, dstType->tag, mod); U_32 hashcode = operation.encodeForHashing(); Opnd* dst = lookupHash(hashcode, src1, src2); if (dst) return dst; if (irBuilderFlags.doSimplify) { dst = simplifier->simplifyMul(dstType, mod, src1, src2); } if (!dst) { dst = createOpnd(dstType); appendInst(instFactory->makeMul(mod, dst, src1, src2)); } insertHash(hashcode, src1, src2, dst->getInst()); return dst; } Opnd* IRBuilder::genSub(Type* dstType, Modifier mod, Opnd* src1, Opnd* src2) { src1 = propagateCopy(src1); src2 = propagateCopy(src2); Operation operation(Op_Sub, dstType->tag, mod); U_32 hashcode = operation.encodeForHashing(); Opnd* dst = lookupHash(hashcode, src1, src2); if (dst) return dst; if (irBuilderFlags.doSimplify) { dst = simplifier->simplifySub(dstType, mod, src1, src2); } if (!dst) { dst = createOpnd(dstType); appendInst(instFactory->makeSub(mod, dst, src1, src2)); } insertHash(hashcode, src1, src2, dst->getInst()); return dst; } Opnd* IRBuilder::genDiv(Type* dstType, Modifier mod, Opnd* src1, Opnd* src2) { src1 = propagateCopy(src1); src2 = propagateCopy(src2); Opnd *tauDivOk = 0; if(src2->getType()->isInteger()) tauDivOk = genTauCheckZero(src2); else tauDivOk = genTauSafe(); // safe by construction Operation operation(Op_TauDiv, dstType->tag, mod); U_32 hashcode = operation.encodeForHashing(); Opnd* dst = lookupHash(hashcode, src1, src2); // tauDivOk is not needed in hash if (dst) return dst; if (irBuilderFlags.doSimplify) { dst = simplifier->simplifyTauDiv(dstType, mod, src1, src2, tauDivOk); } if (!dst) { dst = createOpnd(dstType); appendInst(instFactory->makeTauDiv(mod, dst, src1, src2, tauDivOk)); } insertHash(hashcode, src1, src2, dst->getInst()); // tauDivOk is not needed in hash return dst; } // // for CLI: inserts a CheckDivOpnds before the divide Opnd* IRBuilder::genCliDiv(Type* dstType, Modifier mod, Opnd* src1, Opnd* src2) { src1 = propagateCopy(src1); src2 = propagateCopy(src2); Operation operation(Op_TauDiv, dstType->tag, mod); U_32 hashcode = operation.encodeForHashing(); Opnd* dst = lookupHash(hashcode, src1, src2); // tauDivOk is not needed in hash if (dst) return dst; Opnd *tauDivOk = 0; if(src2->getType()->isInteger()) { if (mod.getSignedModifier() == SignedOp) { // for CLI: if signed, insert a CheckDivOpnds before the divide tauDivOk = genTauCheckDivOpnds(src1, src2); } else { // if unsigned, still need a zero check tauDivOk = genTauCheckZero(src2); } } else { tauDivOk = genTauSafe(); // safe by construction } if (irBuilderFlags.doSimplify) { dst = simplifier->simplifyTauDiv(dstType, mod, src1, src2, tauDivOk); } if (!dst) { dst = createOpnd(dstType); appendInst(instFactory->makeTauDiv(mod, dst, src1, src2, tauDivOk)); } insertHash(hashcode, src1, src2, dst->getInst()); // tauDivOk is not needed in hash return dst; } Opnd* IRBuilder::genRem(Type* dstType, Modifier mod, Opnd* src1, Opnd* src2) { src1 = propagateCopy(src1); src2 = propagateCopy(src2); Operation operation(Op_TauRem, dstType->tag, mod); U_32 hashcode = operation.encodeForHashing(); Opnd* dst = lookupHash(hashcode, src1, src2); // tauDivOk is not needed in hash if (dst) return dst; Opnd *tauDivOk = 0; if(src2->getType()->isInteger()) tauDivOk = genTauCheckZero(src2); else tauDivOk = genTauSafe(); // safe by construction if (irBuilderFlags.doSimplify) { dst = simplifier->simplifyTauRem(dstType, mod, src1, src2, tauDivOk); } if (!dst) { dst = createOpnd(dstType); appendInst(instFactory->makeTauRem(mod, dst, src1, src2, tauDivOk)); } insertHash(hashcode, src1, src2, dst->getInst()); // tauDivOk is not needed in hash return dst; } // // for CLI: inserts a CheckDivOpnds before the divide // Opnd* IRBuilder::genCliRem(Type* dstType, Modifier mod, Opnd* src1, Opnd* src2) { src1 = propagateCopy(src1); src2 = propagateCopy(src2); Operation operation(Op_TauRem, dstType->tag, mod); U_32 hashcode = operation.encodeForHashing(); Opnd* dst = lookupHash(hashcode, src1, src2); // tauDivOk is not needed in hash if (dst) return dst; Opnd *tauDivOk = 0; if (src2->getType()->isInteger()) if (mod.getSignedModifier() == SignedOp) // for CLI: if signed, insert a CheckDivOpnds before the divide tauDivOk = genTauCheckDivOpnds(src1, src2); else // if unsigned, still need zero check tauDivOk = genTauCheckZero(src2); else tauDivOk = genTauSafe(); // safe by construction if (irBuilderFlags.doSimplify) { dst = simplifier->simplifyTauRem(dstType, mod, src1, src2, tauDivOk); } if (!dst) { dst = createOpnd(dstType); appendInst(instFactory->makeTauRem(mod, dst, src1, src2, tauDivOk)); } insertHash(hashcode, src1, src2, dst->getInst()); // tauDivOk is not needed in hash return dst; } Opnd* IRBuilder::genNeg(Type* dstType, Opnd* src) { src = propagateCopy(src); Operation operation(Op_Neg, dstType->tag, Modifier()); U_32 hashcode = operation.encodeForHashing(); Opnd* dst = lookupHash(hashcode, src); if (dst) return dst; if (irBuilderFlags.doSimplify) { dst = simplifier->simplifyNeg(dstType, src); } if (!dst) { dst = createOpnd(dstType); appendInst(instFactory->makeNeg(dst, src)); } insertHash(Op_Neg, src, dst->getInst()); return dst; } Opnd* IRBuilder::genMulHi(Type* dstType, Modifier mod, Opnd* src1, Opnd* src2) { src1 = propagateCopy(src1); src2 = propagateCopy(src2); Operation operation(Op_MulHi, dstType->tag, mod); U_32 hashcode = operation.encodeForHashing(); Opnd* dst = lookupHash(hashcode, src1, src2); if (dst) return dst; if (irBuilderFlags.doSimplify) { dst = simplifier->simplifyMulHi(dstType, mod, src1, src2); } if (!dst) { dst = createOpnd(dstType); appendInst(instFactory->makeMulHi(mod, dst, src1, src2)); } insertHash(hashcode, src1, src2, dst->getInst()); return dst; } Opnd* IRBuilder::genMin(Type* dstType, Opnd* src1, Opnd* src2) { if (irBuilderFlags.genMinMaxAbs && (!dstType->isFloatingPoint() || irBuilderFlags.genFMinMaxAbs)) { src1 = propagateCopy(src1); src2 = propagateCopy(src2); Operation operation(Op_Min, dstType->tag, Modifier()); U_32 hashcode = operation.encodeForHashing(); Opnd* dst = lookupHash(hashcode, src1, src2); if (dst) return dst; if (irBuilderFlags.doSimplify) { dst = simplifier->simplifyMin(dstType, src1, src2); } if (!dst) { dst = createOpnd(dstType); appendInst(instFactory->makeMin(dst, src1, src2)); } insertHash(hashcode, src1, src2, dst->getInst()); return dst; } else { // hand-build it Type* cmpDstType = typeManager->getInt32Type(); Type::Tag typeTag = dstType->tag; switch (typeTag) { case Type::Int32: case Type::Int64: { Opnd *cmpRes = genCmp(cmpDstType, typeTag, Cmp_GT, src2, src1); Opnd *res = genSelect(dstType, cmpRes, src1, src2); return res; } case Type::Single: case Type::Double: { // check for NaN Opnd *src1IsNaN = genCmp(cmpDstType, typeTag, Cmp_NE_Un, src1, src1); Opnd * zero = ((typeTag == Type::Single) ? genLdConstant((float)0) : genLdConstant((double)0)); // we may have [+-]0.0, which can't be distinguished by cmp Opnd *cmp2aRes = genCmp(cmpDstType, typeTag, Cmp_EQ, src1, zero); Opnd *cmp2bRes = genCmp(cmpDstType, typeTag, Cmp_EQ, src2, zero); Opnd *bothAreZero = genAnd(cmpDstType, cmp2aRes, cmp2bRes); // but this expression apparently gets correct min Opnd *minOfZeros = genNeg(dstType, genSub(dstType, Modifier(Overflow_None)| Modifier(Exception_Never)|Modifier(Strict_No), genNeg(dstType, src1), src2)); // otherwise, we can just use a simple min expression Opnd *cmpRes = genCmp(cmpDstType, typeTag, Cmp_GT, src2, src1); Opnd *simpleMin = genSelect(dstType, cmpRes, src1, src2); Opnd *res = genSelect(dstType, src1IsNaN, src1, genSelect(dstType, bothAreZero, minOfZeros, simpleMin)); return res; } default: break; } assert(0); return 0; } } Opnd* IRBuilder::genMax(Type* dstType, Opnd* src1, Opnd* src2) { if (irBuilderFlags.genMinMaxAbs && (!dstType->isFloatingPoint() || irBuilderFlags.genFMinMaxAbs)) { src1 = propagateCopy(src1); src2 = propagateCopy(src2); Operation operation(Op_Max, dstType->tag, Modifier()); U_32 hashcode = operation.encodeForHashing(); Opnd* dst = lookupHash(hashcode, src1, src2); if (dst) return dst; if (irBuilderFlags.doSimplify) { dst = simplifier->simplifyMax(dstType, src1, src2); } if (!dst) { dst = createOpnd(dstType); appendInst(instFactory->makeMax(dst, src1, src2)); } insertHash(hashcode, src1, src2, dst->getInst()); return dst; } else { Type::Tag typeTag = dstType->tag; Type* cmpDstType = typeManager->getInt32Type(); switch (typeTag) { case Type::Int32: case Type::Int64: { Opnd *cmpRes = genCmp(cmpDstType, typeTag, Cmp_GT, src1, src2); Opnd *res = genSelect(dstType, cmpRes, src1, src2); return res; } case Type::Single: case Type::Double: { // check for NaN Opnd *src1IsNaN = genCmp(cmpDstType, typeTag, Cmp_NE_Un, src1, src1); Opnd * zero = ((typeTag == Type::Single) ? genLdConstant((float)0) : genLdConstant((double)0)); // we may have [+-]0.0, which can't be distinguished by cmp Opnd *cmp2aRes = genCmp(cmpDstType, typeTag, Cmp_EQ, src1, zero); Opnd *cmp2bRes = genCmp(cmpDstType, typeTag, Cmp_EQ, src2, zero); Opnd *bothAreZero = genAnd(cmpDstType, cmp2aRes, cmp2bRes); // but this expression apparently gets correct max Opnd *maxOfZeros = genSub(dstType, Modifier(Overflow_None)| Modifier(Exception_Never)|Modifier(Strict_No), src1, genNeg(dstType, src2)); Opnd *cmpRes = genCmp(cmpDstType, typeTag, Cmp_GT, src1, src2); Opnd *simpleMin = genSelect(dstType, cmpRes, src1, src2); Opnd *res = genSelect(dstType, src1IsNaN, src1, genSelect(dstType, bothAreZero, maxOfZeros, simpleMin)); return res; } default: break; } assert(0); return 0; } } Opnd* IRBuilder::genAbs(Type* dstType, Opnd* src1) { if (irBuilderFlags.genMinMaxAbs && (!dstType->isFloatingPoint() || irBuilderFlags.genFMinMaxAbs)) { src1 = propagateCopy(src1); Operation operation(Op_Abs, dstType->tag, Modifier()); U_32 hashcode = operation.encodeForHashing(); Opnd* dst = lookupHash(hashcode, src1); if (dst) return dst; if (irBuilderFlags.doSimplify) { dst = simplifier->simplifyAbs(dstType, src1); } if (!dst) { dst = createOpnd(dstType); appendInst(instFactory->makeAbs(dst, src1)); } insertHash(hashcode, src1, dst->getInst()); return dst; } else { // hand-build it Type::Tag typeTag = src1->getType()->tag; Type* cmpDstType = typeManager->getInt32Type(); switch (typeTag) { case Type::Int32: case Type::Int64: { Opnd *zero = ((typeTag == Type::Int32) ? genLdConstant((I_32)0) : genLdConstant((int64)0)); Opnd *cmpRes = genCmp(cmpDstType, typeTag, Cmp_GT, zero, src1); Opnd *negSrc = genNeg(dstType, src1); Opnd *res = genSelect(dstType, cmpRes, negSrc, src1); return res; } case Type::Single: case Type::Double: { Opnd *zero = ((typeTag == Type::Single) ? genLdConstant((float)0) : genLdConstant((double)0)); Opnd *cmpRes = genCmp(cmpDstType, typeTag, Cmp_GTE, zero, src1); Opnd *negSrc = genSub(dstType, Modifier(Overflow_None)| Modifier(Exception_Never)|Modifier(Strict_No), zero, src1); Opnd *res = genSelect(dstType, cmpRes, negSrc, src1); return res; } default: break; } assert(0); return 0; } } // bitwise instructions Opnd* IRBuilder::genAnd(Type* dstType, Opnd* src1, Opnd* src2) { src1 = propagateCopy(src1); src2 = propagateCopy(src2); Opnd* dst = lookupHash(Op_And, src1, src2); if (dst) return dst; if (irBuilderFlags.doSimplify) { dst = simplifier->simplifyAnd(dstType, src1, src2); } if (!dst) { dst = createOpnd(dstType); appendInst(instFactory->makeAnd(dst, src1, src2)); } insertHash(Op_And, src1, src2, dst->getInst()); return dst; } Opnd* IRBuilder::genOr(Type* dstType, Opnd* src1, Opnd* src2) { src1 = propagateCopy(src1); src2 = propagateCopy(src2); Opnd* dst = lookupHash(Op_Or, src1, src2); if (dst) return dst; if (irBuilderFlags.doSimplify) { dst = simplifier->simplifyOr(dstType, src1, src2); } if (!dst) { dst = createOpnd(dstType); appendInst(instFactory->makeOr(dst, src1, src2)); } insertHash(Op_Or, src1, src2, dst->getInst()); return dst; } Opnd* IRBuilder::genXor(Type* dstType, Opnd* src1, Opnd* src2) { src1 = propagateCopy(src1); src2 = propagateCopy(src2); Opnd* dst = lookupHash(Op_Xor, src1, src2); if (dst) return dst; if (irBuilderFlags.doSimplify) { dst = simplifier->simplifyXor(dstType, src1, src2); } if (!dst) { dst = createOpnd(dstType); appendInst(instFactory->makeXor(dst, src1, src2)); } insertHash(Op_Xor, src1, src2, dst->getInst()); return dst; } Opnd* IRBuilder::genNot(Type* dstType, Opnd* src) { src = propagateCopy(src); Opnd* dst = lookupHash(Op_Not, src); if (dst) return dst; if (irBuilderFlags.doSimplify) { dst = simplifier->simplifyNot(dstType, src); } if (!dst) { dst = createOpnd(dstType); appendInst(instFactory->makeNot(dst, src)); } insertHash(Op_Not, src, dst->getInst()); return dst; } // selection Opnd* IRBuilder::genSelect(Type* dstType, Opnd* src1, Opnd* src2, Opnd* src3) { src1 = propagateCopy(src1); src2 = propagateCopy(src2); src3 = propagateCopy(src3); Opnd* dst = lookupHash(Op_Select, src1, src2, src3); if (dst) return dst; if (irBuilderFlags.doSimplify) { dst = simplifier->simplifySelect(dstType, src1, src2, src3); } if (!dst) { dst = createOpnd(dstType); appendInst(instFactory->makeSelect(dst, src1, src2, src3)); } insertHash(Op_Select, src1, src2, src3, dst->getInst()); return dst; } // Conversion Opnd* IRBuilder::genConv(Type* dstType, Type::Tag toType, Modifier ovfMod, Opnd* src) { src = propagateCopy(src); Operation operation(Op_Conv, toType, ovfMod); U_32 hashcode = operation.encodeForHashing(); Opnd* dst = lookupHash(hashcode, src->getId()); if (dst) return dst; if (irBuilderFlags.doSimplify) { dst = simplifier->simplifyConv(dstType, toType, ovfMod, src); } if (!dst) { dst = createOpnd(dstType); Inst* inst = instFactory->makeConv(ovfMod, toType, dst, src); appendInst(inst); } insertHash(hashcode, src->getId(), dst->getInst()); return dst; } Opnd* IRBuilder::genConvUnmanaged(Type* dstType, Type::Tag toType, Modifier ovfMod, Opnd* src) { assert((dstType->isUnmanagedPtr() && src->getType()->isObject()) || (dstType->isObject() && src->getType()->isUnmanagedPtr())); src = propagateCopy(src); Operation operation(Op_ConvUnmanaged, toType, ovfMod); U_32 hashcode = operation.encodeForHashing(); Opnd* dst = lookupHash(hashcode, src->getId()); if (dst) return dst; if (irBuilderFlags.doSimplify) { dst = simplifier->simplifyConvUnmanaged(dstType, toType, ovfMod, src); } if (!dst) { dst = createOpnd(dstType); Inst* inst = instFactory->makeConvUnmanaged(ovfMod, toType, dst, src); appendInst(inst); } insertHash(hashcode, src->getId(), dst->getInst()); return dst; } Opnd* IRBuilder::genConvZE(Type* dstType, Type::Tag toType, Modifier ovfMod, Opnd* src) { assert(src->getType()->isInteger() && (dstType->isInteger() || dstType->isUnmanagedPtr())); src = propagateCopy(src); Operation operation(Op_ConvZE, toType, ovfMod); U_32 hashcode = operation.encodeForHashing(); Opnd* dst = lookupHash(hashcode, src->getId()); if (dst) return dst; if (irBuilderFlags.doSimplify) { dst = simplifier->simplifyConvZE(dstType, toType, ovfMod, src); } if (!dst) { dst = createOpnd(dstType); Inst* inst = instFactory->makeConvZE(ovfMod, toType, dst, src); appendInst(inst); } insertHash(hashcode, src->getId(), dst->getInst()); return dst; } // Shift Opnd* IRBuilder::genShladd(Type* dstType, Opnd* value, Opnd* shiftAmount, Opnd* addTo) { value = propagateCopy(value); shiftAmount = propagateCopy(shiftAmount); addTo = propagateCopy(addTo); Opnd* dst = lookupHash(Op_Shladd, value, shiftAmount, addTo); if (dst) return dst; if (irBuilderFlags.doSimplify) { dst = simplifier->simplifyShladd(dstType, value, shiftAmount, addTo); } if (!dst) { dst = createOpnd(dstType); appendInst(instFactory->makeShladd(dst, value, shiftAmount, addTo)); } insertHash(Op_Shladd, value, shiftAmount, addTo, dst->getInst()); return dst; } Opnd* IRBuilder::genShl(Type* dstType, Modifier mod, Opnd* value, Opnd* shiftAmount) { value = propagateCopy(value); shiftAmount = propagateCopy(shiftAmount); Operation operation(Op_Shladd, dstType->tag, mod); U_32 hashcode = operation.encodeForHashing(); Opnd* dst = lookupHash(hashcode, value, shiftAmount); if (dst) return dst; if (irBuilderFlags.doSimplify) { dst = simplifier->simplifyShl(dstType, mod, value, shiftAmount); } if (!dst) { dst = createOpnd(dstType); appendInst(instFactory->makeShl(mod, dst, value, shiftAmount)); } insertHash(hashcode, value, shiftAmount, dst->getInst()); return dst; } Opnd* IRBuilder::genShr(Type* dstType, Modifier mods, Opnd* value, Opnd* shiftAmount) { value = propagateCopy(value); shiftAmount = propagateCopy(shiftAmount); Operation operation(Op_Shr, dstType->tag, mods); U_32 hashcode = operation.encodeForHashing(); Opnd* dst = lookupHash(hashcode, value, shiftAmount); if (dst) return dst; if (irBuilderFlags.doSimplify) { dst = simplifier->simplifyShr(dstType, mods, value, shiftAmount); } if (!dst) { dst = createOpnd(dstType); appendInst(instFactory->makeShr(mods, dst, value, shiftAmount)); } insertHash(hashcode, value, shiftAmount, dst->getInst()); return dst; } // Comparison Opnd* IRBuilder::genCmp(Type* dstType, Type::Tag instType, // source type for inst ComparisonModifier mod, Opnd* src1, Opnd* src2) { src1 = propagateCopy(src1); src2 = propagateCopy(src2); Operation operation(Op_Cmp, instType, mod); U_32 hashcode = operation.encodeForHashing(); Opnd* dst = lookupHash(hashcode, src1, src2); if (dst) return dst; if (irBuilderFlags.doSimplify) { dst = simplifier->simplifyCmp(dstType, instType, mod, src1, src2); } if (!dst) { // result of comparison is always a 32-bit int dst = createOpnd(dstType); Inst *i = instFactory->makeCmp(mod, instType, dst, src1, src2); appendInst(i); } insertHash(hashcode, src1, src2, dst->getInst()); return dst; } // 3-way Java-like Comparison // effect is (src1 cmp src2) ? 1 : (src2 cmp src1) ? -1 : 0 // For Float or Double args, if Cmp_GT_Un, then second compare is Cmp_GT, // and vice versa, so that // Cmp3(...,Cmp_GT_Un,src1,src2) -> 1 if src1 or src2 is NaN // Cmp3(...,Cmp_GT,src1,src2) -> -1 if src1 or src2 is NaN Opnd* IRBuilder::genCmp3(Type* dstType, Type::Tag instType, // source type for inst ComparisonModifier mod, Opnd* src1, Opnd* src2) { src1 = propagateCopy(src1); src2 = propagateCopy(src2); Operation operation(Op_Cmp3, instType, mod); U_32 hashcode = operation.encodeForHashing(); Opnd* dst = lookupHash(hashcode, src1, src2); if (dst) return dst; if (irBuilderFlags.doSimplify) { dst = simplifier->simplifyCmp3(dstType, instType, mod, src1, src2); } if (!dst) { // result of comparison is always a 32-bit int dst = createOpnd(dstType); Inst* i = instFactory->makeCmp3(mod, instType, dst, src1, src2); appendInst(i); } insertHash(hashcode, src1, src2, dst->getInst()); return dst; } // Control flow void IRBuilder::genBranch(Type::Tag instType, ComparisonModifier mod, LabelInst* label, Opnd* src1, Opnd* src2) { src1 = propagateCopy(src1); src2 = propagateCopy(src2); if (mod > Cmp_GTE_Un) // bad modifier invalid(); if (irBuilderFlags.doSimplify) { if (simplifier->simplifyBranch(instType, mod, label, src1, src2)) { // simplified branch was emitted; return; } } appendInst(instFactory->makeBranch(mod, instType, src1, src2, label)); } void IRBuilder::genBranch(Type::Tag instType, ComparisonModifier mod, LabelInst* label, Opnd* src) { src = propagateCopy(src); if (mod < Cmp_Zero) // bad modifier invalid(); if (irBuilderFlags.doSimplify) { if (simplifier->simplifyBranch(instType, mod, label, src)) { // simplified branch was emitted; return; } } appendInst(instFactory->makeBranch(mod, instType, src, label)); } void IRBuilder::genJump(LabelInst* label) { appendInst(instFactory->makeJump(label)); } void IRBuilder::genJSR(LabelInst* label) { appendInst(instFactory->makeJSR(label)); } void IRBuilder::genSwitch(U_32 nLabels, LabelInst* labelInsts[], LabelInst* defaultLabel, Opnd* src) { src = propagateCopy(src); appendInst(instFactory->makeSwitch(src, nLabels, labelInsts, defaultLabel)); } void IRBuilder::genThrow(ThrowModifier mod, Opnd* exceptionObj) { exceptionObj = propagateCopy(exceptionObj); appendInst(instFactory->makeThrow(mod, exceptionObj)); } void IRBuilder::genPseudoThrow() { appendInst(instFactory->makePseudoThrow()); } void IRBuilder::genThrowSystemException(CompilationInterface::SystemExceptionId id) { appendInst(instFactory->makeThrowSystemException(id)); } void IRBuilder::genThrowLinkingException(Class_Handle encClass, U_32 CPIndex, U_32 operation) { appendInst(instFactory->makeThrowLinkingException(encClass, CPIndex, operation)); } Opnd* IRBuilder::genCatch(Type* exceptionType) { Opnd* dst = createOpnd(exceptionType); appendInst(instFactory->makeCatch(dst)); return dst; } Opnd* IRBuilder::genSaveRet() { Opnd *dst = createOpnd(typeManager->getIntPtrType()); appendInst(instFactory->makeSaveRet(dst)); return dst; } void IRBuilder::genPrefetch(Opnd *addr) { appendInst(instFactory->makePrefetch(propagateCopy(addr))); } Opnd* IRBuilder::createTypeOpnd(ObjectType* type) { Opnd* res = NULL; POINTER_SIZE_SINT val = (POINTER_SIZE_SINT)type->getRuntimeIdentifier(); res = genLdConstant(val); return res; } // Calls Opnd* IRBuilder::genIndirectCallWithResolve(Type* returnType, Opnd* tauNullCheckedFirstArg, Opnd* tauTypesChecked, U_32 numArgs, Opnd* args[], ObjectType* ch, JavaByteCodes bc, U_32 cpIndex, MethodSignature* sig ) { assert(!returnType->isNullObject()); Opnd* callAddrOpnd = lookupHash(Op_VMHelperCall, bc, cpIndex, numArgs>0?args[0]->getId() : 0); if (tauTypesChecked == NULL) { tauTypesChecked = genTauUnsafe(); } if (callAddrOpnd == NULL) { VM_RT_SUPPORT vmHelperId = VM_RT_UNKNOWN; MemoryManager& mm = irManager->getMemoryManager(); Opnd* clsOpnd = createTypeOpnd(ch); Opnd* idxOpnd = genLdConstant((int)cpIndex); U_32 numHelperArgs = 0; Opnd** helperArgs = new(mm)Opnd*[3]; helperArgs[0] = clsOpnd; helperArgs[1] = idxOpnd; helperArgs[2] = NULL; switch(bc) { case OPCODE_INVOKESTATIC: vmHelperId = VM_RT_GET_INVOKESTATIC_ADDR_WITHRESOLVE; numHelperArgs = 2; break; case OPCODE_INVOKEVIRTUAL: vmHelperId = VM_RT_GET_INVOKEVIRTUAL_ADDR_WITHRESOLVE; helperArgs[2] = args[0]; numHelperArgs = 3; break; case OPCODE_INVOKESPECIAL: vmHelperId = VM_RT_GET_INVOKE_SPECIAL_ADDR_WITHRESOLVE; numHelperArgs = 2; break; case OPCODE_INVOKEINTERFACE: vmHelperId = VM_RT_GET_INVOKEINTERFACE_ADDR_WITHRESOLVE; helperArgs[2] = args[0]; numHelperArgs = 3; break; default: assert(0); } callAddrOpnd = genVMHelperCall(vmHelperId, typeManager->getUnresolvedMethodPtrType(ch, cpIndex, sig), numHelperArgs, helperArgs); insertHash(Op_VMHelperCall, bc, cpIndex, numArgs>0?args[0]->getId() : 0, callAddrOpnd->getInst()); } return genIndirectMemoryCall(returnType, callAddrOpnd, tauNullCheckedFirstArg, tauTypesChecked, numArgs, args); } Opnd* IRBuilder::genDirectCall(MethodDesc* methodDesc, Type* returnType, Opnd* tauNullCheckedFirstArg, Opnd* tauTypesChecked, U_32 numArgs, Opnd* args[]) { if (!tauNullCheckedFirstArg) tauNullCheckedFirstArg = genTauUnsafe(); else tauNullCheckedFirstArg = propagateCopy(tauNullCheckedFirstArg); if (!tauTypesChecked) tauTypesChecked = genTauUnsafe(); else tauTypesChecked = propagateCopy(tauTypesChecked); if (irBuilderFlags.expandCallAddrs) { return genIndirectMemoryCall(returnType, genLdFunAddrSlot(methodDesc), tauNullCheckedFirstArg, tauTypesChecked, numArgs, args); } for (U_32 i=0; imakeDirectCall(dst, tauNullCheckedFirstArg, tauTypesChecked, numArgs, args, methodDesc)); // Note that type initialization should be made available for this type // and all its ancestor types. return dst; } Opnd* IRBuilder::genTauVirtualCall(MethodDesc* methodDesc, Type* returnType, Opnd* tauNullCheckedFirstArg, Opnd* tauTypesChecked, U_32 numArgs, Opnd* args[]) { if(!methodDesc->isVirtual()) // Must de-virtualize - no vtable return genDirectCall(methodDesc, returnType, tauNullCheckedFirstArg, tauTypesChecked, numArgs, args); for (U_32 i=0; igetInst()->getOpcode() == Op_TauUnsafe)) { // if no null check yet, do one tauNullCheckedFirstArg = genTauCheckNull(args[0]); } else { tauNullCheckedFirstArg = propagateCopy(tauNullCheckedFirstArg); } if (!tauTypesChecked || (tauTypesChecked->getInst()->getOpcode() == Op_TauUnsafe)) { // if no type check available yet tauTypesChecked = genTauHasTypeWithConv(&args[0], methodDesc->getParentType()); } else { tauTypesChecked = propagateCopy(tauTypesChecked); } if (irBuilderFlags.doSimplify) { Opnd *dst = simplifier->simplifyTauVirtualCall(methodDesc, returnType, tauNullCheckedFirstArg, tauTypesChecked, numArgs, args); if (dst) return dst; } if (irBuilderFlags.expandVirtualCallAddrs) { return genIndirectMemoryCall(returnType, genTauLdVirtFunAddrSlot(args[0], tauNullCheckedFirstArg, methodDesc), tauNullCheckedFirstArg, tauTypesChecked, numArgs, args); } Opnd *dst = createOpnd(returnType); appendInst(instFactory->makeTauVirtualCall(dst, tauNullCheckedFirstArg, tauTypesChecked, numArgs, args, methodDesc)); return dst; } Opnd* IRBuilder::genJitHelperCall(JitHelperCallId helperId, Type* returnType, U_32 numArgs, Opnd* args[]) { for (U_32 i=0; imakeJitHelperCall(dst, helperId, NULL, NULL, numArgs, args)); return dst; } Opnd* IRBuilder::genJitHelperCall(JitHelperCallId helperId, Type* returnType, Opnd* tauNullCheckedRefArgs, Opnd* tauTypesChecked, U_32 numArgs, Opnd* args[]) { for (U_32 i=0; imakeJitHelperCall(dst, helperId, tauNullCheckedRefArgs, tauTypesChecked, numArgs, args)); return dst; } Opnd* IRBuilder::genVMHelperCall(VM_RT_SUPPORT helperId, Type* returnType, U_32 numArgs, Opnd* args[]) { for (U_32 i=0; imakeVMHelperCall(dst, helperId, numArgs, args)); return dst; } void IRBuilder::genTauTypeCompare(Opnd *arg0, MethodDesc *methodDesc, LabelInst *target, Opnd *tauNullChecked) { arg0 = propagateCopy(arg0); // null check now is in genLdVTable() Type* type = methodDesc->getParentType(); assert(type->isObject()); // Note that we use the methodDesc's type to obtain the vtable which contains the pointer // to the method. This may be an interface vtable. genLdVTable figures out which. Opnd* vtableThis = genLdVTable(arg0, type); Opnd* vtableClass = createOpnd(typeManager->getVTablePtrType(type)); appendInst(instFactory->makeGetVTableAddr(vtableClass, (ObjectType*)type)); genBranch(Type::VTablePtr, Cmp_EQ, target, vtableThis, vtableClass); } Opnd* IRBuilder::genIndirectCall(Type* returnType, Opnd* funAddr, Opnd* tauNullCheckedFirstArg, Opnd* tauTypesChecked, U_32 numArgs, Opnd* args[]) { for (U_32 i=0; imakeIndirectCall(dst, funAddr, tauNullCheckedFirstArg, tauTypesChecked, numArgs, args)); return dst; } Opnd* IRBuilder::genIndirectMemoryCall(Type* returnType, Opnd* funAddr, Opnd* tauNullCheckedFirstArg, Opnd* tauTypesChecked, U_32 numArgs, Opnd* args[]) { for (U_32 i=0; imakeIndirectMemoryCall(dst, funAddr, tauNullCheckedFirstArg, tauTypesChecked, numArgs, args)); return dst; } void IRBuilder::genReturn(Opnd* src, Type* retType) { src = propagateCopy(src); if(Log::isEnabled()) { Type* srcType = src->getType(); bool convOk = retType == srcType; convOk = convOk || (retType->isObject() && (srcType->isObject() || srcType->isUnmanagedPtr())); if (!convOk){ assert(!typeManager->isLazyResolutionMode()); Log::out() << "ERROR !!!! IRBuilder: unimplemented: ret typecheck !!!\n"; } } appendInst(instFactory->makeReturn(src)); } void IRBuilder::genReturn() { appendInst(instFactory->makeReturn()); } void IRBuilder::genRet(Opnd* src) { appendInst(instFactory->makeRet(src)); } // Move instruction Opnd* IRBuilder::genCopy(Opnd* src) { src = propagateCopy(src); Opnd* dst = createOpnd(src->getType()); appendInst(instFactory->makeCopy(dst, src)); return dst; } Opnd* IRBuilder::genArgCoercion(Type* argType, Opnd* actualArg) { actualArg = propagateCopy(actualArg); if (actualArg->getType() == argType) return actualArg; return actualArg; } // actual parameter and variable definitions Opnd* IRBuilder::genArgDef(Modifier mod, Type* type) { Opnd* dst = opndManager->createArgOpnd(type); appendInst(instFactory->makeDefArg(mod, dst)); DefArgModifier defMod = mod.getDefArgModifier(); switch (defMod) { case NonNullThisArg: genTauIsNonNull(dst); break; case SpecializedToExactType: genTauHasExactType(dst, type); break; case DefArgBothModifiers: genTauIsNonNull(dst); genTauHasExactType(dst, type); break; case DefArgNoModifier: break; default: assert(0); } genTauHasType(dst, type); return dst; } VarOpnd* IRBuilder::genVarDef(Type* type, bool isPinned) { return opndManager->createVarOpnd(type, isPinned); } // Phi-node instruction Opnd* IRBuilder::genPhi(U_32 numArgs, Opnd* args[]) { for (U_32 i=0; igetType()); appendInst(instFactory->makePhi(dst, numArgs, args)); return dst; } // Pi-node instruction (splits live range for bounds analysis) Opnd* IRBuilder::genTauPi(Opnd *src, Opnd *tau, PiCondition *cond) { src = propagateCopy(src); tau = propagateCopy(tau); PiOpnd* dst = createPiOpnd(src); appendInst(instFactory->makeTauPi(dst, src, tau, cond)); return dst; } // load instructions Opnd* IRBuilder::genLdConstant(I_32 val) { Operation operation(Op_LdConstant, Type::Int32, Modifier()); U_32 hashcode = operation.encodeForHashing(); Opnd* dst = lookupHash(hashcode, (U_32) val); if (dst) return dst; dst = createOpnd(typeManager->getInt32Type()); appendInst(instFactory->makeLdConst(dst, val)); insertHash(hashcode, (U_32) val, dst->getInst()); return dst; } Opnd* IRBuilder::genLdConstant(int64 val) { Operation operation(Op_LdConstant, Type::Int64, Modifier()); U_32 hashcode = operation.encodeForHashing(); Opnd* dst = lookupHash(hashcode, (U_32) (val >> 32), (U_32) (val & 0xffffffff)); if (dst) return dst; dst = createOpnd(typeManager->getInt64Type()); appendInst(instFactory->makeLdConst(dst, val)); insertHash(hashcode, (U_32) (val >> 32), (U_32) (val & 0xffffffff), dst->getInst()); return dst; } Opnd* IRBuilder::genLdConstant(float val) { ConstInst::ConstValue cv; cv.s = val; U_32 word1 = cv.dword1; U_32 word2 = cv.dword2; Operation operation(Op_LdConstant, Type::Single, Modifier()); U_32 hashcode = operation.encodeForHashing(); Opnd* dst = lookupHash(hashcode, word1, word2); if (dst) return dst; dst = createOpnd(typeManager->getSingleType()); appendInst(instFactory->makeLdConst(dst, val)); insertHash(hashcode, word1, word2, dst->getInst()); return dst; } Opnd* IRBuilder::genLdConstant(double val) { ConstInst::ConstValue cv; cv.d = val; U_32 word1 = cv.dword1; U_32 word2 = cv.dword2; Operation operation(Op_LdConstant, Type::Double, Modifier()); U_32 hashcode = operation.encodeForHashing(); Opnd* dst = lookupHash(hashcode, word1, word2); if (dst) return dst; dst = createOpnd(typeManager->getDoubleType()); appendInst(instFactory->makeLdConst(dst, val)); insertHash(hashcode, word1, word2, dst->getInst()); return dst; } Opnd* IRBuilder::genLdConstant(Type *ptrtype, ConstInst::ConstValue val) { U_32 word1 = val.dword1; U_32 word2 = val.dword2; Operation operation(Op_LdConstant, ptrtype->tag, Modifier()); U_32 hashcode = operation.encodeForHashing(); Opnd* dst = lookupHash(hashcode, word1, word2); if (dst) return dst; dst = createOpnd(ptrtype); appendInst(instFactory->makeLdConst(dst, val)); insertHash(hashcode, word1, word2, dst->getInst()); return dst; } Opnd* IRBuilder::genLdFloatConstant(double val) { ConstInst::ConstValue cv; cv.d = val; U_32 word1 = cv.dword1; U_32 word2 = cv.dword2; Operation operation(Op_LdConstant, Type::Float, Modifier()); U_32 hashcode = operation.encodeForHashing(); Opnd* dst = lookupHash(hashcode, word1, word2); if (dst) return dst; dst = createOpnd(typeManager->getFloatType()); appendInst(instFactory->makeLdConst(dst, val)); insertHash(hashcode, word1, word2, dst->getInst()); return dst; } Opnd* IRBuilder::genLdFloatConstant(float val) { ConstInst::ConstValue cv; cv.dword1 = 0; cv.dword2 = 0; cv.s = val; U_32 word1 = cv.dword1; U_32 word2 = cv.dword2; Operation operation(Op_LdConstant, Type::Float, Modifier()); U_32 hashcode = operation.encodeForHashing(); Opnd* dst = lookupHash(hashcode, word1, word2); if (dst) return dst; dst = createOpnd(typeManager->getFloatType()); appendInst(instFactory->makeLdConst(dst, val)); insertHash(hashcode, word1, word2, dst->getInst()); return dst; } Opnd* IRBuilder::genLdNull() { Operation operation(Op_LdConstant, Type::NullObject, Modifier()); U_32 hashcode = operation.encodeForHashing(); Opnd* dst = lookupHash(hashcode); if (dst) return dst; dst = createOpnd(typeManager->getNullObjectType()); appendInst(instFactory->makeLdNull(dst)); insertHash(hashcode, dst->getInst()); return dst; } Opnd* IRBuilder::genLdRef(MethodDesc* enclosingMethod, U_32 stringToken, Type* type) { bool uncompress = irBuilderFlags.compressedReferences; Modifier mod = uncompress ? AutoCompress_Yes : AutoCompress_No; Opnd* dst = createOpnd(type); appendInst(instFactory->makeLdRef(mod, dst, enclosingMethod, stringToken)); return dst; } Opnd* IRBuilder::genLdVar(Type* dstType, VarOpnd* var) { if (!var->isAddrTaken()) { Opnd *dst = lookupHash(Op_LdVar, var); if (dst) return dst; dst = createOpnd(dstType); appendInst(instFactory->makeLdVar(dst, var)); insertHash(Op_LdVar, var, dst->getInst()); return dst; } else { Opnd *dst = createOpnd(dstType); appendInst(instFactory->makeLdVar(dst, var)); return dst; } } Opnd* IRBuilder::genLdVarAddr(VarOpnd* var) { Opnd* dst = lookupHash(Op_LdVarAddr, var); if (dst) return dst; var->setAddrTaken(); dst = createOpnd(typeManager->getManagedPtrType(var->getType())); appendInst(instFactory->makeLdVarAddr(dst, var)); insertHash(Op_LdVarAddr, var, dst->getInst()); return dst; } Opnd* IRBuilder::genLdInd(Type* type, Opnd *ptr) { ptr = propagateCopy(ptr); Opnd *tauUnsafe = genTauUnsafe(); bool uncompress = false; if (irBuilderFlags.compressedReferences && type->isObject()) { assert(!type->isCompressedReference()); uncompress = true; } Modifier mod = uncompress ? AutoCompress_Yes : AutoCompress_No; Opnd *dst = genTauLdInd(mod, type, type->tag, ptr, tauUnsafe, tauUnsafe); return dst; } Opnd* IRBuilder::genTauLdInd(Modifier mod, Type* type, Type::Tag ldType, Opnd* ptr, Opnd *tauBaseNonNull, Opnd *tauAddressInRange) { ptr = propagateCopy(ptr); tauBaseNonNull = propagateCopy(tauBaseNonNull); tauAddressInRange = propagateCopy(tauAddressInRange); Opnd* dst = createOpnd(type); appendInst(instFactory->makeTauLdInd(mod, ldType, dst, ptr, tauBaseNonNull, tauAddressInRange)); return dst; } Opnd* IRBuilder::genLdRef(Modifier mod, Type* type, U_32 token, MethodDesc *enclosingMethod) { Opnd* dst = createOpnd(type); appendInst(instFactory->makeLdRef(mod, dst, enclosingMethod, token)); return dst; } Opnd* IRBuilder::genLdField(Type* type, Opnd* base, FieldDesc* fieldDesc) { assert(!fieldDesc->isStatic()); base = propagateCopy(base); Opnd *tauNullCheck = genTauCheckNull(base); Opnd *tauAddressInRange = genTauHasType(base, fieldDesc->getParentType()); bool uncompress = false; if (irBuilderFlags.compressedReferences && type->isObject()) { assert(!type->isCompressedReference()); uncompress = true; } Modifier mod = uncompress ? AutoCompress_Yes : AutoCompress_No; if (irBuilderFlags.expandMemAddrs) { return genTauLdInd(mod, type, type->tag, genLdFieldAddr(type, base, fieldDesc), tauNullCheck, tauAddressInRange); } Opnd* dst = createOpnd(type); appendInst(instFactory->makeTauLdField(mod, type, dst, base, tauNullCheck, tauAddressInRange, fieldDesc)); return dst; } Opnd* IRBuilder::genLdFieldWithResolve(Type* type, Opnd* base, ObjectType* enclClass, U_32 cpIndex) { base = propagateCopy(base); Opnd *tauNullCheck = genTauCheckNull(base); Opnd *tauAddressInRange = genTauSafe(); bool uncompress = false; if (irBuilderFlags.compressedReferences && type->isObject()) { assert(!type->isCompressedReference()); uncompress = true; } Modifier mod = uncompress ? AutoCompress_Yes : AutoCompress_No; assert(irBuilderFlags.expandMemAddrs); Opnd* addr = genLdFieldAddrWithResolve(type, base, enclClass, cpIndex, false); return genTauLdInd(mod, type, type->tag, addr, tauNullCheck, tauAddressInRange); } void IRBuilder::genInitType(NamedType* type) { if (!type->needsInitialization()) { return; } MethodDesc * m = irManager->getCompilationInterface().getMethodToCompile(); NamedType* classType = m->getParentType(); if (type == classType) { return; } Opnd* opnd = lookupHash(Op_InitType, type->getId()); if (opnd) return; // no need to re-initialize insertHash(Op_InitType, type->getId(), appendInst(instFactory->makeInitType(type))); } Opnd* IRBuilder::genLdStaticWithResolve(Type* type, ObjectType* enclClass, U_32 cpIdx) { bool uncompress = false; if (irBuilderFlags.compressedReferences && type->isObject()) { assert(!type->isCompressedReference()); uncompress = true; } Modifier mod = uncompress ? AutoCompress_Yes : AutoCompress_No; Opnd *tauOk = genTauSafe(); // static field, always safe Opnd* addrOpnd = genLdStaticAddrWithResolve(type, enclClass, cpIdx, false); return genTauLdInd(mod, type, type->tag, addrOpnd, tauOk, tauOk); } Opnd* IRBuilder::genLdStatic(Type* type, FieldDesc* fieldDesc) { bool uncompress = false; if (irBuilderFlags.compressedReferences && type->isObject()) { assert(!type->isCompressedReference()); uncompress = true; } Modifier mod = uncompress ? AutoCompress_Yes : AutoCompress_No; genInitType(fieldDesc->getParentType()); if (irBuilderFlags.expandMemAddrs) { Opnd *tauOk = genTauSafe(); // static field, always safe return genTauLdInd(mod, type, type->tag, genLdStaticAddr(type, fieldDesc), tauOk, tauOk); } Opnd* dst = createOpnd(type); appendInst(instFactory->makeLdStatic(mod, type, dst, fieldDesc)); return dst; } Opnd* IRBuilder::genLdElem(Type* type, Opnd* array, Opnd* index, Opnd* tauNullChecked, Opnd* tauAddressInRange) { assert(tauNullChecked); assert(tauAddressInRange); array = propagateCopy(array); index = propagateCopy(index); bool uncompress = false; if (irBuilderFlags.compressedReferences && type->isObject()) { assert(!type->isCompressedReference()); uncompress = true; } Modifier mod = uncompress ? AutoCompress_Yes : AutoCompress_No; if (irBuilderFlags.expandMemAddrs) { return genTauLdInd(mod, type, type->tag, genLdElemAddrNoChecks(type, array, index), tauNullChecked, tauAddressInRange); } Opnd* dst = createOpnd(type); appendInst(instFactory->makeTauLdElem(mod, type, dst, array, index, tauNullChecked, tauAddressInRange)); return dst; } Opnd* IRBuilder::genLdElem(Type* type, Opnd* array, Opnd* index) { array = propagateCopy(array); index = propagateCopy(index); Opnd *tauNullChecked = genTauCheckNull(array); Opnd *tauBoundsChecked = genTauCheckBounds(array, index, tauNullChecked); Opnd *tauBaseTypeChecked = genTauHasType(array, array->getType()); Opnd *tauAddressInRange = genTauAnd(tauBoundsChecked, tauBaseTypeChecked); return genLdElem(type,array,index,tauNullChecked,tauAddressInRange); } Opnd* IRBuilder::genLdFieldAddr(Type* type, Opnd* base, FieldDesc* fieldDesc) { assert(!fieldDesc->isStatic()); base = propagateCopy(base); genTauCheckNull(base); Opnd* dst = lookupHash(Op_LdFieldAddr, base->getId(), fieldDesc->getId()); if (dst) return dst; if (base->getType()->isIntPtr()) { // unmanaged pointer dst = createOpnd(typeManager->getIntPtrType()); } else if (irBuilderFlags.compressedReferences && type->isObject()) { // until VM type system is upgraded, // fieldDesc type will have uncompressed ref type; // compress it assert(!type->isCompressedReference()); Type *compressedType = typeManager->compressType(type); dst = createOpnd(typeManager->getManagedPtrType(compressedType)); } else { dst = createOpnd(typeManager->getManagedPtrType(type)); } appendInst(instFactory->makeLdFieldAddr(dst, base, fieldDesc)); insertHash(Op_LdFieldAddr, base->getId(), fieldDesc->getId(), dst->getInst()); return dst; } Opnd* IRBuilder::genLdFieldAddrWithResolve(Type* type, Opnd* base, ObjectType* enclClass, U_32 cpIndex, bool putfield) { base = propagateCopy(base); genTauCheckNull(base); //1. loading field offset JavaByteCodes opcode = putfield? OPCODE_PUTFIELD : OPCODE_GETFIELD; Opnd* dst = lookupHash(Op_VMHelperCall, opcode, base->getId(), cpIndex); if (dst) return dst; if (irBuilderFlags.compressedReferences && type->isObject()) { // until VM type system is upgraded, // fieldDesc type will have uncompressed ref type; // compress it assert(!type->isCompressedReference()); Type *compressedType = typeManager->compressType(type); dst = createOpnd(typeManager->getManagedPtrType(compressedType)); } else { dst = createOpnd(typeManager->getManagedPtrType(type)); } Opnd** args = new (irManager->getMemoryManager()) Opnd*[3]; args[0] = createTypeOpnd(enclClass); args[1] = genLdConstant((int)cpIndex); args[2] = genLdConstant((int)putfield?1:0); Opnd* offsetOpnd = genVMHelperCall(VM_RT_GET_NONSTATIC_FIELD_OFFSET_WITHRESOLVE, typeManager->getIntPtrType(), 3, args); insertHash(Op_VMHelperCall, opcode, base->getId(), cpIndex, dst->getInst()); //2. adding the offset to object opnd -> getting the address of the field appendInst(instFactory->makeAddOffset(dst, base, offsetOpnd)); return dst; } Opnd* IRBuilder::genLdStaticAddr(Type* type, FieldDesc* fieldDesc) { genInitType(fieldDesc->getParentType()); Opnd* dst = lookupHash(Op_LdStaticAddr, fieldDesc->getId()); if (dst) return dst; if (irBuilderFlags.compressedReferences && type->isObject()) { // until VM type system is upgraded, // fieldDesc type will have uncompressed ref type; // compress it assert(!type->isCompressedReference()); Type *compressedType = typeManager->compressType(type); dst = createOpnd(typeManager->getManagedPtrType(compressedType)); } else { dst = createOpnd(typeManager->getManagedPtrType(type)); } appendInst(instFactory->makeLdStaticAddr(dst, fieldDesc)); insertHash(Op_LdStaticAddr, fieldDesc->getId(), dst->getInst()); return dst; } Opnd* IRBuilder::genLdStaticAddrWithResolve(Type* type, ObjectType* enclClass, U_32 cpIndex, bool putfield) { JavaByteCodes opcode = putfield ? OPCODE_PUTSTATIC : OPCODE_GETSTATIC; Opnd* dst = lookupHash(Op_VMHelperCall, opcode, cpIndex); if (dst) return dst; if (irBuilderFlags.compressedReferences && type->isObject()) { // until VM type system is upgraded, // fieldDesc type will have uncompressed ref type; // compress it assert(!type->isCompressedReference()); Type *compressedType = typeManager->compressType(type); dst = createOpnd(typeManager->getManagedPtrType(compressedType)); } else { dst = createOpnd(typeManager->getManagedPtrType(type)); } Opnd** args = new (irManager->getMemoryManager()) Opnd*[3]; args[0] = createTypeOpnd(enclClass); args[1] = genLdConstant((int)cpIndex); args[2] = genLdConstant((int)putfield?1:0); appendInst(instFactory->makeVMHelperCall(dst, VM_RT_GET_STATIC_FIELD_ADDR_WITHRESOLVE, 3, args)); insertHash(Op_VMHelperCall, OPCODE_GETSTATIC, cpIndex, dst->getInst()); return dst; } Opnd* IRBuilder::genLdElemAddr(Type* elemType, Opnd* array, Opnd* index) { // null and bounds checks index = propagateCopy(index); array = propagateCopy(array); Opnd *tauNullChecked = genTauCheckNull(array); genTauCheckBounds(array, index, tauNullChecked); return genLdElemAddrNoChecks(elemType, array, index); } Opnd* IRBuilder::genLdElemAddrNoChecks(Type* elemType, Opnd* array, Opnd* index) { Opnd* dst; if (irBuilderFlags.expandElemAddrs) { // // boundscheck array, index // ldarraybase array --> base // addindex base, index --> dst // return genAddScaledIndex(genLdArrayBaseAddr(elemType, array), index); } else { // // Op_LdElemAddr // dst = lookupHash(Op_LdElemAddr, array, index); if (dst) return dst; if (irBuilderFlags.compressedReferences && elemType->isObject()) { // until VM type system is upgraded, // fieldDesc type will have uncompressed ref type; // compress it assert(!elemType->isCompressedReference()); Type *compressedType = typeManager->compressType(elemType); dst = createOpnd(typeManager->getManagedPtrType(compressedType)); } else { dst = createOpnd(typeManager->getManagedPtrType(elemType)); } appendInst(instFactory->makeLdElemAddr(elemType, dst, array, index)); insertHash(Op_LdElemAddr, array, index, dst->getInst()); } return dst; } Opnd* IRBuilder::genLdFunAddr(MethodDesc* methodDesc) { Opnd* dst = lookupHash(Op_LdFunAddr, methodDesc->getId()); if (dst) return dst; dst = createOpnd(typeManager->getMethodPtrType(methodDesc)); appendInst(instFactory->makeLdFunAddr(dst, methodDesc)); insertHash(Op_LdFunAddr, methodDesc->getId(), dst->getInst()); return dst; } Opnd* IRBuilder::genLdFunAddrSlot(MethodDesc* methodDesc) { Opnd* dst = lookupHash(Op_LdFunAddrSlot, methodDesc->getId()); if (dst) return dst; dst = createOpnd(typeManager->getMethodPtrType(methodDesc)); appendInst(instFactory->makeLdFunAddrSlot(dst, methodDesc)); insertHash(Op_LdFunAddrSlot, methodDesc->getId(), dst->getInst()); return dst; } Opnd* IRBuilder::genLdVTable(Opnd* base, Type* type) { base = propagateCopy(base); Opnd *tauNullChecked = genTauCheckNull(base); return genTauLdVTable(base, tauNullChecked, type); } Opnd* IRBuilder::genTauLdVTable(Opnd* base, Opnd *tauNullChecked, Type* type) { base = propagateCopy(base); SsaOpnd* obj = base->asSsaOpnd(); assert(obj); Opnd* dst = NULL; if (type->isInterface()) { dst = lookupHash(Op_TauLdIntfcVTableAddr, base->getId(), type->getId()); if (dst) return dst; if (irBuilderFlags.useNewTypeSystem) { NamedType* iType = type->asNamedType(); assert(iType); dst = createOpnd(typeManager->getITablePtrObjType(obj, iType)); } else { dst = createOpnd(typeManager->getVTablePtrType(type)); } appendInst(instFactory->makeTauLdIntfcVTableAddr(dst, base, type)); insertHash(Op_TauLdIntfcVTableAddr, base->getId(), type->getId(), dst->getInst()); } else if (type->isClass()) { dst = lookupHash(Op_TauLdVTableAddr, base); if (dst) return dst; if (irBuilderFlags.useNewTypeSystem) { dst = createOpnd(typeManager->getVTablePtrObjType(obj)); } else { dst = createOpnd(typeManager->getVTablePtrType(base->getType())); } appendInst(instFactory->makeTauLdVTableAddr(dst, base, tauNullChecked)); insertHash(Op_TauLdVTableAddr, base, dst->getInst()); } else { assert(0); // shouldn't happen } return dst; } Opnd* IRBuilder::genGetVTable(ObjectType* type) { assert(type->isClass() && (!type->isAbstract() || type->isArray())); Opnd* dst = lookupHash(Op_GetVTableAddr, type->getId()); if (dst) return dst; dst = createOpnd(typeManager->getVTablePtrType(type)); appendInst(instFactory->makeGetVTableAddr(dst, type)); insertHash(Op_GetVTableAddr, type->getId(), dst->getInst()); return dst; } Opnd* IRBuilder::genGetClassObj(ObjectType* type) { assert(type->isClass()); Opnd* dst = lookupHash(Op_GetClassObj, type->getId()); if (dst) return dst; Type* dstType = irManager->getTypeManager().getSystemClassType(); dst = createOpnd(dstType); appendInst(instFactory->makeGetClassObj(dst, type)); insertHash(Op_GetClassObj, type->getId(), dst->getInst()); return dst; } Opnd* IRBuilder::genLdVirtFunAddr(Opnd* base, MethodDesc* methodDesc) { base = propagateCopy(base); Opnd* dst = lookupHash(Op_TauLdVirtFunAddr, base->getId(), methodDesc->getId()); if (dst) return dst; Opnd *tauNullChecked = genTauCheckNull(base); Type *methodType = methodDesc->getParentType(); Opnd* vtableOpnd = genTauLdVTable(base, tauNullChecked, methodType); Opnd *tauVtableHasMethod = genTauHasType(base, methodType); dst = createOpnd(typeManager->getMethodPtrType(methodDesc)); appendInst(instFactory->makeTauLdVirtFunAddr(dst, vtableOpnd, tauVtableHasMethod, methodDesc)); insertHash(Op_TauLdVirtFunAddr, vtableOpnd->getId(), methodDesc->getId(), dst->getInst()); return dst; } Opnd* IRBuilder::genTauLdVirtFunAddrSlot(Opnd* base, Opnd *tauOk, MethodDesc* methodDesc) { base = propagateCopy(base); Opnd* dst = lookupHash(Op_TauLdVirtFunAddrSlot, base->getId(), methodDesc->getId()); if (dst) return dst; Opnd *tauNullChecked = genTauCheckNull(base); Opnd* vtableOpnd = genTauLdVTable(base, tauNullChecked, methodDesc->getParentType()); Opnd *tauVtableHasMethod = tauOk; if (irBuilderFlags.useNewTypeSystem) { SsaOpnd* obj = base->asSsaOpnd(); assert(obj); dst = createOpnd(typeManager->getMethodPtrObjType(obj, methodDesc)); } else { dst = createOpnd(typeManager->getMethodPtrType(methodDesc)); } appendInst(instFactory->makeTauLdVirtFunAddrSlot(dst, vtableOpnd, tauVtableHasMethod, methodDesc)); insertHash(Op_TauLdVirtFunAddrSlot, vtableOpnd->getId(), methodDesc->getId(), dst->getInst()); return dst; } Opnd* IRBuilder::genArrayLen(Type* dstType, Type::Tag type, Opnd* array) { array = propagateCopy(array); Opnd* dst = lookupHash(Op_TauArrayLen, array->getId()); if (dst) return dst; if (irBuilderFlags.doSimplify) { dst = simplifier->simplifyTauArrayLen(dstType, type, array); if (dst) return dst; } Opnd *tauNonNull = genTauCheckNull(array); Opnd *tauIsArray = genTauHasType(array, array->getType()); return genTauArrayLen(dstType, type, array, tauNonNull, tauIsArray); } Opnd* IRBuilder::genTauArrayLen(Type* dstType, Type::Tag type, Opnd* array, Opnd* tauNullChecked, Opnd *tauTypeChecked) { array = propagateCopy(array); Opnd* dst = lookupHash(Op_TauArrayLen, array->getId()); if (dst) return dst; if (irBuilderFlags.doSimplify) { dst = simplifier->simplifyTauArrayLen(dstType, type, array, tauNullChecked, tauTypeChecked); if (dst) return dst; } dst = createOpnd(dstType); appendInst(instFactory->makeTauArrayLen(dst, type, array, tauNullChecked, tauTypeChecked)); insertHash(Op_TauArrayLen, array->getId(), dst->getInst()); return dst; } Opnd* IRBuilder::genLdArrayBaseAddr(Type* elemType, Opnd* array) { array = propagateCopy(array); Opnd* dst = lookupHash(Op_LdArrayBaseAddr, array); if (dst) return dst; if (irBuilderFlags.useNewTypeSystem) { SsaOpnd* arrayVal = array->asSsaOpnd(); assert(arrayVal); Type* baseType = typeManager->getArrayBaseType(arrayVal); dst = createOpnd(baseType); } else { if (irBuilderFlags.compressedReferences && elemType->isObject()) { // until VM type system is upgraded, // fieldDesc type will have uncompressed ref type; // compress it assert(!elemType->isCompressedReference()); Type *compressedType = typeManager->compressType(elemType); dst = createOpnd(typeManager->getManagedPtrType(compressedType)); } else { dst = createOpnd(typeManager->getManagedPtrType(elemType)); } } appendInst(instFactory->makeLdArrayBaseAddr(elemType, dst, array)); insertHash(Op_LdArrayBaseAddr, array, dst->getInst()); return dst; } Opnd* IRBuilder::genAddScaledIndex(Opnd* ptr, Opnd* index) { ptr = propagateCopy(ptr); index = propagateCopy(index); Opnd* dst = lookupHash(Op_AddScaledIndex, ptr, index); if (dst) return dst; if (irBuilderFlags.useNewTypeSystem) { PtrType* ptrType = ptr->getType()->asPtrType(); assert(ptrType); SsaOpnd* indexVar = index->asSsaOpnd(); assert(indexVar); Type* dstType = typeManager->getArrayIndexType(ptrType->getArrayName(), indexVar); dst = createOpnd(dstType); } else { dst = createOpnd(ptr->getType()); } appendInst(instFactory->makeAddScaledIndex(dst, ptr, index)); insertHash(Op_AddScaledIndex, ptr, index, dst->getInst()); return dst; } Opnd* IRBuilder::genUncompressRef(Opnd *compref) { compref = propagateCopy(compref); Opnd* dst = lookupHash(Op_UncompressRef, compref); if (dst) return dst; Type *comprefType = compref->getType(); assert(comprefType->isCompressedReference()); dst = createOpnd(typeManager->uncompressType(comprefType)); appendInst(instFactory->makeUncompressRef(dst, compref)); insertHash(Op_UncompressRef, compref, dst->getInst()); return dst; } Opnd* IRBuilder::genCompressRef(Opnd *uncompref) { Type *uncomprefType = uncompref->getType(); uncompref = propagateCopy(uncompref); Opnd* dst = lookupHash(Op_CompressRef, uncompref); if (dst) return dst; uncomprefType = uncompref->getType(); assert(uncomprefType->isReference() && !uncomprefType->isCompressedReference()); dst = createOpnd(typeManager->compressType(uncomprefType)); appendInst(instFactory->makeCompressRef(dst, uncompref)); insertHash(Op_CompressRef, uncompref, dst->getInst()); return dst; } Opnd* IRBuilder::genLdFieldOffset(FieldDesc* fieldDesc) { assert(!fieldDesc->isStatic()); Opnd *dst = lookupHash(Op_LdFieldOffset, fieldDesc->getId()); if (dst) return dst; dst = createOpnd(typeManager->getOffsetType()); appendInst(instFactory->makeLdFieldOffset(dst, fieldDesc)); insertHash(Op_LdFieldOffset, fieldDesc->getId(), dst->getInst()); return dst; } Opnd* IRBuilder::genLdFieldOffsetPlusHeapbase(FieldDesc* fieldDesc) { assert(!fieldDesc->isStatic()); Opnd *dst = lookupHash(Op_LdFieldOffsetPlusHeapbase, fieldDesc->getId()); if (dst) return dst; dst = createOpnd(typeManager->getOffsetPlusHeapbaseType()); appendInst(instFactory->makeLdFieldOffsetPlusHeapbase(dst, fieldDesc)); insertHash(Op_LdFieldOffsetPlusHeapbase, fieldDesc->getId(), dst->getInst()); return dst; } Opnd* IRBuilder::genLdArrayBaseOffset(Type *elemType) { Opnd* dst = lookupHash(Op_LdArrayBaseOffset, elemType->getId()); if (dst) return dst; dst = createOpnd(typeManager->getOffsetType()); appendInst(instFactory->makeLdArrayBaseOffset(dst, elemType)); insertHash(Op_LdArrayBaseOffset, elemType->getId(), dst->getInst()); return dst; } Opnd* IRBuilder::genLdArrayBaseOffsetPlusHeapbase(Type *elemType) { Opnd* dst = lookupHash(Op_LdArrayBaseOffsetPlusHeapbase, elemType->getId()); if (dst) return dst; dst = createOpnd(typeManager->getOffsetPlusHeapbaseType()); appendInst(instFactory->makeLdArrayBaseOffsetPlusHeapbase(dst, elemType)); insertHash(Op_LdArrayBaseOffsetPlusHeapbase, elemType->getId(), dst->getInst()); return dst; } Opnd* IRBuilder::genLdArrayLenOffset(Type *elemType) { Opnd* dst = lookupHash(Op_LdArrayLenOffset, elemType->getId()); if (dst) return dst; dst = createOpnd(typeManager->getOffsetType()); appendInst(instFactory->makeLdArrayLenOffset(dst, elemType)); insertHash(Op_LdArrayLenOffset, elemType->getId(), dst->getInst()); return dst; } Opnd* IRBuilder::genLdArrayLenOffsetPlusHeapbase(Type *elemType) { Opnd* dst = lookupHash(Op_LdArrayLenOffsetPlusHeapbase, elemType->getId()); if (dst) return dst; dst = createOpnd(typeManager->getOffsetPlusHeapbaseType()); appendInst(instFactory->makeLdArrayLenOffsetPlusHeapbase(dst, elemType)); insertHash(Op_LdArrayLenOffsetPlusHeapbase, elemType->getId(), dst->getInst()); return dst; } Opnd* IRBuilder::genAddOffset(Type *ptrType, Opnd* ref, Opnd* offset) { ref = propagateCopy(ref); offset = propagateCopy(offset); Opnd* dst = lookupHash(Op_AddOffset, ref, offset); if (dst) return dst; assert(!ref->getType()->isCompressedReference()); assert(offset->getType()->isOffset()); dst = createOpnd(ptrType); appendInst(instFactory->makeAddOffset(dst, ref, offset)); insertHash(Op_AddOffset, ref, offset, dst->getInst()); return dst; } Opnd* IRBuilder::genAddOffsetPlusHeapbase(Type *ptrType, Opnd* compref, Opnd* offset) { compref = propagateCopy(compref); offset = propagateCopy(offset); Opnd* dst = lookupHash(Op_AddOffsetPlusHeapbase, compref, offset); if (dst) return dst; assert(compref->getType()->isCompressedReference()); assert(offset->getType()->isOffsetPlusHeapbase()); dst = createOpnd(ptrType); appendInst(instFactory->makeAddOffsetPlusHeapbase(dst, compref, offset)); insertHash(Op_AddOffsetPlusHeapbase, compref, offset, dst->getInst()); return dst; } // store instructions void IRBuilder::genStVar(VarOpnd* var, Opnd* src) { src = propagateCopy(src); appendInst(instFactory->makeStVar(var, src)); if (irBuilderFlags.doCSE) { insertHash(Op_LdVar, var->getId(), src->getInst()); } } void IRBuilder::genStInd(Type* type, Opnd* ptr, Opnd* src) { ptr = propagateCopy(ptr); src = propagateCopy(src); Type *ptrType = ptr->getType(); assert(ptrType->isPtr() || ptrType->isIntPtr()); Type *fieldType = ((PtrType *)ptrType)->getPointedToType(); bool compress = (fieldType->isCompressedReference() && !type->isCompressedReference()); Modifier compressMod = Modifier(compress ? AutoCompress_Yes : AutoCompress_No); Opnd *tauUnsafe = genTauUnsafe(); if (irBuilderFlags.insertWriteBarriers) { appendInst(instFactory->makeTauStInd((Modifier(Store_WriteBarrier)| compressMod), type->tag, src, ptr, tauUnsafe, tauUnsafe, tauUnsafe)); } else { appendInst(instFactory->makeTauStInd((Modifier(Store_NoWriteBarrier)| compressMod), type->tag, src, ptr, tauUnsafe, tauUnsafe, tauUnsafe)); } } void IRBuilder::genTauStInd(Type* type, Opnd* ptr, Opnd* src, Opnd* tauBaseNonNull, Opnd *tauAddressInRange, Opnd* tauElemTypeChecked) { ptr = propagateCopy(ptr); src = propagateCopy(src); Type *ptrType = ptr->getType(); assert(ptrType->isPtr() || ptrType->isIntPtr()); Type *fieldType = ((PtrType *)ptrType)->getPointedToType(); if (fieldType->isArrayElement()) { fieldType = fieldType->getNonValueSupertype(); } bool compress = (fieldType->isCompressedReference() && !type->isCompressedReference()); Modifier compressMod = Modifier(compress ? AutoCompress_Yes : AutoCompress_No); if (irBuilderFlags.insertWriteBarriers) { appendInst(instFactory->makeTauStInd((Modifier(Store_WriteBarrier)| compressMod), type->tag, src, ptr, tauBaseNonNull, tauAddressInRange, tauElemTypeChecked)); } else { appendInst(instFactory->makeTauStInd((Modifier(Store_NoWriteBarrier)| compressMod), type->tag, src, ptr, tauBaseNonNull, tauAddressInRange, tauElemTypeChecked)); } } void IRBuilder::genTauStRef(Type* type, Opnd *objectbase, Opnd* ptr, Opnd* src, Opnd *tauBaseNonNull, Opnd *tauAddressInRange, Opnd *tauElemTypeChecked) { objectbase = propagateCopy(objectbase); ptr = propagateCopy(ptr); src = propagateCopy(src); tauBaseNonNull = propagateCopy(tauBaseNonNull); tauAddressInRange = propagateCopy(tauAddressInRange); tauElemTypeChecked = propagateCopy(tauElemTypeChecked); Type *ptrType = ptr->getType(); assert(ptrType->isPtr()); Type *fieldType = ((PtrType *)ptrType)->getPointedToType(); if (fieldType->isArrayElement()) { fieldType = fieldType->getNonValueSupertype(); } bool compress = (fieldType->isCompressedReference() && !type->isCompressedReference()); Modifier compressMod = Modifier(compress ? AutoCompress_Yes : AutoCompress_No); if (irBuilderFlags.insertWriteBarriers) { appendInst(instFactory->makeTauStRef((Modifier(Store_WriteBarrier)| compressMod), type->tag, src, ptr, objectbase, tauBaseNonNull, tauAddressInRange, tauElemTypeChecked)); } else { appendInst(instFactory->makeTauStRef((Modifier(Store_NoWriteBarrier)| compressMod), type->tag, src, ptr, objectbase, tauBaseNonNull, tauAddressInRange, tauElemTypeChecked)); } } void IRBuilder::genStField(Type* type, Opnd* base, FieldDesc* fieldDesc,Opnd* src) { assert (!fieldDesc->isStatic()); base = propagateCopy(base); src = propagateCopy(src); Opnd *tauBaseNonNull = genTauCheckNull(base); Opnd *tauBaseTypeIsOk = genTauHasType(base, fieldDesc->getParentType()); // Type *fieldType = fieldDesc->getFieldType(); Opnd *tauStoredTypeIsOk = (type->isObject() ? genTauHasType(src, type) : genTauSafe()); // safe, not an object if (irBuilderFlags.expandMemAddrs) { // do not expand ldField of stack values Opnd *ptr = genLdFieldAddr(type, base, fieldDesc); if (irBuilderFlags.insertWriteBarriers && src->getType()->isObject()) { genTauStRef(type, base, ptr, src, tauBaseNonNull, tauBaseTypeIsOk, tauStoredTypeIsOk); } else { genTauStInd(type, ptr, src, tauBaseNonNull, tauBaseTypeIsOk, tauStoredTypeIsOk); } } else { if (irBuilderFlags.insertWriteBarriers && base->getType()->isValue()==false) { appendInst(instFactory->makeTauStField((Modifier(Store_WriteBarrier)| Modifier(AutoCompress_Yes)), type->tag, src, base, tauBaseNonNull, tauBaseTypeIsOk, tauStoredTypeIsOk, fieldDesc)); } else { appendInst(instFactory->makeTauStField((Modifier(Store_NoWriteBarrier)| Modifier(AutoCompress_Yes)), type->tag, src, base, tauBaseNonNull, tauBaseTypeIsOk, tauStoredTypeIsOk, fieldDesc)); } } } void IRBuilder::genStFieldWithResolve(Type* type, Opnd* base, ObjectType* enclClass, U_32 cpIdx, Opnd* src) { base = propagateCopy(base); src = propagateCopy(src); Opnd *tauBaseNonNull = genTauCheckNull(base); Opnd *tauBaseTypeIsOk = genTauSafe(); Opnd *tauStoredTypeIsOk = (type->isObject() ? genTauHasType(src, type) : genTauSafe()); assert(irBuilderFlags.expandMemAddrs); Opnd *ptr = genLdFieldAddrWithResolve(type, base, enclClass, cpIdx, true); if (irBuilderFlags.insertWriteBarriers && src->getType()->isObject()) { genTauStRef(type, base, ptr, src, tauBaseNonNull, tauBaseTypeIsOk, tauStoredTypeIsOk); } else { genTauStInd(type, ptr, src, tauBaseNonNull, tauBaseTypeIsOk, tauStoredTypeIsOk); } } void IRBuilder::genStStaticWithResolve(Type* type, ObjectType* enclClass, U_32 cpIdx, Opnd* src) { src = propagateCopy(src); Opnd *tauOk = genTauSafe(); // address is always ok Opnd *tauTypeIsOk = type->isObject() ? genTauHasType(src, type) : genTauSafe(); assert(irBuilderFlags.expandMemAddrs); Opnd* addr = genLdStaticAddrWithResolve(type, enclClass, cpIdx, true); genTauStInd(type, addr, src, tauOk, tauOk, tauTypeIsOk); return; } void IRBuilder::genStStatic(Type* type, FieldDesc* fieldDesc, Opnd* src) { src = propagateCopy(src); genInitType(fieldDesc->getParentType()); Opnd *tauOk = genTauSafe(); // address is always ok // Type *fieldType = fieldDesc->getFieldType(); Opnd *tauTypeIsOk = (type->isObject() ? genTauHasType(src, type) : genTauSafe()); // safe, not an object if (irBuilderFlags.expandMemAddrs) { genTauStInd(type, genLdStaticAddr(type, fieldDesc), src, tauOk, tauOk, tauTypeIsOk // safety may depend on a type check ); return; } if (irBuilderFlags.insertWriteBarriers) { appendInst(instFactory->makeTauStStatic((Modifier(Store_WriteBarrier)| Modifier(AutoCompress_Yes)), type->tag, src, tauTypeIsOk, fieldDesc)); } else { appendInst(instFactory->makeTauStStatic((Modifier(Store_NoWriteBarrier)| Modifier(AutoCompress_Yes)), type->tag, src, tauTypeIsOk, fieldDesc)); } } void IRBuilder::genStElem(Type* elemType, Opnd* array, Opnd* index, Opnd* src, Opnd* tauNullChecked, Opnd* tauBaseTypeChecked, Opnd* tauAddressInRange) { array = propagateCopy(array); src = propagateCopy(src); index = propagateCopy(index); Opnd *tauElemTypeChecked = NULL; if (elemType->isObject()) { tauElemTypeChecked = genTauCheckElemType(array, src, tauNullChecked, tauBaseTypeChecked); } else { tauElemTypeChecked = genTauSafe(); // src type is ok if non-object } if (irBuilderFlags.expandMemAddrs) { Opnd *ptr = NULL; if (tauNullChecked && tauAddressInRange) { ptr = genLdElemAddrNoChecks(elemType, array, index); } else { ptr = genLdElemAddr(elemType, array, index); } if (irBuilderFlags.insertWriteBarriers && elemType->isObject()) { genTauStRef(elemType, array, ptr, src, tauNullChecked, tauAddressInRange, tauElemTypeChecked); } else { genTauStInd(elemType, ptr, src, tauNullChecked, tauAddressInRange, tauElemTypeChecked); } } else { if (irBuilderFlags.insertWriteBarriers) { appendInst(instFactory->makeTauStElem((Modifier(Store_WriteBarrier)| Modifier(AutoCompress_Yes)), elemType->tag, src, array, index, tauNullChecked, tauAddressInRange, tauElemTypeChecked)); } else { appendInst(instFactory->makeTauStElem((Modifier(Store_NoWriteBarrier)| Modifier(AutoCompress_Yes)), elemType->tag, src, array, index, tauNullChecked, tauAddressInRange, tauElemTypeChecked)); } } } void IRBuilder::genStElem(Type* elemType, Opnd* array, Opnd* index, Opnd* src) { array = propagateCopy(array); src = propagateCopy(src); index = propagateCopy(index); Opnd *tauNullChecked = NULL; Opnd *tauAddressInRange = NULL; Opnd *tauBaseTypeChecked = NULL; // prepare checks tauNullChecked = genTauCheckNull(array); tauBaseTypeChecked = genTauHasType(array, array->getType()); Opnd *tauBoundsChecked = genTauCheckBounds(array, index, tauNullChecked); tauAddressInRange = genTauAnd(tauBaseTypeChecked, tauBoundsChecked); genStElem(elemType,array,index,src,tauNullChecked,tauBaseTypeChecked,tauAddressInRange); } Opnd* IRBuilder::genNewObj(Type* type) { assert(type->isNamedType()); Opnd* dst = createOpnd(type); //FIXME class initialization must be done before allocating new object appendInst(instFactory->makeNewObj(dst, type)); genInitType(type->asNamedType()); return dst; } Opnd* IRBuilder::genNewObjWithResolve(ObjectType* enclClass, U_32 cpIndex) { Opnd* clsOpnd = createTypeOpnd(enclClass); Opnd* idxOpnd = genLdConstant((int)cpIndex); Opnd** args = new (irManager->getMemoryManager()) Opnd*[2]; args[0]=clsOpnd; args[1]=idxOpnd; Opnd* res = genVMHelperCall(VM_RT_NEWOBJ_WITHRESOLVE, typeManager->getUnresolvedObjectType(), 2, args); return res; } Opnd* IRBuilder::genNewArrayWithResolve(NamedType* elemType, Opnd* numElems, ObjectType* enclClass, U_32 cpIndex) { numElems = propagateCopy(numElems); Opnd* clsOpnd = createTypeOpnd(enclClass); Opnd* idxOpnd = genLdConstant((int)cpIndex); Opnd** args = new (irManager->getMemoryManager()) Opnd*[3]; args[0]=clsOpnd; args[1]=idxOpnd; args[2]=numElems; Type* resType = typeManager->getArrayType(elemType); Opnd* res = genVMHelperCall(VM_RT_NEWARRAY_WITHRESOLVE, resType, 3, args); return res; } Opnd* IRBuilder::genNewArray(NamedType* elemType, Opnd* numElems) { numElems = propagateCopy(numElems); Opnd* dst = createOpnd(typeManager->getArrayType(elemType)); appendInst(instFactory->makeNewArray(dst, numElems, elemType)); return dst; } Opnd* IRBuilder::genMultianewarray(NamedType* arrayType, U_32 dimensions, Opnd** numElems) { NamedType* elemType = arrayType; // create an array of arrays type for (U_32 i=0; igetElementType(); } Opnd* dst = createOpnd(arrayType); appendInst(instFactory->makeNewMultiArray(dst, dimensions, numElems, elemType)); return dst; } Opnd* IRBuilder::genMultianewarrayWithResolve(NamedType* arrayType, ObjectType* enclClass, U_32 cpIndex, U_32 dimensions, Opnd** numElems) { Opnd* enclClsOpnd = createTypeOpnd(enclClass); Opnd* idxOpnd = genLdConstant((int)cpIndex); Opnd** args = new (irManager->getMemoryManager()) Opnd*[2]; args[0] = enclClsOpnd; args[1] = idxOpnd; Opnd* clsOpnd = genVMHelperCall(VM_RT_INITIALIZE_CLASS_WITHRESOLVE, typeManager->getUnmanagedPtrType(typeManager->getInt8Type()), 2, args); size_t nArgs2 = 2+dimensions; Opnd** args2 = new (irManager->getMemoryManager()) Opnd*[nArgs2]; args2[0]=clsOpnd; args2[1]=genLdConstant((int)dimensions); // create an array of arrays type for (U_32 i=0; imakeTauMonitorEnter(src, tauNullChecked)); } void IRBuilder::genMonitorExit(Opnd* src) { src = propagateCopy(src); Opnd *tauNullChecked = genTauCheckNull(src); appendInst(instFactory->makeTauMonitorExit(src, tauNullChecked)); } Opnd* IRBuilder::genLdLockAddr(Type* dstType, Opnd* obj) { obj = propagateCopy(obj); Opnd* dst = lookupHash(Op_LdLockAddr, obj); if (dst) return dst; dst = createOpnd(dstType); appendInst(instFactory->makeLdLockAddr(dst, obj)); insertHash(Op_LdLockAddr, obj, dst->getInst()); return dst; } void IRBuilder::genIncRecCount(Opnd* obj, Opnd *oldLock) { obj = propagateCopy(obj); oldLock = propagateCopy(oldLock); appendInst(instFactory->makeLdLockAddr(obj, oldLock)); } Opnd* IRBuilder::genBalancedMonitorEnter(Type* dstType, Opnd* src, Opnd *lockAddr) { // src should already have been checked for null src = propagateCopy(src); lockAddr = propagateCopy(lockAddr); Opnd *tauNullChecked = genTauCheckNull(src); return genTauBalancedMonitorEnter(dstType, src, lockAddr, tauNullChecked); } Opnd* IRBuilder::genTauBalancedMonitorEnter(Type* dstType, Opnd* src, Opnd *lockAddr, Opnd* tauNullChecked) { // src should already have been checked for null src = propagateCopy(src); lockAddr = propagateCopy(lockAddr); Opnd *dst = createOpnd(dstType); appendInst(instFactory->makeTauBalancedMonitorEnter(dst, src, lockAddr, tauNullChecked)); return dst; } void IRBuilder::genBalancedMonitorExit(Opnd* src, Opnd *lockAddr, Opnd *oldValue) { // src should already have been checked for null src = propagateCopy(src); appendInst(instFactory->makeBalancedMonitorExit(src, lockAddr, oldValue)); } Opnd* IRBuilder::genTauOptimisticBalancedMonitorEnter(Type* dstType, Opnd* src, Opnd *lockAddr, Opnd *tauNullChecked) { // src should already have been checked for null src = propagateCopy(src); lockAddr = propagateCopy(lockAddr); Opnd *dst = createOpnd(dstType); appendInst(instFactory->makeTauOptimisticBalancedMonitorEnter(dst, src, lockAddr, tauNullChecked)); return dst; } void IRBuilder::genMonitorEnterFence(Opnd* src) { src = propagateCopy(src); appendInst(instFactory->makeMonitorEnterFence(src)); } void IRBuilder::genMonitorExitFence(Opnd* src) { src = propagateCopy(src); appendInst(instFactory->makeMonitorExitFence(src)); } void IRBuilder::genTypeMonitorEnter(Type* type) { appendInst(instFactory->makeTypeMonitorEnter(type)); } void IRBuilder::genTypeMonitorExit(Type* type) { appendInst(instFactory->makeTypeMonitorExit(type)); } // type checking // CastException (succeeds if argument is null, returns casted object) Opnd* IRBuilder::genCast(Opnd* src, Type* castType) { src = propagateCopy(src); Opnd* dst = lookupHash(Op_TauCast, src->getId(), castType->getId()); if (dst) return dst; Opnd *tauCheckedCast = lookupHash(Op_TauCheckCast, src->getId(), castType->getId()); if (!tauCheckedCast) { Opnd *tauNullChecked = lookupHash(Op_TauCheckNull, src->getId()); if (!tauNullChecked) { tauNullChecked = genTauUnsafe(); } tauCheckedCast = genTauCheckCast(src, tauNullChecked, castType); } dst = genTauStaticCast(src, tauCheckedCast, castType); insertHash(Op_TauCast, src->getId(), castType->getId(), dst->getInst()); return dst; } // type checking // CastException (succeeds if argument is null, returns casted object) Opnd* IRBuilder::genCastWithResolve(Opnd* src, Type* type, ObjectType* enclClass, U_32 cpIndex) { src = propagateCopy(src); Opnd* dst = lookupHash(Op_VMHelperCall, OPCODE_CHECKCAST, src->getId(), cpIndex); if (dst) return dst; Opnd** args = new (irManager->getMemoryManager()) Opnd*[3]; args[0] = createTypeOpnd(enclClass); args[1] = genLdConstant((int)cpIndex); args[2] = src; dst = genVMHelperCall(VM_RT_CHECKCAST_WITHRESOLVE, type, 3, args); insertHash(Op_VMHelperCall, OPCODE_CHECKCAST, src->getId(), cpIndex, dst->getInst()); return dst; } Opnd* IRBuilder::genTauCheckCast(Opnd* src, Opnd *tauNullChecked, Type* castType) { src = propagateCopy(src); tauNullChecked = propagateCopy(tauNullChecked); Opnd* dst = lookupHash(Op_TauCheckCast, src->getId(), castType->getId()); if (dst) return dst; if (irBuilderFlags.doSimplify) { bool alwaysThrows = false; dst = simplifier->simplifyTauCheckCast(src, tauNullChecked, castType, alwaysThrows); if (dst) { return dst; } } dst = createOpnd(typeManager->getTauType()); appendInst(instFactory->makeTauCheckCast(dst, src, tauNullChecked, castType)); insertHash(Op_TauCheckCast, src->getId(), castType->getId(), dst->getInst()); return dst; } // returns src if src is an instance of type, NULL otherwise Opnd* IRBuilder::genAsType(Opnd* src, Type* type) { if (type->isUserValue()) { assert(0); } src = propagateCopy(src); Opnd* tauCheckedNull = genTauUnsafe(); Opnd* dst = lookupHash(Op_TauAsType, src->getId(), tauCheckedNull->getId(), type->getId()); if (dst) return dst; if (irBuilderFlags.doSimplify) { dst = simplifier->simplifyTauAsType(src, tauCheckedNull, type); if (dst) return dst; } dst = createOpnd(type); appendInst(instFactory->makeTauAsType(dst, src, tauCheckedNull, type)); insertHash(Op_TauAsType, src->getId(), tauCheckedNull->getId(), type->getId(), dst->getInst()); return dst; } Opnd* IRBuilder::genInstanceOf(Opnd* src, Type* type) { src = propagateCopy(src); Opnd *tauNullChecked = genTauUnsafe(); Opnd* dst = lookupHash(Op_TauInstanceOf, src->getId(), tauNullChecked->getId(), type->getId()); if (dst) return dst; if (irBuilderFlags.doSimplify) { dst = simplifier->simplifyTauInstanceOf(src, tauNullChecked, type); if (dst) return dst; } dst = createOpnd(typeManager->getInt32Type()); appendInst(instFactory->makeTauInstanceOf(dst, src, tauNullChecked, type)); insertHash(Op_TauInstanceOf, src->getId(), type->getId(), tauNullChecked->getId(), dst->getInst()); return dst; } Opnd* IRBuilder::genInstanceOfWithResolve(Opnd* src, ObjectType* enclClass, U_32 cpIndex) { src = propagateCopy(src); Opnd* dst = lookupHash(Op_VMHelperCall, OPCODE_INSTANCEOF, src->getId(), cpIndex); if (dst) { return dst; } Opnd** args = new (irManager->getMemoryManager()) Opnd*[3]; args[0] = createTypeOpnd(enclClass); args[1] = genLdConstant((int)cpIndex); args[2] = src; dst = genVMHelperCall(VM_RT_INSTANCEOF_WITHRESOLVE, typeManager->getInt32Type(), 3, args); insertHash(Op_VMHelperCall, OPCODE_INSTANCEOF, src->getId(), cpIndex, dst->getInst()); return dst; } //----------------------------------------------------------------------------- // // Private helper methods for generating instructions // //----------------------------------------------------------------------------- Opnd* IRBuilder::propagateCopy(Opnd* opnd) { return simplifier->propagateCopy(opnd); } Opnd* IRBuilder::createOpnd(Type* type) { if (type->tag == Type::Void) return OpndManager::getNullOpnd(); return opndManager->createSsaTmpOpnd(type); } PiOpnd* IRBuilder::createPiOpnd(Opnd *org) { return opndManager->createPiOpnd(org); } Opnd* IRBuilder::genTauCheckNull(Opnd* base) { base = propagateCopy(base); if (! irBuilderFlags.expandNullChecks) { assert(0); // not expanding them is not compatible with taus return base; } Opnd* res = lookupHash(Op_TauCheckNull, base); if (res) return res; // Not advisable to turn off simplification of checknull because // IRBuilder calls genTauCheckNull redundantly many times bool alwaysThrows = false; res = simplifier->simplifyTauCheckNull(base, alwaysThrows); if (res && (res->getInst()->getOpcode() != Op_TauUnsafe)) return res; Opnd* dst = createOpnd(typeManager->getTauType()); Inst *inst = appendInst(instFactory->makeTauCheckNull(dst, base)); insertHash(Op_TauCheckNull, base, inst); // We can make the type init for the base object available here Type* baseType = base->getType(); insertHash(Op_InitType, baseType->getId(), inst); return dst; } Opnd* IRBuilder::genTauCheckZero(Opnd* src) { src = propagateCopy(src); Opnd* res = lookupHash(Op_TauCheckZero, src); if (res) return res; bool alwaysThrows = false; res = simplifier->simplifyTauCheckZero(src, alwaysThrows); if (res && (res->getInst()->getOpcode() != Op_TauUnsafe)) return res; Opnd* dst = createOpnd(typeManager->getTauType()); appendInst(instFactory->makeTauCheckZero(dst, src)); insertHash(Op_TauCheckZero, src, dst->getInst()); return dst; } Opnd *IRBuilder::genTauCheckDivOpnds(Opnd* src1, Opnd *src2) { src1 = propagateCopy(src1); src2 = propagateCopy(src2); Opnd* res = lookupHash(Op_TauCheckDivOpnds, src1, src2); if (res) return res; bool alwaysThrows = false; res = simplifier->simplifyTauCheckDivOpnds(src1, src2, alwaysThrows); if (res && (res->getInst()->getOpcode() != Op_TauUnsafe)) return res; Opnd* dst = createOpnd(typeManager->getTauType()); Inst *inst = appendInst(instFactory->makeTauCheckDivOpnds(dst, src1, src2)); insertHash(Op_TauCheckDivOpnds, src1, src2, inst); return dst; } Opnd *IRBuilder::genTauCheckBounds(Opnd* array, Opnd* index, Opnd *tauNullChecked) { // just to allow limit studies, omit all bounds checks // if command-line flag is given if (irBuilderFlags.suppressCheckBounds) return genTauUnsafe(); array = propagateCopy(array); index = propagateCopy(index); // we also hash operation with array as the opnd Opnd* res = lookupHash(Op_TauCheckBounds, array, index); if (res) return res; Opnd *tauArrayTypeChecked = genTauHasType(array, array->getType()); Opnd* arrayLen = genTauArrayLen(typeManager->getInt32Type(), Type::Int32, array, tauNullChecked, tauArrayTypeChecked); Opnd* dst = genTauCheckBounds(arrayLen, index); // we also hash operation with array as the opnd insertHash(Op_TauCheckBounds, array, index, dst->getInst()); return dst; } Opnd* IRBuilder::genTauCheckElemType(Opnd* array, Opnd* src, Opnd *tauNullChecked, Opnd *tauIsArray) { if (! irBuilderFlags.expandElemTypeChecks) return genTauUnsafe(); array = propagateCopy(array); src = propagateCopy(src); Opnd* res = lookupHash(Op_TauCheckElemType, array, src); if (res) return res; if (irBuilderFlags.doSimplify) { bool alwaysThrows = false; res = simplifier->simplifyTauCheckElemType(array, src, alwaysThrows); if (res && (res->getInst()->getOpcode() != Op_TauUnsafe)) return res; } Opnd* dst = createOpnd(typeManager->getTauType()); Inst* inst = appendInst(instFactory->makeTauCheckElemType(dst, array, src, tauNullChecked, tauIsArray)); insertHash(Op_TauCheckElemType, array, src, inst); return dst; } Opnd * IRBuilder::genTauCheckBounds(Opnd* ub, Opnd *index) { index = propagateCopy(index); ub = propagateCopy(ub); Opnd* dst = lookupHash(Op_TauCheckBounds, ub, index); if (dst) return dst; if (irBuilderFlags.doSimplify) { bool alwaysThrows = false; dst = simplifier->simplifyTauCheckBounds(ub, index, alwaysThrows); } if (!(dst && (dst->getInst()->getOpcode() != Op_TauUnsafe))) { // need to create one dst = createOpnd(typeManager->getTauType()); appendInst(instFactory->makeTauCheckBounds(dst, ub, index)); } insertHash(Op_TauCheckBounds, ub, index, dst->getInst()); return dst; } Opnd * IRBuilder::genCheckFinite(Type *dstType, Opnd* src) { assert(dstType == src->getType()); (void) genTauCheckFinite(src); return src; } Opnd * IRBuilder::genTauCheckFinite(Opnd* src) { src = propagateCopy(src); Opnd* dst = lookupHash(Op_TauCheckFinite, src); if (dst) return dst; if (irBuilderFlags.doSimplify) { bool alwaysThrows = false; dst = simplifier->simplifyTauCheckFinite(src, alwaysThrows); if (dst && (dst->getInst()->getOpcode() != Op_TauUnsafe)) return dst; } dst = createOpnd(typeManager->getTauType()); appendInst(instFactory->makeTauCheckFinite(dst, src)); insertHash(Op_TauCheckFinite, src, dst->getInst()); return dst; } //----------------------------------------------------------------------------- // // Methods for CSE hashing // //----------------------------------------------------------------------------- Opnd* IRBuilder::lookupHash(U_32 opc) { if (! irBuilderFlags.doCSE) return NULL; Inst* inst = cseHashTable->lookup(opc); if (inst) return inst->getDst(); else return NULL; } Opnd* IRBuilder::lookupHash(U_32 opc, U_32 op) { if (! irBuilderFlags.doCSE) return NULL; Inst* inst = cseHashTable->lookup(opc, op); if (inst) return inst->getDst(); else return NULL; } Opnd* IRBuilder::lookupHash(U_32 opc, U_32 op1, U_32 op2) { if (! irBuilderFlags.doCSE) return NULL; Inst* inst = cseHashTable->lookup(opc, op1, op2); if (inst) return inst->getDst(); else return NULL; } Opnd* IRBuilder::lookupHash(U_32 opc, U_32 op1, U_32 op2, U_32 op3) { if (! irBuilderFlags.doCSE) return NULL; Inst* inst = cseHashTable->lookup(opc, op1, op2, op3); if (inst) return inst->getDst(); else return NULL; } void IRBuilder::insertHash(U_32 opc, Inst* inst) { if (! irBuilderFlags.doCSE) return; cseHashTable->insert(opc, inst); } void IRBuilder::insertHash(U_32 opc, U_32 op1, Inst* inst) { if (! irBuilderFlags.doCSE) return; cseHashTable->insert(opc, op1, inst); } void IRBuilder::insertHash(U_32 opc, U_32 op1, U_32 op2, Inst* inst) { if (! irBuilderFlags.doCSE) return; cseHashTable->insert(opc, op1, op2, inst); } void IRBuilder::insertHash(U_32 opc, U_32 op1, U_32 op2, U_32 op3, Inst* inst) { if (! irBuilderFlags.doCSE) return; cseHashTable->insert(opc, op1, op2, op3, inst); } // tau instructions Opnd* IRBuilder::genTauSafe() { Opnd* dst = lookupHash(Op_TauSafe); if (dst) return dst; dst = createOpnd(typeManager->getTauType()); appendInst(instFactory->makeTauSafe(dst)); insertHash(Op_TauSafe, dst->getInst()); return dst; } // tau instructions Opnd* IRBuilder::genTauMethodSafe() { Opnd* dst = tauMethodSafeOpnd; if (dst) return dst; dst = createOpnd(typeManager->getTauType()); Inst *inst = instFactory->makeTauPoint(dst); Node *head = flowGraph->getEntryNode(); Inst *entryLabel = (Inst*)head->getFirstInst(); // first search for one already there Inst *where = entryLabel->getNextInst(); while (where != NULL) { if (where->getOpcode() != Op_DefArg) { break; } where = where->getNextInst(); } // insert before where inst->insertBefore(where); tauMethodSafeOpnd = dst; return dst; } Opnd* IRBuilder::genTauUnsafe() { Operation operation(Op_TauUnsafe, Type::Tau, Modifier()); Opnd* dst = lookupHash(Op_TauUnsafe); if (dst) return dst; dst = createOpnd(typeManager->getTauType()); appendInst(instFactory->makeTauUnsafe(dst)); insertHash(Op_TauUnsafe, dst->getInst()); return dst; } Opnd* IRBuilder::genTauStaticCast(Opnd *src, Opnd *tauCheckedCast, Type *castType) { Operation operation(Op_TauStaticCast, castType->tag, Modifier()); U_32 hashcode = operation.encodeForHashing(); Opnd* dst = lookupHash(hashcode, src->getId(), tauCheckedCast->getId(), castType->getId()); if (dst) return dst; dst = createOpnd(castType); appendInst(instFactory->makeTauStaticCast(dst, src, tauCheckedCast, castType)); insertHash(hashcode, src->getId(), tauCheckedCast->getId(), castType->getId(), dst->getInst()); Operation hasTypeOperation(Op_TauHasType, castType->tag, Modifier()); U_32 hasTypeHashcode = hasTypeOperation.encodeForHashing(); insertHash(hasTypeHashcode, src->getId(), castType->getId(), tauCheckedCast->getId(), dst->getInst()); return dst; } Opnd* IRBuilder::genTauHasType(Opnd *src, Type *castType) { Operation operation(Op_TauHasType, castType->tag, Modifier()); U_32 hashcode = operation.encodeForHashing(); Opnd* dst = lookupHash(hashcode, src->getId(), castType->getId()); if (dst) return dst; dst = createOpnd(typeManager->getTauType()); appendInst(instFactory->makeTauHasType(dst, src, castType)); insertHash(hashcode, src->getId(), castType->getId(), dst->getInst()); return dst; } Opnd* IRBuilder::genTauHasTypeWithConv(Opnd **srcPtr, Type *hasType) { Opnd* src = srcPtr[0]; Opnd* res = genTauHasType(src, hasType); Type* srcType = src->getType(); if (srcType->isUnresolvedType()) { //change opnd type in case if unresolved Modifier mod = Modifier(Overflow_None)|Modifier(Exception_Never)|Modifier(Strict_No); Opnd* newSrc = genConv(hasType, hasType->tag, mod, src); srcPtr[0] = newSrc; } return res; } Opnd* IRBuilder::genTauHasExactType(Opnd *src, Type *castType) { Operation operation(Op_TauHasExactType, castType->tag, Modifier()); U_32 hashcode = operation.encodeForHashing(); Opnd* dst = lookupHash(hashcode, src->getId(), castType->getId()); if (dst) return dst; dst = createOpnd(typeManager->getTauType()); appendInst(instFactory->makeTauHasExactType(dst, src, castType)); insertHash(hashcode, src->getId(), castType->getId(), dst->getInst()); return dst; } Opnd* IRBuilder::genTauIsNonNull(Opnd *src) { U_32 hashcode = Op_TauCheckNull; Opnd* dst = lookupHash(hashcode, src->getId()); if (dst) return dst; dst = createOpnd(typeManager->getTauType()); appendInst(instFactory->makeTauIsNonNull(dst, src)); insertHash(hashcode, src->getId(), dst->getInst()); // We can also make the type init for the base object available here Type* baseType = src->getType(); insertHash(Op_InitType, baseType->getId(), dst->getInst()); return dst; } Opnd* IRBuilder::genTauAnd(Opnd *src1, Opnd *src2) { if (src1->getId() > src2->getId()) { Opnd *tmp = src1; src1 = src2; src2 = tmp; } Opnd* dst = lookupHash(Op_TauAnd, src1, src2); if (dst) return dst; dst = createOpnd(typeManager->getTauType()); Opnd* srcs[2] = { src1, src2 }; appendInst(instFactory->makeTauAnd(dst, 2, srcs)); insertHash(Op_TauAnd, src1->getId(), src2->getId(), dst->getInst()); return dst; } Inst* IRBuilder::getLastGeneratedInst() { return (Inst*)currentLabel->getNode()->getLastInst(); } } //namespace Jitrino