Package soot.jimple.toolkits.thread.mhp.pegcallgraph

Examples of soot.jimple.toolkits.thread.mhp.pegcallgraph.PegCallGraph


    CallGraph callGraph = Scene.v().getCallGraph();

    // Get a call graph trimmed to contain only the relevant methods (non-lib, non-native)
//    G.v().out.println("    MHP: PegCallGraph");
    PegCallGraph pecg = new PegCallGraph(callGraph);
     
      // Find allocation nodes that are run more than once
      // Also find methods that are run more than once
//    G.v().out.println("    MHP: AllocNodesFinder");
    AllocNodesFinder anf = new AllocNodesFinder(pecg, callGraph, (PAG) pta);
    Set<AllocNode> multiRunAllocNodes = anf.getMultiRunAllocNodes();
    Set<Object> multiCalledMethods = anf.getMultiCalledMethods();

    // Find Thread.start() and Thread.join() statements (in live code)
//    G.v().out.println("    MHP: StartJoinFinder");
    StartJoinFinder sjf = new StartJoinFinder(callGraph, (PAG) pta); // does analysis
    Map<Stmt, List<AllocNode>> startToAllocNodes = sjf.getStartToAllocNodes();
    Map<Stmt, List<SootMethod>> startToRunMethods = sjf.getStartToRunMethods();
    Map<Stmt, SootMethod> startToContainingMethod = sjf.getStartToContainingMethod();
    Map<Stmt, Stmt> startToJoin = sjf.getStartToJoin();
   
    // Build MHP Lists
//    G.v().out.println("    MHP: Building MHP Lists");
    List<AbstractRuntimeThread> runAtOnceCandidates = new ArrayList<AbstractRuntimeThread>();
    Iterator threadIt = startToRunMethods.entrySet().iterator();
    int threadNum = 0;
    while(threadIt.hasNext())
    {
      // Get list of possible Runnable.run methods (actually, a list of peg chains)
      // and a list of allocation sites for this thread start statement
      // and the thread start statement itself
      Map.Entry e = (Map.Entry) threadIt.next();
      Stmt startStmt = (Stmt) e.getKey();
      List runMethods = (List) e.getValue();
      List threadAllocNodes = startToAllocNodes.get(e.getKey());

      // Get a list of all possible unique Runnable.run methods for this thread start statement
      AbstractRuntimeThread thread = new AbstractRuntimeThread(); // provides a list interface to the methods in a thread's sub-call-graph
      thread.setStartStmt(startStmt);
//      List threadMethods = new ArrayList();
      Iterator runMethodsIt = runMethods.iterator();
      while(runMethodsIt.hasNext())
      {
        SootMethod method = (SootMethod) runMethodsIt.next();
        if(!thread.containsMethod(method))
        {
          thread.addMethod(method);
          thread.addRunMethod(method);
        }
      }
     
      // Get a list containing all methods in the call graph(s) rooted at the possible run methods for this thread start statement
      // AKA a list of all methods that might be called by the thread started here
      int methodNum = 0;
      while(methodNum < thread.methodCount()) // iterate over all methods in threadMethods, even as new methods are being added to it
      {
        Iterator succMethodsIt = pecg.getSuccsOf(thread.getMethod(methodNum)).iterator();
        while(succMethodsIt.hasNext())
        {
          SootMethod method = (SootMethod) succMethodsIt.next();
          // if all edges into this method are of Kind THREAD, ignore it
          // (because it's a run method that won't be called as part of THIS thread) THIS IS NOT OPTIMAL
          boolean ignoremethod = true;
          Iterator edgeInIt = callGraph.edgesInto(method);
          while(edgeInIt.hasNext())
          {
            Edge edge = (Edge) edgeInIt.next();
            if( edge.kind() != Kind.THREAD && thread.containsMethod(edge.src())) // called directly by any of the thread methods?
              ignoremethod = false;
          }
          if(!ignoremethod && !thread.containsMethod(method))
            thread.addMethod(method);
        }
        methodNum++;
      }
     
      // Add this list of methods to MHPLists
      MHPLists.add(thread);
      if(optionPrintDebug)
        System.out.println(thread.toString());
     
      // Find out if the "thread" in "thread.start()" could be more than one object
      boolean mayStartMultipleThreadObjects = (threadAllocNodes.size() > 1) || so.types_for_sites();
      if(!mayStartMultipleThreadObjects) // if there's only one alloc node
      {
        if(multiRunAllocNodes.contains(threadAllocNodes.iterator().next())) // but it gets run more than once
        {
          mayStartMultipleThreadObjects = true; // then "thread" in "thread.start()" could be more than one object
        }
      }
     
      if(mayStartMultipleThreadObjects)
        thread.setStartStmtHasMultipleReachingObjects();
     
      // Find out if the "thread.start()" statement may be run more than once
      SootMethod startStmtMethod = startToContainingMethod.get(startStmt);
      thread.setStartStmtMethod(startStmtMethod);
      boolean mayBeRunMultipleTimes = multiCalledMethods.contains(startStmtMethod); // if method is called more than once...
      if(!mayBeRunMultipleTimes)
      {
        UnitGraph graph = new CompleteUnitGraph(startStmtMethod.getActiveBody());
        MultiRunStatementsFinder finder = new MultiRunStatementsFinder(
          graph, startStmtMethod, multiCalledMethods, callGraph);
        FlowSet multiRunStatements = finder.getMultiRunStatements(); // list of all units that may be run more than once in this method
        if(multiRunStatements.contains(startStmt))
          mayBeRunMultipleTimes = true;
      }
     
      if(mayBeRunMultipleTimes)
      {
        thread.setStartStmtMayBeRunMultipleTimes();
      }

      // If a run-many thread.start() statement is (always) associated with a join statement in the same method,
      // then it may be possible to treat it as run-once, if this method is non-reentrant and called only
      // by one thread (sounds strict, but actually this is the most common case)
      if(mayBeRunMultipleTimes && startToJoin.containsKey(startStmt))
      {
        thread.setJoinStmt(startToJoin.get(startStmt));
        mayBeRunMultipleTimes = false; // well, actually, we don't know yet
        methodNum = 0;
        List<SootMethod> containingMethodCalls = new ArrayList<SootMethod>();
        containingMethodCalls.add(startStmtMethod);
        while(methodNum < containingMethodCalls.size()) // iterate over all methods in threadMethods, even as new methods are being added to it
        {
          Iterator succMethodsIt = pecg.getSuccsOf(containingMethodCalls.get(methodNum)).iterator();
          while(succMethodsIt.hasNext())
          {
            SootMethod method = (SootMethod) succMethodsIt.next();
            if(method == startStmtMethod)
            {// this method is reentrant
              mayBeRunMultipleTimes = true; // this time it's for sure
              thread.setStartMethodIsReentrant();
              thread.setRunsMany();
              break;
            }
            if(!containingMethodCalls.contains(method))
              containingMethodCalls.add(method);
          }
          methodNum++;
        }
        if(!mayBeRunMultipleTimes)
        {// There's still one thing that might cause this to be run multiple times: if it can be run in parallel with itself
         // but we can't find that out 'till we're done
          runAtOnceCandidates.add(thread);
        }
      }

      // If more than one thread might be started at this start statement,
      // and this start statement may be run more than once,
      // then add this list of methods to MHPLists *AGAIN*
      if(optionPrintDebug)
        System.out.println("Start Stmt " + startStmt.toString() +
          " mayStartMultipleThreadObjects=" + mayStartMultipleThreadObjects + " mayBeRunMultipleTimes=" + mayBeRunMultipleTimes);
      if(mayStartMultipleThreadObjects && mayBeRunMultipleTimes)
      {
        MHPLists.add(thread); // add another copy
        thread.setRunsMany();
        if(optionPrintDebug)
          System.out.println(thread.toString());
      }
      else
        thread.setRunsOnce();
      threadNum++;
    }

    // do same for main method
    AbstractRuntimeThread mainThread = new AbstractRuntimeThread();
//    List mainMethods = new ArrayList();
    MHPLists.add(mainThread);
    mainThread.setRunsOnce();
    mainThread.addMethod(mainMethod);
    mainThread.addRunMethod(mainMethod);
    mainThread.setIsMainThread();
    // get all the successors, add to threadMethods
    int methodNum = 0;
    while(methodNum < mainThread.methodCount())
    {
      Iterator succMethodsIt = pecg.getSuccsOf(mainThread.getMethod(methodNum)).iterator();
      while(succMethodsIt.hasNext())
      {
        SootMethod method = (SootMethod) succMethodsIt.next();
        // if all edges into this are of Kind THREAD, ignore it
        boolean ignoremethod = true;
View Full Code Here

TOP

Related Classes of soot.jimple.toolkits.thread.mhp.pegcallgraph.PegCallGraph

Copyright © 2018 www.massapicom. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.