Uses of Class
jadx.core.dex.nodes.MethodNode

Packages that use MethodNode

Package	Description
jadx.analysis.callgraph
jadx.analysis.callgraph.api
jadx.api
jadx.api.deobf
jadx.api.deobf.impl
jadx.api.impl.passes
jadx.api.metadata.annotations
jadx.api.plugins.pass.types
jadx.api.usage
jadx.api.utils
jadx.core
jadx.core.clsp
jadx.core.codegen
jadx.core.codegen.json
jadx.core.deobf
jadx.core.deobf.conditions
jadx.core.dex.attributes
jadx.core.dex.attributes.nodes
jadx.core.dex.instructions
jadx.core.dex.instructions.args
jadx.core.dex.instructions.invokedynamic
jadx.core.dex.instructions.mods
jadx.core.dex.nodes
jadx.core.dex.nodes.utils
jadx.core.dex.regions.conditions
jadx.core.dex.trycatch
jadx.core.dex.visitors
jadx.core.dex.visitors.blocks
jadx.core.dex.visitors.debuginfo
jadx.core.dex.visitors.finaly
jadx.core.dex.visitors.finaly.traverser.state
jadx.core.dex.visitors.fixaccessmodifiers
jadx.core.dex.visitors.gradle
jadx.core.dex.visitors.kotlin
jadx.core.dex.visitors.regions
jadx.core.dex.visitors.regions.maker
jadx.core.dex.visitors.regions.variables
jadx.core.dex.visitors.rename
jadx.core.dex.visitors.shrink
jadx.core.dex.visitors.ssa
jadx.core.dex.visitors.typeinference
jadx.core.dex.visitors.usage
jadx.core.utils
jadx.core.utils.blocks
jadx.core.utils.exceptions

Uses of MethodNode in jadx.analysis.callgraph

Fields in jadx.analysis.callgraph declared as MethodNode

Modifier and Type	Field	Description
private final @Nullable MethodNode	CallGraphNode.mthNode

Methods in jadx.analysis.callgraph that return MethodNode

Modifier and Type	Method	Description
@Nullable MethodNode	CallGraphNode.getMethodNode()

Methods in jadx.analysis.callgraph with parameters of type MethodNode

Modifier and Type	Method	Description
private static CallGraphNode	CallGraphBuilder.getCallGraphNode(MethodNode mth, Map<MethodInfo,CallGraphNode> nodes, AtomicInteger nodeId)

Constructors in jadx.analysis.callgraph with parameters of type MethodNode

Modifier	Constructor	Description
	CallGraphNode(int id, MethodInfo mthInfo, @Nullable MethodNode mthNode)
	CallGraphNode(int id, MethodNode mthNode)

Uses of MethodNode in jadx.analysis.callgraph.api

Methods in jadx.analysis.callgraph.api that return MethodNode

Modifier and Type	Method	Description
@Nullable MethodNode	ICallGraphNode.getMethodNode()

Uses of MethodNode in jadx.api

Fields in jadx.api declared as MethodNode

Modifier and Type	Field	Description
private final MethodNode	JavaMethod.mth

Methods in jadx.api that return MethodNode

Modifier and Type	Method	Description
MethodNode	JavaMethod.getMethodNode()	Internal API.

Methods in jadx.api with parameters of type MethodNode

Modifier and Type	Method	Description
(package private) JavaMethod	JadxDecompiler.convertMethodNode(MethodNode mth)

Constructors in jadx.api with parameters of type MethodNode

Modifier	Constructor	Description
(package private)	JavaMethod(JavaClass cls, MethodNode m)

Uses of MethodNode in jadx.api.deobf

Methods in jadx.api.deobf with parameters of type MethodNode

Modifier and Type	Method	Description
IDeobfCondition.Action	IDeobfCondition.check(MethodNode mth)
String	IAliasProvider.forMethod(MethodNode mth)
boolean	IRenameCondition.shouldRename(MethodNode mth)

Uses of MethodNode in jadx.api.deobf.impl

Methods in jadx.api.deobf.impl with parameters of type MethodNode

Modifier and Type	Method	Description
boolean	AlwaysRename.shouldRename(MethodNode mth)
boolean	AnyRenameCondition.shouldRename(MethodNode mth)
boolean	CombineDeobfConditions.shouldRename(MethodNode mth)

Uses of MethodNode in jadx.api.impl.passes

Methods in jadx.api.impl.passes with parameters of type MethodNode

Modifier and Type	Method	Description
void	DecompilePassWrapper.visit(MethodNode mth)

Uses of MethodNode in jadx.api.metadata.annotations

Fields in jadx.api.metadata.annotations declared as MethodNode

Modifier and Type	Field	Description
private final MethodNode	VarNode.mth

Methods in jadx.api.metadata.annotations that return MethodNode

Modifier and Type	Method	Description
MethodNode	VarNode.getMth()

Methods in jadx.api.metadata.annotations with parameters of type MethodNode

Modifier and Type	Method	Description
static @Nullable VarNode	VarNode.get(MethodNode mth, CodeVar codeVar)
static @Nullable VarNode	VarNode.get(MethodNode mth, RegisterArg reg)
static @Nullable VarNode	VarNode.get(MethodNode mth, SSAVar ssaVar)
static @Nullable ICodeAnnotation	VarNode.getRef(MethodNode mth, RegisterArg reg)

Constructors in jadx.api.metadata.annotations with parameters of type MethodNode

Modifier	Constructor	Description
	VarNode(MethodNode mth, int reg, int ssa, ArgType type, String name)
protected	VarNode(MethodNode mth, SSAVar ssaVar)

Uses of MethodNode in jadx.api.plugins.pass.types

Methods in jadx.api.plugins.pass.types with parameters of type MethodNode

Modifier and Type	Method	Description
void	JadxDecompilePass.visit(MethodNode mth)	Visit method

Uses of MethodNode in jadx.api.usage

Methods in jadx.api.usage with parameters of type MethodNode

Modifier and Type	Method	Description
void	IUsageInfoVisitor.visitIsSelfCall(MethodNode mth, boolean isSelfCall)
void	IUsageInfoVisitor.visitMethodsUsage(MethodNode mth, List<MethodNode> methods)
void	IUsageInfoVisitor.visitMethodsUses(MethodNode mth, List<MethodNode> methods)
void	IUsageInfoVisitor.visitUnresolvedMethodsUsage(MethodNode mth, List<MethodInfo> methods)

Method parameters in jadx.api.usage with type arguments of type MethodNode

Modifier and Type	Method	Description
void	IUsageInfoVisitor.visitClassUseInMethods(ClassNode cls, List<MethodNode> methods)
void	IUsageInfoVisitor.visitFieldsUsage(FieldNode fld, List<MethodNode> methods)
void	IUsageInfoVisitor.visitMethodsUsage(MethodNode mth, List<MethodNode> methods)
void	IUsageInfoVisitor.visitMethodsUses(MethodNode mth, List<MethodNode> methods)

Uses of MethodNode in jadx.api.utils

Methods in jadx.api.utils with parameters of type MethodNode

Modifier and Type	Method	Description
static String	CodeUtils.extractMethodCode(MethodNode mth, ICodeInfo codeInfo)	Cut method code (including comments and annotations) from class code.
static int	CodeUtils.getMethodEnd(MethodNode mth, ICodeInfo codeInfo)	Search method end position in provided class code info.
private static int	CodeUtils.getMethodStart(MethodNode mth, ICodeInfo codeInfo)	Search first empty line before method definition to include comments and annotations

Uses of MethodNode in jadx.core

Methods in jadx.core with parameters of type MethodNode

Modifier and Type	Method	Description
boolean	ProcessClass.processMethodToVisitor(MethodNode mth, IDexTreeVisitor lastPassToProcess)
boolean	ProcessClass.processMethodUntilVisitor(MethodNode mth, String visitorName, boolean includeVisitor)

Uses of MethodNode in jadx.core.clsp

Methods in jadx.core.clsp with parameters of type MethodNode

Modifier and Type	Method	Description
private void	ClsSet.processMethodDetails(MethodNode mth, List<ClspMethod> methods)

Uses of MethodNode in jadx.core.codegen

Fields in jadx.core.codegen declared as MethodNode

Modifier and Type	Field	Description
protected final MethodNode	InsnGen.mth
private final MethodNode	MethodGen.mth
private final MethodNode	NameGen.mth
private final MethodNode	SimpleModeHelper.mth

Methods in jadx.core.codegen that return MethodNode

Modifier and Type	Method	Description
private MethodNode	MethodGen.getMethodForDefinition()
MethodNode	MethodGen.getMethodNode()

Methods in jadx.core.codegen with parameters of type MethodNode

Modifier and Type	Method	Description
static void	MethodGen.addFallbackInsns(ICodeWriter code, MethodNode mth, InsnNode[] insnArr, MethodGen.FallbackOption option)
void	AnnotationGen.addForMethod(ICodeWriter code, MethodNode mth)
private void	ClassGen.addMethod(ICodeWriter code, MethodNode mth)
void	ClassGen.addMethodCode(ICodeWriter code, MethodNode mth)
(package private) static void	ClassGen.addMthUsageInfo(ICodeWriter code, MethodNode mth)
private boolean	InsnGen.addOuterClassInstance(ConstructorInsn insn, ICodeWriter code, MethodNode callMth)
private void	MethodGen.addOverrideAnnotation(ICodeWriter code, MethodNode mth)
void	AnnotationGen.addThrows(MethodNode mth, ICodeWriter code)
(package private) void	InsnGen.generateMethodArguments(ICodeWriter code, BaseInvokeNode insn, int startArgNum, @Nullable MethodNode mthNode)
EncodedValue	AnnotationGen.getAnnotationDefaultValue(MethodNode mth)
private int	ClassGen.getEnumCtrSkipArgsCount(@Nullable MethodNode callMth)
static MethodGen	MethodGen.getFallbackMethodGen(MethodNode mth)	Return fallback variant of method codegen
private void	InsnGen.makeInlinedLambdaMethod(ICodeWriter code, InvokeCustomNode customNode, MethodNode callMth)
private InsnGen	ClassGen.makeInsnGen(MethodNode mth)
private void	InsnGen.makeInvokeCustomRaw(InvokeCustomRawNode insn, @Nullable MethodNode callMthNode, ICodeWriter code)
private boolean	ClassGen.skipMethod(MethodNode mth)	Additional checks for inlined methods

Constructors in jadx.core.codegen with parameters of type MethodNode

Modifier	Constructor	Description
	MethodGen(ClassGen classGen, MethodNode mth)
	NameGen(MethodNode mth, ClassGen classGen)
	SimpleModeHelper(MethodNode mth)

Uses of MethodNode in jadx.core.codegen.json

Methods in jadx.core.codegen.json with parameters of type MethodNode

Modifier and Type	Method	Description
private List<JsonCodeLine>	JsonCodeGen.fillMthCode(MethodNode mth, MethodGen mthGen)

Uses of MethodNode in jadx.core.deobf

Methods in jadx.core.deobf with parameters of type MethodNode

Modifier and Type	Method	Description
String	DeobfAliasProvider.forMethod(MethodNode mth)

Uses of MethodNode in jadx.core.deobf.conditions

Methods in jadx.core.deobf.conditions with parameters of type MethodNode

Modifier and Type	Method	Description
IDeobfCondition.Action	AbstractDeobfCondition.check(MethodNode mth)
IDeobfCondition.Action	BaseDeobfCondition.check(MethodNode mth)
IDeobfCondition.Action	DeobfLengthCondition.check(MethodNode mth)

Uses of MethodNode in jadx.core.dex.attributes

Fields in jadx.core.dex.attributes declared as MethodNode

Modifier and Type	Field	Description
private final MethodNode	FieldInitInsnAttr.mth

Methods in jadx.core.dex.attributes that return MethodNode

Modifier and Type	Method	Description
MethodNode	FieldInitInsnAttr.getInsnMth()

Constructors in jadx.core.dex.attributes with parameters of type MethodNode

Modifier	Constructor	Description
	FieldInitInsnAttr(MethodNode mth, InsnNode insn)

Uses of MethodNode in jadx.core.dex.attributes.nodes

Fields in jadx.core.dex.attributes.nodes declared as MethodNode

Modifier and Type	Field	Description
private final MethodNode	MethodBridgeAttr.bridgeMth
private final MethodNode	MethodReplaceAttr.replaceMth
private MethodNode	EnumClassAttr.staticMethod

Fields in jadx.core.dex.attributes.nodes with type parameters of type MethodNode

Modifier and Type	Field	Description
private SortedSet<MethodNode>	MethodOverrideAttr.relatedMthNodes	All method nodes from override hierarchy.

Methods in jadx.core.dex.attributes.nodes that return MethodNode

Modifier and Type	Method	Description
MethodNode	MethodBridgeAttr.getBridgeMth()
MethodNode	MethodReplaceAttr.getReplaceMth()
MethodNode	EnumClassAttr.getStaticMethod()

Methods in jadx.core.dex.attributes.nodes that return types with arguments of type MethodNode

Modifier and Type	Method	Description
SortedSet<MethodNode>	MethodOverrideAttr.getRelatedMthNodes()

Methods in jadx.core.dex.attributes.nodes with parameters of type MethodNode

Modifier and Type	Method	Description
static void	CodeFeaturesAttr.add(MethodNode mth, CodeFeaturesAttr.CodeFeature feature)
static boolean	CodeFeaturesAttr.contains(MethodNode mth, CodeFeaturesAttr.CodeFeature feature)
static MethodInlineAttr	MethodInlineAttr.inlineNotNeeded(MethodNode mth)
static boolean	SkipMethodArgsAttr.isSkip(@Nullable MethodNode mth, int argNum)
static MethodInlineAttr	MethodInlineAttr.markForInline(MethodNode mth, InsnNode replaceInsn)
void	EnumClassAttr.setStaticMethod(MethodNode staticMethod)
static void	SkipMethodArgsAttr.skipArg(MethodNode mth, int argNum)
static void	SkipMethodArgsAttr.skipArg(MethodNode mth, RegisterArg arg)

Method parameters in jadx.core.dex.attributes.nodes with type arguments of type MethodNode

Modifier and Type	Method	Description
void	MethodOverrideAttr.setRelatedMthNodes(SortedSet<MethodNode> relatedMthNodes)

Constructors in jadx.core.dex.attributes.nodes with parameters of type MethodNode

Modifier	Constructor	Description
	MethodBridgeAttr(MethodNode bridgeMth)
	MethodReplaceAttr(MethodNode replaceMth)
private	SkipMethodArgsAttr(MethodNode mth)

Constructor parameters in jadx.core.dex.attributes.nodes with type arguments of type MethodNode

Modifier	Constructor	Description
	MethodOverrideAttr(List<IMethodDetails> overrideList, SortedSet<MethodNode> relatedMthNodes, Set<IMethodDetails> baseMethods)

Uses of MethodNode in jadx.core.dex.instructions

Fields in jadx.core.dex.instructions declared as MethodNode

Modifier and Type	Field	Description
private final MethodNode	InsnDecoder.method

Methods in jadx.core.dex.instructions with parameters of type MethodNode

Modifier and Type	Method	Description
static InsnNode	InvokeCustomBuilder.build(MethodNode mth, InsnData insn, boolean isRange)

Constructors in jadx.core.dex.instructions with parameters of type MethodNode

Modifier	Constructor	Description
	InsnDecoder(MethodNode mthNode)

Uses of MethodNode in jadx.core.dex.instructions.args

Methods in jadx.core.dex.instructions.args with parameters of type MethodNode

Modifier and Type	Method	Description
RegisterArg	RegisterArg.duplicateWithNewSSAVar(MethodNode mth)
String	SSAVar.getDetailedVarInfo(MethodNode mth)
@Nullable("if wrap failed") InsnArg	InsnArg.wrapInstruction(MethodNode mth, InsnNode insn)
@Nullable("if wrap failed") InsnArg	InsnArg.wrapInstruction(MethodNode mth, InsnNode insn, boolean unbind)

Uses of MethodNode in jadx.core.dex.instructions.invokedynamic

Methods in jadx.core.dex.instructions.invokedynamic with parameters of type MethodNode

Modifier and Type	Method	Description
static InsnNode	CustomRawCall.build(MethodNode mth, InsnData insn, boolean isRange, List<EncodedValue> values)
private static List<InsnArg>	CustomRawCall.buildArgs(MethodNode mth, List<EncodedValue> values)
static InvokeCustomNode	CustomLambdaCall.buildLambdaMethodCall(MethodNode mth, InsnData insn, boolean isRange, List<EncodedValue> values)
private static @NotNull InvokeCustomNode	CustomLambdaCall.buildMethodCall(MethodNode mth, InsnData insn, boolean isRange, List<EncodedValue> values, IMethodHandle callMthHandle)

Uses of MethodNode in jadx.core.dex.instructions.mods

Methods in jadx.core.dex.instructions.mods with parameters of type MethodNode

Modifier and Type	Method	Description
private ConstructorInsn.CallType	ConstructorInsn.getCallType(MethodNode mth, ClassInfo classType, InsnArg instanceArg)

Constructors in jadx.core.dex.instructions.mods with parameters of type MethodNode

Modifier	Constructor	Description
	ConstructorInsn(MethodNode mth, InvokeNode invoke)
	ConstructorInsn(MethodNode mth, InvokeNode invoke, MethodInfo callMth)

Uses of MethodNode in jadx.core.dex.nodes

Fields in jadx.core.dex.nodes with type parameters of type MethodNode

Modifier and Type	Field	Description
private List<MethodNode>	ClassNode.methods
private Set<MethodNode>	MethodNode.methodsUsed
private Map<MethodInfo,MethodNode>	ClassNode.mthInfoMap
private List<MethodNode>	FieldNode.useIn
private List<MethodNode>	MethodNode.useIn
private List<MethodNode>	ClassNode.useInMth	Methods which uses this class (by instructions only, definition is excluded)

Methods in jadx.core.dex.nodes that return MethodNode

Modifier and Type	Method	Description
static MethodNode	MethodNode.build(ClassNode classNode, IMethodData methodData)
private @Nullable MethodNode	RootNode.deepResolveMethod(@NotNull ClassNode cls, String signature)
@Nullable MethodNode	ClassNode.getClassInitMth()
@Nullable MethodNode	ClassNode.getDefaultConstructor()
@NotNull MethodNode	RootNode.resolveDirectMethod(String rawClsName, String mthShortId)
@Nullable MethodNode	RootNode.resolveMethod(@NotNull MethodInfo mth)
MethodNode	ClassNode.searchMethod(MethodInfo mth)
MethodNode	ClassNode.searchMethodByShortId(String shortId)
@Nullable MethodNode	ClassNode.searchMethodByShortName(String name)	Return first method by original short name Note: methods are not unique by name (class can have several methods with same name but different signature)

Methods in jadx.core.dex.nodes that return types with arguments of type MethodNode

Modifier and Type	Method	Description
List<MethodNode>	ClassNode.getMethods()
Set<MethodNode>	MethodNode.getUsed()
List<MethodNode>	FieldNode.getUseIn()
List<MethodNode>	MethodNode.getUseIn()
List<MethodNode>	ClassNode.getUseInMth()

Methods in jadx.core.dex.nodes with parameters of type MethodNode

Modifier and Type	Method	Description
void	MethodNode.addUsed(MethodNode used)
void	FieldNode.addUseIn(MethodNode mth)
int	MethodNode.compareTo(@NotNull MethodNode o)
InsnNode	InsnNode.copyWithNewSsaVar(MethodNode mth)	See InsnNode.copy()

Method parameters in jadx.core.dex.nodes with type arguments of type MethodNode

Modifier and Type	Method	Description
void	MethodNode.setUsed(List<MethodNode> methodsUsed)
void	FieldNode.setUseIn(List<MethodNode> useIn)
void	MethodNode.setUseIn(List<MethodNode> useIn)
void	ClassNode.setUseInMth(List<MethodNode> useInMth)

Uses of MethodNode in jadx.core.dex.nodes.utils

Methods in jadx.core.dex.nodes.utils that return MethodNode

Modifier and Type	Method	Description
@Nullable MethodNode	MethodUtils.resolveMethod(BaseInvokeNode invokeNode)

Methods in jadx.core.dex.nodes.utils with parameters of type MethodNode

Modifier and Type	Method	Description
@Nullable ArgType	TypeUtils.checkForUnknownTypeVars(MethodNode mth, ArgType checkType)	Search for unknown type vars at current method.
private static Set<ArgType>	TypeUtils.collectKnownTypeVarsAtMethod(MethodNode mth)
boolean	TypeUtils.containsUnknownTypeVar(MethodNode mth, ArgType type)
ArgType	TypeUtils.expandTypeVariables(MethodNode mth, ArgType type)
Set<ArgType>	TypeUtils.getKnownTypeVarsAtMethod(MethodNode mth)
ClassInfo	MethodUtils.getMethodOriginDeclClass(MethodNode mth)
@Nullable IMethodDetails	MethodUtils.getOverrideBaseMth(MethodNode mth)

Uses of MethodNode in jadx.core.dex.regions.conditions

Fields in jadx.core.dex.regions.conditions declared as MethodNode

Modifier and Type	Field	Description
private final MethodNode	IfInfo.mth

Methods in jadx.core.dex.regions.conditions that return MethodNode

Modifier and Type	Method	Description
MethodNode	IfInfo.getMth()

Constructors in jadx.core.dex.regions.conditions with parameters of type MethodNode

Modifier	Constructor	Description
	IfInfo(MethodNode mth, IfCondition condition, BlockNode thenBlock, BlockNode elseBlock)
private	IfInfo(MethodNode mth, IfCondition condition, BlockNode thenBlock, BlockNode elseBlock, BlockSet mergedBlocks, Set<BlockNode> skipBlocks, List<InsnNode> forceInlineInsns)

Uses of MethodNode in jadx.core.dex.trycatch

Methods in jadx.core.dex.trycatch with parameters of type MethodNode

Modifier and Type	Method	Description
boolean	ExceptionHandler.addCatchType(MethodNode mth, @Nullable ClassInfo type)	Add exception type to catch block
void	ExceptionHandler.addCatchTypes(MethodNode mth, Collection<ClassInfo> types)
static ExceptionHandler	ExceptionHandler.build(MethodNode mth, int addr, @Nullable ClassInfo type)
TryEdgeScopeGroupMap	TryCatchBlockAttr.getExecutionScopeGroups(MethodNode mth)
Map<BlockNode,List<TryEdge>>	TryCatchBlockAttr.getHandlerFallthroughGroups(MethodNode mth, TryEdgeScopeGroupMap scopeGroups)
Map<BlockNode,List<TryEdge>>	TryEdgeScopeGroupMap.getScopeEnds(MethodNode mth)	Returns a map of all points where edges meet with each other, dictating the end of that edge's scope.
List<BlockNode>	TryCatchBlockAttr.getSearchBlocksFromFallthroughGroups(MethodNode mth, ExceptionHandler finallyHandler, Map<BlockNode,List<TryEdge>> fallthroughGroups)

Constructors in jadx.core.dex.trycatch with parameters of type MethodNode

Modifier	Constructor	Description
	TryEdgeScopeGroupMap(MethodNode mth, TryCatchBlockAttr tryCatch, int initialCapacity)

Uses of MethodNode in jadx.core.dex.visitors

Fields in jadx.core.dex.visitors declared as MethodNode

Modifier and Type	Field	Description
(package private) final MethodNode	EnumVisitor.EnumData.classInitMth
(package private) final MethodNode	ExtractFieldInit.ConstructorInitInfo.constructorMth

Fields in jadx.core.dex.visitors with type parameters of type MethodNode

Modifier and Type	Field	Description
private final Consumer<MethodNode>	MethodVisitor.visitor

Methods in jadx.core.dex.visitors that return MethodNode

Modifier and Type	Method	Description
private @Nullable MethodNode	MethodThrowsVisitor.searchOverriddenMethod(ClassNode cls, MethodInfo mth, String signature)
private @Nullable MethodNode	OverrideMethodVisitor.searchOverriddenMethod(ClassNode cls, MethodNode mth, String signature)

Methods in jadx.core.dex.visitors that return types with arguments of type MethodNode

Modifier and Type	Method	Description
private static List<MethodNode>	ExtractFieldInit.getConstructorsList(ClassNode cls)
private @NotNull List<MethodNode>	OverrideMethodVisitor.getMethodNodes(MethodNode mth, List<IMethodDetails> overrideList)

Methods in jadx.core.dex.visitors with parameters of type MethodNode

Modifier and Type	Method	Description
private static void	ExtractFieldInit.addFieldInitAttr(MethodNode mth, FieldNode field, IndexInsnNode putInsn)
static void	ModVisitor.addFieldUsage(IFieldInfoRef fieldData, MethodNode mth)
private static @Nullable MethodInlineAttr	MarkMethodsForInline.addInlineAttr(MethodNode mth, InsnNode insn, boolean isCopy)
private static void	ProcessInstructionsVisitor.addJump(MethodNode mth, InsnNode[] insnByOffset, int offset, int target)
private void	PrepareForCodeGen.addNullCasts(MethodNode mth, BlockNode block)
private MethodOverrideAttr	OverrideMethodVisitor.applyOverrideAttr(MethodNode mth, List<IMethodDetails> overrideList, Set<IMethodDetails> baseMethods, boolean update)
private void	GenericTypesVisitor.attachGenericTypesInfo(MethodNode mth, ConstructorInsn insn)
private static boolean	ProcessAnonymous.badMethodUsage(ClassNode cls, MethodNode useMth, AccessInfo accessFlags)
private @Nullable MethodOverrideAttr	OverrideMethodVisitor.buildOverrideAttr(MethodNode mth, List<IMethodDetails> overrideList, Set<IMethodDetails> baseMethods, @Nullable MethodOverrideAttr attr)
private static boolean	ConstInlineVisitor.canInline(MethodNode mth, RegisterArg arg)
private static boolean	ProcessMethodsForInline.canInline(MethodNode mth)
private static boolean	ProcessMethodsForInline.canInlineMethod(MethodNode mth, AccessInfo accessFlags)
private static boolean	ConstructorVisitor.canRemoveConstructor(MethodNode mth, ConstructorInsn co)
private boolean	CheckCode.canRemoveMethod(MethodNode mth)
private List<ArgType>	SignatureProcessor.checkArgTypes(MethodNode mth, SignatureParser sp, List<ArgType> parsedArgTypes)
private static boolean	ModVisitor.checkArrSizes(MethodNode mth, NewArrayNode newArrInsn, FillArrayInsn fillArrInsn)
private void	PrepareForCodeGen.checkEncodedValue(MethodNode mth, EncodedValue encodedValue)
private static boolean	ProcessAnonymous.checkForCommonFieldInit(MethodNode ctrMth)	Checks: + all in constructors + all usage in one class - same field put (ignored: methods not loaded yet)
private static boolean	ProcessAnonymous.checkForInstanceFieldUsage(ClassNode cls, MethodNode ctr)
private static void	ConstInlineVisitor.checkInsn(MethodNode mth, InsnNode insn, List<InsnNode> toRemove)
private void	MethodThrowsVisitor.checkInsn(MethodNode mth, InsnNode insn, Set<String> excludedExceptions, boolean skipExceptions)
void	CheckCode.checkInstructions(MethodNode mth)
private void	OverrideMethodVisitor.checkMethodSignatureCollisions(MethodNode mth, boolean rename)
private static boolean	ProcessAnonymous.checkMethodsUsage(ClassNode cls, MethodNode ctr, MethodNode ctrUseMth)
private static boolean	ClassModifier.checkSyntheticWrapper(MethodNode mth, InsnNode insn)
private static AnonymousClassAttr.InlineType	ProcessAnonymous.checkUsage(ClassNode cls, MethodNode ctr)	Checks: - class have only one constructor which used only once (allow common code for field init) - methods or fields not used outside (allow only nested inner classes with synthetic usage) - if constructor used only in class init check if possible inline by instance field
private static List<ExtractFieldInit.FieldInitInfo>	ExtractFieldInit.collectFieldsInit(ClassNode cls, MethodNode mth, InsnType putType)
private void	PrepareForCodeGen.collectFieldsUsageInAnnotations(MethodNode mth, AttrNode attrNode)
private static List<InsnNode>	SimplifyVisitor.collectUseChain(MethodNode mth, InvokeNode insn, RegisterArg instanceArg)
private static ArithNode	SimplifyVisitor.convertFieldArith(MethodNode mth, InsnNode insn)	Convert field arith operation to arith instruction (IPUT (ARITH (IGET, lit)) -> ARITH ((IGET)) = lit))
private static InsnNode	SimplifyVisitor.convertInvoke(MethodNode mth, InvokeNode insn)	Simplify chains of calls to StringBuilder#append() plus constructor of StringBuilder.
private static InsnNode	SimplifyVisitor.convertStringBuilderChain(MethodNode mth, InvokeNode toStrInsn, List<InsnNode> chain)
private static List<ExceptionHandler>	AttachTryCatchVisitor.convertToHandlers(MethodNode mth, ICatch catchBlock, InsnNode[] insnByOffset)
private boolean	AdjustForIfMergeVisitor.couldMerge(MethodNode mth, BlockNode pred, BlockNode blk, BlockNode succ)
private static @Nullable ExceptionHandler	AttachTryCatchVisitor.createHandler(MethodNode mth, InsnNode[] insnByOffset, int handlerOffset, @Nullable ClassInfo type)
private static boolean	MoveInlineVisitor.deleteMove(MethodNode mth, InsnNode move)
private void	AdjustForIfMergeVisitor.doMove(MethodNode mth, BlockNode target, BlockNode bottomIf, List<InsnNode> movableInstructions)
private List<ArgType>	MethodInvokeVisitor.expandTypes(MethodNode parentMth, IMethodDetails methodDetails, List<ArgType> castTypes)	Use generified types if available
private static void	ProcessMethodsForInline.fixClassDependencies(MethodNode mth)
private static void	ShadowFieldVisitor.fixFieldAccess(MethodNode mth, FieldInfo fieldInfo, ShadowFieldVisitor.FieldFixType fieldFixType, InsnArg arg)
private static void	ModVisitor.fixFieldUsage(MethodNode mth, IndexInsnNode insn)	If field is not visible from use site => cast to origin class
private boolean	OverrideMethodVisitor.fixMethodArgTypes(MethodNode mth, IMethodDetails baseMth, OverrideMethodVisitor.SuperTypesData superData)
private boolean	OverrideMethodVisitor.fixMethodReturnType(MethodNode mth, IMethodDetails baseMth, OverrideMethodVisitor.SuperTypesData superData)
private static void	ModVisitor.fixPrimitiveCast(MethodNode mth, BlockNode block, int i, InsnNode insn)
private static void	ShadowFieldVisitor.fixShadowFieldAccess(MethodNode mth, Map<String,ShadowFieldVisitor.FieldFixInfo> fixInfoMap)
private void	EnumVisitor.fixValuesAccess(MethodNode mth, FieldInfo valuesFieldInfo, ArgType clsType, @Nullable MethodNode valuesMethod)
private static boolean	MarkMethodsForInline.fixVisibilityOfInlineCode(MethodNode mth, InsnNode insn)
private static Map<InsnArg,FieldNode>	AnonymousClassVisitor.getArgsToFieldsMapping(MethodNode mth, List<InsnNode> usedInsns)
private ArgType	MethodInvokeVisitor.getCallClassFromInvoke(MethodNode parentMth, BaseInvokeNode invokeInsn, MethodInfo callMth)
private static InsnNode	AttachCommentsVisitor.getInsnByOffset(MethodNode mth, int offset)
private @NotNull List<MethodNode>	OverrideMethodVisitor.getMethodNodes(MethodNode mth, List<IMethodDetails> overrideList)
static void	InitCodeVariables.initCodeVar(MethodNode mth, RegisterArg regArg)
private static void	InitCodeVariables.initCodeVars(MethodNode mth)
private static void	ProcessInstructionsVisitor.initJumps(MethodNode mth, InsnNode[] insnByOffset)
private static void	AttachTryCatchVisitor.initTryCatches(MethodNode mth, InsnNode[] insnByOffset, List<ITry> tries)
private static void	ModVisitor.inlineCMPInsns(MethodNode mth, BlockNode block, int i, InsnNode insn, InsnRemover remover)	Inline CMP instructions into 'if' to help conditions merging
private void	InlineMethods.inlineMethod(MethodNode mth, MethodNode callMth, MethodInlineAttr mia, BlockNode block, InvokeNode insn)
private static @Nullable MethodInlineAttr	MarkMethodsForInline.inlineMth(MethodNode mth)
private static RegisterArg	ConstructorVisitor.insertPhiInsn(MethodNode mth, BlockNode curBlock, RegisterArg instArg, ConstructorInsn otherCtr)
private boolean	InlineMethods.isAssignNeeded(InsnNode inlineInsn, InvokeNode parentInsn, MethodNode callMthNode)
private boolean	EnumVisitor.isDefaultConstructor(MethodNode mth, String shortId)
private static boolean	ModVisitor.isFieldVisibleInMethod(FieldNode field, MethodNode mth)
private boolean	OverrideMethodVisitor.isMethodVisibleInCls(MethodNode superMth, ClassNode cls)	NOTE: Simplified version of method from ModVisitor.isFieldVisibleInMethod
private static boolean	ClassModifier.isNonDefaultConstructorExists(MethodNode defCtor)
private static boolean	MarkMethodsForInline.isSyntheticAccessPattern(MethodNode mth, InsnNode firstInsn, InsnNode retInsn)
private boolean	MethodThrowsVisitor.isThrowsRequired(MethodNode mth, ArgType type)
private boolean	EnumVisitor.isValuesMethod(MethodNode mth, ArgType clsType)
private static void	ModVisitor.iterativeRemoveStep(MethodNode mth)
private static InsnNode	ModVisitor.makeFilledArrayInsn(MethodNode mth, NewArrayNode newArrayNode, FillArrayInsn insn)
private static String	OverrideMethodVisitor.makeNewAlias(MethodNode mth)
private void	EnumVisitor.markArgsForSkip(MethodNode mth)
private static void	ClassModifier.modifySyntheticMethod(ClassNode cls, MethodNode mth, InsnNode insn, List<RegisterArg> args)	Remove synthetic constructor and redirect calls to existing constructor
private void	PrepareForCodeGen.moveConstructorInConstructor(MethodNode mth)	Check that 'super' or 'this' call in constructor is a first instruction.
static void	MoveInlineVisitor.moveInline(MethodNode mth)
private void	SignatureProcessor.parseMethodSignature(MethodNode mth)
static void	ConstInlineVisitor.process(MethodNode mth)
static @Nullable MethodInlineAttr	MarkMethodsForInline.process(MethodNode mth)
private static void	AnonymousClassVisitor.processAnonymousConstructor(MethodNode mth)
private static void	ModVisitor.processAnonymousConstructor(MethodNode mth, ConstructorInsn co)	For args in anonymous constructor invoke apply: - forbid inline into constructor call - make variables final (compiler require this implicitly)
private static void	ModVisitor.processArith(MethodNode mth, ClassNode parentClass, ArithNode arithNode)
private static InsnNode	SimplifyVisitor.processCast(MethodNode mth, IndexInsnNode castInsn, @Nullable InsnNode parentInsn)
private static @Nullable ConstructorInsn	ConstructorVisitor.processConstructor(MethodNode mth, ConstructorInsn co)	Replace call of synthetic constructor with all 'null' args to a non-synthetic or default constructor if possible.
private void	EnumVisitor.processConstructorInsn(EnumVisitor.EnumData data, EnumClassAttr.EnumField enumField, MethodNode classInitMth)
private static void	AttachCommentsVisitor.processCustomAttach(MethodNode mth, IJavaCodeRef codeRef, ICodeComment comment)
private static boolean	FixSwitchOverEnum.processDirectEnumSwitch(MethodNode mth, SwitchInsn swInsn, InvokeNode invInsn, InsnArg arg)
private static boolean	FixSwitchOverEnum.processEnumSwitch(MethodNode mth, SwitchInsn insn)
private static boolean	ReplaceNewArray.processInsn(MethodNode mth, List<InsnNode> instructions, int i, InsnRemover remover)
private static void	ShadowFieldVisitor.processInsn(MethodNode mth, InsnNode insn, Map<String,ShadowFieldVisitor.FieldFixInfo> fixInfoMap)
private void	MethodThrowsVisitor.processInstructions(MethodNode mth)
private static boolean	ConstructorVisitor.processInvoke(MethodNode mth, BlockNode block, int indexInBlock, InsnRemover remover)
private void	MethodInvokeVisitor.processInvoke(MethodNode parentMth, BaseInvokeNode invokeInsn)
private void	InlineMethods.processInvokeInsn(MethodNode mth, BlockNode block, InvokeNode insn)
private static boolean	MoveInlineVisitor.processMove(MethodNode mth, InsnNode move)
private static void	ModVisitor.processMoveException(MethodNode mth, BlockNode block, InsnNode insn, InsnRemover remover)
private void	OverrideMethodVisitor.processMth(MethodNode mth, OverrideMethodVisitor.SuperTypesData superData)
private static boolean	ReplaceNewArray.processNewArray(MethodNode mth, NewArrayNode newArrayInsn, List<InsnNode> instructions, InsnRemover remover)
private void	MethodInvokeVisitor.processOverloaded(MethodNode parentMth, BaseInvokeNode invokeInsn, IMethodDetails mthDetails)
private MethodOverrideAttr	OverrideMethodVisitor.processOverrideMethods(MethodNode mth, OverrideMethodVisitor.SuperTypesData superData)
private static boolean	FixSwitchOverEnum.processRemappedEnumSwitch(MethodNode mth, SwitchInsn insn, InsnNode wrapInsn, InsnArg arg)
private static boolean	ExtractFieldInit.processStaticFields(ClassNode cls, MethodNode classInitMth)
private static InsnNode	ConstructorVisitor.removeAssignChain(MethodNode mth, InsnNode insn, InsnRemover remover, InsnType insnType)	Remove instructions on 'move' chain until instruction with type 'insnType'
private static boolean	ClassModifier.removeBridgeMethod(ClassNode cls, MethodNode mth)
private static void	ModVisitor.removeCheckCast(MethodNode mth, BlockNode block, int i, IndexInsnNode insn)
private static void	ClassModifier.removeEmptyMethods(MethodNode mth)	Remove public empty constructors (static or default)
private static boolean	ClassModifier.removeFieldUsageFromConstructor(MethodNode mth, FieldNode field, ClassNode fieldsCls)
private static void	ModVisitor.removeStep(MethodNode mth, InsnRemover remover)	Remove unnecessary instructions
private static void	SimplifyVisitor.removeStringBuilderInsns(MethodNode mth, InvokeNode toStrInsn, List<InsnNode> chain)	Remove and unbind all instructions with StringBuilder
private static void	ClassModifier.removeSyntheticMethods(MethodNode mth)
private static boolean	ConstInlineVisitor.replaceArg(MethodNode mth, RegisterArg arg, InsnArg constArg, InsnNode constInsn)
private void	InlineMethods.replaceClsUsage(MethodNode mth, MethodNode inlinedMth, ClassNode parentClass)
private static boolean	ConstInlineVisitor.replaceConst(MethodNode mth, InsnNode constInsn, InsnArg constArg)
private static void	ModVisitor.replaceConst(MethodNode mth, ClassNode parentClass, BlockNode block, int i, InsnNode insn)
private static InsnArg	ReplaceNewArray.replaceConstInArg(MethodNode mth, InsnArg valueArg)
private static void	ModVisitor.replaceConstKeys(MethodNode mth, ClassNode parentClass, SwitchInsn insn)
private void	ModVisitor.replaceConstsInAnnotationForMethodParamsAttr(ClassNode cls, MethodNode m)
private static boolean	ConstructorVisitor.replaceInvoke(MethodNode mth)
private boolean	InlineMethods.replaceRegs(MethodNode mth, MethodNode callMth, MethodInlineAttr mia, InvokeNode insn, InsnNode inlCopy)
private static void	ModVisitor.replaceStep(MethodNode mth, InsnRemover remover)
static void	InitCodeVariables.rerun(MethodNode mth)
void	DotGraphVisitor.save(File dir, MethodNode mth)
private List<ArgType>	MethodInvokeVisitor.searchCastTypes(MethodNode parentMth, IMethodDetails mthDetails, List<IMethodDetails> overloadedMethods, List<ArgType> compilerVarTypes)
private @Nullable ConstructorInsn	PrepareForCodeGen.searchConstructorCall(MethodNode mth)
private @Nullable ConstructorInsn	EnumVisitor.searchEnumSuperCtrInsn(MethodNode ctrMth)
private @Nullable MethodNode	OverrideMethodVisitor.searchOverriddenMethod(ClassNode cls, MethodNode mth, String signature)
private boolean	EnumVisitor.simpleValueOfMth(MethodNode mth, ArgType clsType)
private void	SimplifyVisitor.simplifyArgs(MethodNode mth, InsnNode insn)
private boolean	SimplifyVisitor.simplifyBlock(MethodNode mth, BlockNode block)
private static void	SimplifyVisitor.simplifyIf(MethodNode mth, IfNode insn)	Simplify 'cmp' instruction in if condition
private InsnNode	SimplifyVisitor.simplifyInsn(MethodNode mth, InsnNode insn, @Nullable InsnNode parentInsn)
private InsnNode	SimplifyVisitor.simplifyStringConstructor(MethodNode mth, ConstructorInsn insn)
private static void	SimplifyVisitor.simplifyTernary(MethodNode mth, TernaryInsn insn)	Simplify condition in ternary operation
private ArgType	OverrideMethodVisitor.updateArgType(MethodNode mth, IMethodDetails baseMth, OverrideMethodVisitor.SuperTypesData superData, int argNum)
private boolean	OverrideMethodVisitor.updateReturnType(MethodNode mth, IMethodDetails baseMth, OverrideMethodVisitor.SuperTypesData superData)
private void	InlineMethods.updateUsageInfo(MethodNode mth, MethodNode inlinedMth, InsnNode insn)
private boolean	SignatureProcessor.validateAndApplyTypes(MethodNode mth, SignatureParser sp, ArgType retType, List<ArgType> argTypes)
private void	PrepareForCodeGen.verifyNullCast(MethodNode mth, InsnArg arg)
void	AbstractVisitor.visit(MethodNode mth)
void	AdjustForIfMergeVisitor.visit(MethodNode mth)
void	ApplyVariableNames.visit(MethodNode mth)
void	AttachMethodDetails.visit(MethodNode mth)
void	AttachTryCatchVisitor.visit(MethodNode mth)
void	CheckCode.visit(MethodNode mth)
void	ConstInlineVisitor.visit(MethodNode mth)
void	ConstructorVisitor.visit(MethodNode mth)
void	DeboxingVisitor.visit(MethodNode mth)
static void	DepthTraversal.visit(IDexTreeVisitor visitor, MethodNode mth)
void	DotGraphVisitor.visit(MethodNode mth)
void	FallbackModeVisitor.visit(MethodNode mth)
void	FixSwitchOverEnum.visit(MethodNode mth)
void	GenericTypesVisitor.visit(MethodNode mth)
void	IDexTreeVisitor.visit(MethodNode mth)	Visit method
void	InitCodeVariables.visit(MethodNode mth)
void	InlineMethods.visit(MethodNode mth)
void	MarkMethodsForInline.visit(MethodNode mth)
void	MethodInvokeVisitor.visit(MethodNode mth)
void	MethodThrowsVisitor.visit(MethodNode mth)
void	MethodVisitor.visit(MethodNode mth)
void	ModVisitor.visit(MethodNode mth)
void	MoveInlineVisitor.visit(MethodNode mth)
void	PrepareForCodeGen.visit(MethodNode mth)
void	ProcessInstructionsVisitor.visit(MethodNode mth)
void	ReplaceNewArray.visit(MethodNode mth)
void	ShadowFieldVisitor.visit(MethodNode mth)
void	SimplifyVisitor.visit(MethodNode mth)
private void	MethodThrowsVisitor.visitThrows(MethodNode mth, ArgType excType, Set<String> excludedExceptions)

Constructors in jadx.core.dex.visitors with parameters of type MethodNode

Modifier	Constructor	Description
private	ConstructorInitInfo(MethodNode constructorMth, List<ExtractFieldInit.FieldInitInfo> fieldInits)
	EnumData(ClassNode cls, MethodNode classInitMth, List<BlockNode> staticBlocks)

Constructor parameters in jadx.core.dex.visitors with type arguments of type MethodNode

Modifier	Constructor	Description
	MethodVisitor(String name, Consumer<MethodNode> visitor)

Uses of MethodNode in jadx.core.dex.visitors.blocks

Methods in jadx.core.dex.visitors.blocks with parameters of type MethodNode

Modifier and Type	Method	Description
private static void	BlockSplitter.addTempConnectionsForExcHandlers(MethodNode mth, Map<Integer,BlockNode> blocksMap)	Connect exception handlers to the throw block.
(package private) static BlockNode	BlockSplitter.blockSplitTop(MethodNode mth, BlockNode block)
private static void	BlockExceptionHandler.checkForMultiCatch(MethodNode mth, List<TryCatchBlockAttr> tryBlocks)
private static void	BlockProcessor.checkForUnreachableBlocks(MethodNode mth)
private static boolean	BlockProcessor.checkLoops(MethodNode mth, BlockNode block)
private static void	BlockProcessor.clearBlocksState(MethodNode mth)
private static void	BlockExceptionHandler.clearTryBlocks(MethodNode mth, List<TryCatchBlockAttr> tryBlocks)
private static void	FixMultiEntryLoops.colorDFS(MethodNode mth, FixMultiEntryLoops.BlockColor[] colors, BlockNode block)
static void	DominatorTree.compute(MethodNode mth)
static void	PostDominatorTree.compute(MethodNode mth)
static void	DominatorTree.computeDominanceFrontier(MethodNode mth)
private static void	BlockProcessor.computeDominators(MethodNode mth)
private static void	BlockProcessor.computeUnreachableFromBlock(Set<BlockNode> toRemove, BlockNode block, MethodNode mth)
private static void	BlockExceptionHandler.connectExcHandlers(MethodNode mth, List<TryCatchBlockAttr> tryBlocks)	Wrap try blocks with top/bottom splitter and connect them to handler block.
(package private) static BlockNode	BlockSplitter.connectNewBlock(MethodNode mth, BlockNode block, int offset)
(package private) static List<BlockNode>	BlockSplitter.copyBlocksTree(MethodNode mth, List<BlockNode> blocks)
private static boolean	BlockProcessor.deduplicateBlockInsns(MethodNode mth, BlockNode block)
static void	BlockSplitter.detachMarkedBlocks(MethodNode mth)
private static void	FixMultiEntryLoops.detectSpecialEdges(MethodNode mth)
private static boolean	BlockProcessor.duplicateSimpleMoveBlock(MethodNode mth, BlockNode block)	Duplicate block if it contains only one 'move' insn and all predecessors are 'switch' and 'if'.
private static void	FixMultiEntryLoops.dupPath(MethodNode mth, BlockNode start, BlockNode center, BlockNode end)	Duplicate 'center' block on path from 'start' to 'end'
private static void	BlockSplitter.expandMoveMulti(MethodNode mth)
private static boolean	FixMultiEntryLoops.fixLoop(MethodNode mth, SpecialEdgeAttr backEdge, List<SpecialEdgeAttr> crossEdges)
private static boolean	BlockProcessor.fixUnreachableSplitCross(MethodNode mth, BlockNode splitCross)	Attempts to remove an unreachable synthetic split cross block that has been added previously, along with the associated bottom splitter.
private static BlockNode	BlockExceptionHandler.getTopSplitterBlock(MethodNode mth, BlockNode top)
private static boolean	BlockProcessor.independentBlockTreeMod(MethodNode mth)
private static void	BlockSplitter.initBlocksInTargetNodes(MethodNode mth)	Init 'then' and 'else' blocks for 'if' instruction.
private static void	BlockExceptionHandler.initExcHandlers(MethodNode mth)
static BlockNode	BlockSplitter.insertBlockBetween(MethodNode mth, BlockNode source, BlockNode target)
private static boolean	BlockProcessor.insertBlocksForBreak(MethodNode mth, LoopInfo loop)	Insert additional blocks for possible 'break' insertion
private static boolean	BlockProcessor.insertBlocksForContinue(MethodNode mth, LoopInfo loop)	Insert additional blocks for possible 'continue' insertion
private static boolean	BlockProcessor.insertPreHeader(MethodNode mth, LoopInfo loop)	Insert simple path block before loop header
private static boolean	FixMultiEntryLoops.isEndBlockEntry(MethodNode mth, SpecialEdgeAttr backEdge, List<SpecialEdgeAttr> crossEdges)
private static boolean	FixMultiEntryLoops.isHeaderSuccessorEntry(MethodNode mth, SpecialEdgeAttr backEdge, List<SpecialEdgeAttr> crossEdges)
private static void	BlockProcessor.markLoops(MethodNode mth)
private static void	BlockProcessor.mergeConstAndReturnBlocks(MethodNode mth, BlockNode retBlock, BlockNode pred)
private static boolean	BlockProcessor.mergeConstReturn(MethodNode mth)
private static boolean	BlockExceptionHandler.mergeMultiCatch(MethodNode mth, TryCatchBlockAttr tryCatch)
private static boolean	BlockProcessor.modifyBlocksTree(MethodNode mth)
private static List<TryCatchBlockAttr>	BlockExceptionHandler.prepareTryBlocks(MethodNode mth)
static boolean	BlockExceptionHandler.process(MethodNode mth)
static boolean	FixMultiEntryLoops.process(MethodNode mth)
static void	ResolveJavaJSR.process(MethodNode mth)
private static void	ResolveJavaJSR.processBlocks(MethodNode mth, BlockNode retBlock, BlockNode startBlock, List<BlockNode> jsrBlocks, List<BlockNode> dupBlocks)
private static void	BlockProcessor.processBlocksTree(MethodNode mth)
private static void	BlockExceptionHandler.processCatchAttr(MethodNode mth)
private static void	BlockProcessor.processNestedLoops(MethodNode mth)
private static void	BlockProcessor.registerLoops(MethodNode mth)
(package private) static boolean	BlockSplitter.removeEmptyDetachedBlocks(MethodNode mth)
private static void	BlockExceptionHandler.removeExcHandler(MethodNode mth, ExceptionHandler excHandler)
private static void	BlockProcessor.removeFromMethod(Set<BlockNode> toRemove, MethodNode mth)
private static void	BlockSplitter.removeInsns(MethodNode mth)
private static void	BlockSplitter.removeJumpAttr(MethodNode mth)
static void	BlockProcessor.removeMarkedBlocks(MethodNode mth)
private static void	BlockExceptionHandler.removeMonitorExitFromExcHandler(MethodNode mth, ExceptionHandler excHandler)
static void	BlockProcessor.removeUnreachableBlock(BlockNode blockToRemove, MethodNode mth)
private static void	BlockProcessor.removeUnreachableBlocks(MethodNode mth)
private static void	BlockExceptionHandler.removeUnusedExcHandlers(MethodNode mth, List<TryCatchBlockAttr> tryBlocks, BlockSet blocks)	Remove excHandlers that were not used when connecting.
private static boolean	ResolveJavaJSR.resolve(MethodNode mth)
private static void	ResolveJavaJSR.resolveForRetBlock(MethodNode mth, BlockNode retBlock)
private static @Nullable BlockNode	BlockExceptionHandler.searchBottomBlock(MethodNode mth, List<BlockNode> blocks)
private static BlockNode	BlockExceptionHandler.searchTopBlock(MethodNode mth, List<BlockNode> blocks)
private static void	BlockSplitter.setupConnectionsFromJumps(MethodNode mth, Map<Integer,BlockNode> blocksMap)
private static void	BlockSplitter.setupExitConnections(MethodNode mth)
private static boolean	BlockProcessor.simplifyLoopEnd(MethodNode mth, LoopInfo loop)
private static List<BlockNode>	DominatorTree.sortBlocks(MethodNode mth)
private static void	BlockExceptionHandler.sortHandlers(MethodNode mth, List<TryCatchBlockAttr> tryBlocks)
private static Map<Integer,BlockNode>	BlockSplitter.splitBasicBlocks(MethodNode mth)
private static boolean	BlockProcessor.splitExitBlocks(MethodNode mth)
private static boolean	BlockProcessor.splitLoops(MethodNode mth, BlockNode block, List<LoopInfo> loops)
private static boolean	BlockProcessor.splitReturn(MethodNode mth, BlockNode returnBlock)	Splice return block if several predecessors presents
private static boolean	BlockProcessor.splitThrow(MethodNode mth, BlockNode exitBlock)
(package private) static BlockNode	BlockSplitter.startNewBlock(MethodNode mth, int offset)
static void	BlockProcessor.updateBlocksData(MethodNode mth)	Recalculate all additional info attached to blocks:
(package private) static void	BlockProcessor.updateCleanSuccessors(MethodNode mth)
private static void	BlockProcessor.updateExitBlockConnections(MethodNode mth)
void	BlockFinisher.visit(MethodNode mth)
void	BlockProcessor.visit(MethodNode mth)
void	BlockSplitter.visit(MethodNode mth)
private static boolean	BlockExceptionHandler.wrapBlocksWithTryCatch(MethodNode mth, TryCatchBlockAttr tryCatchBlock)

Uses of MethodNode in jadx.core.dex.visitors.debuginfo

Methods in jadx.core.dex.visitors.debuginfo with parameters of type MethodNode

Modifier and Type	Method	Description
private static void	DebugInfoApplyVisitor.applyDebugInfo(MethodNode mth)
static boolean	DebugInfoApplyVisitor.applyDebugInfo(MethodNode mth, SSAVar ssaVar, ArgType type, String varName)
static boolean	DebugInfoApplyVisitor.applyDebugInfo(MethodNode mth, SSAVar ssaVar, RegisterArg arg)
private void	DebugInfoAttachVisitor.attachDebugInfo(MethodNode mth, List<ILocalVar> localVars, InsnNode[] insnArr)
private void	DebugInfoAttachVisitor.attachSourceLines(MethodNode mth, Map<Integer,Integer> lineMapping, InsnNode[] insnArr)
private static boolean	DebugInfoAttachVisitor.checkSignature(MethodNode mth, ArgType type, ArgType gType)
private static void	DebugInfoApplyVisitor.fixLinesForReturn(MethodNode mth)	Fix debug info for splitter 'return' instructions
private static void	DebugInfoApplyVisitor.fixNamesForPhiInsns(MethodNode mth)
static ArgType	DebugInfoAttachVisitor.getVarType(MethodNode mth, ILocalVar var)
private void	DebugInfoAttachVisitor.processDebugInfo(MethodNode mth, IDebugInfo debugInfo)
private void	DebugInfoApplyVisitor.processMethodParametersAttribute(MethodNode mth)
private static void	DebugInfoApplyVisitor.searchAndApplyVarDebugInfo(MethodNode mth, SSAVar ssaVar)
private static void	DebugInfoApplyVisitor.searchDebugInfoByOffset(MethodNode mth, SSAVar ssaVar)
private void	DebugInfoAttachVisitor.setMethodSourceLine(MethodNode mth, InsnNode[] insnArr)	Set method source line from first instruction
void	DebugInfoApplyVisitor.visit(MethodNode mth)
void	DebugInfoAttachVisitor.visit(MethodNode mth)

Uses of MethodNode in jadx.core.dex.visitors.finaly

Methods in jadx.core.dex.visitors.finaly with parameters of type MethodNode

Modifier and Type	Method	Description
private static @Nullable List<BlockNode>	MarkFinallyVisitor.cutHandlerBlocks(MethodNode mth, MarkFinallyVisitor.TryExtractInfo tryInfo, ExceptionHandler handler)
private static boolean	MarkFinallyVisitor.extractFinally(MethodNode mth, MarkFinallyVisitor.TryExtractInfo tryInfo)	Search and mark common code from 'try' block and 'handlers'.
private static @Nullable Map<InsnNode,List<InsnNode>>	MarkFinallyVisitor.findCommonInsns(MethodNode mth, MarkFinallyVisitor.TryExtractInfo tryInfo)
static TryCatchEdgeBlockMap	TryCatchEdgeBlockMap.getAllInScope(MethodNode mth, TryCatchBlockAttr tryCatch, TryEdgeScopeGroupMap scopeGroups, ExceptionHandler finallyHandler, Map<BlockNode,List<TryEdge>> scopeTerminusGroups)
private static @Nullable MarkFinallyVisitor.TryExtractInfo	MarkFinallyVisitor.getTryBlockData(MethodNode mth, TryCatchBlockAttr tryBlock)	For a given try block, attempts to calculate try block data.
private static boolean	MarkFinallyVisitor.processTryBlock(MethodNode mth, MarkFinallyVisitor.TryExtractInfo tryInfo)	Processes a try block, attempting to extract a finally by locating common instruction patterns between all try branches.
private static void	MarkFinallyVisitor.resetTryBlocks(MethodNode mth, List<TryCatchBlockAttr> tryBlocks)
private static void	MarkFinallyVisitor.undoFinallyVisitor(MethodNode mth)	Reload method without applying this visitor
void	MarkFinallyVisitor.visit(MethodNode mth)

Uses of MethodNode in jadx.core.dex.visitors.finaly.traverser.state

Fields in jadx.core.dex.visitors.finaly.traverser.state declared as MethodNode

Modifier and Type	Field	Description
private final MethodNode	TraverserGlobalCommonState.mth

Methods in jadx.core.dex.visitors.finaly.traverser.state that return MethodNode

Modifier and Type	Method	Description
MethodNode	TraverserGlobalCommonState.getMethodNode()

Constructors in jadx.core.dex.visitors.finaly.traverser.state with parameters of type MethodNode

Modifier	Constructor	Description
	TraverserActivePathState(MethodNode mth, SameInstructionsStrategy sameInstructionsStrategy, BlockNode finallyBlockTerminus, BlockNode candidateBlockTerminus, List<BlockNode> finallyBlocks, List<BlockNode> candidateBlocks)	Creates a new instance of a traversal active path.
	TraverserGlobalCommonState(MethodNode mth)

Uses of MethodNode in jadx.core.dex.visitors.fixaccessmodifiers

Methods in jadx.core.dex.visitors.fixaccessmodifiers with parameters of type MethodNode

Modifier and Type	Method	Description
private void	FixAccessModifiers.fixMethodVisibility(MethodNode mth)
void	FixAccessModifiers.visit(MethodNode mth)

Uses of MethodNode in jadx.core.dex.visitors.gradle

Methods in jadx.core.dex.visitors.gradle with parameters of type MethodNode

Modifier and Type	Method	Description
void	NonFinalResIdsVisitor.visit(MethodNode mth)
boolean	NonFinalResIdsVisitor.visitRegion(MethodNode mth, IRegion region)

Uses of MethodNode in jadx.core.dex.visitors.kotlin

Methods in jadx.core.dex.visitors.kotlin with parameters of type MethodNode

Modifier and Type	Method	Description
private @Nullable String	ProcessKotlinInternals.getConstString(MethodNode mth, InsnNode insn, int arg)
private void	ProcessKotlinInternals.processInvoke(MethodNode mth, InsnNode insn)
private void	ProcessKotlinInternals.processMth(MethodNode mth)

Uses of MethodNode in jadx.core.dex.visitors.regions

Fields in jadx.core.dex.visitors.regions declared as MethodNode

Modifier and Type	Field	Description
private final MethodNode	SwitchOverStringVisitor.SwitchData.mth

Methods in jadx.core.dex.visitors.regions that return MethodNode

Modifier and Type	Method	Description
MethodNode	SwitchOverStringVisitor.SwitchData.getMth()

Methods in jadx.core.dex.visitors.regions with parameters of type MethodNode

Modifier and Type	Method	Description
private static boolean	LoopRegionVisitor.argInLoop(MethodNode mth, LoopRegion loopRegion, RegisterArg arg)
private static boolean	LoopRegionVisitor.assignOnlyInLoop(MethodNode mth, LoopRegion loopRegion, RegisterArg arg)
private boolean	ReturnVisitor.ReturnRemoverVisitor.blockNotInLoop(MethodNode mth, BlockNode block)
private static boolean	ProcessTryCatchRegions.checkAndWrap(MethodNode mth, List<TryCatchBlockAttr> tryBlocks, IRegion region)
private static LoopType	LoopRegionVisitor.checkArrayForEach(MethodNode mth, LoopRegion loopRegion, InsnNode initInsn, InsnNode incrInsn, IfCondition condition)
private static boolean	LoopRegionVisitor.checkForIndexedLoop(MethodNode mth, LoopRegion loopRegion, IfCondition condition)	Check for indexed loop.
private static boolean	LoopRegionVisitor.checkIterableForEach(MethodNode mth, LoopRegion loopRegion, IfCondition condition)
private static List<TryCatchBlockAttr>	ProcessTryCatchRegions.collectTryCatchBlocks(MethodNode mth)
boolean	AbstractRegionVisitor.enterRegion(MethodNode mth, IRegion region)
boolean	CleanRegions.RemoveRegionVisitor.enterRegion(MethodNode mth, IRegion region)
boolean	DebugRegionCounter.RegionCounterVisitor.enterRegion(MethodNode mth, IRegion region)
boolean	IfRegionVisitor.ProcessIfRegionVisitor.enterRegion(MethodNode mth, IRegion region)
boolean	IRegionVisitor.enterRegion(MethodNode mth, IRegion region)
boolean	LoopRegionVisitor.enterRegion(MethodNode mth, IRegion region)
boolean	ReturnVisitor.ReturnRemoverVisitor.enterRegion(MethodNode mth, IRegion region)
boolean	SwitchBreakVisitor.BaseSwitchRegionVisitor.enterRegion(MethodNode mth, IRegion region)
boolean	TernaryMod.enterRegion(MethodNode mth, IRegion region)
boolean	TracedRegionVisitor.enterRegion(MethodNode mth, IRegion region)
private static boolean	LoopRegionVisitor.fixIterableType(MethodNode mth, InsnArg iterableArg, RegisterArg iterVar)
private static String	CheckRegions.getBlockInsnStr(MethodNode mth, IBlock block)
private static boolean	IfRegionVisitor.isSimpleExitBlock(MethodNode mth, IContainer container)
void	AbstractRegionVisitor.leaveRegion(MethodNode mth, IRegion region)
void	DebugRegionCounter.RegionCounterVisitor.leaveRegion(MethodNode mth, IRegion region)
void	IRegionVisitor.leaveRegion(MethodNode mth, IRegion region)
void	LoopRegionVisitor.leaveRegion(MethodNode mth, IRegion region)
void	PostProcessRegions.leaveRegion(MethodNode mth, IRegion region)
void	SwitchBreakVisitor.BaseSwitchRegionVisitor.leaveRegion(MethodNode mth, IRegion region)
void	SwitchBreakVisitor.IterativeSwitchRegionVisitor.leaveRegion(MethodNode mth, IRegion region)
void	TracedRegionVisitor.leaveRegion(MethodNode mth, IRegion region)
private static boolean	TernaryMod.makeTernaryInsn(MethodNode mth, IfRegion ifRegion)
private static void	IfRegionVisitor.markElseIfChains(MethodNode mth, IfRegion ifRegion)	Mark if-else-if chains
private static void	IfRegionVisitor.orderBranches(MethodNode mth, IfRegion ifRegion)
static void	CleanRegions.process(MethodNode mth)
private static void	IfRegionVisitor.process(MethodNode mth)
(package private) static void	PostProcessRegions.process(MethodNode mth)
static void	ProcessTryCatchRegions.process(MethodNode mth)
static void	TernaryMod.process(MethodNode mth)
void	AbstractRegionVisitor.processBlock(MethodNode mth, IBlock block)
void	DebugRegionCounter.RegionCounterVisitor.processBlock(MethodNode mth, IBlock container)
void	IRegionVisitor.processBlock(MethodNode mth, IBlock container)
void	LoopRegionVisitor.processBlock(MethodNode mth, IBlock container)
void	TracedRegionVisitor.processBlock(MethodNode mth, IBlock block)
void	ReturnVisitor.ReturnRemoverVisitor.processBlockTraced(MethodNode mth, IBlock container, IRegion currentRegion)
abstract void	TracedRegionVisitor.processBlockTraced(MethodNode mth, IBlock block, IRegion parentRegion)
private void	SwitchBreakVisitor.ExtractCommonBreak.processBranchRegion(MethodNode mth, IRegion region)
private static void	RegionMakerVisitor.processForceInlineInsns(MethodNode mth)
static void	IfRegionVisitor.processIfRequested(MethodNode mth)
private static boolean	LoopRegionVisitor.processLoopRegion(MethodNode mth, LoopRegion loopRegion)
private static boolean	TernaryMod.processOneBranchTernary(MethodNode mth, IfRegion ifRegion)	Convert one variable change with only 'then' branch: 'if (c) {r = a;}' to 'r = c ? a : r' Convert if 'r' used only once
abstract void	SwitchBreakVisitor.BaseSwitchRegionVisitor.processRegion(MethodNode mth, IRegion region)
void	SwitchBreakVisitor.ExtractCommonBreak.processRegion(MethodNode mth, IRegion region)
void	SwitchBreakVisitor.RemoveUnreachableBreak.processRegion(MethodNode mth, IRegion region)
private static boolean	TernaryMod.processRegion(MethodNode mth, IRegion region)
private static boolean	IfRegionVisitor.removeRedundantElseBlock(MethodNode mth, IfRegion ifRegion)
private static void	TernaryMod.replaceWithTernary(MethodNode mth, IfRegion ifRegion, BlockNode block, InsnNode insn)
private boolean	SwitchOverStringVisitor.restoreSwitchOverString(MethodNode mth, IRegion part1Region)
private static void	SwitchBreakVisitor.runSwitchTraverse(MethodNode mth, Supplier<SwitchBreakVisitor.BaseSwitchRegionVisitor> builder)
static void	DepthRegionTraversal.traverse(MethodNode mth, IContainer container, IRegionVisitor visitor)
static void	DepthRegionTraversal.traverse(MethodNode mth, IRegionVisitor visitor)
static void	DepthRegionTraversal.traverseIncludingExcHandlers(MethodNode mth, IRegionIterativeVisitor visitor)
private static void	DepthRegionTraversal.traverseInternal(MethodNode mth, IRegionVisitor visitor, IContainer startContainer)
static void	DepthRegionTraversal.traverseIterative(MethodNode mth, IRegionIterativeVisitor visitor)
private static boolean	DepthRegionTraversal.traverseIterativeStepInternal(MethodNode mth, IRegionIterativeVisitor visitor, IRegion startRegion)
static <R> R	DepthRegionTraversal.traversePartial(MethodNode mth, IContainer container, IRegionPartialVisitor<R> visitor)
static <R> R	DepthRegionTraversal.traversePartial(MethodNode mth, IRegionPartialVisitor<R> visitor)
private static <R> R	DepthRegionTraversal.traversePartialInternal(MethodNode mth, IRegionPartialVisitor<R> visitor, IContainer startContainer)
private static boolean	LoopRegionVisitor.usedOnlyInLoop(MethodNode mth, LoopRegion loopRegion, RegisterArg arg)
private static boolean	TernaryMod.verifyLineHints(MethodNode mth, InsnNode thenInsn, InsnNode elseInsn)
void	CheckRegions.visit(MethodNode mth)
void	CleanRegions.visit(MethodNode mth)
void	DebugRegionCounter.visit(MethodNode mth)
void	IfRegionVisitor.visit(MethodNode mth)
R	IRegionPartialVisitor.visit(MethodNode mth, IContainer container)	Visit all containers in region until stopped
void	LoopRegionVisitor.visit(MethodNode mth)
void	RegionMakerVisitor.visit(MethodNode mth)
void	ReturnVisitor.visit(MethodNode mth)
void	SwitchBreakVisitor.visit(MethodNode mth)
void	SwitchOverStringVisitor.visit(MethodNode mth)
boolean	IfRegionVisitor.RemoveRedundantElseVisitor.visitRegion(MethodNode mth, IRegion region)
boolean	IRegionIterativeVisitor.visitRegion(MethodNode mth, IRegion region)	If return 'true' traversal will be restarted.
boolean	SwitchOverStringVisitor.visitRegion(MethodNode mth, IRegion region)
boolean	TernaryMod.visitRegion(MethodNode mth, IRegion region)

Constructors in jadx.core.dex.visitors.regions with parameters of type MethodNode

Modifier	Constructor	Description
private	SwitchData(MethodNode mth, IRegion part1Region)

Uses of MethodNode in jadx.core.dex.visitors.regions.maker

Fields in jadx.core.dex.visitors.regions.maker declared as MethodNode

Modifier and Type	Field	Description
private final MethodNode	ExcHandlersRegionMaker.mth
private final MethodNode	IfRegionMaker.mth
private final MethodNode	LoopRegionMaker.mth
private final MethodNode	RegionMaker.mth
private final MethodNode	SwitchRegionMaker.mth
private final MethodNode	SynchronizedRegionMaker.mth

Methods in jadx.core.dex.visitors.regions.maker with parameters of type MethodNode

Modifier and Type	Method	Description
private static boolean	SynchronizedRegionMaker.canRemoveSyncBlock(MethodNode mth, InsnNode synchInsn)
(package private) static @Nullable BlockNode	IfRegionMaker.findOutBlock(MethodNode mth, BlockNode thenBlock, BlockNode elseBlock)
private static BlockNode	IfRegionMaker.getBranchBlock(BlockNode first, BlockNode second, Set<BlockNode> skipBlocks, MethodNode mth)
static void	SwitchRegionMaker.insertBreaks(MethodNode mth, SwitchRegion sw)	Insert 'break' for all cases in switch region Executed in PostProcessRegions after try/catch wrap to handle all blocks
private static void	SwitchRegionMaker.insertBreaksForCase(MethodNode mth, SwitchRegion switchRegion, IContainer caseContainer)	Add break to every exit edge from 'case' region.
(package private) static boolean	IfRegionMaker.isCandidateForOutBlock(MethodNode mth, BlockNode thenBlock, BlockNode elseBlock, BlockNode candidate)
(package private) static @Nullable IfInfo	IfRegionMaker.makeIfInfo(MethodNode mth, BlockNode ifBlock)
static void	SynchronizedRegionMaker.removeSynchronized(MethodNode mth)

Constructors in jadx.core.dex.visitors.regions.maker with parameters of type MethodNode

Modifier	Constructor	Description
	ExcHandlersRegionMaker(MethodNode mth, RegionMaker regionMaker)
(package private)	IfRegionMaker(MethodNode mth, RegionMaker regionMaker)
(package private)	LoopRegionMaker(MethodNode mth, RegionMaker regionMaker, IfRegionMaker ifMaker)
	RegionMaker(MethodNode mth)
	RegionStack(MethodNode mth)
(package private)	SwitchRegionMaker(MethodNode mth, RegionMaker regionMaker)
(package private)	SynchronizedRegionMaker(MethodNode mth, RegionMaker regionMaker)

Uses of MethodNode in jadx.core.dex.visitors.regions.variables

Methods in jadx.core.dex.visitors.regions.variables with parameters of type MethodNode

Modifier and Type	Method	Description
private void	ProcessVariables.checkCodeVars(MethodNode mth, List<CodeVar> codeVars)
private List<CodeVar>	ProcessVariables.collectCodeVars(MethodNode mth)
private void	ProcessVariables.declareVar(MethodNode mth, CodeVar codeVar, List<VarUsage> usageList)
void	CollectUsageRegionVisitor.processBlockTraced(MethodNode mth, IBlock block, IRegion curRegion)
private static void	ProcessVariables.removeUnusedResults(MethodNode mth)
void	ProcessVariables.visit(MethodNode mth)

Uses of MethodNode in jadx.core.dex.visitors.rename

Methods in jadx.core.dex.visitors.rename with parameters of type MethodNode

Modifier and Type	Method	Description
private static boolean	RenameVisitor.canRename(MethodNode mth)
private static void	CodeRenameVisitor.processRename(MethodNode mth, IJavaCodeRef codeRef, ICodeRename rename)

Uses of MethodNode in jadx.core.dex.visitors.shrink

Methods in jadx.core.dex.visitors.shrink with parameters of type MethodNode

Modifier and Type	Method	Description
private static boolean	CodeShrinkVisitor.assignInline(MethodNode mth, RegisterArg arg, InsnNode assignInsn, BlockNode assignBlock)
private static boolean	CodeShrinkVisitor.canMoveBetweenBlocks(MethodNode mth, InsnNode assignInsn, BlockNode assignBlock, BlockNode useBlock, InsnNode useInsn)
private static void	CodeShrinkVisitor.checkInline(MethodNode mth, BlockNode block, InsnList insnList, List<WrapInfo> wrapList, ArgsInfo argsInfo, RegisterArg arg)
private static boolean	CodeShrinkVisitor.inline(MethodNode mth, RegisterArg arg, InsnNode insn, BlockNode block)
private static void	CodeShrinkVisitor.shrinkBlock(MethodNode mth, BlockNode block)
static void	CodeShrinkVisitor.shrinkMethod(MethodNode mth)
private static void	CodeShrinkVisitor.simplifyMoveInsns(MethodNode mth, BlockNode block)
private static boolean	CodeShrinkVisitor.varWithSameNameExists(MethodNode mth, SSAVar inlineVar)
void	CodeShrinkVisitor.visit(MethodNode mth)

Uses of MethodNode in jadx.core.dex.visitors.ssa

Fields in jadx.core.dex.visitors.ssa declared as MethodNode

Modifier and Type	Field	Description
private final MethodNode	LiveVarAnalysis.mth
private final MethodNode	RenameState.mth

Methods in jadx.core.dex.visitors.ssa with parameters of type MethodNode

Modifier and Type	Method	Description
static PhiInsn	SSATransform.addPhi(MethodNode mth, BlockNode block, int regNum)
private static void	SSATransform.fixLastAssignInTry(MethodNode mth)	Fix last try/catch assign instruction
private static void	SSATransform.fixPhiInTryCatch(MethodNode mth, PhiInsn phi, ExcHandlerAttr handlerAttr)
private static boolean	SSATransform.fixPhiWithSameArgs(MethodNode mth, BlockNode block, PhiInsn phi)
private static boolean	SSATransform.fixUselessPhi(MethodNode mth)
private static void	SSATransform.hidePhiInsns(MethodNode mth)
static RenameState	RenameState.init(MethodNode mth)
private static boolean	SSATransform.inlinePhiInsn(MethodNode mth, BlockNode block, PhiInsn phi, RegisterArg inlineArg)
private static void	SSATransform.placePhi(MethodNode mth, int regNum, LiveVarAnalysis la)
private static void	SSATransform.process(MethodNode mth)
private static boolean	SSATransform.removeBlockerInsns(MethodNode mth)
private static boolean	SSATransform.removePhiList(MethodNode mth, List<PhiInsn> insnToRemove)
private static void	SSATransform.removeUnusedInvokeResults(MethodNode mth)
private static void	SSATransform.renameVariables(MethodNode mth)
private static void	SSATransform.renameVarsInBlock(MethodNode mth, RenameState state)
private static boolean	SSATransform.replacePhiWithMove(MethodNode mth, BlockNode block, PhiInsn phi, RegisterArg arg)
private static boolean	SSATransform.shouldSkipInsnResult(MethodNode mth, InsnNode insn, ExcHandlerAttr handlerAttr)
private static void	SSATransform.tryToFixUselessPhi(MethodNode mth)
void	SSATransform.visit(MethodNode mth)

Constructors in jadx.core.dex.visitors.ssa with parameters of type MethodNode

Modifier	Constructor	Description
	LiveVarAnalysis(MethodNode mth)
private	RenameState(MethodNode mth, BlockNode block, SSAVar[] vars, int[] versions)

Uses of MethodNode in jadx.core.dex.visitors.typeinference

Fields in jadx.core.dex.visitors.typeinference declared as MethodNode

Modifier and Type	Field	Description
private final MethodNode	TypeSearch.mth
private final MethodNode	TypeUpdateInfo.mth

Fields in jadx.core.dex.visitors.typeinference with type parameters of type MethodNode

Modifier and Type	Field	Description
private List<Function<MethodNode,Boolean>>	FixTypesVisitor.resolvers

Methods in jadx.core.dex.visitors.typeinference that return MethodNode

Modifier and Type	Method	Description
MethodNode	TypeUpdateInfo.getMth()

Methods in jadx.core.dex.visitors.typeinference with parameters of type MethodNode

Modifier and Type	Method	Description
TypeUpdateResult	TypeUpdate.apply(MethodNode mth, SSAVar ssaVar, ArgType candidateType)	Perform type checking and type propagation for all related variables
private TypeUpdateResult	TypeUpdate.apply(MethodNode mth, SSAVar ssaVar, ArgType candidateType, TypeUpdateFlags flags)
TypeUpdateResult	TypeUpdate.applyDebugInfo(MethodNode mth, SSAVar ssaVar, ArgType candidateType)
private Boolean	FixTypesVisitor.applyFieldType(MethodNode mth)	Use type for var assigned from field (IGET or SGET).
TypeUpdateResult	TypeUpdate.applyWithWiderAllow(MethodNode mth, SSAVar ssaVar, ArgType candidateType)	Allow wider types for apply from debug info and some special cases
TypeUpdateResult	TypeUpdate.applyWithWiderIgnSame(MethodNode mth, SSAVar ssaVar, ArgType candidateType)	Force type setting
private void	TypeInferenceVisitor.assignImmutableTypes(MethodNode mth)
private boolean	FixTypesVisitor.calculateFromBounds(MethodNode mth, SSAVar ssaVar)
private void	TypeInferenceVisitor.calculateFromBounds(MethodNode mth, SSAVar ssaVar)
private boolean	FixTypesVisitor.checkAndSplitConstInsn(MethodNode mth, SSAVar var)
private boolean	FixTypesVisitor.checkRawType(MethodNode mth, SSAVar var, ArgType objType)
private static boolean	FixTypesVisitor.checkTypes(MethodNode mth)	Check if all types resolved
private boolean	FixTypesVisitor.deduceType(MethodNode mth, SSAVar var)
private boolean	FixTypesVisitor.dupConst(MethodNode mth, SSAVar var)
private boolean	FixTypesVisitor.fixBooleanUsage(MethodNode mth, RegisterArg boundArg)
(package private) void	TypeInferenceVisitor.initTypeBounds(MethodNode mth)	Collect initial type bounds from assign and usages
private @Nullable IndexInsnNode	FixTypesVisitor.insertAssignCast(MethodNode mth, SSAVar var, ArgType castType)
private boolean	FixTypesVisitor.insertExplicitUseCast(MethodNode mth, SSAVar ssaVar, RegisterArg useArg, ArgType fieldType)
private void	FixTypesVisitor.insertMove(MethodNode mth, BlockNode blockNode, PhiInsn phiInsn, RegisterArg reg)
private int	FixTypesVisitor.insertMovesForPhi(MethodNode mth, PhiInsn phiInsn, boolean apply)
private @Nullable IndexInsnNode	FixTypesVisitor.insertUseCast(MethodNode mth, RegisterArg useArg, ArgType castType)
private int	FixTypesVisitor.insertUseCasts(MethodNode mth, SSAVar var)
private boolean	FixTypesVisitor.processIncompatiblePrimitives(MethodNode mth, SSAVar var)
private boolean	FixTypesVisitor.runMultiVariableSearch(MethodNode mth)
(package private) boolean	TypeInferenceVisitor.runTypePropagation(MethodNode mth)	Guess type from usage and try to set it to current variable and all connected instructions with TypeUpdate.apply(MethodNode, SSAVar, ArgType)
private boolean	FixTypesVisitor.setBestType(MethodNode mth, SSAVar ssaVar)
private void	TypeInferenceVisitor.setBestType(MethodNode mth, SSAVar ssaVar)
private void	TypeInferenceVisitor.setImmutableType(MethodNode mth, SSAVar ssaVar)
private static boolean	FixTypesVisitor.splitByPhi(MethodNode mth, SSAVar var)	For every PHI make separate CONST insn
private boolean	FixTypesVisitor.tryDeduceTypes(MethodNode mth)
private boolean	FixTypesVisitor.tryFieldTypeWithNewCasts(MethodNode mth, SSAVar ssaVar, boolean insertCasts)
private int	FixTypesVisitor.tryInsertAdditionalInsn(MethodNode mth, PhiInsn phiInsn)	Add MOVE instruction before PHI in bound blocks to make 'soft' type link.
private boolean	FixTypesVisitor.tryInsertAdditionalMove(MethodNode mth)
private boolean	FixTypesVisitor.tryInsertCasts(MethodNode mth)
private int	FixTypesVisitor.tryInsertVarCast(MethodNode mth, SSAVar var)
private boolean	FixTypesVisitor.tryPossibleTypes(MethodNode mth, SSAVar var, ArgType type)
private boolean	FixTypesVisitor.tryRawType(MethodNode mth, SSAVar var)
private boolean	FixTypesVisitor.tryRemoveGenerics(MethodNode mth)
private boolean	FixTypesVisitor.tryRestoreTypeVarCasts(MethodNode mth)	Fix check casts to type var extend type: <T extends Comparable> T var = (Comparable) obj; => T var = (T) obj;
private boolean	FixTypesVisitor.trySplitConstInsns(MethodNode mth)
private boolean	FixTypesVisitor.tryToFixIncompatiblePrimitives(MethodNode mth)
private boolean	FixTypesVisitor.tryToForceImmutableTypes(MethodNode mth)
private boolean	FixTypesVisitor.tryWiderObjects(MethodNode mth, SSAVar var)
void	FinishTypeInference.visit(MethodNode mth)
void	FixTypesVisitor.visit(MethodNode mth)
void	TypeInferenceVisitor.visit(MethodNode mth)

Constructors in jadx.core.dex.visitors.typeinference with parameters of type MethodNode

Modifier	Constructor	Description
	TypeSearch(MethodNode mth)
	TypeSearchState(MethodNode mth)
	TypeUpdateInfo(MethodNode mth, TypeUpdateFlags flags, JadxArgs args)

Uses of MethodNode in jadx.core.dex.visitors.usage

Fields in jadx.core.dex.visitors.usage with type parameters of type MethodNode

Modifier and Type	Field	Description
private final UseSet<ClassNode,MethodNode>	UsageInfo.clsUseInMth
private final UseSet<FieldNode,MethodNode>	UsageInfo.fieldUsage
private final UseSet<MethodNode,MethodNode>	UsageInfo.mthUsage
private final UseSet<MethodNode,MethodNode>	UsageInfo.mthUsage
private final UseSet<MethodNode,MethodNode>	UsageInfo.mthUses
private final UseSet<MethodNode,MethodNode>	UsageInfo.mthUses
private final Map<MethodNode,Boolean>	UsageInfo.selfCalls
private final UseSet<MethodNode,MethodInfo>	UsageInfo.unresolvedMthUsage

Methods in jadx.core.dex.visitors.usage that return types with arguments of type MethodNode

Modifier and Type	Method	Description
private List<MethodNode>	UsageInfo.resolveMthList(List<MethodNode> mthNodeList)

Methods in jadx.core.dex.visitors.usage with parameters of type MethodNode

Modifier and Type	Method	Description
void	UsageInfo.clsUse(MethodNode mth, ArgType useType)
void	UsageInfo.clsUse(MethodNode mth, ClassNode useCls)
void	UsageInfo.fieldUse(MethodNode mth, FieldNode useFld)
void	UsageInfo.methodUse(MethodNode mth, MethodNode useMth)	Add method usage: useMth occurrence found in mth code
private static void	UsageInfoVisitor.processInsn(RootNode root, MethodNode mth, InsnData insnData, UsageInfo usageInfo)
private static void	UsageInfoVisitor.processInstructions(MethodNode mth, UsageInfo usageInfo)
private static void	UsageInfoVisitor.processMethod(MethodNode mth, UsageInfo usageInfo)
private static void	UsageInfoVisitor.processMethodAnnotations(MethodNode mth, UsageInfo usageInfo)
static void	UsageInfoVisitor.replaceMethodUsage(MethodNode mergeIntoMth, MethodNode sourceMth)
void	UsageInfo.unresolvedMethodUse(MethodNode mth, MethodInfo useMth)	Add method usage: useMth occurrence found in mth code

Method parameters in jadx.core.dex.visitors.usage with type arguments of type MethodNode

Modifier and Type	Method	Description
private List<MethodNode>	UsageInfo.resolveMthList(List<MethodNode> mthNodeList)

Uses of MethodNode in jadx.core.utils

Fields in jadx.core.utils declared as MethodNode

Modifier and Type	Field	Description
private final MethodNode	InsnRemover.mth

Fields in jadx.core.utils with type parameters of type MethodNode

Modifier and Type	Field	Description
static final Predicate<MethodNode>	DebugUtils.TEST_MTH_FILTER

Methods in jadx.core.utils with parameters of type MethodNode

Modifier and Type	Method	Description
private static void	BlockUtils.addExcHandler(MethodNode mth, ExceptionHandler handler, BitSet set)
static void	RegionUtils.addToAll(MethodNode mth, IContainer container, AFlag flag)
static List<BlockNode>	BlockUtils.bitSetToBlocks(MethodNode mth, BitSet bs)
static @Nullable BlockNode	BlockUtils.bitSetToOneBlock(MethodNode mth, BitSet bs)
static BitSet	BlockUtils.blocksToBitSet(MethodNode mth, Collection<BlockNode> blocks)
private void	DotGraphUtils.checkAndFixFloatingBlocks(MethodNode mth, BlockNode block, Set<IBlock> regionBlocks)	A block is floating if it exists in no regions at all.
private static void	DebugChecks.checkBlock(MethodNode mth, BlockNode block, Supplier<String> source)
private static void	DebugChecks.checkInsn(MethodNode mth, BlockNode block, InsnNode insn)
static void	DebugChecks.checkMethod(MethodNode mth)
private static void	DebugChecks.checkPHI(MethodNode mth)
private static void	DebugChecks.checkPhiArg(MethodNode mth, PhiInsn phiInsn, RegisterArg arg, Supplier<String> argName)
private static void	DebugChecks.checkRegisterArg(MethodNode mth, RegisterArg reg)
private static void	DebugChecks.checkSSAVars(MethodNode mth)
private static void	DebugChecks.checkVar(MethodNode mth, InsnNode insn, RegisterArg reg)
static void	BlockUtils.cleanBitSet(MethodNode mth, BitSet bs)	Remove exception handlers from block nodes bitset
static List<BlockNode>	BlockUtils.collectAllPredecessors(MethodNode mth, BlockNode startBlock)
static List<BlockNode>	BlockUtils.collectAllSuccessors(MethodNode mth, BlockNode startBlock, boolean clean)
static List<BlockNode>	BlockUtils.collectAllSuccessorsUntil(MethodNode mth, BlockNode startBlock, boolean clean, Predicate<BlockNode> stopCondition)
private static void	BlockUtils.collectAllSuccessorsUntil(MethodNode mth, List<BlockNode> blocks, BlockNode currentBlock, boolean clean, Predicate<BlockNode> stopCondition)
static List<BlockNode>	BlockUtils.collectBlocksDominatedBy(MethodNode mth, BlockNode dominator, BlockNode start)	Collect all block dominated by 'dominator', starting from 'start'
static Set<BlockNode>	BlockUtils.collectBlocksDominatedByWithExcHandlers(MethodNode mth, BlockNode dominator, BlockNode start)	Collect all block dominated by 'dominator', starting from 'start', including exception handlers
static List<InsnNode>	RegionUtils.collectInsns(MethodNode mth, IContainer container)
static List<BlockNode>	BlockUtils.collectPredecessors(MethodNode mth, BlockNode start, Collection<BlockNode> stopBlocks)
static BitSet	BlockUtils.copyBlocksBitSet(MethodNode mth, BitSet bitSet)
static void	InsnRemover.delistPhi(MethodNode mth, PhiInsn phiInsn)
static void	DebugUtils.dump(MethodNode mth)
static void	DebugUtils.dump(MethodNode mth, String desc)
static void	DebugUtils.dumpRaw(MethodNode mth, String desc)
static void	DebugUtils.dumpRaw(MethodNode mth, String desc, Predicate<MethodNode> dumpCondition)
static void	DebugUtils.dumpRawTest(MethodNode mth, String desc)
void	DotGraphUtils.dumpToFile(MethodNode mth)
void	DotGraphUtils.dumpToFile(MethodNode mth, File dir)
@Nullable String	DotGraphUtils.dumpToString(MethodNode mth)
static void	BlockUtils.forEachBlockFromBitSet(MethodNode mth, BitSet bs, Consumer<BlockNode> consumer)
static @Nullable BlockNode	BlockUtils.getBlockByInsn(MethodNode mth, @Nullable InsnNode insn)
static @Nullable BlockNode	BlockUtils.getBlockByInsn(MethodNode mth, @Nullable InsnNode insn, List<BlockNode> blocks)
private static BlockNode	BlockUtils.getBlockByWrappedInsn(MethodNode mth, InsnNode insn)
static @Nullable BlockNode	BlockUtils.getBottomCommonPredecessor(MethodNode mth, List<BlockNode> blocks, Set<BlockNode> containedBlocks)
static @Nullable BlockNode	BlockUtils.getBottomCommonPredecessor(MethodNode mth, List<BlockNode> blocks, Set<BlockNode> containedBlocks, boolean addTopBlock)
static @Nullable CatchAttr	BlockUtils.getCatchAttrForInsn(MethodNode mth, InsnNode insn)
static @Nullable BlockNode	BlockUtils.getCommonDominator(MethodNode mth, List<BlockNode> blocks)	Search the lowest common ancestor in dominator tree for input set.
File	DotGraphUtils.getFullFile(MethodNode mth)
File	DotGraphUtils.getFullFile(MethodNode mth, File outDir)
static List<LoopInfo>	RegionUtils.getLoopsStartInRegion(MethodNode mth, IRegion r)
static @Nullable IContainer	RegionUtils.getNextContainer(MethodNode mth, IRegion region)
static @Nullable InsnNode	BlockUtils.getOnlyOneInsnFromMth(MethodNode mth)	Return insn if it is only one instruction in this method.
static File	DotGraphUtils.getOutDir(MethodNode mth)
static BlockNode	BlockUtils.getPathCross(MethodNode mth, BlockNode b1, BlockNode b2)
static @Nullable BlockNode	BlockUtils.getPathCross(MethodNode mth, Collection<BlockNode> blocks)	Return common cross block for input set.
static @Nullable BlockNode	BlockUtils.getPrevBlockOnPath(MethodNode mth, BlockNode block, BlockNode pathStart)	Return predecessor on path from 'pathStart' block
static @Nullable BlockNode	BlockUtils.getTopCommonSuccessor(MethodNode mth, List<BlockNode> blocks, boolean cleanOnly)
static @Nullable BlockNode	BlockUtils.getTopCommonSuccessor(MethodNode mth, List<BlockNode> blocks, boolean cleanOnly, boolean addTopBlock)
static @Nullable BlockNode	BlockUtils.getTryAndHandlerCrossBlock(MethodNode mth, ExceptionHandler handler)	Return out block of try catch, by finding where try branch meets catch branch.
private String	DotGraphUtils.insertInsns(MethodNode mth, IBlock block)
private static boolean	DebugChecks.insnMissing(MethodNode mth, InsnNode insn)
static boolean	RegionUtils.isBlocksInSameRegion(MethodNode mth, BlockNode firstBlock, BlockNode secondBlock)	Check if two blocks in same region on same level TODO: Add 'region' annotation to all blocks to speed up checks
static boolean	BlockUtils.isExitBlock(MethodNode mth, BlockNode block)
static boolean	RegionUtils.isExitBlock(MethodNode mth, IContainer container)
static boolean	BlockUtils.isFirstInsn(MethodNode mth, InsnNode insn)
static String	DotGraphUtils.methodFormatName(MethodNode methodNode, boolean longName)
static BitSet	BlockUtils.newBlocksBitSet(MethodNode mth)
private static void	DebugUtils.printInsns(MethodNode mth, ICodeWriter cw, String indent, IBlock block)
static void	DebugUtils.printRegion(MethodNode mth, IRegion region, boolean printInsns)
private static void	DebugUtils.printRegion(MethodNode mth, IRegion region, ICodeWriter cw, String indent, boolean printInsns)
static void	DebugUtils.printRegions(MethodNode mth)
static void	DebugUtils.printRegions(MethodNode mth, boolean printInsns)
private static void	DebugUtils.printRegionSpecificInfo(ICodeWriter cw, String indent, MethodNode mth, IRegion region, boolean printInsns)
static void	DebugUtils.printRegionsWithBlock(MethodNode mth, BlockNode block)
private void	DotGraphUtils.processBlock(MethodNode mth, BlockNode block)
private void	DotGraphUtils.processBlock(MethodNode mth, BlockNode block, boolean error, boolean pseudoInRegion)
private void	DotGraphUtils.processIBlock(MethodNode mth, IBlock block)
private void	DotGraphUtils.processIBlock(MethodNode mth, IBlock block, boolean error)
private void	DotGraphUtils.processMethodRegion(MethodNode mth)
private void	DotGraphUtils.processRegion(MethodNode mth, IContainer region, Set<IBlock> regionsBlocks)
static void	DebugChecks.quickCheckPhiInsn(MethodNode mth)
static void	InsnRemover.remove(MethodNode mth, @Nullable InsnNode insn)
static void	InsnRemover.remove(MethodNode mth, BlockNode block, int index)
static void	InsnRemover.remove(MethodNode mth, BlockNode block, InsnNode insn)
static void	InsnRemover.removeAllAndUnbind(MethodNode mth, BlockNode block, List<InsnNode> insns)
static void	InsnRemover.removeAllAndUnbind(MethodNode mth, IContainer container, List<InsnNode> insns)
static void	InsnRemover.removeAllAndUnbind(MethodNode mth, List<InsnNode> insns)
static void	InsnRemover.removeAllMarked(MethodNode mth)
private static void	InsnRemover.removeSsaVar(MethodNode mth, SSAVar ssaVar)
static boolean	InsnRemover.removeWithoutUnbind(MethodNode mth, BlockNode block, InsnNode insn)
static void	BlockUtils.replaceInsn(MethodNode mth, BlockNode block, int i, InsnNode insn)	Replace insn by index i in block, for proper copy attributes, assume attributes are not overlap
static boolean	BlockUtils.replaceInsn(MethodNode mth, BlockNode block, InsnNode oldInsn, InsnNode newInsn)
static boolean	BlockUtils.replaceInsn(MethodNode mth, InsnNode oldInsn, InsnNode newInsn)
static void	InsnUtils.replaceInsns(MethodNode mth, Function<InsnNode,InsnNode> replaceFunction)
static void	InsnUtils.replaceInsnsInInsn(MethodNode mth, InsnNode insn, Function<InsnNode,InsnNode> replaceFunction)
static void	DebugChecks.runChecksAfterVisitor(MethodNode mth, String visitor)
static BlockNode	BlockUtils.searchBlockWithPhi(MethodNode mth, PhiInsn insn)
static @Nullable InsnNode	InsnUtils.searchInsn(MethodNode mth, InsnType insnType, Predicate<InsnNode> test)	Search instruction of specific type and condition in method.
static InsnNode	BlockUtils.searchInsnParent(MethodNode mth, InsnNode insn)
static @Nullable InsnNode	InsnUtils.searchSingleReturnInsn(MethodNode mth, Predicate<InsnNode> test)
static InsnArg	BlockUtils.searchWrappedInsnParent(MethodNode mth, InsnNode insn)
static void	InsnRemover.unbindAllArgs(@Nullable MethodNode mth, InsnNode insn)
static void	InsnRemover.unbindArgUsage(@Nullable MethodNode mth, InsnArg arg)
static void	InsnRemover.unbindInsn(@Nullable MethodNode mth, InsnNode insn)
static void	InsnRemover.unbindInsns(@Nullable MethodNode mth, List<InsnNode> insns)
static void	InsnRemover.unbindResult(@Nullable MethodNode mth, InsnNode insn)
void	DebugChecksPass.visit(MethodNode mth)
static void	RegionUtils.visitBlockNodes(MethodNode mth, IContainer container, Consumer<BlockNode> visitor)
static void	RegionUtils.visitBlocks(MethodNode mth, IContainer container, Consumer<IBlock> visitor)
static boolean	BlockUtils.visitBlocksOnPath(MethodNode mth, BlockNode start, BlockNode end, Consumer<BlockNode> visitor)	Visit blocks on any path from start to end.
private static void	BlockUtils.visitDFS(MethodNode mth, BlockNode startBlock, Function<BlockNode,List<BlockNode>> nextFunc, Consumer<BlockNode> visitor)
static void	BlockUtils.visitDFS(MethodNode mth, Consumer<BlockNode> visitor)
static void	BlockUtils.visitPredecessorsUntil(MethodNode mth, BlockNode start, Predicate<BlockNode> visitor)
static void	RegionUtils.visitRegions(MethodNode mth, IContainer container, Predicate<IRegion> visitor)
static void	BlockUtils.visitReverseDFS(MethodNode mth, Consumer<BlockNode> visitor)

Method parameters in jadx.core.utils with type arguments of type MethodNode

Modifier and Type	Method	Description
static void	DebugUtils.dumpRaw(MethodNode mth, String desc, Predicate<MethodNode> dumpCondition)
static IDexTreeVisitor	DebugUtils.dumpRawVisitor(String desc, Predicate<MethodNode> filter)

Constructors in jadx.core.utils with parameters of type MethodNode

Modifier	Constructor	Description
	InsnRemover(MethodNode mth)
	InsnRemover(MethodNode mth, BlockNode block)

Uses of MethodNode in jadx.core.utils.blocks

Fields in jadx.core.utils.blocks declared as MethodNode

Modifier and Type	Field	Description
private final MethodNode	BlockSet.mth

Methods in jadx.core.utils.blocks with parameters of type MethodNode

Modifier and Type	Method	Description
static BlockSet	BlockSet.empty(MethodNode mth)
static BlockSet	BlockSet.from(MethodNode mth, Collection<BlockNode> blocks)

Constructors in jadx.core.utils.blocks with parameters of type MethodNode

Modifier	Constructor	Description
	BlockSet(MethodNode mth)
	DFSIteration(MethodNode mth, BlockNode startBlock, Function<BlockNode,List<BlockNode>> next)

Uses of MethodNode in jadx.core.utils.exceptions

Constructors in jadx.core.utils.exceptions with parameters of type MethodNode

Modifier	Constructor	Description
	CodegenException(MethodNode mth, String msg)
	CodegenException(MethodNode mth, String msg, Throwable th)
	DecodeException(MethodNode mth, String msg)
	DecodeException(MethodNode mth, String msg, Throwable th)
	JadxException(MethodNode mth, String msg, Throwable th)