Feature/variable renaming

.classpath

@@ -1,8 +1,19 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <classpath>
-	<classpathentry kind="src" path="src/main/java"/>
+	<classpathentry kind="src" output="target/classes" path="src/main/java">
+		<attributes>
+			<attribute name="optional" value="true"/>
+			<attribute name="maven.pomderived" value="true"/>
+		</attributes>
+	</classpathentry>
 	<classpathentry kind="src" path="src/main/rascal"/>
-	<classpathentry kind="src" path="src/test/java"/>
+	<classpathentry kind="src" output="target/test-classes" path="src/test/java">
+		<attributes>
+			<attribute name="optional" value="true"/>
+			<attribute name="maven.pomderived" value="true"/>
+			<attribute name="test" value="true"/>
+		</attributes>
+	</classpathentry>
 	<classpathentry kind="src" path="src/test/rascal"/>
 	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8">
 		<attributes>
@@ -15,5 +26,11 @@
 			<attribute name="maven.pomderived" value="true"/>
 		</attributes>
 	</classpathentry>
+	<classpathentry excluding="**" kind="src" output="target/test-classes" path="src/test/resources">
+		<attributes>
+			<attribute name="maven.pomderived" value="true"/>
+			<attribute name="test" value="true"/>
+		</attributes>
+	</classpathentry>
 	<classpathentry kind="output" path="target/classes"/>
 </classpath>

src/main/java/lang/jimple/util/Pair.java

@@ -1,5 +1,8 @@
 package lang.jimple.util;
 
+import lang.jimple.internal.generated.Type;
+import lang.jimple.internal.generated.Value;
+
 import lombok.AllArgsConstructor;
 import lombok.Data;
 
@@ -9,5 +12,4 @@ public class Pair<First, Second> {
 
 	First first; 
 	Second second; 
-
 }

src/main/rascal/lang/jimple/core/Syntax.rsc

@@ -135,6 +135,7 @@ data Expression
   | lengthOf(Immediate immediate)
   | neg(Immediate immediate) 
   | immediate(Immediate immediate)
+  | phiFunction(Variable variable, list[Variable] definitions)
   ;
 
 data ArrayDescriptor 

src/main/rascal/lang/jimple/decompiler/Decompiler.rsc

@@ -8,7 +8,7 @@ import Exception;
 
 @javaClass{lang.jimple.internal.Decompiler}
 @reflect{for stdout}
-java ClassOrInterfaceDeclaration decompile(loc classFile) throws IO; 
+java ClassOrInterfaceDeclaration decompile(loc classFile) throws IO;
 
 
 

src/main/rascal/lang/jimple/toolkit/ssa/DominanceFrontier.rsc

@@ -0,0 +1,34 @@
+module lang::jimple::toolkit::ssa::DominanceFrontier
+
+import Set;
+import analysis::graphs::Graph;
+import lang::jimple::toolkit::FlowGraph;
+import lang::jimple::toolkit::ssa::DominanceTree;
+
+public map[Node, set[Node]] createDominanceFrontier(FlowGraph flowGraph, map[&T, set[&T]] dominanceTree) {
+	dominanceFrontiers = ();
+
+	for(<origin, child> <- flowGraph) {
+		if(true)
+			dominanceFrontiers = calculateDominanceFrontier(origin, child, dominanceFrontiers, dominanceTree);
+	};
+
+	return dominanceFrontiers;
+}
+
+public map[Node, set[Node]] calculateDominanceFrontier(Node origin, Node destination, map[Node, set[Node]] dominanceFrontier, map[&T, set[&T]] dominanceTree) {
+	temp = origin;
+
+	while(temp != findIdom(dominanceTree, destination)) {
+		originDominanceFrontierValue = if(dominanceFrontier[temp]?) dominanceFrontier[temp]; else {};
+		dominanceFrontier[temp] = originDominanceFrontierValue + {destination};
+
+		temp = findIdom(dominanceTree, temp);
+	};
+
+	return dominanceFrontier;
+}
+
+public bool isJoinNode(FlowGraph flowGraph, Node child) {
+	return size(predecessors(flowGraph, child)) >= 2;
+}

src/main/rascal/lang/jimple/toolkit/ssa/DominanceTree.rsc

@@ -1,16 +1,62 @@
 module lang::jimple::toolkit::ssa::DominanceTree
 
+import demo::Dominators;
+import Set;
+import Relation;
 import lang::jimple::toolkit::FlowGraph;
+import analysis::graphs::Graph;
 
-import List;
+public map[&T, set[&T]] createDominanceTree(Graph[&T] graph) {
+	PRED = graph;
+	ROOT = entryNode();
 
-public map[Node, Node] createDominanceTree(FlowGraph flowGraph) {
-	result = (computeDominator(flowGraph, a): a | <a, _> <- flowGraph);
-	return result;
+	set[&T] rootDominators = reachX(PRED, {ROOT}, {});
+	set[&T] VERTICES = carrier(PRED);
+
+	temp = dominators(PRED, ROOT);
+
+	return (V: (rootDominators - reachX(removeNodeFromGraph(graph, V), {ROOT}, {V}) - {V}) | &T V <- VERTICES );
+}
+
+public map[Node, list[Node]] createAdjacenciesMatrix(FlowGraph flowGraph) {
+	blockTree = ( origin: [] | <origin, _> <- flowGraph);
+
+	for(<origin, destination> <- flowGraph) {
+		blockTree[origin] = blockTree[origin] + [destination];
+	};
+
+	return blockTree;
+}
+
+public map[Node, list[Node]] createIdomTree(map[&T, set[&T]] dominanceTree) {
+	blockTree = ( treeKey: [] | treeKey <- dominanceTree);
+
+	for(treeKey <- dominanceTree) {
+		idom = findIdom(dominanceTree, treeKey);
+
+		if(treeKey != entryNode())
+			blockTree[idom] = blockTree[idom] + [treeKey];
+	};
+
+	return blockTree;
+}
+
+public Graph[&T] removeNodeFromGraph(Graph[&T] graph, &T nodeToRemove) {
+ return { <father, graphChild> | <father, graphChild> <- graph, nodeToRemove != father || nodeToRemove == entryNode() };
 }
 
-public Node computeDominator(FlowGraph flowGraph, Node currentNode) {
-	predecessorNodeList = [a | <a, b> <- flowGraph, b == currentNode];
-	result = if(isEmpty(predecessorNodeList) == true) currentNode; else head(predecessorNodeList);
-	return result;
+
+public Node findIdom(map[&T, set[&T]] dominanceTree, Node child) {
+	ROOT = entryNode();
+	idom = entryNode();
+
+	possibleIdoms = [ father | father <- dominanceTree, child in dominanceTree[father] ];
+
+	for(possibleIdom <- possibleIdoms) {
+		if(size(dominanceTree[possibleIdom]) < size(dominanceTree[idom])) {
+			idom = possibleIdom;
+		};
+	};
+
+	return idom;
 }

src/main/rascal/lang/jimple/toolkit/ssa/Generator.rsc

@@ -0,0 +1,39 @@
+module lang::jimple::toolkit::ssa::Generator
+
+import List;
+
+import lang::jimple::toolkit::FlowGraph;
+import lang::jimple::core::Syntax;
+
+import lang::jimple::toolkit::ssa::DominanceTree;
+import lang::jimple::toolkit::ssa::PhiFunctionInsertion;
+import lang::jimple::toolkit::ssa::DominanceFrontier;
+import lang::jimple::toolkit::ssa::VariableRenaming;
+
+public FlowGraph applySSATransformation(MethodBody methodBody) {
+	FlowGraph flowGraph = forwardFlowGraph(methodBody);
+
+	if(hasUnsupportedInstruction(flowGraph)) // Doest not support invokeStmt and fieldRef rename 
+		return {};
+
+	map[&T, set[&T]] dominanceTree = createDominanceTree(flowGraph);
+	map[&T, set[&T]] dominanceFrontier = createDominanceFrontier(flowGraph, dominanceTree);
+	FlowGraph phiFunctionFlowGraph = insertPhiFunctions(flowGraph, dominanceFrontier);
+	result = applyVariableRenaming(phiFunctionFlowGraph);
+
+	return result;
+}
+
+public bool hasUnsupportedInstruction(FlowGraph flowGraph) {
+	unsupportedList = [ <origin, destination> | <origin, destination> <- flowGraph, unspportedStatement(origin) || unspportedStatement(destination)];
+	
+	return size(unsupportedList) != 0;
+}
+
+public bool unspportedStatement(Node nodeStatement) {
+	switch(nodeStatement) {
+		case stmtNode(invokeStmt(_)): return true;
+		case stmtNode(assign(fieldRef(_, _), _)): return true;
+		default: return false; 
+	}
+}

src/main/rascal/lang/jimple/toolkit/ssa/PhiFunctionInsertion.rsc

@@ -0,0 +1,106 @@
+module lang::jimple::toolkit::ssa::PhiFunctionInsertion
+
+import demo::Dominators;
+import Set;
+import Relation;
+import analysis::graphs::Graph;
+import lang::jimple::toolkit::FlowGraph;
+import lang::jimple::core::Syntax;
+import Type;
+import IO;
+import Node;
+import List;
+
+public FlowGraph insertPhiFunctions(FlowGraph flowGraph, map[&T, set[&T]] dominanceFrontier) {
+	newFlowGraph = { <origin, destination> | <origin, destination> <- flowGraph };
+	variableList = { getStmtVariable(graphNode) | <graphNode, _> <- flowGraph, isVariable(graphNode) };
+	
+	for(Variable variable <- variableList) {
+		F = {}; // set of basic blocks where φ is added
+		W = {}; // set of basic blocks that contain definitions of v
+		
+		for(variableNode <- blocksWithVariable(flowGraph, variable)) { // d ∈ Defs(v)
+			B = variableNode;
+			W = W + {B};
+		};
+		
+		while(size(W) != 0) {
+			// remove a basic block X from W
+			tuple[Node, set[Node]] elements = takeOneFrom(W);
+			X = elements[0];
+			W = elements[1];
+			
+			if(X in dominanceFrontier) { // Avoids NoSuchKey error
+				frontierNodes = dominanceFrontier[X];
+				for(Y <- frontierNodes) { // Y : basic block ∈ DF(X )
+					if(size({Y} & F) == 0 && isJoinNode(flowGraph, Y)) { // Y \notin F && Y is a join node
+						newFlowGraph = insertPhiFunction(newFlowGraph, Y, variable); // add v←φ(...) at entry of Y
+						F = F + {Y}; // F ← F ∪ {Y}
+						if(size([Y] & blocksWithVariable(flowGraph, variable)) == 0) { // Y \notin Defs(v)
+							W = W + {Y}; // W ←W ∪{Y}
+						};
+					};
+				};
+			};
+		};
+	};
+
+	return newFlowGraph;
+}
+
+public bool isJoinNode(FlowGraph flowGraph, Node frontierNode) {
+	int fathersSize = size([ fatherNode | <fatherNode, childNode> <- flowGraph, childNode == frontierNode ]);
+
+	return fathersSize > 1;
+}
+
+public &T getStmtVariable(Node graphNode) {
+	stmtNode(assignStatement) = graphNode;
+	variableArg = assignStatement[0];
+
+	return variableArg;
+}
+
+public list[Node] blocksWithVariable(FlowGraph flowGraph, Variable variable) {
+	return [graphNode | <graphNode, _> <- flowGraph, isSameVariable(graphNode, variable)];;
+}
+
+public bool isVariable(Node graphNode) {
+	if (size(graphNode[..]) == 0) return false;
+	
+	stmtNode(assignStatement) = graphNode;
+	if (size(assignStatement[..]) == 0) return false;
+	
+	variableArg = assignStatement[0];
+	typeOfVariableArg = typeOf(variableArg);
+	
+	if (size(typeOfVariableArg[..]) == 0) return false;
+	
+	return typeOfVariableArg.name == "Variable";
+}
+
+public bool isSameVariable(Node graphNode, Variable variable) {
+	if (size(graphNode[..]) == 0) return false;
+	
+	stmtNode(assignStatement) = graphNode;
+	if (size(assignStatement[..]) == 0) return false;
+	
+	variableArg = assignStatement[0];
+	typeOfVariableArg = typeOf(variableArg);
+	
+	if (size(typeOfVariableArg[..]) == 0) return false;
+	
+	return variableArg == variable;
+}
+
+public FlowGraph insertPhiFunction(FlowGraph flowGraph, Node childNode, Variable variable) {
+	fatherNodes = predecessors(flowGraph, childNode);
+	phiFunctionStmt = stmtNode(assign(variable, phiFunction(variable, [])));
+	
+	phiFunctionRelations = { <fatherNode, phiFunctionStmt> | fatherNode <- fatherNodes };
+	filteredFlowGraph = { <origin, destination> | <origin, destination> <- flowGraph, !(origin in fatherNodes) || !(childNode == destination) };
+	
+	flowGraphWithPhiFunction = phiFunctionRelations + filteredFlowGraph + {<phiFunctionStmt, childNode>};
+	
+	return flowGraphWithPhiFunction;
+}