Google Git
Sign in
apache/harmony/java6/./drlvm/vm/jitrino/src/optimizer/inliner.cpp
blob: c3c43a2eee21118eda1d4954d1c176913199a9bb [file]
/*
* 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 "EMInterface.h"
#include "Log.h"
#include "methodtable.h"
#include "inliner.h"
#include "irmanager.h"
#include "FlowGraph.h"
#include "Inst.h"
#include "Dominator.h"
#include "Loop.h"
#include "simplifier.h"
#include "JavaByteCodeParser.h"
#include "StaticProfiler.h"
#include "optimizer.h"
#include "deadcodeeliminator.h"
#include "VMMagic.h"
namespace Jitrino {
#define MAX_INLINE_GROWTH_FACTOR 170
#define MIN_INLINE_STOP 50
#define MIN_BENEFIT_THRESHOLD 200
#define INLINE_LARGE_THRESHOLD 70
#define MAX_INLINE_GROWTH_FACTOR_PROF 500
#define MIN_INLINE_STOP_PROF 100
// no negative profile benefit for nodes with freq >= 1/10 of entry freq
#define MIN_BENEFIT_THRESHOLD_PROF (MIN_BENEFIT_THRESHOLD / 10)
#define INLINE_LARGE_THRESHOLD_PROF 150
#define CALL_COST 1
#define INLINE_SMALL_THRESHOLD 12
#define INLINE_SMALL_BONUS 300
#define INLINE_MEDIUM_THRESHOLD 50
#define INLINE_MEDIUM_BONUS 200
#define INLINE_LARGE_PENALTY 500
#define INLINE_LOOP_BONUS 200
#define INLINE_LEAF_BONUS 0
#define INLINE_SYNCH_BONUS 50
#define INLINE_RECURSION_PENALTY 300
#define INLINE_EXACT_ARG_BONUS 0
#define INLINE_EXACT_ALL_BONUS 0
#define INLINE_SKIP_EXCEPTION_PATH false
DEFINE_SESSION_ACTION(InlinePass, inline, "Method Inlining");
Inliner::Inliner(SessionAction* argSource, MemoryManager& mm, IRManager& irm,
bool doProfileOnly, bool _usePriorityQueue, const char* inlinePipeline)
: _tmpMM(mm), _toplevelIRM(irm),
_typeManager(irm.getTypeManager()), _instFactory(irm.getInstFactory()),
_opndManager(irm.getOpndManager()),
_hasProfileInfo(irm.getFlowGraph().hasEdgeProfile()),
_inlineCandidates(mm), _initByteSize(irm.getMethodDesc().getByteCodeSize()),
_currentByteSize(irm.getMethodDesc().getByteCodeSize()),
_inlineTree(new (mm) InlineNode(irm, 0, 0)),
translatorAction(NULL),
usePriorityQueue(_usePriorityQueue), inlinerPipelineName(inlinePipeline),
connectEarly(true), isPseudoThrowInserted(false)
{
const char* translatorName = argSource->getStringArg("translatorActionName", "translator");
translatorAction = (TranslatorAction*)PMF::getAction(argSource->getPipeline(), translatorName);
assert(translatorAction);
_doProfileOnlyInlining = doProfileOnly;
_useInliningTranslator = !doProfileOnly;
_maxInlineGrowthFactor = ((double)argSource->getIntArg("growth_factor", doProfileOnly ? MAX_INLINE_GROWTH_FACTOR_PROF : MAX_INLINE_GROWTH_FACTOR)) / 100;
_minInlineStop = argSource->getIntArg("min_stop", doProfileOnly ? MIN_INLINE_STOP_PROF : MIN_INLINE_STOP);
_minBenefitThreshold = argSource->getIntArg("min_benefit_threshold", doProfileOnly ? MIN_BENEFIT_THRESHOLD_PROF : MIN_BENEFIT_THRESHOLD);
_inlineSmallMaxByteSize = argSource->getIntArg("inline_small_method_max_size", INLINE_SMALL_THRESHOLD);
_inlineSmallBonus = argSource->getIntArg("inline_small_method_bonus", INLINE_SMALL_BONUS);
_inlineMediumMaxByteSize = argSource->getIntArg("medium_method_max_size", INLINE_MEDIUM_THRESHOLD);
_inlineMediumBonus = argSource->getIntArg("medium_method_bonus", INLINE_MEDIUM_BONUS);
_inlineLargeMinByteSize = argSource->getIntArg("large_method_min_size", doProfileOnly ? INLINE_LARGE_THRESHOLD_PROF : INLINE_LARGE_THRESHOLD);
_inlineLargePenalty = argSource->getIntArg("large_method_penalty", INLINE_LARGE_PENALTY);
_inlineLoopBonus = argSource->getIntArg("loop_bonus", INLINE_LOOP_BONUS);
_inlineLeafBonus = argSource->getIntArg("leaf_bonus", INLINE_LEAF_BONUS);
_inlineSynchBonus = argSource->getIntArg("synch_bonus", INLINE_SYNCH_BONUS);
_inlineRecursionPenalty = argSource->getIntArg("recursion_penalty", INLINE_RECURSION_PENALTY);
_inlineExactArgBonus = argSource->getIntArg("exact_single_parameter_bonus", INLINE_EXACT_ARG_BONUS);
_inlineExactAllBonus = argSource->getIntArg("exact_all_parameter_bonus", INLINE_EXACT_ALL_BONUS);
_inlineMaxNodeThreshold = irm.getOptimizerFlags().hir_node_threshold * irm.getOptimizerFlags().inline_node_quota / 100;
_inlineSkipExceptionPath = argSource->getBoolArg("skip_exception_path", INLINE_SKIP_EXCEPTION_PATH);
#if defined (_EM64T_) || defined (_IPF_)
_inlineSkipApiMagicMethods = false;
#else
_inlineSkipApiMagicMethods = argSource->getBoolArg("skip_api_magics", true);
#endif
const char* skipMethods = argSource->getStringArg("skip_methods", NULL);
_inlineSkipMethodTable = NULL;
if(skipMethods != NULL || _inlineSkipApiMagicMethods) {
_inlineSkipMethodTable = new (_tmpMM) Method_Table(_tmpMM, skipMethods, "SKIP_METHODS", false);
if (_inlineSkipApiMagicMethods) {
#if defined (_IPF_)
//TODO: IA32 helpers should work on EM64T too -> TODO test
#else
//is_accepted will return 'true' for these methods by skip table-> no inlining will be done
Method_Table::Decision des = Method_Table::mt_accepted;
#ifndef _EM64T_ // not tested
_inlineSkipMethodTable->add_method_record("java/lang/Integer", "numberOfLeadingZeros", "(I)I", des, false);
_inlineSkipMethodTable->add_method_record("java/lang/Integer", "numberOfTrailingZeros", "(I)I", des, false);
_inlineSkipMethodTable->add_method_record("java/lang/Long", "numberOfLeadingZeros", "(J)I", des, false);
_inlineSkipMethodTable->add_method_record("java/lang/Long", "numberOfTrailingZeros", "(J)I", des, false);
_inlineSkipMethodTable->add_method_record("java/lang/Math", "sqrt", "(D)D", des, false);
_inlineSkipMethodTable->add_method_record("java/lang/Math", "sin", "(D)D", des, false);
_inlineSkipMethodTable->add_method_record("java/lang/Math", "cos", "(D)D", des, false);
_inlineSkipMethodTable->add_method_record("java/lang/Math", "abs", "(F)F", des, false);
_inlineSkipMethodTable->add_method_record("java/lang/Math", "abs", "(D)D", des, false);
_inlineSkipMethodTable->add_method_record("java/lang/Math", "tan", "(D)D", des, false);
_inlineSkipMethodTable->add_method_record("java/lang/Math", "atan", "(D)D", des, false);
_inlineSkipMethodTable->add_method_record("java/lang/Math", "atan2", "(DD)D", des, false);
_inlineSkipMethodTable->add_method_record("java/lang/Math", "asin", "(D)D", des, false);
_inlineSkipMethodTable->add_method_record("java/lang/Math", "acos", "(D)D", des, false);
_inlineSkipMethodTable->add_method_record("java/lang/Math", "log", "(D)D", des, false);
_inlineSkipMethodTable->add_method_record("java/lang/Math", "log10", "(D)D", des, false);
_inlineSkipMethodTable->add_method_record("java/lang/Math", "log1p", "(D)D", des, false);
#endif
if(argSource->getBoolArg("System_arraycopy_as_magic",true)) {
_inlineSkipMethodTable->add_method_record("java/lang/System", "arraycopy", "(Ljava/lang/Object;ILjava/lang/Object;II)V", des, false);
}
if(argSource->getBoolArg("String_compareTo_as_magic",true)) {
_inlineSkipMethodTable->add_method_record("java/lang/String", "compareTo", "(Ljava/lang/String;)I", des, false);
}
if(argSource->getBoolArg("String_regionMatches_as_magic",true)) {
_inlineSkipMethodTable->add_method_record("java/lang/String", "regionMatches", "(ILjava/lang/String;II)Z", des, false);
}
if(argSource->getBoolArg("String_indexOf_as_magic",true)) {
_inlineSkipMethodTable->add_method_record("java/lang/String", "indexOf", "(Ljava/lang/String;I)I", des, false);
}
#endif
}
}
const char* bonusMethods = argSource->getStringArg("bonus_methods", NULL);
_inlineBonusMethodTable = NULL;
if(bonusMethods!=NULL) {
_inlineBonusMethodTable = new (_tmpMM) Method_Table(_tmpMM, bonusMethods, "BONUS_METHODS", false);
}
_usesOptimisticBalancedSync = argSource->getBoolArg("sync_optimistic", false) ? argSource->getBoolArg("sync_optcatch", true) : false;
}
I_32
Inliner::computeInlineBenefit(Node* node, MethodDesc& methodDesc, InlineNode* parentInlineNode, U_32 loopDepth)
{
I_32 benefit = 0;
if (Log::isEnabled()) {
Log::out() << "Computing Inline benefit for "
<< methodDesc.getParentType()->getName()
<< "." << methodDesc.getName() << ::std::endl;
}
if (_inlineBonusMethodTable!=NULL && _inlineBonusMethodTable->accept_this_method(methodDesc)) {
benefit+=1000;
if (Log::isEnabled()) {
Log::out() << "Method is in bonus table benefit+=1000"<<std::endl;
}
}
//
// Size impact
//
U_32 size = methodDesc.getByteCodeSize();
Log::out() << " size is " << (int) size << ::std::endl;
if(size < _inlineSmallMaxByteSize) {
// Large bonus for smallest methods
benefit += _inlineSmallBonus;
Log::out() << " isSmall, benefit now = " << benefit << ::std::endl;
} else if(size < _inlineMediumMaxByteSize) {
// Small bonus for somewhat small methods
benefit += _inlineMediumBonus;
Log::out() << " isMedium, benefit now = " << benefit << ::std::endl;
} else if(size > _inlineLargeMinByteSize) {
// Penalty for large methods
benefit -= _inlineLargePenalty * (loopDepth+1);
Log::out() << " isLarge, benefit now = " << benefit << ::std::endl;
}
benefit -= size;
Log::out() << " Subtracting size, benefit now = " << benefit << ::std::endl;
//
// Loop depth impact - add bonus for deep call sites
//
benefit += _inlineLoopBonus*loopDepth;
Log::out() << " Loop Depth is " << (int) loopDepth
<< ", benefit now = " << benefit << ::std::endl;
//
// Synch bonus - may introduce synch removal opportunities
//
if(methodDesc.isSynchronized()){
benefit += _inlineSynchBonus;
Log::out() << " Method is synchronized, benefit now = " << benefit << ::std::endl;
}
//
// Recursion penalty - discourage recursive inlining
//
for(; parentInlineNode != NULL; parentInlineNode = parentInlineNode->getParent()) {
if(&methodDesc == &(parentInlineNode->getIRManager().getMethodDesc())) {
benefit -= _inlineRecursionPenalty;
Log::out() << " Subtracted one recursion level, benefit now = " << benefit << ::std::endl;
}
}
//
// Leaf bonus - try to inline leaf methods
//
if(isLeafMethod(methodDesc)) {
benefit += _inlineLeafBonus;
Log::out() << " Added leaf bonus, benefit now = " << benefit << ::std::endl;
}
//
// Exact argument bonus - may introduce specialization opportunities
//
Inst* last = (Inst*)node->getLastInst();
if(last->getOpcode() == Op_DirectCall) {
MethodCallInst* call = last->asMethodCallInst();
assert(call != NULL);
bool exact = true;
// first 2 opnds are taus; skip them
assert(call->getNumSrcOperands() >= 2);
assert(call->getSrc(0)->getType()->tag == Type::Tau);
assert(call->getSrc(1)->getType()->tag == Type::Tau);
for(U_32 i = 2; i < call->getNumSrcOperands(); ++i) {
Opnd* arg = call->getSrc(i);
assert(arg->getType()->tag != Type::Tau);
if(arg->getInst()->isConst()) {
benefit += _inlineExactArgBonus;
Log::out() << " Src " << (int) i
<< " is const, benefit now = " << benefit << ::std::endl;
} else if(arg->getType()->isObject() && Simplifier::isExactType(arg)) {
benefit += _inlineExactArgBonus;
Log::out() << " Src " << (int) i
<< " is exacttype, benefit now = " << benefit << ::std::endl;
} else {
exact = false;
Log::out() << " Src " << (int) i
<< " is inexact, benefit now = " << benefit << ::std::endl;
}
}
if(call->getNumSrcOperands() > 2 && exact) {
benefit += _inlineExactAllBonus;
Log::out() << " Added allexact bonus, benefit now = " << benefit << ::std::endl;
}
}
//
// Use profile information if available
//
if(_doProfileOnlyInlining && _toplevelIRM.getFlowGraph().hasEdgeProfile()) {
double heatThreshold = _toplevelIRM.getHeatThreshold();
double nodeCount = node->getExecCount();
double scale = nodeCount / heatThreshold;
if(scale > 100)
scale = 100;
// Remove any loop bonus as this is already accounted for in block count
benefit -= _inlineLoopBonus*loopDepth;
// Scale by call site 'hotness'.
benefit = (U_32) ((double) benefit * scale);
Log::out() << " HeatThreshold=" << heatThreshold
<< ", nodeCount=" << nodeCount
<< ", scale=" << scale
<< "; benefit now = " << benefit
<< ::std::endl;
}
return benefit;
}
class JavaByteCodeLeafSearchCallback : public JavaByteCodeParserCallback {
public:
JavaByteCodeLeafSearchCallback() {
leaf = true;
}
void parseInit() {}
// called after parsing ends, but not if an error occurs
void parseDone() {}
// called when an error occurs parsing the byte codes
void parseError() {}
bool isLeaf() const { return leaf; }
protected:
bool leaf;
void offset(U_32 offset) {};
void offset_done(U_32 offset) {};
void nop() {}
void aconst_null() {}
void iconst(I_32) {}
void lconst(int64) {}
void fconst(float) {}
void dconst(double) {}
void bipush(I_8) {}
void sipush(int16) {}
void ldc(U_32) {}
void ldc2(U_32) {}
void iload(uint16 varIndex) {}
void lload(uint16 varIndex) {}
void fload(uint16 varIndex) {}
void dload(uint16 varIndex) {}
void aload(uint16 varIndex) {}
void iaload() {}
void laload() {}
void faload() {}
void daload() {}
void aaload() {}
void baload() {}
void caload() {}
void saload() {}
void istore(uint16 varIndex,U_32 off) {}
void lstore(uint16 varIndex,U_32 off) {}
void fstore(uint16 varIndex,U_32 off) {}
void dstore(uint16 varIndex,U_32 off) {}
void astore(uint16 varIndex,U_32 off) {}
void iastore() {}
void lastore() {}
void fastore() {}
void dastore() {}
void aastore() {}
void bastore() {}
void castore() {}
void sastore() {}
void pop() {}
void pop2() {}
void dup() {}
void dup_x1() {}
void dup_x2() {}
void dup2() {}
void dup2_x1() {}
void dup2_x2() {}
void swap() {}
void iadd() {}
void ladd() {}
void fadd() {}
void dadd() {}
void isub() {}
void lsub() {}
void fsub() {}
void dsub() {}
void imul() {}
void lmul() {}
void fmul() {}
void dmul() {}
void idiv() {}
void ldiv() {}
void fdiv() {}
void ddiv() {}
void irem() {}
void lrem() {}
void frem() {}
void drem() {}
void ineg() {}
void lneg() {}
void fneg() {}
void dneg() {}
void ishl() {}
void lshl() {}
void ishr() {}
void lshr() {}
void iushr() {}
void lushr() {}
void iand() {}
void land() {}
void ior() {}
void lor() {}
void ixor() {}
void lxor() {}
void iinc(uint16 varIndex,I_32 amount) {}
void i2l() {}
void i2f() {}
void i2d() {}
void l2i() {}
void l2f() {}
void l2d() {}
void f2i() {}
void f2l() {}
void f2d() {}
void d2i() {}
void d2l() {}
void d2f() {}
void i2b() {}
void i2c() {}
void i2s() {}
void lcmp() {}
void fcmpl() {}
void fcmpg() {}
void dcmpl() {}
void dcmpg() {}
void ifeq(U_32 targetOffset,U_32 nextOffset) {}
void ifne(U_32 targetOffset,U_32 nextOffset) {}
void iflt(U_32 targetOffset,U_32 nextOffset) {}
void ifge(U_32 targetOffset,U_32 nextOffset) {}
void ifgt(U_32 targetOffset,U_32 nextOffset) {}
void ifle(U_32 targetOffset,U_32 nextOffset) {}
void if_icmpeq(U_32 targetOffset,U_32 nextOffset) {}
void if_icmpne(U_32 targetOffset,U_32 nextOffset) {}
void if_icmplt(U_32 targetOffset,U_32 nextOffset) {}
void if_icmpge(U_32 targetOffset,U_32 nextOffset) {}
void if_icmpgt(U_32 targetOffset,U_32 nextOffset) {}
void if_icmple(U_32 targetOffset,U_32 nextOffset) {}
void if_acmpeq(U_32 targetOffset,U_32 nextOffset) {}
void if_acmpne(U_32 targetOffset,U_32 nextOffset) {}
void goto_(U_32 targetOffset,U_32 nextOffset) {}
void jsr(U_32 offset, U_32 nextOffset) {}
void ret(uint16 varIndex,const U_8* byteCodes) {}
void tableswitch(JavaSwitchTargetsIter*) {}
void lookupswitch(JavaLookupSwitchTargetsIter*) {}
void ireturn(U_32 off) {}
void lreturn(U_32 off) {}
void freturn(U_32 off) {}
void dreturn(U_32 off) {}
void areturn(U_32 off) {}
void return_(U_32 off) {}
void getstatic(U_32 constPoolIndex) {}
void putstatic(U_32 constPoolIndex) {}
void getfield(U_32 constPoolIndex) {}
void putfield(U_32 constPoolIndex) {}
void invokevirtual(U_32 constPoolIndex) { leaf = false; }
void invokespecial(U_32 constPoolIndex) { leaf = false; }
void invokestatic(U_32 constPoolIndex) { leaf = false; }
void invokeinterface(U_32 constPoolIndex,U_32 count) { leaf = false; }
void new_(U_32 constPoolIndex) {}
void newarray(U_8 type) {}
void anewarray(U_32 constPoolIndex) {}
void arraylength() {}
void athrow() {}
void checkcast(U_32 constPoolIndex) {}
int instanceof(const U_8* bcp, U_32 constPoolIndex, U_32 off) {return 3;}
void monitorenter() {}
void monitorexit() {}
void multianewarray(U_32 constPoolIndex,U_8 dimensions) {}
void ifnull(U_32 targetOffset,U_32 nextOffset) {}
void ifnonnull(U_32 targetOffset,U_32 nextOffset) {}
};
bool
Inliner::isLeafMethod(MethodDesc& methodDesc) {
U_32 size = methodDesc.getByteCodeSize();
const U_8* bytecodes = methodDesc.getByteCodes();
ByteCodeParser parser(bytecodes,size);
JavaByteCodeLeafSearchCallback leafTester;
parser.parse(&leafTester);
return leafTester.isLeaf();
}
void
Inliner::reset()
{
_hasProfileInfo = true; // _irm.getFlowGraph().hasEdgeProfile();
_inlineCandidates.clear();
}
bool
Inliner::canInlineFrom(MethodDesc& methodDesc)
{
//
// Test if calls in this method should be inlined
//
bool doInline = !methodDesc.isClassInitializer() && !methodDesc.getParentType()->isLikelyExceptionType();
Log::out() << "Can inline from " << methodDesc.getParentType()->getName() << "." << methodDesc.getName() << " == " << doInline << ::std::endl;
return doInline;
}
bool
Inliner::canInlineInto(MethodDesc& methodDesc)
{
//
// Test if a call to this method should be inlined
//
bool doSkip = (_inlineSkipMethodTable == NULL) ? false : _inlineSkipMethodTable->accept_this_method(methodDesc);
if(doSkip)
Log::out() << "Skipping inlining of " << methodDesc.getParentType()->getName() << "." << methodDesc.getName() << ::std::endl;
bool doInline = !doSkip && !methodDesc.isNative() && !methodDesc.isNoInlining() && !methodDesc.getParentType()->isLikelyExceptionType();
Log::out() << "Can inline this " << methodDesc.getParentType()->getName() << "." << methodDesc.getName() << " == " << doInline << ::std::endl;
return doInline;
}
void
Inliner::connectRegion(InlineNode* inlineNode) {
if(inlineNode == _inlineTree.getRoot())
// This is the top level graph.
return;
IRManager &inlinedIRM = inlineNode->getIRManager();
ControlFlowGraph &inlinedFlowGraph = inlinedIRM.getFlowGraph();
Inst *callInst = inlineNode->getCallInst();
MethodDesc &methodDesc = inlinedIRM.getMethodDesc();
// Mark inlined region
Opnd *obj = 0;
if (methodDesc.isClassInitializer()) {
assert(callInst->getNumSrcOperands() >= 3);
Opnd *obj = callInst->getSrc(2); // this parameter for DirectCall
if (obj && !obj->isNull()) obj = 0;
}
//set up inlinee border markers
{
Node* entry = inlinedFlowGraph.getEntryNode();
//replace MethodEntryInst with simple label -> MethodMarkerInsts will be used to mark inlinee borders
entry->getFirstInst()->unlink();
entry->prependInst(_instFactory.makeLabel());
uint16 callerOffset = inlineNode->getCallInst()->getBCOffset();
assert(callerOffset!=ILLEGAL_BC_MAPPING_VALUE);
Inst* entryMarker = obj ? _instFactory.makeMethodMarker(MethodMarkerInst::Entry, &methodDesc, obj)
: _instFactory.makeMethodMarker(MethodMarkerInst::Entry, &methodDesc);
entryMarker->setBCOffset(callerOffset);
entry->prependInst(entryMarker);
Node* retNode = inlinedFlowGraph.getReturnNode();
if (retNode) {
Inst* exitMarker = obj ? _instFactory.makeMethodMarker(MethodMarkerInst::Exit, &methodDesc, obj)
: _instFactory.makeMethodMarker(MethodMarkerInst::Exit, &methodDesc);
retNode->appendInst(exitMarker);
}
Node* unwindNode = inlinedFlowGraph.getUnwindNode();
if (unwindNode) {
Inst* exitMarker = obj ? _instFactory.makeMethodMarker(MethodMarkerInst::Exit, &methodDesc, obj)
: _instFactory.makeMethodMarker(MethodMarkerInst::Exit, &methodDesc);
unwindNode->appendInst(exitMarker);
}
}
// Fuse callsite arguments with incoming parameters
U_32 numArgs = callInst->getNumSrcOperands() - 2; // omit taus
Opnd *tauNullChecked = callInst->getSrc(0);
Opnd *tauTypesChecked = callInst->getSrc(1);
assert(tauNullChecked->getType()->tag == Type::Tau);
assert(tauTypesChecked->getType()->tag == Type::Tau);
// Mark tauNullChecked def inst as nonremovable
// tauSafe can be here. this is not our case.
Inst* tauNullCheckInst = tauNullChecked->getInst();
if(tauNullCheckInst->getOpcode() == Op_TauCheckNull) {
tauNullCheckInst->setDefArgModifier(NonNullThisArg);
}
Node* entry = inlinedFlowGraph.getEntryNode();
Node* retNode = inlinedFlowGraph.getReturnNode();
Inst* first = (Inst*)entry->getFirstInst();
Inst* inst;
Opnd* thisPtr = 0;
U_32 j;
for(j = 0, inst = first->getNextInst(); j < numArgs && inst != NULL;) {
switch (inst->getOpcode()) {
case Op_DefArg:
{
Opnd* dst = inst->getDst();
Opnd* src = callInst->getSrc(j+2); // omit taus
Inst* copy = NULL;
// todo: make translators isMagicClass and convertMagic2HIRType methods public
// use these methods here
if (dst->getType()->isUnmanagedPtr()==src->getType()->isUnmanagedPtr()) {
copy = _instFactory.makeCopy(dst, src);
} else {
Modifier mod = Modifier(Overflow_None)|Modifier(Exception_Never)|Modifier(Strict_No);
copy = _instFactory.makeConvUnmanaged(mod, dst->getType()->tag, dst, src);
}
copy->insertBefore(inst);
inst->unlink();
inst = copy;
++j;
if (!thisPtr) {
src = thisPtr;
}
}
break;
case Op_TauHasType:
{
// substitute tau parameter for hasType test of parameter
Opnd* src = inst->getSrc(0);
if (tauTypesChecked->getInst()->getOpcode() != Op_TauUnsafe) {
// it's worth substituting the tau
for (U_32 i=0; i<numArgs; ++i) {
if (src == callInst->getSrc(i+2)) {
// it is a parameter
Opnd* dst = inst->getDst();
Inst* copy = _instFactory.makeCopy(dst, tauTypesChecked);
copy->insertBefore(inst);
inst->unlink();
inst = copy;
}
}
}
}
break;
case Op_TauIsNonNull:
{
// substitute tau parameter for isNonNull test of this parameter
Opnd* src = inst->getSrc(0);
if (src == thisPtr) {
Opnd* dst = inst->getDst();
Inst* copy = _instFactory.makeCopy(dst, tauNullChecked);
copy->insertBefore(inst);
inst->unlink();
inst = copy;
}
}
break;
case Op_TauHasExactType:
default:
break;
}
inst = inst->getNextInst();
}
assert(j == numArgs);
//
// Convert returns in inlined region into stvar/ldvar
//
if(retNode != NULL) {
Opnd* dst = callInst->getDst();
VarOpnd* retVar = NULL;
if(!dst->isNull())
retVar = _opndManager.createVarOpnd(dst->getType(), false);
// Iterate return sites
assert(retNode != NULL);
bool isSsa = inlinedIRM.getInSsa();
Opnd** phiArgs = isSsa ? new (_toplevelIRM.getMemoryManager()) Opnd*[retNode->getInDegree()] : NULL;
U_32 phiCount = 0;
const Edges& inEdges = retNode->getInEdges();
Edges::const_iterator eiter;
for(eiter = inEdges.begin(); eiter != inEdges.end(); ++eiter) {
Node* retSite = (*eiter)->getSourceNode();
Inst* ret = (Inst*)retSite->getLastInst();
assert(ret->getOpcode() == Op_Return);
if(retVar != NULL) {
Opnd* tmp = ret->getSrc(0);
assert(tmp != NULL);
if(isSsa) {
SsaVarOpnd* ssaVar = _opndManager.createSsaVarOpnd(retVar);
phiArgs[phiCount++] = ssaVar;
retSite->appendInst(_instFactory.makeStVar(ssaVar, tmp));
} else {
retSite->appendInst(_instFactory.makeStVar(retVar, tmp));
}
}
ret->unlink();
}
if(retVar != NULL) {
// Insert phi and ldVar after call site
Node* joinNode = inlinedFlowGraph.splitReturnNode(_instFactory.makeLabel());
joinNode->setExecCount(retNode->getExecCount());
joinNode->findTargetEdge(retNode)->setEdgeProb(1.0);
if(isSsa) {
SsaVarOpnd* ssaVar = _opndManager.createSsaVarOpnd(retVar);
joinNode->appendInst(_instFactory.makePhi(ssaVar, phiCount, phiArgs));
joinNode->appendInst(_instFactory.makeLdVar(dst, ssaVar));
} else {
joinNode->appendInst(_instFactory.makeLdVar(dst, retVar));
}
// Set return operand.
assert(inlinedIRM.getReturnOpnd() == NULL);
inlinedIRM.setReturnOpnd(dst);
}
}
//
// Insert explicit catch_all/monitor_exit/rethrow at exception exits for a synchronized inlined region
//
if(methodDesc.isSynchronized() && inlinedIRM.getFlowGraph().getUnwindNode()) {
// Add monitor exit to unwind.
Node* unwind = inlinedFlowGraph.getUnwindNode();
uint16 monExitBCMap = 0; //this monexit is not present in bytecode. Need some artificial but valid value.
// Test if an exception exit exists
if(unwind->getInDegree() > 0) {
Node* dispatch = inlinedFlowGraph.createDispatchNode(_instFactory.makeLabel());
// Insert catch all
Opnd* ex = _opndManager.createSsaTmpOpnd(_typeManager.getSystemObjectType());
Inst* catchInst = inlinedIRM.getInstFactory().makeCatchLabel(0, ex->getType());
catchInst->setBCOffset(0);
Node* handler = inlinedFlowGraph.createBlockNode(catchInst);
handler->appendInst(_instFactory.makeCatch(ex));
if(methodDesc.isStatic()) {
// Release class monitor
Inst* monExit = _instFactory.makeTypeMonitorExit(methodDesc.getParentType());
monExit->setBCOffset(monExitBCMap);
handler->appendInst(monExit);
} else {
// Release object monitor
assert(callInst->getNumSrcOperands() > 2);
Opnd* obj = callInst->getSrc(2); // object is arg 2;
const TranslatorFlags& traFlags = translatorAction->getFlags();
if (!traFlags.ignoreSync && !traFlags.syncAsEnterFence) {
if (_usesOptimisticBalancedSync) {
// We may need to insert an optimistically balanced monitorexit.
// Note that we shouldn't have an un-optimistic balanced monitorexit,
// since there is at least one edge to UNWIND; this edge should have
// prevented balancing for a synchronized method, which would have
// a missing monitorexit on the exception path.
Node *aRetNode = retNode;
bool done = false;
int count = 0;
// We should have an optbalmonexit on a return path
while (!done && aRetNode != NULL && !aRetNode->getInEdges().empty()) {
const Edges& retEdges = aRetNode->getInEdges();
if (!retEdges.empty()) {
Edge *anEdgeToReturn = *retEdges.begin();
Node *aMonexitNode = anEdgeToReturn->getSourceNode();
Inst *lastInst = (Inst*)aMonexitNode->getLastInst();
Inst *firstInst = (Inst*)aMonexitNode->getFirstInst();
while (lastInst != firstInst) {
if (lastInst->getOpcode() == Op_OptimisticBalancedMonitorExit) {
Opnd *srcObj = lastInst->getSrc(0);
Opnd *lockAddr = lastInst->getSrc(1);
Opnd *enterDst = lastInst->getSrc(2);
Inst* monExit = _instFactory.makeOptimisticBalancedMonitorExit(srcObj,lockAddr,enterDst);
monExit->setBCOffset(monExitBCMap);
handler->appendInst(monExit);
done = true;
break;
}
lastInst = lastInst->getPrevInst();
}
if (!done) {
// we may have empty nodes or something, so try a predecessor.
assert(count < 10); // try to bound this search
count += 1;
// we have to search further.
aRetNode = aMonexitNode;
assert(aRetNode);
assert(!aRetNode->getInEdges().empty());
}
} else {
assert(0);
}
}
assert(done);
} else {
Opnd* tauSafe = _opndManager.createSsaTmpOpnd(_typeManager.getTauType());
handler->appendInst(_instFactory.makeTauSafe(tauSafe)); // monenter success guarantees non-null
Inst* monExit = _instFactory.makeTauMonitorExit(obj, tauSafe);
monExit->setBCOffset(monExitBCMap);
handler->appendInst(monExit);
}
}
}
// Insert rethrow
Node* rethrow = inlinedFlowGraph.createBlockNode(_instFactory.makeLabel());
Inst* rethrowInst = _instFactory.makeThrow(Throw_NoModifier, ex);
rethrowInst->setBCOffset(monExitBCMap);
rethrow->appendInst(rethrowInst);
// Redirect exception exits to monitor_exit
while (!unwind->getInEdges().empty()) {
Edge* edge = unwind->getInEdges().front();
inlinedFlowGraph.replaceEdgeTarget(edge, dispatch);
}
inlinedFlowGraph.addEdge(dispatch, handler);
inlinedFlowGraph.addEdge(handler, rethrow);
inlinedFlowGraph.addEdge(handler, unwind);
inlinedFlowGraph.addEdge(rethrow, unwind);
}
}
//
// Add type initialization if necessary
//
if ((methodDesc.isStatic() || methodDesc.isInstanceInitializer()) &&
methodDesc.getParentType()->needsInitialization()) {
// initialize type for static methods
Inst* initType = _instFactory.makeInitType(methodDesc.getParentType());
initType->setBCOffset(callInst->getBCOffset());
entry->prependInst(initType); //inittype is placed before methodEntryMarker -> it's a part of caller method in stacktrace
inlinedFlowGraph.splitNodeAtInstruction(initType, true, false, _instFactory.makeLabel());
//here we need to create new unwind node, because old one contains method-exit-marker instruction.
//Init-type is a part of caller method -> it must be out of the range of method marker insts.
Node* oldUnwind = inlinedFlowGraph.getUnwindNode();
Node* newUnwind = inlinedFlowGraph.createDispatchNode(_instFactory.makeLabel());
inlinedFlowGraph.addEdge(entry, newUnwind);
inlinedFlowGraph.addEdge(newUnwind, inlinedFlowGraph.getExitNode());
inlinedFlowGraph.setUnwindNode(newUnwind);
if (oldUnwind!=NULL) {
assert(oldUnwind->getOutDegree() == 1);
inlinedFlowGraph.replaceEdgeTarget(oldUnwind->getExceptionEdge(), newUnwind, true);
}
}
}
void
Inliner::inlineRegion(InlineNode* inlineNode) {
IRManager &inlinedIRM = inlineNode->getIRManager();
DominatorTree* dtree = inlinedIRM.getDominatorTree();
LoopTree* ltree = inlinedIRM.getLoopTree();
ControlFlowGraph &inlinedFlowGraph = inlinedIRM.getFlowGraph();
Node *callNode = inlineNode->getCallNode();
Inst *callInst = inlineNode->getCallInst();
MethodDesc &methodDesc = inlinedIRM.getMethodDesc();
if (Log::isEnabled()) {
Log::out()<<"inlineAndProcessRegion "<< methodDesc.getParentType()->getName() << "."<< methodDesc.getName()<<std::endl;
}
// Scale block counts in the inlined region for this particular call site
if (callNode != NULL) {
scaleBlockCounts(callNode, inlinedIRM);
}
// Update priority queue with calls in this region
processRegion(inlineNode, dtree, ltree);
// If top level flowgraph
if (inlineNode == _inlineTree.getRoot()) {
Log::out() << "inlineNode is root" << ::std::endl;
return;
}
// Splice region into top level flowgraph at call site
assert(callInst->getOpcode() == Op_DirectCall);
Log::out() << "Inlining " << methodDesc.getParentType()->getName()
<< "." << methodDesc.getName() << ::std::endl;
Log::out()
<< "callee = " << methodDesc.getParentType()->getName() << "." << methodDesc.getName()
<< ::std::endl
<< "caller = " << inlinedIRM.getParent()->getMethodDesc().getParentType()->getName() << "."
<< inlinedIRM.getParent()->getMethodDesc().getName()
<< ::std::endl;
//
// Splice the inlined region into the top-level flowgraph
//
IRManager* parent = inlinedIRM.getParent();
assert(parent);
Edge* edgeToInlined = callNode->getUnconditionalEdge();
ControlFlowGraph& parentCFG = parent->getFlowGraph();
parentCFG.spliceFlowGraphInline(edgeToInlined, inlinedFlowGraph);
if (inlinedFlowGraph.getUnwindNode() == NULL) {
// Replace original call with PseudoThrow to keep graph topology.
callNode->appendInst(_instFactory.makePseudoThrow());
isPseudoThrowInserted = true;
} else {
// Inlined graph has exception path -> remove original edge.
Edge* exceptionEdge = callNode->getExceptionEdge();
//exception edge can be NULL because the call inserted instead of the HIR inst is artificial
if (exceptionEdge) {
parentCFG.removeEdge(exceptionEdge);
}
}
callInst->unlink();
}
void Inliner::runTranslatorSession(CompilationContext& inlineCC) {
TranslatorSession* traSession = (TranslatorSession*)translatorAction->createSession(inlineCC.getCompilationLevelMemoryManager());
traSession->setCompilationContext(&inlineCC);
inlineCC.setCurrentSessionAction(traSession);
traSession->run();
inlineCC.setCurrentSessionAction(NULL);
}
InlineNode*
Inliner::getNextRegionToInline(CompilationContext& inlineCC) {
// If in DPGO profiling mode, don't inline if profile information is not available.
if(_doProfileOnlyInlining && !_toplevelIRM.getFlowGraph().hasEdgeProfile()) {
return NULL;
}
Node* callNode = 0;
InlineNode* inlineParentNode = 0;
MethodCallInst* call = 0;
MethodDesc* methodDesc = 0;
U_32 newByteSize = 0;
//
// Search priority queue for next inline candidate
//
bool found = false;
while(!_inlineCandidates.empty() && !found) {
// Find new candidate.
callNode = _inlineCandidates.top().callNode;
inlineParentNode = _inlineCandidates.top().inlineNode;
_inlineCandidates.pop();
call = ((Inst*)callNode->getLastInst())->asMethodCallInst();
assert(call != NULL);
methodDesc = call->getMethodDesc();
// If candidate would cause top level method to exceed size threshold, throw away.
U_32 methodByteSize = methodDesc->getByteCodeSize();
methodByteSize = (methodByteSize <= CALL_COST) ? 1 : methodByteSize-CALL_COST;
newByteSize = _currentByteSize + methodByteSize;
double factor = ((double) newByteSize) / ((double) _initByteSize);
if(newByteSize < _minInlineStop || factor <= _maxInlineGrowthFactor || (methodByteSize < _inlineSmallMaxByteSize)) {
found = true;
} else {
Log::out() << "Skip inlining " << methodDesc->getParentType()->getName() << "." << methodDesc->getName() << ::std::endl;
Log::out() << "methodByteSize="
<< (int)methodByteSize
<< ", newByteSize = " << (int)newByteSize
<< ", factor=" << factor
<< std::endl;
}
}
if(!found) {
// No more candidates. Done with inlining.
assert(_inlineCandidates.empty());
Log::out() << "Done inlining " << std::endl;
return NULL;
}
// Set candidate as current inlined region
Log::out() << "Opt: Inline " << methodDesc->getParentType()->getName() << "." << methodDesc->getName() <<
methodDesc->getSignatureString() << std::endl;
// Generate flowgraph for new region
InlineNode* inlineNode = createInlineNode(inlineCC, call);
assert(inlineNode!=NULL);
inlineParentNode->addChild(inlineNode);
_currentByteSize = newByteSize;
return inlineNode;
}
InlineNode* Inliner::createInlineNode(CompilationContext& inlineCC, MethodCallInst* call) {
MethodDesc *methodDesc = call->getMethodDesc();
IRManager* inlinedIRM = new (_tmpMM) IRManager(_tmpMM, _toplevelIRM, *methodDesc, NULL);
InlineNode *inlineNode = new (_tmpMM) InlineNode(*inlinedIRM, call, call->getNode(), false);
inlineCC.setHIRManager(inlinedIRM);
//prepare type info
U_32 nArgs = call->getNumSrcOperands() - 2;
Type** types = new (_tmpMM)Type*[nArgs];
for (U_32 i = 0; i < nArgs; i++) {
types[i] = call->getSrc(i + 2)->getType();
}
InliningContext* ic = new (_tmpMM) InliningContext(nArgs, types);
inlineCC.setInliningContext(ic);
runTranslatorSession(inlineCC);
return inlineNode;
}
void
Inliner::processDominatorNode(InlineNode *inlineNode, DominatorNode* dnode, LoopTree* ltree) {
if(dnode == NULL)
return;
//
// Process this node for inline candidates
//
Node* node = dnode->getNode();
if(node->isBlockNode()) {
// Search for call site
Inst* last =(Inst*)node->getLastInst();
if(last->getOpcode() == Op_DirectCall) {
// Process call site
MethodCallInst* call = last->asMethodCallInst();
assert(call != NULL);
MethodDesc* methodDesc = call->getMethodDesc();
Log::out() << "Considering inlining instruction I" << (int)call->getId() << ::std::endl;
if (usePriorityQueue && canInlineInto(*methodDesc)) {
U_32 size = methodDesc->getByteCodeSize();
I_32 benefit = computeInlineBenefit(node, *methodDesc, inlineNode, ltree->getLoopDepth(node));
assert(size > 0);
Log::out() << "Inline benefit " << methodDesc->getParentType()->getName() << "." << methodDesc->getName() << " == " << (int) benefit << ::std::endl;
if(0 < size && benefit > _minBenefitThreshold) {
// Inline candidate
Log::out() << "Add to queue" << std::endl;
_inlineCandidates.push(CallSite(benefit, node, inlineNode));
} else {
Log::out() << "Will not inline" << std::endl;
}
}
}
}
//
// Skip exception control flow unless directed
//
if(node->isBlockNode() || !_inlineSkipExceptionPath)
processDominatorNode(inlineNode, dnode->getChild(), ltree);
//
// Process siblings in dominator tree
//
processDominatorNode(inlineNode, dnode->getSiblings(), ltree);
}
void
Inliner::processRegion(InlineNode* inlineNode, DominatorTree* dtree, LoopTree* ltree) {
if(!canInlineFrom(inlineNode->getIRManager().getMethodDesc()))
return;
//
// Process region for inline candidates
//
processDominatorNode(inlineNode, dtree->getDominatorRoot(), ltree);
}
void
Inliner::scaleBlockCounts(Node* callSite, IRManager& inlinedIRM) {
Log::out() << "Scaling block counts for callsite in block "
<< (int) callSite->getId() << ::std::endl;
if(!_toplevelIRM.getFlowGraph().hasEdgeProfile()) {
// No profile information to scale
Log::out() << "No profile information to scale!" << ::std::endl;
return;
}
//
// Compute scale from call site count and inlined method count
//
double callFreq = callSite->getExecCount();
ControlFlowGraph &inlinedRegion = inlinedIRM.getFlowGraph();
double methodFreq = inlinedRegion.getEntryNode()->getExecCount();
double scale = callFreq / ((methodFreq != 0.0) ? methodFreq : 1.0);
Log::out() << "callFreq=" << callFreq
<< ", methodFreq=" << methodFreq
<< ", scale=" << scale << ::std::endl;
//
// Apply scale to each block in inlined region
//
const Nodes& nodes = inlinedRegion.getNodes();
Nodes::const_iterator i;
for(i = nodes.begin(); i != nodes.end(); ++i) {
Node* node = *i;
node->setExecCount(node->getExecCount()*scale);
}
}
double
Inliner::getProfileMethodCount(CompilationInterface& compileIntf, MethodDesc& methodDesc) {
//
// Get the entry count for a given method
//
CompilationContext* cc = compileIntf.getCompilationContext();
if ( cc->hasDynamicProfileToUse() ) {
// Online
double res = cc->getProfilingInterface()->getProfileMethodCount(methodDesc);
return res;
} else {
return 0;
}
}
void
InlineNode::print(::std::ostream& os) {
MethodDesc& _methodDesc = getIRManager().getMethodDesc();
os << _methodDesc.getParentType()->getName() << "." << _methodDesc.getName() << _methodDesc.getSignatureString();
}
void
InlineNode::printTag(::std::ostream& os) {
MethodDesc& _methodDesc = getIRManager().getMethodDesc();
os << "M" << (int) _methodDesc.getId();
}
U_32
InlineTree::computeCheckSum(InlineNode* node) {
if(node == NULL)
return 0;
IRManager& irm = node->getIRManager();
MethodDesc& desc = irm.getMethodDesc();
#ifdef PLATFORM_POSIX
__gnu_cxx::hash<const char*> hash;
#else
stdext::hash_compare<const char*> hash;
#endif
size_t sum = hash(desc.getParentType()->getName());
sum += hash(desc.getName());
sum += computeCheckSum(node->getSiblings());
sum += computeCheckSum(node->getChild());
return (U_32) sum;
}
void Inliner::runInlinerPipeline(CompilationContext& inlineCC, const char* pipeName) {
PMF::HPipeline p = inlineCC.getCurrentJITContext()->getPMF().getPipeline(pipeName);
assert(p!=NULL);
PMF::PipelineIterator pit(p);
while (pit.next()) {
SessionAction* sa = pit.getSessionAction();
sa->setCompilationContext(&inlineCC);
inlineCC.setCurrentSessionAction(sa);
inlineCC.stageId++;
sa->run();
inlineCC.setCurrentSessionAction(0);
assert(!inlineCC.isCompilationFailed() && !inlineCC.isCompilationFinished());
}
}
typedef StlVector<MethodCallInst*> InlineVector;
void Inliner::runInliner(MethodCallInst* call) {
CompilationContext* topCC = _toplevelIRM.getCompilationContext();
CompilationInterface* ci = topCC->getVMCompilationInterface();
InlineNode* rootRegionNode = (InlineNode*) getInlineTree().getRoot();
bool first = true;
do {
InlineNode* regionNode = NULL;
{
CompilationContext inlineCC(topCC->getCompilationLevelMemoryManager(), ci, topCC->getCurrentJITContext());
inlineCC.setPipeline(topCC->getPipeline());//workaround for logging issue. Pipeline must not be NULL
if (first) {
if (call == NULL) { //if method is null -> check all calls in top level method
regionNode = rootRegionNode;
} else {
regionNode = createInlineNode(inlineCC, call); //if method is not null -> inline it first
rootRegionNode->addChild(regionNode);
}
first = false;
} else {
regionNode = getNextRegionToInline(inlineCC);
}
if (regionNode == NULL) {
break;
}
compileAndConnectRegion(regionNode, inlineCC);
}
//inline current region
inlineRegion(regionNode);
// Limit inlining by node count.
if (_toplevelIRM.getFlowGraph().getNodeCount() > _inlineMaxNodeThreshold) {
break;
}
} while (true);
// Clean up phase.
if (_toplevelIRM.getInSsa()) {
DeadCodeEliminator dce(_toplevelIRM);
dce.eliminateUnreachableCode();
assert(_toplevelIRM.getInSsa());
OptPass::fixupSsa(_toplevelIRM);
if (isPseudoThrowInserted && _toplevelIRM.getOptimizerFlags().rept_aggressive) {
dce.removeExtraPseudoThrow();
}
}
}
void Inliner::compileAndConnectRegion(InlineNode* inlineNode, CompilationContext& inlineCC) {
MethodCallInst* call = inlineNode->getCallInst()!=NULL ? inlineNode->getCallInst()->asMethodCallInst() : NULL;
if (call!=NULL) { // processing custom call in a method
IRManager &regionManager = inlineNode->getIRManager();
assert(inlineCC.getHIRManager() == &regionManager);
// Connect region arguments to top-level flowgraph
if(connectEarly) {
connectRegion(inlineNode);
}
// Optimize inlined region before splicing
if (inlinerPipelineName!=NULL) {
CompilationContext* topCC = regionManager.getCompilationContext();
inlineCC.stageId = topCC->stageId;
Inliner::runInlinerPipeline(inlineCC, inlinerPipelineName);
topCC->stageId = inlineCC.stageId;
}
// Splice into flow graph and find next region.
if(!connectEarly) {
connectRegion(inlineNode);
}
OptPass::computeDominatorsAndLoops(regionManager);
}
}
void Inliner::processInlinePragmas(IRManager& irm) {
// VMMagic package should be loaded & resolved at start up.
NamedType* inlinePragma = irm.getCompilationInterface().findClassUsingBootstrapClassloader(PRAGMA_INLINE_TYPE_NAME);
if (inlinePragma == NULL) {
if (Log::isEnabled()) {
Log::out()<<"@Inline is not resolved. Skipping @Inline check."<<std::endl;
}
return; //pragma inline is not resolved -> nothing to check
}
MemoryManager tmpMM("processInlinePragmas");
Inliner inliner(irm.getCompilationContext()->getCurrentSessionAction(), tmpMM, irm, false, false, NULL);
StlVector<MethodCallInst*> callsToInline(tmpMM);
//find all methods with @Inline
const Nodes& nodes = irm.getFlowGraph().getNodes();
for (Nodes::const_iterator it = nodes.begin(), end = nodes.end(); it!=end; ++it) {
Node* node = *it;
for (Inst* inst = (Inst*)node->getFirstInst(); inst!=NULL; inst = inst->getNextInst()) {
if (!inst->isMethodCall()) {
continue;
}
MethodCallInst* mci = inst->asMethodCallInst();
MethodDesc* md = mci->getMethodDesc();
if (md != NULL && md->hasAnnotation(inlinePragma)) {
callsToInline.push_back(mci);
if (Log::isEnabled()) {
Log::out()<<"found @Inline :";mci->print(Log::out()); Log::out()<<std::endl;
}
}
}
}
//now inline all all @Inline methods found
for(StlVector<MethodCallInst*>::const_iterator it = callsToInline.begin(), end = callsToInline.end(); it!=end; ++it) {
MethodCallInst* call = *it;
inliner.runInliner(call);
}
}
void InlinePass::_run(IRManager& irm) {
computeDominatorsAndLoops(irm);
// Set up Inliner
bool connectEarly = getBoolArg("connect_early", true);
const char* pipeName = getStringArg("pipeline", "inliner_pipeline");
MemoryManager tmpMM("Inliner::tmp_mm");
Inliner inliner(this, tmpMM, irm, irm.getFlowGraph().hasEdgeProfile(), true, pipeName);
inliner.setConnectEarly(connectEarly);
inliner.runInliner(NULL); //call is unspecified -> check all calls using priority queue
const OptimizerFlags& optimizerFlags = irm.getOptimizerFlags();
// Print the results to logging / dot file
if(optimizerFlags.dumpdot) {
inliner.getInlineTree().printDotFile(irm.getMethodDesc(), "inlinetree");
}
if(Log::isEnabled()) {
Log::out()<<std::endl;
Log::out() << indent(irm) << "Opt: Inline Tree" << std::endl;
inliner.getInlineTree().printIndentedTree(Log::out(), " ");
}
Log::out() << "Inline Checksum == " << (int) inliner.getInlineTree().computeCheckSum() << ::std::endl;
}
} //namespace Jitrino