1. 包列表
  2. 类列表
  3. soot.jimple.LongConstant

Java 类soot.jimple.LongConstant 实例源码

项目：FuzzDroid    文件：TimingBombTransformer.java    
private void prepareAlarmManagerSet(Body body, InvokeStmt setStmt, SootMethodRef reportRef) {
    Value oldVal = setStmt.getInvokeExpr().getArg(1);

    Local longLocal = UtilInstrumenter.generateFreshLocal(body, LongType.v());
    SootMethod currentTimeMillis = Scene.v().getMethod("<java.lang.System: long currentTimeMillis()>");     
    StaticInvokeExpr timeInvoke = Jimple.v().newStaticInvokeExpr(currentTimeMillis.makeRef());      
    AssignStmt timeInitalize = Jimple.v().newAssignStmt(longLocal, timeInvoke);

    AddExpr addTime = Jimple.v().newAddExpr(longLocal, LongConstant.v(2000L));
    AssignStmt timeAssign = Jimple.v().newAssignStmt(longLocal, addTime);


    body.getUnits().insertBefore(timeInitalize, setStmt);
    body.getUnits().insertBefore(timeAssign, setStmt);

    InvokeExpr expr = setStmt.getInvokeExpr();
    expr.setArg(0, IntConstant.v(0));
    expr.setArg(1, longLocal);

    // Report the change
    InvokeStmt reportStmt = Jimple.v().newInvokeStmt(Jimple.v().newStaticInvokeExpr(
            reportRef, oldVal, longLocal));
    reportStmt.addTag(new InstrumentedCodeTag());
    body.getUnits().insertAfter(reportStmt, setStmt);
}
项目：JAADAS    文件：BaseEntryPointCreator.java    
protected Value getSimpleDefaultValue(String t) {
    if (t.equals("java.lang.String"))
        return StringConstant.v("");
    if (t.equals("char"))
        return DIntConstant.v(0, CharType.v());
    if (t.equals("byte"))
        return DIntConstant.v(0, ByteType.v());
    if (t.equals("short"))
        return DIntConstant.v(0, ShortType.v());
    if (t.equals("int"))
        return IntConstant.v(0);
    if (t.equals("float"))
        return FloatConstant.v(0);
    if (t.equals("long"))
        return LongConstant.v(0);
    if (t.equals("double"))
        return DoubleConstant.v(0);
    if (t.equals("boolean"))
        return DIntConstant.v(0, BooleanType.v());

    //also for arrays etc.
    return G.v().soot_jimple_NullConstant();
}
项目：JAADAS    文件：FixUndefinedLocals.java    
public static PushInst getPushInitializer(Local l, Type t) {
  if (t instanceof IntegerType) {
    return Baf.v().newPushInst(IntConstant.v(soot.jbco.util.Rand.getInt()));
  } else if (t instanceof RefLikeType || t instanceof StmtAddressType) {
    return Baf.v().newPushInst(NullConstant.v());
  } else if (t instanceof LongType) {
    return Baf.v().newPushInst(LongConstant.v(soot.jbco.util.Rand.getLong()));
  } else if (t instanceof FloatType) {
    return Baf.v().newPushInst(
        FloatConstant.v(soot.jbco.util.Rand.getFloat()));
  } else if (t instanceof DoubleType) {
    return Baf.v().newPushInst(
        DoubleConstant.v(soot.jbco.util.Rand.getDouble()));
  }

  return null;
}
项目：JAADAS    文件：Walker.java    
public void outAIntegerConstant(AIntegerConstant node)
   {
String s = (String) mProductions.removeLast();

       StringBuffer buf = new StringBuffer();
       if(node.getMinus() != null)
           buf.append('-');
       buf.append(s);

       s = buf.toString();
       if(s.endsWith("L")) {                        
    mProductions.addLast(LongConstant.v(Long.parseLong(s.substring(0, s.length()-1))));
       } 
       else if (s.equals("2147483648"))
    mProductions.addLast(IntConstant.v(Integer.MIN_VALUE));
       else
    mProductions.addLast(IntConstant.v(Integer.parseInt(s)));
   }
项目：JAADAS    文件：DexNumTransformer.java    
/**
 * Collect all the locals which are assigned a IntConstant(0) or are used
 * within a zero comparison.
 *
 * @param body
 *            the body to analyze
 */
private Set<Local> getNumCandidates(Body body) {
    Set<Local> candidates = new HashSet<Local>();
    for (Unit u : body.getUnits()) {
        if (u instanceof AssignStmt) {
            AssignStmt a = (AssignStmt) u;
            if (!(a.getLeftOp() instanceof Local))
                continue;
            Local l = (Local) a.getLeftOp();
            Value r = a.getRightOp();
            if ((r instanceof IntConstant || r instanceof LongConstant)) {
                candidates.add(l);
                Debug.printDbg("[add null candidate: ", u);
            }
        }
    }

    return candidates;
}
项目：JAADAS    文件：DexNullThrowTransformer.java    
@Override
protected void internalTransform(Body b, String phaseName, Map<String, String> options) {
    LocalCreation lc = new LocalCreation(b.getLocals(), "ex");

    for (Iterator<Unit> unitIt = b.getUnits().snapshotIterator(); unitIt.hasNext(); ) {
        Unit u = unitIt.next();

        // Check for a null exception
        if (u instanceof ThrowStmt) {
            ThrowStmt throwStmt = (ThrowStmt) u;
            if (throwStmt.getOp() == NullConstant.v()
                    || throwStmt.getOp().equals(IntConstant.v(0))
                    || throwStmt.getOp().equals(LongConstant.v(0))) {
                createThrowStmt(b, throwStmt, lc);
            }
        }
    }
}
项目：JAADAS    文件：CPHelper.java    
public static Object isAConstantValue(Value toCheck){
    Object value=null;

    if(toCheck instanceof LongConstant){
        value = new Long(((LongConstant)toCheck).value);
    }
    else if(toCheck instanceof DoubleConstant){
        value = new Double(((DoubleConstant)toCheck).value);
    }
    else if(toCheck instanceof FloatConstant){
        value = new Float(((FloatConstant)toCheck).value);
    }
    else if(toCheck instanceof IntConstant){
        int val = ((IntConstant)toCheck).value;
        value = new Integer(val);           
    }
    return value;
}
项目：JAADAS    文件：CPHelper.java    
public static Value createConstant(Object toConvert){
    if(toConvert instanceof Long){
        return LongConstant.v( ((Long)toConvert).longValue() );
    }
    else if(toConvert instanceof Double){
        return DoubleConstant.v( ((Double)toConvert).doubleValue());
    }
    else if(toConvert instanceof Boolean){
        boolean val = ((Boolean)toConvert).booleanValue();
        if(val)
            return DIntConstant.v(1,BooleanType.v());
        else
            return DIntConstant.v(0,BooleanType.v());
    }   
    else if(toConvert instanceof Float){
        return FloatConstant.v( ((Float)toConvert).floatValue());
    }
    else if(toConvert instanceof Integer){
        return IntConstant.v( ((Integer)toConvert).intValue());
    }
    else
        return null;
}
项目：JAADAS    文件：AsmMethodSource.java    
private Value toSootValue(Object val) throws AssertionError {
    Value v;
    if (val instanceof Integer)
        v = IntConstant.v((Integer) val);
    else if (val instanceof Float)
        v = FloatConstant.v((Float) val);
    else if (val instanceof Long)
        v = LongConstant.v((Long) val);
    else if (val instanceof Double)
        v = DoubleConstant.v((Double) val);
    else if (val instanceof String)
        v = StringConstant.v(val.toString());
    else if (val instanceof org.objectweb.asm.Type)
        v = ClassConstant.v(((org.objectweb.asm.Type) val).getInternalName());
    else if (val instanceof Handle)
        v = MethodHandle.v(toSootMethodRef((Handle) val), ((Handle)val).getTag());
    else
        throw new AssertionError("Unknown constant type: " + val.getClass());
    return v;
}
项目：JAADAS    文件：UnitThrowAnalysis.java    
private void caseBinopDivExpr(BinopExpr expr) {
    // Factors out code common to caseDivExpr and caseRemExpr.
    // The checks against constant divisors would perhaps be
    // better performed in a later pass, post-constant-propagation.
    Value divisor = expr.getOp2();
    Type divisorType = divisor.getType();
    if (divisorType instanceof UnknownType) {
    result = result.add(mgr.ARITHMETIC_EXCEPTION);
    } else if ((divisorType instanceof IntegerType) &&
    ((! (divisor instanceof IntConstant)) ||
     (((IntConstant) divisor).equals(INT_CONSTANT_ZERO)))) {
    result = result.add(mgr.ARITHMETIC_EXCEPTION);
    } else if ((divisorType == LongType.v()) &&
           ((! (divisor instanceof LongConstant)) ||
        (((LongConstant) divisor).equals(LONG_CONSTANT_ZERO)))) {
    result = result.add(mgr.ARITHMETIC_EXCEPTION);
    }
    caseBinopExpr(expr);
}
项目：soot-inflow    文件：BaseEntryPointCreator.java    
protected Value getSimpleDefaultValue(String t) {
    if (t.equals("java.lang.String"))
        return StringConstant.v("");
    if (t.equals("char"))
        return DIntConstant.v(0, CharType.v());
    if (t.equals("byte"))
        return DIntConstant.v(0, ByteType.v());
    if (t.equals("short"))
        return DIntConstant.v(0, ShortType.v());
    if (t.equals("int"))
        return IntConstant.v(0);
    if (t.equals("float"))
        return FloatConstant.v(0);
    if (t.equals("long"))
        return LongConstant.v(0);
    if (t.equals("double"))
        return DoubleConstant.v(0);
    if (t.equals("boolean"))
        return DIntConstant.v(0, BooleanType.v());

    //also for arrays etc.
    return G.v().soot_jimple_NullConstant();
}
项目：FuzzDroid    文件：TimingBombTransformer.java    
private void prepareHandlerPostDelayed(Body body, Stmt invokeStmt, SootMethodRef reportRef) {
    InvokeExpr expr = invokeStmt.getInvokeExpr();

    Value oldValue = expr.getArg(1);
    Value newValue = LongConstant.v(2000L);

    expr.setArg(1, newValue);

    // Report the change
    InvokeStmt reportStmt = Jimple.v().newInvokeStmt(Jimple.v().newStaticInvokeExpr(
            reportRef, oldValue, newValue));
    reportStmt.addTag(new InstrumentedCodeTag());
    body.getUnits().insertAfter(reportStmt, invokeStmt);
}
项目：JAADAS    文件：Walker.java    
public void outAConstantCaseLabel(AConstantCaseLabel node)
   {
String s = (String) mProductions.removeLast();
       int sign = 1;
       if(node.getMinus() != null)
           sign = -1;

       if(s.endsWith("L")) {            
    mProductions.addLast(LongConstant.v(sign * Long.parseLong(s.substring(0, s.length()-1))));
       }
       else if (s.equals("2147483648"))
    mProductions.addLast(IntConstant.v(sign * Integer.MIN_VALUE));
       else
    mProductions.addLast(IntConstant.v(sign * Integer.parseInt(s)));
   }
项目：JAADAS    文件：AbstractNullTransformer.java    
/**
 * Examine expr if it is a comparison with 0.
 *
 * @param expr
 *            the ConditionExpr to examine
 */
protected boolean isZeroComparison(ConditionExpr expr) {
    if (expr instanceof EqExpr || expr instanceof NeExpr) {
        if (expr.getOp2() instanceof IntConstant
                && ((IntConstant) expr.getOp2()).value == 0)
            return true;
        if (expr.getOp2() instanceof LongConstant
                && ((LongConstant) expr.getOp2()).value == 0)
            return true;
    }
    return false;
}
项目：JAADAS    文件：DexNullTransformer.java    
/**
 * Collect all the locals which are assigned a IntConstant(0) or are used
 * within a zero comparison.
 *
 * @param body
 *            the body to analyze
 */
private Set<Local> getNullCandidates(Body body) {
    Set<Local> candidates = null;
    for (Unit u : body.getUnits()) {
        if (u instanceof AssignStmt) {
            AssignStmt a = (AssignStmt) u;
            if (!(a.getLeftOp() instanceof Local))
                continue;
            Local l = (Local) a.getLeftOp();
            Value r = a.getRightOp();
            if ((r instanceof IntConstant && ((IntConstant) r).value == 0)
                    || (r instanceof LongConstant && ((LongConstant) r).value == 0)) {
                if (candidates == null)
                    candidates = new HashSet<Local>();
                candidates.add(l);
                Debug.printDbg("[add null candidate: ", u);
            }
        } else if (u instanceof IfStmt) {
            ConditionExpr expr = (ConditionExpr) ((IfStmt) u)
                    .getCondition();
            if (isZeroComparison(expr) && expr.getOp1() instanceof Local) {
                if (candidates == null)
                    candidates = new HashSet<Local>();
                candidates.add((Local) expr.getOp1());
                Debug.printDbg("[add null candidate if: ", u);
            }
        }
    }

    return candidates == null ? Collections.<Local>emptySet() : candidates;
}
项目：JAADAS    文件：AsmMethodSource.java    
private void convertConstInsn(InsnNode insn) {
    int op = insn.getOpcode();
    StackFrame frame = getFrame(insn);
    Operand[] out = frame.out();
    Operand opr;
    if (out == null) {
        Value v;
        if (op == ACONST_NULL)
            v = NullConstant.v();
        else if (op >= ICONST_M1 && op <= ICONST_5)
            v = IntConstant.v(op - ICONST_0);
        else if (op == LCONST_0 || op == LCONST_1)
            v = LongConstant.v(op - LCONST_0);
        else if (op >= FCONST_0 && op <= FCONST_2)
            v = FloatConstant.v(op - FCONST_0);
        else if (op == DCONST_0 || op == DCONST_1)
            v = DoubleConstant.v(op - DCONST_0);
        else
            throw new AssertionError("Unknown constant opcode: " + op);
        opr = new Operand(insn, v);
        frame.out(opr);
    } else {
        opr = out[0];
    }
    if (op == LCONST_0 || op == LCONST_1 ||
            op == DCONST_0 || op == DCONST_1) {
        pushDual(opr);
    } else {
        push(opr);
    }
}
项目：JAADAS    文件：ConstantInitializerToTagTransformer.java    
private ConstantValueTag createConstantTagFromValue(Constant rightOp) {
    if (rightOp instanceof DoubleConstant)
        return new DoubleConstantValueTag(((DoubleConstant) rightOp).value);
    else if (rightOp instanceof FloatConstant)
        return new FloatConstantValueTag(((FloatConstant) rightOp).value);
    else if (rightOp instanceof IntConstant)
        return new IntegerConstantValueTag(((IntConstant) rightOp).value);
    else if (rightOp instanceof LongConstant)
        return new LongConstantValueTag(((LongConstant) rightOp).value);
    else if (rightOp instanceof StringConstant)
        return new StringConstantValueTag(((StringConstant) rightOp).value);
    else
        return null;
}
项目：JAADAS    文件：ConstantInitializerToTagTransformer.java    
private boolean checkConstantValue(ConstantValueTag t, Constant rightOp) {
    if (t == null || rightOp == null)
        return true;

    if (t instanceof DoubleConstantValueTag) {
        if (!(rightOp instanceof DoubleConstant))
            return false;
        return ((DoubleConstantValueTag) t).getDoubleValue() == ((DoubleConstant) rightOp).value;
    }
    else if (t instanceof FloatConstantValueTag) {
        if (!(rightOp instanceof FloatConstant))
            return false;
        return ((FloatConstantValueTag) t).getFloatValue() == ((FloatConstant) rightOp).value;
    }
    else if (t instanceof IntegerConstantValueTag) {
        if (!(rightOp instanceof IntConstant))
            return false;
        return ((IntegerConstantValueTag) t).getIntValue() == ((IntConstant) rightOp).value;
    }
    else if (t instanceof LongConstantValueTag) {
        if (!(rightOp instanceof LongConstant))
            return false;
        return ((LongConstantValueTag) t).getLongValue() == ((LongConstant) rightOp).value;
    }
    else if (t instanceof StringConstantValueTag) {
        if (!(rightOp instanceof StringConstant))
            return false;
        return ((StringConstantValueTag) t).getStringValue().equals(((StringConstant) rightOp).value);
    }
    else
        // We don't know the type, so we assume it's alright
        return true;
}
项目：JAADAS    文件：UnitThrowAnalysisTest.java    
@Test
public void testJBinOpExp() {
    Value v = Jimple.v().newAddExpr(IntConstant.v(456), 
            Jimple.v().newLocal("local", IntType.v()));
    assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS, Collections.EMPTY_SET,
                unitAnalysis.mightThrow(v)));
    assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES,
            utility.catchableSubset(unitAnalysis.mightThrow(v)));

    v = Jimple.v().newOrExpr(Jimple.v().newLocal("local", LongType.v()),
            LongConstant.v(33));
    assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS, Collections.EMPTY_SET,
                unitAnalysis.mightThrow(v)));
    assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES,
            utility.catchableSubset(unitAnalysis.mightThrow(v)));

    v = Jimple.v().newLeExpr(Jimple.v().newLocal("local", FloatType.v()),
            FloatConstant.v(33.42f));
    assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS, Collections.EMPTY_SET,
                unitAnalysis.mightThrow(v)));
    assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES,
            utility.catchableSubset(unitAnalysis.mightThrow(v)));

    v = Jimple.v().newEqExpr(DoubleConstant.v(-33.45e-3),
            Jimple.v().newLocal("local", DoubleType.v()));
    assertTrue(ExceptionTestUtility.sameMembers(utility.VM_ERRORS, Collections.EMPTY_SET,
                unitAnalysis.mightThrow(v)));
    assertEquals(utility.VM_ERRORS_PLUS_SUPERTYPES,
            utility.catchableSubset(unitAnalysis.mightThrow(v)));
}
项目：bixie    文件：SootValueSwitch.java    
@Override
public void caseLongConstant(LongConstant arg0) {
    long value = arg0.value;
    if (value >= Integer.MAX_VALUE || value <= Integer.MIN_VALUE) {
        Log.debug("Used abstract value for long constant that didn't fit in int");
        this.expressionStack.push(GlobalsCache.v().lookupInternLong(arg0));
    } else {
        expressionStack.push(this.pf.mkIntLiteral(String.valueOf(value)));
    }
}
项目：bixie    文件：GlobalsCache.java    
public IdentifierExpression lookupInternLong(LongConstant s) {
    if (!longInternMap.containsKey(s.toString())) {
        String name = "$LongConst" + longInternMap.size();
        longInternMap.put(s.toString(),
                this.pf.mkIdentifierExpression(this.getBoogieType(s.getType()), name, true, true, true));
    }
    return longInternMap.get(s.toString());
}
项目：averroes    文件：AverroesJimpleBody.java    
/**
 * Return a constant value corresponding to the primary type.
 * 
 * @param type
 * @return
 */
public static Value getPrimValue(PrimType type) {
    if (type instanceof IntegerType) {
        return IntConstant.v(1);
    } else if (type instanceof LongType) {
        return LongConstant.v(1);
    } else if (type instanceof FloatType) {
        return FloatConstant.v(1);
    } else {
        return DoubleConstant.v(1);
    }
}
项目：DroidRA    文件：IntValueAnalysis.java    
/**
 * Returns the possible values for an integer variable.
 * 
 * @param value The variable whose value we are looking for.
 * @param start The statement where the variable is used.
 * @return The set of possible values for the variable.
 */
@Override
public Set<Object> computeVariableValues(Value value, Stmt start) {
  if (value instanceof IntConstant) {
    return Collections.singleton((Object) ((IntConstant) value).value);
  } else if (value instanceof LongConstant) {
    return Collections.singleton((Object) ((LongConstant) value).value);
  } else if (value instanceof Local) {
    return findIntAssignmentsForLocal(start, (Local) value, new HashSet<Stmt>());
  } else {
    return Collections.singleton((Object) TOP_VALUE);
  }
}
项目：DroidRA    文件：IntValueAnalysis.java    
/**
 * Return all possible values for an integer local variable.
 * 
 * @param start The statement where the analysis should start.
 * @param local The local variable whose values we are looking for.
 * @param visitedStmts The set of visited statement.
 * @return The set of possible values for the local variable.
 */
private Set<Object> findIntAssignmentsForLocal(Stmt start, Local local, Set<Stmt> visitedStmts) {
  List<DefinitionStmt> assignStmts =
      findAssignmentsForLocal(start, local, true, new HashSet<Pair<Unit, Local>>());
  Set<Object> result = new HashSet<>(assignStmts.size());

  for (DefinitionStmt assignStmt : assignStmts) {
    Value rhsValue = assignStmt.getRightOp();
    if (rhsValue instanceof IntConstant) {
      result.add(((IntConstant) rhsValue).value);
    } else if (rhsValue instanceof LongConstant) {
      result.add(((LongConstant) rhsValue).value);
    } else if (rhsValue instanceof ParameterRef) {
      ParameterRef parameterRef = (ParameterRef) rhsValue;
      Iterator<Edge> edges =
          Scene.v().getCallGraph()
              .edgesInto(AnalysisParameters.v().getIcfg().getMethodOf(assignStmt));
      while (edges.hasNext()) {
        Edge edge = edges.next();
        InvokeExpr invokeExpr = edge.srcStmt().getInvokeExpr();
        Value argValue = invokeExpr.getArg(parameterRef.getIndex());
        if (argValue instanceof IntConstant) {
          result.add(((IntConstant) argValue).value);
        } else if (argValue instanceof LongConstant) {
          result.add(((LongConstant) argValue).value);
        } else if (argValue instanceof Local) {
          Set<Object> newResults =
              findIntAssignmentsForLocal(edge.srcStmt(), (Local) argValue, visitedStmts);
          result.addAll(newResults);
        } else {
          result.add(TOP_VALUE);
        }
      }
    } else {
      return Collections.singleton((Object) TOP_VALUE);
    }
  }

  return result;
}
项目：DroidRA    文件：InstrumentationUtils.java    
public static Value toDefaultSootTypeValue(Type sootType)
{
    String type = sootType.toString();

    if ("boolean".equals(type))
    {
        IntConstant.v(0);
    }
    else if ("byte".equals(type))
    {
        return IntConstant.v(0);
    }
    else if ("char".equals(type))
    {
        return IntConstant.v(0);
    }
    else if ("short".equals(type))
    {
        return IntConstant.v(0);
    }
    else if ("int".equals(type))
    {
        return IntConstant.v(0);
    }
    else if ("long".equals(type))
    {
        return LongConstant.v(0);
    }
    else if ("float".equals(type))
    {
        return FloatConstant.v(0);
    }
    else if ("double".equals(type))
    {
        return DoubleConstant.v(0);
    }

    return NullConstant.v();
}
项目：jar2bpl    文件：SootValueSwitch.java    
@Override
public void caseLongConstant(LongConstant arg0) {
    long value = arg0.value;
    if (value >= Integer.MAX_VALUE || value <= Integer.MIN_VALUE) {
        Log.debug("Used abstract value for long constant that didn't fit in int");
        this.expressionStack.push(GlobalsCache.v().lookupInternLong(arg0));
    } else {
        expressionStack.push(this.pf.mkIntLiteral(String.valueOf(value)));
    }
}
项目：jar2bpl    文件：GlobalsCache.java    
public IdentifierExpression lookupInternLong(LongConstant s) {
    if (!longInternMap.containsKey(s.toString())) {
        String name = "$LongConst"+longInternMap.size();
        longInternMap.put(s.toString(), this.pf.mkIdentifierExpression(this.getBoogieType(s.getType()), name, true, true, true));
    }
    return longInternMap.get(s.toString());
}
项目：coal    文件：IntValueAnalysis.java    
/**
 * Returns the possible values for an integer variable.
 * 
 * @param value The variable whose value we are looking for.
 * @param start The statement where the variable is used.
 * @return The set of possible values for the variable.
 */
@Override
public Set<Object> computeVariableValues(Value value, Stmt start) {
  if (value instanceof IntConstant) {
    return Collections.singleton((Object) ((IntConstant) value).value);
  } else if (value instanceof LongConstant) {
    return Collections.singleton((Object) ((LongConstant) value).value);
  } else if (value instanceof Local) {
    return findIntAssignmentsForLocal(start, (Local) value, new HashSet<Stmt>());
  } else {
    return Collections.singleton((Object) TOP_VALUE);
  }
}
项目：coal    文件：IntValueAnalysis.java    
/**
 * Return all possible values for an integer local variable.
 * 
 * @param start The statement where the analysis should start.
 * @param local The local variable whose values we are looking for.
 * @param visitedStmts The set of visited statement.
 * @return The set of possible values for the local variable.
 */
private Set<Object> findIntAssignmentsForLocal(Stmt start, Local local, Set<Stmt> visitedStmts) {
  List<DefinitionStmt> assignStmts =
      findAssignmentsForLocal(start, local, true, new HashSet<Pair<Unit, Local>>());
  Set<Object> result = new HashSet<>(assignStmts.size());

  for (DefinitionStmt assignStmt : assignStmts) {
    Value rhsValue = assignStmt.getRightOp();
    if (rhsValue instanceof IntConstant) {
      result.add(((IntConstant) rhsValue).value);
    } else if (rhsValue instanceof LongConstant) {
      result.add(((LongConstant) rhsValue).value);
    } else if (rhsValue instanceof ParameterRef) {
      ParameterRef parameterRef = (ParameterRef) rhsValue;
      Iterator<Edge> edges =
          Scene.v().getCallGraph()
              .edgesInto(AnalysisParameters.v().getIcfg().getMethodOf(assignStmt));
      while (edges.hasNext()) {
        Edge edge = edges.next();
        InvokeExpr invokeExpr = edge.srcStmt().getInvokeExpr();
        Value argValue = invokeExpr.getArg(parameterRef.getIndex());
        if (argValue instanceof IntConstant) {
          result.add(((IntConstant) argValue).value);
        } else if (argValue instanceof LongConstant) {
          result.add(((LongConstant) argValue).value);
        } else if (argValue instanceof Local) {
          Set<Object> newResults =
              findIntAssignmentsForLocal(edge.srcStmt(), (Local) argValue, visitedStmts);
          result.addAll(newResults);
        } else {
          result.add(TOP_VALUE);
        }
      }
    } else {
      return Collections.singleton((Object) TOP_VALUE);
    }
  }

  return result;
}
项目：matos-tool    文件：ConstantValue.java    
/**
 * Builds a representation of a constant from its value expressed as
 * a Soot constant and its Soot type. It is transformed in an equivalent
 * pair of strings.
 * @param v the value of the constant
 * @param t its type.
 */
public ConstantValue(Constant v, Type t) { 
    if (v instanceof IntConstant) {
        int n = ((IntConstant) v).value;
        if (t instanceof CharType) {
            rep_t = CHAR_TYPE;
            rep_v = Character.toString((char) n);
        } else if (t instanceof BooleanType) {
            rep_t = BOOLEAN_TYPE;
            rep_v = Boolean.toString((n != 0));
        } else {
            rep_t = INT_TYPE;
            rep_v = Integer.toString(n);
        }
    } else if (v instanceof LongConstant) {
        rep_t = LONG_TYPE;
        rep_v = Long.toString(((LongConstant) v).value);
    } else if (v instanceof FloatConstant) {
        rep_t = FLOAT_TYPE;
        rep_v = Float.toString(((FloatConstant) v).value);
    } else if (v instanceof NullConstant) {
        rep_t = NULL;
        rep_v = NULL;
    } else {
        rep_t = t.toString();
        rep_v = "";
    }
}
项目：JAADAS    文件：ValueTemplatePrinter.java    
public void caseLongConstant(LongConstant v) {
    printConstant(v,Long.toString(v.value));
}
项目：JAADAS    文件：ConstraintCollector.java    
public void caseIfStmt(IfStmt stmt) {
    if (uses) {
        ConditionExpr cond = (ConditionExpr) stmt.getCondition();

        BinopExpr expr = cond;
        Value lv = expr.getOp1();
        Value rv = expr.getOp2();

        TypeVariable lop;
        TypeVariable rop;

        // ******** LEFT ********
        if (lv instanceof Local) {
            lop = resolver.typeVariable((Local) lv);
        } else if (lv instanceof DoubleConstant) {
            lop = resolver.typeVariable(DoubleType.v());
        } else if (lv instanceof FloatConstant) {
            lop = resolver.typeVariable(FloatType.v());
        } else if (lv instanceof IntConstant) {
            lop = resolver.typeVariable(IntType.v());
        } else if (lv instanceof LongConstant) {
            lop = resolver.typeVariable(LongType.v());
        } else if (lv instanceof NullConstant) {
            lop = resolver.typeVariable(NullType.v());
        } else if (lv instanceof StringConstant) {
            lop = resolver.typeVariable(RefType.v("java.lang.String"));
        } else if (lv instanceof ClassConstant) {
            lop = resolver.typeVariable(RefType.v("java.lang.Class"));
        } else {
            throw new RuntimeException("Unhandled binary expression left operand type: " + lv.getClass());
        }

        // ******** RIGHT ********
        if (rv instanceof Local) {
            rop = resolver.typeVariable((Local) rv);
        } else if (rv instanceof DoubleConstant) {
            rop = resolver.typeVariable(DoubleType.v());
        } else if (rv instanceof FloatConstant) {
            rop = resolver.typeVariable(FloatType.v());
        } else if (rv instanceof IntConstant) {
            rop = resolver.typeVariable(IntType.v());
        } else if (rv instanceof LongConstant) {
            rop = resolver.typeVariable(LongType.v());
        } else if (rv instanceof NullConstant) {
            rop = resolver.typeVariable(NullType.v());
        } else if (rv instanceof StringConstant) {
            rop = resolver.typeVariable(RefType.v("java.lang.String"));
        } else if (rv instanceof ClassConstant) {
            rop = resolver.typeVariable(RefType.v("java.lang.Class"));
        } else {
            throw new RuntimeException("Unhandled binary expression right operand type: " + rv.getClass());
        }

        TypeVariable common = resolver.typeVariable();
        rop.addParent(common);
        lop.addParent(common);
    }
}
项目：JAADAS    文件：RegisterAllocator.java    
private Register asConstant(Value v, ConstantVisitor constantV) {
    Constant c = (Constant) v;

    Register constantRegister = null;

    List<Register> rArray = null;
    AtomicInteger iI = null;
    if (c instanceof ClassConstant) {
        rArray = classConstantReg;
        iI = classI;
    } else if (c instanceof NullConstant) {
           rArray = nullConstantReg;
           iI = nullI;
       } else if (c instanceof FloatConstant) {
           rArray = floatConstantReg;
           iI = floatI;
       } else if (c instanceof IntConstant) {
           rArray = intConstantReg;
           iI = intI;
       } else if (c instanceof LongConstant) {
           rArray = longConstantReg;
           iI = longI;
       } else if (c instanceof DoubleConstant) {
           rArray = doubleConstantReg;
           iI = doubleI;
       } else if (c instanceof StringConstant) {
           rArray = stringConstantReg;
           iI = stringI;
       } else {
           throw new RuntimeException("Error. Unknown constant type: '"+ c.getType() +"'");
       }

    if (rArray.size() == 0 || iI.intValue() >= rArray.size()) {
        rArray.add(new Register(c.getType(), nextRegNum));
        nextRegNum += SootToDexUtils.getDexWords(c.getType());
    }

    constantRegister = rArray.get(iI.intValue()).clone();
    iI.set(iI.intValue() + 1);

    // "load" constant into the register...
    constantV.setDestination(constantRegister);
    c.apply(constantV);
    // ...but return an independent register object
    return constantRegister.clone();
}
项目：JAADAS    文件：ConstantVisitor.java    
public void caseLongConstant(LongConstant l) {
    long constant = l.value;
       stmtV.addInsn(buildConstWideInsn(constant), origStmt);
}
项目：JAADAS    文件：UntypedLongOrDoubleConstant.java    
public LongConstant toLongConstant() {
    return LongConstant.v(value);
}
项目：JAADAS    文件：ConstInstruction.java    
/**
 * Return the literal constant for this instruction.
 *
 * @param register the register number to fill
 * @param body the body containing the instruction
 */
private Constant getConstant(int dest, DexBody body) {

    long literal = 0;

    if (instruction instanceof WideLiteralInstruction) {
        literal = ((WideLiteralInstruction)instruction).getWideLiteral();
    } else if (instruction instanceof NarrowLiteralInstruction) {
        literal = ((NarrowLiteralInstruction)instruction).getNarrowLiteral();
    } else {
        throw new RuntimeException("literal error: expected narrow or wide literal.");
    }


    // floats are handled later in DexBody by calling DexNumtransformer
    Opcode opcode = instruction.getOpcode();
    switch (opcode) {
    case CONST:
    case CONST_4:
    case CONST_16:
        if (IDalvikTyper.ENABLE_DVKTYPER) {
            return UntypedIntOrFloatConstant.v((int)literal);
        } else {
            return IntConstant.v((int) literal);
        }

    case CONST_HIGH16:
        if (IDalvikTyper.ENABLE_DVKTYPER) {
            //
            //return UntypedIntOrFloatConstant.v((int)literal<<16).toFloatConstant();
            // seems that dexlib correctly puts the 16bits into the topmost bits.
            //
            return UntypedIntOrFloatConstant.v((int)literal);//.toFloatConstant();
        } else {
            return IntConstant.v((int) literal);
        }

    case CONST_WIDE_HIGH16:
        if (IDalvikTyper.ENABLE_DVKTYPER) {
            //return UntypedLongOrDoubleConstant.v((long)literal<<48).toDoubleConstant();
            // seems that dexlib correctly puts the 16bits into the topmost bits.
            //
            return UntypedLongOrDoubleConstant.v((long)literal);//.toDoubleConstant();
        } else {
            return LongConstant.v(literal);
        }

    case CONST_WIDE:
    case CONST_WIDE_16:
    case CONST_WIDE_32:
        if (IDalvikTyper.ENABLE_DVKTYPER) {
            return UntypedLongOrDoubleConstant.v(literal);
        } else {
            return LongConstant.v(literal);
        }
    default:
        throw new IllegalArgumentException("Expected a const or a const-wide instruction, got neither.");
    }
}
项目：JAADAS    文件：CONSTANT_Long_info.java    
public Value createJimpleConstantValue(cp_info[] constant_pool) {
    return LongConstant.v(convert());
}
项目：JAADAS    文件：SimplifyExpressions.java    
public NumericConstant getResult(BinopExpr binop){
    if(DEBUG)
        System.out.println("Binop expr"+binop);
    Value leftOp = binop.getOp1();
    Value rightOp = binop.getOp2();

    int op = 0;
    if(binop instanceof AddExpr){
        op=1;
    }
    else if(binop instanceof SubExpr || 
            binop instanceof DCmpExpr || binop instanceof DCmpgExpr
            || binop instanceof DCmplExpr){
        op=2;
    }
    else if(binop instanceof MulExpr){
        op=3;
    }

    if(op == 0){
        if(DEBUG){
            System.out.println("not add sub or mult");
            System.out.println(binop.getClass().getName());
        }           
        return null;
    }
    NumericConstant constant = null;
    if(leftOp instanceof LongConstant  && rightOp instanceof LongConstant){
        if(DEBUG)
            System.out.println("long constants!!");
        if(op ==1)
            constant = ((LongConstant)leftOp).add((LongConstant)rightOp);
        else if(op ==2)
            constant = ((LongConstant)leftOp).subtract((LongConstant)rightOp);
        else if (op ==3)
            constant = ((LongConstant)leftOp).multiply((LongConstant)rightOp);
    }
    else if(leftOp instanceof DoubleConstant  && rightOp instanceof DoubleConstant){
        if(DEBUG)
            System.out.println("double constants!!");
        if(op ==1)
            constant = ((DoubleConstant)leftOp).add((DoubleConstant)rightOp);
        else if(op ==2)
            constant = ((DoubleConstant)leftOp).subtract((DoubleConstant)rightOp);
        else if (op ==3)
            constant = ((DoubleConstant)leftOp).multiply((DoubleConstant)rightOp);

    }
    else if(leftOp instanceof FloatConstant  && rightOp instanceof FloatConstant){
        if(DEBUG)
            System.out.println("Float constants!!");
        if(op ==1)
            constant = ((FloatConstant)leftOp).add((FloatConstant)rightOp);
        else if(op ==2)
            constant = ((FloatConstant)leftOp).subtract((FloatConstant)rightOp);
        else if (op ==3)
            constant = ((FloatConstant)leftOp).multiply((FloatConstant)rightOp);
    }
    else if(leftOp instanceof IntConstant  && rightOp instanceof IntConstant){
        if(DEBUG)
            System.out.println("Integer constants!!");
        if(op ==1)
            constant = ((IntConstant)leftOp).add((IntConstant)rightOp);
        else if(op ==2)
            constant = ((IntConstant)leftOp).subtract((IntConstant)rightOp);
        else if (op ==3)
            constant = ((IntConstant)leftOp).multiply((IntConstant)rightOp);
    }

    return constant;
}
项目：JAADAS    文件：UnitThrowAnalysis.java    
public void caseLongConstant(LongConstant c) {
}
项目：petablox    文件：RelLongExpr.java    
public void visit(Value e) {
    if (e instanceof LongConstant)
        add(e);
}