/** * Emits a class initialization barrier for {@code type}. * * @param frameState supplier to create a frame state representing the state just prior to * execution of the class initialization barrier * @return {@code true} if this method emitted a barrier,{@code false} if not */ default boolean apply(GraphBuilderContext builder, ResolvedJavaType type, Supplier<FrameState> frameState) { return apply(builder, type, frameState, null); }
protected void maybeEagerlyResolve(int cpi, int bytecode) { if (intrinsicContext != null) { constantPool.loadReferencedType(cpi, bytecode); } else if (graphBuilderConfig.eagerResolving()) { /* * Since we're potentially triggering class initialization here, we need synchronization * to mitigate the potential for class initialization related deadlock being caused by * the compiler (e.g., https://github.com/graalvm/graal-core/pull/232/files#r90788550). */ synchronized (BytecodeParser.class) { ClassInitializationPlugin classInitializationPlugin = graphBuilderConfig.getPlugins().getClassInitializationPlugin(); if (classInitializationPlugin != null) { classInitializationPlugin.loadReferencedType(this, constantPool, cpi, bytecode); } else { constantPool.loadReferencedType(cpi, bytecode); } } } }
uninitializedIsError = eagerInitializing = !classInitializationPlugin.supportsLazyInitialization(constantPool); } else { eagerInitializing = graphBuilderConfig.eagerResolving();
private void maybeEmitClassInitialization(GraphBuilderContext b, boolean isStatic, ResolvedJavaType declaringClass) { if (isStatic) { /* * We know that this code only runs during bytecode parsing, so the casts to * BytecodeParser are safe. We want to avoid putting additional rarely used methods into * GraphBuilderContext. */ classInitializationPlugin.apply(b, declaringClass, () -> ((BytecodeParser) b).getFrameStateBuilder().create(b.bci(), (BytecodeParser) b.getNonIntrinsicAncestor(), false, null, null)); } }
private void genNewMultiArray(ResolvedJavaType resolvedType, int rank, ValueNode[] dims) { ClassInitializationPlugin classInitializationPlugin = this.graphBuilderConfig.getPlugins().getClassInitializationPlugin(); if (classInitializationPlugin != null) { classInitializationPlugin.apply(this, resolvedType, this::createCurrentFrameState); } for (int i = rank - 1; i >= 0; i--) { dims[i] = frameState.pop(JavaKind.Int); } for (NodePlugin plugin : graphBuilderConfig.getPlugins().getNodePlugins()) { if (plugin.handleNewMultiArray(this, resolvedType, dims)) { return; } } frameState.push(JavaKind.Object, append(createNewMultiArray(resolvedType, dims))); }
private void genNewObjectArray(ResolvedJavaType resolvedType) { ClassInitializationPlugin classInitializationPlugin = this.graphBuilderConfig.getPlugins().getClassInitializationPlugin(); if (classInitializationPlugin != null) { classInitializationPlugin.apply(this, resolvedType.getArrayClass(), this::createCurrentFrameState); } ValueNode length = frameState.pop(JavaKind.Int); for (NodePlugin plugin : graphBuilderConfig.getPlugins().getNodePlugins()) { if (plugin.handleNewArray(this, resolvedType, length)) { return; } } frameState.push(JavaKind.Object, append(createNewArray(resolvedType, length, true))); }
void genInvokeStatic(JavaMethod target) { if (callTargetIsResolved(target)) { ResolvedJavaMethod resolvedTarget = (ResolvedJavaMethod) target; ResolvedJavaType holder = resolvedTarget.getDeclaringClass(); maybeEagerlyInitialize(holder); ClassInitializationPlugin classInitializationPlugin = graphBuilderConfig.getPlugins().getClassInitializationPlugin(); if (!holder.isInitialized() && classInitializationPlugin == null) { handleUnresolvedInvoke(target, InvokeKind.Static); return; } ValueNode[] classInit = {null}; if (classInitializationPlugin != null) { classInitializationPlugin.apply(this, resolvedTarget.getDeclaringClass(), this::createCurrentFrameState, classInit); } ValueNode[] args = frameState.popArguments(resolvedTarget.getSignature().getParameterCount(false)); Invoke invoke = appendInvoke(InvokeKind.Static, resolvedTarget, args); if (invoke != null && classInit[0] != null) { invoke.setClassInit(classInit[0]); } } else { handleUnresolvedInvoke(target, InvokeKind.Static); } }
ClassInitializationPlugin classInitializationPlugin = this.graphBuilderConfig.getPlugins().getClassInitializationPlugin(); if (classInitializationPlugin != null) { classInitializationPlugin.apply(this, holder, this::createCurrentFrameState);
protected void genNewInstance(ResolvedJavaType resolvedType) { if (resolvedType.isAbstract() || resolvedType.isInterface()) { handleIllegalNewInstance(resolvedType); return; } maybeEagerlyInitialize(resolvedType); ClassInitializationPlugin classInitializationPlugin = graphBuilderConfig.getPlugins().getClassInitializationPlugin(); if (!resolvedType.isInitialized() && classInitializationPlugin == null) { handleIllegalNewInstance(resolvedType); return; } for (ResolvedJavaType exceptionType : this.graphBuilderConfig.getSkippedExceptionTypes()) { if (exceptionType.isAssignableFrom(resolvedType)) { append(new DeoptimizeNode(DeoptimizationAction.InvalidateRecompile, RuntimeConstraint)); return; } } if (classInitializationPlugin != null) { classInitializationPlugin.apply(this, resolvedType, this::createCurrentFrameState); } for (NodePlugin plugin : graphBuilderConfig.getPlugins().getNodePlugins()) { if (plugin.handleNewInstance(this, resolvedType)) { return; } } frameState.push(JavaKind.Object, append(createNewInstance(resolvedType, true))); }
protected void genPutStatic(JavaField field) { int stackSizeBefore = frameState.stackSize(); ValueNode value = frameState.pop(field.getJavaKind()); ResolvedJavaField resolvedField = resolveStaticFieldAccess(field, value); if (resolvedField == null) { return; } if (!parsingIntrinsic() && GeneratePIC.getValue(getOptions())) { graph.recordField(resolvedField); } ClassInitializationPlugin classInitializationPlugin = this.graphBuilderConfig.getPlugins().getClassInitializationPlugin(); ResolvedJavaType holder = resolvedField.getDeclaringClass(); if (classInitializationPlugin != null) { Supplier<FrameState> stateBefore = () -> { JavaKind[] pushedSlotKinds = {field.getJavaKind()}; ValueNode[] pushedValues = {value}; FrameState fs = frameState.create(bci(), getNonIntrinsicAncestor(), false, pushedSlotKinds, pushedValues); assert stackSizeBefore == fs.stackSize(); return fs; }; classInitializationPlugin.apply(this, holder, stateBefore); } for (NodePlugin plugin : graphBuilderConfig.getPlugins().getNodePlugins()) { if (plugin.handleStoreStaticField(this, resolvedField, value)) { return; } } genStoreField(null, resolvedField, value); }