Uses of Class
soot.Body

Packages that use Body

Package	Description
soot	Base Soot classes, shared by different intermediate representations.
soot.asm
soot.baf	Public classes for the Baf intermediate representation.
soot.baf.toolkits.base	A toolkit to optimize the Baf IR.
soot.dava
soot.dava.internal.AST
soot.dexpler
soot.dexpler.instructions
soot.dexpler.typing
soot.dotnet.instructions
soot.dotnet.members
soot.dotnet.members.method
soot.grimp	Public classes for the Grimp intermediate representation.
soot.grimp.toolkits.base	A toolkit to optimize the Grimp IR.
soot.javaToJimple
soot.javaToJimple.toolkits
soot.jbco
soot.jbco.bafTransformations
soot.jbco.jimpleTransformations
soot.jbco.util
soot.jimple	Public classes for the Jimple intermediate representation.
soot.jimple.parser	An interface to the Jimple parser.
soot.jimple.spark.fieldrw
soot.jimple.toolkits.annotation	A toolkit to annotate classfiles with array and null bounds check information.
soot.jimple.toolkits.annotation.arraycheck	Classes that carry out an analysis to determine whether or not array bounds checks are necessary.
soot.jimple.toolkits.annotation.callgraph
soot.jimple.toolkits.annotation.defs
soot.jimple.toolkits.annotation.liveness
soot.jimple.toolkits.annotation.logic
soot.jimple.toolkits.annotation.nullcheck	Classes that carry out an analysis to determine whether or not null pointer checks are necessary.
soot.jimple.toolkits.annotation.parity
soot.jimple.toolkits.annotation.profiling
soot.jimple.toolkits.base	A toolkit to optimize the Jimple IR.
soot.jimple.toolkits.callgraph
soot.jimple.toolkits.graph	A set of utility classes for program transformation and optimizations.
soot.jimple.toolkits.ide.icfg
soot.jimple.toolkits.invoke	A toolkit to deal with Jimple and invoke statements.
soot.jimple.toolkits.pointer
soot.jimple.toolkits.scalar	A toolkit for scalar optimization of Jimple.
soot.jimple.toolkits.scalar.pre	Particial redundency elimination.
soot.jimple.toolkits.thread.mhp
soot.jimple.toolkits.thread.synchronization
soot.jimple.toolkits.typing	Implements a typing algorithm for Jimple.
soot.jimple.validation
soot.shimple	Public classes for the SSA Shimple intermediate representation.
soot.shimple.internal	Shimple internal messy stuff.
soot.shimple.toolkits.scalar	Some analyses based on Shimple.
soot.tagkit	Classes supporting classfile annotation in Soot.
soot.toDex
soot.toolkits.exceptions
soot.toolkits.graph	Toolkit to produce and manipulate various types of control flow graphs.
soot.toolkits.graph.interaction
soot.toolkits.graph.pdg
soot.toolkits.scalar	A number of scalar optimizations, and the flow analysis framework.
soot.tools	Various extensions to Soot that can be executed instead of soot.Main.
soot.util	Generally useful utility classes for Soot.
soot.util.cfgcmd
soot.validation
soot.xml

Uses of Body in soot

Fields in soot declared as Body

Modifier and Type	Field	Description
protected Body	SootMethod.activeBody	Active body associated with this method.

Methods in soot that return Body

Modifier and Type	Method	Description
Body	SootMethod.getActiveBody()	Retrieves the active body for this method.
Body	MethodSource.getBody(SootMethod m, String phaseName)	Returns a filled-out body for the given SootMethod.
Body	UnknownMethodSource.getBody(SootMethod m, String phaseName)
Body	SootMethod.retrieveActiveBody()	Returns the active body if present, else constructs an active body and returns that.
Body	SootMethod.retrieveActiveBody(Consumer<Body> consumer)	Returns the active body if present, else constructs an active body, calls the consumer and returns the body afterward.

Methods in soot with parameters of type Body

Modifier and Type	Method	Description
void	Pack.apply(Body b)
void	Transform.apply(Body b)
protected void	AbstractJasminClass.assignColorsToLocals(Body body)
LocalGenerator	Scene.createLocalGenerator(Body stmtBody)
static List<RefType>	TrapManager.getExceptionTypesOf(Unit u, Body body)	Given a body and a unit handling an exception, returns the list of exception types possibly caught by the handler.
static Set<Unit>	TrapManager.getTrappedUnitsOf(Body b)	Returns a set of units which lie inside the range of any trap.
static List<Trap>	TrapManager.getTrapsAt(Unit unit, Body b)	Returns the list of traps caught at Unit u in Body b.
Map<Object,Object>	Body.importBodyContentsFrom(Body b)	Copies the contents of the given Body into this one.
Map<Object,Object>	Body.importBodyContentsFrom(Body b, boolean noLocalsClone)	Copies the contents of the given Body into this one.
protected void	BodyPack.internalApply(Body b)
protected void	JavaToJimpleBodyPack.internalApply(Body b)
protected void	JimpleBodyPack.internalApply(Body b)
protected void	Pack.internalApply(Body b)
protected abstract void	BodyTransformer.internalTransform(Body b, String phaseName, Map<String,String> options)	This method is called to perform the transformation itself.
static boolean	TrapManager.isExceptionCaughtAt(SootClass e, Unit u, Body b)	If exception e is caught at unit u in body b, return true; otherwise, return false.
void	Printer.printTo(Body b, PrintWriter out)	Prints out the method corresponding to the Body, (declaration and body) in the textual format corresponding to the IR used to encode the Body.
void	SootMethod.setActiveBody(Body body)	Sets the active body for this method.
static void	TrapManager.splitTrapsAgainst(Body b, Unit rangeStart, Unit rangeEnd)	Splits all traps so that they do not cross the range rangeStart - rangeEnd.
void	BodyTransformer.transform(Body b)
void	BodyTransformer.transform(Body b, String phaseName)
void	BodyTransformer.transform(Body b, String phaseName, Map<String,String> options)	Called by clients of the transformation.

Method parameters in soot with type arguments of type Body

Modifier and Type	Method	Description
Body	SootMethod.retrieveActiveBody(Consumer<Body> consumer)	Returns the active body if present, else constructs an active body, calls the consumer and returns the body afterward.
void	Printer.setCustomUnitPrinter(Function<Body,LabeledUnitPrinter> customUnitPrinter)

Constructors in soot with parameters of type Body

Constructor	Description
BriefUnitPrinter(Body body)
LabeledUnitPrinter(Body b)
NormalUnitPrinter(Body body)

Uses of Body in soot.asm

Methods in soot.asm that return Body

Modifier and Type	Method	Description
Body	AsmMethodSource.getBody(SootMethod m, String phaseName)

Methods in soot.asm with parameters of type Body

Modifier and Type	Method	Description
protected void	CastAndReturnInliner.internalTransform(Body body, String phaseName, Map<String,String> options)

Uses of Body in soot.baf

Subclasses of Body in soot.baf

Modifier and Type	Class	Description
class	BafBody

Methods in soot.baf with parameters of type Body

Modifier and Type	Method	Description
protected void	JasminClass.assignColorsToLocals(Body body)

Uses of Body in soot.baf.toolkits.base

Methods in soot.baf.toolkits.base with parameters of type Body

Modifier and Type	Method	Description
boolean	ExamplePeephole.apply(Body b)
boolean	Peephole.apply(Body b)	Entry point for a peephole.
protected void	LoadStoreOptimizer.internalTransform(Body body, String phaseName, Map<String,String> options)
protected void	PeepholeOptimizer.internalTransform(Body body, String phaseName, Map<String,String> options)	The method that drives the optimizations.
protected void	StoreChainOptimizer.internalTransform(Body b, String phaseName, Map<String,String> options)
void	StackTypesValidator.validate(Body body, List<ValidationException> exceptions)

Uses of Body in soot.dava

Subclasses of Body in soot.dava

Modifier and Type	Class	Description
class	DavaBody

Methods in soot.dava with parameters of type Body

Modifier and Type	Method	Description
DavaBody	Dava.newBody(Body b)	Returns a DavaBody constructed from the given body b.

Uses of Body in soot.dava.internal.AST

Methods in soot.dava.internal.AST with parameters of type Body

Modifier and Type	Method	Description
void	ASTMethodNode.storeLocals(Body OrigBody)

Uses of Body in soot.dexpler

Methods in soot.dexpler that return Body

Modifier and Type	Method	Description
Body	DexBody.getBody()	Return the associated JimpleBody.
Body	DexBody.jimplify(Body b, SootMethod m)	Return the jimple equivalent of this body.

Methods in soot.dexpler with parameters of type Body

Modifier and Type	Method	Description
static void	Util.addExceptionAfterUnit(Body b, String exceptionType, Unit u, String m)	Insert a runtime exception before unit u of body b.
void	IDalvikTyper.assignType(Body b)
protected List<Unit>	DexTransformer.collectDefinitionsWithAliases(Local l, LocalDefs localDefs, LocalUses localUses, Body body)	Collect definitions of l in body including the definitions of aliases of l.
static void	Util.emptyBody(Body jBody)	Remove all statements except from IdentityStatements for parameters.
protected void	DexArrayInitReducer.internalTransform(Body b, String phaseName, Map<String,String> options)
protected void	DexFillArrayDataTransformer.internalTransform(Body body, String phaseName, Map<String,String> options)
protected void	DexIfTransformer.internalTransform(Body body, String phaseName, Map<String,String> options)
protected void	DexJumpChainShortener.internalTransform(Body b, String phaseName, Map<String,String> options)
protected void	DexNullArrayRefTransformer.internalTransform(Body body, String phaseName, Map<String,String> options)
protected void	DexNullIfTransformer.internalTransform(Body b, String phaseName, Map<String,String> options)
protected void	DexNullInstanceofTransformer.internalTransform(Body b, String phaseName, Map<String,String> options)
protected void	DexNullThrowTransformer.internalTransform(Body b, String phaseName, Map<String,String> options)
protected void	DexNullTransformer.internalTransform(Body body, String phaseName, Map<String,String> options)
protected void	DexNumTransformer.internalTransform(Body body, String phaseName, Map<String,String> options)
protected void	DexRefsChecker.internalTransform(Body body, String phaseName, Map options)
protected void	DexReturnInliner.internalTransform(Body body, String phaseName, Map<String,String> options)
protected void	DexReturnPacker.internalTransform(Body b, String phaseName, Map<String,String> options)
protected void	DexReturnValuePropagator.internalTransform(Body body, String phaseName, Map<String,String> options)
protected void	DexTrapStackFixer.internalTransform(Body b, String phaseName, Map<String,String> options)
protected void	TrapMinimizer.internalTransform(Body b, String phaseName, Map<String,String> options)
Body	DexBody.jimplify(Body b, SootMethod m)	Return the jimple equivalent of this body.

Constructors in soot.dexpler with parameters of type Body

Constructor	Description
DexDefUseAnalysis(Body body)

Uses of Body in soot.dexpler.instructions

Methods in soot.dexpler.instructions with parameters of type Body

Modifier and Type	Method	Description
void	MoveExceptionInstruction.retype(Body body)
void	RetypeableInstruction.retype(Body body)	Do actual retype.

Uses of Body in soot.dexpler.typing

Methods in soot.dexpler.typing with parameters of type Body

Modifier and Type	Method	Description
void	DalvikTyper.assignType(Body b)
void	DalvikTyper.typeUntypedConstrantInDiv(Body b)
static void	Validate.validateArrays(Body b)

Uses of Body in soot.dotnet.instructions

Methods in soot.dotnet.instructions that return Body

Modifier and Type	Method	Description
Body	CatchHandlerBody.getBody()
Body	CatchFilterHandlerBody.getFilterHandlerBody(Value generalExceptionVariable)
Body	CilBlockContainer.jimplify()

Methods in soot.dotnet.instructions with parameters of type Body

Modifier and Type	Method	Description
protected InvokeExpr	AbstractNewObjInstanceInstruction.createInvokeExpr(Body jb, SootClass clazz, DotnetMethod method, soot.dotnet.instructions.CilCallInstruction.MethodParams methodParams)
protected InvokeExpr	CilCallInstruction.createInvokeExpr(Body jb, SootClass clazz, DotnetMethod method, soot.dotnet.instructions.CilCallInstruction.MethodParams methodParams)
protected InvokeExpr	CilNewObjInstruction.createInvokeExpr(Body jb, SootClass clazz, DotnetMethod method, soot.dotnet.instructions.CilCallInstruction.MethodParams methodParams)
protected Local	AbstractCilnstruction.createTempVar(Body jb, Jimple jimple, Value inv)
protected Local	AbstractCilnstruction.createTempVar(Body jb, Type type)
protected soot.dotnet.instructions.CilCallInstruction.MethodParams	CilCallInstruction.getMethodCallParams(boolean hasBase, Body jb)
protected soot.dotnet.instructions.CilCallInstruction.MethodParams	CilCallInstruction.getMethodCallParams(DotnetMethod method, boolean hasBase, Body jb)
void	CilBinaryNumericInstruction.jimplify(Body jb)
void	CilBlock.jimplify(Body jb)
void	CilBlockContainer.jimplify(Body jb)
void	CilBranchInstruction.jimplify(Body jb)
void	CilCallInstruction.jimplify(Body jb)
void	CilCastClassUnBoxInstruction.jimplify(Body jb)
void	CilCkFiniteInstruction.jimplify(Body jb)
void	CilCompInstruction.jimplify(Body jb)
void	CilConvInstruction.jimplify(Body jb)
void	CilDebugBreakInstruction.jimplify(Body jb)
void	CilDefaultValueInstruction.jimplify(Body jb)
void	CilIfInstruction.jimplify(Body jb)
void	CilILFunctionInstruction.jimplify(Body jb)
void	CilInstruction.jimplify(Body jb)	Jimplify a starting statement of ILSpy AST
void	CilIsInstInstruction.jimplify(Body jb)
void	CilLdcDecimalInstruction.jimplify(Body jb)
void	CilLdcI4Instruction.jimplify(Body jb)
void	CilLdcI8Instruction.jimplify(Body jb)
void	CilLdcR4Instruction.jimplify(Body jb)
void	CilLdcR8Instruction.jimplify(Body jb)
void	CilLdElemaInstruction.jimplify(Body jb)
void	CilLdElemInstruction.jimplify(Body jb)
void	CilLdFldaInstruction.jimplify(Body jb)
void	CilLdFtnInstruction.jimplify(Body jb)
void	CilLdLenInstruction.jimplify(Body jb)
void	CilLdLocInstruction.jimplify(Body jb)
void	CilLdMemberTokenInstruction.jimplify(Body jb)
void	CilLdNullInstruction.jimplify(Body jb)
void	CilLdsFldaInstruction.jimplify(Body jb)
void	CilLdStrInstruction.jimplify(Body jb)
void	CilLdTypeTokenInstruction.jimplify(Body jb)
void	CilLdVirtualFtnInstruction.jimplify(Body jb)
void	CilLeaveInstruction.jimplify(Body jb)
void	CilLocAllocInstruction.jimplify(Body jb)
void	CilMatchInstruction.jimplify(Body jb)
void	CilNewArrInstruction.jimplify(Body jb)
void	CilNewObjInstruction.jimplify(Body jb)
void	CilNopInstruction.jimplify(Body jb)
void	CilNotInstruction.jimplify(Body jb)
void	CilRefAnyInstruction.jimplify(Body jb)
void	CilRefTypeInstruction.jimplify(Body jb)
void	CilRethrowInstruction.jimplify(Body jb)
void	CilSizeOfInstruction.jimplify(Body jb)
void	CilStLocInstruction.jimplify(Body jb)
void	CilStObjInstruction.jimplify(Body jb)
void	CilSwitchInstruction.jimplify(Body jb)
void	CilThrowInstruction.jimplify(Body jb)
void	CilTryCatchInstruction.jimplify(Body jb)
void	CilTryFaultInstruction.jimplify(Body jb)
void	CilTryFinallyInstruction.jimplify(Body jb)
protected void	CilBlockContainer.jimplifyBlock(Body jb, ProtoIlInstructions.IlBlock block)
protected void	CILBlockContainerInstr.jimplifyBlock(Body jb, ProtoIlInstructions.IlBlock block)
Value	CilBinaryNumericInstruction.jimplifyExpr(Body jb)
Value	CilBlock.jimplifyExpr(Body jb)
Value	CilBlockContainer.jimplifyExpr(Body jb)
Value	CILBlockContainerInstr.jimplifyExpr(Body jb)
Value	CilBranchInstruction.jimplifyExpr(Body jb)
Value	CilCallInstruction.jimplifyExpr(Body jb)	Call Expression
Value	CilCastClassUnBoxInstruction.jimplifyExpr(Body jb)
Value	CilCkFiniteInstruction.jimplifyExpr(Body jb)
Value	CilCompInstruction.jimplifyExpr(Body jb)
Value	CilConvInstruction.jimplifyExpr(Body jb)
Value	CilDebugBreakInstruction.jimplifyExpr(Body jb)
Value	CilDefaultValueInstruction.jimplifyExpr(Body jb)
Value	CilIfInstruction.jimplifyExpr(Body jb)
Value	CilILFunctionInstruction.jimplifyExpr(Body jb)
Value	CilInstruction.jimplifyExpr(Body jb)	Jimplify an expression of ILSpy AST statement children
Value	CilIsInstInstruction.jimplifyExpr(Body jb)
Value	CilLdcDecimalInstruction.jimplifyExpr(Body jb)
Value	CilLdcI4Instruction.jimplifyExpr(Body jb)
Value	CilLdcI8Instruction.jimplifyExpr(Body jb)
Value	CilLdcR4Instruction.jimplifyExpr(Body jb)
Value	CilLdcR8Instruction.jimplifyExpr(Body jb)
Value	CilLdElemaInstruction.jimplifyExpr(Body jb)
Value	CilLdElemInstruction.jimplifyExpr(Body jb)
Value	CilLdFldaInstruction.jimplifyExpr(Body jb)
Value	CilLdFtnInstruction.jimplifyExpr(Body jb)	Call Expression
Value	CilLdLenInstruction.jimplifyExpr(Body jb)
Value	CilLdLocInstruction.jimplifyExpr(Body jb)
Value	CilLdMemberTokenInstruction.jimplifyExpr(Body jb)
Value	CilLdNullInstruction.jimplifyExpr(Body jb)
Value	CilLdsFldaInstruction.jimplifyExpr(Body jb)
Value	CilLdStrInstruction.jimplifyExpr(Body jb)
Value	CilLdTypeTokenInstruction.jimplifyExpr(Body jb)
Value	CilLdVirtualFtnInstruction.jimplifyExpr(Body jb)	Call Expression
Value	CilLeaveInstruction.jimplifyExpr(Body jb)
Value	CilLocAllocInstruction.jimplifyExpr(Body jb)
Value	CilMatchInstruction.jimplifyExpr(Body jb)
Value	CilNewArrInstruction.jimplifyExpr(Body jb)
Value	CilNewObjInstruction.jimplifyExpr(Body jb)
Value	CilNopInstruction.jimplifyExpr(Body jb)
Value	CilNotInstruction.jimplifyExpr(Body jb)
Value	CilRefAnyInstruction.jimplifyExpr(Body jb)
Value	CilRefTypeInstruction.jimplifyExpr(Body jb)
Value	CilRethrowInstruction.jimplifyExpr(Body jb)
Value	CilSizeOfInstruction.jimplifyExpr(Body jb)
Value	CilStLocInstruction.jimplifyExpr(Body jb)
Value	CilStObjInstruction.jimplifyExpr(Body jb)
Value	CilSwitchInstruction.jimplifyExpr(Body jb)
Value	CilThrowInstruction.jimplifyExpr(Body jb)
Value	CilTryCatchInstruction.jimplifyExpr(Body jb)
Value	CilTryFaultInstruction.jimplifyExpr(Body jb)
Value	CilTryFinallyInstruction.jimplifyExpr(Body jb)
static boolean	CilBlockContainer.LastStmtIsNotReturn(Body jb)
void	CilILFunctionInstruction.resolveRewritingIsInst(Body jb, Local variable, Value instanceOfExpr)
Local	CilIsInstInstruction.resolveRewritingIsInst(Body jb, Local variable, InstanceOfExpr instanceOfExpr)
protected Value	AbstractCilnstruction.simplifyComplexExpression(Body jb, Value var)

Constructors in soot.dotnet.instructions with parameters of type Body

Constructor	Description
CatchHandlerBody(Local exceptionVariable, ProtoIlInstructions.IlTryCatchHandlerMsg handlerMsg, DotnetBody dotnetBody, Body tryBody, Unit exceptionIdentityStmt, List<Unit> nopsToReplaceWithGoto)

Uses of Body in soot.dotnet.members

Methods in soot.dotnet.members that return Body

Modifier and Type	Method	Description
Body	DotnetMethod.jimplifyMethodBody(ProtoIlInstructions.IlFunctionMsg ilFunctionMsg)	Generate Jimple Body of this Method

Methods in soot.dotnet.members with parameters of type Body

Modifier and Type	Method	Description
static Value	ByReferenceWrapperGenerator.insertWrapperCall(Body jb, SootClass wrapperClass, Value arg)	Inserts calls to wrap objects

Uses of Body in soot.dotnet.members.method

Methods in soot.dotnet.members.method with parameters of type Body

Modifier and Type	Method	Description
Local	DotnetBodyVariableManager.addOrGetVariable(ProtoIlInstructions.IlVariableMsg v, Body jbTmp)	Add or get variable/local of this method body
Local	DotnetBodyVariableManager.addOrGetVariable(ProtoIlInstructions.IlVariableMsg v, Type type, Body jbTmp)	Type of local is got by the protoVariableMsg but in some cases we need to define the type of the local
protected Value	DotnetBody.createTempVar(Body jb, Jimple jimple, Value inv)
void	DotnetBodyVariableManager.fillMethodParameter(Body jb, List<ProtoAssemblyAllTypes.ParameterDefinition> parameters, List<Unit> unwrapCalls, Map<Local,Local> unwrappedToWrapped)	Add parameters of the .NET method to the Jimple Body
static Value	DotnetBodyVariableManager.inlineLocals(Value v, Body jb)	Recursively get value of a locals chain
protected void	TransformIntsToBooleans.internalTransform(Body b, String phaseName, Map<String,String> opts)
void	BlockEntryPointsManager.swapGotoEntriesInJBody(Body jb)	After producing Jimple Body, swap all target branches (label to stmt)

Constructors in soot.dotnet.members.method with parameters of type Body

Constructor	Description
DotnetBodyVariableManager(DotnetBody dotnetBody, Body mainJb)

Uses of Body in soot.grimp

Subclasses of Body in soot.grimp

Modifier and Type	Class	Description
class	GrimpBody	Implementation of the Body class for the Grimp IR.

Methods in soot.grimp with parameters of type Body

Modifier and Type	Method	Description
GrimpBody	Grimp.newBody(Body b, String phase)	Returns a GrimpBody constructed from b.

Uses of Body in soot.grimp.toolkits.base

Methods in soot.grimp.toolkits.base with parameters of type Body

Modifier and Type	Method	Description
protected void	ConstructorFolder.internalTransform(Body b, String phaseName, Map options)	This method change all new Obj/(args) pairs to new Obj(args) idioms.

Uses of Body in soot.javaToJimple

Methods in soot.javaToJimple that return Body

Modifier and Type	Method	Description
Body	AnonClassInitMethodSource.getBody(SootMethod sootMethod, String phaseName)
Body	AssertClassMethodSource.getBody(SootMethod sootMethod, String phaseName)
Body	ClassLiteralMethodSource.getBody(SootMethod sootMethod, String phaseName)
Body	PolyglotMethodSource.getBody(SootMethod sm, String phaseName)
Body	PrivateFieldAccMethodSource.getBody(SootMethod sootMethod, String phaseName)
Body	PrivateFieldSetMethodSource.getBody(SootMethod sootMethod, String phaseName)
Body	PrivateMethodAccMethodSource.getBody(SootMethod sootMethod, String phaseName)

Methods in soot.javaToJimple with parameters of type Body

Modifier and Type	Method	Description
void	PolyglotMethodSource.addAssertInits(Body body)
static Local	Util.getPrivateAccessFieldInvoke(SootMethodRef toInvoke, ArrayList params, Body body, LocalGenerator lg)
static Local	Util.getThis(Type sootType, Body body, HashMap getThisMap, LocalGenerator lg)
static Local	Util.getThisGivenOuter(Type sootType, HashMap getThisMap, Body body, LocalGenerator lg, Local t2)

Constructors in soot.javaToJimple with parameters of type Body

Constructor	Description
DefaultLocalGenerator(Body b)

Uses of Body in soot.javaToJimple.toolkits

Methods in soot.javaToJimple.toolkits with parameters of type Body

Modifier and Type	Method	Description
protected void	CondTransformer.internalTransform(Body b, String phaseName, Map options)

Uses of Body in soot.jbco

Methods in soot.jbco with parameters of type Body

Modifier and Type	Method	Description
protected void	LineNumberGenerator.BafLineNumberer.internalTransform(Body b, String phaseName, Map<String,String> options)

Uses of Body in soot.jbco.bafTransformations

Methods in soot.jbco.bafTransformations with parameters of type Body

Modifier and Type	Method	Description
static Map<Unit,Stack<Type>>	StackTypeHeightCalculator.calculateStackHeights(Body b)
static Map<Unit,Stack<Type>>	StackTypeHeightCalculator.calculateStackHeights(Body b, boolean jimpleLocals)
static Map<Unit,Stack<Type>>	StackTypeHeightCalculator.calculateStackHeights(Body b, Map<Local,Local> b2JLocs)
static Stack<Type>	StackTypeHeightCalculator.getAfterStack(Body b, Unit u)
protected void	AddJSRs.internalTransform(Body b, String phaseName, Map<String,String> options)
protected void	BAFCounter.internalTransform(Body b, String phaseName, Map<String,String> options)
protected void	BafLineNumberer.internalTransform(Body b, String phaseName, Map<String,String> options)
protected void	BAFPrintout.internalTransform(Body b, String phaseName, Map<String,String> options)
protected void	ConstructorConfuser.internalTransform(Body b, String phaseName, Map<String,String> options)
protected void	Counter.internalTransform(Body b, String phaseName, Map<String,String> options)
protected void	FindDuplicateSequences.internalTransform(Body b, String phaseName, Map<String,String> options)
protected void	FixUndefinedLocals.internalTransform(Body b, String phaseName, Map<String,String> options)
protected void	IfNullToTryCatch.internalTransform(Body b, String phaseName, Map<String,String> options)
protected void	IndirectIfJumpsToCaughtGotos.internalTransform(Body b, String phaseName, Map<String,String> options)
protected void	Jimple2BafLocalBuilder.internalTransform(Body b, String phaseName, Map<String,String> options)
protected void	LocalsToBitField.internalTransform(Body b, String phaseName, Map<String,String> options)
protected void	MoveLoadsAboveIfs.internalTransform(Body b, String phaseName, Map<String,String> options)
protected void	RemoveRedundantPushStores.internalTransform(Body b, String phaseName, Map<String,String> options)
protected void	TryCatchCombiner.internalTransform(Body b, String phaseName, Map<String,String> options)
protected void	UpdateConstantsToFields.internalTransform(Body b, String phaseName, Map<String,String> options)
protected void	WrapSwitchesInTrys.internalTransform(Body b, String phaseName, Map<String,String> options)

Uses of Body in soot.jbco.jimpleTransformations

Methods in soot.jbco.jimpleTransformations with parameters of type Body

Modifier and Type	Method	Description
boolean	AddSwitches.checkTraps(Unit u, Body b)
protected void	AddSwitches.internalTransform(Body b, String phaseName, Map<String,String> options)
protected void	ArithmeticTransformer.internalTransform(Body b, String phaseName, Map<String,String> options)
protected void	CollectJimpleLocals.internalTransform(Body body, String phaseName, Map<String,String> options)
protected void	GotoInstrumenter.internalTransform(Body body, String phaseName, Map<String,String> options)

Uses of Body in soot.jbco.util

Methods in soot.jbco.util with parameters of type Body

Modifier and Type	Method	Description
static void	Debugger.printBaf(Body b)
static void	Debugger.printUnits(Body b, String msg)

Constructors in soot.jbco.util with parameters of type Body

Constructor	Description
SimpleExceptionalGraph(Body body)

Uses of Body in soot.jimple

Subclasses of Body in soot.jimple

Modifier and Type	Class	Description
class	JimpleBody	Implementation of the Body class for the Jimple IR.
class	StmtBody	Abstract base class for Body's on Stmts (Jimple and Grimp).

Methods in soot.jimple that return Body

Modifier and Type	Method	Description
Body	JimpleMethodSource.getBody(SootMethod m, String phaseName)

Methods in soot.jimple with parameters of type Body

Modifier and Type	Method	Description
protected void	JasminClass.assignColorsToLocals(Body body)

Uses of Body in soot.jimple.parser

Methods in soot.jimple.parser that return Body

Modifier and Type	Method	Description
Body	JimpleAST.getBody(SootMethod m)	Returns a body corresponding to the parsed jimple for m.

Uses of Body in soot.jimple.spark.fieldrw

Methods in soot.jimple.spark.fieldrw with parameters of type Body

Modifier and Type	Method	Description
protected void	FieldTagAggregator.internalTransform(Body b, String phaseName, Map options)
protected void	FieldTagger.internalTransform(Body body, String phaseName, Map options)

Uses of Body in soot.jimple.toolkits.annotation

Methods in soot.jimple.toolkits.annotation with parameters of type Body

Modifier and Type	Method	Description
protected void	AvailExprTagger.internalTransform(Body b, String phaseName, Map opts)
protected void	DominatorsTagger.internalTransform(Body b, String phaseName, Map opts)

Uses of Body in soot.jimple.toolkits.annotation.arraycheck

Methods in soot.jimple.toolkits.annotation.arraycheck with parameters of type Body

Modifier and Type	Method	Description
protected void	ArrayBoundsChecker.internalTransform(Body body, String phaseName, Map opts)

Uses of Body in soot.jimple.toolkits.annotation.callgraph

Methods in soot.jimple.toolkits.annotation.callgraph with parameters of type Body

Modifier and Type	Method	Description
protected void	CallGraphTagger.internalTransform(Body b, String phaseName, Map options)

Uses of Body in soot.jimple.toolkits.annotation.defs

Methods in soot.jimple.toolkits.annotation.defs with parameters of type Body

Modifier and Type	Method	Description
protected void	ReachingDefsTagger.internalTransform(Body b, String phaseName, Map<String,String> options)

Uses of Body in soot.jimple.toolkits.annotation.liveness

Methods in soot.jimple.toolkits.annotation.liveness with parameters of type Body

Modifier and Type	Method	Description
protected void	LiveVarsTagger.internalTransform(Body b, String phaseName, Map options)

Uses of Body in soot.jimple.toolkits.annotation.logic

Methods in soot.jimple.toolkits.annotation.logic with parameters of type Body

Modifier and Type	Method	Description
Set<Loop>	LoopFinder.getLoops(Body b)
protected void	LoopFinder.internalTransform(Body b, String phaseName, Map<String,String> options)
protected void	LoopInvariantFinder.internalTransform(Body b, String phaseName, Map options)	this one uses the side effect tester

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

Methods in soot.jimple.toolkits.annotation.nullcheck with parameters of type Body

Modifier and Type	Method	Description
void	NullCheckEliminator.internalTransform(Body body, String phaseName, Map<String,String> options)
protected void	NullPointerChecker.internalTransform(Body body, String phaseName, Map<String,String> options)
protected void	NullPointerColorer.internalTransform(Body b, String phaseName, Map<String,String> options)

Uses of Body in soot.jimple.toolkits.annotation.parity

Methods in soot.jimple.toolkits.annotation.parity with parameters of type Body

Modifier and Type	Method	Description
protected void	ParityTagger.internalTransform(Body b, String phaseName, Map options)

Uses of Body in soot.jimple.toolkits.annotation.profiling

Methods in soot.jimple.toolkits.annotation.profiling with parameters of type Body

Modifier and Type	Method	Description
protected void	ProfilingGenerator.internalTransform(Body body, String phaseName, Map opts)

Uses of Body in soot.jimple.toolkits.base

Methods in soot.jimple.toolkits.base with parameters of type Body

Modifier and Type	Method	Description
protected void	ExceptionChecker.checkInvoke(Body b, InvokeStmt is)
protected void	ExceptionChecker.checkInvokeExpr(Body b, InvokeExpr ie, Stmt s)
protected void	ExceptionChecker.checkThrow(Body b, ThrowStmt ts)
protected void	Aggregator.internalTransform(Body b, String phaseName, Map<String,String> options)	Traverse the statements in the given body, looking for aggregation possibilities; that is, given a def d and a use u, d has no other uses, u has no other defs, collapse d and u.
protected void	ExceptionChecker.internalTransform(Body b, String phaseName, Map<String,String> options)
void	JimpleConstructorFolder.internalTransform(Body b, String phaseName, Map<String,String> options)
void	PartialConstructorFolder.internalTransform(Body b, String phaseName, Map<String,String> options)	This method pushes all newExpr down to be the stmt directly before every invoke of the init only if they are in the types list
void	ThisInliner.internalTransform(Body b, String phaseName, Map<String,String> options)
protected boolean	ExceptionChecker.isExceptionCaught(Body b, Stmt s, RefType throwType)
protected boolean	ExceptionChecker.isThrowDeclared(Body b, SootClass throwClass)
protected boolean	ExceptionChecker.isThrowInStmtRange(Body b, Stmt begin, Stmt end, Stmt s)

Uses of Body in soot.jimple.toolkits.callgraph

Methods in soot.jimple.toolkits.callgraph with parameters of type Body

Modifier and Type	Method	Description
protected void	OnFlyCallGraphBuilder.findReceivers(SootMethod m, Body b)
abstract Value	VirtualEdgesSummaries.AbstractParameterMapping.getMappedTargetArgumentArg(Body body)
Value	VirtualEdgesSummaries.DirectParameterMapping.getMappedTargetArgumentArg(Body body)
protected void	ClinitElimTransformer.internalTransform(Body b, String phaseName, Map<String,String> options)
protected void	UnreachableMethodTransformer.internalTransform(Body b, String phaseName, Map<String,String> options)

Constructors in soot.jimple.toolkits.callgraph with parameters of type Body

Constructor	Description
ConstantArrayAnalysis(DirectedGraph<Unit> graph, Body b)

Uses of Body in soot.jimple.toolkits.graph

Methods in soot.jimple.toolkits.graph with parameters of type Body

Modifier and Type	Method	Description
protected void	CriticalEdgeRemover.internalTransform(Body b, String phaseName, Map<String,String> options)	performs critical edge-removing.
protected void	LoopConditionUnroller.internalTransform(Body body, String phaseName, Map<String,String> options)	unrolls conditions.

Uses of Body in soot.jimple.toolkits.ide.icfg

Fields in soot.jimple.toolkits.ide.icfg with type parameters of type Body

Modifier and Type	Field	Description
protected com.google.common.cache.LoadingCache<Body,LocalMustNotAliasAnalysis>	OnTheFlyJimpleBasedICFG.bodyToLMNAA
protected com.google.common.cache.LoadingCache<Body,DirectedGraph<Unit>>	AbstractJimpleBasedICFG.bodyToUnitGraph

Methods in soot.jimple.toolkits.ide.icfg that return Body

Modifier and Type	Method	Description
Body	AbstractJimpleBasedICFG.getBodyOf(Unit u)
protected Body	OnTheFlyJimpleBasedICFG.initForMethod(SootMethod m)

Methods in soot.jimple.toolkits.ide.icfg that return types with arguments of type Body

Modifier and Type	Method	Description
protected Map<Unit,Body>	AbstractJimpleBasedICFG.createUnitToOwnerMap()	Creates a new map used for the unitToOwner map.

Methods in soot.jimple.toolkits.ide.icfg with parameters of type Body

Modifier and Type	Method	Description
DirectedGraph<Unit>	AbstractJimpleBasedICFG.getOrCreateUnitGraph(Body body)
void	AbstractJimpleBasedICFG.initializeUnitToOwner(Body b)
protected DirectedGraph<Unit>	AbstractJimpleBasedICFG.makeGraph(Body body)
boolean	AbstractJimpleBasedICFG.setOwnerStatement(Unit u, Body b)

Uses of Body in soot.jimple.toolkits.invoke

Methods in soot.jimple.toolkits.invoke with parameters of type Body

Modifier and Type	Method	Description
static void	AccessManager.createAccessorMethods(Body body, Stmt before, Stmt after)	Resolves illegal accesses in the interval ]before,after[ by creating accessor methods.

Uses of Body in soot.jimple.toolkits.pointer

Methods in soot.jimple.toolkits.pointer with parameters of type Body

Modifier and Type	Method	Description
protected void	CastCheckEliminatorDumper.internalTransform(Body b, String phaseName, Map<String,String> options)
protected void	FieldRWTagger.internalTransform(Body body, String phaseName, Map<String,String> options)
protected void	ParameterAliasTagger.internalTransform(Body b, String phaseName, Map<String,String> options)
protected void	SideEffectTagger.internalTransform(Body body, String phaseName, Map<String,String> options)

Constructors in soot.jimple.toolkits.pointer with parameters of type Body

Constructor	Description
LocalMustNotAliasAnalysis(DirectedGraph<Unit> directedGraph, Body b)

Uses of Body in soot.jimple.toolkits.scalar

Methods in soot.jimple.toolkits.scalar with parameters of type Body

Modifier and Type	Method	Description
protected void	CommonSubexpressionEliminator.internalTransform(Body b, String phaseName, Map<String,String> options)	Common subexpression eliminator.
protected void	ConditionalBranchFolder.internalTransform(Body body, String phaseName, Map<String,String> options)
protected void	ConstantCastEliminator.internalTransform(Body b, String phaseName, Map<String,String> options)
protected void	ConstantPropagatorAndFolder.internalTransform(Body b, String phaseName, Map<String,String> options)
protected void	CopyPropagator.internalTransform(Body b, String phaseName, Map<String,String> opts)	Cascaded copy propagator.
protected void	DeadAssignmentEliminator.internalTransform(Body b, String phaseName, Map<String,String> options)	Eliminates dead code in a linear fashion.
protected void	EmptySwitchEliminator.internalTransform(Body b, String phaseName, Map<String,String> options)
protected void	FieldStaticnessCorrector.internalTransform(Body b, String phaseName, Map<String,String> options)
protected void	IdentityCastEliminator.internalTransform(Body b, String phaseName, Map<String,String> options)
protected void	IdentityOperationEliminator.internalTransform(Body b, String phaseName, Map<String,String> options)
protected void	LocalNameStandardizer.internalTransform(Body body, String phaseName, Map<String,String> options)
protected void	MethodStaticnessCorrector.internalTransform(Body b, String phaseName, Map<String,String> options)
protected void	NopEliminator.internalTransform(Body b, String phaseName, Map<String,String> options)	Removes NopStmts from the passed body .
protected void	UnconditionalBranchFolder.internalTransform(Body b, String phaseName, Map<String,String> options)
protected void	UnreachableCodeEliminator.internalTransform(Body body, String phaseName, Map<String,String> options)

Constructors in soot.jimple.toolkits.scalar with parameters of type Body

Constructor	Description
FastAvailableExpressions(Body b, SideEffectTester st)	Wrapper for AvailableExpressionsAnalysis.
SlowAvailableExpressions(Body b)	Wrapper for SlowAvailableExpressionsAnalysis.

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

Methods in soot.jimple.toolkits.scalar.pre with parameters of type Body

Modifier and Type	Method	Description
protected void	BusyCodeMotion.internalTransform(Body b, String phaseName, Map<String,String> opts)	performs the busy code motion.
protected void	LazyCodeMotion.internalTransform(Body b, String phaseName, Map<String,String> opts)	performs the lazy code motion.

Uses of Body in soot.jimple.toolkits.thread.mhp

Fields in soot.jimple.toolkits.thread.mhp declared as Body

Modifier and Type	Field	Description
Body	PegChain.body

Methods in soot.jimple.toolkits.thread.mhp that return Body

Modifier and Type	Method	Description
Body	PegGraph.getBody()

Constructors in soot.jimple.toolkits.thread.mhp with parameters of type Body

Constructor	Description
MethodExtentBuilder(Body unitBody, PegCallGraph pcg, CallGraph cg)
PegGraph(CallGraph callGraph, Hierarchy hierarchy, PAG pag, Set<Object> methodsNeedingInlining, Set<AllocNode> allocNodes, List inlineSites, Map synchObj, Set<AllocNode> multiRunAllocNodes, Map allocNodeToObj, Body unitBody, SootMethod sm, boolean addExceptionEdges, boolean dontAddEdgeFromStmtBeforeAreaOfProtectionToCatchBlock)	Constructs a graph for the units found in the provided Body instance.
PegGraph(CallGraph callGraph, Hierarchy hierarchy, PAG pag, Set methodsNeedingInlining, Set allocNodes, List<List> inlineSites, Map<SootMethod,String> synchObj, Set multiRunAllocNodes, Map<AllocNode,String> allocNodeToObj, Body unitBody, String threadName, SootMethod sm, boolean addExceEdge, boolean dontAddEdgeFromStmtBeforeAreaOfProtectionToCatchBlock)	Constructs a graph for the units found in the provided Body instance.

Uses of Body in soot.jimple.toolkits.thread.synchronization

Methods in soot.jimple.toolkits.thread.synchronization with parameters of type Body

Modifier and Type	Method	Description
protected void	LockAllocationBodyTransformer.internalTransform(Body b, String phase, Map opts)
protected void	LockAllocationBodyTransformer.internalTransform(Body b, FlowSet fs, List<soot.jimple.toolkits.thread.synchronization.CriticalSectionGroup> groups, boolean[] insertedGlobalLock)
InstanceFieldRef	LockAllocationBodyTransformer.reconstruct(Body b, PatchingChain<Unit> units, InstanceFieldRef lock, Stmt insertBefore, boolean redirect)
void	LockAllocationBodyTransformer.redirectTraps(Body b, Unit oldUnit, Unit newUnit)

Uses of Body in soot.jimple.toolkits.typing

Methods in soot.jimple.toolkits.typing with parameters of type Body

Modifier and Type	Method	Description
static Unit	Util.findFirstNonIdentityUnit(Body b, Stmt s)	Returns the first statement after all the "identity statements".
static Unit	Util.findLastIdentityUnit(Body b, Stmt s)	A new "normal" statement cannot be inserted in the middle of special "identity statements" (a = @parameter or b = @this in Jimple).
protected void	TypeAssigner.internalTransform(Body b, String phaseName, Map<String,String> options)	Assign types to local variables.
protected static void	TypeAssigner.replaceNullType(Body b)	Replace statements using locals with null_type type and that would throw a NullPointerException at runtime by a set of instructions throwing a NullPointerException.

Uses of Body in soot.jimple.validation

Methods in soot.jimple.validation with parameters of type Body

Modifier and Type	Method	Description
void	FieldRefValidator.validate(Body body, List<ValidationException> exceptions)	Checks the consistency of field references.
void	IdentityStatementsValidator.validate(Body body, List<ValidationException> exceptions)	Checks the following invariants on this Jimple body: this-references may only occur in instance methods this-references may only occur as the first statement in a method, if they occur at all param-references must precede all statements that are not themselves param-references or this-references, if they occur at all
void	IdentityValidator.validate(Body body, List<ValidationException> exceptions)
void	InvokeArgumentValidator.validate(Body body, List<ValidationException> exceptions)
void	InvokeValidator.validate(Body body, List<ValidationException> exceptions)
void	JimpleTrapValidator.validate(Body body, List<ValidationException> exceptions)	Checks whether all Caught-Exception-References are associated to traps.
void	MethodValidator.validate(Body body, List<ValidationException> exceptions)	Checks the following invariants on this Jimple body: static initializer should have 'static' modifier
void	NewValidator.validate(Body body, List<ValidationException> exceptions)	Checks whether after each new-instruction a constructor call follows.
void	ReturnStatementsValidator.validate(Body body, List<ValidationException> exceptions)
void	TypesValidator.validate(Body body, List<ValidationException> exceptions)

Uses of Body in soot.shimple

Subclasses of Body in soot.shimple

Modifier and Type	Class	Description
class	ShimpleBody	Implementation of the Body class for the SSA Shimple IR.

Fields in soot.shimple declared as Body

Modifier and Type	Field	Description
protected Body	DefaultShimpleFactory.body

Methods in soot.shimple that return Body

Modifier and Type	Method	Description
Body	DefaultShimpleFactory.getBody()
Body	ShimpleMethodSource.getBody(SootMethod m, String phaseName)

Methods in soot.shimple with parameters of type Body

Modifier and Type	Method	Description
ShimpleBody	Shimple.newBody(Body b)	Returns a ShimpleBody constructed from b, using default phase options.
ShimpleBody	Shimple.newBody(Body b, Map<String,String> options)	Returns a ShimpleBody constructed from b, using provided option Map.
static void	Shimple.redirectToPreds(Body body, Unit remove)	If you are removing a Unit from a Unit chain which contains PhiExpr's, you might want to call this utility function in order to update any PhiExpr pointers to the Unit to point to the Unit's predecessor(s).

Constructors in soot.shimple with parameters of type Body

Constructor	Description
DefaultShimpleFactory(Body body)

Uses of Body in soot.shimple.internal

Fields in soot.shimple.internal declared as Body

Modifier and Type	Field	Description
protected Body	SPatchingChain.body	Needed to find non-trapped Units of the body.

Constructors in soot.shimple.internal with parameters of type Body

Constructor	Description
SPatchingChain(Body aBody, Chain<Unit> aChain)

Uses of Body in soot.shimple.toolkits.scalar

Methods in soot.shimple.toolkits.scalar with parameters of type Body

Modifier and Type	Method	Description
protected void	SConstantPropagatorAndFolder.internalTransform(Body b, String phaseName, Map<String,String> options)

Uses of Body in soot.tagkit

Methods in soot.tagkit with parameters of type Body

Modifier and Type	Method	Description
protected void	TagAggregator.internalTransform(Body b, String phaseName, Map<String,String> options)

Uses of Body in soot.toDex

Methods in soot.toDex with parameters of type Body

Modifier and Type	Method	Description
void	DexArrayInitDetector.constructArrayInitializations(Body body)	Constructs packed array initializations from the individual element assignments in the given body
void	DexArrayInitDetector.fixTraps(Body activeBody)	Fixes the traps in the given body to account for assignments to individual array elements being replaced by a single fill instruction.
protected void	FastDexTrapTightener.internalTransform(Body b, String phaseName, Map<String,String> options)
protected void	SynchronizedMethodTransformer.internalTransform(Body b, String phaseName, Map<String,String> options)
protected void	TrapSplitter.internalTransform(Body b, String phaseName, Map<String,String> options)
static void	TrapSplitter.removePotentiallyUselassTraps(Body b, Set<Unit> potentiallyUselessTrapHandlers)	Changes the given body so that trap handlers, which are contained in the given set, are removed in case they are not referenced by any trap.

Uses of Body in soot.toolkits.exceptions

Methods in soot.toolkits.exceptions with parameters of type Body

Modifier and Type	Method	Description
protected void	DuplicateCatchAllTrapRemover.internalTransform(Body b, String phaseName, Map<String,String> options)
protected void	TrapTightener.internalTransform(Body body, String phaseName, Map<String,String> options)

Uses of Body in soot.toolkits.graph

Fields in soot.toolkits.graph declared as Body

Modifier and Type	Field	Description
protected Body	UnitGraph.body
protected Body	BlockGraph.mBody

Methods in soot.toolkits.graph that return Body

Modifier and Type	Method	Description
Body	Block.getBody()	Returns the Block's enclosing Body instance.
Body	BlockGraph.getBody()	Returns the Body this BlockGraph is derived from.
Body	DirectedBodyGraph.getBody()
Body	ExceptionalGraph.getBody()	Returns the Body from which this graph was built.
Body	UnitGraph.getBody()

Methods in soot.toolkits.graph with parameters of type Body

Modifier and Type	Method	Description
static ExceptionalUnitGraph	ExceptionalUnitGraphFactory.createExceptionalUnitGraph(Body body)
static ExceptionalUnitGraph	ExceptionalUnitGraphFactory.createExceptionalUnitGraph(Body body, ThrowAnalysis throwAnalysis)
static ExceptionalUnitGraph	ExceptionalUnitGraphFactory.createExceptionalUnitGraph(Body body, ThrowAnalysis throwAnalysis, boolean omitExceptingUnitEdges)
protected ExceptionalUnitGraph	ExceptionalUnitGraphFactory.newExceptionalUnitGraph(Body body, ThrowAnalysis throwAnalysis, boolean omitExceptingUnitEdges)

Constructors in soot.toolkits.graph with parameters of type Body

Constructor	Description
ArrayRefBlockGraph(Body body)	Constructs an ArrayRefBlockGraph from the given Body.
Block(Unit aHead, Unit aTail, Body aBody, int aIndexInMethod, int aBlockLength, BlockGraph aBlockGraph)	Constructs a Block in the context of a BlockGraph, and enclosing Body instances.
BriefBlockGraph(Body body)	Constructs a BriefBlockGraph from a given Body.
BriefUnitGraph(Body body)	Constructs a BriefUnitGraph given a Body instance.
ClassicCompleteBlockGraph(Body body)	Constructs a ClassicCompleteBlockGraph for the blocks found by partitioning the the units of the provided Body instance into basic blocks.
ClassicCompleteUnitGraph(Body body)	Constructs the graph from a given Body instance.
CompleteBlockGraph(Body b)
CompleteUnitGraph(Body b)
ExceptionalBlockGraph(Body body)	Constructs an ExceptionalBlockGraph for the blocks found by partitioning the the units of the provided Body instance into basic blocks.
ExceptionalUnitGraph(Body body)	Constructs the graph from a given Body instance, using the Scene 's default ThrowAnalysis to estimate the set of exceptions that each Unit might throw and a default value, provided by the Options class, for the omitExceptingUnitEdges parameter.
ExceptionalUnitGraph(Body body, boolean ignoredBogusParameter)	Allocates an ExceptionalUnitGraph object without initializing it.
ExceptionalUnitGraph(Body body, ThrowAnalysis throwAnalysis)	Constructs the graph from a given Body instance using the passed ThrowAnalysis and a default value, provided by the Options class, for the omitExceptingUnitEdges parameter.
ExceptionalUnitGraph(Body body, ThrowAnalysis throwAnalysis, boolean omitExceptingUnitEdges)	Constructs the graph for a given Body instance, using the ThrowAnalysis and omitExceptingUnitEdges value that are passed as parameters.
LoopNestTree(Body b)	Builds a loop nest tree from a method body using LoopFinder.
TrapUnitGraph(Body body)	Constructs the graph from a given Body instance.
UnitGraph(Body body)	Performs the work that is required to construct any sort of UnitGraph.
ZonedBlockGraph(Body body)	Constructs a ZonedBlockGraph for the Units comprising the passed Body.

Uses of Body in soot.toolkits.graph.interaction

Methods in soot.toolkits.graph.interaction with parameters of type Body

Modifier and Type	Method	Description
void	InteractionHandler.handleNewAnalysis(Transform t, Body b)
void	InteractionHandler.handleTransformDone(Transform t, Body b)

Uses of Body in soot.toolkits.graph.pdg

Fields in soot.toolkits.graph.pdg declared as Body

Modifier and Type	Field	Description
protected Body	HashMutablePDG.m_body
protected Body	RegionAnalysis.m_methodBody

Constructors in soot.toolkits.graph.pdg with parameters of type Body

Constructor	Description
EnhancedBlockGraph(Body body)
EnhancedUnitGraph(Body body)

Uses of Body in soot.toolkits.scalar

Fields in soot.toolkits.scalar with type parameters of type Body

Modifier and Type	Field	Description
protected Map<Body,Pair<Long,SmartLocalDefs>>	SmartLocalDefsPool.pool

Methods in soot.toolkits.scalar with parameters of type Body

Modifier and Type	Method	Description
static <G> void	FastColorer.assignColorsToLocals(Body unitBody, Map<Local,G> localToGroup, Map<Local,Integer> localToColor, Map<G,Integer> groupToColorCount)	Provides an economical coloring for the locals of unitBody.
SmartLocalDefs	SmartLocalDefsPool.getSmartLocalDefsFor(Body b)	This method returns a fresh instance of a SmartLocalDefs analysis, based on a freshly created ExceptionalUnitGraph for b, with standard parameters.
protected void	FlowSensitiveConstantPropagator.internalTransform(Body body, String phaseName, Map<String,String> options)
protected void	LocalPacker.internalTransform(Body body, String phaseName, Map<String,String> options)
protected void	LocalSplitter.internalTransform(Body body, String phaseName, Map<String,String> options)
protected void	SharedInitializationLocalSplitter.internalTransform(Body body, String phaseName, Map<String,String> options)
protected void	UnusedLocalEliminator.internalTransform(Body body, String phaseName, Map<String,String> options)
void	SmartLocalDefsPool.invalidate(Body b)
LocalDefs	LocalDefsFactory.newLocalDefs(Body body)	Creates a new LocalDefs analysis based on a ExceptionalUnitGraph
LocalDefs	LocalDefsFactory.newLocalDefs(Body body, boolean expectUndefined)	Creates a new LocalDefs analysis based on a ExceptionalUnitGraph If you don't trust the input you should set expectUndefined to true.
static LocalUses	LocalUses.Factory.newLocalUses(Body body)
static LocalUses	LocalUses.Factory.newLocalUses(Body body, LocalDefs localDefs)
static <G> void	FastColorer.unsplitAssignColorsToLocals(Body unitBody, Map<Local,G> localToGroup, Map<Local,Integer> localToColor, Map<G,Integer> groupToColorCount)	Provides a coloring for the locals of unitBody, attempting to not split locals assigned the same name in the original Jimple.

Constructors in soot.toolkits.scalar with parameters of type Body

Constructor	Description
SimpleLocalUses(Body body, LocalDefs localDefs)	Construct the analysis from a method body and a LocalDefs interface.

Uses of Body in soot.tools

Methods in soot.tools with parameters of type Body

Modifier and Type	Method	Description
protected void	CFGViewer.internalTransform(Body b, String phaseName, Map<String,String> options)
protected void	CFGViewer.print_cfg(Body body)

Uses of Body in soot.util

Methods in soot.util with parameters of type Body

Modifier and Type	Method	Description
void	PhaseDumper.dumpAfter(Body b, String phaseName)	Tells the PhaseDumper that a Body transforming phase has ended, so that it can dump the phases's “after” file.
void	PhaseDumper.dumpBefore(Body b, String phaseName)	Tells the PhaseDumper that a Body transforming phase has started, so that it can dump the phases's “before” file.
void	PhaseDumper.dumpBody(Body b, String baseName)
<N> void	PhaseDumper.dumpGraph(DirectedGraph<N> g, Body b)	Asks the PhaseDumper to dump the passed DirectedGraph if the current phase is being dumped.
<N> void	PhaseDumper.dumpGraph(DirectedGraph<N> g, Body b, boolean skipPhaseCheck)	Asks the PhaseDumper to dump the passed DirectedGraph if the current phase is being dumped or skipPhaseCheck == true.

Constructors in soot.util with parameters of type Body

Constructor	Description
LocalBitSetPacker(Body body)
UnitMap(Body b)	maps each unit of this body to the result of mapTo. before the mapping the method init is called. the internal map is initialized without any parameter.
UnitMap(Body b, int initialCapacity)	maps each unit of this body to the result of mapTo. before the mapping the method init is called. the internal map is initialized to initialCapacity.
UnitMap(Body b, int initialCapacity, float loadFactor)	maps each unit of this body to the result of mapTo. before the mapping the method init is called. the internal map is initialized to initialCapacity and loadFactor.

Uses of Body in soot.util.cfgcmd

Methods in soot.util.cfgcmd that return Body

Modifier and Type	Method	Description
abstract Body	CFGIntermediateRep.getBody(JimpleBody b)	Converts a JimpleBody into the corresponding Body in this intermediate representation.

Methods in soot.util.cfgcmd with parameters of type Body

Modifier and Type	Method	Description
abstract DirectedGraph<?>	CFGGraphType.buildGraph(Body b)	Method that will build a graph of this type.
<N> DotGraph	CFGToDotGraph.drawCFG(DirectedGraph<N> graph, Body body)	Create a DotGraph whose nodes and edges depict a control flow graph without distinguished exceptional edges.
abstract DotGraph	CFGGraphType.drawGraph(CFGToDotGraph drawer, DirectedGraph<?> g, Body b)	Method that will draw a DotGraph representation of the control flow in this type of graph.

Uses of Body in soot.validation

Methods in soot.validation with parameters of type Body

Modifier and Type	Method	Description
void	BodyValidator.validate(Body body, List<ValidationException> exceptions)	Validates the given body and saves all validation errors in the given list.
void	CheckEscapingValidator.validate(Body body, List<ValidationException> exception)
void	CheckInitValidator.validate(Body body, List<ValidationException> exception)
void	CheckTypesValidator.validate(Body body, List<ValidationException> exception)
void	CheckVoidLocalesValidator.validate(Body body, List<ValidationException> exception)
void	LocalsValidator.validate(Body body, List<ValidationException> exception)
void	TrapsValidator.validate(Body body, List<ValidationException> exception)
void	UnitBoxesValidator.validate(Body body, List<ValidationException> exception)
void	UsesValidator.validate(Body body, List<ValidationException> exception)
void	ValueBoxesValidator.validate(Body body, List<ValidationException> exception)

Constructors in soot.validation with parameters of type Body

Constructor	Description
UnitValidationException(Unit concerned, Body body, String strMessage)	Creates a new ValidationException, treated as an error.
UnitValidationException(Unit concerned, Body body, String strMessage, boolean isWarning)	Creates a new ValidationException.

Uses of Body in soot.xml

Methods in soot.xml with parameters of type Body

Modifier and Type	Method	Description
void	TagCollector.collectBodyTags(Body b)