/******************************************************************************
* Copyright (c) 2011 IBM Corporation.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*****************************************************************************/
package com.ibm.wala.cast.js.ipa.callgraph.correlations.extraction;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.Stack;
import com.ibm.wala.cast.tree.CAst;
import com.ibm.wala.cast.tree.CAstControlFlowMap;
import com.ibm.wala.cast.tree.CAstEntity;
import com.ibm.wala.cast.tree.CAstNode;
import com.ibm.wala.cast.tree.CAstSourcePositionMap;
import com.ibm.wala.cast.tree.impl.CAstControlFlowRecorder;
import com.ibm.wala.cast.tree.rewrite.CAstRewriter;
import com.ibm.wala.cast.tree.rewrite.CAstBasicRewriter.NoKey;
import com.ibm.wala.util.collections.HashMapFactory;
import com.ibm.wala.util.collections.HashSetFactory;
import com.ibm.wala.util.collections.Pair;
import com.ibm.wala.util.debug.Assertions;
/**
* Extension of {@link CAstRewriter} which allows adding or deleting control flow edges, and keeps track of
* the current entity.
*
* TODO: This class is an unholy mess. It should be restructured considerably.
*
* @author mschaefer
*
*/
public abstract class CAstRewriterExt extends CAstRewriter<NodePos, NoKey> {
/**
* A control flow edge to be added to the CFG.
*
* @author mschaefer
*/
protected static class Edge {
private CAstNode from;
private Object label;
private CAstNode to;
public Edge(CAstNode from, Object label, CAstNode to) {
assert from != null;
assert to != null;
this.from = from;
this.label = label;
this.to = to;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime + from.hashCode();
result = prime * result + ((label == null) ? 0 : label.hashCode());
result = prime * result + to.hashCode();
return result;
}
@Override
public boolean equals(Object obj) {
if(!(obj instanceof Edge))
return false;
Edge that = (Edge)obj;
return this.from.equals(that.from) &&
(this.label == null ? that.label == null : this.label.equals(that.label)) &&
this.to.equals(that.to);
}
}
private final Map<CAstControlFlowMap, Set<CAstNode>> extra_nodes = HashMapFactory.make();
private final Map<CAstControlFlowMap, Set<Edge>> extra_flow = HashMapFactory.make();
private final Map<CAstControlFlowMap, Set<CAstNode>> flow_to_delete = HashMapFactory.make();
// information about an entity to add to the AST
private static class Entity {
private final CAstNode anchor;
private final CAstEntity me;
public Entity(CAstNode anchor, CAstEntity me) {
assert me != null;
this.anchor = anchor;
this.me = me;
}
@Override
public int hashCode() {
final int prime = 31;
int result = prime + ((anchor == null) ? 0 : anchor.hashCode());
return prime * result + me.hashCode();
}
}
private final HashSet<Entity> entities_to_add = HashSetFactory.make();
private final Stack<CAstEntity> entities = new Stack<CAstEntity>();
public CAstNode addNode(CAstNode node, CAstControlFlowMap flow) {
Set<CAstNode> nodes = extra_nodes.get(flow);
if(nodes == null)
extra_nodes.put(flow, nodes = HashSetFactory.make());
nodes.add(node);
return node;
}
public CAstNode addFlow(CAstNode node, Object label, CAstNode target, CAstControlFlowMap flow) {
Set<Edge> edges = extra_flow.get(flow);
if(edges == null)
extra_flow.put(flow, edges = HashSetFactory.make());
edges.add(new Edge(node, label, target));
return node;
}
public void deleteFlow(CAstNode node, CAstEntity entity) {
CAstControlFlowMap flow = entity.getControlFlow();
Set<CAstNode> tmp = flow_to_delete.get(flow);
if(tmp == null)
flow_to_delete.put(flow, tmp = HashSetFactory.make());
tmp.add(node);
}
protected boolean isFlowDeleted(CAstNode node, CAstEntity entity) {
CAstControlFlowMap flow = entity.getControlFlow();
return flow_to_delete.containsKey(flow) && flow_to_delete.get(flow).contains(node);
}
public CAstEntity getCurrentEntity() {
return entities.peek();
}
public Iterable<CAstEntity> getEnclosingEntities() {
return entities;
}
public void addEntity(CAstNode anchor, CAstEntity entity) {
entities_to_add.add(new Entity(anchor, entity));
}
@Override
protected Map<CAstNode,Collection<CAstEntity>> copyChildren(CAstNode root, Map<Pair<CAstNode,NoKey>,CAstNode> nodeMap, Map<CAstNode,Collection<CAstEntity>> children) {
Map<CAstNode, Collection<CAstEntity>> map = super.copyChildren(root, nodeMap, children);
// extend with local mapping information
for(Iterator<Entity> es = entities_to_add.iterator(); es.hasNext(); ) {
Entity e = es.next();
boolean relevant = NodePos.inSubtree(e.anchor, nodeMap.get(Pair.make(root, null))) || NodePos.inSubtree(e.anchor, root);
if(relevant) {
Collection<CAstEntity> c = map.get(e.anchor);
if(c == null)
map.put(e.anchor, c = HashSetFactory.make());
c.add(e.me);
es.remove();
}
}
return map;
}
@Override
protected CAstNode flowOutTo(Map<Pair<CAstNode, NoKey>, CAstNode> nodeMap,
CAstNode oldSource, Object label, CAstNode oldTarget,
CAstControlFlowMap orig, CAstSourcePositionMap src) {
if(oldTarget == CAstControlFlowMap.EXCEPTION_TO_EXIT)
return oldTarget;
Assertions.UNREACHABLE();
return super.flowOutTo(nodeMap, oldSource, label, oldTarget, orig, src);
}
@Override
protected CAstControlFlowMap copyFlow(Map<Pair<CAstNode,NoKey>,CAstNode> nodeMap, CAstControlFlowMap orig, CAstSourcePositionMap newSrc) {
Map<Pair<CAstNode,NoKey>,CAstNode> nodeMapCopy = HashMapFactory.make(nodeMap);
// delete flow if necessary
// TODO: this is bad; what if one of the deleted nodes occurs as a cflow target?
if(flow_to_delete.containsKey(orig)) {
for(CAstNode node : flow_to_delete.get(orig)) {
nodeMapCopy.remove(Pair.make(node, null));
}
//flow_to_delete.remove(orig);
}
CAstControlFlowRecorder flow = (CAstControlFlowRecorder)super.copyFlow(nodeMapCopy, orig, newSrc);
// extend with local flow information
if(extra_nodes.containsKey(orig)) {
for(CAstNode nd : extra_nodes.get(orig))
flow.map(nd, nd);
}
if(extra_flow.containsKey(orig)) {
for(Edge e : extra_flow.get(orig)) {
CAstNode from = e.from;
Object label = e.label;
CAstNode to = e.to;
if(nodeMap.containsKey(Pair.make(from, null)))
from = nodeMap.get(Pair.make(from, null));
if(nodeMap.containsKey(Pair.make(to, null)))
to = nodeMap.get(Pair.make(to, null));
if(!flow.isMapped(from))
flow.map(from, from);
if(!flow.isMapped(to))
flow.map(to, to);
flow.add(from, to, label);
}
/*
* Here, we would like to say extra_flow.remove(orig) to get rid of the extra control flow
* information, but that would not be correct: a single old cfg may be carved up into several
* new ones, each of which needs to be extended with the appropriate extra flow from the old cfg.
*
* Unfortunately, we now end up extending _every_ new cfg with _all_ the extra flow from the old
* cfg, which doesn't sound right either.
*/
}
return flow;
}
Map<CAstEntity, CAstEntity> rewrite_cache = HashMapFactory.make();
@Override
public CAstEntity rewrite(CAstEntity root) {
// avoid rewriting the same entity more than once
// TODO: figure out why this happens in the first place
if(rewrite_cache.containsKey(root)) {
return rewrite_cache.get(root);
} else {
entities.push(root);
enterEntity(root);
CAstEntity entity = super.rewrite(root);
rewrite_cache.put(root, entity);
leaveEntity(root);
entities.pop();
return entity;
}
}
protected void enterEntity(CAstEntity entity) {}
protected void leaveEntity(CAstEntity entity) {}
public CAstRewriterExt(CAst Ast, boolean recursive, NodePos rootContext) {
super(Ast, recursive, rootContext);
}
}