Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /* Soot - a J*va Optimization Framework
   * Copyright (C) 1997-1999 Raja Vallee-Rai
   *
   * 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.toolkits.scalar;
 import soot.options.*;
 
 import soot.*;
 import soot.util.*;
 import java.util.*;
 
 
 // FSet version
 


Analysis that provides an implementation of the LocalDefs interface.
 
 public class SimpleLocalDefs implements LocalDefs
 {
Computes the analysis given a UnitGraph computed from a method body. It is recommended that a ExceptionalUnitGraph (or similar) be provided for correct results in the case of exceptional control flow.

Parameters:
g a graph on which to compute the analysis.
See also:
soot.toolkits.graph.ExceptionalUnitGraph
 
     public SimpleLocalDefs(UnitGraph g)
     {
         if(Options.v().time())
             Timers.v()..start();
         
         if(Options.v().verbose())
             G.v()..println("[" + g.getBody().getMethod().getName() +
                                "]     Constructing SimpleLocalDefs...");
     
         LocalDefsFlowAnalysis analysis = new LocalDefsFlowAnalysis(g);
         
         if(Options.v().time())
             Timers.v()..start();
 
         // Build localUnitPairToDefs map
         {
             Iterator unitIt = g.iterator();
 
              = new HashMap<LocalUnitPairList>(g.size() * 2 + 1, 0.7f);
 
             while(unitIt.hasNext())
                 {
                     Unit s = (UnitunitIt.next();
 
                     Iterator boxIt = s.getUseBoxes().iterator();
 
                     while(boxIt.hasNext())
                         {
                             ValueBox box = (ValueBoxboxIt.next();
 
                             if(box.getValue() instanceof Local)
                                 {
                                     Local l = (Localbox.getValue();
                                     LocalUnitPair pair = new LocalUnitPair(ls);
 
                                     if(!.containsKey(pair))
                                         {
                                             IntPair intPair = analysis.localToIntPair.get(l);
 					    
                                             ArrayPackedSet value = (ArrayPackedSetanalysis.getFlowBefore(s);
                                            List unitLocalDefs = value.toList(intPair.op1intPair.op2);
                                            .put(pair, Collections.unmodifiableList(unitLocalDefs));
                                        }
                                }
                        }
                }
        }
        if(Options.v().time())
            Timers.v()..end();
                
        if(Options.v().time())
            Timers.v()..end();
	if(Options.v().verbose())
	    G.v()..println("[" + g.getBody().getMethod().getName() +
                               "]     SimpleLocalDefs finished.");
    }
    public boolean hasDefsAt(Local lUnit s)
    {
        return .containsKeynew LocalUnitPair(l,s) );
    }
    public List<UnitgetDefsOfAt(Local lUnit s)
    {
        LocalUnitPair pair = new LocalUnitPair(ls);
        List<UnittoReturn = .get(pair);
        
        if(toReturn == null)
            throw new RuntimeException("Illegal LocalDefs query; local " + l + " has no definition at " + 
                                       s.toString());
               
        
        return toReturn;
    }
    /*
      public List getDefsOfBefore(Local l, Unit s)
      {
      IntPair pair = (IntPair) analysis.localToIntPair.get(l);
      FSet value = (FSet) analysis.getValueBeforeUnit(s);
      List unitLocalDefs = value.toList(pair.op1, pair.op2);
      return unitLocalDefs;
      }*/
    /*
      Object[] elements = ((FSet) analysis.getValueBeforeUnit(s)).toArray();
      List listOfDefs = new LinkedList();
      // Extract those defs which correspond to this local
      {
      for(int i = 0; i < elements.length; i++)
      {
      DefinitionUnit d = (DefinitionUnit) elements[i];
      if(d.getLeftOp() == l)
      listOfDefs.add(d);
      }
      }
      // Convert the array so that it's of an appropriate form
      {
      Object[] objects = listOfDefs.toArray();
      DefinitionUnit[] defs = new DefinitionUnit[objects.length];
      for(int i = 0; i < defs.length; i++)
      defs[i] = (DefinitionUnit) objects[i];
      return defs;
      }
      }
      }
    */
    /*
      public DefinitionUnit[] getDefsOfAfter(Local l, Unit s)
      {
      Object[] elements = ((FSet) analysis.getValueAfterUnit(s)).toArray();
      List listOfDefs = new LinkedList();
      // Extract those defs which correspond to this local
      {
      for(int i = 0; i < elements.length; i++)
      {
      DefinitionUnit d = (DefinitionUnit) elements[i];
      if(d.getLeftOp() == l)
      listOfDefs.add(d);
      }
      }
      // Convert the array so that it's of an appropriate form
      {
      Object[] objects = listOfDefs.toArray();
      DefinitionUnit[] defs = new DefinitionUnit[objects.length];
      for(int i = 0; i < defs.length; i++)
      defs[i] = (DefinitionUnit) objects[i];
      return defs;
      }
      }
      public DefinitionUnit[] getDefsBefore(Unit s)
      {
      Object[] elements = ((FSet) analysis.getValueBeforeUnit(s)).toArray();
      DefinitionUnit[] defs = new DefinitionUnit[elements.length];
      for(int i = 0; i < elements.length; i++)
      defs[i] = (DefinitionUnit) elements[i];
      return defs;
      }
      public DefinitionUnit[] getDefsAfter(Unit s)
      {
      Object[] elements = ((FSet) analysis.getValueAfterUnit(s)).toArray();
      DefinitionUnit[] defs = new DefinitionUnit[elements.length];
      for(int i = 0; i < elements.length; i++)
      defs[i] = (DefinitionUnit) elements[i];
      return defs;
      }
    */
class IntPair
    int op1op2;
    public IntPair(int op1int op2)
    {
        this. = op1;
        this. = op2;
    }
    {
        super(g);
        Object[] defs;
        FlowUniverse defUniverse;
        if(Options.v().time())
            Timers.v()..start();
        // Create a list of all the definitions and group defs of the same local together
        {
            Map<LocalArrayListlocalToDefList = new HashMap<LocalArrayList>(g.getBody().getLocalCount() * 2 + 1, 0.7f);
            // Initialize the set of defs for each local to empty
            {
                Iterator localIt = g.getBody().getLocals().iterator();
                while(localIt.hasNext())
                    {
                        Local l = (LocallocalIt.next();
                        localToDefList.put(lnew ArrayList());
                    }
            }
            // Fill the sets up
            {
                Iterator it = g.iterator();
                while(it.hasNext())
                    {
                        Unit s = (Unitit.next();
                    
                        List defBoxes = s.getDefBoxes();
                        if(!defBoxes.isEmpty()) {
                            if(!(defBoxes.size() ==1)) 
                                throw new RuntimeException("invalid number of def boxes");
                            
                            if(((ValueBox)defBoxes.get(0)).getValue() instanceof Local) {
                                Local defLocal = (Local) ((ValueBox)defBoxes.get(0)).getValue();
                                List<Unitl = localToDefList.get(defLocal);
                            
                                if(l == null)
                                    throw new RuntimeException("local " + defLocal + " is used but not declared!");
                                else
                                    l.add(s);
                            }
                        }
                    
                    }
            }
            // Generate the list & localToIntPair
            {
                Iterator it = g.getBody().getLocals().iterator();
                List defList = new LinkedList();
                int startPos = 0;
                 = new HashMap<LocalIntPair>(g.getBody().getLocalCount() * 2 + 1, 0.7f);
                // For every local, add all its defs
                {
                    while(it.hasNext())
                        {
                            Local l = (Localit.next();
                            Iterator jt = localToDefList.get(l).iterator();
                            int endPos = startPos - 1;
                            while(jt.hasNext())
                                {
                                    defList.add(jt.next());
                                    endPos++;
                                }
                            .put(lnew IntPair(startPosendPos));
                            // G.v().out.println(startPos + ":" + endPos);
                            startPos = endPos + 1;
                        }
                }
                defs = defList.toArray();
                defUniverse = new ArrayFlowUniverse(defs);
            }
        }
         = new ArrayPackedSet(defUniverse);
        // Create the preserve sets for each local.
        {
            Map<LocalFlowSetlocalToKillSet = new HashMap<LocalFlowSet>(g.getBody().getLocalCount() * 2 + 1, 0.7f);
             = new HashMap<LocalBoundedFlowSet>(g.getBody().getLocalCount() * 2 + 1, 0.7f);
            Chain locals = g.getBody().getLocals();
            // Initialize to empty set
            {
                Iterator localIt = locals.iterator();
                while(localIt.hasNext())
                    {
                        Local l = (LocallocalIt.next();
                        localToKillSet.put(l.clone());
                    }
            }
            for (Object element : defs) {
			    Unit s = (Unitelement;
			    
			    List defBoxes = s.getDefBoxes();
			    if(!(defBoxes.size() ==1)) 
			        throw new RuntimeException("SimpleLocalDefs: invalid number of def boxes");
			            
			    if(((ValueBox)defBoxes.get(0)).getValue() instanceof Local) {
			        Local defLocal = (Local) ((ValueBox)defBoxes.get(0)).getValue();
			        BoundedFlowSet killSet = (BoundedFlowSetlocalToKillSet.get(defLocal);
			        killSet.add(skillSet);
			        
			    }
			}
            
            // Store complement
            {
                Iterator localIt = locals.iterator();
                while(localIt.hasNext())
                    {
                        Local l = (LocallocalIt.next();
                        BoundedFlowSet killSet = (BoundedFlowSetlocalToKillSet.get(l);
                        killSet.complement(killSet);
                        .put(lkillSet);
                    }
            }
        }
        if(Options.v().time())
            Timers.v()..end();
        if(Options.v().time())
            Timers.v()..start();
        doAnalysis();
        
        if(Options.v().time())
            Timers.v()..end();
    }
    
    protected Object newInitialFlow()
    {
        return .clone();
    }
    protected Object entryInitialFlow()
    {
        return .clone();
    }
    protected void flowThrough(Object inValueObject dObject outValue)
    {
        FlowSet in = (FlowSetinValueout = (FlowSetoutValue;
        Unit unit = (Unit)d;
        List defBoxes = unit.getDefBoxes();
        if(!defBoxes.isEmpty()) {
            if(!(defBoxes.size() ==1)) 
                throw new RuntimeException("SimpleLocalDefs: invalid number of def boxes");
                          
            Value value = ((ValueBox)defBoxes.get(0)).getValue();
            if(value  instanceof Local) {
                Local defLocal = (Localvalue;
            
                // Perform kill on value
                in.intersection(.get(defLocal), out);
                // Perform generation
                out.add(unitout);
            } else { 
                in.copy(out);
                return;
            }
        
        }
        else
            in.copy(out);
    }
    protected void copy(Object sourceObject dest)
    {
        FlowSet sourceSet = (FlowSetsource,
            destSet = (FlowSetdest;
        
        sourceSet.copy(destSet);
    }
    protected void merge(Object in1Object in2Object out)
    {
        FlowSet inSet1 = (FlowSetin1,
            inSet2 = (FlowSetin2;
        
        FlowSet outSet = (FlowSetout;
        
        inSet1.union(inSet2outSet);
    }
New to GrepCode? Check out our FAQ X