Feature/variable renaming

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,24 @@
+module lang::jimple::toolkit::ssa::DominanceFrontier
+
+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) {
+	allNodes = { origin | <origin, _> <- flowGraph } + { destination | <_, destination> <- flowGraph };
+
+	dominanceFrontiers = ();
+
+	for(graphNode <- allNodes) {
+		for(predecessor <- predecessors(flowGraph, graphNode)) {
+			tempPredecessor = predecessor;
+			while(tempPredecessor != findIdom(dominanceTree, graphNode)) {
+				dominanceFrontiers[tempPredecessor] = tempPredecessor in dominanceFrontiers ? dominanceFrontiers[tempPredecessor] : {};
+				dominanceFrontiers[tempPredecessor] = dominanceFrontiers[tempPredecessor] + {graphNode};
+				tempPredecessor = findIdom(dominanceTree, tempPredecessor);
+			};
+		};
+	};
+
+	return dominanceFrontiers;
+}

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

@@ -1,16 +1,54 @@
 module lang::jimple::toolkit::ssa::DominanceTree
 
+import demo::Dominators;
+import Set;
 import lang::jimple::toolkit::FlowGraph;
+import analysis::graphs::Graph;
+import demo::Dominators;
 
-import List;
+public map[&T, set[&T]] createDominanceTree(Graph[&T] graph) {
+	rel[&T, set[&T]] dominanceTreeRelations = dominators(graph, entryNode());
+	return ( father: childs | <father, childs> <- dominanceTreeRelations );
+}
+
+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];
+	};
 
-public map[Node, Node] createDominanceTree(FlowGraph flowGraph) {
-	result = (computeDominator(flowGraph, a): a | <a, _> <- flowGraph);
-	return result;
+	return blockTree;
 }
 
-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 Graph[&T] removeNodeFromGraph(Graph[&T] graph, &T nodeToRemove) {
+ return { <father, graphChild> | <father, graphChild> <- graph, nodeToRemove != father || nodeToRemove == entryNode() };
+}
+
+
+public Node findIdom(map[&T, set[&T]] dominanceTree, Node child) {
+	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/Helpers.rsc

@@ -0,0 +1,115 @@
+module lang::jimple::toolkit::ssa::Helpers
+
+import Node;
+import Type;
+import List;
+
+import lang::jimple::toolkit::FlowGraph;
+import lang::jimple::core::Syntax;
+
+public Variable returnStmtVariable(Node graphNode) {
+	assignStatement = returnStmtNodeBody(graphNode);
+	variableArg = assignStatement[0];
+
+	switch(variableArg) {
+		case Variable variable: return variable;
+	}
+}
+
+public Statement returnStmtNodeBody(Node stmtNode) {
+	switch(stmtNode) {
+		case stmtNode(stmtBody): return stmtBody;
+	}
+}
+
+public Variable returnPhiFunctionLeftHandSide(Expression phiFunctionExpr) {
+	switch(phiFunctionExpr) {
+		case phiFunction(leftHandSide, _): return leftHandSide;
+	}
+}
+
+public list[Variable] returnPhiFunctionRightHandSide(Expression phiFunctionExpr) {
+	switch(phiFunctionExpr) {
+		case phiFunction(_, rightHandSide): return rightHandSide;
+	}
+}
+
+public Variable returnLeftHandSideVariable(Node stmtNode) {
+	switch(stmtNode) {
+		case stmtNode(assign(leftHandSide, _)): return leftHandSide;
+	}
+}
+
+public Expression returnRightHandSideExpression(Node stmtNode) {
+	switch(stmtNode) {
+		case stmtNode(assign(_, rightHandSide)): return rightHandSide;
+	}
+}
+
+public String returnVariableImmediateName(Immediate immediate) {
+	switch(immediate) {
+		case local(String localName): return localName;
+		default: return "";
+	}
+}
+
+public String returnImmediateName(Immediate immediate) {
+	switch(immediate[0]) {
+		case String immediateName: return immediateName;
+	}
+}
+
+public list[Immediate] returnRightHandSideImmediates(Node variableNode) {
+	rightHandSide = returnRightHandSideExpression(variableNode);
+	typeOfVariableArg = typeOf(rightHandSide);
+
+	if(typeOfVariableArg.name != "Expression") return [];
+
+	list[Immediate] immediates = returnExpressionImmediates(rightHandSide);
+	list[Immediate] localVariableImmediates = [ immediate | immediate <- immediates, returnVariableImmediateName(immediate) != ""];
+	int variablesCount = size(localVariableImmediates);
+
+	if(variablesCount != 0) return localVariableImmediates;
+
+	return [];
+}
+
+public list[Immediate] returnExpressionImmediates(Expression expression) {
+	switch(expression) {
+	  case newInstance(Type instanceType): return [];
+	  case newArray(Type baseType, list[ArrayDescriptor] dims): return [];
+	  case cast(Type toType, local(name)): return [];
+	  case instanceOf(Type baseType, local(name)): return [local(name)];
+	  case invokeExp(_): return [];
+	  case arraySubscript(Name arrayName, _): return [local(arrayName)];
+	  case stringSubscript(String stringName, local(name)): return [local(stringName)];
+	  case localFieldRef(Name local, Name className, Type fieldType, Name fieldName): return [];
+	  case fieldRef(Name className, Type fieldType, Name fieldName): return [];
+	  case and(lhs, rhs): return [lhs, rhs];
+	  case or(lhs, rhs): return [lhs, rhs];
+	  case xor(lhs, rhs): return [lhs, rhs];
+	  case reminder(lhs, rhs): return [lhs, rhs];
+	  case isNull(variable): return [variable];
+	  case isNotNull(variable): return [variable];
+	  case cmp(lhs, rhs): return [lhs, rhs];
+	  case cmpg(lhs, rhs): return [lhs, rhs];
+	  case cmpl(lhs, rhs): return [lhs, rhs];
+	  case cmpeq(lhs, rhs): return [lhs, rhs];
+	  case cmpne(lhs, rhs): return [lhs, rhs];
+	  case cmpgt(lhs, rhs): return [lhs, rhs];
+	  case cmpge(lhs, rhs): return [lhs, rhs];
+	  case cmplt(lhs, rhs): return [lhs, rhs];
+	  case cmple(lhs, rhs): return [lhs, rhs];
+	  case shl(lhs, rhs): return [lhs, rhs];
+	  case shr(lhs, rhs): return [lhs, rhs];
+	  case ushr(lhs, rhs): return [lhs, rhs];
+	  case plus(lhs, rhs): return [lhs, rhs];
+	  case minus(lhs, rhs): return [lhs, rhs];
+	  case mult(lhs, rhs): return [lhs, rhs];
+	  case div(lhs, rhs): return [lhs, rhs];
+	  case lengthOf(local(name)): return [local(name)];
+	  case neg(local(name)): return [local(name)];
+	  case immediate(local(name)): return [local(name)];
+	  default: return [];
+	}
+}

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

@@ -0,0 +1,103 @@
+module lang::jimple::toolkit::ssa::PhiFunctionInsertion
+
+import demo::Dominators;
+import Set;
+import Relation;
+import Type;
+import IO;
+import Node;
+import List;
+
+import analysis::graphs::Graph;
+import lang::jimple::toolkit::FlowGraph;
+import lang::jimple::core::Syntax;
+import lang::jimple::toolkit::ssa::Helpers;
+
+public FlowGraph insertPhiFunctions(FlowGraph flowGraph, map[&T, set[&T]] dominanceFrontier) {
+	variableList = { getStmtVariable(graphNode) | <graphNode, _> <- flowGraph, isVariable(graphNode) };
+
+	for(V <- variableList) {
+		DomFromPlus = ();
+		Work = ();
+		W = {};
+
+		for(X <- blocksWithVariable(flowGraph, V)) {
+			Work[X] = 1;
+			W = W + {X};
+		};
+
+		while(W != {}) {
+			<X, newSet> = takeOneFrom(W);
+			W = newSet;
+
+			if(X in dominanceFrontier) {
+				for(Y <- dominanceFrontier[X]) {
+					if(!(Y in DomFromPlus)) {
+						flowGraph = insertPhiFunction(flowGraph, Y, V); // add v←φ(...) at entry of Y
+						DomFromPlus[Y] = 1;
+						if(!(Y in DomFromPlus)) {
+							Work(Y) = 1;
+							W = W + {Y};
+						};
+					};
+				};
+			};
+		};
+	};
+
+	return flowGraph;
+
+}
+
+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;
+
+	assignStatement = returnStmtNodeBody(graphNode);
+	if (size(assignStatement[..]) == 0) return false;
+
+	variableArg = assignStatement[0];
+	typeOfVariableArg = typeOf(variableArg);
+
+	if (size(typeOfVariableArg[..]) == 0) return false;
+
+	return typeOfVariableArg.name == "Variable";
+}
+
+public &T getStmtVariable(Node graphNode) {
+	assignStatement = returnStmtNodeBody(graphNode);
+	variableArg = assignStatement[0];
+
+	return variableArg;
+}
+
+public bool isSameVariable(Node graphNode, Variable variable) {
+	if (size(graphNode[..]) == 0) return false;
+
+	assignStatement = returnStmtNodeBody(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) {
+	if (childNode == exitNode()) return flowGraph;
+
+	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;
+}