--- a/hotspot/src/share/vm/prims/jvm.cpp Fri Aug 31 16:39:35 2012 -0700
+++ b/hotspot/src/share/vm/prims/jvm.cpp Sat Sep 01 13:25:18 2012 -0400
@@ -35,7 +35,7 @@
#include "oops/fieldStreams.hpp"
#include "oops/instanceKlass.hpp"
#include "oops/objArrayKlass.hpp"
-#include "oops/methodOop.hpp"
+#include "oops/method.hpp"
#include "prims/jvm.h"
#include "prims/jvm_misc.hpp"
#include "prims/jvmtiExport.hpp"
@@ -120,29 +120,29 @@
and thus can only support use of handles passed in.
*/
-static void trace_class_resolution_impl(klassOop to_class, TRAPS) {
+static void trace_class_resolution_impl(Klass* to_class, TRAPS) {
ResourceMark rm;
int line_number = -1;
const char * source_file = NULL;
const char * trace = "explicit";
- klassOop caller = NULL;
+ Klass* caller = NULL;
JavaThread* jthread = JavaThread::current();
if (jthread->has_last_Java_frame()) {
vframeStream vfst(jthread);
// scan up the stack skipping ClassLoader, AccessController and PrivilegedAction frames
TempNewSymbol access_controller = SymbolTable::new_symbol("java/security/AccessController", CHECK);
- klassOop access_controller_klass = SystemDictionary::resolve_or_fail(access_controller, false, CHECK);
+ Klass* access_controller_klass = SystemDictionary::resolve_or_fail(access_controller, false, CHECK);
TempNewSymbol privileged_action = SymbolTable::new_symbol("java/security/PrivilegedAction", CHECK);
- klassOop privileged_action_klass = SystemDictionary::resolve_or_fail(privileged_action, false, CHECK);
-
- methodOop last_caller = NULL;
+ Klass* privileged_action_klass = SystemDictionary::resolve_or_fail(privileged_action, false, CHECK);
+
+ Method* last_caller = NULL;
while (!vfst.at_end()) {
- methodOop m = vfst.method();
- if (!vfst.method()->method_holder()->klass_part()->is_subclass_of(SystemDictionary::ClassLoader_klass())&&
- !vfst.method()->method_holder()->klass_part()->is_subclass_of(access_controller_klass) &&
- !vfst.method()->method_holder()->klass_part()->is_subclass_of(privileged_action_klass)) {
+ Method* m = vfst.method();
+ if (!vfst.method()->method_holder()->is_subclass_of(SystemDictionary::ClassLoader_klass())&&
+ !vfst.method()->method_holder()->is_subclass_of(access_controller_klass) &&
+ !vfst.method()->method_holder()->is_subclass_of(privileged_action_klass)) {
break;
}
last_caller = m;
@@ -153,17 +153,17 @@
// that caller, otherwise keep quiet since this should be picked up elsewhere.
bool found_it = false;
if (!vfst.at_end() &&
- instanceKlass::cast(vfst.method()->method_holder())->name() == vmSymbols::java_lang_Class() &&
+ InstanceKlass::cast(vfst.method()->method_holder())->name() == vmSymbols::java_lang_Class() &&
vfst.method()->name() == vmSymbols::forName0_name()) {
vfst.next();
if (!vfst.at_end() &&
- instanceKlass::cast(vfst.method()->method_holder())->name() == vmSymbols::java_lang_Class() &&
+ InstanceKlass::cast(vfst.method()->method_holder())->name() == vmSymbols::java_lang_Class() &&
vfst.method()->name() == vmSymbols::forName_name()) {
vfst.next();
found_it = true;
}
} else if (last_caller != NULL &&
- instanceKlass::cast(last_caller->method_holder())->name() ==
+ InstanceKlass::cast(last_caller->method_holder())->name() ==
vmSymbols::java_lang_ClassLoader() &&
(last_caller->name() == vmSymbols::loadClassInternal_name() ||
last_caller->name() == vmSymbols::loadClass_name())) {
@@ -182,7 +182,7 @@
// show method name if it's a native method
trace = vfst.method()->name_and_sig_as_C_string();
}
- Symbol* s = instanceKlass::cast(caller)->source_file_name();
+ Symbol* s = InstanceKlass::cast(caller)->source_file_name();
if (s != NULL) {
source_file = s->as_C_string();
}
@@ -202,7 +202,7 @@
}
}
-void trace_class_resolution(klassOop to_class) {
+void trace_class_resolution(Klass* to_class) {
EXCEPTION_MARK;
trace_class_resolution_impl(to_class, THREAD);
if (HAS_PENDING_EXCEPTION) {
@@ -522,7 +522,6 @@
JVM_ENTRY(void, JVM_MonitorWait(JNIEnv* env, jobject handle, jlong ms))
JVMWrapper("JVM_MonitorWait");
Handle obj(THREAD, JNIHandles::resolve_non_null(handle));
- assert(obj->is_instance() || obj->is_array(), "JVM_MonitorWait must apply to an object");
JavaThreadInObjectWaitState jtiows(thread, ms != 0);
if (JvmtiExport::should_post_monitor_wait()) {
JvmtiExport::post_monitor_wait((JavaThread *)THREAD, (oop)obj(), ms);
@@ -534,7 +533,6 @@
JVM_ENTRY(void, JVM_MonitorNotify(JNIEnv* env, jobject handle))
JVMWrapper("JVM_MonitorNotify");
Handle obj(THREAD, JNIHandles::resolve_non_null(handle));
- assert(obj->is_instance() || obj->is_array(), "JVM_MonitorNotify must apply to an object");
ObjectSynchronizer::notify(obj, CHECK);
JVM_END
@@ -542,7 +540,6 @@
JVM_ENTRY(void, JVM_MonitorNotifyAll(JNIEnv* env, jobject handle))
JVMWrapper("JVM_MonitorNotifyAll");
Handle obj(THREAD, JNIHandles::resolve_non_null(handle));
- assert(obj->is_instance() || obj->is_array(), "JVM_MonitorNotifyAll must apply to an object");
ObjectSynchronizer::notifyall(obj, CHECK);
JVM_END
@@ -555,7 +552,7 @@
#ifdef ASSERT
// Just checking that the cloneable flag is set correct
- if (obj->is_javaArray()) {
+ if (obj->is_array()) {
guarantee(klass->is_cloneable(), "all arrays are cloneable");
} else {
guarantee(obj->is_instance(), "should be instanceOop");
@@ -574,7 +571,7 @@
// Make shallow object copy
const int size = obj->size();
oop new_obj = NULL;
- if (obj->is_javaArray()) {
+ if (obj->is_array()) {
const int length = ((arrayOop)obj())->length();
new_obj = CollectedHeap::array_allocate(klass, size, length, CHECK_NULL);
} else {
@@ -604,7 +601,7 @@
// "gc-robust" by this stage.
if (klass->has_finalizer()) {
assert(obj->is_instance(), "should be instanceOop");
- new_obj = instanceKlass::register_finalizer(instanceOop(new_obj), CHECK_NULL);
+ new_obj = InstanceKlass::register_finalizer(instanceOop(new_obj), CHECK_NULL);
}
return JNIHandles::make_local(env, oop(new_obj));
@@ -677,7 +674,7 @@
JVM_ENTRY(jclass, JVM_GetCallerClass(JNIEnv* env, int depth))
JVMWrapper("JVM_GetCallerClass");
- klassOop k = thread->security_get_caller_class(depth);
+ Klass* k = thread->security_get_caller_class(depth);
return (k == NULL) ? NULL : (jclass) JNIHandles::make_local(env, Klass::cast(k)->java_mirror());
JVM_END
@@ -734,7 +731,7 @@
}
TempNewSymbol h_name = SymbolTable::new_symbol(name, CHECK_NULL);
- klassOop k = SystemDictionary::resolve_or_null(h_name, CHECK_NULL);
+ Klass* k = SystemDictionary::resolve_or_null(h_name, CHECK_NULL);
if (k == NULL) {
return NULL;
}
@@ -766,7 +763,7 @@
Handle(), throwError, THREAD);
if (TraceClassResolution && result != NULL) {
- trace_class_resolution(java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(result)));
+ trace_class_resolution(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(result)));
}
return result;
JVM_END
@@ -782,9 +779,9 @@
}
TempNewSymbol h_name = SymbolTable::new_symbol(name, CHECK_NULL);
oop from_class_oop = JNIHandles::resolve(from);
- klassOop from_class = (from_class_oop == NULL)
- ? (klassOop)NULL
- : java_lang_Class::as_klassOop(from_class_oop);
+ Klass* from_class = (from_class_oop == NULL)
+ ? (Klass*)NULL
+ : java_lang_Class::as_Klass(from_class_oop);
oop class_loader = NULL;
oop protection_domain = NULL;
if (from_class != NULL) {
@@ -800,11 +797,11 @@
// this function is generally only used for class loading during verification.
ResourceMark rm;
oop from_mirror = JNIHandles::resolve_non_null(from);
- klassOop from_class = java_lang_Class::as_klassOop(from_mirror);
+ Klass* from_class = java_lang_Class::as_Klass(from_mirror);
const char * from_name = Klass::cast(from_class)->external_name();
oop mirror = JNIHandles::resolve_non_null(result);
- klassOop to_class = java_lang_Class::as_klassOop(mirror);
+ Klass* to_class = java_lang_Class::as_Klass(mirror);
const char * to = Klass::cast(to_class)->external_name();
tty->print("RESOLVE %s %s (verification)\n", from_name, to);
}
@@ -869,7 +866,7 @@
THREAD);
}
Handle protection_domain (THREAD, JNIHandles::resolve(pd));
- klassOop k = SystemDictionary::resolve_from_stream(class_name, class_loader,
+ Klass* k = SystemDictionary::resolve_from_stream(class_name, class_loader,
protection_domain, &st,
verify != 0,
CHECK_NULL);
@@ -933,7 +930,7 @@
THREAD);
}
- klassOop k = SystemDictionary::find_instance_or_array_klass(klass_name,
+ Klass* k = SystemDictionary::find_instance_or_array_klass(klass_name,
h_loader,
Handle(),
CHECK_NULL);
@@ -955,7 +952,7 @@
name = type2name(java_lang_Class::primitive_type(JNIHandles::resolve(cls)));
} else {
// Consider caching interned string in Klass
- klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve(cls));
+ Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve(cls));
assert(k->is_klass(), "just checking");
name = Klass::cast(k)->external_name();
}
@@ -976,11 +973,11 @@
return (jobjectArray) JNIHandles::make_local(env, r);
}
- KlassHandle klass(thread, java_lang_Class::as_klassOop(mirror));
+ KlassHandle klass(thread, java_lang_Class::as_Klass(mirror));
// Figure size of result array
int size;
if (klass->oop_is_instance()) {
- size = instanceKlass::cast(klass())->local_interfaces()->length();
+ size = InstanceKlass::cast(klass())->local_interfaces()->length();
} else {
assert(klass->oop_is_objArray() || klass->oop_is_typeArray(), "Illegal mirror klass");
size = 2;
@@ -993,7 +990,7 @@
if (klass->oop_is_instance()) {
// Regular instance klass, fill in all local interfaces
for (int index = 0; index < size; index++) {
- klassOop k = klassOop(instanceKlass::cast(klass())->local_interfaces()->obj_at(index));
+ Klass* k = InstanceKlass::cast(klass())->local_interfaces()->at(index);
result->obj_at_put(index, Klass::cast(k)->java_mirror());
}
} else {
@@ -1010,7 +1007,7 @@
if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) {
return NULL;
}
- klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls));
+ Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
oop loader = Klass::cast(k)->class_loader();
return JNIHandles::make_local(env, loader);
JVM_END
@@ -1022,7 +1019,7 @@
if (java_lang_Class::is_primitive(mirror)) {
return JNI_FALSE;
}
- klassOop k = java_lang_Class::as_klassOop(mirror);
+ Klass* k = java_lang_Class::as_Klass(mirror);
jboolean result = Klass::cast(k)->is_interface();
assert(!result || Klass::cast(k)->oop_is_instance(),
"all interfaces are instance types");
@@ -1040,10 +1037,10 @@
return NULL;
}
- klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls));
+ Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
objArrayOop signers = NULL;
if (Klass::cast(k)->oop_is_instance()) {
- signers = instanceKlass::cast(k)->signers();
+ signers = InstanceKlass::cast(k)->signers();
}
// If there are no signers set in the class, or if the class
@@ -1051,7 +1048,7 @@
if (signers == NULL) return NULL;
// copy of the signers array
- klassOop element = objArrayKlass::cast(signers->klass())->element_klass();
+ Klass* element = objArrayKlass::cast(signers->klass())->element_klass();
objArrayOop signers_copy = oopFactory::new_objArray(element, signers->length(), CHECK_NULL);
for (int index = 0; index < signers->length(); index++) {
signers_copy->obj_at_put(index, signers->obj_at(index));
@@ -1068,9 +1065,9 @@
// This call is ignored for primitive types and arrays.
// Signers are only set once, ClassLoader.java, and thus shouldn't
// be called with an array. Only the bootstrap loader creates arrays.
- klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls));
+ Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
if (Klass::cast(k)->oop_is_instance()) {
- instanceKlass::cast(k)->set_signers(objArrayOop(JNIHandles::resolve(signers)));
+ InstanceKlass::cast(k)->set_signers(objArrayOop(JNIHandles::resolve(signers)));
}
}
JVM_END
@@ -1087,7 +1084,7 @@
return NULL;
}
- klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve(cls));
+ Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve(cls));
return (jobject) JNIHandles::make_local(env, Klass::cast(k)->protection_domain());
JVM_END
@@ -1101,13 +1098,13 @@
}
if (!java_lang_Class::is_primitive(JNIHandles::resolve(cls))) {
// Call is ignored for primitive types
- klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve(cls));
+ Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve(cls));
// cls won't be an array, as this called only from ClassLoader.defineClass
if (Klass::cast(k)->oop_is_instance()) {
oop pd = JNIHandles::resolve(protection_domain);
assert(pd == NULL || pd->is_oop(), "just checking");
- instanceKlass::cast(k)->set_protection_domain(pd);
+ InstanceKlass::cast(k)->set_protection_domain(pd);
}
}
JVM_END
@@ -1127,11 +1124,11 @@
Handle object (THREAD, JNIHandles::resolve(action));
// get run() method
- methodOop m_oop = Klass::cast(object->klass())->uncached_lookup_method(
+ Method* m_oop = Klass::cast(object->klass())->uncached_lookup_method(
vmSymbols::run_method_name(),
vmSymbols::void_object_signature());
methodHandle m (THREAD, m_oop);
- if (m.is_null() || !m->is_method() || !methodOop(m())->is_public() || methodOop(m())->is_static()) {
+ if (m.is_null() || !m->is_method() || !m()->is_public() || m()->is_static()) {
THROW_MSG_0(vmSymbols::java_lang_InternalError(), "No run method");
}
@@ -1221,7 +1218,7 @@
for(; !vfst.at_end(); vfst.next()) {
// get method of frame
- methodOop method = vfst.method();
+ Method* method = vfst.method();
intptr_t* frame_id = vfst.frame_id();
// check the privileged frames to see if we have a match
@@ -1231,7 +1228,7 @@
privileged_context = Handle(thread, thread->privileged_stack_top()->privileged_context());
protection_domain = thread->privileged_stack_top()->protection_domain();
} else {
- protection_domain = instanceKlass::cast(method->method_holder())->protection_domain();
+ protection_domain = InstanceKlass::cast(method->method_holder())->protection_domain();
}
if ((previous_protection_domain != protection_domain) && (protection_domain != NULL)) {
@@ -1269,8 +1266,8 @@
JVM_QUICK_ENTRY(jboolean, JVM_IsArrayClass(JNIEnv *env, jclass cls))
JVMWrapper("JVM_IsArrayClass");
- klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls));
- return (k != NULL) && Klass::cast(k)->oop_is_javaArray() ? true : false;
+ Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
+ return (k != NULL) && Klass::cast(k)->oop_is_array() ? true : false;
JVM_END
@@ -1296,7 +1293,7 @@
return JVM_ACC_ABSTRACT | JVM_ACC_FINAL | JVM_ACC_PUBLIC;
}
- Klass* k = Klass::cast(java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)));
+ Klass* k = Klass::cast(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)));
debug_only(int computed_modifiers = k->compute_modifier_flags(CHECK_0));
assert(k->modifier_flags() == computed_modifiers, "modifiers cache is OK");
return k->modifier_flags();
@@ -1308,15 +1305,15 @@
JVM_ENTRY(jobjectArray, JVM_GetDeclaredClasses(JNIEnv *env, jclass ofClass))
JvmtiVMObjectAllocEventCollector oam;
// ofClass is a reference to a java_lang_Class object. The mirror object
- // of an instanceKlass
+ // of an InstanceKlass
if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(ofClass)) ||
- ! Klass::cast(java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(ofClass)))->oop_is_instance()) {
+ ! Klass::cast(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass)))->oop_is_instance()) {
oop result = oopFactory::new_objArray(SystemDictionary::Class_klass(), 0, CHECK_NULL);
return (jobjectArray)JNIHandles::make_local(env, result);
}
- instanceKlassHandle k(thread, java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(ofClass)));
+ instanceKlassHandle k(thread, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass)));
InnerClassesIterator iter(k);
if (iter.length() == 0) {
@@ -1342,9 +1339,9 @@
// Check to see if the name matches the class we're looking for
// before attempting to find the class.
if (cp->klass_name_at_matches(k, ooff)) {
- klassOop outer_klass = cp->klass_at(ooff, CHECK_NULL);
+ Klass* outer_klass = cp->klass_at(ooff, CHECK_NULL);
if (outer_klass == k()) {
- klassOop ik = cp->klass_at(ioff, CHECK_NULL);
+ Klass* ik = cp->klass_at(ioff, CHECK_NULL);
instanceKlassHandle inner_klass (THREAD, ik);
// Throws an exception if outer klass has not declared k as
@@ -1375,13 +1372,13 @@
{
// ofClass is a reference to a java_lang_Class object.
if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(ofClass)) ||
- ! Klass::cast(java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(ofClass)))->oop_is_instance()) {
+ ! Klass::cast(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass)))->oop_is_instance()) {
return NULL;
}
bool inner_is_member = false;
- klassOop outer_klass
- = instanceKlass::cast(java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(ofClass))
+ Klass* outer_klass
+ = InstanceKlass::cast(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass))
)->compute_enclosing_class(&inner_is_member, CHECK_NULL);
if (outer_klass == NULL) return NULL; // already a top-level class
if (!inner_is_member) return NULL; // an anonymous class (inside a method)
@@ -1389,8 +1386,8 @@
}
JVM_END
-// should be in instanceKlass.cpp, but is here for historical reasons
-klassOop instanceKlass::compute_enclosing_class_impl(instanceKlassHandle k,
+// should be in InstanceKlass.cpp, but is here for historical reasons
+Klass* InstanceKlass::compute_enclosing_class_impl(instanceKlassHandle k,
bool* inner_is_member,
TRAPS) {
Thread* thread = THREAD;
@@ -1403,7 +1400,7 @@
constantPoolHandle i_cp(thread, k->constants());
bool found = false;
- klassOop ok;
+ Klass* ok;
instanceKlassHandle outer_klass;
*inner_is_member = false;
@@ -1416,7 +1413,7 @@
// Check to see if the name matches the class we're looking for
// before attempting to find the class.
if (i_cp->klass_name_at_matches(k, ioff)) {
- klassOop inner_klass = i_cp->klass_at(ioff, CHECK_NULL);
+ Klass* inner_klass = i_cp->klass_at(ioff, CHECK_NULL);
found = (k() == inner_klass);
if (found && ooff != 0) {
ok = i_cp->klass_at(ooff, CHECK_NULL);
@@ -1454,9 +1451,9 @@
ResourceMark rm(THREAD);
// Return null for arrays and primatives
if (!java_lang_Class::is_primitive(JNIHandles::resolve(cls))) {
- klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve(cls));
+ Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve(cls));
if (Klass::cast(k)->oop_is_instance()) {
- Symbol* sym = instanceKlass::cast(k)->generic_signature();
+ Symbol* sym = InstanceKlass::cast(k)->generic_signature();
if (sym == NULL) return NULL;
Handle str = java_lang_String::create_from_symbol(sym, CHECK_NULL);
return (jstring) JNIHandles::make_local(env, str());
@@ -1472,10 +1469,10 @@
ResourceMark rm(THREAD);
// Return null for arrays and primitives
if (!java_lang_Class::is_primitive(JNIHandles::resolve(cls))) {
- klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve(cls));
+ Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve(cls));
if (Klass::cast(k)->oop_is_instance()) {
- return (jbyteArray) JNIHandles::make_local(env,
- instanceKlass::cast(k)->class_annotations());
+ typeArrayOop a = Annotations::make_java_array(InstanceKlass::cast(k)->class_annotations(), CHECK_NULL);
+ return (jbyteArray) JNIHandles::make_local(env, a);
}
}
return NULL;
@@ -1491,36 +1488,34 @@
// field is a handle to a java.lang.reflect.Field object
oop reflected = JNIHandles::resolve_non_null(field);
oop mirror = java_lang_reflect_Field::clazz(reflected);
- klassOop k = java_lang_Class::as_klassOop(mirror);
+ Klass* k = java_lang_Class::as_Klass(mirror);
int slot = java_lang_reflect_Field::slot(reflected);
int modifiers = java_lang_reflect_Field::modifiers(reflected);
fieldDescriptor fd;
KlassHandle kh(THREAD, k);
- intptr_t offset = instanceKlass::cast(kh())->field_offset(slot);
+ intptr_t offset = InstanceKlass::cast(kh())->field_offset(slot);
if (modifiers & JVM_ACC_STATIC) {
// for static fields we only look in the current class
- if (!instanceKlass::cast(kh())->find_local_field_from_offset(offset,
- true, &fd)) {
+ if (!InstanceKlass::cast(kh())->find_local_field_from_offset(offset, true, &fd)) {
assert(false, "cannot find static field");
return NULL; // robustness
}
} else {
// for instance fields we start with the current class and work
// our way up through the superclass chain
- if (!instanceKlass::cast(kh())->find_field_from_offset(offset, false,
- &fd)) {
+ if (!InstanceKlass::cast(kh())->find_field_from_offset(offset, false, &fd)) {
assert(false, "cannot find instance field");
return NULL; // robustness
}
}
- return (jbyteArray) JNIHandles::make_local(env, fd.annotations());
+ return (jbyteArray) JNIHandles::make_local(env, Annotations::make_java_array(fd.annotations(), THREAD));
JVM_END
-static methodOop jvm_get_method_common(jobject method, TRAPS) {
+static Method* jvm_get_method_common(jobject method, TRAPS) {
// some of this code was adapted from from jni_FromReflectedMethod
oop reflected = JNIHandles::resolve_non_null(method);
@@ -1536,10 +1531,10 @@
mirror = java_lang_reflect_Method::clazz(reflected);
slot = java_lang_reflect_Method::slot(reflected);
}
- klassOop k = java_lang_Class::as_klassOop(mirror);
+ Klass* k = java_lang_Class::as_Klass(mirror);
KlassHandle kh(THREAD, k);
- methodOop m = instanceKlass::cast(kh())->method_with_idnum(slot);
+ Method* m = InstanceKlass::cast(kh())->method_with_idnum(slot);
if (m == NULL) {
assert(false, "cannot find method");
return NULL; // robustness
@@ -1553,8 +1548,9 @@
JVMWrapper("JVM_GetMethodAnnotations");
// method is a handle to a java.lang.reflect.Method object
- methodOop m = jvm_get_method_common(method, CHECK_NULL);
- return (jbyteArray) JNIHandles::make_local(env, m->annotations());
+ Method* m = jvm_get_method_common(method, CHECK_NULL);
+ return (jbyteArray) JNIHandles::make_local(env,
+ Annotations::make_java_array(m->annotations(), THREAD));
JVM_END
@@ -1562,8 +1558,9 @@
JVMWrapper("JVM_GetMethodDefaultAnnotationValue");
// method is a handle to a java.lang.reflect.Method object
- methodOop m = jvm_get_method_common(method, CHECK_NULL);
- return (jbyteArray) JNIHandles::make_local(env, m->annotation_default());
+ Method* m = jvm_get_method_common(method, CHECK_NULL);
+ return (jbyteArray) JNIHandles::make_local(env,
+ Annotations::make_java_array(m->annotation_default(), THREAD));
JVM_END
@@ -1571,8 +1568,9 @@
JVMWrapper("JVM_GetMethodParameterAnnotations");
// method is a handle to a java.lang.reflect.Method object
- methodOop m = jvm_get_method_common(method, CHECK_NULL);
- return (jbyteArray) JNIHandles::make_local(env, m->parameter_annotations());
+ Method* m = jvm_get_method_common(method, CHECK_NULL);
+ return (jbyteArray) JNIHandles::make_local(env,
+ Annotations::make_java_array(m->parameter_annotations(), THREAD));
JVM_END
@@ -1585,13 +1583,13 @@
// Exclude primitive types and array types
if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(ofClass)) ||
- Klass::cast(java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(ofClass)))->oop_is_javaArray()) {
+ Klass::cast(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass)))->oop_is_array()) {
// Return empty array
oop res = oopFactory::new_objArray(SystemDictionary::reflect_Field_klass(), 0, CHECK_NULL);
return (jobjectArray) JNIHandles::make_local(env, res);
}
- instanceKlassHandle k(THREAD, java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(ofClass)));
+ instanceKlassHandle k(THREAD, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass)));
constantPoolHandle cp(THREAD, k->constants());
// Ensure class is linked
@@ -1648,24 +1646,24 @@
// Exclude primitive types and array types
if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(ofClass))
- || Klass::cast(java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(ofClass)))->oop_is_javaArray()) {
+ || Klass::cast(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass)))->oop_is_array()) {
// Return empty array
oop res = oopFactory::new_objArray(SystemDictionary::reflect_Method_klass(), 0, CHECK_NULL);
return (jobjectArray) JNIHandles::make_local(env, res);
}
- instanceKlassHandle k(THREAD, java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(ofClass)));
+ instanceKlassHandle k(THREAD, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass)));
// Ensure class is linked
k->link_class(CHECK_NULL);
- objArrayHandle methods (THREAD, k->methods());
+ Array<Method*>* methods = k->methods();
int methods_length = methods->length();
int num_methods = 0;
int i;
for (i = 0; i < methods_length; i++) {
- methodHandle method(THREAD, (methodOop) methods->obj_at(i));
+ methodHandle method(THREAD, methods->at(i));
if (!method->is_initializer()) {
if (!publicOnly || method->is_public()) {
++num_methods;
@@ -1679,7 +1677,7 @@
int out_idx = 0;
for (i = 0; i < methods_length; i++) {
- methodHandle method(THREAD, (methodOop) methods->obj_at(i));
+ methodHandle method(THREAD, methods->at(i));
if (!method->is_initializer()) {
if (!publicOnly || method->is_public()) {
oop m = Reflection::new_method(method, UseNewReflection, false, CHECK_NULL);
@@ -1700,24 +1698,24 @@
// Exclude primitive types and array types
if (java_lang_Class::is_primitive(JNIHandles::resolve_non_null(ofClass))
- || Klass::cast(java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(ofClass)))->oop_is_javaArray()) {
+ || Klass::cast(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass)))->oop_is_array()) {
// Return empty array
oop res = oopFactory::new_objArray(SystemDictionary::reflect_Constructor_klass(), 0 , CHECK_NULL);
return (jobjectArray) JNIHandles::make_local(env, res);
}
- instanceKlassHandle k(THREAD, java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(ofClass)));
+ instanceKlassHandle k(THREAD, java_lang_Class::as_Klass(JNIHandles::resolve_non_null(ofClass)));
// Ensure class is linked
k->link_class(CHECK_NULL);
- objArrayHandle methods (THREAD, k->methods());
+ Array<Method*>* methods = k->methods();
int methods_length = methods->length();
int num_constructors = 0;
int i;
for (i = 0; i < methods_length; i++) {
- methodHandle method(THREAD, (methodOop) methods->obj_at(i));
+ methodHandle method(THREAD, methods->at(i));
if (method->is_initializer() && !method->is_static()) {
if (!publicOnly || method->is_public()) {
++num_constructors;
@@ -1731,7 +1729,7 @@
int out_idx = 0;
for (i = 0; i < methods_length; i++) {
- methodHandle method(THREAD, (methodOop) methods->obj_at(i));
+ methodHandle method(THREAD, methods->at(i));
if (method->is_initializer() && !method->is_static()) {
if (!publicOnly || method->is_public()) {
oop m = Reflection::new_constructor(method, CHECK_NULL);
@@ -1753,7 +1751,7 @@
return JVM_ACC_ABSTRACT | JVM_ACC_FINAL | JVM_ACC_PUBLIC;
}
- Klass* k = Klass::cast(java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls)));
+ Klass* k = Klass::cast(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls)));
return k->access_flags().as_int() & JVM_ACC_WRITTEN_FLAGS;
}
JVM_END
@@ -1768,11 +1766,11 @@
// Return null for primitives and arrays
if (!java_lang_Class::is_primitive(JNIHandles::resolve_non_null(cls))) {
- klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls));
+ Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
if (Klass::cast(k)->oop_is_instance()) {
instanceKlassHandle k_h(THREAD, k);
Handle jcp = sun_reflect_ConstantPool::create(CHECK_NULL);
- sun_reflect_ConstantPool::set_cp_oop(jcp(), k_h->constants());
+ sun_reflect_ConstantPool::set_cp(jcp(), k_h->constants());
return JNIHandles::make_local(jcp());
}
}
@@ -1781,10 +1779,10 @@
JVM_END
-JVM_ENTRY(jint, JVM_ConstantPoolGetSize(JNIEnv *env, jobject unused, jobject jcpool))
+JVM_ENTRY(jint, JVM_ConstantPoolGetSize(JNIEnv *env, jobject obj, jobject unused))
{
JVMWrapper("JVM_ConstantPoolGetSize");
- constantPoolHandle cp = constantPoolHandle(THREAD, constantPoolOop(JNIHandles::resolve_non_null(jcpool)));
+ constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
return cp->length();
}
JVM_END
@@ -1797,31 +1795,31 @@
}
-JVM_ENTRY(jclass, JVM_ConstantPoolGetClassAt(JNIEnv *env, jobject unused, jobject jcpool, jint index))
+JVM_ENTRY(jclass, JVM_ConstantPoolGetClassAt(JNIEnv *env, jobject obj, jobject unused, jint index))
{
JVMWrapper("JVM_ConstantPoolGetClassAt");
- constantPoolHandle cp = constantPoolHandle(THREAD, constantPoolOop(JNIHandles::resolve_non_null(jcpool)));
+ constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
bounds_check(cp, index, CHECK_NULL);
constantTag tag = cp->tag_at(index);
if (!tag.is_klass() && !tag.is_unresolved_klass()) {
THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");
}
- klassOop k = cp->klass_at(index, CHECK_NULL);
+ Klass* k = cp->klass_at(index, CHECK_NULL);
return (jclass) JNIHandles::make_local(k->java_mirror());
}
JVM_END
-JVM_ENTRY(jclass, JVM_ConstantPoolGetClassAtIfLoaded(JNIEnv *env, jobject unused, jobject jcpool, jint index))
+JVM_ENTRY(jclass, JVM_ConstantPoolGetClassAtIfLoaded(JNIEnv *env, jobject obj, jobject unused, jint index))
{
JVMWrapper("JVM_ConstantPoolGetClassAtIfLoaded");
- constantPoolHandle cp = constantPoolHandle(THREAD, constantPoolOop(JNIHandles::resolve_non_null(jcpool)));
+ constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
bounds_check(cp, index, CHECK_NULL);
constantTag tag = cp->tag_at(index);
if (!tag.is_klass() && !tag.is_unresolved_klass()) {
THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");
}
- klassOop k = constantPoolOopDesc::klass_at_if_loaded(cp, index);
+ Klass* k = ConstantPool::klass_at_if_loaded(cp, index);
if (k == NULL) return NULL;
return (jclass) JNIHandles::make_local(k->java_mirror());
}
@@ -1833,11 +1831,11 @@
THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");
}
int klass_ref = cp->uncached_klass_ref_index_at(index);
- klassOop k_o;
+ Klass* k_o;
if (force_resolution) {
k_o = cp->klass_at(klass_ref, CHECK_NULL);
} else {
- k_o = constantPoolOopDesc::klass_at_if_loaded(cp, klass_ref);
+ k_o = ConstantPool::klass_at_if_loaded(cp, klass_ref);
if (k_o == NULL) return NULL;
}
instanceKlassHandle k(THREAD, k_o);
@@ -1856,22 +1854,22 @@
return JNIHandles::make_local(method);
}
-JVM_ENTRY(jobject, JVM_ConstantPoolGetMethodAt(JNIEnv *env, jobject unused, jobject jcpool, jint index))
+JVM_ENTRY(jobject, JVM_ConstantPoolGetMethodAt(JNIEnv *env, jobject obj, jobject unused, jint index))
{
JVMWrapper("JVM_ConstantPoolGetMethodAt");
JvmtiVMObjectAllocEventCollector oam;
- constantPoolHandle cp = constantPoolHandle(THREAD, constantPoolOop(JNIHandles::resolve_non_null(jcpool)));
+ constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
bounds_check(cp, index, CHECK_NULL);
jobject res = get_method_at_helper(cp, index, true, CHECK_NULL);
return res;
}
JVM_END
-JVM_ENTRY(jobject, JVM_ConstantPoolGetMethodAtIfLoaded(JNIEnv *env, jobject unused, jobject jcpool, jint index))
+JVM_ENTRY(jobject, JVM_ConstantPoolGetMethodAtIfLoaded(JNIEnv *env, jobject obj, jobject unused, jint index))
{
JVMWrapper("JVM_ConstantPoolGetMethodAtIfLoaded");
JvmtiVMObjectAllocEventCollector oam;
- constantPoolHandle cp = constantPoolHandle(THREAD, constantPoolOop(JNIHandles::resolve_non_null(jcpool)));
+ constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
bounds_check(cp, index, CHECK_NULL);
jobject res = get_method_at_helper(cp, index, false, CHECK_NULL);
return res;
@@ -1884,18 +1882,18 @@
THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");
}
int klass_ref = cp->uncached_klass_ref_index_at(index);
- klassOop k_o;
+ Klass* k_o;
if (force_resolution) {
k_o = cp->klass_at(klass_ref, CHECK_NULL);
} else {
- k_o = constantPoolOopDesc::klass_at_if_loaded(cp, klass_ref);
+ k_o = ConstantPool::klass_at_if_loaded(cp, klass_ref);
if (k_o == NULL) return NULL;
}
instanceKlassHandle k(THREAD, k_o);
Symbol* name = cp->uncached_name_ref_at(index);
Symbol* sig = cp->uncached_signature_ref_at(index);
fieldDescriptor fd;
- klassOop target_klass = k->find_field(name, sig, &fd);
+ Klass* target_klass = k->find_field(name, sig, &fd);
if (target_klass == NULL) {
THROW_MSG_0(vmSymbols::java_lang_RuntimeException(), "Unable to look up field in target class");
}
@@ -1903,33 +1901,33 @@
return JNIHandles::make_local(field);
}
-JVM_ENTRY(jobject, JVM_ConstantPoolGetFieldAt(JNIEnv *env, jobject unused, jobject jcpool, jint index))
+JVM_ENTRY(jobject, JVM_ConstantPoolGetFieldAt(JNIEnv *env, jobject obj, jobject unusedl, jint index))
{
JVMWrapper("JVM_ConstantPoolGetFieldAt");
JvmtiVMObjectAllocEventCollector oam;
- constantPoolHandle cp = constantPoolHandle(THREAD, constantPoolOop(JNIHandles::resolve_non_null(jcpool)));
+ constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
bounds_check(cp, index, CHECK_NULL);
jobject res = get_field_at_helper(cp, index, true, CHECK_NULL);
return res;
}
JVM_END
-JVM_ENTRY(jobject, JVM_ConstantPoolGetFieldAtIfLoaded(JNIEnv *env, jobject unused, jobject jcpool, jint index))
+JVM_ENTRY(jobject, JVM_ConstantPoolGetFieldAtIfLoaded(JNIEnv *env, jobject obj, jobject unused, jint index))
{
JVMWrapper("JVM_ConstantPoolGetFieldAtIfLoaded");
JvmtiVMObjectAllocEventCollector oam;
- constantPoolHandle cp = constantPoolHandle(THREAD, constantPoolOop(JNIHandles::resolve_non_null(jcpool)));
+ constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
bounds_check(cp, index, CHECK_NULL);
jobject res = get_field_at_helper(cp, index, false, CHECK_NULL);
return res;
}
JVM_END
-JVM_ENTRY(jobjectArray, JVM_ConstantPoolGetMemberRefInfoAt(JNIEnv *env, jobject unused, jobject jcpool, jint index))
+JVM_ENTRY(jobjectArray, JVM_ConstantPoolGetMemberRefInfoAt(JNIEnv *env, jobject obj, jobject unused, jint index))
{
JVMWrapper("JVM_ConstantPoolGetMemberRefInfoAt");
JvmtiVMObjectAllocEventCollector oam;
- constantPoolHandle cp = constantPoolHandle(THREAD, constantPoolOop(JNIHandles::resolve_non_null(jcpool)));
+ constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
bounds_check(cp, index, CHECK_NULL);
constantTag tag = cp->tag_at(index);
if (!tag.is_field_or_method()) {
@@ -1951,10 +1949,10 @@
}
JVM_END
-JVM_ENTRY(jint, JVM_ConstantPoolGetIntAt(JNIEnv *env, jobject unused, jobject jcpool, jint index))
+JVM_ENTRY(jint, JVM_ConstantPoolGetIntAt(JNIEnv *env, jobject obj, jobject unused, jint index))
{
JVMWrapper("JVM_ConstantPoolGetIntAt");
- constantPoolHandle cp = constantPoolHandle(THREAD, constantPoolOop(JNIHandles::resolve_non_null(jcpool)));
+ constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
bounds_check(cp, index, CHECK_0);
constantTag tag = cp->tag_at(index);
if (!tag.is_int()) {
@@ -1964,10 +1962,10 @@
}
JVM_END
-JVM_ENTRY(jlong, JVM_ConstantPoolGetLongAt(JNIEnv *env, jobject unused, jobject jcpool, jint index))
+JVM_ENTRY(jlong, JVM_ConstantPoolGetLongAt(JNIEnv *env, jobject obj, jobject unused, jint index))
{
JVMWrapper("JVM_ConstantPoolGetLongAt");
- constantPoolHandle cp = constantPoolHandle(THREAD, constantPoolOop(JNIHandles::resolve_non_null(jcpool)));
+ constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
bounds_check(cp, index, CHECK_(0L));
constantTag tag = cp->tag_at(index);
if (!tag.is_long()) {
@@ -1977,10 +1975,10 @@
}
JVM_END
-JVM_ENTRY(jfloat, JVM_ConstantPoolGetFloatAt(JNIEnv *env, jobject unused, jobject jcpool, jint index))
+JVM_ENTRY(jfloat, JVM_ConstantPoolGetFloatAt(JNIEnv *env, jobject obj, jobject unused, jint index))
{
JVMWrapper("JVM_ConstantPoolGetFloatAt");
- constantPoolHandle cp = constantPoolHandle(THREAD, constantPoolOop(JNIHandles::resolve_non_null(jcpool)));
+ constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
bounds_check(cp, index, CHECK_(0.0f));
constantTag tag = cp->tag_at(index);
if (!tag.is_float()) {
@@ -1990,10 +1988,10 @@
}
JVM_END
-JVM_ENTRY(jdouble, JVM_ConstantPoolGetDoubleAt(JNIEnv *env, jobject unused, jobject jcpool, jint index))
+JVM_ENTRY(jdouble, JVM_ConstantPoolGetDoubleAt(JNIEnv *env, jobject obj, jobject unused, jint index))
{
JVMWrapper("JVM_ConstantPoolGetDoubleAt");
- constantPoolHandle cp = constantPoolHandle(THREAD, constantPoolOop(JNIHandles::resolve_non_null(jcpool)));
+ constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
bounds_check(cp, index, CHECK_(0.0));
constantTag tag = cp->tag_at(index);
if (!tag.is_double()) {
@@ -2003,13 +2001,13 @@
}
JVM_END
-JVM_ENTRY(jstring, JVM_ConstantPoolGetStringAt(JNIEnv *env, jobject unused, jobject jcpool, jint index))
+JVM_ENTRY(jstring, JVM_ConstantPoolGetStringAt(JNIEnv *env, jobject obj, jobject unused, jint index))
{
JVMWrapper("JVM_ConstantPoolGetStringAt");
- constantPoolHandle cp = constantPoolHandle(THREAD, constantPoolOop(JNIHandles::resolve_non_null(jcpool)));
+ constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
bounds_check(cp, index, CHECK_NULL);
constantTag tag = cp->tag_at(index);
- if (!tag.is_string() && !tag.is_unresolved_string()) {
+ if (!tag.is_string()) {
THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Wrong type at constant pool index");
}
oop str = cp->string_at(index, CHECK_NULL);
@@ -2017,11 +2015,11 @@
}
JVM_END
-JVM_ENTRY(jstring, JVM_ConstantPoolGetUTF8At(JNIEnv *env, jobject unused, jobject jcpool, jint index))
+JVM_ENTRY(jstring, JVM_ConstantPoolGetUTF8At(JNIEnv *env, jobject obj, jobject unused, jint index))
{
JVMWrapper("JVM_ConstantPoolGetUTF8At");
JvmtiVMObjectAllocEventCollector oam;
- constantPoolHandle cp = constantPoolHandle(THREAD, constantPoolOop(JNIHandles::resolve_non_null(jcpool)));
+ constantPoolHandle cp = constantPoolHandle(THREAD, sun_reflect_ConstantPool::get_cp(JNIHandles::resolve_non_null(obj)));
bounds_check(cp, index, CHECK_NULL);
constantTag tag = cp->tag_at(index);
if (!tag.is_symbol()) {
@@ -2044,7 +2042,7 @@
assert(! java_lang_Class::is_primitive(r), "primitive classes not allowed");
if (java_lang_Class::is_primitive(r)) return false;
- klassOop k = java_lang_Class::as_klassOop(r);
+ Klass* k = java_lang_Class::as_Klass(r);
assert(Klass::cast(k)->oop_is_instance(), "must be an instance klass");
if (! Klass::cast(k)->oop_is_instance()) return false;
@@ -2071,15 +2069,15 @@
// RedefineClasses support: bug 6214132 caused verification to fail.
// All functions from this section should call the jvmtiThreadSate function:
-// klassOop class_to_verify_considering_redefinition(klassOop klass).
-// The function returns a klassOop of the _scratch_class if the verifier
+// Klass* class_to_verify_considering_redefinition(Klass* klass).
+// The function returns a Klass* of the _scratch_class if the verifier
// was invoked in the middle of the class redefinition.
-// Otherwise it returns its argument value which is the _the_class klassOop.
+// Otherwise it returns its argument value which is the _the_class Klass*.
// Please, refer to the description in the jvmtiThreadSate.hpp.
JVM_ENTRY(const char*, JVM_GetClassNameUTF(JNIEnv *env, jclass cls))
JVMWrapper("JVM_GetClassNameUTF");
- klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls));
+ Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
return Klass::cast(k)->name()->as_utf8();
JVM_END
@@ -2087,16 +2085,15 @@
JVM_QUICK_ENTRY(void, JVM_GetClassCPTypes(JNIEnv *env, jclass cls, unsigned char *types))
JVMWrapper("JVM_GetClassCPTypes");
- klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls));
+ Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
- // types will have length zero if this is not an instanceKlass
+ // types will have length zero if this is not an InstanceKlass
// (length is determined by call to JVM_GetClassCPEntriesCount)
if (Klass::cast(k)->oop_is_instance()) {
- constantPoolOop cp = instanceKlass::cast(k)->constants();
+ ConstantPool* cp = InstanceKlass::cast(k)->constants();
for (int index = cp->length() - 1; index >= 0; index--) {
constantTag tag = cp->tag_at(index);
- types[index] = (tag.is_unresolved_klass()) ? JVM_CONSTANT_Class :
- (tag.is_unresolved_string()) ? JVM_CONSTANT_String : tag.value();
+ types[index] = (tag.is_unresolved_klass()) ? JVM_CONSTANT_Class : tag.value();
}
}
JVM_END
@@ -2104,47 +2101,47 @@
JVM_QUICK_ENTRY(jint, JVM_GetClassCPEntriesCount(JNIEnv *env, jclass cls))
JVMWrapper("JVM_GetClassCPEntriesCount");
- klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls));
+ Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
if (!Klass::cast(k)->oop_is_instance())
return 0;
- return instanceKlass::cast(k)->constants()->length();
+ return InstanceKlass::cast(k)->constants()->length();
JVM_END
JVM_QUICK_ENTRY(jint, JVM_GetClassFieldsCount(JNIEnv *env, jclass cls))
JVMWrapper("JVM_GetClassFieldsCount");
- klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls));
+ Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
if (!Klass::cast(k)->oop_is_instance())
return 0;
- return instanceKlass::cast(k)->java_fields_count();
+ return InstanceKlass::cast(k)->java_fields_count();
JVM_END
JVM_QUICK_ENTRY(jint, JVM_GetClassMethodsCount(JNIEnv *env, jclass cls))
JVMWrapper("JVM_GetClassMethodsCount");
- klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls));
+ Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
if (!Klass::cast(k)->oop_is_instance())
return 0;
- return instanceKlass::cast(k)->methods()->length();
+ return InstanceKlass::cast(k)->methods()->length();
JVM_END
// The following methods, used for the verifier, are never called with
-// array klasses, so a direct cast to instanceKlass is safe.
+// array klasses, so a direct cast to InstanceKlass is safe.
// Typically, these methods are called in a loop with bounds determined
// by the results of JVM_GetClass{Fields,Methods}Count, which return
// zero for arrays.
JVM_QUICK_ENTRY(void, JVM_GetMethodIxExceptionIndexes(JNIEnv *env, jclass cls, jint method_index, unsigned short *exceptions))
JVMWrapper("JVM_GetMethodIxExceptionIndexes");
- klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls));
+ Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
- oop method = instanceKlass::cast(k)->methods()->obj_at(method_index);
- int length = methodOop(method)->checked_exceptions_length();
+ Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
+ int length = method->checked_exceptions_length();
if (length > 0) {
- CheckedExceptionElement* table= methodOop(method)->checked_exceptions_start();
+ CheckedExceptionElement* table= method->checked_exceptions_start();
for (int i = 0; i < length; i++) {
exceptions[i] = table[i].class_cp_index;
}
@@ -2154,37 +2151,37 @@
JVM_QUICK_ENTRY(jint, JVM_GetMethodIxExceptionsCount(JNIEnv *env, jclass cls, jint method_index))
JVMWrapper("JVM_GetMethodIxExceptionsCount");
- klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls));
+ Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
- oop method = instanceKlass::cast(k)->methods()->obj_at(method_index);
- return methodOop(method)->checked_exceptions_length();
+ Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
+ return method->checked_exceptions_length();
JVM_END
JVM_QUICK_ENTRY(void, JVM_GetMethodIxByteCode(JNIEnv *env, jclass cls, jint method_index, unsigned char *code))
JVMWrapper("JVM_GetMethodIxByteCode");
- klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls));
+ Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
- oop method = instanceKlass::cast(k)->methods()->obj_at(method_index);
- memcpy(code, methodOop(method)->code_base(), methodOop(method)->code_size());
+ Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
+ memcpy(code, method->code_base(), method->code_size());
JVM_END
JVM_QUICK_ENTRY(jint, JVM_GetMethodIxByteCodeLength(JNIEnv *env, jclass cls, jint method_index))
JVMWrapper("JVM_GetMethodIxByteCodeLength");
- klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls));
+ Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
- oop method = instanceKlass::cast(k)->methods()->obj_at(method_index);
- return methodOop(method)->code_size();
+ Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
+ return method->code_size();
JVM_END
JVM_QUICK_ENTRY(void, JVM_GetMethodIxExceptionTableEntry(JNIEnv *env, jclass cls, jint method_index, jint entry_index, JVM_ExceptionTableEntryType *entry))
JVMWrapper("JVM_GetMethodIxExceptionTableEntry");
- klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls));
+ Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
- oop method = instanceKlass::cast(k)->methods()->obj_at(method_index);
- ExceptionTable extable((methodOop(method)));
+ Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
+ ExceptionTable extable(method);
entry->start_pc = extable.start_pc(entry_index);
entry->end_pc = extable.end_pc(entry_index);
entry->handler_pc = extable.handler_pc(entry_index);
@@ -2194,82 +2191,82 @@
JVM_QUICK_ENTRY(jint, JVM_GetMethodIxExceptionTableLength(JNIEnv *env, jclass cls, int method_index))
JVMWrapper("JVM_GetMethodIxExceptionTableLength");
- klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls));
+ Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
- oop method = instanceKlass::cast(k)->methods()->obj_at(method_index);
- return methodOop(method)->exception_table_length();
+ Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
+ return method->exception_table_length();
JVM_END
JVM_QUICK_ENTRY(jint, JVM_GetMethodIxModifiers(JNIEnv *env, jclass cls, int method_index))
JVMWrapper("JVM_GetMethodIxModifiers");
- klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls));
+ Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
- oop method = instanceKlass::cast(k)->methods()->obj_at(method_index);
- return methodOop(method)->access_flags().as_int() & JVM_RECOGNIZED_METHOD_MODIFIERS;
+ Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
+ return method->access_flags().as_int() & JVM_RECOGNIZED_METHOD_MODIFIERS;
JVM_END
JVM_QUICK_ENTRY(jint, JVM_GetFieldIxModifiers(JNIEnv *env, jclass cls, int field_index))
JVMWrapper("JVM_GetFieldIxModifiers");
- klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls));
+ Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
- return instanceKlass::cast(k)->field_access_flags(field_index) & JVM_RECOGNIZED_FIELD_MODIFIERS;
+ return InstanceKlass::cast(k)->field_access_flags(field_index) & JVM_RECOGNIZED_FIELD_MODIFIERS;
JVM_END
JVM_QUICK_ENTRY(jint, JVM_GetMethodIxLocalsCount(JNIEnv *env, jclass cls, int method_index))
JVMWrapper("JVM_GetMethodIxLocalsCount");
- klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls));
+ Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
- oop method = instanceKlass::cast(k)->methods()->obj_at(method_index);
- return methodOop(method)->max_locals();
+ Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
+ return method->max_locals();
JVM_END
JVM_QUICK_ENTRY(jint, JVM_GetMethodIxArgsSize(JNIEnv *env, jclass cls, int method_index))
JVMWrapper("JVM_GetMethodIxArgsSize");
- klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls));
+ Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
- oop method = instanceKlass::cast(k)->methods()->obj_at(method_index);
- return methodOop(method)->size_of_parameters();
+ Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
+ return method->size_of_parameters();
JVM_END
JVM_QUICK_ENTRY(jint, JVM_GetMethodIxMaxStack(JNIEnv *env, jclass cls, int method_index))
JVMWrapper("JVM_GetMethodIxMaxStack");
- klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls));
+ Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
- oop method = instanceKlass::cast(k)->methods()->obj_at(method_index);
- return methodOop(method)->verifier_max_stack();
+ Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
+ return method->verifier_max_stack();
JVM_END
JVM_QUICK_ENTRY(jboolean, JVM_IsConstructorIx(JNIEnv *env, jclass cls, int method_index))
JVMWrapper("JVM_IsConstructorIx");
ResourceMark rm(THREAD);
- klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls));
+ Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
- oop method = instanceKlass::cast(k)->methods()->obj_at(method_index);
- return methodOop(method)->name() == vmSymbols::object_initializer_name();
+ Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
+ return method->name() == vmSymbols::object_initializer_name();
JVM_END
JVM_ENTRY(const char*, JVM_GetMethodIxNameUTF(JNIEnv *env, jclass cls, jint method_index))
JVMWrapper("JVM_GetMethodIxIxUTF");
- klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls));
+ Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
- oop method = instanceKlass::cast(k)->methods()->obj_at(method_index);
- return methodOop(method)->name()->as_utf8();
+ Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
+ return method->name()->as_utf8();
JVM_END
JVM_ENTRY(const char*, JVM_GetMethodIxSignatureUTF(JNIEnv *env, jclass cls, jint method_index))
JVMWrapper("JVM_GetMethodIxSignatureUTF");
- klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls));
+ Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
- oop method = instanceKlass::cast(k)->methods()->obj_at(method_index);
- return methodOop(method)->signature()->as_utf8();
+ Method* method = InstanceKlass::cast(k)->methods()->at(method_index);
+ return method->signature()->as_utf8();
JVM_END
/**
@@ -2282,9 +2279,9 @@
*/
JVM_ENTRY(const char*, JVM_GetCPFieldNameUTF(JNIEnv *env, jclass cls, jint cp_index))
JVMWrapper("JVM_GetCPFieldNameUTF");
- klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls));
+ Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
- constantPoolOop cp = instanceKlass::cast(k)->constants();
+ ConstantPool* cp = InstanceKlass::cast(k)->constants();
switch (cp->tag_at(cp_index).value()) {
case JVM_CONSTANT_Fieldref:
return cp->uncached_name_ref_at(cp_index)->as_utf8();
@@ -2298,9 +2295,9 @@
JVM_ENTRY(const char*, JVM_GetCPMethodNameUTF(JNIEnv *env, jclass cls, jint cp_index))
JVMWrapper("JVM_GetCPMethodNameUTF");
- klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls));
+ Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
- constantPoolOop cp = instanceKlass::cast(k)->constants();
+ ConstantPool* cp = InstanceKlass::cast(k)->constants();
switch (cp->tag_at(cp_index).value()) {
case JVM_CONSTANT_InterfaceMethodref:
case JVM_CONSTANT_Methodref:
@@ -2316,9 +2313,9 @@
JVM_ENTRY(const char*, JVM_GetCPMethodSignatureUTF(JNIEnv *env, jclass cls, jint cp_index))
JVMWrapper("JVM_GetCPMethodSignatureUTF");
- klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls));
+ Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
- constantPoolOop cp = instanceKlass::cast(k)->constants();
+ ConstantPool* cp = InstanceKlass::cast(k)->constants();
switch (cp->tag_at(cp_index).value()) {
case JVM_CONSTANT_InterfaceMethodref:
case JVM_CONSTANT_Methodref:
@@ -2334,9 +2331,9 @@
JVM_ENTRY(const char*, JVM_GetCPFieldSignatureUTF(JNIEnv *env, jclass cls, jint cp_index))
JVMWrapper("JVM_GetCPFieldSignatureUTF");
- klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls));
+ Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
- constantPoolOop cp = instanceKlass::cast(k)->constants();
+ ConstantPool* cp = InstanceKlass::cast(k)->constants();
switch (cp->tag_at(cp_index).value()) {
case JVM_CONSTANT_Fieldref:
return cp->uncached_signature_ref_at(cp_index)->as_utf8();
@@ -2350,9 +2347,9 @@
JVM_ENTRY(const char*, JVM_GetCPClassNameUTF(JNIEnv *env, jclass cls, jint cp_index))
JVMWrapper("JVM_GetCPClassNameUTF");
- klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls));
+ Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
- constantPoolOop cp = instanceKlass::cast(k)->constants();
+ ConstantPool* cp = InstanceKlass::cast(k)->constants();
Symbol* classname = cp->klass_name_at(cp_index);
return classname->as_utf8();
JVM_END
@@ -2360,9 +2357,9 @@
JVM_ENTRY(const char*, JVM_GetCPFieldClassNameUTF(JNIEnv *env, jclass cls, jint cp_index))
JVMWrapper("JVM_GetCPFieldClassNameUTF");
- klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls));
+ Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
- constantPoolOop cp = instanceKlass::cast(k)->constants();
+ ConstantPool* cp = InstanceKlass::cast(k)->constants();
switch (cp->tag_at(cp_index).value()) {
case JVM_CONSTANT_Fieldref: {
int class_index = cp->uncached_klass_ref_index_at(cp_index);
@@ -2379,9 +2376,9 @@
JVM_ENTRY(const char*, JVM_GetCPMethodClassNameUTF(JNIEnv *env, jclass cls, jint cp_index))
JVMWrapper("JVM_GetCPMethodClassNameUTF");
- klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls));
+ Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
- constantPoolOop cp = instanceKlass::cast(k)->constants();
+ ConstantPool* cp = InstanceKlass::cast(k)->constants();
switch (cp->tag_at(cp_index).value()) {
case JVM_CONSTANT_Methodref:
case JVM_CONSTANT_InterfaceMethodref: {
@@ -2399,12 +2396,12 @@
JVM_ENTRY(jint, JVM_GetCPFieldModifiers(JNIEnv *env, jclass cls, int cp_index, jclass called_cls))
JVMWrapper("JVM_GetCPFieldModifiers");
- klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls));
- klassOop k_called = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(called_cls));
+ Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
+ Klass* k_called = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(called_cls));
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
k_called = JvmtiThreadState::class_to_verify_considering_redefinition(k_called, thread);
- constantPoolOop cp = instanceKlass::cast(k)->constants();
- constantPoolOop cp_called = instanceKlass::cast(k_called)->constants();
+ ConstantPool* cp = InstanceKlass::cast(k)->constants();
+ ConstantPool* cp_called = InstanceKlass::cast(k_called)->constants();
switch (cp->tag_at(cp_index).value()) {
case JVM_CONSTANT_Fieldref: {
Symbol* name = cp->uncached_name_ref_at(cp_index);
@@ -2426,20 +2423,20 @@
JVM_QUICK_ENTRY(jint, JVM_GetCPMethodModifiers(JNIEnv *env, jclass cls, int cp_index, jclass called_cls))
JVMWrapper("JVM_GetCPMethodModifiers");
- klassOop k = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(cls));
- klassOop k_called = java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(called_cls));
+ Klass* k = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(cls));
+ Klass* k_called = java_lang_Class::as_Klass(JNIHandles::resolve_non_null(called_cls));
k = JvmtiThreadState::class_to_verify_considering_redefinition(k, thread);
k_called = JvmtiThreadState::class_to_verify_considering_redefinition(k_called, thread);
- constantPoolOop cp = instanceKlass::cast(k)->constants();
+ ConstantPool* cp = InstanceKlass::cast(k)->constants();
switch (cp->tag_at(cp_index).value()) {
case JVM_CONSTANT_Methodref:
case JVM_CONSTANT_InterfaceMethodref: {
Symbol* name = cp->uncached_name_ref_at(cp_index);
Symbol* signature = cp->uncached_signature_ref_at(cp_index);
- objArrayOop methods = instanceKlass::cast(k_called)->methods();
+ Array<Method*>* methods = InstanceKlass::cast(k_called)->methods();
int methods_count = methods->length();
for (int i = 0; i < methods_count; i++) {
- methodOop method = methodOop(methods->obj_at(i));
+ Method* method = methods->at(i);
if (method->name() == name && method->signature() == signature) {
return method->access_flags().as_int() & JVM_RECOGNIZED_METHOD_MODIFIERS;
}
@@ -2465,8 +2462,8 @@
JVMWrapper("JVM_IsSameClassPackage");
oop class1_mirror = JNIHandles::resolve_non_null(class1);
oop class2_mirror = JNIHandles::resolve_non_null(class2);
- klassOop klass1 = java_lang_Class::as_klassOop(class1_mirror);
- klassOop klass2 = java_lang_Class::as_klassOop(class2_mirror);
+ Klass* klass1 = java_lang_Class::as_Klass(class1_mirror);
+ Klass* klass2 = java_lang_Class::as_Klass(class2_mirror);
return (jboolean) Reflection::is_same_class_package(klass1, klass2);
JVM_END
@@ -3049,10 +3046,10 @@
bool trusted = is_trusted_frame(thread, &vfst);
if (trusted) return NULL;
- methodOop m = vfst.method();
+ Method* m = vfst.method();
if (!m->is_native()) {
- klassOop holder = m->method_holder();
- oop loader = instanceKlass::cast(holder)->class_loader();
+ Klass* holder = m->method_holder();
+ oop loader = InstanceKlass::cast(holder)->class_loader();
if (loader != NULL && !java_lang_ClassLoader::is_trusted_loader(loader)) {
return (jclass) JNIHandles::make_local(env, Klass::cast(holder)->java_mirror());
}
@@ -3072,11 +3069,11 @@
bool trusted = is_trusted_frame(thread, &vfst);
if (trusted) return NULL;
- methodOop m = vfst.method();
+ Method* m = vfst.method();
if (!m->is_native()) {
- klassOop holder = m->method_holder();
+ Klass* holder = m->method_holder();
assert(holder->is_klass(), "just checking");
- oop loader = instanceKlass::cast(holder)->class_loader();
+ oop loader = InstanceKlass::cast(holder)->class_loader();
if (loader != NULL && !java_lang_ClassLoader::is_trusted_loader(loader)) {
return JNIHandles::make_local(env, loader);
}
@@ -3108,7 +3105,7 @@
for(vframeStream vfst(thread); !vfst.at_end(); vfst.security_get_caller_frame(1)) {
// Native frames are not returned
if (!vfst.method()->is_native()) {
- klassOop holder = vfst.method()->method_holder();
+ Klass* holder = vfst.method()->method_holder();
assert(holder->is_klass(), "just checking");
depth++;
KlassLink* l = new KlassLink(KlassHandle(thread, holder));
@@ -3151,9 +3148,9 @@
for(vframeStream vfst(thread); !vfst.at_end(); vfst.next()) {
if (!vfst.method()->is_native()) {
- klassOop holder = vfst.method()->method_holder();
+ Klass* holder = vfst.method()->method_holder();
assert(holder->is_klass(), "just checking");
- if (instanceKlass::cast(holder)->name() == class_name_sym) {
+ if (InstanceKlass::cast(holder)->name() == class_name_sym) {
return depth;
}
depth++;
@@ -3172,11 +3169,11 @@
bool trusted = is_trusted_frame(thread, &vfst);
if (trusted) return -1;
- methodOop m = vfst.method();
+ Method* m = vfst.method();
if (!m->is_native()) {
- klassOop holder = m->method_holder();
+ Klass* holder = m->method_holder();
assert(holder->is_klass(), "just checking");
- oop loader = instanceKlass::cast(holder)->class_loader();
+ oop loader = InstanceKlass::cast(holder)->class_loader();
if (loader != NULL && !java_lang_ClassLoader::is_trusted_loader(loader)) {
return depth;
}
@@ -3210,7 +3207,7 @@
// ObjectInputStream ///////////////////////////////////////////////////////////////
-bool force_verify_field_access(klassOop current_class, klassOop field_class, AccessFlags access, bool classloader_only) {
+bool force_verify_field_access(Klass* current_class, Klass* field_class, AccessFlags access, bool classloader_only) {
if (current_class == NULL) {
return true;
}
@@ -3225,7 +3222,7 @@
}
}
- return (!access.is_private() && instanceKlass::cast(current_class)->is_same_class_package(field_class));
+ return (!access.is_private() && InstanceKlass::cast(current_class)->is_same_class_package(field_class));
}
@@ -3244,14 +3241,14 @@
}
// Arrays not allowed here, must use JVM_AllocateNewArray
- if (Klass::cast(java_lang_Class::as_klassOop(curr_mirror))->oop_is_javaArray() ||
- Klass::cast(java_lang_Class::as_klassOop(init_mirror))->oop_is_javaArray()) {
+ if (Klass::cast(java_lang_Class::as_Klass(curr_mirror))->oop_is_array() ||
+ Klass::cast(java_lang_Class::as_Klass(init_mirror))->oop_is_array()) {
ResourceMark rm(THREAD);
THROW_0(vmSymbols::java_lang_InvalidClassException());
}
- instanceKlassHandle curr_klass (THREAD, java_lang_Class::as_klassOop(curr_mirror));
- instanceKlassHandle init_klass (THREAD, java_lang_Class::as_klassOop(init_mirror));
+ instanceKlassHandle curr_klass (THREAD, java_lang_Class::as_Klass(curr_mirror));
+ instanceKlassHandle init_klass (THREAD, java_lang_Class::as_Klass(init_mirror));
assert(curr_klass->is_subclass_of(init_klass()), "just checking");
@@ -3267,7 +3264,7 @@
if (m.is_null()) {
ResourceMark rm(THREAD);
THROW_MSG_0(vmSymbols::java_lang_NoSuchMethodError(),
- methodOopDesc::name_and_sig_as_C_string(Klass::cast(init_klass()),
+ Method::name_and_sig_as_C_string(Klass::cast(init_klass()),
vmSymbols::object_initializer_name(),
vmSymbols::void_method_signature()));
}
@@ -3300,15 +3297,15 @@
if (java_lang_Class::is_primitive(mirror)) {
THROW_0(vmSymbols::java_lang_InvalidClassException());
}
- klassOop k = java_lang_Class::as_klassOop(mirror);
+ Klass* k = java_lang_Class::as_Klass(mirror);
oop result;
- if (k->klass_part()->oop_is_typeArray()) {
+ if (k->oop_is_typeArray()) {
// typeArray
result = typeArrayKlass::cast(k)->allocate(length, CHECK_NULL);
- } else if (k->klass_part()->oop_is_objArray()) {
+ } else if (k->oop_is_objArray()) {
// objArray
- objArrayKlassHandle oak(THREAD, k);
+ objArrayKlass* oak = objArrayKlass::cast(k);
oak->initialize(CHECK_NULL); // make sure class is initialized (matches Classic VM behavior)
result = oak->allocate(length, CHECK_NULL);
} else {
@@ -3325,8 +3322,8 @@
for (vframeStream vfst(thread); !vfst.at_end(); vfst.next()) {
// UseNewReflection
vfst.skip_reflection_related_frames(); // Only needed for 1.4 reflection
- klassOop holder = vfst.method()->method_holder();
- oop loader = instanceKlass::cast(holder)->class_loader();
+ Klass* holder = vfst.method()->method_holder();
+ oop loader = InstanceKlass::cast(holder)->class_loader();
if (loader != NULL) {
return JNIHandles::make_local(env, loader);
}
@@ -3368,22 +3365,22 @@
!vfst.at_end() && loader == NULL;
vfst.next()) {
if (!vfst.method()->is_native()) {
- klassOop holder = vfst.method()->method_holder();
- loader = instanceKlass::cast(holder)->class_loader();
- protection_domain = instanceKlass::cast(holder)->protection_domain();
+ Klass* holder = vfst.method()->method_holder();
+ loader = InstanceKlass::cast(holder)->class_loader();
+ protection_domain = InstanceKlass::cast(holder)->protection_domain();
}
}
} else {
- klassOop curr_klass_oop = java_lang_Class::as_klassOop(curr_klass());
- loader = instanceKlass::cast(curr_klass_oop)->class_loader();
- protection_domain = instanceKlass::cast(curr_klass_oop)->protection_domain();
+ Klass* curr_klass_oop = java_lang_Class::as_Klass(curr_klass());
+ loader = InstanceKlass::cast(curr_klass_oop)->class_loader();
+ protection_domain = InstanceKlass::cast(curr_klass_oop)->protection_domain();
}
Handle h_loader(THREAD, loader);
Handle h_prot (THREAD, protection_domain);
jclass result = find_class_from_class_loader(env, name, true, h_loader, h_prot,
false, thread);
if (TraceClassResolution && result != NULL) {
- trace_class_resolution(java_lang_Class::as_klassOop(JNIHandles::resolve_non_null(result)));
+ trace_class_resolution(java_lang_Class::as_Klass(JNIHandles::resolve_non_null(result)));
}
return result;
JVM_END
@@ -3398,7 +3395,7 @@
THROW_0(vmSymbols::java_lang_NullPointerException());
}
oop a = JNIHandles::resolve_non_null(arr);
- if (!a->is_javaArray() || (type_array_only && !a->is_typeArray())) {
+ if (!a->is_array() || (type_array_only && !a->is_typeArray())) {
THROW_MSG_0(vmSymbols::java_lang_IllegalArgumentException(), "Argument is not an array");
}
return arrayOop(a);
@@ -4019,7 +4016,7 @@
// Security Note:
// The Java level wrapper will perform the necessary security check allowing
// us to pass the NULL as the initiating class loader.
- klassOop klass = SystemDictionary::resolve_or_fail(name, loader, protection_domain, throwError != 0, CHECK_NULL);
+ Klass* klass = SystemDictionary::resolve_or_fail(name, loader, protection_domain, throwError != 0, CHECK_NULL);
KlassHandle klass_handle(THREAD, klass);
// Check if we should initialize the class
@@ -4196,7 +4193,7 @@
}
// check if threads is not an array of objects of Thread class
- klassOop k = objArrayKlass::cast(ah->klass())->element_klass();
+ Klass* k = objArrayKlass::cast(ah->klass())->element_klass();
if (k != SystemDictionary::Thread_klass()) {
THROW_(vmSymbols::java_lang_IllegalArgumentException(), 0);
}
@@ -4248,7 +4245,7 @@
if (java_lang_Class::is_primitive(mirror())) {
return NULL;
}
- klassOop k = java_lang_Class::as_klassOop(mirror());
+ Klass* k = java_lang_Class::as_Klass(mirror());
if (!Klass::cast(k)->oop_is_instance()) {
return NULL;
}
@@ -4259,7 +4256,7 @@
}
objArrayOop dest_o = oopFactory::new_objArray(SystemDictionary::Object_klass(), 3, CHECK_NULL);
objArrayHandle dest(THREAD, dest_o);
- klassOop enc_k = ik_h->constants()->klass_at(encl_method_class_idx, CHECK_NULL);
+ Klass* enc_k = ik_h->constants()->klass_at(encl_method_class_idx, CHECK_NULL);
dest->obj_at_put(0, Klass::cast(enc_k)->java_mirror());
int encl_method_method_idx = ik_h->enclosing_method_method_index();
if (encl_method_method_idx != 0) {