private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException { in.defaultReadObject(); exception = Scene.v().getSootClass((String) in.readObject()); }
public Set<SootClass> classNewInstanceClasses(SootMethod container) { Set<SootClass> result = new LinkedHashSet<SootClass>(); for (String className : classNewInstanceClassNames(container)) { result.add(Scene.v().getSootClass(className)); } return result; }
public Set<SootClass> classForNameClasses(SootMethod container) { Set<SootClass> result = new LinkedHashSet<SootClass>(); for (String className : classForNameClassNames(container)) { result.add(Scene.v().getSootClass(className)); } return result; }
private boolean catches_RuntimeException(SootClass c) { if ((c == Scene.v().getSootClass("java.lang.Throwable")) || (c == Scene.v().getSootClass("java.lang.Exception"))) { return true; } SootClass caughtException = c, runtimeException = Scene.v().getSootClass("java.lang.RuntimeException"); while (true) { if (caughtException == runtimeException) { return true; } if (caughtException.hasSuperclass() == false) { return false; } caughtException = caughtException.getSuperclass(); } } }
private boolean is_HandledByRuntime(SootClass c) { SootClass thrownException = c, runtimeException = Scene.v().getSootClass("java.lang.RuntimeException"), error = Scene.v().getSootClass("java.lang.Error"); while (true) { if ((thrownException == runtimeException) || (thrownException == error)) { return true; } if (thrownException.hasSuperclass() == false) { return false; } thrownException = thrownException.getSuperclass(); } } }
public Value createJimpleConstantValue(cp_info[] constant_pool) { CONSTANT_Class_info cc = (CONSTANT_Class_info) (constant_pool[class_index]); CONSTANT_NameAndType_info cn = (CONSTANT_NameAndType_info) (constant_pool[name_and_type_index]); String className = cc.toString(constant_pool); String nameAndType = cn.toString(constant_pool); String name = nameAndType.substring(0, nameAndType.indexOf(":")); String typeName = nameAndType.substring(nameAndType.indexOf(":") + 1); Type type = Util.v().jimpleTypeOfFieldDescriptor(typeName); return Jimple.v().newStaticFieldRef(Scene.v().makeFieldRef(Scene.v().getSootClass(className), name, type, true)); }
public SootMethod grabMethod(String methodSignature) { String cname = signatureToClass(methodSignature); String mname = signatureToSubsignature(methodSignature); if (!containsClass(cname)) { return null; } SootClass c = getSootClass(cname); return c.getMethodUnsafe(mname); }
/** * Adds an edge to the constructor of the target class from this call to {@link Class#newInstance()}. */ @Override public void classNewInstance(SootMethod container, Stmt newInstanceInvokeStmt) { Set<String> classNames = reflectionInfo.classNewInstanceClassNames(container); if (classNames == null || classNames.isEmpty()) { registerGuard(container, newInstanceInvokeStmt, "Class.newInstance() call site; Soot did not expect this site to be reached"); } else { for (String clsName : classNames) { SootClass cls = Scene.v().getSootClass(clsName); SootMethod constructor = cls.getMethodUnsafe(sigInit); if (constructor != null) { addEdge(container, newInstanceInvokeStmt, constructor, Kind.REFL_CLASS_NEWINSTANCE); } } } }
public static void main(String[] args) { // assumes 2 args: Class + Method Scene.v().loadClassAndSupport(args[0]); SootClass sc = Scene.v().getSootClass(args[0]); SootMethod sm = sc.getMethod(args[1]); Body b = sm.retrieveActiveBody(); CompleteBlockGraph cfg = new CompleteBlockGraph(b); System.out.println(cfg); BlockGraphConverter.addStartStopNodesTo(cfg); System.out.println(cfg); BlockGraphConverter.reverse(cfg); System.out.println(cfg); }
public SootField grabField(String fieldSignature) { String cname = signatureToClass(fieldSignature); String fname = signatureToSubsignature(fieldSignature); if (!containsClass(cname)) { return null; } SootClass c = getSootClass(cname); return c.getFieldUnsafe(fname); }
private SootMethodRef toSootMethodRef(Handle methodHandle) { String bsmClsName = AsmUtil.toQualifiedName(methodHandle.getOwner()); SootClass bsmCls = Scene.v().getSootClass(bsmClsName); List<Type> bsmSigTypes = AsmUtil.toJimpleDesc(methodHandle.getDesc()); Type returnType = bsmSigTypes.remove(bsmSigTypes.size() - 1); return Scene.v().makeMethodRef(bsmCls, methodHandle.getName(), bsmSigTypes, returnType, methodHandle.getTag() == MethodHandle.Kind.REF_INVOKE_STATIC.getValue()); }
private void addCaching() { SootClass method = Scene.v().getSootClass("java.lang.reflect.Method"); method.addField(Scene.v().makeSootField(ALREADY_CHECKED_FIELDNAME, BooleanType.v())); SootClass constructor = Scene.v().getSootClass("java.lang.reflect.Constructor"); constructor.addField(Scene.v().makeSootField(ALREADY_CHECKED_FIELDNAME, BooleanType.v())); SootClass clazz = Scene.v().getSootClass("java.lang.Class"); clazz.addField(Scene.v().makeSootField(ALREADY_CHECKED_FIELDNAME, BooleanType.v())); for (Kind k : Kind.values()) { addCaching(k); } }
public static void main(String[] args) { // assumes 2 args: Class + Method Scene.v().loadClassAndSupport(args[0]); SootClass sc = Scene.v().getSootClass(args[0]); SootMethod sm = sc.getMethod(args[1]); Body b = sm.retrieveActiveBody(); ShimpleBody sb = Shimple.v().newBody(b); CompleteBlockGraph cfg = new CompleteBlockGraph(sb); ValueGraph vg = new ValueGraph(cfg); System.out.println(vg); }
public static void main(String[] args) { // assumes 2 args: Class + Method Scene.v().loadClassAndSupport(args[0]); SootClass sc = Scene.v().getSootClass(args[0]); SootMethod sm = sc.getMethod(args[1]); Body b = sm.retrieveActiveBody(); ShimpleBody sb = Shimple.v().newBody(b); CompleteBlockGraph cfg = new CompleteBlockGraph(sb); SimpleGlobalValueNumberer sgvn = new SimpleGlobalValueNumberer(cfg); System.out.println(sgvn); }
/** Return a dummy SootMethodRef for the method invoked by a * invoke-custom instruction. */ protected SootMethodRef getCustomSootMethodRef() { CallSiteReference callSiteReference = (CallSiteReference) ((ReferenceInstruction) instruction).getReference(); SootClass dummyclass = Scene.v().getSootClass(SootClass.INVOKEDYNAMIC_DUMMY_CLASS_NAME); String methodName = callSiteReference.getMethodName(); MethodProtoReference methodRef = callSiteReference.getMethodProto(); // No reference kind stored in invoke custom instruction for the actual // method being invoked so default to static return getSootMethodRef(dummyclass, methodName, methodRef.getReturnType(), methodRef.getParameterTypes(), Kind.REF_INVOKE_STATIC); }
private SootFieldRef toSootFieldRef(Handle methodHandle) { String bsmClsName = AsmUtil.toQualifiedName(methodHandle.getOwner()); SootClass bsmCls = Scene.v().getSootClass(bsmClsName); Type t = AsmUtil.toJimpleDesc(methodHandle.getDesc()).get(0); int kind = methodHandle.getTag(); return Scene.v().makeFieldRef(bsmCls, methodHandle.getName(), t, kind == MethodHandle.Kind.REF_GET_FIELD_STATIC.getValue() || kind == MethodHandle.Kind.REF_PUT_FIELD_STATIC.getValue()); }
/** * Returns a (possibly not yet resolved) SootClass to be used in references to a class. If/when the class is resolved, it * will be resolved into this SootClass. */ public SootClass makeClassRef(String className) { if (Scene.v().containsClass(className)) { return Scene.v().getSootClass(className); } SootClass newClass; newClass = new SootClass(className); newClass.setResolvingLevel(SootClass.DANGLING); Scene.v().addClass(newClass); return newClass; }
private soot.Local createToString(soot.Local sb, polyglot.ast.Expr expr) { // invoke toString on local (type StringBuffer) soot.Local newString = lg.generateLocal(soot.RefType.v("java.lang.String")); soot.SootClass classToInvoke2 = soot.Scene.v().getSootClass("java.lang.StringBuffer"); soot.SootMethodRef methodToInvoke2 = soot.Scene.v().makeMethodRef(classToInvoke2, "toString", new ArrayList(), soot.RefType.v("java.lang.String"), false); soot.jimple.VirtualInvokeExpr toStringInvoke = soot.jimple.Jimple.v().newVirtualInvokeExpr(sb, methodToInvoke2); soot.jimple.Stmt lastAssign = soot.jimple.Jimple.v().newAssignStmt(newString, toStringInvoke); body.getUnits().add(lastAssign); Util.addLnPosTags(lastAssign, expr.position()); return newString; }
/** * @apilevel internal */ private SootClass sootClass_compute() { if(!Scene.v().isIncrementalBuild()) { return refined_EmitJimpleRefinements_ClassDecl_sootClass(); } if(Scene.v().containsClass(jvmName())) { Scene.v().removeClass(Scene.v().getSootClass(jvmName())); } SootClass sc = null; if(options().verbose()) System.out.println("Creating from source " + jvmName()); sc = new SootClass(jvmName()); sc.setResolvingLevel(SootClass.DANGLING); Scene.v().addClass(sc); return sc; } /**
private soot.Local createStringBuffer(polyglot.ast.Expr expr) { // create and add one string buffer soot.Local local = lg.generateLocal(soot.RefType.v("java.lang.StringBuffer")); soot.jimple.NewExpr newExpr = soot.jimple.Jimple.v().newNewExpr(soot.RefType.v("java.lang.StringBuffer")); soot.jimple.Stmt assign = soot.jimple.Jimple.v().newAssignStmt(local, newExpr); body.getUnits().add(assign); Util.addLnPosTags(assign, expr.position()); soot.SootClass classToInvoke1 = soot.Scene.v().getSootClass("java.lang.StringBuffer"); soot.SootMethodRef methodToInvoke1 = soot.Scene.v().makeMethodRef(classToInvoke1, "<init>", new ArrayList(), soot.VoidType.v(), false); soot.jimple.SpecialInvokeExpr invoke = soot.jimple.Jimple.v().newSpecialInvokeExpr(local, methodToInvoke1); soot.jimple.Stmt invokeStmt = soot.jimple.Jimple.v().newInvokeStmt(invoke); body.getUnits().add(invokeStmt); Util.addLnPosTags(invokeStmt, expr.position()); return local; }