--- a/graal/com.oracle.graal.compiler/src/com/oracle/graal/compiler/match/MatchProcessor.java	Wed May 07 10:58:26 2014 -0700
+++ b/graal/com.oracle.graal.compiler/src/com/oracle/graal/compiler/match/MatchProcessor.java	Wed May 07 11:54:25 2014 -0700
@@ -36,6 +36,7 @@
 
 import com.oracle.graal.compiler.common.*;
 import com.oracle.graal.compiler.gen.*;
+import com.oracle.graal.graph.*;
 import com.oracle.graal.nodes.*;
 
 /**
@@ -192,6 +193,13 @@
         }
 
         /**
+         * Recursively accumulate any required NodeClass.Position declarations.
+         */
+        void generatePositionDeclarations(Set<String> declarations) {
+            matchDescriptor.generatePositionDeclarations(declarations);
+        }
+
+        /**
          *
          * @return the list of node types which are captured by name
          */
@@ -369,6 +377,16 @@
             }
         }
 
+        public void generatePositionDeclarations(Set<String> declarations) {
+            if (inputs.length == 0) {
+                return;
+            }
+            declarations.add(generatePositionDeclaration());
+            for (MatchDescriptor desc : inputs) {
+                desc.generatePositionDeclarations(declarations);
+            }
+        }
+
         List<String> recurseVariants(int index) {
             if (inputs.length == 0) {
                 return new ArrayList<>();
@@ -426,7 +444,7 @@
                     return ", true)";
                 } else {
                     if (nodeType.inputs.length > 0) {
-                        return ", MatchPattern.findPositions(" + nodeType.nodeClass + ".class, new String[]{\"" + String.join("\", \"", nodeType.inputs) + "\"})," + !nodeType.shareable + ")";
+                        return ", " + nodeType.nodeClass + "_positions, " + !nodeType.shareable + ")";
                     }
                     if (nodeType.shareable) {
                         return ", false)";
@@ -436,6 +454,10 @@
             return ")";
         }
 
+        String generatePositionDeclaration() {
+            return String.format("private static final NodeClass.Position[] %s_positions = MatchPattern.findPositions(%s.class, new String[]{\"%s\"});", nodeType.nodeClass, nodeType.nodeClass,
+                            String.join("\", \"", nodeType.inputs));
+        }
     }
 
     /**
@@ -468,12 +490,23 @@
             out.println("import " + MatchStatementSet.class.getPackage().getName() + ".*;");
             out.println("import " + GraalInternalError.class.getName() + ";");
             out.println("import " + NodeLIRBuilder.class.getName() + ";");
+            out.println("import " + NodeClass.class.getName() + ";");
             for (String p : requiredPackages) {
                 out.println("import " + p + ".*;");
             }
             out.println("");
             out.println("public class " + matchStatementClassName + " implements " + MatchStatementSet.class.getSimpleName() + " {");
 
+            out.println();
+            out.println("    private static Method lookupMethod(Class<?> theClass, String name, Class<?>... args) {");
+            out.println("        try {");
+            out.println("            return theClass.getDeclaredMethod(name, args);");
+            out.println("        } catch (Exception e) {");
+            out.println("            throw new GraalInternalError(e);");
+            out.println("        }");
+            out.println("    }");
+            out.println();
+
             // Generate declarations for the reflective invocation of the code generation methods.
             for (MethodInvokerItem invoker : invokers.values()) {
                 StringBuilder args = new StringBuilder();
@@ -490,22 +523,17 @@
                         types.append(", ");
                     }
                 }
-                out.printf("        private static final String[] %s = new String[] {%s};\n", invoker.argumentsListName(), args);
-                out.printf("        private static final Method %s;\n", invoker.reflectiveMethodName());
-                out.printf("        static {\n");
-                out.printf("            Method result = null;\n");
-                out.printf("            try {\n");
-                out.printf("                result = %s.class.getDeclaredMethod(\"%s\", %s);\n", invoker.nodeLIRBuilderClass, invoker.methodName, types);
-                out.printf("             } catch (Exception e) {\n");
-                out.printf("                 throw new GraalInternalError(e);\n");
-                out.printf("             }\n");
-                out.printf("             %s = result;\n", invoker.reflectiveMethodName());
-                out.printf("        }\n");
-
+                out.printf("    private static final String[] %s = new String[] {%s};\n", invoker.argumentsListName(), args);
+                out.printf("    private static final Method %s = lookupMethod(%s.class, \"%s\", %s);\n", invoker.reflectiveMethodName(), invoker.nodeLIRBuilderClass, invoker.methodName, types);
                 out.println();
 
             }
 
+            for (String positionDeclaration : info.positionDeclarations) {
+                out.println("    " + positionDeclaration);
+            }
+            out.println();
+
             String desc = MatchStatement.class.getSimpleName();
             out.println("    // CheckStyle: stop line length check");
             out.println("    private static final List<" + desc + "> statements = Collections.unmodifiableList(Arrays.asList(");
@@ -613,6 +641,7 @@
         final TypeElement topDeclaringType;
         final List<MatchRuleItem> matchRules = new ArrayList<>();
         private final Set<Element> originatingElements = new HashSet<>();
+        public Set<String> positionDeclarations = new LinkedHashSet<>();
 
         public MatchRuleDescriptor(TypeElement topDeclaringType) {
             this.topDeclaringType = topDeclaringType;
@@ -900,6 +929,9 @@
 
             originatingElementsList.addAll(parser.originatingElements);
 
+            // Accumulate any position declarations.
+            parser.generatePositionDeclarations(info.positionDeclarations);
+
             List<String> matches = parser.generateVariants();
             for (String match : matches) {
                 info.matchRules.add(new MatchRuleItem(match, invoker));