Mercurial > hg > graal-jvmci-8
view graal/com.oracle.graal.graphbuilderconf/src/com/oracle/graal/graphbuilderconf/InvocationPlugins.java @ 20116:674a81af7992
removed IntrinsificationsEnabled and IntrinsificationsDisabled options
author | Doug Simon <doug.simon@oracle.com> |
---|---|
date | Wed, 01 Apr 2015 13:59:01 +0200 |
parents | 7815c4d4a07f |
children | ba0f264a71cf |
line wrap: on
line source
/* * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */ package com.oracle.graal.graphbuilderconf; import static java.lang.String.*; import java.lang.reflect.*; import java.util.*; import java.util.stream.*; import com.oracle.graal.api.meta.*; import com.oracle.graal.compiler.common.*; import com.oracle.graal.graph.Node; import com.oracle.graal.graph.iterators.*; import com.oracle.graal.nodes.*; import com.oracle.graal.nodes.type.*; /** * Manages a set of {@link InvocationPlugin}s. */ public class InvocationPlugins { /** * Access to the receiver in an {@link InvocationPlugin} for a non-static method. The class * literal for this interface must be used with * {@link InvocationPlugins#register(InvocationPlugin, Class, String, Class...)} to denote the * receiver argument for such a non-static method. */ public interface Receiver { /** * Gets the receiver value, null checking it first if necessary. * * @return the receiver value with a {@linkplain StampTool#isPointerNonNull(ValueNode) * non-null} stamp */ ValueNode get(); /** * Determines if the receiver is constant. */ boolean isConstant(); } /** * Utility for * {@linkplain InvocationPlugins#register(InvocationPlugin, Class, String, Class...) * registration} of invocation plugins. */ public static class Registration { private final InvocationPlugins plugins; private final Class<?> declaringClass; /** * Creates an object for registering {@link InvocationPlugin}s for methods declared by a * given class. * * @param plugins where to register the plugins * @param declaringClass the class declaring the methods for which plugins will be * registered via this object */ public Registration(InvocationPlugins plugins, Class<?> declaringClass) { this.plugins = plugins; this.declaringClass = declaringClass; } /** * Registers a plugin for a method with no arguments. * * @param name the name of the method * @param plugin the plugin to be registered */ public void register0(String name, InvocationPlugin plugin) { plugins.register(plugin, declaringClass, name); } /** * Registers a plugin for a method with 1 argument. * * @param name the name of the method * @param plugin the plugin to be registered */ public void register1(String name, Class<?> arg, InvocationPlugin plugin) { plugins.register(plugin, declaringClass, name, arg); } /** * Registers a plugin for a method with 2 arguments. * * @param name the name of the method * @param plugin the plugin to be registered */ public void register2(String name, Class<?> arg1, Class<?> arg2, InvocationPlugin plugin) { plugins.register(plugin, declaringClass, name, arg1, arg2); } /** * Registers a plugin for a method with 3 arguments. * * @param name the name of the method * @param plugin the plugin to be registered */ public void register3(String name, Class<?> arg1, Class<?> arg2, Class<?> arg3, InvocationPlugin plugin) { plugins.register(plugin, declaringClass, name, arg1, arg2, arg3); } /** * Registers a plugin for a method with 4 arguments. * * @param name the name of the method * @param plugin the plugin to be registered */ public void register4(String name, Class<?> arg1, Class<?> arg2, Class<?> arg3, Class<?> arg4, InvocationPlugin plugin) { plugins.register(plugin, declaringClass, name, arg1, arg2, arg3, arg4); } /** * Registers a plugin for a method with 5 arguments. * * @param name the name of the method * @param plugin the plugin to be registered */ public void register5(String name, Class<?> arg1, Class<?> arg2, Class<?> arg3, Class<?> arg4, Class<?> arg5, InvocationPlugin plugin) { plugins.register(plugin, declaringClass, name, arg1, arg2, arg3, arg4, arg5); } } static final class MethodInfo { final boolean isStatic; final Class<?> declaringClass; final String name; final Class<?>[] argumentTypes; final InvocationPlugin plugin; int id; MethodInfo(InvocationPlugin plugin, Class<?> declaringClass, String name, Class<?>... argumentTypes) { this.plugin = plugin; this.isStatic = argumentTypes.length == 0 || argumentTypes[0] != Receiver.class; this.declaringClass = declaringClass; this.name = name; this.argumentTypes = argumentTypes; if (!isStatic) { argumentTypes[0] = declaringClass; } } @Override public boolean equals(Object obj) { if (obj instanceof MethodInfo) { MethodInfo that = (MethodInfo) obj; boolean res = this.name.equals(that.name) && this.declaringClass.equals(that.declaringClass) && Arrays.equals(this.argumentTypes, that.argumentTypes); assert !res || this.isStatic == that.isStatic; return res; } return false; } @Override public int hashCode() { // Replay compilation mandates use of stable hash codes return declaringClass.getName().hashCode() ^ name.hashCode(); } ResolvedJavaMethod resolve(MetaAccessProvider metaAccess) { try { ResolvedJavaMethod method; Class<?>[] parameterTypes = isStatic ? argumentTypes : Arrays.copyOfRange(argumentTypes, 1, argumentTypes.length); if (name.equals("<init>")) { method = metaAccess.lookupJavaMethod(declaringClass.getDeclaredConstructor(parameterTypes)); } else { method = metaAccess.lookupJavaMethod(declaringClass.getDeclaredMethod(name, parameterTypes)); } assert method.isStatic() == isStatic; return method; } catch (NoSuchMethodException | SecurityException e) { throw new GraalInternalError(e); } } @Override public String toString() { StringBuilder sb = new StringBuilder(declaringClass.getName()).append('.').append(name).append('('); for (Class<?> p : argumentTypes) { if (sb.charAt(sb.length() - 1) != '(') { sb.append(", "); } sb.append(p.getSimpleName()); } return sb.append(')').toString(); } } protected final MetaAccessProvider metaAccess; private final List<MethodInfo> registrations; /** * The minimum {@linkplain InvocationPluginIdHolder#getInvocationPluginId() id} for a method * associated with a plugin in {@link #plugins}. */ private int minId = Integer.MAX_VALUE; /** * Resolved methods to plugins map. The keys (i.e., indexes) are derived from * {@link InvocationPluginIdHolder#getInvocationPluginId()}. */ private volatile InvocationPlugin[] plugins; /** * The plugins {@linkplain #lookupInvocation(ResolvedJavaMethod) searched} before searching in * this object. */ private InvocationPlugins parent; private InvocationPlugins(InvocationPlugins parent, MetaAccessProvider metaAccess) { this.metaAccess = metaAccess; this.registrations = new ArrayList<>(INITIAL_PLUGIN_CAPACITY); InvocationPlugins p = parent; // Only adopt a non-empty parent while (p != null && p.size() == 0) { p = p.parent; } this.parent = p; } private static final int INITIAL_PLUGIN_CAPACITY = 64; /** * Creates a set of invocation plugins with a non-null {@linkplain #getParent() parent}. */ public InvocationPlugins(InvocationPlugins parent) { this(parent, parent.metaAccess); } public InvocationPlugins(MetaAccessProvider metaAccess) { this(null, metaAccess); } /** * Registers an invocation plugin for a given method. There must be no plugin currently * registered for {@code method}. */ public void register(InvocationPlugin plugin, Class<?> declaringClass, String name, Class<?>... argumentTypes) { MethodInfo methodInfo = new MethodInfo(plugin, declaringClass, name, argumentTypes); assert Checker.check(this, methodInfo, plugin); assert plugins == null : "invocation plugin registration is closed"; registrations.add(methodInfo); } private static int nextInvocationPluginId = 1; /** * Gets the plugin for a given method. * * @param method the method to lookup * @return the plugin associated with {@code method} or {@code null} if none exists */ public InvocationPlugin lookupInvocation(ResolvedJavaMethod method) { assert method instanceof InvocationPluginIdHolder; if (parent != null) { InvocationPlugin plugin = parent.lookupInvocation(method); if (plugin != null) { return plugin; } } InvocationPluginIdHolder pluggable = (InvocationPluginIdHolder) method; if (plugins == null) { // Must synchronize across all InvocationPlugins objects to ensure thread safe // allocation of InvocationPlugin identifiers synchronized (InvocationPlugins.class) { if (plugins == null) { if (registrations.isEmpty()) { plugins = new InvocationPlugin[0]; } else { int max = Integer.MIN_VALUE; for (MethodInfo methodInfo : registrations) { InvocationPluginIdHolder p = (InvocationPluginIdHolder) methodInfo.resolve(metaAccess); int id = p.getInvocationPluginId(); if (id == 0) { id = nextInvocationPluginId++; p.setInvocationPluginId(id); } if (id < minId) { minId = id; } if (id > max) { max = id; } methodInfo.id = id; } int length = (max - minId) + 1; plugins = new InvocationPlugin[length]; for (MethodInfo m : registrations) { int index = m.id - minId; plugins[index] = m.plugin; } } } } } int id = pluggable.getInvocationPluginId(); int index = id - minId; return index >= 0 && index < plugins.length ? plugins[index] : null; } /** * Gets the invocation plugins {@linkplain #lookupInvocation(ResolvedJavaMethod) searched} * before searching in this object. */ public InvocationPlugins getParent() { return parent; } @Override public String toString() { return registrations.stream().map(MethodInfo::toString).collect(Collectors.joining(", ")) + " / parent: " + this.parent; } private static class Checker { private static final int MAX_ARITY = 5; /** * The set of all {@link InvocationPlugin#apply} method signatures. */ static final Class<?>[][] SIGS; static { ArrayList<Class<?>[]> sigs = new ArrayList<>(MAX_ARITY); for (Method method : InvocationPlugin.class.getDeclaredMethods()) { if (!Modifier.isStatic(method.getModifiers()) && method.getName().equals("apply")) { Class<?>[] sig = method.getParameterTypes(); assert sig[0] == GraphBuilderContext.class; assert sig[1] == ResolvedJavaMethod.class; assert sig[2] == Receiver.class; assert Arrays.asList(Arrays.copyOfRange(sig, 3, sig.length)).stream().allMatch(c -> c == ValueNode.class); while (sigs.size() < sig.length - 2) { sigs.add(null); } sigs.set(sig.length - 3, sig); } } assert sigs.indexOf(null) == -1 : format("need to add an apply() method to %s that takes %d %s arguments ", InvocationPlugin.class.getName(), sigs.indexOf(null), ValueNode.class.getSimpleName()); SIGS = sigs.toArray(new Class<?>[sigs.size()][]); } public static boolean check(InvocationPlugins plugins, MethodInfo method, InvocationPlugin plugin) { InvocationPlugins p = plugins; while (p != null) { assert !p.registrations.contains(method) : "a plugin is already registered for " + method; p = p.parent; } int arguments = method.isStatic ? method.argumentTypes.length : method.argumentTypes.length - 1; assert arguments < SIGS.length : format("need to extend %s to support method with %d arguments: %s", InvocationPlugin.class.getSimpleName(), arguments, method); for (Method m : plugin.getClass().getDeclaredMethods()) { if (m.getName().equals("apply")) { Class<?>[] parameterTypes = m.getParameterTypes(); if (Arrays.equals(SIGS[arguments], parameterTypes)) { return true; } } } throw new AssertionError(format("graph builder plugin for %s not found", method)); } } public MetaAccessProvider getMetaAccess() { return metaAccess; } public int size() { return registrations.size(); } /** * Checks a set of nodes added to the graph by an {@link InvocationPlugin}. * * @param b the graph builder that applied the plugin * @param plugin a plugin that was just applied * @param newNodes the nodes added to the graph by {@code plugin} * @throws AssertionError if any check fail */ public void checkNewNodes(GraphBuilderContext b, InvocationPlugin plugin, NodeIterable<Node> newNodes) { if (parent != null) { parent.checkNewNodes(b, plugin, newNodes); } } }