/*
* Copyright (c) 2014, 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 org.graalvm.compiler.core.match;
import static org.graalvm.compiler.debug.GraalDebugConfig.Options.LogVerbose;
import java.util.ArrayList;
import java.util.List;
import org.graalvm.compiler.core.gen.NodeMatchRules;
import org.graalvm.compiler.debug.Debug;
import org.graalvm.compiler.debug.Debug.Scope;
import org.graalvm.compiler.debug.GraalError;
import org.graalvm.compiler.graph.Edges;
import org.graalvm.compiler.graph.Node;
import org.graalvm.compiler.graph.NodeClass;
import org.graalvm.compiler.graph.Position;
import org.graalvm.compiler.options.OptionValues;
import org.graalvm.compiler.serviceprovider.GraalServices;
import org.graalvm.util.Equivalence;
import org.graalvm.util.EconomicMap;
import org.graalvm.util.MapCursor;
public class MatchRuleRegistry {
/**
* Convert a list of field names into {@link org.graalvm.compiler.graph.Position} objects that
* can be used to read them during a match. The names should already have been confirmed to
* exist in the type.
*
* @param nodeClass
* @param names
* @return an array of Position objects corresponding to the named fields.
*/
public static Position[] findPositions(NodeClass<? extends Node> nodeClass, String[] names) {
Position[] result = new Position[names.length];
for (int i = 0; i < names.length; i++) {
Edges edges = nodeClass.getInputEdges();
for (int e = 0; e < edges.getDirectCount(); e++) {
if (names[i].equals(edges.getName(e))) {
result[i] = new Position(edges, e, Node.NOT_ITERABLE);
}
}
if (result[i] == null) {
throw new GraalError("unknown field \"%s\" in class %s", names[i], nodeClass);
}
}
return result;
}
private static final EconomicMap<Class<? extends NodeMatchRules>, EconomicMap<Class<? extends Node>, List<MatchStatement>>> registry = EconomicMap.create(Equivalence.IDENTITY);
/**
* Collect all the {@link MatchStatement}s defined by the superclass chain of theClass.
*
* @param theClass
* @param options
* @return the set of {@link MatchStatement}s applicable to theClass.
*/
@SuppressWarnings("try")
public static synchronized EconomicMap<Class<? extends Node>, List<MatchStatement>> lookup(Class<? extends NodeMatchRules> theClass, OptionValues options) {
EconomicMap<Class<? extends Node>, List<MatchStatement>> result = registry.get(theClass);
if (result == null) {
EconomicMap<Class<? extends Node>, List<MatchStatement>> rules = createRules(theClass);
registry.put(theClass, rules);
assert registry.get(theClass) == rules;
result = rules;
if (LogVerbose.getValue(options)) {
try (Scope s = Debug.scope("MatchComplexExpressions")) {
Debug.log("Match rules for %s", theClass.getSimpleName());
MapCursor<Class<? extends Node>, List<MatchStatement>> cursor = result.getEntries();
while (cursor.advance()) {
Debug.log(" For node class: %s", cursor.getKey());
for (MatchStatement statement : cursor.getValue()) {
Debug.log(" %s", statement.getPattern());
}
}
}
}
}
if (result.size() == 0) {
return null;
}
return result;
}
/*
* This is a separate, public method so that external clients can create rules with a custom
* lookup and without the default caching behavior.
*/
@SuppressWarnings("unchecked")
public static EconomicMap<Class<? extends Node>, List<MatchStatement>> createRules(Class<? extends NodeMatchRules> theClass) {
EconomicMap<Class<? extends NodeMatchRules>, MatchStatementSet> matchSets = EconomicMap.create(Equivalence.IDENTITY);
Iterable<MatchStatementSet> sl = GraalServices.load(MatchStatementSet.class);
for (MatchStatementSet rules : sl) {
matchSets.put(rules.forClass(), rules);
}
// Walk the class hierarchy collecting lists and merge them together. The subclass
// rules are first which gives them preference over earlier rules.
EconomicMap<Class<? extends Node>, List<MatchStatement>> rules = EconomicMap.create(Equivalence.IDENTITY);
Class<? extends NodeMatchRules> currentClass = theClass;
do {
MatchStatementSet matchSet = matchSets.get(currentClass);
if (matchSet != null) {
List<MatchStatement> statements = matchSet.statements();
for (MatchStatement statement : statements) {
Class<? extends Node> nodeClass = statement.getPattern().nodeClass();
List<MatchStatement> current = rules.get(nodeClass);
if (current == null) {
current = new ArrayList<>();
rules.put(nodeClass, current);
}
current.add(statement);
}
}
currentClass = (Class<? extends NodeMatchRules>) currentClass.getSuperclass();
} while (currentClass != NodeMatchRules.class);
return rules;
}
}