public void outACmpeqBinop(ACmpeqBinop node) { mProductions.addLast(Jimple.v().newEqExpr(mValue, mValue)); }
public soot.jimple.BinopExpr newEqExpr(soot.Value op1, soot.Value op2, ASTNode location) { return updateTags(Jimple.v().newEqExpr(op1, op2), location, op1, op2); }
/** * Creates a binary expr that is a comparison */ private soot.Value getBinaryComparisonExpr(soot.Value lVal, soot.Value rVal, polyglot.ast.Binary.Operator operator) { soot.Value rValue; if (operator == polyglot.ast.Binary.EQ) { // System.out.println("processing: // "+body.getMethod().getDeclaringClass()); // System.out.println("lval: "+lVal+" rval: "+rVal); rValue = soot.jimple.Jimple.v().newEqExpr(lVal, rVal); } else if (operator == polyglot.ast.Binary.GE) { rValue = soot.jimple.Jimple.v().newGeExpr(lVal, rVal); } else if (operator == polyglot.ast.Binary.GT) { rValue = soot.jimple.Jimple.v().newGtExpr(lVal, rVal); } else if (operator == polyglot.ast.Binary.LE) { rValue = soot.jimple.Jimple.v().newLeExpr(lVal, rVal); } else if (operator == polyglot.ast.Binary.LT) { rValue = soot.jimple.Jimple.v().newLtExpr(lVal, rVal); } else if (operator == polyglot.ast.Binary.NE) { rValue = soot.jimple.Jimple.v().newNeExpr(lVal, rVal); } else { throw new RuntimeException("Unknown Comparison Expr"); } return rValue; }
case IF_EQ: case IF_EQZ: return Jimple.v().newEqExpr(one, other); case IF_NE: case IF_NEZ:
Stmt throwPoint = ThrowManager.getNullPointerExceptionThrower(b); b.getUnits().insertBefore(Jimple.v() .newIfStmt(Jimple.v().newEqExpr(((InstanceInvokeExpr) ie).getBase(), NullConstant.v()), throwPoint), s);
Value v1 = val1.stackOrValue(); if (op == IF_ICMPEQ) { cond = Jimple.v().newEqExpr(v1, v); } else if (op == IF_ICMPNE) { cond = Jimple.v().newNeExpr(v1, v); cond = Jimple.v().newLeExpr(v1, v); } else if (op == IF_ACMPEQ) { cond = Jimple.v().newEqExpr(v1, v); } else if (op == IF_ACMPNE) { cond = Jimple.v().newNeExpr(v1, v); } else { if (op == IFEQ) { cond = Jimple.v().newEqExpr(v, IntConstant.v(0)); } else if (op == IFNE) { cond = Jimple.v().newNeExpr(v, IntConstant.v(0)); cond = Jimple.v().newLeExpr(v, IntConstant.v(0)); } else if (op == IFNULL) { cond = Jimple.v().newEqExpr(v, NullConstant.v()); } else if (op == IFNONNULL) { cond = Jimple.v().newNeExpr(v, NullConstant.v());
Stmt throwPoint = ThrowManager.getNullPointerExceptionThrower(containerB); containerB.getUnits().insertBefore( Jimple.v().newIfStmt(Jimple.v().newEqExpr(((InstanceInvokeExpr) ie).getBase(), NullConstant.v()), throwPoint), toInline);
newUnits.add(Jimple.v().newAssignStmt(predLocal, staticInvokeExpr)); newUnits.add(Jimple.v().newIfStmt(Jimple.v().newEqExpr(IntConstant.v(0), predLocal), jumpTarget));
/** * in bytecode and Jimple the conditions in conditional binary expressions are often reversed */ private soot.Value reverseCondition(soot.jimple.ConditionExpr cond) { soot.jimple.ConditionExpr newExpr; if (cond instanceof soot.jimple.EqExpr) { newExpr = soot.jimple.Jimple.v().newNeExpr(cond.getOp1(), cond.getOp2()); } else if (cond instanceof soot.jimple.NeExpr) { newExpr = soot.jimple.Jimple.v().newEqExpr(cond.getOp1(), cond.getOp2()); } else if (cond instanceof soot.jimple.GtExpr) { newExpr = soot.jimple.Jimple.v().newLeExpr(cond.getOp1(), cond.getOp2()); } else if (cond instanceof soot.jimple.GeExpr) { newExpr = soot.jimple.Jimple.v().newLtExpr(cond.getOp1(), cond.getOp2()); } else if (cond instanceof soot.jimple.LtExpr) { newExpr = soot.jimple.Jimple.v().newGeExpr(cond.getOp1(), cond.getOp2()); } else if (cond instanceof soot.jimple.LeExpr) { newExpr = soot.jimple.Jimple.v().newGtExpr(cond.getOp1(), cond.getOp2()); } else { throw new RuntimeException("Unknown Condition Expr"); } newExpr.getOp1Box().addAllTagsOf(cond.getOp1Box()); newExpr.getOp2Box().addAllTagsOf(cond.getOp2Box()); return newExpr; }
boolean needIf = needSootIf(sootCond); if (!(sootCond instanceof soot.jimple.ConditionExpr)) { sootCond = soot.jimple.Jimple.v().newEqExpr(sootCond, soot.jimple.IntConstant.v(1)); } else { sootCond = handleDFLCond((soot.jimple.ConditionExpr) sootCond);
cond = soot.jimple.Jimple.v().newEqExpr(result, soot.jimple.IntConstant.v(0)); } else if (cond instanceof soot.jimple.GeExpr) { cond = soot.jimple.Jimple.v().newGeExpr(result, soot.jimple.IntConstant.v(0));
boolean leftNeedIf = needSootIf(lVal); if (!(lVal instanceof soot.jimple.ConditionExpr)) { lVal = soot.jimple.Jimple.v().newEqExpr(lVal, soot.jimple.IntConstant.v(0)); } else { lVal = reverseCondition((soot.jimple.ConditionExpr) lVal); boolean rightNeedIf = needSootIf(rVal); if (!(rVal instanceof soot.jimple.ConditionExpr)) { rVal = soot.jimple.Jimple.v().newEqExpr(rVal, soot.jimple.IntConstant.v(0)); } else { rVal = reverseCondition((soot.jimple.ConditionExpr) rVal);
newUnits.add(Jimple.v().newIfStmt(Jimple.v().newEqExpr(alreadyCheckedLocal, IntConstant.v(0)), jumpTarget));
if (!(sootCond instanceof soot.jimple.ConditionExpr)) { if (!boto) { sootCond = soot.jimple.Jimple.v().newEqExpr(sootCond, soot.jimple.IntConstant.v(0)); } else { sootCond = soot.jimple.Jimple.v().newNeExpr(sootCond, soot.jimple.IntConstant.v(0));
co = Jimple.v().newEqExpr(Util.v().getLocalForStackOp(listBody, typeStack, typeStack.topIndex()), IntConstant.v(0)); co = Jimple.v().newEqExpr(Util.v().getLocalForStackOp(listBody, typeStack, typeStack.topIndex()), NullConstant.v()); co = Jimple.v().newEqExpr(Util.v().getLocalForStackOp(listBody, typeStack, typeStack.topIndex() - 1), Util.v().getLocalForStackOp(listBody, typeStack, typeStack.topIndex())); co = Jimple.v().newEqExpr(Util.v().getLocalForStackOp(listBody, typeStack, typeStack.topIndex() - 1), Util.v().getLocalForStackOp(listBody, typeStack, typeStack.topIndex()));
boolean rightNeedIf = needSootIf(rVal); if (!(rVal instanceof soot.jimple.ConditionExpr)) { rVal = soot.jimple.Jimple.v().newEqExpr(rVal, soot.jimple.IntConstant.v(0)); } else {
protected Value jimpleEqZero(Value v) { return Jimple.v().newEqExpr(v, IntConstant.v(0)); }
/** * Creates an opaque predicate that jumps to the given target * * @param target The target to which the opaque predicate shall jump */ protected void createIfStmt(Unit target) { if (target == null) { return; } final Jimple jimple = Jimple.v(); EqExpr cond = jimple.newEqExpr(intCounter, IntConstant.v(conditionCounter++)); IfStmt ifStmt = jimple.newIfStmt(cond, target); body.getUnits().add(ifStmt); }
@Override protected SootMethod createDummyMainInternal() { LocalGenerator generator = new LocalGenerator(body); // Create the counter used for the opaque predicate int conditionCounter = 0; Value intCounter = generator.generateLocal(IntType.v()); AssignStmt assignStmt = Jimple.v().newAssignStmt(intCounter, IntConstant.v(conditionCounter)); body.getUnits().add(assignStmt); Stmt afterEx = Jimple.v().newReturnVoidStmt(); IfStmt ifStmt = Jimple.v().newIfStmt( Jimple.v().newEqExpr(intCounter, IntConstant.v(conditionCounter)), afterEx); body.getUnits().add(ifStmt); conditionCounter++; Local lcEx = generator.generateLocal(t.getException().getType()); AssignStmt assignNewEx = Jimple.v().newAssignStmt(lcEx, Jimple.v().newNewExpr(t.getException().getType())); body.getUnits().add(assignNewEx); InvokeStmt consNewEx = Jimple.v().newInvokeStmt(Jimple.v().newSpecialInvokeExpr(lcEx, Scene.v().makeConstructorRef(exceptionClass, Collections.<Type>emptyList()))); body.getUnits().add(consNewEx); ThrowStmt throwNewEx = Jimple.v().newThrowStmt(lcEx); body.getUnits().add(throwNewEx); body.getUnits().add(afterEx); return mainMethod; }
b.getUnits().add(Jimple.v().newIfStmt(Jimple.v().newEqExpr(targetLocal, NullConstant.v()), retStmt));