Java LongConstant类代码示例

import soot.jimple.LongConstant; //导入依赖的package包/类
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);
}
 

import soot.jimple.LongConstant; //导入依赖的package包/类
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();
}
 

import soot.jimple.LongConstant; //导入依赖的package包/类
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;
}
 

import soot.jimple.LongConstant; //导入依赖的package包/类
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)));
   }
 

import soot.jimple.LongConstant; //导入依赖的package包/类
/**
 * 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;
}
 

import soot.jimple.LongConstant; //导入依赖的package包/类
@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);
			}
		}
	}
}
 

import soot.jimple.LongConstant; //导入依赖的package包/类
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;
}
 

import soot.jimple.LongConstant; //导入依赖的package包/类
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;
}
 

import soot.jimple.LongConstant; //导入依赖的package包/类
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;
}
 

import soot.jimple.LongConstant; //导入依赖的package包/类
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);
}
 

import soot.jimple.LongConstant; //导入依赖的package包/类
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);
}
 

import soot.jimple.LongConstant; //导入依赖的package包/类
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)));
   }
 

import soot.jimple.LongConstant; //导入依赖的package包/类
/**
 * 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;
}
 

import soot.jimple.LongConstant; //导入依赖的package包/类
/**
 * 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;
}
 

import soot.jimple.LongConstant; //导入依赖的package包/类
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);
	}
}