Package proguard.analysis

Class CallResolver

  • All Implemented Interfaces:
    AttributeVisitor, InstructionVisitor, ClassVisitor
    public class CallResolver
extends java.lang.Object
implements AttributeVisitor, ClassVisitor, InstructionVisitor
    Collects all method invocations inside the analyzed methods.

    All method invocation instructions that appear in the bytecode are inspected, and their actual target method is calculated. Java has several invocation instructions, performing virtual, static, dynamic, interface and special calls. While most of these instructions have a constant operand specifying a method name, the actual method that will be called at runtime depends on multiple factors. Sometimes, e.g. when using virtual calls, the invocation target depends on the specific type of the first parameter on the stack, the so-called this pointer.

    This call analyzer performs a lookup process that adheres to the Java Virtual Machine specification. Being a static analysis, 100% precision cannot be guaranteed, as the specific type of variables at a specific program point is not always known in advance. But using the PartialEvaluator in combination with intraprocedural possible type analysis of MultiTypedReferenceValue objects, the resulting call graph should be a superset of the actual calls happening at runtime. This makes it a complete but potentially unsound analysis.

    In addition to resolving the call target, this analyzer also reconstructs the corresponding arguments and the return value. All the collected information is wrapped in a Call object and passed to subscribed CallHandlers.

    • Constructor Detail

      • CallResolver

        public CallResolver​(ClassPool programClassPool,
                    ClassPool libraryClassPool,
                    CallGraph callGraph,
                    boolean clearCallValuesAfterVisit,
                    boolean useDominatorAnalysis,
                    boolean evaluateAllCode,
                    boolean includeSubClasses,
                    int maxPartialEvaluations,
                    java.util.function.Supplier<java.lang.Boolean> shouldAnalyzeNextCodeAttribute,
                    boolean skipIncompleteCalls,
                    ValueFactory arrayValueFactory,
                    boolean ignoreExceptions,
                    ExecutingInvocationUnit.Builder executingInvocationUnitBuilder,
                    boolean selectiveParameterReconstruction,
                    java.util.Set<MethodSignature> interestingMethods,
                    java.util.Set<java.util.function.Predicate<Call>> interestingCallPredicates,
                    CallHandler... callHandlers)
        Create a new call resolver.
        Parameters:
        programClassPool - ClassPool containing the classes whose calls should be analyzed.
        libraryClassPool - Auxiliary ClassPool containing framework classes. Their calls are not resolved, but the class structure information (i.e. contained methods) is needed when resolving calls whose target lies in such a library class.
        callGraph - The CallGraph to fill with all discovered Calls.
        clearCallValuesAfterVisit - If true, Call.clearValues() will be called after CallHandler.handleCall(Call, TracedStack, TracedVariables). This makes it possible to analyze arguments and the return value of calls while still adding them to a CallGraph afterward, as call graph analysis itself usually only requires the call locations and their targets, not the arguments or return value.
        useDominatorAnalysis - If true, a dominator analysis is carried out using the DominatorCalculator for each method, in order to be able to fill the Call.controlFlowDependent flag.
        evaluateAllCode - See PartialEvaluator.Builder.setEvaluateAllCode(boolean).
        includeSubClasses - If true, virtual calls on class fields, parameters and return values of other methods will take all possible subclasses into account. This is necessary for a more complete call graph, because the runtime type of these objects is not controlled by the current method. E.g. a method that declares its return type to be of type A might also return an object of type B in case B extends A. The same is true for class fields and parameters, so in order to really find all potential calls, this circumstance needs to be modeled. For objects of declared type Object this will be skipped, as the fact that every single Java class is a subclass of object would lead to an immense blow-up of the call graph.
        maxPartialEvaluations - See PartialEvaluator.Builder.stopAnalysisAfterNEvaluations(int).
        shouldAnalyzeNextCodeAttribute - If returns true, the next code attribute will be analyzed. Otherwise, the code attribute will be skipped.
        skipIncompleteCalls - If true, any discovered call that would return true for Call.hasIncompleteTarget() will be discarded and not be forwarded to CallHandler.handleCall(Call, TracedStack, TracedVariables).
        callHandlers - CallHandlers that are interested in the results of this analysis.

    • Method Detail

      • quickResolve

        public static MethodSignature quickResolve​(Instruction instruction,
                                           ProgramClass clazz)
        Lightweight utility method to resolve the target of an invocation instruction on demand, without having to run a full scale analysis. This means the following for the different invocation types:
        • invokestatic: Full target resolution possible.
        • invokevirtual, invokespecial, invokeinterface: Method name and descriptor.
        • invokedynamic: Only descriptor.
        Parameters:
        instruction - The invocation instruction to analyze.
        clazz - The ProgramClass containing this instruction.
        Returns:
        A MethodSignature containing as much information about the invocation target as we can confidently know without needing more in-depth analysis.

      • visitAnyClass

        public void visitAnyClass​(Clazz clazz)
        Description copied from interface: ClassVisitor
        Visits any Clazz instance. The more specific default implementations of this interface delegate to this method.
        Specified by:
        visitAnyClass in interface ClassVisitor

      • visitAnyAttribute

        public void visitAnyAttribute​(Clazz clazz,
                              Attribute attribute)
        Description copied from interface: AttributeVisitor
        Visits any Attribute instance. The more specific default implementations of this interface delegate to this method.
        Specified by:
        visitAnyAttribute in interface AttributeVisitor

      • getDescriptor

        public static java.lang.String getDescriptor​(java.lang.reflect.Method m)
        Get the Descriptor of a Method.