/*
* Bytecode Analysis Framework
* Copyright (C) 2004, University of Maryland
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
package edu.umd.cs.findbugs.ba;
import java.util.BitSet;
import org.apache.bcel.generic.IINC;
import org.apache.bcel.generic.IndexedInstruction;
import org.apache.bcel.generic.Instruction;
import org.apache.bcel.generic.InstructionHandle;
import org.apache.bcel.generic.LoadInstruction;
import org.apache.bcel.generic.LocalVariableInstruction;
import org.apache.bcel.generic.MethodGen;
import org.apache.bcel.generic.RET;
import org.apache.bcel.generic.StoreInstruction;
/**
* Dataflow analysis to find live stores of locals. This is just a backward
* analysis to see which loads reach stores of the same local.
*
* <p>
* This analysis also computes which stores that were killed by a subsequent
* store on any subsequent reachable path. (The FindDeadLocalStores detector
* uses this information to reduce false positives.)
*
* @author David Hovemeyer
*/
public class LiveLocalStoreAnalysis extends BackwardDataflowAnalysis<BitSet> implements Debug {
private final int topBit;
private final int killedByStoreOffset;
public LiveLocalStoreAnalysis(MethodGen methodGen, ReverseDepthFirstSearch rdfs, DepthFirstSearch dfs) {
super(rdfs, dfs);
this.topBit = methodGen.getMaxLocals() * 2;
this.killedByStoreOffset = methodGen.getMaxLocals();
}
@Override
public BitSet createFact() {
return new BitSet();
}
@Override
public void copy(BitSet source, BitSet dest) {
dest.clear();
dest.or(source);
}
@Override
public void initEntryFact(BitSet result) throws DataflowAnalysisException {
result.clear();
}
@Override
public void makeFactTop(BitSet fact) {
fact.clear();
fact.set(topBit);
}
@Override
public boolean same(BitSet fact1, BitSet fact2) {
return fact1.equals(fact2);
}
@Override
public void meetInto(BitSet fact, Edge edge, BitSet result) throws DataflowAnalysisException {
verifyFact(fact);
verifyFact(result);
if (isTop(fact)) {
// Nothing to do, result stays the same
} else if (isTop(result)) {
// Result is top, so it takes the value of fact
copy(fact, result);
} else {
// Meet is union
result.or(fact);
}
verifyFact(result);
}
@Override
public void transferInstruction(InstructionHandle handle, BasicBlock basicBlock, BitSet fact)
throws DataflowAnalysisException {
if (!isFactValid(fact)) {
return;
}
Instruction ins = handle.getInstruction();
if (ins instanceof StoreInstruction) {
// Local is stored: any live stores on paths leading
// to this instruction are now dead
LocalVariableInstruction store = (LocalVariableInstruction) ins;
int local = store.getIndex();
fact.clear(local);
fact.set(local + killedByStoreOffset);
}
if (ins instanceof LoadInstruction || ins instanceof IINC || ins instanceof RET) {
// Local is loaded: it will be live on any path leading
// to this instruction
IndexedInstruction load = (IndexedInstruction) ins;
int local = load.getIndex();
fact.set(local);
fact.clear(local + killedByStoreOffset);
}
if (!isFactValid(fact)) {
throw new IllegalStateException("Fact become invalid");
}
}
@Override
public boolean isFactValid(BitSet fact) {
verifyFact(fact);
return !isTop(fact);
}
/**
* @param fact
*/
private void verifyFact(BitSet fact) {
if (VERIFY_INTEGRITY) {
if (isTop(fact) && fact.nextSetBit(0) < topBit) {
throw new IllegalStateException();
}
}
}
@Override
public String factToString(BitSet fact) {
if (isTop(fact)) {
return "[TOP]";
}
StringBuilder buf = new StringBuilder("[ ");
boolean empty = true;
for (int i = 0; i < killedByStoreOffset; i++) {
boolean killedByStore = killedByStore(fact, i);
boolean storeAlive = isStoreAlive(fact, i);
if (!storeAlive && !killedByStore) {
continue;
}
if (!empty) {
buf.append(", ");
}
empty = false;
buf.append(i);
if (storeAlive) {
buf.append("L");
}
if (killedByStore) {
buf.append("k");
}
}
buf.append("]");
return buf.toString();
}
/**
* Return whether or not given fact is the special TOP value.
*/
@Override
public boolean isTop(BitSet fact) {
return fact.get(topBit);
}
/**
* Return whether or not a store of given local is alive.
*
* @param fact
* a dataflow fact created by this analysis
* @param local
* the local
*/
public boolean isStoreAlive(BitSet fact, int local) {
return fact.get(local);
}
/**
* Return whether or not a store of given local was killed by a subsequent
* (dominated) store.
*/
public boolean killedByStore(BitSet fact, int local) {
return fact.get(local + killedByStoreOffset);
}
// public static void main(String[] argv) throws Exception {
// if (argv.length != 1) {
// System.err.println("Usage: " + LiveLocalStoreAnalysis.class.getName() +
// " <classfile>");
// System.exit(1);
// }
//
// String filename = argv[0];
//
// DataflowTestDriver<BitSet,LiveLocalStoreAnalysis> driver =
// new DataflowTestDriver<BitSet, LiveLocalStoreAnalysis>() {
//
// @Override
// public Dataflow<BitSet, LiveLocalStoreAnalysis>
// createDataflow(ClassContext classContext, Method method)
// throws CFGBuilderException, DataflowAnalysisException {
// return classContext.getLiveLocalStoreDataflow(method);
// }
// };
//
// driver.execute(filename);
// }
}