Class DFA4<InsnType extends IInstruction>

java.lang.Object
com.pnfsoftware.jeb.core.units.code.DFA4<InsnType>
All Implemented Interfaces:
IDFA<InsnType>

public class DFA4<InsnType extends IInstruction> extends Object implements IDFA<InsnType>
Lean Data Flow Analysis (DFA) object implementation.
  • Field Details

    • CACHE_NONE

      public static final int CACHE_NONE
      Nothing is cached
      See Also:
    • CACHE_DUI

      public static final int CACHE_DUI
      Cache basic def/use information at the instruction level
      See Also:
    • CACHE_DUI_UDC_DUC

      public static final int CACHE_DUI_UDC_DUC
      CACHE_DUI + cache standard ud-chains and du-chains
      See Also:
  • Constructor Details

    • DFA4

      public DFA4(IControlFlowGraph<InsnType,? extends IBasicBlock<InsnType>> cfg)
      Create a DFA object with CFG-provided default collection flags and basic caching for instruction-level def-use information. This object can be further configured by invoking its various setters.
      Parameters:
      cfg -
    • DFA4

      public DFA4(IControlFlowGraph<InsnType,? extends IBasicBlock<InsnType>> cfg, int collectionFlags, int cacheConfig)
      Create a DFA object. This object can be further configured by invoking its various setters.
      Parameters:
      cfg -
      collectionFlags - collection flags, see constants in DefUseInfo
      cacheConfig - 0= no cache, 1= cached for instruction-level def-use information; 2= 1 + cache for ud-chains and du-chains
  • Method Details

    • perform

      public void perform()
      Description copied from interface: IDFA
      Perform data flow analysis on the CFG. Upon return, basic blocks will have their data chains (ud and du, full and simple) set up and accessible.
      Specified by:
      perform in interface IDFA<InsnType extends IInstruction>
    • isValid

      public boolean isValid()
      Description copied from interface: IDFA
      Determine whether the current analysis was performed and is valid.
      Specified by:
      isValid in interface IDFA<InsnType extends IInstruction>
      Returns:
    • invalidate

      public void invalidate()
      Description copied from interface: IDFA
      Invalidate the analysis. Clients have the responsibility to invalidate an analysis if the CFG was modified in such a way that data flow should be recalculated.
      Specified by:
      invalidate in interface IDFA<InsnType extends IInstruction>
    • notifyInstructionUpdate

      public void notifyInstructionUpdate(long addr)
      Specified by:
      notifyInstructionUpdate in interface IDFA<InsnType extends IInstruction>
    • getCfg

      Description copied from interface: IDFA
      Retrieve a reference to the CFG object that will be accessed and modified when performing an analysis.
      Specified by:
      getCfg in interface IDFA<InsnType extends IInstruction>
      Returns:
    • setVariableCollectionFlags

      public void setVariableCollectionFlags(int flags)
      Description copied from interface: IDFA
      Set the variable collection flags.
      Specified by:
      setVariableCollectionFlags in interface IDFA<InsnType extends IInstruction>
      Parameters:
      flags - flags, see DefUseInfo
    • getVariableCollectionFlags

      public int getVariableCollectionFlags()
      Description copied from interface: IDFA
      Retrieve the variable collection flags.
      Specified by:
      getVariableCollectionFlags in interface IDFA<InsnType extends IInstruction>
      Returns:
      flags, see DefUseInfo
    • setCacheConfiguration

      public void setCacheConfiguration(int value)
      Set or update the cache configuration of this object.
      Parameters:
      value - one of CACHE_xxx attribute
    • getCacheConfiguration

      public int getCacheConfiguration()
      Retrieve the cache configuration.
      Returns:
      value one of CACHE_xxx attribute
    • setIntegrateCalculatedInputRegisters

      public void setIntegrateCalculatedInputRegisters(boolean integrateCalculatedInputRegisters)
      Specified by:
      setIntegrateCalculatedInputRegisters in interface IDFA<InsnType extends IInstruction>
      Parameters:
      integrateCalculatedInputRegisters - if true, the live registers determined after analysis will be integrated in the use-def chains
    • isIntegrateCalculatedInputRegisters

      public boolean isIntegrateCalculatedInputRegisters()
      Specified by:
      isIntegrateCalculatedInputRegisters in interface IDFA<InsnType extends IInstruction>
    • setAlwaysExamineIrregularFlows

      public void setAlwaysExamineIrregularFlows(boolean alwaysExamineIrregularFlows)
    • isAlwaysExamineIrregularFlows

      public boolean isAlwaysExamineIrregularFlows()
    • setVariableInformationProvider

      public void setVariableInformationProvider(ICFGOwnerContext varInfoProvider)
      Specified by:
      setVariableInformationProvider in interface IDFA<InsnType extends IInstruction>
    • getVariableInformationProvider

      public ICFGOwnerContext getVariableInformationProvider()
      Specified by:
      getVariableInformationProvider in interface IDFA<InsnType extends IInstruction>
    • setMaxBlocks

      public int setMaxBlocks(int maxBlocks)
      Description copied from interface: IDFA
      Set an exploration threshold for most DFA operations. By default, there is no threshold. The threshold is a block count; if a block count is reached, a chain may contain a reference to the invalid address -2 in order to indicate an incomplete result.
      Specified by:
      setMaxBlocks in interface IDFA<InsnType extends IInstruction>
      Parameters:
      maxBlocks - -1 means no limit
      Returns:
      the previous value for this setting
    • getMaxBlocks

      public int getMaxBlocks()
      Description copied from interface: IDFA
      Retrieve the maximum block count used for common DFA operations. See IDFA.setMaxBlocks(int) for details.
      Specified by:
      getMaxBlocks in interface IDFA<InsnType extends IInstruction>
      Returns:
    • formatDUI

      public String formatDUI(DUI o)
    • getDUI

      public DUI getDUI(long addr)
      Specified by:
      getDUI in interface IDFA<InsnType extends IInstruction>
      Returns:
    • getDUI

      public DUI getDUI(AddressableInstruction<InsnType> a)
      Specified by:
      getDUI in interface IDFA<InsnType extends IInstruction>
      Returns:
    • getDUI

      public DUI getDUI(long addr, InsnType insn)
      Specified by:
      getDUI in interface IDFA<InsnType extends IInstruction>
      Returns:
    • getUseDefs

      public Collection<Long> getUseDefs(long addr, int varid, int stopcount, boolean verifyStartOnUsePoint, boolean recordLiveIn, IBasicBlock<InsnType> blkForReachChains, int idxForReachChains, boolean[] aDetectedUseDiscrepancy, boolean treatSpoiledAsDefs, int maxBlocks, boolean limitToStartBlock)
      Find the list of definition points for a used variable.
      Parameters:
      addr - initial instruction address
      varid - used variable, for which definitions are to be collected
      stopcount - the search will stop if the def-count reaches that threshold; use <=0 to mean no stopcount
      verifyStartOnUsePoint - if true, the variable must be used at the provided instruction (else the method will return null)
      recordLiveIn - if true, a candidate argument-definition is recorded as -1 in the returned list
      blkForReachChains - optional basic block used to record reaching variables
      idxForReachChains - optional block index used to record reaching variables
      aDetectedUseDiscrepancy - optional one-element array, if provided, any use discrepancy (using a potentially undefined variable) will interrupt the search, and this flag will be set to true
      treatSpoiledAsDefs - if true, spoiled information for variables will be treated as a regular definition
      maxBlocks - maximum number of basic blocks to be examined; use -1 to mean all; if a positive value is provided, the returned list of addresses may contain -2 to indicate that a definition may be located in an unexplored block
      limitToStartBlock -
      Returns:
      a list of addresses where the variable was defined; the list may contain -1 to indicate a candidate argument-definition; never return null unless verifyStartOnUsePoint was true
    • getUseDefs

      public Collection<Long> getUseDefs(long addr, int varid)
      Specified by:
      getUseDefs in interface IDFA<InsnType extends IInstruction>
      Parameters:
      addr - instruction address
      varid - a variable, which must be used by the provided instruction
      Returns:
      a collection (possibly empty) or null if the variable is not used by the instruction
    • getUseDefs

      public Collection<Long> getUseDefs(long addr, int varid, int stopCount)
      Specified by:
      getUseDefs in interface IDFA<InsnType extends IInstruction>
      Parameters:
      addr - instruction address
      varid - a variable, which must be used by the provided instruction
      Returns:
      a collection (possibly empty) or null if the variable is not used by the instruction
    • getBlockUseDefs

      public Collection<Long> getBlockUseDefs(long addr, int varid)
      Specified by:
      getBlockUseDefs in interface IDFA<InsnType extends IInstruction>
    • isTerminator

      public boolean isTerminator(IBasicBlock<InsnType> blk)
      Description copied from interface: IDFA
      Determine whether the provided block is a terminator. A terminator has no output and its final instruction is a clean routine terminator.
      Specified by:
      isTerminator in interface IDFA<InsnType extends IInstruction>
      Parameters:
      blk - block to test
      Returns:
      true if the block is a clean terminator
    • getDefUses

      public Collection<Long> getDefUses(long addr, int varid, int stopcount, boolean verifyStartOnDefPoint, boolean recordReachOut, IBasicBlock<InsnType> blkForLiveChains, int idxForLiveChains, int maxBlocks, boolean limitToStartBlock)
      Find the list of usage points for a defined variable.
      Parameters:
      addr - initial instruction address (disregarded if computing liveness, in which case, blkForLiveChains must be provided)
      varid - defined variable
      stopcount - the search will stop if the use-count reaches that threshold; use <= 0 to mean no stopcount
      verifyStartOnDefPoint - if true, the variable must be defined by the provided initial instruction (else the method will return null)
      recordReachOut - if true, if the variable reaches the CFG output, a pseudo usage will be recorded as -1
      blkForLiveChains - optional basic block used to record live variables
      idxForLiveChains - optional block index used to record live variables
      maxBlocks - maximum number of basic blocks to be examined; use -1 to mean all; if a positive value is provided, the returned list of addresses may contain -2 to indicate that a usage may be located in an unexplored block
      limitToStartBlock - if true, the exploration will stop as soon as a use is detected outside the provided starting block, where the def took place, and -2 will be added to the returned list (if true, blkForLiveChains should be null); note: unlike what maxBlocks intends to do, a -2 in the resulting collection will indicate a definite out-of-block use
      Returns:
      a list of addresses where the variable is used; the list may contain -1 to indicate the the variable reached an output; never returns null unless verifyStartOnDefPoint was true
    • getDefUses

      public Collection<Long> getDefUses(long addr, int varid)
      Specified by:
      getDefUses in interface IDFA<InsnType extends IInstruction>
      Parameters:
      addr - instruction address
      varid - a variable, which must be defined by the provided instruction
      Returns:
      a collection (possibly empty) or null if the variable is not defined by the instruction
    • getDefUses

      public Collection<Long> getDefUses(long addr, int varid, int stopCount)
      Specified by:
      getDefUses in interface IDFA<InsnType extends IInstruction>
      Parameters:
      addr - instruction address
      varid - a variable, which must be defined by the provided instruction
      stopCount - optional stop count (-1 to collect as many uses as possible)
      Returns:
      a collection (possibly empty) or null if the variable is not defined by the instruction
    • getDefUses

      public Collection<Long> getDefUses(long addr, int varid, int stopCount, boolean recordReachOut)
      Specified by:
      getDefUses in interface IDFA<InsnType extends IInstruction>
      Parameters:
      addr - instruction address
      varid - a variable, which must be defined by the provided instruction
      stopCount - optional stop count (-1 to collect as many uses as possible)
      recordReachOut - if true, a variable reaching is considered used (if so, the output list will contain -1)
      Returns:
      a collection (possibly empty) or null if the variable is not defined by the instruction
    • getBlockDefUses

      public Collection<Long> getBlockDefUses(long addr, int varid)
      Specified by:
      getBlockDefUses in interface IDFA<InsnType extends IInstruction>
    • checkNoUse

      public int checkNoUse(long insnAddress, int varId, boolean reachOutIsUse, int maxBlocks)
      Description copied from interface: IDFA
      Check whether a variable, defined at the provided instruction, is not used.
      Specified by:
      checkNoUse in interface IDFA<InsnType extends IInstruction>
      Parameters:
      insnAddress - initial instruction address
      varId - defined variable at the initial instruction
      Returns:
      1: some uses; 0: no use; -1: no use, but may be a meaningful output; -2: unknown (may be returned only if maxBlocks is positive); -3: error
    • checkNoUse

      public boolean checkNoUse(long insnAddress, int varId, boolean reachOutIsUse)
      Description copied from interface: IDFA
      Check whether a variable, defined at the provided instruction, is not used.
      Specified by:
      checkNoUse in interface IDFA<InsnType extends IInstruction>
      Parameters:
      insnAddress - initial instruction address
      varId - defined variable at the initial instruction
      Returns:
      true if the variable is not used, and optionally (if reachOutIsUse is true), is overwritten before reaching possible end-blocks
    • checkNoUse

      public boolean checkNoUse(long addr, int varid)
      Description copied from interface: IDFA
      Check whether a variable, defined at the provided instruction, is not used.
      Specified by:
      checkNoUse in interface IDFA<InsnType extends IInstruction>
      Parameters:
      addr - initial instruction address
      varid - defined variable at the initial instruction
      Returns:
      true if the variable is not used; reaching-out is not considered a use
    • checkSingleUse

      public Long checkSingleUse(long addr, int varid, boolean reachOutIsUse)
      Parameters:
      addr -
      varid -
      reachOutIsUse -
      Returns:
    • checkSingleUse

      public Long checkSingleUse(long addr, int varid)
      Specified by:
      checkSingleUse in interface IDFA<InsnType extends IInstruction>
      Returns:
    • checkSingleDef

      public Long checkSingleDef(long addr, int varid, boolean liveInIsDef)
      Check whether a used variable has a single explicit definition point (i.e. it is a non-input defined at a unique address).
      Parameters:
      addr - initial instruction address
      varid - used variable at the initial instruction
      liveInIsDef -
      Returns:
      the instruction address, if the variable used at the provided instruction has a single def-point; -1 is returned if the variable has no explicit def-point (as would be the case for method arguments); on error, or if multiple def-points are detected, null is returned
    • checkSingleDefNoInput

      public Long checkSingleDefNoInput(long addr, int varid)
      Description copied from interface: IDFA
      Check whether a used variable has a single explicit definition point. The def point cannot be a routine input (i.e. the definition must be explicit).
      Specified by:
      checkSingleDefNoInput in interface IDFA<InsnType extends IInstruction>
      Parameters:
      addr - initial instruction address
      varid - used variable at the initial instruction
      Returns:
    • checkSingleDef

      public Long checkSingleDef(long addr, int varid)
      Description copied from interface: IDFA
      Check whether a used variable has a single definition point. The def point may be explicit (e.g. resulting from an assignment) or implicit (e.g. provided as a parameter to the routine, which is always represented as the address -1).
      Specified by:
      checkSingleDef in interface IDFA<InsnType extends IInstruction>
      Parameters:
      addr - initial instruction address
      varid - used variable at the initial instruction
      Returns:
    • checkSingleSource

      public Long checkSingleSource(long addr, int varid, boolean liveInIsDef)
      Specified by:
      checkSingleSource in interface IDFA<InsnType extends IInstruction>
      Returns:
    • checkSingleSource

      public Long checkSingleSource(long addr, int varid)
      Specified by:
      checkSingleSource in interface IDFA<InsnType extends IInstruction>
      Returns:
    • collectInstructionAllDefs

      public void collectInstructionAllDefs(long addr, Collection<Integer> r)
      Specified by:
      collectInstructionAllDefs in interface IDFA<InsnType extends IInstruction>
    • collectInstructionAllUses

      public void collectInstructionAllUses(long addr, Collection<Integer> r)
      Specified by:
      collectInstructionAllUses in interface IDFA<InsnType extends IInstruction>
    • getInstructionAllDefs

      public Set<Integer> getInstructionAllDefs(long addr)
      Specified by:
      getInstructionAllDefs in interface IDFA<InsnType extends IInstruction>
    • getInstructionAllUses

      public Set<Integer> getInstructionAllUses(long addr)
      Specified by:
      getInstructionAllUses in interface IDFA<InsnType extends IInstruction>
    • getInstructionDefs

      public Set<Integer> getInstructionDefs(long addr)
      Specified by:
      getInstructionDefs in interface IDFA<InsnType extends IInstruction>
      Returns:
      a list of variables defined by the instruction at index in the block
    • getInstructionUses

      public Set<Integer> getInstructionUses(long addr)
      Specified by:
      getInstructionUses in interface IDFA<InsnType extends IInstruction>
      Returns:
      a list of variables used by the instruction at index in the block
    • getInstructionPotentialDefs

      public Set<Integer> getInstructionPotentialDefs(long addr)
      Specified by:
      getInstructionPotentialDefs in interface IDFA<InsnType extends IInstruction>
      Returns:
      a list of variables potentially defined by the instruction at index in the block; note that this data may not be present (empty lists) depending on DFA settings
    • getInstructionPotentialUses

      public Set<Integer> getInstructionPotentialUses(long addr)
      Specified by:
      getInstructionPotentialUses in interface IDFA<InsnType extends IInstruction>
      Returns:
      a list of variables potentially used by the instruction at index in the block; note that this data may not be present (empty lists) depending on DFA settings
    • getInstructionSpoiledDefs

      public Set<Integer> getInstructionSpoiledDefs(long addr)
      Specified by:
      getInstructionSpoiledDefs in interface IDFA<InsnType extends IInstruction>
      Returns:
      a list of variables potentially spoiled by the instruction at index in the block; note that this data may not be present (empty lists) depending on DFA settings
    • getUseDefChains

      public Map<Integer,Collection<Long>> getUseDefChains(long addr, boolean recordLiveIn)
    • getUseDefChains

      public Map<Integer,Collection<Long>> getUseDefChains(long addr)
      Specified by:
      getUseDefChains in interface IDFA<InsnType extends IInstruction>
    • getDefUseChains

      public Map<Integer,Collection<Long>> getDefUseChains(long addr, boolean recordReachOut)
    • getDefUseChains

      public Map<Integer,Collection<Long>> getDefUseChains(long addr)
      Specified by:
      getDefUseChains in interface IDFA<InsnType extends IInstruction>
    • getLiveChains

      public Map<Integer,Collection<Long>> getLiveChains(IBasicBlock<InsnType> b, int idx, Collection<Integer> varids)
    • getLiveChains

      public Collection<Long> getLiveChains(IBasicBlock<InsnType> b, int idx, int varid)
      Specified by:
      getLiveChains in interface IDFA<InsnType extends IInstruction>
    • getLiveChains

      public Map<Integer,Collection<Long>> getLiveChains(IBasicBlock<InsnType> b, int idx)
      Specified by:
      getLiveChains in interface IDFA<InsnType extends IInstruction>
    • isAlive

      public boolean isAlive(IBasicBlock<InsnType> b, int idx, int varid)
      Specified by:
      isAlive in interface IDFA<InsnType extends IInstruction>
    • getReachChains

      public Map<Integer,Collection<Long>> getReachChains(IBasicBlock<InsnType> b, int idx, Collection<Integer> varids)
    • getReachChains

      public Collection<Long> getReachChains(IBasicBlock<InsnType> b, int idx, int varid)
      Specified by:
      getReachChains in interface IDFA<InsnType extends IInstruction>
    • getReachChains

      public Map<Integer,Collection<Long>> getReachChains(IBasicBlock<InsnType> b, int idx)
      Specified by:
      getReachChains in interface IDFA<InsnType extends IInstruction>
    • isReaching

      public boolean isReaching(IBasicBlock<InsnType> b, int idx, int varid)
      Specified by:
      isReaching in interface IDFA<InsnType extends IInstruction>
    • getUseDiscrepancies

      public Collection<Integer> getUseDiscrepancies(long addr)
      Description copied from interface: IDFA
      Retrieve the list of use-discrepancies at the provided instruction address.
      Specified by:
      getUseDiscrepancies in interface IDFA<InsnType extends IInstruction>
      Parameters:
      addr - instruction address
      Returns:
      a list of variables whose usage at the provided location appears to be incorrect (i.e. not all paths to this usage carry a definition if the variable)
    • isUseDiscrepancy

      public boolean isUseDiscrepancy(long addr, int varid)
      Specified by:
      isUseDiscrepancy in interface IDFA<InsnType extends IInstruction>
      Returns:
    • checkInput

      public boolean checkInput(int varid)
    • getInputs

      public Collection<Integer> getInputs()
      Specified by:
      getInputs in interface IDFA<InsnType extends IInstruction>
    • filterInputs

      public Collection<Integer> filterInputs(Collection<Integer> varids)
      Parameters:
      varids - optional collection of potential argument variables for which we want to verify uses; leave null to retrieve all potential arguments
      Returns:
      a collection of variables that are used in the routine, that look like they have definitions outside the routine
    • getInputsWithUses

      public Map<Integer,Collection<Long>> getInputsWithUses()
      Returns:
    • checkInputWithUses

      public Collection<Long> checkInputWithUses(int varid)
    • filterInputsWithUses

      public Map<Integer,Collection<Long>> filterInputsWithUses(Collection<Integer> varids)
      Parameters:
      varids -
      Returns:
    • getInputMap

      public Map<Integer,Collection<Long>> getInputMap()
      Specified by:
      getInputMap in interface IDFA<InsnType extends IInstruction>
    • getInputMap

      public Collection<Long> getInputMap(int varid)
      Specified by:
      getInputMap in interface IDFA<InsnType extends IInstruction>
    • checkOutput

      public boolean checkOutput(IBasicBlock<InsnType> blk, int varid)
    • getOutputs

      public Collection<Integer> getOutputs(IBasicBlock<InsnType> blk)
      Specified by:
      getOutputs in interface IDFA<InsnType extends IInstruction>
    • filterOutputs

      public Collection<Integer> filterOutputs(IBasicBlock<InsnType> blk, Collection<Integer> varids)
    • getOutputsWithDefs

      public Map<Integer,Collection<Long>> getOutputsWithDefs(IBasicBlock<InsnType> blk)
    • checkOutputsWithDefs

      public Collection<Long> checkOutputsWithDefs(IBasicBlock<InsnType> blk, int varid)
    • filterOutputsWithDefs

      public Map<Integer,Collection<Long>> filterOutputsWithDefs(IBasicBlock<InsnType> blk, Collection<Integer> varids)
    • getOutputMap

      public Map<Integer,Collection<Long>> getOutputMap(IBasicBlock<InsnType> blk)
      Specified by:
      getOutputMap in interface IDFA<InsnType extends IInstruction>
    • getOutputMap

      public Collection<Long> getOutputMap(IBasicBlock<InsnType> blk, int varid)
      Specified by:
      getOutputMap in interface IDFA<InsnType extends IInstruction>
    • checkOutput

      public boolean checkOutput(int varid)
    • getOutputs

      public Collection<Integer> getOutputs()
      Specified by:
      getOutputs in interface IDFA<InsnType extends IInstruction>
    • filterOutputs

      public Collection<Integer> filterOutputs(Collection<Integer> varids)
    • getOutputsWithDefs

      public Map<Integer,Collection<Long>> getOutputsWithDefs()
    • checkOutputsWithDefs

      public Collection<Long> checkOutputsWithDefs(int varid)
    • filterOutputsWithDefs

      public Map<Integer,Collection<Long>> filterOutputsWithDefs(Collection<Integer> varids)
    • getOutputMap

      public Map<Integer,Collection<Long>> getOutputMap()
      Specified by:
      getOutputMap in interface IDFA<InsnType extends IInstruction>
    • getOutputMap

      public Collection<Long> getOutputMap(int varid)
      Specified by:
      getOutputMap in interface IDFA<InsnType extends IInstruction>
    • isNotRedefined

      public boolean isNotRedefined(int varid, long addr0, long addr1)
    • isNotRedefined

      public boolean isNotRedefined(int varid, IBasicBlock<InsnType> b0, int i0, IBasicBlock<InsnType> b1, int i1)
    • isVarReachingFromTo

      public Boolean isVarReachingFromTo(int varid, long addr0, long addr1)
      Description copied from interface: IDFA
      Determine if a variable used by the start instruction reaches the final instruction with the same value.

      Important notes:
      - This method provides a must-reach result: if a multiple paths exist from start to end, where the variable reaches the end via some paths, but not on others (it is overwritten), the method returns false.
      - This method works from the start point to an end point, and provides the guarantee that the variable was not overwritten when it reached the end-point. There is no guarantee provided at the end-point itself.

      Specified by:
      isVarReachingFromTo in interface IDFA<InsnType extends IInstruction>
      Parameters:
      varid - variable id
      addr0 - start address, exclusive
      addr1 - final address, also exclusive
      Returns:
      success indicator; null means unknown
    • isVarReachingFromTo

      public Boolean isVarReachingFromTo(int varid, IBasicBlock<InsnType> b0, int i0, IBasicBlock<InsnType> b1, int i1)
      Description copied from interface: IDFA
      Determine if a variable used by the start instruction reaches the final instruction with the same value. This method provides a must-reach result: if a multiple paths exist from start to end, where the variable reaches the end via some paths, but not on others (it is overwritten), the method returns false.
      Specified by:
      isVarReachingFromTo in interface IDFA<InsnType extends IInstruction>
      Parameters:
      varid - variable id
      b0 - start block
      i0 - final block
      b1 - index of the start instruction in the start block, exclusive
      i1 - index of the final instruction in the final block, also exclusive
      Returns:
      success indicator; null means unknown
    • toString

      public String toString()
      Overrides:
      toString in class Object