/** Hook for subclasses to instantiate a subclass of {@link NewArrayNode}. */ protected NewArrayNode createNewArrayNode(ResolvedJavaType type) { return new NewArrayNode(type, length(), fillContents(), stateBefore()); }
@Override public boolean apply(GraphBuilderContext b, ResolvedJavaMethod targetMethod, Receiver unused, ValueNode componentType, ValueNode length) { b.addPush(JavaKind.Object, new DynamicNewArrayNode(componentType, length, true)); return true; } });
protected DynamicNewArrayNode(NodeClass<? extends DynamicNewArrayNode> c, ValueNode elementType, ValueNode length, boolean fillContents, JavaKind knownElementKind, FrameState stateBefore, MetaAccessProvider metaAccess) { super(c, computeStamp(knownElementKind, metaAccess), length, fillContents, stateBefore); this.elementType = elementType; this.knownElementKind = knownElementKind; assert knownElementKind != JavaKind.Void && knownElementKind != JavaKind.Illegal; }
public void lower(DynamicNewArrayNode newArrayNode, HotSpotRegistersProvider registers, LoweringTool tool) { StructuredGraph graph = newArrayNode.graph(); Arguments args = new Arguments(allocateArrayDynamic, newArrayNode.graph().getGuardsStage(), tool.getLoweringStage()); args.add("elementType", newArrayNode.getElementType()); ValueNode voidClass = newArrayNode.getVoidClass(); assert voidClass != null; args.add("voidClass", voidClass); ValueNode length = newArrayNode.length(); args.add("length", length.isAlive() ? length : graph.addOrUniqueWithInputs(length)); args.addConst("fillContents", newArrayNode.fillContents()); args.addConst("threadRegister", registers.getThreadRegister()); /* * We use Kind.Illegal as a marker value instead of null because constant snippet * parameters cannot be null. */ args.addConst("knownElementKind", newArrayNode.getKnownElementKind() == null ? JavaKind.Illegal : newArrayNode.getKnownElementKind()); if (newArrayNode.getKnownElementKind() != null) { args.addConst("knownLayoutHelper", lookupArrayClass(tool, newArrayNode.getKnownElementKind()).layoutHelper()); } else { args.addConst("knownLayoutHelper", 0); } args.add("prototypeMarkWord", lookupArrayClass(tool, JavaKind.Object).prototypeMarkWord()); args.addConst("counters", counters); SnippetTemplate template = template(newArrayNode, args); template.instantiate(providers.getMetaAccess(), newArrayNode, DEFAULT_REPLACER, args); }
@Override public void lower(DynamicNewArrayNode node, LoweringTool tool) { if (node.graph().getGuardsStage() != StructuredGraph.GuardsStage.AFTER_FSA) { return; } Arguments args = new Arguments(dynamicNewArray, node.graph().getGuardsStage(), tool.getLoweringStage()); args.add("elementType", node.getElementType()); args.add("length", node.length()); args.addConst("fillContents", node.fillContents()); addCounterArgs(args, node, null); template(node, args).instantiate(providers.getMetaAccess(), node, SnippetTemplate.DEFAULT_REPLACER, args); } }
} else if (n instanceof DynamicNewArrayNode) { DynamicNewArrayNode node = (DynamicNewArrayNode) n; ValueNode elementType = node.getElementType();
@Override public Node canonical(CanonicalizerTool tool) { if (elementType.isConstant()) { if (GeneratePIC.getValue(tool.getOptions())) { // Can't fold for AOT, because the resulting NewArrayNode will be missing its // ResolveConstantNode for the array class. return this; } ResolvedJavaType type = tool.getConstantReflection().asJavaType(elementType.asConstant()); if (type != null && type.getArrayClass() != null && !throwsIllegalArgumentException(type)) { return createNewArrayNode(type); } } return this; }
if (dynamicNewArrayNode.getVoidClass() == null) { JavaConstant voidClassMirror = constantReflection.asJavaClass(metaAccess.lookupJavaType(void.class)); ConstantNode voidClass = ConstantNode.forConstant(voidClassMirror, tool.getMetaAccess(), graph); dynamicNewArrayNode.setVoidClass(voidClass);
@Override public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) { ValueNode arg0 = args[0]; ValueNode arg1 = args[1]; boolean arg2; if (args[2].isConstant()) { arg2 = args[2].asJavaConstant().asInt() != 0; } else { assert b.canDeferPlugin(this) : b.getClass().toString(); return false; } org.graalvm.compiler.nodes.java.DynamicNewArrayNode node = new org.graalvm.compiler.nodes.java.DynamicNewArrayNode(arg0, arg1, arg2); b.addPush(JavaKind.Object, node); return true; } @Override
@Override public boolean execute(GraphBuilderContext b, ResolvedJavaMethod targetMethod, InvocationPlugin.Receiver receiver, ValueNode[] args) { jdk.vm.ci.meta.MetaAccessProvider arg0 = b.getMetaAccess(); ValueNode arg1 = args[0]; ValueNode arg2 = args[1]; boolean arg3; if (args[2].isConstant()) { arg3 = args[2].asJavaConstant().asInt() != 0; } else { assert b.canDeferPlugin(this) : b.getClass().toString(); return false; } jdk.vm.ci.meta.JavaKind arg4; if (args[3].isConstant()) { arg4 = snippetReflection.asObject(jdk.vm.ci.meta.JavaKind.class, args[3].asJavaConstant()); } else { assert b.canDeferPlugin(this) : b.getClass().toString(); return false; } org.graalvm.compiler.nodes.java.DynamicNewArrayNode node = new org.graalvm.compiler.nodes.java.DynamicNewArrayNode(arg0, arg1, arg2, arg3, arg4); b.addPush(JavaKind.Object, node); return true; } @Override