src/hotspot/share/runtime/reflection.cpp

*** 38,57 ****
--- 38,59 ----
  #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,796 ****
      outer->external_name(),
      inner->external_name()
    );
  }
  
  // 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()) {
      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),
--- 782,809 ----
      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) {
  
!   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,814 ****
                                                         true,
                                                         CHECK_NULL);
      if (log_is_enabled(Debug, class, resolve)) {
        trace_class_resolution(k);
      }
!     return k->java_mirror();
    }
  
!   assert(ss->type() != T_VOID || ss->at_return_type(),
      "T_VOID should only appear as return type");
  
!   return java_lang_Class::primitive_mirror(ss->type());
  }
  
  static objArrayHandle get_parameter_types(const methodHandle& method,
                                            int parameter_count,
                                            oop* return_type,
--- 811,827 ----
                                                         true,
                                                         CHECK_NULL);
      if (log_is_enabled(Debug, class, resolve)) {
        trace_class_resolution(k);
      }
!     return java_mirror((Klass*)k, bt == T_VALUETYPE);
    }
  
!   assert(bt != T_VOID || ss->at_return_type(),
      "T_VOID should only appear as return type");
  
!   return java_lang_Class::primitive_mirror(bt);
  }
  
  static objArrayHandle get_parameter_types(const methodHandle& method,
                                            int parameter_count,
                                            oop* return_type,
*** 853,864 ****
                                        true, CHECK_(Handle()));
  
    if (log_is_enabled(Debug, class, resolve)) {
      trace_class_resolution(result);
    }
! 
!   oop nt = result->java_mirror();
    return Handle(THREAD, nt);
  }
  
  
  oop Reflection::new_method(const methodHandle& method, bool for_constant_pool_access, TRAPS) {
--- 866,876 ----
                                        true, CHECK_(Handle()));
  
    if (log_is_enabled(Debug, class, resolve)) {
      trace_class_resolution(result);
    }
!   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) {