truffle: src/share/vm/graal/graalVMEntries.cpp comparison

comparison src/share/vm/graal/graalVMEntries.cpp @ 3685:5c8fc9f05960

Merge

author	Lukas Stadler <lukas.stadler@jku.at>
date	Fri, 18 Nov 2011 13:34:10 +0100
parents	345c3bbf9c3c 8c46cdb684d4
children	7958ebb561b0

comparison

equal deleted inserted replaced

-:1976ebe361c2
+:5c8fc9f05960
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */
 #include "precompiled.hpp"
+#include "runtime/fieldDescriptor.hpp"
 #include "c1/c1_Runtime1.hpp"
 #include "ci/ciMethodData.hpp"
 #include "compiler/compileBroker.hpp"
 #include "graal/graalVMEntries.hpp"
 #include "graal/graalCompiler.hpp"
+#include "graal/graalEnv.hpp"
 #include "graal/graalJavaAccess.hpp"
 #include "graal/graalCodeInstaller.hpp"
 #include "graal/graalVMExits.hpp"
 #include "graal/graalVmIds.hpp"
 #include "memory/oopFactory.hpp"
 methodOop getMethodFromHotSpotMethod(jobject hotspot_method) {
 return getMethodFromHotSpotMethod(JNIHandles::resolve(hotspot_method));
 }
 methodOop getMethodFromHotSpotMethod(oop hotspot_method) {
-oop reflected = HotSpotMethodResolved::javaMirror(hotspot_method);
+return (methodOop)HotSpotMethodResolved::javaMirror(hotspot_method);
-assert(reflected != NULL, "NULL not expected");
-return (methodOop)reflected;
-// (tw) Cannot use reflection code, because then the compiler can dead lock with the user application (test using -Xcomp).
-/*
-// method is a handle to a java.lang.reflect.Method object
-oop mirror     = NULL;
-int slot       = 0;
-if (reflected->klass() == SystemDictionary::reflect_Constructor_klass()) {
-mirror = java_lang_reflect_Constructor::clazz(reflected);
-slot   = java_lang_reflect_Constructor::slot(reflected);
-} else {
-assert(reflected->klass() == SystemDictionary::reflect_Method_klass(), "wrong type");
-mirror = java_lang_reflect_Method::clazz(reflected);
-slot   = java_lang_reflect_Method::slot(reflected);
-}
-klassOop k     = java_lang_Class::as_klassOop(mirror);
-// Make sure class is initialized before handing id's out to methods
-//  assert(instanceKlass::cast(k)->is_initialized(), "only initialized classes expected");
-methodOop m = instanceKlass::cast(k)->method_with_idnum(slot);
-assert(m != NULL, "deleted method?");
-return m;*/
-}
-oop getReflectedMethod(methodOop method, TRAPS) {
-assert(method != NULL, "NULL not expected");
-if (!method->is_initializer() || method->is_static()) {
-return Reflection::new_method(method, true, true, CHECK_NULL);
-} else {
-return Reflection::new_constructor(method, CHECK_NULL);
-}
 }
 // public byte[] RiMethod_code(HotSpotResolvedMethod method);
 JNIEXPORT jbyteArray JNICALL Java_com_oracle_graal_hotspot_VMEntries_RiMethod_1code(JNIEnv *env, jobject, jobject hotspot_method) {
 TRACE_graal_3("VMEntries::RiMethod_code");
 // public RiExceptionHandler[] RiMethod_exceptionHandlers(long vmId);
 JNIEXPORT jobjectArray JNICALL Java_com_oracle_graal_hotspot_VMEntries_RiMethod_1exceptionHandlers(JNIEnv *, jobject, jobject hotspot_method) {
 TRACE_graal_3("VMEntries::RiMethod_exceptionHandlers");
 VM_ENTRY_MARK
+ResourceMark rm;
 methodHandle method = getMethodFromHotSpotMethod(hotspot_method);
 typeArrayHandle handlers = method->exception_table();
 int handler_count = handlers.is_null() ? 0 : handlers->length() / 4;
 instanceKlass::cast(HotSpotExceptionHandler::klass())->initialize(CHECK_NULL);
 if (catch_class_index == 0) {
 HotSpotExceptionHandler::set_catchClass(entry, NULL);
 } else {
 constantPoolOop cp = instanceKlass::cast(method->method_holder())->constants();
-ciInstanceKlass* loading_klass = (ciInstanceKlass *) CURRENT_ENV->get_object(method->method_holder());
+KlassHandle loading_klass = method->method_holder();
-bool is_accessible = false;
+Handle catch_class = GraalCompiler::get_RiType(cp, catch_class_index, loading_klass, CHECK_NULL);
-ciKlass *klass = CURRENT_ENV->get_klass_by_index(cp, catch_class_index, is_accessible, loading_klass);
+HotSpotExceptionHandler::set_catchClass(entry, catch_class());
-oop catch_class = GraalCompiler::get_RiType(klass, method->method_holder(), CHECK_NULL);
-HotSpotExceptionHandler::set_catchClass(entry, catch_class);
 }
 array->obj_at_put(i, entry());
 }
 return (jobjectArray) JNIHandles::make_local(array());
 oop reflection_method = JNIHandles::resolve(reflection_method_handle);
 oop reflection_holder = java_lang_reflect_Method::clazz(reflection_method);
 int slot = java_lang_reflect_Method::slot(reflection_method);
 klassOop holder = java_lang_Class::as_klassOop(reflection_holder);
 methodOop method = instanceKlass::cast(holder)->method_with_idnum(slot);
-oop ret = GraalCompiler::createHotSpotMethodResolved(method, CHECK_NULL);
+Handle ret = GraalCompiler::createHotSpotMethodResolved(method, CHECK_NULL);
-return JNIHandles::make_local(THREAD, ret);
+return JNIHandles::make_local(THREAD, ret());
 }
 // public boolean RiMethod_uniqueConcreteMethod(long vmId);
 JNIEXPORT jobject JNICALL Java_com_oracle_graal_hotspot_VMEntries_RiMethod_1uniqueConcreteMethod(JNIEnv *, jobject, jobject hotspot_method) {
 TRACE_graal_3("VMEntries::RiMethod_uniqueConcreteMethod");
 VM_ENTRY_MARK;
-methodOop method = getMethodFromHotSpotMethod(hotspot_method);
+methodHandle method = getMethodFromHotSpotMethod(hotspot_method);
-klassOop holder = method->method_holder();
+KlassHandle holder = method->method_holder();
-if (holder->klass_part()->is_interface()) {
+if (holder->is_interface()) {
 // Cannot trust interfaces. Because of:
 // interface I { void foo(); }
 // class A { public void foo() {} }
 // class B extends A implements I { }
 // class C extends B { public void foo() { } }
 // class D extends B { }
 // Would lead to identify C.foo() as the unique concrete method for I.foo() without seeing A.foo().
 return false;
 }
-methodOop unique_concrete;
+methodHandle unique_concrete;
 {
 ResourceMark rm;
 MutexLocker locker(Compile_lock);
-unique_concrete = Dependencies::find_unique_concrete_method(holder, method);
+unique_concrete = Dependencies::find_unique_concrete_method(holder(), method());
 }
-if (unique_concrete == NULL) {
+if (unique_concrete.is_null()) {
 return NULL;
 } else {
-oop method_resolved = GraalCompiler::createHotSpotMethodResolved(unique_concrete, CHECK_NULL);
+Handle method_resolved = GraalCompiler::createHotSpotMethodResolved(unique_concrete, CHECK_NULL);
-return JNIHandles::make_local(THREAD, method_resolved);
+return JNIHandles::make_local(THREAD, method_resolved());
 }
 }
 // public native int RiMethod_invocationCount(long vmId);
 JNIEXPORT jint JNICALL Java_com_oracle_graal_hotspot_VMEntries_RiMethod_1invocationCount(JNIEnv *, jobject, jobject hotspot_method) {
 TRACE_graal_3("VMEntries::RiMethod_invocationCount");
-methodOop method = getMethodFromHotSpotMethod(hotspot_method);
+return getMethodFromHotSpotMethod(hotspot_method)->invocation_count();
-return method->invocation_count();
 }
 // public native int RiMethod_exceptionProbability(long vmId, int bci);
 JNIEXPORT jint JNICALL Java_com_oracle_graal_hotspot_VMEntries_RiMethod_2exceptionProbability(JNIEnv *, jobject, jobject hotspot_method, jint bci) {
 TRACE_graal_3("VMEntries::RiMethod_exceptionProbability");
-{
+VM_ENTRY_MARK;
-VM_ENTRY_MARK;
+ResourceMark rm;
-methodOop method = getMethodFromHotSpotMethod(hotspot_method);
+methodHandle method = getMethodFromHotSpotMethod(hotspot_method);
-methodDataOop method_data = method->method_data();
+methodDataHandle method_data = method->method_data();
 if (method_data == NULL || !method_data->is_mature()) {
 return -1;
 }
 ProfileData* data = method_data->bci_to_data(bci);
 if (data == NULL) {
 return 0;
 }
 uint trap = Deoptimization::trap_state_is_recompiled(data->trap_state())? 1: 0;
 if (trap > 0) {
 return 100;
 } else {
 return trap;
-}
 }
 }
 // ------------------------------------------------------------------
 // Adjust a CounterData count to be commensurate with
 }
 // public native RiTypeProfile RiMethod_typeProfile(long vmId, int bci);
 JNIEXPORT jobject JNICALL Java_com_oracle_graal_hotspot_VMEntries_RiMethod_2typeProfile(JNIEnv *, jobject, jobject hotspot_method, jint bci) {
 TRACE_graal_3("VMEntries::RiMethod_typeProfile");
+VM_ENTRY_MARK;
 Handle obj;
-{
-VM_ENTRY_MARK;
+methodHandle method = getMethodFromHotSpotMethod(hotspot_method);
-methodHandle method = getMethodFromHotSpotMethod(hotspot_method);
+methodDataHandle method_data = method->method_data();
-if (strstr(method->name_and_sig_as_C_string(), "factor") != NULL) {
+if (method_data == NULL || !method_data->is_mature()) {
-//      tty->print_cr("here");
+return NULL;
 }
-if (bci == 123) {
+ResourceMark rm;
-//      tty->print_cr("here2");
+ProfileData* data = method_data->bci_to_data(bci);
-}
+if (data != NULL && data->is_ReceiverTypeData()) {
-methodDataHandle method_data = method->method_data();
+ReceiverTypeData* recv = data->as_ReceiverTypeData();
-if (method_data == NULL || !method_data->is_mature()) {
+GrowableArray<KlassHandle> receivers;
-return NULL;
+GrowableArray<int> counts;
-}
+// determine morphism
-ProfileData* data = method_data->bci_to_data(bci);
+uint total_count = 0;
-if (data != NULL && data->is_ReceiverTypeData()) {
+for (uint i = 0; i < recv->row_limit(); i++) {
-ReceiverTypeData* recv = data->as_ReceiverTypeData();
+klassOop receiver = recv->receiver(i);
-// determine morphism
+if (receiver == NULL)  continue;
-int morphism = 0;
+uint count = recv->receiver_count(i);
-uint total_count = 0;
+total_count += count;
-for (uint i = 0; i < recv->row_limit(); i++) {
+receivers.append(receiver);
-klassOop receiver = recv->receiver(i);
+counts.append(count);
-if (receiver == NULL)  continue;
+}
-morphism++;
-total_count += recv->receiver_count(i);
+instanceKlass::cast(RiTypeProfile::klass())->initialize(CHECK_NULL);
+obj = instanceKlass::cast(RiTypeProfile::klass())->allocate_instance(CHECK_NULL);
+assert(obj() != NULL, "must succeed in allocating instance");
+int count = MAX2(total_count, recv->count());
+RiTypeProfile::set_count(obj, scale_count(method_data(), count));
+RiTypeProfile::set_morphism(obj, receivers.length());
+if (receivers.length() > 0) {
+typeArrayHandle probabilities = oopFactory::new_typeArray(T_FLOAT, receivers.length(), CHECK_NULL);
+objArrayHandle types = oopFactory::new_objArray(SystemDictionary::RiType_klass(), receivers.length(), CHECK_NULL);
+for (int i = 0; i < receivers.length(); i++) {
+KlassHandle receiver = receivers.at(i);
+float prob = counts.at(i) / (float) total_count;
+Handle type = GraalCompiler::get_RiType(receiver, CHECK_NULL);
+probabilities->float_at_put(i, prob);
+types->obj_at_put(i, type());
 }
-instanceKlass::cast(RiTypeProfile::klass())->initialize(CHECK_NULL);
+RiTypeProfile::set_probabilities(obj, probabilities());
-obj = instanceKlass::cast(RiTypeProfile::klass())->allocate_instance(CHECK_NULL);
+RiTypeProfile::set_types(obj, types());
-assert(obj() != NULL, "must succeed in allocating instance");
+} else {
+RiTypeProfile::set_probabilities(obj, NULL);
-int count = MAX2(total_count, recv->count());
+RiTypeProfile::set_types(obj, NULL);
-RiTypeProfile::set_count(obj, scale_count(method_data(), count));
+}
-RiTypeProfile::set_morphism(obj, morphism);
+}
-if (morphism > 0) {
-typeArrayHandle probabilities = oopFactory::new_typeArray(T_FLOAT, morphism, CHECK_NULL);
-objArrayHandle types = oopFactory::new_objArray(SystemDictionary::RiType_klass(), morphism, CHECK_NULL);
-int pos = 0;
-for (uint i = 0; i < recv->row_limit(); i++) {
-KlassHandle receiver = recv->receiver(i);
-if (receiver.is_null())  continue;
-float prob = recv->receiver_count(i) / (float) total_count;
-oop type = GraalCompiler::get_RiType(receiver, KlassHandle(), CHECK_NULL);
-probabilities->float_at_put(pos, prob);
-types->obj_at_put(pos, type);
-pos++;
-}
-RiTypeProfile::set_probabilities(obj, probabilities());
-RiTypeProfile::set_types(obj, types());
-} else {
-RiTypeProfile::set_probabilities(obj, NULL);
-RiTypeProfile::set_types(obj, NULL);
-}
-}
-}
 return JNIHandles::make_local(obj());
 }
 JNIEXPORT jdouble JNICALL Java_com_oracle_graal_hotspot_VMEntries_RiMethod_2branchProbability(JNIEnv *, jobject, jobject hotspot_method, jint bci) {
 TRACE_graal_3("VMEntries::RiMethod_typeProfile");
-ciMethodData* method_data;
+ResourceMark rm;
-ciMethod* cimethod;
+methodHandle method = getMethodFromHotSpotMethod(hotspot_method);
-{
+methodDataHandle method_data = method->method_data();
-VM_ENTRY_MARK;
-assert(hotspot_method != NULL, "must not be null");
-methodOop method = getMethodFromHotSpotMethod(hotspot_method);
-assert(method != NULL, "method not found");
-if (CURRENT_ENV == NULL) {
-return -1;
-}
-assert(CURRENT_ENV != NULL, "current environment must be present");
-cimethod = (ciMethod*)CURRENT_ENV->get_object(method);
-}
-assert(cimethod != NULL, "cimethod not found");
-method_data = cimethod->method_data();
-jfloat probability = -1;
 if (method_data == NULL || !method_data->is_mature()) return -1;
+method_data->bci_to_data(bci);
-ciProfileData* data = method_data->bci_to_data(bci);
+ProfileData* data = method_data->bci_to_data(bci);
 if (data == NULL || !data->is_JumpData())  return -1;
 // get taken and not taken values
 int     taken = data->as_JumpData()->taken();
 int not_taken = 0;
 }
 }
 JNIEXPORT jobject JNICALL Java_com_oracle_graal_hotspot_VMEntries_RiMethod_2switchProbability(JNIEnv *, jobject, jobject hotspot_method, jint bci) {
 TRACE_graal_3("VMEntries::RiMethod_typeProfile");
-ciMethodData* method_data;
+VM_ENTRY_MARK;
-ciMethod* cimethod;
+ResourceMark rm;
-{
+methodHandle method = getMethodFromHotSpotMethod(hotspot_method);
-VM_ENTRY_MARK;
+methodDataHandle method_data = method->method_data();
-methodOop method = getMethodFromHotSpotMethod(hotspot_method);
-cimethod = (ciMethod*)CURRENT_ENV->get_object(method);
-}
-method_data = cimethod->method_data();
-jfloat probability = -1;
 if (method_data == NULL || !method_data->is_mature()) return NULL;
-ciProfileData* data = method_data->bci_to_data(bci);
+ProfileData* data = method_data->bci_to_data(bci);
 if (data == NULL || !data->is_MultiBranchData())  return NULL;
 MultiBranchData* branch_data = data->as_MultiBranchData();
 long sum = 0;
 // Give up if too few (or too many, in which case the sum will overflow) counts to be meaningful.
 // We also check that individual counters are positive first, otherwise the sum can become positive.
 if (sum < 10 * (cases + 3)) return NULL;
-{
+typeArrayOop probability = oopFactory::new_typeArray(T_DOUBLE, cases + 1, CHECK_NULL);
-VM_ENTRY_MARK;
+for (int i = 0; i < cases + 1; i++) {
-typeArrayOop probability = oopFactory::new_typeArray(T_DOUBLE, cases + 1, CHECK_NULL);
+probability->double_at_put(i, counts->at(i) / (double) sum);
-for (int i = 0; i < cases + 1; i++) {
+}
-probability->double_at_put(i, counts->at(i) / (double) sum);
+return JNIHandles::make_local(probability);
-}
-return JNIHandles::make_local(probability);
-}
 }
 // public native boolean RiMethod_hasCompiledCode(HotSpotMethodResolved method);
 JNIEXPORT jboolean JNICALL Java_com_oracle_graal_hotspot_VMEntries_RiMethod_1hasCompiledCode(JNIEnv *, jobject, jobject hotspot_method) {
 TRACE_graal_3("VMEntries::RiMethod_hasCompiledCode");
-methodOop method = getMethodFromHotSpotMethod(hotspot_method);
+return getMethodFromHotSpotMethod(hotspot_method)->has_compiled_code();
-return method->has_compiled_code();
 }
 // public RiType RiSignature_lookupType(String returnType, HotSpotTypeResolved accessingClass);
 JNIEXPORT jobject JNICALL Java_com_oracle_graal_hotspot_VMEntries_RiSignature_1lookupType(JNIEnv *env, jobject, jstring jname, jobject accessingClass) {
 TRACE_graal_3("VMEntries::RiSignature_lookupType");
 VM_ENTRY_MARK;
+ResourceMark rm;
 Symbol* nameSymbol = VmIds::toSymbol(jname);
 Handle name = JNIHandles::resolve(jname);
 oop result;
 CLEAR_PENDING_EXCEPTION;
 resolved_type = NULL;
 }
 }
 if (resolved_type != NULL) {
-result = GraalCompiler::createHotSpotTypeResolved(resolved_type, name, CHECK_NULL);
+Handle type = GraalCompiler::createHotSpotTypeResolved(resolved_type, name, CHECK_NULL);
+result = type();
 } else {
-result = VMExits::createRiTypeUnresolved(name, THREAD);
+Handle type = VMExits::createRiTypeUnresolved(name, THREAD);
+result = type();
 }
 }
 return JNIHandles::make_local(THREAD, result);
 }
 return NULL;
 }
 }
 result = VMExits::createCiConstantObject(string, CHECK_0);
 } else if (tag.is_klass() || tag.is_unresolved_klass()) {
-bool ignore;
+Handle type = GraalCompiler::get_RiType(cp, index, cp->pool_holder(), CHECK_NULL);
-ciInstanceKlass* accessor = (ciInstanceKlass*) ciEnv::current()->get_object(cp->pool_holder());
+result = type();
-ciKlass* klass = ciEnv::current()->get_klass_by_index(cp, index, ignore, accessor);
-result = GraalCompiler::get_RiType(klass, cp->pool_holder(), CHECK_NULL);
 } else if (tag.is_object()) {
 oop obj = cp->object_at(index);
 assert(obj->is_instance(), "must be an instance");
 result = VMExits::createCiConstantObject(obj, CHECK_NULL);
 } else {
 // public RiMethod RiConstantPool_lookupMethod(long vmId, int cpi, byte byteCode);
 JNIEXPORT jobject JNICALL Java_com_oracle_graal_hotspot_VMEntries_RiConstantPool_1lookupMethod(JNIEnv *env, jobject, jobject type, jint index, jbyte byteCode) {
 TRACE_graal_3("VMEntries::RiConstantPool_lookupMethod");
 VM_ENTRY_MARK;
 index = GraalCompiler::to_cp_index_u2(index);
-constantPoolOop cp = instanceKlass::cast(java_lang_Class::as_klassOop(HotSpotTypeResolved::javaMirror(type)))->constants();
+constantPoolHandle cp = instanceKlass::cast(java_lang_Class::as_klassOop(HotSpotTypeResolved::javaMirror(type)))->constants();
 Bytecodes::Code bc = (Bytecodes::Code) (((int) byteCode) & 0xFF);
-ciInstanceKlass* loading_klass = (ciInstanceKlass *) CURRENT_ENV->get_object(cp->pool_holder());
+methodHandle method = GraalEnv::get_method_by_index(cp, index, bc, cp->pool_holder());
-ciMethod *cimethod = CURRENT_ENV->get_method_by_index(cp, index, bc, loading_klass);
+if (!method.is_null()) {
-if (cimethod->is_loaded()) {
+Handle ret = GraalCompiler::createHotSpotMethodResolved(method, CHECK_NULL);
-methodOop method = (methodOop) cimethod->get_oop();
+return JNIHandles::make_local(THREAD, ret());
-oop ret = GraalCompiler::createHotSpotMethodResolved(method, CHECK_NULL);
-return JNIHandles::make_local(THREAD, ret);
 } else {
-Handle name = VmIds::toString<Handle>(cimethod->name()->get_symbol(), CHECK_NULL);
+// Get the method's name and signature.
-Handle signature = VmIds::toString<Handle>(cimethod->signature()->as_symbol()->get_symbol(), CHECK_NULL);
+Handle name = VmIds::toString<Handle>(cp->name_ref_at(index), CHECK_NULL);
-Handle holder = GraalCompiler::get_RiType(cimethod->holder(), cp->klass(), THREAD);
+Handle signature  = VmIds::toString<Handle>(cp->signature_ref_at(index), CHECK_NULL);
-return JNIHandles::make_local(THREAD, VMExits::createRiMethodUnresolved(name, signature, holder, THREAD));
+int holder_index = cp->klass_ref_index_at(index);
+Handle type = GraalCompiler::get_RiType(cp, holder_index, cp->pool_holder(), CHECK_NULL);
+return JNIHandles::make_local(THREAD, VMExits::createRiMethodUnresolved(name, signature, type, THREAD));
 }
 }
 // public RiType RiConstantPool_lookupType(long vmId, int cpi);
 JNIEXPORT jobject JNICALL Java_com_oracle_graal_hotspot_VMEntries_RiConstantPool_1lookupType(JNIEnv *env, jobject, jobject type, jint index) {
 TRACE_graal_3("VMEntries::RiConstantPool_lookupType");
 VM_ENTRY_MARK;
 constantPoolOop cp = instanceKlass::cast(java_lang_Class::as_klassOop(HotSpotTypeResolved::javaMirror(type)))->constants();
+Handle result = GraalCompiler::get_RiType(cp, index, cp->pool_holder(), CHECK_NULL);
-ciInstanceKlass* loading_klass = (ciInstanceKlass *) CURRENT_ENV->get_object(cp->pool_holder());
+return JNIHandles::make_local(THREAD, result());
-bool is_accessible = false;
-ciKlass *klass = CURRENT_ENV->get_klass_by_index(cp, index, is_accessible, loading_klass);
-return JNIHandles::make_local(THREAD, GraalCompiler::get_RiType(klass, cp->klass(), THREAD));
 }
 // public void RiConstantPool_loadReferencedType(long vmId, int cpi);
 JNIEXPORT void JNICALL Java_com_oracle_graal_hotspot_VMEntries_RiConstantPool_1loadReferencedType(JNIEnv *env, jobject, jobject type, jint index, jbyte op) {
 TRACE_graal_3("VMEntries::RiConstantPool_lookupType");
 }
 }
 }
 // public RiField RiConstantPool_lookupField(long vmId, int cpi);
-JNIEXPORT jobject JNICALL Java_com_oracle_graal_hotspot_VMEntries_RiConstantPool_1lookupField(JNIEnv *env, jobject, jobject type, jint index, jbyte byteCode) {
+JNIEXPORT jobject JNICALL Java_com_oracle_graal_hotspot_VMEntries_RiConstantPool_1lookupField(JNIEnv *env, jobject, jobject constantPoolHolder, jint index, jbyte byteCode) {
 TRACE_graal_3("VMEntries::RiConstantPool_lookupField");
 VM_ENTRY_MARK;
+ResourceMark rm;
 index = GraalCompiler::to_cp_index_u2(index);
-constantPoolOop cp = instanceKlass::cast(java_lang_Class::as_klassOop(HotSpotTypeResolved::javaMirror(type)))->constants();
+constantPoolHandle cp = instanceKlass::cast(java_lang_Class::as_klassOop(HotSpotTypeResolved::javaMirror(constantPoolHolder)))->constants();
-ciInstanceKlass* loading_klass = (ciInstanceKlass *) CURRENT_ENV->get_object(cp->pool_holder());
+int nt_index = cp->name_and_type_ref_index_at(index);
-ciField *field = CURRENT_ENV->get_field_by_index(loading_klass, index);
+int sig_index = cp->signature_ref_index_at(nt_index);
+Symbol* signature = cp->symbol_at(sig_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_RiType(cp, holder_index, cp->pool_holder(), CHECK_NULL);
+instanceKlassHandle holder_klass;
 Bytecodes::Code code = (Bytecodes::Code)(((int) byteCode) & 0xFF);
-Handle field_handle = GraalCompiler::get_RiField(field, loading_klass, cp->pool_holder(), code, THREAD);
+int offset = -1;
-bool is_constant = field->is_constant();
+AccessFlags flags;
-if (is_constant && field->is_static()) {
+BasicType basic_type;
-ciConstant constant = field->constant_value();
+if (holder->klass() == SystemDictionary::HotSpotTypeResolved_klass()) {
-oop constant_object = NULL;
+FieldAccessInfo result;
-switch (constant.basic_type()) {
+LinkResolver::resolve_field(result, cp, index,
-case T_OBJECT:
+Bytecodes::java_code(code),
-case T_ARRAY:
+true, false, Thread::current());
-{
+if (HAS_PENDING_EXCEPTION) {
-ciObject* obj = constant.as_object();
+CLEAR_PENDING_EXCEPTION;
-if (obj->is_null_object()) {
+} else {
-constant_object = VMExits::createCiConstantObject(NULL, CHECK_0);
+offset = result.field_offset();
-} else if (obj->can_be_constant()) {
+flags = result.access_flags();
-constant_object = VMExits::createCiConstantObject(constant.as_object()->get_oop(), CHECK_0);
+holder_klass = result.klass()->as_klassOop();
-}
+basic_type = result.field_type();
-}
+holder = GraalCompiler::get_RiType(holder_klass, CHECK_NULL);
-break;
+}
-case T_DOUBLE:
+}
-constant_object = VMExits::createCiConstantDouble(constant.as_double(), CHECK_0);
-break;
+Handle type = GraalCompiler::get_RiTypeFromSignature(cp, sig_index, cp->pool_holder(), CHECK_NULL);
-case T_FLOAT:
+Handle field_handle = GraalCompiler::get_RiField(offset, flags.as_int(), name, holder, type, code, THREAD);
-constant_object = VMExits::createCiConstantFloat(constant.as_float(), CHECK_0);
-break;
+oop constant_object = NULL;
-case T_LONG:
+// Check to see if the field is constant.
-constant_object = VMExits::createCiConstant(CiKind::Long(), constant.as_long(), CHECK_0);
+if (!holder_klass.is_null() && holder_klass->is_initialized() && flags.is_final() && flags.is_static()) {
-break;
+// This field just may be constant.  The only cases where it will
-case T_INT:
+// not be constant are:
-constant_object = VMExits::createCiConstant(CiKind::Int(), constant.as_int(), CHECK_0);
+//
-break;
+// 1. The field holds a non-perm-space oop.  The field is, strictly
-case T_SHORT:
+//    speaking, constant but we cannot embed non-perm-space oops into
-constant_object = VMExits::createCiConstant(CiKind::Short(), constant.as_int(), CHECK_0);
+//    generated code.  For the time being we need to consider the
-break;
+//    field to be not constant.
-case T_CHAR:
+// 2. The field is a *special* static&final field whose value
-constant_object = VMExits::createCiConstant(CiKind::Char(), constant.as_int(), CHECK_0);
+//    may change.  The three examples are java.lang.System.in,
-break;
+//    java.lang.System.out, and java.lang.System.err.
-case T_BYTE:
-constant_object = VMExits::createCiConstant(CiKind::Byte(), constant.as_int(), CHECK_0);
+bool ok = true;
-break;
+assert( SystemDictionary::System_klass() != NULL, "Check once per vm");
-case T_BOOLEAN:
+if( holder_klass->as_klassOop() == SystemDictionary::System_klass() ) {
-constant_object = VMExits::createCiConstant(CiKind::Boolean(), constant.as_int(), CHECK_0);
+// Check offsets for case 2: System.in, System.out, or System.err
-break;
+if( offset == java_lang_System::in_offset_in_bytes()  ||
-default:
+offset == java_lang_System::out_offset_in_bytes() ||
-constant.print();
+offset == java_lang_System::err_offset_in_bytes() ) {
-fatal("Unhandled constant");
+ok = false;
-break;
+}
 }
-if (constant_object != NULL) {
-HotSpotField::set_constant(field_handle, constant_object);
+if (ok) {
-}
+Handle mirror = holder_klass->java_mirror();
+switch(basic_type) {
+case T_OBJECT:
+case T_ARRAY:
+constant_object = VMExits::createCiConstantObject(mirror->obj_field(offset), CHECK_0);
+break;
+case T_DOUBLE:
+constant_object = VMExits::createCiConstantDouble(mirror->double_field(offset), CHECK_0);
+break;
+case T_FLOAT:
+constant_object = VMExits::createCiConstantFloat(mirror->float_field(offset), CHECK_0);
+break;
+case T_LONG:
+constant_object = VMExits::createCiConstant(CiKind::Long(), mirror->long_field(offset), CHECK_0);
+break;
+case T_INT:
+constant_object = VMExits::createCiConstant(CiKind::Int(), mirror->int_field(offset), CHECK_0);
+break;
+case T_SHORT:
+constant_object = VMExits::createCiConstant(CiKind::Short(), mirror->short_field(offset), CHECK_0);
+break;
+case T_CHAR:
+constant_object = VMExits::createCiConstant(CiKind::Char(), mirror->char_field(offset), CHECK_0);
+break;
+case T_BYTE:
+constant_object = VMExits::createCiConstant(CiKind::Byte(), mirror->byte_field(offset), CHECK_0);
+break;
+case T_BOOLEAN:
+constant_object = VMExits::createCiConstant(CiKind::Boolean(), mirror->bool_field(offset), CHECK_0);
+break;
+default:
+fatal("Unhandled constant");
+break;
+}
+}
+}
+if (constant_object != NULL) {
+HotSpotField::set_constant(field_handle, constant_object);
 }
 return JNIHandles::make_local(THREAD, field_handle());
 }
 // public RiMethod RiType_resolveMethodImpl(HotSpotTypeResolved klass, String name, String signature);
 assert(JNIHandles::resolve(resolved_type) != NULL, "");
 klassOop klass = java_lang_Class::as_klassOop(HotSpotTypeResolved::javaMirror(resolved_type));
 Symbol* name_symbol = VmIds::toSymbol(name);
 Symbol* signature_symbol = VmIds::toSymbol(signature);
-methodOop method = klass->klass_part()->lookup_method(name_symbol, signature_symbol);
+methodHandle method = klass->klass_part()->lookup_method(name_symbol, signature_symbol);
 if (method == NULL) {
 if (TraceGraal >= 3) {
 ResourceMark rm;
 tty->print_cr("Could not resolve method %s %s on klass %s", name_symbol->as_C_string(), signature_symbol->as_C_string(), klass->klass_part()->name()->as_C_string());
 }
 return NULL;
 }
-oop ret = GraalCompiler::createHotSpotMethodResolved(method, CHECK_NULL);
+Handle ret = GraalCompiler::createHotSpotMethodResolved(method, CHECK_NULL);
-return JNIHandles::make_local(THREAD, ret);
+return JNIHandles::make_local(THREAD, ret());
 }
 // public boolean RiType_isSubtypeOf(HotSpotTypeResolved klass, RiType other);
 JNIEXPORT jboolean JNICALL Java_com_oracle_graal_hotspot_VMEntries_RiType_2isSubtypeOf(JNIEnv *, jobject, jobject klass, jobject jother) {
 TRACE_graal_3("VMEntries::RiType_isSubtypeOf");
 }
 // public RiType RiType_componentType(HotSpotResolvedType klass);
 JNIEXPORT jobject JNICALL Java_com_oracle_graal_hotspot_VMEntries_RiType_1componentType(JNIEnv *, jobject, jobject klass) {
 TRACE_graal_3("VMEntries::RiType_componentType");
-ciArrayKlass* array_klass;
+VM_ENTRY_MARK;
-{
+KlassHandle array_klass = java_lang_Class::as_klassOop(HotSpotTypeResolved::javaMirror(klass));
-VM_ENTRY_MARK;
+assert(array_klass->oop_is_objArray(), "just checking");
-assert(JNIHandles::resolve(klass) != NULL, "");
+klassOop element_type = objArrayKlass::cast(array_klass())->element_klass();
-array_klass = (ciArrayKlass *) CURRENT_ENV->get_object(java_lang_Class::as_klassOop(HotSpotTypeResolved::javaMirror(klass)));
-}
-ciType* element_type = array_klass->element_type();
-VM_ENTRY_MARK;
 assert(JNIHandles::resolve(klass) != NULL, "");
-return JNIHandles::make_local(GraalCompiler::get_RiType(element_type, java_lang_Class::as_klassOop(HotSpotTypeResolved::javaMirror(klass)), THREAD));
+return JNIHandles::make_local(GraalCompiler::get_RiType(element_type, THREAD)());
 }
 // public RiType RiType_superType(HotSpotResolvedType klass);
 JNIEXPORT jobject JNICALL Java_com_oracle_graal_hotspot_VMEntries_RiType_1superType(JNIEnv *, jobject, jobject klass) {
 TRACE_graal_3("VMEntries::RiType_superType");
 VM_ENTRY_MARK;
 KlassHandle klass_handle(java_lang_Class::as_klassOop(HotSpotTypeResolved::javaMirror(klass)));
-ciInstanceKlass* k = NULL;
+klassOop k;
 if (klass_handle->oop_is_array()) {
-k = (ciInstanceKlass *) CURRENT_ENV->get_object(SystemDictionary::Object_klass());
+k = SystemDictionary::Object_klass();
 } else {
 guarantee(klass_handle->oop_is_instance(), "must be instance klass");
-k = (ciInstanceKlass *) CURRENT_ENV->get_object(klass_handle());
+k = klass_handle->super();
-k = k->super();
 }
 if (k != NULL) {
-return JNIHandles::make_local(GraalCompiler::get_RiType(k, klass_handle, THREAD));
+return JNIHandles::make_local(GraalCompiler::get_RiType(k, THREAD)());
 } else {
 return NULL;
 }
 }
 // public RiType RiType_uniqueConcreteSubtype(HotSpotResolvedType klass);
 JNIEXPORT jobject JNICALL Java_com_oracle_graal_hotspot_VMEntries_RiType_1uniqueConcreteSubtype(JNIEnv *, jobject, jobject klass) {
 TRACE_graal_3("VMEntries::RiType_uniqueConcreteSubtype");
-Thread* THREAD = Thread::current();
+VM_ENTRY_MARK;
 KlassHandle klass_handle(java_lang_Class::as_klassOop(HotSpotTypeResolved::javaMirror(klass)));
-ciInstanceKlass* k = NULL;
+Klass *up_cast = klass_handle->up_cast_abstract();
-{
+if (up_cast->is_leaf_class()) {
-VM_ENTRY_MARK;
+return JNIHandles::make_local(GraalCompiler::get_RiType(up_cast, THREAD)());
-k = (ciInstanceKlass *) CURRENT_ENV->get_object(klass_handle());
+}
-}
-if (k->is_abstract()) {
-ciInstanceKlass* sub = k->unique_concrete_subklass();
-if (sub != NULL && sub->is_leaf_type()) {
-VM_ENTRY_MARK;
-return JNIHandles::make_local(GraalCompiler::get_RiType(sub, klass_handle, THREAD));
-}
-} else if (k->is_leaf_type()) {
-assert(!k->is_interface(), "");
-return klass;
-}
 return NULL;
 }
 // public bool RiType_isInitialized(HotSpotResolvedType klass);
 JNIEXPORT jboolean JNICALL Java_com_oracle_graal_hotspot_VMEntries_RiType_1isInitialized(JNIEnv *, jobject, jobject hotspot_klass) {
 VM_ENTRY_MARK;
 KlassHandle klass_handle(java_lang_Class::as_klassOop(HotSpotTypeResolved::javaMirror(klass)));
 KlassHandle array = klass_handle->array_klass(THREAD);
 Handle name = VmIds::toString<Handle>(array->name(), CHECK_NULL);
-return JNIHandles::make_local(THREAD, GraalCompiler::createHotSpotTypeResolved(array, name, THREAD));
+return JNIHandles::make_local(THREAD, GraalCompiler::createHotSpotTypeResolved(array, name, THREAD)());
 }
 // public RiField[] RiType_fields(HotSpotTypeResolved klass);
 JNIEXPORT jobject JNICALL Java_com_oracle_graal_hotspot_VMEntries_RiType_1fields(JNIEnv *, jobject, jobject klass) {
 TRACE_graal_3("VMEntries::RiType_fields");
-KlassHandle klass_handle;
+VM_ENTRY_MARK;
-ciInstanceKlass* instance_klass;
+ResourceMark rm;
-objArrayHandle fieldsArray;
-HandleMark hm;
+instanceKlassHandle k = java_lang_Class::as_klassOop(HotSpotTypeResolved::javaMirror(klass));
-{
+class MyFieldClosure : public FieldClosure {
-VM_ENTRY_MARK;
+public:
-klass_handle = java_lang_Class::as_klassOop(HotSpotTypeResolved::javaMirror(klass));
+instanceKlassHandle _holder;
-instance_klass = (ciInstanceKlass *) CURRENT_ENV->get_object(klass_handle());
+Handle _resolved_type_holder;
-}
+GrowableArray<Handle> _field_array;
-GrowableArray<ciField*>* fields = instance_klass->non_static_fields();
-{
+MyFieldClosure(instanceKlassHandle& holder, Handle resolved_type_holder) : _holder(holder), _resolved_type_holder(resolved_type_holder) { }
-VM_ENTRY_MARK;
-int count = 0;
+virtual void do_field(fieldDescriptor* fd) {
-for (int i = 0; i < fields->length(); i++) {
+if (!Thread::current()->has_pending_exception()) {
-ciField* field = fields->at(i);
+if (fd->field_holder() == _holder()) {
-if (field->holder() == instance_klass) {
+Handle type = GraalCompiler::get_RiTypeFromSignature(fd->constants(), fd->signature_index(), fd->field_holder(), Thread::current());
-count++;
+Handle field = VMExits::createRiField(_resolved_type_holder, VmIds::toString<Handle>(fd->name(), Thread::current()), type, fd->offset(), fd->access_flags().as_int(), Thread::current());
+_field_array.append(field());
+}
 }
 }
+};
-fieldsArray = oopFactory::new_objArray(SystemDictionary::RiField_klass(), count, CHECK_NULL);
+MyFieldClosure closure(k, JNIHandles::resolve(klass));
-int z = 0;
+k->do_nonstatic_fields(&closure);
-for (int i = 0; i < fields->length(); i++) {
+objArrayHandle field_array = oopFactory::new_objArray(SystemDictionary::RiField_klass(), closure._field_array.length(), CHECK_NULL);
-ciField* field = fields->at(i);
+for (int i=0; i<closure._field_array.length(); ++i) {
-if (field->holder() == instance_klass) {
+field_array->obj_at_put(i, closure._field_array.at(i)());
-Handle field_handle = GraalCompiler::get_RiField(field, instance_klass, klass_handle, Bytecodes::_illegal, CHECK_NULL);
+}
-fieldsArray->obj_at_put(z, field_handle());
+return JNIHandles::make_local(field_array());
-z++;
-}
-}
-}
-return JNIHandles::make_local(fieldsArray());
 }
 // public RiType getPrimitiveArrayType(CiKind kind);
 JNIEXPORT jobject JNICALL Java_com_oracle_graal_hotspot_VMEntries_getPrimitiveArrayType(JNIEnv *env, jobject, jobject kind) {
 TRACE_graal_3("VMEntries::VMEntries_getPrimitiveArrayType");
 VM_ENTRY_MARK;
 BasicType type = GraalCompiler::kindToBasicType(CiKind::typeChar(kind));
 assert(type != T_OBJECT, "primitive type expecteds");
-ciKlass* klass = ciTypeArrayKlass::make(type);
+Handle result = GraalCompiler::get_RiType(Universe::typeArrayKlassObj(type), CHECK_NULL);
-return JNIHandles::make_local(THREAD, GraalCompiler::get_RiType(klass, KlassHandle(), THREAD));
+return JNIHandles::make_local(THREAD, result());
 }
 // public long getMaxCallTargetOffset(CiRuntimeCall rtcall);
 JNIEXPORT jlong JNICALL Java_com_oracle_graal_hotspot_VMEntries_getMaxCallTargetOffset(JNIEnv *env, jobject, jobject rtcall) {
 TRACE_graal_3("VMEntries::VMEntries_getMaxCallTargetOffset");
 return JNIHandles::make_local(THREAD, VMExits::createRiTypePrimitive((int) basicType, THREAD));
 } else {
 KlassHandle klass = java_lang_Class::as_klassOop(javaClassOop);
 Handle name = java_lang_String::create_from_symbol(klass->name(), CHECK_NULL);
-oop type = GraalCompiler::createHotSpotTypeResolved(klass, name, CHECK_NULL);
+Handle type = GraalCompiler::createHotSpotTypeResolved(klass, name, CHECK_NULL);
-return JNIHandles::make_local(THREAD, type);
+return JNIHandles::make_local(THREAD, type());
 }
 }
 // helpers used to set fields in the HotSpotVMConfig object
 // public HotSpotCompiledMethod installMethod(HotSpotTargetMethod targetMethod, boolean installCode);
 JNIEXPORT jobject JNICALL Java_com_oracle_graal_hotspot_VMEntries_installMethod(JNIEnv *jniEnv, jobject, jobject targetMethod, jboolean install_code) {
 VM_ENTRY_MARK;
 nmethod* nm = NULL;
-if (CURRENT_ENV == NULL) {
+ciEnv* current_env = JavaThread::current()->env();
-Arena arena;
+JavaThread::current()->set_env(NULL);
-ciEnv env(&arena);
+Arena arena;
-ResourceMark rm;
+ciEnv env(&arena);
-CodeInstaller installer(JNIHandles::resolve(targetMethod), nm, install_code != 0);
+ResourceMark rm;
-} else {
+CodeInstaller installer(JNIHandles::resolve(targetMethod), nm, install_code != 0);
-ResourceMark rm;
+JavaThread::current()->set_env(current_env);
-CodeInstaller installer(JNIHandles::resolve(targetMethod), nm, install_code != 0);
-if (CURRENT_ENV->failing()) {
-tty->print_cr("failing: %s", CURRENT_ENV->failure_reason());
-}
-}
 // if install_code is true then we installed the code into the given method, no need to return an RiCompiledMethod
 if (!install_code && nm != NULL) {
 instanceKlass::cast(HotSpotCompiledMethod::klass())->initialize(CHECK_NULL);
 Handle obj = instanceKlass::cast(HotSpotCompiledMethod::klass())->allocate_permanent_instance(CHECK_NULL);
 // public HotSpotProxy installStub(HotSpotTargetMethod targetMethod, String name);
 JNIEXPORT jlong JNICALL Java_com_oracle_graal_hotspot_VMEntries_installStub(JNIEnv *jniEnv, jobject, jobject targetMethod) {
 VM_ENTRY_MARK;
 jlong id;
-if (CURRENT_ENV == NULL) {
+ciEnv* current_env = JavaThread::current()->env();
-Arena arena;
+JavaThread::current()->set_env(NULL);
-ciEnv env(&arena);
+Arena arena;
-ResourceMark rm;
+ciEnv env(&arena);
-CodeInstaller installer(JNIHandles::resolve(targetMethod), id);
+ResourceMark rm;
-} else {
+CodeInstaller installer(JNIHandles::resolve(targetMethod), id);
-ResourceMark rm;
+JavaThread::current()->set_env(current_env);
-CodeInstaller installer(JNIHandles::resolve(targetMethod), id);
-}
 return id;
 }
 // public void recordBailout(String reason);
 JNIEXPORT void JNICALL Java_com_oracle_graal_hotspot_VMEntries_recordBailout(JNIEnv *jniEnv, jobject, jobject message) {

Mercurial > hg > truffle

comparison src/share/vm/graal/graalVMEntries.cpp @ 3685:5c8fc9f05960