ClassInitializationPlugin classInitializationPlugin = this.graphBuilderConfig.getPlugins().getClassInitializationPlugin(); if (classInitializationPlugin != null) { classInitializationPlugin.apply(this, holder, this::createCurrentFrameState);
this.parent = parent; ClassInitializationPlugin classInitializationPlugin = graphBuilderConfig.getPlugins().getClassInitializationPlugin(); if (classInitializationPlugin != null && graphBuilderConfig.eagerResolving()) { uninitializedIsError = eagerInitializing = !classInitializationPlugin.supportsLazyInitialization(constantPool);
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); }
private ResolvedJavaField resolveStaticFieldAccess(JavaField field, ValueNode value) { if (field instanceof ResolvedJavaField) { ResolvedJavaField resolvedField = (ResolvedJavaField) field; ResolvedJavaType resolvedType = resolvedField.getDeclaringClass(); maybeEagerlyInitialize(resolvedType); if (resolvedType.isInitialized() || graphBuilderConfig.getPlugins().getClassInitializationPlugin() != null) { return resolvedField; } /* * Static fields have initialization semantics but may be safely accessed under certain * conditions while the class is being initialized. Executing in the clinit or init of * subclasses (but not implementers) of the field holder are sure to be running in a * context where the access is safe. */ if (!resolvedType.isInterface() && resolvedType.isAssignableFrom(method.getDeclaringClass())) { if (method.isClassInitializer() || method.isConstructor()) { return resolvedField; } } } if (value == null) { handleUnresolvedLoadField(field, null); } else { handleUnresolvedStoreField(field, value, null); } return null; }
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))); }
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); } }
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); } } } }
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))); }