Uses of Interface
soot.Value

Packages that use Value
soot Base Soot classes, shared by different intermediate representations. 
soot.baf Public classes for the Baf intermediate representation. 
soot.baf.internal Internal, messy, implementation-specific classes for the Baf intermediate representation. 
soot.dava.internal.AST   
soot.dava.internal.javaRep   
soot.dava.internal.SET   
soot.dava.toolkits.base.AST   
soot.dava.toolkits.base.AST.analysis   
soot.dava.toolkits.base.AST.structuredAnalysis   
soot.dava.toolkits.base.AST.transformations   
soot.grimp Public classes for the Grimp intermediate representation. 
soot.grimp.internal Internal, messy, implementation-specific classes for the Grimp intermediate representation. 
soot.javaToJimple   
soot.jimple Public classes for the Jimple intermediate representation. 
soot.jimple.internal Internal, messy, implementation-specific classes for the Jimple intermediate representation. 
soot.jimple.spark.builder   
soot.jimple.toolkits.annotation.nullcheck Classes that carry out an analysis to determine whether or not null pointer checks are necessary. 
soot.jimple.toolkits.pointer   
soot.jimple.toolkits.scalar A toolkit for scalar optimization of Jimple. 
soot.jimple.toolkits.scalar.pre Particial redundency elimination. 
soot.shimple Public classes for the SSA Shimple intermediate representation. 
soot.shimple.internal Shimple internal messy stuff. 
soot.shimple.toolkits.graph   
soot.shimple.toolkits.scalar Some analyses based on Shimple. 
soot.toolkits.scalar A number of scalar optimizations, and the flow analysis framework. 
 

Uses of Value in soot
 

Subinterfaces of Value in soot
 interface Immediate
          A local or constant.
 interface Local
          A local variable, used within Body classes.
 

Classes in soot that implement Value
 class EquivalentValue
          Encapsulates the Value class, but uses EquivTo for equality comparisons.
 

Methods in soot that return Value
 Value AbstractValueBox.getValue()
           
 Value EquivalentValue.getDeepestValue()
          returns the deepest Value stored in this.
 Value EquivalentValue.getValue()
           
 Value IdentityUnit.getLeftOp()
           
 Value IdentityUnit.getRightOp()
           
 Value ValueBox.getValue()
          Returns the value contained in this box.
 

Methods in soot with parameters of type Value
 void AbstractValueBox.setValue(Value value)
           
 boolean EquivalentValue.equivToValue(Value v)
          compares the encapsulated value with v, using equivTo
 boolean EquivalentValue.equalsToValue(Value v)
          compares the encapsulated value with v, using equals
 boolean SideEffectTester.unitCanReadFrom(Unit u, Value v)
           
 boolean SideEffectTester.unitCanWriteTo(Unit u, Value v)
           
 void ValueBox.setValue(Value value)
          Sets the value contained in this box as given.
 boolean ValueBox.canContainValue(Value value)
          Returns true if the given Value fits in this box.
 

Constructors in soot with parameters of type Value
EquivalentValue(Value e)
           
 

Uses of Value in soot.baf
 

Methods in soot.baf that return Value
 Value IdentityInst.getLeftOp()
           
 Value IdentityInst.getRightOp()
           
 

Methods in soot.baf with parameters of type Value
 IdentityInst Baf.newIdentityInst(Value local, Value identityRef)
           
 ValueBox Baf.newLocalBox(Value value)
           
 ValueBox Baf.newIdentityRefBox(Value value)
           
 void IdentityInst.setLeftOp(Value variable)
           
 void IdentityInst.setRightOp(Value rvalue)
           
 

Uses of Value in soot.baf.internal
 

Classes in soot.baf.internal that implement Value
 class BafLocal
           
 

Methods in soot.baf.internal that return Value
 Value BIdentityInst.getLeftOp()
           
 Value BIdentityInst.getRightOp()
           
 

Methods in soot.baf.internal with parameters of type Value
 void BIdentityInst.setLeftOp(Value local)
           
 void BIdentityInst.setRightOp(Value identityRef)
           
 boolean BafLocalBox.canContainValue(Value value)
           
 

Constructors in soot.baf.internal with parameters of type Value
BIdentityInst(Value local, Value identityValue)
           
BafLocalBox(Value value)
           
 

Uses of Value in soot.dava.internal.AST
 

Methods in soot.dava.internal.AST that return Value
 Value ASTSwitchNode.get_Key()
           
 Value ASTUnaryCondition.getValue()
           
 

Methods in soot.dava.internal.AST with parameters of type Value
 void ASTSwitchNode.set_Key(Value key)
           
 

Constructors in soot.dava.internal.AST with parameters of type Value
ASTSwitchNode(SETNodeLabel label, Value key, List indexList, Map index2BodyList)
           
ASTSynchronizedBlockNode(SETNodeLabel label, List body, Value local)
           
ASTUnaryCondition(Value value)
           
 

Uses of Value in soot.dava.internal.javaRep
 

Classes in soot.dava.internal.javaRep that implement Value
 class DCmpExpr
           
 class DCmpgExpr
           
 class DCmplExpr
           
 class DInstanceFieldRef
           
 class DIntConstant
           
 class DInterfaceInvokeExpr
           
 class DLengthExpr
           
 class DNegExpr
           
 class DNewArrayExpr
           
 class DNewInvokeExpr
           
 class DNewMultiArrayExpr
           
 class DNotExpr
           
 class DSpecialInvokeExpr
           
 class DStaticFieldRef
           
 class DStaticInvokeExpr
           
 class DThisRef
           
 class DVirtualInvokeExpr
           
 

Constructors in soot.dava.internal.javaRep with parameters of type Value
DCmpExpr(Value op1, Value op2)
           
DCmpgExpr(Value op1, Value op2)
           
DCmplExpr(Value op1, Value op2)
           
DDecrementStmt(Value variable, Value rvalue)
           
DIdentityStmt(Value local, Value identityValue)
           
DIncrementStmt(Value variable, Value rvalue)
           
DInstanceFieldRef(Value base, SootFieldRef fieldRef, HashSet thisLocals)
           
DInterfaceInvokeExpr(Value base, SootMethodRef methodRef, List args)
           
DLengthExpr(Value op)
           
DNegExpr(Value op)
           
DNewArrayExpr(Type type, Value size)
           
DNotExpr(Value op)
           
DSpecialInvokeExpr(Value base, SootMethodRef methodRef, List args)
           
DVirtualInvokeExpr(Value base, SootMethodRef methodRef, List args, HashSet thisLocals)
           
 

Uses of Value in soot.dava.internal.SET
 

Constructors in soot.dava.internal.SET with parameters of type Value
SETSwitchNode(AugmentedStmt characterizingStmt, Value key, IterableSet body, List switchNodeList, IterableSet junkBody)
           
SETSynchronizedBlockNode(ExceptionNode en, Value local)
           
 

Uses of Value in soot.dava.toolkits.base.AST
 

Methods in soot.dava.toolkits.base.AST with parameters of type Value
 void ASTAnalysis.analyseValue(Value v)
           
 void ASTWalker.walk_value(ASTAnalysis a, Value v)
           
 

Uses of Value in soot.dava.toolkits.base.AST.analysis
 

Methods in soot.dava.toolkits.base.AST.analysis with parameters of type Value
 void Analysis.caseValue(Value v)
           
 void AnalysisAdapter.caseValue(Value v)
           
 void DepthFirstAdapter.decideCaseExprOrRef(Value v)
           
 void DepthFirstAdapter.inValue(Value v)
           
 void DepthFirstAdapter.outValue(Value v)
           
 void DepthFirstAdapter.caseValue(Value v)
           
 

Uses of Value in soot.dava.toolkits.base.AST.structuredAnalysis
 

Methods in soot.dava.toolkits.base.AST.structuredAnalysis with parameters of type Value
 Object MustMayInitialize.processSwitchKey(Value key, Object input)
           
 boolean MustMayInitialize.isMayInitialized(Value local)
           
 boolean MustMayInitialize.isMustInitialized(Value local)
           
 List MustMayInitialize.getDefs(Value local)
           
 Object ReachingCopies.processSwitchKey(Value key, Object input)
           
 Object ReachingDefs.processSwitchKey(Value key, Object input)
           
abstract  Object StructuredAnalysis.processSwitchKey(Value key, Object input)
          Deal with the key in the switch construct
 

Uses of Value in soot.dava.toolkits.base.AST.transformations
 

Methods in soot.dava.toolkits.base.AST.transformations with parameters of type Value
 Object DeInliningFinalFields.check(Value val)
           
 

Uses of Value in soot.grimp
 

Subinterfaces of Value in soot.grimp
 interface NewInvokeExpr
           
 

Methods in soot.grimp that return Value
 Value Grimp.newExpr(Value value)
          Carries out the mapping from other Value's to Grimp Value's
static Value Grimp.cloneIfNecessary(Value val)
           
 

Methods in soot.grimp with parameters of type Value
 XorExpr Grimp.newXorExpr(Value op1, Value op2)
          Constructs a XorExpr(Expr, Expr) grammar chunk.
 UshrExpr Grimp.newUshrExpr(Value op1, Value op2)
          Constructs a UshrExpr(Expr, Expr) grammar chunk.
 SubExpr Grimp.newSubExpr(Value op1, Value op2)
          Constructs a SubExpr(Expr, Expr) grammar chunk.
 ShrExpr Grimp.newShrExpr(Value op1, Value op2)
          Constructs a ShrExpr(Expr, Expr) grammar chunk.
 ShlExpr Grimp.newShlExpr(Value op1, Value op2)
          Constructs a ShlExpr(Expr, Expr) grammar chunk.
 RemExpr Grimp.newRemExpr(Value op1, Value op2)
          Constructs a RemExpr(Expr, Expr) grammar chunk.
 OrExpr Grimp.newOrExpr(Value op1, Value op2)
          Constructs a OrExpr(Expr, Expr) grammar chunk.
 NeExpr Grimp.newNeExpr(Value op1, Value op2)
          Constructs a NeExpr(Expr, Expr) grammar chunk.
 MulExpr Grimp.newMulExpr(Value op1, Value op2)
          Constructs a MulExpr(Expr, Expr) grammar chunk.
 LeExpr Grimp.newLeExpr(Value op1, Value op2)
          Constructs a LeExpr(Expr, Expr) grammar chunk.
 GeExpr Grimp.newGeExpr(Value op1, Value op2)
          Constructs a GeExpr(Expr, Expr) grammar chunk.
 EqExpr Grimp.newEqExpr(Value op1, Value op2)
          Constructs a EqExpr(Expr, Expr) grammar chunk.
 DivExpr Grimp.newDivExpr(Value op1, Value op2)
          Constructs a DivExpr(Expr, Expr) grammar chunk.
 CmplExpr Grimp.newCmplExpr(Value op1, Value op2)
          Constructs a CmplExpr(Expr, Expr) grammar chunk.
 CmpgExpr Grimp.newCmpgExpr(Value op1, Value op2)
          Constructs a CmpgExpr(Expr, Expr) grammar chunk.
 CmpExpr Grimp.newCmpExpr(Value op1, Value op2)
          Constructs a CmpExpr(Expr, Expr) grammar chunk.
 GtExpr Grimp.newGtExpr(Value op1, Value op2)
          Constructs a GtExpr(Expr, Expr) grammar chunk.
 LtExpr Grimp.newLtExpr(Value op1, Value op2)
          Constructs a LtExpr(Expr, Expr) grammar chunk.
 AddExpr Grimp.newAddExpr(Value op1, Value op2)
          Constructs a AddExpr(Expr, Expr) grammar chunk.
 AndExpr Grimp.newAndExpr(Value op1, Value op2)
          Constructs a AndExpr(Expr, Expr) grammar chunk.
 NegExpr Grimp.newNegExpr(Value op)
          Constructs a NegExpr(Expr, Expr) grammar chunk.
 LengthExpr Grimp.newLengthExpr(Value op)
          Constructs a LengthExpr(Expr) grammar chunk.
 CastExpr Grimp.newCastExpr(Value op1, Type t)
          Constructs a CastExpr(Expr, Type) grammar chunk.
 InstanceOfExpr Grimp.newInstanceOfExpr(Value op1, Type t)
          Constructs a InstanceOfExpr(Expr, Type) grammar chunk.
 NewArrayExpr Grimp.newNewArrayExpr(Type type, Value size)
          Constructs a NewArrayExpr(Type, Expr) grammar chunk.
 ThrowStmt Grimp.newThrowStmt(Value op)
          Constructs a ThrowStmt(Expr) grammar chunk.
 ExitMonitorStmt Grimp.newExitMonitorStmt(Value op)
          Constructs a ExitMonitorStmt(Expr) grammar chunk
 EnterMonitorStmt Grimp.newEnterMonitorStmt(Value op)
          Constructs a EnterMonitorStmt(Expr) grammar chunk.
 ReturnStmt Grimp.newReturnStmt(Value op)
          Constructs a ReturnStmt(Expr) grammar chunk.
 IfStmt Grimp.newIfStmt(Value condition, Unit target)
          Constructs a IfStmt(Condition, Stmt) grammar chunk.
 IdentityStmt Grimp.newIdentityStmt(Value local, Value identityRef)
          Constructs a IdentityStmt(Local, IdentityRef) grammar chunk.
 AssignStmt Grimp.newAssignStmt(Value variable, Value rvalue)
          Constructs a AssignStmt(Variable, RValue) grammar chunk.
 InvokeStmt Grimp.newInvokeStmt(Value op)
          Constructs a InvokeStmt(InvokeExpr) grammar chunk.
 TableSwitchStmt Grimp.newTableSwitchStmt(Value key, int lowIndex, int highIndex, List targets, Unit defaultTarget)
          Constructs a TableSwitchStmt(Expr, int, int, List of Unit, Stmt) grammar chunk.
 LookupSwitchStmt Grimp.newLookupSwitchStmt(Value key, List lookupValues, List targets, Unit defaultTarget)
          Constructs a LookupSwitchStmt(Expr, List of Expr, List of Unit, Stmt) grammar chunk.
 InstanceFieldRef Grimp.newInstanceFieldRef(Value base, SootFieldRef f)
          Constructs a InstanceFieldRef(Value, SootFieldRef) grammar chunk.
 ArrayRef Grimp.newArrayRef(Value base, Value index)
          Constructs a ArrayRef(Local, Expr) grammar chunk.
 ValueBox Grimp.newVariableBox(Value value)
           
 ValueBox Grimp.newLocalBox(Value value)
           
 ValueBox Grimp.newRValueBox(Value value)
           
 ValueBox Grimp.newImmediateBox(Value value)
           
 ValueBox Grimp.newExprBox(Value value)
           
 ValueBox Grimp.newArgBox(Value value)
           
 ValueBox Grimp.newObjExprBox(Value value)
           
 ValueBox Grimp.newIdentityRefBox(Value value)
           
 ValueBox Grimp.newConditionExprBox(Value value)
           
 ValueBox Grimp.newInvokeExprBox(Value value)
           
 Value Grimp.newExpr(Value value)
          Carries out the mapping from other Value's to Grimp Value's
static Value Grimp.cloneIfNecessary(Value val)
           
static boolean PrecedenceTest.needsBrackets(ValueBox subExprBox, Value expr)
           
static boolean PrecedenceTest.needsBracketsRight(ValueBox subExprBox, Value expr)
           
 

Uses of Value in soot.grimp.internal
 

Classes in soot.grimp.internal that implement Value
 class AbstractGrimpFloatBinopExpr
           
 class AbstractGrimpIntBinopExpr
           
 class AbstractGrimpIntLongBinopExpr
           
 class GAddExpr
           
 class GAndExpr
           
 class GArrayRef
           
 class GCastExpr
           
 class GCmpExpr
           
 class GCmpgExpr
           
 class GCmplExpr
           
 class GDivExpr
           
 class GEqExpr
           
 class GGeExpr
           
 class GGtExpr
           
 class GInstanceFieldRef
           
 class GInstanceOfExpr
           
 class GInterfaceInvokeExpr
           
 class GLeExpr
           
 class GLengthExpr
           
 class GLtExpr
           
 class GMulExpr
           
 class GNeExpr
           
 class GNegExpr
           
 class GNewArrayExpr
           
 class GNewInvokeExpr
           
 class GNewMultiArrayExpr
           
 class GOrExpr
           
 class GRemExpr
           
 class GShlExpr
           
 class GShrExpr
           
 class GSpecialInvokeExpr
           
 class GStaticInvokeExpr
           
 class GSubExpr
           
 class GUshrExpr
           
 class GVirtualInvokeExpr
           
 class GXorExpr
           
 

Methods in soot.grimp.internal with parameters of type Value
 boolean ExprBox.canContainValue(Value value)
           
 boolean GRValueBox.canContainValue(Value value)
           
 boolean ObjExprBox.canContainValue(Value value)
           
 

Constructors in soot.grimp.internal with parameters of type Value
AbstractGrimpIntBinopExpr(Value op1, Value op2)
           
ExprBox(Value value)
           
GAddExpr(Value op1, Value op2)
           
GAndExpr(Value op1, Value op2)
           
GArrayRef(Value base, Value index)
           
GAssignStmt(Value variable, Value rvalue)
           
GCastExpr(Value op, Type type)
           
GCmpExpr(Value op1, Value op2)
           
GCmpgExpr(Value op1, Value op2)
           
GCmplExpr(Value op1, Value op2)
           
GDivExpr(Value op1, Value op2)
           
GEnterMonitorStmt(Value op)
           
GEqExpr(Value op1, Value op2)
           
GExitMonitorStmt(Value op)
           
GGeExpr(Value op1, Value op2)
           
GGtExpr(Value op1, Value op2)
           
GIdentityStmt(Value local, Value identityValue)
           
GIfStmt(Value condition, Unit target)
           
GInstanceFieldRef(Value base, SootFieldRef fieldRef)
           
GInstanceOfExpr(Value op, Type checkType)
           
GInterfaceInvokeExpr(Value base, SootMethodRef methodRef, List args)
           
GInvokeStmt(Value c)
           
GLeExpr(Value op1, Value op2)
           
GLengthExpr(Value op)
           
GLookupSwitchStmt(Value key, List lookupValues, List targets, Unit defaultTarget)
           
GLtExpr(Value op1, Value op2)
           
GMulExpr(Value op1, Value op2)
           
GNeExpr(Value op1, Value op2)
           
GNegExpr(Value op)
           
GNewArrayExpr(Type type, Value size)
           
GOrExpr(Value op1, Value op2)
           
GRValueBox(Value value)
           
GRemExpr(Value op1, Value op2)
           
GReturnStmt(Value returnValue)
           
GShlExpr(Value op1, Value op2)
           
GShrExpr(Value op1, Value op2)
           
GSpecialInvokeExpr(Value base, SootMethodRef methodRef, List args)
           
GSubExpr(Value op1, Value op2)
           
GTableSwitchStmt(Value key, int lowIndex, int highIndex, List targets, Unit defaultTarget)
           
GThrowStmt(Value op)
           
GUshrExpr(Value op1, Value op2)
           
GVirtualInvokeExpr(Value base, SootMethodRef methodRef, List args)
           
GXorExpr(Value op1, Value op2)
           
ObjExprBox(Value value)
           
 

Uses of Value in soot.javaToJimple
 

Methods in soot.javaToJimple that return Value
protected  Value AbstractJimpleBodyBuilder.createExpr(polyglot.ast.Expr expr)
           
protected  Value AbstractJimpleBodyBuilder.getAssignRightLocal(polyglot.ast.Assign assign, Local leftLocal)
           
protected  Value AbstractJimpleBodyBuilder.getSimpleAssignRightLocal(polyglot.ast.Assign assign)
           
protected  Value AbstractJimpleBodyBuilder.getBaseLocal(polyglot.ast.Receiver receiver)
           
protected  Value AbstractJimpleBodyBuilder.createLHS(polyglot.ast.Expr expr)
           
protected  Value AccessFieldJBB.createExpr(polyglot.ast.Expr expr)
           
protected  Value AccessFieldJBB.createLHS(polyglot.ast.Expr expr)
           
protected  Value CommaJBB.createExpr(polyglot.ast.Expr expr)
           
protected  Value JimpleBodyBuilder.createExpr(polyglot.ast.Expr expr)
          Expression Creation
protected  Value JimpleBodyBuilder.getAssignRightLocal(polyglot.ast.Assign assign, Local leftLocal)
           
protected  Value JimpleBodyBuilder.getSimpleAssignRightLocal(polyglot.ast.Assign assign)
           
protected  Value JimpleBodyBuilder.getAssignLocal(polyglot.ast.Assign assign)
          Assign Expression Creation
protected  Value JimpleBodyBuilder.getBaseLocal(polyglot.ast.Receiver receiver)
           
protected  Value JimpleBodyBuilder.createLHS(polyglot.ast.Expr expr)
          create LHS expressions
 

Methods in soot.javaToJimple with parameters of type Value
protected  Local AbstractJimpleBodyBuilder.handlePrivateFieldSet(polyglot.ast.Expr expr, Value right, Value base)
           
protected  Local AccessFieldJBB.handlePrivateFieldSet(polyglot.ast.Expr expr, Value right, Value baseLocal)
           
protected  Local JimpleBodyBuilder.handlePrivateFieldSet(polyglot.ast.Expr expr, Value right, Value base)
           
 

Uses of Value in soot.jimple
 

Subinterfaces of Value in soot.jimple
 interface AddExpr
           
 interface AndExpr
           
 interface AnyNewExpr
          Any expression that allocates objects.
 interface ArrayRef
           
 interface BinopExpr
           
 interface CastExpr
           
 interface CaughtExceptionRef
           
 interface CmpExpr
           
 interface CmpgExpr
           
 interface CmplExpr
           
 interface ConcreteRef
           
 interface ConditionExpr
           
 interface DivExpr
           
 interface EqExpr
           
 interface Expr
           
 interface FieldRef
           
 interface GeExpr
           
 interface GtExpr
           
 interface IdentityRef
           
 interface InstanceFieldRef
           
 interface InstanceInvokeExpr
           
 interface InstanceOfExpr
           
 interface InterfaceInvokeExpr
           
 interface InvokeExpr
           
 interface LeExpr
           
 interface LengthExpr
           
 interface LtExpr
           
 interface MulExpr
           
 interface NeExpr
           
 interface NegExpr
           
 interface NewArrayExpr
           
 interface NewExpr
           
 interface NewMultiArrayExpr
           
 interface OrExpr
           
 interface Ref
           
 interface RemExpr
           
 interface ShlExpr
           
 interface ShrExpr
           
 interface SpecialInvokeExpr
           
 interface StaticInvokeExpr
           
 interface SubExpr
           
 interface UnopExpr
           
 interface UshrExpr
           
 interface VirtualInvokeExpr
           
 interface XorExpr
           
 

Classes in soot.jimple that implement Value
 class ArithmeticConstant
           
 class ClassConstant
           
 class Constant
           
 class DoubleConstant
           
 class FloatConstant
           
 class IntConstant
           
 class LongConstant
           
 class NullConstant
           
 class NumericConstant
           
 class ParameterRef
          ParameterRef objects are used by Body objects to refer to the parameter slots on method entry.
 class RealConstant
           
 class StaticFieldRef
           
 class StringConstant
           
 class ThisRef
           
 

Methods in soot.jimple that return Value
 Value ArrayRef.getBase()
           
 Value ArrayRef.getIndex()
           
 Value BinopExpr.getOp1()
           
 Value BinopExpr.getOp2()
           
 Value CastExpr.getOp()
           
 Value DefinitionStmt.getLeftOp()
           
 Value DefinitionStmt.getRightOp()
           
 Value EnterMonitorStmt.getOp()
           
 Value ExitMonitorStmt.getOp()
           
 Value IfStmt.getCondition()
           
 Value InstanceFieldRef.getBase()
           
 Value InstanceInvokeExpr.getBase()
           
 Value InstanceOfExpr.getOp()
           
 Value InvokeExpr.getArg(int index)
           
static Value Jimple.cloneIfNecessary(Value val)
           
 Value LookupSwitchStmt.getKey()
           
 Value MonitorStmt.getOp()
           
 Value NewArrayExpr.getSize()
           
 Value NewMultiArrayExpr.getSize(int index)
           
 Value RetStmt.getStmtAddress()
           
 Value ReturnStmt.getOp()
           
 Value TableSwitchStmt.getKey()
           
 Value ThrowStmt.getOp()
           
 Value UnopExpr.getOp()
           
 

Methods in soot.jimple with parameters of type Value
 void ArrayRef.setIndex(Value index)
           
 void AssignStmt.setLeftOp(Value variable)
           
 void AssignStmt.setRightOp(Value rvalue)
           
 void BinopExpr.setOp1(Value op1)
           
 void BinopExpr.setOp2(Value op2)
           
 void CastExpr.setOp(Value op)
           
 void EnterMonitorStmt.setOp(Value op)
           
 void ExitMonitorStmt.setOp(Value op)
           
 void IfStmt.setCondition(Value condition)
          condition must be soot.jimple.ConditionExpr
 void InstanceFieldRef.setBase(Value base)
           
 void InstanceInvokeExpr.setBase(Value base)
           
 void InstanceOfExpr.setOp(Value op)
           
 void InvokeExpr.setArg(int index, Value arg)
           
 void InvokeStmt.setInvokeExpr(Value invokeExpr)
           
static Value Jimple.cloneIfNecessary(Value val)
           
 XorExpr Jimple.newXorExpr(Value op1, Value op2)
          Constructs a XorExpr(Immediate, Immediate) grammar chunk.
 UshrExpr Jimple.newUshrExpr(Value op1, Value op2)
          Constructs a UshrExpr(Immediate, Immediate) grammar chunk.
 SubExpr Jimple.newSubExpr(Value op1, Value op2)
          Constructs a SubExpr(Immediate, Immediate) grammar chunk.
 ShrExpr Jimple.newShrExpr(Value op1, Value op2)
          Constructs a ShrExpr(Immediate, Immediate) grammar chunk.
 ShlExpr Jimple.newShlExpr(Value op1, Value op2)
          Constructs a ShlExpr(Immediate, Immediate) grammar chunk.
 RemExpr Jimple.newRemExpr(Value op1, Value op2)
          Constructs a RemExpr(Immediate, Immediate) grammar chunk.
 OrExpr Jimple.newOrExpr(Value op1, Value op2)
          Constructs a OrExpr(Immediate, Immediate) grammar chunk.
 NeExpr Jimple.newNeExpr(Value op1, Value op2)
          Constructs a NeExpr(Immediate, Immediate) grammar chunk.
 MulExpr Jimple.newMulExpr(Value op1, Value op2)
          Constructs a MulExpr(Immediate, Immediate) grammar chunk.
 LeExpr Jimple.newLeExpr(Value op1, Value op2)
          Constructs a LeExpr(Immediate, Immediate) grammar chunk.
 GeExpr Jimple.newGeExpr(Value op1, Value op2)
          Constructs a GeExpr(Immediate, Immediate) grammar chunk.
 EqExpr Jimple.newEqExpr(Value op1, Value op2)
          Constructs a EqExpr(Immediate, Immediate) grammar chunk.
 DivExpr Jimple.newDivExpr(Value op1, Value op2)
          Constructs a DivExpr(Immediate, Immediate) grammar chunk.
 CmplExpr Jimple.newCmplExpr(Value op1, Value op2)
          Constructs a CmplExpr(Immediate, Immediate) grammar chunk.
 CmpgExpr Jimple.newCmpgExpr(Value op1, Value op2)
          Constructs a CmpgExpr(Immediate, Immediate) grammar chunk.
 CmpExpr Jimple.newCmpExpr(Value op1, Value op2)
          Constructs a CmpExpr(Immediate, Immediate) grammar chunk.
 GtExpr Jimple.newGtExpr(Value op1, Value op2)
          Constructs a GtExpr(Immediate, Immediate) grammar chunk.
 LtExpr Jimple.newLtExpr(Value op1, Value op2)
          Constructs a LtExpr(Immediate, Immediate) grammar chunk.
 AddExpr Jimple.newAddExpr(Value op1, Value op2)
          Constructs a AddExpr(Immediate, Immediate) grammar chunk.
 AndExpr Jimple.newAndExpr(Value op1, Value op2)
          Constructs a AndExpr(Immediate, Immediate) grammar chunk.
 NegExpr Jimple.newNegExpr(Value op)
          Constructs a NegExpr(Immediate, Immediate) grammar chunk.
 LengthExpr Jimple.newLengthExpr(Value op)
          Constructs a LengthExpr(Immediate) grammar chunk.
 CastExpr Jimple.newCastExpr(Value op1, Type t)
          Constructs a CastExpr(Immediate, Type) grammar chunk.
 InstanceOfExpr Jimple.newInstanceOfExpr(Value op1, Type t)
          Constructs a InstanceOfExpr(Immediate, Type) grammar chunk.
 NewArrayExpr Jimple.newNewArrayExpr(Type type, Value size)
          Constructs a NewArrayExpr(Type, Immediate) grammar chunk.
 StaticInvokeExpr Jimple.newStaticInvokeExpr(SootMethodRef method, Value arg)
          Constructs a NewStaticInvokeExpr(ArrayType, List of Immediate) grammar chunk.
 SpecialInvokeExpr Jimple.newSpecialInvokeExpr(Local base, SootMethodRef method, Value arg)
          Constructs a NewSpecialInvokeExpr(Local base, SootMethodRef method, List of Immediate) grammar chunk.
 VirtualInvokeExpr Jimple.newVirtualInvokeExpr(Local base, SootMethodRef method, Value arg)
          Constructs a NewVirtualInvokeExpr(Local base, SootMethodRef method, List of Immediate) grammar chunk.
 InterfaceInvokeExpr Jimple.newInterfaceInvokeExpr(Local base, SootMethodRef method, Value arg)
          Constructs a NewInterfaceInvokeExpr(Local base, SootMethodRef method, List of Immediate) grammar chunk.
 StaticInvokeExpr Jimple.newStaticInvokeExpr(SootMethodRef method, Value arg1, Value arg2)
          Constructs a NewStaticInvokeExpr(ArrayType, List of Immediate) grammar chunk.
 SpecialInvokeExpr Jimple.newSpecialInvokeExpr(Local base, SootMethodRef method, Value arg1, Value arg2)
          Constructs a NewSpecialInvokeExpr(Local base, SootMethodRef method, List of Immediate) grammar chunk.
 VirtualInvokeExpr Jimple.newVirtualInvokeExpr(Local base, SootMethodRef method, Value arg1, Value arg2)
          Constructs a NewVirtualInvokeExpr(Local base, SootMethodRef method, List of Immediate) grammar chunk.
 InterfaceInvokeExpr Jimple.newInterfaceInvokeExpr(Local base, SootMethodRef method, Value arg1, Value arg2)
          Constructs a NewInterfaceInvokeExpr(Local base, SootMethodRef method, List of Immediate) grammar chunk.
 ThrowStmt Jimple.newThrowStmt(Value op)
          Constructs a ThrowStmt(Immediate) grammar chunk.
 ExitMonitorStmt Jimple.newExitMonitorStmt(Value op)
          Constructs a ExitMonitorStmt(Immediate) grammar chunk
 EnterMonitorStmt Jimple.newEnterMonitorStmt(Value op)
          Constructs a EnterMonitorStmt(Immediate) grammar chunk.
 ReturnStmt Jimple.newReturnStmt(Value op)
          Constructs a ReturnStmt(Immediate) grammar chunk.
 RetStmt Jimple.newRetStmt(Value stmtAddress)
          Constructs a RetStmt(Local) grammar chunk.
 IfStmt Jimple.newIfStmt(Value condition, Unit target)
          Constructs a IfStmt(Condition, Stmt) grammar chunk.
 IfStmt Jimple.newIfStmt(Value condition, UnitBox target)
           
 IdentityStmt Jimple.newIdentityStmt(Value local, Value identityRef)
          Constructs a IdentityStmt(Local, IdentityRef) grammar chunk.
 AssignStmt Jimple.newAssignStmt(Value variable, Value rvalue)
          Constructs a AssignStmt(Variable, RValue) grammar chunk.
 InvokeStmt Jimple.newInvokeStmt(Value op)
          Constructs a InvokeStmt(InvokeExpr) grammar chunk.
 TableSwitchStmt Jimple.newTableSwitchStmt(Value key, int lowIndex, int highIndex, List targets, Unit defaultTarget)
          Constructs a TableSwitchStmt(Immediate, int, int, List of Unit, Stmt) grammar chunk.
 TableSwitchStmt Jimple.newTableSwitchStmt(Value key, int lowIndex, int highIndex, List targets, UnitBox defaultTarget)
           
 LookupSwitchStmt Jimple.newLookupSwitchStmt(Value key, List lookupValues, List targets, Unit defaultTarget)
          Constructs a LookupSwitchStmt(Immediate, List of Immediate, List of Unit, Stmt) grammar chunk.
 LookupSwitchStmt Jimple.newLookupSwitchStmt(Value key, List lookupValues, List targets, UnitBox defaultTarget)
           
 InstanceFieldRef Jimple.newInstanceFieldRef(Value base, SootFieldRef f)
          Constructs a InstanceFieldRef(Local, SootFieldRef) grammar chunk.
 ArrayRef Jimple.newArrayRef(Value base, Value index)
          Constructs a ArrayRef(Local, Immediate) grammar chunk.
 ValueBox Jimple.newVariableBox(Value value)
           
 ValueBox Jimple.newLocalBox(Value value)
           
 ValueBox Jimple.newRValueBox(Value value)
           
 ValueBox Jimple.newImmediateBox(Value value)
           
 ValueBox Jimple.newArgBox(Value value)
           
 ValueBox Jimple.newIdentityRefBox(Value value)
           
 ValueBox Jimple.newConditionExprBox(Value value)
           
 ValueBox Jimple.newInvokeExprBox(Value value)
           
 void LookupSwitchStmt.setKey(Value key)
           
 void MonitorStmt.setOp(Value op)
           
 boolean NaiveSideEffectTester.unitCanReadFrom(Unit u, Value v)
          Returns true if the unit can read from v.
 boolean NaiveSideEffectTester.unitCanWriteTo(Unit u, Value v)
           
 void NewArrayExpr.setSize(Value size)
           
 void NewMultiArrayExpr.setSize(int index, Value size)
           
protected abstract  void PointerStmtSwitch.caseAssignConstStmt(Value dest, Constant c)
          A statement of the form l = constant;
 void RetStmt.setStmtAddress(Value stmtAddress)
           
 void ReturnStmt.setOp(Value returnValue)
           
 void TableSwitchStmt.setKey(Value key)
           
 void ThrowStmt.setOp(Value op)
           
 void UnopExpr.setOp(Value op)
           
 

Uses of Value in soot.jimple.internal
 

Classes in soot.jimple.internal that implement Value
 class AbstractBinopExpr
           
 class AbstractCastExpr
           
 class AbstractFloatBinopExpr
           
 class AbstractInstanceFieldRef
           
 class AbstractInstanceInvokeExpr
           
 class AbstractInstanceOfExpr
           
 class AbstractIntBinopExpr
           
 class AbstractInterfaceInvokeExpr
           
 class AbstractIntLongBinopExpr
           
 class AbstractInvokeExpr
           
 class AbstractJimpleBinopExpr
           
 class AbstractJimpleFloatBinopExpr
           
 class AbstractJimpleIntBinopExpr
           
 class AbstractJimpleIntLongBinopExpr
           
 class AbstractLengthExpr
           
 class AbstractNegExpr
           
 class AbstractNewArrayExpr
           
 class AbstractNewExpr
           
 class AbstractNewMultiArrayExpr
           
 class AbstractSpecialInvokeExpr
           
 class AbstractStaticInvokeExpr
           
 class AbstractUnopExpr
           
 class AbstractVirtualInvokeExpr
           
 class JAddExpr
           
 class JAndExpr
           
 class JArrayRef
           
 class JCastExpr
           
 class JCaughtExceptionRef
           
 class JCmpExpr
           
 class JCmpgExpr
           
 class JCmplExpr
           
 class JDivExpr
           
 class JEqExpr
           
 class JGeExpr
           
 class JGtExpr
           
 class JimpleLocal
           
 class JInstanceFieldRef
           
 class JInstanceOfExpr
           
 class JInterfaceInvokeExpr
           
 class JLeExpr
           
 class JLengthExpr
           
 class JLtExpr
           
 class JMulExpr
           
 class JNeExpr
           
 class JNegExpr
           
 class JNewArrayExpr
           
 class JNewExpr
           
 class JNewMultiArrayExpr
           
 class JOrExpr
           
 class JRemExpr
           
 class JShlExpr
           
 class JShrExpr
           
 class JSpecialInvokeExpr
           
 class JStaticInvokeExpr
           
 class JSubExpr
           
 class JUshrExpr
           
 class JVirtualInvokeExpr
           
 class JXorExpr
           
 

Methods in soot.jimple.internal that return Value
 Value AbstractBinopExpr.getOp1()
           
 Value AbstractBinopExpr.getOp2()
           
 Value AbstractCastExpr.getOp()
           
 Value AbstractDefinitionStmt.getLeftOp()
           
 Value AbstractDefinitionStmt.getRightOp()
           
 Value AbstractInstanceFieldRef.getBase()
           
 Value AbstractInstanceInvokeExpr.getBase()
           
 Value AbstractInstanceOfExpr.getOp()
           
 Value AbstractInvokeExpr.getArg(int index)
           
 Value AbstractNewArrayExpr.getSize()
           
 Value AbstractNewMultiArrayExpr.getSize(int index)
           
 Value AbstractUnopExpr.getOp()
           
 Value JArrayRef.getBase()
           
 Value JArrayRef.getIndex()
           
 Value JEnterMonitorStmt.getOp()
           
 Value JExitMonitorStmt.getOp()
           
 Value JIfStmt.getCondition()
           
 Value JLookupSwitchStmt.getKey()
           
 Value JRetStmt.getStmtAddress()
           
 Value JReturnStmt.getOp()
           
 Value JTableSwitchStmt.getKey()
           
 Value JThrowStmt.getOp()
           
 

Methods in soot.jimple.internal with parameters of type Value
 void AbstractBinopExpr.setOp1(Value op1)
           
 void AbstractBinopExpr.setOp2(Value op2)
           
 void AbstractCastExpr.setOp(Value op)
           
 void AbstractInstanceFieldRef.setBase(Value base)
           
 void AbstractInstanceInvokeExpr.setBase(Value base)
           
 void AbstractInstanceOfExpr.setOp(Value op)
           
 void AbstractInvokeExpr.setArg(int index, Value arg)
           
 void AbstractNewArrayExpr.setSize(Value size)
           
 void AbstractNewMultiArrayExpr.setSize(int index, Value size)
           
 void AbstractUnopExpr.setOp(Value op)
           
 boolean ConditionExprBox.canContainValue(Value value)
           
 boolean IdentityRefBox.canContainValue(Value value)
           
 boolean ImmediateBox.canContainValue(Value value)
           
 boolean InvokeExprBox.canContainValue(Value value)
           
 void JArrayRef.setIndex(Value index)
           
 void JAssignStmt.setLeftOp(Value variable)
           
 void JAssignStmt.setRightOp(Value rvalue)
           
 void JEnterMonitorStmt.setOp(Value op)
           
 void JExitMonitorStmt.setOp(Value op)
           
 void JIdentityStmt.setLeftOp(Value local)
           
 void JIdentityStmt.setRightOp(Value identityRef)
           
 void JIfStmt.setCondition(Value condition)
           
 void JInvokeStmt.setInvokeExpr(Value invokeExpr)
           
 void JLookupSwitchStmt.setKey(Value key)
           
 void JRetStmt.setStmtAddress(Value stmtAddress)
           
 void JReturnStmt.setOp(Value returnValue)
           
 void JTableSwitchStmt.setKey(Value key)
           
 void JThrowStmt.setOp(Value op)
           
 boolean JimpleLocalBox.canContainValue(Value value)
           
 boolean RValueBox.canContainValue(Value value)
           
 boolean VariableBox.canContainValue(Value value)
           
 

Constructors in soot.jimple.internal with parameters of type Value
AbstractJimpleBinopExpr(Value op1, Value op2)
           
AbstractJimpleIntBinopExpr(Value op1, Value op2)
           
AbstractJimpleIntLongBinopExpr(Value op1, Value op2)
           
ConditionExprBox(Value value)
           
IdentityRefBox(Value value)
           
ImmediateBox(Value value)
           
InvokeExprBox(Value value)
           
JAddExpr(Value op1, Value op2)
           
JAndExpr(Value op1, Value op2)
           
JArrayRef(Value base, Value index)
           
JAssignStmt(Value variable, Value rvalue)
           
JCastExpr(Value op, Type type)
           
JCmpExpr(Value op1, Value op2)
           
JCmpgExpr(Value op1, Value op2)
           
JCmplExpr(Value op1, Value op2)
           
JDivExpr(Value op1, Value op2)
           
JEnterMonitorStmt(Value op)
           
JEqExpr(Value op1, Value op2)
           
JExitMonitorStmt(Value op)
           
JGeExpr(Value op1, Value op2)
           
JGtExpr(Value op1, Value op2)
           
JIdentityStmt(Value local, Value identityValue)
           
JIfStmt(Value condition, Unit target)
           
JIfStmt(Value condition, UnitBox target)
           
JInstanceFieldRef(Value base, SootFieldRef fieldRef)
           
JInstanceOfExpr(Value op, Type checkType)
           
JInterfaceInvokeExpr(Value base, SootMethodRef methodRef, List args)
           
JInvokeStmt(Value c)
           
JLeExpr(Value op1, Value op2)
           
JLengthExpr(Value op)
           
JLookupSwitchStmt(Value key, List lookupValues, List targets, Unit defaultTarget)
          Constructs a new JLookupSwitchStmt.
JLookupSwitchStmt(Value key, List lookupValues, List targets, UnitBox defaultTarget)
          Constructs a new JLookupSwitchStmt.
JLtExpr(Value op1, Value op2)
           
JMulExpr(Value op1, Value op2)
           
JNeExpr(Value op1, Value op2)
           
JNegExpr(Value op)
           
JNewArrayExpr(Type type, Value size)
           
JOrExpr(Value op1, Value op2)
           
JRemExpr(Value op1, Value op2)
           
JRetStmt(Value stmtAddress)
           
JReturnStmt(Value returnValue)
           
JShlExpr(Value op1, Value op2)
           
JShrExpr(Value op1, Value op2)
           
JSubExpr(Value op1, Value op2)
           
JTableSwitchStmt(Value key, int lowIndex, int highIndex, List targets, Unit defaultTarget)
           
JTableSwitchStmt(Value key, int lowIndex, int highIndex, List targets, UnitBox defaultTarget)
           
JThrowStmt(Value op)
           
JUshrExpr(Value op1, Value op2)
           
JVirtualInvokeExpr(Value base, SootMethodRef methodRef, List args)
           
JXorExpr(Value op1, Value op2)
           
JimpleLocalBox(Value value)
           
RValueBox(Value value)
           
VariableBox(Value value)
           
 

Uses of Value in soot.jimple.spark.builder
 

Methods in soot.jimple.spark.builder with parameters of type Value
 Node MethodNodeFactory.getNode(Value v)
           
 

Uses of Value in soot.jimple.toolkits.annotation.nullcheck
 

Methods in soot.jimple.toolkits.annotation.nullcheck with parameters of type Value
 EquivalentValue BranchedRefVarsAnalysis.getEquivalentValue(Value v)
           
protected  boolean BranchedRefVarsAnalysis.isAlwaysNonNull(Value ro)
           
protected  int BranchedRefVarsAnalysis.refInfo(Value r, FlowSet fs)
           
 int BranchedRefVarsAnalysis.anyRefInfo(Value r, FlowSet f)
           
 

Uses of Value in soot.jimple.toolkits.pointer
 

Methods in soot.jimple.toolkits.pointer with parameters of type Value
 boolean PASideEffectTester.unitCanReadFrom(Unit u, Value v)
          Returns true if the unit can read from v.
 boolean PASideEffectTester.unitCanWriteTo(Unit u, Value v)
          Returns true if the unit can read from v.
protected  boolean PASideEffectTester.valueTouchesRWSet(RWSet s, Value v, List boxes)
           
protected  RWSet SideEffectAnalysis.addValue(Value v, SootMethod m, Stmt s)
           
 

Uses of Value in soot.jimple.toolkits.scalar
 

Methods in soot.jimple.toolkits.scalar that return Value
static Value Evaluator.getConstantValueOf(Value op)
          Returns the constant value of op if it is easy to find the constant value; else returns null.
 

Methods in soot.jimple.toolkits.scalar with parameters of type Value
static boolean Evaluator.isValueConstantValued(Value op)
           
static Value Evaluator.getConstantValueOf(Value op)
          Returns the constant value of op if it is easy to find the constant value; else returns null.
 

Uses of Value in soot.jimple.toolkits.scalar.pre
 

Methods in soot.jimple.toolkits.scalar.pre that return Value
static Value SootFilter.rhs(Unit unit)
          filters out the RHS of an assignmentStmt.
static Value SootFilter.binop(Value val)
          only lets binary expression through.
static Value SootFilter.binopRhs(Unit unit)
          only lets binary RHS through.
static Value SootFilter.concreteRef(Value val)
          only lets concrete references through.
static Value SootFilter.noExceptionThrowing(Value val)
          filters out Exception-throwing Values.
static Value SootFilter.noExceptionThrowingRhs(Unit unit)
          filters out RHS that don't throw any exception.
static Value SootFilter.noInvokeRhs(Unit unit)
          filters out RHS that aren't invokes.
static Value SootFilter.noInvoke(Value val)
          filters out Invokes.
returns null if val is null.
static Value SootFilter.local(Value val)
          filters out Locals.
returns null if val is null.
static Value SootFilter.noLocal(Value val)
          only lets non-Locals through.
returns null if val is null.
static Value SootFilter.getEquivalentValueRoot(Value val)
          returns the Value of an EquivalentValue.
 

Methods in soot.jimple.toolkits.scalar.pre with parameters of type Value
static EquivalentValue SootFilter.equiVal(Value val)
          wraps a value into a EquivalentValue.
static Value SootFilter.binop(Value val)
          only lets binary expression through.
static Value SootFilter.concreteRef(Value val)
          only lets concrete references through.
static Value SootFilter.noExceptionThrowing(Value val)
          filters out Exception-throwing Values.
static Value SootFilter.noInvoke(Value val)
          filters out Invokes.
returns null if val is null.
static boolean SootFilter.isInvoke(Value val)
          returns true, if val is an invoke.
static Value SootFilter.local(Value val)
          filters out Locals.
returns null if val is null.
static Value SootFilter.noLocal(Value val)
          only lets non-Locals through.
returns null if val is null.
static boolean SootFilter.isLocal(Value val)
          returns true, if val is a Local.
static Value SootFilter.getEquivalentValueRoot(Value val)
          returns the Value of an EquivalentValue.
static boolean SootFilter.throwsException(Value val)
          a (probably) conservative way of telling, if a Value throws an exception or not.
 

Uses of Value in soot.shimple
 

Subinterfaces of Value in soot.shimple
 interface PhiExpr
          A fully defined PhiExpr usually consists of a list of Values for the arguments alongst with the corresponding control flow predecessor for each argument.
 interface PiExpr
           
 interface ShimpleExpr
           
 

Methods in soot.shimple that return Value
 Value PhiExpr.getValue(int index)
          Returns the value for the given index into the PhiExpr.
 Value PhiExpr.getValue(Unit predTailUnit)
          Get the PhiExpr argument corresponding to the given control flow predecessor, returns null if not available.
 Value PhiExpr.getValue(Block pred)
          Get the PhiExpr argument corresponding to the given control flow predecessor, returns null if not available.
 Value PiExpr.getValue()
           
 

Methods in soot.shimple with parameters of type Value
 boolean PhiExpr.setArg(int index, Value arg, Unit predTailUnit)
          Modify the PhiExpr argument at the given index with the given information.
 boolean PhiExpr.setArg(int index, Value arg, Block pred)
          Modify the PhiExpr argument at the given index with the given information.
 boolean PhiExpr.setValue(int index, Value arg)
          Set the value at the given index into the PhiExpr.
 boolean PhiExpr.setValue(Unit predTailUnit, Value arg)
          Locate the argument assocatiated with the given CFG predecessor unit and set the value.
 boolean PhiExpr.setValue(Block pred, Value arg)
          Locate the argument assocatiated with the given CFG predecessor and set the value.
 boolean PhiExpr.addArg(Value arg, Block pred)
          Add the given argument associated with the given CFG predecessor.
 boolean PhiExpr.addArg(Value arg, Unit predTailUnit)
          Add the given argument associated with the given CFG predecessor.
 void PiExpr.setValue(Value v)
           
static boolean Shimple.isPhiExpr(Value value)
          Returns true if the value is a Phi expression, false otherwise.
static boolean Shimple.isPiExpr(Value value)
           
 

Uses of Value in soot.shimple.internal
 

Classes in soot.shimple.internal that implement Value
 class SPhiExpr
          Internal implementation of Phi nodes.
 class SPiExpr
           
 

Methods in soot.shimple.internal that return Value
 Value SPhiExpr.getValue(int index)
           
 Value SPhiExpr.getValue(Unit predTailUnit)
           
 Value SPhiExpr.getValue(Block pred)
           
 Value SPiExpr.getValue()
           
 

Methods in soot.shimple.internal with parameters of type Value
 boolean SPhiExpr.setArg(int index, Value arg, Unit predTailUnit)
           
 boolean SPhiExpr.setArg(int index, Value arg, Block pred)
           
 boolean SPhiExpr.setValue(int index, Value arg)
           
 boolean SPhiExpr.setValue(Unit predTailUnit, Value arg)
           
 boolean SPhiExpr.setValue(Block pred, Value arg)
           
 boolean SPhiExpr.addArg(Value arg, Block pred)
           
 boolean SPhiExpr.addArg(Value arg, Unit predTailUnit)
           
 void SPiExpr.setValue(Value value)
           
protected  int ShimpleBodyBuilder.indexOfLocal(Value local)
          Convenient function that maps new Locals to the originating Local, and finds the appropriate array index into the naming structures.
 

Constructors in soot.shimple.internal with parameters of type Value
SPiExpr(Value v, Unit u, Object o)
           
SValueUnitPair(Value value, Unit unit)
           
 

Uses of Value in soot.shimple.toolkits.graph
 

Classes in soot.shimple.toolkits.graph that implement Value
protected static class ValueGraph.TypeValueWrapper
           
 

Fields in soot.shimple.toolkits.graph declared as Value
protected  Value ValueGraph.Node.node
           
 

Methods in soot.shimple.toolkits.graph with parameters of type Value
protected  ValueGraph.Node ValueGraph.fetchNode(Value value)
           
protected  ValueGraph.Node ValueGraph.fetchGraph(Value value)
           
 ValueGraph.Node ValueGraph.getNode(Value local)
           
protected  void ValueGraph.Node.setNode(Value node)
           
 

Constructors in soot.shimple.toolkits.graph with parameters of type Value
ValueGraph.Node(Value local, boolean ignored)
           
ValueGraph.Node(Value node)
           
ValueGraph.Node(Value node, boolean ordered, List children)
           
 

Uses of Value in soot.shimple.toolkits.scalar
 

Classes in soot.shimple.toolkits.scalar that implement Value
static class SEvaluator.BottomConstant
          Bottom i.e.
static class SEvaluator.MetaConstant
          Head of a new hierarchy of constants -- Top and Bottom.
static class SEvaluator.TopConstant
          Top i.e.
 

Methods in soot.shimple.toolkits.scalar that return Value
static Value SEvaluator.getConstantValueOf(Value op)
          Returns the constant value of op if it is easy to find the constant value; else returns null.
 

Methods in soot.shimple.toolkits.scalar with parameters of type Value
static boolean SEvaluator.isValueConstantValued(Value op)
          Returns true if given value is determined to be constant valued, false otherwise
static Value SEvaluator.getConstantValueOf(Value op)
          Returns the constant value of op if it is easy to find the constant value; else returns null.
static Constant SEvaluator.getFuzzyConstantValueOf(Value v)
          If a normal expression contains Bottom, always return Bottom.
static Constant SEvaluator.getFuzzyConstantValueOf(Value v, Map localToConstant)
          Get the constant value of the expression given the assumptions in the localToConstant map (may contain Top and Bottom).
 

Uses of Value in soot.toolkits.scalar
 

Methods in soot.toolkits.scalar with parameters of type Value
 boolean ValueUnitPair.canContainValue(Value value)
           
 

Constructors in soot.toolkits.scalar with parameters of type Value
ValueUnitPair(Value value, Unit unit)
          Constructs a ValueUnitPair from a Unit object and a Value object.