Class TypeAnalysis

java.lang.Object
edu.umd.cs.findbugs.ba.BasicAbstractDataflowAnalysis<TypeFrame>
edu.umd.cs.findbugs.ba.AbstractDataflowAnalysis<TypeFrame>
edu.umd.cs.findbugs.ba.ForwardDataflowAnalysis<TypeFrame>
edu.umd.cs.findbugs.ba.FrameDataflowAnalysis<org.apache.bcel.generic.Type, TypeFrame>
edu.umd.cs.findbugs.ba.type.TypeAnalysis
All Implemented Interfaces:
DataflowAnalysis<TypeFrame>, EdgeTypes
Direct Known Subclasses:
FindRefComparison.SpecialTypeAnalysis
public class TypeAnalysis extends FrameDataflowAnalysis<org.apache.bcel.generic.Type, TypeFrame> implements EdgeTypes

A forward dataflow analysis to determine the types of all values in the Java stack frame at all points in a Java method. The values include local variables and values on the Java operand stack.

As a side effect, the analysis computes the exception set throwable on each exception edge in the CFG. This information can be used to prune infeasible exception edges, and mark exception edges which propagate only implicit exceptions.

See Also:

  • Field Details

  • Constructor Details

    • TypeAnalysis

      public TypeAnalysis(org.apache.bcel.classfile.Method method, org.apache.bcel.generic.MethodGen methodGen, CFG cfg, DepthFirstSearch dfs, TypeMerger typeMerger, TypeFrameModelingVisitor visitor, RepositoryLookupFailureCallback lookupFailureCallback, ExceptionSetFactory exceptionSetFactory)
      Constructor.
      Parameters:
      method - TODO
      methodGen - the MethodGen whose CFG we'll be analyzing
      cfg - the control flow graph
      dfs - DepthFirstSearch of the method
      typeMerger - object to merge types
      visitor - a TypeFrameModelingVisitor to use to model the effect of instructions
      lookupFailureCallback - lookup failure callback
      exceptionSetFactory - factory for creating ExceptionSet objects

    • TypeAnalysis

      public TypeAnalysis(org.apache.bcel.classfile.Method method, org.apache.bcel.generic.MethodGen methodGen, CFG cfg, DepthFirstSearch dfs, TypeMerger typeMerger, RepositoryLookupFailureCallback lookupFailureCallback, ExceptionSetFactory exceptionSetFactory)
      Constructor.
      Parameters:
      method - TODO
      methodGen - the MethodGen whose CFG we'll be analyzing
      cfg - the control flow graph
      dfs - DepthFirstSearch of the method
      typeMerger - object to merge types
      lookupFailureCallback - lookup failure callback
      exceptionSetFactory - factory for creating ExceptionSet objects

    • TypeAnalysis

      public TypeAnalysis(org.apache.bcel.classfile.Method method, org.apache.bcel.generic.MethodGen methodGen, CFG cfg, DepthFirstSearch dfs, RepositoryLookupFailureCallback lookupFailureCallback, ExceptionSetFactory exceptionSetFactory)
      Constructor which uses StandardTypeMerger.
      Parameters:
      method - TODO
      methodGen - the MethodGen whose CFG we'll be analyzing
      cfg - the control flow graph
      dfs - DepthFirstSearch of the method
      lookupFailureCallback - callback for Repository lookup failures
      exceptionSetFactory - factory for creating ExceptionSet objects

  • Method Details

    • setValueNumberDataflow

      public void setValueNumberDataflow(ValueNumberDataflow valueNumberDataflow)
      Set the ValueNumberDataflow for the method being analyzed. This is optional; if set, it will be used to make instanceof instructions more precise.
      Parameters:
      valueNumberDataflow - the ValueNumberDataflow

    • setFieldStoreTypeDatabase

      public void setFieldStoreTypeDatabase(FieldStoreTypeDatabase database)
      Set the FieldStoreTypeDatabase. This can be used to get more accurate types for values loaded from fields.
      Parameters:
      database - the FieldStoreTypeDatabase

    • getEdgeExceptionSet

      public ExceptionSet getEdgeExceptionSet(Edge edge)
      Get the set of exceptions that can be thrown on given edge. This should only be called after the analysis completes.
      Parameters:
      edge - the Edge
      Returns:
      the ExceptionSet

    • createFact

      public TypeFrame createFact()
      Description copied from interface: DataflowAnalysis
      Create empty (uninitialized) dataflow facts for one program point. A valid value will be copied into it before it is used.
      Specified by:
      createFact in interface DataflowAnalysis<TypeFrame>

    • initEntryFact

      public void initEntryFact(TypeFrame result)
      Description copied from interface: DataflowAnalysis
      Initialize the "entry" fact for the graph.
      Specified by:
      initEntryFact in interface DataflowAnalysis<TypeFrame>

    • copy

      public void copy(TypeFrame source, TypeFrame dest)
      Description copied from interface: DataflowAnalysis
      Copy dataflow facts.
      Specified by:
      copy in interface DataflowAnalysis<TypeFrame>
      Overrides:
      copy in class FrameDataflowAnalysis<org.apache.bcel.generic.Type, TypeFrame>

    • makeFactTop

      public void makeFactTop(TypeFrame fact)
      Description copied from interface: DataflowAnalysis
      Make given fact the top value.
      Specified by:
      makeFactTop in interface DataflowAnalysis<TypeFrame>
      Overrides:
      makeFactTop in class FrameDataflowAnalysis<org.apache.bcel.generic.Type, TypeFrame>

    • isFactValid

      public boolean isFactValid(TypeFrame fact)
      Description copied from class: AbstractDataflowAnalysis
      Determine whether the given fact is valid (neither top nor bottom).
      Overrides:
      isFactValid in class FrameDataflowAnalysis<org.apache.bcel.generic.Type, TypeFrame>

    • same

      public boolean same(TypeFrame fact1, TypeFrame fact2)
      Description copied from interface: DataflowAnalysis
      Are given dataflow facts the same?
      Specified by:
      same in interface DataflowAnalysis<TypeFrame>
      Overrides:
      same in class FrameDataflowAnalysis<org.apache.bcel.generic.Type, TypeFrame>

    • transferInstruction

      public void transferInstruction(org.apache.bcel.generic.InstructionHandle handle, BasicBlock basicBlock, TypeFrame fact) throws DataflowAnalysisException
      Description copied from class: AbstractDataflowAnalysis
      Transfer function for a single instruction.
      Specified by:
      transferInstruction in class AbstractDataflowAnalysis<TypeFrame>
      Parameters:
      handle - the instruction
      basicBlock - the BasicBlock containing the instruction; needed to disambiguate instructions in inlined JSR subroutines
      fact - which should be modified based on the instruction
      Throws:
      DataflowAnalysisException

    • transfer

      public void transfer(BasicBlock basicBlock, @CheckForNull org.apache.bcel.generic.InstructionHandle end, TypeFrame start, TypeFrame result) throws DataflowAnalysisException
      Description copied from interface: DataflowAnalysis
      Transfer function for the analysis. Taking dataflow facts at start (which might be either the entry or exit of the block, depending on whether the analysis is forwards or backwards), modify result to be the facts at the other end of the block.
      Specified by:
      transfer in interface DataflowAnalysis<TypeFrame>
      Overrides:
      transfer in class AbstractDataflowAnalysis<TypeFrame>
      Parameters:
      basicBlock - the basic block
      end - if nonnull, stop before considering this instruction; otherwise, consider all of the instructions in the basic block
      start - dataflow facts at beginning of block (if forward analysis) or end of block (if backwards analysis)
      result - resulting dataflow facts at other end of block
      Throws:
      DataflowAnalysisException

    • computeThrownExceptionTypes

      private void computeThrownExceptionTypes(BasicBlock basicBlock, @CheckForNull org.apache.bcel.generic.InstructionHandle end, TypeFrame result) throws DataflowAnalysisException
      Throws:
      DataflowAnalysisException

    • meetInto

      public void meetInto(TypeFrame fact, Edge edge, TypeFrame result) throws DataflowAnalysisException
      Description copied from interface: DataflowAnalysis
      Meet a dataflow fact associated with an incoming edge into another fact. This is used to determine the start fact for a basic block.
      Specified by:
      meetInto in interface DataflowAnalysis<TypeFrame>
      Parameters:
      fact - the predecessor fact (incoming edge)
      edge - the edge from the predecessor
      result - the result fact
      Throws:
      DataflowAnalysisException

    • handleInstanceOfBranch

      private TypeFrame handleInstanceOfBranch(TypeFrame fact, TypeFrame tmpFact, Edge edge)

    • mergeValues

      protected void mergeValues(TypeFrame otherFrame, TypeFrame resultFrame, int slot) throws DataflowAnalysisException
      Description copied from class: FrameDataflowAnalysis
      Merge the values contained in a given slot of two Frames.
      Specified by:
      mergeValues in class FrameDataflowAnalysis<org.apache.bcel.generic.Type, TypeFrame>
      Parameters:
      otherFrame - a Frame
      resultFrame - a Frame which will contain the resulting merged value
      slot - a slot in both frames
      Throws:
      DataflowAnalysisException

    • getCachedExceptionSet

      private TypeAnalysis.CachedExceptionSet getCachedExceptionSet(BasicBlock basicBlock)
      Get the cached set of exceptions that can be thrown from given basic block. If this information hasn't been computed yet, then an empty exception set is returned.
      Parameters:
      basicBlock - the block to get the cached exception set for
      Returns:
      the CachedExceptionSet for the block

    • computeBlockExceptionSet

      private TypeAnalysis.CachedExceptionSet computeBlockExceptionSet(BasicBlock basicBlock, TypeFrame result) throws DataflowAnalysisException
      Compute the set of exceptions that can be thrown from the given basic block. This should only be called if the existing cached exception set is out of date.
      Parameters:
      basicBlock - the basic block
      result - the result fact for the block; this is used to determine whether or not the cached exception set is up to date
      Returns:
      the cached exception set for the block
      Throws:
      DataflowAnalysisException

    • computeEdgeExceptionSet

      private ExceptionSet computeEdgeExceptionSet(Edge edge, ExceptionSet thrownExceptionSet)
      Based on the set of exceptions that can be thrown from the source basic block, compute the set of exceptions that can propagate along given exception edge. This method should be called for each outgoing exception edge in sequence, so the caught exceptions can be removed from the thrown exception set as needed.
      Parameters:
      edge - the exception edge
      thrownExceptionSet - current set of exceptions that can be thrown, taking earlier (higher priority) exception edges into account
      Returns:
      the set of exceptions that can propagate along this edge

    • handlerBlockCatches

      private boolean handlerBlockCatches(org.apache.bcel.generic.ObjectType catchType, org.apache.bcel.generic.ObjectType thrownType) throws ClassNotFoundException
      Returns:
      true if the block catching catchType (which might be a multi-catch block) is catching exceptions of type thrownType
      Throws:
      ClassNotFoundException

    • computeThrownExceptionTypes

      private ExceptionSet computeThrownExceptionTypes(BasicBlock basicBlock) throws DataflowAnalysisException
      Compute the set of exception types that can be thrown by given basic block.
      Parameters:
      basicBlock - the basic block
      Returns:
      the set of exceptions that can be thrown by the block
      Throws:
      DataflowAnalysisException

    • toString

      public String toString()
      Overrides:
      toString in class Object

    • isImpliedByGenericTypes

      public boolean isImpliedByGenericTypes(org.apache.bcel.generic.ReferenceType t)