src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.hotspot/src/org/graalvm/compiler/hotspot/meta/HotSpotClassInitializationPlugin.java
changeset 49451 e06f9607f370
parent 47216 71c04702a3d5
child 50858 2d3e99a72541
equal deleted inserted replaced
49450:5d2adef239d6 49451:e06f9607f370
    23 package org.graalvm.compiler.hotspot.meta;
    23 package org.graalvm.compiler.hotspot.meta;
    24 
    24 
    25 import org.graalvm.compiler.core.common.type.ObjectStamp;
    25 import org.graalvm.compiler.core.common.type.ObjectStamp;
    26 import org.graalvm.compiler.core.common.type.Stamp;
    26 import org.graalvm.compiler.core.common.type.Stamp;
    27 import org.graalvm.compiler.core.common.type.StampFactory;
    27 import org.graalvm.compiler.core.common.type.StampFactory;
       
    28 import org.graalvm.compiler.debug.GraalError;
    28 import org.graalvm.compiler.hotspot.nodes.aot.InitializeKlassNode;
    29 import org.graalvm.compiler.hotspot.nodes.aot.InitializeKlassNode;
    29 import org.graalvm.compiler.hotspot.nodes.aot.ResolveConstantNode;
    30 import org.graalvm.compiler.hotspot.nodes.aot.ResolveConstantNode;
    30 import org.graalvm.compiler.nodes.ConstantNode;
    31 import org.graalvm.compiler.nodes.ConstantNode;
    31 import org.graalvm.compiler.nodes.DeoptimizingFixedWithNextNode;
    32 import org.graalvm.compiler.nodes.DeoptimizingFixedWithNextNode;
    32 import org.graalvm.compiler.nodes.FrameState;
    33 import org.graalvm.compiler.nodes.FrameState;
    35 import org.graalvm.compiler.nodes.graphbuilderconf.GraphBuilderContext;
    36 import org.graalvm.compiler.nodes.graphbuilderconf.GraphBuilderContext;
    36 
    37 
    37 import jdk.vm.ci.hotspot.HotSpotResolvedObjectType;
    38 import jdk.vm.ci.hotspot.HotSpotResolvedObjectType;
    38 import jdk.vm.ci.meta.ResolvedJavaMethod;
    39 import jdk.vm.ci.meta.ResolvedJavaMethod;
    39 import jdk.vm.ci.meta.ResolvedJavaType;
    40 import jdk.vm.ci.meta.ResolvedJavaType;
       
    41 import jdk.vm.ci.meta.ConstantPool;
       
    42 
       
    43 import java.lang.invoke.MethodHandle;
       
    44 import java.lang.invoke.MethodHandles;
       
    45 import java.lang.invoke.MethodType;
    40 
    46 
    41 public final class HotSpotClassInitializationPlugin implements ClassInitializationPlugin {
    47 public final class HotSpotClassInitializationPlugin implements ClassInitializationPlugin {
    42     @Override
    48     @Override
    43     public boolean shouldApply(GraphBuilderContext builder, ResolvedJavaType type) {
    49     public boolean shouldApply(GraphBuilderContext builder, ResolvedJavaType type) {
    44         if (!builder.parsingIntrinsic()) {
    50         if (!builder.parsingIntrinsic()) {
    71         ConstantNode hub = builder.append(ConstantNode.forConstant(hubStamp, ((HotSpotResolvedObjectType) type).klass(), builder.getMetaAccess(), builder.getGraph()));
    77         ConstantNode hub = builder.append(ConstantNode.forConstant(hubStamp, ((HotSpotResolvedObjectType) type).klass(), builder.getMetaAccess(), builder.getGraph()));
    72         DeoptimizingFixedWithNextNode result = builder.append(type.isArray() ? new ResolveConstantNode(hub) : new InitializeKlassNode(hub));
    78         DeoptimizingFixedWithNextNode result = builder.append(type.isArray() ? new ResolveConstantNode(hub) : new InitializeKlassNode(hub));
    73         result.setStateBefore(frameState);
    79         result.setStateBefore(frameState);
    74         return result;
    80         return result;
    75     }
    81     }
       
    82 
       
    83     private static final Class<? extends ConstantPool> hscp;
       
    84     private static final MethodHandle loadReferencedTypeIIZMH;
       
    85 
       
    86     static {
       
    87         MethodHandle m = null;
       
    88         Class<? extends ConstantPool> c = null;
       
    89         try {
       
    90             c = Class.forName("jdk.vm.ci.hotspot.HotSpotConstantPool").asSubclass(ConstantPool.class);
       
    91             m = MethodHandles.lookup().findVirtual(c, "loadReferencedType", MethodType.methodType(void.class, int.class, int.class, boolean.class));
       
    92         } catch (Exception e) {
       
    93         }
       
    94         loadReferencedTypeIIZMH = m;
       
    95         hscp = c;
       
    96     }
       
    97 
       
    98     private static boolean isHotSpotConstantPool(ConstantPool cp) {
       
    99         // jdk.vm.ci.hotspot.HotSpotConstantPool is final, so we can
       
   100         // directly compare Classes.
       
   101         return cp.getClass() == hscp;
       
   102     }
       
   103 
       
   104     @Override
       
   105     public boolean supportsLazyInitialization(ConstantPool cp) {
       
   106         if (loadReferencedTypeIIZMH != null && isHotSpotConstantPool(cp)) {
       
   107             return true;
       
   108         }
       
   109         return false;
       
   110     }
       
   111 
       
   112     @Override
       
   113     public void loadReferencedType(GraphBuilderContext builder, ConstantPool cp, int cpi, int opcode) {
       
   114         if (loadReferencedTypeIIZMH != null && isHotSpotConstantPool(cp)) {
       
   115             try {
       
   116                 loadReferencedTypeIIZMH.invoke(cp, cpi, opcode, false);
       
   117             } catch (Throwable t) {
       
   118                 throw GraalError.shouldNotReachHere(t);
       
   119             }
       
   120         } else {
       
   121             cp.loadReferencedType(cpi, opcode);
       
   122         }
       
   123     }
       
   124 
    76 }
   125 }