Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /* Soot - a J*va Optimization Framework
   * Copyright (C) 2003 Jennifer Lhotak
   *
   * 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 soot.jimple.toolkits.annotation.parity;
 
 import soot.*;
 import soot.util.*;
 import java.util.*;
 
 import soot.jimple.*;
 import soot.options.*;
 
 // STEP 1: What are we computing?
 // SETS OF PAIRS of form (X, T) => Use ArraySparseSet.
 //
 // STEP 2: Precisely define what we are computing.
 // For each statement compute the parity of all variables 
 // in the program.
 // 
 // STEP 3: Decide whether it is a backwards or forwards analysis.
 // FORWARDS
 //
 //
 public class ParityAnalysis extends ForwardFlowAnalysis {
 
     private UnitGraph g;
     private final static String TOP = "top";
     private final static String BOTTOM = "bottom";
     private final static String EVEN = "even";
     private final static String ODD = "odd";
 
     private LiveLocals filter;
     
     public ParityAnalysis(UnitGraph gLiveLocals filter)
     {
         super(g);
         this. = g;
 
         this. = filter;
         
          = new HashMap<StmtHashMap>();
         buildBeforeFilterMap();
         
          = new HashMap<StmtHashMap>();
         
         doAnalysis();
         
     }
 
     public ParityAnalysis(UnitGraph g){
         super(g);
         this. = g;
 
         doAnalysis();
     }
     
     private void buildBeforeFilterMap(){
         
         Iterator it = .getBody().getUnits().iterator();
         while (it.hasNext()){
             Stmt s = (Stmt)it.next();
             //if (!(s instanceof DefinitionStmt)) continue;
             //Value left = ((DefinitionStmt)s).getLeftOp();
             //if (!(left instanceof Local)) continue;
         
             //if (!((left.getType() instanceof IntegerType) || (left.getType() instanceof LongType))) continue;
             List list = .getLiveLocalsBefore(s);
             HashMap map = new HashMap(); 
             Iterator listIt = list.iterator();
             while (listIt.hasNext()){
                 map.put(listIt.next(), );
             }
             .put(smap);
         } 
         //System.out.println("init filtBeforeMap: "+filterUnitToBeforeFlow);           
     }
 
 // STEP 4: Is the merge operator union or intersection?
 // 
 // merge  | bottom | even   | odd   | top
 // -------+--------+--------+-------+--------
// bottom | bottom | even   | odd   | top
// -------+--------+--------+-------+--------
// even   | even   | even   | top   | top
// -------+--------+--------+-------+--------
// odd    | odd    | top    | odd   | top  
// -------+--------+--------+-------+--------
// top    | top    | top    | top   | top
//
    protected void merge(Object in1Object in2Object out)
    {
	HashMap inMap1 = (HashMapin1;
	HashMap inMap2 = (HashMapin2;
	HashMap<ObjectStringoutMap = (HashMap<ObjectString>) out;
	Set keys = inMap1.keySet();
	Iterator it = keys.iterator();
	while (it.hasNext()) {
	 	Object var1 = it.next();
        //System.out.println(var1);
		String inVal1 = (String)inMap1.get(var1);
        //System.out.println(inVal1);
		String inVal2 = (String)inMap2.get(var1);
        //System.out.println(inVal2);
       // System.out.println("before out "+outMap.get(var1));
        if (inVal2 == null){
            outMap.put(var1inVal1);
        }
	    else if (inVal1.equals()) {
			outMap.put(var1inVal2);
		}
		else if (inVal2.equals()) {
		        outMap.put(var1inVal1);
		}
		else if ((inVal1.equals()) &&
		   	(inVal2.equals())) {
			outMap.put(var1);
		}
		else if ((inVal1.equals()) &&
		   	(inVal2.equals())) {
			outMap.put(var1);
		}
		else {
			outMap.put(var1);
		}
	}
    }
// STEP 5: Define flow equations.
// in(s) = ( out(s) minus defs(s) ) union uses(s)
//
    protected void copy(Object sourceObject dest) {
        //System.out.println("copy");
        HashMap sourceIn = (HashMap)source;
        HashMap destOut = (HashMap)dest;
        //dest = new HashMap();
        //HashMap destOut = new HashMap();
        destOut.putAll(sourceIn);
        dest = destOut;
    }
   
    // Parity Tests: 	even + even = even
    // 			even + odd = odd 
    // 			odd + odd = even
    //
    // 			even * even = even
    // 			even * odd = even
    // 			odd * odd = odd
    //
    // 			constants are tested mod 2
    //
    private String getParity(HashMap<ValueStringinValue val) {
        //System.out.println("get Parity in: "+in);
        if ((val instanceof AddExpr) | (val instanceof SubExpr)) {
        	String resVal1 = getParity(in, ((BinopExpr)val).getOp1());
	        String resVal2 = getParity(in, ((BinopExpr)val).getOp2());
	        if (resVal1.equals() | resVal2.equals()) {
                return ;
	        }  
            else if (resVal1.equals() | resVal2.equals()){
                return ;
            }
	        else if (resVal1.equals(resVal2)) {
                return ;
	        }
	        else {
	            return ;
	        }
        }
        else if (val instanceof MulExpr) {
	        String resVal1 = getParity(in, ((BinopExpr)val).getOp1());
	        String resVal2 = getParity(in, ((BinopExpr)val).getOp2());
	        if (resVal1.equals() | resVal2.equals()) {
	            return ;
	        }
            else if (resVal1.equals() | resVal2.equals()){
                return ;
            }
	        else if (resVal1.equals() && resVal2.equals()) {
	            return ;
	        }
	        else {
	            return ;
	        }
        }
        else if (val instanceof IntConstant) {
	        int value = ((IntConstant)val).;
	        if ((value % 2) == 0) {
                return ;
	        }
	        else {
	            return ;
	        }
        }
        else if (val instanceof LongConstant) {
	        long value = ((LongConstant)val).;
	        if ((value % 2) == 0) {
	            return ;
	        }
	        else {
	            return ;
	        }
        }
        else if (in.containsKey(val)) {
      	    return in.get(val);
        }
        else {
            return ;
        }
     
    }
    
    
    protected void flowThrough(Object inValueObject unit,
            Object outValue)
    {
        HashMap in  = (HashMapinValue;
        HashMap<ValueStringout = (HashMap<ValueString>) outValue;
        Stmt    s   = (Stmt)    unit;
	    // copy in to out 
	    out.putAll(in);
        // for each stmt where leftOp is defintionStmt find the parity
	    // of rightOp and update parity to EVEN, ODD or TOP
        //boolean useS = false;
        
	    if (s instanceof DefinitionStmt) {
	        Value left = ((DefinitionStmt)s).getLeftOp();
	        if (left instanceof Local) {
                if ((left.getType() instanceof IntegerType) || (left.getType() instanceof LongType)){
                    //useS = true;
	  	            Value right = ((DefinitionStmt)s).getRightOp();
		            out.put(leftgetParity(outright));
                }
	        }
	    }
        // get all use and def boxes of s 
        // if use or def is int or long constant add their parity
        Iterator it = s.getUseAndDefBoxes().iterator();
        while (it.hasNext()){
            Object next = it.next();
            Value val = ((ValueBox)next).getValue();
            //System.out.println("val: "+val.getClass());
            if (val instanceof ArithmeticConstant){
                out.put(valgetParity(outval));
                //System.out.println("out map: "+out);
            }
        }
        
        //if (useS){
        if (Options.v().interactive_mode()){
            buildAfterFilterMap(s);
            updateAfterFilterMap(s);
        }
        //}
    }
    
    private void buildAfterFilterMap(Stmt s){
        
        List list = .getLiveLocalsAfter(s);
        HashMap map = new HashMap(); 
        Iterator listIt = list.iterator();
        while (listIt.hasNext()){
            map.put(listIt.next(), );
        }
        .put(smap);
        //System.out.println("built afterflow filter map: "+filterUnitToAfterFlow);
    }
// STEP 6: Determine value for start/end node, and
// initial approximation.
//
// start node: locals with BOTTOM
// initial approximation: locals with BOTTOM
    protected Object entryInitialFlow()
    {
	/*HashMap initMap = new HashMap();
	Chain locals = g.getBody().getLocals();
	Iterator it = locals.iterator();
	while (it.hasNext()) {
	  initMap.put(it.next(), BOTTOM);
	}
        return initMap;*/
        return newInitialFlow();
    }
    private void updateBeforeFilterMap(){
    
        Iterator<StmtfilterIt = .keySet().iterator();
        while (filterIt.hasNext()){
            Stmt s = filterIt.next();
            HashMap allData = (HashMap).get(s);
            
            HashMap filterData = (HashMap.get(s);
            .put(supdateFilter(allDatafilterData));
            
        }
    }
        
    private void updateAfterFilterMap(Stmt s){
    
        HashMap allData = (HashMap).get(s);
            
        HashMap filterData = (HashMap.get(s);
        .put(supdateFilter(allDatafilterData));
            
    }
        
    private HashMap updateFilter(HashMap allDataHashMap filterData){
        if (allData == nullreturn filterData;
        Iterator<ValuefilterVarsIt = filterData.keySet().iterator();
        ArrayList<ValuetoRemove = new ArrayList<Value>();
        while (filterVarsIt.hasNext()){
            Value v = filterVarsIt.next();
            if (allData.get(v) == null){
                toRemove.add(v);
                //filterData.put(v, new HashMap());
            }
            else {
                filterData.put(vallData.get(v));
            }
        }
        Iterator<ValueremoveIt = toRemove.iterator();
        while (removeIt.hasNext()){
            filterData.remove(removeIt.next());
        }
        return filterData;
    }
    protected Object newInitialFlow()
    {
	    HashMap<ValueStringinitMap = new HashMap<ValueString>();
	    Chain locals = .getBody().getLocals();
	    Iterator it = locals.iterator();
	    while (it.hasNext()) {
            Local next = (Local)it.next();
            //System.out.println("next local: "+next);
            if ((next.getType() instanceof IntegerType) || (next.getType() instanceof LongType)){
	            initMap.put(next);
            }
	    }
    
        Iterator boxIt = .getBody().getUseAndDefBoxes().iterator();
        while (boxIt.hasNext()){
            Value val = ((ValueBox)boxIt.next()).getValue();
            if (val instanceof ArithmeticConstant) {
                initMap.put(valgetParity(initMapval));
            }
        }
        if (Options.v().interactive_mode()){
            updateBeforeFilterMap();
        }
        
        return initMap;
    }
        
New to GrepCode? Check out our FAQ X