private Local insertCastAfter(Local leftlocal, Type lefttype, Type righttype, Stmt stmt) { Local newlocal = Jimple.v().newLocal("tmp", righttype); stmtBody.getLocals().add(newlocal); Unit u = Util.findLastIdentityUnit(this.stmtBody, stmt); stmtBody.getUnits().insertAfter(Jimple.v().newAssignStmt(leftlocal, Jimple.v().newCastExpr(newlocal, lefttype)), u); return newlocal; }
public void outAInvokeStatement(AInvokeStatement node) { Value op = (Value) mProductions.removeLast(); Unit u = Jimple.v().newInvokeStmt(op); mProductions.addLast(u); }
/** * Constructs a ThisRef(RefType) grammar chunk. */ public ThisRef newThisRef(RefType t) { return Jimple.v().newThisRef(t); }
/** * Constructs a ReturnVoidStmt() grammar chunk. */ public ReturnVoidStmt newReturnVoidStmt() { return Jimple.v().newReturnVoidStmt(); }
static Stmt addThrowAfter(JimpleBody b, Stmt target) { Chain<Unit> units = b.getUnits(); Collection<Local> locals = b.getLocals(); int i = 0; // Bah! boolean canAddI = false; do { canAddI = true; Iterator<Local> localIt = locals.iterator(); while (localIt.hasNext()) { Local l = (Local) localIt.next(); if (l.getName().equals("__throwee" + i)) { canAddI = false; } } if (!canAddI) { i++; } } while (!canAddI); Local l = Jimple.v().newLocal("__throwee" + i, RefType.v("java.lang.NullPointerException")); b.getLocals().add(l); Stmt newStmt = Jimple.v().newAssignStmt(l, Jimple.v().newNewExpr(RefType.v("java.lang.NullPointerException"))); Stmt invStmt = Jimple.v().newInvokeStmt(Jimple.v().newSpecialInvokeExpr(l, Scene.v().getMethod("<java.lang.NullPointerException: void <init>()>").makeRef())); Stmt throwStmt = Jimple.v().newThrowStmt(l); units.insertAfter(newStmt, target); units.insertAfter(invStmt, newStmt); units.insertAfter(throwStmt, invStmt); return newStmt; }
public soot.Body getBody(soot.SootMethod sootMethod, String phaseName) { soot.Body body = soot.jimple.Jimple.v().newBody(sootMethod); LocalGenerator lg = new LocalGenerator(body); soot.Local paramLocal = lg.generateLocal(sootType); soot.jimple.ParameterRef paramRef = soot.jimple.Jimple.v().newParameterRef(sootType, 0); soot.jimple.Stmt stmt = soot.jimple.Jimple.v().newIdentityStmt(paramLocal, paramRef); body.getUnits().add(stmt); fieldBase = paramLocal; fieldRef = soot.jimple.Jimple.v().newStaticFieldRef(field); } else { fieldRef = soot.jimple.Jimple.v().newInstanceFieldRef(fieldBase, field); soot.jimple.AssignStmt assign = soot.jimple.Jimple.v().newAssignStmt(fieldLocal, fieldRef); body.getUnits().add(assign); soot.jimple.Stmt retStmt = soot.jimple.Jimple.v().newReturnStmt(fieldLocal); body.getUnits().add(retStmt);
public soot.Body getBody(soot.SootMethod sootMethod, String phaseName) { soot.Body body = soot.jimple.Jimple.v().newBody(sootMethod); LocalGenerator lg = new LocalGenerator(body); soot.Local paramLocal = lg.generateLocal(sootType); soot.jimple.ParameterRef paramRef = soot.jimple.Jimple.v().newParameterRef(sootType, paramCounter); soot.jimple.Stmt stmt = soot.jimple.Jimple.v().newIdentityStmt(paramLocal, paramRef); body.getUnits().add(stmt); if (!isCallParamType(sootType)) { invoke = soot.jimple.Jimple.v().newStaticInvokeExpr(meth, methParams); } else { invoke = soot.jimple.Jimple.v().newSpecialInvokeExpr(base, meth, methParams); stmt = soot.jimple.Jimple.v().newAssignStmt(returnLocal, invoke); } else { stmt = soot.jimple.Jimple.v().newInvokeStmt(invoke); retStmt = soot.jimple.Jimple.v().newReturnStmt(returnLocal); } else { retStmt = soot.jimple.Jimple.v().newReturnVoidStmt();
java.util.List<SootClass> thrownExceptions = new LinkedList<SootClass>(); Body accessorBody = Jimple.v().newBody(); soot.util.Chain accStmts = accessorBody.getUnits(); LocalGenerator lg = new LocalGenerator(accessorBody); int paramID = 0; if (ref instanceof InstanceFieldRef) { accStmts.add(Jimple.v().newIdentityStmt(thisLocal, Jimple.v().newParameterRef(target.getType(), paramID))); parameterTypes.add(target.getType()); paramID++; accStmts.add(Jimple.v().newIdentityStmt(l, Jimple.v().newParameterRef(ref.getField().getType(), paramID))); paramID++; if (ref instanceof InstanceFieldRef) { accStmts.add(Jimple.v().newAssignStmt(Jimple.v().newInstanceFieldRef(thisLocal, ref.getFieldRef()), l)); } else { accStmts.add(Jimple.v().newAssignStmt(Jimple.v().newStaticFieldRef(ref.getFieldRef()), l)); accStmts.addLast(Jimple.v().newReturnVoidStmt()); Type returnType = VoidType.v(); InvokeExpr newExpr = Jimple.v().newStaticInvokeExpr(accessor.makeRef(), args); Stmt newStmt = Jimple.v().newInvokeStmt(newExpr);
public static List<Local> buildParameterLocals(PatchingChain<Unit> units, Collection<Local> locals, List<Type> paramTypes) { List<Local> args = new ArrayList<Local>(); for (int k = 0; k < paramTypes.size(); k++) { Type type = paramTypes.get(k); Local loc = Jimple.v().newLocal("l" + k, type); locals.add(loc); units.add(Jimple.v().newIdentityStmt(loc, Jimple.v().newParameterRef(type, k))); args.add(loc); } return args; }
Collections.emptyList(), VoidType.v(), Modifier.STATIC); sootClass.addMethod(staticInitializerMethod); body = Jimple.v().newBody(staticInitializerMethod); staticInitializerMethod.setActiveBody(body); } else { units.addFirst(Jimple.v().newAssignStmt(Jimple.v().newStaticFieldRef(field.makeRef()), IntConstant.v(value ? 1 : 0))); } else { Local bool = Jimple.v().newLocal("boolLcl", booleanWrapperRefType); body.getLocals().add(bool); units.addFirst(Jimple.v().newAssignStmt(Jimple.v().newStaticFieldRef(field.makeRef()), bool)); units.addFirst(Jimple.v().newInvokeStmt( Jimple.v().newSpecialInvokeExpr(bool, booleanWrapperConstructor.makeRef(), IntConstant.v(value ? 1 : 0)))); units.addFirst(Jimple.v().newAssignStmt(bool, Jimple.v().newNewExpr(booleanWrapperRefType))); units.addLast(Jimple.v().newReturnVoidStmt());
us.add(Jimple.v().newIdentityStmt(l, Jimple.v().newThisRef(tclass.getType()))); for (SootField f : capFields) { Local l2 = lc.generateLocal(f.getType()); us.add(Jimple.v().newIdentityStmt(l2, Jimple.v().newParameterRef(f.getType(), i))); capLocals.add(l2); i++; us.add(Jimple.v() .newInvokeStmt(Jimple.v().newSpecialInvokeExpr(l, Scene.v().makeConstructorRef(Scene.v().getObjectType().getSootClass(), Collections.<Type>emptyList()), Collections.<Value>emptyList()))); for (SootField f : capFields) { Local l2 = localItr.next(); us.add(Jimple.v().newAssignStmt(Jimple.v().newInstanceFieldRef(l, f.makeRef()), l2)); us.add(Jimple.v().newReturnVoidStmt());
private void getBootstrapBody(SootClass tclass, JimpleBody jb) { PatchingChain<Unit> us = jb.getUnits(); LocalGenerator lc = new LocalGenerator(jb); List<Value> capValues = new ArrayList<Value>(); List<Type> capTypes = new ArrayList<Type>(); int i = 0; for (SootField capField : capFields) { Type type = capField.getType(); capTypes.add(type); Local p = lc.generateLocal(type); ParameterRef pref = Jimple.v().newParameterRef(type, i); us.add(Jimple.v().newIdentityStmt(p, pref)); capValues.add(p); i++; } Local l = lc.generateLocal(tclass.getType()); Value val = Jimple.v().newNewExpr(tclass.getType()); us.add(Jimple.v().newAssignStmt(l, val)); us.add(Jimple.v() .newInvokeStmt(Jimple.v().newSpecialInvokeExpr(l, Scene.v().makeConstructorRef(tclass, capTypes), capValues))); us.add(Jimple.v().newReturnStmt(l)); }
switch (k) { case REF_INVOKE_STATIC: return Jimple.v().newStaticInvokeExpr(methodRef, args); case REF_INVOKE_INTERFACE: return Jimple.v().newInterfaceInvokeExpr(args.get(0), methodRef, rest(args)); case REF_INVOKE_VIRTUAL: return Jimple.v().newVirtualInvokeExpr(args.get(0), methodRef, rest(args)); case REF_INVOKE_SPECIAL: final SootClass currentClass = jb.getMethod().getDeclaringClass(); return Jimple.v().newSpecialInvokeExpr(args.get(0), methodRef, rest(args)); } else { SootMethod m = implMethod.getMethodRef().resolve(); m.setModifiers(mod); return Jimple.v().newVirtualInvokeExpr(args.get(0), methodRef, rest(args)); NewExpr newRef = Jimple.v().newNewExpr(type); Local newLocal = lc.generateLocal(type); us.add(Jimple.v().newAssignStmt(newLocal, newRef)); SpecialInvokeExpr specialInvokeExpr = Jimple.v().newSpecialInvokeExpr(newLocal, methodRef, args); InvokeStmt invokeStmt = Jimple.v().newInvokeStmt(specialInvokeExpr); us.add(invokeStmt);
List<Unit> list = new Vector<Unit>(); Local tmpRef = Jimple.v().newLocal("tmpRef", RefType.v("java.io.PrintStream")); body.getLocals().add(tmpRef); list.add(Jimple.v().newAssignStmt(tmpRef, Jimple.v().newStaticFieldRef(Scene.v().getField("<java.lang.System: java.io.PrintStream out>").makeRef()))); list.add(Jimple.v().newInvokeStmt(Jimple.v().newStaticInvokeExpr(toCall.makeRef()))); list.add(Jimple.v().newInvokeStmt(Jimple.v().newVirtualInvokeExpr(tmpRef, toCall.makeRef(), StringConstant.v("Executing supposedly unreachable method:")))); list.add(Jimple.v().newInvokeStmt(Jimple.v().newVirtualInvokeExpr(tmpRef, toCall.makeRef(), StringConstant.v("\t" + method.getDeclaringClass().getName() + "." + method.getName())))); list.add(Jimple.v().newInvokeStmt(Jimple.v().newStaticInvokeExpr(toCall.makeRef(), IntConstant.v(1))));
firstStmt = body.getUnits().getPredOf(firstStmt); Stmt jumpTarget = Jimple.v().newNopStmt(); InstanceFieldRef fieldRef = Jimple.v().newInstanceFieldRef(body.getParameterLocal(m.getParameterCount() - 1), Scene.v().makeFieldRef(c, ALREADY_CHECKED_FIELDNAME, BooleanType.v(), false)); Local alreadyCheckedLocal = localGen.generateLocal(BooleanType.v()); newUnits.add(Jimple.v().newAssignStmt(alreadyCheckedLocal, fieldRef)); newUnits.add(Jimple.v().newIfStmt(Jimple.v().newEqExpr(alreadyCheckedLocal, IntConstant.v(0)), jumpTarget)); newUnits.add(Jimple.v().newReturnVoidStmt()); InstanceFieldRef fieldRef2 = Jimple.v().newInstanceFieldRef(body.getParameterLocal(m.getParameterCount() - 1), Scene.v().makeFieldRef(c, ALREADY_CHECKED_FIELDNAME, BooleanType.v(), false)); newUnits.add(Jimple.v().newAssignStmt(fieldRef2, IntConstant.v(1)));
&& (sootMethod().getSource() instanceof soot.coffi.CoffiMethodSource))) return; JimpleBody body = Jimple.v().newBody(sootMethod()); sootMethod().setActiveBody(body); Body b = new Body(hostType(), body, this); b.add(Jimple.v().newAssignStmt( Jimple.v().newInstanceFieldRef(b.emitThis(hostType()), hostType().getSootField("this$0", type).makeRef()), asLocal(b, Jimple.v().newParameterRef(type.getSootType(), 0)))); Variable v = (Variable) iter.next(); ParameterDeclaration p = (ParameterDeclaration) parameterDeclaration("val$" + v.name()).iterator().next(); b.add(Jimple.v().newAssignStmt(Jimple.v().newInstanceFieldRef(b.emitThis(hostType()), Scene.v() .makeFieldRef(hostType().getSootClassDecl(), "val$" + v.name(), v.type().getSootType(), false) b.add(Jimple.v().newAssignStmt(Jimple.v().newInstanceFieldRef(base, f.sootRef()), l)); b.add(Jimple.v().newReturnVoidStmt());
private void insertCastOrUnboxingCode(Local lhs, Local rhs, Chain<Unit> newUnits) { // if assigning to a reference type then there's nothing to do if (lhs.getType() instanceof PrimType) { if ((rhs.getType() instanceof PrimType)) { // insert cast newUnits.add(Jimple.v().newAssignStmt(lhs, Jimple.v().newCastExpr(rhs, lhs.getType()))); } else { // reference type in rhs; insert unboxing code RefType boxedType = (RefType) rhs.getType(); SootMethodRef ref = Scene.v().makeMethodRef(boxedType.getSootClass(), lhs.getType().toString() + "Value", Collections.<Type>emptyList(), lhs.getType(), false); newUnits.add(Jimple.v().newAssignStmt(lhs, Jimple.v().newVirtualInvokeExpr(rhs, ref))); } } }
/** * Invocation of target implementation method. * * @param jb * @param us * @param args */ private void invokeImplMethod(JimpleBody jb, PatchingChain<Unit> us, LocalGenerator lc, List<Local> args) { Value value = _invokeImplMethod(jb, us, lc, args); if (value instanceof InvokeExpr && soot.VoidType.v().equals(implMethod.getMethodRef().returnType())) { // implementation method is void us.add(Jimple.v().newInvokeStmt(value)); us.add(Jimple.v().newReturnVoidStmt()); } else if (soot.VoidType.v().equals(implMethodType.getReturnType())) { // dispatch method is void us.add(Jimple.v().newInvokeStmt(value)); us.add(Jimple.v().newReturnVoidStmt()); } else { // neither is void, must pass through return value Local ret = lc.generateLocal(value.getType()); us.add(Jimple.v().newAssignStmt(ret, value)); // adapt return value Local retAdapted = adapt(ret, implMethodType.getReturnType(), jb, us, lc); us.add(Jimple.v().newReturnStmt(retAdapted)); } }