1 /*

     2  * Copyright (c) 2018, 2019, 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 java.lang.annotation.Annotation;

    26 import java.lang.reflect.Type;

    27 

    28 import jdk.vm.ci.meta.JavaConstant;

    29 import jdk.vm.ci.meta.JavaKind;

    30 import jdk.vm.ci.meta.ResolvedJavaMethod;

    31 import jdk.vm.ci.meta.ResolvedJavaType;

    32 

    33 /**

    34  * Reflection interface for reflecting on the internals of HotSpot JVMCI types and objects.

    35  */

    36 abstract class HotSpotJVMCIReflection {

    37 

    38     abstract boolean isInstance(HotSpotResolvedObjectTypeImpl holder, HotSpotObjectConstantImpl obj);

    39 

    40     abstract boolean isAssignableFrom(HotSpotResolvedObjectTypeImpl holder, HotSpotResolvedObjectTypeImpl otherType);

    41 

    42     abstract Annotation[] getAnnotations(HotSpotResolvedObjectTypeImpl holder);

    43 

    44     abstract Annotation[] getDeclaredAnnotations(HotSpotResolvedObjectTypeImpl holder);

    45 

    46     abstract <T extends Annotation> T getAnnotation(HotSpotResolvedObjectTypeImpl holder, Class<T> annotationClass);

    47 

    48     abstract boolean isLocalClass(HotSpotResolvedObjectTypeImpl holder);

    49 

    50     abstract boolean isMemberClass(HotSpotResolvedObjectTypeImpl holder);

    51 

    52     abstract HotSpotResolvedObjectType getEnclosingClass(HotSpotResolvedObjectTypeImpl holder);

    53 

    54     abstract JavaConstant readFieldValue(HotSpotResolvedObjectTypeImpl holder, HotSpotResolvedJavaField field, boolean isVolatile);

    55 

    56     abstract JavaConstant readFieldValue(HotSpotObjectConstantImpl object, HotSpotResolvedJavaField field, boolean isVolatile);

    57 

    58     abstract boolean equals(HotSpotObjectConstantImpl hotSpotResolvedJavaType, HotSpotObjectConstantImpl that);

    59 

    60     abstract JavaConstant getJavaMirror(HotSpotResolvedPrimitiveType hotSpotResolvedJavaType);

    61 

    62     abstract ResolvedJavaMethod.Parameter[] getParameters(HotSpotResolvedJavaMethodImpl javaMethod);

    63 

    64     abstract Annotation[][] getParameterAnnotations(HotSpotResolvedJavaMethodImpl javaMethod);

    65 

    66     abstract Type[] getGenericParameterTypes(HotSpotResolvedJavaMethodImpl javaMethod);

    67 

    68     abstract Annotation[] getFieldAnnotations(HotSpotResolvedJavaFieldImpl javaMethod);

    69 

    70     abstract Annotation[] getMethodAnnotations(HotSpotResolvedJavaMethodImpl javaField);

    71 

    72     abstract Annotation[] getMethodDeclaredAnnotations(HotSpotResolvedJavaMethodImpl javaMethod);

    73 

    74     abstract Annotation[] getFieldDeclaredAnnotations(HotSpotResolvedJavaFieldImpl javaMethod);

    75 

    76     abstract <T extends Annotation> T getMethodAnnotation(HotSpotResolvedJavaMethodImpl javaMethod, Class<T> annotationClass);

    77 

    78     abstract HotSpotResolvedObjectTypeImpl getType(HotSpotObjectConstantImpl object);

    79 

    80     abstract String asString(HotSpotObjectConstantImpl object);

    81 

    82     /**

    83      * Given a {@link java.lang.Class} instance, return the corresponding ResolvedJavaType.

    84      */

    85     abstract ResolvedJavaType asJavaType(HotSpotObjectConstantImpl object);

    86 

    87     abstract <T> T asObject(HotSpotObjectConstantImpl object, Class<T> type);

    88 

    89     abstract Object asObject(HotSpotObjectConstantImpl object, HotSpotResolvedJavaType type);

    90 

    91     abstract String formatString(HotSpotObjectConstantImpl object);

    92 

    93     abstract Integer getLength(HotSpotObjectConstantImpl arrayObject);

    94 

    95     abstract JavaConstant readArrayElement(HotSpotObjectConstantImpl arrayObject, int index);

    96 

    97     abstract JavaConstant unboxPrimitive(HotSpotObjectConstantImpl source);

    98 

    99     abstract JavaConstant forObject(Object value);

   100 

   101     abstract JavaConstant boxPrimitive(JavaConstant source);

   102 

   103     abstract int getInt(HotSpotObjectConstantImpl object, long displacement);

   104 

   105     abstract byte getByte(HotSpotObjectConstantImpl object, long displacement);

   106 

   107     abstract short getShort(HotSpotObjectConstantImpl object, long displacement);

   108 

   109     abstract long getLong(HotSpotObjectConstantImpl object, long displacement);

   110 

   111     abstract void checkRead(HotSpotObjectConstantImpl constant, JavaKind kind, long displacement, HotSpotResolvedObjectType type);

   112 

   113     abstract <T extends Annotation> T getFieldAnnotation(HotSpotResolvedJavaFieldImpl javaField, Class<T> annotationClass);

   114 

   115     /**

   116      * Resolves {@code objectHandle} to a raw object if possible.

   117      *

   118      * @throws HotSpotJVMCIUnsupportedOperationError if {@code objectHandle} refers to an object in

   119      *             another heap

   120      */

   121     abstract Object resolveObject(HotSpotObjectConstantImpl objectHandle);

   122 }