Skip to content

Commit 960c69a

Browse files
mateusluizfbmateusluizfb
committed
Extracting helper methods to another file
1 parent 35477ef commit 960c69a

File tree

2 files changed

+120
-111
lines changed

2 files changed

+120
-111
lines changed

‎src/main/rascal/lang/jimple/toolkit/ssa/Helpers.rsc‎

Lines changed: 103 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,103 @@
1+
module lang::jimple::toolkit::ssa::Helpers
2+
3+
import Node;
4+
import Type;
5+
import List;
6+
7+
import lang::jimple::toolkit::FlowGraph;
8+
import lang::jimple::core::Syntax;
9+
10+
public Variable returnStmtVariable(Node graphNode) {
11+
stmtNode(assignStatement) = graphNode;
12+
variableArg = assignStatement[0];
13+
14+
switch(variableArg) {
15+
case Variable variable: return variable;
16+
}
17+
}
18+
19+
public Statement returnStmtNodeBody(Node stmtNode) {
20+
switch(stmtNode) {
21+
case stmtNode(stmtBody): return stmtBody;
22+
}
23+
}
24+
25+
public Variable returnLeftHandSideVariable(Node stmtNode) {
26+
switch(stmtNode) {
27+
case stmtNode(assign(leftHandSide, _)): return leftHandSide;
28+
}
29+
}
30+
31+
public Expression returnRightHandSideExpression(Node stmtNode) {
32+
switch(stmtNode) {
33+
case stmtNode(assign(_, rightHandSide)): return rightHandSide;
34+
}
35+
}
36+
37+
public String returnVariableImmediateName(Immediate immediate) {
38+
switch(immediate) {
39+
case local(String localName): return localName;
40+
default: return "";
41+
}
42+
}
43+
44+
public String returnImmediateName(Immediate immediate) {
45+
switch(immediate[0]) {
46+
case String immediateName: return immediateName;
47+
}
48+
}
49+
50+
public list[Immediate] returnRightHandSideImmediates(Node variableNode) {
51+
rightHandSide = returnRightHandSideExpression(variableNode);
52+
typeOfVariableArg = typeOf(rightHandSide);
53+
54+
if(typeOfVariableArg.name != "Expression") return [];
55+
56+
list[Immediate] immediates = returnExpressionImmediates(rightHandSide);
57+
list[Immediate] localVariableImmediates = [ immediate | immediate <- immediates, returnVariableImmediateName(immediate) != ""];
58+
int variablesCount = size(localVariableImmediates);
59+
60+
if(variablesCount != 0) return localVariableImmediates;
61+
62+
return [];
63+
}
64+
65+
public list[Immediate] returnExpressionImmediates(Expression expression) {
66+
switch(expression) {
67+
case newInstance(Type instanceType): return [];
68+
case newArray(Type baseType, list[ArrayDescriptor] dims): return [];
69+
case cast(Type toType, local(name)): return [];
70+
case instanceOf(Type baseType, local(name)): return [local(name)];
71+
case invokeExp(_): return [];
72+
case arraySubscript(Name arrayName, _): return [local(arrayName)];
73+
case stringSubscript(String stringName, local(name)): return [local(stringName)];
74+
case localFieldRef(Name local, Name className, Type fieldType, Name fieldName): return [];
75+
case fieldRef(Name className, Type fieldType, Name fieldName): return [];
76+
case and(lhs, rhs): return [lhs, rhs];
77+
case or(lhs, rhs): return [lhs, rhs];
78+
case xor(lhs, rhs): return [lhs, rhs];
79+
case reminder(lhs, rhs): return [lhs, rhs];
80+
case isNull(variable): return [variable];
81+
case isNotNull(variable): return [variable];
82+
case cmp(lhs, rhs): return [lhs, rhs];
83+
case cmpg(lhs, rhs): return [lhs, rhs];
84+
case cmpl(lhs, rhs): return [lhs, rhs];
85+
case cmpeq(lhs, rhs): return [lhs, rhs];
86+
case cmpne(lhs, rhs): return [lhs, rhs];
87+
case cmpgt(lhs, rhs): return [lhs, rhs];
88+
case cmpge(lhs, rhs): return [lhs, rhs];
89+
case cmplt(lhs, rhs): return [lhs, rhs];
90+
case cmple(lhs, rhs): return [lhs, rhs];
91+
case shl(lhs, rhs): return [lhs, rhs];
92+
case shr(lhs, rhs): return [lhs, rhs];
93+
case ushr(lhs, rhs): return [lhs, rhs];
94+
case plus(lhs, rhs): return [lhs, rhs];
95+
case minus(lhs, rhs): return [lhs, rhs];
96+
case mult(lhs, rhs): return [lhs, rhs];
97+
case div(lhs, rhs): return [lhs, rhs];
98+
case lengthOf(local(name)): return [local(name)];
99+
case neg(local(name)): return [local(name)];
100+
case immediate(local(name)): return [local(name)];
101+
default: return [];
102+
}
103+
}

‎src/main/rascal/lang/jimple/toolkit/ssa/VariableRenaming.rsc‎

Lines changed: 17 additions & 111 deletions
Original file line numberDiff line numberDiff line change
@@ -15,6 +15,7 @@ import lang::jimple::util::Stack;
1515
import lang::jimple::toolkit::FlowGraph;
1616
import lang::jimple::core::Syntax;
1717
import lang::jimple::toolkit::ssa::DominanceTree;
18+
import lang::jimple::toolkit::ssa::Helpers;
1819

1920
map[str, Stack[int]] VARIABLE_VERSION_STACK = ();
2021
map[str, int] VARIABLE_ASSIGNMENT_COUNT = ();
@@ -50,8 +51,8 @@ public map[Node, list[Node]] replace(Node X) {
5051
5152
// Deal with all nodes that aren't assigments bug uses a variable in some way
5253
if(isNonAssignmentStatementToRename(X)) {
53-
stmtNode(statement) = X;
54-
Node renamedStatement = stmtNode(replaceImmediateUse(statement));
54+
statementBody = returnStmtNodeBody(X);
55+
Node renamedStatement = stmtNode(replaceImmediateUse(statementBody));
5556
renameNodeOcurrecies(X, renamedStatement);
5657
X = renamedStatement;
5758
};
@@ -60,7 +61,7 @@ public map[Node, list[Node]] replace(Node X) {
6061
if(isOrdinaryAssignment(X) && !isRenamed(X)) {
6162
6263
// Replace right hand side variables
63-
list[Immediate] rightHandNodeImmediates = getRightHandSideImmediates(X);
64+
list[Immediate] rightHandNodeImmediates = returnRightHandSideImmediates(X);
6465
for(rightHandSideImmediate <- rightHandNodeImmediates) {
6566
newAssignStmt = replaceRightVariableVersion(ADJACENCIES_MATRIX, rightHandSideImmediate, X);
6667
@@ -71,7 +72,7 @@ public map[Node, list[Node]] replace(Node X) {
7172
7273
// Replace left hand side variables
7374
if(isLeftHandSideVariable(X)) {
74-
Variable V = getStmtVariable(X);
75+
Variable V = returnStmtVariable(X);
7576
Immediate localVariableImmediate = local(V[0]);
7677
7778
int assingmentQuantity = returnAssignmentQuantity(localVariableImmediate);
@@ -101,7 +102,7 @@ public map[Node, list[Node]] replace(Node X) {
101102
}
102103
103104
public void findAndAddPhiFunctionArgs(Node oldNode, Node newNode) {
104-
Variable variable = getStmtVariable(oldNode);
105+
Variable variable = returnStmtVariable(oldNode);
105106
variableName = variable[0];
106107
dfsPhiFunctionLookupAndRename(newNode, newNode, variableName);
107108
}
@@ -157,7 +158,7 @@ public map[Node, list[Node]] replaceNodeOcurrenciesInTrees(map[Node, list[Node]]
157158
}
158159
159160
public Statement replaceImmediateUse(Statement statement) {
160-
return return addEnclosingStmt(statement, replaceImmediateUse(statement[0]));
161+
return addEnclosingStmt(statement, replaceImmediateUse(statement[0]));
161162
}
162163
163164
public Statement addEnclosingStmt(Statement statement, Expression expression) {
@@ -192,7 +193,7 @@ public Expression replaceImmediateUse(Expression expression) {
192193
193194
public Name returnLastVariableVersion(str name) {
194195
Immediate immediate = local(name);
195-
variableName = getVariableImmediateName(immediate);
196+
variableName = returnVariableImmediateName(immediate);
196197
197198
int versionIndex = getVariableVersionStacked(immediate);
198199
str newVariableName = buildVersionName(variableName, versionIndex);
@@ -216,7 +217,7 @@ public bool isSkipableStatement(stmtArgument) {
216217
}
217218
218219
public Node replacePhiFunctionVersion(map[Node, list[Node]] blockTree, Node variableNode) {
219-
stmtNode(assignStatement) = variableNode;
220+
assignStatement = returnStmtNodeBody(variableNode);
220221
assign(assignVariable, assignPhiFunction) = assignStatement;
221222
phiFunction(phiFunctionVariable, variableVersionList) = assignPhiFunction;
222223
variableName = phiFunctionVariable[0];
@@ -257,7 +258,7 @@ public Expression renameExpressionVariables(Expression expression, Immediate imm
257258
return arraySubscript(newVersionName, local(returnCurrentVersionName(local(localName))));
258259
};
259260
260-
list[Immediate] immediates = getExpressionImmediates(expression);
261+
list[Immediate] immediates = returnExpressionImmediates(expression);
261262
int index = indexOf(immediates, immediateToRename);
262263
expression[index] = local(newVersionName);
263264
@@ -266,7 +267,7 @@ public Expression renameExpressionVariables(Expression expression, Immediate imm
266267
267268
public String returnCurrentVersionName(Immediate immediate) {
268269
int variableVersion = getVariableVersionStacked(immediate);
269-
String variableOriginalName = getImmediateName(immediate);
270+
String variableOriginalName = returnImmediateName(immediate);
270271
return buildVersionName(variableOriginalName, variableVersion);
271272
}
272273
@@ -285,18 +286,6 @@ public str buildVersionName(str variableOriginalName, int versionIndex) {
285286
return variableOriginalName + "_version-" + toString(versionIndex);
286287
}
287288
288-
public String getVariableName(Variable variable) {
289-
switch(variable[0]) {
290-
case String variableName: return variableName;
291-
}
292-
}
293-
294-
public String getImmediateName(Immediate immediate) {
295-
switch(immediate[0]) {
296-
case String immediateName: return immediateName;
297-
}
298-
}
299-
300289
public bool isLeftHandSideVariable(Node variableNode) {
301290
switch(variableNode) {
302291
case stmtNode(assign(localVariable(_), _)): return true;
@@ -305,21 +294,6 @@ public bool isLeftHandSideVariable(Node variableNode) {
305294
}
306295
}
307296
308-
public list[Immediate] getRightHandSideImmediates(Node variableNode) {
309-
rightHandSide = returnRightHandSideExpression(variableNode);
310-
typeOfVariableArg = typeOf(rightHandSide);
311-
312-
if(typeOfVariableArg.name != "Expression") return [];
313-
314-
list[Immediate] immediates = getExpressionImmediates(rightHandSide);
315-
list[Immediate] localVariableImmediates = [ immediate | immediate <- immediates, getVariableImmediateName(immediate) != ""];
316-
int variablesCount = size(localVariableImmediates);
317-
318-
if(variablesCount != 0) return localVariableImmediates;
319-
320-
return [];
321-
}
322-
323297
public bool ignoreNode(Node variableNode) {
324298
switch(variableNode) {
325299
case entryNode(): return true;
@@ -357,15 +331,6 @@ public bool isPhiFunctionAssigment(Node variableNode) {
357331
}
358332
}
359333
360-
public Variable getStmtVariable(Node graphNode) {
361-
stmtNode(assignStatement) = graphNode;
362-
variableArg = assignStatement[0];
363-
364-
switch(variableArg) {
365-
case Variable variable: return variable;
366-
}
367-
}
368-
369334
public bool isVariable(Node graphNode) {
370335
if (size(graphNode[..]) == 0) return false;
371336
@@ -390,71 +355,12 @@ public bool isSameVariable(Node graphNode, Variable variable) {
390355
return variableArg == variable;
391356
}
392357
393-
public list[Immediate] getExpressionImmediates(Expression expression) {
394-
switch(expression) {
395-
case newInstance(Type instanceType): return [];
396-
case newArray(Type baseType, list[ArrayDescriptor] dims): return [];
397-
case cast(Type toType, local(name)): return [];
398-
case instanceOf(Type baseType, local(name)): return [local(name)];
399-
case invokeExp(_): return [];
400-
case arraySubscript(Name arrayName, _): return [local(arrayName)];
401-
case stringSubscript(String stringName, local(name)): return [local(stringName)];
402-
case localFieldRef(Name local, Name className, Type fieldType, Name fieldName): return [];
403-
case fieldRef(Name className, Type fieldType, Name fieldName): return [];
404-
case and(lhs, rhs): return [lhs, rhs];
405-
case or(lhs, rhs): return [lhs, rhs];
406-
case xor(lhs, rhs): return [lhs, rhs];
407-
case reminder(lhs, rhs): return [lhs, rhs];
408-
case isNull(variable): return [variable];
409-
case isNotNull(variable): return [variable];
410-
case cmp(lhs, rhs): return [lhs, rhs];
411-
case cmpg(lhs, rhs): return [lhs, rhs];
412-
case cmpl(lhs, rhs): return [lhs, rhs];
413-
case cmpeq(lhs, rhs): return [lhs, rhs];
414-
case cmpne(lhs, rhs): return [lhs, rhs];
415-
case cmpgt(lhs, rhs): return [lhs, rhs];
416-
case cmpge(lhs, rhs): return [lhs, rhs];
417-
case cmplt(lhs, rhs): return [lhs, rhs];
418-
case cmple(lhs, rhs): return [lhs, rhs];
419-
case shl(lhs, rhs): return [lhs, rhs];
420-
case shr(lhs, rhs): return [lhs, rhs];
421-
case ushr(lhs, rhs): return [lhs, rhs];
422-
case plus(lhs, rhs): return [lhs, rhs];
423-
case minus(lhs, rhs): return [lhs, rhs];
424-
case mult(lhs, rhs): return [lhs, rhs];
425-
case div(lhs, rhs): return [lhs, rhs];
426-
case lengthOf(local(name)): return [local(name)];
427-
case neg(local(name)): return [local(name)];
428-
case immediate(local(name)): return [local(name)];
429-
default: return [];
430-
}
431-
}
432-
433-
public Variable returnLeftHandSideVariable(Node stmtNode) {
434-
switch(stmtNode) {
435-
case stmtNode(assign(leftHandSide, _)): return leftHandSide;
436-
}
437-
}
438-
439-
public Expression returnRightHandSideExpression(Node stmtNode) {
440-
switch(stmtNode) {
441-
case stmtNode(assign(_, rightHandSide)): return rightHandSide;
442-
}
443-
}
444-
445358
public bool isNonAssignmentStatementToRename(Node graphNode) {
446359
return !isReplaced(graphNode) && !isOrdinaryAssignment(graphNode) && !ignoreNode(graphNode) && !isPhiFunctionAssigment(graphNode);
447360
}
448361
449-
public String getVariableImmediateName(Immediate immediate) {
450-
switch(immediate) {
451-
case local(String localName): return localName;
452-
default: return "";
453-
}
454-
}
455-
456362
public int returnAssignmentQuantity(Immediate immediate) {
457-
str name = getVariableImmediateName(immediate);
363+
str name = returnVariableImmediateName(immediate);
458364
459365
if(name in VARIABLE_ASSIGNMENT_COUNT) return VARIABLE_ASSIGNMENT_COUNT[name];
460366
@@ -463,23 +369,23 @@ public int returnAssignmentQuantity(Immediate immediate) {
463369
}
464370
465371
public int iterateAssignmentQuantity(Immediate immediate) {
466-
str name = getVariableImmediateName(immediate);
372+
str name = returnVariableImmediateName(immediate);
467373
468374
VARIABLE_ASSIGNMENT_COUNT[name] = VARIABLE_ASSIGNMENT_COUNT[name] + 1;
469375
470376
return VARIABLE_ASSIGNMENT_COUNT[name];
471377
}
472378
473379
public str stackVariableVersion(Immediate immediate, int renameIndex) {
474-
str name = getVariableImmediateName(immediate);
380+
str name = returnVariableImmediateName(immediate);
475381
476382
VARIABLE_VERSION_STACK[name] = name in VARIABLE_VERSION_STACK ? push(renameIndex, VARIABLE_VERSION_STACK[name]) : push(0, emptyStack());
477383
478384
return name;
479385
}
480386
481387
public int getVariableVersionStacked(Immediate immediate) {
482-
str name = getVariableImmediateName(immediate);
388+
str name = returnVariableImmediateName(immediate);
483389
484390
if(name in VARIABLE_VERSION_STACK) return peekIntValue(VARIABLE_VERSION_STACK[name]);
485391
@@ -488,10 +394,10 @@ public int getVariableVersionStacked(Immediate immediate) {
488394
}
489395
490396
public Stack[int] popOldNode(Node oldNode) {
491-
Variable V = getStmtVariable(oldNode);
397+
Variable V = returnStmtVariable(oldNode);
492398
Immediate localVariableImmediate = local(V[0]);
493399
494-
str name = getVariableImmediateName(localVariableImmediate);
400+
str name = returnVariableImmediateName(localVariableImmediate);
495401
newStackTuple = pop(VARIABLE_VERSION_STACK[name])[1];
496402
VARIABLE_VERSION_STACK[name] = newStackTuple;
497403

0 commit comments

Comments
 (0)