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; }
/** * P box = P.valueOf(fromLocal); * * @param fromLocal * primitive * @param jb * @param us * @return */ private Local box(Local fromLocal, JimpleBody jb, PatchingChain<Unit> us, LocalGenerator lc) { PrimType primitiveType = (PrimType) fromLocal.getType(); RefType wrapperType = primitiveType.boxedType(); SootMethod valueOfMethod = wrapper.valueOf.get(primitiveType); Local lBox = lc.generateLocal(wrapperType); if (lBox == null || valueOfMethod == null || us == null) { throw new NullPointerException(String.format("%s,%s,%s,%s", valueOfMethod, primitiveType, wrapper.valueOf.entrySet(), wrapper.valueOf.get(primitiveType))); } us.add(Jimple.v().newAssignStmt(lBox, Jimple.v().newStaticInvokeExpr(valueOfMethod.makeRef(), fromLocal))); return lBox; }
/** * T t = (T) fromLocal; * * @param fromLocal * @param to * @param jb * @param us * @return */ private Local wideningPrimitiveConversion(Local fromLocal, Type to, JimpleBody jb, PatchingChain<Unit> us, LocalGenerator lc) { if (!(fromLocal.getType() instanceof PrimType)) { throw new IllegalArgumentException("Expected source to have primitive type"); } if (!(to instanceof PrimType)) { throw new IllegalArgumentException("Expected target to have primitive type"); } Local l2 = lc.generateLocal(to); us.add(Jimple.v().newAssignStmt(l2, Jimple.v().newCastExpr(fromLocal, to))); return l2; }
/** * p unbox = fromLocal.pValue(); * * @param fromLocal * boxed * @param jb * @param us * @return */ private Local unbox(Local fromLocal, JimpleBody jb, PatchingChain<Unit> us, LocalGenerator lc) { RefType wrapperType = (RefType) fromLocal.getType(); PrimType primitiveType = wrapper.wrapperTypes.get(wrapperType); SootMethod primitiveValueMethod = wrapper.primitiveValue.get(wrapperType); Local lUnbox = lc.generateLocal(primitiveType); us.add(Jimple.v().newAssignStmt(lUnbox, Jimple.v().newVirtualInvokeExpr(fromLocal, primitiveValueMethod.makeRef()))); return lUnbox; }
public Body add(soot.jimple.Stmt stmt) { if(list != null) { list.add(stmt); list = null; } stmt.addTag(currentSourceRangeTag()); soot.PatchingChain<Unit> chain = (soot.PatchingChain<Unit>)chains.peek(); if(stmt instanceof IdentityStmt && chain.size() != 0) { IdentityStmt idstmt = (IdentityStmt) stmt; if(!(idstmt.getRightOp() instanceof CaughtExceptionRef)) { soot.Unit s = chain.getFirst(); while(s instanceof IdentityStmt) s = chain.getSuccOf((soot.jimple.Stmt)s); if(s != null) { chain.insertBefore(stmt, (soot.jimple.Stmt)s); return this; } } } chain.add(stmt); return this; }
public static Local buildThisLocal(PatchingChain<Unit> units, ThisRef tr, Collection<Local> locals) { Local ths = Jimple.v().newLocal("ths", tr.getType()); locals.add(ths); units.add(Jimple.v().newIdentityStmt(ths, Jimple.v().newThisRef((RefType) tr.getType()))); return ths; }
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)); }
/** * 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)); } }
/** * T t = (T) fromLocal; * * @param fromLocal * @param to * @param jb * @param us * @return */ private Local narrowingReferenceConversion(Local fromLocal, Type to, JimpleBody jb, PatchingChain<Unit> us, LocalGenerator lc) { if (fromLocal.getType().equals(to)) { return fromLocal; } if (!(fromLocal.getType() instanceof RefType || fromLocal.getType() instanceof ArrayType)) { return fromLocal; } // throw new IllegalArgumentException("Expected source to have reference type"); if (!(to instanceof RefType || to instanceof ArrayType)) { return fromLocal; // throw new IllegalArgumentException("Expected target to have reference type"); } Local l2 = lc.generateLocal(to); us.add(Jimple.v().newAssignStmt(l2, Jimple.v().newCastExpr(fromLocal, to))); return l2; }
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()), 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());
us.add(Jimple.v().newIdentityStmt(this_, Jimple.v().newThisRef(tclass.getType()))); for (Type ty : implMethodType.getParameterTypes()) { Local l = lc.generateLocal(ty); us.add(Jimple.v().newIdentityStmt(l, Jimple.v().newParameterRef(ty, i))); samParamLocals.add(l); i++; us.add(Jimple.v().newAssignStmt(l, Jimple.v().newInstanceFieldRef(this_, f.makeRef()))); args.add(l);
units.add(handler);
units.add(Jimple.v().newReturnVoidStmt()); } else if (returnType instanceof PrimType) { units.add(Jimple.v().newReturnStmt(IntConstant.v(0))); } else { units.add(Jimple.v().newReturnStmt(NullConstant.v())); units.add(Jimple.v().newInvokeStmt(Jimple.v().newSpecialInvokeExpr(ths, superclassMethodRef, args))); units.add(Jimple.v().newReturnVoidStmt()); } else { Local loc = Jimple.v().newLocal("retValue", returnType); body.getLocals().add(loc); units.add(Jimple.v().newAssignStmt(loc, Jimple.v().newSpecialInvokeExpr(ths, superclassMethodRef, args))); units.add(Jimple.v().newReturnStmt(loc)); List<Local> args = BodyBuilder.buildParameterLocals(initUnits, locals, paramTypes); initUnits.add(Jimple.v().newInvokeStmt(Jimple.v().newSpecialInvokeExpr(ths, smr, args))); initUnits.add(Jimple.v().newReturnVoidStmt()); } else { newSuperInit = mediatingClass.getMethod(constructorName, smr.parameterTypes());
clinitUnits.add(newStmt); } else { clinitUnits.insertBeforeNoRedirect(newStmt, firstStmt); .newInvokeStmt(Jimple.v().newSpecialInvokeExpr(lockLocal, initMethod.makeRef(), Collections.EMPTY_LIST)); if (addingNewClinit) { clinitUnits.add(initStmt); } else { clinitUnits.insertBeforeNoRedirect(initStmt, firstStmt); Stmt assignStmt = Jimple.v().newAssignStmt(actualLockSfr, lockLocal); if (addingNewClinit) { clinitUnits.add(assignStmt); } else { clinitUnits.insertBeforeNoRedirect(assignStmt, firstStmt); clinitUnits.add(Jimple.v().newReturnVoidStmt());
units.add(pop); units.add((Unit) prev.clone()); b.getTraps().add(Baf.v().newTrap(ThrowSet.getRandomThrowable(), ifinst, sii, pop)); if (Rand.getInt() % 2 == 0) { units.insertBefore(pop, sii); units.insertBefore(Baf.v().newGotoInst(sii), pop); units.add(Baf.v().newJSRInst(pop)); } else { units.add(Baf.v().newGotoInst(sii)); if (!BodyBuilder.isExceptionCaughtAt(units, sii, b.getTraps().iterator())) { Unit handler = Baf.v().newThrowInst(); units.add(handler); b.getTraps().add(Baf.v().newTrap(ThrowSet.getRandomThrowable(), sii, (Unit) units.getSuccOf(sii), handler)); done = true;