< prev index next >
src/hotspot/share/runtime/reflection.cpp
Print this page
@@ -38,10 +38,11 @@
#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"
@@ -49,10 +50,11 @@
#include "runtime/reflection.hpp"
#include "runtime/reflectionUtils.hpp"
#include "runtime/signature.hpp"
#include "runtime/thread.inline.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;
@@ -90,11 +92,11 @@
oop Reflection::box(jvalue* value, BasicType type, TRAPS) {
if (type == T_VOID) {
return NULL;
}
- if (type == T_OBJECT || type == T_ARRAY) {
+ if (type == T_OBJECT || type == T_ARRAY || type == T_VALUETYPE) {
// regular objects are not boxed
return (oop) value->l;
}
oop result = java_lang_boxing_object::create(type, value, CHECK_NULL);
if (result == NULL) {
@@ -340,11 +342,11 @@
} else {
Klass* k = java_lang_Class::as_Klass(element_mirror);
if (k->is_array_klass() && ArrayKlass::cast(k)->dimension() >= MAX_DIM) {
THROW_0(vmSymbols::java_lang_IllegalArgumentException());
}
- return oopFactory::new_objArray(k, length, THREAD);
+ return oopFactory::new_array(k, length, THREAD);
}
}
arrayOop Reflection::reflect_new_multi_array(oop element_mirror, typeArrayOop dim_array, TRAPS) {
@@ -748,17 +750,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()) {
+ 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),
@@ -766,17 +779,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,
@@ -808,11 +821,11 @@
}
static Handle new_type(Symbol* signature, Klass* k, TRAPS) {
// Basic types
BasicType type = vmSymbols::signature_type(signature);
- if (type != T_OBJECT) {
+ if (type != T_OBJECT && type != T_VALUETYPE) {
return Handle(THREAD, Universe::java_mirror(type));
}
Klass* result =
SystemDictionary::resolve_or_fail(signature,
@@ -821,12 +834,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) {
@@ -930,11 +942,18 @@
java_lang_reflect_Field::set_clazz(rh(), fd->field_holder()->java_mirror());
java_lang_reflect_Field::set_slot(rh(), fd->index());
java_lang_reflect_Field::set_name(rh(), name());
java_lang_reflect_Field::set_type(rh(), type());
// Note the ACC_ANNOTATION bit, which is a per-class access flag, is never set here.
- java_lang_reflect_Field::set_modifiers(rh(), fd->access_flags().as_int() & JVM_RECOGNIZED_FIELD_MODIFIERS);
+ int modifiers = fd->access_flags().as_int() & JVM_RECOGNIZED_FIELD_MODIFIERS;
+ if (fd->is_flattenable()) {
+ modifiers |= JVM_ACC_FLATTENABLE;
+ }
+ if (fd->is_flattened()) {
+ modifiers |= JVM_ACC_FIELD_FLATTENED;
+ }
+ java_lang_reflect_Field::set_modifiers(rh(), modifiers);
java_lang_reflect_Field::set_override(rh(), false);
if (fd->has_generic_signature()) {
Symbol* gs = fd->generic_signature();
Handle sig = java_lang_String::create_from_symbol(gs, CHECK_NULL);
java_lang_reflect_Field::set_signature(rh(), sig());
@@ -1201,10 +1220,12 @@
oop return_type_mirror = java_lang_reflect_Method::return_type(method_mirror);
BasicType rtype;
if (java_lang_Class::is_primitive(return_type_mirror)) {
rtype = basic_type_mirror_to_basic_type(return_type_mirror, CHECK_NULL);
+ } else if (java_lang_Class::value_mirror(return_type_mirror) == return_type_mirror) {
+ rtype = T_VALUETYPE;
} else {
rtype = T_OBJECT;
}
InstanceKlass* klass = InstanceKlass::cast(java_lang_Class::as_Klass(mirror));
< prev index next >