src/test/java/com/android/tools/r8/cf/methodhandles/InvalidBootstrapMethodHandleTest.java

// Copyright (c) 2020, the R8 project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
package com.android.tools.r8.cf.methodhandles;

import static org.hamcrest.CoreMatchers.containsString;
import static org.junit.Assert.fail;

import com.android.tools.r8.CompilationFailedException;
import com.android.tools.r8.TestBase;
import com.android.tools.r8.TestParameters;
import com.android.tools.r8.TestRunResult;
import com.android.tools.r8.utils.StringUtils;
import com.google.common.collect.ImmutableMap;
import java.util.List;
import java.util.Map;
import java.util.TreeSet;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.objectweb.asm.Handle;
import org.objectweb.asm.Opcodes;

@RunWith(Parameterized.class)
public class InvalidBootstrapMethodHandleTest extends TestBase {

  static final String EXPECTED = StringUtils.lines("Called foo!");

  static final Map<String, Integer> HANDLE_TYPES =
      ImmutableMap.<String, Integer>builder()
          .put("GETFIELD", Opcodes.H_GETFIELD)
          .put("GETSTATIC", Opcodes.H_GETSTATIC)
          .put("PUTFIELD", Opcodes.H_PUTFIELD)
          .put("PUTSTATIC", Opcodes.H_PUTSTATIC)
          .put("INVOKEVIRTUAL", Opcodes.H_INVOKEVIRTUAL)
          .put("INVOKESTATIC", Opcodes.H_INVOKESTATIC)
          .put("INVOKESPECIAL", Opcodes.H_INVOKESPECIAL)
          .put("NEWINVOKESPECIAL", Opcodes.H_NEWINVOKESPECIAL)
          .put("INVOKEINTERFACE", Opcodes.H_INVOKEINTERFACE)
          .build();

  private final TestParameters parameters;
  private final String handleTypeString;

  @Parameterized.Parameters(name = "{0}, {1}")
  public static List<Object[]> data() {
    return buildParameters(
        getTestParameters()
            .withAllRuntimes()
            .withApiLevelsStartingAtIncluding(apiLevelWithInvokeCustomSupport())
            .build(),
        new TreeSet<>(HANDLE_TYPES.keySet()));
  }

  public InvalidBootstrapMethodHandleTest(TestParameters parameters, String handleTypeString) {
    this.parameters = parameters;
    this.handleTypeString = handleTypeString;
  }

  private int handleTypeOpcode() {
    return HANDLE_TYPES.get(handleTypeString);
  }

  @Test
  public void test() throws Exception {
    // The compiler will fail on opcodes different from 6 and 8.
    // Investigate why 8 is supposedly valid.
    if (parameters.isDexRuntime()
        && handleTypeOpcode() != Opcodes.H_INVOKESTATIC
        && handleTypeOpcode() != Opcodes.H_NEWINVOKESPECIAL) {
      try {
        testForD8()
            .addProgramClasses(InvalidBootstrapMethodHandleTestInterface.class)
            .addProgramClassFileData(getProgramClassFileData())
            .compileWithExpectedDiagnostics(
                diagnotics ->
                    diagnotics.assertErrorMessageThatMatches(
                        containsString("Bootstrap handle invalid")));
        fail("Expected compilation to fail");
      } catch (CompilationFailedException e) {
        // Expected failure.
        return;
      }
    }
    TestRunResult<?> result =
        testForRuntime(parameters)
            .addProgramClasses(InvalidBootstrapMethodHandleTestInterface.class)
            .addProgramClassFileData(getProgramClassFileData())
            .run(parameters.getRuntime(), InvalidBootstrapMethodHandleTestClass.class);
    // The static target is valid and should run as expected.
    if (handleTypeOpcode() == Opcodes.H_INVOKESTATIC) {
      result.assertSuccessWithOutput(EXPECTED);
      return;
    }
    // The invalid targets will trigger an error due to the bootstrap method not being able to be
    // cast to the expected signature for a bootstrap method. This happens prior to invoking the
    // target of that handle.
    if (parameters.isCfRuntime()) {
      result.assertFailureWithErrorThatThrows(BootstrapMethodError.class);
      result.assertFailureWithErrorThatMatches(containsString("cannot convert"));
      result.assertFailureWithErrorThatMatches(
          containsString("to (Lookup,String,MethodType)Object"));
      return;
    }
    // D8 allows new-invoke-special type during compilation, but it is not accepted by ART.
    if (handleTypeOpcode() == Opcodes.H_NEWINVOKESPECIAL) {
      result.assertFailureWithErrorThatMatches(
          containsString("handle type is not InvokeStatic: 6"));
    }
  }

  // Each handle is returned such that the method handle itself is valid and will not cause an
  // error due to failed handle construction.
  private Handle getHandle() {
    String bootstrapSignature =
        "(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;)Ljava/lang/invoke/CallSite;";

    switch (handleTypeOpcode()) {
      case Opcodes.H_GETFIELD:
      case Opcodes.H_PUTFIELD:
        return new Handle(
            handleTypeOpcode(),
            binaryName(InvalidBootstrapMethodHandleTestClass.class),
            "nonStaticField",
            "I",
            false);

      case Opcodes.H_GETSTATIC:
      case Opcodes.H_PUTSTATIC:
        return new Handle(
            handleTypeOpcode(),
            binaryName(InvalidBootstrapMethodHandleTestClass.class),
            "staticField",
            "I",
            false);

      case Opcodes.H_INVOKESTATIC:
        return new Handle(
            handleTypeOpcode(),
            binaryName(InvalidBootstrapMethodHandleTestClass.class),
            "staticMethod",
            bootstrapSignature,
            handleTypeOpcode() == Opcodes.H_INVOKEINTERFACE);

      case Opcodes.H_INVOKEVIRTUAL:
      case Opcodes.H_INVOKESPECIAL:
        return new Handle(
            handleTypeOpcode(),
            binaryName(InvalidBootstrapMethodHandleTestClass.class),
            "virtualMethod",
            bootstrapSignature,
            false);

      case Opcodes.H_INVOKEINTERFACE:
        return new Handle(
            handleTypeOpcode(),
            binaryName(InvalidBootstrapMethodHandleTestInterface.class),
            "virtualMethod",
            bootstrapSignature,
            true);

      case Opcodes.H_NEWINVOKESPECIAL:
        return new Handle(
            handleTypeOpcode(),
            binaryName(InvalidBootstrapMethodHandleTestClass.class),
            "<init>",
            "()V",
            false);

      default:
        throw new RuntimeException("Unexpected handle type");
    }
  }

  private byte[] getProgramClassFileData() throws Exception {
    return transformer(InvalidBootstrapMethodHandleTestClass.class)
        .transformMethodInsnInMethod(
            "main",
            (opcode, owner, name, descriptor, isInterface, visitor) -> {
              if (opcode == Opcodes.INVOKESTATIC && name.equals("foo")) {
                visitor.visitInvokeDynamicInsn("foo", "()V", getHandle());
              } else {
                visitor.visitMethodInsn(opcode, owner, name, descriptor, isInterface);
              }
            })
        .transform();
  }
}