--- old/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.core/src/org/graalvm/compiler/core/match/MatchRuleRegistry.java	2017-03-20 17:37:45.000000000 -0700
+++ new/src/jdk.internal.vm.compiler/share/classes/org.graalvm.compiler.core/src/org/graalvm/compiler/core/match/MatchRuleRegistry.java	2017-03-20 17:37:45.000000000 -0700
@@ -23,12 +23,8 @@
 package org.graalvm.compiler.core.match;
 
 import static org.graalvm.compiler.debug.GraalDebugConfig.Options.LogVerbose;
-
 import java.util.ArrayList;
-import java.util.HashMap;
 import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
 
 import org.graalvm.compiler.core.gen.NodeMatchRules;
 import org.graalvm.compiler.debug.Debug;
@@ -38,7 +34,11 @@
 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 {
 
@@ -67,30 +67,32 @@
         return result;
     }
 
-    private static final HashMap<Class<? extends NodeMatchRules>, Map<Class<? extends Node>, List<MatchStatement>>> registry = new HashMap<>();
+    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 Map<Class<? extends Node>, List<MatchStatement>> lookup(Class<? extends NodeMatchRules> theClass) {
-        Map<Class<? extends Node>, List<MatchStatement>> result = registry.get(theClass);
+    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) {
-            Map<Class<? extends Node>, List<MatchStatement>> rules = createRules(theClass);
+            EconomicMap<Class<? extends Node>, List<MatchStatement>> rules = createRules(theClass);
             registry.put(theClass, rules);
             assert registry.get(theClass) == rules;
             result = rules;
 
-            if (LogVerbose.getValue()) {
+            if (LogVerbose.getValue(options)) {
                 try (Scope s = Debug.scope("MatchComplexExpressions")) {
                     Debug.log("Match rules for %s", theClass.getSimpleName());
-                    for (Entry<Class<? extends Node>, List<MatchStatement>> entry : result.entrySet()) {
-                        Debug.log("  For node class: %s", entry.getKey());
-                        for (MatchStatement statement : entry.getValue()) {
+                    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());
                         }
                     }
@@ -108,8 +110,9 @@
      * This is a separate, public method so that external clients can create rules with a custom
      * lookup and without the default caching behavior.
      */
-    public static Map<Class<? extends Node>, List<MatchStatement>> createRules(Class<? extends NodeMatchRules> theClass) {
-        HashMap<Class<? extends NodeMatchRules>, MatchStatementSet> matchSets = new HashMap<>();
+    @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);
@@ -117,8 +120,8 @@
 
         // Walk the class hierarchy collecting lists and merge them together. The subclass
         // rules are first which gives them preference over earlier rules.
-        Map<Class<? extends Node>, List<MatchStatement>> rules = new HashMap<>();
-        Class<?> currentClass = theClass;
+        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) {
@@ -133,7 +136,7 @@
                     current.add(statement);
                 }
             }
-            currentClass = currentClass.getSuperclass();
+            currentClass = (Class<? extends NodeMatchRules>) currentClass.getSuperclass();
         } while (currentClass != NodeMatchRules.class);
         return rules;
     }