Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /* Soot - a J*va Optimization Framework
   * Copyright (C) 2003, 2004 Ondrej 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;
 import java.util.*;
 import java.io.*;
 import soot.util.*;
 import soot.jimple.*;
 import  soot.grimp.*;
 import  soot.jimple.toolkits.annotation.tags.*;
 //import soot.javaToJimple.toolkits.*; 
 import soot.tagkit.*;
Manages the Packs containing the various phases and their options.
 
 public class PackManager {
 	public static boolean DEBUG=false;
     public PackManagerSingletons.Global g ) { PhaseOptions.v().setPackManager(this); init(); }
 
     public boolean onlyStandardPacks() { return ; }
     private boolean onlyStandardPacks = false;
     void notifyAddPack() {
          = false;
     }
 
     private void init()
     {
         Pack p;
 
         // Jimple body creation
         addPack(p = new JimpleBodyPack());
         {
             p.add(new Transform("jb.tt", soot.toolkits.exceptions.TrapTightener.v()));
             p.add(new Transform("jb.ls", LocalSplitter.v()));
             p.add(new Transform("jb.a", Aggregator.v()));
             p.add(new Transform("jb.ule", UnusedLocalEliminator.v()));
             p.add(new Transform("jb.tr", TypeAssigner.v()));
             p.add(new Transform("jb.ulp", LocalPacker.v()));
             p.add(new Transform("jb.lns", LocalNameStandardizer.v()));
             p.add(new Transform("jb.cp", CopyPropagator.v()));
             p.add(new Transform("jb.dae", DeadAssignmentEliminator.v()));
             p.add(new Transform("jb.cp-ule", UnusedLocalEliminator.v()));
             p.add(new Transform("jb.lp", LocalPacker.v()));
             p.add(new Transform("jb.ne", NopEliminator.v()));
             p.add(new Transform("jb.uce", UnreachableCodeEliminator.v()));
         }
 
 
         // Jimple transformation pack
         addPack(p = new BodyPack("jtp"));
         
         // Jimple optimization pack
         addPack(p = new BodyPack("jop"));
         {
             p.add(new Transform("jop.cse", CommonSubexpressionEliminator.v()));
             p.add(new Transform("jop.bcm", BusyCodeMotion.v()));
             p.add(new Transform("jop.lcm", LazyCodeMotion.v()));
             p.add(new Transform("jop.cp", CopyPropagator.v()));
             p.add(new Transform("jop.cpf", ConstantPropagatorAndFolder.v()));
            p.add(new Transform("jop.cbf", ConditionalBranchFolder.v()));
            p.add(new Transform("jop.dae", DeadAssignmentEliminator.v()));
            p.add(new Transform("jop.nce"new NullCheckEliminator()));
            p.add(new Transform("jop.uce1", UnreachableCodeEliminator.v()));
            p.add(new Transform("jop.ubf1", UnconditionalBranchFolder.v()));
            p.add(new Transform("jop.uce2", UnreachableCodeEliminator.v()));
            p.add(new Transform("jop.ubf2", UnconditionalBranchFolder.v()));
            p.add(new Transform("jop.ule", UnusedLocalEliminator.v()));
        }
        // Jimple annotation pack
        addPack(p = new BodyPack("jap"));
        {
            p.add(new Transform("jap.npc", NullPointerChecker.v()));
            p.add(new Transform("jap.npcolorer", NullPointerColorer.v()));
            p.add(new Transform("jap.abc", ArrayBoundsChecker.v()));
            p.add(new Transform("jap.profiling", ProfilingGenerator.v()));
            p.add(new Transform("jap.sea", SideEffectTagger.v()));
            p.add(new Transform("jap.cgtagger", CallGraphTagger.v()));
            p.add(new Transform("jap.parity", ParityTagger.v()));
            p.add(new Transform("jap.pat", ParameterAliasTagger.v()));
            p.add(new Transform("jap.rdtagger", ReachingDefsTagger.v()));
            p.add(new Transform("jap.lvtagger", LiveVarsTagger.v()));
            p.add(new Transform("jap.che", CastCheckEliminatorDumper.v()));
            p.add(new Transform("jap.umt"new UnreachableMethodTransformer()));
            p.add(new Transform("jap.lit", LoopInvariantFinder.v()));
            p.add(new Transform("jap.aet", AvailExprTagger.v()));
            p.add(new Transform("jap.dmt", DominatorsTagger.v()));
	       
        }
        // CFG Viewer 
        /*addPack(p = new BodyPack("cfg"));
        {
            p.add(new Transform("cfg.output", CFGPrinter.v()));
        }*/
        
       
        
         = true;
    }
    public static PackManager v() { 
        return G.v().soot_PackManager();
    }
    private final Map<StringPackpackNameToPack = new HashMap<StringPack>();
    private final List<PackpackList = new LinkedList<Pack>();
    private void addPackPack p ) {
        if.containsKeyp.getPhaseName() ) )
            throw new RuntimeException"Duplicate pack "+p.getPhaseName() );
        .putp.getPhaseName(), p );
        .addp );
    }
    public boolean hasPack(String phaseName) {
        return getPhasephaseName ) != null;
    }
    public Pack getPack(String phaseName) {
        Pack p = .get(phaseName);
        return p;
    }
    public boolean hasPhase(String phaseName) {
        return getPhase(phaseName) != null;
    }
    public HasPhaseOptions getPhase(String phaseName) {
        int index = phaseName.indexOf"." );
        ifindex < 0 ) return getPackphaseName );
        String packName = phaseName.substring(0,index);
        if( !hasPackpackName ) ) return null;
        return getPackpackName ).getphaseName );
    }
    public Transform getTransform(String phaseName) {
        return (TransformgetPhasephaseName );
    }
    public Collection<PackallPacks() {
        return Collections.unmodifiableList );
    }
    public void runPacks() {
        if (Options.v().src_prec() == . && Options.v().keep_line_number()){
            LineNumberAdder lineNumAdder = LineNumberAdder.v();
            lineNumAdder.internalTransform(""null);
        }
        
        retrieveAllBodies();
        
        if (Options.v().interactive_mode()){
            if (InteractionHandler.v().getInteractionListener() == null){
                G.v()..println("Cannot run in interactive mode. No listeners available. Continuing in regular mode.");
                Options.v().set_interactive_mode(false);
            }
            else {
                G.v()..println("Running in interactive mode.");
            }
        }
        
        runBodyPacks();
        handleInnerClasses();
    }
    
    public void coffiMetrics() {
      int tV = 0, tE = 0, hM = 0;
      double aM = 0;
      HashMap<SootMethodint[]> hashVem = ...;
      Iterator<SootMethodit = hashVem.keySet().iterator();
      while (it.hasNext()) {
        int vem[] = hashVem.get(it.next());
        tV+= vem[0];
        tE+= vem[1];
        aM+= vem[2];
        if (vem[2]>hMhM = vem[2];
      }
      if (hashVem.size()>0)
        aM/=hashVem.size();
      
      G.v()..println("Vertices, Edges, Avg Degree, Highest Deg:    "+tV+"  "+tE+"  "+aM+"  "+hM);
    }
    public void runBodyPacks() {
        runBodyPacksreachableClasses() );
    }
    private void runBodyPacksIterator classes ) {
        whileclasses.hasNext() ) {
            SootClass cl = (SootClassclasses.next();
            runBodyPackscl );
        }
    }
    private void handleInnerClasses(){
       InnerClassTagAggregator agg = InnerClassTagAggregator.v();
       agg.internalTransform(""null);
    }
    private void releaseBodiesIterator classes ) {
        whileclasses.hasNext() ) {
            SootClass cl = (SootClassclasses.next();
            releaseBodiescl );
        }
    }
    private Iterator reachableClasses() {
        return Scene.v().getApplicationClasses().iterator();
    }
    private void runBodyPacks(SootClass c) {
        boolean produceJimple = true;
        //here we create a copy of the methods so that transformers are able
        //to add method bodies during the following iteration;
        //such adding of methods happens in rare occasions: for instance when
        //resolving a method reference to a non-existing method, then this
        //method is created as a phantom method when phantom-refs are enabled
        LinkedList<SootMethodmethodsCopy = new LinkedList<SootMethod>(c.getMethods());
        Iterator methodIt = methodsCopy.iterator();
        while (methodIt.hasNext()) {
            SootMethod m = (SootMethodmethodIt.next();
            
            if(){
            	if(m.getExceptions().size()!=0)
            		..println("PackManager printing out jimple body exceptions for method "+m.toString()+" " + m.getExceptions().toString());
            }
            
            if (!m.isConcrete()) continue;
            if (produceJimple) {
                JimpleBody body =(JimpleBodym.retrieveActiveBody();
                PackManager.v().getPack("jtp").apply(body);
                if( Options.v().validate() ) {
                    body.validate();
                }
                PackManager.v().getPack("jop").apply(body);
                PackManager.v().getPack("jap").apply(body);
            }
            
            //PackManager.v().getPack("cfg").apply(m.retrieveActiveBody());
        }
            
    }
    private void releaseBodiesSootClass cl ) {
        Iterator methodIt = cl.methodIterator();
        while (methodIt.hasNext()) {
            SootMethod m = (SootMethodmethodIt.next();
            if (m.hasActiveBody())
                m.releaseActiveBody();
        }
    }
    private void retrieveAllBodies() {
        Iterator clIt = reachableClasses();
        whileclIt.hasNext() ) {
            SootClass cl = (SootClassclIt.next();
            Iterator methodIt = cl.methodIterator();
            while (methodIt.hasNext()) {
                SootMethod m = (SootMethodmethodIt.next();
                if( && cl.isApplicationClass()){                	
                	if(m.getExceptions().size()!=0)
                		..println("PackManager printing out from within retrieveAllBodies exceptions for method "+m.toString()+" " + m.getExceptions().toString());
                	else
                		..println("in retrieveAllBodies......Currently Method "m.toString() +" has no exceptions ");
                }
                ifm.isConcrete() ) {
                    m.retrieveActiveBody();
                }
            }
        }
    }
New to GrepCode? Check out our FAQ X