| /* |
| * 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 _IRMANAGER_H_ |
| #define _IRMANAGER_H_ |
| |
| #include "JavaTranslator.h" |
| #include "CompilationContext.h" |
| #include "MemoryManager.h" |
| #include "Opnd.h" |
| #include "Inst.h" |
| #include "VMInterface.h" |
| #include "JITInstanceContext.h" |
| #include "ControlFlowGraph.h" |
| #include "optimizer.h" |
| #include "PMFAction.h" |
| |
| namespace Jitrino { |
| |
| class MethodDesc; |
| class TypeManager; |
| class ProfilingInterface; |
| class LoopTree; |
| typedef StlHashMap<VarOpnd*, VarOpnd*> GCBasePointerMap; |
| |
| class IRManager { |
| public: |
| // Top-level IRManager |
| IRManager(MemoryManager& mm, CompilationInterface& compilationInterface, OptimizerFlags& optFlags) |
| : _parent(0), |
| _memoryManagerBase(mm), |
| _memoryManager(mm), |
| _opndManager(*(new (_memoryManager) OpndManager(compilationInterface.getTypeManager(),_memoryManager))), |
| _instFactory(*(new (_memoryManager) InstFactory(_memoryManager, |
| *compilationInterface.getMethodToCompile()))), |
| _flowGraph(*(new (_memoryManager) ControlFlowGraph(_memoryManager))), |
| _inlinedReturnOpnd(0), |
| _inlineOptPath(NULL), |
| _gcBasePointerMap(*(new (_memoryManager) GCBasePointerMap(_memoryManager))), |
| _inSsa(false), |
| _lastSsaFixupTraversalNum(0), |
| _lastCriticalEdgeSplitTraversalNum(0), |
| _minRegionInstId(_instFactory.getNumInsts()), |
| _heatThreshold(0), |
| _abort(false), |
| _compilationInterface(compilationInterface), |
| _typeManager(compilationInterface.getTypeManager()), |
| _methodDesc(*compilationInterface.getMethodToCompile()), |
| _jsrEntryMap(NULL), |
| _optFlags(optFlags) |
| { |
| } |
| |
| // Nested IRManager for inlined region. |
| IRManager(MemoryManager& tmpMM, IRManager& containingIRManager, MethodDesc& regionMethodDesc, Opnd *returnOpnd) |
| : _parent(&containingIRManager), |
| _memoryManagerBase(tmpMM), |
| _memoryManager(containingIRManager.getMemoryManager()), |
| _opndManager(containingIRManager.getOpndManager()), |
| _instFactory(containingIRManager.getInstFactory()), |
| _flowGraph(*(new (_memoryManagerBase) ControlFlowGraph(_memoryManager))), |
| _inlinedReturnOpnd(returnOpnd), |
| _inlineOptPath(_parent->getInlineOptPath()), |
| _gcBasePointerMap(_memoryManagerBase), |
| _inSsa(false), |
| _lastSsaFixupTraversalNum(0), |
| _lastCriticalEdgeSplitTraversalNum(0), |
| _minRegionInstId(_instFactory.getNumInsts()), |
| _heatThreshold(containingIRManager.getHeatThreshold()), |
| _abort(_parent->getAbort()), |
| _compilationInterface(containingIRManager.getCompilationInterface()), |
| _typeManager(_compilationInterface.getTypeManager()), |
| _methodDesc(regionMethodDesc), |
| _jsrEntryMap(NULL), |
| _optFlags(containingIRManager._optFlags) |
| { |
| } |
| |
| // The compilation interface to the VM |
| CompilationInterface& getCompilationInterface() {return _compilationInterface;} |
| |
| |
| // The memory manager for the top-level HIR |
| MemoryManager& getMemoryManager() {return _memoryManager; } |
| |
| // The memory manager for this region - if an inlined region, this is |
| // deallocated after splicing into top-level HIR |
| MemoryManager& getNestedMemoryManager() { return _memoryManagerBase; } |
| |
| // The method for this region |
| MethodDesc& getMethodDesc() {return _methodDesc;} |
| |
| // The type manager for the top-level method |
| TypeManager& getTypeManager() {return _typeManager;} |
| |
| // The operand manager for the top-level method |
| OpndManager& getOpndManager() {return _opndManager;} |
| |
| // The instruction factory for the top-level method |
| InstFactory& getInstFactory() {return _instFactory;} |
| |
| // The flowgraph for this region |
| ControlFlowGraph& getFlowGraph() {return _flowGraph;} |
| |
| // The dominator tree for this region - may be NULL or invalid |
| DominatorTree* getDominatorTree() {return getFlowGraph().getDominatorTree();} |
| void setDominatorTree(DominatorTree* tree) { getFlowGraph().setDominatorTree(tree); } |
| |
| // The loop tree for this region - may be NULL or invalid |
| LoopTree* getLoopTree() {return getFlowGraph().getLoopTree();} |
| void setLoopTree(LoopTree* tree) { getFlowGraph().setLoopTree(tree);} |
| |
| // The return operand for this region |
| Opnd* getReturnOpnd() { return _inlinedReturnOpnd; } |
| void setReturnOpnd(Opnd* newReturnOpnd) { _inlinedReturnOpnd = newReturnOpnd; } |
| |
| // The optimization path inlined regions |
| const char* getInlineOptPath() { return _inlineOptPath; } |
| void setInlineOptPath(const char* path) { /*assert(_parent == NULL); */ _inlineOptPath = path; } |
| |
| // The GCMap for region - must be set by GC Managed Pointer Analysis |
| GCBasePointerMap& getGCBasePointerMap() {return _gcBasePointerMap;} |
| |
| // The SSA state of the region |
| bool getInSsa() {return _inSsa;} |
| void setInSsa(bool inSsa){_inSsa = inSsa;} |
| |
| // Is the SSA up-to-date - i.e. have phis been updated after edge removal |
| bool isSsaUpdated() {return getInSsa() && (_lastSsaFixupTraversalNum == _flowGraph.getEdgeRemovalTraversalNum());} |
| void setSsaUpdated() {_lastSsaFixupTraversalNum = _flowGraph.getEdgeRemovalTraversalNum();} |
| |
| // Are critical edges split? This be explicitly updated by the optimizer. |
| bool areCriticalEdgesSplit() {return _lastCriticalEdgeSplitTraversalNum == _flowGraph.getModificationTraversalNum();} |
| void setCriticalEdgesSplit() {_lastCriticalEdgeSplitTraversalNum = _flowGraph.getModificationTraversalNum();} |
| |
| // The minimum Instruction Id in this region. |
| U_32 getMinimumInstId() { return _minRegionInstId; } |
| |
| // The DPGO threshold for hotness - blocks with a execution count |
| // greater than this threshold should be considered hot |
| double getHeatThreshold() {return _heatThreshold;} |
| void setHeatThreshold(double heatThreshold) {_heatThreshold = heatThreshold;} |
| |
| // Set if this compile should be aborted |
| bool getAbort() {return _abort;} |
| void setAbort() {_abort = true; if(_parent != NULL) _parent->setAbort();} |
| |
| // used for jsr-ret inlining, produced by translator |
| void setJsrEntryMap(JsrEntryInstToRetInstMap* mp) { _jsrEntryMap = mp; } |
| JsrEntryInstToRetInstMap* getJsrEntryMap() { return _jsrEntryMap; } |
| |
| // The parent IRManager - NULL if this is the top-level IRManager |
| IRManager* getParent() { return _parent; } |
| |
| // The HIR typechecker main entry point |
| enum OptimizerPhase { OP_FrontEnd, OP_Optimizer }; |
| |
| CompilationContext* getCompilationContext() {return getCompilationInterface().getCompilationContext();} |
| JITInstanceContext* getCurrentJITContext() {return getCompilationContext()->getCurrentJITContext();} |
| ProfilingInterface* getProfilingInterface() {return getCurrentJITContext()->getProfilingInterface();} |
| const OptimizerFlags& getOptimizerFlags() const {return _optFlags;} |
| |
| private: |
| IRManager* _parent; |
| MemoryManager& _memoryManagerBase; |
| MemoryManager& _memoryManager; |
| OpndManager& _opndManager; |
| InstFactory& _instFactory; |
| ControlFlowGraph& _flowGraph; |
| DominatorTree* _dominatorTree; |
| LoopTree* _loopTree; |
| Opnd* _inlinedReturnOpnd; |
| const char* _inlineOptPath; |
| GCBasePointerMap _gcBasePointerMap; |
| bool _inSsa; |
| U_32 _lastSsaFixupTraversalNum; |
| U_32 _lastCriticalEdgeSplitTraversalNum; |
| U_32 _minRegionInstId; |
| double _heatThreshold; |
| bool _abort; |
| |
| CompilationInterface& _compilationInterface; |
| TypeManager& _typeManager; |
| MethodDesc& _methodDesc; |
| JsrEntryInstToRetInstMap* _jsrEntryMap; |
| OptimizerFlags& _optFlags; |
| }; |
| |
| } //namespace Jitrino |
| |
| #endif |