/******************************************************************************
* Copyright (c) 2002 - 2006 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.ir.ssa;
import java.util.EmptyStackException;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.Stack;
import com.ibm.wala.ssa.IR;
import com.ibm.wala.ssa.ISSABasicBlock;
import com.ibm.wala.ssa.SSACFG;
import com.ibm.wala.ssa.SSACFG.BasicBlock;
import com.ibm.wala.ssa.SSAInstruction;
import com.ibm.wala.ssa.SSAOptions;
import com.ibm.wala.ssa.SSAOptions.DefaultValues;
import com.ibm.wala.ssa.SSAPhiInstruction;
import com.ibm.wala.ssa.SymbolTable;
import com.ibm.wala.util.collections.ArrayIterator;
import com.ibm.wala.util.collections.IntStack;
import com.ibm.wala.util.graph.Graph;
import com.ibm.wala.util.graph.dominators.DominanceFrontiers;
/**
* Abstract core of traditional SSA conversion (Cytron et al.).
*
* This implementation is abstract in the sense that it is designed to work over
* the instructions and CFG of a Domo IR, but it is abstract with respect to
* several integral portions of the traditional algorithm:
* <UL>
* <LI> The notion of uses and defs of a given instruction.
* <LI> Assignments (<def> := <use>) that are be copy-propagated away
* <LI> Which values are constants---i.e. have no definition.
* <LI> Any value numbers to be skipped during SSA construction
* <LI> Special initialization and exit block processing.
* </UL>
*
* @author Julian dolby (dolby@us.ibm.com)
*
*/
public abstract class AbstractSSAConversion {
protected abstract int getNumberOfDefs(SSAInstruction inst);
protected abstract int getDef(SSAInstruction inst, int index);
protected abstract int getNumberOfUses(SSAInstruction inst);
protected abstract int getUse(SSAInstruction inst, int index);
protected abstract boolean isAssignInstruction(SSAInstruction inst);
protected abstract int getMaxValueNumber();
protected abstract boolean isLive(SSACFG.BasicBlock Y, int V);
protected abstract boolean skip(int vn);
protected abstract boolean isConstant(int valueNumber);
protected abstract int getNextNewValueNumber();
protected abstract void initializeVariables();
protected abstract void repairExit();
protected abstract void placeNewPhiAt(int value, SSACFG.BasicBlock Y);
protected abstract SSAPhiInstruction getPhi(SSACFG.BasicBlock B, int index);
protected abstract void setPhi(SSACFG.BasicBlock B, int index, SSAPhiInstruction inst);
protected abstract SSAPhiInstruction repairPhiDefs(SSAPhiInstruction phi, int[] newDefs);
protected abstract void repairPhiUse(SSACFG.BasicBlock BB, int phiIndex, int rvalIndex, int newRval);
protected abstract void repairInstructionUses(SSAInstruction inst, int index, int[] newUses);
protected abstract void repairInstructionDefs(SSAInstruction inst, int index, int[] newDefs, int[] newUses);
protected abstract void pushAssignment(SSAInstruction inst, int index, int newRhs);
protected abstract void popAssignment(SSAInstruction inst, int index);
protected final SSACFG CFG;
protected final DominanceFrontiers<ISSABasicBlock> DF;
private final Graph<ISSABasicBlock> dominatorTree;
protected final int[] phiCounts;
protected final SSAInstruction[] instructions;
private final int flags[];
protected final SymbolTable symbolTable;
protected final DefaultValues defaultValues;
protected IntStack S[];
protected int C[];
protected int valueMap[];
private Set<SSACFG.BasicBlock>[] assignmentMap;
protected AbstractSSAConversion(IR ir, SSAOptions options) {
this.CFG = ir.getControlFlowGraph();
this.DF = new DominanceFrontiers<ISSABasicBlock>(ir.getControlFlowGraph(), ir.getControlFlowGraph().entry());
this.dominatorTree = DF.dominatorTree();
this.flags = new int[2 * ir.getControlFlowGraph().getNumberOfNodes()];
this.instructions = getInstructions(ir);
this.phiCounts = new int[CFG.getNumberOfNodes()];
this.symbolTable = ir.getSymbolTable();
this.defaultValues = options.getDefaultValues();
}
//
// top-level control
//
protected void perform() {
init();
placePhiNodes();
renameVariables();
}
//
// initialization
//
protected SSAInstruction[] getInstructions(IR ir) {
return ir.getInstructions();
}
protected final Iterator<SSAInstruction> iterateInstructions(IR ir) {
return new ArrayIterator<SSAInstruction>(getInstructions(ir));
}
protected void init() {
this.S = new IntStack[getMaxValueNumber() + 1];
this.C = new int[getMaxValueNumber() + 1];
this.valueMap = new int[getMaxValueNumber() + 1];
makeAssignmentMap();
}
@SuppressWarnings("unchecked")
private void makeAssignmentMap() {
this.assignmentMap = new Set[getMaxValueNumber() + 1];
for (Iterator BBs = CFG.iterator(); BBs.hasNext();) {
SSACFG.BasicBlock BB = (SSACFG.BasicBlock) BBs.next();
if (BB.getFirstInstructionIndex() >= 0) {
for (Iterator IS = BB.iterator(); IS.hasNext();) {
SSAInstruction inst = (SSAInstruction) IS.next();
if (inst != null) {
for (int j = 0; j < getNumberOfDefs(inst); j++) {
addDefiningBlock(assignmentMap, BB, getDef(inst, j));
}
}
}
}
}
}
private void addDefiningBlock(Set<SSACFG.BasicBlock>[] A, SSACFG.BasicBlock BB, int i) {
if (!skip(i)) {
if (A[i] == null) {
A[i] = new LinkedHashSet<SSACFG.BasicBlock>(2);
}
A[i].add(BB);
}
}
//
// place phi nodes phase of traditional algorithm
//
protected void placePhiNodes() {
int IterCount = 0;
for (Iterator Xs = CFG.iterator(); Xs.hasNext();) {
SSACFG.BasicBlock X = (SSACFG.BasicBlock) Xs.next();
setHasAlready(X, 0);
setWork(X, 0);
}
Set<BasicBlock> W = new LinkedHashSet<BasicBlock>();
for (int V = 0; V < assignmentMap.length; V++) {
// some things (e.g. constants) have no defs at all
if (assignmentMap[V] == null)
continue;
// ignore values as requested
if (skip(V))
continue;
IterCount++;
for (Iterator XS = assignmentMap[V].iterator(); XS.hasNext();) {
SSACFG.BasicBlock X = (SSACFG.BasicBlock) XS.next();
setWork(X, IterCount);
W.add(X);
}
while (!W.isEmpty()) {
SSACFG.BasicBlock X = W.iterator().next();
W.remove(X);
for (Iterator YS = DF.getDominanceFrontier(X); YS.hasNext();) {
SSACFG.BasicBlock Y = (SSACFG.BasicBlock) YS.next();
if (getHasAlready(Y) < IterCount) {
if (isLive(Y, V)) {
placeNewPhiAt(V, Y);
phiCounts[Y.getGraphNodeId()]++;
}
setHasAlready(Y, IterCount);
if (getWork(Y) < IterCount) {
setWork(Y, IterCount);
W.add(Y);
}
}
}
}
}
}
private int getWork(SSACFG.BasicBlock BB) {
return flags[BB.getGraphNodeId() * 2 + 1];
}
private void setWork(SSACFG.BasicBlock BB, int v) {
flags[BB.getGraphNodeId() * 2 + 1] = v;
}
private int getHasAlready(SSACFG.BasicBlock BB) {
return flags[BB.getGraphNodeId() * 2];
}
private void setHasAlready(SSACFG.BasicBlock BB, int v) {
flags[BB.getGraphNodeId() * 2] = v;
}
//
// rename variables phase of traditional algorithm
//
private void renameVariables() {
for (int V = 1; V <= getMaxValueNumber(); V++) {
if (!skip(V)) {
C[V] = 0;
S[V] = new IntStack();
}
}
initializeVariables();
SEARCH(CFG.entry());
}
/**
* Stack frames for the SEARCH recursion.
* Used for converting the recursion to an iteration and avoiding stack overflow.
* @author yinnonh
*
*/
private static class Frame{
public final SSACFG.BasicBlock X;
public final Iterator<ISSABasicBlock> i; // iterator o
public Frame(SSACFG.BasicBlock X, Iterator<ISSABasicBlock> i) {
this.X = X;
this.i = i;
}
}
private void SEARCH(SSACFG.BasicBlock X) {
// original method was recursive:
// SearchPreRec(X)
// for (BasicBlock Y: childs(X))
// SEARCH(Y)
// SearchPostRec(X)
Stack<Frame> stack = new Stack<Frame>();
SearchPreRec(X);
stack.push(new Frame(X, dominatorTree.getSuccNodes(X)));
// invariant: pre-rec phase was performed for elements in the queue.
while (!stack.isEmpty()){
Frame f = stack.peek();
if (f.i.hasNext()){
// iterate next child
BasicBlock next = (BasicBlock) f.i.next();
SearchPreRec(next);
stack.push(new Frame(next, dominatorTree.getSuccNodes(next)));
} else {
// finished iterating children, time to "return"
SearchPostRec(f.X);
stack.pop();
}
}
}
private void SearchPreRec(SSACFG.BasicBlock X) {
int id = X.getGraphNodeId();
int Xf = X.getFirstInstructionIndex();
// first loop
for (int i = 0; i < phiCounts[id]; i++) {
SSAPhiInstruction phi = getPhi(X, i);
if (!skipRepair(phi, -1)) {
setPhi(X, i, repairPhiDefs(phi, makeNewDefs(phi)));
}
}
for (int i = Xf; i <= X.getLastInstructionIndex(); i++) {
SSAInstruction inst = instructions[i];
if (isAssignInstruction(inst)) {
int lhs = getDef(inst, 0);
int rhs = getUse(inst, 0);
int newRhs = skip(rhs) ? rhs : top(rhs);
S[lhs].push(newRhs);
pushAssignment(inst, i, newRhs);
} else {
if (!skipRepair(inst, i)) {
int[] newUses = makeNewUses(inst);
repairInstructionUses(inst, i, newUses);
int[] newDefs = makeNewDefs(inst);
repairInstructionDefs(inst, i, newDefs, newUses);
}
}
}
if (X.isExitBlock()) {
repairExit();
}
for (Iterator YS = CFG.getSuccNodes(X); YS.hasNext();) {
SSACFG.BasicBlock Y = (SSACFG.BasicBlock) YS.next();
int Y_id = Y.getGraphNodeId();
int j = com.ibm.wala.cast.ir.cfg.Util.whichPred(CFG, Y, X);
for (int i = 0; i < phiCounts[Y_id]; i++) {
SSAPhiInstruction phi = getPhi(Y, i);
int oldUse = getUse(phi, j);
int newUse = skip(oldUse) ? oldUse : top(oldUse);
repairPhiUse(Y, i, j, newUse);
}
}
}
private void SearchPostRec(SSACFG.BasicBlock X) {
int id = X.getGraphNodeId();
int Xf = X.getFirstInstructionIndex();
for (int i = 0; i < phiCounts[id]; i++) {
SSAInstruction A = getPhi(X, i);
for (int j = 0; j < getNumberOfDefs(A); j++) {
if (!skip(getDef(A, j))) {
S[valueMap[getDef(A, j)]].pop();
}
}
}
for (int i = Xf; i <= X.getLastInstructionIndex(); i++) {
SSAInstruction A = instructions[i];
if (isAssignInstruction(A)) {
S[getDef(A, 0)].pop();
popAssignment(A, i);
} else if (A != null) {
for (int j = 0; j < getNumberOfDefs(A); j++) {
if (!skip(getDef(A, j))) {
S[valueMap[getDef(A, j)]].pop();
}
}
}
}
}
private int[] makeNewUses(SSAInstruction inst) {
int[] newUses = new int[getNumberOfUses(inst)];
for (int j = 0; j < getNumberOfUses(inst); j++) {
newUses[j] = skip(getUse(inst, j)) ? getUse(inst, j) : top(getUse(inst, j));
}
return newUses;
}
private int[] makeNewDefs(SSAInstruction inst) {
int[] newDefs = new int[getNumberOfDefs(inst)];
for (int j = 0; j < getNumberOfDefs(inst); j++) {
if (skip(getDef(inst, j))) {
newDefs[j] = getDef(inst, j);
} else {
int ii = getNextNewValueNumber();
if (valueMap.length <= ii) {
int[] nvm = new int[valueMap.length * 2 + ii + 1];
System.arraycopy(valueMap, 0, nvm, 0, valueMap.length);
valueMap = nvm;
}
valueMap[ii] = getDef(inst, j);
S[getDef(inst, j)].push(ii);
newDefs[j] = ii;
}
}
return newDefs;
}
protected boolean skipRepair(SSAInstruction inst, int index) {
if (inst == null)
return true;
for (int i = 0; i < getNumberOfDefs(inst); i++)
if (!skip(getDef(inst, i)))
return false;
for (int i = 0; i < getNumberOfUses(inst); i++)
if (!skip(getUse(inst, i)))
return false;
return true;
}
protected void fail(int v) {
assert isConstant(v) || !S[v].isEmpty() : "bad stack for " + v + " while SSA converting";
}
protected boolean hasDefaultValue(int valueNumber) {
return (defaultValues != null) && (defaultValues.getDefaultValue(symbolTable, valueNumber) != -1);
}
protected int getDefaultValue(int valueNumber) {
return defaultValues.getDefaultValue(symbolTable, valueNumber);
}
protected int top(int v) {
if (!(isConstant(v) || !S[v].isEmpty())) {
if (hasDefaultValue(v)) {
return getDefaultValue(v);
} else {
fail(v);
}
}
try {
return (isConstant(v)) ? v : S[v].peek();
} catch (EmptyStackException e) {
throw new RuntimeException("while looking at " + v, e);
}
}
}