| /* |
| * 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 |
| * |
| */ |
| |
| #ifndef _SIMPLIFIER_H_ |
| #define _SIMPLIFIER_H_ |
| |
| #include "VMInterface.h" |
| #include "Opcode.h" |
| #include "Type.h" |
| #include "Inst.h" |
| #include "optpass.h" |
| |
| namespace Jitrino { |
| |
| class FlowGraph; |
| class IRManager; |
| class InstFactory; |
| class Reassociate; |
| |
| |
| class Simplifier : public InstOptimizer { |
| public: |
| Simplifier(IRManager& irm, bool latepass=false, |
| Reassociate *reassociate=0); |
| // |
| // returns an Opnd if the add can be simplified |
| // null if the operation cannot be simplified |
| // |
| Opnd* simplifyAdd(Type*, Modifier, Opnd* src1, Opnd* src2); |
| Opnd* simplifySub(Type*, Modifier, Opnd* src1, Opnd* src2); |
| Opnd* simplifyMul(Type*, Modifier, Opnd* src1, Opnd* src2); |
| Opnd* simplifyTauDiv(Type*, Modifier, Opnd* src1, Opnd* src2, Opnd *tauCheckedOpnds); |
| Opnd* simplifyTauRem(Type*, Modifier, Opnd* src1, Opnd* src2, Opnd *tauCheckedOpnds); |
| Opnd* simplifyNeg(Type*, Opnd* src); |
| Opnd* simplifyMulHi(Type*, Modifier, Opnd* src1, Opnd* src2); |
| Opnd* simplifyMin(Type*, Opnd* src1, Opnd* src2); |
| Opnd* simplifyMax(Type*, Opnd* src1, Opnd* src2); |
| Opnd* simplifyAbs(Type*, Opnd* src1); |
| Opnd* simplifyAnd(Type*, Opnd* src1, Opnd* src2); |
| Opnd* simplifyOr(Type*, Opnd* src1, Opnd* src2); |
| Opnd* simplifyXor(Type*, Opnd* src1, Opnd* src2); |
| Opnd* simplifyNot(Type*, Opnd* src1); |
| Opnd* simplifySelect(Type*, Opnd* src1, Opnd* src2, Opnd* src3); |
| Opnd* simplifyConv(Type*, Type::Tag toType, Modifier, Opnd* src); |
| Opnd* simplifyConvZE(Type*, Type::Tag toType, Modifier, Opnd* src); |
| Opnd* simplifyConvUnmanaged(Type*, Type::Tag toType, Modifier, Opnd* src); |
| Opnd* simplifyShladd(Type* dstType, Opnd* value, Opnd* shiftAmount, Opnd *addto); |
| Opnd* simplifyShl(Type* dstType, Modifier, Opnd* value, Opnd* shiftAmount); |
| Opnd* simplifyShr(Type* dstType, Modifier, Opnd* value, Opnd* shiftAmount); |
| // Comparison |
| Opnd* simplifyCmp(Type* dstType, Type::Tag srcType, ComparisonModifier, Opnd* src1, Opnd* src2); |
| // 3-way Java comparison |
| Opnd* simplifyCmp3(Type* dstType, Type::Tag srcType, ComparisonModifier, Opnd* src1, Opnd* src2); |
| // Control flow |
| // If it can simplify the given branch, then makes a emits branch and |
| // returns true. Otherwise, returns false. You should probably try |
| // canFoldBranch() first. |
| bool simplifyBranch(Type::Tag instType, ComparisonModifier mod, |
| LabelInst* label, Opnd* src1); |
| bool simplifyBranch(Type::Tag instType, ComparisonModifier mod, |
| LabelInst* label, Opnd* src1, Opnd* src2); |
| // tests to fold a branch away completely. side-effects isTaken |
| // and returns True if branch can be folded away. |
| bool canFoldBranch(Type::Tag, ComparisonModifier, Opnd* src1, Opnd* src2,bool& isTaken); |
| bool canFoldBranch(Type::Tag, ComparisonModifier, Opnd* src, bool& isTaken); |
| bool simplifySwitch(U_32 numLabels, LabelInst* label[], LabelInst* defaultLabel, Opnd* src); |
| |
| Opnd* simplifyTauVirtualCall(MethodDesc* methodDesc, |
| Type* returnType, |
| Opnd* tauNullCheckedFirstArg, |
| Opnd* tauTypesChecked, |
| U_32 numArgs, |
| Opnd* args[]); |
| |
| Inst* simplifyIndirectCallInst(Opnd* funPtr, |
| Type* returnType, |
| Opnd* tauNullCheckedFirstArg, |
| Opnd* tauTypesChecked, |
| U_32 numArgs, |
| Opnd** args); |
| |
| Inst* simplifyIndirectMemoryCallInst(Opnd* funPtr, |
| Type* returnType, |
| Opnd* tauNullCheckedFirstArg, |
| Opnd* tauTypesChecked, |
| U_32 numArgs, |
| Opnd** args); |
| |
| Inst* simplifyJitHelperCall(JitHelperCallInst* inst); |
| |
| // loads |
| Opnd* simplifyLdRef(Modifier mod, Type *dstType, |
| U_32 token, |
| MethodDesc* enclosingMethod); |
| Opnd* simplifyTauLdInd(Modifier mod, Type *dstType, |
| Type::Tag type, |
| Opnd* ptr, |
| Opnd* tauBaseNonNull, |
| Opnd* tauAddressInRange); |
| Opnd* simplifyTauLdVTableAddr(Opnd* base, Opnd *tauBaseNonNull); |
| Opnd* simplifyTauLdIntfcVTableAddr(Opnd* base, Type* vtableType); |
| Opnd* simplifyTauLdVirtFunAddr(Opnd* vtable, Opnd *tauVtableHasDesc, MethodDesc*); |
| Opnd* simplifyTauLdVirtFunAddrSlot(Opnd* vtable, Opnd *tauVtableHasDesc, MethodDesc*); |
| |
| // array operations |
| Opnd* simplifyTauArrayLen(Type* dstType, Type::Tag type, Opnd* base); |
| Opnd* simplifyTauArrayLen(Type* dstType, Type::Tag type, Opnd* base, |
| Opnd* tauNullChecked, Opnd *tauTypeChecked); |
| Opnd* simplifyLdArrayBaseAddr(Type* elemType, Opnd* array) { |
| return NULL; |
| } |
| Opnd* simplifyAddScaledIndex(Opnd* base, Opnd* index); |
| // stores |
| void simplifyTauStInd(Inst *inst); // modifies instr in place if possible |
| void simplifyTauStField(Inst *inst); // modifies instr in place if possible |
| void simplifyTauStElem(Inst *inst); // modifies instr in place if possible |
| void simplifyTauStStatic(Inst *inst); // modifies instr in place if possible |
| void simplifyTauStRef(Inst *inst); // modifies instr in place if possible |
| |
| // checks |
| // These all return a tau normally. If we have reason to believe that they |
| // will always pass, we return the tau guaranteeing that. If they would always |
| // fail, returns the destOp of a TauUnsafe instruction. |
| Opnd* simplifyTauCheckBounds(Opnd* arrayLen, Opnd* index, bool &alwaysThrows); |
| Opnd* simplifyTauCheckLowerBound(Opnd* lb, Opnd* idx, bool &alwaysThrows); |
| Opnd* simplifyTauCheckUpperBound(Opnd* idx, Opnd* ub, bool &alwaysThrows); |
| Opnd* simplifyTauCheckNull(Opnd*, bool &alwaysThrows); |
| Opnd* simplifyTauCheckZero(Opnd*, bool &alwaysThrows); |
| Opnd* simplifyTauCheckDivOpnds(Opnd* src1, Opnd* src2, bool &alwaysThrows); |
| Opnd* simplifyTauCheckElemType(Opnd* arrayBase, Opnd* src, bool &alwaysThrows); |
| Opnd* simplifyTauCheckFinite(Opnd*, bool &alwaysThrows); |
| Opnd* simplifyTauCheckCast(Opnd* src, Opnd* tauCheckedNull, Type *castType, |
| bool &alwaysThrows); |
| Opnd* simplifyTauHasType(Opnd* src, Type *castType); |
| Opnd* simplifyTauHasExactType(Opnd* src, Type *castType); |
| Opnd* simplifyTauIsNonNull(Opnd* src); |
| |
| // type checking |
| Opnd* simplifyTauCast(Opnd* src, Opnd* tauCheckedNull, Type* castType); |
| Opnd* simplifyTauStaticCast(Opnd* src, Opnd *tauNonNull, Type* castType); |
| Opnd* simplifyTauAsType(Opnd* src, Opnd *tauCheckedNull, Type* type); |
| Opnd* simplifyTauInstanceOf(Opnd* src, Opnd *tauCheckedNull, Type* type); |
| |
| // compressed references |
| Opnd* simplifyUncompressRef(Opnd* compRef); |
| Opnd* simplifyCompressRef(Opnd* uncompRef); |
| Opnd* simplifyAddOffset(Type *ptrType, Opnd* uncompBase, Opnd *offset); |
| Opnd* simplifyAddOffsetPlusHeapbase(Type *ptrType, Opnd* compBase, |
| Opnd *offsetPlusHeapbase); |
| |
| // tau operations |
| Opnd* simplifyTauAnd(MultiSrcInst *tauAndInst); |
| |
| Opnd* propagateCopy(Opnd*); |
| |
| static bool isNonNullObject(Opnd*); |
| static bool isNonNullParameter(Opnd*); |
| static bool isNullObject(Opnd*); |
| static bool isExactType(Opnd*); |
| protected: |
| IRManager& irManager; |
| ControlFlowGraph& flowGraph; |
| |
| // genOp routines create an instruction, may never return NULL |
| // but may simplify it to some other instruction |
| // numeric |
| virtual Inst* genAdd(Type*, Modifier, Opnd* src1, Opnd* src2) = 0; |
| virtual Inst* genSub(Type*, Modifier, Opnd* src1, Opnd* src2) = 0; |
| virtual Inst* genNeg(Type*, Opnd* src) = 0; |
| virtual Inst* genMul(Type*, Modifier, Opnd* src1, Opnd* src2) = 0; |
| virtual Inst* genMulHi(Type*, Modifier, Opnd* src1, Opnd* src2) = 0; |
| virtual Inst* genMin(Type*, Opnd* src1, Opnd* src2) = 0; |
| virtual Inst* genMax(Type*, Opnd* src1, Opnd* src2) = 0; |
| virtual Inst* genAbs(Type*, Opnd* src1) = 0; |
| // bitwise |
| virtual Inst* genAnd(Type*, Opnd* src1, Opnd* src2) = 0; |
| virtual Inst* genOr(Type*, Opnd* src1, Opnd* src2) = 0; |
| virtual Inst* genXor(Type*, Opnd* src1, Opnd* src2) = 0; |
| virtual Inst* genNot(Type*, Opnd* src1) = 0; |
| virtual Inst* genSelect(Type*, |
| Opnd* src1, Opnd* src2, Opnd* src3) = 0; |
| // conversion |
| virtual Inst* genConv(Type*, Type::Tag toType, Modifier, |
| Opnd* src1) = 0; |
| virtual Inst* genConvZE(Type*, Type::Tag toType, Modifier, |
| Opnd* src1) = 0; |
| virtual Inst* genConvUnmanaged(Type*, Type::Tag toType, Modifier, |
| Opnd* src1) = 0; |
| // shifts |
| virtual Inst* genShladd(Type*, Opnd *value, |
| Opnd* shiftAmount, Opnd* addTo) = 0; |
| virtual Inst* genShl(Type*, Modifier, |
| Opnd* src1, Opnd* src2) = 0; |
| virtual Inst* genShr(Type*, Modifier, |
| Opnd* src1, Opnd* src2) = 0; |
| // comparison |
| virtual Inst* genCmp(Type*, Type::Tag insttype, |
| ComparisonModifier, Opnd* src1, Opnd* src2) = 0; |
| // control flow |
| virtual void genJump(LabelInst* label) = 0; |
| virtual void genBranch(Type::Tag instType, ComparisonModifier mod, |
| LabelInst* label, Opnd* src1, Opnd* src2) = 0; |
| virtual void genBranch(Type::Tag instType, ComparisonModifier mod, |
| LabelInst* label, Opnd* src1) = 0; |
| virtual Inst* genDirectCall(MethodDesc*, |
| Type* returnType, |
| Opnd* tauNullCheckedFirstArg, |
| Opnd* tauTypesChecked, |
| U_32 numArgs, |
| Opnd* args[]) = 0; |
| // load, store & move |
| virtual Inst* genLdConstant(I_32 val) = 0; |
| virtual Inst* genLdConstant(int64 val) = 0; |
| virtual Inst* genLdConstant(float val) = 0; |
| virtual Inst* genLdConstant(double val) = 0; |
| virtual Inst* genLdConstant(Type *type, ConstInst::ConstValue val) = 0; |
| virtual Inst* genTauLdInd(Modifier mod, Type *dstType, Type::Tag type, Opnd *ptr, |
| Opnd *tauNonNullBase, Opnd *tauAddressInRange) = 0; |
| virtual Inst* genLdRef(Modifier mod, Type *dstType, |
| U_32 token, MethodDesc *enclosingMethod) = 0; |
| virtual Inst* genLdFunAddrSlot(MethodDesc*) = 0; |
| virtual Inst* genGetVTableAddr(ObjectType* type) = 0; |
| // compressed references |
| virtual Inst* genCompressRef(Opnd *uncompref) = 0; |
| virtual Inst* genUncompressRef(Opnd *compref) = 0; |
| virtual Inst* genLdFieldOffsetPlusHeapbase(FieldDesc*) = 0; |
| virtual Inst* genLdArrayBaseOffsetPlusHeapbase(Type *elemType) = 0; |
| virtual Inst* genLdArrayLenOffsetPlusHeapbase(Type *elemType) = 0; |
| virtual Inst* genAddOffsetPlusHeapbase(Type *ptrType, Opnd *compRef, |
| Opnd *offsetPlusHeapbase) = 0; |
| virtual Inst* genTauSafe() = 0; |
| virtual Inst* genTauMethodSafe() = 0; |
| virtual Inst* genTauUnsafe() = 0; |
| virtual Inst* genTauStaticCast(Opnd *src, Opnd *tauCheckedCast, Type *castType) = 0; |
| virtual Inst* genTauHasType(Opnd *src, Type *castType) = 0; |
| virtual Inst* genTauHasExactType(Opnd *src, Type *castType) = 0; |
| virtual Inst* genTauIsNonNull(Opnd *src) = 0; |
| |
| // helper for store simplification, builds/finds simpler src, possibly |
| // modifies typetag or store modifier. |
| virtual Opnd *simplifyStoreSrc(Opnd *, Type::Tag &typetag, Modifier &mod, |
| bool compressRef) = 0; |
| |
| virtual void genThrowSystemException(CompilationInterface::SystemExceptionId) = 0; |
| |
| virtual void foldBranch(BranchInst* branchInst, bool isTaken) = 0; |
| virtual void foldSwitch(SwitchInst* switchInst, U_32 index) = 0; |
| virtual void eliminateCheck(Inst* checkInst, bool alwaysThrows) = 0; |
| |
| Opnd *planMul32(I_32 multiplier, Opnd *opnd); |
| Opnd *planMul64(int64 multiplier, Opnd *opnd); |
| public: |
| //------------------------------------------------------------------------- |
| // InstOptimizer methods |
| //------------------------------------------------------------------------- |
| virtual Inst* optimizeInst(Inst* inst); |
| Inst* caseAdd(Inst* inst) { |
| Opnd* opnd = simplifyAdd(inst->getDst()->getType(), |
| inst->getModifier(), |
| inst->getSrc(0), |
| inst->getSrc(1)); |
| if (opnd != NULL) |
| return opnd->getInst(); |
| return inst; |
| } |
| Inst* caseMul(Inst* inst) { |
| Opnd* opnd = simplifyMul(inst->getDst()->getType(), |
| inst->getModifier(), |
| inst->getSrc(0), |
| inst->getSrc(1)); |
| if (opnd != NULL) |
| return opnd->getInst(); |
| return inst; |
| } |
| Inst* caseSub(Inst* inst) { |
| Opnd* opnd = simplifySub(inst->getDst()->getType(), |
| inst->getModifier(), |
| inst->getSrc(0), |
| inst->getSrc(1)); |
| if (opnd != NULL) |
| return opnd->getInst(); |
| return inst; |
| } |
| Inst* caseTauDiv(Inst* inst) { |
| Opnd* opnd = simplifyTauDiv(inst->getDst()->getType(), |
| inst->getModifier(), |
| inst->getSrc(0), |
| inst->getSrc(1), |
| inst->getSrc(2)); |
| if (opnd != NULL) |
| return opnd->getInst(); |
| return inst; |
| } |
| Inst* caseTauRem(Inst* inst) { |
| Opnd* opnd = simplifyTauRem(inst->getDst()->getType(), |
| inst->getModifier(), |
| inst->getSrc(0), |
| inst->getSrc(1), |
| inst->getSrc(2)); |
| if (opnd != NULL) |
| return opnd->getInst(); |
| return inst; |
| } |
| Inst* caseNeg(Inst* inst) { |
| Opnd* opnd = simplifyNeg(inst->getDst()->getType(), |
| inst->getSrc(0)); |
| if (opnd != NULL) |
| return opnd->getInst(); |
| return inst; |
| } |
| Inst* caseMulHi(Inst* inst) { |
| Opnd* opnd = simplifyMulHi(inst->getDst()->getType(), |
| inst->getModifier(), |
| inst->getSrc(0), |
| inst->getSrc(1)); |
| if (opnd != NULL) |
| return opnd->getInst(); |
| return inst; |
| } |
| Inst* caseMin(Inst* inst) { |
| Opnd* opnd = simplifyMin(inst->getDst()->getType(), |
| inst->getSrc(0), |
| inst->getSrc(1)); |
| if (opnd != NULL) |
| return opnd->getInst(); |
| return inst; |
| } |
| Inst* caseMax(Inst* inst) { |
| Opnd* opnd = simplifyMax(inst->getDst()->getType(), |
| inst->getSrc(0), |
| inst->getSrc(1)); |
| if (opnd != NULL) |
| return opnd->getInst(); |
| return inst; |
| } |
| Inst* caseAbs(Inst* inst) { |
| Opnd* opnd = simplifyAbs(inst->getDst()->getType(), |
| inst->getSrc(0)); |
| if (opnd != NULL) |
| return opnd->getInst(); |
| return inst; |
| } |
| |
| // Bitwise |
| Inst* caseAnd(Inst* inst) { |
| Opnd* opnd = simplifyAnd(inst->getDst()->getType(), |
| inst->getSrc(0), |
| inst->getSrc(1)); |
| if (opnd != NULL) |
| return opnd->getInst(); |
| return inst; |
| } |
| Inst* caseOr(Inst* inst) { |
| Opnd* opnd = simplifyOr(inst->getDst()->getType(), |
| inst->getSrc(0), |
| inst->getSrc(1)); |
| if (opnd != NULL) |
| return opnd->getInst(); |
| return inst; |
| } |
| Inst* caseXor(Inst* inst) { |
| Opnd* opnd = simplifyXor(inst->getDst()->getType(), |
| inst->getSrc(0), |
| inst->getSrc(1)); |
| if (opnd != NULL) |
| return opnd->getInst(); |
| return inst; |
| } |
| Inst* caseNot(Inst* inst) { |
| Opnd* opnd = simplifyNot(inst->getDst()->getType(), |
| inst->getSrc(0)); |
| if (opnd != NULL) |
| return opnd->getInst(); |
| return inst; |
| } |
| |
| // selection |
| Inst* caseSelect(Inst* inst) { |
| Opnd* opnd = simplifySelect(inst->getDst()->getType(), |
| inst->getSrc(0), |
| inst->getSrc(1), |
| inst->getSrc(2)); |
| if (opnd != NULL) |
| return opnd->getInst(); |
| return inst; |
| } |
| // conversion |
| Inst* caseConv(Inst* inst) { |
| Opnd* opnd = simplifyConv(inst->getDst()->getType(), |
| inst->getType(), |
| inst->getModifier(), |
| inst->getSrc(0)); |
| if (opnd != NULL) |
| return opnd->getInst(); |
| return inst; |
| } |
| |
| // conversion |
| Inst* caseConvUnmanaged(Inst* inst) { |
| return inst; |
| } |
| |
| Inst* caseConvZE(Inst* inst) { |
| return inst; |
| } |
| |
| |
| // shifts |
| Inst* caseShladd(Inst* inst) { |
| Opnd* opnd = simplifyShladd(inst->getDst()->getType(), |
| inst->getSrc(0), |
| inst->getSrc(1), |
| inst->getSrc(2)); |
| if (opnd != NULL) |
| return opnd->getInst(); |
| return inst; |
| } |
| Inst* caseShl(Inst* inst) { |
| Opnd* opnd = simplifyShl(inst->getDst()->getType(), |
| inst->getModifier(), |
| inst->getSrc(0), |
| inst->getSrc(1)); |
| if (opnd != NULL) |
| return opnd->getInst(); |
| return inst; |
| } |
| Inst* caseShr(Inst* inst) { |
| Opnd* opnd = simplifyShr(inst->getDst()->getType(), |
| inst->getModifier(), |
| inst->getSrc(0), |
| inst->getSrc(1)); |
| if (opnd != NULL) |
| return opnd->getInst(); |
| return inst; |
| } |
| |
| // comparison |
| Inst* caseCmp(Inst* inst) { |
| Opnd* opnd = simplifyCmp(inst->getDst()->getType(), |
| inst->getType(), |
| inst->getComparisonModifier(), |
| inst->getSrc(0), |
| inst->getSrc(1)); |
| if (opnd != NULL) |
| return opnd->getInst(); |
| return inst; |
| } |
| |
| Inst* caseCmp3(Inst* inst) { |
| Opnd* opnd = simplifyCmp3(inst->getDst()->getType(), |
| inst->getType(), |
| inst->getComparisonModifier(), |
| inst->getSrc(0), |
| inst->getSrc(1)); |
| if (opnd != NULL) |
| return opnd->getInst(); |
| return inst; |
| } |
| |
| Inst* caseBranch(BranchInst* inst); |
| |
| Inst* caseJump(BranchInst* inst) { return caseDefault(inst); }; |
| |
| Inst* caseSwitch(SwitchInst* inst); |
| |
| Inst* caseDirectCall(MethodCallInst* inst) {return caseDefault(inst);} |
| |
| Inst* caseTauVirtualCall(MethodCallInst* inst) {return caseDefault(inst);} |
| |
| Inst* caseIndirectCall(CallInst* inst); |
| |
| Inst* caseIndirectMemoryCall(CallInst* inst); |
| |
| Inst* caseJitHelperCall(JitHelperCallInst* inst) {return simplifyJitHelperCall(inst->asJitHelperCallInst());} |
| |
| Inst* caseVMHelperCall(VMHelperCallInst* inst) {return caseDefault(inst);} |
| |
| Inst* caseReturn(Inst* inst) {return caseDefault(inst);} |
| |
| Inst* caseCatch(Inst* inst) {return caseDefault(inst);} |
| |
| Inst* caseThrow(Inst* inst) {return caseDefault(inst);} |
| |
| Inst* casePseudoThrow(Inst* inst) {return caseDefault(inst);} |
| |
| Inst* caseThrowSystemException(Inst* inst) {return caseDefault(inst);} |
| |
| Inst* caseThrowLinkingException(Inst* inst) {return caseDefault(inst);} |
| |
| Inst* caseRethrow(Inst* inst) {return caseDefault(inst);} |
| |
| Inst* caseLeave(Inst* inst) {return caseDefault(inst);} |
| |
| |
| Inst* caseJSR(Inst* inst) {return caseDefault(inst);} |
| |
| Inst* caseRet(Inst* inst) {return caseDefault(inst);} |
| |
| Inst* caseSaveRet(Inst* inst) {return caseDefault(inst);} |
| |
| Inst* caseCopy(Inst* inst) {return inst->getSrc(0)->getInst(); } |
| |
| Inst* caseDefArg(Inst* inst) {return caseDefault(inst);} |
| |
| Inst* caseLdConstant(ConstInst* inst) {return caseDefault(inst);} |
| |
| Inst* caseLdNull(ConstInst* inst) {return caseDefault(inst);} |
| |
| Inst* |
| caseLdRef(TokenInst* inst) { |
| Opnd* opnd = simplifyLdRef(inst->getModifier(), |
| inst->getDst()->getType(), |
| inst->getToken(), |
| inst->getEnclosingMethod()); |
| if (opnd != NULL) |
| return opnd->getInst(); |
| return inst; |
| } |
| |
| Inst* caseLdVar(Inst* inst) {return caseDefault(inst);} |
| |
| Inst* caseLdVarAddr(Inst* inst) {return caseDefault(inst);} |
| |
| Inst* |
| caseTauLdInd(Inst* inst) { |
| Opnd* opnd = simplifyTauLdInd(inst->getModifier(), |
| inst->getDst()->getType(), |
| inst->getType(), |
| inst->getSrc(0), |
| inst->getSrc(1), |
| inst->getSrc(2)); |
| if (opnd != NULL) |
| return opnd->getInst(); |
| return inst; |
| } |
| |
| Inst* caseTauLdField(FieldAccessInst* inst) {return caseDefault(inst);} |
| |
| Inst* caseLdStatic(FieldAccessInst* inst) {return caseDefault(inst);} |
| |
| Inst* caseTauLdElem(TypeInst* inst) {return caseDefault(inst);} |
| |
| // address loads |
| Inst* caseLdFieldAddr(FieldAccessInst* inst) {return caseDefault(inst);} |
| |
| Inst* caseLdStaticAddr(FieldAccessInst* inst) {return caseDefault(inst);} |
| |
| Inst* caseLdElemAddr(TypeInst* inst) {return caseDefault(inst);} |
| |
| Inst* caseTauLdVTableAddr(Inst* inst) { |
| Opnd* opnd = simplifyTauLdVTableAddr(inst->getSrc(0), |
| inst->getSrc(1)); |
| if (opnd != NULL) |
| return opnd->getInst(); |
| return inst; |
| } |
| Inst* caseTauLdIntfcVTableAddr(TypeInst* inst) { |
| Opnd* opnd = simplifyTauLdIntfcVTableAddr(inst->getSrc(0), |
| inst->getTypeInfo()); |
| if (opnd != NULL) |
| return opnd->getInst(); |
| return inst; |
| } |
| Inst* caseTauLdVirtFunAddr(MethodInst* inst) { |
| Opnd* opnd = simplifyTauLdVirtFunAddr(inst->getSrc(0), |
| inst->getSrc(1), |
| inst->getMethodDesc()); |
| if (opnd != NULL) |
| return opnd->getInst(); |
| return inst; |
| } |
| Inst* caseTauLdVirtFunAddrSlot(MethodInst* inst) { |
| Opnd* opnd = simplifyTauLdVirtFunAddrSlot(inst->getSrc(0), |
| inst->getSrc(1), |
| inst->getMethodDesc()); |
| if (opnd != NULL) |
| return opnd->getInst(); |
| return inst; |
| } |
| |
| Inst* caseLdFunAddr(MethodInst* inst) {return caseDefault(inst);} |
| |
| Inst* caseLdFunAddrSlot(MethodInst* inst) {return caseDefault(inst);} |
| |
| Inst* caseGetVTableAddr(TypeInst* inst) {return caseDefault(inst);} |
| |
| Inst* caseGetClassObj(TypeInst* inst) {return caseDefault(inst);} |
| |
| |
| // array access |
| Inst* caseTauArrayLen(Inst* inst) { |
| Opnd* opnd = simplifyTauArrayLen(inst->getDst()->getType(), |
| inst->getType(), |
| inst->getSrc(0), |
| inst->getSrc(1), |
| inst->getSrc(2)); |
| if (opnd != NULL) |
| return opnd->getInst(); |
| return inst; |
| } |
| |
| Inst* caseLdArrayBaseAddr(Inst* inst) {return caseDefault(inst);} |
| |
| Inst* caseAddScaledIndex(Inst* inst) { |
| Opnd* opnd = simplifyAddScaledIndex(inst->getSrc(0), |
| inst->getSrc(1)); |
| if (opnd != NULL) |
| return opnd->getInst(); |
| return inst; |
| } |
| |
| // stores |
| Inst* caseStVar(Inst* inst) {return caseDefault(inst);} |
| |
| Inst* caseTauStInd(Inst* inst) { |
| simplifyTauStInd(inst); |
| return inst; |
| } |
| |
| Inst* caseTauStField(Inst* inst) { |
| simplifyTauStField(inst); |
| return inst; |
| } |
| |
| Inst* caseTauStElem(Inst* inst) { |
| simplifyTauStElem(inst); |
| return inst; |
| } |
| |
| Inst* caseTauStStatic(Inst* inst) { |
| simplifyTauStStatic(inst); |
| return inst; |
| } |
| |
| Inst* caseTauStRef(Inst* inst) { |
| simplifyTauStRef(inst); |
| return inst; |
| } |
| |
| // checks |
| Inst* caseTauCheckBounds(Inst* inst) { |
| bool alwaysThrows = false; |
| Opnd* opnd = simplifyTauCheckBounds(inst->getSrc(0), inst->getSrc(1), |
| alwaysThrows); |
| if (opnd) { |
| eliminateCheck(inst, alwaysThrows); |
| return opnd->getInst(); |
| } |
| return inst; |
| } |
| Inst* caseTauCheckLowerBound(Inst* inst) { |
| bool alwaysThrows = false; |
| Opnd* opnd = simplifyTauCheckLowerBound(inst->getSrc(0), inst->getSrc(1), |
| alwaysThrows); |
| if (opnd) { |
| eliminateCheck(inst, alwaysThrows); |
| return opnd->getInst(); |
| } |
| return inst; |
| } |
| Inst* caseTauCheckUpperBound(Inst* inst) { |
| bool alwaysThrows = false; |
| Opnd* opnd = simplifyTauCheckUpperBound(inst->getSrc(0), inst->getSrc(1), |
| alwaysThrows); |
| if (opnd) { |
| eliminateCheck(inst, alwaysThrows); |
| return opnd->getInst(); |
| } |
| return inst; |
| } |
| Inst* caseTauCheckNull(Inst* inst) { |
| bool alwaysThrows = false; |
| Opnd* opnd = simplifyTauCheckNull(inst->getSrc(0), alwaysThrows); |
| if (opnd) { |
| eliminateCheck(inst, alwaysThrows); |
| return opnd->getInst(); |
| } |
| return inst; |
| } |
| Inst* caseTauCheckZero(Inst* inst) { |
| bool alwaysThrows = false; |
| Opnd* opnd = simplifyTauCheckZero(inst->getSrc(0), alwaysThrows); |
| if (opnd) { |
| eliminateCheck(inst, alwaysThrows); |
| return opnd->getInst(); |
| } |
| return inst; |
| } |
| Inst* caseTauCheckDivOpnds(Inst* inst) { |
| bool alwaysThrows = false; |
| Opnd* opnd = simplifyTauCheckDivOpnds(inst->getSrc(0), inst->getSrc(1), |
| alwaysThrows); |
| if (opnd) { |
| eliminateCheck(inst, alwaysThrows); |
| return opnd->getInst(); |
| } |
| return inst; |
| } |
| Inst* caseTauCheckElemType(Inst* inst) { |
| bool alwaysThrows = false; |
| Opnd* opnd = simplifyTauCheckElemType(inst->getSrc(0), inst->getSrc(1), |
| alwaysThrows); |
| if (opnd) { |
| eliminateCheck(inst, alwaysThrows); |
| return opnd->getInst(); |
| } |
| return inst; |
| } |
| Inst* caseTauCheckFinite(Inst* inst) { |
| bool alwaysThrows = false; |
| Opnd* opnd = simplifyTauCheckFinite(inst->getSrc(0), alwaysThrows); |
| if (opnd) { |
| eliminateCheck(inst, alwaysThrows); |
| return opnd->getInst(); |
| } |
| return inst; |
| } |
| |
| // alloc |
| |
| Inst* caseNewObj(Inst* inst) {return caseDefault(inst);} |
| |
| Inst* caseNewArray(Inst* inst) {return caseDefault(inst);} |
| |
| Inst* caseNewMultiArray(Inst* inst) {return caseDefault(inst);} |
| |
| // sync |
| |
| Inst* caseTauMonitorEnter(Inst* inst) {return caseDefault(inst);} |
| |
| Inst* caseTauMonitorExit(Inst* inst) {return caseDefault(inst);} |
| |
| Inst* caseTypeMonitorEnter(Inst* inst) {return caseDefault(inst);} |
| |
| Inst* caseTypeMonitorExit(Inst* inst) {return caseDefault(inst);} |
| |
| Inst* caseLdLockAddr(Inst* inst) {return caseDefault(inst);} |
| |
| Inst* caseIncRecCount(Inst* inst) {return caseDefault(inst);} |
| |
| Inst* caseTauBalancedMonitorEnter(Inst* inst) {return caseDefault(inst);} |
| |
| Inst* caseBalancedMonitorExit(Inst* inst) {return caseDefault(inst);} |
| |
| Inst* caseTauOptimisticBalancedMonitorEnter(Inst* inst) {return caseDefault(inst);} |
| |
| Inst* caseOptimisticBalancedMonitorExit(Inst* inst) {return caseDefault(inst);} |
| |
| Inst* caseMonitorEnterFence(Inst* inst) {return caseDefault(inst);} |
| |
| Inst* caseMonitorExitFence(Inst* inst) {return caseDefault(inst);} |
| |
| // type checking |
| Inst* caseTauStaticCast(TypeInst *inst) { |
| Opnd* opnd = simplifyTauStaticCast(inst->getSrc(0), inst->getSrc(1), |
| inst->getTypeInfo()); |
| if (opnd != NULL) { |
| return opnd->getInst(); |
| } |
| return inst; |
| } |
| Inst* caseTauCast(TypeInst* inst) { |
| Opnd* opnd = simplifyTauCast(inst->getSrc(0), inst->getSrc(1), inst->getTypeInfo()); |
| if (opnd != NULL) { |
| eliminateCheck(inst, false); |
| return opnd->getInst(); |
| } |
| return inst; |
| } |
| |
| Inst* caseSizeof(TypeInst* inst) {return caseDefault(inst);} |
| |
| Inst* caseTauAsType(TypeInst* inst) { |
| Opnd* opnd = simplifyTauAsType(inst->getSrc(0), inst->getSrc(1), inst->getTypeInfo()); |
| if (opnd != NULL) |
| return opnd->getInst(); |
| return inst; |
| } |
| |
| Inst* caseTauInstanceOf(TypeInst* inst) { |
| Opnd* opnd = simplifyTauInstanceOf(inst->getSrc(0), |
| inst->getSrc(1), |
| inst->getTypeInfo()); |
| if (opnd != NULL) |
| return opnd->getInst(); |
| return inst; |
| } |
| Inst* caseInitType(TypeInst* inst) { |
| return inst; |
| } |
| |
| // labels |
| Inst* caseLabel(Inst* inst) {return caseDefault(inst);} |
| |
| Inst* caseCatchLabelInst(Inst* inst) {return caseDefault(inst);} |
| |
| // method entry/exit |
| Inst* caseMethodEntryLabel(Inst* inst) {return caseDefault(inst);} |
| |
| Inst* caseMethodEntry(Inst* inst) {return caseDefault(inst);} |
| |
| Inst* caseMethodEnd(Inst* inst) {return caseDefault(inst);} |
| |
| // source markers |
| Inst* caseMethodMarker(Inst* inst) {return caseDefault(inst);} |
| |
| Inst* casePhi(Inst* inst){return caseDefault(inst);} |
| |
| Inst* caseTauPi(TauPiInst* inst){return caseDefault(inst);} |
| |
| Inst* caseIncCounter(Inst* inst) {return caseDefault(inst);} |
| |
| Inst* casePrefetch(Inst* inst) {return caseDefault(inst);} |
| |
| // compressed reference stuff |
| Inst* caseUncompressRef(Inst* inst) { |
| Opnd* opnd = simplifyUncompressRef(inst->getSrc(0)); |
| if (opnd != NULL) |
| return opnd->getInst(); |
| return inst; |
| } |
| |
| Inst* caseCompressRef(Inst* inst) { |
| Opnd* opnd = simplifyCompressRef(inst->getSrc(0)); |
| if (opnd != NULL) |
| return opnd->getInst(); |
| return inst; |
| } |
| |
| Inst* caseLdFieldOffset(Inst* inst) {return caseDefault(inst);} |
| |
| Inst* caseLdFieldOffsetPlusHeapbase(Inst* inst) {return caseDefault(inst);} |
| |
| Inst* caseLdArrayBaseOffset(Inst* inst) {return caseDefault(inst);} |
| |
| Inst* caseLdArrayBaseOffsetPlusHeapbase(Inst* inst) {return caseDefault(inst);} |
| |
| Inst* caseLdArrayLenOffset(Inst* inst) {return caseDefault(inst);} |
| |
| Inst* caseLdArrayLenOffsetPlusHeapbase(Inst* inst) {return caseDefault(inst);} |
| |
| Inst* caseAddOffset(Inst* inst) { |
| Opnd* opnd = simplifyAddOffset(inst->getDst()->getType(), |
| inst->getSrc(0), |
| inst->getSrc(1)); |
| if (opnd != NULL) |
| return opnd->getInst(); |
| return inst; |
| } |
| |
| Inst* caseAddOffsetPlusHeapbase(Inst* inst) { |
| Opnd* opnd = simplifyAddOffsetPlusHeapbase(inst->getDst()->getType(), |
| inst->getSrc(0), |
| inst->getSrc(1)); |
| if (opnd != NULL) |
| return opnd->getInst(); |
| return inst; |
| } |
| |
| Inst* caseTauPoint(Inst* inst) { |
| return inst; |
| } |
| |
| Inst* caseTauEdge(Inst* inst) { |
| return inst; |
| } |
| |
| Inst* caseTauAnd(Inst* inst) { |
| Opnd* opnd = simplifyTauAnd(inst->asMultiSrcInst()); |
| if (opnd != NULL) |
| return opnd->getInst(); |
| return inst; |
| } |
| |
| Inst* caseTauUnsafe(Inst* inst) { |
| return inst; |
| } |
| |
| Inst* caseTauSafe(Inst* inst) { |
| return inst; |
| } |
| |
| Inst* caseTauCheckCast(TypeInst* inst) { |
| bool alwaysThrows = false; |
| Opnd* opnd = simplifyTauCheckCast(inst->getSrc(0), |
| inst->getSrc(1), |
| inst->getTypeInfo(), |
| alwaysThrows); |
| if (opnd) { |
| eliminateCheck(inst, alwaysThrows); |
| return opnd->getInst(); |
| } |
| return inst; |
| } |
| |
| Inst* caseTauHasType(TypeInst* inst) { |
| Opnd* opnd = simplifyTauHasType(inst->getSrc(0), |
| inst->getTypeInfo()); |
| if (opnd) |
| return opnd->getInst(); |
| return inst; |
| } |
| |
| Inst* caseTauHasExactType(TypeInst* inst) { |
| Opnd* opnd = simplifyTauHasExactType(inst->getSrc(0), |
| inst->getTypeInfo()); |
| if (opnd) |
| return opnd->getInst(); |
| return inst; |
| } |
| |
| Inst* caseTauIsNonNull(Inst* inst) { |
| Opnd* opnd = simplifyTauIsNonNull(inst->getSrc(0)); |
| if (opnd) |
| return opnd->getInst(); |
| return inst; |
| } |
| |
| Inst* caseIdentHC(Inst* inst) { |
| return caseDefault(inst); |
| } |
| |
| // default |
| Inst* caseDefault(Inst* inst) { |
| return inst; |
| } |
| |
| private: |
| // fold routines always produce a result, except for div by 0, which yields NULL. |
| // currently only applicable to Int32 or Int64 operands |
| Opnd* fold(Opcode op, Type*, ConstInst* srcInst1, ConstInst* srcInst2, bool is_signed); |
| Opnd* fold(Opcode op, Type*, ConstInst* srcInst, bool is_signed); |
| Opnd* foldComparison(ComparisonModifier, |
| Type::Tag cmpType, |
| ConstInst* srcInst1, |
| ConstInst* srcInst2); |
| |
| Opnd* foldConstByAddingToAddWithConstant(Type*, ConstInst*, Inst* addInst); |
| Opnd* foldConstByAddingToSubWithConstant(Type*, ConstInst*, Inst* subInst); |
| Opnd* foldConstMultiplyByAddWithConstant(Type*, ConstInst*, Inst* subInst); |
| Opnd* foldConstMultiplyBySubWithConstant(Type*, ConstInst*, Inst* subInst); |
| Opnd* foldConstMultiplyByMulWithConstant(Type*, ConstInst*, Inst* subInst); |
| Opnd* foldNegOfMultiplyByConstant(Type*, Inst*); |
| |
| // simplifyOp routines produce NULL or a simplified result |
| Opnd* simplifyAddWithNeg(Modifier, Type*, Opnd* src1, Opnd* src2); |
| Opnd* simplifyAddViaReassociation(Type*, Opnd* src1, Opnd* src2); |
| Opnd* simplifySubWithNeg(Modifier, Type*, Opnd* src1, Opnd* src2); |
| Opnd* simplifySubViaReassociation(Type*, Opnd* src1, Opnd* src2); |
| Opnd* simplifyMulViaReassociation(Type*, Opnd* src1, Opnd* src2); |
| Opnd* simplifyMulWithNeg(Type*, Opnd* src1, Opnd* src2); |
| Opnd* simplifyTauDivOfMul(Modifier mod, Type*, Opnd* src1, Opnd* src2, |
| Opnd* tauOpndsChecked); |
| |
| // SimplifyCmp routines have different interface to allow use in |
| // folding Cmps and Branches. Returns true if can simplify, and |
| // writes in ref parameters for new Branch or Cmp instruction. |
| bool simplifyCmpToCmp(Type::Tag, ComparisonModifier, Opnd*, Opnd*, |
| Type::Tag &newInstType, ComparisonModifier &newmod, |
| Opnd* &newSrc1, Opnd* &newSrc2); |
| bool simplifyCmpToCmp(Type::Tag, ComparisonModifier, Opnd*, |
| Type::Tag &newInstType, ComparisonModifier &newmod, |
| Opnd* &newSrc1); |
| // subroutines of simplifyCmpToCmp: |
| // to partition cmp simplification somewhat |
| // check for cmp(x+c1, c2) and the like. |
| bool simplifyCmpOfAddOrSubC(Type::Tag, ComparisonModifier, |
| Opnd*, Opnd*, |
| Type::Tag &newInstType, |
| ComparisonModifier &newmod, |
| Opnd* &newSrc1, Opnd* &newSrc2); |
| bool simplifyCmpOfAddC(Type::Tag, ComparisonModifier, |
| Opnd* addOpnd, Opnd* otherOpnd, |
| Type::Tag &newInstType, |
| ComparisonModifier &newmod, |
| Opnd* &newAddSrc, Opnd* &newOtherSrc, |
| bool swapped); |
| bool simplifyCmpOfSubC(Type::Tag, ComparisonModifier, |
| Opnd* subOpnd, Opnd* otherOpnd, |
| Type::Tag &newInstType, |
| ComparisonModifier &newmod, |
| Opnd* &newSubSrc, Opnd* &newOtherSrc, |
| bool swapped); |
| // check for cmp(cmp(x,y),c) and the like |
| bool simplifyCmpOfCmp(Type::Tag, ComparisonModifier, Opnd*, Opnd*, |
| Type::Tag &newInstType, ComparisonModifier &newmod, |
| Opnd* &newSrc1, Opnd* &newSrc2); |
| // check for cmp(cmp3(x,y),c) and the like |
| bool simplifyCmpOfCmp3(Type::Tag, ComparisonModifier, Opnd*, Opnd*, |
| Type::Tag &newInstType, ComparisonModifier &newmod, |
| Opnd* &newSrc1, Opnd* &newSrc2); |
| // end subroutines of simplifyCmpToCmp |
| |
| // given possible results for the Cmp3, yield the simplified branch |
| // or cmp parameters, returning false if it can't be done. |
| bool simplifyCmp3ByResult(Opnd *cmp3Opnd, |
| bool canbe_1, // can be -1 |
| bool canbe0, |
| bool canbe1, |
| Type::Tag &newInstType, |
| ComparisonModifier &newmod, |
| Opnd* &newSrc1, Opnd* &newSrc2); |
| |
| friend struct OpndDepthCompare; |
| U_32 getDepth(Opnd *src); |
| |
| protected: |
| bool isLate; |
| bool tryReassoc; |
| enum AssocKind { AssocNone, AssocConst, AssocDepth, AssocLoop } assocKind; |
| friend class MulMethod; |
| |
| // re-association machinery |
| friend class Reassociate; |
| Opnd* simplifyAddViaReassociation2(Type* type, Opnd* src1, Opnd* src2); |
| Opnd* simplifyNegViaReassociation2(Type* type, Opnd* src1); |
| Opnd* simplifySubViaReassociation2(Type* type, Opnd* src1, Opnd *src2); |
| Opnd* simplifyMulViaReassociation2(Type* type, Opnd* src1, Opnd* src2); |
| Opnd* simplifyAddOffsetViaReassociation(Opnd* uncompBase, Opnd *offset); |
| Opnd* simplifyAddOffsetPlusHeapbaseViaReassociation(Opnd *compBase, Opnd *offsetPlusHeapbase); |
| Reassociate *theReassociate; |
| }; |
| |
| class SimplifierWithInstFactory : public Simplifier { |
| public: |
| SimplifierWithInstFactory(IRManager&,bool latePass=false, |
| Reassociate *reassociate0=0); |
| virtual Inst* optimizeInst(Inst* inst); |
| U_32 simplifyControlFlowGraph(); |
| protected: |
| void insertInst(Inst* inst); |
| void insertInstInHeader(Inst* inst); |
| |
| virtual Inst* genAdd(Type*, Modifier, Opnd* src1, Opnd* src2); |
| virtual Inst* genSub(Type*, Modifier, Opnd* src1, Opnd* src2); |
| virtual Inst* genNeg(Type*, Opnd* src); |
| virtual Inst* genMul(Type*, Modifier, Opnd* src1, Opnd* src2); |
| virtual Inst* genMulHi(Type*, Modifier, Opnd* src1, Opnd* src2); |
| virtual Inst* genMin(Type*, Opnd* src1, Opnd* src2); |
| virtual Inst* genMax(Type*, Opnd* src1, Opnd* src2); |
| virtual Inst* genAbs(Type*, Opnd* src1); |
| |
| virtual Inst* genAnd(Type*, Opnd* src1, Opnd* src2); |
| virtual Inst* genOr(Type*, Opnd* src1, Opnd* src2); |
| virtual Inst* genXor(Type*, Opnd* src1, Opnd* src2); |
| virtual Inst* genNot(Type*, Opnd* src1); |
| virtual Inst* genSelect(Type*, |
| Opnd* src1, Opnd* src2, Opnd* src3); |
| |
| virtual Inst* genConv(Type*, Type::Tag toType, Modifier, |
| Opnd* src1); |
| virtual Inst* genConvZE(Type*, Type::Tag toType, Modifier, |
| Opnd* src1); |
| virtual Inst* genConvUnmanaged(Type*, Type::Tag toType, Modifier, |
| Opnd* src1); |
| |
| virtual Inst* genShladd(Type*, Opnd *value, |
| Opnd* shiftAmount, Opnd* addTo); |
| virtual Inst* genShl(Type*, Modifier, |
| Opnd* src1, Opnd* src2); |
| virtual Inst* genShr(Type*, Modifier, |
| Opnd* src1, Opnd* src2); |
| |
| virtual Inst* genCmp(Type*, Type::Tag insttype, |
| ComparisonModifier, Opnd* src1, Opnd* src2); |
| virtual void genJump(LabelInst* label); |
| virtual void genBranch(Type::Tag instType, ComparisonModifier mod, |
| LabelInst* label, Opnd* src1, Opnd* src2); |
| virtual void genBranch(Type::Tag instType, ComparisonModifier mod, |
| LabelInst* label, Opnd* src1); |
| virtual Inst* genDirectCall(MethodDesc*, |
| Type* returnType, |
| Opnd* tauNullCheckedFirstArg, |
| Opnd* typesChecked, |
| U_32 numArgs, |
| Opnd* args[]); |
| |
| virtual Inst* genLdConstant(I_32 val); |
| virtual Inst* genLdConstant(int64 val); |
| virtual Inst* genLdConstant(float val); |
| virtual Inst* genLdConstant(double val); |
| virtual Inst* genLdConstant(Type* type, ConstInst::ConstValue val); |
| |
| virtual Inst* genTauLdInd(Modifier mod, Type *dstType, Type::Tag type, Opnd *ptr, |
| Opnd *tauNonNullBase, Opnd *tauAddressInRange); |
| virtual Inst* genLdRef(Modifier mod, Type *dstType, |
| U_32 token, MethodDesc *enclosingMethod); |
| |
| virtual Inst* genLdFunAddrSlot(MethodDesc*); |
| virtual Inst* genGetVTableAddr(ObjectType* type); |
| |
| virtual Inst* genCompressRef(Opnd *uncompref); |
| virtual Inst* genUncompressRef(Opnd *compref); |
| |
| virtual Inst* genLdFieldOffsetPlusHeapbase(FieldDesc*); |
| virtual Inst* genLdArrayBaseOffsetPlusHeapbase(Type *elemType); |
| virtual Inst* genLdArrayLenOffsetPlusHeapbase(Type *elemType); |
| virtual Inst* genAddOffsetPlusHeapbase(Type *ptrType, Opnd *compRef, |
| Opnd *offsetPlusHeapbase); |
| virtual Inst* genTauSafe(); |
| virtual Inst* genTauMethodSafe(); |
| virtual Inst* genTauUnsafe(); |
| virtual Inst* genTauStaticCast(Opnd *src, Opnd *tauNonNull, Type *castType); |
| virtual Inst* genTauHasType(Opnd *src, Type *castType); |
| virtual Inst* genTauHasExactType(Opnd *src, Type *castType); |
| virtual Inst* genTauIsNonNull(Opnd *src); |
| |
| Opnd *simplifyStoreSrc(Opnd *, Type::Tag &typetag, Modifier &mod, |
| bool compressRef); |
| |
| virtual void genThrowSystemException(CompilationInterface::SystemExceptionId); |
| |
| virtual void foldBranch(BranchInst* br, bool isTaken); |
| virtual void foldSwitch(SwitchInst* switchInst, U_32 index); |
| virtual void eliminateCheck(Inst* checkInst, bool alwaysThrows); |
| private: |
| Inst* nextInst; |
| Node* currentCfgNode; |
| InstFactory& instFactory; |
| OpndManager& opndManager; |
| TypeManager& typeManager; |
| Opnd* tauSafeOpnd; |
| Opnd* tauMethodSafeOpnd; |
| Opnd* tauUnsafeOpnd; |
| }; |
| |
| } //namespace Jitrino |
| |
| #endif // _SIMPLIFIER_H_ |
