1 /*
   2  * Copyright (c) 2014, 2017, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 package jdk.vm.ci.hotspot;
  24 
  25 import static jdk.vm.ci.hotspot.CompilerToVM.compilerToVM;
  26 import static jdk.vm.ci.hotspot.HotSpotJVMCIRuntime.runtime;
  27 
  28 import java.lang.invoke.MethodHandle;
  29 import java.util.Objects;
  30 
  31 import jdk.vm.ci.common.JVMCIError;
  32 import jdk.vm.ci.meta.ConstantReflectionProvider;
  33 import jdk.vm.ci.meta.JavaConstant;
  34 import jdk.vm.ci.meta.MethodHandleAccessProvider;
  35 import jdk.vm.ci.meta.ResolvedJavaField;
  36 import jdk.vm.ci.meta.ResolvedJavaMethod;
  37 import jdk.vm.ci.meta.ResolvedJavaType;
  38 
  39 public class HotSpotMethodHandleAccessProvider implements MethodHandleAccessProvider {
  40 
  41     private final ConstantReflectionProvider constantReflection;
  42 
  43     public HotSpotMethodHandleAccessProvider(ConstantReflectionProvider constantReflection) {
  44         this.constantReflection = constantReflection;
  45     }
  46 
  47     /**
  48      * Lazy initialization to break class initialization cycle. Field and method lookup is only
  49      * possible after the {@link HotSpotJVMCIRuntime} is fully initialized.
  50      */
  51     static class LazyInitialization {
  52         static final ResolvedJavaType lambdaFormType;
  53         static final ResolvedJavaField methodHandleFormField;
  54         static final ResolvedJavaField lambdaFormVmentryField;
  55         static final ResolvedJavaField methodField;
  56         static final HotSpotResolvedJavaField vmtargetField;
  57 
  58         /**
  59          * Search for an instance field with the given name in a class.
  60          *
  61          * @param declaringType the type declaring the field
  62          * @param fieldName name of the field to be searched
  63          * @param fieldType resolved Java type of the field
  64          * @return resolved Java field
  65          * @throws NoSuchFieldError
  66          */
  67         private static ResolvedJavaField findFieldInClass(ResolvedJavaType declaringType, String fieldName, ResolvedJavaType fieldType) {
  68             ResolvedJavaField[] fields = declaringType.getInstanceFields(false);
  69             for (ResolvedJavaField field : fields) {
  70                 if (field.getName().equals(fieldName) && field.getType().equals(fieldType)) {
  71                     return field;
  72                 }
  73             }
  74             throw new NoSuchFieldError(fieldType.getName() + " " + declaringType + "." + fieldName);
  75         }
  76 
  77         private static ResolvedJavaType resolveType(Class<?> c) {
  78             return runtime().fromClass(c);
  79         }
  80 
  81         private static ResolvedJavaType resolveType(String className) throws ClassNotFoundException {
  82             return resolveType(Class.forName(className));
  83         }
  84 
  85         static {
  86             try {
  87                 ResolvedJavaType methodHandleType = resolveType(MethodHandle.class);
  88                 ResolvedJavaType memberNameType = resolveType("java.lang.invoke.MemberName");
  89                 lambdaFormType = resolveType("java.lang.invoke.LambdaForm");
  90                 methodHandleFormField = findFieldInClass(methodHandleType, "form", lambdaFormType);
  91                 lambdaFormVmentryField = findFieldInClass(lambdaFormType, "vmentry", memberNameType);
  92                 ResolvedJavaType methodType = resolveType("java.lang.invoke.ResolvedMethodName");
  93                 methodField = findFieldInClass(memberNameType, "method", methodType);
  94                 vmtargetField = (HotSpotResolvedJavaField) findFieldInClass(methodType, "vmtarget", resolveType(HotSpotJVMCIRuntime.getHostWordKind().toJavaClass()));
  95 
  96             } catch (Throwable ex) {
  97                 throw new JVMCIError(ex);
  98             }
  99         }
 100     }
 101 
 102     @Override
 103     public IntrinsicMethod lookupMethodHandleIntrinsic(ResolvedJavaMethod method) {
 104         int intrinsicId = ((HotSpotResolvedJavaMethodImpl) method).intrinsicId();
 105         if (intrinsicId != 0) {
 106             return getMethodHandleIntrinsic(intrinsicId);
 107         }
 108         return null;
 109     }
 110 
 111     public static IntrinsicMethod getMethodHandleIntrinsic(int intrinsicId) {
 112         HotSpotVMConfig config = runtime().getConfig();
 113         if (intrinsicId == config.vmIntrinsicInvokeBasic) {
 114             return IntrinsicMethod.INVOKE_BASIC;
 115         } else if (intrinsicId == config.vmIntrinsicLinkToInterface) {
 116             return IntrinsicMethod.LINK_TO_INTERFACE;
 117         } else if (intrinsicId == config.vmIntrinsicLinkToSpecial) {
 118             return IntrinsicMethod.LINK_TO_SPECIAL;
 119         } else if (intrinsicId == config.vmIntrinsicLinkToStatic) {
 120             return IntrinsicMethod.LINK_TO_STATIC;
 121         } else if (intrinsicId == config.vmIntrinsicLinkToVirtual) {
 122             return IntrinsicMethod.LINK_TO_VIRTUAL;
 123         }
 124         return null;
 125     }
 126 
 127     @Override
 128     public ResolvedJavaMethod resolveInvokeBasicTarget(JavaConstant methodHandle, boolean forceBytecodeGeneration) {
 129         if (methodHandle.isNull()) {
 130             return null;
 131         }
 132 
 133         /* Load non-public field: LambdaForm MethodHandle.form */
 134         JavaConstant lambdaForm = constantReflection.readFieldValue(LazyInitialization.methodHandleFormField, methodHandle);
 135         if (lambdaForm == null || lambdaForm.isNull()) {
 136             return null;
 137         }
 138 
 139         JavaConstant memberName = constantReflection.readFieldValue(LazyInitialization.lambdaFormVmentryField, lambdaForm);
 140         if (memberName.isNull() && forceBytecodeGeneration) {
 141             Object lf = ((HotSpotObjectConstant) lambdaForm).asObject(LazyInitialization.lambdaFormType);
 142             compilerToVM().compileToBytecode(Objects.requireNonNull(lf));
 143             memberName = constantReflection.readFieldValue(LazyInitialization.lambdaFormVmentryField, lambdaForm);
 144             assert memberName.isNonNull();
 145         }
 146         JavaConstant method = constantReflection.readFieldValue(LazyInitialization.methodField, memberName);
 147         return getTargetMethod(method);
 148     }
 149 
 150     @Override
 151     public ResolvedJavaMethod resolveLinkToTarget(JavaConstant memberName) {
 152         if (memberName.isNull()) {
 153             return null;
 154         }
 155         JavaConstant method = constantReflection.readFieldValue(LazyInitialization.methodField, memberName);
 156         return getTargetMethod(method);
 157     }
 158 
 159     /**
 160      * Returns the {@link ResolvedJavaMethod} for the method of a java.lang.invoke.MemberName.
 161      */
 162     private static ResolvedJavaMethod getTargetMethod(JavaConstant method) {
 163         if (method == null) {
 164             // If readFieldValue returns NULL the type was wrong
 165             throw new IllegalArgumentException("unexpected type for memberName");
 166         }
 167 
 168         Object object = ((HotSpotObjectConstantImpl) method).object();
 169         /* Read the ResolvedJavaMethod from the injected field MemberName.method.vmtarget */
 170         return compilerToVM().getResolvedJavaMethod(object, LazyInitialization.vmtargetField.getOffset());
 171     }
 172 }