Package jadx.core.dex.visitors.blocks

Class BlockProcessor

java.lang.Object
jadx.core.dex.visitors.AbstractVisitor
jadx.core.dex.visitors.blocks.BlockProcessor
All Implemented Interfaces:
IDexTreeVisitor
public class BlockProcessor extends AbstractVisitor

  • Field Details

    • LOG

      private static final org.slf4j.Logger LOG

    • DEBUG_MODS

      private static final boolean DEBUG_MODS
      See Also:

  • Constructor Details

    • BlockProcessor

      public BlockProcessor()

  • Method Details

    • visit

      public void visit(MethodNode mth)
      Description copied from interface: IDexTreeVisitor
      Visit method
      Specified by:
      visit in interface IDexTreeVisitor
      Overrides:
      visit in class AbstractVisitor

    • processBlocksTree

      private static void processBlocksTree(MethodNode mth)

    • updateBlocksData

      public static void updateBlocksData(MethodNode mth)
      Recalculate all additional info attached to blocks: 
       - dominators
 - dominance frontier
 - post dominators (only if AFlag.COMPUTE_POST_DOM added to method)
 - loops and nested loop info

      This method should be called after changing a block tree in custom passes added before BlockFinisher.

    • updateCleanSuccessors

      static void updateCleanSuccessors(MethodNode mth)

    • checkForUnreachableBlocks

      private static void checkForUnreachableBlocks(MethodNode mth)

    • fixUnreachableSplitCross

      private static boolean 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.
      Parameters:
      mth - the method containing the unreachable block
      splitCross - the unreachable block
      Returns:
      true if the operation was successful, false if a precondition was not satisfied and no changes were made.

    • deduplicateBlockInsns

      private static boolean deduplicateBlockInsns(MethodNode mth, BlockNode block)

    • getLastInsns

      private static List<InsnNode> getLastInsns(BlockNode blockNode, int sameInsnCount)

    • insertAtStart

      private static void insertAtStart(BlockNode block, List<InsnNode> insns)

    • getSameLastInsnCount

      private static int getSameLastInsnCount(List<BlockNode> predecessors)

    • isSame

      private static boolean isSame(InsnNode insn, InsnNode curInsn)

    • isInsnsEquals

      private static boolean isInsnsEquals(InsnNode insn, InsnNode otherInsn)

    • sameArgs

      private static boolean sameArgs(@Nullable @Nullable InsnArg arg, @Nullable @Nullable InsnArg otherArg)

    • getInsnsFromEnd

      private static InsnNode getInsnsFromEnd(BlockNode block, int number)

    • computeDominators

      private static void computeDominators(MethodNode mth)

    • markLoops

      private static void markLoops(MethodNode mth)

    • registerLoops

      private static void registerLoops(MethodNode mth)

    • processNestedLoops

      private static void processNestedLoops(MethodNode mth)

    • modifyBlocksTree

      private static boolean modifyBlocksTree(MethodNode mth)

    • mergeConstReturn

      private static boolean mergeConstReturn(MethodNode mth)

    • mergeConstAndReturnBlocks

      private static void mergeConstAndReturnBlocks(MethodNode mth, BlockNode retBlock, BlockNode pred)

    • independentBlockTreeMod

      private static boolean independentBlockTreeMod(MethodNode mth)

    • duplicateSimpleMoveBlock

      private static boolean duplicateSimpleMoveBlock(MethodNode mth, BlockNode block)
      Duplicate block if it contains only one 'move' insn and all predecessors are 'switch' and 'if'. This will help to resolve switch cases order and fallthrough detection because such move blocks can be deduplicated by compiler.

    • onlySwitchAndIfInLastInsns

      private static boolean onlySwitchAndIfInLastInsns(List<BlockNode> preds)

    • simplifyLoopEnd

      private static boolean simplifyLoopEnd(MethodNode mth, LoopInfo loop)

    • checkLoops

      private static boolean checkLoops(MethodNode mth, BlockNode block)

    • insertPreHeader

      private static boolean insertPreHeader(MethodNode mth, LoopInfo loop)
      Insert simple path block before loop header

    • insertBlocksForBreak

      private static boolean insertBlocksForBreak(MethodNode mth, LoopInfo loop)
      Insert additional blocks for possible 'break' insertion

    • insertBlocksForContinue

      private static boolean insertBlocksForContinue(MethodNode mth, LoopInfo loop)
      Insert additional blocks for possible 'continue' insertion

    • splitLoops

      private static boolean splitLoops(MethodNode mth, BlockNode block, List<LoopInfo> loops)

    • splitExitBlocks

      private static boolean splitExitBlocks(MethodNode mth)

    • updateExitBlockConnections

      private static void updateExitBlockConnections(MethodNode mth)

    • splitReturn

      private static boolean splitReturn(MethodNode mth, BlockNode returnBlock)
      Splice return block if several predecessors presents

    • splitThrow

      private static boolean splitThrow(MethodNode mth, BlockNode exitBlock)

    • isArgAssignInPred

      private static boolean isArgAssignInPred(List<BlockNode> preds, InsnArg arg)

    • removeMarkedBlocks

      public static void removeMarkedBlocks(MethodNode mth)

    • removeUnreachableBlocks

      private static void removeUnreachableBlocks(MethodNode mth)

    • removeUnreachableBlock

      public static void removeUnreachableBlock(BlockNode blockToRemove, MethodNode mth)

    • computeUnreachableFromBlock

      private static void computeUnreachableFromBlock(Set<BlockNode> toRemove, BlockNode block, MethodNode mth)

    • removeFromMethod

      private static void removeFromMethod(Set<BlockNode> toRemove, MethodNode mth)

    • clearBlocksState

      private static void clearBlocksState(MethodNode mth)