|
|||||||||||
PREV NEXT | FRAMES NO FRAMES |
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)
|
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 |
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)
|
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. |
|
|||||||||||
PREV NEXT | FRAMES NO FRAMES |