Examples of soot.jimple.Stmt

soot.jimple.Stmt

        {
            // populate the preinitialize method
            SootMethod classMethod = modelClass
                    .getMethodByName("preinitialize");
            JimpleBody body = (JimpleBody) classMethod.getActiveBody();
            Stmt insertPoint = body.getFirstNonIdentityStmt();


            Chain units = body.getUnits();
            Local thisLocal = body.getThisLocal();


            Local postfireReturnsLocal = Jimple.v().newLocal("postfireReturns",
                    BooleanType.v());
            body.getLocals().add(postfireReturnsLocal);


            // Initialize the postfire flag.
            units.insertBefore(Jimple.v().newAssignStmt(postfireReturnsLocal,
                    IntConstant.v(1)), insertPoint);
            units.insertBefore(Jimple.v().newAssignStmt(
                    Jimple.v().newInstanceFieldRef(thisLocal,
                            postfireReturnsField.makeRef()),
                    postfireReturnsLocal), insertPoint);


            // Add code to the beginning of the preinitialize method that
            // initializes the attributes.
            //             ModelTransformer.initializeAttributesBefore(body, insertPoint,
            //                     model, body.getThisLocal(),
            //                     model, body.getThisLocal(),
            //                     modelClass);
            for (Iterator entities = model.deepEntityList().iterator(); entities
                    .hasNext();) {
                Entity entity = (Entity) entities.next();
                String fieldName = ModelTransformer.getFieldNameForEntity(
                        entity, model);
                SootField field = modelClass.getFieldByName(fieldName);
                String className = ModelTransformer.getInstanceClassName(
                        entity, options);
                SootClass theClass = Scene.v().loadClassAndSupport(className);
                SootMethod preinitializeMethod = SootUtilities
                        .searchForMethodByName(theClass, "preinitialize");
                Local actorLocal = Jimple.v().newLocal("actor",
                        RefType.v(theClass));
                body.getLocals().add(actorLocal);


                // Get the field.
                units.insertBefore(Jimple.v().newAssignStmt(
                        actorLocal,
                        Jimple.v().newInstanceFieldRef(thisLocal,
                                field.makeRef())), insertPoint);
                units.insertBefore(Jimple.v().newInvokeStmt(
                        Jimple.v().newVirtualInvokeExpr(actorLocal,
                                preinitializeMethod.makeRef())), insertPoint);
            }


            //            units.insertBefore(Jimple.v().newReturnVoidStmt(),
            //                   insertPoint);
        }


        SootField iterationField = new SootField("_iteration", IntType.v());
        modelClass.addField(iterationField);


        {
            // populate the initialize method
            SootMethod classMethod = modelClass.getMethodByName("initialize");
            JimpleBody body = (JimpleBody) classMethod.getActiveBody();
            Stmt insertPoint = body.getFirstNonIdentityStmt();


            Chain units = body.getUnits();
            Local thisLocal = body.getThisLocal();


            if (iterationLimit > 0) {
                units.insertBefore(Jimple.v().newAssignStmt(
                        Jimple.v().newInstanceFieldRef(thisLocal,
                                iterationField.makeRef()), IntConstant.v(0)),
                        insertPoint);
            }


            Local actorLocal = Jimple.v().newLocal("actor", actorType);
            body.getLocals().add(actorLocal);


            for (Iterator entities = model.deepEntityList().iterator(); entities
                    .hasNext();) {
                Entity entity = (Entity) entities.next();
                String fieldName = ModelTransformer.getFieldNameForEntity(
                        entity, model);
                SootField field = modelClass.getFieldByName(fieldName);
                String className = ModelTransformer.getInstanceClassName(
                        entity, options);
                SootClass theClass = Scene.v().loadClassAndSupport(className);
                SootMethod initializeMethod = SootUtilities
                        .searchForMethodByName(theClass, "initialize");


                // Set the field.
                units.insertBefore(Jimple.v().newAssignStmt(
                        actorLocal,
                        Jimple.v().newInstanceFieldRef(thisLocal,
                                field.makeRef())), insertPoint);
                units.insertBefore(Jimple.v().newInvokeStmt(
                        Jimple.v().newVirtualInvokeExpr(actorLocal,
                                initializeMethod.makeRef())), insertPoint);
            }


            //            units.insertBefore(Jimple.v().newReturnVoidStmt(),insertPoint);
        }
        // ModelTransformer does this.
        //         {
        //             // populate the prefire method
        //             SootMethod classMethod =
        //                 modelClass.getMethodByName("prefire");
        //             JimpleBody body = (JimpleBody)classMethod.getActiveBody();
        //             Stmt insertPoint = body.getFirstNonIdentityStmt();
        //             Chain units = body.getUnits();
        //             Local thisLocal = body.getThisLocal();
        //             Local prefireReturnsLocal =
        //                 Jimple.v().newLocal("preReturns", BooleanType.v());
        //             body.getLocals().add(prefireReturnsLocal);
        //             units.insertBefore(Jimple.v().newAssignStmt(prefireReturnsLocal,
        //                     IntConstant.v(1)),
        //                     insertPoint);
        //             units.insertBefore(Jimple.v().newReturnStmt(prefireReturnsLocal),
        //                     insertPoint);
        //             LocalSplitter.v().transform(body, phaseName + ".lns");
        //             LocalNameStandardizer.v().transform(body, phaseName + ".lns");
        //             TypeResolver.resolve(body, Scene.v());
        //         }
        {
            // populate the fire method
            SootMethod classMethod = modelClass.getMethodByName("fire");
            JimpleBody body = (JimpleBody) classMethod.getActiveBody();
            Stmt insertPoint = body.getFirstNonIdentityStmt();


            Chain units = body.getUnits();
            Local thisLocal = body.getThisLocal();


            Local actorLocal = Jimple.v().newLocal("actor", actorType);
            body.getLocals().add(actorLocal);


            Local postfireReturnsLocal = Jimple.v().newLocal("postfireReturns",
                    BooleanType.v());
            body.getLocals().add(postfireReturnsLocal);


            Local indexLocal = Jimple.v().newLocal("index", IntType.v());
            body.getLocals().add(indexLocal);


            Local tokenLocal = Jimple.v().newLocal("token",
                    PtolemyUtilities.tokenType);
            body.getLocals().add(tokenLocal);


            // Update PortParameters.
            for (Iterator parameters = model.attributeList(PortParameter.class)
                    .iterator(); parameters.hasNext();) {
                PortParameter parameter = (PortParameter) parameters.next();
                String fieldName = ModelTransformer.getFieldNameForAttribute(
                        parameter, model);
                SootField field = modelClass.getFieldByName(fieldName);
                RefType fieldType = (RefType) field.getType();
                Local parameterLocal = Jimple.v().newLocal("parameter",
                        fieldType);
                SootClass fieldClass = fieldType.getSootClass();


                body.getLocals().add(parameterLocal);


                // Get a reference to the port parameter.
                units.insertBefore(Jimple.v().newAssignStmt(
                        parameterLocal,
                        Jimple.v().newInstanceFieldRef(thisLocal,
                                field.makeRef())), insertPoint);


                // Invoke the update() method.
                units
                        .insertBefore(
                                Jimple
                                        .v()
                                        .newInvokeStmt(
                                                Jimple
                                                        .v()
                                                        .newVirtualInvokeExpr(
                                                                parameterLocal,
                                                                fieldClass
                                                                        .getMethod(
                                                                                PtolemyUtilities.portParameterUpdateMethod
                                                                                        .getSubSignature())
                                                                        .makeRef())),
                                insertPoint);
            }


            // FIXME: This is the quiescent point where parameters
            // reconfigured as a result of port parameters should be
            // evaluated.
            // Transfer Inputs from input ports.
            for (Iterator ports = model.inputPortList().iterator(); ports
                    .hasNext();) {
                IOPort port = (IOPort) ports.next();


                if (port instanceof ParameterPort) {
                    continue;
                }


                int rate;
                rate = DFUtilities.getTokenConsumptionRate(port);


                String fieldName = ModelTransformer.getFieldNameForPort(port,
                        model);
                SootField field = modelClass.getFieldByName(fieldName);


                // Get a reference to the port.
                Local portLocal = Jimple.v().newLocal("port",
                        PtolemyUtilities.ioportType);
                body.getLocals().add(portLocal);


                Local tempPortLocal = Jimple.v().newLocal("tempPort",
                        PtolemyUtilities.ioportType);
                body.getLocals().add(tempPortLocal);
                units.insertBefore(Jimple.v().newAssignStmt(
                        tempPortLocal,
                        Jimple.v().newInstanceFieldRef(thisLocal,
                                field.makeRef())), insertPoint);
                units.insertBefore(Jimple.v().newAssignStmt(
                        portLocal,
                        Jimple.v().newCastExpr(tempPortLocal,
                                PtolemyUtilities.ioportType)), insertPoint);


                for (int i = 0; i < port.getWidth(); i++) {
                    // The list of initializer instructions.
                    List initializerList = new LinkedList();
                    initializerList.add(Jimple.v().newAssignStmt(indexLocal,
                            IntConstant.v(0)));


                    // The list of body instructions.
                    List bodyList = new LinkedList();


                    // Read
                    bodyList.add(Jimple.v().newAssignStmt(
                            tokenLocal,
                            Jimple.v().newVirtualInvokeExpr(portLocal,
                                    PtolemyUtilities.getMethod.makeRef(),
                                    IntConstant.v(i))));


                    // Write
                    bodyList.add(Jimple.v().newInvokeStmt(
                            Jimple.v()
                                    .newVirtualInvokeExpr(
                                            portLocal,
                                            PtolemyUtilities.sendInsideMethod
                                                    .makeRef(),
                                            IntConstant.v(i), tokenLocal)));


                    // Increment the index.
                    bodyList.add(Jimple.v()
                            .newAssignStmt(
                                    indexLocal,
                                    Jimple.v().newAddExpr(indexLocal,
                                            IntConstant.v(1))));


                    Expr conditionalExpr = Jimple.v().newLtExpr(indexLocal,
                            IntConstant.v(rate));


                    SootUtilities.createForLoopBefore(body, insertPoint,
                            initializerList, bodyList, conditionalExpr);
                }
            }


            Local localPostfireReturnsLocal = Jimple.v().newLocal(
                    "localPostfireReturns", BooleanType.v());
            body.getLocals().add(localPostfireReturnsLocal);


            units.insertBefore(Jimple.v().newAssignStmt(
                    postfireReturnsLocal,
                    Jimple.v().newInstanceFieldRef(thisLocal,
                            postfireReturnsField.makeRef())), insertPoint);


            // Execute the schedule
            Iterator schedule = null;


            try {
                schedule = director.getScheduler().getSchedule()
                        .firingIterator();
            } catch (Exception ex) {
                throw new KernelRuntimeException(ex, "Failed to get schedule");
            }


            while (schedule.hasNext()) {
                Firing firing = (Firing) schedule.next();


                Entity entity = (Entity) firing.getActor();
                int firingCount = firing.getIterationCount();
                String fieldName = ModelTransformer.getFieldNameForEntity(
                        entity, model);
                SootField field = modelClass.getFieldByName(fieldName);
                String className = ModelTransformer.getInstanceClassName(
                        entity, options);
                SootClass theClass = Scene.v().loadClassAndSupport(className);
                SootMethod actorPrefireMethod = SootUtilities
                        .searchForMethodByName(theClass, "prefire");
                SootMethod actorFireMethod = SootUtilities
                        .searchForMethodByName(theClass, "fire");
                SootMethod actorPostfireMethod = SootUtilities
                        .searchForMethodByName(theClass, "postfire");


                // Set the field.
                units.insertBefore(Jimple.v().newAssignStmt(
                        actorLocal,
                        Jimple.v().newInstanceFieldRef(thisLocal,
                                field.makeRef())), insertPoint);


                // The threshold at which it is better to generate loops,
                // than to inline code.  A threshold of 2 means that loops will
                // always be used.
                // FIXME: This should be a command line option.
                int threshold = 2;


                if (firingCount < threshold) {
                    for (int i = 0; i < firingCount; i++) {
                        units.insertBefore(Jimple.v().newInvokeStmt(
                                Jimple.v().newVirtualInvokeExpr(actorLocal,
                                        actorPrefireMethod.makeRef())),
                                insertPoint);
                        units.insertBefore(Jimple.v().newInvokeStmt(
                                Jimple.v().newVirtualInvokeExpr(actorLocal,
                                        actorFireMethod.makeRef())),
                                insertPoint);
                        units.insertBefore(Jimple.v().newAssignStmt(
                                localPostfireReturnsLocal,
                                Jimple.v().newVirtualInvokeExpr(actorLocal,
                                        actorPostfireMethod.makeRef())),
                                insertPoint);
                        units.insertBefore(Jimple.v().newAssignStmt(
                                postfireReturnsLocal,
                                Jimple.v().newAndExpr(postfireReturnsLocal,
                                        localPostfireReturnsLocal)),
                                insertPoint);
                    }
                } else {
                    // The list of initializer instructions.
                    List initializerList = new LinkedList();
                    initializerList.add(Jimple.v().newAssignStmt(indexLocal,
                            IntConstant.v(0)));


                    // The list of body instructions.
                    List bodyList = new LinkedList();
                    bodyList.add(Jimple.v().newInvokeStmt(
                            Jimple.v().newVirtualInvokeExpr(actorLocal,
                                    actorPrefireMethod.makeRef())));
                    bodyList.add(Jimple.v().newInvokeStmt(
                            Jimple.v().newVirtualInvokeExpr(actorLocal,
                                    actorFireMethod.makeRef())));
                    bodyList.add(Jimple.v().newAssignStmt(
                            localPostfireReturnsLocal,
                            Jimple.v().newVirtualInvokeExpr(actorLocal,
                                    actorPostfireMethod.makeRef())));
                    bodyList.add(Jimple.v().newAssignStmt(
                            postfireReturnsLocal,
                            Jimple.v().newAndExpr(postfireReturnsLocal,
                                    localPostfireReturnsLocal)));


                    // Increment the index.
                    bodyList.add(Jimple.v()
                            .newAssignStmt(
                                    indexLocal,
                                    Jimple.v().newAddExpr(indexLocal,
                                            IntConstant.v(1))));


                    Expr conditionalExpr = Jimple.v().newLtExpr(indexLocal,
                            IntConstant.v(firingCount));


                    SootUtilities.createForLoopBefore(body, insertPoint,
                            initializerList, bodyList, conditionalExpr);
                }
            }


            // Transfer outputs from output ports
            for (Iterator ports = model.outputPortList().iterator(); ports
                    .hasNext();) {
                IOPort port = (IOPort) ports.next();
                int rate;
                rate = DFUtilities.getTokenProductionRate(port);


                String fieldName = ModelTransformer.getFieldNameForPort(port,
                        model);
                SootField field = modelClass.getFieldByName(fieldName);


                // Get a reference to the port.
                Local portLocal = Jimple.v().newLocal("port",
                        PtolemyUtilities.ioportType);
                body.getLocals().add(portLocal);


                Local tempPortLocal = Jimple.v().newLocal("tempPort",
                        PtolemyUtilities.ioportType);
                body.getLocals().add(tempPortLocal);
                units.insertBefore(Jimple.v().newAssignStmt(
                        tempPortLocal,
                        Jimple.v().newInstanceFieldRef(thisLocal,
                                field.makeRef())), insertPoint);
                units.insertBefore(Jimple.v().newAssignStmt(
                        portLocal,
                        Jimple.v().newCastExpr(tempPortLocal,
                                PtolemyUtilities.ioportType)), insertPoint);


                for (int i = 0; i < port.getWidthInside(); i++) {
                    // The list of initializer instructions.
                    List initializerList = new LinkedList();
                    initializerList.add(Jimple.v().newAssignStmt(indexLocal,
                            IntConstant.v(0)));


                    // The list of body instructions.
                    List bodyList = new LinkedList();


                    // Read
                    bodyList.add(Jimple.v().newAssignStmt(
                            tokenLocal,
                            Jimple.v().newVirtualInvokeExpr(portLocal,
                                    PtolemyUtilities.getInsideMethod.makeRef(),
                                    IntConstant.v(i))));


                    // Write
                    bodyList.add(Jimple.v().newInvokeStmt(
                            Jimple.v().newVirtualInvokeExpr(portLocal,
                                    PtolemyUtilities.sendMethod.makeRef(),
                                    IntConstant.v(i), tokenLocal)));


                    // Increment the index.
                    bodyList.add(Jimple.v()
                            .newAssignStmt(
                                    indexLocal,
                                    Jimple.v().newAddExpr(indexLocal,
                                            IntConstant.v(1))));


                    Expr conditionalExpr = Jimple.v().newLtExpr(indexLocal,
                            IntConstant.v(rate));


                    SootUtilities.createForLoopBefore(body, insertPoint,
                            initializerList, bodyList, conditionalExpr);
                }
            }


            // Return.
            units.insertBefore(Jimple.v().newAssignStmt(
                    Jimple.v().newInstanceFieldRef(thisLocal,
                            postfireReturnsField.makeRef()),
                    postfireReturnsLocal), insertPoint);


            //       units.insertBefore(Jimple.v().newReturnVoidStmt(),
            //              insertPoint);
            LocalSplitter.v().transform(body, phaseName + ".lns");
            LocalNameStandardizer.v().transform(body, phaseName + ".lns");
            TypeResolver.resolve(body, Scene.v());
        }


        {
            // populate the postfire method
            SootMethod classMethod = modelClass.getMethodByName("postfire");
            JimpleBody body = (JimpleBody) classMethod.getActiveBody();
            Stmt insertPoint = body.getFirstNonIdentityStmt();


            Chain units = body.getUnits();
            Local thisLocal = body.getThisLocal();


            Local postfireReturnsLocal = Jimple.v().newLocal("postfireReturns",
                    BooleanType.v());
            body.getLocals().add(postfireReturnsLocal);
            units.insertBefore(Jimple.v().newAssignStmt(
                    postfireReturnsLocal,
                    Jimple.v().newInstanceFieldRef(thisLocal,
                            postfireReturnsField.makeRef())), insertPoint);


            // If we need to keep track of the number of iterations, then...
            if (iterationLimit > 0) {
                Local iterationLocal = null;
                iterationLocal = Jimple.v().newLocal("iteration", IntType.v());
                body.getLocals().add(iterationLocal);


                // Get the current number of iterations
                units.insertBefore(Jimple.v().newAssignStmt(
                        iterationLocal,
                        Jimple.v().newInstanceFieldRef(body.getThisLocal(),
                                iterationField.makeRef())), insertPoint);


                // Increment the number of iterations.
                units.insertBefore(Jimple.v()
                        .newAssignStmt(
                                iterationLocal,
                                Jimple.v().newAddExpr(iterationLocal,
                                        IntConstant.v(1))), insertPoint);


                // Save the current number of iterations
                units.insertBefore(Jimple.v().newAssignStmt(
                        Jimple.v().newInstanceFieldRef(body.getThisLocal(),
                                iterationField.makeRef()), iterationLocal),
                        insertPoint);


                Stmt endStmt = Jimple.v().newNopStmt();


                // If the number of iterations is less than then
                // limit, then don't force postfire return to be
                // false.
                units.insertBefore(Jimple.v().newIfStmt(
                        Jimple.v().newLtExpr(iterationLocal,
                                IntConstant.v(iterationLimit)), endStmt),
                        insertPoint);
                units.insertBefore(Jimple.v().newAssignStmt(
                        postfireReturnsLocal, IntConstant.v(0)), // FALSE
                        insertPoint);
                units.insertBefore(endStmt, insertPoint);
            }


            units.insertBefore(Jimple.v().newReturnStmt(postfireReturnsLocal),
                    insertPoint);
            LocalSplitter.v().transform(body, phaseName + ".lns");
            LocalNameStandardizer.v().transform(body, phaseName + ".lns");
            TypeResolver.resolve(body, Scene.v());
        }


        {
            // populate the wrapup method
            SootMethod classMethod = modelClass.getMethodByName("wrapup");
            JimpleBody body = (JimpleBody) classMethod.getActiveBody();
            Stmt insertPoint = body.getFirstNonIdentityStmt();


            Chain units = body.getUnits();
            Local thisLocal = body.getThisLocal();


            Local actorLocal = Jimple.v().newLocal("actor", actorType);

View Full Code Here

                        // is a container, name constructor.  Note
                        // that classes might have strange types for
                        // the first argument, so it is hard to just
                        // grab the right constructor.
                        JimpleBody body = (JimpleBody) method.getActiveBody();
                        Stmt insertPoint = (Stmt) body.getUnits().getLast();
                        body.getUnits()
                                .insertBefore(
                                        Jimple.v().newAssignStmt(
                                                Jimple.v().newInstanceFieldRef(
                                                        body.getThisLocal(),
                                                        field.makeRef()),
                                                body.getParameterLocal(0)),
                                        insertPoint);
                    } else {
                        // Assign null to the container field.
                        JimpleBody body = (JimpleBody) method.getActiveBody();
                        Stmt insertPoint = (Stmt) body.getUnits().getLast();
                        body.getUnits().insertBefore(
                                Jimple.v().newAssignStmt(
                                        Jimple.v().newInstanceFieldRef(
                                                body.getThisLocal(),
                                                field.makeRef()),

View Full Code Here

            // this will help us figure out where locals are defined.
            SimpleLocalDefs localDefs = new SimpleLocalDefs(unitGraph);


            for (Iterator units = body.getUnits().snapshotIterator(); units
                    .hasNext();) {
                Stmt unit = (Stmt) units.next();


                if (!unit.containsInvokeExpr()) {
                    continue;
                }


                ValueBox box = unit.getInvokeExprBox();
                Value value = box.getValue();


                if (value instanceof InstanceInvokeExpr) {
                    InstanceInvokeExpr r = (InstanceInvokeExpr) value;

View Full Code Here

            Iterator<SootMethod> mi = ac.getMethods().iterator();
            while (mi.hasNext()) {
                SootMethod sm = mi.next();
                if (sm.isConcrete()) {
                    for (Unit unit : sm.getActiveBody().getUnits()) {
                        Stmt stmt = (Stmt) unit;
                        
                        if (stmt.containsInvokeExpr()) {
                            InvokeExpr expr = stmt.getInvokeExpr();
                            if (expr instanceof SpecialInvokeExpr &&
                                    expr.getMethod().getSignature().equals("<java.net.URL: void <init>(java.lang.String)>") &&
                                    expr.getArg(0) instanceof StringConstant) {
                                Value value = ((SpecialInvokeExpr)expr).getBase();
                                String url = ((StringConstant)expr.getArg(0)).value;

View Full Code Here

        if (method.hasActiveBody()) {
          Body body = method.getActiveBody();
          Collection<Unit> uc = body.getUnits();
          for (Unit u : uc) {
            if (u instanceof Stmt) {
              Stmt stmt = (Stmt)u;
              List boxes = stmt.getUseAndDefBoxes();
              for (Object o : boxes) {
                if (o instanceof ValueBox) {
                  ValueBox box = (ValueBox)o;
                  boxStmtMap.put(box,stmt);
                }

View Full Code Here

      }
    }
  }
  
  public void tag(ValueBox box, String message) {
    Stmt stmt = boxStmtMap.get(box);
    stmt.addTag(new StringTag(message));
  }

View Full Code Here

  }
  
  private void handleAnnotationHotspots() {
    for (ValueBox box : analyzer.getHotspots()) {
      //Stmt stmt = analyzer.getStmt(box);
      Stmt stmt = tagger.getStmt(box);
      Automaton a = analyzer.getAutomaton(box);
      Automaton b = sa.getAutomaton(box);
      Automaton diff = a.complement().intersection(b);
      if (!diff.isEmpty()) {
        String from;
        if (b.isTotal()) {
          from = "anystring";
        }
        else {
          from = quoteString(diff.getShortestExample(true));
        }
        if (stmt.containsInvokeExpr()) {
          InvokeExpr invoke = stmt.getInvokeExpr();
          for (int i=0; i<invoke.getArgCount(); i++) {
            if (box == invoke.getArgBox(i)) {
              stmt.addTag(new StringTag("Type mismatch: cannot convert argument number " + (i+1) + " from " + from + " to " + analyzer.getDescription(a)));
            }
          }
        }
        else if (stmt instanceof IdentityStmt) {
          IdentityStmt iStmt = (IdentityStmt)stmt;
          Value rvalue = iStmt.getRightOp();
          if (rvalue instanceof ParameterRef) {
            ParameterRef parameter = (ParameterRef)rvalue;
            int index = parameter.getIndex();
            stmt.addTag(new StringTag("Type mismatch: cannot convert parameter number " + (index + 1) + " from " + from + " to " + analyzer.getDescription(a)));
          }
        }
        else {
          stmt.addTag(new StringTag("Type mismatch: cannot convert from " + from + " to " + analyzer.getDescription(a)));
        }
      }
    }
  }

View Full Code Here

        if (method.hasActiveBody()) {
          Body body = method.getActiveBody();
          Collection<Unit> uc = body.getUnits();
          for (Unit u : uc) {
            if (u instanceof Stmt) {
              Stmt stmt = (Stmt)u;
              stmt.apply(this);
              if (stmt.containsInvokeExpr()) {
                createHotspotsFromInvokeExpr(stmt);
              }
            }
          }
        }

View Full Code Here

      for (SootMethod m : c.getMethods()) {
        if (!m.isConcrete())
          continue;
        DirectedGraph<Unit> mbug = new ExceptionalUnitGraph(m.retrieveActiveBody());
        for (Unit u : mbug) {
          Stmt s1 = (Stmt) u;
          List<Unit> succs = mbug.getSuccsOf(s1);
          if (succs.size() == 1) {
            Stmt s2 = (Stmt) succs.get(0);
            if (s1 instanceof JAssignStmt && s2 instanceof JInvokeStmt && mbug.getPredsOf(s2).size() == 1) {
              JAssignStmt js1 = (JAssignStmt) s1;
              JInvokeStmt js2 = (JInvokeStmt) s2;
              if (js1.containsInvokeExpr() 
                  && (js1.getInvokeExpr().getMethod().getSignature().equals("<dk.brics.xact.XML: java.util.Map getNamespaceMap()>")

View Full Code Here

      for (SootMethod m : c.getMethods()) {
        if (!m.isConcrete())
          continue;
        DirectedGraph<Unit> mbug = new ExceptionalUnitGraph(m.retrieveActiveBody());
        for (Unit u : mbug) {
          Stmt s = (Stmt) u;
          if (s instanceof JInvokeStmt) {
            JInvokeStmt js = (JInvokeStmt) s;
            if (js.getInvokeExpr().getMethod().getSignature().equals("<dk.brics.xact.XML: void loadXMLSchema(java.lang.String)>")) {
              Origin origin = new Origin(m.getDeclaringClass().getName() + "." + m.getName(), getLineNumber(s), 0);
              String schema = getConstantString(js.getInvokeExpr().getArg(0), origin);

View Full Code Here

0 1 2 3 4 5 6 7 8

TOP

Related Classes of soot.jimple.Stmt

dk.brics.jwig.analysis.jaive.InterfaceInvocationChecker

dk.brics.jwig.analysis.jaive.InterfaceInvocationLinker

dk.brics.jwig.analysis.jaive.InvocationDetector

dk.brics.jwig.analysis.jaive.MyStringAnalysis

dk.brics.jwig.analysis.JwigResolver

dk.brics.string.annotation.AnnotationAnalyzer

dk.brics.string.annotation.HotspotTagger

dk.brics.string.annotation.Transformer

dk.brics.string.BindingAutomatonProvider

dk.brics.string.java.MethodTranslatorImpl

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.