@Override public void visit(Value e) { if (e instanceof UshrExpr) { UshrExpr ue = (UshrExpr) e; add(e, ue.getOp1(), ue.getOp2()); } }
@Override public void caseUshrExpr(UshrExpr v) { throw new RuntimeException("todo"); }
public void caseUshrExpr(UshrExpr v) { printBinaryExpr(v); }
private void handleBinopExpr(BinopExpr be, Stmt stmt, Type tlhs) { Value opl = be.getOp1(), opr = be.getOp2(); Type tl = AugEvalFunction.eval_(this.tg, opl, stmt, this.jb), tr = AugEvalFunction.eval_(this.tg, opr, stmt, this.jb); if ( be instanceof AddExpr || be instanceof SubExpr || be instanceof MulExpr || be instanceof DivExpr || be instanceof RemExpr || be instanceof GeExpr || be instanceof GtExpr || be instanceof LeExpr || be instanceof LtExpr || be instanceof ShlExpr || be instanceof ShrExpr || be instanceof UshrExpr ) { if ( tlhs instanceof IntegerType ) { be.setOp1(this.uv.visit(opl, IntType.v(), stmt)); be.setOp2(this.uv.visit(opr, IntType.v(), stmt)); } } else if ( be instanceof CmpExpr || be instanceof CmpgExpr || be instanceof CmplExpr ) { // No checks in the original assigner } else if ( be instanceof AndExpr || be instanceof OrExpr || be instanceof XorExpr ) { be.setOp1(this.uv.visit(opl, tlhs, stmt)); be.setOp2(this.uv.visit(opr, tlhs, stmt)); } else if ( be instanceof EqExpr || be instanceof NeExpr ) { if ( tl instanceof BooleanType && tr instanceof BooleanType ) { } else if ( tl instanceof Integer1Type || tr instanceof Integer1Type ) { } else if ( tl instanceof IntegerType ) { be.setOp1(this.uv.visit(opl, IntType.v(), stmt)); be.setOp2(this.uv.visit(opr, IntType.v(), stmt)); } } }
@Override public void caseUshrExpr(UshrExpr usre) { stmtV.addInsn(buildCalculatingBinaryInsn("USHR", usre.getOp1(), usre.getOp2()), origStmt); }
public void caseUshrExpr(UshrExpr expr) { caseBinopExpr(expr); }
@Override public void caseUshrExpr(UshrExpr arg0) { translateBinOp(arg0); }
/** * DOC * * @see soot.jimple.ExprSwitch#caseUshrExpr(soot.jimple.UshrExpr) */ @Override public void caseUshrExpr(UshrExpr v) { v.getOp1().apply(this); v.getOp2().apply(this); }
@Override public void caseUshrExpr(UshrExpr v) { throwInvalidWriteException(v); }
@Override public void caseUshrExpr(UshrExpr v) { handleBinaryExpr(v.getOp1(), v.getOp2()); }
/** * It is not neccessary to treat arithmetic expressions. The SecurityLevels * of this expressions are treated at an other place. * @param v an arithmetic expression */ @Override public void caseUshrExpr(UshrExpr v) { logger.finest("Ushr Expr identified " + callingStmt.toString()); rightElement = RightElement.NOT; }
/** * The method should update the <em>security level</em> of a * {@link UshrExpr}, but it is not possible to update the level of an * expression. * * @param v * The expression for which the <em>security level</em> should be * updated. * @see soot.jimple.ExprSwitch#caseUshrExpr(soot.jimple.UshrExpr) * @throws InvalidSwitchException * Always, because the update is not possible. */ @Override public void caseUshrExpr(UshrExpr v) { throw new SwitchException(getMsg("exception.analysis.switch.update_error", this.getClass().getSimpleName(), v.getClass().getSimpleName(), v.toString(), getSourceLine())); }
/** * Looks up the <em>security level</em> for the given binary expression and * stores the level in {@link SecurityLevelValueReadSwitch#level}. For a * {@link UshrExpr} this is the strongest operand <em>security level</em> of * the given binary expression. * * @param v * The expression for which the <em>security level</em> should be * looked up. * @see soot.jimple.ExprSwitch#caseUshrExpr(soot.jimple.UshrExpr) * @see SecurityLevelValueReadSwitch#handleBinaryOperation(BinopExpr) */ @Override public void caseUshrExpr(UshrExpr v) { handleBinaryOperation(v); }