jadx.core.utils

Class BlockUtils

java.lang.Object

jadx.core.utils.BlockUtils

public class BlockUtils
extends java.lang.Object

Method Summary

Modifier and Type	Method and Description
static boolean	atLeastOnePathExists(java.util.Collection<BlockNode> startBlocks, BlockNode end) Search at least one path from startBlocks to end
static java.util.List<BlockNode>	bitSetToBlocks(MethodNode mth, java.util.BitSet bs)
static @Nullable BlockNode	bitSetToOneBlock(MethodNode mth, java.util.BitSet bs)
static boolean	blockContains(BlockNode block, InsnNode insn) Check if instruction contains in block (use == for comparison, not equals)
static java.util.BitSet	blocksToBitSet(MethodNode mth, java.util.Collection<BlockNode> blocks)
static java.util.List<BlockNode>	buildSimplePath(BlockNode block)
static @Nullable BlockNode	calcImmediatePostDominator(MethodNode mth, BlockNode block)
static @Nullable BlockNode	calcImmediatePostDominator(MethodNode mth, BlockNode block, java.util.Map<BlockNode,java.util.BitSet> postDomsMap)
static @Nullable BlockNode	calcPartialImmediatePostDominator(MethodNode mth, BlockNode block, java.util.Collection<BlockNode> blockNodes, BlockNode exitBlock)
static java.util.Map<BlockNode,java.util.BitSet>	calcPartialPostDominance(MethodNode mth, java.util.Collection<BlockNode> blockNodes, BlockNode exitBlock)
static java.util.Map<BlockNode,java.util.BitSet>	calcPostDominance(MethodNode mth)
static boolean	checkFirstInsn(IBlock block, java.util.function.Predicate<InsnNode> predicate)
static boolean	checkLastInsnType(IBlock block, InsnType expectedType)
static void	cleanBitSet(MethodNode mth, java.util.BitSet bs) Remove exception handlers from block nodes bitset
static java.util.List<InsnNode>	collectAllInsns(java.util.List<BlockNode> blocks)
static java.util.List<BlockNode>	collectBlocksDominatedBy(MethodNode mth, BlockNode dominator, BlockNode start) Collect all block dominated by 'dominator', starting from 'start'
static java.util.Set<BlockNode>	collectBlocksDominatedByWithExcHandlers(MethodNode mth, BlockNode dominator, BlockNode start) Collect all block dominated by 'dominator', starting from 'start', including exception handlers
static java.util.List<InsnNode>	collectInsnsWithLimit(java.util.List<BlockNode> blocks, int limit) Return limited number of instructions from method.
static java.util.List<BlockNode>	collectPredecessors(MethodNode mth, BlockNode start, java.util.Collection<BlockNode> stopBlocks)
static boolean	containsExitInsn(IBlock block)
static java.util.BitSet	copyBlocksBitSet(MethodNode mth, java.util.BitSet bitSet)
static void	dfsVisit(MethodNode mth, java.util.function.Consumer<BlockNode> visitor)
static BlockNode	followEmptyPath(BlockNode start) Follow empty blocks and return end of path block (first not empty).
static void	forEachBlockFromBitSet(MethodNode mth, java.util.BitSet bs, java.util.function.Consumer<BlockNode> consumer)
static java.util.Set<BlockNode>	getAllPathsBlocks(BlockNode start, BlockNode end) Collect blocks from all possible execution paths from 'start' to 'end'
static @Nullable BlockNode	getBlockByInsn(MethodNode mth, @Nullable InsnNode insn)
static BlockNode	getBlockByOffset(int offset, java.lang.Iterable<BlockNode> casesBlocks)
static @Nullable BlockNode	getBlockWithFlag(java.util.List<BlockNode> blocks, AFlag flag)
static @Nullable BlockNode	getBottomBlock(java.util.List<BlockNode> blocks) Search last block in control flow graph from input set.
static @Nullable BlockNode	getCommonDominator(MethodNode mth, java.util.List<BlockNode> blocks) Search the lowest common ancestor in dominator tree for input set.
static @Nullable InsnNode	getFirstInsn(@Nullable IBlock block)
static int	getFirstSourceLine(IBlock block)
static int	getInsnIndexInBlock(BlockNode block, InsnNode insn)
static @Nullable InsnNode	getLastInsn(@Nullable IBlock block)
static InsnNode	getLastInsnWithType(IBlock block, InsnType expectedType)
static @Nullable BlockNode	getNextBlock(BlockNode block) Return first successor which not exception handler and not follow loop back edge
static BlockNode	getNextBlockToPath(BlockNode block, BlockNode pathEnd) Return successor on path to 'pathEnd' block
static @Nullable BlockNode	getNextSinglePathBlock(BlockNode block)
static @Nullable InsnNode	getOnlyOneInsnFromMth(MethodNode mth) Return insn if it is only one instruction in this method.
static BlockNode	getPathCross(MethodNode mth, BlockNode b1, BlockNode b2)
static @Nullable BlockNode	getPathCross(MethodNode mth, java.util.Collection<BlockNode> blocks) Return common cross block for input set.
static BlockNode	getTopBlock(java.util.List<BlockNode> blocks)
static BlockNode	getTopSplitterForHandler(BlockNode handlerBlock)
static boolean	insertAfterInsn(BlockNode block, InsnNode insn, InsnNode newInsn)
static boolean	insertBeforeInsn(BlockNode block, InsnNode insn, InsnNode newInsn)
static boolean	isAllBlocksEmpty(java.util.List<BlockNode> blocks)
static boolean	isAllPathExists(java.util.Collection<BlockNode> startBlocks, BlockNode end) Check if exist path from every startBlocks to end
static boolean	isAnyPathExists(BlockNode start, BlockNode end)
static boolean	isBackEdge(BlockNode from, BlockNode to)
static boolean	isEmptySimplePath(BlockNode start, BlockNode end) Return true if on path from start to end no instructions and no branches.
static boolean	isExceptionHandlerPath(BlockNode b)
static boolean	isExitBlock(BlockNode block)
static boolean	isExitBlock(MethodNode mth, BlockNode block)
static boolean	isFirstInsn(MethodNode mth, InsnNode insn)
static boolean	isFollowBackEdge(BlockNode block)
static boolean	isOnlyOnePathExists(BlockNode start, BlockNode end)
static boolean	isPathExists(BlockNode start, BlockNode end)
static java.util.BitSet	newBlocksBitSet(MethodNode mth)
static boolean	replaceInsn(MethodNode mth, BlockNode block, InsnNode oldInsn, InsnNode newInsn)
static void	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	replaceInsn(MethodNode mth, InsnNode oldInsn, InsnNode newInsn)
static BlockNode	searchBlockWithPhi(MethodNode mth, PhiInsn insn)
static InsnNode	searchInsnParent(MethodNode mth, InsnNode insn)
static InsnArg	searchWrappedInsnParent(MethodNode mth, InsnNode insn)
static BlockNode	selectOther(BlockNode node, java.util.List<BlockNode> blocks)
static BlockNode	selectOtherSafe(BlockNode node, java.util.List<BlockNode> blocks)
static void	skipPredSyntheticPaths(BlockNode block) Set 'SKIP' flag for all synthetic predecessors from start block.
static BlockNode	skipSyntheticPredecessor(BlockNode block) Return predecessor of synthetic block or same block otherwise.
static BlockNode	traverseWhileDominates(BlockNode dom, BlockNode start) Search for first node which not dominated by dom, starting from start
static void	visitBlocksOnEmptyPath(BlockNode start, java.util.function.Consumer<BlockNode> visitor)
static boolean	visitBlocksOnPath(MethodNode mth, BlockNode start, BlockNode end, java.util.function.Consumer<BlockNode> visitor) Visit blocks on any path from start to end.
static void	visitSinglePath(BlockNode startBlock, java.util.function.Consumer<BlockNode> visitor) Visit blocks on path without branching or merging paths.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

getBlockByOffset

public static BlockNode getBlockByOffset(int offset,
                                         java.lang.Iterable<BlockNode> casesBlocks)

selectOther

public static BlockNode selectOther(BlockNode node,
                                    java.util.List<BlockNode> blocks)

selectOtherSafe

public static BlockNode selectOtherSafe(BlockNode node,
                                        java.util.List<BlockNode> blocks)

isExceptionHandlerPath

public static boolean isExceptionHandlerPath(BlockNode b)

cleanBitSet

public static void cleanBitSet(MethodNode mth,
                               java.util.BitSet bs)

Remove exception handlers from block nodes bitset

isBackEdge

public static boolean isBackEdge(BlockNode from,
                                 BlockNode to)

isFollowBackEdge

public static boolean isFollowBackEdge(BlockNode block)

blockContains

public static boolean blockContains(BlockNode block,
                                    InsnNode insn)

Check if instruction contains in block (use == for comparison, not equals)

checkFirstInsn

public static boolean checkFirstInsn(IBlock block,
                                     java.util.function.Predicate<InsnNode> predicate)

checkLastInsnType

public static boolean checkLastInsnType(IBlock block,
                                        InsnType expectedType)

getLastInsnWithType

public static InsnNode getLastInsnWithType(IBlock block,
                                           InsnType expectedType)

getFirstSourceLine

public static int getFirstSourceLine(IBlock block)

getFirstInsn

@Nullable
public static @Nullable InsnNode getFirstInsn(@Nullable
                                                        @Nullable IBlock block)

getLastInsn

@Nullable
public static @Nullable InsnNode getLastInsn(@Nullable
                                                       @Nullable IBlock block)

isExitBlock

public static boolean isExitBlock(MethodNode mth,
                                  BlockNode block)

isExitBlock

public static boolean isExitBlock(BlockNode block)

containsExitInsn

public static boolean containsExitInsn(IBlock block)

getBlockByInsn

@Nullable
public static @Nullable BlockNode getBlockByInsn(MethodNode mth,
                                                           @Nullable
                                                           @Nullable InsnNode insn)

searchBlockWithPhi

public static BlockNode searchBlockWithPhi(MethodNode mth,
                                           PhiInsn insn)

searchInsnParent

public static InsnNode searchInsnParent(MethodNode mth,
                                        InsnNode insn)

searchWrappedInsnParent

public static InsnArg searchWrappedInsnParent(MethodNode mth,
                                              InsnNode insn)

newBlocksBitSet

public static java.util.BitSet newBlocksBitSet(MethodNode mth)

copyBlocksBitSet

public static java.util.BitSet copyBlocksBitSet(MethodNode mth,
                                                java.util.BitSet bitSet)

blocksToBitSet

public static java.util.BitSet blocksToBitSet(MethodNode mth,
                                              java.util.Collection<BlockNode> blocks)

bitSetToOneBlock

@Nullable
public static @Nullable BlockNode bitSetToOneBlock(MethodNode mth,
                                                             java.util.BitSet bs)

bitSetToBlocks

public static java.util.List<BlockNode> bitSetToBlocks(MethodNode mth,
                                                       java.util.BitSet bs)

forEachBlockFromBitSet

public static void forEachBlockFromBitSet(MethodNode mth,
                                          java.util.BitSet bs,
                                          java.util.function.Consumer<BlockNode> consumer)

getNextBlock

@Nullable
public static @Nullable BlockNode getNextBlock(BlockNode block)

Return first successor which not exception handler and not follow loop back edge

getNextBlockToPath

public static BlockNode getNextBlockToPath(BlockNode block,
                                           BlockNode pathEnd)

Return successor on path to 'pathEnd' block

visitBlocksOnPath

public static boolean visitBlocksOnPath(MethodNode mth,
                                        BlockNode start,
                                        BlockNode end,
                                        java.util.function.Consumer<BlockNode> visitor)

Visit blocks on any path from start to end. Only one path will be visited!

dfsVisit

public static void dfsVisit(MethodNode mth,
                            java.util.function.Consumer<BlockNode> visitor)

collectPredecessors

public static java.util.List<BlockNode> collectPredecessors(MethodNode mth,
                                                            BlockNode start,
                                                            java.util.Collection<BlockNode> stopBlocks)

getAllPathsBlocks

public static java.util.Set<BlockNode> getAllPathsBlocks(BlockNode start,
                                                         BlockNode end)

Collect blocks from all possible execution paths from 'start' to 'end'

atLeastOnePathExists

public static boolean atLeastOnePathExists(java.util.Collection<BlockNode> startBlocks,
                                           BlockNode end)

Search at least one path from startBlocks to end

isAllPathExists

public static boolean isAllPathExists(java.util.Collection<BlockNode> startBlocks,
                                      BlockNode end)

Check if exist path from every startBlocks to end

isPathExists

public static boolean isPathExists(BlockNode start,
                                   BlockNode end)

isAnyPathExists

public static boolean isAnyPathExists(BlockNode start,
                                      BlockNode end)

getTopBlock

public static BlockNode getTopBlock(java.util.List<BlockNode> blocks)

getBottomBlock

@Nullable
public static @Nullable BlockNode getBottomBlock(java.util.List<BlockNode> blocks)

Search last block in control flow graph from input set.

isOnlyOnePathExists

public static boolean isOnlyOnePathExists(BlockNode start,
                                          BlockNode end)

traverseWhileDominates

public static BlockNode traverseWhileDominates(BlockNode dom,
                                               BlockNode start)

Search for first node which not dominated by dom, starting from start

getCommonDominator

@Nullable
public static @Nullable BlockNode getCommonDominator(MethodNode mth,
                                                               java.util.List<BlockNode> blocks)

Search the lowest common ancestor in dominator tree for input set.

getPathCross

@Nullable
public static @Nullable BlockNode getPathCross(MethodNode mth,
                                                         java.util.Collection<BlockNode> blocks)

Return common cross block for input set.

Returns:

null if cross is a method exit block.

getPathCross

public static BlockNode getPathCross(MethodNode mth,
                                     BlockNode b1,
                                     BlockNode b2)

collectBlocksDominatedBy

public static java.util.List<BlockNode> collectBlocksDominatedBy(MethodNode mth,
                                                                 BlockNode dominator,
                                                                 BlockNode start)

Collect all block dominated by 'dominator', starting from 'start'

collectBlocksDominatedByWithExcHandlers

public static java.util.Set<BlockNode> collectBlocksDominatedByWithExcHandlers(MethodNode mth,
                                                                               BlockNode dominator,
                                                                               BlockNode start)

Collect all block dominated by 'dominator', starting from 'start', including exception handlers

visitSinglePath

public static void visitSinglePath(BlockNode startBlock,
                                   java.util.function.Consumer<BlockNode> visitor)

Visit blocks on path without branching or merging paths.

getNextSinglePathBlock

@Nullable
public static @Nullable BlockNode getNextSinglePathBlock(BlockNode block)

buildSimplePath

public static java.util.List<BlockNode> buildSimplePath(BlockNode block)

skipPredSyntheticPaths

public static void skipPredSyntheticPaths(BlockNode block)

Set 'SKIP' flag for all synthetic predecessors from start block.

followEmptyPath

public static BlockNode followEmptyPath(BlockNode start)

Follow empty blocks and return end of path block (first not empty). Return start block if no such path.

visitBlocksOnEmptyPath

public static void visitBlocksOnEmptyPath(BlockNode start,
                                          java.util.function.Consumer<BlockNode> visitor)

isEmptySimplePath

public static boolean isEmptySimplePath(BlockNode start,
                                        BlockNode end)

Return true if on path from start to end no instructions and no branches.

skipSyntheticPredecessor

public static BlockNode skipSyntheticPredecessor(BlockNode block)

Return predecessor of synthetic block or same block otherwise.

isAllBlocksEmpty

public static boolean isAllBlocksEmpty(java.util.List<BlockNode> blocks)

collectAllInsns

public static java.util.List<InsnNode> collectAllInsns(java.util.List<BlockNode> blocks)

collectInsnsWithLimit

public static java.util.List<InsnNode> collectInsnsWithLimit(java.util.List<BlockNode> blocks,
                                                             int limit)

Return limited number of instructions from method. Return empty list if method contains more than limit.

getOnlyOneInsnFromMth

@Nullable
public static @Nullable InsnNode getOnlyOneInsnFromMth(MethodNode mth)

Return insn if it is only one instruction in this method. Return null otherwise.

isFirstInsn

public static boolean isFirstInsn(MethodNode mth,
                                  InsnNode insn)

replaceInsn

public static void 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

replaceInsn

public static boolean replaceInsn(MethodNode mth,
                                  BlockNode block,
                                  InsnNode oldInsn,
                                  InsnNode newInsn)

insertBeforeInsn

public static boolean insertBeforeInsn(BlockNode block,
                                       InsnNode insn,
                                       InsnNode newInsn)

insertAfterInsn

public static boolean insertAfterInsn(BlockNode block,
                                      InsnNode insn,
                                      InsnNode newInsn)

getInsnIndexInBlock

public static int getInsnIndexInBlock(BlockNode block,
                                      InsnNode insn)

replaceInsn

public static boolean replaceInsn(MethodNode mth,
                                  InsnNode oldInsn,
                                  InsnNode newInsn)

calcPostDominance

public static java.util.Map<BlockNode,java.util.BitSet> calcPostDominance(MethodNode mth)

calcPartialPostDominance

public static java.util.Map<BlockNode,java.util.BitSet> calcPartialPostDominance(MethodNode mth,
                                                                                 java.util.Collection<BlockNode> blockNodes,
                                                                                 BlockNode exitBlock)

calcImmediatePostDominator

@Nullable
public static @Nullable BlockNode calcImmediatePostDominator(MethodNode mth,
                                                                       BlockNode block)

calcPartialImmediatePostDominator

@Nullable
public static @Nullable BlockNode calcPartialImmediatePostDominator(MethodNode mth,
                                                                              BlockNode block,
                                                                              java.util.Collection<BlockNode> blockNodes,
                                                                              BlockNode exitBlock)

calcImmediatePostDominator

@Nullable
public static @Nullable BlockNode calcImmediatePostDominator(MethodNode mth,
                                                                       BlockNode block,
                                                                       java.util.Map<BlockNode,java.util.BitSet> postDomsMap)

getTopSplitterForHandler

public static BlockNode getTopSplitterForHandler(BlockNode handlerBlock)

getBlockWithFlag

@Nullable
public static @Nullable BlockNode getBlockWithFlag(java.util.List<BlockNode> blocks,
                                                             AFlag flag)