Examples with AugmentedStmt soot.dava.internal.asg.AugmentedStmt used on opensource projects

Example 16 with AugmentedStmt

use of soot.dava.internal.asg.AugmentedStmt in project soot by Sable.

the class SETNode method verify.

public void verify() {
    Iterator<IterableSet> sbit = subBodies.iterator();
    while (sbit.hasNext()) {
        IterableSet body = sbit.next();
        Iterator bit = body.iterator();
        while (bit.hasNext()) if ((bit.next() instanceof AugmentedStmt) == false)
            logger.debug("Error in body: " + getClass());
        Iterator cit = body2childChain.get(body).iterator();
        while (cit.hasNext()) ((SETNode) cit.next()).verify();
    }
}

Example 17 with AugmentedStmt

use of soot.dava.internal.asg.AugmentedStmt in project soot by Sable.

the class SuperFirstStmtHandler method createDavaStoreStmts.

/*
	 * Create the following code:
	 * 
	 * DavaSuperHandler handler; handler = new DavaSuperHandler(); //code to
	 * evaluate all args in args2
	 * 
	 * //evaluate 1st arg in args2 --------- handler.store(firstArg);
	 * 
	 * //evaluate 2nd arg in args2 --------- handler.store(secondArg);
	 * 
	 * //AND SO ON TILL ALL ARGS ARE FINISHED
	 * 
	 * return handler;
	 */
private void createDavaStoreStmts() {
    List<AugmentedStmt> davaHandlerStmts = new ArrayList<AugmentedStmt>();
    // create object of DavaSuperHandler handler
    SootClass sootClass = new SootClass("DavaSuperHandler");
    Type localType = sootClass.getType();
    Local newLocal = new JimpleLocal("handler", localType);
    /*
		 * Create * DavaSuperHandler handler; *
		 */
    DVariableDeclarationStmt varStmt = null;
    varStmt = new DVariableDeclarationStmt(localType, newPreInitDavaBody);
    varStmt.addLocal(newLocal);
    AugmentedStmt as = new AugmentedStmt(varStmt);
    davaHandlerStmts.add(as);
    /*
		 * create * handler = new DavaSuperHandler(); *
		 */
    // create RHS
    DNewInvokeExpr invokeExpr = new DNewInvokeExpr(RefType.v(sootClass), makeMethodRef("DavaSuperHandler", new ArrayList()), new ArrayList());
    // create LHS
    GAssignStmt initialization = new GAssignStmt(newLocal, invokeExpr);
    // add to stmts
    davaHandlerStmts.add(new AugmentedStmt(initialization));
    /*
		 * create * handler.store(firstArg); *
		 */
    // best done in a loop for all args
    Iterator typeIt = argsTwoTypes.iterator();
    Iterator valIt = argsTwoValues.iterator();
    // make reference to a method of name store takes one Object arg belongs
    // to DavaSuperHandler
    ArrayList tempList = new ArrayList();
    // SHOULD BE OBJECT
    tempList.add(RefType.v("java.lang.Object"));
    SootMethod method = Scene.v().makeSootMethod("store", tempList, VoidType.v());
    // set the declaring class of new method to be the DavaSuperHandler
    // class
    method.setDeclaringClass(sootClass);
    SootMethodRef getMethodRef = method.makeRef();
    while (typeIt.hasNext() && valIt.hasNext()) {
        Type tempType = (Type) typeIt.next();
        Value tempVal = (Value) valIt.next();
        AugmentedStmt toAdd = createStmtAccordingToType(tempType, tempVal, newLocal, getMethodRef);
        davaHandlerStmts.add(toAdd);
    }
    // sanity check
    if (typeIt.hasNext() || valIt.hasNext())
        throw new DecompilationException("Error creating DavaHandler stmts");
    /*
		 * code to add defs
		 */
    List<Local> uniqueLocals = addDefsToLiveVariables();
    Iterator<Local> localIt = uniqueLocals.iterator();
    while (localIt.hasNext()) {
        Local local = localIt.next();
        AugmentedStmt toAdd = createStmtAccordingToType(local.getType(), local, newLocal, getMethodRef);
        davaHandlerStmts.add(toAdd);
    }
    // set the mustInitialize field to uniqueLocals so that before Y we can
    // assign these locals
    mustInitialize = uniqueLocals;
    /*
		 * create * return handler; *
		 */
    GReturnStmt returnStmt = new GReturnStmt(newLocal);
    davaHandlerStmts.add(new AugmentedStmt(returnStmt));
    // the appropriate dava handler stmts are all in place within
    // davaHandlerStmts
    // store them in an ASTSTatementSequenceNode
    ASTStatementSequenceNode addedNode = new ASTStatementSequenceNode(davaHandlerStmts);
    // add to method body
    List<Object> subBodies = newASTPreInitMethod.get_SubBodies();
    if (subBodies.size() != 1)
        throw new CorruptASTException("ASTMethodNode does not have one subBody");
    List<Object> body = (List<Object>) subBodies.get(0);
    body.add(addedNode);
    newASTPreInitMethod.replaceBody(body);
}

Example 18 with AugmentedStmt

use of soot.dava.internal.asg.AugmentedStmt in project soot by Sable.

the class SuperFirstStmtHandler method createNewASTConstructor.

public void createNewASTConstructor(ASTStatementSequenceNode initNode) {
    List<Object> newConstructorBody = new ArrayList<Object>();
    List<AugmentedStmt> newStmts = new ArrayList<AugmentedStmt>();
    /*
		 * add any definitions to live variables that might be in body X
		 */
    // we have gotten argsTwoType size() out of the handler so thats the
    // index count
    // mustInitialize has the live variables that need to be initialized
    // create new ReftType for DavaSuperHandler
    RefType type = (new SootClass("DavaSuperHandler")).getType();
    // make JimpleLocal to be used in each arg
    // takes care of
    Local jimpleLocal = new JimpleLocal("handler", type);
    // handler
    // make reference to a method of name get takes one int arg belongs to
    // DavaSuperHandler
    ArrayList tempList = new ArrayList();
    tempList.add(IntType.v());
    SootMethodRef getMethodRef = makeMethodRef("get", tempList);
    // Iterator typeIt = argsTwoTypes.iterator();
    if (mustInitialize != null) {
        Iterator<Local> initIt = mustInitialize.iterator();
        while (initIt.hasNext()) {
            Local initLocal = initIt.next();
            Type tempType = initLocal.getType();
            // takes
            DIntConstant arg = DIntConstant.v(mustInitializeIndex, IntType.v());
            // care
            // of
            // the
            // index
            mustInitializeIndex++;
            ArrayList tempArgList = new ArrayList();
            tempArgList.add(arg);
            DVirtualInvokeExpr tempInvokeExpr = new DVirtualInvokeExpr(jimpleLocal, getMethodRef, tempArgList, new HashSet<Object>());
            // NECESASARY CASTING OR RETRIEVAL OF PRIM TYPES TO BE DONE HERE
            Value toAddExpr = getProperCasting(tempType, tempInvokeExpr);
            if (toAddExpr == null)
                throw new DecompilationException("UNABLE TO CREATE TOADDEXPR:" + tempType);
            // need to create a def stmt with the local on the left and
            // toAddExpr on the right
            GAssignStmt assign = new GAssignStmt(initLocal, toAddExpr);
            newStmts.add(new AugmentedStmt(assign));
        }
    }
    // add any statements following the this.<init> statement
    Iterator<AugmentedStmt> it = initNode.getStatements().iterator();
    while (it.hasNext()) {
        AugmentedStmt augStmt = (AugmentedStmt) it.next();
        Stmt stmtTemp = augStmt.get_Stmt();
        if (stmtTemp == originalConstructorUnit) {
            break;
        }
    }
    while (it.hasNext()) {
        /*
			 * notice we dont need to clone these because these will be removed
			 * from the other method from which we are copying these
			 */
        newStmts.add(it.next());
    }
    if (newStmts.size() > 0) {
        newConstructorBody.add(new ASTStatementSequenceNode(newStmts));
    }
    // adding body Y now
    List<Object> originalASTMethodSubBodies = originalASTMethod.get_SubBodies();
    if (originalASTMethodSubBodies.size() != 1)
        throw new CorruptASTException("size of ASTMethodNode subBody not 1");
    List<Object> oldASTBody = (List<Object>) originalASTMethodSubBodies.get(0);
    Iterator<Object> itOld = oldASTBody.iterator();
    boolean sanity = false;
    while (itOld.hasNext()) {
        // going through originalASTMethodNode's ASTNodes
        ASTNode tempNode = (ASTNode) itOld.next();
        // enter only if its not the initNode
        if (tempNode instanceof ASTStatementSequenceNode) {
            if ((((ASTStatementSequenceNode) tempNode).getStatements()).equals(initNode.getStatements())) {
                sanity = true;
                break;
            }
        }
    }
    if (!sanity) {
        // means we never found the initNode which shouldnt happen
        throw new DecompilationException("never found the init node");
    }
    // Y are all the nodes following the initNode
    while (itOld.hasNext()) {
        newConstructorBody.add(itOld.next());
    }
    // setDeclarations in newNode
    // The LocalVariableCleaner which is called in the end of DavaBody will
    // clear up any declarations that are not required
    List<AugmentedStmt> newConstructorDeclarations = new ArrayList<AugmentedStmt>();
    for (AugmentedStmt as : originalASTMethod.getDeclarations().getStatements()) {
        DVariableDeclarationStmt varDecStmt = (DVariableDeclarationStmt) as.get_Stmt();
        newConstructorDeclarations.add(new AugmentedStmt((DVariableDeclarationStmt) varDecStmt.clone()));
    }
    ASTStatementSequenceNode newDecs = new ASTStatementSequenceNode(new ArrayList<AugmentedStmt>());
    if (newConstructorDeclarations.size() > 0) {
        newDecs = new ASTStatementSequenceNode(newConstructorDeclarations);
        // DONT FORGET TO SET THE DECLARATIONS IN THE METHOD ONCE IT IS
        // CREATED
        // newASTConstructorMethod.setDeclarations(newDecs);
        // declarations are always the first element
        newConstructorBody.add(0, newDecs);
    }
    // so we have any declarations followed by body Y
    // have to put the newConstructorBody into an list of subBodies which
    // goes into the newASTConstructorMethod
    newASTConstructorMethod = new ASTMethodNode(newConstructorBody);
    // dont forget to set the declarations
    newASTConstructorMethod.setDeclarations(newDecs);
}

Example 19 with AugmentedStmt

use of soot.dava.internal.asg.AugmentedStmt in project soot by Sable.

the class SuperFirstStmtHandler method createAugmentedStmtToAdd.

private AugmentedStmt createAugmentedStmtToAdd(Local newLocal, SootMethodRef getMethodRef, Value tempVal) {
    ArrayList tempArgList = new ArrayList();
    tempArgList.add(tempVal);
    DVirtualInvokeExpr tempInvokeExpr = new DVirtualInvokeExpr(newLocal, getMethodRef, tempArgList, new HashSet<Object>());
    // create Invoke Stmt with virtualInvoke as the expression
    GInvokeStmt s = new GInvokeStmt(tempInvokeExpr);
    return new AugmentedStmt(s);
}

Example 20 with AugmentedStmt

use of soot.dava.internal.asg.AugmentedStmt in project soot by Sable.

the class SuperFirstStmtHandler method removeInit.

/*
	 * When we havent created the indirection to take care of super bug be it
	 * cos we dont need to or that we CANT cos of some limitation....should
	 * atleast remove the jimple this.init call from the statements
	 */
public void removeInit() {
    // remove constructorUnit from originalASTMethod
    List<Object> newBody = new ArrayList<Object>();
    List<Object> subBody = originalASTMethod.get_SubBodies();
    if (subBody.size() != 1)
        return;
    List oldBody = (List) subBody.get(0);
    Iterator oldIt = oldBody.iterator();
    while (oldIt.hasNext()) {
        // going through each node in the old body
        ASTNode node = (ASTNode) oldIt.next();
        // copy the node as is unless its an ASTStatementSequence
        if (!(node instanceof ASTStatementSequenceNode)) {
            newBody.add(node);
            continue;
        }
        // if the node is an ASTStatementSequenceNode
        // copy all stmts unless it is a constructorUnit
        ASTStatementSequenceNode seqNode = (ASTStatementSequenceNode) node;
        List<AugmentedStmt> newStmtList = new ArrayList<AugmentedStmt>();
        for (AugmentedStmt augStmt : seqNode.getStatements()) {
            Stmt stmtTemp = augStmt.get_Stmt();
            if (stmtTemp == originalConstructorUnit) {
            // do nothing
            } else {
                newStmtList.add(augStmt);
            }
        }
        if (newStmtList.size() != 0) {
            newBody.add(new ASTStatementSequenceNode(newStmtList));
        }
    }
    originalASTMethod.replaceBody(newBody);
}