private boolean examineInvokeExpr(InvokeExpr e) { List<Value> args = e.getArgs(); List<Type> argTypes = e.getMethodRef().parameterTypes(); assert args.size() == argTypes.size(); for (int i = 0; i < args.size(); i++) { if (args.get(i) == l && isFloatingPointLike(argTypes.get(i))) { return true; } } return false; }
private List<Register> getInvokeArgumentRegs(InvokeExpr ie) { constantV.setOrigStmt(origStmt); List<Register> argumentRegs = new ArrayList<Register>(); for (Value arg : ie.getArgs()) { Register currentReg = regAlloc.asImmediate(arg, constantV); argumentRegs.add(currentReg); } return argumentRegs; }
Stmt stmt = (Stmt) callStmt; InvokeExpr invokeExpr = stmt.getInvokeExpr(); final List<Value> args = invokeExpr.getArgs();
Stmt stmt = (Stmt) callStmt; InvokeExpr invokeExpr = stmt.getInvokeExpr(); final List<Value> args = invokeExpr.getArgs();
private boolean examineInvokeExpr(InvokeExpr e) { List<Value> args = e.getArgs(); List<Type> argTypes = e.getMethodRef().parameterTypes(); assert args.size() == argTypes.size(); for (int i = 0; i < args.size(); i++) { if (args.get(i) == l && isObject(argTypes.get(i))) { return true; } } // check for base SootMethodRef sm = e.getMethodRef(); if (!sm.isStatic()) { if (e instanceof AbstractInvokeExpr) { AbstractInstanceInvokeExpr aiiexpr = (AbstractInstanceInvokeExpr) e; Value b = aiiexpr.getBase(); if (b == l) { return true; } } } return false; }
private boolean examineInvokeExpr(InvokeExpr e) { List<Value> args = e.getArgs(); List<Type> argTypes = e.getMethodRef().parameterTypes(); assert args.size() == argTypes.size(); for (int i = 0; i < args.size(); i++) { if (args.get(i) == l && isObject(argTypes.get(i))) { return true; } } // check for base SootMethodRef sm = e.getMethodRef(); if (!sm.isStatic()) { if (e instanceof AbstractInvokeExpr) { AbstractInstanceInvokeExpr aiiexpr = (AbstractInstanceInvokeExpr) e; Value b = aiiexpr.getBase(); if (b == l) { return true; } } } return false; }
@Override public FlowFunction<Value> getReturnFlowFunction(final Unit callSite, SootMethod calleeMethod, final Unit exitStmt, Unit returnSite) { Stmt s = (Stmt) callSite; InvokeExpr ie = s.getInvokeExpr(); final List<Value> callArgs = ie.getArgs(); final List<Local> paramLocals = new ArrayList<Local>(); for (int i = 0; i < calleeMethod.getParameterCount(); i++) { paramLocals.add(calleeMethod.getActiveBody().getParameterLocal(i)); } return new FlowFunction<Value>() { public Set<Value> computeTargets(Value source) { Set<Value> liveParamsAtCallee = new HashSet<Value>(); for (int i = 0; i < paramLocals.size(); i++) { if (paramLocals.get(i).equivTo(source)) { liveParamsAtCallee.add(callArgs.get(i)); } } return liveParamsAtCallee; } }; }
public FlowFunction<Pair<Value, Type>> getCallFlowFunction(final Unit src, final SootMethod dest) { Stmt stmt = (Stmt) src; InvokeExpr ie = stmt.getInvokeExpr(); final List<Value> callArgs = ie.getArgs(); final List<Local> paramLocals = new ArrayList<Local>(); for (int i = 0; i < dest.getParameterCount(); i++) { paramLocals.add(dest.getActiveBody().getParameterLocal(i)); } return new FlowFunction<Pair<Value, Type>>() { public Set<Pair<Value, Type>> computeTargets(Pair<Value, Type> source) { if (!dest.getName().equals("<clinit>") && !dest.getSubSignature().equals("void run()")) { Value value = source.getO1(); int argIndex = callArgs.indexOf(value); if (argIndex > -1) { return Collections.singleton(new Pair<Value, Type>(paramLocals.get(argIndex), source.getO2())); } } return Collections.emptySet(); } }; }
@Override public FlowFunction<Local> getCallFlowFunction(Unit src, final SootMethod dest) { Stmt s = (Stmt) src; InvokeExpr ie = s.getInvokeExpr(); final List<Value> callArgs = ie.getArgs(); final List<Local> paramLocals = new ArrayList<Local>(); for (int i = 0; i < dest.getParameterCount(); i++) { paramLocals.add(dest.getActiveBody().getParameterLocal(i)); } return new FlowFunction<Local>() { public Set<Local> computeTargets(Local source) { // ignore implicit calls to static initializers if (dest.getName().equals(SootMethod.staticInitializerName) && dest.getParameterCount() == 0) { return Collections.emptySet(); } Set<Local> taintsInCaller = new HashSet<Local>(); for (int i = 0; i < callArgs.size(); i++) { if (callArgs.get(i).equivTo(source)) { taintsInCaller.add(paramLocals.get(i)); } } return taintsInCaller; } }; }
public static int getOutWordCount(Collection<Unit> units) { int outWords = 0; for (Unit u : units) { Stmt stmt = (Stmt) u; if (stmt.containsInvokeExpr()) { int wordsForParameters = 0; InvokeExpr invocation = stmt.getInvokeExpr(); List<Value> args = invocation.getArgs(); for (Value arg : args) { wordsForParameters += getDexWords(arg.getType()); } if (!invocation.getMethod().isStatic()) { wordsForParameters++; // extra word for "this" } if (wordsForParameters > outWords) { outWords = wordsForParameters; } } } return outWords; }
/** * @param stmt * any statement containing an InvokeExpr * * @see PurityGraph.methodCall */ @Override protected void applySummary(PurityGraphBox src, Stmt stmt, PurityGraphBox summary, PurityGraphBox dst) { // extract call info InvokeExpr e = stmt.getInvokeExpr(); Local ret = null; if (stmt instanceof AssignStmt) { Local v = (Local) ((AssignStmt) stmt).getLeftOp(); if (v.getType() instanceof RefLikeType) { ret = v; } } Local obj = null; if (!(e instanceof StaticInvokeExpr)) { obj = (Local) ((InstanceInvokeExpr) e).getBase(); } List<Value> args = e.getArgs(); // call methoCall on the PurityGraph PurityGraph g = new PurityGraph(src.g); g.methodCall(summary.g, obj, args, ret); dst.g = g; }
List<Value> args = invokeExpr.getArgs(); List<Type> parameterTypes = invokedMethodRef.parameterTypes(); int argsCount = args.size();
args.add(((InstanceInvokeExpr) expr).getBase()); args.addAll(expr.getArgs()); InvokeExpr newExpr = Jimple.v().newStaticInvokeExpr(accessor.makeRef(), args);
HashSet tokills = new HashSet(); Value expr = stmt.getInvokeExpr(); List parameters = ((InvokeExpr) expr).getArgs();
case ConstructorNewInstance: args.add((Value) ie.getArgs().get(0)); break; case MethodInvoke: args.add((Value) ie.getArgs().get(0)); args.add((Value) ie.getArgs().get(1)); break; case FieldSet: args.add((Value) ie.getArgs().get(0)); args.add((Value) ie.getArgs().get(1)); break; case FieldGet: args.add((Value) ie.getArgs().get(0)); break; default:
newArgs.addAll(ie.getArgs());
@Override public Set<Value> computeTargets(Value source) { for (Value arg : invokeExpr.getArgs()) { if (arg.equivTo(source)) { return Collections.emptySet(); } } return Collections.singleton(source); } };
/** * Gets the number of non-constant arguments to the given method call * * @param s A call site * @return The number of non-constant arguments in the given call site */ private int getNonConstParamCount(Stmt s) { int cnt = 0; for (Value val : s.getInvokeExpr().getArgs()) if (!(val instanceof Constant)) cnt++; return cnt; }
@Override public Set<Value> computeTargets(Value source) { for (Value arg : invokeExpr.getArgs()) { if (arg.equivTo(source)) { return Collections.emptySet(); } } Value left = definitionStmt.getLeftOp(); if (left.equivTo(source) || left.toString().equals(source.toString())) { return Collections.emptySet(); } return Collections.singleton(source); } };
@Override public boolean isExclusiveInternal(Stmt stmt, AccessPath taintedPath) { assert stmt.containsInvokeExpr(); // We are exclusive if the base object is tainted if (stmt.getInvokeExpr() instanceof InstanceInvokeExpr) { InstanceInvokeExpr iiExpr = (InstanceInvokeExpr) stmt.getInvokeExpr(); if (taintedPath.getPlainValue().equals(iiExpr.getBase())) return true; } // If one parameter is tainted, we are exclusive as well for (Value param : stmt.getInvokeExpr().getArgs()) if (taintedPath.getPlainValue().equals(param)) return true; return false; }