QModelIndex
APG::TreeModel::insertConstraint( const QModelIndex& thisIdx, const QString& constraintName )
{
int row = thisIdx.row();
if ( thisIdx.isValid() ) {
ConstraintNode* p = static_cast<ConstraintNode*>( thisIdx.internalPointer() );
ConstraintNode* n = 0;
if ( p->getNodeType() == Constraint::ConstraintGroupType ) {
beginInsertRows( thisIdx, 0, 0 );
QString constraintType = ConstraintFactory::instance()->untranslateName( constraintName );
n = ConstraintFactory::instance()->createConstraint( constraintType, p, 0 );
endInsertRows();
if ( n != 0 ) {
connectDCSlotToNode( n );
return createIndex( 0, 0, n );
}
} else {
p = p->parent();
QModelIndex parentIdx = parent( thisIdx );
beginInsertRows( parentIdx, row + 1, row + 1 );
QString constraintType = ConstraintFactory::instance()->untranslateName( constraintName );
n = ConstraintFactory::instance()->createConstraint( constraintType, p, row + 1 );
endInsertRows();
if ( n != 0 ) {
connectDCSlotToNode( n );
return createIndex( row + 1, 0, n );
}
}
}
return thisIdx;
}
void
APG::TreeModel::slotConstraintDataChanged()
{
ConstraintNode* n = static_cast<ConstraintNode*>( sender() );
if ( n ) {
QModelIndex idx = createIndex( n->row(), 0, n );
emit dataChanged( idx, idx );
}
}
QVariant
APG::TreeModel::data( const QModelIndex &index, int role ) const
{
if ( !index.isValid() || ( role != Qt::DisplayRole ) )
return QVariant();
ConstraintNode* n = static_cast<ConstraintNode*>( index.internalPointer() );
if ( index.column() == 0 ) {
return QVariant( n->getName() );
} else {
return QVariant();
}
}
QModelIndex
APG::TreeModel::parent( const QModelIndex& child ) const
{
if ( !child.isValid() )
return QModelIndex();
ConstraintNode* childItem = static_cast<ConstraintNode*>( child.internalPointer() );
ConstraintNode* parentItem = static_cast<ConstraintNode*>( childItem->parent() );
if ( !parentItem || parentItem == m_rootNode )
return QModelIndex();
return createIndex( parentItem->row(), 0, parentItem );
}
int
APG::TreeModel::rowCount( const QModelIndex& parent ) const
{
if ( parent.column() > 0 )
return 0;
ConstraintNode* parentItem;
if ( !parent.isValid() )
parentItem = m_rootNode;
else
parentItem = static_cast<ConstraintNode*>( parent.internalPointer() );
return parentItem->getRowCount();
}
QModelIndex
APG::TreeModel::index( int row, int column, const QModelIndex& parent ) const
{
if ( !hasIndex( row, column, parent ) )
return QModelIndex();
ConstraintNode* parentItem;
if ( !parent.isValid() )
parentItem = m_rootNode;
else
parentItem = static_cast<ConstraintNode*>( parent.internalPointer() );
ConstraintNode* childItem = parentItem->getChild( row );
if ( childItem )
return createIndex( row, column, childItem );
else
return QModelIndex();
}
bool
APG::TreeModel::removeNode( const QModelIndex& index )
{
int row = index.row();
bool r = false;
QModelIndex parentIndex = index.parent();
// prevent removal of root node
if ( parentIndex.isValid() ) {
ConstraintNode* parent;
parent = static_cast<ConstraintNode*>( parentIndex.internalPointer() );
beginRemoveRows( parentIndex, row, row );
r = parent->removeChild( row );
endRemoveRows();
return r;
} else {
return r;
}
}
/*!
* Start constraint solving
*/
void AndersenLCD::processNode(NodeID nodeId) {
numOfIteration++;
if(0 == numOfIteration % OnTheFlyIterBudgetForStat) {
dumpStat();
}
ConstraintNode* node = consCG->getConstraintNode(nodeId);
for (ConstraintNode::const_iterator it = node->outgoingAddrsBegin(), eit = node->outgoingAddrsEnd(); it != eit;
++it) {
processAddr(cast<AddrCGEdge>(*it));
}
for (PointsTo::iterator piter = getPts(nodeId).begin(), epiter = getPts(
nodeId).end(); piter != epiter; ++piter) {
NodeID ptd = *piter;
// handle load
for (ConstraintNode::const_iterator it = node->outgoingLoadsBegin(), eit = node->outgoingLoadsEnd(); it != eit;
++it) {
if(processLoad(ptd, *it))
pushIntoWorklist(ptd);
}
// handle store
for (ConstraintNode::const_iterator it = node->incomingStoresBegin(), eit = node->incomingStoresEnd(); it != eit;
++it) {
if(processStore(ptd, *it))
pushIntoWorklist((*it)->getSrcID());
}
}
// handle copy, call, return, gep
bool lcd = false;
for (ConstraintNode::const_iterator it = node->directOutEdgeBegin(), eit = node->directOutEdgeEnd(); it != eit;
++it) {
if(GepCGEdge* gepEdge = llvm::dyn_cast<GepCGEdge>(*it))
processGep(nodeId,gepEdge);
else if(processCopy(nodeId,*it))
lcd = true;
}
if(lcd)
SCCDetect();
// update call graph
updateCallGraph(getIndirectCallsites());
}
/*!
* Post process node
*/
void AndersenWave::postProcessNode(NodeID nodeId)
{
double insertStart = stat->getClk();
ConstraintNode* node = consCG->getConstraintNode(nodeId);
// handle load
for (ConstraintNode::const_iterator it = node->outgoingLoadsBegin(), eit = node->outgoingLoadsEnd();
it != eit; ++it) {
if (handleLoad(nodeId, *it))
reanalyze = true;
}
// handle store
for (ConstraintNode::const_iterator it = node->incomingStoresBegin(), eit = node->incomingStoresEnd();
it != eit; ++it) {
if (handleStore(nodeId, *it))
reanalyze = true;
}
double insertEnd = stat->getClk();
timeOfProcessLoadStore += (insertEnd - insertStart) / TIMEINTERVAL;
}
