Google Git
Sign in
apache / harmony-drlvm / 5f88006f0f0d0333d92de8857cbb9a9e9a486afe / . / vm / jitrino / src / optimizer / escanalyzer.cpp
blob: 7e1e14f9ec7f1107eedc19763398ae5cdd81e3b3 [file] [log] [blame]
/*
* 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, Natalya V. Golovleva
*
*/
#include "escanalyzer.h"
#include "FlowGraph.h"
#include "Inst.h"
#include "Stl.h"
#include "BitSet.h"
#include "Dominator.h"
#include "Loop.h"
#include "Log.h"
#include "Type.h"
#include "ssa/SSA.h"
#include "optpass.h"
#include "devirtualizer.h"
#include "VMInterface.h"
namespace Jitrino {
const char* help =
" escape flags:\n"
" escape.max_level[=0] - max level callee method analysis\n"
" escape.do_sync_removal[={ON,off}] - do synchronization removal optimization\n"
" escape.do_sync_removal_vc[={ON,off}] - do synchronization removal optimization\n"
" for virtual call escaped operands\n"
" escape.do_sync_removal_sm[={ON,off}] - do synchronization removal optimization\n"
" for synchronized methods\n"
" escape.do_scalar_repl[={ON,off}] - do scalar replacement optimization for\n"
" local and escaped objects\n"
" escape.do_esc_scalar_repl[={ON,off}] - scalar replacement for escaped objects\n"
" escape.do_scalar_repl_only_final_fields_in_use[={on,OFF}] \n"
" escape.do_scalar_repl_final_fields[={on,OFF}] \n"
" - scalarize final field usage when\n"
" escaped object wasn't optimized\n"
" escape.exec_count_mult[=0] - entry node execCount multiplier\n";
DEFINE_SESSION_ACTION(EscapeAnalysisPass, escape, "Escape Analysis")
struct ComObjStat {
ComObjStat() :_n0(0), _n_ge(0), _n_ae(0), _n_ne(0), _n_lo(0) {};
U_32 _n0;
U_32 _n_ge;
U_32 _n_ae;
U_32 _n_ne;
U_32 _n_lo;
};
static ComObjStat comObjStat;
EscAnalyzer::CalleeMethodInfos* EscAnalyzer::calleeMethodInfos=NULL;
Mutex EscAnalyzer::calleeMethodInfosLock;
static void logMethod(MethodPtrType* mpt);
static void logMethod(MethodDesc* md);
static bool isVMHelperCall(Inst* inst, VM_RT_SUPPORT id);
void
EscapeAnalysisPass::_run(IRManager& irm) {
MemoryManager escMemManager("EscapeAnalyzer:tmp_mm");
EscAnalyzer ea(escMemManager, this, irm);
if (Log::isEnabled() && (ea.allProps!=0)) {
Log::out() << "E s c a p e A n a l y s i s " << std::endl;
}
ea.doAnalysis();
irm.getFlowGraph().purgeUnreachableNodes(); //needed to get valid log after this pass
} // run(IRManager& irm)
EscAnalyzer::EscAnalyzer(MemoryManager& mm, SessionAction* argSource, IRManager& irm)
: eaMemManager(mm), irManager(irm), mh(irm.getMethodDesc()),
compInterface(irm.getCompilationInterface()),os_sc(Log::out())
{
maxMethodExamLevel = (U_32)argSource->getIntArg("max_level",maxMethodExamLevel_default);
allProps = (U_32)argSource->getIntArg("d_prop",0);
debug_method = argSource->getStringArg("d_method", NULL);
method_ea_level = 0; // determines level of method scan
do_sync_removal = argSource->getBoolArg("do_sync_removal",true);
do_sync_removal_vc = argSource->getBoolArg("do_sync_removal_vc",true);
do_sync_removal_sm = argSource->getBoolArg("do_sync_removal_sm",true);
do_scalar_repl = argSource->getBoolArg("do_scalar_repl",true);
do_esc_scalar_repl = argSource->getBoolArg("do_esc_scalar_repl",true);
execCountMultiplier_string = argSource->getStringArg("exec_count_mult", NULL);
ec_mult = ( execCountMultiplier_string==NULL ? 0 : atof(execCountMultiplier_string) );
do_scalar_repl_only_final_fields_in_use = argSource->getBoolArg("do_scalar_repl_only_final_fields_in_use",false);
do_scalar_repl_final_fields = argSource->getBoolArg("do_scalar_repl_final_fields",false);
compressedReferencesArg = argSource->getBoolArg("compressedReferences", false);
const char* translatorName = argSource->getStringArg("translatorActionName", "translator");
translatorAction = (TranslatorAction*)PMF::getAction(argSource->getPipeline(), translatorName);
assert(translatorAction);
shortLog = argSource->log(LogStream::CT).isEnabled();
verboseLog = shortLog && argSource->isLogEnabled("escape_verbose");
init();
}
EscAnalyzer::EscAnalyzer(EscAnalyzer* parent, IRManager& irm)
: eaMemManager(parent->eaMemManager), irManager(irm), mh(irm.getMethodDesc()),
compInterface(irm.getCompilationInterface()), os_sc(Log::out())
{
maxMethodExamLevel = parent->maxMethodExamLevel;
allProps = parent->allProps;
debug_method = parent->debug_method;
translatorAction = parent->translatorAction;
method_ea_level = parent->method_ea_level + 1;
shortLog = parent->shortLog;
verboseLog = parent->verboseLog;
init();
}
void EscAnalyzer::init() {
i32_0 = NULL;
i32_1 = NULL;
initNodeType = 0; // type of initial scanned node
scannedObjs = new (eaMemManager) ObjIds(eaMemManager);
scannedObjsRev = new (eaMemManager) ObjIds(eaMemManager);
scannedInsts = new (eaMemManager) ObjIds(eaMemManager);
scannedSucNodes = new (eaMemManager) ObjIds(eaMemManager);
monitorInstUnits = new (eaMemManager) MonInstUnits(eaMemManager);
exam2Insts = new (eaMemManager) Insts(eaMemManager);
methodEndInsts = new (eaMemManager) Insts(eaMemManager);
checkInsts = new (eaMemManager) Insts(eaMemManager);
}
void
EscAnalyzer::showFlags(std::ostream& os) {
os << " escape flags:"<<std::endl;
os << " escape.max_level[=0] - max level callee method analysis" << std::endl;
os << " escape.do_sync_removal[={ON,off}] - do synchronization removal optimization" << std::endl;
os << " escape.do_sync_removal_vc[={ON,off}] - do synchronization removal optimization" << std::endl;
os << " for virtual call escaped operands" << std::endl;
os << " escape.do_sync_removal_sm[={ON,off}] - do synchronization removal optimization" << std::endl;
os << " for synchronized methods" << std::endl;
os << " escape.do_scalar_repl[={ON,off}] - do scalar replacement optimization for" << std::endl;
os << " local and escaped objects" << std::endl;
os << " escape.do_esc_scalar_repl[={ON,off}] - scalar replacement for escaped objects" << std::endl;
os << " escape.do_scalar_repl_only_final_fields_in_use[={on,OFF}] " << std::endl;
os << " escape.do_scalar_repl_final_fields[={on,OFF}] " << std::endl;
os << " - scalarize final field usage when" << std::endl;
os << " escaped object wasn't optimized" << std::endl;
os << " escape.exec_count_mult[=0] - entry node execCount multiplier" << std::endl;
}
void
EscAnalyzer::doAnalysis() {
const char* mn = mh.getName();
const Nodes& nodes = irManager.getFlowGraph().getNodes();
ControlFlowGraph& fg = irManager.getFlowGraph();
U_32 nodeNum = (U_32)nodes.size();
U_32 num2 = fg.getNodeCount();
U_32 num3 = fg.getMaxNodeId();
Nodes::const_iterator niter;
lastCnGNodeId = 0; // initialization of private field
defArgNumber = -1; // initialization of private field
if (verboseLog) {
Log::out()<<"====== doAnalysis ====== "<<mn<<" level: ";
Log::out()<<method_ea_level<<" ";
if (mh.isSynchronized())
Log::out()<<"sync ";
if (mh.isStatic())
Log::out()<<"stat ";
Log::out()<<nodeNum<<" "<<num2<<" "<<num3<< " ";
mh.printFullName(Log::out());
Log::out()<< std::endl;
}
int maxInd = 0;
int cur = -1;
Node* node;
cngNodes=new (eaMemManager) CnGNodes(eaMemManager); // Common part of connection graph (nodes)
for(niter = nodes.begin(); niter != nodes.end(); ++niter) {
node = *niter;
cur = maxInd++;
// exam instructions
if (verboseLog) {
Log::out() <<std::endl;
Log::out() <<"Scan "<< cur <<" Node ";
FlowGraph::printLabel(Log::out(),node);
Log::out() <<" Id. "<<node->getId() <<std::endl;
}
instrExam(node);
};
if (verboseLog) {
Log::out() <<"printCnGNodes: ";
mh.printFullName(Log::out());
Log::out() << std::endl;
printCnGNodes("First run result: nodes",Log::out());
}
cngEdges=new (eaMemManager) CnGEdges(eaMemManager); // Common part of connection graph (edges)
instrExam2();
if (verboseLog) {
Log::out() <<"printCnGEdges: ";
mh.printFullName(Log::out());
Log::out() << std::endl;
printCnGEdges("resulting OUT CnGEdges",Log::out());
}
setCreatedObjectStates();
if (verboseLog) {
printCreatedObjectsInfo(Log::out());
}
saveScannedMethodInfo(); // to save states of contained obj, if needed
if (verboseLog) {
Log::out() << "++++++++++++++ printRefInfo() ";
mh.printFullName(Log::out());
Log::out() << std::endl;
printRefInfo(Log::out());
Log::out() << "++++++++++++++ end ";
mh.printFullName(Log::out());
Log::out() << std::endl;
}
if (verboseLog) {
Log::out() <<"printCnGNodes: ";
mh.printFullName(Log::out());
Log::out() << std::endl;
printCnGNodes("Marked nodes",Log::out());
}
if (method_ea_level == 0) {
createdObjectInfo(); // prints if verboseLog
}
if (method_ea_level == 0) {
if (do_sync_removal) {
scanSyncInsts();
}
if (do_scalar_repl) {
scanLocalObjects();
eaFixupVars(irManager);
if (do_esc_scalar_repl) {
scanEscapedObjects();
eaFixupVars(irManager);
}
}
if (verboseLog && Log::isEnabled()) {
printCreatedObjectsInfo(Log::out());
}
}
if (verboseLog) {
Log::out()<<"====== doAnalysis ====== "<<mn<<" level: ";
Log::out()<<method_ea_level<<" end ";
if (mh.isSynchronized())
Log::out()<<"sync ";
if (mh.isStatic())
Log::out()<<"stat ";
mh.printFullName(Log::out());
Log::out()<< std::endl;
}
return;
} // doAnalysis()
void
EscAnalyzer::instrExam(Node* node) {
TypeManager& typeManager = irManager.getTypeManager();
int insnum = 0;
if (shortLog) {
Log::out() <<"instrExam: Checking node: "; FlowGraph::printLabel(Log::out(), node);
Log::out()<<" dfNum="<<node->getDfNum()<<std::endl;
}
for (Inst* inst=(Inst*)node->getSecondInst();inst!=NULL;inst=inst->getNextInst()) {
insnum++;
Type* type = NULL;
CnGNode* cgnode = NULL;
U_32 ntype=0;
MethodPtrType* methType = NULL;
U_32 n = 0;
bool addinst = false;
Inst* method_inst = NULL;
if (shortLog) {
Log::out() <<"Checking inst:"; debug_inst_info(inst,Log::out());
}
switch (inst->getOpcode()) {
case Op_NewObj: // newobj
case Op_NewArray: // newarray
case Op_NewMultiArray: // newmultiarray
ntype=NT_OBJECT; // for 3 cases above
case Op_LdRef: // ldref
case Op_LdConstant: // ldc
case Op_GetClassObj: // getclassobj
if (ntype==0)
ntype=NT_LDOBJ; // loads refs
case Op_DefArg: // defarg
if (ntype==0) {
ntype=NT_DEFARG; // for Op_DefArg
defArgNumber++;
}
if (inst->getDst()->getType()->isObject()) {
type=inst->getDst()->getType();
assert(findCnGNode_op(inst->getDst()->getId())==NULL);
cgnode = addCnGNode_op(inst,type,ntype);
}
break;
case Op_Conv: // conv
case Op_ConvUnmanaged:
if (inst->getDst()->getType()->isObject()) {
type=inst->getDst()->getType();
assert(findCnGNode_op(inst->getDst()->getId())==NULL);
cgnode = addCnGNode_op(inst,type,NT_OBJECT);
}
break;
case Op_AddOffset: // used to get non-static field addr in lazy resolution mode.
case Op_LdFieldAddr: // ldflda
case Op_LdStaticAddr: // ldsflda
instrExam_processLdFieldAddr(inst);
break;
case Op_TauLdInd: // ldind
{
Opnd* src = inst->getSrc(0);
if(src->getType()->isUnmanagedPtr())
break; // skip load from unmanaged source
type = inst->getDst()->getType();
if (type->isReference()) { //isObject()) {
assert(findCnGNode_op(inst->getDst()->getId())==NULL);
cgnode = addCnGNode_op(inst,type,NT_LDOBJ);
exam2Insts->push_back(inst);
}
if (src->getInst()->getOpcode()==Op_LdStaticAddr)
break;
if (type->isValue()) {
assert(findCnGNode_op(inst->getDst()->getId())==NULL);
cgnode = addCnGNode_op(inst,type,NT_LDVAL);
exam2Insts->push_back(inst);
}
}
break;
case Op_LdArrayBaseAddr: // ldbase
case Op_AddScaledIndex: // addindex
if (inst->getDst()->getType()->isReference()) {
type=inst->getDst()->getType();
assert(findCnGNode_op(inst->getDst()->getId())==NULL);
cgnode = addCnGNode_op(inst,type,NT_ARRELEM);
exam2Insts->push_back(inst);
}
break;
case Op_VMHelperCall: // callvmhelper
{
VM_RT_SUPPORT callId = inst->asVMHelperCallInst()->getVMHelperId();
switch(callId) {
case VM_RT_GET_STATIC_FIELD_ADDR_WITHRESOLVE:
instrExam_processLdFieldAddr(inst);
break;
case VM_RT_CHECKCAST_WITHRESOLVE:
assert(findCnGNode_op(inst->getDst()->getId())==NULL);
addCnGNode_op(inst,inst->getDst()->getType(), NT_REF);
exam2Insts->push_back(inst);
break;
case VM_RT_NEWOBJ_WITHRESOLVE:
case VM_RT_NEWARRAY_WITHRESOLVE:
case VM_RT_MULTIANEWARRAY_RESOLVED:
assert(findCnGNode_op(inst->getDst()->getId())==NULL);
addCnGNode_op(inst,inst->getDst()->getType(), NT_OBJECT);
break;
default:
break;
}
}
break;
case Op_JitHelperCall: // calljithelper
if (method_ea_level == 0) {
switch(inst->asJitHelperCallInst()->getJitHelperId()) {
case Prefetch:
case Memset0:
case InitializeArray:
case FillArrayWithConst:
case SaveThisState:
case ReadThisState:
case LockedCompareAndExchange:
case AddValueProfileValue:
case ArrayCopyDirect:
case ArrayCopyReverse:
case StringCompareTo:
case StringIndexOf:
case StringRegionMatches:
case ClassIsArray:
case ClassGetAllocationHandle:
case ClassGetTypeSize:
case ClassGetArrayElemSize:
case ClassIsInterface:
case ClassIsFinal:
case ClassGetArrayClass:
case ClassIsFinalizable:
case ClassGetFastCheckDepth:
break;
default:
assert(0);
}
}
break;
case Op_TauStInd: // stind
{
type=inst->getSrc(0)->getType();
if (type->isObject() || type->isValue()) {
exam2Insts->push_back(inst);
}
}
break;
case Op_DirectCall: // call
if (!inst->getDst()->isNull()) {
if (inst->getDst()->getType()->isObject()) {
type=inst->getDst()->getType();
assert(findCnGNode_op(inst->getDst()->getId())==NULL);
cgnode = addCnGNode_op(inst,type,NT_RETVAL);
}
}
methType = typeManager.getMethodPtrType(inst->asMethodInst()->getMethodDesc());
assert(methType!=NULL);
n=methType->getNumParams();
addinst=false;
for (U_32 i = 0; i < n; i++) {
Type* tt = methType->getParamType(i);
if (!tt->isReference()) {
continue;
}
addinst=true;
assert(findCnGNode_mp(inst->getId(),i)==NULL);
cgnode = addCnGNode_mp(inst, methType, NT_ACTARG, i);
}
if (addinst) {
exam2Insts->push_back(inst);
}
if (verboseLog) {
if (method_ea_level == 0) {
Log::out() <<"iE: call ";
logMethod(methType);
}
}
break;
case Op_IndirectMemoryCall: //callimem
if (!inst->getDst()->isNull()) {
if (inst->getDst()->getType()->isObject()) {
type=inst->getDst()->getType();
assert(findCnGNode_op(inst->getDst()->getId())==NULL);
cgnode = addCnGNode_op(inst,type,NT_RETVAL);
}
}
method_inst=inst->getSrc(0)->getInst();
if (method_inst->getOpcode() == Op_LdVar) {
methType = inst->getSrc(0)->getType()->asMethodPtrType();
} else if (method_inst->asMethodInst()!=NULL) {
methType = typeManager.getMethodPtrType(method_inst->asMethodInst()->getMethodDesc());
} else {
assert(method_inst->isVMHelperCallInst()); //lazy resolution helper
methType = inst->getSrc(0)->getType()->asMethodPtrType();
}
assert(methType!=NULL);
n=methType->getNumParams();
addinst=false;
for (U_32 i = 0; i < n; i++) {
Type* tt = methType->getParamType(i);
if (!tt->isReference()) {
continue;
}
addinst=true;
assert(findCnGNode_mp(inst->getId(),i)==NULL);
cgnode = addCnGNode_mp(inst, methType, NT_ACTARG, i);
}
if (addinst) {
exam2Insts->push_back(inst);
}
if (verboseLog) {
if (method_ea_level == 0) {
logMethod(methType);
}
}
break;
case Op_Catch: // catch
type = inst->getDst()->getType();
if (type->isObject()) {
assert(!type->isUnresolvedType());
assert(findCnGNode_op(inst->getDst()->getId())==NULL);
cgnode = addCnGNode_op(inst,type,NT_CATCHVAL);
}
break;
case Op_StVar: // stvar
type = inst->getDst()->getType();
if (type->isObject()) {
assert(findCnGNode_op(inst->getDst()->getId())==NULL);
cgnode = addCnGNode_op(inst,type,NT_VARVAL);
exam2Insts->push_back(inst);
}
break;
case Op_Phi: // phi
type = inst->getDst()->getType();
if (type->isReference()) {
assert(findCnGNode_op(inst->getDst()->getId())==NULL);
cgnode = addCnGNode_op(inst,type,NT_VARVAL);
exam2Insts->push_back(inst);
}
break;
case Op_LdVar: // ldvar
type = inst->getDst()->getType();
if (type->isReference()) {
assert(findCnGNode_op(inst->getDst()->getId())==NULL);
cgnode = addCnGNode_op(inst,type,NT_LDOBJ);
exam2Insts->push_back(inst);
}
break;
case Op_Return: // return
ntype=NT_EXITVAL;
case Op_Throw: // throw
if (ntype==0)
ntype=NT_THRVAL;
if (inst->getNumSrcOperands()>0) {
type = inst->getSrc(0)->getType();
if (type->isObject()) {
assert(findCnGNode_in(inst->getId())==NULL);
cgnode = addCnGNode_ex(inst,ntype);
exam2Insts->push_back(inst);
}
}
break;
case Op_TauStaticCast: // staticcast
case Op_TauCast: // cast
type = inst->getDst()->getType();
if (type->isObject()) {
assert(findCnGNode_op(inst->getDst()->getId())==NULL);
cgnode = addCnGNode_op(inst,type,NT_REF);
exam2Insts->push_back(inst);
}
break;
case Op_SaveRet: // saveret
type = inst->getDst()->getType();
if (type->isIntPtr()) {
cgnode = findCnGNode_op(inst->getDst()->getId());
if (cgnode == NULL)
cgnode = addCnGNode_op(inst,type,NT_INTPTR);
}
break;
case Op_TauMonitorEnter: // monenter
case Op_TauMonitorExit: // monexit
if (do_sync_removal && method_ea_level == 0) {
addMonInst(inst);
}
break;
case Op_TypeMonitorEnter:// tmonenter
case Op_TypeMonitorExit: // tmonexit
break;
case Op_TauVirtualCall: // callvirt
case Op_IndirectCall: // calli
case Op_TauStRef:
case Op_TauStField:
case Op_TauStElem:
case Op_Prefetch:
case Op_TauStStatic:
case Op_Copy:
break;
default:
break;
}
}
return;
} // instrExam(Node* node)
void EscAnalyzer::getLdFieldAddrInfo(Inst* inst, Type*& type, U_32& nType) {
type = NULL;
nType = 0;
if (inst->getOpcode() == Op_LdFieldAddr || inst->getOpcode() == Op_LdStaticAddr) {
FieldAccessInst* fainst = inst->asFieldAccessInst();
type = fainst->getFieldDesc()->getFieldType();
nType = inst->getOpcode() == Op_LdFieldAddr ? NT_INSTFLD : NT_STFLD;
} else {
if (inst->getOpcode() == Op_AddOffset) {
nType = NT_INSTFLD;
} else {
assert(isVMHelperCall(inst, VM_RT_GET_STATIC_FIELD_ADDR_WITHRESOLVE));
nType = NT_STFLD;
}
assert(inst->getDst()->getType()->isManagedPtr());
type = inst->getDst()->getType()->asPtrType()->getPointedToType();
}
assert(type!=NULL && nType!=0);
}
void EscAnalyzer::instrExam_processLdFieldAddr(Inst* inst) {
Type* type = NULL;
U_32 nType = 0;
getLdFieldAddrInfo(inst, type, nType);
if (type->isReference() || nType==NT_INSTFLD) {
assert(findCnGNode_op(inst->getDst()->getId())==NULL);
CnGNode* cgnode = addCnGNode_op(inst,type,NT_REF);
CnGNode* n = findCnGNode_fl(inst,nType);
if (n==NULL) {
n = addCnGNode_fl(inst,nType);
}
cgnode->lNode=n; // stick nodes
exam2Insts->push_back(inst);
}
}
void
EscAnalyzer::instrExam2_processLdFieldAddr(Inst* inst) {
Type* type = NULL;
U_32 nType = 0;
getLdFieldAddrInfo(inst, type, nType);
bool isref = type->isReference();
if (isref || nType==NT_INSTFLD) {
assert(!isref || findCnGNode_op(inst->getDst()->getId()));
if (nType == NT_INSTFLD) {
CnGNode* cgnode=findCnGNode_fl(inst,nType); // field node
assert(cgnode!=NULL);
CnGNode* cgn_src=findCnGNode_op(inst->getSrc(0)->getId()); // instance node
assert(cgn_src!=NULL);
// adding fld edge for ldflda
addEdge(cgn_src,cgnode,ET_FIELD,inst);
// special for java/lang/String::value
if (inst->asFieldAccessInst()!=NULL) {
FieldDesc* fd=inst->asFieldAccessInst()->getFieldDesc();
if (fd->getParentType()->isSystemString()&&strcmp(fd->getName(),"value")==0) {
addEdge(cgnode,cgn_src,ET_DEFER,inst);
}
if (method_ea_level == 0 && cgn_src->nInst->getOpcode()==Op_NewObj) {
//fail if instance type is not compatible with
//store/load type. Incompatibility can be the result of not cleaned dead code.
//see HARMONY-4115 for details.
Inst* instantceInst = cgn_src->nInst;
ObjectType* instanceType = instantceInst->asTypeInst()->getTypeInfo()->asObjectType();
assert(instanceType!=NULL);
ObjectType* fieldObjectType = fd->getParentType()->asObjectType();
assert(fieldObjectType!=NULL);
if (!instanceType->isSubClassOf(fieldObjectType)) {
if (shortLog) {
Log::out()<<"FAILURE: instance type: "<<instanceType->getName();
Log::out()<<" is not compatible with field object type: "<<fieldObjectType->getName()<<std::endl;
Log::out()<<"Instance inst: ";instantceInst->print(Log::out());
Log::out()<<" field inst: ";inst->print(Log::out()); Log::out()<<std::endl;
}
assert(0);
Jitrino::crash("Jitrino failure:escape: illegal HIR sequence");
}
}
}
}
}
}
void
EscAnalyzer::instrExam2() {
TypeManager& typeManager = irManager.getTypeManager();
Insts *instrs = exam2Insts;
int insnum=0;
Inst* inst;
Insts::iterator it;
for (it = instrs->begin( ); it != instrs->end( ); it++ ) {
inst=*it;
insnum++;
Type* type = NULL;
CnGNode* cgnode = NULL;
CnGNode* cgn_src = NULL;
U_32 ntype=0;
MethodPtrType* methType = NULL;
U_32 n = 0;
Inst* method_inst = NULL;
bool not_exam = false;
if (shortLog) {
Node * node = inst->getNode();
Log::out() <<"instrExam2: node: "; FlowGraph::printLabel(Log::out(), node);
Log::out()<<" dfNum="<<node->getDfNum()<<std::endl;
Log::out() <<"inst :"; inst->print(Log::out()); Log::out() << std::endl;
}
switch (inst->getOpcode()) {
case Op_AddOffset:
case Op_LdFieldAddr:
case Op_LdStaticAddr:
instrExam2_processLdFieldAddr(inst);
break;
case Op_VMHelperCall:
{
VM_RT_SUPPORT helperId = inst->asVMHelperCallInst()->getVMHelperId();
switch(helperId) {
case VM_RT_GET_STATIC_FIELD_ADDR_WITHRESOLVE:
instrExam2_processLdFieldAddr(inst);
break;
case VM_RT_CHECKCAST_WITHRESOLVE:
{ //handling is equal to taucheckcast
cgnode = findCnGNode_op(inst->getDst()->getId());
assert(cgnode!=NULL);
if (cgnode->lNode == NULL) {
cgn_src=findCnGNode_op(inst->getSrc(2)->getId());
assert(cgn_src!=NULL);
cgnode->lNode = cgn_src;
}
}
default: break;
}
}
break;
case Op_TauLdInd: // ldind
{
type=inst->getDst()->getType();
if (type->isObject()) {
cgnode=findCnGNode_op(inst->getDst()->getId());
assert(cgnode!=NULL);
// ref to loaded object
cgn_src=findCnGNode_op(inst->getSrc(0)->getId());
assert(cgn_src!=NULL);
addEdge(cgn_src,cgnode,ET_POINT,inst);
}
if (type->isValue()) {
Inst* srcInst = inst->getSrc(0)->getInst();
U_32 src_opcode = srcInst->getOpcode();
if (src_opcode==Op_LdStaticAddr || isVMHelperCall(srcInst, VM_RT_GET_STATIC_FIELD_ADDR_WITHRESOLVE)) {
break;
}
cgnode=findCnGNode_op(inst->getDst()->getId());
assert(cgnode!=NULL);
// ref to loaded object
cgn_src=findCnGNode_op(inst->getSrc(0)->getId());
assert(cgn_src!=NULL);
addEdge(cgn_src,cgnode,ET_POINT,inst);
}
}
break;
case Op_LdArrayBaseAddr: // ldbase
case Op_AddScaledIndex: // addindex
if (inst->getDst()->getType()->isReference()) {
cgnode=findCnGNode_op(inst->getDst()->getId());
assert(cgnode!=NULL);
// ref to loaded address
if (inst->getOpcode()==Op_LdArrayBaseAddr) {
cgn_src=findCnGNode_op(inst->getSrc(0)->getId());
assert(cgn_src!=NULL);
addEdge(cgn_src,cgnode,ET_FIELD,inst); // ref to base element
}
if (inst->getOpcode()==Op_AddScaledIndex) {
if (inst->getSrc(0)->getInst()->getOpcode()==Op_LdArrayBaseAddr) {
cgn_src=findCnGNode_op(
inst->getSrc(0)->getInst()->getSrc(0)->getId());
assert(cgn_src!=NULL);
addEdge(cgn_src,cgnode,ET_FIELD,inst); // ref from array object to inner objects
}
}
}
break;
case Op_TauStInd: // stind
{
type = inst->getSrc(0)->getType();
if (type->isObject()) {
// ref to loaded address
cgn_src=findCnGNode_op(inst->getSrc(0)->getId());
assert(cgn_src!=NULL);
cgnode=findCnGNode_op(inst->getSrc(1)->getId());
assert(cgnode!=NULL);
addEdge(cgnode,cgn_src,ET_DEFER,inst);
break;
}
if (type->isValue()) {
Inst* srcInst = inst->getSrc(1)->getInst();
U_32 src_opcode = srcInst->getOpcode();
if (src_opcode==Op_LdStaticAddr || isVMHelperCall(srcInst, VM_RT_GET_STATIC_FIELD_ADDR_WITHRESOLVE)) {
break;
}
cgn_src=findCnGNode_op(inst->getSrc(0)->getId());
if (cgn_src==NULL) {
cgn_src = addCnGNode_op(inst->getSrc(0)->getInst(),type,NT_LDVAL);
}
cgnode=findCnGNode_op(inst->getSrc(1)->getId());
assert(cgnode!=NULL);
addEdge(cgnode,cgn_src,ET_DEFER,inst);
}
}
break;
case Op_DirectCall: // call
methType = typeManager.getMethodPtrType(inst->asMethodInst()->getMethodDesc());
n = methType->getNumParams();
for (U_32 i = 0; i < n; i++) {
Type* tt = methType->getParamType(i);
if (!tt->isReference()) {
continue;
}
cgnode=findCnGNode_mp(inst->getId(),i);
assert(cgnode!=NULL);
Opnd* param = inst->getSrc(2+i);
cgn_src=findCnGNode_op(param->getId());
assert(cgn_src!=NULL);
addEdge(cgnode,cgn_src,ET_DEFER,inst);
}
break;
case Op_IndirectMemoryCall: //callimem
method_inst=inst->getSrc(0)->getInst();
if (method_inst->getOpcode() == Op_LdVar) {
methType = inst->getSrc(0)->getType()->asMethodPtrType();
} else if (method_inst->asMethodInst()!=NULL) {
methType = typeManager.getMethodPtrType(method_inst->asMethodInst()->getMethodDesc());
} else {
assert(method_inst->isVMHelperCallInst()); //lazy resolution helper
methType = inst->getSrc(0)->getType()->asMethodPtrType();
}
assert(methType!=NULL);
n = methType->getNumParams();
for (U_32 i = 0; i < n; i++) {
Type* tt = methType->getParamType(i);
if (!tt->isReference()) {
continue;
}
cgnode = findCnGNode_mp(inst->getId(),i);
assert(cgnode!=NULL);
Opnd* param = inst->getSrc(3+i);
cgn_src=findCnGNode_op(param->getId());
assert(cgn_src!=NULL);
addEdge(cgnode,cgn_src,ET_DEFER,inst);
}
break;
case Op_StVar: // stvar
type = inst->getDst()->getType();
if (type->isObject()) {
cgnode = findCnGNode_op(inst->getDst()->getId());
assert(cgnode!=NULL);
cgn_src=findCnGNode_op(inst->getSrc(0)->getId());
assert(cgn_src!=NULL);
addEdge(cgn_src,cgnode,ET_DEFER,inst);
}
break;
case Op_Phi: // phi
type = inst->getDst()->getType();
if (type->isObject()) {
U_32 nsrc=inst->getNumSrcOperands();
cgnode = findCnGNode_op(inst->getDst()->getId());
assert(cgnode!=NULL);
for (U_32 i=0; i<nsrc; i++) {
Opnd* srcOpnd = inst->getSrc(i);
cgn_src=findCnGNode_op(srcOpnd->getId());
assert(cgn_src!=NULL);
addEdge(cgn_src,cgnode,ET_DEFER,inst);
}
}
break;
case Op_LdVar: // ldvar
type = inst->getDst()->getType();
if (type->isReference()&&(!type->isUnmanagedPtr())) {
cgnode = findCnGNode_op(inst->getDst()->getId());
assert(cgnode!=NULL);
cgn_src=findCnGNode_op(inst->getSrc(0)->getId());
assert(cgn_src!=NULL);
addEdge(cgn_src,cgnode,ET_DEFER,inst); // load ldobj
}
break;
case Op_Return: // return
ntype=NT_EXITVAL;
case Op_Throw: // throw
if (ntype==0)
ntype=NT_THRVAL;
if (inst->getNumSrcOperands()>0) {
cgnode = findCnGNode_in(inst->getId());
assert(cgnode!=NULL);
cgn_src=findCnGNode_op(inst->getSrc(0)->getId());
assert(cgn_src!=NULL);
addEdge(cgnode,cgn_src,ET_DEFER,inst);
}
break;
case Op_TauStaticCast: // staticcast
case Op_TauCast: // cast
cgnode = findCnGNode_op(inst->getDst()->getId());
assert(cgnode!=NULL);
if (cgnode->lNode == NULL) {
cgn_src=findCnGNode_op(inst->getSrc(0)->getId());
assert(cgn_src!=NULL);
cgnode->lNode = cgn_src;
}
break;
case Op_TauMonitorEnter: // monenter
case Op_TauMonitorExit: // monexit
case Op_TypeMonitorEnter:// tmonenter
case Op_TypeMonitorExit: // tmonexit
break;
default:
if (verboseLog) {
not_exam = true;
}
}
if (verboseLog) {
if (not_exam) {
Log::out() <<"!!! Not examined. ";
inst->print(Log::out()); Log::out() << std::endl;
not_exam = false;
}
}
}
return;
} // instrExam2()
EscAnalyzer::CnGNode*
EscAnalyzer::addCnGNode(Inst* inst, Type* type, U_32 ntype) {
CnGNode* cgnode = new (eaMemManager) CnGNode; // new CG node
cgnode->cngNodeId = ++lastCnGNodeId;
cgnode->instrId = inst->getId();
cgnode->nodeType = ntype;
cgnode->lNode = NULL;
cgnode->nInst = inst;
cgnode->outEdges = NULL;
if (cgnode->nodeType==NT_DEFARG)
cgnode->argNumber = defArgNumber; // number of formal parameter
else
cgnode->argNumber = 0;
if ((ntype==NT_STFLD)||ntype==NT_THRVAL)
setFullState(cgnode,GLOBAL_ESCAPE);
else {
if (ntype==NT_ACTARG) {
setFullState(cgnode,ARG_ESCAPE);
if (inst->getOpcode()==Op_IndirectMemoryCall)
setVirtualCall(cgnode);
} else
setFullState(cgnode,NO_ESCAPE);
}
if (ntype==NT_EXITVAL)
setOutEscaped(cgnode);
cgnode->nodeMDs = NULL;
if (type->isReference()) {
if (type->isArray()) {
if (type->asArrayType()->getElementType()->isReference()) {
cgnode->nodeRefType = NR_REFARR;
} else
cgnode->nodeRefType = NR_ARR;
} else
cgnode->nodeRefType = NR_REF;
if (ntype&(NT_OBJECT|NT_RETVAL)||ntype==NT_LDOBJ) {
cgnode->nodeMDs = new (eaMemManager) NodeMDs(eaMemManager); // to collect methods receiving object
}
} else {
cgnode->nodeRefType = NR_PRIM;
}
if (cgnode->nodeType==NT_OBJECT && cgnode->nodeRefType == NR_REF) {
NamedType* nt = (NamedType*)(inst->getDst())->getType();
if (nt->isUnresolvedType() || nt->isFinalizable()) {
// finalized objects cannot be removed
// unresolved objects too
setOutEscaped(cgnode);
}
}
cngNodes->push_back(cgnode);
return cgnode;
} // addCnGNode(Inst* inst, Type* type, U_32 ntype)
EscAnalyzer::CnGNode*
EscAnalyzer::addCnGNode_op(Inst* inst, Type* type, U_32 ntype) {
CnGNode* cgnode = addCnGNode(inst, type, ntype); // new CG node
Opnd* opnd = inst->getDst();
cgnode->opndId = opnd->getId();
cgnode->refObj = opnd;
if (shortLog) {
Log::out() <<"++++ addNode "; printCnGNode(cgnode,Log::out());
Log::out() << std::endl;
}
return cgnode;
} // addCnGNode_op(Inst* inst, Type* type, U_32 ntype)
EscAnalyzer::CnGNode*
EscAnalyzer::addCnGNode_mp(Inst* inst, MethodPtrType* mpt, U_32 ntype, U_32 narg) {
Type* type = mpt->getParamType(narg);
CnGNode* cgnode = addCnGNode(inst, type, ntype); // new CG node
cgnode->opndId = 0;
cgnode->argNumber = narg;
cgnode->refObj = mpt;
if (shortLog) {
Log::out() <<"++++ addNode "; printCnGNode(cgnode,Log::out());
Log::out() << std::endl;
}
return cgnode;
} // addCnGNode_mp(Inst* inst, MethodDesc* md, U_32 ntype, U_32 narg)
EscAnalyzer::CnGNode*
EscAnalyzer::addCnGNode_ex(Inst* inst, U_32 ntype) {
Type* type = inst->getSrc(0)->getType();
CnGNode* cgnode = addCnGNode(inst, type, ntype); // new CG node
cgnode->opndId = 0;
cgnode->refObj = inst->getSrc(0); // returned or thrown operand
if (shortLog) {
Log::out() <<"++++ addNode "; printCnGNode(cgnode,Log::out());
Log::out() << std::endl;
}
return cgnode;
} // addCnGNode_ex(Inst* inst, U_32 ntype)
EscAnalyzer::CnGNode*
EscAnalyzer::addCnGNode_fl(Inst* inst, U_32 ntype) {
Type* type = inst->getDst()->getType();
CnGNode* cgnode = addCnGNode(inst, type, ntype); // new CG node
cgnode->opndId = 0;
cgnode->refObj = inst; // returned or thrown operand
if (shortLog) {
Log::out() <<"++++ addNode "; printCnGNode(cgnode,Log::out());
Log::out() << std::endl;
}
return cgnode;
} // addCnGNode_fl(Inst* inst, U_32 ntype)
EscAnalyzer::CnGNode*
EscAnalyzer::findCnGNode_op(U_32 nId) {
CnGNodes::iterator it;
for (it = cngNodes->begin( ); it != cngNodes->end( ); it++ ) {
if ((*it)->opndId==nId && ((*it)->nodeType & (NT_OBJS|NT_LDVAL)))
return (*it);
}
return(NULL);
} // findCnGNode_op(U_32 nId)
EscAnalyzer::CnGNode*
EscAnalyzer::findCnGNode_id(U_32 nId) {
CnGNodes::iterator it;
for (it = cngNodes->begin( ); it != cngNodes->end( ); it++ ) {
if ((*it)->cngNodeId==nId)
return (*it);
}
return(NULL);
} // findCnGNode_id(U_32 nId)
EscAnalyzer::CnGNode*
EscAnalyzer::findCnGNode_in(U_32 nId) {
CnGNodes::iterator it;
for (it = cngNodes->begin( ); it != cngNodes->end( ); it++ ) {
if ((*it)->instrId==nId)
return (*it);
}
return(NULL);
} // findCnGNode_in(U_32 nId)
EscAnalyzer::CnGNode*
EscAnalyzer::findCnGNode_mp(U_32 iId, U_32 aId) {
CnGNodes::iterator it;
for (it = cngNodes->begin( ); it != cngNodes->end( ); it++ ) {
if ((*it)->instrId==iId && (*it)->argNumber==aId &&
(*it)->nodeType == NT_ACTARG)
return (*it);
}
return(NULL);
} // findCnGNode_mp(U_32 iId, U_32 aId)
EscAnalyzer::CnGNode*
EscAnalyzer::findCnGNode_fl(Inst* inst, U_32 ntype) {
FieldDesc* fd1 = NULL;
if (inst->asFieldAccessInst()==NULL) {// unresolved field access
assert(inst->getOpcode() == Op_AddOffset || isVMHelperCall(inst, VM_RT_GET_STATIC_FIELD_ADDR_WITHRESOLVE));
} else {
fd1 = inst->asFieldAccessInst()->getFieldDesc();
}
U_32 idr = 0; //object field used to reference this field
if (ntype==NT_INSTFLD) {
idr=inst->getSrc(0)->getId();
}
for (CnGNodes::iterator it = cngNodes->begin( ); it != cngNodes->end( ); it++ ) {
CnGNode* cgNode = *it;
if (cgNode->nodeType==ntype) {
Inst* inst2 = (Inst*)cgNode->refObj;
FieldDesc* fd2 = NULL;
if (inst2->asFieldAccessInst()==NULL) {
assert(inst2->getOpcode() == Op_AddOffset || isVMHelperCall(inst2, VM_RT_GET_STATIC_FIELD_ADDR_WITHRESOLVE));
} else {
fd2 = inst2->asFieldAccessInst()->getFieldDesc();
}
if ((fd1==NULL) != (fd2==NULL)) {
continue; // nodes for resolved & unresolved fields
}
if ( (fd1!=NULL && fd1->getFieldHandle() == fd2->getFieldHandle()) || inst == inst2/*don't optimize*/ ) {
if (ntype==NT_INSTFLD) {
U_32 idf = inst2->getSrc(0)->getId();
if (idr!=idf) {
continue;
}
}
return (*it);
}
}
}
return(NULL);
} // findCnGNode_fl(Opnd* opnd, U_32 ntype)
void
EscAnalyzer::addEdge(CnGNode* cgnfrom, CnGNode* cgnto,
U_32 etype, Inst* inst) {
CnGEdges::iterator it;
CnGRefs* el = NULL;
CnGRef* ref;
CnGNode* cgn1=cgnfrom;
CnGNode* cgn2=cgnto;
if (cgnfrom->lNode) {
cgn1 = findCnGNode_id(cgnfrom->lNode->cngNodeId); // to find CnG node using CnG node Id
assert(cgn1!=NULL);
}
if (cgnfrom->nodeType == NT_REF && cgnfrom->lNode == NULL) {
bool helperCall = isVMHelperCall(cgnfrom->nInst, VM_RT_CHECKCAST_WITHRESOLVE);
assert(cgnfrom->nInst->getOpcode()==Op_TauCast || cgnfrom->nInst->getOpcode()==Op_TauStaticCast || helperCall);
cgn1 = findCnGNode_op(cgnfrom->nInst->getSrc(helperCall ? 2 : 0)->getId());
assert(cgn1!=NULL);
cgnfrom->lNode = cgn1;
}
if (verboseLog) {
Log::out()
<< "++++ addEdge: " << cgnfrom->cngNodeId << "-" << cgnfrom->opndId
<< " ( "<<cgn1->cngNodeId << "-" << cgn1->opndId << " ) to "
<< cgnto->cngNodeId << "-" << cgnto->opndId << " ( "
<< cgn2->cngNodeId << "-" << cgn2->opndId << " )" << std::endl;
}
if (cgn1==cgn2) {
if (verboseLog) {
Log::out() << "+++++++ equal "
<< cgnfrom->cngNodeId<< "-" << cgnfrom->opndId
<< " ( "<<cgn1->cngNodeId << "-" << cgn1->opndId << " ) to "
<< cgnto->cngNodeId << "-" << cgnto->opndId << " ( "
<< cgn2->cngNodeId << "-" << cgn2->opndId << " )" << std::endl;
}
return;
}
for ( it = cngEdges->begin( ); it != cngEdges->end( ); it++ ) {
if ((*it)->cngNodeFrom == cgn1) {
CnGRefs::iterator itr;
for ( itr = (*it)->refList->begin( ); itr != (*it)->refList->end( ); itr++ ) {
if ((*itr)->cngNodeTo == cgn2 && (*itr)->edgeType == etype && cgn1->nodeType != NT_INSTFLD) {
if (etype==ET_FIELD || cgn1->nodeType==NT_ACTARG) {
if (verboseLog) {
Log::out() << "++++ addEdge: ET_FIELD || cgn1==NT_ACTARG && *->cngNodeTo == cgn2" << std::endl;
}
return;
}
if (inst->getOpcode() == Op_LdFieldAddr) {
FieldDesc* fd=inst->asFieldAccessInst()->getFieldDesc();
if (fd->getParentType()->isSystemString()&&strcmp(fd->getName(),"value")==0) {
if (verboseLog) {
Log::out() << "++++ addEdge: ldflda String.value" << std::endl;
}
return;
}
}
if (verboseLog) {
Log::out() << "++++ addEdge: edge already exists and new is added" << std::endl;
}
}
}
ref = new (eaMemManager) CnGRef;
ref->cngNodeTo=cgn2;
ref->edgeType=etype;
ref->edgeInst=inst;
(*it)->refList->push_back(ref);
if (verboseLog) {
Log::out() << "++++ addEdge: added CnGRef" << std::endl;
}
return;
}
}
ref = new (eaMemManager) CnGRef;
ref->cngNodeTo=cgn2;
ref->edgeType=etype;
ref->edgeInst=inst;
CnGEdge* cgedge=new (eaMemManager) CnGEdge;
el=new CnGRefs(eaMemManager);
cgedge->cngNodeFrom=cgn1;
el->push_back(ref);
cgedge->refList=el;
cngEdges->push_back(cgedge);
cgn1->outEdges=el;
if (verboseLog) {
Log::out() << "++++ addEdge: added edge" << std::endl;
}
} // addEdge(CnGNode* cgnfrom, CnGNode* cgnto, U_32 etype, Inst* inst)
void
EscAnalyzer::setCreatedObjectStates() {
CnGNodes::iterator it;
NodeMDs::iterator it1;
for (it = cngNodes->begin( ); it != cngNodes->end( ); it++ ) {
U_32 nt = (*it)->nodeType;
if (nt==NT_STFLD || nt==NT_CATCHVAL
|| (nt==NT_RETVAL && (*it)->nInst->getOpcode()==Op_IndirectMemoryCall)
|| (nt==NT_RETVAL && (*it)->nInst->asMethodInst()->getMethodDesc()->isNative())) {
initNodeType = NT_STFLD;
if (verboseLog) {
Log::out() <<"-- before scanGE: nodeId "
<<(*it)->cngNodeId<<" opId "<<(*it)->opndId<<" state ";
printState(*it); Log::out() << std::endl;
}
scanCnGNodeRefsGE(*it,false);
}
}
scannedObjs->clear();
scannedObjsRev->clear();
for (it = cngNodes->begin( ); it != cngNodes->end( ); it++ ) {
if ((*it)->nodeType&NT_EXITVAL || (*it)->nodeType==NT_DEFARG) { // returned, thrown , defarg
if (verboseLog) {
Log::out() <<"-- before scanEVDA: nodeId " <<(*it)->cngNodeId<<" opId "<<(*it)->opndId<<" state ";
printState(*it); Log::out() << std::endl;
}
initNodeType = (*it)->nodeType;
scanCnGNodeRefsGE(*it,false);
scannedObjs->clear();
scannedObjsRev->clear();
}
}
scannedObjs->clear();
scannedObjsRev->clear();
for (it = cngNodes->begin( ); it != cngNodes->end( ); it++ ) {
if ((*it)->nodeType==NT_ACTARG) {
curMDNode=(*it)->cngNodeId;
if (verboseLog) {
Log::out() <<"-- before scanAE: nodeId " <<(*it)->cngNodeId<<" opId "<<(*it)->opndId<<" state ";
printState(*it); Log::out() << std::endl;
}
initNodeType = NT_ACTARG;
scanCnGNodeRefsAE(*it,false);
scannedObjs->clear();
scannedObjsRev->clear();
}
}
scannedObjs->clear();
scannedObjsRev->clear();
if (method_ea_level==0) {
DominatorTree* dominatorTree = irManager.getDominatorTree();
if (!(dominatorTree && dominatorTree->isValid())) {
OptPass::computeDominators(irManager);
dominatorTree = irManager.getDominatorTree();
}
if (dominatorTree && dominatorTree->isValid()) {
OptPass::computeLoops(irManager,false);
LoopTree* ltree = irManager.getLoopTree();
if (ltree->isValid())
for (it = cngNodes->begin( ); it != cngNodes->end( ); it++ ) {
if ( (*it)->nodeType==NT_OBJECT) {
if (ltree->getLoopHeader((*it)->nInst->getNode(),false)) {
if (verboseLog) {
Log::out()
<<"--setSt loop: nodeId "
<<(*it)->cngNodeId<<" opId "
<<(*it)->opndId<<" state ";
printState(*it);
Log::out() <<" to set loop" << std::endl;
}
setLoopCreated(*it);
comObjStat._n_lo++;
}
}
}
} else {
if (verboseLog) {
mh.printFullName(Log::out()); Log::out() << std::endl;
Log::out() << "DominatorTree isn't valid " << std::endl;
}
}
}
for (it = cngNodes->begin( ); it != cngNodes->end( ); it++ ) {
U_32 nt = (*it)->nodeType;
if ((nt&(NT_OBJECT|NT_RETVAL) || nt==NT_LDOBJ) && (getEscState(*it)==ARG_ESCAPE)) {
for (it1 = (*it)->nodeMDs->begin(); it1 != (*it)->nodeMDs->end(); it1++) {
CnGNode* n=findCnGNode_id(*it1); // method argument node
assert(n!=NULL);
MethodPtrType* mpt = (MethodPtrType*)n->refObj;
Inst* callInst = n->nInst;
if (verboseLog) {
Log::out()<<"--setSt chk arg_esc: nodeId " <<(*it)->cngNodeId
<<" opId " <<(*it)->opndId<<" state ";
printState(*it); Log::out() << std::endl;
Log::out() << " "; callInst->print(Log::out());
Log::out() << std::endl;
}
if (mpt->isUnresolvedMethodPtrType() || mpt->getMethodDesc()->isNative()) { // not scanned native methods
setEscState(*it,GLOBAL_ESCAPE);
if (verboseLog) {
mpt->print(Log::out());
Log::out() << std::endl;
if (mpt->isUnresolvedMethodPtrType()) {
Log::out() << " isUnresolved: true" << std::endl;
} else {
Log::out() << " isNative: true" << std::endl;
}
}
if (verboseLog) {
Log::out() <<"--setSt 1: nodeId " <<(*it)->cngNodeId<<" opId "<<(*it)->opndId <<" state ";
printState(*it);
Log::out()<<" to gl.esc."<< std::endl;
}
break;
}
if (callInst->getOpcode()!=Op_DirectCall) { // not direct call
setVirtualCall(*it);
if (method_ea_level == 0 && do_sync_removal) {
MonUnit* mu = NULL;
if (monitorInstUnits!=NULL)
mu = findMonUnit((*it)->opndId);
if (mu != NULL) {
addMonUnitVCall(mu,callInst);
if (verboseLog) {
Log::out() << "=-=-=-=- callimem for this ";
Log::out() << std::endl;
Log::out() << "=-=- ";
printCnGNode(*it,Log::out());
Log::out() << std::endl;
printCnGNode(n,Log::out());
Log::out() << std::endl;
callInst->print(Log::out());
Log::out() << std::endl;
mpt->print(Log::out());
Log::out() << std::endl;
Log::out() << "=-=-=-=- end " << std::endl;
}
continue;
}
}
if (verboseLog) {
callInst->print(Log::out()); Log::out() << std::endl;
logMethod(mpt);
Log::out() <<"--setSt 2: nodeId " <<(*it)->cngNodeId<<" opId "<<(*it)->opndId <<" state ";
printState(*it);
Log::out() <<" to v.call." << std::endl;
}
continue; //break;
}
CalleeMethodInfo* mtdInfo = mpt->isUnresolvedMethodPtrType() ? NULL : findMethodInfo(mpt->getMethodDesc(), callInst);
if (mtdInfo == NULL) { // no info about called method
setEscState(*it,GLOBAL_ESCAPE);
if (verboseLog) {
Log::out() <<"--setSt 3: nodeId " <<(*it)->cngNodeId<<" opId "<<(*it)->opndId <<" state ";
printState(*it);Log::out() <<" to gl.esc." << std::endl;
}
break;
} else { // to use info about scanned method
U_32 narg = n->argNumber;
ParamInfos::iterator it2;
U_32 state = 0;
if (verboseLog) {
Log::out() << "--setSt cmi: method "
<< mtdInfo->methodIdent->parentName << "::"
<< mtdInfo->methodIdent->name << " "
<< mtdInfo->methodIdent->signature << std::endl;
}
for (it2 = mtdInfo->paramInfos->begin( ); it2 != mtdInfo->paramInfos->end( ); it2++) {
if (verboseLog) {
Log::out()
<<(*it2)->paramNumber<<" == "<<narg<<" state "
<<(*it2)->state <<" < "<< getEscState(*it)<<" ";
printState(*it); Log::out() << std::endl;
}
if ((*it2)->paramNumber == narg) { //???to add scanning of contained obj
if ((state=(*it2)->state&ESC_MASK) < getEscState(*it)) {
if (verboseLog) {
Log::out()<<"--setSt cmi1: nodeId " <<(*it)->cngNodeId<<" opId "<<(*it)->opndId <<" state ";
printState(*it); Log::out() <<" to state " <<state<< std::endl;
}
setEscState(*it,state);
}
}
}
}
}
if (getEscState(*it)==GLOBAL_ESCAPE) { // to set gl.escape for contained objects
initNodeType = NT_STFLD;
CnGNode* cn = *it;
CnGNode* nn = NULL;
CnGRefs::iterator it2;
if (cn->nodeType == NT_LDOBJ) {
scanCnGNodeRefsGE(cn,true);
} else {
if (cn->outEdges != NULL) {
for (it2 = cn->outEdges->begin( ); it2 != cn->outEdges->end( ); it2++ ) {
nn = (*it2)->cngNodeTo;
if (getEscState(nn)==GLOBAL_ESCAPE) {
continue;
}
scanCnGNodeRefsGE(nn,false);
}
}
}
scannedObjs->clear();
scannedObjsRev->clear();
}
}
}
for (it = cngNodes->begin( ); it != cngNodes->end( ); it++ ) {
U_32 nt = (*it)->nodeType;
if ((nt==NT_RETVAL) && getEscState(*it)>GLOBAL_ESCAPE) {
MethodDesc* mdesc = (*it)->nInst->asMethodInst()->getMethodDesc();
if (((*it)->nInst->getOpcode())!=Op_DirectCall) { // only direct call may be here
assert(0);
continue;
}
CalleeMethodInfo* mthInfo = findMethodInfo(mdesc,(*it)->nInst);
if (mthInfo == NULL) {
if (verboseLog) {
Log::out() <<"--setCOS 4: nodeId " <<(*it)->cngNodeId<<" opId "<<(*it)->opndId <<" state ";
printState(*it); Log::out() <<" to gl.esc."<< std::endl;
}
initNodeType = NT_STFLD;
scanCnGNodeRefsGE(*it,false);
} else {
if (getEscState(*it)>((mthInfo->retValueState)&ESC_MASK) || getOutEscaped(*it)==0) {
if (verboseLog) {
Log::out() <<"--setCOS 5: nodeId " <<(*it)->cngNodeId<<" opId "<<(*it)->opndId <<" state ";
printState(*it);
Log::out() <<" to "<< mthInfo->retValueState<< std::endl;
}
if (((mthInfo->retValueState)&ESC_MASK) == GLOBAL_ESCAPE) {
initNodeType = NT_STFLD; // global_escape propagate
} else {
initNodeType = NT_EXITVAL; // out_escaped propagate
}
scanCnGNodeRefsGE(*it,false);
}
}
}
}
scannedObjs->clear();
scannedObjsRev->clear();
scannedSucNodes->clear();
// check states of array elements' and fields' values
for (it = cngNodes->begin( ); it != cngNodes->end( ); it++ ) {
U_32 nt = (*it)->nodeType;
if ((nt&(NT_OBJECT|NT_RETVAL) || nt==NT_LDOBJ) && (getEscState(*it)!=GLOBAL_ESCAPE)) {
if ((*it)->outEdges == NULL)
continue;
if (verboseLog) {
Log::out() <<"--setCOS 6: to check subobj nodes ";
printCnGNode(*it,Log::out()); Log::out() << std::endl;
}
checkSubobjectStates(*it);
}
scannedObjs->clear();
scannedObjsRev->clear();
scannedSucNodes->clear();
}
} // setCreatedObjectStates()
void
EscAnalyzer::scanCnGNodeRefsGE(CnGNode* cgn, bool check_var_src) {
CnGEdges::iterator it;
CnGRefs::iterator it1;
CnGNode* next_node;
ObjIds* scObjs = check_var_src ? scannedObjsRev : scannedObjs;
U_32 ni_opcode = cgn->nInst->getOpcode();
bool needFix = isStateNeedGEFix(getFullState(cgn),cgn->nodeType);
if (cgn->nodeType != NT_STFLD && cgn->nodeType != NT_THRVAL && cgn->nodeType != NT_EXITVAL
&& cgn->nodeType != NT_DEFARG && cgn->nodeType != NT_RETVAL && cgn->nodeType != NT_LDOBJ)
assert(needFix);
if (verboseLog) {
Log::out() <<"--scanGE 1: nodeId "<<cgn->cngNodeId <<" opId "<<cgn->opndId<<" state ";
printState(cgn);
Log::out() <<" " << nodeTypeToString(cgn) <<cgn->nodeType <<" check_var_src " << check_var_src << std::endl;
}
if (cgn->nodeType == NT_LDVAL) {
if (verboseLog) {
Log::out() <<"--scanGE > 1: primitive type " << std::endl;
}
return;
}
if (scObjs->size()!=0) {
if (checkScanned(scObjs,cgn->cngNodeId)) {
if (verboseLog) {
Log::out() <<"--scanGE > 1: was scanned earlier " << std::endl;
}
return;
}
}
if (initNodeType!=NT_EXITVAL && initNodeType!=NT_DEFARG) { //
if (getEscState(cgn) > GLOBAL_ESCAPE) {
if (verboseLog) {
Log::out() <<"--scanGE 2: nodeId "
<<cgn->cngNodeId<<" opId "<<cgn->opndId <<" state ";
printState(cgn);
Log::out() <<" to gl.esc."<< std::endl;
Log::out() <<"--scanGE 2: "<< nodeTypeToString(cgn)
<< cgn->nodeType <<" initNode "<<initNodeType<< std::endl;
}
setEscState(cgn,GLOBAL_ESCAPE);
}
}
if (initNodeType==NT_EXITVAL) {
if (getOutEscaped(cgn) == 0) {
if (verboseLog) {
Log::out() <<"--scanGE 3: nodeId "
<<cgn->cngNodeId<<" opId "<<cgn->opndId <<" state ";
printState(cgn);
Log::out() <<" to out.esc."<< std::endl;
Log::out() <<"--scanGE 3: "<< nodeTypeToString(cgn)
<< cgn->nodeType <<" initNode "<<initNodeType<< std::endl;
}
setOutEscaped(cgn);
}
// The objects created in the method are not global escaped through return
}
if (initNodeType==NT_DEFARG) {
if (needFix) {
if (verboseLog) {
Log::out() <<"--scanGE 4: nodeId " <<cgn->cngNodeId<<" opId "<<cgn->opndId <<" state ";
printState(cgn);
if (cgn->nodeType == NT_OBJECT || cgn->nodeType == NT_LDOBJ || cgn->nodeType == NT_RETVAL) {
Log::out() <<" to gl.esc."<< std::endl;
} else {
Log::out() <<" to out.esc."<< std::endl;
}
Log::out() <<"--scanGE 4: "<< nodeTypeToString(cgn)
<< cgn->nodeType <<" initNode "<<initNodeType<< std::endl;
}
if (cgn->nodeType == NT_OBJECT || cgn->nodeType == NT_LDOBJ || cgn->nodeType == NT_RETVAL) {
setEscState(cgn,GLOBAL_ESCAPE); //objects escaped through defarg - global escape
} else {
setOutEscaped(cgn);
}
}
}
scObjs->push_back(cgn->cngNodeId);
if (cgn->outEdges != NULL) {
bool to_check_var_src = false;
for (it1 = cgn->outEdges->begin( ); it1 != cgn->outEdges->end( ); it1++ ) {
next_node = (*it1)->cngNodeTo;
needFix = isStateNeedGEFix(getFullState(next_node),next_node->nodeType);
if (!needFix) {
if (verboseLog) {
Log::out() <<"--scanGE 5.0 next: already set ";
printState(next_node); Log::out() << std::endl;
}
continue;
}
if (next_node->nodeType == NT_LDOBJ && next_node->nInst->getOpcode()==Op_LdVar
&& cgn->nodeType!=NT_VARVAL) {
to_check_var_src = true;
}
if (verboseLog) {
Log::out() <<"--scanGE 5 next: nodeId "
<<next_node->cngNodeId<<" opId "<<next_node->opndId <<" state ";
printState(next_node); Log::out() << std::endl;
}
scanCnGNodeRefsGE(next_node,to_check_var_src);
if (verboseLog) {
Log::out() <<"--scanGE ret 1 for node: " << next_node->cngNodeId
<<" opId " << next_node->opndId << std::endl;
}
}
}
if (check_var_src) {
if (ni_opcode == Op_LdVar || ni_opcode == Op_StVar || ni_opcode ==Op_Phi) {
U_32 nsrc=cgn->nInst->getNumSrcOperands();
for (U_32 i=0; i<nsrc; i++) {
next_node = findCnGNode_op(cgn->nInst->getSrc(i)->getId());
needFix = isStateNeedGEFix(getFullState(next_node),next_node->nodeType);
if (!needFix) {
if (verboseLog) {
Log::out() <<"--scanGE 6.0 next: already set ";
printState(next_node); Log::out() << std::endl;
}
continue;
}
if (verboseLog) {
Log::out() <<"--scanGE 6 next: nodeId "
<<next_node->cngNodeId<<" opId "<<next_node->opndId <<" state ";
printState(next_node); Log::out() << std::endl;
}
scanCnGNodeRefsGE(next_node,check_var_src);
if (verboseLog) {
Log::out() <<"--scanGE ret 2 for node: " << next_node->cngNodeId
<<" opId " << next_node->opndId << std::endl;
}
}
}
}
} // scanCnGNodeRefsGE(CnGNode* cgn, bool check_var_src)
void
EscAnalyzer::scanCnGNodeRefsAE(CnGNode* cgn, bool check_var_src) {
CnGEdges::iterator it;
CnGRefs::iterator it1;
CnGNode* next_node;
ObjIds* scObjs = check_var_src ? scannedObjsRev : scannedObjs;
U_32 ni_opcode = cgn->nInst->getOpcode();
U_32 curMDNode_saved = 0;
if (curMDNode == 0) {
assert(getEscState(cgn)!=ARG_ESCAPE);
}
assert(getEscState(cgn)!=GLOBAL_ESCAPE);
if (verboseLog) {
Log::out() <<"--scanAE < 1: nodeId "<<cgn->cngNodeId
<<" opId "<<cgn->opndId<<" state ";
printState(cgn);
Log::out() <<" " << nodeTypeToString(cgn) <<cgn->nodeType
<<" check_var_src " << check_var_src << std::endl;
}
if (cgn->nodeType == NT_LDVAL) { // primitive type value
if (verboseLog) {
Log::out() <<"--scanAE > 1: primitive type " << std::endl;
}
return;
}
if (scObjs->size()!=0) {
if (checkScanned(scObjs,cgn->cngNodeId)) {
if (verboseLog) {
Log::out() <<"--scanAE > 2: was scanned earlier " << std::endl;
}
return;
}
}
if (cgn->nodeType == NT_ACTARG) {
curMDNode_saved = curMDNode;
}
if (cgn->nodeMDs!=NULL && curMDNode!=0) {
cgn->nodeMDs->push_back(curMDNode);
if (verboseLog) {
Log::out() <<"--scanAE 1_1: nodeId "<<cgn->cngNodeId
<<" opId "<<cgn->opndId <<" curMDNode "<<curMDNode<< std::endl;
}
}
if (getEscState(cgn) > ARG_ESCAPE) {
if (verboseLog) {
Log::out() <<"--scanAE 2: nodeId "<<cgn->cngNodeId <<" opId "<<cgn->opndId<<" state ";
printState(cgn);
Log::out() <<" to arg.esc."<< std::endl;
}
setEscState(cgn,ARG_ESCAPE);
}
scObjs->push_back(cgn->cngNodeId);
if (cgn->outEdges != NULL) {
bool to_check_var_src = check_var_src;
for (it1 = cgn->outEdges->begin( ); it1 != cgn->outEdges->end( ); it1++ ) {
next_node = (*it1)->cngNodeTo;
if (getEscState(next_node) < ARG_ESCAPE)
continue;
if (getEscState(next_node) == ARG_ESCAPE && cgn->nodeType != NT_ACTARG)
continue;
if (verboseLog) {
Log::out() <<"--scanAE 3 next: nodeId " <<next_node->cngNodeId<<" opId "<<next_node->opndId <<" state ";
printState(next_node);
Log::out() << " " << nodeTypeToString(next_node) << " ref.type " << next_node->nodeRefType << std::endl;
}
if (next_node->nodeType == NT_LDVAL)
continue;
if (next_node->nodeType == NT_LDOBJ)
if (next_node->nInst->getOpcode()==Op_LdVar && cgn->nodeType!=NT_VARVAL)
to_check_var_src = true;
scanCnGNodeRefsAE(next_node,to_check_var_src);
curMDNode = curMDNode_saved;
}
}
if (check_var_src) {
if (ni_opcode == Op_LdVar || ni_opcode == Op_StVar || ni_opcode ==Op_Phi) {
U_32 nsrc=cgn->nInst->getNumSrcOperands();
for (U_32 i=0; i<nsrc; i++) {
next_node = findCnGNode_op(cgn->nInst->getSrc(i)->getId());
if (getEscState(next_node) <= ARG_ESCAPE)
continue;
if (verboseLog) {
Log::out() <<"--scanAE 4 next: nodeId "
<<next_node->cngNodeId<<" opId "<<next_node->opndId <<" state ";
printState(next_node); Log::out() << std::endl;
}
scanCnGNodeRefsAE(next_node,check_var_src);
curMDNode = curMDNode_saved;
}
}
}
if (verboseLog) {
Log::out() <<"--scanAE > 4: exit: nodeId "<<cgn->cngNodeId
<<" opId "<<cgn->opndId<<" state "; printState(cgn);
Log::out() <<" " << nodeTypeToString(cgn) <<cgn->nodeType
<<" check_var_src " << check_var_src << std::endl;
}
} // scanCnGNodeRefsAE(CnGNode* cgn, bool check_var_src)
void
EscAnalyzer::checkSubobjectStates(CnGNode* node) {
CnGRefs::iterator it;
CnGRefs::iterator it1;
CnGNode* cgn;
CnGNode* cgn1;
CnGNode* node_fld;
bool arge = false;
bool calle = false;
bool gle = false;
bool no_mod = false;
Inst* n_inst = node->nInst;
CnGNode* nt = NULL;
if (verboseLog) {
Log::out() <<"--checkSOS 0: ";
printCnGNode(node,Log::out());Log::out() << std::endl;
}
if (node->outEdges==NULL) {
if (verboseLog) {
Log::out() <<"--checkSOS 1: return " << std::endl;
}
return;
}
for (it1 = node->outEdges->begin( ); it1 != node->outEdges->end( ); it1++ ) {
node_fld = (*it1)->cngNodeTo;
if ((*it1)->edgeType != ET_FIELD) {
continue;
}
if (node_fld->outEdges==NULL) {
continue;
}
arge = false;
calle = false;
gle = false;
no_mod = false;
nt = node_fld;
n_inst = node_fld->nInst;
for (it = node_fld->outEdges->begin( ); it != node_fld->outEdges->end( ); it++ ) {
cgn = (*it)->cngNodeTo;
if (verboseLog) {
Log::out() <<"--checkSOS 2: ";
printCnGNode(cgn,Log::out());Log::out() << std::endl;
}
if (getEscState(cgn) < getEscState(node_fld)) {
if (getEscState(cgn)==GLOBAL_ESCAPE) {
gle = true;
break;
}
if (getEscState(cgn)==ARG_ESCAPE) {
arge = true;
continue;
}
}
if (getOutEscaped(node_fld) == 0 && getOutEscaped(cgn) != 0) {
calle = true;
continue;
}
no_mod = true;
}
if (verboseLog) {
Log::out() <<"--checkSOS 2: " << no_mod << " " << gle << " " << calle << " " << arge
<< std::endl;
}
if (gle || calle || arge) {
if (node_fld->nodeType==NT_ARRELEM) {
if (n_inst->getOpcode() == Op_AddScaledIndex) {
n_inst = n_inst->getSrc(0)->getInst();
nt = findCnGNode_op(n_inst->getSrc(0)->getId());
if (verboseLog) {
Log::out() <<"--checkSOS 3: "; printCnGNode(nt,Log::out()); Log::out() << std::endl;
}
if (nt->lNode != NULL) {
nt = nt->lNode;
}
}
}
if (verboseLog) {
Log::out() <<"--checkSOS 4: found ";
printCnGNode(nt,Log::out());Log::out() << std::endl;
}
if (gle) {
initNodeType = NT_STFLD;
} else {
if (calle) {
initNodeType = NT_DEFARG;
} else {
initNodeType = NT_ACTARG;
}
}
if (node_fld->nodeType==NT_INSTFLD) { // set new state beginning with instance field
if (gle || calle) {
scanCnGNodeRefsGE(node_fld,false);
} else {
curMDNode = 0;
scanCnGNodeRefsAE(node_fld,false);
}
} else { // set new state beginning with array elements
for (it = nt->outEdges->begin( ); it != nt->outEdges->end( ); it++ ) {
cgn1 = (*it)->cngNodeTo;
if (cgn1->nodeType != NT_ARRELEM)
continue;
if (gle || calle) {
if (isStateNeedGEFix(getFullState(cgn1),cgn1->nodeType))
scanCnGNodeRefsGE(cgn1,false);
} else {
curMDNode = 0;
if (getEscState(cgn1) > ARG_ESCAPE)
scanCnGNodeRefsAE((*it)->cngNodeTo,false);
}
}
}
}
}
} // checkSubobjectStates(CnGNode* node)
EscAnalyzer::CalleeMethodInfo*
EscAnalyzer::findMethodInfo(MethodDesc* mdesc,Inst* callInst) {
const char* ch1 = mdesc->getParentType()->getName();
const char* ch2 = mdesc->getName();
const char* ch3 = mdesc->getSignatureString();
CalleeMethodInfo* mtdInfo = getMethodInfo(ch1,ch2,ch3);
if (mtdInfo == NULL) {
if (verboseLog) {
Log::out() << " = = = = = = = = To scan method " << std::endl;
mdesc->printFullName(Log::out());
Log::out() << std::endl;
callInst->print(Log::out());
Log::out() << std::endl;
}
if (method_ea_level < maxMethodExamLevel) {
scanCalleeMethod(callInst);
mtdInfo=getMethodInfo(ch1,ch2,ch3);
}
}
return mtdInfo;
} // findMethodInfo(MethodDesc* mdesc)
EscAnalyzer::CalleeMethodInfo*
EscAnalyzer::getMethodInfo(const char* ch1,const char* ch2,const char* ch3) {
CalleeMethodInfos::iterator it;
if (calleeMethodInfos==NULL)
return NULL;
for (it = calleeMethodInfos->begin( ); it != calleeMethodInfos->end( ); it++ ) {
const char* c1 = (*it)->methodIdent->parentName;
const char* c2 = (*it)->methodIdent->name;
const char* c3 = (*it)->methodIdent->signature;
if (strcmp(c1,ch1)==0 && strcmp(c2,ch2)==0 && strcmp(c3,ch3)==0)
return (*it);
}
return NULL;
} // getMethodInfo(const char* ch1,const char* ch2,const char* ch3)
void
EscAnalyzer::scanCalleeMethod(Inst* call) {
if (verboseLog) {
Log::out() << "==";
call->print(Log::out());
Log::out() << std::endl;
}
if (call == NULL) { // scanned Op_DirectCall, not scanned Op_IndirectMemoryCall
Log::out() << "scanMethod: NULL" << std::endl;
return;
}
MethodDesc* methodDesc = call->asMethodCallInst()->getMethodDesc();
if (verboseLog) {
Log::out() << std::endl; Log::out() << "scanMethod: "; logMethod(methodDesc);
}
OpndManager& _opndManager(irManager.getOpndManager());
Opnd *returnOpnd = 0;
if(call->getDst()->isNull())
returnOpnd = _opndManager.getNullOpnd();
else
returnOpnd = _opndManager.createSsaTmpOpnd(call->getDst()->getType());
IRManager* inlinedIRM = new (eaMemManager) IRManager(irManager.getMemoryManager(), irManager, *methodDesc, returnOpnd);
CompilationInterface& ci= inlinedIRM->getCompilationInterface();
bool cibcmap = ci.isBCMapInfoRequired();
if (cibcmap) {
ci.setBCMapInfoRequired(false);
}
{
CompilationContext inlineCC(irManager.getMemoryManager(), &ci, irManager.getCurrentJITContext());
inlineCC.setPipeline(irManager.getCompilationContext()->getPipeline());
inlineCC.setHIRManager(inlinedIRM);
runTranslatorSession(inlineCC);
}
optimizeTranslatedCode(*inlinedIRM);
EscAnalyzer ea1(this, *inlinedIRM);
ea1.doAnalysis();
if (cibcmap) {
ci.setBCMapInfoRequired(true);
}
} // scanCalleeMethod(Inst* call)
void EscAnalyzer::runTranslatorSession(CompilationContext& inlineCC) {
TranslatorSession* traSession = (TranslatorSession*)translatorAction->createSession(inlineCC.getCompilationLevelMemoryManager());
traSession->setCompilationContext(&inlineCC);
inlineCC.setCurrentSessionAction(traSession);
traSession->run();
inlineCC.setCurrentSessionAction(NULL);
}
void
EscAnalyzer::optimizeTranslatedCode(IRManager& irm) {
// run ssa pass
OptPass::computeDominators(irm);
DominatorTree* dominatorTree = irm.getDominatorTree();
ControlFlowGraph& flowGraph = irm.getFlowGraph();
DomFrontier frontier(irm.getNestedMemoryManager(),*dominatorTree,&flowGraph);
SSABuilder ssaBuilder(irm.getOpndManager(),irm.getInstFactory(),frontier,&flowGraph,
irm.getOptimizerFlags());
ssaBuilder.convertSSA(irm.getMethodDesc());
irm.setInSsa(true);
irm.setSsaUpdated();
// run devirt pass
// Devirtualizer pass(irm);
// pass.guardCallsInRegion(irm, dominatorTree);
} // optimizeTranslatedCode(IRManager& irManager)
void
EscAnalyzer::saveScannedMethodInfo() {
CnGNodes::iterator it;
MethodDesc* mdesc = &irManager.getMethodDesc();
MemoryManager& globalMM = irManager.getCurrentJITContext()->getGlobalMemoryManager();
const char* ch1 = mdesc->getParentType()->getName();
const char* ch2 = mdesc->getName();
const char* ch3 = mdesc->getSignatureString();
if (calleeMethodInfos==NULL) {
calleeMethodInfosLock.lock();
if (calleeMethodInfos==NULL)
calleeMethodInfos = new (globalMM) CalleeMethodInfos(globalMM);
calleeMethodInfosLock.unlock();
} else {
CalleeMethodInfo* mtdInfo = getMethodInfo(ch1,ch2,ch3);
if (mtdInfo!=NULL)
return; // already saved for global analyzed method
}
if (getMethodInfo(ch1,ch2,ch3)!=NULL) // info was saved by another jit
return;
calleeMethodInfosLock.lock(); // Lock to save method info in common memory
if (getMethodInfo(ch1,ch2,ch3)!=NULL) { // already saved by another jit
calleeMethodInfosLock.unlock(); // Unlock
return;
}
CalleeMethodInfo* minfo = new (globalMM) CalleeMethodInfo;
char* mpname=new (globalMM) char[strlen(ch1)+1];
strcpy(mpname,ch1);
char* mname=new (globalMM) char[strlen(ch2)+1];
strcpy(mname,ch2);
char* msig=new (globalMM) char[strlen(ch3)+1];
strcpy(msig,ch3);
MemberIdent* mident = new (globalMM) MemberIdent;
mident->parentName=mpname;
mident->name=mname;
mident->signature=msig;
minfo->methodIdent=mident;
U_32 numpar = mdesc->getNumParams();
minfo->numberOfArgs=numpar;
ParamInfos* prminfos = new (globalMM) ParamInfos(globalMM);
minfo->paramInfos=prminfos;
minfo->retValueState=0;
if (mdesc->getReturnType()->isReference()) {
U_32 escstate = 0;
for (it = cngNodes->begin( ); it != cngNodes->end( ); it++) {
if ((*it)->nodeType==NT_EXITVAL) {
if (isGlobalState(getFullState((*it)->outEdges->front()->cngNodeTo))) {
escstate = GLOBAL_ESCAPE;
break;
}
}
}
if (escstate == 0) {
escstate = OUT_ESCAPED|NO_ESCAPE;
}
minfo->retValueState=escstate;
}
bool pmt = checkMonitorsOnThis();
minfo->mon_on_this = pmt;
for (it = cngNodes->begin( ); it != cngNodes->end( ); it++) {
if ((*it)->nodeType==NT_DEFARG) {
ParamInfo* prminfo = new (globalMM) ParamInfo;
prminfo->state=getFullState(*it);
prminfo->paramNumber=(*it)->argNumber;
prminfos->push_back(prminfo);
}
}
calleeMethodInfos->push_back(minfo);
calleeMethodInfosLock.unlock(); // Unlock
if (verboseLog) {
ParamInfos::iterator it2;
Log::out() << "==== ===== calleeMethodInfo " << std::endl;
Log::out() << minfo->methodIdent->parentName << " ";
Log::out() << minfo->methodIdent->name << " ";
Log::out() << minfo->methodIdent->signature << " ";
Log::out() << minfo->numberOfArgs<< " " << std::endl;
for (it2 = minfo->paramInfos->begin( ); it2 != minfo->paramInfos->end( ); it2++) {
Log::out() << (*it2)->paramNumber << " st."
<< (*it2)->state << std::endl;
}
Log::out() << "==== end ===== calleeMethodInfo " << std::endl;
}
} // saveScannedMethodInfo(MemoryManager& mm)
U_32
EscAnalyzer::getMethodParamState(CalleeMethodInfo* mi, U_32 np) {
ParamInfos::iterator it;
U_32 st = 0;
if (mi==NULL)
return 0;
for (it = mi->paramInfos->begin( ); it != mi->paramInfos->end( ); it++) {
if ((*it)->paramNumber == np) {
st = (*it)->state;
return st;
}
}
return st;
} // getMethodParamState(CalleeMethodInfo* mi, U_32 np)
void
EscAnalyzer::markNotEscInsts() {
CnGNodes::iterator it;
bool p2 = false;
StlMap<U_32, U_32> nonEscInsts(eaMemManager);
typedef ::std::pair <U_32,U_32> intPair;
for (it = cngNodes->begin( ); it != cngNodes->end( ); it++ ) {
if ((*it)->nodeType == NT_OBJECT && getEscState(*it) > GLOBAL_ESCAPE && getVirtualCall(*it) == 0
&& getOutEscaped(*it) == 0) {
nonEscInsts.insert(intPair((*it)->instrId,getFullState(*it)));
}
}
if (p2 && Log::isEnabled()) {
Log::out() << "================ > ";
irManager.getMethodDesc().printFullName(Log::out());
Log::out() << std::endl;
}
} // markNotEscInsts()
void
EscAnalyzer::eaFixupVars(IRManager& irm) {
OptPass::computeDominators(irm);
DominatorTree* dominatorTree = irm.getDominatorTree();
ControlFlowGraph& flowGraph = irm.getFlowGraph();
DomFrontier frontier(irm.getNestedMemoryManager(),*dominatorTree,&flowGraph);
SSABuilder ssaBuilder(irm.getOpndManager(),irm.getInstFactory(),frontier,&flowGraph, irm.getOptimizerFlags());
bool phiInserted = ssaBuilder.fixupVars(&irm.getFlowGraph(), irm.getMethodDesc());
irm.setInSsa(true);
if (phiInserted)
irm.setSsaUpdated();
}
void
EscAnalyzer::printCnGNodes(const char* text,::std::ostream& os) {
CnGNodes::const_iterator it;
std::string t1;
std::string t2;
os << " "<< text << std::endl;
for (it = cngNodes->begin( ); it != cngNodes->end( ); it++ ) {
os <<" ";
printCnGNode(*it,os);
os << std::endl;
os << " ";
if ((*it)->nodeType & (NT_OBJS|NT_EXITVAL|NT_LDVAL)) { //node of created or exit object
((Opnd*)(*it)->refObj)->printWithType(os);
}
if ((*it)->nodeType == NT_RETVAL) {
os << std::endl; os << " ";
Inst* inst = ((Opnd*)(*it)->refObj)->getInst();
inst->print(os);
if (inst->getOpcode()==Op_IndirectMemoryCall) {
os << std::endl; os << " ";
printCallMethodName(inst, os);
}
}
if ((*it)->nodeType & NT_ACTARG) { //node of actual method parameter
((MethodPtrType*)(*it)->refObj)->print(os);
os << std::endl;
}
if ((*it)->nodeType & NT_STFLD) { //field node
Inst* inst = (Inst*)(*it)->refObj;
inst->print(os);
}
os << std::endl;
}
} // printCnGNodes(char* text,::std::ostream& os)
void
EscAnalyzer::printCnGNode(CnGNode* cgn,::std::ostream& os) {
std::string t2;
os << "nodeId "<<cgn->cngNodeId<<" ";
if (cgn->nodeType & (NT_OBJS|NT_LDVAL)) { //node of object created in the method
os << "opId "<<cgn->opndId<<" ";
} else {
if (cgn->nodeType & NT_ACTARG) { //node of actual method parameter
os << "nArg "<<cgn->argNumber<<" ";
os << "method ";
((MethodPtrType*)cgn->refObj)->print(os);
}
}
if (cgn->nodeType==NT_DEFARG)
os << " nArg "<<cgn->argNumber<<" "; //Arg number for defarg
os << " inst "<<cgn->instrId<<" ("<<nodeTypeToString(cgn)<<cgn->nodeType<<", ";
switch (cgn->nodeRefType) {
case NR_PRIM : t2="Prim-"; break;
case NR_REF : t2="Ref -"; break;
case NR_ARR : t2="Arr -"; break;
case NR_REFARR : t2="RArr-"; break;
default : t2=" -";
}
os <<t2<<cgn->nodeRefType<<") ";
if (cgn->lNode) {
os << "( " << cgn->lNode->cngNodeId << "-" << cgn->lNode->opndId << " ) ";
}
os << "st. ";
printState(cgn,os); os << " ";
} // printCnGNode(CnGNode* cgn,::std::ostream& os)
std::string
EscAnalyzer::nodeTypeToString(CnGNode* cgn) {
std::string t1;
switch (cgn->nodeType) {
case NT_OBJECT : t1="Obj -"; break;
case NT_DEFARG : t1="DArg-"; break;
case NT_RETVAL : t1="RVal-"; break;
case NT_CATCHVAL: t1="CVal-"; break;
case NT_STFLD : t1="SFld-"; break;
case NT_INSTFLD : t1="IFld-"; break;
case NT_LDOBJ : t1="LObj-"; break;
case NT_INTPTR : t1="IPtr-"; break;
case NT_VARVAL : t1="VVal-"; break;
case NT_ARRELEM : t1="ArEl-"; break;
case NT_REF : t1="REF -"; break;
case NT_ACTARG : t1="AArg-"; break;
case NT_EXITVAL : t1="EVal-"; break;
case NT_THRVAL : t1="TVal-"; break;
case NT_LDVAL : t1="LVal-"; break;
default : t1=" -";
}
return t1;
} // nodeTypeToString(CnGNode* cgn)
void
EscAnalyzer::printCnGEdges(const char* text,::std::ostream& os) {
CnGEdges* cge = cngEdges;
CnGEdges::iterator it;
CnGRefs::iterator it1;
os << " "<< text << std::endl;
if (cge==NULL) {
os <<" NULL"<< std::endl;
return;
}
for (it = cge->begin( ); it != cge->end( ); it++ ) {
os << " from ";
printCnGNode((*it)->cngNodeFrom,os);
os << " to " << std::endl;
for (it1 = (*it)->refList->begin( ); it1 != (*it)->refList->end( ); it1++ ) {
os << " ";
os <<(*it1)->cngNodeTo->cngNodeId<<" (";
os <<edgeTypeToString(*it1)<<(*it1)->edgeType<<"), ";
printCnGNode(findCnGNode_id((*it1)->cngNodeTo->cngNodeId),os);
os << std::endl;
}
}
} // printCnGEdges(char* text,::std::ostream& os)
std::string
EscAnalyzer::edgeTypeToString(CnGRef* edr) {
std::string t1;
switch (edr->edgeType) {
case ET_POINT : t1="poi-"; break;
case ET_DEFER : t1="ref-"; break;
case ET_FIELD : t1="fld-"; break;
default : t1=" -";
}
return t1;
} // edgeTypeToString(CnGRef* edr)
void
EscAnalyzer::printRefInfo(::std::ostream& os) {
CnGNodes::iterator it;
os << "================ Static Fields" << std::endl;
for (it = cngNodes->begin( ); it != cngNodes->end( ); it++ ) {
if ((*it)->nodeType==NT_STFLD) {
printCnGNodeRefs(*it, "", os);
}
}
scannedObjs->clear();
os << "================ Method Agruments" << std::endl;
for (it = cngNodes->begin( ); it != cngNodes->end( ); it++ ) {
if ((*it)->nodeType==NT_ACTARG) {
printCnGNodeRefs(*it, "", os);
}
}
scannedObjs->clear();
os << "================ Return Values" << std::endl;
for (it = cngNodes->begin( ); it != cngNodes->end( ); it++ ) {
if ((*it)->nodeType==NT_EXITVAL) {
printCnGNodeRefs(*it, "", os);
}
}
scannedObjs->clear();
os << "================ Thrown Values" << std::endl;
for (it = cngNodes->begin( ); it != cngNodes->end( ); it++ ) {
if ((*it)->nodeType==NT_THRVAL) {
printCnGNodeRefs(*it, "", os);
}
}
scannedObjs->clear();
os << "================ Instsnce Fields" << std::endl;
for (it = cngNodes->begin( ); it != cngNodes->end( ); it++ ) {
if ((*it)->nodeType==NT_INSTFLD) {
printCnGNodeRefs(*it, "", os);
}
}
scannedObjs->clear();
} // printRefInfo(::std::ostream& os)
void
EscAnalyzer::printCnGNodeRefs(CnGNode* cgn, std::string text,::std::ostream& os) {
CnGNode* node;
CnGRefs::iterator it1;
Inst* inst;
os << text;
if (scannedObjs->size()!=0) {
if (checkScannedObjs(cgn->cngNodeId)) {
os << "nodeId " << cgn->cngNodeId << " . . . " << std::endl;
return;
}
}
printCnGNode(cgn,os);
os << std::endl;
os << text; cgn->nInst->print(os); os << std::endl;
scannedObjs->push_back(cgn->cngNodeId);
if (cgn->outEdges != NULL) {
for (it1 = cgn->outEdges->begin( ); it1 != cgn->outEdges->end( ); it1++ ) {
os << text << edgeTypeToString(*it1) << std::endl;
if ((node=findCnGNode_id((*it1)->cngNodeTo->cngNodeId))!=NULL)
printCnGNodeRefs(node,text+" ",os);
}
}
scannedObjs->pop_back();
if (cgn->nodeType==NT_RETVAL) {
inst = cgn->nInst;
if (inst->getOpcode()==Op_IndirectMemoryCall) {
os << text << " ";
printCallMethodName(inst, os);
os << std::endl;
}
}
if (cgn->nodeType==NT_LDOBJ && getEscState(cgn)!=GLOBAL_ESCAPE) {
inst = cgn->nInst;
lObjectHistory(inst,text,os);
scannedInsts->clear();
}
} // printCnGNodeRefs(CnGNode* cgn, std::string text,::std::ostream& os)
void
EscAnalyzer::printCallMethodName(Inst* inst, ::std::ostream& os) {
assert(inst);
Opnd* zeroOpnd = inst->getSrc(0);
Inst* srcInst = zeroOpnd->getInst();
if (srcInst->getOpcode()== Op_LdVar) {
MethodDesc* md = zeroOpnd->getType()->asMethodPtrType()->getMethodDesc();
md->printFullName(os);
} else if (inst->isMethod()) {
MethodDesc* md = inst->asMethodInst()->getMethodDesc();
md->printFullName(os);
} else if (srcInst->isMethod()) {
// Op_TauLdVirtFunAddrSlot
MethodDesc* md = srcInst->asMethodInst()->getMethodDesc();
md->printFullName(os);
} else if (srcInst->isVMHelperCallInst()) {
// A dst operand from VMHelperCallInst might also be srcInst for
// IndirectMemoryCall (for example, lazy resolution helper).
// There is no MethodDesc to print for such calls.
os << "some vmhelper";
} else {
assert(0);
}
os << std::endl;
} // printCallMethodName(Inst* inst, std::string text,::std::ostream& os)
void
EscAnalyzer::lObjectHistory(Inst* inst,std::string text,::std::ostream& os) {
Inst* inst1;
U_32 nsrc=inst->getNumSrcOperands();
if (scannedInsts->size()!=0) {
if (checkScannedInsts(inst->getId())) {
os << text << "instId " << inst->getId() << " . . . " << std::endl;
return;
}
}
os << text; inst->print(os); os << std::endl;
if (inst->getOpcode()==Op_DirectCall || inst->getOpcode()==Op_IndirectMemoryCall) {
Opnd *returnOpnd = inst->getDst();
if (returnOpnd != NULL) {
CnGNode* n = findCnGNode_op(returnOpnd->getId());
if (n != NULL) {
os<< text << " "; printCnGNode(n,os); os<< std::endl;
}
}
if (inst->getOpcode()==Op_IndirectMemoryCall) {
os << text << " ";
printCallMethodName(inst, os);
os << std::endl;
}
return;
}
scannedInsts->push_back(inst->getId());
for (U_32 i=0; i<nsrc; i++) {
inst1 = inst->getSrc(i)->getInst();
if (!(Type::isTau(inst->getSrc(i)->getType()->tag)))
lObjectHistory(inst1,text+" ",os);
}
} // lObjectHistory(Inst* inst,std::string text,::std::ostream& os)
void
EscAnalyzer::printCreatedObjectsInfo(::std::ostream& os) {
CnGNodes::iterator it;
NodeMDs::iterator it1;
os << "================ Created Object States < ";
irManager.getMethodDesc().printFullName(os);
os << std::endl;
for (it = cngNodes->begin( ); it != cngNodes->end( ); it++ ) {
U_32 nt = (*it)->nodeType;
if (nt&(NT_OBJECT|NT_RETVAL) || nt==NT_LDOBJ) {
printCnGNode(*it,os);
((Opnd*)(*it)->refObj)->printWithType(os);
if (getEscState(*it)==ARG_ESCAPE) {
for (it1 = (*it)->nodeMDs->begin(); it1 != (*it)->nodeMDs->end(); it1++) {
CnGNode* n=findCnGNode_id(*it1);
assert(n!=NULL);
os << std::endl; os <<" ";
printCnGNode(n,os);
os << std::endl; os <<" ";
((MethodPtrType*)n->refObj)->print(os);
}
}
os << std::endl;
os << " =="; ((Opnd*)(*it)->refObj)->getInst()->print(os);
os << std::endl;
}
}
os << "================ > " ;
irManager.getMethodDesc().printFullName(os);
os << std::endl;
} // printCreatedObjectsInfo(::std::ostream& os)
void
EscAnalyzer::createdObjectInfo() {
CnGNodes::iterator it;
int n0 = 0;
int n_ge = 0;
int n_ae = 0;
int n_ne = 0;
U_32 state = 0;
for (it = cngNodes->begin( ); it != cngNodes->end( ); it++ ) {
if ((*it)->nodeType == NT_OBJECT) {
n0++;
state = getEscState(*it);
if (state == GLOBAL_ESCAPE)
n_ge++;
if (state == ARG_ESCAPE)
n_ae++;
if (state == NO_ESCAPE)
n_ne++;
}
}
if (verboseLog) {
Log::out() << "************** Created object info: ";
mh.printFullName(Log::out());
Log::out() << std::endl;
Log::out() << " Number of created objects: " << n0 << std::endl;
if (n0>0) {
Log::out() << " Global escaped objects: " << n_ge << std::endl;
Log::out() << " Arg. escaped objects: " << n_ae << std::endl;
Log::out() << " Non escaped objects: " << n_ne << std::endl;
}
Log::out() << "************** " << std::endl;
}
comObjStat._n0+=n0;
comObjStat._n_ge+=n_ge;
comObjStat._n_ae+=n_ae;
comObjStat._n_ne+=n_ne;
if (verboseLog) {
Log::out() << "************** Common created object info " << std::endl;
Log::out() << " Number of created objects: " << comObjStat._n0 << std::endl;
Log::out() << " Global escaped objects: " << comObjStat._n_ge << std::endl;
Log::out() << " Arg. escaped objects: " << comObjStat._n_ae << std::endl;
Log::out() << " Non escaped objects: " << comObjStat._n_ne << std::endl;
Log::out() << " Objects in loop: " << comObjStat._n_lo << std::endl;
Log::out() << "************** " << std::endl;
}
} // createdObjectInfo()
void
EscAnalyzer::printOriginObjects(Inst* inst, bool all, std::string text) {
Inst* inst1 = NULL;
U_32 nsrc=inst->getNumSrcOperands();
if (scannedObjs->size()!=0) {
if (checkScannedObjs(inst->getId())) {
if (verboseLog) {
Log::out() << "instId " << inst->getId() << " . . . " << std::endl;
}
return;
}
}
if (verboseLog) {
Log::out() << text;
inst->print(Log::out());
Log::out() << std::endl;
}
if (inst->getOpcode()==Op_DirectCall || inst->getOpcode()==Op_IndirectMemoryCall) {
Opnd *returnOpnd = inst->getDst();
if (returnOpnd != NULL) {
CnGNode* n = findCnGNode_op(returnOpnd->getId());
if (n != NULL) {
if (verboseLog) {
Log::out()<< text << " ";
printCnGNode(n,Log::out());
Log::out()<< std::endl;
}
}
}
if (inst->getOpcode()==Op_IndirectMemoryCall) {
if (verboseLog) {
Log::out() << text << " ";
printCallMethodName(inst, Log::out());
Log::out() << std::endl;
}
}
return;
}
if (inst->getOpcode()==Op_TauLdInd || inst->getOpcode()==Op_LdVar) { // ldind,ldvar
Opnd *dst = inst->getDst();
CnGNode* n = findCnGNode_op(dst->getId());
if (n != NULL) {
if (verboseLog) {
Log::out()<< text << " ";
printCnGNode(n,Log::out());
Log::out()<< std::endl;
}
}
}
switch (inst->getOpcode()) {
case Op_LdRef: // ldref
case Op_NewObj: // newobj
case Op_NewArray: // newarray
case Op_NewMultiArray: // newmultiarray
case Op_DefArg: // defarg
{
CnGNode* n = findCnGNode_in(inst->getId());
if (n != NULL) {
if (verboseLog) {
Log::out() << text << " ";
printCnGNode(n,Log::out() );
Log::out() << std::endl;
}
}
break;
}
default:
break;
}
scannedObjs->push_back(inst->getId());
if (all) {
for (U_32 i=0; i<nsrc; i++) {
inst1 = inst->getSrc(i)->getInst();
printOriginObjects(inst1,true,text+" ");
}
} else {
switch (inst->getOpcode()) {
case Op_TauLdInd: // ldind
case Op_AddScaledIndex: // addindex
inst1 = inst->getSrc(0)->getInst();
printOriginObjects(inst1,false,text+" ");
break;
case Op_TauStInd: // stind
for (U_32 i=0; i<2; i++) {
inst1 = inst->getSrc(i)->getInst();
printOriginObjects(inst1,false,text+" ");
}
break;
default:
for (U_32 i=0; i<nsrc; i++) {
inst1 = inst->getSrc(i)->getInst();
printOriginObjects(inst1,false,text+" ");
}
}
}
scannedObjs->pop_back();
} // printOriginObjects(Inst* inst, bool all, std::string text)
void
EscAnalyzer::printMethodInfo(CalleeMethodInfo* mi) {
ParamInfos::iterator it2;
Log::out() << "==== debug ===== calleeMethodInfo " << std::endl;
if (mi==NULL)
Log::out() << " calleeMethodInfo is NULL " << std::endl;
else {
Log::out() << mi->methodIdent->parentName << " ";
Log::out() << mi->methodIdent->name << " ";
Log::out() << mi->methodIdent->signature << " ";
Log::out() << "Number of parameters: " << mi->numberOfArgs<< " " << std::endl;
for (it2 = mi->paramInfos->begin( ); it2 != mi->paramInfos->end( ); it2++) {
Log::out() << (*it2)->paramNumber << " st.";
printState((*it2)->state);
Log::out() << std::endl;
}
Log::out() << "Return value state: ";
printState(mi->retValueState);
Log::out() << " " << std::endl;
}
Log::out() << "==== end ===== calleeMethodInfo " << std::endl;
} // printMethodInfo(CalleeMethodInfo* mi)
void
EscAnalyzer::what_inst(Inst* inst,::std::ostream& os) {
if (inst->asCallInst())
os << " CallInst" << std::endl;
if (inst->asFieldAccessInst()) {
os << " FieldAccessInst" << std::endl;
FieldAccessInst* fai=inst->asFieldAccessInst();
FieldDesc* fd=fai->getFieldDesc();
Type* tt=fd->getFieldType();
os << " isInitOnly " << fd->isInitOnly() << std::endl;
os << " isVolatile " << fd->isVolatile() << std::endl;
os << " fldT " << tt->getName() <<" "<< tt->tag<< std::endl;
os << " isObject " << tt->isObject() << std::endl;
os << " isRef " << tt->isReference()<< std::endl;
if (tt->isReference()) {
ref_type_info(tt,os);
}
os << " getName " << fd->getName() << std::endl;
os << " signature " << fd->getSignatureString() << std::endl;
os << " parentType " << fd->getParentType()->getName() << std::endl;
os << " getId " << fd->getId() << std::endl;
os << " isPrivate " << fd->isPrivate() << std::endl;
os << " isStatic " << fd->isStatic() << std::endl;
os << " ";
fd->printFullName(os);
os << std::endl;
}
if (inst->asMethodCallInst())
os << " MethodCallInst" << std::endl;
if (inst->asMultiSrcInst())
os << " MultiSrcInst" << std::endl;
if (inst->asVarAccessInst()) {
os << " VarAccessInst" << std::endl;
if (inst->asVarAccessInst()->getVar()!=NULL) {
os << " Var: ";
inst->asVarAccessInst()->getVar()->print(os);os << std::endl;
os << " ";
inst->asVarAccessInst()->getVar()->printWithType(os);os<< std::endl;
}
if (inst->asVarAccessInst()->getBaseVar()!=NULL) {
os << " BaseVar: ";
inst->asVarAccessInst()->getBaseVar()->print(os);os << std::endl;
os << " ";
inst->asVarAccessInst()->getBaseVar()->printWithType(os);os << std::endl;
}
}
if (inst->asBranchInst())
os << " BranchInst" << std::endl;
if (inst->asCatchLabelInst())
os << " CatchLabelInst" << std::endl;
if (inst->asConstInst())
os << " ConstInst" << std::endl;
if (inst->asDispatchLabelInst())
os << " DispatchLabelInst" << std::endl;
if (inst->asLabelInst())
os << " LabelInst" << std::endl;
if (inst->asMethodEntryInst())
os << " MethodEntryInst" << std::endl;
if (inst->asMethodInst()) {
os << " MethodInst" << std::endl;
MethodDesc* md=inst->asMethodInst()->getMethodDesc();
logMethod(md);
U_32 n=md->getNumParams();
os << " Params " << n << std::endl;
for (U_32 i = 0; i < n; i++) {
Type* tt = md->getParamType(i);
os << " << "<<i<<" >> " << tt->getName() <<" "<< tt->tag<< std::endl;
os << " isObject " << tt->isObject();
os << " isRef " << tt->isReference()<< std::endl;
if (tt->isReference()) {
ref_type_info(tt,os);
}
}
os << " Id " << md->getId() << std::endl;
os << " isPrivate " << md->isPrivate() << std::endl;
os << " ParentName " << md->getParentType()->getName();os << std::endl;
md->printFullName(os);os << std::endl;
}
if (inst->asMethodMarkerInst())
os << " MethodMarkerInst" << std::endl;
if (inst->asPhiInst())
os << " PhiInst" << std::endl;
if (inst->asTauPiInst())
os << " TauPiInst" << std::endl;
if (inst->asSwitchInst())
os << " SwitchInst" << std::endl;
if (inst->asTokenInst())
os << " TokenInst" << std::endl;
if (inst->asTypeInst()) {
Type* tt = inst->asTypeInst()->getTypeInfo();
os << " TypeInst" << std::endl;
os << " "<< tt->getName() <<" "<< tt->tag<< std::endl;
}
} // what_inst(Inst* inst,::std::ostream& os)
void
EscAnalyzer::ref_type_info(Type* type,::std::ostream& os) {
NamedType* arreltype;
os << " isArr " << type->isArray();
if (type->asArrayType()) {
arreltype=type->asArrayType()->getElementType();
os << " elmT " << arreltype->getName() << " " << arreltype->tag<<" ";
os << " isRef " << arreltype->isReference();
}
os << " isArrElem " << type->isArrayElement()<< std::endl;
} // ref_type_info(Type* type,::std::ostream& os)
void
EscAnalyzer::debug_inst_info(Inst* inst,::std::ostream& os) {
Opnd* dst;
Opnd* src;
U_32 nsrc;
os << " =="; inst->print(os); os << std::endl;
if (verboseLog) {
os << " Inst Info:" << std::endl;
what_inst(inst,os);
os << " Dst & Src Info:" << std::endl;
dst=inst->getDst();
nsrc=inst->getNumSrcOperands();
os << " ";
if (!dst->isNull())
dst->print(os);
else
os << "dst NULL";
os << " --srcnum " << nsrc << std::endl;
if (!dst->isNull()) {
os << " dst ";
debug_opnd_info(dst, os);
} else
os << std::endl;
if ( nsrc != 0 ) {
os << " sources" << std::endl;
for (U_32 i=0; i<nsrc; i++) {
src=inst->getSrc(i);
os << " <<" <<i<<">> ";
debug_opnd_info(src, os);
}
}
}
} // debug_inst_info(Inst* inst,::std::ostream& os)
void
EscAnalyzer::debug_opnd_info(Opnd* opnd,::std::ostream& os) {
Type* type=opnd->getType();
opnd->print(os);
os << " id. " <<opnd->getId();
os << " type " << type->getName() << " " << type->tag<<" ";
os << " isRef " << type->isReference();
os << " isObj " << type->isObject();
os << " isVal " << type->isValue() << std::endl;
if (type->isReference())
ref_type_info(type,os);
os << " ";
opnd->printWithType(os );
os << std::endl;
os << " prop " << opnd->getProperties();
os << " isVar " << opnd->isVarOpnd();
os << " isSsa " << opnd->isSsaOpnd();
os << " isSsaVar " << opnd->isSsaVarOpnd();
os << " isSsaTmp " << opnd->isSsaTmpOpnd();
os << " isPi " << opnd->isPiOpnd() << std::endl;
if (!opnd->isVarOpnd()) {
os << " ";
opnd->getInst()->print(os);
os << std::endl;
what_inst(opnd->getInst(),os);
}
} // debug_opnd_info(Opnd* opnd,::std::ostream& os)
/* ****************************************
Monitors elimination optimization
**************************************** */
void
EscAnalyzer::addMonInst(Inst* inst) {
U_32 monOpndId = inst->getSrc(0)->getId();
MonUnit* monUnit = NULL;
monUnit = findMonUnit(monOpndId);
if (monUnit == NULL) {
monUnit = new (eaMemManager) MonUnit; // new monitor unit
monUnit->opndId = monOpndId;
monUnit->monInsts = new (eaMemManager) Insts(eaMemManager);
monitorInstUnits->push_back(monUnit);
monUnit->icallInsts = NULL;
}
monUnit->monInsts->push_back(inst);
} // addMonInst(Inst* inst)
EscAnalyzer::MonUnit*
EscAnalyzer::findMonUnit(U_32 opndId) {
MonInstUnits::iterator it;
assert(monitorInstUnits != NULL);
for (it = monitorInstUnits->begin( ); it != monitorInstUnits->end( ); it++ ) {
if ((*it)->opndId == opndId)
return *it;
}
return NULL;
}
void
EscAnalyzer::addMonUnitVCall(MonUnit* mu, Inst* inst) {
if (mu->icallInsts == NULL) {
mu->icallInsts = new (eaMemManager) Insts(eaMemManager);
}
mu->icallInsts->push_back(inst);
} // addMonUnitVCall(MonUnit* mu, Inst* inst)
bool
EscAnalyzer::checkMonitorsOnThis() {
MonInstUnits::iterator it;
Insts::iterator it1;
CnGNode* node;
if (monitorInstUnits==NULL)
return false;
for (it = monitorInstUnits->begin( ); it != monitorInstUnits->end( ); it++ ) {
node = findCnGNode_op((*it)->opndId);
Inst* opndInst = node->nInst;
if (verboseLog) {
Log::out() << " checkMOT: ";
opndInst->print(Log::out());
Log::out() << std::endl;
}
if (opndInst->getOpcode()==Op_DefArg && opndInst->getDefArgModifier()==NonNullThisArg) {
if (verboseLog) {
Log::out() << " checkMOT: " << (int)(opndInst->getDefArgModifier()) << " "
<< (opndInst->getDefArgModifier()==DefArgNoModifier) << " "
<< (opndInst->getDefArgModifier()==NonNullThisArg) << " "
<< (opndInst->getDefArgModifier()==DefArgBothModifiers) << " state: ";
printState(node,Log::out());
Log::out() << std::endl;
if (getEscState(node) != GLOBAL_ESCAPE) {
Log::out() << " defarg.ths isn't global "<< std::endl;
}
}
return true;
}
}
return false;
} // checkMonitorsOnThis()
void
EscAnalyzer::scanSyncInsts() {
MonInstUnits::iterator it;
Insts::iterator it1;
NodeMDs::iterator it2;
Insts* syncInsts;
Insts* vcInsts;
CnGNode* node;
U_32 checkedState = 0;
U_32 nState = 0;
bool to_fix_ssa = false;
BitSet fgnodes(eaMemManager,irManager.getFlowGraph().getMaxNodeId());
if (monitorInstUnits == NULL)
return;
if (verboseLog) {
if (monitorInstUnits->size() > 0) {
Log::out() << "Synchronized units: " << monitorInstUnits->size() << std::endl;
}
}
for (it = monitorInstUnits->begin( ); it != monitorInstUnits->end( ); it++ ) {
node = findCnGNode_op((*it)->opndId);
checkedState = 0;
nState = getEscState(node);
if (node->nodeType == NT_OBJECT || nState == GLOBAL_ESCAPE)
checkedState = nState;
if (nState != GLOBAL_ESCAPE && (node->nodeType != NT_OBJECT)) {
checkedState = checkState(node->nInst,nState);
scannedObjs->clear();
if (checkedState != nState && checkedState != 0) {
if (verboseLog) {
Log::out() <<"--scanSyncInsts 1: node " <<node->cngNodeId<<" opndId "<<node->opndId <<" state ";
printState(node);
Log::out()<<" to esc.state "<< checkedState << std::endl;
}
setEscState(node,checkedState);
}
}
if (verboseLog) {
Log::out() <<"--sync: state ";
Log::out() << checkedState << " ";
if (checkedState != nState)
Log::out() << "initState " << nState << " ";
Log::out() << node->cngNodeId << " - " << node->opndId << " ";
printCnGNode(node,Log::out());
Log::out() << std::endl;
if (node->nodeMDs !=NULL) {
Log::out() << " Callee methods (nodeMDs): " << std::endl;
for (it2 = node->nodeMDs->begin(); it2 != node->nodeMDs->end(); it2++) {
CnGNode* n=findCnGNode_id(*it2);
assert(n!=NULL);
Log::out() << " " << n->nInst->getNode()->getId() << " ";
FlowGraph::printLabel(Log::out(),n->nInst->getNode());
Log::out() << " "; n->nInst->print(Log::out());
Log::out()<< std::endl;
}
} else {
Log::out() << " no Callee methods (nodeMDs) " << std::endl;
}
}
syncInsts = (*it)->monInsts;
vcInsts = (*it)->icallInsts;
if (verboseLog) {
for (it1 = syncInsts->begin( ); it1 != syncInsts->end( ); it1++ ) {
Log::out() << " -";
(*it1)->print(Log::out());
Log::out() << " // node "
<< (*it1)->getNode()->getId() << " ";
FlowGraph::printLabel(Log::out(),(*it1)->getNode());
Log::out()<< std::endl;
}
if (vcInsts != NULL) {
Log::out() << " VCallee methods (icallInsts): " << std::endl;
for (it1 = vcInsts->begin( ); it1 != vcInsts->end( ); it1++ ) {
Log::out() << " node "
<< (*it1)->getNode()->getId() << " ";
FlowGraph::printLabel(Log::out(),(*it1)->getNode());
Log::out() << " ";
(*it1)->print(Log::out()); Log::out() << std::endl;
}
} else {
Log::out() << " no VCallee methods (icallInsts) " << std::endl;
}
}
if (getVirtualCall(node)!=0) {
if (checkedState > GLOBAL_ESCAPE && do_sync_removal_vc) {
U_32 bs_size = irManager.getFlowGraph().getMaxNodeId();
if (fgnodes.getSetSize() < bs_size) {
fgnodes.resizeClear(bs_size);
} else {
fgnodes.clear();
}
markLockedNodes(&fgnodes,syncInsts);
if (verboseLog) {
Log::out() << "=-=- vc loc.esc." << std::endl;
printOriginObjects(node->nInst,false);
scannedObjs->clear();
}
if (node->nodeType==NT_OBJECT) {
if (verboseLog) {
Log::out() << "=-=- vc to optimize object ";
node->nInst->print(Log::out());
Log::out() << std::endl;
}
fixMonitorInstsVCalls(*it,&fgnodes);
}
if (node->nodeType==NT_RETVAL) {
if (verboseLog) {
Log::out() << "=-=- vc to optimize retval ";
node->nInst->print(Log::out());
Log::out() << std::endl;
}
fixMonitorInstsVCalls(*it,&fgnodes);
}
to_fix_ssa = true;
} else {
if (verboseLog && do_sync_removal_vc) {
Log::out() << "=-=- vc gl.esc." << std::endl;
printOriginObjects(node->nInst,false);
scannedObjs->clear();
}
}
} else {
if (node->nodeType==NT_OBJECT && getEscState(node) != GLOBAL_ESCAPE) {
if (verboseLog) {
Log::out() << "++++ to optimize (remove) object" << std::endl;
}
removeMonitorInsts(syncInsts);
}
if (node->nodeType==NT_DEFARG && getEscState(node) != GLOBAL_ESCAPE
&& node->nInst->getDefArgModifier()==NonNullThisArg && mh.isSynchronized())
{
if (verboseLog) {
Log::out() << "++++ to optimize (fix) defarg.ths" << std::endl;
}
#ifndef PLATFORM_POSIX
if (do_sync_removal_sm) {
fixSyncMethodMonitorInsts(syncInsts);
}
#endif
}
}
}
#ifndef PLATFORM_POSIX
if (do_sync_removal_sm) {
checkCallSyncMethod();
}
#endif
// to fix var operand inserted by fixMonitorInstsVCalls method
if (to_fix_ssa) {
eaFixupVars(irManager);
}
return;
} // scanSyncInsts()
void
EscAnalyzer::markLockedNodes(BitSet* bs, Insts* syncInsts) {
Insts::iterator si_i;
Opnd* mop = NULL;
Inst* inst = NULL;
Node* n = NULL;
if (syncInsts == NULL) {
return;
}
scannedObjs->clear();
mop = syncInsts->front()->getSrc(0);
for (si_i = syncInsts->begin(); si_i != syncInsts->end(); si_i++) {
if ((*si_i)->getOpcode() == Op_TauMonitorEnter) { //monenter
n = (*si_i)->getNode();
bs->setBit(n->getId(),true);
if (verboseLog) {
Log::out() << "=-=-=Marked node: " << n->getId() << " ";
FlowGraph::printLabel(Log::out(),n); Log::out() << " ";
(*si_i)->print(Log::out()); Log::out() << std::endl;
}
inst = (Inst*)(n->getLastInst());
assert(inst!=NULL);
if (inst->getOpcode() == Op_TauMonitorExit) {
continue;
}
if (n->getOutDegree() != 0) {
markLockedNodes2(n, bs, mop);
}
}
}
} // markLockedNodes(BitSet* bs, Insts* syncInsts)
bool
EscAnalyzer::markLockedNodes2(Node* node, BitSet* bs, Opnd* moninstop) {
const Edges& oedges = node->getOutEdges();
Edges::const_iterator eit;
Inst* inst;
Node* n;
bool found = true;
if (scannedObjs->size()!=0) {
if (checkScannedObjs(node->getId())) {
if (verboseLog) {
Log::out() << "=-=- marked node previously: " << node->getId() << " ";
FlowGraph::printLabel(Log::out(),node);
Log::out() << std::endl;
}
return found;
}
}
scannedObjs->push_back(node->getId());
for (eit=oedges.begin(); eit!=oedges.end(); eit++) {
n = (*eit)->getTargetNode();
bs->setBit(n->getId(),true);
if (verboseLog) {
Log::out() << "=-=- Marked node: " << n->getId() << " ";
FlowGraph::printLabel(Log::out(),n);
Log::out() << std::endl;
}
inst = (Inst*)(n->getLastInst());
if (inst !=NULL) {
if (inst->getOpcode() == Op_TauMonitorExit) {
if (verboseLog) {
Log::out() << "=-=- Marked node: found monexit " << n->getId() << " ";
FlowGraph::printLabel(Log::out(),n); Log::out() << " ";
inst->print(Log::out()); Log::out() << std::endl;
}
continue;
}
}
if (n->getOutDegree() != 0) {
found = markLockedNodes2(n,bs,moninstop);
} else {
found = false;
}
}
return found;
} // markLockedNodes2(BitSet* bs, Insts* syncInsts)
U_32
EscAnalyzer::checkState(Inst* inst,U_32 st) {
U_32 st1;
Inst* inst1;
Opnd* opnd1;
U_32 nsrc=inst->getNumSrcOperands();
if (st <= GLOBAL_ESCAPE)
return st;
if (scannedObjs->size()!=0) {
if (checkScannedObjs(inst->getId())) {
return st;
}
}
if (inst->getOpcode()==Op_DirectCall || inst->getOpcode()==Op_IndirectMemoryCall) {
Opnd *returnOpnd = inst->getDst();
if (returnOpnd != NULL) {
CnGNode* n = findCnGNode_op(returnOpnd->getId());
if (n != NULL) {
st1 = getEscState(n);
if (st > st1)
st=st1;
}
}
return st;
}
if (st <= GLOBAL_ESCAPE)
return st;
if (inst->getOpcode()==Op_TauLdInd || inst->getOpcode()==Op_LdVar) { // ldind, ldvar
Opnd *dst = inst->getDst();
CnGNode* n = findCnGNode_op(dst->getId());
if (n != NULL) {
st1 = getEscState(n);
if (st > st1)
st=st1;
}
}
if (st <= GLOBAL_ESCAPE)
return st;
switch (inst->getOpcode()) {
case Op_LdRef: // ldref
case Op_NewObj: // newobj
case Op_NewArray: // newarray
case Op_NewMultiArray: // newmultiarray
case Op_DefArg: // defarg
{
CnGNode* n = findCnGNode_in(inst->getId());
if (n != NULL) {
st1 = getEscState(n);
if (st > st1)
st=st1;
}
break;
}
default:
break;
}
if (st <= GLOBAL_ESCAPE)
return st;
scannedObjs->push_back(inst->getId());
for (U_32 i=0; i<nsrc; i++) {
opnd1 = inst->getSrc(i);
if (opnd1->isVarOpnd()) {
inst1 = opnd1->asVarOpnd()->getVarAccessInsts();
} else {
inst1 = opnd1->getInst();
}
st1 = checkState(inst1,st);
if (st > st1)
st=st1;
if (st<=GLOBAL_ESCAPE)
break;
}
scannedObjs->pop_back();
return st;
} // checkState(Inst* inst,U_32 st)
void
EscAnalyzer::fixMonitorInstsVCalls(MonUnit* mu, BitSet* bs) {
Inst* opi = findCnGNode_op(mu->opndId)->nInst;
OpndManager& _opndManager = irManager.getOpndManager();
InstFactory& _instFactory = irManager.getInstFactory();
TypeManager& _typeManager = irManager.getTypeManager();
Type* typeInt32 = _typeManager.getInt32Type();
VarOpnd* muflag = _opndManager.createVarOpnd(typeInt32, false);
Inst* stvar0; // = _instFactory.makeStVar(muflag, i32_0);
Inst* stvar1;
Insts::iterator inst_it;
Insts* vcInsts = mu->icallInsts;;
Insts* syncInsts = mu->monInsts;
Node* oldCallNode = NULL;
Node* addedMonNode = NULL;
Node* newCallNode = NULL;
ControlFlowGraph& fg = irManager.getFlowGraph();
Node* entry_node = fg.getEntryNode();
Node* muo_node = opi->getNode();
// values 0 and 1 to set flag variable
if (verboseLog) {
Log::out() << "=-=- w0 Before " << std::endl;
FlowGraph::print(Log::out(),entry_node);
}
insertLdConst(1);
insertLdConst(0);
if (verboseLog) {
Log::out() << "=-=- w0 After " << std::endl;
FlowGraph::print(Log::out(),entry_node);
}
// insert flag=0 before monitor instruction source opnd creation instruction
if (verboseLog) {
Log::out() << "=-=- w1 Before " << std::endl;
FlowGraph::print(Log::out(),muo_node);
}
stvar0 = _instFactory.makeStVar(muflag, i32_0);
stvar0->insertBefore(opi);
if (verboseLog) {
Log::out() << "=-=- w1 After " << std::endl;
FlowGraph::print(Log::out(),muo_node);
}
// insert flag=1 before virtual call instructions
if (verboseLog) {
Log::out() << "=-=-=-=- Start w2" << std::endl;
}
for (inst_it = vcInsts->begin( ); inst_it != vcInsts->end( ); inst_it++ ) {
oldCallNode = (*inst_it)->getNode();
addedMonNode = NULL;
newCallNode = NULL;
if (verboseLog) {
Log::out() << "=-=- w2 Before " << std::endl;
FlowGraph::print(Log::out(),oldCallNode);
if (bs->getBit(oldCallNode->getId())) {
Log::out() << "=-=- monenter is needed " << std::endl;
} else {
Log::out() << "=-=- monenter isn't needed " << std::endl;
}
}
stvar1 = _instFactory.makeStVar(muflag, i32_1);
stvar1->insertBefore(*inst_it);
if (bs->getBit((*inst_it)->getNode()->getId())) {
Inst* mi = syncInsts->front();
Inst* ime = _instFactory.makeTauMonitorEnter(mi->getSrc(0), mi->getSrc(1));
assert(mi->getBCOffset()!=ILLEGAL_BC_MAPPING_VALUE);
ime->setBCOffset(mi->getBCOffset());
ime->insertBefore(*inst_it);
newCallNode = fg.splitNodeAtInstruction(ime,true,false,_instFactory.makeLabel());
SsaTmpOpnd* opflag = _opndManager.createSsaTmpOpnd(typeInt32);
_instFactory.makeLdVar(opflag,(VarOpnd*)muflag)->insertBefore(stvar1);
Inst* branch_inst = _instFactory.makeBranch(Cmp_EQ, Type::Int32,
opflag, i32_1, (LabelInst*)(newCallNode->getFirstInst()));
// insert flag check
branch_inst->insertBefore(stvar1);
addedMonNode = fg.splitNodeAtInstruction(branch_inst,true, false, _instFactory.makeLabel());
fg.addEdge(oldCallNode,newCallNode);
}
if (verboseLog) {
if (bs->getBit(oldCallNode->getId())) {
Log::out() << "=-=- monenter is inserted " << std::endl;
}
Log::out() << "=-=- w2 After " << std::endl;
FlowGraph::print(Log::out(),oldCallNode);
if (addedMonNode != NULL) {
FlowGraph::print(Log::out(),addedMonNode);
}
if (newCallNode != NULL) {
FlowGraph::print(Log::out(),newCallNode);
}
}
}
if (verboseLog) {
Log::out() << "=-=-=-=- Finish w2" << std::endl;
}
insertFlagCheck(syncInsts,muflag,0);
} // fixMonitorInstsVCalls(MonUnit* mu, BitSet* bs)
void
EscAnalyzer::insertFlagCheck(Insts* syncInsts, Opnd* muflag, U_32 chk) {
Insts::iterator inst_it;
OpndManager& _opndManager = irManager.getOpndManager();
InstFactory& _instFactory = irManager.getInstFactory();
ControlFlowGraph& fg = irManager.getFlowGraph();
TypeManager& _typeManager = irManager.getTypeManager();
Type* typeInt32 = _typeManager.getInt32Type();
SsaTmpOpnd* chk_opnd = NULL;
// check flag before monitor instructions
assert(muflag->isVarOpnd()||muflag->isSsaTmpOpnd());
if (chk == 0) {
chk_opnd = insertLdConst(0);
}
if (chk == 1) {
chk_opnd = insertLdConst(1);
}
assert(chk_opnd!=NULL);
if (verboseLog) {
Log::out() << "=-=-=-=- Start w3" << std::endl;
}
for (inst_it = syncInsts->begin( ); inst_it != syncInsts->end( ); inst_it++ ) {
Inst* curMonInst = (*inst_it);
Node* oldnode = curMonInst->getNode();
if (verboseLog) {
Log::out() << "=-=- w3 Before " << std::endl;
FlowGraph::print(Log::out(),oldnode);
}
Node* afterMonInstBlock = NULL;
Node* tiInstBlock = NULL;
if ((*inst_it)->getNextInst()!=NULL) {
// monitor inst isn'n last
tiInstBlock = fg.splitNodeAtInstruction(curMonInst, true, false, _instFactory.makeLabel());
afterMonInstBlock = tiInstBlock;
} else {
// monitor inst is last
afterMonInstBlock = (Node*)(oldnode->getUnconditionalEdge()->getTargetNode());
}
SsaTmpOpnd* i32_flag;
if (muflag->isVarOpnd()) {
i32_flag = _opndManager.createSsaTmpOpnd(typeInt32);
_instFactory.makeLdVar(i32_flag,(VarOpnd*)muflag)->insertBefore(curMonInst);
} else {
i32_flag = (SsaTmpOpnd*)muflag;
}
Inst* branch_inst = _instFactory.makeBranch(Cmp_EQ, Type::Int32,
i32_flag, chk_opnd, (LabelInst*)(afterMonInstBlock->getFirstInst()));
// insert flag check
branch_inst->insertBefore(curMonInst);
Node* monInstBlock = fg.splitNodeAtInstruction(branch_inst,true, false, _instFactory.makeLabel());
fg.addEdge(oldnode,afterMonInstBlock);
if (verboseLog) {
Log::out() << "=-=- w3 After " << std::endl;
FlowGraph::print(Log::out(),oldnode);
FlowGraph::print(Log::out(),monInstBlock);
if (tiInstBlock != NULL) {
FlowGraph::print(Log::out(),tiInstBlock);
}
}
}
if (verboseLog) {
Log::out() << "=-=-=-=- Finish w3" << std::endl;
}
} // insertFlagCheck(Insts* syncInsts, Opnd* muflag, U_32 chk)
void
EscAnalyzer::removeMonitorInsts(Insts* syncInsts) {
ControlFlowGraph& fg = irManager.getFlowGraph();
Insts::iterator it1;
Edge* excedge = NULL;
Node* targetnode = NULL;
Inst* reminst;
bool canthrow = false;
for (it1 = syncInsts->begin( ); it1 != syncInsts->end( ); it1++ ) {
reminst = *it1;
if (reminst->getOperation().canThrow()==true) {
excedge = (Edge*)reminst->getNode()->getExceptionEdge();
if (excedge != NULL)
targetnode = excedge->getTargetNode();
else
targetnode = NULL;
} else {
excedge = NULL;
targetnode = NULL;
}
if (shortLog) {
canthrow = reminst->getOperation().canThrow();
reminst->print(Log::out());
Log::out() << " ";
if (verboseLog) {
Log::out() << std::endl; Log::out() << " canThrow "<< canthrow; Log::out() << std::endl;
if (excedge==NULL) {
Log::out() << " exception edge is NULL " << std::endl;
} else {
Log::out() << " target node is " << targetnode->getId() << std::endl;
}
if (canthrow && (excedge==NULL)) {
const Edges& out_edges = reminst->getNode()->getOutEdges();
for (Edges::const_iterator eit = out_edges.begin(); eit != out_edges.end(); ++eit) {
Node* n = (*eit)->getTargetNode();
Log::out() << " edge to node " << n->getId() << " kind " << (*eit)->getKind() << std::endl;
}
}
}
}
reminst->unlink();
if (shortLog) {
Log::out() << " unlinked: ";
reminst->print(Log::out());
Log::out() << std::endl;
}
if (targetnode != NULL) {
if (targetnode->getInEdges().size() > 1) {
fg.removeEdge(excedge);
if (shortLog) {
Log::out() << " removed edge: "
<< excedge->getSourceNode()->getId() << " -> "
<< excedge->getTargetNode()->getId() << " kind " << excedge->getKind() << std::endl;
}
} else {
scannedObjs->clear();
removeNode(targetnode);
scannedObjs->clear();
}
}
}
} // removeMonitorInsts(Insts* syncInsts)
void
EscAnalyzer::removeNode(Node* node) {
const Edges& out_edges = node->getOutEdges();
Edges::const_iterator eit;
Node* n;
if (shortLog) {
Log::out() << " to remove node "; FlowGraph::printLabel(Log::out(), node); Log::out() << std::endl;
}
if (scannedObjs->size()!=0) {
if (checkScannedObjs(node->getId())) {
return;
}
}
scannedObjs->push_back(node->getId());
Nodes nodes2delete(irManager.getMemoryManager());
for (eit = out_edges.begin(); eit != out_edges.end(); ++eit) {
n = (*eit)->getTargetNode();
if (n->getInEdges().size() == 1) {
nodes2delete.push_back(n);
}
}
Nodes::iterator iter = nodes2delete.begin(), end = nodes2delete.end();
for (; iter != end; ++iter) {
n = (*iter);
removeNode(n);
}
irManager.getFlowGraph().removeNode(node);
scannedObjs->pop_back();
if (shortLog) {
Log::out() << " removed node "; FlowGraph::printLabel(Log::out(), node); Log::out() << std::endl;
}
} // removeNode(Node* node)
void
EscAnalyzer::fixSyncMethodMonitorInsts(Insts* syncInsts) {
SsaTmpOpnd* stThis = (SsaTmpOpnd*)insertReadJitHelperCall();
insertFlagCheck(syncInsts,stThis,1);
} // fixSyncMethodMonitorInsts(Insts* syncInsts)
Opnd*
EscAnalyzer::insertReadJitHelperCall() {
ControlFlowGraph& fg = irManager.getFlowGraph();
Node* oldBlock = fg.getEntryNode();
Inst* inst_after = (Inst*)oldBlock->getFirstInst();
TypeManager& _typeManager = irManager.getTypeManager();
Type* typeInt32 = _typeManager.getInt32Type();
OpndManager& _opndManager = irManager.getOpndManager();
SsaTmpOpnd* stThis = _opndManager.createSsaTmpOpnd(typeInt32);
Node* newBlock = NULL;
if (verboseLog) {
Log::out() << "++++ insertRJHC: before" << std::endl;
FlowGraph::print(Log::out(),oldBlock);
Log::out() << "++++ insertRJHC: before end" << std::endl;
}
// insert jit helper call
Opnd** args = NULL;
InstFactory& instfactory = irManager.getInstFactory();
Inst* jhcinst = instfactory.makeJitHelperCall(
stThis, ReadThisState, NULL, NULL, 0, args);
jhcinst->insertAfter(inst_after);
newBlock = fg.splitNodeAtInstruction(jhcinst,true, false,instfactory.makeLabel());
fg.addEdge(oldBlock,fg.getUnwindNode());
insertLdConst(0);
if (verboseLog) {
Log::out() << "++++ insertRJHC: after" << std::endl;
FlowGraph::print(Log::out(),oldBlock);
FlowGraph::print(Log::out(),newBlock);
Log::out() << "++++ insertRJHC: after end" << std::endl;
}
insertSaveJitHelperCall((Inst*)(newBlock->getFirstInst()),i32_0); // to restore default value
return stThis;
} // insertReadJitHelperCall()
void
EscAnalyzer::checkCallSyncMethod() {
CnGNodes::iterator it;
CnGRefs::iterator it2;
for (it = cngNodes->begin( ); it != cngNodes->end( ); it++ ) {
CnGNode* node = NULL;
CnGNode* aanode = NULL;
MethodPtrType* mpt = NULL;
CalleeMethodInfo* mtdInfo = NULL;
U_32 callee_state = 0;
node = (*it);
if (node->nodeType == NT_ACTARG && node->argNumber == 0) {
mpt = (MethodPtrType*)(node->refObj);
if (!mpt->isUnresolvedMethodPtrType() && mpt->getMethodDesc()->isSynchronized() && node->nInst->getOpcode()==Op_DirectCall) {
MethodDesc* md = mpt->getMethodDesc();
const char* ch1 = md->getParentType()->getName();
const char* ch2 = md->getName();
const char* ch3 = md->getSignatureString();
mtdInfo = getMethodInfo(ch1,ch2,ch3);
if (mtdInfo==NULL) {
callee_state = 0;
if (verboseLog) {
Log::out() << "=- Methodinfo is NULL";
Log::out() << std::endl;
}
} else {
callee_state = getMethodParamState(mtdInfo,0);
}
if (verboseLog) {
Log::out() << "---- checkCallSyncMethod:" << std::endl;
node->nInst->print(Log::out());
Log::out() << std::endl;
printCnGNode(node,Log::out());
Log::out() << std::endl;
if (node->outEdges != NULL) {
for (it2 = node->outEdges->begin(); it2 != node->outEdges->end(); it2++ ) {
Log::out() << " ccsm: ";
printState(callee_state);
Log::out() << " ";
printCnGNode((*it2)->cngNodeTo,Log::out());
Log::out() << std::endl;
}
}
Log::out() << "++++ checkCallSyncMethod: ";
Log::out() << " instance: " << md->isInstance() <<
" initializer: " << md->isInstanceInitializer() << " end" << std::endl;
}
if (callee_state == 0)
callee_state = GLOBAL_ESCAPE;
if (!isGlobalState(callee_state)) {
assert(node->outEdges->size()==1);
aanode = node->outEdges->front()->cngNodeTo;
if (!isGlobalState(aanode->state)&&
(aanode->nodeType==NT_OBJECT||aanode->nodeType==NT_RETVAL)) {
if (verboseLog) {
Log::out() << "=-=- sm this.agr.saving for ";
node->nInst->print(Log::out());
Log::out() << std::endl;
}
insertLdConst(1);
insertSaveJitHelperCall(node->nInst,i32_1);
if (verboseLog) {
Log::out() << " checkCSM: this was saved" << std::endl;
}
} else {
if (verboseLog) {
Log::out() << " checkCSM: this wasn't saved" << std::endl;
}
}
}
}
}
}
} // checkCallSyncMethod()
void
EscAnalyzer::insertSaveJitHelperCall(Inst* inst_before, SsaTmpOpnd* stVal) {
Node* oldBlock = inst_before->getNode();
ControlFlowGraph& fg = irManager.getFlowGraph();
Node* icBlock = stVal->getInst()->getNode();
if (verboseLog) {
Log::out() << "++++ insertSJHC: before" << std::endl;
if (icBlock != oldBlock)
FlowGraph::print(Log::out(),icBlock);
FlowGraph::print(Log::out(),oldBlock);
Log::out() << "++++ insertSJHC: before end" << std::endl;
}
// create jit helper call
Opnd* args[1] = {stVal};
InstFactory& instfactory = irManager.getInstFactory();
Inst* jhcinst = instfactory.makeJitHelperCall(
OpndManager::getNullOpnd(), SaveThisState, NULL, NULL, 1, args);
// insert jit helper
if (inst_before->getNode()->getFirstInst() == inst_before) {
jhcinst->insertAfter(inst_before);
} else {
jhcinst->insertBefore(inst_before);
}
UNUSED Node* newBlock = fg.splitNodeAtInstruction(jhcinst, true, false, instfactory.makeLabel());
// add dispatch edge to oldBlock
fg.addEdge(oldBlock,fg.getUnwindNode());
if (verboseLog) {
Log::out() << "++++ insertSJHC: after" << std::endl;
if (icBlock != oldBlock) {
FlowGraph::print(Log::out(),icBlock);
}
FlowGraph::print(Log::out(),oldBlock);
FlowGraph::print(Log::out(),newBlock);
Log::out() << "++++ insertSJHC: after end" << std::endl;
}
} // insertSaveJitHelperCall(Inst* inst_before, SsaTmpOpnd* stVal)
SsaTmpOpnd*
EscAnalyzer::insertLdConst(U_32 value) {
TypeManager& _typeManager = irManager.getTypeManager();
Type* typeInt32 = _typeManager.getInt32Type();
OpndManager& _opndManager = irManager.getOpndManager();
InstFactory& _instFactory = irManager.getInstFactory();
Inst* ildc = NULL;
if (value == 0)
if (i32_0 == NULL) {
i32_0 = _opndManager.createSsaTmpOpnd(typeInt32);
ildc = _instFactory.makeLdConst(i32_0, 0);
}
if (value == 1)
if (i32_1 == NULL) {
i32_1 = _opndManager.createSsaTmpOpnd(typeInt32);
ildc = _instFactory.makeLdConst(i32_1, 1);
}
if (ildc != NULL) {
ildc->insertAfter(irManager.getFlowGraph().getEntryNode()->getFirstInst());
}
if (value == 0)
return i32_0;
return i32_1;
} // insertLdConst(U_32 value)
/* ****************************************
Scalar replacement optimization
**************************************** */
void
EscAnalyzer::scanLocalObjects() {
CnGNodes::iterator it;
U_32 lo_count=0; // number of local objects
ObjIds* lnoids = NULL; // list of new opnds to optimize
ObjIds* lloids = NULL; // list of load opnds to optimize
ObjIds::iterator lo_it;
bool prTitle = true;
CnGNode* stnode = NULL;
for (it = cngNodes->begin( ); it != cngNodes->end( ); it++ ) {
CnGNode* cgNode = *it;
if (cgNode->nodeType == NT_OBJECT && getEscState(cgNode)==NO_ESCAPE
&& getOutEscaped(cgNode) == 0 && !(cgNode->nInst->getOpcode()==Op_LdRef)) {
if (prTitle) {
if (verboseLog) {
os_sc << "================ Local Object States < ";
irManager.getMethodDesc().printFullName(os_sc);
os_sc << std::endl;
}
prTitle = false;
}
lo_count++; // number of local objects
stnode = checkCnGtoScalarize(cgNode,true);
if (stnode != NULL) {
if (stnode->nodeType == NT_OBJECT) {
if (lnoids == NULL) {
lnoids = new (eaMemManager) ObjIds(eaMemManager);
}
lnoids->push_back(stnode->opndId);
} else {
if (lloids == NULL) {
lloids = new (eaMemManager) ObjIds(eaMemManager);
}
lloids->push_back(stnode->opndId);
}
}
if (verboseLog) {
os_sc << "- - - checkCnG returns ";
if (stnode == NULL) {
os_sc << " null ";
os_sc << std::endl;
} else {
printCnGNode(stnode,os_sc); os_sc << std::endl;
}
}
}
}
if (prTitle)
return;
if (verboseLog) {
os_sc << "CFGOpnds: " << irManager.getOpndManager().getNumSsaOpnds() << " CnGNodes: "
<< cngNodes->size() << " Local Objects: " << lo_count << std::endl;
}
if (lnoids != NULL || lloids != NULL) {
if (verboseLog) {
if (lnoids != NULL) {
if (lnoids->size()>0) {
os_sc << "lnoids size: " << lnoids->size() << " - ";
for (lo_it=lnoids->begin(); lo_it!=lnoids->end(); lo_it++) {
os_sc << " " << (*lo_it);
}
os_sc << std::endl;
}
}
if (lloids != NULL) {
if (lloids->size()>0) {
os_sc << "lloids size: " << lloids->size() << " - ";
for (lo_it=lloids->begin(); lo_it!=lloids->end(); lo_it++) {
os_sc << " " << (*lo_it);
}
os_sc << std::endl;
}
}
}
methodEndInsts->clear();
checkInsts->clear();
checkOpndUsage(lnoids,lloids,true);
bool doopt = false;
if (lnoids != NULL) {
if (lnoids->size()>0) {
doopt = true;
if (verboseLog) {
os_sc << "lnoids size: " << lnoids->size() << " - ";
for (lo_it=lnoids->begin(); lo_it!=lnoids->end(); lo_it++) {
os_sc << " " << (*lo_it);
}
os_sc << std::endl;
}
} else {
if (verboseLog) {
os_sc << "lnoids size: 0" << std::endl;
}
}
}
if (lloids != NULL) {
if (lloids->size()>0) {
doopt = true;
if (verboseLog) {
os_sc << "lloids size: " << lloids->size() << " - ";
for (lo_it=lloids->begin(); lo_it!=lloids->end(); lo_it++) {
os_sc << " " << (*lo_it);
}
os_sc << std::endl;
}
} else {
if (verboseLog) {
os_sc << "lloids size: 0" << std::endl;
}
}
}
if (doopt && do_scalar_repl) {
if (lnoids != NULL) {
doLOScalarReplacement(lnoids);
}
if (lloids != NULL) {
doLOScalarReplacement(lloids);
}
} }
if (verboseLog) {
os_sc << "================ > " ;
irManager.getMethodDesc().printFullName(os_sc);
os_sc << std::endl;
}
} // scanLocalObjects()
void
EscAnalyzer::scanEscapedObjects() {
CnGNodes::iterator it;
U_32 vco_count=0; // number of local objects
U_32 ob_ref_type=0; // object ref type
ObjIds* lnoids = NULL; // list of CnG node Ids for new opnds to optimize
ObjIds* lloids = NULL; // list of CnG node Ids for load opnds to optimize
ObjIds::iterator lo_it;
bool prTitle = true;
CnGNode* stnode = NULL;
for (it = cngNodes->begin( ); it != cngNodes->end( ); it++ ) {
// if ((*it)->nodeType == NT_OBJECT && getEscState(*it)!=NO_ESCAPE
if ((*it)->nodeType == NT_OBJECT
&& getOutEscaped(*it) == 0 && !((*it)->nInst->getOpcode()==Op_LdRef)) {
if ((*it)->nInst->getNode() == NULL && getEscState(*it)==NO_ESCAPE) {
continue; // already scalarized
}
ob_ref_type = (*it)->nodeRefType; // object ref type
if (ob_ref_type != NR_REF) {
continue; // vc arrays not scalarized
}
vco_count++; // number of vc objects
if (prTitle) {
if (verboseLog) {
os_sc << "================ Escaped Object States < ";
irManager.getMethodDesc().printFullName(os_sc);
os_sc << std::endl;
}
prTitle = false;
}
stnode = checkCnGtoScalarize(*it,false);
if (stnode != NULL) {
if (stnode->nodeType == NT_OBJECT) {
if (lnoids == NULL) {
lnoids = new (eaMemManager) ObjIds(eaMemManager);
}
lnoids->push_back(stnode->opndId);
} else {
if (lloids == NULL) {
lloids = new (eaMemManager) ObjIds(eaMemManager);
}
lloids->push_back(stnode->opndId);
}
}
if (verboseLog) {
os_sc << "- - - checkCnG returns ";
if (stnode == NULL) {
os_sc << " null ";
os_sc << std::endl;
} else {
printCnGNode(stnode,os_sc); os_sc << std::endl;
}
}
}
}
if (prTitle)
return;
if (verboseLog) {
os_sc << "CFGOpnds: " << irManager.getOpndManager().getNumSsaOpnds() << " CnGNodes: "
<< cngNodes->size() << " VC Objects: " << vco_count << " lnoids size "
<< (lnoids!=NULL?lnoids->size():0) << " lloids size "
<< (lloids!=NULL?lloids->size():0)<< std::endl;
}
if (lnoids != NULL || lloids != NULL) {
if (verboseLog) {
if (lnoids != NULL) {
if (lnoids->size()>0) {
os_sc << "lnoids size: " << lnoids->size() << " - ";
for (lo_it=lnoids->begin(); lo_it!=lnoids->end(); lo_it++) {
os_sc << " " << (*lo_it);
}
os_sc << std::endl;
}
}
if (lloids != NULL) {
if (lloids->size()>0) {
os_sc << "lloids size: " << lloids->size() << " - ";
for (lo_it=lloids->begin(); lo_it!=lloids->end(); lo_it++) {
os_sc << " " << (*lo_it);
}
os_sc << std::endl;
}
}
}
methodEndInsts->clear();
checkInsts->clear();
checkOpndUsage(lnoids,lloids,false);
bool doopt = false;
if (lnoids != NULL) {
if (lnoids->size()>0) {
doopt = true;
if (verboseLog) {
os_sc << "lnoids size: " << lnoids->size() << " - ";
for (lo_it=lnoids->begin(); lo_it!=lnoids->end(); lo_it++) {
os_sc << " " << (*lo_it);
}
os_sc << std::endl;
}
}
}
if (lloids != NULL) {
if (lloids->size()>0) {
doopt = true;
if (verboseLog) {
os_sc << "lloids size: " << lloids->size() << " - ";
for (lo_it=lloids->begin(); lo_it!=lloids->end(); lo_it++) {
os_sc << " " << (*lo_it);
}
os_sc << std::endl;
}
}
}
if (doopt && do_scalar_repl) {
if (lnoids != NULL) {
doEOScalarReplacement(lnoids);
}
if (lloids != NULL) {
doEOScalarReplacement(lloids);
}
}
}
if (verboseLog) {
os_sc << "================ > " ;
irManager.getMethodDesc().printFullName(os_sc);
os_sc << std::endl;
}
} // scanEscapedObjects()
void
EscAnalyzer::doLOScalarReplacement(ObjIds* loids) {
ObjIds::iterator lo_it;
CnGNode* onode;
Insts::iterator it3;
OpndManager& _opndManager = irManager.getOpndManager();
InstFactory& _instFactory = irManager.getInstFactory();
ScObjFlds* scObjFlds = new (eaMemManager) ScObjFlds(eaMemManager);
ScObjFld* sco = NULL;
ScObjFlds::iterator ito;
if (loids == NULL)
return;
if (loids->size() == 0)
return;
for (lo_it=loids->begin(); lo_it!=loids->end(); lo_it++) {
onode = findCnGNode_op(*lo_it);
if (onode == NULL) {
if (verboseLog) {
os_sc << " - - no cng node for opId " << *lo_it << std::endl;
}
continue;
}
if (onode->nodeRefType == NR_PRIM) {
continue;
}
if (verboseLog) {
os_sc << " - - method: ";
irManager.getMethodDesc().printFullName(os_sc);
os_sc << std::endl;
if (onode->nodeRefType == NR_REF)
os_sc << " - - scalarized local instance ";
else
os_sc << " - - scalarized local array ";
os_sc << " "; printCnGNode(onode,os_sc);
((Opnd*)onode->refObj)->printWithType(os_sc);
os_sc << std::endl;
}
// to collect stind & ldind instructions
scObjFlds->clear();
collectStLdInsts(onode, scObjFlds);
if (verboseLog) {
os_sc << " doLOSR: found object fields " << scObjFlds->size() << std::endl;
}
if (onode->nodeType == NT_LDOBJ) {
if (verboseLog) {
os_sc << "*-*-*- not optimized " << std::endl;
}
continue;
}
if (scObjFlds->size() > 0) {
for (ito = scObjFlds->begin( ); ito != scObjFlds->end( ); ito++ ){
sco = (*ito);
if (sco->ls_insts->size()==0) {
continue;
}
Type* fl_type = NULL;
Type* fl_type1 = NULL;
Inst* ii = sco->ls_insts->front();
if (ii->getOpcode()==Op_TauStInd) {
fl_type1 = ii->getSrc(1)->getType()->asPtrType()->getPointedToType();
fl_type = ii->getSrc(0)->getType();
} else {
fl_type1 = ii->getSrc(0)->getType()->asPtrType()->getPointedToType();
fl_type = ii->getDst()->getType();
}
VarOpnd* fl_var_opnd = _opndManager.createVarOpnd(fl_type, false);
SsaTmpOpnd* fl_init_opnd = _opndManager.createSsaTmpOpnd(fl_type);
Inst* ld_init_val_inst = NULL;
sco->fldVarOpnd = fl_var_opnd;
if (verboseLog) {
os_sc<<" PointedType "; fl_type1->print(os_sc); os_sc <<std::endl;
os_sc<<" OperandType "; fl_type->print(os_sc); os_sc <<std::endl;
}
if (fl_type->isReference()) {
ld_init_val_inst = _instFactory.makeLdNull(fl_init_opnd);
} else {
ld_init_val_inst = _instFactory.makeLdConst(fl_init_opnd, 0);
}
scalarizeOFldUsage(sco);
if (verboseLog) {
os_sc << "++++ old newobj added fld_var: before" << std::endl;
FlowGraph::print(os_sc,onode->nInst->getNode());
os_sc << "++++ old newobj: before end" << std::endl;
}
ld_init_val_inst->insertBefore(onode->nInst);
_instFactory.makeStVar(fl_var_opnd,fl_init_opnd)->insertBefore(onode->nInst);
if (verboseLog) {
os_sc << "++++ old newobj added fld_var: after" << std::endl;
FlowGraph::print(os_sc,onode->nInst->getNode());
os_sc << "++++ old newobj: after end" << std::endl;
}
}
}
Node* no_node = onode->nInst->getNode();
if (no_node != NULL) {
if (verboseLog) {
os_sc << "++++ old newobj removed: before" << std::endl;
FlowGraph::print(os_sc,no_node);
os_sc << "++++ old newobj: before end" << std::endl;
}
removeInst(onode->nInst);
if (verboseLog) {
os_sc << "++++ old newobj removed: after" << std::endl;
FlowGraph::print(os_sc,no_node);
os_sc << "++++ old newobj: after end" << std::endl;
}
}
}
} // doLOScalarReplacement(ObjIds* loids)
void
EscAnalyzer::doEOScalarReplacement(ObjIds* loids) {
ObjIds::iterator lo_it;
CnGNode* onode;
Inst* inst;
Insts::iterator it3;
OpndManager& _opndManager = irManager.getOpndManager();
InstFactory& _instFactory = irManager.getInstFactory();
Insts* vc_insts = new (eaMemManager) Insts(eaMemManager);
ObjIds* vcids = new (eaMemManager) ObjIds(eaMemManager);
double entryNode_execCount = irManager.getFlowGraph().getEntryNode()->getExecCount();
ScObjFlds* scObjFlds = new (eaMemManager) ScObjFlds(eaMemManager);
ScObjFlds* nscObjFlds = NULL;
bool lobj_opt = false;
CnGNode* lonode = NULL;
CnGNode* nonode = NULL;
if (loids == NULL)
return;
if (loids->size() == 0)
return;
for (lo_it=loids->begin(); lo_it!=loids->end(); lo_it++) {
onode = findCnGNode_op(*lo_it);
if (onode == NULL) {
if (verboseLog) {
os_sc << " - - no cng node for opId " << *lo_it << std::endl;
}
continue;
}
if (onode->nodeRefType == NR_PRIM) {
continue;
}
if (onode->nodeType == NT_OBJECT) {
lobj_opt = false;
} else {
lobj_opt = true;
}
double path_prob = -1;
path_prob = checkLocalPath(onode->nInst);
if (verboseLog) {
os_sc<<"pp " << (path_prob )<<std::endl;
os_sc<<"en*m " << (entryNode_execCount*ec_mult)<<std::endl;
os_sc<<"pp<en*m " << (path_prob < entryNode_execCount*ec_mult)<<std::endl;
os_sc<<"pp==0 " << (path_prob==0)<<std::endl;
os_sc<<"* " << (path_prob < entryNode_execCount*ec_mult || path_prob==0)<<std::endl;
}
if (path_prob < entryNode_execCount*ec_mult || path_prob==0) {
if (do_scalar_repl_final_fields) {
checkToScalarizeFinalFiels(onode, scObjFlds);
}
continue;
}
if (verboseLog) {
os_sc << " - - method: ";
irManager.getMethodDesc().printFullName(os_sc);
os_sc << std::endl;
if (onode->nodeRefType == NR_REF)
os_sc << " - - scalarized escaped instance ";
else
os_sc << " - - scalarized escaped array ";
os_sc << " "; printCnGNode(onode,os_sc);
((Opnd*)onode->refObj)->printWithType(os_sc);
os_sc << std::endl;
}
if (onode->nodeRefType != NR_REF) {
return;
}
lonode = NULL;
nonode = NULL;
if (lobj_opt) {
if (verboseLog) {
printOriginObjects(onode->nInst,false);
}
if (onode->nInst->getOpcode() != Op_LdVar) {
if (verboseLog) {
os_sc << " doEO 1 "; onode->nInst->print(os_sc);
os_sc << std::endl;
}
continue;
}
Inst* phi = onode->nInst->getSrc(0)->getInst();
if (phi->getOpcode() != Op_Phi) {
if (verboseLog) {
os_sc << " doEO 2 "; phi->print(os_sc);
os_sc << std::endl;
}
continue;
}
U_32 nsrc = phi->getNumSrcOperands();
if (nsrc > 2) {
if (verboseLog) {
os_sc << " doEO 3" << std::endl;
}
continue;
}
for (U_32 i=0; i<nsrc; i++) {
inst = phi->getSrc(i)->getInst();
if (verboseLog) {
os_sc << " doEO phi "; inst->print(os_sc);
os_sc << std::endl;
}
if (inst->getOpcode() != Op_StVar) {
break;
}
inst = inst->getSrc(0)->getInst();
if (verboseLog) {
os_sc << " doEO stvar "; inst->print(os_sc);
os_sc << std::endl;
}
if (inst->getOpcode() == Op_NewObj && nonode == NULL) {
nonode = findCnGNode_op(inst->getDst()->getId());
continue;
}
if ((inst->getOpcode() == Op_LdVar || inst->getOpcode() == Op_TauLdInd)
&& lonode == NULL) {
lonode = findCnGNode_op(inst->getDst()->getId());
continue;
}
}
if (nonode == NULL || lonode == NULL) {
if (verboseLog) {
os_sc << " doEO 4" << std::endl;
if (nonode == NULL) {
os_sc << " nonode NULL" << std::endl;
}
if (lonode == NULL) {
os_sc << " lonode NULL" << std::endl;
}
}
continue;
}
if (verboseLog) {
os_sc << " no_src "; printCnGNode(nonode,os_sc); os_sc << std::endl;
os_sc << " lo_src "; printCnGNode(lonode,os_sc); os_sc << std::endl;
}
} else {
nonode = onode;
}
// to collect stind & ldind instructions
scObjFlds->clear();
collectStLdInsts(onode, scObjFlds);
if (lobj_opt) {
collectCallInsts(nonode->cngNodeId, vc_insts, vcids);
if (vc_insts->size() > 0 ) {
if (verboseLog) {
os_sc << "--- no opt: newobj escaped " << std::endl;
for (it3=vc_insts->begin(); it3!=vc_insts->end(); it3++) {
(*it3)->print(os_sc); os_sc << std::endl;
}
}
continue;
}
// to collect stind & ldind instructions for newobj
if (nscObjFlds == NULL) {
nscObjFlds = new (eaMemManager) ScObjFlds(eaMemManager);
} else {
nscObjFlds->clear();
}
collectStLdInsts(nonode, nscObjFlds);
if (verboseLog) {
os_sc << " doEOSR: found object fields for newobj " << nscObjFlds->size() << std::endl;
}
if (!checkObjFlds(nscObjFlds, scObjFlds)) {
if (verboseLog) {
os_sc << " checkObjFlds failed " << std::endl;
}
continue;
}
if (verboseLog) {
os_sc << " checkObjFlds passed " << std::endl;
}
}
// to collect call & callimem instructions
collectCallInsts(onode->cngNodeId, vc_insts, vcids);
if (verboseLog) {
os_sc << " doEOSR: found object fields " << scObjFlds->size() << " vc_inst " << vc_insts->size()
<< std::endl;
}
if (verboseLog) {
for (it3=vc_insts->begin(); it3!=vc_insts->end(); it3++) {
(*it3)->print(os_sc); os_sc << std::endl;
}
}
if (lobj_opt) {
if (checkInsts != NULL) {
fixCheckInsts(onode->opndId);
}
}
TypeManager& _typeManager = irManager.getTypeManager();
Inst* nobj_inst = nonode->nInst; // optimized newobj inst for ldvar opnd
Inst* lobj_inst = NULL; // load opnd inst for ldvar opnd
VarOpnd* ob_var_opnd = _opndManager.createVarOpnd(nobj_inst->getDst()->getType(), false);
SsaTmpOpnd* ob_init_opnd = _opndManager.createSsaTmpOpnd(ob_var_opnd->getType());
U_32 ob_id = onode->opndId;
Insts::iterator itvc;
ScObjFlds::iterator ito;
Node* node_no = nobj_inst->getNode();
ScObjFld* sco = NULL;
if (lobj_opt) {
lobj_inst = lonode->nInst;
}
if (scObjFlds->size() > 0) {
for (ito = scObjFlds->begin( ); ito != scObjFlds->end( ); ito++ ){
sco = (*ito);
if (sco->ls_insts->size()==0)
continue;
Type* fl_type = NULL;
Type* fl_type1 = NULL;
Inst* ii = sco->ls_insts->front();
Inst* iadr = NULL;
if (ii->getOpcode()==Op_TauStInd) {
iadr=ii->getSrc(1)->getInst();
fl_type1 = ii->getSrc(1)->getType()->asPtrType()->getPointedToType();
fl_type = ii->getSrc(0)->getType();
} else {
iadr=ii->getSrc(0)->getInst();
fl_type1 = ii->getSrc(0)->getType()->asPtrType()->getPointedToType();
fl_type = ii->getDst()->getType();
}
VarOpnd* fl_var_opnd = _opndManager.createVarOpnd(fl_type, false);
SsaTmpOpnd* fl_init_opnd = _opndManager.createSsaTmpOpnd(fl_type);
Inst* ld_init_val_inst = NULL;
sco->fldVarOpnd = fl_var_opnd;
if (verboseLog) {
os_sc<<" PoitedType "; fl_type1->print(os_sc); os_sc <<std::endl;
os_sc<<" OperandType "; fl_type->print(os_sc); os_sc <<std::endl;
}
if (fl_type->isReference()) {
ld_init_val_inst = _instFactory.makeLdNull(fl_init_opnd);
} else {
ld_init_val_inst = _instFactory.makeLdConst(fl_init_opnd, 0);
}
scalarizeOFldUsage(sco);
if (verboseLog) {
os_sc << "++++ old newobj added fld_var: before" << std::endl;
FlowGraph::print(os_sc,node_no);
os_sc << "++++ old newobj: before end" << std::endl;
}
ld_init_val_inst->insertBefore(nobj_inst);
_instFactory.makeStVar(fl_var_opnd,fl_init_opnd)->insertBefore(nobj_inst);
if (verboseLog) {
os_sc << "++++ old newobj added fld_var: after" << std::endl;
FlowGraph::print(os_sc,node_no);
os_sc << "++++ old newobj: after end" << std::endl;
}
if (lobj_opt) {
//
bool comprRefs = compressedReferencesArg
|| (VMInterface::areReferencesCompressed());
Modifier mod1 = comprRefs ? AutoCompress_Yes : AutoCompress_No;
Opnd* ld_tau_op = _opndManager.createSsaTmpOpnd(_typeManager.getTauType());
Inst* itau = _instFactory.makeTauUnsafe(ld_tau_op);
itau->insertAfter(lobj_inst);
FieldDesc* fd = iadr->asFieldAccessInst()->getFieldDesc();
Opnd* dst_ld = _opndManager.createSsaTmpOpnd(iadr->getDst()->getType());
Opnd* ob_opnd = (Opnd*)(lonode->refObj);
Inst* lda = _instFactory.makeLdFieldAddr(dst_ld,ob_opnd,fd);
lda->insertAfter(itau);
SsaTmpOpnd* fl_tmp_opnd_ld = _opndManager.createSsaTmpOpnd(fl_type);
Inst* ldf = _instFactory.makeTauLdInd(mod1,fl_var_opnd->getType()->tag,
fl_tmp_opnd_ld,dst_ld,ld_tau_op,ld_tau_op);
ldf->insertAfter(lda);
Inst* stv = _instFactory.makeStVar(fl_var_opnd,fl_tmp_opnd_ld);
stv->insertAfter(ldf);
}
}
}
if ((nscObjFlds != NULL) && (nscObjFlds->size() > 0)) {
for (ito = nscObjFlds->begin( ); ito != nscObjFlds->end( ); ito++ ) {
sco = (*ito);
if (sco->ls_insts->size()==0) {
continue;
}
ScObjFlds::iterator it2;
for (it2=scObjFlds->begin(); it2!=scObjFlds->end(); it2++) {
if (sco->fd == (*it2)->fd) {
sco->fldVarOpnd = (*it2)->fldVarOpnd;
break;
}
}
assert(sco->fldVarOpnd!=NULL);
scalarizeOFldUsage(sco);
}
}
restoreEOCreation(vc_insts, scObjFlds, ob_var_opnd, ob_id);
if (verboseLog) {
os_sc << "++++ old newobj: before" << std::endl;
FlowGraph::print(os_sc,node_no);
os_sc << "++++ old newobj: before end" << std::endl;
if (lobj_opt) {
os_sc << "++++ old ldobj: before" << std::endl;
FlowGraph::print(os_sc,lonode->nInst->getNode());
os_sc << "++++ old ldobj: before end" << std::endl;
}
}
_instFactory.makeLdNull(ob_init_opnd)->insertBefore(nobj_inst);
_instFactory.makeStVar(ob_var_opnd,ob_init_opnd)->insertBefore(nobj_inst);
if (lobj_opt) {
_instFactory.makeStVar(ob_var_opnd,(Opnd*)(lonode->refObj))->insertAfter(lonode->nInst);
}
if (methodEndInsts->size()!=0)
fixMethodEndInsts(ob_id);
removeInst(nobj_inst);
if (verboseLog) {
os_sc << "++++ old newobj: after" << std::endl;
FlowGraph::print(os_sc,node_no);
os_sc << "++++ old newobj: after end" << std::endl;
if (lobj_opt) {
os_sc << "++++ old ldobj:after" << std::endl;
FlowGraph::print(os_sc,lonode->nInst->getNode());
os_sc << "++++ old ldobj: after end" << std::endl;
}
}
if (lobj_opt) { // remove ldvar, phi, stvar
Inst* phi = onode->nInst->getSrc(0)->getInst();
if (phi->getOpcode() != Op_Phi) {
assert(0);
}
U_32 nsrc = phi->getNumSrcOperands();
for (U_32 i=0; i<nsrc; i++) {
inst = phi->getSrc(i)->getInst();
removeInst(inst);
}
removeInst(phi);
removeInst(onode->nInst);
}
scObjFlds->clear();
if (nscObjFlds != NULL) {
nscObjFlds->clear();
}
}
} // doEOScalarReplacement(ObjIds* loids)
void
EscAnalyzer::collectStLdInsts(CnGNode* onode, ScObjFlds* scObjFlds) {
ScObjFld* scObjFld = NULL;
CnGRefs::iterator it1;
CnGRefs::iterator it2;
Inst* inst;
CnGNode* fnode;
if (onode->outEdges != NULL) {
for (it1 = onode->outEdges->begin(); it1 != onode->outEdges->end(); it1++) {
if ((*it1)->edgeType == ET_FIELD) {
scObjFld = new (eaMemManager) ScObjFld;
scObjFld->fldVarOpnd=NULL;
scObjFld->isFinalFld=false;
Insts* fl_insts = new (eaMemManager) Insts(eaMemManager);
fnode =(*it1)->cngNodeTo;
if (fnode->outEdges == NULL) {
if (verboseLog) {
os_sc << "collectStLdInsts: no ref from fld" << std::endl;
printCnGNode(onode, os_sc); os_sc << std::endl;
printCnGNode(fnode, os_sc); os_sc << std::endl;
}
continue;
}
for (it2 = fnode->outEdges->begin(); it2 != fnode->outEdges->end(); it2++) {
inst = (*it2)->edgeInst;
if (verboseLog) {
os_sc << "- - - to remove: ";
FlowGraph::printLabel(os_sc,inst->getNode()); os_sc<<" ";
inst->print(os_sc); os_sc<< std::endl;
}
fl_insts->push_back(inst);
if (verboseLog) {
if (inst->getOpcode() == Op_TauStInd) {
inst=inst->getSrc(1)->getInst();
}
if (inst->getOpcode() == Op_TauLdInd) {
inst=inst->getSrc(0)->getInst();
}
os_sc << " ";
FlowGraph::printLabel(os_sc,inst->getNode()); os_sc<<" ";
inst->print(os_sc); os_sc << std::endl;
os_sc << " ";
FlowGraph::printLabel(os_sc,inst->getSrc(0)->getInst()->getNode()); os_sc<<" ";
(inst->getSrc(0)->getInst())->print(os_sc); os_sc << std::endl;
}
}
if (fnode->nInst->getOpcode()==Op_LdFieldAddr) {
FieldDesc* fdesc = fnode->nInst->asFieldAccessInst()->getFieldDesc();
scObjFld->fd = fdesc;
if (fdesc->isInitOnly()) {
scObjFld->isFinalFld=true;
}
}
scObjFld->ls_insts = fl_insts;
scObjFlds->push_back(scObjFld);
} else {
os_sc << " --- col error: not a field "; (*it1)->edgeInst->print(os_sc);
os_sc << std::endl;
}
}
} else {
if (verboseLog) {
os_sc << "- - - to remove 2: ";
onode->nInst->print(os_sc);
os_sc << std::endl;
}
}
} // collectStLdInsts(CnGNode* onode, ScObjFld* scObjFlds)
void
EscAnalyzer::collectCallInsts(U_32 n, Insts* vc_insts, ObjIds* vcids) {
CnGEdges::iterator ite;
CnGRefs::iterator it2;
vc_insts->clear();
vcids->clear();
for (ite = cngEdges->begin( ); ite != cngEdges->end( ); ite++ ) {
for (it2 = (*ite)->refList->begin( ); it2 != (*ite)->refList->end( ); it2++ ) {
if ((*it2)->cngNodeTo->cngNodeId == n) {
Inst* ii=(*ite)->cngNodeFrom->nInst;
U_32 opc = ii->getOpcode();
if (opc == Op_IndirectMemoryCall || opc == Op_DirectCall) {
if (!checkScanned(vcids,ii->getId())) {
vc_insts->push_back(ii);
vcids->push_back(ii->getId());
}
}
}
}
}
} // collectCallInsts(CnGNode* onode, ScObjFld* scObjFlds)
void
EscAnalyzer::scalarizeOFldUsage(ScObjFld* scfld) {
Insts* sl_insts = scfld->ls_insts;
VarOpnd* fl_var_opnd = scfld->fldVarOpnd;
U_32 nsrco = 0;
Inst* inst_ad;
Inst* st_ld_var_inst;
Inst* st_ld_inst;
InstFactory& _instFactory = irManager.getInstFactory();
Node* node_before = NULL;
Insts::const_iterator it;
for (it = sl_insts->begin( ); it != sl_insts->end( ); it++ ) {
st_ld_inst = *it;
node_before = st_ld_inst->getNode();
if (node_before==NULL) {
os_sc << "node_before NULL "; st_ld_inst->print(os_sc); os_sc << std::endl;
}
if (verboseLog) {
os_sc << "++++ scalarizeOFldUsage: before" << std::endl;
FlowGraph::print(os_sc,node_before);
os_sc << "++++ scalarizeOFldUsage: before end" << std::endl;
}
if (st_ld_inst->getOpcode() == Op_TauStInd)
nsrco = 1;
else
nsrco = 0;
inst_ad = st_ld_inst->getSrc(nsrco)->getInst(); // receives address to load/store
if (nsrco == 0) {
st_ld_var_inst = _instFactory.makeLdVar(st_ld_inst->getDst(), fl_var_opnd);
} else {
st_ld_var_inst = _instFactory.makeStVar(fl_var_opnd, st_ld_inst->getSrc(0));
}
st_ld_var_inst->insertAfter(st_ld_inst);
removeInst(st_ld_inst);
removeInst(inst_ad);
if (inst_ad->getOpcode()==Op_AddScaledIndex) {
removeInst(inst_ad->getSrc(0)->getInst());
}
if (verboseLog) {
os_sc << "++++ scalarizeOFldUsage: after" << std::endl;
FlowGraph::print(os_sc,node_before);
os_sc << "++++ scalarizeOFldUsage: after end" << std::endl;
}
}
} // scalarizeOFldUsage(ScObjFld* scfld)
void
EscAnalyzer::checkOpndUsage(ObjIds* lnoids, ObjIds* lloids, bool check_loc) {
const Nodes& nodes = irManager.getFlowGraph().getNodes();
Nodes::const_iterator niter;
bool do_break = false;
if (verboseLog) {
os_sc << " -------- Objects used in: check_loc " << check_loc << std::endl;
}
for(niter = nodes.begin(); niter != nodes.end(); ++niter) {
Node* node = *niter;
Inst *headInst = (Inst*)node->getFirstInst();
Opnd* opnd;
for (Inst* inst=headInst->getNextInst();inst!=NULL;inst=inst->getNextInst()) {
U_32 nsrc = inst->getNumSrcOperands();
for (U_32 i=0; i<nsrc; i++) {
if (!(opnd=inst->getSrc(i))->isSsaOpnd()) { // check ssa operands
if (verboseLog) {
os_sc << " not ssa opnd " << i << " ";
inst->print(os_sc); os_sc << std::endl;
}
continue;
}
U_32 opcode=inst->getOpcode();
if (checkScanned(lnoids,opnd->getId())) {
if (verboseLog) {
os_sc << " no "; FlowGraph::printLabel(os_sc,inst->getNode());
os_sc << " "; inst->print(os_sc); os_sc << std::endl;
}
if (opcode == Op_MethodEnd) {
methodEndInsts->push_back(inst);
continue;
}
if (opcode == Op_LdFieldAddr || opcode == Op_LdArrayBaseAddr)
continue;
if (!check_loc)
if (opcode == Op_IndirectMemoryCall || opcode == Op_DirectCall)
continue;
if (verboseLog) {
os_sc << " no remove " << opnd->getId() << std::endl;
}
lnoids->remove(opnd->getId());
}
if (checkScanned(lloids,opnd->getId())) {
if (verboseLog) {
os_sc << " lo "; FlowGraph::printLabel(os_sc,inst->getNode());
os_sc << " "; inst->print(os_sc); os_sc << std::endl;
}
if (opcode == Op_Branch) {
checkInsts->push_back(inst);
continue;
}
if (opcode == Op_TauCheckNull || opcode == Op_TauIsNonNull || opcode == Op_TauHasType) {
if (checkTauOpnd(inst)) {
checkInsts->push_back(inst);
continue;
}
}
if (opcode == Op_MethodEnd) {
methodEndInsts->push_back(inst);
continue;
}
if (opcode == Op_LdFieldAddr || opcode == Op_LdArrayBaseAddr)
continue;
if (!check_loc) {
if (opcode == Op_IndirectMemoryCall || opcode == Op_DirectCall) {
continue;
}
}
if (verboseLog) {
os_sc << " lo remove " << opnd->getId() << std::endl;
}
lloids->remove(opnd->getId());
}
if ((lnoids == NULL || lnoids->size() == 0)
&& (lloids == NULL || lloids->size() == 0)) {
do_break = true;
break;
}
}
if (do_break) {
break;
}
}
}
if (verboseLog) {
os_sc << " -------- " << std::endl;
}
return;
} // checkOpndUsage(ObjIds* loids,bool check_loc,::std::ostream& os_sc)
bool
EscAnalyzer::checkTauOpnd(Inst* tau_inst) {
const Nodes& nodes = irManager.getFlowGraph().getNodes();
Nodes::const_iterator niter;
bool maydo = true;
U_32 tau_opnd_id = tau_inst->getDst()->getId();
U_32 sc_opnd_id = tau_inst->getSrc(0)->getId();
Inst* inst1;
if (verboseLog) {
os_sc << " -------- Check tau opnd " << std::endl;
}
for(niter = nodes.begin(); niter != nodes.end(); ++niter) {
Node* node = *niter;
Inst *headInst = (Inst*)node->getFirstInst();
Opnd* opnd;
for (Inst* inst=headInst->getNextInst();inst!=NULL;inst=inst->getNextInst()) {
U_32 nsrc = inst->getNumSrcOperands();
for (U_32 i=0; i<nsrc; i++) {
if (!(opnd=inst->getSrc(i))->isSsaOpnd()) // check ssa operands
continue;
if (opnd->getId()==tau_opnd_id) {
U_32 opcode=inst->getOpcode();
if (verboseLog) {
os_sc << " "; FlowGraph::printLabel(os_sc,inst->getNode());
os_sc << " "; inst->print(os_sc); os_sc << std::endl;
if (opcode == Op_IndirectMemoryCall || opcode == Op_DirectCall) {
printCallMethodName(inst, os_sc);
}
}
if (opcode == Op_IndirectMemoryCall || opcode == Op_DirectCall) {
for (U_32 i1=0; i1<nsrc; i1++) {
if (inst->getSrc(i)->getId() == sc_opnd_id)
break;
if (i1 == nsrc) {
maydo = false;
}
}
}
if (opcode == Op_TauLdInd || opcode == Op_TauStInd) {
if (opcode == Op_TauLdInd)
inst1 = inst->getSrc(0)->getInst();
else
inst1 = inst->getSrc(1)->getInst();
if (inst1->getOpcode() != Op_LdFieldAddr)
maydo = false;
if (inst1->getSrc(0)->getId() != sc_opnd_id)
maydo = false;
if (verboseLog) {
os_sc << " "; FlowGraph::printLabel(os_sc,inst1->getNode());
os_sc << " "; inst1->print(os_sc); os_sc << std::endl;
}
}
if (maydo == false) {
return maydo;
}
}
}
}
}
return maydo;
} // checkTauOpnd(Inst* tau_inst)
bool
EscAnalyzer::checkOpndUsage(U_32 lobjid) {
const Nodes& nodes = irManager.getFlowGraph().getNodes();
Nodes::const_iterator niter;
bool maydo = true;
U_32 n_used = 0;
if (verboseLog) {
os_sc << " -------- Used in " << std::endl;
}
for(niter = nodes.begin(); niter != nodes.end(); ++niter) {
Node* node = *niter;
Inst *headInst = (Inst*)node->getFirstInst();
Opnd* opnd;
for (Inst* inst=headInst->getNextInst();inst!=NULL;inst=inst->getNextInst()) {
U_32 nsrc = inst->getNumSrcOperands();
for (U_32 i=0; i<nsrc; i++) {
if (!(opnd=inst->getSrc(i))->isSsaOpnd()) // check ssa operands
continue;
if (opnd->getId()==lobjid) {
n_used++;
U_32 opcode=inst->getOpcode();
if (verboseLog) {
os_sc << " "; FlowGraph::printLabel(os_sc,inst->getNode());
os_sc << " "; inst->print(os_sc); os_sc << std::endl;
if (opcode == Op_IndirectMemoryCall || opcode == Op_DirectCall) {
printCallMethodName(inst, os_sc);
}
}
if (opcode != Op_LdFieldAddr && opcode != Op_LdArrayBaseAddr &&
opcode != Op_IndirectMemoryCall && opcode != Op_DirectCall &&
opcode != Op_MethodEnd && opcode != Op_StVar) {
maydo = false;
}
}
}
}
}
if (verboseLog) {
os_sc << " -------- opnd used: " << n_used << " maydo " << maydo << std::endl;
}
return maydo;
} // checkOpndUsage(U_32 lobjid)
EscAnalyzer::CnGNode*
EscAnalyzer::checkCnGtoScalarize(CnGNode* scnode, bool check_loc) {
U_32 ob_ref_type=0; // object ref type
U_32 ob_fld_count=0; // number of object references to fields
U_32 ob_fin_fld_count=0; // number of object references to final fields
U_32 ob_nfld_count=0; // number of object references to not a field
U_32 ref_to_obj_count=0; // number references to object
U_32 vcall_count=0; // number of virtual calls
U_32 call_count=0; // number of calls
U_32 ob_fld_stind_count=0; // number of stores in object field
U_32 ob_fld_ldind_count=0; // number of loads from object field
U_32 ob_fld_field_count=0; // number of fields of object field
U_32 ob_fld_unkn_count=0; // number of unknown references of object field
U_32 ob_fld_usage_count=0; // number of object field usage
U_32 ob_stvar_count=0; // number of object stvar
bool storeId = false;
CnGRefs::iterator it1;
CnGRefs::iterator it2;
CnGEdges::iterator ite;
CnGNode* nf = NULL;
CnGNode* vnode = NULL;
CnGNode* rnode = scnode;
U_32 scnode_type = scnode->nodeType;
ob_ref_type = scnode->nodeRefType; // object ref type
if (!check_loc && (ob_ref_type != NR_REF))
return NULL; // vc arrays not scalarized
if (scnode->nodeType == NT_OBJECT && ((Opnd*)scnode->refObj)->getType()->isUnresolvedType()) {
//do not scalarize unresolved types -> resolution can have side effect
return NULL;
}
if (verboseLog) {
os_sc << "=="; printCnGNode(scnode,os_sc);
((Opnd*)scnode->refObj)->printWithType(os_sc);
NamedType* nt = (NamedType*)((Opnd*)scnode->refObj)->getType();
if (nt->isUnresolvedType() || nt->isFinalizable()) {
os_sc << " - finalizable or unresolved";
}
os_sc << std::endl;
os_sc << " =="; ((Opnd*)scnode->refObj)->getInst()->print(os_sc);
os_sc << std::endl;
checkOpndUsage(scnode->opndId);
}
if (verboseLog) {
os_sc << " -------- begin - Ref from node " << scnode->cngNodeId << " - "
<< scnode->opndId << std::endl;
}
if (scnode->outEdges != NULL) {
for (it1 = scnode->outEdges->begin(); it1 != scnode->outEdges->end(); it1++) {
if ((*it1)->edgeType == ET_FIELD) {
ob_fld_count++; // number of object fields
if (verboseLog) {
os_sc<<"++ "<<scnode->cngNodeId<< " -> " <<
(*it1)->cngNodeTo->cngNodeId << " - "<<
(*it1)->cngNodeTo->opndId << std::endl;
}
nf = (*it1)->cngNodeTo; // object field cng node
if (nf->nInst->getOpcode()==Op_LdFieldAddr) { // ???
FieldDesc* fdesc = nf->nInst->
asFieldAccessInst()->getFieldDesc();
if (fdesc->isInitOnly())
ob_fin_fld_count++;
}
if (nf->outEdges != NULL ||
(*it1)->cngNodeTo->nInst->getOpcode() != Op_LdArrayBaseAddr) {
ob_fld_usage_count++;
if (verboseLog) {
os_sc << " fld-" << std::endl << " ";
printCnGNode(nf,os_sc); os_sc << std::endl << " ";
(*it1)->cngNodeTo->nInst->print(os_sc); os_sc << std::endl;
}
}
if (nf->outEdges != NULL) {
for (it2 = nf->outEdges->begin( ); it2 != nf->outEdges->end( ); it2++ ) {
if (verboseLog) {
os_sc << " " << edgeTypeToString(*it2) << std::endl;
}
switch ((*it2)->edgeType) {
case ET_POINT: ob_fld_ldind_count++; break;
case ET_DEFER: ob_fld_stind_count++; break;
case ET_FIELD: ob_fld_field_count++; break;
default: ob_fld_unkn_count++;
}
if (verboseLog) {
CnGNode* node = NULL;
if ((node=findCnGNode_id((*it2)->cngNodeTo->cngNodeId))!=NULL) {
os_sc << " ";
printCnGNode(node,os_sc); os_sc << std::endl << " ";
node->nInst->print(os_sc); os_sc << std::endl;
os_sc << " ";
(*it2)->edgeInst->print(os_sc);
os_sc << std::endl;
}
}
}
}
} else {
if ((*it1)->cngNodeTo->nInst->getOpcode() == Op_StVar) {
ob_stvar_count++;
if (ob_stvar_count == 1) {
vnode =(*it1)->cngNodeTo;
}
} else {
ob_nfld_count++;
}
if (verboseLog) {
os_sc << " not_fld " << edgeTypeToString(*it1) << " ";
(*it1)->cngNodeTo->nInst->print(os_sc); os_sc << std::endl;
}
}
}
}
if (verboseLog) {
os_sc << " -------- end - Ref from node " << std::endl;
}
U_32 n=scnode->cngNodeId;
if (verboseLog) {
os_sc << " -------- begin - Ref to node " << scnode->cngNodeId << " - "
<< scnode->opndId << std::endl;
}
for (ite = cngEdges->begin( ); ite != cngEdges->end( ); ite++ ) {
for (it2 = (*ite)->refList->begin( ); it2 != (*ite)->refList->end( ); it2++ ) {
if ((*it2)->cngNodeTo->cngNodeId == n) {
Inst* ii=(*ite)->cngNodeFrom->nInst;
U_32 opc = ii->getOpcode();
if (opc == Op_IndirectMemoryCall || opc == Op_DirectCall) {
if (opc == Op_IndirectMemoryCall)
vcall_count++;
else
call_count++;
} else
ref_to_obj_count++; // number of ref to object
if (verboseLog) {
os_sc << " Ref to object. Edge: " << (*ite)->cngNodeFrom->cngNodeId
<< " - " << (*ite)->cngNodeFrom->opndId << " -> "
<< (*it2)->cngNodeTo->cngNodeId
<< " - " << (*it2)->cngNodeTo->opndId << std::endl << " ";
printCnGNode((*ite)->cngNodeFrom,os_sc);
os_sc << std::endl << " ";
ii->print(os_sc); os_sc << std::endl;
if (ii->getOpcode()==Op_IndirectMemoryCall) {
printCallMethodName(ii, os_sc);
}
}
}
}
}
if (verboseLog) {
os_sc << " -------- end - Ref to node " << std::endl;
}
if (ob_nfld_count == 0 &&
( (scnode_type == NT_OBJECT && ref_to_obj_count == 0)
|| (scnode_type == NT_LDOBJ && ref_to_obj_count == 1 && ob_stvar_count == 0) ) ) {
if (scnode_type == NT_LDOBJ) {
if (ob_fin_fld_count==ob_fld_usage_count) {
if ( (check_loc && (getEscState(scnode)==NO_ESCAPE)) ||
(!check_loc && (getEscState(scnode)!=NO_ESCAPE)) ) {
storeId = true;
} else {
if (verboseLog) {
os_sc << "----scalar no opt: check_loc " << check_loc
<< " state " << getEscState(scnode) << std::endl;
}
}
} else {
if (verboseLog) {
os_sc << "----scalar no opt: LOBJ final fields " << ob_fin_fld_count
<< " used field " << ob_fld_usage_count << std::endl;
}
}
goto MM;
}
if (ob_ref_type == NR_REF) { // NT_OBJECT - object
if (ob_stvar_count == 1) { // find ldvar target operand
if (ob_fin_fld_count!=ob_fld_usage_count) {
if (verboseLog) {
os_sc << "----scalar no opt: stvar=1 final fields " << ob_fin_fld_count
<< " used field " << ob_fld_usage_count << std::endl;
}
goto MM;
}
if (verboseLog) {
os_sc << "************* " << ((Opnd*)scnode->refObj)->getType()->getName() << std::endl;
}
assert(vnode!=NULL);
CnGNode* lobj = getLObj(vnode); // scalarizable load object
if (lobj != NULL) {
if (verboseLog) {
printOriginObjects(lobj->nInst,false," ");
}
bool notnullsrcs = checkVVarSrcs(lobj->nInst);
if (verboseLog) {
os_sc << "----checkCnG: stvar=1 checkVVSrcs " << notnullsrcs << std::endl;
}
if (!notnullsrcs) {
goto MM;
}
if (verboseLog) {
os_sc << "----check srcs opernds for optimized load object (cng node): "
<< lobj->cngNodeId << std::endl;
}
rnode = checkCnGtoScalarize(lobj,check_loc);
if (rnode!=NULL) {
storeId =true;
}
}
goto MM;
}
// to optimize newobj target operand
if (check_loc) { //local object
assert(vcall_count==0 && call_count==0);
storeId = true;
goto MM;
}
// to optimize escaped object
if (do_scalar_repl_only_final_fields_in_use) {
if (ob_fin_fld_count==ob_fld_usage_count) {
storeId = true;
} else {
if (verboseLog) {
os_sc << "----scalar no opt: onlyFF final fields " << ob_fin_fld_count
<< " used field " << ob_fld_usage_count << std::endl;
}
}
} else {
if (ob_fin_fld_count==ob_fld_usage_count) { // objects with only final fields
storeId = true;
} else {
// not global escaped objects may be scalarized
if (getEscState(scnode)!=GLOBAL_ESCAPE && getVirtualCall(scnode)==0) {
storeId = true;
} else {
if (verboseLog) {
os_sc << "----scalar no opt: GLOBAL, fin.flds " << ob_fin_fld_count
<< " used flds " << ob_fld_usage_count << std::endl;
}
}
}
}
goto MM;
}
// NT_OBJECT - array
if (ob_fld_usage_count <= 1 && check_loc && ob_stvar_count == 0) {
storeId = true;
} else {
if (verboseLog) {
os_sc << "----scalar no opt: arr: fld " << ob_fld_count
<< " used flds " << ob_fld_usage_count << std::endl;
}
}
} else {
if (verboseLog) {
os_sc << "----scalar no opt: ref to " << ref_to_obj_count << " not field "
<< ob_nfld_count << " obj stvar " << ob_stvar_count << std::endl;
}
}
MM:
if (verboseLog) {
os_sc << "----checkCnG: ntype " << scnode->nodeType
<< " flds " << ob_fld_count
<< " not flds " << ob_nfld_count
<< " final flds " << ob_fin_fld_count
<< " used flds " << ob_fld_usage_count
<< " vcalls " << vcall_count
<< " calls " << call_count
<< " stored " << ob_fld_stind_count
<< " loaded " << ob_fld_ldind_count
<< " others " << ob_fld_field_count
<< " ref to " << ref_to_obj_count
<< " stvar " << ob_stvar_count
<< " unkn.refs " << ob_fld_unkn_count << std::endl;
}
if (storeId) {
if (verboseLog) {
os_sc << "----scalar may be opt: "; printCnGNode(scnode,os_sc);
os_sc << std::endl;
}
return rnode;
}
if (verboseLog) {
os_sc << "----scalar no opt: "; printCnGNode(scnode,os_sc);
os_sc << std::endl;
}
return NULL;
} // checkCnGtoScalarize(CnGNode* scnode, bool check_loc)
double
EscAnalyzer::checkLocalPath(Inst* nob_inst) {
double prob = 0;
Node* node = nob_inst->getNode();
Opnd* objOpnd = nob_inst->getDst();
U_32 objId = objOpnd ->getId();
if (verboseLog) {
os_sc << " -------- Find local path for "; FlowGraph::printLabel(os_sc,node);
os_sc << " id." << node->getId() << " ";
nob_inst->print(os_sc); os_sc << std::endl;
}
scannedObjs->clear();
scannedObjsRev->clear(); // to store ids of unsuccessful nodes
scannedSucNodes->clear(); // to store ids of unsuccessful nodes
if (node->getKind() != Node::Kind_Exit)
prob = checkNextNodes(node,objId,0);
if (verboseLog) {
double enc = irManager.getFlowGraph().getEntryNode()->getExecCount();
os_sc << " Path count " << prob << " ENTRY node count " << enc
<< " exec_count_mult " << ec_mult << std::endl;
if (prob!=0 && prob>=enc*ec_mult)
os_sc << " -------- Local path found " << std::endl;
else
os_sc << " -------- Local path not found " << std::endl;
}
return prob;
} // checkLocalPath(Inst* nob_inst)
double
EscAnalyzer::checkNextNodes(Node* n, U_32 obId, double cprob) {
Node* node = n;
Inst *headInst = (Inst*)node->getFirstInst();
Opnd* opnd;
Edges::const_iterator eit;
double cnprob = node->getExecCount();
double r = cnprob>cprob?cnprob:cprob;
double no = -4;
if (node->getKind()==Node::Kind_Exit) {
if (verboseLog) {
os_sc << " **** Node EXIT : "; FlowGraph::printLabel(os_sc,node);
os_sc << " id." << node->getId() << " execCount " << node->getExecCount()
<< " in prob " << cprob << std::endl;
}
return r;
}
if (scannedObjs->size()!=0) {
if (checkScannedObjs(node->getId())) {
if (scannedSucNodes->size()!=0) {
if (checkScannedSucNodes(node->getId()))
return cprob;
}
if (scannedObjsRev->size()!=0) {
if (checkScannedObjsRev(node->getId()))
return no;
}
return no; // node scan is not completed
}
}
for (Inst* inst=headInst->getNextInst();inst!=NULL;inst=inst->getNextInst()) {
if (inst->getOpcode()==Op_IndirectMemoryCall || inst->getOpcode()==Op_DirectCall) {
U_32 nsrc = inst->getNumSrcOperands();
for (U_32 i=0; i<nsrc; i++) {
opnd=inst->getSrc(i);
if (opnd->getId()==obId) {
if (verboseLog) {
inst->print(os_sc); os_sc << std::endl;
}
return no;
}
}
}
}
scannedObjs->push_back(node->getId());
Node* tn1;
Node* tn2;
double r0=-1;
double r1=-1;
double r2=-1;
if ((tn1=node->getUnconditionalEdgeTarget())!=NULL) {
r0 = checkNextNodes(tn1,obId,r);
} else {
if ((tn1=node->getTrueEdgeTarget())!=NULL) {
r1 = checkNextNodes(tn1,obId,r);
}
if ((tn2=node->getFalseEdgeTarget())!=NULL) {
r2 = checkNextNodes(tn2,obId,r);
}
if (r1==-1 && r2==-1)
r0=no;
else
r0=r1>r2?r1:r2;
}
if (r0==no) {
scannedObjsRev->push_back(node->getId());
return r0;
} else {
scannedSucNodes->push_back(node->getId());
}
if (r0>r)
return r0;
return r;
} // checkNextNodes(Node* n, U_32 obId, double cprob))
void
EscAnalyzer::restoreEOCreation(Insts* vc_insts, ScObjFlds* scObjFlds, VarOpnd* ob_var_opnd, U_32 oid) {
Insts::iterator itvc;
InstFactory& _instFactory = irManager.getInstFactory();
ControlFlowGraph& fg = irManager.getFlowGraph();
OpndManager& _opndManager = irManager.getOpndManager();
TypeManager& _typeManager = irManager.getTypeManager();
Node* node_before = NULL; // node with call inst before opt
Node* node_obj = NULL; // node with restored newobj after opt
Node* node_obj1 = NULL; // node with restored obj fields init after opt
Node* node_var = NULL; // node with call inst after opt or chknull tau
Node* node_var1 = NULL; // node with call inst after opt
Node* node_after1 = NULL; // node with field var opnds updating after call
ScObjFlds::iterator ito;
const bool splitAfter = true;
SsaTmpOpnd* ob_opnd = NULL;
for (itvc = vc_insts->begin( ); itvc != vc_insts->end( ); itvc++ ) {
Inst* vc = *itvc;
U_32 i;
U_32 nsrc = vc->getNumSrcOperands();
for (i=0; i<nsrc; i++) {
Opnd* opnd=vc->getSrc(i);
if (opnd->getId()==oid) {
break;
}
}
if (i>=nsrc) {
continue;
}
node_before=vc->getNode();
Node* dispatchNode = node_before->getExceptionEdgeTarget(); //now object allocation inst will be connected to this dispatch
assert(dispatchNode);
node_obj1 = NULL;
node_after1 = NULL;
node_var1 = NULL;
if (verboseLog) {
os_sc << "++++ objectCreate: before" << std::endl;
FlowGraph::print(os_sc,node_before);
os_sc << "++++ objectCreate: before end" << std::endl;
}
// loading object var opnd
ob_opnd = _opndManager.createSsaTmpOpnd(ob_var_opnd->getType());
Inst* ldobj=_instFactory.makeLdVar(ob_opnd,ob_var_opnd);
ldobj->insertBefore(vc);
// reset call inst parameters
for (U_32 i1=0; i1<nsrc; i1++) {
if (vc->getSrc(i1)->getId()==oid) {
vc->setSrc(i1,ob_opnd );
}
if (Type::isTau(vc->getSrc(i1)->getType()->tag)) {
Inst* tau_inst = NULL;
Insts::iterator iit;
U_32 to_id = vc->getSrc(i1)->getId();
for (iit=checkInsts->begin(); iit!=checkInsts->end(); iit++) {
if ((*iit)->getDst()->isNull()) {
continue;
}
if ((*iit)->getDst()->getId()!=to_id) {
continue;
}
Inst* ti = *iit;
U_32 ti_oc = ti->getOpcode();
if (ti_oc == Op_TauCheckNull || ti_oc == Op_TauIsNonNull || ti_oc == Op_TauHasType) {
tau_inst = NULL;
SsaTmpOpnd* to = _opndManager.createSsaTmpOpnd(_typeManager.getTauType());
if (ti_oc == Op_TauCheckNull) {
tau_inst = _instFactory.makeTauCheckNull(to,ob_opnd);
}
if (ti_oc == Op_TauIsNonNull) {
tau_inst = _instFactory.makeTauIsNonNull(to,ob_opnd);
}
if (ti_oc == Op_TauHasType) {
tau_inst = _instFactory.makeTauHasType(to,ob_opnd,ti->asTypeInst()->getTypeInfo());
}
if (tau_inst != NULL) {
break;
}
}
}
if (tau_inst == NULL) {
continue;
}
if (verboseLog) {
os_sc << "---- tau_inst can throw " << tau_inst->getOperation().canThrow() << " ";
tau_inst->print(os_sc); os_sc << std::endl;
os_sc << std::endl;
}
assert(vc->getBCOffset()!=ILLEGAL_BC_MAPPING_VALUE);
tau_inst->setBCOffset(vc->getBCOffset());
tau_inst->insertBefore(vc);
vc->setSrc(i1,tau_inst->getDst());
if (tau_inst->getOperation().canThrow() == true) {
node_var1=fg.splitNodeAtInstruction(tau_inst,splitAfter,false,
_instFactory.makeLabel());
fg.addEdge(tau_inst->getNode(),fg.getUnwindNode());
}
}
}
// adding newobj inst
SsaTmpOpnd* nob_opnd = _opndManager.createSsaTmpOpnd(ob_var_opnd->getType());
Inst* newobj=_instFactory.makeNewObj(nob_opnd,ob_var_opnd->getType());
newobj->insertBefore(ldobj);
newobj->setBCOffset(0);
// storing created newobj result in object var opnd
Inst* stvobj=_instFactory.makeStVar(ob_var_opnd,nob_opnd);
stvobj->insertBefore(ldobj);
// node with call inst after opt
node_var=fg.splitNodeAtInstruction(stvobj,splitAfter,false,_instFactory.makeLabel());
// checking, if the object is created goto node_var node
SsaTmpOpnd* ob_opnd_as_flag = _opndManager.createSsaTmpOpnd(ob_var_opnd->getType());
_instFactory.makeLdVar(ob_opnd_as_flag,ob_var_opnd)->insertBefore(newobj);
Inst* branch_inst = _instFactory.makeBranch(Cmp_NonZero, ob_opnd_as_flag->getType()->tag,
ob_opnd_as_flag, (LabelInst*)(node_var->getFirstInst()));
branch_inst->insertBefore(newobj);
// node with newobj instruction after opt
node_obj=fg.splitNodeAtInstruction(branch_inst,splitAfter,false,_instFactory.makeLabel());
fg.addEdge(node_before, node_var);
// created object field initialization
ScObjFld* sco = NULL;
if (scObjFlds->size() > 0) {
Opnd* tau_op = _opndManager.createSsaTmpOpnd(_typeManager.getTauType());
_instFactory.makeTauUnsafe(tau_op)->insertBefore(branch_inst);
for (ito = scObjFlds->begin( ); ito != scObjFlds->end( ); ito++ ){
sco = (*ito);
if (sco->ls_insts->size()==0) {
continue;
}
Type* fl_type = NULL;
Type* type = NULL;
Inst* ii = sco->ls_insts->front();
Inst* iadr = NULL;
if (ii->getOpcode()==Op_TauStInd) {
iadr=ii->getSrc(1)->getInst();
fl_type = ii->getSrc(1)->getType()->asPtrType()->getPointedToType();
type = ii->getSrc(0)->getType();
} else {
iadr=ii->getSrc(0)->getInst();
fl_type = ii->getSrc(0)->getType()->asPtrType()->getPointedToType();
type = ii->getDst()->getType();
}
assert(iadr->getOpcode()==Op_LdFieldAddr); // only esc.objects may be optimized
bool compress = (fl_type->isCompressedReference() &&
!type->isCompressedReference());
Modifier compressMod = Modifier(compress ? AutoCompress_Yes
: AutoCompress_No);
Modifier mod = (compInterface.needWriteBarriers())?
(Modifier(Store_WriteBarrier)|compressMod) : (Modifier(Store_NoWriteBarrier)|compressMod);
SsaTmpOpnd* fl_tmp_opnd_st = _opndManager.createSsaTmpOpnd(type);
Inst* ldflvar_inst = _instFactory.makeLdVar(fl_tmp_opnd_st, sco->fldVarOpnd);
if (sco->isFinalFld) {
ldflvar_inst->insertBefore(stvobj); // after newobj
} else {
ldflvar_inst->insertAfter(ldobj); // after ldvar obj_var_opnd
}
Opnd* dst = _opndManager.createSsaTmpOpnd(iadr->getDst()->getType());
FieldDesc* fd = iadr->asFieldAccessInst()->getFieldDesc();
Inst* ldfladr_inst = NULL;
if (sco->isFinalFld) {
ldfladr_inst = _instFactory.makeLdFieldAddr(dst,nob_opnd,fd);
ldfladr_inst->insertBefore(stvobj); // after newobj
} else {
ldfladr_inst = _instFactory.makeLdFieldAddr(dst,ob_opnd,fd);
ldfladr_inst->insertAfter(ldflvar_inst); // after ldvar ob_var_opnd
}
Inst* nstind=_instFactory.makeTauStInd(mod,type->tag,
fl_tmp_opnd_st,dst,tau_op,tau_op,tau_op);
if (sco->isFinalFld) {
nstind->insertBefore(stvobj);
continue;
} else {
nstind->insertAfter(ldfladr_inst);
}
// updating non-final field var.opnds after call
if (node_after1 == NULL) {
node_after1=fg.createBlockNode(_instFactory.makeLabel());
}
// loading field value
SsaTmpOpnd* fl_tmp_opnd_ld = _opndManager.createSsaTmpOpnd(type);
bool comprRefs = compressedReferencesArg
|| (VMInterface::areReferencesCompressed());
Modifier mod1 = comprRefs ? AutoCompress_Yes : AutoCompress_No;
Inst* ldf = _instFactory.makeTauLdInd(mod1,type->tag,fl_tmp_opnd_ld,dst,
tau_op,tau_op);
node_after1->appendInst(ldf);
// storing field value in field var opnd
Inst* stv = _instFactory.makeStVar(sco->fldVarOpnd,fl_tmp_opnd_ld);
node_after1->appendInst(stv);
}
if (node_after1 != NULL) {
if (verboseLog) {
os_sc << "!!!! to restore not final fields " << std::endl;
}
Node* node_call = node_var;
if (node_var1 != NULL) {
node_call = node_var1;
}
// next node after node with call inst
Node* node_after = node_call->getUnconditionalEdgeTarget();
// inserting node with updating field var opnds
fg.removeEdge(node_call->getUnconditionalEdge());
fg.addEdge(node_call,node_after1);
fg.addEdge(node_after1,node_after);
}
}
node_obj1=fg.splitNodeAtInstruction(newobj,splitAfter,false, _instFactory.makeLabel());
fg.addEdge(node_obj,dispatchNode);
if (verboseLog) {
os_sc << "++++ objectCreate: after" << std::endl;
FlowGraph::print(os_sc,node_before);
FlowGraph::print(os_sc,node_obj);
if (node_obj1 != NULL) {
FlowGraph::print(os_sc,node_obj1);
}
FlowGraph::print(os_sc,node_var);
if (node_var1 != NULL) {
FlowGraph::print(os_sc,node_var1);
}
if (node_after1 != NULL) {
FlowGraph::print(os_sc,node_after1);
}
os_sc << "++++ objectCreate: after end" << std::endl;
}
}
} // restoreEOCreation(Insts* vc_insts, ScObjFlds* objs, VarOpnd* ob_var_opnd,...)
void
EscAnalyzer::removeInst(Inst* reminst) {
ControlFlowGraph& fg = irManager.getFlowGraph();
Edge* excedge = NULL;
if (reminst->getNode()!=NULL) {
if (shortLog) {
Node* node = reminst->getNode();
os_sc <<"--rmInst done: CFGnode "; FlowGraph::printLabel(Log::out(), node);
os_sc << " "; reminst->print(os_sc); os_sc << std::endl;
}
if (reminst->getOperation().canThrow()==true) {
excedge = (Edge*)reminst->getNode()->getExceptionEdge();
assert(excedge != NULL);
if (shortLog) {
os_sc <<"--rmEdge done: to "; FlowGraph::printLabel(Log::out(), excedge->getTargetNode()); os_sc << std::endl;
}
fg.removeEdge(excedge);
}
reminst->unlink();
} else {
if (shortLog) {
os_sc <<"--rmInst null: CFGnode NULL "; reminst->print(os_sc); os_sc << std::endl;
}
}
} // removeInst(Inst* reminst)
void
EscAnalyzer::fixMethodEndInsts(U_32 ob_id) {
Insts::iterator itmei;
InstFactory& _instFactory = irManager.getInstFactory();
OpndManager& _opndManager = irManager.getOpndManager();
for (itmei = methodEndInsts->begin( ); itmei != methodEndInsts->end( ); itmei++ ) {
Inst* mei = *itmei;
U_32 i = 0;
U_32 nsrc = mei->getNumSrcOperands();
if (nsrc == 0)
continue;
Opnd* o = mei->getSrc(i);
if (o->getId() != ob_id)
continue;
if (verboseLog) {
os_sc << "++++ Op_MethodEnd " << std::endl;
mei->print(os_sc); os_sc << std::endl;
os_sc << " -- replaced by " << std::endl;
}
SsaTmpOpnd* null_opnd = _opndManager.createSsaTmpOpnd(o->getType());
_instFactory.makeLdNull(null_opnd)->insertBefore(mei);
mei->setSrc(i,null_opnd);
if (verboseLog) {
mei->getPrevInst()->print(os_sc); os_sc << std::endl;
mei->print(os_sc); os_sc << std::endl;
os_sc << "++++ " << std::endl;
}
}
} // fixMethodEndInsts(U_32 ob_id)
EscAnalyzer::CnGNode*
EscAnalyzer::getLObj(CnGNode* vval) {
CnGNode* n = vval;
while (n->nodeType != NT_LDOBJ) {
if (n->nodeType!=NT_VARVAL)
return NULL;
if (n->outEdges == NULL)
return NULL;
if ((n->outEdges)->size()!=1)
return NULL;
n=(n->outEdges)->front()->cngNodeTo;
}
return n;
} //getLObj(CnGNode* vval)
bool
EscAnalyzer::checkVVarSrcs(Inst* inst) {
Inst* inst1;
U_32 nsrc=inst->getNumSrcOperands();
std::string text = " checkVVS ";
bool res = true;
if (scannedObjs->size()!=0) {
if (checkScannedObjs(inst->getId())) {
if (verboseLog) {
os_sc << "instId " << inst->getId()
<< " . . . returns false" << std::endl;
}
return false;
}
}
if (verboseLog) {
os_sc << text;
inst->print(os_sc);
os_sc << std::endl;
if (inst->getOpcode()==Op_TauLdInd || inst->getOpcode()==Op_LdVar) { // ldind,ldvar
Opnd *dst = inst->getDst();
CnGNode* n = findCnGNode_op(dst->getId());
if (n != NULL) {
os_sc<< text << " ";
printCnGNode(n,os_sc);
os_sc<< std::endl;
}
}
switch (inst->getOpcode()) {
case Op_LdRef: // ldref
case Op_NewObj: // newobj
case Op_NewArray: // newarray
case Op_NewMultiArray: // newmultiarray
case Op_DefArg: // defarg
{
CnGNode* n = findCnGNode_in(inst->getId());
if (n != NULL) {
os_sc << text << " ";
printCnGNode(n,os_sc);
os_sc << std::endl;
}
break;
}
default:
break;
}
}
if (inst->getOpcode()==Op_DirectCall || inst->getOpcode()==Op_IndirectMemoryCall) {
return false;
}
if (nsrc == 0) {
if (inst->getOpcode() == Op_LdStaticAddr) {
FieldDesc* fd = inst->asFieldAccessInst()->getFieldDesc();
const char* ptn = fd->getParentType()->getName();
if (checkObjectType(ptn) && strcmp(fd->getName(),"CACHE")==0 ) {
return true;
} else {
return false;
}
}
if (inst->getOpcode() == Op_NewObj || inst->getOpcode() == Op_NewArray
|| inst->getOpcode() == Op_NewMultiArray) {
return true;
}
if (inst->getOpcode() == Op_LdRef || inst->getOpcode() == Op_DefArg ) {
return false;
}
}
scannedObjs->push_back(inst->getId());
switch (inst->getOpcode()) {
case Op_TauLdInd: // ldind
case Op_AddScaledIndex: // addindex
inst1 = inst->getSrc(0)->getInst();
res = checkVVarSrcs(inst1);
break;
case Op_TauStInd: // stind
for (U_32 i=0; i<2; i++) {
inst1 = inst->getSrc(i)->getInst();
res = checkVVarSrcs(inst1);
}
break;
default:
for (U_32 i=0; i<nsrc; i++) {
inst1 = inst->getSrc(i)->getInst();
bool res1 = checkVVarSrcs(inst1);
res = res && res1;
}
}
scannedObjs->pop_back();
if (verboseLog) {
os_sc << " 1 returns " << res << std::endl;
}
return res;
} // checkVVarSrcs(Inst* inst)
bool
EscAnalyzer::checkObjectType(const char* otn) {
if ((strcmp(otn,"java/lang/Integer") == 0) || (strcmp(otn,"java/lang/Short") == 0)
|| (strcmp(otn,"java/lang/Long") == 0) || (strcmp(otn,"java/lang/Character") == 0)
|| (strcmp(otn,"java/lang/Integer$valueOfCache") == 0)
|| (strcmp(otn,"java/lang/Short$valueOfCache") == 0)
|| (strcmp(otn,"java/lang/Long$valueOfCache") == 0)
|| (strcmp(otn,"java/lang/Character$valueOfCache") == 0) ) {
return true;
}
return false;
}
bool
EscAnalyzer::checkObjFlds(ScObjFlds* nscObjFlds, ScObjFlds* lscObjFlds) {
ScObjFlds::iterator it1;
ScObjFlds::iterator it2;
if (nscObjFlds->size() == 0) {
return true;
}
if (lscObjFlds->size() == 0) {
return false;
}
for (it1=lscObjFlds->begin(); it1!=lscObjFlds->end(); it1++) {
for (it2=nscObjFlds->begin(); it2!=nscObjFlds->end(); it2++) {
if ((*it1)->fd == (*it2)->fd) {
break;
}
return false;
}
}
return true;
} // checkObjFlds(ScObjFlds* nscObjFlds, ScObjFlds* scObjFlds)
void
EscAnalyzer::fixCheckInsts(U_32 opId) {
Insts::iterator iit;
Edge* excedge;
if (checkInsts == NULL) {
return;
}
os_sc << " checkInsts " << checkInsts->size() << std::endl;
for (iit=checkInsts->begin(); iit!=checkInsts->end(); iit++) {
if ((*iit)->getSrc(0)->getId()!=opId) {
continue;
}
if (verboseLog) {
os_sc << " ** "; (*iit)->print(os_sc); os_sc << std::endl;
}
Inst* inst = (*iit);
U_32 opcode = inst->getOpcode();
if (opcode == Op_Branch) {
excedge = NULL;
if (inst->getComparisonModifier()==Cmp_Zero) {
excedge = inst->getNode()->getTrueEdge();
}
if (inst->getComparisonModifier()==Cmp_NonZero) {
excedge = inst->getNode()->getFalseEdge();
}
if (verboseLog) {
os_sc <<"-- to remove edge: to ";
((Inst*)( excedge->getTargetNode()->getLabelInst() ))->print(os_sc);
os_sc << std::endl;
}
if (excedge != NULL) {
irManager.getFlowGraph().removeEdge(excedge);
removeInst(inst);
}
}
if (opcode == Op_TauIsNonNull || opcode == Op_TauCheckNull || opcode == Op_TauHasType) {
if (inst->getOperation().canThrow()==true) {
excedge = (Edge*)inst->getNode()->getExceptionEdge();
if (verboseLog) {
os_sc <<"-- exc edge to ";
((Inst*)(excedge->getTargetNode()->getLabelInst()))->print(os_sc);
os_sc << std::endl;
}
}
removeInst(inst);
}
}
} // fixCheckInsts(U_32 opId)
void
EscAnalyzer::checkToScalarizeFinalFiels(CnGNode* onode, ScObjFlds* scObjFlds) {
ScObjFlds::iterator ito;
ScObjFld* sco = NULL;
bool do_fsc = false;
OpndManager& _opndManager = irManager.getOpndManager();
InstFactory& _instFactory = irManager.getInstFactory();
TypeManager& _typeManager = irManager.getTypeManager();
if (verboseLog) {
os_sc << "########################" << std::endl;
printCnGNode(onode,os_sc); os_sc << std::endl;
}
scObjFlds->clear();
collectStLdInsts(onode, scObjFlds);
if (scObjFlds->size() != 0) {
if (verboseLog) {
os_sc << " used fields: " << scObjFlds->size() << " final fields exist: ";
}
for (ito = scObjFlds->begin( ); ito != scObjFlds->end( ); ito++ ){
sco = (*ito);
if (verboseLog) {
os_sc << sco->isFinalFld << " ";
}
if (sco->isFinalFld) {
do_fsc = true;
}
if (verboseLog) {
os_sc << " field usage : " << sco->ls_insts->size();
}
}
if (verboseLog) {
os_sc << std::endl;
}
}
if (verboseLog) {
if (scObjFlds->size() != 0 && do_fsc) {
printCnGNode(onode,os_sc); os_sc << std::endl;
os_sc << " ############# try to do" << std::endl;
} else {
os_sc << " ############# do_fsc " << do_fsc << std::endl;
}
os_sc << "# #######################" << std::endl;
}
if (onode->nodeType == NT_LDOBJ) {
for (ito = scObjFlds->begin( ); ito != scObjFlds->end( ); ito++ ){
sco = (*ito);
if (!sco->isFinalFld || sco->ls_insts->size() < 2) {
continue;
}
Type* fl_type = NULL;
Type* fl_type1 = NULL;
Inst* ii = sco->ls_insts->front();
Inst* iadr = NULL;
if (ii->getOpcode()==Op_TauStInd) {
iadr=ii->getSrc(1)->getInst();
fl_type1 = ii->getSrc(1)->getType()->asPtrType()->getPointedToType();
fl_type = ii->getSrc(0)->getType();
} else {
iadr=ii->getSrc(0)->getInst();
fl_type1 = ii->getSrc(0)->getType()->asPtrType()->getPointedToType();
fl_type = ii->getDst()->getType();
}
VarOpnd* fl_var_opnd = _opndManager.createVarOpnd(fl_type, false);
sco->fldVarOpnd = fl_var_opnd;
if (verboseLog) {
os_sc<<" PoitedType "; fl_type1->print(os_sc); os_sc <<std::endl;
os_sc<<" OperandType "; fl_type->print(os_sc); os_sc <<std::endl;
}
scalarizeOFldUsage(sco);
if (verboseLog) {
os_sc << "++++ old newobj added fld_var: before" << std::endl;
FlowGraph::print(os_sc,onode->nInst->getNode());
os_sc << "++++ old newobj: before end" << std::endl;
}
bool comprRefs = compressedReferencesArg
|| (VMInterface::areReferencesCompressed());
Modifier mod1 = comprRefs ? AutoCompress_Yes : AutoCompress_No;
Opnd* ld_tau_op = _opndManager.createSsaTmpOpnd(_typeManager.getTauType());
Inst* itau = _instFactory.makeTauUnsafe(ld_tau_op);
itau->insertAfter(onode->nInst);
FieldDesc* fd = iadr->asFieldAccessInst()->getFieldDesc();
Opnd* dst_ld = _opndManager.createSsaTmpOpnd(iadr->getDst()->getType());
Opnd* ob_opnd = (Opnd*)(onode->refObj);
Inst* lda = _instFactory.makeLdFieldAddr(dst_ld,ob_opnd,fd);
lda->insertAfter(itau);
SsaTmpOpnd* fl_tmp_opnd_ld = _opndManager.createSsaTmpOpnd(fl_type);
Inst* ldf = _instFactory.makeTauLdInd(mod1,fl_var_opnd->getType()->tag,
fl_tmp_opnd_ld,dst_ld,ld_tau_op,ld_tau_op);
ldf->insertAfter(lda);
Inst* stv = _instFactory.makeStVar(fl_var_opnd,fl_tmp_opnd_ld);
stv->insertAfter(ldf);
if (verboseLog) {
os_sc << "++++ old newobj added fld_var: after" << std::endl;
FlowGraph::print(os_sc,onode->nInst->getNode());
os_sc << "++++ old newobj: after end" << std::endl;
}
}
}
} // checkToScalarizeFinalFiels(CnGNode* onode, ScObjFlds* scObjFlds)
static void logMethod(MethodPtrType* mpt) {
mpt->print(Log::out()); Log::out() << std::endl;
if (mpt->isUnresolvedMethodPtrType()) {
Log::out() << " isUnresolved: true" << std::endl;
} else {
MethodDesc* mdesc = mpt->getMethodDesc();
logMethod(mdesc);
}
}
static void logMethod(MethodDesc* mdesc) {
Log::out() << " isStatic: " << mdesc->isStatic() << std::endl;
Log::out() << " isFinal: " << mdesc->isFinal() << std::endl;
Log::out() << "---------------" << std::endl;
Log::out() << " NumParams: " << mdesc->getNumParams()<< std::endl;
Log::out() << " isInstance: " << mdesc->isInstance() << std::endl;
Log::out() << " isVirtual: " << mdesc->isVirtual() << std::endl;
Log::out() << " isAbstract: " << mdesc->isAbstract() << std::endl;
Log::out() << " isInstanceInitializer: " << mdesc->isInstanceInitializer() << std::endl;
}
static bool isVMHelperCall(Inst* inst, VM_RT_SUPPORT id) {
VMHelperCallInst* callInst = inst->asVMHelperCallInst();
if (callInst==NULL) {
return false;
}
return callInst->getVMHelperId() == id;
}
} //namespace Jitrino