hotspot/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.printer/src/org/graalvm/compiler/printer/GraphPrinter.java
changeset 46459 7d4e637d3f21
parent 46458 3c12af929e7d
child 46509 b32d3928ad6a
equal deleted inserted replaced
46458:3c12af929e7d 46459:7d4e637d3f21
    20  * or visit www.oracle.com if you need additional information or have any
    20  * or visit www.oracle.com if you need additional information or have any
    21  * questions.
    21  * questions.
    22  */
    22  */
    23 package org.graalvm.compiler.printer;
    23 package org.graalvm.compiler.printer;
    24 
    24 
    25 import static org.graalvm.compiler.core.common.util.Util.JAVA_SPECIFICATION_VERSION;
       
    26 
       
    27 import java.io.Closeable;
    25 import java.io.Closeable;
    28 import java.io.IOException;
    26 import java.io.IOException;
    29 import java.lang.reflect.Array;
    27 import java.lang.reflect.Array;
    30 import java.util.Arrays;
    28 import java.util.Arrays;
    31 import java.util.List;
    29 import java.util.List;
    32 import java.util.Map;
    30 import java.util.Map;
       
    31 
    33 import org.graalvm.compiler.api.replacements.SnippetReflectionProvider;
    32 import org.graalvm.compiler.api.replacements.SnippetReflectionProvider;
    34 import org.graalvm.compiler.core.common.util.ModuleAPI;
       
    35 import org.graalvm.compiler.graph.Graph;
    33 import org.graalvm.compiler.graph.Graph;
    36 import org.graalvm.compiler.nodes.ConstantNode;
    34 import org.graalvm.compiler.nodes.ConstantNode;
       
    35 import org.graalvm.compiler.serviceprovider.JDK9Method;
       
    36 
    37 import jdk.vm.ci.meta.JavaConstant;
    37 import jdk.vm.ci.meta.JavaConstant;
    38 import jdk.vm.ci.meta.JavaKind;
    38 import jdk.vm.ci.meta.JavaKind;
    39 import jdk.vm.ci.meta.MetaUtil;
    39 import jdk.vm.ci.meta.MetaUtil;
    40 import jdk.vm.ci.meta.ResolvedJavaMethod;
    40 import jdk.vm.ci.meta.ResolvedJavaMethod;
    41 import jdk.vm.ci.runtime.JVMCI;
    41 import jdk.vm.ci.runtime.JVMCI;
    66 
    66 
    67     @Override
    67     @Override
    68     void close();
    68     void close();
    69 
    69 
    70     /**
    70     /**
    71      * A JVMCI package {@linkplain Services#exportJVMCITo(Class) dynamically exported} to trusted
    71      * A JVMCI package dynamically exported to trusted modules.
    72      * modules.
       
    73      */
    72      */
    74     String JVMCI_RUNTIME_PACKAGE = JVMCI.class.getPackage().getName();
    73     String JVMCI_RUNTIME_PACKAGE = JVMCI.class.getPackage().getName();
    75 
    74 
    76     /**
    75     /**
    77      * {@code jdk.vm.ci} module.
    76      * {@code jdk.vm.ci} module.
    78      */
    77      */
    79     Object JVMCI_MODULE = JAVA_SPECIFICATION_VERSION < 9 ? null : ModuleAPI.getModule.invoke(Services.class);
    78     Object JVMCI_MODULE = JDK9Method.JAVA_SPECIFICATION_VERSION < 9 ? null : JDK9Method.getModule.invoke(Services.class);
    80 
    79 
    81     /**
    80     /**
    82      * Classes whose {@link #toString()} method does not run any untrusted code.
    81      * Classes whose {@link #toString()} method does not run any untrusted code.
    83      */
    82      */
    84     List<Class<?>> TRUSTED_CLASSES = Arrays.asList(
    83     List<Class<?>> TRUSTED_CLASSES = Arrays.asList(
   100      */
    99      */
   101     static boolean isToStringTrusted(Class<?> c) {
   100     static boolean isToStringTrusted(Class<?> c) {
   102         if (TRUSTED_CLASSES.contains(c)) {
   101         if (TRUSTED_CLASSES.contains(c)) {
   103             return true;
   102             return true;
   104         }
   103         }
   105         if (JAVA_SPECIFICATION_VERSION < 9) {
   104         if (JDK9Method.JAVA_SPECIFICATION_VERSION < 9) {
   106             if (c.getClassLoader() == Services.class.getClassLoader()) {
   105             if (c.getClassLoader() == Services.class.getClassLoader()) {
   107                 // Loaded by the JVMCI class loader
   106                 // Loaded by the JVMCI class loader
   108                 return true;
   107                 return true;
   109             }
   108             }
   110         } else {
   109         } else {
   111             Object module = ModuleAPI.getModule.invoke(c);
   110             Object module = JDK9Method.getModule.invoke(c);
   112             if (JVMCI_MODULE == module || (Boolean) ModuleAPI.isExportedTo.invoke(JVMCI_MODULE, JVMCI_RUNTIME_PACKAGE, module)) {
   111             if (JVMCI_MODULE == module || (Boolean) JDK9Method.isOpenTo.invoke(JVMCI_MODULE, JVMCI_RUNTIME_PACKAGE, module)) {
   113                 // Can access non-statically-exported package in JVMCI
   112                 // Can access non-statically-exported package in JVMCI
   114                 return true;
   113                 return true;
   115             }
   114             }
   116         }
   115         }
   117         return false;
   116         return false;