protected NewInstanceNode createNewInstance(ResolvedJavaType type, boolean fillContents) { return new NewInstanceNode(type, fillContents); }
@Override public void lower(NewInstanceNode node, LoweringTool tool) { if (node.graph().getGuardsStage() != StructuredGraph.GuardsStage.AFTER_FSA) { return; } SharedType type = (SharedType) node.instanceClass(); Arguments args = new Arguments(newInstance, node.graph().getGuardsStage(), tool.getLoweringStage()); args.add("hub", type.getHub()); args.addConst("encoding", type.getHub().getLayoutEncoding()); args.addConst("fillContents", node.fillContents()); addCounterArgs(args, node, type); template(node, args).instantiate(providers.getMetaAccess(), node, SnippetTemplate.DEFAULT_REPLACER, args); }
@Override public void virtualize(VirtualizerTool tool) { /* * Reference objects can escape into their ReferenceQueue at any safepoint, therefore * they're excluded from escape analysis. */ if (!tool.getMetaAccess().lookupJavaType(Reference.class).isAssignableFrom(instanceClass)) { VirtualInstanceNode virtualObject = createVirtualInstanceNode(true); ResolvedJavaField[] fields = virtualObject.getFields(); ValueNode[] state = new ValueNode[fields.length]; for (int i = 0; i < state.length; i++) { state[i] = defaultFieldValue(fields[i]); } tool.createVirtualObject(virtualObject, state, Collections.<MonitorIdNode> emptyList(), false); tool.replaceWithVirtual(virtualObject); } }
protected VirtualInstanceNode createVirtualInstanceNode(boolean hasIdentity) { return new VirtualInstanceNode(instanceClass(), hasIdentity); }
protected ConstantNode defaultFieldValue(ResolvedJavaField field) { return ConstantNode.defaultForKind(field.getType().getJavaKind(), graph()); } }
protected void processNewInstance(NewInstanceNode node, TypeFlowsOfNodes state) { AnalysisType type = (AnalysisType) node.instanceClass(); assert type.isInstantiated(); Object key = uniqueKey(node); BytecodeLocation allocationLabel = bb.analysisPolicy().createAllocationSite(bb, key, method); TypeFlowBuilder<?> newInstanceBuilder = TypeFlowBuilder.create(bb, node, NewInstanceTypeFlow.class, () -> { NewInstanceTypeFlow newInstance = createNewInstanceTypeFlow(node, type, allocationLabel); /* Instance fields of a new object are initialized to null state in AnalysisField. */ methodFlow.addAllocation(newInstance); return newInstance; }); state.add(node, newInstanceBuilder); }
public NewInstanceNode createNewInstanceFromVirtual(VirtualObjectNode virtual) { return new NewInstanceNode(virtual.type(), true); }
/** * Lowers a {@link NewInstanceNode}. */ public void lower(NewInstanceNode newInstanceNode, HotSpotRegistersProvider registers, LoweringTool tool) { StructuredGraph graph = newInstanceNode.graph(); HotSpotResolvedObjectType type = (HotSpotResolvedObjectType) newInstanceNode.instanceClass(); assert !type.isArray(); ConstantNode hub = ConstantNode.forConstant(KlassPointerStamp.klassNonNull(), type.klass(), providers.getMetaAccess(), graph); int size = instanceSize(type); OptionValues localOptions = graph.getOptions(); SnippetInfo snippet = GeneratePIC.getValue(localOptions) ? allocateInstancePIC : allocateInstance; Arguments args = new Arguments(snippet, graph.getGuardsStage(), tool.getLoweringStage()); args.addConst("size", size); args.add("hub", hub); args.add("prototypeMarkWord", type.prototypeMarkWord()); args.addConst("fillContents", newInstanceNode.fillContents()); args.addConst("threadRegister", registers.getThreadRegister()); args.addConst("constantSize", true); args.addConst("typeContext", ProfileAllocations.getValue(localOptions) ? type.toJavaName(false) : ""); args.addConst("counters", counters); SnippetTemplate template = template(newInstanceNode, args); graph.getDebug().log("Lowering allocateInstance in %s: node=%s, template=%s, arguments=%s", graph, newInstanceNode, template, args); template.instantiate(providers.getMetaAccess(), newInstanceNode, DEFAULT_REPLACER, args); }
AnalysisType type = (AnalysisType) node.instanceClass(); type.registerAsAllocated(node);
/** Hook for subclasses to instantiate a subclass of {@link NewInstanceNode}. */ protected NewInstanceNode createNewInstanceNode(ResolvedJavaType type) { return new NewInstanceNode(type, fillContents(), stateBefore()); }
NewInstanceNode newInstanceNode = (NewInstanceNode) node; PEAppendGraphBuilderContext graphBuilderContext = new PEAppendGraphBuilderContext(methodScope, newInstanceNode); ResolvedJavaType type = newInstanceNode.instanceClass(); for (NodePlugin nodePlugin : nodePlugins) { if (nodePlugin.handleNewInstance(graphBuilderContext, type)) {
private static void throwInvocationTargetException(HostedGraphKit graphKit) { ValueNode exception = graphKit.exceptionObject(); ResolvedJavaType exceptionType = graphKit.getMetaAccess().lookupJavaType(InvocationTargetException.class); ValueNode ite = graphKit.append(new NewInstanceNode(exceptionType, true)); ResolvedJavaMethod cons = null; for (ResolvedJavaMethod c : exceptionType.getDeclaredConstructors()) { if (c.getSignature().getParameterCount(false) == 1) { cons = c; } } graphKit.createJavaCallWithExceptionAndUnwind(InvokeKind.Special, cons, ite, exception); graphKit.append(new UnwindNode(ite)); }
@Override public StructuredGraph buildGraph(DebugContext ctx, ResolvedJavaMethod method, HostedProviders providers, Purpose purpose) { HostedGraphKit graphKit = new HostedGraphKit(ctx, providers, method); ResolvedJavaType type = providers.getMetaAccess().lookupJavaType(constructor.getDeclaringClass()); ResolvedJavaMethod cons = providers.getMetaAccess().lookupJavaMethod(constructor); Class<?>[] argTypes = constructor.getParameterTypes(); ValueNode ret = graphKit.append(new NewInstanceNode(type, true)); ValueNode[] args = new ValueNode[argTypes.length + 1]; args[0] = ret; if (argTypes.length > 0) { ValueNode argumentArray = graphKit.loadLocal(1, JavaKind.Object); fillArgsArray(graphKit, argumentArray, 1, args, argTypes); } graphKit.createJavaCallWithException(InvokeKind.Special, cons, args); graphKit.noExceptionPart(); graphKit.createReturn(ret, JavaKind.Object); graphKit.exceptionPart(); throwInvocationTargetException(graphKit); graphKit.endInvokeWithException(); graphKit.mergeUnwinds(); assert graphKit.getGraph().verify(); return graphKit.getGraph(); } }
kit.thenPart(); ResolvedJavaType enumExceptionType = metaAccess.lookupJavaType(RuntimeException.class); NewInstanceNode enumException = kit.append(new NewInstanceNode(enumExceptionType, true)); Iterator<ResolvedJavaMethod> enumExceptionCtor = Arrays.stream(enumExceptionType.getDeclaredConstructors()).filter( c -> c.getSignature().getParameterCount(false) == 1 && c.getSignature().getParameterType(0, null).equals(metaAccess.lookupJavaType(String.class))).iterator();
kit.thenPart(); ResolvedJavaType enumExceptionType = metaAccess.lookupJavaType(RuntimeException.class); NewInstanceNode enumException = kit.append(new NewInstanceNode(enumExceptionType, true)); Iterator<ResolvedJavaMethod> enumExceptionCtor = Arrays.stream(enumExceptionType.getDeclaredConstructors()).filter( c -> c.getSignature().getParameterCount(false) == 1 && c.getSignature().getParameterType(0, null).equals(metaAccess.lookupJavaType(String.class))).iterator();
private static void throwIllegalArgumentException(HostedGraphKit graphKit, String message) { ResolvedJavaType exceptionType = graphKit.getMetaAccess().lookupJavaType(IllegalArgumentException.class); ValueNode ite = graphKit.append(new NewInstanceNode(exceptionType, true)); ResolvedJavaMethod cons = null; for (ResolvedJavaMethod c : exceptionType.getDeclaredConstructors()) { if (c.getSignature().getParameterCount(false) == 2) { cons = c; } } JavaConstant msg = graphKit.getConstantReflection().forString(message); ValueNode msgNode = graphKit.createConstant(msg, JavaKind.Object); ValueNode cause = graphKit.createConstant(JavaConstant.NULL_POINTER, JavaKind.Object); graphKit.createJavaCallWithExceptionAndUnwind(InvokeKind.Special, cons, ite, msgNode, cause); graphKit.append(new UnwindNode(ite)); }
@Override public StructuredGraph buildGraph(DebugContext ctx, ResolvedJavaMethod method, HostedProviders providers, Purpose purpose) { HostedGraphKit graphKit = new HostedGraphKit(ctx, providers, method); ResolvedJavaType exceptionType = graphKit.getMetaAccess().lookupJavaType(exceptionClass); ValueNode instance = graphKit.append(new NewInstanceNode(exceptionType, true)); ResolvedJavaMethod cons = null; for (ResolvedJavaMethod c : exceptionType.getDeclaredConstructors()) { if (c.getSignature().getParameterCount(false) == 1) { ResolvedJavaType stringType = providers.getMetaAccess().lookupJavaType(String.class); if (c.getSignature().getParameterType(0, null).equals(stringType)) { cons = c; } } } JavaConstant msg = graphKit.getConstantReflection().forString(message); ValueNode msgNode = graphKit.createConstant(msg, JavaKind.Object); graphKit.createJavaCallWithExceptionAndUnwind(InvokeKind.Special, cons, instance, msgNode); graphKit.append(new UnwindNode(instance)); graphKit.mergeUnwinds(); assert graphKit.getGraph().verify(); return graphKit.getGraph(); } }
kit.startIf(kit.unique(new ObjectEqualsNode(unboxed, hubNode)), BranchProbabilityNode.FAST_PATH_PROBABILITY); kit.thenPart(); ValueNode created = kit.append(new NewInstanceNode(receiverClass, true)); AbstractMergeNode merge = kit.endIf(); receiver = kit.unique(new ValuePhiNode(StampFactory.object(), merge, new ValueNode[]{created, unboxed}));
StructuredGraph newGraph = new StructuredGraph.Builder(graph().getOptions(), graph().getDebug(), AllowAssumptions.ifNonNull(assumptions)).name("<clone>").build(); ParameterNode param = newGraph.addWithoutUnique(new ParameterNode(0, StampPair.createSingle(getObject().stamp(NodeView.DEFAULT)))); NewInstanceNode newInstance = newGraph.add(new NewInstanceNode(type, true)); newGraph.addAfterFixed(newGraph.start(), newInstance); ReturnNode returnNode = newGraph.add(new ReturnNode(newInstance));