Refactor ExecutingInvocationUnit to use customizable executors

base/src/main/java/proguard/analysis/cpa/jvm/domain/value/JvmValueTransferRelation.java

@@ -7,6 +7,8 @@
 
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.Deque;
+import java.util.LinkedList;
 import java.util.List;
 import proguard.analysis.cpa.defaults.StackAbstractState;
 import proguard.analysis.cpa.interfaces.AbstractState;
@@ -120,6 +122,26 @@ public ValueAbstractState getAbstractReferenceValue(
             value));
   }
 
+  @Override
+  protected void processCall(JvmAbstractState<ValueAbstractState> state, Call call) {
+    Deque<ValueAbstractState> operands = new LinkedList<>();
+    if (call.getTarget().descriptor.argumentTypes != null) {
+      List<String> argumentTypes = call.getTarget().descriptor.argumentTypes;
+      for (int i = argumentTypes.size() - 1; i >= 0; i--) {
+        boolean isCategory2 = ClassUtil.isInternalCategory2Type(argumentTypes.get(i));
+        operands.offerFirst(state.pop());
+        if (isCategory2) {
+          // ExecutingInvocationUnit expects a single parameter for category 2 values
+          state.pop();
+        }
+      }
+    }
+    if (!call.isStatic()) {
+      operands.offerFirst(state.pop());
+    }
+    invokeMethod(state, call, (List<ValueAbstractState>) operands);
+  }
+
   @Override
   public void invokeMethod(
       JvmAbstractState<ValueAbstractState> state, Call call, List<ValueAbstractState> operands) {
@@ -135,7 +157,7 @@ public void invokeMethod(
       String internalReturnClassName = ClassUtil.internalClassNameFromType(returnType);
       if (returnType != null
           && internalReturnClassName != null
-          && executingInvocationUnit.isSupportedClass(internalReturnClassName)) {
+          && executingInvocationUnit.isSupportedMethodCall(internalReturnClassName, null)) {
         // we can at most know the return type
         pushReturnTypedValue(state, operands, (ConcreteCall) call, returnType);
         return;
@@ -151,9 +173,16 @@ private void executeMethod(
       List<ValueAbstractState> operands) {
     Clazz targetClass = call.getTargetClass();
     Method targetMethod = call.getTargetMethod();
+
     Value[] operandsArray =
         operands.stream().map(ValueAbstractState::getValue).toArray(Value[]::new);
 
+    if (operandsArray.length
+        != ClassUtil.internalMethodParameterCount(
+            call.getTarget().descriptor.toString(), call.isStatic())) {
+      throw new IllegalStateException("Unexpected number of parameters");
+    }
+
     Value result = executingInvocationUnit.executeMethod(call, operandsArray);
     String returnType = internalMethodReturnType(targetMethod.getDescriptor(targetClass));
 

base/src/main/java/proguard/classfile/JavaConstants.java

@@ -26,6 +26,14 @@
 public class JavaConstants {
   public static final String JAVA_FILE_EXTENSION = ".java";
 
+  public static final String TYPE_JAVA_LANG_BOOLEAN = "java.lang.Boolean";
+  public static final String TYPE_JAVA_LANG_INTEGER = "java.lang.Integer";
+  public static final String TYPE_JAVA_LANG_LONG = "java.lang.Long";
+  public static final String TYPE_JAVA_LANG_CHARACTER = "java.lang.Character";
+  public static final String TYPE_JAVA_LANG_BYTE = "java.lang.Byte";
+  public static final String TYPE_JAVA_LANG_SHORT = "java.lang.Short";
+  public static final String TYPE_JAVA_LANG_FLOAT = "java.lang.Float";
+  public static final String TYPE_JAVA_LANG_DOUBLE = "java.lang.Double";
   public static final String TYPE_JAVA_LANG_OBJECT = "java.lang.Object";
   public static final String TYPE_JAVA_LANG_STRING = "java.lang.String";
   public static final String TYPE_JAVA_LANG_CLASS = "java.lang.Class";

base/src/main/java/proguard/evaluation/executor/Executor.java

@@ -0,0 +1,90 @@
+/*
+ * ProGuardCORE -- library to process Java bytecode.
+ *
+ * Copyright (c) 2002-2023 Guardsquare NV
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package proguard.evaluation.executor;
+
+import java.util.Optional;
+import proguard.classfile.MethodSignature;
+import proguard.evaluation.ExecutingInvocationUnit;
+import proguard.evaluation.executor.instancehandler.ExecutorInstanceHandler;
+import proguard.evaluation.executor.matcher.ExecutorMatcher;
+import proguard.evaluation.value.ReferenceValue;
+import proguard.evaluation.value.Value;
+
+/**
+ * This abstract class specifies a modular component which can be added to a {@link
+ * ExecutingInvocationUnit} in order to extend its capabilities. An {@link Executor} specifies which
+ * method calls it supports, what methods return their own instance and how a method result is
+ * calculated.
+ */
+public abstract class Executor {
+  protected ExecutorMatcher executorMatcher;
+  protected ExecutorInstanceHandler instanceHandler;
+
+  /**
+   * Calculate the result of a given method. This is the return value for a non-constructor method
+   * (<c>null</c> if it returns <c>void</c>) and the instantiated object for a constructor.
+   *
+   * @param methodData Information about the called method.
+   * @param instance The {@link ReferenceValue} of the instance, <c>null</c> for static methods.
+   * @param callingInstance The instance object, <c>null</c> for static methods.
+   * @param parameters An array of the parameter values of the method call.
+   * @return The result of the method call wrapped in an optional. <code>Optional.empty()</code> if
+   *     a result could not be calculated.
+   */
+  public abstract MethodResult<Object> getMethodResult(
+      MethodExecutionInfo methodData,
+      ReferenceValue instance,
+      Object callingInstance,
+      Value[] parameters);
+
+  /**
+   * Returns whether a certain method invocation is supported.
+   *
+   * @param signature The method signature.
+   * @return whether the method invocation is supported.
+   */
+  public boolean isSupportedMethodCall(MethodSignature signature) {
+    return executorMatcher.matches(signature);
+  }
+
+  /**
+   * Returns whether a certain method invocation is assumed to return its own instance. This
+   * indicates whether replacing the instance reference in the stack and variables is necessary.
+   *
+   * @param signature The method signature.
+   * @param returnsSameTypeAsInstance whether the method has matching return and instance types
+   * @return whether the method returns its own instance.
+   */
+  public boolean returnsOwnInstance(MethodSignature signature, boolean returnsSameTypeAsInstance) {
+    return returnsSameTypeAsInstance
+        && instanceHandler.returnsOwnInstance(signature.getClassName(), signature.method);
+  }
+
+  /**
+   * Get an object which will act as the calling instance. If we know that executing the method does
+   * not modify the instance this can just be the same value. Otherwise, a copy should be returned
+   * in order to not change the reference whose state may be of interest at the end of an analysis.
+   *
+   * @param instanceValue The {@link ReferenceValue} of the instance.
+   * @param className The name of the class of the instance.
+   * @return The new calling instance.
+   */
+  public abstract Optional<Object> getInstanceCopyIfMutable(
+      ReferenceValue instanceValue, String className);
+}

base/src/main/java/proguard/evaluation/executor/MethodExecutionInfo.java

@@ -0,0 +1,200 @@
+/*
+ * ProGuardCORE -- library to process Java bytecode.
+ *
+ * Copyright (c) 2002-2023 Guardsquare NV
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package proguard.evaluation.executor;
+
+import static proguard.classfile.AccessConstants.STATIC;
+import static proguard.classfile.ClassConstants.METHOD_NAME_INIT;
+
+import java.util.Optional;
+import proguard.analysis.datastructure.CodeLocation;
+import proguard.analysis.datastructure.callgraph.ConcreteCall;
+import proguard.classfile.Clazz;
+import proguard.classfile.Method;
+import proguard.classfile.MethodSignature;
+import proguard.classfile.Signature;
+import proguard.classfile.constant.AnyMethodrefConstant;
+import proguard.classfile.util.ClassUtil;
+import proguard.classfile.visitor.ReturnClassExtractor;
+import proguard.evaluation.value.IdentifiedReferenceValue;
+import proguard.evaluation.value.ReferenceValue;
+import proguard.evaluation.value.Value;
+
+/**
+ * This class stores data relevant to modeling the execution of a method and offers methods to
+ * extract additional information.
+ */
+public class MethodExecutionInfo {
+  private final MethodSignature signature;
+  private final CodeLocation caller;
+  private final boolean isConstructor;
+  private final boolean isStatic;
+  private final String returnType;
+  private final Clazz resultClass;
+  private final String resultType;
+
+  /**
+   * Constructs a MethodExecutionInfo.
+   *
+   * @param clazz The referenced class.
+   * @param method The referenced method.
+   * @param caller The code location of the call site. May be null.
+   */
+  public MethodExecutionInfo(Clazz clazz, Method method, CodeLocation caller) {
+    signature = (MethodSignature) Signature.of(clazz, method);
+    this.caller = caller;
+
+    returnType = ClassUtil.internalMethodReturnType(signature.descriptor.toString());
+    isConstructor = signature.method.equals(METHOD_NAME_INIT);
+    isStatic = (method.getAccessFlags() & STATIC) != 0;
+
+    if (isConstructor) {
+      // For a Constructor, we always return a type, even if the return type of the method would be
+      // void.
+      resultClass = clazz;
+    } else {
+      // Get the class of the return type, if available, null otherwise.
+      ReturnClassExtractor returnClassExtractor = new ReturnClassExtractor();
+      method.accept(clazz, returnClassExtractor);
+      resultClass = returnClassExtractor.returnClass;
+    }
+    resultType =
+        resultClass != null && isConstructor
+            ? ClassUtil.internalTypeFromClassName(resultClass.getName())
+            : returnType;
+  }
+
+  /**
+   * Constructs a MethodExecutionInfo.
+   *
+   * @param anyMethodrefConstant A method reference constant. Requires referenced class to be
+   *     initialized (using {@link proguard.classfile.util.ClassReferenceInitializer}.
+   * @param caller The code location of the call site. May be null.
+   */
+  public MethodExecutionInfo(AnyMethodrefConstant anyMethodrefConstant, CodeLocation caller) {
+    this(anyMethodrefConstant.referencedClass, anyMethodrefConstant.referencedMethod, caller);
+  }
+
+  /**
+   * Constructs a MethodExecutionInfo.
+   *
+   * @param call the concrete call.
+   */
+  public MethodExecutionInfo(ConcreteCall call) {
+    this(call.getTargetClass(), call.getTargetMethod(), call.caller);
+  }
+
+  /** Get the method signature of the method */
+  public MethodSignature getSignature() {
+    return signature;
+  }
+
+  /** Get the code location of the call site */
+  public Optional<CodeLocation> getCaller() {
+    return Optional.ofNullable(caller);
+  }
+
+  /** Return whether the method is a constructor. */
+  public boolean isConstructor() {
+    return isConstructor;
+  }
+
+  /** Return whether the method is static. */
+  public boolean isStatic() {
+    return isStatic;
+  }
+
+  /** Get the return type of the method. */
+  public String getReturnType() {
+    return returnType;
+  }
+
+  /**
+   * Get the result class of the method. If the method is a constructor, this will be the class of
+   * the instance.
+   */
+  public Clazz getResultClass() {
+    return resultClass;
+  }
+
+  /**
+   * Get the result type of the method. If the method is a constructor, this will be the type of the
+   * instance.
+   */
+  public String getResultType() {
+    return resultType;
+  }
+
+  /** Get the {@link ReferenceValue} of the instance. */
+  public Optional<ReferenceValue> getInstanceValue(Value instance) {
+    return instance instanceof ReferenceValue
+        ? Optional.of(instance.referenceValue())
+        : Optional.empty();
+  }
+
+  /** Get the reference value of the instance. */
+  public Optional<ReferenceValue> getInstanceValue(Value[] parameters) {
+    return parameters != null && !isStatic ? getInstanceValue(parameters[0]) : Optional.empty();
+  }
+
+  /** Get the object ID for the instance value. */
+  public Optional<Object> getObjectId(ReferenceValue instanceValue) {
+    return instanceValue instanceof IdentifiedReferenceValue
+        ? Optional.of(((IdentifiedReferenceValue) instanceValue).id)
+        : Optional.empty();
+  }
+
+  /** Get the calling instance using the copy behavior defined by the executor. */
+  public Optional<Object> getCallingInstance(Executor executor, Value[] parameters) {
+    return getInstanceValue(parameters)
+        .flatMap(instanceValue -> getCallingInstance(executor, instanceValue));
+  }
+
+  /** Get the calling instance using the copy behavior defined by the executor. */
+  public Optional<Object> getCallingInstance(Executor executor, ReferenceValue instanceValue) {
+    return (instanceValue != null && instanceValue.isParticular() && !isConstructor)
+        ? executor.getInstanceCopyIfMutable(instanceValue, signature.getClassName())
+        : Optional.empty();
+  }
+
+  /** Get the type of the instance. */
+  public Optional<String> getInstanceType(ReferenceValue instanceValue) {
+    return instanceValue != null ? Optional.of(instanceValue.internalType()) : Optional.empty();
+  }
+
+  /** Return whether the return and instance types of the method match. */
+  public boolean returnsSameTypeAsInstance(Value[] parameters) {
+    return getInstanceValue(parameters).map(this::returnsSameTypeAsInstance).orElse(false);
+  }
+
+  /** Return whether the return and instance types of the method match. */
+  public boolean returnsSameTypeAsInstance(Value instance) {
+    return getInstanceValue(instance).map(this::returnsSameTypeAsInstance).orElse(false);
+  }
+
+  /** Return whether the return and instance types of the method match. */
+  public boolean returnsSameTypeAsInstance(ReferenceValue instance) {
+    return getInstanceValue(instance)
+        .map(
+            instanceValue ->
+                getInstanceType(instanceValue)
+                    .map(instanceType -> instanceType.equals(returnType))
+                    .orElse(false))
+        .orElse(false);
+  }
+}