Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/* Soot - a J*va Optimization Framework
* Copyright (C) 2000 Feng Qian
*
* 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.
*/
/*
* Modified by the Sable Research Group and others 1997-1999.
* See the 'credits' file distributed with Soot for the complete list of
* contributors. (Soot is distributed at http://www.sable.mcgill.ca/soot)
*/
package soot.jimple.toolkits.annotation.arraycheck;
import soot.options.*;
import soot.* ;
import soot.toolkits.graph.*;
import soot.jimple.* ;
import java.util.* ;
class ArrayBoundsCheckerAnalysis
{
protected Map blockToBeforeFlow;
protected Map unitToBeforeFlow;
private final Map edgeMap;
private final Set edgeSet;
private HashMap stableRoundOfUnits;
private ArrayRefBlockGraph graph;
private final IntContainer zero = new IntContainer(0);
private boolean fieldin = false;
private HashMap> localToFieldRef;
private HashMap> fieldToFieldRef;
private final int strictness = 2;
private boolean arrayin = false;
private boolean csin = false;
private HashMap> localToExpr;
private boolean classfieldin = false;
private ClassFieldAnalysis cfield;
private boolean rectarray = false;
private HashSet rectarrayset;
private HashSet multiarraylocals;
private final ArrayIndexLivenessAnalysis ailanalysis;
/* A little bit different from ForwardFlowAnalysis */
public ArrayBoundsCheckerAnalysis(Body body,
boolean takeClassField,
boolean takeFieldRef,
boolean takeArrayRef,
boolean takeCSE,
boolean takeRectArray)
{
classfieldin = takeClassField;
fieldin = takeFieldRef;
arrayin = takeArrayRef;
csin = takeCSE;
rectarray = takeRectArray;
SootMethod thismethod = body.getMethod();
if (Options.v().debug())
G.v().out.println("ArrayBoundsCheckerAnalysis started on "+thismethod.getName());
ailanalysis = new ArrayIndexLivenessAnalysis(new ExceptionalUnitGraph(body), fieldin, arrayin, csin, rectarray);
if (fieldin)
{
this.localToFieldRef = ailanalysis.getLocalToFieldRef();
this.fieldToFieldRef = ailanalysis.getFieldToFieldRef();
}
if (arrayin)
{
if (rectarray)
{
this.multiarraylocals = ailanalysis.getMultiArrayLocals();
this.rectarrayset = new HashSet();
RectangularArrayFinder pgbuilder = RectangularArrayFinder.v();
Iterator localIt = multiarraylocals.iterator();
while (localIt.hasNext())
{
Local local = localIt.next();
MethodLocal mlocal = new MethodLocal(thismethod, local);
if (pgbuilder.isRectangular(mlocal))
this.rectarrayset.add(local);
}
}
}
if (csin)
{
this.localToExpr = ailanalysis.getLocalToExpr();
}
if (classfieldin)
{
this.cfield = ClassFieldAnalysis.v();
}
this.graph = new ArrayRefBlockGraph(body);
blockToBeforeFlow = new HashMap(graph.size()*2+1, 0.7f);
edgeMap = new HashMap(graph.size()*2+1, 0.7f);
edgeSet = buildEdgeSet(graph);
doAnalysis();
convertToUnitEntry();
if (Options.v().debug())
G.v().out.println("ArrayBoundsCheckerAnalysis finished.");
}
private void convertToUnitEntry()
{
unitToBeforeFlow = new HashMap();
Iterator blockIt = blockToBeforeFlow.keySet().iterator();
while (blockIt.hasNext())
{
Block block = blockIt.next();
Unit first = block.getHead();
unitToBeforeFlow.put(first, blockToBeforeFlow.get(block));
}
}
/** buildEdgeSet creates a set of edges from directed graph.
*/
public Set buildEdgeSet(DirectedGraph dg)
{
HashSet edges = new HashSet();
Iterator blockIt = dg.iterator();
while (blockIt.hasNext())
{
Block s = blockIt.next();
List preds = graph.getPredsOf(s);
List succs = graph.getSuccsOf(s);
/* Head units has in edge from itself to itself.*/
if (preds.size() == 0)
{
edges.add(new FlowGraphEdge(s,s));
}
/* End units has out edge from itself to itself.*/
if (succs.size() == 0)
{
edges.add(new FlowGraphEdge(s,s));
}
else
{
Iterator succIt = succs.iterator();
while (succIt.hasNext())
{
edges.add(new FlowGraphEdge(s, succIt.next()));
}
}
}
return edges;
}
public Object getFlowBefore(Object s)
{
return unitToBeforeFlow.get(s);
}
/* merge all preds' out set */
private void mergebunch(Object ins[], Object s, Object prevOut, Object out)
{
WeightedDirectedSparseGraph prevgraph = (WeightedDirectedSparseGraph)prevOut,
outgraph = (WeightedDirectedSparseGraph)out;
WeightedDirectedSparseGraph[] ingraphs
= new WeightedDirectedSparseGraph[ins.length];
for (int i=0; i changedSuccs;
/* An temporary object. */
FlowGraphEdge tmpEdge = new FlowGraphEdge();
/* If any output flow set has unknow value, it will be put in this set
*/
HashSet unvisitedNodes = new HashSet(graph.size()*2+1, 0.7f);
/* adjust livelocals set */
{
Iterator blockIt = graph.iterator();
while (blockIt.hasNext())
{
Block block = (Block)blockIt.next();
HashSet livelocals = (HashSet)ailanalysis.getFlowBefore(block.getHead());
livelocals.add(zero);
}
}
/* Set initial values and nodes to visit. */
{
stableRoundOfUnits = new HashMap();
Iterator it = graph.iterator();
while(it.hasNext())
{
Block block = (Block)it.next();
unvisitedNodes.add(block);
stableRoundOfUnits.put(block, new Integer(0));
/* only take out the necessary node set. */
HashSet livelocals = (HashSet)ailanalysis.getFlowBefore(block.getHead());
blockToBeforeFlow.put(block, new WeightedDirectedSparseGraph(livelocals, false));
}
Iterator edgeIt = edgeSet.iterator();
while (edgeIt.hasNext())
{
FlowGraphEdge edge = edgeIt.next();
Block target = (Block)edge.to;
HashSet livelocals = (HashSet)ailanalysis.getFlowBefore(target.getHead());
edgeMap.put(edge, new WeightedDirectedSparseGraph(livelocals, false));
}
}
/* perform customized initialization. */
{
List headlist = graph.getHeads();
Iterator headIt = headlist.iterator();
while (headIt.hasNext())
{
Object head = headIt.next() ;
FlowGraphEdge edge = new FlowGraphEdge(head, head);
WeightedDirectedSparseGraph initgraph =
edgeMap.get(edge) ;
initgraph.setTop();
}
}
/* Perform fixed point flow analysis.
*/
{
WeightedDirectedSparseGraph beforeFlow =
new WeightedDirectedSparseGraph(null, false);
// DebugMsg.counter1 += allUnits.size();
while(!changedUnits.isEmpty())
{
Block s = (Block) changedUnits.removeFirst();
changedUnitsSet.remove(s);
// DebugMsg.counter2++;
/* previousAfterFlow, old-out, it is null initially */
WeightedDirectedSparseGraph previousBeforeFlow =
blockToBeforeFlow.get(s);
beforeFlow.setVertexes(previousBeforeFlow.getVertexes());
// Compute and store beforeFlow
{
List preds = graph.getPredsOf(s);
/* the init node */
if (preds.size() == 0)
{
tmpEdge.changeEndUnits(s,s);
copy(edgeMap.get(tmpEdge), beforeFlow);
}
else if (preds.size() == 1)
{
tmpEdge.changeEndUnits(preds.get(0),s);
copy(edgeMap.get(tmpEdge), beforeFlow);
// widenGraphs(beforeFlow, previousBeforeFlow);
}
else
{
/* has 2 or more preds, Updated by Feng. */
Object predFlows[] = new Object[preds.size()] ;
boolean allUnvisited = true;
Iterator predIt = preds.iterator();
int index = 0 ;
int lastVisited = 0;
while(predIt.hasNext())
{
Object pred = predIt.next();
tmpEdge.changeEndUnits(pred,s);
if (!unvisitedNodes.contains(pred))
{
allUnvisited = false;
lastVisited = index;
}
predFlows[index++] = edgeMap.get(tmpEdge);
}
// put the visited node as the first one
if (allUnvisited)
{
G.v().out.println("Warning : see all unvisited node");
}
else
{
Object tmp = predFlows[0];
predFlows[0] = predFlows[lastVisited];
predFlows[lastVisited] = tmp;
}
mergebunch(predFlows, s, previousBeforeFlow, beforeFlow);
}
copy(beforeFlow, previousBeforeFlow);
}
/* Compute afterFlow and store it.
* Now we do not have afterFlow, we only have the out edges.
* Different out edges may have different flow set.
* It returns back a list of succ units that edge has been
* changed.
*/
{
changedSuccs = flowThrough(beforeFlow, s);
}
{
for (int i = 0; i < changedSuccs.size(); i++)
{
Object succ = changedSuccs.get(i);
if (!changedUnitsSet.contains(succ))
{
changedUnits.add(succ);
changedUnitsSet.add(succ);
}
}
}
/* Decide to remove or add unit from/to unvisitedNodes set */
{
unvisitedNodes.remove(s);
}
}
}
finish = new Date();
if (Options.v().debug())
{
long runtime = finish.getTime()-start.getTime();
long mins = runtime/60000;
long secs = (runtime/60000)/1000;
G.v().out.println("Doing analysis finished."
+ " It took "+mins+" mins and "+secs+ "secs.");
}
}
/* Flow go through a node, the output will be put into edgeMap, and also
* the changed succ will be in a list to return back.
*/
private List
