< prev index next >

src/hotspot/share/runtime/reflection.cpp

Print this page

        

@@ -38,20 +38,22 @@
 #include "memory/universe.hpp"
 #include "oops/instanceKlass.hpp"
 #include "oops/objArrayKlass.hpp"
 #include "oops/objArrayOop.inline.hpp"
 #include "oops/oop.inline.hpp"
+#include "oops/valueKlass.hpp"
 #include "oops/typeArrayOop.inline.hpp"
 #include "prims/jvmtiExport.hpp"
 #include "runtime/arguments.hpp"
 #include "runtime/fieldDescriptor.inline.hpp"
 #include "runtime/handles.inline.hpp"
 #include "runtime/javaCalls.hpp"
 #include "runtime/reflection.hpp"
 #include "runtime/reflectionUtils.hpp"
 #include "runtime/signature.hpp"
 #include "runtime/vframe.inline.hpp"
+#include "utilities/globalDefinitions.hpp"
 
 static void trace_class_resolution(const Klass* to_class) {
   ResourceMark rm;
   int line_number = -1;
   const char * source_file = NULL;

@@ -780,17 +782,28 @@
     outer->external_name(),
     inner->external_name()
   );
 }
 
+// Returns Q-mirror if qtype_if_value is true and k is a ValueKlass;
+// otherwise returns java_mirror or L-mirror for ValueKlass
+static oop java_mirror(Klass* k, jboolean qtype_if_value) {
+  if (qtype_if_value && k->is_value()) {
+    ValueKlass* vk = ValueKlass::cast(InstanceKlass::cast(k));
+    return vk->value_mirror();
+  } else {
+    return k->java_mirror();
+  }
+}
+
 // Utility method converting a single SignatureStream element into java.lang.Class instance
 static oop get_mirror_from_signature(const methodHandle& method,
                                      SignatureStream* ss,
                                      TRAPS) {
 
-
-  if (T_OBJECT == ss->type() || T_ARRAY == ss->type() || T_VALUETYPE == ss->type()) {
+  BasicType bt = ss->type();
+  if (T_OBJECT == bt || T_ARRAY == bt || T_VALUETYPE == bt) {
     Symbol* name = ss->as_symbol(CHECK_NULL);
     oop loader = method->method_holder()->class_loader();
     oop protection_domain = method->method_holder()->protection_domain();
     const Klass* k = SystemDictionary::resolve_or_fail(name,
                                                        Handle(THREAD, loader),

@@ -798,17 +811,17 @@
                                                        true,
                                                        CHECK_NULL);
     if (log_is_enabled(Debug, class, resolve)) {
       trace_class_resolution(k);
     }
-    return k->java_mirror();
+    return java_mirror((Klass*)k, bt == T_VALUETYPE);
   }
 
-  assert(ss->type() != T_VOID || ss->at_return_type(),
+  assert(bt != T_VOID || ss->at_return_type(),
     "T_VOID should only appear as return type");
 
-  return java_lang_Class::primitive_mirror(ss->type());
+  return java_lang_Class::primitive_mirror(bt);
 }
 
 static objArrayHandle get_parameter_types(const methodHandle& method,
                                           int parameter_count,
                                           oop* return_type,

@@ -853,12 +866,11 @@
                                       true, CHECK_(Handle()));
 
   if (log_is_enabled(Debug, class, resolve)) {
     trace_class_resolution(result);
   }
-
-  oop nt = result->java_mirror();
+  oop nt = java_mirror(result, type == T_VALUETYPE);
   return Handle(THREAD, nt);
 }
 
 
 oop Reflection::new_method(const methodHandle& method, bool for_constant_pool_access, TRAPS) {
< prev index next >