# HG changeset patch
# User Doug Simon <doug.simon@oracle.com>
# Date 1394042849 -3600
# Node ID 2f37b0e442fe0666a62e5bc293504aa2122d4923
# Parent  73f5ddd8414d28aab49d69fee8b3d3d95182f54d
removed remaining VMToCompiler calls for allocating Graal API objects

diff -r 73f5ddd8414d -r 2f37b0e442fe graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/HotSpotGraalRuntime.java
--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/HotSpotGraalRuntime.java	Wed Mar 05 17:53:38 2014 +0100
+++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/HotSpotGraalRuntime.java	Wed Mar 05 19:07:29 2014 +0100
@@ -341,7 +341,7 @@
         // Resolve the type in the VM.
         final long metaspaceKlass = compilerToVm.lookupType(name, accessingClass, eagerResolve);
         if (metaspaceKlass == 0) {
-            return vmToCompiler.createUnresolvedJavaType(name);
+            return HotSpotUnresolvedJavaType.create(name);
         }
         return HotSpotResolvedObjectType.fromMetaspaceKlass(metaspaceKlass);
     }
diff -r 73f5ddd8414d -r 2f37b0e442fe graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/bridge/CompilerToVM.java
--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/bridge/CompilerToVM.java	Wed Mar 05 17:53:38 2014 +0100
+++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/bridge/CompilerToVM.java	Wed Mar 05 19:07:29 2014 +0100
@@ -118,13 +118,56 @@
 
     Object lookupConstantInPool(long metaspaceConstantPool, int cpi);
 
-    JavaMethod lookupMethodInPool(long metaspaceConstantPool, int cpi, byte opcode);
-
-    JavaType lookupTypeInPool(long metaspaceConstantPool, int cpi);
+    /**
+     * Looks up a method entry in a constant pool. If the method is resolved, then
+     * {@code unresolvedInfo} is unmodified. Otherwise, it contains these values:
+     * 
+     * <pre>
+     *     [(Symbol*) name,
+     *      (Symbol*) signature,
+     *      (Symbol*) holderName, // only non-zero if holder == 0
+     *      (Klass*)  holder]
+     * </pre>
+     * 
+     * @param metaspaceConstantPool
+     * @param unresolvedInfo an array in which the details for an unresolved method are returned
+     * @return a metaspace Method for a resolved method entry otherwise 0 in which case the values
+     *         returned in {@code unresolvedInfo} should be consulted
+     */
+    long lookupMethodInPool(long metaspaceConstantPool, int cpi, byte opcode, long[] unresolvedInfo);
 
-    JavaField lookupFieldInPool(long metaspaceConstantPool, int cpi, byte opcode);
+    /**
+     * Looks up a class entry in a constant pool.
+     * 
+     * @param metaspaceConstantPool
+     * @param unresolvedTypeName a 1 element array in which the name of the class is returned if
+     *            this method returns 0
+     * @return a metaspace Klass for a resolved method entry otherwise 0 in which case the value
+     *         returned in {@code unresolvedTypeName} should be consulted
+     */
+    long lookupTypeInPool(long metaspaceConstantPool, int cpi, long[] unresolvedTypeName);
 
-    void lookupReferencedTypeInPool(long metaspaceConstantPool, int cpi, byte opcode);
+    /**
+     * Looks up a field entry in a constant pool and attempts to resolve it. The values returned in
+     * {@code info} are:
+     * 
+     * <pre>
+     *     [(Symbol*) name,
+     *      (Symbol*) typeName,   // only non-zero if type == 0
+     *      (Klass*)  type,
+     *      (Symbol*) holderName, // only non-zero if holder == 0
+     *      (Klass*)  holder,
+     *      (int)     flags,      // only valid if field is resolved
+     *      (int)     offset]     // only valid if field is resolved
+     * </pre>
+     * 
+     * @param metaspaceConstantPool
+     * @param info an array in which the details of the field are returned
+     * @return true if the field is resolved
+     */
+    boolean lookupFieldInPool(long metaspaceConstantPool, int cpi, byte opcode, long[] info);
+
+    void loadReferencedTypeInPool(long metaspaceConstantPool, int cpi, byte opcode);
 
     Object lookupAppendixInPool(long metaspaceConstantPool, int cpi);
 
diff -r 73f5ddd8414d -r 2f37b0e442fe graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/bridge/CompilerToVMImpl.java
--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/bridge/CompilerToVMImpl.java	Wed Mar 05 17:53:38 2014 +0100
+++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/bridge/CompilerToVMImpl.java	Wed Mar 05 19:07:29 2014 +0100
@@ -24,7 +24,6 @@
 package com.oracle.graal.hotspot.bridge;
 
 import com.oracle.graal.api.code.*;
-import com.oracle.graal.api.meta.*;
 import com.oracle.graal.hotspot.*;
 import com.oracle.graal.hotspot.meta.*;
 
@@ -65,16 +64,16 @@
     public native Object lookupConstantInPool(long metaspaceConstantPool, int cpi);
 
     @Override
-    public native JavaMethod lookupMethodInPool(long metaspaceConstantPool, int cpi, byte opcode);
+    public native long lookupMethodInPool(long metaspaceConstantPool, int cpi, byte opcode, long[] unresolvedInfo);
 
     @Override
-    public native JavaType lookupTypeInPool(long metaspaceConstantPool, int cpi);
+    public native long lookupTypeInPool(long metaspaceConstantPool, int cpi, long[] unresolvedTypeName);
 
     @Override
-    public native JavaField lookupFieldInPool(long metaspaceConstantPool, int cpi, byte opcode);
+    public native boolean lookupFieldInPool(long metaspaceConstantPool, int cpi, byte opcode, long[] info);
 
     @Override
-    public native void lookupReferencedTypeInPool(long metaspaceConstantPool, int cpi, byte opcode);
+    public native void loadReferencedTypeInPool(long metaspaceConstantPool, int cpi, byte opcode);
 
     @Override
     public native Object lookupAppendixInPool(long metaspaceConstantPool, int cpi);
diff -r 73f5ddd8414d -r 2f37b0e442fe graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/bridge/VMToCompiler.java
--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/bridge/VMToCompiler.java	Wed Mar 05 17:53:38 2014 +0100
+++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/bridge/VMToCompiler.java	Wed Mar 05 19:07:29 2014 +0100
@@ -25,8 +25,6 @@
 
 import java.io.*;
 
-import com.oracle.graal.api.meta.*;
-
 /**
  * Calls from HotSpot into Java.
  */
@@ -47,24 +45,4 @@
     void compileTheWorld() throws Throwable;
 
     PrintStream log();
-
-    JavaMethod createUnresolvedJavaMethod(String name, String signature, JavaType holder);
-
-    JavaField createJavaField(JavaType holder, String name, JavaType type, int offset, int flags, boolean internal);
-
-    ResolvedJavaMethod createResolvedJavaMethod(JavaType holder, long metaspaceMethod);
-
-    JavaType createPrimitiveJavaType(int basicType);
-
-    JavaType createUnresolvedJavaType(String name);
-
-    /**
-     * Creates a resolved Java type.
-     * 
-     * @param javaMirror the {@link Class} mirror
-     * @return the resolved type associated with {@code javaMirror} which may not be the type
-     *         instantiated by this call in the case of another thread racing to create the same
-     *         type
-     */
-    ResolvedJavaType createResolvedJavaType(Class javaMirror);
 }
diff -r 73f5ddd8414d -r 2f37b0e442fe graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/bridge/VMToCompilerImpl.java
--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/bridge/VMToCompilerImpl.java	Wed Mar 05 17:53:38 2014 +0100
+++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/bridge/VMToCompilerImpl.java	Wed Mar 05 19:07:29 2014 +0100
@@ -560,86 +560,6 @@
     }
 
     @Override
-    public JavaMethod createUnresolvedJavaMethod(String name, String signature, JavaType holder) {
-        return new HotSpotMethodUnresolved(name, signature, holder);
-    }
-
-    @Override
-    public JavaField createJavaField(JavaType holder, String name, JavaType type, int offset, int flags, boolean internal) {
-        if (offset != -1) {
-            HotSpotResolvedObjectType resolved = (HotSpotResolvedObjectType) holder;
-            return resolved.createField(name, type, offset, flags);
-        }
-        return new HotSpotUnresolvedField(holder, name, type);
-    }
-
-    @Override
-    public ResolvedJavaMethod createResolvedJavaMethod(JavaType holder, long metaspaceMethod) {
-        HotSpotResolvedObjectType type = (HotSpotResolvedObjectType) holder;
-        return type.createMethod(metaspaceMethod);
-    }
-
-    @Override
-    public ResolvedJavaType createPrimitiveJavaType(int basicType) {
-        Class<?> javaClass;
-        switch (basicType) {
-            case 4:
-                javaClass = boolean.class;
-                break;
-            case 5:
-                javaClass = char.class;
-                break;
-            case 6:
-                javaClass = float.class;
-                break;
-            case 7:
-                javaClass = double.class;
-                break;
-            case 8:
-                javaClass = byte.class;
-                break;
-            case 9:
-                javaClass = short.class;
-                break;
-            case 10:
-                javaClass = int.class;
-                break;
-            case 11:
-                javaClass = long.class;
-                break;
-            case 14:
-                javaClass = void.class;
-                break;
-            default:
-                throw new IllegalArgumentException("Unknown basic type: " + basicType);
-        }
-        return HotSpotResolvedPrimitiveType.fromClass(javaClass);
-    }
-
-    @Override
-    public HotSpotUnresolvedJavaType createUnresolvedJavaType(String name) {
-        int dims = 0;
-        int startIndex = 0;
-        while (name.charAt(startIndex) == '[') {
-            startIndex++;
-            dims++;
-        }
-
-        // Decode name if necessary.
-        if (name.charAt(name.length() - 1) == ';') {
-            assert name.charAt(startIndex) == 'L';
-            return new HotSpotUnresolvedJavaType(name, name.substring(startIndex + 1, name.length() - 1), dims);
-        } else {
-            return new HotSpotUnresolvedJavaType(HotSpotUnresolvedJavaType.getFullName(name, dims), name, dims);
-        }
-    }
-
-    @Override
-    public ResolvedJavaType createResolvedJavaType(Class javaMirror) {
-        return HotSpotResolvedObjectType.fromClass(javaMirror);
-    }
-
-    @Override
     public PrintStream log() {
         return log;
     }
diff -r 73f5ddd8414d -r 2f37b0e442fe graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/meta/HotSpotConstantPool.java
--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/meta/HotSpotConstantPool.java	Wed Mar 05 17:53:38 2014 +0100
+++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/meta/HotSpotConstantPool.java	Wed Mar 05 19:07:29 2014 +0100
@@ -280,21 +280,67 @@
         return runtime().getCompilerToVM().lookupAppendixInPool(metaspaceConstantPool, index);
     }
 
+    /**
+     * Gets a {@link JavaType} corresponding a given metaspace Klass or to a given name if the
+     * former is null.
+     * 
+     * @param metaspaceSymbol a type name
+     * @param metaspaceKlass a resolved type (if non-zero)
+     * @param mayBePrimitive specifies if the requested type may be primitive
+     */
+    private static JavaType getType(long metaspaceSymbol, long metaspaceKlass, boolean mayBePrimitive) {
+        if (metaspaceKlass == 0L) {
+            String name = new HotSpotSymbol(metaspaceSymbol).asString();
+            if (mayBePrimitive && name.length() == 1) {
+                Kind kind = Kind.fromPrimitiveOrVoidTypeChar(name.charAt(0));
+                return HotSpotResolvedPrimitiveType.fromClass(kind.toJavaClass());
+            }
+            return HotSpotUnresolvedJavaType.create(name);
+        } else {
+            return HotSpotResolvedObjectType.fromMetaspaceKlass(metaspaceKlass);
+        }
+    }
+
     @Override
     public JavaMethod lookupMethod(int cpi, int opcode) {
         final int index = toConstantPoolIndex(cpi, opcode);
-        return runtime().getCompilerToVM().lookupMethodInPool(metaspaceConstantPool, index, (byte) opcode);
+        // {name, signature, unresolved_holder_name, resolved_holder}
+        long[] unresolvedInfo = new long[4];
+        long metaspaceMethod = runtime().getCompilerToVM().lookupMethodInPool(metaspaceConstantPool, index, (byte) opcode, unresolvedInfo);
+        if (metaspaceMethod != 0L) {
+            return HotSpotResolvedJavaMethod.fromMetaspace(metaspaceMethod);
+        } else {
+            String name = new HotSpotSymbol(unresolvedInfo[0]).asString();
+            String signature = new HotSpotSymbol(unresolvedInfo[1]).asString();
+            JavaType holder = getType(unresolvedInfo[2], unresolvedInfo[3], false);
+            return new HotSpotMethodUnresolved(name, signature, holder);
+        }
     }
 
     @Override
     public JavaType lookupType(int cpi, int opcode) {
-        return runtime().getCompilerToVM().lookupTypeInPool(metaspaceConstantPool, cpi);
+        long[] unresolvedTypeName = {0};
+        long metaspaceKlass = runtime().getCompilerToVM().lookupTypeInPool(metaspaceConstantPool, cpi, unresolvedTypeName);
+        return getType(unresolvedTypeName[0], metaspaceKlass, false);
     }
 
     @Override
     public JavaField lookupField(int cpi, int opcode) {
         final int index = toConstantPoolIndex(cpi, opcode);
-        return runtime().getCompilerToVM().lookupFieldInPool(metaspaceConstantPool, index, (byte) opcode);
+        long[] info = new long[7];
+        boolean resolved = runtime().getCompilerToVM().lookupFieldInPool(metaspaceConstantPool, index, (byte) opcode, info);
+        String name = new HotSpotSymbol(info[0]).asString();
+        JavaType type = getType(info[1], info[2], true);
+        JavaType holder = getType(info[3], info[4], false);
+        int flags = (int) info[5];
+        int offset = (int) info[6];
+        if (resolved) {
+            HotSpotResolvedObjectType resolvedHolder = (HotSpotResolvedObjectType) holder;
+            HotSpotResolvedJavaField f = resolvedHolder.createField(name, type, offset, flags);
+            return f;
+        } else {
+            return new HotSpotUnresolvedField(holder, name, type);
+        }
     }
 
     @Override
@@ -306,6 +352,6 @@
         } else {
             index = cpi;
         }
-        runtime().getCompilerToVM().lookupReferencedTypeInPool(metaspaceConstantPool, index, (byte) opcode);
+        runtime().getCompilerToVM().loadReferencedTypeInPool(metaspaceConstantPool, index, (byte) opcode);
     }
 }
diff -r 73f5ddd8414d -r 2f37b0e442fe graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/meta/HotSpotResolvedObjectType.java
--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/meta/HotSpotResolvedObjectType.java	Wed Mar 05 17:53:38 2014 +0100
+++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/meta/HotSpotResolvedObjectType.java	Wed Mar 05 19:07:29 2014 +0100
@@ -547,7 +547,7 @@
                     throw new GraalInternalError(e);
                 }
                 if (c == null) {
-                    type = runtime().getVMToCompiler().createUnresolvedJavaType(signature);
+                    type = HotSpotUnresolvedJavaType.create(signature);
                 } else {
                     type = HotSpotResolvedObjectType.fromClass(c);
                 }
diff -r 73f5ddd8414d -r 2f37b0e442fe graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/meta/HotSpotUnresolvedJavaType.java
--- a/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/meta/HotSpotUnresolvedJavaType.java	Wed Mar 05 17:53:38 2014 +0100
+++ b/graal/com.oracle.graal.hotspot/src/com/oracle/graal/hotspot/meta/HotSpotUnresolvedJavaType.java	Wed Mar 05 19:07:29 2014 +0100
@@ -42,6 +42,26 @@
         this.dimensions = dimensions;
     }
 
+    /**
+     * Creates an unresolved type for a valid {@link JavaType#getName() type name}.
+     */
+    public static HotSpotUnresolvedJavaType create(String name) {
+        int dims = 0;
+        int startIndex = 0;
+        while (name.charAt(startIndex) == '[') {
+            startIndex++;
+            dims++;
+        }
+
+        // Decode name if necessary.
+        if (name.charAt(name.length() - 1) == ';') {
+            assert name.charAt(startIndex) == 'L';
+            return new HotSpotUnresolvedJavaType(name, name.substring(startIndex + 1, name.length() - 1), dims);
+        } else {
+            return new HotSpotUnresolvedJavaType(HotSpotUnresolvedJavaType.getFullName(name, dims), name, dims);
+        }
+    }
+
     public static String getFullName(String name, int dimensions) {
         StringBuilder str = new StringBuilder(name.length() + dimensions + 2);
         for (int i = 0; i < dimensions; i++) {
diff -r 73f5ddd8414d -r 2f37b0e442fe src/share/vm/classfile/vmSymbols.hpp
--- a/src/share/vm/classfile/vmSymbols.hpp	Wed Mar 05 17:53:38 2014 +0100
+++ b/src/share/vm/classfile/vmSymbols.hpp	Wed Mar 05 19:07:29 2014 +0100
@@ -359,20 +359,6 @@
   template(setOption_name,                        "setOption")                                                                        \
   template(setOption_signature,                   "(Ljava/lang/String;)Z")                                                            \
   template(finalizeOptions_name,                  "finalizeOptions")                                                                  \
-  template(createUnresolvedJavaMethod_name,       "createUnresolvedJavaMethod")                                                       \
-  template(createUnresolvedJavaMethod_signature,  "(Ljava/lang/String;Ljava/lang/String;Lcom/oracle/graal/api/meta/JavaType;)Lcom/oracle/graal/api/meta/JavaMethod;") \
-  template(createSignature_name,                  "createSignature")                                                                  \
-  template(createSignature_signature,             "(Ljava/lang/String;)Lcom/oracle/graal/api/meta/Signature;")                        \
-  template(createJavaField_name,                  "createJavaField")                                                                  \
-  template(createJavaField_signature,             "(Lcom/oracle/graal/api/meta/JavaType;Ljava/lang/String;Lcom/oracle/graal/api/meta/JavaType;IIZ)Lcom/oracle/graal/api/meta/JavaField;") \
-  template(createResolvedJavaMethod_name,         "createResolvedJavaMethod")                                                         \
-  template(createResolvedJavaMethod_signature,    "(Lcom/oracle/graal/api/meta/JavaType;J)Lcom/oracle/graal/api/meta/ResolvedJavaMethod;") \
-  template(createUnresolvedJavaType_name,         "createUnresolvedJavaType")                                                         \
-  template(createUnresolvedJavaType_signature,    "(Ljava/lang/String;)Lcom/oracle/graal/api/meta/JavaType;")                         \
-  template(createResolvedJavaType_name,           "createResolvedJavaType")                                                           \
-  template(createResolvedJavaType_signature,      "(Ljava/lang/Class;)Lcom/oracle/graal/api/meta/ResolvedJavaType;") \
-  template(createPrimitiveJavaType_name,          "createPrimitiveJavaType")                                                          \
-  template(createPrimitiveJavaType_signature,     "(I)Lcom/oracle/graal/api/meta/JavaType;")                                          \
   template(getVMToCompiler_name,                  "getVMToCompiler")                                                                  \
   template(getVMToCompiler_signature,             "()Lcom/oracle/graal/hotspot/bridge/VMToCompiler;")                                 \
   template(runtime_name,                          "runtime")                                                                          \
diff -r 73f5ddd8414d -r 2f37b0e442fe src/share/vm/graal/graalCompiler.cpp
--- a/src/share/vm/graal/graalCompiler.cpp	Wed Mar 05 17:53:38 2014 +0100
+++ b/src/share/vm/graal/graalCompiler.cpp	Wed Mar 05 19:07:29 2014 +0100
@@ -211,30 +211,21 @@
   TRACE_graal_1("GraalCompiler::print_timers");
 }
 
-Handle GraalCompiler::get_JavaTypeFromSignature(Symbol* signature, KlassHandle loading_klass, TRAPS) {
+KlassHandle GraalCompiler::get_KlassFromSignature(Symbol* signature, KlassHandle loading_klass) {
   BasicType field_type = FieldType::basic_type(signature);
-  // If the field is a pointer type, get the klass of the
-  // field.
+  // If the field is a pointer type, get the klass of the field.
   if (field_type == T_OBJECT || field_type == T_ARRAY) {
-    KlassHandle klass = GraalEnv::get_klass_by_name(loading_klass, signature, false);
-    if (klass.is_null()) {
-      Handle signature_string = java_lang_String::create_from_symbol(signature, CHECK_NH);
-      return VMToCompiler::createUnresolvedJavaType(signature_string, CHECK_NH);
-    } else {
-      return VMToCompiler::createResolvedJavaType(klass->java_mirror(), CHECK_NH);
-    }
-  } else {
-    return VMToCompiler::createPrimitiveJavaType(field_type, CHECK_NH);
+    return GraalEnv::get_klass_by_name(loading_klass, signature, false);
   }
+  return NULL;
 }
 
-Handle GraalCompiler::get_JavaType(constantPoolHandle cp, int index, KlassHandle loading_klass, TRAPS) {
+KlassHandle GraalCompiler::get_Klass(constantPoolHandle cp, int index, KlassHandle loading_klass, Symbol*& klass_name) {
   bool is_accessible = false;
 
   KlassHandle klass = GraalEnv::get_klass_by_index(cp, index, is_accessible, loading_klass);
-  oop catch_class = NULL;
   if (klass.is_null()) {
-    Symbol* klass_name = NULL;
+    klass_name = NULL;
     {
       // We have to lock the cpool to keep the oop from being resolved
       // while we are accessing it. But we must release the lock before
@@ -244,7 +235,9 @@
       if (tag.is_klass()) {
         // The klass has been inserted into the constant pool
         // very recently.
-        return VMToCompiler::createResolvedJavaType(cp->resolved_klass_at(index)->java_mirror(), CHECK_NH);
+        klass = cp->resolved_klass_at(index);
+        klass_name = klass->name();
+        return klass;
       } else if (tag.is_symbol()) {
         klass_name = cp->symbol_at(index);
       } else {
@@ -252,11 +245,10 @@
         klass_name = cp->unresolved_klass_at(index);
       }
     }
-    Handle klass_name_string = java_lang_String::create_from_symbol(klass_name, CHECK_NH);
-    return VMToCompiler::createUnresolvedJavaType(klass_name_string, CHECK_NH);
   } else {
-    return VMToCompiler::createResolvedJavaType(klass->java_mirror(), CHECK_NH);
+    klass_name = klass->name();
   }
+  return klass;
 }
 
 BasicType GraalCompiler::kindToBasicType(jchar ch) {
diff -r 73f5ddd8414d -r 2f37b0e442fe src/share/vm/graal/graalCompiler.hpp
--- a/src/share/vm/graal/graalCompiler.hpp	Wed Mar 05 17:53:38 2014 +0100
+++ b/src/share/vm/graal/graalCompiler.hpp	Wed Mar 05 19:07:29 2014 +0100
@@ -71,8 +71,8 @@
   // Print compilation timers and statistics
   virtual void print_timers();
 
-  static Handle get_JavaTypeFromSignature(Symbol* signature, KlassHandle accessor, TRAPS);
-  static Handle get_JavaType(constantPoolHandle cp, int index, KlassHandle accessor, TRAPS);
+  static KlassHandle get_KlassFromSignature(Symbol* signature, KlassHandle loading_klass);
+  static KlassHandle get_Klass(constantPoolHandle cp, int index, KlassHandle accessor, Symbol*& klass_name);
 
   void exit();
 
diff -r 73f5ddd8414d -r 2f37b0e442fe src/share/vm/graal/graalCompilerToVM.cpp
--- a/src/share/vm/graal/graalCompilerToVM.cpp	Wed Mar 05 17:53:38 2014 +0100
+++ b/src/share/vm/graal/graalCompilerToVM.cpp	Wed Mar 05 19:07:29 2014 +0100
@@ -263,7 +263,7 @@
   return JNIHandles::make_local(THREAD, appendix_oop);
 C2V_END
 
-C2V_VMENTRY(jobject, lookupMethodInPool, (JNIEnv *env, jobject, jlong metaspace_constant_pool, jint index, jbyte opcode))
+C2V_VMENTRY(jlong, lookupMethodInPool, (JNIEnv *env, jobject, jlong metaspace_constant_pool, jint index, jbyte opcode, jlongArray unresolvedInfo_handle))
   constantPoolHandle cp = (ConstantPool*) metaspace_constant_pool;
   instanceKlassHandle pool_holder(cp->pool_holder());
 
@@ -271,30 +271,37 @@
 
   methodHandle method = GraalEnv::get_method_by_index(cp, index, bc, pool_holder);
   if (!method.is_null()) {
-    Handle holder = VMToCompiler::createResolvedJavaType(method->method_holder()->java_mirror(), CHECK_NULL);
-    return JNIHandles::make_local(THREAD, VMToCompiler::createResolvedJavaMethod(holder, method(), THREAD));
+    return (jlong) method();
   } else {
-    // Get the method's name and signature.
-    Handle name = java_lang_String::create_from_symbol(cp->name_ref_at(index), CHECK_NULL);
-    Handle signature  = java_lang_String::create_from_symbol(cp->signature_ref_at(index), CHECK_NULL);
+    // Get the unresolved method's name and signature.
+    typeArrayOop unresolvedInfo = (typeArrayOop) JNIHandles::resolve(unresolvedInfo_handle);
+    assert(unresolvedInfo != NULL && unresolvedInfo->length() == 4, "must be");
+    unresolvedInfo->long_at_put(0, (jlong) cp->name_ref_at(index));
+    unresolvedInfo->long_at_put(1, (jlong) cp->signature_ref_at(index));
     Handle type;
     if (bc != Bytecodes::_invokedynamic) {
       int holder_index = cp->klass_ref_index_at(index);
-      type = GraalCompiler::get_JavaType(cp, holder_index, cp->pool_holder(), CHECK_NULL);
+      Symbol* klass_name = NULL;
+      KlassHandle klass = GraalCompiler::get_Klass(cp, holder_index, cp->pool_holder(), klass_name);
+      unresolvedInfo->long_at_put(2, (jlong) klass_name);
+      unresolvedInfo->long_at_put(3, (jlong) klass());
     } else {
-      type = Handle(SystemDictionary::MethodHandle_klass()->java_mirror());
+      unresolvedInfo->long_at_put(3, (jlong) SystemDictionary::MethodHandle_klass());
     }
-    return JNIHandles::make_local(THREAD, VMToCompiler::createUnresolvedJavaMethod(name, signature, type, THREAD));
+    return 0L;
   }
 C2V_END
 
-C2V_VMENTRY(jobject, lookupTypeInPool, (JNIEnv *env, jobject, jlong metaspace_constant_pool, jint index))
+C2V_VMENTRY(jlong, lookupTypeInPool, (JNIEnv *env, jobject, jlong metaspace_constant_pool, jint index, jlongArray unresolvedTypeName_handle))
   ConstantPool* cp = (ConstantPool*) metaspace_constant_pool;
-  Handle result = GraalCompiler::get_JavaType(cp, index, cp->pool_holder(), CHECK_NULL);
-  return JNIHandles::make_local(THREAD, result());
+  Symbol* klass_name = NULL;
+  KlassHandle klass = GraalCompiler::get_Klass(cp, index, cp->pool_holder(), klass_name);
+  typeArrayOop unresolvedTypeName = (typeArrayOop) JNIHandles::resolve(unresolvedTypeName_handle);
+  unresolvedTypeName->long_at_put(0, (jlong) klass_name);
+  return (jlong) klass();
 C2V_END
 
-C2V_VMENTRY(void, lookupReferencedTypeInPool, (JNIEnv *env, jobject, jlong metaspace_constant_pool, jint index, jbyte op))
+C2V_VMENTRY(void, loadReferencedTypeInPool, (JNIEnv *env, jobject, jlong metaspace_constant_pool, jint index, jbyte op))
   ConstantPool* cp = (ConstantPool*) metaspace_constant_pool;
   Bytecodes::Code bc = (Bytecodes::Code) (((int) op) & 0xFF);
   if (bc != Bytecodes::_checkcast && bc != Bytecodes::_instanceof && bc != Bytecodes::_new && bc != Bytecodes::_anewarray
@@ -316,42 +323,44 @@
   }
 C2V_END
 
-C2V_VMENTRY(jobject, lookupFieldInPool, (JNIEnv *env, jobject, jlong metaspace_constant_pool, jint index, jbyte opcode))
+C2V_VMENTRY(jboolean, lookupFieldInPool, (JNIEnv *env, jobject, jlong metaspace_constant_pool, jint index, jbyte opcode, jlongArray info_handle))
   ResourceMark rm;
 
   constantPoolHandle cp = (ConstantPool*) metaspace_constant_pool;
 
   int nt_index = cp->name_and_type_ref_index_at(index);
-  int sig_index = cp->signature_ref_index_at(nt_index);
-  Symbol* signature = cp->symbol_at(sig_index);
+  int type_index = cp->signature_ref_index_at(nt_index);
+  Symbol* type_name = cp->symbol_at(type_index);
   int name_index = cp->name_ref_index_at(nt_index);
   Symbol* name = cp->symbol_at(name_index);
   int holder_index = cp->klass_ref_index_at(index);
-  Handle holder = GraalCompiler::get_JavaType(cp, holder_index, cp->pool_holder(), CHECK_NULL);
-  instanceKlassHandle holder_klass;
+  Symbol* holder_name = NULL;
+  KlassHandle holder = GraalCompiler::get_Klass(cp, holder_index, cp->pool_holder(), holder_name);
+  KlassHandle type = GraalCompiler::get_KlassFromSignature(type_name, cp->pool_holder());
+  typeArrayOop info = (typeArrayOop) JNIHandles::resolve(info_handle);
+  assert(info != NULL && info->length() == 7, "must be");
+  info->long_at_put(0, (jlong) name);
+  info->long_at_put(1, (jlong) type_name);
+  info->long_at_put(2, (jlong) type());
+  info->long_at_put(3, (jlong) holder_name);
+  info->long_at_put(4, (jlong) holder());
 
   Bytecodes::Code code = (Bytecodes::Code)(((int) opcode) & 0xFF);
-  int offset = -1;
-  AccessFlags flags;
-  if (holder->klass() == SystemDictionary::HotSpotResolvedObjectType_klass()) {
+  if (!holder.is_null()) {
+    int offset = -1;
     fieldDescriptor result;
     LinkResolver::resolve_field_access(result, cp, index, Bytecodes::java_code(code), true, false, Thread::current());
 
     if (HAS_PENDING_EXCEPTION) {
       CLEAR_PENDING_EXCEPTION;
     } else {
-      offset = result.offset();
-      flags = result.access_flags();
-      holder_klass = result.field_holder();
-      holder = VMToCompiler::createResolvedJavaType(holder_klass->java_mirror(), CHECK_NULL);
+      info->long_at_put(4, (jlong) result.field_holder());
+      info->long_at_put(5, (jlong) result.access_flags().as_int());
+      info->long_at_put(6, (jlong) result.offset());
+      return true;
     }
   }
-
-  Handle type = GraalCompiler::get_JavaTypeFromSignature(signature, cp->pool_holder(), CHECK_NULL);
-  Handle java_name = java_lang_String::create_from_symbol(name, CHECK_NULL);
-  Handle field_handle = VMToCompiler::createJavaField(holder, java_name, type, offset, flags.as_int(), false, CHECK_NULL);
-
-  return JNIHandles::make_local(THREAD, field_handle());
+  return false;
 C2V_END
 
 C2V_VMENTRY(jlong, resolveMethod, (JNIEnv *, jobject, jobject resolved_type, jstring name, jstring signature))
@@ -866,10 +875,10 @@
   {CC"lookupType",                    CC"("STRING CLASS"Z)"METASPACE_KLASS,                             FN_PTR(lookupType)},
   {CC"lookupConstantInPool",          CC"("METASPACE_CONSTANT_POOL"I)"OBJECT,                           FN_PTR(lookupConstantInPool)},
   {CC"lookupAppendixInPool",          CC"("METASPACE_CONSTANT_POOL"I)"OBJECT,                           FN_PTR(lookupAppendixInPool)},
-  {CC"lookupMethodInPool",            CC"("METASPACE_CONSTANT_POOL"IB)"METHOD,                          FN_PTR(lookupMethodInPool)},
-  {CC"lookupTypeInPool",              CC"("METASPACE_CONSTANT_POOL"I)"TYPE,                             FN_PTR(lookupTypeInPool)},
-  {CC"lookupReferencedTypeInPool",    CC"("METASPACE_CONSTANT_POOL"IB)V",                               FN_PTR(lookupReferencedTypeInPool)},
-  {CC"lookupFieldInPool",             CC"("METASPACE_CONSTANT_POOL"IB)"FIELD,                           FN_PTR(lookupFieldInPool)},
+  {CC"lookupMethodInPool",            CC"("METASPACE_CONSTANT_POOL"IB[J)"METASPACE_METHOD,              FN_PTR(lookupMethodInPool)},
+  {CC"lookupTypeInPool",              CC"("METASPACE_CONSTANT_POOL"I[J)"METASPACE_KLASS,                FN_PTR(lookupTypeInPool)},
+  {CC"loadReferencedTypeInPool",      CC"("METASPACE_CONSTANT_POOL"IB)V",                               FN_PTR(loadReferencedTypeInPool)},
+  {CC"lookupFieldInPool",             CC"("METASPACE_CONSTANT_POOL"IB[J)Z",                             FN_PTR(lookupFieldInPool)},
   {CC"resolveMethod",                 CC"("HS_RESOLVED_TYPE STRING STRING")"METASPACE_METHOD,           FN_PTR(resolveMethod)},
   {CC"getClassInitializer",           CC"("HS_RESOLVED_TYPE")"METASPACE_METHOD,                         FN_PTR(getClassInitializer)},
   {CC"hasFinalizableSubclass",        CC"("HS_RESOLVED_TYPE")Z",                                        FN_PTR(hasFinalizableSubclass)},
diff -r 73f5ddd8414d -r 2f37b0e442fe src/share/vm/graal/graalVMToCompiler.cpp
--- a/src/share/vm/graal/graalVMToCompiler.cpp	Wed Mar 05 17:53:38 2014 +0100
+++ b/src/share/vm/graal/graalVMToCompiler.cpp	Wed Mar 05 19:07:29 2014 +0100
@@ -171,80 +171,3 @@
   JavaCalls::call_interface(&result, vmToCompilerKlass(), vmSymbols::compileTheWorld_name(), vmSymbols::void_method_signature(), &args, THREAD);
   check_pending_exception("Error while calling compileTheWorld");
 }
-
-oop VMToCompiler::createJavaField(Handle holder, Handle name, Handle type, int index, int flags, jboolean internal, TRAPS) {
-  assert(!holder.is_null(), "just checking");
-  assert(!name.is_null(), "just checking");
-  assert(!type.is_null(), "just checking");
-  JavaValue result(T_OBJECT);
-  JavaCallArguments args;
-  args.push_oop(instance());
-  args.push_oop(holder);
-  args.push_oop(name);
-  args.push_oop(type);
-  args.push_int(index);
-  args.push_int(flags);
-  args.push_int(internal);
-  JavaCalls::call_interface(&result, vmToCompilerKlass(), vmSymbols::createJavaField_name(), vmSymbols::createJavaField_signature(), &args, THREAD);
-  check_pending_exception("Error while calling createJavaField");
-  assert(result.get_type() == T_OBJECT, "just checking");
-  return (oop) result.get_jobject();
-}
-
-oop VMToCompiler::createUnresolvedJavaMethod(Handle name, Handle signature, Handle holder, TRAPS) {
-  assert(!name.is_null(), "just checking");
-  JavaValue result(T_OBJECT);
-  JavaCallArguments args;
-  args.push_oop(instance());
-  args.push_oop(name);
-  args.push_oop(signature);
-  args.push_oop(holder);
-  JavaCalls::call_interface(&result, vmToCompilerKlass(), vmSymbols::createUnresolvedJavaMethod_name(), vmSymbols::createUnresolvedJavaMethod_signature(), &args, THREAD);
-  check_pending_exception("Error while calling createUnresolvedJavaMethod");
-  return (oop) result.get_jobject();
-}
-
-oop VMToCompiler::createResolvedJavaMethod(Handle holder, Method* method, TRAPS) {
-  assert(!holder.is_null(), "just checking");
-  assert(method != NULL, "just checking");
-  JavaValue result(T_OBJECT);
-  JavaCallArguments args;
-  args.push_oop(instance());
-  args.push_oop(holder);
-  args.push_long((jlong) (address) method);
-  JavaCalls::call_interface(&result, vmToCompilerKlass(), vmSymbols::createResolvedJavaMethod_name(), vmSymbols::createResolvedJavaMethod_signature(), &args, THREAD);
-  check_pending_exception("Error while calling createResolvedJavaMethod");
-  assert(result.get_type() == T_OBJECT, "just checking");
-  return (oop) result.get_jobject();
-}
-
-oop VMToCompiler::createPrimitiveJavaType(int basic_type, TRAPS) {
-  JavaValue result(T_OBJECT);
-  JavaCallArguments args;
-  args.push_oop(instance());
-  args.push_int(basic_type);
-  JavaCalls::call_interface(&result, vmToCompilerKlass(), vmSymbols::createPrimitiveJavaType_name(), vmSymbols::createPrimitiveJavaType_signature(), &args, THREAD);
-  check_pending_exception("Error while calling createPrimitiveJavaType");
-  return (oop) result.get_jobject();
-}
-
-oop VMToCompiler::createUnresolvedJavaType(Handle name, TRAPS) {
-  assert(!name.is_null(), "just checking");
-  JavaValue result(T_OBJECT);
-  JavaCallArguments args;
-  args.push_oop(instance());
-  args.push_oop(name);
-  JavaCalls::call_interface(&result, vmToCompilerKlass(), vmSymbols::createUnresolvedJavaType_name(), vmSymbols::createUnresolvedJavaType_signature(), &args, THREAD);
-  check_pending_exception("Error while calling createUnresolvedJavaType");
-  return (oop) result.get_jobject();
-}
-
-oop VMToCompiler::createResolvedJavaType(Handle java_mirror, TRAPS) {
-  JavaValue result(T_OBJECT);
-  JavaCallArguments args;
-  args.push_oop(instance());
-  args.push_oop(java_mirror);
-  JavaCalls::call_interface(&result, vmToCompilerKlass(), vmSymbols::createResolvedJavaType_name(), vmSymbols::createResolvedJavaType_signature(), &args, THREAD);
-  check_pending_exception("Error while calling createResolvedJavaType");
-  return (oop) result.get_jobject();
-}
diff -r 73f5ddd8414d -r 2f37b0e442fe src/share/vm/graal/graalVMToCompiler.hpp
--- a/src/share/vm/graal/graalVMToCompiler.hpp	Wed Mar 05 17:53:38 2014 +0100
+++ b/src/share/vm/graal/graalVMToCompiler.hpp	Wed Mar 05 19:07:29 2014 +0100
@@ -74,24 +74,6 @@
 
   // public abstract void compileTheWorld();
   static void compileTheWorld();
-
-  // public abstract JavaField createJavaField(JavaType holder, String name, JavaType type, int flags, int offset);
-  static oop createJavaField(Handle holder, Handle name, Handle type, int index, int flags, jboolean internal, TRAPS);
-
-  // public abstract JavaMethod createUnresolvedJavaMethod(String name, String signature, JavaType holder);
-  static oop createUnresolvedJavaMethod(Handle name, Handle signature, Handle holder, TRAPS);
-
-  // public abstract JavaMethod createResolvedJavaMethod(JavaType holder, long metaspaceMethod);
-  static oop createResolvedJavaMethod(Handle holder, Method* method, TRAPS);
-
-  // public abstract JavaType createUnresolvedJavaType(String name);
-  static oop createUnresolvedJavaType(Handle name, TRAPS);
-
-  // public abstract ResolvedJavaType createResolvedJavaType(Class javaMirror);
-  static oop createResolvedJavaType(Handle java_mirror, TRAPS);
-
-  // public abstract JavaType createPrimitiveJavaType(int basicType);
-  static oop createPrimitiveJavaType(int basicType, TRAPS);
 };
 
 inline void check_pending_exception(const char* message, bool dump_core = false) {