/*!
* Add Offset(Gep) edge
* Find the base node id of src and connect base node to dst node
* Create gep offset: (offset + baseOff <nested struct gep size>)
*/
bool PAG::addGepEdge(NodeID src, NodeID dst, const LocationSet& ls) {
PAGNode* node = getPAGNode(src);
if (node->hasIncomingVariantGepEdge()) {
/// Since the offset from base to src is variant,
/// the new gep edge being created is also a VariantGepPE edge.
return addVariantGepEdge(src, dst);
}
else {
return addNormalGepEdge(src, dst, ls);
}
}
/*!
* Get a base PAGNode given a pointer
* Return the source node of its connected normal gep edge
* Otherwise return the node id itself
* Size_t offset : gep offset
*/
LocationSet PAG::getLocationSetFromBaseNode(NodeID nodeId) {
PAGNode* node = getPAGNode(nodeId);
PAGEdge::PAGEdgeSetTy& geps = node->getIncomingEdges(PAGEdge::NormalGep);
/// if this node is already a base node
if(geps.empty())
return LocationSet(0);
assert(geps.size()==1 && "one node can only be connected by at most one gep edge!");
PAGNode::iterator it = geps.begin();
const PAGEdge* edge = *it;
assert(isa<NormalGepPE>(edge) && "not a get edge??");
const NormalGepPE* gepEdge = cast<NormalGepPE>(edge);
return gepEdge->getLocationSet();
}
/*!
* Print this PAG graph including its nodes and edges
*/
void PAG::print() {
for (iterator I = begin(), E = end(); I != E; ++I) {
PAGNode* node = I->second;
if (!isa<DummyValPN>(node) && !isa<DummyObjPN>(node)) {
outs() << "node " << node->getId() << " " << *(node->getValue())
<< "\n";
outs() << "\t InEdge: { ";
for (PAGNode::iterator iter = node->getInEdges().begin();
iter != node->getInEdges().end(); ++iter) {
outs() << (*iter)->getSrcID() << " ";
if (NormalGepPE* edge = dyn_cast<NormalGepPE>(*iter))
outs() << " offset=" << edge->getOffset() << " ";
else if (isa<VariantGepPE>(*iter))
outs() << " offset=variant";
}
outs() << "}\t";
outs() << "\t OutEdge: { ";
for (PAGNode::iterator iter = node->getOutEdges().begin();
iter != node->getOutEdges().end(); ++iter) {
outs() << (*iter)->getDstID() << " ";
if (NormalGepPE* edge = dyn_cast<NormalGepPE>(*iter))
outs() << " offset=" << edge->getOffset() << " ";
else if (isa<VariantGepPE>(*iter))
outs() << " offset=variant";
}
outs() << "}\n";
}
outs() << "\n";
}
}
/*!
* Get a base pointer given a pointer
* Return the source node of its connected gep edge if this pointer has
* Otherwise return the node id itself
*/
NodeID PAG::getBaseValNode(NodeID nodeId) {
PAGNode* node = getPAGNode(nodeId);
if (node->hasIncomingEdges(PAGEdge::NormalGep) || node->hasIncomingEdges(PAGEdge::VariantGep)) {
PAGEdge::PAGEdgeSetTy& ngeps = node->getIncomingEdges(PAGEdge::NormalGep);
PAGEdge::PAGEdgeSetTy& vgeps = node->getIncomingEdges(PAGEdge::VariantGep);
assert(((ngeps.size()+vgeps.size())==1) && "one node can only be connected by at most one gep edge!");
PAGNode::iterator it;
if(!ngeps.empty())
it = ngeps.begin();
else
it = vgeps.begin();
assert(isa<GepPE>(*it) && "not a gep edge??");
return (*it)->getSrcID();
}
else
return nodeId;
}
/*!
* Stat null pointers
*/
void AndersenStat::statNullPtr() {
_NumOfNullPtr = 0;
for (PAG::iterator iter = pta->getPAG()->begin(), eiter = pta->getPAG()->end();
iter != eiter; ++iter) {
NodeID pagNodeId = iter->first;
PAGNode* pagNode = iter->second;
PAGEdge::PAGEdgeSetTy& inComingStore = pagNode->getIncomingEdges(PAGEdge::Store);
PAGEdge::PAGEdgeSetTy& outGoingLoad = pagNode->getOutgoingEdges(PAGEdge::Load);
if (inComingStore.empty()==false || outGoingLoad.empty()==false) {
///TODO: change the condition here to fetch the points-to set
PointsTo& pts = pta->getPts(pagNodeId);
if(pta->containBlackHoleNode(pts)) {
_NumOfConstantPtr++;
}
if(pta->containConstantNode(pts)) {
_NumOfBlackholePtr++;
}
if(pts.empty()) {
std::string str;
raw_string_ostream rawstr(str);
if (!isa<DummyValPN>(pagNode) && !isa<DummyObjPN>(pagNode) ) {
// if a pointer is in dead function, we do not care
if(isPtrInDeadFunction(pagNode->getValue()) == false) {
_NumOfNullPtr++;
rawstr << "##Null Pointer : (NodeID " << pagNode->getId()
<< ") PtrName:" << pagNode->getValue()->getName();
wrnMsg(rawstr.str());
//pagNode->getValue()->dump();
}
}
else {
_NumOfNullPtr++;
rawstr << "##Null Pointer : (NodeID " << pagNode->getId();
wrnMsg(rawstr.str());
}
}
}
}
}
/*
* If this is a dummy node or node does not have incoming edges we assume it is not a pointer here
*/
bool PAG::isValidPointer(NodeID nodeId) const {
PAGNode* node = pag->getPAGNode(nodeId);
if ((node->getInEdges().empty() && node->getOutEdges().empty()))
return false;
return node->isPointer();
}
void PTAStat::performStat() {
callgraphStat();
PAG* pag = PAG::getPAG();
u32_t numOfFunction = 0;
u32_t numOfGlobal = 0;
u32_t numOfStack = 0;
u32_t numOfHeap = 0;
u32_t numOfHasVarArray = 0;
u32_t numOfHasVarStruct = 0;
u32_t numOfHasConstArray = 0;
u32_t numOfHasConstStruct = 0;
u32_t numOfScalar = 0;
u32_t numOfConstant = 0;
u32_t fiObjNumber = 0;
u32_t fsObjNumber = 0;
std::set<SymID> memObjSet;
for(PAG::iterator it = pag->begin(), eit = pag->end(); it!=eit; ++it) {
PAGNode* node = it->second;
if(ObjPN* obj = dyn_cast<ObjPN>(node)) {
const MemObj* mem = obj->getMemObj();
if (memObjSet.insert(mem->getSymId()).second == false)
continue;
if(mem->isBlackHoleOrConstantObj())
continue;
if(mem->isFunction())
numOfFunction++;
if(mem->isGlobalObj())
numOfGlobal++;
if(mem->isStack())
numOfStack++;
if(mem->isHeap())
numOfHeap++;
if(mem->isVarArray())
numOfHasVarArray++;
if(mem->isVarStruct())
numOfHasVarStruct++;
if(mem->isConstArray())
numOfHasConstArray++;
if(mem->isConstStruct())
numOfHasConstStruct++;
if(mem->hasPtrObj() == false)
numOfScalar++;
if(mem->isConstant())
numOfConstant++;
if (mem->isFieldInsensitive())
fiObjNumber++;
else
fsObjNumber++;
if(pta->isLocalVarInRecursiveFun(node->getId())) {
localVarInRecursion.set(node->getId());
}
}
}
generalNumMap[TotalNumOfPointers] = pag->getValueNodeNum() + pag->getFieldValNodeNum();
generalNumMap[TotalNumOfObjects] = pag->getObjectNodeNum();
generalNumMap[TotalNumOfFieldObjects] = pag->getFieldObjNodeNum();
generalNumMap[MaxStructSize] = SymbolTableInfo::Symbolnfo()->getMaxStructSize();
generalNumMap[TotalNumOfEdges] = pag->getPAGEdgeNum();
generalNumMap[NumberOfFieldInsensitiveObj] = fiObjNumber;
generalNumMap[NumberOfFieldSensitiveObj] = fsObjNumber;
generalNumMap[NumOfAddrs] = pag->getEdgeSet(PAGEdge::Addr).size();
generalNumMap[NumOfLoads] = pag->getEdgeSet(PAGEdge::Load).size();
generalNumMap[NumOfStores] = pag->getEdgeSet(PAGEdge::Store).size();
generalNumMap[NumOfCopys] = pag->getEdgeSet(PAGEdge::Copy).size();
generalNumMap[NumOfGeps] = pag->getEdgeSet(PAGEdge::NormalGep).size() + pag->getEdgeSet(PAGEdge::VariantGep).size();
generalNumMap[NumOfCalls] = pag->getEdgeSet(PAGEdge::Call).size();
generalNumMap[NumOfReturns] = pag->getEdgeSet(PAGEdge::Ret).size();
generalNumMap[NumOfFunctionObjs] = numOfFunction;
generalNumMap[NumOfGlobalObjs] = numOfGlobal;
generalNumMap[NumOfHeapObjs] = numOfHeap;
generalNumMap[NumOfStackObjs] = numOfStack;
generalNumMap[NumOfObjsHasVarStruct] = numOfHasVarStruct;
generalNumMap[NumOfObjsHasVarArray] = numOfHasVarArray;
generalNumMap[NumOfObjsHasConstStruct] = numOfHasConstStruct;
generalNumMap[NumOfObjsHasConstArray] = numOfHasConstArray;
generalNumMap[NumOfNonPtrObjs] = numOfScalar;
generalNumMap[NumOfIndirectCallSites] = pag->getIndirectCallsites().size();
generalNumMap["TotalCallSite"] = pag->getCallSiteSet().size();
generalNumMap["LocalVarInRecur"] = localVarInRecursion.count();
bitcastInstStat();
branchStat();
}
