private void genGetField(ResolvedJavaField resolvedField, ValueNode receiver) { if (!parsingIntrinsic() && GeneratePIC.getValue(getOptions())) { graph.recordField(resolvedField); } for (NodePlugin plugin : graphBuilderConfig.getPlugins().getNodePlugins()) { if (plugin.handleLoadField(this, receiver, resolvedField)) { return; } } ValueNode fieldRead = append(genLoadField(receiver, resolvedField)); if (resolvedField.getDeclaringClass().getName().equals("Ljava/lang/ref/Reference;") && resolvedField.getName().equals("referent")) { LocationIdentity referentIdentity = new FieldLocationIdentity(resolvedField); append(new MembarNode(0, referentIdentity)); } JavaKind fieldKind = resolvedField.getJavaKind(); pushLoadField(resolvedField, fieldRead, fieldKind); }
for (NodePlugin plugin : graphBuilderConfig.getPlugins().getNodePlugins()) { if (plugin.handleLoadStaticField(this, resolvedField)) { return;
JavaTypeProfile profile = getProfileForTypeCheck(checkedType); for (NodePlugin plugin : graphBuilderConfig.getPlugins().getNodePlugins()) { if (plugin.handleCheckCast(this, object, checkedType.getType(), profile)) { return;
JavaTypeProfile profile = getProfileForTypeCheck(checkedType); for (NodePlugin plugin : graphBuilderConfig.getPlugins().getNodePlugins()) { if (plugin.handleInstanceOf(this, object, checkedType.getType(), profile)) { return;
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); }
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))); }
private void genPutField(JavaField field, ValueNode value) { ValueNode receiverInput = frameState.pop(JavaKind.Object); if (field instanceof ResolvedJavaField) { ValueNode receiver = maybeEmitExplicitNullCheck(receiverInput); ResolvedJavaField resolvedField = (ResolvedJavaField) field; if (!parsingIntrinsic() && GeneratePIC.getValue(getOptions())) { graph.recordField(resolvedField); } for (NodePlugin plugin : graphBuilderConfig.getPlugins().getNodePlugins()) { if (plugin.handleStoreField(this, receiver, resolvedField, value)) { return; } } if (resolvedField.isFinal() && method.isConstructor()) { finalBarrierRequired = true; } genStoreField(receiver, resolvedField, value); } else { handleUnresolvedStoreField(field, value, receiverInput); } }
private boolean computeKindVerification(FrameStateBuilder startFrameState) { if (blockMap.hasJsrBytecodes) { /* * The JSR return address is an int value, but stored using the astore bytecode. Instead * of weakening the kind assertion checking for all methods, we disable it completely * for methods that contain a JSR bytecode. */ startFrameState.disableKindVerification(); } for (NodePlugin plugin : graphBuilderConfig.getPlugins().getNodePlugins()) { if (plugin.canChangeStackKind(this)) { /* * We have a plugin that can change the kind of values, so no kind assertion * checking is possible. */ startFrameState.disableKindVerification(); } } return true; }
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 genStoreIndexed(JavaKind kind) { ValueNode value = frameState.pop(kind); ValueNode index = frameState.pop(JavaKind.Int); ValueNode array = frameState.pop(JavaKind.Object); array = maybeEmitExplicitNullCheck(array); GuardingNode boundsCheck = maybeEmitExplicitBoundsCheck(array, index); GuardingNode storeCheck = maybeEmitExplicitStoreCheck(array, kind, value); for (NodePlugin plugin : graphBuilderConfig.getPlugins().getNodePlugins()) { if (plugin.handleStoreIndexed(this, array, index, boundsCheck, storeCheck, kind, value)) { return; } } JavaKind actualKind = refineComponentType(array, kind); genStoreIndexed(array, index, boundsCheck, storeCheck, actualKind, maskSubWordValue(value, actualKind)); }
protected void createHandleExceptionTarget(FixedWithNextNode afterExceptionLoaded, int bci, FrameStateBuilder dispatchState) { FixedWithNextNode afterInstrumentation = afterExceptionLoaded; for (NodePlugin plugin : graphBuilderConfig.getPlugins().getNodePlugins()) { afterInstrumentation = plugin.instrumentExceptionDispatch(graph, afterInstrumentation); assert afterInstrumentation.next() == null : "exception dispatch instrumentation will be linked to dispatch block"; } BciBlock dispatchBlock = currentBlock.exceptionDispatchBlock(); /* * The exception dispatch block is always for the last bytecode of a block, so if we are not * at the endBci yet, there is no exception handler for this bci and we can unwind * immediately. */ if (bci != currentBlock.endBci || dispatchBlock == null) { dispatchBlock = blockMap.getUnwindBlock(); } FixedNode target = createTarget(dispatchBlock, dispatchState); afterInstrumentation.setNext(target); }
private void genLoadIndexed(JavaKind kind) { ValueNode index = frameState.pop(JavaKind.Int); ValueNode array = frameState.pop(JavaKind.Object); array = maybeEmitExplicitNullCheck(array); GuardingNode boundsCheck = maybeEmitExplicitBoundsCheck(array, index); for (NodePlugin plugin : graphBuilderConfig.getPlugins().getNodePlugins()) { if (plugin.handleLoadIndexed(this, array, index, boundsCheck, kind)) { return; } } JavaKind actualKind = refineComponentType(array, kind); frameState.push(actualKind, append(genLoadIndexed(array, index, boundsCheck, actualKind))); }
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))); }
private void genNewPrimitiveArray(int typeCode) { ResolvedJavaType elementType = metaAccess.lookupJavaType(arrayTypeCodeToClass(typeCode)); ValueNode length = frameState.pop(JavaKind.Int); for (NodePlugin plugin : graphBuilderConfig.getPlugins().getNodePlugins()) { if (plugin.handleNewArray(this, elementType, length)) { return; } } frameState.push(JavaKind.Object, append(createNewArray(elementType, length, true))); }
private boolean tryNodePluginForInvocation(ValueNode[] args, ResolvedJavaMethod targetMethod) { for (NodePlugin plugin : graphBuilderConfig.getPlugins().getNodePlugins()) { if (plugin.handleInvoke(this, targetMethod, args)) { return true; } } return false; }
protected NodePlugin[] createNodePlugins(Plugins plugins) { return plugins.getNodePlugins(); }